UNIVERSITÀ DEGLI STUDI DI ROMA “TOR VERGATA” Facoltà di Scienze Matematiche, Fisiche e Naturali

Corso di Laurea in Fisica

Sviluppo di un’interfaccia VME su logica programmabile

Ivano Sarra

Relatori Prof. Roberto Messi Dott. Andrea Salamon

ANNO ACCADEMICO 2004/2005

Indice Generale Introduzione…………………………I Capitolo I 1.1 VME…………………………..…III 1.2 FPGA………………………….....V 1.2.1 Introduzione alle logiche programmabili…………….V 1.2.2 Caratteristiche tecniche……………………………...VI 1.2.3 Analisi dei parametri fondamentali………………..VIII Capitolo II 2.1 Tipologie di temporizzazione…......X 2.2 Macchina a stati…………………XII 2.3 Protocollo Rabit-Altera………...XIII 2.4 Protocollo Altera-VME………....XV Capitolo III Risultati dell’implementazione.........XIX Conclusioni……………………….XXII Appendice A Simulazioni……………………….XXIII Appendice B VHDL……….……………….........XXV Appendice C Codice sorgente.............................XXVII Glossario Bibliografia

Introduzione L'acquisizione dei dati mediante schede di ingresso-uscita pilotate da computer offre notevole flessibilità, potenza di calcolo e la possibilità di effettuare registrazioni automatiche non presidiate dall'operatore. Una scheda elettronica che realizza l'interfaccia fra il ricevitore ed il PC è suddivisibile in un microcontrollore, che comunica con l’utente, e in un particolare circuito integrato con funzione di interfaccia tra questo ed il data bus. Nella seguente trattazione verrà descritta la procedura con la quale tale circuito integrato viene programmato; inoltre verranno messe in evidenza le procedure di programmazione utilizzate, come la macchina a stati di Moore, e i protocolli seguiti per comunicare con il microcontrollore ed il bus. L’unità di interfaccia consiste in una FPGA1 della serie Altera, l’unità microcontrollore è un Rabbit serie 3000 e per il data bus si è utilizzato il protocollo VME2 a 32bit.

Schematizzazione del sistema. L’utente, tramite un’interfaccia grafica, richiede ad un determinato indirizzo i dati rilevati da una scheda VME collegata al crate del bus. Il Rabbit rileva la richiesta e la trasmette all’Altera, seguendo un protocollo di comunicazione interno; quest’ultima si occupa della ricezione dei dati dalla scheda, tramite comunicazione di tipo Master-Slave, sviluppata in modo da soddisfare lo standard A32 del bus3. L’utente potrà inoltre inviare dati ad un indirizzo a scelta. La progettazione di una scheda, in cui sono presenti più circuiti integrati può essere divisa nelle seguenti fasi: • Programmare i circuiti integrati. L’Altera tramite linguaggio VHDL4, il Rabbit in Dynamic C.

1 Field Programmable Gate Array. 2 Versa Module Europa. 3 La tipologia della comunicazione sarà ampiamente descritta nel corso della trattazione. 4 Acronimo di Very high speed integrated circuits Hardware Description Language.

Sarra Ivano I 19/02/2006 I

• Simulare il funzionamento del circuito integrato sottoponendolo a determinati segnali di prova e verificando che risponda nel modo voluto. Per l’Altera si è utilizzato il programma Modelsim, che oltre a compilare il file VHDL, permette di verificare l’entità realizzata e di visualizzare la risposta dei vari segnali tramite forme d’onda5. Per il Rabbit non si hanno a disposizione programmi di simulazione di questo tipo, e il test di controllo è stato effettuato a "mano", rilevando con l'aiuto di led il valore alto o basso dei segnali in risposta agli stimoli.

• Realizzare la scheda, dove vengono inseriti i circuiti integrati, e verificarne il funzionamento all’interno del bus.

5 Le forme d’onda realizzate sono riportate in appendice A.

Sarra Ivano II 19/02/2006 II

Capitolo I Nella prima parte del capitolo vengono elencate alcune delle caratteristiche tecniche e meccaniche del bus VME. La seconda parte del capitolo è dedicata alla descrizione tecnica del circuito integrato FPGA e della vasta gamma di applicazioni che esso consente.

1.1 VME Lo standard VME nasce nel 1987 ed è ad oggi uno dei più diffusi tra i bus industriali. Vediamo brevemente gli elementi definiti dallo standard, figura 1.1:

Figura 1.1: Schematizzazione del bus VME. Ogni backplane è composto da più moduli funzionali, che determinano la comunicazione nel bus. Per la parte meccanica evidenziamo due unità:

• Backplane; un circuito stampato (PCB6) con connettori di 96 pin e percorsi che connettono i pin di connettore corrispondenti.

• Slot; fessure dove inserire i circuiti stampati. Mentre per la parte elettronica:

• Backplane interface logic; la logica speciale che tiene in considerazione le caratteristiche del backplane: impedenza del segnale, tempo di propagazione...

• Interrupter; un modulo funzionale che genera una richiesta di interrupt, e fornisce le informazioni di status/ID appena l’interrupt handler le richiede.

6 Printed Circuit Board.

Sarra Ivano III 19/02/2006 III

• Interrupt Handler; un modulo funzionale che rileva l’interrupt generato dall’interrupter e risponde richiedendo le informazioni di status/ID.

• Sono inoltre presenti moduli per l’arbitraggio, ovvero per la gestione delle contese tra i vari Master.

A seconda dei bit utilizzati per i dati e gli indirizzi, lo standard VME permette diversi tipi di trasferimento che si differenziano tra di loro per la larghezza delle parole trasferite. Il lavoro da realizzare comportava l’utilizzazione dello standard VME A32. Tuttavia vista la potenza del circuito integrato e la notevole velocità di funzionamento del programma implementato, cercheremo di estendere il progetto tramite l’utilizzo del VME64x7, che utilizza 64 bit per il trasferimento dati. Le linee di trasferimento dati previsti dallo standard IEEE 1014, a cui facciamo riferimento, possono essere cosi schematizzate:

Addressing lines Data lines Control lines A01-A31 AS*

AM0-AM5 DS0*

DS0* DS1*

DS1* BERR*

LWORD* DTACK*

D00-D31

WRITE* Tabella 1.1: Linee di trasferimento dati utilizzate dallo standard VME. Per i dati si utilizzano le linee D (composte da 32 pin), per gli indirizzi le 31 linee A, e LWORD* (per l’ultimo bit significativo). Il 64x prevede il multiplessaggio delle linee A e di LWORD*, da utilizzare per trasferire i dati (insieme alle D) a 64bit. Concludiamo questo capitolo analizzando brevemente i segnali sopraelencati:

