Verilog HDL简介
Verilog HDL（简称 Verilog ）是一种硬件描述语言，用于数字电路的系统设计。可对算法级、门级、开关级等多种抽象设计层次进行建模。
Verilog 继承了 C 语言的多种操作符和结构，与另一种硬件描述语言 VHDL 相比，语法不是很严格，代码更加简洁，更容易上手。
Verilog 不仅定义了语法，还对语法结构都定义了清晰的仿真语义。因此，Verilog 编写的数字模型就能够使用 Verilog 仿真器进行验证。
学习 Verilog 做仿真时，可选择不同仿真环境。FPGA 开发环境有 Xilinx 公司的 ISE（目前已停止更新），VIVADO；因特尔公司的 Quartus II；ASIC 开发环境有 Synopsys 公司的 VCS ；很多人也在用 Icarus Verilog 和 GTKwave 的方法，更加的轻便。
Verilog 的设计多采用自上而下的设计方法（top-down）。即先定义顶层模块功能，进而分析要构成顶层模块的必要子模块；然后进一步对各个模块进行分解、设计，直到到达无法进一步分解的底层功能块。这样，可以把一个较大的系统，细化成多个小系统，从时间、工作量上分配给更多的人员去设计，从而提高了设计速度，缩短了开发周期。
-
设计流程
Verilog 的设计流程，一般包括以下几个步骤：
- 需求分析
工作人员需要对用户提出的功能要求进行分析理解，做出电路系统的整体规划，形成详细的技术指标，确定初步方案。例如，要设计一个电子屏，需要考虑供电方式、工作频率、产品体积、成本、功耗等，电路实现采用 ASIC 还是选用 FPGA/CPLD 器件等。
- 功能划分
正确地分析了用户的电路需求后，就可以进行逻辑功能的总体设计，设计整个电路的功能、接口和总体结构，考虑功能模块的划分和设计思路，各子模块的接口和时序（包括接口时序和内部信号的时序）等，向项目组成员合理分配子模块设计任务。
- 文本描述
可以用任意的文本编辑器，也可以用专用的 HDL 编辑环境，对所需求的数字电路进行设计建模，保存为 .v 文件。
- 功能仿真（前仿真）
对建模文件进行编译，对模型电路进行功能上的仿真验证，查找设计的错误并修正。
此时的仿真验证并没有考虑到信号的延迟等一些 timing 因素，只是验证逻辑上的正确性。
- 逻辑综合
综合（synthesize），就是在标准单元库和特定的设计约束的基础上，将设计的高层次描述（Verilog 建模）转换为门级网表的过程。逻辑综合的目的是产生物理电路门级结构，并在逻辑、时序上进行一定程度的优化，寻求逻辑、面积、功耗的平衡，增强电路的可测试性。
但不是所有的 Verilog 语句都是可以综合成逻辑单元的，例如时延语句。
- 布局布线
根据逻辑综合出的网表与约束文件，利用厂家提供的各种基本标准单元库，对门级电路进行布局布线。至此，已经将 Verilog 设计的数字电路，设计成由标准单元库组成的数字电路。
- 时序仿真（后仿真）
布局布线后，电路模型中已经包含了时延信息。利用在布局布线中获得的精确参数，用仿真软件验证电路的时序。单元器件的不同、布局布线方案都会给电路的时序造成影响，严重时会出现错误。出错后可能就需要重新修改 RTL（寄存器传输级描述，即 Verilog 初版描述），重复后面的步骤。这样的过程可能反复多次，直至错误完全排除。
- FPGA/CPLD 下载或 ASIC 制造工艺生产
完成上面所有步骤后，就可以通过开发工具将设计的数字电路目标文件下载到 FPGA/CPLD 芯片中，然后在电路板上进行调试、验证。
如果要在 ASIC 上实现，则需要制造芯片。一般芯片制造时，也需要先在 FPGA 板卡上进行逻辑功能的验证。
基础语法
数值表示
数值种类
Verilog HDL 有下列四种基本的值来表示硬件电路中的电平逻辑：
- 0：逻辑 0 或 "假"
- 1：逻辑 1 或 "真"
- x 或 X：未知
- z 或 Z：高阻
x 意味着信号数值的不确定，即在实际电路里，信号可能为 1，也可能为 0。
z 意味着信号处于高阻状态，常见于信号（input, reg）没有驱动时的逻辑结果。例如一个 pad 的 input 呈现高阻状态时，其逻辑值和上下拉的状态有关系。上拉则逻辑值为 1，下拉则为 0 。
整数数值表示方法
数字声明时，合法的基数格式有 4 中，包括：十进制('d 或 'D)，十六进制('h 或 'H)，二进制（'b 或 'B），八进制（'o 或 'O）。数值可指明位宽，也可不指明位宽。
- 指明位宽：
4'b1011 // 4bit 数值
32'h3022_c0de // 32bit 的数值
其中，下划线 _ 是为了增强代码的可读性。
- 不指明位宽:
一般直接写数字时，默认为十进制表示，例如下面的 3 种写法是等效的：
counter = 'd100 ; //一般会根据编译器自动分频位宽，常见的为32bit
counter = 100 ;
counter = 32'h64 ;
- 负数表示
通常在表示位宽的数字前面加一个减号来表示负数。例如：
-6'd15
-15
-15 在 5 位二进制中的形式为 5'b10001, 在 6 位二进制中的形式为 6'b11_0001。
需要注意的是，减号放在基数和数字之间是非法的，例如下面的表示方法是错误的：
4'd-2 //非法说明
- 实数表示方法
实数表示方法主要有两种方式：
十进制：
30.123
6.0
3.0
0.001
科学计数法：
1.2e4 //大小为12000
1_0001e4 //大小为100010000
1E-3 //大小为0.001
- 字符串表示方法
字符串是由双引号包起来的字符队列。字符串不能多行书写，即字符串中不能包含回车符。Verilog 将字符串当做一系列的单字节 ASCII 字符队列。例如，为存储字符串 "www.runoob.com", 需要 14*8byte 的存储单元。例如：
reg [0: 14*8-1] str ;
assign str = "www.runoob.com";
数据类型
Verilog 最常用的 2 种数据类型就是线网（wire）与寄存器（reg），其余类型可以理解为这两种数据类型的扩展或辅助。
- 线网（wire）
wire 类型表示硬件单元之间的物理连线，由其连接的器件输出端连续驱动。如果没有驱动元件连接到 wire 型变量，缺省值一般为 "Z"。举例如下：
wire interrupt ;
wire flag1, flag2 ;
wire gnd = 1'b0 ;
线网型还有其他数据类型，包括 wand，wor，wri，triand，trior，trireg 等。这些数据类型用的频率不是很高，这里不做介绍。
- 寄存器（reg）
寄存器（reg）用来表示存储单元，它会保持数据原有的值，直到被改写。声明举例如下：
reg clk_temp;
reg flag1, flag2 ;
例如在 always 块中，寄存器可能被综合成边沿触发器，在组合逻辑中可能被综合成 wire 型变量。寄存器不需要驱动源，也不一定需要时钟信号。在仿真时，寄存器的值可在任意时刻通过赋值操作进行改写。例如：
reg rstn ;
initial begin
rstn = 1'b0 ;
#100 ;
rstn = 1'b1 ;
end
- 向量
当位宽大于 1 时，wire 或 reg 即可声明为向量的形式。例如：
reg [3:0] counter ; //声明4bit位宽的寄存器counter
wire [32-1:0] gpio_data; //声明32bit位宽的线型变量gpio_data
wire [8:2] addr ; //声明7bit位宽的线型变量addr，位宽范围为8:2
reg [0:31] data ; //声明32bit位宽的寄存器变量data, 最高有效位为0
对于上面的向量，我们可以指定某一位或若干相邻位，作为其他逻辑使用。例如：
wire [9:0] data_low = data[0:9] ;
addr_temp[3:2] = addr[8:7] + 1'b1 ;
Verilog 支持可变的向量域选择，例如：
reg [31:0] data1 ;
reg [3:0] byte1 [7:0];
integer j ;
always@* begin
for (j=0; j<=31;j=j+1) begin
byte1[j] = data1[(j+1)*8-1 : j*8];
//把data1[7:0]…data1[31:24]依次赋值给byte1[0][7:0]…byte[3][7:0]
end
end
Verillog 还支持指定 bit 位后固定位宽的向量域选择访问。
[bit+: width] : 从起始 bit 位开始递增，位宽为 width。
[bit-: width] : 从起始 bit 位开始递减，位宽为 width。
//下面 2 种赋值是等效的
A = data1[31-: 8] ;
A = data1[31:24] ;
//下面 2 种赋值是等效的
B = data1[0+ : 8] ;
B = data1[0:7] ;
对信号重新进行组合成新的向量时，需要借助大括号。例如：
wire [31:0] temp1, temp2 ;
assign temp1 = {byte1[0][7:0], data1[31:8]}; //数据拼接
assign temp2 = {32{1'b0}}; //赋值32位的数值0
- 整数，实数，时间寄存器变量
整数，实数，时间等数据类型实际也属于寄存器类型。
整数（integer）
整数类型用关键字 integer 来声明。声明时不用指明位宽，位宽和编译器有关，一般为32 bit。reg 型变量为无符号数，而 integer 型变量为有符号数。例如：
reg [31:0] data1 ;
reg [3:0] byte1 [7:0]; //数组变量，后续介绍
integer j ; //整型变量，用来辅助生成数字电路
always@* begin
for (j=0; j<=31;j=j+1) begin
byte1[j] = data1[(j+1)*8-1 : j*8];
//把data1[7:0]…data1[31:24]依次赋值给byte1[0][7:0]…byte[3][7:0]
end
end
此例中，integer 信号 j 作为辅助信号，将 data1 的数据依次赋值给数组 byte1。综合后实际电路里并没有 j 这个信号，j 只是辅助生成相应的硬件电路。
实数（real）
实数用关键字 real 来声明，可用十进制或科学计数法来表示。实数声明不能带有范围，默认值为 0。如果将一个实数赋值给一个整数，则只有实数的整数部分会赋值给整数。例如：
real data1 ;
integer temp ;
initial begin
data1 = 2e3 ;
data1 = 3.75 ;
end
initial begin
temp = data1 ; //temp 值的大小为3
end
时间（time）
Verilog 使用特殊的时间寄存器 time 型变量，对仿真时间进行保存。其宽度一般为 64 bit，通过调用系统函数 $time 获取当前仿真时间。例如：
time current_time ;
initial begin
#100 ;
current_time = $time ; //current_time 的大小为 100
end
- 数组
在 Verilog 中允许声明 reg, wire, integer, time, real 及其向量类型的数组。
数组维数没有限制。线网数组也可以用于连接实例模块的端口。数组中的每个元素都可以作为一个标量或者向量，以同样的方式来使用，形如：<数组名>[<下标>]。对于多维数组来讲，用户需要说明其每一维的索引。例如：
integer flag [7:0] ; //8个整数组成的数组
reg [3:0] counter [3:0] ; //由4个4bit计数器组成的数组
wire [7:0] addr_bus [3:0] ; //由4个8bit wire型变量组成的数组
wire data_bit[7:0][5:0] ; //声明1bit wire型变量的二维数组
reg [31:0] data_4d[11:0][3:0][3:0][255:0] ; //声明4维的32bit数据变量数组
下面显示了对数组元素的赋值操作：
flag [1] = 32'd0 ; //将flag数组中第二个元素赋值为32bit的0值
counter[3] = 4'hF ; //将数组counter中第4个元素的值赋值为4bit 十六进制数F，等效于counter[3][3:0] = 4'hF，即可省略宽度;
assign addr_bus[0] = 8'b0 ; //将数组addr_bus中第一个元素的值赋值为0
assign data_bit[0][1] = 1'b1; //将数组data_bit的第1行第2列的元素赋值为1，这里不能省略第二个访问标号，即 assign data_bit[0] = 1'b1; 是非法的。
data_4d[0][0][0][0][15:0] = 15'd3 ; //将数组data_4d中标号为[0][0][0][0]的寄存器单元的15~0bit赋值为3
虽然数组与向量的访问方式在一定程度上类似，但不要将向量和数组混淆。向量是一个单独的元件，位宽为 n；数组由多个元件组成，其中每个元件的位宽为 n 或 1。它们在结构的定义上就有所区别。
- 存储器
存储器变量就是一种寄存器数组，可用来描述 RAM 或 ROM 的行为。例如：
reg membit[0:255] ; //256bit的1bit存储器
reg [7:0] mem[0:1023] ; //1Kbyte存储器，位宽8bit
mem[511] = 8'b0 ; //令第512个8bit的存储单元值为0
- 参数
参数用来表示常量，用关键字 parameter 声明，只能赋值一次。例如：
parameter data_width = 10'd32 ;
parameter i=1, j=2, k=3 ;
parameter mem_size = data_width * 10 ;
但是，通过实例化的方式，可以更改参数在模块中的值。此部分以后会介绍。
局部参数用 localparam 来声明，其作用和用法与 parameter 相同，区别在于它的值不能被改变。所以当参数只在本模块中调用时，可用 localparam 来说明。
- 字符串
字符串保存在 reg 类型的变量中，每个字符占用一个字节（8bit）。因此寄存器变量的宽度应该足够大，以保证不会溢出。
字符串不能多行书写，即字符串中不能包含回车符。如果寄存器变量的宽度大于字符串的大小，则使用 0 来填充左边的空余位；如果寄存器变量的宽度小于字符串大小，则会截去字符串左边多余的数据。例如，为存储字符串 "run.runoob.com", 需要 14*8byte 的存储单元：
reg [0: 14*8-1] str ;
assign str = "run.runoob.com";
有一些特殊字符在显示字符串中有特殊意义，例如换行符，制表符等。如果需要在字符串中显示这些特殊的字符，则需要在前面加前缀转义字符 \ 。
表达式
- 表达式
表达式由操作符和操作数构成，其目的是根据操作符的意义得到一个计算结果。表达式可以在出现数值的任何地方使用。例如：
a^b ; //a与b进行异或操作
address[9:0] + 10'b1 ; //地址累加
flag1 && flag2 ; //逻辑与操作
- 操作数
操作数可以是任意的数据类型，只是某些特定的语法结构要求使用特定类型的操作数。操作数可以为常数，整数，实数，线网，寄存器，时间，位选，域选，存储器及函数调用等。
module test;
//实数
real a, b, c;
c = a + b ;
//寄存器
reg [3:0] cprmu_1, cprmu_2 ;
always @(posedge clk) begin
cprmu_2 = cprmu_1 ^ cprmu_2 ;
end
//函数
reg flag1 ;
flag = calculate_result(A, B);
//非法操作数
reg [3:0] res;
wire [3:0] temp;
always@ （*）begin
res = cprmu_2 – cprmu_1 ;
//temp = cprmu_2 – cprmu_1 ; //不合法，always块里赋值对象不能是wire型
end
endmodule
- 操作符
Verilog 中提供了大约 9 种操作符，分别是算术、关系、等价、逻辑、按位、归约、移位、拼接、条件操作符。大部分操作符与 C 语言中类似。同类型操作符之间，除条件操作符从右往左关联，其余操作符都是自左向右关联。圆括号内表达式优先执行。例如下面每组的 2 种写法都是等价的。
A+B-C ;
(A+B）-C ;
A ? B : C ? D : F ;
A ? B : (C ? D : F) ;
(A ? B : C) ? D : F ;
A ? B : C ? D : F ;
不同操作符之间，优先级是不同的。下表列出了操作符优先级从高至低的排列顺序。当没有圆括号时，Verilog 会根据操作符优先级对表达式进行计算。为了避免由操作符优先级导致的计算混乱，在不确定优先级时，建议用圆括号将表达式区分开来。
- 算术操作符
算术操作符包括单目操作符和双目操作符。双目操作符对 2 个操作数进行算术运算，包括乘（*）、除（/）、加（+）、减（-）、求幂（**）、取模（%）。
reg [3:0] a, b;
reg [4:0] c ;
a = 4'b0010 ;
b = 4'b1001 ;
c = a+b; //结果为c=b'b1011
c = a/b; //结果为c=4，取整
如果操作数某一位为 X，则计算结果也会全部出现 X。例如：
b = 4'b100x ;
c = a+b ; //结果为c=4'bxxxx
对变量进行声明时，要根据变量的操作符对变量的位宽进行合理声明，不要让结果溢出。上述例子中，相加的 2 个变量位宽为 4bit，那么结果寄存器变量位宽最少为 5bit。否则，高位将被截断，导致结果高位丢失。无符号数乘法时，结果变量位宽应该为 2 个操作数位宽之和。
reg [3:0] mula ;
reg [1:0] mulb;
reg [5:0] res ;
mula = 4'he ;
mulb = 2'h3 ;
res = mula * mulb ; //结果为res=6'h2a, 数据结果没有丢失位数
+和 - 也可以作为单目操作符来使用，表示操作数的正负性。此类操作符优先级最高。
-4 //表示负4
+3 //表示正3
负数表示时，可以直接在十进制数字前面增加一个减号 -，也可以指定位宽。因为负数使用二进制补码来表示，不指定位宽来表示负数，编译器在转换时，会自动分配位宽，从而导致意想不到的结果。例如：
mula = -4'd4 ;
mulb = 2 ;
res = mula * mulb ; //计算结果为res=-6'd8, 即res=6'h38，正常
res = mula * (-'d4) ; //(4的32次幂-4) * 2, 结果异常
- 关系操作符
关系操作符有大于（>），小于（<），大于等于（>=），小于等于（<=）。关系操作符的正常结果有 2 种，真（1）或假（0）。
如果操作数中有一位为 x 或 z，则关系表达式的结果为 x。
A = 4 ;
B = 3 ;
X = 3'b1xx ;
A > B //为真
A <= B //为假
A >= Z //为X，不确定
- 等价操作符
等价操作符包括逻辑相等（==），逻辑不等（!=），全等（===），非全等（!==）。等价操作符的正常结果有 2 种：为真（1）或假（0）。
逻辑相等/不等操作符不能比较 x 或 z，当操作数包含一个 x 或 z，则结果为 x。
全等比较时，如果按位比较有相同的 x 或 z，返回结果也可以为 1，即全等比较可比较 x 或 z。所以，全等比较的结果一定不包含 x。举例如下：
A = 4 ;
B = 8'h04 ;
C = 4'bxxxx ;
D = 4'hx ;
A == B //为真
A == (B + 1) //为假
A == C //为X，不确定
A === C //为假，返回值为0
C === D //为真，返回值为1
- 逻辑操作符
逻辑操作符主要有 3 个：&&（逻辑与）, ||（逻辑或），!（逻辑非）。
逻辑操作符的计算结果是一个 1bit 的值，0 表示假，1 表示真，x 表示不确定。
如果一个操作数不为 0，它等价于逻辑 1；如果一个操作数等于 0，它等价于逻辑 0。如果它任意一位为 x 或 z，它等价于 x。
如果任意一个操作数包含 x，逻辑操作符运算结果不一定为 x。
逻辑操作符的操作数可以为变量，也可以为表达式。例如：
A = 3;
B = 0;
C = 2'b1x ;
A && B // 为假
A || B // 为真
! A // 为假
! B // 为真
A && C // 为X，不确定
A || C // 为真，因为A为真
(A==2) && (! B) //为真，此时第一个操作数为表达式
- 按位操作符
按位操作符包括：取反（），与（&），或（|），异或（^），同或（^）。按位操作符对 2 个操作数的每 1bit 数据进行按位操作。如果 2 个操作数位宽不相等，则用 0 向左扩展补充较短的操作数。取反操作符只有一个操作数，它对操作数的每 1bit 数据进行取反操作。
下图给出了按位操作符的逻辑规则。
A = 4'b0101 ;
B = 4'b1001 ;
C = 4'bx010 ;
~A //4'b1010
A & B //4'b0001
A | B //4'b1101
A^B //4'b1100
A ~^ B //4'b0011
B | C //4'b1011
B&C //4'bx000
- 归约操作符
归约操作符包括：归约与（&），归约与非（&），归约或（|），归约或非（|），归约异或（），归约同或（~）。归约操作符只有一个操作数，它对这个向量操作数逐位进行操作，最终产生一个 1bit 结果。逻辑操作符、按位操作符和归约操作符都使用相同的符号表示，因此有时候容易混淆。区分这些操作符的关键是分清操作数的数目，和计算结果的规则。
A = 4'b1010 ;
&A ; //结果为 1 & 0 & 1 & 0 = 1'b0，可用来判断变量A是否全1
~|A ; //结果为 ~(1 | 0 | 1 | 0) = 1'b0, 可用来判断变量A是否为全0
^A ; //结果为 1 ^ 0 ^ 1 ^ 0 = 1'b0
- 移位操作符
移位操作符包括左移（<<），右移（>>），算术左移（<<<），算术右移（>>>）。移位操作符是双目操作符，两个操作数分别表示要进行移位的向量信号（操作符左侧）与移动的位数（操作符右侧）。算术左移和逻辑左移时，右边低位会补 0。算术右移时，左边高位会补 0；而逻辑右移时，左边高位会补充符号位，以保证数据缩小后值的正确性。
A = 4'b1100 ;
B = 4'b0010 ;
A = A >> 2 ; //结果为 4'b0011
A = A << 1; //结果为 4'b1000
A = A <<< 1 ; //结果为 4'b1000
C = B + (A>>>2); //结果为 2 + (-4/4) = 1, 4'b0001
- 拼接操作符
拼接操作符用大括号 {，} 来表示，用于将多个操作数（向量）拼接成新的操作数（向量），信号间用逗号隔开。拼接符操作数必须指定位宽，常数的话也需要指定位宽。例如：
A = 4'b1010 ;
B = 1'b1 ;
Y1 = {B, A[3:2], A[0], 4'h3 }; //结果为Y1='b1100_0011
Y2 = {4{B}, 3'd4}; //结果为 Y2=7'b111_1100
Y3 = {32'{1'b0}}; //结果为 Y3=32h0，常用作寄存器初始化时匹配位宽的赋初值
- 条件操作符
条件表达式有 3 个操作符，结构描述如下：
condition_expression ? true_expression : false_expression
计算时，如果 condition_expression 为真（逻辑值为 1），则运算结果为 true_expression；如果 condition_expression 为假（逻辑值为 0），则计算结果为 false_expression。
assign hsel = (addr[9:8] = 2'b0) ? hsel_p1 : hsel_p2 ;
//当信号 addr 高 2bit 为 0 时，hsel 赋值为 hsel_p1; 否则，将 hsel_p2 赋值给 hsel。
其实，条件表达式类似于 2 路（或多路）选择器，其描述方式完全可以用 if-else 语句代替。
当然条件操作符也能进行嵌套，完成一个多次选择的逻辑。例如：
assign hsel = (addr[9:8] = 2'b00) ? hsel_p1 :
(addr[9:8] = 2'b01) ? hsel_p2 :
(addr[9:8] = 2'b10) ? hsel_p3 :
(addr[9:8] = 2'b11) ? hsel_p4 ;
编译指令
以反引号 ` 开始的某些标识符是 Verilog 系统编译指令。
编译指令为 Verilog 代码的撰写、编译、调试等提供了极大的便利。
- `define, `undef
在编译阶段，`define 用于文本替换，类似于 C 语言中的 #define。
一旦 `define 指令被编译，其在整个编译过程中都会有效。例如，在一个文件中定义：
`define DATA_DW 32
则在另一个文件中也可以直接使用 DATA_DW。
`define S $stop;
//用`S来代替系统函数$stop; (包括分号)
`define WORD_DEF reg [31:0]
//可以用`WORD_DEF来声明32bit寄存器变量
`undef 用来取消之前的宏定义，例如：
`define DATA_DW 32
……
reg [DATA_DW-1:0] data_in ;
……
`undef DATA_DW
`ifdef, `ifndef, `elsif, `else, `endif
这些属于条件编译指令。例如下面的例子中，如果定义了 MCU51，则使用第一种参数说明；如果没有定义 MCU、定义了 WINDOW，则使用第二种参数说明；如果 2 个都没有定义，则使用第三种参数说明。
`ifdef MCU51
parameter DATA_DW = 8 ;
`elsif WINDOW
parameter DATA_DW = 64 ;
`else
parameter DATA_DW = 32 ;
`endif
`elsif, `else 编译指令对于 `ifdef 指令是可选的，即可以只有 `ifdef 和 `endif 组成一次条件编译指令块。
当然，也可用 `ifndef 来设置条件编译，表示如果没有相关的宏定义，则执行相关语句。
下面例子中，如果定义了 WINDOW，则使用第二种参数说明。如果没有定义 WINDOW，则使用第一种参数说明。
`ifndef WINDOW
parameter DATA_DW = 32 ;
`else
parameter DATA_DW = 64 ;
`endif
- `include
使用 `include 可以在编译时将一个 Verilog 文件内嵌到另一个 Verilog 文件中，作用类似于 C 语言中的 #include 结构。该指令通常用于将全局或公用的头文件包含在设计文件里。
文件路径既可以使用相对路径，也可以使用绝对路径。
`include "../../param.v"
`include "header.v"
- `timescale
在 Verilog 模型中，时延有具体的单位时间表述，并用 `timescale 编译指令将时间单位与实际时间相关联。
该指令用于定义时延、仿真的单位和精度，格式为：
`timescale time_unit / time_precision
time_unit 表示时间单位，time_precision 表示时间精度，它们均是由数字以及单位 s（秒），ms（毫秒），us（微妙），ns（纳秒），ps（皮秒）和 fs（飞秒）组成。时间精度可以和时间单位一样，但是时间精度大小不能超过时间单位大小，例如下面例子中，输出端 Z 会延迟 5.21ns 输出 A&B 的结果。
`timescale 1ns/100ps //时间单位为1ns，精度为100ps，合法
//`timescale 100ps/1ns //不合法
module AndFunc(Z, A, B);
output Z;
input A, B ;
assign #5.207 Z = A & B
endmodule
在编译过程中，`timescale 指令会影响后面所有模块中的时延值，直至遇到另一个 `timescale 指令或 `resetall 指令。
由于在 Verilog 中没有默认的 `timescale，如果没有指定 `timescale，Verilog 模块就有会继承前面编译模块的 `timescale 参数。有可能导致设计出错。
如果一个设计中的多个模块都带有 `timescale 时，模拟器总是定位在所有模块的最小时延精度上，并且所有时延都相应地换算为最小时延精度，时延单位并不受影响。例如:
`timescale 10ns/1ns
module test;
reg A, B ;
wire OUTZ ;
initial begin
A = 1;
B = 0;
# 1.28 B = 1;
# 3.1 A = 0;
end
AndFunc u_and(OUTZ, A, B) ;
endmodule
在模块 AndFunc 中，5.207 对应 5.21ns。
在模块 test 中，1.28 对应 13ns，3.1 对应 31ns。
但是，当仿真 test 时，由于 AndFunc 中的最小精度为 100ps，因此 test 中的时延精度将进行重新调整。13ns 将对应 130100ps，31ns 将对应 310100ps。仿真时，时延精度也会使用 100ps。仿真时间单位大小没有影响。
如果有并行子模块，子模块间的 `timescale 并不会相互影响。
例如在模块 test 中再例化一个子模块 OrFunc。仿真 test 时，OrFunc 中的 #5.207 延时依然对应 52ns。
//子模块：
`timescale 10ns/1ns //时间单位为1ns，精度为100ps，合法
module OrFunc(Z, A, B);
output Z;
input A, B ;
assign #5.207 Z = A | B
endmodule
//顶层模块：
`timescale 10ns/1ns
module test;
reg A, B ;
wire OUTZ ;
wire OUTX ;
initial begin
A = 1;
B = 0;
# 1.28 B = 1;
# 3.1 A = 0;
end
AndFunc u_and(OUTZ, A, B) ;
OrFunc u_and(OUTX, A, B) ;
endmodule
此例中，仿真 test 时，OrFunc 中的 #5.207 延时依然对应 52ns。
`timescale 的时间精度设置是会影响仿真时间的。时间精度越小，仿真时占用内存越多，实际使用的仿真时间就越长。所以如果没有必要，应尽量将时间精度设置的大一些。
- `default_nettype
该指令用于为隐式的线网变量指定为线网类型，即将没有被声明的连线定义为线网类型。
`default_nettype wand
该实例定义的缺省的线网为线与类型。因此，如果在此指令后面的任何模块中的连线没有说明，那么该线网被假定为线与类型。
`default_nettype none
该实例定义后，将不再自动产生 wire 型变量。
例如下面第一种写法编译时不会报 Error，第二种写法编译将不会通过。
//Z1 无定义就使用，系统默认Z1为wire型变量，有 Warning 无 Error
module test_and(
input A,
input B,
output Z);
assign Z1 = A & B ;
endmodule
//Z1无定义就使用，由于编译指令的存在，系统会报Error，从而检查出书写错误
`default_nettype none
module test_and(
input A,
input B,
output Z);
assign Z1 = A & B ;
endmodule
- `resetall
该编译器指令将所有的编译指令重新设置为缺省值。
`resetall 可以使得缺省连线类型为线网类型。
当 `resetall 加到模块最后时，可以将当前的 `timescale 取消防止进一步传递，只保证当前的 `timescale 在局部有效，避免 `timescale 的错误继承。
- `celldefine, `endcelldefine
这两个程序指令用于将模块标记为单元模块，他们包含模块的定义。例如一些与、或、非门，一些 PLL 单元，PAD 模型，以及一些 Analog IP 等。
`celldefine
module (
input clk,
input rst,
output clk_pll,
output flag);
……
endmodule
`endcelldefine
- `unconnected_drive, `nounconnected_drive
在模块实例化中，出现在这两个编译指令间的任何未连接的输入端口，为正偏电路状态或者为反偏电路状态。
`unconnected_drive pull1
. . .
/ *在这两个程序指令间的所有未连接的输入端口为正偏电路状态（连接到高电平） * /
`nounconnected_drive
`unconnected_drive pull0
. . .
/ *在这两个程序指令间的所有未连接的输入端口为反偏电路状态（连接到低电平） * /
`nounconnected_drive
连续赋值
- 关键词：assign， 全加器
连续赋值语句是 Verilog 数据流建模的基本语句，用于对 wire 型变量进行赋值。：
assign LHS_target = RHS_expression ；
LHS（left hand side） 指赋值操作的左侧，RHS（right hand side）指赋值操作的右侧。
assign 为关键词，任何已经声明 wire 变量的连续赋值语句都是以 assign 开头，例如：
wire Cout, A, B ;
assign Cout = A & B ; //实现计算A与B的功能
需要说明的是：
LHS_target 必须是一个标量或者线型向量，而不能是寄存器类型。
RHS_expression 的类型没有要求，可以是标量或线型或存器向量，也可以是函数调用。
只要 RHS_expression 表达式的操作数有事件发生（值的变化）时，RHS_expression 就会立刻重新计算，同时赋值给 LHS_target。
Verilog 还提供了另一种对 wire 型赋值的简单方法，即在 wire 型变量声明的时候同时对其赋值。wire 型变量只能被赋值一次，因此该种连续赋值方式也只能有一次。例如下面赋值方式和上面的赋值例子的赋值方式，效果都是一致的。
wire A, B ;
wire Cout = A & B ;
- 全加器
下面采用数据流描述方式，来设计一个 1bit 全加器。
设 Ai，Bi，Ci 分别为被加数、加数和相邻低位的进位数，So, Co 分别为本位和与向相邻高位的进位数。
真值表如下：
全加器的表达式为：
So = Ai ⊕ Bi ⊕ Ci ;
Co = AiBi + Ci(Ai+Bi)
rtl 代码（full_adder1.v）如下：
module full_adder1(
input Ai, Bi, Ci,
output So, Co);
assign So = Ai ^ Bi ^ Ci ;
assign Co = (Ai & Bi) | (Ci & (Ai | Bi));
endmodule
当然，更为贴近加法器的代码描述可以为：
module full_adder1(
input Ai, Bi, Ci
output So, Co);
assign {Co, So} = Ai + Bi + Ci ;
endmodule
时延
- 关键词：时延， 惯性时延
连续赋值延时语句中的延时，用于控制任意操作数发生变化到语句左端赋予新值之间的时间延时。时延一般是不可综合的。寄存器的时延也是可以控制的，这部分在时序控制里加以说明。连续赋值时延一般可分为普通赋值时延、隐式时延、声明时延。
下面 3 个例子实现的功能是等效的，分别对应 3 种不同连续赋值时延的写法。
//普通时延，A&B计算结果延时10个时间单位赋值给Z
wire Z, A, B ;
assign #10 Z = A & B ;
//隐式时延，声明一个wire型变量时对其进行包含一定时延的连续赋值。
wire A, B;
wire #10 Z = A & B;
//声明时延，声明一个wire型变量是指定一个时延。因此对该变量所有的连续赋值都会被推迟到指定的时间。除非门级建模中，一般不推荐使用此类方法建模。
wire A, B;
wire #10 Z ;
assign Z =A & B
- 惯性时延
在上述例子中，A 或 B 任意一个变量发生变化，那么在 Z 得到新的值之前，会有 10 个时间单位的时延。如果在这 10 个时间单位内，即在 Z 获取新的值之前，A 或 B 任意一个值又发生了变化，那么计算 Z 的新值时会取 A 或 B 当前的新值。所以称之为惯性时延，即信号脉冲宽度小于时延时，对输出没有影响。
因此仿真时，时延一定要合理设置，防止某些信号不能进行有效的延迟。对一个有延迟的与门逻辑进行时延仿真。
module time_delay_module(
input ai, bi,
output so_lose, so_get, so_normal);
assign #20 so_lose = ai & bi ;
assign #5 so_get = ai & bi ;
assign so_normal = ai & bi ;
endmodule
testbench 参考如下:
`timescale 1ns/1ns
module test ;
reg ai, bi ;
wire so_lose, so_get, so_normal ;
initial begin
ai = 0 ;
#25 ; ai = 1 ;
#35 ; ai = 0 ; //60ns
#40 ; ai = 1 ; //100ns
#10 ; ai = 0 ; //110ns
end
initial begin
bi = 1 ;
#70 ; bi = 0 ;
#20 ; bi = 1 ;
end
time_delay_module u_wire_delay(
.ai (ai),
.bi (bi),
.so_lose (so_lose),
.so_get (so_get),
.so_normal (so_normal));
initial begin
forever begin
#100;
//$display("---gyc---%d", $time);
if ($time >= 1000) begin
$finish ;
end
end
end
endmodule
仿真结果如下:
信号 so_normal 为正常的与逻辑。
于 5ns，所以信号 so_get 的结果为与操作后再延迟 5ns 的结果。
信号 so_lose 前一段是与操作后再延迟 20ns 的结果。
由于信号 ai 第二个高电平持续时间小于 20ns，so_lose 信号会因惯性时延而漏掉对这个脉冲的延时检测，所以后半段 so_lose 信号仍然为 0。
过程结构
关键词：initial， always
过程结构语句有 2 种，initial 与 always 语句。它们是行为级建模的 2 种基本语句。
一个模块中可以包含多个 initial 和 always 语句，但 2 种语句不能嵌套使用。
这些语句在模块间并行执行，与其在模块的前后顺序没有关系。
但是 initial 语句或 always 语句内部可以理解为是顺序执行的（非阻塞赋值除外）。
每个 initial 语句或 always 语句都会产生一个独立的控制流，执行时间都是从 0 时刻开始。initial语句
initial 语句从 0 时刻开始执行，只执行一次，多个 initial 块之间是相互独立的。
如果 initial 块内包含多个语句，需要使用关键字 begin 和 end 组成一个块语句。
如果 initial 块内只要一条语句，关键字 begin 和 end 可使用也可不使用。
initial 理论上来讲是不可综合的，多用于初始化、信号检测等。
对上一节代码稍作修改，进行仿真，代码如下。
`timescale 1ns/1ns
module test ;
reg ai, bi ;
initial begin
ai = 0 ;
#25 ; ai = 1 ;
#35 ; ai = 0 ; //absolute 60ns
#40 ; ai = 1 ; //absolute 100ns
#10 ; ai = 0 ; //absolute 110ns
end
initial begin
bi = 1 ;
#70 ; bi = 0 ; //absolute 70ns
#20 ; bi = 1 ; //absolute 90ns
end
//at proper time stop the simulation
initial begin
forever begin
#100;
//$display("---gyc---%d", $time);
if ($time >= 1000) begin
$finish ;
end
end
end
endmodule
- always 语句
与 initial 语句相反，always 语句是重复执行的。always 语句块从 0 时刻开始执行其中的行为语句；当执行完最后一条语句后，便再次执行语句块中的第一条语句，如此循环反复。
由于循环执行的特点，always 语句多用于仿真时钟的产生，信号行为的检测等。
下面用 always 产生一个 100MHz 时钟源，并在 110ns 时停止仿真代码如下。
代码如下:
`timescale 1ns/1ns
module test ;
parameter CLK_FREQ = 100 ; //100MHz
parameter CLK_CYCLE = 1e9 / (CLK_FREQ * 1e6) ; //switch to ns
reg clk ;
initial clk = 1'b0 ; //clk is initialized to "0"
always # (CLK_CYCLE/2) clk = ~clk ; //generating a real clock by reversing
always begin
#10;
if ($time >= 1000) begin
$finish ;
end
end
endmodule
过程赋值
关键词：阻塞赋值，非阻塞赋值，并行
过程性赋值是在 initial 或 always 语句块里的赋值，赋值对象是寄存器、整数、实数等类型。
这些变量在被赋值后，其值将保持不变，直到重新被赋予新值。
连续性赋值总是处于激活状态，任何操作数的改变都会影响表达式的结果；过程赋值只有在语句执行的时候，才会起作用。这是连续性赋值与过程性赋值的区别。
Verilog 过程赋值包括 2 种语句：阻塞赋值与非阻塞赋值。阻塞赋值
阻塞赋值属于顺序执行，即下一条语句执行前，当前语句一定会执行完毕。
阻塞赋值语句使用等号 = 作为赋值符。
前面的仿真中，initial 里面的赋值语句都是用的阻塞赋值。非阻塞赋值
非阻塞赋值属于并行执行语句，即下一条语句的执行和当前语句的执行是同时进行的，它不会阻塞位于同一个语句块中后面语句的执行。
非阻塞赋值语句使用小于等于号 <= 作为赋值符。
利用下面代码，对阻塞、非阻塞赋值进行仿真，来说明 2 种过程赋值的区别。
`timescale 1ns/1ns
module test ;
reg [3:0] ai, bi ;
reg [3:0] ai2, bi2 ;
reg [3:0] value_blk ;
reg [3:0] value_non ;
reg [3:0] value_non2 ;
initial begin
ai = 4'd1 ; //(1)
bi = 4'd2 ; //(2)
ai2 = 4'd7 ; //(3)
bi2 = 4'd8 ; //(4)
#20 ; //(5)
//non-block-assigment with block-assignment
ai = 4'd3 ; //(6)
bi = 4'd4 ; //(7)
value_blk = ai + bi ; //(8)
value_non <= ai + bi ; //(9)
//non-block-assigment itself
ai2 <= 4'd5 ; //(10)
bi2 <= 4'd6 ; //(11)
value_non2 <= ai2 + bi2 ; //(12)
end
//stop the simulation
always begin
#10 ;
if ($time >= 1000) $finish ;
end
endmodule
仿真结果如下：
语句（1）-（8）都是阻塞赋值，按照顺序执行。
20ns 之前，信号 ai，bi 值改变。由于过程赋值的特点，value_blk = ai + bi 并没有执行到，所以 20ns 之前，value_blk 值为 X（不确定状态）。
20ns 之后，信号 ai，bi 值再次改变。执行到 value_blk = ai + bi，信号 value_blk 利用信号 ai，bi 的新值得到计算结果 7。
语句（9）-（12）都是非阻塞赋值，并行执行。
首先，（9）-（12）虽然都是并发执行，但是执行顺序也是在（8）之后，所以信号 value_non = ai + bi 计算是也会使用信号 ai，bi 的新值，结果为 7。
其次，（10）-（12）是并发执行，所以 value_non2 = ai2 + bi2 计算时，并不关心信号 ai2，bi2 的最新非阻塞赋值结果。即 value_non2 计算时使用的是信号 ai2，bi2 的旧值，结果为 4'hF。
- 使用非阻塞赋值避免竞争冒险
上述仿真代码只是为了让读者更好的理解阻塞赋值与非阻塞赋值的区别。实际 Verilog 代码设计时，切记不要在一个过程结构中混合使用阻塞赋值与非阻塞赋值。两种赋值方式混用时，时序不容易控制，很容易得到意外的结果。
更多时候，在设计电路时，always 时序逻辑块中多用非阻塞赋值，always 组合逻辑块中多用阻塞赋值；在仿真电路时，initial 块中一般多用阻塞赋值。
如下所示，为实现在时钟上升沿交换 2 个寄存器值的功能，在 2 个 always 块中使用阻塞赋值。
因为 2 个 always 块中的语句是同时进行的，但是 a=b 与 b=a 是无法判定执行顺序的，这就造成了竞争的局面。
但不管哪个先执行（和编译器等有关系），不考虑 timing 问题时，他们执行顺序总有先后，最后 a 与 b 的值总是相等的。没有达到交换 2 个寄存器值的效果。
always @(posedge clk) begin
a = b ;
end
always @(posedge clk) begin
b = a;
end
但是，如果在 always 块中使用非阻塞赋值，则可以避免上述竞争冒险的情况。
如下所示，2 个 always 块中语句并行执行，赋值操作右端操作数使用的是上一个时钟周期的旧值，此时 a<=b 与 b<=a 就可以相互不干扰的执行，达到交换寄存器值的目的。
always @(posedge clk) begin
a <= b ;
end
always @(posedge clk) begin
b <= a;
end
当然，利用下面代码也可以实现交换寄存器值的功能，但是显然不如在 always 块中直接用非阻塞赋值简单直观。
always @(posedge clk) begin
temp = a ;
a = b ;
b = temp ;
end
时序控制
关键词：时延控制，事件触发，边沿触发，电平触发
Verilog 提供了 2 大类时序控制方法：时延控制和事件控制。事件控制主要分为边沿触发事件控制与电平敏感事件控制。时延控制
基于时延的时序控制出现在表达式中，它指定了语句从开始执行到执行完毕之间的时间间隔。
时延可以是数字、标识符或者表达式。
根据在表达式中的位置差异，时延控制又可以分为常规时延与内嵌时延。常规时延
遇到常规延时时，该语句需要等待一定时间，然后将计算结果赋值给目标信号。
格式为：#delay procedural_statement，例如：
reg value_test ;
reg value_general ;
#10 value_general = value_test ;
该时延方式的另一种写法是直接将井号 # 独立成一个时延执行语句，例如：
#10 ;
value_ single = value_test ;
- 内嵌时延
遇到内嵌延时时，该语句先将计算结果保存，然后等待一定的时间后赋值给目标信号。
内嵌时延控制加在赋值号之后。例如：
reg value_test ;
reg value_embed ;
value_embed = #10 value_test ;
需要说明的是，这 2 种时延控制方式的效果是有所不同的。
当延时语句的赋值符号右端是常量时，2 种时延控制都能达到相同的延时赋值效果。
当延时语句的赋值符号右端是变量时，2 种时延控制可能会产生不同的延时赋值效果。
例如下面仿真代码：
`timescale 1ns/1ns
module test ;
reg value_test ;
reg value_general, value_embed, value_single ;
//signal source
initial begin
value_test = 0 ;
#25 ; value_test = 1 ;
#35 ; value_test = 0 ; //absolute 60ns
#40 ; value_test = 1 ; //absolute 100ns
#10 ; value_test = 0 ; //absolute 110ns
end
//(1)general delay control
initial begin
value_general = 1;
#10 value_general = value_test ; //10ns, value_test=0
#45 value_general = value_test ; //55ns, value_test=1
#30 value_general = value_test ; //85ns, value_test=0
#20 value_general = value_test ; //105ns, value_test=1
end
//(2)embedded delay control
initial begin
value_embed = 1;
value_embed = #10 value_test ; //0ns, value_test=0
value_embed = #45 value_test ; //10ns, value_test=0
value_embed = #30 value_test ; //55ns, value_test=1
value_embed = #20 value_test ; //85ns, value_test=0
end
//(3)single delay control
initial begin
value_single = 1;
#10 ;
value_single = value_test ; //10ns, value_test=0
#45 ;
value_single = value_test ; //55ns, value_test=1
#30 ;
value_single = value_test ; //85ns, value_test=0
#20 ;
value_single = value_test ; //105ns, value_test=1
end
always begin
#10;
if ($time >= 150) begin
$finish ;
end
end
endmodule
仿真结果如下，由图可知：
（1）一般延时的两种表达方式执行的结果都是一致的。
（2）一般时延赋值方式：遇到延迟语句后先延迟一定的时间，然后将当前操作数赋值给目标信号，并没有"惯性延迟"的特点，不会漏掉相对较窄的脉冲。
（3）内嵌时延赋值方式：遇到延迟语句后，先计算出表达式右端的结果，然后再延迟一定的时间，赋值给目标信号。
下面分析下内嵌延时的赋值过程：
value_embed = #10 value_test ; //0ns, value_test=0
0ns 时，执行此延时语句。
先将 0 赋值给信号 value_embed, 延迟 10ns 输出为 0；
value_embed = #45 value_test ; //10ns, value_test=0
10ns 时，执行此延时语句。
由于此时 value_test 仍然为 0，所以 value_embed 值不变。
即到 55ns 时，value_embed 值仍然保持为 0。
value_embed = #30 value_test ; //55ns, value_test=1
同理，55ns 时，value_test 值为 1，将其赋值给 value_embed 并延迟 30ns 输出。
所以 85ns 时，value_embed 输出为 1。
value_embed = #20 value_test ; //85ns, value_test=0
同理，105ns 时，value_embed 输出为 0。
- 边沿触发事件控制
在 Verilog 中，事件是指某一个 reg 或 wire 型变量发生了值的变化。
基于事件触发的时序控制又主要分为以下几种。
- 一般事件控制
事件控制用符号 @ 表示。
语句执行的条件是信号的值发生特定的变化。
关键字 posedge 指信号发生边沿正向跳变，negedge 指信号发生负向边沿跳变，未指明跳变方向时，则 2 种情况的边沿变化都会触发相关事件。例如：
//信号clk只要发生变化，就执行q<=d，双边沿D触发器模型
always @(clk) q <= d ;
//在信号clk上升沿时刻，执行q<=d，正边沿D触发器模型
always @(posedge clk) q <= d ;
//在信号clk下降沿时刻，执行q<=d，负边沿D触发器模型
always @(negedge clk) q <= d ;
//立刻计算d的值，并在clk上升沿时刻赋值给q，不推荐这种写法
q = @(posedge clk) d ;
- 命名事件控制
用户可以声明 event（事件）类型的变量，并触发该变量来识别该事件是否发生。命名事件用关键字 event 来声明，触发信号用 -> 表示。例如：
event start_receiving ;
always @( posedge clk_samp) begin
-> start_receiving ; //采样时钟上升沿作为时间触发时刻
end
always @(start_receiving) begin
data_buf = {data_if[0], data_if[1]} ; //触发时刻，对多维数据整合
end
- 敏感列表
当多个信号或事件中任意一个发生变化都能够触发语句的执行时，Verilog 中使用"或"表达式来描述这种情况，用关键字 or 连接多个事件或信号。这些事件或信号组成的列表称为"敏感列表"。当然，or 也可以用逗号 , 来代替。例如：
//带有低有效复位端的D触发器模型
always @(posedge clk or negedge rstn) begin
//always @(posedge clk , negedge rstn) begin
//也可以使用逗号陈列多个事件触发
if（! rstn）begin
q <= 1'b ;
end
else begin
q <= d ;
end
end
当组合逻辑输入变量很多时，那么编写敏感列表会很繁琐。此时，更为简洁的写法是 @* 或 @(*)，表示对语句块中的所有输入变量的变化都是敏感的。例如：
always @(*) begin
//always @(a, b, c, d, e, f, g, h, i, j, k, l, m) begin
//两种写法等价
assign s = a? b+c : d ? e+f : g ? h+i : j ? k+l : m ;
end
- 电平敏感事件控制
前面所讨论的事件控制都是需要等待信号值的变化或事件的触发，使用 @+敏感列表 的方式来表示的。
Verilog 中还支持使用电平作为敏感信号来控制时序，即后面语句的执行需要等待某个条件为真。Verilog 中使用关键字 wait 来表示这种电平敏感情况。例如：
initial begin
wait (start_enable) ; //等待 start 信号
forever begin
//start信号使能后，在clk_samp上升沿，对数据进行整合
@(posedge clk_samp) ;
data_buf = {data_if[0], data_if[1]} ;
end
end
语句块
- 关键词：顺序块，并行块，嵌套块，命名块，disable
Verilog 语句块提供了将两条或更多条语句组成语法结构上相当于一条一句的机制。主要包括两种类型：顺序块和并行块。
- 顺序块
顺序块用关键字 begin 和 end 来表示。
顺序块中的语句是一条条执行的。当然，非阻塞赋值除外。
顺序块中每条语句的时延总是与其前面语句执行的时间相关。
在本节之前的仿真中，initial 块中的阻塞赋值，都是顺序块的实例。
- 并行块
并行块有关键字 fork 和 join 来表示。
并行块中的语句是并行执行的，即便是阻塞形式的赋值。
并行块中每条语句的时延都是与块语句开始执行的时间相关。
顺序块与并行块的区别显而易见，下面用仿真说明。
仿真代码如下:
`timescale 1ns/1ns
module test ;
reg [3:0] ai_sequen, bi_sequen ;
reg [3:0] ai_paral, bi_paral ;
reg [3:0] ai_nonblk, bi_nonblk ;
//============================================================//
//(1)Sequence block
initial begin
#5 ai_sequen = 4'd5 ; //at 5ns
#5 bi_sequen = 4'd8 ; //at 10ns
end
//(2)fork block
initial fork
#5 ai_paral = 4'd5 ; //at 5ns
#5 bi_paral = 4'd8 ; //at 5ns
join
//(3)non-block block
initial fork
#5 ai_nonblk <= 4'd5 ; //at 5ns
#5 bi_nonblk <= 4'd8 ; //at 5ns
join
endmodule
- 嵌套块
顺序块和并行块还可以嵌套使用。
仿真代码如下:
`timescale 1ns/1ns
module test ;
reg [3:0] ai_sequen2, bi_sequen2 ;
reg [3:0] ai_paral2, bi_paral2 ;
initial begin
ai_sequen2 = 4'd5 ; //at 0ns
fork
#10 ai_paral2 = 4'd5 ; //at 10ns
#15 bi_paral2 = 4'd8 ; //at 15ns
join
#20 bi_sequen2 = 4'd8 ; //at 35ns
end
endmodule
- 命名块
我们可以给块语句结构命名。
命名的块中可以声明局部变量，通过层次名引用的方法对变量进行访问。
仿真代码如下:
`timescale 1ns/1ns
module test;
initial begin: runoob //命名模块名字为runoob，分号不能少
integer i ; //此变量可以通过test.runoob.i 被其他模块使用
i = 0 ;
forever begin
#10 i = i + 10 ;
end
end
reg stop_flag ;
initial stop_flag = 1'b0 ;
always begin : detect_stop
if ( test.runoob.i == 100) begin //i累加10次，即100ns时停止仿真
$display("Now you can stop the simulation!!!");
stop_flag = 1'b1 ;
end
#10 ;
end
endmodule
命名的块也可以被禁用，用关键字 disable 来表示。
disable 可以终止命名块的执行，可以用来从循环中退出、处理错误等。
与 C 语言中 break 类似，但是 break 只能退出当前所在循环，而 disable 可以禁用设计中任何一个命名的块。
仿真代码如下:
`timescale 1ns/1ns
module test;
initial begin: runoob_d //命名模块名字为runoob_d
integer i_d ;
i_d = 0 ;
while(i_d<=100) begin: runoob_d2
# 10 ;
if (i_d >= 50) begin //累加5次停止累加
disable runoob_d3.clk_gen ;//stop 外部block: clk_gen
disable runoob_d2 ; //stop 当前block: runoob_d2
end
i_d = i_d + 10 ;
end
end
reg clk ;
initial begin: runoob_d3
while (1) begin: clk_gen //时钟产生模块
clk=1 ; #10 ;
clk=0 ; #10 ;
end
end
endmodule
条件语句
- 关键词：if，选择器
- 条件语句
条件（if）语句用于控制执行语句要根据条件判断来确定是否执行。
条件语句用关键字 if 和 else 来声明，条件表达式必须在圆括号中。
条件语句使用结构说明如下：
if (condition1) true_statement1 ;
else if (condition2) true_statement2 ;
else if (condition3) true_statement3 ;
else default_statement ;
if 语句执行时，如果 condition1 为真，则执行 true_statement1 ；如果 condition1 为假，condition2 为真，则执行 true_statement2；依次类推。
else if 与 else 结构可以省略，即可以只有一个 if 条件判断和一组执行语句 ture_statement1 就可以构成一个执行过程。
else if 可以叠加多个，不仅限于 1 或 2 个。
ture_statement1 等执行语句可以是一条语句，也可以是多条。如果是多条执行语句，则需要用 begin 与 end 关键字进行说明。
下面代码实现了一个 4 路选择器的功能。
module mux4to1(
input [1:0] sel ,
input [1:0] p0 ,
input [1:0] p1 ,
input [1:0] p2 ,
input [1:0] p3 ,
output [1:0] sout);
reg [1:0] sout_t ;
always @(*) begin
if (sel == 2'b00)
sout_t = p0 ;
else if (sel == 2'b01)
sout_t = p1 ;
else if (sel == 2'b10)
sout_t = p2 ;
else
sout_t = p3 ;
end
assign sout = sout_t ;
endmodule
事例中 if 条件每次执行的语句只有一条，没有使用 begin 与 end 关键字。但如果是 if-if-else 的形式，即便执行语句只有一条，不使用 begin 与 end 关键字也会引起歧义。
例如下面代码，虽然格式上加以区分，但是 else 对应哪一个 if 条件，是有歧义的。
if(en)
if(sel == 2'b1)
sout = p1s ;
else
sout = p0 ;
当然，编译器一般按照就近原则，使 else 与最近的一个 if（例子中第二个 if）相对应。
但显然这样的写法是不规范且不安全的。
所以条件语句中加入 begin 与 and 关键字就是一个很好的习惯。
例如上述代码稍作修改，就不会再有书写上的歧义。
if(en) begin
if(sel == 2'b1) begin
sout = p1s ;
end
else begin
sout = p0 ;
end
end
多路分支语句
关键词：case，选择器
case 语句是一种多路条件分支的形式，可以解决 if 语句中有多个条件选项时使用不方便的问题。case 语句
case 语句格式如下：
case(case_expr)
condition1 : true_statement1 ;
condition2 : true_statement2 ;
……
default : default_statement ;
endcase
case 语句执行时，如果 condition1 为真，则执行 true_statement1 ; 如果 condition1 为假，condition2 为真，则执行 true_statement2；依次类推。如果各个 condition 都不为真，则执行 default_statement 语句。
default 语句是可选的，且在一个 case 语句中不能有多个 default 语句。
条件选项可以有多个，不仅限于 condition1、condition2 等，而且这些条件选项不要求互斥。虽然这些条件选项是并发比较的，但执行效果是谁在前且条件为真谁被执行。
ture_statement1 等执行语句可以是一条语句，也可以是多条。如果是多条执行语句，则需要用 begin 与 end 关键字进行说明。
case 语句支持嵌套使用。
module mux4to1(
input [1:0] sel ,
input [1:0] p0 ,
input [1:0] p1 ,
input [1:0] p2 ,
input [1:0] p3 ,
output [1:0] sout);
reg [1:0] sout_t ;
always @(*)
case(sel)
2'b00: begin
sout_t = p0 ;
end
2'b01: sout_t = p1 ;
2'b10: sout_t = p2 ;
default: sout_t = p3 ;
endcase
assign sout = sout_t ;
endmodule
case 语句中的条件选项表单式不必都是常量，也可以是 x 值或 z 值。
当多个条件选项下需要执行相同的语句时，多个条件选项可以用逗号分开，放在同一个语句块的候选项中。
但是 case 语句中的 x 或 z 的比较逻辑是不可综合的，所以一般不建议在 case 语句中使用 x 或 z 作为比较值。
例如，对 4 路选择器的 case 语句进行扩展，举例如下：
case(sel)
2'b00: sout_t = p0 ;
2'b01: sout_t = p1 ;
2'b10: sout_t = p2 ;
2'b11: sout_t = p3 ;
2'bx0, 2'bx1, 2'bxz, 2'bxx, 2'b0x, 2'b1x, 2'bzx :
sout_t = 2'bxx ;
2'bz0, 2'bz1, 2'bzz, 2'b0z, 2'b1z :
sout_t = 2'bzz ;
default: $display("Unexpected input control!!!");
endcase
- casex/casez 语句
casex、 casez 语句是 case 语句的变形，用来表示条件选项中的无关项。
casex 用 "x" 来表示无关值，casez 用问号 "?" 来表示无关值。
两者的实现的功能是完全一致的，语法与 case 语句也完全一致。
但是 casex、casez 一般是不可综合的，多用于仿真。
例如用 casez 语句来实现一个 4bit 控制端的 4 路选择选择器。
module mux4to1(
input [3:0] sel ,
input [1:0] p0 ,
input [1:0] p1 ,
input [1:0] p2 ,
input [1:0] p3 ,
output [1:0] sout);
reg [1:0] sout_t ;
always @(*)
casez(sel)
4'b???1: sout_t = p0 ;
4'b??1?: sout_t = p1 ;
4'b?1??: sout_t = p2 ;
4'b1???: sout_t = p3 ;
default: sout_t = 2'b0 ;
endcase
assign sout = sout_t ;
endmodule
循环语句
关键词：while, for, repeat, forever
Verilog 循环语句有 4 种类型，分别是 while，for，repeat，和 forever 循环。循环语句只能在 always 或 initial 块中使用，但可以包含延迟表达式。while 循环
while 循环语法格式如下：
while (condition) begin
…
end
while 循环中止条件为 condition 为假。
如果开始执行到 while 循环时 condition 已经为假，那么循环语句一次也不会执行。
当然，执行语句只有一条时，关键字 begin 与 end 可以省略。
下面代码执行时，counter 执行了 11 次。
`timescale 1ns/1ns
module test ;
reg [3:0] counter ;
initial begin
counter = 'b0 ;
while (counter<=10) begin
#10 ;
counter = counter + 1'b1 ;
end
end
//stop the simulation
always begin
#10 ; if ($time >= 1000) $finish ;
end
endmodule
- for 循环
for 循环语法格式如下：
for(initial_assignment; condition ; step_assignment) begin
…
end
initial_assignment 为初始条件。
condition 为终止条件，condition 为假时，立即跳出循环。
step_assignment 为改变控制变量的过程赋值语句，通常为增加或减少循环变量计数。
一般来说，因为初始条件和自加操作等过程都已经包含在 for 循环中，所以 for 循环写法比 while 更为紧凑，但也不是所有的情况下都能使用 for 循环来代替 while 循环。
下面 for 循环的例子，实现了与 while 循环中例子一样的效果。需要注意的是，i = i + 1 不能像 C 语言那样写成 i++ 的形式，i = i -1 也不能写成 i -- 的形式。
// for 循环语句
integer i ;
reg [3:0] counter2 ;
initial begin
counter2 = 'b0 ;
for (i=0; i<=10; i=i+1) begin
#10 ;
counter2 = counter2 + 1'b1 ;
end
end
- repeat 循环
repeat 循环语法格式如下：
repeat (loop_times) begin
…
end
repeat 的功能是执行固定次数的循环，它不能像 while 循环那样用一个逻辑表达式来确定循环是否继续执行。repeat 循环的次数必须是一个常量、变量或信号。如果循环次数是变量信号，则循环次数是开始执行 repeat 循环时变量信号的值。即便执行期间，循环次数代表的变量信号值发生了变化，repeat 执行次数也不会改变。
下面 repeat 循环例子，实现了与 while 循环中的例子一样的效果。
// repeat 循环语句
reg [3:0] counter3 ;
initial begin
counter3 = 'b0 ;
repeat (11) begin //重复11次
#10 ;
counter3 = counter3 + 1'b1 ;
end
end
下面 repeat 循环例子，实现了连续存储 8 个数据的功能:
always @(posedge clk or negedge rstn) begin
j = 0 ;
if (!rstn) begin
repeat (8) begin
buffer[j] <= 'b0 ; //没有延迟的赋值，即同时赋值为0
j = j + 1 ;
end
end
else if (enable) begin
repeat (8) begin
@(posedge clk) buffer[j] <= counter3 ; //在下一个clk的上升沿赋值
j = j + 1 ;
end
end
end
- forever 循环
forever 循环语法格式如下：
forever begin
…
end
forever 语句表示永久循环，不包含任何条件表达式，一旦执行便无限的执行下去，系统函数 $finish 可退出 forever。
forever 相当于 while(1) 。
通常，forever 循环是和时序控制结构配合使用的。
例如，使用 forever 语句产生一个时钟：
reg clk ;
initial begin
clk = 0 ;
forever begin
clk = ~clk ;
#5 ;
end
end
例如，使用 forever 语句实现一个时钟边沿控制的寄存器间数据传输功能：
reg clk ;
reg data_in, data_temp ;
initial begin
forever @(posedge clk) data_temp = data_in ;
end
过程连续赋值
- 关键词：deassign，force，release
过程连续赋值是过程赋值的一种。这种赋值语句能够替换其他所有 wire 或 reg 的赋值，改写了 wire 或 reg 型变量的当前值。
与过程赋值不同的是，过程连续赋值的表达式能被连续的驱动到 wire 或 reg 型变量中，即过程连续赋值发生作用时，右端表达式中任意操作数的变化都会引起过程连续赋值语句的重新执行。
过程连续性赋值主要有 2 种，assign-deassign 和 force-release。
- assign, deassign
assign（过程赋值操作）与 deassign （取消过程赋值操作）表示第一类过程连续赋值语句。赋值对象只能是寄存器或寄存器组，而不能是 wire 型变量。
赋值过程中对寄存器连续赋值，寄存器中的值被保留直到被重新赋值。
例如，一个带复位端的 D 触发器可以用下面代码描述：
module dff_normal(
input rstn,
input clk,
input D,
output reg Q
);
always @(posedge clk or negedge rstn) begin
if(!rstn) begin //Q = 0 after reset effective
Q <= 1'b0 ;
end
else begin
Q <= D ; //Q = D at posedge of clock
end
end
endmodule
下面，用 assign 与 deassign 改写，完成相同的功能。
即在复位信号为 0 时，Q 端被 assign 语句赋值，始终输出为 0。
复位信号为 1 时，Q 端被 deassign 语句取消赋值，在时钟上升沿被重新赋值。
module dff_assign(
input rstn,
input clk,
input D,
output reg Q
);
always @(posedge clk) begin
Q <= D ; //Q = D at posedge of clock
end
always @(negedge rstn) begin
if(!rstn) begin
assign Q = 1'b0 ; //change Q value when reset effective
end
else begin //cancel the Q value overlay,
deassign Q ; //and Q remains 0-value until the coming of clock posedge
end
end
endmodule
- force, release
force （强制赋值操作）与 release（取消强制赋值）表示第二类过程连续赋值语句。
使用方法和效果，和 assign 与 deassign 类似，但赋值对象可以是 reg 型变量，也可以是 wire 型变量。
因为是无条件强制赋值，一般多用于交互式调试过程，不要在设计模块中使用。
当 force 作用在寄存器上时，寄存器当前值被覆盖；release 时该寄存器值将继续保留强制赋值时的值。之后，该寄存器的值可以被原有的过程赋值语句改变。
当 force 作用在线网上时，线网值也会被强制赋值。但是，一旦 release 该线网型变量，其值马上变为原有的驱动值。
为直观的观察两种类型变量强制赋值的区别，利用第一节中的计数器 counter10 作为设计模块，testbench 设计如下。
`timescale 1ns/1ns
module test ;
reg rstn ;
reg clk ;
reg [3:0] cnt ;
wire cout ;
counter10 u_counter (
.rstn (rstn),
.clk (clk),
.cnt (cnt),
.cout (cout));
initial begin
clk = 0 ;
rstn = 0 ;
#10 ;
rstn = 1'b1 ;
wait (test.u_counter.cnt_temp == 4'd4) ;
@(negedge clk) ;
force test.u_counter.cnt_temp = 4'd6 ;
force test.u_counter.cout = 1'b1 ;
#40 ;
@(negedge clk) ;
release test.u_counter.cnt_temp ;
release test.u_counter.cout ;
end
initial begin
clk = 0 ;
forever #10 clk = ~ clk ;
end
//finish the simulation
always begin
#1000;
if ($time >= 1000) $finish ;
end
endmodule // test
Verilog：基础语法（下）