5.

1 Proiectarea registrelor şi a latchurilor

Latchurile şi registrele pot fi modelate prin metode structurale. De exemplu, latch-ul
de tip D din Figura 5.1 poate fi modelat structural prin programul din Figura 5.2.

D Q
C NQ

(a) (b)

CDQNQ100111100–Ultimul QUltimul NQ

(c)

Fig.5.1 Latch de tip D. a) schema logică; b) schema bloc; c) tabelul de adevăr.

entity dlatch is
port (D, C: in STD_LOGIC;
Q, NQ: buffer STD_LOGIC);
end entity;
architecture dlatch_str of dlatch is
signal DN, SN, RN: STD_LOGIC;
component inv
port (I: in STD_LOGIC; O: out STD_LOGIC);
end component;
component nand2b
port (I0, I1: in STD_LOGIC; O: buffer STD_LOGIC);
end component;
begin
U1: inv port map (......);
U2: nand2b port map (......);
U3: nand2b port map (......);
U4: nand2b port map (......);
U5: nand2b port map (......);
end architecture dlatch_str;

Fig. 5.2 Modelul structural al unui latch de tip D.

5.1 PROIECTAREA REGISTRELOR ŞI A LATCHURILOR / 104

 architecture dlatch_beh of dlatch is
begin
process (C, D, Q)
begin
if (C = ‘1’) then ......;
end if;
end process;
end architecture;

Fig. 5.3 Un nodel comportamental pentru un latch de tip D.

end dlatch_str;

O altă variantă de model pentru un latch de tip D este aceea din Figura 5.3. Este un
model comportamental care foloseşte numai o linie de cod VHDL. Deoarece în
program nu se precizează ce se întâmplă dacă C nu este 1, compilatorul va forma un
model care reţine valoarea lui Q între două execuţii ale procesului.

Pentru a descrie comportarea bistabilelor care comută pe frontul unui semnal de

ceas, trebuie să se folosească atributele semnalelor în VHDL (de exemplu, atributul
‘event). Dacă SEM este numele unui semnal, atunci construcţie SEM‘event
returnează valoarea true dacă SEM se schimbă de la o valoare la alta (eveniment în
SEM), false în caz contrar.
Cu această observaţie, se poate obţine un model pentru un bistabil D comutat pe
frontul pozitiv al semnalului de ceas (Figura 5.4).

Modelul unui bistabil D poate fi complicat pentru a include şi intrări asincrone

(preset, clear) şi o ieşire complementată, ca în circuitul 74x74. Acest model este
prezentat în Figura 5.5.

entity d_ff is
port (D, CLK: in STD_LOGIC;
Q: out STD_LOGIC);
end entity;
architecture d_ff_behav of d_ff is
begin
process (CLK)
begin
if (CLK’event and ......) then ......; end
if;
end process;
end architecture;
Fig. 5.4 Modelul unui bistabil D comutat pe front pozitiv.

105 / Cap. 5 PRACTICA PROIECTELOR DE TIP SECVENŢIAL

 entity d_ff_74 is
port (D, CLK, PR_L, CLR_L: in STD_LOGIC;
Q, NQ: out STD_LOGIC);
end entity;
architecture d_ff_74_behav of d_ff_74 is
signal PR, CLR: ......;

begin
process (CLR_L, CLR, PR_L, PR, CLK)
begin
PR <= not PR_L; CLR <= not CLR_L; -- De ce ?
if (CLR and PR) = ‘1’ then ......; -- valorile
pentru
Q si NQ atunci cand CLR=1 ai PR=1
elsif CLR = ‘1’ then ......;
elsif PR = ‘1’ then ......;
elsif (........) then Q <= ......;
NQ <= .....; -- actiunea pe frontal pozitiv
end if;
end process;
end architecture;
Fig. 5.5 Bistabil D cu intrări asincrone preset şi clear.

