Port Module Verilog: Penjelasan Input, Output, dan Inout

Antarmuka Sebuah Module

Daftar port module adalah antarmuka-nya: semua yang bisa dilihat dan disentuh dunia luar. Di dalam module, isinya menghitung output dari input. Port adalah kabel yang melintasi batas module.

Deklarasi modern bergaya ANSI menuliskan arah, tipe, dan lebar secara langsung:

module my_module(
    input  wire        clk,
    input  wire        reset,
    input  wire [7:0]  data_in,
    output reg  [7:0]  data_out,
    output wire        valid
);
    // body
endmodule

Itulah seluruh bentuknya. Setiap port punya:

• Arah: input, output, atau inout.
• Tipe: wire atau reg (atau logic di SystemVerilog).
• Lebar: rentang seperti [7:0], atau satu bit kalau tidak ditulis.
• Nama: identifier yang akan kamu pakai di dalam isi module.

Tiga Arah Port

input: Digerakkan dari Luar

Input selalu bertipe wire. Penggeraknya berada di luar module, entah sinyal dari module di tingkat atas atau reg milik testbench. Di dalam module ini, kamu bisa membaca input di ekspresi, tapi tidak pernah boleh memberinya nilai:

module reader(input wire [7:0] data);
    initial $display("data = %h", data);
endmodule

Menulis data = ... di dalam module akan menjadi error.

output: Digerakkan dari Dalam

Output digerakkan oleh sesuatu di dalam module ini. Tipenya bisa wire (digerakkan oleh assign atau output sub-module) atau reg (digerakkan dari always/initial).

module driver(
    input  wire       a,
    input  wire       b,
    input  wire       clk,
    output wire       y,    // wire - driven by assign
    output reg        q     // reg  - driven by always
);
    assign y = a & b;       // OK because y is wire

    always @(posedge clk)
        q <= a;             // OK because q is reg
endmodule

Mencoba memberi nilai ke y di dalam blok always, atau menggerakkan q dengan assign, akan menghasilkan compile error. Pilihan kata kunci harus cocok dengan penggeraknya.

inout: Dua Arah

Port inout adalah kabel yang bisa digerakkan bergantian oleh module itu sendiri atau oleh apa pun yang terhubung di luar. Port ini muncul di batas chip: jalur SDA I²C, pin GPIO dua arah, bus data bersama. Di dalam module, kamu mengatur arahnya dengan pola tri-state:

module bidir_pin(
    input  wire data_out,
    input  wire output_enable,
    output wire data_in,
    inout  wire pin
);
    assign pin     = output_enable ? data_out : 1'bz;
    assign data_in = pin;
endmodule

pin adalah kabel yang dipakai bersama. Saat output_enable bernilai high, module menggerakkan pin ke data_out. Saat low, module melepas pin ke impedansi tinggi (z), sehingga penggerak eksternal bisa memakainya. data_in selalu mengamati apa pun yang sedang ada di pin.

inout jarang dipakai di logika yang murni internal. Kalau kamu membangun kontroler memori, inti CPU, atau pipeline pemrosesan gambar, mungkin kamu tidak akan pernah membutuhkannya. Ini fitur untuk lingkar I/O di batas chip.

Port Satu Bit vs Banyak Bit

Rentang lebar bersifat opsional; hilangkan untuk port satu bit:

input wire valid,         // 1 bit
input wire [7:0] data,    // 8 bits
input wire [31:0] addr,   // 32 bits

Kamu bisa memakai parameter untuk lebar, dan begitulah cara kerja module berparameter:

module bus #(
    parameter WIDTH = 32
)(
    input  wire [WIDTH-1:0] in,
    output wire [WIDTH-1:0] out
);
    assign out = in;
endmodule

Gaya ANSI vs Verilog-1995

Sesekali kamu akan melihat kode lama yang memisahkan daftar port dan deklarasinya:

// Old Verilog-1995 style - DON'T do this in new code
module foo(clk, data_in, data_out);
    input clk;
    input [7:0] data_in;
    output reg [7:0] data_out;
    // ...
endmodule

Daftar port hanya berisi nama; setiap port lalu dideklarasikan terpisah di dalam isi module. Gaya ini bertele-tele, rawan error "disebut di daftar port tapi tidak pernah dideklarasikan", dan butuh ketikan dua kali lebih banyak. Gaya ANSI-2001 (yang dipakai di seluruh dokumentasi ini) menggantikan keduanya:

module foo(
    input  wire       clk,
    input  wire [7:0] data_in,
    output reg  [7:0] data_out
);
    // ...
endmodule

Pakai gaya ANSI. Tool sudah mendukungnya sejak 2001.

Contoh Lengkap

module shifter #(
    parameter WIDTH = 8
)(
    input  wire             clk,
    input  wire             reset,
    input  wire             load,
    input  wire [WIDTH-1:0] data_in,
    input  wire             shift_en,
    output reg  [WIDTH-1:0] data_out,
    output wire             msb_out
);
    // Combinational output - assign drives a wire
    assign msb_out = data_out[WIDTH-1];

    // Sequential output - always drives a reg
    always @(posedge clk) begin
        if (reset)         data_out <= 0;
        else if (load)     data_out <= data_in;
        else if (shift_en) data_out <= data_out << 1;
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    reg load = 0;
    reg shift_en = 0;
    reg [7:0] data_in;
    wire [7:0] data_out;
    wire msb_out;

    shifter #(.WIDTH(8)) dut(
        .clk(clk),
        .reset(reset),
        .load(load),
        .data_in(data_in),
        .shift_en(shift_en),
        .data_out(data_out),
        .msb_out(msb_out)
    );

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;

        data_in = 8'h81;
        #10 load = 1;
        #10 load = 0;

        shift_en = 1;
        #80 $finish;
    end

    always @(posedge clk)
        $display("t=%0t data_out=%b msb_out=%b", $time, data_out, msb_out);
endmodule

Satu module itu punya:

• Sebuah parameter (WIDTH).
• Input untuk clock, reset, load enable, data, dan shift enable.
• Output reg (data_out) yang digerakkan di dalam blok always.
• Output wire (msb_out) yang digerakkan oleh penugasan kontinu.
• Deklarasi lengkap bergaya ANSI yang mencantumkan arah, tipe, dan lebar setiap port secara langsung.

Begitulah bentuk hampir setiap module yang bisa disintesis yang akan kamu tulis.

Selanjutnya

Dokumen berikutnya, Instantiasi Module, menunjukkan cara memakai module ini di dalam desain yang lebih besar. Shifter yang baru kamu tulis tidak berguna sendirian; ia baru bermanfaat saat ada yang membuat instance-nya dan menghubungkannya ke sebuah sistem.