Parameters в Verilog: делаем модули настраиваемыми

Константы с поворотом

parameter - это константа: компилятор подбирает её значение и зашивает в проект до старта симуляции. Поворот в том, что тот, кто инстанцирует module, может изменить значение. Один и тот же исходник может производить схемы разных размеров в зависимости от того, как вызывающие его параметризуют.

Так строят переиспользуемые IP. Module FIFO с parameters WIDTH и DEPTH может обслуживать каждую команду в компании. Счётчик с parameter WIDTH - один и тот же исходник, считает ли он до 16 или до 4 миллиардов.

Базовое объявление 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 = 8
    counter dut8(.clk(clk), .reset(reset), .count(count8));

    // Override WIDTH в 16 для этого instance
    counter #(.WIDTH(16)) dut16(.clk(clk), .reset(reset), .count(count16));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        #40 $display("через 4 такта: count8=%0d count16=%0d", count8, count16);
        $finish;
    end
endmodule

Три куска нового синтаксиса:

1. Блок parameters: #( parameter WIDTH = 8 ) между именем module и port list. Дефолтное значение 8 используется, если никто не override-ит.
2. Место использования: output reg [WIDTH-1:0] count. Parameter - это просто константа, мы вставляем её в bit range. Один и тот же исходник module даёт 8-битный или 16-битный выход в зависимости от WIDTH.
3. Синтаксис override: counter #(.WIDTH(16)) dut16(...) в момент instantiation. Блок #(...) идёт перед именем instance, после имени module. Не упомянутые parameters держат дефолты.

localparam: внутренние константы

Есть константы, которые ты не хочешь, чтобы вызывающие переопределяли. Классический случай - кодировки состояний:

module fsm(input wire clk, input wire reset, input wire go, output reg busy);
    // Состояния - деталь реализации, никому снаружи это не должно быть важно.
    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 делает IDLE, RUNNING, DONE доступными внутри module, но не переопределяемыми с instantiation. Это правильный выбор - менять, какое значение состояния означает IDLE, снаружи module было бы ужасно.

Используй parameter для вещей, которые вызывающие должны конфигурировать (ширины, глубины, опции поведения), и localparam для всего остального. Частый паттерн - выводить localparam из parameter:

parameter WIDTH = 32;
localparam WIDTH_M1 = WIDTH - 1;   // вычисляется один раз, не override-ится

Параметризованные ширины на практике

Самое частое использование parameters - гибкие ширины шин. Вот adder, который работает на любой ширине:

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

Один исходный файл, два instance, две разные ширины, никакого copy-paste. Это вся выгода parameters.

Несколько parameters, override по имени

В более крупных модулях часто будет несколько parameters. Override-ь их по имени в любом порядке:

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

// На месте вызова:
fifo #(.WIDTH(32), .DEPTH(1024)) cmd_queue (.clk(clk), .reset(reset), ...);

Не обязательно override-ить каждый parameter; не упомянутые держат дефолты. Дефолт AFULL в примере вычисляется из DEPTH, что значит: если override-ишь DEPTH, AFULL подтянется автоматически - именно такое поведение даёт и localparam, если ты не хочешь, чтобы вызывающие могли override-ить AFULL независимо.

Типичные ошибки

Забыли # в override. counter (.WIDTH(16)) dut(...) выглядит как override, но Verilog читает (.WIDTH(16)) как port-соединение. Нужно counter #(.WIDTH(16)) dut(...).

Использование parameters там, где они недостаточно константны. Parameters резолвятся в момент elaboration, до того как существуют какие-либо сигналы. Нельзя параметризовать на runtime-сигнал - если значение зависит от того, что делает input на момент симуляции, это не parameter, это логика.

Путают parameter и localparam в port list. В блок #(...) наверху идёт только parameter. localparam живёт внутри тела. Компилятор скажет, если перепутаешь.

Что дальше

Теперь умеешь делать модули, размер которых задаётся в compile time. Следующие два документа разбирают правила записи литеральных констант (8'h1F, 4'b1010, 32'd100) и значения x и z, которые появляются, когда сигналы не приводятся или конфликтуют. После этого переходим к операторам - всему, что можно делать с векторами и parameters, которые ты теперь увидел.