Parallel oder sequenziell

Gast #2666671
Lesenswert?

Hallo zusammen
1
...
2
TestProc: process (state, sck)
3

4
variable EdgCnt : integer := 0;
5

6
begin
7
.....
8
if (sck'event and (event='1') then
9
 SDO <= Data(EdgCnt);
10
 EdgCnt := EdgCnt +1;
11
end if;
12
.....
13

14
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
Moderator (Firma: Titel) Persönliche Seite #2666692
Lesenswert?

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:
1
architecture Behavioral of irgendwas is
2
begin
3
  out1 <= in2; 
4
  out2 <= in1; 
5
end Behavioral;
Das sind einfach zwei Verbindungen zwischen Pins.

Und hier die sequentielle Beschreibung:
1
architecture Behavioral of irgendwas is
2
begin
3
  process (in1, in2) begin
4
    out1 <= in2; 
5
    out2 <= in1; 
6
  end process;
7
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"
Gast #2667427
Lesenswert?

also d.h. doch parallel!
1
TestProc: process (state, sck)
2

3

4
variable EdgCnt : integer := 0;
5
begin
6
....
7
if (sck'event and (sck='1') then
8
 SDO <= Data(EdgCnt);
9
 EdgCnt := EdgCnt +1;
10
 if (EdgCnt > 4) then
11
   NextState <=  S1; 
12
   EdgCnt := 0;
13
 end if;
14
end if;
15
..
16
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
Gast #2667501
Lesenswert?

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.
Gast #2667570
Lesenswert?

> ...auch hübsch in die andere Taktdomäne einsynchronisiert
Was meinst du mit hübsch?
1
Process(SYNCLK)
2
begin
3
  if(SYNCLK'Event and (SYNCLK = '1')) then
4
     State <= NextState;
5
  end if; 
6
end Process;
Moderator (Firma: Titel) Persönliche Seite #2667575
Lesenswert?

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...
Gast #2667615
Lesenswert?

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?
Gast #2667620
Lesenswert?

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
Moderator (Firma: Titel) Persönliche Seite #2667640
Lesenswert?

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).
Gast #2667672
Lesenswert?

>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?
1
Proc_1: Process(SYNCLK)
2
begin
3
  if(SYNCLK'Event and (SYNCLK = '1')) then
4
     if(ueb_Fertig ='1') then
5
       State <= NextState;
6
      end if;
7
  end if; 
8
end Process;
9

10
Proc_2: process (sck)
11

12
...
13
begin   
14
 case(state) is
15
    when s0 => Ueb_Fertig <= '0'
16
               ....
17
               .. .
18
               if(Count>4)
19
                  NextState <= S1;
20
                  Ueb_Fertig <= '1';
21
                  Count := 0;
22
               end if;   
23

24
    when s1 => Ueb_Fertig <= '0'
25
               ....
26
               .. .
27
               if(Count>8)
28
                  NextState <= S2;
29
                  Ueb_Fertig <= '1';
30
               end if; 
31
......
32
end process;
Moderator (Firma: Titel) Persönliche Seite #2667743
Lesenswert?

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...
1
  signal tx_done : std_logic;
2

3
  if rising_edge(SYNCLK) then
4
     tx_done <= ueb_Fertig; -- das hier ist das Sync-FF
5
     if(tx_done ='1') then
6
        State <= NextState;
7
     end if;
8
  end if;


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

Noch eine Frage:
was ist der Unerschied zwischen (1) und (2)? ist eine Schreibweise zu 
empfehlen?
1
1) process(Start)
2
   ...
3
   if rising_edge(start) then
4
   ..
5
   end if;
6

7
   if falling_edge(start) then
8
   ...
9
   end if;
10
    ....
11
   end process;
12

13
2) process(Start)
14
   ...
15
   if rising_edge(start) then
16
   ...
17
   elsif falling_edge(start) then 
18
   ...
19
   end if;
20
    ....
21
   end process;
Gast #2667873
Lesenswert?

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ß
Moderator (Firma: Titel) Persönliche Seite #2667898
Lesenswert?

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...

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren