Instantiasi Module Verilog: Menghubungkan Sub-Module

Module di Dalam Module

Desain Verilog adalah pohon module. Module tingkat atas (testbench-mu, atau wrapper tingkat atas sebuah chip) membuat instance module di tingkat bawahnya, yang membuat instance module di tingkat yang lebih bawah lagi, terus sampai ke primitif gerbang dari vendor. Instantiasi adalah sintaks untuk susunan bertingkat itu.

Kamu sudah pernah melihat bentuknya, karena kita memakainya di Module Pertamamu:

and_gate dut(.a(a), .b(b), .y(y));

Baris itu mencetak satu instance dari and_gate, menamainya dut, dan menghubungkan port-nya ke sinyal lokal. Mari kita uraikan setiap bagiannya.

Bentuk Sebuah Instantiasi

module_name instance_name (port_connections);

• module_name harus cocok dengan nama dari sebuah deklarasi module di suatu tempat dalam proyekmu. Verilog peka huruf besar-kecil.
• instance_name adalah label yang kamu pilih, biasanya menggambarkan peran instance ini. Kamu akan memakainya di path hierarkis dan tampilan waveform.
• port_connections menghubungkan port instance ke sinyal lokal. Ada dua cara menuliskannya.

Koneksi Port Bernama (Pakai yang Ini)

Bentuk bernama terlihat seperti ini:

my_module instance_name(
    .clk    (clk),
    .reset  (reset_n),
    .data_in(in_bus),
    .data_out(out_bus),
    .valid  (out_valid)
);

Setiap pasangan .port(signal) berarti "hubungkan port instance ini yang bernama port ke sinyal lokal bernama signal". Urutannya tidak penting. Kalau kamu menambahkan port baru ke deklarasi module, instantiasi yang sudah ada tidak rusak, selama kamu memberi port baru itu nilai default atau memperbarui setiap tempat pemakaiannya.

Dua catatan praktis:

• Nama port (di kiri tanda kurung) harus persis sama dengan deklarasi module.
• Nama sinyal (di dalam tanda kurung) bersifat lokal di tempat instantiasi berada, biasanya module induknya.

Kalau sebuah port tidak dihubungkan, biarkan bagian dalamnya kosong: .optional_port(). Sinyalnya mengambang (z) di dalam instance. Beberapa tool sintesis memberi peringatan; kebanyakan menerimanya.

Koneksi Port Berdasarkan Posisi (Hindari yang Ini)

Bentuk yang lebih ringkas mencantumkan sinyal sesuai urutan daftar port:

my_module instance_name(clk, reset_n, in_bus, out_bus, out_valid);

Ini lebih pendek tapi rapuh. Ubah urutan daftar port module (refactor sungguhan yang memang terjadi), dan setiap instantiasi berdasarkan posisi diam-diam salah sambung. Jangan pakai gaya berdasarkan posisi kecuali daftar port hanya berisi satu atau dua anggota dan kemungkinan besar tidak akan pernah berubah.

Kapan gaya ini masih bisa diterima: module utilitas kecil di mana urutan port adalah bagian dari API-nya. Gerbang dua input boleh berdasarkan posisi. Kontroler memori dengan 30 port sama saja dengan mencari masalah.

Contoh Hierarki Lengkap

// Half-adder: two inputs, sum and carry-out.
module half_adder(
    input  wire a,
    input  wire b,
    output wire sum,
    output wire carry
);
    assign sum   = a ^ b;
    assign carry = a & b;
endmodule

// Full-adder built from two half-adders + an OR gate.
module full_adder(
    input  wire a,
    input  wire b,
    input  wire cin,
    output wire sum,
    output wire cout
);
    wire sum1, carry1, carry2;

    half_adder ha0(.a(a),    .b(b), .sum(sum1), .carry(carry1));
    half_adder ha1(.a(sum1), .b(cin), .sum(sum), .carry(carry2));

    assign cout = carry1 | carry2;
endmodule

// Testbench: drive the full-adder through every input combination.
module test;
    reg  a, b, cin;
    wire sum, cout;

    full_adder dut(.a(a), .b(b), .cin(cin), .sum(sum), .cout(cout));

    initial begin
        for (integer i = 0; i < 8; i = i + 1) begin
            {a, b, cin} = i[2:0];
            #1 $display("a=%b b=%b cin=%b -> sum=%b cout=%b",
                        a, b, cin, sum, cout);
        end
        $finish;
    end
endmodule

Itu adalah hierarki tiga tingkat yang sungguhan: test → full_adder → dua instance half_adder. Setiap instance punya salinan gerbangnya sendiri dari dalam half_adder; tool sintesis akan menghasilkan satu rangkaian untuk setiap instantiasi.

Banyak Instance dari Module yang Sama

Saat kamu membuat instance module yang sama beberapa kali, setiap instance adalah hardware yang independen. Mereka tidak berbagi state. Mereka tidak berbagi gerbang. Bayangkan setiap instance sebagai salinan baru yang dicetak dari desainnya.

adder add0(.a(a0), .b(b0), .sum(s0));
adder add1(.a(a1), .b(b1), .sum(s1));
adder add2(.a(a2), .b(b2), .sum(s2));
adder add3(.a(a3), .b(b3), .sum(s3));

Itu adalah empat adder terpisah yang berjalan paralel. Kalau adder berisi sebuah register, setiap instance akan punya salinan register itu sendiri, dengan state-nya sendiri.

Loop generate: Mencetak Hardware Berulang

Menulis empat instance secara manual masih tidak masalah. Menulis 64 itu melelahkan. Blok generate membiarkan elaborator mengetikkannya untukmu:

module bit_inverter(input wire x, output wire y);
    assign y = ~x;
endmodule

module wide_inverter #(
    parameter WIDTH = 8
)(
    input  wire [WIDTH-1:0] in,
    output wire [WIDTH-1:0] out
);
    genvar i;
    generate
        for (i = 0; i < WIDTH; i = i + 1) begin : invert_loop
            bit_inverter u_inv(.x(in[i]), .y(out[i]));
        end
    endgenerate
endmodule

module test;
    reg  [7:0] in;
    wire [7:0] out;

    wide_inverter #(.WIDTH(8)) dut(.in(in), .out(out));

    initial begin
        in = 8'b1010_1100;
        #1 $display("in =%b", in);
        $display("out=%b", out);
        $finish;
    end
endmodule

Tiga potong sintaks baru:

• genvar i mendeklarasikan variabel loop yang bisa dipakai di generate. Ini bukan sinyal saat runtime; ia hanya ada saat elaborasi.
• generate ... endgenerate membungkus loop-nya. Beberapa tool menerima loop generate tanpa kata kunci generate yang eksplisit, tapi menuliskannya membuat maksudmu jelas.
• begin : invert_loop memberi label pada scope generate. Label itu menjadi bagian dari nama hierarkis setiap instance yang dihasilkan (dut.invert_loop[0].u_inv, dut.invert_loop[1].u_inv, dan seterusnya).

Synthesizer membuka loop itu dan menghasilkan WIDTH salinan bit_inverter. Setiap salinan adalah hardware yang independen.

Menimpa Parameter saat Instantiasi

Kalau module punya parameter, kamu bisa menimpanya dengan #(.PARAM(value)) di antara nama module dan nama instance:

counter #(.WIDTH(16)) c16 (.clk(clk), .count(out16));
counter #(.WIDTH(32)) c32 (.clk(clk), .count(out32));

Kedua instance memakai sumber counter yang sama tapi lebarnya berbeda. Sintaksnya sudah kita bahas di Parameter; ia masuk dengan rapi ke dalam instantiasi.

Nama Hierarkis

Begitu kamu punya hierarki, setiap sinyal punya path hierarkis:

test.dut.ha0.sum

Cara membacanya: di module test, di dalam instance dut, di dalam instance ha0, sinyal bernama sum. Kamu akan melihat path seperti ini di penampil waveform, pesan error, dan sesekali di panggilan $display yang mengintip jauh ke dalam sub-module dari testbench:

$display("internal carry1 = %b", dut.carry1);

Referensi hierarkis seperti itu hanya untuk testbench dan debug. RTL yang bisa disintesis tidak menjangkau ke dalam module lain.

Kesalahan yang Umum

Nama port tidak cocok. .clk_in(clk) menghubungkan clk lokal ke port bernama clk_in. Kalau port module sebenarnya bernama clk, parser akan memberi tahu (beberapa tool lebih jelas daripada yang lain).

Lebar port tidak cocok. Menghubungkan sinyal 4-bit ke port 8-bit diam-diam menambahkan nol di depan (zero-extend); kebalikannya diam-diam memotong bit. Kebanyakan tool memberi peringatan; kalau kamu tidak melihat peringatan, periksa lebih teliti.

Lupa # untuk parameter. counter (.WIDTH(8)) c(.clk(clk)) terlihat seperti penimpaan parameter, padahal bukan: parser mencoba memperlakukan (.WIDTH(8)) sebagai koneksi port dan gagal. Yang benar: counter #(.WIDTH(8)) c(.clk(clk)).

Memakai ulang nama instance. Dua instance tidak boleh punya nama yang sama dalam scope yang sama. Pesan error-nya biasanya jelas; godaan untuk copy-paste-lah yang menjebakmu.

Selanjutnya

Sekarang kamu bisa menghubungkan module-module menjadi hierarki sungguhan. Dokumen berikutnya, Penugasan Kontinu, melengkapi sisi struktural Verilog dan membahas lebih dalam pernyataan assign yang sudah kita pakai dengan bebas sejak bab pertama.