跨时钟域信号为什么会”飘”？——亚稳态的原理与对策

💡 你的 FPGA 系统 99.9% 的时间都工作正常，但偶尔会莫名其妙地出错——状态机跳到非法状态、计数器突然清零、数据偶尔出现乱码。Bug 完全随机，无法复现，仿真也抓不到。

如果你遇到了这种”玄学 Bug”，十有八九是亚稳态在作祟。这篇文章带你彻底搞懂亚稳态：它是什么、为什么会发生、以及怎么解决。

阅读指南： 本文较长，按需阅读即可。

必读：第1-5节（概念 + 原因 + 危害 + MTBF + 双触发器同步器）

进阶：第6-8节（多bit处理 + FPGA原语 + 仿真验证）

速查：第9-10节（常见误区 + 检查清单）

1. 什么是亚稳态

1.1 亚稳态的定义

亚稳态（Metastability） 是指触发器（D触发器、寄存器等）在输入信号违反建立时间（Setup Time）或保持时间（Hold Time）要求时，输出端出现的一种不确定的中间状态。

在理想情况下，数字电路的信号只有两种稳定状态：

逻辑 0：低电平
逻辑 1：高电平

但当触发器采样时刻恰好处于输入信号跳变的不确定窗口时，输出可能会：

停留在逻辑 0 和逻辑 1 之间的中间电平
在一段时间内持续振荡
经过一段不确定的时间后，才最终随机地稳定到 0 或 1

这种不确定的中间状态就是亚稳态。

1.2 触发器的时序参数

要理解亚稳态，首先需要了解触发器的关键时序参数：

           ┌─────────────┐
    D ─────┤             │
           │  D Flip-Flop│───── Q
    CLK ───┤             │
           └─────────────┘

关键时序参数：

建立时间 (Setup Time, Tsu)
- 在时钟有效边沿到来之前，数据信号必须保持稳定的最小时间
- 典型值：几十皮秒到几纳秒
保持时间 (Hold Time, Th)
- 在时钟有效边沿到来之后，数据信号必须继续保持稳定的最小时间
- 典型值：几十皮秒到几纳秒
建立保持时间窗口 (Setup-Hold Window)
- 建立时间和保持时间构成的时间窗口：Tw = Tsu + Th
- 在这个窗口内，数据不能发生变化

时序图示：

CLK    ___________┌─┐___________
                  │ │
D      ──────┐    │ │    ┌──────
             └────┼─┼────┘
                  │ │
              ◄─►◄─►◄─►
              Tsu │ Th
                  │
              时钟边沿

1.3 亚稳态的物理机制

触发器内部是由交叉耦合的逻辑门构成的锁存结构。当输入违反建立保持时间时：

正常采样：输入信号稳定，内部锁存结构能快速切换到明确的 0 或 1 状态
亚稳态：输入信号在窗口期变化，内部锁存结构的两个交叉耦合的反相器可能会：
- 同时尝试驱动对方到不同的状态
- 输出电压停留在阈值电压附近
- 需要更长的时间才能最终稳定

亚稳态电压示意：

Vdd ─────────────────────────── 逻辑 1

        ┌─────────────?
        │亚稳态电压范围
Vth ────┼────────────────────── 阈值电压
        │
        └─────────────?

Vss ─────────────────────────── 逻辑 0

2. 亚稳态产生的原因

2.1 跨时钟域信号传递

最常见的亚稳态来源是不同时钟域之间的信号传递。

// 危险示例：直接跨时钟域传递信号
module cross_domain_bad (
    input  wire clk_a,
    input  wire clk_b,
    input  wire rst,
    input  wire data_a,  // 来自时钟域A的信号
    output reg  data_b   // 目标时钟域B
);

always @(posedge clk_b or posedge rst) begin
    if (rst)
        data_b <= 1'b0;
    else
        data_b <= data_a;  // 危险！data_a可能违反建立保持时间
end

endmodule

问题分析：

