TechCodeview

Dans Verilog, les paramètres sont des constantes et n'appartiennent à aucun autre type de données tel que les types de données registre ou net.

Une expression constante fait référence à un nombre constant ou à un paramètre préalablement défini. Nous ne pouvons pas modifier les valeurs des paramètres au moment de l'exécution, mais nous pouvons modifier une valeur de paramètre à l'aide de la commande paramètre déf déclaration.

Le paramètre déf L'instruction ne peut modifier les paramètres qu'au moment de la compilation. Les valeurs des paramètres peuvent être modifiées à l'aide de la spécification # de retard avec l'instanciation du module.

Dans Verilog , il existe deux méthodes pour remplacer la valeur d'un paramètre de module lors d'une instanciation de module.

1. En utilisant le mot-clé defparam.
2. Et attribution de la valeur des paramètres de l'instance de module.

Après le mot-clé defparam, le chemin hiérarchique du paramètre et la nouvelle valeur du paramètre sont spécifiés. Cette nouvelle valeur doit être une expression constante. Si l'expression de droite fait référence à des paramètres, elle doit être déclarée dans le module où defparam est invoqué.

La méthode d'attribution de valeur de paramètre d'instance de module ressemble à une attribution de délai à l'instance de porte. Cette méthode remplace les paramètres à l’intérieur des modules instanciés tels qu’ils apparaissent dans le module. En utilisant ce format, les paramètres ne peuvent pas être ignorés.

Les expressions constantes peuvent contenir des paramètres précédemment déclarés. Lorsque des changements sont détectés sur les paramètres précédemment déclarés, tous les paramètres qui dépendent de cette valeur sont mis à jour automatiquement.

Considérez qu'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 transmises lors de l'instanciation du module. Ainsi, un additionneur de N bits se convertit en un additionneur de 4 bits, 8 bits ou 16 bits. Ils sont comme les arguments d’une fonction qui sont transmis lors d’un appel de fonction.

 parameter MSB = 7; // MSB is a parameter with the constant value 7 parameter REAL = 4.5; // REAL holds the real number parameter FIFO_DEPTH = 256, MAX_WIDTH = 32; // Declares two parameters parameter [7:0] f_const = 2'b3; // 2 bit value is converted into 8 bits; 8'b3 

Il existe deux types de paramètres, module et spécifier , et les deux acceptent une spécification de plage. Mais ils sont aussi larges que la valeur à stocker, et une spécification de plage n’est donc pas nécessaire.

Paramètres des modules

Il peut être utilisé pour remplacer les définitions de paramètres dans un module et donne au module un ensemble de paramètres différent au moment de la compilation. Un paramètre peut être modifié avec le paramètre déf déclaration. Il est courant d'utiliser des lettres majuscules dans les noms des paramètres pour les remarquer instantanément.

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

 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]; endmodule 

Dans le nouveau style ANSI de déclaration de port Verilog, nous pouvons déclarer des paramètres tels que :

 module design_ip #(parameter BUS_WIDTH=32, parameter DATA_WIDTH=64) (input [BUS_WIDTH-1:0] addr, // other port declarations ); 

Paramètres de remplacement

Les paramètres peuvent être remplacés par de nouvelles valeurs lors de l'instanciation du module. La première partie est le module appelé conception_ip par le nom d0 où les nouveaux paramètres sont passés entre # ( ).

La deuxième partie consiste à utiliser une construction Verilog appelée paramètre déf pour définir les nouvelles valeurs des paramètres. La première méthode est couramment utilisée pour transmettre de nouveaux paramètres dans les conceptions RTL. Et la deuxième méthode est utilisée dans les simulations sur banc d'essai pour mettre à jour rapidement les paramètres de conception sans avoir à réinstancier le module.

 module tb; // Module instantiation override design_ip #(BUS_WIDTH = 64, DATA_WIDTH = 128) d0 ( [port list]); // Use of defparam to override defparam d0.FIFO_DEPTH = 128; endmodule 

Le compteur de module a deux paramètres N et VERS LE BAS , qui est déclaré avoir une valeur par défaut de 2 et 0.

N contrôle le nombre de bits dans la sortie, contrôlant efficacement la largeur du compteur. C'est un compteur 2 bits par défaut.

Paramètre VERS LE BAS contrôle si le compteur doit incrémenter ou décrémenter. Le compteur va décrémenter car le paramètre est mis à 0.

Compteur 2 bits

