Esercizio 3descrizione VHDL di una macchina a stati con ingressi x e y e testbench (tema d'esame giugno 2022)

Esame

In questa pagina 4

Testo (tema d'esame giugno 2022, primo appello, esercizio 3). 1) Descrivere in VHDL la macchina a stati finiti con ingressi $x$ e $y$ e uscita $z$ , avente il seguente diagramma degli stati. In tutti i casi non indicati, il sistema non cambia stato e l'uscita è 0. Separare nel codice gli elementi di memoria dalle parti puramente combinatorie. 2) Creare un test bench in VHDL che faccia attraversare tutti gli stati.

Diagramma (letto dalla figura del tema): stato iniziale $S_0$ (freccia con $rst=1$ , $z=0$ );

$S_0\to S_1$ se $x=1$ and $y=0$ , con $z=1$ ;
$S_0\to S_3$ se $x=0$ and $y=1$ , con $z=1$ ;
$S_1\to S_2$ se $x=1$ , con $z=0$ ;
$S_3\to S_2$ se $x=0$ or $y=1$ , con $z=0$ ;
$S_2\to S_0$ senza condizione (l'arco non ha etichetta), con $z=0$ .

Teoria usata: VHDL - macchine a stati finiti e testbench sequenziale, VHDL - latch, flip-flop e reset sincrono e asincrono, Analisi delle reti sequenziali - tabella e diagramma degli stati, Mealy e Moore.

Passo 1: tipo di macchina e tabella

L'uscita $z$ è scritta sulle frecce ( $z=1$ sulle transizioni uscenti da $S_0$ ): dipende da stato e ingressi, è una macchina di Mealy. Si interpreta il tema così: l'arco da $S_2$ a $S_0$ non ha condizione ed è percorso al ciclo successivo; il reset ( $rst=1$ ) porta a $S_0$ da ogni stato. Tabella (stato futuro / $z$ ; ingressi $xy$ ):

stato	$xy=00$	$01$	$10$	$11$
$S_0$	$S_0/0$	$S_3/1$	$S_1/1$	$S_0/0$
$S_1$	$S_1/0$	$S_1/0$	$S_2/0$	$S_2/0$
$S_2$	$S_0/0$	$S_0/0$	$S_0/0$	$S_0/0$
$S_3$	$S_2/0$	$S_2/0$	$S_3/0$	$S_2/0$

( $S_3\to S_2$ se $x=0$ o $y=1$ : resta in $S_3$ solo con $xy=10$ . $S_0$ non cambia stato per $xy=00$ e $xy=11$ .)

Passo 2: codice VHDL

Tre process: registro di stato con reset (asincrono), stato futuro, uscita. Il reset è specificato dal tema ( $rst=1$ ), si usa quindi asincrono attivo alto.

vhdl

library IEEE;
use IEEE.std_logic_1164.all;

entity fsm_xy is
  port ( clk, rst : in  std_logic;
         x, y     : in  std_logic;
         z        : out std_logic );
end fsm_xy;

architecture beh of fsm_xy is
  type state_type is (S0, S1, S2, S3);
  signal state, next_state : state_type;
begin
  -- elementi di memoria: registro di stato, reset asincrono
  state_register : process (clk, rst)
  begin
    if rst = '1' then
      state <= S0;
    elsif clk'event and clk = '1' then
      state <= next_state;
    end if;
  end process;

  -- parte combinatoria: stato futuro
  next_state_comb : process (state, x, y)
  begin
    next_state <= state;                               -- casi non indicati: non cambia stato
    case state is
      when S0 =>
        if x = '1' and y = '0' then
          next_state <= S1;
        elsif x = '0' and y = '1' then
          next_state <= S3;
        end if;
      when S1 =>
        if x = '1' then next_state <= S2; end if;
      when S2 =>
        next_state <= S0;
      when S3 =>
        if x = '0' or y = '1' then next_state <= S2; end if;
    end case;
  end process;

  -- parte combinatoria: uscita (Mealy: dipende anche dagli ingressi)
  output_comb : process (state, x, y)
  begin
    z <= '0';                                          -- valore di default
    if state = S0 and ((x = '1' and y = '0') or (x = '0' and y = '1')) then
      z <= '1';
    end if;
  end process;
end beh;

L'assegnazione di default next_state <= state; (e z <= '0';) all'inizio dei process realizza la frase "in tutti i casi non indicati il sistema non cambia stato e l'uscita è 0" e impedisce memoria involontaria: ogni percorso assegna sempre i segnali.

Passo 3: testbench

Si devono percorrere tutti gli stati (e conviene anche tutte le transizioni). Sequenza di ingressi $xy$ , un valore per ciclo, dopo il reset iniziale:

ciclo	0	1	2	3	4	5	6	7	8	9
$xy$	10	00	10	00	01	10	00	11	11	00
stato presente	$S_0$	$S_1$	$S_1$	$S_2$	$S_0$	$S_3$	$S_3$	$S_2$	$S_0$	$S_0$
$z$	1	0	0	0	1	0	0	0	0	0
stato futuro	$S_1$	$S_1$	$S_2$	$S_0$	$S_3$	$S_3$	$S_2$	$S_0$	$S_0$	$S_0$

Questa sequenza usa tutte e 8 le transizioni del diagramma: $S_0\to S_1$ (ciclo 0), $S_1$ che resta (1), $S_1\to S_2$ (2), $S_2\to S_0$ (3), $S_0\to S_3$ (4), $S_3$ che resta (5), $S_3\to S_2$ (6), $S_0$ che resta (8, 9).

vhdl

library IEEE;
use IEEE.std_logic_1164.all;

entity tb_fsm_xy is
end tb_fsm_xy;

architecture test of tb_fsm_xy is
  signal clk, rst, x, y, z : std_logic;
  constant PERIOD : time := 10 ns;
  type vec_array is array (0 to 9) of std_logic_vector(1 downto 0);
  constant tv : vec_array := ("10", "00", "10", "00", "01", "10", "00", "11", "11", "00");
begin
  DUT : entity work.fsm_xy(beh) port map (clk, rst, x, y, z);

  generate_clock : process
  begin
    clk <= '1'; wait for PERIOD/2;
    clk <= '0'; wait for PERIOD/2;
  end process;

  apply_inputs : process
  begin
    rst <= '1'; x <= '0'; y <= '0';
    wait for 3*PERIOD/2;                 -- reset iniziale, finisce sul fronte di discesa
    rst <= '0';
    for i in 0 to 9 loop
      x <= tv(i)(1);                     -- primo bit del vettore = x
      y <= tv(i)(0);                     -- secondo bit = y
      wait for PERIOD;                   -- un vettore per ciclo di clock
    end loop;
    std.env.stop;
  end process;
end test;

Il clock sale a $0,10,20,\dots$ ns e scende a $5,15,\dots$ ; gli ingressi cambiano sui fronti di discesa ( $15,25,\dots$ ), lontano dal fronte di salita (Temporizzazione dei flip-flop - setup, hold e frequenza massima di clock). Con la sequenza della tabella $z$ vale $1$ nei cicli 0 e 4 (transizioni $S_0\to S_1$ e $S_0\to S_3$ ) e $0$ negli altri. Il comportamento atteso della tabella è stato confrontato con un modello della macchina.

Errori comuni

Dimenticare lo stato $S_2$ (passaggio obbligato) o il suo ritorno non condizionato a $S_0$ .
Mettere $z=1$ anche nelle transizioni verso $S_2$ .
Non separare memoria e combinatoria (un solo process con tutto).
Dimenticare i valori di default: case incompleti producono memoria involontaria.

Versione ripasso

Testo. FSM di Mealy, ingressi $x,y$ , uscita $z$ : $S_0\xrightarrow{x=1,y=0/z=1}S_1$ , $S_0\xrightarrow{x=0,y=1/z=1}S_3$ , $S_1\xrightarrow{x=1}S_2$ , $S_3\xrightarrow{x=0\vee y=1}S_2$ , $S_2\to S_0$ ; altrove resta e $z=0$ . VHDL con memoria separata e testbench che attraversa tutti gli stati.
Codice: type state_type is (S0,S1,S2,S3); process 1 (rst='1' $\to S_0$ , clk'event and clk='1' $\to$ state <= next_state); process 2 con default next_state <= state; e case; process 3: z <= '0'; if state=S0 and (...) then z <= '1';.
Testbench: clock $10$ ns, reset $1{,}5$ periodi, ingressi tv = "10","00","10","00","01","10","00","11","11","00" (tutte le 8 transizioni), std.env.stop; $z=1$ ai cicli 0 e 4 (VHDL - macchine a stati finiti e testbench sequenziale).
Errori: $S_2$ dimenticato; $z$ sulle frecce sbagliate; memoria e combinatoria mescolate.

Esercizi su questo argomento

Esercizio 12 · descrizione VHDL di una macchina di Mealy con ingressi a e b e testbench (tema d'esame febbraio 2023)