Tesina Architettura dei Sistemi digitali

Scuola Politecnica e delle Scienze di Base

Corso di Laurea Magistrale in Ingegneria Informatica

Tesina di Architettura dei Sistemi Digitali

Analisi, Progettazione,

Implementazione, Simulazione e

Sintesi degli esercizi assegnati

Anno Accademico 2020/2021

Professori

prof. Nicola Mazzocca

prof.ssa Alessandra De Benedictis

Componenti del gruppo

Margherita Maria M63001118

Martina Russo M63001128

Michelle Pepe M63001196

Chiara Paventa M63001157

Indice

1 Progetto di macchine combinatorie 4

1.1 Traccia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

1.2 Soluzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

1.3 Schematici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

1.4 Codice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.5 Simulazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2 Riconoscitore di sequenza 15

2.1 Riconoscitore di sequenza 1-1 . . . . . . . . . . . . . . . . . . . . 15

2.1.1 Traccia . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

2.1.2 Soluzione . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

2.1.3 Schematici . . . . . . . . . . . . . . . . . . . . . . . . . . 16

2.1.4 Codice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

2.1.5 Schematici . . . . . . . . . . . . . . . . . . . . . . . . . . 29

2.2 Riconoscitore di sequenza 1-10 . . . . . . . . . . . . . . . . . . . 33

2.2.1 Traccia . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

2.2.2 Soluzione . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

2.2.3 Schematici . . . . . . . . . . . . . . . . . . . . . . . . . . 33

2.2.4 Codice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

2.2.5 Simulazione . . . . . . . . . . . . . . . . . . . . . . . . . . 40

3 Orologio 42

3.1 Traccia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

3.2 Soluzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

3.3 Schematici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

3.4 Codice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

3.5 Simulazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

3.6 Sintesi su FPGA . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

4 Registro a scorrimento 54

4.1 Traccia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

4.2 Soluzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

4.3 Schematici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

4.4 Codice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

1 2

INDICE

4.5 Simulazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

5 A mod B 67

5.1 Traccia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

5.2 Soluzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

5.3 Schematici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

5.4 Codice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

5.5 Simulazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

6 Protocollo handshaking 96

6.1 Traccia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

6.2 Soluzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

6.3 Schematici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

6.4 Codice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101

6.5 Simulazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

7 Prodotto scalare 117

7.1 Traccia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117

7.2 Soluzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117

7.3 Schematici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118

7.4 Codice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122

7.5 Simulazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136

8 Processore 138

8.1 Traccia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

8.2 Cenni teorici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

8.3 Analisi codice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

8.4 Analisi istruzioni . . . . . . . . . . . . . . . . . . . . . . . . . . . 156

8.5 Modifica di un codice operativo . . . . . . . . . . . . . . . . . . . 160

9 Seriale 161

9.1 Traccia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161

9.2 Soluzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161

9.3 Uart tappo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169

9.4 Sintesi su FPGA . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

9.5 2 Uart . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173

9.6 Sintesi su FPGA . . . . . . . . . . . . . . . . . . . . . . . . . . . 175

10 Switch multistadio 176

10.1 Traccia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176

10.2 Soluzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176

10.3 Schematici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177

10.4 Codice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180

10.5 Simulazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188

3

INDICE

11 Progetto di macchine aritmetiche 190

11.1 Traccia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190

11.2 Soluzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190

11.3 Schematici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191

11.4 Codice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199

11.5 Simulazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214

Capitolo 1

Progetto di macchine

combinatorie

1.1 Traccia

Si progetti un decoder 4:16 utilizzando componenti decoder 2:4 opportuna-

mente interconnessi :

1. in una struttura ad albero

2. in una struttura a semiselezione

1.2 Soluzione

Per risolvere tale traccia, è stato utilizzato un approccio modulare, ovvero

abbiamo decomposto la macchina da implementare in componenti più piccoli. In

particolare, sono stati utilizzati 5 decoder 2:4 per la progettazione del decoder

