Addition & Multiplikation mit FPGA

[D. E. (eschlair)]

Hallo

Mir stellen sich folgende Probleme:


1.
In VHDL möchte ich 4 Schalter überprüfen. Es darf nur jeweils 1 Schalter 
eingeschaltet sein. Bei 2 Schaltern oder mehr sollte ein ERROR 
ausgegeben werden.

Dazu folgender Überlegungsansatz...

>library IEEE;
>use IEEE.STD_LOGIC_1164.ALL;
>use IEEE.STD_LOGIC_ARITH.ALL;
>use IEEE.STD_LOGIC_UNSIGNED.ALL;
...
>signal ERROR: std_logic_vector(0 to 3);
...
>ERROR <= F0 + F1 + F2 + F3;
>
>if ERROR >= 2 then
>  LED <= "00000000";
>end if;


mit folgendem Fehler:
>+ can not have such operands in this context.




2.
Ich möchte ein Lauflicht programmieren. Dazu sollte bei einem Impuls das 
Licht um 1 LED wandern... also "signal * 2" oder "signal / 2".

Hier gibt es den gleichen Fehler wie oben.


Habe mal gelesen, dass man was mit der Lybrary machen muss...aber wie 
genau, weiss ich nicht. Kann mir jemand weiterhelfen?

Vielen Dank

[Klaus F. (kfalser)]

> Bei 2 Schaltern oder mehr sollte ein ERROR ausgegeben werden.

Was hättest Du gern:
Windows MFC Alert Box oder Unix QT?

Scherz beiseite, aber VHDL ist für Hardware, nicht für Software 
Programme.

[Falk B. (falk)]

@ Dave E. (eschlair)

>In VHDL möchte ich 4 Schalter überprüfen. Es darf nur jeweils 1 Schalter
>eingeschaltet sein. Bei 2 Schaltern oder mehr sollte ein ERROR
>ausgegeben werden.

>mit folgendem Fehler:
>+ can not have such operands in this context.

Sicher, du kannst einzelne Bits nicht wie Vektoren addieren. MAchs 
infach, nimm eine CASE Anweisung und schreib die Zustände direkt hin. 
Ist hier auch sinnvoller.

>Ich möchte ein Lauflicht programmieren. Dazu sollte bei einem Impuls das
>Licht um 1 LED wandern... also "signal * 2" oder "signal / 2".

Du solltest aufhören VHDL als eine Programmiersprache wie C anzusehen. 
VHDL ist ein Hardwarebeschreibungssprache. Lies ein parr Bücher und 
schau dir ein peer Tutorials an, wei sowas in VHDL aussieht.

MFG
Falk

[D. E. (eschlair)]

>Scherz beiseite, aber VHDL ist für Hardware, nicht für Software
>Programme.

an dem arbeite ich eben noch...ist das 2. Programm in VHDL.


Mit Error meine ich natürlich irgend eine blinkende LED. Von mir aus 
auch nur eine Leuchtende... Das sollte doch mit VHDL machbar sein, oder?

[Falk B. (falk)]

@  Dave E. (eschlair)

>Mit Error meine ich natürlich irgend eine blinkende LED. Von mir aus
>auch nur eine Leuchtende... Das sollte doch mit VHDL machbar sein, oder?

Mit Müh und Not . . .

SCNR
Falk

[D. E. (eschlair)]

>Mit Müh und Not . . .

was heisst das. Was wird denn mit VHDL gemacht/programmiert?

Braucht es für diese Programmiersprache irgendwelche Vorkenntnisse? 
Könnte ein Elektroniker in der Lehre VHDL programmieren???

MFG

[Falk B. (falk)]

@ Dave E. (eschlair)

>>Mit Müh und Not . . .

>was heisst das.

Schon mal was von Ironie gehört? ;-)

> Was wird denn mit VHDL gemacht/programmiert?

So ziemlich jeder Digitalschaltkreis, vom einfachen LED-Treiber bis zum 
Pentium4.

>Braucht es für diese Programmiersprache irgendwelche Vorkenntnisse?

Aber sicher. Grundlagen der Digitaltechnik z.B.

>Könnte ein Elektroniker in der Lehre VHDL programmieren???

Hmmm, ich bin nich ganz im Bilde, welche Vorkenntnisse die Elekroniker 
heute haben. Ich sag mal vorsichtig ja.

MfG
Falk

[D. E. (eschlair)]

Wie wird denn sonst ein Lauflicht programmiert?

und wenn "wir" schon daran sind:

in C wird ein Struktogramm mit Analyse erstellt und zuletzt der Code mit 
Testbericht etc. Wie ist es denn mit VHDL?

In C läuft das ganze von oben nach unten (Programmverlauf). VHDL von 
unten links nach oben rechts?
oder wie ist die ganze Überlegensweise?

mfG


-> edit:

nochmals zur CASE-Schlaufe.

Die ist ja gut und recht für die Schalterabfragen. Doch bei 4 Schaltern 
müsste man 4 CASE-Schlaufen einfügen. Da könnte man direkt if-Schlaufen 
benützen.

Wenn es nur irgendwie möglich wäre, die Anzahl aktiver Schalter in einer 
Variablen zu speichern....

[Jan M. (mueschel)]

Dave E. wrote:
> Wie wird denn sonst ein Lauflicht programmiert?

mit logischen Verknüpfungen, nicht mit Arithmetik.

> und wenn "wir" schon daran sind:
>
> in C wird ein Struktogramm mit Analyse erstellt und zuletzt der Code mit
> Testbericht etc. Wie ist es denn mit VHDL?

Genauso.

> In C läuft das ganze von oben nach unten (Programmverlauf). VHDL von
> unten links nach oben rechts?

Kein Ablauf. Alles läuft gleichzeitig.

> oder wie ist die ganze Überlegensweise?

Sehr ähnlich zu C.

[Andreas S. (andreas) (Admin)]

VHDL läuft überhaupt nicht (bzw. nur in der Simulation), sondern wird in 
Hardware umgesetzt. Die Sprache alleine zu lernen reicht deswegen nicht, 
sondern man muss auch lernen was wie in Hardware umgesetzt werden kann. 
Ein Online-Tutorial findest du auf http://www.vhdl-online.de/.

[D. E. (eschlair)]

>Ein Online-Tutorial findest du auf http://www.vhdl-online.de/.

vielen Dank. An dem arbeite ich gerade. Hat mich fast erschlagen die 
grosse Menge...:). Muss mir da mal was rauspicken.



edit von Beitrag 8
...
nochmals zur CASE-Schlaufe.