data_a 由 clk_a 域产生，与 clk_b 不同步
data_a 的变化时刻相对于 clk_b 的上升沿是随机的
有可能恰好在 clk_b 上升沿的建立保持窗口内变化
导致 data_b 进入亚稳态

2.2 异步输入信号

来自外部的异步输入信号（如按键、传感器信号、外部接口信号）也可能导致亚稳态：

// 危险示例：直接采样异步输入
module async_input_bad (
    input  wire sys_clk,
    input  wire rst,
    input  wire async_in,  // 异步输入信号
    output reg  sync_out
);

always @(posedge sys_clk or posedge rst) begin
    if (rst)
        sync_out <= 1'b0;
    else
        sync_out <= async_in;  // 危险！async_in是异步的
end

endmodule

2.3 多时钟系统

在使用多个时钟的复杂系统中，不同时钟域之间的交互都可能产生亚稳态。

常见场景：

FPGA与外部ADC/DAC接口
多速率信号处理系统
网络接口（如以太网MAC）
外部存储器接口（DDR控制器）
异步FIFO设计

3. 亚稳态的危害

3.1 逻辑功能错误

亚稳态信号会导致后续逻辑产生不可预测的行为：

// 亚稳态危害示例
always @(posedge clk) begin
    if (meta_signal == 1'b1)    // meta_signal处于亚稳态
        counter <= counter + 1;  // 可能计数错误
    else
        counter <= counter;
end

如果 meta_signal 处于亚稳态（中间电平）：

下游逻辑可能将其识别为 0 或 1，结果不确定
更糟的是，同一个亚稳态信号可能被不同的门电路识别为不同的值

3.2 传播扩散

一个亚稳态信号可能影响多个逻辑单元：

亚稳态信号 ──┬──→ 逻辑A（识别为0）
             ├──→ 逻辑B（识别为1）
             └──→ 逻辑C（识别为？）

这会导致：

状态机进入非法状态
计数器产生错误计数
控制逻辑执行错误操作

3.3 系统不稳定

在关键控制路径上的亚稳态可能导致：

系统崩溃
数据损坏
安全隐患
难以调试的随机性故障

3.4 违反时序约束

亚稳态会延长触发器的 Tco（Clock-to-Output）时间：

正常: Tco = 0.5ns
亚稳态: Tco = 0.5ns + 不确定延迟（可能很长！）

这可能导致下一级时序路径违反时序要求。

💡 工程师手记：我第一次遇到亚稳态问题是在一个多时钟域的图像采集系统中。ADC 输出的数据用 ADC 自己的时钟锁存，然后我直接把数据连到了 FPGA 系统时钟域的处理模块——没有做任何跨时钟域处理。系统大部分时间工作正常，但每隔几分钟图像上就会出现一条随机的”花线”。排查了两天才意识到是亚稳态导致数据位偶尔采错。加了异步 FIFO 之后问题彻底消失。

（建议替换为你自己的真实经历，读者会更有共鸣）

4. 亚稳态的概率分析

4.1 MTBF（平均无故障时间）

亚稳态无法完全消除，但可以将其发生概率降低到可接受的水平。

MTBF 计算公式：

$$ MTBF = \frac{e^{T_{r} / \tau}}{f_{clk} \times f_{data}\times T_{w}} $$

其中：

MTBF：平均无故障时间（Mean Time Between Failures）
Tr：亚稳态恢复时间（Resolution Time）
τ：触发器的时间常数（工艺参数，典型值 100~300ps）
f_clk：采样时钟频率
f_data：数据变化频率
Tw：建立保持时间窗口（Setup-Hold Window）

关键结论：

增加 Tr（通过多级同步器）可以指数级提高 MTBF
Tr 每增加 1ns，MTBF 可以提高数十倍甚至数千倍

4.2 实际数值示例

假设：

f_clk = 100MHz
f_data = 10MHz
Tw = 200ps
τ = 200ps

Tr (恢复时间)	MTBF
0ns (单级)	0.02秒 (不可接受)
1ns (两级)	3.6小时
2ns (三级)	6800年
3ns (四级)	10^16年 (可接受)

结论：使用两级或三级同步器可以将 MTBF 提高到工程上可接受的水平。

5. 亚稳态的解决方案

5.1 双触发器（二级）同步器

最常用、最有效的方案是使用多级触发器同步链。

原理：

第一级触发器可能进入亚稳态
给它一个时钟周期的时间来稳定
第二级触发器采样已经稳定的信号
MTBF 得到指数级提升

标准实现：

// 双触发器同步器（推荐）
module sync_2ff (
    input  wire clk,        // 目标时钟域时钟
    input  wire rst_n,      // 异步复位（低电平有效）
    input  wire async_in,   // 异步输入信号
    output wire sync_out    // 同步输出信号
);

// 两级同步寄存器
(* ASYNC_REG = "TRUE" *) reg sync_ff1;  // 综合约束，防止优化
(* ASYNC_REG = "TRUE" *) reg sync_ff2;

// 第一级：可能进入亚稳态
always @(posedge clk or negedge rst_n) begin
    if (!rst_n)
        sync_ff1 <= 1'b0;
    else
        sync_ff1 <= async_in;
end

// 第二级：采样稳定后的信号
always @(posedge clk or negedge rst_n) begin
    if (!rst_n)
        sync_ff2 <= 1'b0;
    else
        sync_ff2 <= sync_ff1;
end

assign sync_out = sync_ff2;

endmodule

关键要点：

ASYNC_REG 属性：告诉综合工具这是异步信号同步器
- 防止综合工具优化掉中间级
- 指示布局布线工具将两级 FF 靠近放置，减小互连延迟
不要使用初始化值：避免使用 reg sync_ff1 = 0，应该用复位控制
延迟代价：引入 2 个时钟周期的延迟
只适用于单 bit 信号：不能用于多 bit 总线（会导致数据不一致）

5.2 三触发器同步器

对于更高的可靠性要求，可使用三级同步器：

// 三触发器同步器（高可靠性）
module sync_3ff (
    input  wire clk,
    input  wire rst_n,
    input  wire async_in,
    output wire sync_out
);

(* ASYNC_REG = "TRUE" *) reg sync_ff1;
(* ASYNC_REG = "TRUE" *) reg sync_ff2;
(* ASYNC_REG = "TRUE" *) reg sync_ff3;

always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        sync_ff1 <= 1'b0;
        sync_ff2 <= 1'b0;
        sync_ff3 <= 1'b0;
    end else begin
        sync_ff1 <= async_in;
        sync_ff2 <= sync_ff1;
        sync_ff3 <= sync_ff2;
    end
end

assign sync_out = sync_ff3;

endmodule

适用场景：

极高速时钟（>500MHz）
关键安全系统
数据完整性要求极高的应用

5.3 多 bit 信号的跨时钟域处理

对于多 bit 总线，不能直接使用多级同步器，因为不同 bit 可能在不同时刻稳定，导致数据错误。

方案 A：格雷码 (Gray Code)

对于计数器或缓慢变化的多 bit 信号，可以转换为格雷码：

// 格雷码同步器
module gray_sync #(
    parameter WIDTH = 4
)(
    // 发送时钟域
    input  wire                 clk_src,
    input  wire                 rst_n_src,
    input  wire [WIDTH-1:0]     data_src,  // 二进制输入
    
    // 接收时钟域
    input  wire                 clk_dst,
    input  wire                 rst_n_dst,
    output wire [WIDTH-1:0]     data_dst   // 二进制输出
);

