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

kenson

好东西尽收其中 这个是转以下这个仁兄的  akuei2's Blog
[Verilog HDL 建模技巧 ：低级建模 仿顺序操作 · 思路篇] 1 - 封面+书语
1 k* q  Q3 v+ {6 f% `$ ~+ z* E2 W- @
% ?! B  I4 g( r8 e
. t1 P1 _+ B7 l+ A1 n
书语：

“低级建模”是针对入门或者新手提出的一种“设计思路”。我们知道FPGA执行的概念是“并行”，但是在入门众多的实验中，高达4成的实验都是“顺序操作”的执行概念。假设一个比较经典的例子“流水灯”实验。如果利用单片机设计流水灯的驱动程序，是非常简单，我们只要，建立延迟函数，移位函数，和一个大循环，就可以实验流水灯效果。

/ z  |8 W7 {. S5 m- u

但是换做另一个环境如（CPLD/FPGA）的平台上，实验复杂的流水灯效果。在“并行”概念上，设计这样一个驱动程式，会使得初学者上力不接下力。我们可以考虑这样一个问题：“用什么办法，不失CPLD/FPGA的"并行性"，而且还可以轻松实现"顺序操作" ”?

在网上个多的论坛，时常可以看见很多新手求救关于这方面的问题，笔者也是如此，所以笔者才决定写这本笔记。

还有一种问题，就是编程风格的问题。Verilog HDL语言对初学者来说，编程风格是最一个大难题的。有这样冷笑话流传在新手之间流传：“ 如果一个新手写十个驱动程式，会超过10个不同的编程风格 ”。这也难怪的，要建立一个编程风格真的不简单，即使是写了多年经验，也不见得会有编程风格。然而“低级建模”有固定的模板格式，可以很好的帮助新手们。

6 G) M+ O3 G# H! h9 G

除此之外，“低级建模”对“仿顺序操作”是简洁的，不同于一般的编程，滥用了“状态机”来达到效果。“状态机”在仿顺序操作上，虽然有很大的效果，但是“状态机”对资源的消耗，和“代码的臃肿”都是可见的。“低级建模”在“仿顺序操作”上，使用“步骤”的概念，就如我们食饭的时候，首先饭来张口，然后慢慢的咽，最后才吨进食道，就这样一个动作就结束。要吃另一口饭的时候，再重复这个动作。（如果吃饭换做是状态机，事物可能会永远卡在食道）

4 P! s8 G2 x2 Q

目前笔记也只是写了“低级建模”的“思路篇”而已，因为笔者考虑到自身资格和经验的问题，笔记的续文非常不适宜。但是笔者认为这已经是足够了，因为笔记的内容可以很好的帮到初学者，从另一个角度去认识Verilog HDL建模技巧。

' @. c% Y* H  V5 j/ [! d3 P

笔者的话：

还记得自己初次接触Verilog HDL语言时候的感觉吗？曾经有没有因经历失败而灰心呢？如此过来的人，偶尔会回忆，会觉得入门（初学）时的心情是最真实的。即使现在，挫折中，迷失中，混沌中。只要回忆当时，就有继续的勇气 ......

kenson

前言：

再过不久就要毕业了，毕业后就要上班，所以呀学习的时间确实比以前少了许多。不过这不是重点，我发觉自己的“自学”程度已经达到某种的限制，再也提升不了多少，是时候换换环境。故一在此之前写下一本关于Verilog HDL 心得的学习笔记。

* j! o* p0 g2 D1 U) L* @* N

每一本笔记的开始都有一个初衷：在早期练习Verilog HDL 语言（以下简称V语言），有一种莫名的奇怪感觉。相信很多初学者曾经有过这样的感觉 ......

我对这感觉执着很久，似乎要揭开什么！？我以简单的模块，进行了许多样的V语言编程风格，最后我发现有一套很简单而且非常“有效”的方法，我称为“低级建模”。

0 P; _+ h/ Z6 l

一开始，我对这与这方法没有任何“准则”要遵守而非常茫然，要我消耗了很长时间才建立起最基本的“准则”。经过许多的实验，惊讶的发现该方法对于“仿顺序操作”非常有效，我开始猜想“是不是应该建立一个适合低级建模的模板呢？”。模板的概念，有学过C++的朋友应该都知道，在C++的世界里，模板可以根据不同的“类型”，以同样的格式，创建函数，类等等。

" \$ Q& A6 b) E( X- y4 f7 ^4 }, F

在最后的几个试验中，我结论出一种“通用”的编程模板。即使，各个模块都有不同的功能，不同的代码量，不同的编程习惯，但是固定的“形状”还是存在。你应该知道V语言的解读性，不是一般的“穷”！（除非你经验老道）

  Y) p* d7 U4 t7 z6 x, G

可能会出现“鄙视群众”，“批评”自不量力的我搞原创的活儿。这一点我承认，自己才学过几个月的V语言和FPGA而已，没有任何实际的项目经验，V语言都无法精通，根本没有任何资格...  

: t9 I' W' S, t6 [3 t

被这样认为是人之常情，所以我才要事先声明：

这只是个人的一个心得，一个思想而已，纯粹“分享热心”才写这一本笔记。笔记的内容好不好我不知道，有没有用我也不知道，但是有一点，对于初学者来说，它绝对有参考的价值。仅此而已。

+ A  O3 x  g: _) n

这本笔记我不论任何评价。至于该笔记的价值如何，竟可以在读前先不要做任何结论，浏览过后或许你会萌出其他的思路呢？

kenson

第1章“低级建模”的思路
7 _* x' i- G3 w/ @4 }. K) m1 a

首先，我将用一个简单的例子来说明一下，“低级建模”的最基本思路：

（一）利用C语言驱动八位发光二极管：

! y# n1 `/ ?* u( w

http://space.ednchina.com/upload/2010/6/4/8d556145-fa4a-4fb8-a8bf-874d086f1a52.jpg            

(如果我说C语言和单片机是形影不离的哈，估计没有人会反对吧?）

% G  [% c, |4 I3 N3 \" {& `+ `

我们以流水灯作为例子，因为它是最经典的实验。假设我要实现流水灯效果，那么我只要建立一个简单的“流水灯函数”函数，“Flashing”。

void Flashing(){ ...... }  

2 a: ]' |- t1 H$ z

http://space.ednchina.com/upload/2010/6/4/27ce8e29-6ad5-4d5b-83ae-6b6fd1f39b7b.jpg

如果要实现自左向右或者自右向左发光的流水灯，可以使用C语言创建两个简单的函数，“Flashing_To_Right”和“Flashing_To_Left”。

  m: X1 {, x9 c: c7 a5 l5 V

   void Flashing_To_Right() { ...... }

void Flashing_To_Left() { ...... }

; `" |$ M7 {0 ?) ~! S

* Z5 T# t  i* ?: C3 H/ z

假设我要实现流水灯效果：

1. 永远自右向左发亮。

2. 永远自左向右发亮。

3. 流水灯永远跑来跑去。

那么可以这样写：

    while( 1 ) { Flashing_To_Left(); } //1

    while( 1 ) { Flashing_To_Left(); } //2

while( 1 ) { Flashing_To_Left(); Flashing_To_Right(); } //3

对于C语言来说，这些任务都非常的简单。几乎是入门级的实验，但是将这些实验带入到V语言的环境下。确实一个记得思考的问题。

（二）利用V语言驱动八位发光二极管：

, A( _9 U; j; {6 J/ @8 |& a

我们先看一段非常傻瓜的一段代码：

# L, t1 X- |/ C/ q

    module Flashing ( CLK, RSTn, Data_Out );

    input CLK, RSTn;

    output [7:0]Data_Out;

reg [7:0]Counter;

always @ ( posedge CLK or negedge RSTn )

    if( !RSTn )

        Counter <= 8'd0;

    else if( Counter == 200 )

        Counter <= 8'd0;

    else

        Counter <= Counter + 1'b1;

: f" t3 c; G, t1 K

reg [7:0]i;

( Q  f% k3 q# ]: `

always @ ( posedge CLK or negedge RSTn )

     if( !RSTn )

        i <= 8'd0;

     else if( Counter == 200 )

        i <= i + 1'b1;

     else if( i == 8 )

        i <= 8'd0

8 u, Z, l! i$ l/ c

reg [7:0]rData;

always @ ( posedge CLK or negedge RSTn )

    if( !RSTn )

        rData <= 8'b0000_0001;

    else if( i < 8 )

        rData <= { rData[6:0], 1'b0 };

    else if( i == 8 )

        rData <= 8'b0000_0001;

% W6 r! S7 b7 o% S; D/ \& O7 V/ Y

assign Data_Out = rData;

; c' c/ r! e2 O1 O  _. X, N, {

endmodule

2 Z/ \, \# H+ N! {) c' Q

" k+ K9 ]5 F: X* {0 l3 p

没错，上面是实现流水灯的代码。如果我说我要求：“ 自左向右循环3次，自右向左循环5次，然后自左向右一次，自右向左一次，然后自左向右循环30次 ”。当你听到这样的要求，你可能会崩溃.... 如果按照上面的写法，你会写得很长很长。

相比之下，C语言要实现以上的要求，根本就是“小儿科”的功夫。

& n3 }. p1 ]4 I5 T1 r

    int i;

    for( i = 0; i < 3; i++ ) Flashing_To_Right();

    for( i = 0; i < 3; i++ ) Flashing_To_Left();

    Flashing_To_Right();

    Flashing_To_Left();

for( i = 0; i < 30; i++ ) Flashing_To_Right();

2 J! l: Q8 ?& }4 j8 C

给自己5分钟的思考，想想我到底要表达什么？

! w$ F! Y4 s5 A, S- `. |& Z

在C语言上，有“顺序操作”或者“泛型编程”的概念。从上述的代码中，for循环利用i变量，控制循环次数，然后调用3次“Flashing_To_Right()”函数。相反的V语言是“并行操作”的概念，类似的方法完全行不通。这就是新手们常常遇到的问题。

方法行不通，但是不代表思路不行。“低级建模”最基本的思路就是“仿顺序操作”。“低级建模”不是什么困难的东西，它只是一中的“手段”而已，只要你了解它的基本构思，它会成为很有用的工具。

kenson

第2章“低级建模”的结构2.1“低级建模”的基本结构

从一个管理系统看来，“低级建模”会是一个从上直下层次的一个概念。

http://space.ednchina.com/upload/2010/6/4/e760f799-20f2-42e9-bff5-b29e3f32ec75.jpg

从上面的示意图可以看出，老板是最顶级的，而员工是最低级的。老板从上头发号，然后经经理呀，领导呀，最后苦力集团就开始动工了。当完工的时候，一一向上报告。低级建模的概念类似如此。除了老板以外，所有经理，领导，员工的“集合”称为“低级建模”。而老板是“独立模块”，因为老板不受命令，而且也不用报告。而多个“功能模块”的集合称为“组织模块”，如上面示意图中的“永远垂死的苦力集团”

2.2“低级建模”的准则
% s4 y8 ~. K$ ]: ~6 z% @

根据上文和上示意图的分析，“低级建模”基本上有以下几个准则：

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

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

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

    能。

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

1 E9 ~, ?: I) V

注意点：功能模块又分成“低级功能模块”和“非低级功能模块”？这话何解呢？

1 G. \: A: T. ~% `4 X0 |$ _

http://space.ednchina.com/upload/2010/6/4/705e0fbf-e98a-43a1-86d5-4893e5037de9.jpg

从上面的示意图中可以分辨出“低级功能模块”和“非低级功能模块”。“低级功能模块”包含“开始信号”和“完成信号”而“非低级功能模块”则没有（就是这样简单而已）。

kenson

2.3“开始信号”和“完成信号”的作用

先看看以下一段代码：

   

//独立模块     alway @ ( posedge CLK or negedge RSTn ) : [9 A) y. y8 }, M! }  J     ...... 7 m7 F6 j5 l7 r- m5 l2 s     else 1 T: Q8 b3 K1 h8 X          case ( cState ) + K/ r7 L. m' _+ u, s, f 5 _! z  x: J1 L, ]1 T# w ! s/ y3 S: I4 T" c              "打扫" :                if( 打扫完成 ) nState <= "洗厕所" / W/ N/ I6 B/ C; F& \0 p              else "发号打扫命令" ) o, e8 F: d- Z' J! O" M# P( Y7 O2 _               "洗厕所" :               if( 洗厕所完成 ) nState <= "跑腿"               else "发送洗厕所命令" ' @$ g4 l, p' }# D& S               "跑腿" :               ...... 3 m- L9 x0 P; Y$ ?; P) b8 K/ F 5 s6 H& N, {& s5 G /*********************************************************************/            ) U0 F. B) l  M7 ]( k0 o/ } * ~7 B) k) l* }8 Z' F4 ^     //低级功能模块1 - 打扫工作 8 A2 H* }) U5 N; g5 G2 _ always @ ( posedge CLK or negedge RSTn )      ......      else ) Y% S8 G' F, ~) d: u8 q         case( cState ) 8 T9 C% F) n- W+ J1 H" m* A ; A# i! [: ~/ \% ^% X& v               IDLE : + d% B  Z; V) C4 A- f! Y, e+ [+ X               if( 到扫命令 )  nSate <= "打扫"；               else nState <= IDLE;               "打扫" :               "执行打扫" ； / X/ o8 `0 h: W5 M              "打扫完毕后报告" ; 9 Y: C# e* l1 A9 L0 y: W: t              "待命..." nState <= IDLE; ' F9 H( V, j5 T                  ...... ' R& R- R( z7 n+ R" E /*********************************************************************/ & E' s4 ^1 S. v  d3 y 4 B! p! h2 j( Z% I. } * Q" r9 k6 X/ u. f( H0 j    //低级功能模块2 - 洗厕所工作 - e2 U( T% R9 @7 d! `; \5 _/ Y always @ ( posedge CLK or negedge RSTn )      ......      else if          case( cState ) ! p+ k/ I9 i& g                IDLE:   B$ o$ K: `$ I/ W, |0 e6 Z              if( 洗厕所命令 )  nSate <= "洗厕所"；               else nState <= IDLE;                "洗厕所" : - V( ~+ E; u* _3 I# M$ F/ C              "执行洗厕所" ；               "洗厕所完毕后报告" ;               "待命..." nState <= IDLE; : I5 N* M1 z1 }8 P% q1 W; l  R              ...... * z$ k. C) @1 o0 E8 E& e9 L2 A - t) D3 }( H: }- f" e ) V7 G+ Y' w4 O) R5 e /*********************************************************************/ 9 j2 |9 N4 G6 \  R //低级功能模块3 - 跑腿工作 always @ ( posedge CLK or negedge RSTn )      ......      else & f% U$ _) l0 v7 q; a         case( cState ) ( l. E% C. _/ S 9 a2 {" R8 V8 w7 O# |: B                IDLE:   }' }' \8 H/ r, ^0 M* S              if( 跑腿命令 ) nState <= "跑腿"；            ; d8 \; G# X. d9 @& b. k8 l1 N. J               else nState <= IDLE; : u" g" Q. ^/ G7 A9 K4 a6 Q) l               "跑腿" :                  ......

上面的代码可以分成两个部分，一部分是“独立模块”和另一部分是“低级功能模块”。独立模块只有一个则打工模块有三个，而且每一个打工模块仅包含一个功能而已“打扫”，“洗厕所”和“跑腿”....

注意： 独立模块不属于低级建模。

http://space.ednchina.com/upload/2010/6/5/8d7a1a60-20d3-4b06-ade3-c291dfc92b5d.jpg

假设老板有一系列的命令要发号：打扫 ==> 洗厕所 ==> 跑腿

当“负责打扫”的“低级功能模块”收到老板的第一号命令“打扫”时，该模块从“待命状态”变成“打扫状态”，此时老板可以睡一觉或者干其他的活儿。该模块便开始“执行打扫任务”，当该模块“打扫完毕”后，就给老板“报告”，然后返回“待命状态”。故老板听到“打扫完成”报告后，就给下一个“低功能模块”发下一号命令 ...

在“低级建模”的结构上，为了使不同层次的“低级功能模块”可以协调的工作，“开始信号”和“完成信号”扮演着很重要的角色。在现实中，如果 “打扫 ==> 洗厕所 ==> 跑腿”是一个有“次序的三部曲”，那么老板不可能要员工颠倒次序来干活儿 。老板得按次序，一个一个的命令员工干活。除此之外老板也不可能实时监督员工的工作状况，做老板真的很辛苦，除了“发号”以外，还要干很多事情，所以员工的“完成报告”在某种程度上可以减轻老板的活儿（使编程更简单），毕竟老板也是人，他也有疲惫的时候。

5 N5 A5 u5 E, y% N- ]+ v

接下来的话题便是：“每一个低功能模块仅包含一个功能”。

- T: ?: D, z$ K( b, ~% f

虽然在现实中，确实存在“全能的人类”打扫，洗厕所，跑腿等技能全都集于一身。但是“低级建模”的准则必须遵守。你尝试想象一下，如果一个“低级功能模块”，包含了如上的工作 “打扫 ==> 洗厕所 ==> 跑腿” 或者更多，即不是要把代码写得很长很长 ...

所以呀，“低级建模”的准则有它一定的“重要性”（在日后的深入中，你会慢慢了解的）。

kenson

2.4 组织的概念

“组织模块”在“低级建模”中，非常的重要。它不但简化对多个“低级功能模块”的调用，而且也解决了“两义性”或者“多义性”的问题。

你尝试想象一下：如果有多个打工仔，散落在不同的地方。当老板要发号的时候，既不是非常不方便。同样的，在模块化设计中，设计者往往为了使使用更简单，常常都会使用“顶层模块”将多个模块“封装”到一个模块中，亦即将复杂的东西“隐藏”了起来，只剩下简单“接口”而已。这样的做法是为了使该模块可以容易被使用。

http://j.imagehost.org/0312/PIC1e.jpg

, F" Y2 F$ @6 o$ L. B3 P  Z

然而在“低级建模”的设计中，“模块化的组织”更有“层次感”。为了使“上一层模块”可以很方便调用“下一层组织模块”。“低级建模”的设计常常将一组或者一个“组织模块+低级功能模块”，“低级功能模块+低级功能模块”，“组织模块+组织模块”组织起来。虽然感觉上会有一种“杂乱感”，但是实际运用起来，真的非常方便。

% {5 h" J0 ~' \

如上面的示意图中，3个员工被组织了起来，然后3个员工的组合又和领导组织了起来。故这样的组织方法因层次关系，如此类推，最后会有两个“大组织”

4 `* D9 J. t# S2 N

组织1 = { 经理 => 领导 => 3个用工 }

组织2 = { 经理 => 3个员工 }

“低级建模”的“组织”结果会是示意图中所示。除老板意外，大家都有自己的“组织”。

假设老板要命了员工干活，那么老板只要命令任意一个经理就行。

至于“二义性”或者“多义性”的问题，后面会讨论到。

kenson

3.1 模板基本结构

module Template

1 X3 Z$ i$ e# R* _( d  O" l(

    CLK, RSTn,

: L% a. S2 J; w5 r    ...... ,  // "n个输入输出"，

    Start_Sig , Done_Sig

);

       input CLK;

       input RSTn;

       input Start_Sig;

       input Done_Sig;

       ......  // "n个输出输入声明"

* p/ w1 D5 r/ {# c5 F3 ^

       /*******************************************/

+ X' y5 }* \/ t( m9 H6 r

      reg [3:0]i;

      reg isDone;

      always @ ( posedge CLK or negedge RSTn )

           if( !RSTn )

               begin

                   i <= 4'd0;  isDone <= 1'b0;

                   ......   // 任何复位的动作

               end

           else if( Start_Sig )

               case( i )

                   4'b0 :  // 一般都是用于初始化

                   Init;

                   ......   // 任何相关的步骤

                   4'b n + 1, 4'b n + 2 :  //最后两个步骤用来产生完成信号

                   Done;      
# p# ]2 y2 q; G5 a& ]

               endcase

         /*******************************************/

         task Init;

# j2 D* C: z% h( S* S

             begin

                ......          //任何初始化的动作

                i <= 1 + 1b'1;  //指向下一个步骤

             end

         endtask

         /*******************************************/

/ ~8 W- i# @/ f% q8 N' ?9 W* |

         task  "n个Task";

             .......          // "n个Task的执行任务"

         endtask

         /*******************************************/

) s( r. \. |4 k" A3 y

        task Done； //产生Done信号

5 Q' Z. R* w  C4 D

            if( isDone == 1 ) begin isDone <= 1'b0; i <= 4'd0; end

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

        endtask

        /*******************************************/

+ \+ ]( H. r6 n% w( Z9 t. L6 P

        assign Done_Sig = isDone;

        ......  // 相关的输出

    endmodule

从上述中，模板的基本结构有以下的特征：

) f% J* J) h1 U  E! g! \

1) Start_Sig 和 Done_Sig是固定的。

2) 寄存器i用于控制次序步骤。

3) 最后两个i步骤用于产生完成信号。

4) i 等于 0 的时候，多半都是用于初始化动作（选择性）。

* N* I; u  g. T! P/ O8 W2 U

正如准则的要求，“开始信号”和“完成信号”都是必须的。“开始信号”可以视为“片选信号”而“完成信号”如字面上的意思。寄存器i有一个重要的功能，它指向任何下一个步骤，而通常所编写的格式如下：

5 E- I& q( |1 Q6 w' j9 w! T

i <= i + 1;

! R2 R1 w7 I: y5 s

除此之外该模板还引入了 “task - endtask”。目的是为了提升和 “结构性” 。新手们应该知道，使用V语言如果没有良好的编程风格，代码的 “可读性” 是非常的糟糕。

在这里我先简单复习一下，“task - endtask” 的用法 ：

! _% k& b: @9 k& A& V' m/ u9 M

reg [3:0]i;  reg isDone;  reg [7:0]rData;  always @ ( posedge CLK or negedge RSTn)  if( !RSTn )      begin          i <= 4'd0          isDone <= 1'b0;          rData <= 8'd0;      end  else       case ( i ) 4'd0 : i <= i + 1;              ......      endcase

$ X; x5 P. r: r4 G* P0 o7 t % L9 T2 T( Q: d9 N9 F" H; Y5 hreg [3:0]i;  reg isDone;  reg [7:0]rData;  always @ ( posedge CLK or negedge RSTn )  if( !RSTn )      begin ( C: ]6 P) E9 Hi <= 4'd0;          isDone <= 1'b0;          rData <= 8'd0;      end  else      case( i ) 4'd0 : Next;          ......       endcase / e4 N( b$ {$ X- f6 Y" X! u% I /**********************************/ 3 U- @) C: X4 b% c& [+ l  task Next; i <= i + 1'b1;   endtask

上面的两个写法都是等价的。如果模块是小功能，那么左边的写法很适合。但是一旦模块的功能很复杂，那么右边的写法会凸显出优势。

kenson

3.2 建议

为什么需要模板结构？

" r' J2 u* A& L" Q8 s6 `$ _6 ~: O

创建代码的工作往往都是一次性，为了供人参考，或者为日后“升级”的打算。我们不得不养成好的“编程风格”，这也是许多参考书上提出的重点之一。而“模板”便是一种已经制定好的“编程风格”，故这样会简化了编程风格上的问题，只要加以修改，便会完整一个有“结构”和“有风格”的代码。

1 t+ @5 L1 z; }1 i

为什么“低级功能模块”的步骤，需要一个计数寄存器来指向呢？

其实这个问题我也考虑了很久，因为是“仿顺序操作”的关系，故人类对“1, 2, 3 ... ”类似的次序（步骤）有更直接的效果。而且也很好的为代码扩展。

: o( v% _. O! o) Z/ V

编写“低级功能模块”时，必须遵守笔者提议的模板结构吗？

  q. ~: X2 ^& a% q0 M; U3 m# q

模板的结构只是一个参考而已。该“模板”结论是我经过不同风格的编程，得出“最通用”的结果。当然你可以无视我的规定，完全自定义自己的模板结构。但是有一点请注意，必须以“解读性”为优先考虑。因为好的代码不是在“执行效率”上，而是“可维护”和“被解读”。

kenson

4.1建立2个“低级功能模块”
$ l& Z) ^9 P) G; u, O- S" Z

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

