Vivado fifo IP 完整例程(包括testbench)

最新推荐文章于 2024-07-29 11:35:41 发布
最新推荐文章于 2024-07-29 11:35:41 发布
阅读量5.2k 收藏 55
点赞数 11
分类专栏： Xilinx FPGA 嵌入式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010879745/article/details/113761874
版权
FPGA 同时被 3 个专栏收录
46 篇文章 14 订阅
订阅专栏
嵌入式
38 篇文章 5 订阅
订阅专栏
Xilinx
34 篇文章 9 订阅
订阅专栏
本文详细介绍了如何使用Verilog实现异步FIFO，包括完整的例程和仿真分析。通过实例展示了FIFO的读写地址生成、空满标志检测，并提供了独立时钟的Block RAM实现。此外，还提供了自编与调用Xilinx IP核的FIFO测试平台，分析了不同模式下的FIFO行为。
摘要由CSDN通过智能技术生成

网上尽管有各种介绍fifo的文章，但大部分没有一个完整的例程来练习，这里给出能够完整演示的fifo例程和仿真分析。工程文件虽然部分基于xilinx的官方例程，但官方例程没有testbench，这部分是自己编写的，并对不同的配置进行了分析，完整的工程文件见
如果没有分数下载，认真看本篇，也能做出来。

第一部分参考以下文章，表示感谢！
调试成功的简单异步FIFO–verilog实现+testbench-布布扣-bubuko.com http://www.bubuko.com/infodetail-2720594.html

实验一 自编fifo主程序

module Asyn_FIFO
#(
     parameter WIDTH = 8,
     parameter DEPTH = 4
 )
(
     input  clk_wr,
     input  clk_rd,
     input  rst_n_rd,
     input  rst_n_wr,
     input  wr_en,
     input  rd_en,
     input  [WIDTH-1:0] data_wr,
     output [WIDTH-1:0] data_rd,
     output reg rd_empty,
     output reg wr_full
);
 
     //defination
     reg  [WIDTH-1 : 0] mem [0 : (1<<DEPTH)-1];        //2^DEPTH numbers
     reg  [DEPTH   : 0] wp, rp;
     reg  [DEPTH   : 0] wr1_rp, wr2_rp, rd1_wp, rd2_wp;
     reg  [DEPTH   : 0] wbin, rbin;
 
 
     wire [DEPTH-1 : 0] waddr, raddr;
     wire [DEPTH   : 0] wbin_next, rbin_next;        //bincode
     wire [DEPTH   : 0] wgray_next, rgray_next;        //graycode
     
     wire rd_empty_val, wr_full_val;
     
     //output
     assign data_rd = mem[raddr];
 
     //input
     always@(posedge clk_wr)
         if(wr_en && !wr_full)
            mem[waddr] <= data_wr;
 
 /*----------generate waddr and raddr-------------------------*/
     //gen raddr and read gray code
     always@(posedge clk_rd or negedge rst_n_rd)
         if(!rst_n_rd)
            {rbin, rp} <= 0;
         else
            {rbin, rp} <= {rbin_next, rgray_next};
 
     assign raddr = rbin[DEPTH-1 : 0];
     assign rbin_next = rbin + (rd_en & ~rd_empty);
     assign rgray_next = rbin_next ^ (rbin_next >> 1);
 
     //gen waddr and write gray code
     always@(posedge clk_wr or negedge rst_n_wr)
         if(!rst_n_wr)
             {wbin, wp} <= 0;
         else
             {wbin, wp} <= {wbin_next, wgray_next};
 
     assign waddr = wbin[DEPTH-1 : 0];
     assign wbin_next = wbin + (wr_en & ~wr_full);
     assign wgray_next = wbin_next ^ (wbin_next >> 1);
 
 /*---------------synchro rp and wp--------------------------*/
     //synchro rp
     always@(posedge clk_wr or negedge rst_n_wr)
         if(!rst_n_wr)
             {wr2_rp, wr1_rp} <= 0;
         else
             {wr2_rp, wr1_rp} <= {wr1_rp, rp}; //delay two clock
 
     //synchro wp
     always@(posedge clk_rd or negedge rst_n_rd)
         if(!rst_n_rd)
             {rd2_wp, rd1_wp} <= 0;
         else
             {rd2_wp, rd1_wp} <= {rd1_wp, wp};
 
 /*---------------empty and full flags--------------------------*/
     //gen rd_empty
     assign rd_empty_val = (rd2_wp == rgray_next);
     always@(posedge clk_rd or negedge rst_n_rd)
         if(!rst_n_rd)
             rd_empty <= 1'b1;
         else
             rd_empty <= rd_empty_val;
 
     //gen wr_full, two high bit do not equal
     assign wr_full_val = ({~wr2_rp[DEPTH : DEPTH-1], wr2_rp[DEPTH-2 : 0]} == wgray_next);
     always@(posedge clk_wr or negedge rst_n_wr)
         if(!rst_n_wr)
             wr_full <= 1'b0;
         else
             wr_full <= wr_full_val;
 
