Schlüsselwörter: Zustandsautomat, Verkaufsautomat

Der endliche Automat (Finite-State Machine, FSM), auch als Zustandsautomat bezeichnet, ist ein mathematisches Modell, das eine endliche Anzahl von Zuständen und die Verhaltensweisen wie Übergänge und Aktionen zwischen diesen Zuständen darstellt. Der Zustandsautomat ist nicht nur ein Werkzeug zur Schaltungsbeschreibung, sondern auch eine Denkweise und wird im Schaltungsentwurf auf Systemebene und RTL-Ebene häufig verwendet.

Typen von Zustandsautomaten

In Verilog werden Zustandsautomaten hauptsächlich beim Entwurf synchroner sequenzieller Logik eingesetzt und können die Zustände sequenzieller Schaltungen gemäß bestimmter Anforderungen und Regeln zwischen einer endlichen Anzahl von Zuständen umschalten. Die Richtung des Zustandswechsels hängt nicht nur von den Eingangswerten, sondern auch vom aktuellen Zustand ab. Zustandsautomaten lassen sich in 2 Kategorien einteilen: Moore-Zustandsautomaten und Mealy-Zustandsautomaten.

Zustandsautomat vom Moore-Typ

Der Ausgang eines Moore-Zustandsautomaten hängt nur vom aktuellen Zustand ab, nicht vom aktuellen Eingang.

Der Ausgang bleibt für einen vollständigen Taktzyklus stabil. Selbst wenn sich das Eingangssignal zu diesem Zeitpunkt ändert, ändert sich der Ausgang nicht. Der Einfluss des Eingangs auf den Ausgang kann sich erst im nächsten Taktzyklus widerspiegeln. Dies ist auch ein wichtiges Merkmal des Moore-Zustandsautomaten: Eingang und Ausgang sind voneinander isoliert.

Zustandsautomat vom Mealy-Typ

Der Ausgang eines Mealy-Zustandsautomaten hängt nicht nur vom aktuellen Zustand, sondern auch vom aktuellen Eingangssignal ab.

Der Ausgang eines Mealy-Zustandsautomaten ändert sich unmittelbar, nachdem sich das Eingangssignal ändert, und die Eingangsänderung kann innerhalb des Taktzyklus eines beliebigen Zustands auftreten. Daher ist bei gleicher Logik die Reaktion des Ausgangs des Mealy-Zustandsautomaten auf den Eingang um einen Taktzyklus früher als die des Moore-Zustandsautomaten.

Entwurfsablauf für Zustandsautomaten

Zeichnen Sie gemäß den Entwurfsanforderungen das Zustandsübergangsdiagramm, bestimmen Sie den zu verwendenden Typ des Zustandsautomaten und kennzeichnen Sie verschiedene Eingangs- und Ausgangssignale, was für die Programmierung hilfreicher ist. Im Allgemeinen ist der am häufigsten verwendete der Mealy-Zustandsautomat mit 3 Segmenten. Im Folgenden wird anhand eines konkreten Beispiels für die Entwicklung eines Verkaufsautomaten der Ablauf des Zustandsautomatentwurfs erläutert.

Automatischer Verkaufsautomat

Die Funktionsbeschreibung des automatischen Verkaufsautomaten lautet wie folgt:

Der Getränkepreis beträgt 2 Yuan. Der Verkaufsautomat kann nur Münzen zu 0.5 Yuan und 1 Yuan annehmen. Wechselgeld und Produktausgabe sind zu berücksichtigen. Der Münzeinwurf und die Produktausgabe erfolgen jeweils einzeln; es gibt keine Situation, in der mehrere Münzen auf einmal eingeworfen oder mehrere Flaschen Getränk auf einmal ausgegeben werden. Erst nachdem jede Runde des Verkaufsautomaten den Münzeinwurf, die Produktausgabe und die Wechselgeldausgabe abgeschlossen hat, kann er in einen neuen automatischen Verkaufszustand eintreten.

Das Arbeitszustandsübergangsdiagramm des Verkaufsautomaten ist unten dargestellt, einschließlich der Zustände der Eingangs- und Ausgangssignale.

Hier bedeutet coin = 1, dass eine 0.5-Yuan-Münze eingeworfen wird, und coin = 2 bedeutet, dass eine 1-Yuan-Münze eingeworfen wird.

Entwurf des Zustandsautomaten: 3-Segment-Stil (Empfohlen)

