Capitolul 6

Tehnici de bază
în modelarea VHDL

6.1 Modelarea întârzierilor

6.2 Modelarea circuitelor combinaţionale
şi secvenţiale
6.3 Primitive logice
 6.1 Modelarea întârzierilor
Întârzieri de propagare
Semnalele electronice trebuie să respecte legile de bază ale fizicii.
Valorile logice '0' şi '1' sunt implementate în circuitele reale cu
ajutorul a două niveluri diferite de tensiune. Datorită capacităţii
circuitului, nivelurile de tensiune la un nod oarecare al circuitului
nu se pot schimba instantaneu. În consecinţă, într-un circuit real,
există întotdeauna o întârziere finită între momentul la care
intrarea unei porţi îşi modifică valoarea şi momentul la care se va
schimba ieşirea corespunzătoare. Limbajul VHDL foloseşte notaţia
<= pentru a indica schimbarea valorii unui semnal care va avea
loc după o anumită întârziere de propagare.
În modelele de nivel înalt, conceptul standard de asignare de
variabilă, trebuie aplicat şi pentru a descrie algoritmi în maniera
tradiţională. În acest context, asignarea noilor valori unor variabile
este instantanee. Limbajul VHDL foloseşte notaţia := pentru a
indica a asignare instantanee de variabilă. Următoarele
instrucţiuni ilustrează cele două concepte:
6.1 Modelarea întârzierilor (cont.)

(1)AS <= X * Y after 2 ns; -- asignare de semnal

întârziată
(2) BS <= AS + Z after 2 ns; -- asignare de semnal
întârziată
Aceste două instrucţiuni sunt instrucţiuni de asignare de semnale.
Întârzierea de propagare pentru fiecare din aceste asignări de
semnal este specificată, 2 ns. Instrucţiunile de asignare instantanee
de variabile sunt scrise sub forma:
(3) AV := X * Y; -- asignare instantanee de
variabilă;
(4) BV := AV + Z; -- asignare instantanee de
variabilă;
Deşi acestea sunt concepte evidente, uşor de înţeles, întârzierea de
propagare poate produce rezultate neanticipate. Pentru a ilustra
diferenţa dintre asignarea instantanee de variabile şi asignarea
întârziată de semnale, vom presupune că cele patru instrucţiuni
sunt instrucţiuni secvenţiale în interiorul unor procese care sunt
executate în ordinea în care sunt scrise.
 6.1 Modelarea întârzierilor (cont.)

În continuare, presupunem că procesele care conţin instrucţiunile sunt

executate la t = t1 şi la intervale de 2 ns după momentul t1. Întârzierea
asociată cu instrucţiunile de asignare de semnale este de asemenea 2 ns. În
plus, presupunem că pentru cele două situaţii există condiţii iniţiale identice,
după cum se arată în coloana din stânga în Figura 6.1. Vom presupune că
formele de undă pentru intrările întregi X, Y, Z sunt:

X 1 4 5 5 3

Y 2 2 2 3 2

Z 0 3 2 2 2
t1 t1+2 t1+4 t1+6
6.1 Modelarea întârzierilor (cont.)

În Figura 6.1 se prezintă rezultatele atât pentru asignările întârziate de

semnale cu întârziere de propagare cât şi pentru asignările instantanee
de variabile. La t = t1, variabilele AV şi BV iau noile valori, 8 şi respectiv
11. Pentru că noile valori sunt actualizate la momentul la care se
execută instrucţiunea, AV este mai întâi actualizat la noua lui valoare, 8,
când instrucţiunea (3) este executată. Instrucţiunea (4) foloseşte apoi
noua valoare, 8, a lui AV când calculează noua valoare pentru BV, care
este 11. BV îşi ia noua valoare imediat la t = t1.

Iniţial t1 t1+2 t1+4 t1+6

X 1 4 5 5 3
Y 2 2 2 3 2 Fig. 6.1
AV 2 8 10 15 6
Z 0 3 2 2 2
BV 2 11 12 17 8
6.1 Modelarea întârzierilor (cont.)

În mod similar, la t = t1, instrucţiunea (1) calculează o nouă valoare,

8, pentru semnalul AS. Dar, semnalul AS nu va lua această nouă
valoare până la momentul t1+2 din cauza întârzierii de propagare.
Prin urmare, când se execută instrucţiunea (2), la momentul t = t1,
valoarea lui AS va fi tot 2. Deci, noua valoare pentru BS va fi 5. Din
nou, BS nu îşi va lua noua valoare până la t1+2.

Iniţial t1 t1+2 t1+4 t1+6

X 1 4 5 5 3
Y 2 2 2 3 2 Fig. 6.1
AS 2 2 8 10 15
Z 0 3 2 2 2
BS 2 2 5 10 12

AS <= X * Y after 2 ns; BS <= AS + Z after 2 ns;

6.1 Modelarea întârzierilor (cont.)

La t = t1+2 ns, semnalele AV şi BV sunt actualizate la noile lor valori,

8 şi respectiv 11; apoi, toate instrucţiunile se execută din nou în
ordinea în care sunt scrise. Şi de această dată, variabilele îşi iau noile
valori imediat, iar instrucţiunea (4) foloseşte noua valoare a lui AV,
calculată de instrucţiunea (3), pentru a calcula noua valoare pentru
BV. Instrucţiunea (1) calculează noua valoare, 10, pentru AS. Totuşi,
pentru că AS nu îşi ia noua valoare până la momentul t1+4,
instrucţiunea (2) va calcula o nouă valoare, 10, pentru BS folosind
valoarea curentă, 8, pentru AS. Din nou, BS nu îşi va lua noua
valoare până la momentul t1+4.
Se observă că schimbarea valorii lui X la momentul t1 nu afectează
semnalul BS până la momentul t1+4, datorită întârzierii de propagare.
Schimbarea lui X la t1 are efect imediat asupra variabilei BV la t1,
pentru că variabilele sunt actualizate instantaneu. Şi mai important
este faptul că efectul final asupra lui BV şi BS este semnificativ diferit
pentru cele două cazuri. În mod clar, BS nu este numai o versiune
întârziată a lui BV. Întârzierea de propagare a schimbat valorile
curente ale lui BS în raport cu BV, şi nu a întârziat numai schimbările.
6.1 Modelarea întârzierilor (cont.)

