一、为什么 CDC 会出问题？——亚稳态的本质

在数字电路中，触发器的建立时间（Setup Time）和保持时间（Hold Time）对输入信号有严格要求。当来自异步时钟域的信号恰好在采样时钟边沿附近发生变化，触发器就可能无法在一个时钟周期内完成稳定判决，输出既不是确定的 0 也不是确定的 1——这就是亚稳态（Metastability）。

亚稳态的危害不在于输出是什么值，而在于不确定性会向下游逻辑传播，引发功能错误。衡量系统抗亚稳态能力的核心指标是平均无故障时间（MTBF）：

MTBF = exp(C2 × Tmet) / (C1 × fclk × fdata)

其中 Tmet 是留给亚稳态恢复的时间窗口，C1、C2 是与工艺相关的常数。工程结论是：每多串联一级触发器，MTBF 呈指数级提升，这就是"打两拍"能有效抑制亚稳态的根本原因。

⚠️ 关键认知：打两拍不能消除亚稳态，它只是把亚稳态发生后传播到下游的概率压低到工程上可接受的水平。

---

二、单比特 CDC 传输

2.1 慢时钟域 → 快时钟域（慢到快）

快时钟的采样频率高于信号变化频率，因此慢域信号一定能被采到，唯一需要解决的是亚稳态。标准方案：两级同步器（Double FF Synchronizer）。

clk_slow 域                     clk_fast 域
─────────────────────────────────────────────────►
  signal_in ──► FF1 ──► FF2 ──► signal_out（稳定）
               (亚稳态恢复级)   (安全输出级)

Verilog 实现

// ============================================================
// 模块：双级同步器（慢到快，单比特）
// 功能：将 clk_src 域的单比特信号安全同步到 clk_dst 域
// ============================================================
module sync_2ff (
    input  wire clk_dst,   // 目标时钟（快时钟）
    input  wire rst_n,     // 异步复位，低有效
    input  wire data_in,   // 来自慢时钟域的输入信号
    output wire data_out   // 同步后的输出信号
);
    reg ff1, ff2;
    (* ASYNC_REG = "TRUE" *) reg ff1_meta;
    (* ASYNC_REG = "TRUE" *) reg ff2_sync;

    always @(posedge clk_dst or negedge rst_n) begin
        if (!rst_n) begin
            ff1_meta <= 1'b0;
            ff2_sync <= 1'b0;
        end else begin
            ff1_meta <= data_in;    
            ff2_sync <= ff1_meta;   
    end

    assign data_out = ff2_sync;

endmodule

注意：综合属性 ASYNC_REG = "TRUE" 会告知工具将两个 FF 放置于相邻位置，减小走线延迟，进一步提升 MTBF，工程中必须添加。

若下游只需要一个快时钟域的单周期脉冲，可在同步后做上升沿检测：

Verilog 实现

// 上升沿检测：在 clk_fast 域产生单周期脉冲
reg ff3;
always @(posedge clk_dst or negedge rst_n) begin
    if (!rst_n) ff3 <= 1'b0;
    else        ff3 <= ff2_sync;
end

wire pulse_out = ff2_sync & ~ff3; // 检测到上升沿时输出一个周期高电平

---

2.2 快时钟域 → 慢时钟域（快到慢）

这是 CDC 中最棘手的方向。慢时钟可能在快域信号的有效窗口内完全没有采样边沿——漏采。解决核心：延长信号在快域的有效时间，保证慢域至少能采到一次（通常要求信号保持时间 ≥ 1.5 个慢时钟周期）。

方案 A：电平同步器（适合持续电平信号）

对于本身持续时间足够长的电平信号，直接套用双级同步器即可，无需额外处理。

局限：若信号是窄脉冲（仅持续 1~2 个快时钟周期），慢时钟极大概率漏采。

方案 B：脉冲展宽 + 双级同步器（开环，有约束）

在快时钟域将窄脉冲展宽到足够长度，再用双级同步器采入慢时钟域。

局限：展宽长度依赖已知的时钟频率比；若频率比不固定或不可知，此方案不适用。若两个脉冲发送间隔太近，还可能产生脉冲合并。

