WikiLabs - Contribuții utilizator [ro]

CID Aplicatii 4

2021-03-21T14:56:46Z

Sduda:

== Memoria ROM–Introducere ==

Memoria ROM(Read-Only Memory) este un circuit combinational folosit pentru stocarea unor date ce pot fi accesate cu ajutorul unei intrari de adrese. Asa cum se intelege si din nume, memoria ROM, in general, nu poate fi modificata.

Pentru a intelege termenul de memorie, putem face urmatorul exercitiu de imaginatie: sa ne gandim la un dulap cu mai multe sertare. Continutul memoriei este reprezentat de continutul sertarelor, iar adresele sunt reprezentate de etichetele lipite pe aceste sertare, pentru a le identifica. Daca avem nevoie de continutul unui sertar, va trebui sa stim eticheta aferenta acestuia.

Am intalnit memoria ROM in aplicatiile anterioare, atunci cand am vorbit despre structura unui FPGA. Am vazut atunci ca functiile logice erau implementate pe FPGA prin intermediul unor LUT-uri (memorii ROM), care stocau iesirile corespunzatoare unor combinatii de intrari. Asadar, in cazul acela, adresele erau reprezentate de combinatii ale intrarilor, iar continutul memoriei era reprezentat de iesirile aferente acestor combinatii.

O memorie ROM are urmatorii parametri: numarul de biti ai adresei, care este legat de numarul de locatii de memorie (cu n biti de adresa putem forma 2𝑛 combinatii diferite, deci putem accesa maxim 2𝑛 locatii de memorie) si dimensiunea locatiei de memorie, care ne spune cat de multa informatie poate stoca o locatie de memorie.

Sa urmarim exemplul din figura urmatoare:

[[Fișier:ROM memory.PNG ‎| 400px]]

Aici, adresa are dimensiunea de 4 biti, asadar putem accesa cu aceasta 16 locatii diferite de memorie. Dimensiunea fiecarei locatii este de 8 biti, asadar fiecare locatie de memorie poate stoca numere de 8 biti. Spunem ca memoria ROM este o memorie 4x8. Capacitatea acestei memorii este de 16 x 8 biti = 128 biti.

== Exemplul 1 ==

'''Scop''': Descrierea comportamentala a unui decodor, testarea acestuia prin simulare si sinteza pe FPGA.

Decodorul este circuitul care, pentru o anumita valoare a intrarii, va genera la iesire un sir binar care contine 1 pe pozitia cu indicele egal cu valorea intrarii si 0 in rest. De exemplu, decodorul de mai jos pe 2 biti, va avea urmatoarea corespondenta intrare-iesire:

{| class="wikitable"
|- align="center"
||'''in''' || '''out'''
|- align="center"
| 2'b00 || 4'b0001
|- align="center"
|2'b01 || 4'b0010
|- align="center"
|2'b10 || 4'b0100
|- align="center"
|2'b11 || 4'b1000
|}

[[Fișier:Decoder.PNG ‎| 400px]]

Vom implementa acest circuit ca memorie ROM.

'''Implementarea Verilog a circuitului'''
<syntaxhighlight lang="Verilog">
module Decoder(
input [1:0] in,
output reg [3:0] out
);

always@(in) begin
case(in)
2'b00: out = 4'b0001;
2'b01: out = 4'b0010;
2'b10: out = 4'b0100;
2'b11: out = 4'b1000;
default: out = 4'b0000;
endcase
end

endmodule
</syntaxhighlight>

'''Implementarea Verilog a modulului de test'''

<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps

module Decoder_TB();
reg [1:0] in_t;
wire [3:0] out_t;

integer idx;

initial begin
for(idx=0; idx<4; idx = idx + 1) begin
in_t = idx;
#1;
end
#2 $stop();
end

Decoder DUT(
.in(in_t),
.out(out_t)
);

endmodule
</syntaxhighlight>

'''Observatii:'''
* Circuitul Decoder va avea o intrare pe 2 biti, care va reprezenta adresa memoriei ROM si o iesire pe 4 biti, reprezentand continuturile memoriei ROM corespunzatoare fiecarei combinatii de la intrare.
* Chiar daca in interiorul instructiunii ''case'' se acopera toate cazurile posibile (toate combinatiile de 2 biti), este bine sa punem si un ''default'' pentru a evita inserarea in locul circuitului combinational dorit (aici, memoria ROM) a unui latch.

'''Implementarea pe FPGA:'''
* Implementarea pe FPGA are ca tinta doar modulul in sine (Decoder), modulul de test (Decoder_TB) fiind nesintetizabil.
* Semnalele de intrare vor fi legate la dispozitive care comanda stari, iar iesirile la dispozitive care observa stari. Asadar, vom alege aici comutatoare pentru intrari (cate un comutator pentru fiecare bi tal fiecarei intrari –2 in total) si 4 LED-uri pentru iesiri.

{| class="wikitable"
|- align="center"
||'''Semnal''' || '''Dispozitiv''' || '''PIN'''
|- align="center"
| in[0] || SW0 || AB12
|- align="center"
| in[1] || SW1 || AC12
|- align="center"
| out[0] || LEDR0 || V16
|- align="center"
| out[1] || LEDR1 || W16
|- align="center"
| out[2] || LEDR2 || V17
|- align="center"
| out[3] || LEDR3 || V18

|}

[[Fișier:Fpga connections.PNG ‎| 600px]]

==Exemplul 2 ==

'''Scop:''' Implementarea unui circuit de afisare a sumei dintre doua numere pe 2 biti, folosind afisajul cu 7 segmente

[[Fișier:Add and display.PNG ‎| 500px]]

''' Implementarea Verilog amodululuiAdder2b'''

<syntaxhighlight lang="Verilog">
module Adder2b(
input [1:0] in0,
input [1:0] in1,
output reg [2:0] sum
);

always@(*) begin
sum = in0 + in1;
end

endmodule
</syntaxhighlight>

'''Observatii:'''
* Suma a doua numere pe n biti este un numar pe n+1 biti, cel de-al n+1 -ulea fiind bitul de carry. De aceea, aici suma a doua numere pe 2 biti va fi un numar pe 3 biti.
* Aici consideram un sumator simplu, pentru care carry este inglobat in suma (nu este explicit un port separat).

'''Implementarea Verilog a modululuiAfisaj7Seg'''

Inainte de a prezenta codul Verilog, trebuie sa intelegem cum functioneaza afisajul cu 7 segmente. Acest dispozitiv de afisare este format, asa cum sugereaza si numele, din 7 segmente ce pot fi controlate separat. Putem aprinde sau stinge fiecare segment controland tensiunea aplicata pe acesta. Pentru acest afisaj, comanda este negativa: aplicand 0 logic pe un segment acesta se va aprinde, iar aplicand 1 logic, acesta se va stinge.
Structura unui afisaj cu 7 segmente este prezentata in imaginea de mai jos:

[[Fișier:7LED display.PNG | 200px]]

Pentru a reprezenta, de exemplu, cele 16 numere hexa, segmentele trebuie aprinse conform Anexei 1.

In cazul circuitului nostru, vom vrea sa afisam numerele de la 0 la 6, deoarece suma maxima ce poate fi obtinuta este 6. Pentru aceasta, implementam o memorie ROM care va contine codurile de aprins-stins pentru fiecare segment, fiind accesate pe baza numarului pe care dorim sa il afisam. Asadar, intrarea memoriei ROM (adresa) va fi pe 3 biti (3 biti sunt de ajuns pentru a reprezenta numerele de la 0 la 6), iar iesirea va fi pe 7 biti, cate un bit de stare pentru fiecare segment. Vom considera, asadar, ca bitul 0 al iesirii se va lega la segmentul 0, bitul 1 la segmentul 1 si tot asa.

De exemplu, daca la intrare vom avea 0, memoria ROM va trebui sa dea la iesire sirul 1000000, stingand segmentul 6 si aprinzandu-le pe toate celelalte. Extinzand pentru toate numerele de la 0 la 7, obtinem:

{| class="wikitable"
|- align="center"
||'''Numar''' || '''Sir de afisare'''
|- align="center"
| 0 || 7'b100_0000
|- align="center"
| 1 || 7'b111_1001
|- align="center"
| 2 || 7'b010_0100
|- align="center"
| 3 || 7'b011_0000
|- align="center"
| 4 || 7'b001_1001
|- align="center"
| 5 || 7'b001_0010
|- align="center"
| 6 || 7'b000_0010
|}

'''Implementarea Verilog a modululuiDisplay7Seg'''

