3. RTL设计基础

各位同学，欢迎来到第三章。这一章，咱们要啃的可是RTL设计的“硬骨头”。

说实话，很多新手觉得写Verilog就是画画电路，把代码堆上去就行。但我在项目里见过太多“仿真通过、上板就挂”的惨案。问题出在哪？就是没搞懂我们今天要讲的这几个核心概念。

你想想看，如果连组合逻辑和时序逻辑都分不清，赋值方式用错了，复位搞成了异步还不管亚稳态，那流片回来的芯片基本就是一块废硅。所以，这一章咱们必须掰开揉碎了讲清楚。

3.1 组合逻辑 vs 时序逻辑：数字电路的两大基石

先问个问题：一个数字电路，如果输入变了，输出立刻跟着变，这叫啥？组合逻辑。如果输出要等到时钟沿来了才变，这叫啥？时序逻辑。

说白了，组合逻辑就是“纯电路”，没有记忆功能。时序逻辑就是“带寄存器的电路”，能记住过去的状态。

3.1.1 组合逻辑：实时响应

组合逻辑的输出，只取决于当前的输入。没有时钟，没有存储单元。比如一个简单的与门、或门，或者一个加法器。

我在项目中遇到过一个问题：一个同事用组合逻辑写了很长的级联加法，结果综合出来路径延迟巨大，时序直接崩了。嗯，这里要注意，组合逻辑虽然快（没有时钟延迟），但路径太长会出事。

// 组合逻辑示例：一个简单的多路选择器
module mux_2to1 (
    input  wire a,
    input  wire b,
    input  wire sel,
    output wire y
);
    assign y = sel ? b : a;
endmodule

你看，这个代码里没有时钟，没有always块（除非是组合逻辑的always），输出y随着a、b、sel的变化实时变化。

3.1.2 时序逻辑：记忆与同步

时序逻辑就不一样了。它必须有时钟，有触发器（Flip-Flop）。输出只在时钟沿更新，所以它能“记住”上一个状态。

我个人习惯，所有需要“状态”的地方，比如计数器、状态机、数据缓存，一律用时序逻辑。为什么？因为稳定，不容易出毛刺。

// 时序逻辑示例：一个带使能的D触发器
module dff_en (
    input  wire       clk,
    input  wire       rst_n,
    input  wire       en,
    input  wire       d,
    output reg        q
);
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n)
            q <= 1'b0;
        else if (en)
            q <= d;
    end
endmodule

看到了吗？always @(posedge clk) 就是时序逻辑的标志。输出q只在时钟上升沿变化。

3.2 阻塞赋值 vs 非阻塞赋值：一个让无数人翻车的坑

好，接下来这个知识点，我敢说每个RTL工程师都在这上面吃过亏。阻塞赋值（=）和非阻塞赋值（<=），用错了，仿真和综合结果完全不一样。

为什么会这样？因为Verilog的仿真模型和综合模型有差异。你想想看，仿真器是软件，它按顺序执行代码；但综合出来的硬件是并行的。赋值方式就是用来弥合这个鸿沟的。

3.2.1 阻塞赋值（=）：组合逻辑专用

阻塞赋值，顾名思义，它会“阻塞”后面的语句，直到当前赋值完成。在always块里，它是顺序执行的。

我个人习惯，只在组合逻辑的always块里用阻塞赋值。比如写一个译码器、一个加法器。

// 阻塞赋值示例：组合逻辑中的交换
always @(*) begin
    temp = a;
    a    = b;
    b    = temp;
end

这段代码在仿真里是顺序执行的，先temp=a，再a=b，最后b=temp。综合出来呢？其实就是一个交叉连接，没有寄存器。但如果你在时序逻辑里这么写，那就乱套了。

3.2.2 非阻塞赋值（<=）：时序逻辑的标准

非阻塞赋值，所有赋值操作在时钟沿“同时”发生。它不会阻塞后面的语句。这是时序逻辑的唯一正确写法。

我曾经在项目中review过一段代码，一个同事在时序逻辑里用了阻塞赋值，结果仿真时数据总是晚一个周期，查了两天才发现是赋值方式的问题。从那以后，我定了个规矩：时序逻辑里，谁敢用阻塞赋值，请客吃饭！

// 非阻塞赋值示例：正确的移位寄存器
always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        shift_reg <= 4'b0;
    end else begin
        shift_reg <= {shift_reg[2:0], data_in};
    end
end

这里用非阻塞赋值，所有移位操作在同一个时钟沿完成，完美。如果换成阻塞赋值，你会得到一堆奇怪的中间结果。

赋值类型	适用场景	执行方式	综合结果
阻塞赋值（=）	组合逻辑	顺序执行	纯组合电路
非阻塞赋值（<=）	时序逻辑	并行执行	触发器

3.3 同步复位 vs 异步复位：复位策略的选择

复位，是芯片启动时的“第一口奶”。复位没做好，芯片可能连初始化都过不去。