假设这是实验的要求, 首先我们先建立两个“低级功能模块”。一个名为flashing_to_left 和 flashing_to_right 。

) U6 W0 s$ g& M: @& Y$ I7 }

1．module flashing_to_right

2．(

3．    CLK, RSTn,

4．    Start_Sig, Done_Sig,

5．    Q

6．);

7．

8．    input  CLK;

9．    input  RSTn;

10．    input  Start_Sig;

11．    output Done_Sig;

12．    output [7:0]Q;

13．

14．
/***********************************/

15．

16．    parameter DELAY = 8'd200;

17．
" H, m% D0 I4 `/ c9 R" Y

18．
/***********************************/

19．
6 C1 z# ?3 O5 u$ g- b

20．    reg [7:0]Counter;

21．

22．    always @ ( posedge CLK or negedge RSTn )

23．        if( !RSTn )

24．            Counter <= 8'd0;

25．        else if( Counter == DELAY )

26．            Counter <= 8'd0;

27．        else if( Start_Sig )

28．            Counter <= Counter + 1'b1;

29．        else

30．            Counter <= 8'd0;

31．
+ L: L3 ]: V. ^0 Z3 {

32．
/***************************************/

33．
8 y! \$ [7 g4 k) t

34．    reg [3:0]i;

35．    reg [7:0]rData;

36．    reg isDone;

37．

38．    always @ ( posedge CLK or negedge RSTn )

39．        if( !RSTn )

40．            begin

41．                i <= 4'd0;

42．                isDone <= 1'b0;

43．                rData <= 8'dx;     

44．            end

45．        else if( Start_Sig )

46．            case( i )

47．
! I) d/ z! O" F, z  n, ^

