跨异步时钟域的6种方法

已于 2023-06-01 15:51:22 修改
阅读量1.1w 收藏 190
点赞数 28
文章标签： fpga开发
于 2021-05-25 17:27:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z951573431/article/details/117260698
版权

方法1 双触发器（打2拍）

该方法只用于慢到快时钟域的1bit信号传递。在Xilinx器件中，可以使用(* ASYNC_REG = "TRUE" *)标记，将两个寄存器尽量靠近综合，降低 亚稳态因导线延迟太大而传播到第二个寄存器的可能性。

module ff2(
    input  clk0,//10M
    input  din,
    input  clk1,//100M
    output dout
);
    reg din_r=1'd0;
    (* ASYNC_REG = "TRUE" *)
    reg r0=1'd0;
    (* ASYNC_REG = "TRUE" *)
    reg r1=1'd0;
    assign dout = r1;
    always@(posedge clk0)
        din_r <= din;//由于不确定前级是否有触发器，这里默认加一级寄存，防止出现毛刺
    always@(posedge clk1)begin
    	r0    <= din_r;
        r1    <= r0;
    end
endmodule

方法2 双向握手 传递信号

双向握手方法使用了5个触发器，右边3个与方法1一致。左边两个用于将确认信号同步到写时钟域。用户必须将信号保持到确认信号置高。
该方法适用于慢到快、快到慢、1bit信号传递，一般而言，信号有效值为高电平。

在这里插入图片描述
可以用一个非门、一个异或门、一个与门，和一个触发器（下图中的reg-2）实现信号保持，输入低速单脉冲,但是不保证输出单脉冲，可以在输出端加一个寄存器，用于上升沿判断.
在这里插入图片描述
在verilog可以用一些简单的判断来保持信号。下面是一个单向信号异步桥，支持单脉冲输入，单脉冲输出，时钟速率无限制
使用时，确保在active置低时，将s_vld给异步桥。

/* 
*   Name  : 单向信号异步桥
*   Origin: 230406
*   EE    : hel
*/
module signalbridge_async(
    input   wire                s_clk   ,
    input   wire                s_rstn  ,
    input   wire                s_vld   ,// pulse input 

    input   wire                d_clk   ,
    input   wire                d_rstn  ,
    output  reg                 d_vld   ,// pulse output 

    output  wire                active   
);
reg [1   :0] s_syncer ;
reg [1   :0] d_syncer ;
wire         ack_d2 = s_syncer[1];
wire         req_d2 = d_syncer[1];    
reg          req_d3;
reg          async_req;
wire         async_ack = req_d2;
assign       active = async_req | ack_d2 ;
// Source clock domain
always @(posedge s_clk or negedge s_rstn) begin
    if (!s_rstn) begin
        s_syncer   <= 2'd0;
    end else begin
        s_syncer   <=  {s_syncer[0],async_ack};
    end
end
always @(posedge s_clk or negedge s_rstn) begin
    if (!s_rstn) begin
        async_req   <= 1'd0;
    end else if(ack_d2)begin
        async_req   <= 1'd0;
    end else if(s_vld)begin
        async_req   <= 1'd1;
    end
end
// Destination clock domain
always @(posedge d_clk or negedge d_rstn) begin
    if (!d_rstn) begin
        d_syncer   <= 2'd0;
    end else begin
        d_syncer   <=  {d_syncer[0],async_req};
    end
end
always @(posedge d_clk or negedge d_rstn) begin
    if (!d_rstn) begin
        req_d3      <= 1'd0;
        d_vld       <= 1'd0;
    end else begin
        req_d3      <= req_d2;
        d_vld       <= req_d2 & (~req_d3);
    end 
end
endmodule

方法3 双向握手 传递数据

可以使用请求信号采样跨时钟域过来的多比特数据，就可以做到数据的跨时钟域了（数据跨时钟域，频率低到高，高到低）如下图：

在这里插入图片描述
图里没有画反馈信号，数据需要在目的时钟采样时保持稳定。这种单个数据跨时钟域传输的编写流程如下：

  • 原时钟域置高req，置好data
  • 目的时钟域将req打两拍变成req_d2
  • 目的时钟域检测到req_d2置高，将data打到寄存器内，并将ack置高
  • 原时钟域检测到ack_d2被置高，拉低req
  • 目的时钟域检测到req_d2被拉低，将ack拉低

