Verilog always 块：组合逻辑与时序逻辑

行为级 Verilog 的主力

assign 描述单个等式的组合逻辑。一旦需要 if/else、case 或记忆功能，就要用 always。always 块是一段过程代码，每当特定信号变化时就重新执行。触发重新执行的这些信号就是敏感列表。

你最常见到的 always 有两种形式：

1. always @(*)：块中读取的任何信号变化时重新执行，构建组合逻辑。
2. always @(posedge clk)：只在 clk 的上升沿重新执行，构建时钟驱动的时序逻辑（触发器）。

还有其他形式（@(a or b)、@(negedge clk)、@(posedge clk or negedge reset_n)），但你写的几乎所有可综合的块都是上面这两种。

组合逻辑 always @(*)

module decoder3(
    input  wire [2:0] sel,
    output reg  [7:0] out
);
    always @(*) begin
        case (sel)
            3'd0: out = 8'b0000_0001;
            3'd1: out = 8'b0000_0010;
            3'd2: out = 8'b0000_0100;
            3'd3: out = 8'b0000_1000;
            3'd4: out = 8'b0001_0000;
            3'd5: out = 8'b0010_0000;
            3'd6: out = 8'b0100_0000;
            3'd7: out = 8'b1000_0000;
            default: out = 8'b0;
        endcase
    end
endmodule

module test;
    reg [2:0] sel;
    wire [7:0] out;
    decoder3 dut(.sel(sel), .out(out));

    initial begin
        for (integer i = 0; i < 8; i = i + 1) begin
            sel = i[2:0];
            #1 $display("sel=%0d out=%b", sel, out);
        end
        $finish;
    end
endmodule

需要注意三点：

• out 是 reg。 在 always 中赋值的任何信号都必须是 reg。这个关键字并不表示“这是一个触发器”，在这里它只表示“我由过程块写入”。
• always @(*)。 * 的意思是“我读取的任何信号变化时就唤醒”。仿真器会自动推算出敏感列表。你也可以手动写出列表，比如 always @(sel)，但 @(*) 更安全，因为漏掉一个信号是经典的 bug 来源。
• 没有时钟。 这个块描述的是组合逻辑。综合工具会生成一段直接由 sel 计算出 out 的逻辑，没有触发器，也不需要时钟引脚。

default 分支在语法上是可选的，但在实践中不应省略。省略它之后，任何未列出的输入值都会让 out 保持之前的值，这会被综合成一个意料之外的锁存器。务必加上 default。

时序逻辑 always @(posedge clk)

module counter4(
    input  wire       clk,
    input  wire       reset,
    output reg  [3:0] count
);
    always @(posedge clk) begin
        if (reset) count <= 4'd0;
        else       count <= count + 4'd1;
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    wire [3:0] count;

    counter4 dut(.clk(clk), .reset(reset), .count(count));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        #80 $finish;
    end

    always @(posedge clk)
        $display("t=%0t count=%0d", $time, count);
endmodule

与组合逻辑版本的主要区别：

• always @(posedge clk)。 这个块只在 clk 的上升沿重新执行，两个时钟沿之间什么都不会发生。
• 非阻塞赋值 <=。 在时钟驱动的块中，这是正确的运算符。它表示“安排 count 在当前时间步结束时取新值”，这正是触发器的行为方式。原因以及另一种写法请看阻塞赋值与非阻塞赋值。
• 不需要 default。 if 覆盖了两个分支（复位和非复位），没有产生锁存器的风险。

综合工具看到这种形式（时钟敏感列表加非阻塞赋值），就会生成一个 4 位寄存器（四个触发器），外加计算 count + 1 的组合逻辑，以及在复位和加一之间做选择的多路选择器。

综合结果的区别

同一份模块源码，取决于 always 块的形式，可能描述两种完全不同的硬件：

第三种情况就是锁存器陷阱。锁存器是一种透明的存储单元，输入无效时保持输出不变。它在某些特定设计中有用，但意外产生时几乎总是 bug。大多数综合工具在推断出你没要求的锁存器时会发出醒目的警告。请把这个警告当作错误对待。

敏感列表的其他写法

你还会看到几种不太常见的敏感列表：

• always @(a or b or c)：显式列表。Verilog-2001 增加了 , 分隔符：always @(a, b, c)。两种写法都可以。
• always @(posedge clk or negedge reset_n)：异步复位。这个块在时钟上升沿或复位信号下降沿执行。当复位必须立即生效、不能等到下一个时钟时使用。
• always @(negedge clk)：下降沿时钟。很少见；有些设计用它实现在下降沿而不是上升沿采样的“下降沿触发”触发器。

对于新设计，组合逻辑优先使用 always @(*)，时序逻辑优先使用 always @(posedge clk)。只有设计确实需要时才使用异步复位。

两个块就是两块硬件

同一个模块中的多个 always 块彼此独立，每个都会成为一块独立的硬件：

module two_blocks(
    input  wire       clk,
    input  wire       reset,
    input  wire [7:0] in,
    output reg  [7:0] reg_out,    // sequential
    output reg  [7:0] comb_out    // combinational
);
    always @(posedge clk) begin
        if (reset) reg_out <= 8'd0;
        else       reg_out <= in;
    end

    always @(*) begin
        comb_out = in ^ 8'hFF;     // bitwise invert
    end
endmodule

module test;
    reg clk = 0, reset = 1;
    reg [7:0] in;
    wire [7:0] reg_out, comb_out;

    two_blocks dut(.clk(clk), .reset(reset), .in(in),
                   .reg_out(reg_out), .comb_out(comb_out));

    always #5 clk = ~clk;

    initial begin
        in = 8'h00; #12 reset = 0;
        in = 8'hA5; #10;
        in = 8'h3C; #10;
        $finish;
    end

    always @(posedge clk)
        $display("t=%0t in=%h reg_out=%h comb_out=%h",
                 $time, in, reg_out, comb_out);
endmodule

时钟驱动的块生成一个触发器寄存器，组合逻辑块生成一个异或门。它们并排存在，互不知晓。两个输出按完全不同的节奏变化。

always 块不能做的事

有几件事看起来很诱人，但并不允许：

• 给 wire 赋值：赋值目标必须是 reg，编译器会强制检查。
• 在两个不同的 always 块中给同一个 reg 赋值：仿真中会产生未定义行为，也无法综合。每个信号只能有一个驱动源。
• 在同一个组合逻辑块中读写同一个信号，从而形成反馈环路：always @(*) x = x + 1; 是一个零延迟循环，仿真器无法解决。

前两种编译器能发现。第三种有时只会在仿真时表现为卡死。

接下来

下一篇文档 initial 块讲解 always 的兄弟：一个在仿真开始时只执行一次的块，它是测试平台（testbench）的主力。之后会讲阻塞赋值与非阻塞赋值的规则，它们决定了你的时钟驱动块是否按你的意图工作。