Fișier:Lucrarea2 Subiect pentru wiki.pdf

2025-07-17T04:39:15Z

Gvpopescu:

CID aplicatii 5 : Exercitii cu circuite combinationale

2025-07-17T04:29:28Z

Gvpopescu: /* Exercitiul 8: Unitate aritmetico-logică (ALU) */

==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]

===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

2025-07-17T04:28:32Z

Gvpopescu:

2025-02-20T09:56:36Z

Gvpopescu: /* Module (sintetizabile) */

== Module (sintetizabile) ==

Limbajul SystemVerilog este structurat pe module. Fiecare modul reprezintă un circuit care implementează o anume funcție. De exemplu, un modul poate reprezenta un sumator, adică un circuit care are două intrări ce specifică cei doi operanzi și o ieșire ce reprezintă rezultatul adunării. Conținutul modulului reprezintă descrierea (structurală sau comportamentală) a porților care calculeaza suma celor două intrări. Prin urmare, definiția unui modul SystemVerilog are două părți:
* interfață - lista tuturor porturilor de intrare și ieșire ale circuitului, specificate prin nume și dimensiune;
* implementare - descrierea efectivă a circuitului care se folosește de valorile de intrare pentru a calcula valorile de ieșire;

=== Interfața modulelor SystemVerilog ===
Interfața modulului '''Adder''' este prezentată mai jos. '''''Observație:''''' Ca și în sistemul numeral zecimal, unde suma a două numere de '''n''' cifre are nevoie de '''n + 1''' cifre (9 + 9 = 18), și în sistemul binar, suma a două numere de '''n''' biți va fi pe '''n + 1''' biți.
[[Fișier:Adder_interface.svg|thumb|Reprezentarea interfetei modulului "Adder" (black box)]]
<syntaxhighlight lang="verilog">
module Adder(
output logic [4:0] out,
input logic [3:0] in0,
input logic [3:0] in1
);

//implementare

endmodule
</syntaxhighlight>
Cuvintele cheie '''''module''''' și '''''endmodule''''' sunt folosite pentru a începe și a încheia definirea unui modul. Imediat după cuvântul cheie '''''module''''' urmează numele modulului.

<div class="conventie">
<font color="#0000AA">'''''Convenție:'''''</font> Numele unui modul va începe cu literă mare.
</div>

După definirea numelui modulului, urmează lista de porturi, plasată între '''paranteze rotunde''' și separate prin '''virgulă'''. Cuvintele cheie acceptate sunt '''''output''''' (reprezentând un port de ieșire), '''''input''''' (reprezentând un port de intrare) și '''''inout''''' (reprezentând un port bidirecțional).