4:16 ad albero; per realizzare invece la struttura a semi-selezione sono stati

utilizzati 2 decoder 2:4, connettendo le uscite di quest’ultimi tramite 16 porte

AND, così da realizzare correttamente le funzioni di uscita. Di conseguenza, il

primo passo compiuto è stato quello di realizzare il componente fondamentale

dell’architettura, il decoder 2:4, utilizzando una descrizione di tipo behavioral

e successivamente è stato descritto il contenitore, il decoder 4:16, mediante

approccio strutturale.

1.3 Schematici

Il Decoder 2:4 è una macchina combinatoria notevole, che riceve in ingresso

una parola codice su n bit e presenta in uscita la sua rappresentazione decodifi-

cata su m=2 bit. Opzionalmente, può ricevere anche un ingresso di abilitazione

n

en, tale che quando en=0 tutte le uscite del decoder sono nulle. Il decoder 4:16

4 5

CAPITOLO 1. PROGETTO DI MACCHINE COMBINATORIE

è dunque una macchina combinatoria che fa corrispondere ad un codice di 4 bit

in ingresso un’uscita decodificata di 16 bit, in cui al più uno dei bit è alto, se

l’abilitazione è alta e se è stato inserito un codice valido in ingresso. Come si

nota dalla figura 1.1, il decoder risulta avere due ingressi (x1 ed x0), un ingresso

di abilitazione (en) e quattro uscite.

Figura 1.1: Decoder 2:4

Come anticipato nella sezione precedente, tramite composizione di diversi

decoder 2:4 abbiamo realizzato il decoder 4:16. Concettualmente, progettando

un decoder più grande tramite composizione di macchine più piccole, stiamo

suddividendo il codice in ingresso su n bit in sottocodici espressi su un numero

di bit inferiore. Nel nostro caso, il codice in ingresso al decoder più grande,

espresso su 4 bit, è stato suddiviso in due codici espressi su due bit, i quali

saranno gli ingressi dei decoder 2:4 utilizzati per la composizione.

Per il primo punto della traccia, l’ingresso x3x2x1x0 del decoder 4:16 è

stato suddiviso nei due codici x3x3 e x1x0, che rispettivamente piloteranno

il primo e il secondo livello dell’architettura risultante. Infatti, come si può

osservare dalla figura 1.2, la parte più significativa del codice su 4 bit, x3x2,

viene utilizzata per pilotare il decoder 2:4 del primo livello, le cui uscite fungono

da ingressi di abilitazione per i decoder 2:4 del secondo livello, i quali ricevono

in ingresso la parte meno significativa del codice, x1x0. Le uscite dei 4 decoder

del secondo livello vanno poi a definire l’uscita del blocco più grande. 6

CAPITOLO 1. PROGETTO DI MACCHINE COMBINATORIE

Figura 1.2: Decoder 4:16 : struttura ad albero

Per il secondo punto della traccia, sono stati utilizzati due decoder 2:4, dal-

l’architettura si può osservare che l’organizzazione segue quella di una matrice:

ogni uscita del decoder corrisponde ad una locazione di quest’ultima, in partico-

lare, un’uscita è alta se sono abilitate contemporaneamente la riga e la colonna

ad essa corrispondente. Anche in questo secondo caso l’input è stato conside-

rato suddiviso in due parti, ciascuna delle quali va in ingresso ad uno dei due

decoder. Dalla figura 1.3 si può vedere come la parte più significativa, x3x2,

va in ingresso al decoder posto in verticale, mentre la parte meno significativa,

x1x0, va in ingresso al decoder posto in orizzontale. 7

CAPITOLO 1. PROGETTO DI MACCHINE COMBINATORIE

Figura 1.3: Decoder 4:16 : struttura a semiselezione

1.4 Codice

Siamo partite dall’implementazione del decoder 2:4: come prima cosa ab-

biamo definito l’entity dec 2:4, che rappresenta l’interfaccia del componente. Al

