【黑金原创课程】【FPGA那些事儿-驱动篇I 】实验十四：储存模块

实验十四比起动手笔者更加注重原理，因为实验十四要讨论的东西，不是其它而是低级建模II之一的模块类，即储存模块。接触顺序语言之际，“储存”不禁让人联想到变量或者数组，结果它们好比数据的暂存空间。

1.    int main()
2.    {
3.        int VarA;
4.        char VarB;
5.        VarA = 20;
6.        VarB = 5;
7.    }

代码14.1

如代码14.1所示，主函数内一共声明两个变量VarA与VarB（第3~4行）。VarA是两个字节的整型变量，VarB是一个字节的字符变量，然后VarA赋值20（第5行），VarB则赋值5（第6行）。，其中 int 与 char 等字眼用来表示字节，即暂存空间的位宽，然后储存的内容仅局限于二进制，非0即1。

1.    int main()
2.    {
3.        int VarC[20];
4.        VarC[0] = 30;
5.        for( int i = 0; i < 20; i++ ) VarC[i] = i;
6.        VarC[0] = VarC[1];
7.    }

代码14.2

除了变量以外，顺序语言也有数组这个玩意，亦即一连串的变量。如代码14.2所示，主函数内声明数组VarC，数组的成员位宽是两个字节的int，数组的成员长度则是20（第3行）。然而数组常见的赋值方法除了成员直接赋值以外（第4行），也有使用for循环为逐个成员赋值的方法（第5行）。此外，还有某个数组成员为某个数组成员直接赋值的方法（第6行）。目前为止，顺序语言还有储存之间的故事就圆满结束。

人是一种自虐的生物，事情越是顺利，越是容易萌起疑心 ... 然后暗道：“储存是不是太容易理解呢？容易到让人觉得恶心！“。没错，事实的确如此。“储存”一旦投入描述语言之中，话题便会严肃起来。顺序语言是一件懒人多得的语言，它有许多底层工作都交由编译器处理，相较之下描述语言是一件多劳多得的语言，许多底层工作都必须交由我们自己声明与定义。

1.    reg [3:0]D1 = 4’d1;
2.    reg [3:0]D2 ;
3.    reg [3:0]D3;
4.    
5.    initial begin D2 = 4’d2; end
6.    
7.    always @ ( posedge CLOCK or negedge RESET )
8.        if( !RESET )
9.            D3 <= 4’d3;
10.        ......

代码14.3

首先让我们来理解一下初始化与复位化之间的区别。我们知道顺序语言的变量只有初始化，没有复位化这一回事 ... 反之，描述语言却不同。如代码14.3所示，笔者在第1~3行声明D1~D3三个寄存器，其中D1声明不久便立即赋予初值 4’d1。换之，D2则在第5行赋予初值 4’d2，最后D3则在第8~9行赋予复位值4’d3。

所谓初值就是初始化所给予的起始内容，反之复位值就是复位触发所给予的内容。初始化一般都是编译器的赋值活动，第1行的D1还有第5行的D2都是经由编译器的活动给予初值。反观之下，复位化不是编译器活动而是硬件活动，也是俗称的RESET，即电平变化所引起的复位触发。

如代码行第7~9所示，敏感区种含有 negedge RESET的字眼表示，如果RESET的电平由高变低并且产生下降沿触发，结果就执行一下 always 的内容。其中的内容便是复位操作，最终 D3 赋予复位值 4’d3。

图14.1 初始化与复位化的时序图。

如果用时序来表示的话 ... 如图14.1所示，灰色区域表示初始化状态又或者未上电状态

，当中D1与D2都赋予初值4’d1与4’d2，同样D3也给予初值 4’d0。虽然D3在代码14.3之间并没有任何初始化的痕迹，不过默认下编译器都会一视同仁，将所有暂存声明都给予初值0，除非有特别声明，例如第1行的D1与第5行的D2。上电以后，RESET电平又高变低便产生下降沿，结果复位发生了，然后D3被赋予复位值4’d3。

