progettazione di una scheda di controllo per bus vme...

UNIVERSITA DEGLI STUDI DI ROMA“TOR VERGATA”

Facolta di Scienze Matematiche, Fisiche e Naturali

Corso di Laurea Triennale in Fisica

Tesi di Laurea

Progettazione di una scheda di controlloper bus VME

Programmazione del microprocessore Rabbit 3000

Relatore: Laureando:Prof. ROBERTO MESSI FRANCESCO GONNELLA

ANNO ACCADEMICO 2004-2005

Introduzione

Il nostro progetto consiste nella realizzazione di una scheda VME1, che permet-ta di accedere alle schede installate nel rack, tramite un qualsiasi dispositivodotato di connessione Ethernet. Il bus VME e uno dei piu utilizzati sia a li-vello industriale, sia nei laboratori di ricerca. Esso consiste in un rack in cuisi possono installare i piu svariati tipi di schede, come ad esempio schede dimemoria, di acquisizione o di controllo. Tali schede, grazie al bus VME, sonoin grado di comunicare tra loro.L’accesso alle schede installate nel bus da parte dell’utente, e di solito garantitoda una scheda di controllo che contiene un intero calcolatore al quale vengonoconnesse le principali periferiche (monitor, tastiera, mouse, etc.). Queste par-ticolari schede consentono la gestione dell’intero rack.Tali schede sono pero molto piu potenti e costose del necessario, in realta sa-rebbe sufficiente una scheda capace di connettersi (via porta seriale, Ethernet,USB, o IRDA) ad un computer esterno.Tra le varie tecnologie di comunicazione, Ethernet e sicuramente la piu effi-ciente, in quanto consente di collegare il rack VME ad una LAN e quindi digestire tutte le schede installate in remoto.

1Acronimo di Versa Module Europa

iii

iv Introduzione

Indice

Introduzione iii

Indice v

1 Il progetto 11.1 Descrizione della scheda . . . . . . . . . . . . . . . . . . . . . . 21.2 Progettazione e realizzazione della scheda . . . . . . . . . . . . . 3

2 Setup sperimentale 52.1 Storia e specifiche del VME . . . . . . . . . . . . . . . . . . . . 62.2 Rabbit 3000 e Modulo RCM3200 . . . . . . . . . . . . . . . . . 6

2.2.1 Caratteristiche tecniche del Rabbit 3000 . . . . . . . . . 62.2.2 Caratteristiche tecniche del modulo RCM3200 . . . . . . 72.2.3 Scelta della configurazione di pinout ottimale per l’in-

terfaccia con l’FPGA . . . . . . . . . . . . . . . . . . . . 8

3 La programmazione del microprocessore Rabbit 113.1 Protocollo Client ←→ Rabbit . . . . . . . . . . . . . . . . . . . 123.2 Protocollo Rabbit ←→ FPGA . . . . . . . . . . . . . . . . . . . 13

3.2.1 Macchina a stati . . . . . . . . . . . . . . . . . . . . . . 143.3 Struttura del programma . . . . . . . . . . . . . . . . . . . . . . 173.4 Debug . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183.5 Programma di interfaccia utente . . . . . . . . . . . . . . . . . . 20

4 Codice sorgente 214.1 Caratteristiche generali del Dynamic C . . . . . . . . . . . . . . 224.2 Variabili globali . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

4.2.1 Variabile: STATE . . . . . . . . . . . . . . . . . . . . . . 224.2.2 Variabile: ADDRESS . . . . . . . . . . . . . . . . . . . . 234.2.3 Variabile: DATA . . . . . . . . . . . . . . . . . . . . . . 234.2.4 Variabili per la comunicazione TCP-IP . . . . . . . . . . 24

v

vi INDICE

4.3 Funzioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254.3.1 Funzioni di comunicazione TCP-IP . . . . . . . . . . . . 254.3.2 Funzioni di comunicazione: Rabbit ←→ FPGA . . . . . 254.3.3 Funzioni di controllo: Rabbit ←→ FPGA . . . . . . . . . 264.3.4 Funzioni interne . . . . . . . . . . . . . . . . . . . . . . . 28

5 Conclusioni 31

A Codice del programma 33

Capitolo 1

Il progetto

1

2 Il progetto

1.1 Descrizione della scheda

La scheda da noi progettata ha il compito di interfacciare il rack VME con unutente esterno munito di un dispositivo dotato di connessione Ethernet, comead esempio un computer portatile.La comunicazione via Ethernet e svolta mediante TCP-IP, un protocollo dialto livello, mentre il bus VME lavora con un protocollo di basso livello conesigenze tempistiche altamente complesse.Da questo problema nasce l’esigenza di avere due unita distinte e radicalmentediverse:

• un microprocessore ad alto livello, in grado di gestire la comunicazioneTCP-IP;

• un’unita a logica programmabile, in grado di supportare le alte velocitarichieste dal bus VME.

Client

RCM3200

Ethernet

Scheda collegataal bus VME



FPGA

Figura 1.1: Diagramma a blocchi della scheda

Come mostrato in figura 1.1, la scheda da noi progettata e composta da duecircuiti integrati: un FPGA1 ed un microprocessore Rabbit 30002.

1Acronimo di Field Programmable Gate Array.Per la precisione l’FPGA da noi utilizzato e un Altera Acex EP1K100QC208-1

2Per i dettagli vedere il paragrafo 2.2.

1.2 Progettazione e realizzazione della scheda 3

Il primo svolge la funzione di interfaccia con il bus, mentre il secondo quelladi comunicazione con l’utente.Come si vede dallo schema in figura 1.1, il Rabbit svolge sia la funzione dimaster (in quanto e lui che ordina di eseguire le istruzioni all’FPGA, lo slave),sia il ruolo di server nei confronti del client ad esso connesso via Ethernet.Il processo di comunicazione espresso in maniera molto semplice e il seguente:

• l’utente, tramite un programma sul suo computer (il client), richiededi effettuare una certa operazione (di lettura o scrittura) su un certoindirizzo del bus VME;

• a questo punto, l’informazione passa, via Ethernet, al Rabbit che latraduce e la comunica all’FPGI;

• quest’ultimo comunica tramite il protocollo VME, con le schede presentinel rack, ed effettua l’operazione richiesta;

• dopodiche fornisce i risultati (ad esempio il valore del dato letto) alRabbit;

• in fine, il Rabbit li traduce nuovamente e li comunica, sempre via Ether-net, all’utente, ignaro di tutto.

Sono stati, dunque, ideati e realizzati 2 protocolli di comunicazione: unotra le due unita ed uno tra il Rabbit ed il client. Tali protocolli, di naturamolto diversa, sono analizzati in dettaglio rispettivamente nelle sezioni 3.2 e3.1.

1.2 Progettazione e realizzazione della scheda

La progettazione e la realizzazione di una scheda come la nostra, in cui sonopresenti piu circuiti integrati puo essere divisa nelle seguenti fasi:

1. Programmare i circuiti integrati.

2. Simulare il funzionamento del circuito integrato sottoponendolo a deter-minati segnali di prova e verificando che risponda nel modo voluto.

3. Realizzare la scheda, dove vengono inseriti i circuiti integrati, e verificar-ne il funzionamento all’interno del bus.

In figura 1.2, si puo vedere lo schema elettrico della scheda. A destra si pos-sono notare in alto i due connettori a 34 pin per il Modulo del Rabbit 3000,

4 Il progetto

Figura 1.2: Progetto della scheda

