In Verilog, i parametri sono costanti e non appartengono a nessun altro tipo di dati come i tipi di dati di registro o di rete.

Un'espressione costante si riferisce a un numero costante o a un parametro definito in precedenza. Non possiamo modificare i valori dei parametri in fase di esecuzione, ma possiamo modificare il valore di un parametro utilizzando il comando defparam dichiarazione.

IL defparam l'istruzione può modificare i parametri solo al momento della compilazione. I valori dei parametri possono essere modificati utilizzando la # specificazione del ritardo con l'istanziazione del modulo.

In Verilog , esistono due metodi per sovrascrivere il valore di un parametro del modulo durante la creazione di un'istanza del modulo.

1. Utilizzando la parola chiave defparam.
2. E l'assegnazione del valore del parametro dell'istanza del modulo.

Dopo la parola chiave defparam, viene specificato il percorso gerarchico del parametro e il nuovo valore del parametro. Questo nuovo valore dovrebbe essere un'espressione costante. Se l'espressione sul lato destro fa riferimento a qualche parametro, dovrebbe essere dichiarata all'interno del modulo in cui viene invocato defparam.

Il metodo di assegnazione del valore del parametro dell'istanza del modulo sembra un'assegnazione del ritardo all'istanza del gate. Questo metodo sovrascrive i parametri all'interno dei moduli istanziati così come appaiono nel modulo. Utilizzando questo formato, i parametri non possono essere saltati.

Le espressioni costanti possono contenere parametri dichiarati in precedenza. Quando vengono rilevate modifiche sui parametri precedentemente dichiarati, tutti i parametri che dipendono da questo valore vengono aggiornati automaticamente.

Considerare che un sommatore a 4 bit può essere parametrizzato per accettare un valore per il numero di bit e che nuovi valori di parametro possono essere passati durante l'istanziazione del modulo. Pertanto, un sommatore di N bit si converte in un sommatore di 4 bit, 8 bit o 16 bit. Sono come argomenti di una funzione che viene passata durante una chiamata di funzione.

 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 

Esistono due tipi di parametri, modulo E specificare ed entrambi accettano una specifica di intervallo. Tuttavia, sono larghi quanto il valore da memorizzare e quindi non è necessaria una specifica dell'intervallo.

Parametri del modulo

Può essere utilizzato per sovrascrivere le definizioni dei parametri all'interno di un modulo e fare in modo che il modulo abbia un set di parametri diverso in fase di compilazione. Un parametro può essere modificato con defparam dichiarazione. È normale utilizzare lettere maiuscole nei nomi affinché il parametro le noti immediatamente.

Il modulo seguente utilizza parametri per specificare la larghezza del bus, la larghezza dei dati e la profondità del FIFO all'interno del progetto e può essere sovrascritto con nuovi valori quando viene creata un'istanza del modulo o utilizzando le istruzioni 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 

Nel nuovo stile ANSI della dichiarazione della porta Verilog, possiamo dichiarare parametri come:

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

Sostituzione dei parametri

I parametri possono essere sovrascritti con nuovi valori durante la creazione di istanze del modulo. La prima parte è il modulo chiamato design_ip dal nome d0 dove i nuovi parametri vengono passati tra # ( ).

La seconda parte consiste nell'utilizzare un costrutto Verilog chiamato defparam per impostare i nuovi valori dei parametri. Il primo metodo viene comunemente utilizzato per passare nuovi parametri nei progetti RTL. Il secondo metodo viene utilizzato nelle simulazioni sui banchi di prova per aggiornare rapidamente i parametri di progettazione senza dover creare nuovamente un'istanza del modulo.

 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 

Il contatore del modulo ha due parametri N E GIÙ , che viene dichiarato avere un valore predefinito pari a 2 e 0.

N controlla il numero di bit nell'output, controllando efficacemente la larghezza del contatore. Per impostazione predefinita è un contatore a 2 bit.

Parametro GIÙ controlla se il contatore deve incrementare o decrementare. Il contatore diminuirà perché il parametro è impostato su 0.

Contatore a 2 bit

I comandi Linux creano la cartella

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

I parametri predefiniti vengono utilizzati per implementare il contatore where N è uguale a due, rendendolo un contatore a 2 bit e GIÙ è uguale a zero, rendendolo un contatore in avanti. L'uscita del contatore viene lasciata non collegata al livello superiore.

Contatore decrescente a 4 bit

In questo caso, il contatore del modulo viene istanziato con N come 4 rendendolo un contatore a 4 bit. A DOWN viene passato il valore 1 durante l'istanziazione del modulo e quindi viene implementato un contatore alla rovescia.

 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 

Specificare i parametri

Questi parametri vengono utilizzati per fornire valori di tempo e ritardo e dichiarati utilizzando il file specparam parola chiave. È consentito l'utilizzo sia all'interno del blocco specificato che nel corpo del modulo principale.

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

Differenza tra parametri Specifica e Modulo

Appunti

Ecco alcune note importanti per i parametri Verilog, come ad esempio:

• Se stiamo utilizzando il defparam istruzione, dobbiamo specificare un percorso gerarchico per il parametro.
• Non possiamo saltare un parametro in a assegnazione del valore del parametro dell'istanza del modulo . Se necessario, utilizzare il valore iniziale per un parametro non sovrascritto.
• Quando un parametro dipende dall'altro, il secondo verrà automaticamente aggiornato se modifichiamo il primo.