Concatenation dan Replikasi di Verilog: Operator {}

Dua Operator Kecil yang Sangat Berguna

Verilog punya dua bentuk {}:

1. Concatenation: {a, b, c} menyambung beberapa sinyal menjadi satu sinyal yang lebih lebar.
2. Replikasi: {N{pattern}} menyalin sebuah pola sebanyak N kali.

Kamu akan terus memakai keduanya. Setiap kali sebuah bus perlu dipecah, disatukan, diberi padding, atau di-sign-extend, salah satu dari dua operator inilah jawabannya.

Concatenation: {a, b, c}

Kasus paling sederhana: menumpuk dua sinyal menjadi satu:

module concat_demo;
    wire [3:0] a = 4'hA;
    wire [3:0] b = 4'h5;
    wire [7:0] combined = {a, b};   // 8 bits: AAAA_0101

    initial begin
        $display("a        = %b (%h)", a, a);
        $display("b        = %b (%h)", b, b);
        $display("combined = %b (%h)", combined, combined);
        $finish;
    end
endmodule

Dibaca dari kiri ke kanan: a adalah separuh atas, b separuh bawah. Operand pertama di dalam {} adalah yang paling signifikan. Lebar hasilnya adalah jumlah lebar semua operand.

Kamu bisa menyambung operand sebanyak apa pun:

wire [31:0] word = {byte3, byte2, byte1, byte0};

Dan lebar operand-nya boleh berbeda-beda:

wire [11:0] frame = {start_bit, data_byte, parity, stop_bit};
//                    1 bit      8 bits     1 bit   2 bits  = 12

Aturan yang umum: semua operand concatenation harus punya lebar yang eksplisit. Literal tanpa ukuran (1 alih-alih 1'b1) menyebabkan error karena parser tidak tahu berapa banyak bit yang harus dialokasikan. Selalu tulis 1'b0, 1'b1, 4'd0, jangan pernah 0 atau 1 begitu saja di dalam {}.

Concatenation di Sisi Kiri

Concatenation di sisi kiri (LHS) penugasan memecah sinyal lebar kembali menjadi bagian-bagiannya:

module split;
    wire [7:0] a = 8'd200;
    wire [7:0] b = 8'd100;
    wire [8:0] full_sum = a + b;
    wire carry_out;
    wire [7:0] sum_bits;

    // Split the 9-bit sum into a carry bit and an 8-bit sum
    assign {carry_out, sum_bits} = full_sum;

    initial begin
        #1 $display("a + b = %0d, carry_out=%b, sum_bits=%0d",
                    full_sum, carry_out, sum_bits);
        $finish;
    end
endmodule

Itulah pola baku adder dengan carry. {carry_out, sum_bits} adalah satu tujuan 9-bit di sisi kiri penugasan, dan bit-bitnya dibagikan: bit teratas ke carry_out, 8 bit bawah ke sum_bits.

Concatenation di LHS bisa dipakai di assign maupun di blok prosedural:

always @(posedge clk) begin
    {high_byte, low_byte} <= incoming_word;
end

Replikasi: {N{pattern}}

Operator replikasi menyalin sebuah pola sebanyak jumlah yang tetap. Bentuknya {N{pattern}}: jumlahnya, lalu polanya di dalam pasangan kurung kurawal tersendiri:

