Vektor dan Array di Verilog: Penjelasan Sinyal Multi-Bit

Satu Kabel vs Banyak Kabel

Sejauh ini setiap sinyal yang kita lihat lebarnya satu bit. Desain sungguhan hampir tidak pernah seperti itu: alamat lebarnya 16 atau 32 bit, bus data 8 atau 64, piksel RGB 24. Verilog memberimu satu mekanisme untuk membuat sinyal apa pun menjadi multi-bit: tambahkan rentang di dalam kurung siku.

wire [7:0] data;       // 8-bit wire, bit 7 is MSB, bit 0 is LSB
reg  [15:0] address;   // 16-bit reg
output reg [31:0] result; // 32-bit module output

Angka di dalam kurung siku adalah posisi bit dari bit paling signifikan dan paling tidak signifikan. [7:0] berarti "sinyal ini punya bit bernomor 7 turun sampai 0", jadi totalnya 8 bit. Angka pertama adalah indeks tertinggi. Angka kedua yang terendah.

Sesekali kamu akan melihat [0:7]: jumlah bitnya sama, tapi urutannya terbalik saat dipotong. Bentuk [high:low] adalah konvensi yang sangat dominan di industri; tetaplah memakainya kecuali kamu punya alasan kuat untuk tidak melakukannya.

Contoh Lengkap: Adder 8-Bit

module adder8(
    input  wire [7:0] a,
    input  wire [7:0] b,
    output wire [8:0] sum
);
    // 8 bits + 8 bits can produce a 9-bit result (a carry out).
    assign sum = a + b;
endmodule

module test;
    reg  [7:0] a, b;
    wire [8:0] sum;

    adder8 dut(.a(a), .b(b), .sum(sum));

    initial begin
        a = 8'd10;  b = 8'd20;   #1 $display("%0d + %0d = %0d", a, b, sum);
        a = 8'd200; b = 8'd100;  #1 $display("%0d + %0d = %0d", a, b, sum);
        a = 8'hFF;  b = 8'h01;   #1 $display("%h + %h = %h",   a, b, sum);
        $finish;
    end
endmodule

Setiap + menjumlahkan dua vektor 8-bit dan menghasilkan hasil 9-bit. Literal angka seperti 8'd10 berarti "nilai desimal 10 dengan lebar 8 bit"; kita akan membahasnya di Literal Angka.

Memotong: Mengambil Bit Tertentu

Begitu kamu punya vektor, kamu bisa mengambil bit satu per satu atau rentang yang berurutan:

module slicing(input wire [15:0] data);
    initial begin
        $display("full data   = %b", data);
        $display("low byte    = %b", data[7:0]);
        $display("high byte   = %b", data[15:8]);
        $display("nibble[3:1] = %b", data[3:1]);
        $display("bit 9       = %b", data[9]);
    end
endmodule

module test;
    initial begin
        force test.dut.data = 16'b1010_1100_0011_0101;
        #1 $finish;
    end

    slicing dut();
endmodule

Jangan terlalu memikirkan baris force di testbench; kita hanya butuh cara untuk menyuntikkan nilai demi memperagakan pemotongan. Bagian yang menarik adalah potongan-potongannya.

Beberapa aturan:

• Arah potongan harus sama dengan deklarasinya. Kalau kamu mendeklarasikan [7:0], potong dengan [high:low]. Membalik arahnya adalah syntax error.
• Memotong di luar rentang menghasilkan x (tidak diketahui) di simulasi. Tool sintesis mungkin memberi peringatan atau error.
• Pemilihan bit berbasis nol sesuai indeks yang kamu tulis: data[0] adalah bit bernama 0, yang (untuk deklarasi [7:0]) adalah LSB.

Potongan dengan Basis Variabel: +: dan -:

Kebutuhan yang umum: "beri aku 8 bit mulai dari bit N". Kamu tidak bisa langsung menulis data[N+7:N] karena Verilog mengharuskan kedua ujung rentang berupa konstanta. Sintaks yang menyelesaikan masalah ini:

data[base +: width]   // width bits starting at `base`, going UP
data[base -: width]   // width bits starting at `base`, going DOWN

module variable_slice;
    reg [31:0] word = 32'hDEAD_BEEF;

    initial begin
        for (integer i = 0; i < 4; i = i + 1) begin
            $display("byte %0d = %h", i, word[i*8 +: 8]);
        end
        $finish;
    end
endmodule

Lebarnya konstan (kita mengambil 8 bit sekaligus), tapi basisnya bisa berupa ekspresi saat runtime. Itulah yang kamu butuhkan untuk memori yang dialamatkan per byte, tap pada shift register, dan sejenisnya.

Array: Selangkah Setelah Vektor

Vektor adalah satu sinyal multi-bit. Array adalah kumpulan vektor yang diindeks secara independen:

reg [31:0] mem [0:1023];

Deklarasi itu punya dua rentang, dan keduanya punya arti yang berbeda:

• [31:0] adalah dimensi packed: lebar setiap word.
• [0:1023] adalah dimensi unpacked: berapa banyak word yang ada.

Jadi mem adalah 1024 register 32-bit yang terpisah. Kamu mengakses salah satunya dengan satu indeks:

mem[5] = 32'hCAFE_BABE;       // write word 5
data   = mem[address];        // read the word at `address`

module memory_demo;
    reg [7:0] mem [0:7];   // 8 bytes
    integer i;

    initial begin
        for (i = 0; i < 8; i = i + 1) mem[i] = i * i;

        for (i = 0; i < 8; i = i + 1)
            $display("mem[%0d] = %0d", i, mem[i]);

        $finish;
    end
endmodule

Itu adalah memori kecil yang berisi bilangan kuadrat. Desain sungguhan memakai pola yang sama untuk menyimpan register file, tabel lookup, FIFO, dan penyimpanan lain di dalam chip yang lebih besar dari satu vektor.

Packed vs Unpacked: Kenapa Ini Penting

Pembagian antara dimensi packed dan unpacked muncul di mana-mana. Tahu mana yang mana akan menghemat banyak waktu debug:

• Vektor packed adalah satu sinyal. Kamu bisa memperlakukan seluruhnya sebagai angka: data + 1 berfungsi, data == 32'h0 berfungsi, data[7:0] berfungsi.
• Array unpacked adalah banyak sinyal. Kamu tidak bisa memperlakukan seluruhnya sebagai angka: mem + 1 adalah syntax error. Kamu harus mengambil word tertentu dulu.

Beberapa dimensi packed sekaligus juga sah:

reg [3:0][7:0] regs;   // 4 bytes packed together into a 32-bit signal

regs[0] adalah satu byte (byte terendah). regs secara keseluruhan selebar 32 bit. SystemVerilog banyak memakai bentuk ini.

Beberapa dimensi unpacked sekaligus membuat memori 2D:

reg [31:0] frame [0:479][0:639];  // 480x640 of 32-bit pixels

Kamu mengakses satu piksel dengan frame[y][x]. Beginilah bentuk buffer gambar di HDL.

Selanjutnya

Sekarang kamu bisa mendeklarasikan dan mengolah sinyal selebar apa pun yang kamu butuhkan. Dokumen berikutnya, Parameter, menunjukkan cara membuat lebar itu bisa dikonfigurasi, sehingga module yang sama bekerja dengan 8 bit di satu instance dan 32 bit di instance lain. Setelah itu kita lanjut ke aturan menulis angka literal (8'b1010_1100, 32'hDEAD_BEEF), dan nilai x/z yang muncul setiap kali ada sesuatu yang tidak digerakkan.