IP核之FIFO实验
FIFO的英文全称是First In First Out，即先进先出。FPGA使用的FIFO一般指的是对数据的存储具有先进先出特性的一个缓存器，常被用于数据的缓存,或者高速异步数据的交互也即所谓的跨时钟域信号传递。它与FPGA内部的RAM和ROM的区别是没有外部读写地址线，采取顺序写入数据，顺序读出数据的方式，使用起来简单方便，由此带来的缺点就是不能像RAM和ROM那样可以由地址线决定读取或写入某个指定的地址。本章我们将对Vivado软件生成的FIFO IP核进行读写测试，来向大家介绍Xilinx FIFO IP核的使用方法。
5 O% |; d2 I2 M
15.1 FIFO IP核简介
1 G& q; Y+ d! z根据FIFO工作的时钟域，可以将FIFO分为同步FIFO和异步FIFO。同步FIFO是指读时钟和写时钟为同一个时钟，在时钟沿来临时同时发生读写操作。异步FIFO是指读写时钟不一致，读写时钟是互相独立的。Xilinx的FIFO IP核可以被配置为同步FIFO或异步FIFO，其信号框图如下图所示。从图中可以了解到，当被配置为同步FIFO时，只使用wr_clk,所有的输入输出信号都同步于wr_clk信号。而当被配置为异步FIFO时，写端口和读端口分别有独立的时钟，所有与写相关的信号都是同步于写时钟wr_clk，所有与读相关的信号都是同步于读时钟rd_clk。
" x. q) g  S) `. A  G& _" \