Die ist ja gut und recht für die Schalterabfragen. Doch bei 4 Schaltern
müsste man 4 CASE-Schlaufen einfügen. Da könnte man direkt if-Schlaufen
benützen.

Wenn es nur irgendwie möglich wäre, die Anzahl aktiver Schalter in einer
Variablen zu speichern....
...

mfG

[Jan M. (mueschel)]

Dave E. wrote:
> Wenn es nur irgendwie möglich wäre, die Anzahl aktiver Schalter in einer
> Variablen zu speichern....

Natürlich, das geht. Allerdings nicht durch zählen, wie du ursprüunglich 
vorhattest. Überlege dir eine Logikfunktion, die eins ergibt, sobald 
mehr als ein Schalter aktiv ist. Für zwei Schalter ist es ganz einfach:

Error <= Schalter1 and Schalter2

Die Fälle 3, 4 und n sind dir überlassen.

[Falk B. (falk)]

@ Dave E. (eschlair)

>nochmals zur CASE-Schlaufe.

Es ist ein Konstrukt. Genau genommen eine einfache Tabelle.

>Die ist ja gut und recht für die Schalterabfragen. Doch bei 4 Schaltern
>müsste man 4 CASE-Schlaufen einfügen. Da könnte man direkt if-Schlaufen
>benützen.

Jain. If erzeugt Prioritätslogik, die ggf unerwünscht und langsamer ist. 
Case erzeugt gleichwertige Logik.

>Wenn es nur irgendwie möglich wäre, die Anzahl aktiver Schalter in einer
>Variablen zu speichern....

Geht hier sinnvoll auch mit CASE. Etwa so.

process(schalter) 
begin
  case schalter is
    when "0000" => error <= '0'; zaehler <="000";
    when "0001" => error <= '0'; zaehler <="001";
    when "0010" => error <= '0'; zaehler <="001";
    when "0011" => error <= '1'; zaehler <="010";
    when "0100" => error <= '0'; zaehler <="001";
    when "0101" => error <= '1'; zaehler <="010";
    when "0110" => error <= '1'; zaehler <="010";
    when "0111" => error <= '1'; zaehler <="011";
    when "1000" => error <= '0'; zaehler <="001";
    when "1001" => error <= '1'; zaehler <="010";
    when "1010" => error <= '1'; zaehler <="010";
    when "1011" => error <= '1'; zaehler <="011";
    when "1100" => error <= '1'; zaehler <="010";
    when "1101" => error <= '1'; zaehler <="011";
    when "1110" => error <= '1'; zaehler <="011";
    when "1111" => error <= '1'; zaehler <="100";
    when others => error <= '0'; zaehler <="000";
  end case;
end process;

MFG
Falk

[D. E. (eschlair)]

>Error <= Schalter1 and Schalter2
>
>Die Fälle 3, 4 und n sind dir überlassen.

KV-Diagramme behandeln wir erst in der Schule. Habs trotzdem versucht:

Z = (/C or /D) and (/A or /B or /D) and (/A or /B or /C)


im code:
if ((F2 = '0' or F3 = '0') and (F0 = '0' or F1 = '0' or F3 = '0') and 
(F0 = '0' or F1 = '0' or F2 = '0')) >= 2 then
    LED <= "00000000";
end if;


Fehler:
>= can not have such operands in this context.


versuche die Formel noch zu kürzen.

mfG

[Jan M. (mueschel)]

Ich sehe gerade, ich hab deine Frage etwas falsch beantwortet: Eine 
solche Gleichung Error = S1 and S2 zählt natürlich nicht die Schalter, 
sondern findet nur heraus, ob beide gedrückt sind.

> ...  = '0' or F2 = '0')) >= 2

Logische Funktionen liefern nur 1 oder 0, damit ist "größer gleich 2" 
ziemlich sinnlos und auch nicht erlaubt.

[eschlair (Gast)]

>> ...  = '0' or F2 = '0')) >= 2
>
>Logische Funktionen liefern nur 1 oder 0, damit ist "größer gleich 2"
>ziemlich sinnlos und auch nicht erlaubt.

klar logisch. sorry hatte noch was anderes im Kopf.

langsam, langsam dämmerts.....immer ein wenig.

[der mechatroniker (Gast)]

Ihr macht mir Sorgen: Der Sinn von Hardwarebeschreibungssprachen ist 
doch, daß einem das Synthesetool solche Fleißarbeiten wie das austüfteln 
von Booleschen Gleichungen ausgehend von einer mathematisch eindeutigen 
Beschreibung abnimmt.

Von daher denke ich mal, daß die "Zählmethode" irgendwie funktionieren 
müßte, wenn man sie denn richtig formuliert.

Da ich morgen VHDL-Praktikum hab und hier an der Uni an einen mit 
entsprechender Software ausgestatteten Rechner komme, werde ich das 
vielleicht mal austüfteln.

[Jan M. (mueschel)]

Ja, das geht schon. Eine for-Schleife, und jeweils eine Variable 
hochzählen.
Allerdings würde ich das keinem Anfänger empfehlen der gerade versucht 
in VHDL einzusteigen - zu leicht bleibt man wieder in der schon 
bekannten Software-Programmierdenkweise.

Überschätze aber nicht die Synthese, so gut ist die auch wieder nicht.

[Gast (Gast)]

Warum addierst Du den Wert der Schalter nicht einfach und prüfst auf "1" 
?

[Fpgakuechle K. (Gast)]

1) Du willst einen Encoder 4 zu 1; ein ähnliches problem findet sich im 
wiki mit mit mehreren Codierstilen 
http://www.mikrocontroller.net/articles/TTL74185
2) Lauflicht ist ein schieberegister.
schnipsel:

architecture gh of led is
signal led: std_logic_vector(7 downto 0) := "00000001";
begin
process(clk)
 begin
  if rising_edge(clk) then
   if schiebe_pulse = '1' then 
    led <= led(6 downto 0) & led(7);
   end if;
  end if;
 end process;
end architecture;

schiebe_pulse darf nur für einen Takt '1' sein und sollte mit einem 
Zähler erzeugt werden.

