Verilog HDL的基本语法

模块

• Verilog HDL程序是由模块构成的。每个模块的内容都是嵌在module和endmodule两个语句之间。每个模块实现特定的功能。模块是可以进行层次嵌套的。正因为如此,才可以将大型的数字电路设计分割成不同的小模块来实现特定的功能,最后通过顶层模块调用子模块来实现整体功能。

• 每个模块要进行端口定义,并说明输入输出口,然后对模块的功能进行行为逻辑描述。

• Verilog HDL程序的书写格式自由,一行可以写几个语句,一个语句也可以分写多行。

• 除了endmodule语句外,每个语句和数据定义的最后必须有分号。

• 可以用/*.....*/和//.......对Verilog HDL程序的任何部分作注释。一个好的,有使用价值的源程序都应当加上必要的注释,以增强程序的可读性和可维护性。

        每个Verilog程序包括四个主要部分：端口定义、I/O说明、内部信号声明、功能定义

模块内容，模块的内容包括I/O说明、内部信号声明、功能定义。

I/O说明的格式如下：

1.  
            输入口： input 端口名1，端口名2，………,端口名i; //(共有i个输入口)
2.  
    
3.  
           输出口： output 端口名1，端口名2，………,端口名j; //(共有j个输出口)

I/O说明也可以写在端口声明语句里。其格式如下：

        

module module_name(input port1,input port2,…  output port1,output port2… );

内部信号说明：在模块内用到的和与端口有关的wire 和 reg 变量的声明。

如：        
              

1.  
     reg [width-1 : 0] R变量1，R变量2 。。。。；
2.  
    
3.  
    wire [width-1 : 0] W变量1，W变量2 。。。。；
4.  
    
5.  
      ………..

功能定义: 模块中最重要的部分是逻辑功能定义部分。有三种方法可在模块中产生逻辑。

1）.用assign声明语句

 assign a = b & c;

        这种方法的句法很简单，只需写一个assign，后面再加一个方程式即可。例子中的方程式描述了一个有两个输入的与门。

2）.用实例元件

and and_inst( q, a, b );

        采用实例元件的方法象在电路图输入方式下，调入库元件一样。键入元件的名字和相连的引脚即可，表示在设计中用到一个跟与门（and）一样的名为and_inst的与门，其输入端为a, b，输出为q。要求每个实例元件的名字必须是唯一的，以避免与其他调用与门（and）的实例混淆。

3）.用“always”块

1.  
   always @(posedge clk or posedge clr)
2.  
    
3.  
   begin
4.  
    
5.  
           if(clr) q <= 0;
6.  
    
7.  
           else if(en) q <= d;
8.  
    
9.  
   end

        采用“assign”语句是描述组合逻辑最常用的方法之一。而“always”块既可用于描述组合逻辑也可描述时序逻辑。上面的例子用“always”块生成了一个带有异步清除端的D触发器。“always”块可用很多种描述手段来表达逻辑，例如上例中就用了if...else语句来表达逻辑关系。如按一定的风格来编写“always”块，可以通过综合工具把源代码自动综合成用门级结构表示的组合或时序逻辑电路。

X and Z

        在数字电路中,x代表不定值,z代表高阻值。一个x可以用来定义十六进制数的四位二进制数的状态,八进制数的三位,二进制数的一位。z的表示方式同x类似。z还有一种表达方式是可以写作?。在使用case表达式时建议使用这种写法,以提高程序的可读性。见下例:

1.  
   4'b10x0 //位宽为4的二进制数从低位数起第二位为不定值
2.  
    
3.  
   4'b101z //位宽为4的二进制数从低位数起第一位为高阻值
4.  
    
5.  
   12'dz //位宽为12的十进制数其值为高阻值(第一种表达方式)
6.  
    
7.  
   12'd? //位宽为12的十进制数其值为高阻值(第二种表达方式)
8.  
    
9.  
   8'h4x //位宽为8的十六进制数其低四位值为不定值

负数

        一个数字可以被定义为负数,只需在位宽表达式前加一个减号,减号必须写在数字定义表达式的最前面。注意减号不可以放在位宽和进制之间也不可以放在进制和具体的数之间。见下例:

1.  
   -8'd5 //这个表达式代表5的补数（用八位二进制数表示)
2.  
    
3.  
   8'd-5 //非法格式

parameter

        来定义常量,即用parameter来定义一个标识符代表一个常量,称为符号常量。 参数型常数经常用于定义延迟时间和变量宽度。在模块或实例引用时可通过参数传递改变在被引用模块或实例中已定义的参数。下面将通过两个例子进一步说明在层次调用的电路中改变参数常用的一些用法。

        在引用Decode实例时，D1，D2的Width将采用不同的值4和5，且D1的Polarity将为0。可用例子中所用的方法来改变参数，即用 #(4,0)向D1中传递 Width=4,Polarity=0; 用#(5)向D2中传递Width=5,Polarity仍为1。

1.  
   module Decode(A,F);
2.  
    
3.  
   parameter Width=1, Polarity=1;
4.  
    
5.  
   ……………
6.  
    
7.  
   endmodule
8.  
    
9.  
    
10.  
    module Top;
