Verilog-arrays en herinneringen

Een array declaratie van een net of variabele kan zowel scalair als vector zijn. Een willekeurig aantal dimensies kan worden gemaakt door een adresbereik op te geven achter de ID-naam en wordt een multidimensionale array genoemd. Arrays zijn toegestaan ​​in Verilog voor reg , wire , integer en real gegevens typen.

  
  
	reg        y1 [11:0];        // y is an scalar reg array of depth=12, each 1-bit wide
	wire [0:7] y2 [3:0]          // y is an 8-bit vector net with a depth of 4
	reg  [7:0] y3 [0:1][0:3];    // y is a 2D array rows=2,cols=4 each 8-bit wide

  

Een index voor elke dimensie moet worden gespecificeerd om toegang te krijgen tot een bepaald element van een array en kan een uitdrukking zijn van andere variabelen. Er kan een array worden gevormd voor elk van de verschillende gegevenstypen die in Verilog worden ondersteund.

Merk op dat een geheugen van n 1-bit reg niet hetzelfde is als een n-bit vector reg.

Opdracht

  
  
	y1 = 0; 						// Illegal - All elements can't be assigned in a single go
	
	y2[0] = 8'ha2; 			// Assign 0xa2 to index=0 
	y2[2] = 8'h1c; 			// Assign 0x1c to index=2
	y3[1][2] = 8'hdd; 	// Assign 0xdd to rows=1 cols=2
	y3[0][0] = 8'haa; 	// Assign 0xaa to rows=0 cols=0

  

Voorbeeld

De onderstaande code laat eenvoudig zien hoe verschillende arrays kunnen worden gemodelleerd, toegewezen en benaderd. mem1 is een 8-bit vector, mem2 is een 8-bit array met een diepte van 4 (gespecificeerd door het bereik [0:3]) en mem3 is een 16-bit vector 2D array met 4 rijen en 2 kolommen. Aan deze variabelen worden verschillende waarden toegewezen en afgedrukt.

  
  
module des ();
  reg [7:0]  mem1; 							// reg vector 8-bit wide
  reg [7:0]  mem2 [0:3]; 				// 8-bit wide vector array with depth=4
  reg [15:0] mem3 [0:3][0:1]; 	// 16-bit wide vector 2D array with rows=4,cols=2
  
  initial begin
    int i;
    
    mem1 = 8'ha9;
    $display ("mem1 = 0x%0h", mem1);
    
    mem2[0] = 8'haa;
    mem2[1] = 8'hbb;
    mem2[2] = 8'hcc;
    mem2[3] = 8'hdd;
    for(i = 0; i < 4; i = i+1) begin
      $display("mem2[%0d] = 0x%0h", i, mem2[i]);
    end
    
    for(int i = 0; i < 4; i += 1) begin
      for(int j = 0; j < 2; j += 1) begin
        mem3[i][j] = i + j;
        $display("mem3[%0d][%0d] = 0x%0h", i, j, mem3[i][j]);
      end
    end
  end
endmodule

  

ncsim> run
mem1 = 0xa9
mem2[0] = 0xaa
mem2[1] = 0xbb
mem2[2] = 0xcc
mem2[3] = 0xdd
mem3[0][0] = 0x0
mem3[0][1] = 0x1
mem3[1][0] = 0x1
mem3[1][1] = 0x2
mem3[2][0] = 0x2
mem3[2][1] = 0x3
mem3[3][0] = 0x3
mem3[3][1] = 0x4
ncsim: *W,RNQUIE: Simulation is complete.

Herinneringen

Herinneringen zijn digitale opslagelementen die helpen bij het opslaan van gegevens en informatie in digitale circuits. RAM's en ROM's zijn goede voorbeelden van dergelijke geheugenelementen. Opslagelementen kunnen worden gemodelleerd met behulp van eendimensionale arrays van het type reg en heet een geheugen . Elk element in het geheugen kan een woord vertegenwoordigen en er wordt naar verwezen met behulp van een enkele array-index.

Registreer vector

Verilog-vectoren worden gedeclareerd met behulp van een groottebereik aan de linkerkant van de variabelenaam en deze worden gerealiseerd in flops die overeenkomen met de grootte van de variabele. In de onderstaande code accepteert de ontwerpmodule klok-, reset- en enkele besturingssignalen om in het blok te lezen en te schrijven.

Het bevat een 16-bits opslagelement genaamd register dat eenvoudig wordt bijgewerkt tijdens het schrijven en de huidige waarde retourneert tijdens het lezen. Het register wordt geschreven wanneer sel en wr hoog op dezelfde klokflank staan. Het geeft de huidige gegevens terug wanneer sel hoog is en wr laag.

  
  
module des (    input           clk,
                input           rstn,
                input           wr,
                input           sel,
                input [15:0]    wdata,
                output [15:0]   rdata);

	reg [15:0] register;

	always @ (posedge clk) begin
    if (!rstn)
    	register <= 0;
    else begin
    	if (sel & wr) 
      	register <= wdata;
    	else
      	register <= register;
    end
	end

	assign rdata = (sel & ~wr) ? register : 0;
endmodule

  

Het hardwareschema laat zien dat een 16-bits flop wordt bijgewerkt wanneer besturingslogica voor schrijven actief is en dat de huidige waarde wordt geretourneerd wanneer besturingslogica is geconfigureerd voor lezen.

Array

In dit voorbeeld is register een array met vier locaties met elk een breedte van 16 bits. De ontwerpmodule accepteert een extra ingangssignaal dat addr wordt genoemd om toegang te krijgen tot een bepaalde index in de array.

  
  
module des (    input           clk,
                input           rstn,
                input  [1:0]    addr,
                input           wr,
                input           sel,
                input [15:0]    wdata,
                output [15:0]   rdata);

reg [15:0] register [0:3];
integer i;

always @ (posedge clk) begin
    if (!rstn) begin
        for (i = 0; i < 4; i = i+1) begin 
            register[i] <= 0;
        end
    end else begin
        if (sel & wr) 
            register[addr] <= wdata;
        else
            register[addr] <= register[addr];
    end
end
 
assign rdata = (sel & ~wr) ? register[addr] : 0;
endmodule

  

In het hardwareschema is te zien dat elke index van de array een 16-bits flop is en dat het invoeradres wordt gebruikt om toegang te krijgen tot een bepaalde set flops.