java sinon

 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) (down) out <="out" - 1; + endmodule pre> <p>The module counter is instantiated with <strong> <em>N</em> </strong> as 2 even though it is not required because the default value is anyway 2.</p> <p> <strong> <em>DOWN</em> </strong> is not passed during module instantiation. And it takes the default value of 0 making it an up-counter.</p> <pre> module design_top (input clk, input rstn, input en, output [1:0] out); counter #(.N(2)) u0 (.clk(clk), .rstn(rstn), .en(en)); endmodule </pre> <p>The default parameters are used to implement the counter where <strong> <em>N</em> </strong> equals two, making it a 2-bit counter, and <strong> <em>DOWN</em> </strong> equals zero, making it an up-counter. The output from the counter is left unconnected at the top level.</p> <img src="//techcodeview.com/img/verilog-tutorial/47/verilog-parameters.webp" alt="Verilog Parameters"> <p> <strong>4-bit down Counter</strong> </p> <p>In this case, the module counter is instantiated with N as 4 making it a 4-bit counter. DOWN is passed a value of 1 during the module instantiation and hence a down-counter is implemented.</p> <pre> 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 </pre> <br> <img src="//techcodeview.com/img/verilog-tutorial/47/verilog-parameters-2.webp" alt="Verilog Parameters"> <h3>Specify Parameters</h3> <p>These parameters are used to provide time and delay values and declared using the <strong> <em>specparam</em> </strong> keyword. It is allowed to use both within the specified block and the main module body.</p> <pre> // Use of specify block Specify specparam t_rise = 200, t_fall = 150; specparam clk_to_q = 70, d_to_q = 100; endspecify // Within main module module my_block ( ); specparam dhold = 2.0; specparam ddly = 1.5; parameter WIDTH = 32; endmodule </pre> <h3>Difference between Specify and Module Parameters</h3> <table class="table"> <tr> <th>Specify parameter</th> <th>Module parameter</th> </tr> <tr> <td>Specify the specparam keyword declares parameter.</td> <td>The module parameter is declared by parameter.</td> </tr> <tr> <td>It can be declared inside a specific block or within the main module.</td> <td>It can only be declared within the main module.</td> </tr> <tr> <td>This parameter may be assigned specparams and parameters.</td> <td>This may not be assigned specparams.</td> </tr> <tr> <td>SDF can be used to override values.</td> <td>Instance declaration parameter values or defparam can be used to override.</td> </tr> </table> <p> <strong>Notes</strong> </p> <p>Here are some important notes for the Verilog parameters, such as:</p> <ul> <li>If we are using the <strong> <em>defparam</em> </strong> statement, we must specify a hierarchical path to the parameter.</li> <li>We cannot skip over a parameter in a <strong> <em>module instance parameter value assignment</em> </strong> . If we need to do this, use the initial value for a not overwritten parameter.</li> <li>When one parameter depends on the other, then the second will automatically be updated if we change the first one.</li> </ul> <hr></=>

Les paramètres par défaut sont utilisés pour implémenter le compteur où N est égal à deux, ce qui en fait un compteur sur 2 bits, et VERS LE BAS est égal à zéro, ce qui en fait un compteur. La sortie du compteur reste non connectée au niveau supérieur.

Compteur descendant 4 bits

Dans ce cas, le compteur de module est instancié avec N comme 4, ce qui en fait un compteur sur 4 bits. DOWN reçoit la valeur 1 lors de l'instanciation du module et un compteur décroissant est donc 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 

Spécifier les paramètres

Ces paramètres sont utilisés pour fournir des valeurs de temps et de retard et déclarés à l'aide du paramètre de spécification mot-clé. Il est permis d'utiliser à la fois le bloc spécifié et le corps du module principal.

 // Use of specify block Specify specparam t_rise = 200, t_fall = 150; specparam clk_to_q = 70, d_to_q = 100; endspecify // Within main module module my_block ( ); specparam dhold = 2.0; specparam ddly = 1.5; parameter WIDTH = 32; endmodule 

Différence entre les paramètres de spécification et de module

Remarques

Voici quelques remarques importantes concernant les paramètres Verilog, telles que :

• Si nous utilisons le paramètre déf instruction, nous devons spécifier un chemin hiérarchique vers le paramètre.
• Nous ne pouvons pas sauter un paramètre dans un affectation de la valeur du paramètre d'instance de module . Si nous devons le faire, utilisez la valeur initiale pour un paramètre non écrasé.
• Lorsqu'un paramètre dépend de l'autre, alors le second sera automatiquement mis à jour si l'on modifie le premier.