11.  
     
12.  
    wire[3:0] A4;
13.  
     
14.  
    wire[4:0] A5;
15.  
     
16.  
    wire[15:0] F16;
17.  
     
18.  
    wire[31:0] F32;
19.  
     
20.  
    Decode #(4,0) D1(A4,F16);
21.  
     
22.  
    Decode #(5) D2(A5,F32);
23.  
     
24.  
    Endmodule

量

        网络数据类型表示结构实体(例如门)之间的物理连接。网络类型的变量不能储存值，而且它必需受到驱动器(例如门或连续赋值语句，assign)的驱动。如果没有驱动器连接到网络类型的变量上，则该变量就是高阻的，即其值为z。常用的网络数据类型包括wire型和tri型。这两种变量都是用于连接器件单元，它们具有相同的语法格式和功能。之所以提供这两种名字来表达相同的概念是为了与模型中所使用的变量的实际情况相一致。wire型变量通常是用来表示单个门驱动或连续赋值语句驱动的网络型数据，tri型变量则用来表示多驱动器驱动的网络型数据。如果wire型或tri型变量没有定义逻辑强度(logic strength)，在多驱动源的情况下，逻辑值会发生冲突从而产生不确定值。下表为wire型和tri型变量的真值表(注意:这里假设两个驱动源的强度是一致的)。

wire

        wire型数据常用来表示用于以assign关键字指定的组合逻辑信号。Verilog程序模块中输入输出信号类型缺省时自动定义为wire型。wire型信号可以用作任何方程式的输入，也可以用作“assign”语句或实例元件的输出。

wire型信号的格式同reg型信号的很类似。其格式如下：

wire [n-1:0] 数据名1,数据名2,…数据名i; //共有i条总线，每条总线内有n条线路

或

wire [n:1] 数据名1,数据名2,…数据名i;

reg

        寄存器是数据储存单元的抽象。寄存器数据类型的关键字是reg.通过赋值语句可以改变寄存器储存的值，其作用与改变触发器储存的值相当。Verilog HDL语言提供了功能强大的结构语句使设计者能有效地控制是否执行这些赋值语句。这些控制结构用来描述硬件触发条件，例如时钟的上升沿和多路器的选通信号。在行为模块介绍这一节中我们还要详细地介绍这些控制结构。reg类型数据的缺省初始值为不定值，x。

        reg型数据常用来表示用于“always”模块内的指定信号，常代表触发器。通常，在设计中要由“always”块通过使用行为描述语句来表达逻辑关系。在“always”块内被赋值的每一个信号都必须定义成reg型。

reg型数据的格式如下：

reg [n-1:0] 数据名1,数据名2,… 数据名i;

或

reg [n:1] 数据名1,数据名2,… 数据名i;

        对于reg型数据，其赋值语句的作用就象改变一组触发器的存储单元的值。在Verilog中有许多构造(construct)用来控制何时或是否执行这些赋值语句。这些控制构造可用来描述硬件触发器的各种具体情况，如触发条件用时钟的上升沿等，或用来描述具体判断逻辑的细节，如各种多路选择器。reg型数据的缺省初始值是不定值。reg型数据可以赋正值，也可以赋负值。但当一个reg型数据是一个表达式中的操作数时，它的值被当作是无符号值，即正值。例如：当一个四位的寄存器用作表达式中的操作数时，如果开始寄存器被赋以值-1,则在表达式中进行运算时，其值被认为是 15。

        reg型只表示被定义的信号将用在“always”块内，理解这一点很重要。并不是说reg型信号一定是寄存器或触发器的输出。虽然reg型信号常常是寄存器或触发器的输出，但并不一定总是这样。

memory

        Verilog HDL通过对reg型变量建立数组来对存储器建模，可以描述RAM型存储器，ROM存储器和reg文件。数组中的每一个单元通过一个数组索引进行寻址。在Verilog语言中没有多维数组存在。 memory型数据是通过扩展reg型数据的地址范围来生成的。其格式如下：

reg [n-1:0] 存储器名[m-1:0]；

或

reg [n-1:0] 存储器名[m:1]；

         这个例子定义了一个名为mema的存储器，该存储器有256个8位的存储器。该存储器的地址范围是0到255。注意：对存储器进行地址索引的表达式必须是常数表达式。

另外，在同一个数据类型声明语句里，可以同时定义存储器型数据和reg型数据。见下例：

1.  
   parameter wordsize=16, //定义二个参数。
2.  
    
3.  
   memsize=256;
4.  
    
5.  
    
6.  
    
7.  
   reg [wordsize-1:0] mem[memsize-1:0],writereg, readreg;

        尽管memory型数据和reg型数据的定义格式很相似，但要注意其不同之处。如一个由n个1位寄存器构成的存储.

运算符及表达式

等式运算符

1.  
   1) == (等于)
2.  
    
3.  
   2) != (不等于)
4.  
    
5.  
   3) === (等于)
6.  
    