Dave E. wrote:
> Hallo
>
> Mir stellen sich folgende Probleme:
>
>
> 1.
> In VHDL möchte ich 4 Schalter überprüfen. Es darf nur jeweils 1 Schalter
> eingeschaltet sein. Bei 2 Schaltern oder mehr sollte ein ERROR
> ausgegeben werden.
>
> Dazu folgender Überlegungsansatz...
>
>>library IEEE;
>>use IEEE.STD_LOGIC_1164.ALL;
>>use IEEE.STD_LOGIC_ARITH.ALL;
>>use IEEE.STD_LOGIC_UNSIGNED.ALL;
> ...
>>signal ERROR: std_logic_vector(0 to 3);
> ...
>>ERROR <= F0 + F1 + F2 + F3;
>>
>>if ERROR >= 2 then
>>  LED <= "00000000";
>>end if;
>
>
> mit folgendem Fehler:
>>+ can not have such operands in this context.
>
>
>
>
> 2.
> Ich möchte ein Lauflicht programmieren. Dazu sollte bei einem Impuls das
> Licht um 1 LED wandern... also "signal * 2" oder "signal / 2".
>
> Hier gibt es den gleichen Fehler wie oben.
>
>
> Habe mal gelesen, dass man was mit der Lybrary machen muss...aber wie
> genau, weiss ich nicht. Kann mir jemand weiterhelfen?
>
> Vielen Dank

[Mark (Gast)]

noch'n Vorschlag:

signal switches : std_logic_vector(0 to 3);

process(...)
   variable num_sw_pressed : integer range 0 to 4;
begin
   num_sw_pressed := 0;

   for i in 0 to 3 loop
      if switches(i) = '1' then
         num_sw_pressed := num_sw_pressed +1;
      end if;
   end loop;

   -- ERROR ?
   if num_sw_pressed > 1 then
   ...


So würde ich das schreiben, ohne umständliche Kombinatorik oder 100 
case-Abfragen.

[der mechatroniker (Gast)]

> noch'n Vorschlag:

das ist doch kein weiterer Vorschlag, sondern exakt das, was Jan M. 
bereits vorgeschlagen hat und was mir in ähnlicher Form auch bereits im 
Kopf herumgeschwirrt ist.

[Fpgakuechle K. (Gast)]

Mark wrote:
> noch'n Vorschlag:
>
> signal switches : std_logic_vector(0 to 3);
>
> process(...)
>    variable num_sw_pressed : integer range 0 to 4;
> begin
>    num_sw_pressed := 0;
>
>    for i in 0 to 3 loop
>       if switches(i) = '1' then
>          num_sw_pressed := num_sw_pressed +1;
>       end if;
>    end loop;
>
>    -- ERROR ?
>    if num_sw_pressed > 1 then
>    ...
>
>
> So würde ich das schreiben, ohne umständliche Kombinatorik oder 100
> case-Abfragen.

Sorry aber das ist umständliche und langsame Hardware, 3 adder und ein 
größer als Vergleicher! Die Schleife mag zwar für ein Programm auf einer 
CPU besser sein, aber nicht in Hardware. Und die synthese ist noch nicht 
soweit, das selber aus den Code-gebrabbel aus Addern etc erkennt, das 
hier ein 1 aus 4 Coder gemeint ist. Wahrscheinlich baut sie eine Kette 
aus 2 Fulladder und einem vergleicher. Also 3 Logiclevel. Dabei brauchst 
nur eine
Lookuptable also einen Logiclevel.
Auch wenn es langsam langweilig wird, man programmiert nicht VHDL (wie 
C) sondern man baut Hardware mit VHDL. Also formuliert man die Aufgabe 
in Hardware (Blockdiagramm) und schreibt dann denn code.

[D. E. (eschlair)]

>Auch wenn es langsam langweilig wird, man programmiert nicht VHDL (wie
>C) sondern man baut Hardware mit VHDL. Also formuliert man die Aufgabe
>in Hardware (Blockdiagramm) und schreibt dann denn code.

Falls mein angehängter Code zu viel "C-Style" hat, sags mir nur!



Bis vor kurzem konnte ich die angehängte Datei auf den FPGA 
laden...jetzt nicht mehr; nachdem ich den Code umhergeschoben und 
möglichst vereinfacht habe.....:(


Analyzing Entity <test> in library <work> (Architecture <behavioral>).
WARNING:Xst:819 - "***" line 59: The following signals are missing in 
the process sensitivity list:
   ERROR, LED.
ERROR:Xst:827 - "***" line 59: Signal ERROR cannot be synthesized, bad 
synchronous description.
-->




mfG

[Falk B. (falk)]

   process (F0, F1, F2, F3, CLK, RESET)

  begin
    if F0 = '0' and F1 = '0' and F2 = '0' and F3 = '0' and RESET = '1' and ERROR = '1' then
      ERROR <= '0';
      LED <= "00000000";
    end if;

Uuuuhh. Gewöhn dir sowas gar nicht erst an. Das sind zwei massive Fehler

Kombinatorisches asynchrones Reset. SCHLECHT!
Resetquelle wird selber zurückgesetzt: GANZ SCHLECHT!

     if RESET = '1' and ERROR = '0' then
        LED <= "00000000";
    end if;

Was soll das? Nochmal Reset. Unsinn.

Der Rest ist ziemlich merkwürdig. Das soll besser sein als ein CASE 
Konstrukt? Naja . . .

MFG
Falk

[D. E. (eschlair)]

das es SCHLECHT ist, weiss ich, oder dachte es mir. Doch jetzt weiss ich 
nicht viel mehr als vorher....ausser das es GANZ SCHLECHT ist.

Mir ist klar, der RESET-teil bedarf einer Überarbeitung. Doch das nützt 
mir nichts, wenn der Code i.O. ist, aber nicht synthetisierbar (wegen 
was auch immer).

[Falk B. (falk)]

@ Dave E. (eschlair)

>Mir ist klar, der RESET-teil bedarf einer Überarbeitung. Doch das nützt

Nicht nur der. Lass dieses Rumgestochere und fang gleich ordentlich an. 
Dazu gehört, dass man mit Digitaltechnik vertraut ist. Ohne das ist VHDL 
sinnlos.

>mir nichts, wenn der Code i.O. ist, aber nicht synthetisierbar (wegen
>was auch immer).

Wegen des ERROR Signals.

MfG
Falk

[D. E. (eschlair)]

>Wegen des ERROR Signals.

denke ich nicht.
Sobald ich das ERROR-Signal entferne (dieses ist ja nicht zwingend 
nötig), gibt es mir den Fehler mit "LED" an...

> Lass dieses Rumgestochere und fang gleich ordentlich an.

was heisst "Rumgestochere"? Die 4 if-schlaufen für die verschiedenen 
Frequenzen?

[Falk B. (falk)]

@ Dave E. (eschlair)

>denke ich nicht.

Denke ich doch. Ich kann da ein "wenig" aus. ;-)

>Sobald ich das ERROR-Signal entferne (dieses ist ja nicht zwingend
>nötig), gibt es mir den Fehler mit "LED" an...

