Verilog Arrays und Memories: Mehrdimensionale Datenstrukturen meistern

Ein Array-Deklaration eines Nets oder Variables kann Scalar oder Vector sein. Beliebig viele Dimensionen durch Adressbereich nach dem Identifiernamen → Multi-Dimensional Arrays. Erlaubt für reg, wire, integer, real.

reg y1 [11:0];           // Scalar reg Array, Tiefe=12, je 1 Bit
wire [0:7] y2 [3:0];     // 8-Bit Vector Net, Tiefe=4
reg [7:0] y3 [0:1][0:3]; // 2D Array: 2 Zeilen, 4 Spalten, je 8 Bit

Zugriff auf Element: Index für jede Dimension angeben (kann Ausdruck sein).

Zuweisung

y1 = 0;           // Illegal: Alle Elemente auf einmal zuweisen
y2[0] = 8'ha2;    // Index 0
y2[2] = 8'h1c;    // Index 2
y3[1][2] = 8'hdd; // Zeile 1, Spalte 2
y3[0][0] = 8'haa; // Zeile 0, Spalte 0

Beispiel

Code modelliert verschiedene Arrays, weist Werte zu, gibt aus. mem1: 8-Bit-Vector. mem2: 8-Bit-Array, Tiefe 4. mem3: 16-Bit-Vector 2D-Array, 4×2.

module des ();
    reg [7:0] mem1;
    reg [7:0] mem2 [0:3];
    reg [15:0] mem3 [0:3][0:1];
    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)
            $display("mem2[%0d] = 0x%0h", i, mem2[i]);
        for(int i = 0; i < 4; i += 1)
            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
endmodule

Simulationslog:

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

Memories (Speicher)

Digitale Speicherelemente (RAM, ROM). Modellierung mit eindimensionalen Arrays vom Typ reg → Memory. Jedes Element = ein Word, Zugriff über einzelnen Array-Index.

Register Vector

Verilog Vectors (Größenbereich links vom Variablennamen) → Flops passender Größe. Beispiel: Design-Modul mit Clock, Reset, Control-Signals für Read/Write. 16-Bit Storage register. Write bei sel & wr high an Clock-Flanke. Read bei sel high, wr low.

module des (
    input clk, rstn, wr, 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

Hardware-Schema: 16-Bit-Flop aktualisiert bei Write-Control, Wert wird bei Read-Control zurückgegeben.

Array als Memory

register als Array mit 4 Locations à 16 Bit. Zusätzlicher Input addr für Index-Zugriff.

module des (
    input clk, rstn,
    input [1:0] addr,
    input wr, 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) register[i] <= 0;
        end else begin
            if (sel & wr) register[addr] <= wdata;
            else register[addr] <= register[addr];
        end
    end
    assign rdata = (sel & ~wr) ? register[addr] : 0;
endmodule

Hardware-Schema: Jeder Array-Index = 16-Bit-Flop, Input-Adresse wählt Flop-Satz aus.