• I segnali A01-A31, AM0-AM5, DS0*, DS1*, LWORD* sono utilizzati per l’indirizzamento; il fatto che per un indirizzo a 32bit, siano necessari 39 pin (32 di indirizzo e 7 in arbitraggio), è dovuto al fatto che parte di essi AM, DS0/1* e LWORD* determinano il tipo di protocollo di comunicazione richiesto con il bus. A seconda del tipo di comunicazione e del tipo di standard adottato, A32, i valori di questi pin seguono combinazioni ben determinate8.

• I segnali di controllo AS*, WRITE*, BERR*, DTACK*, DS0*, DS1*, controllano e gestiscono la comunicazione tra Master e Slave:

AS* (address strobe9) viene utilizzato dal Master per comunicare di aver fornito gli indirizzi e di essere pronto ha svolgere la sua funzione, leggere o scrivere i dati. WRITE* determina col suo valore la funzione che il Master deve esplicitare: high per la lettura dei dati (Slave→Master), low per la scrittura dei dati (Master→Slave). DS0*, DS1* sono utilizzati oltre che per l’indirizzamento, come strobe supplementari. Come tutti i segnali del bus funzionano in logica negativa: nel primo fronte di discesa indicano che i dati sono stati posti sugli appositi pin, mentre nel primo fronte di salita indicano che i dati sono stati rimossi. DTACK* (data transfer acknowledge) informa (se low) che il trasferimento è avvenuto con successo.

7 Extensions. 8 Per maggiori informazioni sull’arbitraggio si consiglia la lettura del VME Handbook[1]. 9Gli strobe sono segnali utilizzati dagli utenti per asserire che un’operazione è stata svolta.

Sarra Ivano IV 19/02/2006 IV

BERR* (bus error) riporta un errore avvenuto nell’indirizzamento (per esempio low, può rappresentare che uno Slave richiesto non risponde). RETRY* informa il Master che lo Slave è momentaneamente occupato. Sarà il Master a decidere se riprovare in seguito o abbandonare l’operazione.

1.2 FPGA

Il dispositivo FPGA usato è un Altera Acex EP1K100QC208-1, le cui caratteristiche in termini di capacità sono elencate in tabella:

Feature EP1K100 Typical gates 100.000

Maximum system gates 257.000 Logic elements (Les) 4.992

EAB 12 Total RAM bit 49.152

Maximum user I/O pins 333 Acex 1K Device Features

Figura 1.2: Altera Acex EP1K100QC208-1.

1.2.1 Introduzione Alle Logiche Programmabili L'acronimo FPGA sta per Field Programmable Gate Array, ossia "matrice di porte logiche programmabile sul campo". Si tratta di una particolare classe di circuiti integrati che è possibile riprogrammare per realizzare il progetto digitale voluto. È uno strumento che dà la possibilità di riconfigurare le risorse logiche disponibili per implementare un progetto complesso a livello di singole interconnessioni tra porte logiche. Ed è proprio questa la strada che in fase di programmazione si deve seguire, ovvero pensare in termini di porte logiche connesse tra di loro, e quindi procedere con l’implementazione passo passo. La gerarchia strutturale è la seguente: un insieme di transistor integrati permette di implementare una porta logica, un agglomerato di porte logiche forma una rete combinatoria che produce un certo risultato in base agli input forniti (ad esempio un sommatore o un moltiplicatore).

Sarra Ivano V 19/02/2006 V

Per permettere la creazione di funzioni più estese sono nati linguaggi di definizione dei chip di medio-alto livello (come il VHDL): con questi linguaggi si possono usare librerie di componenti pre-definiti e lavorare con blocchi di alto livello. Il processo che ha portato alla creazione del VHDL è analogo a quello che porta dall’Assembler al C al C++..., ovvero il bisogno di aumentare la potenza astraendo dall'hardware sottostante. Definito il chip in VHDL e fatte tutte le sue simulazioni, arriva il momento di trasferire il progetto logico sul supporto fisico. E qui esistono due possibili approcci: 1. Implementare un chip full-custom 2. utilizzare una logica programmabile La prima soluzione prevede la compilazione del progetto logico fino alle singole disposizioni di transistor, questo approccio richiede un forte intervento umano ma permette una ottimizzazione dei ritardi, lo sfruttamento massimo della tecnologia di integrazione scelta e quindi il raggiungimento di elevate prestazioni. Sono progetti full-custom tipicamente i processori (Intel, AMD, etc..). Chiaramente chi si può permettere un approccio del genere può creare prodotti con alte prestazioni, ma con costi di sviluppo elevati; questa modalità di sviluppo è adatta a prodotti di grande diffusione commerciale. La seconda soluzione utilizza dei particolari chip già integrati in cui si hanno una serie di blocchi logici elementari riprogrammabili e collegabili tra loro secondo le esigenze del progetto finale. I vantaggi sono evidenti: si compra il chip, si compra la scheda che permette la programmazione del chip, tramite un compilatore si genera la giusta configurazione a partire dal nostro codice VHDL ed il chip è pronto. In questo modo si azzerano praticamente i costi fissi, ma si innalza di molto il costo per il singolo chip. Queste logiche infatti sono ampiamente ridondanti per permettere la riprogrammazione, ed esiste quindi sempre un rapporto considerevolmente sfavorevole tra numero di transistor globali che compongono il chip fisico e numero di transistor utilizzati nello specifico progetto. Nel nostro caso si è utilizzato il 5% degli elementi logici a disposizione, nel seguente modo:

Total logic elements 263/4.992(5%) Number of cells with registers 12

Number of cells with combinational logic 251 Tabella 1.2: Elementi logici utilizzati.

1.2.2 Caratteristiche Tecniche Una FPGA è composta da un insieme di transistor integrati, che formano array logici e macrocelle EAB10; nei primi i transistor sono configurati in modo da ottenere gate da utilizzare per le funzioni logiche, invece nelle seconde generano i flip-flop da utilizzare per i registri di memoria. Altera realizza tali dispositivi con il nome di ACEX 1K caratterizzati da un basso costo, un elevato numero di porte logiche (nel nostro caso 100.000), un elevato numero di I/O (208) ed elevata frequenza operativa. Il clock effettivo dipenderà dalle funzioni logiche implementate. Lo schema a blocchi è riportato in figura 1.3. Elemento che caratterizza questo dispositivo sono i blocchi EAB (Embedded Array Block), tali elementi sono delle vere e proprie celle di memoria RAM configurabili dall’utente.

10 Embedded Array Block.

