异步fifo的设计(FPGA)

时间 2019-12-09

标签异步 fifo 设计 fpga 繁體版

原文原文链接

本文首先对异步 FIFO 设计的重点难点进行分析

最后给出详细代码

1、FIFO简单讲解

FIFO的本质是RAM，先进先出

重要参数：fifo深度（简单来讲就是须要存多少个数据）

fifo位宽（每一个数据的位宽）

FIFO有同步和异步两种，同步即读写时钟相同，异步即读写时钟不相同

同步FIFO用的少，能够做为数据缓存

异步FIFO能够解决跨时钟域的问题，在应用时需根据实际状况考虑好fifo深度便可

本次要设计一个异步FIFO，深度为8，位宽也是8.

代码是学习Simulation and Synthesis Techniques for Asynchronous FIFO Design Clifford E. Cummings, Sunburst Design, Inc.这篇文章的，

百度搜搜很容易找到，虽然是英文的可是写的确实值得研究。

下面我会对设计的要点进行分析，也是对本身学习过程的一个总结，但愿能和你们交流共同进步。

2、设计要点解析

一、读空信号如何产生？写满信号如何产生？

读空信号：复位的时候，读指针和写指针相等，读空信号有效（这里所说的指针其实就是读地址、写地址）

当读指针遇上写指针的时候，写指针等于读指针意味着最后一个数据被读完，此时读空信号有效

写满信号：当写指针比读指针多一圈时，写指针等于读指针意味着写满了，此时写满信号有效

咱们会发现读空的条件是写指针等于读指针，写满的条件也是写指针等于读指针，到底如何区分呢？

解决方法：将指针的位宽多定义一位

举个例子说明：假设要设计深度为 8 的异步FIFO，此时定义读写指针只须要 3 位（2^3=8）就够用了，

可是咱们在设计时将指针的位宽设计成 4 位，最高位的做用就是区分是读空仍是写满，具体理论 1 以下

当最高位相同，其他位相同认为是读空

当最高位不一样，其他位相同认为是写满

注意：理论1试用的是二进制数之间的空满比较判断。

可是这篇文章中确不是这样比较的，而是用的理论2，这里我解释一下

因为文章在设计中判断是读指针是否等于写指针的时候，用的是读写指针的格雷码形式（为何用格雷码后面解释），此时若用上面的理论1就会出问题，

由于格雷码是镜像对称的，若只根据最高位是否相同来区分是读空仍是写尽是有问题的，详情我会慢慢说，请看 图 1

绿色框起来的是0--15的格雷码，用红线将格雷码分为上下两部分

经过观察格雷码相邻位每次只有1位发生变化，且上下两部分，除了最高位相反，其他位全都关于红线镜像对称，

7 --> 8 ，格雷码从 0100 --> 1100 ,只有最高位发生变化其他位相同

6 --> 9 , 格雷码从 0101 --> 1101 , 只有最高位发生变化其他位相同

以此类推， 为何要说镜像对称呢？

试想若是读指针指向 8，写指针指向 7 ，咱们能够知道此时此刻并非读空状态也不是写满状态

可是若是在此刻套用理论 1 来判断，看会出现什么状况，咱们来套一下

7的格雷码与8的格雷码的最高位不一样，其他位相同，因此判断出为写满。这就出现误判了，一样套用在 6 和 9，5 和 10等也会出现误判。

所以用格雷码判断是否为读空或写满时应使用理论 2，看最高位和次高位是否相等，具体以下：

当最高位和次高位相同，其他位相同认为是读空

当最高位和次高位不一样，其他位相同认为是写满

补：理论2这个判断方法适用于用格雷码判断比较空满

在实际设计中若是不想用格雷码比较，就能够利用格雷码将读写地址同步到一个时钟域后再将格雷码再次转化成二进制数再用理论1进行比较就行了。。

图 1

二、因为是异步FIFO的设计，读写时钟不同，在产生读空信号和写满信号时，会涉及到跨时钟域的问题，如何解决？

跨时钟域的问题：上面咱们已经提到要经过比较读写指针来判断产生读空和写满信号

可是读指针是属于读时钟域的，写指针是属于写时钟域的，而异步FIFO的读写时钟域不一样，是异步的，

要是将读时钟域的读指针与写时钟域的写指针不作任何处理直接比较确定是错误的，所以咱们须要进行同步处理之后仔进行比较

解决方法：两级寄存器同步 + 格雷码

同步的过程有两个：

（1）将写时钟域的写指针同步到读时钟域，将同步后的写指针与读时钟域的读指针进行比较产生读空信号

（2）将读时钟域的读指针同步到写时钟域，将同步后的读指针与写时钟域的写指针进行比较产生写满信号