Weil das alles sehr, naja, sagen wir wild konstruiert ist.

>> Lass dieses Rumgestochere und fang gleich ordentlich an.
>was heisst "Rumgestochere"?

Du hast keine ausreichenden Kenntnisse über Digitaltechnik und VHDL, du 
willst aber mit deinen (wie auch immer gearteten) Kenntnissen von C und 
Co VHDL nutzen. Das geht schief.

> Die 4 if-schlaufen für die verschiedenen Frequenzen?

- Schreib mal ORDENTLICH auf, was das Programm leisten soll.
- Wie soll auf welche Ereignisse reagiert werden?
- Dann überleg dir, wie das mit FlipFlops/Zählern Registern machbar 
wäre.
- Diese Beschreibung muss dann mit VHDL formuliert werden.

Step by Step (uhhhh Babe, uuups, das war Anfang der Neunziger ;-)

Mfg
Falk

[D. E. (eschlair)]

Eigentlich könnte ich einen neuen Thread machen...vllt sollte ich mal 
über die ganze Lage berichten...

Mir, Elektroniker 4.LJ, wurde von einem Mitarbeiter (der sich mit VHDL 
und Co auskannte) der Auftrag erteilt, für die kommenden Lehrlinge (3 
LJ) einen "1-monatigen Kurs" - ~12 Tage exklusiv Schule - in diesem 
Gebiet zu erstellen.
Bevor der Mitarbeiter an die ETH ging, bestellte er noch das Spartan 3A 
Starter Kit. Nun sitze ich da und sollte in 1 Monat (bis ende Oktober) 
einen solchen Kurs auf die Beine stellen... Nur kennt sich sonst in der 
Firma NIEMAND mit FPGA's aus....hm....
egal, ich versuchs mal.


Mein Konzept:
In 12 Tagen kann man nicht all zu viel machen. Der Kurs sollte auch nur 
einen kleinen Einblick in die Welt von VHDL geben.
In den ersten 6 Tagen sollte der "Absolvent" das Tutorial von 
vhdl-online.de lesen sowie sich etwas vertraut machen mit ISE WebPack.
Im 2. Teil sollten etwa 3 Übungen gemacht werden (die ich gerade am 
ausarbeiten bin). Zu guter letzt soll ein eigenes Projekt erstellt 
werden (das StarterKit hat genug Features ;)).

Theorie für die ersten 6 Tage gibt es genug - muss ich mal auch noch 
etwas anpassen.

Nun die Übungen:

1. Mit den Schaltern einzeln LED's ansteuern.

2. Mit Schaltern verschieden Frequenzen einstellen. Bei 2 Schaltern ein 
Reset (etwa so wie das vorhergehende "Programm" von mir).

3. Ein "Lauflicht" oder eben Schieberegister mit dem "Rotary Push-Button 
Switch".


so genug geschrieben. Vllt habt ihr da andere Ideen oder 
Änderungsvorschläge.

Dass ich am Ende des Monats die Programmiersprache voll beherrsche, 
denke ich weniger, denn in naher Zukunft werde ich kaum die Möglichkeit 
haben, FPGA's zu programmieren.


mfG

p.s.: die 3.eler sowie ich besitzen nur C sowie etwas Digi-techkunde.

[Falk B. (falk)]

@  Dave E. (eschlair)

>Mir, Elektroniker 4.LJ, wurde von einem Mitarbeiter (der sich mit VHDL
>und Co auskannte) der Auftrag erteilt, für die kommenden Lehrlinge (3
>LJ) einen "1-monatigen Kurs" - ~12 Tage exklusiv Schule - in diesem
>Gebiet zu erstellen.
>Bevor der Mitarbeiter an die ETH ging,

Er ist also nicht mehr da, und du hast die Augabe geerbt? Kannst du mir 
sagen, wie jemdand wie du, der von VHDL auch keine Ahnung hat, einen 
Cras-Kurs über VHDL erstellt werden soll?
Ist euer Chef sooo dämlich?

>Mein Konzept:
>In 12 Tagen kann man nicht all zu viel machen. Der Kurs sollte auch nur
>einen kleinen Einblick in die Welt von VHDL geben.

Guter Ansatz.

>In den ersten 6 Tagen sollte der "Absolvent" das Tutorial von
>vhdl-online.de lesen sowie sich etwas vertraut machen mit ISE WebPack.

Das Lesen würde ich als Vorbereitung sehen wollen und NICHT in die 
wertvollen Unterrichtsstunden packen.

>Im 2. Teil sollten etwa 3 Übungen gemacht werden (die ich gerade am
>ausarbeiten bin). Zu guter letzt soll ein eigenes Projekt erstellt
>werden (das StarterKit hat genug Features ;)).

Und welche grundlagen sind vorhanden? Ich wiederhole mich. Ohne 
Digitaltechnik-Grundlagen wird das nur Murks.

>Theorie für die ersten 6 Tage gibt es genug

Die gibt es für 6 Monate genug. Und wir reden ja hier von Lehrlingen, 
nicht Studenten!

>1. Mit den Schaltern einzeln LED's ansteuern.

Hello Word, ist wichtig! Um den gesamten Datendurchlauf durch die Tools 
kennenzulernen und zu prüfen.

>2. Mit Schaltern verschieden Frequenzen einstellen.

Du meinst Blinkfreqeunzen. OK.

>Bei 2 Schaltern ein
>Reset (etwa so wie das vorhergehende "Programm" von mir).

Prinzipiell ja, aber inhallich sicher NICHT!

>3. Ein "Lauflicht" oder eben Schieberegister mit dem "Rotary Push-Button
>Switch".

Lauflicht ja, Rotary Push-Button klingt in diesem Rahmen schon als Creme 
de la Creme
Man könnte vorher vielleicht ne Ampel programmieren.

>Dass ich am Ende des Monats die Programmiersprache voll beherrsche,
>denke ich weniger,

Richtig, eher viel weniger.

> denn in naher Zukunft werde ich kaum die Möglichkeit
>haben, FPGA's zu programmieren.

Das ist kaum die Begründung dafür.

>p.s.: die 3.eler sowie ich besitzen nur C sowie etwas Digi-techkunde.

Was ist " etwas Digi-techkunde"?

MFG
Falk

P.S. Wer von den verantwortlichen Deppen glaubt eigentlich, dass jemand 
im 4. Lehrjahr Stoff dem 3. Lehrjahr vermitteln kann, den er nimmer 
selbst gelernt hat? Kopfschüttelnd

[D. E. (eschlair)]