我们知道容器有大有小，所以储存空间也有大小之分，然而决定空间大小就是位宽这种东西。位宽一般是指数据的长度，顺序语言会用 int 或者 char 等关键字表示位宽，反之描述语言会直接声明位宽的大小，如 reg[3:0]D1。在此，顺序语言的位宽区别都是一个字节一个字节比较，反之描述语言比较随意。

1.    reg [3:0]D1;  // Verilog
2.    reg var [3:0]D2;    // Sytem Verilog
3.    logic var [3:0]D3;  // System Verilog

代码14.4

除了位宽以外，我们还要理解什么是储存内容。描述语言相较顺序语言，储存内容的花样较多一些 ... 顺序语言由于比较比较偏向软件，所以储存内容仅有两态，即1与0而已。反之描述语言是介于硬件与软件之间，所以储存内容除了0与1两态之外，也有高阻态z与切开x。

如代码14.4所示，当我们声明D1的时候，除了需要强调位宽以外，我们还要强调储存内容 ... 以Verilog为例的话，关键字 reg 的用意并非强调储存资源是基于寄存器，而是表示储存内容有0有1，还有z与x等四个状态。相反的，SystemVerilog在这方面却做得很好，如代码行2~3所示，var 关键字表示对象是储存空间，reg 关键字表示对象的储存内容有4态，logic关键字则表示对象的储存内容有2态。

1.    char VarA;      // 变量（内存）
2.    char VarB[4]    // 数组（内存）
3.    reg [7:0] D1;   // 寄存器
4.    reg [31:0] D2;  // 寄存器

代码14.5

我们知道顺序语言有所谓的变量与数组，储存资源一般都是基于内存，例如第1行的VarA与第2行的VarB。反之，描述语言不仅可以用寄存器资源建立变量，寄存器资源也能建立数组，例如与第3行的D1与第4行的D2。（虽然顺序语言偶尔也会用到寄存器型的储存资源，不过该储存资源对处理器来说太珍贵了，如果不是特殊条件，一般都不会随意使用）

1. reg [3:0] RAM [15:0]; // 片上内存

代码14.6

此外，描述语言还有另外一种叫做片上内存的储存资源，声明方法如代码14.6所示。FPGA的片上内存与单片机的内存虽然都是内存，但是两者之间却是不同性质的内存。简单而言，单片机的内存是经过烧烤的熟肉，随时可以享用 ... 反之，FPGA的片上内存则是未经过烧烤的生肉，享用之前必须做好事先准备。为此，FPGA的片上内存无法像级单片机内存那样，随便赋值，随意调用。

1. int main()

2. {

3. char VarC[4];

4. for( int i = 0; i < 3; i++ ) VarC[i] = VarC[i+1]

5. }

代码14.7

如代码14.7所示，笔者先建立一个 char 类型的数组 VarC长度并且为4，紧接着利用for循环为数组的整组成员赋值，其中VarC[i] 的赋予内容是 VarC[i+1] 的结果。代码

14.7算是顺序语言常见的例子，期间初始化也好，还是利用for循环为数组赋值也好，许多底层的工作都交由编译器去作，我们只要翘脚把代码照顾好就行。

1. reg [7:0] RAM [3:0]

2. reg [3:0]i;

3.

4. always @ ( posedge CLOCK ) // 错误

5. for( i = 0; i < 3; i = i + 1 ) RAM[i] = RAM[i+1];

代码14.8

换做描述语言，如代码14.8所示 ... 笔者在第1~2行当中先声明位宽为8长度为4的RAM，随之又声明i。假设RAM要实现代码14.7同样的赋值操作，首先最常见的错误就是第4~5行的例子 ... 许多人会直接将关键字for套用在 always 块里，这种赋值操作有两种问题：

其一，编译器并不清楚我们到底要利用空间实现for，还是利用时钟实现for。默认下，编译器会选择前者，后果就是吃光逻辑资源。

其二，RAM[i] = RAM[i+1] 这种赋值操作会搞砸综合，结果片上内存的布线状况会变得非常复杂，从而导致综合失败。

代码14.8算是新手最容易犯下的问题之一，代码14.8虽然没有语法上的错误，而且仿真也会通过，但是综合却万万不可。为此，代码14.8需要更动一下。

