异步FIFO理解及设计

最新推荐文章于 2024-07-27 11:30:47 发布

MVP-curry-萌神

最新推荐文章于 2024-07-27 11:30:47 发布

阅读量633

点赞数 12

文章标签：嵌入式硬件 fpga开发

本文链接：https://blog.csdn.net/mvpkuku/article/details/140689308

版权

一、异步FIFO理解

1.1异步FIFO结构

由图可见，异步FIFO的核心部件就是一个 Simple Dual Port RAM ；左右两边的长条矩形是地址控制器，负责控制地址自增、将二进制地址转为格雷码以及解格雷码；下面的两对D触发器 sync_r2w 和 sync_w2r 是同步器，负责将写地址同步至读时钟域、将读地址同步至写时钟域。

1.2异步FIFO空满的判断

在同步FIFO设计中，fifo_num是由写地址减去读地址所得到，利用fifo_num 来作为FIFO空或满的判断依据。而对于异步FIFO而言，数据是由某一个时钟域的控制信号写入FIFO，而由另一个时钟域的控制信号将数据读出FIFO。也就是说，读写指针的变化动作是由不同的时钟产生的，处在不同的时钟域上，所以不能直接相减。因此，对FIFO空或满的判断也是跨时钟域的，我们首先需要解决的就是如何进行异步FIFO空满的判断。

对于异步FIFO 而言，我们用wr_num和rd_num（对应同步FIFO中的fifo_num）作为读写时钟域各自维护的一套数据计数器。wr_num作为FIFO写满的判断依据，rd_num作为FIFO读空的判断依据。为了得到wr_num,写地址wr_ptr_exp与其处于同一时钟域（写时钟域），然后，读地址rd_ptr_exp则需要从读时钟域同步到写时钟域才能使用，若没有同步，wr_num则会出现亚稳态,从而影响full和almost_full的指示信号，造成数据的丢失。同理，对于rd_num来讲，我们需要将写地址同步到读时钟域来进行rd_num的计算。

“写满”的判断：需要将读指针同步到写时钟域，再与写指针判断
“读空”的判断：需要将写指针同步到读时钟域，再与读指针判断

1.2.1跨时钟域：读慢写快、读快写慢

判断写满：（虚满：因为实际读地址>=同步后的地址）

（1）读慢写快：读地址同步到写时钟域后（快时钟采样慢时钟信号），经过两级触发器的时间消耗，实际的读地址一定是大于等于同步到写时钟域之后的读地址(用于wr_num计算，判断FIFO是否读满)，此时若wr_num判断FIFO写满（实际写指针未超过读指针一圈），即满非真满。可以想象一下，假设一个深度为100的FIFO，在写到第98个数据的时候就报了“写满”，会引起什么后果？答案是不会造成功能错误，只会造成性能损失（2%），大不了FIFO的深度我少用一点点就是的。只会造成性能损失。

判断读空：（虚空：实际写地址>=同步后的地址）

（1）读快写慢：同理，写地址同步到读时钟域后（快时钟采样慢时钟信号），实际的写地址一定是大于等于同步到读时钟域之后的写地址(用于rd_num计算，判断FIFO是否读空),此时若rd_num判断FIFO读空（实际读指针未赶上写指针），即空非真空。可以想象一下，假设某个FIFO，在读到还剩2个数据的时候就报了“读空”，会引起什么后果？答案是不会造成功能错误，只会造成性能损失（2%），大不了我先不读了，等数据多了再读就是的。

上面两种情况都是慢时钟域信号同步到快时钟域，我们采取打两拍可以正常进行FIFO功能，但是对于快同步到慢是否会有问题，即快时钟域的信号同步到慢时钟域造成的漏采 ？

判断写满： （虚满：漏掉读指针，对于写满来说，实际读指针跑到了前面）

