Università degli studi di Napoli Federico II

FACOLTÀ DI SCIENZE MATEMATICHE, FISICHE

E NATURALI
Corso di Laurea in Fisica
Sviluppo, realizzazione e collaudo di un
discriminatore di carica realizzato con un
microprocessore integrato su una logica
programmabile
Relatori: Candidato:
Prof. G. Barbarino Oscar Gargiulo
Dott. S. Russo

Matricola:
567/58

Anno accademico · 2006 / 2007 ·

 Introduzione
Il seguente progetto è stato ispirato al laboratorio sottomarino NEMO

(NEutrin Mediterranean Observatory). Il cuore di NEMO è un telescopio

chiamato km3 (per il suo volume) posto sott'acqua e atto alla rivelazione dei

neutrini. Tali particelle sono elettricamente neutre e di massa molto picco-

la, dell'ordine di 10−5 − 10−6 volte quella dell'elettrone. La loro bassissima

sezione d'urto permette loro di percorrere distanze enormi prima di intera-

gire con altri corpi, questo li rende ideali per lo studio di eventi lontani sia

spazialmente che temporalmente, magari no a raggiungere l'inizio dell'u-

niverso: il Big Bang. I neutrini giunti sulla Terra interagiscono formando

muoni, sono quest'ultimi ad essere rilevati dal telescopio, i cui fotomoltiplica-

tori registrano la radiazione Cherenkov prodotta dal loro moto in un mezzo.

Alla dicoltà di rilevazione e alla rarità degli eventi, comuni anche ad altri

esperimenti dello stesso tipo, NEMO va incontro alla dicoltà di essere real-

izzato sott'acqua, usata come ltro, e quindi di essere costruito in modo da

resistere alla pressione, alle correnti marine e alla corrosione. Il mio lavoro si

è occupato della trasmissione dei dati a terra, limitandone il usso. Infatti

lo stadio nale dell'elettronica del telescopio è un ADC (Analogic to Digital

Converter) che trasforma in un numero digitale di un certo numero di bit

il segnale generato dal telescopio. Purtroppo però tale segnale può essere

generato anche dal cosidetto rumore, quindi la mia scheda si occuperebbe

di selezionare e trasmettere solo i numeri signicativi. La programmazione

della scheda è stata svolta sia dal punto di vista Hardware, tramite linguaggio

VHDL, realizzando dei circuiti digitali e un microprocessore di tipo Microb-

I
laze in un FPGA; che Software, scrivendo un programma in linguaggio C con

lo scopo di controllare le periferiche ed eettuare la selezione dei dati.

II
Indice

1 NEMO 1
1.1 Introduzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Struttura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.1 La torre . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2.2 Il piano . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2.3 Modulo ottico (OM) . . . . . . . . . . . . . . . . . . . 6
1.3 formazione dei muoni . . . . . . . . . . . . . . . . . . . . . . . 7
1.4 Radiazione Cherenkov . . . . . . . . . . . . . . . . . . . . . . 7
1.5 Il problema della comunicazione . . . . . . . . . . . . . . . . . 9

2 Field Programmable Gate Arrays (FPGA) 10

2.1 Introduzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.2 Congurable logic block (CLB) . . . . . . . . . . . . . . . . . 12
2.2.1 Contatore . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.2.2 On-chip RAM . . . . . . . . . . . . . . . . . . . . . . . 14
2.3 Interconnessioni . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.4 Input/Output Block (IOB) . . . . . . . . . . . . . . . . . . . . 16
2.5 MicroBlaze . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

3 Progetto 20
3.1 Introduzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.2 Scheda elettronica . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.3 Simulatore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.4 Computer Aided Design (CAD) . . . . . . . . . . . . . . . . . 26
3.5 Software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.5.1 Inizializzazione . . . . . . . . . . . . . . . . . . . . . . 30
3.5.2 Inizio del ciclo di registrazione . . . . . . . . . . . . . . 31
3.5.3 Risultati . . . . . . . . . . . . . . . . . . . . . . . . . . 32

III
Capitolo 1

NEMO

1.1 Introduzione

Figura 1.1: Posizione proposta per il telescopio

Il sito proposto per il laboratorio sottomarino è a sud-est di Capo Passero

a circa 50 miglia marine dalla costa e ad una profondità di circa 3 km (Fig.

1.1). La rete di collegamento del laboratorio sarà costituita da circa 200 km

1
CAPITOLO 1. NEMO 2

di cavi elettro-ottici che consentiranno la connessione di un numero molto

elevato di strutture di rivelazione. Questa rete sarà in grado di fornire al sis-

tema la potenza necessaria e, allo stesso tempo, di trasmettere i dati raccolti

alla costa, dove verranno analizzati. NEMO è un laboratorio che integrerà

numerosi dispositivi di osservazione: monitoraggio sismico, oceanograco,

e altri strumenti per lo studio della vita sottomarina. Tuttavia il nostro

interesse ricade univocamente sulla rilevazione dei neutrini.

Infatti nora le osservazioni astronomiche si sono sempre basate sulla

rilevazione di onde elettromagnetiche o di protoni e nuclei atomici; purtroppo

però le prime vengono assorbite dai mezzi interstellari e i secondi deessi da

campi elettromagnetici presenti in tutto l'Universo.

Il neutrino per la sua trasparenza alle interazioni è la sonda ideale per

studiare le zone più remote del cosmo. Tuttavia essendo la sua probabilità di

interazione troppo bassa, la rilevazione viene eettuata in maniera indiretta.

Il telescopio sottomarino NEMO si occupa infatti di analizzare la radiazione

Cherenkov prodotta dai Muoni che entrano in acqua con una velocità supe-

riore a quella della luce nel mezzo. Essendo i Muoni formati dall'interazione

tra i neutrini nel rivelatore, ricostruendo la loro traccia è possibile ottenere

informazioni sui neutrini generatori (si consideri che il Muone possiede circa

il 50% - 60% dell'energia del neutrino che l'ha prodotto).

Il problema di fondo però è quello di isolare questi Muoni da quelli prodot-

ti nella nostra atmosfera. Un isolamento completo non è possibile, ma si può

diminuire il usso ltrandolo con qualcosa di denso come acqua o ghiaccio.

Ricapitolando il laboratorio è situato sott'acqua perchè essa assolve ad