Sarra Ivano VI 19/02/2006 VI

Figura 1.3: Struttura del chip Altera Acex 1k. Si possono osservare le celle EAB, e gli array per le funzioni logiche. Gli elementi sono connessi tramite piste interne all’intergrato; ci sono dei pin dedicati (come quello per il clock globale), che corrispondono a piste di collegamento preferenziale, utilizzate per rendere più veloce possibile il circuito integrato. La memoria EAB, si avvale di una serie di dispositivi hardware integrati, che permettono di realizzare al meglio la funzione specifica. La struttura LAB di una ACEX 1K è rappresentata in figura 1.4. Un gruppo LAB, racchiude un certo numero di macro-celle, ossia i "nuclei" che realizzano le strutture fondamentali del FPGA. Le funzioni logiche combinatorie sono realizzate attraverso una memoria, in cui gli indirizzi costituiscono gli ingressi della rete logica e le uscite i dati. Ogni LE (Logic Element) rappresenta un analogo della struttura macro-cella introdotta precedentemente.

Sarra Ivano VII 19/02/2006 VII

Figura 1.4: Struttura logic array block. Tramite i blocchi logici possono essere implementate le varie funzioni logiche.

1.2.3 Analisi Dei Parametri Fondamentali La scelta del dispositivo da utilizzare è sicuramente il primo passo per la buona riuscita di un progetto; scegliere un dispositivo piuttosto che un altro si ripercuoterà in una serie di problemi o di vantaggi che si incontreranno durante la fase di implementazione e simulazione.I parametri più importanti da tenere in considerazione sono:

• Frequenza operativa. • Utilizzo di elementi logici. • Utilizzo di I/O.

Il primo dipende fortemente dal programma implementato; allo stesso tempo bisogna ricordare che nel momento in cui la FPGA sia poi collegata ad un'altra logica, non è detto che tale caratteristica sia ancora ottenibile, in particolare qualora il resto del circuito sia asincrono. Il clock totale dell’interfacia di comunicazione dati da noi realizzata, sarà determinato dal clock proprio del Rabbit, molto inferiore a quello che con un programma mediocre si può ottenere dall'Altera (stimabile sui 150MHz). Il numero di elementi logici necessari dipende ovviamente da quali funzioni andiamo a programmare, ma anche dall’efficienza del sintetizzatore, ossia dal programma che trasforma il circuito logico in una lista di interconnessioni (netlist). Il medesimo problema, infatti può essere risolto in modi differenti, i quali implicano prestazioni differenti in termini di numero di elementi logici utilizzati e frequenza massima operativa. Ogni sintetizzatore è provvisto di parametri di configurazione per ottenere il giusto rapporto fra questi due fattori; è infatti facile intuire che l’ottimizzazione di un parametro va quasi sempre a scapito di un altro. Infine il numero di pin di I/O è fortemente determinato dal tipo di applicazione voluta.

Sarra Ivano VIII 19/02/2006 VIII

Ultima parte di analisi di una FPGA è inerente alla tensione di funzionamento. In particolare viene alimentata con 3.3Volt ed ha una dinamica di uscita variante tra 0 e 3.3Volt, (rispettivamente valore di segnale basso ed alto).

Sarra Ivano IX 19/02/2006 IX

Capitolo II Questo capitolo è destinato alla descrizione del lavoro. Saranno elencate le caratteristiche dei protocolli adottati e riportati i risultati ottenuti con la simulazione; a tal fine è stata necessaria l’implementazione di un testbench, ovvero di un programma in grado di verificare il funzionamento del circuito integrato una volta inserito nella scheda11. La logica implementata nell’FPGA può essere divisa nei seguenti blocchi: interfaccia con il Rabbit, interfaccia con il VME12. Tramite questi blocchi l’Altera connette le due unità, permettendo il trasferimento dei dati.

Schematizzazione Altera. Lo schema evidenzia il ruolo di interfaccia rivestito dall’FPGA. Quando il Rabbit chiede i dati da una scheda collegata al bus, l’Altera trasmette a questo la richiesta, riceve i dati, li memorizza in appositi registri e li trasmette al Rabbit.

2.1 Tipologie Di Temporizzazione La comunicazione tra le unità del bus segue un insieme di regole, protocollo, e due possibili processi di temporizzazione dei segnali: sincrono o asincrono.

• Sincrono La temporizzazione della comunicazione avviene tramite un segnale di clock, figura 2.1.

Figura 2.1: Protocollo sincrono. I dati sono trasmessi sul fronte di discesa del clock del bus.

11 Il codice Vhdl di programmazione e il testbench sono visionabili in appendice. 12 Entrambi i blocchi verranno descritti nel corso del capitolo.

Sarra Ivano X 19/02/2006 X

• Asincrono

La temporizzazione della comunicazione è gestita dal protocollo stesso tramite lo scambio di segnali appositi. L'avvento di sistemi più complessi ha portato a progetti basati sul principio del clock, un cristallo microelettronico che emette rapidi impulsi di elettricità che sincronizzano il flusso dei dati. Nei pc odierni, questo è il cuore del processore. Gli impulsi elettrici, muovendosi alla velocità della luce, non sono abbastanza veloci da mantenere il loro valore per il tempo necessario, senza errori, dal momento che visitano decine di milioni di transistor su un unico chip. La conseguenza è che cominciano ad avvenire errori nei dati. Il fenomeno è conosciuto come metastabilità. Quando l’ingresso dell’FF13 cambia vicino al fronte di clock, il circuito può entrare in uno stato metastabile: il segnale non ha valore logico determinato (ne 0 ne 1). Teoricamente c’è una probabilità piccola (ma non zero), che il FF resti in questo stato per un tempo infinito.

T ime

Logic 1

Logic 0

Traccia di un oscilloscopio che mostra la metastabilità ed il suo decadimento a 0 o ad 1. Al fine di evitare problemi di metastabilità i segnali di I/O dell’Altera passano attraverso una serie di registri di ritardo14. In questo modo prima che il valore di un segnale venga memorizzato nel registro con il quale si lavora, questo viene campionato su diversi cicli di clock.

Shift Register: Il nuovo valore per il primo stadio è pronto quando il secondo prende l’uscita dal primo. In questo modo si garantisce che lo stadio successivo memorizzi il vecchio valore prima che sia sostituito dal nuovo.

13 Flip-Flop. 14 Il codice con cui è stata implementata la rete di registri di ritardo è presente in appendice B.

Sarra Ivano XI 19/02/2006 XI

Due parametri fondamentali nell’analisi dell’interazione di un segnale con un registro di memoria, sono:

