I2C接口控制器设计与验证（思路+代码+详细注释）

原创 已于 2025-03-20 23:04:58 修改 · 2.3k 阅读 · 30 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#fpga #fpga开发

于 2025-03-20 22:58:11 首次发布

目录

一、I2C协议解析

1.I2C协议基本规定

2.I2C写流程

3.I2C读流程

二、 I2C 控制器实现思路解析

三、I2C传输逻辑模块： i2c_bit_shift 

1.接口设计

2.SCL时钟设计

3.各状态转换（状态机设计）

4.波形分析

四、I2C顶层模块：I2C_control

1.接口设计

2.模块例化

3.6个命令（cmd）和7个状态

4.读和写任务

5.状态机设计

6.仿真

本文是根据B站小梅哥FPGA设计编写。

一、I2C协议解析

I2C由两条总线构成：SDA（串行数据总线）和SCL（串行时钟总线），属于半双工，任意时刻只能有一个主机。（总线上一主多从）

1.I2C协议基本规定

（1）在时钟（SCL）为高电平的时候，数据总线（SDA）必须保持稳定，所以数据总线（SDA）
在时钟（SCL）为低电平的时候才能改变。

（2）在时钟（SCL）为高电平的时候，数据总线（SDA）由高到低的跳变为总线起始信号，
在时钟（SCL）为高电平的时候，数据总线（SDA）由低到高的跳变为总线停止信号。

（3）应答，当 IIC 主机（不一定是发送端还是接收端）将 8 位数据或命令传出后，会将数据
总线（SDA）释放，即设置为输入，然后等待从机应答（低电平 0 表示应答，1 表示非
应答），此时的时钟仍然是主机提供的。

2.I2C写流程

提醒：器件地址：有的器件地址在出厂时地址就设置好了，用户不可以更改（例如 OV7670 器件地址为固定的 0x42），有的确定了几位，剩下几位由硬件确定（比如常见的 I2C 接口的EEPROM 存储器，留有 3 个控地址的引脚，由用户自己在硬件设计时确定）。

存储器地址：相当于器件里的存储单元，例如，EEPROM 存储器，内部就是顺序编址的一系列存储单元；型号为 OV7670 的 CMOS 摄像头（OV7670 的该接口叫 SCCB 接口，其实质也是一种特殊的 I2C 协议，可以直接兼容 I2C协议），其内部就是一系列编址的可供读写的寄存器。

（1）主机将SDA设置为输出：发起起始信号；

（2）主机传输器件地址字节，其中最低位为 0，表明为写操作；
（3）主机设置 SDA 为三态门输入，读取从机应答信号；

（4）读取应答信号成功，主机设置 SDA 为输出，传输 1 字节地址数据；
（5）主机设置 SDA 为三态门输入，读取从机应答信号；
（6）读取应答信号成功，主机设置 SDA 为输出，传输待写入的数据；
（7）设置 SDA 为三态门输入，读取从机应答信号；
（8）读取应答信号成功，主机产生 STOP 位，终止传输。

2字节存储器地址流程差不多不过多赘述

3.I2C读流程

（1）主机设置 SDA 为输出：主机发起起始信号；
（2）主机传输器件地址字节，其中最低位为 0，表明为写操作；
（3）主机设置 SDA 为三态门输入，读取从机应答信号；
（4）读取应答信号成功，主机设置 SDA 为输出，传输 1 字节地址数据；
（5）主机设置 SDA 为三态门输入，读取从机应答信号；
（6）读取应答信号成功，主机发起起始信号；
（7）主机传输器件地址字节，其中最低位为 1，表明为读操作；
（8）设置 SDA 为三态门输入，读取从机应答信号；
（9）读取应答信号成功，主机设置 SDA 为三态门输入，读取 SDA 总线上的一个字节的
数据；
（10）产生无应答信号（高电平）（无需设置为输出高电平，因为总线会被自动拉高）；
（11）主机产生 STOP 位，终止传输。

2字节存储器地址流程差不多不过多赘述

二、 I2C 控制器实现思路解析

无论是读or写，每个步骤可以归结为以上五个步骤：

写2字节操作：①（写器件地址，最后一位为0）->②（写存储器地址）->②（写第一字节数据）->③（写第二字节数据并停止）

读一字节操作：①（写器件地址，最后一位为0）->②（写存储器地址）->①写器件地址，最后一位为1）->⑤（读数据并停止）

其他情况皆适用，这里只例举两个例子。

这一思想到目前你可能无法理解怎么用，当学到本章第四小节I2C顶层控制模块便可理解了。

三、I2C传输逻辑模块： i2c_bit_shift 

1.接口设计