Pentru că instrucţiunile de asignare de variabile au fost introduse

pentru a permite dezvoltarea algoritmilor şi pentru că ele nu permit
întârzieri de propagare, aceste instrucţiuni sunt restricţionate de
regulile de sintaxă la folosirea în procese, funcţii şi proceduri.
Deci, declaraţiile de variabile trebuie să fie în interiorul
proceselor sau subprogramelor. Declaraţiile de variabile nu sunt
acceptate în regiunile declarative pentru arhitecturi sau blocuri.
Pentru că toate porturile entităţilor corespund unor semnale în
circuite reale şi pentru că arhitecturile trebuie să reprezinte
comportarea entităţilor, toate declaraţiile de porturi şi obiecte din
arhitecturi trebuie să fie semnale. Semnalele interne pot fi
declarate în regiunile declarative ale regiunilor şi blocurilor, dar nu în
interiorul proceselor şi subprogramelor. Totuşi instrucţiunile de
asignare de semnale pot apărea oriunde.
6.1 Modelarea întârzierilor (cont.)

Modelul din Figura 6.2 satisface toate restricţiile discutate mai sus.
După cum am discutat în Capitolul 4, instrucţiunile dintr-un proces
sunt întotdeauna executate în ordinea în care sunt scrise. Adică,
aceste instrucţiuni sunt instrucţiuni secvenţiale. Instrucţiunile de
asignare de semnale din procesul PROP_DELAY şi cele de asignare
de variabile din procesul INSTANTANEOUS sunt secvenţiale.
entity STATEMENTS is
port(X,Y,Z: in INTEGER; -- Porturile entitatii sunt
B: out INTEGER); -- intotdeauna semnale
end entity STATEMENTS;
architecture PROP_DELAY of STATEMENTS is
signal AS: INTEGER;
begin
process (X,Y,Z)
begin
AS <= X*Y after 2 ns; --Instructiunea (1)
B <= AS+Z after 2 ns; --Instructiunea (2)
end process;
end architecture PROP_DELAY;
6.1 Modelarea întârzierilor (cont.)

architecture INSTANTANEOUS of STATEMENTS is

begin
process(X,Y,Z)
variable AV,BV: INTEGER;
begin
AV := X*Y; --Instructiunea (3)
BV := AV+Z; --Instructiunea (4)
B <= BV;
end process;
end architecture INSTANTANEOUS;

În procesul INSTANTANEOUS, ordinea instrucţiunilor este critică.

Dacă instrucţiunea (4) se execută înaintea instrucţiunii (3),
rezultatele sunt diferite. Această situaţie trebuie privită în contrast
cu aceea a aignărilor de semnale din procesul PROP_DELAY.
Pentru că ambele asignări de semnale folosesc valorile curente
pentru toate semnalele din partea dreaptă, şi pentru că noile valori
calculate pentru semnalele din stânga nu devin efective decât 2 ns
mai târziu, instrucţiunile (1) şi (2) ar putea fi executate în orice
ordine, fără a afecta rezultatul calculat.
6.1 Modelarea întârzierilor (cont.)

După cum ştim, instrucţiunile care se pot executa simultan se

numesc instrucţiuni concurente. Deci, instrucţiunile (1) şi (2) pot
apărea ca instrucţiuni concurente în interiorul unui corp
arhitectural. Ele nu trebuie să fie plasate în interiorul unui proces.
Rezultatul simulării ar fi acelaşi în oricare caz. Această posibilitate
există datorită întârzierii care apare la actualizarea noilor valori
pentru semnale. În paragraful următor vom arăta cum poate folosi
simulatorul VHDL conceptul de întârziere pentru a modela
concurenţa.
6.1 Modelarea întârzierilor (cont.)

Întârziere şi concurenţă
Pentru că semnalele logice se transmit în paralel, modelele VHDL
pentru circuite logice trebuie să includă posibilitatea de concurenţă a
execuţiei. Fig. 6.3 ilustrează acest concept, folosind trei blocuri logice.
Dacă se presupune că setul de intrare 1 şi setul de intrare 2 sunt
activate simultan,blocurile logice 1 şi 2 vor fi activate în paralel. Blocul
logic 3 va fi activat de îndată ce oricare dintre ieşirile din blocul 1 (Z1)
sau din blocul 2 (Z2) se modifică. În timp ce semnalele se propagă
prin blocul logic 3, noi schimbări în semnalele de intrare se pot
propaga prin blocurile 1 şi 2. Deci, transmisia semnalelor poate avea
loc prin toate cele trei blocuri simultan.
Fig. 6.3 Transformarea
blocurilor
Set de
logice în procese.
intrare 1 Bloc logic
Z1
1
Bloc logic Ieşire
3
Set de
intrare 2 Bloc logic Z2
2
6.1 Modelarea întârzierilor (cont.)

Un limbaj de descriere hardware trebuie să ofere un mecanism

