Verilog HDL 建模技巧 ：低级建模 仿顺序操作 · 思路篇

kenson

4. 3 建立“产生效果”的 “低级功能模块”
/ R& W  @$ M, k! h9 \& h

首先，我们先回顾一下“低级建模”的准则。低级建模的准则如下：

+ N& K5 x7 O; |

1. 有“组织模块”和“功能模块”之分。

2. “低级建模”中的“功能模块”均称为“低级功能模块”。

3. “低级功能模块”有如特点：有开始信号，完成信号，一个模块只有一个工能

4. 多个“低级功能模块”组织起来称为“组织模块”。

2 R1 H: a! J& {3 n4 R& S

在上一章节，我们建立了两个“低级功能模块”，各个模块都有“开始信号”，“完成信号”，和“单一的功能”（准则2, 3），然后将两个“低级功能模块”组织了起来（准则1，4），

( S1 K0 a. G* V! T( F

“ 自左向右循环3次，自右向左循环5次，然后自左向右一次，自右向左一次，然后自左向右循环30次”

. O: B4 z% f# [# W5 [( D9 o. i: O

这一章节，我们要从上一章节的基础上，建立另一个“低级功能模块”，用来产生如上的效果。

然后再将它与之前已经组织好的模块，再一次组织起来。

9 N( F/ v) A6 \( x0 I3 i% \

概念图如下：

& H. Y1 \; J( ?# s, C3 Z

http://space.ednchina.com/upload/2010/6/5/008ce9c1-162b-4fee-9b78-4534e377b90e.jpg

“产生效果的模块”代码如下：

. f+ u* }/ u" l9 T1 z( c

1．module effect_module

2．(

3．    CLK, RSTn,

4．    Start_Sig, Done_Sig,

5．    Right_Start_Sig, Left_Start_Sig,

6．    Right_Done_Sig, Left_Done_Sig

7．);

8．

9．     input CLK;

10．    input RSTn;

11．    input Start_Sig;

12．    input Right_Done_Sig;

13．    input Left_Done_Sig;

14．
! S: Q0 w$ s( P9 d( |6 m$ n! r% u4 v

15．    output Done_Sig;

16．    output Right_Start_Sig;

17．    output Left_Start_Sig;

18．
9 q$ q, _4 s: x  a. c

19．
/*************************************/

20．

21．    reg [7:0]i;

22．    reg isDone;

23．    reg isLeft;

24．    reg isRight;

25．

26．    always @ ( posedge CLK or negedge RSTn )

27．        if( !RSTn )

28．            begin

29．                isDone <= 1'b0;

30．                i <= 8'd0;

31．                isRight <= 1'b0;

32．                isLeft <= 1'b0;

33．            end

34．        else if( Start_Sig )

35．            case ( i )

36．

37．                8'd0 :

38．                i <= i + 1'b1;

39．
! y' {- c- \$ k: g

40．                8'd1, 8'd2, 8'd3, 8'd9 :

41．                Flash_Right;

42．
# z! h* m: b; V( D

43．                8'd4, 8'd5, 8'd6, 8'd7, 8'd8, 8'd10 :

44．                Flash_Left;

45．
; u- X2 q% Q! B9 N

46．                8'd41, 8'd42 :

47．                Done;

48．
5 ?3 A  m/ |; ]0 w6 g3 z

49．                default :

50．                Flash_Right;

51．

52．            endcase

53．

54．
/***********************************/

55．

56．    task Flash_Right;

57．

58．        if( Right_Done_Sig )

59．            begin i <= i + 1'b1; isRight = 1'b0; end

60．        else isRight = 1'b1;

61．

62．    endtask

63．

64．
- `$ i4 v" ]8 O/ \* ?  e3 J /***********************************/

65．

66．   task Flash_Left;

67．

68．        if( Left_Done_Sig )

69．            begin i <= i + 1'b1; isLeft = 1'b0; end

70．        else isLeft = 1'b1;

71．

72．    endtask

73．
+ E1 ^/ I% L0 Q3 Y

74．
7 E7 O# [4 q% e /***********************************/

75．
: {- U+ Z8 f" X/ l( z- d+ K8 `" f

76．    task Done;

77．

78．        if( isDone == 1 )

79．            begin isDone <= 1'b0; i <= 8'b0; end

80．        else

81．            begin isDone <= 1'b1; i <= i + 1'b1; end

82．

83．    endtask

84．

85．
/***********************************/

86．

87．    assign Done_Sig = isDone;

88．    assign Right_Start_Sig = isRight;

89．    assign Left_Start_Sig = isLeft;

90．

91．endmodule

+ l' ?) [, Q9 R$ ?9 _" l9 R

这个effect_module由于使用模板的关系，多以编程格式与flashing_to_right/left 大同小异。但是核心功能部分就稍微复杂一些。

第23行和24行，声明用的寄存器“isRight”和“isLeft”分别对应flashing_to_right 和 flashing_to_left 的“Start_Sig”。

5 M1 }8 G! L) g& j. L- X7 _
/ d* _; s& t! W2 B$ J! b; S4 W. r

在40行，第1~3, 9 i步骤，执行“Flash_Right”任务。在56~62行，巧妙的利用“开始信号”和“完成信号”来执行“flashing_to_right”模块。正如下代码：

' i+ F& d" d: [) M

8 S. ?. v4 K# g! ^% {

       if( Right_Done_Sig )

           begin i <= i + 1'b1; isRight = 1'b0; end

        else isRight = 1'b1;

一开始 “isRight" 的初始值为0，所以会进入 else语句，然后“isRight”被设置为1。当“isRight"为1时，“Right_Start_Sig”被拉高（第88行），换一句话说就是“使能flashing_to_right ”模块。

在“flashing_to_right”模块执行完成之前（产生完成信号），i步骤不变。当检查到“完成信号”，i会指向下一个步骤，然后isRight设置为0（关闭flashing_to_right模块）。

即使是Flash_Left 任务，还是其他什么任务。只要涉及到“开始信号”和“完成信号”，都可以使用这样的写法，这是“低级功能模块”的编程好处。

2 w& I# d) a3 [: k! j+ o

在第30行至50行之间，这个功能模块产生的效果，如i指向的步骤那样，0时初始化，1~3,9时执行“flashing_to_right”功能，然后 4~8,10 时执行“flashing_to_left”功能等等......

最后会产生如下的效果：

“ 自左向右循环3次，自右向左循环5次，然后自左向右一次，自右向左一次，然后自左向右循环30次”

在最后两个步骤，产生完成信号。

        if( isDone == 1 )

            begin isDone <= 1'b0; i <= 8'b0; end

        else

            begin isDone <= 1'b1; i <= i + 1'b1; end

# Y6 Z7 B: M( r! X/ @* @: ^

就这样，一个符合“低级建模”准则的“低级功能模块”就完成了。这个模块只是“产生控制次序而已”，还不是完成品。在下一章，当将“effect_module”和“flashing_module”组织过后，就会成为完成品。
5 W- \! q) G7 A0 w; t% i

kenson

4. 4 : 再一次“组织”起来：

这一章，我们要讲 effect_module 和 flashing_module 组织起来，然后命名为“done”

代码如下：

/ @% u" ?8 M8 n0 O% p4 _' A3 L

1．module done

2．(

3．    CLK, RSTn,

4．    Start_Sig, Done_Sig,

5．    Q,

6．    Right_Done, Left_Done,  //用于观察

7．    Right_Start, Left_Start    //用于观察

8．);

9．
! _4 ^2 l4 O) H; |6 S, k

10．    input CLK;

11．    input RSTn;

12．    input Start_Sig;

13．    output Done_Sig;

14．    output Left_Done;

15．    output Right_Done;

16．    output Right_Start;

17．    output Left_Start;

18．    output [7:0]Q;

19．
4 J) n* l& |* i

