[VHDL] Process Sensitivitätsliste ohne if!?

[Thomas P. (daelectrictick)]

Guten Abend,
bin Anfänger und habe eine Verständnisfrage:

Eine Sensitivitätsliste beinhaltet in diesem Fall ein Port mit nem 
Taster. Wird KEY0 nun gedrückt wird der Code innerhalb des Processes 
ausgeführt. Beim loslassen wieder?!

Der folgende Code funktioniert nicht, wenn ich eine Bedinung(if KEY0='0' 
then) einbaue funktioniert der Code tadelos! Warum? Normal müsste der 
Code doch auch funktionieren ohne if!? Was verstehe ich nicht?

process(KEY0)
begin 

lfsr <= "1011101"; 

lfsr(1) <= lfsr(0); 
lfsr(2) <= lfsr(1); 
lfsr(3) <= lfsr(2); 
lfsr(4) <= lfsr(3); 
lfsr(5) <= lfsr(4); 
lfsr(6) <= lfsr(5); 
lfsr(0) <= (lfsr(1) xor lfsr(6)); 
 
LEDG <= lfsr; 
end process;

mfg
thomythehomy

[Schlumpf (Gast)]

Was heißt "funktionieren"?
Also auf einem FPGA oder in der Simulation?

Falls du das in ein FPGA packen  willst, wirst du eh Schiffbruch 
erleiden.
Ich denke, das soll ein rückgekoppeltes Schieberegister darstellen, 
oder?

Wenn ja, wo ist denn dann der Takt? Oder soll KEY den Takt darstellen?

[Da D. (dieter)]

Zuerst die Frage: Ist das Code, der nur für eine Simulation da ist, oder 
soll das synthetisiert werden und in einem FPGA landen?

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

Thomas P. schrieb:
> Normal müsste der Code doch auch funktionieren ohne if!?
Welchen Fehler bekommst du?
Definiere "normal" und "funktionieren".

Das was du da hast ist
1. eine falsche Sensitivliste, weil eigentlich lfsr hineingehört
daraus resultierend
2. eine falsche Simulation, weil der Synthesizer lfsr einfach 
"dazunimmt"
und
3. eine kombinatorische Schleife, weil lfsr ohne Takt auf lfsr geführt 
ist

Die Punkte 2 und 3 werden dir vom Synthesizer als Warnung oder Info 
mitgeteilt.

Zum Thema passen die hier:
http://www.lothar-miller.de/s9y/archives/42-Kombinatorische-Schleifen.html
http://www.lothar-miller.de/s9y/archives/16-Takt-im-Prozess.html

> Was verstehe ich nicht?
Du kannst dir deine HDL Beschreibung (noch) nicht als Hardware 
vorstellen. Das kommt erst mit Übung. Und dann siehst du ganz klar, 
warum das da oben nicht funktioniert.

BTW: nur unter ganz bestimmten Bedingungen ist eine kombinatorische 
Schleife erwünscht. Z.B. bei einem Ringoszillator: 
http://www.lothar-miller.de/s9y/categories/29-Ringoszillator

[asd (Gast)]

Alles berechtigte Einwände und fragen der bisherigen Antworten. Problem 
dürfte vor allem folgendes sein:

> Eine Sensitivitätsliste beinhaltet in diesem Fall ein Port mit nem
> Taster. Wird KEY0 nun gedrückt wird der Code innerhalb des Processes
> ausgeführt. Beim loslassen wieder?!

Für synthetisierbaren Code brauchst du das if tatsächlich. Merke, dass 
die Sensititylist nur Einfluss auf die Simulation hat. Und auch bei 
Simulationen ist die Idee nicht solche Triggerungen der Sensitivitylist 
zu überlassen...

Der Rest wurde schon gesagt... Der Weg führ über einen korrekten Takt.

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

asd schrieb:
> Problem dürfte vor allem folgendes sein:
>> Eine Sensitivitätsliste beinhaltet in diesem Fall ein Port mit nem
>> Taster. Wird KEY0 nun gedrückt wird der Code innerhalb des Processes
>> ausgeführt. Beim loslassen wieder?!
Ich sehe das auch so: die softwarelastige DENKWEISE ist hier das 
Problem. Der "Code" im Prozess wird nicht "ausgeführt". Sondern die 
"Beschreibung" des Prozesses wird in Hardware "abgebildet".

Etwas vereinfacht könnte man sagen: VHDL ist keine Programmiersprache. 
Sonst hieße sie ja VHPL...

[Thomas P. (daelectrictick)]

Danke für die ausführlichen und hilfreichen Kommentare!

Ich werde den Code gleich mal umschreiben und hier posten.

Die Sensitivitylist ist nur für die Simulation!? Würde das Board den 
Process denn nicht dann jedes mal in Hardware umsetzen?

