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

总线 on Lumenth