【黑金原创教程】【FPGA那些事儿-驱动篇I 】实验十五：FIFO储存模块（同步）

实验十五：FIFO储存模块（同步）

笔者虽然在实验十四曾解释储存模块，而且也演示奇怪的家伙，但是实验十四只是一场游戏而已。至于实验十五，笔者会稍微严肃一点，手动建立有规格的储存模块，即同步FIFO。那些看过《时序篇》的同学一定对同步FIFO不会觉得陌生吧？因为笔者曾在《时序篇》建立基于移位寄存器的同步FIFO。不过那种同步FIFO只是用来学习的玩具而已。因此，这回笔者可要认真了！

事实告诉笔者，同步FIFO的利用率远胜其它储存模块，几乎所有接口模块都会出现它的身影。早期的时候，笔者都会利用官方准备的同步FIFO（官方插件模块），大伙都知道官方插件模块都非常傲娇，心意（内容）不仅不容易看透，而且信号也不容易捉摸，最重要是无法随心所欲摆布它们。与其跪下向它求救，笔者还不如创建自己专属的同步FIFO。

故名思议，“同步”表示相同频率的时钟源，“FIFO”表示先进先出的意思。FIFO的用意一般都是缓冲数据，另模块独立，让模块回避调用的束缚。同步FIFO是RAM的亚种，它基于RAM，再加上先进先出的机制，学习同步FIFO就是学习如何建立先进先出的机制。

图15.1 同步FIFO建模图（常规）。

常规上，同步FIFO的建模图如图15.1所示，左边有写入请求 ReqW，写入数据 DataW，还有写满标示Full。换之，右边则有读出请求ReqR，读出数据DataR，还有读空标示 Empty。写入方面，ReqW必须拉高DataW才能写入，一旦FIFO写满，那么Full就会拉高。至于读出方面，ReqR 必须拉高，数据才能经由DataR读出，一旦FIFO读空，Empty就会拉高。不过图15.1可以稍微更动一下，另它更加接近低级建模II的形象。

图15.2 同步FIFO建模图（低级建模II）。

如图15.2所示，Req× 改为沟通信号 En，其中En[1] 表示写入使能， En[0]表示读出使能。Data× 改为数据信号Data，iData为写入数据，oData为读出数据。Full与Empty 则改为状态信号 Tag[1] 与 Tag[0] 。

1. module fifo_savemod

2. ( 

3. input CLOCK, RESET,

4. input [1:0]iEn,

5. input [3:0]iData,

6. ouptut [3:0]oData

7. output [1:0]oTag

8. );

9. ......

10. assign oTag[1] = ...; // Full

11. assign oTag[0] = ...; // Empty

12.

13. endmodule

代码15.1

同步FIFO大致的外皮如代码15.1所示，第3~7行是相关的出入端声明，第10~11行则是相关的输出驱动声明。理解这些以后，接下来我们要学习先进先出这个机制。

图15.3 读空状态。

假设笔者建立位宽为4，深度为4的ram，然后又建立位宽为3的写指针WP与读指正RP。同学一定会好奇道，既然ram只有4个深度，那么指针只要2位宽（2² = 4）即不是可以访问所有深度呢？话虽如此，为了利用指正表示写满与读空状态，指针必须多出一位 ... 因此，指针的最高位常常也被称为方向位。

如图15.3所示，一开始的时候，写指针与读指针同样指向地址0，而且ram里边也是空空如也，为此读空状态“叮咚”亮着红灯。为此，我们可以暂时这样表示读空的逻辑关系：

Empty = (WP == RP);

图15.4 写入中①。

当火车开动以后，首先数据 4’hA 写入地址0，然后写指针从原来的 3’b0_00 递增为 3’b0_01，并且指向地址1。此刻，ram再也不是空空入也，所示读空状态消除红灯，结果如图15.4 所示。

图15.5 写入中②。

紧接着，数据 4’hB 写入地址1，然后写指针从原来的 3’b0_01 递增为 3’b0_10，并且指向地址2，结果如图15.5所示。

图15.6写入中③

然后，数据 4’hC 写入地址2，然后写指针从原来的 3’b0_10 递增为 3’b0_11，并且指向地址3，结果如图15.6所示。

图15.7 写满状态。

