【【verilog代码异步FIFO的设计解释+源码+tb】】

最新推荐文章于 2024-08-26 21:15:20 发布
最新推荐文章于 2024-08-26 21:15:20 发布
阅读量266 收藏
点赞数
分类专栏： FPGA学习 文章标签： fpga开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50965981/article/details/134095898
版权

异步FIFO的设计

使用格雷码 判断 是否是真的满员
用了很巧的办法
使用gray码解决了一个问题，但同时也带来另一个问题，即在格雷码域如何判断空与满。
对于“空”的判断依然依据二者完全相等(包括MSB)；
而对于“满”的判断，如下图，由于gray码除了MSB外，具有镜像对称的特点，当读指针指向7，写指针指向8时，除了MSB，其余位皆相同，不能说它为满。因此不能单纯的只检测最高位了，在gray码上判断为满必须同时满足以下3条：
wptr和同步过来的rptr的MSB不相等，因为wptr必须比rptr多折回一次。
wptr与rptr的次高位不相等，如上图位置7和位置15，转化为二进制对应的是0111和1111，MSB不同说明多折回一次，111相同代表同一位置。
剩下的其余位完全相等。
解释一下 ：
我们来看 7是 0_100 要是用原来的判别 我们会发现 下一个8 是 1_100 除了 第一位不同 但是很明显 我们并没有相差一圈
接下来 我们 观察 15-7=8 其实 我们正需要的是这样的8 其实是我们设置的3位宽所能提供的最大的 深度 而我们将比照 格雷码
才得出的首位相同 次高位不同 接下来都相同

源码asychronous.v