1. reg [7:0] RAM [3:0]

2. reg [3:0]i;

3.

4. always @ ( posedge CLOCK ) // 错误

5. case( i )

6. 0,1,2:

7. begin RAM[i] <= RAM[i+1]; i <= i + 1’b1; end

8. endcase

代码14.9

如代码14.9所示，笔者舍弃关键字 for，取而代之却利用仿顺序操作充当循环，这是一种利用时钟实现for的方法 (伪循环)。不过代码14.9依然不被综合器接受，结果报错 ... 因为片上内存并不支持类似 RAM[i] <= RAM[i+1] 的赋值方式，因为综合期间会导致布线复杂化，并且进一步搞砸综合。为此，代码14.9需要继续更动。

1. reg [7:0] RAM [3:0]

2. reg [3:0]i;

3. reg [7:0]D1;

4.

5. always @ （posedge CLOCK） // 正确

6. case( i )

7. 0,2,4:

8. begin D1 <= RAM[i<<1]; i <= i + 1’b1; end

9. 1,3,5:

10. begin RAM[ (i<<1)+1 ] <= D1; i <= i + 1’b1; end

11. endcase

代码14.10

如代码14.10所示，笔者多建立一个作为暂存作用的寄存器D1，然后利用两组步骤移动RAM之间的数据。步骤0，2与4将RAM[i] 的内容暂存至D1，步骤1，3与5则将D1的内容赋予 RAM[i+1]。如此一来，片上内存成员与成员之间的数据移动便大功告成。事实上代码14.7也干同样的事情，不过事实却被编译器隐藏了 ... 如果读者读者打开代码14.7的编译结果，读者会看见类似的汇编语言，结果如代码14.11所示：

T0 Load RAM[1] => R0;

T1 Load R0 => RAM[0];

T2 Load RAM[2] => R0;

T3 Load R0 => RAM[1];

T4 Load RAM[3] => R0;

T5 Load R0 => RAM[2];

代码14.11

如代码14.11所示，汇编内容会重复使用 Load 指令将某个RAM的内容先暂存至通用寄存器R0，然后又从R0移至另某个RAM当中。至于代码14.11的正确性，笔者不能确保什么，毕竟距离上一次接触汇编语言已经是N年前的事情。不过感觉上差不多就是那样 ... 这就是被编译器所隐藏的底层工作之一，代码14.10不过是将其模仿而已。

讲到这里，我们开始接触重点了。上述的例子告诉我们，编译器不会帮忙描述语言处理底层操作。所以，变量与数组之间的储存操作不及顺序语言那么便捷，而且模仿起来也非常麻烦 ... 不过，我们也不用那么灰心，良驹有良驹的跑法，歪驹有歪驹的走法，我们只要换个角度去面对情况，不视问题，问题自然迎刃而解。

根据笔者的妄想，储存有“储存资源“ 还有“储存方式”之分。描述语言可用的储存资源有寄存器还有片上内存，然而变量与数组也是最简单也是最基础的“储存方式”。基于这些 ... 事实上，描述语言可以描述各种各样的“储存方式”。

1. module rom( input [1:0]iAddr, output [7:0]oData );

2. reg [7:0]D1;

3. always @ (*) 

4. if( iAddr == 2’b00 ) D1 = 8’hA;

5. else if( iAddr == 2’b01 ) D1 = 8’hB;

6. else if( iAddr == 2’b10 ) D1 = 8’hC;

7. else if( iAddr == 2’b11 ) D1 = 8’hD;

8. else D1 = 8’dx;

9.

10. assign oData = D1;

11.

12. endmodule

代码14.12

例如一个简单的静态ROM模块，它可以基于寄存器或者片上内存，结果如代码14.12与14.13所示。代码14.12是基于寄存器的静态ROM，它有2位iAddr与8位的oData

，其中第3~8行是ROM的内容定义，第10行则是输出驱动，为此oData会根据iAddr的输入产生不同的输出。

1. module rom( input [1:0]iAddr, output [7:0]oData );

