CID Aplicatii 11 - Revizia istoricului

Cbira: Cbira a redenumit pagina CID Aplicatii 10 în CID Aplicatii 11 fără a lăsa o redirecționare în loc

2021-05-06T06:16:13Z

Cbira a redenumit pagina CID Aplicatii 10 în CID Aplicatii 11 fără a lăsa o redirecționare în loc

Gvpopescu: /* 2. Stiva */

2021-05-04T06:46:06Z

2. Stiva

Gvpopescu: /* 2. Stiva */

2021-05-04T06:43:33Z

2. Stiva

Gvpopescu la 29 aprilie 2021 12:19

2021-04-29T12:19:50Z

Gvpopescu: Pagină nouă: ==1. Memoria FIFO == Memoria FIFO este o structura de memorare ce respecta regula First-In First-Out. Asadar, din aceasta memorie se va citi mereu cea mai veche data scrisa. Struct...

2021-04-29T11:28:21Z

Pagină nouă: ==1. Memoria FIFO == Memoria FIFO este o structura de memorare ce respecta regula First-In First-Out. Asadar, din aceasta memorie se va citi mereu cea mai veche data scrisa. Struct...

Pagină nouă

==1. Memoria FIFO ==
Memoria FIFO este o structura de memorare ce respecta regula First-In First-Out. Asadar, din aceasta memorie se va citi mereu cea mai veche data scrisa. Structura interna a acestui circuit este prezentata in figura urmatoare.

[[Fișier:FIFO.png]]

Dupa cum se poate observa, nu mai este nevoie de magistrale de adrese pentru scriere si pentru citire. Acestea sunt calculate intern cu ajutorul unor numaratoare cu enable (WRITE_PTR si READ_PTR). Pentru usurinta intelegerii, putem privi FIFO ca o memorie circulara, cu adrese de citire si scriere ce se „urmaresc” una pe cealalta. Memoria tinde spre „umplere” prin scrieri si spre „golire” prin citiri:

[[Fișier:Buffer circular.png]]

FIFO descris mai sus are trei semnale de feedback:
* ''fifo_counter'', care ne spune cate locatii de memorie din cele totale sunt ocupate.
* ''empty'', activ atunci cand memoria este goala (0 locatii de memorie ocupate)
* ''full'', activ atunci cand toate locatiile sunt ocupate. Citirea este blocata din momentul in care ''full'' devine activ pana se elibereaza locatii prin citire.

Semnalele ''write_enable'' si ''read_enable'' care sunt transmise modulului din exterior nu pot ajunge direct la memorie deoarece trebuie impiedicate scrierile sau citirile eronate: o citire eronata apare atunci cand se incearca citirea dintr-o memorie goala, iar o scriere eronata apare atunci cand se incearca scrierea intr-o memorie complet ocupata. De aceea, semnalul real de comanda a scrierii (''wr_en_mem'') este activ doar daca se declanseaza o scriere si memoria nu este plina, iar semnalul real de citire (''rd_en_mem'') este activ doar daca se declanseaza o citire dintr-o memorie care nu este goala.

Principalele blocuri ale memoriei FIFO sunt:
* '''RAMDP''': memorie dual-port, cu citire sincrona. Acesta este elementul de memorare efectiva.
* '''WRITE_PTR''': numarator ce incrementeaza adresa de scriere, daca apare o scriere valida (''wr_en_mem'' este 1).
* '''READ_PTR''': numarator ce incrementeaza adresa de citire, daca apare o citire valida (''rd_en_mem'' este 1).
* '''FIFO_COUNTER''': numarator ce contorizeaza locatiile ocupate: se incrementeaza daca are loc o scriere fara citire (''wr_en_mem'' este 1 si ''rd_en_mem'' este 0) si se decrementeaza daca are loc o citire fara scriere (''rd_en_mem'' este 1 si ''wr_en_mem'' este 0).
* '''CONTROL''': modul combinational care genereaza semnalele de control: ''empty'', ''full'', ''wr_en_mem'' si ''rd_en_mem'', cu functionalitatile descrise anterior.

'''Implementarea memoriei RAMDP'''
<syntaxhighlight lang="Verilog">
module RAMDP
#( parameter DATA_W = 8, ADDR_W = 5)
(
input clock,
input read_enable,
input write_enable,
input [ADDR_W-1:0] addr_read,
input [ADDR_W-1:0] addr_write,
input [DATA_W-1:0] data_in,
output reg [DATA_W-1:0] data_out
);

reg [DATA_W-1:0] memory [0:2**ADDR_W-1];

always@(posedge clock) begin
if(write_enable)
memory[addr_write] <= data_in;
if(read_enable)
data_out <= memory[addr_read];
end

endmodule
</syntaxhighlight>