// asynchronous
module asyn #(
    parameter   WIDTH       =   8               ,
    parameter   DEEPTH      =   16              ,    //  I  just try 16
    parameter   ADDR_WIDTH  =   clogb2(DEEPTH)  
    //  just give up  PROG_EMPTY
  )(
    input                               wr_clk          ,
    input                               rd_clk          ,
    input                               wr_en           ,
    input                               rd_en           ,
    input                               wr_rst_n        ,
    input                               rd_rst_n        ,
    input  [WIDTH-1 : 0 ]               din             ,
    output   reg                        wfull           ,
    output   reg                        wempty          ,
    output   reg  [WIDTH-1 : 0 ]        dout
  );



  // ===================================================================================//
  //             define parameter and internal  signals                                 //
  //====================================================================================//
  reg    [WIDTH-1 : 0]    ram[DEEPTH-1 : 0]      ;    // this is ram
  reg    [ADDR_WIDTH : 0] wr_addr                ;    // we must set more bit wode  add exact bit + address
  reg    [ADDR_WIDTH : 0] rd_addr                ;    // we must set more bit wode
  wire   [ADDR_WIDTH - 1 : 0] wr_addr1           ;
  wire   [ADDR_WIDTH - 1 : 0] rd_addr1           ;
  assign wr_addr1 = wr_addr[ADDR_WIDTH - 1 : 0]  ;    //  we must put  address and addr_pointer together
  assign rd_addr1 = rd_addr[ADDR_WIDTH - 1 : 0]  ;

  // gray
  wire  [ADDR_WIDTH : 0] wr_addr_gray            ;
  wire  [ADDR_WIDTH : 0] rd_addr_gray            ;
  // B 2 Gray code
  assign wr_addr_gray = wr_addr ^ (wr_addr >> 1) ;
  assign rd_addr_gray = rd_addr ^ (rd_addr >> 1) ;

  //synchronous
  reg  [ADDR_WIDTH : 0] wr_addr_gray1            ;
  reg  [ADDR_WIDTH : 0] wr_addr_gray2            ;
  //synchronous
  reg  [ADDR_WIDTH : 0] rd_addr_gray1            ;
  reg  [ADDR_WIDTH : 0] rd_addr_gray2            ;





  //======================================================================================//
  //                            next is main code                                         //
  //========================================================================================//
  function  integer clogb2  ;
    input [31:0] value  ;
    begin
      value = value - 1 ;
      for( clogb2 = 0 ; value > 0 ; clogb2 = clogb2 + 1)
        value = value >>1 ;
    end
  endfunction

  //-----------------------------------------------------------------  wr_addr
  //--the  pointer is another thing
  always@(posedge wr_clk or negedge wr_rst_n)
  begin
    if(wr_rst_n == 0)
    begin
      wr_addr <= 0 ;
    end
    else if( wr_en && !wfull)
    begin
      wr_addr <= wr_addr + 1'b1 ;
    end
    else
      wr_addr <= wr_addr ;
  end

  //----------------------------------------------------------------------- rd_addr
  always@(posedge rd_clk or negedge rd_rst_n)
  begin
    if(rd_rst_n == 0)
    begin
      rd_addr <= 0;
    end
    else if( rd_en && !wempty)
    begin
      rd_addr <= rd_addr + 1'b1 ;
    end
    else
      rd_addr <= rd_addr ;
  end

  //-------------------------------------------------------------------------- write to ram
  //    wr_addr1
  always@(posedge wr_clk or negedge wr_rst_n)
  begin
    if(wr_rst_n == 0 )
    begin
      ram[wr_addr1] <= 0 ;
    end
    else if(wr_en && !wfull)
    begin
      ram[wr_addr1] <= din ;
    end
    else
    begin
      ram[wr_addr1] <= ram[wr_addr1] ;
    end
  end

  //------------------------------------------------------------------------------read to ram
  //  rd_addr1  [ADDR_WIDTH-1 : 0]  this is used to  which need reed
  always@(posedge rd_clk or negedge rd_rst_n)
  begin
    if(rd_rst_n == 0)
    begin
      dout <= 0 ;
    end
    else if( rd_en && !wempty)
    begin
      dout <= ram[rd_addr1] ;
    end
    else
    begin
      dout <= dout ;
    end
  end

  //----------------------------------------------------------------------------------this is what sysnchronus need
  //----------------------------------------------------------------------------------------------------
  //--  next is change to gary   and send to the same time clock //
  //------------------------------------------------------------------------------------------------------\

  //synchronous
  //reg  [ADDR_WIDTH : 0] wr_addr_gray1            ;
  //reg  [ADDR_WIDTH : 0] wr_addr_gray2            ;
  //synchronous
  //reg  [ADDR_WIDTH : 0] rd_addr_gray1            ;
  // reg  [ADDR_WIDTH : 0] rd_addr_gray2            ;

  //  this is pointer point
  // full use reed synchronous write
  // empty use write synchronous read

  //------------------------------------------------------------------------------------------------------\


  // write pointer  synchronous read clk     -----  empty
  always@(posedge rd_clk or negedge rd_rst_n)
  begin
    if( rd_rst_n == 0)
    begin
      wr_addr_gray1 <= 0 ;
      wr_addr_gray2 <= 0 ;
    end
    else
    begin
      wr_addr_gray1 <= wr_addr_gray  ;
      wr_addr_gray2 <= wr_addr_gray1 ;
    end
  end


  // read pointer sunchronous write clk    -----  full
  always@(posedge wr_clk or negedge wr_rst_n)
  begin
    if( wr_rst_n == 0)
    begin
      rd_addr_gray1 <= 0 ;
      rd_addr_gray2 <= 0 ;
    end
    else
    begin
      rd_addr_gray1 <= rd_addr_gray  ;
      rd_addr_gray2 <= rd_addr_gray1 ;
    end
  end

  //---------------------------------------------------  empty  full   determine

  //empty
  always@(*)
  begin
    if( rd_rst_n == 0 )
    begin
      wempty <= 0 ;
    end
    else if(rd_addr_gray == wr_addr_gray2)
    begin
      wempty <= 1 ;
    end
    else
    begin
      wempty <= 0 ;
    end
  end



  // full
  always@(*)
  begin
    if(wr_rst_n == 0)
    begin
      wfull <= 0 ;
    end
    else if( wr_addr_gray == {~rd_addr_gray2[ADDR_WIDTH:ADDR_WIDTH-1],rd_addr_gray2[ADDR_WIDTH-2 : 0] } )
    begin
      wfull <= 1 ;
    end
    else
    begin
      wfull <= 0 ;
    end
  end

endmodule

asychro_tb.v

