Arrays e Memórias Verilog: Dominando Estruturas de Dados Multidimensionais

Uma declaração de array de uma net ou variável pode ser escalar ou vetor. Qualquer número de dimensões pode ser criado especificando um range de endereço após o nome do identificador e é chamado de array multidimensional. Arrays são permitidos em Verilog para tipos de dados reg, wire, integer e real.

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

Um índice para cada dimensão tem que ser especificado para acessar um elemento particular de um array e pode ser uma expressão de outras variáveis. Um array pode ser formado para qualquer um dos diferentes tipos de dados suportados em Verilog.

Atribuição

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

Exemplo

O código mostrado abaixo simplesmente mostra como diferentes arrays podem ser modelados, atribuídos e acessados. mem1 é um vetor de 8-bit, mem2 é um array de 8-bit com profundidade de 4 (especificado pelo range [0:3]) e mem3 é um array 2D de vetor de 16-bit com 4 linhas e 2 colunas. Estas variáveis são atribuídas valores diferentes e impressas.

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

Memórias

Memórias são elementos de armazenamento digital que ajudam a armazenar dados e informações em circuitos digitais. RAMs e ROMs são bons exemplos de tais elementos de memória. Elementos de armazenamento podem ser modelados usando arrays unidimensionais do tipo reg e é chamado de memória. Cada elemento na memória pode representar uma word e é referenciado usando um único índice de array.

Vetor de Registrador

Vetores Verilog são declarados usando um range de size no lado esquerdo do nome da variável e estes são realizados em flops que correspondem ao tamanho da variável. No código mostrado abaixo, o módulo de projeto aceita clock, reset e alguns sinais de controle para ler e escrever no bloco.

Ele contém um elemento de armazenamento de 16-bit chamado register que simplesmente é atualizado durante escritas e retorna o valor atual durante leituras. O registrador é escrito quando sel e wr estão altos na mesma borda de clock. Retorna o dado atual quando sel está alto e wr está baixo.

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

Array

Neste exemplo, register é um array que tem quatro localizações com cada uma tendo largura de 16-bits. O módulo de projeto aceita um sinal de entrada adicional chamado addr para acessar um índice particular no array.

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