Parametry w Verilogu: konfigurowalne moduły

Stałe z haczykiem

parameter to stała: kompilator ustala jej wartość i wbudowuje ją w projekt, zanim zacznie się symulacja. Haczyk polega na tym, że ten, kto tworzy instancję modułu, może tę wartość zmienić. Ten sam plik źródłowy modułu może dać układy różnej wielkości, zależnie od tego, jak wywołujący go sparametryzują.

Tak buduje się bloki IP wielokrotnego użytku. Moduł FIFO z parametrami WIDTH i DEPTH może obsłużyć każdy zespół w firmie. Licznik z parametrem WIDTH to ten sam kod, niezależnie od tego, czy liczy do 16, czy do 4 miliardów.

Podstawowa deklaracja parametru

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

Trzy nowe elementy składni:

1. Blok parametrów: #( parameter WIDTH = 8 ) między nazwą modułu a listą portów. Wartość domyślna 8 jest używana, gdy nikt jej nie nadpisze.
2. Miejsce użycia: output reg [WIDTH-1:0] count. Parametr to po prostu stała, którą wstawiamy w zakres bitów. Ten sam kod modułu daje wyjście 8-bitowe albo 16-bitowe, zależnie od WIDTH.
3. Składnia nadpisania: counter #(.WIDTH(16)) dut16(...) przy tworzeniu instancji. Blok #(...) stoi przed nazwą instancji, a po nazwie modułu. Parametry, których nie wymienisz, zachowują wartości domyślne.

localparam: stałe wewnętrzne

Są stałe, których wywołujący nie powinni nadpisywać. Klasycznym przykładem jest kodowanie stanów:

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 udostępnia IDLE, RUNNING i DONE wewnątrz modułu, ale nie pozwala ich nadpisać przy tworzeniu instancji. To właściwy wybór: zmiana z zewnątrz tego, jaka wartość stanu oznacza IDLE, byłaby przerażająca.

Używaj parameter do rzeczy, które wywołujący powinni konfigurować (szerokości, głębokości, opcje zachowania), a localparam do wszystkiego innego. Częsty wzorzec to wyprowadzanie localparam z parameter:

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

Sparametryzowane szerokości w praktyce

Najczęstsze zastosowanie parametrów to elastyczne szerokości magistral. Oto sumator, który działa przy dowolnej szerokości:

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

Jeden plik źródłowy, dwie instancje, dwie różne szerokości, bez kopiowania i wklejania. Na tym polega cała korzyść z parametrów.

Wiele parametrów, nadpisywanie po nazwie

W większych modułach często masz kilka parametrów. Nadpisuj je po nazwie w dowolnej kolejności:

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), ...);

Nie musisz nadpisywać każdego parametru: niewymienione zachowują wartości domyślne. Domyślna wartość AFULL w przykładzie jest obliczana z DEPTH, więc jeśli nadpiszesz DEPTH, AFULL automatycznie za nim podąży. Taką samą zależność obsłużyłby localparam, gdyby wywołujący nie mieli móc nadpisywać AFULL niezależnie.

Typowe błędy

Brak # przy nadpisaniu. counter (.WIDTH(16)) dut(...) wygląda jak nadpisanie, ale Verilog odczytuje (.WIDTH(16)) jako połączenie portu. Potrzebujesz counter #(.WIDTH(16)) dut(...).

Używanie parametrów tam, gdzie wartość nie jest wystarczająco stała. Parametry są rozwiązywane na etapie elaboracji, zanim powstanie jakikolwiek sygnał. Nie da się parametryzować sygnałem z czasu działania. Jeśli wartość zależy od tego, co robi wejście w czasie symulacji, to nie jest parametr, tylko logika.

Mylenie parameter i localparam w listach portów. W bloku #(...) na początku umieszcza się tylko parameter. localparam znajduje się w ciele modułu. Jeśli je zamienisz, kompilator ci o tym powie.

Co dalej

Potrafisz już tworzyć moduły, których rozmiar jest ustalany podczas kompilacji. Kolejne dwa artykuły omawiają reguły zapisu stałych literałowych (8'h1F, 4'b1010, 32'd100) oraz wartości x i z, które pojawiają się, gdy sygnały nie są sterowane albo mają sprzeczne źródła. Potem przechodzimy do operatorów, czyli wszystkiego, co można zrobić z wektorami i parametrami, które już znasz.