Table of Contents

Laboratorul 04 - Automate cu stări

0. Introducere

Un automat finit (FSA - Finite State Automaton sau FSM - Finite State Machine) este un model de calculabilitate folosit pentru proiectarea diverselor programe sau circuite secvențiale. Altfel spus, automatele cu stări finite ne ajută să modelăm fluxuri de execuție. Acestea au aplicații în diverse domenii cum ar fi matematica, inteligența artificială, jocuri sau analiza lingvistică (*cough* *cough* A-ul din “LFA” in anul 3).

Un FSM modelează o mașină având un număr finit de stări. Trăsătura fundamentală a acestei mașini este că numai una din aceste stări poate fi activă în oricare moment de timp. Așadar, pentru a putea executa toate acțiunile pentru care a fost proiectată, aceasta trebuie sa își schimbe starea activă (sau curentă) în funcție de niște condiții prestabilite.
Vom parcurge în acest laborator o modalitate de reprezentare a stărilor şi tranziţiilor automatelor.

Automatele finite, pe lângă faptul că au stări şi tranziţii, pot primi intrări şi pot da la ieșire diverse informaţii, ceea ce le dă şi utilitatea. Din punctul de vedere al condiţiilor în care automatele dau informaţii la output, ele sunt împărţite în două categorii: Mealy și Moore.

1. Mealy vs. Moore

Automatele pot fi construite atât în forma Mealy, cât şi Moore. În diagramele de mai jos, este reprezentat același automat în cele două forme precizate.

La automatele Mealy, ieşirea depinde de starea curentă şi de input-ul curent.
Observați input-urile şi output-urile corespunzătoare fiecărei tranziţii (fiecărui arc). De exemplu, tranziţia A -> B se poate citi astfel: "Din A, cu input-ul 0, trec în B şi scot la ieşire 0". La automatele Moore output-ul este determinat exclusiv de starea în care se află.
Observaţi input-urile care determină tranzițiile și output-urile corespunzătoare fiecărei stări, care sunt independente de valorile de intrare.

În laborator vom lucra cu varianta Moore, pentru că este mai uşor de reprezentat.

2. Reprezentarea automatelor

Pentru a implementa şi programa un automat finit, avem nevoie de o metodă de memorare a stării automatului într-un moment de timp oarecare, deci de o metodă de codificare.

Cele mai folosite metode de codificare a stărilor unui automat sunt:

  • Numărare efectivă, în binar: de exemplu, la o codificare pe 4 biţi, se numără stările de la 0000, 0001, 0010, … 1111
  • Codul Gray, în care codificarea stărilor consecutive diferă doar printr-un singur bit: 0000, 0001, 0011, 0010 …
  • Codul “one-hot”, în care avem nevoie de atâţia biţi câte stări există. În starea i, toţi biţii sunt 0, mai puţin bitul i, care e pe 1 (hot): 0010 = automatul se află în starea 2 (din cele 4 posibile)
  • Codul “one-cold”, asemănător cu cel de mai sus, numai că valorile sunt inversate: 1101 = automatul se află în starea 2 din cele 4 posibile.

În cadrul acestui laborator vom folosi codificarea prin numărarea efectivă pentru a reprezenta stările.

3. Un automat simplu

Automatul din figură primește un șir binar și scoate la ieșire 1 când recunoaște secvența 011:

Observăm că:

  • există o stare inițială
  • avem 2 ieşiri (0 sau 1)
  • există stări cu tranziții înapoi către ele
  • automatul are 5 stări, deci avem nevoie de o codificare pe 3 biţi, şi totuşi rămân coduri nefolosite; vom introduce 3 stări false pentru a completa codificarea (nu este absolut necesar, dar este considerat good-practice)

De regulă, pentru a ne asigura că automatul nostru este complet și corect, avem nevoie de cateva lucruri în vedere atunci cand îl construim:

  • Definirea stărilor
  • Definirea tranzițiilor (este foarte important ca tranzițiile să fie toate definite și testate, înainte de implementarea propriu zisă a FSM-ului)
  • Definirea intrărilor
  • Definirea ieșirilor