接着，数据 4’hD 写入地址3，然后写指针从原来的 3’b0_11 递增为 3’b1_00，并且重新指向地址0。此刻写指针的最高位为1，这表示写指针已经绕弯ram一圈又回来原点，反之读指针从刚才开始一动也不动，结果最高为0 ... 所以我们可以说写指针与读指针目前处于不同的方向。在此ram已经写满，所以写满状态便“叮咚”亮红灯，结果如图15.6所示。写满状态的逻辑关系则可以这样表示：

FULL = （WP[2] ^ RP[2] && WP[1:0] == RP[1:0]）；

图15.8 读出中①。

从现在开始，另一头火车才开始走动 ... 首先数据4’hA从地址0读出来，读指针也从原本的 3’b0_00 递增为 3’b0_01，并且指向地址1。此刻ram再也不是吃饱饱的状态，所以写满状态被消除红灯，结果如图15.8所示。

图15.9 读出中②。

接下来，数据4’hB 从地址1哪里读出，读指针也从原本的 3’b0_01 递增为 3’b0_10，并且指向地址2，结果如图15.9所示。

图15.10 读出中③。

随之，数据4’hC 从地址2哪里读出，读指针也从原本的 3’b0_10 递增为 3’b0_11，并且指向地址3，结果如图15.10所示。

图15.11读空状态。

最后，数据4’hD 从地址3哪里读出，读指针也从原本的 3’b0_11 递增为 3’b1_00，并且重新指向地址0。当读指针绕弯一圈又回到原点的时候，读者的最高位也成为值1，换句话说 ... 此刻的读指针与写指针也处于同样的位置。同一个时候，ram也是空空如也，所以读空状态便“叮咚”亮起红灯，结果如图15.11所示。为此，读空状态的逻辑关系可以这样表示：

Empty = (WP == RP);

总结而言，当我们设置N位位宽的时候，读写指针的位宽便是 N + 1。此外，读空状态为写指针等价读指针。反之，写满状态是两个指针方向一致（异或状态），然后地址一致。理解先进先出的机制以后，接下来我们便可以填充一下FIFO储存模块的内容。

1. module fifo_savemod

2. (

3. input CLOCK, RESET, 

4. input [1:0]iEn,

5. input [3:0]iData,

6. output [3:0]oData,

7. output [1:0]oTag

8. );

9. reg [3:0] RAM [3:0]; 

10. reg [3:0]D1;

11. reg [2:0]C1,C2; // N+1

12.

13. always @ ( posedge CLOCK or negedge RESET )

14. if( !RESET )

15. begin

16. C1 <= 3'd0;

17. end

18. else if( iEn[1] ) 

19. begin

20. RAM[ C1[1:0] ] <= iData; 

21. C1 <= C1 + 1'b1; 

22. end

23.

24. always @ ( posedge CLOCK or negedge RESET )

25. if( !RESET )

26. begin

27. D1 <= 4'd0;

28. C2 <= 3'd0;

29. end

30. else if( iEn[0] )

31. begin 

32. D1 <= RAM[ C2[1:0] ]; 

33. C2 <= C2 + 1'b1; 

34. end

35.

36. assign oData = D1;

37. assign oTag[1] = ( C1[2]^C2[2] & C1[1:0] == C2[1:0] ); // Full

38. assign oTag[0] = ( C1 == C2 ); // Empty

39.

40. endmodule

代码15.2

笔者在第9~11行创建相关的寄存器，C1取代WP，C2取代RP。第13~22行是写操作，内容非常单纯，即 iEn[1] 拉高便将 iData 写入 C1[1:0] 指定的地方，然后C1递增。

第24~34行是读操作，内容也是一样单纯，iEn[0] 拉高便将 C2[1:0] 指定的数据暂存至 D1，随后C2递增，最后由D驱动oData。第37~38行是写满状态与读空状态的逻辑关系。

图15.12 调用FIFO储存模块。

创建同步FIFO基本上没有什么难度，但是调用FIFO倒是一件难题。如图15.12所示，笔者建立一支核心操作尝试调用 FIFO储存模块，至于核心操作的内容如代码15.3所示：

1. case( i ) // Core

2. 0:

3. if( iTag[1]! ) begin oEn[1] <= 1’b1; oData <= 4’hA; i <= i + 1’b1; end

4. 1:

5. if( iTag[1]! ) begin oEn[1] <= 1’b1; oData <= 4’hB; i <= i + 1’b1; end

