Verilog on Lumenth

IIC总线

Thu, 16 Jul 2026 00:00:00 +0000

本文讲解 IIC 总线协议，并给出可直接参考的 Verilog 主从机代码样例。

文章时序解析内容基于该视频。

IIC总线介绍

IIC（Inter-Integrated Circuit，常写作 I2C）是一种同步串行总线协议，由 Philips 提出由一个主机和若干从机构成，一个主机和多个从机共享同一对 SDA/SCL 信号线。

IIC总线仅使用两根线工作：SCL（Serial Clock，时钟线）与 SDA（Serial Data，数据线），二者均为开漏结构、靠上拉电阻拉高，主从机控制拉低。本文采用7位地址表示法。同一条总线上，每个从机地址必须唯一，主机通过地址选中特定从机进行通信。

IIC协议

上图为 IIC 标准传输格式，图中区分了"主机发出"与"从机发出"的信号。一次完整传输由起始条件开始、停止条件结束，中间按"地址 → 寄存器地址 → 数据"的顺序交互：

读时序：起始位 → 地址+W → ACK(从机) → 寄存器地址 → ACK(从机) → 地址+R → ACK(从机) → 数据 → ACK → … → 停止位
写时序：起始位 → 地址+W → ACK(从机) → 寄存器地址 → ACK(从机) → 写入数据 → ACK → … → 停止位

时序解析

IIC 是同步时序：SDA 上的数据在 SCL 高电平期间必须保持稳定，接收方通常在 SCL 上升沿附近采样；而 SDA 的电平翻转只能发生在 SCL 低电平期间。

这一约束是为了使得 SCL 高电平期间的 SDA 跳变被专门保留给"起始/停止条件"。

起始位（START, S）

总线空闲时，外接的上拉电阻将 SDA 与 SCL 都维持在高电平（IDLE 状态）。当主机准备通信时，在 SCL 为高电平期间将 SDA 拉低，即产生起始条件，标志一次传输开始。

地址位 + W/R

起始条件之后的第一个字节用于寻址：主机在 SCL 上升沿逐位送出 8 位数据，其中前 7 位为从机地址，第 8 位为读写标志 R/W（0 = 写，1 = 读）。

对于"读"操作，主机之所以先发"地址+W"，是为了先把要读取的寄存器地址写进从机；随后再用 repeated START 切换为"地址+R"，从机才据此把对应寄存器的数据发回来。

应答位（ACK）

图中白色信号即应答位，ACK 由当前字节的接收方产生。每传输完 8 位数据后，接收方需在紧跟的第 9 个 SCL 周期给出应答：ACK = SDA 被拉低（低电平），NACK = SDA 释放（高电平）。

NACK 表示发送方未收到应答。在主机读数据时，主机通常会在最后一个字节返回 NACK，通知从机停止继续发送；在其他场景下，NACK 也可能表示地址不存在、设备忙或通信异常。只有收到有效 ACK，通信才会继续。

停止位（STOP, P）

当前一次传输结束后，主机在 SCL 为高电平期间将 SDA 由低释放为高，产生停止条件，总线回到 IDLE 状态。

Verilog代码

本文实现的是标准模式（Standard-mode，≤100 kHz）下的 IIC 主从通信，覆盖 7 位地址、读写双方向、寄存器地址 + 连续多字节数据等最常见的外设访问场景，可作为学习与原型验证的基础 IP。

本文实现代码范围

类别	支持内容	说明
通信模式	标准模式 Standard-mode（默认 100 kHz）	主从双机，单主机结构
寻址	7 位从机地址	主机 `addr` 输入、从机 `SLAVE_ADDR` 参数
传输方向	写（主机→从机）/ 读（主机←从机）	均支持连续多字节
寄存器访问	先写寄存器地址，再读写数据	指针自增，支持跨寄存器连续访问
起止条件	START / STOP	读操作支持 repeated START（不发 STOP 直接重启）
应答机制	每字节后 ACK	从机回 ACK；读末字节主机回 NACK
时钟延长	主机侧支持	检测到 SCL 被从机拉低即等待（clock stretching）
总线建模	SDA/SCL 开漏	逻辑 1 = 释放、逻辑 0 = 拉低，板级外接上拉
错误处理	`error` 标志	地址或数据被 NACK 时置位

未覆盖的部分（如需可在此基础上扩展）：10 位地址、Fast-mode / Fast-mode Plus / High-speed 等高速模式、从机主动时钟延长（本从机不拉低 SCL）、广播呼叫/设备复位等保留地址、多主机仲裁与同步。

主机

主机驱动模块用状态机完成一次完整 IIC 传输：IDLE → START → ADDR_DEVICE(设备地址+W) → ADDR_REG(寄存器地址) → [读时 repeated START + ADDR_RD(设备地址+R)] → DATA(收发数据) → STOP。

SDA/SCL 均为开漏建模：输出逻辑 0 表示主动拉低总线，输出逻辑 1 并不会驱动高电平来实现，而是直接释放引脚，由片外上拉电阻恢复为高电平。因此 SDA_OE 与 SCL_OE 仅控制"是否拉低"总线。

SCL 由检测SCL边沿的计数器驱动——每检测到一次 SCL 实际边沿就重触发半周期计时，数满 T_HALF 翻转 SCL_OE。每 8 位数据后跟 1 拍 ACK：从机拉低为 ACK，释放为高即为 NACK。

当从机把 SCL 拉低时主机检测不到上升沿，计数器不被重触发，于是停在原位等待，直到从机释放产生上升沿才继续，这便实现了时钟延长（clock stretching）。因此主机并不是"按固定时间翻转 SCL"，而是"等待 SCL 实际发生边沿后再开始下一段计时"。

len 表示 DATA 阶段收发的字节数；写时主机连续发送、从机每字节回 ACK，末字节后进入 STOP；读时从机发送、主机对末字节回 NACK 后进入 STOP。与外部的握手复用单个 req 位——写时表示"本字节已发完、请准备下一字节"，读时表示"本字节已收满、请锁存 rd_data"；由于读写不可能同时发生，二者共用一位即可。

