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.
Verilog
- C#-Arrays
- Beziehung zwischen Arrays und Zeigern
- Java-Kopie-Arrays
- Arrays in C++ | Erklären | Initialisieren | Zeiger auf Array-Beispiele
- C++ Dynamische Zuordnung von Arrays mit Beispiel
- Tutorial zu Java-Arrays:Deklarieren, erstellen, initialisieren [Beispiel]
- Verilog-Tutorial
- Verilog-Verkettung
- Verilog Inter- und Intra-Auftragsverzögerung
- MATLAB - Arrays