una triplice funzione:

3 1.2. STRUTTURA

1. è il mezzo in cui i neutrini interagiscono per formare muoni

2. funge da schermo per i muoni atmosferici

3. è il mezzo nel quale si produce e si propaga la radiazione Cherenkov

1.2 Struttura
Il sistema di osservazione è basato su una serie di moduli ottici (paragrafo

1.2.3), la geometria dell'apparato deve essere tale da rendere possibile la ri-

costruzione delle tracce dei muoni. É quindi importante valutare il numero e

la distanza fra le coppie di moduli ottici. La distanza è funzione delle propri-

età di propagazione della luce nell'acqua circostante: minore è l'assorbimento

della luce, maggiore potrà essere la distanza fra i moduli ottici. Il numero

di moduli ottici necessari alla misura, e quindi il costo del rivelatore stesso,

è tanto minore quanto migliore è la trasparenza dell'acqua. I moduli hanno

il compito di generare una risposta elettronica che è funzione del numero dei

fotoni Cherenkov rilevati e del loro tempo di arrivo. Occorre poi trasmettere

i segnali elettronici ad un laboratorio a terra dove sono concentrati i mezzi

di calcolo necessari ad analizzarli e decodicarli per estrarne le informazioni

siche rilevanti.

La struttura proposta del laboratorio è a moduli, chiamati torri, disposti

come una matrice 9x9 su una supercie di 2 km2 e alte circa 750 m. Ogni

torre è composta da 18 piani contenenti 4 moduli ottici.

Il sistema di collegamento per la gestione dei dati e la fornitura della

potenza sarà organizzata utilizzando delle scatole chiamate Junction Box

CAPITOLO 1. NEMO 4

(JB) che separeranno i cavi lungo il proprio percorso da terra no ai 5832

moduli ottici. Un cavo di 100 Km collega il sistema di terra alla JB principale,

la quale smista i segnali su 9 cavi collegati alle JB secondarie. Inne si ha il

collegamento tra ques'ultime e le JB Tower, dalle quali fuoriescono i cavi di

collegamento per i 18 piani di ogni torre. Esiste un dispositivo di controllo

dell'elettronica per ogni piano chiamato Floor Control Module (FCM).

Figura 1.2: Vista schematica dall'alto del laboratorio e smistamento

principale dei cavi alle torri
5 1.2. STRUTTURA

1.2.1 La torre

Come detto precedentemente una torre di Nemo rappresenta la struttura

minima del telescopio. Ogni piano della torre è composto da un traliccio

orizzontale della lunghezza di 20 m che ha sulle estremità i moduli ottici.

Questi ultimi sono disposti in modo tale che due siano orientati verso il

basso e due a formare un angolo di 90◦ rispetto alla verticale. I piani sono

collegati con tiranti tali da disporli in direzioni mutuamente ortogonali e la

distanza tra i piani è di 40 m. L'altezza complessiva della torre è di 750

m, con una distanza dal fondale del primo piano di 150 m. Per tenere le

torri in verticale e i piani separati esse vengono tirate da un ancoraggio sul

fondo e da un sistema di boe, responsabili della spinta verso l'alto necessaria.

Alla base della torre è posta la JB-tower che, come detto prima, è il nodo

elettronico di ogni piano.

Figura 1.3: Vista schematica di una torre. Le sfere bianche sono i moduli
ottici
CAPITOLO 1. NEMO 6

1.2.2 Il piano

I piani presenti sulle torri hanno struttura tubolare e su essi sono collocati,

oltre ai 4 moduli ottici, diversi sensori e due moduli di controllo. Nella parte

centrale della gura 1.4 possiamo vedere il modulo di controllo FCM che è

collegato direttamente alla JB Tower, ai moduli ottici e allo Slow Control

Module (SCM). Quest'ultimo è una scatola con diversi input/output pro-

grammabili collegata ai diversi sensori (bussole, inclinometri, ecc.) posti sul

piano. L'FCM si comporta come un selettore di linee trasmettendo i dati

sulle due bre ottiche collegate alla JB Tower.

Figura 1.4: Sezione di un piano della torre.

1.2.3 Modulo ottico (OM)

Il modulo ottico è il dispositivo che rivela i fotoni Cherenkov prodotti in

acqua dalle tracce dei muoni. Diversamente dagli esperimenti di supercie,

i moduli ottici per il km3 devono essere alloggiati in opportuni contenitori

7 1.3. FORMAZIONE DEI MUONI

resistenti ad alte pressioni. Essi sono costituiti fondamentalmente da un fo-

tomoltiplicatore, da un'elettronica lenta per il controllo dei parametri del

modulo e da un'elettronica veloce per la digitalizzazione dei segnali. Tutti

questi componenti saranno alloggiati all'interno di una sfera in vetro boro-

silicato di diametro esterno di 43 cm e di spessore 15 mm. La sfera, separata

in due semisfere, è garantita per resistere ad una pressione di 700 bar. In una

semisfera è posto il fotomoltiplicatore (PMT) che viene fatto aderire al vetro

tramite un gel. Nell'altra viene invece posta l'elettronica ed ha un rivesti-

mento nero per far si che i fotoni rilevati provengano prevalentemente dalla

direzione in cui è puntato il PMT. Inne in tutto il modulo viene posta una

griglia di mumetal capace di schermare il magnetismo (la frequenza ottimale

è di 50 - 60 Hz).

1.3 formazione dei muoni

Un neutrino può interagire con un protone o un neutrone formando un muone

e un'altra particella:

νµ + N → µ + X

Se i muoni prodotti hanno un'energia dell'ordine dei TeV essi produrranno

radiazione Cherenkov muovendosi nel mezzo considerato (acqua).

1.4 Radiazione Cherenkov

La velocità di propagazione della luce in un materiale è data da c/n dove

n (chiamato indice di rifrazione) è un numero caratteristico del mezzo ed è

CAPITOLO 1. NEMO 8

sempre maggiore di uno (la velocità della luce in un mezzo è sempre inferiore

a quella nel vuoto). Può accadere che una particella incidente in un mez-

zo vi entri con velocità v superiore a c/n, in tal caso se la particella fosse

carica produrrebbe eetti di polarizzazione non simmetrica nel mezzo con