<syntaxhighlight lang="Verilog">
module Display7Seg(
input [2:0] in,
output reg [6:0] out
);

always@(in) begin
case(in)
3'd0: out = 7'b1000000;
3'd1: out = 7'b1111001;
3'd2: out = 7'b0100100;
3'd3: out = 7'b0110000;
3'd4: out = 7'b0011001;
3'd5: out = 7'b0010010;
3'd6: out = 7'b0000010;
default: out = 7'b0000110;
endcase
end

endmodule
</syntaxhighlight>

'''Implementarea Verilog a circuitului AddAndDisplay'''

<syntaxhighlight lang="Verilog">
module AddAndDisplay(
input [1:0] in0,
input [1:0] in1,
output [6:0] displayCode
);

wire [2:0] sum;

Adder2b ADD (
.in0(in0),
.in1(in1),
.sum(sum)
);

Display7Seg DISPLAY(
.in(sum),
.out(displayCode)
);

endmodule
</syntaxhighlight>

'''Implementarea Verilog a modulului de test'''

<syntaxhighlight lang="Verilog">
module AddAndDisplay_TB();

reg [1:0] in0_t, in1_t;
wire [6:0] displayCode_t;

integer idx, jdx;

initial begin
for(idx=0; idx<4; idx = idx + 1) begin
for(jdx=0; jdx<4; jdx = jdx + 1) begin
in0_t = idx;
in1_t = jdx;
#1;
end
end
#2 $stop();
end

AddAndDisplay DUT(
.in0(in0_t),
.in1(in1_t),
.displayCode(displayCode_t)
);

endmodule
</syntaxhighlight>

''' Implementarea pe FPGA:'''

Implementarea pe FPGA are ca tinta doar modulul in sine (AddAndDisplay), modulul de test (AddAndDisplay_TB) fiind nesintetizabil.

Conform indicatiilor din Introducere, semnalele de intrare vor fi legate la dispozitive care comanda stari, iar iesirile la dispozitive care observa stari. Asadar, vom alege aici comutatoare pentru intrari (cate un comutator pentru fiecare bit al fiecarei intrari –4 in total) si afisajul cu 7 segmente Digit 0 pentru iesire.

{| class="wikitable"
|- align="center"
||'''Semnal''' || '''Dispozitiv''' || '''PIN'''
|- align="center"
| in[0] || SW0 || AB12
|- align="center"
| in[1] || SW1 || AC12
|- align="center"
| in[2] || SW2 || AF9
|- align="center"
| in[3] || SW3 || AF10

|- align="center"
| out[0] || HEX0[0] || AE26
|- align="center"
| out[1] || HEX0[1] || AE27
|- align="center"
| out[2] || HEX0[2] || AE28
|- align="center"
| out[3] || HEX0[3] || AG27
|- align="center"
| out[4] || HEX0[4] || AF28
|- align="center"
| out[5] || HEX0[5] || AG28
|- align="center"
| out[6] || HEX0[6] || AH28
|}

[[Fișier:Add and display fpga conn.PNG | 700px]]

==Anexa1==

[[Fișier:Anexa1.PNG | 800px]]

<syntaxhighlight lang="Verilog">
</syntaxhighlight>

CID Aplicatii 4

2021-03-21T14:27:24Z

Sduda: /* Exemplul 2 */

== Memoria ROM–Introducere ==

Memoria ROM(Read-Only Memory)este un circuit combinationalfolosit pentru stocarea unor date ce pot fi accesate cu ajutorul unei intrari de adrese. Asa cum se intelege si din nume, memoria ROM, in general, nu poate fi modificata.

Pentru a intelege termenul de memorie, putem face urmatorul exercitiude imaginatie: sa ne gandim la un dulap cu mai multe sertare. Continutul memoriei este reprezentat de continutul sertarelor, iar adresele sunt reprezentate de etichetele lipite pe aceste sertare, pentru a le identifica. Daca avem nevoie de continutul unui sertar, va trebui sa stim eticheta aferenta acestuia.

Am intalnit memoria ROM in aplicatiile anterioare, atunci cand am vorbit despre structura unui FPGA. Am vazut atunci cafunctiile logice erau implementate pe FPGA prin intermediul unor LUT-uri (memorii ROM), care stocau iesirile corespunzatoare unor combinatii de intrari. Asadar, in cazul acela, adreseleerau reprezentate de combinatii ale intrarilor, iar continutul memoriei era reprezentat de iesirile aferente acestor combinatii.

O memorie ROM are urmatorii parametrii: numerul de biti ai adresei, care este legat de numarul de locatii de memorie (cu n biti de adresa putem forma 2𝑛combinatii diferite, deci putem accesa maxim 2𝑛locatii de memorie) si dimensiunea locatiei de memorie, care ne spune cat de multa informatie poate stoca o locatie de memorie.

Sa urmarim exemplul din figura urmatoare:

[[Fișier:ROM memory.PNG ‎| 400px]]

Aici, adresa are dimensiunea de 4 biti, asadar putem accesa cu aceasta 16 locatii diferite de memorie. Dimensiunea fiecarei locatii este de 8 biti, asadar fiecare locatie de memorie poate stoca numere de 8 biti. Spunem ca memoria ROM este o memorie 4x8. Capacitatea acestei memorii este de 16 x 8 biti = 128 biti.

== Exemplul 1 ==

'''Scop''': Descrierea comportamentala a unui decodor, testarea acestuia prin simulare si sinteza pe FPGA.

Decodorul este circuitul care, pentru o anumita valoare a intrarii, va genera laiesire un sir binar care contine 1 pe pozitia cu indicele egal cu valorea intrarii si 0 in rest. De exemplul, decodorul de mai jos pe 2 biti, va avea urmatoarea corespondentaintrare-iesire:

{| class="wikitable"
|- align="center"
||'''in''' || '''out'''
|- align="center"
| 2'b00 || 4'b0001
|- align="center"
|2'b01 || 4'b0010
|- align="center"
|2'b10 || 4'b0100
|- align="center"
|2'b11 || 4'b1000
|}

[[Fișier:Decoder.PNG ‎| 400px]]

Vom implementa acest circuit ca o memorie ROM.

'''Implementarea Verilog a circuitului'''
<syntaxhighlight lang="Verilog">
module Decoder(
input [1:0] in,
output reg [3:0] out
);

always@(in) begin
case(in)
2'b00: out = 4'b0001;
2'b01: out = 4'b0010;
2'b10: out = 4'b0100;
2'b11: out = 4'b1000;
default: out = 4'b0000;
endcase
end

endmodule
</syntaxhighlight>

'''Implementarea Verilog a modulului de test'''

<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps

module Decoder_TB();
reg [1:0] in_t;
wire [3:0] out_t;

integer idx;

initial begin
for(idx=0; idx<4; idx = idx + 1) begin
in_t = idx;
#1;
end
#2 $stop();
end

Decoder DUT(
.in(in_t),
.out(out_t)
);

endmodule
</syntaxhighlight>

'''Observatii:'''
* Circuitul Decoder va avea o intrare pe 2 biti, care va reprezenta adresa memoriei ROM si o iesire pe 4 biti, reprezentand continuturile memoriei ROM corespunzatoare fiecarei combinatii de la intrare.
* Chiar daca in interiorul case se acopera toate cazurile posibile (toate combinatiile de 2 biti), este bine sa punem si un default, ca sa evitam inserarea in locul circuitului combinational dorit (aici, memoria ROM) a unui latch.

'''Implementarea pe FPGA:'''
* Implementarea pe FPGA are ca tinta doar modulul in sine (Decoder), modulul de test (Decoder_TB) fiind nesintetizabil.
* Semnalele de intrare vor fi legate la dispozitive care comanda stari, iar iesirile la dispozitive care observa stari. Asadar, vom alege aici comutatoare pentru intrari (cate un comutator pentru fiecare bital fiecarei intrari –2in total) si 4 LED-uri pentru iesiri.

{| class="wikitable"
|- align="center"
||'''Semnal''' || '''Dispozitiv''' || '''PIN'''
|- align="center"
| in[0] || SW0 || AB12
|- align="center"
| in[1] || SW1 || AC12
|- align="center"
| out[0] || LEDR0 || V16
|- align="center"
| out[1] || LEDR1 || W16
|- align="center"
| out[2] || LEDR2 || V17
|- align="center"
| out[3] || LEDR3 || V18

|}

[[Fișier:Fpga connections.PNG ‎| 600px]]

==Exemplul 2 ==