Pașii pentru realizarea unui FSM in Verilog

Codificarea stărilor

  • Definim stările necesare automatului pe numarul minim de biți (eg. 6 stări au nevoie de minim 3 biți)
  • În general este recomandat să avem o stare inițială în care să se facă inițializarea automatului. Logica automatului va continua din această stare.

Este recomandat sa aveți nume sugestive pentru stările automatului. Spre exemplu o stare STATE_011 este starea în care automatul a citit la intrare sirul 011. 

localparam STATE_Initial = 3’d0 ,
           STATE_1 = 3’d1 ,
           STATE_2 = 3’d2 ,
           STATE_3 = 3’d3 ,
           STATE_4 = 3’d4 ,
           STATE_5_PlaceHolder = 3’d5 ,
           STATE_6_PlaceHolder = 3’d6 ,
           STATE_7_PlaceHolder = 3’d7;

Precizarea comportamentului ieșirilor

  • În funcție de stări și intrări, precizăm valorile ce trebuie să apară la ieșirea automatului.
  • Putem avea atât ieșiri pe un bit, cât și pe mai multi biți, în funcție de cerințele automatului.
output wire o_w_out ,
 
// ieșire pe 1 bit
assign o_w_out = ( l_r_currentState == STATE_4 );

Logica secvențială de tranziție după ceas

  • starea se va modifica doar pe frontul pozitiv al impulsului de ceas.
  • NextState este determinat de logica combinaționala a automatului. Rolul acestui block always este strict de a realiza tranziția după ceas.
always@ ( posedge i_w_clk ) begin
  if ( Reset ) 
    l_r_currentState <= STATE_Initial ;
  else 
    l_r_currentState <= l_r_nextState ;
end

Logica de schimbare a stărilor

  • aici implementăm algoritmul/logica de tranziție a automatului.
  • tranzițiile între stări se fac în funcție de starea curentă și de intrări.
    always@ ( * ) begin
        l_r_nextState = l_r_currentState ;
 
        case ( l_r_currentState )
            STATE_Initial : begin
                l_r_nextState = STATE_1 ;
            end
            STATE_1 : begin
                if (!i_w_in)
                    l_r_nextState = STATE_2 ;
            end
            STATE_2 : begin
                if (i_w_in)
                    l_r_nextState = STATE_3 ;
            end
            STATE_3 : begin
                if (i_w_in)
                    l_r_nextState = STATE_4 ;
                else
                    l_r_nextState = STATE_2 ;
            end
            STATE_4 : begin
                if (i_w_in)
                    l_r_nextState = STATE_1 ;
                else
                    l_r_nextState = STATE_2 ;
            end
            //Stări pentru tratarea erorilor
            //Dacă automatul ajunge în aceste stări se va reseta.
            STATE_5_PlaceHolder : begin
                NextState = STATE_Initial ;
            end
            STATE_6_PlaceHolder : begin
                NextState = STATE_Initial ;
            end
            STATE_7_PlaceHolder : begin
                NextState = STATE_Initial ;
            end
        endcase
    end

Prin asamblarea pașilor de mai sus obținem un schelet de cod minimal pentru un FSM

Prin asamblarea pașilor de mai sus obținem un schelet de cod minimal pentru un FSM 