module IIC_Master #(
    parameter CLK_FREQ = 100_000_000,   // 系统时钟 100MHz
    parameter IIC_FREQ = 100_000       // IIC 速率 100kHz
)(
    input  wire       clk,        // 100MHz 系统时钟
    input  wire       rst_n,      // 异步复位（低有效）

    // 用户接口
    input  wire       start,      // 启动一次传输
    input  wire       rw,         // 1=读, 0=写
    input  wire [6:0] addr,       // 从机地址
    input  wire [7:0] reg_addr,   // 寄存器地址(ADDR_REG 发送)
    input  wire [7:0] len,        // 本次传输字节数 n（len>=1，0 视为 1）
    input  wire [7:0] wr_data,    // 待写数据（写模式：被 req 请求时由外部更新）
    output reg  [7:0] rd_data,    // 读到的数据（读模式：被 req 通知后由外部锁存）
    output reg        req,        // 单 bit 握手：写=本字节已发完、请求下一字节；读=本字节已收满、通知可锁存
    output reg        busy,       // 传输进行中
    output reg        done,       // 传输完成
    output reg        error,       // 错误标志：从机 NACK 地址或写数据时置 1，保持到下次 start 或成功完成才清零

    // IIC 双线（片外总线，开漏：逻辑1=释放引脚、由板级外接上拉拉高，逻辑0=本模块拉低）
    inout  wire       sda,
    inout  wire       scl
);

    // 时序参数
    localparam DIV    = CLK_FREQ / (2 * IIC_FREQ);   // 半周期 clk 数
    localparam T_HALF = DIV;                          // 每半周期固定计数
    localparam T_BUF  = CLK_FREQ / 200_000;           // STOP 后总线空闲时间
    localparam T_STOP  = CLK_FREQ / 250_000;
    localparam T_HDSTA = CLK_FREQ / 250_000;       // (repeated) START 后 SDA 保持低的保持时间 t_HD:STA(标准模式 4.0us)
    reg [$clog2(DIV):0] scl_cnt;
    reg [$clog2(T_STOP):0] stop_cnt;
    //SCL和SDA的OUTPUT ENABLE
    //起的是下拉作用，为1就是把SCL或SDA拉到0
    reg SCL_OE,SDA_OE;
    assign sda = SDA_OE ? 1'd0 : 1'dz;
    assign scl = SCL_OE ? 1'd0 : 1'dz;
    
    // 状态机
    localparam  IDLE  = 3'd0,
                START = 3'd1,
                ADDR_DEVICE  = 3'd2,
                ADDR_REG     = 3'd3,
                ADDR_RD      = 3'd4,
                DATA         = 3'd5,
                DATA_NEXT    = 3'd7,
                STOP         = 3'd6;
    reg [2:0] state;

    // 收发/计时寄存器
    reg [7:0] shift_reg;   // 发送移位 / 接收收集
    reg [3:0] bit_cnt;     // 0~7 数据位, 8=第9拍(ACK/NACK)
    reg [7:0] remain;      // 剩余待传字节数(含当前)
    reg       is_last;     // 当前读字节是否末字节(决定回 ACK 还是 NACK)
    reg       ack_phase;   // 读：ACK 拍已在上升沿被从机采样，待低电平释放
    reg       scl_run;     // 1=通信中生成 SCL；0=释放 SCL(高)
    reg       scl_run_d;
    wire      scl_run_pos = scl_run && !scl_run_d;   // 刚进入通信，产生首拍下降沿
    reg [$clog2(T_HDSTA):0] hd_cnt;    // t_HD:STA 保持计时
    reg       first_bit;               // 1=当前首字节首位需遵守 t_HD:STA(START 后保持 SDA 低)
    reg       start_fell;              // 1=已检测到 START 的 SCL 下降沿
    
    // 同步 SCL/SDA（异步于 clk），打拍检测边沿与读取实际电平
    reg [2:0] scl_sync, sda_sync;
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            scl_sync <= 3'b111;
            sda_sync <= 3'b111;
        end 
        else begin
            scl_sync <= {scl_sync[1:0], scl};
            sda_sync <= {sda_sync[1:0], sda};
        end
    end
    wire scl_in   = scl_sync[1];                 // 同步后的 SCL 电平
    wire sda_in   = sda_sync[1];                 // 同步后的 SDA 电平
    wire scl_rise = (scl_sync[2:1] == 2'b01);    // SCL 上升沿
    wire scl_fall = (scl_sync[2:1] == 2'b10);    // SCL 下降沿

    // SCL 生成（边沿触发 + 支持从机时钟延长）
    //   每检测到一次 SCL 实际边沿，重触发半周期计时；数到 T_HALF-1 翻转 SCL_OE。
    //   从机把 SCL 拉低时不会检测到上升沿 → 计数器不被重触发 → 主机停在原位等待，
    //   直到从机释放产生上升沿才继续，即时钟延长。
    //   scl_run_pos 时直接拉低，产生通信的第一个下降沿(START 之后的首个 SCL 跳变)。
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            scl_cnt   <= 0;
            SCL_OE    <= 1'b0;
            scl_run_d <= 1'b0;
        end
        else begin
            scl_run_d <= scl_run;
            if (!scl_run) begin
                scl_cnt <= 0;
                SCL_OE  <= 1'b0;          // 空闲/START/STOP：释放 SCL，保持高
            end
            else begin
                if (scl_run_pos) begin
                    SCL_OE  <= 1'b1;      // 刚启动：直接拉低，产生首拍下降沿
                    scl_cnt <= 0;
                end
                else if (scl_rise || scl_fall) begin
                    scl_cnt <= 0;         // 边沿重触发半周期计时
                end
                else if (scl_cnt < T_HALF) begin
                    scl_cnt <= scl_cnt + 1'b1;
                end
                if (scl_cnt == (T_HALF - 1))
                    SCL_OE <= ~SCL_OE;    // 半周期到，翻转驱动(释放<->拉低)
            end
        end
    end
    
    // SDA/状态机：基于 SCL 边沿收发
    //   scl_fall（进入低电平）：发送方设置下一位 SDA；第9拍释放 SDA 让从机回 ACK
    //   scl_rise（进入高电平）：采样 SDA（ACK / 数据位）
    //   每 8 位数据后跟 1 拍 ACK（从机拉低=ACK，释放=NACK）
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            state    <= IDLE;
            SDA_OE   <= 1'b0;
            scl_run  <= 1'b0;
            busy     <= 1'b0;
            done     <= 1'b0;
            req      <= 1'b0;
            error    <= 1'b0;
            shift_reg<= 8'h00;
            bit_cnt  <= 4'd0;
            remain   <= 8'd0;
            is_last  <= 1'b0;
            ack_phase<= 1'b0;
            stop_cnt <= 0;
            hd_cnt   <= 0;
            first_bit<= 1'b0;
            start_fell<= 1'b0;
        end
        else begin
            req <= 1'b0;   // 默认不请求；字节边界处脉冲置 1
            case (state)
                // 空闲：SDA/SCL 均释放(高)。start 拉低 SDA 形成 START
                IDLE: begin
                    SDA_OE  <= 1'b0;
                    scl_run <= 1'b0;
                    if (start) begin
                        busy    <= 1'b1;
                        done    <= 1'b0;
                        error   <= 1'b0;
                        SDA_OE  <= 1'b1;             // SCL 高时拉低 SDA = START
                        state   <= START;
                    end
                end

                // START：拉低 SDA(SCL 仍高)形成 START 条件，装载地址+W。
                // 首字节首位需遵守 t_HD:STA：ADDR_DEVICE 会等 SCL 落下后保持 SDA 低 t_HD:STA，再驱动地址 MSB。
                START: begin
                    SDA_OE    <= 1'b1;               // 维持 START(SDA 低)
                    shift_reg <= {addr, 1'b0};       // 设备地址 + W
                    bit_cnt   <= 4'd0;
                    scl_run   <= 1'b1;               // 触发首拍下降沿(scl_run_pos)
                    first_bit <= 1'b1;               // 首位需 t_HD:STA 保持
                    hd_cnt    <= 0;
                    start_fell<= 1'b0;
                    state     <= ADDR_DEVICE;
                end

                // 设备地址 + W：主机发 8 位，第9拍采样从机 ACK
                ADDR_DEVICE: begin
                    if (first_bit) begin
                        // t_HD:STA：START 的 SCL 落下后，SDA 继续维持低 t_HD:STA，再驱动首位(地址 MSB)
                        if (!start_fell) begin
                            if (scl_fall) start_fell <= 1'b1;   // 等 START 的 SCL 下降沿
                            SDA_OE <= 1'b1;                      // 维持 START 低
                        end
                        else if (hd_cnt < T_HDSTA) begin
                            hd_cnt  <= hd_cnt + 1'b1;            // 计 t_HD:STA
                            SDA_OE <= 1'b1;
                        end
                        else begin
                            SDA_OE   <= ~shift_reg[7];           // t_HD:STA 满足，驱动地址 MSB
                            first_bit<= 1'b0;
                            start_fell<= 1'b0;
                        end
                    end
                    else if (scl_fall) begin
                        if (bit_cnt < 4'd8) SDA_OE <= ~shift_reg[7];
                        else                SDA_OE <= 1'b0;   // 第9拍：释放等 ACK
                    end
                    else if (scl_rise) begin
                        if (bit_cnt < 4'd8) begin
                            shift_reg <= {shift_reg[6:0], 1'b0};
                            bit_cnt   <= bit_cnt + 1'b1;
                        end
                        else begin
                            if (sda_in) begin        // 从机 NACK 地址
                                error <= 1'b1; busy <= 1'b0; done <= 1'b1;
                                scl_run <= 1'b0; state <= IDLE;
                            end
                            else begin
                                shift_reg <= reg_addr;   // 装载寄存器地址
                                bit_cnt   <= 4'd0;
                                state     <= ADDR_REG;
                            end
                        end
                    end
                end

                // 寄存器地址：主机发 8 位，第9拍采样 ACK；写则进 DATA，读则 repeated START
                ADDR_REG: begin
                    if (scl_fall) begin
                        if (bit_cnt < 4'd8) SDA_OE <= ~shift_reg[7];
                        else                SDA_OE <= 1'b0;
                    end
                    else if (scl_rise) begin
                        if (bit_cnt < 4'd8) begin
                            shift_reg <= {shift_reg[6:0], 1'b0};
                            bit_cnt   <= bit_cnt + 1'b1;
                        end
                        else begin
                            if (sda_in) begin        // 从机 NACK
                                error <= 1'b1; busy <= 1'b0; done <= 1'b1;
                                scl_run <= 1'b0; state <= IDLE;
                            end
                            else if (rw == 1'b0) begin
                                // 写：进入 DATA 发送 len 字节（首字节 wr_data 在 start 时已备好）
                                shift_reg <= wr_data;
                                remain   <= (len == 8'd0) ? 8'd1 : len;
                                is_last  <= ((len == 8'd0) ? 8'd1 : len) == 8'd1;
                                bit_cnt  <= 4'd0;
                                state    <= DATA;
                            end
                            else begin
                                // 读：SCL 高时拉低 SDA = repeated START，随后发 地址+R
                                // repeated START 与 START 一样需要保持 t_HD:STA，
                                // 因此进入 ADDR_RD 时置位 first_bit 等标志，由其完成保持后再驱动首位。
                                SDA_OE    <= 1'b1;
                                shift_reg <= {addr, 1'b1};   // 设备地址 + R
                                bit_cnt   <= 4'd0;
                                first_bit <= 1'b1;           // 首位需 t_HD:STA 保持
                                start_fell<= 1'b0;
                                hd_cnt    <= 0;
                                state     <= ADDR_RD;
                            end
                        end
                    end
                end

                // 设备地址 + R（仅读）：repeated START 后的首位同样需保持 t_HD:STA，
                // 然后主机发 8 位，第9拍采样 ACK 后进入 DATA 接收
                ADDR_RD: begin
                    if (first_bit) begin
                        // t_HD:STA：repeated START 的 SCL 落下后，SDA 继续维持低 t_HD:STA，再驱动首位(地址 MSB)
                        if (!start_fell) begin
                            if (scl_fall) start_fell <= 1'b1;   // 等 repeated START 的 SCL 下降沿
                            SDA_OE <= 1'b1;                      // 维持 START 低
                        end
                        else if (hd_cnt < T_HDSTA) begin
                            hd_cnt  <= hd_cnt + 1'b1;            // 计 t_HD:STA
                            SDA_OE <= 1'b1;
                        end
                        else begin
                            SDA_OE   <= ~shift_reg[7];           // t_HD:STA 满足，驱动地址 MSB
                            first_bit<= 1'b0;
                            start_fell<= 1'b0;
                        end
                    end
                    else if (scl_fall) begin
                        if (bit_cnt < 4'd8) SDA_OE <= ~shift_reg[7];
                        else                SDA_OE <= 1'b0;
                    end
                    else if (scl_rise) begin
                        if (bit_cnt < 4'd8) begin
                            shift_reg <= {shift_reg[6:0], 1'b0};
                            bit_cnt   <= bit_cnt + 1'b1;
                        end
                        else begin
                            if (sda_in) begin        // 从机 NACK
                                error <= 1'b1; busy <= 1'b0; done <= 1'b1;
                                scl_run <= 1'b0; state <= IDLE;
                            end
                            else begin
                                shift_reg <= 8'h00;
                                remain   <= (len == 8'd0) ? 8'd1 : len;
                                is_last  <= ((len == 8'd0) ? 8'd1 : len) == 8'd1;
                                bit_cnt  <= 4'd0;
                                state    <= DATA;
                            end
                        end
                    end
                end

                // 数据阶段：写=主机发+从机ACK；读=从机发+主机ACK/NACK
                DATA: begin
                    // —— 写 ——
                    if (rw == 1'b0) begin
                        if (scl_fall) begin
                            if (bit_cnt < 4'd8) SDA_OE <= ~shift_reg[7];
                            else                SDA_OE <= 1'b0;
                        end
                        else if (scl_rise) begin
                            if (bit_cnt < 4'd8) begin
                                shift_reg <= {shift_reg[6:0], 1'b0};
                                bit_cnt   <= bit_cnt + 1'b1;
                            end
                            else begin
                                if (sda_in) begin    // 从机 NACK 数据
                                    error <= 1'b1; busy <= 1'b0; done <= 1'b1;
                                    scl_run <= 1'b0; state <= IDLE;
                                end
                                else if (remain > 8'd1) begin
                                    req      <= 1'b1;       // 请求外部准备下一字节
                                    remain   <= remain - 1'b1;
                                    is_last  <= (remain - 1'b1) == 8'd1;
                                    bit_cnt  <= 4'd0;
                                    state    <= DATA_NEXT;   // 等 wr_data 更新后再装载
                                end
                                else begin
                                    state <= STOP;          // 全部发完
                                end
                            end
                        end
                    end
                    // —— 读 ——
                    else begin
                        if (scl_fall) begin
                            if (bit_cnt < 4'd8) SDA_OE <= 1'b0;   // 接收期间释放
                            else if (!ack_phase) SDA_OE <= is_last ? 1'b0 : 1'b1; // ACK/NACK
                            else begin
                                SDA_OE   <= 1'b0;
                                if (!is_last) begin
                                    remain   <= remain - 1'b1;
                                    shift_reg<= 8'h00;
                                    bit_cnt  <= 4'd0;
                                    is_last  <= (remain - 1'b1) == 8'd1;
                                end
                                ack_phase <= 1'b0;
                            end
                        end
                        else if (scl_rise) begin
                            if (bit_cnt < 4'd8) begin
                                shift_reg <= {shift_reg[6:0], sda_in};
                                if (bit_cnt == 4'd7) begin
                                    rd_data <= {shift_reg[6:0], sda_in};  // 收满 8 位
                                    req     <= 1'b1;                     // 通知外部锁存
                                    bit_cnt <= 4'd8;                     // 进入第9拍
                                end
                                else bit_cnt <= bit_cnt + 1'b1;
                            end
                            else begin
                                // 第9拍上升沿：从机已采样到本字节 ACK/NACK
                                if (is_last) state <= STOP;
                                else          ack_phase <= 1'b1;
                            end
                        end
                    end
                end

                // 字节边界缓冲：本拍外部已在 req 后把 wr_data 更新为新字节，
                // 此刻再装入 shift_reg，确保下一个字节发出的是"新值"而非刚发完的旧值。
                DATA_NEXT: begin
                    shift_reg <= wr_data;
                    state     <= DATA;
                end

                // 停止位：先停 SCL(释放→高)，SCL 高时拉低 SDA，保持 T_STOP 后释放 SDA=STOP
                STOP: begin
                    scl_run <= 1'b0;                 // 释放 SCL，等待变高
                    SDA_OE  <= 1'b1;                 // 保持 SDA 低，等 SCL 高
                    if (scl_in) begin
                        if (stop_cnt < T_STOP) stop_cnt <= stop_cnt + 1'b1;
                        else begin
                            SDA_OE <= 1'b0;          // 释放 SDA→高：SCL 高时 SDA 上升 = STOP
                            done    <= 1'b1;
                            error   <= 1'b0;
                            busy    <= 1'b0;
                            state   <= IDLE;
                        end
                    end
                    else stop_cnt <= 0;
                end

                default: state <= IDLE;
            endcase
        end
    end
    

endmodule

从机

从机作为总线外设，通过一组片内接口与内部逻辑交互。本从机仅实现 IIC 协议，不包含具体设备功能（例如 EEPROM、RTC 等寄存器逻辑），因此可以作为通用 IIC Slave IP 复用。

端口分为三组：片内总线侧 clk/rst_n，IIC 侧 scl/sda，以及内部交互接口 reg_addr / data_out / data_in / req / busy / done / error / rw。

IIC 侧先把 scl/sda 打两拍同步以消除亚稳态，再据此检测边沿与起始/停止条件，用状态机完成与主机对齐的标准 IIC 从机协议：先匹配 7 位地址 → 收 1 字节寄存器地址（reg_addr）→ 进入数据收发。寄存器指针 reg_ptr 取自主机发来的寄存器地址字节（8 位），每收发 1 字节指针自增，因此天然支持跨多个寄存器的连续读写：

写：主机先写 reg_addr，随后连发 N 字节；从机每收到 1 字节，就把 data_out 连同当前 reg_addr 通过 req 脉冲交给内部锁存，并使指针自增。
读：主机先写 reg_addr，再发 repeated START + 地址+R；从机在每个读字节开始前提前一拍用 req 请求内部把 reg_addr 处数据放到 data_in，随后从 data_in 取数连续送出，每字节后指针自增。

SDA 采用开漏建模：仅在需要拉低（回 ACK、或发送的数据位为 0）时驱动 0，其余时刻释放为高阻，由片外引脚上的上拉电阻拉高；从机只在 SCL 低电平期间更新 SDA、在高电平期间保持稳定，因此自身的跳变不会被误判为起始/停止条件。

module iic_slave #(
    parameter [6:0] SLAVE_ADDR = 7'h50    // 本从机地址（由上层指定）
)(
    input  wire       clk,       // 片内总线时钟
    input  wire       rst_n,     // 异步复位（低有效）

    input  wire       scl,       // IIC 时钟（主机驱动，异步于 clk）
    inout  wire       sda,       // IIC 数据（开漏，双向）

    // ===== 内部交互接口（片内逻辑侧）=====
    output wire [7:0] reg_addr,  // 当前访问的寄存器地址（字节偏移），输出给内部
    output reg  [7:0] data_out,  // 写方向：主机写来的数据，输出给内部锁存
    input  wire [7:0] data_in,   // 读方向：内部给从机的数据，由内部按 reg_addr 提供
    output reg        req,       // 单 bit 握手：
                                 //   写=收到 1 字节、请求内部把 data_out 锁存到 reg_addr；
                                 //   读=即将发送 1 字节、请求内部把 reg_addr 处数据放到 data_in
    output reg        busy,      // 从机正处于一次传输中（START 到 STOP）
    output reg        done,      // 一次传输完成（检测到 STOP）
    output reg        error,     // 错误标志（保留/可扩展：如内部 NACK、越界等，正常为 0）
    output reg        rw         // 当前传输方向：1=读（从机发，数据来自 data_in），0=写（从机收，给 data_out）
);

    // ============================================================
    // 一、SCL/SDA 打两拍同步 + 边沿 / 起止条件检测
    // ============================================================
    reg [2:0] scl_sync, sda_sync;
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            scl_sync <= 3'b111;
            sda_sync <= 3'b111;
        end else begin
            scl_sync <= {scl_sync[1:0], scl};
            sda_sync <= {sda_sync[1:0], sda};
        end
    end
    wire scl_rise = (scl_sync[2:1] == 2'b01);
    wire scl_fall = (scl_sync[2:1] == 2'b10);
    wire scl_high =  scl_sync[1];
    wire sda_in   =  sda_sync[1];
    wire start_cond = scl_high && (sda_sync[2:1] == 2'b10);
    wire stop_cond  = scl_high && (sda_sync[2:1] == 2'b01);

    // ============================================================
    // 二、SDA 开漏输出（片外总线）：仅在需要"拉低"时驱动 0，其余释放为高阻。
    // ============================================================
    reg sda_oe, sda_d;
    assign sda = (sda_oe && (sda_d == 1'b0)) ? 1'b0 : 1'bz;

    // ============================================================
    // 三、IIC 从机状态机（与主机协议对齐：地址+W → 寄存器地址 → [repeated START+地址+R] → 数据）
    //     寄存器地址 reg_ptr 取自主机发来的寄存器地址字节（8 位），收发后自增；
    //     写：每收到 1 字节经 req 交给内部（data_out + reg_addr）；
    //     读：每发 1 字节前经 req 向内部要数（data_in），从 data_in 取出连续送出。
    // ============================================================
    localparam S_IDLE  = 3'd0,
               S_START = 3'd1,
               S_ADDR  = 3'd2,
               S_ACK   = 3'd3,
               S_DATA  = 3'd4,
               S_STOP  = 3'd5;
    reg [2:0] state;

    reg [3:0] bit_cnt;
    reg [7:0] shift_rx;
    reg [7:0] addr_byte;
    reg [7:0] shift_tx;
    reg [7:0] reg_ptr;   // 寄存器地址指针（8 位，主机发来的寄存器地址字节），收发后自增
    reg       mack;
    reg       got_addr;
    reg       reg_done;
    reg       slave_tx;

    assign reg_addr = reg_ptr;   // 当前寄存器地址直接给内部

    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            state     <= S_IDLE;
            sda_oe    <= 1'b0;
            sda_d     <= 1'b1;
            bit_cnt   <= 4'd0;
            shift_rx  <= 8'd0;
            shift_tx  <= 8'd0;
            reg_ptr   <= 8'd0;
            rw        <= 1'b0;
            mack      <= 1'b0;
            got_addr  <= 1'b0;
            reg_done  <= 1'b0;
            slave_tx  <= 1'b0;
            data_out  <= 8'd0;
            req       <= 1'b0;
            busy      <= 1'b0;
            done      <= 1'b0;
            error     <= 1'b0;
        end
        else begin
            req  <= 1'b0;   // 默认不请求；需要时脉冲置 1
            done <= 1'b0;   // 默认非完成；STOP 时脉冲置 1

            // 起始/停止条件最高优先级：随时重定位状态机
            if (start_cond) begin
                state     <= S_START;
                bit_cnt   <= 4'd0;
                sda_oe    <= 1'b0;
                got_addr  <= 1'b0;
                reg_done  <= 1'b0;
                slave_tx  <= 1'b0;
                busy      <= 1'b1;
                // reg_ptr 保留，repeated START 后读仍从已设 reg_addr 起
            end
            else if (stop_cond) begin
                state  <= S_STOP;
                sda_oe <= 1'b0;
                busy   <= 1'b0;
                done   <= 1'b1;   // 传输完成脉冲
            end
            else begin
                case (state)
                    S_IDLE: begin
                        sda_oe <= 1'b0;
                    end

                    S_START: begin
                        bit_cnt <= 4'd0;
                        sda_oe  <= 1'b0;
                        state   <= S_ADDR;
                    end

                    // ADDR：收 8 位地址字节（MSB 先入）。收满后在 ACK 拍回 ACK 并判匹配/R-W。
                    S_ADDR: begin
                        if (scl_rise) begin
                            if (bit_cnt < 4'd8) begin
                                shift_rx <= {shift_rx[6:0], sda_in};
                                bit_cnt  <= bit_cnt + 1'b1;
                                if (bit_cnt == 4'd7)
                                    addr_byte <= {shift_rx[6:0], sda_in};
                            end
                        end
                        else if (scl_fall) begin
                            if (bit_cnt == 4'd8) begin
                                if (addr_byte[7:1] == SLAVE_ADDR) begin
                                    rw     <= addr_byte[0];
                                    sda_oe <= 1'b1;
                                    sda_d  <= 1'b0;
                                    // 读方向：提前一拍请求内部提供 reg_ptr 指向的数据（下一字节即读首字节）
                                    if (addr_byte[0] == 1'b1) req <= 1'b1;
                                    state  <= S_ACK;
                                end else begin
                                    sda_oe <= 1'b0;
                                    state  <= S_IDLE;
                                end
                            end
                        end
                    end

                    // ACK：每字节后的应答拍。
                    //   从机发送方向(slave_tx=1，读数据)：释放 SDA，SCL 高采样主机 ACK/NACK，下降沿续传/结束；
                    //   从机接收方向(slave_tx=0)：本低电平已驱动 ACK，下降沿释放并按子阶段决定去向。
                    S_ACK: begin
                        if (slave_tx == 1'b1) begin
                            if (scl_rise) begin
                                mack <= sda_in;             // 0=ACK 续传，1=NACK 结束
                            end
                            else if (scl_fall) begin
                                if (mack == 1'b0) begin
                                    // 主机 ACK：续传下一字节（数据已在上一字节末经 req 请求）
                                    bit_cnt <= 4'd0;
                                    state   <= S_DATA;
                                end else begin
                                    sda_oe <= 1'b0;         // NACK：主机结束读
                                    state  <= S_IDLE;
                                end
                            end
                        end
                        else begin
                            if (scl_fall) begin
                                sda_oe  <= 1'b0;            // 释放 ACK
                                bit_cnt <= 4'd0;
                                if (got_addr == 1'b0) begin
                                    // 刚 ACK 的是"地址字节"
                                    got_addr <= 1'b1;
                                    if (rw == 1'b1) begin
                                        // 读：进入发送（reg_ptr 已由前面 reg_addr 字节设好，数据经 req 已请求）
                                        slave_tx <= 1'b1;
                                        reg_done <= 1'b1;
                                        bit_cnt  <= 4'd0;
                                        state    <= S_DATA;
                                    end else begin
                                        // 写：进入 DATA 收寄存器地址
                                        slave_tx <= 1'b0;
                                        reg_done <= 1'b0;
                                        state    <= S_DATA;
                                    end
                                end
                                else if (reg_done == 1'b0) begin
                                    // 刚 ACK 的是"寄存器地址字节"：锁存寄存器地址
                                    reg_ptr  <= shift_rx;
                                    reg_done <= 1'b1;
                                    slave_tx <= 1'b0;
                                    state    <= S_DATA;
                                end
                                else begin
                                    // 刚 ACK 的是"写数据字节"：交给内部锁存
                                    data_out <= shift_rx;          // 写来的数据给内部
                                    req      <= 1'b1;             // 请求内部锁存到当前 reg_addr
                                    reg_ptr  <= reg_ptr + 1'b1;   // 指针自增
                                    slave_tx <= 1'b0;
                                    state    <= S_DATA;
                                end
                            end
                        end
                    end

                    // DATA：收发一个字节（MSB 先）。
                    //   发(slave_tx=1，读数据)：首拍从 data_in 装载，SCL 低电平驱动位，发满 8 位后释放供主机应答；
                    //   收(slave_tx=0，含 reg_addr 与写数据)：SCL 上升沿移位，收满 8 位后本低电平驱动 ACK。
                    S_DATA: begin
                        if (slave_tx == 1'b1) begin
                            if (scl_fall) begin
                                if (bit_cnt == 4'd0) begin
                                    // 首拍：装载内部提供的读数据（req 已提前一拍请求）
                                    shift_tx <= {data_in[6:0], 1'b0};
                                    sda_oe   <= 1'b1;
                                    sda_d    <= data_in[7];
                                    bit_cnt  <= 4'd1;
                                end
                                else if (bit_cnt < 4'd8) begin
                                    sda_oe   <= 1'b1;
                                    sda_d    <= shift_tx[7];
                                    shift_tx <= {shift_tx[6:0], 1'b0};
                                    bit_cnt  <= bit_cnt + 1'b1;
                                end
                                else begin
                                    // 8 位发完，释放供主机 ACK/NACK；自增指针并提前请求下一字节
                                    sda_oe   <= 1'b0;
                                    reg_ptr  <= reg_ptr + 1'b1;
                                    req      <= 1'b1;
                                    state    <= S_ACK;
                                end
                            end
                        end
                        else begin
                            if (scl_rise) begin
                                if (bit_cnt < 4'd8) begin
                                    shift_rx <= {shift_rx[6:0], sda_in};
                                    bit_cnt  <= bit_cnt + 1'b1;
                                end
                            end
                            else if (scl_fall) begin
                                if (bit_cnt == 4'd8) begin
                                    sda_oe <= 1'b1;         // 驱动 ACK
                                    sda_d  <= 1'b0;
                                    state  <= S_ACK;
                                end
                            end
                        end
                    end

                    S_STOP: begin
                        sda_oe <= 1'b0;
                        state  <= S_IDLE;
                    end

                    default: state <= S_IDLE;
                endcase
            end
        end
    end

endmodule

Verilog语法教程

Mon, 22 Jun 2026 00:00:00 +0000

Verilog 语法教程

Verilog HDL（简称 Verilog）是一种硬件描述语言（Hardware Description Language, HDL），用于数字电路的系统设计。它能在算法级、门级、开关级等多种抽象层次上对硬件进行建模。

阅读本教程前，你需要了解基本的数字电路知识，包括组合逻辑、时序逻辑与时钟/复位的概念。

如果想要动手练习 Verilog，建议在 HDLBits 网站进行练习。

一个完整例子

下面先看一个完整的计数器模块，再逐块拆解它用到的语法：

module counter10(
    input         rstn,        // 复位端，低有效
    input         clk,         // 输入时钟
    output [3:0]  cnt,         // 4 位计数输出
    output        cout         // 溢出进位
);

    reg [3:0] cnt_temp;        // 计数寄存器

    always @(posedge clk or negedge rstn) begin
        if (!rstn)
            cnt_temp <= 4'b0;                       // 复位时归零
        else if (cnt_temp == 4'd9)
            cnt_temp <= 4'b0;                       // 计到 9 后归零
        else
            cnt_temp <= cnt_temp + 1'b1;            // 否则加 1
    end

    assign cout = (cnt_temp == 4'd9);  // 进位：计到 9 时拉高
    assign cnt  = cnt_temp;            // 实时计数输出
endmodule

一、module 与文件结构

一个 Verilog 设计由若干 module（模块） 组成，每个模块用 module ... endmodule 包裹：

module 后跟模块名与端口列表，endmodule 表示模块结束（结尾没有分号）。
模块名应使用有意义的英文，不能是 Verilog 关键字，也不能含空格。
工程中通常一个 .v 文件只放一个 module，且文件名与模块名保持一致，方便工具管理。
模块内部由**端口声明、数据类型定义、连续赋值（assign）、过程块（always）**等部分构成。

module 模块名 ( 端口列表 );
    // 端口声明
    // 信号/寄存器定义
    // assign 连续赋值
    // always 过程块
endmodule

注释

Verilog 支持两种注释，与 C 语言相同：

行注释 //：从 // 到本行行尾。
块注释 /* ... */：可跨越多行。

// 这是一行注释
reg [3:0] cnt;   // 行尾也可以写注释
/* 这是
   跨行块注释 */

注释会被综合器忽略，仅用于提升可读性。建议对关键信号含义、状态编码、时序/约束意图加上注释。

二、端口定义

端口是模块与外部电路的接口，必须声明方向与（可选的）类型/位宽。

1. 三种方向

方向	含义	典型用途
`input`	模块输入，由外部驱动	时钟、复位、数据输入
`output`	模块输出	数据/状态输出
`inout`	双向（三态）	开漏总线，如 IIC 的 `sda`/`scl`

2. 端口默认是 wire

端口声明时若只写方向（不写 reg），默认类型为 wire。因此：

input 永远是外部驱动的 wire，不能被 always 赋值。
output 若要在 always 块里被赋值，必须显式声明为 reg（即 output reg）；若仅由 assign 驱动则保持 wire。

3. 两种声明风格

现代 ANSI 风格（推荐）：方向与类型直接写在端口列表中，直观不易出错。

module counter10(
    input         rstn,
    input         clk,
    output [3:0]  cnt,      // 默认 wire，用 assign 驱动
    output        cout      // 默认 wire
);
    // ...
endmodule

传统非 ANSI 风格：端口列表只列名字，类型/方向再到模块体内声明（旧代码常见，但容易遗漏）：

module counter10(rstn, clk, cnt, cout);
    input  rstn;
    input  clk;
    output [3:0] cnt;
    output       cout;
    // ...
endmodule

三、数据类型：wire 与 reg

Verilog 中最常用的两种变量类型是 线网（wire） 与 寄存器（reg）。

1. wire（线网类型）

顾名思义表示一根"导线"，自身不能存储状态，必须由外部驱动才能呈现 0 或 1（驱动源可以是 assign、模块端口或基本门）。常用于组合逻辑的输出与模块间的连线。

1
2
3

wire        interrupt;
wire        flag1, flag2;
wire        gnd = 1'b0;      // 常接地的线

2. reg（寄存器类型）

reg 类型变量可以在过程块（always）中被赋值。从硬件角度看，它名字里的"寄存器"容易误导——它不一定综合成真正的触发器，最终变成什么电路，完全取决于它写在哪种 always 里：

写在 always @(posedge clk) 里 → 综合成 D 触发器（Flip-Flop）：每位都是一个小存储单元，只在时钟上升沿"啪"地记住新值，平时保持不动。这是 reg 最常见的硬件形态。
写在 always @(*) 里 → 综合成组合门电路（如与门、或门、选择器），没有记忆，输出随输入即时变化。此时 reg 只是"过程中暂存变量"，并不是真正的寄存器。
若分支没写全（缺 else / default）→ 综合器为"保持原值"会悄悄生成锁存器（latch），一般要尽量避免。

一句话：reg 在时序块里 = 触发器（有记忆），在组合块里 = 组合门（无记忆），关键在于它所在的 always。

1
2
3

reg         clk_temp;
reg         flag1, flag2;
reg  [3:0]  counter;

简单记忆：assign 驱动的用 wire，always 块里被赋值的用 reg。

3. signed 有符号类型（仅介绍）

入门阶段极少用到，这里只做概念性介绍，不要求掌握，知道有这回事即可。

默认情况下 wire / reg 是无符号的，算术与比较都按无符号处理。在类型后加 signed 关键字可声明为有符号（二进制补码），此时算术、关系运算以及 >>> 算术右移都会按正负来解释：

reg signed [7:0] a;     // 有符号 8 位，范围 -128 ~ +127
reg        [7:0] b;     // 无符号 8 位，范围 0 ~ 255

a = -8'sd10;            // 注意：字面量也要带 s 才是"有符号字面量"

要点：有符号只改变"如何解释这些 bit"与运算规则；线网/寄存器里存的仍是普通 bit。当有符号与无符号操作数混用时，结果按无符号处理，需要特别小心。

四、位宽与向量

1. 标量 vs 向量

从硬件角度看，Verilog 里的一个信号其实就是一根导线；指定位宽后，它就变成一捆并排的多根导线，这捆"导线束"就叫做向量（vector）。

标量（scalar）：没有指定位宽，本质是 1 根导线，只能表示 0 或 1 一个 bit。
向量（vector）：位宽大于 1，本质是 N 根并排的导线，可一次性承载 N 个 bit，做多位运算（[3:0] 就是 4 根导线，编号 0~3）。

1
2
3

wire        a;          // 1 根导线（1 位标量）
reg  [3:0]  counter;    // 4 根并排导线（4 位向量），位宽 = 3-0+1 = 4
wire [31:0] data;       // 32 根并排导线（32 位向量/总线）

可以想象 wire [31:0] data; 在电路里并不是一根"粗线"，而是 data[0]、data[1] … data[31] 共 32 根独立的导线捆在一起，平时统一叫 data 来批量操作。这种"多根导线"的视角，对理解后面的位选、拼接、移位都很关键。

2. 向量声明与高低位

向量格式为 [msb : lsb]（高位在前、低位在后），位宽 = msb - lsb + 1：

1
2
3

reg  [3:0]   counter;     // 大端：bit3 为最高位 MSB，bit0 为最低位 LSB
wire [8:2]   addr;        // 7 位向量，编号从 8 到 2
reg  [0:31]  data;        // 小端：bit0 为 MSB（不推荐，易混淆，尽量统一用 [msb:lsb]）

3. 位选与域选

可以对向量做单 bit 选择或连续段选择：

1
2

counter[0]        // 取最低位
counter[3:1]      // 取 bit3、bit2、bit1 共 3 位

4. 拼接与复制

拼接运算符 {}：把多个信号拼成更宽的总线。
复制 {n{ }}：把某值重复 n 次。

1
2

wire [7:0] bus = {cnt, 4'b0000};     // 把 4 位 cnt 拼到高 4 位，低 4 位补 0
wire [3:0] zero = {4{1'b0}};         // 等价于 4'b0000

5. 向量的数组（存储器）

前面说的 reg [3:0] counter 是一个"4 位宽的向量"。如果再加一对方括号，就声明了一组相同宽度的向量，也就是存储器（memory） —— 常用于寄存器堆、RAM、FIFO 等：

1
2
3

reg [7:0] byte1 [3:0];    // 声明一个"4 个字、每字 8 位"的存储器
                           // 左侧 [7:0] = 每个字的位宽
                           // 右侧 [3:0] = 字的个数（地址范围 0~3）

读法要分清两个维度：

左侧 [7:0] 是"每个元素的位宽"（数据宽度）。
右侧 [3:0] 是"元素的个数/地址范围"（深度）。

1
2
3

byte1[0]           // 取第 0 个字（一个 8 位向量）
byte1[2][7:0]      // 取第 2 个字的全部 8 位
byte1[addr][3]     // 取第 addr 个字的第 3 位

注意几个常见限制：
不能一次性对整个存储器赋值，只能按字逐一赋值（通常写在带下标的 always 块里）：
1
2
3
4
integer i;
always @(posedge clk) begin
    if (wen) byte1[waddr] <= wdata;  // 只写某一个字
end
存储器元素（byte1[addr]）在传统的连续赋值 assign 中不能直接整体驱动，一般放在 always 块里用 reg 描述，或用 for 循环初始化。

wire 也可以声明成数组（如 wire [7:0] bus [3:0]），但在可综合设计中存储器几乎都用 reg。

五、数值的表示方式

1. 四种逻辑值

Verilog 用下列四种基本值表示硬件电平：

值	含义
`0`	逻辑 0 或"假"
`1`	逻辑 1 或"真"
`x` / `X`	未知（未初始化 / 多驱动冲突）
`z` / `Z`	高阻（常用于 `inout` 三态/开漏释放）

2. 基数格式

数字语法为 <位宽>'<基数><数值>，合法的基数有四种：

二进制 'b / 'B
十进制 'd / 'D
十六进制 'h / 'H
八进制 'o / 'O

为严谨，实际编码中一般始终指定位宽：

1
2
3

4'b1011             // 4 位二进制
32'h3022_c0de       // 32 位十六进制，下划线仅便于阅读、无实际意义
4'd9                // 4 位十进制 9

3. 不定宽、负数与实数

不指定位宽时，编译器通常按宿主字长（常见 32 位）处理：counter = 'd100; 或 counter = 100;。
负数在位宽之前加减号：counter = -6'd15; 是合法的；- 放在数值之后（如 4'd-2）则非法。
Verilog 还有 real 实数类型，支持科学计数法（如 1.2e4、1E-3），但不参与综合，只用于测试/建模。

六、运算符与基础计算

Verilog 提供丰富的运算符。下面按"算术前先补一句：所有运算都在位上按位宽进行，结果位宽不够会截断高位、不够会补符号/零"来分类介绍最常用的几类。

1. 算术运算符

运算符	含义	说明
`+`	加	按位宽相加，溢出则截断高位
`-`	减	按位宽相减
`*`	乘	综合为乘法器，结果位宽通常为两操作数位宽之和
`/`	除	综合资源开销大，尽量少用（2 的幂建议用移位代替）
`%`	取模	同 `/`，综合代价高，慎用

reg [7:0] a, b;
reg [8:0] sum;        // 进位位宽多留 1 位
reg [15:0] prod;

sum  = a + b;         // 8 位 + 8 位，结果用 9 位接住进位
prod = a * b;         // 8×8 = 16 位

注意：Verilog 中的 + - * 是无符号按位宽计算；若操作数带 signed 声明则为有符号运算。位宽不匹配时，窄的操作数会零扩展（无符号）或符号扩展（有符号）到宽的位宽后参与运算。

2. 移位运算符

运算符	含义	说明
`<<`	逻辑左移	右侧补 0，等价于 ×2ⁿ
`>>`	逻辑右移	左侧补 0，等价于 ÷2ⁿ
`<<<`	算术左移	有符号场景下同逻辑左移
`>>>`	算术右移	有符号时左侧补符号位（保持正负）

reg [7:0] x;
x = x << 1;           // 左移 1 位（乘 2），低位补 0
x = x >> 2;           // 右移 2 位（除 4），高位补 0
x = x <<< 1;          // 算术左移

硬件视角：移位在综合后几乎不消耗逻辑资源——它并不是"计算"，而是把导线重新连了一下。例如 x << 1 综合出来就是：把 x[6:0] 接到输出 [7:1]、输出最低位 [0] 接地（补 0）。正因为只是"改接线"，所以比乘除法器便宜得多。

因此，对 2 的整数次幂的乘除，优先用移位实现，比 /、* 更省逻辑资源。例如 addr * 4 写成 addr << 2。

3. 位运算与归约运算符

运算符	含义	说明
`~`	按位取反	每一位取反
`&`	按位与	对应位相与
`\|`	按位或	对应位相或
`^`	按位异或	不同为 1
`~^` / `^~`	同或	相同为 1
`&`(单目)	归约与	把所有位"与"起来，得 1 位
`\|`(单目)	归约或	把所有位"或"起来，得 1 位
`^`(单目)	归约异或	奇偶校验常用

reg [3:0] v;
reg       all_one, any_one, parity;

all_one  = &v;        // 归约与：v 全 1 时为 1
any_one  = |v;        // 归约或：v 任意位为 1 时为 1
parity   = ^v;        // 归约异或：v 中 1 的个数为奇数时为 1

4. 关系与等式运算符

运算符	含义
`>` `>=` `<` `<=`	大小比较，结果为 1 位
`==` `!=`	相等 / 不等
`===` `!==`	全等 / 不全等（会区分 `x`/`z`，仅用于仿真，不可综合）

`1`	`if (cnt == 4'd9) ... // 组合/时序里常用 == 做判断`

5. 拼接、复制与条件运算符

拼接 {}：已在"位宽与向量"一节介绍，可把多个信号拼成更宽总线。
复制 {n{ }}：重复某值 n 次。
条件运算符 ?:：条件 ? 真值 : 假值，常用于 assign 中做二选一。

1
2
3

assign sel_out = sel ? a : b;          // 二选一多路器
assign bus     = {hi, 8'b0, lo};       // 拼接
assign mask    = {8{1'b1}};            // 8 位全 1

运算符优先级与 C 语言类似（乘除移位 > 加减 > 比较 > 位运算 > 条件），写复杂表达式时多用括号避免歧义。

七、always 过程块

always 是描述硬件行为的过程块，内部可以写 if/else、case、for 等控制语句。它的行为完全由**敏感表（sensitivity list）**决定——敏感表里写什么事件，块就在什么事件发生时执行。

实际工程中，绝大多数的 always 只有两种"标准写法"，分别对应时序逻辑和组合逻辑：

写法	触发方式	综合出	典型用途	赋值方式
`always @(posedge clk or negedge rst_n)`	时钟 / 复位边沿	触发器（带复位）	打拍、计数、状态机	非阻塞 `<=`
`always @(*)`	任意输入信号变化	组合逻辑（门电路）	译码、多选一、运算	阻塞 `=`

下面分别介绍这两种写法。

1. 时序逻辑：`always @(posedge clk or negedge rst_n)`

敏感表里写的是边沿事件，块只在边沿到来的那一时刻执行一次。这是描述触发器（Flip-Flop）与寄存器的最标准形式，几乎总是写成"时钟上升沿 + 复位下降沿"：

always @(posedge clk or negedge rst_n) begin
    if (!rst_n)
        q <= 1'b0;          // 复位有效（低有效）时，值清零
    else
        q <= d;             // 否则在时钟上升沿把 d 锁存到 q
end

posedge clk：时钟上升沿触发——每个时钟沿把输入"打一拍"。
negedge rst_n：复位下降沿也触发，因此复位是异步的（复位一拉低立刻生效，不等待时钟）。
若要做同步复位，就把复位写进 if 判断、且不列入敏感表：always @(posedge clk) if (!rst_n) ...。
这种写法综合出来的是带复位的 D 触发器；块内使用非阻塞 <= 赋值（见 §八）。

2. 组合逻辑：`always @(*)`

组合逻辑的输出只取决于当前输入（没有时钟、没有记忆），所以只要右侧用到的任何信号变化，输出就该立刻更新。敏感表用通配符 * 表示"自动包含所有用到的信号"，既省事又不会漏写：

always @(*) begin
    case (sel)
        2'b00:   y = a;
        2'b01:   y = b;
        2'b10:   y = c;
        default: y = 1'b0;
    endcase
end

* 等价于手动列出 always @(a or b or c or sel)，但不用手列，避免漏写敏感信号导致仿真与综合行为不一致。
组合逻辑块内使用阻塞 = 赋值（见 §八）。
一定要把分支写全（加 default），否则综合器会推断出锁存器（见 §3）。

硬件视角：上面这段 case 综合后，本质就是一个多路选择器（MUX）——sel 是选择信号，它控制把 a / b / c / 0 中的哪一路"连"到输出 y。所以 case、或者 ?: 条件运算符，在硬件里都是同一个东西：一个被选择信号控制的多路开关。

3. 避免意外锁存器（latch）

组合逻辑里，如果 if 缺少 else、或 case 缺少 default，综合器会认为"条件不满足时输出应保持原值"，从而推断出锁存器。通常我们不希望出现锁存器，所以组合 always 要分支写全：

always @(*) begin
    if (sel)
        y = a;
    else                // 必须有 else，否则 y 在 sel=0 时被锁存
        y = b;
end

4. begin / end 语句块

begin ... end 把多条语句组织成一个顺序语句块，相当于 C 的 { }。在 always、if、case、for 等结构里，当分支包含多条语句时必须用 begin/end 包裹（单条语句可省略）：

always @(posedge clk) begin
    if (en) begin
        a <= 1'b1;
        b <= 1'b0;   // 多条语句必须包在 begin/end 中
    end
    else
        a <= 1'b0;   // 单条语句可省略 begin/end
end

5. case 语句

case 是多分支选择，常用于译码、状态机跳转。语法：case (表达式) 分支1: 语句; 分支2: 语句; default: 语句; endcase。从硬件角度看它就是一个多路选择器（MUX）：选择信号决定把哪一路输入接到输出。注意：

各分支按全等比较（===）匹配，且分支值之间不应重叠。
组合逻辑务必写 default，否则未覆盖的情况会被综合成锁存器。

always @(*) begin
    case (sel)
        2'b00:   y = a;
        2'b01:   y = b;
        2'b10:   y = c;
        default: y = 1'b0;     // 防止 latch
    endcase
end

相关变体：casez（把 ? / z 当作"不关心"通配）、casex（把 x 与 z 都当通配）。可综合设计里优先用 casez + ? 表示无关位。

6. for 循环

for 循环用于在同一时刻展开重复操作（如批量初始化数组、按位处理）。注意它是在综合/展开（elaboration）阶段被展开成多份并行硬件，因此循环次数必须是常量，不能依赖运行时的变量：

integer i;
always @(posedge clk) begin
    for (i = 0; i < 4; i = i + 1)
        byte1[i] <= 8'b0;   // 4 个字同时清零
end

因为循环会被展开，所以它常用于对存储器/向量做批量赋值、或实现移位寄存器等多位重复结构。循环变量一般用 integer 声明。

7. initial 块

initial 与 always 类似也是过程块，但它只在上电/仿真开始时执行一次（没有敏感表）：

reg [3:0] cnt;
initial begin
    cnt = 4'b0;          // 仿真初值
end

绝大多数非测试平台的 FPGA/ASIC RTL 中，不要依赖 initial 完成寄存器初始化，应使用复位逻辑。initial 主要用于**测试平台（testbench）**设置初值与激励；在可综合的 RTL 中多数综合器不支持（或忽略），变量初值应交给复位信号来完成。

八、阻塞赋值与非阻塞赋值

always 块内的赋值有两种符号，初学者最容易混淆：

赋值	符号	行为
阻塞赋值	`=`	立即生效，语句顺序执行（像软件一行行跑）
非阻塞赋值	`<=`	在块结束时统一更新，语句间并行（像硬件同时打拍）

硬件视角：电路是并行工作的——一个时钟上升沿到来，所有 D 触发器同时把各自的新值锁存进去。非阻塞 <= 正是这种"并行同时打拍"的建模：同一条 always 里的多条 <= 都基于进入本周期时的旧值计算，并在块结束时一起更新，互不干扰。而阻塞 = 是"算完一个再算下一个"的串行思路，适合描述组合逻辑里"前一句的结果立刻给后一句用"的依赖关系。记住这个"并行 vs 串行"的差别，就抓住了两种赋值的本质。

1. 黄金规则

时序逻辑（posedge clk 等）一律用非阻塞 <=：保证同一时钟沿上各语句基于"旧值"同时更新。
组合逻辑（always @(*)）一律用阻塞 =：保证前后语句按顺序、即时生效。

2. 反例：时序块里用错会出 bug

意图：把输入 d 打两拍（两级流水），正确的 q2 应等于上一周期的 q1。

// 非阻塞（正确）：两条语句都基于进入本周期时的旧值计算，q2 得到上一拍的 q1
always @(posedge clk) begin
    q1 <= d;
    q2 <= q1;
end

// 阻塞（错误）：q1 立即被更新，随后 q2 读到的是"刚更新的 q1"，
// 结果 q1、q2 同一拍都变成 d，退化为直通，没有延迟效果
always @(posedge clk) begin
    q1 = d;
    q2 = q1;
end

3. 反例：组合块里用错也会出错

// 阻塞（正确）：y 先算出，z 用到的是刚算出的 y
always @(*) begin
    y = a & b;
    z = y | c;
end

// 非阻塞（错误）：块结束时才统一更新，z 用到的是"上一轮"的 y，并非本次结果
always @(*) begin
    y <= a & b;
    z <= y | c;
end

牢记：“时序用 <=、组合用 =”，几乎能避免所有赋值类时序 bug。

九、parameter 与 localparam

两者都用于定义常量，可在模块内作为位宽、分频系数、地址等"可配置参数"使用。

parameter：可被上层在实例化时覆盖的常量，用来做模块参数化（如数据位宽、从机地址）。
localparam：仅模块内部使用的常量，不能被实例化覆盖（如状态机的状态编码、分频系数）。

module uart_tx #(parameter DATA_W = 8, parameter BAUD = 115200) (
    input clk, ...
);
    localparam IDLE    = 2'b00;            // 状态编码，不对外暴露
    localparam CNT_MAX = 100_000_000 / BAUD - 1;
    reg [DATA_W-1:0] shift_reg;
endmodule

现代模块推荐用 #(parameter ...) 的 ANSI 风格在端口前声明参数；实例化时可按名覆盖，如 uart_tx #(.DATA_W(16)) u_tx (...)。

十、模块实例化

Verilog 通过实例化把若干子模块"连起来"构成更大系统。可以类比成**“搭电路板 / 插元件”**：每个子模块是一颗现成的芯片，实例化就是把它焊到板子上，而 .端口(信号) 就是用导线把外部信号连到这个元件对应的引脚上。

实例化语法：模块名实例名 ( .端口名(连接信号), ... );，推荐用按名连接（.port(signal)），顺序可乱、可读性好：

wire [3:0] cnt_w;
wire       cout_w;

counter10 u_counter (          // u_counter 是把 counter10 这个"芯片"焊到板子上的实例
    .rstn (rstn),              // 用导线把外部 rstn 连到它的 rstn 脚
    .clk  (clk),               // 把 clk 连到它的 clk 脚
    .cnt  (cnt_w),             // 它的 cnt 输出脚，引到板上的 cnt_w 这根导线
    .cout (cout_w)
);

一个模块可以实例化多次（同一颗芯片焊多颗，只要取不同实例名）。也可用按位置连接（省略 .端口名，按模块定义顺序填实参），但易错、可读性差，不推荐。参数化模块实例化时还可按名覆盖参数，如 uart_tx #(.DATA_W(16)) u_tx (...)（见 §九）。