Neustart - vhdl

[Fandango (Gast)]

Hallo!

Ich hatte schon einmal damit begonnen, mein Elektronik Hobby auf 
programmierbare Logik zu erweitern.... einige Monate konnte ich jetzt 
aber so gut wie gar nichts in der Richtung machen und nun habe ich 
endlich die Zeit, noch einmal einen Anlauf zu beginnen.
Daher habe ich mir noch einmal den Klassiker des Hello World vorgenommen 
- die 7-Segment Anzeige. Dabei habe ich jetzt mal versucht z.B. ein 
component zu verwenden. Nicht weil es wohl nötig ist, sondern einfach um 
es zu üben.
Da ich keine Hardware besitze und nur Simulieren kann, hab ich als bcd 
Werte eine willkürliche rom Tabelle gemacht. Aber dennoch ist die Nibble 
Ausgabe versetzt - x"12" z.B.
Stelle 0 -> ansel "10" ist ok,
            nibble "0001" schon daneben das ist ja das hohe Nibble

2 Fragen habe ich aber und bitte um Unterstützung. (im code als 
Kommentar)

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;
entity bcd_seg is
    Port ( data_in : in  STD_LOGIC_VECTOR(3 downto 0);
           anodes  : out STD_LOGIC_VECTOR (6 downto 0));
end bcd_seg;

architecture Behavioral of bcd_seg is
type MY_ROM is array (0 to 15) of STD_LOGIC_VECTOR(6 downto 0);
constant BCD_ROM : MY_ROM := ("0000000","0000001","0000010","0000100",
                     "0100000","0000001","0100010","0100100",
                     "1000000","1000001","0100010","0100100",
                     "1100000","1100001","1100010","1100100");
begin
  process (data_in) begin 
    anodes <= BCD_ROM(to_integer(unsigned(data_in)));
  end process;

end Behavioral;



library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;
entity bcd_mux is
  Generic( NIBBLES : integer := 2;
        F_MUX   : integer := 10000000);
  Port( clk   : in  STD_LOGIC;
      data  : in  STD_LOGIC_VECTOR (NIBBLES*4-1 downto 0);
      ansel : out STD_LOGIC_VECTOR (NIBBLES-1 downto 0) := (others=>'0');
      anodes: out STD_LOGIC_VECTOR (6 downto 0) := (others=>'0'));
end bcd_mux;

architecture Behavioral of bcd_mux is
signal s_clkdiv : integer range 0 to 50000000/F_MUX := 0;
signal s_stelle : integer range 0 to NIBBLES-1 := 0;
signal s_nibble : STD_LOGIC_VECTOR(3 downto 0):="0000";
component bcd_seg
    Port (data_in : in  STD_LOGIC_VECTOR(3 downto 0);
           anodes  : out STD_LOGIC_VECTOR (6 downto 0));
end component;
begin

stellen_multiplexen : process begin
    wait until rising_edge(clk);
    if(s_clkdiv < 50000000/F_MUX) then
      s_clkdiv <= s_clkdiv + 1;
    else
      s_clkdiv <= 0;
    --Ich weiß, Signale nehmen ihren neuen Zustand erst am Ende des Prozesses an. Jedenfalls
    --habe ich das so aufgenommen, aber mehr als eine Phrase ist das irgendwie nicht für mich.
    --Ist das 
    --a) die Ursache dafür, daß ich die falschen Nibble zum ansel bekomme und
    --b) wie schreibe ich es richtig, wie verstehe ich meinen Fehler. Also nicht einfach durch passend machen der Offsets in den Vektor trial and error lässt mich ja beim nächsten mal wieder alt aussehen :-(
--die Testbench gibt x"12" und dann x"a1" aus.

      s_nibble <= data( (s_stelle*4+3) downto (s_stelle*4));  
      if(s_stelle < (NIBBLES-1)) then 
        s_stelle <= s_stelle + 1;
      else
        s_stelle <= 0;            
      end if;  
    end if;
  end process stellen_multiplexen;
  
die_anzeige: bcd_seg port map ( s_nibble, anodes );
  
stelle_auswählen:  process (s_stelle) begin
  --Für Anfänger wird immer gesagt, es sei alle Taktsynchron zu machen - 
  --betrifft das hier das multiplexen der Anzeigestellen auch???
  --s_stelle ändert sich doch nur im Takt oben.
  --und -sei das mal etwas gewichtigeres als eine Anzeige auszuwählen, also
  --ein umfangreicherer Prozess: pauschal am Anfang ein wait, oder wann nicht?
  --if(rising_edge(clk)) then
  ansel <= (others=>'1');
  ansel(s_stelle) <= '0';
  --end if;
  end process stelle_auswählen;
  
end Behavioral;

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

In diesem Prozess wird noch die "alte" s_stelle verwendet:

      s_nibble <= data( (s_stelle*4+3) downto (s_stelle*4));  
      if(s_stelle < (NIBBLES-1)) then 
        s_stelle <= s_stelle + 1;
      else
        s_stelle <= 0;            
      end if;

hier aber sofort die "neue"

  ansel(s_stelle) <= '0';

Das Problem heißt Latency, weil s_nibble quasi später kommt...

Es bringt jetzt aber rein gar nichts, den Prozess so umzubauen:

      if(s_stelle < (NIBBLES-1)) then 
        s_stelle <= s_stelle + 1;
      else
        s_stelle <= 0;            
      end if;  
      s_nibble <= data( (s_stelle*4+3) downto (s_stelle*4));

Weil auch in dieser letzten Zeile noch der alte Wert von s_stelle 
verwendet wird.
Das ist gemeint mit der Signalzuweisung erst am Edne des Prozesses. Alle 
Berechnungen mit Signalen verwenden den "alten" Signalwert und berechnen 
daraus einen "neuen" Wert, der dann am Ende dem Signal zugewiesen 
wird.
Du machst das hier doch auch so:

stelle_auswählen:  process (s_stelle) begin
  ansel <= (others=>'1');
  ansel(s_stelle) <= '0'; -- die letzte Zuweisung an ein Signal gewinnt
end process stelle_auswählen;

Zurück zu deinem Problem. Machs mal so:

:
      if(s_stelle < (NIBBLES-1)) then 
        s_stelle <= s_stelle + 1;
      else
        s_stelle <= 0;            
      end if;  
    end if;
  end process stellen_multiplexen;

  s_nibble <= data( (s_stelle*4+3) downto (s_stelle*4));  

stelle_auswählen:  process (s_stelle) begin
:

>  pauschal am Anfang ein wait,
Nein.
Ein wait until bringt dir zwingend Speicherelemente aka Fliflops ins 
Design. Und damit einen Takt Verzögerung aka. Latency auf das Signal...

> oder wann nicht?
Ein synchrones Design ist erst mal ein Design, das nur einen Takt hat, 
und bei dem externe signale einsynchronisiert sind. Ob da ein wait im 
Prozess auftaucht, bestimmt lediglich, ob ein Speicherelement nötig ist, 
oder nicht.

[Fandango (Gast)]

Vielen Dank!
Ich glaube das hilft mir schon mal als Denkhilfe am Wochenende. Weitere 
Ideen ein langsameres Hirn auf Touren zu bringen sind mir natürlich sehr 
willkommen.

Ich lasse in Ruhe den Post sacken und wünsche erst mal ein schönes 
Wochenende.