FPGA通过I2C控制AT24C64


前言

继上一篇FPGA学习_I2C总线协议内容,本文将基于FPGA通过I2C控制AT24C64(EEPROM芯片)芯片。
AT24C64:256pages 32bitbyte each pages,存储大小为32 * 256 * 8 = 64Kb = 8KB

一、代码设计框图

在这里插入图片描述
完整代码GitHub连接:https://github.com/shun6-6/IIC_EEPROM_Pro

二、IIC_drive模块设计

参考FPGA奇哥系列网课

2.1、模块接口:

module iic_drive#(
    parameter       P_ADDR_WIDTH     = 16   
)(
    input           i_clk               ,
    input           i_rst               ,
    /*----user interface----*/
    input   [6 :0]  i_device_addr       ,//用户输入设备地址
    input   [15:0]  i_operation_addr    ,//用户输入读写数据地址
    input   [7 :0]  i_operation_len     ,//用户输入读写数据长度
    input   [1 :0]  i_operation_type    ,//用户输入读写类型
    input           i_operation_valid   ,//用户输入操作有效信号
    output          o_operation_ready   ,//用户输出操作准备信号

    input   [7 :0]  i_write_date        ,//用户写入数据
    output          o_write_req         ,//用户写数据请求

    output  [7 :0]  o_read_date         ,//输出IIC读到的数据
    output          o_read_valid        ,//数据有效信号
    /*----IIC interface----*/
    output          o_iic_scl           ,//IIC时钟线
    inout           io_iic_sda           //IIC双向数据线
);

2.2、代码功能描述:

该模块将输入的指令以及相关地址和数据通过IIC协议传递给EEPROM芯片,其中状态机一共有11个状态:

localparam      P_ST_IDLE    = 0    ,//状态机-空闲
                P_ST_START   = 1    ,//状态机-起始位
                P_ST_UADDR   = 2    ,//状态机-设备地址
                P_ST_DADDR1  = 3    ,//状态机-数据地址高位
                P_ST_DADDR2  = 4    ,//状态机-数据地址低位
                P_ST_WRITE   = 5    ,//状态机-写数据
                P_ST_REATART = 6    ,//状态机-重启iic总线
                P_ST_READ    = 7    ,//状态机-读数据
                P_ST_WATI    = 8    ,//等待应答后再发生停止位
                P_ST_STOP    = 9    ,//状态机-停止
                P_ST_EMPTY   = 10   ;//空状态

状态转移过程:
P_ST_IDLE :一次操作指令握手成功后,进入START状态;
P_ST_START :该状态下控制SCL和SDA线启动IIC,随后进入写设备地址UADDR状态,
P_ST_UADDRw_st_turn 信号表示一个byte写入结束,即设备地址和读写指令写入(俩个一共为8bit)结束,随后会判断r_st_restart 信号,该信号表示当前操作为读数据操作,因为只有在读数据时,我们采用随机地址读操作,有一次虚写操作,虚写结束后需要重新启动总线,因此若此信号为高需要进入READ读阶段,否则进入写数据地址1(P_ST_DADDR1)阶段;
P_ST_DADDR1r_slave_ack 信号表示从机响应信号,此时响应的是写设备地址阶段的响应信号,如果响应为0,即未响应,则直接进入STOP停止阶段,以重新启动总线,这是由于刚刚写完数据,如果立马进行操作总线,总线处于忙状态,不会响应,若正常响应,则会在顺利写完8bit数据后进入P_ST_DADDR2 阶段。
P_ST_DADDR2 :在写完8bit的低8为地址后(即w_st_turn 拉高),判断当前是读操作还是写操作,写操作则顺利进入写数据WRITE阶段,读操作则需要进入总线重新启动阶段,即P_ST_REATART 。
P_ST_WRITE :当写如byte字节数与用户输入的写数据长度一致时,进入等待WAIT状态,否则继续写;
P_ST_REATART :重启总线,先进入停止STOP阶段,执行停止操作。
P_ST_READ :字节读,此模块只支持字节读操作,但用户要实现多字节读操作也是可以的,该过程会在EEPROM_drive当中被实现,因为EEPROM_drive模块会执行多次字节读。以此实现连续读操作。
P_ST_WATI :等待一拍,等从机ACK结束后进入停止位STOP阶段。
在这里插入图片描述
P_ST_STOP :控制SCL和SDA线结束IIC操作
这里需要注意的是接收完ACK后,不可以直接停止时钟产生,然后直接拉高SDA,需要多产生一个周期SCL,然后在SCL高电平期间拉高SDA以产生停止信号。
P_ST_EMPTY :emmmmm没啥用的一个状态,完全可以将停止位多计数一个时钟执行响应的判断,不过这样写清晰一点,主要是判断是不是需要重启总线(r_st_restart说明是由于读操作导致的重启操作,r_ack_lock说明是由于从机忙没有回应导致的重启总线),如果是则进入START状态,不是就回到IDLE状态。

