VHDL: case-Anwendung ohne clk

[vhdl_quest (Gast)]

Hallo kurze Verständnisfrage eines Anfängers:

Ich habe hier einen VHDL-code mit case-Anweisung. Diese Caseanweisung 
hat in der empfindlichkeitsliste aber nicht den Masterclk, also nicht in 
dem Sinne "if rising edge(clk)" oder so.

SET_NS : process (cs, m_count, n_count, we)
begin -- process SET_NS
  ns <= cs;
  case cs is
    when x1 =>
      ns <= y1;
    when x2 =>
      if m_count = (HIGHTIME-1) and n_count = X"0F" then
        ns <= y2;
      end if;
    when x3 =>
      if m_count = HIGHTIME and n_count = X"1F" then
        ns <= y3;
      end if;
    when x4 =>
      if m_count = (HIGHTIME-1) and n_count = X"2F" then
        ns <= y4;
      end if;
    when x5 =>  
      ns <= y5;
    when x6 =>
      if we = '1' then
        ns <= y6;
      end if;
       -- do nothing. Stay here.
    when others =>
      ns <= y7;
    end case;
end process SET_NS;

wie bzw. wann wird denn nun so eine case-Anweisung abgearbeitet, wenn 
sie nicht von clk abhängig ist?

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

vhdl_quest schrieb:
> wann wird denn nun so eine case-Anweisung abgearbeitet
Zuallererst: "abgearbeitet" wird da gar nichts!!!
Der Prozess wird vom Simulator wie üblich neu berechnet, wenn sich 
ein Signal der Sensitivliste des Prozesses ändert. Und deshalb müssen da 
alle Signale y1..y7 noch mit rein!

Dem Synthesizer ist das schnurzegal, der erweitert die Liste einfach für 
sich selber.

Und dann passen Simulation und Realität nicht mehr zusammen. Böse 
Sache...

[vhdl_quest (Gast)]

Lothar Miller schrieb:
> Und deshalb müssen da
> alle Signale y1..y7 noch mit rein!

was meinst du damit? y1-y7 mit in die Empfindlichkeitsliste?

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

vhdl_quest schrieb:
> y1-y7 mit in die Empfindlichkeitsliste?
Wenn sich y1 ändert, dann kann sich ns ändern...

Aber ich sehe gerade, das ist vermutlich gar kein Signal, sondern der 
Wert eines Typs. Der muss natürlich nicht rein...

Mich hat nur verwirrt, dass ns einen anderen Typ hat als cs. Auf jeden 
Fall haben die beiden andere Werte...


Also:
> y1-y7 mit in die Empfindlichkeitsliste?
Vermutlich nein. Man kann das an diesem Codeausschnitt aber nicht sicher 
erkennen...  ;-)

[vhdl_quest (Gast)]

es fehlen vermutlich folgende Codezeilen um ihn eindeutig zu deuten:

type STATE_TYPE is (y1, y2, y3, y4, y5, y6, y7);
  signal cs : STATE_TYPE := y1;
  signal ns : STATE_TYPE := y1;

da cs in der Empfindlichkeitsliste vorhanden ist, sind auch y1-y7 
vorhanden, denke ich mal ;)

Ich verstehe deine Antwort nun so, das die case-Anweisung quasi immer 
"aktiv" ist und immer dann aktualisiert wird, sobald ns innerhalb des 
Moduls seinen Status ändert. Korrekt?!

Danke!

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

vhdl_quest schrieb:
> fehlen vermutlich folgende Codezeilen um ihn eindeutig zu deuten: ...
Ich hatte mit den offensichtlich unterschiedlichen Typen Probleme:

  case cs is
    when x1 =>    --    x1
      ns <= y1;   --    y1

> Ich verstehe deine Antwort nun so, das die case-Anweisung quasi immer
> "aktiv" ist und immer dann aktualisiert wird, sobald ns innerhalb des
> Moduls seinen Status ändert. Korrekt?!
Sie ist nicht "aktiv" sie ist "da". Richtig in Hardware. Und was da ist, 
ist automatisch aktiv. Nur im Simulator muss mit der Sensitivliste eine 
Neuberechnung ausgelöst werden.

[high_speed (Gast)]

