Esercizi + teoria di VHDL (parte pratica del corso di Architettura dei Calcolatori)

Teoria + Esercizi di VHDL (tratti dal corso di

Architettura di Calcolatori)

 Introduzione al Progetto di Sistemi Digitali

 Introduzione al VHDL

 Sintassi del VHDL

 Dichiarazione Entity ed Architecture

 Descrizione VHDL Dataflow ed assegnazioni condizionate e selezionate

 Preparazione dell’ambiente GHDL + GTKWave

 Realizzazione Full Adder in VHDL con descrizione strutturale

 Realizzazione adder ad 8 bit

 Costrutti iterativi in VHDL + ATTRIBUTI

 Simulazione ad eventi in VHDL

 Descrizione Behavioral

 Esempi realizzazioni: flip flop RS con descrizione comportamentale

 Esempi realizzazioni: convertitore seriale-parallelo

 Oggetti in VHDL

 Tipi in VHDL

 Realizzazione vari componenti in VHDL: flip flop T, contatore, half adder, full

adder con e senza half adder, adder con il full adder e con il process, MUX, shift

register a 4 bit circolare, decodificatore NRZI, comparatore PWM,

accumulatore, shift register non circolare, memoria di 4 parole di 8 bit

 Casi ricorrenti nella programmazione VHDL: round robin, abilitazione LOAD

dopo 3 campionamenti, contatore che conta fin ad un valore M campionato

 Svolgimento completo di circa 10 prove d’esame, corredato di codice completo,

progettazione della macchina (schema a blocchi da realizzare in VHDL) e screen

significativi tratti da GTKWave per comprendere il funzionamento

 Implementazioni varie complete in VHDL tratti da vecchie prove d’esame:

convertitore seriale – parallelo, PWM, Divisore, Moltiplicatore, Codificatore

BCD, Sommatore modulo diminuito, Sommatore Carry Lookahead, cronometro

Questi appunti contengono la “parte pratica” del corso di architettura di

calcolatori, è possibile trovare sempre su questo sito anche la parte teorica.

Compito di Architettura dei Calcolatori

Compito di Macchine per l'elaborazione dell'Informazione

09/02/2012

Progettare e sviluppare in VHDL una macchina che accetta in ingresso un clock, un reset, due

segnali:

 X composto da 2 bit rappresenta la codifica di un insieme di 4 simboli,

 SEL composto da 2 bit.

La macchina presenta un uscita su Y di 8 bit.

Il segnale di clock ha un periodo di 5 us.

Ad ogni periodo di clock viene campionato il segnale X di ingresso.

La macchina riconosce quale dei 4 simboli è stato campionato e conta il numero di campionamenti

per ogni simbolo.

Indipendentemente dal clock, il segnale SEL definisce quale dei 4 valori di conteggio presentare in

uscita.

Il segnale di reset azzera uno dei contatori a seconda del valore del segnale SEL.

M

X Y

SEL

Clock

Reset

Soluzione:

fft.vhdl

Entity fft is port(

Reset,clock : in bit;

Q: out bit);

End Entity;

Architecture fft_arc of fft is

signal status : bit :='0';

Begin

status<= '0' when Reset='1' else

