FPGA跨时钟域设计：亚稳态、同步器与异步FIFO实战

1. 从一个"看起来能跑"的电路说起

如果你写过一段时间的 FPGA 代码，大概率遇到过这种场景：仿真波形完美，时序报告干干净净，板子一上电，功能也正常。然后你加了一个新模块，用了另一个时钟，代码综合通过、时序也过了，但板子开始偶尔抽风——数据偶尔错一位，状态机偶尔跳到一个不该去的状态，复位之后又好了。你反复检查逻辑，怎么看都没问题。

这类问题的根源，十有八九是**跨时钟域（CDC，Clock Domain Crossing）**没处理好。它不像语法错误那样直接报错，也不像时序违例那样在报告里标红，它更像一颗定时炸弹：平时不响，温度一变、电压一抖、或者换一批芯片，就开始出问题。

这篇是"从近似 0 基础开始 FPGA 开发"系列的第 17 篇，专门讲 CDC、亚稳态和异步 FIFO。我假设你已经会写基本的 Verilog 模块、知道什么是时钟、跑过仿真、也上过板。如果你还没到这一步，建议先回头把前面关于时序逻辑和状态机的内容补一下。这篇文章的目标很明确：让你搞清楚亚稳态到底是怎么回事，为什么单比特和多比特信号的处理方式完全不同，以及异步 FIFO 到底该怎么写才不会在关键时刻掉链子。

我会尽量少堆公式，多用"这个东西到底在解决什么问题"的角度来讲。因为 CDC 这块知识，很多人是背下来的——知道要打两拍，但不知道为什么打两拍就够了，也不知道什么时候打两拍根本不够。把"为什么"搞明白，你后面遇到没见过的情况也能自己判断。

2. 亚稳态不是玄学，是触发器的物理特性

2.1 触发器为什么会有"建立时间"和"保持时间"

要理解亚稳态，得先接受一件事：触发器不是理想器件。它的输出不是瞬间翻转的，内部是靠正反馈把输入"锁"住的。数据要在时钟边沿到来之前稳定一段时间（建立时间 setup），并且在边沿之后还要保持一段时间（保持时间 hold），触发器才能可靠地采到值。

你可以把它想象成推一扇很重的门。你在门快要关上的那一刻去推，如果推得够早、够用力，门会顺畅地开；如果你在门缝只剩一条线的瞬间去推，门可能卡在中间——既没完全开，也没完全关。触发器遇到的就是这种情况：数据在建立/保持窗口内发生变化，内部节点被推到一个"不高不低"的中间电平。

这个中间电平就是亚稳态。它不会永远停在那里，正反馈最终会把它拉到 0 或 1，但需要一段不确定的时间，这段恢复时间叫决断时间（resolution time）。问题在于：如果下游电路在这段不确定时间内就去读这个值，读到的可能是 0，也可能是 1，甚至是振荡的中间值。

2.2 MTBF：亚稳态到底有多"危险"

工程上衡量亚稳态风险用的是MTBF（Mean Time Between Failures，平均无故障时间）。它大致和这几个因素有关：

• 时钟频率越高，边沿越密，撞上窗口的概率越大，MTBF 越低；
• 数据变化频率越高，越容易撞窗口；
• 触发器本身的决断速度越快（工艺越好），MTBF 越高；
• 你给亚稳态留的"恢复时间"越长（也就是多打几拍），MTBF 指数级上升。

这里有个反直觉的点：亚稳态不可能被完全消除，只能把它的发生概率压到足够低。你打两拍，不是"消灭"了亚稳态，而是让第一级触发器有整整一个时钟周期去决断，等第二级去采的时候，它已经稳定了。如果第一级还没稳定，第二级采到的仍然是亚稳态——只是这个概率已经小到可以忽略。

注意：很多教程说"打两拍就能消除亚稳态"，这个说法不严谨。准确的说法是"打两拍把亚稳态传播到下游的概率降到工程可接受的水平"。在超高频或者对可靠性要求极高的场景，可能要打三拍。

2.3 为什么"打两拍"是同步器的基本形态

单比特信号跨时钟域，最经典的做法就是两级触发器同步器：

// 单比特信号从 clk_a 域同步到 clk_b 域 reg sync_meta; reg sync_out; always @(posedge clk_b or negedge rst_n) begin if (!rst_n) begin sync_meta <= 1'b0; sync_out <= 1'b0; end else begin sync_meta <= async_in; // 第一级：可能进入亚稳态 sync_out <= sync_meta; // 第二级：采到已稳定的值 end end