entity reg16bit is
port (CLK, CLKEN, OE_L, CLR_L: in STD_LOGIC;
D: in ......; Q: out ......);
end entity;
architecture reg16bit_beh of reg16bit is
signal CLR, OE: STD_LOGIC;
signal IQ: STD_LOGIC_VECTOR (1 to 16);
begin
process (CLK, CLR_L, CLR, OE_L, OE, IQ)
begin
CLR <= nor CLR_L; OE <= OE_L;
if (CLR = ‘1’) then IQ <= (others => ‘0’);
elsif (CLK’event and CLK = ‘1’) then
if (CLKEN = ‘1’) then IQ <= D; end if;
end if;
if OE = ‘1’ then Q <= To_StdULogicVector (IQ);
else Q <= (others => ‘Z’); end if;
end process;
end architecture;

Fig. 5.6 Modelul comportamental al unui registru de 16 biţi.

Modelele comportamentale ale registrelor se pot obţine definind intrările şi ieşirile

ca vectori şi incluzând şi funcţii suplimentare. De exemplu, în Figura 5.6 se prezintă
modelul unui registru de 16 biţi, cu ieşiri three-state, cu intrări clock-enable, output-
5.1 PROIECTAREA REGISTRELOR ŞI A LATCHURILOR / 106
enable şi clear. Se foloseşte un semnal intern IQ pentru a reşine valorile ieşirilor
bistabilelor.
architecture ALG of JKFF is
begin
process(CLK,S,R)
begin
if S = '1' and R = '0' then
Q <= ...... after ......;
QN <= ...... after ......;
elsif S = '0' and R = '1' then
.........
elsif CLK'EVENT and CLK = '1' and S='0' and R='0' then
if J = '1' and K = '0' then
...........
elsif J = '0' and K ='1' then
...........
-- toate variantele
end if;
end if;
end process;
end architecture ALG;

Fig. 5.7 Modelul unui flip-flop JK.

În Figura 5.7 se prezintă modelul algoritmic al unui flip-flop de tip JK. Setarea şi
resetarea sunt operaţii prioritare faţă de operarea normală prin intermediul semnalului
de ceas. Dacă R = S = 1, nu se întâmplă nimic. Pentru că aceasta este o condiţie
ilegală, ieşirea, în general, nu se specifică. Deci, modul de funcţionare "nu se întâmplă
nimic" este consistent cu specificaţia.

1. Completaţi programele din Figura 5.2, Figura 5.3, Figura 5.4, Figura 5.5, Figura
5.6, Figura 5.7. Compilaţi aceste programe şi simulaţi funcţionarea circuitelor
respective.
2. Elaboraţi un raport scris care să conţină modelele VHDL complete (comentate) şi
formele de undă care demonstrează funcţionarea corectă a circuitelor în toate cazurile
posibile.

5.2 Proiectarea numărătoarelor

Operaţia de numărare este fundamentală în circuitele digitale. În Figura 5.8 se

prezintă modelul unui numărător care poate fi resetat (RESET = '1'), încărcat
(LOAD = '1') şi poate număra înainte sau înapoi, după cum se stabileşte prin
semnalul de control UP, pe frontul crescător al semnalului de ceas. Ordinea

107 / Cap. 5 PRACTICA PROIECTELOR DE TIP SECVENŢIAL

priorităţilor este (1) reset, (2) încărcare, (3) numărare. Modelul pentru numărător
foloseşte funcţiile INC şi DEC din pachetul PRIMS [5].

5.1 PROIECTAREA REGISTRELOR ŞI A LATCHURILOR / 108

 entity COUNTER is
generic(DEL:TIME);
port(RESET,LOAD,COUNT,UP,CLK: in ......;
DATA_IN: in BIT_VECTOR(.......);
CNT: inout BIT_VECTOR(......));
end entity COUNTER;
use work.PRIMS.all;
architecture ALG of COUNTER is
begin
process(CLK)
begin
if CLK = '1' then
if RESET = '1' then
-- resetare
elsif LOAD ='1' then
-- functia de incarcare paralela
elsif COUNT ='1' then
if UP = '1' then
-- numarare inainte
else
-- numarare inapoi
end if;
end if;
end if;
end process;
end architecture ALG;

