Progetto sincrono
Una rete riceve in seriale 8 bit, i quali rappresentano un numero
binari in valore assoluto, e due segnali di controllo X e Y che
comandano la rete.
Se XY = 00 bisogna sommare i primi 4 bit con gli ultimi 4 bit.
Se XY = 10 bisogna sottrarre i primi 4 bit dagli ultimi 4bit.
Se XY = 11 bisogna sommare i bit pari con i bit dispari.
Se XY = 01 bisogna sottrarre i bit pari dai bit dispari.
Infine se in uscita si ha un numero maggiore di 4 bisogna
trasmettere l'uscita serialmente altrimenti tramite un registro
parallelo.
Schematico
A sinistra vi è un registro SR8CE.
Per 8 colpi di clock resta attivo per poter
ricevere gli 8 bit.
Gli 8 multiplexer ricevono i bit e
trasmettono l’uscita opportuna in base ai
segnali di controllo XY
Il full adder riceve gli 8 bit e li somma. Se
X e Y sono 10 o 01 il CI del FA è ad 1 (utile
per effettuare la sottrazione fra due
numeri in complemento a 2).
Se il numero ottenuto è minore o uguale
a 4 lo si trasmette tramite uscita parallela
(la quale si resetterà dopo 4 colpi di
clock).
Se ,invece, il numero è maggiore di 4 si
trasmette l’uscita serialmente(un registro
riceve i bit e li invia in un multiplexer, il
quale viene regolato dalle uscite di un
contatore.
La rete viene opportunamente resettata
dopo 12 colpi di clock (8 per ricevere i bit
più 4 bit per inviare l’uscita serialmente).
Simulazione behavioral
Ricevo 00100001. Con XY=00 si sommano i primi 4 bit con gli ultimi 4.Quindi 0010 + 0001 = 0011
Ricevo 00100001. Con XY=01 si sottraggono i 4 bit dispari dai 4 bit pari.
Quindi 0001 – 0100, quindi 0001 + 1011 + 1. In uscita avrò 1101 la quale sarà inviata serialmente poiché è maggiore di 4
Ricevo 00100001. Con XY = 10 si sottraggono gli ultimi 4 bit dai primi 4 bit. Quindi 0001 – 0100, ovvero 0001 + 1011 + 1 =1111
Ricevo 00100001. Con XY = 11 si sommano i 4 bit dispari ai 4 bit pari. Quindi 0001 + 0100 = 0101
Si può notare che la rete nei primi 8 colpi di clock riceve il valore serialmente lasciando le uscite a 0. Poi per 4 colpi di clock
trasmette l’opportuna uscita per poi resettarsi per poter ricevere un nuovo numero
Simulazione post-route
Nella post-route si può notare che la rete trasmette l’uscita con
un ritardo pari a 9 ns.
XY=00 in uscita si trasmette
0011 con uscita parallela
Con XY=01 si ha in uscita 1101 serialmente
Con XY=11 si trasmette in uscita 0101 serialmente
Con XY=10 si trasmette in uscita 1111 serialmente
VHDL
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
use IEEE.NUMERIC_STD.ALL;
entity vhdl is
Port ( Clock
X
Y
Ser_In
Reset
Par_Out
Ser_Out
end vhdl;
Per effettuare le operazioni artimetiche
abbiamo bisogno di alcune librerie.
Definisco le entità opportune
: in STD_LOGIC;
: in STD_LOGIC;
: in STD_LOGIC;
: in STD_LOGIC;
: in STD_LOGIC;
: out STD_LOGIC_VECTOR (3 downto 0);
: out STD_LOGIC);
architecture Behavioral of vhdl is
SIGNAL number
SIGNAL counter
SIGNAL number_op
SIGNAL primi
SIGNAL ultimi
SIGNAL pari
SIGNAL dispari
Begin
:
:
:
:
:
:
:
STD_LOGIC_VECTOR ( 7 DOWNTO 0) :=(others=>'0');
STD_LOGIC_VECTOR ( 3 DOWNTO 0) :=(others=>'0');
STD_LOGIC_VECTOR ( 3 DOWNTO 0) :=(others=>'0');
STD_LOGIC_VECTOR ( 3 DOWNTO 0) :=(others=>'0');
STD_LOGIC_VECTOR ( 3 DOWNTO 0) :=(others=>'0');
STD_LOGIC_VECTOR ( 3 DOWNTO 0) :=(others=>'0');
STD_LOGIC_VECTOR ( 3 DOWNTO 0) :=(others=>'0');
Definisco dei segnali interni utili per la
realizzazione della rete.
Number si memorizza il numero ricevuto.
Counter è il nostro contatore.
Number_op si memorizza il nuovo numero
ottenuto dopo le varie operazioni
Primi,Ultimi,Pari e Dispari, corrispondono ai
rispettivi bit del numero
ricevuto serialmente
Tutti inizializzati a 0!
rete : process(clock,reset)
Variable I : integer;
begin
if(reset = '1') then
Par_Out <="0000";
Ser_Out <= '0';
number
<= "00000000";
counter
<= "0000";
number_op<= "0000";
elsif(clock'event AND clock='1') then
if(counter = 13) then
Par_Out <="0000";
Ser_Out <= '0';
number
<= "00000000";
counter
<= "0000";
number_op<= "0000";
elsif(counter< 8) then
number(0) <=
ser_In;
for I in 6 downto 0 loop
number(I+ 1) <= number( I );
end loop;
Dichiaro un process
che viene invocato
ad ogni variamento
del clock e del reset.
Se il reset è attivo
viene resettata la
rete ad uno stato
pronto per ricevere
un nuovo numero.
Altrimenti ad ogni
fronte di salita del
clock si controlla il
counter.
Se è a 13 bisogna
resettare la rete.
Se è minore di 8
allora memorizza il
bit ricevuto
all’interno del
segnale number
shiftando gli altri bit
a sinistra
if(counter = 7) then
primi(0)<= ser_in;
primi(1)<= number(0);
primi(2)<= number(1);
primi(3)<= number(2);
ultimi(0)<= number(3);
ultimi(1)<= number(4);
ultimi(2)<= number(5);
ultimi(3)<= number(6);
pari(0)<= ser_in;
pari(1)<= number(1);
pari(2)<= number(3);
pari(3)<= number(5);
dispari(0)<= number(0);
dispari(1)<= number(2);
dispari(2)<= number(4);
dispari(3)<= number(6);
end if;
elsif(counter = 8 ) then
if (X='0' and Y='0') then
number_op <= primi + ultimi;
elsif (X='1' and Y='0') then
number_op <= primi + (not ultimi + 1);
elsif (X='0' and Y='1') then
number_op <= pari + (not dispari + 1);
elsif (X='1' and Y='1') then
number_op <= pari + dispari;
end if;
Se il counter è a
7 allora si
assegnano gli
opportuni valori
ai vari segnali.
Quando il
counter ha
campionato 8
fronti positivi di
clock tramite i
due segnali di
controllo si
eseguono le
opportune
operazioni di
somma o
sottrazione in
complemento a
2.
elsif(counter > 8) then
if(number_op<="0100") then
par_out
<= number_op;
elsif(number_op
> "0100") then
case counter is
when
"1001"
when
"1010"
when
"1011"
when
"1100"
when others => null;
end case;
end if;
end if;
counter <=
counter + 1;
end if;
=>
ser_out <= number_op(3);
=>
ser_out <= number_op(2);
=> ser_out <= number_op(1);
=> ser_out <= number_op(0);
end process rete;
end Behavioral;
Se il counter ha campionato più di 8 fronti positivi di clock allora si controlla il numero ottenuto
dalle opportune operazioni, se è minore o uguale a 4 viene inviato in uscita parallela.
Se , invece , è maggiore di 4 viene trasmesso in uscita paralle con un opportuno case.
Infine si incrementa il counter prima dell’end if (riferito al fronte positivo di clock).
Simulazione Behavioral
In ingresso: 00100001. Con XY=00 si trasmette il numero 0011 parallelemente
Con XY=01 si trasmette il numero 1101 serialmente
Con XY=11 si trasmette in uscita il numero 0101 serialmente
Con XY=10 si trasmette in uscita il numero 1111 serialmente
Simulazione post-route
In ingresso: 00100001. Con XY=00 si trasmette il numero 0011 parallelemente
Con XY=01 si trasmette il numero 1101 serialmente
Con XY=11 si trasmette in uscita il numero 0101 serialmente
Con XY=10 si trasmette in uscita il numero 1111 serialmente