（2）读快写慢：进行写满判断的时候需要将读指针同步到写时钟域，因为读快写慢，所以当写时钟同步读指针的时候，必然会漏掉一部分读指针，我们不用关心那到底会漏掉哪些读指针，我们在乎的是漏掉的指针会对FIFO的写满产生影响吗？比如读指针从0读到10，期间写时钟域只同步捕捉到了3、5、8这三个读指针而漏掉了其他指针。当同步到8这个读指针时，真实的读指针可能已经读到10 ，相当于在写时钟域还没来得及觉察的情况下，读时钟域可能从FIFO读了数据出来，这样在判断它是不是满的时候会出现不是真正满的情况，漏掉的指针也没有对FIFO的逻辑操作产生影响。

判断读空：（虚空：漏掉写指针，对于读空来说。实际的写指针跑到了前面）

（2）读慢写快：进行读空判断的时候需要将写指针同步到读指针，因为读慢写快，所以当读时钟同步写指针的时候，必然会漏掉一部分写指针，我们不用关心那到底会漏掉哪些写指针，我们在乎的是漏掉的指针会对FIFO的读空产生影响吗？比如写指针从0写到10，期间读时钟域只同步捕捉到了3、5、8这三个写指针而漏掉了其他指针。当同步到8这个写指针时，真实的写指针可能已经写到10 ，相当于在读时钟域还没来得及觉察的情况下，写时钟域可能写了数据到FIFO去，这样在判断它是不是空的时候会出现不是真正空的情况，漏掉的指针也没有对FIFO的逻辑操作产生影响。

现在我们会发现，所谓的空满信号实际上是不准确的，在还没有空、满的时钟就已经输出了空满信号，这样的空满信号一般称为假空、假满。假空、假满信号本质上是一种保守设计，对FIFO 的正常功能没什么影响。我们就仅采用结构图中所用的两级触发器进行打拍同步。

另外，我们还需要理解并解决另一个问题，除了采取打拍对读写指针（地址）进行跨时钟域处理，还需要什么操作？因为跨时钟域传输一旦没处理好就会引起亚稳态问题，造成指针的值异常，从而引发FIFO的功能错误。

在同步FIFO的设计中，我们采用改为扩展法，采用二进制编码，扩展出来的最高位来判断究竟是读指针追上写指针（读空了）还是写指针超过读指针一圈（写满了）。而在异步FIFO中，倘若我们仍然采取二进制编码的话，会很容易造成跨时钟域的亚稳态。

因为采用二进制计数器时所有位都可能同时变化，在同一个时钟沿同步多个信号的变化会产生亚稳态问题。而使用格雷码只有一位变化，因此在两个时钟域间同步多个位不会产生问题。举个例子，二进制的7（0111）跳转到8（1000），4位都会发生变化，所以发生亚稳态的概率就比较大。而格雷码的跳转就只有一位（从0100--1100，仅第四位发生变化）会发生变化，有效地减小亚稳态发生的可能性。所以需要一个二进制到gray码的转换电路，将地址值转换为相应的gray码，然后将该gray码同步到另一个时钟域进行对比，作为空满状态的检测。

1.2.2格雷码

二进制码与格雷码之间的相互转换

1.二进制转格雷码

gray[3] = 0 ^ bin[3];----gray[3] = bin[3] 异或0等于自身
gray[2] = bin[3] ^ bin[2];
gray[1] = bin[2] ^ bin[1];
gray[0] = bin[1] ^ bin[0];

2.格雷码转回二进制

最高位不需要转换，从次高位开始使用二进制的高位和次高位格雷码相异或

仿真图：

格雷码如何进行空满判断

与二进制一样，首先我们需要将指针向高位拓展一位，这是为了判断写指针是否超过读指针一圈。然后通过对比除了最高位的其余位来判断读写指针是否重合。这种方法判断二进制的指针是没有问题的，但是这不适合格雷码形式的指针，因为格雷码是镜像对称的，若只根据最高位是否相同来区分是读空还是写满是有问题的，如下图：