Fig 5.8 Modelul unui numărător cu funcţii de reset şi load.

În Figura 5.9 este prezentat modelul unui numărător similar cu 74x163. Programul
foloseşte biblioteca IEEE.std_logic_arith.all, care include tipul
UNSIGNED. Această bibliotecă include definiţiile pentru operatorii + şi – care
realizează adunarea şi scăderea asupra operanzilor UNSIGNED. Programul declară
intrarea şi ieşirea numărătorului ca vectori UNSIGNED şi foloseşte + pentru a
incrementa valoarea numărătorului.
Din păcate, unele programe de sinteză au tendinţa să sintetizeze numărătoarele cu
ajutorul unui sumator binar care adună 1 la valoarea curentă a numărătorului. Această
modalitate conduce la o logică de tip combinaţional mai complexă decât ceea ce se
observă la structurile clasice de numărătoare. De aceea, este util să dezvoltăm modele
structurale ale numărătoarelor, modele în care să conectăm celule elementare de
numărare.
De exemplu, putem modela o celulă elementară de numărare pentru numărătorul
74x163, folosind circuitul din Figura 5.10 [6].
În Figura 5.11 se prezintă programul VHDL pentru celula din Figura 5.10. În acest
program, componenta dff_qnn (bistabil de tip D) se presupune definită; este similar
cu bistabilul D din Figura 5.5, cu adăugarea unei ieşiri complementate QN.

109 / Cap. 5 PRACTICA PROIECTELOR DE TIP SECVENŢIAL

 entity num_74x163 is
port (CLK, CLR_L, LD_L, ENP, ENT: in STD_LOGIC;
D: in UNSIGNED (3 downto 0);
Q: out UNSIGEND (3 downto 0);
RCO: out STD_LOGIC);
end entity;

architecture num_74x163_arch of num_74x163 is

signal IQ: UNSIGNED (3 downto 0);
begin
process (CLK, ENT, IQ)
begin
if (CLK’event and CLK = ‘1’) then
if CLR_L = ‘0’ then IQ <= (others => ‘0’);
elsif LD_L = ‘0’ then IQ <= D;
elsif (ENT and ENP) = ‘1’ then IQ <= IQ + 1;
endif;
end if;
if (IQ = 15) and (ENT = ‘1’) then RCO <=
‘1’;
else RCO <= ‘0’;
end if;
Q <= IQ;
end process;
end architecture;
Fig. 5.9 Modelul VHDL al unui numărător de tip 74x163.

Fig. 5.10 Celulă elementară de numărare pentru numărătorul 74x163.

5.2 PROIECTAREA NUMĂRĂTOARELOR / 110

 Semnalele din celula elementară au următoarele semnificaţii:

CLK (comun) Intrarea de ceas pentru toate etajele

LDNOCLR (comun) Activat dacă intrarea LD a numărătorului este activată
şi CLR este negat
NOCLRORLD (comun) Activat dacă intrările CLR şi LD sunt negate
SNTENP (comun) Activat dacă intrarea ENP a numărătorului este
activată
Di (pentru fiecare celulă) Intrarea de încărcare paralelă pentru
celula i
CNTENi (pentru fiecare celulă) intrare de validare pentru celula i
CNTENi + 1 (pentru fiecare celulă) ieşire de validare pentru celula i
Qi (pentru fiecare celulă) Ieşirea de numărare pentru celula i

