Machen Sie eine Up-Down-Zähler mit strukturellen Design

Question

Ich habe versucht, eine 4-Bit-Down-Zähler mit strukturellen Design gemacht. Mein Code ist folgende:

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

architecture Behavioral of counter4bit is 

component D_FlipFlop 
    Port (d : in STD_LOGIC; 
      reset : in STD_LOGIC; 
      clock : in STD_LOGIC; 
      load : in STD_LOGIC; 
      enable : in STD_LOGIC; 
      updown : in STD_LOGIC; 
      q : out STD_LOGIC); 
end component; 

component MUX 
    Port (i0 : in STD_LOGIC; 
      i1 : in STD_LOGIC; 
      i2 : in STD_LOGIC; 
      i3 : in STD_LOGIC; 
      inload : in STD_LOGIC; 
      bitout : out STD_LOGIC; 
      load : in STD_LOGIC; 
      updown : in STD_LOGIC; 
      en : in STD_LOGIC); 
end component; 

signal w: std_logic_vector(3 downto 0); 
signal cnt : std_logic_vector(3 downto 0); 

begin 

FF0 : D_FlipFlop 
    port map(d => w(0), 
       reset => reset, 
       clock =>clock, 
       load => load, 
       enable => enable, 
       updown => updown, 
       q => cnt(0)); 

FF1 : D_FlipFlop 
    port map(d => w(1), 
       reset => reset, 
       Clock => clock, 
       load => load, 
       enable => enable, 
       updown => updown, 
       q => cnt(1)); 

FF2 : D_FlipFlop 
    port map(d => w(2), 
       reset => reset, 
       clock => clock, 
       load => load, 
       enable => enable, 
       updown => updown, 
       q => cnt(2)); 

FF3 : D_FlipFlop 
    port map(d => w(3), 
       reset => reset, 
       clock => clock, 
       load => load, 
       enable => enable, 
       updown => updown, 
       q => cnt(3)); 

MUX0 : MUX 
    port map(i0 => '1', 
       i1 => '1', 
       i2 => '1', 
       i3 => cnt(0), 
       inload => '1', 
       bitout =>w(0) , 
       load => load, 
       updown => updown, 
       en => enable); 

MUX1 : MUX 
    port map(i0 => cnt(0), 
       i1 =>'1', 
       i2 => '1', 
       i3 => cnt(1), 
       inload => '1', 
       bitout =>w(1) , 
       load => load, 
       updown => updown, 
       en => enable); 

MUX2 : MUX 
    port map(i0 => cnt(0), 
       i1 => cnt(1), 
       i2 => '1', 
       i3 => cnt(2), 
       inload => '0', 
       bitout =>w(2) , 
       load => load, 
       updown => updown, 
       en => enable); 

MUX3 : MUX 
    port map(i0 => cnt(0), 
       i1 => cnt(1), 
       i2 =>cnt(2), 
       i3 => cnt(3), 
       inload => '0', 
       bitout =>w(3) , 
       load => load, 
       updown => updown, 
       en => enable); 

counterOut <= cnt ; 

end Behavioral; 

Wenn ich es simulieren es von 0 beginnt, wie es von dem Reset verursachen sollte, dann auf 1 zählt und dann wieder 0. Ich kann nicht sehen, warum es auf 0 geht zurück nach 1.

Hier ist mein Code für Mux:

entity MUX is 
    Port (i0 : in STD_LOGIC; 
      i1 : in STD_LOGIC; 
      i2 : in STD_LOGIC; 
      i3 : in STD_LOGIC; 
      inload : in STD_LOGIC; 
      bitout : out STD_LOGIC; 
      load : in STD_LOGIC; 
      updown : in STD_LOGIC; 
      en : in STD_LOGIC); 
end MUX; 

architecture Behavioral of MUX is 
signal sel : std_logic_vector(1 downto 0); 
signal y, z, x: std_logic; 
begin 

y <= (updown and i0 and i1 and i2 and en); 
z <= (not updown) and i0 and i1 and i2 and en; 

sel(0) <= not load; 
sel(1) <= y or z ; 

process(sel, x) 
    begin 
     if sel = "00" then x<= i3; 
     elsif sel = "01" then x <= (not i3); 
     else x <= inload; 
     end if; 
    end process; 
    bitout <= x ; 
end Behavioral; 

Und der Code für Flip Flop:

entity D_FlipFlop is 
    Port (d : in STD_LOGIC; 
      reset : in STD_LOGIC; 
      clock : in STD_LOGIC; 
      load : in STD_LOGIC; 
      enable : in STD_LOGIC; 
      updown : in STD_LOGIC; 
      q : out STD_LOGIC); 
end D_FlipFlop; 

architecture Behavioral of D_FlipFlop is 

begin 