复位方式有两种：同步复位和异步复位。各有优缺点，咱们一个一个看。

3.3.1 同步复位：与时钟同步

同步复位，只在时钟沿检查复位信号。优点是抗干扰能力强，不容易受毛刺影响。缺点是复位路径必须满足时序约束，而且复位信号宽度必须大于一个时钟周期。

// 同步复位示例
always @(posedge clk) begin
    if (rst_n == 1'b0)
        counter <= 8'b0;
    else
        counter <= counter + 1;
end

你看，复位信号rst_n没有出现在敏感列表里。它只在时钟沿被采样。这样综合出来的电路，复位信号会连接到触发器的同步复位端（如果有的话），或者通过组合逻辑实现。

3.3.2 异步复位：立即生效

异步复位，复位信号一有效，输出立刻清零，不管时钟。优点是响应快，适合紧急复位。缺点是容易受毛刺影响，而且存在“复位释放时的亚稳态”问题。

// 异步复位示例
always @(posedge clk or negedge rst_n) begin
    if (!rst_n)
        counter <= 8'b0;
    else
        counter <= counter + 1;
end

注意敏感列表里多了negedge rst_n。这就是异步复位的标志。综合工具会把它映射到触发器的异步复位端。

3.3.3 我的选择：异步复位，同步释放

我个人习惯，在SoC项目中，统一使用“异步复位，同步释放”策略。为什么？

• 异步复位：保证复位信号能立即生效，不受时钟影响。
• 同步释放：复位释放时，通过两级同步器，避免亚稳态。

我曾经在一个高速接口项目中，因为用了纯异步复位，结果复位释放时刚好碰到时钟沿，导致整个状态机进入非法状态。从那以后，我就再也不敢偷懒了。

// 异步复位，同步释放示例
module rst_sync (
    input  wire clk,
    input  wire rst_async_n,
    output wire rst_sync_n
);
    reg rst_meta, rst_sync;
    always @(posedge clk or negedge rst_async_n) begin
        if (!rst_async_n) begin
            rst_meta <= 1'b0;
            rst_sync <= 1'b0;
        end else begin
            rst_meta <= 1'b1;
            rst_sync <= rst_meta;
        end
    end
    assign rst_sync_n = rst_sync;
endmodule

3.4 模块化设计思想：把大象装进冰箱

好了，前面讲的都是“术”，现在咱们聊聊“道”。模块化设计，说白了就是“分而治之”。

你想想看，一个SoC芯片可能有几亿个晶体管，如果所有代码都写在一个文件里，那别说调试了，连看都看不懂。模块化就是把大系统拆成小模块，每个模块负责一个功能，接口清晰，内部独立。

3.4.1 为什么要模块化？

• 可复用： 写好的模块，下个项目直接拿来用。比如一个I2C控制器，写好之后，所有项目都能用。
• 可调试： 出问题了，定位到模块级别，不用从头看到尾。
• 可维护： 改一个功能，只改一个模块，不影响其他部分。

我个人习惯，每个模块的代码量控制在200-500行之间。超过500行，我就考虑拆分子模块。为什么？因为人脑能同时处理的信息有限，代码太长，自己都看不懂。

3.4.2 模块划分的原则

模块怎么划分？我总结了三条原则：

1. 高内聚： 一个模块只做一件事，并且把它做好。比如一个FIFO模块，就只管数据缓存，别把控制逻辑也塞进去。
2. 低耦合： 模块之间的接口尽量简单。能用简单的握手信号（valid/ready），就别搞复杂的协议。
3. 层次化： 顶层模块只负责例化和连线，不负责具体逻辑。具体逻辑都在底层模块里。

// 模块化设计示例：一个简单的数据通路
// 顶层模块：只负责例化
module data_path (
    input  wire        clk,
    input  wire        rst_n,
    input  wire [7:0]  data_in,
    output wire [15:0] result
);
    wire [7:0]  mul_out;
    wire [15:0] acc_out;

    // 例化乘法器
    multiplier u_mult (
        .a      (data_in),
        .b      (data_in),
        .prod   (mul_out)
    );

    // 例化累加器
    accumulator u_acc (
        .clk    (clk),
        .rst_n  (rst_n),
        .data   (mul_out),
        .sum    (acc_out)
    );

    assign result = acc_out;
endmodule

你看，顶层模块干干净净，只有例化和连线。乘法器和累加器各自独立，想换一个乘法器实现？直接换模块就行，不影响其他部分。

3.5 本章知识体系总览

为了让你更直观地理解本章的知识结构，我画了一张图。这张图展示了组合逻辑、时序逻辑、赋值方式、复位策略和模块化设计之间的关系。

这张图把本章的核心知识点串起来了。你仔细看看，组合逻辑和时序逻辑是基础，赋值方式决定了代码的行为，复位策略保证了芯片的可靠启动，而模块化设计则是让这一切变得有序的方法论。