<div class="sfat">
<font color="#00AA00">'''''Sfat:'''''</font> Când aveți de ales în privința interfeței unui modul, se evită utilizarea semnalelor de tip '''''inout'''''. Acestea introduc elemente de tip [http://en.wikipedia.org/wiki/Tri-state_buffer#Tri-state_Buffer Tri-state Buffer] care sunt ineficiente. O alternativă mai eficientă este definirea a două porturi, unul de intrare și unul de ieșire, cu nume similare (ex: ''data_in'' și ''data_out'').
</div>

<div class="conventie">
<font color="#0000AA">'''''Convenție:'''''</font> Întâi se definesc ieșirile, apoi intrările unui modul.
</div>

<div class="conventie">
<font color="#0000AA">'''''Convenție:'''''</font> Porturile unui modul se scriu unul sub altul, pe câte o linie, aliniate cu un tab la dreapta față de cuvântul cheie '''''module'''''.
</div>

După tipul portului, urmează dimensiunea acestuia, specificată în indecșii biților, unde cel mai puțin semnificativ bit are indexul 0. Spre exemplu, un semnal de 4 biți va avea următoarea specificație '''[3:0]''' (bitul cel mai semnificativ are indexul 3, cel mai puțin semnificativ 0, în total 4 biți). '''''Observație:''''' Semnalelor de un bit le lipsește specificația de dimensiune:

<syntaxhighlight lang="verilog">
input semnal_de_un_bit,
</syntaxhighlight>

După lista de porturi aflată între paranteze, definirea interfeței se termină cu caracterul ''';'''.



=== Implementarea modulelor SystemVerilog ===

Implementarea modulelor SystemVerilog se face prin blocuri. Aceste blocuri pot avea sau nu corespondent într-un ciruit fizic. Dacă toate blocurile unui modul au corespondent într-un circuit fizic, atunci modulul este sintetizabil și poate fi transformat într-un circuit fizic. Blocurile care pot genera construcții sintetizabile sunt de patru tipuri:
* blocuri '''assign'''
* blocuri '''always'''
* blocuri de instanțiere
* blocuri '''generate'''

În SystemVerilog toate semnalele sunt de tip ('''logic'''), acesta acoperind atat fire cat si registre.

Blocurile care sunt întotdeauna nesintetizabile și sunt folosite exclusiv pentru simulare:
* blocuri '''initial'''

'''''Observație:''''' Nu orice bloc '''assign''' sau '''always''' este sintetizabil. Există construcții valide sintactic dar care nu au corespondent în circuit. Aceste blocuri pot fi simulate dar nu pot fi utilizate pentru programarea unei plăci [[FPGA]].

'''''Observație:''''' Ordinea blocurilor într-un modul nu contează.

==== Cuvantul cheie "logic" ====

In SystemVerilog, toate semnalele sunt de tip '''logic''', indiferent de natura lor. In urma sintezei semnalele vor deveni fire, latch-uri sau registre.

Semnalele într-un modul SystemVerilog se definesc în felul următor:
<syntaxhighlight lang="Verilog">

logic [3:0] semnal;

</syntaxhighlight>

<div class="regula">
<font color="red">'''''Regulă:'''''</font> Niciun element nu își poate schimba valoarea în mai mult de un bloc.
</div>

==== Blocuri '''assign''' ====

[[Fișier:Adder.png|thumb|Modulul Adder implementat]]

'''Assign''' este un cuvănt cheie care generează [[circuite combinaționale]]. Cum sumatorul este un [[circuite combinaționale|circuit combinațional]], îl putem implementa cu un bloc '''assign''':
<syntaxhighlight lang="Verilog">
module Adder(
output logic [4:0] out,
input logic [3:0] in0,
input logic [3:0] in1
);

assign out = in0 + in1;

endmodule
</syntaxhighlight>

'''''Observație:''''' În general, un bloc '''assign''' va genera un circuit sintetizabil. Există și excepții, atunci când operația dorită este prea complexă pentru a fi implementată printr-un circuit combinațional, în mod eficient. Spre exemplu:

<syntaxhighlight lang="Verilog">
assign out = in0 / in1;
</syntaxhighlight>

nu este un cod sintetizabil pentru majoritatea tool-urilor de sinteză, dar funcționează perfect într-o simulare.

==== Blocuri '''always''' combinaționale ====

Formatul pentru un bloc '''always''' combinational este următorul:

<syntaxhighlight lang="Verilog">

always_comb begin
//...
end

</syntaxhighlight>

Un bloc de tip '''always_comb''' este sensibil la modificare oricarui semnal din cadrul modulului unde a fost definit, iesirile comandate de acest bloc sunt recalculate la orice modificare a unui semnal de intrare.

În acest caz, putem reface implementarea sumatorului folosind un bloc '''always_comb''' în felul următor:

<syntaxhighlight lang="Verilog">
module Adder(
output logic [4:0] out,
input logic [3:0] in0,
input logic [3:0] in1
);

always_comb begin
out = in0 + in1;
end

endmodule
</syntaxhighlight>

==== Blocuri '''always''' secvențiale. Asignări non-blocante (non-blocking assignments) ====

[[Circuite secvențiale|Circuitele secvențiale]] sunt circuitele care sunt sincronizate de [[Circuite secvențiale#Semnalul de ceas|semnalul de ceas]]. Acest semnal este, de obicei, produs de un generator de ceas și se definește ca intrare pentru fiecare modul secvențial (în care există cel puțin un registru). Putem modifica exemplul anterior, astfel încât ieșirea modulului de sumare să fie sincronă (adică să se modifice doar pe frontul pozitiv de ceas). Astfel, în interfața modulului, apare și semnalul de ceas:

<syntaxhighlight lang="Verilog">
module SyncedAdder(
output logic [4:0] out,
input logic [3:0] in0,
input logic [3:0] in1,
input logic clock
);

//implementation here

endmodule
</syntaxhighlight>

<div class="regula">
<font color="red">'''''Regulă:'''''</font> Pentru descrierea circuitelor secvențiale, se folosește întotdeauna un bloc '''always_ff''' sau '''always_latch'''.
</div>

[[Fișier:SyncedAdder.png|thumb|Modulul SyncedAdder]]
Blocul '''always_ff''' care descrie un circuit secvențial are în lista de sensitivități numai semnalul de ceas iar el nu este sensibil la orice tranziție a ceasului ci numai la unul din fronturi (de obicei cel pozitiv). Astfel, putem implementa sumatorul sincron în felul următor:

<syntaxhighlight lang="Verilog">
module SyncedAdder(
output logic [4:0] out,
input logic [3:0] in0,
input logic [3:0] in1,
input logic clock
);

always_ff@(posedge clock) begin
out <= in0 + in1;
end

endmodule
</syntaxhighlight>

'''''Observație:''''' Cuvântul cheie care specifică frontul pozitiv al unui semnal este '''posedge''' iar cel pentru frontul negativ al semnalului este '''negedge'''.

Observați operatorul '''<=''' folosit pentru atribuirea sumei registrului destinație. Acesta NU este operatorul logic de ''mai mic sau egal'', ci reprezintă un mod de atribuire care se numește non-blocantă. Diferența dintre atribuirea blocantă ('''=''') și cea non-blocantă ('''<=''') este că cea de-a doua întâi evalueaza toate expresiile din partea dreaptă a operatorului de atribuire (în cazul de față, suma ''in0 + in1'') și abia apoi asignează rezultatul registrului destinație. Spre exemplu, dacă dorim să inversăm valorile a două registre, ''reg0'' și ''reg1'', astfel încât ''reg0'' să ia valoarea lui ''reg1'' și invers, vom face în felul următor:

<syntaxhighlight lang="Verilog">
module RegSwapper(
//...
);

logic [31:0] reg0;
logic [31:0] reg1;

//cod corect
always_ff@(posedge clock) begin
reg0 <= reg1;
reg1 <= reg0;
end

endmodule
</syntaxhighlight>

Modulul se va comporta conform așteptărilor. Operatorul '''<=''' nu va bloca restul evaluărilor din blocul always și prin urmare toate asignările se fac simultan, după evaluarea expresiilor din partea dreaptă a operatorului. Pe de altă parte, dacă facem asignarea blocantă:

<syntaxhighlight lang="Verilog">
module RegSwapper(
//...
);

logic [31:0] reg0;
logic [31:0] reg1;

//cod incorect
always_ff@(posedge clock) begin
reg0 = reg1;
reg1 = reg0;
end

endmodule
</syntaxhighlight>
aceasta va bloca restul operațiilor până când asignarea se termină. În acest caz, după primul front de ceas, ambele registre vor conține valoarea inițială a lui ''reg1''.

<div class="regula">
<font color="red">'''''Regulă:'''''</font> Operatorul de asignare non-blocantă ('''<=''') se folosește doar în blocuri '''always_ff''', '''always_latch''' sau '''initial'''.
</div>

<div class="regula">
<font color="red">'''''Regulă:'''''</font> În același bloc '''always''', se folosește același tip de operator de asignare pentru toate operațiile.
</div>

<div class="sfat">
<font color="green">'''''Sfat:'''''</font> Utilizați asignare non-blocantă pentru toate blocurile '''always''' care generează circuite secvențiale (sunt sincronizate de ceas) și asignare blocantă în toate celelalte cazuri.
</div>

==== Blocuri de instanțiere ====

[[Fișier:adder4.png|thumb|Un sumator de patru numere format din trei sumatoare de două numere]]

Odată definit un modul, acesta poate fi folosit de oricâte ori pe parcursul unuia sau mai multor proiecte. Acest sistem se numește instanțiere. Să luam, ca exemplu, un modul care trebuie să facă suma a 4 numere pe 3 biți. Putem să folosim în acest scop modulul '''Adder''' pe 4 biți definit mai sus, în configurația din figură. Observați că se utilizează același modul de trei ori. Este ineficient și inutil să scriem de trei ori implementarea modulului, așa că vom recurge la metoda instanțierii. Orice instanță a unui modul trebuie să aibă un nume unic, după cum și într-un limbaj de programare, variabilele de același fel trebuie sa aibă un nume unic.

Se observă în continuare că există semnale (fire) în modulul '''Adder4''', care nu sunt nici intrări, nici ieșiri, și sunt folosite doar pentru conectarea modulelor '''Adder''' (cel roșu și cel verde). Aceste semnale sunt fire ('''wire''') și trebuie declarate ca atare.

Sintaxa pentru instanțierea unui modul este următoarea:
<syntaxhighlight lang="Verilog">
NumeModulInstantiat numeInstanta(
.nume_intrare_sau_iesire_0(nume_semnal_legat_la_intrare_sau_iesire_0),
.nume_intrare_sau_iesire_1(nume_semnal_legat_la_intrare_sau_iesire_1),
//...
.nume_intrare_sau_iesire_n(nume_semnal_legat_la_intrare_sau_iesire_n),
);
</syntaxhighlight>

Haideți deci să vedem cum arată codul SystemVerilog pentru modulul '''Adder4''':
<syntaxhighlight lang="Verilog">
module Adder4(
output logic [4:0] out,
input logic [2:0] in0,
input logic [2:0] in1,
input logic [2:0] in2,
input logic [2:0] in3
);

//definirea firelor de legatura
logic [3:0] subsum0;
logic [3:0] subsum1;

//instantierea modulelor
Adder adder0(
.out(subsum0), //iesirea numita out a instantei adder0 se leaga la firul subsum0
.in0(in0), //la intrarea numita in0 a instantei adder0 se leaga intrarea in0 a modulului
.in1(in1) //la intrarea numita in1 a instantei adder0 se leaga intrarea in1 a modulului
);

Adder adder1(
.out(subsum1), //iesirea numita out a instantei adder1 se leaga la firul subsum1
.in0(in2), //la intrarea numita in0 a instantei adder1 se leaga intrarea in2 a modulului
.in1(in3) //la intrarea numita in1 a instantei adder1 se leaga intrarea in3 a modulului
);

Adder adder2(
.out(out), //iesirea numita out a instantei adder2 se leaga la iesirea out a modulului
.in0(subsum0), //la intrarea numita in0 a instantei adder2 se leaga firul subsum0
.in1(subsum1) //la intrarea numita in1 a instantei adder2 se leaga firul subsum1
);

endmodule
</syntaxhighlight>

'''''Observație:''''' Instanțele adder0 și adder1 au legate la intrări semnale de 3 biți și la ieșire legate fire de 4 biți, cu toate că porturile lor au 4, respectiv 5 biți (intrările și ieșirile). În acest caz, semnalele se leagă fiind aliniate la cel mai puțin semnificativ bit și se generează un mesaj de avertizare (port mismatch). Cu toate că programele folosite de noi acceptă codul de mai sus, există programe care nu acceptă astfel de construcții, și se opresc cu eroari. Ca să fim foarte riguroși, vom folosi operatorul de concatenare pentru a corecta codul în felul următor (mai multe despre operatori veți putea afla mai jos):

<syntaxhighlight lang="Verilog">
module Adder4(
output logic [4:0] out,
input logic [2:0] in0,
input logic [2:0] in1,
input logic [2:0] in2,
input logic [2:0] in3,
);

//definirea firelor de legatura
logic [4:0] subsum0; //definim firele pe 5 biți deoarece iesirea instantelor adder0 si adder1 este pe 5 biti
logic [4:0] subsum1;

//instantierea modulelor
Adder adder0(
.out(subsum0), //iesirea numita out a instantei adder0 se leaga la firul subsum0
.in0({1'b0,in0}), //la intrarea numita in0 a instantei adder0 se leaga un bit 0 concatenat cu intrarea in0 a modulului
.in1({1'b0,in1}) //la intrarea numita in1 a instantei adder0 se leaga un bit 0 concatenat cu intrarea in1 a modulului
);

Adder adder1(
.out(subsum1), //iesirea numita out a instantei adder1 se leaga la firul subsum1
.in0({1'b0,in2}), //la intrarea numita in0 a instantei adder1 se leaga un bit 0 concatenat cu intrarea in2 a modulului
.in1({1'b0,in3}) //la intrarea numita in1 a instantei adder1 se leaga un bit 0 concatenat cu intrarea in3 a modulului
);

Adder adder2(
.out(out), //iesirea numita out a instantei adder2 se leaga la iesirea out a modulului
.in0(subsum0[3:0]), //la intrarea numita in0 a instantei adder2 se leaga cei mai putin semnificativ 4 biti din firul subsum0
.in1(subsum1[3:0]) //la intrarea numita in1 a instantei adder2 se leaga cei mai putin semnificativ 4 biti din firul subsum1
);

endmodule
</syntaxhighlight>

== Module de test (nesintetizabile) ==

[[Fișier:addertester.png|thumb|Modul de test pentru sumatorul pe 4 biți]]

Modulele de test sunt folosite pentru verificarea funcționalității unui alt modul sintetizabil. Figura alăturată prezintă schema bloc pentru un modul de test pentru sumatorul pe 4 biți. Un modul de test generic urmărește câteva reguli clare:

* pentru fiecare intrare a modulului de testat, se definește o variabilă tip '''logic''', de aceeași dimensiune cu intrarea, folosite pentru a genera stimuli pentru circuit;
* pentru fiecare ieșire a modulului de testat, se definește o variabilă tip '''logic''', de aceeași dimensiune cu ieșirea, folosite pentru verificarea comportamentului (de obicei prin afișarea de forme de undă);
* se instanțiază modulul de testat și se leagă variabilele definite anterior la intrările și ieșirile instanței;
* se scrie un generator de stimuli (un bloc '''initial''') în care se programeaza o secvență temporizată de tranziții pentru intrări;
* se folosește un software de simulare pentru a rula testul și a vedea formele de undă.

Astfel, modulul de test pentru sumatorul pe 4 biți va arăta astfel:
<syntaxhighlight lang="Verilog">
module AdderTester;

//this is the definition of variables and wires
//for driving signals
logic [3:0] i0;
logic [3:0] i1;
logic [4:0] o;

//this is where the stimuls is added for the module
initial begin
i0 = 0;
i1 = 0;
#5 i0 = 3;
#2 i0 = 2;
i1 = 1;
#3 i0 = 1;
i1 = 5;
#5 $stop();
end

//this is where the tested module is instantiated
Adder deviceUnderTest(
.out(o),
.in0(i0),
.in1(i1)
);

endmodule
</syntaxhighlight>

Blocul '''initial''' este folosit pentru a da valori intrărilor modulului de testat. El iși începe execuția la momentul de timp t = 0. Fiecare linie este executată la același moment de tip, până când este întâlnit operatorul #, care așteaptă trecerea unor unități de timp. Astfel, în exemplul de mai sus, primele două linii se execută la t = 0, linia 3 se execută la t = 5, liniile 4 și 5 la t = 7, liniile 6 și 7 la t = 10 și ultima linie, la t = 15. Apelul funcției $stop() determină sfârșitul simulării.

=== Semnalul de ceas în module de test ===

Cuvântul cheie '''forever''' este folosit pentru a executa o atribuire sau apel de funcție în mod repetat, până la sfârșitul simulării. Acesta este în particular folositor pentru a genera un semnal de ceas. Secvența următoare de cod generează un semnal de ceas cu perioada de două unități de timp:
<syntaxhighlight lang="Verilog">
reg clock;

initial begin
clock = 0;
forever #1 clock = !clock;
end
</syntaxhighlight>

<div class="regula"><font color="red">Regulă:</font>Pentru circuitele secvențiale, modulul de test va avea două blocuri '''initial'''. Primul este similar celui de mai sus, și utilizat pentru generarea semnalului de ceas. Al doilea este folosit pentru generarea celorlalte semnale de intrare și directivei de oprire a simulării. Motivul pentru această segregare este faptul că instrucțiunea '''forever''' este blocantă (adică instrucțiunile puse după ea nu se execută). Toate blocurile '''initial''' dintr-un modul de test se execută în paralel.</div>

== Sintaxa SystemVerilog ==

=== Constante ===

Constantele sunt valori numerice. Pentru fiecare valoare, se specifică numărul de biți pe care reprezentată si baza în care este scrisă. Spre exemplu '''8'b111''' este o constantă pe 8 biți a cărei valoare în binar este 111 (adică în decimal, 7). În același fel, '''16'd10''' reprezintă valoarea 10 în decimal reprezentată pe 16 biți. Este posibilă specificarea valorii fără număr de biți sau bază (în care caz baza implicită este cea decimală, și numărul de biți este aproximat de către compilator).

=== Operatori ===

==== Operatori aritmetici ====

{| class="wikitable"
|- bgcolor="#ddeeff" align="center"
|'''Operație''' || '''Operator''' || '''Exemplu'''
|- bgcolor="#ddffdd" align="center"
|Adunare || + || a + b
|- bgcolor="#ddffdd" align="center"
|Scădere || - || a - b
|- bgcolor="#ddffdd" align="center"
|Înmulțire || * || a * b
|- bgcolor="#ddffdd" align="center"
|Împărțire || / || a / b
|}

==== Operatori logici ====

{| class="wikitable"
|- bgcolor="#ddeeff" align="center"
|'''Operație''' || '''Operator''' || '''Exemplu'''
|- bgcolor="#ddffdd" align="center"
|Egal || == || a == b
|- bgcolor="#ddffdd" align="center"
|Diferit || != || a != b
|- bgcolor="#ddffdd" align="center"
|Mai mic || < || a < b
|- bgcolor="#ddffdd" align="center"
|Mai mic sau egal || <= || a <= b
|- bgcolor="#ddffdd" align="center"
|Mai mare || > || a > b
|- bgcolor="#ddffdd" align="center"
|Mai mare sau egal || >= || a >= b
|}

==== Operatori binari logici pe biți ====

{| class="wikitable"
|- bgcolor="#ddeeff" align="center"
|'''Operație''' || '''Operator''' || '''Exemplu'''
|- bgcolor="#ddffdd" align="center"
|Și || & || a & b
|- bgcolor="#ddffdd" align="center"
|Sau || <nowiki>|</nowiki> || a <nowiki>|</nowiki> b
|- bgcolor="#ddffdd" align="center"
|Sau exclusiv || ^ || a ^ b
|}

==== Operatori unari logici pe biți ====

{| class="wikitable"
|- bgcolor="#ddeeff" align="center"
|'''Operație''' || '''Operator''' || '''Exemplu'''
|- bgcolor="#ddffdd" align="center"
|Negare || ~ || ~b
|- bgcolor="#ddffdd" align="center"
|Și pe biții unui semnal|| & || &a
|- bgcolor="#ddffdd" align="center"
|Sau pe biții unui semnal|| <nowiki>|</nowiki> || <nowiki>|</nowiki>a
|- bgcolor="#ddffdd" align="center"
|Sau exclusiv pe biții unui semnal|| ^ || ^a
|}

==== Operatori de shiftare pe biți ====

{| class="wikitable"
|- bgcolor="#ddeeff" align="center"
|'''Operație''' || '''Operator''' || '''Exemplu'''
|- bgcolor="#ddffdd" align="center"
|Shiftare la stânga || << || a << b
|- bgcolor="#ddffdd" align="center"
|Shiftare la dreapta || >> || a >> b
|}

==== Operatorul de acces la biți ====

Dându-se un semnal pe n biți, operatorul de access la o sub-secvență din biții semnalului este '''[m:k]''' unde m și k sunt indecșii biților doriți, cu n < m < k. Ca exemplu:

<syntaxhighlight lang="verilog">
logic [31:0] un_registru;
logic [7:0] un_fir;
logic alt_fir;

assign un_fir = un_registru[30:23]; //firul "un_fir" ia valoarea data de secventa de biti de la 23 la 30 din registrul "un_registru"
assign alt_fir = un_fir[3]; //firul "alt_fir" va lua valoarea bitului 3 din semnalul "un_fir" care este bitul 26 din semnalul "un_registru"
</syntaxhighlight>

==== Operatorul de concatenare ====

Operatorul de concatenare este "{" și "}". Astfel, o serie de semnale separate prin virgulă și închise între două acolade va rezulta într-un singur semnal de dimensiune egală cu suma dimensiunilor semnalelor componente.

<syntaxhighlight lang="Verilog">
logic [3:0] a;
logic [4:0] b;
logic c;
logic [9:0] d;

//semnalul d este format din concatenarea semnalelor a,b,c
//unde a este pe pozitia cea mai semnificativa si c
//pe pozitia cea mai putin semnificativa
assign d = {a,b,c};
</syntaxhighlight>

==== Operatorul de replicare ====

Operatorul de replicare este folosit când se dorește replicarea unui semnal de un număr mare sau necunoscut de ori (dat ca parametru). Astfel, construcția '''{n{m}}''' reprezintă semnalul '''m''', multiplcat de '''n''' ori.

<syntaxhighlight lang="Verilog">
logic a;
logic [4:0] b;
logic [7:0] c;
logic [15:0] d;

assign b = {5{a}}; //b va lua valoarea data de a, replicata de 5 ori
assign d = {2{c}}; //d va lua valoarea lui c (8 biti) replicata de 2 ori
</syntaxhighlight>

=== Blocuri și operatori condiționali ===

Condițiile se pot exprima în trei moduri:
* folosing operatorul condițional cunoscut din limbajul C (condiție '''?''' valoare_pentru_adevărat ''':''' valoare_pentru_fals);
* folosind construcția '''if - else''';
* folosind constructia '''case - endcase''' respectiv '''casex - endcase''' sau '''casez - endcase'''.

Operatorul condițional se poate utiliza în orice tip de bloc. Exemplu:
<syntaxhighlight lang="Verilog">
logic a;
logic [3:0] b;
logic [3:0] c;
logic [3:0] d;

assign b = a ? c : d; //daca a este adevarat (adica daca este egal cu 1), atunci b ia valoarea lui c, altfel, b ia valoarea lui d
</syntaxhighlight>

Blocurile '''if - else''', '''case - endcase''' se pot utiliza doar în blocuri '''always'''. Exemplu:
<syntaxhighlight lang="Verilog">
logic a;
logic [3:0] b;
logic [3:0] c;
logic [3:0] d;

always_comb begin
if(a) begin
b = c;
end else begin
b = d;
end
end

</syntaxhighlight>

Exemplu '''case - endcase''':
<syntaxhighlight lang="Verilog">
logic [1:0] a;
logic [3:0] e;
logic [3:0] c;
logic [3:0] d;

//daca a este egal cu 0, atunci e ia valoarea lui c
//daca a este egal cu 1, atunci e ia valoarea lui d
//in orice alt caz, b ia valoarea 0
always_comb begin
case(a)
2'b00: e = c;
2'b01: e = d;
default: e = 3'b000;
endcase
end

</syntaxhighlight>

Introducere. SystemVerilog HDL

2025-02-20T09:54:36Z

Gvpopescu: /* Verilog si SystemVerilog HDL */

== Introducere în Circuite Digitale ==

[[Fișier:Analogic_sig.png|thumb|Semnal analogic]]

=== Semnale analogice ===

Începând cu lecțiile de electrocinetică de la orele de fizică din liceu (surse de tensiune, rezistențe, condensatoare, bobine, etc.) și terminând cu orele de [[Dispozitive și Circuite Electronice]], sistemele studiate au fost formate din componente formând circuite analogice. Circuitele analogice sunt circuite în care mărimile studiate (curent, tensiune), variază continuu în anumite intervale. Un exemplu concret este un amplificator audio, care preia un semnal sonor analogic și îl amplifică pentru a putea fi transmis mai departe, la un sistem de boxe. Puteți vedea un exemplu de semnal analogic în figura alăturată. Desigur, această imagine este generată de un computer, care este un dispozitiv digital, astfel ea nu poate reprezenta un semnal analogic adevărat ci poate doar simula un astfel de semnal, cu o anumită precizie.

=== Semnale digitale ===

[[Fișier:Sampled.signal.svg|thumb|Semnal eșantionat (discret în timp cu valori continue)]]
[[Fișier:Quantized.signal.svg|thumb|Semnal cuantizat (continuu în timp cu valori discrete)]]
[[Fișier:Digital.signal.svg|thumb|Semnal digital (cuantizat și eșantionat)]]

Un semnal digital este o înșiruire de valori discrete, fiecare din aceste valori făcând parte dintr-o mulțime discretă de valori raționale. Transformarea unui semnal analogic într-un semnal digital, implică o pierdere de precizie. Să luăm spre exemplu un semnal analogic sinusiodal simplu, reprezentând variația în timp a tensiunii la bornele unui rezistor. Între momentele t=0 și t=1, funcția, fiind continuă, are o infinitate de valori, prin urmare este imposibil de a izola fiecare valoare în parte, șirul astfel obținut fiind infinit. Procedura, în această situație, este de a izola doar o parte din valori, la anumite momente de timp, numite eșantioane, astfel încât să obținem un șir finit de valori. Această procedură se numește [http://en.wikipedia.org/wiki/Sampling_(signal_processing) eșantionare], iar perioada de timp dintre două eșantioane succesive, poartă numele de perioadă de eșantionare. Cu cât perioada de eșantionare este mai mică (respectiv frecvența de eșantionare mai mare), cu atât semnalul digital obținut este o copie mai fidelă (pierdere mai mica de precizie) față de semnalul analogic original. Dacă totuși semnalul analogic este de bandă limitată (adică poate fi scris ca o sumă finită de semnale sinusoidale), atunci [http://en.wikipedia.org/wiki/Nyquist%E2%80%93Shannon_sampling_theorem teorema eșantionării] arată că dacă eșantionarea se face cu o frecvență de cel puțin de două ori mai mare decât frecvența maximă din spectrul semnalului, din seria de eșantioane se poate obține cu precizie de 100% semnalul analogic original.

Totuși, mai există o problemă. Semnalul fiind continuu, valorile eșantioanele se află într-un spațiu continuu, prin urmare de precizie infinită. Pentru a reduce precizia valorilor, se utilizează un procedeu numit [http://en.wikipedia.org/wiki/Quantization_(signal_processing) cuantizare]. Acest procedeu implică împărțirea intervalului de valori posibile pentru semnal în subdiviziuni. Cu cât aceste subdiviziuni sunt mai fine, cu atât valorile obținute prin cuantizare vor fi mai aproape de valorile reale ale semnalului original, dar vor fi reprezentate cu un număr mai pare de simboluri.

În concluzie, un semnal digital este o înșiruire de numere, obținute prin eșantionarea și cuantizarea unui semnal analogic.

=== Numere și simboluri. [http://en.wikipedia.org/wiki/Numeral_system Baze de numerație] ===

După cum s-a observat în capitolul anterior, un semnal digital este o înșiruire de valori. Aceste valori sunt reprezentate folosind simboluri, aparținând unei baze de numerație. Cel mai simplu exemplu este cel cu care suntem obișnuiți cu toții, adică baza zecimală, folosind ca simboluri cifrele de la 0 la 9. Dar acesta nu este nici pe departe singurul. Alte exemple ar fi sistemul de numerație roman, unde se folosesc ca simboluri literele I, V, X, L, C, D și M, unde valoarea acestor simboluri intr-un număr depinde de ordinea lor. Același lucru îl putem spune și despre baza de numerație zecimala, unde, spre exemplu, simbolul 9 are altă valoare dacă se află pe prima poziție (9) decât dacă se află pe a doua (90). Ce este interesant de reținut este că, în ciuda asocierii mentale dintre simbolurile cu care am fost obișnuiți de mici să lucrăm și valorile numerice pe care acestea le exprimă, cele două noțiuni sunt complet distincte. Valoarea „zece” poate fi exprimată numeric în baza zecimala ca 10, în sistemul de numerație roman ca X, în sistemul hexazecimal ca A, în sistemul binar ca 1010, în cel octal ca 12, dar toate aceste reprezentări exprimă, de fapt, același număr.

==== Sistemul de numerație binar ====

După cum îi spune și numele, acest sistem utilizează doar două simboluri, de cele mai multe ori, acestea fiind 0 și 1. Prin urmare, un număr poate fi reprezentat în sistemul binar (numit și baza 2) ca o secvență de 0 și 1. Ordinea simbolurilor într-un număr scris în baza doi respectă aceleași reguli ca și numerele scrise în baza zecimală. Astfel, daca într-un număr zecimal, cifra 7 pe poziția 4 era echivalentă cu valoarea 7 * 10<sup>4</sup>, unde 10 este egal cu numărul de simboluri distincte folosite, atunci în baza 2, un 1 pe pozitia 4 este echivalent cu valoarea 1 * 2<sup>4</sup>. Aceasta este și regula de transformare a numerelor din baza 2 în baza 10. Prin urmare:

1001010<sub>(2)</sub> = 1 * 2<sup>6</sup> + 0 * 2<sup>5</sup> + 0 * 2<sup>4</sup> + 1 * 2<sup>3</sup> + 0 * 2<sup>2</sup> + 1 * 2<sup>1</sup> + 0 * 2<sup>0</sup> = 64 + 0 + 0 + 8 + 0 + 2 + 0 = 54<sub>(10)</sub>

Transformarea unui număr din baza zecimală în cea binară implică împărțirea repetată la 2 (numărul de simboluri ale bazei), unde deîmpărțitul la fiecare iterație este dat de câtul împărțirii anterioare. Operația se repetă cât timp câtul este diferit de 0. Numărul în baza binară este dat de secvența resturilor începând cu ultima împărțire și terminând cu prima.

Avantajul sistemului binar este că numărul redus de simboluri face ca și numărul de operații posibile între două simboluri aleatoare să fie redus, prin urmare este ușor de imaginat o realizare fizică a unor circuite care să implementeze aceste operații. Dezavantajul este că pentru numere relativ mici, este nevoie de multe simboluri pentru reprezentare. Așadar, pentru flexibilitatea operației cu valori reprezentate cu multe simboluri, se utilizeaza baza de numerație hexazecimală, adică baza 16. După cum îi spune și numele, baza hexazecimală utilizează 16 simboluri: cifrele de la 0 la 9, și caracterele a, b, c, d, e și f. Utilizarea bazei 16 este avantajoasă datorită trecerii foarte ușoare între ea și baza 2. Astfel, la orice valoare reprezentată printr-o secvență de patru simboluri binare corespunde unul și numai un simbol hexazecimal.

=== Computație și control ===

Am ajuns deci la concluzia că se pot face calcule (computație) folosind doar două simboluri, corespunzătoare valorilor de zero și de unu. Avem la dispoziție o bază de numerație (baza doi), prin care se pot face calcule din cele mai complexe, cu aceeași acuratețe ca și cele din baza decimală. Dar pe lângă calculul efectiv, un sistem informatic trebuie să poată lua decizii, adică să poate evalua o expresie și să decidă valoarea acesteia de adevăr, operație de tipul general '''if then else'''. Cel mai simplu exemplu de funcție care nu se poate calcula fără luarea unei decizii, este funcția modul (de fapt, orice funcție cu ramuri). Aceasta este de forma:
<syntaxhighlight lang="Pascal">
if (operand < 0) then (result = -operand) else (result = operand);
</syntaxhighlight>

Expresia (operand < 0) este ceea ce se numește o expresie logică. Expresiile logice, în [http://en.wikipedia.org/wiki/Boolean_algebra algebra booleană], pot lua numai două valori: '''''adevărat''''' sau '''''fals'''''. Aceste valori pot fi notate cu aceleași simboluri pe care le utilizăm pentru valori numerice în baza doi, adică '''''0''''' pentru valoarea de adevăr '''''fals (false)''''' și '''''1''''' pentru valoarea de adevăr '''''adevărat (true)'''''.

Cum asupra valorilor numerice pot fi aplicați operatori numerici (adunare, scădere, înmulțire), și asupra valorilor logice, pot fi aplicați operatori logici (ȘI, SAU, NU, SAU EXCLUSIV). Aceștia sunt explicați în detaliu pe pagina Wikipedia a [http://en.wikipedia.org/wiki/Boolean_algebra algebrei booleane].

Concluzia este că folosind aceleași două simboluri, putem face calcule, folosind algebra binară, dar putem exercita control asupra unei funcții, folosind algebra booleană. După cum simbolurile se suprapun pentru computație și control, și operatorii asociați pot avea aceeași formă, și atunci distincția se face doar prin interpretarea lor. Spre exemplu, tabelul cu rezultate pentru înmulțirea a două numere de un bit (operație numerică) arată în felul următor:

{| class="wikitable"
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A * 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
|}

În același timp, operația logică ȘI care întoarce 1 dacă și numai dacă ambii operanzi sunt 1 (mă duc la film DACĂ nu plouă ȘI am bani), are următorul tabel de adevăr:

{| class="wikitable"
|- bgcolor="#ddeeff" align="center"
|colspan=2|'''INTRARE''' || '''IEȘIRE'''
|- bgcolor="#ddeeff" align="center"
| A || B || A ȘI 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
|}

Se observă că cele două funcții sunt identice. În acest fel, distincția dintre valoare logică și valoare numerică (respectiv operator logic și operator numeric) ține de interpretarea valorilor de intrare (dacă acestea sunt valori logice sau numerice) iar implementarea operatorilor este identică (prin urmare circuitul asociat este identic).

=== Circuite ===

[[Fișier:Not_gate.png|thumb|Simbol inversor(A - intrare, out - ieșire)]]
[[Fișier:CMOS_inverter.png|thumb|Inversor alcătuit din tranzistoare CMOS]]

În electronica digitală, ca de fapt în toată ramura tehnologiei care lucrează cu circuite digitale (adică calculatoare) ca și în teroria informației, un element care poate lua o valoare binară asociată unui simbol binar, se numește [http://en.wikipedia.org/wiki/Bit bit]. Baza circuitelor digitale, oricât de complexe, este dată de sub-circuitele care calculează operațiile unare și binare (adică care care au unul respectiv doi operanzi) între doi biți. Un astfel de sub-circuit se numește poartă (en:[http://en.wikipedia.org/wiki/Logic_gate gate]). Aceeași poartă poate fi considerată implementarea unui operator numeric de un bit, dar și implementarea unui operator logic.

Modul de codare a valorilor asociate simbolurilor binare, în electronica digitală, este printr-o diferență de potențial între două puncte. În tehnologia curentă utilizată ([http://en.wikipedia.org/wiki/CMOS CMOS]), o tensiune între 0 și Vdd/2 este asociată valorii binare de 0 iar o tensiune între Vdd/2 și Vdd valorii binare de 1.[http://en.wikipedia.org/wiki/Logic_level]

Cea mai simplă poartă este cea care implementează operația logică de negare (are o singură intrare și o singură ieșire care este intotdeauna diferită de cea de intrare, adică pentru intrarea 0, ieșirea este 1 și pentru intrarea 1, ieșirea este 0). Această poartă se numește inversor, sau poartă NU (en: [http://en.wikipedia.org/wiki/Inverter_(logic_gate) inverter], NOT gate).

Simbolurile și tabelele de adevăr pentru cele mai utilizare porți:

{| class="wikitable"
! Tip !! Simbol !! Tabel de adevăr !! Tip !! Simbol !! Tabel de adevăr
|-
| '''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
|}
| '''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
|}
|-
| '''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
|}
| '''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
|}
|-
| '''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
|}
|}

Ca și la reprezentarea simbolică a amplificatoarelor operaționale, se observă că nici porțile logice nu au reprezentate porturile de alimentare (Vdd și Vss), vizibile pe schema inversorului CMOS. Acestea se consideră implicit conectate la sursa de alimentare, respectiv la masă.

== Verilog si SystemVerilog HDL ==

La ora actuală, un circuit digital poate ajunge până la 1 miliard de porți. Asta implică faptul că avem nevoie de unelte care să permită automatizarea procesului de design. Acest lucru se poate face folosind limbaje de descriere hardware ([http://en.wikipedia.org/wiki/Hardware_description_language Hardware Description Languages]). Aceste limbaje sunt special concepute pentru a putea descrie un circuit digital, ori din punct de vedere al comportamentului, ori din punct de vedere al structurii. În mod evident, o descriere comportamentală a unui circuit va fi mai succintă, dar nu va oferi informații despre structura dorită (la nivel de poartă), în timp ce o descriere structurală va fi mai exactă din punct de vedere al componentelor circuitului, dar mai lungă și poate mai dificil de înțeles.

Există două limbaje foarte cunoscute de descriere hardware: [http://en.wikipedia.org/wiki/Verilog Verilog] și [http://en.wikipedia.org/wiki/VHDL VHDL]. În continuarea acestui laborator de Circuite Integrate Digitale, vom folosi pentru descriere circuitelor, limbajul Verilog. Sintaxa acestuia este simplă și este parțial moștenită din C. Totuși, este foarte important de reținut că Verilog nu este un limbaj de programare. El nu se „execută” secvențial de către un procesor, ci se sintetizeaza într-un circuit sau se simulează. Prin urmare utilizatorii de Verilog trebuie să se dezobișnuiască să gândească secvențial ca și cum fiecare linie de cod se execută după cea precedentă, si mai degrabă trebuie să-și imagineze cum funcționează circuitul pe care codul respectiv îl descrie. Astfel, diferența cea mai interesantă față de un limbaj de programare, este că ordinea blocurilor de cod dintr-un modul nu contează.

SystemVerilog este o completare la standardul de bază Verilog și aduce multe imbunătățiri în direcția verificării circuitelor, cum ar fi conceptele de programare orientată pe obiecte. Pe langă acestea, apar și câteva imbunătățiri menite să ajute procesul de proiectare, cum ar fi o diferența mai clară și mai usor de urmărit dintre circuitele combinaționale și secvențiale.

Înainte de a începe lucrul cu uneltele software de simulare și sinteză, parcurgeți tutorial-ul care explică sintaxa [[SystemVerilog]].

2023-02-22T10:47:39Z

Gvpopescu: /* Utilizarea Vivado pentru simularea si sinteza circuitelor digitale */

== Instalare Vivado ==
Pentru a instala utilitarul Vivado, acesta trebuie descarcat de pe site-ul [https://www.xilinx.com/support/download.html Xilinx], alegand versiunea potrivita sistemului de operare folosit. Pentru a putea descarca orice utilitar Xilinx, va trebui mai intai sa creati un cont. Pentru instalarea Vivado 2020.2 pe sistemul de operare Windows, puteti consulta pagina [[Tutorial instalare Vivado]].

== Utilizarea Vivado pentru simularea si sinteza circuitelor digitale ==
=== Crearea unui proiect ===
Pentru a crea un proiect nou, mergeti la '''File->Project->New''', iar apoi vom urma pasii de configurare:

'''Pasul 1: Denumirea proiectului si stabilirea caii catre acesta'''

La acest pas vom denumi proiectul (de obicei, numele trebuie sa corespunda cu numele modulului TOP) si vom stabili calea la care se va crea acesta.

[[Fișier:Vivado tutorial pas1.png]]

'''Pasul 2: Alegerea tipului proiectului'''

La acest pas, vom selecta RTL Project, apoi vom da click pe '''Next'''

[[Fișier:Vivado tutorial pas 2.png]]

'''Pasul 3: Adaugarea surselor deja existente'''

La acest pas vom adauga proiectului sursele modulelor pentru care avem deja descrierea in fisiere de tip Verilog. Acest lucru se face prin '''Add Files''' si selectarea acestora. Daca nu avem fisiere de adaugat, putem da click direct pe '''Next'''.

[[Fișier:Vivado tutorial pas 3.png|600px]]

'''Pasul 4: Adaugarea fisierelor de constrangeri'''

La acest pas vom adauga fisierele de constrangeri pentru sinteza si implemenatrea pe FPGA, daca este cazul. Daca nu, putem da direct click pe '''Next'''.

[[Fișier:Vivado tutorial pas 4.png|600px]]

'''Pasul 5: Alegerea dispozitivului tinta'''

Se selecteaza din meniul '''Parts''' dispozitivul '''xc7s50csga342-1'''

[[Fișier:Tutorial Vivado selectare dispozitiv.png|600px]]



Dupa alegerea dispozitivului, va aparea o pagina cu rezumatul setarilor proiectului. Daca totul este corect, dam click pe '''Finish'''.

'''Pasul 6: Pagina principala a proiectului'''

[[Fișier:Vivado tutorial pas 6.png]]

In fereastra principala a proiectului se pot observa urmatoarele zone: '''Flow navigator''', in care avem principalele comenzi utilizate in crearea, simularea, sinteza si implementarea unui circuit digital pe FPGA, '''Sources''', in care vedem lista cu sursele proiectului (fisiere verilog in care descriem modulele, fisiere utilizate in simulare, in care vom descrie modulele de test, fisierele de constrangeri), '''Consola''', in josul paginii si zona '''Project Sumary''', in care se vor deschide fisierele proiectului.

=== Adaugarea sau crearea de fisiere===
'''Pasul 1:''' In zona '''Sources''', dam click pe '''+''', iar apoi apare pe ecran fereastra in care trebuie sa selectam tipul fisierului: Vom alege '''Add or create constains''', daca dorim crearea sau adaugarea unui fisier de constrangeri, '''Add or create design sources''', in cazul in care dorim crearea sau sa adaugarea de fisiere in care vom descrie modulele digitale, sau '''Add or create simulation sources''', in cazul in care dorim adaugarea sau crearea de fisiere ce vor fi utlizate pentru simulare.

[[Fișier:Vivado tutorial pas 7.png|600px]]

'''Pasul 2:''' Daca dorim adaugarea unor fisiere existente, dam click pe '''Add File''' si navigam pana la locul in care se afla aceste fisere. Daca dorim crearea unui nou fisier, dam click pe '''Create File'''. Se va deschide o frestra mica in care vom completa numele fisierului (de obicei, acesta corespunde cu numele modului descris in interiorul sau) si vom selecta limbajul pe care il vom folosi (Verilog). Dam click pe '''OK''', iar apoi pe '''Finish'''.

[[Fișier:Vivado tutorial pas 8.png|600px]]

'''Pasul 3:''' Vom completa in urmatoarea fereastra numele modulului descris. Obtional, putem completa si lista porturile impreuna cu tipul si dimensiunea lor, Vivado creand astfel pentru noi scheletele descrierii.

[[Fișier:Vivado tutorial pas 9.png|600px]]

'''Pasul 4:''' Fisierul creat va aparea in '''Sources'''. Pentru a-l deschide, vom da doublu-click pe acesta, deschizandu-se in zona '''Project Summary'''.

[[Fișier:Vivado tutorial pas 10.png|780px]]

=== Simularea unui circuit digital ===
Pentru a putea simula un circuit digital, avem nevoie de cel putin doua fisiere: un fisier ce contine descrierea circuitului si un fisier ce contine descrierea modulului de test (test bench). Dupa crearea celor doua module, pentru a rula simularea vom urma pasii urmatori:

'''Pasul 1:''' In zona '''Flow navigator''' dam click pe '''Run Simulation''', iar apoi click pe '''Run Behavioral Simulation'''.

[[Fișier:Vivado tutorial pas 11.png|800px]]

'''Pasul 2:''' Dupa rularea simularii vom observa pe ecran trei zone principale: '''Scope''', in care vedem modulul si submodulele simulate, '''Objects''', in care vom vedea semnalele din interiorul fiecarui modul/submodul si '''Wave''', in care vom vedea forma de unda obtinuta in urma simularii.

[[Fișier:Vivado tutorial pas 12.png|800px]]

'''Pasul 3:''' Putem adauga semnale la forma de unda selectand semnalul dorit din fereastra '''Objects''', dand click dreapta si '''Add to Wave Window'''.

[[Fișier:Vivado tutorial pas 13.png|800px]]

'''Pasul 4:''' Pentru a observa evolutia in timp a semnalelor nou adaugate, simularea trebuie repornita. Pentru acesta, dam click pe '''Restart''', apoi pe '''Run All'''.

[[Fișier:Vivado tutorial pas 14.png|800px]]

'''Pasul 5:''' Folosind Zoom In / Zoom Out, stabilim un nivel optim de zoom, astfel incat sa vizualizarea formelor de unda sa fie semnificativa.

[[Fișier:Vivado tutorial pas 15.png|800px]]

Setarile initiale ale Vivado opresc simularea dupa 1000ns. Daca se doreste o simulare mai lunga si pentru a nu fi nevoie sa se apese run dupa cele 1000ns initiale, se poate introduce "-all" in Settings->Simulation->Simulation->xsim.simulate.runtime.

=== Sinteza și implementarea unui circuit digital pe FPGA ===
După ce am descris modulul și ne-am asigurat că nu există erori de sintaxă sau chiar erori funcșionale prin simulare, putem merge mai departe la sinteza și implementarea acestuia pe FPGA.

'''Pasul 1: Elaborarea circuitului''': La acest pas, utilitarul interpretează codul Verilog, identificând componentele și modul în care ele sunt conectate, generând '''netlist'''-ul. Această etapă este independentă de tehnologie.

[[Fișier:Vivado tutorial sinteza pasul1.png|800px]]

După elaborare, putem vizualiza schema circutului din secțiunea '''Flow Navigator -> RTL ANALYSIS -> Open Elaborated Design -> Schematic'''

[[Fișier:Vivado tutorial sinteza pasul1 1.png|800px]]

'''Pasul 2:''' Vom deschide planificatorul de pini din '''Layout -> I/O planning'''

[[Fișier:Vivado tutorial sinteza pasul2.png|800px]]

'''Pasul 3: Asocierea pinilor plăcii cu porturile circuitului''' La acest pas vom asocia porturile circuitului descris cu [[Pynq-Z2 - Pinout|pinii plăcii FPGA]]. În plus, vom selecta pentru toți pinii standardul '''LVCMOS33''' (coloana '''I/O Std'''). Aceasta este o caracteristică hardware și poate diferi de la un dispozitiv la altul.

[[Fișier:Vivado tutorial sinteza pasul3.png|800px]]

'''Pasul 4: Sinteza circuitului''' La acest pas se realizează transformarea circuitului descris într-un netlist dependent de tehnologie. Se vor folosi la acest pas primitivele disponibile pe FPGA. În plus, deoarece am introdus în I/O Planning constrângerile legate de legarea porturilor la pinii plăcii, tot aici va fi integrată și această informație.

[[Fișier:Vivado tutorial sinteza pasul4.png|800px]]

'''Pasul 5: Implementarea circuitului''' La acest pas se preia netlist-ul ce conține primitivele FPGA și modul lor de interconectare realizat la pasul anterior și se realizează maparea lor efectivă în FPGA (place and route).

[[Fișier:Vivado tutorial sinteza pasul5.png|800px]]

'''Pasul 6:''' După implementare, putem deschide circuitul elaborat pentru a studia căteva elemente precum schema circuitului sintetizat sau diverse rapoarte de sinteză.

[[Fișier:Vivado tutorial sinteza pasul6.png|800px]]

Schema circuitului cu componente disponibile pe FPGA.

[[Fișier:Vivado tutorial sinteza pasul6 1.png|800px]]

Fișierul de constrângeri generat. Acesta putea fi adăugat la proiect și scris manual, dacă nu doream să utilizîm I/O Planning.

[[Fișier:Vivado tutorial sinteza pasul6 2.png|800px]]

'''Pasul 7: Generare a fișierului de programare''' Din circuitul de la punctul anterior, se generează un fișier cu extensia .bit care conține biții de configurare pentru blocurile logice, blocurile de I/O și blocurile de interconectare corespunzătoare circuitului.

[[Fișier:Vivado tutorial sinteza pasul7.png|800px]]

'''Pasul 8: Conectarea la placa FPGA''' Se deschide managerul hardware și ne conectăm la placa FPGA prin Auto Connect. Aceeași operațiunea poate fi realizată și din '''Flow Navigator -> PROGRAM AND DEBUG -> Open Hardware Manager -> Open Target -> Auto Connect'''.

[[Fișier:Vivado tutorial sinteza pasul8.png|800px]]

'''Pasul 9: Programarea plăcii''' La acest pas se descarcă fișierul de configurare pe placă.

[[Fișier:Vivado tutorial sinteza pasul9.png|800px]]

Fișier:Tutorial Vivado selectare dispozitiv.png

2023-02-22T10:46:27Z

Gvpopescu:

Tutorial instalare Vivado

2023-02-22T10:36:41Z

Gvpopescu:

In cele ce urmeaza, vom exemplifica instalarea utilitarului Vivado 2020.2 pentru sistemul de operare Windows. Trebuie sa aveti in vedere inca de la inceput faptul ca acest utilitar are o dimensiune mare, iar descarcarea si instalarea dureaza destul de mult.

'''Pasul 1:''' Accesati [https://www.xilinx.com/support/download.html pagina de descarcare] de pe site-ul Xilinx. Aici veti gasi la sectiunea Vivado (HW Developer) versiunea disponibile ale utilitarului. Selectati versiunea dorita (in timpul laboratorului, vom folosi versiunea 2020.2) si veti descarca utilitarul de instalare corespunzator sistemului de operare folosit (in cazul acestui tutorial, Windows).

'''Pasul 2:''' Selectati '''Xilinx Unified Installer 2020.2: Windows Self Extracting Web Installer'''. Pentru a putea incepe descarcarea, trebuie sa intrati in contul Xilinx personal, sau sa creati unul. Pentru crearea contului, va trebui sa completati campurile obligatorii cu datele voastre. Pentru datele companiei, puteti completa numele si adresa UPB. Odata completate datele, dati click pe butonul '''Download''' din partea de jos a paginii.

'''Pasul 3:''' Dupa terminarea descarcarii, rulati executabilul de instalare.

'''Pasul 4:''' In fereastra de intampinare va sunt prezentate sistemele de operare suportate de acest utilitar. Dati click pe '''Next'''.

[[Fișier:Vivado instalare pas1.png|600px]]

'''Pasul 5:''' In urmatoare fereastra, introduceti datele de autentificare in contul Xilinx si asigurati-va ca este selectat '''Download and Install …''' , apoi dati click pe '''Next'''.

[[Fișier:Vivado instalare pas2.png|600px]]

'''Pasul 6:''' Urmeaza apoi selectarea produsului pe care doriti sa il descarcati. Selectati '''Vivado''', apoi dati click pe '''Next'''.

[[Fișier:Vivado instalare pas3.png|600px]]

'''Pasul 7:''' In fereastra '''Select Edition to Install''', selectati '''Vivado HL WebPACK''', apoi dati click pe '''Next'''.

[[Fișier:Vivado instalare pas4.png|600px]]

'''Pasul 8:''' In fereastra '''Vivado HL WebPACK''' aveti posibilitatea de a selecta doar anumite placi FPGA pentru care doriti instalarea. Pentru a reduce resursele ocupate de utilitar, puteti lasa selectat doar '''SoCs''' si '''7 Series'''. De asemenea, puteti deselecta '''DocNav'''. Dati apoi click pe '''Next'''.

[[Fișier:Vivado instalare pas5.png|600px]]

'''Pasul 9:''' In fereastra '''Accept License Agreements''', validati cele trei casute '''I Agree'''. Dati apoi click pe '''Next'''

[[Fișier:Vivado instalare pas6.png|600px]]

'''Pasul 10:''' In fereastra '''Select Destination Directory''' selectati locul in care doriti instalarea. Desi implicit instalarea se face in C:/, trebuie sa tineti cont de dimensiunea destul de mare a acesteia. Selectati, asadar, locul de instalare convenabil, apoi dati click pe '''Next'''.

'''Pasul 11:''' Ultima fereastra este '''Installation Sumary'''. Verificati selectiile facute, apoi dati click pe Install. Va incepe apoi descarcarea si instalarea.

'''Pasul 12: (Opțional - doar pentru PYNQ)''' Dupa instalarea Vivado va trebui sa instalam fisierele placutei PINQ Z2. Descarcati arhiva PYNQ Z2 de [https://dpoauwgwqsy2x.cloudfront.net/Download/pynq-z2.zip aici], dezarhivati, apoi mutati folder-ul rezultat in '''<Xilinx installation directory>\Vivado\<version>\data\boards\board_files''' (daca folder-ul '''board_files''' nu exista, va trebui creat).

Boolean Board - Pinout

2023-02-22T10:10:42Z

Gvpopescu:

Boolean Board - Pinout

2023-02-22T09:46:39Z

Gvpopescu: /* Boolean Board - Pinout */

==Boolean Board - Pinout==

Aici veți găsi lista cu corespondența pin - componentă pentru placa Boolean Board de la Real Digital. Aceasta se folosește fie în fișierul XDC cu constrângeri, fie în etapa ''Elaboration'', atunci când se selectează conexiunile fizice dorite între intrările și ieșirile circuitului și componentele de pe placă (LED-uri, butoane, comutatoare, etc.).

Pentru funcționarea corectă a plăcii se va selecta "LVCMOS33" ca standard de I/O, unde "33" vine de la 3.3V.

'''Comutatoare''':
{| class="wikitable"
|- bgcolor="#ddeeff" align="center"
|- bgcolor="#ddeeff" align="center"
| Componenta || Pin
|- bgcolor="#ddffdd" align="center"
|SW0 || V2
|- bgcolor="#ddffdd" align="center"
|SW1 || U2
|- bgcolor="#ddffdd" align="center"
|SW2 || U1
|- bgcolor="#ddffdd" align="center"
|SW3 || T2
|- bgcolor="#ddffdd" align="center"
|SW4 || T1
|- bgcolor="#ddffdd" align="center"
|SW5 || R2
|- bgcolor="#ddffdd" align="center"
|SW6 || R1
|- bgcolor="#ddffdd" align="center"
|SW7 || P2
|- bgcolor="#ddffdd" align="center"
|SW8 || P1
|- bgcolor="#ddffdd" align="center"
|SW9 || N2
|- bgcolor="#ddffdd" align="center"
|SW10 || N1
|- bgcolor="#ddffdd" align="center"
|SW11 || M2
|- bgcolor="#ddffdd" align="center"
|SW12 || M1
|- bgcolor="#ddffdd" align="center"
|SW13 || L1
|- bgcolor="#ddffdd" align="center"
|SW14 || K2
|- bgcolor="#ddffdd" align="center"
|SW15 || K1
|}

'''Butoane''':
{| class="wikitable"
|- bgcolor="#ddeeff" align="center"
|- bgcolor="#ddeeff" align="center"
| Componenta || Pin
|- bgcolor="#ddffdd" align="center"
|BTN0 || J2
|- bgcolor="#ddffdd" align="center"
|BTN1 || J5
|- bgcolor="#ddffdd" align="center"
|BTN2 || H2
|- bgcolor="#ddffdd" align="center"
|BTN3 || J1
|}

'''LED-uri''':
{| class="wikitable"
|- bgcolor="#ddeeff" align="center"
|- bgcolor="#ddeeff" align="center"
| Componenta || Pin
|- bgcolor="#ddffdd" align="center"
|LED0 || G1
|- bgcolor="#ddffdd" align="center"
|LED1 || G2
|- bgcolor="#ddffdd" align="center"
|LED2 || F1
|- bgcolor="#ddffdd" align="center"
|LED3 || F2
|- bgcolor="#ddffdd" align="center"
|LED4 || E1
|- bgcolor="#ddffdd" align="center"
|LED5 || E2
|- bgcolor="#ddffdd" align="center"
|LED6 || E3
|- bgcolor="#ddffdd" align="center"
|LED7 || E5
|- bgcolor="#ddffdd" align="center"
|LED8 || E6
|- bgcolor="#ddffdd" align="center"
|LED9 || C3
|- bgcolor="#ddffdd" align="center"
|LED10 || B2
|- bgcolor="#ddffdd" align="center"
|LED11 || A2
|- bgcolor="#ddffdd" align="center"
|LED12 || B3
|- bgcolor="#ddffdd" align="center"
|LED13 || A3
|- bgcolor="#ddffdd" align="center"
|LED14 || B4
|- bgcolor="#ddffdd" align="center"
|LED15 || A4
|}

'''LED-uri RGB''':
{| class="wikitable"
|- bgcolor="#ddeeff" align="center"
|- bgcolor="#ddeeff" align="center"
| Componenta || Pin
|- bgcolor="#ddffdd" align="center"
|RGB0_RED || V6
|- bgcolor="#ddffdd" align="center"
|RGB0_GREEN || V4
|- bgcolor="#ddffdd" align="center"
|RGB0_BLUE || U6
|- bgcolor="#ddffdd" align="center"
|RGB1_RED || U3
|- bgcolor="#ddffdd" align="center"
|RGB1_GREEN || V3
|- bgcolor="#ddffdd" align="center"
|RGB1_BLUE || V5
|}

'''Afisajul cu 7 segmente'''

''Grupul 0 (LEFT)'''
{| class="wikitable"
|- bgcolor="#ddeeff" align="center"
|- bgcolor="#ddeeff" align="center"
| Componenta || Pin
|- bgcolor="#ddffdd" align="center"
|Segmentul 0 || D7
|- bgcolor="#ddffdd" align="center"
|Segmentul 1 || C5
|- bgcolor="#ddffdd" align="center"
|Segmentul 2 || A5
|- bgcolor="#ddffdd" align="center"
|Segmentul 3 || B7
|- bgcolor="#ddffdd" align="center"
|Segmentul 4 || A7
|- bgcolor="#ddffdd" align="center"
|Segmentul 5 || D6
|- bgcolor="#ddffdd" align="center"
|Segmentul 6 || B5
|- bgcolor="#ddffdd" align="center"
|Punctul || A6
|- bgcolor="#ddffdd" align="center"
|Selectie Cifra 0 || D5
|- bgcolor="#ddffdd" align="center"
|Selectie Cifra 1 || C4
|- bgcolor="#ddffdd" align="center"
|Selectie Cifra 2 || C7
|- bgcolor="#ddffdd" align="center"
|Selectie Cifra 3 || A8
|}

''Grupul 1 (RIGHT)'''
{| class="wikitable"
|- bgcolor="#ddeeff" align="center"
|- bgcolor="#ddeeff" align="center"
| Componenta || Pin
|- bgcolor="#ddffdd" align="center"
|Segmentul 0 || F4
|- bgcolor="#ddffdd" align="center"
|Segmentul 1 || J3
|- bgcolor="#ddffdd" align="center"
|Segmentul 2 || D2
|- bgcolor="#ddffdd" align="center"
|Segmentul 3 || C2
|- bgcolor="#ddffdd" align="center"
|Segmentul 4 || B1
|- bgcolor="#ddffdd" align="center"
|Segmentul 5 || H4
|- bgcolor="#ddffdd" align="center"
|Segmentul 6 || D1
|- bgcolor="#ddffdd" align="center"
|Punctul || C1
|- bgcolor="#ddffdd" align="center"
|Selectie Cifra 0 || H3
|- bgcolor="#ddffdd" align="center"
|Selectie Cifra 1 || J4
|- bgcolor="#ddffdd" align="center"
|Selectie Cifra 2 || F3
|- bgcolor="#ddffdd" align="center"
|Selectie Cifra 3 || E4
|}

Pentru lista completă a pinilor puteți accesa [https://www.realdigital.org/hardware/boolean Boolean Board - pagina oficiala] - secțiunea ''User manual'' sau ''Master XDC''.

Boolean Board - Pinout

2023-02-22T09:36:51Z

Gvpopescu: /* Boolean Board - Pinout */

Circuite Integrate Digitale

2023-02-22T09:15:54Z

Gvpopescu: /* Tutoriale și documentații */

== 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 "Verilog", acesta fiind unul din cele 2 limbaje de descriere hardware folosite in industrie la ora actuala (celalalt fiind "VHDL").

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 PYNQ-Z2 impreuna cu o placa de extensie ce adauga leduri si butoane suplimentare.

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. Verilog HDL]] (Sintaxa [[Verilog]])
# [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 : Alte circuite combinationale]]
# [[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 11 : Automate finite

2022-05-29T11:02:09Z

Gvpopescu: /* Exemple */

== 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 2<sup>n</sup>. 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 clock,
input in,
input reset,
output detectOk,
output 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;

reg [1:0] state, state_next;

//registrul de stare
always@(posedge clock) begin
if(reset == 1)
state <= STATE_READ1;
else
state <= state_next;
end

//circuit combinational pentru calculul starii urmatoare
always@(*) 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();

reg clock_t;
reg reset_t;
reg in_t;
wire detectOk_t;
wire 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(
input clock,
input in,
input reset,
output out
);

localparam Q0 = 2'b00;
localparam Q1 = 2'b01;
localparam Q2 = 2'b10;

reg [1:0] state, state_next;

always@(posedge clock) begin
if(reset == 1)
state <= Q0;
else
state <= state_next;
end

always@(*) 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);

endmodule
</syntaxhighlight>

'''Implementarea unui modul de test pentru FSM2'''
<syntaxhighlight lang="Verilog">
module FSM2_TB();

reg clock_t;
reg reset_t;
reg in_t;
wire 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 DUT(
.clock(clock_t),
.reset(reset_t),
.in(in_t),
.out(out_t)
);

endmodule

</syntaxhighlight>

==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 Verilog 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.

CID aplicatii 11 : Automate finite

2022-05-29T07:18:56Z

Gvpopescu: /* Exercițiul 2 */

== 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 2<sup>n</sup>. 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 clock,
input in,
input reset,
output detectOk,
output 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;

reg [1:0] state, state_next;

//registrul de stare
always@(posedge clock) begin
if(reset == 0)
state <= STATE_READ1;
else
state <= state_next;
end

//circuit combinational pentru calculul starii urmatoare
always@(*) 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();

reg clock_t;
reg reset_t;
reg in_t;
wire detectOk_t;
wire detectFail_t;

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

initial begin
in_t = 1;
reset_t = 0;
#2 reset_t = 1;
#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(
input clock,
input in,
input reset,
output out
);

localparam Q0 = 2'b00;
localparam Q1 = 2'b01;
localparam Q2 = 2'b10;

reg [1:0] state, state_next;

always@(posedge clock) begin
if(reset == 0)
state <= Q0;
else
state <= state_next;
end

always@(*) 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);

endmodule
</syntaxhighlight>

'''Implementarea unui modul de test pentru FSM2'''
<syntaxhighlight lang="Verilog">
module FSM2_TB();

reg clock_t;
reg reset_t;
reg in_t;
wire out_t;

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

initial begin
in_t = 0;
reset_t = 0;
#2 reset_t = 1;
#10 in_t = 1;
#5 in_t = 0;
#10 in_t = 1;
#5 in_t = 0;
#10 $stop();
end

FSM2 DUT(
.clock(clock_t),
.reset(reset_t),
.in(in_t),
.out(out_t)
);

endmodule

</syntaxhighlight>

==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 Verilog 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.

CID aplicatii 11 : Automate finite

2022-05-29T07:17:46Z

Gvpopescu: /* Exerciții */

== 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 2<sup>n</sup>. 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 clock,
input in,
input reset,
output detectOk,
output 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;

reg [1:0] state, state_next;

//registrul de stare
always@(posedge clock) begin
if(reset == 0)
state <= STATE_READ1;
else
state <= state_next;
end

//circuit combinational pentru calculul starii urmatoare
always@(*) 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();

reg clock_t;
reg reset_t;
reg in_t;
wire detectOk_t;
wire detectFail_t;

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

initial begin
in_t = 1;
reset_t = 0;
#2 reset_t = 1;
#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(
input clock,
input in,
input reset,
output out
);

localparam Q0 = 2'b00;
localparam Q1 = 2'b01;
localparam Q2 = 2'b10;

reg [1:0] state, state_next;

always@(posedge clock) begin
if(reset == 0)
state <= Q0;
else
state <= state_next;
end

always@(*) 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);

endmodule
</syntaxhighlight>

'''Implementarea unui modul de test pentru FSM2'''
<syntaxhighlight lang="Verilog">
module FSM2_TB();

reg clock_t;
reg reset_t;
reg in_t;
wire out_t;

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

initial begin
in_t = 0;
reset_t = 0;
#2 reset_t = 1;
#10 in_t = 1;
#5 in_t = 0;
#10 in_t = 1;
#5 in_t = 0;
#10 $stop();
end

FSM2 DUT(
.clock(clock_t),
.reset(reset_t),
.in(in_t),
.out(out_t)
);

endmodule

</syntaxhighlight>

==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 Verilog 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 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.

CID aplicatii 11 : Automate finite

2022-05-29T06:58:37Z

Gvpopescu: Exercițiul 1

== 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 2<sup>n</sup>. 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 clock,
input in,
input reset,
output detectOk,
output 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;

reg [1:0] state, state_next;

//registrul de stare
always@(posedge clock) begin
if(reset == 0)
state <= STATE_READ1;
else
state <= state_next;
end

//circuit combinational pentru calculul starii urmatoare
always@(*) 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();

reg clock_t;
reg reset_t;
reg in_t;
wire detectOk_t;
wire detectFail_t;

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

initial begin
in_t = 1;
reset_t = 0;
#2 reset_t = 1;
#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(
input clock,
input in,
input reset,
output out
);

localparam Q0 = 2'b00;
localparam Q1 = 2'b01;
localparam Q2 = 2'b10;

reg [1:0] state, state_next;

always@(posedge clock) begin
if(reset == 0)
state <= Q0;
else
state <= state_next;
end

always@(*) 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);

endmodule
</syntaxhighlight>

'''Implementarea unui modul de test pentru FSM2'''
<syntaxhighlight lang="Verilog">
module FSM2_TB();

reg clock_t;
reg reset_t;
reg in_t;
wire out_t;

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

initial begin
in_t = 0;
reset_t = 0;
#2 reset_t = 1;
#10 in_t = 1;
#5 in_t = 0;
#10 in_t = 1;
#5 in_t = 0;
#10 $stop();
end

FSM2 DUT(
.clock(clock_t),
.reset(reset_t),
.in(in_t),
.out(out_t)
);

endmodule

</syntaxhighlight>

==Exerciții==

CID aplicatii 9 : Numaratorul

2022-05-03T10:01:51Z

Gvpopescu: /* Exemplul 2: Observarea vitezei de variație a biților unui numărător */

== 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: '''''f<sub>bN</sub>'' = ''f<sub>clk</sub> / 2<sup>N+1</sup>'''''

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 clock,
input reset_n,
output reg [WIDTH-1:0] count
);

always@(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;
reg reset_n_t, clock_t;
wire [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 '''''f<sub>bN</sub>'' = ''f<sub>clk</sub> / 2<sup>N+1</sup>''''' cunoscând că frecvența de ceas a FPGA-ului este de 125 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 Verilog a circuitului'''
<syntaxhighlight lang="Verilog">
module clock_generator(
input clock,
input reset,
output clkout1,
output clkout2,
output clkout4,
output clkout8,
);

reg [26:0] count;

always@(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_125MHz
|- 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 [3:0] in,
output reg [3:0] out
);

always @(in)
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 -> ...)