异步FIFO的FPGA实现

﹏ヽ暗。殇╰゛Y 2022-07-17 04:12 146阅读 0赞

REFERCE：http://www.cnblogs.com/BitArt/archive/2013/04/10/3010073.html

百度这条比较有参考意义：http://baike.baidu.com/link?url=eqwa2ZlYj9iCebORBlCbExYqLgd1Wgk16rZsuXfhsy310-eo1FxmyUvVbo6z7GJq3AygTFrGG8t1deppQEq1Iq

本文大部分内容来自Clifford E. Cummings的《Simulation and Synthesis Techniques for Asynchronous FIFO Design》，同时加上一些自己的一些理解，有兴趣的朋友可以阅读原文。

一、FIFO简介

FIFO是英文First In First Out 的缩写，是一种先进先出的数据缓存器，它与普通存储器的区别是没有外部读写地址线，这样使用起来非常简单，但缺点就是只能顺序写入数据，顺序的读出数据，其数据地址由内部读写指针自动加1完成，不能像普通存储器那样可以由地址线决定读取或写入某个指定的地址。

用途1：

异步FIFO读写分别采用相互异步的不同时钟。在现代集成电路芯片中，随着设计规模的不断扩大，一个系统中往往含有数个时钟，多时钟域带来的一个问题就是，如何设计异步时钟之间的接口电路。异步FIFO是这个问题的一种简便、快捷的解决方案，使用异步FIFO可以在两个不同时钟系统之间快速而方便地传输实时数据。

用途2：

对于不同宽度的数据接口也可以用FIFO，例如单片机位8位数据输出，而DSP可能是16位数据输入，在单片机与DSP连接时就可以使用FIFO来达到数据匹配的目的。

\* 异步fifo用途：1.可以在不同时钟域之间方便传送实时数据，以及，2.对于不同位宽的数据接口，进行数据匹配。

二、分类

同步FIFO是指读时钟和写时钟为同一个时钟，在时钟沿来临时同时发生读写操作；

异步FIFO是指读写时钟不一致，读写时钟是互相独立的。

\*根据读写时钟是否相互独立区分。

三、FIFO的常见参数

*  FIFO的宽度：即FIFO一次读写操作的数据位；

*  FIFO的深度：指的是FIFO可以存储多少个N位的数据（如果宽度为N）。

*  满标志：FIFO已满或将要满时由FIFO的状态电路送出的一个信号，以阻止FIFO的写操作继续向FIFO中写数据而造成溢出（overflow）。

*  空标志：FIFO已空或将要空时由FIFO的状态电路送出的一个信号，以阻止FIFO的读操作继续从FIFO中读出数据而造成无效数据的读出（underflow）。

*  读时钟：读操作所遵循的时钟，在每个时钟沿来临时读数据。

*  写时钟：写操作所遵循的时钟，在每个时钟沿来临时写数据。

===============================分 隔 符 ==============================

1.  读写指针的工作原理

写指针：总是指向下一个将要被写入的单元，复位时，指向第1个单元(编号为0)。

读指针：总是指向当前要被读出的数据，复位时，指向第1个单元(编号为0)

1.  FIFO的“空”/“满”检测

FIFO设计的关键：产生可靠的FIFO读写指针和生成FIFO“空”/“满”状态标志。

当读写指针相等时，表明FIFO为空，这种情况发生在复位操作时，或者当读指针读出FIFO中最后一个字后，追赶上了写指针时，如下图所示：

![09122539-f66a4eee9b0341c9ab4e18f4ad6e782c.jpg][]

当读写指针再次相等时，表明FIFO为满，这种情况发生在，当写指针转了一圈，折回来(wrapped around)又追上了读指针，如下图：

![09122758-65cac4b3445f476b9b25338b88fe0595.jpg][]

为了区分到底是满状态还是空状态，可以采用以下方法： （\*区分FIFO的空满状态方法：1：在指针中添加一个额外的位；2：通过对比格雷码判别）

方法1：在指针中添加一个额外的位(extra bit)，当写指针增加并越过最后一个FIFO地址时，就将写指针这个未用的MSB加1，其它位回零。对读指针也进行同样的操作。此时，对于深度为2^n的FIFO，需要的读/写指针位宽为(n+1)位，如对于深度为8的FIFO，需要采用4bit的计数器，0000～1000、1001～1111，MSB作为折回标志位，而低3位作为地址指针。

*   *  如果两个指针的MSB不同，说明写指针比读指针多折回了一次；如r\_addr=0000,而w\_addr = 1000,为满。
     *  如果两个指针的MSB相同，则说明两个指针折回的次数相等。其余位相等，说明FIFO为空；

3.二进制FIFO指针的考虑

