Curs 02

Modelarea HDL a
circuitelor combinaţionale

1
 Circuitul combinaţional

intrari control

intrari date f (..., tPD) iesiri date

circuit combinaţional
întârzierea introdusă de circuit
= timp de proagare
ecuaţia de iesiri_date  f  intrari_control , intrari_date,t PD 
funcţionare:

 sunt caracterizate prin faptul că nu conţin bucle de reacţie  nu au stări interne;

 valorile semnalelor de iesire sunt atribuite numai pe baza valorilor curente ale intrărilor de control şi ale
celor de date;
 valorile semnalelor de iesire sunt atribuite după un interval de timp tPD, egal cu întârzierea introdusă de
către circuit, numit timp de propagare;
 întârzierea introdusă de circuit depinde de:
• structura acestuia,
• modul de implementare pe suport fizic,
• suportul fizic adoptat pentru implementare (ASIC – întârzieri minime, FPGA) 2
 Modelarea în Verilog a
circuitelor combinaţionale

3
 Tehnici de modelare a circuitelor combinaţionale
Modelarea
comportamentală
 se realizează pe baza
blocului always
 descrie comportmentul
circuitului combinaţional, făcând
abstracţie de schema
electronică a acestuia;
 reprezintă tehnica de
modelare a circuitelor
combinaţionale utilizată în
cadrul acestei discipline
 exemplu: Mux2:
 modelare:
always @(di1 or di0 or sel)
y = sel? di1: di0;
Modelarea dataflow Modelarea structurală
 se realizează pe baza  Ss realizează pe baza porţilor
ecuaţiilor logice, care descriu logice;
funcţionarea unui circuit
 in Verilog porţile logice sunt
combinaţional;
furnizate ca primitive logice
 exemplu – Mux2: predefinite pe care utilizatorul le
poate utiliza folosind sintaxa
 ecuatia logica:
acestora;
y = (di0 SI sel) SAU (di1
SI sel)
 modelare:
assign y = (di0 & !sel) |
(di1 & sel);
4
 Stabilirea conţinutului listei de senzitivităţi în
modelarea circuitelor combinaţionale
module c02ex01 ( module c02ex02 (
input X1,X2, input X1,X2,
output reg Y); output reg Y1,Y2);

always@(X1) always@(X1 or Y2)

Y = X1 | X2; Y1 = X1 | Y2;
always@(X2 or Y1)
endmodule Y2 = X2 & Y1;
endmodule

Neintroducerea intrării X2 în lista de Introducerea ieşirilor Y1 şi Y2 în lista de senzitivităţi

senzitivităţi determină un comportament determină bucle de reacţie în circuit
insensibil la tranziţiile suferite de acest semnal

În lista de senzitivităţi se introduc TOATE intrările

circuitului
5
În lista de senzitivităţi se introduc NUMAI intrăile circuitului
 Efectul utilizării instrucţiunilor neblocante în
descrierea circuitelor combinaţionale

module c02ex03 (
input di0, di1, di2, di3,
output reg dout);

reg tmp1, tmp2;

Activarea procesului la timpul 0 ns:
always @ (di0,di1,di2,di3) di0 = 0, di1 = 1 => di0 & di1 = 0
di2 = 0, di3 = 1 => di2 & di3 = 0
begin tmp1 = x, tmp2 = x => tmp1 | tmp2 = x
tmp1 <= di0 & di1; Suspendarea procesului la timpul 0:
tmp1 = 0
tmp2 <= di2 & di3; tmp2 = 0
dout <= tmp1 | tmp2; dout = x
Activarea procesului la timpul 10 ns:
end di0 = 0, di1 = 1 => di0 & di1 = 0
di2 = 1, di3 = 1 => di2 & di3 = 1
tmp1 = 0, tmp2 = 0 => tmp1 | tmp2 = 0
endmodule Suspendarea procesului la timpul 10ns:
tmp1 = 0
tmp2 = 1
dout = 0
Deoarece RHS se evaluează la execuţia instrucţiunilor
În modelarea circuitelor combinaţionale se utilizează iar LHS se actualizează numai la suspendarea
numai intrucţiuni de atribuire blocante proceselor, există un decalaj între tranziţiile suferite6de
intrări şi actualizarea semnalelor ţintă.
 Efectul neacoperirii tuturor condiţiilor logice posibile
între semnalele de intrare!!!

module c02ex04 (
input ctl0, ctl1, in1, in2,
output reg out);

always @ (ctl0, ctl1, in1, in2)

begin
if (ctl0 & ctl1)
out = in1;
else if (ctl0 | ctl1)
out = in2;

end