同步的思想就是用两级寄存器同步，简单说就是打两拍，相信有点基础的早都烂熟于心，就再也不多作解释，不懂的能够看看代码结合理解。

只是这样简单的同步就能够了吗？no no no ，可怕的亚稳态还在等着你。

咱们若是直接用二进制编码的读写指针去完成上述的两种同步是不行的，使用格雷码更合适，为何呢？

由于二进制编码的指针在跳变的时候有多是多位数据一块儿变化，如二进制的7-->8 即 0111 --> 1000 ,在跳变的过程当中 4 位所有发生了改变，这样很容易产生毛刺，例如

异步FIFO的写指针和读指针分属不一样时钟域，这样指针在进行同步过程当中很容易出错，好比写指针在从0111到1000跳变时4位同时改变，这样读时钟在进行写指针同步后获得的写指针多是0000-1111的某个值，一共有2^4个可能的状况，而这些都是不可控制的，你并不能肯定会出现哪一个值，那出错的几率很是大，怎么办呢？到了格雷码发挥做用的时候了，而格雷码的编码特色是相邻位每次只有 1 位发生变化，这样在进行指针同步的时候，只有两种可能出现的状况：1.指针同步正确，正是咱们所要的；2.指针同步出错，举例假设格雷码写指针从000->001，将写指针同步到读时钟域同步出错，出错的结果只多是000->000，由于相邻位的格雷码每次只有一位变化，这个出错结果实际上也就是写指针没有跳变保持不变，咱们所关心的就是这个错误会不会致使读空判断出错？答案是不会，最可能是让空标志在FIFO不是真正空的时候产生，而不会出现空读的情形。因此gray码保证的是同步后的读写指针即便在出错的情形下依然可以保证FIFO功能的正确性。在同步过程当中的亚稳态不可能消除，可是咱们只要保证它不会影响咱们的正常工做便可。

三、因为设计的时候读写指针用了至少两级寄存器同步，同步会消耗至少两个时钟周期，势必会使得判断空或满有所延迟，这会不会致使设计出错呢？

异步FIFO经过比较读写指针进行满空判断，可是读写指针属于不一样的时钟域，因此在比较以前须要先将读写指针进行同步处理，

将写指针同步到读时钟域再和读指针比较进行FIFO空状态判断，由于在同步写指针时须要时间，而在这个同步的时间内有可能还会写入新的数据，所以同步后的写指针必定是小于或者等于当前实际的写指针，因此此时判断FIFO为空不必定是真空，这样更加保守，一共不会出现空读的状况，虽然会影响FIFO的性能，可是并不会出错，同理将读指针同步到写时钟域再和写指针比较进行FIFO满状态判断，同步后的读指针必定是小于或者等于当前的读指针，因此此时判断FIFO为满不必定是真满，这样更保守，这样能够保证FIFO的特性：FIFO空以后不能继续读取，FIFO满以后不能继续写入。总结来讲异步逻辑转到同步逻辑不可避免须要额外的时钟开销，这会致使满空趋于保守，可是保守并不等于错误，这么写会稍微有性能损失，可是不会出错。

举个例子：大多数情形下，异步FIFO两端的时钟不是同频的，或者读快写慢，或者读慢写快，慢的时钟域同步到快的时钟域不会出现漏掉指针的状况，可是将指针从快的时钟域同步到慢的时钟域时可能会有指针遗漏， 举个例子以读慢写快为例，进行满标志判断的时候须要将读指针同步到写时钟域，由于读慢写快，因此不会有读指针遗漏，同步消耗时钟周期，因此同步后的读指针滞后（小于等于）当前读地址，因此可能满标志会提早产生，满并不是真满。进行空标志判断的时候须要将写指针同步到读指针，由于读慢写快，因此当读时钟同步写指针的时候，必然会漏掉一部分写指针，咱们不用关心那到底会漏掉哪些写指针，咱们在意的是漏掉的指针会对FIFO的空标志产生影响吗？好比写指针从0写到10，期间读时钟域只同步捕捉到了三、五、8这三个写指针而漏掉了其余指针。当同步到8这个写指针时，真实的写指针可能已经写到10 ，至关于在读时钟域还没来得及觉察的状况下，写时钟域可能偷偷写了数据到FIFO去，这样在判断它是否是空的时候会出现不是真正空的状况，漏掉的指针也没有对FIFO的逻辑操做产生影响。

四、多位二进制码如何转化为格雷码

二进制码转换成二进制格雷码，其法则是保留二进制码的最高位做为格雷码的最高位，而次高位格雷码为二进制码的高位与次高位相异或，而格雷码其他各位与次高位的求法相相似。
　　

我再换种更简单的描述

二进制数 1 0 1 1 0

二进制数右移1位，空位补0 0 1 0 1 1

异或运算 1 1 1 0 1

