Palabras clave: defparam, parámetro, instanciación, ram

Cuando un módulo es referenciado e instanciado por otro módulo, el módulo de nivel superior puede sobrescribir los valores de los parámetros del módulo de nivel inferior. Esto permite pasar diferentes parámetros a múltiples módulos con el mismo nombre en tiempo de compilación, sin necesidad de crear nuevos archivos para múltiples módulos que solo difieren en los parámetros.

Hay 2 formas de sobrescribir parámetros: 1) usando la palabra clave defparam, 2) instanciación de módulo con valores de parámetros.

Sentencia defparam

Se puede usar la palabra clave defparam para sobrescribir los valores de los parámetros de los módulos de nivel inferior mediante llamadas jerárquicas de módulos.

Por ejemplo, sobrescribir el parámetro MASK de un módulo ram cuyas líneas de dirección y datos de un solo puerto tienen ambas 4 bits de ancho:

Ejemplo

//instantiation
defparam     u_ram_4x4.MASK = 7 ;
ram_4x4    u_ram_4x4
    (
        .CLK    (clk),
        .A      (a[4-1:0]),
        .D      (d),
        .EN     (en),
        .WR     (wr),    //1 for write and 0 for read
        .Q      (q)    );

El modelo de ram_4x4 es el siguiente:

Ejemplo

module  ram_4x4
    (
     input               CLK ,
     input [4-1:0]       A ,
     input [4-1:0]       D ,
     input               EN ,
     input               WR ,    //1 for write and 0 for read
     output reg [4-1:0]  Q    );
 
    parameter        MASK = 3 ;
 
    reg [4-1:0]     mem [0:(1<<4)-1] ;
    always @(posedge CLK) begin
        if (EN && WR) begin
            mem[A]  <= D & MASK;
        end
        else if (EN && !WR) begin
            Q       <= mem[A] & MASK;
        end
    end
 
endmodule

Para realizar una simulación simple de esto, el testbench se escribe de la siguiente manera:

Ejemplo