例如，假设FIFO深度为8，读指针在0_100 (7），写指针位于1_100 (8) ，若按照二进制的指针判断法则去判断，写指针超过读指针一圈，则说明FIFO写满。但此时，实际的写指针指向的地址为0_000(0),读写指针并未重合（写满）。因此，我们采取格雷码进行判断FIFO空满我们应采用另外的方法，我们可以看出，0-8,1-9,2-10,3-11,4-12,5-13,6-14,7-15,(最高和次高为不同，剩余位形同）.

当最高位和次高位相同，其余位相同认为是读空
当最高位和次高位不同，其余位相同认为是写满

二、异步FIFO 设计（Verilog代码及仿真）

2.1.TOP文件

`timescale 1ns / 1ps
module asnch_fifo_top#(
    parameter  DATASIZE_T = 32, // Memory data word width               
    parameter  ADDRSIZE_T = 6   // 地址指针位宽设定为6，地址宽度则为5(定义为6是为进位)，fifo深度则为2^5
)(
    input                       w_clk   ,
    input                       w_rst_n ,
    input                       winc    ,
    input [DATASIZE_T - 1:0]    w_data  ,
    output                      w_full  ,
    input                       r_clk   ,
    input                       r_rst_n ,
    input                       rinc    ,
    output[DATASIZE_T - 1:0]    r_data  ,
    output                      r_empty 
    );

wire[ADDRSIZE_T:0]       wptr   , rptr  ; 
wire[ADDRSIZE_T:0]       r_gray_rptr,r_gray_rptr_d2;
wire[ADDRSIZE_T:0]       r_gray_wptr,r_gray_wptr_d2;
wire[ADDRSIZE_T - 1:0]   w_addr , r_addr;
//*******************写时钟域：产生ram写地址，写指针以及其格雷码，写满判断**************\\
wptr_full#(
    .ADDRSIZE           (ADDRSIZE_T)    
)
wptr_full_u0(
    .w_clk              ( w_clk         ),
    .w_rst_n            ( w_rst_n       ),
    .winc               ( winc          ),
    .rq2_rptr           ( r_gray_rptr_d2),
    .wptr               ( wptr          ),  //写指针
    .r_gray_wptr        ( r_gray_wptr   ),  //写指针格雷码
    .w_addr             ( w_addr        ),  //ram写地址
    .w_full             ( w_full        )
);
//*******************格雷码读指针在写时钟域同步**************\\
fifo_r2w#(  
    .ADDRSIZE           (ADDRSIZE_T)
)
fifo_r2w_u0(
    .w_clk               (w_clk      ),
    .w_rst_n             (w_rst_n    ),
    .rptr                (r_gray_rptr),  
    .rq2_rptr            (r_gray_rptr_d2)  //同步用于full判断
);
//*******************读时钟域：产生ram读地址，读指针以及其格雷码，读空判断**************\\
fifo_empty#(
    .ADDRSIZE           (ADDRSIZE_T) 
)
fifo_empty_u0(
    .r_clk              (r_clk  ),
    .r_rst_n            (r_rst_n),
    .rinc               (rinc   ),
    .rq2_wptr           (r_gray_wptr_d2),
    .rptr               (rptr   ),      //读指针(二进制
    .r_gray_rptr        (r_gray_rptr),  //读指针(格雷码
    .r_addr             (r_addr ),      //ram读地址
    .r_empty            (r_empty)
);
//*******************格雷码写指针在读时钟域同步**************\\
fifo_w2r#(
   .ADDRSIZE           (ADDRSIZE_T) 
)fifo_w2r_u0(
    .r_clk              (r_clk  ),
    .r_rst_n            (r_rst_n),
    .wptr               (r_gray_wptr   ),
    .rq2_wptr           (r_gray_wptr_d2) //同步用于empty判断
    );
//*******************ram寄存器**************\\
fifo_mem#(
    .DATASIZE           (DATASIZE_T) ,            
    .ADDRSIZE           (ADDRSIZE_T) 
)
fifo_mem_u0(
    .w_clk              (w_clk   )  ,
    .winc               (winc    )  ,
    .w_full             (w_full  )  ,
    .w_addr             (w_addr  )  ,
    .w_data             (w_data  )  ,
    .r_addr             (r_addr  )  ,
    .r_data             (r_data  )
);
endmodule

2.2 写文件

`timescale 1ns / 1ps
module wptr_full#(
    parameter   ADDRSIZE   =   6
)(
    input                       w_clk   ,
    input                       w_rst_n ,
    input                       winc    ,
    input [ADDRSIZE : 0]        rq2_rptr,   //格雷码
    output[ADDRSIZE : 0]        wptr    ,   //二进制
    output[ADDRSIZE : 0]        r_gray_wptr,//格雷码
    output[ADDRSIZE - 1 : 0]    w_addr  ,   //二进制
    output                      w_full  
);

reg  [ADDRSIZE : 0]        r_wptr     ;

wire [ADDRSIZE : 0]        w_gray_wptr;

assign  wptr   =  r_wptr;
assign  w_addr =  wptr[ADDRSIZE - 1 : 0];  //产生二进制实际ram地址

assign  r_gray_wptr = w_gray_wptr;


always @(posedge w_clk or negedge w_rst_n) begin
    if(!w_rst_n)
        r_wptr <= 'd0;
    else if(winc && !w_full) 
        r_wptr <= r_wptr + 1;
    else
        r_wptr <= r_wptr;
end

bin2gray#(
    .P_DATA_WIDTH       (ADDRSIZE)
)
bin2gray_u0(
    .i_bin          (r_wptr     ),
    .o_gray         (w_gray_wptr)
);