将一个二进制的计数值从一个时钟域同步到另一个时钟域的时候很容易出现问题，因为采用二进制计数器时所有位都可能同时变化，在同一个时钟沿同步多个信号的变化会产生亚稳态问题。而使用格雷码只有一位变化，因此在两个时钟域间同步多个位不会产生问题。所以需要一个二进制到gray码的转换电路，将地址值转换为相应的gray码，然后将该gray码同步到另一个时钟域进行对比，作为空满状态的检测。

![09142332-2dd055f668444f998685034a733f72cc.jpg][]

*  使用gray码进行对比，如何判断“空”与“满”

使用gray码解决了一个问题，但同时也带来另一个问题，即在格雷码域如何判断空与满。

对于“空”的判断依然依据二者完全相等(包括MSB)；

而对于“满”的判断，如下图，由于gray码除了MSB外，具有镜像对称的特点，当读指针指向7，写指针指向8时，除了MSB，其余位皆相同，不能说它为满。因此不能单纯的只检测最高位了，在gray码上判断为满必须同时满足以下3条：

*  wptr和同步过来的rptr的MSB不相等，因为wptr必须比rptr多折回一次。
 *  wptr与rptr的次高位不相等，如上图位置7和位置15，转化为二进制对应的是0111和1111，MSB不同说明多折回一次，111相同代表同一位置。
 *  剩下的其余位完全相等。

![09142452-504d231d43c942b5bf3e311138264c04.jpg][]

5.总体实现

系统的总体框图如下：

![09142554-b1cc1fcef63e460e9c0186beebbc53ef.jpg][]

1)顶层模块

module AsyncFIFO
     #(parameter ASIZE = 4,    //地址位宽
       parameter DSIZE = 8)    //数据位宽
     (
        input  [DSIZE-1:0] wdata,
        input              winc, wclk, wrst_n,  //写请求信号，写时钟，写复位
        input              rinc, rclk, rrst_n,  //读请求信号，读时钟，读复位
        output [DSIZE-1:0] rdata,
        output             wfull,
        output             rempty
     );
    wire [ASIZE-1:0] waddr, raddr;
    wire [ASIZE:0]   wptr, rptr, wq2_rptr, rq2_wptr;        /************************************************************
    * In order to perform FIFO full and FIFO empty tests using 
    * this FIFO style, the read and write pointers must be
    * passed to the opposite clock domain for pointer comparison
    *************************************************************/
    /*在检测“满”或“空”状态之前，需要将指针同步到其它时钟域时，使用格雷码，可以降低同步过程中亚稳态出现的概率*/
    sync_r2w I1_sync_r2w(
        .wq2_rptr(wq2_rptr), 
        .rptr(rptr),
        .wclk(wclk), 
        .wrst_n(wrst_n));
    sync_w2r I2_sync_w2r (
        .rq2_wptr(rq2_wptr), 
        .wptr(wptr),
        .rclk(rclk), 
        .rrst_n(rrst_n));
    /*
    *  DualRAM 
    */
    DualRAM #(DSIZE, ASIZE) I3_DualRAM(
        .rdata(rdata), 
        .wdata(wdata),
        .waddr(waddr), 
        .raddr(raddr),
        .wclken(winc), 
        .wclk(wclk));
        
    /*
    *  空、满比较逻辑
    */
    rptr_empty #(ASIZE) I4_rptr_empty(
        .rempty(rempty),
        .raddr(raddr),
        .rptr(rptr), 
        .rq2_wptr(rq2_wptr),
        .rinc(rinc), 
        .rclk(rclk),
        .rrst_n(rrst_n));
    wptr_full #(ASIZE) I5_wptr_full(
        .wfull(wfull), 
        .waddr(waddr),
        .wptr(wptr), 
        .wq2_rptr(wq2_rptr),
        .winc(winc), 
        .wclk(wclk),
        .wrst_n(wrst_n));
    endmodule

![复制代码][copycode.gif]

2)DualRAM模块

![复制代码][copycode.gif]

module DualRAM
    #(
        parameter DATA_SIZE = 8,   // 数据位宽
        parameter ADDR_SIZE = 4   // 地址位宽
    )
    (
        input                       wclken,wclk,
        input      [ADDR_SIZE-1:0]  raddr,     //RAM read address
        input      [ADDR_SIZE-1:0]  waddr,     //RAM write address
        input      [DATA_SIZE-1:0]  wdata,    //data input
        output     [DATA_SIZE-1:0]  rdata      //data output
    );    
    localparam RAM_DEPTH = 1 << ADDR_SIZE;   //RAM深度 = 2^ADDR_WIDTH
            reg [DATA_SIZE-1:0] Mem[RAM_DEPTH-1:0];
            always@(posedge wclk)
    begin
         if(wclken)
             Mem[waddr] <= wdata;
    end
    assign rdata =  Mem[raddr];
    endmodule