conseguente creazione di un campo elettrico. Tale fenomeno prende il nome

di eetto Cherenkov e misurando l'angolazione tra la propagazione dell'on-

da rispetto alla direzione della particella è possibile calcolare la velocità di

quest'ultima.

Figura 1.6: Costruzione geometrica

Figura 1.5: eetto Cherenkov dell'eetto Cherenkov

Dallo schema geometrico 1.6 è facile capire che :

c
cos θ = nv

In acqua l'indice di rifrazione è circa 1.33 (varia con la lunghezza d'onda),

abbiamo ottenuto quindi la relazione tra l'angolo misurato θ e la velocità della

particella v.
9 1.5. IL PROBLEMA DELLA COMUNICAZIONE

1.5 Il problema della comunicazione

I segnali provenienti dal fotomoltiplicatore sono trasformati in numero da

un ADC a 200Msample/s a 8 bit, qui entrerebbe in gioco la mia scheda

funzionando da discriminatore di carica per eliminare gli zeri e i valori troppo

bassi.

Considerando che ci sono 5832 moduli ottici, se si dovesse decidere di

trasmettere tutti i risultati dei campionamenti, compresi gli zeri, la necessità

di banda per ogni singolo canale sarebbe di 8 bit x 200 x 106 s−1 = 1.6 Gb/s.

In questo caso la necessità di banda totale per 5832 rivelatori sarebbe di 1.6

Gb/s x 5832 = 9.3 Tb/s, carico trasmissivo molto impegnativo. Se si decide

invece di scartare gli zeri e trasmettere solo i campioni signicativi tenendo

conto del rumore di fondo generato dalla disintegrazione spontanea del 40

K
presente nel sale marino; otterremo un numero perfettamente compatibile

per le moderne tecnologie che permettono già ora un trasferimento di circa

1 Tb/s per bra.

Capitolo 2

Field Programmable Gate Arrays

(FPGA)

2.1 Introduzione
L'FPGA è un potente strumento nell'ambito dell'elettronica digitale, con-

sente di realizzare circuiti piuttosto complessi e veloci in poco spazio e

con prestazioni eccellenti, riducendo inoltre i costi di produzione. Per

queste caratteristiche ha un ruolo importante anche nell'ambito scientico

in quanto ogni esperimento richiede un'elettronica dedicata e alta velocità di

funzionamento.

Oltre le dierenze di architettura gli FPGA si dividono in due tipi fonda-

mentali: i primi sono quelli che possono essere programmati una volta sola

(in genere hanno dimensioni ridotte), gli altri possono essere programmati

più volte (ma perdono la congurazione ogni volta che si spegne il dispositi-

vo). Nel secondo caso è necessaria una sequenza di bit, detto bitstream, per

10
11 2.1. INTRODUZIONE

programmare il dispositivo. Tale sequenza viene generalmente scritta in una

memoria di sola lettura tipo PROM.

Con il passare degli anni gli FPGA sono stati migliorati in complessità

e prestazioni, tuttavia il principio costitutivo di base è rimasto invariato.

Possiamo ritenere il dispositivo come una scatola contenente le seguenti

cose:

• Congurable logic block (CLB): Ognuno di questi blocchi una

volta programmato costituisce un circuito digitale combinatorio1 o

sequenziale2

• Input/Output Box (IOB): Sono dei blocchi localizzati sul perimetro

del dispositivo e collegano i pin con la logica interna, servono quindi

ad interfacciare l'FPGA con eventuali periferiche esterne come display,

porte di comunicazione, ecc.

• Linee di interconnessione: Sono utilizzate per collegare i CLB tra loro

o con gli IOB

1 Le
uscite del circuito sono funzioni solo degli ingressi
2 Le
uscite sono funzioni anche dello stato in cui si trova il sistema, per funzionare
richiede memoria ed un clock
CAPITOLO 2. FIELD PROGRAMMABLE GATE ARRAYS (FPGA) 12

Figura 2.1: Schema illustrativo dei blocchi di un FPGA

L'FPGA da me utilizzato è un Virtex-4 prodotto dalla Xilinx ed appar-

tiene alla famiglia XC4000, in questo capitolo vediamo in dettaglio le carat-

teristiche di questi dispositivi ed inne come è strutturato il microprocessore

MicroBlaze utilizzato in questo progetto.

2.2 Congurable logic block (CLB)

Nella gura 2.2 vediamo lo schema di un CLB. Nella parte sinistra c'è la

parte combinatoria, ovvero le funzioni F'(F1,F2,F3,F4), G'(G1,G2,G3,G4) e

H'(F',G',H1), che permettono di realizzare funzioni no a cinque variabili.

Nella parte destra abbiamo due ip-op di tipo D con set, reset e counter
13 2.2. CONFIGURABLE LOGIC BLOCK (CLB)

Figura 2.2: schema elettronico di un CLB

enable (EC): i primi due vengono usati per settare le uscite dei ip-op a

0 o 1, l'EC per bloccare lo stato del ip-op. L'ingresso dei ip-op può

venire dalla parte combinatoria o dall'esterno tramite l'input DIN. Una serie

di multiplexer programmati dal bitstream ci permettono di realizzare le più

svariate combinazioni di questi elementi per la creazione di circuiti digitali.

Nel mio progetto ho creato nell'FPGA un contatore e un blocco di memo-

ria, i CLB della famiglia xc4000 sono stati migliorati per l'implementazione

di questo tipo di dispositivi.

CAPITOLO 2. FIELD PROGRAMMABLE GATE ARRAYS (FPGA) 14

Figura 2.3: dettaglio del carry out

2.2.1 Contatore

Nel caso si vogliano creare dei contatori, lo scambio dei riporti tra i CLB

avviene tramite la linea COUT. Sono presenti due funzioni logiche combi-

natorie per il calcolo del riporto, unite ad un multiplexer programmabile

(Figura 2.3).

2.2.2 On-chip RAM

I CLB possono essere usati come memorie RAM contenenti no a 64 bit. Gli

ingressi F1...F4 e G1...G4 vengono usati come indirizzi, quindi no ad un

massimo di 28 locazioni ad un bit.

Nella gura 2.4 possiamo vedere una congurazione a 16 locazioni x 2 bit.

Le linee di ingresso dati sono DIN e H1, quelle di uscita corrispondo a quelle