# E1 t/ j/ s4 S9 h( @2 z9 A6 w0 e7 ~
. o2 M/ X7 C1 B/ }5 [图 7.5.13.1 Xilinx的FIFO IP核的信号框图
对于FIFO需要了解一些常见参数：
+ K+ D/ r( N+ m; w- _* uFIFO的宽度：FIFO一次读写操作的数据位N。
FIFO的深度：FIFO可以存储多少个宽度为N位的数据。
/ {/ d( f% k/ [8 Q- m/ b将空标志：almost_empty。FIFO即将被读空。
空标志：empty。FIFO已空时由FIFO的状态电路送出的一个信号，以阻止FIFO的读操作继续从FIFO中读出数据而造成无效数据的读出。
8 H: X, Z7 j% t2 j$ n. E" n将满标志：almost_full。FIFO即将被写满。
满标志：full。FIFO已满或将要写满时由FIFO的状态电路送出的一个信号，以阻止FIFO的写操作继续向FIFO中写数据而造成溢出。
读时钟：读FIFO时所遵循的时钟，在每个时钟的上升沿触发。
写时钟：写FIFO时所遵循的时钟，在每个时钟的上升沿触发。
& f. ~7 z6 a4 ~- |这里请注意，“almost_empty”和“almost_full”这两个信号分别被看作“empty”和“full”的警告信号，他们相对于真正的空（empty）和满（full）都会提前一个时钟周期拉高。
) |* `7 m, c  ?2 U对于FIFO的基本知识先了解这些就足够了，可能有人会好奇为什么会有同步FIFO和异步FIFO，它们各自的用途是什么。之所以有同步FIFO和异步FIFO是因为各自的作用不同。同步FIFO常用于同步时钟的数据缓存，异步FIFO常用于跨时钟域的数据信号的传递，例如时钟域A下的数据data1传递给异步时钟域B，当data1为连续变化信号时，如果直接传递给时钟域B则可能会导致收非所送的情况，即在采集过程中会出现包括亚稳态问题在内的一系列问题，使用异步FIFO能够将不同时钟域中的数据同步到所需的时钟域中。
15.2 实验任务
本节的实验任务是使用Vivado生成FIFO IP核，并实现以下功能：当FIFO为空时，向FIFO中写入数据，写入的数据量和FIFO深度一致，即FIFO被写满；然后从FIFO中读出数据，直到FIFO被读空为止，以此向大家详细介绍一下FIFO IP核的使用方法。

15.3 硬件设计
本章实验只用到了输入的时钟信号和按键复位信号，没有用到其它硬件外设。
+ s* M- G) n( _* E本实验中，各端口信号的管脚分配如下表所示。
表 15.3.1 IP实验管脚分配
) L2 e! x3 Q& V) u5 W/ A2 z* `) e信号名 方向 管脚 端口说明 电平标准
- p7 H# c" @: B! d; Bsys_clk input U18 系统时钟，50Mhz LVCMOS33
sys_rst_n input N16 系统复位，低有效 LVCMOS33
3 t' t* f3 y6 [1 P/ N对应的XDC约束语句如下所示：
, ]  e3 d6 D9 _2 A$ B0 d6 o4 N1 E

1. create_clock -period 20.000 -name clk [get_ports sys_clk]
   1 F: J8 h6 ?: F+ m, ^/ X) G! o8 V
2. set_property -dict {PACKAGE_PIN U18 IOSTANDARD LVCMOS33} [get_ports sys_clk]
   
3. set_property -dict {PACKAGE_PIN N16 IOSTANDARD LVCMOS33} [get_ports sys_rst_n]

复制代码

2 ?) f, s. x1 B: }9 [15.4 程序设计
1 K4 c9 u1 T( Q4 m: ]根据实验任务要求和模块化设计的思想，我们需要如下4个模块：fifo IP核、写fifo模块、读fifo模块以及顶层例化模块实现前三个模块的信号交互。由于FIFO多用于跨时钟域信号的处理，所以本实验我们使用异步FIFO来向大家详细介绍双时钟FIFO IP核的创建和使用。为了方便大家理解，这里我们将读/写时钟都用系统时钟来驱动。系统的功能框图如下图所示：


3 o( [  P% l8 h0 m% O- e$ j  d
' e$ l& M# W( ]2 a$ i图 7.5.13.1 系统框图
首先创建一个名为ip_fifo的工程，接下来我们创建fifo IP核。在Vivado软件的左侧“Flow Navigator”栏中单击“IP Catalog”，“IP Catalog”按钮以及单击后弹出的“IP Catalog”窗口如下图所示。
, X( I$ a- F! j! v
6 w9 B  P$ {% ^. B. z
( S# K7 v  `7 E( W' |6 F
6 O6 B% G* [( |! h7 O图 7.5.13.2 “IP Catalog”按钮


/ V) v$ o1 b$ v9 ]3 x- \
0 ~) J) W7 ~3 c& B' L图 7.5.13.3 “IP Catalog”窗口
在“IP Catalog”窗口中，在搜索栏中输入“fifo”关键字，这时Vivado会自动查找出与关键字匹配的IP核名称，我们双击“FIFO Generator”，如下图所示。
" J' f$ ~) d/ E8 I


" C& v0 C& d7 d3 D: e+ s+ ~9 c- ]( i图 7.5.13.4 搜索栏中输入关键字
弹出“Customize IP”窗口，如下图所示。
# E: ]& H! O, y4 u

/ U% L! K, i7 s* J8 b. d( c
2 F; e2 ^  q9 Y8 T图 7.5.13.5 “Customize IP”窗口
& {6 [8 H8 o3 J3 ^, E; g接下来就是配置IP核的时钟参数的过程。
& d( y0 b' N1 x4 C最上面的“Component Name”一栏设置该IP元件的名称，这里保持默认即可。在第一个“Basic”选项卡中，“Interface Type”选项用于选择FIFO接口的类型，这里我们选择默认的“Native”，即传统意义上的FIFO接口。“Fifo Implementation”选项用于选择我们想要实现的是同步FIFO还是异步FIFO以及使用哪种资源实现FIFO，这里我们选择“Independent Clocks Block RAM”,即使用块RAM来实现的异步FIFO。如下图所示。

7 z1 `# v" ]$ U3 _7 M" ~: e. O/ |
8 u; [% ~9 w! ?5 _
. C# f2 H3 D# e" _) u图 7.5.13.6 “Basic”选项卡
1 T/ e7 |/ z6 ^& V接下来是“Native Ports”选项卡，用于设置FIFO端口的参数。“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”一样的位宽，这也是在实际应用中最常用的情况。由于我们只是观察FIFO的读写，所以最下面的“Reset Pin”选项我们可以不使用，把它取消勾选。其他设置保持默认即可，如下图所示。
9 F/ p0 A! N# {, t# Y3 O+ N
7 P4 }9 Q4 ]6 K+ H: R

$ i4 Y3 v' }9 U图 7.5.13.7 “Native Ports”选项卡
“Status Flags”选项卡，用于设置用户自定义接口或者用于设定专用的输入口。这里我们使用“即将写满”和“即将读空”这两个信号，所以我们把它们勾选上，其他保持默认即可，如下图所示。
! s- p4 }, L. H8 t# N4 _


, x7 d% s) i0 h图 7.5.13.8 “Status Flags”选项卡
“Data Counts”选项卡用于设置FIFO内数据计数的输出信号，此信号表示当前在FIFO内存在多少个有效数据。为了更加方便地观察读/写过程，这里我们把读/写端口的数据计数都打开，且计数值总线的位宽设置为满位宽，即8位，如下图所示。


* Y; l+ P4 A# e
% `4 y: h% m. ~- U/ n8 `2 R图 7.5.13.9 “Data Counts”选项卡
最后的“Summary”选项卡是对前面所有配置的一个总结，在这里我们直接点击“OK”按钮即可，如下图所示。



图 7.5.13.10 “Summary”选项卡
接着就弹出了“Genarate Output Products”窗口，我们直接点击“Generate”即可，如下图所示。

: ]; o! X5 x5 K9 |$ J" v3 n! H+ s! e, g

图 7.5.13.11 “Genarate Output Products”窗口
之后我们就可以在“Design Run”窗口的“Out-of-Context Module Runs”一栏中出现了该IP核对应的run“fifo_generator_0_synth_1”，其综合过程独立于顶层设计的综合，所以在我们可以看到其正在综合，如下图所示。

; ^+ @' P$ @) n: E
/ k+ g+ @1 W! y, B
图 7.5.13.12 “fifo_generator _0_synth_1”run
在其Out-of-Context综合的过程中，我们就可以进行RTL编码了。首先打开IP核的例化模板，在“Source”窗口中的“IP Sources”选项卡中，依次用鼠标单击展开“IP”-“fifo_generator _0”-“Instantitation Template”，我们可以看到“fifo_generator_0.veo”文件，它是由IP核自动生成的只读的verilog例化模板文件，双击就可以打开它，如下图所示。
- R( r' V5 e2 x9 A9 i0 l

* N! [0 P# u2 G, V1 `
图 7.5.13.13 “fifo_generator_0.veo”文件
我们创建一个verilog源文件，其名称为ip_fifo.v，作为顶层模块，其代码如下：

1. 1  module ip_fifo(
   
2. 2      input    sys_clk ,  // 时钟信号
   
3. 3      input    sys_rst_n  // 复位信号
   : g/ H2 U; m# q
4. 4  );
   : P: N8 I) ^" G( ^0 e) A
5. 5  
   
6. 6  //wire define
   7 }2 y4 i9 d) e2 ]9 v
7. 7  wire         fifo_wr_en         ;  // FIFO写使能信号
   0 I) e3 u, f* d: _* r& D
8. 8  wire         fifo_rd_en         ;  // FIFO读使能信号
   ( C1 y9 {7 c$ y/ C: k7 V6 A" O# W/ t; U
9. 9  wire  [7:0]  fifo_din           ;  // 写入到FIFO的数据
   ( P* i/ l, h/ u8 c4 y* W4 l
10. 10 wire  [7:0]  fifo_dout          ;  // 从FIFO读出的数据
    8 S. V8 H% |1 C; Z% l$ x" @- P
11. 11 wire         almost_full        ;  // FIFO将满信号
    - a3 Z7 H  X1 ~: f' ?) [
12. 12 wire         almost_empty       ;  // FIFO将空信号
    6 i) e2 d. _; z( l0 L( c8 |
13. 13 wire         fifo_full          ;  // FIFO满信号
    ; f2 Q" G3 H& ^7 \+ v. `8 _
14. 14 wire         fifo_empty         ;  // FIFO空信号
    
15. 15 wire  [7:0]  fifo_wr_data_count ;  // FIFO写时钟域的数据计数
    
16. 16 wire  [7:0]  fifo_rd_data_count ;  // FIFO读时钟域的数据计数
    9 N/ r9 T8 k! M1 L: J* z
17. 17
    ) R- `7 A( a- }3 G/ m  c) |
18. 18 //*****************************************************
    
19. 19 //**                    main code
    # @  M, m  U: l  R- p; F
20. 20 //*****************************************************
    3 h5 C" A7 L  P1 S% d
21. 21
    
22. 22 //例化FIFO IP核
    
23. 23 fifo_generator_0  fifo_generator_0 (
    
24. 24     .wr_clk        ( sys_clk            ),  // input wire wr_clk
    
25. 25     .rd_clk        ( sys_clk            ),  // input wire rd_clk
    
26. 26
    
27. 27     .wr_en         ( fifo_wr_en         ),  // input wire wr_en
    * ~6 `" I) b! W; Z  Q& c3 O
28. 28     .rd_en         ( fifo_rd_en         ),  // input wire rd_en
    - |* ^: u3 {9 G8 ]" M9 z
29. 29
    
30. 30     .din           ( fifo_din           ),  // input wire [7 : 0] din
    
31. 31     .dout          ( fifo_dout          ),  // output wire [7 : 0] dout
    
32. 32     
    
33. 33     .almost_full   (almost_full         ),  // output wire almost_full
    9 P0 U9 }- e; f7 f. I% o
34. 34     .almost_empty  (almost_empty        ),  // output wire almost_empty
    
35. 35     .full          ( fifo_full          ),  // output wire full
    3 b+ Q% M& l/ E& n- T
36. 36     .empty         ( fifo_empty         ),  // output wire empty
    - u# w. k, h3 P, M6 r6 p& K# b
37. 37
    
38. 38  .wr_data_count ( fifo_wr_data_count ),  // output wire [7 : 0] wr_data_count   
    ; V* K8 ^) v/ A* _4 v( M
39. 39  .rd_data_count ( fifo_rd_data_count )   // output wire [7 : 0] rd_data_count
    ! ^) r! i8 ]- B; U
40. 40 );
    
41. 41
    + b4 Y$ {' u+ [$ T+ b& ^
42. 42 //例化写FIFO模块
    - E, R) ~# e5 J- I
43. 43 fifo_wr  u_fifo_wr(
    % p$ Z" N1 E: w* B! L
44. 44     .clk            ( sys_clk    ),   // 写时钟
    
45. 45     .rst_n          ( sys_rst_n  ),   // 复位信号
    
46. 46
    
47. 47     .fifo_wr_en     ( fifo_wr_en )  , // fifo写请求
    4 {. V  }2 k, J1 G* i
48. 48     .fifo_wr_data   ( fifo_din    ) , // 写入FIFO的数据
    
49. 49     .almost_empty   ( almost_empty ), // fifo将空信号
    
50. 50     .almost_full    ( almost_full  )  // fifo将满信号
    
51. 51 );
    
52. 52
    
53. 53 //例化读FIFO模块
    
54. 54 fifo_rd  u_fifo_rd(
    
55. 55     .clk          ( sys_clk    ),      // 读时钟
    3 o0 N! C- Y( o' t. C
56. 56     .rst_n        ( sys_rst_n  ),      // 复位信号
    
57. 57
    
58. 58     .fifo_rd_en   ( fifo_rd_en ),      // fifo读请求
    
59. 59     .fifo_dout    ( fifo_dout  ),      // 从FIFO输出的数据
    
60. 60     .almost_empty ( almost_empty ),    // fifo将空信号
    " S: h$ d! N7 X+ o/ J. Y
61. 61     .almost_full  ( almost_full  )     // fifo将满信号
    
62. 62 );
    9 P, j. B5 P, U2 b& l
63. 63
    " F6 m8 R1 V9 x
64. 64 //例化ILA IP核
    , q2 K# f1 P; p2 h
65. 65 ila_0  ila_0 (
    ! J  v( r- a8 f! J
66. 66  .clk    ( sys_clk            ), // input wire clk
    
67. 67
    " y. V: T; b; y* l6 D% v
68. 68  .probe0 ( fifo_wr_en         ), // input wire [0:0]  probe0  
    1 Q. x" S3 n7 R9 W$ g
69. 69  .probe1 ( fifo_rd_en         ), // input wire [0:0]  probe1
    
70. 70  .probe2 ( fifo_din           ), // input wire [7:0]  probe2
    
71. 71  .probe3 ( fifo_dout          ), // input wire [7:0]  probe3
    
72. 72  .probe4 ( fifo_empty         ), // input wire [0:0]  probe4
    
73. 73  .probe5 ( almost_empty       ), // input wire [0:0]  probe5
    9 s' {3 ?6 `3 A
74. 74  .probe6 ( fifo_full          ), // input wire [0:0]  probe6
    " O5 r/ q( O8 Z- _' T( e
75. 75  .probe7 ( almost_full        ), // input wire [0:0]  probe7
    9 f  c2 s8 f: t" \1 z
76. 76  .probe8 ( fifo_wr_data_count ), // input wire [7:0]  probe8
    6 M! v+ l6 ^) k8 ?  }# S
77. 77  .probe9( fifo_rd_data_count  )  // input wire [7:0]  probe9
    $ }5 W2 ~4 T1 y- G7 B2 d  L: r. u
78. 78 );
    
79. 79
    ) c+ W" D8 a* u- E  G1 v4 X  M