48．

; O3 ]( A6 j1 ~  N: G7 b
: y0 x2 U3 S6 J. ^; m
' c' E% q+ F9 `- S! b4'd0 :

49．
# V. ?" T8 E+ N% Ybegin rData <= 8'dx; i <= i + 1'b1; end

50．
. D, }% n/ Y! N6 ?


1 u! a8 `  ~) g0 k8 E+ ~+ p

51．
, |; i1 |! D0 e9 s
0 K  \! J3 q* d& ]; b% H

4'd1, 4'd2, 4'd3, 4'd4, 4'd5, 4'd6, 4'd7, 4'd8 :

52．

2 s/ Y4 i8 s+ a" @0 [& ]" t1 m
2 p1 Y3 G8 B3 }8 U. Z
if( Counter == DELAY ) i <= i + 1'b1;

53．
' C1 R# R& B* h/ e, o6 m% ^
4 S5 G* Y8 L$ C$ n6 Y5 M

0 G5 N4 L: k3 D+ }! Q$ X9 kelse rData <= ( 8'h80 >> i - 1 );

54．
% i) ]# c0 U' p# X


5 S" }  q  M% r4 q

55．

; f4 N4 B/ b6 R& }- s
0 i+ V; ~- @4 N$ a( i. a1 h  A" U& M
4'd9 :

56．
0 x8 u2 c6 i- }! g" g+ j, `
  N7 o# A2 M- m, c