dei blocchi F' e G'. La linea S/R diventa il write enable.

15 2.3. INTERCONNESSIONI

Figura 2.4: dettaglio del CLB in congurazione RAM

2.3 Interconnessioni
La connessione tra i vari blocchi avviene attivando degli interruttori che

uniranno tra loro le varie linee di collegamento. Tali linee possono essere

di tipo diretto (DI) per far comunicare blocchi vicini velocizzando la logica,

oppure linee lunghe usate per portare segnali in tutto il chip (ad esempio il

clock). L'FPGA in uso ha quattro linee globali veloci, utilizzate per segnali

come il clock, la cui fase deve rimanere piuttosto invariata. In più vi sono

altre quattro linee globali secondarie che presentano sfasamenti. Queste linee

principali e secondarie sono guidate da dei buers eventualmente collegati a

dei pin posti negli angoli dell'FPGA (Figura 2.5. Nella gura 2.6 possiamo

vedere in dettaglio la matrice di interruttori (detti PIP) che collega le linee

globali a quelle dedicate al trasferimento dei segnali ai blocchi CLB.

CAPITOLO 2. FIELD PROGRAMMABLE GATE ARRAYS (FPGA) 16

Figura 2.5: In questa gura si pos-

sono vedere le linee globali ed il loro Figura 2.6: Dettaglio della matrice di
collegamento ai pin interruttori

2.4 Input/Output Block (IOB)

I blocchi IOB sono usati per interfacciare segnali esterni, sono quindi dotati

di resistenze di pull-up/pull-down e convertitori di logica. Sono dotati di

ip-op per la sincronizzazione e possono essere settati come solo uscita, solo

ingresso oppure bidirezionale.

17 2.5. MICROBLAZE

Figura 2.7: Blocco di Input/Output

2.5 MicroBlaze
MicroBlaze è un microprocessore open source3 che ho utilizzato in questo

progetto per poter eseguire un programma. É un processore ad istruzioni

limitate (RISC: Reduced Instruction Set Computer), ma più che suciente

per il mio scopo.

Nella gura 2.8 possiamo notare:

• 32 registri a 32 bit: utilizzabili per scopi generici

• registri speciali

• la parte computazionale: costituita da ALU (Unità aritmetico-

logica), FPU (Floating-Poin Unit, per il calcolo in virgola mobile),

moltiplicatori, divisori e shift

3 il suo codice VHDL può essere utilizzato e modicato da tutti
CAPITOLO 2. FIELD PROGRAMMABLE GATE ARRAYS (FPGA) 18

Figura 2.8: schema a blocchi del MicroBlaze

• due bus separati a 32 bit: per gli indirizzi e i dati si usano bus divisi
(architettura Harvard)

La cosa fondamentale da tenere sempre presente durante la program-

mazione è che per i dati si usa la codica Big-Endian, ovvero le cifre dei

numeri sono invertite.

Per comunicare con le periferiche il MicroBlaze utilizza dei bus sui quali

mandare i segnali. Dei vari tipi di bus quello utilizzato in questo progetto è

il bus OPB (On-chip peripheral Bus).

Tale bus è costituito da una serie di OR che collegano tra loro le varie

linee, le periferiche non coinvolte durante un trasferimento dati devono avere

le uscite settate a zero. L'architettura del bus è di tipo master-slave guidato

da un arbiter (Figura 2.9).

La gestione del trasferimento dati da parte dell'arbiter avviene in questa

sequenza:

1. Una periferica master invia il segnale di accesso al bus

19 2.5. MICROBLAZE

Figura 2.9: Schema del bus OPB

2. L'arbiter garantisce l'accesso a seconda della priorità delle periferiche

master

3. Durante i cicli successivi avviene il trasferimento dati

Capitolo 3

Progetto

3.1 Introduzione
Lo scopo di questo progetto è quello di limitare la quantità di dati da trasmet-

tere facendoli ltrare da un programma nel quale viene impostata una soglia

per distinguere i numeri validi da quelli dovuti al rumore.

Per simulare il funzionamento della scheda è stato implementato un

hardware nell'FPGA capace di generare numeri casuali a 16 bit alla frequenza

di circa 100KHz.

Il programma raccoglie 200 campioni, memorizzandoli e selezionandoli. I

dati selezionati vengono scritti in un'altra zona della memoria e alla ne viene

inviato tutto tramite porta seriale. In un funzionamento normale la memo-

rizzazione non sarebbe necessaria, i dati verrebbero inviati immediatamente

dopo la selezione.

Nel seguente schema a blocchi viene presentato il progetto nei vari

componenti, la spiegazione viene lasciata alle prossime sezioni.

20
21 3.2. SCHEDA ELETTRONICA

Figura 3.1: Schema a blocchi del progetto

3.2 Scheda elettronica

L'FPGA utilizzato è un Virtex 4 della Xilinx montato su una scheda dalla

Memec insieme a diverse periferiche di input/output. Di queste sono state

utilizzate le seguenti:

Porta di comunicazione seriale RS232 : Una porta low-speed che uti-

lizza un cavo a 9 pin per la trasmissione dei segnali tra la scheda e un

pc

Display LCD : Un display a cristalli liquidi con un input di 10 bit, 2 per

il controllo e 8 per la scrittura dei caratteri

Quattro LED : 2 Led verdi e 2 Rossi usati per indicare lo stato della scheda
CAPITOLO 3. PROGETTO 22

Un blocco di memoria RAM 32M x 16 bit : per la memorizzazione

dei dati

Oltre a queste sono state istanziate nell'FPGA altre periferiche:

Un blocco di memoria da 32KB : Questo blocco di memoria è usato per

la memorizzazione del programma

Un contatore a 10bit : Per dividere la frequenza del sistema, di 100 MHz,

per 1024, rallentando il simulatore a circa 100KHz

Un Linear Feedback Shift Register a 16 bit : Per generare numeri ca-

suali allo scopo di simulare un dato in arrivo da un ADC

Un Microprocessore MicroBlaze : Per il controllo delle periferiche e

l'esecuzione del programma (scritto in linguaggio C)
23 3.3. SIMULATORE

Figura 3.2: Immagine della scheda Memec utilizzata per il progetto

3.3 Simulatore
Come già detto il simulatore è costituito da un contatore e da un Linear Feed-

