I Verilog är parametrar konstanter och tillhör inte någon annan datatyp som register- eller netdatatyper.

Ett konstant uttryck hänvisar till ett konstant tal eller tidigare definierad parameter. Vi kan inte ändra parametervärden vid körning, men vi kan ändra ett parametervärde med hjälp av defparam påstående.

De defparam uttalande kan endast ändra parametrar vid kompileringstillfället. Parametervärden kan ändras med # fördröjningsspecifikation med modulinstansiering.

I Verilog , det finns två metoder för att åsidosätta ett modulparametervärde under en modulinstansering.

1. Genom att använda nyckelordet defparam.
2. Och tilldelning av parametervärde för modulinstanser.

Efter nyckelordet defparam specificeras den hierarkiska sökvägen till parametern och parameterns nya värde. Detta nya värde bör vara ett konstant uttryck. Om uttrycket på höger sida refererar till några parametrar, bör det deklareras i modulen där defparam anropas.

Metoden för tilldelning av parametervärde för modulen instans verkar som en tilldelning av fördröjning till gate instans. Denna metod åsidosätter parametrar inuti instansierade moduler som de visas i modulen. Med detta format kan parametrar inte hoppas över.

Konstanta uttryck kan innehålla tidigare deklarerade parametrar. När ändringar upptäcks på de tidigare deklarerade parametrarna uppdateras alla parametrar som är beroende av detta värde automatiskt.

Tänk på att en 4-bitars adderare kan parametriseras för att acceptera ett värde för antalet bitar, och nya parametervärden kan skickas under modulinstansering. Så en N-bitars adderare konverteras till en 4-bitars, 8-bitars eller 16-bitars adderare. De är som argument för en funktion som skickas under ett funktionsanrop.

 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 

Det finns två typer av parametrar, modul och specificera , och båda accepterar en intervallspecifikation. Men de är gjorda lika breda som det värde som ska lagras dem, och därför är en intervallspecifikation inte nödvändig.

Modulparametrar

Den kan användas för att åsidosätta parameterdefinitioner inom en modul och gör att modulen har en annan uppsättning parametrar vid kompilering. En parameter kan ändras med defparam påstående. Det är vanligt att använda versaler i namn för att parametern ska märka dem direkt.

Modulen nedan använder parametrar för att specificera bussbredden, databredden och djupet för FIFO inom designen, och kan åsidosättas med nya värden när modulen instansieras eller genom att använda defparam-satser.

 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 

I den nya ANSI-stilen för Verilog-portdeklaration kan vi deklarera parametrar som:

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

Åsidosättande parametrar

Parametrar kan åsidosättas med nya värden under instansieringen av modulen. Den första delen kallas modulen design_ip med namnet d0 där nya parametrar skickas inom # ( ).

Den andra delen är att använda en Verilog-konstruktion som kallas defparam för att ställa in de nya parametervärdena. Den första metoden används vanligtvis för att skicka nya parametrar i RTL-designer. Och den andra metoden används i testbänksimuleringar för att snabbt uppdatera designparametrarna utan att behöva återställa modulen.

 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 

Modulräknaren har två parametrar N och NER , som deklareras ha ett standardvärde på 2 och 0.

N styr antalet bitar i utgången, och kontrollerar effektivt räknarens bredd. Det är en 2-bitars räknare som standard.

Parameter NER styr om räknaren ska öka eller minska. Räknaren kommer att minska eftersom parametern är inställd på 0.

2-bitars uppräknare

nackdelar med internet

 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></=>

Standardparametrarna används för att implementera räknaren where N är lika med två, vilket gör det till en 2-bitarsräknare, och NER är lika med noll, vilket gör det till en uppräkning. Utgången från räknaren lämnas oansluten på översta nivån.

4-bitars nedräknare

I detta fall instansieras modulräknaren med N som 4 vilket gör den till en 4-bitars räknare. DOWN skickas ett värde på 1 under modulens instansiering och följaktligen implementeras en nedräknare.

 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 

Ange parametrar

Dessa parametrar används för att tillhandahålla tids- och fördröjningsvärden och deklareras med hjälp av specparam nyckelord. Det är tillåtet att använda både inom det specificerade blocket och huvudmodulkroppen.

 // 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 

Skillnad mellan specificera och modulparametrar

Anteckningar

Här är några viktiga anmärkningar för Verilog-parametrarna, till exempel:

• Om vi ​​använder defparam uttalande måste vi ange en hierarkisk sökväg till parametern.
• Vi kan inte hoppa över en parameter i a modul instans parameter värde tilldelning . Om vi ​​behöver göra detta, använd initialvärdet för en inte överskriven parameter.
• När en parameter beror på den andra kommer den andra automatiskt att uppdateras om vi ändrar den första.