module i2c_bit_shift(
    clk,
    rst_n,
    
    cmd,
    go,
    rx_data,
    tx_data,
    trans_done,
    ack_o,
    i2c_sclk,
    i2c_sdat
    );
    
    input clk;//模块工作时钟，50M 时钟
    input rst_n;//复位，低电平有效
    
    input [5:0] cmd;//控制总线实现各种传输操作的各种命令的组合
    input go;//整个模块的启动使能信号
    output reg [7:0] rx_data;//总线收到的 8 位数据，读操作时读到的数据由此端口输出
    input [7:0] tx_data;//总线要发送的 8 位数据，需要传输的数据经此端口传入该模块
    output reg trans_done;//发送或接收 8 位数据完成标志信号,高标志位
    output reg ack_o;//从机是否应答标志
    output reg i2c_sclk;//i2c 时钟总线
    inout i2c_sdat;//i2c 数据总线

2.SCL时钟设计

我们根据 I2C 的协议标准，这里采用的是快速模式（400kb/s）来作为总线的工作时钟，所以我们将 SYS_CLOCK 设置成 50_000_000，SCL_CLOCK 是用来配置时钟（SCL）总线的频率，通过这两个参数就可以计算出参数 SCL_CNT_M 要计数到多少就能产生期望的总线工作时钟（SCL）频率

每个状态的处理都可以分为四步（如果这里无法理解，接下来状态机代码设计里便可理解了）

//系统时钟采用 50MHz
parameter SYS_CLOCK =50_000_000;
//SCL 总线时钟采用 400kHz
parameter SCL_CLOCK =400_000;
//产生时钟 SCL 计数器最大值
localparam SCL_CNT_M = SYS_CLOCK/SCL_CLOCK/4-1;
reg i2c_sdat_o;//发送数据电平，1：z（因为总线有上拉电阻，高阻态就是拉高）；0：0。
reg i2c_sdat_oe;//高电平SDA为输出模式，低电平为输入模式

//得到每个时刻的脉冲信号sclk_plus，作为序列使能信号
reg [19:0]div_cnt;
reg en_div_cnt;//只在数据传输过程中计数，只在状态机中赋值

    always@(posedge clk or negedge rst_n)
    if(!rst_n)
        div_cnt<=20'b0;
    else if(en_div_cnt)begin
        if(div_cnt<SCL_CNT_M)
            div_cnt<=div_cnt+1'b1;
        else
            div_cnt<=0;
    end
    else
        div_cnt<=20'b0;
        
    wire sclk_plus =(div_cnt == SCL_CNT_M);//当到达时刻时，置高电平
    
    assign i2c_sdat = !i2c_sdat_o && i2c_sdat_oe ? 1'b0:1'bz;//先计算！i2c_sdat,再&&，最后？：//i2c_sdat_oe高电平为输出模式，i2c_sdat_o==1时i2c_sdat=z（由外部上拉电阻把数据线拉高，i2c_sdat_o==0时i2c_sdat=0）

3.各状态转换（状态机设计）

有部分连线在真实过程中不会出现，画出来是为了保证状态机完整性。

从上面的状态转移图可以看出，这里总共分成了 7 个状态，刚开始复位后的默认状态（IDLE）、产生起始信号状态（GEN_STA）、写数据状态（WR_DATA）、读数据状态（RD_DATA）、检测从机是否应答状态（CHECK_ACK）、给从机应答状态（GEN_ACK）、产生停止位状态（GEN_STO）

//状态机7个状态定义：独热码
    localparam
    IDLE = 7'b0000001, //空闲状态
    GEN_STA = 7'b0000010, //产生起始信号
    WR_DATA = 7'b0000100, //写数据状态
    RD_DATA = 7'b0001000, //读数据状态
    CHECK_ACK = 7'b0010000, //检测应答状态
    GEN_ACK = 7'b0100000, //产生应答状态
    GEN_STO = 7'b1000000; //产生停止信号

 Cmd 的 6 个命令（写请求<WR>、起始位请求<STA>、读请求<RD>、停止位请求<STO>、应答位请求<ACK>、无应答请求<NACK>）

//cmd命令定义
    localparam
    WR =6'b000001,//写请求
    STA =6'b000010,//起始位请求
    RD =6'b000100,//读请求
    STO =6'b001000,//停止位请求
    ACK =6'b010000,//应答位请求
    NACK =6'b100000;//无应答请求