'''Scop:''' Implementarea unui circuit de afisare a sumei dintre doua numere pe 2 biti, folosind afisajul cu 7 segmente

[[Fișier:Add and display.PNG ‎| 500px]]

''' Implementarea Verilog amodululuiAdder2b'''

<syntaxhighlight lang="Verilog">
module Adder2b(
input [1:0] in0,
input [1:0] in1,
output reg [2:0] sum
);

always@(*) begin
sum = in0 + in1;
end

endmodule
</syntaxhighlight>

'''Observatii:'''
* Suma a doua numere pe n biti este un numar pe n+1 biti, cel de-al n+1 -ulea fiind bitul de carry.De aceea, aici suma a doua numere pe 2 biti va fi un numar pe 3 biti.
* Aici consideram un sumator simplu, pentru care carry este inglobat in suma (nu este explicit un port separat).

'''Implementarea Verilog a modululuiAfisaj7Seg'''

Inainte de a prezenta codul Verilog, trebuie sa intelegem cum functioneaza afisajul cu 7 segmente. Acest dispozitiv de afisare este format, asa cum sugereaza si numele, din 7 segmente ce pot fi controlate separat. Putem aprinde sau stinge fiecare segmentcontroland tensiunea aplicata pe acesta. Pentru acest afisaj, comanda este negativa: aplicand 0 logic pe un segment acesta se va aprinde, iar aplicand 1 logic, acesta se va stinge.
Structura unui afisaj cu 7 segmente este prezentata in imaginea de mai jos:

[[Fișier:7LED display.PNG | 200px]]

Pentru a reprezenta, de exemplu, cele 16 numere hexa,segmentele trebuie aprinse conform Anexei 1.

In cazul circuitului nostru, vom vrea sa afisam numerele de la 0 la 6, deoarece suma maxima ce poate fi obtinuta este 6. Pentru aceasta, implementam o memorie ROM care va contine codurile de aprins-stins pentru fiecare segment, fiind accesate pe baza numarului pe care dorim sa il afisam. Asadar, intrarea memoriei ROM (adresa) va fi pe 3 biti (3 bitisunt de ajuns pentru a reprezenta numerele de la 0 la 6), iar iesirea va fi pe 7 biti, cate un bit de stare pentru fiecare segment. Vom considera, asadar, ca bitul 0 al iesirii se va lega la segmentul 0, bitul 1 la segmentul 1 si tot asa.

De exemplu, daca la intrare vom avea 0, memoria ROM va trebui sa dea la iesire sirul 1000000, stingand segmentul 6 si aprinzandu-le pe toate celelalte.Extinzand pentru toate numerele de la 0 la 7, obtinem:

{| class="wikitable"
|- align="center"
||'''Numar''' || '''Sir de afisare'''
|- align="center"
| 0 || 7'b100_0000
|- align="center"
| 1 || 7'b111_1001
|- align="center"
| 2 || 7'b010_0100
|- align="center"
| 3 || 7'b011_0000
|- align="center"
| 4 || 7'b001_1001
|- align="center"
| 5 || 7'b001_0010
|- align="center"
| 6 || 7'b000_0010
|}

'''Implementarea Verilog a modululuiDisplay7Seg'''

<syntaxhighlight lang="Verilog">
module Display7Seg(
input [2:0] in,
output reg [6:0] out
);

always@(in) begin
case(in)
3'd0: out = 7'b1000000;
3'd1: out = 7'b1111001;
3'd2: out = 7'b0100100;
3'd3: out = 7'b0110000;
3'd4: out = 7'b0011001;
3'd5: out = 7'b0010010;
3'd6: out = 7'b0000010;
default: out = 7'b0000110;
endcase
end

endmodule
</syntaxhighlight>

'''Implementarea Verilog a circuitului AddAndDisplay'''

<syntaxhighlight lang="Verilog">
module AddAndDisplay(
input [1:0] in0,
input [1:0] in1,
output [6:0] displayCode
);

wire [2:0] sum;

Adder2b ADD (
.in0(in0),
.in1(in1),
.sum(sum)
);

Display7Seg DISPLAY(
.in(sum),
.out(displayCode)
);

endmodule
</syntaxhighlight>

'''Implementarea Verilog a modulului de test'''

<syntaxhighlight lang="Verilog">
module AddAndDisplay_TB();

reg [1:0] in0_t, in1_t;
wire [6:0] displayCode_t;

integer idx, jdx;

initial begin
for(idx=0; idx<4; idx = idx + 1) begin
for(jdx=0; jdx<4; jdx = jdx + 1) begin
in0_t = idx;
in1_t = jdx;
#1;
end
end
#2 $stop();
end

AddAndDisplay DUT(
.in0(in0_t),
.in1(in1_t),
.displayCode(displayCode_t)
);

endmodule
</syntaxhighlight>

''' Implementarea pe FPGA:'''

Implementarea pe FPGA are ca tinta doar modulul in sine (AddAndDisplay), modulul de test (AddAndDisplay_TB) fiind nesintetizabil.

Conform indicatiilor din Introducere, semnalele de intrare vor fi legate la dispozitive care comanda stari, iar iesirile la dispozitive care observa stari. Asadar, vom alege aici comutatoare pentru intrari (cate un comutator pentru fiecare bit al fiecarei intrari –4in total) si afisajul cu 7 segmente Digit 0 pentru iesire.

{| class="wikitable"
|- align="center"
||'''Semnal''' || '''Dispozitiv''' || '''PIN'''
|- align="center"
| in[0] || SW0 || AB12
|- align="center"
| in[1] || SW1 || AC12
|- align="center"
| in[2] || SW2 || AF9
|- align="center"
| in[3] || SW3 || AF10

|- align="center"
| out[0] || HEX0[0] || AE26
|- align="center"
| out[1] || HEX0[1] || AE27
|- align="center"
| out[2] || HEX0[2] || AE28
|- align="center"
| out[3] || HEX0[3] || AG27
|- align="center"
| out[4] || HEX0[4] || AF28
|- align="center"
| out[5] || HEX0[5] || AG28
|- align="center"
| out[6] || HEX0[6] || AH28
|}

[[Fișier:Add and display fpga conn.PNG | 700px]]

==Anexa1==

[[Fișier:Anexa1.PNG | 800px]]

<syntaxhighlight lang="Verilog">
</syntaxhighlight>

CID Aplicatii 4

2021-03-21T14:26:38Z

Sduda: /* TODO: Add image */

== Memoria ROM–Introducere ==

Memoria ROM(Read-Only Memory)este un circuit combinationalfolosit pentru stocarea unor date ce pot fi accesate cu ajutorul unei intrari de adrese. Asa cum se intelege si din nume, memoria ROM, in general, nu poate fi modificata.

Pentru a intelege termenul de memorie, putem face urmatorul exercitiude imaginatie: sa ne gandim la un dulap cu mai multe sertare. Continutul memoriei este reprezentat de continutul sertarelor, iar adresele sunt reprezentate de etichetele lipite pe aceste sertare, pentru a le identifica. Daca avem nevoie de continutul unui sertar, va trebui sa stim eticheta aferenta acestuia.

Am intalnit memoria ROM in aplicatiile anterioare, atunci cand am vorbit despre structura unui FPGA. Am vazut atunci cafunctiile logice erau implementate pe FPGA prin intermediul unor LUT-uri (memorii ROM), care stocau iesirile corespunzatoare unor combinatii de intrari. Asadar, in cazul acela, adreseleerau reprezentate de combinatii ale intrarilor, iar continutul memoriei era reprezentat de iesirile aferente acestor combinatii.

O memorie ROM are urmatorii parametrii: numerul de biti ai adresei, care este legat de numarul de locatii de memorie (cu n biti de adresa putem forma 2𝑛combinatii diferite, deci putem accesa maxim 2𝑛locatii de memorie) si dimensiunea locatiei de memorie, care ne spune cat de multa informatie poate stoca o locatie de memorie.

Sa urmarim exemplul din figura urmatoare:

[[Fișier:ROM memory.PNG ‎| 400px]]

Aici, adresa are dimensiunea de 4 biti, asadar putem accesa cu aceasta 16 locatii diferite de memorie. Dimensiunea fiecarei locatii este de 8 biti, asadar fiecare locatie de memorie poate stoca numere de 8 biti. Spunem ca memoria ROM este o memorie 4x8. Capacitatea acestei memorii este de 16 x 8 biti = 128 biti.

== Exemplul 1 ==

'''Scop''': Descrierea comportamentala a unui decodor, testarea acestuia prin simulare si sinteza pe FPGA.

