Maîtriser les Paramètres Verilog : Construire des Modules Réutilisables et Évolutifs

Les paramètres sont des constructions Verilog qui permettent à un module d'être réutilisé avec une spécification différente. Par exemple, un additionneur 4 bits peut être paramétré pour accepter une valeur pour le nombre de bits et de nouvelles valeurs de paramètres peuvent être passées lors de l'instanciation du module. Ainsi, un additionneur N bits peut devenir un additionneur 4 bits, 8 bits ou 16 bits. Ils sont comme des arguments d'une fonction qui sont passés lors d'un appel de fonction.

parameter MSB = 7; // MSB est un paramètre avec une valeur constante 7
parameter REAL = 4.5; // REAL contient un nombre réel
parameter FIFO_DEPTH = 256, MAX_WIDTH = 32; // Déclare deux paramètres
parameter [7:0] f_const = 2'b3; // Valeur 2 bits convertie en 8 bits ; 8'b3

Les paramètres sont essentiellement des constantes et il est donc illégal de modifier leur valeur à l'exécution. Il est illégal de redéclarer un nom déjà utilisé par un net, une variable ou un autre paramètre.

Il y a deux types majeurs de paramètres, module et specify et les deux acceptent une spécification de plage. Mais, ils sont normalement faits aussi larges que la valeur à stocker l'exige et donc une spécification de plage n'est pas nécessaire.

Paramètres de Module

Les paramètres de module peuvent être utilisés pour remplacer les définitions de paramètres dans un module et cela fait que le module a un ensemble différent de paramètres au moment de la compilation. Un paramètre peut être modifié avec l'instruction defparam ou dans l'instruction d'instance de module. C'est une pratique courante d'utiliser des lettres majuscules dans les noms des paramètres pour les rendre instantanément visibles.

Le module montré ci-dessous utilise des paramètres pour spécifier la largeur du bus, la largeur des données et la profondeur de FIFO dans la conception, et peut être remplacé par de nouvelles valeurs quand le module est instancié ou en utilisant des instructions defparam.

// Style de déclaration de port Verilog 1995
module design_ip (addr, wdata, write, sel, rdata);
  parameter BUS_WIDTH = 32, DATA_WIDTH = 64, FIFO_DEPTH = 512;
  input addr;
  input wdata;
  input write;
  input sel;
  output rdata;
  wire [BUS_WIDTH-1:0] addr;
  wire [DATA_WIDTH-1:0] wdata;
  reg [DATA_WIDTH-1:0] rdata;
  reg [7:0] fifo [FIFO_DEPTH];
  // Le code de conception va ici ...
endmodule

Dans le nouveau style ANSI de déclaration de port Verilog, vous pouvez déclarer les paramètres comme montré ci-dessous.

module design_ip #(
  parameter BUS_WIDTH=32,
  parameter DATA_WIDTH=64
) (
  input [BUS_WIDTH-1:0] addr,
  // Autres déclarations de ports
);

Remplacement des Paramètres

Les paramètres peuvent être remplacés par de nouvelles valeurs lors de l'instanciation du module. La première partie instancie le module appelé design_ip par le nom d0 où de nouveaux paramètres sont passés dans #( ). La seconde partie utilise une construction Verilog appelée defparam pour définir les nouvelles valeurs de paramètres. La première méthode est la façon la plus couramment utilisée pour passer de nouveaux paramètres dans les conceptions RTL. La seconde méthode est couramment utilisée dans les simulations de banc de test pour mettre à jour rapidement les paramètres de conception sans avoir à réinstancier le module.

module tb;
  // Remplacement par instanciation de module
  design_ip #(BUS_WIDTH = 64, DATA_WIDTH = 128) d0 ([liste_ports]);
  // Utilisation de defparam pour remplacer
  defparam d0.FIFO_DEPTH = 128;
endmodule

Exemple

Le module counter a deux paramètres N et DOWN déclarés pour avoir une valeur par défaut de 2 et 0 respectivement. N contrôle le nombre de bits dans la sortie contrôlant effectivement la largeur du compteur. Par défaut, c'est un compteur 2 bits. Le paramètre DOWN contrôle si le compteur doit incrémenter ou décrémenter. Par défaut, le compteur décrémentera car le paramètre est mis à 0.

Compteur Ascendant 2 bits

module counter #(
  parameter N = 2,
  parameter DOWN = 0
) (
  input clk,
  input rstn,
  input en,
  output reg [N-1:0] out
);
  always @ (posedge clk) begin
    if (!rstn) begin
      out <= 0;
    end else begin
      if (en)
        if (DOWN) out <= out - 1;
        else out <= out + 1;
      else
        out <= out;
    end
  end
endmodule

Le module counter est instancié avec N comme 2 même si ce n'est pas requis car la valeur par défaut est de toute façon 2. DOWN n'est pas passé lors de l'instanciation du module et prend donc la valeur par défaut de 0 en faisant un compteur ascendant.

module design_top (
  input clk,
  input rstn,
  input en,
  output [1:0] out
);
  counter #(.N(2)) u0 (
    .clk(clk),
    .rstn(rstn),
    .en(en)
  );
endmodule

On voit que les paramètres par défaut sont utilisés pour implémenter le compteur où N égal deux en fait un compteur 2 bits et DOWN égal zéro en fait un compteur ascendant. La sortie du compteur est laissée non connectée au niveau supérieur.

Compteur Descendant 4 bits

Dans ce cas, le module counter est instancié avec N comme 4 en faisant un compteur 4 bits. DOWN reçoit une valeur de 1 lors de l'instanciation du module et donc un compteur descendant est implémenté.

module design_top (
  input clk,
  input rstn,
  input en,
  output [3:0] out
);
  counter #(.N(4), .DOWN(1)) u1 (
    .clk(clk),
    .rstn(rstn),
    .en(en)
  );
endmodule

Paramètres Specify

Ceux-ci sont principalement utilisés pour fournir des valeurs de timing et de délai et sont déclarés en utilisant le mot-clé specparam. Il est autorisé de les utiliser à la fois dans le bloc specify et le corps principal du module.

// Utilisation du bloc specify
specify
  specparam t_rise = 200, t_fall = 150;
  specparam clk_to_q = 70, d_to_q = 100;
endspecify

// Dans le module principal
module my_block ( ... );
  specparam dhold = 2.0;
  specparam ddly = 1.5;
  parameter WIDTH = 32;
endmodule

Différence entre paramètres specify et module

Paramètre specify	Paramètre module
Déclaré par specparam	Déclaré par parameter
Peut être déclaré dans le bloc specify ou dans le module principal	Ne peut être déclaré que dans le module principal
Peut être assigné des specparams et paramètres	Ne peut pas être assigné des specparams
SDF peut être utilisé pour remplacer les valeurs	Les valeurs de paramètres d'instance ou defparam peuvent être utilisées pour remplacer