Parámetros en Verilog: haciendo los módulos configurables

Constantes con un giro

Un parameter es una constante - el compilador elige su valor y lo hornea en el diseño antes de que empiece la simulación. El giro es que quien instancia el módulo puede cambiar el valor. El mismo archivo fuente del módulo puede producir circuitos de distintos tamaños dependiendo de cómo lo parametricen los que lo llaman.

Así es como construyes IP reutilizable. Un módulo FIFO con parámetros WIDTH y DEPTH puede servir a cada equipo en una empresa. Un contador con un parámetro WIDTH es el mismo código fuente tanto si cuenta hasta 16 como hasta 4 mil millones.

Declaración básica de parámetros

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;

    // Default WIDTH = 8
    counter dut8(.clk(clk), .reset(reset), .count(count8));

    // Override WIDTH to 16 for this instance
    counter #(.WIDTH(16)) dut16(.clk(clk), .reset(reset), .count(count16));

    always #5 clk = ~clk;

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

Tres piezas de sintaxis nuevas:

1. Bloque de parámetros: #( parameter WIDTH = 8 ) entre el nombre del módulo y la lista de puertos. El valor por defecto 8 es lo que el módulo usa cuando nadie sobrescribe.
2. Sitio de uso: output reg [WIDTH-1:0] count. El parámetro es solo una constante - lo metemos en el rango de bits. El mismo código fuente del módulo produce una salida de 8 bits o 16 bits dependiendo de WIDTH.
3. Sintaxis de override: counter #(.WIDTH(16)) dut16(...) en tiempo de instanciación. El bloque #(...) va antes del nombre de la instancia, después del nombre del módulo. Los parámetros que no mencionas mantienen sus valores por defecto.

localparam: constantes internas

Hay constantes que no quieres que los que llaman sobrescriban. Las codificaciones de estado son el caso clásico:

module fsm(input wire clk, input wire reset, input wire go, output reg busy);
    // States are an implementation detail; nobody outside should care.
    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 hace IDLE, RUNNING, DONE disponibles dentro del módulo pero no sobrescribibles desde la instanciación. Esa es la elección correcta - cambiar qué valor de estado significa IDLE desde fuera del módulo sería aterrador.

Usa parameter para cosas que los que llaman deberían configurar (anchos, profundidades, opciones de comportamiento) y localparam para todo lo demás. Un patrón común es derivar localparams a partir de parameters:

parameter WIDTH = 32;
localparam WIDTH_M1 = WIDTH - 1;   // computed once; not overrideable

Anchos parametrizados en la práctica

El uso más común de los parámetros es hacer que los anchos de bus sean flexibles. Aquí hay un sumador que funciona con cualquier ancho:

module adder #(
    parameter WIDTH = 8
)(
    input  wire [WIDTH-1:0] a,
    input  wire [WIDTH-1:0] b,
    output wire [WIDTH:0]   sum    // +1 for 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

Un archivo fuente, dos instancias, dos anchos distintos, sin copiar y pegar. Ese es todo el beneficio de los parámetros.

Varios parámetros, override por nombre

Para módulos más grandes a menudo tendrás varios parámetros. Sobrescríbelos por nombre en cualquier orden:

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

// At the call site:
fifo #(.WIDTH(32), .DEPTH(1024)) cmd_queue (.clk(clk), .reset(reset), ...);

No tienes que sobrescribir cada parámetro; los no mencionados mantienen sus valores por defecto. El valor por defecto de AFULL en el ejemplo se calcula a partir de DEPTH, lo que significa que si sobrescribes DEPTH, AFULL lo sigue automáticamente - exactamente el tipo de dependencia que localparam también manejaría si no quisieras que los que llaman pudieran sobrescribir AFULL de forma independiente.

Errores comunes

Olvidar el # en el override. counter (.WIDTH(16)) dut(...) parece un override pero Verilog lee (.WIDTH(16)) como una conexión de puerto. Necesitas counter #(.WIDTH(16)) dut(...).

Usar parámetros donde no son lo bastante constantes. Los parámetros se resuelven en tiempo de elaboración, antes de que existan las señales. No puedes parametrizar con una señal de runtime - si el valor depende de lo que una entrada está haciendo en tiempo de simulación, no es un parámetro, es lógica.

Confundir parameter y localparam en las listas de puertos. Solo parameter va en el bloque #(...) de arriba. localparam vive dentro del cuerpo. El compilador te lo dirá si los intercambias.

Qué viene a continuación

Ya puedes hacer módulos cuyo tamaño se establece en tiempo de compilación. Los dos siguientes docs cubren las reglas para escribir constantes literales (8'h1F, 4'b1010, 32'd100) y los valores x y z que aparecen cuando las señales están sin excitar o en contención. Después de eso pasamos a los operadores - todo lo que puedes hacer con los vectores y parámetros que ahora has visto.