![复制代码][copycode.gif]

3)同步模块

![复制代码][copycode.gif]

module sync_r2w 
    #(parameter ADDRSIZE = 4)
    (
        output reg [ADDRSIZE:0] wq2_rptr,
        input      [ADDRSIZE:0] rptr,
        input                       wclk, wrst_n
    );
    reg [ADDRSIZE:0] wq1_rptr;
    always @(posedge wclk or negedge wrst_n)
        if (!wrst_n) 
            {wq2_rptr,wq1_rptr} <= 0;
        else 
            {wq2_rptr,wq1_rptr} <= {wq1_rptr,rptr};
    endmodule

![复制代码][copycode.gif]

4)同步模块2

![复制代码][copycode.gif]

module sync_w2r 
    #(parameter ADDRSIZE = 4)
    (
        output reg  [ADDRSIZE:0] rq2_wptr,
        input         [ADDRSIZE:0] wptr,
        input         rclk, rrst_n
    );        reg [ADDRSIZE:0] rq1_wptr;
    always @(posedge rclk or negedge rrst_n)
        if (!rrst_n)
            {rq2_wptr,rq1_wptr} <= 0;
        else 
            {rq2_wptr,rq1_wptr} <= {rq1_wptr,wptr};
    endmodule

![复制代码][copycode.gif]

5)空判断逻辑

![复制代码][copycode.gif]

module rptr_empty 
    #(parameter ADDRSIZE = 4)
    (
        output reg rempty,
        output     [ADDRSIZE-1:0] raddr,
        output reg [ADDRSIZE :0]  rptr,
        input       [ADDRSIZE :0] rq2_wptr,
        input       rinc, rclk, rrst_n);
    
    
    reg  [ADDRSIZE:0] rbin;
    wire [ADDRSIZE:0] rgraynext, rbinnext;
    wire  rempty_val;
    //-------------------
    // GRAYSTYLE2 pointer: gray码读地址指针
    //-------------------
    always @(posedge rclk or negedge rrst_n)
        if (!rrst_n) 
            begin 
                rbin <= 0;
                rptr <= 0;
            end
        else
            begin
                rbin <= rbinnext ; 
                rptr <= rgraynext;
            end
    // gray码计数逻辑
    assign rbinnext = !rempty ? (rbin + rinc) : rbin;
    assign rgraynext = (rbinnext>>1) ^ rbinnext;      //二进制到gray码的转换
            assign raddr = rbin[ADDRSIZE-1:0];
    //---------------------------------------------------------------
    // FIFO empty when the next rptr == synchronized wptr or on reset
    //---------------------------------------------------------------
    /*
    *   读指针是一个n位的gray码计数器，比FIFO寻址所需的位宽大一位
    *   当读指针和同步过来的写指针完全相等时(包括MSB)，说明二者折回次数一致,FIFO为空
    *     
    */
    assign rempty_val = (rgraynext == rq2_wptr);
            always @(posedge rclk or negedge rrst_n)
    if (!rrst_n) 
        rempty <= 1'b1;
    else 
        rempty <= rempty_val;
    endmodule

![复制代码][copycode.gif]

6)满判断逻辑

![复制代码][copycode.gif]

module wptr_full 
    #(
        parameter ADDRSIZE = 4
    )
    (
        output reg                wfull,
        output     [ADDRSIZE-1:0] waddr,
        output reg [ADDRSIZE :0]  wptr,
        input      [ADDRSIZE :0]  wq2_rptr,
        input                     winc, wclk, wrst_n);        
    
    reg  [ADDRSIZE:0] wbin;
    wire [ADDRSIZE:0] wgraynext, wbinnext;
    wire wfull_val;
    // GRAYSTYLE2 pointer
    always @(posedge wclk or negedge wrst_n)
        if (!wrst_n) 
        begin
            wbin <= 0;
            wptr <= 0;
        end
        else 
        begin
            wbin <= wbinnext;
             wptr <= wgraynext;
        end
    //gray 码计数逻辑    
    assign wbinnext  = !wfull ? wbin + winc : wbin;
    assign wgraynext = (wbinnext>>1) ^ wbinnext;
            assign waddr = wbin[ADDRSIZE-1:0];
            /*由于满标志在写时钟域产生，因此比较安全的做法是将读指针同步到写时钟域*/
    /**/
    //------------------------------------------------------------------
    // Simplified version of the three necessary full-tests:
    // assign wfull_val=((wgnext[ADDRSIZE] !=wq2_rptr[ADDRSIZE] ) &&
    // (wgnext[ADDRSIZE-1] !=wq2_rptr[ADDRSIZE-1]) &&
    // (wgnext[ADDRSIZE-2:0]==wq2_rptr[ADDRSIZE-2:0]));
    //------------------------------------------------------------------
    assign wfull_val = (wgraynext=={~wq2_rptr[ADDRSIZE:ADDRSIZE-1],
                        wq2_rptr[ADDRSIZE-2:0]});
    always @(posedge wclk or negedge wrst_n)
    if (!wrst_n) 
        wfull <= 1'b0;
    else 
        wfull <= wfull_val;
    endmodule