suo interno sono stati dichiarati i 3 ingressi (a,b,e) e le 4 uscite (o). L’entity è

stata implementata attraverso un process, quindi tramite una descrizione com-

portamentale; lo stesso risultato poteva essere ottenuto dando una descrizione

dataflow per ognuna delle 4 uscite. Come si può vedere, se il segnale di abili-

tazione è alto, in base alla combinazione dei due bit in ingresso, in uscita verrà

alzato solo uno dei 4 bit, quello corrispondente, in maniera posizionale partendo

da destra verso sinistra, alla decodifica del valore in ingresso.

entity decoder_2_4 is

(

Port a : in std_logic;

b : in std_logic;

e : in std_logic; 8

CAPITOLO 1. PROGETTO DI MACCHINE COMBINATORIE

o : 0)

out std_logic_vector(3 downto

);

end decoder_2_4;

architecture Behavioral of decoder_2_4 is

begin

process(a,b,e)

begin (e='1')

if then

(a='0' b='0')

if AND then

o<="0001";

(a='1' b='0')

elsif AND then

o<="0010";

(a='0' b='1')

elsif AND then

o<="0100";

(a='1' b='1')

elsif AND then

o<="1000";

end if;

else

o<="0000";

end if;

end process;

end Behavioral;

Per l’implementazione del decoder 4:16 sia per quanto riguarda la decompo-

sizione ad albero, sia per quella a semiselezione, abbiamo utilizzato la stessa

entity, per la quale sono state poi definite due architetture differenti tramite il

costrutto architecture. Inoltre, in entrambi i casi, per descrivere il sistema co-

me composizione di macchine, ci siamo posti a livello di astrazione strutturale,

facendo uso del costrutto component, che consente di dichiarare i componenti

utilizzati da un design, mentre con il port map è possibile istanziare il com-

ponente nella parte di descrizione funzionale di un’architettura. L’entity è la

stessa per entrambe le implementazioni:

entity decoder_4_16 is

(

Port x : (3 0);

in std_logic_vector downto

s : := '1';

in std_logic

y : 0)

out std_logic_vector(15 downto

);

end decoder_4_16;

Di seguito è riportato il codice per la risoluzione del primo punto : implemen-

tazione ad albero di un decoder 4:16 : 9

CAPITOLO 1. PROGETTO DI MACCHINE COMBINATORIE

architecture Structural of decoder_4_16 is

-- Definizione segnali intermedi

enable0 : := '0';

signal std_logic

enable1 : := '0';

signal std_logic

enable2 : := '0';

signal std_logic

enable3 : := '0';

signal std_logic

component decoder_2_4

(

port

a : in std_logic;

b : in std_logic;

e : in std_logic;

o : 0)

out std_logic_vector(3 downto

);

end component;

begin

-- Utilizzo di 5 Decoder 2:4 per realizzare Decoder 4:16 ad albero

decoder0: decoder_2_4

(

port map a=> x(2),

b=> x(3),

e=> s,

o(0)=> enable0,

o(1)=> enable1,

o(2)=> enable2,

o(3)=> enable3

);

decoder1: decoder_2_4

(

port map a=> x(0),

b=> x(1),

e=> enable0,

o=>y(3 0)

downto

);

decoder2: decoder_2_4

(

port map a=> x(0),

b=> x(1),

e=> enable1,

o=>y(7 4)

downto

); 10

CAPITOLO 1. PROGETTO DI MACCHINE COMBINATORIE

decoder3: decoder_2_4

(

port map a=> x(0),

b=> x(1),

e=> enable2,

o=>y(11 8)

downto

);

decoder4: decoder_2_4

(

port map a=> x(0),

b=> x(1),

e=> enable3,

o=>y(15 12)

downto

);

end Structural;

Per quanto riguarda invece l’implementazione del decoder 4:16 mediante strut-

tura a semi-selezione, è possibile osservarla di seguito:

architecture Structural of decoder_4_16 is

riga : 0);