pentru modelarea acestei simultaneităţi. În VHDL, această cerinţă
este realizată prin construcţia de proces. Fiecare proces reprezintă
un bloc cu elemente logice şi toate procesele se execută în paralel.
(Desigur, dacă simulatorul funcţionează pe un sistem
monoprocesor, ele se execută de fapt într-o anumită secvenţă, dar
efectul observat din punctul de vedere al simulării este că ele se
execută în paralel.). Folosind Fig. 6.3 şi presupunând că este
cunoscută funcţionalitatea blocurilor, se poate crea un proces VHDL
pentru fiecare bloc logic. Lista de sensibilitate pentru un proces
conţine, în general, setul de semnale de intrare pentru blocul
respectiv. Concret, blocul logic 1 poate fi reprezentat de procesul din
Fig.6.4.
LOGIC_BLOCK1: process (X1, X2, X3) Fig. 6.4 Exemplu
variable YINT: BIT; de proces.
begin
YINT := X1 and X2;
Z1 <= YINT or X3 after 30 ns;
end process LOGIC_BLOCK1;
6.1 Modelarea întârzierilor (cont.)

În această figură, corpul procesului conţine mai întâi o secţiune

declarativă, unde se declară variabila YINT care este locală pentru
proces. Secţiunea executabilă, dintre cuvintele cheie begin şi end
constă dintr-o asignare de variabilă care calculează o valoare
intermediară (YINT) urmată de o asignare de semnal care include
întârzierea de propagare a semnalului prin blocul respectiv.
Ideea de proces poate fi exprimată şi prin asignări de semnale. Să
considerăm următoarele două asignări de semnale:

AS <= X * Y; -- Instrucţiunea S1
BS <= AS + Z; -- Instrucţiunea S2

Aceste instrucţiuni sunt tipărite în ordine textuală, aşa încât tendinţa

naturală este aceea de a spune că ele se execută în secvenţa în
care sunt tipărite. Aceasta înseamnă execuţie secvenţială [31].
6.1 Modelarea întârzierilor (cont.)

Totuşi, aceste două instrucţiuni pot fi interpretate şi în alt mod. S1 şi

S2 pot fi tratate ca instrucţiuni concurente de asignare de semnale.
În acest sens, ele acţionează ca procese. Lista de sensibilitate
pentru S1 conţine pe X şi Y, iar lista pentru S2 este alcătuită din AS
şi Z. În această interpretare, instrucţiunea S1 va fi executată ori de
câte ori X sau Y îşi schimbă valoarea. Instrucţiunea S2 se va
executa ori de câte ori AS sau Z îşi schimbă valoarea. De exemplu,
asignarea concurentă de semnal:
AS <= X * Y; -- instr. concurentă asign. semnal
este echivalentă cu procesul:
process (X, Y) – instr. echivalentă de proces
begin
AS <= X * Y;
end process;
Pentru că nu se menţionează explicit un timp de propagare, timpul
implicit este întârzierea delta. Aceasta are o valoare timp foarte
mică, mai mare decât zero, dar mai mică decât oricare alt interval
care se poate specifica.
6.1 Modelarea întârzierilor (cont.)

Să considerăm acum execuţia lui S1 şi S2, când acestea sunt privite

ca procese concurente. Presupunem că X şi Y se achimbă la
momentul t1. Atunci, atât S1 cât şi S2 sunt activate. În acest caz,
valoarea lui AS folosită de S2 este vechea valoare a lui AS la t1 şi
nu noua valoare a lui AS calculată de S1, pentru că această nouă
valoare nu va fi disponibilă decât la t1+delta. Dacă această nouă
valoare reflectă o schimbare în AS, S2 va fi activată din nou la
t1+delta pentru a calcula o nouă valoare BS, pe baza noii valori a
lui AS.
În Figura 6.5 se ilustrează acest concept, folosind exemplul din
paragraful precedent. Ne amintim că X şi Z îşi schimbă valoarea,
ambele, la t = t1.
6.1 Modelarea întârzierilor (cont.)

Pentru că X îşi schimbă valoarea la t1, instrucţiunea S1 se execută

la t = t1. Ea calculează o nouă valoare, 8, pentru semnalul AS, dar
AS nu îşi ia noua valoare până la t1+delta. Similar, pentru că Z se
schimbă la t = t1, instrucţiunea S2 se va executa la t = t1. Ea
calculează o nouă valoare, 5, pentru BS pentru că AS are încă
valoarea 2, iar Z are valoarea 3. BS îşi ia noua valoare la momentul
t1+delta.
La momentul t1+delta, AS şi BS îşi iau, ambele, noile valori (8 şi
respectiv 5) calculate la momentul t1. Pentru că AS se schimbă la
acest moment, S2 se execută din nou la t = t1+delta. Ea
calculează o nouă valoare, 11, pentru semnalul BS care nu va fi luată
efectiv până la momentul t1+2*delta. Schimbarea lui X la t1 are
efect asupra lui AS la t1+delta şi asupra lui BS la momentul
t1+2*delta. Deci, asignările concurente de semnale se comportă
în mod asemănător cu întârzierile finite de propagare, datorită
construcţiei întârzierii delta.
6.1 Modelarea întârzierilor (cont.)

Iniţial t1 t1+delta t1+2*delta

X 1 4 4 4
Y 2 2 2 2
AS 2 2 8 8
Z 0 3 3 3
BS 2 2 5 11

Fig. 6.5 Asignare concurentă de semnal.

6.1 Modelarea întârzierilor (cont.)

Instrucţiuni secvenţiale şi instrucţiuni concurente în VHDL

Pentru că nu se poate deduce, în general, din text dacă este

implicată o execuţie secvenţială sau una concurentă, trebuie să se
folosească fie o notaţie specială fie semantica limbajului pentru a
specifica modul de execuţie. În VHDL se foloseşte semantica
limbajului. Dacă instrucţiunile sunt direct în declaraţia de
arhitectură, este vorba despre o execuţie concurentă; Dacă
instrucţiunile apar în interiorul unui proces sau subprogram, este
vorba despre execuţie secvenţială. În Figura 6.6 sunt aplicate
aceste concepte. Intrările entităţii STATEMENTS sunt X, Y, Z. Cu
arhitectura CONCURRENT, AS şi BS sunt declarate ca semnale; AS
este un semnal intern iar BS este un semnal port. Cele două
asignări de semnale sunt inserate în secţiunea de cod a corpului
arhitectural. Deci, este implicată execuţia concurentă. Ele pot fi
scrise în orice ordine, iar efectul va fi acelaşi.
6.1 Modelarea întârzierilor (cont.)