80. 80 endmodule

复制代码

顶层模块主要是对FIFO IP核、写FIFO模块、读FIFO模块进行例化，除此之外本实验还生成并例化了一个ILA IP核，用于对顶层模块信号的进行在线捕获观察。
5 F) b# b5 p1 V写FIFO模块fifo_wr.v源文件的代码如下：
) S3 d5 I  U% S. ~+ c. u
/ o6 f( M+ i. Z

1. 1  module fifo_wr(
   " V3 u1 j) C* ~* ]6 v- w0 q
2. 2      input                  clk    ,          // 时钟信号
   , _; \- O# R( i$ M, D3 ]- Y9 t
3. 3      input                  rst_n  ,          // 复位信号
   1 `9 `. A3 l' X6 L  _
4. 4      
   / \  y- _) o( A
5. 5      input                  almost_empty,     // FIFO将空信号
   
6. 6      input                  almost_full ,     // FIFO将满信号
   
7. 7      output    reg          fifo_wr_en ,      // FIFO写使能
   . E* y% m3 o) L2 i# J  V
8. 8      output    reg  [7:0]   fifo_wr_data      // 写入FIFO的数据
   
9. 9  );
   
10. 10
    
11. 11 //reg define
    
12. 12 reg  [1:0]  state            ;  //动作状态
    
