mikrocontroller.net

Forum: FPGA, VHDL & Co. Finite-State-Machine


Autor: VHDL-Beginner (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo nochmals,

ich habe noch eine Frage bezüglich der Automaten in VHDL:

Wie kann man bei den verschiedenen Automaten, den Automaten nach
Einspeisung des Boards mit Spannung in einem Vorgegebenen Zustand
aufwachen lassen?

Eine ähnliche Frage gabs schon mal, aber ich bin mir immer noch nicht
sicher, ob die Antwort für alle Automaten gilt.

Danke


Moore:

architecture RTL of MOORE_TEST is
    signal STATE,NEXTSTATE : STATE_TYPE ;
begin
    REG: process (CLK, RESET) begin
       if RESET=`1` then   STATE <= START ;
       elsif CLK`event and CLK=`1` then
           STATE <= NEXTSTATE ;
       end if ;    end process REG ;
    CMB: process (A,B,STATE) begin
       NEXTSTATE <= STATE ;
       case STATE is
          when START  => if (A or B)=`0` then
                            NEXTSTATE <= MIDDLE ;
                         end if ;
          when MIDDLE => if (A and B)=`1` then
                            NEXTSTATE <= STOP ;
                         end if ;
          when STOP   => if (A xor B)=`1` then
                            NEXTSTATE <= START ;
                         end if ;
          when others => NEXTSTATE <= START ;
          end case ;     end process CMB ;
    -- concurrent signal assignments for output
    Y <= ,1` when STATE=MIDDLE else ,0` ;
    Z <= ,1` when STATE=MIDDLE
               or STATE=STOP else ,0` ;
end RTL ;

Medvedev:

architecture RTL of MEDVEDEV_TEST is
    signal STATE,NEXTSTATE : STATE_TYPE ;
begin
    REG: process (CLK, RESET) begin
       if RESET=`1` then STATE <= START ;
       elsif CLK`event and CLK=`1` then
          STATE <= NEXTSTATE ;
       end if ;
    end process REG;
    CMB: process (A,B,STATE) begin
       NEXTSTATE <= STATE ;
       case STATE is
          when START  => if (A or B)=`0` then
                            NEXTSTATE <= MIDDLE ;
                         end if ;
          when MIDDLE => if (A and B)=`1` then
                            NEXTSTATE <= STOP ;
                         end if ;
          when STOP   => if (A xor B)=`1` then
                            NEXTSTATE <= START ;
                         end if ;
          when others => NEXTSTATE <= START ;
       end case ;
    end process CMB ;
    -- concurrent signal assignments for output
    (Y,Z) <= STATE ;
end RTL ;


Mealey:

architecture RTL of MEDVEDEV_TEST is
    signal STATE,NEXTSTATE : STATE_TYPE ;
begin
    REG: process (CLK, RESET) begin
       if RESET=`1` then
          STATE <= START ;
       elsif CLK`event and CLK=`1` then
          STATE <= NEXTSTATE ;
       end if ;
    end process REG;

    CMB: process (A,B,STATE) begin
       -- Like Medvedev and Moore Examples
    end process CMB ;

    -- concurrent signal assignments for output
    Y <= `1` when (STATE=MIDDLE and (A or B)=`0`)
               or (STATE=STOP and (A and B)=`0`)
             else `0` ;

    Z <= `1` when (STATE=START and (A and B)=`1`)
               or (STATE=MIDDLE)
               or (STATE=STOP and (A or B)=`1`)
             else `0` ;

end RTL ;

Autor: Tobias (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wahrscheinlich zielt deine Frage darauf ab, dass du ja nicht davon
ausgehen kannst das du den Reset per Hand gleich nach dem Einschalten
betätigst. Besitzt du evtl. ein FPGA-Entwicklungsboard mit Debug-LEDs,
dann kannst du ja mal folgenden Code probieren. Ein kleines FPGA-Board
ist sowieso zu empfehlen wenn man VHDL lernen möchte.


Ausgang: LED

in der Architecture vor Begin
signal sig_led : std_logic := '1'; -- probier das ganze auch mal mit
'0'
in der Architecture nach Begin
LED <= sig_led;

Bei der Deklaration des Signals kannst du einen Start-Wert zuweisen.
Dies ist dann der Wert des Signals, den das Signal nach dem Aufwachen
im FPGA annimmt. Damit kann man sich den Reset sparen, obwohl das nicht
ganz sauber ist. Hintergrund der Geschichte ist, dass der FPGA die
Flip-Flops mit einem Start-Wert während des Aufwachens versieht.

Du kannst dir natürlich auch einen Reset- Generator für dein ganzes
VHDL-Design bauen, indem du einen Zaeler beschreibst mit dem Startwert
null, der sofort nach dem Aufwachen hochzält. Solange der Wert des
Zaelers unterhalb einer bestimmten Grenze liegt wird Reset gesetzt
ansonsten nicht. Probier doch mal wenn du ein FPGA-Entwicklungsboard
besitzt den Reset-Generator aufzubauen ohne eine Vorinitialisierung des
Zäler-Signals. Der FPGA weist dem Zäler automatisch den Startwert
'0' zu.

Gruß Tobias

Autor: VHDL-Beginner (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Tobias,

einen FPGA-Entwicklungsboard besitze ich leider nicht. Ich habe mir
selber ein Board gebastelt, den ich verwende um VHDL zu lernen.

Dumme Frage:

Wo und wie sollte der Start-Wert in den obigen FSM´s als Beispiel
stehen, den das Signal nach dem Aufwachen im FPGA annimmt?

Autor: Thomas S. (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Tag,

ich habe auch ne Frage bezüglich Automaten. Seit kurzem lernen wir auch
VHDL in der Schule. Dieses Forum finde ich super, da die Leute auch an
Feiertagen antworten.

Ich würde gerne wissen, ob der untere Automat ohne einen Reset-Signal
starten kann oder nicht! Ruht diser bis überhaupt ein Reset kommt?

Gibt es überhaupt einen Zustand den der Automat ohne Reset-Signal
annehmen kann?

BEGIN
FSM: PROCESS(clk, reset)
BEGIN
IF(reset = '1') THEN
current_state <= S0;
co <= '0';
ELSIF(clk'EVENT AND clk = '1') THEN
-- co auf '0', nur in S3 überschreiben
co <= '0';
CASE current_state IS
WHEN S0 =>
IF(cnt = '1') THEN current_state <= S1; END IF;
WHEN S1 =>
IF(cnt = '1') THEN current_state <= S2; END IF;
WHEN S2 =>
IF(cnt = '1') THEN current_state <= S3; END IF;
WHEN S3 =>
IF(cnt = '1') THEN current_state <= S0;
co<='1'; END IF;
END CASE;
END IF;
END PROCESS FSM;
END counter_arch;

MFG Thomas

Autor: Tobias (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>Wo und wie sollte der Start-Wert in den obigen FSM´s als Beispiel
>stehen, den das Signal nach dem Aufwachen im FPGA annimmt?

Bei der Deklarierung deines Signals zum Bleistift:
signal STATE : STATE_TYPE := START;
Der Start wert sollte der Wert sein, den du auch bei Reset zuweisen
würdest.


@Thomas
>Ich würde gerne wissen, ob der untere Automat ohne einen Reset-Signal
>starten kann oder nicht!
Er startet auch ohne Reset, aber in einem undefinierten Zustand.
Deshalb empfiehlt sich immer eine when others => Anweisung in deine
switch-case Anweisung einfügen.

>Ruht diser bis überhaupt ein Reset kommt?
Nein. Er macht irgendetwas unvorhergesehenes.

>Gibt es überhaupt einen Zustand den der Automat ohne Reset-Signal
>annehmen kann?

Die Zustände werden im FPGA binär codiert. Er kann jeden Zustand
annehmen, der durch die Codierung der Zustände im FPGA erzeugt werden
kann.

Autor: Klaus Falser (kfalser)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Er startet auch ohne Reset, aber in einem undefinierten Zustand.
> Deshalb empfiehlt sich immer eine when others => Anweisung in deine
> switch-case Anweisung einfügen.
Jedes FPGA oder CPLD das ich kenne, startet in einem definierten
Zustand. Dieser Wert ist immer gleich, die Register (FF's) wachen
immer im gleichen Zustand auf.
Dies gilt für alle Teile der Schaltung, ob FSM oder nicht.
Es kann aber sein, daß die FF's in einer Stellung aufwachen, welche
nicht dem gewünschen Startzustand der FSM entspricht. Wie ich in einem
anderen Posting geschrieben habe, gibt es mehrere Möglichkeiten :

- Man verwendet einen RESET.
Ein Reset-Signal soll schon Hardware-seitig so implementiert sein, daß
es beim Einschalten aktiv ist, und erst wenn die ganze Schaltung
korrekt versorgt und betriebsbereit ist, dann wird es weggenommen. Dies
muß automatisch, von der Hardware geschehen. Ein Reset-Knopf zum
manuellen Rücksetzen ist nur ein optional.
Solange das Reset-Signal aktiv ist, wird der Start-Zustand erzwungen.

- Man sagt dem VHDL-Kompiler, in welchem Zustand die FF's aufwachen
sollen, indem man einen Init-Wert vorgibt, z.B.:
signal STATE : STATE_TYPE := START;
Dies wird aber nur von den neueren VHDL-Compilern beim Umsetzen in
Hardware berücksichtigt.
(Achtung : der VHDL-Compiler für die Synthese, nicht der
VHDL-Simulator. Der VHDL-Simulator kennt die Init-Werte schon immer).
Ältere VHDl-Compiler ignorieren den gewünschten Startwert, geben
bestenfalls eine Warnung aus und sind nicht imstande, die
Start-Stellund der FF's an den Fitter/Place&Route weiterzugeben.
Moderne VHDL-Compiler (jedenfalls der von Xilinx) versuchen auch eine
FSM-Erkennung, eventuell wird der Start-Zustand erkannt und die
Kodierung des Zustand an das Power-Up Verhalten des Bausteins
angepasst.

- Man versucht herauszufinden, wie der Start-Zustand kodiert ist, und
gibt dann diese Stellung der FF's selbst manuell in einem
Constraint-File vor.
Dieser Weg ist der Fehleranfälligste, nicht unbedingt empfehlenswert.

- Man weis, die FF's immer mit '0' aufwachen, und erzwingt eine
Kodierung der Zustande, bei dem der Start-Zustand aus lauter '0'
besteht.

Grüße
Klaus

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [vhdl]VHDL-Code[/vhdl]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.