7.  
   4) !== (不等于)

        这四个运算符都是二目运算符,它要求有两个操作数。"=="和"!="又称为逻辑等式运算符。其结果由两个操作数的值决定。由于操作数中某些位可能是不定值x和高阻值z,结果可能为不定值x。而"==="和"!=="运算符则不同,它在对操作数进行比较时对某些位的不定值x和高阻值z也进行比较,两个操作数必需完全一致，其结果才是1，否则为0。"==="和"!=="运算符常用于case表达式的判别,所以又称为"case等式运算符"。

位拼接运算符(Concatation)

        在Verilog HDL语言有一个特殊的运算符：位拼接运算符{}。用这个运算符可以把两个或多个信号的某些位拼接起来进行运算操作。其使用方法如下：

{信号1的某几位，信号2的某几位，..,..,信号n的某几位}

即把某些信号的某些位详细地列出来，中间用逗号分开，最后用大括号括起来表示一个整体信号。见下例：

{a,b[3:0],w,3’b101}

也可以写成为

{a,b[3],b[2],b[1],b[0],w,1’b1,1’b0,1’b1}

在位拼接表达式中不允许存在没有指明位数的信号。这是因为在计算拼接信号的位宽的大小时必需知道其中每个信号的位宽。

位拼接还可以用重复法来简化表达式。见下例：

{4{w}} //这等同于{w,w,w,w}

位拼接还可以用嵌套的方式来表达。见下例：

{b,{3{a,b}}} //这等同于{b,a,b,a,b,a,b}

用于表示重复的表达式如上例中的4和3，必须是常数表达式。

缩减运算符(reduction operator)

        缩减运算符是单目运算符,也有与或非运算。其与或非运算规则类似于位运算符的与或非运算规则,但其运算过程不同。位运算是对操作数的相应位进行与或非运算,操作数是几位数则运算结果也是几位数。而缩减运算则不同,缩减运算是对单个操作数进行或与非递推运算,最后的运算结果是一位的二进制数。缩减运算的具体运算过程是这样的:第一步先将操作数的第一位与第二位进行或与非运算,第二步将运算结果与第三位进行或与非运算,依次类推,直至最后一位。

1.  
   reg [3:0] B;
2.  
    
3.  
   reg C;
4.  
    
5.  
   C = &B;

相当于：

C =( (B[0]&B[1]) & B[2] ) & B[3];

由于缩减运算的与、或、非运算规则类似于位运算符与、或、非运算规则,这里不再详细讲述,请参照位运算符的运算规则介绍。

优先级别

 

关键词

always， and， assign，begin，buf，bufif0，bufif1，case，casex，casez，cmos，deassign，default，defparam，disable，edge，else，end，endcase，endmodule，endfunction，endprimitive, endspecify, endtable， endtask， event， for， force， forever， fork， function，highz0， highz1, if，initial, inout, input，integer，join,large，macromodule，medium，module，nand，negedge，nmos，nor，not，notif0，notifl, or, output, parameter, pmos, posedge, primitive, pull0, pull1, pullup, pulldown, rcmos, reg, releses, repeat, mmos, rpmos, rtran, rtranif0,rtranif1,scalared,small，specify，specparam，strength，strong0, strong1, supply0, supply1, table, task, time, tran, tranif0, tranif1, tri, tri0, tri1, triand, trior， trireg，vectored，wait，wand，weak0，weak1，while， wire，wor, xnor， xor

赋值语句和块语句

信号有两种赋值方式：

(1).非阻塞(Non_Blocking)赋值方式( 如 b <= a; )

        1) 块结束后才完成赋值操作。

        2) b的值并不是立刻就改变的。

        3) 这是一种比较常用的赋值方法。（特别在编写可综合模块时）

(2).阻塞(Blocking)赋值方式( 如 b = a; )

        1) 赋值语句执行完后,块才结束。

        2) b的值在赋值语句执行完后立刻就改变的。

        3) 可能会产生意想不到的结果。

块语句

        块语句通常用来将两条或多条语句组合在一起，使其在格式上看更象一条语句。块语句有两种，一种是begin_end语句，通常用来标识顺序执行的语句，用它来标识的块称为顺序块。一种是fork_join语句，通常用来标识并行执行的语句，用它来标识的块称为并行块。下面进行详细的介绍。

一．顺序块

顺序块有以下特点：

        1) 块内的语句是按顺序执行的，即只有上面一条语句执行完后下面的语句才能执行。

        2) 每条语句的延迟时间是相对于前一条语句的仿真时间而言的。

        3) 直到最后一条语句执行完，程序流程控制才跳出该语句块。

顺序块的格式如下：

1.  
   begin
2.  
    
3.  
   语句1;
4.  
    
5.  
   语句2;
6.  
    
7.  
   ......
8.  
    
9.  
   语句n;
10.  
     
11.  
    end
12.  
     
13.  
    或
14.  
     
15.  
    begin:块名

块内声明语句

1.  
   语句1;
2.  
    
3.  
   语句2;
4.  
    
5.  
   ......
6.  
    
7.  
   语句n;
8.  
    
9.  
   end

其中：

1. 块名即该块的名字，一个标识名。其作用后面再详细介绍。
2. 块内声明语句可以是参数声明语句、reg型变量声明语句、integer型变量声明语句、real型变量声明语句。

下面举例说明：

1.  
   begin
2.  
    