方案 C：握手协议（Handshake，闭环，最通用）✅推荐

握手协议通过反馈确认机制，在不依赖频率比的情况下，确保每个脉冲都被慢时钟域可靠接收。

协议时序流程：

clk_fast 域：
  1. 检测到 pulse_in → 将 req 置高并保持（展宽）
  4. 检测到 ack_sync 为高 → 将 req 拉低（恢复）

clk_slow 域：
  2. 用双级同步器采到 req_sync 为高
  3. 将 ack 置高反馈给快时钟域（同时输出 signal_out 脉冲）
  5. 检测到 req_sync 为低 → 将 ack 拉低

完整 Verilog 实现

// ============================================================
// 模块：单比特快到慢握手协议
// 描述：将 clk_fast 域的窄脉冲可靠传输到 clk_slow 域
//       不依赖频率比，适用范围最广
// ============================================================
module cdc_handshake_1bit (
    // 发送端（快时钟域）
    input  wire clk_fast,     // 快时钟
    input  wire rst_fast_n,   
    input  wire pulse_in,    
    output wire busy,         // 握手进行中，请勿发送新脉冲

    // 接收端（慢时钟域）
    input  wire clk_slow,     // 慢时钟
    input  wire rst_slow_n,   
    output wire pulse_out    
);

 
    reg req;

    always @(posedge clk_fast or negedge rst_fast_n) begin
        if (!rst_fast_n)
            req <= 1'b0;
        else if (pulse_in && !req)  
            req <= 1'b1;
        else if (ack_sync)        
            req <= 1'b0;
    end

    assign busy = req; 

    // ---- 慢时钟域：对 req 进行双级同步 ----
    (* ASYNC_REG = "TRUE" *) reg req_ff1, req_ff2, req_ff3;

    always @(posedge clk_slow or negedge rst_slow_n) begin
        if (!rst_slow_n)
            {req_ff3, req_ff2, req_ff1} <= 3'b0;
        else
            {req_ff3, req_ff2, req_ff1} <= {req_ff2, req_ff1, req};
    end

  
    assign pulse_out = req_ff2 & ~req_ff3;

    // ---- 慢时钟域：产生 ACK 反馈 ----
    reg ack;

    always @(posedge clk_slow or negedge rst_slow_n) begin
        if (!rst_slow_n)
            ack <= 1'b0;
        else
            ack <= req_ff2;  // 跟随同步后的 req
    end

    // ---- 快时钟域：对 ACK 进行双级同步 ----
    (* ASYNC_REG = "TRUE" *) reg ack_ff1;
    reg ack_sync;

    always @(posedge clk_fast or negedge rst_fast_n) begin
        if (!rst_fast_n)
            {ack_sync, ack_ff1} <= 2'b0;
        else
            {ack_sync, ack_ff1} <= {ack_ff1, ack};
    end

endmodule

Testbench

verilog