Deoarece nu se precizează care este

endmodule
Este obligatoriu să se asigure o cale logică de atribuire a
unei valori pentru FIECARE ieşire a circuitului, pentru
TOATE condiţiile logice, sau combinaţiile posibile de
valori, ale semnalelor de intrare;
valoarea semnalului de ieşire pentru
toate condiţiile logice posibile între
semnalele de intrare, intrumentul
software de sinteză presupune că
pentru valorile combinaţiile neacoperite
circuitul îşi memorează la ieşire ultima
7
valoare => se genereaza latch-uri!.
 Reguli generale pentru modelarea comportamentală pentru
sinteză a circuitelor combinaţionale

1. Este obligatoriu ca evenimentele din lista de senzitivităţi a blocului always să fie

controlate de tranziţiile semnalelor de intrare
2. Este obligatoriu ca în lista de senzitivităţi a blocului always să fie introduse TOATE
semnalele de intrare ale circuitului (atât de control cât şi de date); în lista de senzitivităţi
NU se introduc semnalele de ieşire
3. Este obligatoriu să se asigure o cale logică, de atribuire a unei valori pentru FIECARE
ieşire a circuitului, pentru TOATE condiţiile logice sau pentru toate combinaţiile posibile
de valori ale semnalelor de intrare; dacă nu este respectată această regulă, atunci, în
urma sintezei logice, la ieşirile circuitului combinaţional se vor genera celule de
memorie (latch-uri); fenomenul este referit în literatura de specialitate ca “latch
inference”;
4. Pentru atribuirea valorilor se utilizează instrucţiunea de atribuire blocantă
( instrucţiunea = )
5. În sinteză nu se utilizează modelarea întârzierilor (modelarea întârzierilor este utilă in
testarea funcţională a circuitului).

8
 Modelarea comportamentală a multiplexoarelor

intrare control = controleaza selecţia

fluxului de date
sel
intrari di1 ecuatia _ functionar e :
y
date
di0 iesire
date
 
y  sel  di 0   sel  di1

mux2

 aplicaţii specifice:
1. în blocurile de date (datapath block), pentru control fluxului de date care este transmis pe canalele de
date; multiplexorul se introduce la intrarea canalului de date
2. în blocurile de date, pentru implementarea blocurilor combinationale de deplasare a datelor
3. ca bloc de generare a funcţiilor logice combinaţionale (pentru sinteza funcţiilor combinaţionale)
4. altele
 comportament: la iesirea de date sunt trimise datele de intrare, în funcţie de valoarea semnalului de selecţie:
dacă sel = 0 atunci la iesire sunt furnizate datele de pe intrarea di0, dacă sel = 1 atunci la ieşire sunt
furnizate datele de pe intrarea di1.
 observaţie: controlul sursei fluxului de date este controlat de CODUL aplicat pe intrarea de selectie

9
 Modelarea comportamentală a multiplexoarelor –
codul Verilog (1995)

module mux2 (sel, di1, di0, y); // multiplexor cu 2 intrari de date pe 1 bit
input sel; // intrare selectie
input di1, di0; // intrari date
output y; // iesire date

reg y; // deoarece valoarea lui y se atribuie

// intr-un bloc always
always @(sel or di1 or di0) // toare semnalele de intrare
// se introduc in lista de senzitivitati
case (sel) // comportamentul se descrie in mod natural
0: y = di0; // intr-o specificatie de selectie case
1: y = di1;
default : y = 1'b x; // clauza default acopera toate celelate valori ramase
// pentru semnalul sel
endcase

endmodule

10
 Sinteza logică şi implementarea multiplexorului
Sinteza logică:

 
y  sel  di0   sel  di1

Circuitul electronic generat după etapa de sinteză

logică în Xilinx ISE 9.2i

Implementare FPGA:

Schema electronică generată după

implementarea în FPGA Spartan 3 – Xilinx;
sunt utilizate resurse integrate în structura
FPGA: în blocul LUT este implementată
schema electronică obţinută după sinteza
logică 11
 Modelarea comportamentală a demultiplexoarelor

intrare control = controleaza distribuţia

fluxului de date
sel
y1
iesiri
intrare date di
date
y0

dmux2

 aplicaţii specifice:
1. în blocurile de date (datapath block), pentru distribuirea fluxului de date pe diverse canale de date;
2. distribuirea secvenţială a unui semnal de control pe diverse trasee (de exemplu distribuirea secvenţială a unui
semnal de activare enable spre diverse blocuri);
3. altele
 comportament: semnalul aplicat la intrarea de date este distribuit la iesirea de date care corespunde codului