module replicate;
    initial begin
        $display("{8{1'b1}}        = %b", {8{1'b1}});         // 11111111
        $display("{4{1'b1}}        = %b", {4{1'b1}});         // 1111
        $display("{4{2'b10}}       = %b", {4{2'b10}});        // 10101010
        $display("{2{4'hA}}        = %h", {2{4'hA}});         // AA
        $display("{3{3'b101}}      = %b", {3{3'b101}});       // 101101101
        $finish;
    end
endmodule

N harus berupa konstanta, karena compiler perlu tahu lebar hasilnya saat elaborasi. Polanya bisa berupa literal, parameter, atau ekspresi apa pun yang lebarnya diketahui.

Jangan lupa kurung kurawal bagian dalam. {8 1'b1} adalah syntax error; {8{1'b1}} yang benar. {} bagian luar adalah operatornya; {...} bagian dalam membungkus pola yang direplikasi.

Menggabungkan Keduanya: Sign Extension dan Zero Extension

Kedua operator ini bisa digabungkan dengan alami untuk membangun nilai yang lebih lebar:

module extension;
    wire [7:0] a_unsigned = 8'h7F;
    wire [7:0] a_negative = 8'hFF;   // would be -1 as signed

    // Zero-extend to 16 bits
    wire [15:0] zext = {8'b0, a_unsigned};

    // Sign-extend to 16 bits: replicate the top bit of a_negative
    wire [15:0] sext = { {8{a_negative[7]}}, a_negative };

    initial begin
        $display("a_unsigned    = %b -> zext = %b", a_unsigned, zext);
        $display("a_negative    = %b -> sext = %b", a_negative, sext);
        $finish;
    end
endmodule

{ {8{a_negative[7]}}, a_negative } adalah pola sign extension yang standar. Bacalah begini: replikasi bit tanda delapan kali, lalu sambungkan 8 bit aslinya. Hasil akhirnya: representasi two's complement 16-bit dari angka yang sama.

Untuk pelebaran unsigned, kamu bisa mengandalkan penugasan, karena Verilog otomatis melakukan zero-extend saat tujuannya lebih lebar:

wire [15:0] zext_auto = a_unsigned;   // works, top 8 bits are 0

Tapi sign extension tidak pernah terjadi secara implisit kecuali operand dan tujuannya sama-sama dideklarasikan signed. Idiom replikasi yang eksplisit lebih aman.

Pola yang Berguna

Membangun Mask Berisi N Angka Satu

parameter N = 5;
wire [31:0] mask = { {32-N{1'b0}}, {N{1'b1}} };
// e.g. with N=5, mask = 32'h0000_001F

Membalik Urutan Vektor

Verilog tidak punya fungsi reverse bawaan, tapi kamu bisa menulisnya langsung dengan concatenation:

wire [3:0] forward  = 4'b1010;
wire [3:0] reversed = {forward[0], forward[1], forward[2], forward[3]};
// reversed = 4'b0101

Untuk vektor yang lebih lebar, loop generate atau sebuah function lebih rapi.

Mengemas Flag ke Byte Status

wire [7:0] status = {
    error_flag,    // [7]
    overflow,      // [6]
    underflow,     // [5]
    ready,         // [4]
    busy,          // [3]
    1'b0,          // [2] reserved
    1'b0,          // [1] reserved
    valid          // [0]
};

Slot cadangan 1-bit itu punya lebar yang eksplisit: jangan pernah 0 begitu saja di dalam {}.

Kesalahan yang Umum

Literal tanpa ukuran di dalam {}. {a, 0} adalah syntax error atau nol selebar 32 bit. Selalu beri ukuran: {a, 1'b0}.

Lupa kurung kurawal dalam di replikasi. {8 1'b1} tidak bisa di-parse; {8{1'b1}} bisa.

Tertukar urutannya. {a, b} menaruh a di sisi atas dan b di sisi bawah. Kalau anggapanmu terbalik, urutan byte-mu akan terbalik di suatu tempat.

Mereplikasi nol kali. {0{...}} tidak sah di Verilog standar. SystemVerilog mengizinkannya (dan menghasilkan hasil selebar nol). Verilog biasa akan menolaknya.

Selanjutnya

Sekarang kamu sudah melihat setiap operator Verilog. Bab berikutnya berganti arah dan masuk ke struktur: bagaimana module saling terhubung, aturan port, dan sintaks untuk membuat instance sub-module guna membangun desain yang lebih besar.