Verilog Parameter: Module konfigurierbar machen

Konstanten mit einem Twist

Ein parameter ist eine Konstante - der Compiler wählt ihren Wert und backt ihn vor Beginn der Simulation in das Design ein. Der Twist: Wer auch immer das Modul instanziiert, kann den Wert ändern. Dieselbe Modul-Quelldatei kann Schaltungen unterschiedlicher Größen erzeugen, je nachdem, wie Aufrufer sie parametrieren.

So baut man wiederverwendbare IP. Ein FIFO-Modul mit WIDTH- und DEPTH-Parametern kann jedem Team in einer Firma dienen. Ein Counter mit einem WIDTH-Parameter ist dieselbe Quelle, ob er bis 16 oder bis 4 Milliarden zählt.

Grundlegende Parameter-Deklaration

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

    // WIDTH zu 16 überschreiben für diese Instanz
    counter #(.WIDTH(16)) dut16(.clk(clk), .reset(reset), .count(count16));

    always #5 clk = ~clk;

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

Drei neue Syntaxteile:

1. Parameter-Block: #( parameter WIDTH = 8 ) zwischen Modulnamen und Port-Liste. Der Default-Wert 8 ist das, was das Modul nimmt, wenn niemand überschreibt.
2. Nutzungsstelle: output reg [WIDTH-1:0] count. Der Parameter ist nur eine Konstante - wir stecken ihn in den Bit-Bereich. Dieselbe Modul-Quelle produziert je nach WIDTH einen 8-Bit- oder 16-Bit-Ausgang.
3. Override-Syntax: counter #(.WIDTH(16)) dut16(...) bei der Instanziierung. Der #(...)-Block steht vor dem Instanznamen, nach dem Modulnamen. Nicht erwähnte Parameter behalten ihre Defaults.

localparam: Interne Konstanten

Es gibt Konstanten, die Aufrufer nicht überschreiben sollen. Zustandskodierungen sind der Klassiker:

module fsm(input wire clk, input wire reset, input wire go, output reg busy);
    // Zustände sind ein Implementierungsdetail; niemand außerhalb sollte es interessieren.
    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 macht IDLE, RUNNING, DONE innerhalb des Moduls verfügbar, aber nicht von außen überschreibbar. Das ist die richtige Wahl - von außen zu ändern, welcher Zustandswert IDLE ist, wäre erschreckend.

Nutze parameter für Dinge, die Aufrufer konfigurieren sollen (Breiten, Tiefen, Verhaltensoptionen), und localparam für alles andere. Ein übliches Muster: localparams aus parameters ableiten:

parameter WIDTH = 32;
localparam WIDTH_M1 = WIDTH - 1;   // einmal berechnet; nicht überschreibbar

Parametrierte Breiten in der Praxis

Die häufigste Nutzung von Parametern ist, Busbreiten flexibel zu machen. Hier ein Addierer, der bei jeder Breite funktioniert:

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

Eine Quelldatei, zwei Instanzen, zwei verschiedene Breiten, kein Copy-Paste. Das ist der ganze Lohn von Parametern.

Mehrere Parameter, benannter Override

Bei größeren Modulen hast du oft mehrere Parameter. Überschreibe sie namentlich in beliebiger Reihenfolge:

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

// An der Aufrufstelle:
fifo #(.WIDTH(32), .DEPTH(1024)) cmd_queue (.clk(clk), .reset(reset), ...);

Du musst nicht jeden Parameter überschreiben; nicht erwähnte behalten ihre Defaults. Der AFULL-Default im Beispiel wird aus DEPTH berechnet, was heißt: Überschreibst du DEPTH, folgt AFULL automatisch - genau die Art Abhängigkeit, die auch localparam abdecken würde, wenn du nicht wolltest, dass Aufrufer AFULL unabhängig überschreiben können.

Häufige Fehler

Das # im Override vergessen. counter (.WIDTH(16)) dut(...) sieht aus wie ein Override, aber Verilog liest (.WIDTH(16)) als Port-Verbindung. Du brauchst counter #(.WIDTH(16)) dut(...).

Parameter dort nutzen, wo sie nicht konstant genug sind. Parameter lösen sich zur Elaborationszeit auf, bevor irgendein Signal existiert. Du kannst nicht auf ein Laufzeitsignal parametrieren - hängt der Wert von dem ab, was ein Eingang zur Simulationszeit tut, ist es kein Parameter, sondern Logik.

parameter und localparam in Port-Listen verwechseln. Nur parameter gehört in den #(...)-Block oben. localparam lebt im Body. Der Compiler sagt dir, wenn du sie vertauschst.

Wie es weitergeht

Du kannst jetzt Module bauen, deren Größe zur Compile-Zeit festgelegt wird. Die nächsten beiden Docs behandeln die Regeln zum Schreiben literaler Konstanten (8'h1F, 4'b1010, 32'd100) und die x- und z-Werte, die auftauchen, wenn Signale ungetrieben sind oder umkämpft werden. Danach gehen wir zu Operatoren über - alles, was du mit den Vektoren und Parametern machen kannst, die du jetzt gesehen hast.