3.  
   areg = breg;
4.  
    
5.  
   creg = areg; //creg的值为breg的值。
6.  
    
7.  
   end

[例]：这个例子中用顺序块和延迟控制组合来产生一个时序波形。

1.  
   parameter d=50; //声明d是一个参数
2.  
    
3.  
   reg [7:0] r; //声明r是一个8位的寄存器变量
4.  
    
5.  
   begin //由一系列延迟产生的波形
6.  
    
7.  
   #d r = 'h35;
8.  
    
9.  
   #d r = 'hE2;
10.  
     
11.  
    #d r = 'h00;
12.  
     
13.  
    #d r = 'hF7;
14.  
     
15.  
    #d -> end_wave; //触发事件end_wave
16.  
     
17.  
    end

并行块  fork  join

并行块有以下四个特点：

        1) 块内语句是同时执行的，即程序流程控制一进入到该并行块，块内语句则开始同时并行地执行。

        2) 块内每条语句的延迟时间是相对于程序流程控制进入到块内时的仿真时间的。

        3) 延迟时间是用来给赋值语句提供执行时序的。

        4) 当按时间时序排序在最后的语句执行完后或一个disable语句执行时，程序流程控制跳出该程序块。

并行块的格式如下：

1.  
   fork
2.  
    
3.  
   语句1;
4.  
    
5.  
   语句2;
6.  
    
7.  
   .......
8.  
    
9.  
   语句n;
10.  
     
11.  
    join
12.  
     
13.  
    或
14.  
     
15.  
    fork:块名
16.  
     
17.  
    块内声明语句
18.  
     
19.  
    语句1;
20.  
     
21.  
    语句2;
22.  
     
23.  
    ......
24.  
     
25.  
    语句n;
26.  
     
27.  
    join

其中：

        • 块名即标识该块的一个名字，相当于一个标识符。

        • 块内说明语句可以是参数说明语句、reg型变量声明语句、integer型变量声明语句、

real型变量声明语句、time型变量声明语句、事件(event)说明语句。

1.  
   fork
2.  
    
3.  
   #50 r = 'h35;
4.  
    
5.  
   #100 r = 'hE2;
6.  
    
7.  
   #150 r = 'h00;
8.  
    
9.  
   #200 r = 'hF7;
10.  
     
11.  
    #250 -> end_wave; //触发事件end_wave.
12.  
     
13.  
    join

        在这个例子中用并行块来替代了前面例子中的顺序块来产生波形，用这两种方法生成的波形是一样的。

        在fork_join块内，各条语句不必按顺序给出，因此在并行块里，各条语句在前还是在后是无关紧要的。

块名

在VerilgHDL语言中，可以给每个块取一个名字，只需将名字加在关键词begin或fork后面即可。这样做的原因有以下几点。

        1) 这样可以在块内定义局部变量，即只在块内使用的变量。

        2) 这样可以允许块被其它语句调用，如被disable语句。

        3) 在Verilog语言里，所有的变量都是静态的，即所有的变量都只有一个唯一的存储地址，因此进入或跳出块并不影响存储在变量内的值。

基于以上原因，块名就提供了一个在任何仿真时刻确认变量值的方法。

起始时间和结束时间

在并行块和顺序块中都有一个起始时间和结束时间的概念。对于顺序块，起始时间就是第一条语句开始被执行的时间，结束时间就是最后一条语句执行完的时间。而对于并行块来说，起始时间对于块内所有的语句是相同的，即程序流程控制进入该块的时间，其结束时间是按时间排序在最后的语句执行完的时间。

当一个块嵌入另一个块时，块的起始时间和结束时间是很重要的。至于跟在块后面的语句只有在该块的结束时间到了才能开始执行，也就是说，只有该块完全执行完后，后面的语句才可以执行。

在fork_join块内，各条语句不必按顺序给出，因此在并行块里，各条语句在前还是在后是无关紧要的。见下例：

[例]：

1.  
   fork
2.  
    
3.  
   #250 -> end_wave;
4.  
    
5.  
   #200 r = 'hF7;
6.  
    
7.  
   #150 r = 'h00;
8.  
    
9.  
   #100 r = 'hE2;
10.  
     
11.  
    #50 r = 'h35;
12.  
     
13.  
    join

在这个例子中，各条语句并不是按被执行的先后顺序给出的，但同样可以生成前面例子中的波形。

条件语句

if_else语句

        if语句是用来判定所给定的条件是否满足，根据判定的结果（真或假)决定执行给出的两种操作之一。Verilog HDL语言提供了三种形式的if语句。

五点说明：

        (1).三种形式的if语句中在if后面都有“表达式”，一般为逻辑表达式或关系表达式。系统对表达式的值进行判断，若为0,x,z，按“假”处理，若为1，按“真”处理，执行指定的语句。

        (2) .第二、第三种形式的if语句中，在每个else前面有一分号，整个语句结束处有一分号。

        (3).在if和else后面可以包含一个内嵌的操作语句(如上例)，也可以有多个操作语句，此时用begin和end这两个关键词将几个语句包含起来成为一个复合块语句。

        (4).允许一定形式的表达式简写方式。如下面的例子：