开始状态转移吧：

    reg [4:0] cnt;//用来记录sclk_plus次数（1-4）
    reg [7:0] state;
    
    always@(posedge clk or negedge rst_n)
    if(!rst_n)begin
        rx_data<=0;
        i2c_sdat_oe<=1'b0;
        en_div_cnt<=1'b0;
        i2c_sdat_o<=1'b1;
        trans_done<=1'b0;
        ack_o<=1'b0;
        state<=IDLE;
        cnt<=0;
    end    
    else begin
        case(state)
            IDLE://写器件地址操作的 Cmd 命令里面的条件会首先跳转到 GEN_STA这个状态，没有go则留在IDLE状态，分频计数器不开启
                begin
                    trans_done <= 1'b0;
                    i2c_sdat_oe <= 1'd1;
                    if (go) begin
                        en_div_cnt <= 1'b1;//开始分频序列机计数
                        if (cmd & STA)
                            state <= GEN_STA;
                        else if (cmd & WR)
                            state <= WR_DATA;
                        else if (cmd & RD)
                             state <= RD_DATA;
                        else
                             state <= IDLE;
                        end
                    else begin
                        en_div_cnt <= 1'b0;
                        state <= IDLE;
                    end
                end
                
           GEN_STA://产生开始信号：SCL高电平时，SDA输出模式下由高拉低
                begin
                    if (sclk_plus) begin//传送1bit信号分为四个时刻（SCL_CLOCK一个周期分为4部分）
                        if (cnt == 3)
                            cnt <= 0;
                        else
                            cnt <= cnt + 1'b1;
                        case (cnt)
                            0:begin i2c_sdat_o <= 1; i2c_sdat_oe <= 1'd1;end//拉高数据总线，sda输入模式
                            1:begin i2c_sclk <= 1;end//拉高时钟线
                            2:begin i2c_sdat_o <= 0; i2c_sclk <= 1;end//拉低sda,scl保持高电平
                            3:begin i2c_sclk <= 0;end//拉低scl
                            default:begin i2c_sdat_o <= 1; i2c_sclk <= 1;end
                        endcase
                        if (cnt == 3) begin//判断开始后是读or写
                            if (cmd & WR)
                                state <= WR_DATA;
                            else if (cmd & RD)
                                state <= RD_DATA;
                        end
                    end
                end  
                
            WR_DATA:
                begin
                    if (sclk_plus) begin
                        if (cnt == 31)
                            cnt <= 0;
                        else
                            cnt <= cnt + 1'b1;
                        case (cnt)
                            0,4,8,12,16,20,24,28://把 7 位器件地址和最低位（方向位）的 0 直接赋值给 Tx_DATA，从最高位开始传给i2c_sdat_o
                            begin
                                i2c_sdat_o <= tx_data[7-cnt[4:2]];//cnt[4:2]即第几个第一时刻
                                i2c_sdat_oe <= 1'd1;
                            end
                            1,5,9,13,17,21,25,29:begin i2c_sclk<=1;end //将总线时钟（SCL，代码里面 i2c_sclk）拉高
                            2,6,10,14,18,22,26,30:begin i2c_sclk<=1;end //将总线时钟继续保持为高电平
                            3,7,11,15,19,23,27,31:begin i2c_sclk <=0;end //将时钟总线 i2c_sclk 拉为低电平  
                            default:begin i2c_sdat_o <= 1; i2c_sclk <= 1;end
                        endcase
                        if (cnt == 31) begin
                            state <= CHECK_ACK;
                        end
                end
            end
            
            CHECK_ACK:
                begin
                    if(sclk_plus)begin
                        if (cnt == 3)
                            cnt <= 0;
                        else
                            cnt <= cnt + 1'b1;
                        case(cnt)
                            0:begin i2c_sdat_oe <= 1'd0; i2c_sclk <= 0;end//sda数据总线为输入模式
                            1:begin i2c_sclk <= 1;end//将总线时钟 i2c_sclk 拉高
                            2:begin ack_o <= i2c_sdat; i2c_sclk <= 1;end//总线时钟继续保持为高电平，将数据总线数据输入到ack_o，此时判断对方产生是否产生应答只需要判断 ack_o 的值是 0（应答）还是 1（无应答）
                            3:begin i2c_sclk <= 0;end//将时钟总线 i2c_sclk 拉为低电平
                            default:begin i2c_sdat_o <= 1; i2c_sclk <= 1;end
                        endcase
                        if(cnt == 3)begin
                            if(cmd & STO)
                                state <= GEN_STO;
                            else begin
                                state <= IDLE;//继续写/读
                                trans_done <= 1'b1;
                            end
                        end
                    end
                end
                
            GEN_STO://在时钟（SCL，代码里面是 i2c_sclk）为高电平的时候，数据总线（SDA）由低电平到高电平的跳变就一个停止信号
                begin
                    if(sclk_plus)begin
                        if(cnt == 3)
                            cnt <= 0;
                        else
                            cnt <= cnt + 1'b1;
                        case(cnt)
                            0:begin i2c_sdat_o <= 0; i2c_sdat_oe <= 1'd1;end//将 i2c_sdat_o设置为 0，i2c_sdat_oe 使能
                            1:begin i2c_sclk <= 1;end//将总线时钟 i2c_sclk 拉高
                            2:begin i2c_sdat_o <= 1; i2c_sclk <= 1;end//将 i2c_sdat_o 设置为1，让外部上拉电阻将数据总线 i2c_sdat 拉成高电平
                            3:begin i2c_sclk <= 1;end//将时钟总线 i2c_sclk 拉为高电平
                            default:begin i2c_sdat_o <= 1; i2c_sclk <= 1;end
                        endcase
                        if(cnt == 3)begin
                            trans_done <= 1'b1;
                            state <= IDLE;
                        end
                    end
                end
                
         RD_DATA:
            begin
                if (sclk_plus) begin
                    if (cnt == 31)
                        cnt <= 0;
                    else
                        cnt <= cnt + 1'b1;
                    case (cnt)
                        0,4,8,12,16,20,24,28:
                            begin
                            i2c_sdat_oe <= 1'd0;
                            i2c_sclk <= 0;
                            end //将总线设置为输入，即i2c_sdat_oe 设置为 0，i2c_sclk 拉为低电平
                        1,5,9,13,17,21,25,29:begin i2c_sclk<=1;end //sclkposedge
                        2,6,10,14,18,22,26,30:
                            begin
                            i2c_sclk <= 1;
                            rx_data <= {rx_data[6:0],i2c_sdat};//读取数据总线 i2c_sdat 的值到 Rx_DATA,每次将读取到的数据放到 Rx_DATA 的最低位，读取一次，左移一次
                            end //sclk keep high
                        3,7,11,15,19,23,27,31:begin i2c_sclk<=0;end //sclknegedge
                        default:begin i2c_sdat_o <= 1; i2c_sclk <= 1;end
                    endcase
                    if (cnt == 31) begin
                        state <= GEN_ACK;
                    end
                end
           end
           
      GEN_ACK:
        begin
            if(sclk_plus)begin
                if(cnt == 3)
                    cnt <= 0;
                else
                    cnt <= cnt + 1'b1;
                case(cnt)
                    0: begin
                        i2c_sdat_oe <= 1'd1;
                        i2c_sclk <= 0;
                        if(cmd & ACK)
                            i2c_sdat_o <= 1'b0;//拉低（应答）
                        else if(cmd & NACK)
                            i2c_sdat_o <= 1'b1;//拉高（不应答）
                    end
                    1:begin i2c_sclk <= 1;end
                    2:begin i2c_sclk <= 1;end
                    3:begin i2c_sclk <= 0;end
                    default:begin i2c_sdat_o <= 1; i2c_sclk <= 1;end
                endcase
                if(cnt == 3)begin
                    if(cmd & STO)
                        state <= GEN_STO;
                    else begin
                        state <= IDLE;
                        trans_done <= 1'b1;
                    end
                end
            end
        end
        
        default:state<=IDLE; 
    endcase    
