Parallel oder sequenziell

[VHDL Anfänger (Gast)]

Hallo zusammen

...
TestProc: process (state, sck)

variable EdgCnt : integer := 0;

begin
.....
if (sck'event and (event='1') then
 SDO <= Data(EdgCnt);
 EdgCnt := EdgCnt +1;
end if;
.....

end process;

Nach dem was in den Bücher gelesen habe, läuft die Bearbeitung im 
Process sequenziell. D.h das was in der "if" Anweisung doch auch: also 
es wird zuerst Data(edgCnt) ausgegeben dann EdgCnt incrementiert?

Stimmt das oder habe ich es doch falsch verstanden?(oder denke ich 
wieder in Software!!)

Vielen Dank für Erklärung

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

VHDL Anfänger schrieb im Beitrag #2666671:
> D.h das was in der "if" Anweisung doch auch: also
> es wird zuerst Data(edgCnt) ausgegeben dann EdgCnt incrementiert?
Das wird nach der fehlerkorrektur von
> (sck'event and (event='1')
im FPGA einfach gleichzeitig passieren, weil beide/alle Flipflops mit 
dem selben Takt angeseuert werden. Nur der Simulator, der arme Knabe 
muss die einzelnen Schritte nacheinander rechnen, deshalb sieht das da 
sequentiell aus.

> Stimmt das oder habe ich es doch falsch verstanden? (oder denke ich
> wieder in Software!!)
Ja, ja, und ja.

Das Problem liegt da:
> Nach dem was in den Bücher gelesen habe
Diese Anweisungen sind concurrent/gleichzeitig, und es ist klar, was in 
der Hardware daraus gemacht wird:

architecture Behavioral of irgendwas is
begin
  out1 <= in2; 
  out2 <= in1; 
end Behavioral;

Das sind einfach zwei Verbindungen zwischen Pins.

Und hier die sequentielle Beschreibung:

architecture Behavioral of irgendwas is
begin
  process (in1, in2) begin
    out1 <= in2; 
    out2 <= in1; 
  end process;
end Behavioral;

Wird da jetzt "zuerst" out1 oder out2 aktualisiert, oder sind das auch 
nur simple und einfache Drähte zwischen ein paar Pins?

> variable EdgCnt : integer := 0;
Super, wieder mal: Anfänger und Variable...
Beitrag "Variable vs Signal"

[VHDL Anfänger (Gast)]

also d.h. doch parallel!

TestProc: process (state, sck)


variable EdgCnt : integer := 0;
begin
....
if (sck'event and (sck='1') then
 SDO <= Data(EdgCnt);
 EdgCnt := EdgCnt +1;
 if (EdgCnt > 4) then
   NextState <=  S1; 
   EdgCnt := 0;
 end if;
end if;
..
end process;

Wenn hier EdgCnt als signal definiert ist, dann wird "EdgCnt > 4" erst 
beim nächsten SCK (ein Zyklus später) erkannt, als variable geht sie 
sofort in der if Anweisung?

Wie kann man das geliche mit "signal EdgCnt" realisiergen

[Klaus F. (kfalser)]

So ähnlich :

TestProc: process (sck)   -- nur takt !! 

signal EdgCnt : integer := 0;
begin
   if rising_edge(sck) then
     SDO <= Data(EdgCnt);
     if (EdgCnt = 3) then
        NextState <=  S1; 
        EdgCnt <= 0;
     else 
        EdgCnt <= EdgCnt +1;
     end if;
   end if;
end process;

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

@ VHDL Anfänger
Es gibt mir ein wenig zu denken, dass hier ein next_state in einer 
Ein-Prozess-Beschreibung auftaucht:

if (sck'event and (sck='1') then
    :
    NextState <=  S1;

Und auch der Name des Taktes bringt mich ins Grübeln. Wieviele "Takte" 
hast du in deinem Design?

[VHDL Anfänger (Gast)]

Also das ganze ist für den Empfang eines Telegram der Länge zwischen 4 
und 36 bits (cmd(4)+LedNr(8)+data(24)), es müssen nicht alle drei Teile 
kommen (cmd, Cmd+LedNr oder cmd+LedNr+Data), daher habe ich in state 
machine: GET_CMD, GET_LEDNR,GET_DATA,.. ich zähle die sck Flanken, dann 
wechsele ich zur nächsten state. ein Execute signal gibts auch, hier 
beende ich den Empfang und analysiere ich die das Telegram.

Sck ist der Clock der SPI, und es gibt ein clk_25MHZ wo state <= 
NextState gibt, also mindestens zwei Prozesse.

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

VHDL Anfänger schrieb im Beitrag #2667501:
> Sck ist der Clock der SPI, und es gibt ein clk_25MHZ wo
> state <= NextState gibt, also mindestens zwei Prozesse.
Na hoffentlich hast du den NextState dann auch hübsch in die andere 
Taktdomäne einsynchronisiert...

[VHDL ANfänger (Gast)]

> ...auch hübsch in die andere Taktdomäne einsynchronisiert
Was meinst du mit hübsch?

Process(SYNCLK)
begin
  if(SYNCLK'Event and (SYNCLK = '1')) then
     State <= NextState;
  end if; 
end Process;

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

VHDL ANfänger schrieb im Beitrag #2667570:
> Was meinst du mit hübsch?
Mindestens 2 Flipflops. Das ist hübsch. Zum Hintergrund:
http://www.lothar-miller.de/s9y/archives/64-State-Machine-mit-asynchronem-Eingang.html

ABER: Zustände, die i.A. aus mehreren Flipflops aufgebaut sind, lassen 
sich so auch nicht synchronisieren. Denn das wäre ein paralleler Bus, 
für den ein Synchronisierungsmechanismus ganz anders aussehen muss!
Wenn nämlich die "erste" Flipflopstufe falsche Pegel gespeichert hat, 
dann wird an die 2. Stufe dieser falsche Zustand weitergegeben. Nimm mal 
eine FSM mit 4 Zuständen, die One-Hot codiert sind, dann darf immer nur 
1 Zustand aktiv sein. Hier z.B. der s2:
s1  0
s2  1
s3  0
s4  0
Wenn jetzt der NextState also gerade von 0010 nach 0100 
weiterschaltet und zudem ein SYNCLK kommt, dann kann es sein, dass 
im State das neue 0100 ankommt (ist ok), oder auch das alte 0010 (ist 
auch ok) oder auch fehlerhafte 0110 oder 0000.
Weshalb? Siehe oben: Laufzeitunterschiede zu den 4 Flipflops...

Kurz&Gut: so wie du es gemacht hast, haut es dich auf jeden Fall recht 
bald ab und zu auf die Nase...

[VHDL Anfänger (Gast)]

Meine FSM habe ich eigfentlich so aufgebaut wie in FSM Beispiel im VHDL 
Synthese Buch.

>ABER: Zustände, die i.A. aus mehreren Flipflops aufgebaut sind,
ist hier NextState gemeint? da sie in einem Prozess geschrieben und im 
anderen gelesen wird?

>lassen sich so auch nicht synchronisieren. Denn das wäre ein paralleler >Bus,für 
den ein Synchronisierungsmechanismus ganz anders aussehen muss!
Wie kann ich es denn verbessern/FSM Fehler vermeiden?

[berndl (Gast)]

VHDL Anfänger schrieb im Beitrag #2667427:
> Wie kann man das geliche mit "signal EdgCnt" realisiergen

Indem du dir klarmachst, was eine Variable eigentlich ist: Ein 
Logiksignal, in deinem Fall (innerhalb des process) der Eingang eines 
FFs, nicht der Ausgang

Und wie baut man ein Logiksignal? z.B. mit einer Concurrent Anweisung, 
also z.B. edgcnt_new <= edgcnt + 1;
Und dann im process halt edgcnt_new abfragen...

Oder einfaches so wie Klaus es beschrieben hat

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

VHDL Anfänger schrieb im Beitrag #2667615:
>>ABER: Zustände, die i.A. aus mehreren Flipflops aufgebaut sind,
>>lassen sich so auch nicht synchronisieren
> ist hier NextState gemeint? da sie in einem Prozess geschrieben und im
> anderen gelesen wird?
Ja.

>> Denn das wäre ein paralleler Bus,für
>> den ein Synchronisierungsmechanismus ganz anders aussehen muss!
> Wie kann ich es denn verbessern/FSM Fehler vermeiden?
Du setzt in deinem "sck"-Prozess nur ein einziges Flipflop, das heißt: 
"Übertragung fertig". Und das wird dann auf der "SYNCLK"-Domäne mit 
einem (besser 2) Flipflops einsynchronisiert. Und dann mit diesem Signal 
der Zustand weitergeschaltet. Denn ein einziges Flipflop kann nie 
korrupt sein (mal vom hier belanglosen Thema "Metastabilität" 
abgesehen).

[VHDL Anfänger (Gast)]

>Du setzt in deinem "sck"-Prozess nur ein einziges Flipflop, das heißt:
>"Übertragung fertig". Und das wird dann auf der "SYNCLK"-Domäne mit
>einem (besser 2) Flipflops einsynchronisiert. Und dann mit diesem Signal
>der Zustand weitergeschaltet. Denn ein einziges Flipflop kann nie
>korrupt sein (mal vom hier belanglosen Thema "Metastabilität"
>abgesehen).

Ist es so gemeint?

Proc_1: Process(SYNCLK)
begin
  if(SYNCLK'Event and (SYNCLK = '1')) then
     if(ueb_Fertig ='1') then
       State <= NextState;
      end if;
  end if; 
end Process;

Proc_2: process (sck)

...
begin   
 case(state) is
    when s0 => Ueb_Fertig <= '0'
               ....
               .. .
               if(Count>4)
                  NextState <= S1;
                  Ueb_Fertig <= '1';
                  Count := 0;
               end if;   

    when s1 => Ueb_Fertig <= '0'
               ....
               .. .
               if(Count>8)
                  NextState <= S2;
                  Ueb_Fertig <= '1';
               end if; 
......
end process;

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

VHDL Anfänger schrieb im Beitrag #2667672:
> Ist es so gemeint?Proc_1: Process(SYNCLK)
> begin
>   if(SYNCLK'Event and (SYNCLK = '1')) then
>      if(ueb_Fertig ='1') then
>        State <= NextState;
>       end if;
>   end if;
> end Process;
Fast. Du musst ueb_Fertig aber noch einsynchronisieren, denn das ist 
asynchron...

  signal tx_done : std_logic;

  if rising_edge(SYNCLK) then
     tx_done <= ueb_Fertig; -- das hier ist das Sync-FF
     if(tx_done ='1') then
        State <= NextState;
     end if;
  end if;

Und: verwende doch die Funktion rising_edge(), denn die kann wirklich 
(auch in der Simulation) eine steigende Flanke erkennen...

[VHDL Anfänger (Gast)]

@Lothar
vielen Dank für die Hilfe

[VHDL Anfänger (Gast)]

Noch eine Frage:
was ist der Unerschied zwischen (1) und (2)? ist eine Schreibweise zu 
empfehlen?

1) process(Start)
   ...
   if rising_edge(start) then
   ..
   end if;

   if falling_edge(start) then
   ...
   end if;
    ....
   end process;

2) process(Start)
   ...
   if rising_edge(start) then
   ...
   elsif falling_edge(start) then 
   ...
   end if;
    ....
   end process;

[franke (Gast)]

Kommt auf deine Punkte (...) an.

2) wird nicht gehen, da hier ein dopple-edge flipflop beschrieben.
1) kann gehen, wenn du nicht auf das gleich signal schreibst, sprich 
zwei FlipFlops baust.

Zu empfehlen ist keins von beiden.

GRuß

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

VHDL Anfänger schrieb im Beitrag #2667859:
> ist eine Schreibweise zu empfehlen?
Such mal hier im Forum nach meinen Postulaten...
Die Zusammenfassung: es gibt in einen (Anfänger-)Design nur 1 Takt, das 
Design ist nur auf 1 Flanke dieses Taktes aktiv.

franke schrieb:
> 2) wird nicht gehen, da hier ein dopple-edge flipflop beschrieben.
Geht evtl. mit Coolrunner II, weil der DDR-FFs im Kern hat...