mentre in basso si nota lo slot per l’inserimento dell’FPGA.Mentre per i test dell’FPGA sono stati utilizzati dei simulatori al computer,per il Rabbit cio non e stato possibile.I test sul Rabbit sono stati eseguiti tramite la costruzione di un apposito cir-cuito che ha permesso, tramite LED e interruttori, di verificarne il correttofunzionamento3.Tali test, tuttavia, sono parziali e ci riserviamo di eseguirne degli altri nonappena il microprocessore sara montato sulla scheda ultimata.

3Vedi paragrafo 3.4 per un’analisi approfondita dei test eseguiti.

Capitolo 2

Setup sperimentale

5

6 Setup sperimentale

2.1 Storia e specifiche del VME

Lo standard VME nasce nel 1987 ed e ad oggi uno dei piu diffusi tra i busindustriali. A seconda del numero di bit utilizzato per i dati e gli indirizzi, lostandard VME permette diversi tipi di trasferimento che si differenziano tra diloro per la larghezza delle parole trasferite. La scheda e stata progettata perl’utilizzazione dello standard VME A32 (con parole e indirizzi a 32 bit). Tut-tavia viste le grandi potenzialita dell’hardware utilizzato per la realizzazionedella scheda, il progetto e stato implementato in modo da poter supportare,con qualche modifica, anche il protocollo VME64x che utilizza indirizzi e pa-role a 64 bit. Tale possibilita di ampliamento delle funzionalita della schedasara discusso nel capitolo 5.

2.2 Rabbit 3000 e Modulo RCM3200

Il Rabbit 3000, distribuito dalla Rabbit Semiconductor, e un moderno micro-processore a 8 bit.

Esso e l’elemento centrale di un completo sistema di progettazione che in-

Figura 2.1: Modulo RCM3200 e Rabbit 3000.

clude strumenti di sviluppo come un linguaggio di programmazione specifico(il Dynamic C1) e un modulo che contiene oltre al microprocessore, memoriaflash, RAM statica, porte di I/O digitali e sopratutto, una porta Ethernet.Le caratteristiche tecniche specifiche del microprocessore e del modulo RCM3200,usato per la realizzazione del nostro progetto, saranno esaminate nei prossimiparagrafi.

2.2.1 Caratteristiche tecniche del Rabbit 3000

Il Rabbit 3000 e distribuito con package LQFP a 128 pin o TFBGA sempre a128 pin.

1Per ulteriori informazioni sul Dynamic C vedere il paragrafo 4.1.

2.2 Rabbit 3000 e Modulo RCM3200 7

La massima velocita di clock e di 54 MHz con una temperatura compresa trai -40◦C e i +70◦C e alimentazione a 3.3 V ± 5%.Nella figura 2.2, e illustrato il diagramma a blocchi del Rabbit 3000.

��

��

��

��

��

��

��

��

��

��

��

��

��

��

�� !��"�#�$��% ��

��&��

'��

'��

(��)'��%

*+,-./%01��%��

2��'��

��

��&��

��

��

��

��

�

��

��

��

�

��

�

��

��

�

��

��

�

�

��

��

��

�

�

��

��

3/ ��4

��

��

��

��

��

��

��

��

��

��

��

� ��

��

��

��

��

� ��

�

�

��

��

��

3/ ��4

��

��

�

��

�!��

��"��

"��"��

��

"��

"��

��"��

"��5�5

��"��

��"��

"��"��

"��5�

��"��

��"��

0 6�" 6�

0 6��" 6��

��

"��#��"��#��

� �� "��

��

��

��#��

"��"��

��% ��

��2��

7��

$ �� $ ��$ �� $ ��$ �� $ ��$ �� $ ��

��

�� # � �� # � �� # � ��!�� # � ��

� ��

Figura 2.2: Diagramma a blocchi del microprocessore Rabbit 3000.

2.2.2 Caratteristiche tecniche del modulo RCM3200

Il microprocessore Rabbit 3000, da noi utilizzato per la realizzazione del pro-getto, fa parte di un modulo RCM3200.


Il modulo RCM3200 RabbitCore e equipaggiato, oltre che con il microproces-sore, con una porta Ethernet 10/100Base-T, 512 KByte di memoria flash, 256KByte di memoria dati SRAM battery-backed e 512 KByte di memoria SRAMdi esecuzione.L’RCM3200 e dotato di due connettori a 34 pin, per un totale di 68. Tali pincorrispondono solamente ad alcuni dei 128 pin del microprocessore, mentre irimanenti sono collegati all’elettronica montata sul modulo.Il pinout dell’RCM3200 e rappresentato nella figura che segue:

��

��

��

��

�� !��! �!��!�"�#��

�� !��!��!�

�!"�#��

��

��$%$�&'$�&��(�'()

Figura 2.3: Pinout dei due connettori a 34 pin del modulo RCM3200

Le funzioni dei 68 pin dell’RCM3200 possono essere configurate a tempo diesecuzione tramite alcuni speciali registri del microprocessore detti FunctionRegisters o FR2.La problematica della configurazione dei pin sara analizzata nel paragrafoseguente.

2.2.3 Scelta della configurazione di pinout ottimale perl’interfaccia con l’FPGA

I pin in uscita del Rabbit, o meglio dell’RCM3200, schematizzati in figura 2.3,sono organizzati in 7 porte parallele a 8 bit con diverse funzioni e potenzialita.Tali porte sono indicate con le lettere A, B, C, D, E, F, e G; mentre i pin sonoindicati con un numero che va da 0 a 7. Come si vede in figura, pero, non tuttii pin delle porte del Rabbit sono presenti effettivamente nel pinout del modu-lo: mancano, ad esempio, il PC6 e il PC7, mentre il PE2 non e presente in

2Per maggiori informazioni sulla configurazione dei FR consultare la funzione RabbitInit()al paragrafo 4.3.4 o il codice del programma nell’appendice A.

2.2 Rabbit 3000 e Modulo RCM3200 9

quanto utilizzato per la porta Ethernet presente sul modulo. E stato, dunque,necessario riorganizzare i pin in 4 nuove porte che presentassero le funziona-lita da noi richieste: una porta di comunicazione dati dall’FPGA al Rabbit,una porta di comunicazione dati dal Rabbit all’FPGA, una porta di controllodal Rabbit all’FPGA e una per la comunicazione delle risposte dall’FPGA alRabbit (come, ad esempio, errori del bus VME).Per quanto riguarda le due porte di comunicazione dati, si e cercato di mas-simizzare il numero dei pin, per aumentare le prestazioni della comunicazionedal punto di vista delle tempistiche. Si e dunque scelto di utilizzare 16 pin perporta.Per quanto riguarda le due porte di controllo invece, non e stato necessarioimpiegare molti pin, grazie al numero contenuto di comandi e di risposte pos-sibili.Dunque le porte da noi create sono:

1. DataIn: porta di input dati a 16 bit;

2. DataOut: porta di output dati a 16 bit;

3. CtrlIn: porta di controllo in ingresso a 3 bit;

4. CtrlOut: porta di controllo in uscita a 5 bit.

Sulla porta CtrlOut, si e lasciato ampio margine di miglioramento del program-ma; in quanto i 5 bit garantiscono ben 25 = 32 possibilita d’implementazionedi nuovi comandi. Per la porta CtrlIn, invece si e lasciato meno margine inquanto le risposte che l’FPGI (cioe il bus VME) puo fornire sono limitate.Nella figura 2.4, oltre alle porte citate, sono riportate anche due porte seriali.

PF0PF1PF2PF3PF4PF5PF6PF7PG0PG1PG2PG3PG4PG5PG6PG7 MSB

LSB

Data InPA0PA1PA2PA3PA4PA5PA6PA7PB0PD4PB2PB3PB4PB5PB6PB7 MSB