// ============================================================
// Testbench：cdc_handshake_1bit
// 验证：快时钟(10ns) → 慢时钟(30ns) 脉冲握手传输
// ============================================================
`timescale 1ns / 1ps

module cdc_handshake_1bit_tb;

    reg  clk_fast   = 0;
    reg  clk_slow   = 0;
    reg  rst_fast_n = 1;
    reg  rst_slow_n = 1;
    reg  pulse_in   = 0;

    wire busy;
    wire pulse_out;

    // DUT 例化
    cdc_handshake_1bit u_dut (
        .clk_fast   (clk_fast),
        .rst_fast_n (rst_fast_n),
        .pulse_in   (pulse_in),
        .busy       (busy),
        .clk_slow   (clk_slow),
        .rst_slow_n (rst_slow_n),
        .pulse_out  (pulse_out)
    );

    // 时钟生成：快 100MHz / 慢 33MHz
    always #5  clk_fast = ~clk_fast;
    always #15 clk_slow = ~clk_slow;

    // 任务：发送一个脉冲（等待握手空闲）
    task send_pulse;
        begin
            // 等待 busy 为低才发送
            @(posedge clk_fast);
            wait (!busy);
            @(posedge clk_fast);
            pulse_in = 1;
            @(posedge clk_fast);
            pulse_in = 0;
        end
    endtask

    initial begin
        // 复位
        rst_fast_n = 0; rst_slow_n = 0;
        repeat(4) @(posedge clk_fast);
        rst_fast_n = 1; rst_slow_n = 1;
        repeat(5) @(posedge clk_fast);

        // 测试 1：发送第一个脉冲
        $display("[%0t] 发送第 1 个脉冲", $time);
        send_pulse;

        // 等待握手完成
        wait (!busy);
        repeat(10) @(posedge clk_fast);

        // 测试 2：连续发送两个脉冲
        $display("[%0t] 发送第 2 个脉冲", $time);
        send_pulse;
        wait (!busy);

        $display("[%0t] 发送第 3 个脉冲", $time);
        send_pulse;
        wait (!busy);

        repeat(20) @(posedge clk_fast);
        $display("[%0t] 仿真结束", $time);
        $finish;
    end

    // 监控输出
    initial begin
        $monitor("[%0t] pulse_in=%b busy=%b | pulse_out=%b",
                 $time, pulse_in, busy, pulse_out);
    end

endmodule

时序结构如下图所示：

---

三、多比特 CDC 传输

3.1 为什么多比特不能直接用双级同步器？

对于 N 位总线，各位寄存器的翻转时刻由各自的逻辑路径决定，不会严格同时翻转。当不同位分处亚稳态恢复的不同阶段时，接收端采到的数据是一个瞬间的"中间态"，与发送端任何真实值都不对应。

举例：发送端从 3'b011 跳变到 3'b100，bit[2] 和 bit[1:0] 翻转时刻不同，接收端可能采到 3'b000、3'b111、3'b110 等非法值。

格雷码能解决吗？

格雷码相邻码字只有 1 位不同，若多位数据是严格按计数顺序递增/递减变化（如 FIFO 指针），则每次只有 1 位翻转，可以用双级同步器传输。但对于任意跳变的数据总线，格雷码仍然不适用。

---

3.2 慢时钟域 → 快时钟域：MUX 同步器法

快时钟一定能采到慢域数据，问题只是如何保证采到的是稳定态而非翻转过程中的中间态。

核心思想：为多位数据配套一个同步使能信号。只有使能信号在接收域同步后有效时，才将数据锁入输出寄存器。此时数据总线已稳定（不在翻转过程中）。

clk_slow 域                          clk_fast 域
─────────────────────────────────────────────────────────►
  data[N:0] ─────────────────────►  MUX ──► dout_reg
  din_en ──► FF1(fast) ──► FF2 ──► load_en ─┘
             (同步 din_en)

module cdc_mux_sync #(
    parameter DATA_W = 32
)(
    input  wire              clk_src,   // 源时钟（慢）
    input  wire              rst_src_n,
    input  wire [DATA_W-1:0] data_in,   
    input  wire              din_valid,

    input  wire              clk_dst,   // 目标时钟（快）
    input  wire              rst_dst_n,
    output reg  [DATA_W-1:0] data_out,  
    output reg               dout_valid
);


     reg valid_ff1, valid_ff2, valid_ff3;

    always @(posedge clk_dst or negedge rst_dst_n) begin
        if (!rst_dst_n)
            {valid_ff3, valid_ff2, valid_ff1} <= 3'b0;
        else
            {valid_ff3, valid_ff2, valid_ff1} <= {valid_ff2, valid_ff1, din_valid};
    end

    wire load_en = valid_ff2 & ~valid_ff3;


    always @(posedge clk_dst or negedge rst_dst_n) begin
        if (!rst_dst_n) begin
            data_out  <= {DATA_W{1'b0}};
            dout_valid <= 1'b0;
        end else if (load_en) begin
            data_out  <= data_in;   
            dout_valid <= 1'b1;
        end else begin
            dout_valid <= 1'b0;
        end
    end

endmodule

关键约束：din_valid 有效期间 data_in 必须保持稳定（不能变化），且 din_valid 拉低后至少再等待 2 个快时钟周期才能发送下一组数据。

如果缺少显式有效信号，意味着接收端不知道"数据什么时候变了"。需要根据数据更新频率

核心逻辑：在源时钟域内部用寄存器对比上一拍自动检测变化，变化时翻转 flag，再把 flag 同步过去

src 域                          dst 域
──────────────────────────────────────────────────────►
data_in ──► [data_prev寄存器] ──┐
                                ├─ 不同 → toggle flag ──► FF1 ──► FF2
data_lat ◄──────────────────────┘                      边沿检测 → load

// ============================================================
// 模块：Toggle 同步器（无 valid 信号的多比特 CDC）
// 适用：源时钟慢于或快于目标时钟均可
// ============================================================
module cdc_toggle_sync #(
    parameter DATA_W = 32
)(
    input  wire              clk_src,
    input  wire              rst_src_n,
    input  wire [DATA_W-1:0] data_in,   

    input  wire              clk_dst,
    input  wire              rst_dst_n,
    output reg  [DATA_W-1:0] data_out,
    output wire              data_change 
);

reg [DATA_W-1:0] data_prev; 
reg [DATA_W-1:0] data_lat;   
reg              toggle;    

    always @(posedge clk_src or negedge rst_src_n) begin
        if (!rst_src_n) begin
            data_prev <= {DATA_W{1'b0}};
            data_lat  <= {DATA_W{1'b0}};
            toggle    <= 1'b0;
        end else begin
            data_prev <= data_in;           

            if (data_in != data_prev) begin 
                data_lat <= data_in;       
                toggle   <= ~toggle;      
            end
        end
    end


reg toggle_ff1, toggle_ff2;

    always @(posedge clk_dst or negedge rst_dst_n) begin
        if (!rst_dst_n)
            {toggle_ff2, toggle_ff1} <= 3'b0;
        else
            {toggle_ff2, toggle_ff1} <= {toggle_ff1, toggle};
    end


   wire load_en = toggle_ff1 ^ toggle_ff2;
    assign data_change = load_en;


    always @(posedge clk_dst or negedge rst_dst_n) begin
        if (!rst_dst_n)
            data_out <= {DATA_W{1'b0}};
        else if (load_en)
            data_out <= data_lat;  
    end

endmodule

时序结构如下图所示：

从时序图看，慢时钟的数据已经成功同步到快时钟的数据。

---

3.3 快时钟域 → 慢时钟域：握手协议（多比特）

与单比特握手原理一致：用握手信号控制多比特数据的传输窗口，保证慢域采数时数据总线静止。

Verilog 实现

// ============================================================
// 模块：多比特快到慢握手协议
// 描述：req/ack 四相握手，确保慢域接收到完整稳定数据
// ============================================================
module cdc_handshake_nbit #(
    parameter DATA_W = 8
)(
    // 发送端（快时钟域）
    input  wire              clk_fast,
    input  wire              rst_fast_n,
    input  wire [DATA_W-1:0] tx_data,    
    input  wire              tx_valid,   
    output wire              tx_busy,     // 握手进行中

    // 接收端（慢时钟域）
    input  wire              clk_slow,
    input  wire              rst_slow_n,
    output reg  [DATA_W-1:0] rx_data,     
    output wire              rx_valid    
);

 
    reg  [DATA_W-1:0] tx_data_lat;
    reg               req;

    (* ASYNC_REG = "TRUE" *) reg ack_ff1;
    reg               ack_sync;

    always @(posedge clk_fast or negedge rst_fast_n) begin
        if (!rst_fast_n) begin
            req       <= 1'b0;
            tx_data_lat <= {DATA_W{1'b0}};
        end else if (tx_valid && !req) begin
            req       <= 1'b1;
            tx_data_lat <= tx_data;   // 锁存数据，保持稳定直到握手完成
        end else if (ack_sync) begin
            req       <= 1'b0;        // 收到 ACK 后释放
        end
    end

    assign tx_busy = req;

    // ACK 跨域同步至快时钟
    always @(posedge clk_fast or negedge rst_fast_n) begin
        if (!rst_fast_n) {ack_sync, ack_ff1} <= 2'b0;
        else             {ack_sync, ack_ff1} <= {ack_ff1, ack};
    end

    // ---- 接收端：同步 REQ，产生 ACK ----
    (* ASYNC_REG = "TRUE" *) reg req_ff1, req_ff2, req_ff3;

    always @(posedge clk_slow or negedge rst_slow_n) begin
        if (!rst_slow_n) {req_ff3, req_ff2, req_ff1} <= 3'b0;
        else             {req_ff3, req_ff2, req_ff1} <= {req_ff2, req_ff1, req};
    end

    // req_ff2 上升沿时数据稳定，锁存数据
    wire rx_load = req_ff2 & ~req_ff3;
    assign rx_valid = rx_load;

    always @(posedge clk_slow or negedge rst_slow_n) begin
        if (!rst_slow_n) rx_data <= {DATA_W{1'b0}};
        else if (rx_load) rx_data <= tx_data_lat;  // 此时发送端数据锁存中，安全读取
    end

  
    reg ack;
    always @(posedge clk_slow or negedge rst_slow_n) begin
        if (!rst_slow_n) ack <= 1'b0;
        else             ack <= req_ff2;
    end

endmodule

时序结构如下图所示：

从时序图看，快时钟的数据已经成功同步到慢时钟的数据。

---

3.4 异步 FIFO（快慢双向通杀，首选方案）✅

异步 FIFO 是多比特 CDC 最工程化的解决方案，同时适配慢到快和快到慢，且能自然支持流量控制（满/空标志）和突发数据缓冲。

设计要点

子模块	职责
双端口 RAM	数据存储（读写独立端口）
写控制器	维护写指针，产生 fifo_full
读控制器	维护读指针，产生 fifo_empty
写→读同步	写指针（格雷码）同步至读时钟域，用于判空
读→写同步	读指针（格雷码）同步至写时钟域，用于判满

为什么指针用格雷码？ 指针是顺序递增计数器，相邻值只有 1 位不同，满足格雷码跨时钟传输的前提条件，双级同步器不会采到非法中间态。

满/空判断逻辑：

• 读空：读指针（格雷码）== 同步过来的写指针（格雷码）
• 写满：写指针（格雷码）高两位与读指针（格雷码）高两位相反，低位全部相同

Verilog 实现

// ============================================================
// 模块：异步 FIFO（深度 2^PTR_W，位宽 DATA_W）
// ============================================================
module async_fifo #(
    parameter DATA_W = 8,
    parameter PTR_W  = 3   // 地址位宽，深度 = 2^PTR_W = 8
)(
    // 写端口
    input  wire              wr_clk,
    input  wire              wr_rst_n,
    input  wire              wr_en,
    input  wire [DATA_W-1:0] wr_data,
    output wire              full,

    // 读端口
    input  wire              rd_clk,
    input  wire              rd_rst_n,
    input  wire              rd_en,
    output reg  [DATA_W-1:0] rd_data,
    output wire              empty
);

    localparam DEPTH = 1 << PTR_W;

    // ----------------------------------------------------------------
    // 双端口 RAM
    // ----------------------------------------------------------------
    reg [DATA_W-1:0] mem [0:DEPTH-1];

    wire wr_allow = wr_en && !full;
    wire rd_allow = rd_en && !empty;

    always @(posedge wr_clk) begin
        if (wr_allow)
            mem[wr_ptr_bin[PTR_W-1:0]] <= wr_data;
    end

    always @(posedge rd_clk or negedge rd_rst_n) begin
        if (!rd_rst_n) rd_data <= {DATA_W{1'b0}};
        else if (rd_allow)
            rd_data <= mem[rd_ptr_bin[PTR_W-1:0]];
    end

    // ----------------------------------------------------------------
    // 写指针（二进制 + 格雷码）
    // ----------------------------------------------------------------
    reg  [PTR_W:0] wr_ptr_bin;   // 多一位用于满/空区分
    wire [PTR_W:0] wr_ptr_gray = wr_ptr_bin ^ (wr_ptr_bin >> 1);

    always @(posedge wr_clk or negedge wr_rst_n) begin
        if (!wr_rst_n) wr_ptr_bin <= {(PTR_W+1){1'b0}};
        else if (wr_allow) wr_ptr_bin <= wr_ptr_bin + 1'b1;
    end

    // ----------------------------------------------------------------
    // 读指针（二进制 + 格雷码）
    // ----------------------------------------------------------------
    reg  [PTR_W:0] rd_ptr_bin;
    wire [PTR_W:0] rd_ptr_gray = rd_ptr_bin ^ (rd_ptr_bin >> 1);

    always @(posedge rd_clk or negedge rd_rst_n) begin
        if (!rd_rst_n) rd_ptr_bin <= {(PTR_W+1){1'b0}};
        else if (rd_allow) rd_ptr_bin <= rd_ptr_bin + 1'b1;
    end

    // ----------------------------------------------------------------
    // 写指针同步到读时钟域（判空用）
    // ----------------------------------------------------------------
    (* ASYNC_REG = "TRUE" *) reg [PTR_W:0] wr_gray_r1, wr_gray_r2;

    always @(posedge rd_clk or negedge rd_rst_n) begin
        if (!rd_rst_n) {wr_gray_r2, wr_gray_r1} <= {2{(PTR_W+1)'b0}};
        else           {wr_gray_r2, wr_gray_r1} <= {wr_gray_r1, wr_ptr_gray};
    end

    // ----------------------------------------------------------------
    // 读指针同步到写时钟域（判满用）
    // ----------------------------------------------------------------
    (* ASYNC_REG = "TRUE" *) reg [PTR_W:0] rd_gray_r1, rd_gray_r2;

    always @(posedge wr_clk or negedge wr_rst_n) begin
        if (!wr_rst_n) {rd_gray_r2, rd_gray_r1} <= {2{(PTR_W+1)'b0}};
        else           {rd_gray_r2, rd_gray_r1} <= {rd_gray_r1, rd_ptr_gray};
    end

    // ----------------------------------------------------------------
    // 空满判断
    // 读空：读指针格雷码 == 同步过来的写指针格雷码
    // 写满：最高两位相反，其余位相同
    // ----------------------------------------------------------------
    assign empty = (rd_ptr_gray == wr_gray_r2);

    assign full  = (wr_ptr_gray[PTR_W]   != rd_gray_r2[PTR_W]  ) &&
                   (wr_ptr_gray[PTR_W-1] != rd_gray_r2[PTR_W-1]) &&
                   (wr_ptr_gray[PTR_W-2:0] == rd_gray_r2[PTR_W-2:0]);

endmodule

完整 Testbench（覆盖三种场景）

Verilog 实现

`timescale 1ns / 1ps