endmodule

tb程序

module Asyn_FIFO_tb;
 
     parameter WIDTH = 8;
 
     reg clk_wr;
     reg clk_rd;
     reg rst_n_rd;
     reg rst_n_wr;
 
     reg  [WIDTH-1:0] data_wr;
     reg  wr_en;
     wire wr_full;
 
     wire [WIDTH-1:0] data_rd;
     reg  rd_en;
     wire rd_empty;
 
 
     Asyn_FIFO fifo_inst(
     .clk_wr(clk_wr), 
     .rst_n_rd(rst_n_rd),
     .rst_n_wr(rst_n_wr),
     .wr_en(wr_en), 
     .data_wr(data_wr), 
     .clk_rd(clk_rd), 
     .rd_en(rd_en), 
     .data_rd(data_rd), 
     .rd_empty(rd_empty), 
     .wr_full(wr_full)
     );
     
     initial begin
         rst_n_rd = 0;
         rst_n_wr = 0;
         clk_wr = 0;
         clk_rd = 0;
         wr_en = 0;
         rd_en = 0;
         
         #20
         rst_n_rd = 1;
         rst_n_wr = 1;
         
         #80
         wr_en = 1;
         rd_en = 0;
         
         #335
         wr_en = 0;
         rd_en = 1;
     end
 
     always #10 clk_wr = ~clk_wr;
     always #20 clk_rd = ~clk_rd;
     
 /*     always @(posedge clk_rd)
         rd_en <= ($random) % 2;
 
     always @(posedge clk_wr)
         wr_en <= ($random) % 2; */
     
     always @(posedge clk_wr)
         data_wr <= ($random) % 256;
     
endmodule

将simulate.runtime时间改为1500ns
在这里插入图片描述

在这里插入图片描述

实验二 调用已IP库fifo, 编写testbench, 参考xilinx下面的官方例程，但自己编写testbench.

从地址下载
https://www.xilinx.com/support/documentation/sw_manuals/xilinx2018_3/ug939-design-files.zip，解压后用vivado打开lab_1实验
在这里插入图片描述
从Flow Navigator, 选择IP Catalog，输入fifo
在这里插入图片描述
在这里插入图片描述

双击FIFO下面的选项
在这里插入图片描述

在这里插入图片描述
Component Name输入char_fifo， Fifo Implementation选Independent Clocks Block RAM.
在这里插入图片描述
注意这里选的是
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
保持Leave Out of context per IP选择, 双击Generate button.
在这里插入图片描述
至此生成fifo IP.

下面制作testbench,

在这里插入图片描述
在这里插入图片描述

拷贝第57至63行到testbench tb_fifo.v例化

char_fifo your_instance_name (
.rst(rst), // input wire rst
.wr_clk(wr_clk), // input wire wr_clk
.rd_clk(rd_clk), // input wire rd_clk
.din(din), // input wire [7 : 0] din
.wr_en(wr_en), // input wire wr_en
.rd_en(rd_en), // input wire rd_en
.dout(dout), // output wire [7 : 0] dout
.full(full), // output wire full
.empty(empty), // output wire empty
.wr_rst_busy(wr_rst_busy), // output wire wr_rst_busy
.rd_rst_busy(rd_rst_busy) // output wire rd_rst_busy
);

从图上可以看到full信号拉低需要在复位信号410ns以后，重新修改testbench
在这里插入图片描述