**扩展：**

在异步FIFO中，写操作和读操作工作在不同的时钟域，需要跨时钟域来传递FIFO的空满状态信息。（\* 由于要判断空满状态，在跨时钟域采样数据时，为降低跨时钟域产生的亚稳态概率：先转化为格雷码）

一般是**通过传递读写的地址**来实现空满状态控制的。写地址减去读地址(如果写地址小于读地址，则写地址先加上FIFO深度再减去读地址），即为**FIFO中存放的数据个数**，由此产生FIFO的空满判断。不管是读地址还是写地址，每次变化都是加1，溢出后从0开始重新累加。

当写地址跨越时钟域到达读操作一侧时，需要用读时钟去采样由写时钟产生的数据（即写地址）。由于是异步操作，有可能会出现竞争和冒险，采样过程不满足建立保持时间，导致亚稳态。

写地址变化的位越多，出现亚稳态的位就越多，用读时钟采样时出错的概率越高。同理，当读地址跨越时钟域到达写操作侧时，读地址变化的位越多，写时钟采样时出错的概率越高。

因为，必须采用有效的编码，降低读写地址在连续变化时的位翻转率。采用格雷码就能有效的降低连续变化数值的位翻转率。

所以，可以在将地址跨越时钟域之前，先转换成格雷码，然后跨越时钟域。

到达另一时钟域后，通过两级寄存器消除亚稳态，再将格雷码转换成二进制数。

这样，每次地址变化，跨越时钟域时只有一位可能出错，可以大幅降低出错概率，提高FIFO运行的可靠性。

格雷码与二进制的转换：

1.  module BinToGray(
2.  input clk ，
3.  input rst ，
4.  input \[3:0\]bin\_in ，
5.  output reg \[3:0\]gray\_out
6.  );
7.  
8.  always@(bin\_in ) begin
9.  gray\_out <= \{1'b0,bin\_in\[3:1\]\}^bin\_in;
10. end
11. 
12. endmodule

1.  module GrayToBin(
2.  input clk ,
3.  input rst\_n ,
4.  input \[3:0\]gray\_in ,
5.  output reg \[3:0\]bin\_out
6.  );
7.  
8.  
9.  always@(gray\_in) begin
10. bin\_out\[3\] = gray\_in\[3\];
11. bin\_out\[2\] = **gray\_in\[2\]**^**bin\_out\[3\];**
12. bin\_out\[1\] = gray\_in\[1\]^bin\_out\[2\];
13. bin\_out\[0\] = gray\_in\[0\]^bin\_out\[1\];
14. end
15. 
16. endmodule

**二进制数转格雷码**  
(假设以二进制为0的值做为格雷码的0)  
格雷码第n位 = 二进制码第(n+1)位+二进制码第n位。不必理会进制。

Verilog代码:gray=(binary>>1)^binary;

**格雷码转二进制数**  
二进制码第n位 = 二进制码第(n+1)位+格雷码第n位。因为二进制码和格雷码皆有相同位数，所以二进制码可从最高位的左边位元取0，以进行计算。

verilog 代码://------假设 reg \[n-1\] gray,binary;

integer i;

for(i=0;i<=n-1;i=i+1)

binary\[i\]=^(gray>>i)//gray移位后,自身按位异或 (不是很理解）

000 -- 000

001 -- 001

010 -- 011

011 -- 010

100 -- 110

101 -- 111

110 -- 101

111 -- 100

[09122539-f66a4eee9b0341c9ab4e18f4ad6e782c.jpg]: /images/20220717/e6e060365562411d9e0e28f47f1bfc28.png
[09122758-65cac4b3445f476b9b25338b88fe0595.jpg]: /images/20220717/75cfa99316f64abcb0b2959b74671079.png
[09142332-2dd055f668444f998685034a733f72cc.jpg]: /images/20220717/eb03d9bd90e947029ef92f000dbed015.png
[09142452-504d231d43c942b5bf3e311138264c04.jpg]: /images/20220717/8a98042eb6834d5d894c58a808adee10.png
[09142554-b1cc1fcef63e460e9c0186beebbc53ef.jpg]: /images/20220717/7ecac95a9d3d4438b280202738cd5114.png
[copycode.gif]: /images/20220717/806337dc061241f3afbcef5e721e29c9.png