LSB

Data Out

MSB

PE0

PE1PE4PC7

LSB

Ctrl InStrobe(o INT0A)

MSB

PD5

PC4PE5PE6PE7

LSB

Ctrl OutStrobe

PC0

PC1

Trasmissione

Serial 1

Ricezione

PC2

PC3

Trasmissione

Serial 2

Ricezione

Figura 2.4: Configurazione di pinout ottimale.


Il Rabbit, infatti, sopporta funzioni gia implementate per la gestione della co-municazione seriale. Ci e sembrato d’uopo, dunque, lasciare disponibili i pinper un futuro miglioramento.Nella realizzazione delle porte, si e cercato il piu possibile di utilizzare portecomplete del microprocessore, purtroppo alcune sono state costruite prenden-do bit di diverse porte del Rabbit. Inoltre e stato scelto di inserire il PE0come segnale di strobe in ingresso, in quanto su questo pin puo essere abi-litata la funzionalita di interrupt esterno, per la quale il programma e statopredisposto3.

3Per maggiori informazioni sulla predisposizione del programma alla funzionalita diinterrupt, consultare la funzione IntOnOff() al paragrafo 4.3.4.

Capitolo 3

La programmazione delmicroprocessore Rabbit

11

12 La programmazione del microprocessore Rabbit

3.1 Protocollo Client ←→ Rabbit

In questa sezione analizzeremo il protocollo ideato per la comunicazione traClient e Rabbit.Come abbiamo gia visto in precedenza, la comunicazione e svolta tramite con-nessione Ethernet e, nella fattispecie, tramite protocollo TCP-IP.Il protocollo TCP-IP e un protocollo di alto livello, tramite il quale due mac-chine possono inviarsi a vicenda stringhe di caratteri a 8 bit. Il protocollo danoi realizzato non e altro che un insieme di regole che caratterizzano le stringhetramite le quali il Client ed il Rabbit si scambiano informazioni.Dato che, come abbiamo visto nel capitolo 2, i dati e gli indirizzi sono a 32 bit,abbiamo bisogno di 4 caratteri dal Rabbit verso il Client, e di 8 caratteri (64bit: 32 bit di dati e 32 di indirizzo) dal Client verso il Rabbit; vediamo meglioil perche.I comandi che il Client puo inviare al Rabbit sono 2: Read (lettura) e Write(scrittura).Nel caso di lettura, il Client deve inviare semplicemente il comando Read (1carattere) e l’indirizzo su cui leggere (32 bit, 4 caratteri), per un totale di 5caratteri.Nel caso di scrittura, invece, il Client deve inviare, oltre al comando Write(1 carattere), sia l’indirizzo su cui scrivere (32 bit, 4 caratteri), sia il dato dascrivere (32 bit, 4 caratteri), per un totale di 9 caratteri.1

I caratteri sono ordinati come in figura 3.1. Se e il Client ad inviare la stringa

1 2 3 4 5 6 7 8 9

indirizzo dati

comando o risposta

Figura 3.1: Schema del protocollo Client ←→ Rabbit.

allora il primo carattere e il comando, i caratteri da 2 a 5 l’indirizzo e gli ultimi4 caratteri, il dato da scrivere (se necessario). Quando e il Rabbit a rispondere,invece: il primo carattere e la risposta e i caratteri da 2 a 5 il dato letto.Dunque il primo carattere della stringa puo avere valenza di comando quandoe inviato dal Client o di risposta quando e inviato dal Rabbit.I valori che questo carattere puo assumere, dunque sono: Comando:

1Per lo standard VME64x la lunghezza di tali stringhe deve essere raddoppiata.

3.2 Protocollo Rabbit ←→ FPGA 13

• ’w’ per Write, seguito dall’indirizzo e dal dato;

• ’r’ per Read, seguito dall’indirizzo.

Risposta:

• ’r’ nel caso in cui il comando Read sia stato eseguito, seguito dal datoletto;

• ’w’ nel caso in cui il comando Write sia stato eseguito;

• ’B’ (Bus Error) nel caso in cui si sia riscontrato un errore nell’indirizzoo nel dato inviato al bus VME;

• ’R’ (Retry) nel caso in cui il bus VME fosse occupato e richiedesse diriprovare in un secondo momento.

Per maggiori informazioni sul protocollo Client ←→ Rabbit, consultare i pa-ragrafi 4.2.4 e 4.2.4.

3.2 Protocollo Rabbit ←→ FPGA

In questa sezione, analizzeremo il protocollo ideato per la comunicazione traRabbit e FPGA.Questo protocollo e di natura completamente diversa da quello precedentemen-te analizzato. L’FPGA ed il Rabbit, infatti, non si scambiano stringhe comenel caso del TCP-IP, bensı sono semplicemente collegati tramite pin comuni.Ogni pin puo assumere valore 0 o 1 (a seconda che la tensione su quel pin sia3.3V o 0V) e, tramite una combinazione di questi valori, i due oggetti devonodarsi comandi e scambiarsi informazioni. Dunque e necessario assegnare adogni pin una funzione specifica, ovvero creare delle porte di comunicazione.Le porte da noi create, sono state analizzate in dettaglio nella sezione 2.2.3 erappresentate in figura 2.4.Il piu importante tra i pin e quello dedicato a dare il segnale di inizio allacomunicazione, tale pin e detto ”strobe”.Chiaramente, vi sono due pin di strobe, uno in uscita ed uno in ingresso2.In poche parole, quando il Rabbit ”sente” che lo strobe in ingresso si alza (cioeassume valore 1), abilita la lettura del comando che si aspetta sia arrivato dal-l’FPGA. Quando invece il Rabbit ha inviato un’informazione all’FPGA, alzalo strobe in uscita, e dunque dice all’FPGA che l’informazione e pronta peressere letta; uno stratagemma analogo alla paletta che il postino americano

2Quando parliamo di uscita e di ingresso ci riferiamo al Rabbit.


alza dopo aver consegnato la posta.Gli altri pin sono divisi due porte di controllo e due di comunicazione dati.Le 2 porte di controllo (una d’ingresso e una d’uscita) sono utilizzate per l’in-vio di comandi e di risposte (in modo analogo al primo carattere della stringadel protocollo Client ←→ Rabbit).Le operazioni che il Rabbit puo eseguire interagendo con l’FPGA sono 3:

1. ”Comunico indirizzo”;

2. ”Leggi dato”;

3. ”Scrivi dato”.

La prima e utilizzata per comunicare un indirizzo del bus VME dal Rabbitall’FPGA.La seconda per ordinare all’FPGA di leggere il dato che si trova all’indirizzocomunicato.La terza, infine, per comunicare all’FPGA un dato e per ordinargli di scriverloall’indirizzo del bus VME comunicato in precedenza.In altre parole, il Rabbit, comunica dapprima un indirizzo all’FPGA, che lomemorizza. Nel fare questo, non specifica se l’indirizzo sara usato per leggereun dato o per scrivere. A questo punto, il Rabbit puo fare due cose: ordinareall’FPGA di leggere il dato scritto sull’indirizzo che l’FPGA ha in memoria,oppure comunicargli un dato e, allo stesso tempo, ordinargli di scriverlo, sem-pre sull’indirizzo precedentemente memorizzato.Per realizzare tutto questo, e stato necessario implementare un apposito pro-gramma, che eseguisse in sequenza queste operazioni; un programma di questotipo e detto Macchina a Stati o State Machine.

3.2.1 Macchina a stati

