Zähler 4bit mit synchroner Last und Freigabe und asynchronem Reset.

Question

Ich habe einen 4-Bit-Zähler aus D-Flip-Flops und Multiplexern. Es zählt bis 1111 und dann bis 0000. Mein Design ist strukturell. Obwohl ich nicht weiß, wie man die Freigabe und die Last synchron macht. Hier ist mein Versuch:

entity counter4Bit is 
    Port (clock : in STD_LOGIC; 
      reset : in STD_LOGIC; 
      load : in STD_LOGIC; 
      enable : in STD_LOGIC; 
      ud : in STD_LOGIC; 
      counterOut : out STD_LOGIC_VECTOR (3 downto 0)); 
end counter4Bit; 

architecture Behavioral of counter4Bit is 

Component MUX 
    Port (sel : in STD_LOGIC_VECTOR (1 downto 0); 
      a : in STD_LOGIC; 
      b : in STD_LOGIC; 
      c : in STD_LOGIC; 
      d : in STD_LOGIC; 
      f : out STD_LOGIC); 
end component; 

Component D_FlipFlop 
    Port (D : in STD_LOGIC; 
      Resetn : in STD_LOGIC; 
      Clock : in STD_LOGIC; 
      Q : out STD_LOGIC); 
end component; 

signal w: std_logic_vector(3 downto 0); 
signal h: std_logic_vector(3 downto 0); 
signal q0,q1,q2,q3 :std_logic; 
signal nq0,nq1,nq2,nq3 :std_logic; 

begin 

FF0 : D_FlipFlop 
    port map(D => w(0), 
       Resetn => reset, 
       Clock => clock, 
       Q => q0); 

FF1 : D_FlipFlop 
    port map(D => w(1), 
       Resetn => reset, 
       Clock => clock, 
       Q => q1); 

FF2 : D_FlipFlop 
    port map(D => w(2), 
       Resetn => reset, 
       Clock => clock, 
       Q => q2); 

FF3 : D_FlipFlop 
    port map(D => w(3), 
       Resetn => reset, 
       Clock => clock, 
       Q => q3); 

MUX0 : MUX 
    port map(sel(0) => h(0), 
       sel(1) => load, 
       a => q0, 
       b => nq0, 
       c => '1', 
       d => '1', 
       f => w(0)); 

MUX1 : MUX 
    port map(sel(0) => h(1), 
       sel(1) => load, 
       a => q1, 
       b => nq1, 
       c => '1', 
       d => '1', 
       f => w(1)); 

MUX2 : MUX 
    port map(sel(0) => h(2), 
       sel(1) => load, 
       a => q2, 
       b => nq2, 
       c => '0', 
       d => '0', 
       f => w(2)); 

MUX3 : MUX 
    port map(sel(0) => h(3), 
       sel(1) => load, 
       a => q3, 
       b => nq3, 
       c => '0', 
       d => '0', 
       f => w(3));      

h(0) <= (ud and enable) or (enable and (not ud)); 
nq0 <= not q0; 

h(1) <= (ud and enable and q0) or (enable and (not ud) and nq0) ; 
nq1 <= not q1; 

h(2) <= (ud and enable and q0 and q1) or (enable and (not ud) and nq1 and nq0); 
nq2 <= not q2; 

h(3) <= (ud and enable and q0 and q1 and q2) or (enable and (not ud) and nq1 and nq2 and nq0); 
nq3 <= not q3; 

counterOut(0) <= q0; 
counterOut(1) <= q1; 
counterOut(2) <= q2; 
counterOut(3) <= q3; 
end Behavioral; 

Answer 1

Ist das eine akademische Hausaufgaben oder so etwas? Falls nicht, wirf alle Flip-Flop-Instanzen und Muxes weg und schreibe einfach eine getaktete Prozedur. Etwas entlang der Linie:

signal count : integer range 0 to 15; 

process(clk, rst) 
    begin 
    if rst = '0' then 
     count <= 0;  
    elsif rising_edge(clk) then 
     if enable = '1' then 
     if load = '1' then 
      count <= <somevalue>; 
     elsif count < 15 then 
      count <= count + 1; 
     else 
      count <= 0; 
     end if;^ 
     else 
     count <= 0; 
    end if; 
end process; 

