Logic theo clock Verilog: flip-flop, thanh ghi, pipeline

Viên gạch nền: D flip-flop

Mọi thứ trong thiết kế đồng bộ đều quy về một linh kiện phần cứng nhỏ xíu: D flip-flop. Nó có một đầu vào clock, một đầu vào dữ liệu và một đầu ra dữ liệu. Ở mỗi sườn lên của clock, nó chốt giá trị của D và giữ nguyên cho đến sườn kế tiếp. Chỉ vậy thôi.

Trong Verilog:

always @(posedge clk) begin
    q <= d;
end

Ba dòng, một flip-flop. Toán tử <= là phép gán non-blocking, đúng với hành vi của flip-flop thật (xem bài Blocking và non-blocking). Danh sách độ nhạy posedge clk chính là thứ khiến khối này trở thành logic tuần tự.

Xếp nhiều flip-flop như vậy với logic tổ hợp ở giữa, bạn có thể dựng bất kỳ mạch đồng bộ nào mình muốn.

Thanh ghi có reset

Thiết kế thật luôn cần reset, tức một cách đưa hệ thống về trạng thái đã biết khi cấp nguồn hoặc khi cần:

module reg_with_reset #(
    parameter WIDTH = 8
)(
    input  wire             clk,
    input  wire             reset,
    input  wire [WIDTH-1:0] d,
    output reg  [WIDTH-1:0] q
);
    always @(posedge clk) begin
        if (reset) q <= 0;
        else       q <= d;
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    reg [7:0] d;
    wire [7:0] q;

    reg_with_reset dut(.clk(clk), .reset(reset), .d(d), .q(q));

    always #5 clk = ~clk;

    initial begin
        d = 8'hA5;
        #20 reset = 0;
        #10 d = 8'h3C;
        #10 d = 8'hFF;
        #20 $finish;
    end

    always @(posedge clk)
        $display("t=%0t reset=%b d=%h q=%h", $time, reset, d, q);
endmodule

Đây là reset đồng bộ: điều kiện reset được xét ở sườn clock như mọi đầu vào khác. Công cụ tổng hợp tạo ra một flip-flop có mux 2 sang 1 ở đầu vào dữ liệu: khi reset ở mức cao, mux đưa vào số 0; ngược lại nó đưa vào d.

Với phần lớn thiết kế, reset đồng bộ là lựa chọn đúng. Timing đơn giản hơn, chạy tốt trên FPGA, và tín hiệu reset có thể đến từ bất cứ đâu, không cần một nguồn riêng căn theo clock.

Thanh ghi có enable

Bạn thường cần một thanh ghi chỉ cập nhật khi có tín hiệu cho phép. Hãy đặt một câu lệnh if bên trong khối theo clock, và dựa vào hành vi ngầm "giữ giá trị cũ" khi thiếu else:

module reg_with_enable(
    input  wire       clk,
    input  wire       reset,
    input  wire       enable,
    input  wire [7:0] d,
    output reg  [7:0] q
);
    always @(posedge clk) begin
        if (reset)       q <= 8'd0;
        else if (enable) q <= d;
        // No else - q holds its previous value, which is what a FF does
    end
endmodule

Đây là mẫu "thanh ghi có enable" kinh điển. Nó xuất hiện khắp nơi: thanh ghi cấu hình, tầng pipeline chỉ tiến khi tầng sau đã sẵn sàng, bộ đếm có thể tạm dừng rồi chạy tiếp. Việc bỏ else cuối cùng là có chủ ý và an toàn trong khối theo clock: flip-flop vốn đã nhớ giá trị trước đó, nên "không làm gì" nghĩa là "giữ nguyên".

Trong một khối tổ hợp, cùng đoạn code đó sẽ suy ra latch. Quy tắc khác nhau, cú pháp như nhau.

Bộ đếm

Bộ đếm là một thanh ghi có giá trị kế tiếp bằng giá trị hiện tại cộng một:

module counter #(
    parameter WIDTH = 4
)(
    input  wire             clk,
    input  wire             reset,
    input  wire             enable,
    output reg  [WIDTH-1:0] count
);
    always @(posedge clk) begin
        if (reset)        count <= 0;
        else if (enable)  count <= count + 1;
    end
endmodule

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

    counter #(.WIDTH(4)) dut(.clk(clk), .reset(reset), .enable(enable), .count(count));

    always #5 clk = ~clk;

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

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

Bộ đếm tăng lên ở mỗi chu kỳ clock khi enable ở mức cao. Sau 16 chu kỳ nó quay vòng về 0 (vì ta khai báo 4 bit và 15 + 1 tràn thành 0). Việc quay vòng đó là bản chất của số học N bit và cũng chính là cách bộ đếm phần cứng thật hoạt động.

Thanh ghi dịch

Xếp chuỗi các flip-flop cho bạn một thanh ghi dịch. Mẹo là thực hiện toàn bộ phép dịch trong một câu lệnh non-blocking duy nhất:

module shift_register #(
    parameter WIDTH = 4
)(
    input  wire             clk,
    input  wire             reset,
    input  wire             in,
    output reg  [WIDTH-1:0] out
);
    always @(posedge clk) begin
        if (reset) out <= 0;
        else       out <= {out[WIDTH-2:0], in};
    end
endmodule

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

    shift_register #(.WIDTH(4)) dut(.clk(clk), .reset(reset), .in(in), .out(out));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        in = 1; #10;
        in = 0; #10;
        in = 1; #10;
        in = 1; #10;
        in = 0; #40 $finish;
    end

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

Thân khối là out <= {out[WIDTH-2:0], in}: ghép các bit thấp của out hiện tại với in mới, rồi gán cả cụm. Vì đây là phép gán non-blocking, vế phải đọc giá trị out cũ trước khi vế trái được cập nhật. Kết quả là một phép dịch N bit gọn gàng trong một chu kỳ clock.

Đây là mẫu thanh ghi dịch ở dạng nhỏ gọn nhất. Nó mở rộng ra thành LFSR, bộ truyền nối tiếp, bộ chuyển nối tiếp sang song song, tức mọi thiết kế mà dữ liệu đi qua một chuỗi flip-flop theo từng clock.

Pipeline

Pipeline là một chuỗi thanh ghi ngăn cách bởi logic tổ hợp. Mỗi tầng xử lý dữ liệu từ tầng trước rồi chuyển cho tầng sau:

module pipelined_add(
    input  wire        clk,
    input  wire        reset,
    input  wire [7:0]  a, b, c, d,
    output reg  [9:0]  result
);
    reg [8:0] stage1_ab, stage1_cd;
    reg [9:0] stage2;

    always @(posedge clk) begin
        if (reset) begin
            stage1_ab <= 0;
            stage1_cd <= 0;
            stage2    <= 0;
            result    <= 0;
        end else begin
            // Stage 1: two parallel adds.
            stage1_ab <= a + b;
            stage1_cd <= c + d;
            // Stage 2: combine the two partial sums.
            stage2    <= stage1_ab + stage1_cd;
            // Stage 3: forward to output.
            result    <= stage2;
        end
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    reg [7:0] a, b, c, d;
    wire [9:0] result;

    pipelined_add dut(.clk(clk), .reset(reset), .a(a), .b(b), .c(c), .d(d), .result(result));

    always #5 clk = ~clk;

    initial begin
        a = 0; b = 0; c = 0; d = 0;
        #12 reset = 0;
        a = 10; b = 20; c = 30; d = 40; #10;
        a = 1;  b = 2;  c = 3;  d = 4;  #10;
        a = 5;  b = 5;  c = 5;  d = 5;  #40;
        $finish;
    end

    always @(posedge clk)
        $display("t=%0t a=%0d b=%0d c=%0d d=%0d result=%0d", $time, a, b, c, d, result);
endmodule

Ba tầng, độ trễ ba chu kỳ, nhưng khi pipeline đã đầy thì mỗi chu kỳ cho ra một kết quả mới. Độ trễ là 3 clock vì dữ liệu đi qua ba flip-flop; thông lượng là 1 phép tính mỗi clock vì cả ba tầng cùng làm việc song song trên các đầu vào khác nhau.

Đây là cách các thiết kế hiệu năng cao đạt mục tiêu thông lượng: giữ mỗi tầng ngắn, chia pipeline sâu hơn và để tính song song gánh việc.

Reset bất đồng bộ (khi bạn cần)

Đôi khi bạn không thể chờ sườn clock để kích hoạt reset: chip đang tắt nguồn, clock bị ngắt, một watchdog bên ngoài đang kéo đường reset. Khi đó:

always @(posedge clk or negedge reset_n) begin
    if (~reset_n) q <= 0;
    else          q <= d;
end

Lúc này danh sách độ nhạy có cả sườn clock lẫn sườn reset. Flip-flop phản ứng ngay với bất kỳ sườn nào. Theo quy ước, reset_n tích cực mức thấp (được kích hoạt khi ở mức thấp), đó là lý do điều kiện kiểm tra là ~reset_n.

Reset bất đồng bộ có đánh đổi: khó phân tích timing hơn, có thể gây metastability nếu không xử lý cẩn thận lúc nhả reset, và không dùng được trên mọi kiến trúc FPGA. Mặc định hãy dùng reset đồng bộ, chỉ dùng bất đồng bộ khi thiết kế thật sự đòi hỏi.

Tiếp theo

Giờ bạn đã dựng được mọi đường dữ liệu đồng bộ. Bài tiếp theo, Máy trạng thái hữu hạn, kết hợp một thanh ghi theo clock với câu lệnh case để tạo ra mẫu FSM chuẩn: trái tim của mọi bộ điều khiển, bộ xử lý giao thức và khối ra quyết định trong thiết kế số.