assign w_full = (w_gray_wptr == {~rq2_rptr[ADDRSIZE:ADDRSIZE-1],rq2_rptr[ADDRSIZE-2:0]});

endmodule

2.3 读文件

`timescale 1ns / 1ps
module fifo_empty#(
    parameter   ADDRSIZE   =   6
)(
    input                       r_clk       ,
    input                       r_rst_n     ,
    input                       rinc        ,
    input [ADDRSIZE : 0]        rq2_wptr    ,
    output[ADDRSIZE : 0]        rptr        ,
    output[ADDRSIZE : 0]        r_gray_rptr ,
    output[ADDRSIZE - 1 : 0]    r_addr      ,
    output                      r_empty 
);

reg [ADDRSIZE : 0]              r_rptr      ;
reg                             r_r_empty   ;
wire[ADDRSIZE : 0]              w_gray_rptr ;
wire                            empty_value ;

assign r_empty       = r_r_empty;
assign rptr          = r_rptr;
assign r_addr        = rptr[ADDRSIZE - 1 : 0];
assign r_gray_rptr   = w_gray_rptr;

always @(posedge r_clk or negedge r_rst_n) begin
    if(!r_rst_n)
        r_rptr <= 'd0;
    else if(rinc && !r_empty)
        r_rptr <= r_rptr + 1;
    else
        r_rptr <= r_rptr;
end

bin2gray#(
    .P_DATA_WIDTH    (ADDRSIZE)
)
bin2gray_u2(
    .i_bin   (r_rptr     ),
    .o_gray  (w_gray_rptr)
);

assign empty_value = (w_gray_rptr == rq2_wptr);
always @(posedge r_clk or negedge r_rst_n) begin
    if(!r_rst_n)
        r_r_empty <= 'd0;
    else
        r_r_empty <= empty_value;
end
endmodule

2.4 读写指针同步文件

`timescale 1ns / 1ps
module fifo_r2w#(
    parameter   ADDRSIZE    =   6
)(
    input                   w_clk   ,
    input                   w_rst_n ,
    input [ADDRSIZE : 0]    rptr    ,
    output[ADDRSIZE : 0]    rq2_rptr
    );
reg[ADDRSIZE:0] r_rptr_d1;
reg[ADDRSIZE:0] r_rptr_d2;

always @(posedge w_clk or negedge w_rst_n) begin
    if(!w_rst_n)begin
        r_rptr_d1 <= 'd0;
        r_rptr_d2 <= 'd0;
    end
    else begin
        r_rptr_d1 <= rptr;
        r_rptr_d2 <= r_rptr_d1;
    end
end

assign rq2_rptr = r_rptr_d2;
endmodule

