relazioni di fisica generale ii (progettazione logica...
TRANSCRIPT
Relazioni di Fisica Generale II
(Progettazione Logica Digitale)
Marco Trentini
19 febbraio 2012
Prefazione
Questo documento espone le esercitazioni di laboratorio dell’insegnamento di Fisica GeneraleII, modulo Progettazione Logica Digitale, tenuto dal professore Giuliano Boella per il corsodi laurea specialistica in informatica dell’università Milano-Bicocca.
Questo report è stato realizzato con LATEX2ε. Per le figure è stato utilizzato il tool Xfig.
1
Indice
1 Introduzione 7
2 Trasmissione seriale asincrona (FPGA) 92.1 Esposizione del problema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92.2 Descrizione della soluzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92.3 Descrizione del progetto logico . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.3.1 Simulatore di trasmissione . . . . . . . . . . . . . . . . . . . . . . . . . 102.3.2 Ricevitore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132.3.3 Eco . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.4 Listato del sorgente XPLA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212.5 Test e risultati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3 Trasmissione seriale sincrona (FPGA) 293.1 Esposizione del problema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293.2 Descrizione della soluzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293.3 Descrizione del progetto logico . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.3.1 Simulatore di trasmissione . . . . . . . . . . . . . . . . . . . . . . . . . 303.3.2 Ricevitore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333.3.3 Eco . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.4 Listato del sorgente XPLA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383.5 Test e risultati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
4 Semaforo intelligente (FPGA) 464.1 Esposizione del problema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
4.1.1 Funzionamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464.2 Descrizione della soluzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484.3 Descrizione del progetto logico . . . . . . . . . . . . . . . . . . . . . . . . . . 48
4.3.1 Introduzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484.3.2 Controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484.3.3 Data unit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 514.3.4 Accensioni luci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.4 Listato del sorgente XPLA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594.5 Test e risultati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
5 Semaforo intelligente (microcontroller) 705.1 Esposizione del problema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 705.2 Descrizione della soluzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 725.3 Descrizione del progetto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
5.3.1 Init . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 725.3.2 Temporizzatore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 725.3.3 Lettura sensori e via preferenziale . . . . . . . . . . . . . . . . . . . . 75
2
INDICE 3
5.3.4 Ricerca stato prossimo . . . . . . . . . . . . . . . . . . . . . . . . . . . 755.3.5 Accensione gialli . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 765.3.6 Cambio luci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
5.4 Listato del sorgente assembly . . . . . . . . . . . . . . . . . . . . . . . . . . . 785.5 Test e risultati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
6 Conclusione 84
Elenco delle tabelle
2.1 Tabella di verità della logica combinatoria del simulatore di trasmissione . . . 122.2 Tabella di verità del decoder applicato alle uscite dell’UBC del ricevitore . . . 17
3.1 Tabella di verità della logica combinatoria del simulatore di trasmissione . . . 323.2 Tabella di verità del decoder applicato alle uscite dell’UBC del ricevitore . . . 35
4.1 Tabella stati/vie/luci verdi del semaforo . . . . . . . . . . . . . . . . . . . . . 464.2 Tabella di verità del decoder applicato alle uscite dell’UBC del controller . . . 514.3 Decodifica delle luci rosse del semaforo . . . . . . . . . . . . . . . . . . . . . . 584.4 Decodifica delle luci verdi del semaforo . . . . . . . . . . . . . . . . . . . . . . 59
4
Elenco delle figure
2.1 Sincronizzazione del segnale meccanico . . . . . . . . . . . . . . . . . . . . . . 102.2 Diagramma degli stati dell’UBC del simulatore di trasmissione . . . . . . . . 112.3 Schema dell’UBC del simulatore di trasmissione . . . . . . . . . . . . . . . . . 112.4 Schema dell’USR del simulatore di trasmissione . . . . . . . . . . . . . . . . . 122.5 Schema della logica combinatoria del simulatore di trasmissione . . . . . . . . 132.6 Campionamento del messaggio con Fx = F0 . . . . . . . . . . . . . . . . . . . 142.7 Campionamento del messaggio con Fx = 2 · F0 . . . . . . . . . . . . . . . . . 142.8 Campionamento del messaggio con Fx = 4 · F0 . . . . . . . . . . . . . . . . . 152.9 Campionamento del messaggio con Fx = 8 · F0 . . . . . . . . . . . . . . . . . 152.10 Diagramma degli stati dell’UBC del ricevitore . . . . . . . . . . . . . . . . . . 162.11 Schema dell’UBC del ricevitore . . . . . . . . . . . . . . . . . . . . . . . . . . 162.12 Schema della logica combinatoria del ricevitore . . . . . . . . . . . . . . . . . 182.13 Schema dell’USR del ricevitore . . . . . . . . . . . . . . . . . . . . . . . . . . 182.14 Diagramma degli stati dell’UBC dell’eco . . . . . . . . . . . . . . . . . . . . . 192.15 Schema dell’UBC dell’eco . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192.16 Schema dell’USR dell’eco . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202.17 Screenshot della prima simulazione . . . . . . . . . . . . . . . . . . . . . . . . 242.18 Screenshot della prima simulazione . . . . . . . . . . . . . . . . . . . . . . . . 252.19 Screenshot della seconda simulazione . . . . . . . . . . . . . . . . . . . . . . . 272.20 Screenshot della seconda simulazione . . . . . . . . . . . . . . . . . . . . . . . 28
3.1 Sincronizzazione del segnale meccanico . . . . . . . . . . . . . . . . . . . . . . 303.2 Diagramma degli stati dell’UBC del simulatore di trasmissione . . . . . . . . 313.3 Schema dell’UBC del simulatore di trasmissione . . . . . . . . . . . . . . . . . 313.4 Schema dell’USR del simulatore di trasmissione . . . . . . . . . . . . . . . . . 323.5 Schema della logica combinatoria del simulatore di trasmissione . . . . . . . . 333.6 Campionamento del messaggio con Fx = F0 sfasata di 180◦ . . . . . . . . . . 343.7 Diagramma degli stati dell’UBC del ricevitore . . . . . . . . . . . . . . . . . . 343.8 Schema dell’UBC del ricevitore . . . . . . . . . . . . . . . . . . . . . . . . . . 353.9 Schema della logica combinatoria del ricevitore . . . . . . . . . . . . . . . . . 363.10 Schema dell’USR del ricevitore . . . . . . . . . . . . . . . . . . . . . . . . . . 363.11 Schema dell’USR dell’eco . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373.12 Screenshot della prima simulazione . . . . . . . . . . . . . . . . . . . . . . . . 413.13 Screenshot della prima simulazione . . . . . . . . . . . . . . . . . . . . . . . . 423.14 Screenshot della seconda simulazione . . . . . . . . . . . . . . . . . . . . . . . 443.15 Screenshot della seconda simulazione . . . . . . . . . . . . . . . . . . . . . . . 45
4.1 Schema dell’incrocio di due strade . . . . . . . . . . . . . . . . . . . . . . . . 474.2 Comportamento temporale del semaforo relativo allo stato S0 . . . . . . . . . 484.3 Schema della macchina sequenziale sincrona del sistema . . . . . . . . . . . . 49
5
ELENCO DELLE FIGURE 6
4.4 Schema a blocchi del sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . 504.5 Diagramma degli stati del controller . . . . . . . . . . . . . . . . . . . . . . . 514.6 Forme d’onda del temporizzatore e dei segnali di controllo per la data unit . . 524.7 Schema dell’UBC del controller . . . . . . . . . . . . . . . . . . . . . . . . . . 534.8 Schema dell’USR del blocco di acquisizione input . . . . . . . . . . . . . . . . 544.9 Schema logico del blocco via preferenziale . . . . . . . . . . . . . . . . . . . . 544.10 Diagramma degli stati del contatore per la ricerca sequenziale dello stato prossimo 554.11 Schema dell’UBC del blocco per la ricerca sequenziale dello stato prossimo . . 554.12 Schema dell’USR del blocco stato presente . . . . . . . . . . . . . . . . . . . . 564.13 Schema logico del blocco di decisione . . . . . . . . . . . . . . . . . . . . . . . 574.14 Schema di decodifica dell’accensione delle luci del semaforo . . . . . . . . . . 584.15 Screenshot della prima simulazione . . . . . . . . . . . . . . . . . . . . . . . . 634.16 Screenshot della prima simulazione . . . . . . . . . . . . . . . . . . . . . . . . 644.17 Screenshot della seconda simulazione . . . . . . . . . . . . . . . . . . . . . . . 664.18 Screenshot della seconda simulazione . . . . . . . . . . . . . . . . . . . . . . . 674.19 Screenshot della terza simulazione . . . . . . . . . . . . . . . . . . . . . . . . 684.20 Screenshot della terza simulazione . . . . . . . . . . . . . . . . . . . . . . . . 69
5.1 Piedinatura del microcontroller ST6225 . . . . . . . . . . . . . . . . . . . . . 705.2 Schema a blocchi dell’architettura del microcontroller . . . . . . . . . . . . . 715.3 Schema logico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 735.4 Utilizzo delle porte di I/O del microcontroller . . . . . . . . . . . . . . . . . . 745.5 Screenshot del simulatore SIMST6 . . . . . . . . . . . . . . . . . . . . . . . . 83
Capitolo 1
Introduzione
Durante il corso di Fisica Generale II (modulo di Progettazione Logica Digitale) sono stateanalizzate quattro esercitazioni volte alla comprensione di alcune delle metodologie per larealizzazione di macchine sequenziali.Nelle prime tre esercitazioni si è utilizzato un simulatore (XPLA Professional della Xilinx)del circuito integrato FPGA PZ5064-xA44. In questo componente sono presenti struttureAND-OR e flip-flop (macrocelle), le cui interconnessioni sono da realizzarsi attraverso pro-grammazione tramite il linguaggio Abel, un linguaggio di alto livello (HDL). Una volta scrittoil programma in Abel, il simulatore software permette di simulare il comportamento del com-ponente FPGA senza doverlo programmare fisicamente (il simulatore è in grado di produrreanche il file speciale per la programmazione fisica del componente).Nell’ultima esercitazione si è visto un metodo alternativo di come realizzare una macchinasequenziale. In questo caso si è utilizzato un simulatore del microcontroller ST6225. Inquesto componente è presente un’architettura del tutto simile a quella degli attuali PC IBMcompatibili (controller, alu, stack, PC, porte I/O, RAM, ROM, bus, timer, ecc.).Il controller ha un set base di istruzioni macchina che permettono il funzionamento delcomponente. Un’astrazione di queste istruzioni in un linguaggio di basso livello, linguaggioassembly, permette di programmare il componente (con un apposito compilatore che generaistruzioni macchina) in un linguaggio facilmente comprensibile alla mente umana. Una voltascritto il programma in assembly, il simulatore software permette di simulare il funzionamen-to del componente ST6225.
Le quattro esercitazioni sviluppate sono:
1. Trasmissione seriale asincrona (con FPGA);
2. Trasmissione seriale sincrona (con FPGA);
3. Semaforo intelligente (con FPGA);
4. Semaforo intelligente (con microcontroller).
Scopo della prima esercitazione è stato quello di progettare un sistema digitale asincrono chepermette la trasmissione seriale di messaggi (una sequenza di bit) tra due macchine sequen-ziali: un simulatore di trasmissione e un ricevitore. Ognuna delle due macchine sequenzialipossiede un proprio generatore di clock e quindi la comunicazione tra esse è asincrona. Perla realizzazione delle macchine sequenziali si è fatto uso di un componente FPGA.
Scopo della seconda esercitazione è stato quello di progettare un sistema digitale sincro-no che permette la trasmissione seriale di messaggi (una sequenza di bit) tra due macchine
7
CAPITOLO 1. INTRODUZIONE 8
sequenziali: un simulatore di trasmissione e un ricevitore. Le due macchine sequenziali han-no un generatore di clock in comune e quindi la comunicazione tra esse è sincrona. Per larealizzazione delle macchine sequenziali si è fatto uso di un componente FPGA.
Scopo della terza esercitazione è stato quello di progettare un sistema digitale sincrono chepermette la gestione di un semaforo intelligente che si adatta alle condizioni del traffico. Perla realizzazione della macchina sequenziale si è fatto uso di un componente FPGA.
Scopo della quarta esercitazione è stato quello di utilizzare un metodo alternativo per laprogettazione di macchine sequenziali. In questa esperienza, il cui scopo è lo stesso dellaterza, si è utilizzato un microcontroller programmabile in assembly.
Capitolo 2
Trasmissione seriale asincrona(FPGA)
2.1 Esposizione del problema
Si vuole trasmettere una stringa di 7 bit fra due macchine distanti, collegate da un’unica con-nessione elettrica (segnale più massa). Il trasmettitore è una macchina sequenziale sincrona.Il ricevitore è anch’esso una macchina sequenziale sincrona. Le due macchine sono asincronel’una rispetto all’altra poichè hanno ciascuno un proprio generatore di clock. Per realizzarela comunicazione fra le due macchine viene stabilito un protocollo di trasmissione.Viene definita una struttura del messaggio nella forma seguente: viene trasmesso un treno di9 bit, di cui il primo (start bit) sempre a 1 e l’ultimo (stop bit) sempre a 0. In mezzo stannoi 7 bit (B0, . . . , B6) che portano l’informazione. Tra due messaggi la linea resta a 0.Viene stabilita la frequenza nominale di trasmissione F0. Il periodo, inverso della frequenzaF0, è la durata di trasmissione di ogni singolo bit.Viene stabilita la tolleranza sulla frequenza reale: Fr = F0 ± 1%, determinata dalla stabilitàe dalla ripetibilità dei generatori di clock.Bisogna assicurare l’integrità della comunicazione rispettando protocollo e tolleranza.Si devono progettare e realizzare tre macchine:
• Il simulatore di trasmissione trasmette il messaggio alla frequenza F0 in modo da poterimpostare a volontà il contenuto dei bit B0, . . . , B6 con la possibilità di emettere imessaggi immediatamente uno dopo l’altro (senza pausa) oppure con l’interposizionedi qualche periodo di clock (pausa);
• Il ricevitore riceve il dato seriale, lo acquisisce e lo presenta in parallelo sull’uscita conun segnale di ’messaggio pronto’;
• Il ritrasmettitore (o eco), che ha il clock in comune con il ricevitore, ritrasmette in modoseriale alla frequenza F0 il messaggio ricevuto permettendo di verificare la correttezzadella comunicazione attraverso un confronto fra i due messaggi, quello inviato e quelloricevuto.
2.2 Descrizione della soluzione
Si tratta di progettare un sistema digitale asincrono contenente al suo interno due sottosistemidigitali sincroni: il blocco relativo al simulatore di trasmissione e il blocco relativo al ricevitoreed eco. Quindi la comunicazione tra questi due blocchi avviene in modo asincrono (poichè
9
CAPITOLO 2. TRASMISSIONE SERIALE ASINCRONA (FPGA) 10
hanno ciascuno un proprio generatore di clock).Per ognuna delle tre macchine (simulatore di trasmissione, ricevitore ed eco) è necessarioprogettare un’unità dati per l’elaborazione dei dati ed un’unità di controllo composta da unamacchina a stati con logica sequenziale (sincrona) e da circuiti a logica combinatoria. L’unitàdi controllo è composta sostanzialmente da un contatore UBC (Universal Binary Counter)per la rappresentazione degli stati della macchina sequenziale più eventuali circuiti logicinecessari per gestire le condizioni della logica combinatoria, mentre l’unità dati è compostasostanzialmente da un registro a scorrimento USR (Universal Shift Register).
2.3 Descrizione del progetto logico
2.3.1 Simulatore di trasmissione
Introduzione
Compito del simulatore di trasmissione è di trasmettere messaggi di 7+2 bit, eventualmenteinserendo delle pause tra l’invio di un messaggio e l’altro. Un segnale di start/stop meccanico(es. interruttore) indica se spedire o meno il messaggio. I 7 bit del messaggio sono presiin parallelo e trasmessi in seriale. Poichè il segnale meccanico è un ingresso asincrono, ènecessario sincronizzarlo con il clock del simulatore di trasmissione. Questo può essere fattoutilizzando un flip-flop D come mostrato in Figura 2.1 (sempre che la durata del segnaleesterno IN sia maggiore del periodo del clock).
IN D Q
QCLK
CLK
IN
I
I
Figura 2.1: Sincronizzazione del segnale meccanico
Unità di controllo
Poichè dobbiamo essere in grado di conoscere quando un messaggio è stato inviato completa-mente (ad esempio per sapere quando caricare un altro messaggio), abbiamo bisogno di unamacchina a stati sequenziale (sincrona) che farà parte dell’unità di controllo del simulatoredi trasmissione.I bit da trasmettere sono 9 e quindi dobbiamo essere in grado di contare almeno fino a 9.Un contatore binario realizzerà gli stati delle macchina. In particolare useremo un UBC con4 flip-flop D per realizzare una macchina sequenziale sincrona con 16 stati, 7 dei quali sonoridondanti e saranno utilizzati per inserire eventuali cicli di clock di pausa tra l’invio di unmessaggio e l’altro. Segue in Figura 2.2 il diagramma degli stati.Lo stato S15 è lo stato di attesa. In questo stato se I è a 1 allora si incomincia a contare,
altrimenti (I a 0) si attende (sempre nello stato S15) che I salga a 1. Se da S15 si passa subitoa S7 non ci sarà nessun ciclo di clock di pausa e quindi i messaggi saranno perfettamentecontigui. Se si riparte da S0 ci saranno ben 7 cicli di clock di pausa (e quindi 7 zeri) primadell’invio (eventuale) del messaggio successivo.
CAPITOLO 2. TRASMISSIONE SERIALE ASINCRONA (FPGA) 11
I=1
S0 S S S S S5 S6 S7 S8
S9SSSSS 10111314 12
1 2 3 4
S15
I=0
I=1
Figura 2.2: Diagramma degli stati dell’UBC del simulatore di trasmissione
Segue in Figura 2.3 lo schema dell’UBC.Il segnale SR, segnale di reset (reset della macchina sullo stato S0), è posto sempre a 0 in
0
UBC
CLK
TC
0
P0 P1 P2 P3
Q1 Q2 Q3Q0
CE
PR
SR
Figura 2.3: Schema dell’UBC del simulatore di trasmissione
quanto non necessario. Il segnale TC (AND delle 4 uscite dei flip-flop) indica (quando a 1)lo stato S15. Il segnale PR, segnale di preset, serve a resettare la macchina in uno stato benpreciso. Lo stato di preset è determinato dalla configurazione posta su P0, P1, P2, P3. Nelnostro caso i possibili stati di preset sono S0, . . . , S7, quindi P3 è posto sempre a 0 mentre suirestanti viene posta una configurazione a seconda di quanti cicli di clock di pausa si voglionoinserire tra l’invio di un messaggio e l’altro. Il segnale PR è attivo quando entrambi i segnaliTC e I sono a 1. Il segnale CE abilita il conteggio del contatore binario. Di fatto il contatoredeve contare sempre tranne quando si trova nello stato S15 (TC a 1). I segnali SR, PR eCE hanno una priorità di funzionamento gerarchica SR-PR-CE, dove SR è il segnale conmaggiore priorità.La funzione di comando Di dell’i-esimo flip-flop D del blocco funzionale UBC è:
Di = SR · (PR · Pi + PR · (CE · (Qi ⊕ (Qi−1 ·Qi−2 · . . . ·Q0 · 1)) + CE ·Qi))
con Q−1 = 1.
Unità dati
L’unità dati del simulatore di trasmissione è composta da un USR (Universal Shift Regi-ster) posto in modalità PISO (Parallel Input Serial Output). Poichè dobbiamo trasmettere
CAPITOLO 2. TRASMISSIONE SERIALE ASINCRONA (FPGA) 12
sequenze di 9 bit di cui uno (l’ultimo) sempre a 0 ci servirà un UBC con 8 flip-flop (non ènecessario un flip-flop per memorizzare l’ultimo bit 0).Segue in Figura 2.4 lo schema dell’USR.Trattandosi di un USR in modalità PISO, il segnale (seriale) di ingresso IN è posto sempre
MS
CLK
USR (piso)
P0 P1 P2 P3 P4 P5 P6 P7
OUT
Q0 Q1 Q2 Q3 Q4 Q5 Q6 Q7
SH
PL
SR
IN00
1
1
LS
Figura 2.4: Schema dell’USR del simulatore di trasmissione
a 0, così come il segnale di reset SR (che resetta tutte le uscite Qi a 0). Il segnale SH dishift delle uscite Qi è posto sempre a 1 in quanto il registro a scorrimento deve shiftare dicontinuo (anche quando le uscite sono tutte a 0). Il segnale preload PL quando attivo a 1carica la configurazione posta su P0, . . . , P7 sulle uscite Q0, . . . , Q7. P7 è posto sempre a 1in quando è lo start bit. In P0, . . . , P6 ci sarà di volta in volta il messaggio che deve esseretrasmesso. E’ dall’uscita Q7 che escono tutti i bit del messaggio in modo seriale.Il segnale PL è pilotato dalla logica combinatoria dell’unità di controllo. In particolare èattivo quando ci si trova nello stato S15 e quando il segnale I è a 1 (ossia si vuole spedire unmessaggio). I segnali SR, PL e SH hanno una priorità di funzionamento gerarchica SR-PL-SH, dove SR è il segnale con maggiore priorità.La funzione di comando Di dell’i-esimo flip-flop D del blocco funzionale USR è:
Di = SR · (PL · Pi + PL · (SH ·Qi−1 + SH ·Qi))
con Q−1 = IN = 0.
Logica combinatoria
La logica combinatoria di questo sistema coinvolge i segnali TC, I, PR, CE e PL. In parti-colare i segnali PR, CE e PL sono abilitati a seconda delle configurazioni di TC e I comemostrato nella Tabella 2.1.Dalla precedente tabella di verità seguono le seguenti funzioni booleane:
TC I PR CE PL0 0 0 1 01 0 0 0 00 1 0 1 01 1 1 x 1
Tabella 2.1: Tabella di verità della logica combinatoria del simulatore di trasmissione
CAPITOLO 2. TRASMISSIONE SERIALE ASINCRONA (FPGA) 13
TC = Q0 ·Q1 ·Q2 ·Q3
PR = TC · I
CE = TC · I + TC · I = TC
PL = TC · I
da cui è possibile ricavare lo schema logico di Figura 2.5.
TC
I
PL, PR
CE
Figura 2.5: Schema della logica combinatoria del simulatore di trasmissione
2.3.2 Ricevitore
Introduzione
Compito del ricevitore è acquisire correttamente i messaggi inviati dal simulatore di trasmis-sione su linea seriale (segnale DL) e presentarli quindi in parallelo sull’uscita con un segnaledi ’messaggio pronto’.È necessaria una macchina a stati sequenziale (sincrona) che permetta di scandire il tempodi campionamento e di sapere quando il messaggio è stato completamente campionato. Uncontatore binario realizzerà gli stati delle macchina. Se si assume che ad ogni colpo di clockcorrisponde uno stato della macchina possiamo rappresentare con 11 stati la nostra ipoteticamacchina sequenziale sincrona: 9 stati per i bit del messaggio (7 + 2), uno stato che indicache il dato è pronto e uno stato di attesa (del bit di start). Dobbiamo anche considerare cheil fronte di arrivo del segnale viene rilevato nel ricevitore con una indeterminazione pari alladurata di un ciclo di clock Fx del ricevitore.La frequenza con la quale opera il ricevitore non può essere la stessa del trasmettitore. Secosì fosse con un 2% di tolleranza globale sulle frequenze reali si avrebbe molto probabilmenteperdita di informazione durante la fase di campionamento del segnale. Inoltre, poichè il frontedi arrivo del segnale viene rilevato nel ricevitore con una indeterminazione pari alla durata diun ciclo di clock, di fatto non potremmo campionare il primo bit (anche se sappiamo esseresempre a 1). Questa situazione è riportata in Figura 2.6.Quindi la frequenza Fx del ricevitore deve essere multipla della frequenza nominale secondo
le potenze di 2, cioè Fx = 2K · F0 perchè si opera in binario (e quindi per nostra comodità).Bisogna trovare il k minimo che rende sicura la comunicazione. Alla frequenza multipla Fx
nominale, il campionamento del bit in ricezione va fatto a centro bit. Questo è dovuto dalfatto che al variare della frequenza reale rispetto a quella nominale il campionamento anticipao ritarda. Benchè il campionamento a centro bit potrebbe funzionare bene per i primi bitdobbiamo assicurarci che non sbordi dall’ultimo bit (poichè il ritardo o l’anticipo si potreb-bero propagare e moltiplicare bit dopo bit). In sostanza dobbiamo rispettare la seguente
CAPITOLO 2. TRASMISSIONE SERIALE ASINCRONA (FPGA) 14
del fronte
F0
messaggio
Fx
1 0B0 B1B6
camp camp camp camp camprilevamento
Figura 2.6: Campionamento del messaggio con Fx = F0
disequazione.Stati liberi
Stati totali> 2% (2.1)
k = 1 , Fx = 2 · F0
In questo caso abbiamo a disposizione 2 stati macchina per ogni bit che dobbiamo cam-pionare (7+ 2) e quindi 9 · 2 = 18 stati macchina. Supponendo di campionare a centro bit (equindi sempre sull’ultimo dei due stati di ciascun bit) a questi 18 stati dobbiamo aggiungerne2 (dato pronto e attesa). Risulta quindi evidente che la formula 2.1 non sta in piedi poichèmancano addirittura 2 stati. Questa situazione è riportata in Figura 2.7.
camp
F0
messaggio1 0B0 B1
B6
Fx
camp camp camp camprilevamentodel fronte
Figura 2.7: Campionamento del messaggio con Fx = 2 · F0
k = 2 , Fx = 4 · F0
In questo caso abbiamo a disposizione 4 stati macchina per ogni bit che dobbiamo cam-pionare (7+ 2) e quindi 9 · 4 = 36 stati macchina. Supponendo di campionare a centro bit (equindi sempre sul secondo dei 4 stati di ciascun bit) dopo l’ultimo campionamento restanodue stati liberi che sono utilizzati come stato di dato pronto e stato di attesa. Applicando laformula 2.1 risulta che 0/36 = 0 < 2% e quindi non va bene. Questa situazione è riportatain Figura 2.8.
CAPITOLO 2. TRASMISSIONE SERIALE ASINCRONA (FPGA) 15
camp
F0
messaggio1 0B0 B1
B6
Fx
rilevamentodel fronte
camp camp camp camp
Figura 2.8: Campionamento del messaggio con Fx = 4 · F0
k = 3 , Fx = 8 · F0
In questo caso abbiamo a disposizione 8 stati macchina per ogni bit che dobbiamo cam-pionare (7+ 2) e quindi 9 · 8 = 72 stati macchina. Supponendo di campionare a centro bit (equindi sempre sul quarto degli 8 stati di ciascun bit) dopo l’ultimo campionamento restano4 stati liberi due dei quali sono usati per lo stato dato pronto e lo stato attesa. Quindiin definitiva gli stati macchina complessivi sono 70. Applicando la formula 2.1 risulta che2/72 = 0.0277 > 2% e quindi abbiamo trovato il valore di k minimo che rende valida ladisequazione 2.1. Questa situazione è riportata in Figura 2.9.Quindi la frequenza del ricevitore (e dell’eco) sarà 8 volte più veloce di quella del trasmet-
camp
F0
messaggio1 0B0 B1
B6
Fx
rilevamentodel fronte
camp camp camp camp
Figura 2.9: Campionamento del messaggio con Fx = 8 · F0
titore.
Unità di controllo
La macchina a stati sequenziale (sincrona) accennata in precedenza fa parte dell’unità dicontrollo del ricevitore. Useremo un UBC con 7 flip-flop D per realizzare una macchinasequenziale sincrona con 128 stati, 58 dei quali sono ridondanti. Segue in Figura 2.10 ildiagramma degli stati.Poichè il campionamento è al centro bit e poichè per ogni bit abbiamo ben 8 stati disponibili
per effettuare il campionamento, useremo gli stati S3,S11,S19,S27,S35,S43,S51,S59,S67 percampionare i 9 bit. Lo stato S68 è lo stato di messaggio pronto (TR) e l’S69 è lo stato diattesa (dello start bit). All’arrivo dello start bit da S69 si riparte da S0, altrimenti si restanello stato S69. Segue in Figura 2.11 lo schema dell’UBC.Il segnale SR, segnale di reset (reset della macchina sullo stato S0), deve essere abilitato
CAPITOLO 2. TRASMISSIONE SERIALE ASINCRONA (FPGA) 16
camp
S0 S S S S S S S S1 2 3 11 19 27 35 43
camp camp camp camp camp
SSSSS 5159676869
DL=0camp camp camp
DL=1
TR
Figura 2.10: Diagramma degli stati dell’UBC del ricevitore
decoder
P21P
I0
S69O127
O0
UBCCE
PR
SR
Q0 Q Q Q Q Q Q
P P P P P
1 2 3 4 5 6
0 3 4 5 6CLK8
0
II
I
I
I
I
1
2
3
4
5
6
campcampcampcampcampcampcampcampcamp TR
O35
Figura 2.11: Schema dell’UBC del ricevitore
quando ci si trova nello stato S69 e quando arriva il fronte di salita dello start bit (ossiaquando DL è a 1). Il segnale PR, segnale di preset, serve a resettare la macchina in uno statoben preciso. Lo stato di preset è determinato dalla configurazione posta su P0, . . . , P6. Nelnostro caso non abbiamo bisogno di tale funzione (usiamo già SR) e quindi il segnale PR èsempre a 0. Il segnale CE abilita il conteggio del contatore binario. Di fatto il contatore devecontare sempre tranne quando si trova nello stato S69.La funzione di comando Di dell’i-esimo flip-flop D del blocco funzionale UBC è:
Di = SR · (PR · Pi + PR · (CE · (Qi ⊕ (Qi−1 ·Qi−2 · . . . ·Q0 · 1)) + CE ·Qi))
con Q−1 = 1.
Logica combinatoria
Le 7 uscite dell’UBC sono utilizzate come ingressi di un decoder, che ha quindi ben 27 uscite.Il decoder abilita un’unica uscita a seconda della combinazione degli ingressi (univocamentedeterminata). Nella Tabella 2.2 viene riportato il funzionamento del decoder.
CAPITOLO 2. TRASMISSIONE SERIALE ASINCRONA (FPGA) 17
Le funzioni booleane di nostro interesse sono:
I6 I5 I4 I3 I2 I1 I0 CAMP TR S69
O0 = S0 0 0 0 0 0 0 0 0 0 0. . . 0 0 0
O3 = S3 0 0 0 0 0 1 1 1 0 0. . . 0 0 0
O11 = S11 0 0 0 1 0 1 1 1 0 0. . . 0 0 0
O19 = S19 0 0 1 0 0 1 1 1 0 0. . . 0 0 0
O27 = S27 0 0 1 1 0 1 1 1 0 0. . . 0 0 0
O35 = S35 0 1 0 0 0 1 1 1 0 0. . . 0 0 0
O43 = S43 0 1 0 1 0 1 1 1 0 0. . . 0 0 0
O51 = S51 0 1 1 0 0 1 1 1 0 0. . . 0 0 0
O59 = S59 0 1 1 1 0 1 1 1 0 0. . . 0 0 0
O67 = S67 1 0 0 0 0 1 1 1 0 0O68 = S68 1 0 0 0 1 0 0 0 1 0O69 = S69 1 0 0 0 1 0 1 0 0 1
. . . 0 0 0O127 = S127 1 1 1 1 1 1 1 0 0 0
Tabella 2.2: Tabella di verità del decoder applicato alle uscite dell’UBC del ricevitore
TR = Q6 ·Q2 ·Q0 (segnale di dato pronto)
S69 = Q6 ·Q2 ·Q0 (stato di attesa)
CAMP = Q0 ·Q1 ·Q2 (segnale di campionamento)
SR = S69 ·DL (segnale di reset del contatore)
CE = S69 (count enable contatore)
da cui è possibile ricavare lo schema logico di Figura 2.12.
Unità dati
L’unità dati del ricevitore è composta da un USR (Universal Shift Register) posto in moda-lità SIPO (Serial Input Parallel Output). Questo verrà utilizzato per campionare i messaggitrasmessi dal simulatore di trasmissione sulla linea DL. Poichè dobbiamo presentare il mes-saggio di 9 bit in uscita in parallelo ci servirà un UBC con 9 flip-flop. Segue in Figura 2.13lo schema dell’USR.Trattandosi di un USR in modalità SIPO, al segnale (seriale) di ingresso IN è collegato il
segnale seriale DL in uscita dal simulatore di trasmissione che trasporta i messaggi. Entrambii segnali SR (reset) e PL (preload) sono posti a 0 (trattandosi di un SIPO). Il segnale SH di
CAPITOLO 2. TRASMISSIONE SERIALE ASINCRONA (FPGA) 18
DL
Q
Q2
TR
S69
6
Q1
Camp
CE
SR
Q0
Figura 2.12: Schema della logica combinatoria del ricevitore
USR (sipo)
0 P1 P2 P3 P4 P5 P6
Q0 Q1 Q2 Q3 Q4 Q5 Q6
SH
PL
SR
IN
0
P
DL
Camp0
CLK8
QQ7
PP7
8
8
MS LS
Figura 2.13: Schema dell’USR del ricevitore
shift delle uscite Qi è il nostro comando che fa partire il campionamento e quindi sarà colle-gato al segnale CAMP pilotato dalla logica combinatoria dell’unità di controllo. La funzionedi comando Di dell’i-esimo flip-flop D del blocco funzionale USR è:
Di = SR · (PL · Pi + PL · (SH ·Qi−1 + SH ·Qi))
con Q−1 = IN
2.3.3 Eco
Introduzione
Compito dell’eco, che ha il clock in comune con il ricevitore, è ritrasmette in modo seriale allafrequenza F0 (quella del simulatore di trasmissione) il messaggio ricevuto (e disponibile in pa-
CAPITOLO 2. TRASMISSIONE SERIALE ASINCRONA (FPGA) 19
rallelo sulle uscite del ricevitore) permettendo di verificare la correttezza della comunicazioneattraverso un confronto fra i due messaggi, quello inviato e quello ricevuto.
Unità di controllo
Poichè la frequenza del ricevitore è 8 volte più veloce della frequenza del simulatore di tra-smissione dobbiamo essere in grado di contare otto colpi di clock del ricevitore per simulareun colpo di clock del simulatore di trasmissione. Questo è possibile con un semplice contatorea stati sequenziale (sincrono) che conta 8 in modo ciclico.In particolare useremo un UBC con 3 flip-flop D per realizzare una macchina sequenzialesincrona con 8 stati. Segue in Figura 2.14 il diagramma degli stati.In Figura 2.15 è riportato lo schema dell’UBC.
TRS0 S S S1 2 3
SSSS 4567
TRTR
TR
TRTR TR TR
Figura 2.14: Diagramma degli stati dell’UBC dell’eco
In questo caso il contatore deve essere sempre in funzione (CE sempre a 1). Al segnale SR
UBC
TC
P0 P1 P2
Q1 Q2Q0
CE
PR
SR
0
CLK8
1
Figura 2.15: Schema dell’UBC dell’eco
colleghiamo il segnale TR (dato pronto sul ricevitore). In questo modo sincronizziamo l’unitàdati dell’eco permettendo di fatto che il primo bit del messaggio (start bit) posto sull’ultimauscita dell’USR dell’echo resti presente su tale uscita per ben 8 colpi di clock del ricevitore.Il segnale PR (preset) è posto a 0 poichè non necessario.Il segnale TC (AND delle 3 uscite dei flip-flop) indica (quando a 1) che si è contato 8 colpidi clock del ricevitore che equivalgono a 1 colpo di clock del simulatore di trasmissione.
CAPITOLO 2. TRASMISSIONE SERIALE ASINCRONA (FPGA) 20
La funzione di comando Di dell’i-esimo flip-flop D del blocco funzionale UBC è:
Di = SR · (PR · Pi + PR · (CE · (Qi ⊕ (Qi−1 ·Qi−2 · . . . ·Q0 · 1)) + CE ·Qi))
con Q−1 = 1.
Unità dati
L’unità dati dell’eco è composta da un USR (Universal Shift Register) posto in modalitàPISO (Parallel Input Serial Output). Poichè dobbiamo trasmettere sequenze di 9 bit di cuiuno (l’ultimo) sempre a 0 ci servirà un UBC con 8 flip-flop (non è necessario un flip-flop permemorizzare l’ultimo bit 0). In Figura 2.16 è riportato lo schema dell’USR.Trattandosi di un USR in modalità PISO, il segnale (seriale) di ingresso IN è posto sempre
TRUSR (piso)
P0 P1 P2 P3 P4 P5 P6 P7
OUT
Q0 Q1 Q2 Q3 Q4 Q5 Q6 Q7
SH
PL
SR
IN00
LSMS
CLK8
TC
Figura 2.16: Schema dell’USR dell’eco
a 0, così come il segnale di reset SR (che resetta tutte le uscite Qi a 0). Il segnale SH di shiftdelle uscite Qi è collegato al segnale TC dell’unità di controllo. In questo modo dall’ultimauscita Q7 usciranno man mano tutti i bit del messaggio ricevuto con una frequenza 8 voltesuperiore a quella del ricevitore, ossia con la stessa frequenza del simulatore di trasmissione.Il segnale preload PL quando attivo a 1 carica la configurazione posta su P0, . . . , P7 sulleuscite Q0, . . . , Q7. Ai pin P0, . . . , P7 sono collegate le uscite del ricevitore Q1, . . . , Q8. Èdall’uscita Q7 che escono tutti i bit del messaggio in modo seriale. Il segnale PL è pilotatodalla logica combinatoria dell’unità di controllo del ricevitore. In particolare è attivo quandoci si trova nello stato di messaggio pronto (TR).La funzione di comando Di dell’i-esimo flip-flop D del blocco funzionale USR è:
Di = SR · (PL · Pi + PL · (SH ·Qi−1 + SH ·Qi))
con Q−1 = IN = 0.
Logica combinatoria
Le funzioni booleane di nostro interesse sono le seguenti:
SR = TR (reset UBC)
TC = Q0 ·Q1 ·Q2
PL = TR (preload USR)
CAPITOLO 2. TRASMISSIONE SERIALE ASINCRONA (FPGA) 21
SH = TC (shift USR)
2.4 Listato del sorgente XPLA
Per testare la progettazione logica della sperimentazione si è utilizzato il software XPLAProfessional della Xilinx, Inc. che consente di simulare il funzionamento di particolari circuitiintegrati senza doverli prima programmare fisicamente. Inoltre consente anche di produrreun file speciale per la programmazione fisica degli stessi.Segue il listato del sorgente XPLA di questa sperimentazione.
MODULE ex1
TITLE ’Asynchronous Serial Transmission’
DECLARATIONS
"inverted message bits
B0,B1,B2,B3,B4,B5,B6,B7 pin;
"IN
I node istype ’reg_d’;
IN pin;
"Transmitter simulator
CLKT pin;
"UBC
UBCT0,UBCT1,UBCT2,UBCT3 node istype ’reg_d’;
UBCT=[UBCT3..UBCT0];
PT0,PT1,PT2 pin;
TCT, PRT, CET pin istype ’com’;
"USR
USRT0,USRT1,USRT2,USRT3,USRT4,USRT5,USRT6 node istype ’reg_d’;
USRT7 pin istype ’reg_d’;
USRT=[USRT0..USRT7];
PLT pin istype ’com’;
"Receiver
CLKR pin;
"UBC
UBCR0,UBCR1,UBCR2,UBCR3,UBCR4,UBCR5,UBCR6 pin istype ’reg_d’;
UBCR=[UBCR6..UBCR0];
SRR, TRR, CER, CAMP, S69 pin istype ’com’;
"USR
USRR0,USRR1,USRR2,USRR3,USRR4,USRR5,USRR6,USRR7,USRR8 pin istype ’reg_d’;
USRR=[USRR0..USRR8];
CAPITOLO 2. TRASMISSIONE SERIALE ASINCRONA (FPGA) 22
"Echo
"UBC
UBCE0,UBCE1,UBCE2 node istype ’reg_d’;
UBCE=[UBCE2..UBCE0];
TCE pin istype ’com’;
"USR
USRE0,USRE1,USRE2,USRE3,USRE4,USRE5,USRE6 node istype ’reg_d’;
USRE7 pin istype ’reg_d’;
USRE=[USRE0..USRE7];
EQUATIONS
"IN
I.d=IN;
I.clk=CLKT;
"Transmitter
"UBC
when ( PRT == 1 ) then
{ UBCT.d=[0,PT2,PT1,PT0]; }
else when ( CET == 1 ) then
{ UBCT.d=UBCT.q + 1; }
else
{ UBCT.d=UBCT.q; }
UBCT.clk=CLKT;
"com logic
TCT=UBCT0.q & UBCT1.q & UBCT2.q & UBCT3.q;
PRT=TCT & I;
CET=!TCT;
PLT=PRT;
"USR
USRT0.d=PLT & B0;
[USRT1..USRT7].d=PLT & [B1..B7] # !PLT & [USRT0..USRT6].q;
USRT.clk=CLKT;
"Receiver
"UBC
when ( SRR == 1 ) then
{ UBCR.d:=^b0; }
else when ( CER == 1 ) then
{ UBCR.d=UBCR.q + 1; }
else { UBCR.d=UBCR.q; }
UBCR.clk=CLKR;
"com logic
CAPITOLO 2. TRASMISSIONE SERIALE ASINCRONA (FPGA) 23
TRR=UBCR6.q & UBCR2.q & !UBCR0.q;
S69=UBCR6.q & UBCR2.q & UBCR0.q;
CAMP=UBCR0.q & UBCR1.q & !UBCR2.q;
SRR=S69 & USRT7.q;
CER=!S69;
"USR
USRR0.d=CAMP & USRT7.q # !CAMP & USRR0.q;
[USRR1..USRR8].d=CAMP & [USRR0..USRR7].q # !CAMP & [USRR1..USRR8].q;
USRR.clk=CLKR;
"Echo
"UBC
when ( TRR == 1 ) then
{ UBCE.d:=^b0; }
else { UBCE.d=UBCE.q +1; }
UBCE.clk=CLKR;
"com logic
TCE=UBCE0.q & UBCE1.q & UBCE2.q;
"USR
USRE0.d=TRR & USRR1.q # !TRR & (!TCE & USRE0.q );
[USRE1..USRE7].d=TRR & [USRR2..USRR8].q # !TRR & ( TCE & [USRE0..USRE6].q #
!TCE & [USRE1..USRE7].q );
USRE.clk=CLKR;
END
2.5 Test e risultati
Una volta accertato che la compilazione del nostro sorgente XPLA non ha segnalato erroripossiamo far partire il simulatore e simulare la nostra esercitazione.Dapprima dobbiamo inizializzare tutti quei segnali che sono stati dichiarati come pin (puri)all’interno del nostro sorgente.Innanzitutto inizializziamo i bit del nostro messaggio a (ls)1 0 0 1 0 1 0 1 0(ms) (in realtàl’ultimo bit 0 (stop bit) non dobbiamo inizializzarlo). Fatto ciò impostiamo il periodo delclock del simulatore di trasmissione e del ricevitore ed eco. Impostiamo il periodo del clockdel simulatore di trasmettitore a un valore di 0,00001 sec (100KHz). Poichè la frequenza delricevitore deve essere otto volte maggiore di quella del simulatore di trasmissione, impostiamoil periodo del clock del ricevitore (sincrono con l’eco) a un valore di 0,00000125 sec (800KHz).Ora impostiamo i pin PT0,PT1,PT2 dell’UBC del simulatore di trasmissione in modo tale dagenerare o meno delle pause (cicli di clock) tra l’invio di un messaggio e l’altro come spiegatoin precedenza. Per il momento inizializziamoli tutti a 1 e quindi senza la generazione dicicli di clock di pausa tra l’invio di un messaggio e l’altro (poichè dallo stato S15 si passadirettamente a quello S7). Infine dobbiamo simulare il segnale meccanico che abilita l’inviodi messaggi (segnale IN). Per far ciò creiamo uno scalino (basso-alto-basso) di dimensioni apiacere (ma non troppo piccole per generare almeno due invii del messaggio).La Figura 2.17 e la Figura 2.18 mostrano lo storico dei valori dei segnali rilevanti alla finedella simulazione. Il segnale USRT7 è l’uscita dell’USR del simulatore di trasmissione dalla
CAPITOLO 2. TRASMISSIONE SERIALE ASINCRONA (FPGA) 24
Fig
ura
2.17
:Sc
reen
shot
della
prim
asi
mul
azio
ne
CAPITOLO 2. TRASMISSIONE SERIALE ASINCRONA (FPGA) 25
Fig
ura
2.18
:Sc
reen
shot
della
prim
asi
mul
azio
ne
CAPITOLO 2. TRASMISSIONE SERIALE ASINCRONA (FPGA) 26
quale escono i bit del messaggio lungo una linea seriale che collega la scatola contenente ilsimulatore di trasmissione con la scatola contenente il ricevitore ed eco.Il segnale USRE7 è l’uscita dell’USR dell’eco dalla quale escono i bit del messaggio ricevutodal ricevitore lungo un’altra linea seriale. Il messaggio seriale trasmesso dal simulatore ditrasmissione viene ricevuto dal ricevitore che lo rende disponibile all’eco sotto forma paral-lela. L’eco, a sua volta, sincronizato con il ricevitore, rende disponibile il messaggio sottoforma seriale per permettere un confronto tra il messaggio inviato e quello ricevuto.Come è possibile notare sono stati trasmessi dal simulatore di trasmissione ben 3 messaggiidentici senza l’inserimento di cicli di clock di pausa tra l’invio di un messaggio e l’altro(come voluto). Questi 3 messaggi sono stati elaborati correttamente dal ricevitore, comeè possibile vedere dalla linea seriale dell’eco. I segnali da USRR0 a USRR8 sono le uscitedell’USR del ricevitore sulle quali è disponibile il messaggio sotto forma parallela. Quandoil segnale TTR è alto, il messaggio è stato campionato dal ricevitore ed è disponibile sulleuscite del suo USR. Dalla Figura 2.18 è possibile leggere il messaggio pronto in verticale incorrispondenza di TRR alto (lasciando perdere quando va alto la prima volta). I segnali daUBCR0 a UBCR6 mostrano come lavora un contatore sequenziale; in questo caso si trattadel contatore del ricevitore. Si noti il segnale SRR che quando alto resetta il contatore allostato S0: questo avviene quando sia S69 che IN sono alti.Gli altri segnali presenti in figura sono segnali perlopiù utilizzati come condizioni di funziona-mento dei componenti UBC e USR del trasmettitore, ricevitore ed eco. Alcuni segnali sonostati omessi dalla figura (direttiva node nel sorgente). Notare che bisogna considerare i valoridei segnali da quando IN è alto.Vediamo ora di inserire due cicli di clock di pausa tra l’invio di un messaggio e l’altro. L’ini-zializzazione dei segnali pin (puri) è identica a quella precedente tranne per i pin PT0,PT1e PT2 che vanno messi a 1 0 1 rispettivamente (stato S5). La Figura 2.19 e la Figura 2.20mostrano lo storico dei valori dei segnali rilevanti alla fine della simulazione. È possibilenotare che tra un messaggio e l’altro ci sono ben 2 cicli di clock di pausa.
CAPITOLO 2. TRASMISSIONE SERIALE ASINCRONA (FPGA) 27
Fig
ura
2.19
:Sc
reen
shot
della
seco
nda
sim
ulaz
ione
CAPITOLO 2. TRASMISSIONE SERIALE ASINCRONA (FPGA) 28
Fig
ura
2.20
:Sc
reen
shot
della
seco
nda
sim
ulaz
ione
Capitolo 3
Trasmissione seriale sincrona(FPGA)
3.1 Esposizione del problema
Si vuole realizzare una trasmissione seriale sincrona di un byte (8 bit) con modalità start-stop,come avviene fra la tastiera e la CPU del PC. La CPU invia alla tastiera un clock, il CLKΦ,sfasato di 180◦ rispetto al clock CLK che usa al suo interno per acquisire il messaggio. Iltrasmettitore (tastiera) è una macchina sequenziale sincrona. Il ricevitore (CPU) è anch’essouna macchina sequenziale sincrona. Le due macchine sono sincrone tra di loro poichè hannoun generatore di clock in comune. Per realizzare la comunicazione fra le due macchine vienestabilito un protocollo di trasmissione.Viene definita una struttura del messaggio nella forma seguente: viene trasmesso un trenodi 10 bit, di cui il primo (start bit) sempre a 1 e l’ultimo (stop bit) sempre a 0. In mezzostanno gli 8 bit (B0, . . . , B7) che portano l’informazione. Tra due messaggi la linea resta a 0.Viene stabilita la frequenza nominale di trasmissione F0. Il periodo, inverso della frequenzaF0, è la durata di trasmissione di ogni singolo bit.Bisogna assicurare l’integrità della comunicazione rispettando il protocollo.Si devono progettare e realizzare tre macchine:
• Il simulatore di trasmissione trasmette il messaggio alla frequenza F0 in modo da poterimpostare a volontà il contenuto dei bit B0, . . . , B7 con la possibilità di emettere imessaggi immediatamente uno dopo l’altro (senza pausa) oppure con l’interposizionedi qualche periodo di clock (pausa);
• Il ricevitore riceve il dato seriale, lo acquisisce e lo presenta in parallelo sull’uscita conun segnale di ’messaggio pronto’. Il ricevitore opera alla frequenza Fx che è pari allafrequenza F0 del trasmettitore ma sfasata di 180◦;
• Il ritrasmettitore (o eco) ritrasmette in modo seriale alla frequenza Fx il messaggioricevuto permettendo di verificare la correttezza della comunicazione attraverso unconfronto fra i due messaggi, quello inviato e quello ricevuto.
3.2 Descrizione della soluzione
Si tratta di progettare un sistema digitale sincrono costituito da tre sottosistemi: il simulatoredi trasmissione, il ricevitore e l’eco. La comunicazione tra questi tre blocchi avviene in modosincrono.
29
CAPITOLO 3. TRASMISSIONE SERIALE SINCRONA (FPGA) 30
Per ognuna delle tre macchine (simulatore di trasmissione, ricevitore ed eco) è necessarioprogettare un’unità dati per l’elaborazione dei dati ed un’unità di controllo composta da unamacchina a stati con logica sequenziale (sincrona) e da circuiti a logica combinatoria. L’unitàdi controllo è composta sostanzialmente da un contatore UBC (Universal Binary Counter)per la rappresentazione degli stati della macchina sequenziale più eventuali circuiti logicinecessari per gestire le condizioni della logica combinatoria, mentre l’unità dati è compostasostanzialmente da un registro a scorrimento USR (Universal Shift Register).
3.3 Descrizione del progetto logico
3.3.1 Simulatore di trasmissione
Introduzione
Compito del simulatore di trasmissione è di trasmettere messaggi di 8+2 bit, eventualmenteinserendo delle pause (bit 0) tra l’invio di un messaggio e l’altro. Un segnale di start/stopmeccanico (es. interruttore) indica se spedire o meno il messaggio. Gli 8 bit del messaggiosono presi in parallelo e trasmessi in seriale. Poichè il segnale meccanico è un ingressoasincrono, è necessario sincronizzarlo con il clock del simulatore di trasmissione. Questo puòessere fatto utilizzando un flip-flop D come mostrato in Figura 3.1 (sempre che la durata delsegnale esterno IN sia maggiore del periodo del clock).
IN D Q
QCLK
CLK
IN
I
I
Figura 3.1: Sincronizzazione del segnale meccanico
Unità di controllo
Poichè dobbiamo essere in grado di conoscere quando un messaggio è stato inviato completa-mente (ad esempio per sapere quando caricare un altro messaggio), abbiamo bisogno di unamacchina a stati sequenziale (sincrona) che farà parte dell’unità di controllo del simulatoredi trasmissione.I bit da trasmettere sono 10 e quindi dobbiamo essere in grado di contare almeno fino a 10.Un contatore binario realizzerà gli stati della macchina. In particolare useremo un UBC con4 flip-flop D per realizzare una macchina sequenziale sincrona con 16 stati, 6 dei quali sonoridondanti e saranno utilizzati per inserire eventuali cicli di clock di pausa tra l’invio di unmessaggio e l’altro.Segue in Figura 3.2 il diagramma degli stati.Lo stato S15 è lo stato di attesa. In questo stato se I è a 1 allora si incomincia a contare,
altrimenti (I a 0) si attende (sempre nello stato S15) che I salga a 1. Se da S15 si passa subitoa S6 non ci sarà nessun ciclo di clock di pausa e quindi i messaggi saranno perfettamentecontigui. Se si riparte da S0 ci saranno ben 6 cicli di clock di pausa (e quindi 6 zeri) primadell’invio (eventuale) del messaggio successivo.
CAPITOLO 3. TRASMISSIONE SERIALE SINCRONA (FPGA) 31
I=1
S0 S S S S S5 S6 S7 S8
S9SSSSS 10111314 12
1 2 3 4
S15
I=0
I=1
Figura 3.2: Diagramma degli stati dell’UBC del simulatore di trasmissione
Segue in Figura 3.3 lo schema dell’UBC.Il segnale SR, segnale di reset (reset della macchina sullo stato S0), è posto sempre a 0 in
0
UBC
CLK
TC
0
P0 P1 P2 P3
Q1 Q2 Q3Q0
CE
PR
SR
Figura 3.3: Schema dell’UBC del simulatore di trasmissione
quanto non necessario. Il segnale TC (AND delle 4 uscite dei flip-flop) indica (quando a 1)lo stato S15. Il segnale PR, segnale di preset, serve a resettare la macchina in uno stato benpreciso. Lo stato di preset è determinato dalla configurazione posta su P0, P1, P2, P3. Nelnostro caso i possibili stati di preset sono S0, . . . , S6, quindi P3 è posto sempre a 0 mentre suirestanti viene posta una configurazione a seconda di quanti cicli di clock di pausa si voglionoinserire tra l’invio di un messaggio e l’altro. Il segnale PR è attivo quando entrambi i segnaliTC e I sono a 1. Il segnale CE abilita il conteggio del contatore binario. Di fatto il contatoredeve contare sempre tranne quando si trova nello stato S15 (TC a 1). I segnali SR, PR eCE hanno una priorità di funzionamento gerarchica SR-PR-CE, dove SR è il segnale conmaggiore priorità.La funzione di comando Di dell’i-esimo flip-flop D del blocco funzionale UBC è:
Di = SR · (PR · Pi + PR · (CE · (Qi ⊕ (Qi−1 ·Qi−2 · . . . ·Q0 · 1)) + CE ·Qi))
con Q−1 = 1.
Unità dati
L’unità dati del simulatore di trasmissione è composta da un USR (Universal Shift Register)posto in modalità PISO (Parallel Input Serial Output). Poichè dobbiamo trasmettere se-
CAPITOLO 3. TRASMISSIONE SERIALE SINCRONA (FPGA) 32
quenze di 10 bit di cui uno (l’ultimo) sempre a 0 ci servirà un UBC con 9 flip-flop (non ènecessario un flip-flop per memorizzare l’ultimo bit 0).Segue in Figura 3.4 lo schema dell’USR.Trattandosi di un USR in modalità PISO, il segnale (seriale) di ingresso IN è posto sempre
USR (piso)
7 Q8
CLKP0 P1 P2 P3 P4 P5 P6
Q0 Q1 Q2 Q3 Q4 Q5 Q6
SH
PL
SR
IN00
1MS
OUT
P7
1
LS
8P
Q
Figura 3.4: Schema dell’USR del simulatore di trasmissione
a 0, così come il segnale di reset SR (che resetta tutte le uscite Qi a 0). Il segnale SH dishift delle uscite Qi è posto sempre a 1 in quanto il registro a scorrimento deve shiftare dicontinuo (anche quando le uscite sono tutte a 0). Il segnale preload PL quando attivo a 1carica la configurazione posta su P0, . . . , P8 sulle uscite Q0, . . . , Q8. P8 è posto sempre a 1 inquanto è lo start bit. In P0, . . . , P7 ci sarà di volta in volta il byte che deve essere trasmesso.E’ dall’uscita Q8 che escono tutti i bit del messaggio in modo seriale.Il segnale PL è pilotato dalla logica combinatoria dell’unità di controllo. In particolare èattivo quando ci si trova nello stato S15 e quando il segnale I è a 1 (ossia si vuole spedire unmessaggio). I segnali SR, PL e SH hanno una priorità di funzionamento gerarchica SR-PL-SH, dove SR è il segnale con maggiore priorità.La funzione di comando Di dell’i-esimo flip-flop D del blocco funzionale USR è:
Di = SR · (PL · Pi + PL · (SH ·Qi−1 + SH ·Qi))
con Q−1 = IN = 0.
Logica combinatoria
La logica combinatoria di questo sistema coinvolge i segnali TC, I, PR, CE e PL. In parti-colare i segnali PR, CE e PL sono abilitati a seconda delle configurazioni di TC e I comemostrato nella Tabella 3.1. Dalla precedente tabella di verità seguono le seguenti funzioni
TC I PR CE PL0 0 0 1 01 0 0 0 00 1 0 1 01 1 1 x 1
Tabella 3.1: Tabella di verità della logica combinatoria del simulatore di trasmissione
booleane:
CAPITOLO 3. TRASMISSIONE SERIALE SINCRONA (FPGA) 33
PR = TC · I
CE = TC · I + TC · I = TC
PL = TC · I
da cui è possibile ricavare lo schema logico di Figura 3.5.
TC
I
PL, PR
CE
Figura 3.5: Schema della logica combinatoria del simulatore di trasmissione
3.3.2 Ricevitore
Introduzione
Compito del ricevitore è acquisire correttamente i messaggi inviati dal simulatore di trasmis-sione su linea seriale (segnale DL) e presentarli quindi in parallelo sull’uscita con un segnaledi ’messaggio pronto’.È necessaria una macchina a stati sequenziale (sincrona) che permetta di scandire il tempodi campionamento e di sapere quando il messaggio è stato completamente campionato. Uncontatore binario realizzerà gli stati delle macchina. Se si assume che ad ogni colpo di clockcorrisponde uno stato della macchina potremmo rappresentare con 12 stati la nostra mac-china sequenziale sincrona: 10 stati per i bit del messaggio (8 + 2), uno stato che indica cheil dato è pronto e uno stato di attesa (del bit di start). Tuttavia dobbiamo considerare cheil fronte di arrivo del segnale viene rilevato nel ricevitore con una indeterminazione pari alladurata di un ciclo di clock Fx del ricevitore. Con questa ultima considerazione ci accorgiamoche di fatto lo start bit non è campionabile. Quindi decidiamo di campionare solo gli 8 bit delmessaggio senza il bit di start ne tanto meno il bit di stop. La nostra macchina sequenzialesincrona avrà allora 10 stati.La frequenza con la quale opera il ricevitore è la stessa del simulatore di trasmissione masfasata di 180◦. Questa situazione è riportata in Figura 3.6.È necessario uno sfasamento di 180◦ di F0 per campionare a centro bit e quindi per avere
una maggiore tolleranza nel campionamento.
Unità di controllo
La macchina a stati sequenziale (sincrona) accennata in precedenza fa parte dell’unità dicontrollo del ricevitore. Useremo un UBC con 4 flip-flop D per realizzare una macchina se-quenziale sincrona con 16 stati, 6 dei quali sono ridondanti. Segue in Figura 3.7 il diagrammadegli stati.Gli stati S0,S1,S2,S3,S4,S5,S6,S7 sono utilizzati per campionare gli 8 bit. Lo stato S8 è lo
CAPITOLO 3. TRASMISSIONE SERIALE SINCRONA (FPGA) 34
7
F0
messaggio
Fx
1 0B0 B1B
rilevamentodel fronte
camp camp camp
Figura 3.6: Campionamento del messaggio con Fx = F0 sfasata di 180◦
9
S S
S S S
camp camp camp
S S S
camp campcampcamp
SS
DL=0
DL=1
TR
camp
0 1 2 3 4
5678
Figura 3.7: Diagramma degli stati dell’UBC del ricevitore
stato di messaggio pronto (TR) e l’S9 è lo stato di attesa (dello start bit). All’arrivo dellostart bit da S9 si riparte da S0, altrimenti si resta nello stato S9. Segue in Figura 3.8 loschema dell’UBC.Il segnale SR, segnale di reset (reset della macchina sullo stato S0), deve essere abilitato
quando ci si trova nello stato S9 e quando arriva il fronte di salita dello start bit (ossia quandoDL è a 1). Il segnale PR, segnale di preset, serve a resettare la macchina in uno stato benpreciso. Lo stato di preset è determinato dalla configurazione posta su P0, . . . , P3. Nel nostrocaso non abbiamo bisogno di tale funzione (usiamo già SR) e quindi il segnale PR è sempre a0. Il segnale CE abilita il conteggio del contatore binario. Di fatto il contatore deve contaresempre tranne quando si trova nello stato S9. I segnali SR, PR e CE hanno una priorità difunzionamento gerarchica SR-PR-CE, dove SR è il segnale con maggiore priorità.La funzione di comando Di dell’i-esimo flip-flop D del blocco funzionale UBC è:
Di = SR · (PR · Pi + PR · (CE · (Qi ⊕ (Qi−1 ·Qi−2 · . . . ·Q0 · 1)) + CE ·Qi))
con Q−1 = 1.
Logica combinatoria
Le 4 uscite dell’UBC sono utilizzate come ingressi di un decoder, che ha quindi ben 24 uscite.Il decoder abilita un’unica uscita a seconda della combinazione degli ingressi (univocamentedeterminata). Nella Tabella 3.2 viene riportato il funzionamento del decoder.Le funzioni booleane di nostro interesse sono:
TR = Q3 ·Q0 (segnale di dato pronto)
CAPITOLO 3. TRASMISSIONE SERIALE SINCRONA (FPGA) 35
9
21P
CE
PR
SR
Q0 Q Q Q
P P
1 2 3
0 3
0
!CLK
UBC
II
I
1
2
3
O0I0 Camp
TR S
15O
decoder
P
Figura 3.8: Schema dell’UBC del ricevitore
I3 I2 I1 I0 CAMP TR S9
O0 = S0 0 0 0 0 1 0 0O1 = S1 0 0 0 1 1 0 0O2 = S2 0 0 1 0 1 0 0O3 = S3 0 0 1 1 1 0 0O4 = S4 0 1 0 0 1 0 0O5 = S5 0 1 0 1 1 0 0O6 = S6 0 1 1 0 1 0 0O7 = S7 0 1 1 1 1 0 0O8 = S8 1 0 0 0 0 1 0O9 = S9 1 0 0 1 0 0 1
. . . 0 0 0O15 = S15 1 1 1 1 0 0 0
Tabella 3.2: Tabella di verità del decoder applicato alle uscite dell’UBC del ricevitore
S9 = Q3 ·Q0 (stato di attesa)
CAMP = Q3(segnale di campionamento)
SR = S9 ·DL (segnale di reset del contatore)
CE = S9 (count enable contatore)
da cui è possibile ricavare lo schema logico di Figura 3.9.
CAPITOLO 3. TRASMISSIONE SERIALE SINCRONA (FPGA) 36
3
TR
9S
DL
Camp
SR
CE
Q
Q0
Figura 3.9: Schema della logica combinatoria del ricevitore
Unità dati
L’unità dati del ricevitore è composta da un USR (Universal Shift Register) posto in moda-lità SIPO (Serial Input Parallel Output). Questo verrà utilizzato per campionare i messaggitrasmessi dal simulatore di trasmissione sulla linea DL. Poichè dobbiamo presentare il mes-saggio di 8 bit in uscita in parallelo ci servirà un UBC con 8 flip-flop. Segue in Figura 3.10lo schema dell’USR.Trattandosi di un USR in modalità SIPO, al segnale (seriale) di ingresso IN è collegato il
!CLK 0 P1 P2 P3 P4 P5 P6
Q0 Q1 Q2 Q3 Q4 Q5 Q6
SH
PL
SR
IN
0
P
DL
Camp0
Q7
P7
MS LS
USR (sipo)
Figura 3.10: Schema dell’USR del ricevitore
segnale seriale DL in uscita dal simulatore di trasmissione che trasporta i messaggi. Entram-bi i segnali SR (reset) e PL (preload) sono posti a 0 (trattandosi di un SIPO). Il segnaleSH di shift delle uscite Qi è il nostro interruttore che fa partire il campionamento e quindi
CAPITOLO 3. TRASMISSIONE SERIALE SINCRONA (FPGA) 37
sarà collegato al segnale CAMP pilotato dalla logica combinatoria dell’unità di controllo. Lafunzione di comando Di dell’i-esimo flip-flop D del blocco funzionale USR è:
Di = SR · (PL · Pi + PL · (SH ·Qi−1 + SH ·Qi))
con Q−1 = IN
3.3.3 Eco
Introduzione
Compito dell’eco è ritrasmette in modo seriale alla frequenza Fx il messaggio ricevuto (edisponibile in parallelo sulle uscite del ricevitore) permettendo di verificare la correttezza dellacomunicazione attraverso un confronto fra i due messaggi, quello inviato e quello ricevuto.
Unità di controllo
Disponiamo già tutto il necessario per l’unità di controllo dell’eco, non è necessario un altrocontatore. Infatti il segnale TR uscente dall’UBC del ricevitore indica quando sono prontivia via i byte ricevuti.
Unità dati
L’unità dati dell’eco è composta da un USR (Universal Shift Register) posto in modalità PISO(Parallel Input Serial Output). Poichè dobbiamo trasmettere sequenze di 8 bit ci servirà unUSR con 8 flip-flop. In Figura 3.11 è riportato lo schema dell’USR.Trattandosi di un USR in modalità PISO, il segnale (seriale) di ingresso IN è posto sempre
1
USR (piso)
P0 P1 P2 P3 P4 P5 P6 P7
OUT
Q0 Q1 Q2 Q3 Q4 Q5 Q6 Q7
SH
PL
SR
IN00
LSMS
TR
!CLK
Figura 3.11: Schema dell’USR dell’eco
a 0, così come il segnale di reset SR (che resetta tutte le uscite Qi a 0). Il segnale SH di shiftdelle uscite Qi è posto sempre a 1 in quanto deve shiftare sempre. In questo modo dall’ultimauscita Q7 usciranno man mano tutti i bit del messaggio ricevuto con una frequenza pari allafrequenza del simulatore di trasmissione. Il segnale preload PL quando attivo a 1 carica laconfigurazione posta su P0, . . . , P7 sulle uscite Q0, . . . , Q7. Ai pin P0, . . . , P7 sono collegatele uscite del ricevitore Q0, . . . , Q7. È dall’uscita Q7 che escono tutti i bit del messaggio inmodo seriale. Il segnale PL è pilotato dalla logica combinatoria dell’unità di controllo delricevitore. In particolare è attivo quando ci si trova nello stato di messaggio pronto (TR).La funzione di comando Di dell’i-esimo flip-flop D del blocco funzionale USR è:
Di = SR · (PL · Pi + PL · (SH ·Qi−1 + SH ·Qi))
CAPITOLO 3. TRASMISSIONE SERIALE SINCRONA (FPGA) 38
con Q−1 = IN = 0.
Logica combinatoria
Le funzioni booleane di nostro interesse sono le seguenti:
PL = TR (preload USR)
3.4 Listato del sorgente XPLA
Per testare la progettazione logica della sperimentazione si è utilizzato il software XPLAProfessional della Xilinx, Inc. che consente di simulare il funzionamento di particolari circuitiintegrati senza doverli prima programmare fisicamente. Inoltre consente anche di produrreun file speciale per la programmazione fisica degli stessi.Segue il listato del sorgente XPLA di questa sperimentazione.
MODULE ex2
TITLE ’Synchronous serial transmission’
DECLARATIONS
"Inverted data (with the start bit)
B0,B1,B2,B3,B4,B5,B6,B7,B8 pin;
"IN
I node istype ’reg_d’;
IN pin;
"Transmitter
CLKT pin;
"UBC
UBCT0,UBCT1,UBCT2,UBCT3 node istype ’reg_d’;
UBCT=[UBCT3..UBCT0];
PT0,PT1,PT2 pin;
TCT, PRT, CET pin istype ’com’;
"USR
USRT0,USRT1,USRT2,USRT3,USRT4,USRT5,USRT6,USRT7 node istype ’reg_d’;
USRT8 pin istype ’reg_d’;
USRT=[USRT0..USRT8];
PLT pin istype ’com’;
"Receiver
CLKR pin istype ’com’;
"UBC
UBCR0,UBCR1,UBCR2,UBCR3 pin istype ’reg_d’;
CAPITOLO 3. TRASMISSIONE SERIALE SINCRONA (FPGA) 39
UBCR=[UBCR3..UBCR0];
SRR, CER, CAMP, S9 pin istype ’com’;
TRR pin istype ’com’;
"USR
USRR0,USRR1,USRR2,USRR3,USRR4,USRR5,USRR6,USRR7 pin istype ’reg_d’;
USRR=[USRR0..USRR7];
"Echo
"USR
USRE0,USRE1,USRE2,USRE3,USRE4,USRE5,USRE6 node istype ’reg_d’;
USRE7 pin istype ’reg_d’;
USRE=[USRE0..USRE7];
EQUATIONS
"IN
I.d=IN;
I.clk=CLKT;
"Transmitter
"UBC
when ( PRT == 1 ) then
{ UBCT.d=[0,PT2,PT1,PT0]; }
else when ( CET == 1 ) then
{ UBCT.d=UBCT.q + 1; }
else
{ UBCT.d=UBCT.q; }
UBCT.clk=CLKT;
"com logic
TCT=UBCT0.q & UBCT1.q & UBCT2.q & UBCT3.q;
PRT=TCT & I;
CET=!TCT;
"USR
USRT0.d=PLT & B0;
[USRT1..USRT8].d=PLT & [B1..B8] # !PLT & [USRT0..USRT7].q;
USRT.clk=CLKT;
"com logic
PLT=PRT;
"Receiver
CLKR=!CLKT;
when ( SRR == 1 ) then
{ UBCR.d:=^b0; }
else when ( CER == 1 ) then
CAPITOLO 3. TRASMISSIONE SERIALE SINCRONA (FPGA) 40
{ UBCR.d=UBCR.q + 1; }
else { UBCR.d=UBCR.q; }
UBCR.clk=CLKR;
"com logic
TRR=UBCR3.q & !UBCR0.q;
S9=UBCR3.q & UBCR0.q;
CAMP=!UBCR3.q;
SRR=S9 & USRT8.q;
CER=!S9;
"USR
USRR0.d=CAMP & USRT8.q # !CAMP & USRR0.q;
[USRR1..USRR7].d=CAMP & [USRR0..USRR6].q # !CAMP & [USRR1..USRR7].q;
USRR.clk=CLKR;
"Echo
"USR
USRE0.d=TRR & USRR0.q;
[USRE1..USRE7].d=TRR & [USRR1..USRR7].q # !TRR & [USRE0..USRE6].q;
USRE.clk=CLKR;
END
3.5 Test e risultati
Una volta accertato che la compilazione del nostro sorgente XPLA non ha segnalato erroripossiamo far partire il simulatore e simulare la nostra esercitazione.Dapprima dobbiamo inizializzare tutti quei segnali che sono stati dichiarati come pin (puri)all’interno del nostro sorgente. Innanzitutto inizializziamo i bit del nostro messaggio a (ls)1 10 0 1 0 1 1 0 0(ms) (in realtà l’ultimo bit 0 (stop bit) non dobbiamo inizializzarlo). Impostia-mo il periodo del clock del simulatore di trasmissione a un valore di 0,00001 sec (100KHz).La frequenza del ricevitore e dell’eco sarà la stessa di quella del simulatore di trasmissionema sfasata di 180◦.Ora impostiamo i pin PT0,PT1,PT2 dell’UBC del simulatore di trasmissione in modo tale dagenerare o meno delle pause (cicli di clock) tra l’invio di un messaggio e l’altro come spiegatoin precedenza. Per il momento inizializziamo PT0 a 0 e gli altri due a 1 e quindi senza lagenerazione di cicli di clock di pausa tra l’invio di un messaggio e l’altro (poichè dallo statoS9 si passa direttamente a quello S6). Infine dobbiamo simulare il segnale meccanico cheabilita l’invio di messaggi (segnale IN). Per far ciò creiamo uno scalino (basso-alto-basso) didimensioni a piacere (ma non troppo piccole per generare almeno due invii del messaggio).La Figura 3.12 Figura 3.13 mostrano lo storico dei valori dei segnali rilevanti alla fine dellasimulazione. Il segnale USRT8 è l’uscita dell’USR del simulatore di trasmissione dalla qualeescono i bit del messaggio lungo una linea seriale che collega il simulatore di trasmissionecon il ricevitore. Il segnale USRE7 è l’uscita dell’USR dell’eco dalla quale escono i bit delmessaggio ricevuto dal ricevitore lungo un’altra linea seriale. Il messaggio seriale trasmessodal simulatore di trasmissione viene ricevuto dal ricevitore e lo rende disponibile all’eco sot-to forma parallela. L’eco a sua volta rende disponibile il messaggio sotto forma seriale perpermettere un confronto tra il messaggio inviato e quello ricevuto.Come è possibile notare sono stati trasmessi dal simulatore di trasmissione 2 messaggi iden-
CAPITOLO 3. TRASMISSIONE SERIALE SINCRONA (FPGA) 41
Fig
ura
3.12
:Sc
reen
shot
della
prim
asi
mul
azio
ne
CAPITOLO 3. TRASMISSIONE SERIALE SINCRONA (FPGA) 42
Fig
ura
3.13
:Sc
reen
shot
della
prim
asi
mul
azio
ne
CAPITOLO 3. TRASMISSIONE SERIALE SINCRONA (FPGA) 43
tici senza l’inserimento di cicli di clock di pausa tra l’invio di un messaggio e l’altro (comevoluto). Questi 2 messaggi sono stati elaborati correttamente dal ricevitore, come è possibilevedere dalla linea seriale dell’eco (dove non sono presenti i bit di start e di stop). È possibilenotare che sebbene il trasmettitore non ha pause tra l’invio di un messaggio e l’altro, nell’ecociò non accade poichè quando questo ha finito di trasmettere 8 bit, prima dell’arrivo di unaltro segnale di messaggio pronto (TRR) ci sono due cicli vuoti nell’UBC del ricevitore neiquali l’eco emette due bit 0. I segnali da USRR0 a USRR7 sono le uscite dell’USR del rice-vitore sulle quali è disponibile il messaggio sotto forma parallela. Quando il segnale TTR èalto, il messaggio è stato campionato dal ricevitore ed è disponibile sulle uscite del suo USR.Dalla Figura 3.13 è possibile leggere il messaggio pronto in verticale in corrispondenza diTRR alto. I segnali da UBCR0 a UBCR3 mostrano come lavora un contatore sequenziale;in questo caso si tratta del contatore del ricevitore. Si noti il segnale SRR che quando altoresetta il contatore allo stato S0: questo avviene quando sia S69 che USRT8 sono alti.Gli altri segnali presenti in figura sono segnali perlopiù utilizzati come condizioni di funziona-mento dei componenti UBC e USR del trasmettitore, ricevitore ed eco. Alcuni segnali sonostati omessi dalla figura (direttiva node nel sorgente). Notare che bisogna considerare i valoridei segnali da quando IN è alto.Vediamo ora di inserire due cicli di clock di pausa tra l’invio di un messaggio e l’altro. L’ini-zializzazione dei segnali pin (puri) è identica a quella precedente tranne per i pin PT0,PT1e PT2 che vanno messi a 0 0 1 rispettivamente (stato S4).La Figura 3.14 e la Figura 3.15 mostrano lo storico dei valori dei segnali rilevanti alla finedella simulazione. È possibile notare che tra l’invio di un messaggio e l’altro, il simulatore ditrasmissione inserisce 2 cicli di clock di pausa (2 bit a 0), mentre l’eco ne inserisce ben 4 peril discorso fatto precedentemente.
CAPITOLO 3. TRASMISSIONE SERIALE SINCRONA (FPGA) 44
Fig
ura
3.14
:Sc
reen
shot
della
seco
nda
sim
ulaz
ione
CAPITOLO 3. TRASMISSIONE SERIALE SINCRONA (FPGA) 45
Fig
ura
3.15
:Sc
reen
shot
della
seco
nda
sim
ulaz
ione
Capitolo 4
Semaforo intelligente (FPGA)
4.1 Esposizione del problema
Vogliamo realizzare un semaforo intelligente, che si deve adattare alle condizioni del traffico.Consideriamo il caso dell’incrocio di due strade, Nord-Sud (NS) e Est-Ovest (EO) comemostrato in Figura 4.1.Ogni direzione si affaccia all’incrocio con 3 corsie in entrata e 2 corsie in uscita. Le corsie
in entrata sono dotate di sensori di presenza/assenza auto.Il sistema di controllo del semaforo opera sulla base dei segnali dei sensori. Se tutti i sensoriindicano presenza di auto, il sistema abilita (dà luce verde) via via tutte le corsie secondola sequenza normale dei semafori. Se nel corso del ciclo il sistema trova inattivo qualchesensore di corsia, non abilita quella corsia. Nel caso in cui tutti i sensori sono inattivi, vienemantenuta abilitata una corsia preferenziale (NS).I sensori sono 12, tanti quante sono le corsie. Sono raggruppati a coppie quelli delle corsiecorrispondenti nelle direzioni NS e EO; inoltre sono raggruppate le corsie A e B, D e E.Pertanto risultano 4 segnali dai sensori.Consideriamo pertanto che il semaforo avrà’ 4 stati, corrispondenti alla chiamata dei 4 segnalidei sensori. In ogni stato il sistema accende le luci verdi come indicato nella Tabella 4.1.
Stati Vie LuciS0 A e B A+BS1 C C+DS2 D e E D+ES3 F F+A
Tabella 4.1: Tabella stati/vie/luci verdi del semaforo
4.1.1 Funzionamento
Facciamo riferimento alla Figura 4.2.È disegnato il solo comportamento temporale relativo allo stato S0. Quasi al termine della
durata della luce verde il sistema deve valutare i segnali dei sensori e deve decidere qualesarà lo stato successivo.
a) Se è attivo il segnale dello stato S1, allora accenderà le luci gialle dello stato S0 e altermine accenderà il verde dello stato S1.
46
CAPITOLO 4. SEMAFORO INTELLIGENTE (FPGA) 47
S
������������
������������
������������ ����������
������
������
A CB
EF
D
EF
DAC B
N
W
E
Figura 4.1: Schema dell’incrocio di due strade
b) Se è inattivo il segnale dello stato S1 ma è attivo quello dello stato S2, allora accenderàle luci gialle dello stato S0 e al termine accenderà il verde dello stato S2.
c) Se sono inattivi i segnali degli stati S1 e S2 ma è attivo quello dello stato S3, alloraaccenderà le luci gialle dello stato S0 e al termine accenderà il verde dello stato S3.
d) Se sono inattivi i segnali degli stati S1, S2, S3 allora rimarrà nello stato S0, senza accenderele luci gialle e continuerà nell’esplorazione dei segnali S1, S2, S3 fintantochè uno di essidiventerà attivo; quindi si regolerà come nei precedenti casi a), b), c).
Quanto descritto per lo stato S0 va ripetuto per gli altri stati tenendo conto che nel punto d)se tutti i sensori sono inattivi si abilita la corsia preferenziale, ossia lo stato S0. L’esplorazionedei segnali dei sensori avviene in modo ciclico.
CAPITOLO 4. SEMAFORO INTELLIGENTE (FPGA) 48
S
S1
2
3
S0
S
Figura 4.2: Comportamento temporale del semaforo relativo allo stato S0
4.2 Descrizione della soluzione
La struttura del sistema è quella della macchina sequenziale sincrona, come indicato nellaFigura 4.3.Il sistema è composto da tre parti principali: il controller, la data unit e il blocco per le
accensioni delle luci. È un sistema sincrono poichè c’è un solo clock in comune per tutto ilsistema. Il controller funge da temporizzatore sia per la data unit che per il blocco per leaccensioni delle luci. È il controller che scandisce la durata di accensione delle varie luci eattiva via via tutti i blocchi all’interno della data unit che elaborano i valori dei sensori epilotano correttamente le luci del semaforo.
4.3 Descrizione del progetto logico
4.3.1 Introduzione
Nella Figura 4.4 viene riportato lo schema a blocchi dell’intero sistema. Il sistema è compostoda tre blocchi principali: il controller, la data unit ed il blocco di decodifica per l’accensionedelle luci del semaforo. Verranno analizzate ora le singole parti che compongono l’interosistema.
4.3.2 Controller
Compito del controller è la temporizzazione del semaforo e la temporizzazione delle azionidella data unit. Possiamo scegliere di suddividere il tempo in 8 unità temporali per la duratabase del verde e in 2 unità temporali per la durata del giallo. Pertanto con un contatorea 10 stati possiamo realizzare la temporizzazione del semaforo. Per avere la possibilità dioperare con maggiore risoluzione temporale l’analisi dei segnali dei sensori nella data unit,facciamo precedere il contatore di 10 stati con uno di 16 stati. In questo modo con un semplicecontatore a 160 stati realizziamo il controller (è questa una scelta comoda, che ci semplifica lamacchina). In Figura 4.5 viene riportato il diagramma degli stati del contatore complessivo a160 stati. La durata delle luci verdi va dallo stato S0 allo stato S127 (inclusi), mentre quelladelle luci gialle va dallo stato S128 a quello S159 (inclusi). Quindi 128 stati per il verde (8∗16)e 32 stati per il giallo (2 ∗ 16). Allo stato S120 (segnale STRB) vengono congelati i valori deisegnali dei sensori e dallo stato S120 allo stato S123 avviene la ricerca dello stato prossimo
CAPITOLO 4. SEMAFORO INTELLIGENTE (FPGA) 49
(TE
MP
OR
IZZ
AT
OR
E)
ACCENSIONILUCI
DATAUNIT
CLK
IN
Controlli
5
5
4
CO
NT
RO
LLE
R
Condizione
Figura 4.3: Schema della macchina sequenziale sincrona del sistema
(segnale EN). Nello stato S124 (segnale DCS) viene abilitata la decisione sul preset (segnalePR) del contatore allo stato S120 nel caso in cui si debba restare nello stato attuale e sondareciclicamente i sensori (quando lo stato presente coincide con lo stato prossimo). Nello statoS128 avviene la commutazione tra luci verdi e gialle e la temporizzazione di quest’ultime(segnale Q7) continua fino allo stato S159 (segnale TC) dal quale si riparte dallo stato S0. InFigura 4.6 viene riportato uno schema che presenta le forme d’onda del contatore in esamecon l’indicazione dei segnali accennati in precedenza. Un UBC con 8 flip-flop D realizzeràil contatore, una macchina sequenziale sincrona con 256 stati, 96 dei quali sono ridondanti.Segue in Figura 4.7 lo schema dell’UBC.Il segnale SR, segnale di reset (reset della macchina sullo stato S0), è collegato al segnale TC(stato S159). Il segnale PR, segnale di preset, serve a resettare la macchina in uno stato benpreciso. Lo stato di preset è determinato dalla configurazione posta su P0, P1, P2, P3, . . . , P7.Nel nostro caso l’unico stato di preset è S120, quindi su P0, . . . , P7 c’è la combinazione di0 e 1 relativa allo stato S120. Il segnale PR arriva dal blocco di decisione della data united è attivo quando lo stato prossimo del semaforo coincide con lo stato presente. Il segnaleCE abilita il conteggio del contatore binario. Di fatto il contatore deve contare sempre ed
CA
PIT
OLO
4.SE
MA
FO
RO
INT
ELLIG
EN
TE
(FP
GA
)50
RICERCA
SEQUENZIALE
STATO
PROSSIMO
STATO
PRES.
DECISIONE
DECODER
DE
CO
DIF
ICA
CLK
PR
CONTATORE A 160 STATI
PR
INPUT
ACQUISIZIONE
EN
TC
STRB DCS
EN
statopresente
STRB
STRB
DCS
IN
TC
V RG
4
2 2
4 4
DATA UNIT
CONTROLLER
LUCI SEMAFORO
prossimostato
Q7
Q7
A
B
C
D
E
F
VIA
PREF.
Figura 4.4: Schema a blocchi del sistema
CAPITOLO 4. SEMAFORO INTELLIGENTE (FPGA) 51
TC
S0 S159S128S124S123S122S121S120
PR
Commutazioneverde−giallo
Figura 4.5: Diagramma degli stati del controller
è quindi posto costante a 1. I segnali SR, PR e CE hanno una priorità di funzionamentogerarchica SR-PR-CE, dove SR è il segnale con maggiore priorità.La funzione di comando Di dell’i-esimo flip-flop D del blocco funzionale UBC è:
Di = SR · (PR · Pi + PR · (CE · (Qi ⊕ (Qi−1 ·Qi−2 · . . . ·Q0 · 1)) + CE ·Qi))
con Q−1 = 1.
Le 8 uscite dell’UBC sono utilizzate come ingressi di un decoder, che ha quindi ben 28 uscite.Il decoder abilita un’unica uscita a seconda della combinazione degli ingressi (univocamentedeterminata). Nella Tabella 4.2 viene riportato il funzionamento del decoder.Le funzioni booleane di nostro interesse sono:
I7 I6 I5 I4 I3 I2 I1 I0 STRB EN DCS Q7 TCO0 = S0 0 0 0 0 0 0 0 0 0 0 0 0 0. . . . . . 0 0 0 0 0O120 = S120 0 1 1 1 1 0 0 0 1 1 0 0 0O121 = S121 0 1 1 1 1 0 0 1 0 1 0 0 0O122 = S122 0 1 1 1 1 0 1 0 0 1 0 0 0O123 = S123 0 1 1 1 1 0 1 1 0 1 0 0 0O124 = S124 0 1 1 1 1 1 0 0 0 0 1 0 0. . . . . . 0 0 0 0 0O128 = S128 1 0 0 0 0 0 0 0 0 0 0 1 0. . . . . . 0 0 0 1 0O159 = S159 1 0 0 1 1 1 1 1 0 0 0 1 1. . . . . . 0 0 0 0 0O255 = S255 1 1 1 1 1 1 1 1 0 0 0 0 0
Tabella 4.2: Tabella di verità del decoder applicato alle uscite dell’UBC del controller
STRB = S120 = Q0 ·Q1 ·Q2 ·Q3 ·Q4 ·Q5 ·Q6
EN = Q2 ·Q3 ·Q4 ·Q5 ·Q6
DCS = S124 = Q0 ·Q1 ·Q2 ·Q3 ·Q4 ·Q5 ·Q6
SR = TC = S159 = Q0 ·Q1 ·Q2 ·Q3 ·Q4 ·Q5 ·Q6 ·Q7
4.3.3 Data unit
Compito della data unit è di ricercare lo stato prossimo del sistema sulle base della conoscenzadello stato presente e dei 4 sensori; inoltre la data unit pilota l’accensione delle luci del
CA
PIT
OLO
4.SE
MA
FO
RO
INT
ELLIG
EN
TE
(FP
GA
)52
TC
Q6
Q5
Q3
Q2
Q0
Q1
Q4
S124
S120
S159
Q7
STRB
EN
DCS
S120−123
Figura 4.6: Forme d’onda del temporizzatore e dei segnali di controllo per la data unit
CAPITOLO 4. SEMAFORO INTELLIGENTE (FPGA) 53
7
7
I0
O255
O159
O128
O124
120O
O0
CLKP0 P1 P2 P3 P4 P5 P6
Q0 Q1 Q2 Q3 Q4 Q5 Q6
P7
SR
PR
CE1
1 1 1 10 00 0
UBC
decoder
I
I
I
I
I
I
I
1
2
3
4
5
6
7
STRB, EN
ENEN
EN
120S =
DCS
TC, Q7
Q7
Q
Q
Figura 4.7: Schema dell’UBC del controller
semaforo in base allo stato presente/prossimo e in base al segnale che indica la durata diaccensione delle luci gialle. Nel caso in cui lo stato prossimo sia uguale allo stato presente ladata unit resetta il controller in modo tale da far ripartire la ricerca sequenziale dello statoprossimo. Tutte queste operazioni avvengono sotto condizione di alcuni segnali provenientidal controller. Verrano ora analizzate tutte le parti della data unit come riportate nellaFigura 4.4.
Acquisizione input
In questo blocco vengono sincronizzati e congelati i 4 valori dei sensori. Questo avvienequando è alto il segnale STRB (stato S120). È necessario congelare i valori dei sensori perevitare eventuali alterazione degli stessi durante la fase di ricerca dello stato prossimo.Per realizzare il congelamento dei valori dei sensori utilizziamo un USR (Universal ShiftRegister) con 4 flip-flop. In Figura 4.8 è riportato lo schema dell’USR.Il segnale (seriale) di ingresso IN è posto sempre a 0, così come il segnale di reset SR
(che resetta tutte le uscite Qi a 0) ed anche il segnale SH in quanto compito dell’USR èsolo quello di mantenere certi valori sull’uscita. Il segnale preload PL quando attivo a 1carica la configurazione posta su P0, . . . , P3 sulle uscite Q0, . . . , Q3. Ai pin P0, . . . , P3 sonocollegati i segnali dei sensori. Il segnale PL è pilotato dal segnale STRB uscente dalla logicacombinatoria del controller.La funzione di comando Di dell’i-esimo flip-flop D del blocco funzionale USR è:
Di = SR · (PL · Pi + PL · (SH ·Qi−1 + SH ·Qi))
CAPITOLO 4. SEMAFORO INTELLIGENTE (FPGA) 54
CLKP0 P1 P2 P3
Q0 Q1 Q2 Q3
SH
PL
SR
IN00
STRB0
USR
Figura 4.8: Schema dell’USR del blocco di acquisizione input
con Q−1 = IN = 0.
Quindi:
PL = STRB
Via preferenziale
In questo blocco vengono analizzati i valori dei sensori provenienti dal blocco precedente e sequesti sono tutti a 0 viene abilitata la via preferenziale (stato S0), ossia viene portato altoil segnale relativo al primo sensore (quello che controlla le vie A e B). Questa funzione puòessere implementata con un paio di porte logiche come mostrato nella Figura 4.9. L’or tra
Q1
Q3
U
2
Q0
1
2
3
0U
U
U
Q
Figura 4.9: Schema logico del blocco via preferenziale
tutti e 4 i segnali permette di capire se questi sono tutti a 0 (0 come risultato) o meno (1come risultato). Il risultato viene negato (sia per abilitare la via preferenziale nel caso in cuii 4 segnali sono tutti a 0, sia per annullare l’operazione di or nel caso in cui anche un solosegnale è a 1) e viene messo in or con il segnale del primo sensore. Quest’ultimo or abilita lavia preferenziale nel caso in cui tutti e 4 i segnali sono a 0 oppure lascia inalterato il valoredel primo sensore nel caso in cui ci sia anche un solo sensore alto. In definitiva abbiamo leseguenti funzioni booleane:
U0 = (Q0 +Q1 +Q2 +Q3) +Q0
CAPITOLO 4. SEMAFORO INTELLIGENTE (FPGA) 55
U1 = Q1
U2 = Q2
U3 = Q3
Ricerca sequenziale stato prossimo
In questo blocco avviene la ricerca sequenziale dello stato prossimo del sistema. L’attivazionedi questo blocco è determinata dai segnali EN e STRB che arrivano dal controller. Il segnaleEN indica la massima durata della ricerca (4 stati macchina, da S120 a S123). Il segnale STRBavvia la ricerca dello stato prossimo. La ricerca sequenziale dello stato prossimo può essereimplementata con un contatore USR a due flip-flop (per contare almeno fino a 4, tanti quantisono gli stati del sistema). Nella Figura 4.10 viene riportato il diagramma degli stati delcontatore. Sostanzialmente il contatore deve contare ciclicamente fino a quando si posiziona
3
S0 S
SS
1
2
Figura 4.10: Diagramma degli stati del contatore per la ricerca sequenziale dello statoprossimo
su uno stato per il quale è attivo il relativo sensore. Questo stato sarà lo stato prossimo delsistema. All’inzio della ricerca il segnale STRB abilita (senza condizioni) il passaggio dallostato presente del contatore (e del sistema) a quello successivo. In Figura 4.11 viene riportatolo schema dell’UBC. Il segnale SR, segnale di reset (reset della macchina sullo stato S0), è
1
P0 P1
UBC
0 SR
CE
PR
CLK
0
W W0
Figura 4.11: Schema dell’UBC del blocco per la ricerca sequenziale dello stato prossimo
posto sempre a 0 in quanto non necessario. Il segnale PR, segnale di preset, serve a resettarela macchina in uno stato ben preciso. Lo stato di preset è determinato dalla configurazioneposta su P0 e P1. Nel nostro caso non abbiamo bisogno di tale funzione e quindi il segnalePR è sempre a 0. Il segnale CE abilita il conteggio del contatore binario come spiegato in
CAPITOLO 4. SEMAFORO INTELLIGENTE (FPGA) 56
precedenza.La funzione di comando Di dell’i-esimo flip-flop D del blocco funzionale UBC è:
Di = SR · (PR · Pi + PR · (CE · (Wi ⊕ (Wi−1 ·Wi−2 · . . . ·W0 · 1)) + CE ·Wi))
con W−1 = 1.
Le funzioni booleane di nostro interesse sono:
CE = (EN · CONFIG) + STRB
CONFIG = (W0 ·W1 · U0) + (W0 ·W1 · U1) + (W0 ·W1 · U2) + (W0 ·W1 · U3)
Stato presente
Questo blocco serve per memorizzare lo stato presente del sistema proprio alla fine delladurata delle luci gialle (segnale TC) tenendone traccia per l’intero ciclo successivo del con-tatore. È necessario memorizzare lo stato presente del sistema poichè altrimenti andrebbeperso durante la ricerca sequenziale dello stato prossimo; lo stato presente è fondamentalesia per l’accessione delle luci del semaforo sia per la decisione di resettare o meno il controlleral fine di individuare il nuovo stato prossimo (questo nel caso in cui stato presente e statoprossimo coincidano). La memorizzazione dello stato presente del sistema (che altro non èche il vecchio stato prossimo) può essere realizzerà con un USR (Universal Shift Register)con 2 flip-flop. In Figura 4.12 è riportato lo schema dell’USR.Il segnale (seriale) di ingresso IN è posto sempre a 0, così come il segnale di reset SR (che
Z
P0 P1
SH
PL
SR
IN00
0
CLK
TCUSR
0 1Z
Figura 4.12: Schema dell’USR del blocco stato presente
resetta tutte le uscite Zi a 0) ed anche il segnale SH in quanto compito dell’USR è soloquello di mantenere certi valori sull’uscita. Il segnale preload PL quando attivo a 1 carica laconfigurazione posta su P0 e P1 sulle uscite Z0 e Z1. Ai pin P0, P1 sono collegati le uscitedell’UBC del blocco di ricerca sequenziale dello stato prossimo. Il segnale PL è pilotato dalsegnale TC uscente dalla logica combinatoria del controller.La funzione di comando Di dell’i-esimo flip-flop D del blocco funzionale USR è:
Di = SR · (PL · Pi + PL · (SH · Zi−1 + SH ·Qi))
con Z−1 = IN = 0.
Quindi:
CAPITOLO 4. SEMAFORO INTELLIGENTE (FPGA) 57
PL = TC
Decisione
In questo blocco avviene la decisione di resettare o meno il controller, tramite l’attivazionedel segnale PR, al fine di individuare il nuovo stato prossimo nel caso in cui lo stato presentecoincida con lo stato prossimo (le luci del semaforo non vengono alterate fino al nuovo statoprossimo). Questa decisione si attiva un attimo dopo il termine della ricerca sequenzialedello stato prossimo; in particolare si attiva quando il segnale DCS è alto. Questa funzionepuò essere implementata con un paio di porte logiche come mostrato nella Figura 4.13. Lo
PRR
DCS
PR
W
Z 1
0
0
W
Z
1
Figura 4.13: Schema logico del blocco di decisione
stato presente (Z0 e Z1) viene comparato (a coppie di bit) con lo stato prossimo (W0 e W1)tramite porte xor. La tabella di verità dell’xor restituisce 1 solo quando uno dei due bit èa 1, altrimenti (stessi bit) restituisce 0. Quindi se entrambi questi confronti (or) sono a 0significa che lo stato presente è uguale allo stato prossimo. Il not finale serve per abilitareo disabilitare il segnale PR che resetta il contatore del controller. In definitiva abbiamo leseguenti funzioni booleane:
PR = PRR ·DCS
PRR = ((Z0 ⊕W0) + (Z1 ⊕W1))
4.3.4 Accensioni luci
Questa parte del sistema è dedita all’accensione delle luci del semaforo sulla base dei datiprovenienti sia dalla data unit che dal controller. In particolare sarà necessario conoscere lostato presente e lo stato prossimo del sistema (dati provenienti dalla data unit) e il segnaleQ7 proveniente dal controller che indica la durata delle luci gialle e di fatto indica anche lafine della durata di accensione delle luci verdi. Poichè le 12 vie (in entrata) dell’incrocio sonoaccoppiate a due a due, in totale dovremo gestire 6 triple di luci (una per ogni coppia di via),dove una tripla di luci è composta da una luce rossa, una gialla e una verde. Lo schema delladecodifica dell’accensione delle luci è riportato in Figura 4.14. Per trovare le equazioni logichedelle luci rosse, gialle e verdi procederemo in questo modo. Dapprima troveremo le equazionidelle luci rosse basandoci solo sullo stato presente. Dopodichè troveremo le equazioni delleluci verdi tenendo conto dello stato presente, dello stato prossimo e del segnale Q7. Avendoper ogni via le equazioni delle luci rosse e di quelle verdi, le equazioni delle luci gialle sono lecombinazioni che non si presentano ne in quelle rosse ne in quelle verdi. In Tabella 4.3 vieneriportata per ogni via la decodifica delle luci rosse sulla base del solo stato presente.Dalla Tabella 4.1 vediamo che nello stato S0 il semaforo abilita le luci verdi per le vie A e
B. Le restanti vie avranno luci rosse. Nello stato S1 il semaforo abilita le luci verdi per le vieC e D. Le restanti vie avranno luci rosse e così via. Le funzioni booleane per le luci rosse di
CAPITOLO 4. SEMAFORO INTELLIGENTE (FPGA) 58
7
DE
CO
DIF
ICAstato
presente
V RG
prossimostato A
B
C
D
E
F
2
2
Q
Figura 4.14: Schema di decodifica dell’accensione delle luci del semaforo
Z1 Z0 Ar Br Cr Dr Er Fr
0 0 0 0 1 1 1 10 1 1 1 0 0 1 11 0 1 1 1 0 0 11 1 0 1 1 1 1 0
Tabella 4.3: Decodifica delle luci rosse del semaforo
ogni via sono:
Ar = Z0 ⊕ Z1
Br = Z0 + Z1
Cr = Z0 + Z1
Dr = (Z0 ⊕ Z1)
Er = Z0 + Z1
Fr = (Z0 · Z1)
In Tabella 4.4 viene riportata per ogni via la decodifica delle luci verdi sulla base dellostato presente, dello stato prossimo e del segnale Q7.Quando il segnale Q7 è basso significa che ci troviamo nel periodo di accensione delle luci
verdi. In questo caso dobbiamo abilitare le accensioni delle luci verdi basandoci solo sullostato presente come descritto nella Tabella 4.1. Quando Q7 diventa alto nello stato Q128
dovremmo commutare le luci verdi associate allo stato presente in luci gialle. In questo casoperò dobbiamo verificare se stato presente e stato prossimo hanno in comune una via. Sela risposta è positiva allora non avrebbe senso accendere il giallo per la via in comune e poiaccendere il verde per la stessa; per quella via rimane accesa la luce verde. Dalla Tabella 4.1possiamo notare che ci sono quattro situazioni di questo genere. Nel passaggio da S0 a S3
notiamo che la via A è in comune ai due stati (e viceversa). Lo stesso discorso vale per il
CAPITOLO 4. SEMAFORO INTELLIGENTE (FPGA) 59
Z1 Z0 W1 W0 Q7 Av Bv Cv Dv Ev Fv
0 0 X X 0 1 1 0 0 0 00 1 X X 0 0 0 1 1 0 01 0 X X 0 0 0 0 1 1 01 1 X X 0 1 0 0 0 0 10 0 1 1 1 1 0 0 0 0 01 1 0 0 1 1 0 0 0 0 00 1 1 0 1 0 0 0 1 0 01 0 0 1 1 0 0 0 1 0 0
Tabella 4.4: Decodifica delle luci verdi del semaforo
passaggio da S1 a S2 con la via D in comune. Le funzioni booleane per le luci verdi di ognivia sono:
Av = (Q7 · (Z0 ⊕ Z1)) + (Q7 · ((Z0 ⊕ Z1) · (W0 ⊕W1)))
Bv = Q7 · Z0 · Z1
Cv = Q7 · Z0 · Z1
Dv = (Q7 · (Z0 ⊕ Z1)) + (Q7 · ((Z0 ⊕ Z1) · (W0 ⊕W1)))
Ev = Q7 · Z0 · Z1
Fv = Q7 · Z0 · Z1
Le funzioni booleane per le luci gialle sono ricavate in questo modo:
Ag = Ar ·Av
Bg = Br ·Bv
Cg = Cr · Cv
Dg = Dr ·Dv
Eg = Er · Ev
Fg = Fr · Fv
4.4 Listato del sorgente XPLA
Per testare la progettazione logica della sperimentazione si è utilizzato il software XPLAProfessional della Xilinx, Inc. che consente di simulare il funzionamento di particolari circuitiintegrati senza doverli prima programmare fisicamente. Inoltre consente anche di produrreun file speciale per la programmazione fisica degli stessi.Segue il listato del sorgente XPLA di questa sperimentazione.
MODULE ex3
TITLE ’Semaphore’
CAPITOLO 4. SEMAFORO INTELLIGENTE (FPGA) 60
DECLARATIONS
"sensors
S0,S1,S2,S3 pin;
"Controller
CLK pin;
"UBC
UBC0,UBC1,UBC2,UBC3,UBC4,UBC5,UBC6 node istype ’reg_d’;
UBC7 pin istype ’reg_d’;
UBCC=[UBC7..UBC0];
SR,PR,STRB,EN,DCS pin istype ’com’;
"Data Unit
"Input block
"USR
USR0,USR1,USR2,USR3 pin istype ’reg_d’;
USRR=[USR0..USR3];
"Preferential via
IN0 pin istype ’com’;
"Sequential research
"UBC
UBCR0,UBCR1 pin istype ’reg_d’;
UBCRR=[UBCR1..UBCR0];
CER,CONFIG pin istype ’com’;
"Present state
"USR
USRP0,USRP1 pin istype ’reg_d’;
USRPP=[USRP0..USRP1];
"Block decisional
PRR pin istype ’com’;
"Decoder lights
ARED,BRED,CRED,DRED,ERED,FRED pin;
AGREEN,BGREEN,CGREEN,DGREEN,EGREEN,FGREEN pin;
AYELLOW,BYELLOW,CYELLOW,DYELLOW,EYELLOW,FYELLOW pin;
CAPITOLO 4. SEMAFORO INTELLIGENTE (FPGA) 61
EQUATIONS
"Controller
"UBC
when ( SR == 1 ) then
{ UBCC.d=0; }
else
when ( PR == 1 ) then
{ UBCC.d=^b01111000; }
else
UBCC.d=UBCC.q + 1;
UBCC.clk=CLK;
SR=UBC0.q & UBC1.q & UBC2.q & UBC3.q & UBC4.q & !UBC5.q & !UBC6.q & UBC7.q;
STRB=!UBC0.q & !UBC1.q & !UBC2.q & UBC3.q & UBC4.q & UBC5.q & UBC6.q;
EN=!UBC2.q & UBC3.q & UBC4.q & UBC5.q & UBC6.q;
DCS=!UBC0.q & !UBC1.q & UBC2.q & UBC3.q & UBC4.q & UBC5.q & UBC6.q;
"Block input
"USR
[USR0..USR3].d=STRB & [S0..S3] # !STRB & [USR0..USR3].q;
USRR.clk=CLK;
"Preferential via
IN0=(!( USR0.q # USR1.q # USR2.q # USR3.q ) # USR0.q);
"Sequenzial research
"UBC
when ( CER == 1 ) then
{ UBCRR.d=UBCRR.q + 1; }
else
{ UBCRR.d=UBCRR.q; }
UBCRR.clk=CLK;
CONFIG=(!UBCR0.q & !UBCR1.q & IN0) # (UBCR0.q & UBCR1.q & USR3.q) #
(!UBCR0.q & UBCR1.q & USR2.q) # (UBCR0.q & !UBCR1.q & USR1.q);
CER=(EN & !CONFIG) # STRB;
"Block present state
"USR
[USRP0,USRP1].d=SR & [UBCR0,UBCR1].q # !SR & [USRP0,USRP1].q;
USRPP.clk=CLK;
"Block decisional
CAPITOLO 4. SEMAFORO INTELLIGENTE (FPGA) 62
PRR=!((USRP0.q $ UBCR0.q) # (USRP1.q $ UBCR1.q));
PR=PRR & DCS;
"Decoder lights
ARED=USRP0.q $ USRP1.q;
BRED=USRP0.q # USRP1.q;
CRED=!USRP0.q # USRP1.q;
DRED=!(USRP0.q $ USRP1.q);
ERED=USRP0.q # !USRP1.q;
FRED=!(USRP0.q & USRP1.q);
AGREEN=!UBC7.q & (USRP0.q !$ USRP1.q) # UBC7.q & ((USRP0.q !$ USRP1.q)
& (UBCR0.q !$ UBCR1.q));
BGREEN=!USRP0.q & !USRP1.q & !UBC7.q;
CGREEN=USRP0.q & !USRP1.q & !UBC7.q;
DGREEN=!UBC7.q & (USRP0.q $ USRP1.q) # UBC7.q & ((USRP0.q $ USRP1.q)
& (UBCR0.q $ UBCR1.q));
EGREEN=!USRP0.q & USRP1.q & !UBC7.q;
FGREEN=USRP0.q & USRP1.q & !UBC7.q;
AYELLOW=!ARED & !AGREEN;
BYELLOW=!BRED & !BGREEN;
CYELLOW=!CRED & !CGREEN;
DYELLOW=!DRED & !DGREEN;
EYELLOW=!ERED & !EGREEN;
FYELLOW=!FRED & !FGREEN;
END
4.5 Test e risultati
Una volta accertato che la compilazione del nostro sorgente XPLA non ha segnalato erroripossiamo far partire il simulatore e simulare la nostra esercitazione.Questa simulazione può simulare solo situazioni statiche dei sensori di corsia (ossia i valoridegli stessi non cambiano durante la simulazione). Dapprima dobbiamo inizializzare i valoridei 4 sensori ed il clock della macchina sequenziale sincrona. Con il simulatore si utilizzeràun periodo di clock molto inferiore rispetto a quello che si potrebbe utilizzare nella realtà.Avendo 128 stati per il verde e 32 per il giallo nella realtà sarebbe ragionevole usare un clockdi 7Hz in modo tale da avere una durata del verde di circa 18 secondi e una durata del giallodi circa 4,5 secondi. Con il simulatore adottiamo un clock di 10KHz che su una scala di10.000.000 di nano-secondi ci permette di avere ben 5 transizioni degli stati del semaforo suuna singola schermata. Come primo test mettiamo i valori dei 4 sensori tutti a 1 in modotale da verificare se il semaforo cambia correttamente stato in modo ciclico. La Figura 4.15e la Figura 4.16 mostrano lo storico dei valori dei segnali rilevanti alla fine della simulazione.Dalla simulazione notiamo che lo stato prossimo (UBCR0 e UBCR1) cambia stato in modo
ciclico da S0 a S3. Di conseguenza si comporta in modo analogo lo stato presente (USRP0e USRP1). Lo stato prossimo viene calcolato ogni volta che STRB è alto e diventa il nuovostato presente appena dopo che SR è alto. Il segnale UBC7 quando alto segnala l’inizio ela durata di accensione delle luci gialle. Notiamo che il segnale PR è sempre basso poichè
CA
PIT
OLO
4.SE
MA
FO
RO
INT
ELLIG
EN
TE
(FP
GA
)63
Figura 4.15: Screenshot della prima simulazione
CA
PIT
OLO
4.SE
MA
FO
RO
INT
ELLIG
EN
TE
(FP
GA
)64
Figura 4.16: Screenshot della prima simulazione
CAPITOLO 4. SEMAFORO INTELLIGENTE (FPGA) 65
in questa simulazione non accade mai che lo stato presente e quello prossimo coincidano.Andando ad analizzare le 18 luci del semaforo (che nella realtà sono ben 54, raggruppate atriple) notiamo che esse vengono pilotate in modo corretto.Settiamo ora i valori dei 4 sensori tutti a 0 e verifichiamo il funzionamento del sistema. LaFigura 4.17 e la Figura 4.18 mostrano lo storico dei valori dei segnali rilevanti alla fine dellasimulazione. Non essendo attivo nessuno dei 4 sensori, viene abilitata la corsia preferenziale,come è possibile notare dal segnale IN0 (che è alto). La corsia preferenziale abilita il verdesulle vie A e B. Nel blocco di ricerca sequenziale dello stato prossimo si cicla sempre dallostato S0 a S3 fermandosi sempre in S0. Essendo sempre lo stato presente uguale allo statoprossimo, nel blocco di decisione della data unit viene abilitato sempre il preset del contatoree di fatto il contatore cicla all’infinito dallo stato S120 allo stato S124.Come ultimo test inizializziamo il primo sensore basso, il secondo alto, il terzo basso e il quartoalto. La Figura 4.19 e la Figura 4.20 mostrano lo storico dei valori dei segnali rilevanti alla finedella simulazione. Con quella configurazione dei sensori gli stati del semaforo si alternanotra S1 e S3 come è possibile notare dallo stato presente (USRP0 e USRP1) (tralasciando ilprimo stato S0 dovuto all’inizializzazione dell’hardware). Le luci del semaforo abilitano inmodo alterno la coppia di vie C e D e la coppia F e A.
CA
PIT
OLO
4.SE
MA
FO
RO
INT
ELLIG
EN
TE
(FP
GA
)66
Figura 4.17: Screenshot della seconda simulazione
CA
PIT
OLO
4.SE
MA
FO
RO
INT
ELLIG
EN
TE
(FP
GA
)67
Figura 4.18: Screenshot della seconda simulazione
CA
PIT
OLO
4.SE
MA
FO
RO
INT
ELLIG
EN
TE
(FP
GA
)68
Figura 4.19: Screenshot della terza simulazione
CA
PIT
OLO
4.SE
MA
FO
RO
INT
ELLIG
EN
TE
(FP
GA
)69
Figura 4.20: Screenshot della terza simulazione
Capitolo 5
Semaforo intelligente(microcontroller)
5.1 Esposizione del problema
In questa esercitazione si adotterà un metodo alternativo per la realizzazione di macchinesequenziali. Nelle prime tre esercitazioni si è utilizzato un componente programmabile dellafamiglia di circuiti integrati FPGA; in questa si utilizzerà un microcontroller membro dellafamiglia 8-bit HCMOS ST62xx. Lo scopo di questa esercitazione è lo stesso di quello presen-tato nella precedente (Semaforo intelligente (FPGA)), ossia si vuole realizzare un semaforo“intelligente”, che si deve adattare alle condizioni del traffico (per una spiegazione più det-tagliata si faccia riferimento alle sezioni “Esposizione del problema” e “Funzionamento” dellaprecedente esperienza).Il microcontroller utilizzato è il modello ST6225. L’architettura hardware di questo compo-nente è del tutto simile a quella presente negli attuali PC IBM compatibili: alu, controller,stack, program counter, memoria ROM/RAM, porte I/O, bus, timer, ecc. In Figura 5.1 vieneriportata la piedinatura del componente.In Figura 5.2 viene riportato lo schema a blocchi dell’architettura del microcontroller.
ST
6225
V dd
PC7 6
10
11
12
14
13
1
2
3
4
5
7
8
9
28
27
26
25
24
23
22
21
20
19
18
17
16
15
V ss
PA0
PA1
PA2
PA3
PA4
PA5
PA6
PA7
PB0
PB1
PB2
PB3
PB4PB5
PB6
PB7
RESET
TEST
PC4
PC5
PC6
NMI
OSCout
OSCin
TIMER
Figura 5.1: Piedinatura del microcontroller ST6225
Il controller (inteso come processore) ha un set base di istruzioni macchina che permettono ilfunzionamento del componente. Un’astrazione di queste istruzioni in un linguaggio di basso
70
CAPITOLO 5. SEMAFORO INTELLIGENTE (MICROCONTROLLER) 71
TEST
USER PROGRAMROM
3878 BYTE
PC
DIGITAL
TIMER 1 TIMER
PORT A PA0..PA7
PORT B
PORT C
PB0..PB7
PC4..PC7
TEST
NMI
V dd V ss OSCin OSCout
RESET
RESET
SUPPLYPOWER
USER
DATA ROM
DATA RAM
64 BYTE
A/D CONVERTER8 BIT
OSCILLATOR
8 BIT CORE
STACK LEVEL 1STACK LEVEL 2STACK LEVEL 3STACK LEVEL 4STACK LEVEL 5STACK LEVEL 6
INTERRUPT
SELECTABLE
WATCHDOG
Figura 5.2: Schema a blocchi dell’architettura del microcontroller
CAPITOLO 5. SEMAFORO INTELLIGENTE (MICROCONTROLLER) 72
livello, linguaggio assembly, permette di programmare il componente (con un apposito com-pilatore che genera istruzioni macchina) in un linguaggio facilmente comprensibile alla menteumana. Una volta scritto e compilato il programma in assembly un simulatore software cipermetterà di simulare il funzionamento del componente ST6225, effettuando di fatto undebugging sull’esecuzione del programma compilato.Per maggiori informazioni sul microcontroller ST6225 si consiglia di consultare il relativodata sheet.
5.2 Descrizione della soluzione
Una possibile soluzione consiste nel seguire sulla falsa riga le varie fasi della soluzione dellasperimentazione con FPGA. In Figura 5.3 viene riportato lo schema logico per la realizzazio-ne del semaforo “intelligente” con il microcontroller.
Per realizzare il semaforo “intelligente” bisogna programmare correttamente il microcon-troller. Le porte I/O del microcontroller saranno utilizzate per la lettura dei sensori e perpilotare le luci del semaforo come mostrato in Figura 5.4.La porta C verrà utilizzata per la lettura dei sensori e quindi sarà una porta d’ingresso. I
6 bit meno significativi della porta A piloteranno le luci gialle del semaforo corrispondentiad ogni via. I 6 bit meno significativi della porta B piloteranno sia le luci verdi che quellerosse del semaforo a seconda che sia abilitato o meno il buffer. Il buffer viene abilitato da unimpulso basso-alto proveniente dal bit più significativo della porta B. Prima si accenderannoi rossi e poi i verdi. Le porte A e B saranno due porte d’uscita.
5.3 Descrizione del progetto
Con il data sheet del microcontroller sotto mano dobbiamo implementare in assembly le variefasi dello schema logico di Figura 5.3.
5.3.1 Init
Quando si avvia l’hardware dobbiamo portare il sistema in uno dei 4 stati possibili accendendole luci verdi e rosse relative a tale stato. Ecco il codice assembly.
; init
LD A,40H ; read first byte in the ROM window
LD PGREEN,A
COM A
RES 7,A
LD DRB,A ; switch on red lights
SET 7,DRB ; enable buffer
LD A,PGREEN
SET 7,A
LD DRB,A ; switch on green lights and disable buffer
LDI PS,0H ; set present state
LDI WDR,0FEH ; WATCHDOG preset
5.3.2 Temporizzatore
Dobbiamo utilizzare il timer all’interno del microcontroller per scandire la durata di accen-sione delle luci verdi e gialle.
CAPITOLO 5. SEMAFORO INTELLIGENTE (MICROCONTROLLER) 73
INITinizializzazione hardwareinizializzazione softwareinizializzazone processo
DURATAVERDE
S0=0 S1=0 S2=0 S3=0 S0=1
P=0 S1=1 X=1
no
S0=1
no
P=X
DURATA
GIALLO
P=X
LEGGENDA
X STATO PROSSIMO
Sn SENSORI
P STATO PRESENTE
temporizzatore
LETTURASENSORI
si si si si
no no no no
si
si si
no no
si si
no no
si si
no no
P=1 S2=1 X=2
P=2 S3=1 X=3
X=0
si
via preferenziale
ricerca stato prossimo
GIALLI
ACCENSIONE
accensione condizionale gialli
spegnimento condizionale verdi
temporizzatore
CAMBIO
LUCI
spegnimento gialli
accensione rossi e verdi
Figura 5.3: Schema logico
CAPITOLO 5. SEMAFORO INTELLIGENTE (MICROCONTROLLER) 74
ross
igi
alli
verd
i
buffe
r
V ss
PA0
PA1
PA2
PA3
PA4
PA5
PA6
PA7
PB0
PB1
PB2
PB3
PB4PB5
PB6
PB7
RESET
TEST
PC4
PC5
PC6
NMI
OSCout
OSCin
TIMER
V dd
PC7 6
10
11
12
14
13
1
2
3
4
5
7
8
9
28
27
26
25
24
23
22
21
20
19
18
17
16
15S
T62
25
sens
ori
Figura 5.4: Utilizzo delle porte di I/O del microcontroller
Il timer del microcontroller è composto da un contatore a 8 bit (registro TCR) con un pre-scaler programmabile di 7 bit (registro PSC), e quindi la capacità di conteggio massima deltimer è di 215. Un registro di 8 bit (TSCR) gestisce la logica di funzionamento del timer.Poichè utilizziamo l’oscillatore interno del microcontroller, il clock del prescaler (che di fattoè un contatore) è il clock dell’oscillatore diviso per 12, ossia 8Mhz/12=∼667Khz. I 3 bitmeno significativi del registro TSCR gestiscono il fattore di divisione del prescaler il qualecontribuisce a determinare il clock del contatore a 8 bit (TCR). Il fattore di divisione va daun minimo di 1 (con i 3 bit a 0) a un massimo di 128 (con i 3 bit a 1). Poichè vogliamogestire durate nell’ordine di secondi utilizzeremo il fattore di divisione massimo in modo taleda allungare il più possibile il periodo dei cicli di clock del contatore TCR. In questo modoil clock di quest’ultimo sarà pari a (8Mhz/12)/128=∼5,2Khz. Questo vuol dire che ogni1/5200 secondi, il contatore TCR viene decrementato di una unità. Quando arriva a zero,il settimo bit (TMZ) del registro TSCR viene posto a uno per segnalare il fatto. Supponen-do di caricare al massimo il contatore TCR (0FFh), riusciremmo a scandire una durata di(1/((8Mhz/12)/128))*256=∼0,050 secondi. La flessibilità di un linguaggio di programmazio-ne come l’assembly ci permette di allungare a piacimento questa durata (tuttavia esiste unlimite massimo). Il quarto bit (PSI) del registro TSCR abilita(1)/disabilita(0) il contatore.Il quinto (DOUT) e il sesto bit (TOUT) impostano la modalità di funzionamento del timer.Quando entrambi sono a 1 verrà utilizzato il clock dell’oscillatore interno e il bit TMZ saràcollegato al segnale TIMER che è uno dei pin d’uscita del microcontroller.Segue la routine DELAY che gestirà la durata di accensione delle luci.
; delay
DELAY LDI PSC,03H ; prescaler
CAPITOLO 5. SEMAFORO INTELLIGENTE (MICROCONTROLLER) 75
LDI TCR,0FFH ; counter
LDI TSCR,03FH ; timer register (go timer, /128)
LOOP1 LDI WDR,0FEH ; watch dog ; (max 64 cycles)
JRR 7,TSCR,LOOP1 ; loop on TMZ ; 5 cycles
LDI TSCR,037H ; stop timer
DEC V
JRZ LOOP2
JP DELAY
LOOP2 LD A,COUNT ; check COUNT
CPI A,0H
JRZ EXIT
LD A,X
LD V,A
DEC COUNT
JP DELAY
EXIT LDI WDR,0FEH ; WATCHDOG preset
RET
Le locazioni V e X (8 bit) conterranno il numero di volte per il quale si vuole azzerare ilcontatore TCR (X server per ricordarsi il valore di V, poichè quest’ultimo viene decrementa-to). Se carichiamo sia TCR che V al massimo valore, ossia 0FFh, riusciamo a scandire unadurata massima di ben (1/((8Mhz/12)/128))*256*256=∼13 secondi. Per riuscire a scandiredurate ancora più lunghe ci serviamo di un’altra locazione a 8 bit, COUNT, che conterrà ilnumero di volte per il quale si vuole azzerare V. In questo modo riusciremo a scandire duratemassime di quasi 1 ora, decisamente troppo lunghe per scandire l’accensione delle luci verdio gialle di un semaforo.Imposteremo V a 50h e COUNT a 0h per scandire la durata di accensione delle luci gialledi circa 4 secondi e V a 0C8h e COUNT a 2h per scandire la durata di accensione delle luciverdi di circa 20 secondi.
5.3.3 Lettura sensori e via preferenziale
I sensori sono collegati alla porta C (4 bit) del microcontroller che sarà quindi impostatacome porta d’ingresso. Alla locazione DRC (8 bit) è possibile leggere i valori dei sensori sui4 bit piu’ significativi. Se questi sono tutti a 0 bisogna attivare la via preferenziale, ossiabisogna portare a 1 il primo sensore.Segue il codice assembly che realizza queste funzioni.
; sensors reading and check preferential way
CHECK LD A,DRC ; sensors reading
ANDI A, 0F0H ; check preferential way
JRNZ NO_P_WAY
LDI A,10H ; set preferential way
NO_P_WAY LD SENSORS,A ; set sensors
5.3.4 Ricerca stato prossimo
Conoscendo lo stato presente del sistema (locazione PS) e i valori dei sensori (locazione SEN-SORS, 4 bit più significativi) possiamo determinare lo stato prossimo del sistema (locazioneXS). A seconda dello stato presente del sistema si va a controllare il bit del sensore relativo
CAPITOLO 5. SEMAFORO INTELLIGENTE (MICROCONTROLLER) 76
allo stato seguente quello presente. Se questo è alto allora lo stato prossimo sarà quello asso-ciato al sensore controllato, altrimenti si andrà a controllare in modo ciclico tutti i restantisensori e ci si comporterà di conseguenza. Una volta determinato lo stato prossimo del siste-ma, lo si confronterà con quello presente e se coincidenti allora si ripartirà dalla lettura deisensori.Segue il codice assembly che realizza queste funzionalità.
; check present state (PS)
LDI WDR,0FEH ; WATCHDOG preset
JRS 0,PS,PPP
JRS 1,PS,TWO
JP ZERO
PPP JRS 1,PS,THREE
JP ONE
; find next state (XS)
ZERO JRR 5,SENSORS,ONE
LDI A,1H
LD XS,A
JP COMPARE
ONE JRR 6,SENSORS,TWO
LDI A,2H
LD XS,A
JP COMPARE
TWO JRR 7,SENSORS,THREE
LDI A,3H
LD XS,A
JP COMPARE
THREE JRR 4,SENSORS,ZERO
LDI A,0H
LD XS,A
JP COMPARE
; compare next and present state
COMPARE LDI WDR,0FEH ; WATCHDOG preset
LD A,PS
CP A,XS
JRNZ NO_CHECK
JP CHECK ; return to the sensors reading
5.3.5 Accensione gialli
Se lo stato prossimo XP è diverso dallo stato presente PS allora dobbiamo spegnere le luciverdi che sono accese, accendere le relative gialle e temporizzare quest’ultime. Dobbiamo peròtener conto che nella transizione da uno stato all’altro ci potrebbe essere in comune una via.In questo caso non ha senso spegnere la luce verdi per quella via, accedere la relativa gialla epoi riaccendere la verde. La luce verde di quella via deve rimanere accesa. Lo spegnimentocondizionale delle luci verdi può essere implementato facendo l’and tra la combinazione delle
CAPITOLO 5. SEMAFORO INTELLIGENTE (MICROCONTROLLER) 77
luci verdi dello stato presente e la combinazione delle luci verdi dello stato prossimo. Il risul-tato dell’and sarà la combinazione delle luci verdi che devono rimanere accese. Un discorsoanalogo va fatto per l’accensione delle luci gialle che può essere implementata effettuandol’and tra il complemento della combinazione delle luci verdi dello stato prossimo e la combi-nazione delle luci verdi dello stato presente. Fatto ciò dobbiamo scandire l’accensione delleluci gialle richiamando opportunamente la routine DELAY.Segue il codice assembly che realizza queste funzionalità.
; switch on yellow lights
NO_CHECK LD A,PS
ADDI A, 40H
LD Y,A
LD A,(Y)
LD PGREEN,A ; PS green lights combination
LD A,XS
ADDI A, 40H
LD Y,A
LD A,(Y)
LD XGREEN,A ; XS green lights combination
AND A,PGREEN
SET 7,A
LD DRB,A ; conditional switch off green lights
LD A,XGREEN
COM A
AND A,PGREEN
LD DRA,A ; conditional switch on yellow lights
; delay yellow lights
LDI WDR,0FEH ; WATCHDOG preset
LDI A,50H
LD V,A ; times TMZ at zero
LD X,A ; backup V
LDI COUNT, 0H ; times V at zero
CALL DELAY
5.3.6 Cambio luci
Alla fine della durata di accensione delle luci gialle dobbiamo spegnere quest’ultime, accenderela combinazione di luci verdi dello stato prossimo, accendere le luci rosse opportune (ottenutedalla negazione di quelle verdi) e temporizzare le luci verdi per poi ripartire dalla lettura deisensori. Inoltre lo stato prossimo è il nuovo stato presente.Segue il codice assembly che realizza queste funzionalità.
; lights change
LDI DRA,0H ; switch off yellow lights
LD A,XGREEN
COM A
RES 7,A
CAPITOLO 5. SEMAFORO INTELLIGENTE (MICROCONTROLLER) 78
LD DRB,A ; switch on red lights
SET 7,DRB ; enable buffer
LD A,XGREEN
SET 7,A
LD DRB,A ; switch on green lights and disable buffer
; next state become present state
LD A,XS
LD PS,A
; delay green lights
G_DELAY LDI A,0C8H
LD V,A ; times TMZ at zero
LD X,A ; backup V
LDI COUNT, 02H ; times V at zero
CALL DELAY
5.4 Listato del sorgente assembly
Segue il sorgente in assembly che sarà utilizzato, una volta compilato, per la programmazionedel microcontroller ST6225 al fine di realizzare il semaforo “intelligente”.
;|------------------------------------------------------------------------|
;| TRAFFIC ADAPTED SEMAPHORE |
;|------------------------------------------------------------------------|
;|------------------------------------------------------------------------|
;| ST6225 REGISTERS DECLARATION |
;|------------------------------------------------------------------------|
; .LINESIZE 79 ; printing
; .PL 58 ; printing
.TITLE " TRAFFIC ADAPTED SEMAPHORE "
.VERS "ST6225" ; 8MHz
.ROMSIZE 4 ; ROM size
X .DEF 80h ; Index register
Y .DEF 81h ; Index register
V .DEF 82h ; Short direct register
W .DEF 83h ; Short direct register
A .DEF 0FFh!m ; Accumulator
DRA .DEF 0C0h!m ; Port a data register
DRB .DEF 0C1h!m ; Port b data register
DRC .DEF 0C2h!m ; Port c data register
DDRA .DEF 0C4h ; Port a direction register
DDRB .DEF 0C5h ; Port b direction register
CAPITOLO 5. SEMAFORO INTELLIGENTE (MICROCONTROLLER) 79
DDRC .DEF 0C6h ; Port c direction register
IOR .DEF 0C8h ; Interrupt option register
DRWR .DEF 0C9h ; Data rom window register
ORA .DEF 0CCh ; Port a option register
ORB .DEF 0CDh ; Port b option register
ORC .DEF 0CEh ; Port c option register
ADR .DEF 0D0h ; A/D data register
ADCR .DEF 0D1h ; A/D control register
PSC .DEF 0D2h ; Timer prescaler register
TCR .DEF 0D3h!m ; Timer counter register
TSCR .DEF 0D4h ; Timer status control register
WDR .DEF 0D8h ; Watchdog register
;|------------------------------------------------------------------------|
;| DATA DECLARATION |
;|------------------------------------------------------------------------|
COUNT .DEF 084H
SENSORS .DEF 085H
PS .DEF 086H!m ; present state
XS .DEF 087H!m ; next state
PGREEN .DEF 088H ; present green lights
XGREEN .DEF 089H ; next green lights
;|------------------------------------------------------------------------|
;| TABLE IN ROM |
;|------------------------------------------------------------------------|
.ORG 0F00H ; green lights for S0, S1, S2, S3 state
.BYTE 3H, 0CH, 18H, 21H, 0H, 0H
;|------------------------------------------------------------------------|
;| INTERRUPT VECTORS |
;|------------------------------------------------------------------------|
.ORG 0FF0H
IT_ADC NOP
RETI
IT_TIMER NOP
RETI
IT_PRTBC NOP
RETI
IT_PRTA NOP
RETI
CAPITOLO 5. SEMAFORO INTELLIGENTE (MICROCONTROLLER) 80
NOP
NOP
NOP
NOP
NMI NOP
RETI
RESET JP BEGIN
;|------------------------------------------------------------------------|
;| REGISTERS INITIALIZATION |
;|------------------------------------------------------------------------|
.ORG 880H ; program begin
BEGIN LDI IOR,00H ; interrupts off
LDI WDR,0FEH ; WATCHDOG preset
RETI ; end of reset interrupt
LDI DDRA,0FFH ; A out register
LDI ORA,0FFH ; push-pull mode
LDI DRA,00H ; data A
LDI DDRB,0FFH ; B out register
LDI ORB,0FFH ; push-pull mode
LDI DRB,80H ; data B
LDI DDRC,00H ; C in register
LDI ORC,00H ; no interrupt mode
LDI DRC,00H ; data C
LDI ADCR,00H ; ADC off (power down)
LDI TSCR,07H ; TIMER in standby
LDI TCR,0FFH ; timer counter full
LDI DRWR,3CH ; preset DRWR
;|------------------------------------------------------------------------|
;| MAIN PROGRAM |
;|------------------------------------------------------------------------|
; init
LD A,40H ; read first byte in the ROM window
LD PGREEN,A
COM A
RES 7,A
LD DRB,A ; switch on red lights
SET 7,DRB ; enable buffer
LD A,PGREEN
SET 7,A
LD DRB,A ; switch on green lights and disable buffer
LDI PS,0H ; set present state
LDI WDR,0FEH ; WATCHDOG preset
; delay green lights
CAPITOLO 5. SEMAFORO INTELLIGENTE (MICROCONTROLLER) 81
G_DELAY LDI A,0C8H
LD V,A ; times TMZ at zero
LD X,A ; backup V
LDI COUNT, 02H ; times V at zero
CALL DELAY
; sensors reading and check preferential way
CHECK LD A,DRC ; sensors reading
ANDI A, 0F0H ; check preferential way
JRNZ NO_P_WAY
LDI A,10H ; set preferential way
NO_P_WAY LD SENSORS,A ; set sensors
; check present state (PS)
LDI WDR,0FEH ; WATCHDOG preset
JRS 0,PS,PPP
JRS 1,PS,TWO
JP ZERO
PPP JRS 1,PS,THREE
JP ONE
; find next state (XS)
ZERO JRR 5,SENSORS,ONE
LDI A,1H
LD XS,A
JP COMPARE
ONE JRR 6,SENSORS,TWO
LDI A,2H
LD XS,A
JP COMPARE
TWO JRR 7,SENSORS,THREE
LDI A,3H
LD XS,A
JP COMPARE
THREE JRR 4,SENSORS,ZERO
LDI A,0H
LD XS,A
JP COMPARE
; compare next and present state
COMPARE LDI WDR,0FEH ; WATCHDOG preset
LD A,PS
CP A,XS
JRNZ NO_CHECK
JP CHECK ; return to the sensors reading
CAPITOLO 5. SEMAFORO INTELLIGENTE (MICROCONTROLLER) 82
; switch on yellow lights
NO_CHECK LD A,PS
ADDI A, 40H
LD Y,A
LD A,(Y)
LD PGREEN,A ; PS green lights combination
LD A,XS
ADDI A, 40H
LD Y,A
LD A,(Y)
LD XGREEN,A ; XS green lights combination
AND A,PGREEN
SET 7,A
LD DRB,A ; conditional switch off green lights
LD A,XGREEN
COM A
AND A,PGREEN
LD DRA,A ; conditional switch on yellow lights
; delay yellow lights
LDI WDR,0FEH ; WATCHDOG preset
LDI A,50H
LD V,A ; times TMZ at zero
LD X,A ; backup V
LDI COUNT, 0H ; times V at zero
CALL DELAY
; lights change
LDI DRA,0H ; switch off yellow lights
LD A,XGREEN
COM A
RES 7,A
LD DRB,A ; switch on red lights
SET 7,DRB ; enable buffer
LD A,XGREEN
SET 7,A
LD DRB,A ; switch on green lights and disable buffer
; next state become present state
LD A,XS
LD PS,A
CALL G_DELAY
; delay
DELAY LDI PSC,03H ; prescaler
CAPITOLO 5. SEMAFORO INTELLIGENTE (MICROCONTROLLER) 83
LDI TCR,0FFH ; counter
LDI TSCR,03FH ; timer register (go timer, /128)
LOOP1 LDI WDR,0FEH ; watch dog ; (max 64 cycles)
JRR 7,TSCR,LOOP1 ; loop on TMZ ; 5 cycles
LDI TSCR,037H ; stop timer
DEC V
JRZ LOOP2
JP DELAY
LOOP2 LD A,COUNT ; check COUNT
CPI A,0H
JRZ EXIT
LD A,X
LD V,A
DEC COUNT
JP DELAY
EXIT LDI WDR,0FEH ; WATCHDOG preset
RET
;|------------------------------------------------------------------------|
;| END OF MAIN PROGRAM |
;|------------------------------------------------------------------------|
.END
5.5 Test e risultati
Una volta accertato che la compilazione del sorgente in assembly non ha segnalato erroripossiamo simulare la nostra esercitazione. La simulazione consiste nell’esecuzione passo passodelle istruzioni contenute nel programma assembly con la verifica dei registri e delle locazionidi memoria coinvolti nel programma (è anche possibile modificare i valori dei sensori durantel’esecuzione del programma). In Figura 5.5 viene riportato uno screenshot del simulatore.
Figura 5.5: Screenshot del simulatore SIMST6
Capitolo 6
Conclusione
Esistono diversi metodi per realizzare una macchina sequenziale. Un modo è quello di com-binare componenti SSI (Single Scale Integration, come flip-flop e porte logiche) e MSI (Me-dium Scale Integration, come contatori e registri a scorrimento). Un altro modo è quellodi utilizzare componenti a livello LSI (Large Scale Integration, come FPGA) programmabilidall’utente. In questi componenti sono presenti strutture AND-OR e flip-flop (macrocelle),le cui interconnessioni sono da realizzarsi attraverso programmazione tramite un linguaggiodi alto livello (HDL). Un terzo modo è quello di utilizzare microcontroller, dei veri e propriPC in miniatura, spesso programmabili in assembly.Nelle nostre esperienze di laboratorio abbiamo adottato le metodologie di realizzazione dimacchine sequenziali tramite componenti FPGA e microcontroller. La programmazione inAbel degli FPGA risulta più snella e semplice rispetto alla programmazione in assembly deimicrocontroller che ha però il vantaggio di essere molto flessibile e completa.I simulatori giocano un ruolo primario nella verifica della macchina sequenziale progettata,infatti permettono di testare il progetto senza l’impiego di hardware e questo significa unrisparmio in termini di tempo e costi sul progetto.
84