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

kenson · 发表于 2010-6-5 21:48

好东西尽收其中这个是转以下这个仁兄的 akuei2's Blog
[Verilog HDL 建模技巧：低级建模仿顺序操作 · 思路篇] 1 - 封面+书语

书语：

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

, g" A9 y+ `+ {, ]+ _) ~: y

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

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

6 `+ m: n# W7 T; S/ n

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

d- x! n* G( x& H! E

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

! k- R, {% O- Q! p. A v

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

! t# z' x- C& U( u( e d5 \ n

笔者的话：

6 D }6 p* Y( K O2 [

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

kenson · 发表于 2010-6-5 21:49

前言：

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

5 J, }$ e, {0 y7 f$ B. Z4 z. w

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

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

- Z/ x g1 X$ i# `: |+ L

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

# ?( c- [+ N8 ?" ]

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

0 ]0 b/ s1 \$ a- [) h% x0 B

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

3 q$ A1 d1 r0 b# @

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

9 I# ^) K) ^0 o6 \

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

/ u9 H: Z: s2 m& L- I2 V9 X2 ~

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

kenson · 发表于 2010-6-5 21:50

第1章“低级建模”的思路

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

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

9 d; t$ {( D+ V/ g+ J9 ^/ p

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

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

. o' v( b4 A# {& o9 g, ]

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

2 a! t# \+ Q0 U

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

! j* x1 j3 V. Z

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

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

; E) n9 M7 @) K0 p' q/ s

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

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

