Deﬁnizione, progetto VHDL-RTL e realizzazione tramite FPGA ... · Universita di Roma Tor Vergata...

Universita di Roma Tor Vergata - Facolta di IngegneriaDipartimento di Elettronica Digitale

Definizione, progetto VHDL-RTL e realizzazionetramite FPGA di un modulatore QPSK con

sagomatura di impulso a coseno rialzatoa sintesi diretta

RelatoreCh. mo Prof.Giancarlo Cardarilli

CorrelatoreIng.Marco Re

Correlatore Tesi di laurea diIng. Antonio D’OttavioDomenico Giancristofaro matr. II009409

Anno Accademico 2000-2001

Indice

Elenco delle figure vi

1 Modulazioni digitali 31.1 Sommario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.2 Modulazione . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

1.2.1 Traslazione in frequenza . . . . . . . . . . . . . . . . . 41.2.1.1 Spazio dei segnali . . . . . . . . . . . . . . . 61.2.1.2 Tipologie di modulazioni satellitari . . . . . 6

1.3 Principi di demodulazione . . . . . . . . . . . . . . . . . . . . 121.3.1 Demodulatore . . . . . . . . . . . . . . . . . . . . . . . 121.3.2 Decisore . . . . . . . . . . . . . . . . . . . . . . . . . . 141.3.3 Interferenza intersimbolica . . . . . . . . . . . . . . . . 171.3.4 Principi di codifica . . . . . . . . . . . . . . . . . . . . 211.3.5 Capacita trasmissiva . . . . . . . . . . . . . . . . . . . 23

2 Architetture modulatori QPSK 262.1 Sommario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262.2 Realizzazioni digitali di modulatori QPSK . . . . . . . . . . . 27

2.2.1 Modulatore DDFS . . . . . . . . . . . . . . . . . . . . 272.2.2 Modulatore classico . . . . . . . . . . . . . . . . . . . 28

2.2.2.1 Modulatore classico con fclk = 4× fif . . . . 30

3 Implementazione SRRC polifase 333.1 Sommario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333.2 Progetto del filtro SRRC . . . . . . . . . . . . . . . . . . . . . 333.3 Implementazione polifase SRRC . . . . . . . . . . . . . . . . . 35

3.3.1 Modello Matlab . . . . . . . . . . . . . . . . . . . . . . 353.4 Modello VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . 37

3.4.1 Polifase standard gated-clock . . . . . . . . . . . . . . 373.4.1.1 SRRCxN . . . . . . . . . . . . . . . . . . . . 373.4.1.2 Rate Adapter . . . . . . . . . . . . . . . . . . 393.4.1.3 Risultati sperimentali . . . . . . . . . . . . . 40

3.4.2 ROM Polifase clock-enable . . . . . . . . . . . . . . . . 40

i

3.4.2.1 Risultati sperimentali . . . . . . . . . . . . . 42

4 Implementazione Modulatore QPSK 444.1 Sommario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444.2 Modello Matlab . . . . . . . . . . . . . . . . . . . . . . . . . . 444.3 Modelli VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . 47

4.3.1 Modulatore classico . . . . . . . . . . . . . . . . . . . 474.3.2 ThinModulator . . . . . . . . . . . . . . . . . . . . . . 49

4.3.2.1 Risultati sperimentali . . . . . . . . . . . . . 534.3.2.1.1 Test VHDL . . . . . . . . . . . . . . 534.3.2.1.2 Test FPGA . . . . . . . . . . . . . . 54

5 Conclusioni 58

A Sintesi diretta di frequenza digitale 59A.1 Sommario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59A.2 DDFS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59A.3 Pianificazione delle frequenze . . . . . . . . . . . . . . . . . . 61

A.3.1 Spurie dovute al DAC . . . . . . . . . . . . . . . . . . 61A.3.2 Spurie dovute al troncamento della fase . . . . . . . . 62

A.4 Convertitore Fase-Frequenza . . . . . . . . . . . . . . . . . . . 63A.4.1 Algoritmo CORDIC . . . . . . . . . . . . . . . . . . . 64

A.5 Descrizione modello matematico . . . . . . . . . . . . . . . . 65A.6 Descrizione modello VHDL . . . . . . . . . . . . . . . . . . . 66

B Sistemi Multirate 71B.1 Sommario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71B.2 Downsampling e Upsampling . . . . . . . . . . . . . . . . . . 71B.3 Architetture Multirate . . . . . . . . . . . . . . . . . . . . . . 74

B.3.1 CIC . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75B.3.2 Polifase . . . . . . . . . . . . . . . . . . . . . . . . . . 78

C Logiche programmabili 81C.1 Sommario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81C.2 Tipologie di logiche programmabili . . . . . . . . . . . . . . . 81C.3 Architettura Virtex . . . . . . . . . . . . . . . . . . . . . . . . 83

C.3.1 CLB . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83C.3.2 IOB . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85C.3.3 Risorse di connessione . . . . . . . . . . . . . . . . . . 86C.3.4 Circuiti di utilita . . . . . . . . . . . . . . . . . . . . . 86

C.3.4.1 DLL . . . . . . . . . . . . . . . . . . . . . . . 87C.3.4.2 BlockRAM . . . . . . . . . . . . . . . . . . . 87C.3.4.3 SRL16 . . . . . . . . . . . . . . . . . . . . . 88

ii

D Flusso di progettazione 89D.1 Sommario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89D.2 Modello Matematico . . . . . . . . . . . . . . . . . . . . . . . 89D.3 Modello VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . 89D.4 Sintesi del progetto . . . . . . . . . . . . . . . . . . . . . . . . 90D.5 Mappatura . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90D.6 Piazzamento delle risorse . . . . . . . . . . . . . . . . . . . . 91D.7 Connessione delle risorse . . . . . . . . . . . . . . . . . . . . . 91D.8 Simulazione back-annotata . . . . . . . . . . . . . . . . . . . 91D.9 Programmazione della FPGA . . . . . . . . . . . . . . . . . . 91D.10 Verifica sperimentale . . . . . . . . . . . . . . . . . . . . . . . 92

E Listati Matlab 93E.1 NCO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93

NCO Q.m . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93Imposta frequenze Q.m . . . . . . . . . . . . . . . . 94Imposta NCO Q.m . . . . . . . . . . . . . . . . . . . 94Crea super accumulatore Q.m . . . . . . . . . . . . 94Tronca Q.m . . . . . . . . . . . . . . . . . . . . . . . 94Crea coseno e seno Q.m . . . . . . . . . . . . . . . 95Forward cordic Q.m . . . . . . . . . . . . . . . . . . 96

Calcola rotazioni Cordic.m . . . . . . . . . . 96Visualizza spettro e SFDR p.m . . . . . . . 96

Calcola SFDR.m . . . . . . . . . . . . . . . . . . . . 97Calcola incremento fase NCO.m . . . . . . . . . . . . . . . 97Visualizza spettro NCO VHDL.m . . . . . . . . . . . . . . 97

E.2 Creazione vettori di test . . . . . . . . . . . . . . . . . . . . . 97CreaVettoriTest.m . . . . . . . . . . . . . . . . . . . . . . . . 98CreaSequenzaPatternGenerator.m . . . . . . . . . . . . . . . 100

E.3 Polifase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100Creazione coefficienti . . . . . . . . . . . . . . . . . . . . . . . 100

CreaCoeffsFreqSamplScaled.m . . . . . . . . . . . . . 101applica polifase.m . . . . . . . . . . . . . . . . . . . . 102RaisedCosineResponse.m . . . . . . . . . . . . . . . . 102CreaROM.m . . . . . . . . . . . . . . . . . . . . . . . 103

Test VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104PolyphasePSDVHDLvsPSDMatlab.m . . . . . . . . . 105

applica polifase.m . . . . . . . . . . . . . . . . 105Test FPGA . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

VisualizzaPSDPolifaseVHDLFPGAout.m . . . . . . . 106applica polifase.m . . . . . . . . . . . . . . . . 106

E.4 Modulatore . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106Tabella e grafico BER . . . . . . . . . . . . . . . . . . . . . . 106

CreaTabellaBER.m . . . . . . . . . . . . . . . . . . . . 107

iii

calcolaBER.m . . . . . . . . . . . . . . . . . . . 108Test VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

QPSKModemPSDeBERVHDLvsMatlab.m . . . . . . . 112applica polifase.m . . . . . . . . . . . . . . . . 112

Test FPGA . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112QPSKModemPSDFPGAvsPSDMatlab.m . . . . . . . 113

applica polifase.m . . . . . . . . . . . . . . . . 114

F Listati VHDL 115nco.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116

accumulator.vhd . . . . . . . . . . . . . . . . . . . . . . . . . 117cordic pipelined unrolled.vhd . . . . . . . . . . . . . . . . . 120

cordic base j.vhd . . . . . . . . . . . . . . . . . . . . 121adder 12.vhd . . . . . . . . . . . . . . . . . . . 121adder 13.vhd . . . . . . . . . . . . . . . . . . . 122reg 12.vhd . . . . . . . . . . . . . . . . . . . . 122reg 13.vhd . . . . . . . . . . . . . . . . . . . . 122shifter.vhd . . . . . . . . . . . . . . . . . . . . . 123

cosine rebuild.vhd . . . . . . . . . . . . . . . . . . . . . . . . 123delay 13.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . 123sine rebuild.vhd . . . . . . . . . . . . . . . . . . . . . . . . . 124to first quadrant.vhd . . . . . . . . . . . . . . . . . . . . . . 124troncatore 12.vhd . . . . . . . . . . . . . . . . . . . . . . . . 124

polyphase gatedClock.vhd . . . . . . . . . . . . . . . . . . . . . . 125srrc coeffs.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . 125rate adapter.vhd . . . . . . . . . . . . . . . . . . . . . . . . . 126

coeffs selector.vhd . . . . . . . . . . . . . . . . . . . . 130counter divider 3.vhd . . . . . . . . . . . . . . . . . 130counter divider 4.vhd . . . . . . . . . . . . . . . . . 131

fftr.vhd . . . . . . . . . . . . . . . . . . . . . . 131counter divider 6.vhd . . . . . . . . . . . . . . . . . 132selector.vhd . . . . . . . . . . . . . . . . . . . . . . . . 132

srrc x n.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . 136fir 1.vhd . . . . . . . . . . . . . . . . . . . . . . . . . 138

adder 7.vhd . . . . . . . . . . . . . . . . . . . 139fir multiplier.vhd . . . . . . . . . . . . . . . . 139shift reg.vhd . . . . . . . . . . . . . . . . . . . 139

mux 6.vhd . . . . . . . . . . . . . . . . . . . . . . . . 140ROM polyphase.vhd . . . . . . . . . . . . . . . . . . . . . . . . . 140

counter.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141srrc x n.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

demux 3x10.vhd . . . . . . . . . . . . . . . . . . . . . 143mux 3x12.vhd . . . . . . . . . . . . . . . . . . . . . . 143ROMx3.vhd . . . . . . . . . . . . . . . . . . . . . . . . 148

iv

ROMx4.vhd . . . . . . . . . . . . . . . . . . . . . . . . 153ROMx6.vhd . . . . . . . . . . . . . . . . . . . . . . . . 161shift reg.vhd . . . . . . . . . . . . . . . . . . . . . . . 162

Modulator BlockRAM.vhd . . . . . . . . . . . . . . . . . . . . . . 163adder I Q.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . 164counter.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164multiplier I Q.vhd . . . . . . . . . . . . . . . . . . . . . . . 164NCO basic.vhd . . . . . . . . . . . . . . . . . . . . . . . . . 165srrc x n.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . 166

ram.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . 166shift reg.vhd . . . . . . . . . . . . . . . . . . . . . . . 166

FIFO RAM ThinModulator.vhd . . . . . . . . . . . . . . . . . . 168counter.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168Data Source Interface.vhd . . . . . . . . . . . . . . . . . . . 169

asynch fifo 2x15.vhd . . . . . . . . . . . . . . . . . . 170ffd.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . 170ffd en.vhd . . . . . . . . . . . . . . . . . . . . . . . . 170ffs.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

ThinModulator.vhd . . . . . . . . . . . . . . . . . . . . . . . 172mult C2 adder.vhd . . . . . . . . . . . . . . . . . . . 173mux 2x7.vhd . . . . . . . . . . . . . . . . . . . . . . . 173ram 12x4096 rising registered.vhd . . . . . . . . . . 174shift reg.vhd . . . . . . . . . . . . . . . . . . . . . . . 174

G Acronimi 175

Bibliografia 178

Indice analitico 183

v

Elenco delle figure

1.1 Spettro segnale NRZ . . . . . . . . . . . . . . . . . . . . . . . 41.2 Spettro di un segnale in banda traslata . . . . . . . . . . . . . 41.3 Trasformata di Hilbert nel dominio della frequenza . . . . . . 51.4 Modulazione QPSK nel tempo . . . . . . . . . . . . . . . . . 81.5 Tipologie di QPSK . . . . . . . . . . . . . . . . . . . . . . . . 81.6 Confronto costellazioni M–QAM e M–PSK . . . . . . . . . . . 91.7 Andamento temporale BFSK . . . . . . . . . . . . . . . . . . 101.8 Andamento temporale fase del segnale MSK . . . . . . . . . . 111.9 Risposta all’impulso del filtro gaussiano . . . . . . . . . . . . 111.10 Confronto spettri QPSK, MSK e GMSK . . . . . . . . . . . . 121.11 Demodulatore con banco di correlatori . . . . . . . . . . . . . 131.12 Demodulatore con filtro adattato . . . . . . . . . . . . . . . . 141.13 Effetto filtro adattato . . . . . . . . . . . . . . . . . . . . . . 151.14 Costellazione BPSK e densita di probabilita condizionate . . 161.15 Effetto interferenza intersimbolica . . . . . . . . . . . . . . . . 181.16

∑∞m=−∞X

(f + m

T

)per T < 1

2W . . . . . . . . . . . . . . . . 191.17

∑∞m=−∞X

(f + m

T

)per T = 1

2W . . . . . . . . . . . . . . . . 191.18 sinc

(π t

T

). . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

1.19∑∞

m=−∞X(f + m

T

)per T > 1

2W . . . . . . . . . . . . . . . . 201.20 Sagomatura d’impulso a coseno rialzato . . . . . . . . . . . . 211.21 Diagrammi vettoriali QPSK con sagomatura d’impulso . . . . 211.22 Trasmissione numerica . . . . . . . . . . . . . . . . . . . . . . 221.23 Codificatore (3, 1, 3) . . . . . . . . . . . . . . . . . . . . . . . 231.24 Piano di Shannon . . . . . . . . . . . . . . . . . . . . . . . . . 25

2.1 Modulatore Standard . . . . . . . . . . . . . . . . . . . . . . . 262.2 Modulatore DDFS . . . . . . . . . . . . . . . . . . . . . . . . 272.3 Modulatore QPSK classico per un solo data rate . . . . . . . 292.4 Modulatore QPSK classico 3 data rate . . . . . . . . . . . . . 302.5 Modulatore QPSK classico 3 data rate Ottimizzato . . . . . . 312.6 Modulatore QPSK classico 3 data rate fclk = 4× fif . . . . . 32

3.1 SRRC 19 coefficienti interpolante 3 . . . . . . . . . . . . . . . 36

vi

3.2 SRRC 25 coefficienti interpolante 4 . . . . . . . . . . . . . . . 363.3 SRRC 39 coefficienti interpolante 6 . . . . . . . . . . . . . . . 363.4 SRRC interpolante 3, 4, 6 . . . . . . . . . . . . . . . . . . . . 373.5 FIR iesimo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383.6 Rate Adapter . . . . . . . . . . . . . . . . . . . . . . . . . . . 393.7 SRRCxN versione ROM . . . . . . . . . . . . . . . . . . . . . 413.8 Confronto Polifase VHDL – Polifase Matlab . . . . . . . . . . 423.9 Confronto Polifase FPGA – Polifase Matlab . . . . . . . . . . 43

4.1 Effetto del canale sul segnale modulato QPSK . . . . . . . . . 454.2 Grafico prestazioni modem Matlab in termini di BER . . . . 464.3 Modulatore classico . . . . . . . . . . . . . . . . . . . . . . . . 474.4 SRRCxN versione RAM . . . . . . . . . . . . . . . . . . . . . 484.5 RAM 12× 4096 . . . . . . . . . . . . . . . . . . . . . . . . . . 484.6 Temporizzazioni modulatore classico . . . . . . . . . . . . . . 494.7 ThinModulator . . . . . . . . . . . . . . . . . . . . . . . . . . 504.8 FIFO RAM ThinModulator . . . . . . . . . . . . . . . . . . . 514.9 Clock×2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 524.10 Interfaccia modulatore – sorgente dati . . . . . . . . . . . . . 524.11 Confronto Modulatore x3 VHDL – Matlab . . . . . . . . . . . 534.12 Confronto Modulatore x3 FPGA – Matlab . . . . . . . . . . . 564.13 Confronto Modulatore x4 FPGA – Matlab . . . . . . . . . . . 574.14 Confronto Modulatore x6 FPGA – Matlab . . . . . . . . . . . 57

A.1 Schema di principio DDFS . . . . . . . . . . . . . . . . . . . . 60A.2 Spettro in uscita dal DAC . . . . . . . . . . . . . . . . . . . . 61A.3 Andamento nel tempo della parola troncata . . . . . . . . . . 62A.4 Spettro dente di sega . . . . . . . . . . . . . . . . . . . . . . . 62A.5 Ottimizzazione del convertitore fase-ampiezza . . . . . . . . . 63A.6 Rotazione planare . . . . . . . . . . . . . . . . . . . . . . . . 64A.7 Uscita DDFS nel tempo . . . . . . . . . . . . . . . . . . . . . 66A.8 Spettro Coseno Matlab . . . . . . . . . . . . . . . . . . . . . . 67A.9 NCO VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67A.10 Iterazione iesima . . . . . . . . . . . . . . . . . . . . . . . . . 68A.11 Cordic Pipelined Unrolled . . . . . . . . . . . . . . . . . . . . 69A.12 Spettro coseno generato dal DDFS VHDL . . . . . . . . . . . 70

B.1 Upsampling . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72B.2 Upsampler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73B.3 Downsampling . . . . . . . . . . . . . . . . . . . . . . . . . . 73B.4 Downsampler . . . . . . . . . . . . . . . . . . . . . . . . . . . 74B.5 Cambiamento di rate frazionario . . . . . . . . . . . . . . . . 74B.6 Nobili Identita . . . . . . . . . . . . . . . . . . . . . . . . . . 75B.7 Integratore e sua risposta in frequenza . . . . . . . . . . . . . 76

vii

B.8 Comb e sua risposta in frequenza . . . . . . . . . . . . . . . . 76B.9 Interpolatore CIC . . . . . . . . . . . . . . . . . . . . . . . . . 76B.10 Decimatore CIC . . . . . . . . . . . . . . . . . . . . . . . . . 77B.11 Spettro del CIC per R=2, N=1, M=1 . . . . . . . . . . . . . 77B.12 Effetto di M sulla frequenza del CIC . . . . . . . . . . . . . . 78B.13 Trasformazioni interpolatore polifase . . . . . . . . . . . . . . 79

C.1 Gerarchia implementazioni circuiti logici . . . . . . . . . . . . 81C.2 Implementazione di un moltiplicatore . . . . . . . . . . . . . . 84C.3 Slice Virtex . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85C.4 CLB Virtex . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85C.5 VersaBlock . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86C.6 Clock globale . . . . . . . . . . . . . . . . . . . . . . . . . . . 87C.7 Configurazione delle BlockRAM . . . . . . . . . . . . . . . . . 88

viii

Ringraziamenti

Dal punto di vista didattico desidero ringraziare molti dei miei insegnanti,un pensiero particolare per Francesco Valdoni che mi ha introdotto ad unavisione piu ingegneristica delle Comunicazioni Elettriche, e per GiancarloCardarilli, Marco Re, Andrea Del Re e Dario Gelfusa grazie ai quali que-gli stessi concetti hanno trovato applicazione pratica in questa Tesi in uncontesto fortemente motivante.

Un ringraziamento ad Alenia Spazio per l’occasione formativa ed inparticolare all’Ing. Domenico Giancristofaro per la pazienza dimostrata neimiei confronti ed il notevole apporto teorico.

Un rilevante contributo e giunto anche dai NewsGroup Comp.arch.fpga,comp.lang.vhdl e comp.dsp nei quali Ray Andraka, Allan Herrimann, JackyRenaux e Brian Philopsky svolgono un importante servizio di volontariatoculturale.

Come dimenticare i compagni con cui sin dall’inizio abbiamo affrontatoinsieme questa avventura, i loro nomi sono nella mia mente e nei tanti ricor-di che ci accomunano, un grazie particolare a chi ha sempre corso dinanzia me dimostrandomi giorno per giorno che cio che sembrava impossibile inrealta non lo era, l’auspicio e di rimanere in contatto con tutti.

Ancora un grazie per la mia famiglia, per tutto cio che non mi viene inmente perche e banale, scontato, pero esiste e mi ha consentito di arrivarea questo traguardo, grazie Mamma perche ogni giorno trascorso con te e ungiorno felice.

ix

Introduzione

Le comunicazioni spaziali rappresentano probabilmente uno dei settori dimaggiore interesse dell’elettronica e delle telecomunicazioni, ad esse diret-tamente o indirettamente si debbono molti dei progressi scientifici degliultimi 50 anni, numerose sono infatti le applicazioni nella vita quotidianadi idee e materiali derivati da attivita spaziali. Queste comunicazioni eranoun tempo adibite esclusivamente ad attivita militare o scientifica e pertantopresentavano costi elevati e scarsa efficienza, l’avvento di servizi quale la tvdigitale, la telefonia, il GPS ed altri le hanno rese maggiormente soggettealle leggi del mercato conseguentemente si e assistito ad un miglioramentoprogressivo delle prestazioni, dei costi e dell’efficienza.

In questa rapida evoluzione l’unico aspetto che non e mai stato messo indiscussione e la modulazione adottata, infatti da sempre per la trasmissionein ambito spaziale di segnali non di servizio si utilizza la modulazione QPSKin quanto essa come vedremo individua il punto di minimo in un idealespazio sui cui assi ci sono l’efficienza spettrale, la semplicita circuitale1 el’efficienza energetica2.

L’argomento della Tesi si puo pertanto definire datato ed in fondo benconosciuto tuttavia il rapido e costante evolversi delle tecniche digitali, af-fiancato dai processi di integrazione su larga scala, consente di dire qualco-sa di nuovo anche nella realizzazione di un modulatore QPSK, al riguardobasta osservare che attualmente le FPGA3 sono utilizzate in applicazionispaziali soltanto per circuiti marginali mentre esse sono destinate ad unruolo primario nelle future realizzazioni in virtu delle prestazioni in rapidaascesa, della loro riprogrammabilita a distanza e soprattutto della riduzionedi costi e tempi di progettazione che implicitamente consentono.

Le specifiche tecniche dalle quali trae origine il modulatore QPSK sonostate emesse dall’Alenia Aerospazio, una Societa del gruppo Finmeccanicaall’avanguardia nell’industria aerospaziale mondiale. Tra i suoi prodotti dimaggior successo indubbiamente SkyPlex, un processore che consente l’ac-cesso al satellite non piu ad un unico flusso dati assemblato dalla stazione

1che si traduce in spazi e pesi ridotti ovvero costi di lancio ridotti2molta della energia del satellite viene utilizzata per comunicare, ottimizzando questo

consumo si puo aumentare sensibilmente la vita delle batterie e quindi del satellite stesso3Field Programmable Gate Array

1

2

gateway, bensi a piu flussi i quali vengono demodulati separatamente, op-portunamente assemblati e successivamente di nuovo modulati ed inviativerso Terra in un unico flusso. I satelliti che attualmente utilizzano Skyplexsono gli HotBird 4 e 5, dei geostazionari appartenenti all’operatore EUTEL-SAT [4] impiegati prevalentemente per la televisione digitale, al riguardo lapresenza di molteplici piccole emittenti che hanno accesso al satellite, sem-bra confermare l’idea che Skyplex abbia effettivamente rappresentato unmodo nuovo di concepire le comunicazioni satellitari.

Le portanti utilizzate sono a 14GHz per HotBird 5 e 19Ghz per HotBird4, e naturalmente impensabile allo stato attuale della tecnologia digitalepensare di produrre direttamente questi segnali, tuttavia i vantaggi del di-gitale sono fortemente desiderati ed allora nella presente Tesi si propone unasoluzione di compromesso ossia l’utilizzo di un modulatore digitale che mo-dula una portante intermedia a 40MHz generata in forma digitale medianteun DDFS4 a partire da un clock superiore a 160MHz, successive conversionidi frequenza analogiche traslano poi il segnale modulato alle frequenze real-mente applicate all’amplificatore di potenza TWTA5 che alimenta l’antennairradiante verso Terra. Le specifiche del modulatore digitale richiedono cheesso sia in grado di accettare tre distinti data rate, 55Mbps, 82, 5Mbps e110Mbps, inoltre al fine di eliminare l’interferenza intersimbolica deve es-sere applicata una sagomatura d’impulso con spettro a coseno rialzato eα = 0, 35 quale fattore di roll-off.

4Direct Digital Frequency Synthesizer5Travelling Wave Tube Amplifier

Capitolo 1

Modulazioni digitali

1.1 Sommario

La trasmissione di informazione tra una sorgente ed un destinatario attra-verso un mezzo trasmissivo comporta sempre il ricorso alla modulazioneche, a seconda della particolare applicazione, si propone di ottenere uno opiu dei seguenti obiettivi:

• minimizzare la potenza irradiata.

• minimizzare la banda occupata.

• minimizzare la complessita e quindi i costi.

in questo capitolo si cerchera di evidenziare i motivi che da sempre portanoa considerare la modulazione QPSK1 come la piu adatta a comunicazionispaziali ad elevato data rate, in quest’ottica vengono anche introdotti con-cetti quali la sagomatura dell’impulso, la demodulazione con filtro adattato,i criteri di decisione e la codifica.

1.2 Modulazione

Molte delle moderne comunicazioni elettriche avvengono in forma digitaleindipendentemente dal fatto che la sorgente sia digitale oppure analogica,il motivo di cio e che a monte e/o a valle del canale trasmissivo il segnalesubisce comunque delle elaborazioni digitali volte ad ottimizzarne le carat-teristiche, pertanto la scelta di una trasmissione digitale rappresenta unasoluzione di continuita.

Lo spettro di un generico segnale randomico NRZ2 mostrato in Figu-ra(1.1) evidenzia tuttavia come i segnali digitali non siano adatti alle tra-

1Quadrature Phase Shift Keying2No Return to Zero

3

CAPITOLO 1. MODULAZIONI DIGITALI 4

Figura 1.1: Spettro segnale NRZ

smissioni in mezzi fisici reali, vi e infatti troppa potenza distribuita sui lobilaterali, essa e sia inutile ai fini della trasmissione dell’informazione che de-leteria in quanto aumenta il livello del rumore in eventuali canali adiacenti.La potenza utile e invece addensata nei pressi della continua pertanto sirende necessaria una traslazione in frequenza al fine di poter inviare piusequenze digitali su di un unico mezzo trasmissivo.

1.2.1 Traslazione in frequenza

La traslazione in frequenza nella sua forma piu semplice si ottiene molti-plicando il segnale digitale in banda base, opportunamente filtrato, per unaportante analogica a frequenza fc, ne deriva uno spettro bilatero centratosu questa frequenza come in Figura(1.2).

Figura 1.2: Spettro di un segnale in banda traslata

Al fine di poter confrontare sistemi operanti a frequenze diverse e im-portante poter rappresentare in banda base un qualsiasi segnale in banda


traslata s (t), a tal riguardo, in riferimento a sistemi reali, e di interesse ilsolo asse positivo delle frequenze, descritto dal segnale analitico [2]

s+ (t) = s (t) + s (t) (1.1)

dove

s (t) =1πt∗ s (t) (1.2)

e la trasformata di Hilbert di s (t) il cui effetto nel dominio della frequenzae visualizzato in Figura(1.3), essa ruota di +90 le componenti a frequenza

Figura 1.3: Trasformata di Hilbert nel dominio della frequenza

positiva e di −90 quelle a frequenza negativa, ricordando inoltre che latraslazione in frequenza corrisponde ad una moltiplicazione per l’esponen-ziale complesso nel dominio del tempo si ottiene l’espressione dell’inviluppocomplesso sl (t):

sl (t) = s+ (t) e−2πfct (1.3)

Il segnale in banda traslata s (t) puo pertanto essere rappresentato intre diverse forme:

Inviluppo Complesso:

s (t) = <[sl (t) e−2πfct

](1.4)

Modulo e fase:s (t) = a (t) cos (2πfct+ ϕ (t)) (1.5)

dove a (t) e ϕ (t) sono dei segnali reali in banda base che rappresentanorispettivamente l’ampiezza e la fase del segnale in banda traslata s (t).

Quadratura:

s (t) = sc (t) cos (2πfct)− ss (t) sin (2πfct) (1.6)


essendo sc (t) e ss (t) dei segnali in banda base denominati rispettiva-mente componente in fase e componente in quadratura del segnale inbanda traslata s (t).

La formulazione(1.6) e di fondamentale importanza in questa Tesi in quantoda essa si evince in maniera immediata lo schema di un possibile modulato-re.

1.2.1.1 Spazio dei segnali

Un qualsiasi segnale reale puo essere rappresentato come un vettore nel-lo spazio dei segnali, tale spazio eredita le proprieta classiche degli spazivettoriali definiti dall’algebra lineare, in particolare e caratterizzato da unanorma:

‖s (t) ‖ =√〈s (t) , s (t)〉 =

√∫ b

a|s (t)|2 dt (1.7)

che consente di individuare una base ossia un gruppo di N segnali ψj aventinorma unitaria ed ortogonali tra loro:

〈ψj , ψk〉 = 0 ∀ j, k : j 6= k (1.8)

Ogni segnale sm (t) appartenente allo spazio dei segnali puo essere rap-presentato come combinazione lineare dei vettori ψj (t) della base

sm (t) =N∑

J=1

smjψj (t) (1.9)

essendo smj (t) la proiezione di sm (t) lungo la direzione dello spazio vetto-riale individuata dal jesimo vettore ψj (t) della base. Nel caso di uno spaziobidimensionale si ha che m ∈ (1, 2) pertanto tralasciando la base che euguale per ogni segnale si ha che il generico segnale sm (t) e individuato dalvettore s = [sm1 sm2].

Il progetto di una modulazione digitale si basa quindi sulla scelta di unabase ortonormale nella quale rappresentare M segnali disposti a formareuna costellazione le cui caratteristiche geometriche influenzano il progettodel trasmettitore e la qualita della ricezione. La sequenza di bit da trasmet-tere viene suddivisa in gruppi costituiti da b = log2M bits, ogni gruppoindividua un simbolo tra gli M di un alfabeto cui sono associati gli Msegnali della costellazione.

1.2.1.2 Tipologie di modulazioni satellitari

Il segnale in banda traslata espresso dall’equazione(1.5) evidenzia come l’in-formazione in banda base possa essere codificata sia nel modulo che nella


fase3 della portante. Per applicazioni satellitari non si utilizzano modulazio-ni che associano informazione al modulo della portante in quanto richiedonoamplificatori lineari in classe A che non sfruttano al meglio la scarsa ener-gia disponibile, inoltre tali modulazioni sono vulnerabili alle variazioni delguadagno del canale stesso.

Nel caso di una modulazione M–PSK4 utilizzante una portante a fre-quenza fc e per la quale ogni simbolo da trasmettere sia caratterizzato daenergia ES si ha l’espressione del segnale modulato:

sm (t) =

√2ES

Tg (t) cos

(2πM

(m− 1))

cos (2πfct)−√2ES

Tg (t) cos

(2πM

(m− 1))

sin (2πfct)

(1.10)

dove g(t) e la sagomatura d’impulso5 ed m = 1, 2, . . . ,M e un interoassociato al simbolo del quale e richiesta la trasmissione.

La base e costituita dalle funzioni

ψ1 (t) =

√2Tg (t) cos (2πfct)

ψ2 (t) =

√2Tg (t) sin (2πfct)

(1.11)

pertanto ogni segnale modulato puo essere rappresentato da un vettore:

sm = [sm1 sm2] =[√Es cos

(2πM (m− 1)

) √Es sin

(2πM (m− 1)

)](1.12)

Le tipologie piu comuni di M–PSK sono la BPSK6(M= 2) e la QPSK(M=4), per quest’ultima l’andamento nel tempo e illustrato in Figura(1.4), dovenon essendo stata applicata la sagomatura dell’impulso si ha che l’invilup-po e costante, tale soluzione e di solo interesse teorico in quanto l’efficie-nza energetica che ne deriva non bilancia i numerosi problemi derivantidall’insorgere dell’interferenza intersimbolica.

La costellazione QPSK e costituita da 4 punti individuati sostituendom = 1, 2, 3, 4 nella equazione(1.13),

smj =∫ T

0sm (t)ψj (t) (1.13)

i loro valori sono riportati in Tabella(1.1).3e quindi nella frequenza4Phase Shift Keying5Sezione(1.3.3)6Binary Phase Shift Keying


Figura 1.4: Modulazione QPSK nel tempo

Simbolo Segnale Coordinata I Coordinata Q00 s0 +1 +101 s1 -1 +110 s2 -1 -111 s3 +1 -1

Tabella 1.1: Punti della costellazione QPSK

Le brusche transizioni della fase in Figura(1.4) si hanno nel passaggiodal simbolo che nella costellazione di Figura(1.5a) ha coordinate (1, 1) alsimbolo con coordinate (−1,−1) , l’inviluppo complesso passa per l’origi-ne e compie una ampia escursione in ampiezza inadatta agli amplificatorinon lineari utilizzati per ottimizzare l’impiego dell’energia nel satellite. La

Figura 1.5: Tipologie di QPSK

modulazione OQPSK7 la cui costellazione e rappresentata in Figura(1.5b)e una variante della QPSK che risolve il problema delle transizioni di fase

7Offset Quadrature Phase Shift Keying


mediante uno sfasamento temporale tra la componente in fase e quella inquadratura, esse non cambiano mai contemporaneamente pertanto la mas-sima variazione dell’ampiezza dell’inviluppo complesso e di circa 3dB controi 40dB della QPSK.

La modulazione π4 QPSK [1] risolve il medesimo problema ruotando di

π4 la costellazione ad ogni simbolo come in Figura(1.5c), in tal modo laescursione di fase massima e di 135, intermedia tra i 180 della QPSKconvenzionale ed i 90 della OQPSK, rispetto a quest’ultima pero si ha ilvantaggio di poter utilizzare la demodulazione incoerente, l’informazione einfatti associata all’ampiezza della variazione di fase ed alla direzione incui avviene la rotazione pertanto non e necessario che il ricevitore conoscala fase in anticipo visto che il riferimento per la demodulazione del sim-bolo attuale e costituito dal simbolo precedente. Il ricevitore π

4 QPSK haun’architettura piu semplice ma la probabilita d’errore e maggiore di circa3dB rispetto all’equivalente ricevitore coerente in quanto sono possibili duesorgenti d’errore, un simbolo corrotto oppure un riferimento errato.

Una diretta estensione della modulazione M–PSK e la M–QAM8, leloro costellazioni coincidono nel caso di M = 4 mentre per valori diversidifferiscono profondamente come evidenziato in Figura(1.6) nel caso di M =16.

Figura 1.6: Confronto costellazioni M–QAM e M–PSK

Per entrambe l’efficienza spettrale e ηs = 4 in quanto ad ogni simbolosono associati 4 bit mentre nella QPSK soltanto due, i segnali della costella-zione QAM tuttavia non hanno tutti la stessa energia pertanto, per i motiviprecedentemente esposti, non sono adatti ad applicazioni spaziali.

Dalla costellazione della 16–PSK si puo osservare come i segnali sianoravvicinati tra loro molto piu che nella QPSK dove se ne ha uno in ogniquadrante, cio determina un aumento della probabilita di scambiare un

8Quadrature Amplitude Modulation


segnale per uno dei segnali adiacenti pertanto occorre aumentare la potenzaal fine di ottenere la stessa probabilita d’errore della QPSK.

L’altra grande famiglia di modulazioni digitali utilizzata in ambito spa-ziale e quella che interessa le variazioni della frequenza della portante e cheva sotto il nome di M–FSK9 [7], continua o discontinua a seconda che lavariazione tra le M frequenze associate ai simboli da trasmettere avvengacon continuita di fase o meno. In Figura(1.7) e riportato l’andamento tem-

Figura 1.7: Andamento temporale BFSK

porale di una M–FSK incoerente per il caso di M = 2, essa si realizza condue oscillatori, a seconda del simbolo da trasmettere il modulatore emetteuna portante oppure l’altra.

Le discontinuita nella fase che si hanno nella M–FSK incoerente deter-minano una banda molto ampia e pertanto una scarsa efficienza spettrale,per questo motivo si sono affermate le tecniche a fase continua CPFSK10 ilcui generico segnale modulato e descritto dalla:

sm (t) =√

2Eb

Tbcos(

2πfct+ 2πkf

∫ t

−∞m (τ) dτ

)(1.14)

dove la fase del segnale modulato e continua in quanto non direttamenteproporzionale al segnale modulante digitale m (t) ma al suo integrale. L’in-dice di modulazione kf = 2∆f

Rbdetermina la separazione tra i toni, essa e

minima nel caso della MSK11 per la quale si ha kf = 0, 5. L’andamentodella fase nel tempo per la MSK e rappresentato in Figura(1.8), ad ogni bit1 da trasmettere viene associato un aumento della fase pari a +90 mentread ogni bit 0 si associa una diminuzione di −90 della stessa.

Una derivazione della MSK e la GMSK12 che riduce ulteriormente labanda filtrando la modulante digitale con un filtro gaussiano avente risposta

9Frequency Shift Keying10Continuous Phase Frequency Shift Keying11Minimum Shift Keying12Gaussian Minimum Shift Keying


Figura 1.8: Andamento temporale fase del segnale MSK

all’impulso

hG (t) =√π

αe−

π2

α2 t2 (1.15)

rappresentata in Figura(1.9),

Figura 1.9: Risposta all’impulso del filtro gaussiano

esso e completamente descritto dal prodotto BT dove T e l’intervallodi simbolo e B la banda a 3dB determinata da α = 1,8

B , quanto piu BTdiminuisce tanto piu lo spettro diviene compatto comportando pero unaumento dell’interferenza intersimbolica13.

La Figura(1.10) illustra un confronto spettrale tra le modulazioni MSK,GMSK e QPSK, lo spettro di quest’ultima e il piu stretto per quel cheriguarda la banda utile me presenta molta energia distribuita inutilmentesui lobi secondari, la modulazione piu efficiente sotto questo punto di vistae la GMSK che, per tal motivo, e utilizzata nella telefonia cellulare GSM

13Sezione(1.3.3)


Figura 1.10: Confronto spettri QPSK, MSK e GMSK

dove i canali sono molto vicini tra loro e si richiede elevata autonomia dellebatterie.

1.3 Principi di demodulazione

Questa Tesi e volta alla realizzazione di un modulatore QPSK, cio implicatuttavia la conoscenza almeno dei principi della demodulazione che vengonoqui brevemente esposti tralasciando il caso in cui il segnale in ingresso alricevitore presenti una deriva di fase, frequenza o temporizzazione.

Un generico ricevitore digitale e costituito dalla cascata di due circuiti,un demodulatore ed un decisore, il primo si occupa di estrarre dal segnalemodulato affetto da rumore le componenti nelle direzioni dei vettori ψi dellabase dello spazio dei segnali utilizzato, compito poi del decisore e di sceglierequale tra i segnali appartenenti alla costellazione trasmessa sia da associareal segnale ricevuto.

1.3.1 Demodulatore

Il segnale r (t) in ingresso al ricevitore e la somma del segnale modula-to sm (t) e del rumore n (t) introdotto dal canale, quest’ultimo puo esse-re espresso come combinazione lineare dei vettori ψi della base14, si ha

14la parte di n (t) che non e rappresentabile come combinazione lineare degli ψi eirrilevante nel processo di decisione


pertanto:

rj (t) =∫ T

0r (t) ψj (t) dt

=∫ T

0sm (t) ψj (t) dt+

∫ T

0n (t) ψj (t) dt

= smj (t) + nj (t)

(1.16)

questa equazione descrive in maniera immediata il demodulatore che puoessere realizzato con un banco di correlatori ciascuno dei quali correla il se-gnale ricevuto r (t) con uno dei vettori della base restituendone la proiezionein quella direzione, tale demodulatore e descritto in Figura(1.11).

Figura 1.11: Demodulatore con banco di correlatori

Un demodulatore ben piu semplice puo essere dedotto dalla medesimaequazione(1.16) scrivendo la correlazione come una convoluzione:

rj =∫ T

0r (τ) ψj (τ) dτ

=[∫ T

0r (τ) ψj (T − t+ τ) dτ

]|t=T

= [r (t) ∗ ψj (T − t)] |t=T

(1.17)

ne consegue che la componente rj (t) del segnale ricevuto puo essere cal-colata campionando al tempo t = T l’uscita di un filtro avente rispostaall’impulso h (t) = ψj (T − t). Il demodulatore basato su questo banco difiltri che si dicono adattati ai segnali della base e illustrato in Figura(1.12),per esso una considerazione importante e che l’uscita dai filtri adattati e


Figura 1.12: Demodulatore con filtro adattato

campionata soltanto a t = T, essendo T il tempo di simbolo, e quindinon e richiesto che essa sia uguale all’impulso trasmesso in ogni istante, esufficiente che lo sia nel solo istante di campionamento.

Il filtro adattato e il demodulatore che consente di ottenere il piu altoSNR15, la sua risposta in frequenza e infatti:

HRX (f) = H∗TX (f) e−2πft (1.18)

che corrisponde a ruotare tutte le componenti del segnale d’ingresso in modoche abbiano la stessa fase come illustrato graficamente in Figura(1.13), siottiene cosı che i moduli delle singole componenti del segnale si sommano inmaniera costruttiva massimizzando l’energia del segnale mentre quella delrumore rimane invariata.

1.3.2 Decisore

L’uscita del demodulatore lungo il jesimo vettore della base dello spazio deisegnali e somma di una componente deterministica e di una componen-te aleatoria gaussiana generata dall’elaborazione di un processo di rumoregaussiano, la componente deterministica individua con precisione nello spa-zio dei segnali il segnale trasmesso mentre la componente gaussiana provocauna deviazione rispetto ad esso la cui ampiezza e individuata dal valoredella densita spettrale di rumore N0

2 .

15Signal to Noise Ratio


(a) Segnale trasmesso (b) Uscita del filtroadattato

Figura 1.13: Effetto filtro adattato

Il processo di decisione [13] che associa il segnale demodulato r0 ad unodei vettori della costellazione puo essere implementato secondo il criterioML16 oppure il MAP17:

ML: consiste nello scegliere il vettore sj della costellazione che ha la mag-gior probabilita di coincidere col segnale sm emesso.

MAP: e uguale al criterio ML ma tiene anche conto del fatto che nonnecessariamente tutti i segnali appartenenti alla costellazione hannola stessa probabilita di essere emessi.

Se i segnali della costellazione sono equiprobabili allora i due critericoincidono e il decisore non fa altro che calcolare le distanze tra il segnaledemodulato r0 e tutti i segnali sj della costellazione optando poi a favore delpiu vicino, in sostanza quindi il decisore suddivide lo spazio dei segnali in Mregioni dette di decisione, ciascuna contiene un punto sj della costellazionee tutti i punti che sono piu vicini ad esso che non agli altri punti della co-stellazione. Nel caso si utilizzi il criterio MAP le regioni si ampliano per queipunti della costellazione che hanno maggiore probabilita di essere emessi adiscapito delle regioni che contengono i punti con minore probabilita.

Le probabilita d’errore [8] di BPSK e QPSK coincidono in quanto laQPSK e data dall’unione di due costellazioni BPSK ortogonali tra loro, Idue segnali s1 =

√Eb e s2 = −

√Eb della costellazione BPSK sono rap-

presentati in Figura(1.14) insieme alla densita di probabilita condizionate:

p (r|s1) =1√πN0

e− (r−

√Eb)

2

N0 (1.19)

16Maximum Likelihood17Maximum A Posteriori probability


Figura 1.14: Costellazione BPSK e densita di probabilita condizionate

p (r|s2) =1√πN0

e− (r+

√Eb)

2

N0 (1.20)

Nell’ipotesi che sia stato emesso s1 (t) la probabilita d’errore si ottiene in-tegrando la gaussiana da −∞ a 0 infatti quella e la regione di decisioneassociata al simbolo s2, si ha:

P (e|s1) =∫ 0

−∞P (r|s1) dr

=1√πN0

∫ 0

−∞e− (r−

√Eb)

2

N0 dr

=1√2π

∫ √2EbN0

−∞e−

x2

2 dx

=1√2π

∫ +∞√2EbN0

e−x2

2 dx

= Q

(√2Eb

N0

)= Q

√ d212

2N0

=12erfc

(Eb

N0

)

(1.21)

essendo erfc (x) la funzione complementare di errore

erfc (x) =2π

∫ +∞

xe−y2

dy (1.22)

Il medesimo risultato si ha per P (e|s2) e, per via della simmetria del-la costellazione, entrambe coincidono con la probabilita d’errore della mo-


dulazione BPSK e quindi anche della QPSK che tuttavia ha un’efficienzaspettrale doppia in quanto ad ogni simbolo associa due bit e non uno.

L’ultima formulazione della (1.21) consente due osservazioni importanti:

1. la probabilita d’errore dipende unicamente dal rapporto EbN0

denomi-nato rapporto segnale/rumore per bit e non da altre caratteristichedel segnale o del rumore.

2. quanto piu sono ravvicinati i simboli della costellazione tanto piupeggiora la probabilita d’errore, questo e il motivo per il quale alla16–PSK si preferisce la QPSK anche se l’efficienza spettrale e inferiore.

La BER18 esprime lo stesso concetto della probabilita d’errore ma inmaniera piu immediata, essa e infatti il rapporto tra il numero dei bitricevuti in maniera errata ed il numero totale dei bit trasmessi, una analogamisura e la SER19 che esprime invece il rapporto tra il numero dei simboliricevuti in maniera errata ed il numero totale dei simboli trasmessi, essecoincidono per la QPSK a patto di utilizzare la codifica di Gray la qualeassocia a segnali adiacenti della costellazione gruppi di bit che differisconotra loro soltanto per un bit.

1.3.3 Interferenza intersimbolica

L’equazione delle onde per un mezzo debolmente disomogeneo e non dissi-pativo

∇2E + κ20n

2 (r)E = 0 (1.23)

e funzione dell’indice di rifrazione n(r) =√ε′ (r) essendo ε′ la parte reale

della costante dielettrica del mezzo.Ipotizzando per la (1.23) una soluzione espressa nella forma della espan-

sione asintotica di Luneburg-Kline

E (r) = e−jκ0Φ(r)∞∑

m=0

Em (r)(κ0)

m (1.24)

si perviene all’importante risultato secondo il quale nel caso in cui l’indicedi rifrazione del mezzo trasmissivo dipende dalla frequenza si ha che unimpulso trasmesso subisce un allargamento temporalmente e per il principiodella conservazione dell’energia diminuisce in ampiezza [11]. Il fenomenoviene denominato ISI20 ed e particolarmente deleterio nelle trasmissioni diimpulsi digitali reali come quelli tratteggiati in Figura(1.15a), essi vengonodeformati come in Figura(1.15b) pertanto negli istanti di campionamento

18Bit Error Rate19Symbol Error Rate20Inter Symbol Interference


(a) Segnale Tx ed Rx (b) Effetto ISI su impulsi

Figura 1.15: Effetto interferenza intersimbolica

del ricevitore si hanno contributi derivanti da piu impulsi il che puo generareerrori come ad esempio nell’istante (3) dove il segnale ricevuto ha ampiezzadimezzata rispetto al simbolo trasmesso.

Il problema dell’interferenza intersimbolica e stato individuato sin dalleprime trasmissioni transoceaniche di Morse, una soluzione intuitiva fu quel-la di operare al massimo data rate in grado di consentire una ricezione dibuona qualita21, tuttavia l’evolversi delle tecnologia e la sempre piu strin-gente necessita di trasmettere in tempi brevi grandi moli di informazione haportato ad una soluzione piu ingegnosa.

Ricordando che il ricevitore basato sul filtro adattato richiede l’uguaglia-nza tra l’impulso trasmesso e quello ricevuto soltanto nell’istante di campio-namento ne consegue che si puo scegliere una forma dell’impulso qualsiasi apatto che si annulli in tutti i multipli dell’istante di campionamento tranneuno, il suo andamento temporale e pertanto:

x (nT ) =

1 se n = 00 se n 6= 0

(1.25)

in virtu della condizione di Nyquist [8] per l’annullamento dell’ISI si ha chegli impulsi x (t) che rispettano la (1.25) sono tutti quelli la cui trasformatadi Fourier risponde al vincolo

∞∑m=−∞

X(f +

m

T

)= T (1.26)

dove W e la banda del canale.I casi possibili sono tre:

T < 12W : le repliche di X (f) non si sovrappongono pertanto non c’e mododi rispettare il criterio di Nyquist e quindi l’utilizzo di queste tipologiedi impulsi porta a trasmissioni affette da ISI.

T = 12W : questa condizione implica che le repliche spettrali si tocchino soloin un punto come in Figura(1.17), l’unico spettro che soddisfa questa

21circa 200Baud per il telegrafo


0 W-W-1/T -1/T

T

Figura 1.16:∑∞

m=−∞X(f + m

T

)per T < 1

2W

0 W-W-1/T -1/T

T

Figura 1.17:∑∞

m=−∞X(f + m

T

)per T = 1

2W

condizione e descritto dalla

X (f) =T se |f | < W0 altrimenti

(1.27)

si tratta di un rettangolo in frequenza cui corrisponde la

x (t) =sin(π t

T

)π t

T

≡ sinc

(πt

T

)(1.28)

rappresentata in Figura(1.18), essa presenta la banda minima ma epraticamente irrealizzabile per via della anticausalita e delle lunghecode che si estendono illimitatamente e decadono come 1

x .

Figura 1.18: sinc(π t

T

)T > 1

2W : le repliche spettrali in questo caso si sovrappongono, vi sono quin-di molti impulsi che rispettano il criterio di Nyquist, la famiglia piu


0 W-W-1/T -1/T

T

Figura 1.19:∑∞

m=−∞X(f + m

T

)per T > 1

2W

utilizzata e quella degli spettri a coseno rialzato descritti dalla

Hrc (f) =

T se 0 ≤ |f | ≤ (1+α)

2TT2

[1 + cos πT

α

(|f | − (1−α)

2T

)]se (1+α)

2T ≤ |f | ≤ (1−α)2T

0 se 0 ≤ |f | ≥ (1−α)2T

(1.29)dove α e il fattore di roll-off ed assume valori compresi tra 0 ed 1,in particolare per α = 0 la banda occupata dall’impulso e proprio laminima di Nyquist22, al crescere di α essa aumenta sino a raddoppiareper α = 1. L’individuazione degli spettri a coseno rialzato parte dallaantitrasformata di Fourier:

h (t) =sin(

2πtTS

)2πT

cos (2παt)

1−(

2αtπ

)2 (1.30)

che evidenzia come la sinc viene corretta con il coseno al fine di mi-gliorarne le caratteristiche, rilevante l’ossevazione che le code dell’im-pulso sagomato pur continuando ad estendersi illimitatamente deca-dono come 1

x3 pertanto molto piu rapidamente che non nel caso in cuil’impulso sagomato sia una sinc.

Nelle applicazioni pratiche si utilizza la sagomatura d’impulso con spet-tro a coseno rialzato, la risposta in frequenza e nel tempo e illustrata al va-riare di α in Figura(1.20) si puo osservare come quanto piu α tende a zero,tanto piu hanno ampiezza elevata i lobi laterali, cio determina forti escur-sioni dell’inviluppo complesso come mostrato in Figura(1.21), pertanto perconsentire un utilizzo ottimale degli amplificatori, nelle applicazioni spazialisi utilizza il valore α = 0, 35.

Alla luce dei concetti esposti per il filtro adattato, si comprende comesia sensato suddividere la sagomatura a coseno rialzato tra il trasmettitoreed il ricevitore secondo la

Hrc (f) = HTx (f)HRx (f) (1.31)

22ossia Rs2


(a) Risposta in frequenza (b) Risposta nel tempo

Figura 1.20: Sagomatura d’impulso a coseno rialzato

Figura 1.21: Diagrammi vettoriali QPSK con sagomatura d’impulso

in entrambe sono infatti necessari dei filtri23 che possono essere progettati inmodo da eseguire anche la sagomatura dell’impulso, il modulo della rispostain frequenza per entrambe gli SRRC24 sara pertanto:

|HTx (f)| = |HRx (f)| =√Hrc (f) (1.32)

1.3.4 Principi di codifica

Tralasciando l’eventuale conversione in digitale di una sorgente analogica,si ha che una generica trasmissione numerica puo essere realizzata come infigura(1.22) dove la codifica di sorgente si propone di rimuovere le dipende-nze tra i simboli da trasmettere al fine di ridurne il numero come nel casodegli algoritmi che nei computer vengono utilizzati per la compressione deifile.

23il filtro in trasmissione riduce le emissioni nelle bande adiacenti mentre quello inricezione effettua la demodulazione ed elimina il rumore esterno alla banda utile.

24Square Root Raised Cosine


Figura 1.22: Trasmissione numerica

La codifica di canale si basa sull’introduzione di simboli addizionali nel-la sequenza trasmessa, essi sono scelti in modo da presentare una qualchecorrelazione tra loro consentendo cosı la rivelazione degli errori e conse-guentemente la riduzione della probabilita di errore intrinseca del canale.Le principali tecniche di correzione degli errori sono due, la ARQ25 e laFEC26:

ARQ: suddivide in blocchi l’informazione da trasmettere, se in ricezionesi individua la presenza di errori in un blocco ne viene richiesta laritrasmissione, necessita di un canale duplex ed ha lo svantaggio cheanche un singolo errore comporta la ritrasmissione dell’intero bloccoin cui e contenuto.

FEC: non richiede un canale duplex ma il numero di simboli ridondanti daaggiungere e molto maggiore rispetto all’ARQ, ne consegue che il datarate effettivo si riduce ma, per il teorema di Shannon sulla Capacitatrasmissiva27 si riduce anche la potenza necessaria per ottenere unatrasmissione numerica praticamente esente da errori.

In ambito satellitare si utilizza la codifica di canale di tipo FEC, in unao piu delle seguenti forme:

Codifica a blocchi: la piu importante e la Reed-Salomon (204,188), essaaggiunge 16 bytes di ridondanza per ogni 188 bytes da trasmettere,in tal modo si possono correggere sino a 8 errori e la BER richiestapassa da 10−4 a piu di 10−10. Il principio e che con l’aggiunta di bit siottengono delle combinazioni le quali possono essere ricevute soltantoin caso di errore, una volta che esso e stato rilevato si sceglie nell’alfa-beto dei possibili simboli trasmessi quello che presenta la distanza diHamming28 minore rispetto al simbolo ricevuto.

Codifica convoluzionale: viene specificata con i tre parametri (n,k,m)dove k e il numero di bit in ingresso ed n il numero di bit in uscitadal codificatore, entrambe assumono valori compresi tra 1 ed 8, m einvece il numero di registri utilizzati ed e compreso tra 2 e 10.

25Automatic ReQuest for repeat26Forward Error Correction27Sezione(1.3.5)28e il numero di bit diversi tra due simboli


Un esempio di codificatore e riportato in Figura(1.23), esso produce 3

Figura 1.23: Codificatore (3, 1, 3)

bit di uscita per ogni bit di ingresso quindi il ritmo di codifica e 1/3,ogni bit d’uscita e generato quale somma di alcuni dei bit presenti ne-gli m = 3 registri di memoria, il criterio di selezione di questi polinomigeneratori determina la qualita della codifica. Laddove si desideri unritmo di codifica variabile si ricorre alla versione Punctured, in parti-colare se si richiede la massima qualita vengono utilizzano tutte le nuscite del codificatore convoluzionale, altrimenti soltanto una parte diesse.

Interleaving: le codifiche precedenti hanno prestazioni eccellenti ma inpresenza di un gruppo di errori ravvicinati non sono in grado di rico-struire la sequenza trasmessa, il problema si risolve mescolando i bitdella sequenza da trasmettere ad esempio caricando una ROM lungole righe e leggendone il contenuto lungo le colonne.

1.3.5 Capacita trasmissiva

Per confrontare differenti tipi di modulazione e comprendere come l’effettodei codici possa migliorare la qualita di una trasmissione numerica e moltoutile il teorema [3] seguente:

Teorema 1 (di Shannon) Un qualsiasi canale caratterizzato da una velo-cita di segnalazione Rs = 1

Ts, una varianza29 di rumore al ricevitore σ2

S eduna varianza del segnale ricevuto σ2

N pone un limite, denominato capacitadi canale C, al massimo flusso informativo che transita in esso:

C = 12TS

log2

(1 + σ2

S

σ2N

)(bit/s) (1.33)

29potenza


nel caso di rumore gaussiano additivo bianco con densita spettrale dipotenza SW (f) = N0

2 si ha che la potenza di rumore e PW = σ2W = N0B

inoltre se la sorgente e gaussiana e limitata nella banda B puo essere rap-presentata con 2B campioni30 ciascuno con la medesima potenza PS = σ2

S ,ne deriva che l’equazione(1.33) puo essere riscritta nella forma:

C = Blog2

(1 + PS

N0B

)(bit/s) (1.34)

dalla quale si deduce che a parita di rumore se si vuole aumentare la capa-cita trasmissiva di un canale conviene aumentare la banda B, un aumentodella potenza ha infatti minore effetto essendo mitigato dal logaritmo.

E’ interessante una rappresentazione grafica dell’equazione(1.34) nel co-siddetto piano di Shannon, si giunge ad essa partendo dall’ipotesi che ilritmo binario in trasmissione sia uguale alla capacita del canale, si ha cioeC = Rb = 1

Tbpertanto

C

B= log2

(1 +

RbPSTb

N0B

)= log2

(1 +

C

B

PSTb

N0

)= log2

(1 +

C

B

Eb

N0

)(1.35)

da cui si ottieneEb

N0=

2CB − 1

CB

(1.36)

che rappresenta la curva limite nel piano di Shannon illustrato in Figu-ra(1.24), la regione sottostante e quella permessa ed in essa giacciono ipunti corrispondenti alle varie modulazioni, quanto piu essi si avvicinanoalla curva limite riuscendo a mantenere basso il rapporto Eb

N0tanto piu la

modulazione e efficiente.I punti corrispondenti alle modulazioni si ottengono imponendo per tut-

te una determinata probabilita d’errore, 10−5 per il piano in Figura(1.24),ad essa nel caso della QPSK corrisponde Eb

N0= 9, 6dB mentre l’efficienza

spettrale e ηS = RbB = 2 in quanto ad ogni coppia di bit si associa un simbo-

lo, le coordinate del punto sono pertanto (9, 6 , 2). La modulazione BPSKpresenta lo stesso Eb

N0e quindi la stessa efficienza energetica ma l’efficienza

spettrale vale 1 pertanto sotto questo punto di vista e piu lontana dallacurva limite e quindi le sue prestazioni sono inferiori. Nel caso di una QP-SK con codifica convoluzionale, caratterizzata da un ritmo di codifica 1/2 ek = 7 bit, si ha un guadagno di codifica di 5, 2dB rispetto alla QPSK noncodificata mentre l’efficienza spettrale vale 1 pertanto le coordinate del pun-to sono (4, 4 , 1), la forte vicinanza alla curva limite giustifica il crescenteinteresse per i turbocodici. E’ interessante osservare come le modulazioni di

30per il teorema del campionamento


Figura 1.24: Piano di Shannon

tipo M–QAM con costellazione quadrata incrementano l’efficienza spettraledella trasmissione, ma penalizzano l’efficienza energetica di circa 6 dB perogni quadruplicazione dei punti della costellazione.

Capitolo 2

Architetture modulatoriQPSK

2.1 Sommario

Dalla formula che descrive la generica modulazione M–PSK

sm (t) =

√2ES

Tg (t) cos

(2πM

(m− 1))

cos (2πfct)−√2ES

Tg (t) cos

(2πM

(m− 1))

sin (2πfct)

(2.1)

si ricava immediatamente lo schema di un modulatore che la implementiinfatti cos (2πfct) e sin (2πfct) sono due portanti in quadratura generabiliin forma analogica come in Figura(2.1)

Figura 2.1: Modulatore Standard

o in forma digitale ottenendo in tal caso risultati nettamente superioriin termini di purezza spettrale e risoluzione.

26

CAPITOLO 2. ARCHITETTURE MODULATORI QPSK 27

La modulante agisce su m ∈ (0, 1, 2, 3), corrispondentemente il terminecos(

2πM (m− 1)

)si valorizza nell’insieme (−1, 0,+1) e quindi ben si presta

ad una realizzazione digitale. La sagomatura dell’impulso1 g (t) necessariaai fini dell’eliminazione dell’ISI si realizza con un filtro analogico o digitale,quest’ultimo e da preferire in quanto non necessita di tarature individualied e meno ingombrante.

L’orientamento pertanto e stato sin dall’inizio per una realizzazione com-pletamente digitale, tuttavia anche nel solo ambito digitale vi sono diversemodalita di implementare alcuni dei blocchi costituenti il modulatore, nelseguito verranno esposte le diverse soluzioni prese in considerazione ed icriteri che hanno portato alla selezione dell’architettura adottata.

2.2 Realizzazioni digitali di modulatori QPSK

Sono state individuate due diverse architetture per la realizzazione del mo-dulatore QPSK, la prima lo vede realizzato variando alcuni dei parametridi un DDFS mentre la seconda si ottiene digitalizzando uno o piu blocchidello schema classico di Figura(2.1).

2.2.1 Modulatore DDFS

Il DDFS2 e costituito da un accumulatore di fase il quale somma al suovalore precedente un contributo fisso generando cosı una rampa di fase, ap-plicandola poi ad un convertitore fase-ampiezza si ottiene la funzione sinu-soidale desiderata. Il DDFS puo essere utilizzato per realizzare tre differentimodulazioni come illustrato in Figura(2.2).

Figura 2.2: Modulatore DDFS

La scelta dell’incremento di fase, congiuntamente alla frequenza di clockdel sistema, determina la frequenza generata, sommando all’incremento fisso

1Sezione(1.3.3)2Appendice(A.2)


un valore variabile in funzione della modulante si realizza una modulazionedi frequenza con ottime prestazioni in quanto il cambio frequenza avvienecon continuita di fase ed istantaneamente.

La modulazione di fase si ottiene in maniera analoga sommando la mo-dulante alla rampa di fase generata dall’accumulatore, l’inviluppo costanteche ne deriva non consente di implementare sagomatura dell’impulso3 inquanto questa, come visto in Figura(1.21), produce un inviluppo il cui mo-dulo varia nel tempo e viene a coincidere con i punti della costellazione neisoli istanti di simbolo.

La terza modulazione implementabile e quella d’ampiezza che si ottienesecondo lo schema classico ossia moltiplicando la portante sinusoidale che siha in uscita dal convertitore fase-ampiezza per la modulante.

In definitiva il modulatore basato sul DDFS e molto flessibile e consentedi applicare contemporaneamente ad una stessa modulante una o piu modu-lazioni4 tuttavia la limitazione che riguarda l’inviluppo complesso lo rendeinutilizzabile per la realizzazione di un modulatore QPSK per applicazionispaziali.

2.2.2 Modulatore classico

L’implementazione digitale del modulatore classico si basa anche essa sulDDFS5 il quale genera due portanti in quadratura aventi frequenza che daspecifica deve essere 40MHz, esse sono in formato digitale pertanto ogniloro campione assume un valore compreso tra −1 e +1 ed e espresso incomplemento a due su 12 bit. I campioni delle portanti vengono emessi allafrequenza di clock di 165MHz che e stata scelta in quanto multiplo interodei 3 ritmi di simbolo di cui si richiede l’implementazione, in questo modogli interpolatori6 sono piu semplici da realizzare rispetto al caso frazionario.

I valori dell’interpolazione sono riportati in Tabella(2.1) e vengono reali-

Data Rate Ingresso (Mbps) Symbol Rate (MSpS) Interpolazione55 27, 5 682, 5 41, 25 4110 55 3

Tabella 2.1: Valori interpolazione richiesti

zzati tutti mediante una architettura polifase7 sia perche l’architettura CIC8

3Sezione(1.3.3)4ottenendo cosı una cifratura della comunicazione che ne puo aumentare la segretezza5Appendice(A.2)6Appendice(B.2)7Appendice(B.3.2)8Appendice(B.3.1)


per valori cosı bassi richiede la compensazione del guadagno, che per il fat-to che nel CIC la sagomatura d’impulso e l’eliminazione delle immagini9

richiedono un ulteriore filtro che invece nel polifase e intrinseco.Il DDFS viene realizzato utilizzando come convertitore fase-ampiezza

un processore CORDIC10 il quale ottimizza l’implementazione su FPGA ede particolarmente adatto per modulatori in quadratura in quanto generasimultaneamente ed in maniera implicita sia il seno che il coseno.

Considerando per semplicita il solo data rate di 55Mbps in ingresso almodulatore, lo schema che risulta dalle precedenti considerazioni e mostratoin Figura(2.3),

Figura 2.3: Modulatore QPSK classico per un solo data rate

essa evidenzia l’utilizzo di un blocco S/P il quale ha in ingresso un flussobinario a 55Mbps che suddivide in due flussi a 27, 5MSpS semplicementedistribuendo i bit pari sul ramo superiore11 del modulatore ed i bit disparisul ramo inferiore12.

L’architettura polifase richiede un clock con frequenza pari al ritmo disimbolo, nel caso in Figura(2.3) il divisore per 6 genera un clock a 27, 5MHza partire da un clock a 165MHz, la complessita che deriva dall’implemen-tazione del divisore di frequenza e compensata dal fatto che gran partedella architettura polifase opera con un clock che e 6 volte inferiore rispet-to al clock di sistema, di qui una minore dissipazione ed una piu sempliceprogettazione del filtro ospitato dall’architettura stessa.

Lo schema del modulatore classico che consente di accettare 3 diversi9create con l’inserzione di zeri nel processo di interpolazione

10Appendice(A.4.1)11nel seguito denominato ramo I12nel seguito denominato ramo Q


data rate in ingresso e in Figura(2.4), ad ogni data rate corrisponde un

Figura 2.4: Modulatore QPSK classico 3 data rate

clock ridotto ed un diverso interpolatore polifase, si tratta pertanto di unasoluzione abbastanza onerosa in termini di implementazione su FPGA ri-chiede infatti 6 interpolatori, il che significa nella migliore delle ipotesi lanecessita di 6 sommatori ciascuno avente fino ad un massimo di 7 ingressi a12 bit, la complessita e molto elevata quindi la massima frequenza ottenibilecon questa architettura e bassa.

Rispetto all’architettura in Figura(2.4) si possono introdurre diverse ot-timizzazioni, come mostrato dalla Figura(2.5) nella quale si utilizzano duesoli interpolatori, uno per il ramo I e l’altro per il ramo Q, essi sono dimen-sionati per il massimo rate d’interpolazione, cioe 6, per esso la decomposi-zione polifase prevede 6 filtri FIR ognuno dei quali utilizza 7 coefficienti13.Nel caso che invece di interpolare 6, che e il valore di default, si voglia inter-polare 4 oppure 3 occorre caricare l’insieme dei coefficienti corrispondenteed impostare la divisione in modo da avere il giusto valore del clock ridotto,l’iterazione ciclica deve poi coinvolgere i primi 4 oppure i primi 3 rami delladecomposizione polifase invece che tutti e 6 i rami.

2.2.2.1 Modulatore classico con fclk = 4× fif

Lo schema in Figura(2.5) comporta una notevole riduzione della complessitatuttavia prevede ancora l’utilizzo di un DDFS e di una coppia di moltiplica-tori ciascuno con due ingressi a 12 bit, una loro implementazione su FPGA

13valore desunto analizzando la risposta in frequenza ai tre diversi data rate


Figura 2.5: Modulatore QPSK classico 3 data rate Ottimizzato

e particolarmente onerosa, basti pensare che nella Xilinx Virtex2 essi ven-gono realizzati come blocchi ad alto livello implementati nella BlockRAM14

e pertanto ottimizzati per velocita e dissipazione. In realta imponendo trala frequenza di clock fclk e la frequenza intermedia desiderata fif il vincolo:

fclk = 4× fif (2.2)

si ha che il seno ed il coseno vengono campionati in corrispondenza degliangoli π

2 , π, 3π2 , 2π e loro multipli in corrispondenza dei quali le due funzioni

assumono uno dei 3 valori (−1, 0, 1) come illustra la Tabella(2.2).

Angolo (rad) Coseno Senoπ2n 0 1πn −1 03π2 n 0 −1

2πn 1 0

Tabella 2.2: Coseno e seno nel caso di fclk = 4× fif

Il DDFS compie una enorme elaborazione cercando di approssimare que-sti valori come evidenziato dalla Figura(A.7) relativa ad una simulazioneVHDL, tuttavia gli stessi possono essere ottenuti in maniera molto piu effi-ciente e precisa utilizzando un contatore ed una ROM i quali sono in gradodi generare una qualsiasi sequenza ripetitiva. Dati i valori assunti da senoe coseno la moltiplicazione non e una vera moltiplicazione ma si riduce a

14Appendice(C.3.4.2)


lasciar passare il campione proveniente dall’interpolatore SRRC, annullarlooppure invertirlo in complemento a due a seconda che la funzione trigono-metrica valga rispettivamente 1, 0 oppure −1. Lo schema che deriva dalleprecedenti considerazioni e mostrato in Figura(2.6)

Figura 2.6: Modulatore QPSK classico 3 data rate fclk = 4× fif

Un’ultima importante osservazione sulle sequenze seno e coseno che sihanno sotto l’ipotesi fclk = 4 × fif e che esse alternano uno zero ad unaltro valore, quindi in sostanza effettuano un’interpolazione di valore 2 chee in cascata a quella prodotta dall’SRRC polifase, essa puo pertanto esse-re ridotta consentendo al polifase di operare ad una frequenza piu bassa,tale opportunita non e stata utilizzata in quanto l’ortogonalita delle duesequenze consente un’ottimizzazione ancor piu rilevante come descritto nelCapitolo(4).

L’unico svantaggio arrecato dal vincolo fclk = 4 × fif e che fif non epiu 40MHz bensı 41, 25MHz, non appare tuttavia come una grande limi-tazione in quanto in ogni caso l’uscita modulata, centrata sulla frequenzaintermedia, deve essere traslata a frequenze piu consone alla trasmissionesatellitare.

Capitolo 3

Implementazione SRRCpolifase

3.1 Sommario

La struttura polifase ha un ruolo preponderante nell’architettura del modu-latore pertanto ogni miglioramento ad essa apportato si riversa in manieraproporzionale sulle prestazioni globali del circuito. Dopo aver descritto ilprogetto del filtro SRRC da essa ospitato, si passa a definire due diver-se realizzazioni, la prima deriva direttamente dalla teoria e non e adattaad una implementazione su FPGA, la seconda comporta una progettazio-ne piu elaborata ma l’implementazione e semplificata, vengono presentateentrambe al fine di mettere in evidenza le scelte progettuali.

3.2 Progetto del filtro SRRC

Le considerazioni emerse nella trattazione dell’ISI1 hanno portato ad indi-viduare la seguente famiglia di spettri a coseno rialzato:

Hrc (f) =

T se 0 ≤ |f | ≤ (1+α)

2TT2

[1 + cos πT

α

(|f | − (1−α)

2T

)]se (1+α)

2T ≤ |f | ≤ (1−α)2T

0 se 0 ≤ |f | ≥ (1−α)2T

(3.1)per essa le specifiche prevedono un fattore di roll-off α = 0, 35 scelto comecompromesso tra utilizzazione della banda e complessita della realizzazio-ne, la risposta in frequenza viene suddivisa equamente tra trasmissione ericezione

|HTx (f)| = |HRx (f)| =√Hrc (f) (3.2)

1Sezione(1.3.3)

33

CAPITOLO 3. IMPLEMENTAZIONE SRRC POLIFASE 34

in modo da poter utilizzare il filtro in ricezione anche come filtro adattatoe quindi demodulatore secondo quanto visto in Sezione(1.3.1).

Il progetto del filtro e stato effettuato col metodo del campionamentodella risposta in frequenza data dalle equazioni (3.1) e (3.2), di essa si pren-dono N−1

2 campioni e per simmetria si ricavano i restanti N−12 , effettuando

per ciascuno di essi la IDFT2 si ottiene un campionamento della rispostaimpulsiva e quindi gli N coefficienti del filtro SRRC. L’espressione dellaIDFT e:

hd (n) =N−1∑k=0

Hd (k) e(2πN )kn (3.3)

che per la condizione di simmetria si riduce a:

hd (n) = Hd (0) +

N−12∑

k=0

Hd (k) cos(

2πNkn

)(3.4)

L’anticausalita viene rimossa traslando la risposta impulsiva di N−12 cam-

pioni.Non necessariamente un numero di campioni maggiore si traduce in un

aumento dell’attenuazione del filtro in banda oscura, ad esempio il filtroSRRC interpolante 6 e stato realizzato con 39 coefficienti piuttosto che coni 42 consentiti dall’architettura in quanto per quest’ultimo valore gli estremidella risposta impulsiva hanno un’ampiezza maggiore che si traduce in uninnalzamento della soglia del rumore. Partendo da questa considerazione etenendo conto del fatto che i tre valori di interpolazione vengono implemen-tati tutti con una unica architettura, si e individuato il n di coefficientiottimale nei tre casi, in particolare l’interpolazione 3 viene realizzata con 19coefficienti, l’interpolazione 4 con 25 coefficienti e l’interpolazione 6 con 39coefficienti.

La tecnica di progetto basata sul campionamento in frequenza ben sipresta ad una eventuale compensazione della risposta in frequenza del DAC3

dovuta al mantenimento di ordine zero:

HDAC (f) =sin(

πffs

)πf

e−π

(ffs

)(3.5)

tale compensazione si realizza moltiplicando la risposta in frequenza del-l’SRRC per l’inverso della risposta in frequenza del DAC per poi procedereal campionamento della risposta globale.

2Inverse Discrete Fourier Transform3Digital Analog Converter


3.3 Implementazione polifase SRRC

La decomposizione polifase4 puo essere implementata in maniera immediatadistribuendo ciclicamente i coefficienti del filtro SRRC su un banco di N filtriFIR con N pari al valore di interpolazione desiderata. Ogni FIR utilizza 7coefficienti pertanto per interpolare 3 i 19 coefficienti con l’aggiunta di duecoefficienti nulli vengono distribuiti sui primi 3 FIR, per interpolare 4 i 25coefficienti piu 3 nulli sono applicati ai primi 4 FIR ed infine per interpolare6 i 39 coefficienti piu due nulli vengono distribuiti su tutti i FIR.

3.3.1 Modello Matlab

Lo script Matlab CreaCoeffsFreqSamplScaled.m (Listato E.3.1) effettuail calcolo dei coefficienti del filtro SRRC in accordo alla teoria espressa inSezione(3.2), in particolare la risposta in frequenza descritta dall’equazio-ne(3.1) e implementata dalla funzione RaisedCosineResponse.m (Lista-

to E.3.3) . La distribuzione dei coefficienti sui diversi filtri viene eseguitatramite la funzione applica polifase.m (Listato E.3.2) , essa calcola il nu-mero dei FIR in base al valore dell’interpolazione poi associa a ciascunodi essi una riga in una matrice che viene riempita una colonna alla voltasino all’esaurimento dei coefficienti. La sequenza dati di test viene applicataad ognuno di questi FIR tramite la funzione filter, di Matlab, ottenendouna matrice con un numero di righe pari al numero di FIR ed un nume-ro di colonne pari alla dimensione del vettore di test, gli elementi di questamatrice vengono prelevati colonna per colonna modellando cosı il comporta-mento del commutatore presente nella descrizione della architettura polifaseottimizzata, di questo vettore viene calcolato lo spettro. CreaCoeffsFre-qSamplScaled.m (Listato E.3.1) consente anche di scalare i coefficienti alfine di utilizzare al massimo la dinamica della rappresentazione in comple-mento a due utilizzata5 in particolare la somma che si effettua in ogni FIRdel polifase deve valere al massimo 1, essa e nota a priori in quanto sononoti i coefficienti ed il segnale d’ingresso appartiene all’insieme (+1,−1).Lo stesso CreaCoeffsFreqSamplScaled.m (Listato E.3.1) consente il con-fronto tra il filtro progettato col campionamento in frequenza e quello cheMatlab progetta automaticamente con la funzione rcosine, tale confrontomostra come le prestazioni del campionamento in frequenza siano netta-mente superiori. La risposta in frequenza ed all’impulso degli SRRC per itre data rate richiesti in specifica e rappresentata nelle Figure (3.1), (3.2)e (3.3) che evidenziano una differenza di circa 40dB tra banda passante ebanda oscura.

4Appendice(B.3.2)512 bit di cui 1 per il segno ed i restanti per la parte dopo la virgola


(a) Risposta in frequenza (b) Risposta all’impulso

Figura 3.1: SRRC 19 coefficienti interpolante 3






3.4 Modello VHDL

Le differenze sostanziali tra le due implementazioni VHDL del polifase risie-dono nella strategia di creazione e distribuzione dei clock ridotti, generatia partire dal clock di sistema a 165MHz, e nella dislocazione della logicacombinatoria.

3.4.1 Polifase standard gated-clock

Questa realizzazione e costituita principalmente da due blocchi:

SRRCxN: incorpora i FIR ed un multiplexer che seleziona ciclicamente,ad ogni colpo di clock, l’uscita di uno di essi.

RateAdapter: in funzione del data rate selezionato applica ad SRRCxNil giusto set di coefficienti, il clock ridotto ed una conta ciclica da 0 aN-1 essendo N il valore dell’interpolazione.

3.4.1.1 SRRCxN

Nello schema a blocchi in Figura(3.4), associato al file srrc x n.vhd

Figura 3.4: SRRC interpolante 3, 4, 6


(Listato F.2.10) , si ha che il multiplexer descritto in mux 6.vhd (Lista-

to F.2.15) opera alla frequenza di clock mentre ciascuno dei 6 FIR descrit-to da fir 1.vhd (Listato F.2.11) e rappresentato in Figura(3.5) utilizza la

Figura 3.5: FIR iesimo

stessa temporizzazione dei dati in ingresso.I moltiplicatori sono in genere la parte piu delicata nelle implementa-

zioni di algoritmi DSP6 su FPGA, laddove possibile e bene non utilizzarli osemplificarli al massimo, nel modulatore QPSK il segnale d’ingresso ai FIRpuo assumere soltanto i valori7 +1 e −1 pertanto ogni moltiplicatore puo es-sere sostituito con una descrizione VHDL che ad ogni colpo del clock ridottopresenta in uscita il valore del coefficiente o il suo negato. La negazione di unnumero rappresentato in complemento a due si realizza invertendone tuttii bit e sommando 1, necessita pertanto di un sommatore che e un altro deicircuiti critici dei DSP, per evitarlo dato il numero esiguo di coefficienti si escelto di fornire alla descrizione VHDL fir multiplier.vhd (Listato F.2.13)

che di fatto sostituisce il moltiplicatore, sia il coefficiente che il suo negato.La somma delle uscite dei moltiplicatori viene effettuata in adder 7.vhd(Listato F.2.12) , un sommatore la cui complessita limita le prestazioni delmodulatore sia perche e costituito da 7 ingressi a 12bit sia perche lo schemadel modulatore in Figura(2.6) ne richiede 12.

Gli elementi di ritardo tipici dei FIR sono realizzati con un registro a6Digital Signal Processing7due valori si rappresentano con 1 solo bit anche se in complemento a due a +1

corrisponde 01 e a −1 corrisponde 11


scorrimento SIPO8 il cui VHDL e in shift reg.vhd (Listato F.2.14) , talesoluzione e migliore rispetto al mettere in cascata 7 descrizioni FFD9 inquanto segnala chiaramente al sintetizzatore VHDL che essi debbono esserposti quanto piu vicini possibile tra di loro.

3.4.1.2 Rate Adapter

Nello schema a blocchi in Figura(3.6), associato al file rate adapter.vhd

Figura 3.6: Rate Adapter

(Listato F.2.3) , si ha che selector.vhd (Listato F.2.9) a seconda del data rateimpostato tramite rate sel seleziona uno tra i contatori/divisori descrittida counter divider 3.vhd (Listato F.2.5) , counter divider 4.vhd(Listato F.2.6) e counter divider 6.vhd (Listato F.2.8) , tra essi il piucritico e senza dubbio il contatore/divisore per 3 in quanto utilizza entrambei fronti del clock e pertanto e come se operasse ad una velocita di clockdoppia rispetto agli altri due.

La selezione di quale banco di coefficienti utilizzare viene effettuata incoeffs selector.vhd (Listato F.2.4) basandosi sul valore di rate sel, si trat-ta di una descrizione non efficiente in quanto il sintetizzatore la implementa

8Serial In Parallel Out9Flip Flop D


con un multiplexer le cui dimensioni divengono molto grandi al crescere delnumero di coefficienti.

Trattandosi di una architettura gated-clock , si ha che i clock ridottivengono generati con elaborazioni combinatorie sul clock di sistema, cio e daevitare in quanto un semplice rumore, termico o ambientale, puo dar luogo aproblemi di corsa critica, per questo motivo viene preferita la tecnica clock-enable nella quale tutti i blocchi che richiedono il clock ridotto operano inrealta col clock di sistema ma dispongono di un segnale di abilitazione clock-enable pilotato tramite della logica combinatoria anch’essa temporizzata dalclock di sistema, in tal modo non e nemmeno piu necessario che i clockridotti abbiano un duty-cycle del 50%.

3.4.1.3 Risultati sperimentali

Il VHDL di questo progetto e stato ampliamente testato ed ha rappre-sentato un punto di partenza verso una conoscenza piu approfondita delletematiche della sintesi tuttavia non e stata effettuata alcuna implementa-zione su FPGA in quanto l’eccessiva sensibilita del gated-clock lo rendeinadatto ad applicazioni spaziali dove i circuiti sono soggetti a radiazioni,stress meccanici e termici.

3.4.2 ROM Polifase clock-enable

La Figura(3.5) e il punto di partenza per una semplificazione sostanzialedel polifase e quindi del modulatore, essa evidenzia come ognuno degli ad-dendi che giungono al sommatore puo assumere solo due valori, quello delcoefficiente o il suo negato, pertanto il numero di combinazioni possibili alsuo ingresso e 27 = 128, un numero finito e tutto sommato limitato, di quil’idea di inserire in una ROM i risultati delle somme corrispondenti a queste128 combinazioni, eliminando in tal modo il grosso sommatore che limita lamassima frequenza di clock applicabile al modulatore.

Ogni FIR viene pertanto realizzato con una ROM ed un registro a scor-rimento nel quale fluiscono i simboli da trasmettere, le uscite in parallelodel registro individuano una locazione di memoria nella quale e memorizza-to su 12 bit il risultato della somma. Un polifase che interpoli N si realizzacon una unica ROM avente nelle prime 128 locazioni le somme per il pri-mo FIR, nelle successive 128 le somme per il secondo FIR e cosı via sinoalle somme per il FIR Nesimo. Il multiplexer che ha il compito di iterareciclicamente sulle uscite dei FIR si ottiene aggiungendo dei bit alla ROM efacendoli pilotare direttamente dal contatore/divisore che quindi in ogni pe-riodo di clock va a selezionare un diverso banco di 128 locazioni di memoriacorrispondente ad uno degli N FIR.

Sulla base delle precedenti considerazioni il polifase che consente diimplementare i 3 data rate richiesti dalle specifiche diviene quello in Fi-


gura(3.7), cui corrisponde il file srrc x n.vhd (Listato F.3.3) , in esso

Figura 3.7: SRRCxN versione ROM

il segnale rate sel imposta il data rate e conseguentemente il multiple-xer descritto in mux 3x12 (Listato F.3.5) insieme al demultiplexer de-mux 3x10.vhd (Listato F.3.4) seleziona la ROM da utilizzare tra quelledescritte in ROMx3.vhd (Listato F.3.6) , ROMx4.vhd (Listato F.3.7) eROMx6.vhd (Listato F.3.8) .

I valori da inserire nelle ROM sono determinati da CreaROM.m (Lista-

to E.3.4) a partire dal file contenente i coefficienti scalati, esso calcola tuttele possibili somme per ogni FIR, le pone in cascata, implementando cosı unintero polifase, e produce delle descrizioni della ROM in uno dei 3 formati:

COSTANTE: e il formato utilizzato per piccole ROM, viene sintetizza-to infatti come un multiplexer le cui dimensioni possono divenirerilevanti.

CASE: e adatto a ROM di medie dimensioni in quanto il costrutto VHDLCASE viene riconosciuto dal sintetizzatore XST che lo implementasulla RAM distribuita in ogni CLB10.

BlockRAM: viene utilizzato per ROM di dimensioni molto grandi imple-mentate tramite la BlockRAM11 presente nella FPGA Virtex, e unasoluzione che consente velocita di clock inferiori rispetto alla ROMdistribuita nelle CLB, tuttavia e decisamente piu agevole il Floorplan-ning12. Il file di testo prodotto puo essere applicato al Core Generatorper ottenere la BlockRAM inizializzata.

10Configurable Logic Block11Appendice(C.3.4.2)12Appendice(D.6)


La produzione e distribuzione dei clock ridotti a partire dal clock disistema a 165MHz per i motivi precedentemente espressi non avviene piusecondo la tecnica gated-clock ma secondo la clock-enable. I 3 contatori/-divisori utilizzati nel precedente progetto vengono soppiantati dal contato-re/divisore programmabile descritto in counter.vhd (Listato F.3.2) , essoproduce sia la conta ciclica sino ad N − 1 che la produzione di un impulsodi abilitazione ogni N colpi di clock destinato alle descrizioni che debbonooperare a velocita ridotta. Apparentemente, per quello che riguarda i vin-coli sulle temporizzazioni, il clock-enable introduce un abbassamento dellamassima frequenza di clock in quanto circuiti ai quali prima si applicavail vincolo del clock ridotto ora si vedono applicato il vincolo del clock disistema che e piu stringente, tuttavia per essi si puo settare una specificadenominata multi-cycle che comunica al sintetizzatore di rilassare le lorotemporizzazioni di un fattore N.


Per la versione ROM clock-enable del polifase sono state effettuate le dueseguenti verifiche sperimentali:

VHDL: si e applicata alla descrizione VHDL del polifase la medesima se-quenza applicata al polifase Matlab, gli spettri risultanti sono pratica-mente coincidenti come illustra la Figura(3.8) riferita ad un clock di

Figura 3.8: Confronto Polifase VHDL – Polifase Matlab


sistema di 40MHz generata tramite PolyphasePSDVHDLvsPSD-Matlab.m (Listato E.3.5) .

FPGA: l’implementazione su FPGA e stata abbastanza elaborata per viadella necessita di adattare il ritmo dei dati provenienti dal pattern-generator con il ritmo del segnale di abilitazione generato a partire dalclock di sistema, la soluzione trovata viene descritta in Sezione(4.3.2),qui ci si limita a riportare i risultati ottenuti tramite PolyphaseP-SDFPGAvsPSDMatlab.m (Listato E.3.7) in termini di confrontospettrale col modello Matlab, essi sono graficati in Figura(3.9) che

Figura 3.9: Confronto Polifase FPGA – Polifase Matlab

ricalca quella ottenuta per il modello VHDL.

Capitolo 4

Implementazione ModulatoreQPSK

4.1 Sommario

I principali risultati di questa Tesi sono racchiusi in questo capitolo dovevengono illustrati due diverse realizzazioni, una ricalca lo schema classicodel modulatore QPSK mentre l’altra e una diretta estensione del progettoROM Polifase clock-enable1.

Il modello Matlab dell’intero canale di comunicazione comprendente tra-smettitore, canale e ricevitore, ha consentito sia una valutazione qualitativadei risultati tramite gli spettri che una misura quantitativa tramite la BERagevolando inoltre lo sviluppo di entrambe i modelli VHDL.

4.2 Modello Matlab

La descrizione del modello e sia in QPSKModemPSDeBERVHDLv-sMatlab.m (Listato E.4.4) che in QPSKModemPSDFPGAvsPSDMa-tlab.m (Listato E.4.6) , la sua definizione si basa, per quel che riguarda iltrasmettitore, sullo schema del modulatore classico con fclk = 4× fif di Fi-gura(2.6) mentre per il ricevitore si e utilizzata la teoria della demodulazionecon filtro adattato2 ed il criterio di decisione ML descritto in Sezione(1.3.2),essa e di riferimento anche per la caratterizzazione del rumore introdottodal canale. Segue una breve descrizione del modello:

Trasmettitore: dal rapporto tra la frequenza di clock ed il ritmo di sim-bolo viene dedotto il file di coefficienti da utilizzare, essi sono calcola-ti da CreaCoeffsFreqSamplScaled.m (Listato E.3.1) e memorizzatiin SRRCx3 FreqSampl scaled.dat, SRRCx4 FreqSampl scaled.dat e

1Sezione(3.4.2)2Sezione(1.3.1)

44

CAPITOLO 4. IMPLEMENTAZIONE MODULATORE QPSK 45

SRRCx6 FreqSampl scaled.dat. La sequenza randomica dei bit datrasmettere viene caricata da bit tx.dat ed e anche utilizzata per ca-ratterizzare il modello VHDL e l’implementazione su FPGA al fine dipoter effettuare confronti in termini di BER. Dalla sequenza bit txse ne ottengono due, quella contenente i bit dispari viene applicata alramo I del modulatore mentre l’altra, contenente i bit pari, viene ap-plicata al ramo Q per poi essere applicate entrambe ai due filtri SRRCpolifase, implementati tramite applica polifase.m (Listato E.3.2) .Le uscite degli interpolatori sono moltiplicate rispettivamente con icampioni del coseno e del seno rispondenti al vincolo fclk = 4 × fif , icampioni risultanti vengono poi sommati.

Canale: viene sommato del rumore gaussiano al segnale in uscita dal mo-dulatore, nel caso di un rumore quantificato con Eb/No = 6dB l’effettoe rappresentato in Figura(4.1).

(a) Uscita Tx QPSK (b) Ingresso Rx QPSK

Figura 4.1: Effetto del canale sul segnale modulato QPSK

Ricevitore: il segnale QPSK affetto da rumore viene applicato ad unADC3 e successivamente moltiplicato per i campioni delle due por-tanti in quadratura, il successivo filtro adattato utilizza i medesimicoefficienti dell’SRRC in trasmissione ma mantiene inalterato il rit-mo dei campioni, i simboli che si ottengono alla sua uscita vengonoapplicati al decisore implementato tramite la funzione demodmap diMatlab. La sequenza di bit ricevuta viene confrontata con quella tra-smessa, non essendo stati utilizzati dei bit di segnalazione tale opera-zione si effettua traslando la sequenza ricevuta di un numero di bitN bit sfasamento Matlab rispetto a quella trasmessa, il valore vie-ne determinato in maniera empirica effettuando diverse traslazioni escegliendo quella cui corrisponde il minimo numero di bit errati.

3Analog Digital Converter


Lo script CreaTabellaBER.m (Listato E.4.1) consente una valutazioneglobale delle prestazioni del modulatore, esso infatti confronta sia in for-ma tabellare che grafica la probabilita d’errore teorica con la BER ricavatasperimentalmente, a tal fine si avvale della funzione calcolaBER.m (Lista-

to E.4.2) che valuta la BER in corrispondenza di un dato valore di Eb/No.Il numero di bit applicati al modulatore e funzione di Eb/No infatti se adesempio per un dato valore di Eb/No la probabilita d’errore e dell’ordine di10−4 allora il numero di bit da trasmettere e 10×104. La Tabella(4.1) e rife-rita al data rate 110Mbps e alla frequenza di clock 165MHz cui corrisponde

Eb/No (dB) Probabilita d’errore teorica BER Modem QPSK Matlab0 0.07864960 0.078495161 0.05628195 0.055388722 0.03750612 0.038288283 0.02287840 0.024357694 0.01250081 0.015849185 0.00595386 0.006673346 0.00238829 0.003096717 0.00077267 0.000848898 0.00019090 0.000206599 0.00003362 0.00003194

Tabella 4.1: Tabella prestazioni modem Matlab in termini di BER

la curva del BER rappresentata in Figura(4.2).

Figura 4.2: Grafico prestazioni modem Matlab in termini di BER


4.3 Modelli VHDL

Dopo aver introdotto la realizzazione VHDL dello schema di principio pre-sentato in Figura(2.6) si passa alla descrizione del progetto ThinModulatorche incorpora tutte le ottimizzazioni dedotte nel capitolo precedente e neintroduce altre consentite dall’ortogonalita dei due rami del modulatoreQPSK.

4.3.1 Modulatore classico

Lo schema in Figura(4.3) corrisponde a Modulator BlockRAM.vhd

Figura 4.3: Modulatore classico

(Listato F.4.1) , si assume che il modulatore riceva in ingresso sia la sequenzadei bit pari che quella dei bit dispari, esse vengono applicate al filtro SRRCpolifase in Figura(4.4) che si differenzia da quello di Figura(3.7) unicamenteper il modo in cui vengono memorizzati i risultati delle somme, non piu in3 ROM distribuite nelle CLB bensı in un’unica RAM4 abilitata soltanto inlettura ed implementata nella BlockRAM5 tramite un Core Xilinx.

Trattandosi di un modulatore QPSK per applicazioni spaziali sono im-portanti sia le dimensioni che la massima frequenza di clock implementabile,nel progetto della RAM si e scelto di ottimizzare quest’ultimo aspetto inse-rendo le somme per ogni interpolatore SRRC in 1024 locazioni di memoria

4inizializzata con il file generato da CreaROM.m (Listato E.3.4)5Appendice(C.3.4.2)


Figura 4.4: SRRCxN versione RAM

indipendentemente dal fatto che siano tutte necessarie oppure no, in talmodo si puo selezionare un SRRC oppure un altro applicando il segnale ra-te sel ad ulteriori 2 bit di indirizzo della RAM la quale quindi non richiedealcuna logica combinatoria a monte della sua rete di indirizzamento intrin-seca. La descrizione VHDL del polifase e in srrc x n.vhd (Listato F.4.6)

mentre il file per la simulazione della RAM e ram.vhd (Listato F.4.7) tut-tavia si puo evitare l’utilizzo del Core Xilinx istanziando 12 BlockRAM nelformato 1× 4096bit come in Figura(4.5).

Figura 4.5: RAM 12× 4096

Le due portanti in quadratura sono generate da NCO basic.vhd (Li-

stato F.4.5) a partire dal clock di sistema mediante un contatore modulo 4


alla cui conta ciclica vengono associati i valori di coseno e seno riportati inTabella(4.2), i campioni delle portanti cosı generate vengono moltiplicati per

Valore contatore Coseno Seno0 1 01 0 −12 −1 03 0 1

Tabella 4.2: Generazione funzioni trigonometriche col contatore

i campioni provenienti dagli SRRC, in particolare in multiplier I Q.vhd(Listato F.4.4) essi vengono lasciati passare, annullati oppure invertiti a se-conda del valore della corrispondente portante per poi essere sommati inadder I Q.vhd (Listato F.4.2) la cui complessita puo essere evitata, so-stituendo il sommatore con un piu semplice commutatore operante allafrequenza di clock, i due ingressi sono infatti alternativamente nulli. Taleottimizzazione, cosı come le prove sperimentali e la successiva implementa-zione su FPGA, e stata inserita nella rielaborazione del progetto denominataThinModulator la quale include anche l’interfacciamento tra il modulatoree la sorgente dei dati.

4.3.2 ThinModulator

Il nome ThinModulator6 evidenzia come in questo progetto siano state in-serite tutte le ottimizzazioni rese possibili dalla modulazione QPSK, essesono evidenziate dal diagramma temporale in Figura(4.6), relativo alla rea-

Figura 4.6: Temporizzazioni modulatore classico

6modulatore snello in inglese


lizzazione VHDL del modulatore classico di Figura(4.3), in particolare sievincono due considerazioni:

1. l’uscita QPSK out del modulatore si ottiene prelevando alternativa-mente l’uscita QPSK I del moltiplicatore sul ramo I oppure l’uscitaQPSK Q del moltiplicatore sul ramo Q.

2. le sequenze seno e coseno sono sfasate tra loro di 90, immaginando disommarle algebricamente si ottiene una sequenza che per due periodidi clock vale +1 e per i successivi due periodi vale −1.

su di esse si basa il ThinModulator mostrato in Figura(4.7),

Figura 4.7: ThinModulator

i due interpolatori SRRC vengono realizzati con una unica RAM inquanto il contenuto per il ramo I e uguale a quello del ramo Q inoltre, co-me evidenziato in Figura(4.6), un campione ogni due dell’uscita del polifaseviene annullato nel successivo moltiplicatore, pertanto e sensato intercalarei campioni, cosa che del resto nello schema in Figura(4.3) veniva effettua-ta dal sommatore d’uscita. Il commutatore mux 2x7.vhd (Listato F.5.10)

provvede ad inviare alternativamente all’unica RAM un indirizzo oppurel’altro, vengono poi aggiunti 2 bit per la selezione del FIR7 ed altri 2 bit perla selezione del data rate. Nell’architettura ThinModulator le moltiplicazio-ni e la somma finale vengono tutte effettuate in mult C2 adder.vhd(Listato F.5.9) che opera in maniera ciclica lasciando passare inalterati 2campioni provenienti dalla RAM ed invertendo i successivi due.

Il ThinModulator necessita per il suo funzionamento del contatore pro-grammabile counter.vhd (Listato F.3.2) descritto nella Sezione(3.4.2), es-so genera il segnale di abilitazione per la tecnica clock-enable e la con-ta ciclica che va a selezionare l’Nesimo banco di 128 locazioni nella RAMcorrispondente all’Nesimo FIR del polifase SRRC.

7e quindi del banco di 128 locazioni di memoria


Il modulatore QPSK effettivamente implementato sulla FPGA e quelloil cui schema a blocchi e rappresentato in Figura(4.8), esso include anche

Figura 4.8: FIFO RAM ThinModulator

una interfaccia verso il mondo esterno resasi necessaria in quanto il clockassociato ai dati provenienti dal pattern-generator ha la stessa frequenza delsegnale clock-enable ma la relazione di fase tra i due e aleatoria e pertantosi possono verificare situazioni non previste in fase di progetto.

Le possibili soluzioni al problema sono due:

1. utilizzare il clock dei dati per produrre il clock di sistema, da essopoi si ricava il segnale clock-enable, la soluzione e impraticabile inquanto le specifiche implicano la moltiplicazione del clock per fattori3, 4 e 6 mentre la FPGA Virtex consente soltanto la moltiplicazioneper 2 utilizzando una ClkDLL89 come in Figura(4.9). oppure per 4mettendone due in cascata.

2. una FIFO10 consente di mettere in fase le due temporizzazioni, essa ecostituita da un registro a scorrimento nel quale i dati vengono scrittiutilizzando la temporizzazione che giunge dal pattern-generator e lettiutilizzando quella prodotta localmente dal contatore programmabilecounter.vhd (Listato F.3.2) .

L’unica soluzione che soddisfa le specifiche del modulatore e la 2) tut-tavia essa richiede che le due temporizzazioni abbiano la stessa frequenzaaltrimenti dopo poco tempo la FIFO o si svuota o si riempie completamentedeterminando cosı perdita di informazione, per soddisfare questo vincolo si

8Appendice(C.3.4.1)9la frequenza minima in ingresso alla ClkDLL e 25MHz

10First In First Out


Figura 4.9: Clock×2

e scelto di inviare al pattern-generator, quale sincronismo per l’emissione deidati, il segnale di clock-enable che si ottiene a partire dal clock di sistema11.

Lo schema dell’interfaccia tra il modulatore e la sorgente dati e in Figu-ra(4.10) cui corrisponde Data Source Interface.vhd (Listato F.5.3) , la

Figura 4.10: Interfaccia modulatore – sorgente dati

FIFO e stata implementata con un Core Xilinx per la cui simulazione si uti-lizza asynch fifo 2x15.vhd (Listato F.5.4) , il clock in scrittura e quelloproveniente dal pattern-generator mentre quello in lettura e il clock di siste-ma tuttavia l’abilitazione alla lettura e determinata dal segnale clock-enableproveniente dal counter.vhd (Listato F.3.2) . La logica che gravita intorno

1140MHz per la scheda DINI sulla quale e stato implementato il modulatore


alla FIFO ha il compito di consentire la prima lettura soltanto dopo cheessa sia stata parzialmente riempita, si deve cioe attendere che il segnalealmost-empty passi per la prima volta al livello logico basso.


4.3.2.1.1 Test VHDL La medesima sequenza dati applicata al modelloMatlab e stata applicata alla descrizione VHDL, l’uscita e poi nuovamen-te esportata in Matlab dove, dopo una conversione dalla rappresentazionein complemento a due al formato reale, ne viene prodotto e visualizzatolo spettro confrontandolo con quello ottenuto con il modello Matlab delmodem, i due sostanzialmente coincidono come mostrato in Figura(4.11)riferita ad un modulatore interpolante 3 e che, per garantire conformita con

Figura 4.11: Confronto Modulatore x3 VHDL – Matlab

i risultati dell’implementazione su FPGA12, opera ad una frequenza di clockdi 40MHz. Per una verifica piu puntuale lo stesso script QPSKModemP-SDeBERVHDLvsMatlab.m (Listato E.4.4) realizza anche una misura diBER, a tal fine viene aggiunto del rumore gaussiano dovuto al canale edil segnale risultante e poi applicato al demodulatore che richiede di essertarato con la procedura inserita quale commento nello script, la corretta ta-ratura del demodulatore consente di ottenere misure di BER praticamenteidentiche ai risultati teorici.

12la scheda DINI ospita un quarzo a 40MHz eventualmente modificabile


4.3.2.1.2 Test FPGA La sequenza da trasmettere e stata caricata nelPattern Generator tramite il file di testo prodotto da CreaSequenzaPat-ternGenerator.m (Listato E.2.2) del quale si propone il seguente stralcio:

ASCII 000000ASCDOWNFORMAT:MODE FULLFORMAT:CLOCK EXTERNAL, LEFiftyLABEL dummy, 24LABEL data_in_SRRCxN_tx_Q, 4LABEL rate_sel_x3, 4LABEL reset, 4LABEL data_in_SRRCxN_tx_I, 4VECTOR000000 0 0 1 0000000 0 0 1 0000000 0 0 1 0000000 0 0 1 0000000 0 0 1 0000000 0 0 0 0000000 0 0 0 0000000 0 0 0 0000000 0 0 0 0000000 0 0 0 0*M000000 0 0 0 0000000 1 0 0 0000000 1 0 0 0000000 0 0 0 1000000 0 0 0 0000000 0 0 0 1000000 1 0 0 1000000 1 0 0 1000000 0 0 0 0...... . . . .000000 0 0 0 1

essa segnala al pattern-generator di predisporsi per ricevere dall’esternoil sincronismo per il clock associato ai dati emessi i quali sono allocatisui canali data in SRRCxN tx I e data in SRRCxN tx Q mentre ra-te sel x3 imposta il data rate e reset consente l’inizializzazione della FP-GA. Il segnale reset e al livello 1 soltanto nella sequenza che precede *Min quanto questa viene emessa una sola volta mentre la sequenza successivaviene ripetuta ciclicamente un numero infinito di volte.


Le connessioni tra pattern-generator, scheda DINI ed analizzatore di statilogici sono descritte nel seguente testo estratto dal file .ucf il quale vieneutilizzato per immettere i vincoli fisici e temporali nella sintesi del progettosulla FPGA Xilinx Virtex1000BG560-4:

################################################NET "clk" LOC = "D17"; #clock a 40MHz interno################################################# POD CLK PATTERN GENERATOR #################################################NET "data_in_clk" LOC = "A17"; #JP11 pin 12NET "data_in_clk_sync" LOC = "C28"; #JP1 pin 20################################################# POD 1 PATTERN GENERATOR #################################################NET "reset" LOC = "AE31"; #JP12 pin 10NET "data_in_I" LOC = "AD29"; #JP12 pin 8NET "data_in_q" LOC = "V29"; #JP12 pin 3################################################# POD 2 PATTERN GENERATOR #################################################NET "rate_sel<0>" LOC = "V31"; #JP12 pin 4NET "rate_sel<1>" LOC = "Y29"; #JP12 pin 6################################################## POD 2 ANALIZZATORE STATI #################################################NET "modulator_out<0>" LOC = "C29"; #JP6 pin 1NET "modulator_out<1>" LOC = "A31"; #JP6 pin 3NET "modulator_out<2>" LOC = "B30"; #JP6 pin 5NET "modulator_out<3>" LOC = "C30"; #JP6 pin 7NET "modulator_out<4>" LOC = "D28"; #JP6 pin 9NET "modulator_out<5>" LOC = "F29"; #JP6 pin 13NET "modulator_out<6>" LOC = "H31"; #JP6 pin 15NET "modulator_out<7>" LOC = "P30"; #JP6 pin 19NET "modulator_out<8>" LOC = "A28"; #JP6 pin 4NET "modulator_out<9>" LOC = "C27"; #JP6 pin 8NET "modulator_out<10>" LOC = "D32"; #JP6 pin 10NET "modulator_out<11>" LOC = "E30"; #JP6 pin 12NET "data_out_clk" LOC = "B29"; #JP1 pin 19################################################# AZIONAMENTO MANUALE #################################################NET "count_clk_en_reset" LOC = "AK24"; #JP12 pin 15


Al fine di agevolare il raggiungimento dei vincoli temporali con stati scelti ipin della FPGA piu vicini alle 12 BlockRAM utilizzate nel progetto, esse sitrovano infatti distribuite in due colonne laterali.

L’analizzatore di stati logici consente di prelevare dall’uscita del mo-dulatore un pacchetto di 64000 campioni adiacenti, applicandoli allo scriptMatlab QPSKModemPSDFPGAvsPSDMatlab.m (Listato E.4.6) sonostati ottenuti gli spettri mostrati nelle figure (4.12), (4.13) e (4.14), es-si evidenziano una forte similitudine tra il risultato teorico ed il risultatosperimentale.

Figura 4.12: Confronto Modulatore x3 FPGA – Matlab

Capitolo 5

Conclusioni

E’ stato progettato ed implementato su FPGA un modulatore QPSK conottime prestazioni sia in termini di purezza spettrale che di BER, la sempli-cita dell’architettura individuata la rende fortemente suscettibile ai continuiprogressi apportati alle moderne FPGA dalle principali fonderie.

Possibili evoluzioni di questo lavoro di Tesi possono riguardare i seguentiaspetti:

• determinazione del numero di bit effettivamente necessari in uscitadal modulatore, una riduzione in tal senso si rifletterebbe proporzio-nalmente sulle dimensioni della ROM.

• il modulatore e pensato per applicazioni spaziali, un ambiente parti-colarmente ostile per i circuiti a larga scala di integrazione richiedepertanto l’implementazione di una tecnica di riconfigurazione cicli-ca volta a ridurre gli effetti delle radiazioni sul funzionamento delcircuito.

• realizzazione di una scheda che applichi l’uscita del modulatore ad unconvertitore digitale/analogico il quale dovra essere precompensatotramite i coefficienti del filtro ospitato dalla struttura polifase.

L’architettura proposta e stata sviluppata su FPGA tuttavia essa sicompone di una ROM, dei registri a scorrimento e poca altra logica com-binatoria, si puo pertanto ipotizzare una realizzazione non su logiche pro-grammabili quali FPGA o ASIC bensı su componenti VLSI commerciali.

58

Appendice A

Sintesi diretta di frequenzadigitale

A.1 Sommario

La generazione di portanti sinusoidali, una delle funzioni chiave dell’elettro-nica applicata alle telecomunicazioni, e stata realizzata con tecniche analo-giche sino agli anni ’70 quando l’avvento dei circuiti a larga scala d’integra-zione ha aperto la strada a realizzazioni digitali con prestazioni decisamentesuperiori, esse permettono infatti di variare la frequenza in istantaneamentee con continuita di fase raggiungendo risoluzioni dell’ordine del µHz, il tuttocon costi e dimensioni contenuti.

L’unico aspetto nel quale le tecniche analogiche sono superiori e l’esten-sione spettrale che raggiunge diversi GHz pertanto la norma di progettoe di utilizzare tecniche digitali laddove possibile ed integrarle con tecnicheanalogiche negli altri casi.

A.2 DDFS

La sintesi diretta di frequenza digitale si basa sullo schema in Figura(A.1)che viene indifferentemente denominato DDS1, NCO2 oppure DDFS, essogenera una funzione a frequenza arbitraria e non lineare, quale il seno o ilcoseno3, nei tre seguenti passi:

1. genera una sequenza di valori dell’argomento variabile in funzionedella frequenza che si desidera ottenere.

2. associa alla sequenza generata le corrispondenti ampiezze del seno odel coseno.

1Direct Digital Synthesizer2Numerical Control Oscillator3caratterizzate tuttavia da un argomento ϕ lineare nel tempo

59

APPENDICE A. SINTESI DIRETTA DI FREQUENZA DIGITALE 60

Convertitore Fase-Ampiezza

Accumulatore di fase

Registro Incremento

fase (T)

Registro di fase

Convertitore Digitale/Analogico FiltroA-1 A-1 A A

A

P B

Figura A.1: Schema di principio DDFS

3. converte in analogico l’ampiezza espressa in digitale.

Con riferimento alla Figura(A.1) la sequenza dei valori dell’argomento, cia-scuno rappresentato con A bit, viene generata mediante l’accumulatore difase, esso si compone di un registro di fase e di un sommatore che aggiungeal valore precedentemente contenuto nel registro il valore T di una paro-la di sintonia contenuta in un registro ad A−1 bit4. Variando il valore Tcontenuto nel registro di incremento il progettista o l’operatore ha modo divariare la frequenza generata dal DDFS:

fout =T × fclk

2A(A.1)

per variare la risoluzione in frequenza occorre invece cambiare il numerodi bit A del registro di fase, si tratta di un valore da decidere in sede diprogetto tenendo conto della applicazione cui e destinato il DDFS, valorielevati di A infatti aumentano la risoluzione, pari a fclk

2A , ma comportano unamaggiore complessita circuitale e conseguentemente una minor frequenza diclock applicabile al sistema il che per il teorema di Nyquist5 si traduce inuna riduzione della massima frequenza generabile.

Dopo aver generato la rampa di fase il convertitore fase/ampiezza latrasforma nella funzione sinusoidale prescelta, esso ha in ingresso P bits conP A in quanto l’utilizzo di tutti i bit che provengono dall’accumulatore difase determina una complessita non gestibile indipendentemente dal modoin cui il convertitore e realizzato. Il troncamento della fase determina inuscita dal DDFS la presenza di spurie la cui distribuzione ed ampiezzapuo tuttavia essere controllata mediante una opportuna pianificazione dellefrequenze.

4per ottemperare al criterio di Nyquist5Appendice(B.2)


La sequenza discreta ottenuta dal convertitore fase-ampiezza viene ap-plicata ad un DAC il cui numero di bit B in ingresso determina il massimolivello delle spurie da esso prodotte, l’ordine zero del campionamento da poiluogo ad una sagomatura sin(x)

x dello spettro che richiede una precompensa-zione. Il filtro anti-aliasing ha il compito di lasciare passare in uscita il solo

Figura A.2: Spettro in uscita dal DAC

spettro compreso nella banda 0 < fout <fclk2 detta di Nyquist.

A.3 Pianificazione delle frequenze

A.3.1 Spurie dovute al DAC

Come evidenziato in Figura(A.2) la non-linearita del DAC genera alla suauscita oltre alla frequenza fondamentale fout anche delle immagini aven-ti frequenza fclk ± fout, scegliendo fout > fNyquist abbiamo che la primaimmagine cade nella banda di Nyquist e quindi non puo essere filtrata per-tanto, tenendo conto anche della banda di transizione non nulla del filtroanti-aliasing, si ha che la massima frequenza generabile e dell’ordine di0, 4fout.

La distribuzione delle spurie dovute al DAC e imposta dalla relazionetra fclk e fout mentre la loro ampiezza e determinata dal numero di bit Bin particolare abbiamo che il rapporto S

N espresso in dB tra il segnale ed ilrumore di quantizzazione [10] vale:

SN (dB) = 6.02×B + 1.76 + 20 log10(FFS) (A.2)

dove con FFS si indica la percentuale del fondoscala a cui lavora il DAC.La potenza del rumore di quantizzazione e costante per un dato valore

di B pertanto se si riduce la banda utile ossia si lavora in una frazione dellabanda di Nyquist si ottiene un miglioramento del rapporto S

N .


A.3.2 Spurie dovute al troncamento della fase

La risoluzione in frequenza aumenta al crescere del numero di bit A nell’ac-cumulatore di fase tuttavia, allo stato attuale della tecnica, soltanto i P bitpiu significativi possono essere applicati al convertitore fase-ampiezza chealtrimenti diviene irrealizzabile.

Il troncamento da luogo ad un errore che e periodico e pertanto producedelle frequenze spurie in uscita dal DDFS, la loro ampiezza varia da unminimo di 0 quando i P bit eliminati sono tutti 0, condizione che si verificaper6:

GCD(T, 2(A−P )

)= 2(A−P ) (A.3)

ad un massimo di −6.02P dBc nel caso l’MSB7 dei P bit troncati sia 1 etutti gli altri siano 0 il che accade se:

GCD(T, 2(A−P )

)= 2(A−P ) (A.4)

Per comprendere la distribuzione di queste spurie si parte dall’osservazioneche il segnale d’errore e proprio la parola troncata espressa su R = A−Pbits, la parola di sintonia ad essa associata e ETW = T mod

(2R)

la qualeaccumulandosi da luogo alla forma d’onda a dente di sega di Figura(A.3)avente frequenza fondamentale F0 = Fclk ×

(ETW

2R

)e spettro rappresentato

Figura A.3: Andamento nel tempo della parola troncata

in Figura(A.4). Le righe spettrali che cadono in multipli dispari della banda

Figura A.4: Spettro dente di sega

di Nyquist hanno delle immagini proprio all’interno di essa e pertanto nonsono eliminabili mediante filtraggio, si puo soltanto ridistribuirne la potenza

6GDC indica il massimo comun divisore tra i due argomenti7Most Significant Bit


mediante la tecnica del dithering che consiste nel distruggere la periodicitaaggiungendo delle quantita randomiche prima del troncamento.

A.4 Convertitore Fase-Frequenza

Vi sono due tipi di convertitore fase-ampiezza:

ROM le fasi troncate in uscita dall’accumulatore di fase individuano dellelocazioni di memoria in una ROM le quali contengono la corrispon-dente ampiezza del seno o del coseno. La simmetria del coseno e delseno consente di ridurre le dimensioni della ROM limitandosi a me-morizzare i valori delle ampiezze per le sole fasi comprese tra 0 e 90

ed utilizzando i due bit piu significativi della parola di fase troncataper ricostruire l’ampiezza corretta come in Figura(A.5).

Figura A.5: Ottimizzazione del convertitore fase-ampiezza

CORDIC la simmetria del coseno e del seno viene utilizzata anche nel-la soluzione CORDIC [9], della quale esistono due forme denominateVectoring CORDIC e Rotation CORDIC, quest’ultima e quella utileper la generazione di seno e coseno a partire dall’argomento, si cercainfatti di annullare l’angolo ϕ iniziale sommando e sottraendo ad essodegli angoli via via piu piccoli, al crescere del numero di iterazioniaumenta la precisione del risultato e conseguentemente migliora l’ap-prossimazione sia per il seno che per il coseno dell’angolo di partenza.L’algoritmo e adatto ad applicazioni digitali in quanto le rotazioni sibasano su moltiplicazioni per potenze di due.

La ROM risulta una soluzione conveniente nel caso si scelga una fasetroncata con al massimo 14 bit [14], oltre conviene la soluzione CORDICla quale ha anche il vantaggio di produrre congiuntamente ed in maniera


intrinseca sia seno che coseno risultando ottimale per la realizzazione di unmodulatore con portanti in quadratura, per questi motivi nel seguito verratralasciata la trattazione del DDFS basato sulla ROM.

A.4.1 Algoritmo CORDIC

Si basa su di una rotazione planare che trasforma un vettore (Xi, Yi) inun nuovo vettore (Xn, Yn), la forma matriciale di una generica rotazione

(Xn , Yn)

(Xi , Yi)

X

Y

Figura A.6: Rotazione planare

planare di un angolo ϕ e[Xn

Yn

]=[

cosϕ sinϕsinϕ cosϕ

] [Xi

Yi

](A.5)

trattandosi di un algoritmo iterativo la rotazione ϕ viene scomposta in nrotazioni ϕi ciascuna delle quali e espressa dalla[

Xi+1

Yi+1

]=[

cosϕi sinϕi

sinϕi cosϕi

] [Xi

Yi

](A.6)

da cui raccogliendo cos (ϕi) si ha[Xi+1

Yi+1

]= cosϕi

[1 − tanϕi

tanϕi 1

] [Xi

Yi

](A.7)

quest’ultima forma e vantaggiosa in quanto il numero di moltiplicazionipassa da 4 a 3, l’ulteriore vincolo

tanϕi = Si2(−i) (A.8)


con Si ∈ −1;+1 consente di ottimizzare l’implementazione su sistemidigitali in quanto le moltiplicazioni per potenze di due si ottengono facendoscorrere il contenuto di un registro in una direzione o nell’altra.

Il valore di Si alla iesima iterazione viene determinato richiedendo chesia minima la differenza tra l’angolo iniziale e l’angolo che si ottiene dallasomma degli angoli delle iterazioni precedenti, se tale differenza e minore dizero allora Si = −1 altrimenti Si = +1.

Il vincolo descritto dall’equazione(A.8) e fondamentale nella semplifica-zione dell’algoritmo in quanto cos (ϕi) = cos (−ϕi) e quindi per una dataiterazione n la produttoria dei cos (ϕi) delle iterazioni precedenti e nota apriori e vale

Kn =n−1∏i=0

Ki =n−1∏i=0

cos

(arctan

(12i

))=

n−1∏i=0

√1 + 2(−2i) (A.9)

tale valore approssima 0, 607252935008881 per n → ∞ ma gia per n = 5vale 0, 607351770141296 pertanto per algoritmi CORDIC con un numero diiterazioni maggiori di 10 si puo considerare un numero costante soprattuttoin considerazione della lunghezza finita dei registri. Il reciproco di K va-le approssimativamente 1, 64676025812107 ed e denominato guadagno delCORDIC, se occorre che il vettore risultante abbia modulo unitario deveessere compensato utilizzando una delle seguenti strategie:

1. per la prima iterazione si ha Xi = 1 , Yi = 0 , alla fine occorre divideresia Xn che Yn per il guadagno.

2. iniziando con Xi = 0.607351770141296 , Yi = 0 non e poi necessariodividere per il guadagno tuttavia le prestazioni sono inferiori rispettoalla soluzione precedente in quanto 0, 607351770141296 non e potenzadi due e quindi la sua implementazione in un registro implica un erroreiniziale.

3. compensazione del guadagno ad ogni iterazione.

Omettendo K per semplicita di rappresentazione si ha che l’iesima itera-zione del CORDIC e descritta dalle equazioni:

Xi+1 = Xi − Si2(−2i)Yi

Yi+1 = Yi + Si2(−2i)Xi

ϕi+1 = ϕi − Si arctan 2(−2i)

(A.10)

A.5 Descrizione modello matematico

Lo script Matlab che descrive l’NCO e NCO Q.m (Listato E.1.1) , tramiteImposta frequenze Q (Listato E.1.2) vengono impostate la frequen-


za di clock e quella desiderata in uscita mentre Imposta NCO Q.m(Listato E.1.3) consente di impostare i parametri:

n bit acc N di bit accumulatore di fasen periods N di periodi della funzione generatan bit cordic N di bit per la fase troncatan it cordic N di iterazioni del CORDICn bit dac N di bit per seno e coseno prodotti dal CORDIC

L’accumulatore di fase in Crea super accumulatore Q.m (Lista-

to E.1.4) e modellato con un vettore contenente tutti i valori consecutivi dellafase da applicare al CORDIC, in tale vettore sono memorizzate n periodsrampe di fase. Tronca Q.m (Listato E.1.5) consente di passare da una rap-presentazione della fase su n bit acc bits ad una su n bit cordic bits, talevettore quantizzato e poi utilizzato da Crea coseno e seno Q.m (Li-

stato E.1.6) il quale per ogni campione di fase invoca Forward cordic Q.m(Listato E.1.7) che opera riportando tutte le fasi nel primo quadrante in ac-cordo alla Figura(A.5) ed eseguendo iterativamente per n it cordic volte leequazioni(A.10). Partendo con il coseno che vale 0, 607252936517011 inveceche 1 non e necessario dividere dopo l’ultima iterazione per il guadagno delCORDIC8 tuttavia occorre riportare i valori calcolati nel giusto quadrante,del seno e coseno ottenuti viene visualizzato un periodo nel dominio deltempo come in Figura(A.7) relativa al caso di fclk = 4× fout.

(a) Coseno (b) Seno

Figura A.7: Uscita DDFS nel tempo

Per la determinazione dello spettro viene utilizzato il metodo Multi-Taper in Visualizza spettro e SFDR p.m (Listato E.1.9) il qualemostra anche l’SFDR9 determinato in Calcola SFDR.m (Listato E.1.10)

quale differenza tra il massimo assoluto dello spettro ed il maggior massimorelativo, un esempio dei risultati ottenuti e in Figura(A.8).

A.6 Descrizione modello VHDL

Il file NCO.vhd (Listato F.1.1) descrive lo schematico di Figura(A.9), quando8Appendice(A.9)9Spurious Free Dynamic Range


Figura A.8: Spettro Coseno Matlab

clk coseno(11:0)fase(12:0)

seno(11:0)

U0

cordic_pipelined_unrolled

clkout_delay_13in_delay_13

U1

delay_13


U2

delay_13


U3

delay_13

ingresso(31:0) uscita(12:0)

U5 troncatore_12

coseno(11:0)

seno(11:0)load

clear

freq_word(31:0)Theta_tr(12:0)

Theta_tr(12)

Theta_tr(12)

fase(12:0)

Theta_tr(11)

ctrl_segno_seno

cos(11:0)

sin(11:0)

Theta(31:0)

clear

theta(31:0)

clk

freq_word(31:0)

load

U4 accumulator

in_tfq(12:0) out_tfq(12:0)

U6

to_first_quadrant

ctrl(1:0)

ctrl(1)

ctrl(0)

ctrl(1:0)

out_cosine_rebuild(11:0)in_cosine_rebuild(11:0)

U8 cosine_rebuild

ctrlout_sine_rebuild(11:0)in_sine_rebuild(11:0)

U7 sine_rebuild

Figura A.9: NCO VHDL

LOAD e alto l’accumulatore Accumulator.vhd (Listato F.1.2) viene cari-cato con la parola di sintonia il cui valore in binario viene calcolato tramitelo script Matlab Calcola incremento fase NCO.m (Listato E.1.11) adogni colpo di clock questo incremento si somma al valore precedentemente


contenuto nel registro a 32 bit per poi essere troncato a 12 bit tramite Tron-catore 12.vhd (Listato F.1.14) , i 2 bit piu significativi vengono ritardatida Delay 13.vhd (Listato F.1.11) di 13 periodi di clock in modo da poterassociare al giusto quadrante il seno ed il coseno calcolati per un dato valo-re della fase che viene confinata tra 0 e 90 da To first quadrant.vhd(Listato F.1.13) , in pratica questi due bit vanno a pilotare delle inversioni incomplemento a due realizzate condizionatamente in Cosine rebuild.vhd(Listato F.1.10) e Sine rebuild.vhd (Listato F.1.12) .

Coseno e seno vengono calcolati mediante un’architettura CORDIC noniterativa al fine di ottenere la massima velocita di clock di sistema, ogni ite-razione e effettuata tramite Cordic base j.vhd (Listato F.1.4) in accordoalle equazioni(A.10) visivamente descritte in Figura(A.10).

in_x(11:0)

in_y(11:0)

in_z(12:0)

a_cost_j(12:0)

coseno(11:0)

seno(11:0)

clk

clk

out_reg_12(11:0)in_reg_12(11:0)

U0 reg_12

clk

out_reg_12(11:0)in_reg_12(11:0)

U1 reg_12

in_shifter(11:0) out_shifter(11:0)

U2 shifter

in_a(11:0)

out_adder_12(11:0)

in_b(11:0)sgn

U4 adder_12

in_a(11:0)

out_adder_12(11:0)

in_b(11:0)sgn

U5 adder_12

in_a(12:0)

out_adder_13(12:0)

in_b(12:0)

sgn

U7 adder_13

clk

clk

out_reg_13(12:0)in_reg_13(12:0)

U6 reg_13

clk

clk

sgn

z_out_reg(12:0)

fase_j(12:0)

in_shifter(11:0) out_shifter(11:0)

U3 shifter

x_out_reg(11:0)

y_out_reg(11:0)

shifter_to_adder_x(11:0)

shifter_to_adder_y(11:0)

clk

z_out_reg(12)

z_out_reg(12)

Figura A.10: Iterazione iesima

Vengono eseguite 13 iterazioni in cascata, tramite la descrizione Cor-dic pipelined unrolled.vhd (Listato F.1.3) cui e associato lo schema inFigura(A.11) in esso i valori degli angoli elementari da sommare o sottrar-re vengono calcolati ed espressi in binario tramite lo script Matlab Cal-cola rotazioni Cordic.m (Listato E.1.8) i cui risultati sono visualizzatiin Tabella(A.1) che ben evidenzia come l’entita della rotazione i esima sidimezza rispetto alla rotazione precedente.

Tramite lo script Matlab Visualizza spettro NCO VHDL.m (Li-

stato E.1.12) e possibile ottenere lo spettro del coseno generato dal CORDICVHDL, un esempio di risultato e riportato in Figura(A.12).


a_cost_j(12:0)

coseno(11:0)

clk

fase_j(12:0)

in_x(11:0)

seno(11:0)in_y(11:0)

in_z(12:0)

U0

cordic_base_j

a_cost_j(12:0)

coseno(11:0)

clk

fase_j(12:0)

in_x(11:0)

seno(11:0)in_y(11:0)

in_z(12:0)

U1

cordic_base_j

a_cost_j(12:0)

coseno(11:0)

clk

fase_j(12:0)

in_x(11:0)

seno(11:0)in_y(11:0)

in_z(12:0)

U2

cordic_base_j

a_cost_j(12:0)

coseno(11:0)

clk

fase_j(12:0)

in_x(11:0)

seno(11:0)in_y(11:0)

in_z(12:0)

U3

cordic_base_j

a_cost_j(12:0)

coseno(11:0)

clk

fase_j(12:0)

in_x(11:0)

seno(11:0)in_y(11:0)

in_z(12:0)

U4

cordic_base_j

a_cost_j(12:0)

coseno(11:0)

clk

fase_j(12:0)

in_x(11:0)

seno(11:0)in_y(11:0)

in_z(12:0)

U5

cordic_base_j

a_cost_j(12:0)

coseno(11:0)

clk

fase_j(12:0)

in_x(11:0)

seno(11:0)in_y(11:0)

in_z(12:0)

U6

cordic_base_j

a_cost_j(12:0)

coseno(11:0)clk

fase_j(12:0)

in_x(11:0)

seno(11:0)in_y(11:0)

in_z(12:0)

U7

cordic_base_j

a_cost_j(12:0)

coseno(11:0)clk

fase_j(12:0)

in_x(11:0)

seno(11:0)in_y(11:0)

in_z(12:0)

U8

cordic_base_j

a_cost_j(12:0)

coseno(11:0)clk

fase_j(12:0)

in_x(11:0)

seno(11:0)in_y(11:0)

in_z(12:0)

U9

cordic_base_j

a_cost_j(12:0)

coseno(11:0)clk

fase_j(12:0)

in_x(11:0)

seno(11:0)in_y(11:0)

in_z(12:0)

U10

cordic_base_j

a_cost_j(12:0)

coseno(11:0)clk

fase_j(12:0)

in_x(11:0)

seno(11:0)in_y(11:0)

in_z(12:0)

U11

cordic_base_j

a_cost_j(12:0)

coseno(11:0)clk

fase_j(12:0)

in_x(11:0)

seno(11:0)in_y(11:0)

in_z(12:0)

U12

cordic_base_j

x1(11:0)

y1(11:0)

z1(12:0)

x2(11:0)

y2(11:0)

z2(12:0) z3(12:0) z4(12:0) z5(12:0) z6(12:0)

z8(12:0) z9(12:0) z10(12:0) z11(12:0) z12(12:0)

y3(11:0) y4(11:0) y5(11:0) y6(11:0)

y8(11:0) y9(11:0) y10(11:0) y11(11:0) y12(11:0)

x3(11:0) x4(11:0) x5(11:0) x6(11:0) x7(11:0)

x8(11:0) x9(11:0) x10(11:0) x11(11:0) x12(11:0)

x0(11:0)

y0(11:0)

z0(12:0)

y7(11:0)

z7(12:0)

coseno(11:0)

seno(11:0)

fase(12:0)

a_0(12:0) a_1(12:0) a_2(12:0) a_3(12:0) a_4(12:0) a_5(12:0) a_6(12:0)

a_7(12:0) a_8(12:0) a_9(12:0) a_10(12:0) a_11(12:0)a_12(12:0)

x13(11:0)

y13(11:0)

a_0 <= "0010000000000" ;

SignalAssignments_2

a_1 <= "0001001011100" ;

SignalAssignments_3

a_2 <= "0000100111111" ;

SignalAssignments_4

a_3 <= "0000010100010" ;

SignalAssignments_5

a_4 <= "0000001010001" ;

SignalAssignments_6

a_5 <= "0000000101000" ;

SignalAssignments_7

a_6 <= "0000000010100" ;

SignalAssignments_8

a_7 <= "0000000001010" ;

SignalAssignments_9

a_8 <= "0000000000101" ;

SignalAssignments_10

a_9 <= "0000000000010" ;


a_10 <= "0000000000001" ;


a_11 <= "0000000000000" ;


a_12 <= "0000000000000" ;


x0 <= "010011011100" ;y0 <= "000000000000" ;


Figura A.11: Cordic Pipelined Unrolled

Iterazione Angolo ϕi

1 45, 00002 26, 56513 14, 03624 7, 12505 3, 57636 1, 78997 0, 89528 0, 44769 0, 223810 0, 111911 0, 056012 0, 028013 0, 0140

Tabella A.1: Rotazioni elementari CORDIC


Figura A.12: Spettro coseno generato dal DDFS VHDL

Appendice B

Sistemi Multirate

B.1 Sommario

Tutti i sistemi dove l’elettronica analogica deve interfacciarsi con l’elettro-nica digitale sono dei sistemi multirate nei quali vi sono campioni generaticon frequenze di campionamento FS diverse, in particolare si puo pensareche la parte analogica del sistema operi con FS → ∞ mentre la parte digi-tale con la minima FS sufficiente all’elaborazione desiderata, vengono cosımantenute basse sia la complessita che la dissipazione del sistema digitale.Numerosi sono gli esempi di sistemi multirate completamente digitali, adesempio per l’audio digitale si ha che gli studi di produzione campionano a48kHz mentre lo standard per i CD e a 44, 1kHz ed il broadcasting a 32kHz,per passare informazioni da un ambiente all’altro si rende quindi necessarioa seconda dei casi un upsampler1 che consente di salire ad un rate piu altooppure un downsampler2 col quale scendere ad un rate piu basso.

B.2 Downsampling e Upsampling

Nei sistemi multirate il seguente teorema del campionamento assume im-portanza fondamentale:

Teorema 2 (di Shannon e Nyquist) Se un segnale continuo x (t) pos-siede trasformata di Fourier X (f) a banda limitata (i.e. |X (f)| = 0 ∀ |f | 6∈[f0, f0 +B]) allora x (t) puo essere ricostruito in maniera univoca e senzaerrore a partire dai suoi campioni x (kT ) a patto che la frequenza di cam-pionamento Fs = 1

T sia maggiore della frequenza di Nyquist FNyquist = 2Bdel segnale.

Nel caso la condizione sulla banda limitata non sia rispettata si haaliasing [10], le code di una replica spettrale centrate su di un multiplo

1il termine interpolatore non include il filtro anti-immagine situato a valle2il termine decimatore non include il filtro anti-aliasing situato a monte

71

APPENDICE B. SISTEMI MULTIRATE 72

della frequenza di campionamento si vanno cioe a sovrapporre a quelle dellareplica antecedente e della replica successiva.

L’upsampler si basa sull’interpolatore il quale deve produrre in uscitapiu campioni di quanti ne abbia in ingresso mantenendo uno spettro simile,cio si puo ottenere o aggiungendo L − 1 zeri tra due campioni d’ingres-so adiacenti nel caso si voglia interpolare L, oppure ripetendo L − 1 volteogni campione, quest’ultima soluzione e piu complessa da un punto di vistacircuitale e conduce a risultati peggiori in quanto si tratta di un campiona-mento con tenuta di ordine zero. Per comprendere la necessita di un filtroa valle dell’interpolatore si fa riferimento alla Figura(B.1), in particolare in

Figura B.1: Upsampling

(B.1.a) si ha lo spettro di un generico segnale campionato caratterizzato dauna banda inferiore alla banda di Nyquist e con delle repliche centrate in-torno ai multipli della frequenza di campionamento FS1, lo spettro all’uscitadell’interpolatore e rappresentato in (B.1.b) e si differenzia dal precedentein quanto all’uscita dell’interpolatore la frequenza di campionamento e FS2

e pertanto all’interno della banda di Nyquist sono presenti delle componentispettrali che non c’erano a monte dell’interpolatore, esse sono dette imma-gini ed il filtro passabasso tramite il quale vengono eliminate e detto filtro


anti-immagine. L’upsampler e pertanto costituito da un interpolatore ed unfiltro anti-immagine come in Figura(B.2).

Figura B.2: Upsampler

Il downsampler e basato sul decimatore il quale deve produrre in usci-ta meno campioni di quanti ne abbia in ingresso mantenendo uno spettrosimile, cio si ottiene prendendo un campione ogni M nel caso si voglia de-cimare il rate di un valore M. La Figura(B.3) illustra la necessita di unfiltro a monte del decimatore in particolare in (B.3.a) si ha lo spettro di

Figura B.3: Downsampling

un generico segnale campionato caratterizzato da una banda inferiore allabanda di Nyquist riferita alla frequenza di campionamento FS1 in ingres-so al downsampler, il segnale in uscita dal decimatore occupa la medesima


banda tuttavia essendo diminuita la frequenza di campionamento3, e dimi-nuita anche la banda di Nyquist che essendo divenuta inferiore a quella delsegnale, in virtu del teorema del campionamento, determina aliasing.

A monte del decimatore e pertanto necessario un filtro detto anti-aliasing che limiti la banda del segnale d’ingresso all’interno della bandadi Nyquist relativa al rate piu basso conseguentemente lo schema a blocchidel downsampler e quello rappresentato in Figura(B.4).

Figura B.4: Downsampler

Lavorando sui campioni e implicito siano possibili soltanto fattori interid’interpolazione o decimazione, nel caso in cui se ne richiedano di frazionarioccorre mettere in cascata il decimatore e l’interpolatore facendo attenzioneche l’interpolatore preceda il decimatore come in Figura(B.5) in quanto al-trimenti la banda del segnale d’ingresso deve essere confinata in FS

2M essendoM il fattore di decimazione.

Figura B.5: Cambiamento di rate frazionario

Nel caso in cui si desideri realizzare dei fattori di interpolazione o de-cimazione elevati occorre suddividere la catena in piu stadi, in genere dueo tre, ed implementare il rate piu elevato nell’ultimo stadio, tornano moltoutili inoltre le Nobili Identita in Figura(B.6), dimostrate in [12], le qualiconsentono di spostare l’operazione di filtraggio verso la regione del sistemache opera con il rate piu basso ottenendo cosı una notevole semplificazione.

B.3 Architetture Multirate

Diverse architetture sono state sviluppate allo scopo di realizzare sistemimultirate tuttavia al momento le opzioni piu valide ed utilizzate sembrano

3che in figura vale FS2 = FS13


Figura B.6: Nobili Identita

essere la decomposizione polifase ed il CIC4, esse presentano caratteristicheabbastanza diverse pertanto a seconda dell’applicazione si puo trovare unaoppure l’altra o anche entrambe.

B.3.1 CIC

Il CIC e stato introdotto da Hogenhauer [6] nel 1981 si caratterizza perla sua estrema semplicita che ne porta a trascurare i difetti quali la rispo-sta in frequenza non piatta e l’eccessivo guadagno. E’ costituito da unacascata di n blocchi integratori5 ed n blocchi comb6, ciascuno di essi con-tiene un sommatore ed un ritardo, sono quindi assenti i moltiplicatori lacui implementazione su FPGA determina spesso la massima frequenza diclock utilizzabile nel circuito, l’architettura CIC e quindi ideale per siste-mi dove siano richiesti elevati cambiamenti di rate corrispondenti ad altefrequenze non raggiungibili dai moltiplicatori. La funzione di trasferimentodell’integratore nel piano Z e

HI (z) =1

1− z−1(B.1)

ha pertanto un polo in z= −1 che ne determina il comportamento pas-sabasso ma con un guadagno infinito nell’origine, si tratta pertanto di unsistema instabile che viene compensato inserendo in cascata un comb la cuifunzione di trasferimento e

HC (z) = 1− z−RM (B.2)

dove R e la variazione del data rate desiderata mentre M e il ritardo diffe-renziale che sovente assume i valori 1 o 2 ed in pratica si realizza inserendoM blocchi di ritardo nella catena che porta al sommatore. L’interpolatore oil decimatore CIC si ottengono rispettivamente ponendo in cascata N comb

4Cascaded Integrator Comb5Figura(B.7)6Figura(B.8)


(a) Integrator (b) Integrator

Figura B.7: Integratore e sua risposta in frequenza

(a) Comb (b) Comb

Figura B.8: Comb e sua risposta in frequenza

ed N integratori oppure viceversa, se pero tra i blocchi si effettua il cambia-mento del rate come nelle Figure (B.9) e (B.10) si ottiene che meta del CICopera ad un rate piu basso con gli indubbi vantaggi che ne conseguono edinoltre il progetto dei due blocchi diviene indipendente dal cambiamento dirate desiderato quindi la struttura puo esser resa programmabile.

Figura B.9: Interpolatore CIC

In entrambe i casi la risposta in frequenza nel piano z e:

H (z) = HNI (z)HN

C (z) =

(1− z−RM

)N(1− z−1)N

=

(RM−1∑

k=0

z−k

)N

(B.3)


Figura B.10: Decimatore CIC

il cui spettro nel caso di R = 2 rappresentato in Figura(B.11) evidenzia un

Figura B.11: Spettro del CIC per R=2, N=1, M=1

nullo in corrispondenza della frequenza di campionamento relativa al rateminore, mentre in corrispondenza della sua frequenza di Nyquist ossia almargine della banda utile presenta un’attenuazione di circa 5 dB, questaosservazione da sola e sufficiente ad affermare che il CIC e inadatto perimplementazioni di piccoli cambi di data rate, nel qual caso occorre com-pensare la risposta in frequenza in modo da renderla maggiormente piattanella banda utile. Per ampi valori del cambiamento di rate R si ottienedall’Equazione(B.3) l’approssimazione

H (f) =∣∣∣RM sin πMf

πMf

∣∣∣N se 0 ≤ f < 1M (B.4)

che consente le seguenti tre osservazioni importanti ai fini del progetto:

1. nello spettro vi sono dei nulli in corrispondenza dei multipli di f = 1M

modificando M, R ed N opportunamente si puo fare in modo che i ter-mini di aliasing o immagine cadano in queste regioni come evidenziatoin Figura(B.12).

2. al crescere di N aumenta velocemente l’attenuazione il che significache la banda nella quale la risposta in frequenza e piatta si restringeulteriormente, diviene pertanto sempre piu necessario l’inserimento amonte di una precompensazione.


(a) N = 4,M = 1, R = 7 (b) N = 4,M = 2, R = 7

Figura B.12: Effetto di M sulla frequenza del CIC

3. si ha un guadagno molto elevato infatti a fronte di Bin bits in ingressosi hanno Bout = [N log2RM +Bin] bits in uscita7, la dipendenza daR comporta che la decisione sul numero di bit debba tenere conto siadel massimo che del minimo rate8 a cui il CIC deve operare.

B.3.2 Polifase

La struttura polifase [5] ha il grande vantaggio di essere un upsampler vero eproprio infatti l’architettura determina il cambiamento di rate mentre i suoicoefficienti impostano la risposta dei filtri anti-aliasing o anti-immagine.

Ipotizzando di voler interpolare 3 e di disporre dei coefficienti h (n) delfiltro anti-immagine, cui corrisponde la trasformata

H (z) =N−1∑n=0

h (n) z−n (B.5)

7nel caso di un decimatore implementato con una aritmetica in complemento a due8determina il numero di bit da mantenere nello stadio finale


scomponibile nelle tre componenti polifase H0 (z), H1 (z) ed H2 (z):

H (z) =N−1∑n=0

h (n) z−n

=

N−13∑

n=0

h (3n) z−(3n) +

N−13∑

n=0

h (3n+ 1) z−(3n+1) +

N−13∑

n=0

h (3n+ 2) z−(3n+2)

=

N−13∑

n=0

h (3n) z−(3n) + z−1

N−13∑

n=0

h (3n) z−(3n) + z−2

N−13∑

n=0

h (3n) z−(3n)

= H0 (z) + z−1H1 (z) + z−2H2 (z)(B.6)

si ha che l’ultima equazione e implementabile con lo schema in Figura(B.13a), da essa tramite un risultato classico della teoria dei sistemi si ottienelo schema(B.13 b) quindi utilizzando la Nobile Identita (b) si giunge alloschema(B.13 c) nel quale la parte terminale non e altro che un commuta-tore che ad ogni intervallo di clock preleva in maniera ciclica una delle trecomponenti polifase come evidenziato in Figura(B.13 d).

Figura B.13: Trasformazioni interpolatore polifase

Rispetto alla forma polifase di partenza quella ottenuta e piu efficiente inquanto le tre componenti operano ad un rate minore rispetto al commutato-re inoltre estendendo la precedente trattazione si possono ottenere risultatisimili sia per un interpolatore polifase di ordine N che per un decimatorepolifase.

Nella realizzazione pratica non si fa altro che distribuire i coefficienti delfiltro di partenza su L filtri se L e il fattore di interpolazione, ognuno diquesti filtri implementa una decomposizione polifase, l’uscita dei filtri puo


andare ad un sommatore oppure piu intelligentemente ad un commutatoreil quale ne trasferisce in uscita solo uno alla volta in maniera ciclica ad unrate L volte superiore al rate dei dati in ingresso al polifase, cio e possibilein quanto il processo d’interpolazione inserisce L− 1 zeri per ogni campioned’ingresso, e pertanto inutile calcolare il prodotto di questo campione nulloper il rispettivo coefficiente del filtro.

Appendice C

Logiche programmabili

C.1 Sommario

Dopo aver elencato le diverse tipologie di logiche programmabili eviden-ziandone i principali pregi e difetti si passa ad una descrizione particolareg-giata dell’architettura Virtex [15] alla quale appartiene l’FPGA utilizzatanell’implementazione del modulatore.

C.2 Tipologie di logiche programmabili

Le logiche programmabili sono una delle diverse possibita di implementa-zione di un circuito digitale, la gerarchia delle possibili soluzioni e illustratain Figura(C.1).

Figura C.1: Gerarchia implementazioni circuiti logici

La prima tipologia di logica programmabile e stata la PAL1 che imple-menta una somma di prodotti programmabile una sola volta, la sua diretta

1Programmable Array Logic

81

APPENDICE C. LOGICHE PROGRAMMABILI 82

estensione e rappresentata dalle PLD2 le quali dispongono di un elevatonumero di blocchi logici interconnessi tra loro, ciascuno di essi implementauna somma di prodotti che puo essere registrata o meno, il ritardo che nederiva e quindi ben definito. Vi sono poi le CPLD3 le quali non presenta-no delle interconnessioni globali bensi delle strutture di routing raccolte infasci pertanto il ritardo risulta definito soltanto a livello locale mentre none possibile conoscere a priori quali gruppi di fasci verranno effettivamenteutilizzati per le interconnessioni. Diverse CPLD sono del tipo ISP4 possonocioe essere programmate senza estrazione dal circuito, tale programmazionerimane memorizzata sin quando non e necessario mutare il funzionamentodella CPLD in accordo a mutate esigenze della logica d’utente. Chiudonoil quadro delle logiche programmabili le FPGA, dispositivi molto complessinei quali sono immersi un numero elevato di blocchi logici abbastanza sem-plici ma tutti interconnessi tra loro, il ritardo e pertanto non predicibile apriori.

Si sono nel tempo affermate due diverse tipologie di FPGA, le OTP5

e le ISP anche dette SRAM6, tra le OTP la tecnologia piu rilevante e laantifuse caratterizzata da elementi molto piccoli e veloci da programmarei quali pero per tale operazione richiedono ai bordi del circuito integratoun numero elevato di transistori aventi il compito di fondere il polisilicioamorfo. I veri vantaggi sono pertanto:

1. non e possibile carpire la logica a partire dal dispositivo che pertanto eadatto ad applicazioni dove sia richiesto un certo grado di segretezza.

2. sopporta elevate radiazioni elettromagnetiche senza subire alterazionifunzionali il che e importante in applicazioni spaziali.

Le FPGA con tecnologia SRAM richiedono la riprogrammazione ad ogniriaccensione, a tal fine si utilizza una PROM esterna la quale contiene laconfigurazione in maniera stabile e ad ogni ripartenza la passa ad una opiu FPGA disposte in catena. Attualmente si tratta della tecnologia checonsente di raggiungere le prestazioni piu elevate sia in termini di velocitadi clock che di complessita delle funzioni realizzate, nella seguente sezioneviene descritta l’architettura Virtex della Xilinx che ha riscosso un notevolesuccesso commerciale in virtu delle numerose innovazioni tecnologiche daessa introdotte.

L’evoluzione verso le famiglie Virtex E , Virtex 2 e Virtex 2 Pro hariguardato i seguenti aspetti:

1. diminuzione dello spessore dello strato di ossido7.2Programmable Logic Device3Complex Programmable Logic Device4In System Programmable5One Time Programmable6Static Random Access Memory7dai 0.22-µm della Virtex ai 0.13-µm della Virtex 2 Pro


2. aumento del numero di strati di metallo8.

3. progressiva integrazione ed ottimizzazione dei dispositivi aritmeticialla base delle applicazioni DSP.

La Virtex 2 e la Virtex 2 PRO sono inoltre delle platform FPGA le qualiconsentono di realizzare in un solo dispositivo delle funzionalita complesseche attualmente vengono implementate con piu circuiti integrati, a tal fineoltre a essere disponibili in formati molto grandi9 implementano numeroseagevolazioni quali dei blocchi di memoria RAM, moltiplicatori precablatied ottimizzati, possibilita di ospitare dei moduli altrui protetti da licenzequali ad esempio il Power PC IBM e i Multi-Gigabit Transceivers presentidi default nella Virtex 2 PRO.

C.3 Architettura Virtex

La famiglia Virtex si compone di nove diverse FPGA diverse tra loro per ledimensioni che vanno da 50mila porte logiche sino ad 1milione, quest’ulti-mo formato e quello utilizzato per l’implementazione del modulatore, nellafattispecie la scheda DINI utilizza 6 FPGA XCV1000BG560-4 dove BG560indica il formato BallGrid da 560 pin, mentre -4 e lo speed grade il qualeviene calcolato statisticamente, migliori prestazioni in termini di velocita diclock si possono ottenere utilizzando versioni con speed grade -5 o -6. Allabase della architettura Virtex ci sono i CLB e gli IOB10, i primi si occupanodi realizzare le funzionalita che il progettista richiede mediante un linguag-gio ad alto livello quale il VHDL11 o il VERILOG, i secondi realizzanoinvece dell’interfacciamento di questa logica con il mondo esterno.

Oltre a CLB e IOB ogni FPGA contiene anche un numero elevato dirisorse dedicate alle connessioni, esse sono diversificate in termini di esten-sione e capacita di pilotaggio ed alcune sono espressamente dedicate alrouting di segnali particolarmente importanti come ad esempio il clock.

C.3.1 CLB

L’entita logica programmabile di base della architettura Virtex e la LC12,essa include:

8dai 5 strati della Virtex ai 9 della Virtex 2 Pro9sino a 10M gate

10Input Output Block11VHSIC Hardware Description Language12Logic Cell


• un generatore di funzioni13 che puo anche essere utilizzato come RAM14

sincrona distribuita nel formato 16× 1 bit oppure come SRL1615.

• logica dedicata al riporto nelle operazioni aritmetiche, tra cui unaporta XOR denominata XORCY che consente l’implementazione diun full-adder ad 1 bit, un multiplexer denominato MUXCY ed unaporta AND che ottimizza l’implementazione dei moltiplicatori.

Figura C.2: Implementazione di un moltiplicatore

• un registro che puo essere configurato sia come FFD sensibile al frontedel clock che come latch sensibile al livello.

L’unione di due LC viene denominata Slice, come evidenziato in Fi-gura(C.3) il multiplexer F5 combina le uscite delle LUT consentendo direalizzare le seguenti strutture:

• generatore di funzioni a 5 ingressi.

• multiplexer 4:1.

• funzioni specifiche sino ad un massimo di 9 ingressi.

inoltre la combinazione delle due LUT puo dar luogo ad una RAM sincrona16× 2 bit o 32× 1 bit oppure una RAM sincrona a doppia porta 16× 1 bit.

Il CLB rappresentato in Figura(C.4) contiene 2 Slice e quindi 4 LC, inesso il multiplexer F6 coadiuvato dal multiplexer F5 combina le uscite delle4 LUT consentendo di implementare:

• generatore di funzioni a 6 ingressi.

• multiplexer 8:1.

• funzioni specifiche sino ad un massimo di 19 ingressi.13implementato con una LUT a 4 ingressi14Random Access Memory15Shift Register Left 16-bit


Figura C.3: Slice Virtex

Figura C.4: CLB Virtex

C.3.2 IOB

Come precedentemente affermato gli IOB si occupano dell’interfacciamentodella logica implementata nelle CLB con il mondo esterno, ognuno si essie dotato di 3 registri che possono essere configurati sia come sensibili allivello che al fronte, da progetto si puo decidere di includere della logica inquesti registri oppure non utilizzarli. Vi sono inoltre dei resistori di pull-up


e di pull-down di valore compreso tra 50 e 100Ω. Sono possibili 13 diversistandard di interfacciamento col mondo esterno, nella fattispecie LVTTL,LVCMOS2, PCI 5V, PCI 3, 3V, GTL, GTL+, HSTL I, HSTL III, HSTLIV, SSTL3 I e II, SSTL2 I e II, CTT e AGP dei quali molti richiedono unatensione di riferimento, in particolare gli IOB sono suddivisi in 8 banchiall’interno di ognuno dei quali puo essere utilizzata soltanto una tensione diriferimento.

C.3.3 Risorse di connessione

Le CLB sono connesse tra di loro tramite la GRM16 costituita da matrici dicommutazione locate nell’intersezione dei canali di smistamento orizzontalie verticali, ogni CLB appartiene ad un VersaBLOCK il quale realizza ilrouting locale come illustrato in Figura(C.5).

Figura C.5: VersaBlock

Ogni GRM e connessa tramite 24 linee ad ognuna delle 4 GRM adiacen-ti, 96 linee esadecimali connettono inoltre ogni GRM con quella che distada essa 6 GRM in ogni direzione, lungo i bordi della FPGA c’e poi il Versa-Ring che rende flessibile il progetto mappato rispetto all’assegnamento deipin del dispositivo.

Si hanno delle linee di routing dedicate per i bus 3-state e per i segnali diriporto verso le CLB verticalmente adiacenti, inoltre ogni CLB e raggiuntada 4 linee di clock globali, che debbono essere pilotate da opportuni buffer, eda 24 linee secondarie dedicate allo smistamento di segnali ad ampio fan-outnon necessariamente segnali di clock.

C.3.4 Circuiti di utilita

All’interno della Virtex oltre alle CLB vi sono dei circuiti che implementanoalcune funzionalita molto utilizzate nella progettazione digitale, tra di essi

16General Routing Matrix


Figura C.6: Clock globale

vi sono le DLL17, le BlockRAM e gli SRL16.

C.3.4.1 DLL

Le DLL ottimizzano lo smistamento del segnale di clock all’interno dellegrandi FPGA infatti sulla base della differenza tra il clock in ingresso ed ilclock distribuito applicano a quest’ultimo un ritardo opportuno eliminandopertanto lo skew. La struttura puo essere utilizzata sia per raddoppiare oquadruplicare la frequenza di clock in ingresso alla FPGA18 che per effet-tuare su di essa delle divisioni del clock per i valori 1, 5 , 2 , 2, 5 , 3 , 4 ,5 , 8 o 16. Nella Virtex vi sono 4 DLL, una per ogni linea di clock globalee per ogni buffer globale come illustrato in Figura(C.6).

C.3.4.2 BlockRAM

La BlockRAM e un blocco di memoria SRAM che complementa la RAMdistribuita nelle LUT delle CLB, nella Virtex ogni blocco e alto 4 CLB,ne consegue che sulla XCV1000 ve ne sono 16 ai bordi di ognuno dei duelati verticali. Ogni blocco dispone di 4096 celle di memoria alle quali si puoaccedere in configurazione singola porta o doppia porta19. Ogni BlockRAMpuo essere anche configurata in sola lettura, per la sua inizializzazione sipossono utilizzare i Core opportuni oppure istanziare la primitiva desiderataed assegnare dei valori alle 16 stringhe di inizializzazione ciascuna delle qualie composta da 64 cifre esadecimali e pertanto copre 256 bit.

17Delay Locked Loop18la frequenza di clock in ingresso deve essere maggiore di 25MHz19le due porte hanno in comune le stesse 4096 celle di memoria


(a) Primitive BlockRAM (b) Stringhe d’inizializzazione

Figura C.7: Configurazione delle BlockRAM

C.3.4.3 SRL16

La LUT presente in ogni LC viene utilizzata come multiplexer 16:1 aven-te 4 ingressi che seleziona come uscita seriale di un registro a scorrimentoa 16 bit. Una tale struttura consente di creare delle reti di ritardo mol-to compatte particolarmente adatte all’implementazione della tecnica delpipelining.

Appendice D

Flusso di progettazione

D.1 Sommario

In questa appendice viene descritto tutto il processo che consente di passareda una descrizione matematica del sistema che si intende implementare suFPGA sino alla verifica del suo effettivo funzionamento passando per laverifica funzionale del VHDL.

D.2 Modello Matematico

La stesura di un modello matematico e di aiuto sia nella verifica della cor-rettezza di una idea che nella comprensione stessa di determinati aspettidi una tematica che possono inizialmente rimanere poco chiari, soprattuttoi numerosi esempi del Toolbox per le comunicazioni di Matlab oltre allefunzioni ad alto livello consentono un approccio semplice a tematiche qualimodulazioni e demodulazioni, progettazione di filtri, codifiche e decodifiche.Sostanziale e anche l’utilita di Matlab laddove si desideri spostare tutta lacomplessita del progetto in migliaia di cifre contenute in una RAM, l’alle-stimento di script parametrici consente infatti di rispondere con rapidita amodifiche delle specifiche di progetto. Si puo passare alla fase successiva delprogetto solo dopo aver realizzato delle simulazioni su dei modelli matema-tici il piu possibile vicini alla reale architettura che si intende implementare,in tal modo si possono ad esempio dimensionare opportunamente il numerodi bit da assegnare a determinati segnali influenzando cosı la stesura delmodello VHDL.

D.3 Modello VHDL

Anche nella realizzazione del modello VHDL occorre tener conto del pas-so successivo, l’implementazione, questo in quanto il VHDL e anche unlinguaggio descrittivo pertanto alcuni modelli che potrebbero soddisfare

89

APPENDICE D. FLUSSO DI PROGETTAZIONE 90

una verifica funzionale possono risultare non sintetizzabili, cio si verificaad esempio se all’interno di un processo si richiede che si operi su entrambei fronti del clock. La verifica funzionale avviene applicando degli stimoli almodello e verificando le risposte o in termini di forme d’onda digitali oppurenel dominio del tempo o della frequenza previa creazione di un file e suaesportazione in Matlab dove si possono utilizzare delle varianti degli scriptche compongono il modello matematico. Quale software per la verifica e lastesura del modello VHDL si e utilizzato ActiveHDL, esso realizza anche unambiente integrato verso diversi tipi di sintetizzatori VHDL e software perl’implementazione effettiva su FPGA consentendo di uno stesso progetto laverifica funzionale, RTL1 e back-annotata.

D.4 Sintesi del progetto

La sintesi consente di passare dalla descrizione VHDL del progetto alladescrizione RTL ossia la sua espressione in termini di registri e logica com-binatoria, in questa fase e importante l’utilizzo di un software quale Synplifyche illustra graficamente la corrispondenza tra le due descrizioni ed effet-tua anche una verifica delle prestazioni in risposta a determinati vincolisul timing di alcuni segnali di rilievo tra cui certamente il clock. La Xilinxdistribuisce con i suoi prodotti anche XST un sintetizzatore meno graficorispetto a Synplify ma con prestazioni abbastanza simili, esso ha il van-taggio di riconoscere automaticamente le stringhe di inizializzazione delleBlockRAM2 consentendo pertanto un piu veloce passaggio dal VHDL perla verifica al VHDL per la sintesi.

In questa fase oltre ai vincoli temporali al progetto e bene inserire anchei vincoli sui pin che si desiderano utilizzare, al fine di ottimizzare il timingad esempio nel progetto ThinModulator son stati prescelti tutti pin che sitrovano dal lato della FPGA dove sono dislocate le BlockRAM utilizzate,con questo semplice accorgimento si risparmia una inutile fatica al softwared’implementazione, occorre pero tener presente che non tutti i pin dellaFPGA sono disponibili sugli slot che sulla scheda DINI sono adiacenti adessa.

D.5 Mappatura

Impostando in Synplify anche il tipo di FPGA sul quale si desidera realiz-zare il progetto e possibile ottenere la vista tecnologica che mostra come ilprogetto RTL e quindi il progetto VHDL viene effettivamente implementatonel dispositivo, in sostanza in questa fase vengono stabilite quali tipologiedi risorse verranno utilizzate.

1Register Transfer Logic2Appendice(C.3.4.2)


D.6 Piazzamento delle risorse

Una volta individuate la tipologia di risorse da utilizzare rimane da effet-tuare il piazzamento, ossia la selezione nominale delle risorse da utilizzare,questa fase e in genere abbastanza veloce ed il progettista la puo influenzaremediante il FloorPlanner con il quale si specificano quali siti all’interno dellaFPGA debbono ospitare una determinata funzione, in sostanza si impongo-no dei vincoli fisici che possono essere memorizzati in un file UCF3 o PCF4.Il Floorplanner puo risultare utile ad esempio per impostare le BlockRAMda utilizzare per un dato segnale in modo da rendere il piu breve possibileil percorso dalla sua uscita sino al registro ed al pin d’uscita.

D.7 Connessione delle risorse

Questa fase e sicuramente la piu lunga e complessa, vengono selezionatele risorse di connessione5 che consentono di soddisfare al meglio i vinco-li temporali impostati nel file UCF garantendo comunque i vincoli fisiciimpostati nel file UCF o PCF. Anche per questa fase Xilinx mette a di-sposizione del progettista un Tool quale FPGA Editor che gli consente diimporre determinate connessioni o modificare le connessioni effettuate daltool automatico.

D.8 Simulazione back-annotata

Dopo aver verificato mediante lo STA6 che i vincoli sul timing sono soddi-sfatti si puo generare il modello di simulazione del progetto ottenuto dopoil PAR7, esso e costituito da due file uno con estensione .sdk e l’altro .vhd,quest’ultimo realizza l’architettura structure del modello VHDL, creandoper essa un TestBench si debbono ottenere a parita di stimoli le stesseforme d’onda che si ottengono dal modello funzionale.

D.9 Programmazione della FPGA

Se anche la simulazione back-annotata ha avuto esito positivo si passa allacreazione del file .bit e successivamente del file .hex da inserire nella PROMche ad ogni riaccensione si occupa di riprogrammare le FPGA presentisulla scheda DINI. E’ necessario impostare per il file il formato HEX e nonselezionare l’opzione swap bits. Il Data Stream deve contenere nell’ordine il

3User Constrain File4Physical Constrain File5Appendice(C.3.3)6Static Timing Analyzer7Place And Route


file fpga f.bit per la gestione del bus PCI, il file .bit relativo al progetto cheandra ad occupare la FPGA A e 4 file blank 1.bit che riempiranno le altreFPGA. Salvando viene automaticamente generato il file .hex, per trasferirlonella Prom occorre seguire la seguente procedura sul computer nel quale estata installata la scheda DINI:

1. inserire il Jumper J2 sulla scheda e premere il tasto giallo.

2. riavviare il computer.

3. spostare il file .hex generato dal prom formatter nella directoryF:/SchedaDini/AETEST/aetest_nt .

4. far partire il programma AETEST.EXE ed eseguire i diversi passi diprogramma:

• selezionare Open Device.

• selezionare 3) Flash menu.

• selezionare 6) Download Hex File.

• scrivere il nome del file .hex e premere invio.

• premere due volte invio quindi uscire.

5. togliere il Jumper J2 e premere il tasto giallo.

6. controllare che si spengano i led rossi superiori.

D.10 Verifica sperimentale

Per la verifica sperimentale vengono utilizzati un pattern-generator che vie-ne caricato con dei vettori di test da applicare alla FPGA in maniera ri-petitiva o singola, lo script Matlab CreaSequenzaPatternGenerator.m(Listato E.2.2) consente di creare in maniera automatica il file di testo con ilquale caricare il pattern-generator, in esso si puo anche impostare se il clockdi emissione dei dati debba esser prodotto autonomamente dal pattern-generator oppure sincronizzato ad un clock esterno come e avvenuto perle prove del modulatore. Le uscite del modulatore vengono invece inviateall’analizzatore di stati logici, si effettua una singola acquisizione di 64milacampioni in accordo ai 6mila applicati ed il file ottenuto viene esportato ver-so Matlab dove un’analisi dello spettro consente di confrontare il risultatoteorico col risultato sperimentale.

Appendice E

Listati Matlab

E.1 NCO

Listato E.1.1: NCO Q.m1 % DESCRIPTION : Implementa un NCO quantizzato , ne grafica i risultati sia nel2 % dominio del tempo che della frequenza e valuta l ’ SFDR34 % Pulizia ambiente Matlab5 clear all ;6 close all ;7 clc ;8 % Imposto la frequenza di clock e la frequenza richiesta in uscita dall ’ NCO9 [f_out , f_clk] = imposta_frequenze_Q ;

10 % Imposto le caratteristiche dell ’ NCO11 [n_bit_acc, n_bit_cordic, n_bit_dac, n_it_cordic, n_periods] = imposta_NCO_Q ;12 % creo l ’ accumulatore il quale contiene i soli valori delle fasi che elaborati13 % alla frequenza di clock generano in uscita la frequenza desiderata14 super_acc = crea_super_accumulatore_Q(f_out , f_clk , n_bit_acc, n_periods) ;15 % le fasi vengono troncate da una rappresentazione con n_bit_acc bits ad una16 % rappresentazione con n_bit_cordic bits17 super_acc_T = tronca_Q(super_acc , n_bit_cordic) ;18 % vengono generati tramite l ’ algoritmo CORDIC i valori del seno e del coseno19 % corrispondenti agli angoli presenti in super_acc20 [coseno , seno] = crea_coseno_e_seno_Q(super_acc_T, n_bit_cordic, ...21 n_bit_dac, n_it_cordic) ;22 % grafico un periodo del seno e del coseno calcolati con il CORDIC23 figure ;24 subplot(2,1,1); stairs(super_acc , coseno) ;25 xlim( [ 0 , 6.2832 ] ); ylim( [ -1.01 , +1.01 ] );26 subplot(2,1,2); stairs(super_acc , seno );27 xlim( [ 0 , 6.2832 ] ); ylim( [ -1.01 , +1.01 ] );28 % Rappresentazione nel dominio della frequenza del coseno generato dal CORDIC29 visualizza_spettro_e_sfdr_p( coseno , f_clk );30 % salva il coseno nel file coseno . dat31 fid = fopen(’coseno_Q.dat’,’w’) ;32 fprintf(fid,’%20.19f\n’, coseno) ;33 fclose(fid) ;34 % salva il seno nel file seno . dat35 fid = fopen(’seno_Q.dat’,’w’) ;36 fprintf(fid,’%20.19f\n’, seno) ;37 fclose(fid) ;

Listato E.1.2: Imposta frequenze Q.m1 % DESCRIPTION : consente d ’ impostare frequenza di clock e d ’ uscita dall ’ NCO23 function [f_out,f_clk]=imposta_frequenze_Q45 prompt = ’Frequenza desiderata in uscita (Hz) :’,6 ’Frequenza di clock (Hz) :’;7 title = ’Caratteristiche NCO’;8 lines = 1;9 def = ’41.25e6’,’165e6’;

93

APPENDICE E. LISTATI MATLAB 94

10 answer = inputdlg(prompt,title,lines,def) ;11 f_out = str2double(answer(1));12 f_clk = str2double(answer(2));

Listato E.1.3: Imposta NCO Q.m1 % DESCRIPTION : consente d ’ impostare le dimensioni dei bus dell ’ accumulatore ,2 % del Cordic e del DAC34 function [n_bit_acc,n_bit_cordic,n_bit_dac,n_it_cordic,n_periods]=imposta_NCO_Q56 prompt = ’N di bit accumulatore di fase : ’,7 ’N di bit per la fase in ingresso al Cordic : ’,8 ’N di bit per seno e coseno prodotti dal Cordic : ’,9 ’N di iterazioni del Cordic : ’,

10 ’N di periodi della funzione generata : ’;11 title = ’Caratteristiche NCO’;12 lines = 1;13 def = ’32’,’13’,’12’,’13’,’3000’;14 answer = inputdlg(prompt,title,lines,def) ;15 % n di bit in ingresso all ’ accumulatore di fase16 n_bit_acc = str2double(answer(1));17 % n di bit per la fase in ingresso al Cordic18 n_bit_cordic = str2double(answer(2));19 % n di bit per seno e coseno prodotti dal Cordic20 n_bit_dac = str2double(answer(3));21 % n di iterazioni del Cordic22 n_it_cordic = str2double(answer(4));23 % n di periodi generati24 n_periods = str2double(answer(5));

Listato E.1.4: Crea super accumulatore Q.m1 % DESCRIPTION : implementa un accumulatore contenente le fasi che lette2 % alla velocita del clock producono in uscita dal Cordic3 % la frequenza desiderata , puo memorizzare piu periodi45 function super_acc = crea_super_accumulatore_Q(f_out,f_clk,n_bit_acc,n_periods)67 % caratteristiche dell ’ accumulatore di fase8 % massimo numero di fasi memorizzabili nell ’ accumulatore9 range_acc = 2^n_bit_acc ;

10 % minima frequenza generabile11 f_res = f_clk / range_acc ;12 % minima fase memorizzabile13 phi_res = 2*pi / range_acc ;14 % determina l ’ incremento di fase necessario ad ottenere f_out15 f_word = f_out / f_res ;16 % incremento di fase che alla frequenza di clock produce in uscita la17 % frequenza desiderata18 delta_phi = f_word * phi_res ;19 % dimensioni dell ’ accumulatore contenente 1 periodo con le sole fasi che danno20 % luogo alla corretta frequenza generata21 dim_acc = round(range_acc/f_word) ;22 % massimo numero di fasi memorizzabili nel superaccumulatore23 dim_super_acc = dim_acc * n_periods ;24 % creazione del superaccumulatore25 super_acc = 0 : 1 : dim_super_acc ;26 super_acc = delta_phi * super_acc ;

Listato E.1.5: Tronca Q.m1 % DESCRIPTION : le fasi vengono troncate da una rappresentazione con2 % n_bit_acc bits ad una rappresentazione con n_bit_cordic bits34 function super_acc_T = tronca_Q(super_acc , n_bit_cordic)56 super_acc = rem(super_acc , 2*pi) ;7 new_risoluzione_fase = 2*pi / 2^n_bit_cordic ;8 super_acc_T = [fix(super_acc / new_risoluzione_fase)] * new_risoluzione_fase ;


Listato E.1.6: Crea coseno e seno Q.m1 % DESCRIPTION : imposta le caratteristiche del CORDIC e calcola seno e2 % coseno per tutte le fasi presenti nel vettore super_acc34 function [coseno , seno] = crea_coseno_e_seno_Q(super_acc_T, n_bit_cordic,...5 n_bit_dac, n_it)67 % ottengo le dimensioni del super_accumulatore8 dim_super_acc_T = size(super_acc_T , 2) ;9

10 % queste inizializzazioni velocizzano l ’ esecuzione del ciclo CORDIC11 coseno = zeros(1,dim_super_acc_T) ;12 seno = zeros(1,dim_super_acc_T) ;1314 new_capacity_fase = 2^(n_bit_cordic - 1) ;15 new_capacity_ampiezza = 2^(n_bit_dac - 1) ;1617 for j = 1 : dim_super_acc_T18 [coseno(j),seno(j)] = forward_cordic_Q(n_it,super_acc_T(j), ...19 new_capacity_fase, new_capacity_ampiezza);20 end ;

Listato E.1.7: Forward cordic Q.m1 % DESCRIPTION : esegue N iterazioni dell ’ algoritmo Cordic per calcolare il2 % seno ed il coseno dell ’ angolo Theta che riceve in ingresso ,3 % si parte dal valore 0.607252936517011 per il coseno in modo4 % da evitare la moltiplicazione finale ed evitare l ’ utilizzo5 % di un bit per il solo valore 1 del coseno che del seno .67 % m =1 individua le coordinate circolari mentre Nit e il n di iterazioni8 function [coseno, seno] = forward_cordic(N_it, Theta, new_capacity_fase,...9 new_capacity_ampiezza);

1011 % per semplificare il CORDIC riportiamo l ’ angolo nel primo quadrante ,12 % l ’ angolo effettivo potra poi essere ricavato mediante multcos e multsin13 multcos = 1;14 multsin = 1;15 if ( Theta > pi/2 & Theta < pi)16 % l ’ angolo viene riportato dal 2 quadrante al 1 17 Theta = pi/2 - rem(Theta,pi/2);18 multcos = -1;19 end20 if (Theta >= pi & Theta < (3/2)*pi)21 % l ’ angolo viene riportato dal 3 quadrante al 1 22 Theta = rem(Theta,pi/2);23 multcos = -1;24 multsin = -1;25 end26 if (Theta >= (3/2)*pi & Theta < 2*pi)27 % l ’ angolo viene riportato dal 4 quadrante al 1 28 Theta = pi/2 - rem(Theta,pi/2);29 multsin = -1;30 end31 % x ed y sono vettori aventi lunghezza pari al n di iterazioni , contengono32 % il coseno ed il seno dell ’ angolo inizialmente e memorizzato in z_attuale33 x_attuale = [floor(0.607252936517011* new_capacity_ampiezza)] / ...34 new_capacity_ampiezza ;35 y_attuale = 0 ;36 z_attuale = Theta ;37 % calcola il seno ed il coseno mediante N_it iterazioni dell ’ algoritmo CORDIC38 for i = 0:(N_it-1)39 % calcola il fattore moltiplicativo mu per la p_esima iterazione40 if z_attuale <= 041 mu = -1;42 else43 mu = 1;44 end45 S = 2^(-i) ;46 % Standard Cordic iteration , m = 1 per le coordinate circolari47 x_succ = x_attuale - [floor((mu * S * y_attuale) * ...48 new_capacity_ampiezza)] / new_capacity_ampiezza;49 y_succ = y_attuale + [floor((mu * S * x_attuale) * ...50 new_capacity_ampiezza)] / new_capacity_ampiezza;51 z_succ = z_attuale - [floor((mu * atan( S ))* ...52 new_capacity_fase)] / new_capacity_fase;53 x_attuale = x_succ ; y_attuale = y_succ ; z_attuale = z_succ ;54 end55 % Vengono restituiti il coseno ed il seno opportunamente scalati e riportati56 % nelal giusto quadrante57 % new_capacity_ampiezza = 2^(12 - 1) ;58 coseno = [floor((multcos * x_attuale)*new_capacity_ampiezza)]/...59 new_capacity_ampiezza;60 seno = [floor((multsin * y_attuale)*new_capacity_ampiezza)]/...61 new_capacity_ampiezza;


Listato E.1.8: Calcola rotazioni Cordic.m1 % DESCRIPTION : Per ogni iterazione del Cordic calcola l ’ angolo di rotazione2 % e il fattore di scaling34 % Pulizia ambiente Matlab5 clear all ;6 close all ;7 clc ;89 disp(’Valore degli angoli di rotazione a(n)’) ;

10 % Calcolo dei valori degli a ( n )11 for i = 0:1:1212 a(i+1) = atan(2^(-i));13 end ;14 i = [1:1:13] ;15 valore = [ i’ , ((a)* 180 / pi)’ ]16 a_tot = sum((a)* 180 / pi)1718 % converto ora gli a ( i ) in complemento a due su 1 bit per il segno e dodici19 % per la parte intera20 n_bit = 13 ;21 a_bin = dec2bin( (2^n_bit .* a(i) )/ (2*pi) )2223 disp(’Valore dei fattori di scaling k(n)’) ;24 % Calcolo il valore degli scalamenti da effettuare ad ogni rotazione25 k = sqrt(2) ;26 valore = [ 0 , k]27 for i = 1:1:1328 k = k*sqrt(1 + 2^(-2*i)) ;29 valore = [i , k]30 end ;

Listato E.1.9: Visualizza spettro e SFDR p.m1 % DESCRIPTION : plotta la stima dello spettro e l ’ SFDR23 function visualizza_spettro_e_SFDR_p( segnale , f_clk );45 % ottengo le dimensioni del vettore segnale6 dim_segnale = ( size(segnale , 2) )- 1 ;7 % viene calcolata e plottata la densita spettrale di potenza8 [Pxx , f] = pmtm(segnale , 8 , 4096 , f_clk) ;9 Pxx_dB = 10*log10(Pxx) ;

10 figure; plot(f , Pxx_dB - max(Pxx_dB) );11 grid ; xlim([0 f_clk/2]) ;12 title(’Power spectral density MultiTaper’);13 xlabel(’Frequency (Hz)’); ylabel(’dB / Hz’);14 % viene calcolato e visualizzato il valore dello SFDR15 valore_sfdr = calcola_sfdr(Pxx) ;16 text(1e7,-50,[’SFDR = ’,num2str(valore_sfdr)],’FontSize’,13);

Listato E.1.10: Calcola SFDR.m1 % DESCRIPTION : calcola l ’ SFDR del vettore passato in ingresso23 function [valore_sfdr] = calcola_sfdr(Pxx)4 % diff prende il vettore Pxx e costruisce un vettore i cui elementi sono5 % la differenza tra elementi adiacenti del vettore Pxx , si ottiene quindi6 % un vettore piu corto di uno .7 der = diff(Pxx);8 % dal vettore precedente ottengo il vettore dei segni corrispondenti9 signs=sign(der);

10 % viene inizializzato il ciclo che individua i massimi della PSD11 signold = 0 ; % contiene il valore del segno precedente12 signnew = 0 ; % contiene il valore del segno attuale13 p = 1 ; % puntatore per riempire il vettore dei massimi14 % Siamo in presenza di un massimo se il segno della derivata nel punto15 % precedente e negativo mentre il segno della derivata nel punto attuale16 % e positivo , viene scandito il vettore dei segni alla ricerca di questa17 % condizione e solo se verificata il massimo viene memorizzato18 for k=1:(length(signs)-1)19 signold = signs(k) ;


20 signew = signs(k+1) ;21 % individua la presenza di un massimo ed eventualmente lo memorizza22 if (signold == 1 & signew == -1)23 vettore_massimi(p) = Pxx(k+1) ;24 p=p+1 ;25 end26 end27 % ottengo posizione e valore del massimo assoluto28 [max_assoluto , pos] = max(vettore_massimi);29 % annullo il valore del massimo assoluto in modo da poter ricercare il30 % primo massimo relativo31 vettore_massimi(1 , pos) = 0;32 % ottengo il valore del 1 massimo relativo33 primo_max_relativo = max(vettore_massimi) ;34 % restituisco l ’ SFDR35 valore_sfdr = 10.*log10(max_assoluto)-10.*log10(primo_max_relativo);

Listato E.1.11: Calcola incremento fase NCO.m1 % DESCRIPTION : calcola la Frequency Word dell ’ NCO in 3 formati diversi23 % Pulizia ambiente Matlab4 clear all ;5 close all ;6 clc ;78 f_clk = 165e6 ;9 f_out = 41.25e6 ;

10 n_bit_acc = 32 ;11 n_bit_cordic = 13 ;1213 fw = round( (f_out * 2^n_bit_acc) / f_clk )1415 fw_hex = dec2hex(fw)16 fw_bin = dec2bin(fw)

Listato E.1.12: Visualizza spettro NCO VHDL.m1 % DESCRIPTION : visualizza lo spettro del seno prodotto dall ’ NCO VHDL23 % Pulizia ambiente Matlab4 clear all ;5 close all ;6 clc ;7 % Imposto la frequenza di clock del sistema e quella prodotta dall ’ NCO8 f_out = 40e6 ;9 f_clk = 165e6 ;

10 % carica la sequenza filtrata dal file data_out_SRRC_I . dat11 fid = fopen(’sine_to_matlab.dat’ , ’r’) ;12 seno_vhdl_dec = fscanf(fid,’%f’) ;13 fclose(fid) ;14 n_bit_dopo_virgola = 11 ;15 seno_vhdl = seno_vhdl_dec .* 2^(- n_bit_dopo_virgola) ;16 % Rappresentazione nel dominio della frequenza del coseno generato dall ’ NCO17 visualizza_spettro_e_sfdr_p( seno_vhdl , f_clk );

E.2 Creazione vettori di test

Listato E.2.1: CreaVettoriTest.m1 % DESCRIPTION : Crea dei vettori NRZ e RZ da applicare al VHDL23 % Pulizia ambiente Matlab4 clear all ;5 close all ;6 clc ;7 % vengono impostate le caratteristiche del polifase8 prompt = ’N bit Reset attivo :’,9 ’Interpolazione :’,

10 ’Nome del file sorgente :’ ;11 title = ’Impostazione delle caratteristiche dei segnali di test’;


12 lines = 1;13 def = ’5’ , ’4’, ’bit_tx.dat’ ;14 answer = inputdlg(prompt,title,lines,def) ;15 n_bit_reset_alto = str2double(answer(1));16 interp_rate = str2double(answer(2));17 nome_file_sorgente = char(answer(3));18 % legge da un file i bit randomici da trasmettere19 fid = fopen( nome_file_sorgente , ’r’) ;20 bit_tx = fscanf(fid,’%f’) ;21 fclose(fid) ;22 % determinazione del numero di bit di test da applicare23 n_bits2tx = length(bit_tx) ;24 % creazione del segnale di reset25 n_bit_dummy = 4*n_bit_reset_alto ;26 reset = zeros(n_bits2tx/2, 1) ;27 % vengono aggiunti 10 bit 1 all ’ inizio del segnale di reset piu altri 1028 reset =[ones(1,n_bit_reset_alto) zeros(1,n_bit_dummy/4) reset’]’;29 % salva su file il vettore di test RZ per la componente Q30 fid = fopen(’reset.dat’,’w’) ;31 fprintf(fid,’%d\n’, reset) ;32 fclose(fid) ;33 % vengono aggiunti dei bit di inizializzazione alla sequenza da trasmettere34 bit_tx =[zeros(1,n_bit_dummy) bit_tx’]’;35 % viene creato il vettore dei bit pari e quello dei bit dispari36 bit_I = bit_tx(1 : 2 : n_bits2tx + n_bit_dummy) ;37 bit_Q = bit_tx(2 : 2 : n_bits2tx + n_bit_dummy) ;38 % salva su file il vettore di test RZ per la componente I39 fid = fopen(’data_in_SRRCxN_tx_I_rz.dat’,’w’) ;40 fprintf(fid,’%d\n’, bit_I) ;41 fclose(fid) ;42 % salva su file il vettore di test RZ per la componente Q43 fid = fopen(’data_in_SRRCxN_tx_Q_rz.dat’,’w’) ;44 fprintf(fid,’%d\n’, bit_Q) ;45 fclose(fid) ;46 % i bit vengono opportunamente mappati47 data_in_SRRC_tx_I = -2*bit_I + 1 ;48 data_in_SRRC_tx_Q = -2*bit_Q + 1 ;49 % salva su file il vettore di test RZ per la componente I50 fid = fopen(’data_in_SRRCxN_tx_I_nrz.dat’,’w’) ;51 fprintf(fid,’%+d\n’, data_in_SRRC_tx_I) ;52 fclose(fid) ;53 % salva su file il vettore di test RZ per la componente Q54 fid = fopen(’data_in_SRRCxN_tx_Q_nrz.dat’,’w’) ;55 fprintf(fid,’%+d\n’, data_in_SRRC_tx_Q) ;56 fclose(fid) ;57 % si tiene conto del fatto che rate_sel e codificato su due bit58 switch interp_rate59 case 360 rate_sel_coded = 0 ;61 case 462 rate_sel_coded = 1 ;63 case 664 rate_sel_coded = 2 ;65 otherwise66 error(’Impossible !!! ’)67 end68 % creazione del segnale rate_sel per l ’ impostazione del data_rate69 rate_sel = rate_sel_coded * ones(length(data_in_SRRC_tx_Q) , 1) ;70 fid = fopen(strcat(’rate_sel_x’, num2str(interp_rate), ’.dat’),’w’);71 fprintf(fid,’%+d\n’, rate_sel) ;72 fclose(fid) ; disp(’Vettori di test generati correttamente.’) ;

Listato E.2.2: CreaSequenzaPatternGenerator.m1 % DESCRIPTION : Ha in ingresso i file con le sequenze da applicare ai2 % rispettivi canali del pattern generator34 % Pulizia ambiente Matlab5 clear all ;6 close all ;7 clc ;8 fclose(’all’);9 % vengono impostate le caratteristiche del polifase

10 prompt = ’Tipo di clock (int , ext) :’,11 ’N di segnali :’,12 ’N di bit nella sequenza d’’inizializzazione :’,13 ’Nome file di test da produrre :’ ;14 title = ’Caratteristiche dei vettori di test da applicare all’’FPGA’;15 lines = 1;16 def = ’ext’ , ’3’, ’10’ , ’I_testVector_x3.dat’;17 answer = inputdlg(prompt,title,lines,def) ;18 tipo_clock = char(answer(1));19 n_segnali = str2double(answer(2));20 n_bit_start = str2double(answer(3));21 nome_file_test = char(answer(4));


22 switch lower(tipo_clock)23 case ’int’,24 % viene richiesto di impostare il valore del clock interno25 answer = inputdlg( ’frequenza del clock interno :’, ...26 ’Impostazione del clock interno del Pattern Generator’,1,’40’) ;27 f_clk = str2double(answer(1))*10^6;28 clk_string = [’FORMAT:CLOCK INTERNAL,’ num2str((1/f_clk)*10^9)’E-9’];29 case ’ext’,30 % viene richiesto di impostare il range del clock esterno31 clk_ext = questdlg(’Selezionare range clock al Pattern Generator:’,...32 ’Selezione clock esterno’, ...33 ’f_clk_ext < 50MHz’,’50MHz < f_clk_ext < 100MHz’, ...34 ’f_clk_ext > 100MHz’,’f_clk_ext < 50MHz’);35 % viene ricavata la stringa da settare per il range esterno selezionato36 switch clk_ext37 case ’f_clk_ext < 50MHz’, ...38 clk_string = ’FORMAT:CLOCK EXTERNAL, LEFifty’;39 case ’50MHz < f_clk_ext < 100MHz’, ...40 clk_string = ’FORMAT:CLOCK EXTERNAL, GTFifty’;41 case ’f_clk_ext < 50MHz’, ...42 clk_string = ’FORMAT:CLOCK EXTERNAL, GTONe’;43 end44 end45 % si itera per acquisire i valori da assegnare ai diversi canali46 for s = 1 : 1 : n_segnali47 prompt = ’Nome del segnale :’,48 ’N di bit associati (multiplo di 4) :’,49 ’Nome file sorgente :’ ;50 title = [’Caratteristiche del segnale ’ num2str(s) ];51 lines = 1;52 def = ’data_in_SRRCxN_tx_I’,’4’,’data_in_SRRCxN_tx_I_rz.dat’;53 answer = inputdlg(prompt,title,lines,def) ;54 label(s) = answer(1);55 n_bit_label(s) = str2double(answer(2));56 eing_file(s) = answer(3);57 end58 % vengono caricati da file i segnali di test da applicare59 for s = 1 : n_segnali60 fid_in(s) = fopen( char(eing_file(s)) , ’r’) ;61 segnale(:,s) = fscanf(fid_in(s),’%d’) ;62 end63 % viene calcolata la lunghezza della stringa dummy costituita da tutti 064 n_cifreHEX_dummy = num2str( (40 - sum(n_bit_label) )/ 4 );65 % scrivo su file le stringhe esadecimali calcolate66 fid_out = fopen([tipo_clock ’Clk_’ nome_file_test ],’w’);67 % aggiungo al file l ’ intestazione68 fprintf(fid_out,’%s\n’, ’ASCII 000000’) ;69 fprintf(fid_out,’%s\n’, ’ASCDOWN’) ;70 fprintf(fid_out,’%s\n’, ’FORMAT:MODE FULL’) ;71 fprintf(fid_out,’%s\n’ , clk_string );72 % vengono aggiunte le label73 fprintf(fid_out,’%s’, ’LABEL dummy, ’) ;74 fprintf(fid_out,’%s\n’, num2str(40 - sum(n_bit_label) ));75 for s = 1 : n_segnali76 fprintf(fid_out,’%s’, ’LABEL ’) ;77 fprintf(fid_out,’%s’, char(label(s)) );78 fprintf(fid_out,’%s’, ’, ’) ;79 fprintf(fid_out,’%s\n’, num2str( n_bit_label(s) ));80 end81 fprintf(fid_out,’%s\n’, ’VECTOR’) ;82 % si itera su tutta la lunghezza della sequenza d ’ inizializzazione83 for row = 1 : 1 : n_bit_start84 % viene stampata una riga del vettore di test finale85 fprintf(fid_out,strcat(’%0’, n_cifreHEX_dummy ,’d’), 0 );86 for s = 1 : n_segnali87 fprintf(fid_out,’%s’, ’ ’) ;88 fprintf(fid_out, strcat(’%0’, num2str(n_bit_label(s) / 4 ), ’X’), ...89 segnale(row,s) );90 end91 fprintf(fid_out,’%s\n’, ’’) ;92 end93 fprintf(fid_out,’%s\n’, ’*M’) ;94 % si itera su tutta la lunghezza dei vettori di test d ’ ingresso95 for row = n_bit_start + 1 : 1 : length(segnale)96 % viene stampata una riga del vettore di test finale97 fprintf(fid_out,strcat(’%0’, n_cifreHEX_dummy ,’d’), 0 );98 for s = 1 : n_segnali99 fprintf(fid_out,’%s’, ’ ’) ;

100 fprintf(fid_out, strcat(’%0’, num2str(n_bit_label(s) / 4 ), ’X’), ...101 segnale(row,s) );102 end103 fprintf(fid_out,’%s\n’, ’’) ;104 end105 % chiusura dei file contenenti i segnali di test da applicare106 for s = 1 : n_segnali107 fclose(fid_in(s));108 end109 % chiusura del file di test da applicare alla FPGA110 fclose(fid_out);111 % segnalazione di fine creazione del file112 sound(wavread(’drumroll.wav’));


113 disp(’Vettore di test generato correttamente.’)

E.3 Polifase

Creazione coefficienti

Listato E.3.1: CreaCoeffsFreqSamplScaled.m1 % DESCRIPTION : calcola e confronta l ’ SRRC Matlab col FreqSampl e2 % condizionatamente scala i coefficienti34 % pulizia ambiente Matlab5 clear all ;6 close all ;7 clc ;8 % vengono impostate le caratteristiche del polifase9 prompt = ’Frequenza di clock :’,

10 ’Data Rate :’,11 ’Roll Off :’,12 ’N coefficienti del FIR desiderati :’,13 ’N di bit dopo la virgola :’,14 ’Scaling :’ ;15 title = ’Caratteristiche del polifase’;16 def = ’165’, ’110’, ’0.35’, ’19’, ’11’, ’Si’;17 answer = inputdlg(prompt, title, 1, def) ;18 f_clk = str2double(answer(1))*10^6;19 symbol_rate = str2double(answer(2))*10^6 / 2;20 roll_off = str2double(answer(3));21 n_coeffs = str2double(answer(4));22 n_bit_dopo_virgola = str2double(answer(5));23 Scaling = answer(6);24 % calcolo della interpolazione richiesta25 SpS = f_clk/symbol_rate ;26 % carica da file la sequenza dei dati da filtrare27 fid = fopen(’data_in_SRRCxN_tx_I_nrz.dat’ , ’r’) ;28 data_in_SRRCxN_tx_I = fscanf(fid,’%f’) ;29 fclose(fid) ;3031 % ***************************** MATLAB SRRC **********************************32 delay = 3 ;33 input_rate_SRRC = symbol_rate ;34 output_rate_SRRC = f_clk ;35 num_fir = rcosine(input_rate_SRRC,output_rate_SRRC,’fir/sqrt’,roll_off,delay);36 % viene filtrata la sequenza d ’ ingresso37 data_out_SRRC_matlab = applica_polifase(data_in_SRRCxN_tx_I, SpS , num_fir);38 % Power Spectral Density plotting39 [Pyy_matlab , f_out] = pwelch(data_out_SRRC_matlab, [] , [] , ’onesided’, ...40 length(data_out_SRRC_matlab) - 1 , f_clk) ;41 Pyy_matlab_dB = 10*log10(Pyy_matlab) ;42 figure ; plot(f_out , Pyy_matlab_dB - max(Pyy_matlab_dB) );43 grid ; xlim([0 f_clk/2]) ; ylim([-70 0]);44 legend([’SRRCx’ num2str(SpS) ’ Matlab ’ [num2str(symbol_rate/10^6)] ’ MSpS’]);45 xlabel(’Frequency (Hz)’); ylabel(’dB / Hz’);46 figure ; impz(num_fir) ;4748 % ***************************** FreqSampl SRRC ****************************49 Ts = 1/symbol_rate ; % tempo di simbolo50 % risposta in frequenza nell ’ origine del filtro a radice di coseno rialzato51 H(1) = sqrt(RaisedCosineResponse(0,roll_off,Ts));52 % per la simmetria occorrono solo N /2 campioni della risposta in frequenza53 for k = 1 : (n_coeffs - 1)/2,54 H(k + 1) = sqrt(RaisedCosineResponse(k*f_clk/n_coeffs, roll_off, Ts));55 H(n_coeffs - k + 1) = H(k + 1);56 end57 % mediante la trasformata di Fourier discreta inversa IDFT viene calcolata la58 % risposta all ’ impulso e traslata per garantire la causalita59 for n = (-(n_coeffs - 1)/2) : ((n_coeffs - 1)/2)60 num_fir_FreqSampl(n + ((n_coeffs - 1)/2) +1) = H(0 + 1);61 for m = 1 : (n_coeffs - 1)/2,62 num_fir_FreqSampl(n + ((n_coeffs - 1)/2) +1) = ...63 num_fir_FreqSampl(n + ((n_coeffs-1)/2)+1) + ...64 2*H(m + 1)*cos(2*pi*m*n / n_coeffs);65 end66 end67 % calcolo il fattore di scaling e l ’ aggiunta al nome del file dei coefficienti68 if strcmp(Scaling, ’No’)69 % i coefficienti non scalati vengono salvati nel file70 fid = fopen(strcat(’SRRCx’ , num2str(SpS) , ’_FreqSampl.dat’) , ’w’);71 fprintf(fid,’%20.19f\n’, num_fir_FreqSampl) ;


72 fclose(fid) ;73 % la sequenza dati e applicata all ’ SRRC progettato campionando in frequenza74 data_out_SRRC_FreqSampl = ...75 applica_polifase(data_in_SRRCxN_tx_I, SpS , num_fir_FreqSampl);76 % Power Spectral Density plotting77 [Pyy_FreqSampl , f_out] = pwelch(data_out_SRRC_FreqSampl, [] , [] , ...78 ’onesided’, length(data_out_SRRC_FreqSampl) - 1 , f_clk) ;79 Pyy_FreqSampl_dB = 10*log10(Pyy_FreqSampl) ;80 figure ; plot(f_out , Pyy_FreqSampl_dB - max(Pyy_FreqSampl_dB) );81 grid ; xlim([0 f_clk/2]) ; ylim([-70 0]);82 legend([’SRRCx’ num2str(SpS) ’ FreqSampl ’ ...83 [num2str(symbol_rate/10^6)] ’MSpS’]);84 xlabel(’Frequency (Hz)’); ylabel(’dB / Hz’);85 figure ; impz(num_fir_FreqSampl) ;86 else87 % n di FIR che effettivamente costituiscono il polifase88 n_fir = SpS ;89 % lunghezza massima dei FIR costituenti il polifase90 max_dim_fir = ceil( n_coeffs / n_fir) ;91 % creo una matrice che in ogni riga ha i coefficienti92 % di uno dei rami del filtro SRRC polifase93 % la inizializzo per velocizzare il riempimento94 matrice_dei_fir = zeros(n_fir, max_dim_fir) ;95 for i = 1 : n_fir % riempio una riga alla volta96 % estraggo i coefficenti dell ’ i_esimo fir97 fir_i = num_fir_FreqSampl(i : n_fir : n_coeffs) ;98 % figure ; freqz ( fir_i ) ; figure ; impz ( fir_i ) ;99 % li copio nella matrice dei fir

100 matrice_dei_fir(i , 1:length(fir_i) )= fir_i ;101 end102 % sommo i moduli dei coefficienti di ogni FIR103 for i = 1 : n_fir104 modulo_i = sum(abs(matrice_dei_fir(i,:)));105 vettore_moduli(i) = modulo_i ;106 end107 % calcolo il fattore di scaling108 scaling_factor = max(vettore_moduli) / 0.95 ;109 % viene applicato il fattore di scaling110 num_fir_FreqSampl_scaled = num_fir_FreqSampl / scaling_factor ;111 % i coefficienti scalati vengono salvati nel file112 fid = fopen(strcat(’SRRCx’,num2str(SpS),’_FreqSampl_scaled.dat’),’w’);113 fprintf(fid,’%20.19f\n’, num_fir_FreqSampl_scaled);114 fclose(fid);115 % la sequenza dati e applicata all ’ SRRC coi coefficienti scalati116 data_out_SRRC_FreqSampl_scaled = applica_polifase(data_in_SRRCxN_tx_I, ...117 SpS , num_fir_FreqSampl_scaled);118 % Power Spectral Density plotting119 [Pyy_FreqSampl_scaled , f_out] = pwelch(data_out_SRRC_FreqSampl_scaled,...120 [],[], ’onesided’, length(data_out_SRRC_FreqSampl_scaled) - 1 , f_clk);121 Pyy_FreqSampl_scaled_dB = 10*log10(Pyy_FreqSampl_scaled) ;122 figure; plot(f_out,Pyy_FreqSampl_scaled_dB-max(Pyy_FreqSampl_scaled_dB));123 grid ; xlim([0 f_clk/2]) ; ylim([-70 0]);124 legend([’SRRCx’ num2str(SpS) ’ FreqSampl scaled ’ ...125 [num2str(symbol_rate/10^6)] ’ MSpS’ ]);126 xlabel(’Frequency (Hz)’); ylabel(’dB / Hz’);127 figure ; impz(num_fir_FreqSampl_scaled) ;128 end

Listato E.3.2: applica polifase.m1 % DESCRIPTION : Applica il filtraggio secondo lo schema polifase23 function data_out_polifase=applica_polifase(data_in_polifase,SpS,coefficienti)45 % n di FIR che costituiscono il polifase6 n_fir = SpS ;7 n_symb = length(data_in_polifase) ;8 % n di coefficienti del filtro da realizzare9 n_coefficienti = length(coefficienti) ;

10 % lunghezza massima dei FIR costituenti il polifase11 max_dim_fir = ceil( n_coefficienti / n_fir) ;12 % creo una matrice che in ogni riga ha i coefficienti di uno dei rami del13 % filtro SRRC polifase14 matrice_dei_fir = zeros(n_fir, max_dim_fir) ;15 for i = 1 : n_fir % riempio una riga alla volta16 % estraggo i coefficenti dell ’ i_esimo fir17 fir_i = coefficienti(i : n_fir : n_coefficienti) ;18 % figure ; freqz ( fir_i ) ; figure ; impz ( fir_i ) ;19 % li copio nella matrice dei fir20 matrice_dei_fir(i , 1:length(fir_i) )= fir_i ;21 end22 % applico la sequenza dati ad ogni fir23 matrice_fir_out = zeros( n_fir , n_symb );24 for i = 1 : n_fir25 matrice_fir_out(i,:)=filter(matrice_dei_fir(i,:),1,data_in_polifase’);


26 end27 % creo un vettore con le uscite dal filtro prese come le prenderebbe un28 % multiplexer questo vettore in pratica e il risultato dell ’ interpolazione29 data_out_polifase = zeros( 1 , n_symb * n_fir );30 k = 0 ; % e un puntatore per scandire il vettore da riempire31 for colonna = 1 : n_symb % considero un simbolo alla volta32 for riga = 1 : n_fir % ed un fir alla volta33 k = k + 1 ;34 data_out_polifase(k) = matrice_fir_out(riga , colonna);35 end36 end

Listato E.3.3: RaisedCosineResponse.m1 % DESCRIPTION : Calcola la risposta in frequenza del filtro a coseno rialzato23 function [y] = RaisedCosineResponse(f,roll_off,T)4 if (abs(f) > ((1+roll_off)/(2*T))),5 y = 0;6 elseif (abs(f) > ((1-roll_off)/(2*T))),7 y = (T/2)*(1+cos((pi*T/roll_off)*(abs(f)-(1-roll_off)/(2*T))));8 else9 y = T;

10 end

Listato E.3.4: CreaROM.m1 % DESCRIPTION : genera i valori da inserire nella ROM del polifase mediante2 % il costrutto VHDL case oppure il Constant oppure genera un3 % file in formato . coe adatto ad essere fornito ad un Core4 % Xilinx che implementa una BlockRAM56 % Pulizia ambiente Matlab7 clear all ;8 close all ;9 clc ;

10 % vengono impostate le caratteristiche del polifase11 prompt = ’Interpolazione :’,12 ’N di bit dopo la virgola :’;13 title = ’Caratteristiche del polifase’;14 def = ’3’, ’11’;15 answer = inputdlg(prompt, title, 1, def) ;16 SpS = str2double(answer(1));17 n_bit_dopo_virgola = str2double(answer(2));18 % scelta tra l ’ implementazione della ROM con il CASE o con una costante19 implementazione = questdlg(’Scegliere il codice VHDL da generare ’, ...20 ’Selezione implementazione ROM’,’Case’,’Costante’,’BlockRAM’,’Case’);21 % carico da file il vettore contenente i coefficienti del filtro gia scalati22 fid = fopen(strcat(’SRRCx’,num2str(SpS),’_FreqSampl_scaled.dat’),’r’);23 num_fir = fscanf(fid,’%f’) ;24 num_fir = num_fir’ ;25 fclose(fid) ;26 % n di FIR che costituiscono il polifase27 n_fir = SpS ;28 % n di coefficienti del filtro da realizzare29 n_coefficienti = length(num_fir) ;30 % lunghezza massima dei FIR costituenti il polifase31 max_dim_fir = ceil( n_coefficienti / n_fir) ;32 % matrice che in ogni riga ha i coefficienti di uno dei rami del filtro SRRC33 % inizializzo per velocizzare il riempimento34 matrice_dei_fir = zeros(n_fir, max_dim_fir) ;35 for i = 1 : n_fir % riempio una riga alla volta36 % estraggo i coefficienti dell ’ i_esimo fir37 fir_i = num_fir(i : n_fir : n_coefficienti) ;38 % li copio nella matrice dei fir39 matrice_dei_fir(i , 1:length(fir_i) )= fir_i ;40 end41 % indirizzo della ROM da inserire nel file42 rom_addr = 0 ;43 % viene aperto il file nel quale memorizzare i valori della ROM44 fid = fopen(strcat(’SRRCx’,num2str(SpS),’ROM_’,implementazione,’.dat’),’w’);45 switch(implementazione)46 case ’BlockRAM’,47 % viene richiesto se generare una RAM zero padded48 RamPadded = questdlg(’Generare una RAM zero padded ’, ...49 ’Selezione tipo ROM’,’Si’,’No’,’Si’);5051 % sintassi per il file . coe da fornire al CORE BlockRAM52 fprintf(fid,’%s\n’, ’MEMORY_INITIALIZATION_RADIX=16;’) ;53 fprintf(fid,’%s\n’, ’MEMORY_INITIALIZATION_VECTOR=’) ;


54 end55 % itero sui fir che costituiscono il polifase56 % for i = 1 : n_fir57 for i = n_fir : -1 : 158 % viene scritta sul file l ’ istruzione per l ’ assegnamento di default59 % per i valori non assegnati60 switch(implementazione)61 case ’Case’,’Costante’,62 % aggiungo al file il commento che indica il numero del FIR63 fprintf(fid,’%s\n’, ’ ’) ;64 fprintf(fid,’%s’, ’ -- somme per il FIR ’) ;65 % fprintf ( fid ,’% s \ n ’, num2str ( i ) ) ;66 fprintf(fid,’%s\n’, num2str(n_fir - i)) ;67 end68 % calcolo le somme da inserire nel file per il filtro i_esimo69 % itero su tutte le combinazioni d ’ ingresso70 for eing = 0 : 1 : 2^max_dim_fir - 171 % la sequenza d ’ ingresso attuale viene convertita in formato rz +1,072 eing_rz = bitget(eing,max_dim_fir:-1:1) ;73 % la sequenza d ’ ingresso attuale viene convertita in formato nrz +1,-174 eing_nrz = ( -2 .* eing_rz )+ 1 ;75 % vengono sommati i coefficienti pesati del filtro i_esimo76 somma = sum( eing_nrz .* matrice_dei_fir(i,:) ) ;77 % le somme vengono convertite in interi e arrotondate in modo da poter78 % esser elaborate dal VHDL79 somma_int = round( somma * 2^n_bit_dopo_virgola );80 % calcolo l ’ intero in complemento a due corrispondente alla somma81 if sign(somma_int) == -1 % coefficiente negativo82 somma_int_C2 = 2^(n_bit_dopo_virgola+1) - abs(somma_int); %2^ N - | x |83 else % coefficiente positivo84 somma_int_C2 = abs(somma_int) ; % | x |85 end86 % aggiungo al file l ’ i_esimo valore della somma del fir87 switch(implementazione)88 case ’Case’,89 % sintassi per il costrutto VHDL Case90 fprintf(fid,’%s’, ’ when ’) ;91 fprintf(fid,’%3d’, rom_addr );92 fprintf(fid,’%s’, ’ => SRRC_out <= X"’) ;93 fprintf(fid,’%03X’, somma_int_C2) ;94 fprintf(fid,’%s\n’, ’";’) ;95 case ’Costante’,96 % sintassi per il costrutto VHDL Constant97 fprintf(fid,’%s’, ’ ROM_value’’(X"’) ;98 fprintf(fid,’%03X’, somma_int_C2) ;99 fprintf(fid,’%s’, ’") , -- ’) ;

100 fprintf(fid,’%3d’, rom_addr) ;101 fprintf(fid,’%s\n’, ’ ’) ;102 case ’BlockRAM’,103 % sintassi per il file . coe da fornire al CORE BlockRAM104 fprintf(fid,’%03X’, somma_int_C2) ;105 fprintf(fid,’%s\n’, ’, ’) ;106 otherwise, disp(’Unknown method.’)107 end108 % punto alla successiva cella di memoria da riempire109 rom_addr = rom_addr + 1 ;110 end111 end112 % viene scritta sul file l ’ istruzione per l ’ assegnamento di default113 % per i valori non assegnati114 switch(implementazione)115 case ’Case’,116 % sintassi per il costrutto VHDL Case117 fprintf(fid,’%s\n’, ’ when OTHERS => SRRC_out <= X"000";’);118 case ’Costante’,119 % sintassi per il costrutto VHDL Constant120 fprintf(fid,’%s\n’, ’ ’) ;121 fprintf(fid,’%s\n’, ’ OTHERS => ROM_value’’(X"000") );’);122 case ’BlockRAM’,123 % se la RAM e padded aggiungo degli 0 che la occupano tutta in questo124 % modo si possono mettere in un ’ unica RAM tutti e tre gli SRRC125 if strcmp(RamPadded , ’Si’)126 % per l ’ indirizzamento considero la ROM di dimensioni maggiori127 for addr = rom_addr : 1 : 2^(max_dim_fir + round(log2(6))) - 1128 fprintf(fid,’%03X’, 0) ;129 fprintf(fid,’%s\n’, ’, ’) ;130 end131 end132 fprintf(fid,’%s\n’, ’;’) ;133 otherwise, disp(’Unknown method.’)134 end135 % viene chiuso il file contenente i valori delle somme da porre nella ROM136 fclose(fid) ; disp(’Generato file valori ROM .’) ;


Test VHDL

Listato E.3.5: PolyphasePSDVHDLvsPSDMatlab.m1 % DESCRIPTION : Confronta lo spettro della sequenza filtrata tramite il VHDL2 % con quello della sequenza filtrata tramite Matlab34 % Pulizia ambiente Matlab5 clear all ;6 close all ;7 clc ;8 % ************** IMPOSTAZIONE CARATTERISTICHE DEL MODULATORE **************9 % vengono impostate le caratteristiche del polifase

10 prompt = ’Frequenza di clock :’,11 ’Symbol Rate :’,12 ’N di bit dopo la virgola :’;13 title = ’Caratteristiche del polifase’;14 def = ’40’, ’40/3’, ’11’;15 answer = inputdlg(prompt, title, 1, def) ;16 f_clk = str2double(answer(1))*10^6;17 symbol_rate = eval( char(answer(2)) )*10^6;18 n_bit_dopo_virgola = str2double(answer(3));19 % viene determinato il valore dell ’ interpolazione20 SpS = f_clk / symbol_rate ;21 % selezione del file sorgente tra quello prodotto dalla simulazione semplice e22 % quello della back - annotata23 file_simulazione = questdlg(’Selezionare il nome del file sorgente VHDL :’,...24 ’Selezione simulazione back-annotata o semplice’,...25 ’data_out_SRRCxN_tx_I.dat’,’TB_data_out_SRRCxN_tx_I.dat’,...26 ’data_out_SRRCxN_tx_I.dat’);2728 % **** VIENE APPLICATA LA DECOMPOSIZIONE POLIFASE MATLAB DI RIFERIMENTO ****29 % carica da file la sequenza dei dati da filtrare30 fid = fopen(’data_in_SRRCxN_tx_I_nrz.dat’ , ’r’) ;31 data_in_SRRCxN_tx_I = fscanf(fid,’%f’) ;32 fclose(fid) ;33 % carica da file i coefficienti del filtro polifase34 fid = fopen( strcat(’SRRCx’, num2str(SpS), ’_FreqSampl_scaled.dat’),’r’);35 num_fir = fscanf(fid,’%f’) ;36 num_fir = num_fir’ ;37 fclose(fid) ;38 % applica il filtraggio polifase Matlab39 data_out_SRRCxN_tx_I = applica_polifase(data_in_SRRCxN_tx_I, SpS , num_fir);40 % con il metodo di Welch viene calcolato lo spettro della sequenza filtrata41 % mediante il polifase MATLAB42 [Pyy_Matlab , f_out] = pwelch(data_out_SRRCxN_tx_I, [] , [] , ’onesided’,...43 length(data_out_SRRCxN_tx_I) - 1 , f_clk) ;44 Pyy_dB_Matlab = 10*log10(Pyy_Matlab) ;45 figure ; plot(f_out , Pyy_dB_Matlab - max(Pyy_dB_Matlab) );46 grid ; xlim([0 f_clk/2]) ; ylim([-70 0]);47 legend([’Out SRRCx’,num2str(SpS),’ Matlab ’,num2str(symbol_rate/1e6),’ MSpS’]);48 xlabel(’Frequency (Hz)’); ylabel(’dB / Hz’);4950 % ************** VIENE APPLICATA LA DECOMPOSIZIONE POLIFASE VHDL *********51 % carica da file la sequenza filtrata dal polifase VHDL52 fid = fopen(file_simulazione , ’r’) ;53 % viene scartato il primo numero che e un overflow54 string_unuseful = fscanf(fid, ’%s’ , 1);55 % vengono letti un numero di campioni pari a quelli del polifase Matlab56 data_out_SRRCxN_tx_I_dec=fscanf(fid,’%f’,length(data_in_SRRCxN_tx_I)*SpS);57 fclose(fid);58 data_out_SRRCxN_tx_I_VHDL=data_out_SRRCxN_tx_I_dec.*2^(- n_bit_dopo_virgola);59 % viene prodotta una stringa da aggiungere alla label nel caso di simulazione60 % back - annotata61 if strcmp(file_simulazione , ’TB_data_out_SRRCxN_tx_I.dat’)62 tipo_simulazione = ’B.A. ’ ;63 else64 tipo_simulazione = ’’ ;65 end66 % con il metodo di Welch viene calcolato lo spettro della sequenza filtrata67 % dal polifase VHDL68 [Pyy_VHDL , f_out]=pwelch(data_out_SRRCxN_tx_I_VHDL, [] , [] , ’onesided’,...69 length(data_out_SRRCxN_tx_I_VHDL) - 1 , f_clk) ;70 Pyy_dB_VHDL = 10*log10(Pyy_VHDL) ;71 figure ; plot(f_out , Pyy_dB_VHDL - max(Pyy_dB_VHDL) , ’-r’);72 grid ; xlim([0 f_clk/2]) ; ylim([-70 0]);73 legend([’Out SRRCx’,num2str(SpS),’ VHDL ’,tipo_simulazione,...74 num2str(symbol_rate/1e6),’ MSpS’]);75 xlabel(’Frequency (Hz)’); ylabel(’dB / Hz’);7677 % ****************************** CONFRONTO SPETTRALE *********************78 % visualizzazione contemporanea dei due spettri79 figure ;80 plot(f_out,Pyy_dB_Matlab-max(Pyy_dB_Matlab),’-b’,f_out,...81 Pyy_dB_VHDL-max(Pyy_dB_VHDL),’-r’);82 grid ; xlim([0 f_clk/2]) ; ylim([-70 0]);83 legend([’Out SRRCx’, num2str(SpS), ’ Matlab ’ , num2str(symbol_rate/1e6),...


84 ’ MSpS’ ],[’Out SRRCx’, num2str(SpS),’ VHDL ’,tipo_simulazione,...85 num2str(symbol_rate/1e6) , ’ MSpS’ ] );86 xlabel(’Frequency (Hz)’); ylabel(’dB / Hz’);87 % ******************************* CONFRONTO TEMPORALE *********************88 % n_bits = length ( data_out_SRRCxN_tx_I ) ;89 % N_bit_sfasamento = 8 ;90 % [ data_out_SRRCxN_tx_I (( N_bit_sfasamento +1) : n_bits ) ’,...91 % data_out_SRRCxN_tx_I_VHDL (1:( n_bits - N_bit_sfasamento ) ) ]

Listato E.3.6: applica polifase.m

vedi listato(E.3.2)

Test FPGA

Listato E.3.7: VisualizzaPSDPolifaseVHDLFPGAout.m1 % DESCRIPTION : carica da file la sequenza dati filtrata tramite l ’ FPGA e2 % ne fa l ’ analisi spettrale34 % Pulizia ambiente Matlab5 clear all ;6 close all ;7 clc ;8 % ************ IMPOSTAZIONE CARATTERISTICHE DEL MODULATORE ************9 % vengono impostate le caratteristiche del polifase

10 prompt = ’Frequenza di clock :’,11 ’Symbol Rate :’,12 ’N di bit dopo la virgola :’,13 ’N di campioni da considerare :’;14 title = ’Caratteristiche del polifase’;15 def = ’40’, ’40/3’, ’11’, ’18000’;16 answer = inputdlg(prompt, title, 1, def) ;17 f_clk = str2double(answer(1))*10^6;18 symbol_rate = eval( char(answer(2)) )*10^6;19 n_bit_dopo_virgola = str2double(answer(3));20 n_values = str2double(answer(4));21 % viene determinato il valore dell ’ interpolazione22 SpS = f_clk / symbol_rate ;23 % **** VIENE APPLICATA LA DECOMPOSIZIONE POLIFASE MATLAB DI RIFERIMENTO ****24 % carica da file la sequenza dei dati da filtrare25 fid = fopen(’data_in_SRRCxN_tx_I_nrz.dat’ , ’r’) ;26 data_in_SRRCxN_tx_I = fscanf(fid,’%f’) ;27 fclose(fid) ;28 % carica da file i coefficienti del filtro polifase29 fid = fopen( strcat(’SRRCx’,num2str(SpS),’_FreqSampl_scaled.dat’),’r’);30 num_fir = fscanf(fid,’%f’) ;31 num_fir = num_fir’ ;32 fclose(fid) ;33 % applica il filtraggio polifase Matlab34 data_out_SRRCxN_tx_I = applica_polifase(data_in_SRRCxN_tx_I, SpS , num_fir);35 % con il metodo di Welch viene calcolato lo spettro della sequenza36 % filtrata dal polifase MATLAB37 [Pyy_Matlab , f_out] = pwelch(data_out_SRRCxN_tx_I, [] , [] , ’onesided’,...38 length(data_out_SRRCxN_tx_I) - 1 , f_clk) ;39 Pyy_dB_Matlab = 10*log10(Pyy_Matlab) ;40 figure ; plot(f_out , Pyy_dB_Matlab - max(Pyy_dB_Matlab) , ’-b’);41 grid ; xlim([0 f_clk/2]) ; ylim([-70 0]);42 legend([’Out SRRCx’, num2str(SpS), ’ Matlab ’ , ...43 num2str(symbol_rate/1e6) , ’ MSpS’ ]);44 xlabel(’Frequency (Hz)’); ylabel(’dB / Hz’);45 % ************ ELABORAZIONE DELLA SEQUENZA FILTRATA DALL ’ FPGA *************46 % carica la sequenza proveniente dall ’ analizzatore di stati logici47 fid = fopen(’file_out.txt’ , ’r’);48 % vengono scartate le prime 7 stringhe49 string_unuseful = fscanf(fid, ’%s’ , 7);50 % viene prelevata la stringa che indica il formato51 formato = fscanf(fid, ’%s’ , 1) ;52 % viene scartata una stringa con tutti -


53 string_unuseful = fscanf(fid, ’%s’ , 1);54 % i dati vengono letti dal file nel giusto formato55 switch(formato)56 case ’Hex’,57 value_int_C2 = fscanf(fid, ’%x’ , n_values) ;58 case ’Decimal’,59 value_int_C2 = fscanf(fid, ’%f’ , n_values) ;60 end61 fclose(fid) ;62 % converte l ’ intero unsigned in complemento a due in un intero con segno63 value_int = zeros(n_values,1);64 for i = 1 : 1 : n_values65 if bitget( value_int_C2(i) , 12) == 1 % valore negativo66 % x_C2 = 2^ N - | x |67 value_int(i) = -( 2^(n_bit_dopo_virgola+1) - value_int_C2(i) );68 else % coefficiente positivo69 value_int(i) = value_int_C2(i) ; % x_C2 = | x |70 end71 end72 % converte da intero con segno a numero reale con segno73 value_real = value_int .* 2^(- n_bit_dopo_virgola);74 data_out_SRRCxN_tx_I_FPGA = value_real ;75 % con il metodo di Welch viene calcolato lo spettro della sequenza76 % filtrata dal polifase VHDL e plottata77 [Pyy_FPGA , f_out] = pwelch(data_out_SRRCxN_tx_I_FPGA, [] , [] , ...78 ’onesided’, length(data_out_SRRCxN_tx_I_FPGA) - 1 , f_clk) ;79 Pyy_dB_FPGA = 10*log10(Pyy_FPGA) ;80 figure ; plot(f_out , Pyy_dB_FPGA - max(Pyy_dB_FPGA) , ’-r’ );81 grid ; xlim([0 f_clk/2]) ; ylim([-70 0]);82 legend([’Out SRRCx’, num2str(SpS), ’ FPGA ’ , ...83 num2str(symbol_rate/1e6), ’ MSpS’ ]);84 xlabel(’Frequency (Hz)’); ylabel(’dB / Hz’);8586 % ************** CONFRONTO SPETTRALE *********************************87 % visualizzazione contemporanea dei due spettri88 figure ;89 plot(f_out , Pyy_dB_Matlab - max(Pyy_dB_Matlab) , ’-b’ , f_out , ...90 Pyy_dB_FPGA - max(Pyy_dB_FPGA) , ’-r’);91 grid ; xlim([0 f_clk/2]) ; ylim([-70 0]);92 legend([’Out SRRCx’, num2str(SpS), ’ Matlab ’ , num2str(symbol_rate/1e6),...93 ’ MSpS’ ], [’Out SRRCx’, num2str(SpS), ’ FPGA ’ , ...94 num2str(symbol_rate/1e6) , ’ MSpS’ ] );95 xlabel(’Frequency (Hz)’); ylabel(’dB / Hz’);96 % ******************* CONFRONTO TEMPORALE *****************************97 % n_bits = length ( data_out_SRRCxN_tx_I ) ;98 % N_bit_sfasamento = 8 ;99 % [ data_out_SRRCxN_tx_I (( N_bit_sfasamento +1) : n_bits ) ’ , ...

100 % data_out_SRRCxN_tx_I_FPGA (1:( n_bits - N_bit_sfasamento ) ) ]


vedi listato(E.3.2)

E.4 Modulatore

Tabella e grafico BER

Listato E.4.1: CreaTabellaBER.m1 % MODULE NAME : CreaTabellaBER . m2 % DESCRIPTION : Crea una tabella ed un grafico del BER in funzione di Eb / N034 % Pulizia ambiente Matlab5 clear all ;6 close all ;7 clc ;8 % ****************************************************************************


9 % ****************** IMPOSTAZIONE CARATTERISTICHE MISURA *****************10 % ****************************************************************************11 prompt = ’Frequenza di clock :’,12 ’Data Rate :’,13 ’Eb/No minimo (dB) :’,14 ’Eb/No massimo (dB) :’,15 ’N di ripetizioni per ogni valore di Eb/No :’;16 title = ’Impostazione della simulazione Modem QPSK’;17 def = ’165’, ’110’, ’2’, ’6’, ’2’;18 answer = inputdlg(prompt, title, 1, def) ;19 f_clk = str2double(answer(1))*10^6;20 data_rate = str2double(answer(2))*10^6;21 EbNo_dB_min = str2double(answer(3));22 EbNo_dB_max = str2double(answer(4));23 Repeat = str2double(answer(5));2425 % messaggio per rassicurare l ’ operatore , qualcosa si muove anche se non sembra26 disp(’...elaborazione della tabella dei BER in corso’)27 disp(’ ’)28 disp(’ ’)29 % iterazione sui diversi valori di EbNo_dB30 for EbNo_dB = EbNo_dB_min : 1 : EbNo_dB_max31 EbNo = 10.^(EbNo_dB/10) ;32 expBER = 0.5 .* erfc(sqrt(EbNo)) ;33 expBER_vect(EbNo_dB + 1 - EbNo_dB_min) = expBER ;34 n_bits = 60 * 12 .* round( [1 ./ expBER’] ./ 12) ;35 if n_bits < 1200036 n_bits = 12000 ;37 end38 for i = 1:1:Repeat39 [n_bit_errati , BER] = calcolaBER(n_bits , EbNo_dB, f_clk , data_rate) ;40 temp_BER(i) = BER ;41 end42 BER_vect(EbNo_dB + 1 - EbNo_dB_min) = ( sum(temp_BER) )/ Repeat ;43 end44 % Viene plottato il BER teorico affiancato al BER sperimentale45 EbNo_dB = [EbNo_dB_min : 1 : EbNo_dB_max] ;46 semilogy(EbNo_dB(:), BER_vect, ’b-’, EbNo_dB(:), expBER_vect, ’r-’);47 legend(’BER sperimentale ’,’BER Teorico’,0); grid on;48 xlabel(’EbNo (dB)’); ylabel(’BER’);49 disp(’ Eb/No BER teorico BER sperimentale’)50 [EbNo_dB’ expBER_vect’ BER_vect’]

Listato E.4.2: calcolaBER.m1 % MODULE NAME : Modulatore QPSK con applica_polifase SRRC . m2 % DESCRIPTION : Funzione per la misura del BER3 % DATE : 19-10-200145 function [n_bit_errati_Matlab , BER_Matlab] = ...6 BER_sperimentale(n_bits , EbNo_dB , f_clk , data_rate)78 %%%%%%%%%%%%%%%%%%%%%%%% IMPOSTAZIONE MODULATORE %%%%%%%%%%%%%%%%%%%%%%%%%9 symbol_rate = data_rate / 2 ;

10 SpS = f_clk / symbol_rate ;11 n_symb = n_bits / 2 ;12 n_sample = n_symb * SpS ;1314 % crea un vettore di bits randomici15 bit_tx = randint(n_bits, 1, [0 1] );16 n_bits_tx = length(bit_tx) ;1718 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% MODULAZIONE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%19 % carica da file i coefficienti del filtro polifase20 fid = fopen( strcat(’SRRCx’, num2str(SpS), ’_FreqSampl_scaled.dat’),’r’);21 num_fir = fscanf(fid,’%f’) ;22 num_fir = num_fir’ ;23 fclose(fid) ;24 % viene creato il vettore dei bit pari e quello dei bit dispari25 bit_tx_I = bit_tx(1 : 2 : n_bits_tx) ;26 bit_tx_Q = bit_tx(2 : 2 : n_bits_tx) ;27 % si passa dalla codifica RZ alla codifica NRZ28 data_in_SRRCxN_tx_I_Matlab = -2*bit_tx_I + 1 ;29 data_in_SRRCxN_tx_Q_Matlab = -2*bit_tx_Q + 1 ;30 % applica il filtraggio polifase Matlab31 data_out_SRRCxN_tx_I_Matlab = applica_polifase(data_in_SRRCxN_tx_I_Matlab,...32 SpS , num_fir);33 data_out_SRRCxN_tx_Q_Matlab = applica_polifase(data_in_SRRCxN_tx_Q_Matlab,...34 SpS , num_fir);35 % Vengono generati i campioni di seno e coseno considerando f_IF = f_clk / 436 % n di campioni da generare per le portanti37 n_sample = length(data_out_SRRCxN_tx_I_Matlab);38 % periodo di campionamento39 t_clk = 1 / f_clk ;40 % istanti di campionamento


41 t = 0 : t_clk : (n_sample-1)*t_clk ;42 % incrementi di fase43 theta = 2*pi*(f_clk/4)*t ;44 % generazione di un coseno45 coseno = [cos(theta)] ;46 % generazione di un seno47 seno = [sin(theta)] ;48 data_out_QPSK_Mod_Matlab = [coseno .* data_out_SRRCxN_tx_I_Matlab] - ...49 [seno .* data_out_SRRCxN_tx_Q_Matlab] ;50 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% EFFETTO DEL CANALE %%%%%%%%%%%%%%%%%%%%%%%%%%%51 data_in_QPSK_DeMod_Matlab = awgn(data_out_QPSK_Mod_Matlab, ...52 EbNo_dB + 10*log10(2) -10*log10(0.5.*SpS), ’measured’, [], ’dB’);5354 %%%%%%%%%%%%%%%%%%%%%%%%%%%%% DEMODULAZIONE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%55 % il segnale in banda traslata viene suddiviso nelle componenti in banda base56 data_in_SRRCxN_rx_I_Matlab = coseno .* data_in_QPSK_DeMod_Matlab ;57 data_in_SRRCxN_rx_Q_Matlab = -seno .* data_in_QPSK_DeMod_Matlab ;58 % applico il filtro adattato ad entrambe le componenti59 data_out_SRRCxN_rx_I_Matlab = filter(num_fir, 1 , data_in_SRRCxN_rx_I_Matlab);60 data_out_SRRCxN_rx_Q_Matlab = filter(num_fir, 1 , data_in_SRRCxN_rx_Q_Matlab);61 data_I_Q_rx_Matlab = ...62 [data_out_SRRCxN_rx_I_Matlab’ data_out_SRRCxN_rx_Q_Matlab’];63 % viene effettuato uno sfasamento , una decimazione ed applicato il decisore64 symbols_Matlab = demodmap(data_I_Q_rx_Matlab , [symbol_rate 1] , f_clk , ...65 ’qask’ , 4) ;66 % l ’ uscita del decisore viene convertita in formato NRZ67 for n = 1:length(symbols_Matlab)68 switch symbols_Matlab(n)69 case 070 symbols_I_Matlab(n) = 1 ; symbols_Q_Matlab(n) = 1 ;71 case 172 symbols_I_Matlab(n) = -1 ; symbols_Q_Matlab(n) = 1 ;73 case 274 symbols_I_Matlab(n) = 1 ; symbols_Q_Matlab(n) = -1 ;75 case 376 symbols_I_Matlab(n) = -1 ; symbols_Q_Matlab(n) = -1 ;77 end78 end79 % si passa dalla codifica NRZ alla codifica RZ80 bit_rx_I_Matlab = ( symbols_I_Matlab - 1) / (-2) ;81 bit_rx_Q_Matlab = ( symbols_Q_Matlab - 1) / (-2) ;82 % dai simboli si riottiene la sequenza composta da bit I e Q alternati83 bit_rx_Matlab = 4*ones(1 , n_bits_tx) ;84 bit_rx_Matlab(1 : 2 : n_bits_tx) = bit_rx_I_Matlab ;85 bit_rx_Matlab(2 : 2 : n_bits_tx) = bit_rx_Q_Matlab ;86 % viene compensato lo sfasamento tra la sequenza trasmessa e quella ricevuta87 N_bit_sfasamento_Matlab = 12 ;88 [n_bit_errati_Matlab BER_Matlab] = ...89 biterr(bit_tx(1:(n_bits_tx - N_bit_sfasamento_Matlab)), ...90 bit_rx_Matlab( (N_bit_sfasamento_Matlab + 1):n_bits_tx)’) ;


vedi listato(E.3.2)

Test VHDL

Listato E.4.4: QPSKModemPSDeBERVHDLvsMatlab.m1 % DESCRIPTION : Confronta lo spettro ed il BER della sequenza modulata2 % tramite il VHDL con quello Matlab34 % Pulizia ambiente Matlab5 clear all ;6 close all ;7 clc ;8 % ****************************************************************************9 % **************** IMPOSTAZIONE CARATTERISTICHE DEL MODEM ****************

10 % ****************************************************************************11 prompt = ’Frequenza di clock :’,


12 ’Symbol Rate :’,13 ’N di bit dopo la virgola :’14 ’Eb/No (dB)’ ;15 title = ’Impostazione della simulazione Modem QPSK’;16 def = ’40’, ’40/3’, ’11’, ’6’;17 answer = inputdlg(prompt, title, 1, def) ;18 f_clk = str2double(answer(1))*10^6;19 symbol_rate = eval( char(answer(2)) )*10^6;20 n_bit_dopo_virgola = str2double(answer(3));21 EbNo_dB = str2double(answer(4));22 EbNo = 10^(EbNo_dB/10);23 % viene determinato il valore dell ’ interpolazione24 SpS = f_clk / symbol_rate ;25 % selezione del file sorgente tra quello prodotto dalla simulazione semplice e26 % quello della back - annotata27 file_simulazione = questdlg(’Selezionare il nome del file sorgente VHDL :’,...28 ’Selezione simulazione back-annotata o semplice’, ...29 ’data_out_QPSK_modulator.dat’,’TB_data_out_QPSK_modulator.dat’,...30 ’data_out_QPSK_modulator.dat’);3132 % ****************************************************************************33 % ********************* MODEM QPSK MATLAB DI RIFERIMENTO *********************34 % ****************************************************************************35 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% MODULAZIONE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%36 % carica da file i coefficienti del filtro polifase37 fid = fopen( strcat(’SRRCx’, num2str(SpS), ’_FreqSampl_scaled.dat’),’r’);38 num_fir = fscanf(fid,’%f’) ;39 num_fir = num_fir’ ;40 fclose(fid) ;41 % carica da file la sequenza randomica da modulare42 fid = fopen(’bit_tx.dat’ , ’r’) ;43 bit_tx = fscanf(fid,’%f’) ;44 fclose(fid) ;45 n_bits_tx = length(bit_tx) ;46 % viene creato il vettore dei bit pari e quello dei bit dispari47 bit_tx_I = bit_tx(1 : 2 : n_bits_tx) ;48 bit_tx_Q = bit_tx(2 : 2 : n_bits_tx) ;49 % si passa dalla codifica RZ alla codifica NRZ50 data_in_SRRCxN_tx_I_Matlab = -2*bit_tx_I + 1 ;51 data_in_SRRCxN_tx_Q_Matlab = -2*bit_tx_Q + 1 ;52 % applica il filtraggio polifase Matlab53 data_out_SRRCxN_tx_I_Matlab = applica_polifase(data_in_SRRCxN_tx_I_Matlab,...54 SpS , num_fir);55 data_out_SRRCxN_tx_Q_Matlab = applica_polifase(data_in_SRRCxN_tx_Q_Matlab,...56 SpS , num_fir);57 % Vengono generati i campioni di seno e coseno considerando f_IF = f_clk / 458 % n di campioni da generare per le portanti59 n_sample = length(data_out_SRRCxN_tx_I_Matlab);60 % periodo di campionamento61 t_clk = 1 / f_clk ;62 % istanti di campionamento63 t = 0 : t_clk : (n_sample-1)*t_clk ;64 % incrementi di fase65 theta = 2*pi*(f_clk/4)*t ;66 % generazione di un coseno67 coseno = [cos(theta)] ;68 % generazione di un seno69 seno = [sin(theta)] ;7071 data_out_QPSK_Mod_Matlab = [coseno .* data_out_SRRCxN_tx_I_Matlab] - ...72 [seno .* data_out_SRRCxN_tx_Q_Matlab] ;73 % spettro del segnale QPSK modulato tramite Matlab74 [Pyy_Mod_Matlab , f_out] = pwelch(data_out_QPSK_Mod_Matlab, [] , [] , ...75 ’onesided’, length(data_out_QPSK_Mod_Matlab) - 1 , f_clk) ;76 Pyy_Mod_Matlab_dB = 10*log10(Pyy_Mod_Matlab) ;77 figure ; plot(f_out , Pyy_Mod_Matlab_dB - max(Pyy_Mod_Matlab_dB) );78 grid ; xlim([0 f_clk/2]) ; ylim([-60 0]);79 legend([’Out QPSK Modem Matlab ’ , num2str(2*symbol_rate/1e6) , ’ MbpS’], 3);80 xlabel(’Frequency (Hz)’); ylabel(’dB / Hz’);8182 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% EFFETTO DEL CANALE %%%%%%%%%%%%%%%%%%%%%%%%%%%83 data_in_QPSK_DeMod_Matlab = awgn(data_out_QPSK_Mod_Matlab, ...84 EbNo_dB + 10*log10(2) -10*log10(0.5.*SpS), ’measured’, [], ’dB’);85 % viene calcolata e plottata la densita spettrale di potenza del segnale86 % QPSK affetto da rumore87 [Pyy_DeMod_in_Matlab , f_out] = pwelch(data_in_QPSK_DeMod_Matlab,[],[], ...88 ’onesided’, length(data_in_QPSK_DeMod_Matlab) - 1 , f_clk) ;89 Pyy_DeMod_in_Matlab_dB = 10*log10(Pyy_DeMod_in_Matlab) ;90 figure ; plot(f_out, Pyy_DeMod_in_Matlab_dB - max(Pyy_DeMod_in_Matlab_dB));91 grid ; xlim([0 f_clk/2]);92 legend([’In QPSK DeMod Matlab ’ , num2str(2*symbol_rate/1e6) , ’ MbpS’], 3);93 xlabel(’Frequency (Hz)’); ylabel(’dB / Hz’);9495 %%%%%%%%%%%%%%%%%%%%%%%%%%%%% DEMODULAZIONE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%96 % il segnale in banda traslata viene suddiviso nelle componenti in banda base97 data_in_SRRCxN_rx_I_Matlab = coseno .* data_in_QPSK_DeMod_Matlab ;98 data_in_SRRCxN_rx_Q_Matlab = -seno .* data_in_QPSK_DeMod_Matlab ;99 % applico il filtro adattato ad entrambe le componenti

100 data_out_SRRCxN_rx_I_Matlab = filter(num_fir, 1 , data_in_SRRCxN_rx_I_Matlab);101 data_out_SRRCxN_rx_Q_Matlab = filter(num_fir, 1 , data_in_SRRCxN_rx_Q_Matlab);


102 % diagramma ad occhio della sequenza I ricevuta103 eyediagram(data_out_SRRCxN_rx_I_Matlab(601:2400) , SpS , 1/symbol_rate , 2);104 data_I_Q_rx_Matlab = ...105 [data_out_SRRCxN_rx_I_Matlab’ data_out_SRRCxN_rx_Q_Matlab’];106 % scatterplot del segnale ricevuto107 scatterplot(data_I_Q_rx_Matlab , SpS , 2) ;108 % viene effettuato uno sfasamento , una decimazione ed applicato il decisore109 symbols_Matlab = demodmap(data_I_Q_rx_Matlab , [symbol_rate 1] , f_clk , ...110 ’qask’ , 4) ;111 % l ’ uscita del decisore viene convertita in formato NRZ112 for n = 1:length(symbols_Matlab)113 switch symbols_Matlab(n)114 case 0115 symbols_I_Matlab(n) = 1 ; symbols_Q_Matlab(n) = 1 ;116 case 1117 symbols_I_Matlab(n) = -1 ; symbols_Q_Matlab(n) = 1 ;118 case 2119 symbols_I_Matlab(n) = 1 ; symbols_Q_Matlab(n) = -1 ;120 case 3121 symbols_I_Matlab(n) = -1 ; symbols_Q_Matlab(n) = -1 ;122 end123 end124 % si passa dalla codifica NRZ alla codifica RZ125 bit_rx_I_Matlab = ( symbols_I_Matlab - 1) / (-2) ;126 bit_rx_Q_Matlab = ( symbols_Q_Matlab - 1) / (-2) ;127 % dai simboli si riottiene la sequenza composta da bit I e Q alternati128 bit_rx_Matlab = 4*ones(1 , n_bits_tx) ;129 bit_rx_Matlab(1 : 2 : n_bits_tx) = bit_rx_I_Matlab ;130 bit_rx_Matlab(2 : 2 : n_bits_tx) = bit_rx_Q_Matlab ;131 % viene compensato lo sfasamento tra la sequenza trasmessa e quella ricevuta132 N_bit_sfasamento_Matlab = 12 ;133 [n_bit_errati_Matlab BER_Matlab] = ...134 biterr(bit_tx(1:(n_bits_tx - N_bit_sfasamento_Matlab)), ...135 bit_rx_Matlab( (N_bit_sfasamento_Matlab + 1):n_bits_tx)’) ;136 disp([’ Risultati Modulatore Matlab -> Demodulatore Matlab ’]);137 disp([’N di bit di sfasamento : ’ num2str(N_bit_sfasamento_Matlab)]);138 disp([’N di bit errati : ’ num2str(n_bit_errati_Matlab)]);139 disp([’BER : ’ num2str(BER_Matlab)]);140 % viene calcolato il valore dello sfasamento per il quale si ha la minore BER141 for N_bit_sfasamento_Matlab = 1:1:15142 [n_bit_errati_Matlab(N_bit_sfasamento_Matlab) ...143 BER_Matlab(N_bit_sfasamento_Matlab)] = ...144 biterr(bit_tx(1:(n_bits_tx - N_bit_sfasamento_Matlab)) , ...145 bit_rx_Matlab( (N_bit_sfasamento_Matlab + 1):n_bits_tx)’);146 disp(’ ’);147 disp([’N di bit di sfasamento : ’ num2str(N_bit_sfasamento_Matlab)]);148 disp([’N di bit errati : ’ ...149 num2str(n_bit_errati_Matlab(N_bit_sfasamento_Matlab))]);150 disp([’BER : ’ ...151 num2str(BER_Matlab(N_bit_sfasamento_Matlab))]);152 end153 [ber_Matlab , N_bit_sfasamento_Matlab] = min(BER_Matlab) ;154 disp(’ ’);155 disp(’ ’);156 disp([’BER minima : ’ num2str(ber_Matlab)]);157 disp([’N di bit errati : ’ ...158 num2str(n_bit_errati_Matlab(N_bit_sfasamento_Matlab))]);159 disp([’Sfasamento : ’ num2str(N_bit_sfasamento_Matlab)]);160 % Visualizza il valore teorico per il BER161 theoretical_BER = 0.5 .* erfc(sqrt(EbNo)) ;162 disp(’ ’);163 disp([’BER teorico : ’ num2str(theoretical_BER)]);164 disp(’ ’);165166 % ****************************************************************************167 % ************** MODULATORE QPSK VHDL E DEMODULATORE MATLAB ******************168 % ****************************************************************************169 % carica da file la sequenza modulata tramite il VHDL170 fid = fopen(file_simulazione , ’r’) ;171 % viene scartato il primo numero che e un overflow172 string_unuseful = fscanf(fid, ’%s’ , 1);173 % vengono letti un numero di campioni pari a quelli del polifase Matlab174 data_out_QPSK_Mod_dec = fscanf(fid,’%f’, ...175 length(data_in_SRRCxN_tx_I_Matlab) * SpS);176 fclose(fid);177 data_out_QPSK_Mod_VHDL = data_out_QPSK_Mod_dec .* 2^(- n_bit_dopo_virgola);178 % viene prodotta una stringa da aggiungere alla label nel caso di simulazione179 % back - annotata180 if strcmp(file_simulazione , ’TB_data_out_QPSK_modulator.dat’)181 tipo_simulazione = ’B.A. ’ ;182 else183 tipo_simulazione = ’’ ;184 end185 % spettro del segnale QPSK modulato tramite il VHDL186 [Pyy_Mod_VHDL , f_out] = pwelch(data_out_QPSK_Mod_VHDL,[],[],’onesided’,...187 length(data_out_QPSK_Mod_VHDL) - 1 , f_clk) ;188 Pyy_Mod_VHDL_dB = 10*log10(Pyy_Mod_VHDL) ;189 figure ; plot(f_out , Pyy_Mod_VHDL_dB - max(Pyy_Mod_VHDL_dB) , ’-r’);190 grid ; xlim([0 f_clk/2]) ; ylim([-60 0]);191 legend([’Out QPSK Modem VHDL ’ , tipo_simulazione , ...


192 num2str(2*symbol_rate/1e6) , ’ MbpS’], 3);193 xlabel(’Frequency (Hz)’); ylabel(’dB / Hz’);194195 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% EFFETTO DEL CANALE %%%%%%%%%%%%%%%%%%%%%%%%%%%%196 data_in_QPSK_DeMod_VHDL = awgn(data_out_QPSK_Mod_VHDL, EbNo_dB +10*log10(2)...197 -10*log10(0.5.*SpS), ’measured’, [], ’dB’);198 % viene calcolata e plottata la densita spettrale di potenza del segnale QPSK199 % affetto da rumore200 [Pyy_DeMod_in_VHDL , f_out] = pwelch(data_in_QPSK_DeMod_VHDL, [] , [] , ...201 ’onesided’, length(data_in_QPSK_DeMod_VHDL) - 1 , f_clk) ;202 Pyy_DeMod_in_VHDL_dB = 10*log10(Pyy_DeMod_in_VHDL) ;203 figure ; plot(f_out , Pyy_DeMod_in_VHDL_dB-max(Pyy_DeMod_in_VHDL_dB),’-r’) ;204 grid ; xlim([0 f_clk/2]) ;205 legend([’In QPSK DeMod VHDL ’ , num2str(2*symbol_rate/1e6) , ’ MbpS’], 3) ;206 xlabel(’Frequency (Hz)’); ylabel(’dB / Hz’);207208 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% DEMODULAZIONE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%209 % PROCEDURA PER L ’ ALLINEAMENTO DEL DEMODULATORE :210 % Il demodulatore e suscettibile a tre variabili :211 % quadrante_iniziale , offset_demodmap , N_bit_sfasamento_VHDL212 % a ) togliere il commento dal ciclo FOR che itera su N_bit_sfasamento_VHDL213 % b ) assegnare quadrante_iniziale = 0214 % c ) far partire la simulazione , alla fine si ha il minimo BER e il215 % corrispondente N_bit_sfasamento_VHDL216 % d ) fare lo stesso variando per i valori 1, 2, 3 di quadrante_iniziale217 % e ) fissando il valore minimo per quadrante_iniziale e N_bit_sfasamento_VHDL218 % ricercare il minimo di offset_demodmap219220 % Vengono generati i campioni di seno e coseno considerando f_IF = f_clk / 4221 quadrante_iniziale = 1 ;222 % incrementi di fase223 theta_rx_VHDL = 2*pi*(f_clk/4)*t + quadrante_iniziale*pi/2 ;224 coseno_rx_VHDL = [cos(theta_rx_VHDL)] ; % generazione del coseno225 seno_rx_VHDL = [sin(theta_rx_VHDL)] ; % generazione del seno226 % il segnale in banda traslata viene suddiviso nelle componenti in banda base227 data_in_SRRCxN_rx_I_VHDL = coseno_rx_VHDL .* data_in_QPSK_DeMod_VHDL’ ;228 data_in_SRRCxN_rx_Q_VHDL = -seno_rx_VHDL .* data_in_QPSK_DeMod_VHDL’ ;229 % applico il filtro adattato ad entrambe le componenti230 data_out_SRRCxN_rx_I_VHDL = filter(num_fir, 1 , data_in_SRRCxN_rx_I_VHDL);231 data_out_SRRCxN_rx_Q_VHDL = filter(num_fir, 1 , data_in_SRRCxN_rx_Q_VHDL);232 % diagramma ad occhio della sequenza I ricevuta233 % eyediagram ( data_out_SRRCxN_rx_I_VHDL (601:2400) , SpS ,1/ symbol_rate ,3,’- r ’) ;234 data_I_Q_rx_VHDL = [data_out_SRRCxN_rx_I_VHDL’ data_out_SRRCxN_rx_Q_VHDL’];235 % scatterplot del segnale ricevuto236 % scatterplot ( data_I_Q_rx_VHDL , SpS , 3) ;237 % viene effettuato uno sfasamento , una decimazione ed applicato il decisore238 offset_demodmap = 1 ;239 symbols_VHDL = demodmap(data_I_Q_rx_VHDL , [symbol_rate offset_demodmap] ,...240 f_clk , ’qask’ , 4) ;241 % l ’ uscita del decisore viene convertita in formato NRZ242 for n = 1:length(symbols_VHDL)243 switch symbols_VHDL(n)244 case 0245 symbols_I_VHDL(n) = 1 ; symbols_Q_VHDL(n) = 1 ;246 case 1247 symbols_I_VHDL(n) = -1 ; symbols_Q_VHDL(n) = 1 ;248 case 2249 symbols_I_VHDL(n) = 1 ; symbols_Q_VHDL(n) = -1 ;250 case 3251 symbols_I_VHDL(n) = -1 ; symbols_Q_VHDL(n) = -1 ;252 end253 end254 % si passa dalla codifica NRZ alla codifica RZ255 bit_rx_I_VHDL = ( symbols_I_VHDL - 1) / (-2) ;256 bit_rx_Q_VHDL = ( symbols_Q_VHDL - 1) / (-2) ;257 % dai simboli si riottiene la sequenza composta da bit I e Q alternati258 bit_rx_VHDL = 4*ones(1 , n_bits_tx) ;259 bit_rx_VHDL(1 : 2 : n_bits_tx) = bit_rx_I_VHDL ;260 bit_rx_VHDL(2 : 2 : n_bits_tx) = bit_rx_Q_VHDL ;261 % viene compensato lo sfasamento tra la sequenza trasmessa e quella ricevuta262 N_bit_sfasamento_VHDL = 16 ;263 [n_bit_errati_VHDL BER_VHDL] = ...264 biterr(bit_tx(1:(n_bits_tx - N_bit_sfasamento_VHDL)) , ...265 bit_rx_VHDL( (N_bit_sfasamento_VHDL + 1):n_bits_tx)’) ;266 disp([’ Risultati Modulatore VHDL -> Demodulatore Matlab ’]);267 disp([’N di bit di sfasamento : ’ num2str(N_bit_sfasamento_VHDL)]);268 disp([’N di bit errati : ’ num2str(n_bit_errati_VHDL)]);269 disp([’BER : ’ num2str(BER_VHDL)]);270 % viene calcolato il valore dello sfasamento per il quale si ha la minore BER271 for N_bit_sfasamento_VHDL = 1:1:30272 [n_bit_errati_VHDL(N_bit_sfasamento_VHDL) BER_VHDL(N_bit_sfasamento_VHDL)]...273 = biterr(bit_tx(1:(n_bits_tx - N_bit_sfasamento_VHDL)) , ...274 bit_rx_VHDL( (N_bit_sfasamento_VHDL + 1):n_bits_tx)’);275 disp(’ ’);276 disp([’N di bit di sfasamento : ’ num2str(N_bit_sfasamento_VHDL)]);277 disp([’N di bit errati : ’ ...278 num2str(n_bit_errati_VHDL(N_bit_sfasamento_VHDL))]);279 disp([’BER : ’ num2str(BER_VHDL(N_bit_sfasamento_VHDL))]);280 end281 [ber_VHDL , N_bit_sfasamento_VHDL] = min(BER_VHDL) ;


282 disp(’ ’);283 disp(’ ’);284 disp([’BER minima : ’num2str(ber_VHDL)]);285 disp([’N di bit errati : ’num2str(n_bit_errati_VHDL(N_bit_sfasamento_VHDL))]);286 disp([’Sfasamento : ’num2str(N_bit_sfasamento_VHDL)]);287 % Visualizza il valore teorico per il BER288 theoretical_BER = 0.5 .* erfc(sqrt(EbNo)) ;289 disp(’ ’);290 disp([’BER teorico : ’ num2str(theoretical_BER)]);291 disp(’ ’);292293 % ****************************************************************************294 % *************************** CONFRONTO MODULATORI *************************295 % ****************************************************************************296 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% CONFRONTO SPETTRALE %%%%%%%%%%%%%%%%%%%%%%%%%%297 % visualizzazione contemporanea dei due spettri298 figure ; plot(f_out , Pyy_Mod_Matlab_dB - max(Pyy_Mod_Matlab_dB),...299 ’-b’ , f_out , Pyy_Mod_VHDL_dB - max(Pyy_Mod_VHDL_dB) , ’-r’);300 grid ; xlim([0 f_clk/2]) ; ylim([-60 0]);301 legend([’Out QPSK Modem Matlab ’ , num2str(2*symbol_rate/1e6) , ’ MbpS’ ],...302 [’Out QPSK Modem VHDL ’,tipo_simulazione,num2str(2*symbol_rate/1e6),...303 ’ MbpS’ ] , 3);304 xlabel(’Frequency (Hz)’); ylabel(’dB / Hz’);305 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% CONFRONTO TEMPORALE %%%%%%%%%%%%%%%%%%%%%%%%%%306 % n_bits = 1000;307 % N_bit_sfasamento = 7 ;308 % [ data_out_QPSK_Mod_Matlab (1:( n_bits - N_bit_sfasamento ) ) ’ , ...309 % data_out_QPSK_Mod_VHDL (( N_bit_sfasamento +1) : n_bits ) ]


vedi listato(E.3.2)

Test FPGA

Listato E.4.6: QPSKModemPSDFPGAvsPSDMatlab.m1 % DESCRIPTION : Confronta lo spettro della sequenza modulata tramite il VHDL2 % con quello della sequenza modulata tramite Matlab34 % Pulizia ambiente Matlab5 clear all ;6 close all ;7 clc ;8 % ************** IMPOSTAZIONE CARATTERISTICHE DEL MODULATORE *************9 % vengono impostate le caratteristiche del modulatore

10 prompt = ’Frequenza di clock :’,11 ’Symbol Rate :’,12 ’N di bit dopo la virgola :’,13 ’N di campioni da considerare :’;14 title = ’Caratteristiche del modulatore’;15 def = ’40’, ’40/3’, ’11’,’18000’;16 answer = inputdlg(prompt, title, 1, def) ;17 f_clk = str2double(answer(1))*10^6;18 symbol_rate = eval( char(answer(2)) )*10^6;19 n_bit_dopo_virgola = str2double(answer(3));20 n_values = str2double(answer(4));21 % viene determinato il valore dell ’ interpolazione22 SpS = f_clk / symbol_rate ;2324 % ********* VIENE APPLICATA LA MODULAZIONE QPSK MATLAB DI RIFERIMENTO ******25 % carica da file la sequenza dei dati da filtrare sul ramo I26 fid = fopen(’data_in_SRRCxN_tx_I_nrz.dat’ , ’r’) ;27 data_in_SRRCxN_tx_I = fscanf(fid,’%f’) ;28 fclose(fid) ;29 % carica da file la sequenza dei dati da filtrare sul ramo Q30 fid = fopen(’data_in_SRRCxN_tx_Q_nrz.dat’ , ’r’) ;31 data_in_SRRCxN_tx_Q = fscanf(fid,’%f’) ;32 fclose(fid) ;


33 % carica da file i coefficienti del filtro polifase34 fid = fopen( strcat(’SRRCx’, num2str(SpS), ’_FreqSampl_scaled.dat’),’r’);35 num_fir = fscanf(fid,’%f’) ;36 num_fir = num_fir’ ;37 fclose(fid) ;38 % applica il filtraggio polifase Matlab39 data_out_SRRCxN_tx_I = applica_polifase(data_in_SRRCxN_tx_I, SpS , num_fir);40 data_out_SRRCxN_tx_Q = applica_polifase(data_in_SRRCxN_tx_Q, SpS , num_fir);41 % Vengono generati i campioni di seno e coseno considerando che f_IF = f_clk /442 % n di campioni da generare per le portanti43 n_sample = length(data_out_SRRCxN_tx_I) ;44 % periodo di campionamento45 t_clk = 1 / f_clk ;46 % istanti di campionamento47 t = 0 : t_clk : (n_sample-1)*t_clk ;48 % incrementi di fase per generare 41.25 MHz49 theta = 2*pi*(f_clk/4)*t ;50 % generazione del coseno51 coseno = [cos(theta)] ;52 % generazione del seno53 seno = [sin(theta)] ;54 data_out_QPSK_modulator = [coseno .* data_out_SRRCxN_tx_I] - ...55 [seno .* data_out_SRRCxN_tx_Q] ;56 % viene calcolata e plottata la densita spettrale di potenza57 [Pyy_Matlab , f_out] = pwelch(data_out_QPSK_modulator, [] , [] , ...58 ’onesided’, length(data_out_QPSK_modulator) - 1 , f_clk) ;59 Pyy_dB_Matlab = 10*log10(Pyy_Matlab) ;60 figure ; plot(f_out , Pyy_dB_Matlab - max(Pyy_dB_Matlab) );61 grid ; xlim([0 f_clk/2]) ; ylim([-60 0]);62 legend([’Out QPSK Modem Matlab ’ , num2str(2*symbol_rate/1e6) , ’ MbpS’], 3);63 xlabel(’Frequency (Hz)’); ylabel(’dB / Hz’);6465 % **************** VIENE APPLICATA LA MODULAZIONE QPSK VHDL **************66 % ************ ELABORAZIONE DELLA SEQUENZA FILTRATA DALL ’ FPGA ************67 % carica la sequenza proveniente dall ’ analizzatore di stati logici68 fid = fopen(’file_out.txt’ , ’r’);69 % vengono scartate le prime 7 stringhe70 string_unuseful = fscanf(fid, ’%s’ , 7);71 % viene prelevata la stringa che indica il formato72 formato = fscanf(fid, ’%s’ , 1) ;73 % viene scartata una stringa con tutti -74 string_unuseful = fscanf(fid, ’%s’ , 1);75 % i dati vengono letti dal file nel giusto formato76 switch(formato)77 case ’Hex’,78 value_int_C2 = fscanf(fid, ’%x’ , n_values) ;79 case ’Decimal’,80 value_int_C2 = fscanf(fid, ’%f’ , n_values) ;81 end82 fclose(fid) ;83 % converte l ’ intero unsigned in complemento a due in un intero con segno84 value_int = zeros(n_values,1);85 for i = 1 : 1 : n_values86 if bitget( value_int_C2(i) , 12) == 1 % valore negativo87 % x_C2 = 2^ N - | x |88 value_int(i) = -( 2^(n_bit_dopo_virgola+1) - value_int_C2(i) );89 else % coefficiente positivo90 value_int(i) = value_int_C2(i) ; % x_C2 = | x |91 end92 end93 % converte da intero con segno a numero reale con segno94 value_real = value_int .* 2^(- n_bit_dopo_virgola);95 data_out_QPSK_modulator_FPGA = value_real ;96 % viene calcolato lo spettro della sequenza modulata dal VHDL97 [Pyy_FPGA , f_out] = pwelch(data_out_QPSK_modulator_FPGA, [] , [] , ...98 ’onesided’, length(data_out_QPSK_modulator_FPGA) - 1 , f_clk) ;99 Pyy_dB_FPGA = 10*log10(Pyy_FPGA) ;

100 figure ; plot(f_out , Pyy_dB_FPGA - max(Pyy_dB_FPGA) , ’-r’) ;101 grid ; xlim([0 f_clk/2]) ; ylim([-60 0]) ;102 legend([’Out QPSK Modem FPGA ’ , num2str(symbol_rate*2/1e6) , ’ MbpS’], 3) ;103 xlabel(’Frequency (Hz)’); ylabel(’dB / Hz’);104105 % *************************** CONFRONTO SPETTRALE *************************106 % visualizzazione contemporanea dei due spettri107 figure ; plot(f_out , Pyy_dB_Matlab - max(Pyy_dB_Matlab),’-b’,...108 f_out , Pyy_dB_FPGA - max(Pyy_dB_FPGA) , ’-r’);109 grid ; xlim([0 f_clk/2]) ; ylim([-60 0]);110 legend([’Out QPSK Modem Matlab ’ , num2str(symbol_rate*2/1e6) , ’ MbpS’ ] , ...111 [’Out QPSK Modem FPGA ’ , num2str(symbol_rate*2/1e6) , ’ MbpS’ ] , 3);112 xlabel(’Frequency (Hz)’); ylabel(’dB / Hz’);113 % **************************** CONFRONTO TEMPORALE ************************114 % n_bits = length ( data_out_QPSK_modulator ) ;115 % n_bits = 12000;116 % N_bit_sfasamento = 0 ;117 % [ data_out_QPSK_modulator (1:( n_bits - N_bit_sfasamento ) ) ’ , ...118 % data_out_QPSK_modulator_FPGA (( N_bit_sfasamento +1) : n_bits ) ]



vedi listato(E.3.2)

Appendice F

Listati VHDL

Listato F.1.1: nco.vhd1 library IEEE;2 use IEEE.std_logic_1164.all;34 entity NCO is5 port(6 clear : in STD_LOGIC;7 clk : in STD_LOGIC;8 load : in STD_LOGIC;9 freq_word : in STD_LOGIC_VECTOR (31 downto 0);

10 coseno : out STD_LOGIC_VECTOR (11 downto 0);11 seno : out STD_LOGIC_VECTOR (11 downto 0)12 );13 end NCO;1415 architecture NCO of NCO is16 ---- Signal declarations used on the diagram ----17 signal COS : STD_LOGIC_VECTOR (11 downto 0);18 signal CTRL : STD_LOGIC_VECTOR (1 downto 0);19 signal CTRL_SEGNO_SENO : STD_LOGIC ;20 signal FASE : STD_LOGIC_VECTOR (12 downto 0);21 signal SIN : STD_LOGIC_VECTOR (11 downto 0);22 signal THETA : STD_LOGIC_VECTOR (31 downto 0);23 signal THETA_TR : STD_LOGIC_VECTOR (12 downto 0);24 ---- Component declarations -----25 component ACCUMULATOR26 port (27 clear : in STD_LOGIC;28 clk : in STD_LOGIC;29 freq_word : in STD_LOGIC_VECTOR (31 downto 0);30 load : in STD_LOGIC;31 theta : inout STD_LOGIC_VECTOR (31 downto 0)32 );33 end component ;34 component CORDIC_PIPELINED_UNROLLED35 port (36 clk : in STD_LOGIC;37 fase : in STD_LOGIC_VECTOR (12 downto 0);38 coseno : out STD_LOGIC_VECTOR (11 downto 0);39 seno : out STD_LOGIC_VECTOR (11 downto 0)40 );41 end component ;42 component COSINE_REBUILD43 port (44 ctrl : in STD_LOGIC_VECTOR (1 downto 0);45 in_cosine_rebuild : in STD_LOGIC_VECTOR (11 downto 0);46 out_cosine_rebuild : out STD_LOGIC_VECTOR (11 downto 0)47 );48 end component ;49 component DELAY_1350 port (51 clk : in STD_LOGIC;52 in_delay_13 : in STD_LOGIC;53 out_delay_13 : out STD_LOGIC54 );55 end component ;56 component SINE_REBUILD57 port (58 ctrl : in STD_LOGIC;59 in_sine_rebuild : in STD_LOGIC_VECTOR (11 downto 0);60 out_sine_rebuild : out STD_LOGIC_VECTOR (11 downto 0)61 );

115

APPENDICE F. LISTATI VHDL 116

62 end component ;63 component TO_FIRST_QUADRANT64 port (65 in_tfq : in STD_LOGIC_VECTOR (12 downto 0);66 out_tfq : out STD_LOGIC_VECTOR (12 downto 0)67 );68 end component ;69 component TRONCATORE_1270 port (71 ingresso : in STD_LOGIC_VECTOR (31 downto 0);72 uscita : out STD_LOGIC_VECTOR (12 downto 0)73 );74 end component ;7576 begin77 ---- Component instantiations ----78 U0 : CORDIC_PIPELINED_UNROLLED79 port map(80 clk => clk,81 coseno => cos,82 fase => fase,83 seno => sin84 );85 U1 : DELAY_1386 port map(87 clk => clk,88 in_delay_13 => Theta_tr(11),89 out_delay_13 => ctrl(0)90 );91 U2 : DELAY_1392 port map(93 clk => clk,94 in_delay_13 => Theta_tr(12),95 out_delay_13 => ctrl(1)96 );97 U3 : DELAY_1398 port map(99 clk => clk,

100 in_delay_13 => Theta_tr(12),101 out_delay_13 => ctrl_segno_seno102 );103 U5 : TRONCATORE_12104 port map(105 ingresso => Theta,106 uscita => Theta_tr107 );108 U4 : ACCUMULATOR109 port map(110 clear => clear,111 clk => clk,112 freq_word => freq_word,113 load => load,114 theta => Theta115 );116 U6 : TO_FIRST_QUADRANT117 port map(118 in_tfq => Theta_tr,119 out_tfq => fase120 );121 U8 : COSINE_REBUILD122 port map(123 ctrl => ctrl,124 in_cosine_rebuild => cos,125 out_cosine_rebuild => coseno126 );127 U7 : SINE_REBUILD128 port map(129 ctrl => ctrl_segno_seno,130 in_sine_rebuild => sin,131 out_sine_rebuild => seno132 );133 end NCO;

Listato F.1.2: accumulator.vhd1 library ieee;2 use ieee.std_logic_1164.all;3 use ieee.std_logic_arith.all;4 use ieee.std_logic_signed.all;56 entity accumulator is7 port ( freq_word : in std_logic_vector(31 downto 0);8 clk, load, clear : in std_logic;9 theta : inout std_logic_vector(31 downto 0)

10 );11 end accumulator;1213 architecture acc_arch of accumulator is


14 signal reg_theta : std_logic_vector(31 downto 0);15 begin16 process(load, clear, freq_word, theta)17 begin18 if load=’1’ then19 reg_theta <= freq_word;20 else if clear=’1’ then21 reg_theta <= "00000000000000000000000000000000";22 else23 reg_theta <= freq_word + theta;24 end if;25 end if;26 end process;2728 process(clk)29 begin30 if clk’event and clk=’1’ then31 theta <= reg_theta;32 end if;33 end process;34 end acc_arch;

Listato F.1.3: cordic pipelined unrolled.vhd1 library IEEE;2 use IEEE.std_logic_1164.all;34 entity cordic_pipelined_unrolled is5 port(6 clk : in STD_LOGIC;7 fase : in STD_LOGIC_VECTOR (12 downto 0);8 coseno : out STD_LOGIC_VECTOR (11 downto 0);9 seno : out STD_LOGIC_VECTOR (11 downto 0)

10 );11 end cordic_pipelined_unrolled;1213 architecture CORDIC_PIPELINED_UNROLLED of cordic_pipelined_unrolled is14 signal A_0 : STD_LOGIC_VECTOR (12 downto 0);15 signal A_1 : STD_LOGIC_VECTOR (12 downto 0);16 signal A_10 : STD_LOGIC_VECTOR (12 downto 0);17 signal A_11 : STD_LOGIC_VECTOR (12 downto 0);18 signal A_12 : STD_LOGIC_VECTOR (12 downto 0);19 signal A_2 : STD_LOGIC_VECTOR (12 downto 0);20 signal A_3 : STD_LOGIC_VECTOR (12 downto 0);21 signal A_4 : STD_LOGIC_VECTOR (12 downto 0);22 signal A_5 : STD_LOGIC_VECTOR (12 downto 0);23 signal A_6 : STD_LOGIC_VECTOR (12 downto 0);24 signal A_7 : STD_LOGIC_VECTOR (12 downto 0);25 signal A_8 : STD_LOGIC_VECTOR (12 downto 0);26 signal A_9 : STD_LOGIC_VECTOR (12 downto 0);27 signal X0 : STD_LOGIC_VECTOR (11 downto 0);28 signal X1 : STD_LOGIC_VECTOR (11 downto 0);29 signal X10 : STD_LOGIC_VECTOR (11 downto 0);30 signal X11 : STD_LOGIC_VECTOR (11 downto 0);31 signal X12 : STD_LOGIC_VECTOR (11 downto 0);32 signal X13 : STD_LOGIC_VECTOR (11 downto 0);33 signal X2 : STD_LOGIC_VECTOR (11 downto 0);34 signal X3 : STD_LOGIC_VECTOR (11 downto 0);35 signal X4 : STD_LOGIC_VECTOR (11 downto 0);36 signal X5 : STD_LOGIC_VECTOR (11 downto 0);37 signal X6 : STD_LOGIC_VECTOR (11 downto 0);38 signal X7 : STD_LOGIC_VECTOR (11 downto 0);39 signal X8 : STD_LOGIC_VECTOR (11 downto 0);40 signal X9 : STD_LOGIC_VECTOR (11 downto 0);41 signal Y0 : STD_LOGIC_VECTOR (11 downto 0);42 signal Y1 : STD_LOGIC_VECTOR (11 downto 0);43 signal Y10 : STD_LOGIC_VECTOR (11 downto 0);44 signal Y11 : STD_LOGIC_VECTOR (11 downto 0);45 signal Y12 : STD_LOGIC_VECTOR (11 downto 0);46 signal Y13 : STD_LOGIC_VECTOR (11 downto 0);47 signal Y2 : STD_LOGIC_VECTOR (11 downto 0);48 signal Y3 : STD_LOGIC_VECTOR (11 downto 0);49 signal Y4 : STD_LOGIC_VECTOR (11 downto 0);50 signal Y5 : STD_LOGIC_VECTOR (11 downto 0);51 signal Y6 : STD_LOGIC_VECTOR (11 downto 0);52 signal Y7 : STD_LOGIC_VECTOR (11 downto 0);53 signal Y8 : STD_LOGIC_VECTOR (11 downto 0);54 signal Y9 : STD_LOGIC_VECTOR (11 downto 0);55 signal Z0 : STD_LOGIC_VECTOR (12 downto 0);56 signal Z1 : STD_LOGIC_VECTOR (12 downto 0);57 signal Z10 : STD_LOGIC_VECTOR (12 downto 0);58 signal Z11 : STD_LOGIC_VECTOR (12 downto 0);59 signal Z12 : STD_LOGIC_VECTOR (12 downto 0);60 signal Z2 : STD_LOGIC_VECTOR (12 downto 0);61 signal Z3 : STD_LOGIC_VECTOR (12 downto 0);62 signal Z4 : STD_LOGIC_VECTOR (12 downto 0);


63 signal Z5 : STD_LOGIC_VECTOR (12 downto 0);64 signal Z6 : STD_LOGIC_VECTOR (12 downto 0);65 signal Z7 : STD_LOGIC_VECTOR (12 downto 0);66 signal Z8 : STD_LOGIC_VECTOR (12 downto 0);67 signal Z9 : STD_LOGIC_VECTOR (12 downto 0);68 ---- Component declarations -----69 component CORDIC_BASE_J70 generic( n : INTEGER );71 port (72 a_cost_j : in STD_LOGIC_VECTOR (12 downto 0);73 clk : in STD_LOGIC;74 in_x : in STD_LOGIC_VECTOR (11 downto 0);75 in_y : in STD_LOGIC_VECTOR (11 downto 0);76 in_z : in STD_LOGIC_VECTOR (12 downto 0);77 coseno : out STD_LOGIC_VECTOR (11 downto 0);78 fase_j : out STD_LOGIC_VECTOR (12 downto 0);79 seno : out STD_LOGIC_VECTOR (11 downto 0)80 );81 end component ;8283 begin84 x0 <= "010011011100" ;85 y0 <= "000000000000" ;86 a_0 <= "0010000000000" ;87 a_1 <= "0001001011100" ;88 a_2 <= "0000100111111" ;89 a_3 <= "0000010100010" ;90 a_4 <= "0000001010001" ;91 a_5 <= "0000000101000" ;92 a_6 <= "0000000010100" ;93 a_7 <= "0000000001010" ;94 a_8 <= "0000000000101" ;95 a_9 <= "0000000000010" ;96 a_10 <= "0000000000001" ;97 a_11 <= "0000000000000" ;98 a_12 <= "0000000000000" ;99 ---- Component instantiations ----

100 U0 : CORDIC_BASE_J101 generic map ( n => 0 )102 port map(103 a_cost_j => a_0,104 clk => clk,105 coseno => x1,106 fase_j => z1,107 in_x => x0,108 in_y => y0,109 in_z => z0,110 seno => y1111 );112 U1 : CORDIC_BASE_J113 generic map ( n => 1 )114 port map(115 a_cost_j => a_1,116 clk => clk,117 coseno => x2,118 fase_j => z2,119 in_x => x1,120 in_y => y1,121 in_z => z1,122 seno => y2123 );124 U2 : CORDIC_BASE_J125 generic map ( n => 2 )126 port map(127 a_cost_j => a_2,128 clk => clk,129 coseno => x3,130 fase_j => z3,131 in_x => x2,132 in_y => y2,133 in_z => z2,134 seno => y3135 );136 U3 : CORDIC_BASE_J137 generic map ( n => 3 )138 port map(139 a_cost_j => a_3,140 clk => clk,141 coseno => x4,142 fase_j => z4,143 in_x => x3,144 in_y => y3,145 in_z => z3,146 seno => y4147 );148 U4 : CORDIC_BASE_J149 generic map ( n => 4 )150 port map(151 a_cost_j => a_4,152 clk => clk,153 coseno => x5,154 fase_j => z5,155 in_x => x4,156 in_y => y4,157 in_z => z4,


158 seno => y5159 );160 U5 : CORDIC_BASE_J161 generic map ( n => 5 )162 port map(163 a_cost_j => a_5,164 clk => clk,165 coseno => x6,166 fase_j => z6,167 in_x => x5,168 in_y => y5,169 in_z => z5,170 seno => y6171 );172 U6 : CORDIC_BASE_J173 generic map ( n => 6 )174 port map(175 a_cost_j => a_6,176 clk => clk,177 coseno => x7,178 fase_j => z7,179 in_x => x6,180 in_y => y6,181 in_z => z6,182 seno => y7183 );184 U7 : CORDIC_BASE_J185 generic map ( n => 7 )186 port map(187 a_cost_j => a_7,188 clk => clk,189 coseno => x8,190 fase_j => z8,191 in_x => x7,192 in_y => y7,193 in_z => z7,194 seno => y8195 );196 U8 : CORDIC_BASE_J197 generic map ( n => 8 )198 port map(199 a_cost_j => a_8,200 clk => clk,201 coseno => x9,202 fase_j => z9,203 in_x => x8,204 in_y => y8,205 in_z => z8,206 seno => y9207 );208 U9 : CORDIC_BASE_J209 generic map ( n => 9 )210 port map(211 a_cost_j => a_9,212 clk => clk,213 coseno => x10,214 fase_j => z10,215 in_x => x9,216 in_y => y9,217 in_z => z9,218 seno => y10219 );220 U10 : CORDIC_BASE_J221 generic map ( n => 10 )222 port map(223 a_cost_j => a_10,224 clk => clk,225 coseno => x11,226 fase_j => z11,227 in_x => x10,228 in_y => y10,229 in_z => z10,230 seno => y11231 );232 U11 : CORDIC_BASE_J233 generic map ( n => 11 )234 port map(235 a_cost_j => a_11,236 clk => clk,237 coseno => x12,238 fase_j => z12,239 in_x => x11,240 in_y => y11,241 in_z => z11,242 seno => y12243 );244 U12 : CORDIC_BASE_J245 generic map ( n => 12 )246 port map(247 a_cost_j => a_12,248 clk => clk,249 coseno => x13,250 in_x => x12,251 in_y => y12,252 in_z => z12,


253 seno => y13254 );255 z0 <= FASE;256 COSENO <= x13;257 SENO <= y13;258 end CORDIC_PIPELINED_UNROLLED;

Listato F.1.4: cordic base j.vhd1 library IEEE;2 use IEEE.std_logic_1164.all;34 entity cordic_base_j is5 generic( n : integer );6 port(7 clk : in STD_LOGIC;8 a_cost_j : in STD_LOGIC_VECTOR (12 downto 0);9 in_x : in STD_LOGIC_VECTOR (11 downto 0);

10 in_y : in STD_LOGIC_VECTOR (11 downto 0);11 in_z : in STD_LOGIC_VECTOR (12 downto 0);12 coseno : out STD_LOGIC_VECTOR (11 downto 0);13 fase_j : out STD_LOGIC_VECTOR (12 downto 0);14 seno : out STD_LOGIC_VECTOR (11 downto 0)15 );16 end cordic_base_j;1718 architecture CORDIC_BASE_J of cordic_base_j is19 signal SGN : STD_LOGIC ;20 signal SHIFTER_TO_ADDER_X : STD_LOGIC_VECTOR (11 downto 0);21 signal SHIFTER_TO_ADDER_Y : STD_LOGIC_VECTOR (11 downto 0);22 signal X_OUT_REG : STD_LOGIC_VECTOR (11 downto 0);23 signal Y_OUT_REG : STD_LOGIC_VECTOR (11 downto 0);24 signal Z_OUT_REG : STD_LOGIC_VECTOR (12 downto 0);25 component ADDER_1226 port (27 in_a : in STD_LOGIC_VECTOR (11 downto 0);28 in_b : in STD_LOGIC_VECTOR (11 downto 0);29 sgn : in STD_LOGIC;30 out_adder_12 : out STD_LOGIC_VECTOR (11 downto 0)31 );32 end component ;33 component ADDER_1334 port (35 in_a : in STD_LOGIC_VECTOR (12 downto 0);36 in_b : in STD_LOGIC_VECTOR (12 downto 0);37 sgn : in STD_LOGIC;38 out_adder_13 : out STD_LOGIC_VECTOR (12 downto 0)39 );40 end component ;41 component REG_1242 port (43 clk : in STD_LOGIC;44 in_reg_12 : in STD_LOGIC_VECTOR (11 downto 0);45 out_reg_12 : out STD_LOGIC_VECTOR (11 downto 0)46 );47 end component ;48 component REG_1349 port (50 clk : in STD_LOGIC;51 in_reg_13 : in STD_LOGIC_VECTOR (12 downto 0);52 out_reg_13 : out STD_LOGIC_VECTOR (12 downto 0)53 );54 end component ;55 component SHIFTER56 generic( n : INTEGER );57 port (58 in_shifter : in STD_LOGIC_VECTOR (11 downto 0);59 out_shifter : out STD_LOGIC_VECTOR (11 downto 0)60 );61 end component ;6263 begin64 sgn <= not(z_out_reg(12)) ;65 U0 : REG_1266 port map(67 clk => clk,68 in_reg_12 => in_x,69 out_reg_12 => x_out_reg70 );71 U1 : REG_1272 port map(73 clk => clk,74 in_reg_12 => in_y,75 out_reg_12 => y_out_reg76 );77 U2 : SHIFTER78 generic map ( n => n )


79 port map(80 in_shifter => x_out_reg,81 out_shifter => shifter_to_adder_y82 );83 U4 : ADDER_1284 port map(85 in_a => x_out_reg,86 in_b => shifter_to_adder_x,87 out_adder_12 => coseno,88 sgn => z_out_reg(12)89 );90 U5 : ADDER_1291 port map(92 in_a => y_out_reg,93 in_b => shifter_to_adder_y,94 out_adder_12 => seno,95 sgn => sgn96 );97 U7 : ADDER_1398 port map(99 in_a => z_out_reg,

100 in_b => a_cost_j,101 out_adder_13 => fase_j,102 sgn => z_out_reg(12)103 );104 U6 : REG_13105 port map(106 clk => clk,107 in_reg_13 => in_z,108 out_reg_13 => z_out_reg109 );110 U3 : SHIFTER111 generic map ( n => n )112 port map(113 in_shifter => y_out_reg,114 out_shifter => shifter_to_adder_x115 );116 end CORDIC_BASE_J;

Listato F.1.5: adder 12.vhd1 library ieee;2 use ieee.std_logic_1164.all;3 use ieee.std_logic_signed.all;45 entity adder_12 is6 port(in_a , in_b : in std_logic_vector(11 downto 0);7 sgn : in std_logic;8 out_adder_12 : out std_logic_vector(11 downto 0));9 end adder_12;

1011 architecture adder_12_arch of adder_12 is12 begin13 process(in_a , in_b , sgn)14 begin15 if sgn = ’0’ then16 out_adder_12 <= in_a - in_b ;17 else18 out_adder_12 <= in_a + in_b ;19 end if;20 end process;21 end adder_12_arch;

Listato F.1.6: adder 13.vhd1 library ieee;2 use ieee.std_logic_1164.all;3 use ieee.std_logic_signed.all;45 entity adder_13 is6 port(in_a , in_b : in std_logic_vector(12 downto 0);7 sgn : in std_logic;8 out_adder_13 : out std_logic_vector(12 downto 0));9 end adder_13;

1011 architecture adder_13_arch of adder_13 is12 begin13 process(in_a , in_b , sgn)14 begin15 if sgn = ’0’ then16 out_adder_13 <= in_a - in_b ;17 else18 out_adder_13 <= in_a + in_b ;19 end if;


20 end process;21 end adder_13_arch ;

Listato F.1.7: reg 12.vhd1 library ieee;2 use ieee.std_logic_1164.all;34 entity reg_12 is5 port( in_reg_12 : in std_logic_vector(11 downto 0);6 clk : in std_logic;7 out_reg_12 : out std_logic_vector(11 downto 0));8 end reg_12;9

10 architecture reg_12_arch of reg_12 is11 begin12 process(clk , in_reg_12)13 begin14 if rising_edge(clk) then15 out_reg_12 <= in_reg_12;16 end if;17 end process;18 end reg_12_arch ;

Listato F.1.8: reg 13.vhd1 library ieee;2 use ieee.std_logic_1164.all;34 entity reg_13 is5 port( in_reg_13 : in std_logic_vector(12 downto 0);6 clk : in std_logic;7 out_reg_13 : out std_logic_vector(12 downto 0)8 );9 end reg_13;

1011 architecture reg_13_arch of reg_13 is12 begin13 process(clk , in_reg_13)14 begin15 if rising_edge(clk) then16 out_reg_13 <= in_reg_13;17 end if;18 end process;19 end reg_13_arch ;

Listato F.1.9: shifter.vhd1 library ieee;2 use ieee.std_logic_1164.all;34 entity shifter is5 generic(n:integer);6 port( in_shifter : in std_logic_vector(11 downto 0);7 out_shifter : out std_logic_vector(11 downto 0));8 end shifter;9

10 architecture shifter_arch of shifter is11 begin12 process(in_shifter)13 variable i:integer;14 begin15 if n < 12 then16 out_shifter(11-n downto 0) <= in_shifter(11

downto n);17 for i in 11 downto (11-n) loop18 if in_shifter(11)=’0’ then19 out_shifter(11 downto 11-n) <= (

others=>’0’);20 else21 out_shifter(11 downto 11-n) <= (

others=>’1’);22 end if;23 end loop;24 else out_shifter <= "000000000000" ;25 end if;26 end process;


27 end shifter_arch ;

Listato F.1.10: cosine rebuild.vhd1 library ieee;2 use ieee.std_logic_1164.all;3 use ieee.std_logic_signed.all;45 entity cosine_rebuild is6 port( in_cosine_rebuild : in std_logic_vector(11 downto 0);7 ctrl : in std_logic_vector(1 downto 0);8 out_cosine_rebuild : out std_logic_vector(11 downto 0));9 end cosine_rebuild ;

1011 architecture cosine_rebuild_arch of cosine_rebuild is12 begin13 process(in_cosine_rebuild, ctrl)14 variable temp : std_logic_vector(11 downto 0);15 begin16 temp(11 downto 0) := in_cosine_rebuild ;17 case ctrl is18 when "00" => null ; -- primo quadrante19 when "01" => temp := ("111111111111" xor temp)+1; -- secondo

quadrante20 when "10" => temp := ("111111111111" xor temp)+1; -- terzo

quadrante21 when "11" => null ; -- quarto quadrante22 when others => temp := "000000000000" ;23 end case;24 out_cosine_rebuild(11 downto 0) <= temp(11 downto 0) ;25 end process;26 end cosine_rebuild_arch ;

Listato F.1.11: delay 13.vhd1 library IEEE;2 use IEEE.STD_LOGIC_1164.all;34 entity delay_13 is5 port (6 clk : in STD_LOGIC;7 in_delay_13 : in STD_LOGIC;8 out_delay_13 : out STD_LOGIC9 );

10 end delay_13;1112 architecture delay_13_arch of delay_13 is13 signal reg_int : STD_LOGIC_VECTOR(12 downto 0);14 begin15 process (clk)16 begin17 if clk’event and clk=’1’ then18 reg_int <= in_delay_13 & reg_int(12 downto 1);19 end if;20 end process;21 out_delay_13 <= reg_int(0);22 end delay_13_arch;

Listato F.1.12: sine rebuild.vhd1 library ieee;2 use ieee.std_logic_1164.all;3 use ieee.std_logic_signed.all;45 entity sine_rebuild is6 port( in_sine_rebuild : in std_logic_vector(11 downto 0);7 ctrl : in std_logic;8 out_sine_rebuild : out std_logic_vector(11 downto 0));9 end sine_rebuild ;

1011 architecture sine_rebuild_arch of sine_rebuild is12 begin13 process(in_sine_rebuild, ctrl)14 variable temp : std_logic_vector(11 downto 0);15 begin16 temp(11 downto 0) := in_sine_rebuild ;17 case ctrl is


18 when ’1’ => temp := ("111111111111" xor temp)+1 ;19 when ’0’ => null ;20 when others => temp := "000000000000" ;21 end case;22 out_sine_rebuild(11 downto 0) <= temp(11 downto 0) ;23 end process;24 end sine_rebuild_arch ;

Listato F.1.13: to first quadrant.vhd1 library ieee;2 use ieee.std_logic_1164.all;3 use ieee.std_logic_signed.all;45 entity to_first_quadrant is6 port( in_tfq : in std_logic_vector(12 downto 0);7 out_tfq : out std_logic_vector(12 downto 0));8 end to_first_quadrant;9

10 architecture to_first_quadrant_arch of to_first_quadrant is11 begin12 process(in_tfq)13 variable temp : std_logic_vector(10 downto 0);14 begin15 temp(10 downto 0) := in_tfq(10 downto 0) ;16 case in_tfq(11) is17 when ’1’ => temp := ("11111111111" xor temp)+1 ;18 when ’0’ => null ;19 when others => temp := "00000000000" ;20 end case;21 out_tfq(10 downto 0) <= temp(10 downto 0) ;22 out_tfq(12 downto 11) <= "00" ;23 end process;24 end to_first_quadrant_arch ;

Listato F.1.14: troncatore 12.vhd1 library ieee;2 use ieee.std_logic_1164.all;34 entity troncatore_12 is5 port( ingresso : in std_logic_vector(31 downto 0);6 uscita : out std_logic_vector(12 downto 0)7 );8 end troncatore_12;9

10 architecture tro_12_arch of troncatore_12 is11 begin12 process(ingresso)13 begin14 for i in 0 to 12 loop15 uscita(i) <= ingresso(i+19);16 end loop;17 end process;18 end tro_12_arch;

Listato F.2.1: polyphase gatedClock.vhd1 library IEEE;2 use IEEE.std_logic_1164.all;3 use work.SRRC_coeffs.all;45 entity polyphase_gatedClock is6 port(7 clk : in STD_LOGIC;8 reset : in STD_LOGIC;9 to_SRRC_I : in STD_LOGIC;

10 rate_sel : in STD_LOGIC_VECTOR(1 downto 0);11 clk_sync : out STD_LOGIC;12 poly_out : out STD_LOGIC_VECTOR(11 downto 0)13 );14 end polyphase_gatedClock;1516 architecture polyphase_gatedClock of polyphase_gatedClock is17 component rate_adapter18 port (19 clk : in STD_LOGIC;20 rate_sel : in STD_LOGIC_VECTOR(1 downto 0);


21 reset : in STD_LOGIC;22 clk_div_n : out STD_LOGIC;23 coeffs_to_SRRCxN : out coeffs;24 count_n : out STD_LOGIC_VECTOR(2 downto 0)25 );26 end component;27 component srrc_x_n28 port (29 SRRCxN_coeffs : in coeffs;30 clk : in STD_LOGIC;31 clk_div_n : in STD_LOGIC;32 count_n : in STD_LOGIC_VECTOR(2 downto 0);33 in_fir_MSB : in STD_LOGIC;34 reset : in STD_LOGIC;35 polyphase_out : out STD_LOGIC_VECTOR(11 downto 0)36 );37 end component;3839 signal clk_div_n : STD_LOGIC;40 signal coefficients : coeffs;41 signal count_n : STD_LOGIC_VECTOR (2 downto 0);4243 begin44 U1 : srrc_x_n45 port map(46 SRRCxN_coeffs => coefficients,47 clk => clk,48 clk_div_n => clk_div_n,49 count_n => count_n,50 in_fir_MSB => to_SRRC_I,51 polyphase_out => poly_out,52 reset => reset53 );54 U2 : rate_adapter55 port map(56 clk => clk,57 clk_div_n => clk_div_n,58 coeffs_to_SRRCxN => coefficients,59 count_n => count_n,60 rate_sel => rate_sel,61 reset => reset62 );63 clk_sync <= clk;64 end polyphase_gatedClock;

Listato F.2.2: srrc coeffs.vhd1 library ieee;2 use ieee.std_logic_1164.all;3 use ieee.std_logic_signed.all;45 package SRRC_coeffs is6 subtype coeff is std_logic_vector(11 downto 0);7 type coeffs is array(0 to 83) of coeff;8 end SRRC_coeffs ;

Listato F.2.3: rate adapter.vhd1 library IEEE;2 use IEEE.std_logic_1164.all;3 use work.SRRC_coeffs.all;45 entity rate_adapter is6 port(7 clk : in STD_LOGIC;8 reset : in STD_LOGIC;9 rate_sel : in STD_LOGIC_VECTOR(1 downto 0);

10 clk_div_n : out STD_LOGIC;11 coeffs_to_SRRCxN : out coeffs;12 count_n : out STD_LOGIC_VECTOR(2 downto 0)13 );14 end rate_adapter;1516 architecture rate_adapter of rate_adapter is17 component coeffs_selector18 port (19 rate_sel : in STD_LOGIC_VECTOR(1 downto 0);20 coeffs_SRRC : out coeffs21 );22 end component;23 component counter_divider_324 port (25 clk : in STD_LOGIC;26 reset : in STD_LOGIC;


27 clk_div_3 : out STD_LOGIC;28 count_3 : out STD_LOGIC_VECTOR(2 downto 0)29 );30 end component;31 component counter_divider_432 port (33 clk : in STD_LOGIC;34 reset : in STD_LOGIC;35 clk_div_4 : out STD_LOGIC;36 count_4 : out STD_LOGIC_VECTOR(2 downto 0)37 );38 end component;39 component counter_divider_640 port (41 clk : in STD_LOGIC;42 reset : in STD_LOGIC;43 clk_div_6 : out STD_LOGIC;44 count_6 : out STD_LOGIC_VECTOR(2 downto 0)45 );46 end component;47 component selector48 port (49 clk_div_3 : in STD_LOGIC;50 clk_div_4 : in STD_LOGIC;51 clk_div_6 : in STD_LOGIC;52 count_3 : in STD_LOGIC_VECTOR(2 downto 0);53 count_4 : in STD_LOGIC_VECTOR(2 downto 0);54 count_6 : in STD_LOGIC_VECTOR(2 downto 0);55 rate_sel : in STD_LOGIC_VECTOR(1 downto 0);56 clk_div_n : out STD_LOGIC;57 count_n : out STD_LOGIC_VECTOR(2 downto 0)58 );59 end component;6061 signal SRRC_coefficients : coeffs;62 signal to_clk_div_3 : STD_LOGIC;63 signal to_clk_div_4 : STD_LOGIC;64 signal to_clk_div_6 : STD_LOGIC;65 signal count_4 : STD_LOGIC_VECTOR (2 downto 0);66 signal to_count_3 : STD_LOGIC_VECTOR (2 downto 0);67 signal to_count_6 : STD_LOGIC_VECTOR (2 downto 0);6869 begin70 U0 : counter_divider_371 port map(72 clk => clk,73 clk_div_3 => to_clk_div_3,74 count_3 => to_count_3,75 reset => reset76 );77 U1 : counter_divider_478 port map(79 clk => clk,80 clk_div_4 => to_clk_div_4,81 count_4 => count_4,82 reset => reset83 );84 U2 : counter_divider_685 port map(86 clk => clk,87 clk_div_6 => to_clk_div_6,88 count_6 => to_count_6,89 reset => reset90 );91 U3 : selector92 port map(93 clk_div_3 => to_clk_div_3,94 clk_div_4 => to_clk_div_4,95 clk_div_6 => to_clk_div_6,96 clk_div_n => clk_div_n,97 count_3 => to_count_3,98 count_4 => count_4,99 count_6 => to_count_6,

100 count_n => count_n,101 rate_sel => rate_sel102 );103 U5 : coeffs_selector104 port map(105 coeffs_SRRC => SRRC_coefficients,106 rate_sel => rate_sel107 );108 coeffs_to_SRRCxN <= SRRC_coefficients;109 end rate_adapter;

Listato F.2.4: coeffs selector.vhd1 library ieee;2 use ieee.std_logic_1164.all;3 use ieee.std_logic_signed.all;


4 use work.SRRC_coeffs.all;56 entity coeffs_selector is7 port(8 rate_sel : in std_logic_vector(1 downto 0);9 coeffs_SRR : out coeffs

10 );11 end coeffs_selector;1213 architecture coeffs_selector_arch of coeffs_selector is14 -- calcolati con campionamento in frequenza e scalati15 Constant coeffs_SRRCx3 : coeffs := coeffs’(16 -- coefficienti del FIR 117 coeff’(X"FE0") , -- 118 coeff’(X"020") , -- 1 inverted19 coeff’(X"03D") , -- 220 coeff’(X"FC3") , -- 2 inverted21 coeff’(X"F94") , -- 322 coeff’(X"06C") , -- 3 inverted23 coeff’(X"59E") , -- 424 coeff’(X"A62") , -- 4 inverted25 coeff’(X"F94") , -- 526 coeff’(X"06C") , -- 5 inverted27 coeff’(X"03D") , -- 628 coeff’(X"FC3") , -- 6 inverted29 coeff’(X"FE0") , -- 730 coeff’(X"020") , -- 7 inverted31 -- coefficienti del FIR 232 coeff’(X"00A") , -- 833 coeff’(X"FF6") , -- 8 inverted34 coeff’(X"FB0") , -- 935 coeff’(X"050") , -- 9 inverted36 coeff’(X"1B1") , -- 1037 coeff’(X"E4F") , -- 10 inverted38 coeff’(X"461") , -- 1139 coeff’(X"B9F") , -- 11 inverted40 coeff’(X"F19") , -- 1241 coeff’(X"0E7") , -- 12 inverted42 coeff’(X"046") , -- 1343 coeff’(X"FBA") , -- 13 inverted44 coeff’(X"000") , -- 1445 coeff’(X"000") , -- 14 inverted46 -- coefficienti del FIR 347 coeff’(X"046") , -- 1548 coeff’(X"FBA") , -- 15 inverted49 coeff’(X"F19") , -- 1650 coeff’(X"0E7") , -- 16 inverted51 coeff’(X"461") , -- 1752 coeff’(X"B9F") , -- 17 inverted53 coeff’(X"1B1") , -- 1854 coeff’(X"E4F") , -- 18 inverted55 coeff’(X"FB0") , -- 1956 coeff’(X"050") , -- 19 inverted57 coeff’(X"00A") , -- 2058 coeff’(X"FF6") , -- 20 inverted59 coeff’(X"000") , -- 2160 coeff’(X"000") , -- 21 inverted61 -- coefficienti del FIR 462 coeff’(X"000") , -- 2263 coeff’(X"000") , -- 22 inverted64 coeff’(X"000") , -- 2365 coeff’(X"000") , -- 23 inverted66 coeff’(X"000") , -- 2467 coeff’(X"000") , -- 24 inverted68 coeff’(X"000") , -- 2569 coeff’(X"000") , -- 25 inverted70 coeff’(X"000") , -- 2671 coeff’(X"000") , -- 26 inverted72 coeff’(X"000") , -- 2773 coeff’(X"000") , -- 27 inverted74 coeff’(X"000") , -- 2875 coeff’(X"000") , -- 28 inverted76 -- coefficienti del FIR 577 coeff’(X"000") , -- 2978 coeff’(X"000") , -- 29 inverted79 coeff’(X"000") , -- 3080 coeff’(X"000") , -- 30 inverted81 coeff’(X"000") , -- 3182 coeff’(X"000") , -- 31 inverted83 coeff’(X"000") , -- 3284 coeff’(X"000") , -- 32 inverted85 coeff’(X"000") , -- 3386 coeff’(X"000") , -- 33 inverted87 coeff’(X"000") , -- 3488 coeff’(X"000") , -- 34 inverted89 coeff’(X"000") , -- 3590 coeff’(X"000") , -- 35 inverted91 -- coefficienti del FIR 692 coeff’(X"000") , -- 3693 coeff’(X"000") , -- 36 inverted


94 coeff’(X"000") , -- 3795 coeff’(X"000") , -- 37 inverted96 coeff’(X"000") , -- 3897 coeff’(X"000") , -- 38 inverted98 coeff’(X"000") , -- 3999 coeff’(X"000") , -- 39 inverted

100 coeff’(X"000") , -- 40101 coeff’(X"000") , -- 40 inverted102 coeff’(X"000") , -- 41103 coeff’(X"000") , -- 41 inverted104 coeff’(X"000") , -- 42105 coeff’(X"000") -- 42 inverted106 );107 -- calcolati con campionamento in frequenza e scalati108 Constant coeffs_SRRCx4 : coeffs := coeffs’(109 -- coefficienti del FIR 1110 coeff’(X"FD8") , -- 1111 coeff’(X"028") , -- 1 inverted112 coeff’(X"03D") , -- 2113 coeff’(X"FC3") , -- 2 inverted114 coeff’(X"F9B") , -- 3115 coeff’(X"065") , -- 3 inverted116 coeff’(X"55D") , -- 4117 coeff’(X"AA3") , -- 4 inverted118 coeff’(X"F9B") , -- 5119 coeff’(X"065") , -- 5 inverted120 coeff’(X"03D") , -- 6121 coeff’(X"FC3") , -- 6 inverted122 coeff’(X"FD8") , -- 7123 coeff’(X"028") , -- 7 inverted124 -- coefficienti del FIR 2125 coeff’(X"FF9") , -- 8126 coeff’(X"007") , -- 8 inverted127 coeff’(X"FDB") , -- 9128 coeff’(X"025") , -- 9 inverted129 coeff’(X"104") , -- 10130 coeff’(X"EFC") , -- 10 inverted131 coeff’(X"4AE") , -- 11132 coeff’(X"B52") , -- 11 inverted133 coeff’(X"F1A") , -- 12134 coeff’(X"0E6") , -- 12 inverted135 coeff’(X"051") , -- 13136 coeff’(X"FAF") , -- 13 inverted137 coeff’(X"000") , -- 14138 coeff’(X"000") , -- 14 inverted139 -- coefficienti del FIR 3140 coeff’(X"02C") , -- 15141 coeff’(X"FD4") , -- 15 inverted142 coeff’(X"F57") , -- 16143 coeff’(X"0A9") , -- 16 inverted144 coeff’(X"2F7") , -- 17145 coeff’(X"D09") , -- 17 inverted146 coeff’(X"2F7") , -- 18147 coeff’(X"D09") , -- 18 inverted148 coeff’(X"F57") , -- 19149 coeff’(X"0A9") , -- 19 inverted150 coeff’(X"02C") , -- 20151 coeff’(X"FD4") , -- 20 inverted152 coeff’(X"000") , -- 21153 coeff’(X"000") , -- 21 inverted154 -- coefficienti del FIR 4155 coeff’(X"051") , -- 22156 coeff’(X"FAF") , -- 22 inverted157 coeff’(X"F1A") , -- 23158 coeff’(X"0E6") , -- 23 inverted159 coeff’(X"4AE") , -- 24160 coeff’(X"B52") , -- 24 inverted161 coeff’(X"104") , -- 25162 coeff’(X"EFC") , -- 25 inverted163 coeff’(X"FDB") , -- 26164 coeff’(X"025") , -- 26 inverted165 coeff’(X"FF9") , -- 27166 coeff’(X"007") , -- 27 inverted167 coeff’(X"000") , -- 28168 coeff’(X"000") , -- 28 inverted169 -- coefficienti del FIR 5170 coeff’(X"000") , -- 29171 coeff’(X"000") , -- 29 inverted172 coeff’(X"000") , -- 30173 coeff’(X"000") , -- 30 inverted174 coeff’(X"000") , -- 31175 coeff’(X"000") , -- 31 inverted176 coeff’(X"000") , -- 32177 coeff’(X"000") , -- 32 inverted178 coeff’(X"000") , -- 33179 coeff’(X"000") , -- 33 inverted180 coeff’(X"000") , -- 34181 coeff’(X"000") , -- 34 inverted182 coeff’(X"000") , -- 35


183 coeff’(X"000") , -- 35 inverted184 -- coefficienti del FIR 6185 coeff’(X"000") , -- 36186 coeff’(X"000") , -- 36 inverted187 coeff’(X"000") , -- 37188 coeff’(X"000") , -- 37 inverted189 coeff’(X"000") , -- 38190 coeff’(X"000") , -- 38 inverted191 coeff’(X"000") , -- 39192 coeff’(X"000") , -- 39 inverted193 coeff’(X"000") , -- 40194 coeff’(X"000") , -- 40 inverted195 coeff’(X"000") , -- 41196 coeff’(X"000") , -- 41 inverted197 coeff’(X"000") , -- 42198 coeff’(X"000") -- 42 inverted199 );200 -- calcolati con campionamento in frequenza e scalati201 Constant coeffs_SRRCx6 : coeffs := coeffs’(202 -- coefficienti del FIR 1203 coeff’(X"FEB") , -- 1204 coeff’(X"015") , -- 1 inverted205 coeff’(X"04A") , -- 2206 coeff’(X"FB6") , -- 2 inverted207 coeff’(X"F25") , -- 3208 coeff’(X"0DB") , -- 3 inverted209 coeff’(X"53D") , -- 4210 coeff’(X"AC3") , -- 4 inverted211 coeff’(X"06E") , -- 5212 coeff’(X"F92") , -- 5 inverted213 coeff’(X"00B") , -- 6214 coeff’(X"FF5") , -- 6 inverted215 coeff’(X"FF5") , -- 7216 coeff’(X"00B") , -- 7 inverted217 -- coefficienti del FIR 2218 coeff’(X"FED") , -- 8219 coeff’(X"013") , -- 8 inverted220 coeff’(X"03D") , -- 9221 coeff’(X"FC3") , -- 9 inverted222 coeff’(X"F91") , -- 10223 coeff’(X"06F") , -- 10 inverted224 coeff’(X"591") , -- 11225 coeff’(X"A6F") , -- 11 inverted226 coeff’(X"F91") , -- 12227 coeff’(X"06F") , -- 12 inverted228 coeff’(X"03D") , -- 13229 coeff’(X"FC3") , -- 13 inverted230 coeff’(X"FED") , -- 14231 coeff’(X"013") , -- 14 inverted232 -- coefficienti del FIR 3233 coeff’(X"FF5") , -- 15234 coeff’(X"00B") , -- 15 inverted235 coeff’(X"00B") , -- 16236 coeff’(X"FF5") , -- 16 inverted237 coeff’(X"06E") , -- 17238 coeff’(X"F92") , -- 17 inverted239 coeff’(X"53D") , -- 18240 coeff’(X"AC3") , -- 18 inverted241 coeff’(X"F25") , -- 19242 coeff’(X"0DB") , -- 19 inverted243 coeff’(X"04A") , -- 20244 coeff’(X"FB6") , -- 20 inverted245 coeff’(X"FEB") , -- 21246 coeff’(X"015") , -- 21 inverted247 -- coefficienti del FIR 4248 coeff’(X"006") , -- 22249 coeff’(X"FFA") , -- 22 inverted250 coeff’(X"FB9") , -- 23251 coeff’(X"047") , -- 23 inverted252 coeff’(X"1A7") , -- 24253 coeff’(X"E59") , -- 24 inverted254 coeff’(X"455") , -- 25255 coeff’(X"BAB") , -- 25 inverted256 coeff’(X"F1F") , -- 26257 coeff’(X"0E1") , -- 26 inverted258 coeff’(X"03B") , -- 27259 coeff’(X"FC5") , -- 27 inverted260 coeff’(X"000") , -- 28261 coeff’(X"000") , -- 28 inverted262 -- coefficienti del FIR 5263 coeff’(X"020") , -- 29264 coeff’(X"FE0") , -- 29 inverted265 coeff’(X"F5E") , -- 30266 coeff’(X"0A2") , -- 30 inverted267 coeff’(X"30B") , -- 31268 coeff’(X"CF5") , -- 31 inverted269 coeff’(X"30B") , -- 32270 coeff’(X"CF5") , -- 32 inverted271 coeff’(X"F5E") , -- 33


272 coeff’(X"0A2") , -- 33 inverted273 coeff’(X"020") , -- 34274 coeff’(X"FE0") , -- 34 inverted275 coeff’(X"000") , -- 35276 coeff’(X"000") , -- 35 inverted277 -- coefficienti del FIR 6278 coeff’(X"03B") , -- 36279 coeff’(X"FC5") , -- 36 inverted280 coeff’(X"F1F") , -- 37281 coeff’(X"0E1") , -- 37 inverted282 coeff’(X"455") , -- 38283 coeff’(X"BAB") , -- 38 inverted284 coeff’(X"1A7") , -- 39285 coeff’(X"E59") , -- 39 inverted286 coeff’(X"FB9") , -- 40287 coeff’(X"047") , -- 40 inverted288 coeff’(X"006") , -- 41289 coeff’(X"FFA") , -- 41 inverted290 coeff’(X"000") , -- 42291 coeff’(X"000") -- 42 inverted292 );293 begin294 with rate_sel select295 coeffs_SRRC <= coeffs_SRRCx3 when "00" ,296 coeffs_SRRCx4 when "01" ,297 coeffs_SRRCx6 when others ;298 end coeffs_selector_arch;

Listato F.2.5: counter divider 3.vhd1 library IEEE;2 use IEEE.std_logic_1164.all;3 use IEEE.std_logic_unsigned.all;45 entity counter_divider_3 is6 port (7 clk : in STD_LOGIC;8 reset : in STD_LOGIC;9 count_3 : out STD_LOGIC_VECTOR (2 downto 0);

10 clk_div_3 : out STD_LOGIC11 );12 end counter_divider_3;1314 architecture counter_divider_3_arch of counter_divider_3 is15 signal int_count_3 : STD_LOGIC_VECTOR (1 downto 0) ;16 signal count_0_delayed : STD_LOGIC;17 begin18 process (clk , reset)19 begin20 if reset=’1’ then21 int_count_3 <= "01";22 elsif falling_edge(clk) then23 int_count_3 <= int_count_3(0)&not(int_count_3(0) or

int_count_3(1));24 end if;25 end process;2627 process(clk)28 begin29 if rising_edge(clk) then30 count_0_delayed <= int_count_3(0);31 end if;32 end process;33 clk_div_3 <= int_count_3(0) nor count_0_delayed;3435 process(clk)36 begin37 if falling_edge(clk) then38 count_3 <= ’0’ & int_count_3;39 end if;40 end process;41 end counter_divider_3_arch;

Listato F.2.6: counter divider 4.vhd1 library IEEE;2 use IEEE.std_logic_1164.all;34 entity counter_divider_4 is5 port(6 clk : in STD_LOGIC;7 reset : in STD_LOGIC;


8 clk_div_4 : out STD_LOGIC;9 count_4 : out STD_LOGIC_VECTOR(2 downto 0)

10 );11 end counter_divider_4;1213 architecture counter_divider_4 of counter_divider_4 is14 component fftr15 port (16 clk : in STD_LOGIC;17 eing : in STD_LOGIC;18 reset : in STD_LOGIC;19 aus : out STD_LOGIC20 );21 end component;2223 constant VCC_CONSTANT : STD_LOGIC := ’1’;24 constant GND_CONSTANT : STD_LOGIC := ’0’;25 signal GND : STD_LOGIC;26 signal VCC : STD_LOGIC;27 signal aus : STD_LOGIC_VECTOR (2 downto 0);2829 begin30 U1 : fftr31 port map(32 aus => aus(1),33 clk => clk,34 eing => aus(0),35 reset => reset36 );37 U2 : fftr38 port map(39 aus => aus(0),40 clk => clk,41 eing => VCC,42 reset => reset43 );44 VCC <= VCC_CONSTANT;45 GND <= GND_CONSTANT;46 aus(2) <= GND;47 clk_div_4 <= aus(1);48 count_4 <= aus;49 end counter_divider_4;

Listato F.2.7: fftr.vhd1 library IEEE;2 use IEEE.std_logic_1164.all;34 entity fftr is5 port (6 reset : in std_logic;7 clk : in std_logic;8 eing : in std_logic;9 aus : out std_logic

10 );11 end entity;1213 architecture fftr_arch of fftr is14 signal TEMP_aus: std_logic;15 begin16 process (clk, reset)17 begin18 if reset = ’1’ then19 TEMP_aus <= ’0’;20 elsif falling_edge(clk) then21 if eing = ’1’ then22 TEMP_aus <= not TEMP_AUS;23 else null;24 end if;25 end if;26 end process;27 aus <= TEMP_aus;28 end architecture;

Listato F.2.8: counter divider 6.vhd1 library IEEE;2 use IEEE.std_logic_1164.all;3 use IEEE.std_logic_unsigned.all;45 entity counter_divider_6 is6 port (7 clk : in STD_LOGIC;8 reset : in STD_LOGIC;


9 count_6 : out STD_LOGIC_VECTOR (2 downto 0);10 clk_div_6 : out STD_LOGIC11 );12 end counter_divider_6;1314 architecture counter_divider_6_arch of counter_divider_6 is15 begin16 process (clk, reset)17 variable count_6_interno : STD_LOGIC_VECTOR (2 downto 0);18 begin19 if reset=’1’ then20 count_6_interno := "000";21 clk_div_6 <= ’0’ ;22 else23 if falling_edge(clk) then24 if count_6_interno < 5 then25 count_6_interno := count_6_interno + 1;26 if count_6_interno = 3 then27 clk_div_6 <= ’1’ ;28 else null;29 end if ;30 else31 count_6_interno := "000";32 clk_div_6 <= ’0’ ;33 end if;34 end if;35 end if;36 count_6 <= count_6_interno;37 end process;38 end counter_divider_6_arch;

Listato F.2.9: selector.vhd1 library ieee;2 use ieee.std_logic_1164.all;34 entity selector is5 port( rate_sel : in std_logic_vector( 1 downto 0);6 clk_div_3 : in std_logic ;7 count_3 : in std_logic_vector(2 downto 0);8 clk_div_4 : in std_logic ;9 count_4 : in std_logic_vector(2 downto 0);

10 clk_div_6 : in std_logic ;11 count_6 : in std_logic_vector(2 downto 0);12 clk_div_n : out std_logic ;13 count_n : out std_logic_vector(2 downto 0)14 );15 end selector;1617 architecture selector_arch of selector is18 begin19 process (rate_sel,clk_div_3,clk_div_4,clk_div_6,count_3,count_4,count_6)20 begin21 case rate_sel is22 when "00" =>23 clk_div_n <= clk_div_3 ;24 count_n <= count_3 ;25 when "01" =>26 clk_div_n <= clk_div_4 ;27 count_n <= count_4 ;28 when "10" =>29 clk_div_n <= clk_div_6 ;30 count_n <= count_6 ;31 when others =>32 clk_div_n <= ’X’ ;33 count_n <= "XXX" ;34 end case;35 end process;36 end selector_arch;

Listato F.2.10: srrc x n.vhd1 library IEEE;2 use IEEE.std_logic_1164.all;3 use work.SRRC_coeffs.all;45 entity SRRC_x_N is6 port(7 SRRCxN_coeffs : in coeffs;8 clk : in STD_LOGIC;9 clk_div_n : in STD_LOGIC;

10 in_fir_MSB : in STD_LOGIC;11 reset : in STD_LOGIC;12 count_n : in STD_LOGIC_VECTOR(2 downto 0);13 polyphase_out : out STD_LOGIC_VECTOR(11 downto 0)


14 );15 end SRRC_x_N;1617 architecture SRRC_x_N of SRRC_x_N is18 component fir_119 port (20 clk_div_n : in STD_LOGIC;21 coeff_a : in coeff;22 coeff_b : in coeff;23 coeff_c : in coeff;24 coeff_d : in coeff;25 coeff_e : in coeff;26 coeff_f : in coeff;27 coeff_g : in coeff;28 in_fir_MSB : in STD_LOGIC;29 n_coeff_a : in coeff;30 n_coeff_b : in coeff;31 n_coeff_c : in coeff;32 n_coeff_d : in coeff;33 n_coeff_e : in coeff;34 n_coeff_f : in coeff;35 n_coeff_g : in coeff;36 reset : in STD_LOGIC;37 out_fir : out STD_LOGIC_VECTOR(11 downto 0)38 );39 end component;40 component mux_641 port (42 clk : in STD_LOGIC;43 count_n : in STD_LOGIC_VECTOR(2 downto 0);44 in_0 : in STD_LOGIC_VECTOR(11 downto 0);45 in_1 : in STD_LOGIC_VECTOR(11 downto 0);46 in_2 : in STD_LOGIC_VECTOR(11 downto 0);47 in_3 : in STD_LOGIC_VECTOR(11 downto 0);48 in_4 : in STD_LOGIC_VECTOR(11 downto 0);49 in_5 : in STD_LOGIC_VECTOR(11 downto 0);50 out_mux : out STD_LOGIC_VECTOR(11 downto 0)51 );52 end component;5354 signal coeff_1 : coeff;55 signal coeff_2 : coeff;56 signal coeff_3 : coeff;57 signal coeff_4 : coeff;58 signal coeff_5 : coeff;59 signal coeff_6 : coeff;60 signal coeff_7 : coeff;61 signal coeff_8 : coeff;62 signal coeff_9 : coeff;63 signal coeff_10 : coeff;64 signal coeff_11 : coeff;65 signal coeff_12 : coeff;66 signal coeff_13 : coeff;67 signal coeff_14 : coeff;68 signal coeff_15 : coeff;69 signal coeff_16 : coeff;70 signal coeff_17 : coeff;71 signal coeff_18 : coeff;72 signal coeff_19 : coeff;73 signal coeff_20 : coeff;74 signal coeff_21 : coeff;75 signal coeff_22 : coeff;76 signal coeff_23 : coeff;77 signal coeff_24 : coeff;78 signal coeff_25 : coeff;79 signal coeff_26 : coeff;80 signal coeff_27 : coeff;81 signal coeff_28 : coeff;82 signal coeff_29 : coeff;83 signal coeff_30 : coeff;84 signal coeff_31 : coeff;85 signal coeff_32 : coeff;86 signal coeff_33 : coeff;87 signal coeff_34 : coeff;88 signal coeff_35 : coeff;89 signal coeff_36 : coeff;90 signal coeff_37 : coeff;91 signal coeff_38 : coeff;92 signal coeff_39 : coeff;93 signal coeff_40 : coeff;94 signal coeff_41 : coeff;95 signal coeff_42 : coeff;9697 signal n_coeff_1 : coeff;98 signal n_coeff_2 : coeff;99 signal n_coeff_3 : coeff;

100 signal n_coeff_4 : coeff;101 signal n_coeff_5 : coeff;102 signal n_coeff_6 : coeff;103 signal n_coeff_7 : coeff;104 signal n_coeff_8 : coeff;105 signal n_coeff_9 : coeff;106 signal n_coeff_10 : coeff;107 signal n_coeff_11 : coeff;108 signal n_coeff_12 : coeff;109 signal n_coeff_13 : coeff;110 signal n_coeff_14 : coeff;


111 signal n_coeff_15 : coeff;112 signal n_coeff_16 : coeff;113 signal n_coeff_17 : coeff;114 signal n_coeff_18 : coeff;115 signal n_coeff_19 : coeff;116 signal n_coeff_20 : coeff;117 signal n_coeff_21 : coeff;118 signal n_coeff_22 : coeff;119 signal n_coeff_23 : coeff;120 signal n_coeff_24 : coeff;121 signal n_coeff_25 : coeff;122 signal n_coeff_26 : coeff;123 signal n_coeff_27 : coeff;124 signal n_coeff_28 : coeff;125 signal n_coeff_29 : coeff;126 signal n_coeff_30 : coeff;127 signal n_coeff_31 : coeff;128 signal n_coeff_32 : coeff;129 signal n_coeff_33 : coeff;130 signal n_coeff_34 : coeff;131 signal n_coeff_35 : coeff;132 signal n_coeff_36 : coeff;133 signal n_coeff_37 : coeff;134 signal n_coeff_38 : coeff;135 signal n_coeff_39 : coeff;136 signal n_coeff_40 : coeff;137 signal n_coeff_41 : coeff;138 signal n_coeff_42 : coeff;139140 signal to_in_0 : STD_LOGIC_VECTOR (11 downto 0);141 signal to_in_1 : STD_LOGIC_VECTOR (11 downto 0);142 signal to_in_2 : STD_LOGIC_VECTOR (11 downto 0);143 signal to_in_3 : STD_LOGIC_VECTOR (11 downto 0);144 signal to_in_4 : STD_LOGIC_VECTOR (11 downto 0);145 signal to_in_5 : STD_LOGIC_VECTOR (11 downto 0);146147 begin148 coeff_1 <= SRRCxN_coeffs(0);149 n_coeff_1 <= SRRCxN_coeffs(1);150 coeff_2 <= SRRCxN_coeffs(2);151 n_coeff_2 <= SRRCxN_coeffs(3);152 coeff_3 <= SRRCxN_coeffs(4);153 n_coeff_3 <= SRRCxN_coeffs(5);154 coeff_4 <= SRRCxN_coeffs(6);155 n_coeff_4 <= SRRCxN_coeffs(7);156 coeff_5 <= SRRCxN_coeffs(8);157 n_coeff_5 <= SRRCxN_coeffs(9);158 coeff_6 <= SRRCxN_coeffs(10);159 n_coeff_6 <= SRRCxN_coeffs(11);160 coeff_7 <= SRRCxN_coeffs(12);161 n_coeff_7 <= SRRCxN_coeffs(13);162 coeff_8 <= SRRCxN_coeffs(14);163 n_coeff_8 <= SRRCxN_coeffs(15);164 coeff_9 <= SRRCxN_coeffs(16);165 n_coeff_9 <= SRRCxN_coeffs(17);166 coeff_10 <= SRRCxN_coeffs(18);167 n_coeff_10 <= SRRCxN_coeffs(19);168 coeff_11 <= SRRCxN_coeffs(20);169 n_coeff_11 <= SRRCxN_coeffs(21);170 coeff_12 <= SRRCxN_coeffs(22);171 n_coeff_12 <= SRRCxN_coeffs(23);172 coeff_13 <= SRRCxN_coeffs(24);173 n_coeff_13 <= SRRCxN_coeffs(25);174 coeff_14 <= SRRCxN_coeffs(26);175 n_coeff_14 <= SRRCxN_coeffs(27);176 coeff_15 <= SRRCxN_coeffs(28);177 n_coeff_15 <= SRRCxN_coeffs(29);178 coeff_16 <= SRRCxN_coeffs(30);179 n_coeff_16 <= SRRCxN_coeffs(31);180 coeff_17 <= SRRCxN_coeffs(32);181 n_coeff_17 <= SRRCxN_coeffs(33);182 coeff_18 <= SRRCxN_coeffs(34);183 n_coeff_18 <= SRRCxN_coeffs(35);184 coeff_19 <= SRRCxN_coeffs(36);185 n_coeff_19 <= SRRCxN_coeffs(37);186 coeff_20 <= SRRCxN_coeffs(38);187 n_coeff_20 <= SRRCxN_coeffs(39);188 coeff_21 <= SRRCxN_coeffs(40);189 n_coeff_21 <= SRRCxN_coeffs(41);190 coeff_22 <= SRRCxN_coeffs(42);191 n_coeff_22 <= SRRCxN_coeffs(43);192 coeff_23 <= SRRCxN_coeffs(44);193 n_coeff_23 <= SRRCxN_coeffs(45);194 coeff_24 <= SRRCxN_coeffs(46);195 n_coeff_24 <= SRRCxN_coeffs(47);196 coeff_25 <= SRRCxN_coeffs(48);197 n_coeff_25 <= SRRCxN_coeffs(49);198 coeff_26 <= SRRCxN_coeffs(50);199 n_coeff_26 <= SRRCxN_coeffs(51);200 coeff_27 <= SRRCxN_coeffs(52);201 n_coeff_27 <= SRRCxN_coeffs(53);


202 coeff_28 <= SRRCxN_coeffs(54);203 n_coeff_28 <= SRRCxN_coeffs(55);204 coeff_29 <= SRRCxN_coeffs(56);205 n_coeff_29 <= SRRCxN_coeffs(57);206 coeff_30 <= SRRCxN_coeffs(58);207 n_coeff_30 <= SRRCxN_coeffs(59);208 coeff_31 <= SRRCxN_coeffs(60);209 n_coeff_31 <= SRRCxN_coeffs(61);210 coeff_32 <= SRRCxN_coeffs(62);211 n_coeff_32 <= SRRCxN_coeffs(63);212 coeff_33 <= SRRCxN_coeffs(64);213 n_coeff_33 <= SRRCxN_coeffs(65);214 coeff_34 <= SRRCxN_coeffs(66);215 n_coeff_34 <= SRRCxN_coeffs(67);216 coeff_35 <= SRRCxN_coeffs(68);217 n_coeff_35 <= SRRCxN_coeffs(69);218 coeff_36 <= SRRCxN_coeffs(70);219 n_coeff_36 <= SRRCxN_coeffs(71);220 coeff_37 <= SRRCxN_coeffs(72);221 n_coeff_37 <= SRRCxN_coeffs(73);222 coeff_38 <= SRRCxN_coeffs(74);223 n_coeff_38 <= SRRCxN_coeffs(75);224 coeff_39 <= SRRCxN_coeffs(76);225 n_coeff_39 <= SRRCxN_coeffs(77);226 coeff_40 <= SRRCxN_coeffs(78);227 n_coeff_40 <= SRRCxN_coeffs(79);228 coeff_41 <= SRRCxN_coeffs(80);229 n_coeff_41 <= SRRCxN_coeffs(81);230 coeff_42 <= SRRCxN_coeffs(82);231 n_coeff_42 <= SRRCxN_coeffs(83);232233 U1 : fir_1234 port map(235 clk_div_n => clk_div_n,236 coeff_a => coeff_1,237 coeff_b => coeff_2,238 coeff_c => coeff_3,239 coeff_d => coeff_4,240 coeff_e => coeff_5,241 coeff_f => coeff_6,242 coeff_g => coeff_7,243 in_fir_MSB => in_fir_MSB,244 n_coeff_a => n_coeff_1,245 n_coeff_b => n_coeff_2,246 n_coeff_c => n_coeff_3,247 n_coeff_d => n_coeff_4,248 n_coeff_e => n_coeff_5,249 n_coeff_f => n_coeff_6,250 n_coeff_g => n_coeff_7,251 out_fir => to_in_0,252 reset => reset253 );254 U2 : fir_1255 port map(256 clk_div_n => clk_div_n,257 coeff_a => coeff_8,258 coeff_b => coeff_9,259 coeff_c => coeff_10,260 coeff_d => coeff_11,261 coeff_e => coeff_12,262 coeff_f => coeff_13,263 coeff_g => coeff_14,264 in_fir_MSB => in_fir_MSB,265 n_coeff_a => n_coeff_8,266 n_coeff_b => n_coeff_9,267 n_coeff_c => n_coeff_10,268 n_coeff_d => n_coeff_11,269 n_coeff_e => n_coeff_12,270 n_coeff_f => n_coeff_13,271 n_coeff_g => n_coeff_14,272 out_fir => to_in_1,273 reset => reset274 );275 U3 : fir_1276 port map(277 clk_div_n => clk_div_n,278 coeff_a => coeff_15,279 coeff_b => coeff_16,280 coeff_c => coeff_17,281 coeff_d => coeff_18,282 coeff_e => coeff_19,283 coeff_f => coeff_20,284 coeff_g => coeff_21,285 in_fir_MSB => in_fir_MSB,286 n_coeff_a => n_coeff_15,287 n_coeff_b => n_coeff_16,288 n_coeff_c => n_coeff_17,289 n_coeff_d => n_coeff_18,290 n_coeff_e => n_coeff_19,291 n_coeff_f => n_coeff_20,292 n_coeff_g => n_coeff_21,293 out_fir => to_in_2,294 reset => reset295 );


296 U4 : fir_1297 port map(298 clk_div_n => clk_div_n,299 coeff_a => coeff_22,300 coeff_b => coeff_23,301 coeff_c => coeff_24,302 coeff_d => coeff_25,303 coeff_e => coeff_26,304 coeff_f => coeff_27,305 coeff_g => coeff_28,306 in_fir_MSB => in_fir_MSB,307 n_coeff_a => n_coeff_22,308 n_coeff_b => n_coeff_23,309 n_coeff_c => n_coeff_24,310 n_coeff_d => n_coeff_25,311 n_coeff_e => n_coeff_26,312 n_coeff_f => n_coeff_27,313 n_coeff_g => n_coeff_28,314 out_fir => to_in_3,315 reset => reset316 );317 U5 : fir_1318 port map(319 clk_div_n => clk_div_n,320 coeff_a => coeff_29,321 coeff_b => coeff_30,322 coeff_c => coeff_31,323 coeff_d => coeff_32,324 coeff_e => coeff_33,325 coeff_f => coeff_34,326 coeff_g => coeff_35,327 in_fir_MSB => in_fir_MSB,328 n_coeff_a => n_coeff_29,329 n_coeff_b => n_coeff_30,330 n_coeff_c => n_coeff_31,331 n_coeff_d => n_coeff_32,332 n_coeff_e => n_coeff_33,333 n_coeff_f => n_coeff_34,334 n_coeff_g => n_coeff_35,335 out_fir => to_in_4,336 reset => reset337 );338 U6 : fir_1339 port map(340 clk_div_n => clk_div_n,341 coeff_a => coeff_36,342 coeff_b => coeff_37,343 coeff_c => coeff_38,344 coeff_d => coeff_39,345 coeff_e => coeff_40,346 coeff_f => coeff_41,347 coeff_g => coeff_42,348 in_fir_MSB => in_fir_MSB,349 n_coeff_a => n_coeff_36,350 n_coeff_b => n_coeff_37,351 n_coeff_c => n_coeff_38,352 n_coeff_d => n_coeff_39,353 n_coeff_e => n_coeff_40,354 n_coeff_f => n_coeff_41,355 n_coeff_g => n_coeff_42,356 out_fir => to_in_5,357 reset => reset358 );359 U7 : mux_6360 port map(361 clk => clk,362 count_n => count_n,363 in_0 => to_in_0,364 in_1 => to_in_1,365 in_2 => to_in_2,366 in_3 => to_in_3,367 in_4 => to_in_4,368 in_5 => to_in_5,369 out_mux => polyphase_out370 );371 end SRRC_x_N;

Listato F.2.11: fir 1.vhd1 library IEEE;2 use IEEE.std_logic_1164.all;3 use work.SRRC_coeffs.all;45 entity fir_1 is6 port(7 clk_div_n : in STD_LOGIC;8 coeff_a : in coeff;9 coeff_b : in coeff;

10 coeff_c : in coeff;11 coeff_d : in coeff;12 coeff_e : in coeff;


13 coeff_f : in coeff;14 coeff_g : in coeff;15 in_fir_MSB : in STD_LOGIC;16 n_coeff_a : in coeff;17 n_coeff_b : in coeff;18 n_coeff_c : in coeff;19 n_coeff_d : in coeff;20 n_coeff_e : in coeff;21 n_coeff_f : in coeff;22 n_coeff_g : in coeff;23 reset : in STD_LOGIC;24 out_fir : out STD_LOGIC_VECTOR(11 downto 0)25 );26 end fir_1;2728 architecture fir_1 of fir_1 is29 component adder_730 port (31 clk_div_n : in STD_LOGIC;32 in_a : in STD_LOGIC_VECTOR(11 downto 0);33 in_b : in STD_LOGIC_VECTOR(11 downto 0);34 in_c : in STD_LOGIC_VECTOR(11 downto 0);35 in_d : in STD_LOGIC_VECTOR(11 downto 0);36 in_e : in STD_LOGIC_VECTOR(11 downto 0);37 in_f : in STD_LOGIC_VECTOR(11 downto 0);38 in_g : in STD_LOGIC_VECTOR(11 downto 0);39 reset : in STD_LOGIC;40 out_adder : out STD_LOGIC_VECTOR(11 downto 0)41 );42 end component;43 component fir_multiplier44 port (45 clk_div_n : in STD_LOGIC;46 coeff_n : in coeff;47 in_a : in STD_LOGIC;48 n_coeff_n : in coeff;49 reset : in STD_LOGIC;50 out_mult : out STD_LOGIC_VECTOR(11 downto 0)51 );52 end component;53 component shift_reg54 port (55 clk_div_n : in STD_LOGIC;56 in_reg : in STD_LOGIC;57 reset : in STD_LOGIC;58 out_ffd_1 : out STD_LOGIC;59 out_ffd_2 : out STD_LOGIC;60 out_ffd_3 : out STD_LOGIC;61 out_ffd_4 : out STD_LOGIC;62 out_ffd_5 : out STD_LOGIC;63 out_ffd_6 : out STD_LOGIC64 );65 end component;66 signal in_ffd_1 : STD_LOGIC;67 signal out_ffd_1 : STD_LOGIC;68 signal out_ffd_2 : STD_LOGIC;69 signal out_ffd_3 : STD_LOGIC;70 signal out_ffd_4 : STD_LOGIC;71 signal out_ffd_5 : STD_LOGIC;72 signal out_ffd_6 : STD_LOGIC;73 signal to_add_a : STD_LOGIC_VECTOR (11 downto 0);74 signal to_add_b : STD_LOGIC_VECTOR (11 downto 0);75 signal to_add_c : STD_LOGIC_VECTOR (11 downto 0);76 signal to_add_d : STD_LOGIC_VECTOR (11 downto 0);77 signal to_add_e : STD_LOGIC_VECTOR (11 downto 0);78 signal to_add_f : STD_LOGIC_VECTOR (11 downto 0);79 signal to_add_g : STD_LOGIC_VECTOR (11 downto 0);8081 begin82 U1 : shift_reg83 port map(84 clk_div_n => clk_div_n,85 in_reg => in_ffd_1,86 out_ffd_1 => out_ffd_1,87 out_ffd_2 => out_ffd_2,88 out_ffd_3 => out_ffd_3,89 out_ffd_4 => out_ffd_4,90 out_ffd_5 => out_ffd_5,91 out_ffd_6 => out_ffd_6,92 reset => reset93 );94 U2 : fir_multiplier95 port map(96 clk_div_n => clk_div_n,97 coeff_n => coeff_a,98 in_a => in_ffd_1,99 n_coeff_n => n_coeff_a,

100 out_mult => to_add_a,101 reset => reset102 );103 U3 : fir_multiplier104 port map(105 clk_div_n => clk_div_n,106 coeff_n => coeff_b,107 in_a => out_ffd_1,


108 n_coeff_n => n_coeff_b,109 out_mult => to_add_b,110 reset => reset111 );112 U4 : fir_multiplier113 port map(114 clk_div_n => clk_div_n,115 coeff_n => coeff_c,116 in_a => out_ffd_2,117 n_coeff_n => n_coeff_c,118 out_mult => to_add_c,119 reset => reset120 );121 U5 : fir_multiplier122 port map(123 clk_div_n => clk_div_n,124 coeff_n => coeff_d,125 in_a => out_ffd_3,126 n_coeff_n => n_coeff_d,127 out_mult => to_add_d,128 reset => reset129 );130 U6 : fir_multiplier131 port map(132 clk_div_n => clk_div_n,133 coeff_n => coeff_e,134 in_a => out_ffd_4,135 n_coeff_n => n_coeff_e,136 out_mult => to_add_e,137 reset => reset138 );139 U7 : fir_multiplier140 port map(141 clk_div_n => clk_div_n,142 coeff_n => coeff_f,143 in_a => out_ffd_5,144 n_coeff_n => n_coeff_f,145 out_mult => to_add_f,146 reset => reset147 );148 U8 : fir_multiplier149 port map(150 clk_div_n => clk_div_n,151 coeff_n => coeff_g,152 in_a => out_ffd_6,153 n_coeff_n => n_coeff_g,154 out_mult => to_add_g,155 reset => reset156 );157 U9 : adder_7158 port map(159 clk_div_n => clk_div_n,160 in_a => to_add_a,161 in_b => to_add_b,162 in_c => to_add_c,163 in_d => to_add_d,164 in_e => to_add_e,165 in_f => to_add_f,166 in_g => to_add_g,167 out_adder => out_fir,168 reset => reset169 );170 in_ffd_1 <= in_fir_MSB;171 end fir_1;

Listato F.2.12: adder 7.vhd1 library ieee;2 use ieee.std_logic_1164.all;3 use ieee.std_logic_signed.all;45 entity adder_7 is6 port(in_a, in_b, in_c, in_d : in std_logic_vector(11 downto 0);7 in_e, in_f, in_g : in std_logic_vector(11 downto 0);8 clk_div_n , reset : in std_logic;9 out_adder : out std_logic_vector(11 downto 0));

10 end adder_7 ;1112 architecture adder_7_arch of adder_7 is13 begin14 process(reset, clk_div_n , in_a , in_b , in_c , in_d, in_e, in_f, in_g)15 begin16 if reset = ’1’ then17 out_adder <= "000000000000";18 elsif falling_edge(clk_div_n) then19 out_adder <= in_a + in_b + in_c + in_d + in_e + in_f + in_g;20 end if ;21 end process;22 end adder_7_arch ;


Listato F.2.13: fir multiplier.vhd1 library ieee;2 use ieee.std_logic_1164.all;3 use ieee.std_logic_signed.all;4 use work.SRRC_coeffs.all;56 entity fir_multiplier is7 port( in_a : in std_logic ;8 reset : in std_logic ;9 coeff_n : in coeff ;

10 n_coeff_n : in coeff ;11 clk_div_n : in std_logic ;12 out_mult : out std_logic_vector(11 downto 0));13 end fir_multiplier;1415 architecture fir_multiplier_arch of fir_multiplier is16 begin17 process(in_a , coeff_n, n_coeff_n, clk_div_n, reset)18 begin19 if reset = ’1’ then20 out_mult <= "000000000000" ;21 elsif falling_edge(clk_div_n) then22 case in_a is23 when ’0’ => out_mult <= coeff_n ;24 when ’1’ => out_mult <= n_coeff_n ;25 when others => out_mult <= "000000000000" ;26 end case;27 end if;28 end process;29 end fir_multiplier_arch;

Listato F.2.14: shift reg.vhd1 library IEEE;2 use IEEE.std_logic_1164.all;34 entity shift_reg is5 port (6 clk_div_n : in std_logic ;7 reset : in std_logic ;8 in_reg : in std_logic ;9 out_ffd_1 : out std_logic ;

10 out_ffd_2 : out std_logic ;11 out_ffd_3 : out std_logic ;12 out_ffd_4 : out std_logic ;13 out_ffd_5 : out std_logic ;14 out_ffd_6 : out std_logic15 );16 end entity;1718 architecture shift_reg_arch of shift_reg is19 signal temp_out_reg : std_logic_vector(5 downto 0);20 signal temp_go_mult : std_logic_vector(6 downto 0);21 begin22 process(clk_div_n, reset)23 begin24 if reset = ’1’ then25 temp_out_reg <= "000000";26 elsif falling_edge(clk_div_n) then27 temp_out_reg <= in_reg & temp_out_reg(5 downto 1);28 end if;29 end process;30 out_ffd_6 <= temp_out_reg(0);31 out_ffd_5 <= temp_out_reg(1);32 out_ffd_4 <= temp_out_reg(2);33 out_ffd_3 <= temp_out_reg(3);34 out_ffd_2 <= temp_out_reg(4);35 out_ffd_1 <= temp_out_reg(5);36 end architecture;

Listato F.2.15: mux 6.vhd1 library ieee;2 use ieee.std_logic_1164.all;3


4 entity mux_6 is5 port(in_0, in_1, in_2, in_3, in_4, in_5 : in std_logic_vector(11 downto 0);6 count_n : in std_logic_vector(2 downto 0);7 clk : in std_logic;8 out_mux : out std_logic_vector(11 downto 0));9 end mux_6;

1011 architecture mux_arch of mux_6 is12 begin13 process (clk, count_n, in_0, in_1, in_2, in_3, in_4, in_5)14 begin15 if falling_edge(clk) then16 case count_n is17 when "000" => out_mux <= in_0 ;18 when "001" => out_mux <= in_1 ;19 when "010" => out_mux <= in_2 ;20 when "011" => out_mux <= in_3 ;21 when "100" => out_mux <= in_4 ;22 when "101" => out_mux <= in_5 ;23 when others => out_mux <= "XXXXXXXXXXXX" ;24 end case;25 else null ;26 end if;27 end process;28 end mux_arch ;

Listato F.3.1: ROM polyphase.vhd1 library IEEE;2 use IEEE.std_logic_1164.all;34 entity ROM_polyphase is5 port(6 clk : in STD_LOGIC;7 reset : in STD_LOGIC;8 to_SRRC_I : in STD_LOGIC;9 rate_sel : in STD_LOGIC_VECTOR(1 downto 0);

10 clk_sync : out STD_LOGIC;11 poly_out : out STD_LOGIC_VECTOR(11 downto 0)12 );13 end ROM_polyphase;1415 architecture ROM_polyphase of ROM_polyphase is16 component counter17 port (18 clk : in STD_LOGIC;19 rate_sel : in STD_LOGIC_VECTOR(1 downto 0);20 reset : in STD_LOGIC;21 clk_en : out STD_LOGIC;22 count : out STD_LOGIC_VECTOR(2 downto 0)23 );24 end component;25 component srrc_x_n26 port (27 clk : in STD_LOGIC;28 clk_en : in STD_LOGIC;29 fir_sel : in STD_LOGIC_VECTOR(2 downto 0);30 in_fir_MSB : in STD_LOGIC;31 rate_sel : in STD_LOGIC_VECTOR(1 downto 0);32 reset : in STD_LOGIC;33 out_srrc : out STD_LOGIC_VECTOR(11 downto 0)34 );35 end component;36 signal clk_en : STD_LOGIC;37 signal count_n : STD_LOGIC_VECTOR (2 downto 0);3839 begin40 U1 : counter41 port map(42 clk => clk,43 clk_en => clk_en,44 count => count_n,45 rate_sel => rate_sel,46 reset => reset47 );48 U2 : srrc_x_n49 port map(50 clk => clk,51 clk_en => clk_en,52 fir_sel => count_n,53 in_fir_MSB => to_SRRC_I,54 out_srrc => poly_out,55 rate_sel => rate_sel,56 reset => reset57 );58 clk_sync <= clk;59 end ROM_polyphase;


Listato F.3.2: counter.vhd1 library IEEE;2 use IEEE.std_logic_1164.all;3 use IEEE.std_logic_unsigned.all;45 entity counter is6 port (7 clk : in std_logic;8 reset : in std_logic;9 rate_sel : in std_logic_vector(1 downto 0);

10 count : out std_logic_vector(2 downto 0);11 clk_en : out std_logic12 );13 end entity;1415 architecture counter_arch of counter is16 type rate_table_type is array (0 to 2) of std_logic_vector (2 downto 0);17 -- definisco un array con i valori dei rate diminuiti di 118 -- per migliorare l ’ implementazione19 constant count_limit_table : rate_table_type := ("010","011","101");20 signal TEMP_count : std_logic_vector(2 downto 0);21 signal TEMP_clk_en : std_logic;22 begin23 process(clk, reset)24 begin25 if reset = ’1’ then26 TEMP_count <= "000";27 TEMP_clk_en <= ’1’ ;28 elsif rising_edge(clk) then29 if (TEMP_count = count_limit_table(conv_integer(rate_sel))-1)

then30 TEMP_clk_en <= ’1’ ;31 TEMP_count <= TEMP_count + 1;32 elsif (TEMP_count = count_limit_table(conv_integer(rate_sel))

)then33 TEMP_clk_en <= ’0’ ;34 TEMP_count <= "000";35 else36 TEMP_clk_en <= ’0’ ;37 TEMP_count <= TEMP_count + 1;38 end if;39 end if;40 end process;41 count <= TEMP_count;42 clk_en <= TEMP_clk_en;43 end counter_arch;

Listato F.3.3: srrc x n.vhd1 library IEEE;2 use IEEE.std_logic_1164.all;34 entity srrc_x_n is5 port(6 clk : in STD_LOGIC;7 clk_en : in STD_LOGIC;8 in_fir_MSB : in STD_LOGIC;9 reset : in STD_LOGIC;

10 fir_sel : in STD_LOGIC_VECTOR(2 downto 0);11 rate_sel : in STD_LOGIC_VECTOR(1 downto 0);12 out_srrc : out STD_LOGIC_VECTOR(11 downto 0)13 );14 end srrc_x_n;1516 architecture srrc_x_n of srrc_x_n is17 component demux_3x1018 port (19 clk : in STD_LOGIC;20 in_mux : in STD_LOGIC_VECTOR(9 downto 0);21 sel : in STD_LOGIC_VECTOR(1 downto 0);22 out_0 : out STD_LOGIC_VECTOR(8 downto 0);23 out_1 : out STD_LOGIC_VECTOR(8 downto 0);24 out_2 : out STD_LOGIC_VECTOR(9 downto 0)25 );26 end component;27 component mux_3x1228 port (29 clk : in STD_LOGIC;30 in_0 : in STD_LOGIC_VECTOR(11 downto 0);31 in_1 : in STD_LOGIC_VECTOR(11 downto 0);32 in_2 : in STD_LOGIC_VECTOR(11 downto 0);33 sel : in STD_LOGIC_VECTOR(1 downto 0);34 out_mux : out STD_LOGIC_VECTOR(11 downto 0)35 );36 end component;


37 component romx338 port (39 address : in STD_LOGIC_VECTOR(8 downto 0);40 SRRC_out : out STD_LOGIC_VECTOR(11 downto 0)41 );42 end component;43 component ROMx444 port (45 address : in STD_LOGIC_VECTOR(8 downto 0);46 SRRC_out : out STD_LOGIC_VECTOR(11 downto 0)47 );48 end component;49 component ROMx650 port (51 address : in STD_LOGIC_VECTOR(9 downto 0);52 SRRC_out : out STD_LOGIC_VECTOR(11 downto 0)53 );54 end component;55 component shift_reg56 port (57 clk : in STD_LOGIC;58 clk_en : in STD_LOGIC;59 in_reg : in STD_LOGIC;60 reset : in STD_LOGIC;61 out_ffd_1 : out STD_LOGIC;62 out_ffd_2 : out STD_LOGIC;63 out_ffd_3 : out STD_LOGIC;64 out_ffd_4 : out STD_LOGIC;65 out_ffd_5 : out STD_LOGIC;66 out_ffd_6 : out STD_LOGIC67 );68 end component;69 signal address : STD_LOGIC_VECTOR (9 downto 0);70 signal BUS615 : STD_LOGIC_VECTOR (11 downto 0);71 signal BUS619 : STD_LOGIC_VECTOR (11 downto 0);72 signal BUS623 : STD_LOGIC_VECTOR (11 downto 0);73 signal sel : STD_LOGIC_VECTOR (1 downto 0);74 signal to_romx3 : STD_LOGIC_VECTOR (8 downto 0);75 signal to_romx4 : STD_LOGIC_VECTOR (8 downto 0);76 signal to_romx6 : STD_LOGIC_VECTOR (9 downto 0);7778 begin79 U1 : shift_reg80 port map(81 clk => clk,82 clk_en => clk_en,83 in_reg => address(0),84 out_ffd_1 => address(1),85 out_ffd_2 => address(2),86 out_ffd_3 => address(3),87 out_ffd_4 => address(4),88 out_ffd_5 => address(5),89 out_ffd_6 => address(6),90 reset => reset91 );92 U2 : demux_3x1093 port map(94 clk => clk,95 in_mux => address,96 out_0 => to_romx3,97 out_1 => to_romx4,98 out_2 => to_romx6,99 sel => sel

100 );101 U3 : romx3102 port map(103 SRRC_out => BUS615,104 address => to_romx3105 );106 U4 : ROMx4107 port map(108 SRRC_out => BUS619,109 address => to_romx4110 );111 U5 : ROMx6112 port map(113 SRRC_out => BUS623,114 address => to_romx6115 );116 U6 : mux_3x12117 port map(118 clk => clk,119 in_0 => BUS615,120 in_1 => BUS619,121 in_2 => BUS623,122 out_mux => out_srrc,123 sel => sel124 );125 address(7) <= fir_sel(0);126 address(8) <= fir_sel(1);127 address(9) <= fir_sel(2);128 address(0) <= in_fir_MSB;129 sel <= rate_sel;


130 end srrc_x_n;

Listato F.3.4: demux 3x10.vhd1 library ieee;2 use ieee.std_logic_1164.all;34 entity demux_3x10 is5 port(in_mux : in std_logic_vector(9 downto 0);6 clk : in std_logic;7 sel : in std_logic_vector(1 downto 0);8 out_0 : out std_logic_vector(8 downto 0);9 out_1 : out std_logic_vector(8 downto 0);

10 out_2 : out std_logic_vector(9 downto 0)11 );12 end demux_3x10;1314 architecture demux_3x10_arch of demux_3x10 is15 begin16 process (sel, in_mux, clk)17 begin18 if rising_edge(clk) then19 case sel is20 when "00" => out_0 <= in_mux(8 downto 0) ;21 when "01" => out_1 <= in_mux(8 downto 0) ;22 when "10" => out_2 <= in_mux ;23 when others => null;24 end case;25 end if;26 end process;27 end demux_3x10_arch ;

Listato F.3.5: mux 3x12.vhd1 library ieee;2 use ieee.std_logic_1164.all;34 entity mux_3x12 is5 port(in_0, in_1, in_2 : in std_logic_vector(11 downto 0);6 clk : in std_logic ;7 sel : in std_logic_vector(1 downto 0);8 out_mux : out std_logic_vector(11 downto 0));9 end mux_3x12;

1011 architecture mux_3x12_arch of mux_3x12 is12 begin13 process (sel, in_0, in_1, in_2, clk)14 begin15 if rising_edge(clk) then16 case sel is17 when "00" => out_mux <=in_0 ;18 when "01" => out_mux <=in_1 ;19 when "10" => out_mux <=in_2 ;20 when others => out_mux <= "XXXXXXXXXXXX" ;21 end case;22 end if;23 end process;24 end mux_3x12_arch;

Listato F.3.6: ROMx3.vhd1 library ieee;2 use ieee.std_logic_1164.all;3 use ieee.std_logic_unsigned.all;45 entity ROMx3 is6 port(address : in STD_LOGIC_vector(8 downto 0);7 SRRC_out : out STD_LOGIC_VECTOR(11 downto 0)8 );9 end;

1011 architecture ROMx3_arch of ROMx3 is12 begin13 process(address)14 variable addr : integer ;15 begin16 addr := conv_integer(address) ;17 case addr is


18 -- somme per il FIR 019 when 0 => SRRC_out <= X"52B";20 when 1 => SRRC_out <= X"52B";21 when 2 => SRRC_out <= X"517";22 when 3 => SRRC_out <= X"517";23 when 4 => SRRC_out <= X"5CB";24 when 5 => SRRC_out <= X"5CB";25 when 6 => SRRC_out <= X"5B6";26 when 7 => SRRC_out <= X"5B6";27 when 8 => SRRC_out <= X"1C8";28 when 9 => SRRC_out <= X"1C8";29 when 10 => SRRC_out <= X"1B4";30 when 11 => SRRC_out <= X"1B4";31 when 12 => SRRC_out <= X"268";32 when 13 => SRRC_out <= X"268";33 when 14 => SRRC_out <= X"253";34 when 15 => SRRC_out <= X"253";35 when 16 => SRRC_out <= X"C69";36 when 17 => SRRC_out <= X"C69";37 when 18 => SRRC_out <= X"C55";38 when 19 => SRRC_out <= X"C55";39 when 20 => SRRC_out <= X"D09";40 when 21 => SRRC_out <= X"D09";41 when 22 => SRRC_out <= X"CF4";42 when 23 => SRRC_out <= X"CF4";43 when 24 => SRRC_out <= X"907";44 when 25 => SRRC_out <= X"907";45 when 26 => SRRC_out <= X"8F2";46 when 27 => SRRC_out <= X"8F2";47 when 28 => SRRC_out <= X"9A6";48 when 29 => SRRC_out <= X"9A6";49 when 30 => SRRC_out <= X"992";50 when 31 => SRRC_out <= X"992";51 when 32 => SRRC_out <= X"6FA";52 when 33 => SRRC_out <= X"6FA";53 when 34 => SRRC_out <= X"6E6";54 when 35 => SRRC_out <= X"6E6";55 when 36 => SRRC_out <= X"79A";56 when 37 => SRRC_out <= X"79A";57 when 38 => SRRC_out <= X"785";58 when 39 => SRRC_out <= X"785";59 when 40 => SRRC_out <= X"397";60 when 41 => SRRC_out <= X"397";61 when 42 => SRRC_out <= X"383";62 when 43 => SRRC_out <= X"383";63 when 44 => SRRC_out <= X"437";64 when 45 => SRRC_out <= X"437";65 when 46 => SRRC_out <= X"422";66 when 47 => SRRC_out <= X"422";67 when 48 => SRRC_out <= X"E38";68 when 49 => SRRC_out <= X"E38";69 when 50 => SRRC_out <= X"E24";70 when 51 => SRRC_out <= X"E24";71 when 52 => SRRC_out <= X"ED8";72 when 53 => SRRC_out <= X"ED8";73 when 54 => SRRC_out <= X"EC3";74 when 55 => SRRC_out <= X"EC3";75 when 56 => SRRC_out <= X"AD6";76 when 57 => SRRC_out <= X"AD6";77 when 58 => SRRC_out <= X"AC1";78 when 59 => SRRC_out <= X"AC1";79 when 60 => SRRC_out <= X"B75";80 when 61 => SRRC_out <= X"B75";81 when 62 => SRRC_out <= X"B61";82 when 63 => SRRC_out <= X"B61";83 when 64 => SRRC_out <= X"49F";84 when 65 => SRRC_out <= X"49F";85 when 66 => SRRC_out <= X"48B";86 when 67 => SRRC_out <= X"48B";87 when 68 => SRRC_out <= X"53F";88 when 69 => SRRC_out <= X"53F";89 when 70 => SRRC_out <= X"52A";90 when 71 => SRRC_out <= X"52A";91 when 72 => SRRC_out <= X"13D";92 when 73 => SRRC_out <= X"13D";93 when 74 => SRRC_out <= X"128";94 when 75 => SRRC_out <= X"128";95 when 76 => SRRC_out <= X"1DC";96 when 77 => SRRC_out <= X"1DC";97 when 78 => SRRC_out <= X"1C8";98 when 79 => SRRC_out <= X"1C8";99 when 80 => SRRC_out <= X"BDE";

100 when 81 => SRRC_out <= X"BDE";101 when 82 => SRRC_out <= X"BC9";102 when 83 => SRRC_out <= X"BC9";103 when 84 => SRRC_out <= X"C7D";104 when 85 => SRRC_out <= X"C7D";105 when 86 => SRRC_out <= X"C69";106 when 87 => SRRC_out <= X"C69";107 when 88 => SRRC_out <= X"87B";108 when 89 => SRRC_out <= X"87B";109 when 90 => SRRC_out <= X"866";110 when 91 => SRRC_out <= X"866";111 when 92 => SRRC_out <= X"91A";112 when 93 => SRRC_out <= X"91A";113 when 94 => SRRC_out <= X"906";114 when 95 => SRRC_out <= X"906";115 when 96 => SRRC_out <= X"66E";


116 when 97 => SRRC_out <= X"66E";117 when 98 => SRRC_out <= X"65A";118 when 99 => SRRC_out <= X"65A";119 when 100 => SRRC_out <= X"70E";120 when 101 => SRRC_out <= X"70E";121 when 102 => SRRC_out <= X"6F9";122 when 103 => SRRC_out <= X"6F9";123 when 104 => SRRC_out <= X"30C";124 when 105 => SRRC_out <= X"30C";125 when 106 => SRRC_out <= X"2F7";126 when 107 => SRRC_out <= X"2F7";127 when 108 => SRRC_out <= X"3AB";128 when 109 => SRRC_out <= X"3AB";129 when 110 => SRRC_out <= X"397";130 when 111 => SRRC_out <= X"397";131 when 112 => SRRC_out <= X"DAD";132 when 113 => SRRC_out <= X"DAD";133 when 114 => SRRC_out <= X"D98";134 when 115 => SRRC_out <= X"D98";135 when 116 => SRRC_out <= X"E4C";136 when 117 => SRRC_out <= X"E4C";137 when 118 => SRRC_out <= X"E38";138 when 119 => SRRC_out <= X"E38";139 when 120 => SRRC_out <= X"A4A";140 when 121 => SRRC_out <= X"A4A";141 when 122 => SRRC_out <= X"A35";142 when 123 => SRRC_out <= X"A35";143 when 124 => SRRC_out <= X"AE9";144 when 125 => SRRC_out <= X"AE9";145 when 126 => SRRC_out <= X"AD5";146 when 127 => SRRC_out <= X"AD5";147 -- somme per il FIR 1148 when 128 => SRRC_out <= X"52B";149 when 129 => SRRC_out <= X"52B";150 when 130 => SRRC_out <= X"49F";151 when 131 => SRRC_out <= X"49F";152 when 132 => SRRC_out <= X"6FA";153 when 133 => SRRC_out <= X"6FA";154 when 134 => SRRC_out <= X"66E";155 when 135 => SRRC_out <= X"66E";156 when 136 => SRRC_out <= X"C69";157 when 137 => SRRC_out <= X"C69";158 when 138 => SRRC_out <= X"BDE";159 when 139 => SRRC_out <= X"BDE";160 when 140 => SRRC_out <= X"E38";161 when 141 => SRRC_out <= X"E38";162 when 142 => SRRC_out <= X"DAD";163 when 143 => SRRC_out <= X"DAD";164 when 144 => SRRC_out <= X"1C8";165 when 145 => SRRC_out <= X"1C8";166 when 146 => SRRC_out <= X"13D";167 when 147 => SRRC_out <= X"13D";168 when 148 => SRRC_out <= X"397";169 when 149 => SRRC_out <= X"397";170 when 150 => SRRC_out <= X"30C";171 when 151 => SRRC_out <= X"30C";172 when 152 => SRRC_out <= X"907";173 when 153 => SRRC_out <= X"907";174 when 154 => SRRC_out <= X"87B";175 when 155 => SRRC_out <= X"87B";176 when 156 => SRRC_out <= X"AD6";177 when 157 => SRRC_out <= X"AD6";178 when 158 => SRRC_out <= X"A4A";179 when 159 => SRRC_out <= X"A4A";180 when 160 => SRRC_out <= X"5CB";181 when 161 => SRRC_out <= X"5CB";182 when 162 => SRRC_out <= X"53F";183 when 163 => SRRC_out <= X"53F";184 when 164 => SRRC_out <= X"79A";185 when 165 => SRRC_out <= X"79A";186 when 166 => SRRC_out <= X"70E";187 when 167 => SRRC_out <= X"70E";188 when 168 => SRRC_out <= X"D09";189 when 169 => SRRC_out <= X"D09";190 when 170 => SRRC_out <= X"C7D";191 when 171 => SRRC_out <= X"C7D";192 when 172 => SRRC_out <= X"ED8";193 when 173 => SRRC_out <= X"ED8";194 when 174 => SRRC_out <= X"E4C";195 when 175 => SRRC_out <= X"E4C";196 when 176 => SRRC_out <= X"268";197 when 177 => SRRC_out <= X"268";198 when 178 => SRRC_out <= X"1DC";199 when 179 => SRRC_out <= X"1DC";200 when 180 => SRRC_out <= X"437";201 when 181 => SRRC_out <= X"437";202 when 182 => SRRC_out <= X"3AB";203 when 183 => SRRC_out <= X"3AB";204 when 184 => SRRC_out <= X"9A6";205 when 185 => SRRC_out <= X"9A6";206 when 186 => SRRC_out <= X"91A";207 when 187 => SRRC_out <= X"91A";208 when 188 => SRRC_out <= X"B75";209 when 189 => SRRC_out <= X"B75";210 when 190 => SRRC_out <= X"AE9";211 when 191 => SRRC_out <= X"AE9";212 when 192 => SRRC_out <= X"517";213 when 193 => SRRC_out <= X"517";


214 when 194 => SRRC_out <= X"48B";215 when 195 => SRRC_out <= X"48B";216 when 196 => SRRC_out <= X"6E6";217 when 197 => SRRC_out <= X"6E6";218 when 198 => SRRC_out <= X"65A";219 when 199 => SRRC_out <= X"65A";220 when 200 => SRRC_out <= X"C55";221 when 201 => SRRC_out <= X"C55";222 when 202 => SRRC_out <= X"BC9";223 when 203 => SRRC_out <= X"BC9";224 when 204 => SRRC_out <= X"E24";225 when 205 => SRRC_out <= X"E24";226 when 206 => SRRC_out <= X"D98";227 when 207 => SRRC_out <= X"D98";228 when 208 => SRRC_out <= X"1B4";229 when 209 => SRRC_out <= X"1B4";230 when 210 => SRRC_out <= X"128";231 when 211 => SRRC_out <= X"128";232 when 212 => SRRC_out <= X"383";233 when 213 => SRRC_out <= X"383";234 when 214 => SRRC_out <= X"2F7";235 when 215 => SRRC_out <= X"2F7";236 when 216 => SRRC_out <= X"8F2";237 when 217 => SRRC_out <= X"8F2";238 when 218 => SRRC_out <= X"866";239 when 219 => SRRC_out <= X"866";240 when 220 => SRRC_out <= X"AC1";241 when 221 => SRRC_out <= X"AC1";242 when 222 => SRRC_out <= X"A35";243 when 223 => SRRC_out <= X"A35";244 when 224 => SRRC_out <= X"5B6";245 when 225 => SRRC_out <= X"5B6";246 when 226 => SRRC_out <= X"52A";247 when 227 => SRRC_out <= X"52A";248 when 228 => SRRC_out <= X"785";249 when 229 => SRRC_out <= X"785";250 when 230 => SRRC_out <= X"6F9";251 when 231 => SRRC_out <= X"6F9";252 when 232 => SRRC_out <= X"CF4";253 when 233 => SRRC_out <= X"CF4";254 when 234 => SRRC_out <= X"C69";255 when 235 => SRRC_out <= X"C69";256 when 236 => SRRC_out <= X"EC3";257 when 237 => SRRC_out <= X"EC3";258 when 238 => SRRC_out <= X"E38";259 when 239 => SRRC_out <= X"E38";260 when 240 => SRRC_out <= X"253";261 when 241 => SRRC_out <= X"253";262 when 242 => SRRC_out <= X"1C8";263 when 243 => SRRC_out <= X"1C8";264 when 244 => SRRC_out <= X"422";265 when 245 => SRRC_out <= X"422";266 when 246 => SRRC_out <= X"397";267 when 247 => SRRC_out <= X"397";268 when 248 => SRRC_out <= X"992";269 when 249 => SRRC_out <= X"992";270 when 250 => SRRC_out <= X"906";271 when 251 => SRRC_out <= X"906";272 when 252 => SRRC_out <= X"B61";273 when 253 => SRRC_out <= X"B61";274 when 254 => SRRC_out <= X"AD5";275 when 255 => SRRC_out <= X"AD5";276 -- somme per il FIR 2277 when 256 => SRRC_out <= X"500";278 when 257 => SRRC_out <= X"541";279 when 258 => SRRC_out <= X"485";280 when 259 => SRRC_out <= X"4C6";281 when 260 => SRRC_out <= X"5D7";282 when 261 => SRRC_out <= X"618";283 when 262 => SRRC_out <= X"55D";284 when 263 => SRRC_out <= X"59E";285 when 264 => SRRC_out <= X"9C4";286 when 265 => SRRC_out <= X"A05";287 when 266 => SRRC_out <= X"94A";288 when 267 => SRRC_out <= X"98B";289 when 268 => SRRC_out <= X"A9C";290 when 269 => SRRC_out <= X"ADC";291 when 270 => SRRC_out <= X"A21";292 when 271 => SRRC_out <= X"A62";293 when 272 => SRRC_out <= X"5D7";294 when 273 => SRRC_out <= X"618";295 when 274 => SRRC_out <= X"55D";296 when 275 => SRRC_out <= X"59E";297 when 276 => SRRC_out <= X"6AF";298 when 277 => SRRC_out <= X"6F0";299 when 278 => SRRC_out <= X"634";300 when 279 => SRRC_out <= X"675";301 when 280 => SRRC_out <= X"A9C";302 when 281 => SRRC_out <= X"ADC";303 when 282 => SRRC_out <= X"A21";304 when 283 => SRRC_out <= X"A62";305 when 284 => SRRC_out <= X"B73";306 when 285 => SRRC_out <= X"BB4";307 when 286 => SRRC_out <= X"AF9";308 when 287 => SRRC_out <= X"B3A";309 when 288 => SRRC_out <= X"485";310 when 289 => SRRC_out <= X"4C6";311 when 290 => SRRC_out <= X"40B";


312 when 291 => SRRC_out <= X"44C";313 when 292 => SRRC_out <= X"55D";314 when 293 => SRRC_out <= X"59E";315 when 294 => SRRC_out <= X"4E3";316 when 295 => SRRC_out <= X"524";317 when 296 => SRRC_out <= X"94A";318 when 297 => SRRC_out <= X"98B";319 when 298 => SRRC_out <= X"8CF";320 when 299 => SRRC_out <= X"910";321 when 300 => SRRC_out <= X"A21";322 when 301 => SRRC_out <= X"A62";323 when 302 => SRRC_out <= X"9A7";324 when 303 => SRRC_out <= X"9E8";325 when 304 => SRRC_out <= X"55D";326 when 305 => SRRC_out <= X"59E";327 when 306 => SRRC_out <= X"4E3";328 when 307 => SRRC_out <= X"524";329 when 308 => SRRC_out <= X"634";330 when 309 => SRRC_out <= X"675";331 when 310 => SRRC_out <= X"5BA";332 when 311 => SRRC_out <= X"5FB";333 when 312 => SRRC_out <= X"A21";334 when 313 => SRRC_out <= X"A62";335 when 314 => SRRC_out <= X"9A7";336 when 315 => SRRC_out <= X"9E8";337 when 316 => SRRC_out <= X"AF9";338 when 317 => SRRC_out <= X"B3A";339 when 318 => SRRC_out <= X"A7E";340 when 319 => SRRC_out <= X"ABF";341 when 320 => SRRC_out <= X"541";342 when 321 => SRRC_out <= X"582";343 when 322 => SRRC_out <= X"4C6";344 when 323 => SRRC_out <= X"507";345 when 324 => SRRC_out <= X"618";346 when 325 => SRRC_out <= X"659";347 when 326 => SRRC_out <= X"59E";348 when 327 => SRRC_out <= X"5DF";349 when 328 => SRRC_out <= X"A05";350 when 329 => SRRC_out <= X"A46";351 when 330 => SRRC_out <= X"98B";352 when 331 => SRRC_out <= X"9CC";353 when 332 => SRRC_out <= X"ADC";354 when 333 => SRRC_out <= X"B1D";355 when 334 => SRRC_out <= X"A62";356 when 335 => SRRC_out <= X"AA3";357 when 336 => SRRC_out <= X"618";358 when 337 => SRRC_out <= X"659";359 when 338 => SRRC_out <= X"59E";360 when 339 => SRRC_out <= X"5DF";361 when 340 => SRRC_out <= X"6F0";362 when 341 => SRRC_out <= X"731";363 when 342 => SRRC_out <= X"675";364 when 343 => SRRC_out <= X"6B6";365 when 344 => SRRC_out <= X"ADC";366 when 345 => SRRC_out <= X"B1D";367 when 346 => SRRC_out <= X"A62";368 when 347 => SRRC_out <= X"AA3";369 when 348 => SRRC_out <= X"BB4";370 when 349 => SRRC_out <= X"BF5";371 when 350 => SRRC_out <= X"B3A";372 when 351 => SRRC_out <= X"B7B";373 when 352 => SRRC_out <= X"4C6";374 when 353 => SRRC_out <= X"507";375 when 354 => SRRC_out <= X"44C";376 when 355 => SRRC_out <= X"48D";377 when 356 => SRRC_out <= X"59E";378 when 357 => SRRC_out <= X"5DF";379 when 358 => SRRC_out <= X"524";380 when 359 => SRRC_out <= X"564";381 when 360 => SRRC_out <= X"98B";382 when 361 => SRRC_out <= X"9CC";383 when 362 => SRRC_out <= X"910";384 when 363 => SRRC_out <= X"951";385 when 364 => SRRC_out <= X"A62";386 when 365 => SRRC_out <= X"AA3";387 when 366 => SRRC_out <= X"9E8";388 when 367 => SRRC_out <= X"A29";389 when 368 => SRRC_out <= X"59E";390 when 369 => SRRC_out <= X"5DF";391 when 370 => SRRC_out <= X"524";392 when 371 => SRRC_out <= X"564";393 when 372 => SRRC_out <= X"675";394 when 373 => SRRC_out <= X"6B6";395 when 374 => SRRC_out <= X"5FB";396 when 375 => SRRC_out <= X"63C";397 when 376 => SRRC_out <= X"A62";398 when 377 => SRRC_out <= X"AA3";399 when 378 => SRRC_out <= X"9E8";400 when 379 => SRRC_out <= X"A29";401 when 380 => SRRC_out <= X"B3A";402 when 381 => SRRC_out <= X"B7B";403 when 382 => SRRC_out <= X"ABF";404 when 383 => SRRC_out <= X"B00";405 when OTHERS => SRRC_out <= X"000";406 end case;407 end process;408 end ROMx3_arch;



1011 architecture ROMx4_arch of ROMx4 is12 begin13 process(address)14 variable addr : integer ;15 begin16 addr := conv_integer(address) ;17 case addr is18 -- somme per il FIR 019 when 0 => SRRC_out <= X"4F1";20 when 1 => SRRC_out <= X"4F1";21 when 2 => SRRC_out <= X"500";22 when 3 => SRRC_out <= X"500";23 when 4 => SRRC_out <= X"53B";24 when 5 => SRRC_out <= X"53B";25 when 6 => SRRC_out <= X"549";26 when 7 => SRRC_out <= X"549";27 when 8 => SRRC_out <= X"2EA";28 when 9 => SRRC_out <= X"2EA";29 when 10 => SRRC_out <= X"2F9";30 when 11 => SRRC_out <= X"2F9";31 when 12 => SRRC_out <= X"334";32 when 13 => SRRC_out <= X"334";33 when 14 => SRRC_out <= X"342";34 when 15 => SRRC_out <= X"342";35 when 16 => SRRC_out <= X"B95";36 when 17 => SRRC_out <= X"B95";37 when 18 => SRRC_out <= X"BA3";38 when 19 => SRRC_out <= X"BA3";39 when 20 => SRRC_out <= X"BDE";40 when 21 => SRRC_out <= X"BDE";41 when 22 => SRRC_out <= X"BED";42 when 23 => SRRC_out <= X"BED";43 when 24 => SRRC_out <= X"98E";44 when 25 => SRRC_out <= X"98E";45 when 26 => SRRC_out <= X"99C";46 when 27 => SRRC_out <= X"99C";47 when 28 => SRRC_out <= X"9D7";48 when 29 => SRRC_out <= X"9D7";49 when 30 => SRRC_out <= X"9E6";50 when 31 => SRRC_out <= X"9E6";51 when 32 => SRRC_out <= X"6BD";52 when 33 => SRRC_out <= X"6BD";53 when 34 => SRRC_out <= X"6CB";54 when 35 => SRRC_out <= X"6CB";55 when 36 => SRRC_out <= X"706";56 when 37 => SRRC_out <= X"706";57 when 38 => SRRC_out <= X"715";58 when 39 => SRRC_out <= X"715";59 when 40 => SRRC_out <= X"4B6";60 when 41 => SRRC_out <= X"4B6";61 when 42 => SRRC_out <= X"4C4";62 when 43 => SRRC_out <= X"4C4";63 when 44 => SRRC_out <= X"4FF";64 when 45 => SRRC_out <= X"4FF";65 when 46 => SRRC_out <= X"50E";66 when 47 => SRRC_out <= X"50E";67 when 48 => SRRC_out <= X"D60";68 when 49 => SRRC_out <= X"D60";69 when 50 => SRRC_out <= X"D6E";70 when 51 => SRRC_out <= X"D6E";71 when 52 => SRRC_out <= X"DAA";72 when 53 => SRRC_out <= X"DAA";73 when 54 => SRRC_out <= X"DB8";74 when 55 => SRRC_out <= X"DB8";75 when 56 => SRRC_out <= X"B59";76 when 57 => SRRC_out <= X"B59";77 when 58 => SRRC_out <= X"B67";78 when 59 => SRRC_out <= X"B67";79 when 60 => SRRC_out <= X"BA3";80 when 61 => SRRC_out <= X"BA3";81 when 62 => SRRC_out <= X"BB1";82 when 63 => SRRC_out <= X"BB1";83 when 64 => SRRC_out <= X"44F";84 when 65 => SRRC_out <= X"44F";85 when 66 => SRRC_out <= X"45D";86 when 67 => SRRC_out <= X"45D";87 when 68 => SRRC_out <= X"499";88 when 69 => SRRC_out <= X"499";


89 when 70 => SRRC_out <= X"4A7";90 when 71 => SRRC_out <= X"4A7";91 when 72 => SRRC_out <= X"248";92 when 73 => SRRC_out <= X"248";93 when 74 => SRRC_out <= X"256";94 when 75 => SRRC_out <= X"256";95 when 76 => SRRC_out <= X"292";96 when 77 => SRRC_out <= X"292";97 when 78 => SRRC_out <= X"2A0";98 when 79 => SRRC_out <= X"2A0";99 when 80 => SRRC_out <= X"AF2";

100 when 81 => SRRC_out <= X"AF2";101 when 82 => SRRC_out <= X"B01";102 when 83 => SRRC_out <= X"B01";103 when 84 => SRRC_out <= X"B3C";104 when 85 => SRRC_out <= X"B3C";105 when 86 => SRRC_out <= X"B4A";106 when 87 => SRRC_out <= X"B4A";107 when 88 => SRRC_out <= X"8EB";108 when 89 => SRRC_out <= X"8EB";109 when 90 => SRRC_out <= X"8FA";110 when 91 => SRRC_out <= X"8FA";111 when 92 => SRRC_out <= X"935";112 when 93 => SRRC_out <= X"935";113 when 94 => SRRC_out <= X"943";114 when 95 => SRRC_out <= X"943";115 when 96 => SRRC_out <= X"61A";116 when 97 => SRRC_out <= X"61A";117 when 98 => SRRC_out <= X"629";118 when 99 => SRRC_out <= X"629";119 when 100 => SRRC_out <= X"664";120 when 101 => SRRC_out <= X"664";121 when 102 => SRRC_out <= X"672";122 when 103 => SRRC_out <= X"672";123 when 104 => SRRC_out <= X"413";124 when 105 => SRRC_out <= X"413";125 when 106 => SRRC_out <= X"422";126 when 107 => SRRC_out <= X"422";127 when 108 => SRRC_out <= X"45D";128 when 109 => SRRC_out <= X"45D";129 when 110 => SRRC_out <= X"46B";130 when 111 => SRRC_out <= X"46B";131 when 112 => SRRC_out <= X"CBE";132 when 113 => SRRC_out <= X"CBE";133 when 114 => SRRC_out <= X"CCC";134 when 115 => SRRC_out <= X"CCC";135 when 116 => SRRC_out <= X"D07";136 when 117 => SRRC_out <= X"D07";137 when 118 => SRRC_out <= X"D16";138 when 119 => SRRC_out <= X"D16";139 when 120 => SRRC_out <= X"AB7";140 when 121 => SRRC_out <= X"AB7";141 when 122 => SRRC_out <= X"AC5";142 when 123 => SRRC_out <= X"AC5";143 when 124 => SRRC_out <= X"B00";144 when 125 => SRRC_out <= X"B00";145 when 126 => SRRC_out <= X"B0F";146 when 127 => SRRC_out <= X"B0F";147 -- somme per il FIR 1148 when 128 => SRRC_out <= X"4F5";149 when 129 => SRRC_out <= X"4F5";150 when 130 => SRRC_out <= X"49D";151 when 131 => SRRC_out <= X"49D";152 when 132 => SRRC_out <= X"647";153 when 133 => SRRC_out <= X"647";154 when 134 => SRRC_out <= X"5EF";155 when 135 => SRRC_out <= X"5EF";156 when 136 => SRRC_out <= X"F07";157 when 137 => SRRC_out <= X"F07";158 when 138 => SRRC_out <= X"EAE";159 when 139 => SRRC_out <= X"EAE";160 when 140 => SRRC_out <= X"059";161 when 141 => SRRC_out <= X"059";162 when 142 => SRRC_out <= X"000";163 when 143 => SRRC_out <= X"000";164 when 144 => SRRC_out <= X"F07";165 when 145 => SRRC_out <= X"F07";166 when 146 => SRRC_out <= X"EAE";167 when 147 => SRRC_out <= X"EAE";168 when 148 => SRRC_out <= X"059";169 when 149 => SRRC_out <= X"059";170 when 150 => SRRC_out <= X"000";171 when 151 => SRRC_out <= X"000";172 when 152 => SRRC_out <= X"918";173 when 153 => SRRC_out <= X"918";174 when 154 => SRRC_out <= X"8BF";175 when 155 => SRRC_out <= X"8BF";176 when 156 => SRRC_out <= X"A6A";177 when 157 => SRRC_out <= X"A6A";178 when 158 => SRRC_out <= X"A11";179 when 159 => SRRC_out <= X"A11";180 when 160 => SRRC_out <= X"647";181 when 161 => SRRC_out <= X"647";182 when 162 => SRRC_out <= X"5EF";183 when 163 => SRRC_out <= X"5EF";184 when 164 => SRRC_out <= X"79A";185 when 165 => SRRC_out <= X"79A";186 when 166 => SRRC_out <= X"741";


187 when 167 => SRRC_out <= X"741";188 when 168 => SRRC_out <= X"059";189 when 169 => SRRC_out <= X"059";190 when 170 => SRRC_out <= X"000";191 when 171 => SRRC_out <= X"000";192 when 172 => SRRC_out <= X"1AB";193 when 173 => SRRC_out <= X"1AB";194 when 174 => SRRC_out <= X"152";195 when 175 => SRRC_out <= X"152";196 when 176 => SRRC_out <= X"059";197 when 177 => SRRC_out <= X"059";198 when 178 => SRRC_out <= X"000";199 when 179 => SRRC_out <= X"000";200 when 180 => SRRC_out <= X"1AB";201 when 181 => SRRC_out <= X"1AB";202 when 182 => SRRC_out <= X"152";203 when 183 => SRRC_out <= X"152";204 when 184 => SRRC_out <= X"A6A";205 when 185 => SRRC_out <= X"A6A";206 when 186 => SRRC_out <= X"A11";207 when 187 => SRRC_out <= X"A11";208 when 188 => SRRC_out <= X"BBC";209 when 189 => SRRC_out <= X"BBC";210 when 190 => SRRC_out <= X"B63";211 when 191 => SRRC_out <= X"B63";212 when 192 => SRRC_out <= X"49D";213 when 193 => SRRC_out <= X"49D";214 when 194 => SRRC_out <= X"444";215 when 195 => SRRC_out <= X"444";216 when 196 => SRRC_out <= X"5EF";217 when 197 => SRRC_out <= X"5EF";218 when 198 => SRRC_out <= X"596";219 when 199 => SRRC_out <= X"596";220 when 200 => SRRC_out <= X"EAE";221 when 201 => SRRC_out <= X"EAE";222 when 202 => SRRC_out <= X"E55";223 when 203 => SRRC_out <= X"E55";224 when 204 => SRRC_out <= X"000";225 when 205 => SRRC_out <= X"000";226 when 206 => SRRC_out <= X"FA7";227 when 207 => SRRC_out <= X"FA7";228 when 208 => SRRC_out <= X"EAE";229 when 209 => SRRC_out <= X"EAE";230 when 210 => SRRC_out <= X"E55";231 when 211 => SRRC_out <= X"E55";232 when 212 => SRRC_out <= X"000";233 when 213 => SRRC_out <= X"000";234 when 214 => SRRC_out <= X"FA7";235 when 215 => SRRC_out <= X"FA7";236 when 216 => SRRC_out <= X"8BF";237 when 217 => SRRC_out <= X"8BF";238 when 218 => SRRC_out <= X"866";239 when 219 => SRRC_out <= X"866";240 when 220 => SRRC_out <= X"A11";241 when 221 => SRRC_out <= X"A11";242 when 222 => SRRC_out <= X"9B9";243 when 223 => SRRC_out <= X"9B9";244 when 224 => SRRC_out <= X"5EF";245 when 225 => SRRC_out <= X"5EF";246 when 226 => SRRC_out <= X"596";247 when 227 => SRRC_out <= X"596";248 when 228 => SRRC_out <= X"741";249 when 229 => SRRC_out <= X"741";250 when 230 => SRRC_out <= X"6E8";251 when 231 => SRRC_out <= X"6E8";252 when 232 => SRRC_out <= X"000";253 when 233 => SRRC_out <= X"000";254 when 234 => SRRC_out <= X"FA7";255 when 235 => SRRC_out <= X"FA7";256 when 236 => SRRC_out <= X"152";257 when 237 => SRRC_out <= X"152";258 when 238 => SRRC_out <= X"0F9";259 when 239 => SRRC_out <= X"0F9";260 when 240 => SRRC_out <= X"000";261 when 241 => SRRC_out <= X"000";262 when 242 => SRRC_out <= X"FA7";263 when 243 => SRRC_out <= X"FA7";264 when 244 => SRRC_out <= X"152";265 when 245 => SRRC_out <= X"152";266 when 246 => SRRC_out <= X"0F9";267 when 247 => SRRC_out <= X"0F9";268 when 248 => SRRC_out <= X"A11";269 when 249 => SRRC_out <= X"A11";270 when 250 => SRRC_out <= X"9B9";271 when 251 => SRRC_out <= X"9B9";272 when 252 => SRRC_out <= X"B63";273 when 253 => SRRC_out <= X"B63";274 when 254 => SRRC_out <= X"B0B";275 when 255 => SRRC_out <= X"B0B";276 -- somme per il FIR 2277 when 256 => SRRC_out <= X"4F1";278 when 257 => SRRC_out <= X"4F1";279 when 258 => SRRC_out <= X"44F";280 when 259 => SRRC_out <= X"44F";281 when 260 => SRRC_out <= X"6BD";282 when 261 => SRRC_out <= X"6BD";283 when 262 => SRRC_out <= X"61A";284 when 263 => SRRC_out <= X"61A";


285 when 264 => SRRC_out <= X"B95";286 when 265 => SRRC_out <= X"B95";287 when 266 => SRRC_out <= X"AF2";288 when 267 => SRRC_out <= X"AF2";289 when 268 => SRRC_out <= X"D60";290 when 269 => SRRC_out <= X"D60";291 when 270 => SRRC_out <= X"CBE";292 when 271 => SRRC_out <= X"CBE";293 when 272 => SRRC_out <= X"2EA";294 when 273 => SRRC_out <= X"2EA";295 when 274 => SRRC_out <= X"248";296 when 275 => SRRC_out <= X"248";297 when 276 => SRRC_out <= X"4B6";298 when 277 => SRRC_out <= X"4B6";299 when 278 => SRRC_out <= X"413";300 when 279 => SRRC_out <= X"413";301 when 280 => SRRC_out <= X"98E";302 when 281 => SRRC_out <= X"98E";303 when 282 => SRRC_out <= X"8EB";304 when 283 => SRRC_out <= X"8EB";305 when 284 => SRRC_out <= X"B59";306 when 285 => SRRC_out <= X"B59";307 when 286 => SRRC_out <= X"AB7";308 when 287 => SRRC_out <= X"AB7";309 when 288 => SRRC_out <= X"53B";310 when 289 => SRRC_out <= X"53B";311 when 290 => SRRC_out <= X"499";312 when 291 => SRRC_out <= X"499";313 when 292 => SRRC_out <= X"706";314 when 293 => SRRC_out <= X"706";315 when 294 => SRRC_out <= X"664";316 when 295 => SRRC_out <= X"664";317 when 296 => SRRC_out <= X"BDE";318 when 297 => SRRC_out <= X"BDE";319 when 298 => SRRC_out <= X"B3C";320 when 299 => SRRC_out <= X"B3C";321 when 300 => SRRC_out <= X"DAA";322 when 301 => SRRC_out <= X"DAA";323 when 302 => SRRC_out <= X"D07";324 when 303 => SRRC_out <= X"D07";325 when 304 => SRRC_out <= X"334";326 when 305 => SRRC_out <= X"334";327 when 306 => SRRC_out <= X"292";328 when 307 => SRRC_out <= X"292";329 when 308 => SRRC_out <= X"4FF";330 when 309 => SRRC_out <= X"4FF";331 when 310 => SRRC_out <= X"45D";332 when 311 => SRRC_out <= X"45D";333 when 312 => SRRC_out <= X"9D7";334 when 313 => SRRC_out <= X"9D7";335 when 314 => SRRC_out <= X"935";336 when 315 => SRRC_out <= X"935";337 when 316 => SRRC_out <= X"BA3";338 when 317 => SRRC_out <= X"BA3";339 when 318 => SRRC_out <= X"B00";340 when 319 => SRRC_out <= X"B00";341 when 320 => SRRC_out <= X"500";342 when 321 => SRRC_out <= X"500";343 when 322 => SRRC_out <= X"45D";344 when 323 => SRRC_out <= X"45D";345 when 324 => SRRC_out <= X"6CB";346 when 325 => SRRC_out <= X"6CB";347 when 326 => SRRC_out <= X"629";348 when 327 => SRRC_out <= X"629";349 when 328 => SRRC_out <= X"BA3";350 when 329 => SRRC_out <= X"BA3";351 when 330 => SRRC_out <= X"B01";352 when 331 => SRRC_out <= X"B01";353 when 332 => SRRC_out <= X"D6E";354 when 333 => SRRC_out <= X"D6E";355 when 334 => SRRC_out <= X"CCC";356 when 335 => SRRC_out <= X"CCC";357 when 336 => SRRC_out <= X"2F9";358 when 337 => SRRC_out <= X"2F9";359 when 338 => SRRC_out <= X"256";360 when 339 => SRRC_out <= X"256";361 when 340 => SRRC_out <= X"4C4";362 when 341 => SRRC_out <= X"4C4";363 when 342 => SRRC_out <= X"422";364 when 343 => SRRC_out <= X"422";365 when 344 => SRRC_out <= X"99C";366 when 345 => SRRC_out <= X"99C";367 when 346 => SRRC_out <= X"8FA";368 when 347 => SRRC_out <= X"8FA";369 when 348 => SRRC_out <= X"B67";370 when 349 => SRRC_out <= X"B67";371 when 350 => SRRC_out <= X"AC5";372 when 351 => SRRC_out <= X"AC5";373 when 352 => SRRC_out <= X"549";374 when 353 => SRRC_out <= X"549";375 when 354 => SRRC_out <= X"4A7";376 when 355 => SRRC_out <= X"4A7";377 when 356 => SRRC_out <= X"715";378 when 357 => SRRC_out <= X"715";379 when 358 => SRRC_out <= X"672";380 when 359 => SRRC_out <= X"672";381 when 360 => SRRC_out <= X"BED";382 when 361 => SRRC_out <= X"BED";


383 when 362 => SRRC_out <= X"B4A";384 when 363 => SRRC_out <= X"B4A";385 when 364 => SRRC_out <= X"DB8";386 when 365 => SRRC_out <= X"DB8";387 when 366 => SRRC_out <= X"D16";388 when 367 => SRRC_out <= X"D16";389 when 368 => SRRC_out <= X"342";390 when 369 => SRRC_out <= X"342";391 when 370 => SRRC_out <= X"2A0";392 when 371 => SRRC_out <= X"2A0";393 when 372 => SRRC_out <= X"50E";394 when 373 => SRRC_out <= X"50E";395 when 374 => SRRC_out <= X"46B";396 when 375 => SRRC_out <= X"46B";397 when 376 => SRRC_out <= X"9E6";398 when 377 => SRRC_out <= X"9E6";399 when 378 => SRRC_out <= X"943";400 when 379 => SRRC_out <= X"943";401 when 380 => SRRC_out <= X"BB1";402 when 381 => SRRC_out <= X"BB1";403 when 382 => SRRC_out <= X"B0F";404 when 383 => SRRC_out <= X"B0F";405 -- somme per il FIR 3406 when 384 => SRRC_out <= X"4BC";407 when 385 => SRRC_out <= X"50D";408 when 386 => SRRC_out <= X"443";409 when 387 => SRRC_out <= X"493";410 when 388 => SRRC_out <= X"586";411 when 389 => SRRC_out <= X"5D6";412 when 390 => SRRC_out <= X"50D";413 when 391 => SRRC_out <= X"55D";414 when 392 => SRRC_out <= X"A02";415 when 393 => SRRC_out <= X"A53";416 when 394 => SRRC_out <= X"989";417 when 395 => SRRC_out <= X"9D9";418 when 396 => SRRC_out <= X"ACC";419 when 397 => SRRC_out <= X"B1C";420 when 398 => SRRC_out <= X"A53";421 when 399 => SRRC_out <= X"AA3";422 when 400 => SRRC_out <= X"586";423 when 401 => SRRC_out <= X"5D6";424 when 402 => SRRC_out <= X"50D";425 when 403 => SRRC_out <= X"55D";426 when 404 => SRRC_out <= X"64F";427 when 405 => SRRC_out <= X"6A0";428 when 406 => SRRC_out <= X"5D6";429 when 407 => SRRC_out <= X"627";430 when 408 => SRRC_out <= X"ACC";431 when 409 => SRRC_out <= X"B1C";432 when 410 => SRRC_out <= X"A53";433 when 411 => SRRC_out <= X"AA3";434 when 412 => SRRC_out <= X"B95";435 when 413 => SRRC_out <= X"BE6";436 when 414 => SRRC_out <= X"B1C";437 when 415 => SRRC_out <= X"B6D";438 when 416 => SRRC_out <= X"443";439 when 417 => SRRC_out <= X"493";440 when 418 => SRRC_out <= X"3CA";441 when 419 => SRRC_out <= X"41A";442 when 420 => SRRC_out <= X"50D";443 when 421 => SRRC_out <= X"55D";444 when 422 => SRRC_out <= X"494";445 when 423 => SRRC_out <= X"4E4";446 when 424 => SRRC_out <= X"989";447 when 425 => SRRC_out <= X"9D9";448 when 426 => SRRC_out <= X"910";449 when 427 => SRRC_out <= X"960";450 when 428 => SRRC_out <= X"A53";451 when 429 => SRRC_out <= X"AA3";452 when 430 => SRRC_out <= X"9DA";453 when 431 => SRRC_out <= X"A2A";454 when 432 => SRRC_out <= X"50D";455 when 433 => SRRC_out <= X"55D";456 when 434 => SRRC_out <= X"494";457 when 435 => SRRC_out <= X"4E4";458 when 436 => SRRC_out <= X"5D6";459 when 437 => SRRC_out <= X"627";460 when 438 => SRRC_out <= X"55D";461 when 439 => SRRC_out <= X"5AD";462 when 440 => SRRC_out <= X"A53";463 when 441 => SRRC_out <= X"AA3";464 when 442 => SRRC_out <= X"9DA";465 when 443 => SRRC_out <= X"A2A";466 when 444 => SRRC_out <= X"B1C";467 when 445 => SRRC_out <= X"B6D";468 when 446 => SRRC_out <= X"AA3";469 when 447 => SRRC_out <= X"AF3";470 when 448 => SRRC_out <= X"50D";471 when 449 => SRRC_out <= X"55D";472 when 450 => SRRC_out <= X"493";473 when 451 => SRRC_out <= X"4E4";474 when 452 => SRRC_out <= X"5D6";475 when 453 => SRRC_out <= X"626";476 when 454 => SRRC_out <= X"55D";477 when 455 => SRRC_out <= X"5AD";478 when 456 => SRRC_out <= X"A53";479 when 457 => SRRC_out <= X"AA3";480 when 458 => SRRC_out <= X"9D9";


481 when 459 => SRRC_out <= X"A2A";482 when 460 => SRRC_out <= X"B1C";483 when 461 => SRRC_out <= X"B6C";484 when 462 => SRRC_out <= X"AA3";485 when 463 => SRRC_out <= X"AF3";486 when 464 => SRRC_out <= X"5D6";487 when 465 => SRRC_out <= X"626";488 when 466 => SRRC_out <= X"55D";489 when 467 => SRRC_out <= X"5AD";490 when 468 => SRRC_out <= X"6A0";491 when 469 => SRRC_out <= X"6F0";492 when 470 => SRRC_out <= X"627";493 when 471 => SRRC_out <= X"677";494 when 472 => SRRC_out <= X"B1C";495 when 473 => SRRC_out <= X"B6C";496 when 474 => SRRC_out <= X"AA3";497 when 475 => SRRC_out <= X"AF3";498 when 476 => SRRC_out <= X"BE6";499 when 477 => SRRC_out <= X"C36";500 when 478 => SRRC_out <= X"B6D";501 when 479 => SRRC_out <= X"BBD";502 when 480 => SRRC_out <= X"493";503 when 481 => SRRC_out <= X"4E4";504 when 482 => SRRC_out <= X"41A";505 when 483 => SRRC_out <= X"46B";506 when 484 => SRRC_out <= X"55D";507 when 485 => SRRC_out <= X"5AD";508 when 486 => SRRC_out <= X"4E4";509 when 487 => SRRC_out <= X"534";510 when 488 => SRRC_out <= X"9D9";511 when 489 => SRRC_out <= X"A2A";512 when 490 => SRRC_out <= X"960";513 when 491 => SRRC_out <= X"9B1";514 when 492 => SRRC_out <= X"AA3";515 when 493 => SRRC_out <= X"AF3";516 when 494 => SRRC_out <= X"A2A";517 when 495 => SRRC_out <= X"A7A";518 when 496 => SRRC_out <= X"55D";519 when 497 => SRRC_out <= X"5AD";520 when 498 => SRRC_out <= X"4E4";521 when 499 => SRRC_out <= X"534";522 when 500 => SRRC_out <= X"627";523 when 501 => SRRC_out <= X"677";524 when 502 => SRRC_out <= X"5AD";525 when 503 => SRRC_out <= X"5FE";526 when 504 => SRRC_out <= X"AA3";527 when 505 => SRRC_out <= X"AF3";528 when 506 => SRRC_out <= X"A2A";529 when 507 => SRRC_out <= X"A7A";530 when 508 => SRRC_out <= X"B6D";531 when 509 => SRRC_out <= X"BBD";532 when 510 => SRRC_out <= X"AF3";533 when 511 => SRRC_out <= X"B44";534 when OTHERS => SRRC_out <= X"000";535 end case;536 end process;537 end ROMx4_arch;


1011 architecture ROMx6_arch of ROMx6 is12 begin13 process(address)14 variable addr : integer ;15 begin16 addr := conv_integer(address) ;17 case addr is18 -- somme per il FIR 019 when 0 => SRRC_out <= X"515";20 when 1 => SRRC_out <= X"515";21 when 2 => SRRC_out <= X"509";22 when 3 => SRRC_out <= X"509";23 when 4 => SRRC_out <= X"5A3";24 when 5 => SRRC_out <= X"5A3";25 when 6 => SRRC_out <= X"597";26 when 7 => SRRC_out <= X"597";27 when 8 => SRRC_out <= X"1C7";28 when 9 => SRRC_out <= X"1C7";29 when 10 => SRRC_out <= X"1BB";30 when 11 => SRRC_out <= X"1BB";31 when 12 => SRRC_out <= X"254";32 when 13 => SRRC_out <= X"254";


33 when 14 => SRRC_out <= X"248";34 when 15 => SRRC_out <= X"248";35 when 16 => SRRC_out <= X"C6C";36 when 17 => SRRC_out <= X"C6C";37 when 18 => SRRC_out <= X"C60";38 when 19 => SRRC_out <= X"C60";39 when 20 => SRRC_out <= X"CF9";40 when 21 => SRRC_out <= X"CF9";41 when 22 => SRRC_out <= X"CED";42 when 23 => SRRC_out <= X"CED";43 when 24 => SRRC_out <= X"91D";44 when 25 => SRRC_out <= X"91D";45 when 26 => SRRC_out <= X"911";46 when 27 => SRRC_out <= X"911";47 when 28 => SRRC_out <= X"9AA";48 when 29 => SRRC_out <= X"9AA";49 when 30 => SRRC_out <= X"99F";50 when 31 => SRRC_out <= X"99F";51 when 32 => SRRC_out <= X"6D8";52 when 33 => SRRC_out <= X"6D8";53 when 34 => SRRC_out <= X"6CC";54 when 35 => SRRC_out <= X"6CC";55 when 36 => SRRC_out <= X"765";56 when 37 => SRRC_out <= X"765";57 when 38 => SRRC_out <= X"759";58 when 39 => SRRC_out <= X"759";59 when 40 => SRRC_out <= X"389";60 when 41 => SRRC_out <= X"389";61 when 42 => SRRC_out <= X"37D";62 when 43 => SRRC_out <= X"37D";63 when 44 => SRRC_out <= X"416";64 when 45 => SRRC_out <= X"416";65 when 46 => SRRC_out <= X"40A";66 when 47 => SRRC_out <= X"40A";67 when 48 => SRRC_out <= X"E2E";68 when 49 => SRRC_out <= X"E2E";69 when 50 => SRRC_out <= X"E23";70 when 51 => SRRC_out <= X"E23";71 when 52 => SRRC_out <= X"EBC";72 when 53 => SRRC_out <= X"EBC";73 when 54 => SRRC_out <= X"EB0";74 when 55 => SRRC_out <= X"EB0";75 when 56 => SRRC_out <= X"AE0";76 when 57 => SRRC_out <= X"AE0";77 when 58 => SRRC_out <= X"AD4";78 when 59 => SRRC_out <= X"AD4";79 when 60 => SRRC_out <= X"B6D";80 when 61 => SRRC_out <= X"B6D";81 when 62 => SRRC_out <= X"B61";82 when 63 => SRRC_out <= X"B61";83 when 64 => SRRC_out <= X"49F";84 when 65 => SRRC_out <= X"49F";85 when 66 => SRRC_out <= X"493";86 when 67 => SRRC_out <= X"493";87 when 68 => SRRC_out <= X"52C";88 when 69 => SRRC_out <= X"52C";89 when 70 => SRRC_out <= X"520";90 when 71 => SRRC_out <= X"520";91 when 72 => SRRC_out <= X"150";92 when 73 => SRRC_out <= X"150";93 when 74 => SRRC_out <= X"144";94 when 75 => SRRC_out <= X"144";95 when 76 => SRRC_out <= X"1DD";96 when 77 => SRRC_out <= X"1DD";97 when 78 => SRRC_out <= X"1D2";98 when 79 => SRRC_out <= X"1D2";99 when 80 => SRRC_out <= X"BF6";

100 when 81 => SRRC_out <= X"BF6";101 when 82 => SRRC_out <= X"BEA";102 when 83 => SRRC_out <= X"BEA";103 when 84 => SRRC_out <= X"C83";104 when 85 => SRRC_out <= X"C83";105 when 86 => SRRC_out <= X"C77";106 when 87 => SRRC_out <= X"C77";107 when 88 => SRRC_out <= X"8A7";108 when 89 => SRRC_out <= X"8A7";109 when 90 => SRRC_out <= X"89B";110 when 91 => SRRC_out <= X"89B";111 when 92 => SRRC_out <= X"934";112 when 93 => SRRC_out <= X"934";113 when 94 => SRRC_out <= X"928";114 when 95 => SRRC_out <= X"928";115 when 96 => SRRC_out <= X"661";116 when 97 => SRRC_out <= X"661";117 when 98 => SRRC_out <= X"656";118 when 99 => SRRC_out <= X"656";119 when 100 => SRRC_out <= X"6EF";120 when 101 => SRRC_out <= X"6EF";121 when 102 => SRRC_out <= X"6E3";122 when 103 => SRRC_out <= X"6E3";123 when 104 => SRRC_out <= X"313";124 when 105 => SRRC_out <= X"313";125 when 106 => SRRC_out <= X"307";126 when 107 => SRRC_out <= X"307";127 when 108 => SRRC_out <= X"3A0";128 when 109 => SRRC_out <= X"3A0";129 when 110 => SRRC_out <= X"394";130 when 111 => SRRC_out <= X"394";


131 when 112 => SRRC_out <= X"DB8";132 when 113 => SRRC_out <= X"DB8";133 when 114 => SRRC_out <= X"DAC";134 when 115 => SRRC_out <= X"DAC";135 when 116 => SRRC_out <= X"E45";136 when 117 => SRRC_out <= X"E45";137 when 118 => SRRC_out <= X"E39";138 when 119 => SRRC_out <= X"E39";139 when 120 => SRRC_out <= X"A69";140 when 121 => SRRC_out <= X"A69";141 when 122 => SRRC_out <= X"A5D";142 when 123 => SRRC_out <= X"A5D";143 when 124 => SRRC_out <= X"AF7";144 when 125 => SRRC_out <= X"AF7";145 when 126 => SRRC_out <= X"AEB";146 when 127 => SRRC_out <= X"AEB";147 -- somme per il FIR 1148 when 128 => SRRC_out <= X"513";149 when 129 => SRRC_out <= X"513";150 when 130 => SRRC_out <= X"4D3";151 when 131 => SRRC_out <= X"4D3";152 when 132 => SRRC_out <= X"656";153 when 133 => SRRC_out <= X"656";154 when 134 => SRRC_out <= X"616";155 when 135 => SRRC_out <= X"616";156 when 136 => SRRC_out <= X"EFC";157 when 137 => SRRC_out <= X"EFC";158 when 138 => SRRC_out <= X"EBD";159 when 139 => SRRC_out <= X"EBD";160 when 140 => SRRC_out <= X"040";161 when 141 => SRRC_out <= X"040";162 when 142 => SRRC_out <= X"000";163 when 143 => SRRC_out <= X"000";164 when 144 => SRRC_out <= X"EFC";165 when 145 => SRRC_out <= X"EFC";166 when 146 => SRRC_out <= X"EBD";167 when 147 => SRRC_out <= X"EBD";168 when 148 => SRRC_out <= X"040";169 when 149 => SRRC_out <= X"040";170 when 150 => SRRC_out <= X"000";171 when 151 => SRRC_out <= X"000";172 when 152 => SRRC_out <= X"8E6";173 when 153 => SRRC_out <= X"8E6";174 when 154 => SRRC_out <= X"8A6";175 when 155 => SRRC_out <= X"8A6";176 when 156 => SRRC_out <= X"A29";177 when 157 => SRRC_out <= X"A29";178 when 158 => SRRC_out <= X"9EA";179 when 159 => SRRC_out <= X"9EA";180 when 160 => SRRC_out <= X"656";181 when 161 => SRRC_out <= X"656";182 when 162 => SRRC_out <= X"616";183 when 163 => SRRC_out <= X"616";184 when 164 => SRRC_out <= X"79A";185 when 165 => SRRC_out <= X"79A";186 when 166 => SRRC_out <= X"75A";187 when 167 => SRRC_out <= X"75A";188 when 168 => SRRC_out <= X"040";189 when 169 => SRRC_out <= X"040";190 when 170 => SRRC_out <= X"000";191 when 171 => SRRC_out <= X"000";192 when 172 => SRRC_out <= X"183";193 when 173 => SRRC_out <= X"183";194 when 174 => SRRC_out <= X"143";195 when 175 => SRRC_out <= X"143";196 when 176 => SRRC_out <= X"040";197 when 177 => SRRC_out <= X"040";198 when 178 => SRRC_out <= X"000";199 when 179 => SRRC_out <= X"000";200 when 180 => SRRC_out <= X"183";201 when 181 => SRRC_out <= X"183";202 when 182 => SRRC_out <= X"143";203 when 183 => SRRC_out <= X"143";204 when 184 => SRRC_out <= X"A29";205 when 185 => SRRC_out <= X"A29";206 when 186 => SRRC_out <= X"9EA";207 when 187 => SRRC_out <= X"9EA";208 when 188 => SRRC_out <= X"B6D";209 when 189 => SRRC_out <= X"B6D";210 when 190 => SRRC_out <= X"B2D";211 when 191 => SRRC_out <= X"B2D";212 when 192 => SRRC_out <= X"4D3";213 when 193 => SRRC_out <= X"4D3";214 when 194 => SRRC_out <= X"493";215 when 195 => SRRC_out <= X"493";216 when 196 => SRRC_out <= X"616";217 when 197 => SRRC_out <= X"616";218 when 198 => SRRC_out <= X"5D7";219 when 199 => SRRC_out <= X"5D7";220 when 200 => SRRC_out <= X"EBD";221 when 201 => SRRC_out <= X"EBD";222 when 202 => SRRC_out <= X"E7D";223 when 203 => SRRC_out <= X"E7D";224 when 204 => SRRC_out <= X"000";225 when 205 => SRRC_out <= X"000";226 when 206 => SRRC_out <= X"FC0";227 when 207 => SRRC_out <= X"FC0";228 when 208 => SRRC_out <= X"EBD";


229 when 209 => SRRC_out <= X"EBD";230 when 210 => SRRC_out <= X"E7D";231 when 211 => SRRC_out <= X"E7D";232 when 212 => SRRC_out <= X"000";233 when 213 => SRRC_out <= X"000";234 when 214 => SRRC_out <= X"FC0";235 when 215 => SRRC_out <= X"FC0";236 when 216 => SRRC_out <= X"8A6";237 when 217 => SRRC_out <= X"8A6";238 when 218 => SRRC_out <= X"866";239 when 219 => SRRC_out <= X"866";240 when 220 => SRRC_out <= X"9EA";241 when 221 => SRRC_out <= X"9EA";242 when 222 => SRRC_out <= X"9AA";243 when 223 => SRRC_out <= X"9AA";244 when 224 => SRRC_out <= X"616";245 when 225 => SRRC_out <= X"616";246 when 226 => SRRC_out <= X"5D7";247 when 227 => SRRC_out <= X"5D7";248 when 228 => SRRC_out <= X"75A";249 when 229 => SRRC_out <= X"75A";250 when 230 => SRRC_out <= X"71A";251 when 231 => SRRC_out <= X"71A";252 when 232 => SRRC_out <= X"000";253 when 233 => SRRC_out <= X"000";254 when 234 => SRRC_out <= X"FC0";255 when 235 => SRRC_out <= X"FC0";256 when 236 => SRRC_out <= X"143";257 when 237 => SRRC_out <= X"143";258 when 238 => SRRC_out <= X"104";259 when 239 => SRRC_out <= X"104";260 when 240 => SRRC_out <= X"000";261 when 241 => SRRC_out <= X"000";262 when 242 => SRRC_out <= X"FC0";263 when 243 => SRRC_out <= X"FC0";264 when 244 => SRRC_out <= X"143";265 when 245 => SRRC_out <= X"143";266 when 246 => SRRC_out <= X"104";267 when 247 => SRRC_out <= X"104";268 when 248 => SRRC_out <= X"9EA";269 when 249 => SRRC_out <= X"9EA";270 when 250 => SRRC_out <= X"9AA";271 when 251 => SRRC_out <= X"9AA";272 when 252 => SRRC_out <= X"B2D";273 when 253 => SRRC_out <= X"B2D";274 when 254 => SRRC_out <= X"AED";275 when 255 => SRRC_out <= X"AED";276 -- somme per il FIR 2277 when 256 => SRRC_out <= X"515";278 when 257 => SRRC_out <= X"515";279 when 258 => SRRC_out <= X"49F";280 when 259 => SRRC_out <= X"49F";281 when 260 => SRRC_out <= X"6D8";282 when 261 => SRRC_out <= X"6D8";283 when 262 => SRRC_out <= X"661";284 when 263 => SRRC_out <= X"661";285 when 264 => SRRC_out <= X"C6C";286 when 265 => SRRC_out <= X"C6C";287 when 266 => SRRC_out <= X"BF6";288 when 267 => SRRC_out <= X"BF6";289 when 268 => SRRC_out <= X"E2E";290 when 269 => SRRC_out <= X"E2E";291 when 270 => SRRC_out <= X"DB8";292 when 271 => SRRC_out <= X"DB8";293 when 272 => SRRC_out <= X"1C7";294 when 273 => SRRC_out <= X"1C7";295 when 274 => SRRC_out <= X"150";296 when 275 => SRRC_out <= X"150";297 when 276 => SRRC_out <= X"389";298 when 277 => SRRC_out <= X"389";299 when 278 => SRRC_out <= X"313";300 when 279 => SRRC_out <= X"313";301 when 280 => SRRC_out <= X"91D";302 when 281 => SRRC_out <= X"91D";303 when 282 => SRRC_out <= X"8A7";304 when 283 => SRRC_out <= X"8A7";305 when 284 => SRRC_out <= X"AE0";306 when 285 => SRRC_out <= X"AE0";307 when 286 => SRRC_out <= X"A69";308 when 287 => SRRC_out <= X"A69";309 when 288 => SRRC_out <= X"5A3";310 when 289 => SRRC_out <= X"5A3";311 when 290 => SRRC_out <= X"52C";312 when 291 => SRRC_out <= X"52C";313 when 292 => SRRC_out <= X"765";314 when 293 => SRRC_out <= X"765";315 when 294 => SRRC_out <= X"6EF";316 when 295 => SRRC_out <= X"6EF";317 when 296 => SRRC_out <= X"CF9";318 when 297 => SRRC_out <= X"CF9";319 when 298 => SRRC_out <= X"C83";320 when 299 => SRRC_out <= X"C83";321 when 300 => SRRC_out <= X"EBC";322 when 301 => SRRC_out <= X"EBC";323 when 302 => SRRC_out <= X"E45";324 when 303 => SRRC_out <= X"E45";325 when 304 => SRRC_out <= X"254";326 when 305 => SRRC_out <= X"254";


327 when 306 => SRRC_out <= X"1DD";328 when 307 => SRRC_out <= X"1DD";329 when 308 => SRRC_out <= X"416";330 when 309 => SRRC_out <= X"416";331 when 310 => SRRC_out <= X"3A0";332 when 311 => SRRC_out <= X"3A0";333 when 312 => SRRC_out <= X"9AA";334 when 313 => SRRC_out <= X"9AA";335 when 314 => SRRC_out <= X"934";336 when 315 => SRRC_out <= X"934";337 when 316 => SRRC_out <= X"B6D";338 when 317 => SRRC_out <= X"B6D";339 when 318 => SRRC_out <= X"AF7";340 when 319 => SRRC_out <= X"AF7";341 when 320 => SRRC_out <= X"509";342 when 321 => SRRC_out <= X"509";343 when 322 => SRRC_out <= X"493";344 when 323 => SRRC_out <= X"493";345 when 324 => SRRC_out <= X"6CC";346 when 325 => SRRC_out <= X"6CC";347 when 326 => SRRC_out <= X"656";348 when 327 => SRRC_out <= X"656";349 when 328 => SRRC_out <= X"C60";350 when 329 => SRRC_out <= X"C60";351 when 330 => SRRC_out <= X"BEA";352 when 331 => SRRC_out <= X"BEA";353 when 332 => SRRC_out <= X"E23";354 when 333 => SRRC_out <= X"E23";355 when 334 => SRRC_out <= X"DAC";356 when 335 => SRRC_out <= X"DAC";357 when 336 => SRRC_out <= X"1BB";358 when 337 => SRRC_out <= X"1BB";359 when 338 => SRRC_out <= X"144";360 when 339 => SRRC_out <= X"144";361 when 340 => SRRC_out <= X"37D";362 when 341 => SRRC_out <= X"37D";363 when 342 => SRRC_out <= X"307";364 when 343 => SRRC_out <= X"307";365 when 344 => SRRC_out <= X"911";366 when 345 => SRRC_out <= X"911";367 when 346 => SRRC_out <= X"89B";368 when 347 => SRRC_out <= X"89B";369 when 348 => SRRC_out <= X"AD4";370 when 349 => SRRC_out <= X"AD4";371 when 350 => SRRC_out <= X"A5D";372 when 351 => SRRC_out <= X"A5D";373 when 352 => SRRC_out <= X"597";374 when 353 => SRRC_out <= X"597";375 when 354 => SRRC_out <= X"520";376 when 355 => SRRC_out <= X"520";377 when 356 => SRRC_out <= X"759";378 when 357 => SRRC_out <= X"759";379 when 358 => SRRC_out <= X"6E3";380 when 359 => SRRC_out <= X"6E3";381 when 360 => SRRC_out <= X"CED";382 when 361 => SRRC_out <= X"CED";383 when 362 => SRRC_out <= X"C77";384 when 363 => SRRC_out <= X"C77";385 when 364 => SRRC_out <= X"EB0";386 when 365 => SRRC_out <= X"EB0";387 when 366 => SRRC_out <= X"E39";388 when 367 => SRRC_out <= X"E39";389 when 368 => SRRC_out <= X"248";390 when 369 => SRRC_out <= X"248";391 when 370 => SRRC_out <= X"1D2";392 when 371 => SRRC_out <= X"1D2";393 when 372 => SRRC_out <= X"40A";394 when 373 => SRRC_out <= X"40A";395 when 374 => SRRC_out <= X"394";396 when 375 => SRRC_out <= X"394";397 when 376 => SRRC_out <= X"99F";398 when 377 => SRRC_out <= X"99F";399 when 378 => SRRC_out <= X"928";400 when 379 => SRRC_out <= X"928";401 when 380 => SRRC_out <= X"B61";402 when 381 => SRRC_out <= X"B61";403 when 382 => SRRC_out <= X"AEB";404 when 383 => SRRC_out <= X"AEB";405 -- somme per il FIR 3406 when 384 => SRRC_out <= X"505";407 when 385 => SRRC_out <= X"52F";408 when 386 => SRRC_out <= X"471";409 when 387 => SRRC_out <= X"49B";410 when 388 => SRRC_out <= X"6BB";411 when 389 => SRRC_out <= X"6E6";412 when 390 => SRRC_out <= X"628";413 when 391 => SRRC_out <= X"652";414 when 392 => SRRC_out <= X"A8A";415 when 393 => SRRC_out <= X"AB4";416 when 394 => SRRC_out <= X"9F6";417 when 395 => SRRC_out <= X"A21";418 when 396 => SRRC_out <= X"C41";419 when 397 => SRRC_out <= X"C6B";420 when 398 => SRRC_out <= X"BAD";421 when 399 => SRRC_out <= X"BD7";422 when 400 => SRRC_out <= X"429";423 when 401 => SRRC_out <= X"453";424 when 402 => SRRC_out <= X"395";


425 when 403 => SRRC_out <= X"3BF";426 when 404 => SRRC_out <= X"5DF";427 when 405 => SRRC_out <= X"60A";428 when 406 => SRRC_out <= X"54B";429 when 407 => SRRC_out <= X"576";430 when 408 => SRRC_out <= X"9AE";431 when 409 => SRRC_out <= X"9D8";432 when 410 => SRRC_out <= X"91A";433 when 411 => SRRC_out <= X"944";434 when 412 => SRRC_out <= X"B64";435 when 413 => SRRC_out <= X"B8F";436 when 414 => SRRC_out <= X"AD1";437 when 415 => SRRC_out <= X"AFB";438 when 416 => SRRC_out <= X"4EF";439 when 417 => SRRC_out <= X"519";440 when 418 => SRRC_out <= X"45B";441 when 419 => SRRC_out <= X"485";442 when 420 => SRRC_out <= X"6A5";443 when 421 => SRRC_out <= X"6D0";444 when 422 => SRRC_out <= X"611";445 when 423 => SRRC_out <= X"63C";446 when 424 => SRRC_out <= X"A74";447 when 425 => SRRC_out <= X"A9E";448 when 426 => SRRC_out <= X"9E0";449 when 427 => SRRC_out <= X"A0A";450 when 428 => SRRC_out <= X"C2A";451 when 429 => SRRC_out <= X"C55";452 when 430 => SRRC_out <= X"B96";453 when 431 => SRRC_out <= X"BC1";454 when 432 => SRRC_out <= X"413";455 when 433 => SRRC_out <= X"43D";456 when 434 => SRRC_out <= X"37F";457 when 435 => SRRC_out <= X"3A9";458 when 436 => SRRC_out <= X"5C9";459 when 437 => SRRC_out <= X"5F4";460 when 438 => SRRC_out <= X"535";461 when 439 => SRRC_out <= X"560";462 when 440 => SRRC_out <= X"998";463 when 441 => SRRC_out <= X"9C2";464 when 442 => SRRC_out <= X"904";465 when 443 => SRRC_out <= X"92E";466 when 444 => SRRC_out <= X"B4E";467 when 445 => SRRC_out <= X"B79";468 when 446 => SRRC_out <= X"ABA";469 when 447 => SRRC_out <= X"AE5";470 when 448 => SRRC_out <= X"51B";471 when 449 => SRRC_out <= X"546";472 when 450 => SRRC_out <= X"487";473 when 451 => SRRC_out <= X"4B2";474 when 452 => SRRC_out <= X"6D2";475 when 453 => SRRC_out <= X"6FC";476 when 454 => SRRC_out <= X"63E";477 when 455 => SRRC_out <= X"668";478 when 456 => SRRC_out <= X"AA0";479 when 457 => SRRC_out <= X"ACB";480 when 458 => SRRC_out <= X"A0C";481 when 459 => SRRC_out <= X"A37";482 when 460 => SRRC_out <= X"C57";483 when 461 => SRRC_out <= X"C81";484 when 462 => SRRC_out <= X"BC3";485 when 463 => SRRC_out <= X"BED";486 when 464 => SRRC_out <= X"43F";487 when 465 => SRRC_out <= X"46A";488 when 466 => SRRC_out <= X"3AB";489 when 467 => SRRC_out <= X"3D6";490 when 468 => SRRC_out <= X"5F6";491 when 469 => SRRC_out <= X"620";492 when 470 => SRRC_out <= X"562";493 when 471 => SRRC_out <= X"58C";494 when 472 => SRRC_out <= X"9C4";495 when 473 => SRRC_out <= X"9EF";496 when 474 => SRRC_out <= X"930";497 when 475 => SRRC_out <= X"95B";498 when 476 => SRRC_out <= X"B7B";499 when 477 => SRRC_out <= X"BA5";500 when 478 => SRRC_out <= X"AE7";501 when 479 => SRRC_out <= X"B11";502 when 480 => SRRC_out <= X"505";503 when 481 => SRRC_out <= X"52F";504 when 482 => SRRC_out <= X"471";505 when 483 => SRRC_out <= X"49C";506 when 484 => SRRC_out <= X"6BC";507 when 485 => SRRC_out <= X"6E6";508 when 486 => SRRC_out <= X"628";509 when 487 => SRRC_out <= X"652";510 when 488 => SRRC_out <= X"A8A";511 when 489 => SRRC_out <= X"AB5";512 when 490 => SRRC_out <= X"9F6";513 when 491 => SRRC_out <= X"A21";514 when 492 => SRRC_out <= X"C41";515 when 493 => SRRC_out <= X"C6B";516 when 494 => SRRC_out <= X"BAD";517 when 495 => SRRC_out <= X"BD7";518 when 496 => SRRC_out <= X"429";519 when 497 => SRRC_out <= X"453";520 when 498 => SRRC_out <= X"395";521 when 499 => SRRC_out <= X"3BF";522 when 500 => SRRC_out <= X"5DF";


523 when 501 => SRRC_out <= X"60A";524 when 502 => SRRC_out <= X"54C";525 when 503 => SRRC_out <= X"576";526 when 504 => SRRC_out <= X"9AE";527 when 505 => SRRC_out <= X"9D8";528 when 506 => SRRC_out <= X"91A";529 when 507 => SRRC_out <= X"945";530 when 508 => SRRC_out <= X"B65";531 when 509 => SRRC_out <= X"B8F";532 when 510 => SRRC_out <= X"AD1";533 when 511 => SRRC_out <= X"AFB";534 -- somme per il FIR 4535 when 512 => SRRC_out <= X"508";536 when 513 => SRRC_out <= X"52D";537 when 514 => SRRC_out <= X"48E";538 when 515 => SRRC_out <= X"4B4";539 when 516 => SRRC_out <= X"5E5";540 when 517 => SRRC_out <= X"60B";541 when 518 => SRRC_out <= X"56C";542 when 519 => SRRC_out <= X"591";543 when 520 => SRRC_out <= X"9E5";544 when 521 => SRRC_out <= X"A0B";545 when 522 => SRRC_out <= X"96B";546 when 523 => SRRC_out <= X"991";547 when 524 => SRRC_out <= X"AC2";548 when 525 => SRRC_out <= X"AE8";549 when 526 => SRRC_out <= X"A49";550 when 527 => SRRC_out <= X"A6F";551 when 528 => SRRC_out <= X"5E5";552 when 529 => SRRC_out <= X"60B";553 when 530 => SRRC_out <= X"56C";554 when 531 => SRRC_out <= X"591";555 when 532 => SRRC_out <= X"6C3";556 when 533 => SRRC_out <= X"6E9";557 when 534 => SRRC_out <= X"649";558 when 535 => SRRC_out <= X"66F";559 when 536 => SRRC_out <= X"AC2";560 when 537 => SRRC_out <= X"AE8";561 when 538 => SRRC_out <= X"A49";562 when 539 => SRRC_out <= X"A6F";563 when 540 => SRRC_out <= X"BA0";564 when 541 => SRRC_out <= X"BC6";565 when 542 => SRRC_out <= X"B26";566 when 543 => SRRC_out <= X"B4C";567 when 544 => SRRC_out <= X"48E";568 when 545 => SRRC_out <= X"4B4";569 when 546 => SRRC_out <= X"414";570 when 547 => SRRC_out <= X"43A";571 when 548 => SRRC_out <= X"56C";572 when 549 => SRRC_out <= X"591";573 when 550 => SRRC_out <= X"4F2";574 when 551 => SRRC_out <= X"518";575 when 552 => SRRC_out <= X"96B";576 when 553 => SRRC_out <= X"991";577 when 554 => SRRC_out <= X"8F1";578 when 555 => SRRC_out <= X"917";579 when 556 => SRRC_out <= X"A49";580 when 557 => SRRC_out <= X"A6F";581 when 558 => SRRC_out <= X"9CF";582 when 559 => SRRC_out <= X"9F5";583 when 560 => SRRC_out <= X"56C";584 when 561 => SRRC_out <= X"591";585 when 562 => SRRC_out <= X"4F2";586 when 563 => SRRC_out <= X"518";587 when 564 => SRRC_out <= X"649";588 when 565 => SRRC_out <= X"66F";589 when 566 => SRRC_out <= X"5D0";590 when 567 => SRRC_out <= X"5F5";591 when 568 => SRRC_out <= X"A49";592 when 569 => SRRC_out <= X"A6F";593 when 570 => SRRC_out <= X"9CF";594 when 571 => SRRC_out <= X"9F5";595 when 572 => SRRC_out <= X"B26";596 when 573 => SRRC_out <= X"B4C";597 when 574 => SRRC_out <= X"AAD";598 when 575 => SRRC_out <= X"AD3";599 when 576 => SRRC_out <= X"52D";600 when 577 => SRRC_out <= X"553";601 when 578 => SRRC_out <= X"4B4";602 when 579 => SRRC_out <= X"4DA";603 when 580 => SRRC_out <= X"60B";604 when 581 => SRRC_out <= X"631";605 when 582 => SRRC_out <= X"591";606 when 583 => SRRC_out <= X"5B7";607 when 584 => SRRC_out <= X"A0B";608 when 585 => SRRC_out <= X"A30";609 when 586 => SRRC_out <= X"991";610 when 587 => SRRC_out <= X"9B7";611 when 588 => SRRC_out <= X"AE8";612 when 589 => SRRC_out <= X"B0E";613 when 590 => SRRC_out <= X"A6F";614 when 591 => SRRC_out <= X"A94";615 when 592 => SRRC_out <= X"60B";616 when 593 => SRRC_out <= X"631";617 when 594 => SRRC_out <= X"591";618 when 595 => SRRC_out <= X"5B7";619 when 596 => SRRC_out <= X"6E9";620 when 597 => SRRC_out <= X"70F";


621 when 598 => SRRC_out <= X"66F";622 when 599 => SRRC_out <= X"695";623 when 600 => SRRC_out <= X"AE8";624 when 601 => SRRC_out <= X"B0E";625 when 602 => SRRC_out <= X"A6F";626 when 603 => SRRC_out <= X"A94";627 when 604 => SRRC_out <= X"BC6";628 when 605 => SRRC_out <= X"BEC";629 when 606 => SRRC_out <= X"B4C";630 when 607 => SRRC_out <= X"B72";631 when 608 => SRRC_out <= X"4B4";632 when 609 => SRRC_out <= X"4DA";633 when 610 => SRRC_out <= X"43A";634 when 611 => SRRC_out <= X"460";635 when 612 => SRRC_out <= X"591";636 when 613 => SRRC_out <= X"5B7";637 when 614 => SRRC_out <= X"518";638 when 615 => SRRC_out <= X"53E";639 when 616 => SRRC_out <= X"991";640 when 617 => SRRC_out <= X"9B7";641 when 618 => SRRC_out <= X"917";642 when 619 => SRRC_out <= X"93D";643 when 620 => SRRC_out <= X"A6F";644 when 621 => SRRC_out <= X"A94";645 when 622 => SRRC_out <= X"9F5";646 when 623 => SRRC_out <= X"A1B";647 when 624 => SRRC_out <= X"591";648 when 625 => SRRC_out <= X"5B7";649 when 626 => SRRC_out <= X"518";650 when 627 => SRRC_out <= X"53E";651 when 628 => SRRC_out <= X"66F";652 when 629 => SRRC_out <= X"695";653 when 630 => SRRC_out <= X"5F5";654 when 631 => SRRC_out <= X"61B";655 when 632 => SRRC_out <= X"A6F";656 when 633 => SRRC_out <= X"A94";657 when 634 => SRRC_out <= X"9F5";658 when 635 => SRRC_out <= X"A1B";659 when 636 => SRRC_out <= X"B4C";660 when 637 => SRRC_out <= X"B72";661 when 638 => SRRC_out <= X"AD3";662 when 639 => SRRC_out <= X"AF8";663 -- somme per il FIR 5664 when 640 => SRRC_out <= X"505";665 when 641 => SRRC_out <= X"51B";666 when 642 => SRRC_out <= X"4EF";667 when 643 => SRRC_out <= X"505";668 when 644 => SRRC_out <= X"429";669 when 645 => SRRC_out <= X"43F";670 when 646 => SRRC_out <= X"413";671 when 647 => SRRC_out <= X"429";672 when 648 => SRRC_out <= X"A8A";673 when 649 => SRRC_out <= X"AA0";674 when 650 => SRRC_out <= X"A74";675 when 651 => SRRC_out <= X"A8A";676 when 652 => SRRC_out <= X"9AE";677 when 653 => SRRC_out <= X"9C4";678 when 654 => SRRC_out <= X"998";679 when 655 => SRRC_out <= X"9AE";680 when 656 => SRRC_out <= X"6BB";681 when 657 => SRRC_out <= X"6D2";682 when 658 => SRRC_out <= X"6A5";683 when 659 => SRRC_out <= X"6BC";684 when 660 => SRRC_out <= X"5DF";685 when 661 => SRRC_out <= X"5F6";686 when 662 => SRRC_out <= X"5C9";687 when 663 => SRRC_out <= X"5DF";688 when 664 => SRRC_out <= X"C41";689 when 665 => SRRC_out <= X"C57";690 when 666 => SRRC_out <= X"C2A";691 when 667 => SRRC_out <= X"C41";692 when 668 => SRRC_out <= X"B64";693 when 669 => SRRC_out <= X"B7B";694 when 670 => SRRC_out <= X"B4E";695 when 671 => SRRC_out <= X"B65";696 when 672 => SRRC_out <= X"471";697 when 673 => SRRC_out <= X"487";698 when 674 => SRRC_out <= X"45B";699 when 675 => SRRC_out <= X"471";700 when 676 => SRRC_out <= X"395";701 when 677 => SRRC_out <= X"3AB";702 when 678 => SRRC_out <= X"37F";703 when 679 => SRRC_out <= X"395";704 when 680 => SRRC_out <= X"9F6";705 when 681 => SRRC_out <= X"A0C";706 when 682 => SRRC_out <= X"9E0";707 when 683 => SRRC_out <= X"9F6";708 when 684 => SRRC_out <= X"91A";709 when 685 => SRRC_out <= X"930";710 when 686 => SRRC_out <= X"904";711 when 687 => SRRC_out <= X"91A";712 when 688 => SRRC_out <= X"628";713 when 689 => SRRC_out <= X"63E";714 when 690 => SRRC_out <= X"611";715 when 691 => SRRC_out <= X"628";716 when 692 => SRRC_out <= X"54B";717 when 693 => SRRC_out <= X"562";718 when 694 => SRRC_out <= X"535";


719 when 695 => SRRC_out <= X"54C";720 when 696 => SRRC_out <= X"BAD";721 when 697 => SRRC_out <= X"BC3";722 when 698 => SRRC_out <= X"B96";723 when 699 => SRRC_out <= X"BAD";724 when 700 => SRRC_out <= X"AD1";725 when 701 => SRRC_out <= X"AE7";726 when 702 => SRRC_out <= X"ABA";727 when 703 => SRRC_out <= X"AD1";728 when 704 => SRRC_out <= X"52F";729 when 705 => SRRC_out <= X"546";730 when 706 => SRRC_out <= X"519";731 when 707 => SRRC_out <= X"52F";732 when 708 => SRRC_out <= X"453";733 when 709 => SRRC_out <= X"46A";734 when 710 => SRRC_out <= X"43D";735 when 711 => SRRC_out <= X"453";736 when 712 => SRRC_out <= X"AB4";737 when 713 => SRRC_out <= X"ACB";738 when 714 => SRRC_out <= X"A9E";739 when 715 => SRRC_out <= X"AB5";740 when 716 => SRRC_out <= X"9D8";741 when 717 => SRRC_out <= X"9EF";742 when 718 => SRRC_out <= X"9C2";743 when 719 => SRRC_out <= X"9D8";744 when 720 => SRRC_out <= X"6E6";745 when 721 => SRRC_out <= X"6FC";746 when 722 => SRRC_out <= X"6D0";747 when 723 => SRRC_out <= X"6E6";748 when 724 => SRRC_out <= X"60A";749 when 725 => SRRC_out <= X"620";750 when 726 => SRRC_out <= X"5F4";751 when 727 => SRRC_out <= X"60A";752 when 728 => SRRC_out <= X"C6B";753 when 729 => SRRC_out <= X"C81";754 when 730 => SRRC_out <= X"C55";755 when 731 => SRRC_out <= X"C6B";756 when 732 => SRRC_out <= X"B8F";757 when 733 => SRRC_out <= X"BA5";758 when 734 => SRRC_out <= X"B79";759 when 735 => SRRC_out <= X"B8F";760 when 736 => SRRC_out <= X"49B";761 when 737 => SRRC_out <= X"4B2";762 when 738 => SRRC_out <= X"485";763 when 739 => SRRC_out <= X"49C";764 when 740 => SRRC_out <= X"3BF";765 when 741 => SRRC_out <= X"3D6";766 when 742 => SRRC_out <= X"3A9";767 when 743 => SRRC_out <= X"3BF";768 when 744 => SRRC_out <= X"A21";769 when 745 => SRRC_out <= X"A37";770 when 746 => SRRC_out <= X"A0A";771 when 747 => SRRC_out <= X"A21";772 when 748 => SRRC_out <= X"944";773 when 749 => SRRC_out <= X"95B";774 when 750 => SRRC_out <= X"92E";775 when 751 => SRRC_out <= X"945";776 when 752 => SRRC_out <= X"652";777 when 753 => SRRC_out <= X"668";778 when 754 => SRRC_out <= X"63C";779 when 755 => SRRC_out <= X"652";780 when 756 => SRRC_out <= X"576";781 when 757 => SRRC_out <= X"58C";782 when 758 => SRRC_out <= X"560";783 when 759 => SRRC_out <= X"576";784 when 760 => SRRC_out <= X"BD7";785 when 761 => SRRC_out <= X"BED";786 when 762 => SRRC_out <= X"BC1";787 when 763 => SRRC_out <= X"BD7";788 when 764 => SRRC_out <= X"AFB";789 when 765 => SRRC_out <= X"B11";790 when 766 => SRRC_out <= X"AE5";791 when 767 => SRRC_out <= X"AFB";792 when OTHERS => SRRC_out <= X"000";793 end case;794 end process;795 end ROMx6_arch;

Listato F.3.9: shift reg.vhd1 library IEEE;2 use IEEE.std_logic_1164.all;34 entity shift_reg is5 port (6 clk : in std_logic ;7 clk_en : in std_logic ;8 reset : in std_logic ;9 in_reg : in std_logic ;

10 out_ffd_1 : out std_logic ;11 out_ffd_2 : out std_logic ;12 out_ffd_3 : out std_logic ;


13 out_ffd_4 : out std_logic ;14 out_ffd_5 : out std_logic ;15 out_ffd_6 : out std_logic16 );17 end entity;1819 architecture shift_reg_arch of shift_reg is20 signal temp_out_reg : std_logic_vector(5 downto 0);21 begin22 process(clk, clk_en, reset)23 begin24 if reset = ’1’ then25 temp_out_reg <= "000000";26 elsif rising_edge(clk) then27 if clk_en = ’1’ then28 temp_out_reg <= in_reg & temp_out_reg(5 downto 1);29 end if;30 end if;31 end process;32 out_ffd_6 <= temp_out_reg(0);33 out_ffd_5 <= temp_out_reg(1);34 out_ffd_4 <= temp_out_reg(2);35 out_ffd_3 <= temp_out_reg(3);36 out_ffd_2 <= temp_out_reg(4);37 out_ffd_1 <= temp_out_reg(5);38 end architecture;

Listato F.4.1: Modulator BlockRAM.vhd1 library IEEE;2 use IEEE.std_logic_1164.all;34 entity Modulator_BlockRAM is5 port(6 clk : in STD_LOGIC;7 reset : in STD_LOGIC;8 to_SRRC_I : in STD_LOGIC;9 to_SRRC_Q : in STD_LOGIC;

10 rate_sel : in STD_LOGIC_VECTOR(1 downto 0);11 clk_2_analyzer : out STD_LOGIC;12 QPSK_out : out STD_LOGIC_VECTOR(11 downto 0)13 );14 end Modulator_BlockRAM;1516 architecture Modulator_BlockRAM of Modulator_BlockRAM is17 component adder_I_Q18 port (19 QPSK_I : in STD_LOGIC_VECTOR(11 downto 0);20 QPSK_Q : in STD_LOGIC_VECTOR(11 downto 0);21 clk : in STD_LOGIC;22 reset : in STD_LOGIC;23 QPSK_out : out STD_LOGIC_VECTOR(11 downto 0)24 );25 end component;26 component counter27 port (28 clk : in STD_LOGIC;29 rate_sel : in STD_LOGIC_VECTOR(1 downto 0);30 reset : in STD_LOGIC;31 clk_en : out STD_LOGIC;32 count : out STD_LOGIC_VECTOR(2 downto 0)33 );34 end component;35 component multiplier_I_Q36 port (37 clk : in STD_LOGIC;38 from_NCO : in STD_LOGIC_VECTOR(1 downto 0);39 from_SRRC : in STD_LOGIC_VECTOR(11 downto 0);40 out_mult : out STD_LOGIC_VECTOR(11 downto 0)41 );42 end component;43 component NCO_basic44 port (45 clk : in STD_LOGIC;46 reset : in STD_LOGIC;47 cosine : out STD_LOGIC_VECTOR(1 downto 0);48 sine : out STD_LOGIC_VECTOR(1 downto 0)49 );50 end component;51 component srrc_x_n52 port (53 clk : in STD_LOGIC;54 clk_en : in STD_LOGIC;55 fir_sel : in STD_LOGIC_VECTOR(2 downto 0);56 in_fir_MSB : in STD_LOGIC;57 rate_sel : in STD_LOGIC_VECTOR(1 downto 0);58 reset : in STD_LOGIC;59 out_srrc : out STD_LOGIC_VECTOR(11 downto 0)


60 );61 end component;62 ---- Signal declarations used on the diagram ----63 signal clk_en : STD_LOGIC;64 signal cosine : STD_LOGIC_VECTOR (1 downto 0);65 signal count_n : STD_LOGIC_VECTOR (2 downto 0);66 signal QPSK_I : STD_LOGIC_VECTOR (11 downto 0);67 signal QPSK_Q : STD_LOGIC_VECTOR (11 downto 0);68 signal sine : STD_LOGIC_VECTOR (1 downto 0);69 signal to_mult_I : STD_LOGIC_VECTOR (11 downto 0);70 signal to_mult_Q : STD_LOGIC_VECTOR (11 downto 0);7172 begin73 U1 : srrc_x_n74 port map(75 clk => clk,76 clk_en => clk_en,77 fir_sel => count_n,78 in_fir_MSB => to_SRRC_I,79 out_srrc => to_mult_I,80 rate_sel => rate_sel,81 reset => reset82 );83 U2 : srrc_x_n84 port map(85 clk => clk,86 clk_en => clk_en,87 fir_sel => count_n,88 in_fir_MSB => to_SRRC_Q,89 out_srrc => to_mult_Q,90 rate_sel => rate_sel,91 reset => reset92 );93 U3 : counter94 port map(95 clk => clk,96 clk_en => clk_en,97 count => count_n,98 rate_sel => rate_sel,99 reset => reset

100 );101 U4 : multiplier_I_Q102 port map(103 clk => clk,104 from_NCO => sine,105 from_SRRC => to_mult_Q,106 out_mult => QPSK_Q107 );108 U5 : multiplier_I_Q109 port map(110 clk => clk,111 from_NCO => cosine,112 from_SRRC => to_mult_I,113 out_mult => QPSK_I114 );115 U6 : NCO_basic116 port map(117 clk => clk,118 cosine => cosine,119 reset => reset,120 sine => sine121 );122 U7 : adder_I_Q123 port map(124 QPSK_I => QPSK_I,125 QPSK_Q => QPSK_Q,126 QPSK_out => QPSK_out,127 clk => clk,128 reset => reset129 );130 clk_2_analyzer <= clk;131 end Modulator_BlockRAM;

Listato F.4.2: adder I Q.vhd1 library ieee;2 use ieee.std_logic_1164.all;3 use ieee.std_logic_signed.all;45 entity adder_I_Q is6 port(QPSK_I, QPSK_Q : in std_logic_vector(11 downto 0);7 clk , reset : in std_logic;8 QPSK_out : out std_logic_vector(11 downto 0));9 end adder_I_Q ;

1011 architecture adder_I_Q_arch of adder_I_Q is12 begin13 process(reset, clk , QPSK_I , QPSK_Q)14 begin15 if falling_edge(clk) then


16 if reset = ’1’ then17 QPSK_out <= "000000000000";18 else QPSK_out <= QPSK_I + QPSK_Q ;19 end if;20 else null ;21 end if ;22 end process;23 end adder_I_Q_arch ;

Listato F.4.3: counter.vhd

vedi listato(F.3.2)

Listato F.4.4: multiplier I Q.vhd1 library ieee;2 use ieee.std_logic_1164.all;3 use ieee.std_logic_signed.all;45 entity multiplier_I_Q is6 port( from_SRRC : in std_logic_vector(11 downto 0);7 from_NCO : in std_logic_vector( 1 downto 0);8 clk : in std_logic ;9 out_mult : out std_logic_vector(11 downto 0));

10 end multiplier_I_Q;1112 architecture multiplier_I_Q_arch of multiplier_I_Q is13 begin14 process(clk, from_SRRC ,from_NCO)15 variable temp : std_logic_vector(11 downto 0);16 begin17 if falling_edge(clk) then18 temp(11 downto 0) := from_SRRC ;19 case from_NCO is20 when "11" => temp := ("111111111111" xor temp)+1 ;21 when "01" => null ;22 when others => temp := "000000000000" ;23 end case;24 out_mult(11 downto 0) <= temp(11 downto 0) ;25 else null;26 end if;27 end process;28 end multiplier_I_Q_arch;

Listato F.4.5: NCO basic.vhd1 library ieee;2 use ieee.std_logic_1164.all;3 use ieee.std_logic_signed.all;45 entity NCO_basic is6 port( clk : in std_logic ;7 reset : in std_logic ;8 cosine : out std_logic_vector(1 downto 0);9 sine : out std_logic_vector(1 downto 0)

10 );11 end NCO_basic;1213 architecture NCO_basic_arch of NCO_basic is14 signal count_4 : STD_LOGIC_VECTOR (1 downto 0) ;15 begin16 process (clk, reset)17 begin18 if reset=’1’ then19 count_4 <= "00";20 else21 if falling_edge(clk) then22 count_4 <= count_4 + 1 ;23 else null ;24 end if;25 end if;26 end process;2728 process (clk, count_4)


29 begin30 if falling_edge(clk) then31 case count_4 is32 when "00" =>33 cosine <= "01" ;34 sine <= "00" ;35 when "01" =>36 cosine <= "00" ;37 sine <= "11" ;38 when "10" =>39 cosine <= "11" ;40 sine <= "00" ;41 when "11" =>42 cosine <= "00" ;43 sine <= "01" ;44 when others =>45 cosine <= "XX" ;46 sine <= "XX" ;47 end case;48 else null;49 end if;50 end process;51 end NCO_basic_arch;

Listato F.4.6: srrc x n.vhd1 library IEEE;2 use IEEE.std_logic_1164.all;34 entity srrc_x_n is5 port(6 clk : in STD_LOGIC;7 clk_en : in STD_LOGIC;8 in_fir_MSB : in STD_LOGIC;9 reset : in STD_LOGIC;

10 fir_sel : in STD_LOGIC_VECTOR(2 downto 0);11 rate_sel : in STD_LOGIC_VECTOR(1 downto 0);12 out_srrc : out STD_LOGIC_VECTOR(11 downto 0)13 );14 end srrc_x_n;1516 architecture srrc_x_n of srrc_x_n is17 component shift_reg18 port (19 clk : in STD_LOGIC;20 clk_en : in STD_LOGIC;21 in_reg : in STD_LOGIC;22 reset : in STD_LOGIC;23 out_ffd_1 : out STD_LOGIC;24 out_ffd_2 : out STD_LOGIC;25 out_ffd_3 : out STD_LOGIC;26 out_ffd_4 : out STD_LOGIC;27 out_ffd_5 : out STD_LOGIC;28 out_ffd_6 : out STD_LOGIC29 );30 end component;31 component ram32 port (33 addr : in STD_LOGIC_VECTOR(11 downto 0);34 clk : in STD_LOGIC;35 dout : out STD_LOGIC_VECTOR(11 downto 0)36 );37 end component;38 signal address : STD_LOGIC_VECTOR (11 downto 0);3940 begin41 U1 : shift_reg42 port map(43 clk => clk,44 clk_en => clk_en,45 in_reg => address(0),46 out_ffd_1 => address(1),47 out_ffd_2 => address(2),48 out_ffd_3 => address(3),49 out_ffd_4 => address(4),50 out_ffd_5 => address(5),51 out_ffd_6 => address(6),52 reset => reset53 );54 U3 : ram55 port map(56 addr => address,57 clk => clk,58 dout => out_srrc59 );60 address(7) <= fir_sel(0);61 address(8) <= fir_sel(1);62 address(9) <= fir_sel(2);63 address(0) <= in_fir_MSB;64 address(10) <= rate_sel(0);65 address(11) <= rate_sel(1);


66 end srrc_x_n;

Listato F.4.7: ram.vhd1 -- synopsys translate_off2 LIBRARY ieee;3 USE ieee.std_logic_1164.ALL;45 Library XilinxCoreLib;6 ENTITY ram IS7 port (8 addr : IN std_logic_VECTOR(11 downto 0);9 clk : IN std_logic;

10 dout : OUT std_logic_VECTOR(11 downto 0));11 END ram;1213 ARCHITECTURE ram_a OF ram IS14 component wrapped_ram15 port (16 addr : IN std_logic_VECTOR(11 downto 0);17 clk : IN std_logic;18 dout : OUT std_logic_VECTOR(11 downto 0));19 end component;20 -- Configuration specification21 for all : wrapped_ram22 use entity XilinxCoreLib.blkmemsp_v3_1(behavioral)23 generic map(24 c_reg_inputs => 0,25 c_addr_width => 12,26 c_has_sinit => 0,27 c_has_rdy => 0,28 c_width => 12,29 c_has_en => 0,30 c_mem_init_file => "ram.mif",31 c_depth => 4096,32 c_has_nd => 0,33 c_has_default_data => 0,34 c_default_data => "0",35 c_limit_data_pitch => 8,36 c_pipe_stages => 0,37 c_has_rfd => 0,38 c_has_we => 0,39 c_sinit_value => "0",40 c_has_limit_data_pitch => 0,41 c_enable_rlocs => 0,42 c_has_din => 0,43 c_write_mode => 0);44 BEGIN45 U0 : wrapped_ram46 port map (47 addr => addr,48 clk => clk,49 dout => dout);50 END ram_a;51 -- synopsys translate_on

Listato F.4.8: shift reg.vhd

vedi listato(F.3.9)

Listato F.5.1: FIFO RAM ThinModulator.vhd1 library IEEE;2 use IEEE.std_logic_1164.all;34 library unisim;5 use unisim.vcomponents.all;67 entity FIFO_RAM_ThinModulator is8 port(9 clk : in STD_LOGIC;

10 count_clk_en_reset : in STD_LOGIC;


11 data_in_I : in STD_LOGIC;12 data_in_Q : in STD_LOGIC;13 data_in_clk : in std_ulogic;14 reset : in STD_LOGIC;15 rate_sel : in STD_LOGIC_VECTOR(1 downto 0);16 data_in_clk_sync : out STD_LOGIC;17 data_out_clk : out STD_LOGIC;18 modulator_out : out STD_LOGIC_VECTOR(11 downto 0)19 );20 end FIFO_RAM_ThinModulator;2122 architecture FIFO_RAM_ThinModulator of FIFO_RAM_ThinModulator is23 component counter24 port (25 clk : in STD_LOGIC;26 rate_sel : in STD_LOGIC_VECTOR(1 downto 0);27 reset : in STD_LOGIC;28 clk_en : out STD_LOGIC;29 count : out STD_LOGIC_VECTOR(2 downto 0)30 );31 end component;32 component Data_Source_Interface33 port (34 I_to_fifo : in STD_LOGIC;35 Q_to_fifo : in STD_LOGIC;36 clk : in STD_LOGIC;37 clk_en : in STD_LOGIC;38 data_in_clk : in STD_LOGIC;39 reset : in STD_LOGIC;40 I_from_fifo : out STD_LOGIC;41 Q_from_fifo : out STD_LOGIC42 );43 end component;44 component ThinModulator45 port (46 I_in_fir_MSB : in STD_LOGIC;47 Q_in_fir_MSB : in STD_LOGIC;48 clk : in STD_LOGIC;49 clk_en : in STD_LOGIC;50 fir_sel : in STD_LOGIC_VECTOR(2 downto 0);51 rate_sel : in STD_LOGIC_VECTOR(1 downto 0);52 reset : in STD_LOGIC;53 QPSK_out : out STD_LOGIC_VECTOR(11 downto 0)54 );55 end component;56 component IBUFG57 port (58 I : in std_ulogic;59 O : out std_ulogic60 );61 end component;62 signal clk_en : STD_LOGIC;63 signal clk_to_fifo : STD_LOGIC;64 signal I_data_from_fifo : STD_LOGIC;65 signal Q_data_from_fifo : STD_LOGIC;66 signal fir_sel : STD_LOGIC_VECTOR (2 downto 0);67 for U4 : IBUFG use entity virtex.IBUFG;6869 begin70 U1 : Data_Source_Interface71 port map(72 I_from_fifo => I_data_from_fifo,73 I_to_fifo => data_in_I,74 Q_from_fifo => Q_data_from_fifo,75 Q_to_fifo => data_in_Q,76 clk => clk,77 clk_en => clk_en,78 data_in_clk => clk_to_fifo,79 reset => reset80 );81 U2 : ThinModulator82 port map(83 I_in_fir_MSB => I_data_from_fifo,84 QPSK_out => modulator_out,85 Q_in_fir_MSB => Q_data_from_fifo,86 clk => clk,87 clk_en => clk_en,88 fir_sel => fir_sel,89 rate_sel => rate_sel,90 reset => reset91 );92 U3 : counter93 port map(94 clk => clk,95 clk_en => clk_en,96 count => fir_sel,97 rate_sel => rate_sel,98 reset => count_clk_en_reset99 );

100 U4 : IBUFG101 port map(102 I => data_in_clk,103 O => clk_to_fifo104 );105 data_in_clk_sync <= clk_en;


106 data_out_clk <= clk;107 end FIFO_RAM_ThinModulator;

Listato F.5.2: counter.vhd

vedi listato(F.3.2)

Listato F.5.3: Data Source Interface.vhd1 library IEEE;2 use IEEE.std_logic_1164.all;34 entity Data_Source_Interface is5 port(6 I_to_fifo : in STD_LOGIC;7 Q_to_fifo : in STD_LOGIC;8 clk : in STD_LOGIC;9 clk_en : in STD_LOGIC;

10 data_in_clk : in STD_LOGIC;11 reset : in STD_LOGIC;12 I_from_fifo : out STD_LOGIC;13 Q_from_fifo : out STD_LOGIC14 );15 end Data_Source_Interface;1617 architecture Data_Source_Interface of Data_Source_Interface is18 component ffd19 port (20 clk : in STD_LOGIC;21 in_ffd : in STD_LOGIC;22 reset : in STD_LOGIC;23 out_ffd : out STD_LOGIC24 );25 end component;26 component ffd_en27 port (28 clk : in STD_LOGIC;29 clk_en : in STD_LOGIC;30 in_ffd : in STD_LOGIC;31 reset : in STD_LOGIC;32 out_ffd : out STD_LOGIC33 );34 end component;35 component ffs36 port (37 S : in std_ulogic;38 clk : in std_ulogic;39 reset : in std_ulogic;40 Q : out std_ulogic41 );42 end component;43 component asynch_fifo_2x1544 port (45 ainit : in STD_LOGIC;46 din : in STD_LOGIC_VECTOR(1 downto 0);47 rd_clk : in STD_LOGIC;48 rd_en : in STD_LOGIC;49 wr_clk : in STD_LOGIC;50 wr_en : in STD_LOGIC;51 almost_empty : out STD_LOGIC;52 dout : out STD_LOGIC_VECTOR(1 downto 0);53 empty : out STD_LOGIC;54 full : out STD_LOGIC55 );56 end component;57 constant VCC_CONSTANT : STD_LOGIC := ’1’;58 signal data_in_clk_to_fifo : STD_LOGIC;59 signal enable_reading : STD_LOGIC;60 signal fifo_out_enable : STD_LOGIC;61 signal out_enable : STD_LOGIC;62 signal read_enable : STD_LOGIC;63 signal start_rd_en : STD_LOGIC;64 signal VCC : STD_LOGIC;65 signal data_from_fifo : STD_LOGIC_VECTOR (1 downto 0);66 signal data_to_fifo : STD_LOGIC_VECTOR (1 downto 0);6768 begin69 U1 : asynch_fifo_2x15


70 port map(71 ainit => reset,72 almost_empty => enable_reading,73 din => data_to_fifo,74 dout => data_from_fifo,75 rd_clk => clk,76 rd_en => read_enable,77 wr_clk => data_in_clk_to_fifo,78 wr_en => VCC79 );80 U11 : ffs81 port map(82 Q => start_rd_en,83 S => enable_reading,84 clk => clk,85 reset => reset86 );87 U14 : ffd_en88 port map(89 clk => clk,90 clk_en => clk_en,91 in_ffd => start_rd_en,92 out_ffd => out_enable,93 reset => reset94 );95 U15 : ffd96 port map(97 clk => clk,98 in_ffd => data_from_fifo(1),99 out_ffd => Q_from_fifo,

100 reset => fifo_out_enable101 );102 U2 : ffd103 port map(104 clk => clk,105 in_ffd => data_from_fifo(0),106 out_ffd => I_from_fifo,107 reset => fifo_out_enable108 );109 fifo_out_enable <= not(out_enable);110 read_enable <= start_rd_en and clk_en;111 VCC <= VCC_CONSTANT;112 data_to_fifo(0) <= I_to_fifo;113 data_to_fifo(1) <= Q_to_fifo;114 data_in_clk_to_fifo <= data_in_clk;115 end Data_Source_Interface;

Listato F.5.4: asynch fifo 2x15.vhd1 -- synopsys translate_off2 LIBRARY ieee;3 USE ieee.std_logic_1164.ALL;4 Library XilinxCoreLib;5 ENTITY asynch_fifo_2x15 IS6 port (7 din : IN std_logic_VECTOR(1 downto 0);8 wr_en : IN std_logic;9 wr_clk : IN std_logic;

10 rd_en : IN std_logic;11 rd_clk : IN std_logic;12 ainit : IN std_logic;13 dout : OUT std_logic_VECTOR(1 downto 0);14 full : OUT std_logic;15 empty : OUT std_logic;16 almost_empty: OUT std_logic);17 END asynch_fifo_2x15;18 ARCHITECTURE asynch_fifo_2x15_a OF asynch_fifo_2x15 IS19 component wrapped_asynch_fifo_2x1520 port (21 din : IN std_logic_VECTOR(1 downto 0);22 wr_en : IN std_logic;23 wr_clk : IN std_logic;24 rd_en : IN std_logic;25 rd_clk : IN std_logic;26 ainit : IN std_logic;27 dout : OUT std_logic_VECTOR(1 downto 0);28 full : OUT std_logic;29 empty : OUT std_logic;30 almost_empty: OUT std_logic);31 end component;32 -- Configuration specification33 for all : wrapped_asynch_fifo_2x1534 use entity XilinxCoreLib.async_fifo_v4_0(behavioral)35 generic map(36 c_wr_count_width => 2,37 c_has_rd_err => 0,38 c_data_width => 2,39 c_has_almost_full => 0,40 c_rd_err_low => 0,41 c_has_wr_ack => 0,


42 c_wr_ack_low => 0,43 c_fifo_depth => 15,44 c_rd_count_width => 2,45 c_has_wr_err => 0,46 c_has_almost_empty => 1,47 c_rd_ack_low => 0,48 c_has_wr_count => 0,49 c_use_blockmem => 1,50 c_has_rd_ack => 0,51 c_has_rd_count => 0,52 c_wr_err_low => 0,53 c_enable_rlocs => 0);54 BEGIN55 U0 : wrapped_asynch_fifo_2x1556 port map (57 din => din,58 wr_en => wr_en,59 wr_clk => wr_clk,60 rd_en => rd_en,61 rd_clk => rd_clk,62 ainit => ainit,63 dout => dout,64 full => full,65 empty => empty,66 almost_empty => almost_empty);67 END asynch_fifo_2x15_a;68 -- synopsys translate_on

Listato F.5.5: ffd.vhd1 library ieee;2 use ieee.std_logic_1164.all;34 entity ffd is5 port(in_ffd : in std_logic ;6 clk : in std_logic ;7 reset : in std_logic ;8 out_ffd : out std_logic );9 end ffd;

1011 architecture ffd_arch of ffd is12 begin13 process (clk, reset)14 begin15 if reset=’1’ then16 out_ffd <= ’0’;17 elsif rising_edge(clk) then18 out_ffd <= in_ffd;19 end if;20 end process;21 end ffd_arch ;

Listato F.5.6: ffd en.vhd1 library ieee;2 use ieee.std_logic_1164.all;34 entity ffd_en is5 port(in_ffd : in std_logic ;6 clk : in std_logic ;7 clk_en : in std_logic ;8 reset : in std_logic ;9 out_ffd : out std_logic );

10 end ffd_en;1112 architecture ffd_en_arch of ffd_en is13 begin14 process (clk, clk_en, reset)15 begin16 if reset=’1’ then17 out_ffd <= ’0’;18 elsif rising_edge(clk) then19 if clk_en = ’1’ then20 out_ffd <= in_ffd;21 end if;22 end if;23 end process;24 end ffd_en_arch ;


Listato F.5.7: ffs.vhd1 library ieee;2 use ieee.std_logic_1164.all;3 entity ffs is4 port (S, clk, reset : in std_ulogic;5 Q : out std_ulogic);6 end entity ffs;78 architecture ffs_arch of ffs is9 signal state : std_ulogic;

10 begin11 process (clk, reset) is12 begin13 if (reset = ’1’) then14 state <= ’0’;15 elsif rising_edge(clk) then16 case S is17 when ’0’ => state <= ’1’;18 when others => null;19 end case;20 end if;21 end process ;22 Q <= state;23 end ffs_arch;

Listato F.5.8: ThinModulator.vhd1 library IEEE;2 use IEEE.std_logic_1164.all;34 entity ThinModulator is5 port(6 I_in_fir_MSB : in STD_LOGIC;7 Q_in_fir_MSB : in STD_LOGIC;8 clk : in STD_LOGIC;9 clk_en : in STD_LOGIC;

10 reset : in STD_LOGIC;11 fir_sel : in STD_LOGIC_VECTOR(2 downto 0);12 rate_sel : in STD_LOGIC_VECTOR(1 downto 0);13 QPSK_out : out STD_LOGIC_VECTOR(11 downto 0)14 );15 end ThinModulator;1617 architecture ThinModulator of ThinModulator is18 component mult_C2_adder19 port (20 clk : in STD_LOGIC;21 in_mca : in STD_LOGIC_VECTOR(11 downto 0);22 reset : in STD_LOGIC;23 out_mca : out STD_LOGIC_VECTOR(11 downto 0)24 );25 end component;26 component mux_2x727 port (28 clk : in STD_LOGIC;29 in_I : in STD_LOGIC_VECTOR(6 downto 0);30 in_Q : in STD_LOGIC_VECTOR(6 downto 0);31 reset : in STD_LOGIC;32 out_mux : out STD_LOGIC_VECTOR(6 downto 0)33 );34 end component;35 component shift_reg36 port (37 clk : in STD_LOGIC;38 clk_en : in STD_LOGIC;39 in_reg : in STD_LOGIC;40 reset : in STD_LOGIC;41 out_ffd_1 : out STD_LOGIC;42 out_ffd_2 : out STD_LOGIC;43 out_ffd_3 : out STD_LOGIC;44 out_ffd_4 : out STD_LOGIC;45 out_ffd_5 : out STD_LOGIC;46 out_ffd_6 : out STD_LOGIC47 );48 end component;49 component ram_12x4096_rising_registered50 port (51 addr : in STD_LOGIC_VECTOR(11 downto 0);52 clk : in STD_LOGIC;53 dout : out STD_LOGIC_VECTOR(11 downto 0)54 );55 end component;56 signal address : STD_LOGIC_VECTOR (11 downto 0);57 signal I_address : STD_LOGIC_VECTOR (6 downto 0);58 signal out_ram : STD_LOGIC_VECTOR (11 downto 0);59 signal Q_address : STD_LOGIC_VECTOR (6 downto 0);6061 begin


62 U1 : shift_reg63 port map(64 clk => clk,65 clk_en => clk_en,66 in_reg => I_address(0),67 out_ffd_1 => I_address(1),68 out_ffd_2 => I_address(2),69 out_ffd_3 => I_address(3),70 out_ffd_4 => I_address(4),71 out_ffd_5 => I_address(5),72 out_ffd_6 => I_address(6),73 reset => reset74 );75 U2 : shift_reg76 port map(77 clk => clk,78 clk_en => clk_en,79 in_reg => Q_address(0),80 out_ffd_1 => Q_address(1),81 out_ffd_2 => Q_address(2),82 out_ffd_3 => Q_address(3),83 out_ffd_4 => Q_address(4),84 out_ffd_5 => Q_address(5),85 out_ffd_6 => Q_address(6),86 reset => reset87 );88 U3 : ram_12x4096_rising_registered89 port map(90 addr => address,91 clk => clk,92 dout => out_ram93 );94 U4 : mux_2x795 port map(96 out_mux(0) => address(0),97 out_mux(1) => address(1),98 out_mux(2) => address(2),99 out_mux(3) => address(3),

100 out_mux(4) => address(4),101 out_mux(5) => address(5),102 out_mux(6) => address(6),103 clk => clk,104 in_I => I_address,105 in_Q => Q_address,106 reset => reset107 );108 U6 : mult_C2_adder109 port map(110 clk => clk,111 in_mca => out_ram,112 out_mca => QPSK_out,113 reset => reset114 );115 I_address(0) <= I_in_fir_MSB;116 Q_address(0) <= Q_in_fir_MSB;117 address(7) <= fir_sel(0);118 address(8) <= fir_sel(1);119 address(9) <= fir_sel(2);120 address(10) <= rate_sel(0);121 address(11) <= rate_sel(1);122 end ThinModulator;

Listato F.5.9: mult C2 adder.vhd1 library ieee;2 use ieee.std_logic_1164.all;3 use ieee.std_logic_signed.all;45 entity mult_C2_adder is6 port(in_mca : in std_logic_vector(11 downto 0);7 reset : in std_logic ;8 clk : in std_logic ;9 out_mca : out std_logic_vector(11 downto 0));

10 end mult_C2_adder;1112 architecture mult_C2_adder_arch of mult_C2_adder is13 signal TEMP_count : std_logic_vector(1 downto 0);14 begin15 process(clk, reset)16 begin17 if reset = ’1’ then18 TEMP_count <= "11";19 elsif rising_edge(clk) then20 TEMP_count <= TEMP_count + 1;21 end if;22 end process;23 process(clk, reset, TEMP_count(1), in_mca)


24 begin25 if reset = ’1’ then26 out_mca <= x"000" ;27 elsif rising_edge(clk) then28 out_mca <= in_mca ;29 if TEMP_count(1) = ’1’ then30 out_mca <= ( x"FFF" xor in_mca) + 1 ;31 end if;32 end if;33 end process;34 end mult_C2_adder_arch ;

Listato F.5.10: mux 2x7.vhd1 library ieee;2 use ieee.std_logic_1164.all;34 entity mux_2x7 is5 port(in_I, in_Q : in std_logic_vector(6 downto 0);6 reset : in std_logic ;7 clk : in std_logic ;8 out_mux : out std_logic_vector(6 downto 0));9 end mux_2x7;

1011 architecture mux_2x7_arch of mux_2x7 is12 signal sel : std_logic;13 begin14 -- processo che genera il segnale di selezione alternato15 process (clk, reset)16 begin17 if reset = ’1’ then18 sel <= ’1’;19 elsif rising_edge(clk) then20 sel <= not sel;21 end if;22 end process;23 out_mux <= in_I when (sel = ’0’) else in_Q ;24 end mux_2x7_arch ;

Listato F.5.11: ram 12x4096 rising registered.vhd1 -- synopsys translate_off2 LIBRARY ieee;3 USE ieee.std_logic_1164.ALL;45 Library XilinxCoreLib;6 ENTITY ram_12x4096_rising_registered IS7 port (8 addr : IN std_logic_VECTOR(11 downto 0);9 clk : IN std_logic;

10 dout : OUT std_logic_VECTOR(11 downto 0));11 END ram_12x4096_rising_registered;1213 ARCHITECTURE ram_12x4096_rising_registered_a OF ram_12x4096_rising_registered IS14 component wrapped_ram_12x4096_rising_registered15 port (16 addr: IN std_logic_VECTOR(11 downto 0);17 clk: IN std_logic;18 dout: OUT std_logic_VECTOR(11 downto 0));19 end component;20 for all : wrapped_ram_12x4096_rising_registered21 use entity XilinxCoreLib.blkmemsp_v4_0(behavioral)22 generic map(23 c_reg_inputs => 1,24 c_addr_width => 12,25 c_has_sinit => 0,26 c_ysinit_is_high => 1,27 c_has_rdy => 0,28 c_width => 12,29 c_has_en => 0,30 c_ymake_bmm => 0,31 c_yen_is_high => 1,32 c_yprimitive_type => "4kx1",33 c_yhierarchy => "hierarchy1",34 c_mem_init_file => "ram_12x4096_rising_registered.mif",35 c_ywe_is_high => 1,36 c_yuse_single_primitive => 1,37 c_depth => 4096,38 c_has_nd => 0,39 c_has_default_data => 0,40 c_default_data => "0",41 c_ytop_addr => "1024",42 c_limit_data_pitch => 8,43 c_pipe_stages => 1,


44 c_ybottom_addr => "0",45 c_has_rfd => 0,46 c_yclk_is_rising => 1,47 c_has_we => 0,48 c_sinit_value => "0",49 c_has_limit_data_pitch => 0,50 c_enable_rlocs => 0,51 c_has_din => 0,52 c_write_mode => 0);53 BEGIN54 U0 : wrapped_ram_12x4096_rising_registered55 port map (56 addr => addr,57 clk => clk,58 dout => dout);59 END ram_12x4096_rising_registered_a;60 -- synopsys translate_on

Listato F.5.12: shift reg.vhd

vedi listato(F.3.9)

Appendice G

Acronimi

ADC Analog Digital Converter

ARQ Automatic ReQuest for repeat

BER Bit Error Rate

BPSK Binary Phase Shift Keying

CIC Cascaded Integrator Comb

CLB Configurable Logic Block

CORDIC COordinate Rotate DIgital Computer

CPFSK Continuous Phase Frequency Shift Keying

CPLD Complex Programmable Logic Device

DAC Digital Analog Converter

DDS Direct Digital Synthesizer

DDFS Direct Digital Frequency Synthesizer

DLL Delay Locked Loop

DSP Digital Signal Processing

FA Full Adder

FEC Forward Error Correction

FFD Flip Flop D

FIFO First In First Out

FPGA Field Programmable Gate Array

175

APPENDICE G. ACRONIMI 176

FSK Frequency Shift Keying

GMSK Gaussian Minimum Shift Keying

GRM General Routing Matrix

IDFT Inverse Discrete Fourier Transform

IF Intermediate Frequency

IOB Input Output Block

ISI Inter Symbol Interference

ISP In System Programmable

LC Logic Cell

LUT Look-Up Table

MAP Maximum A Posteriori probability

ML Maximum Likelihood

MSB Most Significant Bit

MSK Minimum Shift Keying

NCO Numerical Control Oscillator

NRZ No Return to Zero

OQPSK Offset Quadrature Phase Shift Keying

OTP One Time Programmable

PAL Programmable Array Logic

PAR Place And Route

PCF Physical Constrain File

PLD Programmable Logic Device

PSK Phase Shift Keying

QAM Quadrature Amplitude Modulation

QPSK Quadrature Phase Shift Keying

RAM Random Access Memory

RTL Register Transfer Logic

APPENDICE G. ACRONIMI 177

SER Symbol Error Rate

SFDR Spurious Free Dynamic Range

SIPO Serial In Parallel Out

SNR Signal to Noise Ratio

SRAM Static Random Access Memory

SRL16 Shift Register Left 16-bit

SRRC Square Root Raised Cosine

STA Static Timing Analyzer

TWTA Travelling Wave Tube Amplifier

UCF User Constrain File

VHDL VHSIC Hardware Description Language

VHSIC Very High Speed Integrated Circuit

Bibliografia

[1] AN1298. Digital modulation in communications systems, anintroduction. Technical report, Hewlett Packard, 2000. 9

[2] Dirk A. Baker. Space-time block coding with imperfect channelestimates. Master’s thesis, West Virginia University, 2001. 5

[3] C.E.Shannon. A mathematical theory of communication. The BellSystem Technical Journal, 27, 1948. 23

[4] Annex D. Skyplex. Technical report, EUTELSAT, 1999. 2

[5] Robert D.Turney. Multirate filters and wavelets: From theory toimplementation. Xilinx. 78

[6] Hogenauer E.B. An economical class of digital filters for decimationand interpolation. IEEE Transactions on acoustics, speech and signalprocessing, 1981. 75

[7] Dr Mike Fitton. Principles of digital modulation. Technical report,Telecommunications Research Lab Toshiba, 2000. 10

[8] John G.Proakis. Digital Communications. Prentice Hall, 1998. 15, 18

[9] J.E.Volder. The cordic trigonometric computing technique. IRE Trans.on Electron. Comput., pages 330–334, September 1959. 63

[10] A.V. Oppenheim and R.W.Schafer. Elaborazione numerica dei segnali.Franco Angeli, undicesima edition, 1999. 61, 71

[11] Domenico Solimini. Appunti dalle lezioni di Campi Elettromagnetici.TeXMat, 1999. 17

[12] P.P. Vaidyanathan. Multirate Systems and Filter Banks. Prentice-Hall,1993. 74

[13] Francesco Valdoni. Comunicazioni Elettriche. I due Ladroni, 1998. 15

[14] Jouko Vankka. Methods of mapping from phase to sine amplitude indds. IEEE international Frequency control symposium, 1996. 63

178

BIBLIOGRAFIA 179

[15] Xilinx. Virtex 2.5V Field Programmable Gate Arrays, July 1999. 81

Elenco dei listati

E.1.1 NCO Q.m . . . . . . . . . . . . . . . . . . . . . . . . . . . 93E.1.2 Imposta frequenze Q.m . . . . . . . . . . . . . . . . . . . 93E.1.3 Imposta NCO Q.m . . . . . . . . . . . . . . . . . . . . . 94E.1.4 Crea super accumulatore Q.m . . . . . . . . . . . . . . . 94E.1.5 Tronca Q.m . . . . . . . . . . . . . . . . . . . . . . . . . . 94E.1.6 Crea coseno e seno Q.m . . . . . . . . . . . . . . . . . . 95E.1.7 Forward cordic Q.m . . . . . . . . . . . . . . . . . . . . . 95E.1.8 Calcola rotazioni Cordic.m . . . . . . . . . . . . . . . . . 96E.1.9 Visualizza spettro e SFDR p.m . . . . . . . . . . . . . 96E.1.10 Calcola SFDR.m . . . . . . . . . . . . . . . . . . . . . . . 96E.1.11 Calcola incremento fase NCO.m . . . . . . . . . . . . . . 97E.1.12 Visualizza spettro NCO VHDL.m . . . . . . . . . . . . . 97E.2.1 CreaVettoriTest.m . . . . . . . . . . . . . . . . . . . . . . . 97E.2.2 CreaSequenzaPatternGenerator.m . . . . . . . . . . . . . . 98E.3.1 CreaCoeffsFreqSamplScaled.m . . . . . . . . . . . . . . . . 100E.3.2 applica polifase.m . . . . . . . . . . . . . . . . . . . . . . . 101E.3.3 RaisedCosineResponse.m . . . . . . . . . . . . . . . . . . . 102E.3.4 CreaROM.m . . . . . . . . . . . . . . . . . . . . . . . . . . 102E.3.5 PolyphasePSDVHDLvsPSDMatlab.m . . . . . . . . . . . . 104E.3.6applica polifase.m . . . . . . . . . . . . . . . . . . . . . . . . 105E.3.7 VisualizzaPSDPolifaseVHDLFPGAout.m . . . . . . . . . . 105E.3.8applica polifase.m . . . . . . . . . . . . . . . . . . . . . . . . 106E.4.1 CreaTabellaBER.m . . . . . . . . . . . . . . . . . . . . . . 106E.4.2 calcolaBER.m . . . . . . . . . . . . . . . . . . . . . . . . . 107E.4.3applica polifase.m . . . . . . . . . . . . . . . . . . . . . . . . 108E.4.4 QPSKModemPSDeBERVHDLvsMatlab.m . . . . . . . . . 108E.4.5applica polifase.m . . . . . . . . . . . . . . . . . . . . . . . . 112E.4.6 QPSKModemPSDFPGAvsPSDMatlab.m . . . . . . . . . . 112E.4.7applica polifase.m . . . . . . . . . . . . . . . . . . . . . . . . 114F.1.1 nco.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115F.1.2 accumulator.vhd . . . . . . . . . . . . . . . . . . . . . . . . 116F.1.3 cordic pipelined unrolled.vhd . . . . . . . . . . . . . . . . 117F.1.4 cordic base j.vhd . . . . . . . . . . . . . . . . . . . . . . . 120F.1.5 adder 12.vhd . . . . . . . . . . . . . . . . . . . . . . . . . 121

180

ELENCO DEI LISTATI 181

F.1.6 adder 13.vhd . . . . . . . . . . . . . . . . . . . . . . . . . 121F.1.7 reg 12.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . 122F.1.8 reg 13.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . 122F.1.9 shifter.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . 122F.1.10 cosine rebuild.vhd . . . . . . . . . . . . . . . . . . . . . . . 123F.1.11 delay 13.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . 123F.1.12 sine rebuild.vhd . . . . . . . . . . . . . . . . . . . . . . . . 123F.1.13 to first quadrant.vhd . . . . . . . . . . . . . . . . . . . . 124F.1.14 troncatore 12.vhd . . . . . . . . . . . . . . . . . . . . . . . 124F.2.1 polyphase gatedClock.vhd . . . . . . . . . . . . . . . . . . 124F.2.2 srrc coeffs.vhd . . . . . . . . . . . . . . . . . . . . . . . . . 125F.2.3 rate adapter.vhd . . . . . . . . . . . . . . . . . . . . . . . 125F.2.4 coeffs selector.vhd . . . . . . . . . . . . . . . . . . . . . . . 126F.2.5 counter divider 3.vhd . . . . . . . . . . . . . . . . . . . . 130F.2.6 counter divider 4.vhd . . . . . . . . . . . . . . . . . . . . 130F.2.7 fftr.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131F.2.8 counter divider 6.vhd . . . . . . . . . . . . . . . . . . . . 131F.2.9 selector.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . 132F.2.10 srrc x n.vhd . . . . . . . . . . . . . . . . . . . . . . . . . 132F.2.11 fir 1.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136F.2.12 adder 7.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . 138F.2.13 fir multiplier.vhd . . . . . . . . . . . . . . . . . . . . . . . 139F.2.14 shift reg.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . 139F.2.15 mux 6.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . 139F.3.1 ROM polyphase.vhd . . . . . . . . . . . . . . . . . . . . . 140F.3.2 counter.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . 141F.3.3 srrc x n.vhd . . . . . . . . . . . . . . . . . . . . . . . . . 141F.3.4 demux 3x10.vhd . . . . . . . . . . . . . . . . . . . . . . . . 143F.3.5 mux 3x12.vhd . . . . . . . . . . . . . . . . . . . . . . . . . 143F.3.6 ROMx3.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . 143F.3.7 ROMx4.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . 148F.3.8 ROMx6.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . 153F.3.9 shift reg.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . 161F.4.1 Modulator BlockRAM.vhd . . . . . . . . . . . . . . . . . . 162F.4.2 adder I Q.vhd . . . . . . . . . . . . . . . . . . . . . . . . 163F.4.3counter.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164F.4.4 multiplier I Q.vhd . . . . . . . . . . . . . . . . . . . . . . 164F.4.5 NCO basic.vhd . . . . . . . . . . . . . . . . . . . . . . . . 164F.4.6 srrc x n.vhd . . . . . . . . . . . . . . . . . . . . . . . . . 165F.4.7 ram.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166F.4.8shift reg.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . 166F.5.1 FIFO RAM ThinModulator.vhd . . . . . . . . . . . . . . 166F.5.2counter.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168F.5.3 Data Source Interface.vhd . . . . . . . . . . . . . . . . . 168

ELENCO DEI LISTATI 182

F.5.4 asynch fifo 2x15.vhd . . . . . . . . . . . . . . . . . . . . . 169F.5.5 ffd.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170F.5.6 ffd en.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . 170F.5.7 ffs.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171F.5.8 ThinModulator.vhd . . . . . . . . . . . . . . . . . . . . . . 171F.5.9 mult C2 adder.vhd . . . . . . . . . . . . . . . . . . . . . . 172F.5.10 mux 2x7.vhd . . . . . . . . . . . . . . . . . . . . . . . . . 173F.5.11 ram 12x4096 rising registered.vhd . . . . . . . . . . . . . 173F.5.12shift reg.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . 174

Indice analitico

Aaccumulatore . . . . . . . . . . . . . . . . . . . 62antifuse . . . . . . . . . . . . . . . . . . . . . . . . 82

Bbase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6BlockRAM . . . . . . . . . . . . . . . . . . . . . 87

Cclock-enable . . . . . . . . . . . . . . . . . . . . 40codifica Gray . . . . . . . . . . . . . . . . . . . 17commutatore . . . . . . . . . . . . . . . . . . . 49CORDIC . . . . . . . . . . . . . . . . . . . . . . . 63Core . . . . . . . . . . . . . . . . . . . . . . . . . . . 52costellazione . . . . . . . . . . . . . . . . . . . . . 7CPLD . . . . . . . . . . . . . . . . . . . . . . . . . . 82

DDDFS . . . . . . . . . . . . . . . . . . . . . . . . . . 59DDS . . . . . . . . . . . . . . . . . . . . . . . . . . . 59DLL . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

Eefficienza spettrale . . . . . . . . . . . . . . . 9

FFEC . . . . . . . . . . . . . . . . . . . . . . . . . . . 22FIFO . . . . . . . . . . . . . . . . . . . . . . . . . . . 51FloorPlanner . . . . . . . . . . . . . . . . . . . 91

Ggated-clock . . . . . . . . . . . . . . . . . . . . . 40

HHilbert . . . . . . . . . . . . . . . . . . . . . . . . . . 5

I

inviluppo complesso . . . . . . . . . . . . . 5

LLUT . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

MMAP . . . . . . . . . . . . . . . . . . . . . . . . . . . 15moltiplicatore . . . . . . . . . . . . . . . . . . 30

NNCO . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

PPAL . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81PLD . . . . . . . . . . . . . . . . . . . . . . . . . . . 82portante . . . . . . . . . . . . . . . . . . . . . . . . . 7programmabile . . . . . . . . . . . . . . . . . 42

Qquadratura . . . . . . . . . . . . . . . . . . . . . 26

Rroll-off . . . . . . . . . . . . . . . . . . . . . . . . . . 33rumore . . . . . . . . . . . . . . . . . . . . . . . . . 45rumore gaussiano . . . . . . . . . . . . . . . 14

Ssagomatura . . . . . . . . . . . . . . . . . . . . . 27Scheda Dini . . . . . . . . . . . . . . . . . . . . 83segnale analitico . . . . . . . . . . . . . . . . . 5Shannon . . . . . . . . . . . . . . . . . . . . . . . 22simbolo . . . . . . . . . . . . . . . . . . . . . . . . . . 6Slice . . . . . . . . . . . . . . . . . . . . . . . . . . . 84spazio segnali . . . . . . . . . . . . . . . . . . . . 6spurie . . . . . . . . . . . . . . . . . . . . . . . . . . 61SRAM . . . . . . . . . . . . . . . . . . . . . . . . . 82

183

INDICE ANALITICO 184

TThinModulator . . . . . . . . . . . . . . . . . 49

VVersaBLOCK . . . . . . . . . . . . . . . . . . 86VersaRING . . . . . . . . . . . . . . . . . . . . . 86Virtex . . . . . . . . . . . . . . . . . . . . . . . . . . 82

Deﬁnizione, progetto VHDL-RTL e realizzazione tramite FPGA ... · Universita di Roma Tor Vergata...

Documents

Transcript of Deﬁnizione, progetto VHDL-RTL e realizzazione tramite FPGA ... · Universita di Roma Tor Vergata...