back Shift Register (LFSR). Esso può essere resettato, attivato e disattivato

dal programma.

Il clock di sistema è di 100MHz, pertanto è stato usato un contatore a

10bit per far si che il generatore di numeri casuali lavori ad una frequen-

za inferiore (ovvero 100KHz), facendo in modo che il segnale in uscita del

contatore venga usato come Enable.

CAPITOLO 3. PROGETTO 24

L'LFSR è una macchina di Moore1 che produce una lunga sequenza di

numeri casuali a partire da uno scelto detto seed.

Figura 3.3: schema elettrico indicativo di un LFSR a 16 bit

Come possiamo vedere da questo schema elettronico (gura 3.3), un nu-

mero in uscita viene riportato in ingresso con il cambiamento di alcuni bit da

parte delle porte logiche Xor. Il dispositivo si comporta come un contatore

da 1 a 65535 ma a sequenza casuale (il numero 0 non può essere usato come

seed in quanto bloccherebbe il contatore).

Il punto di inizio del simulatore è il contatore a 10 bit che dopo 1024 colpi

di clock manda un segnale alto della durata di 20 ns all'LFSR e al MicroBlaze.

L'arrivo di tale segnale genererà un interrupt che porterà il programma nello

stato di acquisizione, l'LFSR cambierà stato e il numero verrà memorizzato

e controllato.

Riporto di seguito i codici VHDL del contatore e dell'LFSR e i risultati

delle simulazioni.

1 Un automa a stati niti le cui uscite sono funzioni esclusivamente dello stato in cui si
trova. Inoltre lo stato iniziale deve essere denito.
25 3.3. SIMULATORE

Figura 3.4: VHDL Contatore

Figura 3.5: VHDL LFSR

Figura 3.6: Si può qui vedere il segnale della durata di 20 ns generato dal
contatore ogni 10240 ns. C'è un ritardo di 100 ns a causa di un reset iniziale
CAPITOLO 3. PROGETTO 26

Figura 3.7: Transazione del linear feedback shift register quando riceve il
segnale di enable dal contatore

3.4 Computer Aided Design (CAD)

Sono due i CAD utilizzati in questo progetto, entrambi forniti dalla Xilinx:

ISE e EDK. Il primo consente di generare il bitstream e scriverlo sull'FPGA

o su una PROM a partire da un codice VHDL o altro. Il secondo invece ci

permette di congurare il MicroBlaze inserendo controllori per le periferiche,

bus o altro.

In questo progetto in particolar modo sono state aggiunte tutte le per-

iferiche esterne nominate in precedenza, compreso il gestore dell'interrupt, e

inne sono stati congurati i collegamenti con il bus, gli indirizzi e i gestori

delle periferiche.

Nelle gure 3.8 e 3.9 possiamo vedere il collegamento con i bus e la

struttura del progetto in ISE.

27 3.4. COMPUTER AIDED DESIGN (CAD)

Figura 3.9: schema del progetto ISE

Figura 3.8: EDK: lista delle periferiche
e loro collegamento con i bus

I bus LMB (Local Memory Bus) sono due per il tipo di architettura del