6 N0 j' v* Q4 t" L2 S+ z( N# A0 Z+ y
begin i <= 4'd10; isDone <= 1'b1; end

57．
: a) V; ~: B7 F9 F. R; I. d
" C$ H5 |. D* T8 I9 v# C

( Y0 F! \* J8 b& x% h

58．
, F1 \6 j; k& ?$ M

& M+ F2 Q7 p' A3 b/ t; C. A
3 i/ k6 |7 f# l2 p3 w6 _8 i1 r# F4'd10 :

59．



begin i <= 4'd0; isDone <= 1'b0; end

60．


# l3 R7 N' n5 J* @) a( B( `" B
( K6 U- G+ g3 t7 N0 H5 N# k) N

61．            endcase

62．

63．

64．
/**********************************/

65．

66．    assign Done_Sig = isDone;

67．    assign Q = ( i > 0 && i < 9 ) ? rData : 8'dx;

68．

69．
/**********************************/

70．

71．endmodule

, E: J+ q; B  t/ P! _

1．module flashing_to_left

2．(

3．    CLK, RSTn,

4．    Start_Sig, Done_Sig,

5．    Q

6．);

7．

8．     input  CLK;

9．     input  RSTn;

10．    input  Start_Sig;

11．    output Done_Sig;

12．    output [7:0]Q;

13．
3 }7 v! @) |# N