第一级触发器叫"亚稳态采样级"，它的输出可能短暂处于中间态；第二级触发器用完整的 clk_b 周期去采第一级的输出，此时第一级大概率已经决断完毕。这样sync_out就是一个干净的、属于 clk_b 域的信号。

这里有个细节很多人忽略：第一级的输出不要扇出到别的地方。如果你把sync_meta直接拿去驱动别的逻辑，那你就把亚稳态传播出去了，同步器等于白做。只有sync_out才是安全的。

3. 单比特和多比特：为什么处理方式天差地别

3.1 单比特信号：慢一点没关系，错一拍是致命的

单比特信号跨时钟域，典型的是控制信号、使能、标志位。这类信号用两级同步器处理，但要注意一个陷阱：如果源信号只持续一个源时钟周期，目标时钟可能根本采不到它。

举个例子：clk_a 是 100MHz，clk_b 是 10MHz。clk_a 域产生一个单周期脉冲，宽度 10ns。clk_b 的周期是 100ns，这个脉冲很可能落在两次 clk_b 边沿之间，直接被漏掉。这不是亚稳态问题，是采样率问题。

解决办法是脉冲展宽或者握手。脉冲展宽就是把源域的脉冲拉长到目标域一定能采到；握手则是源域发出请求，等目标域回应之后再撤销。握手更可靠，但延迟更大。

还有一种情况是电平信号（比如一个持续为高的使能），这种用两级同步器就够了，因为它在目标域看来是"稳定"的，只是边沿位置不确定，同步器保证边沿干净即可。

3.2 多比特信号：为什么不能每个 bit 各打两拍

这是 CDC 里最经典的坑。假设你要把一个 4 位计数器从 clk_a 传到 clk_b，你给每一位都接一个两级同步器。看起来没问题？错。

问题在于：多位信号在跨时钟域时，各个 bit 的传播延迟可能不同。clk_a 域的值从0111变成1000，四位同时翻转。但在 clk_b 采样时，可能采到1111（还没翻完）或者0000（翻过头了），得到一个源域从未出现过的值。这叫数据一致性丢失。

所以多比特信号跨时钟域，有三条主流路线：

1. 格雷码（Gray Code）：让相邻值之间只翻转一位，这样即使采样时刻不对，最多采到相邻的合法值。适合连续变化的计数器，比如异步 FIFO 的读写指针。
2. 握手（Handshake）：源域把数据放稳，发请求；目标域确认收到后回应答；源域再撤销请求。数据在整个过程中保持不变，目标域采的时候一定是稳的。适合偶尔变化的数据。
3. 异步 FIFO：用双口 RAM 做缓冲，读写各自在自己的时钟域操作，靠格雷码指针判断空满。适合连续数据流。

3.3 格雷码的适用边界

格雷码不是万能的。它只适合每次只变化一个步进的场景，比如计数器加一。如果你要传的是一个任意跳变的数据（比如从 100 直接跳到 500），格雷码就不适用了，因为那需要翻转多位。

另外，格雷码转二进制、二进制转格雷码都有固定公式：

// 二进制转格雷码 gray = bin ^ (bin >> 1); // 格雷码转二进制 bin[N-1] = gray[N-1]; for (i = N-2; i >= 0; i = i - 1) bin[i] = bin[i+1] ^ gray[i];

在异步 FIFO 里，读写指针用格雷码跨域，就是为了保证指针采样的一致性。这个后面会详细讲。

4. 异步 FIFO：CDC 里的"重型武器"

4.1 异步 FIFO 到底解决什么问题

异步 FIFO 的核心价值是：让两个不同时钟域之间可以连续、高速地传数据，而不需要握手带来的延迟开销。它内部是一块双口 RAM，写端口在写时钟域，读端口在读时钟域，两边各有一套指针。

• 写指针：指向下一个要写的位置，只在写时钟域变化；
• 读指针：指向下一个要读的位置，只在读时钟域变化；
• 空标志：由读时钟域判断（读指针追上写指针就是空）；
• 满标志：由写时钟域判断（写指针追上读指针就是满）。

难点在于：读时钟域要知道写指针才能判断空，写时钟域要知道读指针才能判断满，而这两个指针各自属于对方的时钟域。所以指针必须跨时钟域同步，而且必须用格雷码。