Una Macchina a Stati non e altro che un programma dotato di una specialevariabile3 che indica lo stato in cui la macchina si trova. A seconda dello stato,la macchina esegue operazioni diverse.La nostra Macchina a Stati, e dotata di 4 stati4:

3Questa variabile e trattata approfonditamente nel paragrafo 4.2.1.4In realta gli stati sono molti di piu, in quanto per la comunicazione tra Rabbit ed FPGA

e stata usata una porta di soli 16 bit, come gia visto nel capitolo 2. Dunque e stato necessario”spezzare” gli stati di comunicazione indirizzo, scrittura e lettura in 2 parti, una per primi16 bit e una per i secondi. Il concetto e comunque molto simile: infatti basta supporredi ripetere piu volte lo stesso processo. In questa sede, dunque, per motivi di leggibilitae chiarezza, illustreremo la macchina a stati trascurando questo fatto. Il programma ecomunque trattato dettagliatamente nel capitolo 4.

3.2 Protocollo Rabbit ←→ FPGA 15

1. Idle;

2. ”Comunicazione indirizzo”;

3. ”Leggi dato”;

4. ”Scrivi dato”.

Il primo e lo stato in cui la macchina si trova quando non deve eseguire nessunaoperazione, in altre parole aspetta di essere messa in un altro stato.I rimanenti tre sono quelli analoghi alle operazioni di cui sopra.I diagrammi di flusso dei tre stati sono riportati in figura 3.2 e 3.3. Nei dia-

Stato: Comunicazione indirizzo

Scrive l'indirizzo su DataOut

Scrive il comando "comunico indirizzo"

su CtrlOut

Alza lo StrobeOut

Lo StrobeInè alto?

No

Sì

Abbassa lo StrobeOut

Legge la risposta dell'FPGA su CtrlIn

C'è un errore?

No

Sì

Comunica l'errore al CLIENT

Passa a stato: idle

Fine

Stato: Leggi dati

Scrive il comando "leggi dato" su

CtrlOut

Alza lo StrobeOut

Lo StrobeInè alto?

No

Sì



C'è un errore?

No

Sì


Passa a stato: idle

Fine

Legge il dato da DataIn

Figura 3.2: Diagramma di flusso degli stati di comunicazione indirizzo e letturadati.


grammi e da notare che, in ogni operazione di comunicazione tra Rabbit edFPGA, il Rabbit, dapprima scrive i dati sulle porte in uscita5, poi alza il se-gnale di strobe. Questo serve ad evitare che l’FPGA inizi a leggere su i pin,prima che il Rabbit abbia finito di farli commutare nel modo appropriato.A questo punto entra in un loop infinito che si conclude soltanto quando l’F-PGA alza il proprio strobe, ovvero lo strobe in ingresso del Rabbit.Un protocollo di comunicazione di questo tipo, in cui cioe una parte aspetta

Stato: Scrivi dato

Scrive il dato su DataOut

Scrive il comando "scrivi dato" su

CtrlOut

Alza lo StrobeOut

Lo StrobeInè alto?

No

Sì



C'è un errore?

No

Sì


Passa a stato: idle

Fine

Figura 3.3: Diagramma di flusso dello stato di scrittura dato.

un segnale dell’altra per proseguire, e detto asincrono.L’alternativa sarebbe un protocollo in cui le due parti si scambiano segnali ”atempo”, cioe seguendo un segnale che passa da 1 a 0 con una frequenza costan-

5Le porte in ingresso e in uscita del Rabbit sono esaminate in dettaglio nella sezione 2.2.3

3.3 Struttura del programma 17

te (e con forma d’onda quadra), detto clock. Un protocollo di comunicazionedi questo tipo e detto sincrono, e non ci e sembrato adatto al nostro scopo6.

3.3 Struttura del programma

Dopo aver analizzato i due protocolli, passiamo all’analisi del programma im-plementato sul microprocessore Rabbit.Il programma e stato strutturato in 3 blochi:

1. Connessione;

2. Comunicazione con il client;

3. Comunicazione con l’FPGA (Macchina a stati).

Questi blocchi venegono eseguiti simultaneamente7 e si comandano a vicendatramite alcune variabili globali alle quali tutti i blocchi hanno accesso.

Il blocco di connessione, non fa altro che aspettare una connessione TCP-IP e, qualora questa connessione avvenga, abilita la comunicazione. D’altraparte, quando la connessione termina, chiude la comunicazione e si mette nuo-vamente in attesa di connessione. Il programma da noi implementato, puosupportare una sola connessione alla volta.

Il blocco di comunicazione con il client e quello che attua la comunicazioneappena trattata nella sezione 3.1. In altre parole, questo blocco riceve dalclient: i comandi (Read o Write), l’indirizzo e il dato. A questo punto, me-morizza questi ultimi in due variabili globali (accessibili anche dal blocco dicomunicazione con l’FPGA) e, infine, cambia il valore della variabile di stato,ponendo cosı la macchina a stati, cioe il terzo blocco, nello stato desiderato.Nella fattispecie, sia che il comando sia Read, sia che sia Write, il blocco dicomunicazione con il client, pone sempre la macchina a stati nello stato di ”co-municazione indirizzo”. Dopo aver fatto questo, la pone nello stato di scritturao lettura, in base al comando ricevuto dal client.

Il terzo blocco e costituito dalla macchina a stati gia esaminata in dettaglionel paragrafo 3.2.1. Il passaggio dallo stato idle agli altri stati attivi, e dovutoesclusivamente al secondo blocco, che dopo aver ricevuto l’istruzione dal client,cambia il valore della variabile di stato. Dopo aver eseguito le dovute istruzioni,

6Cfr. paragrafo 4.1.7Per maggiori informazioni consultare il paragrafo 4.1 e 4.3.4.


la macchina torna nello stato idle automaticamente, come si puo vedere daidiagrammi in figura 3.2 e 3.3.

Il funzionamento dei tre blocchi appena illustrati e schematizzato in figura3.4.

BLOCCO:Connessione

BLOCCO:Comunicazione conil Client (via TCP-IP)

BLOCCO:Macchina a statidi comunicazione

con l'FPGA

Indirizzo Dato

Scrive o leggeLegge o scrive

Stato

Variabili Globali

Abilita

Figura 3.4: Schema del funzionamento dei tre blocchi del programma.

3.4 Debug

Durante e dopo l’implementazione, e stato effettuato un controllo sul correttofunzionamento del programma.Per eseguire tale controllo e stato necessario costruire un hardware con alcuniled e interruttori, collegato alla scheda di programmazione fornita dalla RabbitSemiconductor. Con l’ausilio di quest’hardware abbiamo simulato gli input econtrollato gli output del Rabbit.Grazie ad un deviatore che collegava il PE08 a massa o a 3.3V, si simulava

il segnale di strobe in ingresso. Questo e risultato particolarmente comodo, inquanto il protocollo di comunicazione da noi realizzato, come visto nel para-grafo 3.2, mette in attesa il Rabbit fino a quando lo strobe in ingresso e basso.C’era dunque tutto il tempo per eseguire misure di differenze di potenziale econtrollare se i giusti LED fossero accesi.

8Si tratta del pin di strobe in ingresso del Rabbit, cfr. paragrafo 2.2.3.

3.4 Debug 19

Figura 3.5: Il modulo RCM 3200 collegato al test bench.

I LED erano collegati alle porte in uscita del Rabbit e, realizzando opportuniprogrammi di test, si e potuto controllare se i risultati che il microprocessoreforniva, fossero effettivamente quelli attesi.I test eseguiti nella fattispecie sono stati:

• Controllo della funzione CtrlOut() e dello stato ”StAdd”;