In Software werden die einzelnen Befehle sequenziell abgearbeitet.
In einer Hardwareschaltung ist dass ganz anders, dort arbeiten alle
Schaltungsteile andauernd, je nach anliegenden Eingangsbedingungen und
interne Zuständen ändert sich der Ausgang. (Flankengesteuerte Baugruppen 
mit eingeschlossen)
Bei der Synthese wird aus der sequenziellen Beschreibung ein 
Hardwaremodell
generiert, welches das gleiche Verhalten aufweist wie es die VHDL
Beschreibung beschreibt.

Bei einer Schaltung fragt man nicht nach dem Abarbeitungszeitpunkt, 
sondern
nach den Bedingungen, bei denen sich das Ausgangssignal ändern kann.


MfG
Holger

[tomb (Gast)]

vhdl_quest schrieb:
> Diese Caseanweisung
> hat in der empfindlichkeitsliste aber nicht den Masterclk, also nicht in
> dem Sinne "if rising edge(clk)" oder so.


Vielleicht mal etwas grundlegender: Kennst du den Unterschied zwischen 
kombinatorischer und sequentieller Logik?

Wenn man VHDL2008 verwendet empfiehlt sich vor allem für Anfänger die 
Verwendung von process(all), damit man nicht in irgendeine falsche 
Denkweise verfällt.
Hab schon Leute getroffen die haben den Code tatsächlich wie Software 
gelesen und mittels der Sensitivity-List den Ablauf gesteuert.

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

tomb schrieb:
> Hab schon Leute getroffen die haben den Code tatsächlich wie Software
> gelesen und mittels der Sensitivity-List den Ablauf gesteuert.
Ja, sowas gibts. Die schreiben auch ein

   wait for 20 us;

mitten in den Code...

[vhdl_quest (Gast)]

Hallo, erst einmal Danke für die hilfreichen RE's.

Mir ist schon klar, das es einen grundlegenden Unterschied zwischen C++ 
(seq.) und VHDL (comb.) gibt. Allerdings habe ich den Schalter noch 
nicht wirklich im Kopf umlegen können :) Viele Dinge sind mir immer noch 
unverständlich...

Zurück zu meiner Frage. Ich poste  den Code nun noch einmal 
vollständiger (ich hatte ihn u.a. auch fehlerhaft gepostet) und versuche 
auf den Punkt zu kommen um den es mir eigentlich geht:

entity Test is
port (
    clk : in std_logic;
    sclk : out std_logic;
    we : in std_logic);
end Test;

architecture rtl of Test is

type STATE_TYPE is (y1, y2, y3, y4, y5, y6);
signal cs : STATE_TYPE := y1;
signal ns : STATE_TYPE := y1;
signal m_count : std_logic_vector(7 downto 0) := (others => '0');

.
.
.

DO_SCLK : process (clk)
begin -- process DO_SCLK
if rising_edge(clk) then -- rising clock edge
    if cs = y6 or cs = y1 or cs = y4 then
      m_count <= (others => '0');
      sclk <= '1';
    else
      .
      .
      .
    end if;
end if;


SET_CS : process (clk)
begin -- process SET_CS
if rising_edge(clk) then -- rising clock edge
   cs <= ns;
end if;
end process SET_CS;


SET_NS : process (cs, m_count, n_count, we)
begin -- process SET_NS
  ns <= cs;
  case cs is
    when y1 =>
      ns <= y2;
    when y2 =>
      if m_count = (HIGHTIME-1) and n_count = X"0F" then
        ns <= y3;
      end if;
    when y3 =>
      if m_count = HIGHTIME and n_count = X"1F" then
        ns <= y4;
      end if;
    when y4 =>
      if m_count = (HIGHTIME-1) and n_count = X"2F" then
        ns <= y5;
      end if;
    when y5 =>
      --if sclk_count = HIGHTIME and bit_count = X"30" then
      ns <= y6;
      --end if;
    when y6 =>
      if we = '1' then
        ns <= y5;
      end if;
       -- do nothing. Stay here.
    when others =>
      ns <= y1;
    end case;
end process SET_NS;

Mir geht es nun um DO_SCLK!

-> cs ist also ab Start mit y1 geladen, d.h. die Anweisung

if rising_edge(clk) then -- rising clock edge
    if cs = y6 or cs = y1 or cs = y4 then
      m_count <= (others => '0');
      sclk <= '1';

ist erfüllt und sclk wird auf "1" gesetzt, sofern clk eine steigende 
Flanke besitzt.

Allerdings wird ja (in SET_NS) "gleichzeitig" (?!) wenn ns=cs=y1 ist, 
ns=cs=y2 gesetzt:

when y1 =>
   ns <= y2;