2. reg [7:0] RAM [3:0];

3. initial begin

4. RAM[0] = 8’hA;

5. RAM[1] = 8’hB;

6. RAM[2] = 8’hC;

7. RAM[3] = 8’hD;

8. end

9.

10. assign oData = RAM[ iAddr ];

11.

12. endmodule

代码14.13

反之，代码14.13是基于片上内存的静态ROM，它也有2位iAddr与8位oData，第3~7行是内容的定义也是初始化片上内存，第10行则是输出驱动，oData会根据iAddr的输出产生不同的输出。

代码14.12与代码14.13虽然都是静态ROM，不过却有根本性的不同，因为两者源于不同的储存资源，其中最大的证据就是第10行的输出驱动，前者由寄存器驱动，后者则由片上内存驱动。不同的储存资源也有不同的性质，例如寄存器操作简单，而且布线有余，不过不支持大容量的储存行为。换之，片上内存虽然操作麻烦，布线也紧凑，可是却支持大容量的储存行为。

储存方式相较储存资源理解起来稍微抽象一点，而且想象范围也非常广大 ... 如果储存资源是“容器的种类”，那么储存方式就是“容器的用法”。举例而言，一个简单静态ROM，根据需要它还可以演变成为其它亚种，例如常见的单口ROM或者双口ROM或等。

1. module rom( input CLOCK，input [1:0]iAddr, output [7:0]oData );

2. reg [7:0] RAM [3:0];

3. initial begin

4. RAM[0] = 8’hA;

5. RAM[1] = 8’hB;

6. RAM[2] = 8’hC;

7. RAM[3] = 8’hD;

8. end

9.

10. reg [1:0] D1;

11. always @ （ posedge CLOCK）

12. D1 <= iAddr;

13.

14. assign oData = RAM[ D1 ];

15.

16. endmodule

代码14.14

如代码14.14所示，那是单口ROM的典型例子，然而单口ROM与静态ROM之间的差别就在于前者有时钟信号，后者没有时钟信号。期间，代码14.14用D1暂存iAddr，然后再由D1充当RAM的寻址工具。

1. module rom( input CLOCK，input [1:0]iAddr1, iAddr2，output [7:0]oData1，oData2 );

2. reg [7:0] RAM [3:0];

3. initial begin

4. RAM[0] = 8’hA;

5. RAM[1] = 8’hB;

6. RAM[2] = 8’hC;

7. RAM[3] = 8’hD;

8. end

9.

10. reg [1:0] D1;

11. always @ （ posedge CLOCK）

12. D1 <= iAddr1;

13.

14. assign oData1 = RAM[ D1 ];

15.

16. reg [1:0] D2;

17. always @ （ posedge CLOCK）

18. D2 <= iAddr2;

19.

20. assign oData2 = RAM[ D2 ];

21.

22. endmodule

代码14.15

如代码14.15所示，那是双口ROM的典型例子，如果将其比较单口ROM，它则多了一组 iAddr与oData而已，即iAddr1与oData1，iAddr2与oData2。第10~14行是第一组（第一口），第16~20行则是第二组（第二口），不过两组 iAddr 与 oData 都从同样的RAM资源哪里读取结果。

事实上，ROM还会根据更多不同要求产生更多亚种，而且亚种的种类也绝非局限在于专业规范，因为亚种的储存模块会依照设计者的欲望——有多畸形就多畸形，死守传统只会固步自封而已。无论模块对象是静态ROM，单口ROM还是双口ROM等 ... 笔者眼中，它们都是任意的“储存方式”而已。

根据笔者的妄想，储存方式的覆盖范围非常之广。简单而言，凡是模块涉及数据的储存操作，低级建模II都视为储存类。举例而言，ROM模块储存自读不写的数据； RAM模块储存又读又写的数据；FIFO模块储存先写先读的数据。

为此，我们可以这样命名它们：

rom_savemod.v // rom储存模块

ram_savemod.v // ram储存模块

fifo_savemod.v // fifo储存模块