'''Implementarea memoriei FIFO'''
<syntaxhighlight lang="Verilog">
module FIFO
#( parameter DATA_W = 8, ADDR_W = 5)
(
input clock, reset, // semnal de ceas si reset
input write_enable, // comanda de scriere
input read_enable, // comanda de citire
input [DATA_W-1 : 0] data_in, // date de intrare
output [DATA_W-1 : 0] data_out, // date de iesire
output empty, // semnal activ cand memoria este goala
output full, // semnal activ cand memoria este plina
output reg [ADDR_W:0] fifo_counter //nr locatii folosite
);
wire rd_en_mem, wr_en_mem;
reg [ADDR_W-1:0] write_ptr_reg, read_ptr_reg;

//WRITE POINTER
always@(posedge clock) begin
if(reset == 0)
write_ptr_reg <= 0;
else if (wr_en_mem == 1)
write_ptr_reg <= write_ptr_reg + 1;
end

//READ POINTER
always@(posedge clock) begin
if(reset == 0)
read_ptr_reg <= 0;
else if (rd_en_mem == 1)
read_ptr_reg <= read_ptr_reg + 1;
end

//FIFO COUNTER
always@(posedge clock) begin
if(reset == 0)
fifo_counter <= 0;
else if (rd_en_mem && !wr_en_mem)
fifo_counter <= fifo_counter - 1;
else if (!rd_en_mem && wr_en_mem)
fifo_counter <= fifo_counter + 1;
end

//READ_ENABLE AND WRITE_ENABLE
assign wr_en_mem = write_enable & ~full;
assign rd_en_mem = read_enable & ~empty;

//FULL AND EMPTY
assign full = (fifo_counter == 2**ADDR_W);
assign empty = (fifo_counter == 0);

RAMDP #(.DATA_W(DATA_W), .ADDR_W(ADDR_W)) MEM(
.clock(clock),
.read_enable(rd_en_mem),
.write_enable(wr_en_mem),
.addr_read(read_ptr_reg),
.addr_write(write_ptr_reg),
.data_in(data_in),
.data_out(data_out)
);

endmodule
</syntaxhighlight>

'''Implementarea unui test bench pentru memoria FIFO'''
<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps

module FIFO_TB;

parameter DATA_W_T = 8;
parameter ADDR_W_T = 5;

reg clock_t, reset_t;
reg write_enable_t, read_enable_t;
reg [DATA_W_T-1 : 0] data_in_t;
wire [DATA_W_T-1 : 0] data_out_t;
wire empty_t, full_t;
wire [ADDR_W_T:0] fifo_counter_t;

integer i;
integer j;

initial begin
reset_t = 0;
#2 reset_t = 1;
read_enable_t = 0;
for(j = 0; j<= 2**ADDR_W_T; j = j + 1) begin //umplem complet FIFO. La final, semnalul full va deveni HIGH
#2;
data_in_t = j;
write_enable_t = 1;
end
#2 read_enable_t = 1;
write_enable_t = 0; //pornim citirea pana cand FIFO se va goli complet, iar semnalul empty va deveni HIGH
#80 $stop();

end

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

FIFO #(.DATA_W(DATA_W_T), .ADDR_W(ADDR_W_T)) DUT(
.clock(clock_t),
.reset(reset_t),
.write_enable(write_enable_t),
.read_enable(read_enable_t),
.data_in(data_in_t),
.data_out(data_out_t),
.empty(empty_t),
.full(full_t),
.fifo_counter(fifo_counter_t)

);

endmodule
</syntaxhighlight>

==2. Module descrise recursiv ==

@@ Linia 170: / Linia 170: @@
 ==2. Stiva ==
 Stiva este o structura de memorie care se supune regulii LIFO (Last-In First-Out). Asadar, data citita din stiva va fi ultima data introdusa.
 Introducerea elementelor in stiva se face prin operatia '''push''', iar extragerea lor prin '''pop'''. Asadar, vom avea doua semnale care vor comanda scrierea, respectiv citirea: ''push'' si ''pop''. Considerand structura stivei, cele doua operatii nu vor avea loc in acelasi timp, spre deosebire de FIFO. Umplerea si golirea completa a stivei vor fi semnalizate cu ajutorul semnalelor ''full'', respectiv ''empty''.

← Versiunea anterioară		Versiunea de la data 4 mai 2021 06:43
Linia 169:		Linia 169:

	==2. Stiva ==		==2. Stiva ==
		+	Stiva este o structura de memorie care se supune regulii LIFO (Last-In First-Out). Asadar, data citita din stiva va fi ultima data introdusa.
		+
		+	Introducerea elementelor in stiva se face prin operatia '''push''', iar extragerea lor prin '''pop'''. Asadar, vom avea doua semnale care vor comanda scrierea, respectiv citirea: ''push'' si ''pop''. Considerand structura stivei, cele doua operatii nu vor avea loc in acelasi timp, spre deosebire de FIFO. Umplerea si golirea completa a stivei vor fi semnalizate cu ajutorul semnalelor ''full'', respectiv ''empty''.
		+
		+	Deoarece scrierea si citirea sunt ambele legate de varful stivei, este nevoie de o singura adresa pentru acestea: adresa varfului stivei (''ptr_reg''). Aceasta se va incrementa atunci cand un element va fi introdus in varful stivei si se va descrementa atunci cand un element va fi extras din stiva. Atat scrierea cat si citirea sunt sincrone si au loc atunci cand se comanda o operatie de push si stiva nu este plina, respectiv atunci cand se comanda o operatie de pop si stiva nu este goala.