Simuliere ich nun das ganze mit Modelsim, sieht das ganze so aus wie im 
Screenshot (Anhang).


Was ich nun absolut nicht verstehe ist, wie in DO_SCLK jemals die 
Bedingung

if rising_edge(clk) then -- rising clock edge
    if cs = y6 or cs = y1 or cs = y4 then
      m_count <= (others => '0');
      sclk <= '1';

erfüllt sein kann?! Wenn ich mir die Signale in Modelsim angucke, hat cs 
bei der ersten steigenden Flanke den Status "y2" => Bedingung ist aber 
y6 oder y1 oder y4 für sclk<='1'. Trotzdem wird sclk zu "1". Wie kann 
das sein?

Das sind diese Feinheiten die mir extrem schwer fallen zu kapieren :)

Hoffe ich habe halbwegs rübergebracht, was ich nicht verstehe...

THX for RE

[tomb (Gast)]

vhdl_quest schrieb:
> Mir ist schon klar, das es einen grundlegenden Unterschied zwischen C++
> (seq.) und VHDL (comb.) gibt.

Sorry, dass ich mir jetzt nicht alles durchgelesen habe, aber 
sequentielle und kombinatorische Logik gibt es in Hardware und damit 
auch in Hardwarebeschreibungssprachen.

Sequentielle Logik ist ein getakteter process. Kombinatorische Logik 
wäre dein Bsp mit dem Case ohne Clock. Für eine saubere Schreibweise 
würde ich da auch eine strikte Trennung (2 Prozess-Schreibeweise mit 
Present- und Next-State) vorschlagen. Aber hier gehen die Meinungen 
auseinander.

[tomb (Gast)]

Dazu auch noch eine nützliche Naming-Convention die dem realen 
Signalverlauf nachempfunden ist und damit auch förderlich für das 
Verständnis ist:

http://www.dz.ee.ethz.ch/en/information/hdl-help/vhdl-naming-conventions.html

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

vhdl_quest schrieb:
> Wenn ich mir die Signale in Modelsim angucke, hat cs
> bei der ersten steigenden Flanke den Status "y2" => Bedingung ist aber
> y6 oder y1 oder y4 für sclk<='1'. Trotzdem wird sclk zu "1". Wie kann
> das sein?
Der Trick ist, dass immer der Wert gilt, der bei (bzw. kurz vor) der 
steigenden Flanke am flipflop anliegt.
Im richtigen Leben ist nach einem Takt erst mal Hektik, bis alle Signale 
durch alle Kombinatorik durchmarschiert sind und sich ein neuer Wert 
stabilisiert hat. Nur im (Verhaltens-)Simulator ändern sich die Werte 
sofort nach einer steigenden Flanke, weil dort keine 
Verzögerungszeiten existieren...

> Trotzdem wird sclk zu "1". Wie kann das sein?
sclk wird also 1, weil vor dem letzten Takt alles gepasst hat.

Und nicht vergessen: nach dem Takt ist vor dem Takt... ;-)

tomb schrieb:
> Sequentielle Logik ist ein getakteter process. Kombinatorische Logik
> wäre dein Bsp mit dem Case ohne Clock.
Hier sind jetzt m.E. zwei Abstraktionsebenen zusammengemischt. Direkt 
auf dem FPGA gibt es nur Logik (=Kombinatorik) und Flipflops 
(=Speicher für Sequenzen/Schritte).

Ich kann mir unter "sequentieller Logik" echt nichts vorstellen...
Ist das Logik, die zwischen 2 FFs platziert wurde?

[tomb (Gast)]

vhdl_quest schrieb:
> erfüllt sein kann?! Wenn ich mir die Signale in Modelsim angucke, hat cs
> bei der ersten steigenden Flanke den Status "y2" => Bedingung ist aber
> y6 oder y1 oder y4 für sclk<='1'. Trotzdem wird sclk zu "1". Wie kann
> das sein?

Dazu musst du wissen wie ein flankengesteuerte Flipflop funktioniert 
(soetwas ist sclk).
Prinzipiell kann man sich das aus zwei Latches vorstellen. Ein 
Master-Latch welches bei Low-Level transparent ist und ein Slave-Latch 
welches bei High-Level transparent ist.
Der Wert am Eingang wird als bei einem Low Level der Clock in das 
Master-FF übernommen und erst bei einem High Level an das Slave-FF 
weitergegeben. So ensteht das taktflankensensitive Verhalten. Daraus 
folgt aber auch, das zur Rising-Edge der Wert übernommen wird vorher 
schon anlag.

