Capitolo 8: Progetto di Macchine a Stati Finiti Reti Logiche Contemporary Logic Design Randy H. Katz University of California, Berkeley May 1993.

Capitolo 8: Progetto di Macchine a Stati Finiti Reti Logiche Contemporary Logic Design Randy H. Katz University of California, Berkeley May Trasparenze tradotte da: Luciano Lavagno Universita’ di Udine Settembre 1998

Motivazioni • 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

Riassunto del capitolo
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

Concetto di Macchina a Stati
Hardware = Unita’ Operativa (UO) + Unita’ di Controllo (UC) Bit risultato Registri Unita’ funzionali combinatorie (p.es. ALU) Bus FSM che genera sequenze di segnali di controllo Informa l’UO su che cosa fare al prossimo passo Bit controllo Unita’ di controllo ”Burattinaio che tira i fili" Stato Risultati ed ingressi Controlli ed uscite Unita’ operativa ”Burattino"

Esempio: controllore di parita’ dispari Mette ad 1 l’uscita ogni volta che l’ingresso ha un numero dispari di 1 Reset St. presente Ingresso St. futuro Uscita Pari Pari Pari 1 Disp. Pari Disp. Disp. 1 [0] Disp. 1 Pari 1 1 1 Tabella di transizione simbolica Disp. [1] St. presente Ingresso St. futuro Uscita 1 1 1 1 1 Diagramma degli stati 1 1 1 Tabella di transizione codificata

Esempio: controllore di parita’ dispari Funzioni di stato futuro e di uscita NS = PS xor PI; OUT = PS Realizzazione con FF D Realizzazione con FF T Comportamento nel tempo con ingresso

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

Esempio: sistema sincrono attivo sul fronte di salita Durata stato 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 Clock Ingressi Uscite

Macchine a stati comunicanti L’uscita di una macchina e’ l’ingresso di un’altra e viceversa Le due macchine avanzano insieme (“al passo”) Ingressi/uscite iniziali: X = 0, Y = 0

Metodo base di progetto
Processo a sei passi 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

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 50 Sensore FSM Open Meccanismo monete 100 distributore distribuzione automatico gomma Reset Clk

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 2 da 100 lire 2 da 50 lire, 100 lire Reset S0 50 100 Disegnare il diagramma degli stati: S1 S2 Ingressi: 50, 100, reset Uscita: apri 50 100 100 50 S3 S4 S5 S6 [apri] [apri] [apri] 50 100 S7 S8 [apri] [apri]

Passo 3: Minimizzazione degli stati Stato Ingressi Stato Futuro 50 100 X 150 Uscita Apri X 1 Reset Presente 100 1 X 50 1 X 100 50 50 50 50 100 100 100 50, 100 150 [open] 150 Riutilizzare gli stati quando e’ possibile Tabella degli stati simbolica

Passo 4: Codifica degli stati Stato presente Q 1 Ingressi Stato futuro D 1 X X X X Uscita Apri X 1 100 1 50 1 Tabella degli stati codificata

Passo 5. Scegliere i FF per la realizzazione FF D sono i piu’ facili da usare Q1 Q1 Q1 Q1 Q0 Q1 Q0 Q1 Q0 100 50 100 50 100 50 50 50 50 100 100 100 Q0 Q0 Q0 Mappa per D1 Mappa per D0 Mappa per Apri D1 = Q Q0 50 D0 = 50 Q0 + Q Q Q1 100 OPEN = Q1 Q0 8 porte

Passo 5. Scegliere i FF per la realizzazione FF J-K J 1 X Stato presente Q 1 Ingressi Stato futuro D 1 X X K 1 X J 1 X K X 1 D 1 N 1 Tabella di transizione codificata trasformata

Realizzazione: J1 = Q0 50 K1 = 0 J0 = Q Q1 100 K0 = Q1 50 7 porte

Rappresentazioni alternative per FSM
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

