Scopul lucrarii:

Creare unei stive folosind limbajul de descriere Verilog.Testare modulului nou creat.

Implimentarea solutiei in cod Verilog:

module STACK(DATAIO, PUSH ,POP, Reset , empty , full , eror , SP,ck);
// definirea parametrilor
parameter w_size = 32; //lungimea cuvintului
parameter m_size = 1024;//marimea memoriei
parameter adr_size = 10; //lunginea adresei

//declararea intrarilor si esirilor

inout [w_size-1:0]DATAIO;
input PUSH,POP,Reset,ck;

output empty,full,eror;
output [adr_size-1:0]SP;
//formam registrii
reg [w_size-1: 0]RegD;
reg [adr_size-1:0]SP;
reg empty,full,eror;
reg [w_size-1:0] Stack [m_size-1:0];
wire [w_size-1:0]#(10)DATAIO = RegD;

//initializarea
initial
begin
RegD =32'bz;//la intrare punem valoarea de hiZ,pentru a u avea scurtcircuit
SP = 0; //Stak pointerul in initializam la zero
empty = 1; //spunem ca e goala mem

end
//circiutul ese esnsibil pe frontul pozitiv a semnalelor din lista de lensivitati
always@( posedge ck)
begin
if(PUSH == 1) //in cazul daca comandam sa se inregistreze datele
begin
if(empty==1)//daca este pe poz 1
begin
Stack[SP] <= DATAIO;//se inscriu datele in stak
empty <= 0; //nu mai e goala memoria
if(eror==1) //daca avem eroare
eror<=0; //o aminam
end

else
if(full==1) //daca am ajuns pe ultima pozitie a memoriei
begin

Stack[SP] = DATAIO;//pastram informatia

eror <=1; //si avertizam ca avem eroare
end

else
//in alt caz,executam inscrierea inctimantind sp
begin
SP <= SP+1;
RegD <= 32'bz;

Stack[SP] <= DATAIO;

// Daca am ajuns la valoarea maximal a SP
if(SP == 10'b1)
full<=1;//anuntam de aceasta la iesire
end
end
 //daca citim datele(scoatem) din stack
if(POP == 1)
begin
if((SP==10'b0)&&(empty !=1 ))//controlam sa nu avem inceput de memorie si SP sa
nu fie pe prima pozitie
begin
RegD <=Stack[SP]; //in registuru ce permite transportul valorii la iesire
incarcam data
empty <=1;

end
else
if (empty==1) //daca ii inceput de memorie
begin
RegD <=Stack[SP]; //transmitem la iesire informatia
eror <=1; //si anuntam ca avem eroare
end
else //in alt caz
begin
RegD <= Stack[SP]; // transferam la iesite datele
if(SP!=10'b0) //controlam daca nu e pe val “o”SP
SP <= SP-1;//daca nu trecem la valoarea precedenta
if(eror==1) //resetam eroarea
eror =0;
if(full==1)//resetam supraincaracarea
full =0;
end
end
//segventa de cod ce descrie comportamentului resetului
if(Reset == 1)//daca avem reset se reseteaza tore valorile iesirilor si a
intrarilor
begin
RegD <= 32'bz;
SP <=10'b0;
full <=0;
empty <=1;
eror <=0;
end
end
endmodule

Codul de testare a modulului sus prezentat:

module Stack_TB;
parameter w_size = 32;
parameter m_size = 1024;
parameter addr_size = 10;

reg [w_size-1:0]RegD;
reg PUSH,POP,Reset,ck;
wire empty,full,eror;
wire [addr_size-1:0]SP;
reg [m_size - 1:0]i;
wire [w_size-1:0]#(0)DATAIO = RegD;

STACK Q0(DATAIO,PUSH,POP,Reset,empty,full,eror,SP,ck);

initial
begin
#1 Reset = 1;
#1 ck = 0;
#1 ck = 1;
#1RegD=32'bz;
#1Reset = 0;
RegD = 32'b0;

for (i=0;i<10;i=i+1)
begin
 #1 PUSH = 1;
#1 ck = 0;
#1 ck = 1;
#1 PUSH = 0;
RegD = RegD+1;
end
#1 RegD = 32'bz;

for(i=0;i < 10 ;i=i+1)

begin
#1 POP = 1;
#1 ck = 0;
#1 ck = 1;
#1 POP = 0;
RegD=32'bz;
end
end
initial
begin
$monitor("push = " ,PUSH," pop = ",POP," reset = ",Reset,"dataio = ",DATAIO,"regd =
",RegD," SP = ",SP);
end

initial
begin
#100 $stop;
end
endmodule
Rezultatele vizualizate in ModelSim:

Concluzii:

La această lucrare de laborator am screa stack de capacitate de 1k de celule a cite 32 biți

capacitata. Memoria Stack este o memorie de tip LIFO pentru manipularea cu ea avem comenzi
de gestionare a datelor, Pop, Push, Reset.