signal std_logic_vector(3 downto

colonna : 0);

signal std_logic_vector(3 downto

component decoder_2_4

(

port a : in std_logic;

b : in std_logic;

e : in std_logic;

o : 0)

out std_logic_vector(3 downto

);

end component;

component operatore_and

(

port a : in std_logic;

b : in std_logic;

z : out std_logic

);

end component;

begin 11

CAPITOLO 1. PROGETTO DI MACCHINE COMBINATORIE

decoder_riga: decoder_2_4

(

port map a => x(2),

b => x(3),

e => s,

o => riga

);

decoder_colonna: decoder_2_4

(

port map a => x(0),

b => x(1),

e => s,

o => colonna

);

and_riga : i 0 3

for in to generate

and_colonna : j 0 3

for in to generate

uscita : operatore_and (

port map a=> riga(i),

b=> colonna(j),

z=> y(j+i*4)

);

end generate;

end generate;

end Structural;

1.5 Simulazione

Per vedere l’implementazione simulata, è stato creato un test bench adegua-

to, riportato in seguito

entity decoder_4_16_tb is

end decoder_4_16_tb;

architecture Behavior of decoder_4_16_tb is

component decoder_4_16

port(

x : (3 0);

in std_logic_vector downto

s : in std_logic;

y : 0)

out std_logic_vector(15 downto

);

end component; 12

CAPITOLO 1. PROGETTO DI MACCHINE COMBINATORIE

-- Dati di input

x : (3 0) := (others=>'0');

signal std_logic_vector downto

s :

signal std_logic:='1';

-- Dati di output

y : (15 0) := (others=>'0');

signal std_logic_vector downto

begin

uut : decoder_4_16

(

port map

x => x,

y => y,

s => s

);

stim_proc : process

begin

x <= "0000";

10 ns;

wait for

y="0000000000000001";

assert

x <= "0001";

10 ns;

wait for

y="0000000000000010";

assert

x <= "0010";

10 ns;

wait for

y="0000000000000100";

assert

x <= "0011";

10 ns;

wait for

y="0000000000001000";

assert

x <= "0100";

10 ns;

wait for

y="0000000000010000";

assert

x <= "0101";

10 ns;

wait for

y="0000000000100000";

assert

x <= "0110";

10 ns;

wait for

y="0000000001000000";

assert 13

CAPITOLO 1. PROGETTO DI MACCHINE COMBINATORIE

x <= "0111";

10 ns;

wait for

y="0000000010000000";

assert

x <= "1000";

10 ns;

wait for

y="0000000100000000";

assert

x <= "1001";

10 ns;

wait for

y="0000001000000000";

assert

x <= "1010";

10 ns;

wait for

y="0000010000000000";

assert

x <= "1011";

10 ns;

wait for

y="0000100000000000";

assert

x <= "1100";

10 ns;

wait for

y="0001000000000000";

assert

x <= "1101";

10 ns;

wait for

y="0010000000000000";

assert

x <= "1110";

10 ns;

wait for

y="0100000000000000";

assert

x <= "1111";

10 ns;

wait for

y="1000000000000000";

assert

wait;

end process;

end Behavior;

Entrambe le architetture sono state simulate attraverso l’utilizzo dello stesso

testbench, il cui risultato è riportato in figura 1.4 : 14

CAPITOLO 1. PROGETTO DI MACCHINE COMBINATORIE

Figura 1.4: Simulazione Decoder 4:16

Capitolo 2

Riconoscitore di sequenza

2.1 Riconoscitore di sequenza 1-1

2.1.1 Traccia

Si vuole progettare un riconoscitore di sequenza come macchina sincrona

a sincronizzazione esterna. La macchina riceve attraverso un ingresso seriale

stringhe di 3 bit e, alla ricezione del terzo bit di ciascuna stringa, fornisce uscita

alta se la sequenza ricevuta è 1-1. Si disegni l’automa e si proceda alla sintesi

utilizzando flip-flop D. Implementare la m