// 源域：二进制转格雷码
reg [WIDTH-1:0] gray_src;
always @(posedge clk_src or negedge rst_n_src) begin
    if (!rst_n_src)
        gray_src <= {WIDTH{1'b0}};
    else
        gray_src <= data_src ^ (data_src >> 1);  // 二进制转格雷码
end

// 跨时钟域：双触发器同步（每个 bit 独立同步）
reg [WIDTH-1:0] gray_sync1;
reg [WIDTH-1:0] gray_sync2;

always @(posedge clk_dst or negedge rst_n_dst) begin
    if (!rst_n_dst) begin
        gray_sync1 <= {WIDTH{1'b0}};
        gray_sync2 <= {WIDTH{1'b0}};
    end else begin
        gray_sync1 <= gray_src;
        gray_sync2 <= gray_sync1;
    end
end

// 目标域：格雷码转二进制
reg [WIDTH-1:0] binary_dst;
integer i;
always @(*) begin
    binary_dst[WIDTH-1] = gray_sync2[WIDTH-1];
    for (i = WIDTH-2; i >= 0; i = i - 1)
        binary_dst[i] = binary_dst[i+1] ^ gray_sync2[i];
end

assign data_dst = binary_dst;

endmodule

格雷码特点：

相邻两个数只有 1 bit 不同
即使采样到中间状态，也只会误差 ±1
适用于计数器、FIFO 指针

方案 B：握手协议

对于任意多 bit 数据，使用请求-应答握手：

// 握手同步器（多bit数据跨时钟域）
module handshake_sync #(
    parameter DATA_WIDTH = 8
)(
    // 发送时钟域
    input  wire                     clk_src,
    input  wire                     rst_n_src,
    input  wire [DATA_WIDTH-1:0]    data_in,
    input  wire                     data_valid,  // 数据有效脉冲
    output reg                      data_ready,  // 准备接收下一个数据
    
    // 接收时钟域
    input  wire                     clk_dst,
    input  wire                     rst_n_dst,
    output reg  [DATA_WIDTH-1:0]    data_out,
    output reg                      data_out_valid  // 输出数据有效
);

// 源域：数据寄存和请求信号生成
reg [DATA_WIDTH-1:0] data_hold;
reg                  req;

always @(posedge clk_src or negedge rst_n_src) begin
    if (!rst_n_src) begin
        data_hold <= {DATA_WIDTH{1'b0}};
        req       <= 1'b0;
    end else begin
        if (data_valid && data_ready) begin
            data_hold <= data_in;
            req       <= ~req;  // 翻转请求信号
        end
    end
end

// 请求信号同步到目标域
wire req_sync;
sync_2ff u_req_sync (
    .clk      (clk_dst),
    .rst_n    (rst_n_dst),
    .async_in (req),
    .sync_out (req_sync)
);

// 目标域：检测请求信号变化
reg req_sync_d1;
wire req_toggle;

always @(posedge clk_dst or negedge rst_n_dst) begin
    if (!rst_n_dst)
        req_sync_d1 <= 1'b0;
    else
        req_sync_d1 <= req_sync;
end

assign req_toggle = req_sync ^ req_sync_d1;  // 检测翻转

// 目标域：接收数据和应答信号生成
reg ack;

always @(posedge clk_dst or negedge rst_n_dst) begin
    if (!rst_n_dst) begin
        data_out       <= {DATA_WIDTH{1'b0}};
        data_out_valid <= 1'b0;
        ack            <= 1'b0;
    end else begin
        if (req_toggle) begin
            data_out       <= data_hold;  // 采样数据
            data_out_valid <= 1'b1;
            ack            <= ~ack;       // 翻转应答信号
        end else begin
            data_out_valid <= 1'b0;
        end
    end
end

// 应答信号同步回源域
wire ack_sync;
sync_2ff u_ack_sync (
    .clk      (clk_src),
    .rst_n    (rst_n_src),
    .async_in (ack),
    .sync_out (ack_sync)
);

// 源域：检测应答完成
reg ack_sync_d1;

always @(posedge clk_src or negedge rst_n_src) begin
    if (!rst_n_src) begin
        ack_sync_d1 <= 1'b0;
        data_ready  <= 1'b1;
    end else begin
        ack_sync_d1 <= ack_sync;
        // 请求和应答相等时，表示传输完成，可以接收新数据
        data_ready  <= (req == ack_sync);
    end
end

endmodule

方案 C：异步 FIFO

对于连续数据流，最有效的方案是异步 FIFO：

// 简化的异步FIFO架构说明
// - 写指针在写时钟域递增（二进制）
// - 读指针在读时钟域递增（二进制）
// - 指针转换为格雷码后跨时钟域同步
// - 在对方时钟域比较格雷码指针，生成满/空标志

5.4 使用 FPGA 原语

某些 FPGA 提供了专用的跨时钟域原语：

Xilinx 示例：

// Xilinx XPM_CDC_SINGLE（单bit同步）
XPM_CDC_SINGLE #(
    .DEST_SYNC_FF   (2),       // 同步级数：2-10
    .INIT_SYNC_FF   (0),       // 初始化同步FF
    .SIM_ASSERT_CHK (0),       // 仿真断言检查
    .SRC_INPUT_REG  (1)        // 源域输入寄存器
) u_xpm_cdc_single (
    .dest_out (sync_out),      // 1-bit output: 同步后的信号
    .dest_clk (clk_dst),       // 1-bit input: 目标时钟
    .src_clk  (clk_src),       // 1-bit input: 源时钟（可选）
    .src_in   (async_in)       // 1-bit input: 输入信号
);

Intel (Altera) 示例：

// Altera ALTERA_MF 同步器
altera_std_synchronizer #(
    .depth (2)  // 同步链深度
) u_sync (
    .clk     (clk_dst),
    .reset_n (rst_n),
    .din     (async_in),
    .dout    (sync_out)
);

6. 亚稳态的仿真与验证

6.1 仿真中的挑战

亚稳态在常规 RTL 仿真中很难复现，因为：

仿真器使用离散事件模型，没有真实的中间电压
时序违例通常只会产生 X（未知态），而不是真实的亚稳态行为

6.2 强制注入亚稳态

可以在测试平台中强制注入亚稳态进行测试：

// 测试平台：强制注入亚稳态
module tb_metastability;

reg clk_a, clk_b, rst_n;
reg data_a;
wire data_b;

// 被测模块
sync_2ff dut (
    .clk      (clk_b),
    .rst_n    (rst_n),
    .async_in (data_a),
    .sync_out (data_b)
);

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

initial begin
    clk_b = 0;
    forever #7 clk_b = ~clk_b;   // 71.4MHz，与clk_a不同步
end

// 测试序列
initial begin
    rst_n = 0;
    data_a = 0;
    #100 rst_n = 1;
    
    // 随机变化data_a，增加建立保持违例的概率
    repeat (1000) begin
        #($urandom_range(1, 20)) data_a = $random;
    end
    
    #1000 $finish;
end

// 监测违例
always @(posedge clk_b) begin
    if (data_b === 1'bx)
        $display("Time %t: Metastability detected (X state)", $time);
end

endmodule

6.3 静态时序分析 (STA)

使用 EDA 工具的静态时序分析功能检查跨时钟域路径：

Vivado 示例：

# 检查跨时钟域路径
report_cdc -details -verbose

# 检查异步信号
report_methodology -checks {TIMING-*}

# 生成CDC报告
report_cdc -file cdc_report.txt

6.4 CDC (Clock Domain Crossing) 工具

专业的 CDC 验证工具：

Synopsys SpyGlass CDC
Cadence Conformal CDC
Mentor Questa CDC
Xilinx Vivado 内置 CDC 检查

7. 设计规范与最佳实践

7.1 设计规则

强制规则：所有跨时钟域信号必须同步
- 单 bit 控制信号：双触发器同步器
- 多 bit 数据：格雷码、握手、FIFO
- 绝不直接连接不同时钟域的信号
使用专用同步模块
- 创建参数化的同步器模块
- 统一管理和复用
- 便于约束和验证

添加综合和时序约束

# Vivado XDC 约束示例
# 标记异步信号
set_false_path -from [get_pins async_signal_reg/C] -to [get_pins sync_ff1_reg/D]

# 设置最大延迟约束
set_max_delay -datapath_only -from [get_clocks clk_src] -to [get_clocks clk_dst] 8.0

模块化隔离时钟域
- 清晰划分不同的时钟域模块
- 在模块边界处进行同步
- 避免时钟域在模块内部交叉

7.2 编码规范

// 推荐：集中管理跨时钟域信号
module top_design (
    input  wire clk_100m,
    input  wire clk_50m,
    input  wire rst_n,
    input  wire ext_signal,
    // ...
);

// 所有跨时钟域同步器放在顶层或专门的CDC模块中
wire ext_signal_sync;
sync_2ff u_ext_sync (
    .clk      (clk_100m),
    .rst_n    (rst_n),
    .async_in (ext_signal),
    .sync_out (ext_signal_sync)
);

// 域内模块只使用同步后的信号
domain_100m u_domain_100m (
    .clk    (clk_100m),
    .rst_n  (rst_n),
    .signal (ext_signal_sync),  // 已同步的信号
    // ...
);

endmodule

7.3 复位策略

对于跨时钟域的复位信号，也需要同步：

// 异步复位同步释放 (Asynchronous Assert, Synchronous Deassert)
module reset_sync (
    input  wire clk,
    input  wire async_rst_n,  // 异步复位输入（低电平有效）
    output reg  sync_rst_n    // 同步复位输出（低电平有效）
);

reg rst_sync_ff1;

always @(posedge clk or negedge async_rst_n) begin
    if (!async_rst_n) begin
        rst_sync_ff1 <= 1'b0;
        sync_rst_n   <= 1'b0;
    end else begin
        rst_sync_ff1 <= 1'b1;
        sync_rst_n   <= rst_sync_ff1;
    end
end

endmodule

原理：

复位的施加是异步的（立即响应）
复位的释放是同步的（避免部分触发器复位，部分未复位）

7.4 注释与文档

在代码中明确标注跨时钟域信号：

// 跨时钟域信号标注示例
module my_module (
    input  wire clk_sys,          // 系统时钟 100MHz
    input  wire clk_ext,          // 外部时钟 75MHz
    // ...
    
    input  wire ext_flag,         // CDC: 来自clk_ext域，需要同步到clk_sys
    output reg  sys_status        // CDC: 来自clk_sys域，需要同步到clk_ext
);

// 同步器：ext_flag (clk_ext -> clk_sys)
(* ASYNC_REG = "TRUE" *) reg ext_flag_sync1;  // CDC同步器第一级
(* ASYNC_REG = "TRUE" *) reg ext_flag_sync2;  // CDC同步器第二级

always @(posedge clk_sys) begin
    ext_flag_sync1 <= ext_flag;      // 可能进入亚稳态
    ext_flag_sync2 <= ext_flag_sync1; // 亚稳态已收敛
end

// 使用同步后的信号
wire ext_flag_safe = ext_flag_sync2;

// ...
endmodule

8. 实际案例分析

案例 1：按键消抖与同步

// 按键输入处理（消抖 + 同步）
module key_debounce_sync (
    input  wire sys_clk,        // 系统时钟 50MHz
    input  wire rst_n,
    input  wire key_in,         // 按键输入（异步、有抖动）
    output reg  key_press       // 按键按下脉冲（单时钟周期）
);

// 第一步：同步到系统时钟域（解决亚稳态）
(* ASYNC_REG = "TRUE" *) reg key_sync1;
(* ASYNC_REG = "TRUE" *) reg key_sync2;

always @(posedge sys_clk or negedge rst_n) begin
    if (!rst_n) begin
        key_sync1 <= 1'b1;  // 按键默认高电平（未按下）
        key_sync2 <= 1'b1;
    end else begin
        key_sync1 <= key_in;
        key_sync2 <= key_sync1;
    end
end

// 第二步：消抖（延迟20ms计数）
localparam DEBOUNCE_TIME = 1_000_000;  // 50MHz * 20ms = 1,000,000
reg [19:0] debounce_cnt;
reg        key_stable;

always @(posedge sys_clk or negedge rst_n) begin
    if (!rst_n) begin
        debounce_cnt <= 20'd0;
        key_stable   <= 1'b1;
    end else begin
        if (key_sync2 == key_stable) begin
            debounce_cnt <= 20'd0;
        end else begin
            if (debounce_cnt < DEBOUNCE_TIME)
                debounce_cnt <= debounce_cnt + 1'b1;
            else
                key_stable <= key_sync2;  // 稳定后更新
        end
    end
end

// 第三步：边沿检测（生成单周期脉冲）
reg key_stable_d1;

always @(posedge sys_clk or negedge rst_n) begin
    if (!rst_n) begin
        key_stable_d1 <= 1'b1;
        key_press     <= 1'b0;
    end else begin
        key_stable_d1 <= key_stable;
        // 检测下降沿（按键按下）
        key_press <= (~key_stable) && key_stable_d1;
    end
end

endmodule

案例 2：异步 FIFO 的指针同步

// 异步FIFO的写指针同步到读时钟域
module fifo_ptr_sync #(
    parameter ADDR_WIDTH = 4
)(
    // 写域
    input  wire                     wr_clk,
    input  wire                     wr_rst_n,
    input  wire [ADDR_WIDTH:0]      wr_ptr_binary,  // 写指针（二进制，含MSB用于满判断）
    
    // 读域
    input  wire                     rd_clk,
    input  wire                     rd_rst_n,
    output wire [ADDR_WIDTH:0]      wr_ptr_sync     // 同步后的写指针（格雷码->二进制）
);

// 步骤1：写域，二进制转格雷码
reg [ADDR_WIDTH:0] wr_ptr_gray;
always @(posedge wr_clk or negedge wr_rst_n) begin
    if (!wr_rst_n)
        wr_ptr_gray <= {(ADDR_WIDTH+1){1'b0}};
    else
        wr_ptr_gray <= wr_ptr_binary ^ (wr_ptr_binary >> 1);
end

// 步骤2：格雷码跨时钟域同步（多bit，但格雷码相邻只变1bit）
(* ASYNC_REG = "TRUE" *) reg [ADDR_WIDTH:0] wr_gray_sync1;
(* ASYNC_REG = "TRUE" *) reg [ADDR_WIDTH:0] wr_gray_sync2;

always @(posedge rd_clk or negedge rd_rst_n) begin
    if (!rd_rst_n) begin
        wr_gray_sync1 <= {(ADDR_WIDTH+1){1'b0}};
        wr_gray_sync2 <= {(ADDR_WIDTH+1){1'b0}};
    end else begin
        wr_gray_sync1 <= wr_ptr_gray;
        wr_gray_sync2 <= wr_gray_sync1;
    end
end

// 步骤3：读域，格雷码转二进制
reg [ADDR_WIDTH:0] wr_ptr_binary_sync;
integer i;
always @(*) begin
    wr_ptr_binary_sync[ADDR_WIDTH] = wr_gray_sync2[ADDR_WIDTH];
    for (i = ADDR_WIDTH-1; i >= 0; i = i - 1)
        wr_ptr_binary_sync[i] = wr_ptr_binary_sync[i+1] ^ wr_gray_sync2[i];
end

assign wr_ptr_sync = wr_ptr_binary_sync;

endmodule

案例 3：错误的多 bit 跨时钟域传输

// 错误示例：多bit信号直接同步
module multi_bit_bad (
    input  wire        clk_src,
    input  wire        clk_dst,
    input  wire        rst_n,
    input  wire [7:0]  data_src,
    output reg  [7:0]  data_dst
);

// 错误！每个bit独立同步，可能在不同时刻稳定
(* ASYNC_REG = "TRUE" *) reg [7:0] sync1;
(* ASYNC_REG = "TRUE" *) reg [7:0] sync2;

always @(posedge clk_dst or negedge rst_n) begin
    if (!rst_n) begin
        sync1 <= 8'd0;
        sync2 <= 8'd0;
    end else begin
        sync1 <= data_src;  // 8个bit可能在不同时钟周期稳定！
        sync2 <= sync1;
    end
end

assign data_dst = sync2;

endmodule