Angenommen ich schreibe sowas hier:

process(KEY0)
begin 

lfsr <= "11011"
 
LEDG <= lfsr; 
end process;

Bei Programmierung des fpga's müsste demnach ja nun egal ob ich KEY0 
betätige oder nicht die LED aufleuchten bzw die LEDs.


Ich habe mich erkundigt was das mit der kombinatorischen Logik auf sich 
hat. Ich werde sie in Zukunft meiden!

Ich beschreibe ein FPGA.

Vielleicht noch etwas zu meiner Person:

Ich bin Elektrotechnikstudent im 5. Semester und bekomme in 2 Wochen 
VHDL als Fach und wollte nun schonmal die Materie kennenlernen.

Die Digitaltechnik Klausur habe ich mit sehr gut absolviert, so dass ich 
in diesem Bereich eine gute Grundlage besitze.

[Schlumpf (Gast)]

Thomas P. schrieb:
> Bei Programmierung des fpga's müsste demnach ja nun egal ob ich KEY0
> betätige oder nicht die LED aufleuchten bzw die LEDs.

richtig ;-)

Das ist das Identische wie:

LEDG <= "11011";

ganz ohne Process etc.

Die Synthese nagelt dir dabei die Ausgänge einfach fest auf den 
eingestellten Wert und dein FPGA ist somit nur ein teures Stück "Draht" 
;-)

[Thomas P. (daelectrictick)]

Hier mal der überarbeitete Code:

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std;

entity laufschrift is
  port(--HEX0, HEX1, HEX2, HEX3, HEX4, HEX5,HEX6,HEX7: out std_ulogic_vector (0 to 6);
       KEY: in std_logic_vector (3 downto 0);
     CLOCK_50: in std_logic;
     LEDR: out std_logic_vector (5 downto 0)
       );
  
end entity laufschrift;

architecture switchled of laufschrift is
signal fp_o: std_logic_vector(5 downto 0);

signal counter: integer range 0 to 100000000;
signal toggle: std_logic;

begin
teiler: process (CLOCK_50)
begin
if KEY(0)='0' then
  counter<=0;
elsif rising_edge(CLOCK_50) then
  if counter < 100000000 then
    counter <= counter + 1;
    toggle <= '0';
  else
    counter <= 0;
    toggle <= '1';
  end if;
end if;
end process teiler;


flipflop: process(CLOCK_50, KEY(0))
begin

if KEY(0)='0' then --reset
  fp_o(0)<='1';
  fp_o(1)<='1';
  fp_o(2)<='1';
  fp_o(3)<='1';
  fp_o(4)<='1';
  fp_o(5)<='1';
elsif CLOCK_50='1' and CLOCK_50'event then
  if toggle='1' then
    fp_o(0)<=fp_o(5);
    fp_o(1)<=fp_o(5) xor fp_o(0);
    fp_o(2)<=fp_o(1);
    fp_o(3)<=fp_o(5) xor fp_o(2);
    fp_o(4)<=fp_o(3);
    fp_o(5)<=fp_o(4);
  end if;
end if;

end process flipflop;
LEDR<=fp_o;
end architecture switchled;

Ich habe in diesem Code die Clk zur Synchronisation benutzt..

Wenn ich mir den Schaltplan im Technology Map Viewer anschaue, sieht es 
ziemlich nach Chaos aus.

Wieso? Was mache ich noch falsch?

Sollte man bei der Hardwarebeschreibung dann lieber im process die wait 
until Anweisung benutzen?

P.S.: Der Code macht schonmal das was er soll.

mfg
Thomythehomie

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

Thomas P. schrieb:
> Ich habe mich erkundigt was das mit der kombinatorischen Logik auf sich
> hat. Ich werde sie in Zukunft meiden!
Es wird dir nicht gelingen. Du brauchst kombinatorische Logik in jeder 
Schaltung. Was du meiden und davon unterscheiden sollst, ist die 
kombinatorische Schleife. Die Gefahr beginnt, wenn eine 
kombinatorische Rückkopplung eingebaut wird...

> Die Sensitivitylist ist nur für die Simulation!?
Ja. Ausschließlich!

Thomas P. schrieb:
> Wenn ich mir den Schaltplan im Technology Map Viewer anschaue
Nimm den RTL-Viewer, wenns nicht gerade der von Xilinx ist...
> sieht es ziemlich nach Chaos aus.
Wird schon passen.

> std_ulogic
Lass das u einfach weg. Die ganze Welt lässt es weg. Nur Schulen 
verwenden es...

> P.S.: Der Code macht schonmal das was er soll.
Meistens. Denn das hier ist ein Quell für Probleme:
> if KEY(0)='0' then
Man synchronisiert asynchrone externe Signale ein. Immer! Denn was dir 
mit diesem (unnötigen) Reset passieren kann und wird, ist das dort in 
der Mitte der Seite:
http://www.lothar-miller.de/s9y/categories/35-Einsynchronisieren