• Tsu Tempo di setup per i dati in ingresso al dispositivo. Affinché un segnale venga campionato correttamente, questo deve rimanere presente all’ingresso di un registro non meno di un determinato intervallo temporale, dipendente dal clock del dispositivo.

• Tco Tempo che intercorre tra il fronte del clock e la effettiva presenza del dato in uscita. È fissato dalla tecnologia usata . In un progetto Tsu e Tco devono dunque essere correlati al fin di garantire una corretta comunicazione tra le varie unità. I sistemi asincroni contano su un protocollo di conoscenza e trasmissione dei dati che non è regolato dal clock. Prima che i dati vengano scambiati deve esserci un accordo sul protocollo che sia reciprocamente accettabile. La comunicazione FPGA ↔ VME e Rabbit ↔ FPGA, è asincrona; la comunicazione è determinata tramite i segnali STROBE_IN e STROBE_OUT (entrambi segnali di controllo), il primo in uscita dal Rabbit, il secondo dall’Altera. La scelta di utilizzare un protocollo asincrono tra Rabbit e FPGA risolve anche le problematiche legate alle differenti velocità dei due integrati (il Rabbit è molto più lento dell’FPGA). L’Altera campiona le varie informazioni provenienti dal Rabbit secondo il proprio clock, ma solo quando lo stesso Rabbit (tramite lo strobe), l’abilita a farlo.

2.2 Macchina A Stati

Nella comunicazione Rabbit-Altera, il primo riveste il ruolo di Master, la seconda quello di Slave. In rispetto di ciò, la comunicazione tra i due circuiti integrati è asincrona e gestita dagli strobe; sarà sempre il Rabbit a fornire la funzione da svolgere. L’Altera è stata programmata tramite una macchina a stati, un dispositivo digitale che evolve secondo una determinata sequenza di stati. È realizzata in due sezioni, una che implementa logica combinatoria, l’altra che implementa quella sequenziale, dove sono presenti i registri che identificano in quale stato la macchina sia15. Il primo blocco, denominato anche "transition function", determina il successivo stato in cui la macchina deve evolvere; il secondo, noto come "function", genera le opportune uscite. Queste due operazioni si basano sul valore degli ingressi e dello stato presente; una rappresentazione della macchina a stati è rappresentata nel diagramma di flusso 2.2. Nel progetto di una macchina a stati è opportuno prendere delle precauzioni al fine di evitare un funzionamento improprio. È opportuno sia avere uno stato di partenza “IDLE” (nel nostro caso l’Altera è preimpostata in modalità READ_ADDR, ovvero aspetta istruzioni dal Rabbit), ed evitare che ci siano stati raggiungibili da cui non è possibile uscire. È quindi previsto l’inserimento di un reset asincrono che riporti la macchina allo stato IDLE.

15 Chiamati appunto registri di "stato".

Sarra Ivano XII 19/02/2006 XII

Figura 2.2: Macchina a stati. Prende in ingresso un segnale x a un bit, e quando riconosce la sequenza “1101” pone l’uscita y a “1.. Il diagramma è un grafico orientato i cui vertici sono gli stati che può assumere la macchina a stati e i rami rappresentano le transizioni tra gli stati. Nel caso del nostro esempio, possiamo dire che la macchina deve spostarsi in un nuovo stato ogni volta che riconosce un ingresso appartenente alla sequenza “1101”, mentre deve arretrare allo stato iniziale”IDLE” o ad uno stato intermedio (a seconda dei casi) se l’ingresso non appartiene alla sequenza data:A, B, C e D sono i simboli associati ai quattro stati che la macchina a stati può assumere, mentre le coppie x/y associate a ciascun ramo rappresentano il valore assunto dal bit di ingresso x e dal bit di uscita y in corrispondenza della transizione. Le macchine a stati trattate sono di tipo sincrono, cioè lo stato cambia in corrispondenza dei cicli di clock, e si calcola un nuovo stato ad ogni nuovo ciclo di clock.

Figura 2.3 : Cambiamento di stato. Ad ogni ciclo di clock la macchina aggiorna lo stato; la funzione di uscita può dipendere solo dallo stato presente (macchina di Moore), o sia dallo stato presente che dai valori di ingresso. Quando si usa una macchina a stati finiti come controllore, la funzione di uscita viene spesso limitata in modo da dipendere solo dallo stato presente: macchine a stati finiti di tale tipo sono dette macchine di Moore. Se la funzione di uscita dipendesse sia dallo stato presente che dall'ingresso corrente, si direbbe che la macchina è una macchina di Mealy; i due tipi di macchine hanno capacità equivalenti, e si possono convertire l'una nell'altra seguendo un procedimento del tutto meccanico. Il vantaggio fondamentale delle macchine di Moore è di essere più veloci, mentre le macchine di Mealy possono rivelarsi più piccole, poichè possono richiedere un numero di stati minore rispetto alle corrispondenti macchine di Moore.

2.3 Protocollo Rabbit-Altera Descriviamo ora il protocolo interno tra il Rabbit e l’Altera. Nel crearlo si è cercato di utilizzare il minor numero di pin di controllo possibile, per venire incontro all’esigenza di lasciarne a sufficienza, per la creazione di una seconda porta seriale per la comunicazione con l’utente. Infatti se l’elevato numero di pin I/O di una FPGA permette una notevole flessibilità di progetto, il Rabbit non presenta questa caratteristica.

Sarra Ivano XIII 19/02/2006 XIII

I pin in uscita dal Rabbit sono: • 16 per i dati; su questi verranno trasmessi sia i dati che gli indirizzi (indicati nel codice

sorgente con DAT_IN). • 2 di selezione; rappresentano quale parte del codice a 32bit il Rabbit, o l’Altera stiano

trasmettendo (indicati nel codice sorgente con SEL). • 2 di istruzione per l’Altera, indicati nel codice sorgente con READ e WRITE

(read,write) = (0,0) la macchina è in attesa che il Rabbit mandi gli indirizzi e gli eventuali dati da trasmettere. (read,write) = (1,0) la macchina va a leggere agli indirizzi trasmessi. (read,write) = (0,1) la macchina scrive agli indirizzi indicati, i dati trasmessi16.

• 1 strobe, indicato nel codice sorgente con STROBE_IN. I pin in uscita dall’Altera sono:

• 16 per la trasmissione dei dati richiesti, (indicati nel codice sorgente con DAT_OUT). • 2 per gli eventuali errori riscontrati nella comunicazione col bus, indicati nel codice sorgente

con ERR_IND (corrisponde a BERR*17) e ERR_GEN (corrisponde a RETRY*). • 1 strobe, indicato nel codice sorgente con STROBE_OUT.