这样就能够实现二进制到格雷码的转换了，总结就是移位而且异或，verilog代码实现就一句：assign wgraynext = (wbinnext>>1) ^ wbinnext;

是否是很是简单。

3、代码解析

异步FIFO的信号接口：

wclk wrst_n winc wdata //写时钟、写复位、写请求、写数据这几个与写有关的所有与wclk同步

rclk rrst_n rinc rdata //读时钟、读复位、读请求、读数据这几个与读有关的所有与rclk同步

wfull //写满与wclk同步

rempty // 读空与rclk同步

本次代码共分为6个module

一、fifo.v 是顶层模块，做用是将各个小模块例化联系起来

module fifo
#(
  parameter DSIZE = 8,        
  parameter ASIZE = 4
 ) 
 (
     output [DSIZE-1:0] rdata,  
     output             wfull,  
     output             rempty,  
     input  [DSIZE-1:0] wdata,  
     input              winc, wclk, wrst_n, 
     input              rinc, rclk, rrst_n
 );

  wire   [ASIZE-1:0] waddr, raddr;  
  wire   [ASIZE:0]   wptr, rptr, wq2_rptr, rq2_wptr;
// synchronize the read pointer into the write-clock domain
  sync_r2w  sync_r2w
  (
                    .wq2_rptr    (wq2_rptr),
                    .rptr        (rptr    ),                          
                    .wclk        (wclk    ), 
                    .wrst_n      (wrst_n  )  
 );

// synchronize the write pointer into the read-clock domain
  sync_w2r  sync_w2r 
  (
                   .rq2_wptr(rq2_wptr), 
                   .wptr(wptr),                          
                   .rclk(rclk),
                   .rrst_n(rrst_n)
 );

//this is the FIFO memory buffer that is accessed by both the write and read clock domains.
//This buffer is most likely an instantiated, synchronous dual-port RAM. 
//Other memory styles can be adapted to function as the FIFO buffer. 
  fifomem 
  #(DSIZE, ASIZE)
  fifomem                        
  (
      .rdata(rdata), 
      .wdata(wdata),                           
      .waddr(waddr),
      .raddr(raddr),                           
      .wclken(winc),
      .wfull(wfull),                           
      .wclk(wclk)
  );

//this module is completely synchronous to the read-clock domain and contains the FIFO read pointer and empty-flag logic.  
  rptr_empty
  #(ASIZE)    
  rptr_empty                          
  (
      .rempty(rempty),                          
      .raddr(raddr),                          
      .rptr(rptr),
      .rq2_wptr(rq2_wptr),                          
      .rinc(rinc),
      .rclk(rclk),                          
      .rrst_n(rrst_n)
  );

//this module is completely synchronous to the write-clock domain and contains the FIFO write pointer and full-flag logic
  wptr_full 
  #(ASIZE)    
  wptr_full                         
  (
      .wfull(wfull),
      .waddr(waddr),  
      .wptr(wptr),
      .wq2_rptr(wq2_rptr),    
      .winc(winc),
      .wclk(wclk),        
      .wrst_n(wrst_n)
  );
  endmodule

View Code

二、fifomem.v 生成存储实体，FIFO 的本质是RAM,所以在设计存储实体的时候有两种方法：用数组存储数据或者调用RAM的IP核 html

module fifomem
#(
    parameter  DATASIZE = 8, // Memory data word width               
    parameter  ADDRSIZE = 4  // 深度为8即地址为3位便可，这里多定义一位的缘由是用来判断是空仍是满，详细在后文讲到
) // Number of mem address bits
(
    output [DATASIZE-1:0] rdata, 
    input  [DATASIZE-1:0] wdata, 
    input  [ADDRSIZE-1:0] waddr, raddr, 
    input                 wclken, wfull, wclk
);
 
`ifdef RAM   //能够调用一个RAM IP核
// instantiation of a vendor's dual-port RAM 
my_ram  mem
      (
          .dout(rdata),
          .din(wdata),     
          .waddr(waddr),
          .raddr(raddr),   
          .wclken(wclken), 
          .wclken_n(wfull),
          .clk(wclk)
      );
  `else  //用数组生成存储体
 // RTL Verilog memory model