13. 13 reg         almost_empty_d0  ;  //almost_empty 延迟一拍
    
14. 14 reg         almost_empty_syn ;  //almost_empty 延迟两拍
    
15. 15 reg  [3:0]  dly_cnt          ;  //延迟计数器
    # E! r  D" \; ]7 T
16. 16 //*****************************************************
    
17. 17 //**                    main code
    
18. 18 //*****************************************************
    * p0 b9 p' j6 n
19. 19
    
20. 20 //因为 almost_empty 信号是属于FIFO读时钟域的
    , P, Y+ X" |3 C' p  X
21. 21 //所以要将其同步到写时钟域中
    
22. 22 always@( posedge clk ) begin
    
23. 23  if( !rst_n ) begin
    2 p0 j& ]0 ]& U8 Z6 _6 p
24. 24      almost_empty_d0  <= 1'b0 ;
    2 ~; D8 j; M0 z8 {1 u4 u% Q4 I, t+ V
25. 25      almost_empty_syn <= 1'b0 ;
    # _. z) d( R9 |: I. f
26. 26  end
    
27. 27  else begin
    3 {  H1 B2 p  |
28. 28      almost_empty_d0  <= almost_empty ;
    . w+ L& p. s. g8 R, l
29. 29      almost_empty_syn <= almost_empty_d0 ;
    
30. 30  end
    " H7 Z2 {3 l9 I' j6 R% @
31. 31 end
    
32. 32
    
33. 33 //向FIFO中写入数据
    
34. 34 always @(posedge clk ) begin
    ; P- U) i/ ]( r. t( S
35. 35     if(!rst_n) begin
    0 G* K5 Q+ z' P. f
36. 36         fifo_wr_en   <= 1'b0;
    
37. 37         fifo_wr_data <= 8'd0;
    / l. k3 k4 H: K6 Y, w* b5 M/ ]+ }