Nel diagramma a stati 2.4 e 2.6 è rappresentata la comunicazione tra Rabbit e Altera in entrata ed in uscita18.

Figura2.4: Comunicazione con il Rabbit in entrata. La macchina aspetta che il Rabbit asserisca lo strobe, per iniziare a memorizzare la parte di indirizzo da questo inviata; questa viene quindi memorizzata in un apposito registro. La parte di 16bit, dei 32 di cui è composto il dato, viene pilotata dal segnale SEL: 00 prima parte del dato, 01 seconda parte del dato, 10 prima parte dell’indirizzo, 11 seconda parte dell’indirizzo. Il ciclo è iterato, tramite comunicazione tra i due strobe, fino a che la macchina non passa allo stato successivo (il Rabbit modifica la configurazione (read,write) = (0,0))19.

16 Non è stata implementata la funzione leggi e scrivi in quanto non richiesta. 17 L’utilizzo del segnale BERR* proprio del protocollo VME verrà chiarito nel prossimo capitolo. 18 Entrat ed uscita dall’Altera. 19 La forma d’onda ottenuta con Modelsim, il programma di simulazione adottato, è visionabile in appendice.

Sarra Ivano XIV 19/02/2006 XIV

Figura 2.5: Cambiamenti di stato nella macchina a stati. È il Rabbit a decidere lo stato in cui si trova l’Altera tramite la combinazione dei due segnali read,write. La macchina è preimpostata nello stato READ_ADDR, stato IDLE in cui aspetta istruzioni dal Rabbit ed è pronta a memorizzare l’indirizzo e gli eventuali dati da trasmette. Al variare della combinazione dei segnali read e write cambia lo stato: 1-0 stato di lettura da una determinata scheda nel crate, 0-1 stato di scrittura in una determinata scheda nel crate. La macchina aggiorna lo stato ad ogni ciclo di clock. Asserendo ilsegnale di reset la macchina ritorna autonomamente nello stato IDLE. Nel diagramma 2.6 è rappresentata la comunicazione tra il Rabbit e l’Altera in uscita; possiamo considerare questo come lo stato conclusivo del sistema di lettura. La comunicazione, asincrona, è strettamente dipendente dal clock del Rabbit20.

Figura 2.6: Comunicazione con il Rabbit in uscita. Una volta letti i dati dall’indirizzo richiesto, l’Altera tramite il suo strobe comunica al Rabbit che è pronta a trasmettere. Il Rabbit, tramite la combinazione SEL richiede quale delle due parti (da 16bit), in cui è stato scomposto il dato, l’Altera deve mandare: 00 prima parte del dato, 01 seconda parte del dato.

2.4 Protocollo Altera-VME

L’Altera ha nei confronti del bus una funzione di Master, schematizzabile come in figura 2.7. Il ruolo dei principali segnali è stato descritto nella sezione riguardante il VME. È interessante notare come tale schematizzazione metta in evidenza il carattere I/O di alcuni segnali.

20 La forma d’onda ottenuta con Modelsim è visionabile in appendice.

Sarra Ivano XV 19/02/2006 XV

Figura 2.7: Interfaccia con VME. Il Master gestisce la comunicazione con gli Slave nel crate seguendo il protocollo. La comunicazione tra l’Altera ed il bus avviene in modo asincrono; questa si differenzia a seconda del tipo di funzioni che il Rabbit chiede di svolgere. Quando il Rabbit, ultimato il trasferimento dell’indirizzo, pone la combinazione (read,write) = (1,0) la macchina entra nel ciclo di lettura dal bus secondo la seguente configurazione:

Sarra Ivano XVI 19/02/2006 XVI

Figura 2.8: Diagramma del ciclo di lettura. Schematizzazione del ciclo di lettura Master-Slave secondo lo standard VME-A32.

Sarra Ivano XVII 19/02/2006 XVII

Figura 2.9: Ciclo di lettura. Temporizzazione con cui i vari segnali variano il loro valore seguendo il protocollo. Quando il Rabbit pone la combinazione (read,write) = (0,1), la macchina entra nel ciclo di scrittura, caratterizzato dal valore low per il segnale WRITE*; i dati verranno posti dal Master sulle linee D*. La figura 2.10 rappresenta la temporizzazione con cui variano i segnali in questo ciclo.

Figura 2.10: Ciclo di scrittura. Il ruolo dei vari segnali segue lo schema del diagramma 2.6 con la sola eccezione di WRITE* (pilotato questa volta alto) e del fatto che i dati sono forniti dal Master (FPGA).

Sarra Ivano XVIII 19/02/2006 XVIII

Capitolo III

Risultati dell’implementazione In questo capitolo saranno elencati alcuni dei dati forniti dal software utilizzato per la creazione del codice binario con il quale abbiamo programmato l'Altera, Quartus II21. Analizzando questi dati si può concludere che il lavoro effettuato ha dato risultati più che soddisfacenti; nel dir ciò ci riferiamo agli standard di progetto inerenti a:

• Frequenza operativa • Utilizzo di elementi logici • Utilizzo di I/O

Timing analyzer:

Clock Setup 192.31 MHz Risorse utilzzate:

Celle logiche 263/4992(5%) Numero registri 12 I/O pins (utente) 120/147(81%)

Seguono le celle EAB dell’Altera utilizzate. Queste sono state realizzate da Quartus II22, al momento del debug finale del codice. Solo una minima parte degli elementi logici a disposizione è stata utilizzata.

21 In appendice sono presenti due rappresentazioni dell’circuito integrato realizzate da Quartus, mostranti la distribuzione delle celle logiche. 22 Programma con cui è stato convertito il codice VHDL nel codice binario, utilizzato per programmare il circuito integrato.

Sarra Ivano XIX 19/02/2006 XIX

Sarra Ivano XX 19/02/2006 XX

Sarra Ivano XXI 19/02/2006 XXI