`timescale 1ns/1ps


module tb_fifo1;

//***************************************************************************
// Parameter definitions
//***************************************************************************

  parameter         WIDTH        = 8;
  parameter         DEPTH        = 16;

  //inputs 
  reg rst;
  reg wr_clk;
  reg rd_clk;
  reg [7:0] din;
  reg wr_en;
  reg rd_en;

  //outputs 
  wire [7:0] dout;
  wire full;
  wire empty;
  wire [3:0] rd_data_count;
  wire [3:0] wr_data_count; 

  // Instantiate the Unit 
 
char_fifo your_instance_name (
  .rst(rst),                      // input wire rst
  .wr_clk(wr_clk),                // input wire wr_clk
  .rd_clk(rd_clk),                // input wire rd_clk
  .din(din),                      // input wire [7 : 0] din
  .wr_en(wr_en),                  // input wire wr_en
  .rd_en(rd_en),                  // input wire rd_en
  .dout(dout),                    // output wire [7 : 0] dout
  .full(full),                    // output wire full
  .empty(empty),                  // output wire empty
  .rd_data_count(rd_data_count),  // output wire [3 : 0] rd_data_count
  .wr_data_count(wr_data_count)  // output wire [3 : 0] wr_data_count
);

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

  initial begin
      // Initialize Inputs 
      wr_clk = 0;                
      rd_clk = 0;
      rst = 1;
      din = 1'b1;
      wr_en = 0;
      rd_en = 0;

      // Wait 100 ns for global reset to finish 
      #100
      rst = 0;
      #500; 

	  repeat (18) begin 
		wr_en = 1;
		#20;
		wr_en = 0;
		#20;
		din = din + 1'b1;
      end 
	  
	  #290
	  repeat (18) begin 
		rd_en = 1;
		#40;
		rd_en = 0;
		#40;
      end	 
 
  end

endmodule

选Standard FIFO时，有效读写深度是15
写得时候，din是输入，所以不与rd_clk时钟对齐，读的时候是时钟打得出去，所以dout与时钟rd_clk对齐。
在这里插入图片描述
在这里插入图片描述

选First Word First Through, 有效深度度是17

即使没有使能，只要有读时钟，dout就会取第一个数据，第一个读使能和读时钟上升沿，dout就会取第二个数。
在这里插入图片描述
设计深度16，实际是17，上图与下图完全相符，达到深度17时full跳起，
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
注意下图，尽管没有使能rd_en, 但由于是First Word First Through模式，在empty降低后，仍将第一们数据推向输出总线，这样写的数量就减少了1，出现长7的情况。
在这里插入图片描述
2021. 5. 6 输入第一 个数据后的六个时钟周期，empty变为0，同时把第一个数据推向dout, 写计数器在第二个写时钟时将写数据计数器加1，与真实写入数据的时钟差一个时钟周期。读写计数并不保持严格的时间周期，可能错两三个时钟周期才计数
在这里插入图片描述
读取第17个数据后的下一个读时钟上升沿empty信号升起。
在这里插入图片描述

实验三 专门处理IP核流程

lab2 IP manager
在这里插入图片描述

在这里插入图片描述
以下过程类似lab1
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

Component Name名字改为clk_core，同时改变下面的配置
• Primary Clock Input Frequency: 200
• Source: Differential clock capable pin
在这里插入图片描述

Port Name设置如下
• clk_out1: clk_rx, 200
• clk_out2: clk_tx, 166.667
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

人工智能和FPGA AI技术
关注
专栏目录
Xilinx DDR3 MIG IP核设计（3）--MIG IP核例程与读写测试（Native接口）
孤独的单刀
12-06 2万+
这篇文章会帮助您：1、学习Xilinx MIG IP核关于DDR3的官方示例设计；2、学会如何通过MIG IP核对DDR3做一个简单的读写测试。
Vivado使用技巧（7）：使用IP核自带Testbench进行仿真
FPGADesigner的博客
08-17 1万+
Vivado中IP Catalog内的大多数IP核都提供了一个TestBench，用于单独仿真该IP核。在设计中可以使用这个TestBench来仿真测试IP核的功能是否正确。在产生IP核的输出文件时，可以看到该IP核是否包含TestBench： 相关文件输出完毕后，在Sources窗口的IP Sources中可以看到该TestBench文件，查阅该文件可以学习不少TestBench的设计编写...
Vivado18.3-IP核-FIFO 学习笔记
weixin_42151221的博客
12-05 9350
本内容学习自领航者ZYNQ 之FPGA开发指南 V1.0 1.FIFO IP核简介 根据FIFO 工作的时钟域，可以将FIFO 分为同步FIFO 和异步FIFO。同步FIFO 是指读时钟和写时钟为同一个时钟，在时钟沿来临时同时发生读写操作。异步FIFO 是指读写时钟不一致，读写时钟是互相独立的。Xilinx 的FIFO IP 核可以被配置为同步FIFO 或异步FIFO，其信号框图如下图所示。从...
赛灵思的fifo的IP核，wr_rst_busy和rd_rst_busy信号
最新发布
weixin_44357071的博客
07-29 354
我在代码中，通过fifo的IP核实现数据的存储和延迟传输，将两个输入在乘法器对齐。但是发现wr_rst_busy和rd_rst_busy一直会拉高，所以找到问题。
FIFO代码以及对应的testbench
05-24
这个是vivado写的Verilog代码，主要是实现FIFO的功能，还有一些是自己的测试testbench
Vivado 下 IP核之FIFO 实验
yishuihanq的博客
06-12 7655
FIFO 本质上是由RAM加读写控制逻辑构成的一种先进先出的数据缓冲器，其与普通存储器RAM的区别在于 FIFO没有外部读写地址线，使用起来非常简单，但FIFO只能顺序写入数据，并按顺序读出数据，其数据地址由内部读写指针自动加 1完成，不能像普通存储器那样可以由地址线决定读取或写入某个指定的地址，不过也正是因为这个特性，使得 FIFO在使用时并不存在像RAM那样的读写冲突问题。根据 FIFO工作的时钟域，可以将FIFO分为。
testbench
qp314的专栏
02-04 6020
1. 激励的产生对于testbench而言，端口应当和被测试的module一一对应。端口分为input,output和inout类型产生激励信号的时候，input对应的端口应当申明为reg,   output对应的端口申明为wire，inout端口比较特殊，下面专门讲解。1）直接赋值。一般用initial块给信号赋初值，initial块执行一次，always或者forever表示由事件激发反复执行
Vivado IP核fifo使用指南
热门推荐
Kevin
04-01 3万+
fifo是FPGA中使用最为频繁的IP核之一，可以通过软件自动生成，也可以自主编写。下面介绍vivado的fifo生成步骤 1、打开ip核，搜索fifo 2、创建fifo 选择独立的时钟块ram。 3、 A、选择标准fifo或者frist word full模式，标准模式是数据延时一个时钟周期进入或者输出；frist word full模式时数据直接随时钟同步进入或者输出。 B、设...
简易异步FIFO代码及testbench
09-16
简易异步FIFO代码及testbench，满足基本FIFO要求，简单实用
fifo完整例程.rar
02-10
网上尽管有各种介绍fifo的文章，但大部分没有一个完整的例程来练习，这里给出能够完整演示的fifo例程和仿真分析。工程文件虽然部分基于xilinx的官方例程，但官方例程没有testbench，这部分是自己编写的，并对不同的...
EDA作业：基于ZYNQ的FIFO IP核的读写测验
weixin_49812895的博客
11-25 783
目录 一、实验目的 二、实验环境 三、实验内容 四、实验结果与分析 实验原理 实验步骤 一、实验目的 使用 Vivado 生成 FIFO IP 核，并实现以下功能：当 FIFO 为空时，向 FIFO 中写入数据，写入的数据量和 FIFO 深度一致，即 FIFO 被写满；然后从 FIFO 中读出数据，直到 FIFO 被读空为止。 二、实验环境 PC机 vivado 2018.3 ZYBO Z7开发板 三、实验内容 根据系统框图，创建工程、添加并撰写Verilog文件和...
异步FIFO Verilog源码与testbench
01-29
网上有很多关于同步FIFO和异步FIFO的源码，个人觉得不易理解，故上传本人最近写的源码，与大家一起分享
同步FIFO代码和testbench
04-02
此代码是同步FIFO的Verilog源代码，经上板测试是没有问题的，请大家放心使用
基于Verilog的同步FIFO的设计（例化IP core）
04-03
本设计是采用Verilog设计的同步FIFO，读写位宽为8位。FIFO需要的RAM是由IP core 例化而来的，时序性能比较好。
用testbench仿真
08-13
用testbench仿真
xilinx 官方fifo IP使用手册
08-30
xilinx 官方fifo IP使用手册，里面描述了关于xilinx官方IP FIFO的所有使用细节
[ip核][vivado]aurora
qwerty的博客
06-26 1万+
Xapp1193: discovered:1)并不是所有芯片都支持aurora.xc7z010就没有。
详解AXI4-Stream接口（2）--AXI4-Stream接口IP源码分析及仿真
孤独的单刀
11-22 1万+
通过本文您会学到：如何对AXI4-Stream接口IP的源码进行分析
同步（单时钟）、异步（双时钟）FIFO的Verilog HDL实现（含Testbench仿真代码）
qq_36045093的博客
07-21 5780
参考资料： 《FPGA自学笔记——设计与验证》；《硬件架构的艺术》；《Verilog HDL数字集成电路高级程序设计》等 链接： 一、FIFO的定义和应用场景 FIFO（First in First Out）是一种先进先出的数据缓冲器，通常用于接口电路的数据缓存。与普通存储器的区别是没有外部读写地址线，可以使用两个时钟分别进行读和写操作。 FIFO只能顺序写入数据和顺序读出数据，其数据地址由内部读、写指针自动加1完成，不能像普通存储器那样可以由地址线决定读取或写入某个指定的地址。 二、FIFO的
vivado FIFO ip
09-29
vivado FIFO IP是一种在Xilinx Vivado设计套件中提供的用于实现FIFO（First-In-First-Out）功能的IP核。通过使用vivado FIFO IP，您可以方便地在您的设计中添加FIFO缓存以实现数据的存储和读取。首先，您需要将fifo_ip.veo文件中的内容复制粘贴到您的Verilog程序中，以实例化该IP核。然后，在配置界面中您可以选择不同的选项来定制FIFO的参数，如读写计数界面和FIFO实现方式。点击“OK”后，您就可以完成FIFO的异步配置。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值