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 opportunamente 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 decodificata su m=2 bit. Opzionalmente, può ricevere anche un ingresso di abilitazione 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, dall’architettura si può osservare che l’organizzazione segue quella di una matrice: ogni uscita del decoder corrisponde ad una locazione di quest’ultima, in particolare, un’uscita è alta se sono abilitate contemporaneamente la riga e la colonna ad essa corrispondente. Anche in questo secondo caso l’input è stato considerato 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 abbiamo 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 comportamentale; lo stesso risultato poteva essere ottenuto dando una descrizione dataflow per ognuna delle 4 uscite. Come si può vedere, se il segnale di abilitazione è 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 decomposizione 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 come 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 componente 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: implementazione 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 struttura 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 3for in to generate
and_colonna : j 0 3for 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 adeguato, 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