Arrays y memorias en Verilog: Dominando estructuras de datos multi-dimensionales

Una declaración de array de un net o variable puede ser escalar o vectorial. Cualquier número de dimensiones puede crearse especificando un rango de dirección tras el nombre del identificador, llamado array multi-dimensional. Arrays permitidos para reg, wire, integer y real.

reg y1 [11:0];           // array escalar reg profundidad=12, cada 1 bit
wire [0:7] y2 [3:0]      // net vector 8-bit con profundidad 4
reg [7:0] y3 [0:1][0:3]; // array 2D filas=2, cols=4, cada 8 bits

Para acceder a un elemento, hay que especificar un índice para cada dimensión, pudiendo ser expresión de otras variables.

Asignación

y1 = 0;           // Ilegal: no se puede asignar todos los elementos de golpe
y2[0] = 8'ha2;    // Asigna 0xa2 al índice 0
y2[2] = 8'h1c;    // Asigna 0x1c al índice 2
y3[1][2] = 8'hdd; // Asigna 0xdd a fila=1 col=2
y3[0][0] = 8'haa; // Asigna 0xaa a fila=0 col=0

Ejemplo

El código muestra cómo modelar, asignar y acceder a diferentes arrays. mem1 es vector 8-bit, mem2 array 8-bit profundidad 4 ([0:3]), mem3 vector 16-bit 2D con 4 filas y 2 columnas.

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) 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

Salida:

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.

Memorias

Las memorias son elementos de almacenamiento digital que guardan datos en circuitos digitales. RAMs y ROMs son ejemplos. Elementos de almacenamiento pueden modelarse con arrays unidimensionales de tipo reg y se llaman memoria. Cada elemento representa una palabra y se referencia con un índice único.

Vector de Registro (Register Vector)

Los vectores Verilog se declaran con rango de tamaño a la izquierda del nombre y se realizan en flip-flops que coinciden con el tamaño. El módulo des acepta clock, reset y señales de control para leer/escribir.

Contiene un elemento de almacenamiento de 16 bits llamado register que se actualiza en escrituras y devuelve el valor actual en lecturas. Se escribe cuando sel y wr están altos en el mismo flanco de clock. Devuelve dato actual cuando sel alto y wr bajo.

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

El esquema muestra un flop de 16 bits actualizado cuando lógica de control para escritura está activa y valor actual devuelto cuando configurado para lectura.

Array

En este ejemplo, register es un array con 4 ubicaciones de 16 bits cada una. El módulo acepta señal adicional addr para acceder a un índice particular.

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) 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

En el esquema se ve que cada índice del array es un flop de 16 bits y la dirección de entrada accede a un conjunto particular de flops.