6. 2:

7. if( iTag[1]! ) begin oEn[1] <= 1’b1; oData <= 4’hC; i <= i + 1’b1; end

8. 3:

9. if( iTag[1]! ) begin oEn[1] <= 1’b1; oData <= 4’hD; i <= i + 1’b1; end

10. 4:

11. begin oEn[1] <= 1’b0; i <= i + 1’b1; end

12. 5:

13. if( iTag[0]! ) begin oEn[0] <= 1’b1; i <= i + 1’b1; end

14. 6:

15. if( iTag[0]! ) begin oEn[0] <= 1’b1; i <= i + 1’b1; end

16. 7:

17. if( iTag[0]! ) begin oEn[0] <= 1’b1; i <= i + 1’b1; end

18. 8:

19. if( iTag[0]! ) begin oEn[0] <= 1’b1; i <= i + 1’b1; end

20. 9:

21. begin oEn[0] <= 1’b0; i <= i + 1’b1; end

22. endcase

代码15.3

如代码15.3所示，步骤0~3用来一边检测 Tag[1] 是否为高，一边向储存模块写入数据 4’hA~4‘hD，步骤4则用来拉低 oEn[1] 并且歇息一下。步骤5~8用来一边检测 Tag[0] 是否为高，一边从储存模块哪里读出数据，步骤9则用来拉低 oEn[0]并且偷懒一下。

图15.13 读写FIFO储存模块的理想时序图。

图15.13是代码15.3所生产的理想时序图，同时也是核心操作作为视角的时序，至于C1~C2是FIFO储存模块作为视角的时序。各个视角的时序过程如下：

核心操作视角：

l T0，isTag[1]为低（即时值），拉高oEn[1]（未来值），并且发送数据 4’hA（未来值）。

l T1，isTag[1]为低（即时值），拉高oEn[1]（未来值），并且发送数据 4’hB（未来值）。

l T2，isTag[1]为低（即时值），拉高oEn[1]（未来值），并且发送数据 4’hC（未来值）。

l T3，isTag[1]为低（即时值），拉高oEn[1]（未来值），并且发送数据 4’hD（未来值）。

l T4，isTag[1]为高（即时值），拉低oEn[1]（未来值）。

l T5，isTag[0]为低（即时值），拉高oEn[1]（未来值）。

l T6，isTag[0]为低（即时值），拉高oEn[1]（未来值），数据4’hA读出（过去值）。

l T7，isTag[0]为低（即时值），拉高oEn[1]（未来值），数据4’hB读出（过去值）。

l T8，isTag[0]为低（即时值），拉高oEn[1]（未来值），数据4’hC读出（过去值）。

l T9，isTag[0]为高（即时值），拉低oEn[1]（未来值），数据4’hD读出（过去值）。

l T10，isTag[0]为高（即时值）。

FIFO储存模块视角：

l T0，oEn[1]为低（过去值）。C1等价C2为读空状态，iTag[0]拉高（即时值）。

l T1，oEn[1]为高（过去值），读取数据4’hA（过去值），递增C1。C1不等价C2，iTag[0]拉低（即时值）。

l T2，oEn[1]为高（过去值），读取数据4’hB（过去值），递增C1。

l T3，oEn[1]为高（过去值），读取数据4’hC（过去值），递增C1。

l T4，oEn[1]为高（过去值），读取数据4’hA（过去值），递增C1。C1等价C2为写满状态，iTag[1]拉高（即时值）。

l T5，oEn[1]为低（过去值）。

l T6，oEn[0]为高（过去值），读出数据4’hA（未来值），递增C2。C1不等价C2，isTag[1]拉低（即时值）。

l T7，oEn[0]为高（过去值），读出数据4’hB（未来值），递增C2。

l T8，oEn[0]为高（过去值），读出数据4’hC（未来值），递增C2。

l T9，oEn[0]为高（过去值），读出数据4’hD（未来值），递增C2。C1等价C2为读空状态，isTag[0]拉高（即时值）。

l T10，oEn[0]为低（过去值）。

读者是不是一边浏览一边捏蛋蛋呢？什么过去值，又什么未来值，又又什么即时值的 ... 没错，同步FIFO的设计原理虽然简单，但是时序解读却让人泪流满面。因为同步FIFO夹杂两种时序表现——时间点事件还有即时事件。如图15.13 所示，除了 iTag 信号是触发即时事件以外，所有信号都是触发时间点事件。读过《时序篇》或者《工具篇II》的朋友一定知晓，即时值不仅比过去值优先，而且即时值也会无视时钟。