Rappresentazione ad Algorithmic State Machine (ASM) Tre elementi base: • Stato • Decisione • Uscita Cammino di ingresso nello stato Codice dello stato * *** 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) Nome Stato dello stato Lista uscite Blocco assoc. allo stato ASM T F Condizione Output Condizione Box Lista uscite condizionali Uscite ad altri blocchi ASM

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

Esempio: controllo di parita’ Ingresso X, uscita Z Pari Lista di uscita vuota implica Z inattivo Z attivo nello stato Dispari F X Tabella degli stati simbolica T Stato presente Pari Disp. Stato futuro Pari Disp. Ingr. F T Uscita — A Dispari 1 H. Z F T X Tabella degli stati codificata Stato presente 1 Stato futuro 1 Ingr. 1 Uscita 1 Seguire i cammini per derivare le tabelle di transizione degli stati

ASM per distributore automatico 00 100 10 T T 100 100 F F F F 50 50 T T 50 01 150 1 H.Apri T F 50 Reset F T F T 100

Linguaggi di descrizione dell’hardware: VHDL ENTITY parity_checker IS PORT ( x, clk: IN BIT; z: OUT BIT); END parity_checker; 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) state_register <= Odd WHEN x = ‘1’ ELSE Even END BLOCK state_even; BEGIN state_odd: BLOCK ((state_register = Odd) AND GUARD) 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; Descrizione dell’interfaccia Realizzazione FSM Espressione di controllo Decisione stato futuro Decisione uscite

Linguaggi di descrizione dell’hardware: ABEL module parity title 'odd parity checker state machine' u1 device 'p22v10'; "Input Pins clk, X, RESET pin 1, 2, 3; "Output Pins Q, Z pin 21, 22; Q, Z istype 'pos,reg'; "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; test_vectors ([clk, RESET, X] -> [SREG]) [0,1,.X.] -> [S0]; [.C.,0,1] -> [S1]; [.C.,0,1] -> [S0]; [.C.,0,0] -> [S1]; end parity;

Metodo progetto per macchine di Moore e Mealy
Definizioni Macchina di Mealy Le uscite dipendono da stati ed ingressi Cambiamenti in ingresso causano cambiamenti immediati in uscita Alcuni segnali sono asincroni X Z i k Ingressi Logica Uscite combinatoria per uscite e stato futuro Reazione Registro di stato di stato Clock Registro di stato Macchina di Moore Le uscite dipendono solo dagli stati Cambiamenti in uscita sincronizzati con il clock X Logica i Logica Ingressi combinat. combinatoria per uscite per stato futuro (ingressi dei Z k flipflop) Uscite Clock Reazione di stato

Macchine di Moore e di Mealy
Diagrammi degli stati equivalenti Macchina di Moore ( Reset)/0 Reset Macchina di Mealy Reset/0 Reset [0] Reset D Reset/0 50/0 N 50 50 50 100 50 100/0 100/0 [0] D 100/1 50/0 N 100 100 50 100/0 [0] 50 100 /1 150 150 [1] Reset Reset/1 Uscite associate con lo stato Uscite associate con la transizione

Stati o transizioni? Una macchina di Mealy in genere ha meno stati di una di Moore a parita’ di sequenza di uscita Stesso comportamento ingresso/uscita Diverso numero di stati S0 00 S0 IN IN S1 01 S1 1 ASM equivalenti IN IN S2 10 H.OUT H.OUT IN

Comportamento nel tempo delle macchine di Moore De-progettate questo circuito: Ingresso X Uscita Z Stato A, B = Z Due metodi per de-progettazione: • Ad hoc: provare combinazioni di ingresso per derivare tabella di transizione • Formale: derivare le transizioni analizzando il circuito

De-progettazione ad hoc Comportamento in risposta alla sequenza : Tabella di transizione degli stati parziale

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+

ASM completa per la macchina di Moore da identificare Nota: tutte le uscite sono associate con gli stati Non ci sono uscite dipendenti dagli ingressi (macchina di Moore)

De-progettate questa macchina di Mealy Ingresso X, Uscita Z, Stato A, B Il registro di stato ha un FF D ed un FF J-K