好奇的朋友一定会觉得疑惑，笔者究竟是为了定义储存类呢？事情说来话长，笔者也是经过多番考虑以后才狠下心肠去决定的。首先，让我们继续从顺序语言的角度去理解吧：

1. unsigned char Variable;

2. void FunctionA( unsinged char A ) { Variable = A； }

3. unsinged char FunctionB( void ) { return Variable； } 

4. int main()

5. {

6. unsigned char D1;

7. FunctionA( 0x0A ); 

8. D1 =FunctionB();

9. ......

10. }

代码14.16

假设有N个函数想共享数据，一般而言我们都会建立全局变量（数组）。如代码14.16所示，笔者先建立全局变量Variable，然后又声明函数A为Variable 赋值，反之函数B则返回Variable的内容。完后，再编辑主函数的操作 ... 期间，主函数先声明变量D，然后调用函数A，并且传递参数 0x0A，完后便调用函数B，并且将返回的内容赋予D。

函数之间之所以可以共享数据，那是因为编译器在后面大力帮忙，并且处理底层操作才得以实现。换之，描述语言虽然没有类似的好处，但是描述语言可以模仿。

1. reg [7:0]Variable;

2. reg [7:0]T,D1;

3. reg [3:0]i,Go;

4. always @ ( posedge CLOCk ) // 核心操作

5. case(i)

6. 0: // 主操作

7. begin T <= 8’h0A; i <= 4’d8; Go <= i + 1’b1; end

8. 1:

9. begin i <= 4’d9; Go <= i + 1’b1; end

10. 2:

11. begin D1 <= T; i <= i + 1’b1; end

12. ......

13. 8：// Fake Function A 伪函数A

14. begin Variable = T; i <= Go; end

15. 9: // Fake Function B 伪函数B

16. begin T = Variable; i <= Go; end

17. endcase

代码14.17

如代码14.17所示，笔者先建立Variable，然后又建立T与D，还有i与Go。Variable模仿全局变量，T则是伪函数的暂存空间（数据传递），i指向步骤，Go则是指向返回步骤。步骤0~2，我们可以视为主函数，步骤8~9则是伪函数A与伪函数B。

步骤0，i将指向伪函数A的入口，T赋予 8’h0A，Go则指向下一个步骤。

步骤8，Variable 赋予 T 的内容，然后返回步骤。

步骤1，i将指向伪函数B的入口，Go则指向下一个步骤。

步骤9，T赋予Varibale 的内容，然后返回步骤。

步骤2，D1赋予Varibale的内容，然后操作结束。

如果我们将代码14.16与代码14.17互相比较的话，它们存在几处区别甚微的地方。

其一，代码14.17的代码量比代码14.16还要多；

其二，代码14.16的Variable是真正意义上的全局变量，反之代码14.17则是山寨。

除此之外，代码14.17还是一只核心操作组成，或者代码14.17是有一只函数而已。

如果主函数，函数A还有函数B之间只有简单操作，而且数据的传递量也不多的话，那么仅有一只核心操作也没有什么问题。相反的，如果函数之间不仅有复杂的操作，而且数据的传递量也很多的话，独秀的核心操作就要举白旗投降了。为此，我们必须借助多模块的力量来解决复杂的操作，但是多模块之间又如何共享数据呢？首先，让我们换个思路思考问题。

1. unsigned char Variable; // 储存类

2. void FunctionA( unsinged char A ) { Variable = A； } // 功能类

3. unsinged char FunctionB( void ) { return Variable； } // 功能类 

4. int main() { ...... } // 控制类

代码14.18

如代码14.18所示，全局变量视为储存类，函数A与函数B视为功能类，至于主函数视为控制类。

图14.2 代码14.18的建模图。

代码14.18经过分类以后，大致的建模布局如图14.2所示。一只名为main的控制模块充当中介，次序调度，协调者等角色。其中，A功能模块与B功能模块负责最基本的操作，variable储存模块则负责储存操作。余下，所有模块都经由问答信号联系起来，至于Verilog则可以这样表示：

1. module ( ... );

2.

3. wire [2:0]CallU1；

4. main_ctrlmod U1

