Verilog语言设计增加延时的正确方法

在设计仿真激励文件时，为了满足和外部芯片接口的时序要求，经常会用到延时赋值语句，由于不同的延时赋值语句在仿真过程中行为不同，会产生不同的激励输出，如果不认真区分不同表达式引起的差异，就可能产生错误的激励，无法保证仿真结果的正确，本文就是区分各种延时赋值语句的差异，并给出比较结果；

1：阻塞式左延时赋值语句
举例说明如下：

module adder_t1 (co, sum, a, b, ci);
output co;
output [3:0] sum;
input [3:0] a, b;
input ci;
reg co;
reg [3:0] sum;
always @(a or b or ci)
#12 {co, sum} = a + b + ci; // 在15ns时a发生变化，启动该块，但是等到27ns时才执行后面的语句，所以是最新的结果
endmodule

分析：上面例子是希望在输入信号变化后12ns再更新输出结果，假设在15ns时a发生变化，在27ns时，结果将被更新，但是如果在15ns到24ns这一段时间，a，b，ci又发生了变化，在27ns时，结果将按照最新的a，b，ci进行计算并被更新；

如果将程序修改成如下格式，仿真的结果不变：

module adder_t7a (co, sum, a, b, ci);
output co;
output [3:0] sum;
input [3:0] a, b;
input ci;
reg co;
reg [3:0] sum;
reg [4:0] tmp;
always @(a or b or ci)
begin
#12 tmp = a + b + ci; // 在15ns a发生变化时，启动该always块，但是12ns后即第27ns时才执行 
 //tmp = a + b + ci tmp才被赋值，因此赋值的是最近的a，b，ci变化的值
{co, sum} = tmp;
end
endmodule

如果将程序做如下修改：

module adder_t7b (co, sum, a, b, ci);
output co;
output [3:0] sum;
input [3:0] a, b;
input ci;
reg co;
reg [3:0] sum;
reg [4:0] tmp;
always @(a or b or ci)
begin
tmp = a + b + ci;  // 在15ns a发生变化时，启动该always块，执行该语句，获得当前tem ,然后就开始执行下一句 #12
#12 {co, sum} = tmp; // 所以tmp的值是15ns的值，再过12ns即27ns时赋值给输出。因此，中间的变换被忽视
end
//15~27之间执行该语句块，只有执行完该语句块之后才是开始执行下一个语句块
endmodule

仿真的结果如下图所示：从15ns到27ns之间的变化被忽视；

结论：阻塞式赋值语句是一句一句执行的，一句没有执行完，下一句绝不会执行。正因为如此，在此例中在延时12个ns的时间里，不作任何处理，tmp值保持不变（2’b10），而且对敏感变量的变化不作反应。 不要将延时放在阻塞式赋值语句的左侧，这是一种不好的代码设计方式；

2：阻塞式右延时赋值语句
看下面的例子：

module adder_t6 (co, sum, a, b, ci);
output co;
output [3:0] sum;
input [3:0] a, b;
input ci;
reg co;
reg [3:0] sum;
always @(a or b or ci)
{co, sum} = #12 a + b + ci; // 先计算a + b + ci的值，过12ns后赋值为输出；赋值语句是从右往左执行
endmodule

它的仿真结果同adder_t7b，赋值语句是从右往左执行，信号从15ns到27ns之间的变化被忽视；即 同：

tmp = a + b + ci;  

#12 {co, sum} = tmp;

下面两个例子的仿真结果和adder_t6相同：

module adder_t11a (co, sum, a, b, ci);
output co;
output [3:0] sum;
input [3:0] a, b;
input ci;
reg co;
reg [3:0] sum;
reg [4:0] tmp;
always @(a or b or ci)
begin
tmp = #12 a + b + ci;
{co, sum} = tmp;
end
endmodule
module adder_t11b (co, sum, a, b, ci);
output co;
output [3:0] sum;
input [3:0] a, b;
input ci;
reg co;
reg [3:0] sum;
reg [4:0] tmp;
always @(a or b or ci)
begin
tmp = a + b + ci;
{co, sum} = #12 tmp;
end
endmodule

结论：不要将延时放在阻塞式赋值语句的右侧，这是一种不好的代码设计方式；

3：非阻塞式左延时赋值语句
看例子：

module adder_t2 (co, sum, a, b, ci);
output co;
output [3:0] sum;
input [3:0] a, b;
input ci;
reg co;
reg [3:0] sum;
always @(a or b or ci)
#12 {co, sum} <= a + b + ci;
endmodule

它的仿真结果同adder_t1，在27ns时，结果将按照最新的a，b，ci进行计算并被更新；由于首先要执行#12，然后才能执行非阻塞赋值，所以能对信号进行实时跟踪！ 

结论：不要将延时放在非阻塞式赋值语句的左侧，这是一种不好的代码设计方式；

4：非阻塞式右延时赋值语句
看例子：

module adder_t3 (co, sum, a, b, ci);
output co;
output [3:0] sum;
input [3:0] a, b;
input ci;
reg co;
reg [3:0] sum;
always @(a or b or ci)
{co, sum} <= #12 a + b + ci;
endmodule

非阻塞赋值，不会阻止下一条语句的执行，输出结果能随时跟踪输入信号的变化；

结论：使用非阻塞式右延时赋值语句可以，输出结果能够跟随输入的变化，建议使用；

5：非阻塞式右延时多重赋值语句
看例子：

module adder_t9c (co, sum, a, b, ci);
output co;
output [3:0] sum;
input [3:0] a, b;
input ci;
reg co;
reg [3:0] sum;
reg [4:0] tmp;
always @(a or b or ci or tmp)
begin
tmp <= #12 a + b + ci;
{co, sum} <= tmp;
end
endmodule

非阻塞赋值，不会阻止下一条语句的执行，输出结果能随时跟踪输入信号的变化；这与下面的例子结果是相同的：

module adder_t9d (co, sum, a, b, ci);
output co;
output [3:0] sum;
input [3:0] a, b;
input ci;
reg co;
reg [3:0] sum;
reg [4:0] tmp;
always @(a or b or ci or tmp)
begin
tmp <= a + b + ci;
{co, sum} <= #12 tmp;
end
endmodule

6：连续赋值语句
看例子：

module adder_t4 (co, sum, a, b, ci);
output co;
output [3:0] sum;
input [3:0] a, b;
input ci;
assign #12 {co, sum} = a + b + ci;
endmodule
module adder_t5 (co, sum, a, b, ci);
output co;
output [3:0] sum;
input [3:0] a, b;
input ci;
assign {co, sum} = #12 a + b + ci;
endmodule

输出结果能随时跟踪输入信号的变化；

结论：非阻塞语句和连续赋值语句无论怎么添加延时语句，其输出都会随着输入的变化而跟踪变化！这里要特别注意阻塞语句的延时添加，一般不在阻塞赋值语句中添加延时！