Conclusioni Al fine di verificare l’efficienza del sistema è stato implementato un programma che simulasse il microcontrollore e il data bus. In appendice sono presenti le forme d’onda ottenute assegnando valori di prova ai segnali coinvolti nel trasferimento dati. Le analisi di timing ottenute con il software di sviluppo Quartus II sono in accordo con le richieste ed in particolare per i segnali di clock sono ammessi valori di frequenza maggiori di quelli richiesti. Valutate le potenzialità del sistema nel suo complesso, è previsto l’ampliamento del trasferimento dati da 32 a 64bit. Per quanto riguarda la parte circuitale la scheda è stata realizzata in modo da permettere tale implementazione. Nel complesso la programmazione di un circuito integrato FPGA comporta lo sviluppo di varie fasi di progetto parallele: da un lato bisogna stabilire un protocollo di comunicazione con il microcontrollore, facendo particolare attenzione alla determinazione del numero pin assegnabili ai singoli segnali e che il protocollo asincrono adottato non rallenti troppo la comunicazione; questo significa evitare le fasi di comunicazioni ridondanti utilizzando al meglio i segnali di controllo, che tuttavia non possono essere sovrabbondanti. Dall’altro lato c’è la comunicazione col bus, direttamente dipendente dalle specifiche del bus. La difficoltà maggiore sta nel relazionare le varie parti e districarsi tra il ruolo di Slave sostenuto con il microcontrollore e quello di Master adottato con il bus. Questa difficoltà è stata risolta con l’utilizzo di una macchina a stati di Moore, che ha reso molto più semplice la realizzazione del programma e lo stesso più leggibile.

Sarra Ivano XXII 19/02/2006 XXII

Appendice A • Simulazioni

Appendice 1:Il Rabit fornisce l’indirizzo e l’eventuale dato (a 32bit) all’Altera. Le varie parti da 16bit che il Rabbit manda, vengono memorizzate in appositi registri di memoria. Tutta la comunicazione è asincrona e gestita da due strobe (strobe_in, strobe_out). Il tempo rappresentato sull’ascissa è quello con cui i segnali variano nella simulazione; è quindi arbitrario e non rispecchia quello reale.

Sarra Ivano XXIII 19/02/2006 XXIII

Appendice 2:L’Altera manda al Rabbit il dato da 32bit letto dalla scheda nel crate. La temporizzazione rimane asincrona. Una volta letti i dati dall’indirizzo richiesto, l’Altera tramite il suo strobe comunica al Rabbit che è pronta a trasmettere. Il Rabbit, tramite la combinazione SEL richiede quale delle due parti (da 16bit), in cui è stato scomposto il dato, l’Altera deve mandare: 00 prima parte del dato, 01 seconda parte del dato.

Sarra Ivano XXIV 19/02/2006 XXIV

Appendice B • VHDL

Il VHDL è un linguaggio ad alto livello per la modellizzazione di circuiti elettronici. Un costrutto in VHDL è composto da due blocchi principali: una Entity, e una Architecture. Nella Entità vengono dichiarati gli ingressi e le uscite del blocco logico da rappresentare, l’architettura descrive il blocco logico, determinandone il funzionamento. La principale struttura contenuta all’interno di un architettura è il Process, formato da un insieme di istruzioni sequenziali. Un processo comunica con il resto del progetto leggendo o aggiornando determinati segnali o porte dell’entità dichiarate al di fuori di esso. Riportiamo di seguito alcuni esempi di elementi logici realizzati in VHDL ed utilizzati nel progetto23.

• Multiplexer Multiplexer: process (A,B,C,D,SEL) begin if (SEL(1) = ‘1’) then if (SEL(0) = ‘0’) then Z <= A; else Z <= B; end if; else if (SEL(0) = ‘0’) then Z <= C; else Z <= D; end if; end if; end process Multiplexer; Alternativamente si può utilizzare il costrutto case: Multiplexer: process (A,B,C,D,SEL) begin case SEL is when “00” => Z <= A; when “01” => Z <= B; when “10” => Z <= C; when “11” => Z <= D; end case; end process Multiplexer;

23 Per spiegazioni dettagliate sui costrutti e sul linguaggio VHDL consultare il manuale HDL Synthesis Guide[2].

Sarra Ivano XXV 19/02/2006 XXV

• Flip-Flop FF: process (clk) begin if (clk’event and clk = ‘1’) then Q <= D; end if; end process FF;

• Shift Register SHIFT_REG: process (reset,clk) begin if (reset = ‘0’) then SHIFT_REG <= (others => ‘0’); elsif (clk’event and clk = ‘1’) then SHIFT_REG <= dat_in; for I in 1 to 2 loop SHIFT_REG(I-1) <= SHIFT_REG (I); end for; end if; end process SHIFT_REG; new_dat_in <= SHIFT_REG(0);

Sarra Ivano XXVI 19/02/2006 XXVI