Decodorul este circuitul care, pentru o anumita valoare a intrarii, va genera laiesire un sir binar care contine 1 pe pozitia cu indicele egal cu valorea intrarii si 0 in rest. De exemplul, decodorul de mai jos pe 2 biti, va avea urmatoarea corespondentaintrare-iesire:

{| class="wikitable"
|- align="center"
||'''in''' || '''out'''
|- align="center"
| 2'b00 || 4'b0001
|- align="center"
|2'b01 || 4'b0010
|- align="center"
|2'b10 || 4'b0100
|- align="center"
|2'b11 || 4'b1000
|}

[[Fișier:Decoder.PNG ‎| 400px]]

Vom implementa acest circuit ca o memorie ROM.

'''Implementarea Verilog a circuitului'''
<syntaxhighlight lang="Verilog">
module Decoder(
input [1:0] in,
output reg [3:0] out
);

always@(in) begin
case(in)
2'b00: out = 4'b0001;
2'b01: out = 4'b0010;
2'b10: out = 4'b0100;
2'b11: out = 4'b1000;
default: out = 4'b0000;
endcase
end

endmodule
</syntaxhighlight>

'''Implementarea Verilog a modulului de test'''

<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps

module Decoder_TB();
reg [1:0] in_t;
wire [3:0] out_t;

integer idx;

initial begin
for(idx=0; idx<4; idx = idx + 1) begin
in_t = idx;
#1;
end
#2 $stop();
end

Decoder DUT(
.in(in_t),
.out(out_t)
);

endmodule
</syntaxhighlight>

'''Observatii:'''
* Circuitul Decoder va avea o intrare pe 2 biti, care va reprezenta adresa memoriei ROM si o iesire pe 4 biti, reprezentand continuturile memoriei ROM corespunzatoare fiecarei combinatii de la intrare.
* Chiar daca in interiorul case se acopera toate cazurile posibile (toate combinatiile de 2 biti), este bine sa punem si un default, ca sa evitam inserarea in locul circuitului combinational dorit (aici, memoria ROM) a unui latch.

'''Implementarea pe FPGA:'''
* Implementarea pe FPGA are ca tinta doar modulul in sine (Decoder), modulul de test (Decoder_TB) fiind nesintetizabil.
* Semnalele de intrare vor fi legate la dispozitive care comanda stari, iar iesirile la dispozitive care observa stari. Asadar, vom alege aici comutatoare pentru intrari (cate un comutator pentru fiecare bital fiecarei intrari –2in total) si 4 LED-uri pentru iesiri.

{| class="wikitable"
|- align="center"
||'''Semnal''' || '''Dispozitiv''' || '''PIN'''
|- align="center"
| in[0] || SW0 || AB12
|- align="center"
| in[1] || SW1 || AC12
|- align="center"
| out[0] || LEDR0 || V16
|- align="center"
| out[1] || LEDR1 || W16
|- align="center"
| out[2] || LEDR2 || V17
|- align="center"
| out[3] || LEDR3 || V18

|}

[[Fișier:Fpga connections.PNG ‎| 600px]]

==Exemplul 2 ==

'''Scop:''' Implementarea unui circuit de afisare a sumei dintre doua numere pe 2 biti, folosind afisajul cu 7 segmente

[[Fișier:Add and display.PNG ‎| 500px]]

''' Implementarea Verilog amodululuiAdder2b'''

<syntaxhighlight lang="Verilog">
module Adder2b(
input [1:0] in0,
input [1:0] in1,
output reg [2:0] sum
);

always@(*) begin
sum = in0 + in1;
end

endmodule
</syntaxhighlight>

'''Observatii:'''
* Suma a doua numere pe n biti este un numar pe n+1 biti, cel de-al n+1 -ulea fiind bitul de carry.De aceea, aici suma a doua numere pe 2 biti va fi un numar pe 3 biti.
* Aici consideram un sumator simplu, pentru care carry este inglobat in suma (nu este explicit un port separat).

'''Implementarea Verilog a modululuiAfisaj7Seg'''

Inainte de a prezenta codul Verilog, trebuie sa intelegem cum functioneaza afisajul cu 7 segmente. Acest dispozitiv de afisare este format, asa cum sugereaza si numele, din 7 segmente ce pot fi controlate separat. Putem aprinde sau stinge fiecare segmentcontroland tensiunea aplicata pe acesta. Pentru acest afisaj, comanda este negativa: aplicand 0 logic pe un segment acesta se va aprinde, iar aplicand 1 logic, acesta se va stinge.
Structura unui afisaj cu 7 segmente este prezentata in imaginea de mai jos:

[[Fișier:7LED display.PNG | 400px]]

Pentru a reprezenta, de exemplu, cele 16 numere hexa,segmentele trebuie aprinse conform Anexei 1.

In cazul circuitului nostru, vom vrea sa afisam numerele de la 0 la 6, deoarece suma maxima ce poate fi obtinuta este 6. Pentru aceasta, implementam o memorie ROM care va contine codurile de aprins-stins pentru fiecare segment, fiind accesate pe baza numarului pe care dorim sa il afisam. Asadar, intrarea memoriei ROM (adresa) va fi pe 3 biti (3 bitisunt de ajuns pentru a reprezenta numerele de la 0 la 6), iar iesirea va fi pe 7 biti, cate un bit de stare pentru fiecare segment. Vom considera, asadar, ca bitul 0 al iesirii se va lega la segmentul 0, bitul 1 la segmentul 1 si tot asa.

De exemplu, daca la intrare vom avea 0, memoria ROM va trebui sa dea la iesire sirul 1000000, stingand segmentul 6 si aprinzandu-le pe toate celelalte.Extinzand pentru toate numerele de la 0 la 7, obtinem:

{| class="wikitable"
|- align="center"
||'''Numar''' || '''Sir de afisare'''
|- align="center"
| 0 || 7'b100_0000
|- align="center"
| 1 || 7'b111_1001
|- align="center"
| 2 || 7'b010_0100
|- align="center"
| 3 || 7'b011_0000
|- align="center"
| 4 || 7'b001_1001
|- align="center"
| 5 || 7'b001_0010
|- align="center"
| 6 || 7'b000_0010
|}

'''Implementarea Verilog a modululuiDisplay7Seg'''

<syntaxhighlight lang="Verilog">
module Display7Seg(
input [2:0] in,
output reg [6:0] out
);

always@(in) begin
case(in)
3'd0: out = 7'b1000000;
3'd1: out = 7'b1111001;
3'd2: out = 7'b0100100;
3'd3: out = 7'b0110000;
3'd4: out = 7'b0011001;
3'd5: out = 7'b0010010;
3'd6: out = 7'b0000010;
default: out = 7'b0000110;
endcase
end

endmodule
</syntaxhighlight>

'''Implementarea Verilog a circuitului AddAndDisplay'''

<syntaxhighlight lang="Verilog">
module AddAndDisplay(
input [1:0] in0,
input [1:0] in1,
output [6:0] displayCode
);

wire [2:0] sum;

Adder2b ADD (
.in0(in0),
.in1(in1),
.sum(sum)
);

Display7Seg DISPLAY(
.in(sum),
.out(displayCode)
);

endmodule
</syntaxhighlight>

'''Implementarea Verilog a modulului de test'''

<syntaxhighlight lang="Verilog">
module AddAndDisplay_TB();

reg [1:0] in0_t, in1_t;
wire [6:0] displayCode_t;

integer idx, jdx;

initial begin
for(idx=0; idx<4; idx = idx + 1) begin
for(jdx=0; jdx<4; jdx = jdx + 1) begin
in0_t = idx;
in1_t = jdx;
#1;
end
end
#2 $stop();
end

AddAndDisplay DUT(
.in0(in0_t),
.in1(in1_t),
.displayCode(displayCode_t)
);

endmodule
</syntaxhighlight>

''' Implementarea pe FPGA:'''

Implementarea pe FPGA are ca tinta doar modulul in sine (AddAndDisplay), modulul de test (AddAndDisplay_TB) fiind nesintetizabil.

Conform indicatiilor din Introducere, semnalele de intrare vor fi legate la dispozitive care comanda stari, iar iesirile la dispozitive care observa stari. Asadar, vom alege aici comutatoare pentru intrari (cate un comutator pentru fiecare bit al fiecarei intrari –4in total) si afisajul cu 7 segmente Digit 0 pentru iesire.