not status when (clock='0' and clock'event) else

status;

Q<=status;

End Architecture;

counter8.vhdl

Entity counter8 is port(

reset, ck : in bit;

ripple: out bit;

cnt: out bit_vector(7 downto 0));

End Entity;

Architecture count8_arch of counter8 is

Component fft is port(

Reset,clock : in bit;

Q: out bit);

End Component;

For All : fft use Entity work.fft(fft_arc);

signal link: bit_vector(7 downto 0);

Begin

c0: fft port map(reset,ck, link(0));

c1: fft port map(reset,link(0), link(1));

c2: fft port map(reset,link(1), link(2));

c3: fft port map(reset,link(2), link(3));

c4: fft port map(reset,link(3), link(4));

c5: fft port map(reset,link(4), link(5));

c6: fft port map(reset,link(5), link(6));

c7: fft port map(reset,link(6), link(7));

cnt(7 downto 0)<=link;

ripple<='1' when link=X"11" else

'0' after 10 ns;

End;

macchina.vhdl

Entity macchina is port(

reset, clk: in bit;

x, sel: in bit_vector(1 downto 0);

y: out bit_vector(7 downto 0));

End entity;

Architecture macchina_arc of macchina is

Component cont is port(

reset, ck : in bit;

ripple: out bit;

cnt: out bit_vector(7 downto 0));

End Component;

For All : cont use Entity work.counter8(count8_arch);

signal rip1,rip2,rip3,rip4:bit;

signal resetcont,decsel,decx, contck: bit_vector(0 to 3);

signal temp_x: bit_vector(1 downto 0);

--matrice di memoria fatta da tre contatori

TYPE matrice is ARRAY (0 to 3) of bit_vector(7 downto 0);

signal contoutput: matrice;

Begin

--campiono la x

temp_x <= "00" when reset='1' and reset'event else

x when clk='1' and clk'event and reset='0' else

temp_x;

--a seconda del valore di x, devo selezionare uno dei contatori

with temp_x select

decx<= "0001" when "00",

"0010" when "01",

"0100" when "10",

"1000" when "11";

--faccio la nand fra il vettore decx che dice quale contatore è abilitato, e un vettore di

clock,. che vale tutti 1 quando il clock vale 1, e quindi facendo la nand attivo solo il

contatore che ha:

--al vettore decx ho 1 cioe l ho selezionato con la x

--al vettore clock=1, quindi il clock è attivo, in tal caso 1 nand 1=0 , e quindi il clock

è 0 e quindi il fft conta

contck<=decx nand (clk & clk & clk & clk);

with sel select

decsel<= "0001" when "00",

"0010" when "01",

"0100" when "10",

"1000" when "11";

--faccio la and fra il vettore decsel , che ha un 1 nella posizione corrispondnete al

contatore che ho selezionato con i bit sel, e fra il vettore di ttuti reset che vale quindi

tutti 1 quando il reset è altpo:

--quando ho un 1 nella posizione orrente del contatore abilitato da sel, ed il reset è

alto, ho la and fra 1e 1 che fa 1, e quindi dando questo resetcont(i) al contatore in

questione gli sto ablitando o meno il reset

resetcont<= decsel and (reset & reset & reset & reset);

--ai componenti contatori assegno un clock e un reset personalizzati che sono la

posizione i-sima dei segnali resetcont e contclock che tiro fuori dal confronto fra due

vettori, e che quindi valgono 0 o 1:

-- se contclock(i)=0 dico al contatore di contare

--se resetcont=1 dico al contatore di resettarsi

cn1: cont port map(resetcont(0),contck(0),rip1,contoutput(0));

cn2: cont port map(resetcont(1),contck(1),rip2,contoutput(1));

cn3: cont port map(resetcont(2),contck(2),rip3,contoutput(2));

cn4: cont port map(resetcont(3),contck(3),rip4,contoutput(3));

--OSS: quindi nela simulazione il clock lo usciamo soo per fsre questo conto con i

vettori, perciò se anche abbiamo messo che il fft conta sul front di discesa, in realtà

con questo confronto l'incremento del contatore si ha quando clock(i)=1 e decx(i)=1,

e cioè sul fronte di salita del clokc dell'esercizio che da questo confronto vuol dire il

fronte dare un fronte di discesa a quel particolare contatore

with sel select

y<= contoutput(3) when "00",

contoutput(2) when "01",

contoutput(1) when "10",

contoutput(0) when "11";

End;

macchina_tb.vhdl

Entity macchina_tb is

End entity;

Architecture macchina_tb_arc of macchina_tb is

Component m is port(

reset, clk: in bit; x, sel: in bit_vector(1 downto 0);

y: out bit_vector(7 downto 0));

End component;

For All : m use Entity work.macchina(macchina_arc);

signal clock, reset: bit;

signal x, sel: bit_vector(0 to 1);

signal y: bit_vector(7 downto 0);

Begin

clock<= not clock after 5 us;

reset<= '1' after 87 us,

'0' after 88 us;

sel<="00" after 5 us,

"11" after 28 us,

"00" after 50 us,

"11" after 80 us;

x<="00" after 5 us,

"11" after 56 us;

m1: m port map(reset,clock,x,sel,y);

End;

Con il reset

Senza Reset

Riflessioni Compito di Architettura dei Calcolatori

Compito di Macchine per l'elaborazione dell'Informazione

16/10/2014

Nome ________________ Cognome ________________

Progettare e sviluppare in VHDL una macchina che accetta in ingresso:

 un clock di periodo 10 us,

 un s