4.2 指针为什么必须用格雷码

假设写指针是二进制，从 7（0111）加到 8（1000），四位全翻。读时钟域在采样这个指针时，可能采到 0000 到 1111 之间的任何值。如果采到一个比实际大的值，读逻辑会以为 FIFO 里还有数据，实际上已经空了，读出垃圾；如果采到比实际小的值，会误判为空，丢数据。

用格雷码之后，7 到 8 只翻一位（格雷码 0100 → 1100），读时钟域最多采到旧值或新值，不会采到中间态。这样空判断最多"晚一拍"或"早一拍"，但不会出现非法状态。

4.3 空满判断的细节：多一位的指针

异步 FIFO 的指针通常比地址位宽多一位。比如 RAM 深度是 16，地址是 4 位，指针用 5 位。为什么？为了区分"空"和"满"。

• 空：读指针 == 写指针（包括最高位）；
• 满：写指针和读指针的最高位不同，但低位相同。

这样用同一个指针宽度就能同时表达空和满，不需要额外的计数器。

// 满判断（写时钟域） wire full = (wptr_gray_next == {~rptr_gray_sync[ADDR_WIDTH], rptr_gray_sync[ADDR_WIDTH-1:0]}); // 空判断（读时钟域） wire empty = (rptr_gray_next == wptr_gray_sync);

这里的rptr_gray_sync是读指针同步到写时钟域后的格雷码，wptr_gray_sync是写指针同步到读时钟域后的格雷码。注意同步的是格雷码，不是二进制。

4.4 一个可综合的异步 FIFO 骨架

下面给一个参数化的异步 FIFO 核心结构，省略了 RAM 的具体实现（可以用双口 RAM IP，也可以用寄存器堆）：

module async_fifo #( parameter DATA_WIDTH = 8, parameter ADDR_WIDTH = 4 // 深度 = 2^ADDR_WIDTH )( input wire wclk, input wire wrst_n, input wire winc, input wire [DATA_WIDTH-1:0] wdata, output wire wfull, input wire rclk, input wire rrstd_n, input wire rinc, output wire [DATA_WIDTH-1:0] rdata, output wire rempty ); localparam PTR_WIDTH = ADDR_WIDTH + 1; reg [PTR_WIDTH-1:0] wptr_bin, wptr_gray; reg [PTR_WIDTH-1:0] rptr_bin, rptr_gray; // 跨时钟域同步后的指针 reg [PTR_WIDTH-1:0] wptr_gray_sync1, wptr_gray_sync2; reg [PTR_WIDTH-1:0] rptr_gray_sync1, rptr_gray_sync2; // 写指针逻辑 wire [PTR_WIDTH-1:0] wptr_bin_next = wptr_bin + (winc & ~wfull); wire [PTR_WIDTH-1:0] wptr_gray_next = wptr_bin_next ^ (wptr_bin_next >> 1); always @(posedge wclk or negedge wrst_n) begin if (!wrst_n) begin wptr_bin <= 0; wptr_gray <= 0; end else begin wptr_bin <= wptr_bin_next; wptr_gray <= wptr_gray_next; end end // 读指针逻辑 wire [PTR_WIDTH-1:0] rptr_bin_next = rptr_bin + (rinc & ~rempty); wire [PTR_WIDTH-1:0] rptr_gray_next = rptr_bin_next ^ (rptr_bin_next >> 1); always @(posedge rclk or negedge rrstd_n) begin if (!rrstd_n) begin rptr_bin <= 0; rptr_gray <= 0; end else begin rptr_bin <= rptr_bin_next; rptr_gray <= rptr_gray_next; end end // 读指针同步到写时钟域 always @(posedge wclk or negedge wrst_n) begin if (!wrst_n) begin rptr_gray_sync1 <= 0; rptr_gray_sync2 <= 0; end else begin rptr_gray_sync1 <= rptr_gray; rptr_gray_sync2 <= rptr_gray_sync1; end end // 写指针同步到读时钟域 always @(posedge rclk or negedge rrstd_n) begin if (!rrstd_n) begin wptr_gray_sync1 <= 0; wptr_gray_sync2 <= 0; end else begin wptr_gray_sync1 <= wptr_gray; wptr_gray_sync2 <= wptr_gray_sync1; end end // 满判断 assign wfull = (wptr_gray_next == {~rptr_gray_sync2[PTR_WIDTH-1:PTR_WIDTH-1], rptr_gray_sync2[PTR_WIDTH-2:0]}); // 空判断 assign rempty = (rptr_gray_next == wptr_gray_sync2); // RAM 实例化（略），写端口用 wptr_bin[ADDR_WIDTH-1:0]， // 读端口用 rptr_bin[ADDR_WIDTH-1:0] endmodule