Der Entwurf des Zustandsautomaten ist wie folgt:

  • (0) Bestimmen Sie zunächst die Kodierung des Zustandsautomaten entsprechend der Anzahl der Zustände. Die Verwendung einer Kodierung zur Zuweisung von Werten zu Zustandsregistern verbessert die Lesbarkeit des Codes.
  • (1) Das erste Segment des Zustandsautomaten: sequenzielle Logik, nicht blockierende Zuweisung, um den Zustand des Registers zu übertragen.
  • (2) Das zweite Segment des Zustandsautomaten: kombinatorische Logik, blockierende Zuweisung, um den nächsten Zustand des Zustandsautomaten basierend auf dem aktuellen Zustand und der aktuellen Eingabe zu bestimmen.
  • (3) Das dritte Segment des Zustandsautomaten: sequenzielle Logik, nicht blockierende Zuweisung. Da es sich um einen Mealy-Zustandsautomaten handelt, bestimmen Sie das Ausgangssignal basierend auf dem aktuellen Zustand und der aktuellen Eingabe.

Beispiel

// Verkaufsautomat
// 2 Yuan für eine Flasche Getränk
// nur 2 Münzen unterstützt: 5 Jiao und 1 Yuan
// die Funktion des Verkaufens und Wechselns fertigstellen