Answer 2

Weil Sie enthalten nicht die Einheit/Architektur Paare für für D_FlipFlop oder MUX ich dachte, ich mit einem Verfahren ersetzt für alle 4 FFs und gleichzeitige bedingte Signalzuweisungen zeigen würde Substitution für die Multiplexer.

Die Idee hier ist, zu demonstrieren, wie man bitbreite Vier-Eingang-Multiplexer verwendet, obwohl es einige Dinge gibt, die wir basierend auf dem Zählerwert als Ganzes beschreiben können.

Aktiviert und aufwärts gezählt stellt den FF-Eingängen einen Wert gleich dem Counterout + 1 dar, etwas, das wir als Inkrement bezeichnen, und das nur ein xor für jedes Element des Zählers und des Übertragsbaums benötigt.

Das Abwärtszählen zeigt ebenfalls einen Dekrementeingang.

Es stellt sich heraus, dass das LSB immer dann umschaltet, wenn es aktiviert ist, damit das LSB des Zählers einen LSB-Eingang ohne Zähler haben kann.

(Als Chipdesigner erinnerten wir uns an diese Dinge in einer früheren Zeit. Sie haben eine Lizenz für arithmetische Elemente (zB "+" oder "-" Operatoren) bezahlt. Eine Art "Du hast '0's? Way zurück, wenn wir '1' auf ihrer Seite lagen "Art der Erinnerung. In jedem Fall neigen Sie dazu, sich an die kurzen Schnitte erinnern, erhöhen und dekrementieren mit '0' Werte für den B-Eingang eines Addierers fällt die eine XOR und erfordert die nicht Werte.)

Die vier Eingänge der Multiplexer erfordern zwei Auswahleingänge. Sie können den Eingängen Funktionen willkürlich zuweisen und Werte auswählen. Zum Beispiel:

hold (no enable, no load) 00 
load      01 
enable and up    10 
enable and down   11 

Die Auswahlleitungen für das wären:

sel(1) <= enable and not load; -- overriding load 
sel(0) <= load or (not load and enable and ud); 

Wo Last Vorrang vor Zählung erfolgt. Die Sel-Eingänge werden für alle vier Multiplexer verwendet. Beachten Sie, dass für "10" und "11" Werte von sel Gleichungen werden auf dem folgenden Code des MUX0 kombiniert, kann man einen 4-Eingangs-Multiplexer und die Versorgung q (0) an beiden Eingänge verwenden:

library ieee; 
use ieee.std_logic_1164.all; 

entity counter4bit is -- updown counter sync load, enable, async reset 
    port ( 
     clock:  in std_logic; 
     reset:  in std_logic; 
     load:  in std_logic; 
     enable:  in std_logic; 
     ud:   in std_logic; -- assume up = '0', down = '1' 
     counterin: in std_logic_vector (3 downto 0); -- ADDED 
     counterout: out std_logic_vector (3 downto 0) 
    ); 
end entity counter4bit; 

architecture foo of counter4bit is 
    signal sel:  std_logic_vector (1 downto 0); -- mux selects 
    signal din:  std_logic_vector (3 downto 0); -- outputs of muxes to FFs 
    signal q:  std_logic_vector (3 downto 0); -- output of FFs 
    signal incr: std_logic_vector (3 downto 1); 
    signal decr: std_logic_vector (3 downto 1); 
begin 

FLIPFLOPS: -- abstract the structural FFs away, no MCVE provided. 
    process (reset, clock) 
    begin 
     if reset = '0' then -- resetn on FF component declaraiton 
      q <= (others => '0'); -- reset all FFs to '0' 
     elsif rising_edge(clock) then 
      q <= din; 
     end if; 
    end process; 

    -- Pick values of select for the conditions 
    -- hold (no enable, no load) 00 
    -- load      01 
    -- enable and up    10 
    -- enable and down   11 

    sel(1) <= enable and not load; -- overriding load 
    sel(0) <= load or (not load and enable and ud); 

    -- UP incrementer 

-- incr(0) <= not q(0); 
    incr(1) <= q(1) xor q(0); 
    incr(2) <= q(2) xor (q(0) and q(1)); 
    incr(3) <= q(3) xor (q(0) and q(1) and q(2)); 

    -- DOWN decrementer 