aplicat pe instrarea de selecţie: dacă sel = 0 atunci data de intrare este furnizată la iesirea y0, dacă sel = 1
atunci data de intrare este furnizată la ieşirea y1.
 observaţie: distribuirea fluxului de date este controlat de CODUL aplicat pe intrarea de selectie

12
Modelarea comportamentală a demultiplexoarelor – codul Verilog
module dmux2 (sel, di, y1, y0); // demultiplexor cu 2 iesiri de date pe 1 bit
input sel; // intrare selectie
input di; // intrare date
output y1, y0; // iesiri date

reg y1, y0; // deoarece valorile lui y se atribuie

// intr-un bloc always
always @(sel or di) // toate semnalele de intrare
// se introduc in lista de senzitivitati
case (sel) // comportamentul se descrie in mod natural
0: // intr-o specificatie de selectie case
begin
y0 = di; // pentru evitarea latchurilor
y1 = 1'bx; // este necesar sa se precizeze
end // valorile tuturor iesirilor
1:
begin
y0 = 1'bx;
y1 = di;
end
default :
begin
y0 = 1'bx;
y1 = 1'bx;
end
endcase

endmodule

13
 Sinteza logică şi implementarea demultiplexorului
Sinteza logică:

buffere

Implementare FPGA:

14
Generarea accidentală a latchurilor: exemplu - demultiplexoare
module dmux2 (sel, di, y1, y0);
input sel;
input di;
output y1, y0; reg y1, y0;

always @(sel or di)

case (sel)
0: y0 = di; // se precizeaza doar valoarea
1: y1 = di; // pentru iesirile care primesc data de intrare
default :
begin
y0 = 1'bx;
y1 = 1'bx;
end
endcase

endmodule

latchuri
pe ieşiri

15
Circuitul generat după sinteza logică
Implementarea FPGA a demultiplexorului cu latchuri

latchuri pe ieşiri

16
Modelarea comportamentală a codificatoarelor prioritare

di3
di2 y1 cod
intrare
date di1 binar
y0
di0

cod4to2

 aplicaţii specifice:
1. generator de cod binar în blocuri de testare;
2. generator de cod binar în blocuri de accesare a unor segmente de memorie
3. conversia datelor în cod binar
4. altele
 comportament: circuitul generează la ieşire codul binar corespunzător intrării active;
dacă di3 = 1 atunci ieşirea y1y0 = 11,
dacă di2 = 1 atunci ieşirea y1y0 = 10,
dacă di1 = 1 atunci ieşirea y1y0 = 01,
dacă di0 = 1 atunci ieşirea y1y0 = 00;
 observaţie: circuitul trebuie să includă logică prioritară în monitorizarea intrărilor; în caz
contrar, la activarea simultană a 2 sau mai multe intrări, codul generat la ieşire este ambiguu
17
 Modelarea comportamentală a codificatorului prioritar – 2 variante echivalente
module cod4to2(di3, di2, di1, di0, y1, y0);// VARIANTA 1: pe baza specificatiei conditionale if
input di3, di2, di1, di0; // intrari date: di3 intrarea cea mai prioritara
output reg y1, y0; // iesiri date = codul binar al intrarii active

always @ (di3 or di2 or di1 or di0) // toate intrarile in lista de senzitivitati

if (di3) {y1,y0} = 2'b11;
else if (di2) {y1,y0} = 2'b10;
else if (di1) {y1,y0} = 2'b01;
else if (di0) {y1,y0} = 2'b00;
else {y1,y0} = 2'bx;
// prima data se evalueaza intrarea cu prioritate
// maxima: conditia (di3)
// ultima data se evalueaza intrarea cu
// prioritate minima: conditia (di0)
// in absenta acestei linii se genereaza latchuri

endmodule

module cod4to2(di3, di2, di1, di0, y1, y0); // VARIANTA 2: pe baza specificatie de selectie
input di3, di2, di1, di0;
output reg y1, y0;
always @ (di3 or di2 or di1 or di0)
casex ({di3, di2, di1, di0})
4'b 1xxx : {y1,y0} = 2'd3;
4'b 01xx : {y1,y0} = 2'd2;
4'b 001x : {y1,y0} = 2'd1;
4'b 0001 : {y1,y0} = 2'd0;
default : {y1,y0} = 2'bx;
endcase
endmodule
// casex
// expresia care controleaza selectia se obtine
// prin concatenarea intrarilor
// alternativa 1 – prima evaluata => prioritate
// maxima: di3 activ, restul nu conteaza
// alternativa 2: di3 inactiv SI di2 activ, restul nu
// conteaza
// alternativa 3: di3 SI di2 inactive SI di1 activ,
// restul nu conteaza
// alternativa 4 – ultima evaluata => prioritate
// minima: di3 SI di2 SI di1 inactive, di0 activ
// precizeaza valoarea iesirilor pentru alte cazuri
18
Sinteza logică a codificatorului prioritar – varianta 1