Metodo ad hoc Comportamento nel tempo con sequenza di ingresso : Notate le alee su Z! Uscite valide al fronte di discesa successivo del clock Tabella di transizione parziale basata sulle forme d’onda

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 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 A+ B+ Z

ASM per la macchina di Mealy da identificare S0 = 00, S1 = 01, S2 = 10, S3 = 11 Nota: alcune uscite dipendono dalle transizioni, altre dagli stati (macchina di Mealy)

Variante macchina di Moore (anche detta macchina di Mealy sincrona) Clock X i Z Ingressi Logica k Uscite combinatoria per uscite e stato futuro Registro di stato Reazione Clock di stato Uscite e stati memorizzati: “risponde” dopo un ciclo di clock (Moore) ma non ci sono alee sulle uscite!

Macchina di Mealy X i Z Ingressi Logica k Uscite combinatoria per uscite e stato futuro Registro di stato Reazione Clock di stato Uscite non memorizzate: “risponde” immediatamente (Mealy) ma puo’ avere alee sulle uscite!

Specifiche informali di FSM
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

Riconoscitore di stringa finita 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: … Z: … X: … Z: …

Riconoscitore di stringa finita Passo 2. Disegnare diagramma degli stati/ASM per le due stringhe che vanno riconosciute, cioe’ 010 ed 100. Reset S0 [0] Diagramma degli stati di Moore Reset manda la FSM nello stato S0 S1 S4 [0] [0] S2 S5 [0] [0] S3 S6 Rimane per sempre nello stato Produce 1 in uscita [1] [0]

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) Reset S0 [0] S1 S4 [0] [0] S2 S5 [0] [0] S3 S6 [1] [0]

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 Reset S0 [0] S1 S4 [0] [0] S2 S5 [0] [0] S3 S6 [1] [0]

Riconoscitore di stringa finita S2, S5 mancano ancora di alcune transizioni 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 S4 [0] [0] Diagramma degli stati finale S2 S5 [0] [0] S3 S6 [1] [0]

Riconoscitore di stringa finita module string title '010/100 string recognizer state machine Josephine Engineer, Itty Bity Machines, Inc.' u1 device 'p22v10'; "Input Pins clk, X, RESET pin 1, 2, 3; "Output Pins Q0, Q1, Q2, Z pin 19, 20, 21, 22; Q0, Q1, Q2, Z istype 'pos,reg'; "State registers SREG = [Q0, Q1, Q2, Z]; S0 = [0,0,0,0]; " Reset state S1 = [0,0,1,0]; " strings of the form ...0 S2 = [0,1,0,0]; " strings of the form ...01 S3 = [0,1,1,1]; " strings of the form S4 = [1,0,0,0]; " strings of the form ...1 S5 = [1,0,1,0]; " strings of the form ...10 S6 = [1,1,0,0]; " strings of the form equations [Q0.ar, Q1.ar, Q2.ar, Z.ar] = RESET; "Reset to S0 state_diagram SREG state S0: if X then S4 else S1; state S1: if X then S2 else S1; state S2: if X then S4 else S3; state S3: if X then S2 else S6; state S4: if X then S4 else S5; state S5: if X then S2 else S6; state S6: goto S6; test_vectors ([clk, RESET, X] -> [Z]) [0,1,.X.] -> [0]; [.C.,0,0] -> [0]; [.C.,0,1] -> [0]; [.C.,0,0] -> [1]; end string; Descrizione ABEL

Riconoscitore di stringa finita Riassunto del procedimento: • 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

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: , 001, 011, 010, 110, 111, 101, 100 Esempio di comportamento corretto di ingresso/uscita: Ingresso di modo M 1 Stato presente 000 001 010 110 111 101 Stato futuro (Z2 Z1 Z0) 001 010 110 111 101

Contatore complesso Uno stato per ogni combinazione di uscita Aggiungere gli archi opportuni in base al modo Reset S0 [000] S1 [001] S2 [010] S3 [011] S4 [100] S5 [101] S6 [110] S7 [111]