38. 38         state        <= 2'd0;
    
39. 39      dly_cnt      <= 4'd0;
    
40. 40     end
    
41. 41     else begin
    ; S8 D& L4 y( G5 @) C
42. 42         case(state)
    2 J+ I) @! [! k4 x1 U
43. 43             2'd0: begin
    0 v/ h) E7 b' d3 V7 x( e1 `  L# F
44. 44                 if(almost_empty_syn) begin  //如果检测到FIFO将被读空（下一拍就会空）
    
45. 45                     state <= 2'd1;          //就进入延时状态
    + x- D( v( M& ]+ e* T
46. 46                 end
    7 t* b/ c4 u) v' b/ J
47. 47                 else
    & \% H' o' S/ R
48. 48                     state <= state;
    4 W" e0 V4 m5 c% J8 U
49. 49             end
    : U0 n, ~. [9 f- ?8 ?* h  ~  {
50. 50          2'd1: begin
    
51. 51                 if(dly_cnt == 4'd10) begin  //延时10拍
    
52. 52                                             //原因是FIFO IP核内部状态信号的更新存在延时
    
53. 53                                             //延迟10拍以等待状态信号更新完毕                  
    
54. 54                     dly_cnt    <= 4'd0;     
    
55. 55                  state      <= 2'd2;        //开始写操作
    
56. 56                  fifo_wr_en <= 1'b1;        //打开写使能
    
57. 57              end
    
58. 58              else
    & M/ \' X% S! z8 K* {0 Y6 P/ K
59. 59                  dly_cnt <= dly_cnt + 4'd1;
    
60. 60             end            
    ' X/ N2 B) u3 O' |
61. 61          2'd2: begin
    
62. 62                 if(almost_full) begin      //等待FIFO将被写满（下一拍就会满）
    9 ], V0 I& x2 i, h
63. 63                     fifo_wr_en   <= 1'b0;  //关闭写使能
    
64. 64                     fifo_wr_data <= 8'd0;
    
65. 65                     state        <= 2'd0;  //回到第一个状态
    
66. 66                 end
    
67. 67                 else begin                 //如果FIFO没有被写满
    
68. 68                     fifo_wr_en   <= 1'b1;  //则持续打开写使能
    6 J5 R0 B5 E" d; N, z7 d
69. 69                     fifo_wr_data <= fifo_wr_data + 1'd1;  //且写数据值持续累加
    
70. 70                 end
    
71. 71             end
    . N, P! n- d/ t
72. 72          default : state <= 2'd0;
    
73. 73         endcase
    : Q& @6 W" ?# w
74. 74     end
    
75. 75 end
    
76. 76
    
77. 77 endmodule
    

复制代码

# u6 D1 u$ m' lfifo_wr模块的核心部分是一个不断进行状态循环的小状态机，如果检测到FIFO为空，则先延时10拍，这里注意，由于FIFO的内部信号的更新比实际的数据读/写操作有所延时，所以延时10拍的目的是等待FIFO的空/满状态信号、数据计数信号等信号的更新完毕之后再进行FIFO写操作，如果写满，则回到状态0，即等待FIFO被读空，以进行下一轮的写操作。
& B  ~. K6 u) O. d2 z9 h读FIFO模块fifo_rd.v源文件的代码如下：

1. 1  module fifo_rd(
   ) T# }: p+ z4 ?' E& A
2. 2      input               clk          ,   // 时钟信号
   
3. 3      input               rst_n        ,   // 复位信号
   & Q  C4 e7 D$ ~3 o* L9 j
4. 4  
   
5. 5      input        [7:0]  fifo_dout    ,   // 从FIFO读出的数据
   
6. 6      input               almost_full  ,   // FIFO将满信号
   
7. 7      input               almost_empty ,   // FIFO将空信号
   9 s) }$ s6 T1 n$ D