detaliu

buffere

Circuitul electronic obţinut după etapa de sinteză logică

detaliu
19
 Sinteza logică a
codificatorului prioritar – detaliu
varianta 2

buffere

Circuitul electronic
obţinut după etapa
de sinteză logică

Circuitul electronic obţinut

detaliu după etapa de sinteză logică

Obs: circuitul obţinut după etapa de

sinteză logică este mai complex => o
variantă de modelare mai puţin
eficientă, şi mai imprecisă detaliu
20
 Implementarea FPGA a codificatorului prioritar – ambele variante

Obs: deşi cele 2 circuite obţinute după etapa de sinteză logică sunt diferite, deoarece sunt21de
complexitate apropiată, pentru implementarea FPGA soluţia este comună
Generarea accidentală a latchurilor: exemplu – codificator prioritar
module Cod4_2(di3, di2, di1, di0, y1, y0);
input di3, di2, di1, di0;
output reg y1, y0;

always @ (di3 or di2 or di1 or di0)

if (di3) {y1,y0} = 2'b11;
else if (di2) {y1,y0} = 2'b10;
else if (di1) {y1,y0} = 2'b01;
else if (di0) {y1,y0} = 2'b00;
// linia else {y1,y0} = 2'bx; se elimina => care e valoarea iesirii daca niciuna dintre intrari nu e a ctiva?
endmodule

latchuri pe ieşiri

Circuitul electronic
obţinut după etapa 22
de sinteză logică
 Modelarea comportamentală a decodificatoarelor

y3
di1 y2 iesire
cod
binar di0
y1 date
y0

dcd2to4

 aplicaţii specifice:
1. bloc de decodificare a codului aplicat aplicat la intrare;
2. generator de semnale de control (semnale de activare pentru diferite circuite) în funcţie de
codul aplicat la intrare
3. altele
 comportament: circuitul activează numai ieşirea care corespunde codului binar aplicat pe intrări;
dacă d1d0 = 11 atunci numai ieşirea y3 este activă, celelalte ieşiri sunt inactive,
dacă d1d0 = 10, atunci numai ieşirea y2 este activă, celelalte ieşiri sunt inactive,
dacă d1d0 = 01, atunci numai ieşirea y1 este activă, celelalte ieşiri sunt inactive,
dacă d1d0 = 00, atunci numai ieşirea y0 este activă, celelalte ieşiri sunt inactive;

23
 Modelarea comportamentală a decodificatorului
module dcd2to4(di1, di0, y3, y2, y1, y0); // VARIANTA 1: decodificator binar pe 2 biti
input di1, di0; // intrari date = cod binar
output reg y3, y2, y1, y0; // iesiri date

always @ (di1 or di0) // in lista de senzitivitati se introduc toate

// intrarile
case ({di1, di0}) // expresia care controleaza selectia se obtine
// prin concatenarea intrarilor
0 : {y3,y2,y1,y0} = 4‘b0001;
1 : {y3,y2,y1,y0} = 4’b0010;
2 : {y3,y2,y1,y0} = 4‘b0100;
3 : {y3,y2,y1,y0} = 4‘b1000;
default : {y3,y2,y1,y0} = 4'b0; // precizeaza valoarea iesirilor pentru alte cazuri
endcase
endmodule

module dcd2to4(di, y); // VARIANTA 2: semnalele declarate ca vectori

input [1:0] di; // intrari date = cod binar
output reg [3:0] y; // iesiri date

always @ (di)
case (di)
0 : y = 4‘b0001;
1 : y = 4’b0010;
2 : y = 4‘b0100;
3 : y = 4‘b1000;
default : y = 4'b0;
endcase
endmodule

24
Circuitul electronic obţinut după
etapa de sinteză logică depinde
de DIRECTIVELE DE SINTEZĂ

25
Sinteza logică a
decodificatorului
Circuitul obţinut după etapa de sinteză
logică depinde de directivele de sinteză;
directivele de sinteză reprezintă comenzi
date de catre utilizator, care ghidează
modul de obţinere a circuitului electronic
în etapa de sinteză:
Varianta 1: decodificatorul este sintetizat
pe baza porţilor logice

Varianta 2: decodificatorul este sintetizat

prin intermediul multiplexoarelor (s-a
utilizat directiva de sinteză MUX
extraction)