5. ( 

6. .oCall( CallU1 ),

7. .iDone( { DoneU1, DoneU2, DoneU3 } ),

8. ...

9. );

10.

11. wire DoneU2;

12. a_funcmod U2

13. ( 

14. .iCall( CallU1[0] ), 

15. .oDone( DoneU2 ),

16. ...

17. );

18.

19. wire DoneU3;

20. b_funcmod U3

21. ( 

22. .iCall( CallU1[1] ), 

23. .oDone( DoneU3 ),

24. ...

25. );

26.

27. wire DoneU4;

28. varibale_savemod U1

29. ( 

30. .iCall( CallU1[2] ), 

31. .oDone( DoneU4 ),

32. ...

33. );

34.

35. endmodule

代码14.18

如代码14.18所示，组合模块的内容包含，main控制模块为实例U1，a功能模块与b功能模块为实例U2~U3，variable储存模块为实例 U4。最后，各个模块经由问答信号 Call/Done 联系起来。

前面的例子告诉我们，描述语言在变量上的运用，远远不及顺序语言那么便捷，毕竟描述语言没有底层补助，而且模仿它人也超麻烦。话虽如此，这是描述语言的缺点也是优点 ... 优点？笔者有没有搞错？那么麻烦还称为优点，笔者是不是脑子进水了？这位同学别猴急，笔者会慢慢解释的。

1. unsigned char LUT[4] = { 10, 20, 30, 40 };

2. int main()

3. {

4. int D1;

5. D1 = LUT[1] + LUT[2];

6. ...

7. }

代码14.19

如代码14.19所示，第1行声明位宽为8，长度为4的LUT查表，第2~7行则是查表的运用。表面上，顺序语言虽有惊人的便捷性，不过底子里却是一片死残，尤其是时钟的利用率更是惨不忍睹。那些写过算法的同学一定知道，查表常常用来优化算法的运算速度 ... 简单来说，查表就是顺序语言“空间换速度”的优化手段。

查表既是ROM也是一种储存方式。如果把话说难听一点，所谓查表也不过是顺序语言在利用数组模仿ROM而已，它除了便捷性好以外，无论是资源的消耗，还是时钟的消耗等效率都远远不及描述语言的ROM。顺序语言偶尔虽然也有山寨的FIFO，Shift等储存方式，不过性能却是差强人意。

顺序语言之所以那么逊色，那是因为被钢铁一般坚固的顺序结构绑得死死。述语言是自由的语言，结构也是自由。虽然自由结构为人们带来许多麻烦，但是“储存方式”可以描述的范畴，绝对超乎人们的估量。归根究底，究竟是顺序语言好，还是描述语言模比较厉害呢？除了见仁见智以外，答案也只有天知晓。

随着时代不断变迁，“储存方式”的需求也逐渐成长，例如50年代需要rom，60年代需要ram，70年代需要 fifo。二十一世纪的今天，保守的规范再也无法压抑“储存方式”的放肆衍生，例如rom衍生出来静态rom，单口rom，双口rom等许多亚种；此外，fifo也衍生出同步fifo或者异步fifo等亚种。至于ram的亚种，比前两者更加恐怖！不管怎么样，大伙都是笔者的好孩子，亦即 ××_savemod。

虽然伟大的官方早已准备数之不尽的储存模块，但是笔者还是强调手动建模比较好，因为官方的东西有太多限制了。此刻，可能有人跳出来反驳道：“为什么不用官方插件模块，它们既完整又便捷，那个白痴才不吃天上掉下来的馅饼！笔者是呆子！蠢货！“。话说这位同学也别那么激动，如果读者一路索取它人的东西，学习只会本末倒置而已。

除此之外，官方插件模块是商业的产物，不仅自定义有限内容也是隐性，而且还是不择不扣的快餐。快餐即美味也方便，偶尔吃下还不错，但是长期食用就会危害健康，危害学习。

“fifo插件的数据位宽能不能设为11位？”，某人求救道。

“ram插件怎样调用？怎样仿真？”，某人求救道。