20．
% Y9 w8 S  a7 w) W- U4 ?6 K/*******************************/

21．
$ F7 x5 }5 M/ V. v! H4 q

22．    wire Right_Start_Sig;

23．    wire Left_Start_Sig;

24．    wire Right_Done_Sig;

25．    wire Left_Done_Sig;

26．

27．    effect_module U3

28．    (

29．        .CLK( CLK ),

30．        .RSTn( RSTn ),

31．        .Start_Sig( Start_Sig ),
- C2 Q1 g( `: a* _; }) G



; }- _6 R4 }$ \" l( m6 S# B: B // in from top

32．        .Done_Sig( Done_Sig ),   

9 V! |/ ^/ V1 S
% |" w6 k' E! p$ c' d9 k3 v
/ R# V) I9 d% {  ~& V4 m // out to top

33．        .Right_Start_Sig( Right_Start_Sig ),
; O* M; m+ Z! A
5 |7 v6 R; A/ _( F" f // out to U2

34．        .Left_Start_Sig( Left_Start_Sig ),  
) _8 h/ i5 `# Q2 s. f

// out to U2

35．        .Right_Done_Sig( Right_Done_Sig ),  
// in from U2

36．        .Left_Done_Sig( Left_Done_Sig )     
( t: q5 A  b- u5 F4 O% a) e // in from U2

37．    );

38．

39．
% G# J( w+ H% m6 M* [/*************************************/

40．
8 ~6 C; y) k( N8 X. D9 a

41．    flashing_module U4

42．    (

43．        .CLK( CLK ),

44．        .RSTn( RSTn ),

45．        .Right_Start_Sig( Right_Start_Sig ),     // in from U1

46．        .Left_Start_Sig( Left_Start_Sig ),      
// in from U1

47．        .Right_Done_Sig( Right_Done_Sig ),   
2 c& G  F: r7 N$ {/ G# I' ?// out to U1

48．        .Left_Done_Sig( Left_Done_Sig ),   
* ~8 V) \1 M  u2 {
1 }: E) G+ Q! r1 {: ^* r$ V// out to U1

49．        .Q( Q )                            // out to top

50．    );

51．
- y9 V! s; h$ c

52．    /*************************************/

53．
7 d- Z6 _( N" O+ u' E- z  t

54．
//用于观察

55．    assign Left_Done = Left_Done_Sig;

56．    assign Right_Done = Right_Done_Sig;

57．    assign Right_Start = Right_Start_Sig;  

58．    assign Left_Start = Left_Start_Sig;

59．

60．endmodule

5 R/ `6 I4 Z* a! v, Q; h  }

这是第二层的组织了，到这里基本上我们已经完成如下图的效果

1． `timescale 1 ns/ 1 ns

2． module done_vlg_tst();

3． reg CLK;

4． reg RSTn;

5． reg Start_Sig;

6．
  O3 T$ S, x: g. H

7． wire Done_Sig;

8． wire [7:0]  Q;

9． wire Left_Done;

10．wire Right_Done;

11．wire Right_Start;

12．wire Left_Start;

13．done i1

14．(

15．
* `1 x. d, i/ Y( c  g5 e- B.CLK(CLK),

16．
' D0 ]* A( M6 [2 T  f.Done_Sig(Done_Sig),

17．
" J( v( B$ s2 o* Y% h.Q(Q),

18．
( g2 e/ b2 \( {' K.RSTn(RSTn),

19．
.Start_Sig(Start_Sig),

20．
.Left_Done( Left_Done ),

21．
.Right_Done( Right_Done ),

22．
+ O; u6 i0 d7 P4 w9 t  a' Y.Right_Start( Right_Start ),

23．
.Left_Start( Left_Start )

24．);

25．

26．initial                                                

27．begin  RSTn = 0; #20; RSTn = 1;  end  

28．

29．initial

30．begin  CLK = 1; forever #20 CLK = ~CLK;  end

31．

32．initial

33．begin  Start_Sig = 1;  end

34．
7 s" m' `. b7 z: U% N1 T

35．endmodule

- g8 a8 K9 z) z- `9 q& B7 N/ {, A! r6 X

下面是仿真的载图：

/ e; [; I8 p+ v" T0 e

http://j.imagehost.org/0352/PIC10_7.jpg

kenson

转载无罪！学习有理！

littlebadbay

mark 好文章

botao

学习了,多谢分享.