Si costruisca una rete sequenziale con due ingressi ck e Bin ed una uscita Gr. L' ingresso ck va collegato ad un generatore di un segnale di clock con periodo Ti. Si supporra' che il segnale di clock stia a '0' tra t=0 e t=Ti-fi e stia a '1' per un tempo fi tra Ti-fi e Ti (Il segnale di clock per il testing viene gia' fornito). L' ingresso Bin e' a quattro bit. Tali bit rappresentano un numero tra 0 e 15 in codice binario. Il bit Bin(3) e' il bit più significativo mentre Bin(0) rappresenta il bit meno significativo. Anche l'uscita Gr e' a quattro bit. La rete deve fornire in uscita i quattro segnali Gr(3) - Gr(0), relativi al codice Gray (la sequenza di valori utilizzata nelle mappe di Karnaugh) corrispondente agli ingressi Bin(3) - Bin(0).
La tabella di conversione da codice binario a codice Gray per un ingresso a 4 bit e' la seguente:
|
Num |
Bin(3)
|
Bin(2) |
Bin(1) |
Bin(0) |
Gr(3) |
Gr(2) |
Gr(1) |
Gr(0) |
||
|
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
||
|
1 |
0 |
0 |
0 |
1 |
0 |
0 |
0 |
1 |
||
|
2 |
0 |
0 |
1 |
0 |
0 |
0 |
1 |
1 |
||
|
3 |
0 |
0 |
1 |
1 |
0 |
0 |
1 |
0 |
||
|
4 |
0 |
1 |
0 |
0 |
0 |
1 |
1 |
0 |
||
|
5 |
0 |
1 |
0 |
1 |
0 |
1 |
1 |
1 |
||
|
6 |
0 |
1 |
1 |
0 |
0 |
1 |
0 |
1 |
||
|
7 |
0 |
1 |
1 |
1 |
0 |
1 |
0 |
0 |
||
|
8 |
1 |
0 |
0 |
0 |
1 |
1 |
0 |
0 |
||
|
9 |
1 |
0 |
0 |
1 |
1 |
1 |
0 |
1 |
||
|
10 |
1 |
0 |
1 |
0 |
1 |
1 |
1 |
1 |
||
|
11 |
1 |
0 |
1 |
1 |
1 |
1 |
1 |
0 |
||
|
12 |
1 |
1 |
0 |
0 |
1 |
0 |
1 |
0 |
||
|
13 |
1 |
1 |
0 |
1 |
1 |
0 |
1 |
1 |
||
|
14 |
1 |
1 |
1 |
0 |
1 |
0 |
0 |
1 |
||
|
15 |
1 |
1 |
1 |
1 |
1 |
0 |
0 |
0 |
I valori del codice Gray vengono inviati sulle uscite sul fronte di discesa del clock ck. Si assume che sull' ingresso Bin i valori restino costanti lungo tutto il periodo di clock e cambino sul fronte di discesa del clock. Le uscite si riferiranno dunque SEMPRE al valore presentato nel PRECEDENTE periodo. Le uscite saranno tutte nulle per t=0.
Nel costruire la rete si produca:
entity bin_gray is generic (Ti:time;fi:time); port(Bin:bit_vector(3 downto 0);ck:bit;Gr:out bit_vector(3 downto 0)); end bin_gray;
Si richiede di sviluppare tale entita' nel file bin_gray.vhd (OBBLIGATORIO)
Si possono ottenere indicazioni sulla correttezza dell' elaborato utilizzando il test 461 .
Il candidato, qualora il suo elaborato non superi detto test, e' tenuto a segnalare questo fatto nell' elaborato stesso e può addurre una giustificazione plausibile di questa manchevolezza, se ritiene che la soluzione da lui proposta sia comunque consistente con l'enunciato.
Per questa prova di laboratorio vengono presentate due possibili soluzioni, contenute rispettivamente nel file bin_gray.vhd e nel file bin_gray_rom.vhd .
La prima soluzione è più tradizionale, essendo costituita da una rete combinatoria in ingresso ad elementi di memoria; nella seconda la rete combinatoria viene sostituita da una rom, in cui sono stati memorizzati i valori da porre in uscita al sistema in funzione degli ingressi.
Dall'analisi del testo d'esame (…I valori vengono inviati sulle uscite sul fronte di discesa del clock ck …) e scorrendo le entita' descritte nelle varie librerie si puo' decidere di usare un registro a 4 bit di tipo master slave, dove ciascun ingresso e' campionato sul fronte di salita di ck e viene riportato sull' uscita sul fronte di discesa di ck. Si veda a tal proposito la descrizione in rms all'interno di questo stesso file; il codice è contenuto nel file ffg.vhd .
A partire da tale componente è possibile descrivere il circuito come un insieme di quattro di questi registri master-slave, le cui uscite sono Gr(3) - Gr(0) , mentre gli ingressi sono quattro uscite obit(3) -obit(0), risultato di una rete combinatoria costituita da exor, a cui afferiscono i 4 ingressi Bin(3) - Bin(0). Il tutto risulta così rappresentato:
Lo sviluppo della rete combinatoria può prendere spunto dalla tavola di verità che lega i suoi 4 ingressi Bin(3)-Bin(0) alle 4 uscite obit(3) - obit(0). L' ingresso Bin è a quattro bit. Tali bit rappresentano un numero tra 0 e 15. Il bit Bin(3) è il bit più significativo, mentre Bin(0) rappresenta il bit meno significativo. La rete combinatoria fornisce in uscita quattro segnali obit(3) -obit(0).
Con riferimento alla figura, obit(3) è l'ingresso del master slave più significativo, la cui uscita è Gr(3), mentre obit(0) è l'ingresso del master slave meno significativo, la cui uscita è Gr(0).
I valori vengono inviati sulle uscite Gr(3) -Gr(0) sul fronte di discesa del clock ck.
Analizzando la tabella , è possibile sviluppare con degli exor le relazioni tra ingressi e uscite (per semplicità o3 sta per obit(3), Bin3 sta per Bin(3) e così via):
obit(0) <= (Bin(1) xor Bin(0)) after delay_xor;
obit(1) <= (Bin(2) xor Bin(1)) after delay_xor;
obit(2) <= (Bin(3) xor Bin(2)) after delay_xor;
obit(3) <= Bin(3) ;
Scegliendo il ritardo di propagazione più lungo, questo è pari a delay_xor. Tale ritardo deve essere inferiore a (Ti - fi), periodo di tempo in cui il clock rimane alto, dopo di chè il suo fronte di discesa fa cambiare le uscite.
Quindi: delay_xor < Ti - fi, per cui si può porre delay_xor = (Ti- fi- 1ns). Nell'esempio con Ti = 250 ns e fi = 60 ns si ottiene delay_xor = 189 ns.
Il codice vhd corrispondente a tale soluzione si trova nel file bin_gray.vhd .
Anziché sviluppare la rete combinatoria in questo modo, è possibile memorizzare le varie uscite della rete combinatoria ( obit(3) - obit(0) ) in una rom, il cui bus indirizzi è collegato agli ingressi Bin(3) - Bin(0). Occorre però fare le opportune conversioni da bit_vector a standard_logic e viceversa. La struttura del sistema è rappresentata in figura:
Per la ROM si è usata la definizione della RAM contenuta nel file ram_____.vhd: essendo una ROM, risulta abilitata solo in lettura (RnW viene posto a '1') e il segnale CS è posto a '1' dopo un certo ritardo (turn_on_delay) dallo start_up; nel disegno tale ritardo è rappresentato con un rettangolo dai bordi arrotondati per distinguerlo dai componenti veri e propri. I dati vengono trasferiti in uscita con un ritardo rom_delay; anche questo è rappresentato con un rettangolo dai bordi arrotondati.
I 4 segnali d'ingresso Bin afferiscono agli indirizzi (addr) della ROM previa un'opportuna conversione dei primi (di tipo bit vector) in segnali di tipo standard logic, chiamati int_addr. Per evidenziare la necessità di tale conversione tra nBCD e int_addr è interposto un ellisse con il nome della funzione To_StdLogicVector contenuta nel file ieee.vhd. Dualmente i 4 segnali data in uscita dalla ROM vanno convertiti in segnali di tipo bit vector, essendo essi di tipo standard logic. La funzione utilizzata è To_BitVector ed è indicata in un ellisse nel disegno. Tale funzione si può trovare nel file ieee.vhd.
I dati convertiti (int_data_bit) entrano in 4 master slaves, e sul fronte di discesa del clock CK pongono in uscita 4 bit che pilotano Gr. Circa la definizione dei master slaves si rimanda al contenuto del file ffg.vhd .
Dovendo inizializzare la ROM si è utilizzato il file gray.bin per memorizzare le 16 parole da 4 bit che fanno le veci della rete combinatoria i cui ingressi sono Bin e le uscite sono Gr.
I ritardi sono stati fissati rispettivamente:
In pratica dall'inizio del clock, dopo 1 ns si attiva la Rom e dopo rom_delay ( 1ns) prima dell'inizio del fronte di salita del clock vengono presentati i dati ai 4 master slaves.
Il codice vhd corrispondente a tale soluzione si trova nel file bin_gray_rom.vhd .