• Controllo della funzione DataIn();

• Controllo della funzione CtrlIn();

• Controllo della funzione DataOut();

• Test dei comandi via TCP-IP (con Telnet9);

Nonostante questi test abbiano dato risultati positivi, il corretto funzionamen-to della scheda non e ancora garantito.E necessario ancora eseguire dei test sulla scheda ultimata, per controllare ilcorretto funzionamento del Rabbit e dell’FPGA simultaneamente.

9Telnet e un semplice programma di comunicazione TCP-IP. Tramite questo, sono stateinviate delle stringhe formattate come visto al paragrafo 3.1, e controllate le stringhe dirisposta del Rabbit.


3.5 Programma di interfaccia utente

Per la comunicazione con il client e stato realizzato, inoltre, un semplice ap-plicativo.Questo programma consente di collegarsi alla scheda di controllo VME da noiprogettata (ovvero al Rabbit) e di eseguire le operazione piu elementari:

• Lettura dei dati contenuti su un indirizzo del bus VME;

• Scrittura su un indirizzo del bus VME;

• Lettura in un range di indirizzi del bus.

Il programma e stato realizzato in Java ed e quindi compatibile con qualsiasisistema operativo.Il funzionamento del programma e molto semplice: basta inserire l’indirizzo

Figura 3.6: Uno screenshot del programma di interfaccia.

ip della scheda, il numero della porta e cliccare il tasto connetti. A questopunto si puo selezionare la modalita di scrittura o di lettura, inserire i relatividati ed eseguire l’operazione.Nel caso di operazione di lettura, e possibile leggere i dati contenuti in unintervallo di indirizzi, scrivendo soltanto il primo e l’ultimo.Come si vede dalla figura 3.6, i risultati di tutte le operazioni vengono visua-lizzati nell’area di log sottostante.Anche in questo caso, ci riserviamo di eseguire test piu approfonditi una voltache la scheda sara ultimata.

Capitolo 4

Codice sorgente

21

22 Codice sorgente

4.1 Caratteristiche generali del Dynamic C

Il Dynamic C e un linguaggio appositamente creato per la programmazionedi microcontrollori di alto livello, come il Rabbit. Esso e identico al C, conl’aggiunta di espansioni appositamente create per la gestione delle funziona-lita dei microcontrollori. Le espansioni del linguaggio comprendono strumentiper multi-tasking collaborativi e con prelazione, nonche per la protezione dallasovrascrittura delle variabili in caso di interruzioni dell’alimentazione. I prin-cipali strumenti per multi-tasking utilizzati nel nostro progetto sono i costate.Il programma viene implementato con una struttura a blocchi, i costate, chesono eseguiti contemporaneamente1 e si scambiano informazioni grazie a va-riabili globali. Tale metodologia di programmazione causa, pero, una perditad’informazione sul numero di cicli di clock necessari per arrivare ad eseguireuna data istruzione. In altre parole il prezzo da pagare per una programma-zione multi-tasking leggibile e veloce e l’impossibilita di gestire applicazionicritiche sotto il profilo delle tempistiche. Tuttavia cio non danneggia il nostroprogetto, essendo il protocolllo da noi ideato asincrono.

4.2 Variabili globali

Nel codice sono state definite una serie di variabili globali. La comprensionedel ruolo di tali variabili e necessaria per capire il codice.

4.2.1 Variabile: STATE

Questa variabile di tipo unsigned int contiene un numero intero senza segno,che indica lo stato in cui si trova la state machine. Dire che la state machinee in un particolare stato, equivale a dire che la variabile STATE contiene ilvalore relativo a quello stato.I valori possibili sono stabiliti dalle define poste in testa al codice.Tali valori sono elencatidi seguito.

STATE = stIdle

E lo stato in cui la macchina aspetta istruzioni.

1Chiaramente un dispositivo come il Rabbit, dotato di un unico processore, non puorealmente eseguire piu istruzioni allo stesso tempo, pero il costate da la possibilita allosviluppatore di programmare esattamente come se cio accadesse.

4.2 Variabili globali 23

STATE = stAdd1, stAdd2, stAdd3, stAdd4

Sono gli stati in cui la macchina comunica all’FPGA l’indirizzo del bus VMEsu cui scrivere o da cui leggere i dati.Come abbiamo gia visto, l’indirizzo e a 32 bit2, secondo lo standard del pro-tocollo VME. Essendo la porta di comunicazione a 16 bit, abbiamo bisognodi spezzare l’indirizzo in 2 porzioni (di 16 bit ciascuna)3 prima di comunicarloall’FPGA. Il numero che segue stAdd (1, 24), indica, appunto, quale porzionedi indirizzo si sta comunicando.

STATE = stDataWr1, stDataWr2, stDataWr3, stDataWr4

Sono gli stati in cui la macchina richiede all’FPGA di scrivere i dati su unindirizzo del bus VME.Il dato a 32 bit, analogamente a quanto visto per stAdd, va suddiviso inporzioni, anche in questo caso indicate dal numero che segue stDataWr.

STATE = stDataRd1, stDataRd2, stDataRd3, stDataRd4

Sono gli stati in cui la macchina richiede all’FPGA di leggere i dati da unindirizzo del bus VME.Il funzionamento e analogo a quello appena descritto per StDataWr.

4.2.2 Variabile: ADDRESS

Questa variabile di tipo unsigned int contiene un numero intero senza segno,che rappresenta l’indirizzo a 32 bit del bus VME5.L’indirizzo viene memorizzato dal programma indipendentemente dall’utilizzoche se ne intende fare; cioe sia che si intenda scrivere un certo dato sull’indi-rizzo, sia che s’intenda leggerlo.

4.2.3 Variabile: DATA

Questa variabile di tipo unsigned int contiene un numero intero senza segno,che rappresenta il dato da scrivere sul bus VME o che vi e stato letto.

2Il programma e comunque predisposto per supportare il protocollo VME a 64 bit.34 porzioni di 16 bit nel caso di protocollo a 64 bit.4Anche 3 o 4 nel caso di protocollo a 64 bit.5Nel caso di protocollo VME a 64 bit il tipo unsigned int non e piu sufficiente a contenere

l’indirizzo, di conseguenza la variabile va ridefinita come unsigned long.

24 Codice sorgente

4.2.4 Variabili per la comunicazione TCP-IP

Le variabili analizzate nei seguenti paragrafi sono state utilizzate per la comu-nicazione del Rabbit con il client mediante il protocollo TCP-IP.

Variabile: buffer[9]

Questo e un array di 9 variabili di tipo char (cioe di caratteri a 8 bit). Ela stringa di caratteri inviata dal client al Rabbit per la comunicazione viaTCP-IP.Il primo carattere della stringa, cioe i primi 8 bit, rappresenta il comando cheil client invia al Rabbit per richiedere di eseguire un’operazione di lettura oscrittura.I valori che esso puo assumere sono 2:

• ’r’ (Read) nel caso in cui si richieda di effettuare la procedura di lettura;

• ’w’ (Write) nel caso in cui si richieda di effettuare la procedura di scrit-tura;

I caratteri da 2 a 5 (32 bit) contengono l’indirizzo VME da cui il Rabbitdeve leggere i dati richiesti o a cui deve scrivere.Dunque questi 4 caratteri contengono l’indirizzo sia nel caso di procedura dilettura sia nel caso di procedura di scrittura.I caratteri da 6 a 9 (32 bit) vengono utilizzati solamente nel caso di proceduradi scrittura e contengono i dati.

Variabile: data