`timescale 1ns/1ns
 
module test ;
    parameter    AW = 4 ;
    parameter    DW = 4 ;
 
    reg                  clk ;
    reg [AW:0]           a ;
    reg [DW-1:0]         d ;
    reg                  en ;
    reg                  wr ;
    wire [DW-1:0]        q ;
 
    //clock generating
    always begin
        #15 ;     clk = 0 ;
        #15 ;     clk = 1 ;
    end
 
    initial begin
        a         = 10 ;
        d         = 2 ;
        en        = 'b0 ;
        wr        = 'b0 ;
        repeat(10) begin
            @(negedge clk) ;
            en     = 1'b1;
            a      = a + 1 ;
            wr     = 1'b1 ;  //write command
            d      = d + 1 ;
        end
        a         = 10 ;
        repeat(10) begin
            @(negedge clk) ;
            a      = a + 1 ;
            wr     = 1'b0 ;  //read command
        end
    end // initial begin
 
    //instantiation
    defparam     u_ram_4x4.MASK = 7 ;
    ram_4x4    u_ram_4x4
    (
        .CLK    (clk),
        .A      (a[AW-1:0]),
        .D      (d),
        .EN     (en),
        .WR     (wr),    //1 for write and 0 for read
        .Q      (q)
     );
 
    //stop simulation
    initial begin
        forever begin
            #100;
            if ($time >= 1000)  $finish ;
        end
    end
 
endmodule // test

El resultado de la simulación es el siguiente:

La parte amarilla en la figura: cuando la dirección es c por primera vez, se escribe el dato 4; cuando la dirección es c por segunda vez, se lee el dato 4; se puede ver que el comportamiento de ram es correcto, y MASK no es 3, porque el bit2 de la salida Q de ram no está enmascarado.

Cuando la dirección es 1 por primera vez, se escribe el dato 9; cuando la dirección es 1 por segunda vez, el dato leído es 1, porque en este momento MASK es 7, y el bit3 de la señal de salida Q de ram está enmascarado. De esto se puede ver que el parámetro MASK se ha sobrescrito correctamente.

Instanciación de módulo con parámetros

El segundo método consiste en escribir los nuevos valores de los parámetros en la sentencia de instanciación del módulo al instanciarlo, para así sobrescribir los valores de los parámetros del módulo original.

Por ejemplo, realizar una instanciación de módulo con parámetros en un módulo ram cuyos anchos de dirección y datos son ambos variables:

Ejemplo

ram #(.AW(4), .DW(4))
    u_ram
    (
        .CLK    (clk),
        .A      (a[AW-1:0]),
        .D      (d),
        .EN     (en),
        .WR     (wr),    //1 for write and 0 for read
        .Q      (q)
     );

El modelo de ram es el siguiente:

Ejemplo

module  ram
    #(  parameter       AW = 2 ,
        parameter       DW = 3 )
    (
        input                   CLK ,
        input [AW-1:0]          A ,
        input [DW-1:0]          D ,
        input                   EN ,
        input                   WR ,    //1 for write and 0 for read
        output reg [DW-1:0]     Q
     );
 
    reg [DW-1:0]         mem [0:(1<<AW)-1] ;
    always @(posedge CLK) begin
        if (EN && WR) begin
            mem[A]  <= D ;
        end
        else if (EN && !WR) begin
            Q       <= mem[A] ;
        end
    end
 
endmodule

Para la simulación, solo es necesario, en el testbench del ejemplo anterior, reemplazar u_ram_4x4 por el módulo instanciado u_ram, o agregarlo nuevamente.

El resultado de la simulación es el siguiente. Como se puede ver en la figura, los parámetros AW y DW del módulo ram se han sobrescrito a 4, y el comportamiento de ram es correcto.

Diferencias y recomendaciones

(1) Al igual que en la instanciación de puertos de módulo, en la instanciación parametrizada también se puede omitir los nombres de los parámetros originales y realizar la instanciación de parámetros en orden. Por ejemplo, la instanciación de u_ram puede describirse como:

ram #(4, 4)   u_ram (......) ;

(2) Por supuesto, con defparam también se pueden sobrescribir los parámetros declarados en la declaración de puertos del módulo, y con la instanciación parametrizada también se pueden sobrescribir los parámetros declarados en el cuerpo del módulo. Por ejemplo, la instanciación de u_ram y u_ram_4x4 puede describirse respectivamente como:

Ejemplo

defparam     u_ram.AW = 4 ;
defparam     u_ram.DW = 4 ;
ram   u_ram(......);
ram_4x4  #(.MASK(7))    u_ram_4x4(......);

(3) ¿Se pueden mezclar estos dos métodos de sobrescritura de parámetros? ¡Por supuesto que sí! El requisito es que todos los parámetros estén declarados en la declaración de puertos del módulo o que todos los parámetros estén declarados en el cuerpo del módulo. Por ejemplo, la declaración de u_ram también se puede expresar como (los parámetros en el cuerpo del módulo se pueden verificar mediante experimentos propios):

Ejemplo

defparam     u_ram.AW = 4 ;
ram #(.DW(4)) u_ram (......);  //solo a alguien tan aburrido como yo se le ocurriría experimentar con esta forma de escribir

(4) ¿Y si un módulo tiene tanto parámetros declarados en la declaración de puertos del módulo como parámetros declarados en el cuerpo del módulo? ¿Se pueden sobrescribir ambos tipos al mismo tiempo? Por ejemplo, agregue el parámetro MASK al módulo ram, y el modelo es el siguiente:

Ejemplo

module  ram
    #(  parameter       AW = 2 ,
        parameter       DW = 3 )
    (
        input                   CLK ,
        input [AW-1:0]          A ,
        input [DW-1:0]          D ,
        input                   EN ,
        input                   WR ,    //1 for write and 0 for read
        output reg [DW-1:0]     Q    );
 
    parameter            MASK = 3 ;
 
    reg [DW-1:0]         mem [0:(1<<AW)-1] ;
    always @(posedge CLK) begin
        if (EN && WR) begin
            mem[A]  <= D ;
        end
        else if (EN && !WR) begin
            Q       <= mem[A] ;
        end
    end
 
endmodule

En este momento, si se usa defparam para sobrescribir el valor del parámetro MASK, la compilación informa un Error:

Ejemplo

//Se informa Error cuando todos usan defparam
defparam     u_ram.AW = 4 ;
defparam     u_ram.DW = 4 ;
defparam     u_ram.MASK = 7 ;
ram   u_ram  (......);
 
//También se informa Error al sobrescribir parámetros en el cuerpo del módulo con defparam
defparam     u_ram.MASK = 7 ;
ram #(.AW(4), .DW(4))   u_ram (......);

¡¡¡Aquí viene el punto clave!!! Si usa el método de instanciación de módulo con parámetros para sobrescribir el valor del parámetro MASK, la compilación no informará error, y MASK también se sobrescribirá correctamente.

ram #(.AW(4), .DW(4), .MASK(7)) u_ram (......);

Una posible explicación es que, a los ojos del compilador, si existen parámetros en la declaración de puertos del módulo, entonces los parámetros en el cuerpo se consideran de tipo localparam, y el uso de defparam no podrá sobrescribir los parámetros declarados en el cuerpo del módulo.

También puede estar relacionado con el compilador, y puedes experimentar en otros compiladores también.

(5) Se recomienda no usar el método de defparam al instanciar un módulo existente y sobrescribir sus parámetros relacionados. Además de las desventajas anteriores, defparam generalmente no es sintetizable.

(6) También se recomienda que, al escribir un módulo, si se sabe de antemano que será instanciado y tiene parámetros que deben sobrescribirse, escriba estos parámetros antes de la declaración de puertos del módulo (usando el signo hash#para indicarlo). Este formato de código no solo tiene buena legibilidad, sino que también es conveniente para la depuración.

Descarga del código fuente

Download

Resumen de la etapa

En realidad, con lo que se ha presentado hasta aquí, ya pueden usar los conocimientos del lenguaje Verilog aprendidos anteriormente para construir una pequeña choza de paja para circuitos de hardware. Sí, una pequeña choza de paja. Debido a la especial naturaleza del lenguaje de descripción de hardware que corresponde a los circuitos de hardware reales, al construir varios modelos con Verilog, se debe considerar cómo es el circuito realmente generado y si cumple con los requisitos reales. A veces la simulación rtl puede pasar, pero el circuito real finalmente generado puede funcionar de manera anormal.

Por lo tanto, para agregar ladrillos y tejas a tu pequeña choza de paja, todavía necesitas aprender la parte avanzada. Por supuesto, la parte avanzada solo puede convertir tu pequeña choza de paja en una casa de ladrillos resistente que pueda soportar viento y nieve, pero puede derrumbarse si encuentra un terremoto.

Si deseas consolidar tu casa de ladrillos para construir una villa, necesitas aprender los temas avanzados de Verilog, como PLI (Interfaz de Lenguaje de Programación), UDP (Primitivas Definidas por el Usuario), restricciones de temporización y análisis de temporización, etc. También necesitas participar en más proyectos de ingeniería para acumular experiencia y prestar especial atención a algunas técnicas de diseño, como diseño de bajo consumo, diseño asíncrono, etc. Por supuesto, aprender a usar SystemVerilog para una verificación integral agregará una capa de escudo protector a tu construcción.

Pero si deseas terminar de aprender todos los conocimientos de circuitos digitales y Verilog para construir un palacio presidencial a prueba de proyectiles, realmente no podemos ayudarte. Porque el mar del conocimiento no tiene fin, y no hay orilla a la que regresar.

Debido a la limitación de espacio, aquí solo se presenta la parte avanzada. Cuando haya oportunidad, también se agregarán las partes de temas avanzados y técnicas.