module BasicFsm (
    // ------------------------------------------------------------
    // Ieșiri
    // ------------------------------------------------------------
    output wire o_w_out ,
    // ------------------------------------------------------------
    // Intrări
    // ------------------------------------------------------------
    input wire i_w_clk ,
    input wire i_w_reset ,
    input wire i_w_in ,
    // ------------------------------------------------------------
    );
 
    // --------------------------------------------------------------------
    // Codificarea stărilor
    // --------------------------------------------------------------------
    localparam STATE_Initial = 3’d0 ,
    STATE_1 = 3’d1 ,
    STATE_2 = 3’d2 ,
    STATE_3 = 3’d3 ,
    STATE_4 = 3’d4 ,
    STATE_5_PlaceHolder = 3’d5 ,
    STATE_6_PlaceHolder = 3’d6 ,
    STATE_7_PlaceHolder = 3’d7;
    // --------------------------------------------------------------------
 
 
    // --------------------------------------------------------------------
    // Regiștri pentru memorarea stărilor
    // --------------------------------------------------------------------
    reg [2:0] l_r_currentState ;
    reg [2:0] l_r_nextState ;
    // --------------------------------------------------------------------
 
    // --------------------------------------------------------------------
    // Ieșiri
    // --------------------------------------------------------------------
    // ieșire pe 1 bit
    assign o_w_out = ( l_r_currentState == STATE_4 );
 
 
    // --------------------------------------------------------------------
    // Tranziție sincrona: bloc always@(posedge Clock) 
    // --------------------------------------------------------------------
    always@ ( posedge i_w_clk ) begin
        if ( i_w_reset ) begin
            l_r_currentState <= STATE_Initial ;
        else begin
            l_r_currentState <=  l_r_nextState ;
        end
    end
    // --------------------------------------------------------------------
 
 
    // --------------------------------------------------------------------
    // Tranziție condiționată: bloc always@ ( * ) 
    // --------------------------------------------------------------------
always@ ( * ) begin
         l_r_nextState = l_r_currentState ;
 
        case ( l_r_currentState )
            STATE_Initial : begin
                l_r_nextState = STATE_1 ;
            end
            STATE_1 : begin
                if (!i_w_in)
                    l_r_nextState = STATE_2 ;
            end
            STATE_2 : begin
                if (i_w_in)
                    l_r_nextState = STATE_3 ;
            end
            STATE_3 : begin
                if (i_w_in)
                    l_r_nextState = STATE_4 ;
                else
                    l_r_nextState = STATE_1 ;
            end
            STATE_4 : begin
                if (i_w_in)
                    l_r_nextState = STATE_1 ;
                else
                    l_r_nextState = STATE_2 ;
            end
            //Stări pentru tratarea erorilor
            //Dacă automatul ajunge în aceste stări se va reseta.
            STATE_5_PlaceHolder : begin
                NextState = STATE_Initial ;
            end
            STATE_6_PlaceHolder : begin
                NextState = STATE_Initial ;
            end
            STATE_7_PlaceHolder : begin
                NextState = STATE_Initial ;
            end
        endcase
    end
    // --------------------------------------------------------------------
 
endmodule

TL;DR

  • FSA sau FSM este folosit pentru proiectarea diverselor programe sau circuite secvenţiale
  • Au un număr finit de stări, iar în orice moment de timp se pot afla într-una singura din acestea
  • Pot executa tranziții, pot primi intrări și pot da la ieșire informații
  • Se poate clasifica în: Mealy și Moore
  • Mealy → ieşirea depinde de starea curentă şi de intrarea curent
  • Moore → ieşirea este determinat exclusiv de starea în care se află
  • Reprezentarea stărilor → numărare, cod Gray, cod ”one-hot”, cod ”one-cold”

Exerciții

Task 1 (2p + 0.25p + 0.25p) Implementați un modul care să aprindă și se stingă un LED la un anumit interval de timp. Astfel, vom folosi un FSM simplu, cu doar două stări. După simularea cu succes a circuitului, completați fișierul xdc și încărcați soluția pe FPGA.

  • În prima stare, LED-ul va fi stins, se va aștepta un anumit interval de timp (1s), iar apoi trece in starea 2.
  • Starea a doua, în care va petrece același interval de timp, dar aprins.

Urmăriți TODO-urile din schelet!