类似问题每月至少出现数十次，而且还是快餐爱好者提问的。笔者也有类似的经验，所以非常明白这种心境。年轻的笔者就是爱好快餐，凡事拿来主义，伸手比吃饭更多。渐渐地，笔者愈来愈懒，能不增反降，最终变成只会求救的肥仔而已。后悔以后，笔者才脚踏实地自力建模，慢慢减肥。

在此，笔者滔滔不绝只想告知读者 ... 自由结构虽然麻烦，不过这是将想象力具体化的关键因素，储存模块的潜能远超保守的规范。规范有时候就像一粒绊脚石，让人不经意跌倒一次又一次，阻碍人们前进，限制人们想象，最后让人成为不动手即不动脑的懒人。最后，让我们建立一只不规格又畸形的储存模块作为本实验的句号。

图14.3 实验十四的建模图。

图14.3是实验十四的建模图，组合模块 savemod_demo 的内容包括一支核心操作，一只数码管基础模块，还有一只名字帅到掉渣的储存模块。核心操作会拉高 oEn，并且将相关的 Addr 与 Data 写入储存模块，紧接着该储存模块会经由 oData驱动数码管基础模块。事不宜迟，让我们先来瞧瞧推挤位移储存模块这位帅哥。

pushshift_savemod.v

图14.4 推挤位移储存模块的建模图。

顾名思义，该模块是推挤功能再加上位移功能的储存模块，左边是储存模块常见的iEn，iAddr与iData，右边则是超乎常规的oData。

1. module pushshift_savemod

2. (

3. input CLOCK,RESET,

4. input iEn,

5. input [3:0]iAddr,

6. input [3:0]iData,

7. output [23:0]oData

8. );

第3~7行是相关的出入端声明。

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

10. reg [23:0] D1;

11.

12. always @ ( posedge CLOCK or negedge RESET )

13. if( !RESET )

14. begin

15. D1 <= 24'd0; 

16. end

第9行是片上内存RAM的声明，第10行则是寄存器D1的声明。第15行则是D1的复位操作。

17. else if( iEn )

18. begin

19. RAM[ iAddr ] <= iData;

20. D1[3:0] <= RAM[ iAddr ];

21. D1[7:4] <= D1[3:0];

22. D1[11:8] <= D1[7:4];

23. D1[15:12] <= D1[11:8];

24. D1[19:16] <= D1[15:12];

25. D1[23:20] <= D1[19:16];

26. end

27.

28. assign oData = D1;

29.

30. endmodule

第17行表示 iEn不拉高该模块就不工作。第18~26行是该模块的核心操作，第19行表示RAM将iData储存至 iAddr指定的位置；第20行表示，RAM将iAddr指定的内容赋予D1[3:0]。如此一来，第19行与第20行的结合就成为推挤功能。至于第21~25行则是6个深度的位移功能（即4位宽为一个深度）， iEn每拉高一个时钟，D1的内容就向左移动一个深度。

savemod_demo.v

该组合模块的连线部署根据图14.3，具体内容我们还是来看代码吧。

1. module savemod_demo

2. (

3. input CLOCK,RESET,

4. output [7:0]DIG,

5. output [5:0]SEL

6. );

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

7. reg [3:0]i;

8. reg [3:0]D1,D2; // D1 for Address, D2 for Data

9. reg isEn;

10.

11. always @ ( posedge CLOCK or negedge RESET ) // Core

12. if( !RESET )

13. begin

14. i <= 4'd0;

15. { D1,D2 } <= 8'd0;

16. isEn <= 1'b0;

17. end

18. else

以上内容是相关的寄存器声明以及复位操作。其中D1用来暂存地址数据，D2用来暂存读写数据。第12~17行是这些寄存器的复位操作。

19. case( i )

20.

21. 0:

22. begin isEn <= 1'b1; D1 <= 4'd0; D2 <= 4'hA; i <= i + 1'b1; end

23.

24. 1:

25. begin isEn <= 1'b1; D1 <= 4'd0; D2 <= 4'hB; i <= i + 1'b1; end

26.

27. 2:

28. begin isEn <= 1'b1; D1 <= 4'd0; D2 <= 4'hC; i <= i + 1'b1; end

29.