entity STATEMENTS is
port(X,Y,Z: in INTEGER; -- Toate porturile
-- entitatii
BS: out INTEGER); -- sunt intotdeauna
-- semnale
end entity STATEMENTS;

architecture CONCURRENT of STATEMENTS is

signal AS: INTEGER;
begin
AS <= X*Y; --Instructiunea S1
BS <= AS+Z; --Instructiunea S2
end architecture CONCURRENT;
6.1 Modelarea întârzierilor (cont.)

În arhitectura SEQUENTIAL, asignările de variabile S3 şi S4 sunt

inserate în interiorul unui proces unde sunt declarate două variabile
locale. Pentru că ele apar într-un proces, vor fi executate exact în
secvenţa în care apar. Aici, ordinea lui S3 şi S4 este importantă.
Rezultatul calculului, BV, este asignat unui semnal, astfel că
valoarea lui poate fi observată la un port extern. Trebuie accentuat
că instrucţiunile de asignare de semnale pot fi instrucţiuni
secvenţiale sau concurente.
architecture SEQUENTIAL of STATEMENTS is
begin
process(X,Y,Z)
variable AV,BV: INTEGER;
begin
AV := X*Y; --Instructiunea S3
BV := AV+Z; --Instructiunea S4
BS <= BV;
end process;
end architecture SEQUENTIAL;
6.1 Modelarea întârzierilor (cont.)

Întârzieri inerţiale şi de transport în propagarea semnalelor

După cum am mai menţionat, în realitate, noile tranzacţii se suprapun

cu cele în curs de execuţie în funcţie de mecanismul de întârziere
folosit. Acesta este reprezentat în partea opţională a instrucţiunilor de
asignare prezentate în Capitolul 3. Regula de sintaxă pentru
mecanismul de întârziere este

mecanism_de_întârziere
<= transport | [ reject expresie_time ] inertial

O asignare de semnal la care se omite specificarea mecanismului de

întârziere este echivalent cu specificarea inerţial. De exemplu,
Z <= I after 10 ns; --întârziere inerţială
Propagarea semnalului va avea loc dacă şi numai dacă intrarea I se
menţine la nivelul dat timp de 10 ns - timpul specificat în clauza after.
Deci, schimbările în I vor afecta Z numai dacă noua valoare a lui I se
menţine la noul nivel timp de 10 ns sau mai mult.
6.1 Modelarea întârzierilor (cont.)

Mecanismul de întârziere de transport .

Z <= transport I after 10 ns; --înt. de transport.
Toate schimbările în I se vor propaga la Z fără a avea importanţă
cât timp va sta I la noua valoare.
Folosim mecanismul de întârziere transport atunci când modelăm
un dispozitiv ideal cu răspuns infinit în frecvenţă, la care oricare
impuls de intrare, oricât de scurt, produce un impuls de ieşire. Un
exemplu este o linie de transmisie ideală, care transmite toate
schimbările de la intrare întârziate cu un anumit interval de timp. Un
proces care modelează o astfel de linie cu o întârziere de 500 ps:
transmission_line: process (line_in) is
begin
line_out <= transport line_in after 500 ps;
end process transmission_line;
În acest model ieşirea urmăreşte orice schimbare de la intrare, dar
cu o întârziere de 500 ps. Dacă intrarea se schimbă de două sau
mai multe ori în timpul unei perioade mai scurtă de 500 ps,
tranzacţiile planificate sunt aşezate la coadă de un driver până la
timpul de simulare la care ele trebuie să se aplice (Figura 6.12)
 line_in

line_out

200 400 600 800 1000 ps

700 ps 700 ps 1000 ps
'1' '1' '0'

1000 ps
'0'

Fig. 6.12 Tranzacţii planificate la coadă de un driver folosind întârzierea de transport.

La momentul 200 ps se modifică intrarea, şi se planifică o tranzacţie pentru 700 ps.
La timpul 500 ps, intrarea se schimbă din nou, şi o altă tranzacţie este planificată la 1000 ps.
Aceasta este aşezată la coadă, după tranzacţia anterioară.
Când timpul de simulare atinge 700 ps, se aplică prima tranzacţie, iar a doua rămâne la coadă.
La sfârşit, timpul de simulare ajunge la 1000 ps şi se aplică tranzacţia finală, lăsând driverul
gol.
Fiecare nouă tranziţie care este generată de o instrucţiune de
asignare de semnal este planificată pentru un timp de simulare ulterior
tranzacţiilor în curs aşezate la coadă de driver. Situaţia este mai
complexă dacă se folosesc întârzieri variabile, pentru că putem
planifica o tranzacţie pentru un timp anterior faţă de tranzacţiile de la
coadă. Semantica mecanismului de întârziere de transport specifică
faptul că, dacă există tranzacţii planificate în driver pentru un timp
ulterior sau identic cu o nouă tranzacţie, tranzacţiile ulterioare se şterg.
 6.1 Modelarea întârzierilor (cont.)

Exemplu
Figura 6.13 prezintă un proces care descrie comportarea unui
element cu întârziere asimetrică, cu timpi de întârziere diferiţi pentru
tranziţiile pozitive şi negative. Întârzierea pentru tranziţiile pozitive
este de 800 ps iar pentru cele negative este de 500 ps.
entity assym_delay is
end entity assym_delay;
architecture test of assym_delay is
signal a, z : bit;
begin
asym_delay : process (a) is
constant Tpd_01 : time := 800 ps;
constant Tpd_10 : time := 500 ps;
begin
if a = '1' then
z <= transport a after Tpd_01;
else -- a = '0'
z <= transport a after Tpd_10;
end if;
end process asym_delay;
end architecture test;
6.1 Modelarea întârzierilor (cont.)

