Verilog入门：2026年用异步FIFO解决跨时钟域问题的实战技巧

module async_fifo #(
    parameter DATA_WIDTH = 8,
    parameter FIFO_DEPTH = 16
)(
    input  wire                     wr_clk,
    input  wire                     wr_rst_n,
    input  wire                     wr_en,
    input  wire [DATA_WIDTH-1:0]    wr_data,
    output wire                     full,

    input  wire                     rd_clk,
    input  wire                     rd_rst_n,
    input  wire                     rd_en,
    output wire [DATA_WIDTH-1:0]    rd_data,
    output wire                     empty
);

    // 地址宽度 = log2(FIFO_DEPTH)
    localparam ADDR_WIDTH = $clog2(FIFO_DEPTH);

    // 双端口RAM
    reg [DATA_WIDTH-1:0] mem [0:FIFO_DEPTH-1];

    // 写指针（二进制）
    reg [ADDR_WIDTH:0] wr_ptr_bin;
    wire [ADDR_WIDTH:0] wr_ptr_gray;

    // 读指针（二进制）
    reg [ADDR_WIDTH:0] rd_ptr_bin;
    wire [ADDR_WIDTH:0] rd_ptr_gray;

    // 同步后的指针
    reg [ADDR_WIDTH:0] wr_ptr_gray_sync1, wr_ptr_gray_sync2;
    reg [ADDR_WIDTH:0] rd_ptr_gray_sync1, rd_ptr_gray_sync2;

    // 写地址与写数据
    always @(posedge wr_clk or negedge wr_rst_n) begin
        if (!wr_rst_n)
            wr_ptr_bin <= 0;
        else if (wr_en && !full)
            wr_ptr_bin <= wr_ptr_bin + 1;
    end

    always @(posedge wr_clk) begin
        if (wr_en && !full)
            mem[wr_ptr_bin[ADDR_WIDTH-1:0]] <= wr_data;
    end

    // 读地址与读数据
    always @(posedge rd_clk or negedge rd_rst_n) begin
        if (!rd_rst_n)
            rd_ptr_bin <= 0;
        else if (rd_en && !empty)
            rd_ptr_bin <= rd_ptr_bin + 1;
    end

    assign rd_data = mem[rd_ptr_bin[ADDR_WIDTH-1:0]];

    // 二进制转格雷码
    assign wr_ptr_gray = wr_ptr_bin ^ (wr_ptr_bin >> 1);
    assign rd_ptr_gray = rd_ptr_bin ^ (rd_ptr_bin >> 1);

    // 写指针同步到读时钟域
    always @(posedge rd_clk or negedge rd_rst_n) begin
        if (!rd_rst_n) begin
            wr_ptr_gray_sync1 <= 0;
            wr_ptr_gray_sync2 <= 0;
        end else begin
            wr_ptr_gray_sync1 <= wr_ptr_gray;
            wr_ptr_gray_sync2 <= wr_ptr_gray_sync1;
        end
    end

    // 读指针同步到写时钟域
    always @(posedge wr_clk or negedge wr_rst_n) begin
        if (!wr_rst_n) begin
            rd_ptr_gray_sync1 <= 0;
            rd_ptr_gray_sync2 <= 0;
        end else begin
            rd_ptr_gray_sync1 <= rd_ptr_gray;
            rd_ptr_gray_sync2 <= rd_ptr_gray_sync1;
        end
    end

    // 空满判断
    wire [ADDR_WIDTH:0] wr_ptr_gray_sync = wr_ptr_gray_sync2;
    wire [ADDR_WIDTH:0] rd_ptr_gray_sync = rd_ptr_gray_sync2;

    assign full  = (wr_ptr_gray[ADDR_WIDTH:ADDR_WIDTH-2] == ~rd_ptr_gray_sync[ADDR_WIDTH:ADDR_WIDTH-2] &&
                    wr_ptr_gray[ADDR_WIDTH-3:0] == rd_ptr_gray_sync[ADDR_WIDTH-3:0]);
    assign empty = (rd_ptr_gray == wr_ptr_gray_sync);

endmodule

# 写时钟域约束
create_clock -name wr_clk -period 10.000 [get_ports wr_clk]

# 读时钟域约束
create_clock -name rd_clk -period 20.000 [get_ports rd_clk]

# 跨时钟域假路径：从写时钟到读时钟
set_false_path -from [get_clocks wr_clk] -to [get_clocks rd_clk]
set_false_path -from [get_clocks rd_clk] -to [get_clocks wr_clk]

# 异步复位释放路径（可选）
set_false_path -from [get_ports wr_rst_n] -to [get_clocks wr_clk]
set_false_path -from [get_ports rd_rst_n] -to [get_clocks rd_clk]

`timescale 1ns/1ps

module tb_async_fifo;

    reg         wr_clk, rd_clk;
    reg         wr_rst_n, rd_rst_n;
    reg         wr_en, rd_en;
    reg  [7:0]  wr_data;
    wire [7:0]  rd_data;
    wire        full, empty;

    async_fifo #(.DATA_WIDTH(8), .FIFO_DEPTH(16)) uut (
        .wr_clk(wr_clk),
        .wr_rst_n(wr_rst_n),
        .wr_en(wr_en),
        .wr_data(wr_data),
        .full(full),
        .rd_clk(rd_clk),
        .rd_rst_n(rd_rst_n),
        .rd_en(rd_en),
        .rd_data(rd_data),
        .empty(empty)
    );

    // 写时钟生成
    initial begin
        wr_clk = 0;
        forever #5 wr_clk = ~wr_clk;  // 100MHz
    end

    // 读时钟生成
    initial begin
        rd_clk = 0;
        forever #10 rd_clk = ~rd_clk; // 50MHz
    end

    // 复位与激励
    initial begin
        wr_rst_n = 0; rd_rst_n = 0;
        wr_en = 0; rd_en = 0; wr_data = 0;
        #100;
        wr_rst_n = 1; rd_rst_n = 1;
        #20;

        // 写入16个数据
        repeat (16) begin
            @(posedge wr_clk);
            wr_en = 1;
            wr_data = wr_data + 1;
            #5;
        end
        wr_en = 0;

        // 等待非空
        wait (!empty);
        // 读取16个数据
        repeat (16) begin
            @(posedge rd_clk);
            rd_en = 1;
            #5;
        end
        rd_en = 0;
        #500;
        $finish;
    end

endmodule