Questa e una variabile di tipo unsigned long, cioe un intero senza segno a 32bit. Essa contiene l’indirizzo VME o il dato nel momento in cui esso vengainviato dal client al Rabbit. In questo caso, infatti, il dato va ricostruito apartire dalle porzioni di 16 bit inviate al Rabbit dall’FPGA e poi inviato alclient tramite la variabile send, spiegata di seguito.

Variabile: send[5]

Questo e un array di 5 variabili di tipo char (cioe di caratteri a 8 bit). Ela stringa di caratteri inviata dal Rabbit al client per la comunicazione viaTCP-IP.Il primo carattere della stringa, cioe i primi 8 bit, rappresenta la risposta che

4.3 Funzioni 25

il Rabbit invia al client dopo aver effettuato la procedura richiesta:I valori che esso puo assumere sono 4:

• ’r’ (Read) nel caso in cui la procedura di lettura sia stata effettuata consuccesso;

• ’w’ (Write) nel caso in cui la procedura di scrittura sia stata effettuatacon successo;

• ’B’ (Bus Error) nel caso in cui si sia riscontrato un errore nell’indirizzoo nel dato inviato al bus VME;

• ’R’ (Retry) nel caso in cui il bus VME fosse occupato e richiedesse diriprovare in un secondo momento.

4.3 Funzioni

In questa sezione sono descritte le varie funzioni utilizzate all’interno del pro-gramma.Nelle descrizioni delle singole funzioni si fa riferimento al codice riportatonell’appendice A per motivi di leggibilita.

4.3.1 Funzioni di comunicazione TCP-IP

Funzione: connect()

void connect()

Mette il Rabbit in attesa di connessione TCP-IP.Parametri: nessuno.Valore restituito: nessuno.

Quando questa funzione viene chiamata, il programma attende fino a quan-do non viene stabilita una connessione TCP-IP sulla porta PORT definita nel-le define in testa al codice. Una volta che tale connessione e stata stabilitaconfigura il tipo di comunicazione ASCII e termina.

4.3.2 Funzioni di comunicazione: Rabbit ←→ FPGA

Funzione: DataOut()

void DataOut(unsigned int data)

26 Codice sorgente

Scrive dati sulla porta di comunicazione DataOut.Parametri: data: valore intero a 16 bit che viene scritto sulla porta.Valore restituito: nessuno

Questa funzione setta i valori dei pin della porta di comunicazione a 16 bitDataOut, in modo tale da rappresentare l’intero data.La porta DataOut e costituita da due porte a 8 bit del Rabbit: la F e la G.DataOut() non fa altro che scomporre il numero data in due porzioni da 8 bitciascuna (con un’operazione di AND logico bit a bit) e poi inviarle alle porteF e G.

Funzione: DataIn()

unsigned int DataIn()

Legge dati dalla porta di comunicazione DataIn.Parametri: nessuno.Valore restituito: il valore a 16 bit letto sulla porta.

Questa funzione legge i valori dei pin della porta di comunicazione a 16 bitDataIn, e poi li combina in modo tale da rappresentare un numero intero a 16bit.Essendo la porta DataIn costituita da alcuni pin delle porte B e D del Rabbit,l’operazione eseguita da DataIn per calcolare il valore del dato e leggermentepiu complicata di quella vista per la funzione precedente.

4.3.3 Funzioni di controllo: Rabbit ←→ FPGA

Funzione: CtrlOut()

int CtrlOut(unsigned int ctrl)

Scrive dati sulla porta di controllo CtrlOut.Parametri: ctrl: vaolre intero a 16 bit che viene scritto sulla porta.Valore restituito: 1 nel caso di ctrl non valido, 0 in caso contrario.

Il valore di ctrl deve essere minore di 32, dunque la funzione esegue da primaun controllo sulla variabile e restituisce 1 qualora fosse maggiore o uguale a32.

4.3 Funzioni 27

A questo punto CtrlOut scomponte il numero ctrl bit a bit e lo scrive sui pindella porta.

Funzione: CtrlIn()

unsigned char CtrlIn()

Legge dati dalla porta di controllo CtrlIn.Parametri: nessuno.Valore restituito: il valore a 3 bit letto sulla porta.

Questa funzione ricompone bit a bit il valore a partire dai tre pin dellaporta di controllo CtrlIn.

Funzione: StrobeOut()

void StrobeOut(unsigned int OnOff)

Abilita o disabilita il seganle di strobe in uscita.Parametri: OnOff: 1 per abilitare strobe in uscita, 0 per disabilitarlo.Valore restituito: nessuno.

Questa funzione non fa altro che scrivere il valore di OnOff sul pin di strobein uscita, cioe il 5 della porta D.

Funzione: StrobeIn()

unsigned int StrobeIn()

Restituice il valore del segnale di strobe in ingresso.Parametri: nessuno.Valore restituito: 1 se lo strobe in ingresso e attivato o 0 in caso contrario.

Questa funzione legge il valore del pin di strobe in ingresso, il pin 0 dellaporta E, e lo restituisce.Come abbiamo visto, il programma e predisposto all’implementazione di unsegnale di interrupt6. Si ricorda, dunque, che StrobeIn() deve essere utilizzata

6Vedere la funzione IntOnOff riportata di seguito.

28 Codice sorgente

solo nel caso in cui si lavori senza segnale di interrupt, in caso contrario nonha piu senso controllare se lo strobe e alzato o meno, in quanto qualora sialzasse il programma manderebbe immediatamente in esecuzione la proceduradi gestione dell’interrupt. Inoltre, dato che il pin di interrupt INT0, e proprioil PE0, l’utilizzo di questa funzione in caso di interrupt abilitato genererebbeun errore a runtime.

4.3.4 Funzioni interne

Funzione: IntOnOff()

void IntOnOff(int OnOff)

Abilita o disabilita la modalita di interrupt (sul PE0).Parametri: OnOff: 1 per abilitare l’interrupt, 0 per disabilitarlo.Valore restituito: nessuno.

Questa funzione abilita l’interrupt sul pin 0 della porta E. In caso di inter-rupt sul PE0 viene lanciata la funzione IntIn(), che va scritta in caso si volesseimplementare la funzionalita di interrupt in questo programma.

Funzione: RabbitInit()

void RabbitInit()

Inizializza il Rabbit: abilita la porta Ethernet 10/100Base-T per la comunica-zione via TCP-IP con il client e configura tutti i pin, in ingresso e in uscita,per la comunicazione con l’FPGA.Parametri: nessuno.Valore restituito: nessuno.

Questa funzione inizializza il Rabbit creando tutte le porte viste nelle de-scrizioni delle funzioni precedenti: DataIn, DataOut, CtrlIn, CtrlOut, nonchei pin di strobe in ingresso e in uscita.Per fare questo RabbitInit() scrive su i Function Register delle cinque porteparallele del Rabbit, configurandoli in modo appropriato.Per la comprensione di questa funzione si consiglia di leggere il codice accura-tamente commentato nell’appendice A.

4.3 Funzioni 29

Programma principale, funzione Main()

void Main()

Questa e la funzione principale del programma. Essa e costituita da ununico loop infinito for(;;) che inizia subito dopo la dichiarazione e l’inizia-lizzazione delle variabili locali.All’interno di questo loop vi sono i 3 costate di cui abbiamo discusso nellasezione 3.3:

• Connessione;

• Comunicazione TCP-IP;

• Sate Machine di comunicazione con l’FPGA.

Per la comprensione della main() si consiglia di leggere il codice ed i commentiriportati nell’appendice A.

30 Codice sorgente

Capitolo 5

Conclusioni

31

32 Conclusioni