localparam DEPTH = 1<<ADDRSIZE;   // 左移至关于乘法，2^4
reg [DATASIZE-1:0] mem [0:DEPTH-1]; //生成2^4个位宽位8的数组
assign rdata = mem[raddr];
always @(posedge wclk)  //当写使能有效且还未写满的时候将数据写入存储实体中，注意这里是与wclk同步的
    if (wclken && !wfull)
        mem[waddr] <= wdata;
 `endif
 endmodule

View Code

三、sync_r2w.v 将 rclk 时钟域的格雷码形式的读指针同步到 wclk 时钟域，简单来说就是用两级寄存器同步，即打两拍数组

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) begin
          wq1_rptr <= 0;          
          wq2_rptr <= 0;
      end           
      else begin        
          wq1_rptr<= rptr;
          wq2_rptr<=wq1_rptr;
      end          
  endmodule

View Code

四、sync_w2r.v 将 wclk 时钟域的格雷码形式的写指针同步到 rclk 时钟域缓存

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)begin
          rq1_wptr <= 0;
          rq2_wptr <= 0;
      end 
      else begin
          rq1_wpt <= wptr;
          rq2_wptr <= rq1_wptr;
      end
        
endmodule

View Code

五、rptr_empty.v 将 sync_w2r.v 同步后的写指针与 rclk 时钟域的读指针进行比较生成都空信号dom

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;
 // GRAYSTYLE2 pointer
 //将二进制的读指针与格雷码进制的读指针同步
  always @(posedge rclk or negedge rrst_n) 
      if (!rrst_n) begin
          rbin <= 0;
          rptr <= 0;
      end  
      else begin        
          rbin<=rbinnext; //直接做为存储实体的地址
          rptr<=rgraynext;//输出到 sync_r2w.v模块，被同步到 wrclk 时钟域
      end
  // Memory read-address pointer (okay to use binary to address memory)
  assign raddr     = rbin[ADDRSIZE-1:0]; //直接做为存储实体的地址，好比链接到RAM存储实体的读地址端。
  assign rbinnext  = rbin + (rinc & ~rempty); //不空且有读请求的时候读指针加1
  assign rgraynext = (rbinnext>>1) ^ rbinnext; //将二进制的读指针转为格雷码
  // FIFO empty when the next rptr == synchronized wptr or on reset 
  assign rempty_val = (rgraynext == rq2_wptr); //当读指针等于同步后的写指针，则为空。
  always @(posedge rclk or negedge rrst_n) 
      if (!rrst_n)
          rempty <= 1'b1; 
      else     
          rempty <= rempty_val;
 
endmodule

View Code

六、wptr_full.v 将 sync_r2w.v 同步后的读指针与wclk 时钟域的写指针进行比较生成写满信号异步

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;
  // GRAYSTYLE2 pointer
  always @(posedge wclk or negedge wrst_n)   
      if (!wrst_n)
          {wbin, wptr} <= 0;   
      else         
          {wbin, wptr} <= {wbinnext, wgraynext};
  // Memory write-address pointer (okay to use binary to address memory) 
  assign waddr = wbin[ADDRSIZE-1:0];
  assign wbinnext  = wbin + (winc & ~wfull);
  assign wgraynext = (wbinnext>>1) ^ wbinnext; //二进制转为格雷码
  //-----------------------------------------------------------------
  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

View Code

七、测试文件ide

`timescale 1ns /1ns 

module test();
reg  [7:0] wdata;
reg           winc, wclk, wrst_n; 
reg           rinc, rclk, rrst_n;
wire [7:0] rdata;  
wire           wfull;  
wire          rempty;  

fifo

u_fifo (
               .rdata(rdata),  
               .wfull(wfull),  
               .rempty(rempty),  
               .wdata (wdata),  
               .winc  (winc), 
               .wclk  (wclk), 
               .wrst_n(wrst_n), 
               .rinc(rinc), 
               .rclk(rclk), 
               .rrst_n(rrst_n)
 );
localparam CYCLE = 20;
localparam CYCLE1 = 40;



        //时钟周期，单位为ns，可在此修改时钟周期。
     
            //生成本地时钟50M
            initial begin
                wclk = 0;
                forever
                #(CYCLE/2)
                wclk=~wclk;
            end
            initial begin
                rclk = 0;
                forever
                #(CYCLE1/2)
                rclk=~rclk;
            end

            //产生复位信号
            initial begin
                wrst_n = 1;
                #2;
                wrst_n = 0;
                #(CYCLE*3);
                wrst_n = 1;
            end
            
             initial begin
                rrst_n = 1;
                #2;
                rrst_n = 0;
                #(CYCLE*3);
                rrst_n = 1;
            end

            always  @(posedge wclk or negedge wrst_n)begin
                if(wrst_n==1'b0)begin
                    winc <= 0;
                    rinc <= 0;
                end
                else begin
                    winc <= $random;
                    rinc <= $random;
                end
            end

            always  @(posedge rclk or negedge rrst_n)begin
                if(rrst_n==1'b0)begin                  
                    rinc <= 0;
                end
                else begin                
                    rinc <= $random;
                end
            end
always@(*)begin
  if(winc == 1)
    wdata= $random ;
  else
    wdata = 0;
end  
endmodule

View Code

八、仿真结果性能

因为截图篇幅的限制请本身验证仿真。学习

原文连接：http://www.cnblogs.com/aslmer/p/6114216.html 测试