[Der L. (vhdl-neuling)]

Thomas P. schrieb:
> Ich bin Elektrotechnikstudent im 5. Semester und bekomme in 2 Wochen
> VHDL als Fach und wollte nun schonmal die Materie kennenlernen.

Hi Thomas,

was mir zu Beginn wirklich sehr hilfreich war, ist:
VHDL ist eine Beschreibungssprache, mit der man schön 
Schaltungen/Logiken beschreiben kann. Es kann aber noch viel mehr. D.h. 
du kannst viel schreiben was hinterher kein Syntheziser dieser Welt in 
einem FPGA umsetzen kann.
Die Welten FPGA und VHDL bilden nur eine teilweise Schnittmenge. So 
brauchst du auch Werkzeuge für die FPGA-Entwicklung, die dir wiederum 
VHDL nicht bietet, z.B. Constraints.

----------------------
-                    -
- VHDL    --------------
-         -            -
-----------    FPGA    -
          -            -
          --------------

Die "Wait"-Anweisung benutze ich bsplw. nur in Simulationen/Testbenches. 
Man kann sich Konstrukte basteln, die die Synthese problemlos 
durchlaufen. Aber warum sollte man, wenn man es nicht muss :)

derLars

[peter (Gast)]

Hmmm..., ich spiele seid 2 Woche mal mit Verilog.
Da habe ich festgestellt , das es weniger unbekannte Beschreibungen gibt 
wie in VHDL die etwas machen was teilweise auch im Test schwer 
auffindbar ist.

Lothar hat mir ein Fehler aufgedeckt um ein Grafikbild darzustellen 
320x240.
Es funktioniert jetzt wunderbar durch eine Auslagerung der Beschreibung, 
aber ich werde jetzt zb ausgesperrt wenn ich das Video-RAM neu laden 
möchte, es geht nicht mehr.

In Verilog habe ich keine RAM-Aussperrung....man kann sagen es geht 
doch.
Und das macht mir das Leben als Anfänger schwer mit VHDL.

Warum gibt es in Verilog mehr beschreibungen wo Prozessoren nachgeahmt 
werden oder andere Systeme? Ich habe eine 6502-Beschreibung gefunden und 
auf dem NANO überspielt, dann habe ich die Verbindungen des Prozessors 
zum C64 verbunden (Prozessor vom C64 entfernt) und de C64 läuft mit dem 
NANO.
Auch der Parallax Propeller wurde nachgebaut mit Verilog, hab ich auch 
am laufen. Auch einige andere schöne viele Spielereien mit Verilog gibt 
es.
Auch kann ich als Anfänger die Beschreibungen besser verstehen.

Warum man in Europa dieses Verilog wenig nimmt ist keine Frage des 
Verstandes sondern einer Lobby der es nicht um eine gute Funktion geht 
sondern nur ums Geld...schade...

Auch die Prozess-CLK mit Wait und den anderen Aufrufen wird immer wieder 
diskutiert...nimmm das Wait ...nimm nicht rising_edge...auf keine Fall : 
"if clk='1'...immer wieder lese ich gegensätzliche Meinungen. Nicht sehr 
hilfreich für eine Anfänger.

Grus

Gruss

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

peter schrieb:
> Lothar hat mir ein Fehler aufgedeckt um ein Grafikbild darzustellen
Das war nicht sehr schwierig, denn ich habe es einfach nur simuliert.

> Auch einige andere schöne viele Spielereien mit Verilog gibt es.
> Auch kann ich als Anfänger die Beschreibungen besser verstehen.
Klassiker zum Thema:
Beitrag "Frage zur Lernkurve VHDL vs. Verilog"
http://www.lothar-miller.de/s9y/archives/88-VHDL-vs.-Verilog-am-Beispiel-einer-Stoppuhr.html

[Thomas P. (daelectrictick)]

Lothar Miller schrieb:
> Es wird dir nicht gelingen. Du brauchst kombinatorische Logik in jeder
> Schaltung. Was du meiden und davon unterscheiden sollst, ist die
> kombinatorische Schleife. Die Gefahr beginnt, wenn eine
> kombinatorische Rückkopplung eingebaut wird...

Richtig! Habe es im Auto geschrieben und erst zu Hause gemerkt, dass was 
falsch ist. Konnte es leider nicht editieren, denn die 60 Minuten 
Bearbeitungszeit waren um..

Lothar Miller schrieb:
> Lass das u einfach weg. Die ganze Welt lässt es weg. Nur Schulen
> verwenden es...

Ok. std_ulogic achtet grob gesagt nicht auf Kollisionen, wenn man z.B. 
mit I2c arbeitet, oder?