← Versiunea anterioară	Versiunea de la data 6 mai 2021 06:16
(Nicio diferență)

← Versiunea anterioară		Versiunea de la data 29 aprilie 2021 12:19
Linia 168:		Linia 168:
	</syntaxhighlight>		</syntaxhighlight>

−	==2. ~~Module descrise recursiv~~ ==	+	==2. Stiva ==
		+
		+
		+	'''Implementarea modulului Stack'''
		+	<syntaxhighlight lang="Verilog">
		+	module STACK
		+	#( parameter DATA_W = 8, ADDR_W = 5)
		+	(
		+	input clock, reset, // semnal de ceas si reset
		+	input push, // comanda de scriere
		+	input pop, // comanda de citire
		+	input [DATA_W-1 : 0] data_in, // date de intrare
		+	output reg [DATA_W-1 : 0] data_out, // date de iesire
		+	output empty, // semnal activ cand memoria este goala
		+	output full // semnal activ cand memoria este plina
		+	);
		+
		+	wire rd_en_mem, wr_en_mem;
		+	reg [ADDR_W:0] ptr_reg;
		+
		+	reg [DATA_W-1:0] stack [0:2**ADDR_W - 1];
		+
		+	//WRITE POINTER
		+	always@(posedge clock) begin
		+	if(reset == 0)
		+	ptr_reg <= 0;
		+	else if (wr_en_mem == 1)
		+	ptr_reg <= ptr_reg + 1;
		+	else if (rd_en_mem == 1)
		+	ptr_reg <= ptr_reg - 1;
		+	end
		+
		+	//READ_ENABLE AND WRITE_ENABLE
		+	assign wr_en_mem = push & ~full;
		+	assign rd_en_mem = pop & ~empty;
		+
		+	//FULL AND EMPTY
		+	assign full = (ptr_reg == 2**ADDR_W);
		+	assign empty = (ptr_reg == 0);
		+
		+	always@(posedge clock) begin
		+	if (wr_en_mem == 1)
		+	stack[ptr_reg] <= data_in;
		+	if (rd_en_mem == 1)
		+	data_out <= stack[ptr_reg-1];
		+	end
		+
		+	endmodule
		+	</syntaxhighlight>
		+
		+	'''Implementarea unui test bench pentru modulul Stack'''
		+	<syntaxhighlight lang="Verilog">
		+	`timescale 1ns/1ps
		+
		+	module STACK_TB;
		+
		+	parameter DATA_W_T = 8;
		+	parameter ADDR_W_T = 5;
		+
		+	reg clock_t, reset_t;
		+	reg push_t, pop_t;
		+	reg [DATA_W_T-1 : 0] data_in_t;
		+	wire [DATA_W_T-1 : 0] data_out_t;
		+	wire empty_t, full_t;
		+
		+	integer i;
		+	integer j;
		+
		+	initial begin
		+	reset_t = 0;
		+	push_t = 0;
		+	pop_t = 0;
		+	#2;
		+	//umplerea completa a stivei
		+	reset_t = 1;
		+	push_t = 1;
		+	for(j = 0; j<= 2**ADDR_W_T; j = j + 1) begin
		+	data_in_t = j;
		+	#2;
		+	end
		+	//golirea completa a stivei
		+	push_t = 0;
		+	pop_t = 1;
		+	#80;
		+	//intraoducerea a 5 elemente in stiva
		+	push_t = 1;
		+	pop_t = 0;
		+	for(j = 0; j<= 4; j = j + 1) begin
		+	data_in_t = j*2;
		+	#2;
		+	end
		+	//extragerea celor 5 elemente din stiva
		+	push_t = 0;
		+	pop_t = 1;
		+	#80;
		+	$stop();
		+	end
		+
		+	initial begin
		+	clock_t = 0;
		+	forever #1 clock_t = ~clock_t;
		+	end
		+
		+	STACK #(.DATA_W(DATA_W_T), .ADDR_W(ADDR_W_T)) DUT(
		+	.clock(clock_t),
		+	.reset(reset_t),
		+	.push(push_t),
		+	.pop(pop_t),
		+	.data_in(data_in_t),
		+	.data_out(data_out_t),
		+	.empty(empty_t),
		+	.full(full_t)
		+	);
		+
		+	endmodule
		+	</syntaxhighlight>