>Er ist also nicht mehr da, und du hast die Augabe geerbt?

Nein, er hat mir die Aufgabe gegeben. Er war übrigens mein 
Abteilungschef. Die 2. Person der Firma, die was von VHDL verstanden 
hätte, ist mein ehemaliger -pensionierter- Chef...


>Das Lesen würde ich als Vorbereitung sehen wollen und NICHT in die
>wertvollen Unterrichtsstunden packen.

;) ne keine Unterrichtsstunden. Ganz normales arbeiten.


>Und welche grundlagen sind vorhanden? Ich wiederhole mich. Ohne
>Digitaltechnik-Grundlagen wird das nur Murks.

..hm..ja, sorry. ich weiss was and, nand, exor etc. kann auch ein 
KV-Diagramm erstellen. Wahrheitstabelle, Signal-Zeit-Plan, 
Funktionsgleichungen...In der Schule haben wir gerade Kommutativ-, 
Assoziativ-, Distributiv-, De Morgansche.... Gesetze.


>> denn in naher Zukunft werde ich kaum die Möglichkeit
>>haben, FPGA's zu programmieren.
>
>Das ist kaum die Begründung dafür.

Also ganz ehrlich...ein StarterKit hab ich noch bei mir zu Hause...;) - 
vorübergehend versteht sich. Dennoch in der Freizeit würde ich lieber 
LED's löten ;)!


>P.S. Wer von den verantwortlichen Deppen glaubt eigentlich, dass jemand
>im 4. Lehrjahr Stoff dem 3. Lehrjahr vermitteln kann, den er nimmer
>selbst gelernt hat? *Kopfschüttelnd*

Das Projekt muss ja nicht unbedingt vollendet sein. Hab noch einen 
Mitstift ;)...

mfg

[Falk B. (falk)]

@ Dave E. (eschlair)

>Nein, er hat mir die Aufgabe gegeben. Er war übrigens mein

Aber er ist nicht mehr da. Und du kannst kein VHDL. Und sollst dennoch 
den kurs als Lehrkraft machen?

>;) ne keine Unterrichtsstunden. Ganz normales arbeiten.

???
Ich denke das soll eine Lehrveranstaltung sein? Was soll dann "Ganz 
normales Arbeiten" sein? Entwickeln die Lehrlinge jetz mal fix dem 
Pentium 5 im Praktikum?

>..hm..ja, sorry. ich weiss was and, nand, exor etc. kann auch ein
>KV-Diagramm erstellen. Wahrheitstabelle, Signal-Zeit-Plan,
>Funktionsgleichungen...In der Schule haben wir gerade Kommutativ-,
>Assoziativ-, Distributiv-, De Morgansche.... Gesetze.

Na das klingt doch schon mal ziemlich gut. Fehlt noch ein wenig über 
State Machines und man kann damit was anfangen.

>Das Projekt muss ja nicht unbedingt vollendet sein. Hab noch einen
>Mitstift ;)...

Ahhh, der erbt dann wieder ganz überaschen . . . Ohje!!!
Dst das die neue Sparwelle? Kompetente Lehrer sind schon lange zu teuer, 
also lassen wir mal die Stifte ran. Wenns nicht real wäre würde ich 
jetzt lachen :-(

MFG
Falk

[(VHDL) Ausbilder Schmidt (Gast)]

@FPGA Kuechle
"Sorry aber das ist umständliche und langsame Hardware, 3 adder und ein
größer als Vergleicher! Die Schleife mag zwar für ein Programm auf einer
CPU besser sein, aber nicht in Hardware. Und die synthese ist noch nicht
soweit, das selber aus den Code-gebrabbel aus Addern etc erkennt, das
hier ein 1 aus 4 Coder gemeint ist. Wahrscheinlich baut sie eine Kette
aus 2 Fulladder und einem vergleicher. Also 3 Logiclevel. Dabei brauchst
nur eine
Lookuptable also einen Logiclevel.
Auch wenn es langsam langweilig wird, man programmiert nicht VHDL (wie
C) sondern man baut Hardware mit VHDL. Also formuliert man die Aufgabe
in Hardware (Blockdiagramm) und schreibt dann denn code."

so ist das also, Du enttäuschst mich. Aus Deinen Beiträgen hatte ich 
bisher auf einiges FPGA-Know-How geschlossen. Damit hast Du das 
Gegenteil bewiesen.
> Lusche <
gib den VHDL-Code (unten) dem ISE9.2 als Futter und sie wird
GENAU 1 (in Worten EINE) LUT4 generieren !
Wo sind Deine 3 Adder, die langsame, umständliche Hardware?
Wenn man nichts weiß, sollte man nichts schreiben!
Die Devise heißt heute: lesbaren Code schreiben, nicht nur in Bits
denken!

  signal sw_q : std_logic_vector(3 downto 0);
begin
  process(rst,clk)
    variable sw_cnt : integer range 0 to 4;
  begin
    if rst='1' then
      sw_q <= (others=>'0');
    elsif rising_edge(clk) then
      sw_cnt := 0;
      sw_q <= sw;

      for i in 0 to 3 loop
        if sw_q(i)='1' then
          sw_cnt := sw_cnt+1;
        end if;
      end loop;

      if sw_cnt > 1 then
        err <= '1';
      else
        err <= '0';
      end if;

    end if;
  end process;

[Jan M. (mueschel)]

Ja natürlich passt das in eine einzige LUT, der ganze Zähler wird 
einfach rausoptimiert, weil er überhaupt nicht gebraucht wird...

[high_speed (Gast)]

Ein gutes Buch zum Thema ist:

VHDL-Synthese. Entwurf digitaler Schaltungen und Systeme
http://users.etech.fh-hamburg.de/users/reichardt/buch_rt.html
http://www.amazon.de/VHDL-Synthese-Entwurf-digitaler-Schaltungen-Systeme/dp/3486581929

Die Vergleicher mit den Zählern haben unterschiedliche Bitbreiten.
Wenn der Vektor 24 bit breit ist, sollte er auch immer mit 24 bit 
verglichen
werden.

if test = "00011111" then

Desweiteren würde ich den Zähler einfach durchlaufen lassen und je nach
Schalterstellung ein anderes Bit als Quelle nehmen.


MfG
Holger

[D. E. (eschlair)]

>Ahhh, der erbt dann wieder ganz überaschen . . . Ohje!!!
>Dst das die neue Sparwelle? Kompetente Lehrer sind schon lange zu teuer,
>also lassen wir mal die Stifte ran. Wenns nicht real wäre würde ich
>jetzt lachen :-(

Vergiss das Wort Schule. Und auch Lehrer. Es gibt nur Lehrmeister und 
(Lehrlings)Abteilungsleiter. Mit dem Lehrmeister hast du fast nichts zu 
tun. Und das ganze in einer normalen Firma wie z.B.: Siemens....egal.

wenn du Wissen möchtest, was wir so machen -> www.selectron.ch

Dennoch vermisse ich den kompetenten Ausbildner.


werd mich sicher melden in den nächsten 14 Tagen...;)

mfG

[thomas (Gast)]

Also die Sache mit den Schleifen ist eigentlich ganz fein ( von 
Ausbilder Schmidt ) ... aber warum macht ihr es so kompliziert ?

Wenn mehr als 1 Schalter eingeschaltet ist, soll ein LED leuchten ... 
das kann man doch auch umformulieren, oder ? Wenn keiner oder genau 1 
Schalter an ist, dann leuchte eben nicht ;)