Lothar Miller schrieb:
> Meistens. Denn das hier ist ein Quell für Probleme:
>> if KEY(0)='0' then
> Man synchronisiert asynchrone externe Signale ein. Immer! Denn was dir
> mit diesem (unnötigen) Reset passieren kann und wird, ist das dort in
> der Mitte der Seite:
> http://www.lothar-miller.de/s9y/categories/35-Einsynchronisieren

Sehr guter Beitrag! Ich denke ich kann nun schon etwas glänzen vor dem 
Professor! Das Einsynchronisieren erscheint mir logisch. Ich werde es 
selber mal ausprobieren.. Genau wie das Entprellen auf deiner Seite.




Der Lars schrieb:
> Die Welten FPGA und VHDL bilden nur eine teilweise Schnittmenge. So
> brauchst du auch Werkzeuge für die FPGA-Entwicklung, die dir wiederum
> VHDL nicht bietet, z.B. Constraints.
>
> ----------------------
> -                    -
> - VHDL    --------------
> -         -            -
> -----------    FPGA    -
>           -            -
>           --------------

Das behalte ich im Hinterkopf! Für die Anfänge werde ich mich auf die 
oben genannte Schnittmenge beschränken.

> Die "Wait"-Anweisung benutze ich bsplw. nur in Simulationen/Testbenches.
> Man kann sich Konstrukte basteln, die die Synthese problemlos
> durchlaufen. Aber warum sollte man, wenn man es nicht muss :)

Du musst bei der Synthese eines Processes entweder eine Sensitivitylist 
oder eine "Wait"-Anweisung benutzen. Wenn du keine "Wait"-Anweisungen 
benutzt musst du ja zwangsläufig auf die Sensitivitylist zurückgreifen, 
die aber nur bei Simulation von Bedeutung ist. Ich habe für mich 
rausgefunden, soll der Code synthetisiert werden benutze ich die 
"Wait"-Anweisung. Bei der Simulation die Sensitivitylist. Hoffe mein 
Gedankengang ist richtig!


@Peter: Als Anfänger findet man hier im Forum sehr viele Informationen. 
Das zuletzt angesprochene Problem ist einfach zu lösen:

Beitrag "CLK'event oder rising_edge(clk)"

Lese dir den Beitrag sorgfältig durch, wenn es stimmt was da steht und 
da gehe ich stark von aus!!, dann ist es gar nicht so schwer zu 
entscheiden, welcher von den Befehlen reicht und wann man doch lieber 
rising_edge benutzen sollte. Ich habe gemerkt, es kommt auch immer auf 
die Anwendung an, aber wir als Anfänger sollten uns mit solchen 
Antworten, wie die ausm FAQ, zufrieden geben und erstmal beherrschen.

Gruß
Thomythehomie

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

Thomas P. schrieb:
> Ok. std_ulogic achtet grob gesagt nicht auf Kollisionen, wenn man z.B.
> mit I2c arbeitet, oder?
Mit std_ulogic wird keine Auflösungstabelle verwendet. D.h. das Treiben 
von 'Z' und '0' auf das selbe Signal wird nicht auf '0' aufgelöst, 
sondern führt zu einem Fehler. Die Simulation eines I2C Busses mit 
st_ulogic wird daher nicht möglich sein. Man könnte ihn aber durchaus 
damit implementieren. std_ulogic wurde früher (tm) verwendet, weil der 
Simulator schneller war, wenn er Signalkonflikte nicht auflösen musste. 
Heute sind die Simualtoren entsprechend dem Marktbedürfnis 
weiterentwickelt und dieses Argument zählt nicht mehr.

> Ich habe für mich rausgefunden, soll der Code synthetisiert werden
> benutze ich die "Wait"-Anweisung. Bei der Simulation die
> Sensitivitylist. Hoffe mein Gedankengang ist richtig!
Gerade bei der Simulation ist die wait-Anweisung die Anweisung 
schlechthin. So wirft dir das Template von Xilinx gleich einen Prozess 
mit zwei vor den Latz:

  -- insert reset
  wait for 100 ns;

  -- insert stimuli

  -- wait forever
  wait;

Und auch hier ist in der TB die wait-Anweisung ganz hübsch:
http://www.lothar-miller.de/s9y/archives/91-Schalter-und-Bruecke.html
Auch eine serielle Schnitte oder ein Display-Timing oder ... ist ein 
wait eine tolle Sache.

Bei des Synthese sorgt ein "wait until" (das einzige wait, das 
synthetisiert werden kann) dafür, dass das Design sicher synchron zum 
Takt ist und so z.B. keine kombinatorischen Schleifen aufgebaut werden.

[Thomas P. (daelectrictick)]

Top! Damit wurden alle meine Fragen beantwortet. Ich bedanke mich bei 
allen Beteiligten für die Hilfe!

Gruß
ThomyTheHomie