. j! k5 @$ ^( c9 ~$ X9 g- C9 z

, ~! l2 y- P. q; z4 I' p

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

1. 永远自右向左发亮。

2. 永远自左向右发亮。

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

% N; ~! ~( j. o" u

那么可以这样写：

4 ]/ m- v9 H1 B+ m2 `. v2 L

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

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

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

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

, Q; n) u+ `6 f, j. C1 R0 ~1 @. O

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

* J4 f3 s2 Q- J6 k+ B4 a

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

. u6 s. W4 h3 _5 o: S! K9 n3 [

( f- j# |1 ^4 o. O/ L, N m) t

module Flashing ( CLK, RSTn, Data_Out );

- e+ Q( ^* F% Z6 I

input CLK, RSTn;

output [7:0]Data_Out;

# p* v5 L; w% \; [# k2 N2 s) x

reg [7:0]Counter;

: A2 o! t* g; w- g! j

always @ ( posedge CLK or negedge RSTn )

if( !RSTn )

Counter <= 8'd0;

else if( Counter == 200 )

Counter <= 8'd0;

else

Counter <= Counter + 1'b1;

' N" y5 a6 I$ N( Z$ d/ _- ]& q2 F

reg [7:0]i;

- k8 | A% u; t9 o& x

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

6 C9 \* o1 K6 D1 V# {- J' r4 L

reg [7:0]rData;

( N0 y( u$ |' E* }* i

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;

# u0 ~" Q4 p; m+ l1 m8 H

assign Data_Out = rData;

^! q$ v% M) c+ M( b0 V0 O% I5 a C

endmodule

" x0 s/ w) ]( ?" c6 G6 E+ i# {

7 w0 P/ h/ _& S: a( B

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

) S; l+ ~1 n0 v% [, W. |$ P

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

- q, X! K3 [) Q- {* z

( a2 J0 B3 c7 r& C! S) g G

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();

% ^/ e) _2 W6 d' M7 A% m

: C6 n* [& t/ Y2 a/ o( O% t

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

+ m" i. e* `, {# R0 k# L: ]

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

3 P; m2 r$ m% ] Y' ~' d N

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

kenson · 发表于 2010-6-5 21:51

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

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

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

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

2.2“低级建模”的准则

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

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

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

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

能。

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

! s- `# V) j7 i$ C; V3 U

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

6 X7 y0 Y) M0 k3 H8 ]9 E! H

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

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

kenson · 发表于 2010-6-5 21:52

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

7 U2 |! ~( O' V3 ^4 l

先看看以下一段代码：

% {# r0 ?; i& M% W4 U2 w

//独立模块
alway @ ( posedge CLK or negedge RSTn )
   ......
   else
      case ( cState )

            "打扫" :
            if( 打扫完成 ) nState <= "洗厕所"
            else "发号打扫命令"

            "洗厕所" :
            if( 洗厕所完成 ) nState <= "跑腿"
            else "发送洗厕所命令"

            "跑腿" :
            ......

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

//低级功能模块1 - 打扫工作
always @ ( posedge CLK or negedge RSTn )
   ......
   else
      case( cState )

            IDLE :
            if( 到扫命令 )  nSate <= "打扫"；
            else nState <= IDLE;

            "打扫" :
            "执行打扫" ；
            "打扫完毕后报告" ;
            "待命..." nState <= IDLE;
               ......

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

//低级功能模块2 - 洗厕所工作
always @ ( posedge CLK or negedge RSTn )
   ......
   else if
      case( cState )

            IDLE:
            if( 洗厕所命令 )  nSate <= "洗厕所"；
            else nState <= IDLE;

            "洗厕所" :
            "执行洗厕所" ；
            "洗厕所完毕后报告" ;
            "待命..." nState <= IDLE;
            ......

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

//低级功能模块3 - 跑腿工作
always @ ( posedge CLK or negedge RSTn )
   ......
   else
      case( cState )

            IDLE:
            if( 跑腿命令 ) nState <= "跑腿"；
            else nState <= IDLE;

            "跑腿" :
               ......

; o9 l; G% A# i

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

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

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

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

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

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

! B7 }( ]$ W$ e2 K q! x" n3 R

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

+ M# K, n; @, v* ~/ g) d

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

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

) ~3 A) R4 Q8 n7 y! p: ~3 t- k

kenson · 发表于 2010-6-5 21:53

2.4 组织的概念

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

4 Y9 H: {+ c, C, S' O

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

# Z/ v r& w. N8 c

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

8 I& y6 Q8 |) U6 O1 k* l# B/ |

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

( Z3 M8 b2 u: i1 J1 `! x3 A7 \

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

7 W$ t- Q; J6 q% d3 g

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

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

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

. r: f! ?4 r5 n# y# g; l8 j

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

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

kenson · 发表于 2010-6-5 21:55

3.1 模板基本结构

1 m% o p; {8 K: w: @8 T7 p/ y2 mmodule Template

7 S5 ^+ W" O" @0 p/ n(

& }0 D( h6 }5 q% N$ h
CLK, RSTn,

0 a. M: O* P& t+ p) R) ` ...... , // "n个输入输出"，

! L" F' Z: r% w8 u Start_Sig , Done_Sig

5 L( u1 g3 ]: e);

$ z b( d' N. z

input CLK;

input RSTn;

input Start_Sig;

input Done_Sig;

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

- ]4 h$ x; M- @3 F( U8 u$ v

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

7 L. p$ A( _# f1 T( n3 [6 d

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 )2 }+ P4 t0 c, L) x8 }: b

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

Init;

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

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

Done;
0 a, z* d5 N( j/ O

endcase

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

/ `, t7 u$ @- H* C# j! I1 Y2 o

task Init;

2 {- U% Q' _' T: B% v+ Q/ M H% J

begin

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

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

end

endtask

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

2 I; Q* l4 a9 d

task "n个Task";

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

endtask

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

" B9 c0 h$ J$ }7 N% z& s$ D

task Done； //产生Done信号

: y3 X3 _4 o& h' I( w! }

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

else begin isDone <= 1'b1; i <= i + 1'b1; end7 c7 f) p: ?" f L

endtask

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

0 g( n% r; j# S ?. ]

assign Done_Sig = isDone;

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

endmodule

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

: Y' f- X- t3 p: Z1 g

1) Start_Sig 和 Done_Sig是固定的。

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

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

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

8 R' c1 w) o0 ?/ s) A

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

! p& i! d' a* E/ |3 }

, K: e* d. A- G# p7 G3 U
i <= i + 1;

, R9 S# |6 K3 T0 W' \" P5 C( N. Y2 j

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

2 B8 g% M" M; Q- D# k

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

8 X6 ?6 F. N6 J5 {, }

  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

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 : Next;       ......
   endcase
/**********************************/
  task Next;

i <= i + 1'b1;
  endtask

- D' I2 M# J9 Y

上面的两个写法都是等价的。如果模块是小功能，那么左边的写法很适合。但是一旦模块的功能很复杂，那么右边的写法会凸显出优势。
9 u9 w, L! `7 q ]! i ?! o

kenson · 发表于 2010-6-5 21:55

3.2 建议

为什么需要模板结构？

+ g. v$ a/ }0 X- M, u

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

' g5 g2 p: R( g" U

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

6 @: Q. B g8 }, h8 F; o* T. ^

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

" U, Q, r, V! v2 v5 Q5 d) p( X

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

+ V+ h: V, `2 q

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

kenson · 发表于 2010-6-5 21:56

4.1建立2个“低级功能模块”

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

! ^, g1 U7 @4 ^3 P, l

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

) f% ]6 h) w! e* o; }+ ?# G

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．1 \; t* r- b3 e8 V" K8 E3 P

14．
0 f) i Y* D1 T0 V% t3 ? /***********************************/

15．" w) H3 h6 K: ]7 w' n% i

16． parameter DELAY = 8'd200;

17．* i% Z( `1 K H7 B' |& ?& m( l

18．6 N0 ~$ K1 {& p1 s0 N `$ d
/***********************************/

19． h# Y1 F5 b0 J: ]* N) k

20． reg [7:0]Counter;

21．
6 I9 O2 L7 i0 J; ^

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． a/ { N( R: @8 N0 w0 y

32．
. Z: E+ z& v, k# {7 T /***************************************/

33．
8 [+ O) d+ c. D! R) @' V/ z0 S

34． reg [3:0]i;

35． reg [7:0]rData;

36． reg isDone;

37．& _, v/ y2 r' M) ^$ T# q: K

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．- _4 C# a& G/ u* z

48．, k7 M- Y i4 j! p: F2 M' h; G
0 u* O0 K: A* G7 A

1 s* {) W9 n3 e3 i7 \& O6 b5 X# w% m; Q. u1 N% M& d! w. `2 i# p G
4'd0 :

49．
) J8 q( i# x+ P% g" ~( H& `begin rData <= 8'dx; i <= i + 1'b1; end

50．
, u; [6 u! d  j# {) i. |3 p
  l2 N1 ?3 W& V( L% t5 c
# D' V$ S4 z9 j+ ~4 S; T: f9 ~. _5 r  g6 }

51． 0 |4 {4 f4 B4 C: Z6 g

1 }4 _/ u; J: M1 a2 F
# t+ Y% [' ^: }' D5 ^. l7 k7 @2 R1 n8 V+ U/ Z8 Q" R) c, U- S
4'd1, 4'd2, 4'd3, 4'd4, 4'd5, 4'd6, 4'd7, 4'd8 :

52．
0 U2 n- P/ ?5 P& ^3 \5 _% s4 W5 b% v) ^3 H" J
! N4 _. o& f1 \) I& s1 a
% I+ K. e6 g: ]% b& q8 J m4 U& s
if( Counter == DELAY ) i <= i + 1'b1;

53．
7 \ H0 l5 K% a7 K2 J% S2 w- G; w: @5 L. ?
% q: }# Q" z8 Y, Y8 E5 k
- P+ j" D8 g( ^( i/ n/ ^2 ?
else rData <= ( 8'h80 >> i - 1 );

54．5 m' }3 o* v0 c6 b& g1 G

1 B% I& k" [" b/ i7 x7 |* {* x9 [5 _; N$ }, p
) i; B s, c3 }- _6 A

& H) P) d; I5 ]! X2 \