Varianta 2: decodificatorul este sintetizat

prin intermediul unui bloc de memorie
ROM (s-a utilizat directiva de sinteză ROM
extraction)
26
Implementarea FPGA a decodificatorului pentru ambele variante
de circuite obţinute după sinteza logică

Toate circuite obţinute

după etapa de sinteză
logică conduc la aceeaşi
implementare deoarece
atât porţile logice,
multiplexoarele cât şi
blocul de memorie ROM
se pot implementa pe
baza blocurilor LUT din
structura FPGA

27
 Generarea accidentală a latchurilor: exemplu – decodificatorul
module dcd2to4(di1, di0, y3, y2, y1, y0);
input di1, di0;
output reg y3, y2, y1, y0;
always @ (di1 or di0)
case ({di1, di0})
0 : y0 = 1’b1; // greseala consta in faptul ca se
1 : y1 = 1’b1; // precizeaza valoarea numai pentru
2 : y2 = 1’b1; // iesirile active (nu si pentru celelalte iesiri)
3 : y3 = 1’b1;
default : {y3,y2,y1,y0} = 4'bx;
endcase
endmodule

latchuri pe ieşiri

Circuitul electronic
obţinut după etapa
de sinteză logică 28
 Introducerea semnalelor de activare
 Semnalul de activare (enable) controlează semnal de control = controlează
activarea decodificatorului
funcţionarea circuitului combinaţional;
 Semnal de control are prioritate maximă: => codul
descrie o logică prioritară; se utilizează specificaţia
condiţională if; en

 Comportament: dacă semnalul de activare este activ, cod 2 4 iesire

di y
atunci circuitul îşi îndeplineşte funcţia, dacă semnalul de binar date
activare nu este activ, atunci circuitul combinaţional este
inactiv şi furnizează pe ieşiri valori inactive (0 sau starea
de înaltă impedanţă z) dcd2to4
module dcd2to4(en, di, y);
input en; // intrare de activare
input [1:0] di; // intrari date = cod binar
output reg [3:0] y; // iesiri date

always @ (en or di) // in lista de senzitivitati se introduc toate intrarile

if (en) // prin acest if, functionarea circuitului este

// controlata de semnalul de activare en (prioritate max)
case (di)
0 : y = 4‘b0001;
1 : y = 4’b0010;
2 : y = 4‘b0100;
3 : y = 4‘b1000;
default : y = 4'b0;
endcase
else // pentru a nu se genera latch-uri este obligatorie
y = 4’b0; // specificatia else, care acopera restul combinatiilor
// posibile de valori pentru semnalele de intrare 29
endmodule
 Modelarea bufferului trei-stari (tri-state buffer)
semnal de control = controlează
 Semnalul de activare (output_enable) controlează activarea bufferului
funcţionarea bufferului;
 Semnal de activare are prioritate maximă: => codul
descrie o logică prioritară; se utilizează specificaţia data oen
condiţională if; intrare
di y iesire
 Comportament: dacă semnalul de activare este activ
atunci la iesire este furnizată data de intrare, dacă
semnalul de activare nu este activ, atunci ieşirea bufferului
trece în starea de înaltă impedanţă
buf1

module buf1(oen, di, y); // VARIANTA 1: buffer TS pe 1 bit

input oen; // intrare de activare
input di; // intrare date
output reg y; // iesire date

always @ (oen or di) // in lista de senzitivitati se introduc toate intrarile

if (oen) y = di;
else y = 1’bz;
endmodule

module buf1(oen, di, y); // VARIANTA 2- modelare dataflow: buffer TS pe 1

// bit modelat prin intermediul
// operatorului de selectie ?
input oen; // intrare de activare
input di; // intrare date
output y; // iesire date

assign y = oen? di : 1’bz;

30
endmodule
Sinteza logică şi implementarea FPGA a bufferului TS

Ciruitul electronic obţinut după etapa de sinteza logică

buffer

Implementarea în FPGA

31
 Componente parametrizabile – declararea parametrilor in
Verilog 1995

N M
intrare di y iesire

Circuit

module Circuit (di, y); // VARIANTA 1:

// dimensiunile bus-urilor se definesc // parametri ramin la valorile initiale
// ca parametri; // N si M ,unde N,M = numere naturale
// valorile N si M sunt numere naturale
Circuit U1 (
Instanţiere .di (semnal_extern),
parameter inpSize = N; module
parameter outSize = M; .y (semnal_extern)
);
// dimensiunea buss-urilor este
// declarata in functie de parametri // VARIANTA 2:
// redimensionarea parametrilor
input [inpSize-1:0] di; // precizarea noilor valori se face
// prin intermediul unei liste de valori
output [outSize-1:0] y; // in care valorile sunt asociate
……… // parametrilor prin pozitie
endmodule // inpSize = 3, outSize = 8

