• FPGA原理与结构（13）——FIFO IP核的使用与测试

    系列文章目录：FPGA原理与结构（0）——目录与传送门

    一、前言

            本文介绍FIFO Generator v13.2 IP核的具体使用与例化，在学习一个IP核的使用之前，首先需要对于IP核的具体参数和原理有一个基本的了解，具体可以参考：

    FPGA原理与结构——FIFO IP核原理学习icon-default.png?t=N7T8https://blog.csdn.net/apple_53311083/article/details/132378996?spm=1001.2014.3001.5501

    二、FIFO IP核定制

    1、FIFO IP核

    step1 打开vivado工程，点击左侧栏中的IP Catalog

    c1987bb2bcf249be8d0ca5f847744a0c.jpeg

    step2 在搜索栏搜索FIFO，找到FIFO Generator核

    99ad759bbe6a4661b465b48f57064dc5.jpeg

    2、IP核定制 

    step3 Basic 界面定制

    f0f81c6c86c54f9ca5078d8b1ee0dfbf.jpeg

    ①Component Name ：自定义FIFO的名称 

    ②Interface Type ：接口类型，我们知道FIFO可以支持Native接口和AXI接口，其中AXI接口包括AXI3,AXI4,AXI Stream类型，这里我们选择Native。

        Fifo Implementation ：用于选择我们想要实现的是同步 FIFO 还是异步 FIFO 以及使用哪
    种资源实现 FIFO，这里我们选择“Independent Clocks Block RAM”,即使用块 RAM 来实现的异步 FIFO。
        Synchronization Stages ：同步级数，这里保持默认为2，如果有更高的频率要求，可以提升。
    ③FIFO Implementation Options ：不同资源类型实现FIFO所能支持的功能列表，大家根据表格自行观察连接即可。


    step4 Native Ports 界面设计

    5cb4107a8efc498ead60d87e7a8d816a.jpeg

    ①Read Mode ：用于设置读 FIFO 时的读模式，可选的有标准模式和前显模式，一般没有特殊需求的前提下，我们推荐标准模式。这里我们选择默认的“Standard FIFO”。
    ②Data Port Parameters ：用于设置读写端口的数据总线的宽度以及 FIFO 的深度，写宽度“Write Width”我们设置为 8 位，写深度“Write Depth”我们设置为 256，注意此时 FIFO IP 核所能实现的实际深度却是 255；虽然读宽度“Read Width”能够设置成和 写宽度不一样的位宽，且此时读深度“Read Depth”会根据上面三个参数被动地自动设置成相应的值；但是我们还是将读宽度“Read Width”设置成和写宽度“Write Width”一样的位宽，这也是在实际应用中最常用的情况。
    ③ ECC模式：在本次的FIFO测试中不使用
    ④ Initiazation ：用于设置FIFO的复位等相关内容，默认同步复位，安全复位，full在复位时保持高电平有效。

    step5 Status Flags 界面定制

    a0527277fa314254b78eb21c51ed18b7.jpeg

    “Status Flags”界面，这个界面用于设置用户自定义接口或者用于设定专用的输入口。
    ① Optional Flags : 可选信号，在这里可以勾选将空和将满信号，这里我们都勾上。
    ② Handshaking Options ：握手信号，这里我们使用不到，就不勾选了。
    ③ Programmable Flags : 可编程阈值，这里我们也不做选择。

    step6 Data Counts

    3abd803c1c1948d9906d08033aab49fe.jpeg

            Data Counts界面用于设置 FIFO 内数据计数的输出信号，此信号表示当前在 FIFO 内存在多少个有效数据。为了更加方便地观察读/写过程，这里我们把读/写端口的数据计数都打开，且计数值总线的位宽设置为满位宽，即 8 位。

    step7 Summary 5615d074617449bcaa49ddc8e40c1ce3.jpeg

             IP核定制的最后一面永远是Summary界面，帮助我们进行一个回顾和检查。

    三、IP核测试

            首先设计了写FIFO模块和读FIFO模块：

    3.1 写fifo模块

    1. //-------------------------------------<写fifo模块>--------------------------------
    2. module fifo_wr(
    3. //-------------------<信号输入>-----------------------
    4.     input clk,               //系统时钟
    5.     input rst,                   //复位信号
    6.     input almost_empty,          //FIFO将空信号
    7.     input almost_full ,          //FIFO将满信号
    8.  
    9. //-------------------<信号输出>----------------------- 
    10.     output reg fifo_wr_en,         //FIFO写使能
    11.     output reg [7:0] fifo_wr_data  //写入FIFO的数据
    12. );
    13.  
    14. //reg define
    15. reg  [1:0]  state            ;  //动作状态
    16. reg  		almost_empty_d0  ;  //almost_empty 延迟一拍
    17. reg  		almost_empty_syn ;  //almost_empty 延迟两拍
    18. reg  [3:0]  dly_cnt          ;  //延迟计数器
    19.  
    20. //因为 almost_empty 信号是属于FIFO读时钟域的
    21. //所以要将其同步到写时钟域中
    22. always@( posedge clk ) begin
    23. 	if( rst ) begin
    24. 		almost_empty_d0  <= 1'b0 ;
    25. 		almost_empty_syn <= 1'b0 ;
    26. 	end
    27. 	else begin
    28. 		almost_empty_d0  <= almost_empty ;
    29. 		almost_empty_syn <= almost_empty_d0 ;
    30. 	end
    31. end
    32.  
    33. //向FIFO中写入数据
    34. always @(posedge clk ) begin
    35.     if(rst) begin
    36.         fifo_wr_en   <= 1'b0;
    37.         fifo_wr_data <= 8'd0;
    38.         state        <= 2'd0;
    39. 		dly_cnt      <= 4'd0;
    40.     end
    41.     else begin
    42.         case(state)
    43.             2'd0: begin 
    44.                 if(almost_empty_syn) begin  //如果检测到FIFO将被读空
    45.                     state <= 2'd1;          //就进入延时状态
    46.                 end 
    47.                 else
    48.                     state <= state;
    49.             end 
    50. 			2'd1: begin
    51.                 if(dly_cnt == 4'd10) begin  //延时10拍
    52. 											//原因是FIFO IP核内部状态信号的更新存在延时
    53. 											//延迟10拍以等待状态信号更新完毕                   
    54.                     dly_cnt    <= 4'd0;
    55. 					state      <= 2'd2;     //开始写操作
    56. 					fifo_wr_en <= 1'b1;     //打开写使能
    57. 				end
    58. 				else
    59. 					dly_cnt <= dly_cnt + 4'd1;
    60.             end             
    61. 			2'd2: begin
    62.                 if(almost_full) begin      //等待FIFO将被写满
    63.                     fifo_wr_en   <= 1'b0;  //关闭写使能
    64.                     fifo_wr_data <= 8'd0;
    65.                     state        <= 2'd0;  //回到第一个状态
    66.                 end
    67.                 else begin                 //如果FIFO没有被写满
    68.                     fifo_wr_en   <= 1'b1;  //则持续打开写使能
    69.                     fifo_wr_data <= fifo_wr_data + 1'd1;  //且写数据值持续累加
    70.                 end
    71.             end 
    72. 			default : state <= 2'd0;
    73.         endcase
    74.     end
    75. end
    77. endmodule

    3.2 读FIFO模块

    1. //-------------------------------------<读fifo模块>--------------------------------
    2. module fifo_rd(
    3. //-------------------<信号输入>-----------------------
    4.     input               clk ,        // 时钟信号
    5.     input               rst ,      // 复位信号
    6.     input        [7:0]  fifo_dout ,  // 从FIFO读出的数据
    7.     input               almost_full ,// FIFO将满信号
    8.     input               almost_empty,// FIFO将空信号
    9.  
    10. //-------------------<信号输出>----------------------- 
    11.     output  reg         fifo_rd_en   // FIFO读使能
    12. );
    13.  
    14. //reg define
    15. reg  [1:0]  state           ;  // 动作状态
    16. reg         almost_full_d0  ;  // fifo_full 延迟一拍
    17. reg  		almost_full_syn ;  // fifo_full 延迟两拍
    18. reg  [3:0]  dly_cnt         ;  // 延迟计数器
    19.  
    20. //因为 fifo_full 信号是属于FIFO写时钟域的
    21. //所以要将其同步到读时钟域中
    22. always@( posedge clk ) begin
    23. 	if( rst ) begin
    24. 		almost_full_d0  <= 1'b0 ;
    25. 		almost_full_syn <= 1'b0 ;
    26. 	end
    27. 	else begin
    28. 		almost_full_d0  <= almost_full ;
    29. 		almost_full_syn <= almost_full_d0 ;
    30. 	end
    31. end
    32.  
    33. //读出FIFO的数据
    34. always @(posedge clk ) begin
    35.     if(rst) begin
    36.         fifo_rd_en <= 1'b0;
    37. 		state      <= 2'd0;
    38. 		dly_cnt    <= 4'd0;
    39.     end
    40.     else begin
    41.         case(state)
    42.             2'd0: begin
    43.                 if(almost_full_syn)      //如果检测到FIFO将被写满
    44.                     state <= 2'd1;       //就进入延时状态
    45.                 else
    46.                     state <= state;
    47.             end 
    48. 			2'd1: begin
    49.                 if(dly_cnt == 4'd10) begin  //延时10拍
    50. 											//原因是FIFO IP核内部状态信号的更新存在延时
    51. 											//延迟10拍以等待状态信号更新完毕
    52.                     dly_cnt <= 4'd0;
    53. 					state   <= 2'd2;        //开始读操作
    54. 				end
    55. 				else
    56. 					dly_cnt <= dly_cnt + 4'd1;
    57.             end
    58. 		    2'd2: begin
    59.                 if(almost_empty) begin     //等待FIFO将被读空
    60.                     fifo_rd_en <= 1'b0;    //关闭读使能
    61.                     state      <= 2'd0;    //回到第一个状态
    62.                 end
    63.                 else                       //如果FIFO没有被读空
    64.                     fifo_rd_en <= 1'b1;    //则持续打开读使能
    65.             end 
    66. 			default : state <= 2'd0;
    67.         endcase
    68.     end
    69. end
    71. endmodule

    3.3 顶层模块

    1. module fifo_top(
    2. //-------------------<信号输入>-----------------------
    3.     input sys_clk,               //系统时钟
    4.     input rst                    //复位信号
    5. );
    6.  
    7.     wire [7:0] din;             //fifo的输入数据（写入的数据）
    8.     wire wr_en;                 //写使能
    9.     wire rd_en;                 //读使能
    10.     wire [7:0] dout;            //fifo的输出数据（读出的数据）
    11.     wire full;                  //fifo满信号
    12.     wire almost_full;           //fifo将满标志
    13.     wire empty;                 //fifo空标志
    14.     wire almost_empty;          //fifo将空标志
    15.     wire [7:0]rd_data_count;    //fifo写时钟域的数据计数
    16.     wire [7:0]wr_data_count;    //fifo读时钟域的数据计数
    17.     wire wr_rst_busy;
    18.     wire rd_data_count;              
    19.     
    20. //-------------------<IP核例化>-----------------------
    21. fifo_exp1 fifo1 (
    22.   .rst            (rst),                       // input wire rst
    23.   .wr_clk         (sys_clk),                   // input wire wr_clk
    24.   .rd_clk         (sys_clk),                   // input wire rd_clk
    25.   .din            (din),                       // input wire [7 : 0] din
    26.   .wr_en          (wr_en),                     // input wire wr_en
    27.   .rd_en          (rd_en),                     // input wire rd_en
    28.   .dout           (dout),                      // output wire [7 : 0] dout
    29.   .full           (full),                      // output wire full
    30.   .almost_full    (almost_full),               // output wire almost_full
    31.   .empty          (empty),                     // output wire empty
    32.   .almost_empty   (almost_empty),              // output wire almost_empty
    33.   .rd_data_count  (rd_data_count),             // output wire [7 : 0] rd_data_count
    34.   .wr_data_count  (wr_data_count),             // output wire [7 : 0] wr_data_count
    35.   .wr_rst_busy    (wr_rst_busy),               // output wire wr_rst_busy
    36.   .rd_rst_busy    (rd_rst_busy)                // output wire rd_rst_busy
    37. );
    38.  
    39. //例化写FIFO模块
    40. fifo_wr  fifo_wr_u1(
    41.     .clk            ( sys_clk    ),   // 写时钟
    42.     .rst            ( rst  ),   // 复位信号
    43.  
    44.     .fifo_wr_en     ( wr_en )  , // fifo写请求
    45.     .fifo_wr_data   ( din    ) , // 写入FIFO的数据
    46.     .almost_empty   ( almost_empty ), // fifo空信号
    47.     .almost_full    ( almost_full  )  // fifo满信号
    48. );
    49.  
    50. //例化读FIFO模块
    51. fifo_rd  fifo_rd_u1(
    52.     .clk          ( sys_clk    ),      // 读时钟
    53.     .rst          ( rst  ),      // 复位信号
    54.  
    55.     .fifo_rd_en   ( rd_en ),      // fifo读请求
    56.     .fifo_dout    ( dout  ),      // 从FIFO输出的数据
    57.     .almost_empty ( almost_empty ),    // fifo空信号
    58.     .almost_full  ( almost_full  )     // fifo满信号
    59. );
    60.  
    61. endmodule

    3.4 测试模块

    1. `timescale 1ns / 1ps
    2.  
    3. module tb_ip_fifo( );
    4.     // Inputs
    5.     reg sys_clk;
    6.     reg rst;
    7.     
    8.     // Instantiate the Unit Under Test (UUT)
    9.     fifo_top  tb1_fifo_top (
    10.         .sys_clk         (sys_clk), 
    11.         .rst             (rst)
    12.     );
    13.     
    14.     //Genarate the clk
    15.     parameter PERIOD = 20;
    16.  
    17.     always begin
    18.         sys_clk = 1'b0;
    19.         #(PERIOD/2) sys_clk = 1'b1;
    20.         #(PERIOD/2);
    21.     end   
    22.    
    23.     initial begin
    24.         // Initialize Inputs
    25.         rst = 1;
    26.         // Wait 100 ns for global reset to finish
    27.         #100  ;
    28.         rst = 0;
    29.         // Add stimulus here
    30.         
    31.     end
    32.  
    33. endmodule

    3.4 测试结果

    4e6a307bdfe14cad9d529680c41836ab.jpeg

            通过看到FIFO如我们预期的写入和读出数据，读出的数据满足先入先出的原则。

    四、总结 

            本文总结了FIFO IP核的使用方法，给出了各个配置参数的具体含义及配置方式，并对相关的设计进行了测试。

  • 相关阅读:
    如何理解printf变参函数的实现
    基于Java+Spring Boot+MySQL的课程设计选题管理
    五、Javascript 空间坐标[尺寸、滑动]
    【Flink】入门Demo实现、Flink运行架构之运行时组件，任务提交流程，任务调度原理
    Solon2 常用注解之 @ProxyComponent 用法说明
    java计算机毕业设计健身俱乐部管理系统MyBatis+系统+LW文档+源码+调试部署
    IP可视对讲实时录制系统
    spring 只读事务 设置异常回滚事务
    【前端设计模式】之访问者模式
    【计算机基础】Git系列3：常用操作
  • 原文地址：https://blog.csdn.net/apple_53311083/article/details/132471818