`timescale 1ns/1ps
module asych_tb #(
    parameter   WIDTH       =   8               ,
    parameter   DEEPTH      =   8               ,
    parameter   ADDR_WIDTH  =   3
  );
  reg                               wr_clk          ;
  reg                               rd_clk          ;
  reg                               wr_en           ;
  reg                               rd_en           ;
  reg                               wr_rst_n        ;
  reg                               rd_rst_n        ;
  reg  [WIDTH-1 : 0 ]               din             ;
  wire                              wfull           ;
  wire                              wempty          ;
  wire [WIDTH-1 : 0 ]               dout            ;


  asyn#(
        .WIDTH     ( WIDTH ),
        .DEEPTH    ( DEEPTH ),
        .ADDR_WIDTH ( ADDR_WIDTH )
      )u_asyn(
        .wr_clk    ( wr_clk    ),
        .rd_clk    ( rd_clk    ),
        .wr_en     ( wr_en     ),
        .rd_en     ( rd_en     ),
        .wr_rst_n  ( wr_rst_n  ),
        .rd_rst_n  ( rd_rst_n  ),
        .din       ( din       ),
        .wfull     ( wfull     ),
        .wempty    ( wempty    ),
        .dout      ( dout      )
      );




  always     #10     wr_clk  =   ~wr_clk       ;
  always     #5      rd_clk  =   ~rd_clk       ;



  initial
  begin
    wr_clk      =     0 ;
    wr_rst_n    =     1 ;
    wr_en       =     0 ;


    rd_clk      =     0 ;
    rd_rst_n    =     1 ;
    rd_en       =     0 ;

    #10
     wr_rst_n    =      0;
    rd_rst_n    =      0;

    #10
     wr_rst_n    =      1;
    rd_rst_n    =      1;


    // next is write
    wr_en       =       1;
    rd_en       =       0;

    //only write
    wr_en       =       1;
    rd_en       =       0;
din = 1 ;
    repeat(10)
    begin
      @(negedge wr_clk)
       begin
         din  =  {$random}%30  ;
       end
     end

     //only read
     wr_en       =       0;
    rd_en       =       1;

    repeat(10)
    begin
      @(negedge rd_clk) ;

    end
    rd_en      =       0   ;


//read and write
    wr_en = 0;
    rd_en = 0;    
    #80;
    wr_en = 1;
    rd_en = 1;

    repeat(20) begin
        @(negedge wr_clk) begin
            din = {$random}%30;
        end
    end

end


endmodule
ZxsLoves
关注
专栏目录
来一个Verilog代码：异步fifo 及其测试的tb文件
weixin_42588672的博客
02-10 155
Verilog代码如下： module async_fifo ( input clk, input rst, input wr_en, input rd_en, input [7:0] wr_data, output reg [7:0] rd_data, output full, output empty ); paramet...
[vivado2019.2+verilog]同步复位和异步复位tb仿真及源码
weixin_45838228的博客
04-19 2477
[vivado2019.2+verilog]同步复位和异步复位tb仿真及源码 一、sync_reset 1.新建项目 2.Add Design Sources 文件 也可以 之后就是一路ok，finsh就行了。个人习惯在设计文件名后面加上“_top”。 接着就可以在右侧编写verilog程序了， 下面展示一些 内联代码片。 `timescale 1ns / 1ps ////////////////////////////////////////////////////////////////////
异步FIFO设计（代码篇）
weixin_48085905的博客
05-06 430
/空信号检测（写指针同步到rd_clk后与读指针进行比较）//满信号检测（读指针同步到wr_clk后与写指针进行比较）//读数据 1 latency。//写指针同步到读时钟域。//读指针同步到写时钟域。//深度16 宽度16。//读指针转换为格雷码。
FPGA开发——使用verilog实现异步FIFO
最新发布
weixin_63553972的博客
08-26 1724
1、FIFO的分类FIFOFirst In First Out）先进先出存储器。根据接入的时钟信号，可以分为同步FIFO和异步FIFO。FIFO底层是基于双口RAM，同步FIFO的读写时钟一致，异步FIFO 读时钟和写时钟不同。作用：
异步FIFO设计代码
kobetriumph的博客
07-01 2160
异步FIFO的RTL代码实现
异步FIFO代码（包含almost_full以及almost_empty信号），测试代码，功能仿真结果
qq_35579390的博客
08-25 3930
废话不多说直接上代码 module test #( parameter data_width = 8, addr_width = 4, data_depth = 16) ( input rst_n, input wr_clk, //写时钟 input wr_en, //写使能信号 input [data_width-1:0] data_in, //数据输入 input rd_clk, //读时钟 input rd_en, //读使能信号 o
异步FIFO代码及仿真结果（Verilog）
SummerXRT的博客
08-17 3166
文章目录1.代码截图2.仿真结果3.代码 注：代码附于文末 注：因为CSDN不支持Verilog高亮，先用截图的代码便于阅读。 1.代码截图 2.仿真结果 仿真结果如下： 空满标志生成正常 读写地址指针计数器正常 数据存取正常 格雷码逻辑正常 指针跨时钟域同步正常 3.代码 代码如下： module asy_fifo#( parameter WIDTH=8,//FIFO的位宽 parameter DEEPTH=32,//FIFO的深度 parameter POINTER_WIDTH=
异步多时钟FIFO测试verilog代码
09-25
对应于异步多时钟FIFO的testbench文件。
异步FIFO Verilog源码与testbench
01-29
在`async_fifo_tb.v` 文件中，我们找到了testbench的代码，它是验证异步FIFO功能是否正确的关键部分。Testbench通常包括以下步骤： 1. **初始化**：设置测试环境，例如初始化读写指针，填充FIFO，以及设置测试数据...
sync_fifo.zip，博客对应同步FIFO接口源码（RTL和TB）
08-12
在本压缩包"sync_fifo.zip"中，包含了实现同步FIFO的源码（RTL，即Register Transfer Level，寄存器传输级）以及测试平台（TB，Testbench）。源码是硬件描述语言（如Verilog或VHDL）编写的，用于描述FIFO的逻辑功能...
异步fifo_正点原子开拓者FPGA开发板资料连载第十五章 IP核之FIFO实验
weixin_39652760的博客
12-05 694
1)实验平台：正点原子开拓者FPGA 开发板2)摘自《开拓者FPGA开发指南》关注官方微信号公众号，获取更多资料：正点原子3)全套实验源码+手册+视频下载地址：http://www.openedv.com/thread-13912-1-1.html第十五章 IP核之FIFO实验FIFO的英文全称是First In First Out，即先进先出。FPGA使用的FIFO一般指的是对数据的存储具有先进...
异步FIFO源代码
08-30
异步FIFO，跨时钟通信必备，完整代码verilog版本.......
同步FIFO接口源码及波形图教程
综上所述，该资源提供了同步FIFO在RTL和TB层面的设计与测试源码，并包括了VCS仿真环境的自动化脚本，是一个对同步FIFO设计和测试感兴趣的工程师非常有价值的资料。通过这些文件，用户可以学习到如何设计一个符合特定...
异步FIFO代码分析
CLL_caicai的博客
10-12 365
module Asyn_FIFO(data_out, full, empty, data_in, wen, wclk, wrst,ren, rclk, rrst); parameter datasize = 8; parameter addrsize = 4; input [datasize-1:0]data_in; input wen,ren,wclk,rclk,wrst,rrst; output [datasize-1:0]data_out; output empty,full; reg emp.
异步FIFO的Verilog代码 DCFIFO实现
cuiweitju的专栏
09-29 3989
module fifo1(rdata, wfull, rempty, wdata, winc, wclk, wrst_n,rinc, rclk, rrst_n); parameter DSIZE = 8;  parameter ASIZE = 4; output [DSIZE-1:0] rdata; output wfull; output rempty; input
异步FIFO的verilog代码实现（包含将满和将空逻辑）
y183128184的博客
10-29 2025
转自：https://www.cnblogs.com/lyc-seu/p/12439203.html 代码参考来源： Clifford E. Cummings, "Simulation and Synthesis Techniques for Asynchronous FIFO Design". https://www.cnblogs.com/IClearner/p/6579754.html （一）异步FIFO简介 使用场景：在有大量的数据需要进行跨时钟域传输， 并且对数据传输
异步fifo读空、写满分析（附完整异步fifo代码）
热门推荐
争取早日成为硅农
03-02 3万+
FIFO 是 First-In, First-Out 的缩写，即“先进先出”，是一种常见的数据结构，类似于排队服务。在 FIFO 结构中，最先进入的数据项首先被取出，后进入的数据项则会在队列中等待。FIFO 在计算机科学和电子工程中被广泛使用，用于数据存储和传输。特点数据按照先进先出的顺序进行存储和检索。支持两个基本操作：入队（enqueue）将数据放入队列尾部，出队（dequeue）从队列头部取出数据。FIFO 可以用数组或链表等数据结构来实现。应用领域数据缓冲。
异步FIFO理解及代码实现
努力为了更好
08-06 1023
相对于同步FIFO，内部读写时钟是同一个时钟源，异步FIFO，内部读写时钟是独立的。所以，异步FIFO的参数有： 宽度：每个数据的位数； 深度：FIFO最多能存储多少个N位的数据。 还有Din:输入 nWr：写使能 Wr_Clk：写时钟 nRd:读使能 Rd_Clk:读时钟 Dout：输出； Buff:缓存 以下是异步FIFO的实现： /*功能定义：用来实现异步FIFO； ...
异步FIFO：Verilog代码设计与实现
ytyChris的博客
12-25 2418
1.异步FIFO的定义 FIFO：First in first out的缩写，即先进先出，可以理解为一个双端口ram。异步fifo是指读写时钟不一样，有两个时钟信号，分别是读时钟信号和写时钟信号。与之对应的是同步fifo，它的读和写都由同一个时钟触发，只有一个时钟信号。 2.FIFO用途 首先做一个类比：把FIFO类比为一个蓄水池，该蓄水池有进水口和出水口。当进水量大于出水量时，可以把多余的水存入蓄水池中。当出水量大于进水量时，可以从蓄水池中取出水。由于受到重力的作用，从进水口先进入的水肯定先从出水口出来。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值