好奇的同学可能困惑道：“为什么iTag不能设计成为时间点事件呢？”。笔者曾在《时序篇》建立基于移位寄存器的FIFO，其中iTag就是设计成为时间点事件，结果FIFO的写满状态或者读空状态都来不及反馈，因此发生调用上的混乱。

图15.14 读写FIFO储存模块的即时事件。

为了理解重点，首先让我们来焦距写数据的部分。如图15.14所示，关键的地方就是发生在T4——这只时钟沿。T4之际，FIFO储存模块读取oEn[1]的过去值，C1也因此递增，即时事件就在这个瞬间发生了。写满状态成立，iTag[1]也随之拉高即时值。从时序上来看，C1的更新（C1为4’b100）是发生在T4之后，不过那也无关紧要，因为即时值是更新在小小的时间沿之间，也是即时层 ... 然而，即时层是无法显示在时序之上。

图15.15 迟到的写满状态。

假设，iTag[1]不是经由即时事件触发而是事件点事件，那么iTag就会反馈迟到的写满状态。如图15.15所示，T4之际 oEn[1] 为高，C1也因此递增为 3’b100。T5之际，C1与C2的过去值均为 3’b100 与 3’b000，然后拉高 iTag[1]。由于时间点事件的关系，所以iTag[1]迟一拍被拉高 ... 读者千万别小看这样慢来一拍，它是搞乱调用的罪魁祸首。

如果核心操作在T5继续写操作的话，此刻iTag[1]的过去值为0，它会认为FIFO未满，然后不管三七二十一执行写操作，结果FIFO发生错乱随之机能崩溃。从某种程度来看，即时事件的偷时钟能力，是建立同步FIFO的关键。

fifo_savemod.v

图15.16 fifo储存模块的建模图。

图15.16基本上与图15.2没什么两样，不过FIFO储存模块的位宽还有深度发生改变而已。此外，图15.16的信号布局虽然有点违规低，不过这点小细节读者就不要太计较了。建模技巧毕竟不是暴力规范，用不着死守，反之随机应变才是本意。

1. module fifo_savemod

2. (

3. input CLOCK, RESET, 

4. input [1:0]iEn,

5. input [7:0]iData,

6. output [7:0]oData,

7. output [1:0]oTag

8. );

以上内容是相关的出入端声明。

9. reg [7:0] RAM [15:0]; 

10. reg [7:0]D1;

11. reg [4:0]C1,C2; // N+1

12.

以上内容是相关的内存与寄存器声明。第9行，RAM声明为8位宽还有24=16个深度。为此，第11行的写指针C1与读指针C2声明为5个位宽。

13. always @ ( posedge CLOCK or negedge RESET )

14. if( !RESET )

15. begin

16. C1 <= 5'd0;

17. end

18. else if( iEn[1] ) 

19. begin

20. RAM[ C1[3:0] ] <= iData; 

21. C1 <= C1 + 1'b1; 

22. end

23.

以上内容是fifo的写操作，第18行的 iEn[1] 每拉高一个时钟， 第20行的iData 便写入C1[3:0]指定的位置，随后第21行写指针也递增。

24. always @ ( posedge CLOCK or negedge RESET )

25. if( !RESET )

26. begin

27. D1 <= 8'd0;

28. C2 <= 5'd0;

29. end

30. else if( iEn[0] )

31. begin 

32. D1 <= RAM[ C2[3:0] ]; 

33. C2 <= C2 + 1'b1; 

34. end

35.

以上内容是fifo的读操作，第30行的 iEn[0] 每拉高一个时钟， 第32行的D1便赋予C2[3:0]指定的数据，随后第33行的读指针也递增。

36. assign oData = D1;

37. assign oTag[1] = ( C1[4]^C2[4] & C1[3:0] == C2[3:0] ); // Full

38. assign oTag[0] = ( C1 == C2 ); // Empty

39.

40. endmodule

以上内容是相关输出驱动声明，其中第37行是写满状态，第38行是读空状态。在此，读者需要注意一下 ... 第36行相较第37~38行 ，前者由寄存器D1驱动，即oData信号为时间点事件。反之，后者由组合逻辑驱动，即 oTag[1:0] 信号为即时事件。为此，该储存模块的内部状态是以即时的方式反馈出去。