Bevor man mit HDL anfängt sollte man sich ohnehin erstmal einige 
Grundschaltungen der Elektronik ansehen.

[tomb (Gast)]

Lothar Miller schrieb:
> Ich kann mir unter "sequentieller Logik" echt nichts vorstellen...
> Ist das Logik, die zwischen 2 FFs platziert wurde?

Nein, zwischen zwei FF ist kombinatorische Logik. Sequentielle Logik ist 
getaktete Logik, also zb D-Flipflops.
Natürlich lässt sich sequentielle Logik auch wieder in kombinatorische 
zerlegen.

[tomb (Gast)]

tomb schrieb:
> Der Wert am Eingang wird als bei einem Low Level der Clock in das
> Master-FF übernommen und erst bei einem High Level an das Slave-FF
> weitergegeben.

Hier sollte besser Master- und Slave-Latch stehen, obwohl es auch 
Level-sensitive FFs gibt.

[vhdl_quest (Gast)]

@Miller und tomb:

Danke ich glaube ich habe es kapiert :) Das ganze jetzt nochmal im Kopf 
durchgehen und sacken lassen...

[Duke Scarring (Gast)]

Lothar Miller schrieb:
> Ich kann mir unter "sequentieller Logik" echt nichts vorstellen...
> Ist das Logik, die zwischen 2 FFs platziert wurde?
Nein. Umgekehrt: Logik, wo zwischendrin ein FF klemmt ;-)

Duke

[tomb (Gast)]

Duke Scarring schrieb:
> Lothar Miller schrieb:
>> Ich kann mir unter "sequentieller Logik" echt nichts vorstellen...
>> Ist das Logik, die zwischen 2 FFs platziert wurde?
> Nein. Umgekehrt: Logik, wo zwischendrin ein FF klemmt ;-)
>
> Duke

Noch ein wenig anders ausgedrückt. Sequentielle Logik ist Kombinatorik 
mit Rückkopplung.

Das wissen nämlich auch manche nicht, dass Latches und in weiterer Folge 
FFs nur kombinatorische Schleifen sind.

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

tomb schrieb:
> Das wissen nämlich auch manche nicht, dass Latches und in weiterer Folge
> FFs nur kombinatorische Schleifen sind.
Wobei beim D-FF niemals eine richtige Schleife zustandekommt, weil es 
keine direkte Mitkopplung gibt, sondern die Schleife immer im FF 
aufgebrochen wird. Da sieht man das recht schön:
http://www.scienceblogs.de/von_bits_und_bytes/2011/07/wie-rechner-rechnen-teil-4.php


BTW: Ist nicht die Ganze Welt eine Schleife?
Dreht sich nicht alles irgendwie um sich selbst?

[tomb (Gast)]

Lothar Miller schrieb:
> Wobei beim D-FF niemals eine richtige Schleife zustandekommt, weil es
> keine direkte Mitkopplung gibt, sondern die Schleife immer im FF
> aufgebrochen wird. Da sieht man das recht schön:
> http://www.scienceblogs.de/von_bits_und_bytes/2011...

Im Inneren schon. Indem Fall durch das RS-FF am Ende.
Man kann es aber auch wie schon erwähnt einfach durch zwei Latches 
modellieren, dann hat man die Loop durch die Latches. Die Rückkopplung 
ist halt notwendig zur Speicherung.

> BTW: Ist nicht die Ganze Welt eine Schleife?
> Dreht sich nicht alles irgendwie um sich selbst?

Klar alles nur ein Frage der Sichtweise :)

[tomb (Gast)]

Wenn es jemanden interessiert, so werden Latches und FFs wirklich in 
Hardware umgesetzt.

Latch: 
http://tams-www.informatik.uni-hamburg.de/applets/hades/webdemos/05-switched/40-cmos/latch2_print.html

FF: 
http://tams-www.informatik.uni-hamburg.de/applets/hades/webdemos/05-switched/40-cmos/dff2_print.html

Man sieht schön, dass ein D-FF einfach nur aus zwei Latches mit 
unterschiedlicher Pegelsensititvät besteht.

Wichtig sind auch die Bufferstufen bei der Rückkopplung. Ansosnten ist 
ein D-Latch einfach nur ein rückgekoppelter 2:1-MUX. Mit 
Transmissionsgattern geht das halt effizienter als mit Logischen 
Gattern.