Verilog arrays en memories: Meerdimensionale datastructuren beheersen

Een array-declaratie van een net of variabele kan scalar of vector zijn. Elk aantal dimensies kan worden aangemaakt door een adresbereik na de identifiernaam op te geven, een multi-dimensionale array. Arrays zijn toegestaan in Verilog voor reg, wire, integer en real datatypes.

reg y1 [11:0];        // y1 is scalar reg array diepte=12, elk 1-bit breed
wire [0:7] y2 [3:0];   // y2 is 8-bit vector net met diepte 4
reg [7:0] y3 [0:1][0:3]; // y3 is 2D array rijen=2, kolommen=4, elk 8-bit breed

Voor elke dimensie moet een index opgegeven worden om een specifiek element te benaderen; dit kan een expressie van andere variabelen zijn. Een array kan gevormd worden voor elk van de ondersteunde datatypes.

Let op: een memory van n 1-bit reg is niet hetzelfde als een n-bit vector reg.

Toewijzing

y1 = 0;          // Illegaal - Alle elementen kunnen niet in één keer toegewezen worden
y2[0] = 8'ha2;   // Wijs 0xa2 toe aan index=0
y2[2] = 8'h1c;   // Wijs 0x1c toe aan index=2
y3[1][2] = 8'hdd; // Wijs 0xdd toe aan rij=1 kolom=2
y3[0][0] = 8'haa; // Wijs 0xaa toe aan rij=0 kolom=0

Voorbeeld

De onderstaande code toont hoe verschillende arrays gemodelleerd, toegewezen en benaderd worden. mem1 is een 8-bit vector, mem2 een 8-bit array met diepte 4 (bereik [0:3]) en mem3 een 16-bit vector 2D array met 4 rijen en 2 kolommen. Deze variabelen krijgen verschillende waarden en worden geprint.

module des ();
reg [7:0] mem1;           // reg vector 8-bit breed
reg [7:0] mem2 [0:3];     // 8-bit vector array met diepte=4
reg [15:0] mem3 [0:3][0:1]; // 16-bit vector 2D array rijen=4, kolommen=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. 

Memories

Memories zijn digitale opslagelementen die data en informatie in digitale circuits opslaan. RAMs en ROMs zijn voorbeelden. Opslagelementen kunnen gemodelleerd worden met eendimensionale arrays van type reg en heten memory. Elk element in de memory kan een woord voorstellen en wordt gerefereerd met een enkele array-index.

Register Vector

Verilog-vectors worden gedeclareerd met een groottebereik links van de variabelenaam en worden gerealiseerd in flipflops die de grootte matchen. In de onderstaande code accepteert het ontwerpmodule klok, reset en controlesignalen om te lezen en schrijven in het blok.

Het bevat een 16-bit opslagelement genaamd register dat bij schrijfacties wordt bijgewerkt en de huidige waarde retourneert bij leesacties. Het register wordt geschreven wanneer sel en wr hoog zijn op dezelfde klokflank. Het retourneert de huidige data 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 toont een 16-bit flipflop dat wordt bijgewerd bij actieve schrijfcontrole en de huidige waarde retourneert bij leescontrole.

Array

In dit voorbeeld is register een array met vier locaties, elk 16-bits breed. Het ontwerpmodule accepteert een extra invoersignaal addr om een specifieke index in de array te benaderen.

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-bit flipflop is en het invoeradres wordt gebruikt om een specifieke set flipflops te benaderen.