MicroBlaze, comunicano velocemente con i gestori della memoria (quest'ul-

tima viene creata nell'FPGA). Poichè non è richiesta una comunicazione

molto veloce con la memoria RAM on-board, quest'ultima è stata collegata

al bus OPB. Nella seconda gura possiamo invece notare che un le VHDL

(Top_level) collega tra loro il MicroBlaze, il contatore a 10 bit e l'LFSR.

L'ultimo le, con estensione .ucf, contiene informazioni sull'utilizzo dei pin

esterni.

A partire dal le VHDL seguono diversi processi per la creazione del

bitstream utilizzato per la programmazione dell'FPGA:

1. Synthesize: in questo passo viene controllata la sintassi e il codice

viene tradotto in una serie di porte logiche di base e ip-op, viene

creato un netlist.

2. Translate: Il netlist viene tradotto in un codice standard della Xilinx

CAPITOLO 3. PROGETTO 28

(NGD). Vengono eettuati controlli sul timing (se richiesti) e vengono

applicate delle regole base di disegno.

3. Map: Durante questa fase avviene la suddivisione della logica del

progetto in sottoinsiemi ricostruibili nei singoli CLB, senza però che

essi sia collocati.

4. Place and Route: Ai CLB creati nella fase precedente viene data una

collocazione sica nell'FPGA. Il primo CLB viene posto a caso, quindi

una ripetizione del processo porterebbe ad un risultato diverso. Inne

vengono programmati i PIP, le Switch Matrix e i driver buers per

collegare i vari blocchi.

5. Generate: Questa è la fase nale che porta la traduzione del progetto

nel le bitstream che può nalmente essere scritto sul dispositivo o su

ROM programmabile.
29 3.5. SOFTWARE

3.5 Software

Figura 3.10: Diagramma di usso del programma

CAPITOLO 3. PROGETTO 30

Ogni periferica ha uno o più registri che permettono al software di

controllarla tramite operazioni di scrittura o lettura su di essi.

All'avvio del programma come prima cosa vengono inizializzate le per-

iferiche: viene pulito il display, spenti i LED (tranne il rosso) e inizializzati i

puntatori ai registri delle periferiche da utilizzare. Come ultimo passo viene

congurato l'interrupt che avvia la routine di acquisizione.

Dopo l'inizializzazione il programma avvia la simulazione e attende i dati

in ingresso registrandoli in memoria no ad un limite opportunatamente

scelto (200 campioni).

Il simulatore scambia un segnale con il microprocessore per causare un

interrupt, quest'ultimo viene ricevuto dal programma e disattivato. Viene

poi iniziata la fase di acquisizione del numero proveniente dal simulatore e

inne viene riattivato l'interrupt.

Oltre ad essere memorizzato ogni numero viene confrontato con il valore

di soglia, i numeri superiori ad esso vengono registrati in un'altra zona della

memoria. Alla ne dell'operazione i dati registrati e quelli scelti vengono

trasmessi tramite la porta seriale.

Il programma è stato scritto in linguaggio C con l'aggiunta di librerie

fornite dalla Xilinx. Viene inoltre creata una libreria, xparameters.h, con le

informazioni delle periferiche utilizzate dal microprocessore.

3.5.1 Inizializzazione

Per inizializzare una periferica bisogna usare una funzione specica, la quale

inserisce informazioni sul registro e tipo di periferica in una variabile che può
31 3.5. SOFTWARE

essere usata in seguito per operazioni di scrittura o lettura. Operazioni che

possono essere eettuate con apposite funzioni.

Per il display è diverso in quanto c'è bisogno di uno strobe per convalidare

il dato ed un tempo di attesa per far si che i caratteri vengano scritti, riporto

lo pseudo-codice utilizzato:

1. scrittura del dato con strobe alto

2. breve attesa

3. scrittura dello stesso dato con strobe basso

4. attesa

Per il setup dell'interrupt si richiede invece qualche passaggio in più, ma

fondamentale è l'associazione tra il segnale ed una funzione che deve essere

eseguita alla sua ricezione.

3.5.2 Inizio del ciclo di registrazione

Il ciclo comincia con il controllo del numero di campioni registrati e viene

eseguito no al massimo valore impostato (200). A questo punto il program-

ma si interrompe mettendosi in uno stato d'attesa. All'arrivo del segnale di

interrupt viene attivato un ag2 che porta il programma a registrare il dato.

Per puro scopo di valutazione tutti i dati vengono registrati. Per memoriz-

zare un dato basta semplicemente passare il valore al puntatore all'indirizzo

della memoria. Nella stessa routine vengono confrontati i numeri con il valore

di soglia ed eventualmente registrati in un secondo punto della RAM.

2 Un segnale,
in questo caso il valore di una variabile, che diverse funzioni del programma
possono utilizzare per controllare le operazioni da eseguire
CAPITOLO 3. PROGETTO 32

Durante questa operazione gli interrupt sono disattivati per permettere

al microprocessore di funzionare senza interruzioni.

3.5.3 Risultati

È Riportato di seguito il risultato della simulazione:

33 3.5. SOFTWARE

Figura 3.11: Stampa dei 200 campioni acquisiti

CAPITOLO 3. PROGETTO 34

Figura 3.12: Numeri selezionati dal programma, la soglia impostata è 40,000

35 3.5. SOFTWARE

Conclusione
Ricapitolando in questa tesi sono state discusse le motivazioni che spin-

gono alla costruzione di un laboratorio sottomarino e le problematiche alle

quali si va incontro.

È stata valutata l'importanza del neutrino nello studio dell'Universo,

sono state elencate le sue caratteristiche e la tecnica di rilevazione usata

nell'esperimento NEMO.

Il cuore della tesi è l'analisi del problema della trasmissione dei dati ed

una possibile soluzione ad esso. La soluzione proposta dalla mia tesi riguarda

lo scarto del rumore dopo la conversione numerica eseguita dall'ADC posto

dopo il fotomoltiplicatore.

Il nucleo della scheda utilizzata è un FPGA, quindi è stata fatta una

descrizione accurata della sua struttura, del suo funzionamento e della

procedura di programmazione hardware e software.

Nel terzo capitolo ho spiegato i vari passi del progetto, tuttavia ci tengo

a far capire che, per quanto possa sembrare semplice, è stato piuttosto arduo

da portare a termine per mancanza di manuali ed esempi idonei. Per non

parlare poi del mancato funzionamento del debug module (MDM) che mi ha

obbligato ad un lungo debug manuale del programma.

Nonostante tutte le dicoltà ho portato a termine il mio progetto con

successo e spero possa essere in qualche modo di aiuto a chi voglia cimentarsi

nella programmazione di FPGA con microprocessori integrati. A tale scopo

allego in appendice il codice sorgente del mio programma.

CAPITOLO 3. PROGETTO 36

Appendice
Codice sorgente del programma (Linguaggio c)

#include <stdio.h>
#include <stdlib.h>
#include <xgpio.h>
#include <xintc.h>
#include <xbasic_types.h>
#include <xstatus.h>
#include d:\oscar\progetto_irq\microblaze_0\include\xparameters.h
//

//- Dichiarazione variabili globali -

#dene lcd_delay 100000 //1ms circa
Xuint16 n_campioni = 200; Xuint16 soglia = 40000;
XIntc Intc;
static Xuint16 GlobalIntrMask; static volatile Xuint32 IntrFlag;
XGpio led_gpio,int_ack_gpio; Xuint32 *mem_add,*PRC_add;
//

// Dichiarazione funzioni 

static void xtoa (unsigned long val, char *buf, unsigned radix, int
is_neg);
void lcd_printf(char* frase, int clear);
void lcd_printi(int num,int clear);
void GpioDriverHandler(void *CallbackRef);
void GpioDriverHandler_ack(void *CallbackRef);
XStatus GpioSetupIntrSystem(XIntc* IntcInstancePtr, XGpio* InstancePtr,
Xuint16 DeviceId, Xuint16 IntrId, Xuint16 IntrMask);
void GpioDisableIntr(XIntc* IntcInstancePtr, XGpio* InstancePtr,
Xuint16 IntrId, Xuint16 IntrMask);
void stampa_campioni(Xuint32 selezionati);
void acquisizione_dati(Xuint32 *contatore,Xuint32 *selezionati);
//-
int main() {
Xuint16 j, k;
Xuint32 i;
Xuint32 contatore=0, selezionati=0;
37 3.5. SOFTWARE

//inizializzazione LEDs
if (XGpio_Initialize(&led_gpio, XPAR_LEDS_4BIT_DEVICE_ID)
!= XST_SUCCESS)
{
xil_printf(\n\rErrore nell'inizializzazione dei LEDs);
exit(1);
}
XGpio_DiscreteWrite(&led_gpio, 1, 11); //sono stati spenti i LED
tranne il secondo (rosso)
//inizializzazione LCD;
if (XGpio_Initialize(&int_ack_gpio, XPAR_LCD_DEVICE_ID) !=
XST_SUCCESS) //utilizzo il puntatore int_ack per non sprecare
memoria
{
xil_printf(\n\rErrore nell'inizializzazione del display);
exit(1);
}
XGpio_DiscreteWrite(&int_ack_gpio, 1, 0x23f);
for(i=0;i<lcd_delay;i++);
XGpio_DiscreteWrite(&int_ack_gpio, 1, 0x3f); //impostati 8-bit
input
for(i=0;i<lcd_delay*300;i++);
lcd_printf(Soglia:\n, 1);
lcd_printi(soglia, 0);
// inizializzazione indirizzo memoria
mem_add = (Xuint32 *)XPAR_DDR_SDRAM_32MX16_MEM0_
BASEADDR;
//inizialiazzazione indirizzo di acquisizione
PRC_add = (Xuint32 *)XPAR_PRC_BASEADDR;
//inizializzazione periferica interrupt
if (XIntc_Initialize(&Intc, XPAR_OPB_INTC_0_ DEVICE_ID)
!= XST_SUCCESS)
{
xil_printf(\n\rErrore nell'inizializzazione della periferica interrupt);
exit(1);
}
//Inizializzazione interrupt sulla periferica usata come strobe
if (XGpio_Initialize(&int_ack_gpio, XPAR_INT_ACK_DEVICE_ID)
!= XST_SUCCESS)
{
xil_printf(\n\rErrore nell'inizializzazione della periferica int_ack);
CAPITOLO 3. PROGETTO 38

exit(1);
}
if (GpioSetupIntrSystem(&Intc, &int_ack_gpio, XPAR_INT_ACK_
DEVICE_ID, XPAR_OPB_INTC_0_INT_ACK_IP2INTC_IRPT_
INTR, 1) != XST_SUCCESS)
{
xil_printf(\n\rErrore nell'inizializzazione dell'interrupt per la perifer-
ica push_buttons);
exit(1);
}
//-
microblaze_enable_interrupts(); //attiva gli interrupt sul microblaze
XGpio_DiscreteWrite(&led_gpio, 1, 7); //acceso il primo LED (verde)
IntrFlag=0;
//avvio generatore di numeri casuali
PRC_add[0]=1;
//inizio stato di attesa interrupt
while(contatore<n_campioni)
{
while(!IntrFlag); //quando si riceve un interrupt si esce da questo ciclo
// Quando si riceve un interrupt questo viene disattivato durante la
procedura di acquisizione
if (IntrFlag)
{
XIntc_Acknowledge(&Intc, 0);
XIntc_Disable(&Intc, 0);
acquisizione_dati(&contatore, &selezionati);
XIntc_Enable(&Intc, 0);
}
IntrFlag=0; //il ag di interrupt viene azzerato
} //ne while(contatore) //il programma raccoglie 200 campioni
// Disattivazione degli interrupt 
GpioDisableIntr(&Intc, &int_ack_gpio, XPAR_OPB_INTC_0_PUSH_
BUTTONS_3BIT_IP2INTC_IRPT_INTR, 1);
GpioDisableIntr(&Intc, &int_ack_gpio, XPAR_OPB_INTC_0_INT_ACK_
IP2INTC_IRPT_INTR, 1);
XGpio_DiscreteWrite(&led_gpio, 1, 11); //acceso di nuovo il LED
rosso
// Stampa dei risultati -
stampa_campioni(selezionati);
39 3.5. SOFTWARE

return 0;
} //ne main
// FUNZIONI -
//
// funzione GpioSetupIntrSystem 
//
// Funzione che attiva l'interrupt sulla periferica con:
// indirizzo di base del registro: InstancePtr
// indirizzo dell'interrupt: IntcInstancePtr
// ID di dispositivo: DeviceId
// ID di interrupt della periferica: IntrID
// IntrMask è il canale, in genere è 1
XStatus GpioSetupIntrSystem(XIntc* IntcInstancePtr, XGpio* InstancePtr,
Xuint16 DeviceId, Xuint16 IntrId, Xuint16 IntrMask)
{
XStatus Result;
GlobalIntrMask = IntrMask; //viene memorizzato come variabile
globale per un'altra funzione
/* Associa la funzione GpioDriverHandler all'interrupt della periferi-
ca*/
Result = XIntc_Connect(IntcInstancePtr, IntrId, (XInterruptHandler)GpioDriverHandler,
InstancePtr);
if (Result != XST_SUCCESS)
{
xil_printf(\n\rErrore sull'attivazione dell'interrupt);
exit(1);
}
/* vengono ora attivati gli interrupt della periferica Gpio*/
XGpio_InterruptEnable(InstancePtr, IntrMask);
XGpio_InterruptGlobalEnable(InstancePtr);
/* viene attivato l'interrupt sull'interrupt controller */
XIntc_Enable(IntcInstancePtr, IntrId);
Result = XIntc_Start(IntcInstancePtr, XIN_REAL_MODE);
if (Result != XST_SUCCESS)
{
xil_printf(\n\rErrore sull'attivazione dell'interrupt);
exit(1);
}
return XST_SUCCESS;
}
//-
CAPITOLO 3. PROGETTO 40

//

//- funzione GpioDriverHandler -

//
// la funzione viene eseguita alla ricezione di un interrupt
void GpioDriverHandler(void *CallbackRef)
{
XGpio *GpioPtr = (XGpio *)CallbackRef;
IntrFlag = 1; //cambio il valore del ag per indicare che è stato
ricevuto l'interrupt
// Il segnale di interrupt viene azzerato
XGpio_InterruptClear(GpioPtr, GlobalIntrMask);
}
//

// funzione GpioDisableIntr -

// funzione usata per disattivare l'interrupt una volta acquisito
void GpioDisableIntr(XIntc* IntcInstancePtr,XGpio* InstancePtr,Xuint16
IntrId,Xuint16 IntrMask)
{
XGpio_InterruptDisable(InstancePtr, IntrMask);
XIntc_Disable(IntcInstancePtr, IntrId);
}
//

//- funzione acquisizione_dati() 

//
// Quando arriva un dato viene eseguita questa funzione che lo registra
nella zona di memoria A e se supera la
// soglia lo registra anche nella zona di memoria B
//
// Le zone A e B della memoria sono state predisposte per ottenere
200 campioni, ma il limite massimo è quello
// di saturazione del blocco di memoria
void acquisizione_dati(Xuint32 *contatore,Xuint32 *selezionati)
{
Xuint32 i,j;
i=*contatore;
j=*selezionati;
//acquisizione di un numero nella zona iniziale della memoria
mem_add[i]=PRC_add[2];//XIo_In32(PRC_add[2]);
41 3.5. SOFTWARE

//scarto dei numeri inferiori alla soglia

if (mem_add[i]>soglia)
{
mem_add[n_campioni+1+j]=mem_add[i];
j++;
}
i++;
*contatore=i; //contatore è stato aumentato di 1
selezionati=j; //selezionati viene aumentato solo se il numero è
superiore alla soglia
}
//

//- funzione stampa_campioni 

void stampa_campioni(Xuint32 selezionati)
{
int i;
// stampa dei campioni acquisiti
xil_printf(\n Numeri acquisiti: \n\n\r);
for (i=0;i<n_campioni;i++)
{
xil_printf(%d) %d\t,i+1,mem_add[i]);
if ( ((i+1)%4) == 0) xil_printf(\n\r); //vado a capo dopo 4 colonne
}
//stampa selezione
xil_printf(\n\n Numeri selezionati: \n\n\r);
for (i=n_campioni+1;i<selezionati+n_campioni+1;i++)
{
xil_printf(%d) %d\t,(i-n_campioni),mem_add[i]);
if ( ((i-n_campioni)%4) == 0) xil_printf(\n\r);
}
}
//

// lcd_printf 

//
// Funzione per scrivere una stringa sul display
//
// frase: è la stringa da scrivere, uno \n è riconosciuto come un ritorno
a capo, poichè
// il display è a due righe un altro \n verrà scartato non sono ammessi
ritorni di
CAPITOLO 3. PROGETTO 42

// linea e tabulazioni
//
// clear: 1 pulisce il display prima di scrivere
void lcd_printf(char* frase, int clear)
{
int i,tempo;
XGpio address;
if (XGpio_Initialize(&address, XPAR_LCD_DEVICE_ID) != XST_SUCCESS)
//inizializzazione periferica
{
xil_printf(Errore di inizializzazione display\n\r);
exit(1);
}
if (clear==1)
{
XGpio_DiscreteWrite(&address,1,1 | (19));
for(tempo=0;tempo<lcd_delay;tempo++);
XGpio_DiscreteWrite(&address,1,1); //clear eettuato
for(tempo=0;tempo<lcd_delay*300;tempo++);
XGpio_DiscreteWrite(&address,1,0xc | (19));
for(tempo=0;tempo<lcd_delay;tempo++);
XGpio_DiscreteWrite(&address,1,0xc); //display on
for(tempo=0;tempo<lcd_delay*300;tempo++);
}
for (i=0;i<strlen(frase);i++)
{
switch(frase[i])
{
case '\n':
XGpio_DiscreteWrite(&address,1,0x2a8);
for(tempo=0;tempo<lcd_delay;tempo++);
XGpio_DiscreteWrite(&address,1,0xa8); //seconda riga
for(tempo=0;tempo<lcd_delay*10;tempo++);
break;
case '\t': xil_printf(Errore, tabulazioni non supportate dal display\n\r);
exit(1);
case '\r': break;
default:
XGpio_DiscreteWrite(&address, 1,frase[i]| 0x300);
for(tempo=0;tempo<lcd_delay;tempo++);
XGpio_DiscreteWrite(&address, 1,frase[i] | 0x100); //scritto il carat-
tere sul display
43 3.5. SOFTWARE

for(tempo=0;tempo<lcd_delay*10;tempo++);
} //ne switch (frase[i])
} //ne for (i)
}
//-
// funzione xtoa 
//
// Converte il numero val in stringa, associando il valore a buf, la
conversione avviene in base radix
// Se il numero è negativo is_neg deve essere uguale ad 1
static void xtoa (unsigned long val, char *buf, unsigned radix, int
is_neg)
{
char *p; /* pointer to traverse string */
char *rstdig; /* pointer to rst digit */
char temp; /* temp char */
unsigned digval; /* value of digit */
p = buf;
if (is_neg)
{
/* negative, so output '-' and negate */
p++ = '-';
val = (unsigned long)(-(long)val);
}
rstdig = p; /* save pointer to rst digit */
do
{
digval = (unsigned) (val
val /= radix; /* get next digit */
/* convert to ascii and store */
if (digval > 9)
p++ = (char) (digval - 10 + 'a'); /* a letter */
else
p++ = (char) (digval + '0'); /* a digit */
} while (val > 0);
/* We now have the digit of the number in the buer, but in reverse
order. Thus we reverse them now. */
*p = '\0'; /* terminate string; p points to last digit */
do
{
CAPITOLO 3. PROGETTO 44

temp = *p;
p = *rstdig;
rstdig = temp; /* swap *p and *rstdig */
p;
++rstdig; /* advance to next two digits */
} while (rstdig < p); /* repeat until halfway */
}
//-
// funzione lcd_printi 
//
// Funzione per scrivere un numero sul display
//
// num è il numero da scrivere, la base è ssata a 10
// clear deve essere 1 se si vuole pulire il display
void lcd_printi(int num,int clear)
{
int i,tempo;
char frase[33];
XGpio address;
if (XGpio_Initialize(&address, XPAR_LCD_DEVICE_ID) != XST_SUCCESS)
{
xil_printf(Errore di inizializzazione display\n\r);
exit(1);
}
if (clear==1)
{
XGpio_DiscreteWrite(&address,1,1 | (19));
for(tempo=0;tempo<lcd_delay;tempo++);
XGpio_DiscreteWrite(&address,1,1); //clear eettuato
for(tempo=0;tempo<lcd_delay*150;tempo++);
XGpio_DiscreteWrite(&address,1,0xc | (19));
for(tempo=0;tempo<lcd_delay;tempo++);
XGpio_DiscreteWrite(&address,1,0xc); //display on
for(tempo=0;tempo<lcd_delay*150;tempo++);
}
xtoa(num,frase,10,0); //conversione del numero in stringa
if (frase != NULL)
{
for(i=0;i<strlen(frase);i++)
{
XGpio_DiscreteWrite(&address, 1, frase[i] | 0x300);
45 3.5. SOFTWARE

for(tempo=0;tempo<lcd_delay;tempo++);
XGpio_DiscreteWrite(&address, 1,frase[i] | 0x100); //scrittura delle
cifre
for(tempo=0;tempo<lcd_delay*10;tempo++);
}
}
else
{
xil_printf(Errore, il numero inserito non è valido\n\r);
exit(1);
}
}
//