Parametri in Verilog: rendere i moduli configurabili

Costanti con una sorpresa

Un parameter è una costante: il compilatore ne sceglie il valore e lo incorpora nel progetto prima che la simulazione inizi. La sorpresa è che chi istanzia il modulo può cambiarne il valore. Lo stesso file sorgente di un modulo può produrre circuiti di dimensioni diverse a seconda di come viene parametrizzato.

È così che si costruiscono IP riutilizzabili. Un modulo FIFO con i parametri WIDTH e DEPTH può servire tutti i team di un'azienda. Un contatore con un parametro WIDTH ha lo stesso sorgente sia che conti fino a 16 sia che conti fino a 4 miliardi.

Dichiarazione di base di un parametro

module counter #(
    parameter WIDTH = 8
)(
    input  wire             clk,
    input  wire             reset,
    output reg  [WIDTH-1:0] count
);
    always @(posedge clk) begin
        if (reset) count <= 0;
        else       count <= count + 1;
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    wire [7:0] count8;
    wire [15:0] count16;

    // Default WIDTH = 8
    counter dut8(.clk(clk), .reset(reset), .count(count8));

    // Override WIDTH to 16 for this instance
    counter #(.WIDTH(16)) dut16(.clk(clk), .reset(reset), .count(count16));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        #40 $display("after 4 clocks: count8=%0d count16=%0d", count8, count16);
        $finish;
    end
endmodule

Tre elementi di sintassi nuovi:

1. Blocco dei parametri: #( parameter WIDTH = 8 ) tra il nome del modulo e l'elenco delle porte. Il valore predefinito 8 è quello che il modulo usa quando nessuno lo sovrascrive.
2. Punto di utilizzo: output reg [WIDTH-1:0] count. Il parametro è solo una costante, che inseriamo nell'intervallo di bit. Lo stesso sorgente produce un'uscita a 8 o 16 bit a seconda di WIDTH.
3. Sintassi di sovrascrittura: counter #(.WIDTH(16)) dut16(...) al momento dell'istanziazione. Il blocco #(...) va prima del nome dell'istanza, dopo il nome del modulo. I parametri che non citi mantengono i valori predefiniti.

localparam: costanti interne

Ci sono costanti che non vuoi far sovrascrivere a chi usa il modulo. Le codifiche degli stati sono il caso classico:

module fsm(input wire clk, input wire reset, input wire go, output reg busy);
    // States are an implementation detail; nobody outside should care.
    localparam IDLE    = 2'd0;
    localparam RUNNING = 2'd1;
    localparam DONE    = 2'd2;

    reg [1:0] state;

    always @(posedge clk) begin
        if (reset) state <= IDLE;
        else begin
            case (state)
                IDLE:    if (go) state <= RUNNING;
                RUNNING: state <= DONE;
                DONE:    state <= IDLE;
            endcase
        end
    end

    always @(*) busy = (state != IDLE);
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    reg go = 0;
    wire busy;

    fsm dut(.clk(clk), .reset(reset), .go(go), .busy(busy));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        #5  go = 1;
        #10 go = 0;
        #40 $finish;
    end

    always @(posedge clk) $display("t=%0t state=%0d busy=%b", $time, dut.state, busy);
endmodule

localparam rende disponibili IDLE, RUNNING e DONE dentro il modulo, ma non sovrascrivibili dall'istanziazione. È la scelta giusta: cambiare dall'esterno quale valore di stato significa IDLE sarebbe da incubo.

Usa parameter per ciò che chi usa il modulo deve poter configurare (larghezze, profondità, opzioni di comportamento) e localparam per tutto il resto. Un pattern comune è ricavare i localparam dai parameter:

parameter WIDTH = 32;
localparam WIDTH_M1 = WIDTH - 1;   // computed once; not overrideable

Larghezze parametriche nella pratica

L'uso più comune dei parametri è rendere flessibili le larghezze dei bus. Ecco un sommatore che funziona con qualsiasi larghezza:

module adder #(
    parameter WIDTH = 8
)(
    input  wire [WIDTH-1:0] a,
    input  wire [WIDTH-1:0] b,
    output wire [WIDTH:0]   sum    // +1 for carry-out
);
    assign sum = a + b;
endmodule

module test;
    reg  [3:0]  a4, b4;
    wire [4:0]  sum4;
    reg  [15:0] a16, b16;
    wire [16:0] sum16;

    adder #(.WIDTH(4))  small(.a(a4),  .b(b4),  .sum(sum4));
    adder #(.WIDTH(16)) big  (.a(a16), .b(b16), .sum(sum16));

    initial begin
        a4  = 4'd9;       b4  = 4'd8;
        a16 = 16'd60000;  b16 = 16'd10000;
        #1;
        $display("small: %0d + %0d = %0d", a4,  b4,  sum4);
        $display("big  : %0d + %0d = %0d", a16, b16, sum16);
        $finish;
    end
endmodule

Un file sorgente, due istanze, due larghezze diverse, nessun copia e incolla. È tutto il vantaggio dei parametri.

Più parametri, sovrascrittura per nome

Nei moduli più grandi avrai spesso diversi parametri. Sovrascrivili per nome, in qualsiasi ordine:

module fifo #(
    parameter WIDTH = 8,
    parameter DEPTH = 16,
    parameter AFULL = DEPTH - 2
)(
    input  wire             clk,
    input  wire             reset,
    // ... ports ...
);
    // ...
endmodule

// At the call site:
fifo #(.WIDTH(32), .DEPTH(1024)) cmd_queue (.clk(clk), .reset(reset), ...);

Non devi sovrascrivere tutti i parametri; quelli non citati mantengono i valori predefiniti. Nell'esempio il valore predefinito di AFULL è calcolato da DEPTH, quindi se sovrascrivi DEPTH, AFULL si adegua automaticamente: è esattamente il tipo di dipendenza che gestirebbe anche un localparam, se non volessi permettere di sovrascrivere AFULL in modo indipendente.

Errori comuni

Dimenticare il # nella sovrascrittura. counter (.WIDTH(16)) dut(...) sembra una sovrascrittura, ma Verilog legge (.WIDTH(16)) come un collegamento di porta. Ti serve counter #(.WIDTH(16)) dut(...).

Usare parametri dove non sono abbastanza costanti. I parametri si risolvono durante l'elaborazione, prima che esista qualsiasi segnale. Non puoi parametrizzare su un segnale a runtime: se il valore dipende da ciò che fa un ingresso durante la simulazione, non è un parametro, è logica.

Confondere parameter e localparam negli elenchi delle porte. Solo parameter va nel blocco #(...) in cima. localparam vive nel corpo. Se li scambi, il compilatore te lo segnala.

Cosa viene dopo

Ora puoi creare moduli la cui dimensione viene fissata in fase di compilazione. Le prossime due pagine trattano le regole per scrivere costanti letterali (8'h1F, 4'b1010, 32'd100) e i valori x e z che compaiono quando i segnali non sono pilotati o sono contesi. Poi passiamo agli operatori: tutto ciò che puoi fare con i vettori e i parametri che hai visto finora.