Wann nimmt man "Wait until." und wann "If.." ?

[peter (Gast)]

Hallo, guten Tag.
ZU welchen Zweck mit man das eine oder das andere?

Danke.
Gruss

-------------------------
process
begin
  wait until rising_edge(clock);
  .....
-------------------------

-------------------------
if rising_edge(clk50_in) then
  ......
end if;
------------------------

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

peter schrieb:
> ZU welchen Zweck mit man das eine oder das andere?
So wie es hier dasteht ist es gleichwertig.
Die Variante mit "if reset ... elsif rising_edge(clk)" ist sinnvoll, 
wenn man ein Flipflop mitasynchronem Reset beschreiben will. Bei der 
Schreibweise mit "wait until rising_edge(clk)" wird garantiert ein 
synchrones Design und ein synchroner Reset (wenn überhaupt nötig) 
erzeugt.

Siehe dort unten: 
http://www.lothar-miller.de/s9y/categories/34-Getakteter-Prozess

[Klakx (Gast)]

mit "wait until rising_edge(clk)"
kann man bequem für Testbenches nehmen

z.B.

process
begin
  wait until rising_edge(clock);
  Signal <= 1;

  wait until rising_edge(clock);
  Signal <= 2

  wait until rising_edge(Trigger_signal);
  Signal <= 2;
end process

mit der anderen Beschreibung definiert man kontrollierter die FFs.

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

Klakx schrieb:
> mit der anderen Beschreibung definiert man kontrollierter die FFs.
Was bedeutet "kontrollierter"?
Auf welche Hardware beziehst du diese Aussage?

> mit "wait until rising_edge(clk)"
> kann man bequem für Testbenches nehmen
Du hast den Link nicht angeklickt oder die Mitte der verlinkten Seite 
überblättert. Stimmts?

[TM F. (p_richner)]

Aus meiner Sicht blockiert das Programm bei wait until, bis der Zustand 
eintrifft.
Bei If geht das Programm weiter und macht den If-Ablauf erst, wenn der 
Zustand zutrifft.

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

P_ Richner schrieb:
> Aus meiner Sicht
Ist das Software-Sicht?

Es ist einfach so, dass aus jeder der beiden Beschreibungen immer ein 
Flipflop entsteht. Nur kann mit der "if elsif endif" Variante auch eines 
mit asynchronem Reset erzeugt werden. Bei der Variante mit "wait until" 
nur eines mit synchronem Reset.

> Bei If geht das Programm weiter
Es ist nach wie vor kein Programm, weil es nicht VHPL sondern VHDL 
heißt.

[Klakx (Gast)]

Lothar Miller schrieb:
> Klakx schrieb:
>> mit der anderen Beschreibung definiert man kontrollierter die FFs.
> Was bedeutet "kontrollierter"?
> Auf welche Hardware beziehst du diese Aussage?
>

Es ist z.b. eine mögliche Beschreibung für FPGA und ASIC, die kompatibel 
zu Coding-Checker in Standardeinstellungen ist. "kontrollierter" ist 
vielleicht streitbar, ich sehe jedoch in dieser Struktur einfacher die 
Umsetzung.

>> mit "wait until rising_edge(clk)"
>> kann man bequem für Testbenches nehmen
> Du hast den Link nicht angeklickt oder die Mitte der verlinkten Seite
> überblättert. Stimmts?

Ich habe nur meine Herangehensweise beschrieben. Um den Vergleich der 
Synthesefähigkeit oder anderen Dingen ging es mir nicht. Deine Seite ist 
gut beschrieben.

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

Klakx schrieb:
> Es ist z.b. eine mögliche Beschreibung für FPGA und ASIC
Es liegt in der Natur von ASICs, dass der Reset-Pfad dort natürlich 
extra in die Hand genommen und deshalb auch auscodiert werden muss. Bei 
SRAM-FPGAs ist das nicht nötig, weil bis zum Start des Designs sowieso 
schon alle Flipflops aus dem Config-Prom geladen wurden.