always @(*)begin
    case (r_st_cur)
        P_ST_IDLE    : r_st_nxt = w_operation_active ? P_ST_START : P_ST_IDLE;
        P_ST_START   : r_st_nxt = P_ST_UADDR;

        P_ST_UADDR   : r_st_nxt = w_st_turn    ? 
                                  r_st_restart ? P_ST_READ : P_ST_DADDR1
                                : P_ST_UADDR;
 
        P_ST_DADDR1  : r_st_nxt = r_slave_ack    ? P_ST_STOP   :                           
                                  w_st_turn      ? P_ST_DADDR2 : P_ST_DADDR1;
 
        P_ST_DADDR2  : r_st_nxt = w_st_turn && ri_operation_type == P_W ? P_ST_WRITE   :   
                                  w_st_turn && ri_operation_type == P_R ? P_ST_REATART :
                                  P_ST_DADDR2;
 
        P_ST_WRITE   : r_st_nxt = w_st_turn && r_wr_cnt == ri_operation_len - 1          
                                             ? P_ST_WATI   : P_ST_WRITE;

        P_ST_REATART : r_st_nxt = P_ST_STOP;

        P_ST_READ   : r_st_nxt = w_st_turn ? P_ST_WATI   : P_ST_READ;//随机读,一次一个byte

        P_ST_WATI    : r_st_nxt = P_ST_STOP;
        P_ST_STOP    : r_st_nxt = r_st_cnt == 1 ? P_ST_EMPTY : P_ST_STOP;
        P_ST_EMPTY   : r_st_nxt = r_st_restart | r_ack_lock ? P_ST_START : P_ST_IDLE;
        default      : r_st_nxt = P_ST_IDLE;
    endcase
end

2.3、IIC协议实现过程:

过程和之前介绍的SPI总线协议类似,通过维护一个计数器,来使数据在SCL时钟下降沿改变,在SCL时钟上升沿被采样
在这里插入图片描述
主要难点是停止位的部分:

  • 写数据结束的停止位在第一张波形图哪里做了详细说明:
  • 读数据结束的停止位:如下图所示:在黄线部分已经读完了数据,后面需要加一个时钟周期传输NO ACK(图中红线部分)表示此次字节读结束,然后停止位的产生一定还需要多一个时钟周期,并且在此时钟周期最后拉高SDA,其实和写数据停止位一样,重复说明防止出错!!!

在这里插入图片描述

三、EEPROM_ctrl模块设计

3.1、模块接口:

module eeprom_ctrl(
    input           i_clk                   ,
    input           i_rst                   ,
    /*----user interface----*/
    input   [2 :0]  i_eeprom_addr           ,
    input   [15:0]  i_user_operation_addr   ,
    input   [1 :0]  i_user_operation_type   ,
    input   [7 :0]  i_user_operation_len    ,
    input           i_user_operation_valid  ,
    output          o_user_operation_ready  ,

    input   [7 :0]  i_user_write_date       ,
    input           i_user_write_valid      ,
    input           i_user_write_sop        ,
    input           i_user_write_eop        ,

    output  [7 :0]  o_user_read_date        ,
    output          o_user_read_valid       ,
    /*----iic drive interface----*/
    output  [6 :0]  o_device_addr           ,
    output  [15:0]  o_operation_addr        ,
    output  [7 :0]  o_operation_len         ,
    output  [1 :0]  o_operation_type        ,
    output          o_operation_valid       ,
    input           i_operation_ready       ,

    output  [7 :0]  o_write_date            ,
    input           i_write_req             ,

    input   [7 :0]  i_read_date             ,
    input           i_read_valid             
);

3.2、代码功能描述

该模块主要讲用户输入的读写指令转化为驱动读写指令,并且将用户输入的写数据存入FIFO,一个一个把8bit数据吐给IIC驱动,因为IIC_drive是串行传输的,同时也把从EEPROM读出的数据暂存入FIFO,读完后一次性连续的传递给用户模块。同时在该模块当中完成了一个上面刚刚提到的操作,连续读 :IIC_drive模块只支持字节读操作,但用户要实现多字节读操作也是可以的,因为EEPROM_drive模块会执行多次字节读。以此实现连续读操作。