这段代码有几个关键点值得展开：

第一，指针更新用的是"下一拍值"参与比较。比如wfull用的是wptr_gray_next和同步过来的读指针比较，而不是当前wptr_gray。这是因为满判断要在写指针即将追上读指针时就拉高，防止多写一个。空判断同理。

第二，同步链是两级。rptr_gray_sync1和rptr_gray_sync2构成标准两级同步器。有些设计会加第三级，取决于时钟频率和可靠性要求。

第三，复位是分开的。写域用wrst_n，读域用rrst_n。异步 FIFO 的两个域复位可以不同步，但要注意复位释放的时刻，最好用复位同步器处理，避免复位撤销时的亚稳态。

4.5 深度不是 2 的幂怎么办

上面的设计假设 FIFO 深度是 2 的幂，这样格雷码才能循环。如果深度是 10、24 这种非 2 的幂，格雷码的循环特性就被破坏了，指针从最大值回到 0 时可能翻转多位。

工程上有两种处理方式：

• 向上取整到 2 的幂：深度 10 就做成 16，浪费一点 RAM，但逻辑简单可靠。这是最常用的做法。
• 用专门的算法生成非 2 的幂格雷码：复杂度高，容易出错，除非 RAM 极其紧张，否则不建议。

我个人的经验是：能用 2 的幂就用 2 的幂。FPGA 里的 BRAM 本来就是按块分配的，你省那几个位置，可能反而因为地址译码逻辑变复杂而多耗 LUT，得不偿失。

5. 那些仿真看不出来、上板才炸的坑

5.1 复位同步：被忽视的重灾区

异步 FIFO 的两个域复位不同步，如果复位释放的时刻正好落在某个时钟的建立/保持窗口，触发器可能进入亚稳态。更麻烦的是，两个域的复位释放时刻不同，可能导致指针初始状态不一致。

标准做法是复位同步器：异步复位、同步释放。每个时钟域各用一个：

module reset_sync ( input wire clk, input wire arst_n, output wire srst_n ); reg rst_sync1, rst_sync2; always @(posedge clk or negedge arst_n) begin if (!arst_n) begin rst_sync1 <= 1'b0; rst_sync2 <= 1'b0; end else begin rst_sync1 <= 1'b1; rst_sync2 <= rst_sync1; end end assign srst_n = rst_sync2; endmodule

这样复位撤销时，srst_n的上升沿是和clk同步的，不会产生亚稳态。

5.2 同步器上的"组合逻辑污染"

我见过不少代码，在同步器的第一级前面接了组合逻辑：

// 错误示范 always @(posedge clk_b) begin sync1 <= a & b | c; // 组合逻辑直接进同步器 sync2 <= sync1; end

如果a & b | c在 clk_b 的边沿附近有毛刺，第一级触发器采到的就是毛刺，同步器同步的是一个错误的值。正确做法是：源信号先在源时钟域寄存一拍，再进同步器。这样进同步器的信号是干净的、稳定的。

5.3 多比特信号"看起来用了格雷码"但没用对

有些设计者知道要用格雷码，但用错了地方。比如把数据本身转成格雷码传过去，而不是把指针转成格雷码。数据是任意值，转成格雷码之后相邻值仍然可能翻转多位，没有意义。格雷码只对"连续步进"的量有效。

还有一种情况：指针用了格雷码，但空满判断时又转回二进制比较。这等于把格雷码的好处抵消了。空满判断必须直接在格雷码上做。

5.4 时序约束：CDC 路径要"放过"

跨时钟域的路径，静态时序分析（STA）是分析不了的，因为两个时钟没有固定相位关系。如果你不做处理，工具会报一堆无法满足的时序违例。

正确做法是用set_false_path或set_clock_groups告诉工具：这些路径不用分析。

# 方法一：设置时钟组，两个时钟异步 set_clock_groups -asynchronous \ -group {clk_a} \ -group {clk_b} # 方法二：对特定路径设 false path set_false_path -from [get_clocks clk_a] -to [get_clocks clk_b] set_false_path -from [get_clocks clk_b] -to [get_clocks clk_a]