Meine Verallgemeinerung in Richtung FPGA basiert auf dem Titel des 
Forums und der Tatsache, dass der weit überwiegende Teil der VHDL 
Anwender FPGAs beschreibt...

[Nuxlio (Gast)]

wait until wird nur in Testbenches verwendet, da sich der VHDL-Code 
sonst nicht synthetisieren lässt.

Eine saubere Struktur für einen getakteten Prozess sieht so aus:

LABEL: process(CLOCK,RESET)
begin
    if RESET = '0' then
        --hier Reset Logik
    elsif rising_edge(CLOCK) then
        --hier getaktete Logik
    end if;
end process LABEL;

Die Struktur ist auch einleuchtend, wenn man sie mit der Struktur eines 
Flip-Flops vergleicht, welches auf eine Taktflanke reagiert (auch nur 
auf eine!! nur ein rising_edge bzw. falling_edge auch wenn es Ausnahmen 
gibt).
Ein normales FlipFlop reagiert auf nur eine Taktflanke und hat einen 
asynchronen Reset.

VG,

Nuxlio

[asd (Gast)]

>> wait until wird nur in Testbenches verwendet, da sich der VHDL-Code
>> sonst nicht synthetisieren lässt.

Das stimmt so nicht! Siehe: 
http://www.lothar-miller.de/s9y/archives/16-Takt-im-Prozess.html

Wäre aber schon aufgefallen, wenn man den Thread durchgelesen hätte. 
Z.B.:
Lothar Miller schrieb:
> peter schrieb:
>> ZU welchen Zweck mit man das eine oder das andere?
> So wie es hier dasteht ist es gleichwertig.
> Die Variante mit "if reset ... elsif rising_edge(clk)" ist sinnvoll,
> wenn man ein Flipflop mitasynchronem Reset beschreiben will. Bei der
> Schreibweise mit "wait until rising_edge(clk)" wird garantiert ein
> synchrones Design und ein synchroner Reset (wenn überhaupt nötig)
> erzeugt.
>
> Siehe dort unten:
> http://www.lothar-miller.de/s9y/categories/34-Getakteter-Prozess

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

Nuxlio schrieb:
> Ein normales FlipFlop reagiert auf nur eine Taktflanke und hat einen
> asynchronen Reset.
Was ist "normal"? Ein synchrones Flipflop, wie es bei Xilinx seit der 
Spartan3 Serie "Standard" ist, hat keinen asynchronen Reset.

> Eine saubere Struktur für einen getakteten Prozess sieht so aus:
Mit diesen Allgemeinfloskeln aus dem letzten Jahrtausend sollte man sehr 
aufpassen! Siehe den Beitrag "Re: Hardware mit VHDL "richtig" beschreiben."

Fazit: /eine saubere Struktur für einen getakteten Prozess sieht so 
aus/, wie es im Handbuch zum FPGA und zum Synthesizer beschrieben ist.

Vor allem MUSS man beim Einsatz eines asynchronen Resets UNBEDINGT 
darauf hinweisen, dass das Resetsignal in jedem Fall trotzdem 
einsynchronisiert werden MUSS! Sonst passiert nämlich das wie dort in 
der Mitte: 
http://www.lothar-miller.de/s9y/categories/35-Einsynchronisieren
Und das halbe Design startet evtl. jetzt gleich, und der Rest erst einen 
Takt später. Das ist dann der Fall, wenn das Design manchmal nicht 
"anläuft". Wenn es aber läuft, dann problemlos tagelang...

> wait until wird nur in Testbenches verwendet, da sich der VHDL-Code
> sonst nicht synthetisieren lässt.
Ein "wait until" kann jeder Synthesizer schon locker seit 5 Jahren in 
Hardware umsetzen. Und manche sogar noch mehr: 
http://www.lothar-miller.de/s9y/archives/47-wait-im-Prozess.html