process(clock, reset) 
begin 
    if (reset = '0') then 
     q <= '0'; 
    elsif (rising_edge(clock)) then 
     q <= d; 
    end if; 
end process; 

end Behavioral; 

Ich habe beachten das Laden und Aktivieren ist synchron, während das Zurücksetzen asynchron ist, ich werde auch ein Bild meiner Simulation anhängen.

Answer 1

Wenn ich es simuliere, beginnt es von 0, wie es vom Zurücksetzen verursachen sollte, zählt dann zu 1 und dann wieder 0. Ich kann nicht sehen, warum es nach 0 geht zurück 1.

ich gestern Prüfstand geändert Ihre Wellenform zu duplizieren:

musste ich ändern mit einer ‚0‘ zurückgesetzt ' 1 'und' 1 'bis' 0 'setzen von Delta-Zyklen, um einen Zählerout zu bekommen, der als alle' 0's erscheint.

Das erste, was zu bemerken ist, dass Sie die Polarität falsch eingestellt haben.

Fixing das gibt:

Und wir die Zählung nicht sehen können, richtig und noch Stände haben zu erhöhen.

Ohne in die Polarität der Last geht die ins Stocken geraten Werte durch die Empfindlichkeit Liste für den Prozess in MUX verursacht werden:

process(sel, x) 
    begin 
     if sel = "00" then x<= i3; 
     elsif sel = "01" then x <= (not i3); 
     else x <= inload; 
     end if; 
    end process; 
    bitout <= x ; 
end Behavioral; 

, die eine Empfindlichkeit Liste haben sollte:

process (sel, i3, inload) -- was (sel, x) -- incorrect sensitivity list 

Und das produziert:

, die immer noch einen Mangel an Schritten zeigt, aber eine Änderung bekommt.

Ändern der Belastungswert auf ‚0‘ in dem Prüfstand gibt uns die fehlenden Transaktionen auf counterout, aber die Werte sind immer noch falsch:

, die uns entweder Ihre Auswahl Gleichungen erzählt sind falsch oder Ihre Multiplexer-Eingänge sind falsch oder eine Kombination aus beidem.

In jedem Fall scheint MUX, wo Sie konzentrieren sollten.

So indem Sie in Ihren wählen Änderungen in MUX setzen Sie uns in den Kommentaren sagen gibt Ihnen einen korrekten Hochzählzeitgebers:

-- sel(0) <= not load; 
-- sel(1) <= y or z ; 
sel(1) <= (not load); -- per comments 
sel(0) <= y or z; 

Wir erhalten:

die die Hochzählzeitgebers zeigen korrekt aber nicht die Abwärtszählung. Beachten Sie, dass die Polarität der Last in den Auswahlmöglichkeiten geändert wurde und dass sie in der obigen Wellenform übereinstimmt.

Jetzt wissen wir, dass wir entweder sind angeblich cnt zu erhöhen oder verringern basierend auf updown und

y <= updown and i0 and i1 and i2 and en; 

Arbeiten für das Zählen auf, die

z <= not updown and i0 and i1 and i2 and en; 

Blätter, die leider den gleichen Wert verwendet auf i0, i1 und i2, um das Bitout (die Eingabe in das jeweilige D_FlipFlop für ein bestimmtes cnt-Element) umzuschalten.

Wir sind ziemlich sicher, dass z sein will:

z <= not updown and not i0 and not i1 and not i2 and en; 

für Erniedrigen (nicht Updown).

Wenn wir diese Änderung vornehmen, funktioniert die Zählung nicht. Was wir brauchen, sind die unbenutzten Eingänge zu den MUX's, um der richtige Wert für das Updown zu sein, die 1 für Up (wie jetzt) ​​oder "0" für Down.

Und wir können mit updown in counter4bit das tun:

MUX0 : MUX 
    port map(i0 => updown, -- '1' 
       i1 => updown, -- '1', 
       i2 => updown, -- '1', 
       i3 => cnt(0), 
       inload => '1', 
       bitout =>w(0) , 
       load => load, 
       updown => updown, 
       en => enable); 

MUX1 : MUX 
    port map(i0 => cnt(0), 
       i1 => updown, -- '1', 
       i2 => updown, -- '1', 
       i3 => cnt(1), 
       inload => '1', 
       bitout =>w(1) , 
       load => load, 
       updown => updown, 
       en => enable); 

MUX2 : MUX 
    port map(i0 => cnt(0), 
       i1 => cnt(1), 
       i2 => updown, -- '1', 
       i3 => cnt(2), 
       inload => '0', 
       bitout =>w(2) , 
       load => load, 
       updown => updown, 
       en => enable); 

Und das gibt uns:

Hinweis diese Wellenform noch nicht Prüflast oder aktivieren (false), aber es zählt hoch und dann wieder runter.

Es gibt auch einige unbenutzte Ports auf dem D_FlipFlop (laden, aktivieren, herunterfahren).