通过上述流程编写的数据异步桥如下：
支持单个数据输入输出，时钟速率无限制。使用时，确保在active置低时，将s_din和s_vld给异步桥，s_vld必须为单脉冲。

/* 
*   Name  : 单向数据异步桥
*   Origin: 230404
*   EE    : hel
*/
module databridge_async #(
    parameter DW = 8
)(
    input   wire                s_clk   ,
    input   wire                s_rstn  ,
    input   wire    [DW-1:0]    s_din   ,
    input   wire                s_vld   , // pulse input 

    input   wire                d_clk   ,
    input   wire                d_rstn  ,
    output  reg     [DW-1:0]    d_dout  ,
    output  reg                 d_vld   ,// pulse output 

    output  wire                active   
);
reg [1   :0] s_syncer ;
reg [1   :0] d_syncer ;
wire         ack_d2 = s_syncer[1];
wire         req_d2 = d_syncer[1];    
reg          req_d3;
reg [DW-1:0] async_dat;
reg          async_req;
wire         async_ack = req_d2;
assign       active = async_req | ack_d2 ;
// Source clock domain
always @(posedge s_clk or negedge s_rstn) begin
    if (!s_rstn) begin
        s_syncer   <= 2'd0;
    end else begin
        s_syncer   <=  {s_syncer[0],async_ack};
    end