entity sync_ser_cell is
port (CLK, LDNOCLR, NOCLRORLD, CNTENP, D, CNTEN: in.....;
CNTENO, Q: out STD_LOGIC);
end entity;
architecture sync_ser_cell_arch of sync_ser_cell is
component dff_qnn
port (CLK, D: in ......; Q, QN: out ......);
end component;
signal LDAT, CDAT, DIN, Q_L: STD_LOGIC;
begin
LDAT <= LDNOCLR ...... D;
CDAT <= NOCLRORLD and ((........) xor not ......);
DIN <= LDAT ...... CDAT;
CNTENO <= (......) and ......;
U1: dff_qnn port map (......);
end architecture;

Fig. 5.11 Modelul VHDL pentru o celulă elementară de numărare.

În Figura 5.12 se arată modul în care se poate obţine un numărător serial de 8 biţi
folosind celula definită anterior. Primele două asignări din corpul arhitectural
sintetizează semnalele LDNOCLR şi NOCLRORLD. Următoarele două instrucţiuni sunt
dedicate condiţiilor legătură pentru lanţul serial de numărare. În sfârşit, instrucţiunea
generate instanţiază opt celule de numărare de 1 bit şi conectează lanţul de validare.

1. Completaţi programele din Figura 5.8, Figura 5.9, Figura 5.11, Figura 5.12.
Compilaţi aceste programe şi simulaţi funcţionarea circuitelor respective.
2. Elaboraţi un raport scris care să conţină modelele VHDL complete (comentate) şi
formele de undă care demonstrează funcţionarea corectă a circuitelor în toate cazurile
posibile.

111 / Cap. 5 PRACTICA PROIECTELOR DE TIP SECVENŢIAL

 entity 74x163_b is
port (CLK,, CLR_L, LD_L, ENP, ENT: in STD_LOGIC;
D: in STD_LOGIC_VECTOR (7 downto 0);
Q: out STD_LOGIC_VECTOR (7 downto 0)
RCO: out STD_LOGIC);
end entity;
architecture 74x163_b_arch of 74x163_b is
component sync_ser_cell
port (CLK, LDNOCLR, NOCLRORLD, CNTENP, D, CNTEN: in ...
CNTENO, Q: out ......);
end component;
signal LDNOCLR, NOCLRORLD: STD_LOGIC;
signal SCNTEN: STD_LOGIC_VECTOR (8 downto 0);
begin
LDNOCLR <= ......;
NOCLRORLD <= ......;
SCNTEN (0) <= ......;
RCO <= ......;
g1: for i in 0 to 7 generate
U1: sync_ser_cell port map (......);
end generate;
end architecture;

Fig. 5.12 Modelul VHDL pentru un numărător serial care foloseşte

celule elementare de numărare.

5.3 Proiectarea registrelor de deplasare

Registrele de deplasare sunt elemente importante pentru efectuarea operaţiilor

asupra datelor. În Figura 5.13 se prezintă un model pentru această circuit. Se poate
efectua încărcarea paralelă a registrului (pentru LOAD = '1'), conţinutul lui se poate
deplasa la dreapta (SR = '1' şi SL = '0') sau se poate deplasa la stâng (SR =
'0' şi SL = '1'). IR şi IL sunt intrări seriale pentru deplasarea la dreapta/stânga.
Încărcarea paralelă are prioritate faţă de deplasare.
O altă variantă a acestui registru de deplasare este prezentată în Figura 5.14. Pentru
celelalte două combinaţii SR SL, intrarea se transferă neschimbată la ieşire. IL şi IR
sunt valorile care se introduc în partea stângă, respectiv dreaptă, a ieşirii deplasate. Se
foloseşte operaţia de concatenare pentru a modela deplasările.

5.3 PROIECTAREA REGISTRELOR DE DEPLASARE / 112

 entity SHIFTREG is
generic(DEL: TIME);
port(DATA_IN: in BIT_VECTOR(3 downto 0);
CLK,LOAD,SR,SL: in BIT; IL,IR: in BIT;
Q: inout BIT_VECTOR(3 downto 0));
end entity SHIFTREG;