module async_fifo_tb;

    parameter DATA_W = 8;
    parameter PTR_W  = 3;  // 深度 = 8

    reg              wr_clk  = 0;
    reg              rd_clk  = 0;
    reg              wr_rst_n = 1;
    reg              rd_rst_n = 1;
    reg              wr_en   = 0;
    reg              rd_en   = 0;
    reg  [DATA_W-1:0] wr_data = 0;
    wire [DATA_W-1:0] rd_data;
    wire             full, empty;

    async_fifo #(.DATA_W(DATA_W), .PTR_W(PTR_W)) u_dut (
        .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)
    );

    // 写快读慢：写 10ns 周期，读 25ns 周期
    always #5  wr_clk = ~wr_clk;
    always #12 rd_clk = ~rd_clk;

    integer i;
    initial begin
        // ---------- 复位 ----------
        wr_rst_n = 0; rd_rst_n = 0;
        repeat(4) @(posedge wr_clk);
        wr_rst_n = 1; rd_rst_n = 1;
        repeat(4) @(posedge wr_clk);

        // ---------- 场景 1：只写，验证 full 信号 ----------
        $display("=== 场景 1：只写直到 full ===");
        wr_en = 1;
        for (i = 0; i < 12; i = i + 1) begin
            @(negedge wr_clk);
            wr_data = i * 10;
            if (full) $display("[%0t] FIFO 已满，写入被阻止 data=%0d", $time, wr_data);
        end
        wr_en = 0;
        repeat(4) @(posedge wr_clk);

        // ---------- 场景 2：只读，验证 empty 信号 ----------
        $display("=== 场景 2：只读直到 empty ===");
        rd_en = 1;
        repeat(15) @(posedge rd_clk);
        rd_en = 0;
        if (empty) $display("[%0t] FIFO 已空", $time);
        repeat(4) @(posedge rd_clk);

        // ---------- 场景 3：同时读写 ----------
        $display("=== 场景 3：读写同时进行 ===");
        wr_en = 1; rd_en = 1;
        for (i = 0; i < 20; i = i + 1) begin
            @(negedge wr_clk);
            wr_data = $random % 256;
        end
        wr_en = 0;
        repeat(20) @(posedge rd_clk);
        rd_en = 0;

        $display("[%0t] 仿真完成", $time);
        $finish;
    end