55．
9 ?7 n( ^9 W+ T
& A6 |0 C! U2 l1 K C. ^, O) Q3 U7 z9 `+ N

4 Z) j- K2 O/ V* g, {/ ?4'd9 :

56．# q7 L1 o& S) a; j; S8 b9 J
, N. g- X9 m! e: k% ^

; ^9 w/ H5 n, V
( D% R9 ?9 L. p) g' v. o/ w% [+ t! z7 z* W- E/ y
begin i <= 4'd10; isDone <= 1'b1; end

57．
$ }9 q0 S+ I5 q- v+ c% N* j& R9 o( @% G: V- O% }
4 {% s8 m( s9 D; b% O% U! x# I+ U
) i5 q4 I' |9 S4 @% f' W% A& q8 M

58．
1 e" \9 o+ u/ R$ s% a N# P: @/ x, l
* D1 U) s X2 [( g) A

, ?4 b% m; [6 F0 t! i4'd10 :

59． 4 Q' A, q: V Y( `, }

$ W/ ^, A3 b. N1 ]1 l8 K# \/ N9 V' m( K2 o7 a5 m$ ? x8 U
) ?1 S0 W. @- u) H9 `$ b
begin i <= 4'd0; isDone <= 1'b0; end

60．3 Z8 j- y/ a# r- p

% ]9 @2 |" l# h$ h
- f% L6 Z! q/ g* h/ A: M

61． endcase

62．

63．! J8 E h( r% O

64．
0 E* A6 V0 i% g# y7 U /**********************************/

65．

66． assign Done_Sig = isDone;

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

68．
* u* j2 P2 L8 n; Y2 d4 M, D: f

69．' \& @6 q2 k) L
/**********************************/

70．

71．endmodule

9 P2 J b" k6 J

& o8 L4 b X4 [. W1 \& 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．/ x1 T4 w9 C: H; l6 q |

14．7 s7 `" |( m/ t7 `
/***********************************/