signal asdf : std_logic_vector( 3 downto 0 );

asdf <= F1 & F2 & F3 & F4;

if ( asdf = "0000" or asdf = "1000" or asdf = "0100" or asdf = "0010" or asdf = "0001" ) then
    -- LED aus
else
    -- LED an
end if;

[(VHDL) Ausbilder Schmidt (Gast)]

@thomas

natürlich geht das, viele Wege führen nach Rom. Es gibt kleine, aber 
feine
Unterschiede. Du schreibst den Code wie von Dir vorgeschlagen.
Am nächsten Tag merkst Du, dass noch 2 Schalter mehr benötigt werden 
oder
Dein Ausbilder sagt Dir das. In Deinem Bsp. musst Du in die Zeile 
reingehen
und alle 5 Konstanten anpassen. Dazu kommen jetzt noch die neuen 
Varianten
durch 2 zusätzliche Schalter. Du musst genau aufpassen, dass alle Einsen
und Nullen an der richtigen Position stehen.
In meinem Code mit der Loop muss ich nur noch den Vektor mit den 
Schaltern
breiter machen, alles übrige muss nicht angefasst werden, vorausgesetzt
ich habe es so geschrieben:
...
variable sw_cnt : integer range 0 to sw_q'HIGH+1;
...
for i in 0 to sw_q'HIGH loop
...

wer hat nun eher Feierabend?

[Falk B. (falk)]

@ Dave E. (eschlair)

>wenn du Wissen möchtest, was wir so machen -> www.selectron.ch
>Dennoch vermisse ich den kompetenten Ausbildner.

"Gerne helfen wir Ihnen mit gut ausgebildeten Ingenieuren bei der 
Definition der optimalen Systemarchitektur und der erfolgreichen 
Umsetzung Ihrer zukünftigen Lösungen."

