Parameters em Verilog: Tornando modules configuráveis

Constantes com uma reviravolta

Um parameter é uma constante - o compilador escolhe seu valor e o assa no design antes da simulação começar. A reviravolta é que quem instancia o module pode mudar o valor. O mesmo arquivo fonte de module pode produzir circuitos de tamanhos diferentes dependendo de como chamadores o parametrizam.

É assim que você constrói IP reutilizável. Um module FIFO com parameters WIDTH e DEPTH pode servir cada equipe em uma empresa. Um contador com um parameter WIDTH é o mesmo fonte quer ele conte até 16 ou 4 bilhões.

Declaração básica de parameter

module counter #(
    parameter WIDTH = 8
)(
    input  wire             clk,
    input  wire             reset,
    output reg  [WIDTH-1:0] count
);
    always @(posedge clk) begin
        if (reset) count <= 0;
        else       count <= count + 1;
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    wire [7:0] count8;
    wire [15:0] count16;

    // WIDTH padrão = 8
    counter dut8(.clk(clk), .reset(reset), .count(count8));

    // Sobrescreve WIDTH para 16 nesta instância
    counter #(.WIDTH(16)) dut16(.clk(clk), .reset(reset), .count(count16));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        #40 $display("apos 4 clocks: count8=%0d count16=%0d", count8, count16);
        $finish;
    end
endmodule

Três pedaços de sintaxe nova:

1. Bloco de parameter: #( parameter WIDTH = 8 ) entre o nome do module e a lista de ports. O valor padrão 8 é o que o module usa quando ninguém sobrescreve.
2. Local de uso: output reg [WIDTH-1:0] count. O parameter é só uma constante - nós o plugamos no range de bits. Mesmo fonte de module produz uma saída de 8 bits ou de 16 bits dependendo de WIDTH.
3. Sintaxe de sobrescrita: counter #(.WIDTH(16)) dut16(...) no momento da instanciação. O bloco #(...) vai antes do nome da instância, depois do nome do module. Quaisquer parameters que você não mencionar mantêm seus padrões.

localparam: Constantes internas

Há constantes que você não quer que chamadores sobrescrevam. Codificações de estado são o caso clássico:

module fsm(input wire clk, input wire reset, input wire go, output reg busy);
    // Estados são um detalhe de implementação; ninguém de fora deveria se importar.
    localparam IDLE    = 2'd0;
    localparam RUNNING = 2'd1;
    localparam DONE    = 2'd2;

    reg [1:0] state;

    always @(posedge clk) begin
        if (reset) state <= IDLE;
        else begin
            case (state)
                IDLE:    if (go) state <= RUNNING;
                RUNNING: state <= DONE;
                DONE:    state <= IDLE;
            endcase
        end
    end

    always @(*) busy = (state != IDLE);
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    reg go = 0;
    wire busy;

    fsm dut(.clk(clk), .reset(reset), .go(go), .busy(busy));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        #5  go = 1;
        #10 go = 0;
        #40 $finish;
    end

    always @(posedge clk) $display("t=%0t state=%0d busy=%b", $time, dut.state, busy);
endmodule

localparam torna IDLE, RUNNING, DONE disponíveis dentro do module mas não sobrescritíveis a partir da instanciação. Essa é a escolha certa - mudar o que o valor IDLE significa de fora do module seria aterrorizante.

Use parameter para coisas que chamadores devem configurar (larguras, profundidades, opções de comportamento) e localparam para todo o resto. Um padrão comum é derivar localparams de parameters:

parameter WIDTH = 32;
localparam WIDTH_M1 = WIDTH - 1;   // calculado uma vez; não sobrescritível

Larguras parametrizadas na prática

O uso mais comum de parameters é tornar larguras de barramento flexíveis. Aqui está um somador que funciona em qualquer largura:

module adder #(
    parameter WIDTH = 8
)(
    input  wire [WIDTH-1:0] a,
    input  wire [WIDTH-1:0] b,
    output wire [WIDTH:0]   sum    // +1 para carry-out
);
    assign sum = a + b;
endmodule

module test;
    reg  [3:0]  a4, b4;
    wire [4:0]  sum4;
    reg  [15:0] a16, b16;
    wire [16:0] sum16;

    adder #(.WIDTH(4))  small(.a(a4),  .b(b4),  .sum(sum4));
    adder #(.WIDTH(16)) big  (.a(a16), .b(b16), .sum(sum16));

    initial begin
        a4  = 4'd9;       b4  = 4'd8;
        a16 = 16'd60000;  b16 = 16'd10000;
        #1;
        $display("small: %0d + %0d = %0d", a4,  b4,  sum4);
        $display("big  : %0d + %0d = %0d", a16, b16, sum16);
        $finish;
    end
endmodule

Um arquivo fonte, duas instâncias, duas larguras diferentes, sem copy-paste. Essa é a recompensa inteira dos parameters.

Múltiplos parameters, sobrescrita nomeada

Para modules maiores você frequentemente terá vários parameters. Sobrescreva-os por nome em qualquer ordem:

module fifo #(
    parameter WIDTH = 8,
    parameter DEPTH = 16,
    parameter AFULL = DEPTH - 2
)(
    input  wire             clk,
    input  wire             reset,
    // ... ports ...
);
    // ...
endmodule

// No local de chamada:
fifo #(.WIDTH(32), .DEPTH(1024)) cmd_queue (.clk(clk), .reset(reset), ...);

Você não precisa sobrescrever cada parameter; os não mencionados mantêm seus padrões. O padrão AFULL no exemplo é calculado a partir de DEPTH, o que significa que se você sobrescrever DEPTH, AFULL segue automaticamente - exatamente o tipo de dependência que localparam também lidaria se você não quisesse que chamadores conseguissem sobrescrever AFULL independentemente.

Erros comuns

Esquecer o # na sobrescrita. counter (.WIDTH(16)) dut(...) parece uma sobrescrita mas Verilog lê (.WIDTH(16)) como uma conexão de port. Você precisa de counter #(.WIDTH(16)) dut(...).

Usar parameters onde eles não são constantes o suficiente. Parameters resolvem em tempo de elaboração, antes que qualquer sinal exista. Você não pode parametrizar com base em um sinal de runtime - se o valor depende do que uma entrada está fazendo no tempo de simulação, não é um parameter, é lógica.

Confundir parameter e localparam em listas de port. Apenas parameter vai no bloco #(...) no topo. localparam vive dentro do corpo. O compilador vai te avisar se você trocar.

O que vem a seguir

Você agora consegue fazer modules cujo tamanho é definido em tempo de compilação. Os próximos dois docs cobrem as regras para escrever constantes literais (8'h1F, 4'b1010, 32'd100) e os valores x e z que aparecem quando sinais não são conduzidos ou estão em contenção. Depois disso passamos a operadores - tudo que você consegue fazer com os vetores e parameters que agora viu.