1.  
   if(expression) 等同与 if( expression == 1 )
2.  
    
3.  
   if(！expression) 等同与 if( expression != 1 )

        (5).if语句的嵌套

case语句

        case语句是一种多分支选择语句，Verilog语言提供的case语句直接处理多分支选择。case语句通常用于微处理器的指令译码,它的一般形式如下:

        1) case(表达式) <case分支项> endcase

        2) casez(表达式) <case分支项> endcase

        3) casex(表达式) <case分支项> endcase

case分支项的一般格式如下:

1.  
   分支表达式: 语句
2.  
    
3.  
   缺省项(default项): 语句

说明:

        a) case括弧内的表达式称为控制表达式，case分支项中的表达式称为分支表达式。控制表达式通常表示为控制信号的某些位，分支表达式则用这些控制信号的具体状态值来表示，因此分支表达式又可以称为常量表达式。

        b) 当控制表达式的值与分支表达式的值相等时，就执行分支表达式后面的语句。如果所有的分支表达式的值都没有与控制表达式的值相匹配的，就执行default后面的语句。

        c) default项可有可无，一个case语句里只准有一个default项。

下面是一个简单的使用case语句的例子。该例子中对寄存器rega译码以确定result的值。

1.  
   reg [15:0] rega;
2.  
    
3.  
   reg [9:0] result;
4.  
    
5.  
    
6.  
   case(rega)
7.  
    
8.  
   16 'd0: result = 10 'b0111111111;
9.  
    
10.  
    16 'd1: result = 10 'b1011111111;
11.  
     
12.  
    16 'd2: result = 10 'b1101111111;
13.  
     
14.  
    16 'd3: result = 10 'b1110111111;
15.  
     
16.  
    16 'd4: result = 10 'b1111011111;
17.  
     
18.  
    16 'd5: result = 10 'b1111101111;
19.  
     
20.  
    16 'd6: result = 10 'b1111110111;
21.  
     
22.  
    16 'd7: result = 10 'b1111111011;
23.  
     
24.  
    16 'd8: result = 10 'b1111111101;
25.  
     
26.  
    16 'd9: result = 10 'b1111111110;
27.  
     
28.  
    default： result = 'bx;
29.  
     
30.  
    endcase

        d) 每一个case分项的分支表达式的值必须互不相同，否则就会出现矛盾现象(对表达式的同一个值，有多种执行方案)。

        e) 执行完case分项后的语句，则跳出该case语句结构，终止case语句的执行。

        f) 在用case语句表达式进行比较的过程中，只有当信号的对应位的值能明确进行比较时，比较才能成功。因此要注意详细说明case分项的分支表达式的值。

        g) case语句的所有表达式的值的位宽必须相等，只有这样控制表达式和分支表达式才能进行对应位的比较。一个经常犯的错误是用'bx, 'bz 来替代 n'bx, n'bz，这样写是不对的，因为信号x, z的缺省宽度是机器的字节宽度，通常是32位(此处 n 是case控制表达式的位宽)。

下面将给出 case, casez, casex 的真值表：

由于使用条件语句不当在设计中生成了原本没想到有的锁存器

        Verilog HDL设计中容易犯的一个通病是由于不正确使用语言，生成了并不想要的锁存器。下面我们给出了一个在“always"块中不正确使用if语句，造成这种错误的例子。

        检查一下左边的"always"块，if语句保证了只有当al=1时，q才取d的值。这段程序没有写出 al = 0 时的结果, 那么当al=0时会怎么样呢？

        在"always"块内，如果在给定的条件下变量没有赋值，这个变量将保持原值，也就是说会生成一个锁存器！ 如果设计人员希望当 al = 0 时q的值为0，else项就必不可少了，请注意看右边的"always"块，整个Verilog程序模块综合出来后，"always"块对应的部分不会生成锁存器。

        Verilog HDL程序另一种偶然生成锁存器是在使用case语句时缺少default项的情况下发生的。

        case语句的功能是：在某个信号（本例中的sel)取不同的值时，给另一个信号（本例中的q)赋不同的值。注意看下图左边的例子，如果sel=0,q取a值，而sel=11,q取b的值。这个例子中不清楚的是：如果sel取00和11以外的值时q将被赋予什么值？在下面左边的这个例子中，程序是用Verilog HDL写的，即默认为q保持原值，这就会自动生成锁存器。

        右边的例子很明确，程序中的case语句有default项，指明了如果sel不取00或11时，编译器或仿真器应赋给q的值。程序所示情况下，q赋为0,因此不需要锁存器。

循环语句

在Verilog HDL中存在着四种类型的循环语句，用来控制执行语句的执行次数。

        1) forever 连续的执行语句。

        2) repeat 连续执行一条语句 n 次。

        3) while 执行一条语句直到某个条件不满足。如果一开始条件即不满足(为假)， 则语句一次也不能被执行。

        4) for通过以下三个步骤来决定语句的循环执行。

        a) 先给控制循环次数的变量赋初值。

        b) 判定控制循环的表达式的值，如为假则跳出循环语句，如为真则执行指定的语句后，转到第三步。

        c) 执行一条赋值语句来修正控制循环变量次数的变量的值，然后返回第二步。