8. 8      output  reg         fifo_rd_en       // FIFO读使能
   
9. 9  );
   
10. 10
    
11. 11 //reg define
    0 |7 v+ ~4 v( w) Q4 Z
12. 12 reg  [1:0]  state           ;  //状态
    
13. 13 reg         almost_full_d0  ;  //almost_full延迟一拍
    
14. 14 reg         almost_full_syn ;  //almost_full延迟两拍
    
15. 15 reg  [3:0]  dly_cnt         ;  //延迟计数器
    ; U! Z7 \5 D+ g
16. 16
    * c  f5 S0 t7 W1 Y2 w0 H- C$ ?4 V
17. 17 //*****************************************************
    
18. 18 //**                    main code
    
19. 19 //*****************************************************
    
20. 20
    
21. 21 //因为 fifo_full 信号是属于FIFO写时钟域的
    
22. 22 //所以要将其同步到读时钟域中
    - F- Y+ Y5 w# P8 _! a' N
23. 23 always@( posedge clk ) begin
    " l- u$ c4 z4 Y1 W7 O. V
24. 24  if( !rst_n ) begin
    . u/ c/ e# P/ Z9 |) K: N8 b2 l! _
25. 25      almost_full_d0  <= 1'b0 ;
    ! c6 V. Q- P+ x9 N