`timescale 1ns / 1ps
module fifo_w2r#(
    parameter   ADDRSIZE    =   6
)(
    input                   r_clk   ,
    input                   r_rst_n ,
    input [ADDRSIZE : 0]    wptr    ,
    output[ADDRSIZE : 0]    rq2_wptr
    );

reg[ADDRSIZE:0] r_wptr_d1;
reg[ADDRSIZE:0] r_wptr_d2;
always @(posedge r_clk or negedge r_rst_n) begin
    if(!r_rst_n)begin
        r_wptr_d1 <= 'd0;
        r_wptr_d2 <= 'd0;
    end
    else begin
        r_wptr_d1 <= wptr;
        r_wptr_d2 <= r_wptr_d1;
    end
end
assign rq2_wptr = r_wptr_d2;

endmodule

2.5 TB文件

`timescale 1ns / 1ps
module asnch_fifo_tb();
    reg                       w_clk   ;
    reg                       w_rst_n ;
    reg                       winc    ;
    reg [8 - 1:0]             w_data  ;
    wire                      w_full  ;
    reg                       r_clk   ;
    reg                       r_rst_n ;
    reg                       rinc    ;
    wire[8- 1:0]              r_data  ;
    wire                      r_empty ;
asnch_fifo_top#(
    .DATASIZE_T  (8), // Memory data word width               
    .ADDRSIZE_T  (3)  // 地址指针位宽设定为4，地址宽度则为3(定义为6是为进位)，fifo深度则为2^3
)
asnch_fifo_top_u0(
    .w_clk                  (w_clk   ),
    .w_rst_n                (w_rst_n ),
    .winc                   (winc    ),
    .w_data                 (w_data  ),
    .w_full                 (w_full  ),
    .r_clk                  (r_clk   ),
    .r_rst_n                (r_rst_n ),
    .rinc                   (rinc    ),
    .r_data                 (r_data  ),
    .r_empty                (r_empty )
    );

 initial begin  //设置写时钟，写周期是20ns，50Mhz
    w_clk=0;
    forever #10 w_clk=~w_clk;
end

initial begin  //设置读时钟，读周期是10ns，100Mhz
    r_clk=0;
    forever  #5 r_clk=~r_clk;
end
                    
initial begin
    w_rst_n=1'b0;      //写复位
    r_rst_n=1'b0;      //读复位
    winc   =1'b0;      //写无效
    rinc   =1'b0;      //读无效
    w_data=0;          //初始写数据为0  
    #28 w_rst_n=1'b1;  //松开写复位
        r_rst_n=1'b1;  //松开读复位
        winc =1'b1;    //写有效
        w_data=1;      //输入数据为1
    @(posedge w_clk);//写入数据     
    repeat(7)       //接着写入2，3，4，5，6，7，8这些数据
            begin
                 #18;
                 w_data=w_data+1'b1;
                 @(posedge w_clk);  
             end
    #18    w_data = w_data+1'b1;  //此时异步FIFO已经写满了，在往同步FIFO中写数据8
    //8这个数据不会被写进
    @(posedge r_clk);     
    #8  rinc=1'b1;      //读使能，写无效 
        winc=1'b0;
    @(posedge r_clk);     //第一个读出的数为1
    repeat(7)        //读取剩余的数
       begin
           @(posedge r_clk);   
       end
    #2;
      rinc=1'b0;        //结束读操作                                    
end    
endmodule

仿真

能够成功实现仿真，具体的细致分析与应用需要进一步学习！

PS：小白学习，借鉴颇多，若有雷同，纯属抄袭。

MVP-curry-萌神

关注

12
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
异步FIFO理解及设计

由图可见，异步FIFO的核心部件就是一个 Simple Dual Port RAM；左右两边的长条矩形是地址控制器，负责控制地址自增、将二进制地址转为格雷码以及解格雷码；下面的两对D触发器 sync_r2w 和 sync_w2r 是同步器，负责将写地址同步至读时钟域、将读地址同步至写时钟域。
复制链接

扫一扫