30. 3:

31. begin isEn <= 1'b1; D1 <= 4'd0; D2 <= 4'hD; i <= i + 1'b1; end

32.

33. 4:

34. begin isEn <= 1'b1; D1 <= 4'd0; D2 <= 4'hE; i <= i + 1'b1; end

35.

36. 5:

37. begin isEn <= 1'b1; D1 <= 4'd0; D2 <= 4'hF; i <= i + 1'b1; end

38.

39. 6:

40. begin isEn <= 1'b1; D1 <= 4'd0; D2 <= 4'h0; i <= i + 1'b1; end

41.

42. 7:

43. begin isEn <= 1'b0; i <= i; end

44.

45. endcase

46.

以上内容为核心操作，操作过程如下：

步骤0为地址0写入数据 4’hA;，将原本的数据挤出来，并且发生位移。

步骤1为地址0写入数据 4’hB;，将4’hA挤出来，并且发生位移。

步骤2为地址0写入数据 4’hC;，将4’hB挤出来，并且发生位移。

步骤3为地址0写入数据 4’hD;，将4’hC挤出来，并且发生位移。

步骤4为地址0写入数据 4’hE;，将4’hD挤出来，并且发生位移。

步骤5为地址0写入数据 4’hF，将4’hE挤出来，并且发生位移。

步骤6为地址0写入数据 4’d0，将4’hF挤出来，并且发生位移。

步骤7结束操作。

图14.5 savemod_demo 部分时序图。

图14.5是 savemod_demo 部分重要的理想时序图，其中isEn，D1与D2 是核心操作所发送的数据，至于RAM[0]与oData是推挤位移储存模块的内部状况与输出结果。时序过程如下：

T0，核心操作拉高isEn，发送4’d0地址数据与4’hA读写数据。

T1，核心操作拉高isEn，发送4’d0地址数据与4’hB读写数据。储存模块将4’hA载入地址0。

T2，核心操作拉高isEn，发送4’d0地址数据与4’hC读写数据。储存模块将4’hB载入地址0，并且将数据 4’hA挤出，oData的结果为 24’h00000A。

T3，核心操作拉高isEn，发送4’d0地址数据与4’hD读写数据。储存模块将4’hC载入地址0，并且将数据 4’hB挤出，同时发生位移，oData的结果为 24’h0000AB。

T4，核心操作拉高isEn，发送4’d0地址数据与4’hE读写数据。储存模块将4’hD载入地址0，并且将数据 4’hC挤出，同时发生位移，oData的结果为 24’h000ABC。

T5，核心操作拉高isEn，发送4’d0地址数据与4’hF读写数据。储存模块将4’hE载入地址0，并且将数据 4’hD挤出，同时发生位移，oData的结果为 24’h00ABCD。

T6，核心操作拉高isEn，发送4’d0地址数据与4’d0读写数据。储存模块将4’hF载入地址0，并且将数据 4’hE挤出，同时发生位移，oData的结果为 24’h0ABCDE。

T7，储存模块将4’d0载入地址0，并且将数据 4’hF挤出，同时发生位移，oData的结果为 24’hABCDEF。

47. wire [23:0]DataU1;

48.

49. pushshift_savemod U1

50. (

51. .CLOCK( CLOCK ),

52. .RESET( RESET ),

53. .iEn( isEn ), // < Core

54. .iAddr( D1 ), // < Core

55. .iData( D2 ), // < Core

56. .oData( DataU1 ) // > U2

57. );

58.

第47~58行是该储存模块的实例化。

59. smg_basemod U2

60. (

61. .CLOCK( CLOCK ),

62. .RESET( RESET ),

63. .DIG( DIG ), // top

64. .SEL( SEL ), // top

65. .iData( DataU1 ) // < U1

66. );

67.

68. endmodule

第59~66行是数码管基础模块的实例化。编译完毕便下载程序，如果数码管从左至右显示“ABCDEF”，那么表示实验成功。最后还是要强调一下，推挤位移目前是没有意义的储存模块，可是实验十四的目的也非常清楚，就是解释储存模块，演示畸形的储存模块。