architecture DF of SHIFTREG is
begin
SH:block(not CLK'STABLE and CLK ='1')
begin
Q <= guarded DATA_IN after DEL when LOAD= '1' else
Q(2 downto 0) & IL after DEL when SL='1' and SR='0' else
IR & Q(3 downto 1) after DEL when SL='0' and SR='1' else
Q;
end block SH;
end architecture DF;

Fig. 5.13 Modelul unui registru de deplasare.

entity SHIFTER is
......
end entity SHIFTER;

architecture ALG of SHIFTER is

begin
process(SR,SL,DATA_IN,IL,IR)
variable CON: BIT_VECTOR(0 to 1);
begin
CON := SR&SL;
case CON is
when "00" => DATA_OUT <= DATA_IN after DEL;
when "01" ......
...... – toate variantele
end case;
end process;
end architecture ALG;

Fig. 5.14 Modelul VHDL al unui registru de deplasare (instrucţiunea case).

În Figura 5.15 este prezentat tabelul de funcţionare pentru un registru de deplasare

de 8 biţi cu un set extins de funcţii. În plus faţă de funcţiile Hold, Load şi Shift
(prezente la 74x194 şi 74x299) acest registru realizează şi deplasarea circulară
deplasarea aritmetică. În operaţiile de deplasare circulară, bitul care se află la un capăt
al vectorului se transferă înapoi, la celălalt capăt. În operaţiile de deplasare aritmetică,
intrarea se setează pentru înmulţirea cu 2 sau împărţirea la 2; pentru o deplasare la

113 / Cap. 5 PRACTICA PROIECTELOR DE TIP SECVENŢIAL

stânga, intrarea din dreapta este 0, pentru o deplasare la dreapta, este copiat bitul cel
mai din stânga (semn).

FuncţiaIntrăriStarea
următoareS2S1S0Q7Q6Q5Q4Q3Q2Q1Q0Hold000Q7Q6Q5Q4Q3Q2Q1Q0Load001D
7D6D5D4D3D2D1D0Shift Right010RINQ7Q6Q5Q3Q2Q1Q0Shift
Left011Q6Q5Q4Q3Q2Q1Q0LINShift Circular Right100Q0Q7Q6Q5Q4Q3Q2Q1Shift
Circular Left101Q6Q5Q4Q3Q2Q1Q0Q7Shift Arithmetic
Right110Q7Q7Q6Q5Q4Q3Q2Q1Shift Arithmetic Left111Q6Q5Q4Q3Q2Q1Q00

Fig. 5.15 Tabelul de adevăr pentru un registru de deplasare cu funcţii extinse.

Un model comportamental pentru acest registru cu funcţii extinse este prezentat în

Figura 5.16. Se defineşte un proces şi se foloseşte atributul event pentru a obţine
comutarea pe frontul dorit al semnalului CLK. Alte caracteristici ale programului sunt:
- Se foloseşte un semnal intern, IQ, imagine a lui Q, semnal care poate fi citit/scris
prin instrucţiunile procesului. O altă posibilitate este definirea ieşirilor Q de tip buffer.
- Intrarea CLR este asincronă; întrucât acest semnal este în lista de sensibilitate, el
este testat ori de câte ori se schimbă. Iar instrucţiunea IF este structurată astfel încât
CLR are precedenţă faţă de orice altă condiţie.
- Se foloseşte o instrucţiune CASE pentru a defini operaţia registrului pentru cele
opt combinaţiii posibile ale intrărilor de selecţie S (2 downto 0).
- În CASE, cazul „when others” este necesar pentru a evita erori la compilare.
- Instrucţiunea NULL arată că, în anumite cazuri, nu are loc nici o acţiune. În cazul 1
nu se impune nici o acţiune; acţiunea implicită pentru un semnal este menţinerea
valorii până când se indică altceva.
- În cele mai multe cazuri se foloseşte operaţia de concatenare & pentru a construi
un tablou de 8 biţi dintr-un subset de 7 biţi format din IQ, plus un alt bit.
- Întrucât VHDL este puternic tipizat, se foloseşte CONV_INTEGER pentru a
converti intrarea S (STD_LOGIC_VECTOR) la un întreg în instrucţiunea CASE.

1. Completaţi programele din Figura 5.13, Figura 5.14, Figura 5.16. Compilaţi
aceste programe şi simulaţi funcţionarea circuitelor respective.
5.3 PROIECTAREA REGISTRELOR DE DEPLASARE / 114
 2. Elaboraţi un raport scris care să conţină modelele VHDL complete (comentate) şi
formele de undă care demonstrează funcţionarea corectă a circuitelor în toate cazurile
posibile.

entity shift_reg is
port (CLK, CLR, RIN, LIN: in STD_LOGIC;
S: in ... ; D: in .......; Q:
out ......;
end entity;
architecture schift_reg_arch of shift_reg is
signal IQ STD_LOGIC_VECTOR (7 downto 0);
begin
process (CLK, CLR, IQ)
begin
if (CLR = ‘1’) then IQ <= (others =>
‘0’);
elsif (CLK’event and CLK = ‘1’) then
case CONV_INTEGER (S) is
when 0 => null;
when 1 => IQ <= D;
when 2 => IQ <= RIN & IQ(7 downto 1);
...... -- toate cazurile;
when others => null;
end case;
end if;
Q <= IQ;
end process;
Fig. 5.16 Modelul VHDL pentru un registru de deplasare cu funcţii extinse.
end architecture;

5.4 Proiectarea unor circuite secvenţiale complexe

Automat pentru furnizarea băuturilor răcoritoare – numărarea mondelor

Maşinile care livrează diferite produse au structuri diferite în funcţie de mai multe
caracteristici: pot livra un singur produs sau mai multe produse, pot da restul dacă
suma introdusă a fost prea mare sau nu dau rest, acceptă bancnote sau acceptă numai
monede, proiectul maşinii este de tip comportamental, maşină cu stări finite, etc.
Varianta pe care o vom lua în considerare în acest paragraf acceptă numai monede
(de 5, 10 şi 25 cenţi), livrează un singur produs, dă restul dacă suma a fost mai mare
decât preţul produsului. Semnalele de intrare sunt: intrare 5 cenţi, intrare 10 cenţi,
intrare 25 cenţi, reset. Semnalele de ieşire sunt: rest 5 cenţi, rest 10 cenţi, furnizare
produs. Se foloseşte un numărător pentru a ţine evidenţa numărului de valori de 5 cenţi
introduse. Adică, numărătorul se incrementează cu 1 dacă s-a introdus o monedă de 5
cenţi, se incrementează cu 2 dacă s-a introdus o monedă de 10 cenţi, se incrementează
cu 5 dacă s-a introdus o monedă de 25 cenţi. Programul este prezentat în Figura 5.17.

115 / Cap. 5 PRACTICA PROIECTELOR DE TIP SECVENŢIAL

entity drink_count_vhdl is
port (NICKEL_IN, DIME_IN, QUARTER_IN, RESET: Boolean;
CLK: in Bit;
NICKEL_OUT, DIME_OUT, DISPENSE: out Boolean);
end entity;
architecture BEHAVIOR of drink_count_vhdl is
signal CURRENT_NICKEL_COUNT,
NEXT_NICKEL_COUNT: INTEGER range 0 to 7;
signal CURRENT_RETURN_CHANGE, NEXT_RETURN_CHANGE:
Boolean;
begin
process (NICKEL_IN, DIME_IN, QUARTER_IN, RESET, CLK,
CURRENT_NICKEL_COUNT, CURRENT_RETURN_CHANGE)
variable TEMP_NICKEL_COUNT: Integer range 0 to 12;
begin
-- Asignari implicite
NICKEL_OUT <= .....; DIME_OUT <= ....; DISPENSE
<= ....; NEXT_NICKEL_COUNT <= .....; NEXT_RETURN_CHANGE
<= .....;
-- Reset sincron
if (not RESET) then
TEMP_NICKEL_COUNT <= CURRENT_NICKEL_COUNT;
-- Verifica daca s-au introdus bani
if (NICKEL_IN) then
TEMP_NICKEL_COUNT <= ......; -- suma totala introdusa
elsif (DIME_IN) then
TEMP_NICKEL_COUNT <= ......;
elsif (QUARTER_IN) then
............;
end if;

-- S-au introdus bani suficienti?

if (TEMP_NICKEL_COUNT >= ......) then
TEMP_NICKEL_COUNT <= .......;
DISPENSE <= TRUE;
end if;

Fig. 5.17 Modelul VHDL al unui automat pentru furnizarea băuturilor răcoritoare.

5.4 PROIECTAREA UNOR CIRCUITE SECVENŢIALE COMPLEXE / 116

 -- Restul
if (TEMP_NICKEL_COUNT >= 1 or
CURRENT_RETURN_CHANGE)
then
if (TEMP_NICKEL_COUNT >= 2) then
DIME_OUT <= ......;
TEMP_NICKEL_COUNT <= ......;
NEXT_RETURN_CHANGE <= ......;
end if;
if (TEMP_NICKEL_COUNT = 1) then
NICKEL_OUT <= ......;
TEMP_NICKEL_COUNT <= ......;
end if;
end if;

NEXT_NICKEL_COUNT <= TEMP_NICKEL_COUNT;

end if;
end process;

process
begin
wait until CLK’ event and CLK = ‘1’;
CURRENT_RETURN_CHANGE <= NEXT_RETURN_CHANGE;
CURRENT_NICKEL_COUNY <= NEXT_NICKEL_COUNT;
end process;
end architecture;
Fig. 5.17 Modelul VHDL al unui automat pentru furnizarea băuturilor răcoritoare.

117 / Cap. 5 PRACTICA PROIECTELOR DE TIP SECVENŢIAL

 Exerciţii şi probleme

5.1 Să se proiecteze un circuit presetabil de alarmare. Circuitul este de fapt un

numărător care numără invers. Capacitatea maximă este 59. El poate fi încărcat de la
tastatură zecimală, după care, la apăsarea tastei de VALIDARE, începe să numere
înapoi până la 0. La 0 activează un semnal de ALARMA. Ritmul de numărare este dat
de un semnal de ceas cu perioada de o secundă.
a. Elaboraţi schema bloc a acestui circuit; descrieţi semnalele de intrare, de ieşire,
intermediare.
b. Elaboraţi modelele VHDL ale blocurilor componente şi simulaţi funcţionarea
acestora.
c. Elaboraţi un model structural al circuitului prin interconectarea blocurilor de la
punctul anterior.
d. Elaboraţi o schemă logică funcţională a circuitului şi explicaţi funcţionarea
acestuia.
e. Elaboraţi un model schematic în XILINX ISE 9.2i folosind schema de la punctul
anterior.
f. Elaboraţi un raport scris care să conţină modelele VHDL complete (comentat) şi
formele de undă care demonstrează funcţionarea corectă a circuitului în toate cazurile
posibile.

5.2 Realizaţi un model structural pentru un registru paralel-paralel de 4 biţi [5].

Note şi comentarii

EXERCIŢII ŞI PROBLEME/ 118

 Convertor serial – paralel cu numărarea biţilor
Serial to parallel converter – counting bits

Modelul pe care îl propunem în acest paragraf citeşte un şir de biţi de intrare (serial)
şi produce o ieşire paralelă de 8 biţi. Schema bloc a convertorului este prezentată în
Figura 5.18.

RESET Fig. 5.18

SERIAL_IN Convertor READ_ENABLE

CLOCK serial - paralel PARITY_EROR

8
PARALLEL_OUT

Modelul este prezentat ]n Figura ???? (Cu FSM – Nu aici!!!)

119 / Cap. 5 PRACTICA PROIECTELOR DE TIP SECVENŢIAL