Contatore complesso module counter title 'combination binary/gray code upcounter Josephine Engineer, Itty Bity Machines, Inc.' u1 device 'p22v10'; "Input Pins clk, M, RESET pin 1, 2, 3; "Output Pins Z0, Z1, Z2 pin 19, 20, 21; Z0, Z1, Z2 istype 'pos,reg'; "State registers SREG = [Z0, Z1, Z2]; S0 = [0,0,0]; S1 = [0,0,1]; S2 = [0,1,0]; S3 = [0,1,1]; S4 = [1,0,0]; S5 = [1,0,1]; S6 = [1,1,0]; S7 = [1,1,1]; equations [Z0.ar, Z1.ar, Z2.ar] = RESET; "Reset to state S0 state_diagram SREG state S0: goto S1; state S1: if M then S3 else S2; state S2: if M then S6 else S3; state S3: if M then S2 else S4; state S4: if M then S0 else S5; state S5: if M then S4 else S6; state S6: goto S7; state S7: if M then S5 else S0; test_vectors ([clk, RESET, M] -> [Z0, Z1, Z2]) [0,1,.X.] -> [0,0,0]; [.C.,0,0] -> [0,0,1]; [.C.,0,0] -> [0,1,0]; [.C.,0,1] -> [1,1,0]; [.C.,0,1] -> [1,1,1]; [.C.,0,1] -> [1,0,1]; [.C.,0,0] -> [1,1,0]; [.C.,0,0] -> [1,1,1]; end counter; Descrizione ABEL

Controllore di semaforo 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.

Controllore di semaforo Figura dell’incrocio: Secondaria C HL FL Principale Principale FL HL C Secondaria

Controllore di semaforo • Tabella degli ingressi e delle uscite: Segnale di ingresso reset C TS TL Segnale di uscita HG, HY, HR FG, FY, FR ST Descrizione porta la FSM nello stato iniziale presenza veicolo su strada secondaria fine intervallo di tempo breve fine intervallo di tempo corto 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)

Controllore di semaforo Completamento di ASM: Iniziare con sequenza e uscite di base: S S 3 H.HG H.FR H.HR H.FY S 1 S 2 H.HY H.FR H.HR H.FG

Controllore di semaforo Decidere condizioni di uscita per S0: Veicolo in attesa E fine dell’intervallo lungo: C • TL Frammenti equivalenti di ASM

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

Controllore di semaforo Condizione di uscita per S2: nessun veicolo OPPURE fine dell’intervallo lungo ASM completa per il controllore di semaforo

Controllore di semaforo Confrontate con il diagramma degli stati: S0: HG S1: HY S2: FG S3: FY 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

Controllore di semaforo module traffic title 'traffic light FSM' u1 device 'p22v10'; "Input Pins clk, C, RESET, TS, TL pin 1, 2, 3, 4, 5; "Output Pins Q0, Q1, HG, HY, HR, FG, FY, FR, ST pin 14, 15, 16, 17, 18, 19, 20, 21, 22; Q0, Q1 istype 'pos,reg'; ST, HG, HY, HR, FG, FY, FR istype 'pos,com'; "State registers SREG = [Q0, Q1]; S0 = [ 0, 0]; S1 = [ 0, 1]; S2 = [ 1, 0]; S3 = [ 1, 1]; equations [Q0.ar, Q1.ar] = RESET; HG = !Q0 & !Q1; HY = !Q0 & Q1; HR = (Q0 & !Q1) # (Q0 & Q1); FG = Q0 & !Q1; FY = Q0 & Q1; FR = (!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 test_vectors ([clk,RESET, C, TS, TL]->[SREG,HG,HY,HR,FG,FY,FR,ST]) [.X., 1,.X.,.X.,.X.]->[ S0, 1, 0, 0, 0, 0, 1, 0]; [.C., 0, 0, 0, 0]->[ S0, 1, 0, 0, 0, 0, 1, 0]; [.C., 0, 1, 0, 1]->[ S1, 0, 1, 0, 0, 0, 1, 0]; [.C., 0, 1, 0, 0]->[ S1, 0, 1, 0, 0, 0, 1, 0]; [.C., 0, 1, 1, 0]->[ S2, 0, 0, 1, 1, 0, 0, 0]; [.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]; [.C., 0, 1, 1, 0]->[ S0, 1, 0, 0, 0, 0, 1, 0]; end traffic; Descrizione ABEL