26. 26      almost_full_syn <= 1'b0 ;
    ! q" M0 }7 e- i: X! T5 ?! i
27. 27  end
    2 s" b9 @- f/ I& C
28. 28  else begin
    0 S3 k9 \4 j! ^* U0 k) e
29. 29      almost_full_d0  <= almost_full ;
    % p8 j6 g1 `# I. a0 D
30. 30      almost_full_syn <= almost_full_d0 ;
    
31. 31  end
    " p& A; F- M5 B) ?
32. 32 end
    
33. 33
    
34. 34 //读出FIFO的数据
    2 s. C# R* `+ T2 j. `) g$ |3 S
35. 35 always @(posedge clk ) begin
    " U9 _8 p, S3 H
36. 36     if(!rst_n) begin
    
37. 37         fifo_rd_en <= 1'b0;
    $ W  z4 j& g# U0 O2 y2 P0 S' i0 i
38. 38      state      <= 2'd0;
    
39. 39      dly_cnt    <= 4'd0;
    % P" s& D, b; Q3 x$ b/ k. G
40. 40     end
    - L. {. P" \, K
41. 41     else begin
    ! L( o; P+ f0 S: }6 ^
42. 42         case(state)
    
43. 43             2'd0: begin                     
    4 i% I& C6 |& e+ A
44. 44                 if(almost_full_syn)        //如果检测到FIFO被写满
    
45. 45                     state <= 2'd1;         //就进入延时状态
    - [) i# A' O$ y0 d
46. 46                 else
    
47. 47                     state <= state;
    
48. 48             end
    & x; m: B( I0 E# N
49. 49          2'd1: begin
    
50. 50                 if(dly_cnt == 4'd10) begin //延时10拍
    
51. 51                                            //原因是FIFO IP核内部状态信号的更新存在延时
    
52. 52                                            //延迟10拍以等待状态信号更新完毕
    
53. 53                     dly_cnt <= 4'd0;
    
54. 54                  state   <= 2'd2;          //开始读操作
    
55. 55              end
    ( _* b9 k2 V& D+ Q5 u
56. 56              else
    " q6 V& u- |( V1 z6 q1 {* G
57. 57                  dly_cnt <= dly_cnt + 4'd1;
    9 K3 d6 B! u) K
58. 58             end
    
59. 59          2'd2: begin
    
60. 60                 if(almost_empty) begin     //等待FIFO将被读空（下一拍就会空）
    4 D  l% X2 m% g; ?/ d$ O
61. 61                     fifo_rd_en <= 1'b0;    //关闭读使能
    
62. 62                     state      <= 2'd0;    //回到第一个状态
    . }3 B5 ]# H9 @$ q/ D- E  P, H
63. 63                 end
    . Z' z2 u7 t( u6 n
64. 64                 else                       //如果FIFO没有被读空
    % B& D: b; F& v- O, ^
65. 65                     fifo_rd_en <= 1'b1;    //则持续打开读使能
    
66. 66             end
    
67. 67          default : state <= 2'd0;
    ! v7 I! C+ {# D
68. 68         endcase
    
69. 69     end
    ( j# S+ K5 H' }2 K
70. 70 end
    
71. 71
    ( z8 f1 \0 d5 D3 z2 U
72. 72 endmodule

复制代码

读模块的代码结构与写模块几乎一样，也是使用一个不断进行状态循环的小的状态机来控制操作过程，读者参考着代码应该很容易能够理解，这里就不再赘述。
我们对代码进行仿真，TestBench中只要送出时钟的复位信号即可。TB文件如下：
4 ?6 q, g( X. C, e
- S, z! B! G( V0 R

1. 1  `timescale 1ns / 1ps
   
2. 2  module tb_ip_fifo( );
   9 I$ ^) Q6 S0 W4 t5 M
3. 3      // Inputs
   7 J7 h8 s) A" E
