Transcript Chapter #8: Finite State Machine Design Contemporary Logic

Reti Logiche
Macchine a Stati Finiti
Capitolo 8: Progetto di
Macchine a Stati Finiti
Reti Logiche
Contemporary Logic Design
Randy H. Katz
University of California, Berkeley
May 1993
Trasparenze tradotte da:
Luciano Lavagno
Universita’ di Udine
Settembre 1998
© R.H. Katz 8-1
Motivazioni
Reti Logiche
Macchine a Stati Finiti
• Contatori: reti logiche sequenziali in cui stato = uscita
• Generalizzazione a Mcchine a Stati Finiti (FSM):
Le uscite sono funzione degli stati (e degli ingressi)
Stati futuri sono funzione degli stati e degli ingressi
Usate per realizzare circuiti che controllano altri circuiti
Logica che “prende le decisioni”
• Applicazione di tecniche di progetto logico sequenziale:
Specifiche informali (“a parole”)
Trasformazione in specifiche formali di FSM
Esempi di progetti
© R.H. Katz 8-2
Riassunto del capitolo
Reti Logiche
Macchine a Stati Finiti
Concetto di macchina a stati
• Suddivisione tra unita’ operativa (data path) e di controllo (control unit)
• Campionamento degli ingressi ed aggiornamento delle uscite
Metodo base di progetto
• Sei passi di progetto
Diverse rappresentazioni di Macchine a Stati Finiti
• Diagramma degli stati, ASM, VHDL, ABEL Description Language
Macchine di Moore e di Mealy
• Definizione, esempi di realizzazione
Problemi informali
• Esempi di progetto
© R.H. Katz 8-3
Reti Logiche
Macchine a Stati Finiti
Concetto di Macchina a Stati
Hardware = Unita’ Operativa (UO) + Unita’ di Controllo (UC)
Bit risultato
Registri
Unita’ funzionali
combinatorie (p.es. ALU)
Bus
Bit controllo
Unita’ di controllo
FSM che genera sequenze
di segnali di controllo
Informa l’UO su che cosa fare
al prossimo passo
”Burattinaio che
tira i fili"
Stato
Controlli
ed uscite
Risultati
ed ingressi
”Burattino"
Unita’ operativa
© R.H. Katz 8-4
Reti Logiche
Macchine a Stati Finiti
Concetto di Macchina a Stati
Esempio: controllore di parita’ dispari
Mette ad 1 l’uscita ogni volta che l’ingresso ha un numero dispari di 1
Reset
0
Pari
[0]
1
0
1
Disp.
[1]
Diagramma
degli stati
St. presente Ingresso
Pari
0
Pari
1
Disp.
0
Disp.
1
St. futuro
Pari
Disp.
Disp.
Pari
Uscita
0
0
1
1
Tabella di transizione simbolica
St. presente
0
0
1
1
Ingresso
0
1
0
1
St. futuro
0
1
1
0
Uscita
0
0
1
1
Tabella di transizione codificata
© R.H. Katz 8-5
Reti Logiche
Macchine a Stati Finiti
Concetto di Macchina a Stati
Esempio: controllore di parita’ dispari
Funzioni di stato futuro e di uscita
NS = PS xor PI; OUT = PS
Inp ut
NS
Inp ut
D
Q
CLK
R
Outpu t
Q
CLK
PS/Outp ut
R
Q
Q
\Rese t
\Rese t
Realizzazione con FF T
Realizzazione con FF D
Input
T
1
0
0
1
1
0
1
0
1
1
1
0
Clk
Output
1
1
1
0
1
1
0
0
1
0
1
1
Comportamento nel tempo con ingresso 1 0 0 1 1 0 1 0 1 1 1 0
© R.H. Katz 8-6
Concetto di Macchina a Stati
Reti Logiche
Macchine a Stati Finiti
Temporizzazione:
Quando vengono campionati gli ingressi, calcolato lo stato
futuro, aggiornate le uscite?
Durata di uno stato: intervallo tra eventi del clock
• Evento di clock fa cambiare uscite e stato in base agli ingressi
• Necessario soddisfare tempi di setup/hold:
Ingressi devono essere stabili prima dell’evento di clock
• Dopo il tempo di propagazione, si passa allo stato futuro e
si stabilizzano le uscite
NOTA: segnali asincroni hanno effetto subito,
segnali sincroni hanno effetto al prossimo evento di clock
P.es., abilitazione tri-state: attivo immediatamente
azzeramento sincrono contatore: attivo al prossimo evento
di clock
© R.H. Katz 8-7
Concetto di Macchina a Stati
Reti Logiche
Macchine a Stati Finiti
Esempio: sistema sincrono attivo sul fronte di salita
Durata stato
Clock
Ingressi
Uscite
Sul fronte di salita vengono campionati gli
ingressi e calcolati le uscite e lo stato futuro
Dopo un ritardo di propagazione, le uscite e lo
stato futuro sono stabili
Uscite imediate:
hanno effetto subito sull’UO
possono far cambiare i risultati dell’UO
Uscite ritardate:
hanno effetto al prossimo evento di clock
ritardi di propagazione devono essere
maggiori del tempo di hold
© R.H. Katz 8-8
Reti Logiche
Macchine a Stati Finiti
Concetto di Macchina a Stati
Macchine a stati comunicanti
L’uscita di una macchina e’ l’ingresso di un’altra e viceversa
X
CLK
FSM 2
FSM 1
Y
FSM 1
A
A
B
C
D
D
X
Y=0
Y=0
X=0
X=0
A
[1]
FSM 2
C
[0]
X=1
Y=1
Y
X=1
Y=0,1
B
[0]
X=0
D
[1]
Le due macchine avanzano insieme (“al passo”)
Ingressi/uscite iniziali: X = 0, Y = 0
© R.H. Katz 8-9
Metodo base di progetto
Processo a sei passi
Reti Logiche
Macchine a Stati Finiti
1. Capire la specifica
2. Derivare una specifica astratta dell’FSM
3. Minimizzare gli stati
4. Assegnare gli stati
5. Scegliere i tipi di FF per realizzare il registro di stato
6. Realizzare l’FSM
1, 2 descritti adesso; 3, 4, 5 descritti piu’ avanti;
4, 5 casi generali del metodo di progetto visto per il contatore
© R.H. Katz 8-10
Reti Logiche
Macchine a Stati Finiti
Metodo base di progetto
Esempio: FSM che controlla distributore automatico
Definizione informale e generica
fornire gomma da masticare dopo aver ricevuto 150 lire
unica fessura per 50 e 100 lire
non da’ resto
Passo 1. Capire il problema:
Disegnare una figura!
Schema a blocchi
Sensore
monete
50
100
Reset
FSM
Open
distributore
automatico
Meccanismo
distribuzione
gomma
Clk
© R.H. Katz 8-11
Reti Logiche
Macchine a Stati Finiti
Esempio distributore automatico
Passo 2. Trasformare in una specifica formale piu’ adatta
Tabulare sequenze di ingresso “tipiche”
3 da 50 lire
1 da 50 lire, 1 da 100 lire
1 da 100 lire, 1 da 50 lire
Reset
2 da 100 lire
2 da 50 lire, 100 lire
S0
50
Disegnare il diagramma degli stati:
S1
Ingressi: 50, 100, reset
Uscita: apri
50
S3
50
100
100
S2
50
100
S4
S5
S6
[apri]
[apri]
[apri]
100
S7
S8
[apri]
[apri]
© R.H. Katz 8-12
Reti Logiche
Macchine a Stati Finiti
Esempio distributore automatico
Passo 3: Minimizzazione degli stati
Stato
Presente
Reset
0
0
50
50
100
50
50
100
100
50, 100
100
150
[open]
150
Riutilizzare gli
stati quando
e’ possibile
Ingressi
100 50
0
0
1
1
0
0
1
1
0
0
1
1
X
0
1
0
1
0
1
0
1
0
1
0
1
X
Stato
Futuro
Uscita
Apri
0
50
100
X
50
100
150
X
100
150
150
X
150
0
0
0
X
0
0
0
X
0
0
0
X
1
Tabella degli stati simbolica
© R.H. Katz 8-13
Reti Logiche
Macchine a Stati Finiti
Esempio distributore automatico
Passo 4: Codifica degli stati
Stato presente Ingressi
Q1 Q0
100 50
0
0
0
1
1
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
Stato futuro
D 1 D0
0 0
0 1
1 0
X X
0 1
1 0
1 1
X X
1 0
1 1
1 1
X X
1 1
1 1
1 1
X X
Uscita
Apri
0
0
0
X
0
0
0
X
0
0
0
X
1
1
1
X
Tabella degli stati codificata
© R.H. Katz 8-14
Reti Logiche
Macchine a Stati Finiti
Esempio distributore automatico
Passo 5. Scegliere i FF per la realizzazione
FF D sono i piu’ facili da usare
Q1 Q0
100 50
Q1
Q1 Q0
100 50
Q1
50
100
Q1 Q0
100 50
50
100
Q0
Mappa per D1
Q1
50
100
Q0
Mappa per D0
Q0
Mappa per Apri
D1 = Q1 + 100 + Q0 50
D0 = 50 Q0 + Q0 50 + Q1 50 + Q1 100
OPEN = Q1 Q0
8 porte
© R.H. Katz 8-15
Reti Logiche
Macchine a Stati Finiti
Esempio distributore automatico
Passo 5. Scegliere i FF per la realizzazione
FF J-K
Stato presente Ingressi
Q1 Q0
D N
0 0
0
0
0
1
1
0
1
1
0 1
0
0
0
1
1
0
1
1
1 0
0
0
0
1
1
0
1
1
1 1
0
0
0
1
1
0
1
1
Stato futuro J1
D1 D0
0
0
1
X
0
1
1
X
1
1
1
X
1
1
1
X
0
1
0
X
1
0
1
X
0
1
1
X
1
1
1
X
0
0
1
X
0
1
1
X
X
X
X
X
X
X
X
X
K1
J0 K 0
X
X
X
X
X
X
X
X
0
0
0
X
0
0
0
X
0
1
0
X
X
X
X
X
0
1
1
X
X
X
X
X
X
X
X
X
0
1
0
X
X
X
X
X
0
0
0
X
Tabella di transizione codificata trasformata
© R.H. Katz 8-16
Esempio distributore automatico
Reti Logiche
Macchine a Stati Finiti
Realizzazione:
J1 = 100 + Q0 50
K1 = 0
J0 = Q0 50 + Q1 100
K0 = Q1 50
7 porte
© R.H. Katz 8-17
Rappresentazioni alternative per FSM
Reti Logiche
Macchine a Stati Finiti
Perche’ i diagrammi degli stati non bastano
Non abbastanza flessibili per grandi FSM
Non adatti per sviluppo graduale della FSM
Non descrivono in modo ovvio un algoritmo: cioe’ una ben
specifica sequenza di operazioni basate sui dati di ingresso
algoritmo = sequenza + operazioni sui dati
separazione fra controllo e dati
Spostamento graduale verso rappresentazioni simili ad un programma:
• Rappresentazione ad Algorithmic State Machine (ASM)
• Linguaggi di descrizione dell’hardware (Hardware
Description Languages, HDL)
p.es. VHDL, ABEL
© R.H. Katz 8-18
Reti Logiche
Macchine a Stati Finiti
Rappresentazioni alternative per FSM
Rappresentazione ad Algorithmic State Machine (ASM)
Tre elementi base:
• Stato
• Decisione
• Uscita
FSM e’ esattamente in uno
stato alla volta
Singolo ingresso in uno stato
Unico cammino di uscita da
uno stato per ogni
combinazione degli ingressi
Uscite
attive alte (.H) o basse (.L)
immediate (I) o ritardate
(fino al clock successivo)
Cammino
di ingresso nello stato
Codice dello stato
*
***
Nome
dello stato
Lista uscite
assoc. allo stato
T
Condizione
Condizione
Stato
F
Blocco
ASM
Output
Box
Lista uscite
condizionali
Uscite ad
altri blocchi ASM
© R.H. Katz 8-19
Reti Logiche
Macchine a Stati Finiti
Rappresentazioni alternative per FSM
Rappresentazione ad ASM
Condizioni:
l’ordine non ha effetto sul risultato finale
Blocchi ASM equivalenti:
A passa a B se (I0 • I1) altrimenti passa a C
A
A
010
I0
T
010
F
I1
T
F
I1
F
F
I0
T
T
B
C
B
C
© R.H. Katz 8-20
Reti Logiche
Macchine a Stati Finiti
Rappresentazioni alternative per FSM
Esempio: controllo di parita’
Ingresso X, uscita Z
Pari
0
Lista di uscita vuota implica Z inattivo
Z attivo nello stato Dispari
F
X
T
Dispari
Stato
Ingr. presente
F
Pari
T
Pari
F
Disp.
T
Disp.
1
H.Z
F
X
Tabella degli stati simbolica
Stato
futuro Uscita
—
Pari
—
Disp.
A
Disp.
A
Pari
T
Seguire i cammini per
derivare le tabelle di
transizione degli stati
Tabella degli stati codificata
Stato Stato
Ingr. presente futuro Uscita
0
0
0
0
1
0
0
1
0
1
1
1
1
1
1
0
© R.H. Katz 8-21
Reti Logiche
Macchine a Stati Finiti
Rappresentazioni alternative per FSM
ASM per distributore automatico
0
00
T
100
F
F
100
10
T
100
F
F
50
50
T
50
T
150
01
11
H.Apri
50
T
Reset
F
F
100
F
T
T
0
© R.H. Katz 8-22
Rappresentazioni alternative per FSM
Linguaggi di descrizione dell’hardware: VHDL
ENTITY parity_checker IS
PORT (
x, clk: IN BIT;
z: OUT BIT);
END parity_checker;
Reti Logiche
Macchine a Stati Finiti
Descrizione dell’interfaccia
Realizzazione FSM
ARCHITECTURE behavioral OF parity_checker IS
BEGIN
main: BLOCK (clk = ‘1’ and not clk’STABLE)
TYPE state IS (Even, Odd);
SIGNAL state_register: state := Even;
BEGIN state_even:
BLOCK ((state_register = Even) AND GUARD)
BEGIN
state_register <= Odd WHEN x = ‘1’
ELSE Even
END BLOCK state_even;
Espressione di controllo
Decisione stato futuro
BEGIN state_odd:
BLOCK ((state_register = Odd) AND GUARD)
BEGIN
state_register <= Even WHEN x = ‘1’
ELSE Odd;
END BLOCK state_odd;
z <= ‘0’ WHEN state_register = Even ELSE
‘1’ WHEN state_register = Odd;
END BLOCK main;
END behavioral;
Decisione uscite
© R.H. Katz 8-23
Rappresentazioni alternative per FSM
Linguaggi di descrizione dell’hardware: ABEL
Reti Logiche
Macchine a Stati Finiti
module parity
test_vectors ([clk, RESET, X] -> [SREG])
title 'odd parity checker state machine'
[0,1,.X.] -> [S0];
u1 device 'p22v10';
[.C.,0,1] -> [S1];
[.C.,0,1] -> [S0];
"Input Pins
[.C.,0,1] -> [S1];
clk, X, RESET pin 1, 2, 3;
[.C.,0,0] -> [S1];
[.C.,0,1] -> [S0];
"Output Pins
[.C.,0,1] -> [S1];
Q, Z
pin 21, 22;
[.C.,0,0] -> [S1];
[.C.,0,0] -> [S1];
Q, Z
istype 'pos,reg';
[.C.,0,0] -> [S1];
end parity;
"State registers
SREG = [Q, Z];
S0 = [0, 0]; " even number of 0's
S1
= [1, 1]; " odd number of 0's
equations
[Q.ar, Z.ar] = RESET; "Reset to state S0
state_diagram SREG
state S0:
if X then S1
else S0;
state S1:
if X then S0
else S1;
© R.H. Katz 8-24
Metodo progetto per macchine di Moore e Mealy
Reti Logiche
Macchine a Stati Finiti
Definizioni
Macchina di Mealy
Xi
Ingressi
Zk
Uscite
Logica
combinatoria
per uscite e
stato futuro
Registro di stato
Clock
Le uscite dipendono da
stati ed ingressi
Cambiamenti in ingresso
causano cambiamenti
immediati in uscita
Reazione
di stato
Alcuni segnali
sono asincroni
Registro di
stato
Xi
Ingressi
Macchina di Moore
Logica
combinat.
per uscite
Logica
combinatoria
per stato futuro
(ingressi dei
flipflop)
Zk
Uscite
Clock
Le uscite dipendono
solo dagli stati
Cambiamenti in uscita
sincronizzati con
il clock
Reazione
di stato
© R.H. Katz 8-25
Reti Logiche
Macchine a Stati Finiti
Macchine di Moore e di Mealy
Diagrammi degli stati equivalenti
Macchina
di Moore
50 100 + Reset
(50 100 + Reset)/0
Reset/0
Reset
0
0
Macchina
di Mealy
[0]
Reset/0
Reset
50/0
50
50
100/0
50 100/0
100/1
N
50 100
D
[0]
N
50/0
100
100
D
50 100/0
50 +100/1
150
Reset/1
Uscite associate
con lo stato
[0]
50 100
50 + 100
150
[1]
Reset
Uscite associate
con la transizione
© R.H. Katz 8-26
Reti Logiche
Macchine di Moore e di Mealy
Macchine a Stati Finiti
Stati o transizioni?
Una macchina di Mealy in genere ha meno stati di una di Moore
a parita’ di sequenza di uscita
0
0/0
0
0
[0]
Stesso comportamento
ingresso/uscita
0
0
1
1
1/1
[0]
Diverso numero di stati
1/0
0/0
1
1
2
[1]
S0
00
S0
IN
S1
0
IN
01
IN
S2
1
S1
1
ASM
equivalenti
IN
10
H.OUT
H.OUT
IN
© R.H. Katz 8-27
Macchine di Moore e di Mealy
Comportamento nel tempo delle macchine di Moore
Reti Logiche
Macchine a Stati Finiti
De-progettate questo circuito:
X
X
\B
J Q
C
KR Q
F Fa
A
\A
Ingresso X
Uscita Z
Stato A, B = Z
\R eset
Clk
X
X
\A
J Q
C
KR Q
F Fb
Z
\B
\R eset
Due metodi per de-progettazione:
• Ad hoc: provare combinazioni di ingresso per derivare tabella di
transizione
• Formale: derivare le transizioni analizzando il circuito
© R.H. Katz 8-28
Reti Logiche
Macchine a Stati Finiti
Macchine di Moore e di Mealy
De-progettazione ad hoc
Comportamento in risposta alla sequenza 1 0 1 0 1 0:
100
X
Clk
A
Z
\Reset
Reset X = 1
X=0
X=1
X= 0
X=1
X= 0
X= 0
AB = 00 AB = 00 AB = 11 AB = 11 AB = 10 AB = 10 AB = 01 AB = 00
A B
0 0
Tabella di
transizione degli
stati parziale
0 1
1 0
1 1
X
0
1
0
1
0
1
0
1
A+
?
1
0
?
1
0
1
1
B+
?
1
0
?
0
1
1
0
Z
0
0
1
1
0
0
1
1
© R.H. Katz 8-29
Reti Logiche
Macchine a Stati Finiti
Macchine di Moore e di Mealy
De-progettazione formale
Derivare la tabella di transizione dalle funzioni di stato futuro
in ingresso ai flipflop e dalle funzioni di uscita!
Ja = X
Jb = X
Ka = X • B
Kb = X xor A
Z=B
Funzioni di eccitazione del FF J-K:
A+ = Ja • A + Ka • A = X • A + (X + B) • A
B+ = Jb • B + Kb • B = X • B + (X • A + X • A) • B
Mappe di Karnaugh delle funzioni di stato futuro:
A+
Stato 00, Ingresso 0 -> Stato 00
Stato 01, Ingresso 1 -> Stato 01
B+
© R.H. Katz 8-30
Reti Logiche
Macchine a Stati Finiti
Macchine di Moore e di Mealy
ASM completa per la macchina di Moore da identificare
00
S0
11
S3
H. Z
0
1
X
0
X
1
S1
01
S2
10
H. Z
0
X
1
1
X
0
Nota: tutte le uscite sono associate con gli stati
Non ci sono uscite dipendenti dagli ingressi (macchina di Moore)
© R.H. Katz 8-31
Reti Logiche
Macchine a Stati Finiti
Macchine di Moore e di Mealy
De-progettate questa macchina di Mealy
Clk
D
Q
DA
C
A
\A
X
\A
R
\X
Q
J
C
K
\Reset
A
X
B
Q
R
Q
\B
\Reset
DA
\X
B
B
Z
\X
X
A
Ingresso X, Uscita Z, Stato A, B
Il registro di stato ha un FF D ed un FF J-K
© R.H. Katz 8-32
Reti Logiche
Macchine di Moore e di Mealy
Macchine a Stati Finiti
Metodo ad hoc
Comportamento nel tempo con sequenza di ingresso 101011:
100
Notate le
alee su Z!
X
Clk
Uscite valide
al fronte di
discesa
successivo
del clock
A
B
Z
\Res et
Reset
AB=00
Z =0
X =1
AB=00
Z =0
X =0
AB=00
Z =0
X =1
AB=01
Z =0
X =0
AB=11
Z=1
A B
0 0
Tabella di
transizione
parziale basata
sulle forme
d’onda
0 1
1 0
1 1
X
0
1
0
1
0
1
0
1
X =1
AB=10
Z =1
A+
0
0
?
1
?
0
1
?
X =1
AB=01
Z =0
B+
1
0
?
1
?
1
0
?
Z
0
0
?
0
?
1
1
?
© R.H. Katz 8-33
Reti Logiche
Macchine a Stati Finiti
Macchine di Moore e di Mealy
Metodo formale
A+ = B • (A + X) = A • B + B • X
B+ = Jb • B + Kb • B = (A xor X) • B + X • B
=A•B•X + A•B•X + B•X
Z
=A•X + B•X
A+
Transizioni ed uscite mancanti:
Stato 01, Ingr. 0 -> Stato 01, Uscita 1
Stato 10, Ingr. 0 -> Stato 00, Uscita 0
Stato 11, Ingr. 1 -> Stato 11, Uscita 1
B+
Z
© R.H. Katz 8-34
Reti Logiche
Macchine a Stati Finiti
Macchine di Moore e di Mealy
ASM per la macchina di Mealy da identificare
S0 = 00, S1 = 01, S2 = 10, S3 = 11
S0
1
H. Z
00
10
S2
0
X
0
S1
X
1
H. Z
S3
01
11
H. Z
0
X
1
1
X
0
Nota: alcune uscite dipendono dalle transizioni, altre
dagli stati (macchina di Mealy)
© R.H. Katz 8-35
Macchine di Moore e di Mealy
Variante macchina di Moore
(anche detta macchina di Mealy sincrona)
Reti Logiche
Macchine a Stati Finiti
Clock
Xi
Ingressi
Zk
Uscite
Logica
combinatoria
per uscite
e stato futuro
Registro di stato
Clock
Reazione
di stato
Uscite e stati memorizzati:
“risponde” dopo un ciclo di clock (Moore)
ma non ci sono alee sulle uscite!
© R.H. Katz 8-36
Reti Logiche
Macchine a Stati Finiti
Macchine di Moore e di Mealy
Macchina di Mealy
Xi
Ingressi
Logica
combinatoria
per uscite
e stato futuro
Registro di stato
Zk
Uscite
Clock
Reazione
di stato
Uscite non memorizzate:
“risponde” immediatamente (Mealy)
ma puo’ avere alee sulle uscite!
© R.H. Katz 8-37
Specifiche informali di FSM
Reti Logiche
Macchine a Stati Finiti
Traduzione di specifiche informali in specifiche formali
Quattro esempi:
• Riconoscitore di stringa finita
• Contatore con decisioni complesse
• Controllore di semaforo
• Serratura a combinazione numerica
Useremo diagrammi degli stati ed ASM
© R.H. Katz 8-38
Specifiche informali di FSM
Riconoscitore di stringa finita
Reti Logiche
Macchine a Stati Finiti
Un riconoscitore di stringa finita ha un ingresso (X) ed una uscita (Z).
L’uscita e’ attiva quando e’ stata vista la sequenza …010…
in ingresso, purche’ non sia mai stata vista la sequenza 100.
Passo 1. Capire il problema
Esempi di comportamenti ingresso/uscita:
X: 00101010010…
Z: 000010101000…
X: 11011010010…
Z: 000000001000…
© R.H. Katz 8-39
Reti Logiche
Macchine a Stati Finiti
Specifiche informali di FSM
Riconoscitore di stringa finita
Passo 2. Disegnare diagramma degli stati/ASM per le due stringhe
che vanno riconosciute, cioe’ 010 ed 100.
S0
[0]
Produce
1 in uscita
Reset
S1
[0]
S4
[0]
S2
[0]
S5
[0]
S3
[1]
S6
[0]
Diagramma degli stati
di Moore
Reset manda la FSM
nello stato S0
Rimane per sempre nello stato
© R.H. Katz 8-40
Reti Logiche
Macchine a Stati Finiti
Specifiche informali di FSM
Riconoscitore di stringa finita
Condizioni di uscita da S3: ho riconosciuto …010
se il prossimo ingresso e’ 0, ho visto …0100 (stato S6)!
se il prossimo ingresso e’ 1, ho visto …0101 = …01 (stato S2)
S0
[0]
Reset
S1
[0]
S4
[0]
S2
[0]
S5
[0]
S3
[1]
S6
[0]
© R.H. Katz 8-41
Reti Logiche
Macchine a Stati Finiti
Specifiche informali di FSM
Riconoscitore di stringa finita
Condizioni di uscita da S1: riconosce stringhe del tipo …0 (nessun 1)
torna ad S1 se l’ingresso e’ 0
Condizioni di uscita da S4: riconosce stringhe del tipo …1 (nessuno 0)
torna ad S4 se l’ingresso e’ 1
S0
[0]
Reset
S1
[0]
S4
[0]
S2
[0]
S5
[0]
S3
[1]
S6
[0]
© R.H. Katz 8-42
Specifiche informali di FSM
Riconoscitore di stringa finita
S2, S5 mancano ancora di alcune transizioni
Reti Logiche
Macchine a Stati Finiti
S2 = …01; se il prossimo ingresso e’ 1, potrebbe essere l’inizio
di (01)1(00), cioe’ esattamente del caso di S4!
S5 = …10; se il prossimo ingresso e’ 1, potrebbe essere l’inizio
di (10)1(0), cioe’ esattamente del caso di S2!
Reset
S0
[0]
S1
[0]
S4
[0]
S2
[0]
S5
[0]
S3
[1]
S6
[0]
Diagramma degli
stati finale
© R.H. Katz 8-43
Specifiche informali di FSM
Riconoscitore di stringa finita
Reti Logiche
Macchine a Stati Finiti
module string
state_diagram SREG
title '010/100 string recognizer state machine state S0: if X then
Josephine Engineer, Itty Bity Machines, Inc.' state S1: if X then
u1 device 'p22v10';
state S2: if X then
state S3: if X then
"Input Pins
state S4: if X then
state S5: if X then
clk, X, RESET
pin 1, 2, 3;
state S6: goto S6;
"Output Pins
test_vectors ([clk,
Q0, Q1, Q2, Z
pin 19, 20, 21, 22;
[0,1,.X.] -> [0];
[.C.,0,0] -> [0];
Q0, Q1, Q2, Z istype 'pos,reg';
[.C.,0,0] -> [0];
[.C.,0,1] -> [0];
"State registers
[.C.,0,0] -> [1];
SREG = [Q0, Q1, Q2, Z];
[.C.,0,1] -> [0];
S0 = [0,0,0,0]; " Reset state
[.C.,0,0] -> [1];
S1 = [0,0,1,0]; " strings of the form ...0
[.C.,0,1] -> [0];
S2 = [0,1,0,0]; " strings of the form ...01
[.C.,0,0] -> [1];
S3 = [0,1,1,1]; " strings of the form ...010
[.C.,0,0] -> [0];
S4 = [1,0,0,0]; " strings of the form ...1
[.C.,0,1] -> [0];
S5 = [1,0,1,0]; " strings of the form ...10
[.C.,0,0] -> [0];
S6 = [1,1,0,0]; " strings of the form ...100
end string;
equations
[Q0.ar, Q1.ar, Q2.ar, Z.ar] = RESET; "Reset to S0
S4
S2
S4
S2
S4
S2
else
else
else
else
else
else
S1;
S1;
S3;
S6;
S5;
S6;
RESET, X] -> [Z]
Descrizione ABEL
© R.H. Katz 8-44
Specifiche informali di FSM
Riconoscitore di stringa finita
Riassunto del procedimento:
Reti Logiche
Macchine a Stati Finiti
• Scrivere esempi di sequenze di ingresso ed uscita per capire
la specifica
• Scrivere le sequenze degli stati delle stringhe da riconoscere
• Aggiungere transizioni mancanti, riutilizzando stati il piu’
possibile
• Verificare il comportamento ingresso/uscita del diagramma
degli stati per verificare che si comporti come specificato
© R.H. Katz 8-45
Reti Logiche
Macchine a Stati Finiti
Specifiche informali di FSM
Contatore complesso
Un contatore sincrono a 3 bit ha un ingresso M che ne controlla
il modo di funzionamento:
• Quando M = 0 il contatore conta in avanti in binario puro.
• Quando M = 1 il contatore conta in avanti in codice Gray.
Binario: 000, 001, 010, 011, 100, 101, 110, 111
Gray: 000, 001, 011, 010, 110, 111, 101, 100
Esempio di comportamento corretto di ingresso/uscita:
Ingresso di modo M
0
0
1
1
1
0
0
Stato presente Stato futuro (Z2 Z1 Z0)
000
001
001
010
010
110
110
111
111
101
101
110
110
111
© R.H. Katz 8-46
Reti Logiche
Macchine a Stati Finiti
Specifiche informali di FSM
Contatore complesso
Uno stato per ogni combinazione di uscita
Aggiungere gli archi opportuni in base al modo
S0
[000]
S0
Reset
000
S1
S1
[001]
0
S2
[010]
001
H. Z 0
S2
S3
[011]
1
M
010
H. Z 1
M
S3
011
H. Z 1
H. Z 0
0
1
M
1
S4
[100]
S6
S7
[111]
S4
H. Z 2
H. Z 1
S7
S5
[101]
S6
[110]
0
110
111
M
1
M
H. Z 2
H. Z 1
H. Z 0
0
100
H. Z 2
0
S5
101
H. Z 2
H. Z 0
1
0
M
1
© R.H. Katz 8-47
Specifiche informali di FSM
Contatore complesso
Reti Logiche
Macchine a Stati Finiti
module counter
title 'combination binary/gray code upcounter
Josephine Engineer, Itty Bity Machines, Inc.'
u1 device 'p22v10';
state_diagram SREG
state S0: goto S1;
"Input Pins
state S1: if M then S3 else S2;
clk, M, RESET
pin 1, 2, 3;
state S2: if M then S6 else S3;
state S3: if M then S2 else S4;
"Output Pins
state S4: if M then S0 else S5;
Z0, Z1, Z2
pin 19, 20, 21;
state S5: if M then S4 else S6;
state S6: goto S7;
Z0, Z1, Z2
istype 'pos,reg';
state S7: if M then S5 else S0;
"State registers
SREG = [Z0, Z1, Z2];
test_vectors ([clk, RESET, M] -> [Z0, Z1, Z2])
S0 = [0,0,0];
[0,1,.X.] -> [0,0,0];
S1 = [0,0,1];
[.C.,0,0] -> [0,0,1];
S2 = [0,1,0];
[.C.,0,0] -> [0,1,0];
S3 = [0,1,1];
[.C.,0,1] -> [1,1,0];
S4 = [1,0,0];
[.C.,0,1] -> [1,1,1];
S5 = [1,0,1];
[.C.,0,1] -> [1,0,1];
S6 = [1,1,0];
[.C.,0,0] -> [1,1,0];
S7 = [1,1,1];
[.C.,0,0] -> [1,1,1];
end counter;
equations
[Z0.ar, Z1.ar, Z2.ar] = RESET; "Reset to state S0
Descrizione ABEL
© R.H. Katz 8-48
Specifiche informali di FSM
Controllore di semaforo
Reti Logiche
Macchine a Stati Finiti
Una strada di grande traffico incrocia una strada secondaria.
Il sensore C segnala la presenza di un’auto sulla strada secondaria
Se non ci sono veicoli sulla strada secondaria, il semaforo rimane
verde per la strada principale.
Se c’e’ un veicolo sulla strada secondaria, il semaforo passa da verde
a giallo a rosso per la strada principale, permettendo al semaforo
di diventare verde per la strada secondaria.
Il semaforo rimane verde per la strada secondaria finche’ ci sono
veicoli, ma con un tempo massimo prefissato.
Quando una di queste due condizioni e’ soddisfatta, il semaforo
diventa giallo e poi rosso per la strada secondaria, permettendo al
semaforo di diventare verde per la strada principale.
Anche se ci sono veicoli sulla strada secondaria, la strada principale
ha un intervallo minimo prefissato con il semaforo verde.
Supponete di avere un temporizzatore che genera un’uscita TS
dopo un breve intervallo di tempo ed una TL dopo un lungo intervallo
di tempo, in risposta ad un segnale di partenza ST.
Usate TS per temporizzare il giallo e TL per il verde.
© R.H. Katz 8-49
Reti Logiche
Macchine a Stati Finiti
Specifiche informali di FSM
Controllore di semaforo
Figura dell’incrocio:
Secondaria
C
HL
FL
Principale
Principale
HL
FL
C
Secondaria
© R.H. Katz 8-50
Reti Logiche
Macchine a Stati Finiti
Specifiche informali di FSM
Controllore di semaforo
• Tabella degli ingressi e delle uscite:
Segnale di ingresso
reset
C
TS
TL
Descrizione
porta la FSM nello stato iniziale
presenza veicolo su strada secondaria
fine intervallo di tempo breve
fine intervallo di tempo corto
Segnale di uscita
HG, HY, HR
FG, FY, FR
ST
Descrizione
attiva luce verde/gialla/rossa principale
attiva luce verde/gialla/rossa secondaria
inizio intervallo breve o lungo
• Tabella degli stati (alcune uscite ne implicano altre)
Stato
S0
S1
S2
S3
Descrizione
Verde principale (rosso secondaria)
Giallo principale (rosso secondaria)
Verde secondaria (rosso principale)
Giallo secondaria (rosso principale)
© R.H. Katz 8-51
Reti Logiche
Macchine a Stati Finiti
Specifiche informali di FSM
Controllore di semaforo
Completamento di ASM:
Iniziare con sequenza e uscite di base:
S0
S3
H.HG
H.FR
H.HR
H.FY
S1
H.HY
H.FR
S2
H.HR
H.FG
© R.H. Katz 8-52
Reti Logiche
Macchine a Stati Finiti
Specifiche informali di FSM
Controllore di semaforo
Decidere condizioni di uscita per S0:
Veicolo in attesa E fine dell’intervallo lungo: C • TL
S0
S0
H.HG
H.FR
0
H.HG
H.FR
0
TL
TL • C
1
0
C
1
H.ST
1
H.ST
S1
H.HY
H.FR
S1
H.HY
H.FR
Frammenti equivalenti di ASM
© R.H. Katz 8-53
Reti Logiche
Specifiche informali di FSM
Macchine a Stati Finiti
Controllore di semaforo
Transizione da S1 ad S2:
Attivare ST uscendo da S0
Restare in S1 finche’ TS e’ attivato
Stesso comportamento per la transizione da S3 ad S4
S1
S2
H.HY
H.FR
0
TS
H.ST
H.HR
H.FG
1
© R.H. Katz 8-54
Reti Logiche
Macchine a Stati Finiti
Specifiche informali di FSM
Controllore di semaforo
Condizione di uscita per S2: nessun veicolo OPPURE fine
dell’intervallo lungo
S0
H.HG
H.FR
0
H.ST
1
TL • C
S3
H.HR
H.FY
TS
0
1
H.ST
S1
H.HY
H.FR
0
TS
H.ST
H.ST
1
S2
H.HR
H.FG
0
TL + C
1
ASM completa per il controllore di semaforo
© R.H. Katz 8-55
Reti Logiche
Macchine a Stati Finiti
Specifiche informali di FSM
Controllore di semaforo
Confrontate con il diagramma degli stati:
TL + C
Reset
S0: HG
S0
TL•C/ST
S1: HY
TS/ST
TS
S1
S2: FG
S3
TS
TS/ST
S3: FY
TL + C/ST
S2
TL • C
Vantaggi di ASM:
• Permette di concentrarsi su cammino e condizioni per
uscire da uno stato
• Condizione di uscita costruita passo per passo, e poi
trasformata in una condizione logica
• E’ piu’ facile capire una specifica algoritmica
© R.H. Katz 8-56
Reti Logiche
Macchine a Stati Finiti
Specifiche informali di FSM
Controllore di semaforo
module traffic
title 'traffic light FSM'
u1 device 'p22v10';
"Input Pins
clk, C, RESET, TS, TL
pin
1, 2,
3, 4,
"Output Pins
Q0, Q1, HG, HY, HR,
FG, FY, FR, ST
pin 14, 15, 16, 17, 18,
19, 20, 21, 22;
5;
HY
HR
FG
FY
FR
=
=
=
=
=
!Q0 & Q1;
(Q0 & !Q1) # (Q0 & Q1);
Q0 & !Q1;
Q0 & Q1;
(!Q0 & !Q1) # (!Q0 & Q1);
state_diagram SREG
state S0: if (TL & C) then S1 with ST = 1
else S0 with ST = 0
state S1: if TS then S2 with ST = 1
else S1 with ST = 0
state S2: if (TL # !C) then S3 with ST = 1
else S2 with ST = 0
state S3: if TS then S0 with ST = 1
else S3 with ST = 0
Q0, Q1 istype 'pos,reg';
ST, HG, HY, HR,
FG, FY, FR istype 'pos,com'; test_vectors
([clk,RESET, C, TS, TL]->[SREG,HG,HY,HR,FG,FY,FR,ST])
"State registers
[.X.,
1,.X.,.X.,.X.]->[ S0, 1, 0, 0, 0, 0, 1, 0];
SREG = [Q0, Q1];
[.C.,
0, 0, 0, 0]->[ S0, 1, 0, 0, 0, 0, 1, 0];
S0 = [ 0, 0];
[.C.,
0, 1, 0, 1]->[ S1, 0, 1, 0, 0, 0, 1, 0];
S1 = [ 0, 1];
[.C.,
0, 1, 0, 0]->[ S1, 0, 1, 0, 0, 0, 1, 0];
S2 = [ 1, 0];
[.C.,
0, 1, 1, 0]->[ S2, 0, 0, 1, 1, 0, 0, 0];
S3 = [ 1, 1];
[.C.,
0, 1, 0, 0]->[ S2, 0, 0, 1, 1, 0, 0, 0];
[.C.,
0, 1, 0, 1]->[ S3, 0, 0, 1, 0, 1, 0, 0];
equations
[.C.,
0, 1, 1, 0]->[ S0, 1, 0, 0, 0, 0, 1, 0];
[Q0.ar, Q1.ar] = RESET;
end traffic;
HG = !Q0 & !Q1;
Descrizione ABEL
© R.H. Katz 8-57
Specifiche informali di FSM
Serratura a combinazione numerica
Reti Logiche
Macchine a Stati Finiti
Una serratura seriale a 3 bit controlla l’ingresso di una stanza.
Gli ingressi sono: RESET, ENTER ed un interruttore a 2 posizioni
KEY-IN per il bit di codice.
La serratura genera l’uscita UNLOCK (sblocca) quando il codice
introdotto corrisponde alla combinazione interna.
Una luce di ERROR si illumina se il codice non corrisponde alla
combinazione.
La sequenza corretta e’: (1) premi RESET, (2) introduci il bit di codice,
(3) premi ENTER, ripeti (2) e (3) per altre 2 volte.
La specifica e’ incompleta:
• come viene definita la combinazione?
• quando viene accesa ERROR esattamente?
Fate supposizioni ragionevoli:
• combinazione memorizzata in un registro oppure pre-definita
nella logica di stato futuro
• attivare ERROR subito, appena identificato un errore, oppure
aspettare la fine del codice
In questo caso: combinazione in un registro e segnalazione di errore
alla fine del codice
© R.H. Katz 8-58
Reti Logiche
Macchine a Stati Finiti
Specifiche informali di FSM
Serratura a combinazione numerica
Capire il problema: disegnare lo schema a blocchi...
RESET
Dati dall’operatore
ENTER
UNLOCK
KEY-IN
Combination
Loc k FSM
Combinazione
interna
ERROR
L0
L1
L2
Ingressi:
Reset
Enter
Key-In
L0, L1, L2
Uscite:
Unlock
Error
© R.H. Katz 8-59
Specifiche informali di FSM
Serratura a combinazione numerica
Reti Logiche
Macchine a Stati Finiti
Enumerazione degli stati:
quali sequenze portano all’apertura della porta?
le condizioni di errore saranno verificate in un secondo tempo …
Stato iniziale START piu’ tre stati di confronto COMP
START
Entra in START quando c’e’ RESET
1
Reset
Esce da START quando ENTER e’
stato premuto
0
Enter
COMP0
0
1
KI = L0
N
Continua se Key-In e’ uguale ad L0
Y
© R.H. Katz 8-60
Reti Logiche
Macchine a Stati Finiti
Specifiche informali di FSM
Serratura a combinazione numerica
COMP0
IDLE1
Cammino per
sbloccare:
KI = L 0
N
Y
Enter
1
COMP2
IDLE0
0
Attendere che
Enter sia stato
premuto
Enter
COMP1
0
KI = L2
N
Y
1
DONE
H.Unloc k
Confrontare Key-In
KI = L1
Y
N
Reset
0
1
START
© R.H. Katz 8-61
Reti Logiche
Macchine a Stati Finiti
Specifiche informali di FSM
Serratura a combinazione numerica
Adesso consideriamo gli errori:
Dovremmo seguire la stessa sequenza del cammino che
finisce con UNLOCK, eccetto per l’attivazione di ERROR
alla fine
IDLE0'
ERROR3
IDLE1'
H.Error
Enter
ERROR1
1
0
0
Enter
ERROR2
Reset
0
1
1
START
Errore in COMP0 va ad IDLE0'
Errore in COMP1 va ad IDLE1'
Errore in COMP2 va ad ERROR3
© R.H. Katz 8-62
Specifiche informali di FSM
Serratura a combinazione numerica
Reti Logiche
Macchine a Stati Finiti
Reset + Enter
Reset
Start
Reset • Enter
Comp0
KI = L0
KI ° L0
Enter
Enter
Idle0
Idle0'
Enter
Enter
Comp1
Diagramma degli stati
equivalente
KI = L1
Error1
KI ° L1
Enter
Enter
Idle1
Idle1'
Enter
Enter
Comp2
KI = L2
Reset
Done
[Unlock]
Reset
Start
Error2
KI ° L2
Error3
[Error]
Reset
Reset
Start
© R.H. Katz 8-63
Specifiche informali di FSM
Serratura a combinazione numerica
Reti Logiche
Macchine a Stati Finiti
module lock
title 'comb. lock FSM'
u1 device 'p22v10';
equations
[Q0.ar, Q1.ar, Q2.ar, Q3.ar] = RESET;
UNLOCK = !Q0 & Q1 & Q2 & !Q3;"asserted in DONE
"Input Pins
ERROR = Q0 & !Q1 & Q2 & Q3; "asserted in ERROR3
clk, RESET, ENTER, L0, L1, L2, KI
pin
1, 2, 3, 4, 5, 6, 7;
state_diagram SREG
state START: if (RESET # !ENTER)
"Output Pins
then START else COMP0;
Q0, Q1, Q2, Q3, UNLOCK, ERROR
state COMP0: if (KI == L0) then IDLE0 else IDLE0p;
pin 16, 17, 18, 19, 14, 15;
state IDLE0: if (!ENTER) then IDLE0 else COMP1;
state COMP1: if (KI == L1) then IDLE1 else IDLE1p;
Q0, Q1, Q2, Q3 istype 'pos,reg';state IDLE1: if (!ENTER) then IDLE1 else COMP2;
UNLOCK, ERROR istype 'pos,com';state COMP2: if (KI == L2) then DONE else ERROR3;
state DONE: if (!RESET) then DONE else START;
"State registers
state IDLE0p:if (!ENTER) then IDLE0p else ERROR1;
SREG
= [Q0, Q1, Q2, Q3];
state ERROR1:goto IDLE1p;
START
= [ 0, 0, 0, 0];
state IDLE1p:if (!ENTER) then IDLE1p else ERROR2;
COMP0
= [ 0, 0, 0, 1];
state ERROR2:goto ERROR3;
IDLE0 = [ 0, 0, 1, 0];
state ERROR3:if (!RESET) then ERROR3 else START;
COMP1 = [ 0, 0, 1, 1];
IDLE1 = [ 0, 1, 0, 0];
test_vectors
COMP2 = [ 0, 1, 0, 1];
DONE = [ 0, 1, 1, 0];
end lock;
IDLE0p = [ 0, 1, 1, 1];
ERROR1 = [ 1, 0, 0, 0];
IDLE1p = [ 1, 0, 0, 1];
ERROR2 = [ 1, 0, 1, 0];
ERROR3 = [ 1, 0, 1, 1];
Descrizione ABEL
© R.H. Katz 8-64
Riassunto del capitolo
Comportamento fondamentale nel tempo di una FSM
Reti Logiche
Macchine a Stati Finiti
• quando gli ingressi vengono campionati, e quando gli stati e le uscite
cambiano e si stabilizzano
• Macchine di Moore e Mealy (sincrone ed asincrone)
uscite = F(stato) oppure uscite = F(stato, ingressi)
Primi due passi della procedura (in sei passi) per la sintesi di FSM
• capire il problema
• derivare una rappresentazione astratta della FSM
Rappresentazioni astratte di FSM
• diagrammi degli stati, ASM, linguaggi di descrizione dell’hardware
Specifiche informali
• capire il comportamento ingresso/uscita; disegnare schemi
• tracciare gli stati per l’”obiettivo”; aggiungere le condizioni di errore
• riutilizzare gli stati se possibile
© R.H. Katz 8-65