tx_rx_demo.v

图15.17 实验十五的建模图。

实验十五是实验十三的延续 ... 实验十三之际，RX功能模块接收并且失败发送一连串的数据，因为发送方不仅来不及，而且接收成功的数据也没有地方缓冲。如今实验十五多了一只FIFO储存模块作为缓冲空间。注意，图15.17虽然是实验十五的建模图，可是却与实际的连线部署有一点出入，不过大意上都是差不多的。

RX功能模块接收一连串的数据，然后经由周边操作协调，事后再将数据缓冲至FIFO储存模块。至于核心操作会不停从FIFO储存模块哪里读取数据，然后再调用TX功能模块将数据发送出去。

1. module tx_rx_demo

2. (

3. input CLOCK, RESET, 

4. input RXD,

5. output TXD

6. ); 

以上内容是相关的出入端声明。

7. wire DoneU1;

8. wire [7:0]DataU1;

9.

10. rx_funcmod U1

11. (

12. .CLOCK( CLOCK ),

13. .RESET( RESET ),

14. .RXD( RXD ), // < top

15. .iCall( isRX ), // < sub

16. .oDone( DoneU1 ), // > U2

17. .oData( DataU1 ) // > U2

18. );

19.

以上内容是RX功能模块的实例化。第15行表示 isRX 充当使能。

20. reg isRX;

21.

22. always @ ( posedge CLOCK or negedge RESET ) // sub

23. if( !RESET ) isRX <= 1'b0;

24. else if( DoneU1 ) isRX <= 1'b0; 

25. else isRX <= 1'b1; 

26.

以上内容是周边操作，它主要重复调用RX功能模块。

27. wire [1:0]TagU2;

28. wire [7:0]DataU2;

29.

30. fifo_savemod U2

31. (

32. .CLOCK( CLOCK ),

33. .RESET( RESET ),

34. .iEn ( { DoneU1 , isRead } ), // < U1 & Core

35. .iData ( DataU1 ), // < U1

36. .oData ( DataU2 ), // > U3

37. .oTag ( TagU2 ) // > core

38. );

39.

以上内容是FIFO储存模块的实例化。第34行表示，DoneU1充当写入使能，isRead充当读出使能。

40. wire DoneU3;

41.

42. tx_funcmod U3

43. (

44. .CLOCK( CLOCK ), 

45. .RESET( RESET ),

46. .TXD( TXD ), // > top

47. .iCall( isTX ), // < core

48. .oDone( DoneU3 ), // > core

49. .iData( DataU2 ) // < U2

50. );

51.

以上内容是TX功能模块的实例化。第47行表示 isTX充当使能。第49行表示，该模块的iData直接经由DataU2驱动。

52. reg [3:0]i;

53. reg isRead;

54. reg isTX;

55.

56. always @ ( posedge CLOCK or negedge RESET ) // core

57. if( !RESET )

58. begin 

59. i <= 4'd0;

60. isRead <= 1'b0;

61. isTX<= 1'b0;

62. end

以上内容是核心操作的相关寄存器声明与复位操作。

63. else

64. case( i )

65.

66. 0:

67. if( !TagU2[0] ) begin isRead <= 1'b1; i <= i + 1'b1; end

68.

69. 1:

70. begin isRead <= 1'b0; i <= i + 1'b1; end

71.

72. 2:

73. if( DoneU3 ) begin isTX <= 1'b0; i <= 4'd0; end

74. else isTX <= 1'b1;

75.

76. endcase

77.

78. endmodule

以上内容是操作操作。步骤0用来判断FIFO是否读空，否则就拉高isRead。步骤1则拉低isRead，然后FIFO就会读出数据。步骤2则使能TX功能模块，并且将方才读出的数据发送出去。

编译完毕并下载程序。此刻，串口便可以支持一连串的数据发送与接收，为了避免部分数据凭空消失的怪事，数据流的容量必须配合FIFO的缓冲容量（深度）。此外，实验十五还有许多优化的空间，然而这些都是交由读者的功课。(注意，某些串口调试助手必须把检验位设置为标志位才能显示字符)

细节一：完整的个体模块

该实验的 fifo_savemod.v 已经是完整的个体。