forever语句

forever 语句;   或    

forever begin 多条语句 end

        forever循环语句常用于产生周期性的波形，用来作为仿真测试信号。它与always语句不同处在于不能独立写在程序中，而必须写在initial块中。其具体使用方法将在"事件控制"这一小节里详细地加以说明。

repeat语句

repeat语句的格式如下:

repeat(表达式) 语句； 或

repeat(表达式) begin 多条语句 end

在repeat语句中，其表达式通常为常量表达式。

while语句

while语句的格式如下：

while(表达式) 语句

或用如下格式：

while(表达式) begin 多条语句 end

for语句

for语句的一般形式为：

for（表达式1；表达式2；表达式3) 语句

它的执行过程如下：

        1) 先求解表达式1；

        2) 求解表达式2，若其值为真（非0)，则执行for语句中指定的内嵌语句，然后执行下面的第3步。若为假(0)，则结束循环，转到第5步。

        3) 若表达式为真，在执行指定的语句后，求解表达式3。

        4) 转回上面的第2步骤继续执行。

        5) 执行for语句下面的语句。

结构说明语句

Verilog语言中的任何过程模块都从属于以下四种结构的说明语句。

        1) initial说明语句

        2) always说明语句

        3) task说明语句

        4) function说明语句

        initial和always说明语句在仿真的一开始即开始执行。initial语句只执行一次。相反，always语句则是不断地重复执行，直到仿真过程结束。在一个模块中，使用initial和always语句的次数是不受限制的。task和function语句可以在程序模块中的一处或多处调用。

        一个模块中可以有多个initial块，它们都是并行运行的。initial块常用于测试文件和虚拟模块的编写，用来产生仿真测试信号和设置信号记录等仿真环境。

        always语句由于其不断重复执行的特性，只有和一定的时序控制结合在一起才有用。如果一个always语句没有时序控制，则这个always语句将会发成一个仿真死锁。

        沿触发的always块常常描述时序逻辑，如果符合可综合风格要求可用综合工具自动转换为表示时序逻辑的寄存器组和门级逻辑，而电平触发的always块常常用来描述组合逻辑和带锁存器的组合逻辑，如果符合可综合风格要求可转换为表示组合逻辑的门级逻辑或带锁存器的组合逻辑。一个模块中可以有多个always块，它们都是并行运行的。

        task和function说明语句分别用来定义任务和函数。利用任务和函数可以把一个很大的程序模块分解成许多较小的任务和函数便于理解和调试。输入、输出和总线信号的值可以传入、传出任务和函数。任务和函数往往还是大的程序模块中在不同地点多次用到的相同的程序段。学会使用task和function语句可以简化程序的结构，使程序明白易懂，是编写较大型模块的基本功。

一． task和function说明语句的不同点

任务和函数有些不同，主要的不同有以下四点：

        1) 函数只能与主模块共用同一个仿真时间单位，而任务可以定义自己的仿真时间单位。

        2) 函数不能启动任务，而任务能启动其它任务和函数。

        3) 函数至少要有一个输入变量，而任务可以没有或有多个任何类型的变量。

        4) 函数返回一个值，而任务则不返回值。

        函数的目的是通过返回一个值来响应输入信号的值。任务却能支持多种目的，能计算多个结果值，这些结果值只能通过被调用的任务的输出或总线端口送出。Verilog HDL模块使用函数时是把它当作表达式中的操作符，这个操作的结果值就是这个函数的返回值。

task说明语句

        如果传给任务的变量值和任务完成后接收结果的变量已定义，就可以用一条语句启动任务。任务完成以后控制就传回启动过程。如任务内部有定时控制，则启动的时间可以与控制返回的时间不同。任务可以启动其它的任务，其它任务又可以启动别的任务，可以启动的任务数是没有限制的。不管有多少任务启动，只有当所有的启动任务完成以后，控制才能返回。

1) 任务的定义

定义任务的语法如下：

1.  
   任务:
2.  
    
3.  
   task <任务名>;
4.  
    
5.  
   <端口及数据类型声明语句>
6.  
    
7.  
   <语句1>
8.  
    
9.  
   <语句2>
10.  
     
11.  
    .....
12.  
     
13.  
    <语句n>
14.  
     
15.  
    endtask

这些声明语句的语法与模块定义中的对应声明语句的语法是一致的。

2) 任务的调用及变量的传递

启动任务并传递输入输出变量的声明语句的语法如下：

任务的调用：

        <任务名>(端口1，端口2，...，端口n);

下面的例子说明怎样定义任务和调用任务：

1.  
   task my_task;
2.  
    
3.  
   input a, b;
4.  
    
5.  
   inout c;
6.  
    
7.  
   output d, e;
8.  
    
9.  
   …

<语句> //执行任务工作相应的语句

1.  
   …
2.  
    
3.  
   c = foo1; //赋初始值
4.  
    
5.  
   d = foo2; //对任务的输出变量赋值t
6.  
    
7.  
   e = foo3;
8.  
    
9.  
   endtask

任务调用：