Nei costrutti precedenti I vari segnali sono stati dichiarati all’interno dell’architettura o sono vere e proprie porte (pin o insiemi di pin di I/O) dell’entità. entity nome_dell’entità is port (nome_porta: modo tipo_dato; // ; ) end [nome_dell’entità]; architecture nome_dell’architettura of nome_dell’entità is {dichiarazioni} begin [istruzioni concorrenti] end [nome_dell’architettura];

Sarra Ivano XXVII 19/02/2006 XXVII

Appendice C • Codice Sorgente

library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_signed.all; entity int_rabbit_vme is port(clk : in std_logic; rst : in std_logic; A_n : inout std_logic_vector(31 downto 1); D_n : inout std_logic_vector(31 downto 0); LWORD_n : inout std_logic ; BERR_n : in std_logic ; DTACK_n : in std_logic ; AM_n : out std_logic_vector( 5 downto 0); RETRY_n : in std_logic ; WRITE_n : out std_logic ; DS1_n : out std_logic ; DS0_n : out std_logic ; AS_n : out std_logic ; IACK_n : out std_logic ; -- comunicazione rabbit -- dat_in : in std_logic_vector(15 downto 0); sel : in std_logic_vector( 1 downto 0); dat_out : out std_logic_vector(15 downto 0); strobe_in : in std_logic ; strobe_out : out std_logic ; read : in std_logic ; -- leggi dal bus -- write : in std_logic ; -- scrivi nel bus -- err_ind : out std_logic err_gen : out std_logic ); end int_rabbit_vme; architecture interface of int_rabbit_vme is type STATE_TYPE is (READ_ADDR,RD_BUS,WR_BUS,WRITE_OUT,ZERO_RD,SEND_RD,RD_DATA_RD,FINE_RD,ZERO_WR,SEND_WR,RD_DATA_WR,FINE_WR); -- READ_ADDR(leggi dal rabbit), WRITE_OUT (manda al rabbit) -- signal PRESENT_STATE, next_state : STATE_TYPE; signal latch_dat1 : std_logic_vector(15 downto 0); signal latch_dat2 : std_logic_vector(15 downto 0); signal addr_1 : std_logic_vector(15 downto 0); signal addr_2 : std_logic_vector(15 downto 0); signal data : std_logic_vector(31 downto 0); signal FF : std_logic_vector(4 downto 0); signal strobe : std_logic;

Sarra Ivano XXVIII 19/02/2006 XXVIII

begin state: process(clk) begin --strobe <= FF(0); -- strobe <= strobe_in; case PRESENT_STATE is when READ_ADDR => -- STATO memorizza indirizzo -- err_ind <= '0'; -- serve per il processo errore -- err_gen <= '0'; -- // // -- strobe_out <= '0'; if (strobe='1') then -- demultiplexer: process (dat_in,sel) -- case sel is when "00" => latch_dat1 <= dat_in; when "01" => latch_dat2 <= dat_in; when "10" => addr_1 <= dat_in; when "11" => addr_2 <= dat_in; when others => addr_2 <= (others => '0'); end case; strobe_out <= '1'; end if; if (read='0') and (write='0') then next_state <= READ_ADDR; elsif (read='1') and (write='0') then next_state <= RD_BUS; elsif (read='0') and (write='1') then next_state <= WR_BUS; end if; when RD_BUS => -- STATO leggi dal bus -- next_state <= ZERO_RD; when ZERO_RD => WRITE_n <= '0'; IACK_n <= '0'; AS_n <= '1'; DS0_n <= '1'; DS1_n <= '1'; -- per evitare problemi metto sui pin l, indirizzo già nello stato ZERO -- LWORD_n <= addr_1(0); A_n(15 downto 1) <= addr_1(15 downto 1); A_n(31 downto 16) <= addr_2; AM_n <= (others => '0');

Sarra Ivano XXIX 19/02/2006 XXIX

next_state <= SEND_RD; when SEND_RD => -- mando l'indirizzo come indicato nel manuale, con A(31..1),LWORD*,AM(5..0) -- WRITE_n <= '1'; IACK_n <= '1'; AS_n <= '0'; DS0_n <= '0'; DS1_n <= '0'; if (DTACK_n='0') then next_state <= RD_DATA_RD; elsif (BERR_n='0') then err_ind <= '1'; strobe_out <= '1'; elsif (RETRY_n='0') then err_gen <= '1'; strobe_out <= '1'; end if; when RD_DATA_RD => -- prendo i dati a seconda della grandezza del bus -- data <= D_n; next_state <= FINE_RD; when FINE_RD => AS_n <= '1'; DS0_n <= '1'; DS1_n <= '1'; WRITE_n <= '0'; strobe_out <= '1'; next_state <= WRITE_OUT; when WR_BUS => -- STATO scrivi sul bus -- next_state <= ZERO_WR; when ZERO_WR => WRITE_n <= '1'; IACK_n <= '0'; AS_n <= '1'; DS0_n <= '1'; DS1_n <= '1'; -- per evitare problemi metto sui pin l,indirizzo già nello stato ZERO -- LWORD_n <= addr_1(0); D_n(15 downto 0) <= latch_dat1; D_n(31 downto 16) <= latch_dat2; A_n(15 downto 1) <= addr_1(15 downto 1); A_n(31 downto 16) <= addr_2; AM_n <= (others => '0'); next_state <= SEND_WR; when SEND_WR => -- mando l'indirizzo come indicato nel manuale, con A(31..1),LWORD*,AM(5..0) -- WRITE_n <= '0';

Sarra Ivano XXX 19/02/2006 XXX

IACK_n <= '1'; AS_n <= '0'; DS0_n <= '0'; DS1_n <= '0'; if (DTACK_n='0') then next_state <= RD_DATA_WR; elsif (BERR_n='0') then err_ind <= '1'; strobe_out <= '1'; elsif (RETRY_n='0') then err_gen <= '1'; strobe_out <= '1'; end if; when RD_DATA_WR => next_state <= FINE_WR; when FINE_WR => AS_n <= '1'; DS0_n <= '1'; DS1_n <= '1'; WRITE_n <= '1'; strobe_out <= '1'; when WRITE_OUT => -- STATO manda al rabbit -- strobe_out <= '0'; if (strobe='1') then case sel is when "00" => dat_out <= data(15 downto 0); when "01" => dat_out <= data(31 downto 16); when others => dat_out <= (others => '0'); end case; strobe_out <= '1'; end if; if (read='1') and (write='0') then next_state <= WRITE_OUT; end if; end case; end process state; cambia_stato: process (clk, rst) begin if (rst = '1') then PRESENT_STATE <= READ_ADDR; elsif (clk'event and clk = '1') then PRESENT_STATE <= next_state; end if; end process cambia_stato;

Sarra Ivano XXXI 19/02/2006 XXXI

--shift_reg: process(rst,clk) --variable I : integer; --begin -- if (rst='0') then -- FF <= (others=>'0'); -- elsif (clk'event and clk='1') then -- FF(4) <= strobe_in; -- for I in 1 to 4 loop -- FF(I-1) <= FF(I); -- end loop; -- end if; --end process shift_reg; end interface;

• Testbench library IEEE; use IEEE.std_logic_1164.all; use IEEE.std_logic_arith.all; entity testbench is end testbench; architecture rtl of testbench is component int_rabbit_vme Port (clk : in std_logic; rst : in std_logic; A_n : inout std_logic_vector(31 downto 1); D_n : inout std_logic_vector(31 downto 0); LWORD_n : inout std_logic ; BERR_n : in std_logic ; DTACK_n : in std_logic ; AM_n : out std_logic_vector( 5 downto 0); RETRY_n : in std_logic ; WRITE_n : out std_logic ; DS1_n : out std_logic ; DS0_n : out std_logic ; AS_n : out std_logic ; IACK_n : out std_logic ; -- comunicazione rabbit -- dat_in : in std_logic_vector(15 downto 0); sel : in std_logic_vector( 1 downto 0); dat_out : out std_logic_vector(15 downto 0); strobe_in : in std_logic ; strobe_out : out std_logic ; read : in std_logic ; -- leggi dal bus --

Sarra Ivano XXXII 19/02/2006 XXXII

write : in std_logic ; -- scrivi nel bus -- err_ind : out std_logic ; -- pin che dice che c'è un errore dal bus (rabbit blocca tutto) -- err_gen : out std_logic ); -- errore slave occupato RETRY(dal bus) -- end component; signal clk : std_logic:='1'; signal rst : std_logic:='1'; signal LWORD_n: std_logic; signal BERR_n: std_logic; signal DTACK_n: std_logic; signal RETRY_n: std_logic; signal WRITE_n: std_logic; signal DS1_n: std_logic; signal DS0_n: std_logic; signal AS_n: std_logic; signal IACK_n: std_logic; signal strobe_in : std_logic; signal strobe_out: std_logic; signal read: std_logic; signal write: std_logic; signal err_ind: std_logic; signal err_gen: std_logic; signal A_n: std_logic_vector(31 downto 1); signal D_n: std_logic_vector(31 downto 0); signal AM_n: std_logic_vector( 5 downto 0); signal dat_in: std_logic_vector(15 downto 0); signal sel: std_logic_vector( 1 downto 0); signal dat_out: std_logic_vector(15 downto 0); type state_test_a is (inizio, primo, secondo, terzo, leggi_indirizzo, leggi_dal_bus, leggi); signal stato : state_test_a; begin UUT : int_rabbit_vme -- unità sotto test -- port map (clk, rst, A_n, D_n, LWORD_n, BERR_n, DTACK_n, AM_n, RETRY_n, WRITE_n, DS1_n, DS0_n, AS_n, IACK_n, dat_in, sel, dat_out, strobe_in, strobe_out, read, write, err_ind, err_gen); reset: process(rst) variable muta: std_logic:='0'; begin if (muta = '0') then rst <= '0' after 1 ns; muta:='1'; end if; end process reset; clock: process(clk)

Sarra Ivano XXXIII 19/02/2006 XXXIII

begin clk <= not clk after 1.33 ns; end process clock; stimoli: process begin strobe_in <= '0'; wait for 50 ns; stato <= inizio; read <= '0'; write <= '0'; dat_in <= "1111111100000000"; sel <= "00"; wait for 100 ns; -- il rabbit fa le sue operazioni strobe_in <= '1'; wait until (strobe_out = '1'); wait for 10 ns; strobe_in <= '0'; stato <= primo; read <= '0'; write <= '0'; dat_in <= "0000000011111111"; sel <= "01"; wait for 100 ns; -- il rabbit fa le sue operazioni strobe_in <= '1'; --wait for 10 ns; --se metto questo se impalla tutto-- wait until (strobe_out'event) and (strobe_out='1'); wait for 10 ns; strobe_in<= '0'; stato <= secondo; read <= '0'; write <= '0'; dat_in <= "1111111100000000"; sel <= "10"; wait for 100 ns; -- il rabbit fa le sue operazioni strobe_in <= '1'; wait until (strobe_out = '1'); wait for 10 ns; strobe_in <= '0'; stato <= terzo; read <= '0'; write <= '0'; dat_in <= "0000000011111111"; sel <= "11"; wait for 100 ns; -- il rabbit fa le sue operazioni strobe_in <= '1';

Sarra Ivano XXXIV 19/02/2006 XXXIV

wait until (strobe_out = '1'); wait for 10 ns; strobe_in <= '0'; -- ciclo lettura -- wait for 50 ns; stato <= leggi_indirizzo; read <= '1'; write <= '0'; wait for 100 ns; -- il rabbit fa le sue operazioni strobe_in <= '1'; stato <= leggi_dal_bus; D_n <= (others => '0'); wait for 50 ns; stato <= leggi; DTACK_n <= '0'; wait until (strobe_out = '1'); wait for 10 ns; strobe_in <= '0'; read <= '1'; write <= '0'; sel <= "00"; wait for 100 ns; -- il rabbit fa le sue operazioni strobe_in <= '1'; wait until (strobe_out = '1'); wait for 10 ns; strobe_in <= '0'; read <= '1'; write <= '0'; sel <= "01"; wait for 100 ns; -- il rabbit fa le sue operazioni strobe_in <= '1'; end process stimoli; end rtl; configuration cfg_tb_test of testbench is for rtl for UUT: int_rabbit_vme end for; end for; end cfg_tb_test;

Sarra Ivano XXXV 19/02/2006 XXXV

Glossario A32: standard VME che utillizza trasferimento dati a 32 bit. Ciclo di lettura: l’FPGA richiede i dati da una scheda collegata al bus. Ciclo di scrittura: l’FPGA scrive i dati su una scheda collegata al bus. Clock: segnale che determina il tempo di campionamento di un circuito integrato. Può essere considerato l’orologio interno del sistema. FPGA: Field Programmable Gate Array. Circuito integrato riprogrammabile utilizzato come tramite per la comunicazione tra microcontrollore e bus. Macchina a stati: dispositivo digitale che evolve secondo una determinata sequenza di stati. Macchina a stati di Mealy: la funzione di uscita della macchina dipende sia dallo stato presente che dall'ingresso corrente. Macchina a stati di Moore: la funzione di uscita della macchina dipende solo dallo stato presente. Master: ruolo rivestito nella comunicazione tra due unità di una scheda, da una di queste. Il Master stabilisce le funzioni che lo Slave deve svolgere. Metastabilità: fenomeno a causa del quale il valore di un segnale non viene interpretato correttamente dal circuito integrato. Modelsim: programma di compilazione e simulazione adottato per la programmazione dell’FPGA. Protocollo: insieme di regole che stabiliscono la comunicazione tra le varie unità di un sistema. Protocollo Asincrono: la temporizzazione della comunicazione è gestita dal protocollo stesso tramite lo scambio di segnali appositi. Protocollo Sincrono: la temporizzazione della comunicazione avviene tramite un segnale di clock. Rabbit: Microcontrollore adottato nella scheda. Sovrintende alle funzioni di lettura e scrittura. Slave: ruolo rivestito nella comunicazione tra due unità di una scheda, da una di queste. Lo Slave svolge le funzioni stabilite da Master. Stato IDLE: stato “zero” di una macchina a stati. In questo stato la macchina è in attesa di istruzioni. Strobe: segnali utilizzati dagli utenti per asserire che un’operazione è stata svolta. Testbench: programma in grado di verificare il funzionamento del circuito integrato una volta inserito nella scheda.

VHDL: acronimo di Very high speed integrated circuits Hardware Description Language. Linguaggio di programmazione di alto livello. VME: Versa Module Europa. Bus data dotato di diversi standard per la trasmissione dei dati.

Bibliografia Manuali [1] D. Peterson. The VMEbus Handbook Fourth Edition. Vita. [2] Jayaram Bhasker. Verilog HDL Synthesis. Star Galaxy Publishing. 2002. [3] Catello Antonio De Rosa. Fondamenti del linguaggio VHDL. Libreria Clup. 2004. Articoli in rete

• Alessandro Fin. Laboratorio di Sistemi per la Progettazione Automatica. Dipartimento di Informatica Università di Verona.

• Casola Valentina. Lezione 8 corso ACE 2004/05.

• Data sheet Altera ACEX 1K.

• Catello Antonio De Rosa. Logiche Programmabili Anno 2000. Articolo pubblicato su

Elettronica Oggi (Novembre 2000).

• Randy H. Katz. Contemporary Logic Design. University of California, Berkeley. 1993.