4. 4      reg sys_clk;
   4 @! |: f- }6 `  ]5 ^& R7 j
5. 5      reg sys_rst_n;
   
6. 6      
   
7. 7  // Instantiate the Unit Under Test (UUT)
   " P' ]! c& g/ r( M0 J2 V1 L* g
8. 8  ip_fifo  u_ip_fifo (
   
9. 9          .sys_clk         (sys_clk),
   9 H; C# ~+ W9 L5 i
10. 10         .sys_rst_n       (sys_rst_n)
    
11. 11     );
    
12. 12     
    
13. 13 //Genarate the clk
      |( l% H7 v8 d3 b
14. 14 parameter PERIOD = 20;
    6 n* M0 A* H9 U1 [: C  U3 |: U
15. 15 always begin
    
16. 16     sys_clk = 1'b0;
    
17. 17     #(PERIOD/2) sys_clk = 1'b1;
    
18. 18     #(PERIOD/2);
    " _3 a, |6 U. r/ ^) x/ {8 X! A
19. 19 end   
    7 U- {2 d4 A0 g0 |" e& T: u6 N
20. 20   
    
21. 21 initial begin
    9 r0 S$ w' B5 u
22. 22     // Initialize Inputs
    . v- m  Y9 z3 E% J5 e3 d
23. 23     sys_rst_n = 0;
    
24. 24     // Wait 100 ns for global reset to finish
    
25. 25     #100  ;
    . U5 `. v: ?  U' w7 x
26. 26     sys_rst_n = 1;
    
27. 27     // Add stimulus here
    3 @/ A3 [+ t; V0 C
28. 28 end
    , c9 Z, n/ @! s' m8 _" I' x4 Y
29. 29
    
30. 30 endmodule

复制代码

写满后转为读的仿真波形图如下图所示：
1 X4 L1 U6 o# ]  V: U


; o5 Q' _; v  K& {# @  H; b& [2 @' P图 7.5.13.14 Vivado仿真波形1
由波形图可知，当写满255个数据后，fifo_full满信号就会拉高。经过延时之后，fifo_rd_en写使能信号拉高，经过一拍之后就开始将fifo中的数据送到fifo_dout端口上。
写满后转为读的仿真波形图如下图所示：
8 I- m8 ^# d0 O1 n" C  M; ]
, z  T$ L% s4 U
% n( i9 @5 b9 ~1 `8 ?. E' D! |
2 ^6 A! Y! x+ z+ P% @. U- ?图 7.5.13.15 Vivado仿真波形2
由波形图可知，当读完255个数据后，fifo_empty空信号就会拉高。经过延时之后，fifo_wr_en写使能信号拉高，经过一拍之后就开始向fifo中继续写入数据。

& h- X& [- ?1 v5 c15.5 下载验证
2 S- v: Q8 m6 a9 U+ b. Y6 x0 o编译工程并生成比特流.bit文件，将比特流.bit文件下载到Zynq中。
2 |/ r- P, _* h/ ]5 j4 Z9 {# G下载完成后，接下来在Vivado中会自动出现“hw_ila_1”Dashboard窗口。如下图所示：
, X$ G. e6 z; x/ Y# q2 A5 A

1 |9 J+ p5 z7 V$ Q/ W9 e/ R
图 7.5.13.1 将探针信号添加到波形窗口中
将有关探针信号添加到波形窗口中，这里我们已经完成信号的添加，方法是点击“hw_ila_1”Dashboard窗口左上角的“+”。同时我们在窗口右下角将“fifo_rd_en”信号添加到触发窗口中且设置为上升沿触发，
0 ~: T+ M  X/ B; j7 z' h8 i. L单击左上角的触发按钮，如下图所示：

7 e9 T8 _( r' B

% h- ?7 f2 W- {% k6 v) V+ Q+ E+ i# M图 7.5.13.2 触发按钮
# x3 b/ ?( k: W$ m- i' I最后就看到了ILA捕获得到的数据，展开波形图如下图所示：


( F7 C) d; _2 k; _1 |/ [
图 7.5.13.3 捕获得到的波形图
  ]2 a! i2 c! j& E2 i2 N从捕获得到的波形图中可以看出，其逻辑行为与仿真波形图中的一致，证明我们的代码正确地实现了预期的功能.
————————————————
版权声明：正点原子

8 U& [' J1 A/ l# A, j5 s