Ghép nối và nhân bản trong Verilog: toán tử {}

Hai toán tử nhỏ nhưng đáng giá

Verilog có hai dạng {}:

1. Ghép nối (concatenation): {a, b, c} gộp nhiều tín hiệu thành một tín hiệu rộng hơn.
2. Nhân bản (replication): {N{pattern}} sao chép một mẫu N lần.

Bạn sẽ dùng cả hai liên tục. Mỗi khi một bus cần được tách, gộp, đệm thêm bit hoặc mở rộng dấu, một trong hai toán tử này chính là câu trả lời.

Ghép nối: {a, b, c}

Trường hợp đơn giản nhất: xếp hai tín hiệu thành một:

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

Đọc từ trái sang phải: a là nửa cao, b là nửa thấp. Toán hạng đầu tiên trong {} là phần có trọng số lớn nhất. Độ rộng kết quả bằng tổng độ rộng các toán hạng.

Bạn có thể ghép bao nhiêu toán hạng cũng được:

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

Và các toán hạng có thể có độ rộng khác nhau:

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

Một quy tắc chung: mọi toán hạng của phép ghép nối phải có độ rộng tường minh. Hằng số không ghi độ rộng (1 thay vì 1'b1) gây lỗi vì trình phân tích không biết phải cấp bao nhiêu bit. Luôn viết 1'b0, 1'b1, 4'd0, đừng bao giờ viết 0 hay 1 trơn trong {}.

Ghép nối ở vế trái

Ghép nối ở vế trái của phép gán tách một tín hiệu rộng trở lại thành các phần:

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

Đây là mẫu bộ cộng có bit nhớ kinh điển. {carry_out, sum_bits} là một đích 9 bit duy nhất ở vế trái phép gán, và các bit được chia ra: bit cao nhất vào carry_out, 8 bit thấp vào sum_bits.

Ghép nối ở vế trái dùng được trong assign lẫn trong các khối thủ tục:

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

Nhân bản: {N{pattern}}

Toán tử nhân bản sao chép một mẫu với số lần cố định. Dạng của nó là {N{pattern}}: một số đếm, rồi đến mẫu nằm trong cặp ngoặc nhọn riêng:

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 phải là hằng số, vì trình biên dịch cần biết độ rộng kết quả ở bước elaboration. Mẫu có thể là hằng số, một parameter hoặc bất kỳ biểu thức nào đã biết độ rộng.

Đừng quên cặp ngoặc bên trong. {8 1'b1} là lỗi cú pháp; {8{1'b1}} mới đúng. Cặp {} bên ngoài là toán tử; cặp {...} bên trong bao lấy mẫu được nhân bản.

Kết hợp cả hai: mở rộng dấu và mở rộng bằng số 0

Hai toán tử này kết hợp rất tự nhiên để tạo giá trị rộng hơn:

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 } là mẫu mở rộng dấu chuẩn. Hãy đọc nó là: lặp bit dấu tám lần, rồi nối thêm 8 bit gốc. Kết quả là biểu diễn bù hai 16 bit của cùng một số.

Với việc mở rộng số không dấu, bạn có thể dựa vào phép gán: Verilog tự động mở rộng bằng số 0 khi đích rộng hơn:

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

Nhưng mở rộng dấu không bao giờ diễn ra ngầm, trừ khi cả toán hạng lẫn đích đều được khai báo signed. Cách nhân bản tường minh an toàn hơn.

Các mẫu hữu ích

Tạo mặt nạ gồm N bit 1

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

Đảo ngược một vector

Verilog không có sẵn hàm đảo ngược, nhưng bạn có thể viết trực tiếp bằng ghép nối:

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

Với vector rộng hơn, một vòng lặp generate hoặc một function sẽ gọn hơn.

Gói các cờ vào một byte trạng thái

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]
};

Các ô dự trữ 1 bit đều có độ rộng tường minh: đừng bao giờ viết 0 trơn trong {}.

Lỗi thường gặp

Hằng số không ghi độ rộng trong {}. {a, 0} là lỗi cú pháp hoặc là một số 0 rộng 32 bit. Luôn ghi độ rộng: {a, 1'b0}.

Quên cặp ngoặc bên trong khi nhân bản. {8 1'b1} không phân tích được; {8{1'b1}} thì được.

Nhầm thứ tự. {a, b} đặt a ở phía cao và b ở phía thấp. Hiểu ngược lại là bạn sẽ có thứ tự byte bị đảo ở đâu đó.

Nhân bản không lần. {0{...}} không hợp lệ trong Verilog chuẩn. SystemVerilog cho phép (và tạo ra kết quả rộng 0 bit). Verilog thuần sẽ từ chối.

Tiếp theo

Giờ bạn đã gặp mọi toán tử của Verilog. Chương tiếp theo chuyển hướng sang cấu trúc: cách các module kết nối với nhau, quy tắc về cổng và cú pháp khởi tạo module con để xây dựng thiết kế lớn hơn.