14．
( V, H$ L4 ^/ B: i& y /***********************************/

15．
5 ^' j! D8 ], U3 D) X: o

16．    parameter DELAY = 8'd200;

17．
4 c  x2 h, C. G6 S5 `

18．
/***********************************/

19．

20．    reg [7:0]Counter;

21．

22．    always @ ( posedge CLK or negedge RSTn )

23．        if( !RSTn )

24．            Counter <= 8'd0;

25．        else if( Counter == DELAY )

26．            Counter <= 8'd0;

27．        else if( Start_Sig )

28．            Counter <= Counter + 1'b1;

29．        else

30．            Counter <= 8'd0;

31．
, {7 N2 I. [( i) |# I1 A( p

32．
/***************************************/

33．
3 H, U  Z* d0 B; p

34．    reg [3:0]i;

35．    reg [7:0]rData;

36．    reg isDone;

37．

38．    always @ ( posedge CLK or negedge RSTn )

39．        if( !RSTn )

40．            begin

41．                i <= 4'd0;

42．                isDone <= 1'b0;

43．                rData <= 8'dx;     

44．            end

45．        else if( Start_Sig )

46．            case( i )

47．

48．
7 W* C" Z8 M+ |: \) s

5 K# g0 a" W0 _8 T! p
4'd0 :

49．

; H6 I1 l  T0 s" N: w2 p& E2 f

2 F8 L) O- E6 x* [. n1 [begin rData <= 8'dx; i <= i + 1'b1; end

50．



: I6 _0 m' E: f$ A& o8 t

51．

5 T+ G$ T+ c5 D( V& s' @1 q: b0 X$ r

( C: t+ `1 D/ j) G4'd1, 4'd2, 4'd3, 4'd4, 4'd5, 4'd6, 4'd7, 4'd8 :