end
always @(posedge s_clk or negedge s_rstn) begin
    if (!s_rstn) begin
        async_dat   <= {DW{1'd0}};
    end else if(s_vld && (!active))begin
        async_dat   <=  s_din;
    end
end
always @(posedge s_clk or negedge s_rstn) begin
    if (!s_rstn) begin
        async_req   <= 1'd0;
    end else if(ack_d2)begin
        async_req   <= 1'd0;
    end else if(s_vld)begin
        async_req   <= 1'd1;
    end
end
// Destination clock domain
always @(posedge d_clk or negedge d_rstn) begin
    if (!d_rstn) begin
        d_syncer   <= 2'd0;
    end else begin
        d_syncer   <=  {d_syncer[0],async_req};
    end
end
always @(posedge d_clk or negedge d_rstn) begin
    if (!d_rstn) begin
        d_dout      <= {DW{1'd0}};
    end else if(req_d2)begin
        d_dout      <= async_dat;
    end 
end
always @(posedge d_clk or negedge d_rstn) begin
    if (!d_rstn) begin
        req_d3      <= 1'd0;
        d_vld       <= 1'd0;
    end else begin
        req_d3      <= req_d2;
        d_vld       <= req_d2 & (~req_d3);
    end 
end
endmodule

testbench：

`timescale 1ns/1ps
module databridge_async_tb ();
parameter DW = 8;
reg s_clk  = 0;
reg s_rstn = 0;
reg [DW-1:0] s_din = 0;
reg s_vld = 0;
reg d_clk  = 0;
reg d_rstn = 0;
wire [DW-1:0] d_dout;
wire d_vld;
wire active;
reg [DW-1:0]buffer ;
real ts;
real td;
real a;
real b;
real clkstp;
always #(ts)  s_clk <= ~s_clk;
always #(td)  d_clk <= ~d_clk;
databridge_async #(DW) databridge_async
(
    .s_clk   ( s_clk  ),
    .s_rstn  ( s_rstn ),
    .s_din   ( s_din  ),
    .s_vld   ( s_vld  ),
    .d_clk   ( d_clk  ),
    .d_rstn  ( d_rstn ),
    .d_dout  ( d_dout ),
    .d_vld   ( d_vld  ),
    .active  ( active )
);
task automatic gen_trans;
input [DW-1:0]data;
begin
    #0
    s_vld  =  1;
    s_din  = data;
    @(posedge s_clk);
    #0
    s_vld  =  0;
    s_din  =  0;
end
endtask //automatic

task automatic wait_busy;
begin
    @(posedge s_clk);#0;
    while (active) begin
        @(posedge s_clk);#0;
    end
end
endtask //automatic

task automatic loop_test;
input integer n;
integer i;
reg [63:0]random_dat;
begin
    for (i = 0;i<n ;i=i+1 ) begin
        random_dat = {$random} % (2**DW);
        gen_trans(random_dat[DW-1:0]);
        wait_busy();  
        if (buffer != random_dat[DW-1:0]) begin
            $display("error missmatch, send:0x%x, recv:0x%x",random_dat[DW-1:0],buffer);
            #100
            $finish;
        end 
        $display("%0d/%0d 0x%0x==0x%0x",i+1,n,random_dat[DW-1:0],buffer);     
    end
    $display("FULL PASS %0d",n);
end
endtask //automatic

always @(posedge d_clk) begin
    buffer <= (d_vld)?d_dout:buffer;
end

initial begin 
    ts = 3.333;
    td = 10.567;
    #3000;
    ts = 10.567;
    td = 3.333;
    while ( clkstp!=1 ) begin
        #3000;
        a = {$random}%300;
        b = {$random}%300;
        ts = a<10 ?10:a;
        td = b<10 ?10:b;
    end
end
initial begin
    // $dumpfile("wave.vcd");                  //生成的vcd文件名称
    // $dumpvars(0, databridge_async_tb);      //tb模块名称
    clkstp = 0;
    #10 s_rstn = 1;
    #10 d_rstn = 1;
    #10;
    @(posedge s_clk);
    loop_test(10000);
    #1000;
    clkstp = 1;
    $finish;
end
endmodule

方法4 转为独热码或格雷码

  • 如果多bit信号是简单连续变化（连续加一或减一），可以将其转为格雷码，再打2拍到目标时钟域，最终再解码为二进制编码。

  • 如果多bit信号没有变化规律，可以将其转为独热码，再打2拍到目标时钟域，最终再解码为二进制编码。该方法适用于慢到快、多bit信号传递。

  • 为什么data不能直接通过同步器过域：
    在这里插入图片描述
    多比特数据由于存在传输路径延迟，到达同步器有先后顺序，导致同步器采样到不同电平，输出错误数据。
    根本原因是源端数据有多个bit发生跳变。如果每次只有一个bit跳变（连续变化格雷码、独热码），就一定能采样到正确的数据。
    假如目的时钟非常慢，比原时钟慢很多，在慢时钟上升沿时还是能采到正确数据，可能采到跳变之前的也可能是之后的，但总之都是source的数据。如果采到跳变之前的数据，就会产生异步FIFO的虚空虚满。从这个角度看，异步FIFO是绝对安全的（忽略同步器失效），异步FIFO两边的时钟频率没有任何要求。

方法5 深度为2的ASYNC-FIFO

在传输信号，不需要较高带宽时，可以将普通格雷码异步FIFO特化为2-deep ASYNC-FIFO，该方法适用于慢到快、快到慢、多bit信号传递。一般很少使用2deep-FIFO，而是使用双向握手来传递单个多比特数据。
在这里插入图片描述

方法6 ASYNC-FIFO

该方法适用于慢到快、快到慢、多bit数据传递。

module async_fifo //（First_Word_Fall_Through FIFO，数据提前输出，可能不利于时序收敛）
#(
    parameter integer DATA_WIDTH = 16 ,
    parameter integer ADDR_WIDTH = 8   //深度只能是2**ADDR_WIDTH 
)
(
    input   wire                 wr_rst  ,    
    input   wire                 wr_clk  ,    
    input   wire                 wr_ena  ,    
    input   wire[DATA_WIDTH-1:0] wr_dat  , 
    output  wire                 wr_full ,

    input   wire                 rd_rst  ,  
    input   wire                 rd_clk  ,    
    input   wire                 rd_ena  ,    
    output  wire[DATA_WIDTH-1:0] rd_dat  , 
    output  wire                 rd_empty 
);
reg  [DATA_WIDTH-1:0]mem[0:2**ADDR_WIDTH-1];
reg  [ADDR_WIDTH  :0]wrptr;
reg  [ADDR_WIDTH  :0]rdptr;
wire [ADDR_WIDTH-1:0]wraddr = wrptr[ADDR_WIDTH-1:0];
wire [ADDR_WIDTH-1:0]rdaddr = rdptr[ADDR_WIDTH-1:0];
wire [ADDR_WIDTH  :0]wrptr_gray = (wrptr>>1)^wrptr;
wire [ADDR_WIDTH  :0]rdptr_gray = (rdptr>>1)^rdptr;

reg  [ADDR_WIDTH  :0]wrptr_gray_r0;
reg  [ADDR_WIDTH  :0]wrptr_gray_r1;
reg  [ADDR_WIDTH  :0]rdptr_gray_r0;
reg  [ADDR_WIDTH  :0]rdptr_gray_r1;
assign wr_full  = (wrptr_gray == {~rdptr_gray_r1[ADDR_WIDTH:ADDR_WIDTH-1],rdptr_gray_r1[ADDR_WIDTH-2:0]});
assign rd_empty = (rdptr_gray == wrptr_gray_r1);//在有些设计中，full和empty提早一个时钟出现，并加了一级寄存，这有助于收敛
always @(posedge wr_clk or posedge wr_rst) begin
    if (wr_rst) begin
        rdptr_gray_r0 <= 'd0;
        rdptr_gray_r1 <= 'd0;
    end else begin
        rdptr_gray_r0 <= rdptr_gray;
        rdptr_gray_r1 <= rdptr_gray_r0;
    end
end
always @(posedge rd_clk or posedge rd_rst) begin
    if (rd_rst) begin
        wrptr_gray_r0 <= 'd0;
        wrptr_gray_r1 <= 'd0;
    end else begin
        wrptr_gray_r0 <= wrptr_gray;
        wrptr_gray_r1 <= wrptr_gray_r0;
    end
end
always @(posedge wr_clk or posedge wr_rst) begin
    if (wr_rst) begin
        mem[0]      <= 'd0;
        wrptr       <= 'd0;
    end else if (wr_ena&&(!wr_full)) begin
        mem[wraddr] <= wr_dat;
        wrptr       <= wrptr + 1'd1;
    end else begin
        mem[wraddr] <= mem[wraddr];
        wrptr       <= wrptr;
    end
end
always @(posedge rd_clk or posedge rd_rst) begin
    if (rd_rst) begin
        rdptr       <= 'd0;
    end else if (rd_ena&&(!rd_empty)) begin
        rdptr       <= rdptr + 1'd1;
    end else begin
        rdptr       <= rdptr;
    end
end
assign rd_dat = mem[rdaddr];
endmodule
昨日傍晚
关注
  • 28
    点赞
  • 踩
  • 190
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
跨时钟域处理3大方法揭晓
03-15
跨时钟域处理的3大方法，讲的很细，很清楚，很适合初学者的学习
基于PCIExpress的多核SoC片间异步桥设计与实现
08-26
基于PCIExpress的多核SoC片间异步桥设计与实现
【CDC】跨时钟域处理方法总结一
xulu1588的博客
07-31 721
异步时序就是一个设计中有多个时钟，每个时钟的源头不一样，即：多个时钟之间无确定性关系，称为异步时序。
跨时钟域异步处理方法
qq_43053845的博客
01-29 344
信号分为电平信号和脉冲信号，也可以分为单比特信号和多比特信号。
跨时钟域传输数据——单bit和多bit信号（总结）
qq_42135020的博客
04-07 3730
总结单bit和多bit信号的跨时钟域传输
跨时钟域方法（同步器、异步FIFO、边沿检测器、脉冲同步器、同步FIFO）
m0_53333865的博客
11-09 1661
跨时钟域方法（同步器、异步FIFO、边沿检测器、脉冲同步器、同步FIFO）
跨时钟域处理方法
好好学习，天天向上
08-16 9704
跨时钟域处理
跨时钟域处理方法总结--最终详尽版跨时钟域处理--最终详尽版
messi_cyc的专栏
02-13 5229
IC
跨时钟域传输总结（包含verilog代码|Testbench|仿真结果）
Loudrs的博客
06-08 5020
采样中“快到慢”与“慢到快”在考虑问题时有什么区别？只需要考虑亚稳态问题除亚稳态问题外，还需考虑慢时钟的采样速率问题。因为根据采样定理，采样频率低于信号最高频率2倍的时候，是无法完整采样的。CDC传输方法总结：慢到快只考虑亚稳态问题，采用延迟打拍法；快到慢还需要考虑慢时钟采样速度，但是只要延长信号长度即可。常用方法为电平同步器、脉冲同步器、握手协议。其中，握手协议限制较为灵活，但握手信号需要在两个时钟域来回传递导致延时很大，所以握手协议是以牺牲效率为代价保证信号传递质量。
apb/axi异步桥实现
cy413026的博客
03-20 9955
1.基本异步处理电路 1.1电平同步 1.2脉冲同步 现将脉冲变成电平，同步之后再恢复， 1.下面是脉冲展电平的做法 2.下面是电平恢复脉冲 1.3异步fifo 1.4demux同步 DEBUX通过一个同步到目标时钟域的信号作为目标时钟域多比特数据更新的使能信号 2.Qualifier synchronization 其实和demux很相像，先选择一个quali...
时钟的同步与异步问题
啦啦啦啦啦
08-04 4527
时钟的同步与异步问题，是一个很基础，但是很常见的问题，本文简单总结笔者理解的相关问题，用于对时钟之间同步异步问题进行简单的判断。时钟相关的属性有频率，相位，是否同源。判断时钟的同步异步，是否同源是一个决定性的因素。。首先需要对时钟的同步异步进行划分的原因是需要满足触发器的建立时间与保持时间，而异步时钟即使是相同的频率，也没有办法确定相位，也是没有办法进行静态时序分析的。因此需要对两种时钟进行区分。......
跨时钟域信号处理中同步通信的设计的重要性及解决方法
01-19
上次提出了一个处于异步时钟域的MCU与FPGA直接通信的实现方式，其实在这之前，特权同学想列举一个异步时钟域中出现的很典型的问题。也就是要用一个反例来说明没有足够重视异步通信会给整个设计带来什么样的危害。 　　特权同学要举的这个反例是真真切切的在某个项目上发生过的，很具有代表性。它不仅会涉及使用组合逻辑和时序逻辑在异步通信中的优劣、而且能把亚稳态的危害活生生的展现在你面前。 　　从这个模块要实现的功能说起吧，如图1所示，实现的功能其实很简单的，就是一个频率计，只不过FPGA除了脉冲采集进行计数外，还要响应CPU的控制。 　　 　　图1 功能模块 　　CPU的控
跨时钟域处理3大方法揭秘1
08-03
1. 打两拍 2. 异步双口 RAM 3. 格雷码转换
基于FPGA的异步跨时钟域设计-论文
05-18
基于FPGA的异步跨时钟域设计
46-FPGA跨时钟域异步FIFO设计.7z
03-17
FPGA跨时钟域异步FIFO设计,Vivado仿真工程
源同步信号跨时钟域采集的两种方法
08-04
对于数据采集接收的一方而言，所谓源同步信号，即传输待接收的数据和时钟信号均由发送方产生。FPGA应用中，常常需要产生一些源同步接口信号传输...当然，无论何种情况，目的只有一个，保证信号稳定可靠的被传送或接收。
基于FPGA设计跨时钟域的同步策略
01-19
本文总结出了几种同步策略来解决跨时钟域问题。 　2 异步设计中的亚稳态 　触发器是FPGA设计中常用的基本器件。触发器工作过程中存在数据的建立（setup）和保持（hold）时间。对于使用上升沿触发的触发器来说，...
基于FPGA轻松玩转AI
YEYUANGEN的专栏
04-11 1638
同时，与基于GPU或ASIC的解决方案相比，FPGA提供了许多优势，其中包括易于集成多个接口和传感器，以及适应新神经网络架构的灵活性（图4）。受益于像Xilinx Zynq UltraScale+ MPSoC 这样的FPGA，AI现在也可以离线使用或在边缘部署、使用.可用于开发和部署用于实时推理的机器学习应用，因此将AI集成到应用中变得轻而易举。对于一个最先进的网络来说，它可能需要数天到数周的时间，需要数十亿的浮点计算和大量的训练数据(GByte到数百GByte)，直到网络达到所需的精度。
考试酷基本功修炼课学习历程＿FPGA成长篇
最新发布
MDYFPGA的博客
04-14 922
还是喜欢数字电路课程的同学，不管你是集成电路专业，微电子专业的学生，还是硬件工程师，不管你是想提高逻辑思维能力的人士，还是准备工作面试的人士，都是可以学习的。最开始的时候，做起来也不是很顺利，因为涉及内容很多，总会有不太懂的内容，这时可以准备一个记事本，把易错题记录下来，对不理解的语句画出波形来分析，总之，不管是即将毕业找工作的还是想快速复盘的，还是初学者快速入门的都是非常适合的，不管你是英语差的偏科生，具有数学天分的中专以上的学生，题型通常包含:代码，波形图，答案，答案解析组成的，我们根据项目的经验，
异步FIFO地址可以使用格雷码跨异步时钟域处理
04-27
是的，异步FIFO地址可以使用格雷码跨异步时钟域处理。在异步时钟域之间进行地址传输时，由于时钟相位不同，可能会出现传输过程中的数据错误或者数据丢失的情况。使用格雷码可以有效地减少这种情况的发生。因为格雷码中相邻的数值只有一位不同，因此在传输过程中，只会有一位发生变化，从而减少了数据传输错误的概率。同时，使用格雷码还可以减少由于时钟抖动等原因导致的地址错位问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值