Dominando Parâmetros em Verilog: Crie Módulos Reutilizáveis e Escaláveis

Parâmetros são construções Verilog que permitem reutilizar um módulo com especificação diferente. Por exemplo, um somador de 4 bits pode ser parametrizado para aceitar o número de bits, e novos valores passados na instanciação. Assim, um somador N-bit vira 4, 8 ou 16 bits. São como argumentos de função passados na chamada.

parameter MSB = 7;
parameter REAL = 4.5;
parameter FIFO_DEPTH = 256, MAX_WIDTH = 32;
parameter [7:0] f_const = 2'b3; // valor de 2 bits convertido para 8 bits: 8'b3

Parâmetros são basicamente constantes, sendo ilegal modificar seu valor em tempo de execução. Ilegal redeclarar nome já usado por net, variável ou outro parâmetro.

Dois tipos principais: module e specify, ambos aceitam especificação de range. Normalmente feitos tão largos quanto o valor requer.

Parâmetros de Módulo

Podem sobrescrever definições de parâmetros dentro de um módulo, fazendo o módulo ter parâmetros diferentes em tempo de compilação. Podem ser modificados com defparam ou na instrução de instanciação. Prática comum usar letras maiúsculas para torná-los visíveis.

O módulo abaixo usa parâmetros para largura de barramento, largura de dados e profundidade de FIFO, sobrescrevíveis na instanciação ou com defparam.

// Estilo Verilog 1995
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];
  // Código do design aqui ...
endmodule

No novo estilo ANSI, declare parâmetros assim:

module design_ip #(parameter BUS_WIDTH=32, parameter DATA_WIDTH=64) (
  input [BUS_WIDTH-1:0] addr,
  // Outras declarações de porta
);

Sobrescrevendo Parâmetros

Parâmetros podem ser sobrescritos com novos valores na instanciação. A primeira parte instancia design_ip como d0 com novos parâmetros em #( ). A segunda usa defparam para definir novos valores. O primeiro método é o mais comum em RTL. O segundo é comum em testbenches para atualizar parâmetros rapidamente sem reinstanciar.

module tb;
  // Sobrescrita na instanciação
  design_ip #(BUS_WIDTH = 64, DATA_WIDTH = 128) d0 ( [lista_portas] );
  
  // Uso de defparam
  defparam d0.FIFO_DEPTH = 128;
endmodule

Exemplo: Contador Parametrizado

O módulo counter tem parâmetros N e DOWN com defaults 2 e 0. N controla bits da saída (largura do contador). Default é contador de 2 bits. DOWN controla incrementar/decrementar. Default 0 = incrementa.

Contador up de 2 bits

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)
        if (DOWN) out <= out - 1;
        else out <= out + 1;
      else out <= out;
    end
  end
endmodule

Instanciação com N=2 (default) e DOWN não passado (default 0 = up-counter).

module design_top (
  input clk,
  input rstn,
  input en,
  output [1:0] out
);
  counter #(.N(2)) u0 (
    .clk(clk), .rstn(rstn), .en(en)
  );
endmodule

Parâmetros default implementam contador de 2 bits up-counter. Saída do contador deixada desconectada no topo.

Contador down de 4 bits

Instanciação com N=4 (4 bits) e DOWN=1 (down-counter).

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

Parâmetros Specify

Usados para valores de timing e delay, declarados com specparam. Permitidos tanto no bloco specify quanto no corpo principal do módulo.

// Bloco specify
specify
  specparam t_rise = 200, t_fall = 150;
  specparam clk_to_q = 70, d_to_q = 100;
endspecify

// No módulo principal
module my_block ( ... );
  specparam dhold = 2.0;
  specparam ddly = 1.5;
  parameter WIDTH = 32;
endmodule

Diferença entre Parâmetros Specify e Module

Parâmetro Specify	Parâmetro Module
Declarado por specparam	Declarado por parameter
Pode ser declarado no bloco specify ou módulo principal	Só pode ser declarado no módulo principal
Pode receber specparams e parameters	Não pode receber specparams
SDF pode sobrescrever valores	Valores de instanciação ou defparam sobrescrevem