{| class="wikitable"
|- align="center"
||'''Semnal''' || '''Dispozitiv''' || '''PIN'''
|- align="center"
| in[0] || SW0 || AB12
|- align="center"
| in[1] || SW1 || AC12
|- align="center"
| in[2] || SW2 || AF9
|- align="center"
| in[3] || SW3 || AF10

|- align="center"
| out[0] || HEX0[0] || AE26
|- align="center"
| out[1] || HEX0[1] || AE27
|- align="center"
| out[2] || HEX0[2] || AE28
|- align="center"
| out[3] || HEX0[3] || AG27
|- align="center"
| out[4] || HEX0[4] || AF28
|- align="center"
| out[5] || HEX0[5] || AG28
|- align="center"
| out[6] || HEX0[6] || AH28
|}

[[Fișier:Add and display fpga conn.PNG | 700px]]

==Anexa1==

[[Fișier:Anexa1.PNG | 800px]]

<syntaxhighlight lang="Verilog">
</syntaxhighlight>

Fișier:7LED display.PNG

2021-03-21T14:26:04Z

Sduda:

CID Aplicatii 4

2021-03-21T14:25:01Z

Sduda:

== Memoria ROM–Introducere ==

Memoria ROM(Read-Only Memory)este un circuit combinationalfolosit pentru stocarea unor date ce pot fi accesate cu ajutorul unei intrari de adrese. Asa cum se intelege si din nume, memoria ROM, in general, nu poate fi modificata.

Pentru a intelege termenul de memorie, putem face urmatorul exercitiude imaginatie: sa ne gandim la un dulap cu mai multe sertare. Continutul memoriei este reprezentat de continutul sertarelor, iar adresele sunt reprezentate de etichetele lipite pe aceste sertare, pentru a le identifica. Daca avem nevoie de continutul unui sertar, va trebui sa stim eticheta aferenta acestuia.

Am intalnit memoria ROM in aplicatiile anterioare, atunci cand am vorbit despre structura unui FPGA. Am vazut atunci cafunctiile logice erau implementate pe FPGA prin intermediul unor LUT-uri (memorii ROM), care stocau iesirile corespunzatoare unor combinatii de intrari. Asadar, in cazul acela, adreseleerau reprezentate de combinatii ale intrarilor, iar continutul memoriei era reprezentat de iesirile aferente acestor combinatii.

O memorie ROM are urmatorii parametrii: numerul de biti ai adresei, care este legat de numarul de locatii de memorie (cu n biti de adresa putem forma 2𝑛combinatii diferite, deci putem accesa maxim 2𝑛locatii de memorie) si dimensiunea locatiei de memorie, care ne spune cat de multa informatie poate stoca o locatie de memorie.

Sa urmarim exemplul din figura urmatoare:

[[Fișier:ROM memory.PNG ‎| 400px]]

Aici, adresa are dimensiunea de 4 biti, asadar putem accesa cu aceasta 16 locatii diferite de memorie. Dimensiunea fiecarei locatii este de 8 biti, asadar fiecare locatie de memorie poate stoca numere de 8 biti. Spunem ca memoria ROM este o memorie 4x8. Capacitatea acestei memorii este de 16 x 8 biti = 128 biti.

== Exemplul 1 ==

'''Scop''': Descrierea comportamentala a unui decodor, testarea acestuia prin simulare si sinteza pe FPGA.

Decodorul este circuitul care, pentru o anumita valoare a intrarii, va genera laiesire un sir binar care contine 1 pe pozitia cu indicele egal cu valorea intrarii si 0 in rest. De exemplul, decodorul de mai jos pe 2 biti, va avea urmatoarea corespondentaintrare-iesire:

{| class="wikitable"
|- align="center"
||'''in''' || '''out'''
|- align="center"
| 2'b00 || 4'b0001
|- align="center"
|2'b01 || 4'b0010
|- align="center"
|2'b10 || 4'b0100
|- align="center"
|2'b11 || 4'b1000
|}

[[Fișier:Decoder.PNG ‎| 400px]]

Vom implementa acest circuit ca o memorie ROM.

'''Implementarea Verilog a circuitului'''
<syntaxhighlight lang="Verilog">
module Decoder(
input [1:0] in,
output reg [3:0] out
);

always@(in) begin
case(in)
2'b00: out = 4'b0001;
2'b01: out = 4'b0010;
2'b10: out = 4'b0100;
2'b11: out = 4'b1000;
default: out = 4'b0000;
endcase
end

endmodule
</syntaxhighlight>

'''Implementarea Verilog a modulului de test'''

<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps

module Decoder_TB();
reg [1:0] in_t;
wire [3:0] out_t;

integer idx;

initial begin
for(idx=0; idx<4; idx = idx + 1) begin
in_t = idx;
#1;
end
#2 $stop();
end

Decoder DUT(
.in(in_t),
.out(out_t)
);

endmodule
</syntaxhighlight>

'''Observatii:'''
* Circuitul Decoder va avea o intrare pe 2 biti, care va reprezenta adresa memoriei ROM si o iesire pe 4 biti, reprezentand continuturile memoriei ROM corespunzatoare fiecarei combinatii de la intrare.
* Chiar daca in interiorul case se acopera toate cazurile posibile (toate combinatiile de 2 biti), este bine sa punem si un default, ca sa evitam inserarea in locul circuitului combinational dorit (aici, memoria ROM) a unui latch.

'''Implementarea pe FPGA:'''
* Implementarea pe FPGA are ca tinta doar modulul in sine (Decoder), modulul de test (Decoder_TB) fiind nesintetizabil.
* Semnalele de intrare vor fi legate la dispozitive care comanda stari, iar iesirile la dispozitive care observa stari. Asadar, vom alege aici comutatoare pentru intrari (cate un comutator pentru fiecare bital fiecarei intrari –2in total) si 4 LED-uri pentru iesiri.

{| class="wikitable"
|- align="center"
||'''Semnal''' || '''Dispozitiv''' || '''PIN'''
|- align="center"
| in[0] || SW0 || AB12
|- align="center"
| in[1] || SW1 || AC12
|- align="center"
| out[0] || LEDR0 || V16
|- align="center"
| out[1] || LEDR1 || W16
|- align="center"
| out[2] || LEDR2 || V17
|- align="center"
| out[3] || LEDR3 || V18

|}

[[Fișier:Fpga connections.PNG ‎| 600px]]

==Exemplul 2 ==

'''Scop:''' Implementarea unui circuit de afisare a sumei dintre doua numere pe 2 biti, folosind afisajul cu 7 segmente

[[Fișier:Add and display.PNG ‎| 500px]]

''' Implementarea Verilog amodululuiAdder2b'''

<syntaxhighlight lang="Verilog">
module Adder2b(
input [1:0] in0,
input [1:0] in1,
output reg [2:0] sum
);

always@(*) begin
sum = in0 + in1;
end

endmodule
</syntaxhighlight>

'''Observatii:'''
* Suma a doua numere pe n biti este un numar pe n+1 biti, cel de-al n+1 -ulea fiind bitul de carry.De aceea, aici suma a doua numere pe 2 biti va fi un numar pe 3 biti.
* Aici consideram un sumator simplu, pentru care carry este inglobat in suma (nu este explicit un port separat).

'''Implementarea Verilog a modululuiAfisaj7Seg'''

Inainte de a prezenta codul Verilog, trebuie sa intelegem cum functioneaza afisajul cu 7 segmente. Acest dispozitiv de afisare este format, asa cum sugereaza si numele, din 7 segmente ce pot fi controlate separat. Putem aprinde sau stinge fiecare segmentcontroland tensiunea aplicata pe acesta. Pentru acest afisaj, comanda este negativa: aplicand 0 logic pe un segment acesta se va aprinde, iar aplicand 1 logic, acesta se va stinge.
Structura unui afisaj cu 7 segmente este prezentata in imaginea de mai jos:

== TODO: Add image ==

Pentru a reprezenta, de exemplu, cele 16 numere hexa,segmentele trebuie aprinse conform Anexei 1.

In cazul circuitului nostru, vom vrea sa afisam numerele de la 0 la 6, deoarece suma maxima ce poate fi obtinuta este 6. Pentru aceasta, implementam o memorie ROM care va contine codurile de aprins-stins pentru fiecare segment, fiind accesate pe baza numarului pe care dorim sa il afisam. Asadar, intrarea memoriei ROM (adresa) va fi pe 3 biti (3 bitisunt de ajuns pentru a reprezenta numerele de la 0 la 6), iar iesirea va fi pe 7 biti, cate un bit de stare pentru fiecare segment. Vom considera, asadar, ca bitul 0 al iesirii se va lega la segmentul 0, bitul 1 la segmentul 1 si tot asa.

