Khối always trong Verilog: logic tổ hợp và logic tuần tự

Công cụ chủ lực của Verilog hành vi

assign mô tả logic tổ hợp gồm một phương trình duy nhất. Ngay khi cần if/else, case hoặc bộ nhớ, bạn sẽ dùng đến always. Khối always là một đoạn code thủ tục chạy lại mỗi khi những tín hiệu cụ thể thay đổi. Các tín hiệu kích hoạt việc chạy lại đó gọi là sensitivity list (danh sách độ nhạy).

Có hai dạng always mà bạn sẽ gặp nhiều nhất:

1. always @(*): chạy lại mỗi khi bất kỳ tín hiệu nào được đọc trong khối thay đổi. Tạo ra logic tổ hợp.
2. always @(posedge clk): chỉ chạy lại ở sườn lên của clk. Tạo ra logic tuần tự theo clock (flip-flop).

Còn có các dạng khác (@(a or b), @(negedge clk), @(posedge clk or negedge reset_n)), nhưng hai dạng trên chiếm gần như mọi khối tổng hợp được mà bạn sẽ viết.

always @(*) tổ hợp

module decoder3(
    input  wire [2:0] sel,
    output reg  [7:0] out
);
    always @(*) begin
        case (sel)
            3'd0: out = 8'b0000_0001;
            3'd1: out = 8'b0000_0010;
            3'd2: out = 8'b0000_0100;
            3'd3: out = 8'b0000_1000;
            3'd4: out = 8'b0001_0000;
            3'd5: out = 8'b0010_0000;
            3'd6: out = 8'b0100_0000;
            3'd7: out = 8'b1000_0000;
            default: out = 8'b0;
        endcase
    end
endmodule

module test;
    reg [2:0] sel;
    wire [7:0] out;
    decoder3 dut(.sel(sel), .out(out));

    initial begin
        for (integer i = 0; i < 8; i = i + 1) begin
            sel = i[2:0];
            #1 $display("sel=%0d out=%b", sel, out);
        end
        $finish;
    end
endmodule

Ba điều cần để ý:

• out là reg. Mọi thứ được gán bên trong always đều phải là reg. Từ khóa này không có nghĩa "đây là một flip-flop"; ở đây nó chỉ có nghĩa "tôi được ghi từ một khối thủ tục".
• always @(*). Dấu * nghĩa là "thức dậy mỗi khi bất cứ thứ gì tôi đọc thay đổi". Trình mô phỏng tự xác định sensitivity list. Bạn có thể tự viết danh sách, ví dụ always @(sel), nhưng @(*) an toàn hơn vì bỏ sót một tín hiệu là nguồn bug kinh điển.
• Không có clock. Khối này mô tả logic tổ hợp. Công cụ tổng hợp tạo ra một khối logic tính out trực tiếp từ sel: không có flip-flop, không cần chân clock.

Nhánh default không bắt buộc về cú pháp, nhưng về bản chất thì nên coi là bắt buộc. Bỏ nó đi thì mọi giá trị đầu vào không được liệt kê sẽ khiến out giữ giá trị cũ, và điều đó được tổng hợp thành một latch ngoài ý muốn. Luôn thêm nhánh default.

always @(posedge clk) tuần tự

module counter4(
    input  wire       clk,
    input  wire       reset,
    output reg  [3:0] count
);
    always @(posedge clk) begin
        if (reset) count <= 4'd0;
        else       count <= count + 4'd1;
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    wire [3:0] count;

    counter4 dut(.clk(clk), .reset(reset), .count(count));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        #80 $finish;
    end

    always @(posedge clk)
        $display("t=%0t count=%0d", $time, count);
endmodule

Những khác biệt chính so với bản tổ hợp:

• always @(posedge clk). Khối chỉ chạy lại ở sườn lên của clk. Giữa hai sườn không có gì xảy ra.
• Phép gán non-blocking <=. Bên trong một khối theo clock, đây là toán tử đúng. Nó có nghĩa "lên lịch để count nhận giá trị mới vào cuối bước thời gian", đúng như cách một flip-flop hoạt động. Lý do và cách làm thay thế có trong Blocking và non-blocking.
• Không cần default. Lệnh if đã bao cả hai nhánh (reset và không reset). Không có nguy cơ sinh latch.