z '0'

200 400 600 800 1000 ps

1000 ps 900 ps tranzacţie aplicată,

'1' ‘0' nu este eveniment

1000 ps
'1'

Fig. 6.14 Tranzacţiile din driver atunci când se folosesc întârzieri de

transport asimetrice. La momentul 200 ps se modifică intrarea şi se
planifică o tranzacţie pentru 1000 ps.
La momentul 400 ps, intrarea se modifică din nou, şi se planifică o altă
tranzacţie pentru 900 ps. Pentru că aceasta este aşezată la coadă
înaintea celei de la 1000 ps, aceea din urmă va fi ştearsă. Când timpul
de simulare ajunge la 900 ps, se aplică tranzacţia care a rămas, dar
pentru că valoarea este '0', nu va apărea eveniment în semnal.
6.1 Modelarea întârzierilor (cont.)

Cele mai multe dispozitive electronice nu au un răspuns infinit în

frecvenţă, aşa încât nu este potrivit să fie modelate cu ajutorul unor
întârzieri de transport. În dispozitivele reale, schimbările valorilor la
nodurile interne şi la ieşiri implică procese de transport de sarcini în
prezenţa unor capacităţi, inductanţe şi rezistenţe. Aceste procese
conferă dispozitivului o anumită inerţie; el va tinde să rămână în
aceeaşi stare până când este forţat prin aplicarea intrărilor un timp
suficient de lung. Din acest motiv VHDL include mecanisme de
întârziere inerţială, pentru a permite modelarea dispozitivelor care
rejectează impulsurile de intrare prea scurte pentru a depăşi inerţia.
Întârzierea inerţială este mecanismul folosit implicit într-o asignare de
semnal, sau îl putem specifica explicit incluzând cuvântul cheie
inerţial.
Pentru a explica modul în care funcţionează întârzierea inerţială, vom
considera un model în care toate asignările pentru un semnal dat
folosesc aceeaşi valoare a întârzierii, 3 ns, cum este cazul modelului
următor de inversor:
6.1 Modelarea întârzierilor (cont.)

inv: process (a) is

begin
y <= inertial not a after 3 ns;
end process inv;

Atâta timp cât evenimentele de la intrare apar la mai mult de 3 ns

unul de celălalt, nu sunt probleme. De fiecare dată când se
execută o asignare de semnal, nu există tranzacţii la coadă, astfel
că se programează o noua tranzacţie, iar ieşirea îşi schimbă
valoarea cu 3 ns mai târziu.
Totuşi, dacă o intrare se schimbă la mai puţin de 3 ns după
schimbarea anterioară, acesta reprezintă un puls cu durata mai
mică decât întârzierea introdusă de dispozitiv, aşa încât ar trebui
să fie rejectat.
6.1 Modelarea întârzierilor (cont.)

Această comportare este prezentată în partea de sus a Figurii 6.15.

Într-un model simplu ca acesta, putem interpreta întârzierea inerţială:
dacă o asignare de semnal ar produce un puls de ieşire mai mic
decât întârzierea de propagare, pulsul de ieşire nu are loc.

a a

y y

2 4 6 8 10 12 14 16 18 20 22 ns
2 4 6 8 10 ns

Fig. 6.15 Rezultatele asignării de semnale folosind mecanismul de întârziere de transport. În

formele de undă de sus, se specifică o întârziere inerţială de 3 ns. Modificarea intrării de la
momentul 1 ns se reflectă la ieşire la momentul 4 ns. Pulsul de la 6 ns la 8 ns este mai mic
decât întârzierea de propagare, aşa încât el nu va afecta ieşirea. În formele de undă din partea
de jos, se specifică o întârziere inerţială de 3 ns şi o limită de rejecţie a pulsului de 2 ns.
Modificările intrării de la momentele 1, 6, 9 şi 11.5 ns sunt toate reflectate le ieşire, pentru că
apar la intervale mai mari de 2 ns. Totuşi, pulsurile de intrare care urmează au lungimea mai
mică sau egală cu limita de rejecţie şi nu vor mai afecta ieşirea.
6.1 Modelarea întârzierilor (cont.)

În continuare. extindem acest model prin specificarea unei limite la

care se produce rejectarea impulsului, după cuvântul reject în
asignarea de semnal:
inv: process (a) is
begin
y <= reject 2 ns inertial not a after 3 ns;
end process inv;
Aceasta se poate interpreta în felul următor: dacă o asignare de
semnal ar produce un puls mai scurt decât (sau egal cu) limita de
rejecţie, pulsul de ieşire nu mai are loc. În acest model simplu,
atâta timp cât schimbările la intrare apar la mai mult de 2 ns, ele
produc schimbări la ieşire cu 3 ns mai târziu, ca în Figura 6.15. De
menţionat că limita de rejecţie specificată trebuie să fie între 0 fs şi
întârzierea specificată în asignarea de semnal. Omiterea limitei de
rejecţie este echivalentă cu specificarea unei limite egală cu
întârzierea, iar specificarea unei limite de 0 fs este acelaşi lucru ca
şi specificarea unei întârzieri de transport.
6.1 Modelarea întârzierilor (cont.)

11 ns 12 ns 14 ns 15 ns 16 ns 17 ns 20 ns 25 ns
'1' 'X' '1' '0' '1' '1' '1' '0'

reţinute reţinute şterse

interval de rejecţie a pulsului (13 ns - 18 ns)

11 ns 12 ns 16 ns 17 ns 18 ns tranzacţie nouă
'1' 'X' '1' '1' '1'