De exemplu, daca la intrare vom avea 0, memoria ROM va trebui sa dea la iesire sirul 1000000, stingand segmentul 6 si aprinzandu-le pe toate celelalte.Extinzand pentru toate numerele de la 0 la 7, obtinem:

{| class="wikitable"
|- align="center"
||'''Numar''' || '''Sir de afisare'''
|- align="center"
| 0 || 7'b100_0000
|- align="center"
| 1 || 7'b111_1001
|- align="center"
| 2 || 7'b010_0100
|- align="center"
| 3 || 7'b011_0000
|- align="center"
| 4 || 7'b001_1001
|- align="center"
| 5 || 7'b001_0010
|- align="center"
| 6 || 7'b000_0010
|}

'''Implementarea Verilog a modululuiDisplay7Seg'''

<syntaxhighlight lang="Verilog">
module Display7Seg(
input [2:0] in,
output reg [6:0] out
);

always@(in) begin
case(in)
3'd0: out = 7'b1000000;
3'd1: out = 7'b1111001;
3'd2: out = 7'b0100100;
3'd3: out = 7'b0110000;
3'd4: out = 7'b0011001;
3'd5: out = 7'b0010010;
3'd6: out = 7'b0000010;
default: out = 7'b0000110;
endcase
end

endmodule
</syntaxhighlight>

'''Implementarea Verilog a circuitului AddAndDisplay'''

<syntaxhighlight lang="Verilog">
module AddAndDisplay(
input [1:0] in0,
input [1:0] in1,
output [6:0] displayCode
);

wire [2:0] sum;

Adder2b ADD (
.in0(in0),
.in1(in1),
.sum(sum)
);

Display7Seg DISPLAY(
.in(sum),
.out(displayCode)
);

endmodule
</syntaxhighlight>

'''Implementarea Verilog a modulului de test'''

<syntaxhighlight lang="Verilog">
module AddAndDisplay_TB();

reg [1:0] in0_t, in1_t;
wire [6:0] displayCode_t;

integer idx, jdx;

initial begin
for(idx=0; idx<4; idx = idx + 1) begin
for(jdx=0; jdx<4; jdx = jdx + 1) begin
in0_t = idx;
in1_t = jdx;
#1;
end
end
#2 $stop();
end

AddAndDisplay DUT(
.in0(in0_t),
.in1(in1_t),
.displayCode(displayCode_t)
);

endmodule
</syntaxhighlight>

''' Implementarea pe FPGA:'''

Implementarea pe FPGA are ca tinta doar modulul in sine (AddAndDisplay), modulul de test (AddAndDisplay_TB) fiind nesintetizabil.

Conform indicatiilor din Introducere, semnalele de intrare vor fi legate la dispozitive care comanda stari, iar iesirile la dispozitive care observa stari. Asadar, vom alege aici comutatoare pentru intrari (cate un comutator pentru fiecare bit al fiecarei intrari –4in total) si afisajul cu 7 segmente Digit 0 pentru iesire.

{| class="wikitable"
|- align="center"
||'''Semnal''' || '''Dispozitiv''' || '''PIN'''
|- align="center"
| in[0] || SW0 || AB12
|- align="center"
| in[1] || SW1 || AC12
|- align="center"
| in[2] || SW2 || AF9
|- align="center"
| in[3] || SW3 || AF10

|- align="center"
| out[0] || HEX0[0] || AE26
|- align="center"
| out[1] || HEX0[1] || AE27
|- align="center"
| out[2] || HEX0[2] || AE28
|- align="center"
| out[3] || HEX0[3] || AG27
|- align="center"
| out[4] || HEX0[4] || AF28
|- align="center"
| out[5] || HEX0[5] || AG28
|- align="center"
| out[6] || HEX0[6] || AH28
|}

[[Fișier:Add and display fpga conn.PNG | 700px]]

==Anexa1==

[[Fișier:Anexa1.PNG | 800px]]

<syntaxhighlight lang="Verilog">
</syntaxhighlight>

Fișier:Anexa1.PNG

2021-03-21T14:23:56Z

Sduda:

Fișier:Add and display fpga conn.PNG

2021-03-21T14:23:25Z

Sduda:

CID Aplicatii 4

2021-03-21T14:16:20Z

CID Aplicatii 2

2021-03-08T18:02:38Z

Sduda: /* Exemplul 1 */

==Module de test - Introducere==
Modulul de test este folosit pentru testarea circuitului descris, prin simulare, si nu este sintetizabil. Simularea permite detectia rapida a erorilor de implementare si corectarea acestora. Ideea generala a unui modul de test este descrisa in figura de mai jos (consideram un circuit cu numele circuit si modulul sau de test circuit_TB):

[[Fișier:Circuit_TB.PNG ‎| 400px]]

'''Observatii:'''

* Modulul de test NU are intrari sau iesiri si nu este sintetizabil. Toate procesele au loc in interiorul acestuia.
* Modulul de test are in principal urmatoarele componente: o instantiere a modulului testat (circuit), un generator de semnale de test si, optional, un bloc de evaluare automata a rezultatului. Aceasta evaluare automata devine insa obligatorie pentru circuitele complexe.
* Generatorul de semnale de test va genera cate un semnal pentru fiecare intrare a circuitului. Tinand cont ca aceasta generare se face in blocuri initial, trebuie sa definim cate un semnal de test de tip reg pentru fiecare intrare a modulului testat.
* Pentru fiecare iesire a modulului testat, definim cate un semnal de tip wire. Acesta poate fi evaluat mai departe intr-un bloc de evaluare automata.

'''Notiuni de sintaxa'''
* Variabilele de tip ''wire'' sunt folosite pentru a conecta elemente dintr-un design. Acestea pot fi citite sau asignate, insa nu pot stoca valori
* Variabilele de tip ''reg'' sunt folosite pentru a stoca date.

==Exemplul 1==

Descrieti structural circuitul reprezentat mai jos si creati pentru acesta un modul de test.

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

'''Implementarea Verilog a circuitului'''
<syntaxhighlight lang="Verilog">
module exemplul1(out, in0, in1, sel);

output out;
input in0;
input in1;
input sel;
wire w1, w2, w3;

not inverter_gate(w1, sel);
and and_gate1(w2, in0, w1);
and and_gate2(w3, sel, in1);
or or_gate(out, w2, w3);

endmodule
</syntaxhighlight>

'''Implementarea Verilog a modulului de test'''
<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps

module exemplul1_TB();

reg in0_t, in1_t, sel_t;
wire out_t;
integer idx;

initial begin
for(idx=0; idx<8;idx=idx+1) begin
in0_t = idx[0];
in1_t = idx[1];
sel_t = idx[2];
#1;
end
end

exemplul1DUT(out_t, in0_t, in1_t, sel_t);

endmodule
</syntaxhighlight>
'''Notiuni de sintaxa'''
* Tipul de date ''integer'' este reprezinta o variabila de tip ''reg'' definit pe 32 de biti (''reg[31:0]'' )
* Blocul ''initial'' se executa intotdeauna la timpul 0 al simularii. In cazul in care sunt definite mai multe blocuri initial, acestea se vor executa in paralel.
* '' `timescale'' este o directiva de preprocesare care ii indica simulatorului unitatea default de masurarea a timpului si precizia pasului de simulare. In cazul de mai sus ''`timescale 1ns/1ps'' inseamna ca precizia de simulare este 1ps, iar unitate de masura a timpului este in ns.
* Pentru a astepta un anumit interval de tip se pot folosi instructiuni de intarziere:
** ''#1;'' - Asteapta o unitate de timp (conform celei specificate in directiva ''`timescale'') Intarzierile cu "#" nu sunt recomandate in testarea circuitelor secventiale. Exemple:
** ''#5ns;'' - Asteapta 5 nanosecunde
** ''#12us;'' - Asteapta 12 microsecunde
** ''#1s;'' - Asteapta o secunda