La scheda di controllo da noi realizzata, in conclusione, sebbene molto sem-plice dal punto di vista proggettuale, offre tutte le prestazioni richieste.Se paragonata ad una classica scheda di controllo con calcolatore integrato,risulta meno potente dal punto di vista della capacita di calcolo, ma piu sem-plice da gestire e piu versatile. Infatti, la connettivita, basata sul protocolloTCP-IP, permette una facile integrazione in ambienti distribuiti preesistenti.In parole semplici, e possibile collegare con facilita una qualsiasi macchina allascheda, dunque al rack VME, e quindi ottenere una potenza di calcolo di granlunga superiore a qualsiasi calcolatore possa essere integrato su scheda.Inoltre una scheda di questo tipo ha un costo di produzione sensibilmente in-feriore a quello di una scheda di controllo con calcolatore integrato.

Il progetto da noi realizzato, inoltre, offre ampio margine di miglioramen-to. La struttura dei programmi realizzati, sia per il Rabbit, sia per l’FPGA,permette una facile implementazione dello standard VME64x a 64 bit.Il protocollo di comunicazione tra client e Rabbit, data la sua semplicita, offrealta compatibilita, cioe consente lo sviluppo di un software d’interfaccia uten-te anche molto sofisticato e svincolato dall’hardware e dal sistema operativosottostante.

Appendice A

Codice del programma

/∗∗∗ GLOBAL VARIABLES ∗∗∗/unsigned int STATE;//variabile che indica lo statounsigned char ERROR;//variabile di erroreunsigned int ADDRESS; /∗ nel caso di 64 bit deve essere long ∗///variabile che contiene l’indirizzo a cui andranno scritti o// da cui andranno letti i datiunsigned int DATA;//variabile che contiene i dati che andranno scritti o che sono stati letti

/∗∗∗ STATES ∗∗∗/#define stIdle 0#define stAdd1 1#define stAdd2 2#define stAdd3 3 // solo per 64 bit#define stAdd4 4 // solo per 64 bit#define stDataWr1 5#define stDataWr2 6#define stDataWr3 7 // solo per 64 bit#define stDataWr4 8 // solo per 64 bit#define stDataRd1 9#define stDataRd2 10#define stDataRd3 11 // solo per 64 bit#define stDataRd4 12 // solo per 64 bit

/∗∗∗ TCP/IP CONNECTION ∗∗∗/#define CINBUFSIZE 31

33

34 Codice del programma

#define COUTBUFSIZE 31#define MY GATEWAY ”141.108.248.1”#define MY IP ADDRESS ”141.108.249.231” // indirizzo del rabbit#define MY NETMASK ”255.255.254.0” // maschera di sottorete delrabbit#define TCP BUF SIZE 2048#define HTTP MAXSERVERS 4#define MAX TCP SOCKET BUFFERS 4#memmap xmem#use ”dcrtcp.lib”#define PORT 9999

/∗∗∗ TCP − IP COMMANDS ∗∗∗/#define CMDRead ’r’#define CMDWrite ’w’#define CMDRetry ’R’ //Errori del bus#define CMDBerr ’B’

35

/∗∗∗ FPGA COMMANDS ∗∗∗/#define ADDR 4 // (00100)#define IOWR 8 // (01000)#define IORD 16 // (10000)

/∗∗∗ TCP − IP VARIABLES ∗∗∗/char buffer[9];/∗ 1 CMD;2 − 5 ADDRESS; 6 − 9 DATA ∗/

tcp Socket socket;unsigned long data;unsigned char send[5];

/∗∗ Questi comandi si usano sommando al comadno ADDR, IOWR o IORD ilnumero∗ del pezzo di indirizzo o di dato da leggere o da scrivere.∗ Nel caso di indirizzi e dati a 16 bit i pezzi sono due∗∗ ES.∗∗ ADDR + 1 (passaggio del primo pezzo di indirizzo)∗ IOWR + 2 (scrivi il∗ secondo pezzo di dato)∗∗/


/∗∗∗∗∗∗ FUNZIONI ∗∗∗∗∗/

/∗∗∗ tcp − ip ∗∗∗/// Funzione che abilita la connessioneconnect(){

sock init();tcp reserveport(80);tcp listen(&socket, PORT, 0, 0, NULL, 0);while (!sock established(&socket) && sock bytesready(&socket) ==−1)

tcp tick(NULL);sock mode(&socket, TCP MODE ASCII);

}

/∗∗∗ FPGA communication ∗∗∗/

// Funzione che scrive i dati sulla porta in uscitavoidDataOut(unsigned int data){

WrPortI(PGDR, &PGDRShadow, (data & 0xFF00) >> 8);//Scrive gli 8 bit piu significativi sulla porta G

WrPortI(PFDR, &PFDRShadow, data & 0x00FF);//Scrive gli 8 bit meno significativi sulla porta F

}

// FUNZIONE LANCIATA IN CASO DI INTERRUPT SU PE0interrupt voidIntIn(){/∗∗ inserire qui la funzione nel caso in cui∗ si voglia usare la funzionalita di interrupt∗/}

voidRabbitInit(){

//PORT A

37

WrPortI(SPCR, &SPCRShadow, 0x80);/∗∗ setta tutti i bit del SPCR, in modo da disabilitare∗ la Slave Port e settare la porta A come Input∗/

//PORT BWrPortI(PBDDR, &PBDDRShadow, 0x00);//setta tutti i bit come input(valore 0 del ddr)

//PORT CWrPortI(PCDR, &PCDRShadow, PCDRShadow & 0x10);//azzera il PC4 (1110111 = EF)WrPortI(PCFR, &PCFRShadow, 0XEF);//setta le porte parallele su PC0 PC1 E PC2 PC3 (00000101 = 0X05)

//PORT DWrPortI(PDFR, &PDFRShadow, 0x00);//azzera tutto il Function RegisterWrPortI(PDDDR, &PDDDRShadow, PDDRShadow & 0xE7);//azzera il bit 4 e 5 (11100111 = E7)WrPortI(PDDDR, &PDDDRShadow, PDDDRShadow | 0x20);/∗∗ ora alza il 5(00010000 = 20), cioe’ mette∗ il bit 4 in input e il 5 in output∗/

//PORT EWrPortI(PECR, &PECRShadow, PECRShadow & 0x00);//clear all bits to pclk / 2WrPortI(PEFR, &PEFRShadow, 0x00);//azzera tutto il Function RegisterWrPortI(PEDDR, &PEDDRShadow, PEDDRShadow & 0x02);//abbassa tutto tranne il 2(PE1) (00000010 = 2)WrPortI(PEDDR, &PEDDRShadow, PEDDRShadow | 0xE8);//alza tutto tranne 0, 1, 2, 4(11101000 = E8)

// Per Abilitare l ’interrupt sul PE0, togliere il commento da qui sotto// SetVectExtern3000(0, IntIn);


WrPortI(PEDR, &PEDRShadow, 0x00);//azzera tutto il Data Register

//PORT FWrPortI(PFFR, &PFFRShadow, 0x00);//setta tutto come normale I / OWrPortI(PFDDR, &PFDDRShadow, 0xFF);//setta tutto come Output(11111111 = FF)WrPortI(PFDR, &PFDRShadow, 0x00);//azzera tutto

//PORT GWrPortI(PGFR, &PGFRShadow, 0x00);//setta tutto come normale I / OWrPortI(PGDDR, &PGDDRShadow, 0xFF);//setta tutto come Output(11111111 = FF)WrPortI(PGDR, &PGDRShadow, 0x00);//azzera tutto

}

// Funzione che accende e spegne la funzionalita di interruptvoidIntOnOff(int OnOff){