end   
        
endmodule

以上代码连起来便是完整设计代码，可直接复制粘贴使用

接下来进行波形仿真：本实验采用的是镁光官网提供的 EEPROM 仿真模型，仿真模型 24LC04B.v 文件，在本篇文章顶部可自行下载

`timescale 1ns / 1ps

module i2c_bit_shift_tb;

reg Clk;
reg Rst_n;
reg [5:0] Cmd;
reg Go;
wire [7:0] Rx_DATA;
reg  [7:0] Tx_DATA;
wire Trans_Done;
wire ack_o;
wire i2c_sclk;
wire i2c_sdat;

pullup PUP(i2c_sdat); //模拟外部上拉电阻

localparam
WR = 6'b000001, //写请求
STA = 6'b000010, //起始位请求
RD = 6'b000100, //读请求
STO = 6'b001000, //停止位请求
ACK = 6'b010000, //应答位请求
NACK = 6'b100000; //无应答请求

i2c_bit_shift DUT(
    .clk(Clk),
    .rst_n(Rst_n),
    .cmd(Cmd),
    .go(Go),
    .rx_data(Rx_DATA),
    .tx_data(Tx_DATA),
    .trans_done(Trans_Done),
    .ack_o(ack_o),
    .i2c_sclk(i2c_sclk),
    .i2c_sdat(i2c_sdat)
);

M24LC04B M24LC04B(
    .A0(0),
    .A1(0),
    .A2(0),
    .WP(0),
    .SDA(i2c_sdat),
    .SCL(i2c_sclk),
    .RESET(~Rst_n)
);

    always #10 Clk = ~Clk;
    initial begin
        Clk = 1;
        Rst_n = 0;
        Cmd = 6'b000000;
        Go = 0;
        Tx_DATA = 8'd0;
        #2001;
        Rst_n = 1;
        #2000;
        
        //写数据操作，往 EEPROM 器件的 B1 地址写数据
        //第一次：起始位+EEPROM 器件地址（7 位）+写方向（1 位）
        Cmd = STA | WR;//按位或
        Go = 1;
        Tx_DATA = 8'hA0 | 8'd0;//最后一位为0：写操作
        @ (posedge Trans_Done);//说明字段传输完成，进入下一状态
        Go = 0;
        #200;
        
        //第二次：写 EEPROM 的 8 位寄存器地址
        Cmd = WR;
        Go = 1;
        Tx_DATA = 8'hB1;//写地址 B1
        @ (posedge Trans_Done);
         Go = 0;
        #200;
        
        //第三次：写 8 位数据 + 停止位
        Cmd = WR | STO;
        Go = 1;
        Tx_DATA = 8'hda;//写数据 DA
        @ (posedge Trans_Done);
        Go = 0;
        #200;
        
        #5000000; //仿真模型的两次操作时间间隔
        
        //读数据操作，从 EEPROM 器件的 B1 地址读数据
        //第一次：起始位+EEPROM 器件地址（7 位）+写方向（1 位）
        Cmd = STA | WR;
        Go = 1;
        Tx_DATA = 8'hA0 | 8'd0;//写方向 
        @ (posedge Trans_Done);
        Go = 0;
        #200;
        
        //第二次：写 EEPROM 的 8 位寄存器地址
        Cmd = WR;
        Go = 1;
        Tx_DATA = 8'hB1;//写地址 B1
        @ (posedge Trans_Done);
        Go = 0;
        #200;
        
        //第三次：起始位+EEPROM 器件地址（7 位）+读方向（1 位）
        Cmd = STA | WR;
        Go = 1;
        Tx_DATA = 8'hA0 | 8'd1;//读方向
        @ (posedge Trans_Done);
        Go = 0;
        #200;
        
        //第四次：读 8 位数据 + 停止位
        Cmd = RD | STO;
        Go = 1;
        @ (posedge Trans_Done);
        Go = 0;
        #200;
        
        #2000;
        $stop;
    end
endmodule

4.波形分析

可以看到头和尾有两块很密集的波形，前面的是写操作后面的读操作，我们先看写（放大）

这张图上state显示出来的部分只有00000100，但不是只有这一个状态，其他状态放大波形可看到，这里不过多赘述了。

我们再来看看读操作部分吧。

四、I2C顶层模块：I2C_control

对于一个单字节读操作，可以分为四步：

（1）起始位+写数据（7 位器件 ID + 1 位读写控制位（这里是 0，表示写）），等待从
机应答。
（2）写数据（8 位 EEPROM 的寄存器地址），等待从机应答。
（3）起始位+写数据（7 位器件 ID + 1 位读写控制位（这里是 1，表示读）），等待从机应答。
（4）读数据（从 EEPROM 中读出 8 位数据）+ 应答位（根据需要给出应答0或者无应答1）+ 停止位。

总的来说就是写了三次 1 字节的数据，读了一次 1 字节的数据。为了让代码更简洁这里用两个 task 一个是用来写字节（write_byte），另一个是读字节（read_byte）。

写字节的 task 里面就将要写的字节数据准备好（赋值给 i2c_bit_shift 模块的 Tx_DATA 端口），同时涉及到的传给 i2c_bit_shift 模块的 Cmd 命令也准备好，同时触发 Go 信号，这样就可以通过
i2c_bit_shift 模块将要写的数据发送到总线上了。

同理，读字节的 task 里面将涉及到的传给i2c_bit_shift 模块的 Cmd 命令也准备好，同时触发 Go 信号，这样就可以通过 i2c_bit_shift 模块将总线上的数据读取出来了。

1.接口设计

module i2c_control(
    Clk,
    Rst_n,
    
    wrreg_req,
    rdreg_req,
    addr,
    addr_mode,
    wrdata,
    rddata,
    device_id,
    RW_Done,
    
    ack,
    
    i2c_sclk,
    i2c_sdat
    );
    input Clk;
    input Rst_n;
    
    input wrreg_req;//写请求
    input rdreg_req;//读请求
    input [15:0] addr;//寄存器地址16位
    input addr_mode;//单字节地址和双字节寄存器地址
    input [7:0] wrdata;//要写入从机数据，是由Tx_DATA准备好最后再赋值给他
    output reg [7:0] rddata;//存储读到的数据，也是读到Rx_DATA后再传给它
    input [7:0] device_id;//器件地址
    output reg RW_Done;//读写完成信号
    
    output reg ack;//从机应答信号
    
    output i2c_sclk;//时钟总线
    inout i2c_sdat;//数据总线

    wire [15:0] reg_addr;
    
    assign reg_addr = addr_mode?addr:{addr[7:0],addr[15:8]};//双字节地址先传高八位再传低八位，所以若为单字节地址把地址有效部分【7：0】放到高位

2.模块例化

    wire [7:0] Rx_DATA;
    reg [7:0] Tx_DATA;
    wire Trans_Done;
    wire ack_o;
    reg Go;
    reg [5:0] Cmd;

//模块例化
    i2c_bit_shift i2c_bit_shift(
    .clk(Clk),
    .rst_n(Rst_n),
    .cmd(Cmd),
    .go(Go),
    .rx_data(Rx_DATA),
    .tx_data(Tx_DATA),
    .trans_done(Trans_Done),
    .ack_o(ack_o),
    .i2c_sclk(i2c_sclk),
    .i2c_sdat(i2c_sdat)
);

3.6个命令（cmd）和7个状态

//六个命令
localparam
    WR   =6'b000001,//写请求
    STA  =6'b000010,//起始位请求
    RD   =6'b000100,//读请求
    STO  =6'b001000,//停止位请求
    ACK  =6'b010000,//应答位请求
    NACK =6'b100000;//无应答请求

//七个状态
localparam
    IDLE         = 7'b0000001, //空闲状态
    WR_REG       = 7'b0000010, //写寄存器状态
    WAIT_WR_DONE = 7'b0000100, //等待写寄存器完成状态
    WR_REG_DONE  = 7'b0001000, //写寄存器完成状态
    RD_REG       = 7'b0010000, //读寄存器状态
    WAIT_RD_DONE = 7'b0100000, //等待读寄存器完成状态
    RD_REG_DONE  = 7'b1000000; //读寄存器完成状态

4.读和写任务

目的是为了简化后续代码

   task read_byte;
        input [5:0]Ctrl_Cmd;
        begin
            Cmd <= Ctrl_Cmd;
            Go <= 1'b1;
        end
    endtask
    
    task write_byte;
        input [5:0]Ctrl_Cmd;
        input [7:0]Wr_Byte_Data;
        begin
            Cmd <= Ctrl_Cmd;
            Tx_DATA <= Wr_Byte_Data;
            Go <= 1'b1;
        end
    endtask

5.状态机设计

    reg [6:0] state;
    reg [7:0] cnt;
    
    always@(posedge Clk or negedge Rst_n)
    if(!Rst_n)begin
        Cmd<=6'b0;
        Tx_DATA<=8'b0;
        Go<=1'b0;
        rddata<=0;
        state<=IDLE;
        ack<=0;
    end
    else begin
        case(state)
            IDLE:
                begin
                    cnt<=0;
                    ack<=0;
                    RW_Done<=1'b0;
                    if(wrreg_req)
                        state<=WR_REG;
                    else if(rdreg_req)
                        state<=RD_REG;
                    else
                        state<=IDLE;
                end
                
             WR_REG:
                begin
                    state <= WAIT_WR_DONE;//每次进入写请求时都会先进入等待写完成阶段（这一阶段的目的是判断存储器地址字节数并接收从机ACK信号）
                    case(cnt)
                        0:write_byte(WR | STA, device_id);
                        1:write_byte(WR, reg_addr[15:8]);
                        2:write_byte(WR, reg_addr[7:0]);//若为单字节地址应该跳过这个步骤，在状态WAIT_WR_DONE中执行
                        3:write_byte(WR | STO, wrdata);
                        default:;
                    endcase
                end
                
             WAIT_WR_DONE:
                begin
                    Go <= 1'b0;
                    if(Trans_Done)begin
                        ack <= ack | ack_o;
                        case(cnt)
                            0: begin cnt <= 1; state <= WR_REG;end
                            1: begin
                                state <= WR_REG;
                                if(addr_mode)//addr_mode==1即为双字节地址，从2开始继续传输低8位地址，反之为单字节跳过步骤2，从3开始
                                    cnt <= 2;
                                else
                                    cnt <= 3;
                            end
                            2: begin
                                cnt <= 3;
                                state <= WR_REG;
                            end
                            3:state <= WR_REG_DONE;
                            default:state <= IDLE;
                        endcase
                    end
                end 
                
            WR_REG_DONE:
                begin
                    RW_Done <= 1'b1;//完成写操作标志
                    state <= IDLE;
                end
                
           RD_REG:
                begin
                    state <= WAIT_RD_DONE;
                    case(cnt)
                        0:write_byte(WR | STA, device_id);
                        1:write_byte(WR, reg_addr[15:8]);
                        2:write_byte(WR, reg_addr[7:0]);
                        3:write_byte(WR | STA, device_id | 8'd1);//最低位是1，读操作命令（一定不要混淆主机发送读命令和主机的写操作，这一步是主机写操作并告诉从机它需要读数据了）
                        4:read_byte(RD | NACK | STO);
                        default:;
                    endcase
                end
                
           WAIT_RD_DONE:
                begin
                    Go <= 1'b0;
                    if(Trans_Done)begin
                        if(cnt <= 3)
                            ack <= ack | ack_o;
                        case(cnt)
                            0: begin cnt <= 1; state <= RD_REG;end
                            1: begin
                                state <= RD_REG;
                                if(addr_mode)
                                    cnt <= 2;
                                else
                                    cnt <= 3;
                            end
                            2: begin
                                cnt <= 3;
                                state <= RD_REG;
                            end
                            3:begin
                                cnt <= 4;
                                state <= RD_REG;
                            end
                                4:state <= RD_REG_DONE;
                            default:state <= IDLE;
                        endcase
                    end
                end
                
             RD_REG_DONE:
                begin
                    RW_Done <= 1'b1;
                    rddata <= Rx_DATA;
                    state <= IDLE;
                end
                
             default:state<=IDLE;
        endcase
    end
endmodule

以上为所有完整代码。

6.仿真

接下来是波形仿真：依然需要用到仿真模型 24LC04B.v 文件

`timescale 1ns / 1ps

