I Verilog er parametere konstanter og tilhører ikke noen annen datatype som register- eller nettodatatyper.

Et konstant uttrykk refererer til et konstant tall eller tidligere definert parameter. Vi kan ikke endre parameterverdier under kjøring, men vi kan endre en parameterverdi ved å bruke defparam uttalelse.

De defparam setningen kan bare endre parametere på kompileringstidspunktet. Parameterverdier kan endres ved å bruke # forsinkelsesspesifikasjon med modulinstansiering.

I Verilog , er det to metoder for å overstyre en modulparameterverdi under instansiering av en modul.

1. Ved å bruke nøkkelordet defparam.
2. Og modulforekomstparameterverditilordning.

Etter nøkkelordet defparam spesifiseres den hierarkiske banen til parameteren og parameterens nye verdi. Denne nye verdien bør være et konstant uttrykk. Hvis uttrykket på høyre side refererer til noen parametere, bør det deklareres i modulen der defparam påkalles.

Tilordningsmetoden for modulforekomstparameterverdi virker som en tilordning av forsinkelse til portforekomst. Denne metoden overstyrer parametere inne i instansierte moduler slik de vises i modulen. Ved å bruke dette formatet kan ikke parametere hoppes over.

Konstante uttrykk kan inneholde tidligere deklarerte parametere. Når endringer oppdages på de tidligere deklarerte parameterne, oppdateres alle parametere som avhenger av denne verdien automatisk.

Tenk på at en 4-bits adderer kan parameteriseres for å akseptere en verdi for antall biter, og nye parameterverdier kan sendes under instansiering av modulen. Så en N-bit adder konverterer til en 4-bit, 8-bit eller 16-bit adder. De er som argumenter for en funksjon som sendes under et funksjonskall.

 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 er to typer parametere, modul og spesifisere , og begge godtar en rekkeviddespesifikasjon. Men de er laget like brede som verdien som skal lagres dem, og derfor er en rekkeviddespesifikasjon ikke nødvendig.

Modul parametere

Den kan brukes til å overstyre parameterdefinisjoner i en modul og gjør at modulen har et annet sett med parametere på kompileringstidspunktet. En parameter kan endres med defparam uttalelse. Det er vanlig å bruke store bokstaver i navn for at parameteren skal legge merke til dem umiddelbart.

Modulen nedenfor bruker parametere for å spesifisere bussbredden, databredden og dybden til FIFO i designet, og kan overstyres med nye verdier når modulen instansieres eller ved å bruke defparam-setninger.

 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 nye ANSI-stilen til Verilog-porterklæringen kan vi deklarere parametere som:

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

Overordnede parametere

Parametre kan overstyres med nye verdier under instansiering av modulen. Den første delen er modulen som heter design_ip med navnet d0 der nye parametere sendes innenfor # ( ).

Den andre delen er bruk en Verilog-konstruksjon kalt defparam for å angi de nye parameterverdiene. Den første metoden brukes ofte til å sende nye parametere i RTL-design. Og den andre metoden brukes i testbenksimuleringer for raskt å oppdatere designparametrene uten å måtte gjenopprette 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 

Modultelleren har to parametere N og NED , som er erklært å ha en standardverdi på 2 og 0.

N kontrollerer antall biter i utgangen, og kontrollerer effektivt bredden på telleren. Det er en 2-bits teller som standard.

Parameter NED kontrollerer om telleren skal øke eller redusere. Telleren vil reduseres fordi parameteren er satt til 0.

2-bit opp Counter

ascii av a i java

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

Standardparametrene brukes til å implementere telleren hvor N er lik to, noe som gjør det til en 2-bits teller, og NED er lik null, noe som gjør det til en oppteller. Utgangen fra telleren forblir ukoblet på toppnivå.

4-bit ned teller

I dette tilfellet blir modultelleren instansiert med N som 4, noe som gjør den til en 4-bits teller. DOWN sendes en verdi på 1 under instansieringen av modulen, og derfor implementeres en nedteller.

 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 

Spesifiser parametere

Disse parameterne brukes til å gi tids- og forsinkelsesverdier og deklareres ved hjelp av specparam søkeord. Det er tillatt å bruke både innenfor den angitte blokken og hovedmodulkroppen.

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

Forskjellen mellom Spesifiser og Modulparametere

Notater

Her er noen viktige merknader for Verilog-parametrene, for eksempel:

• Hvis vi bruker defparam setning, må vi spesifisere en hierarkisk bane til parameteren.
• Vi kan ikke hoppe over en parameter i en modulforekomstparameterverditilordning . Hvis vi trenger å gjøre dette, bruk startverdien for en parameter som ikke er overskrevet.
• Når en parameter avhenger av den andre, vil den andre automatisk bli oppdatert hvis vi endrer den første.