endmodule

时序结构如下图所示：

异步FIFO针对对时钟速率较高的场景，从上述时序图看，从快时钟域同步到慢时钟域数据满足实际要求

---

四、方法选型决策树

开始：需要跨时钟域传输
          │
          ├─ 单比特信号？
          │       ├─ 慢→快 ──► 双级同步器（ASYNC_REG属性）
          │       └─ 快→慢
          │               ├─ 信号是持续电平（时间足够长）──► 双级同步器
          │               └─ 窄脉冲
          │                       ├─ 频率比固定且已知 ──► 脉冲展宽法（注意间隔约束）
          │                       └─ 频率比未知或不固定 ──► 握手协议（推荐）
          │
          └─ 多比特信号？
                  ├─ 数据是顺序计数值（如指针）──► 格雷码 + 双级同步器
                  ├─ 慢→快，有稳定使能信号 ──► MUX同步器法
                  ├─ 快→慢，偶发传输 ──► 多比特握手协议
                  └─ 高速流式数据 ──► 异步 FIFO ✅首选

---

五、常见设计陷阱与工程规范

5.1 常见错误

错误	后果	正确做法
多比特数据直接用双级同步器	采到非法中间态	使用异步FIFO或握手协议
两级FF之间插入组合逻辑	竞争冒险产生毛刺，破坏同步效果	确保FF1与FF2之间无组合路径
漏写 ASYNC_REG 属性	工具可能跨寄存器优化路径，降低MTBF	对所有跨域FF必须添加该属性
握手期间发送新脉冲	旧数据未被确认即被覆盖	检查 busy 信号，握手未完成前禁止发送
异步复位释放时序问题	复位撤除时的亚稳态	使用复位同步器（Reset Synchronizer）处理跨域复位