-- decr(0) <= not q(0); 
    decr(1) <= q(1) xor not q(0); 
    decr(2) <= q(2) xor (not q(0) and not q(1)); 
    decr(3) <= q(3) xor (not q(0) and not q(1) and not q(2)); 

-- no MCVE provided multiplexers either 

MUX0: 
    din(0) <= (q(0)   and not sel(1) and not sel(0)) or -- hold "00" 
       (counterin(0) and not sel(1) and  sel(0)) or -- load "01" 
      -- (incr(0)  and  sel(1) and not sel(0)) or -- up "10" 
      -- (decr(0)  and  sel(1) and  sel(0)); -- down "11" 
       (not q(0)  and  sel(1));     -- "10" | "11" 

       -- din(0) only requires a 3 input mux 

MUX1: 
    din(1) <= (q(1)   and not sel(1) and not sel(0)) or -- hold "00" 
       (counterin(1) and not sel(1) and  sel(0)) or -- load "01" 
       (incr(1)  and  sel(1) and not sel(0)) or -- up "10" 
       (decr(1)  and  sel(1) and  sel(0)); -- down "11" 

      -- din(1) through din(3) require 4 input muxes 

MUX2: 
    din(2) <= (q(2)   and not sel(1) and not sel(0)) or -- hold "00" 
       (counterin(2) and not sel(1) and  sel(0)) or -- load "01" 
       (incr(2)  and  sel(1) and not sel(0)) or -- up "10" 
       (decr(2)  and  sel(1) and  sel(0)); -- down "11" 

MUX3: 
    din(3) <= (q(3)   and not sel(1) and not sel(0)) or -- hold "00" 
       (counterin(3) and not sel(1) and  sel(0)) or -- load "01" 
       (incr(3)  and  sel(1) and not sel(0)) or -- up "10" 
       (decr(3)  and  sel(1) and  sel(0)); -- down "11"   
OUTPUT: 
    counterout <= q; 

end architecture; 

The other Eine Sache ist, dass es einen zusätzlichen Eingangsport gibt, um den Ladewert zu liefern, der willkürlich Counter genannt wird, um mit dem Counterout übereinzustimmen.

So ein quick and dirty Prüfstand das abstrahierte Modell zu trainieren:

library ieee; 
use ieee.std_logic_1164.all; 

entity counter4bit_tb is 
end entity; 

architecture foo of counter4bit_tb is 
    signal clock:  std_logic := '0'; 
    signal reset:  std_logic; -- '0' for reset 
    signal load:  std_logic; 
    signal enable:  std_logic; 
    signal ud:   std_logic; -- up = '0', down = '1' 
    signal counterin: std_logic_vector (3 downto 0); 
    signal counterout: std_logic_vector (3 downto 0); 
begin 
DUT: 
    entity work.counter4bit 
     port map (
      clock => clock, 
      reset => reset, 
      load => load, 
      enable => enable, 
      ud => ud, 
      counterin => counterin, 
      counterout => counterout 
     ); 
CLKGEN: 
    process 
    begin 
     wait for 5 ns; 
     clock <= not clock; 
     if now > 380 ns then 
      wait; 
     end if; 
    end process; 

STIMULIS: 
    process 
    begin 
     wait for 6 ns; 
     reset <= '0'; 
     load <= '0'; 
     enable <= '0'; 
     ud <= '0'; -- up 
     counterin <= (others => '1'); 
     wait for 20 ns; 
     reset <= '1'; 
     load <= '1'; 
     wait for 10 ns; 
     load <= '0'; 
     wait for 10 ns; 
     enable <= '1'; 
     wait for 160 ns; 
     ud <= '1'; -- down 
     wait for 160 ns; 
     enable <= '0'; 
     wait; 
    end process; 
end architecture; 

Und das gibt uns:

, die die Erhöhungs- und Verringerungs zeigt korrekt sind, sowie die Multiplexer-Eingänge.

Also hier ist eine Möglichkeit, die vier Input-Muxes zu organisieren, um Halt (kein Inkrement, kein Dekrementieren, kein Laden), Laden, Inkrementieren und Dekrementieren bereitzustellen. Sie könnten auch bemerken, dass es einen asynchronen Reset vorwegnimmt.