Menguasai Parameter di Verilog: Sintaks, Contoh, dan Praktik Terbaik

By 佐川 直弘 | Naohiro Sagawa (運営者)

※記事内に広告を含みます。Amazonアソシエイトとして適格販売により収入を得ています。

1. Pendahuluan

Apa itu parameter dalam Verilog?

Mengapa parameter penting?

• Kegunaan kembali yang lebih baik – Modul dapat dipakai kembali dalam banyak proyek, memungkinkan pengembangan yang efisien bahkan pada desain berskala besar.
• Pemeliharaan yang lebih mudah – Karena konstanta d tempat perubahan hanya memerlukan pembaruan pada parameter yang bersangkutan.
• Keterbacaan yang meningkat – Dengan menghindari “angka ajaib” dan memberi nama yang jelas pada nilai‑nilai, kode Anda menjadi jauh lebih mudah dipahami oleh orang lain.

Apa yang akan Anda pelajari dalam artikel ini

• Pemula yang baru mulai belajar Verilog
• Insinyur menengah yang menginginkan desain modul yang lebih fleksibel
• Desainer yang ingin pemeliharaan dan keterbacaan kode

2. Sintaks Dasar parameter

Cara mendeklarasikan parameter

parameter parameter_name = value;

parameter DATA_WIDTH = 8;

Mendefinisikan beberapa parameter sekaligus

parameter WIDTH = 8, DEPTH = 256;

parameter WIDTH = 8;
parameter DEPTH = 256;

Menentukan lebar bit

parameter [7:0] INIT_VALUE = 8'hFF;

Lingkup dan redefinisi parameter

3. Memparameterisasi Modul dengan parameter

Menambahkan fleksibilitas pada modul dengan parameter

Contoh: Modul penjumlah yang diparameterisasi

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

Cara mengganti parameter dari modul tingkat atas

1. Menggunakan sintaks #()

adder #(.WIDTH(16)) adder_inst (
    .a(a_input),
    .b(b_input),
    .sum(sum_output)
);

2. Menggunakan defparam (tidak disarankan)

defparam adder_inst.WIDTH = 16;

Contoh: Mengganti beberapa parameter sekaligus

module fifo #(parameter DATA_WIDTH = 8, DEPTH = 64)(/* ports */);

// Instantiation in top-level module
fifo #(
    .DATA_WIDTH(16),
    .DEPTH(128)
) fifo_inst (
    /* connections */
);

4. Aplikasi parameter

Membuat lebar bit dan ukuran bus dapat dikonfigurasi

module register #(parameter WIDTH = 8)(
    input  wire clk,
    input  wire [WIDTH-1:0] d,
    output reg  [WIDTH-1:0] q
);
    always @(posedge clk)
        q <= d;
endmodule

Manajemen terpusat nilai desain untuk keterbacaan dan pemeliharaan

parameter CLK_DIV = 100;

always @(posedge clk)
    if (counter == CLK_DIV)
        clk_out <= ~clk_out;

Mengontrol pengulangan struktural dengan generate

module shift_reg #(parameter STAGES = 4)(
    input wire clk,
    input wire in,
    output wire out
);
    reg [STAGES-1:0] shift;

    always @(posedge clk)
        shift <= {shift[STAGES-2:0], in};

    assign out = shift[STAGES-1];
endmodule

Menggunakan parameter dalam testbench

module testbench;
    parameter DATA_WIDTH = 16;

    reg [DATA_WIDTH-1:0] a, b;
    wire [DATA_WIDTH-1:0] result;

    adder #(.WIDTH(DATA_WIDTH)) dut (
        .a(a),
        .b(b),
        .sum(result)
    );

    // Test logic...
endmodule

5. Praktik Terbaik dan Peringatan Saat Menggunakan parameter

Selalu tentukan lebar bit secara eksplisit

parameter [7:0] INIT_VAL = 8'hFF;  // Explicitly defined as 8-bit

Pahami perbedaan antara parameter dan localparam

module example #(parameter WIDTH = 8) ();
    localparam HALF_WIDTH = WIDTH / 2;
endmodule

Redefinisi dan masalah hierarki

• Gunakan konvensi penamaan yang jelas (misalnya FIFO_DEPTH, ALU_WIDTH).
• Perhatikan ruang lingkup parameter di dalam setiap modul.

Sadari keterbatasan alat sintesis

• Operasi aritmetika pada parameter dengan lebar bit eksplisit dapat berperilaku berbeda antar alat.
• Interpretasi signed vs. unsigned dapat bervariasi.
• defparam sering kali sudah usang atau tidak didukung pada alat modern.

6. FAQ: Pertanyaan yang Sering Diajukan

Q1. Apa perbedaan antara parameter dan localparam?

• parameter : Fleksibel, tetapi harus ditangani dengan hati‑hati agar tidak terjadi timpa yang tidak diinginkan.
• localparam : Cocok untuk konstanta internal yang tidak boleh diubah secara eksternal.

• Ingin modul dapat dipakai kembali → gunakan parameter
• Membutuhkan nilai tetap untuk stabilitas desain → gunakan localparam

Q2. Apa yang terjadi jika saya tidak menentukan lebar bit pada sebuah parameter?

parameter WIDTH = 8;  // Actually 32-bit wide

parameter [7:0] WIDTH = 8;

Q3. Apakah parameter harus selalu berupa konstanta?

input [7:0] a;
parameter WIDTH = a; // Error

parameter WIDTH = 8;

Q4. Bagaimana perubahan nilai parameter memengaruhi implementasi FPGA?

Q5. Bisakah saya menggunakan operasi aritmetika atau logika di dalam parameter?

parameter WIDTH = 8;
parameter HALF_WIDTH = WIDTH / 2;

7. Kesimpulan

Poin-poin penting

• parameter mendefinisikan konstanta dalam sebuah modul, secara signifikan meningkatkan kemampuan penggunaan kembali dan pemeliharaan desain.
• Dengan menggunakan sintaks #() saat instansiasi, parameter dapat ditimpa secara dinamis dari modul induk.
• Ketika digabungkan dengan generate, pengulangan struktural dan desain kondisional dapat dikontrol secara fleksibel.
• Perhatikan spesifikasi lebar bit, perbedaan antara localparam dan parameter, serta perilaku yang bergantung pada alat.
• FAQ mencakup kesalahpahaman umum dan jebakan desain.

Pemikiran akhir