Jaja, das Marketinggefasel. :-(

MFg
Falk

[thomas (Gast)]

Wahrscheinlich du ^^
Wenn das ganze flexibel gestaltet sein soll, ist deine Variante 
natürlich besser.
Für ein Einsteigerseminar in VHDL kann aber auch ein wenig Aussagenlogik 
nicht schaden.

Also dann, schönen Feierabend :P

[Karl (Gast)]

Dann mach mal aus der doch relativ trivialen Aufgabe z.B. ein majority 
gate mit 20 oder 30 Eingängen. Mal sehen, ob das die Synthese auch noch 
(so) schön hinbekommt (wie man es mit manueller Optimierung machen 
könnte). Bei Arithmetik in Schleifen gingen bis jetzt zu Recht die 
Warnlampen an. Mag sein, dass es ein Synthesizer kann, ein anderer 
nicht. Trotzdem kein Grund beleidigend zu werden.

[(VHDL) Ausbilder Schmidt (Gast)]

Karl,

hast recht, bei majority mit 30 Eingängen tut sich der XST schwer, hier
muss etwas vorgekaut werden, damit die Slices nicht das FPGA sprengen.
Wenn man z.B. eine 3er-majority als Basis nimmt, kann man damit
wieder durch Loops gehen und sich bis zum Ausgang "durchiterieren",
das geht. Wenn man das geschickt schreibt, bleibt es auch noch lesbar.

[Fpgakuechle K. (Gast)]

(VHDL) Ausbilder Schmidt wrote:

> so ist das also, Du enttäuschst mich. Aus Deinen Beiträgen hatte ich
> bisher auf einiges FPGA-Know-How geschlossen. Damit hast Du das
> Gegenteil bewiesen.
>> Lusche <
> gib den VHDL-Code (unten) dem ISE9.2 als Futter und sie wird
> GENAU 1 (in Worten EINE) LUT4 generieren !
> Wo sind Deine 3 Adder, die langsame, umständliche Hardware?
> Wenn man nichts weiß, sollte man nichts schreiben!
> Die Devise heißt heute: lesbaren Code schreiben, nicht nur in Bits
> denken!

Ich vergess mal die Beleiigungen und schalt selber ein paar Gänge 
zurück.
Die Variante von thomas ist richtig. man kann das auch noch klarer 
schreiben:

<vhdl>
signal asdf : std_logic_vector( 3 downto 0 );

asdf <= F1 & F2 & F3 & F4;

err <= '0' when (asdf = "0000") or
                (asdf = "1000") or
                (asdf = "0100") or
                (asdf = "0010") or
                (asdf = "0001" )
                    else '1';
 </vhdl>

Es ist wie gesagt ein Coder, kein Adder. Die synthese ist nicht 
standardisiert, wenn die XST 9.2 schlau genug ist eine LUT daraus zu 
bauen
Glück gehabt. Andere Synthesetool sehen das bestimmt anders und setzten 
stur + mit Adder um und > mit einem Comperator. das kann natürlich auch 
so gewollt sein, keine LUT sondern die Carry chain zu nutzen. jetzt 
probiere ich mal mit der 9.2 aus, mal sehen welcher compilerschalter die 
Optimierung veranlasst. Hat du den falschen gesetzt -> Dann nix mit 
einer LUT.

Es mar zwar clever aussehen, code um die Ecke zu schreiben, aber man 
macht sich von der nichtstandardisierten Synthese abhängig. Wird also 
tool abhängig.

[D. E. (eschlair)]

><vhdl>
>signal asdf : std_logic_vector( 3 downto 0 );
>
>asdf <= F1 & F2 & F3 & F4;
>
>err <= '0' when (asdf = "0000") or
>                (asdf = "1000") or
>                (asdf = "0100") or
>                (asdf = "0010") or
>                (asdf = "0001" )
>                    else '1';
></vhdl>

Nun hab ich diese when-Schlaufe eingefügt - wohl mit folgendem Fehler:

Line 67. parse error, unexpected WHEN, expecting SEMICOLON


unerwartet WHEN, erwartet SEMICOLON...?

[Fpgakuechle K. (Gast)]

Aehm, dieses Konstrukt (conditional assignment) kann nicht innerhalb 
eines Prozesses verwendet werden. Ist vielleicht das Dein problem? Und 
es ist keine When schlaufe, sondern eine bedingte Signalzuweisung, nicht 
mit case oder select verwechseln (auch da gibt es when).

[esch (Gast)]

>Aehm, dieses Konstrukt (conditional assignment) kann nicht innerhalb
>eines Prozesses verwendet werden. Ist vielleicht das Dein problem?

sowas in der Art. Nun habe ich "case" benützt - geht auch.

Doch nun zum Schieberegister. VHDL soll "hardwareähnlich" geschrieben 
werden. Ein Schieberegsiter = 8 Flip-Flop. 1 Flip-Flop = 4x NAND...das 
gäbe: (bei 2 Ausgängen).
Z1 <= S nand clk;
Z2 <= clk nand R;
Z3 <= Z4 nand Z2;
Z4 <= Z3 nand Z1;
Z5 <= Z4 nand clk;
Z6 <= clk nand Z3;
Z8 <= Z5 nand Z7;
Z7 <= Z8 nand Z6;
LED0 <= Z4;
LED1 <= Z8;

ist das nun wirklich so gemeint? Wie wirds richtig gemacht?



im Anhang ist der bereits gepostete Code - etwas abgeändert...
mfG

[Falk B. (falk)]

@  esch (Gast)

>Doch nun zum Schieberegister. VHDL soll "hardwareähnlich" geschrieben
>werden. Ein Schieberegsiter = 8 Flip-Flop. 1 Flip-Flop = 4x NAND...das

???

>gäbe: (bei 2 Ausgängen).
>Z1 <= S nand clk;
>Z2 <= clk nand R;
>Z3 <= Z4 nand Z2;
>Z4 <= Z3 nand Z1;
>Z5 <= Z4 nand clk;
>Z6 <= clk nand Z3;
>Z8 <= Z5 nand Z7;
>Z7 <= Z8 nand Z6;
>LED0 <= Z4;
>LED1 <= Z8;

Was soll das?

>ist das nun wirklich so gemeint? Wie wirds richtig gemacht?

Komm drauf an, WAs du machen willst.

>im Anhang ist der bereits gepostete Code - etwas abgeändert...

Ziemlich viel Text für eine mir unklare Funktion. Aber es ist ja auch 
sehr sinnvoll, Leerveranstaltungen von Azubis ausarbeiten zu lassen . . 
. (nein, kein Rechtschreibfehler)

MFG
Falk

[esch (Gast)]

hm, sorry vergiss es einfach. (es sollte ein 2-bit schieberegister sein 
- mit einzelnen NAND-Gattern).
dann muss ich anders fragen (solange meine Posts noch nicht unter Rubrik 
spam gehen...).

Wie sieht ein 8-bit Schieberegister in VHDL aus, das auf positive 
Flanken getriggert ist?
Also sobald ein Impuls da ist, wird geschoben.

mfG

[Falk B. (falk)]

@ esch (Gast)

>hm, sorry vergiss es einfach. (es sollte ein 2-bit schieberegister sein
>- mit einzelnen NAND-Gattern).

Das macht man nicht, auch nicht zu Übungszwecken. Das ist akademischer 
Unsinn.

>dann muss ich anders fragen (solange meine Posts noch nicht unter Rubrik
>spam gehen...).

Naja . . .

>Wie sieht ein 8-bit Schieberegister in VHDL aus, das auf positive
>Flanken getriggert ist?

Das ist doch mal was.

signal shift: std_logic_vector(7 downto 0);

process(clk)
begin
  if rising_edge(clk) then
    shift <= shift(6 downto 0) & data_in;  -- links schieben
--    shift <= data_in & shift(7 downto 1);  -- rechts schieben
  end if;
end process;

data_in und clk sind logischerweise Eingangssignale.

MfG
Falk

[na (Gast)]

Hallo Dave,

Also, du denkst hier ein wenig auf der falschen "Ebene" der Hardware. 
Man KANN in VHDL zwar mit NANDS und anderen logischen Funktionen alles 
mögliche wie Schieberegister, Multiplexer usw. realsieren, aber das ist 
nicht ganz Sinn und Zweck der Sache (für manche Spezialfälle bietet es 
sich an).

Wenn du dich mit VHDL beschäftigst, solltest du erstmal auf RT-Ebene 
bleiben. Das heißt du denkst in Elementen wie Registern, FIFOs, 
Multiplexern und ab und zu mal ein paar Gatter. Außerdem ist das 
Verständnis sequentieller Logik, z.B. für Zustandsautomaten (Finite 
state machine - FSM), wichtig.

Ein Schieberegister zum Beispiel. Zuerst einmal ein Register an sich und 
der Wert, der pro Takt reingeschoben werden soll:

-- Signal 1 Byte Breite, Achtung: das ist ohne weitere Beschreibung noch kein Register
signal schieberegister : std_logic_vector(7 downto 0);

-- Signal 1 Bit Breite
signal register_input : std_logic;

Damit ein Register daraus wird, muss das ganze in einen taktsensitiven 
Prozess, wie Falk das bereits geschrieben hat. In VHDL ist ein Prozess 
sozusagen ein Stück Hardware. Daher arbeiten alle Prozesse gleichzeitig. 
Mit taktsensitiven Prozessen kann man Register bauen (ein Register 
reagiert nur auf den takt und evtl. reset), bei Prozessen ohne Takt 
entsteht reine Kombinatorik (dann müssen alle abhängigen Größen in die 
Sensitivitätsliste).

-- taktsensitiver Prozess: reagiert NUR auf clk
SCHIEBEREGISTER_PROCESS: process(clk)
begin
-- Reaktion auf steigende Flanke  
  if (clk'event and clk = '1') then
-- Wert wird "von rechts nach links" geschoben    
    schieberegister(7 downto 0) <= schieberegister(6 downto 0) & register_input;
  end if;
end process;

Du kannst in anderen Prozessen (oder im selben) lesend auf das 
Schieberegister zugreifen. Es darf aber nicht in anderen Prozessen 
geschrieben werden (da du dann dasselbe Register zweimal bauen würdest).

Andere Elemente lassen sich ebenfalls einfach beschreiben, es ist nur 
eben wichtig, dass man vorher weiß, wie am Ende der Datenpfad aussehen 
sollte bzw. der Ablauf über eine FSM gesteuert werden soll.
Ein Multiplexer ist z.B. ein einfaches case (oder auch if) statement. Du 
kannst dir bei ISE einfach anschauen, was produziert wird, indem du auf 
"View RTL-schematic" klickst. Du kannst ja zur Übung mal einen 
Multiplexer mit zwei 1-bit-Eingängen bauen und deinen Code hier posten. 
Einmal mit case oder if und einmal über Gatter (also sozusagen eine 
gedankliche Ebene tiefer, Tipp:

$$y = x_1\cdot sel + x2\cdot !sel$$

ist ein rein kombinatorischer Prozess).
Wenn du das verstanden hast, welche Anweisung in VHDL welche Hardware 
entstehen lässt, kannst du dich mit Zustandsautomaten beschäftigen.
So würde ich vom generellen Ablauf her auch eine Lehrveranstaltung 
aufbauen.

[esch (Gast)]

Wie kann man 2 Dateien gleichzeitig anhängen?

Also hier mal die 2 Varianten.

@na
sorry kann deinen Tipp nicht lesen.


>Wenn du das verstanden hast, welche Anweisung in VHDL welche Hardware
>entstehen lässt, kannst du dich mit Zustandsautomaten beschäftigen.

Zustandsautomaten?

mfG

[D. E. (eschlair)]

2. variante

[Falk B. (falk)]

@ esch (Gast)

>Wie kann man 2 Dateien gleichzeitig anhängen?

Geht nicht. Entweder mehrere Posts oder als ZIP File

>Zustandsautomaten?

Finite State Machines. Quasi Programmabläufe in Hardware.

Die erste Variante ist OK, die zweite Unsinn.

MFg
Falk

[D. E. (eschlair)]

klar.
1. Variante "normal", 2, Variante <<sozusagen eine
gedankliche Ebene tiefer>>

>Quasi Programmabläufe in Hardware.

etwa wie state event...

hast du gerade ein gutes Beispiel auf Lager?

vllt Schrankenautomat oder Geldautomat

[Falk B. (falk)]

@ Dave E. (eschlair)

>1. Variante "normal", 2, Variante <<sozusagen eine
>gedankliche Ebene tiefer>>

Naja, da willst du was auch UND Gattern bauen. und nebenbei erhält dein 
MUX noch einen Takt zusätzliche Verzögerung ;-)

>etwa wie state event...

???

>hast du gerade ein gutes Beispiel auf Lager?

Nein.

>vllt Schrankenautomat oder Geldautomat

Das ist ja nicht gerade der richtige Einstieg, viel zu komlex. Mach 
erstmal was einfaches, sowas wie ein steuerbares Lauflicht oder so.

MFG
Falk

[Volker (Gast)]

Falk wrote:
> Die erste Variante ist OK,

Das sehe ich nicht so. Meiner Meinung nach muß in der Sensitivity Liste
"CLK" eingetragen sein und nicht SO,E0, E1.
Es handelt sich um einen getakteten Prozeß und nicht um reine 
Kombinatorik.


begin
  --process (S0, E0, E1) falsch
    process (CLK) --richtig
  begin
    if CLK'event and CLK='1' then
      if S0 = '0' then
        LED <= E0;
      else
        LED <= E1;
      end if;
    end if;
  end process;
end Behavioral;

Gruß Volker

[Falk B. (falk)]

@ Volker (Gast)

>> Die erste Variante ist OK,

>Das sehe ich nicht so. Meiner Meinung nach muß in der Sensitivity Liste
>"CLK" eingetragen sein und nicht SO,E0, E1.

Uuups, das hab ich wohl übersehen. Entschuldigung.

MFG
Falk

[na (Gast)]

Ja, so fast ist das richtig. Entweder den Multiplexer ganz ohne Takt 
beschreiben (ohne clk'event usw., dann entsteht reine Kombinatorik, alle 
signale müssen in die sensitivity list, kein clk!) oder nur mit Takt in 
der sensitivity list (dann arbeitet dein Multiplexer sequentiell). Diese 
zwei Arten von Prozessen musst du grundsätzlich unterscheiden!

Zustandsautomaten sind der nächste Schritt. Ein Beispiel für eine 
Zustandsmaschine mit zwei Zuständen, die zwei Schalter für die Funktion 
einer LED auswertet. Das ist nur eine Möglichkeit, in VHDL führen öfter 
mehrere Wege zum selben Ergebnis. Man muss sich dann überlegen, ob man 
etwas möglichst schnell, möglichst platzsparend oder wie auch immer 
bauen will.

type STATE is (ZUSTAND_1, ZUSTAND_2);
signal zustand : STATE;
.
.
.

SYNC_FSM: process (clk, a_reset_l)
begin

  if (a_reset_l = '0') then   -- ein asynchrones reset, low aktiv
    zustand <= ZUSTAND_1; 
    led <= '0';

  elsif (clk'event and clk = '1') then   -- steigende Flanke
  
   case (zustand) is    -- Zustandsunterscheidung der FSM
------------------------------------------      
     when ZUSTAND_1 =>

       if (schalter_1 = '1') then -- Schalterstellung 1 aus, 0 an
         led <= '0';
       else
         led <= '1';
       end if;

       -- Zustandsübergang (kann von verschiedenen Eingangssignalen abhängig    
       -- sein und in verschiedene Zustände wechseln, hier: Schalter 2)
       if (schalter_2 = '1') then 
         zustand <= ZUSTAND_2;
       else
         zustand <= ZUSTAND_1;
       end if;
------------------------------------------
     when ZUSTAND_2 =>

       if (schalter_1 = '1') then -- Schalterstellung 1 an, 0 aus
         led <= '1';
       else
         led <= '0';
       end if;

       if (schalter_2 = '1') then
         zustand <= ZUSTAND_2;
       else
         zustand <= ZUSTAND_1;
       end if;
------------------------------------------        
     when others => NULL;

   end case;
  end if;  
end process;

Was hier klar sein muss, "zustand" und "led" werden als Register gebaut. 
Es sind damit Speicherelemente, die den Wert nur bei steigender 
Taktflanke übernehmen. Nützlich zum Beispiel auch für Zähler.
Wenn du Lust hast, kannst du ja zur Übung eine FSM bauen, die in einem 
Zustand bis zu einem Wert zählt und dann in den nächsten geht, dort 
wieder zählt und zurückgeht. Oder auch mit paar mehr Zuständen und 
Bedingungen. Probiers mal aus.