注意：set_false_path是"不分析"，不是"保证正确"。你设了 false path，工具就不管了，正确性完全靠你的同步器设计。所以约束和设计必须配套，不能只写约束不管逻辑。

5.5 仿真为什么测不出 CDC 问题

普通的功能仿真里，触发器的行为是理想的：要么 0 要么 1，没有中间态，也没有建立/保持时间。所以亚稳态在 RTL 仿真里根本不会出现。你跑一万遍仿真，波形都是干净的。

要验证 CDC，得用专门的方法：

• CDC 静态检查工具：比如 SpyGlass CDC、Questa CDC，能在不仿真的情况下扫描设计，找出缺少同步器的跨时钟域路径。
• 门级仿真带 SDF 反标：综合后的网表加上时序信息，仿真时可能复现亚稳态，但覆盖率有限，跑得也慢。
• 硬件实测：最终还是要上板，用真实数据流压测。

我个人的习惯是：CDC 路径写完，先用工具的 CDC 检查过一遍，再上板。纯靠仿真和肉眼检查，漏掉的概率很高。

6. 几个实际项目里的判断经验

6.1 什么时候该用异步 FIFO，什么时候握手就够

不是所有跨时钟域都要上异步 FIFO。判断标准是数据率和延迟容忍度：

握手的问题是每次传输都要等几个时钟周期，数据率高的时候根本扛不住。异步 FIFO 的问题是占 RAM 资源，而且设计复杂。选哪个，取决于你的数据特征。

6.2 FIFO 深度怎么估

异步 FIFO 的深度估算是个经验活。核心思路是：在最坏情况下，写端写入的数据量不能超过 FIFO 剩余空间，否则溢出。

简化估算公式：

深度 >= 突发长度 - (突发长度 / 写时钟频率) * 读时钟频率

举个例子：写时钟 100MHz，读时钟 80MHz，写端一次突发 1000 个数据。在写这 1000 个数据的时间里，读端能读走1000 * 80/100 = 800个，所以 FIFO 至少要能存1000 - 800 = 200个。再留点余量，取 256（2 的幂）。

实际项目中还要考虑空满标志的同步延迟（通常 2-3 个时钟周期），以及读写使能的响应延迟。保守一点，把估算值乘以 1.5 到 2 倍。

6.3 空满标志的"保守性"

异步 FIFO 的空满标志有一个重要特性：它们是保守的。

• 空标志拉高时，FIFO 可能实际上还有数据（因为写指针同步过来有延迟）；
• 满标志拉高时，FIFO 可能实际上还有空间（因为读指针同步过来有延迟）。

这种保守性是安全的：空的时候不读，满的时候不写，不会出错。但会影响吞吐率。如果你发现 FIFO 吞吐率上不去，先检查是不是空满标志太保守，而不是急着加深度。

6.4 跨时钟域信号命名规范

这是个软性但很重要的经验：给跨时钟域的信号加后缀，比如_cdc、_sync、_meta。这样你在 review 代码或者跑 CDC 工具时，一眼就能看出哪些信号是跨域的。

我见过太多项目，信号命名混乱，CDC 路径藏在几千行代码里，工具报了几百条警告，根本分不清哪些是真问题、哪些是误报。命名规范能省下大量排查时间。

7. 写在最后的一点个人体会

CDC 这块知识，最大的特点是"平时用不上，用上就是大事"。你写十个模块可能九个都不涉及跨时钟域，但一旦涉及，处理不好就是偶发性故障，排查起来极其痛苦——因为它不可复现，换个板子、换个温度，现象就变了。

我的建议是：把同步器做成标准模块，项目里统一调用。不要每次手写两级触发器，容易漏掉复位、容易把第一级扇出出去。异步 FIFO 也一样，用经过验证的模板，参数化深度和位宽，不要每次重新造轮子。

另外，CDC 检查要尽早做。不要等到项目后期才跑工具，那时候改动的代价太大。写完一个跨时钟域模块，立刻跑一遍 CDC 检查，把问题扼杀在早期。

最后说一个心态问题：亚稳态无法根除，只能管理。接受这一点，你就不会纠结于"为什么打了两拍还会出问题"，而是会去思考"我的 MTBF 够不够、我的同步链级数对不对、我的约束写没写全"。工程上的可靠性，从来不是靠消灭风险，而是靠把风险控制在可接受的范围内。