Parameter Verilog: Membuat Module yang Bisa Dikonfigurasi

Konstanta dengan Sedikit Kejutan

parameter adalah konstanta: compiler menentukan nilainya dan menanamkannya ke dalam desain sebelum simulasi dimulai. Kejutannya, siapa pun yang membuat instance module bisa mengubah nilainya. File sumber module yang sama bisa menghasilkan rangkaian dengan ukuran berbeda, tergantung bagaimana pemakainya mengatur parameternya.

Begitulah cara membangun IP yang bisa dipakai ulang. Module FIFO dengan parameter WIDTH dan DEPTH bisa melayani setiap tim di sebuah perusahaan. Counter dengan parameter WIDTH memakai sumber yang sama, entah menghitung sampai 16 atau sampai 4 miliar.

Deklarasi Parameter Dasar

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

Tiga potong sintaks baru:

1. Blok parameter: #( parameter WIDTH = 8 ) di antara nama module dan daftar port. Nilai default 8 adalah nilai yang dipakai module saat tidak ada yang menimpanya.
2. Tempat pemakaian: output reg [WIDTH-1:0] count. Parameter hanyalah konstanta: kita memasukkannya ke rentang bit. Sumber module yang sama menghasilkan output 8-bit atau 16-bit tergantung WIDTH.
3. Sintaks penimpaan: counter #(.WIDTH(16)) dut16(...) saat instantiasi. Blok #(...) ditaruh sebelum nama instance, setelah nama module. Parameter yang tidak kamu sebutkan tetap memakai nilai default-nya.

localparam: Konstanta Internal

Ada konstanta yang tidak ingin kamu biarkan ditimpa oleh pemakai module. Encoding state adalah contoh klasiknya:

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 membuat IDLE, RUNNING, DONE tersedia di dalam module, tapi tidak bisa ditimpa saat instantiasi. Itu pilihan yang tepat: mengubah nilai state mana yang berarti IDLE dari luar module akan sangat menakutkan.

Pakai parameter untuk hal-hal yang sebaiknya bisa dikonfigurasi pemakai (lebar, kedalaman, opsi perilaku) dan localparam untuk sisanya. Pola yang umum adalah menurunkan localparam dari parameter:

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

Lebar Berparameter dalam Praktik

Pemakaian parameter yang paling umum adalah membuat lebar bus menjadi fleksibel. Ini adder yang bekerja di lebar berapa pun:

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

Satu file sumber, dua instance, dua lebar berbeda, tanpa copy-paste. Itulah seluruh manfaat parameter.

Banyak Parameter, Penimpaan Bernama

Untuk module yang lebih besar, sering kali kamu punya beberapa parameter. Timpa berdasarkan nama, dengan urutan bebas:

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), ...);

Kamu tidak harus menimpa setiap parameter; yang tidak disebutkan tetap memakai nilai default-nya. Default AFULL di contoh dihitung dari DEPTH, artinya kalau kamu menimpa DEPTH, AFULL otomatis ikut. Ketergantungan seperti ini juga bisa ditangani localparam kalau kamu tidak ingin pemakai bisa menimpa AFULL secara terpisah.

Kesalahan yang Umum

Lupa # saat menimpa. counter (.WIDTH(16)) dut(...) terlihat seperti penimpaan, tapi Verilog membaca (.WIDTH(16)) sebagai koneksi port. Kamu butuh counter #(.WIDTH(16)) dut(...).

Memakai parameter untuk nilai yang tidak cukup konstan. Parameter ditentukan saat elaborasi, sebelum ada sinyal apa pun. Kamu tidak bisa membuat parameter dari sinyal saat runtime: kalau nilainya bergantung pada apa yang dilakukan sebuah input saat simulasi, itu bukan parameter, melainkan logika.

Tertukar parameter dan localparam di daftar port. Hanya parameter yang masuk ke blok #(...) di bagian atas. localparam berada di dalam isi module. Compiler akan memberi tahu kalau kamu menukarnya.

Selanjutnya

Sekarang kamu bisa membuat module yang ukurannya ditentukan saat compile. Dua dokumen berikutnya membahas aturan menulis konstanta literal (8'h1F, 4'b1010, 32'd100) dan nilai x serta z yang muncul saat sinyal tidak digerakkan atau diperebutkan. Setelah itu kita lanjut ke operator: semua yang bisa kamu lakukan dengan vektor dan parameter yang sudah kamu lihat.