my_task(v,w,x,y,z);

        任务调用变量(v,w,x,y,z)和任务定义的I/O变量(a,b,c,d,e)之间是一个一个地对应的。当任务启动时，由v,w,和x.传入的变量赋给了a,b,和c，而当任务完成后的输出又通过c,d和e赋给了x,y和z。

function说明语句

函数的目的是返回一个用于表达式的值。

定义函数的语法:

1.  
   function <返回值的类型或范围> (函数名);
2.  
    
3.  
   <端口说明语句>
4.  
    
5.  
   <变量类型说明语句>
6.  
    
7.  
   begin
8.  
    
9.  
   <语句>
10.  
     
11.  
    ........
12.  
     
13.  
    end
14.  
     
15.  
    endfunction

请注意<返回值的类型或范围>这一项是可选项，如缺省则返回值为一位寄存器类型数据。下面用例子说明：

1.  
   function [7:0] getbyte;
2.  
    
3.  
   input [15:0] address;
4.  
    
5.  
   begin
6.  
    
7.  
   <说明语句> //从地址字中提取低字节的程序
8.  
    
9.  
   getbyte = result_expression; //把结果赋予函数的返回字节
10.  
     
11.  
    end
12.  
     
13.  
    endfunction

从函数返回的值

        函数的定义蕴含声明了与函数同名的、函数内部的寄存器。如在函数的声明语句中<返回值的类型或范围>为缺省,则这个寄存器是一位的，否则是与函数定义中<返回值的类型或范围>一致的寄存器。函数的定义把函数返回值所赋值寄存器的名称初始化为与函数同名的内部变量。下面的例子说明了这个概念：getbyte被赋予的值就是函数的返回值。

函数的调用

函数的调用是通过将函数作为表达式中的操作数来实现的。

其调用格式如下：

  

      <函数名> (<表达式><,<表达式>>*)

其中函数名作为确认符。下面的例子中通过对两次调用函数getbyte的结果值进行位拼接运算来生成一个字。

word = control? {getbyte(msbyte),getbyte(lsbyte)} : 0;

函数的使用规则

与任务相比较函数的使用有较多的约束，下面给出的是函数的使用规则：

        1) 函数的定义不能包含有任何的时间控制语句，即任何用＃、@、或wait来标识的语句。

        2) 函数不能启动任务。

        3) 定义函数时至少要有一个输入参量。

        4) 在函数的定义中必须有一条赋值语句给函数中的一个内部变量赋以函数的结果值，该内部变量具有和函数名相同的名字。

系统函数和任务

Verilog HDL语言中共有以下一些系统函数和任务：

$bitstoreal, $rtoi, $display, $setup, $finish, $skew, $hold, $setuphold, $itor, $strobe, $period, $time, $printtimescale, $timefoemat, $realtime, $width, $real tobits, $write, $recovery,

$display和$write任务

格式：

$display(p1,p2,....pn);

        这两个函数和系统任务的作用是用来输出信息，即将参数p2到pn按参数p1给定的格式输出。参数p1通常称为格式控制，参数p2至pn通常称为输出表列。这两个任务的作用基本相同。$display自动地在输出后进行换行,$write则不是这样。如果想在一行里输出多个信息，可以使用$write。在$display和$write中，其输出格式控制是用双引号括起来的字符串，它包括两种信息：

        格式说明，由"%"和格式字符组成。它的作用是将输出的数据转换成指定的格式输出。格式说明总是由%字符开始的。对于不同类型的数据用不同的格式输出。表一中给出了常用的几种输出格式。

        普通字符，即需要原样输出的字符。其中一些特殊的字符可以通过表二中的转换序列来输出。下面表中的字符形式用于格式字符串参数中，用来显示特殊的字符。

如果输出列表中表达式的值包含有不确定的值或高阻值，其结果输出遵循以下规则：

        (1).在输出格式为十进制的情况下：

                • 如果表达式值的所有位均为不定值，则输出结果为小写的x。

                • 如果表达式值的所有位均为高阻值，则输出结果为小写的z。

                • 如果表达式值的部分位为不定值，则输出结果为大写的X。

                • 如果表达式值的部分位为高阻值，则输出结果为大写的Z。

        (2).在输出格式为十六进制和八进制的情况下：

               • 每4位二进制数为一组代表一位十六进制数，每3位二进制数为一组代表一位八进制数。

                • 如果表达式值相对应的某进制数的所有位均为不定值，则该位进制数的输出的结果为小写的x。

                • 如果表达式值相对应的某进制数的所有位均为高阻值，则该位进制数的输出结果为小写的z。

                • 如果表达式值相对应的某进制数的部分位为不定值，则该位进制数输出结果为大写的X。

                • 如果表达式值相对应的某进制数的部分位为高阻值，则该位进制数输出结果为大写的Z。

对于二进制输出格式，表达式值的每一位的输出结果为0、1、x、z。下面举例说明：

语句输出结果：

