WikiLabs - Contribuții utilizator [ro]

CID aplicatii 12 : Exercitii cu circuite secventiale

2026-05-21T10:14:09Z

Mihai.antonescu: /* Exercitii */

==Teorie==
Acest laborator are rolul de a sedimenta cunostintele dobandite anterior.

El consta in exercitii separate, unele date ca subiect la lucrarea 2 in anii anteriori.

Unele exercitii contin si automate. Daca acestea nu au fost inca predate, puteti ignora partea aceea de circuit.

Dupa cum se poate observa, exemplele sunt diverse ca domeniu de aplicabilitate. Prin asta se doreste a se arata importanta si diversitatea circuitelor digitale in societatea moderna.

==Exercitii==

===Exercitiul 1: password checker===

SystemVerilog suporta codul ASCII deci puteti introduce si litere/string-uri care vor fi tratate prin reprezentarea lor binara.

[https://wiki.dcae.pub.ro/images/5/5c/Subiect_l2_password_checker.pdf password_checker.pdf]

===Exercitiul 2: PWM static pe RGB ===

[https://wiki.dcae.pub.ro/images/f/f2/Subiect_pwm_l2.pdf PWM_static_pe_RGB.pdf]

===Exercitiul 3: calculator de siruri dupa formula data===

[https://wiki.dcae.pub.ro/images/a/a2/Subiect_l2_sir_calculator.pdf calculator_siruri.pdf]

===Exercitiul 4: UART tx - structural===

UART este un standard pentru transmisiune de date seriale. Pentru o descriere a protocolului puteti citi: [https://www.circuitbasics.com/basics-uart-communication/ functionare_uart]

[https://wiki.dcae.pub.ro/images/d/d0/Subiect_l2_uart_tx.pdf uart_tx.pdf]

===Exercitiul 5: UART rx - behavioural===

Daca ati inteles cum functioneaza mecanismul de UART (si pentru a testa functionarea TX de la exercitiul anterior) puteti scrie modulul de RX (receiver) al protocolului, astfel incat cele 2 sa comunice intre ele.

La nivel de TB ar fi amandoua instantiate si conectate intre ele.

UART RX ar trebui sa scoata un puls al semnalului "valid" impreuna cu 8 biti de date daca transmisiunea a fost efectuata cu succes, datele care ies din el fiind cele care au intrat in modulul de tx.

Pentru a compara abordarea structurala cu cea comportamentala, acest modul se doreste a fi facut comportamental.
In always-urile acestuia vor aparea mecanisme de numarare care practic alcatuiesc un mic FSM de control.

===Exercitiul 6: microcontrollere - oscillator control register===

Acest subiect prezinta un modul simplificat al mecanismului de control al oscilatorului de pe un microcontroller. Acest modul controleaza generarea smenalului de ceas ce se propaga catre microcontroller si deci viteza la care sistemul va functiona.

[https://wiki.dcae.pub.ro/images/0/09/Subiect_l2_uc_osccon.pdf uc_osccon.pdf]

===Exercitiul 7: Led care se invarte===

[https://wiki.dcae.pub.ro/images/a/af/L2_led_care_se_invarte.pdf Led_care_se_invarte.pdf]

===Exercitiul 8: Media dintre cel mai mic și cel mai mare număr===

[https://wiki.dcae.pub.ro/images/0/0c/Lucrarea2_Subiect_pentru_wiki.pdf Media_dintre_cel_mai_mic_si_cel_mai_mare_numar]

===Exercitiul 9: Fifo facut din 2 stive===

[https://wiki.dcae.pub.ro/images/2/2f/Subiect_fifo_din_2_stive.pdf Fifo_facut_din_2_stive]

Fișier:Subiect fifo din 2 stive.pdf

2026-05-21T10:13:46Z

Mihai.antonescu:

CID aplicatii 8 : Registre si memorii RAM

2026-04-29T21:02:04Z

Mihai.antonescu: /* Teorie */

==Teorie==

Acest laborator are scopul de a prezenta circuitele secventiale simple: registre si memorii RAM.

Pornind de la bistabilii prezentati/construiti in laboratorul anterior, apare notiunea de registru, acesta fiind o grupare de bistabili. Astfel in loc sa se memoreze un singur bit de informatie (bistabil), se pot memora acum numere pe mai multi biti (registru).

Din exterior, un registru este vazut astfel:

[[Fișier:Registru_exterior_view.png | 400px]]

:Semnalul de "clock" controleaza sincronizarea registrilor din tot sistemul.
:Semnalul de "reset" aduce registrul la o valoare initiala (uzual 0).
:Semnalul de "we" (write enable) controleaza salvarea unor date noi. Cand acesta este activ, data de pe intrarea "data_in" se salveaza in registru.
:Semnalul "data_in" reprezinta datele ce se doresc a fi scrise in registru.
:Semnalul "data_out" reprezinta valoarea stocata in registru.

Semnalele "data_in" si "data_out" pot fi pe oricat de multi biti se doreste, in mod uzual multipli de 8.

Pornind de la notiunea de registru (care poate fi vazut ca o memorie cu o locatie si avand "m" biti) se doreste cresterea acestei memorii astfel incat aceasta sa curpinda mai multe locatii adresabile, unde se pot stoca date. Adaugand mai multi registri in paralel, unul langa altul, si cateva circuite de tip mux/demux se poate obtine o memorie de tip RAM (Random Access Memory), cu "m" locatii de "n" biti fiecare. Aceste memorii se cheama "Random Access" deoarece permit si scriere si citire in/din orice locatie.

Din exterior, o memorie RAM este vazuta astfel:

[[Fișier:Ram_mXn_1read_1write_exterior_view.png ‎| 400px]]

Semnalele acestui circuit se pot imparti in semnale ce tin de interfata de scriere sau interfata de citire si mai apoi in semnale de date si semnale de control. Interfata sa este:

:Semnalul de "clock": controleaza sincronizarea registrilor din memorie.
:Semnalul "addr_read": adresa de la care se citesc datele.
:Semnalul "data_read": data ce se citeste.
:Semnalul de "we": semnal de control ce controleaza activarea scrierii. Scrierea are loc doar cand acest semnal este activ.
:Semnalul "addr_write": adresa la care se scriu datele.
:Semnalul "data_write": data ce urmeaza a fi scrisa atunci cand semnalul "we" este activ.

'''Observatie''': Orice memorie are "m" locatii de "n" biti. Semnalele de "data_read" si "data_write" au aceeasi dimensiune, "n", numarul de biti ai fiecarei locatii. Semnalele de adresa au dimensiunea log2(m). Pentru o memorie cu 16 locatii va fi nevoie de 4 biti de adresa pentru a putea selecta orice locatie, pentru 32 locatii 5b s.a.m.d.

'''Observatie''': In unele situatii se mai poate pune un registru suplimentar pe iesirea datelor, cu rol in sincronizare si evitarea timpilor de propagare prea lungi intre elemente de memorare (ajuta implementarea conceptului de pipeline).

'''Observatie''': Exista mai multe variante de memorii RAM (cu registru pe iesire/fara, multiport/single port citire, adrese separate sau nu pentru citire/scriere). Cea de mai sus este o memorie cu un singur port de citire, fara registru suplimentar pe iesire, ce foloseste adrese distincte pentru citire si pentru scriere (la fel de bine se poate lucra si cu o singura adresa, comuna pentru scriere si citire).

'''Observatie''': Memoriile RAM pot sa nu aiba reset, utilizatorul trebuie apoi sa aiba grija sa citeasca doar din locatii scrise de el anterior.
In mod uzual ele nu au reset.

==Exemple==

===Exemplul 1 : Registrul===

In urmatorul exemplu se implementeaza registrul descris mai sus:

'''Descrierea registrului (fisierul register_8b.sv):'''
<syntaxhighlight lang="Verilog">
module register_8b
(
input logic clock,
input logic reset, // activ pe "1"
input logic we,
input logic [7:0] data_in,
output logic [7:0] data_out // data_out are aceeasi dimensiune ca data_in
);

always_ff @(posedge clock) // clock sincronizeaza actiunile circuitului
begin // doar pe edge-ul pozitiv circuitul actioneaza
if(reset == 1)
begin
data_out <= 0;
end
else
begin
if(we == 1) // comanda de scriere
begin
data_out <= data_in;
end
else // puteam sa omit acest else
begin
data_out <= data_out; // raman datele salvate anterior
end
end
end

endmodule
</syntaxhighlight>

Un alt mod de a scrie un registru este dat mai jos, cu observatia ca aici am pus semnalul de reset activ in logica negativa:

'''Descrierea registrului (fisierul register_8b_v2.sv):'''
<syntaxhighlight lang="Verilog">
module register_8b_v2
(
input logic clock,
input logic reset_n, // activ in "0"
// uzual semnalel cu n in fata sau la sfarsit sunt in logica negativa: nreset, resetn
input logic we,
input logic [7:0] data_in,
output logic [7:0] data_out
);

logic [7:0] memorie_efectiva;

assign data_out = memorie_efectiva;

always_ff @(posedge clock)
begin
if( reset_n == 0)
begin
memorie_efectiva <= 0;
end
else
begin
if(we == 1)
begin
memorie_efectiva <= data_in;
end
end
end

endmodule
</syntaxhighlight>

'''Descrierea test bench-ului registrului pe 8biti: (fisierul register_8b_tb.sv):'''
<syntaxhighlight lang="Verilog">
`timescale 1ns / 1ps

module register_8b_tb();

logic clock_tb;
logic reset_tb;
logic we_tb;
logic [7:0] data_in_tb;
logic [7:0] data_out_tb;

register_8b dut // varianta cu reset activ in "1"
(
.clock(clock_tb),
.reset(reset_tb),
.we(we_tb),
.data_in(data_in_tb),
.data_out(data_out_tb)
);

initial
begin
clock_tb = 0;
forever
begin
#5 clock_tb = ~clock_tb; // perioada totala 10 !!!
end
end

initial
begin
reset_tb <= 0;
we_tb <= 0;
data_in_tb <= 0;
// observatie: pana la primul reset sau prima scriere, valoarea din registru va fi necunoscuta (in simulare X)

// dau reset la circuit
@(posedge clock_tb); // astept sa treaca 1 clock cycle
reset_tb <= 1;
@(posedge clock_tb);
reset_tb <= 0;

repeat(5) // dupa 5 cicli de ceas
begin
@(posedge clock_tb);
end

// incep sa fac scrieri
we_tb <= 1;
data_in_tb <= 5;
@(posedge clock_tb);
we_tb <= 0;
data_in_tb <= 10; // scrierea asta nu se face deoarece nu am write enable activ
@(posedge clock_tb);
data_in_tb <= 11; // nici asta
@(posedge clock_tb);
data_in_tb <= 12; // nici asta
@(posedge clock_tb);
we_tb = 1;
data_in_tb <= 42; // asta da
@(posedge clock_tb);
data_in_tb <= 51; // si asta da
@(posedge clock_tb);
we_tb <= 0;

repeat(5) // dupa 5 cicli de ceas
begin
@(posedge clock_tb);
end
$stop();
end

endmodule
</syntaxhighlight>

===Exemplul 2: Memorie RAM===

In urmatorul exemplu se implementeaza memoria RAM descrisa mai sus, particularizata pentru 64 de locatii a cate 8b fiecare:

'''Descrierea memoriei RAM: (fisierul ram64x8_v1.sv):'''
<syntaxhighlight lang="Verilog">
module ram64x8_v1
(
input logic clock,
//interfata de citire
input logic [5:0] addr_read, // 64 locatii => 6 biti de adresa
output logic [7:0] data_read, // fiecare locatie are 8b
// interfata de scriere
input logic we,
input logic [5:0] addr_write,
input logic [7:0] data_write
);

logic [7:0] memorie_efectiva [0:63]; // memorie cu locatiile de la 0 la 63, fiecare avand 8 biti

assign data_read = memorie_efectiva[addr_read]; // fara registru pe iesire => citire asincrona fata de clock

always_ff @(posedge clock)
begin
if(we == 1)
begin
memorie_efectiva[addr_write] <= data_write; // scriu la locatia data de "addr_write" din memoria efectiva datele "data_write"
end
end

endmodule
</syntaxhighlight>

Acesta va fi folosit si pe post de modul de "top".

Echivalent se poate folosi si sintaxa cu always ca mai jos.

'''Descrierea memoriei RAM: (fisierul ram64x8_v2.sv):'''
<syntaxhighlight lang="Verilog">
module ram64x8_v2 // varianta cu always combinational pe citire
(
input logic clock,
//interfata de citire
input logic [5:0] addr_read,
output logic [7:0] data_read,
// interfata de scriere
input logic we,
input logic [5:0] addr_write,
input logic [7:0] data_write
);

logic [7:0] memorie_efectiva [0:63];

always_comb // citire asincrona fata de clock
begin
data_read = memorie_efectiva[addr_read];
end

always_ff @(posedge clock)
begin
if(we == 1)
begin
memorie_efectiva[addr_write] <= data_write; // scriu la locatia data de "addr_write" din memoria efectiva datele "data_write"
end
end

endmodule
</syntaxhighlight>

'''Descrierea test bench-ului memoriei RAM: (fisierul ram64x8_v1_tb.sv):'''
<syntaxhighlight lang="Verilog">
`timescale 1ns / 1ps

module ram64x8_tb();

logic clock_tb;
logic [5:0] addr_read_tb;
logic [7:0] data_read_tb;
logic we_tb;
logic [5:0] addr_write_tb;
logic [7:0] data_write_tb;

ram64x8_v1 dut
(
.clock(clock_tb),
//interfata de citire
.addr_read(addr_read_tb), // 64 locatii => 6 biti de adresa
.data_read(data_read_tb), // fiecare locatie are 8b
// interfata de scriere
.we(we_tb),
.addr_write(addr_write_tb),
.data_write(data_write_tb)
);

initial
begin
clock_tb = 0;
forever
begin
#5 clock_tb = ~clock_tb; // perioada totala 10 !!!
end
end

initial
begin
we_tb <= 0;
data_write_tb <= 0;
addr_read_tb <= 0; // citind de la o adresa nescrisa inca, iesirea e necunoscuta
addr_write_tb <= 0;
repeat(5) // dupa 5 cicli de ceas
begin
@(posedge clock_tb);
end

// incep sa fac scrieri
we_tb <= 1; // scriu data 5 la adresa 10
addr_write_tb <= 10;
data_write_tb <= 5;
addr_read_tb <= 11; // citind de la o adresa nescrisa inca, iesirea e necunoscuta
@(posedge clock_tb);
we_tb <= 0; // scrierea asta nu se face deoarece nu am write enable activ
addr_write_tb <= 11;
data_write_tb <= 10;
@(posedge clock_tb);
data_write_tb <= 11; // nici asta
@(posedge clock_tb);
data_write_tb <= 12; // nici asta
@(posedge clock_tb);
we_tb <= 1;
addr_write_tb <= 20; // scriere ok
data_write_tb <= 42; // scriu data 42 la adresa 20
@(posedge clock_tb);
data_write_tb <= 51; // si asta; suprascriu datele anterioare la adresa 20.
@(posedge clock_tb);
addr_write_tb <= 21;
data_write_tb <= 11; // scriere ok
addr_read_tb <= 20; // citesc de la adresa 20, scrisa anteior deci voi vedea date cunoscute pe iesire.
@(posedge clock_tb);
addr_write_tb <= 23;
data_write_tb <= 14; // scriere ok
addr_read_tb <= 21; // variez adresa de citire si pot parcurge memorie locatie cu locatie
@(posedge clock_tb);
we_tb <= 0; // opresc scrierea

repeat(5) // dupa 5 cicli de ceas
begin
@(posedge clock_tb);
end
$stop();
end

endmodule
</syntaxhighlight>

[[Fișier:Ram64X8_waveform.png|1000px]]

In forma de unda de mai sus sunt marcate momentele de timp cand au loc scrieri in memorie (cand am write enable activ si valori cunoscute pentru data si adresa de scriere). Se salveaza valorile imediat la stanga frontului de ceas.

In simularea completa, se poate observa si scrierea in registrii din memorie a datelor dorite la adresa setata.

==Exercitii==
===Exercitiul 1: RAM cu registru la iesire===

Pornind de la exemplul anterior, se doreste adaugarea unui registru la citirea datelor, astfel citirea devenind sincrona cu semnalul de ceas. In cod acest lucru se poate face foarte usor, punand operatia de citire pe ceas.

Se doreste simularea si apoi testarea fizica a acestei memorii. Simularea noii memorii se face prin executarea a 3 scrieri la adrese diferite si citirea apoi a datelor respective. Sinteza si testarea fizica necesita micsorarea memoriei din cauza numarului limitat de switchuri/butoane al placii. Vom lucra acum cu o memorie de 8 locatii X 4 biti.
Adresa va fi comandata de switch-uri si datele de intrare din butoane. Se va folosi Button[0] pentru semnalul de "we" (write enable). Afisarea datelor se va face pe leduri.

===Exercitiul 2: RAM multiport citire===

Pornind de la exercitiul 1, se doreste modificarea memoriei astfel incat sa poata fi citite 2 locatii simultan si independent de adresa la care se face scrierea. Se pastreaza citirea sincrona.

Se obtine astfel un circuit a carui interfata este la randul ei compusa din 3 interfete (+semnal comun "clock"):

:- interfata de scriere

:- interfata de citire 0

:- interfata de citire 1

Interfata circuitului arata ca in figura de mai jos:

[[Fișier:Ram_64X8_2read_1write_exterior_view.png | 400px]]

Generati forme de unda corespunzatoare pentru a testa aceasta memorie.

'''Observatie''': Blocul de registri (register file) din interiorul procesoarelor (vedeti AMP) poate fi o astfel de memorie RAM. Are 2 adrese pentru citirea celor 2 operanzi care intra in ALU si o adresa pentru rezultatul calculului ce este salvat.

===Exercitiul 3: Registrul paralel-serie===

Descrieti comportamental un registru paralel-serie. Acesta are rolul de a salva datele de la intrare pe "n" biti (aici 8) si apoi de a le scoate la iesire bit cu bit.

Interfata acestuia este data in desenul de mai jos.

[[Fișier:Registru_paralel_serie.png | 400px]]

:Semnalul de "en" (enable) are rolul de a controla deplasarea, care se executa prin operatia de shiftare la dreapta ">>". Daca acesta are valoarea "1", datele salvate se muta la dreapta cu o pozitie.
:Semnalul de write_en/start/save are rolul de a salva cei 8 biti care urmeaza a fi serializati.

Generati forme de unda corespunzatoare pentru a testa aceast circuit (minim 3 scrieri/serializari).

'''Bonus''': Realizati acelasi circuit folosind o descriere structurala.

===Exercitiul 4: Registrul serie-paralel===

Descrieti comportamental un registru serie-paralel. Acesta are rolul de a salva date introduse bit cu bit ca apoi sa fie scoase cate "n" biti deodata.

Interfata acestuia este data in desenul de mai jos.

[[Fișier:Registru_serie_paralel.png | 400px]]

Semnalul de "en" (enable) are rolul de a controla deplasarea, care se executa prin operatia de shiftare la dreapta ">>". Daca acesta are valoarea "1", datele salvate se muta la dreapta cu o pozitie.

Generati forme de unda corespunzatoare pentru a testa aceast circuit (minim 3 scrieri/paralelizari).

Citirea se poate face oricand, desi doar dupa "n" pasi, va fi cu valoarea corecta.

===Exercitiul 5: Registrul de intarziere pe 8b===

Prin conectarea in serie a mai multor registri pe 8b (astfel incat data ce iese din unul sa fie intrare pentru urmatorul) se pot construi registri de intarziere cu "x" cicli de ceas. Cum fiecare registru salveaza datele pe ceas, se poate spune ca datele de la iesire sunt intarziate cu un ceas fata de datele de la intrare, astfel o intarziere cu "x" cicli de ceas se obtine prin punerea in serie a "x" registri.

Pornind de la un registru simplu pe 8b (exemplul 1), construiti structural un registru de intarziere cu 4 cicli de ceas.

Testati functionarea acestuia prin simulare. Datale introduse trebuie sa iasa defazate cu 4 cicli de ceas (adica cu 4 cicli de ceas mai tarziu).

CID aplicatii 5 : Exercitii cu circuite combinationale

2026-04-26T17:08:31Z

Mihai.antonescu: /* Exercitiul 5: Sumator cu reprezentare in cifre zecimale */

==Teorie==

Acest laborator are rolul de a sedimenta cunostiintele dobandite anterior.

El consta in exercitii separate, unele date ca subiect la lucrarea 1 in anii anteriori si cateva notiuni de teorie si sintaxa ajutatoare.

==Teorie: Parametrizare==
Parametrizarea este un mod de a generaliza codul scris pentru a nu fi necesara descrierea aceluiasi modul de mai multe ori (daca circuitul isi schimba o dimensiune).

Pentru a intelege mai clar avantajele si sintaxa urmariti urmatorul exemplu:

Fisierul sumator.sv:
<syntaxhighlight lang="Verilog">
module sumator # // <= diez deoarece urmeaza lista cu parametri
( // parametri
parameter data_size = 4 // valoare default 4
// alti parametri aici daca este nevoie, separati prin virgula
)
( // interfata
input logic [data_size-1:0] in0, // si pot folosi parametrul "data_size" pentru dimensiunea bus-ului
input logic [data_size-1:0] in1,
output logic [data_size-1:0] out0
);

assign out0 = in0 + in1;

endmodule
</syntaxhighlight>

Cand se instantiaza un modul parametrizat, se specifica valorile parametrilor astfel:
<syntaxhighlight lang="Verilog">
sumator # ( // parametri
.data_size(8) // se genereaza un sumator pe 8b
)
nume_instanta_0
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out0)
);

sumator # ( // parametri
.data_size(32) // se genereaza un sumator pe 32b
)
nume_instanta_1
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out1)
);

sumator nume_instanta_2 // se genereaza un sumator de dimensiune default, aici 4, asa cum e scris in modulul "sumator"
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out2)
);
</syntaxhighlight>

Puteti folosi parametrizarea in exercitiul 3 de mai jos. Acolo sunt 2 tipuri de multiplexoare, unul cu intrarile pe 1 bit si unul cu intrarile pe 2 biti. Poate fi scris un singur modul parametrizat care sa acopere ambele situatii.

==Teorie: Concatenarea==

Pentru o mai usoara conectare a firelor sau pentru o mai buna organizare si expresivitate a codului, de multe ori este util ca fire individuale sa fie grupate impreuna sau ca un bus de mai multi biti sa fie separat in fire individuale. Acest lucru se face folosind concatenarea, prin simbolurile "{ }".

Un exemplu de folosire a concatenarii este oferit mai jos.
Un sumator pe 8b are rezultatul pe maxim 9b, in cazul in care ambele numere sunt mari. Astfel apare un bit de carry out.
<syntaxhighlight lang="Verilog">
module sumator (
input logic [7:0] in0,
input logic [7:0] in1,
output logic [7:0] out0,
output logic carry_out
);

assign {carry_out,out0} = in0 + in1; // fac suma intre in0 si in1 iar rezultatul il pun pe cei 9b alcatuiti din: 1b carry_out si 8b out0, in ordinea asta

endmodule
</syntaxhighlight>
Se pot concatena oricat de multe semnale, puse in "{ }" si separate prin virgula. Atentie la dimensiunile firelor care se concateneaza.

Se poate de asemenea face concatenare si la dreapta egalului, astfel:
<syntaxhighlight lang="Verilog">
assign fir_pe_10_b = {fir_pe_3b,fir_pe_5b,fir_pe_1b,fir_pe_1b};
</syntaxhighlight>
In exemplul anterior ultimi 2b ai "fir_pe_10_b" vor avea mereu aceeasi valoare, provenind din acelasi fir. Sintaxa SystemVerilog permite asta.

Puteti folosii concatenarea, in exercitiul 2, la flag-ul de overflow.

==Teorie: Constante ca intrari in circuite==
In cazul in care se doreste scrierea unor constante la intrarea unor module, acestea se pun direct intre paranteze la instantiere.
De exemplu, pentru multiplexorul de jos din subiectul "alu structural", intrarea "in3" este conectata la valoarea "1". Sintaxa pentru aceasta este: ".in3(1),".

==Teorie: "_"==
Simbolul "_" (underscore) este ignorat de SystemVerilog si ajuta vizual la citirea semnalelor pe mai multi biti. De exemplu 16'b1010010111110000 este identic cu 16'b1010_0101_1111_0000, al doilea fiind totusi mai usor de citit.

==Exercitii==

===Exercitiul 0: Repararea erorilor===
Arhiva de mai jos contine mai multe proiecte in Vivado, fiecare avand cate o eroare de sintaxa sau de logica. In vederea aprofundari cunostiintelor voastre (si pentru lucrarea de saptamana urmatoare), incercati sa le parcurgeti si sa rezolvati toate problemele.
Pe langa proiecte in sine, in arhiva se afla si un fisier text cu o introducere, rezolvarile si explicatiile pentru fiecare situatie.

[https://drive.google.com/file/d/1uOdI88CL0zUiW1hvgnU5H-K-AnNTWCLK/view?usp=sharing Arhiva_proiecte_cu_erori.zip]

===Exercitiul 1: ALU - descriere comportamentala===
Descrieți comportamental o unitate aritmetico-logică (ALU) care are la intrare 2 numere binare de câte 8 biți și poate calcula următoarele funcții:
:- suma celor două numere
:- diferența celor două numere
:- operații logice bit cu bit (bitwise): SI, SAU, XOR și inversele lor
:- operandul din stanga trece neschimbat
:- operandul din dreapta trece neschimbat
:- numărul din stânga este deplasat la stânga cu nr. de poziții indicat de numărul din dreapta
:- numărul din stânga este deplasat la dreapta cu nr. de poziții indicat de numărul din dreapta

Funcția executată la un anumit moment este determinată de configurația binară de pe intrarea de comandă (function).

ALU are de asemenea intrare de carry și ieșire de carry, plus alte două ieșiri - indicatori - pentru cazurile când rezultatul este zero și când cei doi operanzi sunt egali.

Intrarea de control va fi facuta pe 4 biti ca sa permita existenta a 16 operatii posibile. Fiecare numar de pe intrarea de control (combinatie de 0 si 1) va reprezenta o operatie din cele de mai sus. Scrierea se va face folosind un bloc "case" in functie de aceasta intrare.

===Exercitiul 2: ALU - descriere structurala===

[https://wiki.dcae.pub.ro/images/8/8f/Subiect_big_alu.pdf subiect_alu.pdf]

Daca se doreste selectarea doar a anumitor biti dintr-un bus (cum se vrea din instruction) acest lucru se poate face in 2 feluri:

a) cu fir aditional:
:''wire [1:0] fir_aditional1;''
:''assign fir_aditional1 = instruction[11:10];''
:// apoi la instantiere: ''.sel(fir_aditional1),''

b) direct in instantiere;
:la instantierea celor 2 mux4 din stanga, direct:
::''.sel(instruction[11:10]),''

Pentru a scrie mai putin (a nu face toate modulele de calcul separat + instantierea lor) si pentru ca e vorba de operatii simple, se poate pune operatia cu assign direct in top pe un fir declarat acolo, sau si mai prescurtat, direct operatia dorita cand se intantiaza modulul in care aceasta intra. De exemplu, pentru operatia de shift la dreapta care intra in primul multiplexor, se poate pune: ".in0(data0 >> data1),".

===Exercitiul 3: Multiplexoare===

[https://wiki.dcae.pub.ro/images/3/3a/Subiect_muxes.pdf subiect_muxes.pdf]

===Exercitiul 4: Rom/Look-up table===

[https://wiki.dcae.pub.ro/images/2/2e/Subiect_rom_luts.pdf rom_luts.pdf]

===Exercitiul 5: Sumator cu reprezentare in cifre zecimale===
Proiectati si verificati un sumator zecimal pentru numere cu 2 cifre

Modulul de top (Figura 1) este alcatuit din 2 blocuri de tip '''digitsum'''. Fiecare bloc aduna cifrele de pe aceasi pozitie.

'''Figura 1'''
Top level

[[Fișier: bcdsum.png]]

Blocul '''digitsum''' (Figura 2) este alcatuit din 4 blocuri, 2 sumatoare binare pe 4 biti (de tip '''sum4'''), o instanta de '''cmp''' si un multiplexor elementar mux2

'''Figura 2'''
Blocul DIGIT SUM

[[Fișier: digit.png]]

Primul sumator aduna cifrele din domeniul [0...9] avand un rezultat intre [0 ... 18]

Comparatorul are la iesire 1 daca rezultatul este mai mare decat 9.

Daca rezultatul este mai mic decat 9, acesta este trimis in mod direct la iesirea '''digit''' a blocului '''digitsum'''.

Daca rezultatul este mai mare decat 9, o corectie este necesara si se aduna 6 la rezultat.

Comparatorul cu valoarea 9 este descris structural din porti in figura de mai jos:

Atentie: In acest comparator, intrarea pentru bitul [0] se ignora.

'''Figure 3'''
the comparator

[[Fișier: cmp.png]]

Testbench-ul va genera stimuli pentru '''bcdsum''' ca in Figura 4.

Intrarea b0 a '''bcdsum''' se schimba la fiecare 5 pasi de simulare .

b1, a0 si a1 se schimba sincron cu b0 ca in Figura 4.

'''Figure 4'''

[[Fișier: teststimuli.png]]

Cerinte:
# '''cmp'''- descris structural la nivel de porti ca in Figura 3.
# '''sum4''' descris comportamental cu un assign continuu.
# '''mux''' descris comportamental cu always.
# '''digitsum''' descris strctural ca in Figura 2.
# modulul de top numit '''bcdsum''', descris structural ca in Figure 1.
# modulul de testbench, '''bcdsum_tb''', instantiaza '''bcdsum''' cu numele '''dut'''.
# in testbench, generati stimuli pentru intrarile circuitului testat.

===Exercitiul 6: Codor Cezar===

[https://wiki.dcae.pub.ro/images/9/92/Cid_L1_codor_Cezar.pdf Codor_Cezar.pdf]

===Exercitiul 7: Calcul si Flag-uri===

[https://wiki.dcae.pub.ro/images/c/c2/L1_calcul_si_flaguri.pdf Calcul_si_flaguri.pdf]

===Exercitiul 8: Unitate aritmetico-logică (ALU)===

[https://wiki.dcae.pub.ro/images/8/85/Subiect_ALU_pentru_wiki.pdf Unitate_aritmetico-logica]

CID aplicatii 5 : Exercitii cu circuite combinationale

2026-04-26T16:25:02Z

Mihai.antonescu: /* Exercitiul 5: Sumator cu reprezentare in cifre zecimale */

==Teorie==

Acest laborator are rolul de a sedimenta cunostiintele dobandite anterior.

El consta in exercitii separate, unele date ca subiect la lucrarea 1 in anii anteriori si cateva notiuni de teorie si sintaxa ajutatoare.

==Teorie: Parametrizare==
Parametrizarea este un mod de a generaliza codul scris pentru a nu fi necesara descrierea aceluiasi modul de mai multe ori (daca circuitul isi schimba o dimensiune).

Pentru a intelege mai clar avantajele si sintaxa urmariti urmatorul exemplu:

Fisierul sumator.sv:
<syntaxhighlight lang="Verilog">
module sumator # // <= diez deoarece urmeaza lista cu parametri
( // parametri
parameter data_size = 4 // valoare default 4
// alti parametri aici daca este nevoie, separati prin virgula
)
( // interfata
input logic [data_size-1:0] in0, // si pot folosi parametrul "data_size" pentru dimensiunea bus-ului
input logic [data_size-1:0] in1,
output logic [data_size-1:0] out0
);

assign out0 = in0 + in1;

endmodule
</syntaxhighlight>

Cand se instantiaza un modul parametrizat, se specifica valorile parametrilor astfel:
<syntaxhighlight lang="Verilog">
sumator # ( // parametri
.data_size(8) // se genereaza un sumator pe 8b
)
nume_instanta_0
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out0)
);

sumator # ( // parametri
.data_size(32) // se genereaza un sumator pe 32b
)
nume_instanta_1
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out1)
);

sumator nume_instanta_2 // se genereaza un sumator de dimensiune default, aici 4, asa cum e scris in modulul "sumator"
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out2)
);
</syntaxhighlight>

Puteti folosi parametrizarea in exercitiul 3 de mai jos. Acolo sunt 2 tipuri de multiplexoare, unul cu intrarile pe 1 bit si unul cu intrarile pe 2 biti. Poate fi scris un singur modul parametrizat care sa acopere ambele situatii.

==Teorie: Concatenarea==

Pentru o mai usoara conectare a firelor sau pentru o mai buna organizare si expresivitate a codului, de multe ori este util ca fire individuale sa fie grupate impreuna sau ca un bus de mai multi biti sa fie separat in fire individuale. Acest lucru se face folosind concatenarea, prin simbolurile "{ }".

Un exemplu de folosire a concatenarii este oferit mai jos.
Un sumator pe 8b are rezultatul pe maxim 9b, in cazul in care ambele numere sunt mari. Astfel apare un bit de carry out.
<syntaxhighlight lang="Verilog">
module sumator (
input logic [7:0] in0,
input logic [7:0] in1,
output logic [7:0] out0,
output logic carry_out
);

assign {carry_out,out0} = in0 + in1; // fac suma intre in0 si in1 iar rezultatul il pun pe cei 9b alcatuiti din: 1b carry_out si 8b out0, in ordinea asta

endmodule
</syntaxhighlight>
Se pot concatena oricat de multe semnale, puse in "{ }" si separate prin virgula. Atentie la dimensiunile firelor care se concateneaza.

Se poate de asemenea face concatenare si la dreapta egalului, astfel:
<syntaxhighlight lang="Verilog">
assign fir_pe_10_b = {fir_pe_3b,fir_pe_5b,fir_pe_1b,fir_pe_1b};
</syntaxhighlight>
In exemplul anterior ultimi 2b ai "fir_pe_10_b" vor avea mereu aceeasi valoare, provenind din acelasi fir. Sintaxa SystemVerilog permite asta.

Puteti folosii concatenarea, in exercitiul 2, la flag-ul de overflow.

==Teorie: Constante ca intrari in circuite==
In cazul in care se doreste scrierea unor constante la intrarea unor module, acestea se pun direct intre paranteze la instantiere.
De exemplu, pentru multiplexorul de jos din subiectul "alu structural", intrarea "in3" este conectata la valoarea "1". Sintaxa pentru aceasta este: ".in3(1),".

==Teorie: "_"==
Simbolul "_" (underscore) este ignorat de SystemVerilog si ajuta vizual la citirea semnalelor pe mai multi biti. De exemplu 16'b1010010111110000 este identic cu 16'b1010_0101_1111_0000, al doilea fiind totusi mai usor de citit.

==Exercitii==

===Exercitiul 0: Repararea erorilor===
Arhiva de mai jos contine mai multe proiecte in Vivado, fiecare avand cate o eroare de sintaxa sau de logica. In vederea aprofundari cunostiintelor voastre (si pentru lucrarea de saptamana urmatoare), incercati sa le parcurgeti si sa rezolvati toate problemele.
Pe langa proiecte in sine, in arhiva se afla si un fisier text cu o introducere, rezolvarile si explicatiile pentru fiecare situatie.

[https://drive.google.com/file/d/1uOdI88CL0zUiW1hvgnU5H-K-AnNTWCLK/view?usp=sharing Arhiva_proiecte_cu_erori.zip]

===Exercitiul 1: ALU - descriere comportamentala===
Descrieți comportamental o unitate aritmetico-logică (ALU) care are la intrare 2 numere binare de câte 8 biți și poate calcula următoarele funcții:
:- suma celor două numere
:- diferența celor două numere
:- operații logice bit cu bit (bitwise): SI, SAU, XOR și inversele lor
:- operandul din stanga trece neschimbat
:- operandul din dreapta trece neschimbat
:- numărul din stânga este deplasat la stânga cu nr. de poziții indicat de numărul din dreapta
:- numărul din stânga este deplasat la dreapta cu nr. de poziții indicat de numărul din dreapta

Funcția executată la un anumit moment este determinată de configurația binară de pe intrarea de comandă (function).

ALU are de asemenea intrare de carry și ieșire de carry, plus alte două ieșiri - indicatori - pentru cazurile când rezultatul este zero și când cei doi operanzi sunt egali.

Intrarea de control va fi facuta pe 4 biti ca sa permita existenta a 16 operatii posibile. Fiecare numar de pe intrarea de control (combinatie de 0 si 1) va reprezenta o operatie din cele de mai sus. Scrierea se va face folosind un bloc "case" in functie de aceasta intrare.

===Exercitiul 2: ALU - descriere structurala===

[https://wiki.dcae.pub.ro/images/8/8f/Subiect_big_alu.pdf subiect_alu.pdf]

Daca se doreste selectarea doar a anumitor biti dintr-un bus (cum se vrea din instruction) acest lucru se poate face in 2 feluri:

a) cu fir aditional:
:''wire [1:0] fir_aditional1;''
:''assign fir_aditional1 = instruction[11:10];''
:// apoi la instantiere: ''.sel(fir_aditional1),''

b) direct in instantiere;
:la instantierea celor 2 mux4 din stanga, direct:
::''.sel(instruction[11:10]),''

Pentru a scrie mai putin (a nu face toate modulele de calcul separat + instantierea lor) si pentru ca e vorba de operatii simple, se poate pune operatia cu assign direct in top pe un fir declarat acolo, sau si mai prescurtat, direct operatia dorita cand se intantiaza modulul in care aceasta intra. De exemplu, pentru operatia de shift la dreapta care intra in primul multiplexor, se poate pune: ".in0(data0 >> data1),".

===Exercitiul 3: Multiplexoare===

[https://wiki.dcae.pub.ro/images/3/3a/Subiect_muxes.pdf subiect_muxes.pdf]

===Exercitiul 4: Rom/Look-up table===

[https://wiki.dcae.pub.ro/images/2/2e/Subiect_rom_luts.pdf rom_luts.pdf]

===Exercitiul 5: Sumator cu reprezentare in cifre zecimale===
Proiectati si verificati un sumator zecimal pentru numere cu 2 cifre

Modulul de top (Figura 1) este alcatuit din 2 blocuri de tip '''digitsum'''. Fiecare bloc aduna cifrele de pe aceasi pozitie.

'''Figura 1'''
Top level

[[Fișier: bcdsum.png]]

Blocul '''digitsum''' (Figura 2) este alcatuit din 4 blocuri, 2 sumatoare binare pe 4 biti (de tip '''sum4'''), o instanta de '''cmp''' si un multiplexor elementar mux2

'''Figura 2'''
Blocul DIGIT SUM

[[Fișier: digit.png]]

Primul sumator aduna cifrele din domeniul [0...9] avand un rezultat intre [0 ... 18]

Comparatorul are la iesire 1 daca rezultatul este mai mare decat 9.

Daca rezultatul este mai mic decat 9, acesta este trimis in mod direct la iesirea '''digit''' a blocului '''digitsum'''.

Daca rezultatul este mai mare decat 9, o corectie este necesara si se aduna 6 la rezultat.

Comparatorul cu valoarea 9 este descris structural din porti in figura de mai jos:

'''Figure 3'''
the comparator

[[Fișier: cmp.png]]

Testbench-ul va genera stimuli pentru '''bcdsum''' ca in Figura 4.

Intrarea b0 a '''bcdsum''' se schimba la fiecare 5 pasi de simulare .

b1, a0 si a1 se schimba sincron cu b0 ca in Figura 4.

'''Figure 4'''

[[Fișier: teststimuli.png]]

Cerinte:
# '''cmp'''- descris structural la nivel de porti ca in Figura 3.
# '''sum4''' descris comportamental cu un assign continuu.
# '''mux''' descris comportamental cu always.
# '''digitsum''' descris strctural ca in Figura 2.
# modulul de top numit '''bcdsum''', descris structural ca in Figure 1.
# modulul de testbench, '''bcdsum_tb''', instantiaza '''bcdsum''' cu numele '''dut'''.
# in testbench, generati stimuli pentru intrarile circuitului testat.

===Exercitiul 6: Codor Cezar===

[https://wiki.dcae.pub.ro/images/9/92/Cid_L1_codor_Cezar.pdf Codor_Cezar.pdf]

===Exercitiul 7: Calcul si Flag-uri===

[https://wiki.dcae.pub.ro/images/c/c2/L1_calcul_si_flaguri.pdf Calcul_si_flaguri.pdf]

===Exercitiul 8: Unitate aritmetico-logică (ALU)===

[https://wiki.dcae.pub.ro/images/8/85/Subiect_ALU_pentru_wiki.pdf Unitate_aritmetico-logica]

CID aplicatii 10 : Aplicatii cu numaratoare

2026-04-23T10:57:29Z

Mihai.antonescu: /* Exemplu: Numaratul apasarilor unui buton */

==Teorie==

Numaratoarele au extrem de multe aplicatii in lumea reala, cateva dintre acestea fiind descrise mai jos.

==Exemplu: Numaratul apasarilor unui buton==

Un prim sistem simplu cu numarator poate fi cel care contorizeaza de cate ori a fost apasat un buton sau, echivalent, cate persoane/masini au trecut printr-un senzor, de cate ori a fost deschisa o usa etc. Acest sistem se poate apoi dezvolta cu usurinta pentru a numara si oamenii care trec invers prin respectivul set de senzori prin adaugarea functionalitatii de up/down la numarator.

Un astfel de sistem simplu (varianta doar cu numarat intrari) ar arata in felul urmator:

[[Fișier:Aplicatii_numarator_exemplu_contor_senzor.png | 800px]]

Circuitul de debounce are rolul de a "curata" semnalul de intrare, astfel incat chiar si in prezenta zgomotului sau a unei activari indelungate a senzorului/butonului, sa se contorizeze un singur eveniment. O explicatie mai detaliata puteti gasi [[Circuitul_de_debounce|aici]].

Numaratorul numara evenimentele.

Transcodorul pentru display cu 7 segmente este apoi folosit pentru o mai usoara vizualizare a numarului curent.

'''Observatie:''' transcodorul pentru 7seg din exemplul de mai jos este in logica negativa. Daca circuitul fizic este in logica pozitiva trebuie adaugat un inversor la iesirea din acesta. De asemnea consider segmentul "a" pe bitul "0" si segmentul "h" pe bitul "6".

'''Descrierea debouncer-ului (fisierul debounce.sv):'''
<syntaxhighlight lang="Verilog">
module debounce
#(
parameter limit = 20'd650000
) (
input logic clock,
input logic in,
output logic out
);

logic [19:0] counter; // observatie: si circuitul de debounce foloseste un numarator
logic hit;

assign out = (counter == limit);

always_ff @(posedge clock)
begin
if(in == 0)
begin
counter <= 0;
hit <= 0;
end
else
begin
if(counter == limit)
begin
hit <= 1;
counter <= counter + 1;
end
else
begin
if(in == 1 & hit == 0)
begin
counter <= counter + 1;
end
end
end
end

endmodule
</syntaxhighlight>

'''Descrierea numaratorului pe 4b(fisierul counter_4b.sv):'''
<syntaxhighlight lang="Verilog">
module counter_4b
(
input logic clock,
input logic reset,
input logic en,
output logic [3:0] out
);

always_ff @(posedge clock)
begin
if(reset == 1)
begin
out <=0;
end
else
begin
if(en == 1)
begin
out <= out + 1;
end
else
begin
out <= out;
end
end
end

endmodule
</syntaxhighlight>

'''Descrierea transcodorului pentru afisaj cu 7seg(fisierul transcodor_7seg.sv):'''
<syntaxhighlight lang="Verilog">
module transcodor_7seg // logica negativa
(
input logic [3:0] in,
output logic [6:0] out
);

always_comb
begin
case(in)
4'd0: out = 7'b1000000;// h....a
4'd1: out = 7'b1111001;
4'd2: out = 7'b0100100;
4'd3: out = 7'b0110000;
4'd4: out = 7'b0011001;
4'd5: out = 7'b0010010;
4'd6: out = 7'b0000010;
4'd7: out = 7'b1111000;
4'd8: out = 7'b0000000;
4'd9: out = 7'b0010000;
4'd10: out = 7'b0001000;
4'd11: out = 7'b0000011;
4'd12: out = 7'b1000110;
4'd13: out = 7'b0100001;
4'd14: out = 7'b0000110;
4'd15: out = 7'b0001110;
default: out = 7'b1111111;//tot stins
endcase
end

endmodule
</syntaxhighlight>

'''Descrierea sistemului, modulul de top (fisierul top.sv):'''
<syntaxhighlight lang="Verilog">

module top
(
input logic clock,
input logic reset,
input logic button,
output logic [6:0] out // logica negativa
);

logic debounce_0_X_out;
logic [3:0] counter_4b_0_X_out;

debounce
#(
.limit(20'd50_000)
) debounce_0 (
.clock(clock),
.in(button),
.out(debounce_0_X_out)
);

counter_4b counter_4b_0
(
.clock(clock),
.reset(reset),
.en(debounce_0_X_out),
.out(counter_4b_0_X_out)
);

transcodor_7seg transcodor_7seg_0 // logica negativa
(
.in(counter_4b_0_X_out),
.out(out)
);

endmodule
</syntaxhighlight>

'''Descrierea test bench-ului(fisierul tb.sv):'''
<syntaxhighlight lang="Verilog">
`timescale 1ns / 1ps

module tb();

logic clock_tb;
logic reset_tb;
logic button_tb;
logic [6:0] out_tb;

top dut
(
.clock(clock_tb),
.reset(reset_tb),
.button(button_tb),
.out(out_tb) // logica negativa
);

initial
begin
clock_tb = 0;
forever
begin
#5 clock_tb = ~clock_tb;
end
end

initial
begin
reset_tb <= 0;
button_tb <= 0;

#50;
reset_tb <= 1;
#50;
reset_tb <= 0;
#100;

repeat(5) // vreau 5 apasari de buton
begin
button_tb <= 1;
repeat(70_000)
begin
@(posedge clock_tb);
end
button_tb <= 0;
repeat(70_000)
begin
@(posedge clock_tb);
end
end

#1000 $stop();
end

endmodule
</syntaxhighlight>

==Exercitii==

=== Exercitiul 1: Divizor de frecventa cu puteri ale lui 2===

Divizorul de frecventa are rolul de a genera un semnal de ceas mai lent din semnalul de ceas principal.
El este alcatuit doar dintr-un numarator, iar fiecare bit al acestuia va fi practic un semnal de ceas cu frecventa din ce in ce mai mica astfel (la jumate):

bit[0] - frecventa de 2 ori mai mica decat semnalul de ceas

bit[1] - frecventa de 2 ori mai mica decat bit[0], deci de 4 ori mai mica decat semnalul de ceas

bit[2] - frecventa de 2 ori mai mica decat bit[1], deci de 8 ori mai mica decat semnalul de ceas

Acest lucru se poate observa si in poza ce urmeaza:

[[Fișier:Freq_divider_output.png| 800px]]

Implementati acest circuit, si folosind ledurile prezente pe placa, incercati sa conectati bitul corespunzator la leduri astfel incat cel mai din dreapta led sa clipeasca cu o frecventa cat mai apropiata de 1s.

'''Observatie:''' Printr-un astfel de divizor de frecventa minimal, un numar foarte mic de frecvente poate fi generat. Daca se doreste generarea unui semnal periodic cu o perioada exacta, diferita de cele posibile prin acest mecanism, se poate construi urmatorul circuit:

===Exercitiul 2: Divizor de frecventa ce poate genera orice perioada===

Un astfel de divizor de frecventa este construit ca in figura de mai jos:

[[Fișier:Freq_div_orice_freq.png | 800px]]

Prin adaugarea constantei "limit", perioada semnalului de iesire poate sa fie orice multiplu a perioadei semnalului de ceas.

Bistabilul de tip t, se modifica atunci cand limita este atinsa si practic iesirea lui este semnalul periodic dorit (cu observatia ca o perioada a semnalului de iesire necesita 2 numarari pana la limita).

Sa se calculeze valoarea necesara pentru "limit" astfel incat pe leduri sa se genereze semnal cu perioada exact 1s.

'''Observatie:''' In FPGA exista fizic trasee speciale pentru reset si ca sinteza sa le foloseasca pe acestea in mod optim nu este recomandat sa se puna logica (cum e aici poarta sau) pe acestea. Modificati schema de mai sus astfel incat sa eliminati respectiva poarta de pe reset. (Sfat: numaratorul va avea acum si intrari de load: semnalul de comanda si data propriu zisa)

===Exercitiul 3: PWM (Pulse Width Modulation)===

PWM este un concept folosit foarte des in multiple ramuri ale ingineriei, de la transmisiunea informatiei pana la controlul motoarelor sau al intensitatii ledurilor din instalatii de Craciun. El se refera la a avea un semnal periodic cu factor de umplere variabil, asa cum este aratat in poza de mai jos :

[[Fișier:Pwm.png| 800px]]

Generarea unui astfel de semnal periodic se face printr-un numarator si un comparator, ca in figura de mai jos:

[[Fișier:Pwm_schematic.png | 800px]]

Raportul dintre limita pusa si valoarea la care numaratorul se reseteaza este practic factorul de umplere selectat.

Pentru testare pe placa, cei 6b ai limitei provin de la switch-uri si butoane. Afisarea se face pe led[0].

Testati acest circuit in simulare si apoi implementati pe placa pentru o valoare fixa a limitei. Implementati in paralel mai multe generatoare de semnal PWM cu limite diferite, astfel incat sa observati diferentele de intentistate dintre ledurile comandate de acestea.

===Exercitiul 4: PWM cu limita variabila===

Un exemplu foarte uzual de folosire a PWM este aprinderea ledurilor cu diverse pattern-uri. Factorul de umplere determina intensitatea cu care ledul este aprins. Un PWM cu o limita variabila automata va face ledul sa para din ce in ce mai stins sau din ce in ce mai luminos (exemplu: instalatii de Craciun). Combinand asta cu leduri RGB se obtin efecte de schimbare a culorii ledului aparent la intamplare.

Un astfel de circuit se realizeaza punand inca un numarator in locul limitei, ca in poza de mai jos:

[[Fișier:Pwm_duty_cycle_up_schematic.png | 800px]]

Pentru o functionalitate suplimentara, anume a pastra un anumit factor de umplere mai multe perioade, am adaugat inca un numarator.

Pentru claritatea desenului, nu am mai tras efectiv firul de ceas catre intrarile unde acesta se duce.

Rezultatul este:

[[Fișier:Pwm_duty_cycle_up_output.png | 800px]]

Testati circuitul propus prin simulare si apoi vizualizati implementarea sa pe placa. Alegeti limite potrivite astfel incat sa puteti observa usor rezultatul.

'''Bonus:''' Incercati sa adaugati si parametri pentru LIMIT_DUTY_CYCLE_LOW si LIMIT_DUTY_CYCLE_HIGH, care sa permita factorului de umplere sa varieze doar intre ele (numaratorul va avea nevoie de intrari pentru comanda de load si data load, ca sa poata incepe de la orice valoare).

'''Bonus:''' Modificati circuitul astfel incat semnalul de iesire sa isi schimbe sensul de variatie al factorului de umplere cand ajunge cu acesta la capat. In forma curenta factorul de umplere creste de la 0% la 100% si apoi se reseteaza brusc la 0%, repetand acest ciclu. Se vrea ca la ajungerea la 100% sa inceapa o scadere treptata catre 0%, urmata apoi de o urcare s.a.m.d.

===Exercitiul 5: Ceas===

Un ceas poate fi construit cifra cu cifra, folosind numaratoare si comparatoare (si transcodoare pentru display cu 7seg ca sa se vada totul mai bine pe placa).

Incercati sa implementati un ceas cu milisecunde, secunde si minute in varianta comportamentala.

'''Observatie:''' Va fi nevoie fie separat, fie in modul de un numarator cu frecventa rezolutiei dorite (aici 1 ms).

'''Observatie:''' Codul va contine multe "if" de tipul "daca cifra unitatilor secundelor a ajuns la 10, se face 0 si cresc cifra zecilor", repetate pentru fiecare cifra.

Incercati si o implementare structurala a ceasului, mergand pe aceeasi idee. Fiecare cifra va contine numaratorul ei. Cand numaratorul unei cifre ajunge ajunge la limita sa, va da enable pentru numaratorul cifrei urmatoare. Daca este nevoie se pot folosi si porti aditionale (ex: ca sa creasca minutul cifra zecilor secundelor trebuie sa fie 5 si cifra unitatilor secundelor trebuie sa fie 9).

'''Observatie:''' Va fi nevoie de un numarator cu frecventa rezolutiei dorite (aici 1 ms sau 1s).

'''Observatie:''' Pentru a scrie mai putin puteti face un numarator doar cu secunde si minute. Principiul de baza este acelasi si daca aveati milisecunde.

'''Observatie:''' Simularea a cateva milisecunde sau chiar secunde este un proces indelungat (dureaza minute-ore fizice), astfel strict pentru simulari se recomanda ceasul sa functioneze cu microsecunde sau milisecunde maxim.

CID aplicatii 9 : Numaratorul

2026-04-23T10:56:47Z

Mihai.antonescu: /* Exemple */

== Numărătorul ==
Numărătorul este cel mai simplu automat, fiind format dintr-un registru (element de memorare) ce reține valoarea curentă a acestuia și un circuit de incrementare (circuit de reacție) ce generează la ieșirea sa valoarea ce va trebui stocată în registru la următorul front crescător de ceas (valoarea curentă incrementată cu 1).

În figura de mai jos este reprezentat un numărător cu reset sincron:

[[Fișier:Numarator cu reset.png|600px]]

În cazul de mai sus, cât timp semnalul ''reset'' este activ, valoarea numărătorului va fi 0. Atunci când semnalul ''reset'' nu este activ, numărătorul își va incrementa valoarea la fiecare front crescător de ceas.

== Divizor de frecvență cu factor de divizare putere a lui 2==
În unele cazuri, apare necesitatea obținerii unor semnale de ceas cu frecvență mai mică decât cea a ceasului de sistem. Aceste noi semnale de ceas pot fi obținute chiar din semnalul de ceas al sistemului, prin circuite care realizează divizarea acestuia. Cea mai simplă divizare a unui semnal de ceas este cea cu factor de divizare egal cu o putere a lui 2. Pentru acest caz, putem folosi un numărător.

Dacă urmărim figura de mai jos în care sunt reprezentate variațiile fiecărui bit în timpul funcționării unui numărător pe 4 biți, observăm că, cu cât ordinul bitului crește (este mai semnificativ), frecvența de variație este mai mică. Între frecvențele de variație corespunzătoare a doi biți succesivi există următoarea relație: frecvența unui bit este de două ori mai mică decât frecvența bitului anterior (mai puțin semnificativ).

[[Fișier:Divizare frecventa.png]]

Observând că frecvența bitului 0 este de două ori mai mică decât cea a ceasului, putem concluziona că frecvența de variație a bitului cu indicele N este dată de: '''''fbN'' = ''fclk / 2N+1'''''

Așadar, pentru a realiza un divizor de frecvență cu factor de divizare putere a lui 2, putem folosi un numărător îndeajuns de mare, din care extragem bitul cu frecvența de variație egală cu frecvența dorită.

== Exemple==
===Exemplul 1: Implementarea unui numărător cu reset sincron===
În acest exemplu vom realiza implementarea numărătorului cu reset sincron prezentat în figura din secțiunea de introducere teoretică. În plus, vom folosi parametrul WIDTH pentru a controla dimensiunea acestuia.

'''Implementarea Numărătorului cu reset sincron'''
<syntaxhighlight lang="Verilog">
module Numarator
#(parameter WIDTH = 8)
(
input logic clock,
input logic reset_n,
output logic [WIDTH-1:0] count
);

always_ff @(posedge clock) begin
if(reset_n == 0)
count <= 0;
else
count <= count + 1;
end

endmodule

</syntaxhighlight>

'''Implementarea unui modul de test pentru numărător'''
<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps

module Numarator_TB();

parameter WIDTH_T = 5;
logic reset_n_t, clock_t;
logic [WIDTH_T-1:0] count_t;

initial begin
clock_t = 0;
forever #1 clock_t = ~clock_t;
end

initial begin
reset_n_t <= 0;
#2 reset_n_t <= 1;
#500 $stop();
end

Numarator #(.WIDTH(WIDTH_T)) DUT(
.clock(clock_t),
.reset_n(reset_n_t),
.count(count_t)
);

endmodule

</syntaxhighlight>

'''Observație:''' Cât timp semnalul ''reset'' este inactiv, numărătorul își va incrementa valoarea la fiecare front crescător de ceas. Când va ajunge la valoarea sa maximă (de exemplu, 31 pentru un numărător pe 5 biți), va avea loc o depășire și având la dispozitie un număr limitat de biți (de exemplu, 5), semnalul de ieșire va deveni 0 (reținem doar cei mai puțin semnificativi 5 biți), circuitul reluând numărarea de la capat.

===Exemplul 2: Observarea vitezei de variație a biților unui numărător===
În acest exemplu vom realiza implementarea unui divizor de frecvență ce generează la ieșire 4 semnale de ceas cu următoarele frecvențe:
* ''clkout1'': semnal de ceas cu frecvența de 1 Hz.
* ''clkout2'': semnal de ceas cu frecvența de 2 Hz.
* ''clkout4'': semnal de ceas cu frecvența de 4 Hz.
* ''clkout8'': semnal de ceas cu frecvența de 8 Hz.

Dacă aplicăm formula '''''fbN'' = ''fclk / 2N+1''''' cunoscând că frecvența de ceas a FPGA-ului este de 100 MHz, vom obține:
* ''clkout1'' poate fi obținut prin bitul 26 al unui numărător.
* ''clkout2'' poate fi obținut prin bitul 25 al unui numărător.
* ''clkout4'' poate fi obținut prin bitul 24 al unui numărător.
* ''clkout8'' poate fi obținut prin bitul 23 al unui numărător.

Din rezultatele de mai sus, rezultă că avem nevoie de un numărător pe 27 biți, astfel încât să putem folosi bitul cel mai semnificativ (bitul 26) pentru generarea semnalului de ceas cu frecvența cea mai mică.

'''Implementarea SystemVerilog a circuitului'''
<syntaxhighlight lang="Verilog">
module clock_generator(
input logic clock,
input logic reset,
output logic clkout1,
output logic clkout2,
output logic clkout4,
output logic clkout8,
);

logic [26:0] count;

always_ff @(posedge clock) begin
if(reset == 1)
count <= 0;
else
count <= count + 1;
end

assign clkout1 = count[26];
assign clkout2 = count[25];
assign clkout4 = count[24];
assign clkout8 = count[23];

endmodule

</syntaxhighlight>

'''Observație:''' Cerința ca reset să fie activ în 1 este impusă de logica în care lucrează butoanele FPGA-ului.

'''Implementarea circuitului pe FPGA'''

Realizați sinteza circuitului pe FPGA, ținând cont de următoarele constrângeri de I/O:
{| class="wikitable"
|- align="center"
||'''Port''' || '''Conexiune'''
|- align="center"
| clock || CLK_100MHz
|- align="center"
| reset || Button 0
|- align="center"
| clkout1 || LED3
|- align="center"
| clkout2 || LED2
|- align="center"
| clkout4 || LED1
|- align="center"
| clkout8 || LED0
|}

Observați viteza cu care fiecare din LED-uri se stinge și se aprinde.

== Exerciții==
===Exercițiul 1===
Implementați un numărător parametrizat cu reset sincron și semnal de ''enable''. Semnalul ''enable'' controlează funcționarea numărătorului astfel: când este activ (egal cu 1), permite funcționarea normală (incrementare la fiecare front crescător de ceas); când este inactiv (egal cu 0), va determina numărătorul să își păstreze valoarea curentă.

Implementați și un modul de test care să testeze funcționarea corectă a circuitului.

===Exercițiul 2===
Implementați un numărător parametrizat cu reset sincron și capacitatea de a număra crescător sau descrescător. Controlul direcției de numărare se va realiza cu ajutorul unui semnal ''count_updown'', care controlează funcționarea numărătorului astfel: când este 0, numărătorul va număra crescător, prin incrementarea valorii curente, iar când este 1, numărătorul va număra descrescător, prin decrementarea valorii curente

Implementați și un modul de test care să testeze funcționarea corectă a circuitului.

===Exercițiul 3===
Implementați circuitul descris prin schema de mai jos, știind că:
* COUNTER este un numărător pe 32 biți fără reset.
* RAM este o memorie 16x4b, cu citire sincrona.
* ROM este o memorie 16x4b, ce are descrierea prezentată mai jos.

[[Fișier:Cid_lab6.jpg]]

'''Implementarea modulului ROM'''
<syntaxhighlight lang="Verilog">
module ROM(
input logic [3:0] in,
output logic [3:0] out
);

always_comb
case(in)
0: out = 4'b0000;
1: out = 4'b0110;
2: out = 4'b0011;
3: out = 4'b1110;
4: out = 4'b1011;
5: out = 4'b1111;
6: out = 4'b0111;
7: out = 4'b1100;
8: out = 4'b0001;
9: out = 4'b0101;
10: out = 4'b1101;
11: out = 4'b1010;
12: out = 4'b0010;
13: out = 4'b0100;
14: out = 4'b1000;
15: out = 4'b1001;
default: out = 4'b0000;
endcase
endmodule
</syntaxhighlight>

Realizați un modul de test în care să scrieți memoria RAM cu date, astfel încât să se realizeze citirea memoriei ROM în ordine, la fiecare ciclu de ceas (adresa 0 -> adresa 1 -> ... -> adresa 15 -> adresa 0 -> ...)

CID aplicatii 7 : Circuite secventiale elementare

2026-04-23T10:55:19Z

Mihai.antonescu: /* Exemplul 3: Descrierea comportamentală a bistabilului de tip D */

==Hazardul combinațional==

Hazardul apare atunci când modificarea unei intrări a unui circuit combinațional determină modificări nedorite ale ieșirii. Aceste variații apar datorită diferențelor de întârzieri pe diverse căi de la intrare către ieșire.

De unde aceste întârzieri? Fiecare poartă este, așa cum am văzut la începutul aplicațiilor, un circuit electronic format, de obicei, din tranzistoare MOS. Răspunsul acestor dispozitive nu este instantaneu, introducând întârzieri. Timpul scurs de la modificarea unei intrări a unei porți până la modificarea corespunzătoare a ieșirii se numește timp de propagare.

În figura următoare avem evidențiat timpul de propagare printr-o poartă ''SAU'' (Tp). Acesta este reprezentat de timpul scurs de la modificarea lui a până la modificarea ieșirii.

[[Fișier:Comutare poarta SAU.png | 400px]]

Avănd un circuit cu mai multe porți în cascadă, căile prin care anumite semnale ajung la intrările unei anumite porți pot diferi. Datorită timpilor de propagare diferiți care afectează aceste semnale până să ajungă la poarta curentă și a timpului de propagare efectiv al porții curente, pot apărea la ieșire tranziții nedorite ale semnalelor. Dacă la ieșire se așteaptă ca linia să rămană constant în 1, dar apare o scurtă tranziție prin 0, hazardul se numește ''1 static''. Dacă la ieșire se așteaptă ca linia să rămană constant în 0, dar apare o scurtă tranziție prin 1, hazardul se numește ''0 static''. Dacă se așteaptă o tranziție la ieșire, dar apare un regim tranzitoriu cu numeroase tranziții până la stabilizare, hazardul se numește dinamic.

Pentru a înțelege mai bine, să considerăm exemplul de mai jos:

[[Fișier:Circuit comb hazard.png | 400px]]

Observăm că intrările porții ''P2'' urmează căi diferite: semnalul ''c'' este ieșirea unei porți, având o întârziere cauzată de timpul de propagare al porții ''P1'', pe când semnalul ''b'' vine direct de la intrare, propagarea prin fir fiind neglijabilă. Să considerăm cazul în care intrarea ''a'' rămane permanent în 0, iar intrarea ''b'' comută la un moment dat din 0 în 1. Inițial, semnalul ''c'' este 1, iar ''d'' este 1. După comutarea lui ''b'', semnalul ''c'' va comuta din 1 in 0, iar ''d'' va rămane 1. Acesta este cazul ideal. În realitate, datorită timpilor de propagare ai porților logice ''P1'' și ''P2'', vom avea o scurtă tranziție prin 0:

[[Fișier:Circuit comb hazard propagare.png | 400px]]

==Atribuirea blocanta si non-blocanta==
Pentru ca simulatorul sa functioneze in mod corect si semnalele sa se modifice in simulare asa cum se modifica si in realitate este nevoie sa folosim atribuirea blocanta ( semnul "=") la circuite combinationale si atribuirea non-blocanta (semnul "<=") la circuite secventiale.

In mod uzual orice always combinational ( '''always_comb''' ) va folosi '''atribuirea blocanta ( = )''' si orice always pe ceas ( '''always_ff @(posedge clock)''' ) va folosi '''atribuirea non-blocanta ( <= )'''.

Diferenta dintre cele 2 atribuiri consta in modul in care simulatorul "executa" instructiunea de atribuire. La atribuirea blocanta se simuleaza linie cu linie, in ordinea in care acestea au fost scrise. La atribuirea non-blocanta se salveaza toti termenii din dreapta si se pun deodata (in acelasi pas de simulare) in termenii din stanga. Pentru a clarifica acest concept avem exemplul de mai jos:

<syntaxhighlight lang="Verilog">
a = b;
b = a;

c <= d;
d <= c;
</syntaxhighlight>

In primul caz, deoarece am folosit atribuirea blocanta, a ia valoarea lui b si apoi b ia valoarea lui a, care deja a devenit b deci concret b ramane pe loc si deci atat a cat si b vor avea aceasi valoare la final.

In al doilea caz, deoarece am folosit atribuirea non-blocanta, ce este in partea dreapta se transfera peste operanzii din stanga deodata, astfel c ia valoarea lui d si d ia valoarea lui c, la final avand loc o interschimbare.

==Latch-ul==
Latch-urile sunt dispozitive elementare de memorare, sensibile la nivelul semnalelor de intrare. Exemple de astfel de dispozitive sunt latch-urile de tip SR și latch-urile de tip D.

===Latch-ul SR===
Latch-ul de tip SR poate fi realizat cu două porți ''SI NU'' sau ''SAU NU'' și este un dispozitiv asincron controlat de stările semnalelor ''S'' (set) și ''R'' (reset). Tabelul de adevăr al acestui circuit este prezentat mai jos.

[[Fișier:Latch SR.png|400px]]

Atunci când ''S'' este 1 și ''R'' este 0, ieșirea ''Q'' va deveni 1, iar ''Qn'' va deveni 0. Atunci când ''R'' este 1 și ''S'' este 0, ieșirea ''Q'' se resetează (devine 0), iar ''Qn'' devine 1. Starea de memorare apare atunci când atât ''R'' cât și ''S'' sunt 0 în același timp. Cazul în care ''R'' și ''S'' sunt 1 în același timp duce la un comportament nedorit. (atât ''Q'' cât și ''Qn'' vor fi 0, ceea ce este incorect din punct de vedere al logicii dorite – ''Qn'' să fie negatul lui ''Q''). În plus, dacă din aceasta stare se dorește trecerea în starea de memorare (''R'' = 0, ''S'' = 0), poate apărea oscilația. În realitate, cele două porți nu vor avea același timp de propagare datorită variațiilor de producție și circuitul va ajunge în cele din urma într-o stare stabilă, nepredictibilă.

===Latch-ul de tip D===
Latch-ul de tip D elimină problema combinațiilor nedorite de la ieșire. Acesta modifică ieșire doar atunci când semnalul de enable (''E'') este 1. Altfel, atunci când ''E'' este 0, va memora starea anterioara (''Qt-1'').

[[Fișier:Latch D.png|500px]]

==Bistabilul de tip D==
Bistabilul de tip D este un dispozitiv de memorare ce salvează valoarea intrării pe unul din fronturile ceasului (în mod uzual, frontul crescător). El poate fi obținut prin conectarea a două latch-uri de tip D, conform schemei de mai jos. De obicei, singura ieșire care ne interesează este ''Q''.

[[Fișier:Bistabil D.png|300px]]

Comportamentul bistabilului de tip D poate fi observat în forma de undă următoare. Modificările lui ''data_out'' sunt determinate de fronturile crescătoare ale semnalului ''clock''. La apariția acestora, ''data_out'' va lua valoarea intrării ''data_in''.

[[Fișier:Forma unda bistabil.png]]

===Bistabilul de tip D cu reset sincron===
Resetarea unui bistabil înseamnă aducerea valorii memorate la 0 sau la o altă valoare de reset definită de cel care proiectează circuitul. Vom considera în exemplul nostru că semnalul de ''reset'' va fi activ în 0 și va face 0 valoarea memorată atunci când este activ. Un reset sincron înseamnă că acesta va acționa asupra valorii memorate''data_out'' pe frontul crescător al ceasului.

[[Fișier:Forma unda bistabil reset sincron.png]]

===Bistabilul de tip D cu reset asincron===
Un reset asincron înseamnă că acesta va acționa asincron, fără a ține cont de ceas. Acest lucru înseamnă că el va acționa asupra valorii memorate imediat ce devine activ. În exemplele noastre, vom considera semnalul de ''reset'' ca fiind activ în 0. Trecerea sa în 0 (frontul căzător) determină imediat resetarea circuitului. De asemenea, orice eveniment de front crescător de ceas ce apare cât timp reset-ul este activ, va duce la menținerea resetării circuitului.

[[Fișier:Forma unda bistabil reset asincron.png]]

==Exemple==
===Exemplul 1: Evidențierea hazardului combinațional===

Implementați circuitul cu porți logice prezentat în secțiunea de introducere teoretică și reproduceți în modulul de testare variațiile semnalelor ''a'' și ''b'' propuse, astfel încât să observăm pe ieșirea ''d'' hazardul.

Deoarece în simulare propagarea este ideală, va trebui să introducem un timp de propagare folosind ''#n''. Acesta va avea efect doar în simulare și va fi ignorat la o eventuală sinteză.

Pentru modulul de test, va trebui să alegem un timp de modificare a valorilor semnalelor mai mare decât timpul de propagare ales. Aici, vom folosi 1ns timp de propagare și 5ns timp de variație a intrărilor in testbench.

'''Implementarea SystemVerilog a circuitului'''

<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps
module Circuit(
input logic a,
input logic b,
output logic c,
output logic d
);

assign #1 c = ~(a | b);
assign #1 d = ~(c & b);

endmodule
</syntaxhighlight>

'''Implementarea unui modul de test care să evidențieze hazardul'''
<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps

module Circuit_TB();

logic a_t, b_t;
logic c_t, d_t;

initial begin
a_t = 0;
b_t = 0;
#5 b_t = 1;
#5 $stop();
end

Circuit DUT(
.a(a_t),
.b(b_t),
.c(c_t),
.d(d_t)
);

endmodule
</syntaxhighlight>

[[Fișier:Poza_hazard.png ‎| 800px]]

In acest exemplu se observa ca iesirea c se modifica la 1ns dupa modificarile intrarilor (intarizerea adaugata pentru transmiterea prin porti) si iesirea d se modifica de 2 ori: prima data la 1ns din cauza intrarilor si a doua oara dupa inca 1ns din cauza lui c. In intervalul [6-7]ns apare o valoare parazita, un hazard.

===Exemplul 2: Descrierea comportamentală a latch-ului de tip D===
'''Descrierea SystemVerilog a modulului'''
<syntaxhighlight lang="Verilog">
module latch_D(
input logic D,
input logic E,
output logic Q
);

assign Q = (E == 1) ? D : Q;

endmodule
</syntaxhighlight>

'''Modul de test pentru latch-ul D'''
<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps

module latch_D_TB();

logic D_t, E_t;
logic Q_t;

initial begin
D_t = 0;
E_t = 1;
#1 D_t = 1;
#1 D_t = 0;
#1 E_t = 0;
#1 D_t = 1;
#1 D_t = 0;
#5 $stop();
end

latch_D DUT1(
.D(D_t),
.E(E_t),
.Q(Q_t)
);

endmodule
</syntaxhighlight>

===Exemplul 3: Descrierea comportamentală a bistabilului de tip D===
'''Descrierea SystemVerilog a modulului'''
<syntaxhighlight lang="Verilog">
module flipflop_D(
input logic data_in,
input logic clock,
output logic data_out
);

always_ff @(posedge clock) begin
data_out <= data_in; // atribuire non-blocanta
end

endmodule
</syntaxhighlight>

'''Modulul de test pentru bistabilul de tip D'''
<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps

module flipflop_D_TB();

logic data_in_t, clock_t;
logic data_out_t;

initial begin
data_in_t <= 0;
#2 data_in_t <= 1;
#4 data_in_t <= 0;
#5 $stop();
end

initial begin
clock_t = 0;
forever #1 clock_t = ~ clock_t;
end

flipflop_D DUT(
.data_in(data_in_t),
.clock(clock_t),
.data_out(data_out_t)
);

endmodule
</syntaxhighlight>

'''Observatie:''' Atunci cand avem un circuit secvential, se foloseste atribuirea non-blocanta ("<=”)

==Exerciții==
===Exercițiul 1===
Descrieți structural latch-ul de tip SR, conform schemei din secțiunea de introducere teoretică. Puteți simula întârzierile prin porți folosind #1.

Realizați un modul de test care să pună în evidență funcționarea. Respectați la generarea stimulilor următoarea variație (fiecare segment de timp durează 5ns).

[[Fișier:Forma unda latchSR.png]]

===Exercițiul 2===
Modificați descrierea bistabilului de tip D prezentată în exemple, astfel încât acesta să permită resetarea sincronă. Semnalul de reset va fi activ în 0.

Realizați un modul de test care să respecte la generarea stimulilor forma de unda prezentată în secțiunea de introducere teoretică, la '''Bistabilul de tip D cu reset sincron'''.

===Exercițiul 3===
Modificați descrierea bistabilului de tip D prezentată în exemple, astfel încât acesta să permită resetarea asincronă. Semnalul de reset va fi activ în 0.

Realizați un modul de test care să respecte la generarea stimulilor forma de unda prezentată în secțiunea de introducere teoretică, la '''Bistabilul de tip D cu reset asincron'''.

'''Indicație''': Frontul căzător al semnalului ''reset'' va trebui să fie adăugat în lista de sensitivități a blocului always care determină modificarea lui ''data_out''.

===Exercițiul 4===
Pentru evidentierea hazardului combinational (si a modului in care acesta se rezolva) descrieti in SystemVerilog si simulati urmatoarele 2 circuite:

[[Fișier:Poza_circ_secventiale_basic_exercitiu_4_circuit.png ‎| 600px]]

Pentru a putea observa efectele hazardului, portile trebuie descrise ca avand timpi de propagare.

Formele de unda pentru semnalele de la intrare vor fi:

[[Fișier:Poza_circ_secventiale_basic_exercitiu_4_forme_unda.png ‎| 600px]]

===Exercițiul 5===
Pentru evidentierea efectului atribuirii blocant si non-blocante se va implementa si simula circuitul de mai jos. El este alcatuit din 3 registre, fiecare memorand (si punand la iesire) pe frontul pozitiv al ceasului valoarea de la intrare.

Cele 3 registre de sus vor folosii atribuirea blocanta si cele 3 registre de jos vor folosii atribuirea non-blocanta. In simulare se doreste a se vizualiza: intrarile, iesirile, firele interne de legatura dintre registrii.

Pentru a scrie semnificativ mai putin, nu este nevoie sa instantiati fiecare registru dintro serie ca modul separat ci se pot face toate cele 3 atribuiri in cadrul aceluiasi bloc "always", la nivelul de top. Practic tot circuitul se reduce la un fisier de top ce contine intrari/iesiri, declararea registrilor pe 1b si cele 2 always-uri care dicteaza functionarea.

[[Fișier:Poza_circ_secventiale_basic_exercitiu_5_circuit.png ‎| 600px]]

CID aplicatii 5 : Exercitii cu circuite combinationale

2026-04-06T16:41:04Z

Mihai.antonescu: /* Exercitiul 0: Repararea erorilor */

==Teorie==

Acest laborator are rolul de a sedimenta cunostiintele dobandite anterior.

El consta in exercitii separate, unele date ca subiect la lucrarea 1 in anii anteriori si cateva notiuni de teorie si sintaxa ajutatoare.

==Teorie: Parametrizare==
Parametrizarea este un mod de a generaliza codul scris pentru a nu fi necesara descrierea aceluiasi modul de mai multe ori (daca circuitul isi schimba o dimensiune).

Pentru a intelege mai clar avantajele si sintaxa urmariti urmatorul exemplu:

Fisierul sumator.sv:
<syntaxhighlight lang="Verilog">
module sumator # // <= diez deoarece urmeaza lista cu parametri
( // parametri
parameter data_size = 4 // valoare default 4
// alti parametri aici daca este nevoie, separati prin virgula
)
( // interfata
input logic [data_size-1:0] in0, // si pot folosi parametrul "data_size" pentru dimensiunea bus-ului
input logic [data_size-1:0] in1,
output logic [data_size-1:0] out0
);

assign out0 = in0 + in1;

endmodule
</syntaxhighlight>

Cand se instantiaza un modul parametrizat, se specifica valorile parametrilor astfel:
<syntaxhighlight lang="Verilog">
sumator # ( // parametri
.data_size(8) // se genereaza un sumator pe 8b
)
nume_instanta_0
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out0)
);

sumator # ( // parametri
.data_size(32) // se genereaza un sumator pe 32b
)
nume_instanta_1
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out1)
);

sumator nume_instanta_2 // se genereaza un sumator de dimensiune default, aici 4, asa cum e scris in modulul "sumator"
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out2)
);
</syntaxhighlight>

Puteti folosi parametrizarea in exercitiul 3 de mai jos. Acolo sunt 2 tipuri de multiplexoare, unul cu intrarile pe 1 bit si unul cu intrarile pe 2 biti. Poate fi scris un singur modul parametrizat care sa acopere ambele situatii.

==Teorie: Concatenarea==

Pentru o mai usoara conectare a firelor sau pentru o mai buna organizare si expresivitate a codului, de multe ori este util ca fire individuale sa fie grupate impreuna sau ca un bus de mai multi biti sa fie separat in fire individuale. Acest lucru se face folosind concatenarea, prin simbolurile "{ }".

Un exemplu de folosire a concatenarii este oferit mai jos.
Un sumator pe 8b are rezultatul pe maxim 9b, in cazul in care ambele numere sunt mari. Astfel apare un bit de carry out.
<syntaxhighlight lang="Verilog">
module sumator (
input logic [7:0] in0,
input logic [7:0] in1,
output logic [7:0] out0,
output logic carry_out
);

assign {carry_out,out0} = in0 + in1; // fac suma intre in0 si in1 iar rezultatul il pun pe cei 9b alcatuiti din: 1b carry_out si 8b out0, in ordinea asta

endmodule
</syntaxhighlight>
Se pot concatena oricat de multe semnale, puse in "{ }" si separate prin virgula. Atentie la dimensiunile firelor care se concateneaza.

Se poate de asemenea face concatenare si la dreapta egalului, astfel:
<syntaxhighlight lang="Verilog">
assign fir_pe_10_b = {fir_pe_3b,fir_pe_5b,fir_pe_1b,fir_pe_1b};
</syntaxhighlight>
In exemplul anterior ultimi 2b ai "fir_pe_10_b" vor avea mereu aceeasi valoare, provenind din acelasi fir. Sintaxa SystemVerilog permite asta.

Puteti folosii concatenarea, in exercitiul 2, la flag-ul de overflow.

==Teorie: Constante ca intrari in circuite==
In cazul in care se doreste scrierea unor constante la intrarea unor module, acestea se pun direct intre paranteze la instantiere.
De exemplu, pentru multiplexorul de jos din subiectul "alu structural", intrarea "in3" este conectata la valoarea "1". Sintaxa pentru aceasta este: ".in3(1),".

==Teorie: "_"==
Simbolul "_" (underscore) este ignorat de SystemVerilog si ajuta vizual la citirea semnalelor pe mai multi biti. De exemplu 16'b1010010111110000 este identic cu 16'b1010_0101_1111_0000, al doilea fiind totusi mai usor de citit.

==Exercitii==

===Exercitiul 0: Repararea erorilor===
Arhiva de mai jos contine mai multe proiecte in Vivado, fiecare avand cate o eroare de sintaxa sau de logica. In vederea aprofundari cunostiintelor voastre (si pentru lucrarea de saptamana urmatoare), incercati sa le parcurgeti si sa rezolvati toate problemele.
Pe langa proiecte in sine, in arhiva se afla si un fisier text cu o introducere, rezolvarile si explicatiile pentru fiecare situatie.

[https://drive.google.com/file/d/1uOdI88CL0zUiW1hvgnU5H-K-AnNTWCLK/view?usp=sharing Arhiva_proiecte_cu_erori.zip]

===Exercitiul 1: ALU - descriere comportamentala===
Descrieți comportamental o unitate aritmetico-logică (ALU) care are la intrare 2 numere binare de câte 8 biți și poate calcula următoarele funcții:
:- suma celor două numere
:- diferența celor două numere
:- operații logice bit cu bit (bitwise): SI, SAU, XOR și inversele lor
:- operandul din stanga trece neschimbat
:- operandul din dreapta trece neschimbat
:- numărul din stânga este deplasat la stânga cu nr. de poziții indicat de numărul din dreapta
:- numărul din stânga este deplasat la dreapta cu nr. de poziții indicat de numărul din dreapta

Funcția executată la un anumit moment este determinată de configurația binară de pe intrarea de comandă (function).

ALU are de asemenea intrare de carry și ieșire de carry, plus alte două ieșiri - indicatori - pentru cazurile când rezultatul este zero și când cei doi operanzi sunt egali.

Intrarea de control va fi facuta pe 4 biti ca sa permita existenta a 16 operatii posibile. Fiecare numar de pe intrarea de control (combinatie de 0 si 1) va reprezenta o operatie din cele de mai sus. Scrierea se va face folosind un bloc "case" in functie de aceasta intrare.

===Exercitiul 2: ALU - descriere structurala===

[https://wiki.dcae.pub.ro/images/8/8f/Subiect_big_alu.pdf subiect_alu.pdf]

Daca se doreste selectarea doar a anumitor biti dintr-un bus (cum se vrea din instruction) acest lucru se poate face in 2 feluri:

a) cu fir aditional:
:''wire [1:0] fir_aditional1;''
:''assign fir_aditional1 = instruction[11:10];''
:// apoi la instantiere: ''.sel(fir_aditional1),''

b) direct in instantiere;
:la instantierea celor 2 mux4 din stanga, direct:
::''.sel(instruction[11:10]),''

Pentru a scrie mai putin (a nu face toate modulele de calcul separat + instantierea lor) si pentru ca e vorba de operatii simple, se poate pune operatia cu assign direct in top pe un fir declarat acolo, sau si mai prescurtat, direct operatia dorita cand se intantiaza modulul in care aceasta intra. De exemplu, pentru operatia de shift la dreapta care intra in primul multiplexor, se poate pune: ".in0(data0 >> data1),".

===Exercitiul 3: Multiplexoare===

[https://wiki.dcae.pub.ro/images/3/3a/Subiect_muxes.pdf subiect_muxes.pdf]

===Exercitiul 4: Rom/Look-up table===

[https://wiki.dcae.pub.ro/images/2/2e/Subiect_rom_luts.pdf rom_luts.pdf]

===Exercitiul 5: Sumator cu reprezentare in cifre zecimale===
Proiectati si verificati un sumator zecimal pentru numere cu 2 cifre

Modulul de top (Figura 1) este alcatuit din 2 blocuri de tip '''digitsum'''. Fiecare bloc aduna cifrele de pe aceasi pozitie.

'''Figura 1'''
Top level

[[Fișier: bcdsum.png]]

Blocul '''digitsum''' (Figura 2) este alcatuit din 4 blocuri, 2 sumatoare binare pe 4 biti (de tip '''sum4'''), o instanta de '''cmp''' si un multiplexor elementar mux2

'''Figura 2'''
Blocul DIGIT SUM

[[Fișier: digit.png]]

Primul sumator aduna cifrele din domeniul [0...9] avand un rezultat intre [0 ... 18]

Comparatorul are la iesire 1 daca rezultatul este mai mare decat 9.

Daca rezultatul este mai mic decat 9, acesta este trimis in mod direct la iesirea '''digit''' a blocului '''digitsum'''.

Daca rezultatul este mai mare decat 9, o crectie este necesara si se aduna 6 la rezultat.

Comparatorul cu valoarea 9 este descris structural din porti in figura de mai jos:

'''Figure 3'''
the comparator

[[Fișier: cmp.png]]

Testbench-ul va genera stimuli pentru '''bcdsum''' ca in Figura 4.

Intrarea b0 a '''bcdsum''' se schimba la fiecare 5 pasi de simulare .

b1, a0 si a1 se schimba sincron cu b0 ca in Figura 4.

'''Figure 4'''

[[Fișier: teststimuli.png]]

Cerinte:
# '''cmp'''- descris structural la nivel de porti ca in Figura 3.
# '''sum4''' descris comportamental cu un assign continuu.
# '''mux''' descris comportamental cu always.
# '''digitsum''' descris strctural ca in Figura 2.
# modulul de top numit '''bcdsum''', descris structural ca in Figure 1.
# modulul de testbench, '''bcdsum_tb''', instantiaza '''bcdsum''' cu numele '''dut'''.
# in testbench, generati stimuli pentru intrarile circuitului testat.

===Exercitiul 6: Codor Cezar===

[https://wiki.dcae.pub.ro/images/9/92/Cid_L1_codor_Cezar.pdf Codor_Cezar.pdf]

===Exercitiul 7: Calcul si Flag-uri===

[https://wiki.dcae.pub.ro/images/c/c2/L1_calcul_si_flaguri.pdf Calcul_si_flaguri.pdf]

===Exercitiul 8: Unitate aritmetico-logică (ALU)===

[https://wiki.dcae.pub.ro/images/8/85/Subiect_ALU_pentru_wiki.pdf Unitate_aritmetico-logica]

CID aplicatii 2 : Instantiere si porti logice

2026-04-03T08:44:24Z

Mihai.antonescu: /* Exemplul 2: NAND2 din AND2 si NOT */

==Teorie: incapsulare si instantiere==
Unitatile constructive de baza din care se formeaza circuitele digitale se numesc porti logice. Acestea implementeaza functii logice si prin conectarea mai multor astfel de circuite simple complexitatea unui circuit poate creste pana la nivelul procesoarelor actuale. Pentru a putea controla cresterea complexitatii in proiectarea unui circuit de dimensiuni mari se folosesc 2 concepte cheie:

1) incapsularea functiei dorite intr-un modul

2) instantierea unor module mai mici si asamblarea acestora pentru a forma un modul mai mare.

Incapsularea se refera la a grupa elementele ce alcatuiesc o anumita functionalitate intr-un modul. Aceste elemente pot la randul lor sa fie alte module.
Instantierea (asemanator cu POO) se refera la a apela un modul deja scris pentru a fi folosit efectiv in circuitul curent.
Pentru a face o analogie cu programarea, cand se declara o variabila (sau un obiect), tipul variabilei este echivalent cu modulul si numele ei este numele instantei.

Pentru a intelege aceste concepte se da circuitul de mai jos:

[[Fișier:schema_principiu_instantiere.png ‎| 800px]]

'''Observatii:'''

1) Notatie aici: Numele modulului este scris in interior.

2) Notatie aici: Numele instantei este scris deasupra.

3) Idee fundamentala: prin instantierea si incapsularea unor circuite simple, mici, apar circuite mai complexe.

4) Idei esentiale (daca vreuna e neclara consultati cadrul didactic):

:a) "modul_2" este instantiat o singura data in tot proiecul, iar instanta se cheama "x"

:b) "modul_2" are o intrare numita "in0" si o iesire numita "out0"

:c) "modul_2" este instantiat in cadrul "modul_6"

:d) Modulul cel mai mare, ce cuprinde toata functionalitatea dorita a sistemului (aici "modul_6") se numeste uzual top.

:e) Instanta top-ului care apare atunci cand se doreste testarea sa in simulare intr-un testbench (tb) se numeste uzual DUT (design under test)

:f) "modul_0" apare instantiat de 3 ori. Circuitul final, cuprinde 3 subcircuite de tip "modul_0".

:g) La nivel de top, instanta sa se cheama "b".

:h) La nivel de "modul_5", cele 2 instante se cheama "a" si "c".

:i) "a" si "c" sunt 2 circuite fizice diferite chiar daca ambele sunt de tipul "modul_0". Fiind instante ale aceluiasi modul, deci identice in alcatuire, luate separat ele fac acelasi lucru. Luate in contextul lui "modul_5", "a" genereaza datele de pe firul "w0" si "c" genereaza datele pentru iesire.

:j) circuitul "b" de tip "modul_1" (instantiat in "modul_5") este complet diferit de circuitul "b" de tip "modul_0" (instantiat in top). Este permis ca ele sa aiba acelasi nume (cele 2 instante) deoarece se afla in locatii diferite.

:k) Identic, mai multe module au o intrare numita "in_0". La sinteza circuitului nu se face confuzie intre acestea deoarece fiecare e vazut la nivelul altei instante.

:l) Identic, firele de legatura "w0", "w1".

:m) La nivelul "top", firul de legatura "w2" leaga iesirea "out_0" a instantei "b" la intrarea "in2" a instantei "y".

:n) La nivelul "top", firul de legatura "w1" leaga iesirea "out_0" a instantei "x" la intrarea "in1" a instantei "y".

:o) La nivelul "modul_5", firul de legatura "w1" leaga iesirea instantei "b" la intrarea instantei "c".

:Pentru claritatea desenului, respectivele intrari si iesiri nu au fost denumite. In cod este obligatoriu ca ele sa fie definite si denumite.

:p) La nivelul "top", "in0","in1","in2","in3","in4" si "out0" formeaza interfata modulului (semnalele care intra sau ies din modul).

:q) La nivelul "top", "w0", "w1", "w2" sunt fire interne de legatura.

:r) La nivelul "top", firul "in3" este conectat ca intrare pentru 3 submodule.

==Teorie: testarea circuitelor==
Pentru a se testa functionarea corecta a circuitului final, acesta este instantiat intr-un modul numit "test_bench" sau "tb". Acest modul este folosit strict in simulare.
Testarea unui circuit are loc conform schemei urmatoare:

[[Fișier:schema_principiu_tb.png ‎| 600px]]

Generarea datelor de intrare se va face asemanator cu laboratorul 1.

Voi veti avea rolul modelului ideal si al comparatorului datelor de iesire, uitandu-va la datele de intrare veti calcula iesirea corecta si apoi veti compara aceasta valoare cu raspunsul circuitului ce se testeaza.

In cazul unui sistem automat, se genereaza mesaje de eroare sau mesaje ca functionarea este in regula.

Observatie: proiectarea si verificarea sunt 2 domenii diferite, firmele avand departamente separate pentru acestea.

Proiectarea/Design se ocupa cu scrierea in Verilog/SystemVerilog a modului de top si toate modulele ce se afla in acesta, avand ca scop final realizarea fizica pe placa a unui circuit.

Verificarea se ocupa de scrierea in SystemVerilog (limbaj format din Verilog cu concepte de POO) a modului de testbench si generarea de stimuli si scenarii care sa testeze functionarea design-ului.

==Teorie: porti logice==
Portile logice folosite uzual, impreuna cu tabelele lor de adevar si reprezentarea grafica sunt date mai jos.

Se folosesc porti logice cu 1 sau 2 intrari, cele cu mai mult de 2 intrari fiind construite din acestea.

{| class="wikitable"
! Tip !! Simbol !! Tabel de adevăr !! Tip !! Simbol !! Tabel de adevăr
|-
| '''Buffer/Repetor'''
| [[Image:Buffer_gate.png|Buffer symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || A
|- bgcolor="#ddffdd" align="center"
|0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1
|}
| '''NOT'''
| [[Image:not.png|NOT symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || NOT A
|- bgcolor="#ddffdd" align="center"
|0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0
|}
|-
| '''AND'''
| [[Image:and.png|AND symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A AND B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 1
|}
| '''NAND'''
| [[Image:nand.png|NAND symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A NAND B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 0
|}
|-
| '''OR'''
| [[Image:or.png|OR symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A OR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 1
|}
| '''NOR'''
| [[Image:nor.png|NOR symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A NOR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 0
|}
|-
| '''XOR'''
| [[Image:xor.png|XOR symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A XOR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 0
|}
| '''XNOR'''
| [[Image:xnor.png|XNOR symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A XNOR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 1
|}
|}

==Despre FPGA==
FPGA-ul (Field-Programmable Gate Array) este un circuit programabil, capabil sa implementeze circuite definit de utilizator. El este format dintr-o matrice de blocuri programabile, interconectate intre ele printr-o serie de conexiuni la randul lor programabile.

Cand se doreste implementarea unui circuit pe FPGA, acesta urmeaza urmatoarele etape:

:'''Elaborarea''' este procesul prin care codul SystemVerilog este transformat intr-un circuit la nivel de porti si registre (netlist) si este independent de modelul de FPGA folosit.

:'''Sinteza''' este procesul în care se realizează transformarea circuitului descris într-un netlist dependent de tehnologie. Se vor folosi la acest pas primitivele disponibile pe FPGA.

:'''Implementarea''' este procesul în care se preia netlist-ul ce conține primitivele FPGA și modul lor de interconectare realizat la pasul de sinteză și se realizează maparea lor efectivă în FPGA (place and route).

:'''Generarea Bitstream-ului''' este procesul prin care informatiile din implementare sunt asamblate intr-un singur fisier.

:'''Programarea''' este procesul prin care fisierul generat anterior este trimis efectiv catre placa cu FPGA (prin USB) unde determina modificarea valorilor si conexiunilor interne din aceasta.

O introducere mai detaliata poate fi gasita aici : [[FPGA - Introducere]].

[[Fișier:Fpgaimg.PNG|600px]]

'''Observatii:'''
* Pentru a putea controla circuitul propus si a putea vedea rezultatele, intrarile si iesirile (input si output din module) in/din acesta trebuie conectate la pini fizici ai FPGA-ului care sunt conectati la butoane/switch-uri/leduri.
* Conexiunile dintre butoane/switch-uri si pinii FPGA sunt fixe. La fel si cele intre pinii FPGA si LED-uri. (in functie de PCB)
* Conexiunile dintre porturile modulului ''Module'' si pinii FPGA sunt configurabile. (in functie de noi, prin fisierul XDC)
* Legarea porturilor modulului ''Module'' la pinii fizici ai FPGA se realizeaza prin configurarea conexiunilor din FPGA conform contrangerilor de I/O pe care le vom mentiona in proiect, inainte de sinteza.

==Exemple==

===Exemplul 1: Analiza circuitelor cu porti===
Fie urmatorul circuit alcatuit din porti logice:
[[Fișier:Mux2_schema_interna_2.png ‎| 400px]]

Se doreste exprimarea circuitului de mai sus ca formula de tip: iesire = f(intrari).

Pentru asta, abordarea consta in a porni de la iesire si a merge pas cu pas catre intrari, asa cum este exemplificat mai jos. Se vor folosi simbolurile "~" pentru NOT, "&" pentru AND, "|" pentru OR.
:pas1: out0 = ?
:pas2: out0 = w1 | w2
:pas3: out0 = w1 | ( ? )
:pas4: out0 = w1 | ( sel & in1 )
:pas5: out0 = ( ? ) | ( sel & in1 )
:pas6: out0 = ( in0 & w0 ) | ( sel & in1 )
:pas7: out0 = ( in0 & ( ? ) ) | ( sel & in1 )
:pas8: out0 = ( in0 & (~sel) ) | ( sel & in1 )

===Exemplul 2: NAND2 din AND2 si NOT===
In urmatorul exemplu se implementeaza o poarta NAND din o poarta AND si o poarta NOT.

Codul de mai jos exemplifica ideea de instantiere si contine comentarii legate de sintaxa SystemVerilog necesara.

In mod uzual fisierele sunt denumite dupa modulul ce se afla in ele, in fiecare fisier fiind un singur modul.

Schema circuitul care se doreste a fi creat este:

[[Fișier:schema_exemplu_rezolvat.png ‎| 600px]]

'''Descrierea portii NOT (fisierul not_gate.sv):'''
<syntaxhighlight lang="Verilog">
// comentarii cu "//" sau cu /* .... */ ;
/*
ca in c/c++
*/

module not_gate // cuvant cheie "module" apoi numele modulului (asemanator clase din c++)
( // intre paranteze se pune interfata (firele care intra sau ies din modul)
input logic in0, // in0 este o intrare => input
output logic out0 // out0 este o iesire => output
); // aici ";" sa nu il uitati

assign out0 = ~in0; // cuvant cheie assign;
// semnalele pot lua valoare prin assign
// ~ e semnul pentru negatie pe biti (ca in c/c++)

endmodule // cuvant cheie "endmodule". orice module se inchide cu endmodule.
</syntaxhighlight>

'''Descrierea portii AND (fisierul and_gate.sv):'''
<syntaxhighlight lang="Verilog">
module and_gate
(
input logic in0, // aici sunt 2 intrari
input logic in1,
output logic out0
); // nu conteaza ordinea in care sunt puse intrarile si iesirile.
// uzual si pentru usurinta se ordoneaza si grupeaza dupa functionalitate
// in cazul de mai sus, am pus intai intrarile, apoi iesirile.

assign out0 = in0 & in1; // operatia propriu zisa

endmodule
</syntaxhighlight>

'''Descrierea modulului top (fisierul top.sv):'''
<syntaxhighlight lang="Verilog">

module top
(
input logic a,
input logic b,
output logic c
);

logic w0; //declarat un fir intern de legatura

and_gate and_gate_0 // instantiere: nume_modul nume_instanta (asemanator int x din c/c++)
(
.in0(a), // la intrarea "in0" a instantei "and_gate_0" se conecteaza firul "a" din top
.in1(b), // grija ca "in0", "in1", "out0" sa existe in declararea modulului "and_gate"
.out0(w0) // grija ca "a", "b", "w0" sa existe la nivelul modulului in care se face instantierea
);

not_gate not_gate_0
(
.in0(w0), // "w0" care iese din "and_gate_0" intra in "not_gate_0"
.out0(c) // "c" care iese din "not_gate_0" iese din modulul "top" (e iesire in interfata de sus)
); // se poate scrie si ".in0(w0),.out0(c)" dar se prefera fiecare fir pe randul sau (lizibilitate si loc de comentarii pt design-uri complexe)
// Observatie: la varianta de mai sus de instantiere, nu conteaza ordinea firelor.

/*
not_gate not_gate_0
( // se poate instantia si in forma prescurtata ca aici
w0, // in acest caz se pun conexiunile in ordinea in care sunt declarate intrarile si iesirile din modul
c // NU se recomanda stilul asta de instantiere
); // apar greseli frecvent la ordinea firelor si la numarul lor,
*/ // mai ales daca modulul e complex si are multe intrari si intrari

endmodule
</syntaxhighlight>

Echivalent se pot folosi si "primitive" SystemVerilog pentru scrierea top-ului.

Primitivele sunt circuite care exista deja in limbaj, folosite atunci cand se doreste o descriere structurala a circuitului.

In instantiere acestora, iesirea se pune prima, urmata de intrari.

'''Observatie:''' daca se doreste scrierea acestor porti de catre voi (ca mai sus), numele modulului nu trebuie sa fie un cuvant cheie ocupat de primitive.

'''Descrierea alternativa a modulului top (fisierul top_v2.sv):'''
<syntaxhighlight lang="Verilog">
module top_v2
(
input logic a,
input logic b,
output logic c
);

logic w0;

and and_gate_0(w0,a,b); // primitiva pentru poarta and
not not_gate_0(c,w0); // primitiva pentru poarta not

endmodule
</syntaxhighlight>

Fiind un modul simplu, intreaga functionalitate putea fi scrisa la nivel de "top" si simplificat ca mai jos.

'''Descrierea alternativa a modulului top (fisierul top_v3.sv):'''
<syntaxhighlight lang="Verilog">
module top_v3
(
input logic a,
input logic b,
output logic c
);

assign c = ~ (a & b); // a si b, negate

endmodule
</syntaxhighlight>

Testarea circuitul se face printr-un testbench, acesta fiind:

'''Descrierea testbench-ului (fisierul top_tb.sv):'''
<syntaxhighlight lang="Verilog">
`timescale 1ns / 1ps

module top_tb(); // din/in tb nu intra si iese nimic. niciodata.

logic a_tb;
logic b_tb;
logic c_tb;

top dut // instantierea modulului de tip "top" sub numele "dut"
(
.a(a_tb),
.b(b_tb),
.c(c_tb)
);

initial
begin // in loc de { ... } din c/c++, in SystemVerilog se pune begin ... end
a_tb = 0; // a_tb ia valoarea 0 la momentul 0 al simularii
b_tb = 0;
#10; // dupa 10 unitati de timp (aici, 10ns)
a_tb = 1;
b_tb = 0;
#10;
a_tb = 0;
b_tb = 1;
#10;
a_tb = 1;
b_tb = 1;
#10;
a_tb = 0;
b_tb = 0;

#20 $stop(); // oprirea simularii
end //end pentru initial

endmodule
</syntaxhighlight>

Formele de unda rezultate din simulare se pot vedea mai jos:

[[Fișier:exemplu_rezolvat_nand_forme_de_unda.png ‎| 800px]]

In chenarul verde se pot observa instantele din simulare.

Daca se doreste adaugarea de semnale noi pentru a fi vazute, se selecteaza modulul instantiat in care acestea se afla (chenar verde).

Apoi, din chenarul rosu se aleg semnalele si se adauga prin click dreapta->add to wave window.

Pentru o mai usoara vizualizare, semnalele se pot grupa asa cum se vede in chenarul mov prin click dreapta->new group.

Se observa o functionare corecta circuitului, acesta fiind o poarta NAND. El scoate "0" cand ambele semnale de intrare sunt "1" si scoate "1" in rest.

'''Implementarea circuitului pe FPGA'''

Dupa ce circuitul a fost testat in simulare, se doreste punerea sa fizica pe placa FPGA. Pentru aceasta, se tine cont de urmatoarele.

* Pentru a controla intrarile ''a'' si ''b'' ale circuitului '''top'', va trebui sa le conectam prin intermediul conexiunilor configurabile ale FPGA-ului la pini ce sunt mai departe conectati fizic la dispozitive ce pot controla valorile semnalelor (switch-uri, butoane).
* Pentru a observa valoarea iesirii, vom conecta semnalul de iesire ''c''la un dispozitiv de observare, cum ar fi un LED, care va fi aprins daca ''c'' este 1 si stins daca ''c'' este 0.

[[Fișier:NAND2 FPGA.png | 600px]]

Pentru a realiza conectarea porturilor modulului ''top'' la pinii fizici ai FPGA ce sunt conectati mai departe la componentele de pe placa, va trebui sa specificam in utilitarul de sinteza maparea porturilor la acestia. Maparea se realizeaza prin mentionarea codurilor pinilor la care dorim conexiunea si poata numele de '''constrangeri de I/O'''. Aceste coduri sunt mentionate in documentatia placii de dezvoltare cu FPGA (in cazul nostru, Boolean Board) si pot fi regasite si in pagina [[Boolean Board - Pinout]].

Conform schemei, la acest exemplu avem nevoie de codurile pinilor conectati mai departe la Switch0, Switch1 si LED0.

'''Observatie:''' Daca intrarile si iesirile ar fi semnale pe mai multi biti, fiecare bit al intrarilor va fi conectat la cate un switch/buton si fiecare bit al iesirii va fi conectat la un LED. Acest lucru este necesar deoarece switch-urile/butoanele pot avea doar doua stari (0 si 1) si astfel pot controla un singur bit. La fel, un LED poate avea doar doua stari (0 - stins si 1 - aprins) si poate afisa starea unui singur bit.

Dupa ce ati extras codurile necesare, urmati pasii descrisi in [[Tutorial_Vivado|tutorialul Vivado]].

Dupa programarea cu succes a placii, puteti testa functionalitatea circuitului prin modficarea valorilor switch-urilor si observarea starii LED-ului.

==Exercitii==
Pentru urmatoarele exercitii se doreste atat testarea designurilor prin simulare cat si punerea acestora pe placa. Legat de placa, intrarile vor fi conectate la butoane, iar iesirile la leduri. Se va consulta tabelul cu pini disponibili ([[Boolean Board - Pinout]].).

Exista moduri mai rapide de a scrie functionalitatea dorita (vezi exemplu), dar tema principala a acestui laborator este instantierea, asa ca sunteti rugati sa respectati desenele si sa instantiati fiecare poarta individual.

===Exercitiul 1: AND4 din AND2===

Acest exercitiu arata cum se construieste o poarta AND cu 4 intrari din porti AND mai simple, cu 2 intrari.
Iesirea acesteia va fi "1" doar daca toate intrarile sunt "1".

[[Fișier:schema_and4_din_and2.png ‎| 600px]]

Pentru testarea circuitului, generati in testbench urmatoarele forme de unda (liniile punctate reprezinta 5ns):

[[Fișier:Wavedrom_and4.png ‎| 500px]]

===Exercitiul 2: OR4 din OR2===

Asemanator cu exercitiul anterior, se poate construi si o poarta or cu 4 intrari din porti or cu 2 intrari.
Iesirea acesteia va fi "1" doar daca oricare din intrari (cel putin una) este "1".

Pentru testarea circuitului se folosesc formele de unda de la exercitiul 1.

[[Fișier:schema_or4_din_or2.png ‎| 600px]]

===Exercitiul 3: AND4 din AND2 aranjat in cascada (nu arbore)===

In multe cazuri, aceeasi functionalitate poate fi atinsa prin circuite care arata diferit.
O alta varianta de a face o poarta AND cu 4 intrari este prezentata mai jos.

Comparati cele 2 variante.

Pentru testarea circuitului se folosesc formele de unda de la exercitiul 1.

[[Fișier:schema_and4_din_and2_v2.png ‎| 600px]]

===Exercitiul 4: AND4 din NAND2===

Orice poarta logica de baza poate fi construita doar din porti NAND sau doar din porti NOR.

Desenati si implementati circuitul pentru o poarta AND4 din porti NAND cu 2 intrari.

Tip: Incercati intai sa generati o poarta AND2 din NAND2.

Pentru testarea circuitului se folosesc formele de unda de la exercitiul 1.

===Exercitiul 5: AND4 pe 4b din AND4 pe 1b===

Se pot face operatii logice si pe mai multi biti deodata prin punerea in paralel a mai multor porti cu o singura iesire.
Exemplu :
pentru intrarile 0011 si 1110 iesirea va fi 0010

Pentru exersarea instantierii si intelegerea circuitului din spatele operatilor multibit implementati acest circuit prin instantierea a 4 porti AND4 pe 1 bit intr-o poarta AND4 pe 4 biti.

[[Fișier:schema_and4_4b_din_and4_1b_v1.png ‎| 400px]]

Pentru testarea circuitului, generati in testbench urmatoarele forme de unda (liniile punctate reprezinta 5ns):

[[Fișier:Wavedrom_and4_4b.png ‎| 500px]]

Exista si un mod mai rapid si simplu de a scrie aceasta functionalitate, grupand intrarile si iesirile in "bus"-uri, ca in codul de mai jos.
Acest mod de a grupa firele este desenat mai jos.

[[Fișier:schema_and4_4b_din_and4_1b_v2.png ‎| 600px]]

Fisierul and4_4b.sv:
<syntaxhighlight lang="Verilog">
module and4_4b
(
input logic [3:0] in0, // in0 are 4b, de la bit 3 la bit 0 inclusiv
input logic [3:0] in1, // se noteaza msb:lsb (most significant bit: least significant bit) (echivalent cu conceptul de cifra sutelor, cifra unitatilor, pt binar)
input logic [3:0] in2,
input logic [3:0] in3,
output logic [3:0] out0
);

assign out0 = in0 & in1 & in2 & in3;

endmodule
</syntaxhighlight>

===Exercitiul 6: Desenati schemele logice pentru urmatoarele circuite:===

'''a) Schema 1'''
<syntaxhighlight lang="Verilog">
module schema1 (a, b, c, d, f);
input logic a, b, c, d;
output logic f, g;

logic w1;
logic w2;

and P1 ( w1, a, c );
or P2 ( f, w1, w2, d);
not P3 (w2, b);
and P4 (g, w1, b, d);
endmodule
</syntaxhighlight>

Observatie: In versiunea veche de verilog (si s-a pastrat si in cea curenta), se pot specifica directiile porturilor si in exteriorul parantezelor, ca mai sus.
Aceasta scriere NU este recomandata.

'''b) Schema 2'''
<syntaxhighlight lang="Verilog">
module schema2 (a, b, c, d, f);
input logic a, b, c, d;
output logic f;

logic w1, w2;

nand P1 ( w1, a, b ), P2 (w2, c, d);
and P3 ( f, w1, w2);
endmodule
</syntaxhighlight>

'''Observatie:''' asemanator cu C/C++, se pot face declaratii in aceeasi linie a mai multor "variabile", aici fire sau instante, cum se poate vedea la w1 si w2 (ambele fiind fire) sau la P1 si P2 (ambele fiind porti nand).
Aceasta scriere NU este recomandata.

CID aplicatii 1 : Generare de forme de unda

2026-02-28T17:42:01Z

Mihai.antonescu: /* Exercițiul 2 */

În această sesiune de aplicații vom învăța cum să generăm semnale digitale cu ajutorul limbajului SystemVerilog. Generarea de semnale este utilizată în testarea prin simulare a circuitelor digitale. Semnalele generate sunt introduse la intrarea circuitului, observându-se apoi cum se modifică starea ieșirilor acestuia.

Proiectarea circuitelor digitale se bazează pe generarea unor circuite digitale fizice. Deși se va scrie cod în limbajul SystemVerilog, mereu trebuie avut în vedere faptul că în spate se va genera un circuit fizic, codul nu se rulează pas cu pas, aceasta fiind deosebirea fundamentală dintre limbajele de descriere hardware (generează circuite fizice) și limbajele de programare (cod care se execută pas cu pas). Unele concepte cât și unele elemente de sintaxa este posibil să semene cu ce ați facut la programare, dar este important să înțelegeți că prin codul scris se desenează/generează circuite. Sau invers, pornind de la un desen, se poate face o descriere în SystemVerilog a acestuia.

Proiectele exemplu care pot fi descărcate au fost implementate folosind Vivado 2021.2. Dacă aveți altă versiune este posibil să vă ceară să le salvați în versiunea respectivă sau să fie nevoie să vă faceți un proiect nou, în care să adaugați fișierele cu cod.

==Noțiuni și cunoștințe necesare==

* [[Introducere. SystemVerilog HDL]] (Sintaxa [[SystemVerilog]])

* [[Tutorial Vivado]].

==Modulul de test (Testbench)==
Modulul de test este un modul nesintetizabil (nu poate fi transformat într-un circuit de către utilitarul care realizează sinteza) și este folosit, așa cum sugerează și numele, în testarea circuitelor. Acest modul este folosit exclusiv în simulare. Simularea permite detecția rapidă a erorilor de implementare și corectarea acestora. Ideea generală a unui modul de test este descrisă în figura de mai jos (considerăm un circuit cu numele ''circuit'' și modulul său de test ''circuit_tb''):

[[Fișier:CircuitTestbench.png ‎| 400px]]

După cum se vede în figura de mai sus, modulul de test conține printre altele și un '''generator de semnale de test'''. Acesta are rolul de a genera câte un semnal de test pentru fiecare intrare a circuitului. Forma acestor semnale de test este stabilită de către cel care realizează verificarea și trebuie aleasă astfel încât să detectăm cât mai multe posibile erori.

==Exemple==
====Exemplul 1: Generarea a doua semnale digitale de 1 bit====
Să se genereze două semnale digitale de 1 bit, care să aibă următoarea variație în timp (unitatea de timp este de 1ns):

[[Fișier:CID Aplicatii1 ex1.svg|400px]]

<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps // setăm unitatea de timp la 1ns, cu o precizie de 1ps

module waveform1(); // modulul se numește waveform1 și nu are nicio intrare și nicio ieșire. Semnalele de test generate sunt semnale interne.

logic a, b; // cele două semnale de test sunt trebuie declarate ca elemente de tip logic.

initial begin
$monitor("time = %2d, a = %b, b=%b", $time, a, b); // monitorizăm în consolă starea semnalelor a si b
a = 0; // semnalul a va avea valoarea 0 la momentul inițial de timp (la momentul t = 0)
b = 0; // semnalul b va avea valoarea 0 la momentul inițial de timp (la momentul t = 0)
#1 a = 1; // după 1ns de la momentul inițial, a se face 1
#1 b = 1; // după 2ns de la momentul inițial, b se face 1
#1 a = 0; // după 3ns de la momentul inițial, a se face 0
b = 0; // după 3ns de la momentul inițial, b se face 0
#2 $stop(); // simularea este oprită
end

endmodule // incheiem descrierea modulului de generare de semnale digitale
</syntaxhighlight>

'''Observație:''' Atunci când un semnal are dimensiunea de 1 bit, nu va apărea nimic intre tipul acestuia și nume. Atunci când semnalul are o dimensiune mai mare sau egală cu doi biți, dimensiunea va fi descrisă sub forma '''[n-1:0]''', unde '''n''' este numărul de biți. Conform acestei descrieri, bitul '''n-1''' este cel mai semnificativ.

<syntaxhighlight lang="Verilog">
logic a; //semnal cu dimeniunea de 1 bit
logic [7:0] data; //semnal/magistrală/bus cu dimensiunea de 8 biți
</syntaxhighlight>

====Exemplul 2: Generarea unui semnal periodic de 1 bit====
Să se genereze un semnal digital periodic de 1 bit, cu perioada egală cu 2ns:

[[Fișier:Clock wave.png | 600px]]

<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps // setăm unitatea de timp la 1ns, cu o precizie de 1ps

module waveform2(); // modulul se numește waveform2 si nu are nicio intrare și nicio iesire

logic clock; // semnalul de test este declarat de tip logic

initial begin
clock = 0; // valoarea inițială a semnalului va fi 0 (la momentul t = 0)
forever // forever indică faptul că ce urmează se va repeta într-o buclă continuă.
begin
#1 clock = ~clock; // La trecea unui timp egal cu unitatea de timp definită, semnalul clock iși va nega valoarea
end

// fiind o singura instructiune in bucla "forever", se putea omite begin/end => forever #1 clock = ~clock;

end

initial begin
#20 $stop(); // La 20 de unități de timp (aici, 20 ns), simularea se va opri.
// Aici punem $stop într-un bloc separat, deoarece forever blochează blocul initial în care se află
// Toate blocurile initial încep la același moment de timp (t = 0) și au efect în paralel
end

endmodule
</syntaxhighlight>

==Exerciții==
====Exercițiul 1====
Generați două semnale digitale '''a''' și '''b''' de 1 bit, astfel încât să se formeze cu ele toate cele 4 combinații posibile, după cum urmează:

'''t = 0ns''': a = 0, b = 0
'''t = 1ns''': a = 0, b = 1
'''t = 2ns''': a = 1, b = 0
'''t = 3ns''': a = 1, b = 1

Rezolvati aceasta cerinta folosind un singur block "initial".

Rezolvati aceasta cerinta folosind blocuri "initial" distincte pentru fiecare din cele 2 semnale si pentru comanda de "stop".

====Exercițiul 2====
Generați semnalele din imaginea de mai jos:

[[Fișier:lab1_ex2_waveform.png | 600px]]

Simularea se va opri la 100ns de la inceperea ei.

====Exercițiul 3====
Să se genereze un semnal digital de 8 biți aliniat la fronturile crescătoare ale unui semnal periodic (semnal de ceas), ce are perioada de 2ns:

[[Fișier:Clock and data wave.png | 600px]]

'''Observație:'''
* Frontul crescător al unui semnal este definit ca tranziția dintre nivelul de 0 logic și 1 logic.
* Spunem că un semnal este aliniat la fronturile crescătoare ale unui alt semnal dacă acesta își modifică valoarea imediat după apariția acelui front crescător. În figura de mai sus, se observă că '''data''' își schimbă valoarea imediat după fiecare front crescător al semnalului '''clock'''.

'''Indicații''':

* Așteptarea unui front crescător al semnalului ''NumeSemnal'' se realizează cu '''@(posedge ''NumeSemnal'')'''. Aceasta va înlocui întârzierile de tip '''#n''' folosite anterior.
* Pentru semnalele ce se doresc aliniate la un eveniment de tip '''posedge''', vom folosi atribuirea non-blocantă: de exemplu, '''data <= 1;'''.
* Nu uitați! Folosirea ''forever'' pentru generarea semnalului de ceas va bloca acel bloc ''initial''.
* Incrementarea valorii unui semnal se poate realiza cu un bloc de tip ''for'', inclus in blocul ''initial''. Blocul ''for'' va avea nevoie de un contor de tip ''integer'', declarat în afara blocului ''initial''. Pentru mai multe detalii, consultați tutorialul de sintaxa SystemVerilog.

Folosind indicațiile anterioare, înlocuiți al doilea bloc ''initial'' din '''Exemplul 2''' cu următoarea secvență și completați liniile de cod lipsă:
<syntaxhighlight lang="Verilog">
integer index;

initial begin
for(index = 0; index < 11; index = index + 1) begin
//completati codul
end
#20 $stop();
end
</syntaxhighlight>

====Exercițiul 4====
Desenați formele de undă ale semnalelor de test ''a'', ''b'' și ''c'', generate cu ajutorul următoarelor două blocuri ''initial'':
<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps

module waveform();

logic a, b, c;

initial begin
a = 0;
b = 0;
#2 b = 1;
#1 a = 1;
#3 b = 0;
#3 a = 0;
#2 $stop();
end

initial begin
c = 1;
#2 c = 0;
#3 c = 1;
end

endmodule
</syntaxhighlight>

====Exercițiul 5====
Generati un semnal digital '''clock''' cu dimensiunea de 1 bit si perioada de 2ns si un semnal digital '''data''', cu dimensiunea de 4 biti, aliniat la fronturile crescatoare ale semnalului '''clock'''. Semnalul '''data''' va varia astfel: '''0, 1, 2, 3, 0, 1, 2 ,3, 0, 1 ... '''. Opriti simularea dupa ce semnalul '''data''' a realizat 4 variatii complete (s-a generat secventa '''0, 1, 2, 3''' de 4 ori).

Fișier:Lab1 ex2 waveform.png

2026-02-28T17:41:09Z

Mihai.antonescu:

CID aplicatii 1 : Generare de forme de unda

2026-02-28T17:40:32Z

Mihai.antonescu:

În această sesiune de aplicații vom învăța cum să generăm semnale digitale cu ajutorul limbajului SystemVerilog. Generarea de semnale este utilizată în testarea prin simulare a circuitelor digitale. Semnalele generate sunt introduse la intrarea circuitului, observându-se apoi cum se modifică starea ieșirilor acestuia.

Proiectarea circuitelor digitale se bazează pe generarea unor circuite digitale fizice. Deși se va scrie cod în limbajul SystemVerilog, mereu trebuie avut în vedere faptul că în spate se va genera un circuit fizic, codul nu se rulează pas cu pas, aceasta fiind deosebirea fundamentală dintre limbajele de descriere hardware (generează circuite fizice) și limbajele de programare (cod care se execută pas cu pas). Unele concepte cât și unele elemente de sintaxa este posibil să semene cu ce ați facut la programare, dar este important să înțelegeți că prin codul scris se desenează/generează circuite. Sau invers, pornind de la un desen, se poate face o descriere în SystemVerilog a acestuia.

Proiectele exemplu care pot fi descărcate au fost implementate folosind Vivado 2021.2. Dacă aveți altă versiune este posibil să vă ceară să le salvați în versiunea respectivă sau să fie nevoie să vă faceți un proiect nou, în care să adaugați fișierele cu cod.

==Noțiuni și cunoștințe necesare==

* [[Introducere. SystemVerilog HDL]] (Sintaxa [[SystemVerilog]])

* [[Tutorial Vivado]].

==Modulul de test (Testbench)==
Modulul de test este un modul nesintetizabil (nu poate fi transformat într-un circuit de către utilitarul care realizează sinteza) și este folosit, așa cum sugerează și numele, în testarea circuitelor. Acest modul este folosit exclusiv în simulare. Simularea permite detecția rapidă a erorilor de implementare și corectarea acestora. Ideea generală a unui modul de test este descrisă în figura de mai jos (considerăm un circuit cu numele ''circuit'' și modulul său de test ''circuit_tb''):

[[Fișier:CircuitTestbench.png ‎| 400px]]

După cum se vede în figura de mai sus, modulul de test conține printre altele și un '''generator de semnale de test'''. Acesta are rolul de a genera câte un semnal de test pentru fiecare intrare a circuitului. Forma acestor semnale de test este stabilită de către cel care realizează verificarea și trebuie aleasă astfel încât să detectăm cât mai multe posibile erori.

==Exemple==
====Exemplul 1: Generarea a doua semnale digitale de 1 bit====
Să se genereze două semnale digitale de 1 bit, care să aibă următoarea variație în timp (unitatea de timp este de 1ns):

[[Fișier:CID Aplicatii1 ex1.svg|400px]]

<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps // setăm unitatea de timp la 1ns, cu o precizie de 1ps

module waveform1(); // modulul se numește waveform1 și nu are nicio intrare și nicio ieșire. Semnalele de test generate sunt semnale interne.

logic a, b; // cele două semnale de test sunt trebuie declarate ca elemente de tip logic.

initial begin
$monitor("time = %2d, a = %b, b=%b", $time, a, b); // monitorizăm în consolă starea semnalelor a si b
a = 0; // semnalul a va avea valoarea 0 la momentul inițial de timp (la momentul t = 0)
b = 0; // semnalul b va avea valoarea 0 la momentul inițial de timp (la momentul t = 0)
#1 a = 1; // după 1ns de la momentul inițial, a se face 1
#1 b = 1; // după 2ns de la momentul inițial, b se face 1
#1 a = 0; // după 3ns de la momentul inițial, a se face 0
b = 0; // după 3ns de la momentul inițial, b se face 0
#2 $stop(); // simularea este oprită
end

endmodule // incheiem descrierea modulului de generare de semnale digitale
</syntaxhighlight>

'''Observație:''' Atunci când un semnal are dimensiunea de 1 bit, nu va apărea nimic intre tipul acestuia și nume. Atunci când semnalul are o dimensiune mai mare sau egală cu doi biți, dimensiunea va fi descrisă sub forma '''[n-1:0]''', unde '''n''' este numărul de biți. Conform acestei descrieri, bitul '''n-1''' este cel mai semnificativ.

<syntaxhighlight lang="Verilog">
logic a; //semnal cu dimeniunea de 1 bit
logic [7:0] data; //semnal/magistrală/bus cu dimensiunea de 8 biți
</syntaxhighlight>

====Exemplul 2: Generarea unui semnal periodic de 1 bit====
Să se genereze un semnal digital periodic de 1 bit, cu perioada egală cu 2ns:

[[Fișier:Clock wave.png | 600px]]

<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps // setăm unitatea de timp la 1ns, cu o precizie de 1ps

module waveform2(); // modulul se numește waveform2 si nu are nicio intrare și nicio iesire

logic clock; // semnalul de test este declarat de tip logic

initial begin
clock = 0; // valoarea inițială a semnalului va fi 0 (la momentul t = 0)
forever // forever indică faptul că ce urmează se va repeta într-o buclă continuă.
begin
#1 clock = ~clock; // La trecea unui timp egal cu unitatea de timp definită, semnalul clock iși va nega valoarea
end

// fiind o singura instructiune in bucla "forever", se putea omite begin/end => forever #1 clock = ~clock;

end

initial begin
#20 $stop(); // La 20 de unități de timp (aici, 20 ns), simularea se va opri.
// Aici punem $stop într-un bloc separat, deoarece forever blochează blocul initial în care se află
// Toate blocurile initial încep la același moment de timp (t = 0) și au efect în paralel
end

endmodule
</syntaxhighlight>

==Exerciții==
====Exercițiul 1====
Generați două semnale digitale '''a''' și '''b''' de 1 bit, astfel încât să se formeze cu ele toate cele 4 combinații posibile, după cum urmează:

'''t = 0ns''': a = 0, b = 0
'''t = 1ns''': a = 0, b = 1
'''t = 2ns''': a = 1, b = 0
'''t = 3ns''': a = 1, b = 1

Rezolvati aceasta cerinta folosind un singur block "initial".

Rezolvati aceasta cerinta folosind blocuri "initial" distincte pentru fiecare din cele 2 semnale si pentru comanda de "stop".

====Exercițiul 2====
Generați semnalele din imaginea de mai jos:
[[Fișier:lab1_ex2_waveform.png | 600px]]
Simularea se va opri la 100ns de la inceperea ei.

====Exercițiul 3====
Să se genereze un semnal digital de 8 biți aliniat la fronturile crescătoare ale unui semnal periodic (semnal de ceas), ce are perioada de 2ns:

[[Fișier:Clock and data wave.png | 600px]]

'''Observație:'''
* Frontul crescător al unui semnal este definit ca tranziția dintre nivelul de 0 logic și 1 logic.
* Spunem că un semnal este aliniat la fronturile crescătoare ale unui alt semnal dacă acesta își modifică valoarea imediat după apariția acelui front crescător. În figura de mai sus, se observă că '''data''' își schimbă valoarea imediat după fiecare front crescător al semnalului '''clock'''.

'''Indicații''':

* Așteptarea unui front crescător al semnalului ''NumeSemnal'' se realizează cu '''@(posedge ''NumeSemnal'')'''. Aceasta va înlocui întârzierile de tip '''#n''' folosite anterior.
* Pentru semnalele ce se doresc aliniate la un eveniment de tip '''posedge''', vom folosi atribuirea non-blocantă: de exemplu, '''data <= 1;'''.
* Nu uitați! Folosirea ''forever'' pentru generarea semnalului de ceas va bloca acel bloc ''initial''.
* Incrementarea valorii unui semnal se poate realiza cu un bloc de tip ''for'', inclus in blocul ''initial''. Blocul ''for'' va avea nevoie de un contor de tip ''integer'', declarat în afara blocului ''initial''. Pentru mai multe detalii, consultați tutorialul de sintaxa SystemVerilog.

Folosind indicațiile anterioare, înlocuiți al doilea bloc ''initial'' din '''Exemplul 2''' cu următoarea secvență și completați liniile de cod lipsă:
<syntaxhighlight lang="Verilog">
integer index;

initial begin
for(index = 0; index < 11; index = index + 1) begin
//completati codul
end
#20 $stop();
end
</syntaxhighlight>

====Exercițiul 4====
Desenați formele de undă ale semnalelor de test ''a'', ''b'' și ''c'', generate cu ajutorul următoarelor două blocuri ''initial'':
<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps

module waveform();

logic a, b, c;

initial begin
a = 0;
b = 0;
#2 b = 1;
#1 a = 1;
#3 b = 0;
#3 a = 0;
#2 $stop();
end

initial begin
c = 1;
#2 c = 0;
#3 c = 1;
end

endmodule
</syntaxhighlight>

====Exercițiul 5====
Generati un semnal digital '''clock''' cu dimensiunea de 1 bit si perioada de 2ns si un semnal digital '''data''', cu dimensiunea de 4 biti, aliniat la fronturile crescatoare ale semnalului '''clock'''. Semnalul '''data''' va varia astfel: '''0, 1, 2, 3, 0, 1, 2 ,3, 0, 1 ... '''. Opriti simularea dupa ce semnalul '''data''' a realizat 4 variatii complete (s-a generat secventa '''0, 1, 2, 3''' de 4 ori).

CID aplicatii 1 : Generare de forme de unda

2026-02-28T17:29:46Z

Mihai.antonescu: /* Exercițiul 1 */

În această sesiune de aplicații vom învăța cum să generăm semnale digitale cu ajutorul limbajului SystemVerilog. Generarea de semnale este utilizată în testarea prin simulare a circuitelor digitale. Semnalele generate sunt introduse la intrarea circuitului, observându-se apoi cum se modifică starea ieșirilor acestuia.

Proiectarea circuitelor digitale se bazează pe generarea unor circuite digitale fizice. Deși se va scrie cod în limbajul SystemVerilog, mereu trebuie avut în vedere faptul că în spate se va genera un circuit fizic, codul nu se rulează pas cu pas, aceasta fiind deosebirea fundamentală dintre limbajele de descriere hardware (generează circuite fizice) și limbajele de programare (cod care se execută pas cu pas). Unele concepte cât și unele elemente de sintaxa este posibil să semene cu ce ați facut la programare, dar este important să înțelegeți că prin codul scris se desenează/generează circuite. Sau invers, pornind de la un desen, se poate face o descriere în SystemVerilog a acestuia.

Proiectele exemplu care pot fi descărcate au fost implementate folosind Vivado 2021.2. Dacă aveți altă versiune este posibil să vă ceară să le salvați în versiunea respectivă sau să fie nevoie să vă faceți un proiect nou, în care să adaugați fișierele cu cod.

==Noțiuni și cunoștințe necesare==

* [[Introducere. SystemVerilog HDL]] (Sintaxa [[SystemVerilog]])

* [[Tutorial Vivado]].

==Modulul de test (Testbench)==
Modulul de test este un modul nesintetizabil (nu poate fi transformat într-un circuit de către utilitarul care realizează sinteza) și este folosit, așa cum sugerează și numele, în testarea circuitelor. Acest modul este folosit exclusiv în simulare. Simularea permite detecția rapidă a erorilor de implementare și corectarea acestora. Ideea generală a unui modul de test este descrisă în figura de mai jos (considerăm un circuit cu numele ''circuit'' și modulul său de test ''circuit_tb''):

[[Fișier:CircuitTestbench.png ‎| 400px]]

După cum se vede în figura de mai sus, modulul de test conține printre altele și un '''generator de semnale de test'''. Acesta are rolul de a genera câte un semnal de test pentru fiecare intrare a circuitului. Forma acestor semnale de test este stabilită de către cel care realizează verificarea și trebuie aleasă astfel încât să detectăm cât mai multe posibile erori.

==Exemple==
====Exemplul 1: Generarea a doua semnale digitale de 1 bit====
Să se genereze două semnale digitale de 1 bit, care să aibă următoarea variație în timp (unitatea de timp este de 1ns):

[[Fișier:CID Aplicatii1 ex1.svg|400px]]

<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps // setăm unitatea de timp la 1ns, cu o precizie de 1ps

module waveform1(); // modulul se numește waveform1 și nu are nicio intrare și nicio ieșire. Semnalele de test generate sunt semnale interne.

logic a, b; // cele două semnale de test sunt trebuie declarate ca elemente de tip logic.

initial begin
$monitor("time = %2d, a = %b, b=%b", $time, a, b); // monitorizăm în consolă starea semnalelor a si b
a = 0; // semnalul a va avea valoarea 0 la momentul inițial de timp (la momentul t = 0)
b = 0; // semnalul b va avea valoarea 0 la momentul inițial de timp (la momentul t = 0)
#1 a = 1; // după 1ns de la momentul inițial, a se face 1
#1 b = 1; // după 2ns de la momentul inițial, b se face 1
#1 a = 0; // după 3ns de la momentul inițial, a se face 0
b = 0; // după 3ns de la momentul inițial, b se face 0
#2 $stop(); // simularea este oprită
end

endmodule // incheiem descrierea modulului de generare de semnale digitale
</syntaxhighlight>

'''Observație:''' Atunci când un semnal are dimensiunea de 1 bit, nu va apărea nimic intre tipul acestuia și nume. Atunci când semnalul are o dimensiune mai mare sau egală cu doi biți, dimensiunea va fi descrisă sub forma '''[n-1:0]''', unde '''n''' este numărul de biți. Conform acestei descrieri, bitul '''n-1''' este cel mai semnificativ.

<syntaxhighlight lang="Verilog">
logic a; //semnal cu dimeniunea de 1 bit
logic [7:0] data; //semnal/magistrală/bus cu dimensiunea de 8 biți
</syntaxhighlight>

====Exemplul 2: Generarea unui semnal periodic de 1 bit====
Să se genereze un semnal digital periodic de 1 bit, cu perioada egală cu 2ns:

[[Fișier:Clock wave.png | 600px]]

<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps // setăm unitatea de timp la 1ns, cu o precizie de 1ps

module waveform2(); // modulul se numește waveform2 si nu are nicio intrare și nicio iesire

logic clock; // semnalul de test este declarat de tip logic

initial begin
clock = 0; // valoarea inițială a semnalului va fi 0 (la momentul t = 0)
forever // forever indică faptul că ce urmează se va repeta într-o buclă continuă.
begin
#1 clock = ~clock; // La trecea unui timp egal cu unitatea de timp definită, semnalul clock iși va nega valoarea
end

// fiind o singura instructiune in bucla "forever", se putea omite begin/end => forever #1 clock = ~clock;

end

initial begin
#20 $stop(); // La 20 de unități de timp (aici, 20 ns), simularea se va opri.
// Aici punem $stop într-un bloc separat, deoarece forever blochează blocul initial în care se află
// Toate blocurile initial încep la același moment de timp (t = 0) și au efect în paralel
end

endmodule
</syntaxhighlight>

==Exerciții==
====Exercițiul 1====
Generați două semnale digitale '''a''' și '''b''' de 1 bit, astfel încât să se formeze cu ele toate cele 4 combinații posibile, după cum urmează:

'''t = 0ns''': a = 0, b = 0
'''t = 1ns''': a = 0, b = 1
'''t = 2ns''': a = 1, b = 0
'''t = 3ns''': a = 1, b = 1

Rezolvati aceasta cerinta folosind un singur block "initial".

Rezolvati aceasta cerinta folosind blocuri "initial" distincte pentru fiecare din cele 2 semnale si pentru comanda de "stop".

====Exercițiul 2====
Să se genereze un semnal digital de 8 biți aliniat la fronturile crescătoare ale unui semnal periodic (semnal de ceas), ce are perioada de 2ns:

[[Fișier:Clock and data wave.png | 600px]]

'''Observație:'''
* Frontul crescător al unui semnal este definit ca tranziția dintre nivelul de 0 logic și 1 logic.
* Spunem că un semnal este aliniat la fronturile crescătoare ale unui alt semnal dacă acesta își modifică valoarea imediat după apariția acelui front crescător. În figura de mai sus, se observă că '''data''' își schimbă valoarea imediat după fiecare front crescător al semnalului '''clock'''.

'''Indicații''':

* Așteptarea unui front crescător al semnalului ''NumeSemnal'' se realizează cu '''@(posedge ''NumeSemnal'')'''. Aceasta va înlocui întârzierile de tip '''#n''' folosite anterior.
* Pentru semnalele ce se doresc aliniate la un eveniment de tip '''posedge''', vom folosi atribuirea non-blocantă: de exemplu, '''data <= 1;'''.
* Nu uitați! Folosirea ''forever'' pentru generarea semnalului de ceas va bloca acel bloc ''initial''.
* Incrementarea valorii unui semnal se poate realiza cu un bloc de tip ''for'', inclus in blocul ''initial''. Blocul ''for'' va avea nevoie de un contor de tip ''integer'', declarat în afara blocului ''initial''. Pentru mai multe detalii, consultați tutorialul de sintaxa SystemVerilog.

Folosind indicațiile anterioare, înlocuiți al doilea bloc ''initial'' din '''Exemplul 2''' cu următoarea secvență și completați liniile de cod lipsă:
<syntaxhighlight lang="Verilog">
integer index;

initial begin
for(index = 0; index < 11; index = index + 1) begin
//completati codul
end
#20 $stop();
end
</syntaxhighlight>

====Exercițiul 3====
Desenați formele de undă ale semnalelor de test ''a'', ''b'' și ''c'', generate cu ajutorul următoarelor două blocuri ''initial'':
<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps

module waveform();

logic a, b, c;

initial begin
a = 0;
b = 0;
#2 b = 1;
#1 a = 1;
#3 b = 0;
#3 a = 0;
#2 $stop();
end

initial begin
c = 1;
#2 c = 0;
#3 c = 1;
end

endmodule
</syntaxhighlight>

====Exercițiul 4====
Generati un semnal digital '''clock''' cu dimensiunea de 1 bit si perioada de 2ns si un semnal digital '''data''', cu dimensiunea de 4 biti, aliniat la fronturile crescatoare ale semnalului '''clock'''. Semnalul '''data''' va varia astfel: '''0, 1, 2, 3, 0, 1, 2 ,3, 0, 1 ... '''. Opriti simularea dupa ce semnalul '''data''' a realizat 4 variatii complete (s-a generat secventa '''0, 1, 2, 3''' de 4 ori).

Circuite Integrate Digitale

2026-02-25T19:12:28Z

Mihai.antonescu: /* Scopul laboratorului */

== Scopul laboratorului ==

Laboratorul de circuite integrate digitale vine ca o completare practica a cursului de CID.
Prin definitie, acesta se va axa pe elemente practice de simulare, sinteza si testare a circuitelor ce sunt prezentate la curs.

Acest laborator se bazeaza pe limbajul "SystemVerilog", acesta fiind unul din cele 2 limbaje de descriere hardware folosite in industrie la ora actuala (celalalt fiind "VHDL"). "SystemVerilog" vine ca o completare la "Verilog", introducand numeroase elemente ce ajuta in special testarea circuitelor, dar si unele imbunatatiri pentru procesul de proiectare.

Platformele sunt structurate astfel incat sa contina cateva elemente de teorie minimala, un exemplu de circuit descris in cod Verilog si apoi exercitii pe care sa le rezolvati in ora de aplicatii (simulare/testare pe placa FPGA) si acasa (simulare).

In laborator se va lucra in Vivado, program al firmei Xilinx, pe o placa Boolean Board.

Circuitele digitale sunt o parte fundamentala a electronici moderne, cu numeroase oportunitati in industrie, atat in design cat si in verificarea circuitelor.

Pe langa ce veti invata in acest laborator, limbajul ofera si capabilitati mai avansate pentru a descrie mai eficient circuitele dorite, cat si pentru testarea acestora. Sintaxa nu se termina cu ce invatati aici si pentru cei pasionati, nu ezitati sa va contactati cadrul didactic cu intrebari.

Speram ca o sa va placa, veti invata si vi se va parea interesant ce veti vedea in orele de aplicatii ce urmeaza. Spor.

== Tutoriale și documentații ==

Programul Vivado este gratuit (necesita cont, dar este gratis) si poate fi descarcat si instalat urmand tutorialul de aici:
# [[Tutorial instalare Vivado]]
# [[Tutorial Vivado]].
# [[FPGA - Introducere]].
# [https://www.realdigital.org/doc/02013cd17602c8af749f00561f88ae21 Boolean Board - user manual]
# [[Boolean Board - Pinout]].
# [https://www.tulembedded.com/FPGA/ProductsPYNQ-Z2.html Pynq-Z2 - pagina oficiala]
# [https://dpoauwgwqsy2x.cloudfront.net/Download/pynqz2_user_manual_v1_0.pdf Pynq-Z2 - user manual]
# [[Pynq-Z2 - Pinout]].

O lista de link-uri utile poate fi gasita aici:
# [[Introducere. SystemVerilog HDL]] (Sintaxa [[SystemVerilog]])
# [https://www.asic-world.com/digital/index.html Asic-world - digital]
# [https://www.asic-world.com/verilog/index.html Asic-world - verilog]
# [https://nandgame.com/ Joc online: Nandgame]
# [https://circuitverse.org/simulator Simulator/joc online si grafic de circuite: Circuitverse]
# [https://falstad.com/circuit/ Simulator online si grafic de circuite (analog+digital): Falstad]
# [https://github.com/hneemann/Digital Simulator grafic de circuite digitale: hneemann-digital]
# [https://play.google.com/store/apps/details?id=com.ViacheslavRud.Circuit&hl=en_US&gl=US Joc android - Make it True: Solve the Circuit]
# [https://www.edaplayground.com/ Simulatoare online (mod text): Edaplayground]
# [https://wavedrom.com/ Utilitar desenare forme de unda]
# [https://www.draw.io/ Utilitar desenare diagrame]
# [[Domenii conexe]]

== Lucrări de laborator ==

# [[CID_aplicatii_1 : Generare de forme de unda]]
# [[CID_aplicatii_2 : Instantiere si porti logice]]
# [[CID_aplicatii_3 : Circuite combinationale elementare]]
# [[CID_aplicatii_4 : Memoria ROM]]
# [[CID_aplicatii_5 : Exercitii cu circuite combinationale]]
# CID_aplicatii_6 : Lucrarea 1 - circuite combinationale
# [[CID_aplicatii_7 : Circuite secventiale elementare]]
# [[CID_aplicatii_8 : Registre si memorii RAM]]
# [[CID_aplicatii_9 : Numaratorul]]
# [[CID_aplicatii_10 : Aplicatii cu numaratoare]]
# [[CID_aplicatii_11 : Automate finite]]
# [[CID_aplicatii_12 : Exercitii cu circuite secventiale]]
# CID_aplicatii_13 : Lucrarea 2 - circuite secventiale
# [[CID_aplicatii_14 : Circuite digitale complexe]]

CID aplicatii 1 : Generare de forme de unda

2026-02-25T08:33:30Z

Mihai.antonescu:

În această sesiune de aplicații vom învăța cum să generăm semnale digitale cu ajutorul limbajului SystemVerilog. Generarea de semnale este utilizată în testarea prin simulare a circuitelor digitale. Semnalele generate sunt introduse la intrarea circuitului, observându-se apoi cum se modifică starea ieșirilor acestuia.

Proiectarea circuitelor digitale se bazează pe generarea unor circuite digitale fizice. Deși se va scrie cod în limbajul SystemVerilog, mereu trebuie avut în vedere faptul că în spate se va genera un circuit fizic, codul nu se rulează pas cu pas, aceasta fiind deosebirea fundamentală dintre limbajele de descriere hardware (generează circuite fizice) și limbajele de programare (cod care se execută pas cu pas). Unele concepte cât și unele elemente de sintaxa este posibil să semene cu ce ați facut la programare, dar este important să înțelegeți că prin codul scris se desenează/generează circuite. Sau invers, pornind de la un desen, se poate face o descriere în SystemVerilog a acestuia.

Proiectele exemplu care pot fi descărcate au fost implementate folosind Vivado 2021.2. Dacă aveți altă versiune este posibil să vă ceară să le salvați în versiunea respectivă sau să fie nevoie să vă faceți un proiect nou, în care să adaugați fișierele cu cod.

==Noțiuni și cunoștințe necesare==

* [[Introducere. SystemVerilog HDL]] (Sintaxa [[SystemVerilog]])

* [[Tutorial Vivado]].

==Modulul de test (Testbench)==
Modulul de test este un modul nesintetizabil (nu poate fi transformat într-un circuit de către utilitarul care realizează sinteza) și este folosit, așa cum sugerează și numele, în testarea circuitelor. Acest modul este folosit exclusiv în simulare. Simularea permite detecția rapidă a erorilor de implementare și corectarea acestora. Ideea generală a unui modul de test este descrisă în figura de mai jos (considerăm un circuit cu numele ''circuit'' și modulul său de test ''circuit_tb''):

[[Fișier:CircuitTestbench.png ‎| 400px]]

După cum se vede în figura de mai sus, modulul de test conține printre altele și un '''generator de semnale de test'''. Acesta are rolul de a genera câte un semnal de test pentru fiecare intrare a circuitului. Forma acestor semnale de test este stabilită de către cel care realizează verificarea și trebuie aleasă astfel încât să detectăm cât mai multe posibile erori.

==Exemple==
====Exemplul 1: Generarea a doua semnale digitale de 1 bit====
Să se genereze două semnale digitale de 1 bit, care să aibă următoarea variație în timp (unitatea de timp este de 1ns):

[[Fișier:CID Aplicatii1 ex1.svg|400px]]

<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps // setăm unitatea de timp la 1ns, cu o precizie de 1ps

module waveform1(); // modulul se numește waveform1 și nu are nicio intrare și nicio ieșire. Semnalele de test generate sunt semnale interne.

logic a, b; // cele două semnale de test sunt trebuie declarate ca elemente de tip logic.

initial begin
$monitor("time = %2d, a = %b, b=%b", $time, a, b); // monitorizăm în consolă starea semnalelor a si b
a = 0; // semnalul a va avea valoarea 0 la momentul inițial de timp (la momentul t = 0)
b = 0; // semnalul b va avea valoarea 0 la momentul inițial de timp (la momentul t = 0)
#1 a = 1; // după 1ns de la momentul inițial, a se face 1
#1 b = 1; // după 2ns de la momentul inițial, b se face 1
#1 a = 0; // după 3ns de la momentul inițial, a se face 0
b = 0; // după 3ns de la momentul inițial, b se face 0
#2 $stop(); // simularea este oprită
end

endmodule // incheiem descrierea modulului de generare de semnale digitale
</syntaxhighlight>

'''Observație:''' Atunci când un semnal are dimensiunea de 1 bit, nu va apărea nimic intre tipul acestuia și nume. Atunci când semnalul are o dimensiune mai mare sau egală cu doi biți, dimensiunea va fi descrisă sub forma '''[n-1:0]''', unde '''n''' este numărul de biți. Conform acestei descrieri, bitul '''n-1''' este cel mai semnificativ.

<syntaxhighlight lang="Verilog">
logic a; //semnal cu dimeniunea de 1 bit
logic [7:0] data; //semnal/magistrală/bus cu dimensiunea de 8 biți
</syntaxhighlight>

====Exemplul 2: Generarea unui semnal periodic de 1 bit====
Să se genereze un semnal digital periodic de 1 bit, cu perioada egală cu 2ns:

[[Fișier:Clock wave.png | 600px]]

<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps // setăm unitatea de timp la 1ns, cu o precizie de 1ps

module waveform2(); // modulul se numește waveform2 si nu are nicio intrare și nicio iesire

logic clock; // semnalul de test este declarat de tip logic

initial begin
clock = 0; // valoarea inițială a semnalului va fi 0 (la momentul t = 0)
forever // forever indică faptul că ce urmează se va repeta într-o buclă continuă.
begin
#1 clock = ~clock; // La trecea unui timp egal cu unitatea de timp definită, semnalul clock iși va nega valoarea
end

// fiind o singura instructiune in bucla "forever", se putea omite begin/end => forever #1 clock = ~clock;

end

initial begin
#20 $stop(); // La 20 de unități de timp (aici, 20 ns), simularea se va opri.
// Aici punem $stop într-un bloc separat, deoarece forever blochează blocul initial în care se află
// Toate blocurile initial încep la același moment de timp (t = 0) și au efect în paralel
end

endmodule
</syntaxhighlight>

==Exerciții==
====Exercițiul 1====
Generați două semnale digitale '''a''' și '''b''' de 1 bit, astfel încât să se formeze cu ele toate cele 4 combinații posibile, după cum urmează:

'''t = 0ns''': a = 0, b = 0
'''t = 1ns''': a = 0, b = 1
'''t = 2ns''': a = 1, b = 0
'''t = 3ns''': a = 1, b = 1

====Exercițiul 2====
Să se genereze un semnal digital de 8 biți aliniat la fronturile crescătoare ale unui semnal periodic (semnal de ceas), ce are perioada de 2ns:

[[Fișier:Clock and data wave.png | 600px]]

'''Observație:'''
* Frontul crescător al unui semnal este definit ca tranziția dintre nivelul de 0 logic și 1 logic.
* Spunem că un semnal este aliniat la fronturile crescătoare ale unui alt semnal dacă acesta își modifică valoarea imediat după apariția acelui front crescător. În figura de mai sus, se observă că '''data''' își schimbă valoarea imediat după fiecare front crescător al semnalului '''clock'''.

'''Indicații''':

* Așteptarea unui front crescător al semnalului ''NumeSemnal'' se realizează cu '''@(posedge ''NumeSemnal'')'''. Aceasta va înlocui întârzierile de tip '''#n''' folosite anterior.
* Pentru semnalele ce se doresc aliniate la un eveniment de tip '''posedge''', vom folosi atribuirea non-blocantă: de exemplu, '''data <= 1;'''.
* Nu uitați! Folosirea ''forever'' pentru generarea semnalului de ceas va bloca acel bloc ''initial''.
* Incrementarea valorii unui semnal se poate realiza cu un bloc de tip ''for'', inclus in blocul ''initial''. Blocul ''for'' va avea nevoie de un contor de tip ''integer'', declarat în afara blocului ''initial''. Pentru mai multe detalii, consultați tutorialul de sintaxa SystemVerilog.

Folosind indicațiile anterioare, înlocuiți al doilea bloc ''initial'' din '''Exemplul 2''' cu următoarea secvență și completați liniile de cod lipsă:
<syntaxhighlight lang="Verilog">
integer index;

initial begin
for(index = 0; index < 11; index = index + 1) begin
//completati codul
end
#20 $stop();
end
</syntaxhighlight>

====Exercițiul 3====
Desenați formele de undă ale semnalelor de test ''a'', ''b'' și ''c'', generate cu ajutorul următoarelor două blocuri ''initial'':
<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps

module waveform();

logic a, b, c;

initial begin
a = 0;
b = 0;
#2 b = 1;
#1 a = 1;
#3 b = 0;
#3 a = 0;
#2 $stop();
end

initial begin
c = 1;
#2 c = 0;
#3 c = 1;
end

endmodule
</syntaxhighlight>

====Exercițiul 4====
Generati un semnal digital '''clock''' cu dimensiunea de 1 bit si perioada de 2ns si un semnal digital '''data''', cu dimensiunea de 4 biti, aliniat la fronturile crescatoare ale semnalului '''clock'''. Semnalul '''data''' va varia astfel: '''0, 1, 2, 3, 0, 1, 2 ,3, 0, 1 ... '''. Opriti simularea dupa ce semnalul '''data''' a realizat 4 variatii complete (s-a generat secventa '''0, 1, 2, 3''' de 4 ori).

CID aplicatii 12 : Exercitii cu circuite secventiale

2025-06-05T07:50:05Z

Mihai.antonescu:

CID aplicatii 12 : Exercitii cu circuite secventiale

2025-06-05T07:49:46Z

Mihai.antonescu:

Fișier:L2 led care se invarte.pdf

2025-06-05T07:49:05Z

Mihai.antonescu:

Fișier:Subiect.pdf

2025-06-05T07:46:28Z

Mihai.antonescu:

Fișier:Subiect pwm l2.pdf

2025-06-05T07:42:57Z

Mihai.antonescu:

CID aplicatii 5 : Exercitii cu circuite combinationale

2025-06-05T07:40:15Z

Mihai.antonescu: /* Exercitiul 6: Calcul si Flag-uri */

==Teorie==

Acest laborator are rolul de a sedimenta cunostiintele dobandite anterior.

El consta in exercitii separate, unele date ca subiect la lucrarea 1 in anii anteriori si cateva notiuni de teorie si sintaxa ajutatoare.

==Teorie: Parametrizare==
Parametrizarea este un mod de a generaliza codul scris pentru a nu fi nevoie sa scrii acelasi modul de mai multe ori doar pentru ca circuitul isi schimba o dimensiune.

Pentru a intelege mai clar avantajele si sintaxa urmariti urmatorul exemplu:

Fisierul sumator.sv:
<syntaxhighlight lang="Verilog">
module sumator # // <= diez deoarece urmeaza lista cu paramteri
( // parametri
parameter data_size = 4 // valoare default 4
// alti parametri aici daca este nevoie, separati prin virgula
)
( // interfata
input logic [data_size-1:0] in0, // si pot folosii parametrul "data_size" pentru dimensiunea bus-ului
input logic [data_size-1:0] in1,
output logic [data_size-1:0] out0
);

assign out0 = in0 + in1;

endmodule
</syntaxhighlight>

Cand se instantiaza un modul parametrizat, se specifica valorile parametrilor astfel:
<syntaxhighlight lang="Verilog">
sumator # ( // parametri
.data_size(8) // se genereaza un sumator pe 8b
)
nume_instanta_0
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out0)
);

sumator # ( // parametri
.data_size(32) // se genereaza un sumator pe 32b
)
nume_instanta_1
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out1)
);

sumator nume_instanta_2 // se genereaza un sumator de dimensiune default, aici 4, asa cum e scris in modulul "sumator"
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out2)
);
</syntaxhighlight>

Puteti folosi parametrizarea in exercitiul 3 de mai jos. Acolo sunt 2 tipuri de multiplexoare, unul cu intrarile pe 1 bit si unul cu intrarile pe 2 biti. Poate fi scris un singur modul parametrizat care sa acopere ambele situatii.

==Teorie: Concatenarea==

Pentru o mai usoara conectare a firelor sau pentru o mai buna organizare si expresivitate a codului, de multe ori este util ca fire individuale sa fie grupate impreuna sau ca un bus de mai multi biti sa fie separat in fire individuale. Acest lucru se face folosind concatenarea, prin simbolurile "{ }".

Un exemplu de folosire a concatenarii este oferit mai jos.
Un sumator pe 8b are rezultatul pe maxim 9b, in cazul in care ambele numere sunt mari. Astfel apare un bit de carry out.
<syntaxhighlight lang="Verilog">
module sumator (
input logic [7:0] in0,
input logic [7:0] in1,
output logic [7:0] out0,
output logic carry_out
);

assign {carry_out,out0} = in0 + in1; // fac suma intre in0 si in1 iar rezultatul il pun pe cei 9b alcatuiti din: 1b carry_out si 8b out0, in ordinea asta

endmodule
</syntaxhighlight>
Se pot concatena oricat de multe semnale, puse in "{ }" si separate prin virgula. Atentie la dimensiunile firelor care se concateneaza.

Se poate de asemenea face concatenare si la dreapta egalului, astfel:
<syntaxhighlight lang="Verilog">
assign fir_pe_10_b = {fir_pe_3b,fir_pe_5b,fir_pe_1b,fir_pe_1b};
</syntaxhighlight>
In exemplul anterior ultimi 2b ai "fir_pe_10_b" vor avea mereu aceeasi valoare, provenind din acelasi fir. Sintaxa SystemVerilog permite asta.

Puteti folosii concatenarea, in exercitiul 2, la flag-ul de overflow.

==Teorie: Constante ca intrari in circuite==
In cazul in care se doreste scrierea unor constante la intrarea unor module, acestea se pun direct intre paranteze la instantiere.
De exemplu, pentru multiplexorul de jos din subiectul "alu structural", intrarea "in3" este conectata la valoarea "1". Sintaxa pentru aceasta este: ".in3(1),".

==Teorie: "_"==
Simbolul "_" (underscore) este ignorat de SystemVerilog si ajuta vizual la citirea semnalelor pe mai multi biti. De exemplu 16'b1010010111110000 este identic cu 16'b1010_0101_1111_0000, al doilea fiind totusi mai usor de citit.

==Exercitii==

===Exercitiul 0: Repararea erorilor===
Arhiva de mai jos contine mai multe proiecte in Vivado, fiecare avand cate o eroare de sintaxa sau de logica. In vederea aprofundari cunostiintelor voastre (si pentru lucrarea de saptamana urmatoare), incercati sa le parcurgeti si sa rezolvati toate problemele.
Pe langa proiecte in sine, in arhiva se afla si un fisier text cu o introducere, rezolvarile si explicatiile pentru fiecare situatie.

[https://drive.google.com/file/d/1cNTpQC54_JEeSk8SxgHTEdGtobCn_-EI/view?usp=drive_link Arhiva_proiecte_cu_erori.zip]

===Exercitiul 1: ALU - descriere comportamentala===
Descrieți comportamental o unitate aritmetico-logică (ALU) care are la intrare 2 numere binare de câte 8 biți și poate calcula următoarele funcții:
:- suma celor două numere
:- diferența celor două numere
:- operații logice bit cu bit (bitwise): SI, SAU, XOR și inversele lor
:- operandul din stanga trece neschimbat
:- operandul din dreapta trece neschimbat
:- numărul din stânga este deplasat la stânga cu nr. de poziții indicat de numărul din dreapta
:- numărul din stânga este deplasat la dreapta cu nr. de poziții indicat de numărul din dreapta

Funcția executată la un anumit moment este determinată de configurația binară de pe intrarea de comandă (function).

ALU are de asemenea intrare de carry și ieșire de carry, plus alte două ieșiri - indicatori - pentru cazurile când rezultatul este zero și când cei doi operanzi sunt egali.

Intrarea de control va fi facuta pe 4 biti ca sa permita existenta a 16 operatii posibile. Fiecare numar de pe intrarea de control (combinatie de 0 si 1) va reprezenta o operatie din cele de mai sus. Scrierea se va face folosind un bloc "case" in functie de aceasta intrare.

===Exercitiul 2: ALU - descriere structurala===

[https://wiki.dcae.pub.ro/images/8/8f/Subiect_big_alu.pdf subiect_alu.pdf]

Daca se doreste selectarea doar a anumitor biti dintr-un bus (cum se vrea din instruction) acest lucru se poate face in 2 feluri:

a) cu fir aditional:
:''wire [1:0] fir_aditional1;''
:''assign fir_aditional1 = instruction[11:10];''
:// apoi la instantiere: ''.sel(fir_aditional1),''

b) direct in instantiere;
:la instantierea celor 2 mux4 din stanga, direct:
::''.sel(instruction[11:10]),''

Pentru a scrie mai putin (a nu face toate modulele de calcul separat + instantierea lor) si pentru ca e vorba de operatii simple, se poate pune operatia cu assign direct in top pe un fir declarat acolo, sau si mai prescurtat, direct operatia dorita cand se intantiaza modulul in care aceasta intra. De exemplu, pentru operatia de shift la dreapta care intra in primul multiplexor, se poate pune: ".in0(data0 >> data1),".

===Exercitiul 3: Multiplexoare===

[https://wiki.dcae.pub.ro/images/3/3a/Subiect_muxes.pdf subiect_muxes.pdf]

===Exercitiul 4: Rom/Look-up table===

[https://wiki.dcae.pub.ro/images/2/2e/Subiect_rom_luts.pdf rom_luts.pdf]

===Exercitiul 5: Sumator cu reprezentare in cifre zecimale===
Proiectati si verificati un sumator zecimal pentru numere cu 2 cifre

Modulul de top (Figura 1) este alcatuit din 2 blocuri de tip '''digitsum'''. Fiecare bloc aduna cifrele de pe aceasi pozitie.

'''Figura 1'''
Top level

[[Fișier: bcdsum.png]]

Blocul '''digitsum''' (Figura 2) este alcatuit din 4 blocuri, 2 sumatoare binare pe 4 biti (de tip '''sum4'''), o instanta de '''cmp''' si un multiplexor elementar mux2

'''Figura 2'''
Blocul DIGIT SUM

[[Fișier: digit.png]]

Primul sumator aduna cifrele din domeniul [0...9] avand un rezultat intre [0 ... 18]

Comparatorul are la iesire 1 daca rezultatul este mai mare decat 9.

Daca rezultatul este mai mic decat 9, acesta este trimis in mod direct la iesirea '''digit''' a blocului '''digitsum'''.

Daca rezultatul este mai mare decat 9, o crectie este necesara si se aduna 6 la rezultat.

Comparatorul cu valoarea 9 este descris structural din porti in figura de mai jos:

'''Figure 3'''
the comparator

[[Fișier: cmp.png]]

Testbench-ul va genera stimuli pentru '''bcdsum''' ca in Figura 4.

Intrarea b0 a '''bcdsum''' se schimba la fiecare 5 pasi de simulare .

b1, a0 si a1 se schimba sincron cu b0 ca in Figura 4.

'''Figure 4'''

[[Fișier: teststimuli.png]]

Cerinte:
# '''cmp'''- descris structural la nivel de porti ca in Figura 3.
# '''sum4''' descris comportamental cu un assign continuu.
# '''mux''' descris comportamental cu always.
# '''digitsum''' descris strctural ca in Figura 2.
# modulul de top numit '''bcdsum''', descris structural ca in Figure 1.
# modulul de testbench, '''bcdsum_tb''', instantiaza '''bcdsum''' cu numele '''dut'''.
# in testbench, generati stimuli pentru intrarile circuitului testat.

===Exercitiul 6: Codor Cezar===

[https://wiki.dcae.pub.ro/images/9/92/Cid_L1_codor_Cezar.pdf Codor_Cezar.pdf]

===Exercitiul 7: Calcul si Flag-uri===

[https://wiki.dcae.pub.ro/images/c/c2/L1_calcul_si_flaguri.pdf Calcul_si_flaguri.pdf]

CID aplicatii 5 : Exercitii cu circuite combinationale

2025-06-05T07:39:52Z

Mihai.antonescu:

==Teorie==

Acest laborator are rolul de a sedimenta cunostiintele dobandite anterior.

El consta in exercitii separate, unele date ca subiect la lucrarea 1 in anii anteriori si cateva notiuni de teorie si sintaxa ajutatoare.

==Teorie: Parametrizare==
Parametrizarea este un mod de a generaliza codul scris pentru a nu fi nevoie sa scrii acelasi modul de mai multe ori doar pentru ca circuitul isi schimba o dimensiune.

Pentru a intelege mai clar avantajele si sintaxa urmariti urmatorul exemplu:

Fisierul sumator.sv:
<syntaxhighlight lang="Verilog">
module sumator # // <= diez deoarece urmeaza lista cu paramteri
( // parametri
parameter data_size = 4 // valoare default 4
// alti parametri aici daca este nevoie, separati prin virgula
)
( // interfata
input logic [data_size-1:0] in0, // si pot folosii parametrul "data_size" pentru dimensiunea bus-ului
input logic [data_size-1:0] in1,
output logic [data_size-1:0] out0
);

assign out0 = in0 + in1;

endmodule
</syntaxhighlight>

Cand se instantiaza un modul parametrizat, se specifica valorile parametrilor astfel:
<syntaxhighlight lang="Verilog">
sumator # ( // parametri
.data_size(8) // se genereaza un sumator pe 8b
)
nume_instanta_0
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out0)
);

sumator # ( // parametri
.data_size(32) // se genereaza un sumator pe 32b
)
nume_instanta_1
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out1)
);

sumator nume_instanta_2 // se genereaza un sumator de dimensiune default, aici 4, asa cum e scris in modulul "sumator"
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out2)
);
</syntaxhighlight>

Puteti folosi parametrizarea in exercitiul 3 de mai jos. Acolo sunt 2 tipuri de multiplexoare, unul cu intrarile pe 1 bit si unul cu intrarile pe 2 biti. Poate fi scris un singur modul parametrizat care sa acopere ambele situatii.

==Teorie: Concatenarea==

Pentru o mai usoara conectare a firelor sau pentru o mai buna organizare si expresivitate a codului, de multe ori este util ca fire individuale sa fie grupate impreuna sau ca un bus de mai multi biti sa fie separat in fire individuale. Acest lucru se face folosind concatenarea, prin simbolurile "{ }".

Un exemplu de folosire a concatenarii este oferit mai jos.
Un sumator pe 8b are rezultatul pe maxim 9b, in cazul in care ambele numere sunt mari. Astfel apare un bit de carry out.
<syntaxhighlight lang="Verilog">
module sumator (
input logic [7:0] in0,
input logic [7:0] in1,
output logic [7:0] out0,
output logic carry_out
);

assign {carry_out,out0} = in0 + in1; // fac suma intre in0 si in1 iar rezultatul il pun pe cei 9b alcatuiti din: 1b carry_out si 8b out0, in ordinea asta

endmodule
</syntaxhighlight>
Se pot concatena oricat de multe semnale, puse in "{ }" si separate prin virgula. Atentie la dimensiunile firelor care se concateneaza.

Se poate de asemenea face concatenare si la dreapta egalului, astfel:
<syntaxhighlight lang="Verilog">
assign fir_pe_10_b = {fir_pe_3b,fir_pe_5b,fir_pe_1b,fir_pe_1b};
</syntaxhighlight>
In exemplul anterior ultimi 2b ai "fir_pe_10_b" vor avea mereu aceeasi valoare, provenind din acelasi fir. Sintaxa SystemVerilog permite asta.

Puteti folosii concatenarea, in exercitiul 2, la flag-ul de overflow.

==Teorie: Constante ca intrari in circuite==
In cazul in care se doreste scrierea unor constante la intrarea unor module, acestea se pun direct intre paranteze la instantiere.
De exemplu, pentru multiplexorul de jos din subiectul "alu structural", intrarea "in3" este conectata la valoarea "1". Sintaxa pentru aceasta este: ".in3(1),".

==Teorie: "_"==
Simbolul "_" (underscore) este ignorat de SystemVerilog si ajuta vizual la citirea semnalelor pe mai multi biti. De exemplu 16'b1010010111110000 este identic cu 16'b1010_0101_1111_0000, al doilea fiind totusi mai usor de citit.

==Exercitii==

===Exercitiul 0: Repararea erorilor===
Arhiva de mai jos contine mai multe proiecte in Vivado, fiecare avand cate o eroare de sintaxa sau de logica. In vederea aprofundari cunostiintelor voastre (si pentru lucrarea de saptamana urmatoare), incercati sa le parcurgeti si sa rezolvati toate problemele.
Pe langa proiecte in sine, in arhiva se afla si un fisier text cu o introducere, rezolvarile si explicatiile pentru fiecare situatie.

[https://drive.google.com/file/d/1cNTpQC54_JEeSk8SxgHTEdGtobCn_-EI/view?usp=drive_link Arhiva_proiecte_cu_erori.zip]

===Exercitiul 1: ALU - descriere comportamentala===
Descrieți comportamental o unitate aritmetico-logică (ALU) care are la intrare 2 numere binare de câte 8 biți și poate calcula următoarele funcții:
:- suma celor două numere
:- diferența celor două numere
:- operații logice bit cu bit (bitwise): SI, SAU, XOR și inversele lor
:- operandul din stanga trece neschimbat
:- operandul din dreapta trece neschimbat
:- numărul din stânga este deplasat la stânga cu nr. de poziții indicat de numărul din dreapta
:- numărul din stânga este deplasat la dreapta cu nr. de poziții indicat de numărul din dreapta

Funcția executată la un anumit moment este determinată de configurația binară de pe intrarea de comandă (function).

ALU are de asemenea intrare de carry și ieșire de carry, plus alte două ieșiri - indicatori - pentru cazurile când rezultatul este zero și când cei doi operanzi sunt egali.

Intrarea de control va fi facuta pe 4 biti ca sa permita existenta a 16 operatii posibile. Fiecare numar de pe intrarea de control (combinatie de 0 si 1) va reprezenta o operatie din cele de mai sus. Scrierea se va face folosind un bloc "case" in functie de aceasta intrare.

===Exercitiul 2: ALU - descriere structurala===

[https://wiki.dcae.pub.ro/images/8/8f/Subiect_big_alu.pdf subiect_alu.pdf]

Daca se doreste selectarea doar a anumitor biti dintr-un bus (cum se vrea din instruction) acest lucru se poate face in 2 feluri:

a) cu fir aditional:
:''wire [1:0] fir_aditional1;''
:''assign fir_aditional1 = instruction[11:10];''
:// apoi la instantiere: ''.sel(fir_aditional1),''

b) direct in instantiere;
:la instantierea celor 2 mux4 din stanga, direct:
::''.sel(instruction[11:10]),''

Pentru a scrie mai putin (a nu face toate modulele de calcul separat + instantierea lor) si pentru ca e vorba de operatii simple, se poate pune operatia cu assign direct in top pe un fir declarat acolo, sau si mai prescurtat, direct operatia dorita cand se intantiaza modulul in care aceasta intra. De exemplu, pentru operatia de shift la dreapta care intra in primul multiplexor, se poate pune: ".in0(data0 >> data1),".

===Exercitiul 3: Multiplexoare===

[https://wiki.dcae.pub.ro/images/3/3a/Subiect_muxes.pdf subiect_muxes.pdf]

===Exercitiul 4: Rom/Look-up table===

[https://wiki.dcae.pub.ro/images/2/2e/Subiect_rom_luts.pdf rom_luts.pdf]

===Exercitiul 5: Sumator cu reprezentare in cifre zecimale===
Proiectati si verificati un sumator zecimal pentru numere cu 2 cifre

Modulul de top (Figura 1) este alcatuit din 2 blocuri de tip '''digitsum'''. Fiecare bloc aduna cifrele de pe aceasi pozitie.

'''Figura 1'''
Top level

[[Fișier: bcdsum.png]]

Blocul '''digitsum''' (Figura 2) este alcatuit din 4 blocuri, 2 sumatoare binare pe 4 biti (de tip '''sum4'''), o instanta de '''cmp''' si un multiplexor elementar mux2

'''Figura 2'''
Blocul DIGIT SUM

[[Fișier: digit.png]]

Primul sumator aduna cifrele din domeniul [0...9] avand un rezultat intre [0 ... 18]

Comparatorul are la iesire 1 daca rezultatul este mai mare decat 9.

Daca rezultatul este mai mic decat 9, acesta este trimis in mod direct la iesirea '''digit''' a blocului '''digitsum'''.

Daca rezultatul este mai mare decat 9, o crectie este necesara si se aduna 6 la rezultat.

Comparatorul cu valoarea 9 este descris structural din porti in figura de mai jos:

'''Figure 3'''
the comparator

[[Fișier: cmp.png]]

Testbench-ul va genera stimuli pentru '''bcdsum''' ca in Figura 4.

Intrarea b0 a '''bcdsum''' se schimba la fiecare 5 pasi de simulare .

b1, a0 si a1 se schimba sincron cu b0 ca in Figura 4.

'''Figure 4'''

[[Fișier: teststimuli.png]]

Cerinte:
# '''cmp'''- descris structural la nivel de porti ca in Figura 3.
# '''sum4''' descris comportamental cu un assign continuu.
# '''mux''' descris comportamental cu always.
# '''digitsum''' descris strctural ca in Figura 2.
# modulul de top numit '''bcdsum''', descris structural ca in Figure 1.
# modulul de testbench, '''bcdsum_tb''', instantiaza '''bcdsum''' cu numele '''dut'''.
# in testbench, generati stimuli pentru intrarile circuitului testat.

===Exercitiul 6: Codor Cezar===

[https://wiki.dcae.pub.ro/images/9/92/Cid_L1_codor_Cezar.pdf Codor_Cezar.pdf]

===Exercitiul 6: Calcul si Flag-uri===

[https://wiki.dcae.pub.ro/images/c/c2/L1_calcul_si_flaguri.pdf Calcul_si_flaguri.pdf]

Fișier:L1 calcul si flaguri.pdf

2025-06-05T07:39:00Z

Mihai.antonescu:

CID aplicatii 5 : Exercitii cu circuite combinationale

2025-06-05T07:20:16Z

Mihai.antonescu: /* Exercitiul 5: Sumator cu reprezentare in cifre zecimale */

==Teorie==

Acest laborator are rolul de a sedimenta cunostiintele dobandite anterior.

El consta in exercitii separate, unele date ca subiect la lucrarea 1 in anii anteriori si cateva notiuni de teorie si sintaxa ajutatoare.

==Teorie: Parametrizare==
Parametrizarea este un mod de a generaliza codul scris pentru a nu fi nevoie sa scrii acelasi modul de mai multe ori doar pentru ca circuitul isi schimba o dimensiune.

Pentru a intelege mai clar avantajele si sintaxa urmariti urmatorul exemplu:

Fisierul sumator.sv:
<syntaxhighlight lang="Verilog">
module sumator # // <= diez deoarece urmeaza lista cu paramteri
( // parametri
parameter data_size = 4 // valoare default 4
// alti parametri aici daca este nevoie, separati prin virgula
)
( // interfata
input logic [data_size-1:0] in0, // si pot folosii parametrul "data_size" pentru dimensiunea bus-ului
input logic [data_size-1:0] in1,
output logic [data_size-1:0] out0
);

assign out0 = in0 + in1;

endmodule
</syntaxhighlight>

Cand se instantiaza un modul parametrizat, se specifica valorile parametrilor astfel:
<syntaxhighlight lang="Verilog">
sumator # ( // parametri
.data_size(8) // se genereaza un sumator pe 8b
)
nume_instanta_0
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out0)
);

sumator # ( // parametri
.data_size(32) // se genereaza un sumator pe 32b
)
nume_instanta_1
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out1)
);

sumator nume_instanta_2 // se genereaza un sumator de dimensiune default, aici 4, asa cum e scris in modulul "sumator"
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out2)
);
</syntaxhighlight>

Puteti folosi parametrizarea in exercitiul 3 de mai jos. Acolo sunt 2 tipuri de multiplexoare, unul cu intrarile pe 1 bit si unul cu intrarile pe 2 biti. Poate fi scris un singur modul parametrizat care sa acopere ambele situatii.

==Teorie: Concatenarea==

Pentru o mai usoara conectare a firelor sau pentru o mai buna organizare si expresivitate a codului, de multe ori este util ca fire individuale sa fie grupate impreuna sau ca un bus de mai multi biti sa fie separat in fire individuale. Acest lucru se face folosind concatenarea, prin simbolurile "{ }".

Un exemplu de folosire a concatenarii este oferit mai jos.
Un sumator pe 8b are rezultatul pe maxim 9b, in cazul in care ambele numere sunt mari. Astfel apare un bit de carry out.
<syntaxhighlight lang="Verilog">
module sumator (
input logic [7:0] in0,
input logic [7:0] in1,
output logic [7:0] out0,
output logic carry_out
);

assign {carry_out,out0} = in0 + in1; // fac suma intre in0 si in1 iar rezultatul il pun pe cei 9b alcatuiti din: 1b carry_out si 8b out0, in ordinea asta

endmodule
</syntaxhighlight>
Se pot concatena oricat de multe semnale, puse in "{ }" si separate prin virgula. Atentie la dimensiunile firelor care se concateneaza.

Se poate de asemenea face concatenare si la dreapta egalului, astfel:
<syntaxhighlight lang="Verilog">
assign fir_pe_10_b = {fir_pe_3b,fir_pe_5b,fir_pe_1b,fir_pe_1b};
</syntaxhighlight>
In exemplul anterior ultimi 2b ai "fir_pe_10_b" vor avea mereu aceeasi valoare, provenind din acelasi fir. Sintaxa SystemVerilog permite asta.

Puteti folosii concatenarea, in exercitiul 2, la flag-ul de overflow.

==Teorie: Constante ca intrari in circuite==
In cazul in care se doreste scrierea unor constante la intrarea unor module, acestea se pun direct intre paranteze la instantiere.
De exemplu, pentru multiplexorul de jos din subiectul "alu structural", intrarea "in3" este conectata la valoarea "1". Sintaxa pentru aceasta este: ".in3(1),".

==Teorie: "_"==
Simbolul "_" (underscore) este ignorat de SystemVerilog si ajuta vizual la citirea semnalelor pe mai multi biti. De exemplu 16'b1010010111110000 este identic cu 16'b1010_0101_1111_0000, al doilea fiind totusi mai usor de citit.

==Exercitii==

===Exercitiul 0: Repararea erorilor===
Arhiva de mai jos contine mai multe proiecte in Vivado, fiecare avand cate o eroare de sintaxa sau de logica. In vederea aprofundari cunostiintelor voastre (si pentru lucrarea de saptamana urmatoare), incercati sa le parcurgeti si sa rezolvati toate problemele.
Pe langa proiecte in sine, in arhiva se afla si un fisier text cu o introducere, rezolvarile si explicatiile pentru fiecare situatie.

[https://drive.google.com/file/d/1cNTpQC54_JEeSk8SxgHTEdGtobCn_-EI/view?usp=drive_link Arhiva_proiecte_cu_erori.zip]

===Exercitiul 1: ALU - descriere comportamentala===
Descrieți comportamental o unitate aritmetico-logică (ALU) care are la intrare 2 numere binare de câte 8 biți și poate calcula următoarele funcții:
:- suma celor două numere
:- diferența celor două numere
:- operații logice bit cu bit (bitwise): SI, SAU, XOR și inversele lor
:- operandul din stanga trece neschimbat
:- operandul din dreapta trece neschimbat
:- numărul din stânga este deplasat la stânga cu nr. de poziții indicat de numărul din dreapta
:- numărul din stânga este deplasat la dreapta cu nr. de poziții indicat de numărul din dreapta

Funcția executată la un anumit moment este determinată de configurația binară de pe intrarea de comandă (function).

ALU are de asemenea intrare de carry și ieșire de carry, plus alte două ieșiri - indicatori - pentru cazurile când rezultatul este zero și când cei doi operanzi sunt egali.

Intrarea de control va fi facuta pe 4 biti ca sa permita existenta a 16 operatii posibile. Fiecare numar de pe intrarea de control (combinatie de 0 si 1) va reprezenta o operatie din cele de mai sus. Scrierea se va face folosind un bloc "case" in functie de aceasta intrare.

===Exercitiul 2: ALU - descriere structurala===

[https://wiki.dcae.pub.ro/images/8/8f/Subiect_big_alu.pdf subiect_alu.pdf]

Daca se doreste selectarea doar a anumitor biti dintr-un bus (cum se vrea din instruction) acest lucru se poate face in 2 feluri:

a) cu fir aditional:
:''wire [1:0] fir_aditional1;''
:''assign fir_aditional1 = instruction[11:10];''
:// apoi la instantiere: ''.sel(fir_aditional1),''

b) direct in instantiere;
:la instantierea celor 2 mux4 din stanga, direct:
::''.sel(instruction[11:10]),''

Pentru a scrie mai putin (a nu face toate modulele de calcul separat + instantierea lor) si pentru ca e vorba de operatii simple, se poate pune operatia cu assign direct in top pe un fir declarat acolo, sau si mai prescurtat, direct operatia dorita cand se intantiaza modulul in care aceasta intra. De exemplu, pentru operatia de shift la dreapta care intra in primul multiplexor, se poate pune: ".in0(data0 >> data1),".

===Exercitiul 3:===

[https://wiki.dcae.pub.ro/images/3/3a/Subiect_muxes.pdf subiect_muxes.pdf]

===Exercitiul 4:===

[https://wiki.dcae.pub.ro/images/2/2e/Subiect_rom_luts.pdf rom_luts.pdf]

===Exercitiul 5: Sumator cu reprezentare in cifre zecimale===
Proiectati si verificati un sumator zecimal pentru numere cu 2 cifre

Modulul de top (Figura 1) este alcatuit din 2 blocuri de tip '''digitsum'''. Fiecare bloc aduna cifrele de pe aceasi pozitie.

'''Figura 1'''
Top level

[[Fișier: bcdsum.png]]

Blocul '''digitsum''' (Figura 2) este alcatuit din 4 blocuri, 2 sumatoare binare pe 4 biti (de tip '''sum4'''), o instanta de '''cmp''' si un multiplexor elementar mux2

'''Figura 2'''
Blocul DIGIT SUM

[[Fișier: digit.png]]

Primul sumator aduna cifrele din domeniul [0...9] avand un rezultat intre [0 ... 18]

Comparatorul are la iesire 1 daca rezultatul este mai mare decat 9.

Daca rezultatul este mai mic decat 9, acesta este trimis in mod direct la iesirea '''digit''' a blocului '''digitsum'''.

Daca rezultatul este mai mare decat 9, o crectie este necesara si se aduna 6 la rezultat.

Comparatorul cu valoarea 9 este descris structural din porti in figura de mai jos:

'''Figure 3'''
the comparator

[[Fișier: cmp.png]]

Testbench-ul va genera stimuli pentru '''bcdsum''' ca in Figura 4.

Intrarea b0 a '''bcdsum''' se schimba la fiecare 5 pasi de simulare .

b1, a0 si a1 se schimba sincron cu b0 ca in Figura 4.

'''Figure 4'''

[[Fișier: teststimuli.png]]

Cerinte:
# '''cmp'''- descris structural la nivel de porti ca in Figura 3.
# '''sum4''' descris comportamental cu un assign continuu.
# '''mux''' descris comportamental cu always.
# '''digitsum''' descris strctural ca in Figura 2.
# modulul de top numit '''bcdsum''', descris structural ca in Figure 1.
# modulul de testbench, '''bcdsum_tb''', instantiaza '''bcdsum''' cu numele '''dut'''.
# in testbench, generati stimuli pentru intrarile circuitului testat.

===Exercitiul 6:===

[https://wiki.dcae.pub.ro/images/9/92/Cid_L1_codor_Cezar.pdf Codor_Cezar.pdf]

CID aplicatii 11 : Automate finite

2025-05-16T09:25:40Z

Mihai.antonescu: /* Exemplul 2: Automat ce detecteaza fronturile crescatoare ale unui semnal */

== Automate finite ==

Automatul finit este folosit pentru a descrie sisteme ce tranziteaza un numar finit de stari. Acest tip de sistem este foarte util atunci cand starile nu sunt tranzitate intr-un mod simplu, evident sau repetitiv.

Automatul finit, numit și FSM (Finite State Machine), este un model matematic de computație, definit de următoarele elemente:
* O mulțime finită de simboluri de intrare, numită alfabet de intrare;
* O mulțime finită și nevidă de simboluri de ieșire, numită alfabet de ieșire;
* O mulțime finită și nevidă de stări, din care doar una, numită starea curentă, este activă la un moment dat;
* O stare inițială, care face parte din mulțimea stărilor;
* O funcție de tranziție a stărilor, care calculează starea următoare a automatului în funcție de starea curentă și de simbolul de intrare;
* O funcție de calcul a ieșirii, care determină simbolul de ieșire în funcție de starea curentă (în cazul automatelor de tip Moore) sau în funcție de starea curentă și de simbolul de intrare (în cazul automatelor de tip Mealy).

[[[[Fișier:Fsm.png]]]]

La fiecare front al ceasului, valoarea stării următoare, calculată de către CLC, va fi încărcată în registru. Dacă registrul are n biți, numărul maxim de stări care pot fi reprezentate este 2n. Acest număr poate fi mai mic, în funcție de schema de codare a stărilor. De exemplu, pentru n = 4, folosind codarea binară se pot reprezenta cel mult 16 stări (0000, 0001, 0010, ..., 1111), în timp ce pentru codarea one-hot, în care doar un singur bit poate lua valoarea 1, se pot reprezenta 4 stări (1000, 0100, 0010, 0001).

Pentru a reprezenta comportamentul unui automat finit, putem folosi grafuri sau organigrame, conventiile de notare depinzand de tipul automatului (Moore sau Mealy).

== Exemple ==
=== Exemplul 1: Automat ce detecteaza secvente de tipul 11....100....0===
In acest exemplu va fi implementat un automat care detecteaza secventele de tipul 11....100....0. Pentru aceasta, automatul va avea o intrare pe un bit (''in'', pe care va veni secventa de biti) si doua iesiri: ''detectOk'', care semnalizeaza prin 1 ca nu a fost inca detectata o secventa ilegala si ''detectFail'', care semnalizeaza prin 1 ca a fost detectata o secventa ilegala (un 1 dupa 0).

Automatul va avea 3 stari:
* Q0 - STATE_READ1: automatul intra in aceasta stare la reset si va ramane in aceasta atata timp cat intrarea este 1 (inca nu a aparut niciun 0).
* Q1 - STATE_READ0: automatul intra in aceasta stare atunci cand apare pe intrare primul 0 si va ramane in aceasta atata timp cat pe intrare este 0.
* Q2 - STATE_ERROR: automatul intra in aceasta stare atunci cand apare un 1 dupa 0 si va ramane blocat aici pana la reset.

Pentru a coda cele 3 stari avem nevoie de minim 2 biti: STATE_READ1 = 2'b00, STATE_READ0 = 2'b01, STATE_ERROR = 2'b10.

Graful automatului este:

[[Fișier:Organigrama FSM 111000.png]]

'''Implementarea automatului'''
<syntaxhighlight lang="Verilog">
module FSM1(
input logic clock,
input logic in,
input logic reset,
output logic detectOk,
output logic detectFail
);

//Se asociaza sirurilor de biti folositi pentru codarea starilor nume ce pot fi folosite mai usor in cod.
//La compilare, numele vor fi inlocuite in cod cu numerele asociate la inceput.
localparam STATE_READ1 = 2'b00;
localparam STATE_READ0 = 2'b01;
localparam STATE_ERROR = 2'b10;

logic [1:0] state, state_next;

//registrul de stare
always_ff @(posedge clock) begin
if(reset == 1)
state <= STATE_READ1;
else
state <= state_next;
end

//circuit combinational pentru calculul starii urmatoare
always_comb begin
state_next = state;
case(state)
STATE_READ1: begin
if(in == 0) state_next = STATE_READ0;
end
STATE_READ0: begin
if(in == 1) state_next = STATE_ERROR;
end
STATE_ERROR: state_next = STATE_ERROR;
default: state_next = STATE_READ1;
endcase
end

//circuit combinational pentru calculul iesirilor
assign detectOk = (state == STATE_READ0) || (state == STATE_READ1);
assign detectFail = (state == STATE_ERROR);

endmodule
</syntaxhighlight>

'''Implementarea unui modul de test pentru FSM1'''
<syntaxhighlight lang="Verilog">
module FSM1_TB();

logic clock_t;
logic reset_t;
logic in_t;
logic detectOk_t;
logic detectFail_t;

initial begin
clock_t = 0;
forever #1 clock_t = ~clock_t;
end

initial begin
in_t <= 1;
reset_t <= 1;
#2 reset_t <= 0;
#10 in_t <= 0;
#10 in_t <= 1;
#10 $stop();
end

FSM1 DUT(
.clock(clock_t),
.reset(reset_t),
.in(in_t),
.detectOk(detectOk_t),
.detectFail(detectFail_t)
);

endmodule
</syntaxhighlight>

===Exemplul 2: Automat ce detecteaza fronturile crescatoare ale unui semnal===
Automatul ce detecteaza fronturile crescatoare are un singur semnal de intrare ''in'', care reprezinta semnalul analizat si o singura iesire, ''out'', generand pe aceasta un puls lung cat o perioada de ceas la fiecare aparitie a unui front crescator pe ''in''.

Vom avea nevoie de 3 stari:
* Q0: automatul intra in aceasta stare la reset si va ramane in aceasta atata timp cat intrarea este 0 (inca nu a aparut niciun front crescator).
* Q1: automatul intra in aceasta stare atunci cand apare pe intrare un front crescator. Dupa aparitia frontului crescator sunt doua posibilitati: linia ramane in 1, ceea ce duce la trecerea in starea Q2 care va duce iesirea in 0 dupa o perioada de ceas, sau linia trece in 0 dupa un ciclu de ceas, ceea ce duce la revenirea in starea Q0.
* Q2: automatul intra in aceasta stare atunci cand linia de intrare ramane in 1 mai mult de o perioada de ceas. Automatul va ramane in aceasta stare atata timp cat ''in'' ramane in 1 si va reveni in starea Q0 imediat ce ''in'' revine in 0.

Graful automatului este:

[[Fișier:Organigrama FSM rising edge.png]]

'''Implementarea automatului'''
<syntaxhighlight lang="Verilog">
module FSM2_Moore(
input logic clock,
input logic in,
input logic reset,
output logic out
);

localparam Q0 = 2'b00;
localparam Q1 = 2'b01;
localparam Q2 = 2'b10;

logic [1:0] state, state_next;

always_ff @(posedge clock) begin
if(reset == 1)
state <= Q0;
else
state <= state_next;
end

always_comb begin
state_next = state;
case(state)
Q0: begin
if(in == 1) state_next = Q1;
end
Q1: begin
if(in == 0) state_next = Q0;
if(in == 1) state_next = Q2;
end
Q2: begin
if(in == 0) state_next = Q0;
end
default: state_next = Q0;
endcase
end

assign out = (state == Q1); // iesirea depinde numai de stare => Moore

endmodule
</syntaxhighlight>

<syntaxhighlight lang="Verilog">
module FSM2_mealy(
input logic clock,
input logic in,
input logic reset,
output logic out
);

localparam stare_wait_1 = 1'b0;
localparam stare_wait_0 = 1'b1;

logic state, state_next;

always_ff @(posedge clock) begin
if(reset == 1)
state <= stare_wait_1;
else
state <= state_next;
end

always_comb begin
state_next = state;
case(state)
stare_wait_1: begin
if(in == 1) state_next = stare_wait_0;
end
stare_wait_0: begin
if(in == 0) state_next = stare_wait_1;
end
default: state_next = stare_wait_1 ;
endcase
end

// daca pana acum semnalul a fost "0" si astept sa vina "1" si intrarea chiar vine "1" => am avut front crescator
assign out = (state==stare_wait_1) & (in==1); // in apare aici => dependenta iesiri de intrare => Mealy

endmodule
</syntaxhighlight>

'''Implementarea unui modul de test pentru FSM2'''
<syntaxhighlight lang="Verilog">
module FSM2_TB();

logic clock_t;
logic reset_t;
logic in_t;
logic out_t;

initial begin
clock_t = 0;
forever #1 clock_t = ~clock_t;
end

initial begin
in_t <= 0;
reset_t <= 1;
#2 reset_t <= 0;
#10 in_t <= 1;
#5 in_t <= 0;
#10 in_t <= 1;
#5 in_t <= 0;
#10 $stop();
end

FSM2_Moore DUT(
.clock(clock_t),
.reset(reset_t),
.in(in_t),
.out(out_t)
);

endmodule

</syntaxhighlight>

Se poate observa ca automatele de tip Moore au un numar mai mare de stari iar automatele de tip Mealy au o logica mai complexa pentru calcularea iesirilor.

==Exerciții==
=== Exercițiul 1 ===
Implementați un automat finit ce detectează fronturile descrescătoare. Acesta are un singur semnal de intrare ''in'', care reprezintă semnalul analizat și o singură ieșire ''out'', generând pe această un puls lung cât o perioadă de ceas la fiecare apariție a unui front descrescător pe ''in''.

Realizați implementarea SystemVerilog plecând de la graful automatului:

[[Fișier:Graf FSM falling edge.png]]

=== Exercițiul 2 ===
Implementați un automat finit ce detectează atât fronturile crescătoare, cât și pe cele descrescătoare.

=== Exercițiul 3 ===
Să se implementeze un circuit care generează un semnal PWM cu un factor de umplere ce variază triungular, la fiecare front descrescător al unui semnal de intrare.

Schema circuitului este:

[[Fișier:FSM Exercitiu.png]]

Modulele componente ale circuitului sunt:
* '''FallingEdgeDetector''': Automat ce detectează fronturile descrescătoare ale semnalului de intrare.
* '''TriangularCounter''': Automat ce generează la iesire secvența de numere 64, 128, 192, 255, 192, 128, 64.
* '''Counter''': Numărător pe 8 biți cu reset sincron.
* '''COMP''': Comparator cu două intrări pe 8 biți. Ieșirea sa va fi 1 atunci când counter < out și 0 în rest.

=== Exercițiul 4 ===
Implementați automatul de control al unui aparat care vinde ciocolata.

O cafea costa 2.5 lei. Automatul accepta monezi de 50 de bani si hartii de 1 leu. Daca se depaseste suma, restul ramane in aparat si va fi folosit la urmatoarea tranzactie. Se accepta introducerea si a unei monezi si a unei bancnote in acelasi timp.

Intrarile sistemului sunt: clock (1b), reset (1b), in_50_b (1b), in_100_b (1b); iesirile sistemului sunt: give_cioco(1b).

Implementati automatul de control care va tine minte suma curenta si va da sau nu ciocolata in functie de aceasta. Implementati acest automat in ambele variante: Mealy si Moore.

CID aplicatii 11 : Automate finite

2025-05-16T09:25:14Z

Mihai.antonescu: /* Exemplul 1: Automat ce detecteaza secvente de tipul 11....100....0 */

== Automate finite ==

Automatul finit este folosit pentru a descrie sisteme ce tranziteaza un numar finit de stari. Acest tip de sistem este foarte util atunci cand starile nu sunt tranzitate intr-un mod simplu, evident sau repetitiv.

Automatul finit, numit și FSM (Finite State Machine), este un model matematic de computație, definit de următoarele elemente:
* O mulțime finită de simboluri de intrare, numită alfabet de intrare;
* O mulțime finită și nevidă de simboluri de ieșire, numită alfabet de ieșire;
* O mulțime finită și nevidă de stări, din care doar una, numită starea curentă, este activă la un moment dat;
* O stare inițială, care face parte din mulțimea stărilor;
* O funcție de tranziție a stărilor, care calculează starea următoare a automatului în funcție de starea curentă și de simbolul de intrare;
* O funcție de calcul a ieșirii, care determină simbolul de ieșire în funcție de starea curentă (în cazul automatelor de tip Moore) sau în funcție de starea curentă și de simbolul de intrare (în cazul automatelor de tip Mealy).

[[[[Fișier:Fsm.png]]]]

La fiecare front al ceasului, valoarea stării următoare, calculată de către CLC, va fi încărcată în registru. Dacă registrul are n biți, numărul maxim de stări care pot fi reprezentate este 2n. Acest număr poate fi mai mic, în funcție de schema de codare a stărilor. De exemplu, pentru n = 4, folosind codarea binară se pot reprezenta cel mult 16 stări (0000, 0001, 0010, ..., 1111), în timp ce pentru codarea one-hot, în care doar un singur bit poate lua valoarea 1, se pot reprezenta 4 stări (1000, 0100, 0010, 0001).

Pentru a reprezenta comportamentul unui automat finit, putem folosi grafuri sau organigrame, conventiile de notare depinzand de tipul automatului (Moore sau Mealy).

== Exemple ==
=== Exemplul 1: Automat ce detecteaza secvente de tipul 11....100....0===
In acest exemplu va fi implementat un automat care detecteaza secventele de tipul 11....100....0. Pentru aceasta, automatul va avea o intrare pe un bit (''in'', pe care va veni secventa de biti) si doua iesiri: ''detectOk'', care semnalizeaza prin 1 ca nu a fost inca detectata o secventa ilegala si ''detectFail'', care semnalizeaza prin 1 ca a fost detectata o secventa ilegala (un 1 dupa 0).

Automatul va avea 3 stari:
* Q0 - STATE_READ1: automatul intra in aceasta stare la reset si va ramane in aceasta atata timp cat intrarea este 1 (inca nu a aparut niciun 0).
* Q1 - STATE_READ0: automatul intra in aceasta stare atunci cand apare pe intrare primul 0 si va ramane in aceasta atata timp cat pe intrare este 0.
* Q2 - STATE_ERROR: automatul intra in aceasta stare atunci cand apare un 1 dupa 0 si va ramane blocat aici pana la reset.

Pentru a coda cele 3 stari avem nevoie de minim 2 biti: STATE_READ1 = 2'b00, STATE_READ0 = 2'b01, STATE_ERROR = 2'b10.

Graful automatului este:

[[Fișier:Organigrama FSM 111000.png]]

'''Implementarea automatului'''
<syntaxhighlight lang="Verilog">
module FSM1(
input logic clock,
input logic in,
input logic reset,
output logic detectOk,
output logic detectFail
);

//Se asociaza sirurilor de biti folositi pentru codarea starilor nume ce pot fi folosite mai usor in cod.
//La compilare, numele vor fi inlocuite in cod cu numerele asociate la inceput.
localparam STATE_READ1 = 2'b00;
localparam STATE_READ0 = 2'b01;
localparam STATE_ERROR = 2'b10;

logic [1:0] state, state_next;

//registrul de stare
always_ff @(posedge clock) begin
if(reset == 1)
state <= STATE_READ1;
else
state <= state_next;
end

//circuit combinational pentru calculul starii urmatoare
always_comb begin
state_next = state;
case(state)
STATE_READ1: begin
if(in == 0) state_next = STATE_READ0;
end
STATE_READ0: begin
if(in == 1) state_next = STATE_ERROR;
end
STATE_ERROR: state_next = STATE_ERROR;
default: state_next = STATE_READ1;
endcase
end

//circuit combinational pentru calculul iesirilor
assign detectOk = (state == STATE_READ0) || (state == STATE_READ1);
assign detectFail = (state == STATE_ERROR);

endmodule
</syntaxhighlight>

'''Implementarea unui modul de test pentru FSM1'''
<syntaxhighlight lang="Verilog">
module FSM1_TB();

logic clock_t;
logic reset_t;
logic in_t;
logic detectOk_t;
logic detectFail_t;

initial begin
clock_t = 0;
forever #1 clock_t = ~clock_t;
end

initial begin
in_t <= 1;
reset_t <= 1;
#2 reset_t <= 0;
#10 in_t <= 0;
#10 in_t <= 1;
#10 $stop();
end

FSM1 DUT(
.clock(clock_t),
.reset(reset_t),
.in(in_t),
.detectOk(detectOk_t),
.detectFail(detectFail_t)
);

endmodule
</syntaxhighlight>

===Exemplul 2: Automat ce detecteaza fronturile crescatoare ale unui semnal===
Automatul ce detecteaza fronturile crescatoare are un singur semnal de intrare ''in'', care reprezinta semnalul analizat si o singura iesire, ''out'', generand pe aceasta un puls lung cat o perioada de ceas la fiecare aparitie a unui front crescator pe ''in''.

Vom avea nevoie de 3 stari:
* Q0: automatul intra in aceasta stare la reset si va ramane in aceasta atata timp cat intrarea este 0 (inca nu a aparut niciun front crescator).
* Q1: automatul intra in aceasta stare atunci cand apare pe intrare un front crescator. Dupa aparitia frontului crescator sunt doua posibilitati: linia ramane in 1, ceea ce duce la trecerea in starea Q2 care va duce iesirea in 0 dupa o perioada de ceas, sau linia trece in 0 dupa un ciclu de ceas, ceea ce duce la revenirea in starea Q0.
* Q2: automatul intra in aceasta stare atunci cand linia de intrare ramane in 1 mai mult de o perioada de ceas. Automatul va ramane in aceasta stare atata timp cat ''in'' ramane in 1 si va reveni in starea Q0 imediat ce ''in'' revine in 0.

Graful automatului este:

[[Fișier:Organigrama FSM rising edge.png]]

'''Implementarea automatului'''
<syntaxhighlight lang="Verilog">
module FSM2_Moore(
input logic clock,
input logic in,
input logic reset,
output logic out
);

localparam Q0 = 2'b00;
localparam Q1 = 2'b01;
localparam Q2 = 2'b10;

logic [1:0] state, state_next;

always_ff @(posedge clock) begin
if(reset == 1)
state <= Q0;
else
state <= state_next;
end

always_comb begin
state_next = state;
case(state)
Q0: begin
if(in == 1) state_next = Q1;
end
Q1: begin
if(in == 0) state_next = Q0;
if(in == 1) state_next = Q2;
end
Q2: begin
if(in == 0) state_next = Q0;
end
default: state_next = Q0;
endcase
end

assign out = (state == Q1); // iesirea depinde numai de stare => Moore

endmodule
</syntaxhighlight>

<syntaxhighlight lang="Verilog">
module FSM2_mealy(
input logic clock,
input logic in,
input logic reset,
output logic out
);

localparam stare_wait_1 = 1'b0;
localparam stare_wait_0 = 1'b1;

logic state, state_next;

always_ff @(posedge clock) begin
if(reset == 1)
state <= stare_wait_1;
else
state <= state_next;
end

always_comb begin
state_next = state;
case(state)
stare_wait_1: begin
if(in == 1) state_next = stare_wait_0;
end
stare_wait_0: begin
if(in == 0) state_next = stare_wait_1;
end
default: state_next = stare_wait_1 ;
endcase
end

// daca pana acum semnalul a fost "0" si astept sa vina "1" si intrarea chiar vine "1" => am avut front crescator
assign out = (state==stare_wait_1) & (in==1); // in apare aici => dependenta iesiri de intrare => Mealy

endmodule
</syntaxhighlight>

'''Implementarea unui modul de test pentru FSM2'''
<syntaxhighlight lang="Verilog">
module FSM2_TB();

logic clock_t;
logic reset_t;
logic in_t;
logic out_t;

initial begin
clock_t = 0;
forever #1 clock_t = ~clock_t;
end

initial begin
in_t = 0;
reset_t = 1;
#2 reset_t = 0;
#10 in_t = 1;
#5 in_t = 0;
#10 in_t = 1;
#5 in_t = 0;
#10 $stop();
end

FSM2_Moore DUT(
.clock(clock_t),
.reset(reset_t),
.in(in_t),
.out(out_t)
);

endmodule

</syntaxhighlight>

Se poate observa ca automatele de tip Moore au un numar mai mare de stari iar automatele de tip Mealy au o logica mai complexa pentru calcularea iesirilor.

==Exerciții==
=== Exercițiul 1 ===
Implementați un automat finit ce detectează fronturile descrescătoare. Acesta are un singur semnal de intrare ''in'', care reprezintă semnalul analizat și o singură ieșire ''out'', generând pe această un puls lung cât o perioadă de ceas la fiecare apariție a unui front descrescător pe ''in''.

Realizați implementarea SystemVerilog plecând de la graful automatului:

[[Fișier:Graf FSM falling edge.png]]

=== Exercițiul 2 ===
Implementați un automat finit ce detectează atât fronturile crescătoare, cât și pe cele descrescătoare.

=== Exercițiul 3 ===
Să se implementeze un circuit care generează un semnal PWM cu un factor de umplere ce variază triungular, la fiecare front descrescător al unui semnal de intrare.

Schema circuitului este:

[[Fișier:FSM Exercitiu.png]]

Modulele componente ale circuitului sunt:
* '''FallingEdgeDetector''': Automat ce detectează fronturile descrescătoare ale semnalului de intrare.
* '''TriangularCounter''': Automat ce generează la iesire secvența de numere 64, 128, 192, 255, 192, 128, 64.
* '''Counter''': Numărător pe 8 biți cu reset sincron.
* '''COMP''': Comparator cu două intrări pe 8 biți. Ieșirea sa va fi 1 atunci când counter < out și 0 în rest.

=== Exercițiul 4 ===
Implementați automatul de control al unui aparat care vinde ciocolata.

O cafea costa 2.5 lei. Automatul accepta monezi de 50 de bani si hartii de 1 leu. Daca se depaseste suma, restul ramane in aparat si va fi folosit la urmatoarea tranzactie. Se accepta introducerea si a unei monezi si a unei bancnote in acelasi timp.

Intrarile sistemului sunt: clock (1b), reset (1b), in_50_b (1b), in_100_b (1b); iesirile sistemului sunt: give_cioco(1b).

Implementati automatul de control care va tine minte suma curenta si va da sau nu ciocolata in functie de aceasta. Implementati acest automat in ambele variante: Mealy si Moore.

CID aplicatii 11 : Automate finite

2025-05-15T12:32:46Z

Mihai.antonescu: /* Exemplul 2: Automat ce detecteaza fronturile crescatoare ale unui semnal */

== Automate finite ==

Automatul finit este folosit pentru a descrie sisteme ce tranziteaza un numar finit de stari. Acest tip de sistem este foarte util atunci cand starile nu sunt tranzitate intr-un mod simplu, evident sau repetitiv.

Automatul finit, numit și FSM (Finite State Machine), este un model matematic de computație, definit de următoarele elemente:
* O mulțime finită de simboluri de intrare, numită alfabet de intrare;
* O mulțime finită și nevidă de simboluri de ieșire, numită alfabet de ieșire;
* O mulțime finită și nevidă de stări, din care doar una, numită starea curentă, este activă la un moment dat;
* O stare inițială, care face parte din mulțimea stărilor;
* O funcție de tranziție a stărilor, care calculează starea următoare a automatului în funcție de starea curentă și de simbolul de intrare;
* O funcție de calcul a ieșirii, care determină simbolul de ieșire în funcție de starea curentă (în cazul automatelor de tip Moore) sau în funcție de starea curentă și de simbolul de intrare (în cazul automatelor de tip Mealy).

[[[[Fișier:Fsm.png]]]]

La fiecare front al ceasului, valoarea stării următoare, calculată de către CLC, va fi încărcată în registru. Dacă registrul are n biți, numărul maxim de stări care pot fi reprezentate este 2n. Acest număr poate fi mai mic, în funcție de schema de codare a stărilor. De exemplu, pentru n = 4, folosind codarea binară se pot reprezenta cel mult 16 stări (0000, 0001, 0010, ..., 1111), în timp ce pentru codarea one-hot, în care doar un singur bit poate lua valoarea 1, se pot reprezenta 4 stări (1000, 0100, 0010, 0001).

Pentru a reprezenta comportamentul unui automat finit, putem folosi grafuri sau organigrame, conventiile de notare depinzand de tipul automatului (Moore sau Mealy).

== Exemple ==
=== Exemplul 1: Automat ce detecteaza secvente de tipul 11....100....0===
In acest exemplu va fi implementat un automat care detecteaza secventele de tipul 11....100....0. Pentru aceasta, automatul va avea o intrare pe un bit (''in'', pe care va veni secventa de biti) si doua iesiri: ''detectOk'', care semnalizeaza prin 1 ca nu a fost inca detectata o secventa ilegala si ''detectFail'', care semnalizeaza prin 1 ca a fost detectata o secventa ilegala (un 1 dupa 0).

Automatul va avea 3 stari:
* Q0 - STATE_READ1: automatul intra in aceasta stare la reset si va ramane in aceasta atata timp cat intrarea este 1 (inca nu a aparut niciun 0).
* Q1 - STATE_READ0: automatul intra in aceasta stare atunci cand apare pe intrare primul 0 si va ramane in aceasta atata timp cat pe intrare este 0.
* Q2 - STATE_ERROR: automatul intra in aceasta stare atunci cand apare un 1 dupa 0 si va ramane blocat aici pana la reset.

Pentru a coda cele 3 stari avem nevoie de minim 2 biti: STATE_READ1 = 2'b00, STATE_READ0 = 2'b01, STATE_ERROR = 2'b10.

Graful automatului este:

[[Fișier:Organigrama FSM 111000.png]]

'''Implementarea automatului'''
<syntaxhighlight lang="Verilog">
module FSM1(
input logic clock,
input logic in,
input logic reset,
output logic detectOk,
output logic detectFail
);

//Se asociaza sirurilor de biti folositi pentru codarea starilor nume ce pot fi folosite mai usor in cod.
//La compilare, numele vor fi inlocuite in cod cu numerele asociate la inceput.
localparam STATE_READ1 = 2'b00;
localparam STATE_READ0 = 2'b01;
localparam STATE_ERROR = 2'b10;

logic [1:0] state, state_next;

//registrul de stare
always_ff @(posedge clock) begin
if(reset == 1)
state <= STATE_READ1;
else
state <= state_next;
end

//circuit combinational pentru calculul starii urmatoare
always_comb begin
state_next = state;
case(state)
STATE_READ1: begin
if(in == 0) state_next = STATE_READ0;
end
STATE_READ0: begin
if(in == 1) state_next = STATE_ERROR;
end
STATE_ERROR: state_next = STATE_ERROR;
default: state_next = STATE_READ1;
endcase
end

//circuit combinational pentru calculul iesirilor
assign detectOk = (state == STATE_READ0) || (state == STATE_READ1);
assign detectFail = (state == STATE_ERROR);

endmodule
</syntaxhighlight>

'''Implementarea unui modul de test pentru FSM1'''
<syntaxhighlight lang="Verilog">
module FSM1_TB();

logic clock_t;
logic reset_t;
logic in_t;
logic detectOk_t;
logic detectFail_t;

initial begin
clock_t = 0;
forever #1 clock_t = ~clock_t;
end

initial begin
in_t = 1;
reset_t = 1;
#2 reset_t = 0;
#10 in_t = 0;
#10 in_t = 1;
#10 $stop();
end

FSM1 DUT(
.clock(clock_t),
.reset(reset_t),
.in(in_t),
.detectOk(detectOk_t),
.detectFail(detectFail_t)
);

endmodule
</syntaxhighlight>

===Exemplul 2: Automat ce detecteaza fronturile crescatoare ale unui semnal===
Automatul ce detecteaza fronturile crescatoare are un singur semnal de intrare ''in'', care reprezinta semnalul analizat si o singura iesire, ''out'', generand pe aceasta un puls lung cat o perioada de ceas la fiecare aparitie a unui front crescator pe ''in''.

Vom avea nevoie de 3 stari:
* Q0: automatul intra in aceasta stare la reset si va ramane in aceasta atata timp cat intrarea este 0 (inca nu a aparut niciun front crescator).
* Q1: automatul intra in aceasta stare atunci cand apare pe intrare un front crescator. Dupa aparitia frontului crescator sunt doua posibilitati: linia ramane in 1, ceea ce duce la trecerea in starea Q2 care va duce iesirea in 0 dupa o perioada de ceas, sau linia trece in 0 dupa un ciclu de ceas, ceea ce duce la revenirea in starea Q0.
* Q2: automatul intra in aceasta stare atunci cand linia de intrare ramane in 1 mai mult de o perioada de ceas. Automatul va ramane in aceasta stare atata timp cat ''in'' ramane in 1 si va reveni in starea Q0 imediat ce ''in'' revine in 0.

Graful automatului este:

[[Fișier:Organigrama FSM rising edge.png]]

'''Implementarea automatului'''
<syntaxhighlight lang="Verilog">
module FSM2_Moore(
input logic clock,
input logic in,
input logic reset,
output logic out
);

localparam Q0 = 2'b00;
localparam Q1 = 2'b01;
localparam Q2 = 2'b10;

logic [1:0] state, state_next;

always_ff @(posedge clock) begin
if(reset == 1)
state <= Q0;
else
state <= state_next;
end

always_comb begin
state_next = state;
case(state)
Q0: begin
if(in == 1) state_next = Q1;
end
Q1: begin
if(in == 0) state_next = Q0;
if(in == 1) state_next = Q2;
end
Q2: begin
if(in == 0) state_next = Q0;
end
default: state_next = Q0;
endcase
end

assign out = (state == Q1); // iesirea depinde numai de stare => Moore

endmodule
</syntaxhighlight>

<syntaxhighlight lang="Verilog">
module FSM2_mealy(
input logic clock,
input logic in,
input logic reset,
output logic out
);

localparam stare_wait_1 = 1'b0;
localparam stare_wait_0 = 1'b1;

logic state, state_next;

always_ff @(posedge clock) begin
if(reset == 1)
state <= stare_wait_1;
else
state <= state_next;
end

always_comb begin
state_next = state;
case(state)
stare_wait_1: begin
if(in == 1) state_next = stare_wait_0;
end
stare_wait_0: begin
if(in == 0) state_next = stare_wait_1;
end
default: state_next = stare_wait_1 ;
endcase
end

// daca pana acum semnalul a fost "0" si astept sa vina "1" si intrarea chiar vine "1" => am avut front crescator
assign out = (state==stare_wait_1) & (in==1); // in apare aici => dependenta iesiri de intrare => Mealy

endmodule
</syntaxhighlight>

'''Implementarea unui modul de test pentru FSM2'''
<syntaxhighlight lang="Verilog">
module FSM2_TB();

logic clock_t;
logic reset_t;
logic in_t;
logic out_t;

initial begin
clock_t = 0;
forever #1 clock_t = ~clock_t;
end

initial begin
in_t = 0;
reset_t = 1;
#2 reset_t = 0;
#10 in_t = 1;
#5 in_t = 0;
#10 in_t = 1;
#5 in_t = 0;
#10 $stop();
end

FSM2_Moore DUT(
.clock(clock_t),
.reset(reset_t),
.in(in_t),
.out(out_t)
);

endmodule

</syntaxhighlight>

Se poate observa ca automatele de tip Moore au un numar mai mare de stari iar automatele de tip Mealy au o logica mai complexa pentru calcularea iesirilor.

==Exerciții==
=== Exercițiul 1 ===
Implementați un automat finit ce detectează fronturile descrescătoare. Acesta are un singur semnal de intrare ''in'', care reprezintă semnalul analizat și o singură ieșire ''out'', generând pe această un puls lung cât o perioadă de ceas la fiecare apariție a unui front descrescător pe ''in''.

Realizați implementarea SystemVerilog plecând de la graful automatului:

[[Fișier:Graf FSM falling edge.png]]

=== Exercițiul 2 ===
Implementați un automat finit ce detectează atât fronturile crescătoare, cât și pe cele descrescătoare.

=== Exercițiul 3 ===
Să se implementeze un circuit care generează un semnal PWM cu un factor de umplere ce variază triungular, la fiecare front descrescător al unui semnal de intrare.

Schema circuitului este:

[[Fișier:FSM Exercitiu.png]]

Modulele componente ale circuitului sunt:
* '''FallingEdgeDetector''': Automat ce detectează fronturile descrescătoare ale semnalului de intrare.
* '''TriangularCounter''': Automat ce generează la iesire secvența de numere 64, 128, 192, 255, 192, 128, 64.
* '''Counter''': Numărător pe 8 biți cu reset sincron.
* '''COMP''': Comparator cu două intrări pe 8 biți. Ieșirea sa va fi 1 atunci când counter < out și 0 în rest.

=== Exercițiul 4 ===
Implementați automatul de control al unui aparat care vinde ciocolata.

O cafea costa 2.5 lei. Automatul accepta monezi de 50 de bani si hartii de 1 leu. Daca se depaseste suma, restul ramane in aparat si va fi folosit la urmatoarea tranzactie. Se accepta introducerea si a unei monezi si a unei bancnote in acelasi timp.

Intrarile sistemului sunt: clock (1b), reset (1b), in_50_b (1b), in_100_b (1b); iesirile sistemului sunt: give_cioco(1b).

Implementati automatul de control care va tine minte suma curenta si va da sau nu ciocolata in functie de aceasta. Implementati acest automat in ambele variante: Mealy si Moore.

CID aplicatii 11 : Automate finite

2025-05-12T08:29:08Z

Mihai.antonescu:

== Automate finite ==

Automatul finit este folosit pentru a descrie sisteme ce tranziteaza un numar finit de stari. Acest tip de sistem este foarte util atunci cand starile nu sunt tranzitate intr-un mod simplu, evident sau repetitiv.

Automatul finit, numit și FSM (Finite State Machine), este un model matematic de computație, definit de următoarele elemente:
* O mulțime finită de simboluri de intrare, numită alfabet de intrare;
* O mulțime finită și nevidă de simboluri de ieșire, numită alfabet de ieșire;
* O mulțime finită și nevidă de stări, din care doar una, numită starea curentă, este activă la un moment dat;
* O stare inițială, care face parte din mulțimea stărilor;
* O funcție de tranziție a stărilor, care calculează starea următoare a automatului în funcție de starea curentă și de simbolul de intrare;
* O funcție de calcul a ieșirii, care determină simbolul de ieșire în funcție de starea curentă (în cazul automatelor de tip Moore) sau în funcție de starea curentă și de simbolul de intrare (în cazul automatelor de tip Mealy).

[[[[Fișier:Fsm.png]]]]

La fiecare front al ceasului, valoarea stării următoare, calculată de către CLC, va fi încărcată în registru. Dacă registrul are n biți, numărul maxim de stări care pot fi reprezentate este 2n. Acest număr poate fi mai mic, în funcție de schema de codare a stărilor. De exemplu, pentru n = 4, folosind codarea binară se pot reprezenta cel mult 16 stări (0000, 0001, 0010, ..., 1111), în timp ce pentru codarea one-hot, în care doar un singur bit poate lua valoarea 1, se pot reprezenta 4 stări (1000, 0100, 0010, 0001).

Pentru a reprezenta comportamentul unui automat finit, putem folosi grafuri sau organigrame, conventiile de notare depinzand de tipul automatului (Moore sau Mealy).

== Exemple ==
=== Exemplul 1: Automat ce detecteaza secvente de tipul 11....100....0===
In acest exemplu va fi implementat un automat care detecteaza secventele de tipul 11....100....0. Pentru aceasta, automatul va avea o intrare pe un bit (''in'', pe care va veni secventa de biti) si doua iesiri: ''detectOk'', care semnalizeaza prin 1 ca nu a fost inca detectata o secventa ilegala si ''detectFail'', care semnalizeaza prin 1 ca a fost detectata o secventa ilegala (un 1 dupa 0).

Automatul va avea 3 stari:
* Q0 - STATE_READ1: automatul intra in aceasta stare la reset si va ramane in aceasta atata timp cat intrarea este 1 (inca nu a aparut niciun 0).
* Q1 - STATE_READ0: automatul intra in aceasta stare atunci cand apare pe intrare primul 0 si va ramane in aceasta atata timp cat pe intrare este 0.
* Q2 - STATE_ERROR: automatul intra in aceasta stare atunci cand apare un 1 dupa 0 si va ramane blocat aici pana la reset.

Pentru a coda cele 3 stari avem nevoie de minim 2 biti: STATE_READ1 = 2'b00, STATE_READ0 = 2'b01, STATE_ERROR = 2'b10.

Graful automatului este:

[[Fișier:Organigrama FSM 111000.png]]

'''Implementarea automatului'''
<syntaxhighlight lang="Verilog">
module FSM1(
input logic clock,
input logic in,
input logic reset,
output logic detectOk,
output logic detectFail
);

//Se asociaza sirurilor de biti folositi pentru codarea starilor nume ce pot fi folosite mai usor in cod.
//La compilare, numele vor fi inlocuite in cod cu numerele asociate la inceput.
localparam STATE_READ1 = 2'b00;
localparam STATE_READ0 = 2'b01;
localparam STATE_ERROR = 2'b10;

logic [1:0] state, state_next;

//registrul de stare
always_ff @(posedge clock) begin
if(reset == 1)
state <= STATE_READ1;
else
state <= state_next;
end

//circuit combinational pentru calculul starii urmatoare
always_comb begin
state_next = state;
case(state)
STATE_READ1: begin
if(in == 0) state_next = STATE_READ0;
end
STATE_READ0: begin
if(in == 1) state_next = STATE_ERROR;
end
STATE_ERROR: state_next = STATE_ERROR;
default: state_next = STATE_READ1;
endcase
end

//circuit combinational pentru calculul iesirilor
assign detectOk = (state == STATE_READ0) || (state == STATE_READ1);
assign detectFail = (state == STATE_ERROR);

endmodule
</syntaxhighlight>

'''Implementarea unui modul de test pentru FSM1'''
<syntaxhighlight lang="Verilog">
module FSM1_TB();

logic clock_t;
logic reset_t;
logic in_t;
logic detectOk_t;
logic detectFail_t;

initial begin
clock_t = 0;
forever #1 clock_t = ~clock_t;
end

initial begin
in_t = 1;
reset_t = 1;
#2 reset_t = 0;
#10 in_t = 0;
#10 in_t = 1;
#10 $stop();
end

FSM1 DUT(
.clock(clock_t),
.reset(reset_t),
.in(in_t),
.detectOk(detectOk_t),
.detectFail(detectFail_t)
);

endmodule
</syntaxhighlight>

===Exemplul 2: Automat ce detecteaza fronturile crescatoare ale unui semnal===
Automatul ce detecteaza fronturile crescatoare are un singur semnal de intrare ''in'', care reprezinta semnalul analizat si o singura iesire, ''out'', generand pe aceasta un puls lung cat o perioada de ceas la fiecare aparitie a unui front crescator pe ''in''.

Vom avea nevoie de 3 stari:
* Q0: automatul intra in aceasta stare la reset si va ramane in aceasta atata timp cat intrarea este 0 (inca nu a aparut niciun front crescator).
* Q1: automatul intra in aceasta stare atunci cand apare pe intrare un front crescator. Dupa aparitia frontului crescator sunt doua posibilitati: linia ramane in 1, ceea ce duce la trecerea in starea Q2 care va duce iesirea in 0 dupa o perioada de ceas, sau linia trece in 0 dupa un ciclu de ceas, ceea ce duce la revenirea in starea Q0.
* Q2: automatul intra in aceasta stare atunci cand linia de intrare ramane in 1 mai mult de o perioada de ceas. Automatul va ramane in aceasta stare atata timp cat ''in'' ramane in 1 si va reveni in starea Q0 imediat ce ''in'' revine in 0.

Graful automatului este:

[[Fișier:Organigrama FSM rising edge.png]]

'''Implementarea automatului'''
<syntaxhighlight lang="Verilog">
module FSM2_Moore(
input logic clock,
input logic in,
input logic reset,
output logic out
);

localparam Q0 = 2'b00;
localparam Q1 = 2'b01;
localparam Q2 = 2'b10;

logic [1:0] state, state_next;

always_ff @(posedge clock) begin
if(reset == 1)
state <= Q0;
else
state <= state_next;
end

always_comb begin
state_next = state;
case(state)
Q0: begin
if(in == 1) state_next = Q1;
end
Q1: begin
if(in == 0) state_next = Q0;
if(in == 1) state_next = Q2;
end
Q2: begin
if(in == 0) state_next = Q0;
end
default: state_next = Q0;
endcase
end

assign out = (state == Q1); // iesirea depinde numai de stare => Moore

endmodule
</syntaxhighlight>

<syntaxhighlight lang="Verilog">
module FSM2_mealy(
input logic clock,
input logic in,
input logic reset,
output logic out
);

localparam stare_wait_1 = 1'b0;
localparam stare_wait_0 = 1'b1;

logic state, state_next;

always_ff @(posedge clock) begin
if(reset == 1)
state <= stare_wait_1;
else
state <= state_next;
end

always_comb begin
state_next = state;
case(state)
stare_wait_1: begin
if(in == 1) state_next = stare_wait_0;
end
stare_wait_0: begin
if(in == 0) state_next = stare_wait_1;
end
default: state_next = Q0;
endcase
end

// daca pana acum semnalul a fost "0" si astept sa vina "1" si intrarea chiar vine "1" => am avut front crescator
assign out = (state==stare_wait_1) & (in==1); // in apare aici => dependenta iesiri de intrare => Mealy

endmodule
</syntaxhighlight>

'''Implementarea unui modul de test pentru FSM2'''
<syntaxhighlight lang="Verilog">
module FSM2_TB();

logic clock_t;
logic reset_t;
logic in_t;
logic out_t;

initial begin
clock_t = 0;
forever #1 clock_t = ~clock_t;
end

initial begin
in_t = 0;
reset_t = 1;
#2 reset_t = 0;
#10 in_t = 1;
#5 in_t = 0;
#10 in_t = 1;
#5 in_t = 0;
#10 $stop();
end

FSM2_Moore DUT(
.clock(clock_t),
.reset(reset_t),
.in(in_t),
.out(out_t)
);

endmodule

</syntaxhighlight>

Se poate observa ca automatele de tip Moore au un numar mai mare de stari iar automatele de tip Mealy au o logica mai complexa pentru calcularea iesirilor.

==Exerciții==
=== Exercițiul 1 ===
Implementați un automat finit ce detectează fronturile descrescătoare. Acesta are un singur semnal de intrare ''in'', care reprezintă semnalul analizat și o singură ieșire ''out'', generând pe această un puls lung cât o perioadă de ceas la fiecare apariție a unui front descrescător pe ''in''.

Realizați implementarea SystemVerilog plecând de la graful automatului:

[[Fișier:Graf FSM falling edge.png]]

=== Exercițiul 2 ===
Implementați un automat finit ce detectează atât fronturile crescătoare, cât și pe cele descrescătoare.

=== Exercițiul 3 ===
Să se implementeze un circuit care generează un semnal PWM cu un factor de umplere ce variază triungular, la fiecare front descrescător al unui semnal de intrare.

Schema circuitului este:

[[Fișier:FSM Exercitiu.png]]

Modulele componente ale circuitului sunt:
* '''FallingEdgeDetector''': Automat ce detectează fronturile descrescătoare ale semnalului de intrare.
* '''TriangularCounter''': Automat ce generează la iesire secvența de numere 64, 128, 192, 255, 192, 128, 64.
* '''Counter''': Numărător pe 8 biți cu reset sincron.
* '''COMP''': Comparator cu două intrări pe 8 biți. Ieșirea sa va fi 1 atunci când counter < out și 0 în rest.

=== Exercițiul 4 ===
Implementați automatul de control al unui aparat care vinde ciocolata.

O cafea costa 2.5 lei. Automatul accepta monezi de 50 de bani si hartii de 1 leu. Daca se depaseste suma, restul ramane in aparat si va fi folosit la urmatoarea tranzactie. Se accepta introducerea si a unei monezi si a unei bancnote in acelasi timp.

Intrarile sistemului sunt: clock (1b), reset (1b), in_50_b (1b), in_100_b (1b); iesirile sistemului sunt: give_cioco(1b).

Implementati automatul de control care va tine minte suma curenta si va da sau nu ciocolata in functie de aceasta. Implementati acest automat in ambele variante: Mealy si Moore.

CID aplicatii 5 : Exercitii cu circuite combinationale

2025-03-20T20:07:59Z

Mihai.antonescu:

==Teorie==

Acest laborator are rolul de a sedimenta cunostiintele dobandite anterior.

El consta in exercitii separate, unele date ca subiect la lucrarea 1 in anii anteriori si cateva notiuni de teorie si sintaxa ajutatoare.

==Teorie: Parametrizare==
Parametrizarea este un mod de a generaliza codul scris pentru a nu fi nevoie sa scrii acelasi modul de mai multe ori doar pentru ca circuitul isi schimba o dimensiune.

Pentru a intelege mai clar avantajele si sintaxa urmariti urmatorul exemplu:

Fisierul sumator.sv:
<syntaxhighlight lang="Verilog">
module sumator # // <= diez deoarece urmeaza lista cu paramteri
( // parametri
parameter data_size = 4 // valoare default 4
// alti parametri aici daca este nevoie, separati prin virgula
)
( // interfata
input logic [data_size-1:0] in0, // si pot folosii parametrul "data_size" pentru dimensiunea bus-ului
input logic [data_size-1:0] in1,
output logic [data_size-1:0] out0
);

assign out0 = in0 + in1;

endmodule
</syntaxhighlight>

Cand se instantiaza un modul parametrizat, se specifica valorile parametrilor astfel:
<syntaxhighlight lang="Verilog">
sumator # ( // parametri
.data_size(8) // se genereaza un sumator pe 8b
)
nume_instanta_0
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out0)
);

sumator # ( // parametri
.data_size(32) // se genereaza un sumator pe 32b
)
nume_instanta_1
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out1)
);

sumator nume_instanta_2 // se genereaza un sumator de dimensiune default, aici 4, asa cum e scris in modulul "sumator"
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out2)
);
</syntaxhighlight>

Puteti folosi parametrizarea in exercitiul 3 de mai jos. Acolo sunt 2 tipuri de multiplexoare, unul cu intrarile pe 1 bit si unul cu intrarile pe 2 biti. Poate fi scris un singur modul parametrizat care sa acopere ambele situatii.

==Teorie: Concatenarea==

Pentru o mai usoara conectare a firelor sau pentru o mai buna organizare si expresivitate a codului, de multe ori este util ca fire individuale sa fie grupate impreuna sau ca un bus de mai multi biti sa fie separat in fire individuale. Acest lucru se face folosind concatenarea, prin simbolurile "{ }".

Un exemplu de folosire a concatenarii este oferit mai jos.
Un sumator pe 8b are rezultatul pe maxim 9b, in cazul in care ambele numere sunt mari. Astfel apare un bit de carry out.
<syntaxhighlight lang="Verilog">
module sumator (
input logic [7:0] in0,
input logic [7:0] in1,
output logic [7:0] out0,
output logic carry_out
);

assign {carry_out,out0} = in0 + in1; // fac suma intre in0 si in1 iar rezultatul il pun pe cei 9b alcatuiti din: 1b carry_out si 8b out0, in ordinea asta

endmodule
</syntaxhighlight>
Se pot concatena oricat de multe semnale, puse in "{ }" si separate prin virgula. Atentie la dimensiunile firelor care se concateneaza.

Se poate de asemenea face concatenare si la dreapta egalului, astfel:
<syntaxhighlight lang="Verilog">
assign fir_pe_10_b = {fir_pe_3b,fir_pe_5b,fir_pe_1b,fir_pe_1b};
</syntaxhighlight>
In exemplul anterior ultimi 2b ai "fir_pe_10_b" vor avea mereu aceeasi valoare, provenind din acelasi fir. Sintaxa SystemVerilog permite asta.

Puteti folosii concatenarea, in exercitiul 2, la flag-ul de overflow.

==Teorie: Constante ca intrari in circuite==
In cazul in care se doreste scrierea unor constante la intrarea unor module, acestea se pun direct intre paranteze la instantiere.
De exemplu, pentru multiplexorul de jos din subiectul "alu structural", intrarea "in3" este conectata la valoarea "1". Sintaxa pentru aceasta este: ".in3(1),".

==Teorie: "_"==
Simbolul "_" (underscore) este ignorat de SystemVerilog si ajuta vizual la citirea semnalelor pe mai multi biti. De exemplu 16'b1010010111110000 este identic cu 16'b1010_0101_1111_0000, al doilea fiind totusi mai usor de citit.

==Exercitii==

===Exercitiul 0: Repararea erorilor===
Arhiva de mai jos contine mai multe proiecte in Vivado, fiecare avand cate o eroare de sintaxa sau de logica. In vederea aprofundari cunostiintelor voastre (si pentru lucrarea de saptamana urmatoare), incercati sa le parcurgeti si sa rezolvati toate problemele.
Pe langa proiecte in sine, in arhiva se afla si un fisier text cu o introducere, rezolvarile si explicatiile pentru fiecare situatie.

[https://drive.google.com/file/d/1cNTpQC54_JEeSk8SxgHTEdGtobCn_-EI/view?usp=drive_link Arhiva_proiecte_cu_erori.zip]

===Exercitiul 1: ALU - descriere comportamentala===
Descrieți comportamental o unitate aritmetico-logică (ALU) care are la intrare 2 numere binare de câte 8 biți și poate calcula următoarele funcții:
:- suma celor două numere
:- diferența celor două numere
:- operații logice bit cu bit (bitwise): SI, SAU, XOR și inversele lor
:- operandul din stanga trece neschimbat
:- operandul din dreapta trece neschimbat
:- numărul din stânga este deplasat la stânga cu nr. de poziții indicat de numărul din dreapta
:- numărul din stânga este deplasat la dreapta cu nr. de poziții indicat de numărul din dreapta

Funcția executată la un anumit moment este determinată de configurația binară de pe intrarea de comandă (function).

ALU are de asemenea intrare de carry și ieșire de carry, plus alte două ieșiri - indicatori - pentru cazurile când rezultatul este zero și când cei doi operanzi sunt egali.

Intrarea de control va fi facuta pe 4 biti ca sa permita existenta a 16 operatii posibile. Fiecare numar de pe intrarea de control (combinatie de 0 si 1) va reprezenta o operatie din cele de mai sus. Scrierea se va face folosind un bloc "case" in functie de aceasta intrare.

===Exercitiul 2: ALU - descriere structurala===

[https://wiki.dcae.pub.ro/images/8/8f/Subiect_big_alu.pdf subiect_alu.pdf]

Daca se doreste selectarea doar a anumitor biti dintr-un bus (cum se vrea din instruction) acest lucru se poate face in 2 feluri:

a) cu fir aditional:
:''wire [1:0] fir_aditional1;''
:''assign fir_aditional1 = instruction[11:10];''
:// apoi la instantiere: ''.sel(fir_aditional1),''

b) direct in instantiere;
:la instantierea celor 2 mux4 din stanga, direct:
::''.sel(instruction[11:10]),''

Pentru a scrie mai putin (a nu face toate modulele de calcul separat + instantierea lor) si pentru ca e vorba de operatii simple, se poate pune operatia cu assign direct in top pe un fir declarat acolo, sau si mai prescurtat, direct operatia dorita cand se intantiaza modulul in care aceasta intra. De exemplu, pentru operatia de shift la dreapta care intra in primul multiplexor, se poate pune: ".in0(data0 >> data1),".

===Exercitiul 3:===

[https://wiki.dcae.pub.ro/images/3/3a/Subiect_muxes.pdf subiect_muxes.pdf]

===Exercitiul 4:===

[https://wiki.dcae.pub.ro/images/2/2e/Subiect_rom_luts.pdf rom_luts.pdf]

===Exercitiul 5: Sumator cu reprezentare in cifre zecimale===
Proiectati si verificati un sumator zecimal pentru numere cu 2 cifre

Modulul de top (Figura 1) este alcatuit din 2 blocuri de tip '''digitsum'''. Fiecare bloc aduna cifrele de pe aceasi pozitie.

'''Figura 1'''
Top level

[[Fișier: bcdsum.png]]

Blocul '''digitsum''' (Figura 2) este alctuit din 4 blocuri, 2 sumatoare binare pe 4 biti (de tip '''sum4'''), o instanta de '''cmp''' si un multiplexor elementar mux2

'''Figura 2'''
Blocul DIGIT SUM

[[Fișier: digit.png]]

Primul sumator aduna cifrele din domeniul [0...9] avand un rezultat intre [0 ... 18]

Comparatorul are la iesire 1 daca rezultatul este mai mare decat 9.

Daca rezultatul este mai mic decat 9, acesta este trimis in mod direct la iesirea '''digit''' a blocului '''digitsum'''.

Daca rezultatul este mai mare decat 9, o crectie este necesara si se aduna 6 la rezultat.

Comparatorul cu valoarea 9 este descris structural din porti in figura de mai jos:

'''Figure 3'''
the comparator

[[Fișier: cmp.png]]

Testbench-ul va genera stimuli pentru '''bcdsum''' ca in Figura 4.

Intrarea b0 a '''bcdsum''' se schimba la fiecare 5 pasi de simulare .

b1, a0 si a1 se schimba sincron cu b0 ca in Figura 4.

'''Figure 4'''

[[Fișier: teststimuli.png]]

Cerinte:
# '''cmp'''- descris structural la nivel de porti ca in Figura 3.
# '''sum4''' descris comportamental cu un assign continuu.
# '''mux''' descris comportamental cu always.
# '''digitsum''' descris strctural ca in Figura 2.
# modulul de top numit '''bcdsum''', descris structural ca in Figure 1.
# modulul de testbench, '''bcdsum_tb''', instantiaza '''bcdsum''' cu numele '''dut'''.
# in testbench, generati stimuli pentru intrarile circuitului testat.

===Exercitiul 6:===

[https://wiki.dcae.pub.ro/images/9/92/Cid_L1_codor_Cezar.pdf Codor_Cezar.pdf]

Fișier:Cid L1 codor Cezar.pdf

2025-03-20T20:06:48Z

Mihai.antonescu:

CID aplicatii 2 : Instantiere si porti logice

2025-03-13T11:26:43Z

Mihai.antonescu: /* Exemplul 2: NAND2 din AND2 si NOT */

==Teorie: incapsulare si instantiere==
Unitatile constructive de baza din care se formeaza circuitele digitale se numesc porti logice. Acestea implementeaza functii logice si prin conectarea mai multor astfel de circuite simple complexitatea unui circuit poate creste pana la nivelul procesoarelor actuale. Pentru a putea controla cresterea complexitatii in proiectarea unui circuit de dimensiuni mari se folosesc 2 concepte cheie:

1) incapsularea functiei dorite intr-un modul

2) instantierea unor module mai mici si asamblarea acestora pentru a forma un modul mai mare.

Incapsularea se refera la a grupa elementele ce alcatuiesc o anumita functionalitate intr-un modul. Aceste elemente pot la randul lor sa fie alte module.
Instantierea (asemanator cu POO) se refera la a apela un modul deja scris pentru a fi folosit efectiv in circuitul curent.
Pentru a face o analogie cu programarea, cand se declara o variabila (sau un obiect), tipul variabilei este echivalent cu modulul si numele ei este numele instantei.

Pentru a intelege aceste concepte se da circuitul de mai jos:

[[Fișier:schema_principiu_instantiere.png ‎| 800px]]

'''Observatii:'''

1) Notatie aici: Numele modulului este scris in interior.

2) Notatie aici: Numele instantei este scris deasupra.

3) Idee fundamentala: prin instantierea si incapsularea unor circuite simple, mici, apar circuite mai complexe.

4) Idei esentiale (daca vreuna e neclara consultati cadrul didactic):

:a) "modul_2" este instantiat o singura data in tot proiecul, iar instanta se cheama "x"

:b) "modul_2" are o intrare numita "in0" si o iesire numita "out0"

:c) "modul_2" este instantiat in cadrul "modul_6"

:d) Modulul cel mai mare, ce cuprinde toata functionalitatea dorita a sistemului (aici "modul_6") se numeste uzual top.

:e) Instanta top-ului care apare atunci cand se doreste testarea sa in simulare intr-un testbench (tb) se numeste uzual DUT (design under test)

:f) "modul_0" apare instantiat de 3 ori. Circuitul final, cuprinde 3 subcircuite de tip "modul_0".

:g) La nivel de top, instanta sa se cheama "b".

:h) La nivel de "modul_5", cele 2 instante se cheama "a" si "c".

:i) "a" si "c" sunt 2 circuite fizice diferite chiar daca ambele sunt de tipul "modul_0". Fiind instante ale aceluiasi modul, deci identice in alcatuire, luate separat ele fac acelasi lucru. Luate in contextul lui "modul_5", "a" genereaza datele de pe firul "w0" si "c" genereaza datele pentru iesire.

:j) circuitul "b" de tip "modul_1" (instantiat in "modul_5") este complet diferit de circuitul "b" de tip "modul_0" (instantiat in top). Este permis ca ele sa aiba acelasi nume (cele 2 instante) deoarece se afla in locatii diferite.

:k) Identic, mai multe module au o intrare numita "in_0". La sinteza circuitului nu se face confuzie intre acestea deoarece fiecare e vazut la nivelul altei instante.

:l) Identic, firele de legatura "w0", "w1".

:m) La nivelul "top", firul de legatura "w2" leaga iesirea "out_0" a instantei "b" la intrarea "in2" a instantei "y".

:n) La nivelul "top", firul de legatura "w1" leaga iesirea "out_0" a instantei "x" la intrarea "in1" a instantei "y".

:o) La nivelul "modul_5", firul de legatura "w1" leaga iesirea instantei "b" la intrarea instantei "c".

:Pentru claritatea desenului, respectivele intrari si iesiri nu au fost denumite. In cod este obligatoriu ca ele sa fie definite si denumite.

:p) La nivelul "top", "in0","in1","in2","in3","in4" si "out0" formeaza interfata modulului (semnalele care intra sau ies din modul).

:q) La nivelul "top", "w0", "w1", "w2" sunt fire interne de legatura.

:r) La nivelul "top", firul "in3" este conectat ca intrare pentru 3 submodule.

==Teorie: testarea circuitelor==
Pentru a se testa functionarea corecta a circuitului final, acesta este instantiat intr-un modul numit "test_bench" sau "tb". Acest modul este folosit strict in simulare.
Testarea unui circuit are loc conform schemei urmatoare:

[[Fișier:schema_principiu_tb.png ‎| 600px]]

Generarea datelor de intrare se va face asemanator cu laboratorul 1.

Voi veti avea rolul modelului ideal si al comparatorului datelor de iesire, uitandu-va la datele de intrare veti calcula iesirea corecta si apoi veti compara aceasta valoare cu raspunsul circuitului ce se testeaza.

In cazul unui sistem automat, se genereaza mesaje de eroare sau mesaje ca functionarea este in regula.

Observatie: proiectarea si verificarea sunt 2 domenii diferite, firmele avand departamente separate pentru acestea.

Proiectarea/Design se ocupa cu scrierea in Verilog/SystemVerilog a modului de top si toate modulele ce se afla in acesta, avand ca scop final realizarea fizica pe placa a unui circuit.

Verificarea se ocupa de scrierea in SystemVerilog (limbaj format din Verilog cu concepte de POO) a modului de testbench si generarea de stimuli si scenarii care sa testeze functionarea design-ului.

==Teorie: porti logice==
Portile logice folosite uzual, impreuna cu tabelele lor de adevar si reprezentarea grafica sunt date mai jos.

Se folosesc porti logice cu 1 sau 2 intrari, cele cu mai mult de 2 intrari fiind construite din acestea.

{| class="wikitable"
! Tip !! Simbol !! Tabel de adevăr !! Tip !! Simbol !! Tabel de adevăr
|-
| '''Buffer/Repetor'''
| [[Image:Buffer_gate.png|Buffer symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || A
|- bgcolor="#ddffdd" align="center"
|0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1
|}
| '''NOT'''
| [[Image:not.png|NOT symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || NOT A
|- bgcolor="#ddffdd" align="center"
|0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0
|}
|-
| '''AND'''
| [[Image:and.png|AND symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A AND B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 1
|}
| '''NAND'''
| [[Image:nand.png|NAND symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A NAND B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 0
|}
|-
| '''OR'''
| [[Image:or.png|OR symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A OR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 1
|}
| '''NOR'''
| [[Image:nor.png|NOR symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A NOR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 0
|}
|-
| '''XOR'''
| [[Image:xor.png|XOR symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A XOR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 0
|}
| '''XNOR'''
| [[Image:xnor.png|XNOR symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A XNOR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 1
|}
|}

==Despre FPGA==
FPGA-ul (Field-Programmable Gate Array) este un circuit programabil, capabil sa implementeze circuite definit de utilizator. El este format dintr-o matrice de blocuri programabile, interconectate intre ele printr-o serie de conexiuni la randul lor programabile.

Cand se doreste implementarea unui circuit pe FPGA, acesta urmeaza urmatoarele etape:

:'''Elaborarea''' este procesul prin care codul SystemVerilog este transformat intr-un circuit la nivel de porti si registre (netlist) si este independent de modelul de FPGA folosit.

:'''Sinteza''' este procesul în care se realizează transformarea circuitului descris într-un netlist dependent de tehnologie. Se vor folosi la acest pas primitivele disponibile pe FPGA.

:'''Implementarea''' este procesul în care se preia netlist-ul ce conține primitivele FPGA și modul lor de interconectare realizat la pasul de sinteză și se realizează maparea lor efectivă în FPGA (place and route).

:'''Generarea Bitstream-ului''' este procesul prin care informatiile din implementare sunt asamblate intr-un singur fisier.

:'''Programarea''' este procesul prin care fisierul generat anterior este trimis efectiv catre placa cu FPGA (prin USB) unde determina modificarea valorilor si conexiunilor interne din aceasta.

O introducere mai detaliata poate fi gasita aici : [[FPGA - Introducere]].

[[Fișier:Fpgaimg.PNG|600px]]

'''Observatii:'''
* Pentru a putea controla circuitul propus si a putea vedea rezultatele, intrarile si iesirile (input si output din module) in/din acesta trebuie conectate la pini fizici ai FPGA-ului care sunt conectati la butoane/switch-uri/leduri.
* Conexiunile dintre butoane/switch-uri si pinii FPGA sunt fixe. La fel si cele intre pinii FPGA si LED-uri. (in functie de PCB)
* Conexiunile dintre porturile modulului ''Module'' si pinii FPGA sunt configurabile. (in functie de noi, prin fisierul XDC)
* Legarea porturilor modulului ''Module'' la pinii fizici ai FPGA se realizeaza prin configurarea conexiunilor din FPGA conform contrangerilor de I/O pe care le vom mentiona in proiect, inainte de sinteza.

==Exemple==

===Exemplul 1: Analiza circuitelor cu porti===
Fie urmatorul circuit alcatuit din porti logice:
[[Fișier:Mux2_schema_interna_2.png ‎| 400px]]

Se doreste exprimarea circuitului de mai sus ca formula de tip: iesire = f(intrari).

Pentru asta, abordarea consta in a porni de la iesire si a merge pas cu pas catre intrari, asa cum este exemplificat mai jos. Se vor folosi simbolurile "~" pentru NOT, "&" pentru AND, "|" pentru OR.
:pas1: out0 = ?
:pas2: out0 = w1 | w2
:pas3: out0 = w1 | ( ? )
:pas4: out0 = w1 | ( sel & in1 )
:pas5: out0 = ( ? ) | ( sel & in1 )
:pas6: out0 = ( in0 & w0 ) | ( sel & in1 )
:pas7: out0 = ( in0 & ( ? ) ) | ( sel & in1 )
:pas8: out0 = ( in0 & (~sel) ) | ( sel & in1 )

===Exemplul 2: NAND2 din AND2 si NOT===
In urmatorul exemplu se implementeaza o poarta NAND din o poarta AND si o poarta NOT.

Codul de mai jos exemplifica ideea de instantiere si contine comentarii legate de sintaxa SystemVerilog necesara.

In mod uzual fisierele sunt denumite dupa modulul ce se afla in ele, in fiecare fisier fiind un singur modul.

Schema circuitul care se doreste a fi creat este:

[[Fișier:schema_exemplu_rezolvat.png ‎| 600px]]

'''Descrierea portii NOT (fisierul not_gate.sv):'''
<syntaxhighlight lang="Verilog">
// comentarii cu "//" sau cu /* .... */ ;
/*
ca in c/c++
*/

module not_gate // cuvant cheie "module" apoi numele modulului (asemanator clase din c++)
( // intre paranteze se pune interfata (firele care intra sau ies din modul)
input logic in0, // in0 este o intrare => input
output logic out0 // out0 este o iesire => output
); // aici ";" sa nu il uitati

assign out0 = ~in0; // cuvant cheie assign;
// semnalele pot lua valoare prin assign
// ~ e semnul pentru negatie pe biti (ca in c/c++)

endmodule // cuvant cheie "endmodule". orice module se inchide cu endmodule.
</syntaxhighlight>

'''Descrierea portii AND (fisierul and_gate.sv):'''
<syntaxhighlight lang="Verilog">
module and_gate
(
input logic in0, // aici sunt 2 intrari
input logic in1,
output logic out0
); // nu conteaza ordinea in care sunt puse intrarile si iesirile.
// uzual si pentru usurinta se ordoneaza si grupeaza dupa functionalitate
// in cazul de mai sus, am pus intai intrarile, apoi iesirile.

assign out0 = in0 & in1; // operatia propriu zisa

endmodule
</syntaxhighlight>

'''Descrierea modulului top (fisierul top.sv):'''
<syntaxhighlight lang="Verilog">

module top
(
input logic a,
input logic b,
output logic c
);

logic w0; //declarat un fir intern de legatura

and_gate and_gate_0 // instantiere: nume_modul nume_instanta (asemanator int x din c/c++)
(
.in0(a), // la intrarea "in0" a instantei "and_gate_0" se conecteaza firul "a" din top
.in1(b), // grija ca "in0", "in1", "out0" sa existe in declararea modulului "and_gate"
.out0(w0) // grija ca "a", "b", "w0" sa existe la nivelul modulului in care se face instantierea
);

not_gate not_gate_0
(
.in0(w0), // "w0" care iese din "and_gate_0" intra in "not_gate_0"
.out0(c) // "c" care iese din "not_gate_0" iese din modulul "top" (e iesire in interfata de sus)
); // se poate scrie si ".in0(w0),.out0(c)" dar se prefera fiecare fir pe randul sau (lizibilitate si loc de comentarii pt design-uri complexe)
// Observatie: la varianta de mai sus de instantiere, nu conteaza ordinea firelor.

/*
not_gate not_gate_0
( // se poate instantia si in forma prescurtata ca aici
w0, // in acest caz se pun conexiunile in ordinea in care sunt declarate intrarile si iesirile din modul
c // NU se recomanda stilul asta de instantiere
); // apar greseli frecvent la ordinea firelor si la numarul lor,
*/ // mai ales daca modulul e complex si are multe intrari si intrari

endmodule
</syntaxhighlight>

Echivalent se pot folosi si "primitive" SystemVerilog pentru scrierea top-ului.

Primitivele sunt circuite care exista deja in limbaj, folosite atunci cand se doreste o descriere structurala a circuitului.

In instantiere acestora, iesirea se pune prima, urmata de intrari.

'''Observatie:''' daca se doreste scrierea acestor porti de catre voi (ca mai sus), numele modulului nu trebuie sa fie un cuvant cheie ocupat de primitive.

'''Descrierea alternativa a modulului top (fisierul top_v2.sv):'''
<syntaxhighlight lang="Verilog">
module top_v2
(
input logic a,
input logic b,
output logic c
);

logic w0;

and and_gate_0(w0,a,b); // primitiva pentru poarta and
not not_gate_0(c,w0); // primitiva pentru poarta not

endmodule
</syntaxhighlight>

Fiind un modul simplu, intreaga functionalitate putea fi scrisa la nivel de "top" si simplificat ca mai jos.

'''Descrierea alternativa a modulului top (fisierul top_v3.sv):'''
<syntaxhighlight lang="Verilog">
module top_v3
(
input logic a,
input logic b,
output logic c
);

assign c = ~ (a & b); // a si b, negate

endmodule
</syntaxhighlight>

Testarea circuitul se face printr-un testbench, acesta fiind:

'''Descrierea testbench-ului (fisierul top_tb.sv):'''
<syntaxhighlight lang="Verilog">
`timescale 1ns / 1ps

module top_tb(); // din/in tb nu intra si iese nimic. niciodata.

logic a_tb;
logic b_tb;
logic c_tb;

top dut // instantierea modulului de tip "top" sub numele "dut"
(
.a(a_tb),
.b(b_tb),
.c(c_tb)
);

initial
begin // in loc de { ... } din c/c++, in SystemVerilog se pune begin ... end
#10; // dupa 10 unitati de timp
a_tb = 0; // a_tb ia valoarea 0
b_tb = 0;
#10; // dupa inca 10 unitati de timp, deci in total la 20
a_tb = 1;
b_tb = 0;
#10;
a_tb = 0;
b_tb = 1;
#10;
a_tb = 1;
b_tb = 1;
#10;
a_tb = 0;
b_tb = 0;

#20 $stop(); // oprirea simularii
end //end pentru initial

endmodule
</syntaxhighlight>

Formele de unda rezultate din simulare se pot vedea mai jos:

[[Fișier:exemplu_rezolvat_nand_forme_de_unda.png ‎| 800px]]

In chenarul verde se pot observa instantele din simulare.

Daca se doreste adaugarea de semnale noi pentru a fi vazute, se selecteaza modulul instantiat in care acestea se afla (chenar verde).

Apoi, din chenarul rosu se aleg semnalele si se adauga prin click dreapta->add to wave window.

Pentru o mai usoara vizualizare, semnalele se pot grupa asa cum se vede in chenarul mov prin click dreapta->new group.

Se observa o functionare corecta circuitului, acesta fiind o poarta NAND. El scoate "0" cand ambele semnale de intrare sunt "1" si scoate "1" in rest.

'''Implementarea circuitului pe FPGA'''

Dupa ce circuitul a fost testat in simulare, se doreste punerea sa fizica pe placa FPGA. Pentru aceasta, se tine cont de urmatoarele.

* Pentru a controla intrarile ''a'' si ''b'' ale circuitului '''top'', va trebui sa le conectam prin intermediul conexiunilor configurabile ale FPGA-ului la pini ce sunt mai departe conectati fizic la dispozitive ce pot controla valorile semnalelor (switch-uri, butoane).
* Pentru a observa valoarea iesirii, vom conecta semnalul de iesire ''c''la un dispozitiv de observare, cum ar fi un LED, care va fi aprins daca ''c'' este 1 si stins daca ''c'' este 0.

[[Fișier:NAND2 FPGA.png | 600px]]

Pentru a realiza conectarea porturilor modulului ''top'' la pinii fizici ai FPGA ce sunt conectati mai departe la componentele de pe placa, va trebui sa specificam in utilitarul de sinteza maparea porturilor la acestia. Maparea se realizeaza prin mentionarea codurilor pinilor la care dorim conexiunea si poata numele de '''constrangeri de I/O'''. Aceste coduri sunt mentionate in documentatia placii de dezvoltare cu FPGA (in cazul nostru, Boolean Board) si pot fi regasite si in pagina [[Boolean Board - Pinout]].

Conform schemei, la acest exemplu avem nevoie de codurile pinilor conectati mai departe la Switch0, Switch1 si LED0.

'''Observatie:''' Daca intrarile si iesirile ar fi semnale pe mai multi biti, fiecare bit al intrarilor va fi conectat la cate un switch/buton si fiecare bit al iesirii va fi conectat la un LED. Acest lucru este necesar deoarece switch-urile/butoanele pot avea doar doua stari (0 si 1) si astfel pot controla un singur bit. La fel, un LED poate avea doar doua stari (0 - stins si 1 - aprins) si poate afisa starea unui singur bit.

Dupa ce ati extras codurile necesare, urmati pasii descrisi in [[Tutorial_Vivado|tutorialul Vivado]].

Dupa programarea cu succes a placii, puteti testa functionalitatea circuitului prin modficarea valorilor switch-urilor si observarea starii LED-ului.

==Exercitii==
Pentru urmatoarele exercitii se doreste atat testarea designurilor prin simulare cat si punerea acestora pe placa. Legat de placa, intrarile vor fi conectate la butoane, iar iesirile la leduri. Se va consulta tabelul cu pini disponibili ([[Boolean Board - Pinout]].).

Exista moduri mai rapide de a scrie functionalitatea dorita (vezi exemplu), dar tema principala a acestui laborator este instantierea, asa ca sunteti rugati sa respectati desenele si sa instantiati fiecare poarta individual.

===Exercitiul 1: AND4 din AND2===

Acest exercitiu arata cum se construieste o poarta AND cu 4 intrari din porti AND mai simple, cu 2 intrari.
Iesirea acesteia va fi "1" doar daca toate intrarile sunt "1".

[[Fișier:schema_and4_din_and2.png ‎| 600px]]

Pentru testarea circuitului, generati in testbench urmatoarele forme de unda (liniile punctate reprezinta 5ns):

[[Fișier:Wavedrom_and4.png ‎| 500px]]

===Exercitiul 2: OR4 din OR2===

Asemanator cu exercitiul anterior, se poate construi si o poarta or cu 4 intrari din porti or cu 2 intrari.
Iesirea acesteia va fi "1" doar daca oricare din intrari (cel putin una) este "1".

Pentru testarea circuitului se folosesc formele de unda de la exercitiul 1.

[[Fișier:schema_or4_din_or2.png ‎| 600px]]

===Exercitiul 3: AND4 din AND2 aranjat in cascada (nu arbore)===

In multe cazuri, aceeasi functionalitate poate fi atinsa prin circuite care arata diferit.
O alta varianta de a face o poarta AND cu 4 intrari este prezentata mai jos.

Comparati cele 2 variante.

Pentru testarea circuitului se folosesc formele de unda de la exercitiul 1.

[[Fișier:schema_and4_din_and2_v2.png ‎| 600px]]

===Exercitiul 4: AND4 din NAND2===

Orice poarta logica de baza poate fi construita doar din porti NAND sau doar din porti NOR.

Desenati si implementati circuitul pentru o poarta AND4 din porti NAND cu 2 intrari.

Tip: Incercati intai sa generati o poarta AND2 din NAND2.

Pentru testarea circuitului se folosesc formele de unda de la exercitiul 1.

===Exercitiul 5: AND4 pe 4b din AND4 pe 1b===

Se pot face operatii logice si pe mai multi biti deodata prin punerea in paralel a mai multor porti cu o singura iesire.
Exemplu :
pentru intrarile 0011 si 1110 iesirea va fi 0010

Pentru exersarea instantierii si intelegerea circuitului din spatele operatilor multibit implementati acest circuit prin instantierea a 4 porti AND4 pe 1 bit intr-o poarta AND4 pe 4 biti.

[[Fișier:schema_and4_4b_din_and4_1b_v1.png ‎| 400px]]

Pentru testarea circuitului, generati in testbench urmatoarele forme de unda (liniile punctate reprezinta 5ns):

[[Fișier:Wavedrom_and4_4b.png ‎| 500px]]

Exista si un mod mai rapid si simplu de a scrie aceasta functionalitate, grupand intrarile si iesirile in "bus"-uri, ca in codul de mai jos.
Acest mod de a grupa firele este desenat mai jos.

[[Fișier:schema_and4_4b_din_and4_1b_v2.png ‎| 600px]]

Fisierul and4_4b.sv:
<syntaxhighlight lang="Verilog">
module and4_4b
(
input logic [3:0] in0, // in0 are 4b, de la bit 3 la bit 0 inclusiv
input logic [3:0] in1, // se noteaza msb:lsb (most significant bit: least significant bit) (echivalent cu conceptul de cifra sutelor, cifra unitatilor, pt binar)
input logic [3:0] in2,
input logic [3:0] in3,
output logic [3:0] out0
);

assign out0 = in0 & in1 & in2 & in3;

endmodule
</syntaxhighlight>

===Exercitiul 6: Desenati schemele logice pentru urmatoarele circuite:===

'''a) Schema 1'''
<syntaxhighlight lang="Verilog">
module schema1 (a, b, c, d, f);
input logic a, b, c, d;
output logic f, g;

logic w1;
logic w2;

and P1 ( w1, a, c );
or P2 ( f, w1, w2, d);
not P3 (w2, b);
and P4 (g, w1, b, d);
endmodule
</syntaxhighlight>

Observatie: In versiunea veche de verilog (si s-a pastrat si in cea curenta), se pot specifica directiile porturilor si in exteriorul parantezelor, ca mai sus.
Aceasta scriere NU este recomandata.

'''b) Schema 2'''
<syntaxhighlight lang="Verilog">
module schema2 (a, b, c, d, f);
input logic a, b, c, d;
output logic f;

logic w1, w2;

nand P1 ( w1, a, b ), P2 (w2, c, d);
and P3 ( f, w1, w2);
endmodule
</syntaxhighlight>

'''Observatie:''' asemanator cu C/C++, se pot face declaratii in aceeasi linie a mai multor "variabile", aici fire sau instante, cum se poate vedea la w1 si w2 (ambele fiind fire) sau la P1 si P2 (ambele fiind porti nand).
Aceasta scriere NU este recomandata.

CID aplicatii 3 : Circuite combinationale elementare

2025-03-13T11:25:14Z

Mihai.antonescu: /* Exemplu - Decodorul */

==Teorie==
Acest laborator are ca scop scrierea unor circuite combinationale simple si explorarea variantelor de sintaxa diferite ce ajung sa ofere aceeasi functionalitate. Sintaxa va fi explicata in comentariile exemplului rezolvat mai jos.

Descrierea circuitelor in SystemVerilog se face in una din doua forme:

:1) structurala - descrie cum un modul e alcatuit din module sau primitive mai simple

:2) comportamentala/behavioural - descrie cum se calculeaza iesirile din intrari

==Exemplu - Decodorul==
Decodorul este un circuit a carui iesire pe n biti are un singur bit de "1", anume cel selectat prin singura sa intrare pe log2(n) biti.
Astfel, pentru un decodor cu iesire pe 8b, intrarea va avea 3b (logaritm in baza 2 din 8) si tabelul de adevar va arata astfel:

{| class="wikitable"
|- bgcolor="#ddeeff" align="center"
|- bgcolor="#ddeeff" align="center"
| in(3b) || out(8b)
|- bgcolor="#ddffdd" align="center"
|000 || 0000_0001
|- bgcolor="#ddffdd" align="center"
|001 || 0000_0010
|- bgcolor="#ddffdd" align="center"
|010 || 0000_0100
|- bgcolor="#ddffdd" align="center"
|011 || 0000_1000
|- bgcolor="#ddffdd" align="center"
|100 || 0001_0000
|- bgcolor="#ddffdd" align="center"
|101 || 0010_0000
|- bgcolor="#ddffdd" align="center"
|110 || 0100_0000
|- bgcolor="#ddffdd" align="center"
|111 || 1000_0000
|}

Iesirea este numerotata de la bitul 7 (msb) pana la bitul 0 (lsb). Se observa ca daca intrarea are valoare "a", singurul bit de "1" din iesire este cel de pe pozitia "a".

'''Observatie:''' Atat in tabelul de mai sus, cat si in codul SystemVerilog poate sa apara "_" (underscore) ca sa ajute vizual la separarea/numararea cifrelor. Se foloseste in mod uzual la scrierea in binar ca sa grupeze 4b (o cifra in hexa).

Circuitul exemplu al acestui laborator va fi un decodor mai mic, cu 2 biti de intrare si 4 de iesire, avand tabelul de adevar:

{| class="wikitable"
|- bgcolor="#ddeeff" align="center"
|- bgcolor="#ddeeff" align="center"
| in(2b) || out(4b)
|- bgcolor="#ddffdd" align="center"
|00 || 0001
|- bgcolor="#ddffdd" align="center"
|01 || 0010
|- bgcolor="#ddffdd" align="center"
|10 || 0100
|- bgcolor="#ddffdd" align="center"
|11 || 1000
|}

O varianta de schema care implementeaza acest circuit este cea de mai jos:

[[Fișier:w3_exemplu_rezolvat.png ‎| 600px]]

In circuitul de mai sus, apare dubla negatie, respectivul semnal putand fi luat si direct de la intrare. Acest lucru se intampla din considerente electrice. Desi pe desene nu sunt trecute, fiecare poarta are si fire de alimentare si de masa. Astfel, pentru a evita fire de lungimi foarte mari sau fire care se propaga in multe intrari si probleme de cadere a tensiunilor, se folosesc astfel de buffere/repetoare.

Codul de mai jos exemplifica moduri diferite de a exprima aceasta functionalitate.
El contine comentarii referitoare la sintaxa de baza SystemVerilog, necesara implementarii modulelor in diverse moduri.

'''Descrierea modulului decodor - varianta structurala din porti, cu primitive (fisierul decodor_v1.sv):'''
<syntaxhighlight lang="Verilog">
module decodor_v1
(
input logic [1:0] in, // definirea intrarilor sub forma de "bus"
// bus-ul de intrare se numeste "in" si este pe 2 biti: in[1], in[0]
// fizic sunt 2 fire distincte, grupate pentru o mai simpla folosire.
output logic [3:0] out // avem o iesire, numita "out" pe 4 biti.
);

logic in_0_inv;
logic in_1_inv;
logic in_0_nat;
logic in_1_nat;

not not_gate_0(in_0_inv,in[0]); // aleg bitul 0 al lui in sa intre in aceasta poarta not;

not not_gate_1(in_1_inv,in[1]); // observatie: cele 2 fire si cele 2 porti putea fi comprimate intr-un bus + poarta not pe 2 biti.

not not_gate_2(in_0_nat,in_0_inv);

not not_gate_3(in_1_nat,in_1_inv);

and and_gate_0(out[0],in_1_inv,in_0_inv);

and and_gate_1(out[1],in_1_inv,in_0_nat);

and and_gate_2(out[2],in_1_nat,in_0_inv);

and and_gate_3(out[3],in_1_nat,in_0_nat);

endmodule
</syntaxhighlight>

'''Descrierea modulului decodor - varianta cu assign, urmand schema (fisierul decodor_v2.sv):'''
<syntaxhighlight lang="Verilog">
module decodor_v2
(
input logic [1:0] in,
output logic [3:0] out
);

// fiecare bit din iesire calculat independent
assign out[0] = ~in[0] & ~in[1];
assign out[1] = in[0] & ~in[1];
assign out[2] = ~in[0] & in[1];
assign out[3] = in[0] & in[1];

endmodule
</syntaxhighlight>

'''Descrierea modulului decodor - varianta cu assign, cu operatorul "?" (fisierul decodor_v3.sv):'''
<syntaxhighlight lang="Verilog">
module decodor_v3
(
input logic [1:0] in,
output logic [3:0] out
);

// operatorul "?": identic c/c++; (conditie) ? (if_true) : (if_false);

assign out = (in==0) ? // if in == 0
1 : // if true: out = 1
(in==1) ? // else, verifica alt if.
2 : // if in !=0 si in == 1
(in==2) ?
4 :
8; // last case in==3

endmodule
</syntaxhighlight>

'''Descrierea modulului decodor - varianta cu always cu if (fisierul decodor_v4.sv):'''
<syntaxhighlight lang="Verilog">
module decodor_v4
(
input logic [1:0] in,
output logic [3:0] out
);

always_comb // mereu cand se schimba orice semnal, se "executa" ce e mai jos;
// always_comb genereaza un circuit combinational
begin // begin si end pe post de acolade din c/c++; delimiteaza if/else si altele asemenea; inclusiv always cu totul
if(in == 0)
begin // nota autorului: eu prefer sa pun begin/end asa. ele se pot pune si dupa conditie sau aliniate altfel.
// ^ preferinta personala legata de coding style, important e sa fiti consecventi in cum scrieti
out = 1;
end
else
begin
if(in == 1)
out = 2; // fiind o singura instructiune, begin/end se poate omite (identic c/c++)
else
begin // nota autorului: eu personal le pun mereu. in caz ca mai adaug linii in if dupa, sa fie deja puse
if(in == 2)
begin
out = 4;
end
else
begin
out = 8;
end
end
end
end//end pt always

endmodule
</syntaxhighlight>

'''Descrierea modulului decodor - varianta cu always cu case (fisierul decodor_v5.sv):'''
<syntaxhighlight lang="Verilog">
module decodor_v5
(
input logic [1:0] in,
output logic [3:0] out
);

always_comb
begin
case(in) // functioneaza ca switch/case din c/c++; sintaxa usor diferita
0: // if in == 0
begin
out = 1;
end
2'd1: // if in == 1; 2'd1 se traduce: pe 2 biti, in baza zece (eng: decimal, "d"), valoarea 1
begin // pt "0" de mai sus: daca nu se pune nimic se considera in baza zece.
out = 2;
end
2'b10: // if in == 2; scris in binar "b", 2'b10 => adica valoarea 2(10 binar) pe 2 biti
begin
out = 4;
end
2'h3: // if in == 3; scris in hexa (baza 16 "h", se poate si "x"), fiind numar mic, nu se vede diferenta fata de zecimal.
begin
out = 8;
end
default: // daca in == un caz netrat;
begin // aici inutil pt ca am tratat toate cazurile posibile; pus ca exemplu de sintaxa
out = 0;
end
endcase // orice "case" se inchide cu "endcase"
end

endmodule
</syntaxhighlight>

'''Descrierea modulului decodor - varianta cu assign comportamental (fisierul decodor_v6.sv):'''
<syntaxhighlight lang="Verilog">
module decodor_v6
(
input logic [1:0] in,
output logic [3:0] out
);

assign out = 1 << in;
// prin shiftare
// 1<<0 == 1 == 4'b0001;
// 1<<1 == 2 == 4'b0010;
// 1<<2 == 4 == 4'b0100;
// 1<<3 == 8 == 4'b1000;

endmodule
</syntaxhighlight>

'''Descrierea modulului top (fisierul top.sv):'''
<syntaxhighlight lang="Verilog">
// observatie:
// puteti da in vivado: rtl analysis -> open elaborated design -> schematic pentru a vedea desenul rezultat
// puteti vedea ca moduri diferite de scriere produc aparitia a diferite primitive de sinteza
module top
(
input logic [1:0] in,
output logic [3:0] out_v1, // fiecare varianta de decodor cu iesirea lui
output logic [3:0] out_v2, // toate ar trebui sa scoata acelasi rezultat
output logic [3:0] out_v3,
output logic [3:0] out_v4,
output logic [3:0] out_v5,
output logic [3:0] out_v6
);

decodor_v1 decodor_v1_0
(
.in(in),
.out(out_v1)
);

decodor_v2 decodor_v2_0
(
.in(in),
.out(out_v2)
);

decodor_v3 decodor_v3_0
(
.in(in),
.out(out_v3)
);

decodor_v4 decodor_v4_0
(
.in(in),
.out(out_v4)
);

decodor_v5 decodor_v5_0
(
.in(in),
.out(out_v5)
);

decodor_v6 decodor_v6_0
(
.in(in),
.out(out_v6)
);

endmodule
</syntaxhighlight>

==Exercitii==
===Exercitiul 1: Multiplexorul===

Multiplexorul (mux) este un circuit ce are rolul de a selecta una dintre intrari pentru ca aceasta sa ajunga la iesire.

Imaginati-va o intersectie in care toate masinile vor sa se iasa catre aceasi strada. Pentru a evita accidente, este nevoie de un element de control, de selectie, prin care se hotaraste care dintre intrari este lasata sa ajunga la iesire, in respectivul moment de timp.
Multiplexorul poate fi de asemenea vazut ca un comutator.

'''Observatie 1:''' conceptul de baza al multiplexarii este absolut vital si o sa apara des in multe zone ale ingineriei si la materii foarte diferite.
Ca niste mici exemple, el se foloseste in:
:a) telecomunicatii - cine are voie sa comunice pe un fir la un moment de timp
:b) internet - routere - cine trimite pachetele tcp/ip catre destinatia x
:c) panouri cu leduri - aprindere pe rand a ledurilor (de la instalatii de craciun pana la ecrane/televizoare care aprind randurile alternativ)

'''Observatie 2:''' numarul de intrari maxim posibile este 2^(nr_biti_selectie)

'''Observatie 3:''' multiplexoarele pot avea intrarile date si iesirea pe mai multi biti.

'''Observatie 4:''' este de ajutor sa incepeti sa vedeti circuitele ca avand o cale de date ce sunt procesate si o cale de control care decide cum se face asta.
Aici calea de date este alcatuita din intrari si iesire, iar calea de control din firele de selectie.
Acest principiu se propaga si in arhitectura microprocesoarelor unde vor aparea magistrale si memorii de date/instructiuni.

Pornind de la exemplul oferit, implementati multiplexorul in cat mai multe variante.

Multiplexorul cu 2 intrari pe un bit fiecare (mux elementar) este desenat in figurile de mai jos: cum este vazut din exterior (prima figura) si alcatuirea lui interna (a doua figura).

[[Fișier:mux2_general.png ‎| 300px]]
[[Fișier:mux2_schema_interna.png ‎| 300px]]

Pentru testarea circuitului, generati in testbench urmatoarele forme de unda (liniile punctate reprezinta 10ns):

[[Fișier:Wavedrom_mux2.png ‎| 500px]]

===Exercitiul 2: Implementati un mux4 (multiplexor cu 4 intrari)===

Interfata lui este ca in figura de mai jos.

[[Fișier:mux_general.png ‎| 300px]]

Pentru varianta lui structurala, mux4 se construieste din mai multe mux2 legate corespunzator. Incercati sa construiti voi aceasta schema.

Pentru testarea circuitului, generati in testbench urmatoarele forme de unda (liniile punctate reprezinta 10ns):

[[Fișier:Wavedrom_mux4.png ‎| 500px]]

===Exercitiul 3: Demultiplexorul===

Demultiplexorul (demux) este un circuit ce are rolul de a selecta catre care iesire se va duce intrarea.
Imaginati-va o intersectie in care intra o singura masina si trebuie sa decida daca iese catre stanga/inainte/dreapta.

Pentru acest exercitiu se va implementa un demux2 (cu 2 iesiri).

'''Observatie 1''': celelalte iesiri, cele neselectate iau valoarea 0.

'''Observatie 2''': numarul de iesiri maxim posibile este 2^(nr_biti_selectie)

Interfata demultiplexorului este data mai jos. Incercati sa construiti acest circuit in cat mai multe variante de sintaxa posibile (minim 4).

[[Fișier:demux2_general.png ‎| 300px]]

Generati forme de unda pentru a vedea functionarea demultiplexorului.

===Exercitiul 4: Sumatorul===

Sumatorul are rolul de a scoate la iesire suma celor 2 intrari.

Uzual el mai are si intrare si iesire de "carry" adica de transport (cand se depaseste baza de numarare si e nevoie de inca o cifra, ex in zecimal: 88 + 20 = 108; apare o cifra in plus, cifra sutelor).

[[Fișier:sumator_8b_general.png ‎| 300px]]

Observatie: desi scrierea cu assign si + este cea mai usoara si clara pentru un sumator, si celelalte moduri de scriere sunt posibile.
La aceasta scriere, daca se doresta ca sumatorul sa aiba carry out, sumatorul se poate face cu un bit mai mare decat intrarile, iar acel bit sa fie conectat la carry out. Practic, obtii un rezultat pe "n" biti + un bit de depasire, anume msb-ul.

Generati formele de unda necesare testarii sumatorului pe 8b.

Pentru a vedea pas cu pas cum se construieste un sumator pe 8b puteti parcurge urmatoarea platforma de laborator: [https://wiki.dcae.pub.ro/images/0/0f/Cid_gan_sumator_aplicatia_2.pdf Sumator.pdf]

===Exercitiul 5: Comparatorul===

Comparatorul are rolul de a vedea relatia dintre cele 2 intrari ale sale, daca cele 2 numere sunt egale, daca primul e mai mic sau mai mare.

Astfel el poate avea 3 iesiri dintre care se activeaza doar una:
:- iesire de egalitate
:- iesire de in0 < in1
:- iesire de in0 > in1

Se mai poate face si o varianta de comparator cu 2 iesiri, asa cum veti studia la arhitectura microprocesoarelor.
:- iesire de egalitate
:- iesire care este 0 daca in0<in1 sau 1 daca in0>in1

Aceasta abordare este folosita la AMP la flag-urile din procesoare, folosind operatia de scadere si flag-urile de "zero" si "negativ".

Scrieti modulul de comparator, in ambele variante de interfata. Intrarile pot avea oricat de multi biti (comparator mai mic sau mai mare), pentru acest exercitiu sa il faceti pe 4b.

Scrieti un testbench care sa genereze toate combinatiile posibile de date de la intrare.

'''Discutie''': Daca acest comparator are datele pe 32b sau mai mult (sau daca circuitul devine mult mai complex), nu se mai poate face o astfel de testare exhaustiva a combinatiilor posibile de date de la intrare pentru ca simularea ar dura prea mult. De situatia asta se ocupa inginerii de verificare ce lucreaza in paralel cu inginerii de design. Pentru mai multe detalii puteti cauta "constrained random functional verification". Incercati sa identificati cazurile/situatiile ce ar trebui testate pentru un comparator pe 32b inainte de a spune ca acesta functioneaza corect (minim 10).

CID aplicatii 2 : Instantiere si porti logice

2025-03-04T09:38:58Z

Mihai.antonescu: /* Exercitiul 5: AND4 pe 4b din AND4 pe 1b */

==Teorie: incapsulare si instantiere==
Unitatile constructive de baza din care se formeaza circuitele digitale se numesc porti logice. Acestea implementeaza functii logice si prin conectarea mai multor astfel de circuite simple complexitatea unui circuit poate creste pana la nivelul procesoarelor actuale. Pentru a putea controla cresterea complexitatii in proiectarea unui circuit de dimensiuni mari se folosesc 2 concepte cheie:

1) incapsularea functiei dorite intr-un modul

2) instantierea unor module mai mici si asamblarea acestora pentru a forma un modul mai mare.

Incapsularea se refera la a grupa elementele ce alcatuiesc o anumita functionalitate intr-un modul. Aceste elemente pot la randul lor sa fie alte module.
Instantierea (asemanator cu POO) se refera la a apela un modul deja scris pentru a fi folosit efectiv in circuitul curent.
Pentru a face o analogie cu programarea, cand se declara o variabila (sau un obiect), tipul variabilei este echivalent cu modulul si numele ei este numele instantei.

Pentru a intelege aceste concepte se da circuitul de mai jos:

[[Fișier:schema_principiu_instantiere.png ‎| 800px]]

'''Observatii:'''

1) Notatie aici: Numele modulului este scris in interior.

2) Notatie aici: Numele instantei este scris deasupra.

3) Idee fundamentala: prin instantierea si incapsularea unor circuite simple, mici, apar circuite mai complexe.

4) Idei esentiale (daca vreuna e neclara consultati cadrul didactic):

:a) "modul_2" este instantiat o singura data in tot proiecul, iar instanta se cheama "x"

:b) "modul_2" are o intrare numita "in0" si o iesire numita "out0"

:c) "modul_2" este instantiat in cadrul "modul_6"

:d) Modulul cel mai mare, ce cuprinde toata functionalitatea dorita a sistemului (aici "modul_6") se numeste uzual top.

:e) Instanta top-ului care apare atunci cand se doreste testarea sa in simulare intr-un testbench (tb) se numeste uzual DUT (design under test)

:f) "modul_0" apare instantiat de 3 ori. Circuitul final, cuprinde 3 subcircuite de tip "modul_0".

:g) La nivel de top, instanta sa se cheama "b".

:h) La nivel de "modul_5", cele 2 instante se cheama "a" si "c".

:i) "a" si "c" sunt 2 circuite fizice diferite chiar daca ambele sunt de tipul "modul_0". Fiind instante ale aceluiasi modul, deci identice in alcatuire, luate separat ele fac acelasi lucru. Luate in contextul lui "modul_5", "a" genereaza datele de pe firul "w0" si "c" genereaza datele pentru iesire.

:j) circuitul "b" de tip "modul_1" (instantiat in "modul_5") este complet diferit de circuitul "b" de tip "modul_0" (instantiat in top). Este permis ca ele sa aiba acelasi nume (cele 2 instante) deoarece se afla in locatii diferite.

:k) Identic, mai multe module au o intrare numita "in_0". La sinteza circuitului nu se face confuzie intre acestea deoarece fiecare e vazut la nivelul altei instante.

:l) Identic, firele de legatura "w0", "w1".

:m) La nivelul "top", firul de legatura "w2" leaga iesirea "out_0" a instantei "b" la intrarea "in2" a instantei "y".

:n) La nivelul "top", firul de legatura "w1" leaga iesirea "out_0" a instantei "x" la intrarea "in1" a instantei "y".

:o) La nivelul "modul_5", firul de legatura "w1" leaga iesirea instantei "b" la intrarea instantei "c".

:Pentru claritatea desenului, respectivele intrari si iesiri nu au fost denumite. In cod este obligatoriu ca ele sa fie definite si denumite.

:p) La nivelul "top", "in0","in1","in2","in3","in4" si "out0" formeaza interfata modulului (semnalele care intra sau ies din modul).

:q) La nivelul "top", "w0", "w1", "w2" sunt fire interne de legatura.

:r) La nivelul "top", firul "in3" este conectat ca intrare pentru 3 submodule.

==Teorie: testarea circuitelor==
Pentru a se testa functionarea corecta a circuitului final, acesta este instantiat intr-un modul numit "test_bench" sau "tb". Acest modul este folosit strict in simulare.
Testarea unui circuit are loc conform schemei urmatoare:

[[Fișier:schema_principiu_tb.png ‎| 600px]]

Generarea datelor de intrare se va face asemanator cu laboratorul 1.

Voi veti avea rolul modelului ideal si al comparatorului datelor de iesire, uitandu-va la datele de intrare veti calcula iesirea corecta si apoi veti compara aceasta valoare cu raspunsul circuitului ce se testeaza.

In cazul unui sistem automat, se genereaza mesaje de eroare sau mesaje ca functionarea este in regula.

Observatie: proiectarea si verificarea sunt 2 domenii diferite, firmele avand departamente separate pentru acestea.

Proiectarea/Design se ocupa cu scrierea in Verilog/SystemVerilog a modului de top si toate modulele ce se afla in acesta, avand ca scop final realizarea fizica pe placa a unui circuit.

Verificarea se ocupa de scrierea in SystemVerilog (limbaj format din Verilog cu concepte de POO) a modului de testbench si generarea de stimuli si scenarii care sa testeze functionarea design-ului.

==Teorie: porti logice==
Portile logice folosite uzual, impreuna cu tabelele lor de adevar si reprezentarea grafica sunt date mai jos.

Se folosesc porti logice cu 1 sau 2 intrari, cele cu mai mult de 2 intrari fiind construite din acestea.

{| class="wikitable"
! Tip !! Simbol !! Tabel de adevăr !! Tip !! Simbol !! Tabel de adevăr
|-
| '''Buffer/Repetor'''
| [[Image:Buffer_gate.png|Buffer symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || A
|- bgcolor="#ddffdd" align="center"
|0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1
|}
| '''NOT'''
| [[Image:not.png|NOT symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || NOT A
|- bgcolor="#ddffdd" align="center"
|0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0
|}
|-
| '''AND'''
| [[Image:and.png|AND symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A AND B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 1
|}
| '''NAND'''
| [[Image:nand.png|NAND symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A NAND B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 0
|}
|-
| '''OR'''
| [[Image:or.png|OR symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A OR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 1
|}
| '''NOR'''
| [[Image:nor.png|NOR symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A NOR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 0
|}
|-
| '''XOR'''
| [[Image:xor.png|XOR symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A XOR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 0
|}
| '''XNOR'''
| [[Image:xnor.png|XNOR symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A XNOR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 1
|}
|}

==Despre FPGA==
FPGA-ul (Field-Programmable Gate Array) este un circuit programabil, capabil sa implementeze circuite definit de utilizator. El este format dintr-o matrice de blocuri programabile, interconectate intre ele printr-o serie de conexiuni la randul lor programabile.

Cand se doreste implementarea unui circuit pe FPGA, acesta urmeaza urmatoarele etape:

:'''Elaborarea''' este procesul prin care codul SystemVerilog este transformat intr-un circuit la nivel de porti si registre (netlist) si este independent de modelul de FPGA folosit.

:'''Sinteza''' este procesul în care se realizează transformarea circuitului descris într-un netlist dependent de tehnologie. Se vor folosi la acest pas primitivele disponibile pe FPGA.

:'''Implementarea''' este procesul în care se preia netlist-ul ce conține primitivele FPGA și modul lor de interconectare realizat la pasul de sinteză și se realizează maparea lor efectivă în FPGA (place and route).

:'''Generarea Bitstream-ului''' este procesul prin care informatiile din implementare sunt asamblate intr-un singur fisier.

:'''Programarea''' este procesul prin care fisierul generat anterior este trimis efectiv catre placa cu FPGA (prin USB) unde determina modificarea valorilor si conexiunilor interne din aceasta.

O introducere mai detaliata poate fi gasita aici : [[FPGA - Introducere]].

[[Fișier:Fpgaimg.PNG|600px]]

'''Observatii:'''
* Pentru a putea controla circuitul propus si a putea vedea rezultatele, intrarile si iesirile (input si output din module) in/din acesta trebuie conectate la pini fizici ai FPGA-ului care sunt conectati la butoane/switch-uri/leduri.
* Conexiunile dintre butoane/switch-uri si pinii FPGA sunt fixe. La fel si cele intre pinii FPGA si LED-uri. (in functie de PCB)
* Conexiunile dintre porturile modulului ''Module'' si pinii FPGA sunt configurabile. (in functie de noi, prin fisierul XDC)
* Legarea porturilor modulului ''Module'' la pinii fizici ai FPGA se realizeaza prin configurarea conexiunilor din FPGA conform contrangerilor de I/O pe care le vom mentiona in proiect, inainte de sinteza.

==Exemple==

===Exemplul 1: Analiza circuitelor cu porti===
Fie urmatorul circuit alcatuit din porti logice:
[[Fișier:Mux2_schema_interna_2.png ‎| 400px]]

Se doreste exprimarea circuitului de mai sus ca formula de tip: iesire = f(intrari).

Pentru asta, abordarea consta in a porni de la iesire si a merge pas cu pas catre intrari, asa cum este exemplificat mai jos. Se vor folosi simbolurile "~" pentru NOT, "&" pentru AND, "|" pentru OR.
:pas1: out0 = ?
:pas2: out0 = w1 | w2
:pas3: out0 = w1 | ( ? )
:pas4: out0 = w1 | ( sel & in1 )
:pas5: out0 = ( ? ) | ( sel & in1 )
:pas6: out0 = ( in0 & w0 ) | ( sel & in1 )
:pas7: out0 = ( in0 & ( ? ) ) | ( sel & in1 )
:pas8: out0 = ( in0 & (~sel) ) | ( sel & in1 )

===Exemplul 2: NAND2 din AND2 si NOT===
In urmatorul exemplu se implementeaza o poarta NAND din o poarta AND si o poarta NOT.

Codul de mai jos exemplifica ideea de instantiere si contine comentarii legate de sintaxa SystemVerilog necesara.

In mod uzual fisierele sunt denumite dupa modulul ce se afla in ele, in fiecare fisier fiind un singur modul.

Schema circuitul care se doreste a fi creat este:

[[Fișier:schema_exemplu_rezolvat.png ‎| 600px]]

'''Descrierea portii NOT (fisierul not_gate.sv):'''
<syntaxhighlight lang="Verilog">
// comentarii cu "//" sau cu /* .... */ ;
/*
ca in c/c++
*/

module not_gate // cuvant cheie "module" apoi numele modulului (asemanator clase din c++)
( // intre paranteze se pune interfata (firele care intra sau ies din modul)
input logic in0, // in0 este o intrare => input
output logic out0 // out0 este o intrare => output
); // aici ";" sa nu il uitati

assign out0 = ~in0; // cuvant cheie assign;
// semnalele pot lua valoare prin assign
// ~ e semnul pentru negatie pe biti (ca in c/c++)

endmodule // cuvant cheie "endmodule". orice module se inchide cu endmodule.
</syntaxhighlight>

'''Descrierea portii AND (fisierul and_gate.sv):'''
<syntaxhighlight lang="Verilog">
module and_gate
(
input logic in0, // aici sunt 2 intrari
input logic in1,
output logic out0
); // nu conteaza ordinea in care sunt puse intrarile si iesirile.
// uzual si pentru usurinta se ordoneaza si grupeaza dupa functionalitate
// in cazul de mai sus, am pus intai intrarile, apoi iesirile.

assign out0 = in0 & in1; // operatia propriu zisa

endmodule
</syntaxhighlight>

'''Descrierea modulului top (fisierul top.sv):'''
<syntaxhighlight lang="Verilog">

module top
(
input logic a,
input logic b,
output logic c
);

logic w0; //declarat un fir intern de legatura

and_gate and_gate_0 // instantiere: nume_modul nume_instanta (asemanator int x din c/c++)
(
.in0(a), // la intrarea "in0" a instantei "and_gate_0" se conecteaza firul "a" din top
.in1(b), // grija ca "in0", "in1", "out0" sa existe in declararea modulului "and_gate"
.out0(w0) // grija ca "a", "b", "w0" sa existe la nivelul modulului in care se face instantierea
);

not_gate not_gate_0
(
.in0(w0), // "w0" care iese din "and_gate_0" intra in "not_gate_0"
.out0(c) // "c" care iese din "not_gate_0" iese din modulul "top" (e iesire in interfata de sus)
); // se poate scrie si ".in0(w0),.out0(c)" dar se prefera fiecare fir pe randul sau (lizibilitate si loc de comentarii pt design-uri complexe)
// Observatie: la varianta de mai sus de instantiere, nu conteaza ordinea firelor.

/*
not_gate not_gate_0
( // se poate instantia si in forma prescurtata ca aici
w0, // in acest caz se pun conexiunile in ordinea in care sunt declarate intrarile si iesirile din modul
c // NU se recomanda stilul asta de instantiere
); // apar greseli frecvent la ordinea firelor si la numarul lor,
*/ // mai ales daca modulul e complex si are multe intrari si intrari

endmodule
</syntaxhighlight>

Echivalent se pot folosi si "primitive" SystemVerilog pentru scrierea top-ului.

Primitivele sunt circuite care exista deja in limbaj, folosite atunci cand se doreste o descriere structurala a circuitului.

In instantiere acestora, iesirea se pune prima, urmata de intrari.

'''Observatie:''' daca se doreste scrierea acestor porti de catre voi (ca mai sus), numele modulului nu trebuie sa fie un cuvant cheie ocupat de primitive.

'''Descrierea alternativa a modulului top (fisierul top_v2.sv):'''
<syntaxhighlight lang="Verilog">
module top_v2
(
input logic a,
input logic b,
output logic c
);

logic w0;

and and_gate_0(w0,a,b); // primitiva pentru poarta and
not not_gate_0(c,w0); // primitiva pentru poarta not

endmodule
</syntaxhighlight>

Fiind un modul simplu, intreaga functionalitate putea fi scrisa la nivel de "top" si simplificat ca mai jos.

'''Descrierea alternativa a modulului top (fisierul top_v3.sv):'''
<syntaxhighlight lang="Verilog">
module top_v3
(
input logic a,
input logic b,
output logic c
);

assign c = ~ (a & b); // a si b, negate

endmodule
</syntaxhighlight>

Testarea circuitul se face printr-un testbench, acesta fiind:

'''Descrierea testbench-ului (fisierul top_tb.sv):'''
<syntaxhighlight lang="Verilog">
`timescale 1ns / 1ps

module top_tb(); // din/in tb nu intra si iese nimic. niciodata.

logic a_tb;
logic b_tb;
logic c_tb;

top dut // instantierea modulului de tip "top" sub numele "dut"
(
.a(a_tb),
.b(b_tb),
.c(c_tb)
);

initial
begin // in loc de { ... } din c/c++, in SystemVerilog se pune begin ... end
#10; // dupa 10 unitati de timp
a_tb = 0; // a_tb ia valoarea 0
b_tb = 0;
#10; // dupa inca 10 unitati de timp, deci in total la 20
a_tb = 1;
b_tb = 0;
#10;
a_tb = 0;
b_tb = 1;
#10;
a_tb = 1;
b_tb = 1;
#10;
a_tb = 0;
b_tb = 0;

#20 $stop(); // oprirea simularii
end //end pentru initial

endmodule
</syntaxhighlight>

Formele de unda rezultate din simulare se pot vedea mai jos:

[[Fișier:exemplu_rezolvat_nand_forme_de_unda.png ‎| 800px]]

In chenarul verde se pot observa instantele din simulare.

Daca se doreste adaugarea de semnale noi pentru a fi vazute, se selecteaza modulul instantiat in care acestea se afla (chenar verde).

Apoi, din chenarul rosu se aleg semnalele si se adauga prin click dreapta->add to wave window.

Pentru o mai usoara vizualizare, semnalele se pot grupa asa cum se vede in chenarul mov prin click dreapta->new group.

Se observa o functionare corecta circuitului, acesta fiind o poarta NAND. El scoate "0" cand ambele semnale de intrare sunt "1" si scoate "1" in rest.

'''Implementarea circuitului pe FPGA'''

Dupa ce circuitul a fost testat in simulare, se doreste punerea sa fizica pe placa FPGA. Pentru aceasta, se tine cont de urmatoarele.

* Pentru a controla intrarile ''a'' si ''b'' ale circuitului '''top'', va trebui sa le conectam prin intermediul conexiunilor configurabile ale FPGA-ului la pini ce sunt mai departe conectati fizic la dispozitive ce pot controla valorile semnalelor (switch-uri, butoane).
* Pentru a observa valoarea iesirii, vom conecta semnalul de iesire ''c''la un dispozitiv de observare, cum ar fi un LED, care va fi aprins daca ''c'' este 1 si stins daca ''c'' este 0.

[[Fișier:NAND2 FPGA.png | 600px]]

Pentru a realiza conectarea porturilor modulului ''top'' la pinii fizici ai FPGA ce sunt conectati mai departe la componentele de pe placa, va trebui sa specificam in utilitarul de sinteza maparea porturilor la acestia. Maparea se realizeaza prin mentionarea codurilor pinilor la care dorim conexiunea si poata numele de '''constrangeri de I/O'''. Aceste coduri sunt mentionate in documentatia placii de dezvoltare cu FPGA (in cazul nostru, Boolean Board) si pot fi regasite si in pagina [[Boolean Board - Pinout]].

Conform schemei, la acest exemplu avem nevoie de codurile pinilor conectati mai departe la Switch0, Switch1 si LED0.

'''Observatie:''' Daca intrarile si iesirile ar fi semnale pe mai multi biti, fiecare bit al intrarilor va fi conectat la cate un switch/buton si fiecare bit al iesirii va fi conectat la un LED. Acest lucru este necesar deoarece switch-urile/butoanele pot avea doar doua stari (0 si 1) si astfel pot controla un singur bit. La fel, un LED poate avea doar doua stari (0 - stins si 1 - aprins) si poate afisa starea unui singur bit.

Dupa ce ati extras codurile necesare, urmati pasii descrisi in [[Tutorial_Vivado|tutorialul Vivado]].

Dupa programarea cu succes a placii, puteti testa functionalitatea circuitului prin modficarea valorilor switch-urilor si observarea starii LED-ului.

==Exercitii==
Pentru urmatoarele exercitii se doreste atat testarea designurilor prin simulare cat si punerea acestora pe placa. Legat de placa, intrarile vor fi conectate la butoane, iar iesirile la leduri. Se va consulta tabelul cu pini disponibili ([[Boolean Board - Pinout]].).

Exista moduri mai rapide de a scrie functionalitatea dorita (vezi exemplu), dar tema principala a acestui laborator este instantierea, asa ca sunteti rugati sa respectati desenele si sa instantiati fiecare poarta individual.

===Exercitiul 1: AND4 din AND2===

Acest exercitiu arata cum se construieste o poarta AND cu 4 intrari din porti AND mai simple, cu 2 intrari.
Iesirea acesteia va fi "1" doar daca toate intrarile sunt "1".

[[Fișier:schema_and4_din_and2.png ‎| 600px]]

Pentru testarea circuitului, generati in testbench urmatoarele forme de unda (liniile punctate reprezinta 5ns):

[[Fișier:Wavedrom_and4.png ‎| 500px]]

===Exercitiul 2: OR4 din OR2===

Asemanator cu exercitiul anterior, se poate construi si o poarta or cu 4 intrari din porti or cu 2 intrari.
Iesirea acesteia va fi "1" doar daca oricare din intrari (cel putin una) este "1".

Pentru testarea circuitului se folosesc formele de unda de la exercitiul 1.

[[Fișier:schema_or4_din_or2.png ‎| 600px]]

===Exercitiul 3: AND4 din AND2 aranjat in cascada (nu arbore)===

In multe cazuri, aceeasi functionalitate poate fi atinsa prin circuite care arata diferit.
O alta varianta de a face o poarta AND cu 4 intrari este prezentata mai jos.

Comparati cele 2 variante.

Pentru testarea circuitului se folosesc formele de unda de la exercitiul 1.

[[Fișier:schema_and4_din_and2_v2.png ‎| 600px]]

===Exercitiul 4: AND4 din NAND2===

Orice poarta logica de baza poate fi construita doar din porti NAND sau doar din porti NOR.

Desenati si implementati circuitul pentru o poarta AND4 din porti NAND cu 2 intrari.

Tip: Incercati intai sa generati o poarta AND2 din NAND2.

Pentru testarea circuitului se folosesc formele de unda de la exercitiul 1.

===Exercitiul 5: AND4 pe 4b din AND4 pe 1b===

Se pot face operatii logice si pe mai multi biti deodata prin punerea in paralel a mai multor porti cu o singura iesire.
Exemplu :
pentru intrarile 0011 si 1110 iesirea va fi 0010

Pentru exersarea instantierii si intelegerea circuitului din spatele operatilor multibit implementati acest circuit prin instantierea a 4 porti AND4 pe 1 bit intr-o poarta AND4 pe 4 biti.

[[Fișier:schema_and4_4b_din_and4_1b_v1.png ‎| 400px]]

Pentru testarea circuitului, generati in testbench urmatoarele forme de unda (liniile punctate reprezinta 5ns):

[[Fișier:Wavedrom_and4_4b.png ‎| 500px]]

Exista si un mod mai rapid si simplu de a scrie aceasta functionalitate, grupand intrarile si iesirile in "bus"-uri, ca in codul de mai jos.
Acest mod de a grupa firele este desenat mai jos.

[[Fișier:schema_and4_4b_din_and4_1b_v2.png ‎| 600px]]

Fisierul and4_4b.sv:
<syntaxhighlight lang="Verilog">
module and4_4b
(
input logic [3:0] in0, // in0 are 4b, de la bit 3 la bit 0 inclusiv
input logic [3:0] in1, // se noteaza msb:lsb (most significant bit: least significant bit) (echivalent cu conceptul de cifra sutelor, cifra unitatilor, pt binar)
input logic [3:0] in2,
input logic [3:0] in3,
output logic [3:0] out0
);

assign out0 = in0 & in1 & in2 & in3;

endmodule
</syntaxhighlight>

===Exercitiul 6: Desenati schemele logice pentru urmatoarele circuite:===

'''a) Schema 1'''
<syntaxhighlight lang="Verilog">
module schema1 (a, b, c, d, f);
input logic a, b, c, d;
output logic f, g;

logic w1;
logic w2;

and P1 ( w1, a, c );
or P2 ( f, w1, w2, d);
not P3 (w2, b);
and P4 (g, w1, b, d);
endmodule
</syntaxhighlight>

Observatie: In versiunea veche de verilog (si s-a pastrat si in cea curenta), se pot specifica directiile porturilor si in exteriorul parantezelor, ca mai sus.
Aceasta scriere NU este recomandata.

'''b) Schema 2'''
<syntaxhighlight lang="Verilog">
module schema2 (a, b, c, d, f);
input logic a, b, c, d;
output logic f;

logic w1, w2;

nand P1 ( w1, a, b ), P2 (w2, c, d);
and P3 ( f, w1, w2);
endmodule
</syntaxhighlight>

'''Observatie:''' asemanator cu C/C++, se pot face declaratii in aceeasi linie a mai multor "variabile", aici fire sau instante, cum se poate vedea la w1 si w2 (ambele fiind fire) sau la P1 si P2 (ambele fiind porti nand).
Aceasta scriere NU este recomandata.

CID aplicatii 3 : Circuite combinationale elementare

2025-03-04T09:36:14Z

Mihai.antonescu: /* Exercitiul 3: Demultiplexorul */

==Teorie==
Acest laborator are ca scop scrierea unor circuite combinationale simple si explorarea variantelor de sintaxa diferite ce ajung sa ofere aceeasi functionalitate. Sintaxa va fi explicata in comentariile exemplului rezolvat mai jos.

Descrierea circuitelor in SystemVerilog se face in una din doua forme:

:1) structurala - descrie cum un modul e alcatuit din module sau primitive mai simple

:2) comportamentala/behavioural - descrie cum se calculeaza iesirile din intrari

==Exemplu - Decodorul==
Decodorul este un circuit a carui iesire pe n biti are un singur bit de "1", anume cel selectat prin singura sa intrare pe log2(n) biti.
Astfel, pentru un decodor cu iesire pe 8b, intrarea va avea 3b (logaritm in baza 2 din 8) si tabelul de adevar va arata astfel:

{| class="wikitable"
|- bgcolor="#ddeeff" align="center"
|- bgcolor="#ddeeff" align="center"
| in(3b) || out(8b)
|- bgcolor="#ddffdd" align="center"
|000 || 0000_0001
|- bgcolor="#ddffdd" align="center"
|001 || 0000_0010
|- bgcolor="#ddffdd" align="center"
|010 || 0000_0100
|- bgcolor="#ddffdd" align="center"
|011 || 0000_1000
|- bgcolor="#ddffdd" align="center"
|100 || 0001_0000
|- bgcolor="#ddffdd" align="center"
|101 || 0010_0000
|- bgcolor="#ddffdd" align="center"
|110 || 0100_0000
|- bgcolor="#ddffdd" align="center"
|111 || 1000_0000
|}

Iesirea este numerotata de la bitul 7 (msb) pana la bitul 0 (lsb). Se observa ca daca intrarea are valoare "a", singurul bit de "1" din iesire este cel de pe pozitia "a".

'''Observatie:''' Atat in tabelul de mai sus, cat si in codul SystemVerilog poate sa apara "_" (underscore) ca sa ajute vizual la separarea/numararea cifrelor. Se foloseste in mod uzual la scrierea in binar ca sa grupeze 4b (o cifra in hexa).

Circuitul exemplu al acestui laborator va fi un decodor mai mic, cu 2 biti de intrare si 4 de iesire, avand tabelul de adevar:

{| class="wikitable"
|- bgcolor="#ddeeff" align="center"
|- bgcolor="#ddeeff" align="center"
| in(2b) || out(4b)
|- bgcolor="#ddffdd" align="center"
|00 || 0001
|- bgcolor="#ddffdd" align="center"
|01 || 0010
|- bgcolor="#ddffdd" align="center"
|10 || 0100
|- bgcolor="#ddffdd" align="center"
|11 || 1000
|}

O varianta de schema care implementeaza acest circuit este cea de mai jos:

[[Fișier:w3_exemplu_rezolvat.png ‎| 600px]]

In circuitul de mai sus, apare dubla negatie, respectivul semnal putand fi luat si direct de la intrare. Acest lucru se intampla din considerente electrice. Desi pe desene nu sunt trecute, fiecare poarta are si fire de alimentare si de masa. Astfel, pentru a evita fire de lungimi foarte mari sau fire care se propaga in multe intrari si probleme de cadere a tensiunilor, se folosesc astfel de buffere/repetoare.

Codul de mai jos exemplifica moduri diferite de a exprima aceasta functionalitate.
El contine comentarii referitoare la sintaxa de baza SystemVerilog, necesara implementarii modulelor in diverse moduri.

'''Descrierea modulului decodor - varianta structurala din porti, cu primitive (fisierul decodor_v1.sv):'''
<syntaxhighlight lang="Verilog">
module decodor_v1
(
input logic [1:0] in, // definirea intrarilor sub forma de "bus"
// bus-ul de intrare se numeste "in" si este pe 2 biti: in[1], in[0]
// fizic sunt 2 fire distincte, grupate pentru o mai simpla folosire.
output logic [3:0] out // avem o iesire, numita "out" pe 4 biti.
);

logic in_0_inv;
logic in_1_inv;
logic in_0_nat;
logic in_1_nat;

not not_gate_0(in_0_inv,in[0]); // aleg bitul 0 al lui in sa intre in aceasta poarta not;

not not_gate_1(in_1_inv,in[1]); // observatie: cele 2 fire si cele 2 porti putea fi comprimate intr-un bus + poarta not pe 2 biti.

not not_gate_2(in_0_nat,in_0_inv);

not not_gate_3(in_1_nat,in_1_inv);

and and_gate_0(out[0],in_1_inv,in_0_inv);

and and_gate_1(out[1],in_1_inv,in_0_nat);

and and_gate_2(out[2],in_1_nat,in_0_inv);

and and_gate_3(out[3],in_1_nat,in_0_nat);

endmodule
</syntaxhighlight>

'''Descrierea modulului decodor - varianta cu assign, urmand schema (fisierul decodor_v2.sv):'''
<syntaxhighlight lang="Verilog">
module decodor_v2
(
input logic [1:0] in,
output logic [3:0] out
);

// fiecare bit din iesire calculat independent
assign out[0] = ~in[0] & ~in[1];
assign out[1] = in[0] & ~in[1];
assign out[2] = ~in[0] & in[1];
assign out[3] = in[0] & in[1];

endmodule
</syntaxhighlight>

'''Descrierea modulului decodor - varianta cu assign, cu operatorul "?" (fisierul decodor_v3.sv):'''
<syntaxhighlight lang="Verilog">
module decodor_v3
(
input logic [1:0] in,
output logic [3:0] out
);

// operatorul "?": identic c/c++; (conditie) ? (if_true) : (if_flase);

assign out = (in==0) ? // if in == 0
1 : // if true: out = 1
(in==1) ? // else, verifica alt if.
2 : // if in !=0 si in == 1
(in==2) ?
4 :
8; // last case in==3

endmodule
</syntaxhighlight>

'''Descrierea modulului decodor - varianta cu always cu if (fisierul decodor_v4.sv):'''
<syntaxhighlight lang="Verilog">
module decodor_v4
(
input logic [1:0] in,
output logic [3:0] out
);

always_comb // mereu cand se schimba orice semnal, se "executa" ce e mai jos;
// always_comb genereaza un circuit combinational
begin // begin si end pe post de acolade din c/c++; delimiteaza if/else si altele asemenea; inclusiv always cu totul
if(in == 0)
begin // nota autorului: eu prefer sa pun begin/end asa. ele se pot pune si dupa conditie sau aliniate altfel.
// ^ preferinta personala legata de coding style, important e sa fiti consecventi in cum scrieti
out = 1;
end
else
begin
if(in == 1)
out = 2; // fiind o singura instructiune, begin/end se poate omite (identic c/c++)
else
begin // nota autorului: eu personal le pun mereu. in caz ca mai adaug linii in if dupa, sa fie deja puse
if(in == 2)
begin
out = 4;
end
else
begin
out = 8;
end
end
end
end//end pt always

endmodule
</syntaxhighlight>

'''Descrierea modulului decodor - varianta cu always cu case (fisierul decodor_v5.sv):'''
<syntaxhighlight lang="Verilog">
module decodor_v5
(
input logic [1:0] in,
output logic [3:0] out
);

always_comb
begin
case(in) // functioneaza ca switch/case din c/c++; sintaxa usor diferita
0: // if in == 0
begin
out = 1;
end
2'd1: // if in == 1; 2'd1 se traduce: pe 2 biti, in baza zece (eng: decimal, "d"), valoarea 1
begin // pt "0" de mai sus: daca nu se pune nimic se considera in baza zece.
out = 2;
end
2'b10: // if in == 2; scris in binar "b", 2'b10 => adica valoarea 2(10 binar) pe 2 biti
begin
out = 4;
end
2'h3: // if in == 3; scris in hexa (baza 16 "h", se poate si "x"), fiind numar mic, nu se vede diferenta fata de zecimal.
begin
out = 8;
end
default: // daca in == un caz netrat;
begin // aici inutil pt ca am tratat toate cazurile posibile; pus ca exemplu de sintaxa
out = 0;
end
endcase // orice "case" se inchide cu "endcase"
end

endmodule
</syntaxhighlight>

'''Descrierea modulului decodor - varianta cu assign comportamental (fisierul decodor_v6.sv):'''
<syntaxhighlight lang="Verilog">
module decodor_v6
(
input logic [1:0] in,
output logic [3:0] out
);

assign out = 1 << in;
// prin shiftare
// 1<<0 == 1 == 4'b0001;
// 1<<1 == 2 == 4'b0010;
// 1<<2 == 4 == 4'b0100;
// 1<<3 == 8 == 4'b1000;

endmodule
</syntaxhighlight>

'''Descrierea modulului top (fisierul top.sv):'''
<syntaxhighlight lang="Verilog">
// observatie:
// puteti da in vivado: rtl analysis -> open elaborated design -> schematic pentru a vedea desenul rezultat
// puteti vedea ca moduri diferite de scriere produc aparitia a diferite primitive de sinteza
module top
(
input logic [1:0] in,
output logic [3:0] out_v1, // fiecare varianta de decodor cu iesirea lui
output logic [3:0] out_v2, // toate ar trebui sa scoata acelasi rezultat
output logic [3:0] out_v3,
output logic [3:0] out_v4,
output logic [3:0] out_v5,
output logic [3:0] out_v6
);

decodor_v1 decodor_v1_0
(
.in(in),
.out(out_v1)
);

decodor_v2 decodor_v2_0
(
.in(in),
.out(out_v2)
);

decodor_v3 decodor_v3_0
(
.in(in),
.out(out_v3)
);

decodor_v4 decodor_v4_0
(
.in(in),
.out(out_v4)
);

decodor_v5 decodor_v5_0
(
.in(in),
.out(out_v5)
);

decodor_v6 decodor_v6_0
(
.in(in),
.out(out_v6)
);

endmodule
</syntaxhighlight>

==Exercitii==
===Exercitiul 1: Multiplexorul===

Multiplexorul (mux) este un circuit ce are rolul de a selecta una dintre intrari pentru ca aceasta sa ajunga la iesire.

Imaginati-va o intersectie in care toate masinile vor sa se iasa catre aceasi strada. Pentru a evita accidente, este nevoie de un element de control, de selectie, prin care se hotaraste care dintre intrari este lasata sa ajunga la iesire, in respectivul moment de timp.
Multiplexorul poate fi de asemenea vazut ca un comutator.

'''Observatie 1:''' conceptul de baza al multiplexarii este absolut vital si o sa apara des in multe zone ale ingineriei si la materii foarte diferite.
Ca niste mici exemple, el se foloseste in:
:a) telecomunicatii - cine are voie sa comunice pe un fir la un moment de timp
:b) internet - routere - cine trimite pachetele tcp/ip catre destinatia x
:c) panouri cu leduri - aprindere pe rand a ledurilor (de la instalatii de craciun pana la ecrane/televizoare care aprind randurile alternativ)

'''Observatie 2:''' numarul de intrari maxim posibile este 2^(nr_biti_selectie)

'''Observatie 3:''' multiplexoarele pot avea intrarile date si iesirea pe mai multi biti.

'''Observatie 4:''' este de ajutor sa incepeti sa vedeti circuitele ca avand o cale de date ce sunt procesate si o cale de control care decide cum se face asta.
Aici calea de date este alcatuita din intrari si iesire, iar calea de control din firele de selectie.
Acest principiu se propaga si in arhitectura microprocesoarelor unde vor aparea magistrale si memorii de date/instructiuni.

Pornind de la exemplul oferit, implementati multiplexorul in cat mai multe variante.

Multiplexorul cu 2 intrari pe un bit fiecare (mux elementar) este desenat in figurile de mai jos: cum este vazut din exterior (prima figura) si alcatuirea lui interna (a doua figura).

[[Fișier:mux2_general.png ‎| 300px]]
[[Fișier:mux2_schema_interna.png ‎| 300px]]

Pentru testarea circuitului, generati in testbench urmatoarele forme de unda (liniile punctate reprezinta 10ns):

[[Fișier:Wavedrom_mux2.png ‎| 500px]]

===Exercitiul 2: Implementati un mux4 (multiplexor cu 4 intrari)===

Interfata lui este ca in figura de mai jos.

[[Fișier:mux_general.png ‎| 300px]]

Pentru varianta lui structurala, mux4 se construieste din mai multe mux2 legate corespunzator. Incercati sa construiti voi aceasta schema.

Pentru testarea circuitului, generati in testbench urmatoarele forme de unda (liniile punctate reprezinta 10ns):

[[Fișier:Wavedrom_mux4.png ‎| 500px]]

===Exercitiul 3: Demultiplexorul===

Demultiplexorul (demux) este un circuit ce are rolul de a selecta catre care iesire se va duce intrarea.
Imaginati-va o intersectie in care intra o singura masina si trebuie sa decida daca iese catre stanga/inainte/dreapta.

Pentru acest exercitiu se va implementa un demux2 (cu 2 iesiri).

'''Observatie 1''': celelalte iesiri, cele neselectate iau valoarea 0.

'''Observatie 2''': numarul de iesiri maxim posibile este 2^(nr_biti_selectie)

Interfata demultiplexorului este data mai jos. Incercati sa construiti acest circuit in cat mai multe variante de sintaxa posibile (minim 4).

[[Fișier:demux2_general.png ‎| 300px]]

Generati forme de unda pentru a vedea functionarea demultiplexorului.

===Exercitiul 4: Sumatorul===

Sumatorul are rolul de a scoate la iesire suma celor 2 intrari.

Uzual el mai are si intrare si iesire de "carry" adica de transport (cand se depaseste baza de numarare si e nevoie de inca o cifra, ex in zecimal: 88 + 20 = 108; apare o cifra in plus, cifra sutelor).

[[Fișier:sumator_8b_general.png ‎| 300px]]

Observatie: desi scrierea cu assign si + este cea mai usoara si clara pentru un sumator, si celelalte moduri de scriere sunt posibile.
La aceasta scriere, daca se doresta ca sumatorul sa aiba carry out, sumatorul se poate face cu un bit mai mare decat intrarile, iar acel bit sa fie conectat la carry out. Practic, obtii un rezultat pe "n" biti + un bit de depasire, anume msb-ul.

Generati formele de unda necesare testarii sumatorului pe 8b.

Pentru a vedea pas cu pas cum se construieste un sumator pe 8b puteti parcurge urmatoarea platforma de laborator: [https://wiki.dcae.pub.ro/images/0/0f/Cid_gan_sumator_aplicatia_2.pdf Sumator.pdf]

===Exercitiul 5: Comparatorul===

Comparatorul are rolul de a vedea relatia dintre cele 2 intrari ale sale, daca cele 2 numere sunt egale, daca primul e mai mic sau mai mare.

Astfel el poate avea 3 iesiri dintre care se activeaza doar una:
:- iesire de egalitate
:- iesire de in0 < in1
:- iesire de in0 > in1

Se mai poate face si o varianta de comparator cu 2 iesiri, asa cum veti studia la arhitectura microprocesoarelor.
:- iesire de egalitate
:- iesire care este 0 daca in0<in1 sau 1 daca in0>in1

Aceasta abordare este folosita la AMP la flag-urile din procesoare, folosind operatia de scadere si flag-urile de "zero" si "negativ".

Scrieti modulul de comparator, in ambele variante de interfata. Intrarile pot avea oricat de multi biti (comparator mai mic sau mai mare), pentru acest exercitiu sa il faceti pe 4b.

Scrieti un testbench care sa genereze toate combinatiile posibile de date de la intrare.

'''Discutie''': Daca acest comparator are datele pe 32b sau mai mult (sau daca circuitul devine mult mai complex), nu se mai poate face o astfel de testare exhaustiva a combinatiilor posibile de date de la intrare pentru ca simularea ar dura prea mult. De situatia asta se ocupa inginerii de verificare ce lucreaza in paralel cu inginerii de design. Pentru mai multe detalii puteti cauta "constrained random functional verification". Incercati sa identificati cazurile/situatiile ce ar trebui testate pentru un comparator pe 32b inainte de a spune ca acesta functioneaza corect (minim 10).

CID aplicatii 2 : Instantiere si porti logice

2025-02-25T09:27:19Z

Mihai.antonescu: /* Exercitiul 3: AND4 din AND2 aranjat pe lung (nu arbore) */

==Teorie: incapsulare si instantiere==
Unitatile constructive de baza din care se formeaza circuitele digitale se numesc porti logice. Acestea implementeaza functii logice si prin conectarea mai multor astfel de circuite simple complexitatea unui circuit poate creste pana la nivelul procesoarelor actuale. Pentru a putea controla cresterea complexitatii in proiectarea unui circuit de dimensiuni mari se folosesc 2 concepte cheie:

1) incapsularea functiei dorite intr-un modul

2) instantierea unor module mai mici si asamblarea acestora pentru a forma un modul mai mare.

Incapsularea se refera la a grupa elementele ce alcatuiesc o anumita functionalitate intr-un modul. Aceste elemente pot la randul lor sa fie alte module.
Instantierea (asemanator cu POO) se refera la a apela un modul deja scris pentru a fi folosit efectiv in circuitul curent.
Pentru a face o analogie cu programarea, cand se declara o variabila (sau un obiect), tipul variabilei este echivalent cu modulul si numele ei este numele instantei.

Pentru a intelege aceste concepte se da circuitul de mai jos:

[[Fișier:schema_principiu_instantiere.png ‎| 800px]]

'''Observatii:'''

1) Notatie aici: Numele modulului este scris in interior.

2) Notatie aici: Numele instantei este scris deasupra.

3) Idee fundamentala: prin instantierea si incapsularea unor circuite simple, mici, apar circuite mai complexe.

4) Idei esentiale (daca vreuna e neclara consultati cadrul didactic):

:a) "modul_2" este instantiat o singura data in tot proiecul, iar instanta se cheama "x"

:b) "modul_2" are o intrare numita "in0" si o iesire numita "out0"

:c) "modul_2" este instantiat in cadrul "modul_6"

:d) Modulul cel mai mare, ce cuprinde toata functionalitatea dorita a sistemului (aici "modul_6") se numeste uzual top.

:e) Instanta top-ului care apare atunci cand se doreste testarea sa in simulare intr-un testbench (tb) se numeste uzual DUT (design under test)

:f) "modul_0" apare instantiat de 3 ori. Circuitul final, cuprinde 3 subcircuite de tip "modul_0".

:g) La nivel de top, instanta sa se cheama "b".

:h) La nivel de "modul_5", cele 2 instante se cheama "a" si "c".

:i) "a" si "c" sunt 2 circuite fizice diferite chiar daca ambele sunt de tipul "modul_0". Fiind instante ale aceluiasi modul, deci identice in alcatuire, luate separat ele fac acelasi lucru. Luate in contextul lui "modul_5", "a" genereaza datele de pe firul "w0" si "c" genereaza datele pentru iesire.

:j) circuitul "b" de tip "modul_1" (instantiat in "modul_5") este complet diferit de circuitul "b" de tip "modul_0" (instantiat in top). Este permis ca ele sa aiba acelasi nume (cele 2 instante) deoarece se afla in locatii diferite.

:k) Identic, mai multe module au o intrare numita "in_0". La sinteza circuitului nu se face confuzie intre acestea deoarece fiecare e vazut la nivelul altei instante.

:l) Identic, firele de legatura "w0", "w1".

:m) La nivelul "top", firul de legatura "w2" leaga iesirea "out_0" a instantei "b" la intrarea "in2" a instantei "y".

:n) La nivelul "top", firul de legatura "w1" leaga iesirea "out_0" a instantei "x" la intrarea "in1" a instantei "y".

:o) La nivelul "modul_5", firul de legatura "w1" leaga iesirea instantei "b" la intrarea instantei "c".

:Pentru claritatea desenului, respectivele intrari si iesiri nu au fost denumite. In cod este obligatoriu ca ele sa fie definite si denumite.

:p) La nivelul "top", "in0","in1","in2","in3","in4" si "out0" formeaza interfata modulului (semnalele care intra sau ies din modul).

:q) La nivelul "top", "w0", "w1", "w2" sunt fire interne de legatura.

:r) La nivelul "top", firul "in3" este conectat ca intrare pentru 3 submodule.

==Teorie: testarea circuitelor==
Pentru a se testa functionarea corecta a circuitului final, acesta este instantiat intr-un modul numit "test_bench" sau "tb". Acest modul este folosit strict in simulare.
Testarea unui circuit are loc conform schemei urmatoare:

[[Fișier:schema_principiu_tb.png ‎| 600px]]

Generarea datelor de intrare se va face asemanator cu laboratorul 1.

Voi veti avea rolul modelului ideal si al comparatorului datelor de iesire, uitandu-va la datele de intrare veti calcula iesirea corecta si apoi veti compara aceasta valoare cu raspunsul circuitului ce se testeaza.

In cazul unui sistem automat, se genereaza mesaje de eroare sau mesaje ca functionarea este in regula.

Observatie: proiectarea si verificarea sunt 2 domenii diferite, firmele avand departamente separate pentru acestea.

Proiectarea/Design se ocupa cu scrierea in Verilog/SystemVerilog a modului de top si toate modulele ce se afla in acesta, avand ca scop final realizarea fizica pe placa a unui circuit.

Verificarea se ocupa de scrierea in SystemVerilog (limbaj format din Verilog cu concepte de POO) a modului de testbench si generarea de stimuli si scenarii care sa testeze functionarea design-ului.

==Teorie: porti logice==
Portile logice folosite uzual, impreuna cu tabelele lor de adevar si reprezentarea grafica sunt date mai jos.

Se folosesc porti logice cu 1 sau 2 intrari, cele cu mai mult de 2 intrari fiind construite din acestea.

{| class="wikitable"
! Tip !! Simbol !! Tabel de adevăr !! Tip !! Simbol !! Tabel de adevăr
|-
| '''Buffer/Repetor'''
| [[Image:Buffer_gate.png|Buffer symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || A
|- bgcolor="#ddffdd" align="center"
|0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1
|}
| '''NOT'''
| [[Image:not.png|NOT symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || NOT A
|- bgcolor="#ddffdd" align="center"
|0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0
|}
|-
| '''AND'''
| [[Image:and.png|AND symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A AND B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 1
|}
| '''NAND'''
| [[Image:nand.png|NAND symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A NAND B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 0
|}
|-
| '''OR'''
| [[Image:or.png|OR symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A OR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 1
|}
| '''NOR'''
| [[Image:nor.png|NOR symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A NOR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 0
|}
|-
| '''XOR'''
| [[Image:xor.png|XOR symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A XOR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 0
|}
| '''XNOR'''
| [[Image:xnor.png|XNOR symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A XNOR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 1
|}
|}

==Despre FPGA==
FPGA-ul (Field-Programmable Gate Array) este un circuit programabil, capabil sa implementeze circuite definit de utilizator. El este format dintr-o matrice de blocuri programabile, interconectate intre ele printr-o serie de conexiuni la randul lor programabile.

Cand se doreste implementarea unui circuit pe FPGA, acesta urmeaza urmatoarele etape:

:'''Elaborarea''' este procesul prin care codul SystemVerilog este transformat intr-un circuit la nivel de porti si registre (netlist) si este independent de modelul de FPGA folosit.

:'''Sinteza''' este procesul în care se realizează transformarea circuitului descris într-un netlist dependent de tehnologie. Se vor folosi la acest pas primitivele disponibile pe FPGA.

:'''Implementarea''' este procesul în care se preia netlist-ul ce conține primitivele FPGA și modul lor de interconectare realizat la pasul de sinteză și se realizează maparea lor efectivă în FPGA (place and route).

:'''Generarea Bitstream-ului''' este procesul prin care informatiile din implementare sunt asamblate intr-un singur fisier.

:'''Programarea''' este procesul prin care fisierul generat anterior este trimis efectiv catre placa cu FPGA (prin USB) unde determina modificarea valorilor si conexiunilor interne din aceasta.

O introducere mai detaliata poate fi gasita aici : [[FPGA - Introducere]].

[[Fișier:Fpgaimg.PNG|600px]]

'''Observatii:'''
* Pentru a putea controla circuitul propus si a putea vedea rezultatele, intrarile si iesirile (input si output din module) in/din acesta trebuie conectate la pini fizici ai FPGA-ului care sunt conectati la butoane/switch-uri/leduri.
* Conexiunile dintre butoane/switch-uri si pinii FPGA sunt fixe. La fel si cele intre pinii FPGA si LED-uri. (in functie de PCB)
* Conexiunile dintre porturile modulului ''Module'' si pinii FPGA sunt configurabile. (in functie de noi, prin fisierul XDC)
* Legarea porturilor modulului ''Module'' la pinii fizici ai FPGA se realizeaza prin configurarea conexiunilor din FPGA conform contrangerilor de I/O pe care le vom mentiona in proiect, inainte de sinteza.

==Exemple==

===Exemplul 1: Analiza circuitelor cu porti===
Fie urmatorul circuit alcatuit din porti logice:
[[Fișier:Mux2_schema_interna_2.png ‎| 400px]]

Se doreste exprimarea circuitului de mai sus ca formula de tip: iesire = f(intrari).

Pentru asta, abordarea consta in a porni de la iesire si a merge pas cu pas catre intrari, asa cum este exemplificat mai jos. Se vor folosi simbolurile "~" pentru NOT, "&" pentru AND, "|" pentru OR.
:pas1: out0 = ?
:pas2: out0 = w1 | w2
:pas3: out0 = w1 | ( ? )
:pas4: out0 = w1 | ( sel & in1 )
:pas5: out0 = ( ? ) | ( sel & in1 )
:pas6: out0 = ( in0 & w0 ) | ( sel & in1 )
:pas7: out0 = ( in0 & ( ? ) ) | ( sel & in1 )
:pas8: out0 = ( in0 & (~sel) ) | ( sel & in1 )

===Exemplul 2: NAND2 din AND2 si NOT===
In urmatorul exemplu se implementeaza o poarta NAND din o poarta AND si o poarta NOT.

Codul de mai jos exemplifica ideea de instantiere si contine comentarii legate de sintaxa SystemVerilog necesara.

In mod uzual fisierele sunt denumite dupa modulul ce se afla in ele, in fiecare fisier fiind un singur modul.

Schema circuitul care se doreste a fi creat este:

[[Fișier:schema_exemplu_rezolvat.png ‎| 600px]]

'''Descrierea portii NOT (fisierul not_gate.sv):'''
<syntaxhighlight lang="Verilog">
// comentarii cu "//" sau cu /* .... */ ;
/*
ca in c/c++
*/

module not_gate // cuvant cheie "module" apoi numele modulului (asemanator clase din c++)
( // intre paranteze se pune interfata (firele care intra sau ies din modul)
input logic in0, // in0 este o intrare => input
output logic out0 // out0 este o intrare => output
); // aici ";" sa nu il uitati

assign out0 = ~in0; // cuvant cheie assign;
// semnalele pot lua valoare prin assign
// ~ e semnul pentru negatie pe biti (ca in c/c++)

endmodule // cuvant cheie "endmodule". orice module se inchide cu endmodule.
</syntaxhighlight>

'''Descrierea portii AND (fisierul and_gate.sv):'''
<syntaxhighlight lang="Verilog">
module and_gate
(
input logic in0, // aici sunt 2 intrari
input logic in1,
output logic out0
); // nu conteaza ordinea in care sunt puse intrarile si iesirile.
// uzual si pentru usurinta se ordoneaza si grupeaza dupa functionalitate
// in cazul de mai sus, am pus intai intrarile, apoi iesirile.

assign out0 = in0 & in1; // operatia propriu zisa

endmodule
</syntaxhighlight>

'''Descrierea modulului top (fisierul top.sv):'''
<syntaxhighlight lang="Verilog">

module top
(
input logic a,
input logic b,
output logic c
);

logic w0; //declarat un fir intern de legatura

and_gate and_gate_0 // instantiere: nume_modul nume_instanta (asemanator int x din c/c++)
(
.in0(a), // la intrarea "in0" a instantei "and_gate_0" se conecteaza firul "a" din top
.in1(b), // grija ca "in0", "in1", "out0" sa existe in declararea modulului "and_gate"
.out0(w0) // grija ca "a", "b", "w0" sa existe la nivelul modulului in care se face instantierea
);

not_gate not_gate_0
(
.in0(w0), // "w0" care iese din "and_gate_0" intra in "not_gate_0"
.out0(c) // "c" care iese din "not_gate_0" iese din modulul "top" (e iesire in interfata de sus)
); // se poate scrie si ".in0(w0),.out0(c)" dar se prefera fiecare fir pe randul sau (lizibilitate si loc de comentarii pt design-uri complexe)
// Observatie: la varianta de mai sus de instantiere, nu conteaza ordinea firelor.

/*
not_gate not_gate_0
( // se poate instantia si in forma prescurtata ca aici
w0, // in acest caz se pun conexiunile in ordinea in care sunt declarate intrarile si iesirile din modul
c // NU se recomanda stilul asta de instantiere
); // apar greseli frecvent la ordinea firelor si la numarul lor,
*/ // mai ales daca modulul e complex si are multe intrari si intrari

endmodule
</syntaxhighlight>

Echivalent se pot folosi si "primitive" SystemVerilog pentru scrierea top-ului.

Primitivele sunt circuite care exista deja in limbaj, folosite atunci cand se doreste o descriere structurala a circuitului.

In instantiere acestora, iesirea se pune prima, urmata de intrari.

'''Observatie:''' daca se doreste scrierea acestor porti de catre voi (ca mai sus), numele modulului nu trebuie sa fie un cuvant cheie ocupat de primitive.

'''Descrierea alternativa a modulului top (fisierul top_v2.sv):'''
<syntaxhighlight lang="Verilog">
module top_v2
(
input logic a,
input logic b,
output logic c
);

logic w0;

and and_gate_0(w0,a,b); // primitiva pentru poarta and
not not_gate_0(c,w0); // primitiva pentru poarta not

endmodule
</syntaxhighlight>

Fiind un modul simplu, intreaga functionalitate putea fi scrisa la nivel de "top" si simplificat ca mai jos.

'''Descrierea alternativa a modulului top (fisierul top_v3.sv):'''
<syntaxhighlight lang="Verilog">
module top_v3
(
input logic a,
input logic b,
output logic c
);

assign c = ~ (a & b); // a si b, negate

endmodule
</syntaxhighlight>

Testarea circuitul se face printr-un testbench, acesta fiind:

'''Descrierea testbench-ului (fisierul top_tb.sv):'''
<syntaxhighlight lang="Verilog">
`timescale 1ns / 1ps

module top_tb(); // din/in tb nu intra si iese nimic. niciodata.

logic a_tb;
logic b_tb;
logic c_tb;

top dut // instantierea modulului de tip "top" sub numele "dut"
(
.a(a_tb),
.b(b_tb),
.c(c_tb)
);

initial
begin // in loc de { ... } din c/c++, in SystemVerilog se pune begin ... end
#10; // dupa 10 unitati de timp
a_tb = 0; // a_tb ia valoarea 0
b_tb = 0;
#10; // dupa inca 10 unitati de timp, deci in total la 20
a_tb = 1;
b_tb = 0;
#10;
a_tb = 0;
b_tb = 1;
#10;
a_tb = 1;
b_tb = 1;
#10;
a_tb = 0;
b_tb = 0;

#20 $stop(); // oprirea simularii
end //end pentru initial

endmodule
</syntaxhighlight>

Formele de unda rezultate din simulare se pot vedea mai jos:

[[Fișier:exemplu_rezolvat_nand_forme_de_unda.png ‎| 800px]]

In chenarul verde se pot observa instantele din simulare.

Daca se doreste adaugarea de semnale noi pentru a fi vazute, se selecteaza modulul instantiat in care acestea se afla (chenar verde).

Apoi, din chenarul rosu se aleg semnalele si se adauga prin click dreapta->add to wave window.

Pentru o mai usoara vizualizare, semnalele se pot grupa asa cum se vede in chenarul mov prin click dreapta->new group.

Se observa o functionare corecta circuitului, acesta fiind o poarta NAND. El scoate "0" cand ambele semnale de intrare sunt "1" si scoate "1" in rest.

'''Implementarea circuitului pe FPGA'''

Dupa ce circuitul a fost testat in simulare, se doreste punerea sa fizica pe placa FPGA. Pentru aceasta, se tine cont de urmatoarele.

* Pentru a controla intrarile ''a'' si ''b'' ale circuitului '''top'', va trebui sa le conectam prin intermediul conexiunilor configurabile ale FPGA-ului la pini ce sunt mai departe conectati fizic la dispozitive ce pot controla valorile semnalelor (switch-uri, butoane).
* Pentru a observa valoarea iesirii, vom conecta semnalul de iesire ''c''la un dispozitiv de observare, cum ar fi un LED, care va fi aprins daca ''c'' este 1 si stins daca ''c'' este 0.

[[Fișier:NAND2 FPGA.png | 600px]]

Pentru a realiza conectarea porturilor modulului ''top'' la pinii fizici ai FPGA ce sunt conectati mai departe la componentele de pe placa, va trebui sa specificam in utilitarul de sinteza maparea porturilor la acestia. Maparea se realizeaza prin mentionarea codurilor pinilor la care dorim conexiunea si poata numele de '''constrangeri de I/O'''. Aceste coduri sunt mentionate in documentatia placii de dezvoltare cu FPGA (in cazul nostru, Boolean Board) si pot fi regasite si in pagina [[Boolean Board - Pinout]].

Conform schemei, la acest exemplu avem nevoie de codurile pinilor conectati mai departe la Switch0, Switch1 si LED0.

'''Observatie:''' Daca intrarile si iesirile ar fi semnale pe mai multi biti, fiecare bit al intrarilor va fi conectat la cate un switch/buton si fiecare bit al iesirii va fi conectat la un LED. Acest lucru este necesar deoarece switch-urile/butoanele pot avea doar doua stari (0 si 1) si astfel pot controla un singur bit. La fel, un LED poate avea doar doua stari (0 - stins si 1 - aprins) si poate afisa starea unui singur bit.

Dupa ce ati extras codurile necesare, urmati pasii descrisi in [[Tutorial_Vivado|tutorialul Vivado]].

Dupa programarea cu succes a placii, puteti testa functionalitatea circuitului prin modficarea valorilor switch-urilor si observarea starii LED-ului.

==Exercitii==
Pentru urmatoarele exercitii se doreste atat testarea designurilor prin simulare cat si punerea acestora pe placa. Legat de placa, intrarile vor fi conectate la butoane, iar iesirile la leduri. Se va consulta tabelul cu pini disponibili ([[Boolean Board - Pinout]].).

Exista moduri mai rapide de a scrie functionalitatea dorita (vezi exemplu), dar tema principala a acestui laborator este instantierea, asa ca sunteti rugati sa respectati desenele si sa instantiati fiecare poarta individual.

===Exercitiul 1: AND4 din AND2===

Acest exercitiu arata cum se construieste o poarta AND cu 4 intrari din porti AND mai simple, cu 2 intrari.
Iesirea acesteia va fi "1" doar daca toate intrarile sunt "1".

[[Fișier:schema_and4_din_and2.png ‎| 600px]]

Pentru testarea circuitului, generati in testbench urmatoarele forme de unda (liniile punctate reprezinta 5ns):

[[Fișier:Wavedrom_and4.png ‎| 500px]]

===Exercitiul 2: OR4 din OR2===

Asemanator cu exercitiul anterior, se poate construi si o poarta or cu 4 intrari din porti or cu 2 intrari.
Iesirea acesteia va fi "1" doar daca oricare din intrari (cel putin una) este "1".

Pentru testarea circuitului se folosesc formele de unda de la exercitiul 1.

[[Fișier:schema_or4_din_or2.png ‎| 600px]]

===Exercitiul 3: AND4 din AND2 aranjat in cascada (nu arbore)===

In multe cazuri, aceeasi functionalitate poate fi atinsa prin circuite care arata diferit.
O alta varianta de a face o poarta AND cu 4 intrari este prezentata mai jos.

Comparati cele 2 variante.

Pentru testarea circuitului se folosesc formele de unda de la exercitiul 1.

[[Fișier:schema_and4_din_and2_v2.png ‎| 600px]]

===Exercitiul 4: AND4 din NAND2===

Orice poarta logica de baza poate fi construita doar din porti NAND sau doar din porti NOR.

Desenati si implementati circuitul pentru o poarta AND4 din porti NAND cu 2 intrari.

Tip: Incercati intai sa generati o poarta AND2 din NAND2.

Pentru testarea circuitului se folosesc formele de unda de la exercitiul 1.

===Exercitiul 5: AND4 pe 4b din AND4 pe 1b===

Se pot face operatii logice si pe mai multi biti deodata prin punerea in paralel a mai multor porti cu o singura iesire.
Exemplu :
pentru intrarile 0011 si 1110 iesirea va fi 0010

Pentru exersarea instantierii si intelegerea circuitului din spatele operatilor multibit implementati acest circuit prin instantierea a 4 porti AND2 pe 1 bit intr-o poarta AND2 pe 4 biti.

[[Fișier:schema_and4_4b_din_and4_1b_v1.png ‎| 400px]]

Pentru testarea circuitului, generati in testbench urmatoarele forme de unda (liniile punctate reprezinta 5ns):

[[Fișier:Wavedrom_and4_4b.png ‎| 500px]]

Exista si un mod mai rapid si simplu de a scrie aceasta functionalitate, grupand intrarile si iesirile in "bus"-uri, ca in codul de mai jos.
Acest mod de a grupa firele este desenat mai jos.

[[Fișier:schema_and4_4b_din_and4_1b_v2.png ‎| 600px]]

Fisierul and4_4b.sv:
<syntaxhighlight lang="Verilog">
module and4_4b
(
input logic [3:0] in0, // in0 are 4b, de la bit 3 la bit 0 inclusiv
input logic [3:0] in1, // se noteaza msb:lsb (most significant bit: least significant bit) (echivalent cu conceptul de cifra sutelor, cifra unitatilor, pt binar)
input logic [3:0] in2,
input logic [3:0] in3,
output logic [3:0] out0
);

assign out0 = in0 & in1 & in2 & in3;

endmodule
</syntaxhighlight>

===Exercitiul 6: Desenati schemele logice pentru urmatoarele circuite:===

'''a) Schema 1'''
<syntaxhighlight lang="Verilog">
module schema1 (a, b, c, d, f);
input logic a, b, c, d;
output logic f, g;

logic w1;
logic w2;

and P1 ( w1, a, c );
or P2 ( f, w1, w2, d);
not P3 (w2, b);
and P4 (g, w1, b, d);
endmodule
</syntaxhighlight>

Observatie: In versiunea veche de verilog (si s-a pastrat si in cea curenta), se pot specifica directiile porturilor si in exteriorul parantezelor, ca mai sus.
Aceasta scriere NU este recomandata.

'''b) Schema 2'''
<syntaxhighlight lang="Verilog">
module schema2 (a, b, c, d, f);
input logic a, b, c, d;
output logic f;

logic w1, w2;

nand P1 ( w1, a, b ), P2 (w2, c, d);
and P3 ( f, w1, w2);
endmodule
</syntaxhighlight>

'''Observatie:''' asemanator cu C/C++, se pot face declaratii in aceeasi linie a mai multor "variabile", aici fire sau instante, cum se poate vedea la w1 si w2 (ambele fiind fire) sau la P1 si P2 (ambele fiind porti nand).
Aceasta scriere NU este recomandata.

CID aplicatii 2 : Instantiere si porti logice

2025-02-25T09:25:54Z

Mihai.antonescu: /* Exemplul 2: NAND2 din AND2 si NOT */

==Teorie: incapsulare si instantiere==
Unitatile constructive de baza din care se formeaza circuitele digitale se numesc porti logice. Acestea implementeaza functii logice si prin conectarea mai multor astfel de circuite simple complexitatea unui circuit poate creste pana la nivelul procesoarelor actuale. Pentru a putea controla cresterea complexitatii in proiectarea unui circuit de dimensiuni mari se folosesc 2 concepte cheie:

1) incapsularea functiei dorite intr-un modul

2) instantierea unor module mai mici si asamblarea acestora pentru a forma un modul mai mare.

Incapsularea se refera la a grupa elementele ce alcatuiesc o anumita functionalitate intr-un modul. Aceste elemente pot la randul lor sa fie alte module.
Instantierea (asemanator cu POO) se refera la a apela un modul deja scris pentru a fi folosit efectiv in circuitul curent.
Pentru a face o analogie cu programarea, cand se declara o variabila (sau un obiect), tipul variabilei este echivalent cu modulul si numele ei este numele instantei.

Pentru a intelege aceste concepte se da circuitul de mai jos:

[[Fișier:schema_principiu_instantiere.png ‎| 800px]]

'''Observatii:'''

1) Notatie aici: Numele modulului este scris in interior.

2) Notatie aici: Numele instantei este scris deasupra.

3) Idee fundamentala: prin instantierea si incapsularea unor circuite simple, mici, apar circuite mai complexe.

4) Idei esentiale (daca vreuna e neclara consultati cadrul didactic):

:a) "modul_2" este instantiat o singura data in tot proiecul, iar instanta se cheama "x"

:b) "modul_2" are o intrare numita "in0" si o iesire numita "out0"

:c) "modul_2" este instantiat in cadrul "modul_6"

:d) Modulul cel mai mare, ce cuprinde toata functionalitatea dorita a sistemului (aici "modul_6") se numeste uzual top.

:e) Instanta top-ului care apare atunci cand se doreste testarea sa in simulare intr-un testbench (tb) se numeste uzual DUT (design under test)

:f) "modul_0" apare instantiat de 3 ori. Circuitul final, cuprinde 3 subcircuite de tip "modul_0".

:g) La nivel de top, instanta sa se cheama "b".

:h) La nivel de "modul_5", cele 2 instante se cheama "a" si "c".

:i) "a" si "c" sunt 2 circuite fizice diferite chiar daca ambele sunt de tipul "modul_0". Fiind instante ale aceluiasi modul, deci identice in alcatuire, luate separat ele fac acelasi lucru. Luate in contextul lui "modul_5", "a" genereaza datele de pe firul "w0" si "c" genereaza datele pentru iesire.

:j) circuitul "b" de tip "modul_1" (instantiat in "modul_5") este complet diferit de circuitul "b" de tip "modul_0" (instantiat in top). Este permis ca ele sa aiba acelasi nume (cele 2 instante) deoarece se afla in locatii diferite.

:k) Identic, mai multe module au o intrare numita "in_0". La sinteza circuitului nu se face confuzie intre acestea deoarece fiecare e vazut la nivelul altei instante.

:l) Identic, firele de legatura "w0", "w1".

:m) La nivelul "top", firul de legatura "w2" leaga iesirea "out_0" a instantei "b" la intrarea "in2" a instantei "y".

:n) La nivelul "top", firul de legatura "w1" leaga iesirea "out_0" a instantei "x" la intrarea "in1" a instantei "y".

:o) La nivelul "modul_5", firul de legatura "w1" leaga iesirea instantei "b" la intrarea instantei "c".

:Pentru claritatea desenului, respectivele intrari si iesiri nu au fost denumite. In cod este obligatoriu ca ele sa fie definite si denumite.

:p) La nivelul "top", "in0","in1","in2","in3","in4" si "out0" formeaza interfata modulului (semnalele care intra sau ies din modul).

:q) La nivelul "top", "w0", "w1", "w2" sunt fire interne de legatura.

:r) La nivelul "top", firul "in3" este conectat ca intrare pentru 3 submodule.

==Teorie: testarea circuitelor==
Pentru a se testa functionarea corecta a circuitului final, acesta este instantiat intr-un modul numit "test_bench" sau "tb". Acest modul este folosit strict in simulare.
Testarea unui circuit are loc conform schemei urmatoare:

[[Fișier:schema_principiu_tb.png ‎| 600px]]

Generarea datelor de intrare se va face asemanator cu laboratorul 1.

Voi veti avea rolul modelului ideal si al comparatorului datelor de iesire, uitandu-va la datele de intrare veti calcula iesirea corecta si apoi veti compara aceasta valoare cu raspunsul circuitului ce se testeaza.

In cazul unui sistem automat, se genereaza mesaje de eroare sau mesaje ca functionarea este in regula.

Observatie: proiectarea si verificarea sunt 2 domenii diferite, firmele avand departamente separate pentru acestea.

Proiectarea/Design se ocupa cu scrierea in Verilog/SystemVerilog a modului de top si toate modulele ce se afla in acesta, avand ca scop final realizarea fizica pe placa a unui circuit.

Verificarea se ocupa de scrierea in SystemVerilog (limbaj format din Verilog cu concepte de POO) a modului de testbench si generarea de stimuli si scenarii care sa testeze functionarea design-ului.

==Teorie: porti logice==
Portile logice folosite uzual, impreuna cu tabelele lor de adevar si reprezentarea grafica sunt date mai jos.

Se folosesc porti logice cu 1 sau 2 intrari, cele cu mai mult de 2 intrari fiind construite din acestea.

{| class="wikitable"
! Tip !! Simbol !! Tabel de adevăr !! Tip !! Simbol !! Tabel de adevăr
|-
| '''Buffer/Repetor'''
| [[Image:Buffer_gate.png|Buffer symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || A
|- bgcolor="#ddffdd" align="center"
|0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1
|}
| '''NOT'''
| [[Image:not.png|NOT symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || NOT A
|- bgcolor="#ddffdd" align="center"
|0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0
|}
|-
| '''AND'''
| [[Image:and.png|AND symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A AND B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 1
|}
| '''NAND'''
| [[Image:nand.png|NAND symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A NAND B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 0
|}
|-
| '''OR'''
| [[Image:or.png|OR symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A OR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 1
|}
| '''NOR'''
| [[Image:nor.png|NOR symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A NOR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 0
|}
|-
| '''XOR'''
| [[Image:xor.png|XOR symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A XOR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 0
|}
| '''XNOR'''
| [[Image:xnor.png|XNOR symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A XNOR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 1
|}
|}

==Despre FPGA==
FPGA-ul (Field-Programmable Gate Array) este un circuit programabil, capabil sa implementeze circuite definit de utilizator. El este format dintr-o matrice de blocuri programabile, interconectate intre ele printr-o serie de conexiuni la randul lor programabile.

Cand se doreste implementarea unui circuit pe FPGA, acesta urmeaza urmatoarele etape:

:'''Elaborarea''' este procesul prin care codul SystemVerilog este transformat intr-un circuit la nivel de porti si registre (netlist) si este independent de modelul de FPGA folosit.

:'''Sinteza''' este procesul în care se realizează transformarea circuitului descris într-un netlist dependent de tehnologie. Se vor folosi la acest pas primitivele disponibile pe FPGA.

:'''Implementarea''' este procesul în care se preia netlist-ul ce conține primitivele FPGA și modul lor de interconectare realizat la pasul de sinteză și se realizează maparea lor efectivă în FPGA (place and route).

:'''Generarea Bitstream-ului''' este procesul prin care informatiile din implementare sunt asamblate intr-un singur fisier.

:'''Programarea''' este procesul prin care fisierul generat anterior este trimis efectiv catre placa cu FPGA (prin USB) unde determina modificarea valorilor si conexiunilor interne din aceasta.

O introducere mai detaliata poate fi gasita aici : [[FPGA - Introducere]].

[[Fișier:Fpgaimg.PNG|600px]]

'''Observatii:'''
* Pentru a putea controla circuitul propus si a putea vedea rezultatele, intrarile si iesirile (input si output din module) in/din acesta trebuie conectate la pini fizici ai FPGA-ului care sunt conectati la butoane/switch-uri/leduri.
* Conexiunile dintre butoane/switch-uri si pinii FPGA sunt fixe. La fel si cele intre pinii FPGA si LED-uri. (in functie de PCB)
* Conexiunile dintre porturile modulului ''Module'' si pinii FPGA sunt configurabile. (in functie de noi, prin fisierul XDC)
* Legarea porturilor modulului ''Module'' la pinii fizici ai FPGA se realizeaza prin configurarea conexiunilor din FPGA conform contrangerilor de I/O pe care le vom mentiona in proiect, inainte de sinteza.

==Exemple==

===Exemplul 1: Analiza circuitelor cu porti===
Fie urmatorul circuit alcatuit din porti logice:
[[Fișier:Mux2_schema_interna_2.png ‎| 400px]]

Se doreste exprimarea circuitului de mai sus ca formula de tip: iesire = f(intrari).

Pentru asta, abordarea consta in a porni de la iesire si a merge pas cu pas catre intrari, asa cum este exemplificat mai jos. Se vor folosi simbolurile "~" pentru NOT, "&" pentru AND, "|" pentru OR.
:pas1: out0 = ?
:pas2: out0 = w1 | w2
:pas3: out0 = w1 | ( ? )
:pas4: out0 = w1 | ( sel & in1 )
:pas5: out0 = ( ? ) | ( sel & in1 )
:pas6: out0 = ( in0 & w0 ) | ( sel & in1 )
:pas7: out0 = ( in0 & ( ? ) ) | ( sel & in1 )
:pas8: out0 = ( in0 & (~sel) ) | ( sel & in1 )

===Exemplul 2: NAND2 din AND2 si NOT===
In urmatorul exemplu se implementeaza o poarta NAND din o poarta AND si o poarta NOT.

Codul de mai jos exemplifica ideea de instantiere si contine comentarii legate de sintaxa SystemVerilog necesara.

In mod uzual fisierele sunt denumite dupa modulul ce se afla in ele, in fiecare fisier fiind un singur modul.

Schema circuitul care se doreste a fi creat este:

[[Fișier:schema_exemplu_rezolvat.png ‎| 600px]]

'''Descrierea portii NOT (fisierul not_gate.sv):'''
<syntaxhighlight lang="Verilog">
// comentarii cu "//" sau cu /* .... */ ;
/*
ca in c/c++
*/

module not_gate // cuvant cheie "module" apoi numele modulului (asemanator clase din c++)
( // intre paranteze se pune interfata (firele care intra sau ies din modul)
input logic in0, // in0 este o intrare => input
output logic out0 // out0 este o intrare => output
); // aici ";" sa nu il uitati

assign out0 = ~in0; // cuvant cheie assign;
// semnalele pot lua valoare prin assign
// ~ e semnul pentru negatie pe biti (ca in c/c++)

endmodule // cuvant cheie "endmodule". orice module se inchide cu endmodule.
</syntaxhighlight>

'''Descrierea portii AND (fisierul and_gate.sv):'''
<syntaxhighlight lang="Verilog">
module and_gate
(
input logic in0, // aici sunt 2 intrari
input logic in1,
output logic out0
); // nu conteaza ordinea in care sunt puse intrarile si iesirile.
// uzual si pentru usurinta se ordoneaza si grupeaza dupa functionalitate
// in cazul de mai sus, am pus intai intrarile, apoi iesirile.

assign out0 = in0 & in1; // operatia propriu zisa

endmodule
</syntaxhighlight>

'''Descrierea modulului top (fisierul top.sv):'''
<syntaxhighlight lang="Verilog">

module top
(
input logic a,
input logic b,
output logic c
);

logic w0; //declarat un fir intern de legatura

and_gate and_gate_0 // instantiere: nume_modul nume_instanta (asemanator int x din c/c++)
(
.in0(a), // la intrarea "in0" a instantei "and_gate_0" se conecteaza firul "a" din top
.in1(b), // grija ca "in0", "in1", "out0" sa existe in declararea modulului "and_gate"
.out0(w0) // grija ca "a", "b", "w0" sa existe la nivelul modulului in care se face instantierea
);

not_gate not_gate_0
(
.in0(w0), // "w0" care iese din "and_gate_0" intra in "not_gate_0"
.out0(c) // "c" care iese din "not_gate_0" iese din modulul "top" (e iesire in interfata de sus)
); // se poate scrie si ".in0(w0),.out0(c)" dar se prefera fiecare fir pe randul sau (lizibilitate si loc de comentarii pt design-uri complexe)
// Observatie: la varianta de mai sus de instantiere, nu conteaza ordinea firelor.

/*
not_gate not_gate_0
( // se poate instantia si in forma prescurtata ca aici
w0, // in acest caz se pun conexiunile in ordinea in care sunt declarate intrarile si iesirile din modul
c // NU se recomanda stilul asta de instantiere
); // apar greseli frecvent la ordinea firelor si la numarul lor,
*/ // mai ales daca modulul e complex si are multe intrari si intrari

endmodule
</syntaxhighlight>

Echivalent se pot folosi si "primitive" SystemVerilog pentru scrierea top-ului.

Primitivele sunt circuite care exista deja in limbaj, folosite atunci cand se doreste o descriere structurala a circuitului.

In instantiere acestora, iesirea se pune prima, urmata de intrari.

'''Observatie:''' daca se doreste scrierea acestor porti de catre voi (ca mai sus), numele modulului nu trebuie sa fie un cuvant cheie ocupat de primitive.

'''Descrierea alternativa a modulului top (fisierul top_v2.sv):'''
<syntaxhighlight lang="Verilog">
module top_v2
(
input logic a,
input logic b,
output logic c
);

logic w0;

and and_gate_0(w0,a,b); // primitiva pentru poarta and
not not_gate_0(c,w0); // primitiva pentru poarta not

endmodule
</syntaxhighlight>

Fiind un modul simplu, intreaga functionalitate putea fi scrisa la nivel de "top" si simplificat ca mai jos.

'''Descrierea alternativa a modulului top (fisierul top_v3.sv):'''
<syntaxhighlight lang="Verilog">
module top_v3
(
input logic a,
input logic b,
output logic c
);

assign c = ~ (a & b); // a si b, negate

endmodule
</syntaxhighlight>

Testarea circuitul se face printr-un testbench, acesta fiind:

'''Descrierea testbench-ului (fisierul top_tb.sv):'''
<syntaxhighlight lang="Verilog">
`timescale 1ns / 1ps

module top_tb(); // din/in tb nu intra si iese nimic. niciodata.

logic a_tb;
logic b_tb;
logic c_tb;

top dut // instantierea modulului de tip "top" sub numele "dut"
(
.a(a_tb),
.b(b_tb),
.c(c_tb)
);

initial
begin // in loc de { ... } din c/c++, in SystemVerilog se pune begin ... end
#10; // dupa 10 unitati de timp
a_tb = 0; // a_tb ia valoarea 0
b_tb = 0;
#10; // dupa inca 10 unitati de timp, deci in total la 20
a_tb = 1;
b_tb = 0;
#10;
a_tb = 0;
b_tb = 1;
#10;
a_tb = 1;
b_tb = 1;
#10;
a_tb = 0;
b_tb = 0;

#20 $stop(); // oprirea simularii
end //end pentru initial

endmodule
</syntaxhighlight>

Formele de unda rezultate din simulare se pot vedea mai jos:

[[Fișier:exemplu_rezolvat_nand_forme_de_unda.png ‎| 800px]]

In chenarul verde se pot observa instantele din simulare.

Daca se doreste adaugarea de semnale noi pentru a fi vazute, se selecteaza modulul instantiat in care acestea se afla (chenar verde).

Apoi, din chenarul rosu se aleg semnalele si se adauga prin click dreapta->add to wave window.

Pentru o mai usoara vizualizare, semnalele se pot grupa asa cum se vede in chenarul mov prin click dreapta->new group.

Se observa o functionare corecta circuitului, acesta fiind o poarta NAND. El scoate "0" cand ambele semnale de intrare sunt "1" si scoate "1" in rest.

'''Implementarea circuitului pe FPGA'''

Dupa ce circuitul a fost testat in simulare, se doreste punerea sa fizica pe placa FPGA. Pentru aceasta, se tine cont de urmatoarele.

* Pentru a controla intrarile ''a'' si ''b'' ale circuitului '''top'', va trebui sa le conectam prin intermediul conexiunilor configurabile ale FPGA-ului la pini ce sunt mai departe conectati fizic la dispozitive ce pot controla valorile semnalelor (switch-uri, butoane).
* Pentru a observa valoarea iesirii, vom conecta semnalul de iesire ''c''la un dispozitiv de observare, cum ar fi un LED, care va fi aprins daca ''c'' este 1 si stins daca ''c'' este 0.

[[Fișier:NAND2 FPGA.png | 600px]]

Pentru a realiza conectarea porturilor modulului ''top'' la pinii fizici ai FPGA ce sunt conectati mai departe la componentele de pe placa, va trebui sa specificam in utilitarul de sinteza maparea porturilor la acestia. Maparea se realizeaza prin mentionarea codurilor pinilor la care dorim conexiunea si poata numele de '''constrangeri de I/O'''. Aceste coduri sunt mentionate in documentatia placii de dezvoltare cu FPGA (in cazul nostru, Boolean Board) si pot fi regasite si in pagina [[Boolean Board - Pinout]].

Conform schemei, la acest exemplu avem nevoie de codurile pinilor conectati mai departe la Switch0, Switch1 si LED0.

'''Observatie:''' Daca intrarile si iesirile ar fi semnale pe mai multi biti, fiecare bit al intrarilor va fi conectat la cate un switch/buton si fiecare bit al iesirii va fi conectat la un LED. Acest lucru este necesar deoarece switch-urile/butoanele pot avea doar doua stari (0 si 1) si astfel pot controla un singur bit. La fel, un LED poate avea doar doua stari (0 - stins si 1 - aprins) si poate afisa starea unui singur bit.

Dupa ce ati extras codurile necesare, urmati pasii descrisi in [[Tutorial_Vivado|tutorialul Vivado]].

Dupa programarea cu succes a placii, puteti testa functionalitatea circuitului prin modficarea valorilor switch-urilor si observarea starii LED-ului.

==Exercitii==
Pentru urmatoarele exercitii se doreste atat testarea designurilor prin simulare cat si punerea acestora pe placa. Legat de placa, intrarile vor fi conectate la butoane, iar iesirile la leduri. Se va consulta tabelul cu pini disponibili ([[Boolean Board - Pinout]].).

Exista moduri mai rapide de a scrie functionalitatea dorita (vezi exemplu), dar tema principala a acestui laborator este instantierea, asa ca sunteti rugati sa respectati desenele si sa instantiati fiecare poarta individual.

===Exercitiul 1: AND4 din AND2===

Acest exercitiu arata cum se construieste o poarta AND cu 4 intrari din porti AND mai simple, cu 2 intrari.
Iesirea acesteia va fi "1" doar daca toate intrarile sunt "1".

[[Fișier:schema_and4_din_and2.png ‎| 600px]]

Pentru testarea circuitului, generati in testbench urmatoarele forme de unda (liniile punctate reprezinta 5ns):

[[Fișier:Wavedrom_and4.png ‎| 500px]]

===Exercitiul 2: OR4 din OR2===

Asemanator cu exercitiul anterior, se poate construi si o poarta or cu 4 intrari din porti or cu 2 intrari.
Iesirea acesteia va fi "1" doar daca oricare din intrari (cel putin una) este "1".

Pentru testarea circuitului se folosesc formele de unda de la exercitiul 1.

[[Fișier:schema_or4_din_or2.png ‎| 600px]]

===Exercitiul 3: AND4 din AND2 aranjat pe lung (nu arbore)===

In multe cazuri, aceeasi functionalitate poate fi atinsa prin circuite care arata diferit.
O alta varianta de a face o poarta AND cu 4 intrari este prezentata mai jos.

Comparati cele 2 variante.

Pentru testarea circuitului se folosesc formele de unda de la exercitiul 1.

[[Fișier:schema_and4_din_and2_v2.png ‎| 600px]]

===Exercitiul 4: AND4 din NAND2===

Orice poarta logica de baza poate fi construita doar din porti NAND sau doar din porti NOR.

Desenati si implementati circuitul pentru o poarta AND4 din porti NAND cu 2 intrari.

Tip: Incercati intai sa generati o poarta AND2 din NAND2.

Pentru testarea circuitului se folosesc formele de unda de la exercitiul 1.

===Exercitiul 5: AND4 pe 4b din AND4 pe 1b===

Se pot face operatii logice si pe mai multi biti deodata prin punerea in paralel a mai multor porti cu o singura iesire.
Exemplu :
pentru intrarile 0011 si 1110 iesirea va fi 0010

Pentru exersarea instantierii si intelegerea circuitului din spatele operatilor multibit implementati acest circuit prin instantierea a 4 porti AND2 pe 1 bit intr-o poarta AND2 pe 4 biti.

[[Fișier:schema_and4_4b_din_and4_1b_v1.png ‎| 400px]]

Pentru testarea circuitului, generati in testbench urmatoarele forme de unda (liniile punctate reprezinta 5ns):

[[Fișier:Wavedrom_and4_4b.png ‎| 500px]]

Exista si un mod mai rapid si simplu de a scrie aceasta functionalitate, grupand intrarile si iesirile in "bus"-uri, ca in codul de mai jos.
Acest mod de a grupa firele este desenat mai jos.

[[Fișier:schema_and4_4b_din_and4_1b_v2.png ‎| 600px]]

Fisierul and4_4b.sv:
<syntaxhighlight lang="Verilog">
module and4_4b
(
input logic [3:0] in0, // in0 are 4b, de la bit 3 la bit 0 inclusiv
input logic [3:0] in1, // se noteaza msb:lsb (most significant bit: least significant bit) (echivalent cu conceptul de cifra sutelor, cifra unitatilor, pt binar)
input logic [3:0] in2,
input logic [3:0] in3,
output logic [3:0] out0
);

assign out0 = in0 & in1 & in2 & in3;

endmodule
</syntaxhighlight>

===Exercitiul 6: Desenati schemele logice pentru urmatoarele circuite:===

'''a) Schema 1'''
<syntaxhighlight lang="Verilog">
module schema1 (a, b, c, d, f);
input logic a, b, c, d;
output logic f, g;

logic w1;
logic w2;

and P1 ( w1, a, c );
or P2 ( f, w1, w2, d);
not P3 (w2, b);
and P4 (g, w1, b, d);
endmodule
</syntaxhighlight>

Observatie: In versiunea veche de verilog (si s-a pastrat si in cea curenta), se pot specifica directiile porturilor si in exteriorul parantezelor, ca mai sus.
Aceasta scriere NU este recomandata.

'''b) Schema 2'''
<syntaxhighlight lang="Verilog">
module schema2 (a, b, c, d, f);
input logic a, b, c, d;
output logic f;

logic w1, w2;

nand P1 ( w1, a, b ), P2 (w2, c, d);
and P3 ( f, w1, w2);
endmodule
</syntaxhighlight>

'''Observatie:''' asemanator cu C/C++, se pot face declaratii in aceeasi linie a mai multor "variabile", aici fire sau instante, cum se poate vedea la w1 si w2 (ambele fiind fire) sau la P1 si P2 (ambele fiind porti nand).
Aceasta scriere NU este recomandata.

CID aplicatii 2 : Instantiere si porti logice

2025-02-25T09:19:36Z

Mihai.antonescu: /* Teorie: incapsulare si instantiere */

==Teorie: incapsulare si instantiere==
Unitatile constructive de baza din care se formeaza circuitele digitale se numesc porti logice. Acestea implementeaza functii logice si prin conectarea mai multor astfel de circuite simple complexitatea unui circuit poate creste pana la nivelul procesoarelor actuale. Pentru a putea controla cresterea complexitatii in proiectarea unui circuit de dimensiuni mari se folosesc 2 concepte cheie:

1) incapsularea functiei dorite intr-un modul

2) instantierea unor module mai mici si asamblarea acestora pentru a forma un modul mai mare.

Incapsularea se refera la a grupa elementele ce alcatuiesc o anumita functionalitate intr-un modul. Aceste elemente pot la randul lor sa fie alte module.
Instantierea (asemanator cu POO) se refera la a apela un modul deja scris pentru a fi folosit efectiv in circuitul curent.
Pentru a face o analogie cu programarea, cand se declara o variabila (sau un obiect), tipul variabilei este echivalent cu modulul si numele ei este numele instantei.

Pentru a intelege aceste concepte se da circuitul de mai jos:

[[Fișier:schema_principiu_instantiere.png ‎| 800px]]

'''Observatii:'''

1) Notatie aici: Numele modulului este scris in interior.

2) Notatie aici: Numele instantei este scris deasupra.

3) Idee fundamentala: prin instantierea si incapsularea unor circuite simple, mici, apar circuite mai complexe.

4) Idei esentiale (daca vreuna e neclara consultati cadrul didactic):

:a) "modul_2" este instantiat o singura data in tot proiecul, iar instanta se cheama "x"

:b) "modul_2" are o intrare numita "in0" si o iesire numita "out0"

:c) "modul_2" este instantiat in cadrul "modul_6"

:d) Modulul cel mai mare, ce cuprinde toata functionalitatea dorita a sistemului (aici "modul_6") se numeste uzual top.

:e) Instanta top-ului care apare atunci cand se doreste testarea sa in simulare intr-un testbench (tb) se numeste uzual DUT (design under test)

:f) "modul_0" apare instantiat de 3 ori. Circuitul final, cuprinde 3 subcircuite de tip "modul_0".

:g) La nivel de top, instanta sa se cheama "b".

:h) La nivel de "modul_5", cele 2 instante se cheama "a" si "c".

:i) "a" si "c" sunt 2 circuite fizice diferite chiar daca ambele sunt de tipul "modul_0". Fiind instante ale aceluiasi modul, deci identice in alcatuire, luate separat ele fac acelasi lucru. Luate in contextul lui "modul_5", "a" genereaza datele de pe firul "w0" si "c" genereaza datele pentru iesire.

:j) circuitul "b" de tip "modul_1" (instantiat in "modul_5") este complet diferit de circuitul "b" de tip "modul_0" (instantiat in top). Este permis ca ele sa aiba acelasi nume (cele 2 instante) deoarece se afla in locatii diferite.

:k) Identic, mai multe module au o intrare numita "in_0". La sinteza circuitului nu se face confuzie intre acestea deoarece fiecare e vazut la nivelul altei instante.

:l) Identic, firele de legatura "w0", "w1".

:m) La nivelul "top", firul de legatura "w2" leaga iesirea "out_0" a instantei "b" la intrarea "in2" a instantei "y".

:n) La nivelul "top", firul de legatura "w1" leaga iesirea "out_0" a instantei "x" la intrarea "in1" a instantei "y".

:o) La nivelul "modul_5", firul de legatura "w1" leaga iesirea instantei "b" la intrarea instantei "c".

:Pentru claritatea desenului, respectivele intrari si iesiri nu au fost denumite. In cod este obligatoriu ca ele sa fie definite si denumite.

:p) La nivelul "top", "in0","in1","in2","in3","in4" si "out0" formeaza interfata modulului (semnalele care intra sau ies din modul).

:q) La nivelul "top", "w0", "w1", "w2" sunt fire interne de legatura.

:r) La nivelul "top", firul "in3" este conectat ca intrare pentru 3 submodule.

==Teorie: testarea circuitelor==
Pentru a se testa functionarea corecta a circuitului final, acesta este instantiat intr-un modul numit "test_bench" sau "tb". Acest modul este folosit strict in simulare.
Testarea unui circuit are loc conform schemei urmatoare:

[[Fișier:schema_principiu_tb.png ‎| 600px]]

Generarea datelor de intrare se va face asemanator cu laboratorul 1.

Voi veti avea rolul modelului ideal si al comparatorului datelor de iesire, uitandu-va la datele de intrare veti calcula iesirea corecta si apoi veti compara aceasta valoare cu raspunsul circuitului ce se testeaza.

In cazul unui sistem automat, se genereaza mesaje de eroare sau mesaje ca functionarea este in regula.

Observatie: proiectarea si verificarea sunt 2 domenii diferite, firmele avand departamente separate pentru acestea.

Proiectarea/Design se ocupa cu scrierea in Verilog/SystemVerilog a modului de top si toate modulele ce se afla in acesta, avand ca scop final realizarea fizica pe placa a unui circuit.

Verificarea se ocupa de scrierea in SystemVerilog (limbaj format din Verilog cu concepte de POO) a modului de testbench si generarea de stimuli si scenarii care sa testeze functionarea design-ului.

==Teorie: porti logice==
Portile logice folosite uzual, impreuna cu tabelele lor de adevar si reprezentarea grafica sunt date mai jos.

Se folosesc porti logice cu 1 sau 2 intrari, cele cu mai mult de 2 intrari fiind construite din acestea.

{| class="wikitable"
! Tip !! Simbol !! Tabel de adevăr !! Tip !! Simbol !! Tabel de adevăr
|-
| '''Buffer/Repetor'''
| [[Image:Buffer_gate.png|Buffer symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || A
|- bgcolor="#ddffdd" align="center"
|0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1
|}
| '''NOT'''
| [[Image:not.png|NOT symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || NOT A
|- bgcolor="#ddffdd" align="center"
|0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0
|}
|-
| '''AND'''
| [[Image:and.png|AND symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A AND B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 1
|}
| '''NAND'''
| [[Image:nand.png|NAND symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A NAND B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 0
|}
|-
| '''OR'''
| [[Image:or.png|OR symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A OR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 1
|}
| '''NOR'''
| [[Image:nor.png|NOR symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A NOR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 0
|}
|-
| '''XOR'''
| [[Image:xor.png|XOR symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A XOR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 0
|}
| '''XNOR'''
| [[Image:xnor.png|XNOR symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A XNOR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 1
|}
|}

==Despre FPGA==
FPGA-ul (Field-Programmable Gate Array) este un circuit programabil, capabil sa implementeze circuite definit de utilizator. El este format dintr-o matrice de blocuri programabile, interconectate intre ele printr-o serie de conexiuni la randul lor programabile.

Cand se doreste implementarea unui circuit pe FPGA, acesta urmeaza urmatoarele etape:

:'''Elaborarea''' este procesul prin care codul SystemVerilog este transformat intr-un circuit la nivel de porti si registre (netlist) si este independent de modelul de FPGA folosit.

:'''Sinteza''' este procesul în care se realizează transformarea circuitului descris într-un netlist dependent de tehnologie. Se vor folosi la acest pas primitivele disponibile pe FPGA.

:'''Implementarea''' este procesul în care se preia netlist-ul ce conține primitivele FPGA și modul lor de interconectare realizat la pasul de sinteză și se realizează maparea lor efectivă în FPGA (place and route).

:'''Generarea Bitstream-ului''' este procesul prin care informatiile din implementare sunt asamblate intr-un singur fisier.

:'''Programarea''' este procesul prin care fisierul generat anterior este trimis efectiv catre placa cu FPGA (prin USB) unde determina modificarea valorilor si conexiunilor interne din aceasta.

O introducere mai detaliata poate fi gasita aici : [[FPGA - Introducere]].

[[Fișier:Fpgaimg.PNG|600px]]

'''Observatii:'''
* Pentru a putea controla circuitul propus si a putea vedea rezultatele, intrarile si iesirile (input si output din module) in/din acesta trebuie conectate la pini fizici ai FPGA-ului care sunt conectati la butoane/switch-uri/leduri.
* Conexiunile dintre butoane/switch-uri si pinii FPGA sunt fixe. La fel si cele intre pinii FPGA si LED-uri. (in functie de PCB)
* Conexiunile dintre porturile modulului ''Module'' si pinii FPGA sunt configurabile. (in functie de noi, prin fisierul XDC)
* Legarea porturilor modulului ''Module'' la pinii fizici ai FPGA se realizeaza prin configurarea conexiunilor din FPGA conform contrangerilor de I/O pe care le vom mentiona in proiect, inainte de sinteza.

==Exemple==

===Exemplul 1: Analiza circuitelor cu porti===
Fie urmatorul circuit alcatuit din porti logice:
[[Fișier:Mux2_schema_interna_2.png ‎| 400px]]

Se doreste exprimarea circuitului de mai sus ca formula de tip: iesire = f(intrari).

Pentru asta, abordarea consta in a porni de la iesire si a merge pas cu pas catre intrari, asa cum este exemplificat mai jos. Se vor folosi simbolurile "~" pentru NOT, "&" pentru AND, "|" pentru OR.
:pas1: out0 = ?
:pas2: out0 = w1 | w2
:pas3: out0 = w1 | ( ? )
:pas4: out0 = w1 | ( sel & in1 )
:pas5: out0 = ( ? ) | ( sel & in1 )
:pas6: out0 = ( in0 & w0 ) | ( sel & in1 )
:pas7: out0 = ( in0 & ( ? ) ) | ( sel & in1 )
:pas8: out0 = ( in0 & (~sel) ) | ( sel & in1 )

===Exemplul 2: NAND2 din AND2 si NOT===
In urmatorul exemplu se implementeaza o poarta NAND din o poarta AND si o poarta NOT.

Codul de mai jos exemplifica ideea de instantiere si contine comentarii legate de sintaxa SystemVerilog necesara.

In mod uzual fisierele sunt denumite dupa modulul ce se afla in ele, in fiecare fisier fiind un singur modul.

Schema circuitul care se doreste a fi creat este:

[[Fișier:schema_exemplu_rezolvat.png ‎| 600px]]

'''Descrierea portii NOT (fisierul not_gate.sv):'''
<syntaxhighlight lang="Verilog">
// comentarii cu "//" sau cu /* .... */ ;
/*
ca in c/c++
*/

module not_gate // cuvant cheie "module" apoi numele modulului (asemanator clase din c++)
( // intre paranteze se pune interfata (firele care intra sau ies din modul)
input logic in0, // in0 este o intrare => input
output logic out0 // out0 este o intrare => output
); // aici ";" sa nu il uitati

assign out0 = ~in0; // cuvant cheie assign;
// semnalele de tip wire (cum e out0) iau valoare prin assign
// ~ e semnul pentru negatie pe biti (ca in c/c++)

endmodule // cuvant cheie "endmodule". orice module se inchide cu endmodule.
</syntaxhighlight>

'''Descrierea portii AND (fisierul and_gate.sv):'''
<syntaxhighlight lang="Verilog">
module and_gate
(
input logic in0, // aici sunt 2 intrari
input logic in1,
output logic out0
); // nu conteaza ordinea in care sunt puse intrarile si iesirile.
// uzual si pentru usurinta se ordoneaza si grupeaza dupa functionalitate
// in cazul de mai sus, am pus intai intrarile, apoi iesirile.

assign out0 = in0 & in1; // operatia propriu zisa

endmodule
</syntaxhighlight>

'''Descrierea modulului top (fisierul top.sv):'''
<syntaxhighlight lang="Verilog">

module top
(
input logic a,
input logic b,
output logic c
);

logic w0; //declarat un fir intern de legatura

and_gate and_gate_0 // instantiere: nume_modul nume_instanta (asemanator int x din c/c++)
(
.in0(a), // la intrarea "in0" a instantei "and_gate_0" se conecteaza firul "a" din top
.in1(b), // grija ca "in0", "in1", "out0" sa existe in declararea modulului "and_gate"
.out0(w0) // grija ca "a", "b", "w0" sa existe la nivelul modulului in care se face instantierea
);

not_gate not_gate_0
(
.in0(w0), // "w0" care iese din "and_gate_0" intra in "not_gate_0"
.out0(c) // "c" care iese din "not_gate_0" iese din modulul "top" (e iesire in interfata de sus)
); // se poate scrie si ".in0(w0),.out0(c)" dar se prefera fiecare fir pe randul sau (lizibilitate si loc de comentarii pt design-uri complexe)
// Observatie: la varianta de mai sus de instantiere, nu conteaza ordinea firelor.

/*
not_gate not_gate_0
( // se poate instantia si in forma prescurtata ca aici
w0, // in acest caz se pun conexiunile in ordinea in care sunt declarate intrarile si iesirile din modul
c // NU se recomanda stilul asta de instantiere
); // apar greseli frecvent la ordinea firelor, la numarul lor,
*/ // mai ales daca modulul e complex si are multe intrari si intrari

endmodule
</syntaxhighlight>

Echivalent se pot folosi si "primitive" SystemVerilog pentru scrierea top-ului.

Primitivele sunt porti logice care exista deja in limbaj, folosite atunci cand se doreste o descriere structurala a circuitului.

In instantiere acestora, iesirea se pune prima, urmata de intrari.

'''Observatie:''' daca se doreste scrierea acestor porti de catre voi (ca mai sus), numele modulului nu trebuie sa fie un cuvant cheie ocupat de primitive.

'''Descrierea alternativa a modulului top (fisierul top_v2.sv):'''
<syntaxhighlight lang="Verilog">
module top_v2
(
input logic a,
input logic b,
output logic c
);

wire w0;

and and_gate_0(w0,a,b); // primitiva pentru poarta and
not not_gate_0(c,w0); // primitiva pentru poarta not

endmodule
</syntaxhighlight>

Fiind un modul simplu, intreaga functionalitate putea fi scrisa la nivel de "top" si simplificat ca mai jos.

'''Descrierea alternativa a modulului top (fisierul top_v3.sv):'''
<syntaxhighlight lang="Verilog">
module top_v3
(
input logic a,
input logic b,
output logic c
);

assign c = ~ (a & b); // a si b, negate

endmodule
</syntaxhighlight>

Testarea circuitul se face printr-un testbench, acesta fiind:

'''Descrierea testbench-ului (fisierul top_tb.sv):'''
<syntaxhighlight lang="Verilog">
`timescale 1ns / 1ps

module top_tb(); // din/in tb nu intra si iese nimic. niciodata.

logic a_tb;
logic b_tb;
logic c_tb;

top dut // instantierea modulului de tip "top" sub numele "dut"
(
.a(a_tb),
.b(b_tb),
.c(c_tb)
);

initial
begin // in loc de { ... } din c/c++, in SystemVerilog se pune begin ... end
#10; // dupa 10 unitati de timp
a_tb = 0; // a_tb ia valoarea 0
b_tb = 0;
#10; // dupa inca 10 unitati de timp, deci in total la 20
a_tb = 1;
b_tb = 0;
#10;
a_tb = 0;
b_tb = 1;
#10;
a_tb = 1;
b_tb = 1;
#10;
a_tb = 0;
b_tb = 0;

#20 $stop(); // oprirea simularii
end //end pentru initial

endmodule
</syntaxhighlight>

Formele de unda rezultate din simulare se pot vedea mai jos:

[[Fișier:exemplu_rezolvat_nand_forme_de_unda.png ‎| 800px]]

In chenarul verde se pot observa instantele din simulare.

Daca se doreste adaugarea de semnale noi pentru a fi vazute, se selecteaza modulul instantiat in care acestea se afla (chenar verde).

Apoi, din chenarul rosu se aleg semnalele si se adauga prin click dreapta->add to wave window.

Pentru o mai usoara vizualizare, semnalele se pot grupa asa cum se vede in chenarul mov prin click dreapta->new group.

Se observa o functionare corecta circuitului, acesta fiind o poarta NAND. El scoate "0" cand ambele semnale de intrare sunt "1" si scoate "1" in rest.

'''Implementarea circuitului pe FPGA'''

Dupa ce circuitul a fost testat in simulare, se doreste punerea sa fizica pe placa FPGA. Pentru aceasta, se tine cont de urmatoarele.

* Pentru a controla intrarile ''a'' si ''b'' ale circuitului '''top'', va trebui sa le conectam prin intermediul conexiunilor configurabile ale FPGA-ului la pini ce sunt mai departe conectati fizic la dispozitive ce pot controla valorile semnalelor (switch-uri, butoane).
* Pentru a observa valoarea iesirii, vom conecta semnalul de iesire ''c''la un dispozitiv de observare, cum ar fi un LED, care va fi aprins daca ''c'' este 1 si stins daca ''c'' este 0.

[[Fișier:NAND2 FPGA.png | 600px]]

Pentru a realiza conectarea porturilor modulului ''top'' la pinii fizici ai FPGA ce sunt conectati mai departe la componentele de pe placa, va trebui sa specificam in utilitarul de sinteza maparea porturilor la acestia. Maparea se realizeaza prin mentionarea codurilor pinilor la care dorim conexiunea si poata numele de '''constrangeri de I/O'''. Aceste coduri sunt mentionate in documentatia placii de dezvoltare cu FPGA (in cazul nostru, Boolean Board) si pot fi regasite si in pagina [[Boolean Board - Pinout]].

Conform schemei, la acest exemplu avem nevoie de codurile pinilor conectati mai departe la Switch0, Switch1 si LED0.

'''Observatie:''' Daca intrarile si iesirile ar fi semnale pe mai multi biti, fiecare bit al intrarilor va fi conectat la cate un switch/buton si fiecare bit al iesirii va fi conectat la un LED. Acest lucru este necesar deoarece switch-urile/butoanele pot avea doar doua stari (0 si 1) si astfel pot controla un singur bit. La fel, un LED poate avea doar doua stari (0 - stins si 1 - aprins) si poate afisa starea unui singur bit.

Dupa ce ati extras codurile necesare, urmati pasii descrisi in [[Tutorial_Vivado|tutorialul Vivado]].

Dupa programarea cu succes a placii, puteti testa functionalitatea circuitului prin modficarea valorilor switch-urilor si observarea starii LED-ului.

==Exercitii==
Pentru urmatoarele exercitii se doreste atat testarea designurilor prin simulare cat si punerea acestora pe placa. Legat de placa, intrarile vor fi conectate la butoane, iar iesirile la leduri. Se va consulta tabelul cu pini disponibili ([[Boolean Board - Pinout]].).

Exista moduri mai rapide de a scrie functionalitatea dorita (vezi exemplu), dar tema principala a acestui laborator este instantierea, asa ca sunteti rugati sa respectati desenele si sa instantiati fiecare poarta individual.

===Exercitiul 1: AND4 din AND2===

Acest exercitiu arata cum se construieste o poarta AND cu 4 intrari din porti AND mai simple, cu 2 intrari.
Iesirea acesteia va fi "1" doar daca toate intrarile sunt "1".

[[Fișier:schema_and4_din_and2.png ‎| 600px]]

Pentru testarea circuitului, generati in testbench urmatoarele forme de unda (liniile punctate reprezinta 5ns):

[[Fișier:Wavedrom_and4.png ‎| 500px]]

===Exercitiul 2: OR4 din OR2===

Asemanator cu exercitiul anterior, se poate construi si o poarta or cu 4 intrari din porti or cu 2 intrari.
Iesirea acesteia va fi "1" doar daca oricare din intrari (cel putin una) este "1".

Pentru testarea circuitului se folosesc formele de unda de la exercitiul 1.

[[Fișier:schema_or4_din_or2.png ‎| 600px]]

===Exercitiul 3: AND4 din AND2 aranjat pe lung (nu arbore)===

In multe cazuri, aceeasi functionalitate poate fi atinsa prin circuite care arata diferit.
O alta varianta de a face o poarta AND cu 4 intrari este prezentata mai jos.

Comparati cele 2 variante.

Pentru testarea circuitului se folosesc formele de unda de la exercitiul 1.

[[Fișier:schema_and4_din_and2_v2.png ‎| 600px]]

===Exercitiul 4: AND4 din NAND2===

Orice poarta logica de baza poate fi construita doar din porti NAND sau doar din porti NOR.

Desenati si implementati circuitul pentru o poarta AND4 din porti NAND cu 2 intrari.

Tip: Incercati intai sa generati o poarta AND2 din NAND2.

Pentru testarea circuitului se folosesc formele de unda de la exercitiul 1.

===Exercitiul 5: AND4 pe 4b din AND4 pe 1b===

Se pot face operatii logice si pe mai multi biti deodata prin punerea in paralel a mai multor porti cu o singura iesire.
Exemplu :
pentru intrarile 0011 si 1110 iesirea va fi 0010

Pentru exersarea instantierii si intelegerea circuitului din spatele operatilor multibit implementati acest circuit prin instantierea a 4 porti AND2 pe 1 bit intr-o poarta AND2 pe 4 biti.

[[Fișier:schema_and4_4b_din_and4_1b_v1.png ‎| 400px]]

Pentru testarea circuitului, generati in testbench urmatoarele forme de unda (liniile punctate reprezinta 5ns):

[[Fișier:Wavedrom_and4_4b.png ‎| 500px]]

Exista si un mod mai rapid si simplu de a scrie aceasta functionalitate, grupand intrarile si iesirile in "bus"-uri, ca in codul de mai jos.
Acest mod de a grupa firele este desenat mai jos.

[[Fișier:schema_and4_4b_din_and4_1b_v2.png ‎| 600px]]

Fisierul and4_4b.sv:
<syntaxhighlight lang="Verilog">
module and4_4b
(
input logic [3:0] in0, // in0 are 4b, de la bit 3 la bit 0 inclusiv
input logic [3:0] in1, // se noteaza msb:lsb (most significant bit: least significant bit) (echivalent cu conceptul de cifra sutelor, cifra unitatilor, pt binar)
input logic [3:0] in2,
input logic [3:0] in3,
output logic [3:0] out0
);

assign out0 = in0 & in1 & in2 & in3;

endmodule
</syntaxhighlight>

===Exercitiul 6: Desenati schemele logice pentru urmatoarele circuite:===

'''a) Schema 1'''
<syntaxhighlight lang="Verilog">
module schema1 (a, b, c, d, f);
input logic a, b, c, d;
output logic f, g;

logic w1;
logic w2;

and P1 ( w1, a, c );
or P2 ( f, w1, w2, d);
not P3 (w2, b);
and P4 (g, w1, b, d);
endmodule
</syntaxhighlight>

Observatie: In versiunea veche de verilog (si s-a pastrat si in cea curenta), se pot specifica directiile porturilor si in exteriorul parantezelor, ca mai sus.
Aceasta scriere NU este recomandata.

'''b) Schema 2'''
<syntaxhighlight lang="Verilog">
module schema2 (a, b, c, d, f);
input logic a, b, c, d;
output logic f;

logic w1, w2;

nand P1 ( w1, a, b ), P2 (w2, c, d);
and P3 ( f, w1, w2);
endmodule
</syntaxhighlight>

'''Observatie:''' asemanator cu C/C++, se pot face declaratii in aceeasi linie a mai multor "variabile", aici fire sau instante, cum se poate vedea la w1 si w2 (ambele fiind fire) sau la P1 si P2 (ambele fiind porti nand).
Aceasta scriere NU este recomandata.

CID aplicatii 2 : Instantiere si porti logice

2025-02-25T09:16:35Z

Mihai.antonescu:

==Teorie: incapsulare si instantiere==
Unitatile constructive de baza din care se formeaza circuitele digitale se numesc porti logice. Acestea implementeaza functii logice si prin conectarea mai multor astfel de circuite simple complexitatea unui circuit poate creste pana la nivelul procesoarelor actuale. Pentru a putea controla cresterea complexitatii in proiectarea unui circuit de dimensiuni mari se folosesc 2 concepte cheie:

1) incapsularea functiei dorite intr-un modul

2) instantierea unor module mai mici si asamblarea acestora pentru a forma un modul mai mare.

Incapsularea se refera la a grupa elementele ce alcatuiesc o anumita functionalitate intre-un modul. Aceste elemente pot la randul lor sa fie alte module.
Instantierea (asemanator cu POO) se refera la a apela un modul deja scris pentru a fi folosit efectiv in circuitul curent.
Pentru a face o analogie cu programarea, cand se declara o variabila (sau un obiect), tipul variabilei este echivalent cu modulul si numele ei este numele instantei.

Pentru a intelege aceste concepte se da circuitul de mai jos:

[[Fișier:schema_principiu_instantiere.png ‎| 800px]]

'''Observatii:'''

1) Notatie aici: Numele modulului este scris in interior.

2) Notatie aici: Numele instantei este scris deasupra.

3) Idee fundamentala: prin instantierea si incapsularea unor circuite simple, mici, apar circuite mai complexe.

4) Idei esentiale (daca vreuna e neclara consultati cadrul didactic):

:a) "modul_2" este instantiat o singura data in tot proiecul, iar instanta se cheama "x"

:b) "modul_2" are o intrare numita "in0" si o iesire numita "out0"

:c) "modul_2" este instantiat in cadrul "modul_6"

:d) Modulul cel mai mare, ce cuprinde toata functionalitatea dorita a sistemului (aici "modul_6") se numeste uzual top.

:e) Instanta top-ului care apare atunci cand se doreste testarea sa in simulare intr-un testbench (tb) se numeste uzual DUT (design under test)

:f) "modul_0" apare instantiat de 3 ori. Circuitul final, cuprinde 3 subcircuite de tip "modul_0".

:g) La nivel de top, instanta sa se cheama "b".

:h) La nivel de "modul_5", cele 2 instante se cheama "a" si "c".

:i) "a" si "c" sunt 2 circuite fizice diferite chiar daca ambele sunt de tipul "modul_0". Fiind instante ale aceluiasi modul, deci identice in alcatuire, luate separat ele fac acelasi lucru. Luate in contextul lui "modul_5", "a" genereaza datele de pe firul "w0" si "c" genereaza datele pentru iesire.

:j) circuitul "b" de tip "modul_1" (instantiat in "modul_5") este complet diferit de circuitul "b" de tip "modul_0" (instantiat in top). Este permis ca ele sa aiba acelasi nume (cele 2 instante) deoarece se afla in locatii diferite.

:k) Identic, mai multe module au o intrare numita "in_0". La sinteza circuitului nu se face confuzie intre acestea deoarece fiecare e vazut la nivelul altei instante.

:l) Identic, firele de legatura "w0", "w1".

:m) La nivelul "top", firul de legatura "w2" leaga iesirea "out_0" a instantei "b" la intrarea "in2" a instantei "y".

:n) La nivelul "top", firul de legatura "w1" leaga iesirea "out_0" a instantei "x" la intrarea "in1" a instantei "y".

:o) La nivelul "modul_5", firul de legatura "w1" leaga iesirea instantei "b" la intrarea instantei "c".

:Pentru claritatea desenului, respectivele intrari si iesiri nu au fost denumite. In cod este obligatoriu ca ele sa fie definite si denumite.

:p) La nivelul "top", "in0","in1","in2","in3","in4" si "out0" formeaza interfata modulului (semnalele care intra sau ies din modul).

:q) La nivelul "top", "w0", "w1", "w2" sunt fire interne de legatura.

:r) La nivelul "top", firul "in3" este conectat ca intrare pentru 3 submodule.

==Teorie: testarea circuitelor==
Pentru a se testa functionarea corecta a circuitului final, acesta este instantiat intr-un modul numit "test_bench" sau "tb". Acest modul este folosit strict in simulare.
Testarea unui circuit are loc conform schemei urmatoare:

[[Fișier:schema_principiu_tb.png ‎| 600px]]

Generarea datelor de intrare se va face asemanator cu laboratorul 1.

Voi veti avea rolul modelului ideal si al comparatorului datelor de iesire, uitandu-va la datele de intrare veti calcula iesirea corecta si apoi veti compara aceasta valoare cu raspunsul circuitului ce se testeaza.

In cazul unui sistem automat, se genereaza mesaje de eroare sau mesaje ca functionarea este in regula.

Observatie: proiectarea si verificarea sunt 2 domenii diferite, firmele avand departamente separate pentru acestea.

Proiectarea/Design se ocupa cu scrierea in Verilog/SystemVerilog a modului de top si toate modulele ce se afla in acesta, avand ca scop final realizarea fizica pe placa a unui circuit.

Verificarea se ocupa de scrierea in SystemVerilog (limbaj format din Verilog cu concepte de POO) a modului de testbench si generarea de stimuli si scenarii care sa testeze functionarea design-ului.

==Teorie: porti logice==
Portile logice folosite uzual, impreuna cu tabelele lor de adevar si reprezentarea grafica sunt date mai jos.

Se folosesc porti logice cu 1 sau 2 intrari, cele cu mai mult de 2 intrari fiind construite din acestea.

{| class="wikitable"
! Tip !! Simbol !! Tabel de adevăr !! Tip !! Simbol !! Tabel de adevăr
|-
| '''Buffer/Repetor'''
| [[Image:Buffer_gate.png|Buffer symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || A
|- bgcolor="#ddffdd" align="center"
|0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1
|}
| '''NOT'''
| [[Image:not.png|NOT symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || NOT A
|- bgcolor="#ddffdd" align="center"
|0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0
|}
|-
| '''AND'''
| [[Image:and.png|AND symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A AND B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 1
|}
| '''NAND'''
| [[Image:nand.png|NAND symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A NAND B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 0
|}
|-
| '''OR'''
| [[Image:or.png|OR symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A OR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 1
|}
| '''NOR'''
| [[Image:nor.png|NOR symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A NOR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 0
|}
|-
| '''XOR'''
| [[Image:xor.png|XOR symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A XOR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 0
|}
| '''XNOR'''
| [[Image:xnor.png|XNOR symbol]]
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A XNOR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 1
|}
|}

==Despre FPGA==
FPGA-ul (Field-Programmable Gate Array) este un circuit programabil, capabil sa implementeze circuite definit de utilizator. El este format dintr-o matrice de blocuri programabile, interconectate intre ele printr-o serie de conexiuni la randul lor programabile.

Cand se doreste implementarea unui circuit pe FPGA, acesta urmeaza urmatoarele etape:

:'''Elaborarea''' este procesul prin care codul SystemVerilog este transformat intr-un circuit la nivel de porti si registre (netlist) si este independent de modelul de FPGA folosit.

:'''Sinteza''' este procesul în care se realizează transformarea circuitului descris într-un netlist dependent de tehnologie. Se vor folosi la acest pas primitivele disponibile pe FPGA.

:'''Implementarea''' este procesul în care se preia netlist-ul ce conține primitivele FPGA și modul lor de interconectare realizat la pasul de sinteză și se realizează maparea lor efectivă în FPGA (place and route).

:'''Generarea Bitstream-ului''' este procesul prin care informatiile din implementare sunt asamblate intr-un singur fisier.

:'''Programarea''' este procesul prin care fisierul generat anterior este trimis efectiv catre placa cu FPGA (prin USB) unde determina modificarea valorilor si conexiunilor interne din aceasta.

O introducere mai detaliata poate fi gasita aici : [[FPGA - Introducere]].

[[Fișier:Fpgaimg.PNG|600px]]

'''Observatii:'''
* Pentru a putea controla circuitul propus si a putea vedea rezultatele, intrarile si iesirile (input si output din module) in/din acesta trebuie conectate la pini fizici ai FPGA-ului care sunt conectati la butoane/switch-uri/leduri.
* Conexiunile dintre butoane/switch-uri si pinii FPGA sunt fixe. La fel si cele intre pinii FPGA si LED-uri. (in functie de PCB)
* Conexiunile dintre porturile modulului ''Module'' si pinii FPGA sunt configurabile. (in functie de noi, prin fisierul XDC)
* Legarea porturilor modulului ''Module'' la pinii fizici ai FPGA se realizeaza prin configurarea conexiunilor din FPGA conform contrangerilor de I/O pe care le vom mentiona in proiect, inainte de sinteza.

==Exemple==

===Exemplul 1: Analiza circuitelor cu porti===
Fie urmatorul circuit alcatuit din porti logice:
[[Fișier:Mux2_schema_interna_2.png ‎| 400px]]

Se doreste exprimarea circuitului de mai sus ca formula de tip: iesire = f(intrari).

Pentru asta, abordarea consta in a porni de la iesire si a merge pas cu pas catre intrari, asa cum este exemplificat mai jos. Se vor folosi simbolurile "~" pentru NOT, "&" pentru AND, "|" pentru OR.
:pas1: out0 = ?
:pas2: out0 = w1 | w2
:pas3: out0 = w1 | ( ? )
:pas4: out0 = w1 | ( sel & in1 )
:pas5: out0 = ( ? ) | ( sel & in1 )
:pas6: out0 = ( in0 & w0 ) | ( sel & in1 )
:pas7: out0 = ( in0 & ( ? ) ) | ( sel & in1 )
:pas8: out0 = ( in0 & (~sel) ) | ( sel & in1 )

===Exemplul 2: NAND2 din AND2 si NOT===
In urmatorul exemplu se implementeaza o poarta NAND din o poarta AND si o poarta NOT.

Codul de mai jos exemplifica ideea de instantiere si contine comentarii legate de sintaxa SystemVerilog necesara.

In mod uzual fisierele sunt denumite dupa modulul ce se afla in ele, in fiecare fisier fiind un singur modul.

Schema circuitul care se doreste a fi creat este:

[[Fișier:schema_exemplu_rezolvat.png ‎| 600px]]

'''Descrierea portii NOT (fisierul not_gate.sv):'''
<syntaxhighlight lang="Verilog">
// comentarii cu "//" sau cu /* .... */ ;
/*
ca in c/c++
*/

module not_gate // cuvant cheie "module" apoi numele modulului (asemanator clase din c++)
( // intre paranteze se pune interfata (firele care intra sau ies din modul)
input logic in0, // in0 este o intrare => input
output logic out0 // out0 este o intrare => output
); // aici ";" sa nu il uitati

assign out0 = ~in0; // cuvant cheie assign;
// semnalele de tip wire (cum e out0) iau valoare prin assign
// ~ e semnul pentru negatie pe biti (ca in c/c++)

endmodule // cuvant cheie "endmodule". orice module se inchide cu endmodule.
</syntaxhighlight>

'''Descrierea portii AND (fisierul and_gate.sv):'''
<syntaxhighlight lang="Verilog">
module and_gate
(
input logic in0, // aici sunt 2 intrari
input logic in1,
output logic out0
); // nu conteaza ordinea in care sunt puse intrarile si iesirile.
// uzual si pentru usurinta se ordoneaza si grupeaza dupa functionalitate
// in cazul de mai sus, am pus intai intrarile, apoi iesirile.

assign out0 = in0 & in1; // operatia propriu zisa

endmodule
</syntaxhighlight>

'''Descrierea modulului top (fisierul top.sv):'''
<syntaxhighlight lang="Verilog">

module top
(
input logic a,
input logic b,
output logic c
);

logic w0; //declarat un fir intern de legatura

and_gate and_gate_0 // instantiere: nume_modul nume_instanta (asemanator int x din c/c++)
(
.in0(a), // la intrarea "in0" a instantei "and_gate_0" se conecteaza firul "a" din top
.in1(b), // grija ca "in0", "in1", "out0" sa existe in declararea modulului "and_gate"
.out0(w0) // grija ca "a", "b", "w0" sa existe la nivelul modulului in care se face instantierea
);

not_gate not_gate_0
(
.in0(w0), // "w0" care iese din "and_gate_0" intra in "not_gate_0"
.out0(c) // "c" care iese din "not_gate_0" iese din modulul "top" (e iesire in interfata de sus)
); // se poate scrie si ".in0(w0),.out0(c)" dar se prefera fiecare fir pe randul sau (lizibilitate si loc de comentarii pt design-uri complexe)
// Observatie: la varianta de mai sus de instantiere, nu conteaza ordinea firelor.

/*
not_gate not_gate_0
( // se poate instantia si in forma prescurtata ca aici
w0, // in acest caz se pun conexiunile in ordinea in care sunt declarate intrarile si iesirile din modul
c // NU se recomanda stilul asta de instantiere
); // apar greseli frecvent la ordinea firelor, la numarul lor,
*/ // mai ales daca modulul e complex si are multe intrari si intrari

endmodule
</syntaxhighlight>

Echivalent se pot folosi si "primitive" SystemVerilog pentru scrierea top-ului.

Primitivele sunt porti logice care exista deja in limbaj, folosite atunci cand se doreste o descriere structurala a circuitului.

In instantiere acestora, iesirea se pune prima, urmata de intrari.

'''Observatie:''' daca se doreste scrierea acestor porti de catre voi (ca mai sus), numele modulului nu trebuie sa fie un cuvant cheie ocupat de primitive.

'''Descrierea alternativa a modulului top (fisierul top_v2.sv):'''
<syntaxhighlight lang="Verilog">
module top_v2
(
input logic a,
input logic b,
output logic c
);

wire w0;

and and_gate_0(w0,a,b); // primitiva pentru poarta and
not not_gate_0(c,w0); // primitiva pentru poarta not

endmodule
</syntaxhighlight>

Fiind un modul simplu, intreaga functionalitate putea fi scrisa la nivel de "top" si simplificat ca mai jos.

'''Descrierea alternativa a modulului top (fisierul top_v3.sv):'''
<syntaxhighlight lang="Verilog">
module top_v3
(
input logic a,
input logic b,
output logic c
);

assign c = ~ (a & b); // a si b, negate

endmodule
</syntaxhighlight>

Testarea circuitul se face printr-un testbench, acesta fiind:

'''Descrierea testbench-ului (fisierul top_tb.sv):'''
<syntaxhighlight lang="Verilog">
`timescale 1ns / 1ps

module top_tb(); // din/in tb nu intra si iese nimic. niciodata.

logic a_tb;
logic b_tb;
logic c_tb;

top dut // instantierea modulului de tip "top" sub numele "dut"
(
.a(a_tb),
.b(b_tb),
.c(c_tb)
);

initial
begin // in loc de { ... } din c/c++, in SystemVerilog se pune begin ... end
#10; // dupa 10 unitati de timp
a_tb = 0; // a_tb ia valoarea 0
b_tb = 0;
#10; // dupa inca 10 unitati de timp, deci in total la 20
a_tb = 1;
b_tb = 0;
#10;
a_tb = 0;
b_tb = 1;
#10;
a_tb = 1;
b_tb = 1;
#10;
a_tb = 0;
b_tb = 0;

#20 $stop(); // oprirea simularii
end //end pentru initial

endmodule
</syntaxhighlight>

Formele de unda rezultate din simulare se pot vedea mai jos:

[[Fișier:exemplu_rezolvat_nand_forme_de_unda.png ‎| 800px]]

In chenarul verde se pot observa instantele din simulare.

Daca se doreste adaugarea de semnale noi pentru a fi vazute, se selecteaza modulul instantiat in care acestea se afla (chenar verde).

Apoi, din chenarul rosu se aleg semnalele si se adauga prin click dreapta->add to wave window.

Pentru o mai usoara vizualizare, semnalele se pot grupa asa cum se vede in chenarul mov prin click dreapta->new group.

Se observa o functionare corecta circuitului, acesta fiind o poarta NAND. El scoate "0" cand ambele semnale de intrare sunt "1" si scoate "1" in rest.

'''Implementarea circuitului pe FPGA'''

Dupa ce circuitul a fost testat in simulare, se doreste punerea sa fizica pe placa FPGA. Pentru aceasta, se tine cont de urmatoarele.

* Pentru a controla intrarile ''a'' si ''b'' ale circuitului '''top'', va trebui sa le conectam prin intermediul conexiunilor configurabile ale FPGA-ului la pini ce sunt mai departe conectati fizic la dispozitive ce pot controla valorile semnalelor (switch-uri, butoane).
* Pentru a observa valoarea iesirii, vom conecta semnalul de iesire ''c''la un dispozitiv de observare, cum ar fi un LED, care va fi aprins daca ''c'' este 1 si stins daca ''c'' este 0.

[[Fișier:NAND2 FPGA.png | 600px]]

Pentru a realiza conectarea porturilor modulului ''top'' la pinii fizici ai FPGA ce sunt conectati mai departe la componentele de pe placa, va trebui sa specificam in utilitarul de sinteza maparea porturilor la acestia. Maparea se realizeaza prin mentionarea codurilor pinilor la care dorim conexiunea si poata numele de '''constrangeri de I/O'''. Aceste coduri sunt mentionate in documentatia placii de dezvoltare cu FPGA (in cazul nostru, Boolean Board) si pot fi regasite si in pagina [[Boolean Board - Pinout]].

Conform schemei, la acest exemplu avem nevoie de codurile pinilor conectati mai departe la Switch0, Switch1 si LED0.

'''Observatie:''' Daca intrarile si iesirile ar fi semnale pe mai multi biti, fiecare bit al intrarilor va fi conectat la cate un switch/buton si fiecare bit al iesirii va fi conectat la un LED. Acest lucru este necesar deoarece switch-urile/butoanele pot avea doar doua stari (0 si 1) si astfel pot controla un singur bit. La fel, un LED poate avea doar doua stari (0 - stins si 1 - aprins) si poate afisa starea unui singur bit.

Dupa ce ati extras codurile necesare, urmati pasii descrisi in [[Tutorial_Vivado|tutorialul Vivado]].

Dupa programarea cu succes a placii, puteti testa functionalitatea circuitului prin modficarea valorilor switch-urilor si observarea starii LED-ului.

==Exercitii==
Pentru urmatoarele exercitii se doreste atat testarea designurilor prin simulare cat si punerea acestora pe placa. Legat de placa, intrarile vor fi conectate la butoane, iar iesirile la leduri. Se va consulta tabelul cu pini disponibili ([[Boolean Board - Pinout]].).

Exista moduri mai rapide de a scrie functionalitatea dorita (vezi exemplu), dar tema principala a acestui laborator este instantierea, asa ca sunteti rugati sa respectati desenele si sa instantiati fiecare poarta individual.

===Exercitiul 1: AND4 din AND2===

Acest exercitiu arata cum se construieste o poarta AND cu 4 intrari din porti AND mai simple, cu 2 intrari.
Iesirea acesteia va fi "1" doar daca toate intrarile sunt "1".

[[Fișier:schema_and4_din_and2.png ‎| 600px]]

Pentru testarea circuitului, generati in testbench urmatoarele forme de unda (liniile punctate reprezinta 5ns):

[[Fișier:Wavedrom_and4.png ‎| 500px]]

===Exercitiul 2: OR4 din OR2===

Asemanator cu exercitiul anterior, se poate construi si o poarta or cu 4 intrari din porti or cu 2 intrari.
Iesirea acesteia va fi "1" doar daca oricare din intrari (cel putin una) este "1".

Pentru testarea circuitului se folosesc formele de unda de la exercitiul 1.

[[Fișier:schema_or4_din_or2.png ‎| 600px]]

===Exercitiul 3: AND4 din AND2 aranjat pe lung (nu arbore)===

In multe cazuri, aceeasi functionalitate poate fi atinsa prin circuite care arata diferit.
O alta varianta de a face o poarta AND cu 4 intrari este prezentata mai jos.

Comparati cele 2 variante.

Pentru testarea circuitului se folosesc formele de unda de la exercitiul 1.

[[Fișier:schema_and4_din_and2_v2.png ‎| 600px]]

===Exercitiul 4: AND4 din NAND2===

Orice poarta logica de baza poate fi construita doar din porti NAND sau doar din porti NOR.

Desenati si implementati circuitul pentru o poarta AND4 din porti NAND cu 2 intrari.

Tip: Incercati intai sa generati o poarta AND2 din NAND2.

Pentru testarea circuitului se folosesc formele de unda de la exercitiul 1.

===Exercitiul 5: AND4 pe 4b din AND4 pe 1b===

Se pot face operatii logice si pe mai multi biti deodata prin punerea in paralel a mai multor porti cu o singura iesire.
Exemplu :
pentru intrarile 0011 si 1110 iesirea va fi 0010

Pentru exersarea instantierii si intelegerea circuitului din spatele operatilor multibit implementati acest circuit prin instantierea a 4 porti AND2 pe 1 bit intr-o poarta AND2 pe 4 biti.

[[Fișier:schema_and4_4b_din_and4_1b_v1.png ‎| 400px]]

Pentru testarea circuitului, generati in testbench urmatoarele forme de unda (liniile punctate reprezinta 5ns):

[[Fișier:Wavedrom_and4_4b.png ‎| 500px]]

Exista si un mod mai rapid si simplu de a scrie aceasta functionalitate, grupand intrarile si iesirile in "bus"-uri, ca in codul de mai jos.
Acest mod de a grupa firele este desenat mai jos.

[[Fișier:schema_and4_4b_din_and4_1b_v2.png ‎| 600px]]

Fisierul and4_4b.sv:
<syntaxhighlight lang="Verilog">
module and4_4b
(
input logic [3:0] in0, // in0 are 4b, de la bit 3 la bit 0 inclusiv
input logic [3:0] in1, // se noteaza msb:lsb (most significant bit: least significant bit) (echivalent cu conceptul de cifra sutelor, cifra unitatilor, pt binar)
input logic [3:0] in2,
input logic [3:0] in3,
output logic [3:0] out0
);

assign out0 = in0 & in1 & in2 & in3;

endmodule
</syntaxhighlight>

===Exercitiul 6: Desenati schemele logice pentru urmatoarele circuite:===

'''a) Schema 1'''
<syntaxhighlight lang="Verilog">
module schema1 (a, b, c, d, f);
input logic a, b, c, d;
output logic f, g;

logic w1;
logic w2;

and P1 ( w1, a, c );
or P2 ( f, w1, w2, d);
not P3 (w2, b);
and P4 (g, w1, b, d);
endmodule
</syntaxhighlight>

Observatie: In versiunea veche de verilog (si s-a pastrat si in cea curenta), se pot specifica directiile porturilor si in exteriorul parantezelor, ca mai sus.
Aceasta scriere NU este recomandata.

'''b) Schema 2'''
<syntaxhighlight lang="Verilog">
module schema2 (a, b, c, d, f);
input logic a, b, c, d;
output logic f;

logic w1, w2;

nand P1 ( w1, a, b ), P2 (w2, c, d);
and P3 ( f, w1, w2);
endmodule
</syntaxhighlight>

'''Observatie:''' asemanator cu C/C++, se pot face declaratii in aceeasi linie a mai multor "variabile", aici fire sau instante, cum se poate vedea la w1 si w2 (ambele fiind fire) sau la P1 si P2 (ambele fiind porti nand).
Aceasta scriere NU este recomandata.

CID aplicatii 1 : Generare de forme de unda

2025-02-23T20:35:05Z

Mihai.antonescu:

În această sesiune de aplicații vom învăța cum să generăm semnale digitale cu ajutorul limbajului SystemVerilog. Generarea de semnale este utilizată în testarea prin simulare a circuitelor digitale. Semnalele generate sunt introduse la intrarea circuitului, observându-se apoi cum se modifică starea ieșirilor acestuia.

Proiectarea circuitelor digitale se bazează pe generarea unor circuite digitale fizice. Deși se va scrie cod în limbajul SystemVerilog, mereu trebuie avut în vedere faptul că în spate se va genera un circuit fizic, codul nu se rulează pas cu pas, aceasta fiind deosebirea fundamentală dintre limbajele de descriere hardware (generează circuite fizice) și limbajele de programare (cod care se execută pas cu pas). Unele concepte cât și unele elemente de sintaxa este posibil să semene cu ce ați facut la programare, dar este important să înțelegeți că prin codul scris se desenează/generează circuite. Sau invers, pornind de la un desen, se poate face o descriere în SystemVerilog a acestuia.

Proiectele exemplu care pot fi descărcate au fost implementate folosind Vivado 2021.2. Dacă aveți altă versiune este posibil să vă ceară să le salvați în versiunea respectivă sau să fie nevoie să vă faceți un proiect nou, în care să adaugați fișierele cu cod.

==Noțiuni și cunoștințe necesare==

* [[Introducere. SystemVerilog HDL]] (Sintaxa [[SystemVerilog]])

* [[Tutorial Vivado]].

==Modulul de test (Testbench)==
Modulul de test este un modul nesintetizabil (nu poate fi transformat într-un circuit de către utilitarul care realizează sinteza) și este folosit, așa cum sugerează și numele, în testarea circuitelor. Acest modul este folosit exclusiv în simulare. Simularea permite detecția rapidă a erorilor de implementare și corectarea acestora. Ideea generală a unui modul de test este descrisă în figura de mai jos (considerăm un circuit cu numele ''circuit'' și modulul său de test ''circuit_tb''):

[[Fișier:CircuitTestbench.png ‎| 400px]]

După cum se vede în figura de mai sus, modulul de test conține printre altele și un '''generator de semnale de test'''. Acesta are rolul de a genera câte un semnal de test pentru fiecare intrare a circuitului. Forma acestor semnale de test este stabilită de către cel care realizează verificarea și trebuie aleasă astfel încât să detectăm cât mai multe posibile erori.

==Exemple==
====Exemplul 1: Generarea a doua semnale digitale de 1 bit====
Să se genereze două semnale digitale de 1 bit, care să aibă următoarea variație în timp (unitatea de timp este de 1ns):

[[Fișier:CID Aplicatii1 ex1.svg|400px]]

<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps // setăm unitatea de timp la 1ns, cu o precizie de 1ps

module waveform1(); // modulul se numește waveform1 și nu are nicio intrare și nicio ieșire. Semnalele de test generate sunt semnale interne.

logic a, b; // cele două semnale de test sunt trebuie declarate ca elemente de tip logic.

initial begin
$monitor("time = %2d, a = %b, b=%b", $time, a, b); // monitorizăm în consolă starea semnalelor a si b
a = 0; // semnalul a va avea valoarea 0 la momentul inițial de timp (la momentul t = 0)
b = 0; // semnalul b va avea valoarea 0 la momentul inițial de timp (la momentul t = 0)
#1 a = 1; // după 1ns de la momentul inițial, a se face 1
#1 b = 1; // după 2ns de la momentul inițial, b se face 1
#1 a = 0; // după 3ns de la momentul inițial, a se face 0
b = 0; // după 3ns de la momentul inițial, b se face 0
#2 $stop(); // simularea este oprită
end

endmodule // incheiem descrierea modulului de generare de semnale digitale
</syntaxhighlight>

'''Observație:''' Atunci când un semnal are dimensiunea de 1 bit, nu va apărea nimic intre tipul acestuia și nume. Atunci când semnalul are o dimensiune mai mare sau egală cu doi biți, dimensiunea va fi descrisă sub forma '''[n-1:0]''', unde '''n''' este numărul de biți. Conform acestei descrieri, bitul '''n-1''' este cel mai semnificativ.

<syntaxhighlight lang="Verilog">
logic a; //semnal cu dimeniunea de 1 bit
logic [7:0] data; //semnal/magistrală/bus cu dimensiunea de 8 biți
</syntaxhighlight>

====Exemplul 2: Generarea unui semnal periodic de 1 bit====
Să se genereze un semnal digital periodic de 1 bit, cu perioada egală cu 2ns:

[[Fișier:Clock wave.png | 600px]]

<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps // setăm unitatea de timp la 1ns, cu o precizie de 1ps

module waveform2(); // modulul se numește waveform2 si nu are nicio intrare și nicio iesire

logic clock; // semnalul de test este declarat de tip logic

initial begin
clock = 0; // valoarea inițială a semnalului va fi 0 (la momentul t = 0)
forever #1 clock = ~clock; // forever indică faptul că ce urmează se va repeta într-o buclă continuă.
// La trecea unui timp egal cu unitatea de timp definită, semnalul clock iși va nega valoarea
end

initial begin
#20 $stop(); // La 20 de unități de timp (aici, 20 ns), simularea se va opri.
// Aici punem $stop într-un bloc separat, deoarece forever blochează blocul initial în care se află
// Toate blocurile initial încep la același moment de timp (t = 0) și au efect în paralel
end

endmodule
</syntaxhighlight>

==Exerciții==
====Exercițiul 1====
Generați două semnale digitale '''a''' și '''b''' de 1 bit, astfel încât să se formeze cu ele toate cele 4 combinații posibile, după cum urmează:

'''t = 0ns''': a = 0, b = 0
'''t = 1ns''': a = 0, b = 1
'''t = 2ns''': a = 1, b = 0
'''t = 3ns''': a = 1, b = 1

====Exercițiul 2====
Să se genereze un semnal digital de 8 biți aliniat la fronturile crescătoare ale unui semnal periodic (semnal de ceas), ce are perioada de 2ns:

[[Fișier:Clock and data wave.png | 600px]]

'''Observație:'''
* Frontul crescător al unui semnal este definit ca tranziția dintre nivelul de 0 logic și 1 logic.
* Spunem că un semnal este aliniat la fronturile crescătoare ale unui alt semnal dacă acesta își modifică valoarea imediat după apariția acelui front crescător. În figura de mai sus, se observă că '''data''' își schimbă valoarea imediat după fiecare front crescător al semnalului '''clock'''.

'''Indicații''':

* Așteptarea unui front crescător al semnalului ''NumeSemnal'' se realizează cu '''@(posedge ''NumeSemnal'')'''. Aceasta va înlocui întârzierile de tip '''#n''' folosite anterior.
* Pentru semnalele ce se doresc aliniate la un eveniment de tip '''posedge''', vom folosi atribuirea non-blocantă: de exemplu, '''data <= 1;'''.
* Nu uitați! Folosirea ''forever'' pentru generarea semnalului de ceas va bloca acel bloc ''initial''.
* Incrementarea valorii unui semnal se poate realiza cu un bloc de tip ''for'', inclus in blocul ''initial''. Blocul ''for'' va avea nevoie de un contor de tip ''integer'', declarat în afara blocului ''initial''. Pentru mai multe detalii, consultați tutorialul de sintaxa SystemVerilog.

Folosind indicațiile anterioare, înlocuiți al doilea bloc ''initial'' din '''Exemplul 2''' cu următoarea secvență și completați liniile de cod lipsă:
<syntaxhighlight lang="Verilog">
integer index;

initial begin
for(index = 0; index < 11; index = index + 1) begin
//completati codul
end
#20 $stop();
end
</syntaxhighlight>

====Exercițiul 3====
Desenați formele de undă ale semnalelor de test ''a'', ''b'' și ''c'', generate cu ajutorul următoarelor două blocuri ''initial'':
<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps

module waveform();

logic a, b, c;

initial begin
a = 0;
b = 0;
#2 b = 1;
#1 a = 1;
#3 b = 0;
#3 a = 0;
#2 $stop();
end

initial begin
c = 1;
#2 c = 0;
#3 c = 1;
end

endmodule
</syntaxhighlight>

====Exercițiul 4====
Generati un semnal digital '''clock''' cu dimensiunea de 1 bit si perioada de 2ns si un semnal digital '''data''', cu dimensiunea de 4 biti, aliniat la fronturile crescatoare ale semnalului '''clock'''. Semnalul '''data''' va varia astfel: '''0, 1, 2, 3, 0, 1, 2 ,3, 0, 1 ... '''. Opriti simularea dupa ce semnalul '''data''' a realizat 4 variatii complete (s-a generat secventa '''0, 1, 2, 3''' de 4 ori).

CID aplicatii 5 : Exercitii cu circuite combinationale

2024-10-28T16:32:02Z

Mihai.antonescu:

==Teorie==

Acest laborator are rolul de a sedimenta cunostiintele dobandite anterior.

El consta in exercitii separate, unele date ca subiect la lucrarea 1 in anii anteriori si cateva notiuni de teorie si sintaxa ajutatoare.

==Teorie: Parametrizare==
Parametrizarea este un mod de a generaliza codul scris pentru a nu fi nevoie sa scrii acelasi modul de mai multe ori doar pentru ca circuitul isi schimba o dimensiune.

Pentru a intelege mai clar avantajele si sintaxa urmariti urmatorul exemplu:

Fisierul sumator.sv:
<syntaxhighlight lang="Verilog">
module sumator # // <= diez deoarece urmeaza lista cu paramteri
( // parametri
parameter data_size = 4 // valoare default 4
// alti parametri aici daca este nevoie, separati prin virgula
)
( // interfata
input logic [data_size-1:0] in0, // si pot folosii parametrul "data_size" pentru dimensiunea bus-ului
input logic [data_size-1:0] in1,
output logic [data_size-1:0] out0
);

assign out0 = in0 + in1;

endmodule
</syntaxhighlight>

Cand se instantiaza un modul parametrizat, se specifica valorile parametrilor astfel:
<syntaxhighlight lang="Verilog">
sumator # ( // parametri
.data_size(8) // se genereaza un sumator pe 8b
)
nume_instanta_0
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out0)
);

sumator # ( // parametri
.data_size(32) // se genereaza un sumator pe 32b
)
nume_instanta_1
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out1)
);

sumator nume_instanta_2 // se genereaza un sumator de dimensiune default, aici 4, asa cum e scris in modulul "sumator"
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out2)
);
</syntaxhighlight>

Puteti folosi parametrizarea in exercitiul 3 de mai jos. Acolo sunt 2 tipuri de multiplexoare, unul cu intrarile pe 1 bit si unul cu intrarile pe 2 biti. Poate fi scris un singur modul parametrizat care sa acopere ambele situatii.

==Teorie: Concatenarea==

Pentru o mai usoara conectare a firelor sau pentru o mai buna organizare si expresivitate a codului, de multe ori este util ca fire individuale sa fie grupate impreuna sau ca un bus de mai multi biti sa fie separat in fire individuale. Acest lucru se face folosind concatenarea, prin simbolurile "{ }".

Un exemplu de folosire a concatenarii este oferit mai jos.
Un sumator pe 8b are rezultatul pe maxim 9b, in cazul in care ambele numere sunt mari. Astfel apare un bit de carry out.
<syntaxhighlight lang="Verilog">
module sumator (
input logic [7:0] in0,
input logic [7:0] in1,
output logic [7:0] out0,
output logic carry_out
);

assign {carry_out,out0} = in0 + in1; // fac suma intre in0 si in1 iar rezultatul il pun pe cei 9b alcatuiti din: 1b carry_out si 8b out0, in ordinea asta

endmodule
</syntaxhighlight>
Se pot concatena oricat de multe semnale, puse in "{ }" si separate prin virgula. Atentie la dimensiunile firelor care se concateneaza.

Se poate de asemenea face concatenare si la dreapta egalului, astfel:
<syntaxhighlight lang="Verilog">
assign fir_pe_10_b = {fir_pe_3b,fir_pe_5b,fir_pe_1b,fir_pe_1b};
</syntaxhighlight>
In exemplul anterior ultimi 2b ai "fir_pe_10_b" vor avea mereu aceeasi valoare, provenind din acelasi fir. Sintaxa SystemVerilog permite asta.

Puteti folosii concatenarea, in exercitiul 2, la flag-ul de overflow.

==Teorie: Constante ca intrari in circuite==
In cazul in care se doreste scrierea unor constante la intrarea unor module, acestea se pun direct intre paranteze la instantiere.
De exemplu, pentru multiplexorul de jos din subiectul "alu structural", intrarea "in3" este conectata la valoarea "1". Sintaxa pentru aceasta este: ".in3(1),".

==Teorie: "_"==
Simbolul "_" (underscore) este ignorat de SystemVerilog si ajuta vizual la citirea semnalelor pe mai multi biti. De exemplu 16'b1010010111110000 este identic cu 16'b1010_0101_1111_0000, al doilea fiind totusi mai usor de citit.

==Exercitii==

===Exercitiul 0: Repararea erorilor===
Arhiva de mai jos contine mai multe proiecte in Vivado, fiecare avand cate o eroare de sintaxa sau de logica. In vederea aprofundari cunostiintelor voastre (si pentru lucrarea de saptamana urmatoare), incercati sa le parcurgeti si sa rezolvati toate problemele.
Pe langa proiecte in sine, in arhiva se afla si un fisier text cu o introducere, rezolvarile si explicatiile pentru fiecare situatie.

[https://drive.google.com/file/d/1cNTpQC54_JEeSk8SxgHTEdGtobCn_-EI/view?usp=drive_link Arhiva_proiecte_cu_erori.zip]

===Exercitiul 1: ALU - descriere comportamentala===
Descrieți comportamental o unitate aritmetico-logică (ALU) care are la intrare 2 numere binare de câte 8 biți și poate calcula următoarele funcții:
:- suma celor două numere
:- diferența celor două numere
:- operații logice bit cu bit (bitwise): SI, SAU, XOR și inversele lor
:- operandul din stanga trece neschimbat
:- operandul din dreapta trece neschimbat
:- numărul din stânga este deplasat la stânga cu nr. de poziții indicat de numărul din dreapta
:- numărul din stânga este deplasat la dreapta cu nr. de poziții indicat de numărul din dreapta

Funcția executată la un anumit moment este determinată de configurația binară de pe intrarea de comandă (function).

ALU are de asemenea intrare de carry și ieșire de carry, plus alte două ieșiri - indicatori - pentru cazurile când rezultatul este zero și când cei doi operanzi sunt egali.

Intrarea de control va fi facuta pe 4 biti ca sa permita existenta a 16 operatii posibile. Fiecare numar de pe intrarea de control (combinatie de 0 si 1) va reprezenta o operatie din cele de mai sus. Scrierea se va face folosind un bloc "case" in functie de aceasta intrare.

===Exercitiul 2: ALU - descriere structurala===

[https://wiki.dcae.pub.ro/images/8/8f/Subiect_big_alu.pdf subiect_alu.pdf]

Daca se doreste selectarea doar a anumitor biti dintr-un bus (cum se vrea din instruction) acest lucru se poate face in 2 feluri:

a) cu fir aditional:
:''wire [1:0] fir_aditional1;''
:''assign fir_aditional1 = instruction[11:10];''
:// apoi la instantiere: ''.sel(fir_aditional1),''

b) direct in instantiere;
:la instantierea celor 2 mux4 din stanga, direct:
::''.sel(instruction[11:10]),''

Pentru a scrie mai putin (a nu face toate modulele de calcul separat + instantierea lor) si pentru ca e vorba de operatii simple, se poate pune operatia cu assign direct in top pe un fir declarat acolo, sau si mai prescurtat, direct operatia dorita cand se intantiaza modulul in care aceasta intra. De exemplu, pentru operatia de shift la dreapta care intra in primul multiplexor, se poate pune: ".in0(data0 >> data1),".

===Exercitiul 3:===

[https://wiki.dcae.pub.ro/images/3/3a/Subiect_muxes.pdf subiect_muxes.pdf]

===Exercitiul 4:===

[https://wiki.dcae.pub.ro/images/2/2e/Subiect_rom_luts.pdf rom_luts.pdf]

===Exercitiul 5: Sumator cu reprezentare in cifre zecimale===
Proiectati si verificati un sumator zecimal pentru numere cu 2 cifre

Modulul de top (Figura 1) este alcatuit din 2 blocuri de tip '''digitsum'''. Fiecare bloc aduna cifrele de pe aceasi pozitie.

'''Figura 1'''
Top level

[[Fișier: bcdsum.png]]

Blocul '''digitsum''' (Figura 2) este alctuit din 4 blocuri, 2 sumatoare binare pe 4 biti (de tip '''sum4'''), o instanta de '''cmp''' si un multiplexor elementar mux2

'''Figura 2'''
Blocul DIGIT SUM

[[Fișier: digit.png]]

Primul sumator aduna cifrele din domeniul [0...9] avand un rezultat intre [0 ... 18]

Comparatorul are la iesire 1 daca rezultatul este mai mare decat 9.

Daca rezultatul este mai mic decat 9, acesta este trimis in mod direct la iesirea '''digit''' a blocului '''digitsum'''.

Daca rezultatul este mai mare decat 9, o crectie este necesara si se aduna 6 la rezultat.

Comparatorul cu valoarea 9 este descris structural din porti in figura de mai jos:

'''Figure 3'''
the comparator

[[Fișier: cmp.png]]

Testbench-ul va genera stimuli pentru '''bcdsum''' ca in Figura 4.

Intrarea b0 a '''bcdsum''' se schimba la fiecare 5 pasi de simulare .

b1, a0 si a1 se schimba sincron cu b0 ca in Figura 4.

'''Figure 4'''

[[Fișier: teststimuli.png]]

Cerinte:
# '''cmp'''- descris structural la nivel de porti ca in Figura 3.
# '''sum4''' descris comportamental cu un assign continuu.
# '''mux''' descris comportamental cu always.
# '''digitsum''' descris strctural ca in Figura 2.
# modulul de top numit '''bcdsum''', descris structural ca in Figure 1.
# modulul de testbench, '''bcdsum_tb''', instantiaza '''bcdsum''' cu numele '''dut'''.
# in testbench, generati stimuli pentru intrarile circuitului testat.

CID aplicatii 7 : Circuite secventiale elementare

2024-10-22T13:57:40Z

Mihai.antonescu:

==Hazardul combinațional==

Hazardul apare atunci când modificarea unei intrări a unui circuit combinațional determină modificări nedorite ale ieșirii. Aceste variații apar datorită diferențelor de întârzieri pe diverse căi de la intrare către ieșire.

De unde aceste întârzieri? Fiecare poartă este, așa cum am văzut la începutul aplicațiilor, un circuit electronic format, de obicei, din tranzistoare MOS. Răspunsul acestor dispozitive nu este instantaneu, introducând întârzieri. Timpul scurs de la modificarea unei intrări a unei porți până la modificarea corespunzătoare a ieșirii se numește timp de propagare.

În figura următoare avem evidențiat timpul de propagare printr-o poartă ''SAU'' (Tp). Acesta este reprezentat de timpul scurs de la modificarea lui a până la modificarea ieșirii.

[[Fișier:Comutare poarta SAU.png | 400px]]

Avănd un circuit cu mai multe porți în cascadă, căile prin care anumite semnale ajung la intrările unei anumite porți pot diferi. Datorită timpilor de propagare diferiți care afectează aceste semnale până să ajungă la poarta curentă și a timpului de propagare efectiv al porții curente, pot apărea la ieșire tranziții nedorite ale semnalelor. Dacă la ieșire se așteaptă ca linia să rămană constant în 1, dar apare o scurtă tranziție prin 0, hazardul se numește ''1 static''. Dacă la ieșire se așteaptă ca linia să rămană constant în 0, dar apare o scurtă tranziție prin 1, hazardul se numește ''0 static''. Dacă se așteaptă o tranziție la ieșire, dar apare un regim tranzitoriu cu numeroase tranziții până la stabilizare, hazardul se numește dinamic.

Pentru a înțelege mai bine, să considerăm exemplul de mai jos:

[[Fișier:Circuit comb hazard.png | 400px]]

Observăm că intrările porții ''P2'' urmează căi diferite: semnalul ''c'' este ieșirea unei porți, având o întârziere cauzată de timpul de propagare al porții ''P1'', pe când semnalul ''b'' vine direct de la intrare, propagarea prin fir fiind neglijabilă. Să considerăm cazul în care intrarea ''a'' rămane permanent în 0, iar intrarea ''b'' comută la un moment dat din 0 în 1. Inițial, semnalul ''c'' este 1, iar ''d'' este 1. După comutarea lui ''b'', semnalul ''c'' va comuta din 1 in 0, iar ''d'' va rămane 1. Acesta este cazul ideal. În realitate, datorită timpilor de propagare ai porților logice ''P1'' și ''P2'', vom avea o scurtă tranziție prin 0:

[[Fișier:Circuit comb hazard propagare.png | 400px]]

==Atribuirea blocanta si non-blocanta==
Pentru ca simulatorul sa functioneze in mod corect si semnalele sa se modifice in simulare asa cum se modifica si in realitate este nevoie sa folosim atribuirea blocanta ( semnul "=") la circuite combinationale si atribuirea non-blocanta (semnul "<=") la circuite secventiale.

In mod uzual orice always combinational ( '''always@(*)''' ) va folosi '''atribuirea blocanta ( = )''' si orice always pe ceas ( '''always@(posedge clock)''' ) va folosi '''atribuirea non-blocanta ( <= )'''.

Diferenta dintre cele 2 atribuiri consta in modul in care simulatorul "executa" instructiunea de atribuire. La atribuirea blocanta se simuleaza linie cu linie, in ordinea in care acestea au fost scrise. La atribuirea non-blocanta se salveaza toti termenii din dreapta si se pun deodata (in acelasi pas de simulare) in termenii din stanga. Pentru a clarifica acest concept avem exemplul de mai jos:

<syntaxhighlight lang="Verilog">
a = b;
b = a;

c <= d;
d <= c;
</syntaxhighlight>

In primul caz, deoarece am folosit atribuirea blocanta, a ia valoarea lui b si apoi b ia valoarea lui a, care deja a devenit b deci concret b ramane pe loc si deci atat a cat si b vor avea aceasi valoare la final.

In al doilea caz, deoarece am folosit atribuirea non-blocanta, ce este in partea dreapta se transfera peste operanzii din stanga deodata, astfel c ia valoarea lui d si d ia valoarea lui c, la final avand loc o interschimbare.

==Latch-ul==
Latch-urile sunt dispozitive elementare de memorare, sensibile la nivelul semnalelor de intrare. Exemple de astfel de dispozitive sunt latch-urile de tip SR și latch-urile de tip D.

===Latch-ul SR===
Latch-ul de tip SR poate fi realizat cu două porți ''SI NU'' sau ''SAU NU'' și este un dispozitiv asincron controlat de stările semnalelor ''S'' (set) și ''R'' (reset). Tabelul de adevăr al acestui circuit este prezentat mai jos.

[[Fișier:Latch SR.png|400px]]

Atunci când ''S'' este 1 și ''R'' este 0, ieșirea ''Q'' va deveni 1, iar ''Qn'' va deveni 0. Atunci când ''R'' este 1 și ''S'' este 0, ieșirea ''Q'' se resetează (devine 0), iar ''Qn'' devine 1. Starea de memorare apare atunci când atât ''R'' cât și ''S'' sunt 0 în același timp. Cazul în care ''R'' și ''S'' sunt 1 în același timp duce la un comportament nedorit. (atât ''Q'' cât și ''Qn'' vor fi 0, ceea ce este incorect din punct de vedere al logicii dorite – ''Qn'' să fie negatul lui ''Q''). În plus, dacă din aceasta stare se dorește trecerea în starea de memorare (''R'' = 0, ''S'' = 0), poate apărea oscilația. În realitate, cele două porți nu vor avea același timp de propagare datorită variațiilor de producție și circuitul va ajunge în cele din urma într-o stare stabilă, nepredictibilă.

===Latch-ul de tip D===
Latch-ul de tip D elimină problema combinațiilor nedorite de la ieșire. Acesta modifică ieșire doar atunci când semnalul de enable (''E'') este 1. Altfel, atunci când ''E'' este 0, va memora starea anterioara (''Qt-1'').

[[Fișier:Latch D.png|500px]]

==Bistabilul de tip D==
Bistabilul de tip D este un dispozitiv de memorare ce salvează valoarea intrării pe unul din fronturile ceasului (în mod uzual, frontul crescător). El poate fi obținut prin conectarea a două latch-uri de tip D, conform schemei de mai jos. De obicei, singura ieșire care ne interesează este ''Q''.

[[Fișier:Bistabil D.png|300px]]

Comportamentul bistabilului de tip D poate fi observat în forma de undă următoare. Modificările lui ''data_out'' sunt determinate de fronturile crescătoare ale semnalului ''clock''. La apariția acestora, ''data_out'' va lua valoarea intrării ''data_in''.

[[Fișier:Forma unda bistabil.png]]

===Bistabilul de tip D cu reset sincron===
Resetarea unui bistabil înseamnă aducerea valorii memorate la 0 sau la o altă valoare de reset definită de cel care proiectează circuitul. Vom considera în exemplul nostru că semnalul de ''reset'' va fi activ în 0 și va face 0 valoarea memorată atunci când este activ. Un reset sincron înseamnă că acesta va acționa asupra valorii memorate''data_out'' pe frontul crescător al ceasului.

[[Fișier:Forma unda bistabil reset sincron.png]]

===Bistabilul de tip D cu reset asincron===
Un reset asincron înseamnă că acesta va acționa asincron, fără a ține cont de ceas. Acest lucru înseamnă că el va acționa asupra valorii memorate imediat ce devine activ. În exemplele noastre, vom considera semnalul de ''reset'' ca fiind activ în 0. Trecerea sa în 0 (frontul căzător) determină imediat resetarea circuitului. De asemenea, orice eveniment de front crescător de ceas ce apare cât timp reset-ul este activ, va duce la menținerea resetării circuitului.

[[Fișier:Forma unda bistabil reset asincron.png]]

==Exemple==
===Exemplul 1: Evidențierea hazardului combinațional===

Implementați circuitul cu porți logice prezentat în secțiunea de introducere teoretică și reproduceți în modulul de testare variațiile semnalelor ''a'' și ''b'' propuse, astfel încât să observăm pe ieșirea ''d'' hazardul.

Deoarece în simulare propagarea este ideală, va trebui să introducem un timp de propagare folosind ''#n''. Acesta va avea efect doar în simulare și va fi ignorat la o eventuală sinteză.

Pentru modulul de test, va trebui să alegem un timp de modificare a valorilor semnalelor mai mare decât timpul de propagare ales. Aici, vom folosi 1ns timp de propagare și 5ns timp de variație a intrărilor in testbench.

'''Implementarea SystemVerilog a circuitului'''

<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps
module Circuit(
input logic a,
input logic b,
output logic c,
output logic d
);

assign #1 c = ~(a | b);
assign #1 d = ~(c & b);

endmodule
</syntaxhighlight>

'''Implementarea unui modul de test care să evidențieze hazardul'''
<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps

module Circuit_TB();

logic a_t, b_t;
logic c_t, d_t;

initial begin
a_t = 0;
b_t = 0;
#5 b_t = 1;
#5 $stop();
end

Circuit DUT(
.a(a_t),
.b(b_t),
.c(c_t),
.d(d_t)
);

endmodule
</syntaxhighlight>

[[Fișier:Poza_hazard.png ‎| 800px]]

In acest exemplu se observa ca iesirea c se modifica la 1ns dupa modificarile intrarilor (intarizerea adaugata pentru transmiterea prin porti) si iesirea d se modifica de 2 ori: prima data la 1ns din cauza intrarilor si a doua oara dupa inca 1ns din cauza lui c. In intervalul [6-7]ns apare o valoare parazita, un hazard.

===Exemplul 2: Descrierea comportamentală a latch-ului de tip D===
'''Descrierea SystemVerilog a modulului'''
<syntaxhighlight lang="Verilog">
module latch_D(
input logic D,
input logic E,
output logic Q
);

assign Q = (E == 1) ? D : Q;

endmodule
</syntaxhighlight>

'''Modul de test pentru latch-ul D'''
<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps

module latch_D_TB();

logic D_t, E_t;
logic Q_t;

initial begin
D_t = 0;
E_t = 1;
#1 D_t = 1;
#1 D_t = 0;
#1 E_t = 0;
#1 D_t = 1;
#1 D_t = 0;
#5 $stop();
end

latch_D DUT1(
.D(D_t),
.E(E_t),
.Q(Q_t)
);

endmodule
</syntaxhighlight>

===Exemplul 3: Descrierea comportamentală a bistabilului de tip D===
'''Descrierea SystemVerilog a modulului'''
<syntaxhighlight lang="Verilog">
module flipflop_D(
input logic data_in,
input logic clock,
output logic data_out
);

always_ff @(posedge clock) begin
data_out <= data_in; // atribuire non-blocanta
end

endmodule
</syntaxhighlight>

'''Modulul de test pentru bistabilul de tip D'''
<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps

module flipflop_D_TB();

logic data_in_t, clock_t;
logic data_out_t;

initial begin
data_in_t = 0;
#2 data_in_t = 1;
#4 data_in_t = 0;
#5 $stop();
end

initial begin
clock_t = 0;
forever #1 clock_t = ~ clock_t;
end

flipflop_D DUT(
.data_in(data_in_t),
.clock(clock_t),
.data_out(data_out_t)
);

endmodule
</syntaxhighlight>

'''Observatie:''' Atunci cand avem un circuit secvential, se foloseste atribuirea non-blocanta ("<=”)

==Exerciții==
===Exercițiul 1===
Descrieți structural latch-ul de tip SR, conform schemei din secțiunea de introducere teoretică. Puteți simula întârzierile prin porți folosind #1.

Realizați un modul de test care să pună în evidență funcționarea. Respectați la generarea stimulilor următoarea variație (fiecare segment de timp durează 5ns).

[[Fișier:Forma unda latchSR.png]]

===Exercițiul 2===
Modificați descrierea bistabilului de tip D prezentată în exemple, astfel încât acesta să permită resetarea sincronă. Semnalul de reset va fi activ în 0.

Realizați un modul de test care să respecte la generarea stimulilor forma de unda prezentată în secțiunea de introducere teoretică, la '''Bistabilul de tip D cu reset sincron'''.

===Exercițiul 3===
Modificați descrierea bistabilului de tip D prezentată în exemple, astfel încât acesta să permită resetarea asincronă. Semnalul de reset va fi activ în 0.

Realizați un modul de test care să respecte la generarea stimulilor forma de unda prezentată în secțiunea de introducere teoretică, la '''Bistabilul de tip D cu reset asincron'''.

'''Indicație''': Frontul căzător al semnalului ''reset'' va trebui să fie adăugat în lista de sensitivități a blocului always care determină modificarea lui ''data_out''.

===Exercițiul 4===
Pentru evidentierea hazardului combinational (si a modului in care acesta se rezolva) descrieti in SystemVerilog si simulati urmatoarele 2 circuite:

[[Fișier:Poza_circ_secventiale_basic_exercitiu_4_circuit.png ‎| 600px]]

Pentru a putea observa efectele hazardului, portile trebuie descrise ca avand timpi de propagare.

Formele de unda pentru semnalele de la intrare vor fi:

[[Fișier:Poza_circ_secventiale_basic_exercitiu_4_forme_unda.png ‎| 600px]]

===Exercițiul 5===
Pentru evidentierea efectului atribuirii blocant si non-blocante se va implementa si simula circuitul de mai jos. El este alcatuit din 3 registre, fiecare memorand (si punand la iesire) pe frontul pozitiv al ceasului valoarea de la intrare.

Cele 3 registre de sus vor folosii atribuirea blocanta si cele 3 registre de jos vor folosii atribuirea non-blocanta. In simulare se doreste a se vizualiza: intrarile, iesirile, firele interne de legatura dintre registrii.

Pentru a scrie semnificativ mai putin, nu este nevoie sa instantiati fiecare registru dintro serie ca modul separat ci se pot face toate cele 3 atribuiri in cadrul aceluiasi bloc "always", la nivelul de top. Practic tot circuitul se reduce la un fisier de top ce contine intrari/iesiri, declararea registrilor pe 1b si cele 2 always-uri care dicteaza functionarea.

[[Fișier:Poza_circ_secventiale_basic_exercitiu_5_circuit.png ‎| 600px]]

CID aplicatii 8 : Registre si memorii RAM

2024-10-22T13:57:28Z

Mihai.antonescu:

==Teorie==

Acest laborator are scopul de a prezenta circuitele secventiale simple: registre si memorii RAM.

Pornind de la bistabilii prezentati/construiti in laboratorul anterior, apare notiunea de registru, acesta fiind o grupare de bistabili. Astfel in loc sa se memoreze un singur bit de informatie (bistabil), se pot memora acum numere pe mai multi biti (registru).

Din exterior, un registru este vazut astfel:

[[Fișier:Registru_exterior_view.png | 400px]]

:Semnalul de "clock" controleaza sincronizarea registrilor din tot sistemul.
:Semnalul de "reset" aduce registrul la o valoare initiala (uzual 0).
:Semnalul de "we" (write enable) controleaza salvarea unor date noi. Cand acesta este activ, data de pe intrarea "data_in" se salveaza in registru.
:Semnalul "data_in" reprezinta datele ce se doresc a fi scrise in registru.
:Semnalul "data_out" reprezinta valoarea stocata in registru.

Semnalele "data_in" si "data_out" pot fi pe oricat de multi biti se doreste, in mod uzual multipli de 8.

Pornind de la notiunea de registru (care poate fi vazut ca o memorie cu o locatie si avand "m" biti) se doreste cresterea acestei memorii astfel incat aceasta sa curpinda mai multe locatii adresabile, unde se pot stoca date. Adaugand mai multi registri in paralel, unul langa altul, si cateva circuite de tip mux/demux se poate obtine o memorie de tip RAM (Random Access Memory), cu "m" locatii de "n" biti fiecare. Aceste memorii se cheama "Random Access" deoarece permit si scriere si citire. In functie de tehologia folosita, memoriile RAM pot fi construite din bistabili sau din latch-uri.

Din exterior, o memorie RAM este vazuta astfel:

[[Fișier:Ram_mXn_1read_1write_exterior_view.png ‎| 400px]]

Semnalele acestui circuit se pot imparti in semnale ce tin de interfata de scriere sau interfata de citire si mai apoi in semnale de date si semnale de control. Interfata sa este:

:Semnalul de "clock": controleaza sincronizarea registrilor din memorie.
:Semnalul "addr_read": adresa de la care se citesc datele.
:Semnalul "data_read": data ce se citeste.
:Semnalul de "we": semnal de control ce controleaza activarea scrierii. Scrierea are loc doar cand acest semnal este activ.
:Semnalul "addr_write": adresa la care se scriu datele.
:Semnalul "data_write": data ce urmeaza a fi scrisa atunci cand semnalul "we" este activ.

'''Observatie''': Orice memorie are "m" locatii de "n" biti. Semnalele de "data_read" si "data_write" au aceeasi dimensiune, "n", numarul de biti ai fiecarei locatii. Semnalele de adresa au dimensiunea log2(m). Pentru o memorie cu 16 locatii va fi nevoie de 4 biti de adresa pentru a putea selecta orice locatie, pentru 32 locatii 5b s.a.m.d.

'''Observatie''': In unele situatii se mai poate pune un registru suplimentar pe iesirea datelor, cu rol in sincronizare si evitarea timpilor de propagare prea lungi intre elemente de memorare (ajuta implementarea conceptului de pipeline).

'''Observatie''': Exista mai multe variante de memorii RAM (cu registru pe iesire/fara, multiport/single port citire, adrese separate sau nu pentru citire/scriere). Cea de mai sus este o memorie cu un singur port de citire, fara registru suplimentar pe iesire, ce foloseste adrese distincte pentru citire si pentru scriere (la fel de bine se poate lucra si cu o singura adresa, comuna pentru scriere si citire).

'''Observatie''': Memoriile RAM pot sa nu aiba reset, utilizatorul trebuie apoi sa aiba grija sa citeasca doar din locatii scrise de el anterior.
In mod uzual ele nu au reset.

==Exemple==

===Exemplul 1 : Registrul===

In urmatorul exemplu se implementeaza registrul descris mai sus:

'''Descrierea registrului (fisierul register_8b.sv):'''
<syntaxhighlight lang="Verilog">
module register_8b
(
input logic clock,
input logic reset, // activ pe "1"
input logic we,
input logic [7:0] data_in,
output logic [7:0] data_out // data_out are aceeasi dimensiune ca data_in
);

always_ff @(posedge clock) // clock sincronizeaza actiunile circuitului
begin // doar pe edge-ul pozitiv circuitul actioneaza
if(reset == 1)
begin
data_out <= 0;
end
else
begin
if(we == 1) // comanda de scriere
begin
data_out <= data_in;
end
else // puteam sa omit acest else
begin
data_out <= data_out; // raman datele salvate anterior
end
end
end

endmodule
</syntaxhighlight>

Un alt mod de a scrie un registru este dat mai jos, cu observatia ca aici am pus semnalul de reset activ in logica negativa:

'''Descrierea registrului (fisierul register_8b_v2.sv):'''
<syntaxhighlight lang="Verilog">
module register_8b_v2
(
input logic clock,
input logic reset_n, // activ in "0"
// uzual semnalel cu n in fata sau la sfarsit sunt in logica negativa: nreset, resetn
input logic we,
input logic [7:0] data_in,
output logic [7:0] data_out
);

logic [7:0] memorie_efectiva;

assign data_out = memorie_efectiva;

always_ff @(posedge clock)
begin
if( reset_n == 0)
begin
memorie_efectiva <= 0;
end
else
begin
if(we == 1)
begin
memorie_efectiva <= data_in;
end
end
end

endmodule
</syntaxhighlight>

'''Descrierea test bench-ului registrului pe 8biti: (fisierul register_8b_tb.sv):'''
<syntaxhighlight lang="Verilog">
`timescale 1ns / 1ps

module register_8b_tb();

logic clock_tb;
logic reset_tb;
logic we_tb;
logic [7:0] data_in_tb;
logic [7:0] data_out_tb;

register_8b dut // varianta cu reset activ in "1"
(
.clock(clock_tb),
.reset(reset_tb),
.we(we_tb),
.data_in(data_in_tb),
.data_out(data_out_tb)
);

initial
begin
clock_tb = 0;
forever
begin
#5 clock_tb = ~clock_tb; // perioada totala 10 !!!
end
end

initial
begin
reset_tb <= 0;
we_tb <= 0;
data_in_tb <= 0;
// observatie: pana la primul reset sau prima scriere, valoarea din registru va fi necunoscuta (in simulare X)

// dau reset la circuit
@(posedge clock_tb); // astept sa treaca 1 clock cycle
reset_tb <= 1;
@(posedge clock_tb);
reset_tb <= 0;

repeat(5) // dupa 5 cicli de ceas
begin
@(posedge clock_tb);
end

// incep sa fac scrieri
we_tb <= 1;
data_in_tb <= 5;
@(posedge clock_tb);
we_tb <= 0;
data_in_tb <= 10; // scrierea asta nu se face deoarece nu am write enable activ
@(posedge clock_tb);
data_in_tb <= 11; // nici asta
@(posedge clock_tb);
data_in_tb <= 12; // nici asta
@(posedge clock_tb);
we_tb = 1;
data_in_tb <= 42; // asta da
@(posedge clock_tb);
data_in_tb <= 51; // si asta da
@(posedge clock_tb);
we_tb <= 0;

repeat(5) // dupa 5 cicli de ceas
begin
@(posedge clock_tb);
end
$stop();
end

endmodule
</syntaxhighlight>

===Exemplul 2: Memorie RAM===

In urmatorul exemplu se implementeaza memoria RAM descrisa mai sus, particularizata pentru 64 de locatii a cate 8b fiecare:

'''Descrierea memoriei RAM: (fisierul ram64x8_v1.sv):'''
<syntaxhighlight lang="Verilog">
module ram64x8_v1
(
input logic clock,
//interfata de citire
input logic [5:0] addr_read, // 64 locatii => 6 biti de adresa
output logic [7:0] data_read, // fiecare locatie are 8b
// interfata de scriere
input logic we,
input logic [5:0] addr_write,
input logic [7:0] data_write
);

logic [7:0] memorie_efectiva [0:63]; // memorie cu locatiile de la 0 la 63, fiecare avand 8 biti

assign data_read = memorie_efectiva[addr_read]; // fara registru pe iesire => citire asincrona fata de clock

always_ff @(posedge clock)
begin
if(we == 1)
begin
memorie_efectiva[addr_write] <= data_write; // scriu la locatia data de "addr_write" din memoria efectiva datele "data_write"
end
end

endmodule
</syntaxhighlight>

Acesta va fi folosit si pe post de modul de "top".

Echivalent se poate folosi si sintaxa cu always ca mai jos.

'''Descrierea memoriei RAM: (fisierul ram64x8_v2.sv):'''
<syntaxhighlight lang="Verilog">
module ram64x8_v2 // varianta cu always combinational pe citire
(
input logic clock,
//interfata de citire
input logic [5:0] addr_read,
output logic [7:0] data_read,
// interfata de scriere
input logic we,
input logic [5:0] addr_write,
input logic [7:0] data_write
);

logic [7:0] memorie_efectiva [0:63];

always_comb // citire asincrona fata de clock
begin
data_read = memorie_efectiva[addr_read];
end

always_ff @(posedge clock)
begin
if(we == 1)
begin
memorie_efectiva[addr_write] <= data_write; // scriu la locatia data de "addr_write" din memoria efectiva datele "data_write"
end
end

endmodule
</syntaxhighlight>

'''Descrierea test bench-ului memoriei RAM: (fisierul ram64x8_v1_tb.sv):'''
<syntaxhighlight lang="Verilog">
`timescale 1ns / 1ps

module ram64x8_tb();

logic clock_tb;
logic [5:0] addr_read_tb;
logic [7:0] data_read_tb;
logic we_tb;
logic [5:0] addr_write_tb;
logic [7:0] data_write_tb;

ram64x8_v1 dut
(
.clock(clock_tb),
//interfata de citire
.addr_read(addr_read_tb), // 64 locatii => 6 biti de adresa
.data_read(data_read_tb), // fiecare locatie are 8b
// interfata de scriere
.we(we_tb),
.addr_write(addr_write_tb),
.data_write(data_write_tb)
);

initial
begin
clock_tb = 0;
forever
begin
#5 clock_tb = ~clock_tb; // perioada totala 10 !!!
end
end

initial
begin
we_tb <= 0;
data_write_tb <= 0;
addr_read_tb <= 0; // citind de la o adresa nescrisa inca, iesirea e necunoscuta
addr_write_tb <= 0;
repeat(5) // dupa 5 cicli de ceas
begin
@(posedge clock_tb);
end

// incep sa fac scrieri
we_tb <= 1; // scriu data 5 la adresa 10
addr_write_tb <= 10;
data_write_tb <= 5;
addr_read_tb <= 11; // citind de la o adresa nescrisa inca, iesirea e necunoscuta
@(posedge clock_tb);
we_tb <= 0; // scrierea asta nu se face deoarece nu am write enable activ
addr_write_tb <= 11;
data_write_tb <= 10;
@(posedge clock_tb);
data_write_tb <= 11; // nici asta
@(posedge clock_tb);
data_write_tb <= 12; // nici asta
@(posedge clock_tb);
we_tb <= 1;
addr_write_tb <= 20; // scriere ok
data_write_tb <= 42; // scriu data 42 la adresa 20
@(posedge clock_tb);
data_write_tb <= 51; // si asta; suprascriu datele anterioare la adresa 20.
@(posedge clock_tb);
addr_write_tb <= 21;
data_write_tb <= 11; // scriere ok
addr_read_tb <= 20; // citesc de la adresa 20, scrisa anteior deci voi vedea date cunoscute pe iesire.
@(posedge clock_tb);
addr_write_tb <= 23;
data_write_tb <= 14; // scriere ok
addr_read_tb <= 21; // variez adresa de citire si pot parcurge memorie locatie cu locatie
@(posedge clock_tb);
we_tb <= 0; // opresc scrierea

repeat(5) // dupa 5 cicli de ceas
begin
@(posedge clock_tb);
end
$stop();
end

endmodule
</syntaxhighlight>

[[Fișier:Ram64X8_waveform.png|1000px]]

In forma de unda de mai sus sunt marcate momentele de timp cand au loc scrieri in memorie (cand am write enable activ si valori cunoscute pentru data si adresa de scriere). Se salveaza valorile imediat la stanga frontului de ceas.

In simularea completa, se poate observa si scrierea in registrii din memorie a datelor dorite la adresa setata.

==Exercitii==
===Exercitiul 1: RAM cu registru la iesire===

Pornind de la exemplul anterior, se doreste adaugarea unui registru la citirea datelor, astfel citirea devenind sincrona cu semnalul de ceas. In cod acest lucru se poate face foarte usor, punand operatia de citire pe ceas.

Se doreste simularea si apoi testarea fizica a acestei memorii. Simularea noii memorii se face prin executarea a 3 scrieri la adrese diferite si citirea apoi a datelor respective. Sinteza si testarea fizica necesita micsorarea memoriei din cauza numarului limitat de switchuri/butoane al placii. Vom lucra acum cu o memorie de 8 locatii X 4 biti.
Adresa va fi comandata de switch-uri si datele de intrare din butoane. Se va folosi Button[0] pentru semnalul de "we" (write enable). Afisarea datelor se va face pe leduri.

===Exercitiul 2: RAM multiport citire===

Pornind de la exercitiul 1, se doreste modificarea memoriei astfel incat sa poata fi citite 2 locatii simultan si independent de adresa la care se face scrierea. Se pastreaza citirea sincrona.

Se obtine astfel un circuit a carui interfata este la randul ei compusa din 3 interfete (+semnal comun "clock"):

:- interfata de scriere

:- interfata de citire 0

:- interfata de citire 1

Interfata circuitului arata ca in figura de mai jos:

[[Fișier:Ram_64X8_2read_1write_exterior_view.png | 400px]]

Generati forme de unda corespunzatoare pentru a testa aceasta memorie.

'''Observatie''': Blocul de registri (register file) din interiorul procesoarelor (vedeti AMP) poate fi o astfel de memorie RAM. Are 2 adrese pentru citirea celor 2 operanzi care intra in ALU si o adresa pentru rezultatul calculului ce este salvat.

===Exercitiul 3: Registrul paralel-serie===

Descrieti comportamental un registru paralel-serie. Acesta are rolul de a salva datele de la intrare pe "n" biti (aici 8) si apoi de a le scoate la iesire bit cu bit.

Interfata acestuia este data in desenul de mai jos.

[[Fișier:Registru_paralel_serie.png | 400px]]

:Semnalul de "en" (enable) are rolul de a controla deplasarea, care se executa prin operatia de shiftare la dreapta ">>". Daca acesta are valoarea "1", datele salvate se muta la dreapta cu o pozitie.
:Semnalul de write_en/start/save are rolul de a salva cei 8 biti care urmeaza a fi serializati.

Generati forme de unda corespunzatoare pentru a testa aceast circuit (minim 3 scrieri/serializari).

'''Bonus''': Realizati acelasi circuit folosind o descriere structurala.

===Exercitiul 4: Registrul serie-paralel===

Descrieti comportamental un registru serie-paralel. Acesta are rolul de a salva date introduse bit cu bit ca apoi sa fie scoase cate "n" biti deodata.

Interfata acestuia este data in desenul de mai jos.

[[Fișier:Registru_serie_paralel.png | 400px]]

Semnalul de "en" (enable) are rolul de a controla deplasarea, care se executa prin operatia de shiftare la dreapta ">>". Daca acesta are valoarea "1", datele salvate se muta la dreapta cu o pozitie.

Generati forme de unda corespunzatoare pentru a testa aceast circuit (minim 3 scrieri/paralelizari).

Citirea se poate face oricand, desi doar dupa "n" pasi, va fi cu valoarea corecta.

===Exercitiul 5: Registrul de intarziere pe 8b===

Prin conectarea in serie a mai multor registri pe 8b (astfel incat data ce iese din unul sa fie intrare pentru urmatorul) se pot construi registri de intarziere cu "x" cicli de ceas. Cum fiecare registru salveaza datele pe ceas, se poate spune ca datele de la iesire sunt intarziate cu un ceas fata de datele de la intrare, astfel o intarziere cu "x" cicli de ceas se obtine prin punerea in serie a "x" registri.

Pornind de la un registru simplu pe 8b (exemplul 1), construiti structural un registru de intarziere cu 4 cicli de ceas.

Testati functionarea acestuia prin simulare. Datale introduse trebuie sa iasa defazate cu 4 cicli de ceas (adica cu 4 cicli de ceas mai tarziu).

CID aplicatii 9 : Numaratorul

2024-10-22T13:57:05Z

Mihai.antonescu:

== Numărătorul ==
Numărătorul este cel mai simplu automat, fiind format dintr-un registru (element de memorare) ce reține valoarea curentă a acestuia și un circuit de incrementare (circuit de reacție) ce generează la ieșirea sa valoarea ce va trebui stocată în registru la următorul front crescător de ceas (valoarea curentă incrementată cu 1).

În figura de mai jos este reprezentat un numărător cu reset sincron:

[[Fișier:Numarator cu reset.png|600px]]

În cazul de mai sus, cât timp semnalul ''reset'' este activ, valoarea numărătorului va fi 0. Atunci când semnalul ''reset'' nu este activ, numărătorul își va incrementa valoarea la fiecare front crescător de ceas.

== Divizor de frecvență cu factor de divizare putere a lui 2==
În unele cazuri, apare necesitatea obținerii unor semnale de ceas cu frecvență mai mică decât cea a ceasului de sistem. Aceste noi semnale de ceas pot fi obținute chiar din semnalul de ceas al sistemului, prin circuite care realizează divizarea acestuia. Cea mai simplă divizare a unui semnal de ceas este cea cu factor de divizare egal cu o putere a lui 2. Pentru acest caz, putem folosi un numărător.

Dacă urmărim figura de mai jos în care sunt reprezentate variațiile fiecărui bit în timpul funcționării unui numărător pe 4 biți, observăm că, cu cât ordinul bitului crește (este mai semnificativ), frecvența de variație este mai mică. Între frecvențele de variație corespunzătoare a doi biți succesivi există următoarea relație: frecvența unui bit este de două ori mai mică decât frecvența bitului anterior (mai puțin semnificativ).

[[Fișier:Divizare frecventa.png]]

Observând că frecvența bitului 0 este de două ori mai mică decât cea a ceasului, putem concluziona că frecvența de variație a bitului cu indicele N este dată de: '''''fbN'' = ''fclk / 2N+1'''''

Așadar, pentru a realiza un divizor de frecvență cu factor de divizare putere a lui 2, putem folosi un numărător îndeajuns de mare, din care extragem bitul cu frecvența de variație egală cu frecvența dorită.

== Exemple==
===Exemplul 1: Implementarea unui numărător cu reset sincron===
În acest exemplu vom realiza implementarea numărătorului cu reset sincron prezentat în figura din secțiunea de introducere teoretică. În plus, vom folosi parametrul WIDTH pentru a controla dimensiunea acestuia.

'''Implementarea Numărătorului cu reset sincron'''
<syntaxhighlight lang="Verilog">
module Numarator
#(parameter WIDTH = 8)
(
input logic clock,
input logic reset_n,
output logic [WIDTH-1:0] count
);

always_ff @(posedge clock) begin
if(reset_n == 0)
count <= 0;
else
count <= count + 1;
end

endmodule

</syntaxhighlight>

'''Implementarea unui modul de test pentru numărător'''
<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps

module Numarator_TB();

parameter WIDTH_T = 5;
logic reset_n_t, clock_t;
logic [WIDTH_T-1:0] count_t;

initial begin
clock_t = 0;
forever #1 clock_t = ~clock_t;
end

initial begin
reset_n_t = 0;
#2 reset_n_t = 1;
#500 $stop();
end

Numarator #(.WIDTH(WIDTH_T)) DUT(
.clock(clock_t),
.reset_n(reset_n_t),
.count(count_t)
);

endmodule

</syntaxhighlight>

'''Observație:''' Cât timp semnalul ''reset'' este inactiv, numărătorul își va incrementa valoarea la fiecare front crescător de ceas. Când va ajunge la valoarea sa maximă (de exemplu, 31 pentru un numărător pe 5 biți), va avea loc o depășire și având la dispozitie un număr limitat de biți (de exemplu, 5), semnalul de ieșire va deveni 0 (reținem doar cei mai puțin semnificativi 5 biți), circuitul reluând numărarea de la capat.

===Exemplul 2: Observarea vitezei de variație a biților unui numărător===
În acest exemplu vom realiza implementarea unui divizor de frecvență ce generează la ieșire 4 semnale de ceas cu următoarele frecvențe:
* ''clkout1'': semnal de ceas cu frecvența de 1 Hz.
* ''clkout2'': semnal de ceas cu frecvența de 2 Hz.
* ''clkout4'': semnal de ceas cu frecvența de 4 Hz.
* ''clkout8'': semnal de ceas cu frecvența de 8 Hz.

Dacă aplicăm formula '''''fbN'' = ''fclk / 2N+1''''' cunoscând că frecvența de ceas a FPGA-ului este de 100 MHz, vom obține:
* ''clkout1'' poate fi obținut prin bitul 26 al unui numărător.
* ''clkout2'' poate fi obținut prin bitul 25 al unui numărător.
* ''clkout4'' poate fi obținut prin bitul 24 al unui numărător.
* ''clkout8'' poate fi obținut prin bitul 23 al unui numărător.

Din rezultatele de mai sus, rezultă că avem nevoie de un numărător pe 27 biți, astfel încât să putem folosi bitul cel mai semnificativ (bitul 26) pentru generarea semnalului de ceas cu frecvența cea mai mică.

'''Implementarea SystemVerilog a circuitului'''
<syntaxhighlight lang="Verilog">
module clock_generator(
input logic clock,
input logic reset,
output logic clkout1,
output logic clkout2,
output logic clkout4,
output logic clkout8,
);

logic [26:0] count;

always_ff @(posedge clock) begin
if(reset == 1)
count <= 0;
else
count <= count + 1;
end

assign clkout1 = count[26];
assign clkout2 = count[25];
assign clkout4 = count[24];
assign clkout8 = count[23];

endmodule

</syntaxhighlight>

'''Observație:''' Cerința ca reset să fie activ în 1 este impusă de logica în care lucrează butoanele FPGA-ului.

'''Implementarea circuitului pe FPGA'''

Realizați sinteza circuitului pe FPGA, ținând cont de următoarele constrângeri de I/O:
{| class="wikitable"
|- align="center"
||'''Port''' || '''Conexiune'''
|- align="center"
| clock || CLK_100MHz
|- align="center"
| reset || Button 0
|- align="center"
| clkout1 || LED3
|- align="center"
| clkout2 || LED2
|- align="center"
| clkout4 || LED1
|- align="center"
| clkout8 || LED0
|}

Observați viteza cu care fiecare din LED-uri se stinge și se aprinde.

== Exerciții==
===Exercițiul 1===
Implementați un numărător parametrizat cu reset sincron și semnal de ''enable''. Semnalul ''enable'' controlează funcționarea numărătorului astfel: când este activ (egal cu 1), permite funcționarea normală (incrementare la fiecare front crescător de ceas); când este inactiv (egal cu 0), va determina numărătorul să își păstreze valoarea curentă.

Implementați și un modul de test care să testeze funcționarea corectă a circuitului.

===Exercițiul 2===
Implementați un numărător parametrizat cu reset sincron și capacitatea de a număra crescător sau descrescător. Controlul direcției de numărare se va realiza cu ajutorul unui semnal ''count_updown'', care controlează funcționarea numărătorului astfel: când este 0, numărătorul va număra crescător, prin incrementarea valorii curente, iar când este 1, numărătorul va număra descrescător, prin decrementarea valorii curente

Implementați și un modul de test care să testeze funcționarea corectă a circuitului.

===Exercițiul 3===
Implementați circuitul descris prin schema de mai jos, știind că:
* COUNTER este un numărător pe 32 biți fără reset.
* RAM este o memorie 16x4b, cu citire sincrona.
* ROM este o memorie 16x4b, ce are descrierea prezentată mai jos.

[[Fișier:Cid_lab6.jpg]]

'''Implementarea modulului ROM'''
<syntaxhighlight lang="Verilog">
module ROM(
input logic [3:0] in,
output logic [3:0] out
);

always_comb
case(in)
0: out = 4'b0000;
1: out = 4'b0110;
2: out = 4'b0011;
3: out = 4'b1110;
4: out = 4'b1011;
5: out = 4'b1111;
6: out = 4'b0111;
7: out = 4'b1100;
8: out = 4'b0001;
9: out = 4'b0101;
10: out = 4'b1101;
11: out = 4'b1010;
12: out = 4'b0010;
13: out = 4'b0100;
14: out = 4'b1000;
15: out = 4'b1001;
default: out = 4'b0000;
endcase
endmodule
</syntaxhighlight>

Realizați un modul de test în care să scrieți memoria RAM cu date, astfel încât să se realizeze citirea memoriei ROM în ordine, la fiecare ciclu de ceas (adresa 0 -> adresa 1 -> ... -> adresa 15 -> adresa 0 -> ...)

CID aplicatii 10 : Aplicatii cu numaratoare

2024-10-22T13:56:45Z

Mihai.antonescu:

==Teorie==

Numaratoarele au extrem de multe aplicatii in lumea reala, cateva dintre acestea fiind descrise mai jos.

==Exemplu: Numaratul apasarilor unui buton==

Un prim sistem simplu cu numarator poate fi cel care contorizeaza de cate ori a fost apasat un buton sau, echivalent, cate persoane/masini au trecut printr-un senzor, de cate ori a fost deschisa o usa etc. Acest sistem se poate apoi dezvolta cu usurinta pentru a numara si oamenii care trec invers prin respectivul set de senzori prin adaugarea functionalitatii de up/down la numarator.

Un astfel de sistem simplu (varianta doar cu numarat intrari) ar arata in felul urmator:

[[Fișier:Aplicatii_numarator_exemplu_contor_senzor.png | 800px]]

Circuitul de debounce are rolul de a "curata" semnalul de intrare, astfel incat chiar si in prezenta zgomotului sau a unei activari indelungate a senzorului/butonului, sa se contorizeze un singur eveniment. O explicatie mai detaliata puteti gasi [[Circuitul_de_debounce|aici]].

Numaratorul numara evenimentele.

Transcodorul pentru display cu 7 segmente este apoi folosit pentru o mai usoara vizualizare a numarului curent.

'''Observatie:''' transcodorul pentru 7seg din exemplul de mai jos este in logica negativa. Daca circuitul fizic este in logica pozitiva trebuie adaugat un inversor la iesirea din acesta. De asemnea consider segmentul "a" pe bitul "0" si segmentul "h" pe bitul "6".

'''Descrierea debouncer-ului (fisierul debounce.sv):'''
<syntaxhighlight lang="Verilog">
module debounce
#(
parameter limit = 20'd650000
) (
input logic clock,
input logic in,
output logic out
);

logic [19:0] counter; // observatie: si circuitul de debounce foloseste un numarator
logic hit;

assign out = (counter == limit);

always_ff @(posedge clock)
begin
if(in == 0)
begin
counter <= 0;
hit <= 0;
end
else
begin
if(counter == limit)
begin
hit <= 1;
counter <= counter + 1;
end
else
begin
if(in == 1 & hit == 0)
begin
counter <= counter + 1;
end
end
end
end

endmodule
</syntaxhighlight>

'''Descrierea numaratorului pe 4b(fisierul counter_4b.sv):'''
<syntaxhighlight lang="Verilog">
module counter_4b
(
input logic clock,
input logic reset,
input logic en,
output logic [3:0] out
);

always_ff @(posedge clock)
begin
if(reset == 1)
begin
out <=0;
end
else
begin
if(en == 1)
begin
out <= out + 1;
end
else
begin
out <= out;
end
end
end

endmodule
</syntaxhighlight>

'''Descrierea transcodorului pentru afisaj cu 7seg(fisierul transcodor_7seg.sv):'''
<syntaxhighlight lang="Verilog">
module transcodor_7seg // logica negativa
(
input logic [3:0] in,
output logic [6:0] out
);

always_comb
begin
case(in)
4'd0: out = 7'b1000000;// h....a
4'd1: out = 7'b1111001;
4'd2: out = 7'b0100100;
4'd3: out = 7'b0110000;
4'd4: out = 7'b0011001;
4'd5: out = 7'b0010010;
4'd6: out = 7'b0000010;
4'd7: out = 7'b1111000;
4'd8: out = 7'b0000000;
4'd9: out = 7'b0010000;
4'd10: out = 7'b0001000;
4'd11: out = 7'b0000011;
4'd12: out = 7'b1000110;
4'd13: out = 7'b0100001;
4'd14: out = 7'b0000110;
4'd15: out = 7'b0001110;
default: out = 7'b1111111;//tot stins
endcase
end

endmodule
</syntaxhighlight>

'''Descrierea sistemului, modulul de top (fisierul top.sv):'''
<syntaxhighlight lang="Verilog">

module top
(
input logic clock,
input logic reset,
input logic button,
output logic [6:0] out // logica negativa
);

logic debounce_0_X_out;
logic [3:0] counter_4b_0_X_out;

debounce
#(
.limit(20'd50_000)
) debounce_0 (
.clock(clock),
.in(button),
.out(debounce_0_X_out)
);

counter_4b counter_4b_0
(
.clock(clock),
.reset(reset),
.en(debounce_0_X_out),
.out(counter_4b_0_X_out)
);

transcodor_7seg transcodor_7seg_0 // logica negativa
(
.in(counter_4b_0_X_out),
.out(out)
);

endmodule
</syntaxhighlight>

'''Descrierea test bench-ului(fisierul tb.sv):'''
<syntaxhighlight lang="Verilog">
`timescale 1ns / 1ps

module tb();

logic clock_tb;
logic reset_tb;
logic button_tb;
logic [6:0] out_tb;

top dut
(
.clock(clock_tb),
.reset(reset_tb),
.button(button_tb),
.out(out_tb) // logica negativa
);

initial
begin
clock_tb = 0;
forever
begin
#5 clock_tb = ~clock_tb;
end
end

initial
begin
reset_tb = 0;
button_tb = 0;

#50;
reset_tb = 1;
#50;
reset_tb = 0;
#100;

repeat(5) // vreau 5 apasari de buton
begin
button_tb = 1;
repeat(70_000)
begin
@(posedge clock_tb);
end
button_tb = 0;
repeat(70_000)
begin
@(posedge clock_tb);
end
end

#1000 $stop();
end

endmodule
</syntaxhighlight>

==Exercitii==

=== Exercitiul 1: Divizor de frecventa cu puteri ale lui 2===

Divizorul de frecventa are rolul de a genera un semnal de ceas mai lent din semnalul de ceas principal.
El este alcatuit doar dintr-un numarator, iar fiecare bit al acestuia va fi practic un semnal de ceas cu frecventa din ce in ce mai mica astfel (la jumate):

bit[0] - frecventa de 2 ori mai mica decat semnalul de ceas

bit[1] - frecventa de 2 ori mai mica decat bit[0], deci de 4 ori mai mica decat semnalul de ceas

bit[2] - frecventa de 2 ori mai mica decat bit[1], deci de 8 ori mai mica decat semnalul de ceas

Acest lucru se poate observa si in poza ce urmeaza:

[[Fișier:Freq_divider_output.png| 800px]]

Implementati acest circuit, si folosind ledurile prezente pe placa, incercati sa conectati bitul corespunzator la leduri astfel incat cel mai din dreapta led sa clipeasca cu o frecventa cat mai apropiata de 1s.

'''Observatie:''' Printr-un astfel de divizor de frecventa minimal, un numar foarte mic de frecvente poate fi generat. Daca se doreste generarea unui semnal periodic cu o perioada exacta, diferita de cele posibile prin acest mecanism, se poate construi urmatorul circuit:

===Exercitiul 2: Divizor de frecventa ce poate genera orice perioada===

Un astfel de divizor de frecventa este construit ca in figura de mai jos:

[[Fișier:Freq_div_orice_freq.png | 800px]]

Prin adaugarea constantei "limit", perioada semnalului de iesire poate sa fie orice multiplu a perioadei semnalului de ceas.

Bistabilul de tip t, se modifica atunci cand limita este atinsa si practic iesirea lui este semnalul periodic dorit (cu observatia ca o perioada a semnalului de iesire necesita 2 numarari pana la limita).

Sa se calculeze valoarea necesara pentru "limit" astfel incat pe leduri sa se genereze semnal cu perioada exact 1s.

'''Observatie:''' In FPGA exista fizic trasee speciale pentru reset si ca sinteza sa le foloseasca pe acestea in mod optim nu este recomandat sa se puna logica (cum e aici poarta sau) pe acestea. Modificati schema de mai sus astfel incat sa eliminati respectiva poarta de pe reset. (Sfat: numaratorul va avea acum si intrari de load: semnalul de comanda si data propriu zisa)

===Exercitiul 3: PWM (Pulse Width Modulation)===

PWM este un concept folosit foarte des in multiple ramuri ale ingineriei, de la transmisiunea informatiei pana la controlul motoarelor sau al intensitatii ledurilor din instalatii de Craciun. El se refera la a avea un semnal periodic cu factor de umplere variabil, asa cum este aratat in poza de mai jos :

[[Fișier:Pwm.png| 800px]]

Generarea unui astfel de semnal periodic se face printr-un numarator si un comparator, ca in figura de mai jos:

[[Fișier:Pwm_schematic.png | 800px]]

Raportul dintre limita pusa si valoarea la care numaratorul se reseteaza este practic factorul de umplere selectat.

Pentru testare pe placa, cei 6b ai limitei provin de la switch-uri si butoane. Afisarea se face pe led[0].

Testati acest circuit in simulare si apoi implementati pe placa pentru o valoare fixa a limitei. Implementati in paralel mai multe generatoare de semnal PWM cu limite diferite, astfel incat sa observati diferentele de intentistate dintre ledurile comandate de acestea.

===Exercitiul 4: PWM cu limita variabila===

Un exemplu foarte uzual de folosire a PWM este aprinderea ledurilor cu diverse pattern-uri. Factorul de umplere determina intensitatea cu care ledul este aprins. Un PWM cu o limita variabila automata va face ledul sa para din ce in ce mai stins sau din ce in ce mai luminos (exemplu: instalatii de Craciun). Combinand asta cu leduri RGB se obtin efecte de schimbare a culorii ledului aparent la intamplare.

Un astfel de circuit se realizeaza punand inca un numarator in locul limitei, ca in poza de mai jos:

[[Fișier:Pwm_duty_cycle_up_schematic.png | 800px]]

Pentru o functionalitate suplimentara, anume a pastra un anumit factor de umplere mai multe perioade, am adaugat inca un numarator.

Pentru claritatea desenului, nu am mai tras efectiv firul de ceas catre intrarile unde acesta se duce.

Rezultatul este:

[[Fișier:Pwm_duty_cycle_up_output.png | 800px]]

Testati circuitul propus prin simulare si apoi vizualizati implementarea sa pe placa. Alegeti limite potrivite astfel incat sa puteti observa usor rezultatul.

'''Bonus:''' Incercati sa adaugati si parametri pentru LIMIT_DUTY_CYCLE_LOW si LIMIT_DUTY_CYCLE_HIGH, care sa permita factorului de umplere sa varieze doar intre ele (numaratorul va avea nevoie de intrari pentru comanda de load si data load, ca sa poata incepe de la orice valoare).

'''Bonus:''' Modificati circuitul astfel incat semnalul de iesire sa isi schimbe sensul de variatie al factorului de umplere cand ajunge cu acesta la capat. In forma curenta factorul de umplere creste de la 0% la 100% si apoi se reseteaza brusc la 0%, repetand acest ciclu. Se vrea ca la ajungerea la 100% sa inceapa o scadere treptata catre 0%, urmata apoi de o urcare s.a.m.d.

===Exercitiul 5: Ceas===

Un ceas poate fi construit cifra cu cifra, folosind numaratoare si comparatoare (si transcodoare pentru display cu 7seg ca sa se vada totul mai bine pe placa).

Incercati sa implementati un ceas cu milisecunde, secunde si minute in varianta comportamentala.

'''Observatie:''' Va fi nevoie fie separat, fie in modul de un numarator cu frecventa rezolutiei dorite (aici 1 ms).

'''Observatie:''' Codul va contine multe "if" de tipul "daca cifra unitatilor secundelor a ajuns la 10, se face 0 si cresc cifra zecilor", repetate pentru fiecare cifra.

Incercati si o implementare structurala a ceasului, mergand pe aceeasi idee. Fiecare cifra va contine numaratorul ei. Cand numaratorul unei cifre ajunge ajunge la limita sa, va da enable pentru numaratorul cifrei urmatoare. Daca este nevoie se pot folosi si porti aditionale (ex: ca sa creasca minutul cifra zecilor secundelor trebuie sa fie 5 si cifra unitatilor secundelor trebuie sa fie 9).

'''Observatie:''' Va fi nevoie de un numarator cu frecventa rezolutiei dorite (aici 1 ms sau 1s).

'''Observatie:''' Pentru a scrie mai putin puteti face un numarator doar cu secunde si minute. Principiul de baza este acelasi si daca aveati milisecunde.

'''Observatie:''' Simularea a cateva milisecunde sau chiar secunde este un proces indelungat (dureaza minute-ore fizice), astfel strict pentru simulari se recomanda ceasul sa functioneze cu microsecunde sau milisecunde maxim.

CID aplicatii 11 : Automate finite

2024-10-22T13:56:22Z

Mihai.antonescu:

== Automate finite ==

Automatul finit este folosit pentru a descrie sisteme ce tranziteaza un numar finit de stari. Acest tip de sistem este foarte util atunci cand starile nu sunt tranzitate intr-un mod simplu, evident sau repetitiv.

Automatul finit, numit și FSM (Finite State Machine), este un model matematic de computație, definit de următoarele elemente:
* O mulțime finită de simboluri de intrare, numită alfabet de intrare;
* O mulțime finită și nevidă de simboluri de ieșire, numită alfabet de ieșire;
* O mulțime finită și nevidă de stări, din care doar una, numită starea curentă, este activă la un moment dat;
* O stare inițială, care face parte din mulțimea stărilor;
* O funcție de tranziție a stărilor, care calculează starea următoare a automatului în funcție de starea curentă și de simbolul de intrare;
* O funcție de calcul a ieșirii, care determină simbolul de ieșire în funcție de starea curentă (în cazul automatelor de tip Moore) sau în funcție de starea curentă și de simbolul de intrare (în cazul automatelor de tip Mealy).

[[[[Fișier:Fsm.png]]]]

La fiecare front al ceasului, valoarea stării următoare, calculată de către CLC, va fi încărcată în registru. Dacă registrul are n biți, numărul maxim de stări care pot fi reprezentate este 2n. Acest număr poate fi mai mic, în funcție de schema de codare a stărilor. De exemplu, pentru n = 4, folosind codarea binară se pot reprezenta cel mult 16 stări (0000, 0001, 0010, ..., 1111), în timp ce pentru codarea one-hot, în care doar un singur bit poate lua valoarea 1, se pot reprezenta 4 stări (1000, 0100, 0010, 0001).

Pentru a reprezenta comportamentul unui automat finit, putem folosi grafuri sau organigrame, conventiile de notare depinzand de tipul automatului (Moore sau Mealy).

== Exemple ==
=== Exemplul 1: Automat ce detecteaza secvente de tipul 11....100....0===
In acest exemplu va fi implementat un automat care detecteaza secventele de tipul 11....100....0. Pentru aceasta, automatul va avea o intrare pe un bit (''in'', pe care va veni secventa de biti) si doua iesiri: ''detectOk'', care semnalizeaza prin 1 ca nu a fost inca detectata o secventa ilegala si ''detectFail'', care semnalizeaza prin 1 ca a fost detectata o secventa ilegala (un 1 dupa 0).

Automatul va avea 3 stari:
* Q0 - STATE_READ1: automatul intra in aceasta stare la reset si va ramane in aceasta atata timp cat intrarea este 1 (inca nu a aparut niciun 0).
* Q1 - STATE_READ0: automatul intra in aceasta stare atunci cand apare pe intrare primul 0 si va ramane in aceasta atata timp cat pe intrare este 0.
* Q2 - STATE_ERROR: automatul intra in aceasta stare atunci cand apare un 1 dupa 0 si va ramane blocat aici pana la reset.

Pentru a coda cele 3 stari avem nevoie de minim 2 biti: STATE_READ1 = 2'b00, STATE_READ0 = 2'b01, STATE_ERROR = 2'b10.

Graful automatului este:

[[Fișier:Organigrama FSM 111000.png]]

'''Implementarea automatului'''
<syntaxhighlight lang="Verilog">
module FSM1(
input logic clock,
input logic in,
input logic reset,
output logic detectOk,
output logic detectFail
);

//Se asociaza sirurilor de biti folositi pentru codarea starilor nume ce pot fi folosite mai usor in cod.
//La compilare, numele vor fi inlocuite in cod cu numerele asociate la inceput.
localparam STATE_READ1 = 2'b00;
localparam STATE_READ0 = 2'b01;
localparam STATE_ERROR = 2'b10;

logic [1:0] state, state_next;

//registrul de stare
always_ff @(posedge clock) begin
if(reset == 1)
state <= STATE_READ1;
else
state <= state_next;
end

//circuit combinational pentru calculul starii urmatoare
always_comb begin
state_next = state;
case(state)
STATE_READ1: begin
if(in == 0) state_next = STATE_READ0;
end
STATE_READ0: begin
if(in == 1) state_next = STATE_ERROR;
end
STATE_ERROR: state_next = STATE_ERROR;
default: state_next = STATE_READ1;
endcase
end

//circuit combinational pentru calculul iesirilor
assign detectOk = (state == STATE_READ0) || (state == STATE_READ1);
assign detectFail = (state == STATE_ERROR);

endmodule
</syntaxhighlight>

'''Implementarea unui modul de test pentru FSM1'''
<syntaxhighlight lang="Verilog">
module FSM1_TB();

logic clock_t;
logic reset_t;
logic in_t;
logic detectOk_t;
logic detectFail_t;

initial begin
clock_t = 0;
forever #1 clock_t = ~clock_t;
end

initial begin
in_t = 1;
reset_t = 1;
#2 reset_t = 0;
#10 in_t = 0;
#10 in_t = 1;
#10 $stop();
end

FSM1 DUT(
.clock(clock_t),
.reset(reset_t),
.in(in_t),
.detectOk(detectOk_t),
.detectFail(detectFail_t)
);

endmodule
</syntaxhighlight>

===Exemplul 2: Automat ce detecteaza fronturile crescatoare ale unui semnal===
Automatul ce detecteaza fronturile crescatoare are un singur semnal de intrare ''in'', care reprezinta semnalul analizat si o singura iesire, ''out'', generand pe aceasta un puls lung cat o perioada de ceas la fiecare aparitie a unui front crescator pe ''in''.

Vom avea nevoie de 3 stari:
* Q0: automatul intra in aceasta stare la reset si va ramane in aceasta atata timp cat intrarea este 0 (inca nu a aparut niciun front crescator).
* Q1: automatul intra in aceasta stare atunci cand apare pe intrare un front crescator. Dupa aparitia frontului crescator sunt doua posibilitati: linia ramane in 1, ceea ce duce la trecerea in starea Q2 care va duce iesirea in 0 dupa o perioada de ceas, sau linia trece in 0 dupa un ciclu de ceas, ceea ce duce la revenirea in starea Q0.
* Q2: automatul intra in aceasta stare atunci cand linia de intrare ramane in 1 mai mult de o perioada de ceas. Automatul va ramane in aceasta stare atata timp cat ''in'' ramane in 1 si va reveni in starea Q0 imediat ce ''in'' revine in 0.

Graful automatului este:

[[Fișier:Organigrama FSM rising edge.png]]

'''Implementarea automatului'''
<syntaxhighlight lang="Verilog">
module FSM2_Moore(
input logic clock,
input logic in,
input logic reset,
output logic out
);

localparam Q0 = 2'b00;
localparam Q1 = 2'b01;
localparam Q2 = 2'b10;

logic [1:0] state, state_next;

always_ff @(posedge clock) begin
if(reset == 1)
state <= Q0;
else
state <= state_next;
end

always_comb begin
state_next = state;
case(state)
Q0: begin
if(in == 1) state_next = Q1;
end
Q1: begin
if(in == 0) state_next = Q0;
if(in == 1) state_next = Q2;
end
Q2: begin
if(in == 0) state_next = Q0;
end
default: state_next = Q0;
endcase
end

assign out = (state == Q1); // iesirea depinde numai de stare => Moore

endmodule
</syntaxhighlight>

<syntaxhighlight lang="Verilog">
module FSM2_mealy(
input logic clock,
input logic in,
input logic reset,
output logic out
);

localparam stare_wait_1 = 1'b0;
localparam stare_wait_0 = 1'b1;

logic [1:0] state, state_next;

always_ff @(posedge clock) begin
if(reset == 1)
state <= stare_wait_1;
else
state <= state_next;
end

always_comb begin
state_next = state;
case(state)
stare_wait_1: begin
if(in == 1) state_next = stare_wait_0;
end
stare_wait_0: begin
if(in == 0) state_next = stare_wait_1;
end
default: state_next = Q0;
endcase
end

// daca pana acum semnalul a fost "0" si astept sa vina "1" si intrarea chiar vine "1" => am avut front crescator
assign out = (state==stare_wait_1) & (in==1); // in apare aici => dependenta iesiri de intrare => Mealy

endmodule
</syntaxhighlight>

'''Implementarea unui modul de test pentru FSM2'''
<syntaxhighlight lang="Verilog">
module FSM2_TB();

logic clock_t;
logic reset_t;
logic in_t;
logic out_t;

initial begin
clock_t = 0;
forever #1 clock_t = ~clock_t;
end

initial begin
in_t = 0;
reset_t = 1;
#2 reset_t = 0;
#10 in_t = 1;
#5 in_t = 0;
#10 in_t = 1;
#5 in_t = 0;
#10 $stop();
end

FSM2_Moore DUT(
.clock(clock_t),
.reset(reset_t),
.in(in_t),
.out(out_t)
);

endmodule

</syntaxhighlight>

Se poate observa ca automatele de tip Moore au un numar mai mare de stari iar automatele de tip Mealy au o logica mai complexa pentru calcularea iesirilor.

==Exerciții==
=== Exercițiul 1 ===
Implementați un automat finit ce detectează fronturile descrescătoare. Acesta are un singur semnal de intrare ''in'', care reprezintă semnalul analizat și o singură ieșire ''out'', generând pe această un puls lung cât o perioadă de ceas la fiecare apariție a unui front descrescător pe ''in''.

Realizați implementarea SystemVerilog plecând de la graful automatului:

[[Fișier:Graf FSM falling edge.png]]

=== Exercițiul 2 ===
Implementați un automat finit ce detectează atât fronturile crescătoare, cât și pe cele descrescătoare.

=== Exercițiul 3 ===
Să se implementeze un circuit care generează un semnal PWM cu un factor de umplere ce variază triungular, la fiecare front descrescător al unui semnal de intrare.

Schema circuitului este:

[[Fișier:FSM Exercitiu.png]]

Modulele componente ale circuitului sunt:
* '''FallingEdgeDetector''': Automat ce detectează fronturile descrescătoare ale semnalului de intrare.
* '''TriangularCounter''': Automat ce generează la iesire secvența de numere 64, 128, 192, 255, 192, 128, 64.
* '''Counter''': Numărător pe 8 biți cu reset sincron.
* '''COMP''': Comparator cu două intrări pe 8 biți. Ieșirea sa va fi 1 atunci când counter < out și 0 în rest.

=== Exercițiul 4 ===
Implementați automatul de control al unui aparat care vinde ciocolata.

O cafea costa 2.5 lei. Automatul accepta monezi de 50 de bani si hartii de 1 leu. Daca se depaseste suma, restul ramane in aparat si va fi folosit la urmatoarea tranzactie. Se accepta introducerea si a unei monezi si a unei bancnote in acelasi timp.

Intrarile sistemului sunt: clock (1b), reset (1b), in_50_b (1b), in_100_b (1b); iesirile sistemului sunt: give_cioco(1b).

Implementati automatul de control care va tine minte suma curenta si va da sau nu ciocolata in functie de aceasta. Implementati acest automat in ambele variante: Mealy si Moore.

CID aplicatii 10 : Aplicatii cu numaratoare

2024-10-22T13:55:43Z

Mihai.antonescu:

==Teorie==

Numaratoarele au extrem de multe aplicatii in lumea reala, cateva dintre acestea fiind descrise mai jos.

==Exemplu: Numaratul apasarilor unui buton==

Un prim sistem simplu cu numarator poate fi cel care contorizeaza de cate ori a fost apasat un buton sau, echivalent, cate persoane/masini au trecut printr-un senzor, de cate ori a fost deschisa o usa etc. Acest sistem se poate apoi dezvolta cu usurinta pentru a numara si oamenii care trec invers prin respectivul set de senzori prin adaugarea functionalitatii de up/down la numarator.

Un astfel de sistem simplu (varianta doar cu numarat intrari) ar arata in felul urmator:

[[Fișier:Aplicatii_numarator_exemplu_contor_senzor.png | 800px]]

Circuitul de debounce are rolul de a "curata" semnalul de intrare, astfel incat chiar si in prezenta zgomotului sau a unei activari indelungate a senzorului/butonului, sa se contorizeze un singur eveniment. O explicatie mai detaliata puteti gasi [[Circuitul_de_debounce|aici]].

Numaratorul numara evenimentele.

Transcodorul pentru display cu 7 segmente este apoi folosit pentru o mai usoara vizualizare a numarului curent.

'''Observatie:''' transcodorul pentru 7seg din exemplul de mai jos este in logica negativa. Daca circuitul fizic este in logica pozitiva trebuie adaugat un inversor la iesirea din acesta. De asemnea consider segmentul "a" pe bitul "0" si segmentul "h" pe bitul "6".

'''Descrierea debouncer-ului (fisierul debounce.sv):'''
<syntaxhighlight lang="Verilog">
module debounce
#(
parameter limit = 20'd650000
) (
input logic clock,
input logic in,
output logic out
);

logic [19:0] counter; // observatie: si circuitul de debounce foloseste un numarator
logic hit;

assign out = (counter == limit);

always_ff@(posedge clock)
begin
if(in == 0)
begin
counter <= 0;
hit <= 0;
end
else
begin
if(counter == limit)
begin
hit <= 1;
counter <= counter + 1;
end
else
begin
if(in == 1 & hit == 0)
begin
counter <= counter + 1;
end
end
end
end

endmodule
</syntaxhighlight>

'''Descrierea numaratorului pe 4b(fisierul counter_4b.sv):'''
<syntaxhighlight lang="Verilog">
module counter_4b
(
input logic clock,
input logic reset,
input logic en,
output logic [3:0] out
);

always_ff@(posedge clock)
begin
if(reset == 1)
begin
out <=0;
end
else
begin
if(en == 1)
begin
out <= out + 1;
end
else
begin
out <= out;
end
end
end

endmodule
</syntaxhighlight>

'''Descrierea transcodorului pentru afisaj cu 7seg(fisierul transcodor_7seg.sv):'''
<syntaxhighlight lang="Verilog">
module transcodor_7seg // logica negativa
(
input logic [3:0] in,
output logic [6:0] out
);

always_comb
begin
case(in)
4'd0: out = 7'b1000000;// h....a
4'd1: out = 7'b1111001;
4'd2: out = 7'b0100100;
4'd3: out = 7'b0110000;
4'd4: out = 7'b0011001;
4'd5: out = 7'b0010010;
4'd6: out = 7'b0000010;
4'd7: out = 7'b1111000;
4'd8: out = 7'b0000000;
4'd9: out = 7'b0010000;
4'd10: out = 7'b0001000;
4'd11: out = 7'b0000011;
4'd12: out = 7'b1000110;
4'd13: out = 7'b0100001;
4'd14: out = 7'b0000110;
4'd15: out = 7'b0001110;
default: out = 7'b1111111;//tot stins
endcase
end

endmodule
</syntaxhighlight>

'''Descrierea sistemului, modulul de top (fisierul top.sv):'''
<syntaxhighlight lang="Verilog">

module top
(
input logic clock,
input logic reset,
input logic button,
output logic [6:0] out // logica negativa
);

logic debounce_0_X_out;
logic [3:0] counter_4b_0_X_out;

debounce
#(
.limit(20'd50_000)
) debounce_0 (
.clock(clock),
.in(button),
.out(debounce_0_X_out)
);

counter_4b counter_4b_0
(
.clock(clock),
.reset(reset),
.en(debounce_0_X_out),
.out(counter_4b_0_X_out)
);

transcodor_7seg transcodor_7seg_0 // logica negativa
(
.in(counter_4b_0_X_out),
.out(out)
);

endmodule
</syntaxhighlight>

'''Descrierea test bench-ului(fisierul tb.sv):'''
<syntaxhighlight lang="Verilog">
`timescale 1ns / 1ps

module tb();

logic clock_tb;
logic reset_tb;
logic button_tb;
logic [6:0] out_tb;

top dut
(
.clock(clock_tb),
.reset(reset_tb),
.button(button_tb),
.out(out_tb) // logica negativa
);

initial
begin
clock_tb = 0;
forever
begin
#5 clock_tb = ~clock_tb;
end
end

initial
begin
reset_tb = 0;
button_tb = 0;

#50;
reset_tb = 1;
#50;
reset_tb = 0;
#100;

repeat(5) // vreau 5 apasari de buton
begin
button_tb = 1;
repeat(70_000)
begin
@(posedge clock_tb);
end
button_tb = 0;
repeat(70_000)
begin
@(posedge clock_tb);
end
end

#1000 $stop();
end

endmodule
</syntaxhighlight>

==Exercitii==

=== Exercitiul 1: Divizor de frecventa cu puteri ale lui 2===

Divizorul de frecventa are rolul de a genera un semnal de ceas mai lent din semnalul de ceas principal.
El este alcatuit doar dintr-un numarator, iar fiecare bit al acestuia va fi practic un semnal de ceas cu frecventa din ce in ce mai mica astfel (la jumate):

bit[0] - frecventa de 2 ori mai mica decat semnalul de ceas

bit[1] - frecventa de 2 ori mai mica decat bit[0], deci de 4 ori mai mica decat semnalul de ceas

bit[2] - frecventa de 2 ori mai mica decat bit[1], deci de 8 ori mai mica decat semnalul de ceas

Acest lucru se poate observa si in poza ce urmeaza:

[[Fișier:Freq_divider_output.png| 800px]]

Implementati acest circuit, si folosind ledurile prezente pe placa, incercati sa conectati bitul corespunzator la leduri astfel incat cel mai din dreapta led sa clipeasca cu o frecventa cat mai apropiata de 1s.

'''Observatie:''' Printr-un astfel de divizor de frecventa minimal, un numar foarte mic de frecvente poate fi generat. Daca se doreste generarea unui semnal periodic cu o perioada exacta, diferita de cele posibile prin acest mecanism, se poate construi urmatorul circuit:

===Exercitiul 2: Divizor de frecventa ce poate genera orice perioada===

Un astfel de divizor de frecventa este construit ca in figura de mai jos:

[[Fișier:Freq_div_orice_freq.png | 800px]]

Prin adaugarea constantei "limit", perioada semnalului de iesire poate sa fie orice multiplu a perioadei semnalului de ceas.

Bistabilul de tip t, se modifica atunci cand limita este atinsa si practic iesirea lui este semnalul periodic dorit (cu observatia ca o perioada a semnalului de iesire necesita 2 numarari pana la limita).

Sa se calculeze valoarea necesara pentru "limit" astfel incat pe leduri sa se genereze semnal cu perioada exact 1s.

'''Observatie:''' In FPGA exista fizic trasee speciale pentru reset si ca sinteza sa le foloseasca pe acestea in mod optim nu este recomandat sa se puna logica (cum e aici poarta sau) pe acestea. Modificati schema de mai sus astfel incat sa eliminati respectiva poarta de pe reset. (Sfat: numaratorul va avea acum si intrari de load: semnalul de comanda si data propriu zisa)

===Exercitiul 3: PWM (Pulse Width Modulation)===

PWM este un concept folosit foarte des in multiple ramuri ale ingineriei, de la transmisiunea informatiei pana la controlul motoarelor sau al intensitatii ledurilor din instalatii de Craciun. El se refera la a avea un semnal periodic cu factor de umplere variabil, asa cum este aratat in poza de mai jos :

[[Fișier:Pwm.png| 800px]]

Generarea unui astfel de semnal periodic se face printr-un numarator si un comparator, ca in figura de mai jos:

[[Fișier:Pwm_schematic.png | 800px]]

Raportul dintre limita pusa si valoarea la care numaratorul se reseteaza este practic factorul de umplere selectat.

Pentru testare pe placa, cei 6b ai limitei provin de la switch-uri si butoane. Afisarea se face pe led[0].

Testati acest circuit in simulare si apoi implementati pe placa pentru o valoare fixa a limitei. Implementati in paralel mai multe generatoare de semnal PWM cu limite diferite, astfel incat sa observati diferentele de intentistate dintre ledurile comandate de acestea.

===Exercitiul 4: PWM cu limita variabila===

Un exemplu foarte uzual de folosire a PWM este aprinderea ledurilor cu diverse pattern-uri. Factorul de umplere determina intensitatea cu care ledul este aprins. Un PWM cu o limita variabila automata va face ledul sa para din ce in ce mai stins sau din ce in ce mai luminos (exemplu: instalatii de Craciun). Combinand asta cu leduri RGB se obtin efecte de schimbare a culorii ledului aparent la intamplare.

Un astfel de circuit se realizeaza punand inca un numarator in locul limitei, ca in poza de mai jos:

[[Fișier:Pwm_duty_cycle_up_schematic.png | 800px]]

Pentru o functionalitate suplimentara, anume a pastra un anumit factor de umplere mai multe perioade, am adaugat inca un numarator.

Pentru claritatea desenului, nu am mai tras efectiv firul de ceas catre intrarile unde acesta se duce.

Rezultatul este:

[[Fișier:Pwm_duty_cycle_up_output.png | 800px]]

Testati circuitul propus prin simulare si apoi vizualizati implementarea sa pe placa. Alegeti limite potrivite astfel incat sa puteti observa usor rezultatul.

'''Bonus:''' Incercati sa adaugati si parametri pentru LIMIT_DUTY_CYCLE_LOW si LIMIT_DUTY_CYCLE_HIGH, care sa permita factorului de umplere sa varieze doar intre ele (numaratorul va avea nevoie de intrari pentru comanda de load si data load, ca sa poata incepe de la orice valoare).

'''Bonus:''' Modificati circuitul astfel incat semnalul de iesire sa isi schimbe sensul de variatie al factorului de umplere cand ajunge cu acesta la capat. In forma curenta factorul de umplere creste de la 0% la 100% si apoi se reseteaza brusc la 0%, repetand acest ciclu. Se vrea ca la ajungerea la 100% sa inceapa o scadere treptata catre 0%, urmata apoi de o urcare s.a.m.d.

===Exercitiul 5: Ceas===

Un ceas poate fi construit cifra cu cifra, folosind numaratoare si comparatoare (si transcodoare pentru display cu 7seg ca sa se vada totul mai bine pe placa).

Incercati sa implementati un ceas cu milisecunde, secunde si minute in varianta comportamentala.

'''Observatie:''' Va fi nevoie fie separat, fie in modul de un numarator cu frecventa rezolutiei dorite (aici 1 ms).

'''Observatie:''' Codul va contine multe "if" de tipul "daca cifra unitatilor secundelor a ajuns la 10, se face 0 si cresc cifra zecilor", repetate pentru fiecare cifra.

Incercati si o implementare structurala a ceasului, mergand pe aceeasi idee. Fiecare cifra va contine numaratorul ei. Cand numaratorul unei cifre ajunge ajunge la limita sa, va da enable pentru numaratorul cifrei urmatoare. Daca este nevoie se pot folosi si porti aditionale (ex: ca sa creasca minutul cifra zecilor secundelor trebuie sa fie 5 si cifra unitatilor secundelor trebuie sa fie 9).

'''Observatie:''' Va fi nevoie de un numarator cu frecventa rezolutiei dorite (aici 1 ms sau 1s).

'''Observatie:''' Pentru a scrie mai putin puteti face un numarator doar cu secunde si minute. Principiul de baza este acelasi si daca aveati milisecunde.

'''Observatie:''' Simularea a cateva milisecunde sau chiar secunde este un proces indelungat (dureaza minute-ore fizice), astfel strict pentru simulari se recomanda ceasul sa functioneze cu microsecunde sau milisecunde maxim.

CID aplicatii 8 : Registre si memorii RAM

2024-10-22T13:55:06Z

Mihai.antonescu:

==Teorie==

Acest laborator are scopul de a prezenta circuitele secventiale simple: registre si memorii RAM.

Pornind de la bistabilii prezentati/construiti in laboratorul anterior, apare notiunea de registru, acesta fiind o grupare de bistabili. Astfel in loc sa se memoreze un singur bit de informatie (bistabil), se pot memora acum numere pe mai multi biti (registru).

Din exterior, un registru este vazut astfel:

[[Fișier:Registru_exterior_view.png | 400px]]

:Semnalul de "clock" controleaza sincronizarea registrilor din tot sistemul.
:Semnalul de "reset" aduce registrul la o valoare initiala (uzual 0).
:Semnalul de "we" (write enable) controleaza salvarea unor date noi. Cand acesta este activ, data de pe intrarea "data_in" se salveaza in registru.
:Semnalul "data_in" reprezinta datele ce se doresc a fi scrise in registru.
:Semnalul "data_out" reprezinta valoarea stocata in registru.

Semnalele "data_in" si "data_out" pot fi pe oricat de multi biti se doreste, in mod uzual multipli de 8.

Pornind de la notiunea de registru (care poate fi vazut ca o memorie cu o locatie si avand "m" biti) se doreste cresterea acestei memorii astfel incat aceasta sa curpinda mai multe locatii adresabile, unde se pot stoca date. Adaugand mai multi registri in paralel, unul langa altul, si cateva circuite de tip mux/demux se poate obtine o memorie de tip RAM (Random Access Memory), cu "m" locatii de "n" biti fiecare. Aceste memorii se cheama "Random Access" deoarece permit si scriere si citire. In functie de tehologia folosita, memoriile RAM pot fi construite din bistabili sau din latch-uri.

Din exterior, o memorie RAM este vazuta astfel:

[[Fișier:Ram_mXn_1read_1write_exterior_view.png ‎| 400px]]

Semnalele acestui circuit se pot imparti in semnale ce tin de interfata de scriere sau interfata de citire si mai apoi in semnale de date si semnale de control. Interfata sa este:

:Semnalul de "clock": controleaza sincronizarea registrilor din memorie.
:Semnalul "addr_read": adresa de la care se citesc datele.
:Semnalul "data_read": data ce se citeste.
:Semnalul de "we": semnal de control ce controleaza activarea scrierii. Scrierea are loc doar cand acest semnal este activ.
:Semnalul "addr_write": adresa la care se scriu datele.
:Semnalul "data_write": data ce urmeaza a fi scrisa atunci cand semnalul "we" este activ.

'''Observatie''': Orice memorie are "m" locatii de "n" biti. Semnalele de "data_read" si "data_write" au aceeasi dimensiune, "n", numarul de biti ai fiecarei locatii. Semnalele de adresa au dimensiunea log2(m). Pentru o memorie cu 16 locatii va fi nevoie de 4 biti de adresa pentru a putea selecta orice locatie, pentru 32 locatii 5b s.a.m.d.

'''Observatie''': In unele situatii se mai poate pune un registru suplimentar pe iesirea datelor, cu rol in sincronizare si evitarea timpilor de propagare prea lungi intre elemente de memorare (ajuta implementarea conceptului de pipeline).

'''Observatie''': Exista mai multe variante de memorii RAM (cu registru pe iesire/fara, multiport/single port citire, adrese separate sau nu pentru citire/scriere). Cea de mai sus este o memorie cu un singur port de citire, fara registru suplimentar pe iesire, ce foloseste adrese distincte pentru citire si pentru scriere (la fel de bine se poate lucra si cu o singura adresa, comuna pentru scriere si citire).

'''Observatie''': Memoriile RAM pot sa nu aiba reset, utilizatorul trebuie apoi sa aiba grija sa citeasca doar din locatii scrise de el anterior.
In mod uzual ele nu au reset.

==Exemple==

===Exemplul 1 : Registrul===

In urmatorul exemplu se implementeaza registrul descris mai sus:

'''Descrierea registrului (fisierul register_8b.sv):'''
<syntaxhighlight lang="Verilog">
module register_8b
(
input logic clock,
input logic reset, // activ pe "1"
input logic we,
input logic [7:0] data_in,
output logic [7:0] data_out // data_out are aceeasi dimensiune ca data_in
);

always_ff@(posedge clock) // clock sincronizeaza actiunile circuitului
begin // doar pe edge-ul pozitiv circuitul actioneaza
if(reset == 1)
begin
data_out <= 0;
end
else
begin
if(we == 1) // comanda de scriere
begin
data_out <= data_in;
end
else // puteam sa omit acest else
begin
data_out <= data_out; // raman datele salvate anterior
end
end
end

endmodule
</syntaxhighlight>

Un alt mod de a scrie un registru este dat mai jos, cu observatia ca aici am pus semnalul de reset activ in logica negativa:

'''Descrierea registrului (fisierul register_8b_v2.sv):'''
<syntaxhighlight lang="Verilog">
module register_8b_v2
(
input logic clock,
input logic reset_n, // activ in "0"
// uzual semnalel cu n in fata sau la sfarsit sunt in logica negativa: nreset, resetn
input logic we,
input logic [7:0] data_in,
output logic [7:0] data_out
);

logic [7:0] memorie_efectiva;

assign data_out = memorie_efectiva;

always_ff@(posedge clock)
begin
if( reset_n == 0)
begin
memorie_efectiva <= 0;
end
else
begin
if(we == 1)
begin
memorie_efectiva <= data_in;
end
end
end

endmodule
</syntaxhighlight>

'''Descrierea test bench-ului registrului pe 8biti: (fisierul register_8b_tb.sv):'''
<syntaxhighlight lang="Verilog">
`timescale 1ns / 1ps

module register_8b_tb();

logic clock_tb;
logic reset_tb;
logic we_tb;
logic [7:0] data_in_tb;
logic [7:0] data_out_tb;

register_8b dut // varianta cu reset activ in "1"
(
.clock(clock_tb),
.reset(reset_tb),
.we(we_tb),
.data_in(data_in_tb),
.data_out(data_out_tb)
);

initial
begin
clock_tb = 0;
forever
begin
#5 clock_tb = ~clock_tb; // perioada totala 10 !!!
end
end

initial
begin
reset_tb <= 0;
we_tb <= 0;
data_in_tb <= 0;
// observatie: pana la primul reset sau prima scriere, valoarea din registru va fi necunoscuta (in simulare X)

// dau reset la circuit
@(posedge clock_tb); // astept sa treaca 1 clock cycle
reset_tb <= 1;
@(posedge clock_tb);
reset_tb <= 0;

repeat(5) // dupa 5 cicli de ceas
begin
@(posedge clock_tb);
end

// incep sa fac scrieri
we_tb <= 1;
data_in_tb <= 5;
@(posedge clock_tb);
we_tb <= 0;
data_in_tb <= 10; // scrierea asta nu se face deoarece nu am write enable activ
@(posedge clock_tb);
data_in_tb <= 11; // nici asta
@(posedge clock_tb);
data_in_tb <= 12; // nici asta
@(posedge clock_tb);
we_tb = 1;
data_in_tb <= 42; // asta da
@(posedge clock_tb);
data_in_tb <= 51; // si asta da
@(posedge clock_tb);
we_tb <= 0;

repeat(5) // dupa 5 cicli de ceas
begin
@(posedge clock_tb);
end
$stop();
end

endmodule
</syntaxhighlight>

===Exemplul 2: Memorie RAM===

In urmatorul exemplu se implementeaza memoria RAM descrisa mai sus, particularizata pentru 64 de locatii a cate 8b fiecare:

'''Descrierea memoriei RAM: (fisierul ram64x8_v1.sv):'''
<syntaxhighlight lang="Verilog">
module ram64x8_v1
(
input logic clock,
//interfata de citire
input logic [5:0] addr_read, // 64 locatii => 6 biti de adresa
output logic [7:0] data_read, // fiecare locatie are 8b
// interfata de scriere
input logic we,
input logic [5:0] addr_write,
input logic [7:0] data_write
);

logic [7:0] memorie_efectiva [0:63]; // memorie cu locatiile de la 0 la 63, fiecare avand 8 biti

assign data_read = memorie_efectiva[addr_read]; // fara registru pe iesire => citire asincrona fata de clock

always_ff@(posedge clock)
begin
if(we == 1)
begin
memorie_efectiva[addr_write] <= data_write; // scriu la locatia data de "addr_write" din memoria efectiva datele "data_write"
end
end

endmodule
</syntaxhighlight>

Acesta va fi folosit si pe post de modul de "top".

Echivalent se poate folosi si sintaxa cu always ca mai jos.

'''Descrierea memoriei RAM: (fisierul ram64x8_v2.sv):'''
<syntaxhighlight lang="Verilog">
module ram64x8_v2 // varianta cu always combinational pe citire
(
input logic clock,
//interfata de citire
input logic [5:0] addr_read,
output logic [7:0] data_read,
// interfata de scriere
input logic we,
input logic [5:0] addr_write,
input logic [7:0] data_write
);

logic [7:0] memorie_efectiva [0:63];

always_comb // citire asincrona fata de clock
begin
data_read = memorie_efectiva[addr_read];
end

always_ff@(posedge clock)
begin
if(we == 1)
begin
memorie_efectiva[addr_write] <= data_write; // scriu la locatia data de "addr_write" din memoria efectiva datele "data_write"
end
end

endmodule
</syntaxhighlight>

'''Descrierea test bench-ului memoriei RAM: (fisierul ram64x8_v1_tb.sv):'''
<syntaxhighlight lang="Verilog">
`timescale 1ns / 1ps

module ram64x8_tb();

logic clock_tb;
logic [5:0] addr_read_tb;
logic [7:0] data_read_tb;
logic we_tb;
logic [5:0] addr_write_tb;
logic [7:0] data_write_tb;

ram64x8_v1 dut
(
.clock(clock_tb),
//interfata de citire
.addr_read(addr_read_tb), // 64 locatii => 6 biti de adresa
.data_read(data_read_tb), // fiecare locatie are 8b
// interfata de scriere
.we(we_tb),
.addr_write(addr_write_tb),
.data_write(data_write_tb)
);

initial
begin
clock_tb = 0;
forever
begin
#5 clock_tb = ~clock_tb; // perioada totala 10 !!!
end
end

initial
begin
we_tb <= 0;
data_write_tb <= 0;
addr_read_tb <= 0; // citind de la o adresa nescrisa inca, iesirea e necunoscuta
addr_write_tb <= 0;
repeat(5) // dupa 5 cicli de ceas
begin
@(posedge clock_tb);
end

// incep sa fac scrieri
we_tb <= 1; // scriu data 5 la adresa 10
addr_write_tb <= 10;
data_write_tb <= 5;
addr_read_tb <= 11; // citind de la o adresa nescrisa inca, iesirea e necunoscuta
@(posedge clock_tb);
we_tb <= 0; // scrierea asta nu se face deoarece nu am write enable activ
addr_write_tb <= 11;
data_write_tb <= 10;
@(posedge clock_tb);
data_write_tb <= 11; // nici asta
@(posedge clock_tb);
data_write_tb <= 12; // nici asta
@(posedge clock_tb);
we_tb <= 1;
addr_write_tb <= 20; // scriere ok
data_write_tb <= 42; // scriu data 42 la adresa 20
@(posedge clock_tb);
data_write_tb <= 51; // si asta; suprascriu datele anterioare la adresa 20.
@(posedge clock_tb);
addr_write_tb <= 21;
data_write_tb <= 11; // scriere ok
addr_read_tb <= 20; // citesc de la adresa 20, scrisa anteior deci voi vedea date cunoscute pe iesire.
@(posedge clock_tb);
addr_write_tb <= 23;
data_write_tb <= 14; // scriere ok
addr_read_tb <= 21; // variez adresa de citire si pot parcurge memorie locatie cu locatie
@(posedge clock_tb);
we_tb <= 0; // opresc scrierea

repeat(5) // dupa 5 cicli de ceas
begin
@(posedge clock_tb);
end
$stop();
end

endmodule
</syntaxhighlight>

[[Fișier:Ram64X8_waveform.png|1000px]]

In forma de unda de mai sus sunt marcate momentele de timp cand au loc scrieri in memorie (cand am write enable activ si valori cunoscute pentru data si adresa de scriere). Se salveaza valorile imediat la stanga frontului de ceas.

In simularea completa, se poate observa si scrierea in registrii din memorie a datelor dorite la adresa setata.

==Exercitii==
===Exercitiul 1: RAM cu registru la iesire===

Pornind de la exemplul anterior, se doreste adaugarea unui registru la citirea datelor, astfel citirea devenind sincrona cu semnalul de ceas. In cod acest lucru se poate face foarte usor, punand operatia de citire pe ceas.

Se doreste simularea si apoi testarea fizica a acestei memorii. Simularea noii memorii se face prin executarea a 3 scrieri la adrese diferite si citirea apoi a datelor respective. Sinteza si testarea fizica necesita micsorarea memoriei din cauza numarului limitat de switchuri/butoane al placii. Vom lucra acum cu o memorie de 8 locatii X 4 biti.
Adresa va fi comandata de switch-uri si datele de intrare din butoane. Se va folosi Button[0] pentru semnalul de "we" (write enable). Afisarea datelor se va face pe leduri.

===Exercitiul 2: RAM multiport citire===

Pornind de la exercitiul 1, se doreste modificarea memoriei astfel incat sa poata fi citite 2 locatii simultan si independent de adresa la care se face scrierea. Se pastreaza citirea sincrona.

Se obtine astfel un circuit a carui interfata este la randul ei compusa din 3 interfete (+semnal comun "clock"):

:- interfata de scriere

:- interfata de citire 0

:- interfata de citire 1

Interfata circuitului arata ca in figura de mai jos:

[[Fișier:Ram_64X8_2read_1write_exterior_view.png | 400px]]

Generati forme de unda corespunzatoare pentru a testa aceasta memorie.

'''Observatie''': Blocul de registri (register file) din interiorul procesoarelor (vedeti AMP) poate fi o astfel de memorie RAM. Are 2 adrese pentru citirea celor 2 operanzi care intra in ALU si o adresa pentru rezultatul calculului ce este salvat.

===Exercitiul 3: Registrul paralel-serie===

Descrieti comportamental un registru paralel-serie. Acesta are rolul de a salva datele de la intrare pe "n" biti (aici 8) si apoi de a le scoate la iesire bit cu bit.

Interfata acestuia este data in desenul de mai jos.

[[Fișier:Registru_paralel_serie.png | 400px]]

:Semnalul de "en" (enable) are rolul de a controla deplasarea, care se executa prin operatia de shiftare la dreapta ">>". Daca acesta are valoarea "1", datele salvate se muta la dreapta cu o pozitie.
:Semnalul de write_en/start/save are rolul de a salva cei 8 biti care urmeaza a fi serializati.

Generati forme de unda corespunzatoare pentru a testa aceast circuit (minim 3 scrieri/serializari).

'''Bonus''': Realizati acelasi circuit folosind o descriere structurala.

===Exercitiul 4: Registrul serie-paralel===

Descrieti comportamental un registru serie-paralel. Acesta are rolul de a salva date introduse bit cu bit ca apoi sa fie scoase cate "n" biti deodata.

Interfata acestuia este data in desenul de mai jos.

[[Fișier:Registru_serie_paralel.png | 400px]]

Semnalul de "en" (enable) are rolul de a controla deplasarea, care se executa prin operatia de shiftare la dreapta ">>". Daca acesta are valoarea "1", datele salvate se muta la dreapta cu o pozitie.

Generati forme de unda corespunzatoare pentru a testa aceast circuit (minim 3 scrieri/paralelizari).

Citirea se poate face oricand, desi doar dupa "n" pasi, va fi cu valoarea corecta.

===Exercitiul 5: Registrul de intarziere pe 8b===

Prin conectarea in serie a mai multor registri pe 8b (astfel incat data ce iese din unul sa fie intrare pentru urmatorul) se pot construi registri de intarziere cu "x" cicli de ceas. Cum fiecare registru salveaza datele pe ceas, se poate spune ca datele de la iesire sunt intarziate cu un ceas fata de datele de la intrare, astfel o intarziere cu "x" cicli de ceas se obtine prin punerea in serie a "x" registri.

Pornind de la un registru simplu pe 8b (exemplul 1), construiti structural un registru de intarziere cu 4 cicli de ceas.

Testati functionarea acestuia prin simulare. Datale introduse trebuie sa iasa defazate cu 4 cicli de ceas (adica cu 4 cicli de ceas mai tarziu).

CID aplicatii 5 : Exercitii cu circuite combinationale

2024-10-22T13:54:30Z

Mihai.antonescu:

==Teorie==

Acest laborator are rolul de a sedimenta cunostiintele dobandite anterior.

El consta in exercitii separate, unele date ca subiect la lucrarea 1 in anii anteriori si cateva notiuni de teorie si sintaxa ajutatoare.

==Teorie: Parametrizare==
Parametrizarea este un mod de a generaliza codul scris pentru a nu fi nevoie sa scrii acelasi modul de mai multe ori doar pentru ca circuitul isi schimba o dimensiune.

Pentru a intelege mai clar avantajele si sintaxa urmariti urmatorul exemplu:

Fisierul sumator.sv:
<syntaxhighlight lang="Verilog">
module sumator # // <= diez deoarece urmeaza lista cu paramteri
( // parametri
parameter data_size = 4 // valoare default 4
// alti parametri aici daca este nevoie, separati prin virgula
)
( // interfata
input logic [data_size-1:0] in0, // si pot folosii parametrul "data_size" pentru dimensiunea bus-ului
input logic [data_size-1:0] in1,
output logic [data_size-1:0] out0
);

assign out0 = in0 + in1;

endmodule
</syntaxhighlight>

Cand se instantiaza un modul parametrizat, se specifica valorile parametrilor astfel:
<syntaxhighlight lang="Verilog">
sumator # ( // parametri
.data_size(8) // se genereaza un sumator pe 8b
)
nume_instanta_0
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out0)
);

sumator # ( // parametri
.data_size(32) // se genereaza un sumator pe 32b
)
nume_instanta_1
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out1)
);

sumator nume_instanta_2 // se genereaza un sumator de dimensiune default, aici 4, asa cum e scris in modulul "sumator"
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out2)
);
</syntaxhighlight>

Puteti folosi parametrizarea in exercitiul 3 de mai jos. Acolo sunt 2 tipuri de multiplexoare, unul cu intrarile pe 1 bit si unul cu intrarile pe 2 biti. Poate fi scris un singur modul parametrizat care sa acopere ambele situatii.

==Teorie: Concatenarea==

Pentru o mai usoara conectare a firelor sau pentru o mai buna organizare si expresivitate a codului, de multe ori este util ca fire individuale sa fie grupate impreuna sau ca un bus de mai multi biti sa fie separat in fire individuale. Acest lucru se face folosind concatenarea, prin simbolurile "{ }".

Un exemplu de folosire a concatenarii este oferit mai jos.
Un sumator pe 8b are rezultatul pe maxim 9b, in cazul in care ambele numere sunt mari. Astfel apare un bit de carry out.
<syntaxhighlight lang="Verilog">
module sumator (
input logic [7:0] in0,
input logic [7:0] in1,
output logic [7:0] out0,
output logic carry_out
);

assign {carry_out,out0} = in0 + in1; // fac suma intre in0 si in1 iar rezultatul il pun pe cei 9b alcatuiti din: 1b carry_out si 8b out0, in ordinea asta

endmodule
</syntaxhighlight>
Se pot concatena oricat de multe semnale, puse in "{ }" si separate prin virgula. Atentie la dimensiunile firelor care se concateneaza.

Se poate de asemenea face concatenare si la dreapta egalului, astfel:
<syntaxhighlight lang="Verilog">
assign fir_pe_10_b = {fir_pe_3b,fir_pe_5b,fir_pe_1b,fir_pe_1b};
</syntaxhighlight>
In exemplul anterior ultimi 2b ai "fir_pe_10_b" vor avea mereu aceeasi valoare, provenind din acelasi fir. Sintaxa SystemVerilog permite asta.

Puteti folosii concatenarea, in exercitiul 2, la flag-ul de overflow.

==Teorie: Constante ca intrari in circuite==
In cazul in care se doreste scrierea unor constante la intrarea unor module, acestea se pun direct intre paranteze la instantiere.
De exemplu, pentru multiplexorul de jos din subiectul "alu structural", intrarea "in3" este conectata la valoarea "1". Sintaxa pentru aceasta este: ".in3(1),".

==Teorie: "_"==
Simbolul "_" (underscore) este ignorat de SystemVerilog si ajuta vizual la citirea semnalelor pe mai multi biti. De exemplu 16'b1010010111110000 este identic cu 16'b1010_0101_1111_0000, al doilea fiind totusi mai usor de citit.

==Exercitii==
===Exercitiul 1: ALU - descriere comportamentala===
Descrieți comportamental o unitate aritmetico-logică (ALU) care are la intrare 2 numere binare de câte 8 biți și poate calcula următoarele funcții:
:- suma celor două numere
:- diferența celor două numere
:- operații logice bit cu bit (bitwise): SI, SAU, XOR și inversele lor
:- operandul din stanga trece neschimbat
:- operandul din dreapta trece neschimbat
:- numărul din stânga este deplasat la stânga cu nr. de poziții indicat de numărul din dreapta
:- numărul din stânga este deplasat la dreapta cu nr. de poziții indicat de numărul din dreapta

Funcția executată la un anumit moment este determinată de configurația binară de pe intrarea de comandă (function).

ALU are de asemenea intrare de carry și ieșire de carry, plus alte două ieșiri - indicatori - pentru cazurile când rezultatul este zero și când cei doi operanzi sunt egali.

Intrarea de control va fi facuta pe 4 biti ca sa permita existenta a 16 operatii posibile. Fiecare numar de pe intrarea de control (combinatie de 0 si 1) va reprezenta o operatie din cele de mai sus. Scrierea se va face folosind un bloc "case" in functie de aceasta intrare.

===Exercitiul 2: ALU - descriere structurala===

[https://wiki.dcae.pub.ro/images/8/8f/Subiect_big_alu.pdf subiect_alu.pdf]

Daca se doreste selectarea doar a anumitor biti dintr-un bus (cum se vrea din instruction) acest lucru se poate face in 2 feluri:

a) cu fir aditional:
:''wire [1:0] fir_aditional1;''
:''assign fir_aditional1 = instruction[11:10];''
:// apoi la instantiere: ''.sel(fir_aditional1),''

b) direct in instantiere;
:la instantierea celor 2 mux4 din stanga, direct:
::''.sel(instruction[11:10]),''

Pentru a scrie mai putin (a nu face toate modulele de calcul separat + instantierea lor) si pentru ca e vorba de operatii simple, se poate pune operatia cu assign direct in top pe un fir declarat acolo, sau si mai prescurtat, direct operatia dorita cand se intantiaza modulul in care aceasta intra. De exemplu, pentru operatia de shift la dreapta care intra in primul multiplexor, se poate pune: ".in0(data0 >> data1),".

===Exercitiul 3:===

[https://wiki.dcae.pub.ro/images/3/3a/Subiect_muxes.pdf subiect_muxes.pdf]

===Exercitiul 4:===

[https://wiki.dcae.pub.ro/images/2/2e/Subiect_rom_luts.pdf rom_luts.pdf]

===Exercitiul 5: Sumator cu reprezentare in cifre zecimale===
Proiectati si verificati un sumator zecimal pentru numere cu 2 cifre

Modulul de top (Figura 1) este alcatuit din 2 blocuri de tip '''digitsum'''. Fiecare bloc aduna cifrele de pe aceasi pozitie.

'''Figura 1'''
Top level

[[Fișier: bcdsum.png]]

Blocul '''digitsum''' (Figura 2) este alctuit din 4 blocuri, 2 sumatoare binare pe 4 biti (de tip '''sum4'''), o instanta de '''cmp''' si un multiplexor elementar mux2

'''Figura 2'''
Blocul DIGIT SUM

[[Fișier: digit.png]]

Primul sumator aduna cifrele din domeniul [0...9] avand un rezultat intre [0 ... 18]

Comparatorul are la iesire 1 daca rezultatul este mai mare decat 9.

Daca rezultatul este mai mic decat 9, acesta este trimis in mod direct la iesirea '''digit''' a blocului '''digitsum'''.

Daca rezultatul este mai mare decat 9, o crectie este necesara si se aduna 6 la rezultat.

Comparatorul cu valoarea 9 este descris structural din porti in figura de mai jos:

'''Figure 3'''
the comparator

[[Fișier: cmp.png]]

Testbench-ul va genera stimuli pentru '''bcdsum''' ca in Figura 4.

Intrarea b0 a '''bcdsum''' se schimba la fiecare 5 pasi de simulare .

b1, a0 si a1 se schimba sincron cu b0 ca in Figura 4.

'''Figure 4'''

[[Fișier: teststimuli.png]]

Cerinte:
# '''cmp'''- descris structural la nivel de porti ca in Figura 3.
# '''sum4''' descris comportamental cu un assign continuu.
# '''mux''' descris comportamental cu always.
# '''digitsum''' descris strctural ca in Figura 2.
# modulul de top numit '''bcdsum''', descris structural ca in Figure 1.
# modulul de testbench, '''bcdsum_tb''', instantiaza '''bcdsum''' cu numele '''dut'''.
# in testbench, generati stimuli pentru intrarile circuitului testat.

CID aplicatii 3 : Circuite combinationale elementare

2024-10-22T13:54:09Z

Mihai.antonescu:

==Teorie==
Acest laborator are ca scop scrierea unor circuite combinationale simple si explorarea variantelor de sintaxa diferite ce ajung sa ofere aceeasi functionalitate. Sintaxa va fi explicata in comentariile exemplului rezolvat mai jos.

Descrierea circuitelor in SystemVerilog se face in una din doua forme:

:1) structurala - descrie cum un modul e alcatuit din module sau primitive mai simple

:2) comportamentala/behavioural - descrie cum se calculeaza iesirile din intrari

==Exemplu - Decodorul==
Decodorul este un circuit a carui iesire pe n biti are un singur bit de "1", anume cel selectat prin singura sa intrare pe log2(n) biti.
Astfel, pentru un decodor cu iesire pe 8b, intrarea va avea 3b (logaritm in baza 2 din 8) si tabelul de adevar va arata astfel:

{| class="wikitable"
|- bgcolor="#ddeeff" align="center"
|- bgcolor="#ddeeff" align="center"
| in(3b) || out(8b)
|- bgcolor="#ddffdd" align="center"
|000 || 0000_0001
|- bgcolor="#ddffdd" align="center"
|001 || 0000_0010
|- bgcolor="#ddffdd" align="center"
|010 || 0000_0100
|- bgcolor="#ddffdd" align="center"
|011 || 0000_1000
|- bgcolor="#ddffdd" align="center"
|100 || 0001_0000
|- bgcolor="#ddffdd" align="center"
|101 || 0010_0000
|- bgcolor="#ddffdd" align="center"
|110 || 0100_0000
|- bgcolor="#ddffdd" align="center"
|111 || 1000_0000
|}

Iesirea este numerotata de la bitul 7 (msb) pana la bitul 0 (lsb). Se observa ca daca intrarea are valoare "a", singurul bit de "1" din iesire este cel de pe pozitia "a".

'''Observatie:''' Atat in tabelul de mai sus, cat si in codul SystemVerilog poate sa apara "_" (underscore) ca sa ajute vizual la separarea/numararea cifrelor. Se foloseste in mod uzual la scrierea in binar ca sa grupeze 4b (o cifra in hexa).

Circuitul exemplu al acestui laborator va fi un decodor mai mic, cu 2 biti de intrare si 4 de iesire, avand tabelul de adevar:

{| class="wikitable"
|- bgcolor="#ddeeff" align="center"
|- bgcolor="#ddeeff" align="center"
| in(2b) || out(4b)
|- bgcolor="#ddffdd" align="center"
|00 || 0001
|- bgcolor="#ddffdd" align="center"
|01 || 0010
|- bgcolor="#ddffdd" align="center"
|10 || 0100
|- bgcolor="#ddffdd" align="center"
|11 || 1000
|}

O varianta de schema care implementeaza acest circuit este cea de mai jos:

[[Fișier:w3_exemplu_rezolvat.png ‎| 600px]]

In circuitul de mai sus, apare dubla negatie, respectivul semnal putand fi luat si direct de la intrare. Acest lucru se intampla din considerente electrice. Desi pe desene nu sunt trecute, fiecare poarta are si fire de alimentare si de masa. Astfel, pentru a evita fire de lungimi foarte mari sau fire care se propaga in multe intrari si probleme de cadere a tensiunilor, se folosesc astfel de buffere/repetoare.

Codul de mai jos exemplifica moduri diferite de a exprima aceasta functionalitate.
El contine comentarii referitoare la sintaxa de baza SystemVerilog, necesara implementarii modulelor in diverse moduri.

'''Descrierea modulului decodor - varianta structurala din porti, cu primitive (fisierul decodor_v1.sv):'''
<syntaxhighlight lang="Verilog">
module decodor_v1
(
input logic [1:0] in, // definirea intrarilor sub forma de "bus"
// bus-ul de intrare se numeste "in" si este pe 2 biti: in[1], in[0]
// fizic sunt 2 fire distincte, grupate pentru o mai simpla folosire.
output logic [3:0] out // avem o iesire, numita "out" pe 4 biti.
);

logic in_0_inv;
logic in_1_inv;
logic in_0_nat;
logic in_1_nat;

not not_gate_0(in_0_inv,in[0]); // aleg bitul 0 al lui in sa intre in aceasta poarta not;

not not_gate_1(in_1_inv,in[1]); // observatie: cele 2 fire si cele 2 porti putea fi comprimate intr-un bus + poarta not pe 2 biti.

not not_gate_2(in_0_nat,in_0_inv);

not not_gate_3(in_1_nat,in_1_inv);

and and_gate_0(out[0],in_1_inv,in_0_inv);

and and_gate_1(out[1],in_1_inv,in_0_nat);

and and_gate_2(out[2],in_1_nat,in_0_inv);

and and_gate_3(out[3],in_1_nat,in_0_nat);

endmodule
</syntaxhighlight>

'''Descrierea modulului decodor - varianta cu assign, urmand schema (fisierul decodor_v2.sv):'''
<syntaxhighlight lang="Verilog">
module decodor_v2
(
input logic [1:0] in,
output logic [3:0] out
);

// fiecare bit din iesire calculat independent
assign out[0] = ~in[0] & ~in[1];
assign out[1] = in[0] & ~in[1];
assign out[2] = ~in[0] & in[1];
assign out[3] = in[0] & in[1];

endmodule
</syntaxhighlight>

'''Descrierea modulului decodor - varianta cu assign, cu operatorul "?" (fisierul decodor_v3.sv):'''
<syntaxhighlight lang="Verilog">
module decodor_v3
(
input logic [1:0] in,
output logic [3:0] out
);

// operatorul "?": identic c/c++; (conditie) ? (if_true) : (if_flase);

assign out = (in==0) ? // if in == 0
1 : // if true: out = 1
(in==1) ? // else, verifica alt if.
2 : // if in !=0 si in == 1
(in==2) ?
4 :
8; // last case in==3

endmodule
</syntaxhighlight>

'''Descrierea modulului decodor - varianta cu always cu if (fisierul decodor_v4.sv):'''
<syntaxhighlight lang="Verilog">
module decodor_v4
(
input logic [1:0] in,
output logic [3:0] out
);

always_comb // mereu cand se schimba orice semnal, se "executa" ce e mai jos;
// always_comb genereaza un circuit combinational
begin // begin si end pe post de acolade din c/c++; delimiteaza if/else si altele asemenea; inclusiv always cu totul
if(in == 0)
begin // nota autorului: eu prefer sa pun begin/end asa. ele se pot pune si dupa conditie sau aliniate altfel.
// ^ preferinta personala legata de coding style, important e sa fiti consecventi in cum scrieti
out = 1;
end
else
begin
if(in == 1)
out = 2; // fiind o singura instructiune, begin/end se poate omite (identic c/c++)
else
begin // nota autorului: eu personal le pun mereu. in caz ca mai adaug linii in if dupa, sa fie deja puse
if(in == 2)
begin
out = 4;
end
else
begin
out = 8;
end
end
end
end//end pt always

endmodule
</syntaxhighlight>

'''Descrierea modulului decodor - varianta cu always cu case (fisierul decodor_v5.sv):'''
<syntaxhighlight lang="Verilog">
module decodor_v5
(
input logic [1:0] in,
output logic [3:0] out
);

always_comb
begin
case(in) // functioneaza ca switch/case din c/c++; sintaxa usor diferita
0: // if in == 0
begin
out = 1;
end
2'd1: // if in == 1; 2'd1 se traduce: pe 2 biti, in baza zece (eng: decimal, "d"), valoarea 1
begin // pt "0" de mai sus: daca nu se pune nimic se considera in baza zece.
out = 2;
end
2'b10: // if in == 2; scris in binar "b", 2'b10 => adica valoarea 2(10 binar) pe 2 biti
begin
out = 4;
end
2'h3: // if in == 3; scris in hexa (baza 16 "h", se poate si "x"), fiind numar mic, nu se vede diferenta fata de zecimal.
begin
out = 8;
end
default: // daca in == un caz netrat;
begin // aici inutil pt ca am tratat toate cazurile posibile; pus ca exemplu de sintaxa
out = 0;
end
endcase // orice "case" se inchide cu "endcase"
end

endmodule
</syntaxhighlight>

'''Descrierea modulului decodor - varianta cu assign comportamental (fisierul decodor_v6.sv):'''
<syntaxhighlight lang="Verilog">
module decodor_v6
(
input logic [1:0] in,
output logic [3:0] out
);

assign out = 1 << in;
// prin shiftare
// 1<<0 == 1 == 4'b0001;
// 1<<1 == 2 == 4'b0010;
// 1<<2 == 4 == 4'b0100;
// 1<<3 == 8 == 4'b1000;

endmodule
</syntaxhighlight>

'''Descrierea modulului top (fisierul top.sv):'''
<syntaxhighlight lang="Verilog">
// observatie:
// puteti da in vivado: rtl analysis -> open elaborated design -> schematic pentru a vedea desenul rezultat
// puteti vedea ca moduri diferite de scriere produc aparitia a diferite primitive de sinteza
module top
(
input logic [1:0] in,
output logic [3:0] out_v1, // fiecare varianta de decodor cu iesirea lui
output logic [3:0] out_v2, // toate ar trebui sa scoata acelasi rezultat
output logic [3:0] out_v3,
output logic [3:0] out_v4,
output logic [3:0] out_v5,
output logic [3:0] out_v6
);

decodor_v1 decodor_v1_0
(
.in(in),
.out(out_v1)
);

decodor_v2 decodor_v2_0
(
.in(in),
.out(out_v2)
);

decodor_v3 decodor_v3_0
(
.in(in),
.out(out_v3)
);

decodor_v4 decodor_v4_0
(
.in(in),
.out(out_v4)
);

decodor_v5 decodor_v5_0
(
.in(in),
.out(out_v5)
);

decodor_v6 decodor_v6_0
(
.in(in),
.out(out_v6)
);

endmodule
</syntaxhighlight>

==Exercitii==
===Exercitiul 1: Multiplexorul===

Multiplexorul (mux) este un circuit ce are rolul de a selecta una dintre intrari pentru ca aceasta sa ajunga la iesire.

Imaginati-va o intersectie in care toate masinile vor sa se iasa catre aceasi strada. Pentru a evita accidente, este nevoie de un element de control, de selectie, prin care se hotaraste care dintre intrari este lasata sa ajunga la iesire, in respectivul moment de timp.
Multiplexorul poate fi de asemenea vazut ca un comutator.

'''Observatie 1:''' conceptul de baza al multiplexarii este absolut vital si o sa apara des in multe zone ale ingineriei si la materii foarte diferite.
Ca niste mici exemple, el se foloseste in:
:a) telecomunicatii - cine are voie sa comunice pe un fir la un moment de timp
:b) internet - routere - cine trimite pachetele tcp/ip catre destinatia x
:c) panouri cu leduri - aprindere pe rand a ledurilor (de la instalatii de craciun pana la ecrane/televizoare care aprind randurile alternativ)

'''Observatie 2:''' numarul de intrari maxim posibile este 2^(nr_biti_selectie)

'''Observatie 3:''' multiplexoarele pot avea intrarile date si iesirea pe mai multi biti.

'''Observatie 4:''' este de ajutor sa incepeti sa vedeti circuitele ca avand o cale de date ce sunt procesate si o cale de control care decide cum se face asta.
Aici calea de date este alcatuita din intrari si iesire, iar calea de control din firele de selectie.
Acest principiu se propaga si in arhitectura microprocesoarelor unde vor aparea magistrale si memorii de date/instructiuni.

Pornind de la exemplul oferit, implementati multiplexorul in cat mai multe variante.

Multiplexorul cu 2 intrari pe un bit fiecare (mux elementar) este desenat in figurile de mai jos: cum este vazut din exterior (prima figura) si alcatuirea lui interna (a doua figura).

[[Fișier:mux2_general.png ‎| 300px]]
[[Fișier:mux2_schema_interna.png ‎| 300px]]

Pentru testarea circuitului, generati in testbench urmatoarele forme de unda (liniile punctate reprezinta 10ns):

[[Fișier:Wavedrom_mux2.png ‎| 500px]]

===Exercitiul 2: Implementati un mux4 (multiplexor cu 4 intrari)===

Interfata lui este ca in figura de mai jos.

[[Fișier:mux_general.png ‎| 300px]]

Pentru varianta lui structurala, mux4 se construieste din mai multe mux2 legate corespunzator. Incercati sa construiti voi aceasta schema.

Pentru testarea circuitului, generati in testbench urmatoarele forme de unda (liniile punctate reprezinta 10ns):

[[Fișier:Wavedrom_mux4.png ‎| 500px]]

===Exercitiul 3: Demultiplexorul===

Demultiplexorul (demux) este un circuit ce are rolul de a selecta catre care iesire se va duce intrarea.
Imaginati-va o intersectie in care intra o singura masina si trebuie sa decida daca iese catre stanga/inainte/dreapta.

Pentru acest exercitiu se va implementa un demux2 (cu 2 iesiri).

'''Observatie 1''': celelalte iesiri, cele neselectate iau valoarea 0.

'''Observatie 2''': numarul de iesiri maxim posibile este 2^(nr_biti_selectie)

Interfata demultiplexorului este data mai jos. Incercati sa construiti acest circuit in cat mai multe variante de sintaxa posibile (minim4).

[[Fișier:demux2_general.png ‎| 300px]]

Generati forme de unda pentru a vedea functionarea demultiplexorului.

===Exercitiul 4: Sumatorul===

Sumatorul are rolul de a scoate la iesire suma celor 2 intrari.

Uzual el mai are si intrare si iesire de "carry" adica de transport (cand se depaseste baza de numarare si e nevoie de inca o cifra, ex in zecimal: 88 + 20 = 108; apare o cifra in plus, cifra sutelor).

[[Fișier:sumator_8b_general.png ‎| 300px]]

Observatie: desi scrierea cu assign si + este cea mai usoara si clara pentru un sumator, si celelalte moduri de scriere sunt posibile.
La aceasta scriere, daca se doresta ca sumatorul sa aiba carry out, sumatorul se poate face cu un bit mai mare decat intrarile, iar acel bit sa fie conectat la carry out. Practic, obtii un rezultat pe "n" biti + un bit de depasire, anume msb-ul.

Generati formele de unda necesare testarii sumatorului pe 8b.

Pentru a vedea pas cu pas cum se construieste un sumator pe 8b puteti parcurge urmatoarea platforma de laborator: [https://wiki.dcae.pub.ro/images/0/0f/Cid_gan_sumator_aplicatia_2.pdf Sumator.pdf]

===Exercitiul 5: Comparatorul===

Comparatorul are rolul de a vedea relatia dintre cele 2 intrari ale sale, daca cele 2 numere sunt egale, daca primul e mai mic sau mai mare.

Astfel el poate avea 3 iesiri dintre care se activeaza doar una:
:- iesire de egalitate
:- iesire de in0 < in1
:- iesire de in0 > in1

Se mai poate face si o varianta de comparator cu 2 iesiri, asa cum veti studia la arhitectura microprocesoarelor.
:- iesire de egalitate
:- iesire care este 0 daca in0<in1 sau 1 daca in0>in1

Aceasta abordare este folosita la AMP la flag-urile din procesoare, folosind operatia de scadere si flag-urile de "zero" si "negativ".

Scrieti modulul de comparator, in ambele variante de interfata. Intrarile pot avea oricat de multi biti (comparator mai mic sau mai mare), pentru acest exercitiu sa il faceti pe 4b.

Scrieti un testbench care sa genereze toate combinatiile posibile de date de la intrare.

'''Discutie''': Daca acest comparator are datele pe 32b sau mai mult (sau daca circuitul devine mult mai complex), nu se mai poate face o astfel de testare exhaustiva a combinatiilor posibile de date de la intrare pentru ca simularea ar dura prea mult. De situatia asta se ocupa inginerii de verificare ce lucreaza in paralel cu inginerii de design. Pentru mai multe detalii puteti cauta "constrained random functional verification". Incercati sa identificati cazurile/situatiile ce ar trebui testate pentru un comparator pe 32b inainte de a spune ca acesta functioneaza corect (minim 10).