module  vending_machine_p3  (
    input           clk ,
    input           rstn ,
    input [1:0]     coin ,     //01 für 0.5 Jiao, 10 für 1 Yuan

    output [1:0]    change ,
    output          sell    //das Getränk ausgeben
    );

    //Maschinenzustand dekodieren
    parameter            IDLE   = 3'd0 ;
    parameter            GET05  = 3'd1 ;
    parameter            GET10  = 3'd2 ;
    parameter            GET15  = 3'd3 ;

    //Maschinenvariable
    reg [2:0]            st_next ;
    reg [2:0]            st_cur ;

    //(1) Zustandsübergang
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            st_cur      <= 'b0 ;
        end
        else begin
            st_cur      <= st_next ;
        end
    end

    //(2) Zustandswechsel, unter Verwendung blockierender Zuweisung für Kombinationslogik
    //alle case-Elemente müssen vollständig angezeigt werden    
    always @(*) begin
        //st_next = st_cur ;//Wenn die Bedingungsoptionen nicht vollständig berücksichtigt werden, können Sie einen Anfangswert zuweisen, um ein Latch zu eliminieren
        case(st_cur)
            IDLE:
                case (coin)
                    2'b01:     st_next = GET05 ;
                    2'b10:     st_next = GET10 ;
                    default:   st_next = IDLE ;
                endcase
            GET05:
                case (coin)
                    2'b01:     st_next = GET10 ;
                    2'b10:     st_next = GET15 ;
                    default:   st_next = GET05 ;
                endcase

            GET10:
                case (coin)
                    2'b01:     st_next = GET15 ;
                    2'b10:     st_next = IDLE ;
                    default:   st_next = GET10 ;
                endcase
            GET15:
                case (coin)
                    2'b01,2'b10:
                               st_next = IDLE ;
                    default:   st_next = GET15 ;
                endcase
            default:    st_next = IDLE ;
        endcase
    end

    //(3) Ausgangslogik unter Verwendung nicht blockierender Zuweisung
    reg  [1:0]   change_r ;
    reg          sell_r ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            change_r       <= 2'b0 ;
            sell_r         <= 1'b0 ;
        end
        else if ((st_cur == GET15 && coin ==2'h1)
               || (st_cur == GET10 && coin ==2'd2)) begin
            change_r       <= 2'b0 ;
            sell_r         <= 1'b1 ;
        end
        else if (st_cur == GET15 && coin == 2'h2) begin
            change_r       <= 2'b1 ;
            sell_r         <= 1'b1 ;
        end
        else begin
            change_r       <= 2'b0 ;
            sell_r         <= 1'b0 ;
        end
    end
    assign       sell    = sell_r ;
    assign       change  = change_r ;

endmodule

Das Testbench-Design ist wie folgt. In der Simulation werden vier Szenarien simuliert, nämlich:

case1 entspricht dem Einwerfen von vier 0.5-Yuan-Münzen nacheinander; case2 entspricht der Münzeinwurfreihenfolge 1 Yuan - 0.5 Yuan - 1 Yuan; case3 entspricht der Reihenfolge 0.5 Yuan - 1 Yuan - 0.5 Yuan; case4 entspricht der Reihenfolge von drei aufeinanderfolgenden 0.5-Yuan-Münzen, gefolgt von einer 1-Yuan-Münze.

Beispiel

`timescale 1ns/1ps

module test ;
    reg          clk;
    reg          rstn ;
    reg [1:0]    coin ;
    wire [1:0]   change ;
    wire         sell ;

    //Takterzeugung
    parameter    CYCLE_200MHz = 10 ; //
    always begin
        clk = 0 ; #(CYCLE_200MHz/2) ;
        clk = 1 ; #(CYCLE_200MHz/2) ;
    end

    //Motivation erzeugen
    reg [9:0]    buy_oper ; //Zustand des Kaufvorgangs speichern
    initial begin
        buy_oper  = 'h0 ;
        coin      = 2'h0 ;
        rstn      = 1'b0 ;
        #8 rstn   = 1'b1 ;
        @(negedge clk) ;

        //Fall(1) 0.5 -> 0.5 -> 0.5 -> 0.5
        #16 ;
        buy_oper  = 10'b00_0101_0101 ;
        repeat(5) begin
            @(negedge clk) ;
            coin      = buy_oper[1:0] ;
            buy_oper  = buy_oper >> 2 ;
        end

        //case(2) 1 -> 0.5 -> 1, Wechselgeld herausgeben
        #16 ;
        buy_oper  = 10'b00_0010_0110 ;
        repeat(5) begin
            @(negedge clk) ;
            coin      = buy_oper[1:0] ;
            buy_oper  = buy_oper >> 2 ;
        end

        //case(3) 0.5 -> 1 -> 0.5
        #16 ;
        buy_oper  = 10'b00_0001_1001 ;
        repeat(5) begin
            @(negedge clk) ;
            coin      = buy_oper[1:0] ;
            buy_oper  = buy_oper >> 2 ;
        end

        //case(4) 0.5 -> 0.5 -> 0.5 -> 1, Wechselgeld herausgeben
        #16 ;
        buy_oper  = 10'b00_1001_0101 ;
        repeat(5) begin
            @(negedge clk) ;
            coin      = buy_oper[1:0] ;
            buy_oper  = buy_oper >> 2 ;
        end
    end

   //(1) Mealy-Zustand mit 3 Stufen
    vending_machine_p3 u_mealy_p3     (
        .clk              (clk),
        .rstn             (rstn),
        .coin             (coin),
        .change           (change),
        .sell             (sell)
        );

   //Simulationsende
   always begin
      #100;
      if ($time >= 10000)  $finish ;
   end

endmodule // test

Die Simulationsergebnisse sind wie folgt:

Aus der Abbildung ist ersichtlich, dass das Signal sell, das die Produktausgabeaktion repräsentiert, nach Abschluss des Münzeinwurfs normal auf High gezogen werden kann, und das Signal change, das die Wechselgeldausgabeaktion repräsentiert, kann ebenfalls abhängig vom eingegebenen Münzszenario das korrekte Wechselgeld- oder Kein-Wechselgeld-Signal ausgeben.

Modifikation des Zustandsautomaten: 2-Segment-Stil

Führe die Beschreibungen von Segment 2 und 3 des 3-Segment-Zustandsautomaten zusammen, lasse die anderen Teile unverändert, und der Zustandsautomat wird zu einer 2-Segment-Beschreibung.

Die geänderten Teile sind wie folgt:

Beispiel

//(2) Zustandswechsel und Ausgabelogik
//alle verwenden blockierende Zuweisung für Kombinationslogik
reg  [1:0]   change_r ;
reg          sell_r ;
always @(*) begin //alle case-Einträge müssen vollständig angezeigt werden
    case(st_cur)
        IDLE: begin
            change_r     = 2'b0 ;
            sell_r       = 1'b0 ;
            case (coin)
                2'b01:     st_next = GET05 ;
                2'b10:     st_next = GET10 ;
                default:   st_next = IDLE ;
            endcase // case (coin)
        end
        GET05: begin
            change_r     = 2'b0 ;
            sell_r       = 1'b0 ;
            case (coin)
                2'b01:     st_next = GET10 ;
                2'b10:     st_next = GET15 ;
                default:   st_next = GET05 ;
            endcase // case (coin)
        end

        GET10:
            case (coin)
                2'b01:     begin
                    st_next      = GET15 ;
                    change_r     = 2'b0 ;
                    sell_r       = 1'b0 ;
                end
                2'b10:     begin
                    st_next      = IDLE ;
                    change_r     = 2'b0 ;
                    sell_r       = 1'b1 ;
                end
                default:   begin
                    st_next      = GET10 ;
                    change_r     = 2'b0 ;
                    sell_r       = 1'b0 ;
                end
            endcase // case (coin)

        GET15:
            case (coin)
                2'b01: begin
                    st_next     = IDLE ;
                    change_r    = 2'b0 ;
                    sell_r      = 1'b1 ;
                end
                2'b10:     begin
                    st_next     = IDLE ;
                    change_r    = 2'b1 ;
                    sell_r      = 1'b1 ;
                end
                default:   begin
                    st_next     = GET15 ;
                    change_r    = 2'b0 ;
                    sell_r      = 1'b0 ;
                end
            endcase
        default:  begin
            st_next     = IDLE ;
            change_r    = 2'b0 ;
            sell_r      = 1'b0 ;
        end

    endcase
end

Instanziieren Sie das oben neu geänderte Modul in der 3-Segment-Testbench, um eine Simulation durchzuführen. Die Ergebnisse sind wie folgt:

Aus der Abbildung ist ersichtlich, dass das Produktausgabe-Signal sell und das Wechselgeld-Signal change einen Taktzyklus früher als der Ausgang des 3-Segment-Zustandsautomaten liegen. Dies liegt daran, dass die Ausgangssignale allesamt blockierende Zuweisungen sind.

Wie in den rot eingekreisten Bereichen in der Abbildung dargestellt, treten an den Ausgangssignalen Glitch-Impulse auf. Dies liegt daran, dass die Eingangssignale asynchron sind und die Ausgangssignale kombinatorische Logikausgänge ohne Taktansteuerung sind.

In der Praxis treten solche Glitch-Impulse nicht auf, wenn die Eingangssignale mit dem Takt synchronisiert sind. Wenn die Eingangssignale asynchron sind, sollten die Signale zuerst synchronisiert werden.

Modifikation des Zustandsautomaten: 1-Segment-Stil (mit Vorsicht verwenden)

Fasst man die Beschreibungen der Segmente 1, 2 und 3 des 3-Segment-Zustandsautomaten zusammen, wird der Zustandsautomat zu einer 1-Segment-Beschreibung.

Die geänderten Teile sind wie folgt:

Beispiel


    //(1) mit einer Zustandsvariable beschreiben
    reg  [1:0]   change_r ;
    reg          sell_r ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            st_cur     <= 'b0 ;
            change_r   <= 2'b0 ;
            sell_r     <= 1'b0 ;
        end
        else begin
            case(st_cur)

            IDLE: begin
                change_r  <= 2'b0 ;
                sell_r    <= 1'b0 ;
                case (coin)
                    2'b01:     st_cur <= GET05 ;
                    2'b10:     st_cur <= GET10 ;
                endcase
            end
            GET05: begin
                case (coin)
                    2'b01:     st_cur <= GET10 ;
                    2'b10:     st_cur <= GET15 ;
                endcase
            end

            GET10:
                case (coin)
                    2'b01:     st_cur   <=  GET15 ;
                    2'b10:     begin
                        st_cur   <= IDLE ;
                        sell_r   <= 1'b1 ;
                    end
                endcase

            GET15:
                case (coin)
                    2'b01:     begin
                        st_cur   <= IDLE ;
                        sell_r   <= 1'b1 ;
                    end
                    2'b10:     begin
                        st_cur   <= IDLE ;
                        change_r <= 2'b1 ;
                        sell_r   <= 1'b1 ;
                    end
                endcase

            default:  begin
                  st_cur    <= IDLE ;
            end

            endcase // case (st_cur)
        end // else: !if(!rstn)
    end

Instanziieren Sie das oben neu geänderte Modul in der 3-Segment-Testbench, um eine Simulation durchzuführen. Die Ergebnisse sind wie folgt:

Man erkennt aus der Abbildung, dass die Ausgangssignale genau dieselben sind wie die des 3-Segment-Zustandsautomaten.

Der Nachteil des 1-Segment-Zustandsautomaten besteht darin, dass viele Arten von Logik vermischt werden, was die spätere Wartung erschwert. Wenn es nur wenige Zustände und Ausgangssignale gibt, kann dieser Beschreibungsstil ausprobiert werden.

Modifikation des Zustandsautomaten: Moore-Typ

Wenn ein Moore-Zustandsautomat verwendet wird, um den Arbeitsablauf des Verkaufsautomaten zu beschreiben, müssen 2 weitere Zustandskodierungen hinzugefügt werden, um das Eingangssignal und den Zustand des Zustandsautomaten zu beschreiben, wenn der Mealy-Zustandsautomat ausgibt.

Der Verilog-Code des automatischen Verkaufsautomaten, der durch den 3-Segment-Moore-Zustandsautomaten beschrieben wird, lautet wie folgt:

Beispiel

module  vending_machine_moore    (
    input           clk ,
    input           rstn ,
    input [1:0]     coin ,     //01 für 0.5 Jiao, 10 für 1 Yuan

    output [1:0]    change ,
    output          sell    //das Getränk ausgeben
    );

    //Maschinenzustand dekodieren
    parameter            IDLE   = 3'd0 ;
    parameter            GET05  = 3'd1 ;
    parameter            GET10  = 3'd2 ;
    parameter            GET15  = 3'd3 ;
    // neuer Zustand für den Moore-Zustandsautomaten
    parameter            GET20  = 3'd4 ;
    parameter            GET25  = 3'd5 ;

    //Maschinenvariable
    reg [2:0]            st_next ;
    reg [2:0]            st_cur ;

    //(1) Zustandsübergang
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            st_cur      <= 'b0 ;
        end
        else begin
            st_cur      <= st_next ;
        end
    end

    //(2) Zustandswechsel, unter Verwendung blockierender Zuweisung für Kombinationslogik
    always @(*) begin //alle case-Einträge müssen vollständig angezeigt werden
        case(st_cur)
            IDLE:
                case (coin)
                    2'b01:     st_next = GET05 ;
                    2'b10:     st_next = GET10 ;
                    default:   st_next = IDLE ;
                endcase
            GET05:
                case (coin)
                    2'b01:     st_next = GET10 ;
                    2'b10:     st_next = GET15 ;
                    default:   st_next = GET05 ;
                endcase

            GET10:
                case (coin)
                    2'b01:     st_next = GET15 ;
                    2'b10:     st_next = GET20 ;
                    default:   st_next = GET10 ;
                endcase
            GET15:
                case (coin)
                    2'b01:     st_next = GET20 ;
                    2'b10:     st_next = GET25 ;
                    default:   st_next = GET15 ;
                endcase
            GET20:         st_next = IDLE ;
            GET25:         st_next = IDLE ;
            default:       st_next = IDLE ;
        endcase // case (st_cur)
    end // always @ (*)

   // (3) Ausgangslogik,
   // bei Verwendung nicht-blockierender Zuweisung um einen Taktzyklus verzögert
    reg  [1:0]   change_r ;
    reg          sell_r ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            change_r       <= 2'b0 ;
            sell_r         <= 1'b0 ;
        end
        else if (st_cur == GET20 ) begin
            sell_r         <= 1'b1 ;
        end
        else if (st_cur == GET25) begin
            change_r       <= 2'b1 ;
            sell_r         <= 1'b1 ;
        end
        else begin
            change_r       <= 2'b0 ;
            sell_r         <= 1'b0 ;
        end
    end
    assign       sell    = sell_r ;
    assign       change  = change_r ;

endmodule

Instanziieren Sie die oben modifizierte Moore-Zustandsmaschine in der 3-Segment-Testbench, um eine Simulation durchzuführen. Die Ergebnisse sind wie folgt:

Aus der Abbildung ist ersichtlich, dass das Ausgangssignal im Vergleich zur 3-Segment-Zustandsmaschine vom Mealy-Typ um einen Taktzyklus verzögert ist. Das liegt daran, dass das Eintreten in die neu hinzugefügte Codierungs-Zustandsmaschine eine Verzögerung von einem Taktzyklus erfordert. Wenn man zu diesem Zeitpunkt eine nicht-blockierende Zuweisung für den Ausgang verwendet, wird das endgültige Ausgangssignal um einen Taktzyklus verzögert. Dies ist auch eine Eigenschaft der Moore-Zustandsmaschine.

Beim Zuweisen des Ausgangssignals kann die Verwendung einer blockierenden Zuweisung es um einen Taktzyklus vorziehen.

Die Ausgangslogik wird wie folgt geändert.

Beispiel


    // (3.2) Ausgangslogik, unter Verwendung blockierender Zuweisung
    reg  [1:0]   change_r ;
    reg          sell_r ;
    always @(*) begin
        change_r  = 'b0 ;
        sell_r    = 'b0 ; // nicht alle Bedingungen auflisten, sie initialisieren
        if (st_cur == GET20 ) begin
            sell_r         = 1'b1 ;
        end
        else if (st_cur == GET25) begin
            change_r       = 2'b1 ;
            sell_r         = 1'b1 ;
        end
    end

Die Simulationsergebnisse der blockierenden Zuweisung für das Ausgangssignal sind wie folgt:

Aus der Abbildung ist ersichtlich, dass das Ausgangssignal nun mit der 3-Segment-Mealy-Zustandsmaschine übereinstimmt.

Quellcode-Download

Herunterladen