Serratura a combinazione numerica 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

Serratura a combinazione numerica Capire il problema: disegnare lo schema a blocchi... Dati dall’operatore Combinazione interna Ingressi: Reset Enter Key-In L0, L1, L2 Uscite: Unlock Error

Serratura a combinazione numerica 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 Entra in START quando c’e’ RESET Esce da START quando ENTER e’ stato premuto Continua se Key-In e’ uguale ad L0

Serratura a combinazione numerica Cammino per sbloccare: Attendere che Enter sia stato premuto Confrontare Key-In

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 Errore in COMP0 va ad IDLE0' Errore in COMP1 va ad IDLE1' Errore in COMP2 va ad ERROR3

Serratura a combinazione numerica Diagramma degli stati equivalente

Serratura a combinazione numerica module lock title 'comb. lock FSM' u1 device 'p22v10'; "Input Pins clk, RESET, ENTER, L0, L1, L2, KI pin 1, 2, 3, 4, 5, 6, 7; "Output Pins Q0, Q1, Q2, Q3, UNLOCK, ERROR pin 16, 17, 18, 19, 14, 15; Q0, Q1, Q2, Q3 istype 'pos,reg'; UNLOCK, ERROR istype 'pos,com'; "State registers SREG = [Q0, Q1, Q2, Q3]; START = [ 0, 0, 0, 0]; COMP0 = [ 0, 0, 0, 1]; IDLE0 = [ 0, 0, 1, 0]; COMP1 = [ 0, 0, 1, 1]; IDLE1 = [ 0, 1, 0, 0]; COMP2 = [ 0, 1, 0, 1]; DONE = [ 0, 1, 1, 0]; 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]; equations [Q0.ar, Q1.ar, Q2.ar, Q3.ar] = RESET; UNLOCK = !Q0 & Q1 & Q2 & !Q3;"asserted in DONE ERROR = Q0 & !Q1 & Q2 & Q3; "asserted in ERROR3 state_diagram SREG state START: if (RESET # !ENTER) then START else COMP0; state COMP0: if (KI == L0) then IDLE0 else IDLE0p; state IDLE0: if (!ENTER) then IDLE0 else COMP1; state COMP1: if (KI == L1) then IDLE1 else IDLE1p; state IDLE1: if (!ENTER) then IDLE1 else COMP2; state COMP2: if (KI == L2) then DONE else ERROR3; state DONE: if (!RESET) then DONE else START; state IDLE0p:if (!ENTER) then IDLE0p else ERROR1; state ERROR1:goto IDLE1p; state IDLE1p:if (!ENTER) then IDLE1p else ERROR2; state ERROR2:goto ERROR3; state ERROR3:if (!RESET) then ERROR3 else START; test_vectors end lock; Descrizione ABEL

Riassunto del capitolo
Comportamento fondamentale nel tempo di una FSM • 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

Capitolo 8: Progetto di Macchine a Stati Finiti Reti Logiche Contemporary Logic Design Randy H. Katz University of California, Berkeley May 1993.

Presentazioni simili

Presentazione sul tema: "Capitolo 8: Progetto di Macchine a Stati Finiti Reti Logiche Contemporary Logic Design Randy H. Katz University of California, Berkeley May 1993."— Transcript della presentazione:

Presentazioni simili

Sul progetto

Feed-back

Entrare

Autorizzarsi attraverso i social network:

Capitolo 8: Progetto di Macchine a Stati Finiti Reti Logiche Contemporary Logic Design Randy H. Katz University of California, Berkeley May 1993.

Presentazioni simili

Presentazione sul tema: "Capitolo 8: Progetto di Macchine a Stati Finiti Reti Logiche Contemporary Logic Design Randy H. Katz University of California, Berkeley May 1993."— Transcript della presentazione:

Presentazioni simili

Sul progetto

Feed-back