1.  
   $display("%d", 1'bx); 输出结果为：x
2.  
    
3.  
   $display("%h", 14'bx0_1010); 输出结果为：xxXa
4.  
    
5.  
   $display("%h %o",12'b001x_xx10_1x01,12'b001_xxx_101_x01); 输出结果为：XXX 1x5X

注意：因为$write在输出时不换行，要注意它的使用。可以在$write中加入换行符\n，以确保明确的输出显示格式。

系统任务$monitor

格式：

1.  
   $monitor(p1,p2,.....，pn);
2.  
    
3.  
   $monitor;
4.  
    
5.  
   $monitoron;
6.  
    
7.  
   $monitoroff;

        任务$monitor提供了监控和输出参数列表中的表达式或变量值的功能。其参数列表中输出控制格式字符串和输出表列的规则和$display中的一样。当启动一个带有一个或多个参数的$monitor任务时，仿真器则建立一个处理机制，使得每当参数列表中变量或表达式的值发生变化时，整个参数列表中变量或表达式的值都将输出显示。如果同一时刻，两个或多个参数的值发生变化，则在该时刻只输出显示一次。但在$monitor中，参数可以是$time系统函数。这样参数列表中变量或表达式的值同时发生变化的时刻可以通过标明同一时刻的多行输出来显示。如：

$monitor($time,,"rxd=%b txd=%b",rxd,txd);

        在$display中也可以这样使用。注意在上面的语句中，“,,"代表一个空参数。空参数在输出时显示为空格。

        $monitoron和$monitoroff任务的作用是通过打开和关闭监控标志来控制监控任务$monitor的启动和停止,这样使得程序员可以很容易的控制$monitor何时发生。

        通常在通过调用$monitoron启动$monitor时，不管$monitor参数列表中的值是否发生变化，总是立刻输出显示当前时刻参数列表中的值，这用于在监控的初始时刻设定初始比较值。在缺省情况下，控制标志在仿真的起始时刻就已经打开了。在多模块调试的情况下，许多模块中都调用了$monitor,因为任何时刻只能有一个$monitor起作用，因此需配合$monitoron与$monitoroff使用，把需要监视的模块用$monitoron打开，在监视完毕后及时用$monitoroff关闭，以便把$monitor 让给其他模块使用。$monitor与$display的不同处还在于$monitor往往在initial块中调用，只要不调用$monitoroff,$monitor便不间断地对所设定的信号进行监视。

时间度量系统函数$time

        在Verilog HDL中有两种类型的时间系统函数：$time和$realtime。用这两个时间系统函数可以得到当前的仿真时刻。

        $time可以返回一个64比特的整数来表示的当前仿真时刻值。该时刻是以模块的仿真时间尺度为基准的。下面举例说明。

[例]：

1.  
   `timescale 10ns/1ns
2.  
    
3.  
   module test;
4.  
    
5.  
   reg set;
6.  
    
7.  
   parameter p=1.6;
8.  
    
9.  
   initial
10.  
     
11.  
    begin
12.  
     
13.  
    $monitor($time,,"set=",set);
14.  
     
15.  
    #p set=0;
16.  
     
17.  
    #p set=1;
18.  
     
19.  
    end
20.  
     
21.  
    endmodule
22.  
     
23.  
     
24.  
     
25.  
    输出结果为：
26.  
     
27.  
    0 set=x
28.  
     
29.  
    2 set=0
30.  
     
31.  
    3 set=1

在这个例子中，模块test想在时刻为16ns时设置寄存器set为0，在时刻为32ns时设置寄存器set为1。但是由$time记录的set变化时刻却和预想的不一样。这是由下面两个原因引起的：

        1) $time显示时刻受时间尺度比例的影响。在上面的例子中，时间尺度是10ns，因为$time输出的时刻总是时间尺度的倍数，这样将16ns和32ns输出为1.6和3.2。

        2) 因为$time总是输出整数，所以在将经过尺度比例变换的数字输出时，要先进行取整。在上面的例子中，1.6和3.2经取整后为2和3输出。注意：时间的精确度并不影响数字的取整。

$realtime系统函数

        $realtime和$time的作用是一样的，只是$realtime返回的时间数字是一个实型数，该数字也是以时间尺度为基准的。下面举例说明：

[例]:

1.  
   `timescale10ns/1ns
2.  
    
3.  
   module test;
4.  
    
5.  
   reg set;
6.  
    
7.  
   parameter p=1.55;
8.  
    
9.  
   initial
10.  
     
11.  
    begin
12.  
     
13.  
    $monitor($realtime,,"set=",set);
14.  
     
15.  
    #p set=0;
16.  
     
17.  
    #p set=1;
18.  
     
19.  
    end
20.  
     
21.  
    endmodule

输出结果为：

 

系统任务$finish

格式：

1.  
   $finish;
2.  
    
3.  
   $finish(n);

系统任务$finish的作用是退出仿真器，返回主操作系统，也就是结束仿真过程。任务$finish可以带参数，根据参数的值输出不同的特征信息。如果不带参数，默认$finish的参数值为1。下面给出了对于不同的参数值，系统输出的特征信息：

        0 不输出任何信息

@hh...h

reg[7:0] mem[1:256];

`define signal string

`include “文件名”

'include "fileB" 'include "fileC" //including fileB and fileC

 `timescale<时间单位>/<时间精度>

 `timescale 1ns/1ps

 `timescale 10us/100ns

# time (触发的时刻〕－>(事件名)