Công cụ tổng hợp nhận ra dạng này (sensitivity theo clock, phép gán non-blocking) và tạo ra một thanh ghi 4 bit (bốn flip-flop), cùng logic tổ hợp tính count + 1 và bộ mux chọn giữa reset và tăng giá trị.

Khác biệt khi tổng hợp

Cùng một mã nguồn module có thể mô tả hai phần cứng hoàn toàn khác nhau, tùy vào dạng của khối always:

Trường hợp thứ ba là cái bẫy latch. Latch là một ô nhớ trong suốt, giữ nguyên đầu ra khi đầu vào không được kích hoạt: hữu ích trong một số thiết kế đặc thù, nhưng gần như luôn là bug khi xuất hiện ngoài ý muốn. Hầu hết công cụ tổng hợp đều cảnh báo rõ khi suy ra một latch mà bạn không yêu cầu. Hãy coi cảnh báo đó là lỗi.

Các biến thể của sensitivity list

Bạn sẽ gặp một vài dạng sensitivity list ít phổ biến hơn:

• always @(a or b or c): danh sách tường minh. Verilog-2001 thêm dấu phân cách ,: always @(a, b, c). Cách nào cũng được.
• always @(posedge clk or negedge reset_n): reset bất đồng bộ. Khối chạy ở sườn lên của clock hoặc sườn xuống của reset. Dùng khi reset phải có hiệu lực ngay lập tức, không chờ đến clock kế tiếp.
• always @(negedge clk): chạy theo sườn xuống của clock. Hiếm gặp; một số thiết kế dùng nó cho flip-flop "kích hoạt sườn âm", lưu dữ liệu ở sườn xuống thay vì sườn lên.

Với thiết kế mới, hãy ưu tiên always @(*) cho logic tổ hợp và always @(posedge clk) cho logic tuần tự. Chỉ dùng reset bất đồng bộ khi thiết kế thực sự cần.

Hai khối là hai phần cứng

Nhiều khối always trong cùng một module là độc lập với nhau, mỗi khối trở thành một phần cứng riêng:

module two_blocks(
    input  wire       clk,
    input  wire       reset,
    input  wire [7:0] in,
    output reg  [7:0] reg_out,    // sequential
    output reg  [7:0] comb_out    // combinational
);
    always @(posedge clk) begin
        if (reset) reg_out <= 8'd0;
        else       reg_out <= in;
    end

    always @(*) begin
        comb_out = in ^ 8'hFF;     // bitwise invert
    end
endmodule

module test;
    reg clk = 0, reset = 1;
    reg [7:0] in;
    wire [7:0] reg_out, comb_out;

    two_blocks dut(.clk(clk), .reset(reset), .in(in),
                   .reg_out(reg_out), .comb_out(comb_out));

    always #5 clk = ~clk;

    initial begin
        in = 8'h00; #12 reset = 0;
        in = 8'hA5; #10;
        in = 8'h3C; #10;
        $finish;
    end

    always @(posedge clk)
        $display("t=%0t in=%h reg_out=%h comb_out=%h",
                 $time, in, reg_out, comb_out);
endmodule

Khối theo clock tạo ra một thanh ghi flip-flop. Khối tổ hợp tạo ra một cổng XOR. Chúng nằm cạnh nhau và không khối nào biết đến khối kia. Hai đầu ra thay đổi theo những lịch hoàn toàn khác nhau.

Những gì khối always không làm được

Một vài điều trông hấp dẫn nhưng không được phép:

• Gán cho một wire: đích phải là reg. Trình biên dịch bắt buộc điều này.
• Gán cho cùng một reg từ hai khối always khác nhau: gây ra hành vi không xác định khi mô phỏng và không tổng hợp được. Mỗi tín hiệu chỉ có một nguồn điều khiển.
• Đọc và ghi cùng một tín hiệu trong cùng một khối tổ hợp theo cách tạo ra vòng phản hồi: always @(*) x = x + 1; là một vòng lặp không độ trễ mà trình mô phỏng không giải được.

Hai lỗi đầu trình biên dịch bắt được. Lỗi thứ ba đôi khi chỉ lộ ra lúc mô phỏng dưới dạng chương trình bị treo.

Tiếp theo là gì

Tài liệu tiếp theo, Khối initial, nói về người anh em của always: một khối chạy đúng một lần khi bắt đầu mô phỏng. Đó là công cụ chủ lực của testbench. Sau đó là các quy tắc về phép gán blocking và non-blocking, quyết định khối theo clock của bạn có làm đúng điều bạn muốn hay không.