52．
1 I" Y; |7 b4 F8 A# x

- K/ T4 I$ K; s7 E
) ~7 p, k6 U" V
0 P' h) G4 a  X1 N/ h8 N( kif( Counter == DELAY ) i <= i + 1'b1;

53．



+ x2 V8 G/ r. C* d$ Pelse rData <= ( 8'h01 << i - 1 );

54．
& g: e" s7 P+ |3 E$ B2 }4 w

55．
  C4 }+ w/ m( V7 q/ q
/ j4 P1 z" e- C/ P
0 B( }0 Y2 b. M5 \
! r3 F, e4 q! |' s8 x4'd9 :

56．

: `6 m4 }0 Q! Y  a! O
& A" y% M/ J3 F9 C# s6 Q9 t
begin i <= 4'd10; isDone <= 1'b1; end

57．
" w" ~& ?+ D$ W) W; R

* d, {) m4 y8 X( H
6 I4 \: @; f/ {2 h# O! w$ }

58．
/ P9 F5 N# y2 g" l0 @

7 U: z# e8 x- h- v% u5 t/ n$ Z1 i
& j" m; y. M) r2 a' t6 U4'd10 :

59．


6 o; f, K- [% D1 Y# e+ _% A
begin i <= 4'd0; isDone <= 1'b0; end

60．
! j; e4 t  g6 w; I7 M
  }- A0 F, j. B+ K) s6 ^
' X$ D9 @4 v- K6 {7 I5 V: b: V
8 Q5 I# H6 A1 d; e: W# p

61．            endcase

62．
8 N- y4 I1 S) O7 J9 l

63．
2 A5 z1 F, I+ R3 o7 N; q" Z /**********************************/

64．

65．    assign Done_Sig = isDone;

66．    assign Q = ( i > 0 && i < 9 ) ? rData : 8'dx;

67．

68．
/**********************************/

69．

70．endmodule

两个模块几乎是一模一样，不同的地方只是在 53行而已。虽然代码都很简单，但是还是稍微关心 45 ~ 61 行的代码，因为是功能的核心部分。正如模板结构般，在第45行，如果Start_Sig 不处于高电平，那么该模块根本无法执行功能。计数寄存器i使用与指向下一个步骤，正如在第49行，当rData 被初始化过后，i指向下一个步骤。

在51行到53行之间，是移位操作，每一次的移位动作都需要200个时钟周期。移位操作一共有8个步骤。最后该模块产生一个“高脉冲”以表示“完成”，然而i也被复位为0。

3 d3 G3 Q& [+ x% }" x- f$ B

仿真效果如下

http://space.ednchina.com/upload/2010/6/5/a27937ce-915e-4ed0-9e21-7a1e0b72070a.jpg

（第一行是输出Q，第二行是Start_Sig,第三行是完成信号）

5 |9 T& F' ]" }2 I& Z

( 最后一行是完成信号 ) http://space.ednchina.com/upload/2010/6/5/dbc4e2e6-fa71-46aa-8cdd-9c8d94da7a39.jpg

注意最后一行，当i 计数从1~8过后，就产生一个完成信号，而完成信号需要两个时钟周期的时间。

完成创建2个“低级功能模块”以后，为了使日后调用方便，必须封装起来。“低级功能模块”的封装工作会比较麻烦，因为“低级功能模块”有“复用连线”的现象，换一句话说，会出现“两义性”或者“多义性”的问题 ......

kenson

4.2 “低级功能模块”封装 和“两义性”或者“多义性”的问题

http://a.imagehost.org/0020/PIC4_3a.jpg

如上的示意图。当我们要封装2个“低级功能模块”在一次，如果两个“低级功能模块”使用同一个输入（重用输入连线）或者同一个输出（重用输出连线）就会出现两义性的问题。为了解决这个问题，使用“多路选择器”便可以。

7 z% w  H* @8 e( T, A# I( Q% w

1．module flashing_module

2．(

3．    CLK, RSTn,

4．    Right_Start_Sig, Left_Start_Sig, Right_Done_Sig, Left_Done_Sig,

5．    Q

6．);

7．

8．     input CLK;

9．     input RSTn;

10．    input Right_Start_Sig;

11．    input Left_Start_Sig;

12．

13．    output Right_Done_Sig;

14．    output Left_Done_Sig;

15．    output [7:0]Q;

16．
" x1 A% E$ w- f& T6 Q) l; X

17．
% `& f; Y( o$ z /*******************************/

18．
! k/ ~  A, T. p5 n( g' Q6 d

19．    wire [7:0]Q_U1;

20．
2 p/ N" u; q9 H5 P; B  v4 {

21．    flashing_to_right U1

22．    (

23．        .CLK( CLK ),      
7 \+ v' u5 T# }
0 S4 ]7 F- O. [; r
. g7 [% @4 e: f0 I: W! E// input - from top

24．        .RSTn( RSTn ),
9 i& {4 T. o. ^; ]% \
4 j, {) X/ s7 L) v

/ ?& u8 @1 Z! I) z: R' J
9 ?! g! m2 `: o// input - from top

25．        .Start_Sig( Right_Start_Sig ),
// input - from top

26．        .Done_Sig( Right_Done_Sig ),  // output - to top

27．        .Q( Q_U1 )

$ b6 r2 D- f& P$ o2 g1 t5 ]
9 O' S+ {+ ~8 f) K

5 g* D' c2 g% A/ j. ^) g" Z
& U- c- j2 v, Y# _5 `// output - to wire

28．    );

29．
/ o' n4 y1 r( N& l. W# L

30．
7 W& M8 w' u, f  V/********************************/

31．
( m/ U" Z# O; g' ^9 z5 ~

32．    wire [7:0]Q_U2;

33．
( r3 ^0 t( R/ x- P# i$ D

34．    flashing_to_left U2

35．    (

36．        .CLK( CLK ),           

// input - from top

37．        .RSTn( RSTn ),            
9 ~* @; ]3 n1 F8 h// input - from top

38．        .Start_Sig( Left_Start_Sig ),  
// input - from top

39．        .Done_Sig( Left_Done_Sig ),
! K8 n: w. h) A1 Y4 R/ ]; _  F// output - to top

40．        .Q( Q_U2 )
  U5 r: D  x( ^8 c

; R, N7 {" Z, _+ R
  G% i. W/ W8 W- [5 H$ L# a
. }$ [0 g0 L+ d6 z0 U! Z4 ^
' k9 n6 N2 B! c' r9 P// output - to wire

41．    );

42．

43．
% ]# T8 B7 }0 H) A/*************************************/

44．
* {, x7 y# ?' u7 }, {' W5 E

45．    reg [7:0]rQ;

46．
8 f0 Y/ H* N5 a8 e1 e+ y, i) X2 Y

47．    always @ ( * )

48．    if( Right_Start_Sig ) rQ = Q_U1;

49．    else if( Left_Start_Sig ) rQ = Q_U2;

50．    else rQ = 3'dx;

51．
+ Q: g& H: K# R% C- G3 b, j: r( G

52．    assign Q = rQ；  

53．
+ z. b) f, f( c" J* y

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

55．

56．endmodule   
- \; s) K. v; j( m5 Q  g6 g

' s; P/ y. ^7 n4 `: w

为了解决多“两义性”或者“多义性”的问题多路选择器常常被使用。如上述代码中在45~52行（从第27，第40行引出“连线”)“Q_U1”和“Q_U2”被if控制着输出。这样的写法是最优化的，生成的RTL图也非常的整洁。

1 r! g1 S3 _5 p# r; H

http://space.ednchina.com/upload/2010/6/5/0f6b6eb3-8c6b-4af8-bcdc-6946a733b70a.jpg

* P' C5 ?' T+ }8 ^1 A

当然还有其他的写法：

; q3 [! C5 w6 M% [

assign Q = Right_Start_Sig ? Q_U1 : Q_U2 ;

) U$ n- f0 f# M( X

虽然如上的写法和，第45到52行的写法相比，更为简洁，而且生成的 RTL图也一样。但是这样的写法有如下的弱点：

4 ]# Z; _" R3 o  q

1. 解读性很差。

2. 只能解决两义性的问题而已。

所以不怎么推荐使用。

/ C( P( l1 ]: X

还有一中更糟糕的写法：

8 E0 ^, p7 x3 T2 X8 m$ G+ }2 d; R

    reg [7:0]rQ;

    always @ ( * )

    case( { Right_Start_Sig, Left_Start_Sig } )

        2'b10   : rQ = Q_U1;

        2'b01   : rQ = Q_U2;

        default : rQ = 3'bxxx；

    endcase

assign Q = rQ;

虽然该写法的解读性很高效果也一样，但是却很浪费资源。生成的RTL图如下：

http://space.ednchina.com/upload/2010/6/5/2f9ae0c3-d220-4ce9-b86b-ebf273901983.jpg

, x- w% j( |+ M& ?+ o

和上述两个写法相比，它可差多了，所以不推荐使用。

/**********************************************************/

& C  a1 |6 b7 X  }) Z# C

    reg [7:0]rQ;

( V* B* X" w5 t& l9 e& y

    always @ ( * )

    if( Right_Start_Sig ) rQ = Q_U1;

    else if( Left_Start_Sig ) rQ = Q_U2;

    else rQ = 3'dx;

: M+ X% C8 M' g8 c' P

assign Q = rQ；  

) r9 n# X6 }; b9 j+ V. t

接下来，我们来分析上面的代码。

- j5 U$ q* h7 N5 a7 }  s