15．
9 i* d2 w( U! ? i

16． parameter DELAY = 8'd200;

17．
2 F. h7 n% G; [+ ~2 X. O/ j, F

18．- Z) `- N8 P: O; m
/***********************************/

19．
6 A; H% F8 T$ A+ ^8 j# @. F, o- H" m

20． reg [7:0]Counter;

21．8 X3 m0 \* m$ Q+ p: |- ^

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．
- r& J0 z2 h: `9 U; g" w8 K/ c

32．
e' g1 T: ^* d0 I* v# ^+ I0 a/***************************************/

33．* x3 L! Q8 ?# B: f

34． reg [3:0]i;

35． reg [7:0]rData;

36． reg isDone;

37．4 i: X2 H" g- Q6 `7 P V! N

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．
, {2 d' ~. G* @ Y& _2 V2 f' @' v

48． ) E, ^$ z, k5 N$ p7 ~( _

m d5 u) E2 y+ G9 l. I @( r) q
5 e6 |. g4 g1 d7 P/ t. Z
9 @9 |# |! e+ {/ S# N4'd0 :

49． + f! V$ i+ [$ }- q  M8 v
; i) D6 m  H. ]+ Q6 }
; y5 ~$ W& R# y+ u& U; Q: _. X1 N
  z3 m( {; f. }# C
begin rData <= 8'dx; i <= i + 1'b1; end

50．; A! @# ]3 C7 m! Z2 R2 h3 L
$ e3 W C5 i& V& N7 @/ k. u
0 X0 h1 Z$ H" P

5 [( y5 \! l* J3 A

51． 4 V8 c1 N6 H- X
5 ?% x+ C0 W9 m

$ x+ ~" |0 [( @! F7 e( q) Z0 ^, z
4'd1, 4'd2, 4'd3, 4'd4, 4'd5, 4'd6, 4'd7, 4'd8 :

52．; J# X* Y, i. f# {6 W" C3 z

/ A" t: P8 r7 g' e7 J) `. _1 @8 w+ g# R
7 H5 s2 Q1 E. A

' x0 J$ J2 _: I% e1 ?if( Counter == DELAY ) i <= i + 1'b1;

53． 7 P- n; ?0 A1 w" V. \2 i

) b3 {* j0 A3 a8 A' b) S" p7 a% h- S# m! w
9 j, q/ z9 Y) ` `9 @! ^
else rData <= ( 8'h01 << i - 1 );

54．+ a$ q+ O$ q9 H; j/ S8 v0 t
# o/ |$ M. s( j
/ d9 c; Q& ^+ r, Y4 L
4 S4 w. Z U$ V+ w

1 j5 Z9 | m0 _) I4 _+ M

55．
; ]7 e! D8 S, K2 E* W) A( l4 A6 j' p7 W
4 m% t# f. M9 ]/ z
2 i! M' ` N7 ~( N
4'd9 :

56．
5 a: v* F3 d; T7 r3 [% k& u% F& E0 g# n4 N V9 n3 S) V

" w, }; l- ?0 f' t# v1 X1 S1 s. f8 X; |: ` r6 [
begin i <= 4'd10; isDone <= 1'b1; end

57．1 D6 l; v1 L0 x9 Y, ^8 n3 a

3 U* j7 t- a7 a% w5 C# S2 s# V
3 S6 G# T D3 r. g1 x0 q( ^; ^4 l! I& ^+ _) k1 H! }# Y

58． 6 L1 k5 h7 q8 |* @$ z

6 o/ s6 a- G- j! I* j7 _( J# N3 |
0 S |+ p( Q N7 M1 `. p+ E+ B& T# }; @$ f' A: |
4'd10 :

59． v7 j, O8 L& p

) [/ w0 i# W/ [
6 z9 N: j- B7 n; @8 |
8 S& e+ N9 A% p( J% G, m1 cbegin i <= 4'd0; isDone <= 1'b0; end

60．4 E* s# G* |0 B( q9 P) Q+ ~4 m

6 g' N- R7 Y: r( t8 `- W
! P- F5 d5 }! e, E3 O1 J+ U/ E: u+ T' a% b% J4 {& D* w9 ?: H1 d9 [& h

61． endcase

62．8 `3 D$ ^# P- E$ |+ w

63．/ ~; ~* X: _% Y
/**********************************/

64．

65． assign Done_Sig = isDone;

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

67．. l9 {/ \! G5 f7 ~1 k* J

68．
9 ]) R( o7 B T& { o, _6 j) _3 L/**********************************/

69．

70．endmodule

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

p( J! ^. g5 `2 l% e2 p

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

3 V/ p, @0 c" R& f

仿真效果如下

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

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

) N! a5 B+ K( Q/ J

. T+ `# Z+ k+ \, H, ~" d
/ r* Q, s( o s9 z& }1 V

( 最后一行是完成信号 )

http://space.ednchina.com/upload/2010/6/5/dbc4e2e6-fa71-46aa-8cdd-9c8d94da7a39.jpg

* a4 Z0 _7 U8 S& e

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

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

kenson · 发表于 2010-6-5 21:57

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

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

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

2 S/ d2 r# d' x( Y7 M3 c! e t3 E

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．
% _) b2 _3 A+ F6 Y0 F

8． input CLK;

9． input RSTn;

10． input Right_Start_Sig;

11． input Left_Start_Sig;

12．1 N% t5 e3 a3 w n- S: Q. _* W

13． output Right_Done_Sig;

14． output Left_Done_Sig;

15． output [7:0]Q;

16．- N& u5 K+ _' j a* L0 i+ E; M

17．
( N- Y+ D2 y+ ^% d /*******************************/

18．+ W% A2 N( F& ~% V: R4 s2 {

19． wire [7:0]Q_U1;

20．$ e3 L: P3 H T, P6 ?, d

21． flashing_to_right U1

22． (

23． .CLK( CLK ), ! N7 l* @; b5 F3 j" X
9 g. p" y; Y/ K( E- M0 N
! t. y4 P. _# n) k! E( R
// input - from top

24． .RSTn( RSTn ),# R5 u- H% F( a0 P% v
9 U# W. [, S# e- b. D$ o
. `4 S0 A9 o5 {" C
/ a: X$ S( u0 U# J
a% H1 |! F# u' w, Q
// input - from top

25． .Start_Sig( Right_Start_Sig ),
5 @! T/ g% B6 a// input - from top

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

27． .Q( Q_U1 )" V) Q+ U) I6 h6 w/ S6 Z

2 x) O$ M1 p: z+ t& t
. q9 Z3 D( n$ Z$ n- j! a$ m3 f6 t1 j

9 w: D0 H8 X/ S8 L3 e1 s
/ \8 e( v, R/ e/ _// output - to wire

28． );

29．% a' u! s' E& Z! P! k6 i: y1 A6 _

30．( s3 @" o) C& y2 \' F! E, j2 R
/********************************/

31．1 a5 B9 ~8 O' ?& r8 W

32． wire [7:0]Q_U2;

33．
3 @: I- e) m6 Z. \. q, Q" v

34． flashing_to_left U2

35． (

36． .CLK( CLK ), 8 n0 Y. R4 W- ?" s3 q+ A/ O* e

, J1 d7 z" |5 w! {2 ]* \% p; k* ~// input - from top

37． .RSTn( RSTn ),
/ N- q; o. p/ ?$ |8 ?4 [1 Q g// input - from top

38． .Start_Sig( Left_Start_Sig ), . s' s5 E( t' W+ _6 J3 n* ~
// input - from top

39． .Done_Sig( Left_Done_Sig ),. W/ L" `( Q* M5 f4 S
// output - to top

40． .Q( Q_U2 )7 H3 V1 L$ N! N1 g% u6 z, u4 j

9 k0 P7 ~3 `0 U: A/ A6 v) E/ c# ~
C3 U3 I; e/ l2 y! U7 e- C- C: U$ X1 t% s) R- n3 b

; U" R7 Z& D3 J# U( X) C7 d
/ m- Z, Q5 C) h' l7 P9 Z# A// output - to wire

41． );

42．
7 w; m ~# Z8 @. \+ [6 _8 L7 C

43．
5 \, I' n. y. G/*************************************/

44．
! a X* V. ]/ {; l; x' }7 V

45． reg [7:0]rQ;

46．
5 k& o- ^8 {* k X0 U( e# j! l* X

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．
! M$ K" w3 E7 a8 a2 v0 e

52． assign Q = rQ；

53．
% b. H; w6 X" x" K

54．6 f5 [) O3 h1 a. I8 R
/*************************************/

55．
2 x# H6 a/ |6 q$ w! M3 U5 \

56．endmodule 5 ^0 W& M' F- f

$ p) ~ Y0 G: a, Q

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

4 l, K2 q, C6 L$ U# M

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

当然还有其他的写法：

' Z2 A1 y( e! w& ]2 G/ M- h

assign Q = Right_Start_Sig ? Q_U1 : Q_U2 ;

7 Q$ B/ H7 h: y) P P

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

* g3 e' x4 Q, ~8 m

1. 解读性很差。

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

2 M% Q8 }8 i* P

所以不怎么推荐使用。

* e" j: r; S2 E9 m* x/ x' B

还有一中更糟糕的写法：

3 s& b7 O' d0 K" G/ @$ b0 m

reg [7:0]rQ;

6 x& C. c; R O" e& O: u

always @ ( * )

case( { Right_Start_Sig, Left_Start_Sig } )

2'b10 : rQ = Q_U1;

2'b01 : rQ = Q_U2;

default : rQ = 3'bxxx；

endcase

; j8 p& a, Y- u' J

assign Q = rQ;

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

5 g; E' G0 Q+ ?7 m- w

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

& V" n5 h- b, {, p0 L. x: r2 h

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

9 O# `0 s! J# Q- g

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

9 _# O9 O4 H2 {4 O2 x7 U2 L

reg [7:0]rQ;

. T+ j7 \+ c* i7 m1 r7 G

always @ ( * )

if( Right_Start_Sig ) rQ = Q_U1;

else if( Left_Start_Sig ) rQ = Q_U2;

else rQ = 3'dx;

" L* E+ Y5 N5 `1 P- ^

assign Q = rQ；

+ W9 |: d/ q" Q: [) r2 R

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

?. k& ^' `6 P6 V

& k" S* ?, Z; E

always @ ( * )

5 O% T) \, ], L

7 o+ [% X' O0 e

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

8 @& r' {/ c) I& O. e% G

. Z3 V2 J t4 `1 d0 T7 X. c

if( Right_Start_Sig ) rQ = Q_U1;

else if( Left_Start_Sig ) rQ = Q_U2;

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

, t# O$ F% M* p* W, p& \

% N) g+ u e3 L$ }# N

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

. H1 H2 v$ x+ S ]; x( B

' A/ H" s$ x# Q4 j

always @ ( * )

/ L. Y) Z# z- ^x if( Right_Start_Sig ) Q = Q_U1;//连线 Q，Q_U1 和 Q_U2 之间没有

1 z. }. O3 l: c2 n/ O1 L
x else if( Left_Start_Sig ) Q = Q_U2;
3 k- \2 N0 V* B. O# P8 O//寄存器驱动

+ a4 X& J6 Q' `3 Y) S( ~& j4 hx else Q = 3'dx;

% s, S& u9 j" Z; h5 e

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

[* D7 K( j2 f8 V$ J: n& z

总结：

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

		自动登录	找回密码
密码			请使用微信账号登录和注册会员

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

浏览过的版块

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