module i2c_control_tb;
    reg Clk;
    reg Rst_n;
    reg wrreg_req;
    reg rdreg_req;
    reg [15:0]addr;
    reg addr_mode;
    reg  [7:0]wrdata;
    wire [7:0]rddata;
    reg  [7:0]device_id;
    wire RW_Done;
    wire ack;
    wire i2c_sclk;
    wire i2c_sdat;

pullup PUP(i2c_sdat);//外部上拉

i2c_control DUT(
    .Clk(Clk),
    .Rst_n(Rst_n),
    .wrreg_req(wrreg_req),
    .rdreg_req(rdreg_req),
    .addr(addr),
    .addr_mode(addr_mode),
    .wrdata(wrdata),
    .rddata(rddata),
    .device_id(device_id),
    .RW_Done(RW_Done),
    .ack(ack),
    .i2c_sclk(i2c_sclk),
    .i2c_sdat(i2c_sdat)
);

M24LC04B M24LC04B(
    .A0(0),
    .A1(0),
    .A2(0),
    .WP(0),
    .SDA(i2c_sdat),
    .SCL(i2c_sclk),
    .RESET(~Rst_n)
);

    initial Clk = 1;
    always #10 Clk = ~Clk;
    
    initial begin
        Rst_n = 0;
        rdreg_req = 0;
        wrreg_req = 0;
        #2001;
        Rst_n = 1;
        #2000;
        
        write_one_byte(8'hA0,8'h0A,8'hd1);
        write_one_byte(8'hA0,8'h0B,8'hd2);
        write_one_byte(8'hA0,8'h0C,8'hd3);
        write_one_byte(8'hA0,8'h0D,8'hd4);
        
        read_one_byte(8'hA0,8'h0A);
        read_one_byte(8'hA0,8'h0B);
        read_one_byte(8'hA0,8'h0C);
        read_one_byte(8'hA0,8'h0D);
        $stop;
    end
    
    
    task write_one_byte;
        input [7:0]id;
        input [7:0]mem_address;
        input [7:0]data;
        begin
            addr = {8'd0,mem_address};
            device_id = id;
            addr_mode = 0;
            wrdata = data;
            wrreg_req = 1;
            #20;
            wrreg_req = 0;
            @(posedge RW_Done);
            #5000000;//一定要等够5ms
        end
    endtask
    
    
    task read_one_byte;
        input [7:0]id;
        input [7:0]mem_address;
        begin
            addr = {8'd0,mem_address};
            device_id = id;
            addr_mode = 0;
            rdreg_req = 1;
            #20;
            rdreg_req = 0;
            @(posedge RW_Done);
            #5000000;//一定要等够5ms
        end
    endtask
    
endmodule

插播一条：之前做仿真第二次写操作一直收不到从机ACK，找了好久原因才发现24LC04B 需要 5ms 的写周期时间，之前写的仿真代码周期时间设短了，主机在从机未完成内部写周期时发起新操作，从机可能不响应。

★C++语言期末课程设计★——图书借阅系统（完整项目+源代码+详细注释）
小浝仔
06-15 4884
大家好！我是小浝仔，这个程序是用C++语言程序编写的，实现功能如下：1、管理员模式：录入图书信息、查看图书信息、修改图书信息、修改管理密码、退出系统；2、客户模式：①查看图书信息：按书名查找、按书号查找、查看所有未借阅图书、查看所有已借阅图书、查看所有图书、返回主菜单； ②借阅图书：按书名借阅、按书号借阅、查看所有图书、返回主菜单、退出系统；3、退出系统...
I2C接口控制设计与实现
小王在努力...的博客
08-11 1398
根据完整的 I2C 传输时序，提取出通用的底层传输单元。
IIC控制器的verilog && C语言实现
qq_43534451的博客
04-17 1992
verilog实现方法 学习了《FPGA的自学笔记设计与验证》串口读写EEPROM这一章节后，会画时序图和状态转移图，并根据状态转移图和时序图写verilog代码。 I2C 协议整体时序说明如下： 总线空闲状态：SDA 为高电平，SCL 为高电平； I2C 协议起始位：SCL 为高电平时，SDA 出现下降沿，产生一个起始位； I2C 协议结束位：SCL 为高电平时，SDA 出现上升沿，产生一个结束...
IIC通信过程详解以及底层代码实现
鸵鸟小姐的博客
03-31 9242
IIC通信原理与代码详解
I2C总线接口电路设计
Find的博客
07-30 4993
https://wenku.baidu.com/view/de241cd2ce2f0066f5332235.html
Verilog：I2C控制器
2303_76814451的博客
03-02 2030
Verilog实现I2C通信协议，通过对AT24C02进行单字节读写操作来进行功能验证
I2C接口电路设计
最新发布
weixin_74442878的博客
03-27 773
前两个问题导致的原因是设备中有多个I2C接口，没有使用的接口要上拉，如果没上啦，可能受到电路的影响，或者单片机认为没使用的接口也要用，就一起初始化了而产生问题。开漏输出能输出的有效电平只有逻辑电平0，逻辑电平1只能表现为悬浮状态，为了能进行逻辑通信，所以在需要输出逻辑电平1的情况下，加上上拉电阻，实现输出逻辑电平1.对于电容值他受板子面积，总线上的设备数量，走线，芯片输入电容相加，再加上走线带来的杂散电容，所以不好改变，也改变不了多少，所以只能改变下电阻值。一般是2.2k，3k，4.7k。
PIC__I2C.zip_PIC I2C_PIC i2c_i2c pic
09-20
标题中的"PIC__I2C.zip"表明这是一个与微控制器（ PIC）和I2C通信协议相关的压缩包文件。I2C（Inter-Integrated Circuit）是一种由飞利浦（现NXP半导体）开发的串行通信接口，常用于电子设备之间的短距离通信，如...
JAVA公共资源模块的设计与开发(源代码+论文).rar
04-03
通常，我们可以按照MVC（模型-视图-控制器）或三层架构（表示层、业务逻辑层、数据访问层）来组织代码。源代码应遵循单一职责原则，每个类只做一件事，接口定义行为，抽象类提供通用实现。 4. **毕业设计与论文**：...
I2C总线控制器的介绍
01-15
I2C总线控制器的介绍，很常用的一种工业控制应用上的总线技术
完整的I2C控制器Verilog程序
04-10
完整的IC2控制器设计文件，包括完整的testbench
i2c控制器代码
09-05
本文档是关于i2c总线控制器的verilog程序
使用Verilog设计I2C控制器
qq_28824733的博客
04-30 3701
使用Verilog设计I2C控制器
基于FPGA的I2C接口控制器（包含单字节和多字节读写）
详解FPGA及硬件电路开发
02-14 4340
本文档详细阐述了基于FPGA实现的I2C接口控制器设计，支持可变长度的寄存器地址和数据读写。通过分析EEPROM的单字节和页读写时序，提出了一个通用模块，使用状态机和计数器实现I2C通信。设计考虑了I2C的时序要求，如应答机制和数据线状态变化。文档提供了详细的端口信号列表、状态机设计和参考代码，以及对模块的仿真和资源消耗分析。
I2C总线串行接口应用设计
weixin_34067980的博客
04-22 421
I2C总线串行接口应用设计 I2C是一种较为常用的串行接口标准，具有协议完善、支持芯片较多和占用I/O线少等优点。I2C总线是PHILIPS公司为有效实现电子器件之间 的控制而开发的一种简单的双向两线总线。现在，I2C总线已经成为一个国际标准，在超过100种不同的IC集成电路上实现，得到超过50家公司的许可，应 用涉及家电、通信、控制等众多领域，特别是在ARM嵌入式系统...
【硬件工程师课程】9.常用接口电路设计--I2C电路设计
wr_9794的博客
11-29 355
硬件学习与巩固，I2C的设计
I2C电路设计
FourLeafCloverLLLS的博客
04-28 8804
I2C协议已经用了很多了，但是呢，在硬件设计方面，基本也是只会抄抄电路，并没有理解其中的原理和细节。这一章我们具体要说说需要怎么设计I2C电路。 1. 什么是I2C？ I2C Bus(Inter-Integrated Circuit Bus) 最早是由Philips半导体（现被NXP收购）开发的两线时串行总线，常用于微控制器与外设之间的连接。这里要注意IIC是为了与低速设备通信而发明的，所以IIC的传输速率比不上SPI 1.1 硬件连接 I2C仅需两根线就可以支持一主多从或者多主连接，I2C使用两个双向.
Verilog实现I2C总线主控制器源码下载
I2C（Inter-Integrated Circuit）是一种多主机串行通信总线，广泛应用于微控制器和各种外围设备之间的通信。了解I2C协议的基本原理，包括其物理层（电平标准）、数据传输规则、设备地址、读写操作、时钟同步以及总线...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值