• 跨时钟域问题（一）(建立时间保持时间和亚稳态)

    🏡 博客首页：安静到无声

    ⛳️ 欢迎关注： ❤️ 点赞 🎒 收藏 ✏️ 留言

    🚧 系列专栏：跨时钟域

    🎈 如有错误不吝赐教

    目录


    在这里插入图片描述

    1. 电平同步器

    单bit信号跨时钟域最为简单的方法就是通过寄存器打两拍进行同步，也就是所谓的电平同步器。电路图如下所示：
    在这里插入图片描述

    图1 电平同步器

    从图1可以看出，同步触发器有三个触发器构成，其中第一个触发器的时钟脉冲为CLOCK1，第2个和第3个触发器的时钟脉冲为CLOCK2，在两个时钟域之间的连接没有组合逻辑电路。其中在原时钟域下经过一个触发器主要为了消除毛刺。在进入第二个时钟域，我们需要进行打两拍，原因在系列文章——跨时钟域问题（一）(建立时间保持时间和亚稳态)，进行了详细的说明，主要为了避免进入亚稳态的情况。

    根据图1电路我们可以知晓，信号在两个同步时钟周期以后，便可以成为新时钟域下的有效信号。考虑到时钟关系，信号的延时是新时钟域中的一到两个时钟周期。

    但这样的电路有一个明显的局限性，可同步的信号需要满足较为苛刻的要求。从本质上说，就是信号必须要被新时钟域所采到，而不能有遗漏，因而原时钟域下的信号必须足够长。即：

    从慢时钟域传递到快时钟域（快采慢）。信号肯定被采到，故最为适用。但此时输出信号一般为电平信号，如果要求获得与新周期等宽的脉冲信号，则不可用。

    快时钟域传递到慢时钟域下（慢采快），传递的信号必须为较宽的电平信号，要求保持高电平或低电平一个同步时钟周期以上。和输入信号关系较大，不可传递原时钟周期的脉冲信号。因而不适用与快时钟传递到慢时钟。

    源代码

    `timescale 1ns/1ps

module level_syc(
    input  wire                         clk_1                      ,
    input  wire                         clk_2                      ,
    input  wire                         din                        ,
    input  wire                         rst_n                      ,
    
    output wire                         dout                        
);
	
reg                                     src_state                  ;
reg                                     src_state_d0, src_state_d1 ;
	
	//原时钟域信号寄存器输出，消除毛刺
    always @(posedge clk_1 or negedge rst_n)
    begin
        if(rst_n == 1'b0)
            src_state <= 1'b0;
        else
            src_state <= din;
    end
	
	//同步至新时钟域
    always @(posedge clk_2 or negedge rst_n)
    begin
        if(rst_n == 1'b0)
        begin
            src_state_d0 <= 1'b0;
            src_state_d1 <= 1'b0;
        end
        else
        begin
            src_state_d0 <= src_state;
            src_state_d1 <= src_state_d0;
        end
    end
	
    assign dout = src_state_d1;
	
endmodule



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43

    仿真代码

    `timescale 1ns/1ps

module level_syc_tb();

reg                                     clk_1, clk_2, rst_n        ;
reg                                     din                        ;
	
	//		慢时钟域到快时钟域
    always
        begin
            #30 clk_1 = ~clk_1;
        end
    always
        begin
            #10 clk_2 = ~clk_2;
        end
	
	//		快时钟域到慢时钟域
/*    always
        begin
            #10 clk_1 = ~clk_1;
        end
    always
        begin
            #30 clk_2 = ~clk_2;
        end
*/
    initial
        fork
            clk_1 = 1'b1;
            din = 1'b0;
            #5 clk_2 = 1'b1;
            #10 rst_n = 1'b0;
            #50 rst_n = 1'b1;
			
			//慢时钟域到快时钟域
            #200 din = 1'b1;
            #260 din = 1'b0;

            #400 $stop;

			
			//快时钟域到慢时钟域，高电平持续两个同步时钟周期
/*            #320 din = 1'b1;
            #380 din = 1'b0;
			
			//快时钟域到慢时钟域，高电平持续小于两个同步时钟周期
            #800 din = 1'b1;
            #820 din = 1'b0;
*/
        join
		
    level_syc u1(.clk_1(clk_1),
    .clk_2                             (clk_2                     ),
    .rst_n                             (rst_n                     ),
    .din                               (din                       ),
    .dout                              (dout)                     ) 
				 