Fig. 6.16 Tranzacţiile înainte (sus) şi după (jos) o asignare de semnal cu întârziere inerţială.
Tranzacţiile de la 20 şi 25 ns sunt şterse deoarece ele sunt planificate mai târziu decât noua
tranzacţie. Cele de la 11 şi 12 ns sunt reţinute pentru că sunt înainte de intervalul de rejecţie a
pulsului. Tranzacţiile de la 16 şi 17 ns sunt în interiorul intarvalului de rejecţie şi sunt de asemenea
reţinute. Celelalte tranzacţii din intervalul de rejecţie sunt şterse.
 6.2 Modelarea circuitelor
combinaţionale şi secvenţiale
VHDL posedă elementele necesare pentru modelarea circuitelor
logice de tip combinaţional şi de tip secvenţial. În Figura 6.18
sunt reprezentate cele două cazuri: în (a) este prezentat un circuit
combinaţional la care ieşirea Z este o funcţie numai de intrarea X şi
care răspunde la schimbările lui X după o întârziere DEL.

DEL DEL

X Z X Z

(a) (b)

Fig. 6.18 Un circuit combinaţional (a) şi unul secvenţial (b).

 Modelarea circuitelor combinaţionale şi secvenţiale (cont.)

Dacă circuitul ar trebui să fie modelat ca o reţea de porţi logice,

graful reţelei ar fi aciclic, adică nu ar conţine legături de reacţie. Un
circuit combinaţional poate fi modelat în VHDL folosind construcţiile
de proces, după cum urmează:
COMBINATIONAL: process (X)
--declaraţii de variabile de proces
variable ZVAR: BIT;
begin
-- se reprezintă funcţionalitatea circuitului
-- se calculează ZVAR
Z <= ZVAR after DEL; -- modelează întârzierea
circuitului
end process COMBINATIONAL;
Atunci când semnalul X din lista de sensibilitate a procesului se
modifică, procesul se execută; adică, lista de sensibilitate este
echivalentă cu intrările circuitului.
Procesul reprezintă funcţionalitatea circuitului prin calcularea valorii
variabilei ZVAR.
Întârzierea introdusă de circuit este modelată prin asignarea lui ZVAR
semnalului Z după intervalul DEL.
Modelarea circuitelor combinaţionale şi secvenţiale (cont.)

Circuitele secvenţiale au legături de reacţie. De exemplu, în Figura

6.18b, circuitul este din nou comandat de intrarea X, dar se formează
două seturi de ieşiri: (1) Z, ieşirile de date ale circuitului şi (2) Y,
variabilele de stare ale circuitului, care sunt transmise înapoi ca intrări
ale circuitului. Acest mecanism de reacţie impune comportarea
secvenţială a circuitului. Procesul SEQUENTIAL de mai jos modelează
această comportare secvenţială.

SEQUENTIAL: process (X, Y)

-- declaraţii de variabile de proces
variable YVAR, ZVAR: BIT;
begin
-- se reprezintă funcţia circuitului
-- se calculează YVAR şi ZVAR
Y <= YVAR after DEL; --întârzierea variabilei stare
Z <= ZVAR after DEL; -- întârzierea ieşirii
end process SEQUENTIAL;
Modelarea circuitelor combinaţionale şi secvenţiale (cont.)

Variabila de stare este memorată în semnalul Y, care este format de

proces. Y este de asemenea în lista de sensibilitate a procesului; prin
urmare, procesul va putea fi declanşat când Y se modifică, modelând
astfel reacţia în circuitul secvenţial. Reacţia conferă circuitelor
secvenţiale proprietatea de memorare. În funcţie de nivelul de
abstractizare folosit, mecanismul de memorare poate fi "mascat" în
model. De exemplu, în modelarea comportamentală a unui registru,
spre deosebire de modelul structural cu o interconexiune de porţi,
reacţia nu este evidentă în model. Vom vedea că alte construcţii ale
limbajului pot fi folosite pentru amodela comportarea secvenţială la
aceste niveluri ridicate de abstractizare.
Modelarea circuitelor combinaţionale şi secvenţiale (cont.)

Exemplu. În Figura 6.19a se prezintă descrierea VHDL pentru un circuit de

decizie majoritară cu trei intrări. Comportarea circuitului este implementată
printr-o singură instrucţiune de asignare de semnal, care are un proces
echivalent.
entity MAJ3 is
generic(DEL: TIME);
port(X: in BIT_VECTOR(0 to 2); Z: out BIT);
end entity MAJ3;
architecture DATAFLOW of MAJ3 is
begin
Z <= (X(0) and X(1)) or (X(1) and X(2))
or (X(0) and X(2)) after DEL;
end architecture DATAFLOW;

-- (a) descrierea VHDL

Modelarea circuitelor combinaţionale şi secvenţiale (cont.)

În Figura 6.19b se prezintă modelul folosit în bulcă deschisă, care

funcţionează ca un circuit logic de tip combinaţional. În Figura 6.19c
ieşirea Z este conectată la intrarea X(2); această legătură
converteşte modelul într-un circuit secvenţial, care ar putea fi numit
element de "consens", adică ieşirea Z este egală cu ultima valoare
pentru care X(0) şi X(1) au avut aceeaşi opinie.

X(0) Z X(0) Z
X(1) MAJ3 X(1) MAJ3
X(2)

(b) Circuit combinaţional (c) Circuit secvenţial

 6.3 Primitive logice
În acelaşi timp, vom arăta şi tehnici noi de modelare pentru circuite
combinaţionale şi secvenţiale- În Figura 6.20 sunt prezentate primitive
care sunt clasificate în combinaţionale şi secvenţiale.
Primitive de tip combinaţional Primitive de tip secvenţial
Porţi logice Circuite bistabile
Buffere Registre
Sumatoare Latch-uri
Multiplexoare Numărătoare
Decodificatoare RAM
Codificatoare
Comparatoare
Registre de deplasare
Unităţi aritmetice şi logice
Numărătoare
ROM
PLA
Fig 6.20 Primitive folosite în proiectare.
 Primitive logice (cont.)