Task 2 (2.5p + 0.25p + 0.75p) Chiar dacă a trecut Craciunul, acum știm destul de multe pentru a realiza o simplă instalație de pom. Implementați un FSM care să producă următoarea secvență folosind LED-urile. După simularea cu succes a circuitului, completați fișierul xdc și încărcați soluția pe FPGA.

  • “*” înseamnă că LED-ul este aprins;
  • ”-” înseamnă că LED-ul respectiv este stins;
  • T00, T01, …, T14 sunt stările posibile ale LED-urilor;
  • Durata tranziției de la starea Tn la Tn+1 trebuie să fie de o secundă. 
        t00 *-*-*-*-
    t01 -*-*-*-*
    t02 *-*-*-*-
    t03 -*-*-*-*
    t04 *------*
    t05 -*----*-
    t06 --*--*--
    t07 ---**---
    t08 --*--*--
    t09 -*----*-
    t10 *------*
    t11 -**-*--*
    t12 *---**-*
    t13 *---*-**
    t14 -**-*--*
    mergi la t00

Hint!
Pentru întârzierea tranziției trebuie să folosiți un timer. Timer-ul este un circuit simplu care numără într-un contor tranzițiile ceasului. Astfel, pentru cronometrare folosiți frecvența ceasului ca să aflați câte tranziții trebuie numărate. Apoi, blocați FSM-ul în starea curentă până când contorul ajunge la valoare dorită.
Pentru simulare, va trebui să micșorați intervalul cronometrat.

Task 3 (2.5p + 0.5p + 1p) Implementați un modul care să simuleze comportamentul unui semafor pentru pietoni controlat prin apăsarea unui buton. După simularea cu succes a circuitului, completați fișierul xdc și încărcați soluția pe FPGA.

  1. În starea inițială sunt aprinse primele 4 LED-uri (simulând culoarea rosie a semaforului).
  2. Când este primit semnalul de la buton, cronometrați un interval de 2 secunde.
  3. După expirarea celor 2 secunde, tranziționați în starea următoare, unde se aprind celelalte 4 LED-uri. Acestea rămân aprinse pentru încă 2 secunde.
  4. La expirarea cuantei de timp alocate pentru culoarea verde, se revine la starea inițială.

Pentru a asigura o funcționare corectă pe un circuit real, trebuie să folosiți în mod normal un debouncer, pe care să îl atașați butonului folosit (vezi secțiunea Switch debouncing din laborator).
Pentru simulare tratați intrările de tip buton ca fiind deja eșantionate, deoarece schimbarea de semnal se produce instantaneu, fara niciun fel de zgomot.

Bonus (3p) Considerăm ADN-ul unei specii ca fiind o succesiune de nucleotide: adenină(A), guanină(G), citozină(C) şi timină(T). Implementați un modul care să identifice exemplarele mutante, care au în succesiunea de nucleotide secvenţa GGTC. Trebuie să creaţi un automat Moore care:

  1. Primeşte la fiecare pas câte o nucleotidă;
  2. Dacă identifică un exemplar mutant, se blochează într-o stare rezervată.

Porturi modul:

  • intrări: clock, reset (pentru posibilitatea introducerii altui ADN) şi cele 4 nucleotide; (pentru nucleotide putem folosi butoane, adică porturi pe un 1 bit)
  • ieșire: mutant (un LED care, dacă este aprins, semnalează detecţia unui mutant).

FSM-ul trebuie să fie capabil să identifice pattern-ul menționat și să trateze corect inclusiv input-urile eronate. (Spre exemplu: “ATCG” este greșit, “AAAAAAA” este greșit, “GGTC” este corect, “ATCGGTC” este corect, “GGGGGTC” este corect, “GGTCA” este corect)

Completați fișierul xdc pentru modulul de detecție al mutanților (Task 4) și încărcați soluția pe FPGA.

  • intrări: un switch pentru resetare şi 4 push-buttons pentru nucleotide;
  • ieșiri: un led care se aprinde cand se detecteaza un mutant.

Resurse