Circuit # (3,8) U2(

.di (semnal_extern),
.y (semnal_extern)
);
32
 Exemplu de multiplexor parametrizabil – declararea
parametrilor in Verilog 1995

// multiplexor cu 4 intrari de date pe 8 biti

module Mux4 (sel, di3, di2, di1, di0, y);

parameter inpNumber = 2; // seteaza nr. intrari date;

// nr.intrari date = 2**inpNumber
parameter dataSize = 8; // dimensiunea datelor

input [inpNumber-1:0] sel; // intrare selectie

input [dataSize-1:0] di3, di2, di1, di0; // intrari date pe 8 biti
output reg [dataSize-1:0] y; // iesire date pe 8 biti

always @(sel or di3 or di2 or di1 or di0)

case (sel)
0: y = di0;
1: y = di1;
2: y = di2;
3: y = di3;
default : y = {dataSize{1'b x}}; // x este concatenat de dataSize ori
endcase
endmodule

33
 Exemplu de demultiplexor parametrizabil

// demultiplexor cu 4 iesiri de date pe 8 biti

module Dmux4 (sel, di, y0, y1, y2, y3);

parameter outNumber = 2; // seteaza numarul de iesiri; nr.iesiri=2**outNumber

parameter dataSize = 8; // dimensiunea datelor

input [outNumber-1:0]sel; // intrare selectie

input [dataSize-1:0] di; // intrare date
output reg [dataSize-1:0] y0, y1, y2, y3; // iesiri date

always @(sel or di)

case (sel)
0: begin y0 = di; y1 = 'b0; y2 = 'b0; y3 = 'b0; end
1: begin y0 = ’b0; y1 = di; y2 = 'b0; y3 = 'b0; end
2: begin y0 = 'b0; y1 = 'b0; y2 = di; y3 = 'b0; end
3: begin y0 = 'b0; y1 = 'b0; y2 = 'b0; y3 = di; end
default : begin y0 = 'b0; y1 = 'b0; y2 = 'b0; y3 = 'b0; end
endcase

endmodule

34
 Exemplu de demultiplexor parametrizabil – declararea
parametrilor in Verilog 2001
// demultiplexor cu 4 iesiri de date pe 8 biti
module Dmux4 #
(
parameter outNumber = 2, // seteaza numarul de iesiri; nr.iesiri=2**outNumber
parameter dataSize = 8 // dimensiunea datelor
)
(
input [outNumber-1:0] sel, // intrare selectie
input [dataSize-1:0] di, // intrare date
output reg [dataSize-1:0] y0, y1, y2, y3 // iesiri date
);
always @(sel or di)
case (sel)
0: begin y0 = di; y1 = 'b0; y2 = 'b0; y3 = 'b0; end
1: begin y0 = ’b0; y1 = di; y2 = 'b0; y3 = 'b0; end
2: begin y0 = 'b0; y1 = 'b0; y2 = di; y3 = 'b0; end
3: begin y0 = 'b0; y1 = 'b0; y2 = 'b0; y3 = di; end
default : begin y0 = 'b0; y1 = 'b0; y2 = 'b0; y3 = 'b0; end
endcase

endmodule

// instantierea modulului cu parametri in Verilog2001: valorile parametrilor se pot

// specifica explicit

Dmux4 #(.outNumber(…), .dataSize(…)) numeComponenta (.sel(…),.di(…),.y0(…),.y1(…),.y2(…),.y3(…));

35
 Modelarea întârzierilor specifice circuitelor
combinaţionale (modelarea timpului de propagare tPD)
`timescale 1ns/1ns
module c02ex06 (
input [1:0] in1, in2,
output reg [2:0] outA, outB, outC, outD,
output [2:0] outE); Blocheaza executia buclei pina la
executia instructiunii de atribuire
always @*
#10 outA = in1 + in2;
always @* Lasa libera executia buclei chiar
outB = #10 in1 + in2; daca executia instructiunii de
always @* atribuire nu s-a executat
#10 outC <= in1 + in2;
always @*
outD <= #10 in1 + in2;
assign #10 outE = in1 + in2; modelarea corecta a intârzierii tPD

endmodule

36
 Modelarea testbench-urilor

Generator stimuli

stimuli

Device Under Test Model referinta

raspuns real raspuns ideal

Bloc asertii

mesaje
depanare si
informatii

37
 Exemplu de modelare testbench
// exemplu de testare a functionarii unui multiplexor
`timescale 1ns/10ps
module testMux2;

// declaratiile stimulilor
reg selS, di1S, di0S;
// declaratiile raspunsurilor DUT / REF
wire doutDUT, doutREF;

// valorile stimulilor sunt generate intr-un task, ca argumente la apelul taskului

// taskul reprezinta un scenariu de testare
task test1 (input selV, di1V, di0V);
begin
selS = selV;
di1S = di1V;
di0S = di0V;
#10; // se introduce o intirziere intre 2 seturi distincte de stimuli

end
endtask

// definirea generatorului de stimuli

initial
begin
test1 (1'b0, 1'b1, 1'b0);
test1 (1'b1, 1'b1, 1'b0);
test1 (1'b0, 1'b1, 1'b1);
test1 (1'b1, 1'b0, 1'b0);
$finish;
end
38
 Exemplu de modelare testbench - continuare
// instantiere DUT (Device Under Test) = dispozitivul a carui functionare este testata
mux2 DUT(
.sel (selS),
.di1 (di1S),
.di0 (di0S),
.dout (doutDUT));
// instantiere MODEL DE REFERINTA = contine modelul ideal al DUT
mux2Ideal REF(
.sel (selS),
.di1 (di1S),
.di0 (di0S),
.dout (doutREF));

// definire bloc asertii = responsabil cu generarea mesajelor utilizate in verificare

always @(selS, di0S, di1S)
Begin
// cu comanda $monitor se afiseaza valorile stimulilor si a raspunsurilor
$monitor ($time, ": sel = %b, di1 = %b, di0 = %b, doutDUT = %b, doutREF = %b",
selS, di1S, di0S, doutDUT, doutREF);
// se introduce o intirziere; in caz contrar, comanzile $display
// se executa inaintea comenzii $monitor
#0.01
$display();
if (doutDUT == doutREF)
$display ("la timpul: %d testul este trecut", $time);
else
$display ("la timpul: %d eroare in circuit", $time);
end

endmodule
39
 Modelarea VHDL a
circuitelor combinaţionale

40
 Specificaţii selecţie vs.
condiţionale
CASE semnal_selectie IS IF conditie_1 THEN instrucţiuni_1;
WHEN valoare_1  instrucţiuni_1; ELSIF conditie_2 THEN instrucţiuni_2;
WHEN valoare_2  instrucţiuni_2; ...
....... ELSE instrucţiuni_n;
WHEN valoare_n  instrucţiuni_n; END IF;
END CASE;
se introduc numai în interiorul proceselor

WITH semnal_selectie SELECT semnal_tinta 

semnal_tinta  optiune_1 WHEN conditie_1 ELSE
optiune_1 WHEN valoare_1_semnal_selectie, optiune_2 WHEN conditie_2 ELSE
optiune_2 WHEN valoare_2_semnal_selectie, ...
... optiune_n;
optiune_n WHEN valoare_n_semnal_selectie;
se introduc numai în exteriorul proceselor
sunt executate concurent cu procesele

41
 Specificaţii condiţionale
se recomandă utilizarea acestora NUMAI
pentru descrierea sistemelor digitale a căror
comportament depinde de o logică prioritară.

42
 Specificaţii de selecţie
se utilizează pentru descrierea sistemelor digitale la
care semnalele de intrare au valori mutual exclusive.

43
Exemplu specificaţii selecţie vs. condiţionale

44
 Inferarea (generarea)
latch-urilor
pentru toate combinaţiile posibile de valori/
combinaţiile logice ale semnalelor de intrare,
tuturor semnalelor de ieşire ale sistemului
combinaţional trebuie să li se asigure o cale
logică, prin care acestora să li se atribuie o
valoare.

45
• În cazul sistemelor combinaţionale, toate
semnalele de intrare ale acestora trebuie
introduse în lista de senzitivităţi a
procesului care descrie comportamentul
sistemului respectiv.
• În lista de senzitivităţi a procesului nu se
introduc semnale de ieşire

46
 Exemplu de generare a
latch-urilor
library ieee;
use ieee.std_logic_1164.all;
entity DCD is
port(
X : in std_logic;
Y : out std_logic_vector(1 downto 0));
end;
architecture GRESIT of DCD is
begin
comb:process(X)
begin
Y <= “00”’; // Y trebuie initializat!
case X is
when ‘0’ => Y(0) <= ’1’;
when ‘1’ => Y(1) <= ’1’;
when others => Y <= (others=>'0');
end case;
end process;
end GRESIT;

47
48
 Exemplu de generare a latch-
urilor
library ieee;
use ieee.std_logic_1164.all;
entity DPAR is
port(
EN : in std_logic;
X : in std_logic_vector(1 downto 0);
Y : out std_logic);
end;
architecture GRESIT of DPAR is
begin
comb:process(X, EN)
begin
if EN=‘0’ then // care este comportamtnul daca EN diferit de 0?
if (X=“00”) or (X=“11”) then y<=‘0’;
elsif (X=“01”) or (X=“10”) then y<=‘1’;
end if;
end if;
end process;
end GRESIT;

WARNING:Xst:737 - Found 1-bit latch for signal <Y>. 49

50
 Descrierea comportamentală a
multiplexoarelor
entity MUX is port ( entity MUX is port (
di_mux : in std_logic_vector(3 donwto 0); di_mux : in std_logic_vector(3 downto 0);
sel_mux: in std_logic_vector (1 downto 0); sel_mux : in std_logic_vector (1 downto 0);
do_mux : out std_logic); do_mux : out std_logic);
end MUX; end MUX;
architecture beh of MUX is begin architecture beh of MUX is begin
comb:process (di_mux, sel_mux) begin with sel_mux select
case sel_mux is do_mux<=
when "00" => do_mux <= di_mux(0); di_mux(0) when "00",
when "01 " => do_mux <= di_mux(1); di_mux(1) when "01",
when "10 " => do_mux <= di_mux(2); di_mux(2) when “10",
when "11 " => do_mux <= di_mux(3); di_mux(3) when “11",
when others => do_mux <= ‘-’; ‘-’ when others;
end case; end beh;
end process;
end beh;

51
 Descrierea comportamentală a
codificatoarelor prioritare
entity COD is port ( entity COD is port (
di_cod : in std_logic_vector (7 downto 0); di_cod : in std_logic_vector (7 downto 0);
do_cod : out std_logic_vector (2 downto 0)); do_cod : out std_logic_vector (2 downto 0));
end COD; end COD;
architecture beh of COD is architecture beh of COD is begin
do_cod <=
begin
"000" when di_cod(0)='1‘ else
process(di_cod) begin "001" when di_cod(1)='1‘ else
do_cod < ="000"; "010" when di_cod(2)='1‘ else
if di_cod(0)='1'then do_cod <= "000"; "011" when di_cod(3)='1‘ else
elsif di_cod(1)='1'then do_cod <= "001"; “100" when di_cod(4)='1‘ else
elsif di_cod(2)='1'then do_cod <= "010"; “101" when di_cod(5)='1‘ else
elsif di_cod(3)='1'then do_cod <= "011"; “110" when di_cod(6)='1‘ else
elsif di_cod(4)='1'then do_cod <= "100"; “111" when di_cod(7)='1‘ else
elsif di_cod(5)='1'then do_cod <= "101"; "000";
elsif di_cod(6)='1'then do_cod <= "110"; end beh;
elsif di_cod(7)='1'then do_cod <= "111";
end if;
end process;
end beh;

52
Descrierea comportamentală a
decodificatoarelor
entity DEC is port(
di_dcd : in std_logic_vector(1 downto 0);
en_dcd : in std_logic;
do_dcd : out std_logic_vector(3 downto 0));
end DEC;
architecture beh of DEC is begin
comb:process(di_dcd,en_dcd) begin
if en_dcd ='1' then
do_dcd <= "0000"; -- initializare!
case di_dcd is
when "00" => do_dcd(0) <= '1';
when "01" => do_dcd(1) <= '1';
when "10" => do_dcd(2) <= '1';
when "11" => do_dcd(3) <= '1';
when others => do_dcd <= (others=>’0’);
end case;
else
do_dcd <= "0000";
end if;
end process;
end beh;

53
Descrierea comportamentală a
bufferelor TS
entity MUX is
port (
di_mux : in std_logic_vector(1 downto 0);
sel_mux : in std_logic;
oe_mux : in std_logic;
do_mux : out std_logic);
end MUX;
architecture beh of MUX is
signal tmp_mux: std_logic;
begin
comb:process (di_mux, sel_mux) begin
case sel_mux is
when ‘0’=> tmp_mux <= di_mux(0);
when ‘1’=> tmp_mux <= di_mux(1);
when others=> tmp_mux <= ‘-’;
end case;
end process;
-- varianta 1
do_mux <= tmp_mux WHEN (oe_mux=’1’) ELSE ‘Z’;
-- varianta 2
iesire: process (oe_mux,tmp_mux) begin
if (oe_mux=’1’) then do_mux <= tmp_mux;
else do_mux <= ’Z’;
end if;
end process;
end BEH;

54