Poartă AND
Porţile logice sunt primitivele combinaţionale de bază în VHDL. În
Figura 6.21 este dezvoltat modelul pentru o poartă NAND cu două
intrări. Modelul calculează funcţia logică NAND între două semnale
de intrare şi copiază rezultatul la ieşirea O după întârzierea
generică DEL. Modelele primitive pentru celelalte porţi de bază sunt
lăsate ca exerciţii pentru cititor.

entity NAND2 is
generic(DEL: TIME);
port(I1,I2: in BIT; O: out BIT);
end entity NAND2;
architecture DF of NAND2 is
begin
O <= not(I1 and I2) after DEL;
end architecture DF;
 Primitive logice (cont.)

Buffer
Primitivele buffer copiază transferă I la ieşirea O, cu condiţia
casemnalul de validare (enable) E să fie activ (în exemplul nostru '1').
Dacă intrarea E este '0', ieşirea bufferului este în starea de înaltă
impedanţă. Condiţia de înaltă impedanţă la ieşire este modelată
printr-un 1 logic. Deci, ieşirea acestui buffer poate fi conectată direct
cu ieşirea altui buffer folosind un operator AND cablat. Pentru multe
situaţii acesta este un model suficient de exact. Au fost folosite
entity BUF is
întârzieri diferite pentru validarea şi invalidarea ieşirii bufferului.
generic(DATA_DEL,Z_DEL: TIME);
port(I,EN: in BIT; O: out BIT);
end entity BUF;
architecture ALG of BUF is
begin
process(I,EN)
begin
if EN = '1' then
O <= I after DATA_DEL;
else
O <= '1' after Z_DEL;
end if;
end process;
 Primitive logice (cont.)

Sumator
Primitiva de bază este reprezentată de sumatorul complet, care adună
doi biţi de date şi o intrare de transport (carry) pentru a forma o ieşire
de date şi una de transport. În Figura 6.23 este prezentat modelul flux
de date pentru un sumator complet de doi biţi. Ieşirea SUM este
funcţia paritate impară aplicată celor trei biţi de intrare. Ieşirea de
transport COUT este funcţia de decizie majoritară aplicată celor trei
intrări. Pentru modelare au fost folosite întârzieri generice diferite.
entity FULL_ADDER is
generic(SUM_DEL,CARRY_DEL:TIME);
port(A,B,CI: in BIT; SUM,COUT: out BIT);
end entity FULL_ADDER;
architecture DF of FULL_ADDER is
begin
SUM <= A xor B xor CI after SUM_DEL;
COUT <= (A and B) or (A and CI) or (B and CI)
after CARRY_DEL;
end architecture DF;
Primitive logice (cont.)

Sumatoarele pentru cuvinte de mai mulţi biţi se fosmează prin

conectarea în cascadă a mai multor sumatoare elementare. În
Figura 6.24 este prezentată schema unui sumator de patru biţi
implementat în această manieră.
A3 B3 A2 B2 A1 B1 A0 B0 CIN

A B CI A B CI A B CI A B CI

CO SUM CO SUM CO SUM CO SUM

COUT S3 S2 S1 S0
 Primitive logice (cont.)

Multiplexor
De multe ori este necesar să se selecteze datele din mai multe surse
posibile. În general, numărul surselor este 2N, iar selecţia se
realizează cu ajutorul unui multiplexor 2N:1. În alte situaţii, se
multiplexează vectori de B biţi. În Figura 6.25 este prezentat modelul
VHDL pentru un multiplexor 4:1 pentru cuvinte de câte 4 biţi. Acest
multiplexor este modelat compact folosind o asignare condiţionată.
entity FOUR_TO_1_MUX is
generic(DEL: TIME);
port(IN0,IN1,IN2,IN3: in BIT_VECTOR(3 downto 0);
SEL: in BIT_VECTOR(1 downto 0);
O: out BIT_VECTOR(3 downto 0));
end entity FOUR_TO_1_MUX;
architecture DF of FOUR_TO_1_MUX is
begin
O <= IN0 after DEL when SEL = "00" else
IN1 after DEL when SEL = "01" else
IN2 after DEL when SEL = "10" else
IN3 after DEL;
end architecture DF;
Primitive logice (cont.)

Decodificator
Decodificatoarele acceptă la intrare N biţi şi activează una din cele 2 N
ieşiri. Numărul i activat la ieşire este egal cu echivalentul zecimal al
codului binar prezentat la cei N biţi de intrare. În acest sens,
decodificatorul funcţionează ca un convertor binar - zecimal.
Decodificatoarele se folosesc pentru a converti semnale care
corespund unor adrese în semnale de selecţie a unei singure linii, care
se pot folosi pentru a activa ieşirile unui singur dispozitiv. Sunt folosite
de asemenea pentru a interpreta intrări standard din câmpul cod
operaţie al instrucţiunilor sistemelor microprogramate. În Figura 6.26
este prezentat modelul VHDL pentru un decodificator cu două intrări şi
patru ieşiri.
Primitive logice (cont.)

entity TWO_TO_4_DEC is
generic(DEL: TIME);
port(I: in BIT_VECTOR(1 downto 0);
O: out BIT_VECTOR(3 downto 0));
end entity TWO_TO_4_DEC;

architecture ALG of TWO_TO_4_DEC is

begin
process(I)
begin
case I is
when "00" => O<= "0001" after DEL;
when "01" => O<= "0010" after DEL;
when "10" => O<= "0100" after DEL;
when "11" => O<= "1000" after DEL;
end case;
end process;
end architecture ALG;
 Primitive logice (cont.)

