Paramètres Verilog : rendre tes modules configurables

Des constantes avec une astuce

Un parameter est une constante - le compilateur choisit sa valeur et la grave dans le design avant que la simulation ne démarre. L'astuce, c'est que celui qui instancie le module peut changer la valeur. Le même fichier source de module peut produire des circuits de tailles différentes selon la façon dont les appelants le paramètrent.

C'est comme ça que tu construis de l'IP réutilisable. Un module FIFO avec des paramètres WIDTH et DEPTH peut servir chaque équipe d'une entreprise. Un compteur avec un paramètre WIDTH est le même source qu'il compte jusqu'à 16 ou jusqu'à 4 milliards.

Déclaration de paramètre basique

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 par défaut = 8
    counter dut8(.clk(clk), .reset(reset), .count(count8));

    // Override WIDTH à 16 pour cette 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

Trois morceaux de syntaxe nouvelle :

1. Bloc de paramètre : #( parameter WIDTH = 8 ) entre le nom du module et la liste de ports. La valeur par défaut 8 est ce que le module utilise quand personne ne surcharge.
2. Site d'utilisation : output reg [WIDTH-1:0] count. Le paramètre est juste une constante - on le branche dans la plage de bits. Le même source produit une sortie 8 ou 16 bits selon WIDTH.
3. Syntaxe d'override : counter #(.WIDTH(16)) dut16(...) au moment de l'instantiation. Le bloc #(...) vient avant le nom d'instance, après le nom du module. Les paramètres que tu ne mentionnes pas gardent leurs défauts.

localparam : constantes internes

Il y a des constantes que tu ne veux pas que les appelants surchargent. Les encodages d'état sont le cas classique :

module fsm(input wire clk, input wire reset, input wire go, output reg busy);
    // Les états sont un détail d'implémentation ; personne d'extérieur ne doit s'en soucier.
    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 rend IDLE, RUNNING, DONE disponibles à l'intérieur du module mais non surchargeables depuis l'instantiation. C'est le bon choix - changer ce que la valeur d'état signifie pour IDLE depuis l'extérieur du module serait terrifiant.

Utilise parameter pour les choses que les appelants doivent configurer (largeurs, profondeurs, options comportementales) et localparam pour tout le reste. Un motif courant est de dériver des localparams à partir de parameters :

parameter WIDTH = 32;
localparam WIDTH_M1 = WIDTH - 1;   // calculé une fois ; non surchargeable

Largeurs paramétrées en pratique

L'usage le plus courant des paramètres est de rendre flexibles les largeurs de bus. Voici un additionneur qui marche à n'importe quelle largeur :

module adder #(
    parameter WIDTH = 8
)(
    input  wire [WIDTH-1:0] a,
    input  wire [WIDTH-1:0] b,
    output wire [WIDTH:0]   sum    // +1 pour la retenue sortante
);
    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 fichier source, deux instances, deux largeurs différentes, pas de copier-coller. C'est tout le bénéfice des paramètres.

Plusieurs paramètres, override nommé

Pour les modules plus gros tu auras souvent plusieurs paramètres. Surcharge-les par nom dans n'importe quel ordre :

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

// Au site d'appel :
fifo #(.WIDTH(32), .DEPTH(1024)) cmd_queue (.clk(clk), .reset(reset), ...);

Tu n'as pas à surcharger chaque paramètre ; ceux non mentionnés gardent leurs défauts. Le défaut AFULL dans l'exemple est calculé à partir de DEPTH, ce qui veut dire que si tu surcharges DEPTH, AFULL suit automatiquement - exactement le genre de dépendance que localparam gérerait aussi si tu ne voulais pas que les appelants puissent surcharger AFULL indépendamment.

Erreurs courantes

Oublier le # dans l'override. counter (.WIDTH(16)) dut(...) a l'air d'un override mais Verilog lit (.WIDTH(16)) comme une connexion de port. Tu as besoin de counter #(.WIDTH(16)) dut(...).

Utiliser des paramètres là où ils ne sont pas assez constants. Les paramètres se résolvent à l'élaboration, avant qu'aucun signal n'existe. Tu ne peux pas paramétrer sur un signal runtime - si la valeur dépend de ce qu'une entrée fait au moment de la simulation, ce n'est pas un paramètre, c'est de la logique.

Confondre parameter et localparam dans la liste de ports. Seul parameter va dans le bloc #(...) en haut. localparam vit à l'intérieur du corps. Le compilateur te le dira si tu les inverses.

La suite

Tu peux maintenant rendre la taille de tes modules réglable à la compilation. Les deux prochains documents couvrent les règles d'écriture des constantes littérales (8'h1F, 4'b1010, 32'd100) et les valeurs x et z qui apparaissent quand les signaux ne sont pas pilotés ou en contention. Ensuite on passe aux opérateurs - tout ce que tu peux faire avec les vecteurs et paramètres que tu as maintenant vus.