localparam      P_ST_IDLE       = 0     ,
                P_ST_WRITE      = 1     ,
                P_ST_WAIT       = 2     ,
                P_ST_READ       = 3     ,
                P_ST_REREAD     = 4     ,
                P_ST_OUT_DATA   = 5     ;
always @(*)begin
    case (r_st_cur)
        P_ST_IDLE     : r_st_nxt = w_user_active && i_user_operation_type == P_W ? P_ST_WRITE :
                                   w_user_active && i_user_operation_type == P_R ? P_ST_WAIT  :
                                   P_ST_IDLE;

        P_ST_WRITE    : r_st_nxt = w_drive_end && ri_user_operation_type == P_W ? P_ST_IDLE : P_ST_WRITE;
        P_ST_WAIT     : r_st_nxt = P_ST_READ;
        P_ST_READ     : r_st_nxt = w_drive_end ? 
                                    r_read_cnt == ri_user_operation_len - 1 ? P_ST_OUT_DATA : P_ST_REREAD
                                    : P_ST_READ;   
        P_ST_REREAD   : r_st_nxt = P_ST_READ; 
        P_ST_OUT_DATA : r_st_nxt = w_fifo_read_empty ? P_ST_IDLE : P_ST_OUT_DATA;
        default       : r_st_nxt = P_ST_IDLE;
    endcase
end

该模块状态机以及相应跳转条件
该功能较为简单,
P_ST_IDLE :根据输入操作类型分别进入写WRITE状态或者是等待WAIT状态,这是因为用户输入的操作指令都会在本地先打一拍然后寄存下来,对于写数据而言,会先将数据存入FIFO然后再进行握手操作,然后再把本地寄存的用户指令再发给IIC驱动,这期间因为FIFO存数据所以指令赋值推后了好多拍,因此指令赋值不会出错,但是进行读数据操作时,用户指令i_user_operation_type先赋值给ri_user_operation_type以寄存,然后将ri_user_operation_type赋值给驱动ro_operation_type,在这个过程中就需要先等待一拍,否则就会出现上一次操作的的ri_user_operation_type给了ro_operation_type,错过了本次正确的i_user_operation_type。 这就是为什么进入读操作时先要进入一次WAIT状态以打一排。
之后的状态都很简单了!!!

四、EEPROM_drive模块

该模块就是例化了上述俩个模块

五、iic_top模块

该模块则是简单实现了一个不断翻转读写状态的的用户模块。

module iic_top(
    input           i_clk       ,
    output          o_iic_scl   ,//IIC时钟线
    inout           io_iic_sda   //IIC双向数据线
    );
localparam      P_WRITE_NUM = 8;
localparam      P_W         = 1     ,//写数据
                P_R         = 2     ;//读数据
reg  [2 :0]     ri_eeprom_addr          ; 
reg  [15:0]     ri_user_operation_addr  ; 
reg  [1 :0]     ri_user_operation_type  ; 
reg  [7 :0]     ri_user_operation_len   ; 
reg             ri_user_operation_valid ; 
wire            o_user_operation_ready  ;
reg  [7 :0]     ri_user_write_date      ; 
reg             ri_user_write_valid     ; 
reg             ri_user_write_sop       ; 
reg             ri_user_write_eop       ; 
wire [7 :0]     o_user_read_date        ;
wire            o_user_read_valid       ;
reg  [7 :0]     r_write_cnt             ;
reg             r_wr_st                 ;
wire            w_user_active           ;
wire            w_clk_5mhz              ;
wire            w_clk_5mhz_lock         ;
wire            w_clk_125khz            ;
wire            w_clk_125khz_rst        ;
assign w_user_active = ri_user_operation_valid & o_user_operation_ready;
SYSCLK_div SYSCLK_div_5mhz
   (
    .clk_out1               (w_clk_5mhz     ),   
    .locked                 (w_clk_5mhz_lock),       
    .clk_in1                (i_clk          )      
);
CLK_DIV_module#(
    .P_CLK_DIV_CNT          (40) //MAX = 65535
)CLK_DIV_module_U(
    .i_clk                  (w_clk_5mhz      ),
    .i_rst                  (~w_clk_5mhz_lock),
    .o_clk_div              (w_clk_125khz    )
    );
rst_gen_module#(
    .P_RST_CYCLE            (1)  
)rst_gen_module_u0(     
    .i_clk                  (w_clk_125khz    ),
    .o_rst                  (w_clk_125khz_rst)
    ); 