Registru de deplasare
Deplasările sunt operaţii importante efectuate asupra bit vectorilor
pentru că, în anumite condiţii, deplasarea la dreapta reprezintă o
împărţire la doi iar deplasarea la stânga reprezintă o înmulţire cu doi.
Într-un sens pur logic, deplasarea corespunde unei permutări a unui
cuvânt binar. În Figura 6.28 este prezentat modelul VHDL pentru un
registru de deplasare care deplasează cuvântul de intrare spre
dreapta cu o poziţie dacă SR = '1' şi SR = '0', cuvântul de
intrare este deplasat spre stânga cu o poziţie dacă SR = '0' şi SL
= '1'. 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.
 Primitive logice (cont.)

entity SHIFTER is
generic(DEL: TIME);
port(DATA_IN: in BIT_VECTOR(3 downto 0);
SR,SL: in BIT; IL,IR: in BIT;
DATA_OUT: out BIT_VECTOR(3 downto 0));
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" => DATA_OUT <= DATA_IN(2 downto 0) & IL
after DEL;
when "10" => DATA_OUT <= IR & DATA_IN(3 downto 1)
after DEL;
when "11" => DATA_OUT <= DATA_IN after DEL;
end case;
end process;
end architecture ALG;
Primitive logice (cont.)

Flip-flop
Circuitele bistabile (flip-flop) reprezintă primitivele secvenţiale de
bază. În Figura 6.34 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.

? Ce inseamna “latch” si ce inseamna “flip-flop”?

 Primitive logice (cont.)

architecture ALG of JKFF is

begin
process(CLK,S,R)
begin
if S = '1' and R = '0' then
Q <= '1' after SRDEL;
QN <= '0' after SRDEL;
elsif S = '0' and R = '1' then
Q <= '0' after SRDEL;
QN <= '1' after SRDEL;
elsif CLK'EVENT and CLK = '1' and S='0' and R='0' then
if J = '1' and K = '0' then
Q <= '1' after CLKDEL;
QN <= '0' after CLKDEL;
elsif J = '0' and K ='1' then
Q <= '0' after CLKDEL;
QN <= '1' after CLKDEL;
elsif J= '1' and K= '1' then
Q <= not Q after CLKDEL;
QN <= not QN after CLKDEL;
end if;
end if;
end process;
end architecture ALG;
 Primitive logice (cont.)

Registru
Registrele se pot folosi pentru a memora date. Deşi pot fi construite
modele structurale ale registrelor pornind de la primitive cum sunt
bistabile şi porţi logice, vom elabora un model comportamental pentru
un astfel de registru (Figura 6.35). Registrul este în întregime sincron,
adică atât funcţia de reset cât şi aceea de încărcare paralelă (load)
sunt sincrone, având prioritate reset. Alte modele pot considera
reset ca fiind asincron în raport cu semnalul de ceas. Folosirea
registrelor care sunt total sincrone conduce la evitarea erorilor de
temporizare. Registrul prezentat este un registru controlat, adică va fi
încărcat numai atunci când LOAD = '1', pe frontul activ (crescător)
al semnalului de ceas. Se foloseşte un bloc gardat (vezi paragraful
următor). Având un semnal de control (LOAD) registrul este mai uşor
de controlat cu semnale generate de o unitate de control (Capitolul 8).
Primitive logice (cont.)

entity REG is
generic(DEL: TIME);
port(RESET,LOAD,CLK: in BIT;
DATA_IN: in BIT_VECTOR(3 downto 0);
Q: inout BIT_VECTOR(3 downto 0));
end entity REG;

architecture DF of REG is
begin
REG: block(not CLK'STABLE and CLK ='1')
begin
Q <= guarded "0000" after DEL when RESET ='1' else
DATA_IN after DEL when LOAD ='1' else
Q;
end block REG;
end architecture DF;
Primitive logice (cont.)

Latch
Registrul de mai sus, comandat de un semnal de ceas, preia
eşantioane ale intrărilor şi actualizează ieşirile în momentul când
apare o tranziţie pozitivă în semnalul de ceas. O altă formă a unui
element de memorare, similar unui registru, este latch-ul, a cărui ieşire
preia valoarea de la intrare atunci când ceasul este activ; el
memorează valoarea intrării atunci când semnalul de ceas este
dezactivat. Deci, când ceasul este valid, un latch acţionează ca un
buffer logic, iar după următoarea tranziţie el funcţionează ca un
element de memorie. Latchurile au un avantaj important faţă de
elementele de memorie acţionate pe front: noile valori apar mai
devreme, aşa încât se reduc întârzierile în propagare. În Figura 6.36
am prezentat descrierea VHDL pentru un latch.
 Primitive logice (cont.)

Atunci când garda (CLK) pentru blocul LATCH trece în '1', valoarea lui D este
transferată la LOUT, după LATCH_DEL şi oricare schimbare ulterioară în D se
va transfera la LOUT atâta timp cât CLK este '1'. Când CLK devine zero,
instrucţiunea gardată este dezactivată iar semnalul LOUT îşi menţine ultima
valoare obţinută pe durata cât CLK a fost '1'. În Figura 6.37 am prezentat
formele de undă explicative pentru funcţionarea unui latch, pentru care
LATCH_DEL = 10 ns.
entity LATCH is
generic(LATCH_DEL:TIME);
port(D: in BIT_VECTOR(7 downto 0);
CLK: in BIT; LOUT: out BIT_VECTOR(7 downto 0));
end entity LATCH;
architecture DFLOW of LATCH is
begin
LATCH: block(CLK = '1')
begin
LOUT <= guarded D after LATCH_DEL;
end block LATCH;
end architecture DFLOW;
Primitive logice (cont.)

CLK

LOUT

0 50 100 150 200 t (ns)

Primitive logice (cont.)

Registru de deplasare
Registrele de deplasare sunt elemente importante pentru efectuarea
operaţiilor asupra datelor. În Figura 6.38 se prezintă un model pentru
această primitivă. Se observă că elementul poate fi încărcat (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.
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;