if (OnOff == 1){

WrPortI(I0CR, &I0CRShadow, 0x09);//abilita l’interrupt sul fronte di salita del PE0

}else

{WrPortI(I0CR, &I0CRShadow, 0x00);//disabilita l ’interrupt sul fronte di salita del PE0

}}

// Funzione che restituisce i dati sulla porta in ingressounsigned intDataIn(){

39

return (RdPortI(PADR) + BitRdPortI(PBDR, 0) ∗ 0x100 + BitRdPortI(PDDR,4) ∗ 0x200 + BitRdPortI(PBDR, 2) ∗ 0x400 + BitRdPortI(PBDR, 3) ∗ 0x800+ BitRdPortI(PBDR, 4) ∗ 0x1000 + BitRdPortI(PBDR, 5) ∗ 0x2000 + BitRd-PortI(PBDR, 6) ∗ 0x4000 + BitRdPortI(PBDR, 7) ∗ 0x8000);}

unsigned charCtrlIn(){

unsigned int ctrl; //??? non servereturn (BitRdPortI(PEDR, 1) + BitRdPortI(PEDR, 4) ∗ 2 + BitRdPor-

tI(PCDR, 5) ∗ 4);}

// Funzione che scrive i dati sulla porta in uscitaintCtrlOut(unsigned int ctrl){

if (ctrl < 32){

BitWrPortI(PCDR, &PCDRShadow, ctrl & 0x01, 4);//Scrive il bit 1 di ctrl sul PC4BitWrPortI(PEDR, &PEDRShadow, (ctrl & 0x02) >> 1, 3);//Scrive il bit 2 di ctrl sul PE3BitWrPortI(PEDR, &PEDRShadow, (ctrl & 0x04) >> 2, 5);//Scrive il bit 3 di ctrl sul PE5BitWrPortI(PEDR, &PEDRShadow, (ctrl & 0x08) >> 3, 6);//Scrive il bit 4 di ctrl sul PE6BitWrPortI(PEDR, &PEDRShadow, (ctrl & 0x10) >> 4, 7);//Scrive il bit 5 di ctrl sul PE7return 0;//tutto ok

}else

{return 1;//Ctrl non valido

}}


// Funzione che accende e spegne il segnale di Strobe in uscitavoidStrobeOut(unsigned int OnOff){

BitWrPortI(PDDR, &PDDRShadow, OnOff, 5);//Mette la variabline OnOf, che deve essere 0 o 1, nel PD5

}

// Funzione che restituisce il valore Strobe in ingresso (1 o 0)// Da utilizzare solo se il PE0 non e settato come interruptunsigned intStrobeIn(){

return BitRdPortI(PEDR, 0);//Restituisce il valore dello Strobe in ingresso

}

41

/∗∗∗∗∗∗∗∗ MAIN ∗∗∗∗∗∗∗∗/main(){

int len;//lunghezza effettiva di bufferchar CMD;//Comando, ovvero primo carattere di bufferRabbitInit();//inizializzazione delle porte

/∗∗∗ Inizializzazione variabili globali ∗∗∗/STATE = stIdle;ADDRESS = 0;DATA = 0;

for (;;){

costate // CONNECTION{

if (!sock established(&socket) && sock bytesready(&socket) == −1){

connect();}

len = sock gets(&socket, buffer, sizeof(buffer) − 1);tcp tick(&socket);

}

costate // TCP − IP COMMUNICATION{if (len > 0){

CMD = buffer[0];

switch (CMD){

case CMDRead:{

ADDRESS = buffer[1] + buffer[2] ∗ 256;// mette i primi 16 bit di indirizzo in ADDRESS


STATE = stAdd1;waitfor(STATE == stIdle);

ADDRESS = buffer[3] + buffer[4] ∗ 256;//mette i secondi 16 bit di indirizzo in ADDRESSSTATE = stAdd2;waitfor(STATE == stIdle);

STATE = stDataRd1;waitfor(STATE == stIdle);

if (ERROR 6= 0){

send[0] = ERROR;sock write(&socket, send, 1);ERROR = 0;break;

}

data = DATA;// Mette i secondi 16 bit di dati in dataSTATE = stDataRd2;waitfor(STATE == stIdle);

data += DATA ∗ 65536;if (ERROR 6= 0){


}

send[0] = ’r’;memcpy(send + 1, &data, 4);sock write(&socket, send, sizeof(send));//non c ’e il −1 perche non c’ e lo / 0break;

}

43

case CMDWrite:{

ADDRESS = buffer[1] + buffer[2] ∗ 256;//mette i primi 16 bit di indirizzo in ADDRESSSTATE = stAdd1;waitfor(STATE == stIdle);

ADDRESS = buffer[3] + buffer[4] ∗ 256;//mette i secondi 16 bit di indirizzo in ADDRESSSTATE = stAdd2;waitfor(STATE == stIdle);

DATA = buffer[5] + buffer[6] ∗ 256;STATE = stDataWr1;waitfor(STATE == stIdle);

if (ERROR 6= 0){


}

DATA = buffer[7] + buffer[8] ∗ 256;STATE = stDataWr2;waitfor(STATE == stIdle);

if (ERROR 6= 0){


}

send[0] = ’w’;sock write(&socket, send, 1);//mi basta inviare il primo byte di send[]break;


}

/∗ aggiungere altri case per implementare nuovi comandi ∗/default:{

// comando errato}} // switch

} // if} // costate

costate // STATE MACHINE FOR FPGI COMMUNICATION{

switch (STATE){case stIdle:{

//non fare nientebreak;

}

/∗∗ Passaggio indirizzo ∗∗/case stAdd1:case stAdd2:case stAdd3:case stAdd4:{

StrobeOut(0);//Abbassa lo strobeDataOut(ADDRESS);CtrlOut(ADDR + STATE − stAdd1 + 1);

/∗∗ Invia il comando con il numero del pezzo indirizzo∗ da passare(STATE − stAdd1 + 1)∗/

StrobeOut(1);//Alza lo strobewaitfor(StrobeIn() == 1);//Aspetta che l ’altera risponda

45

StrobeOut(0);//Abbassa lo strobeERROR = CtrlIn();//Comunica l ’erroreSTATE = stIdle;//Si mette nello stato Idlebreak;

}

/∗∗ Scrittura Dati ∗∗/case stDataWr1:case stDataWr2:case stDataWr3:case stDataWr4:{

StrobeOut(0);//Abbassa lo strobeDataOut(DATA);CtrlOut(IOWR + STATE − stDataWr1 + 1);StrobeOut(1);//Alza lo strobewaitfor(StrobeIn() == 1);//Aspetta la risposta del FPGI

StrobeOut(0);//Abbassa lo strobeERROR = CtrlIn();//Comunica l ’erroreSTATE = stIdle;//Si mette nello stato Idlebreak;

}

/∗∗ Lettura Dati ∗∗/case stDataRd1:case stDataRd2:case stDataRd3:case stDataRd4:{

StrobeOut(0);


//Abbassa lo strobeCtrlOut(IORD + STATE − stDataRd1 + 1);StrobeOut(1);//Alza lo strobewaitfor(StrobeIn() == 1);//Aspetta la rispostaStrobeOut(0);

ERROR = CtrlIn();/∗ Comunica l’errore, se c’ e’, altrimenti CtrlIn() restituisce 0,∗ cioe’ nessun errore∗/

DATA = DataIn();STATE = stIdle;break;

}

/∗∗ Tutti gli altri stati ∗∗/default:{//stato inesistente}

} //switch} //costate} //for} //main

progettazione di una scheda di controllo per bus vme...

Documents