eeprom_drive eeprom_drive_u0(
    .i_clk                  (w_clk_125khz    ),
    .i_rst                  (w_clk_125khz_rst),
    .i_eeprom_addr          (ri_eeprom_addr         ),
    .i_user_operation_addr  (ri_user_operation_addr ),
    .i_user_operation_type  (ri_user_operation_type ),
    .i_user_operation_len   (ri_user_operation_len  ),
    .i_user_operation_valid (ri_user_operation_valid),
    .o_user_operation_ready (o_user_operation_ready ),
    .i_user_write_date      (ri_user_write_date     ),
    .i_user_write_valid     (ri_user_write_valid    ),
    .i_user_write_sop       (ri_user_write_sop      ),
    .i_user_write_eop       (ri_user_write_eop      ),
    .o_user_read_date       (o_user_read_date       ),
    .o_user_read_valid      (o_user_read_valid      ),
    .o_iic_scl              (o_iic_scl ),//IIC时钟线
    .io_iic_sda             (io_iic_sda) //IIC双向数据线
    );
always @(posedge w_clk_125khz or posedge w_clk_125khz_rst)begin
    if(w_clk_125khz_rst)begin
        ri_eeprom_addr          <= 'd0;
        ri_user_operation_addr  <= 'd0;
        ri_user_operation_type  <= 'd0;
        ri_user_operation_len   <= 'd0;
        ri_user_operation_valid <= 'd0;
    end
    else if(o_user_operation_ready && r_wr_st == 0)begin
        ri_eeprom_addr          <= 3'b011;
        ri_user_operation_addr  <= 'd0;
        ri_user_operation_type  <= P_W;
        ri_user_operation_len   <= P_WRITE_NUM;
        ri_user_operation_valid <= 'd1;
    end
    else if(o_user_operation_ready && r_wr_st == 1)begin
        ri_eeprom_addr          <= 3'b011;
        ri_user_operation_addr  <= 'd0;
        ri_user_operation_type  <= P_R;
        ri_user_operation_len   <= P_WRITE_NUM;
        ri_user_operation_valid <= 'd1;
    end
    else begin
        ri_eeprom_addr          <= 'd0;
        ri_user_operation_addr  <= 'd0;
        ri_user_operation_type  <= 'd0;
        ri_user_operation_len   <= 'd0;
        ri_user_operation_valid <= 'd0;
    end
end
always @(posedge w_clk_125khz or posedge w_clk_125khz_rst)begin
    if(w_clk_125khz_rst)
        ri_user_write_date <= 'd0;
    else if(ri_user_write_valid)
        ri_user_write_date <= ri_user_write_date + 1;
    else
        ri_user_write_date <= ri_user_write_date;
end 
  
always @(posedge w_clk_125khz or posedge w_clk_125khz_rst)begin
    if(w_clk_125khz_rst)
        ri_user_write_sop <= 'd0;
    else if(w_user_active && ri_user_operation_type == P_W)
        ri_user_write_sop <= 'd1;
    else
        ri_user_write_sop <= 'd0;
end 
always @(posedge w_clk_125khz or posedge w_clk_125khz_rst)begin
    if(w_clk_125khz_rst)
        ri_user_write_valid <= 'd0;
    else if(ri_user_write_eop)
        ri_user_write_valid <= 'd0;
    else if(w_user_active && ri_user_operation_type == P_W)
        ri_user_write_valid <= 'd1;
    else
        ri_user_write_valid <= ri_user_write_valid;
end 
always @(posedge w_clk_125khz or posedge w_clk_125khz_rst)begin
    if(w_clk_125khz_rst)
        ri_user_write_eop <= 'd0;
    // else if((w_user_active || ri_user_write_valid) && r_write_cnt == P_WRITE_NUM - 2)
    //     ri_user_write_eop <= 'd1;
    else if(w_user_active && P_WRITE_NUM == 1)
        ri_user_write_eop <= 'd1;//write 1 byte
    else if(ri_user_write_valid && r_write_cnt == P_WRITE_NUM - 2)
        ri_user_write_eop <= 'd1;//write over 1 byte
    else
        ri_user_write_eop <= 'd0;
end 
always @(posedge w_clk_125khz or posedge w_clk_125khz_rst)begin
    if(w_clk_125khz_rst)
        r_write_cnt <= 'd0;
    else if(r_write_cnt == P_WRITE_NUM - 1)
        r_write_cnt <= 'd0;
    else if(ri_user_write_valid)
        r_write_cnt <= r_write_cnt + 1'd1;
    else
        r_write_cnt <= r_write_cnt;