endmodule


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60

    仿真结果如图所示：

    从慢时钟域传递到快时钟域（快采慢）。信号成功完成跨时钟域。同步延迟为80ns。
    在这里插入图片描述

    图2 从慢时钟域传递到快时钟域（快采慢）

    快时钟域传递到慢时钟域下（慢采快）。第一个信号成功完成跨时钟域。第二个信号被滤掉。
    在这里插入图片描述

    图3 从快时钟域传递到慢时钟域（慢采快）

    结论：
    从快时钟域向慢时钟域传递时钟周期的脉冲信号时，信号很可能会被滤掉。结合波形图可得，信号必须持续至少一个同步时钟周期，才能确保肯定被采到，完成跨时钟域。考虑到跨时钟域下，时钟的相互关系并不确定，因而，采用电平同步器进行块到慢时钟域的跨越是不合理的。

    2. 边沿同步（检测）器

    边沿检测同步器在电平同步器的输出端增加一个触发器，新的触发器的输出经过反相后和电平同步器的输出进行与操作。这一电路会检测同步器输入的上升沿，产生一个与原时钟周期等宽、高电平有效的脉冲，如果将与门两个输入端交换使用，就可以构成一个检测输入信号下降沿的同步器。将与门改为与非门可以构成一个产生低电平有效脉冲电路。
    在这里插入图片描述

    图4 边沿检测同步器

    该模块的实质是设计了一个三级的缓存，从左到右分别定义为Q0，Q1和Q2。其中检测上升沿和下降沿的方法与牛客网练习VL24 边沿检测是一致的。

    • 提取上边沿 pules = Q1 & (~Q2);
    • 提取下边沿 pulse = (~Q1) & Q2;
    • 提取双边沿 pulse = Q1 ^ Q2;

    当一个脉冲进入一个更快的时钟域中时，边沿同步检测器可以工作的更好，这一电路会产生一个脉冲，用来指示输入信号的上升沿和下降沿。这种边同步器有一个限制，即输入脉冲的宽度必须大于同步时钟周期与第一个同步触发器所需保持时间之和。最保险的脉冲宽度是同步器时钟周期的两倍。如果是一个单时钟周期宽度脉冲进入一个较慢的时钟域，则这再同步器没有作用，这这种情况下，要采用脉冲同步器。

    源代码

    module edge_syc(
    input  wire                         clk_1                      ,
    input  wire                         clk_2                      ,
    input  wire                         din                        ,
    input  wire                         rst_n                      ,
    
    output wire                         dout_r                     ,
    output wire                         dout_f                     ,
    output wire                         dout_e                      
	
);
reg                                     src_state                  ;
reg                                     src_state_d0, src_state_d1, src_state_d2;
	
	//原时钟域下脉冲信号转变为电平信号
    always @(posedge clk_1 or negedge rst_n)
    begin
        if(rst_n == 1'b0)
            src_state <= 1'b0;
        else
            src_state <= din;
    end
	
	//同步至新时钟域
    always @(posedge clk_2 or negedge rst_n)
    begin
        if(rst_n == 1'b0)
        begin
            src_state_d0 <= 1'b0;
            src_state_d1 <= 1'b0;
            src_state_d2 <= 1'b0;
        end
        else
        begin
            src_state_d0 <= src_state;
            src_state_d1 <= src_state_d0;
            src_state_d2 <= src_state_d1;
        end
    end
	
	//边沿检测产生新的脉冲
    assign dout_r = src_state_d1 & ~src_state_d2;
    assign dout_f = !src_state_d1 & src_state_d2;
    assign dout_e = src_state_d1 ^ src_state_d2;
	
endmodule

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46

    仿真代码

    `timescale 1ns/1ps

module edge_syc_tb();
reg                                     clk_1, clk_2, rst_n        ;
reg                                     din                        ;
	
always
    begin
        #30 clk_1 = ~clk_1;
    end

always
    begin
        #10 clk_2 = ~clk_2;
    end
    
initial
    fork
        clk_1 = 1'b1;
        din = 1'b0;
        #5 clk_2 = 1'b1;
        #10 rst_n = 1'b0;
        #50 rst_n = 1'b1;
        
        #200 din = 1'b1;
        #260 din = 1'b0;
        
        #320 din = 1'b1;
        #380 din = 1'b0;

        #500 $stop;
        
//			#400 din = 1'b1;
//			#460 din = 1'b0;
    join
    
edge_syc u1(
    .clk_1                             (clk_1                     ),
    .clk_2                             (clk_2                     ),
    .rst_n                             (rst_n                     ),
    .din                               (din                       ),
    .dout_r                            (dout_r                    ),
    .dout_f                            (dout_f                    ),
    .dout_e                            (dout_e)                   ); 


endmodule


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48

    在这里插入图片描述

    图5 边沿检测同步器仿真结果

    由实验结果可知，先对于输入/edge_syc_tb/u1/src_state，输出/edge_syc_tb/u1/dout_r延迟了两个时钟周期(clk_2)，即40ns。这也能够保证信号的有效采集。

    3. 脉冲检测器

    之前所考虑的两个同步器，都只适合从慢时钟域到快时钟域，不必考虑新时钟域下采不到信号的问题。从快时钟域传递单bit信号到慢时钟域，则需要用到脉冲同步器。

    脉冲同步器的输人信号是一个单时钟宽度脉冲， 它触发原时钟域中的一个翻转电路图。 每当翻转电路接收到一个脉冲时，它就会在高、低电平间进行转换， 然后通过电平同步到达异或门的一个输入端， 而另一个信号经一个时钟周期延迟进入异或门的另一端， 翻转电路每转换一次状态， 这个同步器的输出端就产生一个单时钟宽度的脉冲。
    在这里插入图片描述

    图6 脉冲同步器

    每当快时钟域clka检测到Signal_a脉冲信号为高时，让wide_a信号取反，使得Signal_a的第一个脉冲变为wide_a信号的上升沿，Signal_a的第二个脉变为wide_a信号的下降沿。这样就使快速时钟域clka的脉冲信号Signal_a展宽之后在慢速时钟域clkb中能够被采集到。在接收方，慢时钟将wide_a打两拍同步到慢速时钟域clkb，再通过双边缘检测将wide_b2转换为脉冲信号。

    在这里插入图片描述

    图7 时序数据情况

    代码 

    //脉冲同步器
module pulse_syc(
    input  wire                         clk_1                      ,
    input  wire                         clk_2                      ,
    input  wire                         din                        ,
    input  wire                         rst_n                      ,
    
    output                              dout                        
);
reg                                     src_state                  ;
reg                                     src_state_d0, src_state_d1, src_state_d2;
	
	//原时钟域下脉冲信号转变为电平信号
always @(posedge clk_1 or negedge rst_n)
begin
    if(rst_n == 1'b0)
        src_state <= 1'b0;

//		else if(din == 1'b1)		//通过2选1MUX完成翻转功能,脉冲到来完成从脉冲到电平的转换
//			src_state <= ~src_state;

    else
        src_state <= din ^ src_state;                           //通过异或门做处理
end

//同步至新时钟域
always @(posedge clk_2 or negedge rst_n)
begin
    if(rst_n == 1'b0)
    begin
        src_state_d0 <= 1'b0;
        src_state_d1 <= 1'b0;
        src_state_d2 <= 1'b0;
    end
    else
    begin
        src_state_d0 <= src_state;
        src_state_d1 <= src_state_d0;
        src_state_d2 <= src_state_d1;
    end
end

//边沿检测产生新的脉冲
assign dout = src_state_d1 ^ src_state_d2;
	
endmodule


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47

    仿真

    `timescale 1ns/1ps

//		高频到低频		//
module pulse_syc_tb();
reg                                     clk_1, clk_2, rst_n        ;
reg                                     din                        ;
	
always
    begin
        #10 clk_1 = ~clk_1;
    end

always
    begin
        #30 clk_2 = ~clk_2;
    end
    
initial
    fork
        clk_1 = 1'b1;
        din = 1'b0;
        #5 clk_2 = 1'b1;
        #10 rst_n = 1'b0;
        #50 rst_n = 1'b1;
        #100 din = 1'b0;
        
        #200 din = 1'b1;                                        //间隔两个同步周期的脉冲信号
        #220 din = 1'b0;
        #320 din = 1'b1;
        #340 din = 1'b0;
        
        #600 din = 1'b1;                                        //间隔一个同步周期的脉冲信号
        #620 din = 1'b0;
        #680 din = 1'b1;
        #700 din = 1'b0;
        
        #900 din = 1'b1;                                        //等于两个原时钟周期的脉冲信号
        #1020 din = 1'b0;
        #1200 $stop;
    join
    
pulse_syc u1(.clk_1(clk_1),
.clk_2                             (clk_2                     ),
.rst_n                             (rst_n                     ),
.din                               (din                       ),
.dout                              (dout)                     ); 

endmodule




    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51

    在这里插入图片描述

    图8 仿真结果

    当输入脉冲间隔为两个同步时钟周期时，脉冲同步器可正常完成输出；当输入脉冲间隔为低于两个同步时钟周期时，脉冲同步器错误输出了一个更宽的脉冲。因而，脉冲同步器对于脉冲的间隔有比较严格的要求：输入脉冲的最小间隔必须等于两个新时钟的时钟周期。

    参考

    1. https://blog.csdn.net/qq_40268672/article/details/123347337
    2. https://blog.csdn.net/u013668469/article/details/99480694
    3. Mike Stein.跨越鸿沟：同步世界中的异步信号[J].电子设计技术,2004(07):76+78+80+82+84+86.
  • 相关阅读:
    头歌-信息安全技术-【实训10】HTML信息隐藏、动态分析技术
    html 标签
    在Linux怎么用vim实现把一个文件里面的文本复制到另一个文件里面
    R函数optim()最小化或者最大化多参数函数
    一文了解.Net的CLR、GC内存管理
    9/30-10/1
    OPPO手机如何添加日程桌面插件？
    数据分析师 医学数据分析 spss ，二项检验的概念和优缺点，适用场景 卡方检验和二相检验的区别
    RFID设备在自动化堆场中的管理应用
    Linux三剑客之grep、sed、awk
  • 原文地址：https://blog.csdn.net/lihuanyu520/article/details/126135231