# A+ A# U' R$ V3 H* B9 R/ w

    always @ ( * )

2 C. r* B7 E" ~9 d. h0 f

“always @ ( * )”这样的写法在Verilog HDL 2001 中已经被支持（好像是这个版本）。在敏感包中的“*”，可以理解为“任何状况都有效”。

1 F3 O. A2 T) a

6 g% ^6 c* U8 U# `& K/ T

    if( Right_Start_Sig ) rQ = Q_U1;

    else if( Left_Start_Sig ) rQ = Q_U2;

else rQ = 3'dx;  //不能省略掉

而“else rQ = 3'dx”，这行不能被省略掉。不要问我为什么，这是V语言的编程规则。你尝试注释掉后，再编译看看，你会发现会很多“Warning”。

1 j8 q9 V3 A; I( q

       always @ ( * )

x   if( Right_Start_Sig ) Q = Q_U1;//连线 Q，Q_U1 和 Q_U2 之间没有

( Y; f" ?; ]7 Y6 V, v2 A9 ax   else if( Left_Start_Sig ) Q = Q_U2;
//寄存器驱动

x   else Q = 3'dx;

还有一点请注意，因为“Q_U1”和“Q_U2”是连线的关系，所以必须使用寄存器来驱动。如上的代码中“rQ”便是扮演这样的角色。如果该寄存器被省略了，会出现编译错误。

总结：

“两义性”或者“多义性”的问题，不仅在“低级建模”中出现，日常的建模也会出现它们的踪影，然而“低级建模”出现的频率比较高罢了。“多路选择器”在设计的时候应该经多方面的考虑，亦即取得最平衡的效果。

2 `" V! t( I" k- n' Y' m4 L8 |