'''Observatii:'''
* Modulul exemplul1 este implementat folosind instantieri ale portilor logice predefinite in Verilog.
* Instantierea, in general, se face astfel: tip_modul nume_modul (...intefata...). In cazul nostru, interfatarea se face implicit prin ordine: punem semnalele la care modulul trebuie sa se conecteze in ordine si acestea se vor conecta automat. Pentru portile logice, interfata este de tipul (out, in0, in1, ....).
* Acest mod de interfatare este oarecum acceptat pentru modulele foarte simple, dar nerecomandat pentru modulele complexe, unde gresirea ordinii duce la implementarea gresita a circuitelor.
* Pentru modulul de test(exemplul1_TB), observam ca interfata acestuia este goala (nu exista intrari sau iesiri).
* De asemenea, pentru fiecare intrare a modulului testat se defineste un semnal de tip reg, iar pentru fiecare iesire se defineste un semnal de tip wire. '''Atentie!''' Dimensiunea acestor semnale trebuie sa corespunda cu dimensiunea semnalelor din interfata modului la care vor fi legate.
* Generarea semnalelor de test a fost facuta cu ajutorul unei bucle de tip for care variaza un index intre 0 si 7 (generam astfel toate variantele de biti pentru cele trei semnale de 1 bit: sel_t, in0_tsi in1_t, fiecare legandu-se la un bit al indexului). In instantierea modulului exemplu1 observam din nou interfatarea implicita prin ordine.
* Analizand ordinea semnalelor din interfata modulului exemplul1 si ordinea legaturilor din instantierea acestuia in exemplul1_TB, out_t se va lega la out, sel_tla sel, in0_tla in0 si in1_t la in1.

==Exemplul 2==
Descrieti functional circuitul anterior cu ajutorul operatorilor Verilog si realizati un modul de test cu evaluare automata.

'''Implementarea Verilog a circuitului'''

<syntaxhighlight lang="Verilog">
module exemplul2(
output out,
input in0,
input in1,
input sel
);

assign out = ((~sel) & in0) | (sel & in1);

endmodule
</syntaxhighlight>

'''Implementarea Verilog a modulului de test'''
<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps

module exemplul2_TB();

reg in0_t, in1_t, sel_t;
wire out_t;
integer idx; //index for loop
reg flag; //test status flag

initial begin
flag = 0;
for(idx=0; idx<8;idx=idx+1) begin
in0_t = idx[0];
in1_t = idx[1];
sel_t = idx[2];
#1;
if(((sel_t == 0) && (out_t == in0_t)) || ((sel_t == 1) && (out_t == in1_t))) begin
end else begin
flag = 1;
$display("TEST_FAIL at sel = %b, in0 = %b, in1 = %b, out = %b", sel_t, in0_t, in1_t, out_t);
end
end

if(flag == 0)
$display("TEST_PASS");
end

exemplul2 dut(
.in0(in0_t),
.in1(in1_t),
.sel(sel_t),
.out(out_t));

endmodule
</syntaxhighlight>

'''Elemente de sintaxa'''
* Functia de sistem ''$display'' este folosita pentru a printa mesaje in consola. Aceasta are sintaxa similara cu function ''printf'' din C. Aceasta este nesintetizabila si nu ar trebui folosita in modulele proiectate decat pentru debug.

'''Observatii:'''
* Pentru modulul de test: Pe langa generarea semnalelor de test, observam ca la fiecare pas testam corectitudinea iesirii. Asa cum am observat, circuitul realizeaza urmatoarea functie: atunci cand ''sel'' este 0, ''out'' va fi egal cu ''in0'', iar atunci cand ''sel'' este 1, ''out'' va fi egal cu ''in1''. Ne vom folosi de acest lucru pentru evaluarea automata.
* Consideram un fanion ''flag'', de tip ''reg'' deoarece isi va modifica valoarea intr-un bloc ''initial'', pe care il vom initializa cu 0 (prezumtia de nevinovatie– consideram initial circuitul corect). Testam conditia de corectitudine la fiecare pas de generare a semnalelor de test (la fiecare iteratie a buclei ''for'') si daca ea este indeplinita, nimic nu se intampla cu ''flag'', ramanand 0. Daca acesta conditie nu este indeplinita cel putin o data, ''flag'' se va face 1, semnalizand ca apare cel putin un caz incorect, afisandu-se totodata in consola cu ''$display'' mesajul TEST_FAIL si starea semnalelor in momentul acestuia. La iesirea din bucla testam din nou fanionul si daca acesta este 0, inseamna ca nu a aparut nici macar un caz incorect, afisand in cazul acesta mesajul TEST_PASS.
* Instantierea modulului testat se face astfel:
''.semnal_interfata_modul_testat(semnalul_la care_va_fi_conectat)''
Aceasta modalitate ne ofera controlul asupra conexiunilor, fara constrangeri de ordine.

==Exemplul 3==
Descrieti comportamental acelasi circuit, folosind blocurile assign conditionat, always + if si always + case.

'''Implementarea Verilog a circuitului'''
* ''' Folosing ''assign'' conditionat'''
<syntaxhighlight lang="Verilog">
module exemplul3(
output out,
input in0,
input in1,
input sel
);

assign out = (sel == 0) ? in0 : in1;

endmodule
</syntaxhighlight>

* ''' Folosing ''always'' si ''if'' '''

<syntaxhighlight lang="Verilog">
module exemplul3(
output out,
input in0,
input in1,
input sel
);

always@(in0 or in1 or sel) begin
if(sel == 0)
out = in0;
else
out = in1;
end

endmodule
</syntaxhighlight>

* ''' Folosing ''always'' si ''case'' '''
<syntaxhighlight lang="Verilog">
module exemplul3(
output out,
input in0,
input in1,
input sel
);

always@(*) begin
case(sel)
1'b0: out = in0;
1'b1: out = in1;
default: out = in0;
endcase
end

endmodule
</syntaxhighlight>

'''Elemente de sintaxa'''
* Blocul ''always'' descrie un comportament repetitiv. Acesta se executa atunci cand se schimba un element din lista de senzitivitate "@(...)". In functie de semnalele definite in lista de senzitivitate, blocul always poate avea atat comportament combinational, cat si secvential (vezi [[Verilog]] pentru mai multe detalii).

'''Observatii: '''
* In primul caz, ''assign'' conditionat are o sintaxa asemanatoare cu cea a limbajului C:
''(conditie) ? semnalul_cond_indeplinita : semnal_cond_neindeplinita; ''
* In cazul 2, folosind un bloc ''always'' pentru actualizarea semnalului ''out'', acesta trebuie declarat ca ''reg'' (''output reg out''). In interiorul parantezelor blocului ''always'' punem lista de semnale la care acesta va fi sensibil. Fiind un circuit combinational, ''out'' trebuie sa fie sensibil imediat la toate semnalele care il influenteaza. Putem inlocui toata aceasta lista cu *. Asta ne asigura ca nu am omis niciun semnal.
* In cazul 3, folosim * pentru lista de senzitivitati a circuitului si un bloc case. '''Atentie!''' Desi aici este clar ca am acoperit toate combinatiile posibile ale lui sel(0 si 1), pentru combinatii complexe este posibil sa omitem cazuri si astfel circuitul nostru se va transforma intr-unul de memorare. Ca sa evitam acest lucru, definim si un caz default.
* Se poate folosi modulul de test anterior pentru testare, cu observatia ca modulul instantiat se va denumi exemplul3.

== Exercitii suplimentare ==
1. Scrieti un modul de test pentru un sumator pe 4 biti, descris cu ajutorul Verilog astfel:

<syntaxhighlight lang="Verilog">
module sum(
input[3:0] a,
input[3:0] b,
output[4:0] sum,
);

assign sum = a + b;

endmodule
</syntaxhighlight>

2. Scrieti un modul de test pentru un comparator pe 8 biti, descris cu ajutorul Verilog astfel:
<syntaxhighlight lang="Verilog">
module comp(
input[3:0] a,
input[3:0] b,
output lt,
output gt,
output eq,
);

assign lt = a < b;
assign gt = a > b;
assign eq = a == b;

endmodule
</syntaxhighlight>

<syntaxhighlight lang="Verilog">
</syntaxhighlight>

2021-03-06T22:57:13Z

Sduda:

==Module de test - Introducere==
Modulul de test este folosit pentru testarea circuitului descris,prin simulare,si nu este sintetizabil. Simularea permite detectia rapida a erorilor de implementare si corectarea acestora.Ideea generala a unui modul de test este descrisa in figura de mai jos(consideram un circuit cu numele circuitsi modulul sau de test circuit_TB):

TODO: Insert image

'''Observatii:'''

* Modulul de test NU are intrari sau iesiresi nu este sintetizabil. Toate procesele au loc in interiorul acestuia.
* Modulul de test are in principal urmatoarele componente: o instantiere a modulului testat (circuit), un generator de semnale de test si,optional, un bloc de evaluare automata a rezultatului.Aceasta evaluare automata devine insa obligatorie pentru circuitele complexe.o
* Generatorul de semnale de test va genera cate un semnal pentru fiecare intrare a circuitului. Tinand cont ca aceasta generare se face in blocuri initial, trebuie sa definim cate un semnal de test de tip regpentru fiecare intrare a modulului testat.
* Pentru fiecare iesire a modulului testat, definim cate un semnal de tip wire. Acesta poate fi evaluat mai departe intr-un bloc de evaluare automata.

