Vetores e Arrays em Verilog: Sinais multi-bit explicados

Um wire vs muitos

Até agora todo sinal que vimos teve um bit de largura. Designs reais quase nunca ficam assim - endereços têm 16 ou 32 bits, barramentos de dados têm 8 ou 64, pixels RGB têm 24. Verilog te dá um único mecanismo para tornar qualquer sinal multi-bit: adicione um range entre colchetes.

wire [7:0] data;       // wire de 8 bits, bit 7 é MSB, bit 0 é LSB
reg  [15:0] address;   // reg de 16 bits
output reg [31:0] result; // saída de module de 32 bits

Os números entre os colchetes são as posições de bit dos bits mais e menos significativos. [7:0] significa "este sinal tem bits numerados de 7 até 0", o que dá 8 bits no total. O primeiro número é o índice alto. O segundo é o baixo.

Você ocasionalmente verá [0:7] - mesmo número de bits, endianness oposto para fins de fatia. A forma [high:low] é a convenção esmagadora da indústria; fique com ela a menos que tenha uma razão forte para não ficar.

Um exemplo: somador de 8 bits

module adder8(
    input  wire [7:0] a,
    input  wire [7:0] b,
    output wire [8:0] sum
);
    // 8 bits + 8 bits pode produzir um resultado de 9 bits (um carry out).
    assign sum = a + b;
endmodule

module test;
    reg  [7:0] a, b;
    wire [8:0] sum;

    adder8 dut(.a(a), .b(b), .sum(sum));

    initial begin
        a = 8'd10;  b = 8'd20;   #1 $display("%0d + %0d = %0d", a, b, sum);
        a = 8'd200; b = 8'd100;  #1 $display("%0d + %0d = %0d", a, b, sum);
        a = 8'hFF;  b = 8'h01;   #1 $display("%h + %h = %h",   a, b, sum);
        $finish;
    end
endmodule

Cada + soma os dois vetores de 8 bits e produz um resultado de 9 bits. Literais numéricos como 8'd10 dizem "um valor decimal 10 com largura de 8 bits" - cobriremos isso em Number Literals.

Fatias: Pegando bits

Uma vez que você tem um vetor, pode tirar bits individuais ou ranges contíguos:

module slicing(input wire [15:0] data);
    initial begin
        $display("full data   = %b", data);
        $display("low byte    = %b", data[7:0]);
        $display("high byte   = %b", data[15:8]);
        $display("nibble[3:1] = %b", data[3:1]);
        $display("bit 9       = %b", data[9]);
    end
endmodule

module test;
    initial begin
        force test.dut.data = 16'b1010_1100_0011_0101;
        #1 $finish;
    end

    slicing dut();
endmodule

Não se prenda à linha force do testbench - só precisamos de uma forma de injetar um valor para demonstrar fatias. O interessante são as fatias em si.

Algumas regras:

• A direção da fatia precisa bater com a declaração. Se você declarou [7:0], fatie com [high:low]. Reverter a direção é um erro de sintaxe.
• Fatiar fora do range produz x (desconhecido) na simulação. A ferramenta de síntese pode avisar ou dar erro.
• Seleção de bit é baseada em zero no índice que você escreveu - data[0] é o bit chamado 0, que (para uma declaração [7:0]) é o LSB.

Fatias de base variável: +: e -:

Uma necessidade comum: "me dê 8 bits começando do bit N". Você não pode escrever data[N+7:N] diretamente porque o Verilog exige que ambos os lados do range sejam constantes. A sintaxe que resolve isso:

data[base +: width]   // width bits começando em `base`, subindo
data[base -: width]   // width bits começando em `base`, descendo

module variable_slice;
    reg [31:0] word = 32'hDEAD_BEEF;

    initial begin
        for (integer i = 0; i < 4; i = i + 1) begin
            $display("byte %0d = %h", i, word[i*8 +: 8]);
        end
        $finish;
    end
endmodule

A largura é constante (estamos pegando 8 bits por vez), mas a base pode ser uma expressão de runtime. É exatamente o que você precisa para memórias endereçáveis por byte, taps de shift register, e por aí vai.

Arrays: Um passo além dos vetores

Um vetor é um único sinal multi-bit. Um array é uma coleção de vetores, indexados independentemente:

reg [31:0] mem [0:1023];

Essa declaração tem dois ranges, e os dois ranges significam coisas diferentes:

• [31:0] é a dimensão packed - a largura de cada palavra individual.
• [0:1023] é a dimensão unpacked - quantas palavras existem.

Então mem é 1024 registers separados de 32 bits. Você acessa um com um único índice:

mem[5] = 32'hCAFE_BABE;       // escreve a palavra 5
data   = mem[address];        // lê a palavra em `address`

module memory_demo;
    reg [7:0] mem [0:7];   // 8 bytes
    integer i;

    initial begin
        for (i = 0; i < 8; i = i + 1) mem[i] = i * i;

        for (i = 0; i < 8; i = i + 1)
            $display("mem[%0d] = %0d", i, mem[i]);

        $finish;
    end
endmodule

Essa é uma memória minúscula segurando quadrados. Designs reais usam o mesmo padrão para segurar register files, lookup tables, FIFOs e qualquer outro armazenamento on-chip maior que um único vetor.

Packed vs Unpacked: Por que importa

A divisão entre dimensões packed e unpacked aparece em todos os lugares. Saber qual é qual economiza muito debug:

• Um vetor packed é um sinal. Você pode tratar o todo como um número: data + 1 funciona, data == 32'h0 funciona, data[7:0] funciona.
• Um array unpacked é muitos sinais. Você não pode tratar o todo como um número: mem + 1 é um erro de sintaxe. Você tem que escolher uma palavra específica primeiro.

Múltiplas dimensões packed também são legais:

reg [3:0][7:0] regs;   // 4 bytes empacotados juntos em um sinal de 32 bits

regs[0] é um byte (o byte baixo). regs como um todo tem 32 bits. SystemVerilog usa isso intensamente.

Múltiplas dimensões unpacked criam uma memória 2D:

reg [31:0] frame [0:479][0:639];  // 480x640 de pixels de 32 bits

Você acessa um único pixel com frame[y][x]. É assim que um buffer de imagem ficaria em HDL.

O que vem a seguir

Você agora consegue declarar e manipular qualquer sinal de qualquer largura que precisar. O próximo doc - Parameters - mostra como tornar essas larguras configuráveis para que o mesmo module funcione com 8 bits em uma instância e 32 em outra. Depois vamos para as regras para escrever números literais (8'b1010_1100, 32'hDEAD_BEEF) e os valores x/z que aparecem sempre que algo não é conduzido.