end 
always @(posedge w_clk_125khz or posedge w_clk_125khz_rst)begin
    if(w_clk_125khz_rst)
        r_wr_st <= 'd0;
    else if(w_user_active)
        r_wr_st <= r_wr_st + 1'd1;
    else
        r_wr_st <= r_wr_st;
end 
endmodule
  • 41
    点赞
  • 17
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
### 回答1: STM32是一款具有丰富外设的32位微控制器,而AT24C64是一款I2C总线上的EEPROM芯片。那么,STM32 AT24C64 I2C是指使用STM32微控制器与AT24C64 EEPROM芯片进行I2C通信的应用。 I2C是一种串行通信协议,它可以在两个设备之间传输数据,并且只需两条线进行传输,即时钟线SCL和数据线SDA。对于STM32与AT24C64之间的I2C通信,首先需要在STM32上配置I2C外设,并初始化相应的寄存器和引脚。然后,可以利用STM32的I2C外设发送读/写命令以及读/写数据到AT24C64芯片。 在AT24C64芯片上,我们可以将大量的数据存储在64K位的存储器中。使用I2C通信协议时,STM32可以向AT24C64写入数据,也可以从AT24C64读取存储的数据。通过发送合适的I2C命令和地址,STM32可以访问AT24C64存储器中的特定位置,并且可以按需读取或写入所需的数据。 总结来说,STM32 AT24C64 I2C是指使用STM32微控制器通过I2C总线与AT24C64 EEPROM芯片进行通信的应用。通过适当的配置和命令发送,STM32可以读取和写入AT24C64芯片中存储的数据。这种应用可以广泛应用于各种需要存储数据的嵌入式系统中,例如数据日志记录、配置保存等等。 ### 回答2: STM32是意法半导体公司开发的一系列32位微控制器。AT24C64是一款由Microchip公司生产的基于I2C总线的64K位串行EEPROM芯片。I2C是一种串行总线通信协议,用于连接微控制器与外设。 STM32微控制器提供了内置的I2C控制器,能够与外部设备进行I2C通信。AT24C64芯片具有8个地址引脚,可以通过配置这些引脚来设置不同的设备地址。在STM32中,可以通过配置I2C控制器的相关寄存器来设置通信速率、使能I2C总线以及发送和接收数据。 要在STM32上使用AT24C64芯片,需要首先初始化I2C控制器,并将其配置为主机模式。然后,可以向AT24C64发送读/写命令,并通过I2C总线发送和接收数据。在读取或写入数据之前,需要设置AT24C64的设备地址,并指定要读取或写入的内存地址。 在读取数据时,STM32可以通过I2C控制器发送寻址序列来指定要读取的内存地址,然后从AT24C64读取数据。在写入数据时,STM32可以通过I2C控制器发送寻址序列和数据来指定要写入的内存地址和数据。 当完成读取或写入操作时,STM32可以通过I2C控制器发出停止序列来结束通信。 总之,通过STM32的内置I2C控制器,我们可以轻松地与AT24C64芯片进行通信,实现数据的读取和写入操作。 ### 回答3: STM32是意法半导体公司生产的一系列32位微控制器,而AT24C64是一种24系列的EEPROM(电可擦除可编程只读存储器),支持I2C总线通信。 STM32是基于ARM Cortex-M内核的微控制器系列,具有低功耗、高性能和丰富的外设功能。它适用于各种应用,包括工业控制、汽车电子、家用电器等。AT24C64是一种容量为64K位的串行EEPROM,通过I2C总线与主控器进行通信。 I2C(Inter-Integrated Circuit)是一种双线的串行通信协议,适合连接多种外围设备。它具有简单、高效、灵活的特点,支持多主机和多从机模式。对于STM32和AT24C64之间的通信,可以通过STM32的I2C接口来实现。 STM32通过配置I2C控制器的寄存器,设置通信速率和数据格式,并发送读或写命令给AT24C64。AT24C64则接收到命令后,执行读取或写入操作,并将数据返回给STM32。在操作过程中,需要注意I2C总线的起始信号、地址、数据和停止信号等协议规定。 通过使用STM32和AT24C64的组合,可以实现非易失性存储器的扩展。STM32可以读取和写入AT24C64中的数据,以满足系统的存储需求。同时,STM32还可以通过I2C总线与其他外围设备进行通信,实现更丰富的功能。 总结起来,STM32和AT24C64结合使用,可以实现高效稳定的I2C通信,扩展非易失性存储器容量,并满足各种应用场景的需求。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

顺子学不会FPGA

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值