==Exemplul 1==

'''Scop''': Descrierea structurala a unui circuit simplu si realizarea unui modul de test pentru acesta

TODO: Insert image

'''Implementarea Verilog a circuitului'''
<syntaxhighlight lang="Verilog">
module exemplul1(out, in0, in1, sel);

output out;
input in0;
input in1;
input sel;
wire w1, w2, w3;

not inverter_gate(w1, sel);
and and_gate1(w2, in0, w1);
and and_gate2(w3, sel, in1);
or or_gate(out, w2, w3);

endmodule
</syntaxhighlight>

'''Implementarea Verilog a modulului de test'''
<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps

module exemplul1_TB();

reg in0_t, in1_t, sel_t;
wire out_t;
integer idx;

initial begin
for(idx=0; idx<8;idx=idx+1) begin
in0_t = idx[0];
in1_t = idx[1];
sel_t = idx[2];
#1;
end
end

exemplul1DUT(out_t, in0_t, in1_t, sel_t);

endmodule
</syntaxhighlight>

'''Observatii:'''
* Modulul exemplul1 este implementat folosind instantieri ale portilor logice predefinite in Verilog.
* Instantierea, in general, se face astfel: tip_modul nume_modul (...intefata...). In cazul nostru, interfatarea se face implicit prin ordine: punem semnalele la care modulul trebuie sa se conecteze in ordine si acestea se vor conectaautomat. Pentru portile logice, interfata este de tipul (out, in0, in1, ....).
* Acest mod de interfatare este oarecum acceptat pentru modulele foarte simple, dar nerecomandat pentru modulele complexe, unde gresirea ordinii duce la implementarea gresita a circuitelor.
* Pentru modulul de test(exemplul1_TB), observam ca interfata acestuia este goala (nu exista intrari sau iesiri).
* De asemenea, pentru fiecare intrare a modulului testat se defineste un semnal de tip reg, iar pentru fiecare iesire se defineste un semnal de tip wire. '''Atentie!''' Dimensiunea acestor semnale trebuie sa corespunda cu dimensiunea semnalelor din interfata modului la care vor fi legate.
* Generarea semnalelor de test a fost facuta cu ajutorul unei bucle de tip forcare variaza un index intre 0 si 7 (generam astfel toate variantele de biti pentru cele trei semnale de 1 bit: sel_t, in0_tsi in1_t, fiecare legandu-se la un bit al indexului).In instantierea modulului exemplu1 observam din nou interfatarea implicita prin ordine.
* Analizand ordinea semnalelor din interfata modulului exemplul1 si ordinea legaturilor din instantierea acestuia in exemplul1_TB, out_t se va lega la out, sel_tla sel, in0_tla in0 si in1_t la in1.

==Exemplul 2==
'''Scop:''' Descrierea functionala a aceluiasi circuit cu ajutorul operatorilor Verilog si realizarea unui modul de test cu evaluare automata.

'''Implementarea Verilog a circuitului'''

<syntaxhighlight lang="Verilog">
module exemplul2(output out,input in0,input in1,input sel);

assign out = ((~sel) & in0) | (sel & in1);

endmodule
</syntaxhighlight>

'''Implementarea Verilog a modulului de test'''
<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps

module exemplul2_TB();

reg in0_t, in1_t, sel_t;
wire out_t;
integer idx; //index for loop
reg flag; //test status flag

initial begin
flag = 0;
for(idx=0; idx<8;idx=idx+1) begin
in0_t = idx[0];
in1_t = idx[1];
sel_t = idx[2];
#1;
if(((sel_t == 0) && (out_t == in0_t)) || ((sel_t == 1) && (out_t == in1_t))) begin
end else begin
flag = 1;
$display("TEST_FAIL at sel = %b, in0 = %b, in1 = %b, out = %b", sel_t, in0_t, in1_t, out_t);
end
end

if(flag == 0)
$display("TEST_PASS");
end

exemplul2 dut(
.in0(in0_t),
.in1(in1_t),
.sel(sel_t),
.out(out_t));

endmodule
</syntaxhighlight>

'''Observatii:'''
* Pentru modulul de test: Pe langa generarea semnalelor de test, observam ca la fiecare pas testam corectitudinea iesirii. Asa cum am observat, circuitul realizeaza urmatoarea functie: atunci cand ''sel'' este 0, ''out'' va fi egal cu ''in0'', iar atunci cand ''sel'' este 1, ''out'' va fi egal cu ''in1''. Ne vom folosi de acest lucru pentru evaluarea automata.
* Consideram un fanion ''flag'', de tip ''reg'' deoarece isi va modifica valoarea intr-un bloc ''initial'', pe care il vom initializa cu 0 (prezumtia de nevinovatie –consideram initial circuitul corect). Testam conditia de corectitudine la fiecare pas de generare a semnalelor de test (la fiecare iteratie a buclei ''for'') si daca ea este indeplinita, nimic nu se intampla cu ''flag'', ramanand 0.Daca acesta conditie nu este indeplinita cel putin o data, ''flag'' se va face 1, semnalizand ca apare cel putin un caz incorect, afisandu-se totodata in consola cu ''$display'' mesajul TEST_FAIL si starea semnalelor in momentul acestuia. La iesirea din bucla testam din nou fanionul si daca acesta este 0, inseamna ca nu a aparut nici macar un caz incorect, afisand in cazul acesta mesajul TEST_PASS.
* Instantierea modulului testat se face astfel:
''.semnal_interfata_modul_testat(semnalul_la care_va_fi_conectat)''
Aceasta modalitate ne ofera controlul asupra conexiunilor, fara constrangeri de ordine.

==Exemplul 3==
'''Scop:''' Descrierea comportamentala a aceluiasi circuit cu ajutorul blocurilor assign conditionat, always + if si always + case.

'''Implementarea Verilog a circuitului'''
* ''' Folosing ''assign'' conditionat'''
<syntaxhighlight lang="Verilog">
module exemplul3(
output out,
input in0,
input in1,
input sel
);

assign out = (sel == 0) ? in0 : in1;

endmodule
</syntaxhighlight>

* ''' Folosing ''always'' si ''if'' '''

<syntaxhighlight lang="Verilog">
module exemplul3(
output out,
input in0,
input in1,
input sel
);

always@(in0 or in1 or sel) begin
if(sel == 0)
out = in0;
else
out = in1;
end

endmodule
</syntaxhighlight>

* ''' Folosing ''always'' si ''case'' '''
<syntaxhighlight lang="Verilog">
module exemplul3(
output out,
input in0,
input in1,
input sel
);

always@(*) begin
case(sel)
1'b0: out = in0;
1'b1: out = in1;
default: out = in0;
endcase
end

endmodule
</syntaxhighlight>

'''Observatii: '''
* In primul caz, ''assign'' conditionat are o sintaxa asemanatoare cu cea a limbajului C:
''(conditie) ? semnalul_cond_indeplinita : semnal_cond_neindeplinita; ''
* In cazul 2, folosind un bloc ''always'' pentru actualizarea semnalului ''out'', acesta trebuie declarat ca ''reg'' (''output reg out''). In interiorul parantezelor blocului ''always'' punem lista de semnale la care acesta va fi sensibil. Fiind un circuit combinational, ''out'' trebuie sa fie sensibil imediat la toate semnalele care il influenteaza. Putem inlocui toata aceasta lista cu *. Asta ne asigura ca nu am omis niciun semnal.
* In cazul 3, folosim * pentru lista de senzitivitati a circuitului si un bloc case. '''Atentie!''' Desi aici este clar ca am acoperit toate combinatiile posibile ale lui sel(0 si 1), pentru combinatii complexe este posibil sa omitem cazuri si astfel circuitul nostru se va transforma intr-unul de memorare. Ca sa evitam acest lucru, definim si un caz default.
* Se poate folosi modulul de test anterior pentru testare, cu observatia ca modulul instantiat se va denumii exemplul3.

<syntaxhighlight lang="Verilog">
</syntaxhighlight>

CID Aplicatii 2

2021-03-06T22:34:49Z

Sduda:

CID Aplicatii 2

2021-03-06T16:24:59Z

Sduda: Pagină nouă: Work in progress

Work in progress