5.2 CDC 静态检查工具

工程中不能仅靠仿真验证 CDC，需配合静态分析工具：

• Synopsys SpyGlass CDC：业界标准CDC规则检查器，可识别未保护的跨域路径
• Mentor Questa CDC：形式化验证CDC结构
• Vivado/Quartus 时序报告：检查跨域路径是否被正确约束为 set_false_path 或 set_max_delay -datapath_only

XDC/SDC 约束示例：对握手信号中的 REQ 路径，应添加 set_max_delay 约束，放宽时序裕量要求，同时告知工具该路径是有意设计的跨域传输。

tcl

set_max_delay -from [get_cells req_reg] \
              -to   [get_cells req_ff1_reg] \
              -datapath_only 10.0

---

六、总结

场景	推荐方案	关键优势
单比特，慢→快	双级同步器	简单高效
单比特，快→慢（电平信号）	双级同步器	简单
单比特，快→慢（窄脉冲）	握手协议	无频率比限制，最可靠
多比特，计数指针	格雷码+双级同步器	低延迟
多比特，慢→快	MUX同步器	实现简单，适合低频数据
多比特，快→慢	握手协议	保证数据完整性
多比特，流式高速	异步 FIFO	吞吐率高，适用性最广

CDC 设计的核心哲学只有一句话：在同步的那一刻，保证被采样的信号是稳定不变的。所有方法——无论是打拍、握手还是 FIFO——本质上都是在为这一目标服务。