Verilog-Arrays und -Erinnerungen

Ein Array Die Deklaration eines Netzes oder einer Variablen kann entweder skalar oder vektoriell sein. Eine beliebige Anzahl von Dimensionen kann durch Angabe eines Adressbereichs nach dem Bezeichnernamen erstellt werden und wird als mehrdimensionales Array bezeichnet. Arrays sind in Verilog für reg erlaubt , wire , integer und real Datentypen.

  
  
	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

  

Für den Zugriff auf ein bestimmtes Element eines Arrays muss für jede Dimension ein Index angegeben werden, der ein Ausdruck anderer Variablen sein kann. Ein Array kann für jeden der verschiedenen Datentypen gebildet werden, die in Verilog unterstützt werden.

Beachten Sie, dass ein Speicher von n 1-Bit-Registern nicht dasselbe ist wie ein n-Bit-Vektorregister.

Zuweisung

  
  
	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

  

Beispiel

Der unten gezeigte Code zeigt einfach, wie verschiedene Arrays modelliert, zugewiesen und aufgerufen werden können. mem1 ist ein 8-Bit-Vektor, mem2 ist ein 8-Bit-Array mit einer Tiefe von 4 (angegeben durch den Bereich [0:3]) und mem3 ist ein 16-Bit-Vektor-2D-Array mit 4 Zeilen und 2 Spalten. Diesen Variablen werden unterschiedliche Werte zugewiesen und gedruckt.

  
  
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

  

Simulationsprotokoll

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.

Erinnerungen

Speicher sind digitale Speicherelemente, die dabei helfen, Daten und Informationen in digitalen Schaltungen zu speichern. RAMs und ROMs sind gute Beispiele für solche Speicherelemente. Speicherelemente können mit eindimensionalen Arrays vom Typ reg modelliert werden und wird als Speicher bezeichnet . Jedes Element im Speicher kann ein Wort darstellen und wird über einen einzelnen Array-Index referenziert.

Vektor registrieren

Verilog-Vektoren werden mit einem Größenbereich auf der linken Seite des Variablennamens deklariert und diese werden in Flops umgesetzt, die der Größe der Variablen entsprechen. Im unten gezeigten Code akzeptiert das Designmodul Takt-, Reset- und einige Steuersignale zum Lesen und Schreiben in den Block.

Es enthält ein 16-Bit-Speicherelement namens Register, das beim Schreiben einfach aktualisiert wird und beim Lesen den aktuellen Wert zurückgibt. Das Register wird geschrieben, wenn sel und wr auf derselben Taktflanke hoch sind. Es gibt die aktuellen Daten zurück, wenn sel hoch und wr niedrig ist.

  
  
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

  

Das Hardwareschema zeigt, dass ein 16-Bit-Flop aktualisiert wird, wenn die Steuerlogik für Schreibvorgänge aktiv ist, und der aktuelle Wert zurückgegeben wird, wenn die Steuerlogik für Lesevorgänge konfiguriert ist.

Array

In diesem Beispiel ist Register ein Array mit vier Stellen, von denen jede eine Breite von 16 Bit hat. Das Designmodul akzeptiert ein zusätzliches Eingangssignal namens addr, um auf einen bestimmten Index im Array zuzugreifen.

  
  
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

  

Aus dem Hardware-Schema ist ersichtlich, dass jeder Index des Arrays ein 16-Bit-Flop ist und die Eingangsadresse verwendet wird, um auf einen bestimmten Satz von Flops zuzugreifen.