ZYNQ_project:IIC_EEPROM

核桃_warrior

已于 2023-12-05 16:39:08 修改

阅读量1k

点赞数 22

文章标签：网络

于 2023-11-28 20:46:19 首次发布

本文链接：https://blog.csdn.net/Meng_long2022/article/details/134651988

版权

EEPROM简介：

EEPROM(Electrically Erasable Progammable Read Only Memory， E2PROM)是指带电可擦可编程只读存储器，是一种常用的非易失性存储器（掉电数据不丢失）， E2PROM 有多种类型的产品，我们领航者 ZYNQ开发板上使用的是 ATMEL 公司生产的 AT24C 系列的 AT24C64 这一型号。 AT24C64 具有高可靠性，可对所存数据保存 100 年，并可多次擦写，擦写次数达一百万次。
它的存储容量：256页每页32个字节。256 x 32 = 8192 (byte字节)

8192 x 8 = 65536(bit比特)

65536 / 1024 = 64 （Kbit）。。。。所以是AT24C系列，64Kbit存储容量。

AT24C64 采用两线串行接口的双向数据传输协议——I2C 协议实现读写操作，所以我们有必要了
解一下 I2C 协议。

IIC协议简介：

简单，双向，二线制总线标准。多用于主机与从机在数据量不大且短距离的（主从）通信。

主机启动总线，并产生时钟用于传送数据，此时任何接收数据的器件均被认为是从机。
IIC总线由数据线SDA和时钟线SCL构成通信线路，各种iic通信器件并联在总线上，通过器件地址识别器件（与器件通信前先要找到这个器件，发地址，等响应，找到对应要通信的从设备）。

IIC总线物理结构拓扑原理结构图：

图中的 I2C_SCL 是串行时钟线， I2C_SDA 是串行数据线，由于 I2C 器件一般采用开漏结构与总线相连，
所以 I2C_SCL 和 I2C_SDA 均需接上拉电阻，也正因此，当总线空闲时，这两条线路都处于高电平状态，当
连到总线上的任一器件输出低电平，都将使总线拉低，即各器件的 SDA 及 SCL 都是“线与”关系。
I2C 总线支持多主和主从两种工作方式，通常工作在主从工作方式，我们的开发板就采用主从工作方式。
在主从工作方式中，系统中只有一个主机，其它器件都是具有 I2C 总线的外围从机。在主从工作方式中，主
机启动数据的发送（发出启动信号）并产生时钟信号，数据发送完成后，发出停止信号。

IIC的协议层

仔细观察图 33.1.2 可知 IIC 协议的整体时序由四个部分构成，上图中分别使用①、②、③、④进行区
分。
图中①：总线空闲状态，在 I2C 器件开始通信（传输数据）之前，串行时钟线 SCL 和串行数据线 SDA
线由于上拉的原因处于高电平状态，此时 I2C 总线处于空闲状态。
图中②：起始信号，如果主机（此处指 FPGA）想开始传输数据，只需在 SCL 为高电平时将 SDA 线拉
低，产生一个起始信号。
图中③：数据传输状态，主机可以向从机写数据，也可以读取从机输出的数据，数据的传输由双向数据
线（SDA）完成。
图中④：停止状态，当数据传输完成，主机只需产生一个停止信号，告诉从机数据传输结束，停止信号
的产生是在 SCL 为高电平时， SDA 从低电平跳变到高电平，从机检测到停止信号后，停止接收数据，并且
I2C 总线跳转回总线空闲状态。

数据传输的具体时序：

scl为高时，sda产生下降沿，产生起始信号。（告诉从机，要开始数据通信了）。

在scl为低时，sda可以改变数据；scl为高时，sda数据保持；

8bit数据一组，也就需要8个时钟周期；

第九个时钟周期：主机释放总线，从机控制总线产生应答位0.若为高，则说明无应答，这组数据是无效的传输。

scl为高时，sda产生上升沿，表示停止信号。（主机结束与从机的通信）

器件地址：

当多个 I2C 器件挂接在总线上时，怎样才能与我们想要传输数据的器件进行通信。这就涉及到了器件地址（也称从机地址， SLAVE ADDRESS）。
有两种器件地址：7bit全都是固定的，与部分bit固定，部分bit可编程。

AT24C64，起始位+1010+A2A1A0.最低三位可编程。

WR位为0，表示主机要进行写操作，1表示读操作。

IIC 读写时序

写时序：（字节写和页写）

字节写：

主机发送完字地址，从机正确应答后就把内部的存储单元地址指针指向该单元。如果读写控制位 R/W位为“0”即写命令，从机就处于接收数据的状态，此时，主机就开始写数据了，写数据可分为单次写（对于 E2PROM 而言，称为字节写）和连续写（对于 E2PROM 而言，称为页写）。下面我们先分别介绍 E2PROM的单次写与连续写。

从左上角开始按行往右看。

（1）主机先产生开始标志信号：scl == 1 sda产生下降沿。

（2）然后发送器件地址（MSB~LSB高位在前）最后一位是读写控制标志位，读写控制信号位，0写；1读。

（3）然后从机产生应答位。

（4）然后发送字地址（存储器的存储空间的地址，相当于指针，相当于门牌号（学过C语言的都应该不陌生））由于AT24C64，存储空间为64Kbit，8bit只能表示256byte（2的8次方 = 256）（256x8/1024 == 2Kbit）.

64Kbit ： 64x1024/8= 8192

2的13次方，才能表示完8192个数据。

iic以字节传数据，所以AT24C64要用两字节的字地址。

从机指针指向对应的字地址，准备接收数据。

每传递一字节数据后从机会在下一个时钟周期产生应答位。（主机释放总线，从机拉低总线）

（5）然后从机产生应答位。

（6）然后主机开始发送数据：8bit数据位，

（7）然后从机产生应答位。

（8）然后主机产生停止信号，结束位。

页写：

接下来我们开始介绍 E2PROM 的连续写（页写）时序：

（1）主机产生起始信号。

（2）主机发送器件地址+指令bit。

（3）从机应答。

（4）主机发送第一个字节，从机应答。第二个字节，从机应答。

（5）传递一字节的数据(8bit)，高位在前。从机产生应答位。

（6）主机发送停止信号。

两者的区别在于发送完一字节数据后，是发送结束信号还是继续发送下一字节数据，如果发送的是结束信号，就称为单次写，如果继续发送下一字节数据，就称为连续写。

要注意的是，所有 I2C 设备均支持单字节数据写入操作，但只有部分 I2C 设备支持页写操作，对于
AT24C64 的页写，是不能发送超过一页的单元容量的数据的，而 AT24C64 的一页的单元容量为 32Byte，当
写完一页的最后一个单元时，地址指针指向该页的开头，如果再写入数据，就会覆盖该页的起始数据。

读时序：

I2C 写时序介绍完毕后，接下来我们开始 I2C 读时序部分的介绍。根据一次读操作读取数据量的多少，
读操作可分为随机读操作和顺序读操作。

读数据有三种方式：当前地址读，随机读，连续读。

当前地址读方式：

当前地址读是指在一次读或写操作后发起读操作。由于 I2C 器件在读写操作后，其内部的地址指针自动加一，因此当前地址读可以读取下一个字地址的数据。也就是说上次读或写操作的单元地址为 02 时，当前地址读的内容就是地址 03 处的单元数据。

（1）主机发送起始信号。

（2）主机发送器件地址+读命令（1）.

（3）从机发送响应信号，从机应答。

（4）从机发送数据8bit，高位在前。

（5）主机非应答，高电平无应答信号.

（6）主机发送停止信号。

随机读取方式：

并不随机，指定地址并读取一字节数据。

（1）主机发送起始信号。

（2）主机发送器件地址+写指令（0）.原因是，接下来是要写入字地址（存储器的地址），所以是写指令。从机产生应答位。

（3）主机发送第一字节地址，从机产生应答位。

（4）主机发送第二字节地址，从机产生应答位。

（5）主机发送起始信号。又一次发送起始信号。

（6）主机发送期间地址+读指令（1）.从机产生应答位。

（7）从机发送8bit数据。主机产生无应答位。

（8）主机发送停止信号。

需要注意理解的是随机地址读在发送完器件地址和字地址后，竟然又发送起始信号和器件地址，而且第一次发送器件地址时后面的读写控制位为“ 0”，也就是写命令，第二次发送器件地址时后面的读写控制位为“1”，也就是读。为什么会有这样奇怪的操作呢？这是因为我们需要使从机内的存储单元地址指针指向我们想要读取的存储单元地址处，所以首先发送了一次Dummy Write 也就是虚写操作，只所以称为虚写，是因为我们并不是真的要写数据，而是通过这种虚写操作使地址指针指向虚写操作中字地址的位置，等从机应答后，就可以以当前地址读的方式读数据了。

当前地址读下的连续读：

当前地址读和随机读都是一次读取一个字节，连续读是将当前地址读或随机读的主机非应答改成应答，表示继续读取数据。

（1）主机发送起始信号。

（2）主机发送器件地址+读命令（1），从机产生应答信号。

（3）从机发送8bit数据，主机产生应答信号（0）.

（4）从机发送下一字节数据，主机产生应答信号（0）.

.................

(5)从机发送下一字节数据，主机产生无应答信号（1）.

（6）主机发送停止信号。

随机地址连续读：

有当前地址连续读，当然也有随机地址连续读，随机地址连续读是在图 33.1.10 随机地址读时序的基础上，主机非应答改成应答，表示继续读取数据。

（1）主机发送起始信号。

（2）主机发送器件地址+写指令（0）.原因是”虚写“。从机产生应答位。

（3）主机发送第一字节地址，从机产生应答位。

（4）主机发送第二字节地址，从机产生应答位。

（5）主机发送起始信号。又一次发送起始信号。

（6）主机发送期间地址+读指令（1）.从机产生应答位。

（7）从机发送8bit数据。主机产生应答位（0）。

（8）从机发送下一字节的8bit数据。主机产生应答位（0）。

................

（10）从机发送8bit数据。主机产生无应答位。

（11）主机发送停止信号。

总结：

所以器件地址为1010_000

实验任务：

本节的实验任务是先向 E2PROM（AT24C64）的存储器地址 0 至 255 分别写入数据 0~255；写完之后再读取存储器地址 0~255 中的数据，把读到的数据通过串口发送给上位机，验证数据正确否。

模块框图：

时序图：

就是使用前面给的时序图。

代码：

写代码，组合逻辑不要过长，输出端口尽量用时序逻辑。

只放接口模块代码，拱大家参考。

/*
    iic协议接口模块
    输入端：时钟，复位，写时序控制标志信号，读时序控制标志信号
    输出端：二线，读写时序完成标志信号，接收数据与标志信号
    在该模块例化伪双端口ram，用于存储接收到的数据，读出后传给tx模块
    // 先实现写入一页的数据，然后再拓展。每页32个字节
*/
`include "para.v"
module iic_interface (
    input		wire				sys_clk		    ,
    input		wire				sys_rst_n	    ,
    input       wire                iic_wr_flag     ,
    input       wire                iic_rd_flag     ,

    inout       wire                sda             ,

    output		reg                 scl             ,
    output      wire                iic_wr_done     ,
    output      wire                iic_rd_done     ,
    output      reg     [7:0]       po_data         ,
    output      reg                 po_flag         
);
    parameter   DEVICE_W = 8'b1010_0000 ;
    parameter   DEVICE_R = 8'b1010_0001 ;
    // localparam 
    localparam  IDLE                    =   4'b0000     ,
                START                   =   4'b0001     ,
                ADDR_DEVICE             =   4'b0011     ,
                SLAVE_ACK               =   4'b0010     ,
                ADDR_FIRST              =   4'b0110     ,
                ADDR_SECOND             =   4'b0111     ,
                START2                  =   4'b0101     ,
                ADDR_DEVICE_R           =   4'b0100     ,
                ACK_SLAVE2_R            =   4'b1100     ,
                READ_DATA               =   4'b1101     ,
                ACK_MASTER              =   4'b1111     ,
                NOACK_MASTER            =   4'b1110     ,
                END_R                   =   4'b1010     ,
                WRITE_DATA              =   4'b1011     ,
                ACK_SLAVE2_W            =   4'b1001     ,
                END_W                   =   4'b1000     ;
                
    // reg signal
    reg     [ 3:0]      state_c             ;
    reg     [ 3:0]      state_n             ;
    reg     [31:0]      cnt_scl             ;
    reg     [ 2:0]      cnt_bit             ;
    reg     [31:0]      cnt_data            ;
    reg                 master_ack_ok       ; // 用来检测主机是否正常产生响应。
    reg                 addr_first_req      ;
    reg                 addr_second_req     ;
    reg                 start2_req          ;
    reg                 write_data_req      ;
    reg                 slave_ack_ok        ; // 从机在规定时刻有响应
    reg                 ack_master_req      ;
    reg                 noack_master_req    ;
    reg                 end_w_req           ;
    reg                 read_work           ; // 根据输入端口的flag信号，控制工作状态。
    reg                 write_work          ; // 不能有同时拉高的时候。
    reg                 sda_out             ;
    reg     [ 7:0]      addr_h = 8'h00      ; // at24c64的高低字节地址。
    reg     [ 7:0]      addr_l = 8'h00      ; 
    reg     [31:0]      generate_data       ;
    reg                 write_work_r        ;
    reg                 read_work_r         ;
    reg                 po_flag_r           ;
    reg     [ 7:0]      po_data_r           ;
    reg                 iic_en  ;
    // wire signal
    // wire                iic_en              ;
    wire                end_cnt_bit         ;
    wire                add_cnt_bit         ;
    wire                end_cnt_scl         ;
    wire                add_cnt_scl         ;
    wire                add_cnt_data        ;
    wire                end_cnt_data        ;
    wire                keep_cnt_data       ;
    // 状态转移条件
    wire        IDLEtoSTART                 ;
    wire        STARTtoADDR_DEVICE          ;
    wire        ADDR_DEVICEtoSLAVE_ACK      ;
    wire        SLAVE_ACKtoIDLE             ;
    wire        SLAVE_ACKtoADDR_FIRST       ;
    wire        SLAVE_ACKtoADDR_SECOND      ;
    wire        SLAVE_ACKtoSTART2           ;
    wire        SLAVE_ACKtoWRITE_DATA       ;
    wire        ADDR_FIRSTtoSLAVE_ACK       ;
    wire        ADDR_SECONDtoSLAVE_ACK      ;
    wire        START2toADDR_DEVICE_R       ;
    wire        ADDR_DEVICE_RtoACK_SLAVE2_R ;
    wire        ACK_SLAVE2_RtoREAD_DATA     ;
    wire        READ_DATA_ACK_MASTER        ;
    wire        READ_DATAtoNOACK_MASTER     ;
    wire        ACK_MASTERtoREAD_DATA       ;
    wire        NOACK_MASTERtoEND_R         ;
    wire        END_RtoIDLE                 ;
    wire        WRITE_DATAtoACK_SLAVE2_W    ;
    wire        ACK_SLAVE2_WtoEND_W         ;
    wire        ACK_SLAVE2_WtoWRITE_DATA    ;
    wire        END_WtoIDLE                 ;
/******************************************************************************************
********************************************main code**************************************
*******************************************************************************************/
    // reg     [ 3:0]      state_c           ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            state_c <= IDLE ;
        else
            state_c <= state_n ;
    end
    // reg     [ 3:0]      state_n           ;
    always @(*) begin
        case(state_c)
        IDLE         :  if(IDLEtoSTART)
                            state_n = START ;
                        else 
                            state_n = IDLE ;
        START        :  if(STARTtoADDR_DEVICE)
                            state_n = ADDR_DEVICE ;
                        else 
                            state_n = START ;
        ADDR_DEVICE  :  if(ADDR_DEVICEtoSLAVE_ACK)
                            state_n = SLAVE_ACK ;
                        else 
                            state_n = ADDR_DEVICE ;
        SLAVE_ACK    :  if(SLAVE_ACKtoADDR_FIRST)
                            state_n = ADDR_FIRST ;
                        else if(SLAVE_ACKtoADDR_SECOND)
                            state_n = ADDR_SECOND ;
                        else if(SLAVE_ACKtoSTART2) // 进入读数据相关状态
                            state_n = START2 ;
                        else if(SLAVE_ACKtoWRITE_DATA) // 进入写数据相关状态
                            state_n = WRITE_DATA ;
                        else if(SLAVE_ACKtoIDLE) // 新增
                            state_n = IDLE ; // 在该进行跳转的时候，从机没有任何响应，跳回IDLE状态。
                        else 
                            state_n = SLAVE_ACK ;
        ADDR_FIRST   :  if(ADDR_FIRSTtoSLAVE_ACK)
                            state_n = SLAVE_ACK ;
                        else 
                            state_n = ADDR_FIRST ;
        ADDR_SECOND  :  if(ADDR_SECONDtoSLAVE_ACK)
                            state_n = SLAVE_ACK ;
                        else 
                            state_n = ADDR_SECOND ;
        START2       :  if(START2toADDR_DEVICE_R)
                            state_n = ADDR_DEVICE_R ;
                        else 
                            state_n = START2 ;
        ADDR_DEVICE_R:  if(ADDR_DEVICE_RtoACK_SLAVE2_R)
                            state_n = ACK_SLAVE2_R ;
                        else 
                            state_n = ADDR_DEVICE_R ;
        ACK_SLAVE2_R :  if(ACK_SLAVE2_RtoREAD_DATA)
                            state_n = READ_DATA ;
                        else 
                            state_n = ACK_SLAVE2_R ;
        READ_DATA    :  if(READ_DATA_ACK_MASTER)
                            state_n = ACK_MASTER ;
                        else if(READ_DATAtoNOACK_MASTER)
                            state_n = NOACK_MASTER ;
                        else 
                            state_n = READ_DATA ;
        ACK_MASTER   :  if(ACK_MASTERtoREAD_DATA)
                            state_n = READ_DATA ;
                        else
                            state_n = ACK_MASTER ; // 在该进行跳转前，主机无任何响应，跳转回idle
        NOACK_MASTER :  if(NOACK_MASTERtoEND_R)
                            state_n = END_R ;
                        else 
                            state_n = NOACK_MASTER ; // 主机无响应，跳转回idle
        END_R        :  if(END_RtoIDLE)
                            state_n = IDLE ;
                        else 
                            state_n = END_R ; // 正常来讲就是一个scl周期就会跳回idle
        WRITE_DATA   :  if(WRITE_DATAtoACK_SLAVE2_W)
                            state_n = ACK_SLAVE2_W ;
                        else 
                            state_n = WRITE_DATA ;
        ACK_SLAVE2_W :  if(ACK_SLAVE2_WtoWRITE_DATA) // 写数据状态优先跳转。
                            state_n = WRITE_DATA ;
                        else if(ACK_SLAVE2_WtoEND_W)
                            state_n = END_W ;
                        else 
                            state_n = ACK_SLAVE2_W ; // 从机无应答，跳回idle
        END_W        :  if(END_WtoIDLE)
                            state_n = IDLE ;
                        else 
                            state_n = END_W ;
        default      :  state_n = IDLE ;
        endcase
    end

    assign  IDLEtoSTART                     = (state_c == IDLE          ) && (iic_wr_flag || iic_rd_flag) ;
    assign  STARTtoADDR_DEVICE              = (state_c == START         ) && (end_cnt_scl && scl) ;
    assign  ADDR_DEVICEtoSLAVE_ACK          = (state_c == ADDR_DEVICE   ) && (end_cnt_scl && scl) && (end_cnt_bit) ;
    assign  SLAVE_ACKtoIDLE                 = (state_c == SLAVE_ACK     ) && (end_cnt_scl && scl) && (!slave_ack_ok) ;
    assign  SLAVE_ACKtoADDR_FIRST           = (state_c == SLAVE_ACK     ) && (end_cnt_scl && scl) && (addr_first_req  ) && (slave_ack_ok) ;
    assign  SLAVE_ACKtoADDR_SECOND          = (state_c == SLAVE_ACK     ) && (end_cnt_scl && scl) && (addr_second_req ) && (slave_ack_ok) ;
    assign  SLAVE_ACKtoSTART2               = (state_c == SLAVE_ACK     ) && (end_cnt_scl && scl) && (start2_req      ) && (slave_ack_ok) ;
    assign  SLAVE_ACKtoWRITE_DATA           = (state_c == SLAVE_ACK     ) && (end_cnt_scl && scl) && (write_data_req  ) && (slave_ack_ok) ;
    assign  ADDR_FIRSTtoSLAVE_ACK           = (state_c == ADDR_FIRST    ) && (end_cnt_scl && scl) && (end_cnt_bit) ;
    assign  ADDR_SECONDtoSLAVE_ACK          = (state_c == ADDR_SECOND   ) && (end_cnt_scl && scl) && (end_cnt_bit) ;
    assign  START2toADDR_DEVICE_R           = (state_c == START2        ) && (end_cnt_scl && scl) ;
    assign  ADDR_DEVICE_RtoACK_SLAVE2_R     = (state_c == ADDR_DEVICE_R ) && (end_cnt_scl && scl) && (end_cnt_bit) ;
    assign  ACK_SLAVE2_RtoREAD_DATA         = (state_c == ACK_SLAVE2_R  ) && (end_cnt_scl && scl) && (slave_ack_ok) ;
    assign  READ_DATA_ACK_MASTER            = (state_c == READ_DATA     ) && (end_cnt_scl && scl) && (end_cnt_bit) && (ack_master_req) ;
    assign  READ_DATAtoNOACK_MASTER         = (state_c == READ_DATA     ) && (end_cnt_scl && scl) && (end_cnt_bit) && (noack_master_req) ;
    assign  ACK_MASTERtoREAD_DATA           = (state_c == ACK_MASTER    ) && (end_cnt_scl && scl) && (master_ack_ok) ;
    assign  NOACK_MASTERtoEND_R             = (state_c == NOACK_MASTER  ) && (end_cnt_scl && scl) && (master_ack_ok) ;
    assign  END_RtoIDLE                     = (state_c == END_R         ) && (end_cnt_scl && scl) ;
    assign  WRITE_DATAtoACK_SLAVE2_W        = (state_c == WRITE_DATA    ) && (end_cnt_scl && scl) && (end_cnt_bit) ;
    assign  ACK_SLAVE2_WtoEND_W             = (state_c == ACK_SLAVE2_W  ) && (end_cnt_scl && scl) && (end_w_req       ) && (slave_ack_ok) ;
    assign  ACK_SLAVE2_WtoWRITE_DATA        = (state_c == ACK_SLAVE2_W  ) && (end_cnt_scl && scl) && (write_data_req  ) && (slave_ack_ok) ;
    assign  END_WtoIDLE                     = (state_c == END_W         ) && (end_cnt_scl && scl) ;

    // reg                 po_flag_r           ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            po_flag_r <= 1'b0 ;
        else if((state_c == READ_DATA) && (end_cnt_scl && end_cnt_bit && scl))
            po_flag_r <= 1'b1 ;
        else 
            po_flag_r <= 1'b0 ;
    end
    // reg     [ 7:0]      po_data_r           ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            po_data_r <= 8'd0 ;
        else if(state_c == READ_DATA && (scl) && (cnt_scl == (`MAX_CNT_SCL >> 1)))
            po_data_r[7 - cnt_bit] <= sda ;
            // po_data_r <= {po_data[6:0],sda} ;
        else if(state_c == IDLE)
            po_data_r <= 8'd0 ;
        else 
            po_data_r <= po_data_r ;
    end
    // reg                 write_work_r        ;
    // reg                 read_work_r         ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            write_work_r <= 1'b0 ;
            read_work_r  <= 1'b0 ;
        end
        else begin
            write_work_r <= write_work ;
            read_work_r  <= read_work  ;
        end  
    end
    // reg                 generate_data       ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            generate_data <= 32'd0 ;
        else if(add_cnt_data && generate_data == `MAX_CNT_DATA - 1)
            generate_data <= 32'd0 ;
        else if(add_cnt_data)
            generate_data <= generate_data + 1'b1 ;
        else    
            generate_data <= generate_data ;
    end
    // reg     [31:0]      cnt_scl             ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            cnt_scl <= 32'd0 ;
        else if(add_cnt_scl) begin
            if(end_cnt_scl)
                cnt_scl <= 32'd0 ;
            else
                cnt_scl <= cnt_scl + 1'b1 ;
        end
        else 
            cnt_scl <= 32'd0 ;     
    end
    // wire                add_cnt_scl         ;
    assign  add_cnt_scl = (state_c != IDLE) ;
    // wire                end_cnt_scl         ; 
    assign  end_cnt_scl = (add_cnt_scl) && (cnt_scl == (`MAX_CNT_SCL - 1)) ;

    // reg     [ 2:0]      cnt_bit             ; 一共就计数0 ~ 7，其实可以自己归零。111 -> 000
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            cnt_bit <= 3'd0 ;
        else if(add_cnt_bit) begin
            if(end_cnt_bit && (end_cnt_scl && scl))
                cnt_bit <= 3'd0 ;
            else if(end_cnt_scl && scl)
                cnt_bit <= cnt_bit + 1'b1 ;
            else 
                cnt_bit <= cnt_bit ;
        end
        else 
            cnt_bit <= 3'd0 ;
    end
    // wire                add_cnt_bit         ;
    assign  add_cnt_bit = ((state_c == (ADDR_DEVICE)) || (state_c == (ADDR_FIRST)) || (state_c == (ADDR_SECOND)) || (state_c == (READ_DATA)) || state_c == (WRITE_DATA) || state_c == (ADDR_DEVICE_R)) ;
    // wire                end_cnt_bit         ; // cnt_bit == 7
    assign  end_cnt_bit = add_cnt_bit && (cnt_bit == (`MAX_CNT_BIT - 1)) ;

    // reg     [31:0]      cnt_data            ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            cnt_data <= 3'd0 ;
        else if(add_cnt_data) begin
            if(end_cnt_data)
                cnt_data <= 3'd0 ;
            else 
                cnt_data <= cnt_data + 1'b1 ;
        end
        else if(keep_cnt_data)
            cnt_data <= cnt_data ;
        else 
            cnt_data <= 3'd0 ;
    end

    assign    add_cnt_data  = (state_c == (READ_DATA) || state_c == (WRITE_DATA))
                            && (end_cnt_scl && scl && end_cnt_bit) ;
    assign    end_cnt_data  = add_cnt_data && (cnt_data == `MAX_CNT_DATA - 1);
    assign    keep_cnt_data = ((state_c == (READ_DATA)) || (state_c == (WRITE_DATA)) || (state_c == (ACK_MASTER)) || (state_c == (ACK_SLAVE2_W)));

    // reg                 master_ack_ok       ; // 用来检测主机是否正常产生响应。
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            master_ack_ok <= 1'b0 ;
        else if(state_c == ACK_MASTER) begin
            if(cnt_scl == (`MAX_CNT_SCL >> 1) && scl && ~sda)
                master_ack_ok <= 1'b1 ;
            else 
                master_ack_ok <= master_ack_ok ;
        end
        else if(state_c == NOACK_MASTER) begin
            if(cnt_scl == (`MAX_CNT_SCL >> 1) && scl && sda)
                master_ack_ok <= 1'b1 ;
            else 
                master_ack_ok <= master_ack_ok ;
        end
        else 
            master_ack_ok <= 1'b0 ;
    end
    // reg                 slave_ack_ok        ; // 从机在规定时刻有响应
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            slave_ack_ok <= 1'b0 ;
        else if(state_c == (SLAVE_ACK) || state_c == (ACK_SLAVE2_R) || state_c == (ACK_SLAVE2_W)) begin
            if(cnt_scl == (`MAX_CNT_SCL >> 1) && scl && ~sda) // && ~sda
                slave_ack_ok <= 1'b1 ;
            else 
                slave_ack_ok <= slave_ack_ok ;
        end
        else 
            slave_ack_ok <= 1'b0 ;
    end
    // reg                 addr_first_req      ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            addr_first_req <= 1'b0 ;
        else if(state_c == START) 
            addr_first_req <= 1'b1 ;
        else if(state_c == ADDR_FIRST)
            addr_first_req <= 1'b0 ;
        else 
            addr_first_req <= addr_first_req ;
    end
    // reg                 addr_second_req     ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            addr_second_req <= 1'b0 ;
        else if(state_c == START) 
            addr_second_req <= 1'b1 ;
        else if(state_c == ADDR_SECOND)
            addr_second_req <= 1'b0 ;
        else 
            addr_second_req <= addr_second_req ;
    end
    // reg                 start2_req          ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            start2_req <= 1'b0 ;
        else if((state_c == START) && (read_work)) 
            start2_req <= 1'b1 ;
        else if(state_c == START2)
            start2_req <= 1'b0 ;
        else 
            start2_req <= start2_req ;
    end

    // reg         read_work   ; // 根据输入端口的flag信号，控制工作状态。
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            read_work <= 1'b0 ;
        else if(state_c == END_R)
            read_work <= 1'b0 ;
        else if(!write_work && iic_rd_flag)
            read_work <= 1'b1 ;
        else 
            read_work <= read_work ;
    end
    // reg         write_work  ; // 不能有同时拉高的时候。
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            write_work <= 1'b0 ;
        else if(state_c == END_W)
            write_work <= 1'b0 ;
        else if(!write_work && iic_wr_flag)
            write_work <= 1'b1 ;
        else 
            write_work <= write_work ;
    end
    // reg                 write_data_req      ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            write_data_req <= 1'b0 ;
        else if(state_c == WRITE_DATA && (end_cnt_scl && scl && end_cnt_bit) && cnt_data == (`MAX_CNT_DATA - 1))
                write_data_req <= 1'b0 ;
        else if(state_c == START && (end_cnt_scl && scl && write_work))
            write_data_req <= 1'b1 ;
        else 
            write_data_req <= write_data_req ;
    end
    // reg                 ack_master_req      ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            ack_master_req <= 1'b0 ;
        else if(state_c == READ_DATA && (end_cnt_scl && scl && end_cnt_bit) && cnt_data == (`MAX_CNT_DATA - 2))
                ack_master_req <= 1'b0 ;
        else if(state_c == START && (end_cnt_scl && scl && read_work))
            ack_master_req <= 1'b1 ;
        else 
            ack_master_req <= ack_master_req ;
    end
    // reg                 noack_master_req    ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            noack_master_req <= 1'b0 ;
        else if(state_c == NOACK_MASTER)
                noack_master_req <= 1'b0 ;
        else if(state_c == START && (end_cnt_scl && scl && read_work))
            noack_master_req <= 1'b1 ;
        else 
            noack_master_req <= noack_master_req ;
    end
    // reg                 end_w_req           ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            end_w_req <= 1'b0 ;
        else if(state_c == END_W)
                end_w_req <= 1'b0 ;
        else if(state_c == START && (end_cnt_scl && scl && write_work))
            end_w_req <= 1'b1 ;
        else 
            end_w_req <= end_w_req ;
    end

    // reg              sda_out ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            sda_out <= 1'b1 ;
        else 
        case (state_c)
        IDLE           :    sda_out <= 1'b1 ;
        START          :    if(cnt_scl == (`MAX_CNT_SCL >> 1) && scl) 
                                sda_out <= 1'b0 ;
                            else 
                                sda_out <= sda_out ;
        ADDR_DEVICE    :    if(cnt_scl == (`MAX_CNT_SCL >> 1) && !scl) 
                                sda_out <= DEVICE_W[7 - cnt_bit] ;
                            else 
                                sda_out <= sda_out ;
        SLAVE_ACK      :    sda_out <= 1'b1 ;
        ADDR_FIRST     :    if(cnt_scl == (`MAX_CNT_SCL >> 1) && !scl) 
                                sda_out <= addr_h[7 - cnt_bit] ;
                            else 
                                sda_out <= sda_out ;
        ADDR_SECOND    :    if(cnt_scl == (`MAX_CNT_SCL >> 1) && !scl) 
                                sda_out <= addr_l[7 - cnt_bit] ;
                            else 
                                sda_out <= sda_out ;
        START2         :    if(cnt_scl == (`MAX_CNT_SCL >> 1) && !scl) 
                                sda_out <= 1'b1 ;
                            else if(cnt_scl == (`MAX_CNT_SCL >> 1) && scl) 
                                sda_out <= 1'b0 ;
                            else 
                                sda_out <= sda_out ;
        ADDR_DEVICE_R  :    if(cnt_scl == (`MAX_CNT_SCL >> 1) && !scl) 
                                sda_out <= DEVICE_R[7 - cnt_bit] ;
                            else 
                                sda_out <= sda_out ;
        ACK_SLAVE2_R   :    sda_out <= 1'b1 ;
        READ_DATA      :    sda_out <= 1'b1 ;
        ACK_MASTER     :    sda_out <= 1'b0 ;
        NOACK_MASTER   :    sda_out <= 1'b1 ;
        END_R          :    if(cnt_scl == (`MAX_CNT_SCL >> 1) && !scl) 
                                sda_out <= 1'b0 ;
                            else if(cnt_scl == (`MAX_CNT_SCL >> 1) && scl)
                                sda_out <= 1'b1 ;
                            else 
                                sda_out <= sda_out ;
        WRITE_DATA     :    if(cnt_scl == (`MAX_CNT_SCL >> 1) && !scl) 
                                sda_out <= generate_data[7 - cnt_bit] ;
                            else 
                                sda_out <= sda_out ;
        ACK_SLAVE2_W   :    sda_out <= 1'b1 ;
        END_W          :    if(cnt_scl == (`MAX_CNT_SCL >> 1) && !scl) 
                                sda_out <= 1'b0 ;
                            else if(cnt_scl == (`MAX_CNT_SCL >> 1) && scl)
                                sda_out <= 1'b1 ;
                            else 
                                sda_out <= sda_out ;
        default        :        sda_out <= 1'b1 ;
        endcase
    end                                                                                
    // wire            iic_en ;
    // reg                 iic_en  ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            iic_en <= 1'b0 ;
        else if((state_c == IDLE) || (state_c == START) || (state_c == ADDR_DEVICE) || (state_c == ADDR_FIRST) 
             || (state_c == ADDR_SECOND) || (state_c == START2) || (state_c == ADDR_DEVICE_R) || (state_c == ACK_MASTER) 
             || (state_c == NOACK_MASTER) || (state_c == END_R) || (state_c == WRITE_DATA) || (state_c == END_W))
            iic_en <= 1'b1 ;
        else 
            iic_en <= 1'b0 ;
    end
    reg             sda_out_r ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            sda_out_r <= 1'b1 ;
        else 
            sda_out_r <= sda_out ;
    end
    // assign  iic_en = ~((state_c == SLAVE_ACK) || (state_c == ACK_SLAVE2_R) || (state_c == ACK_SLAVE2_W) || (state_c == READ_DATA)) ;
    // assign  iic_en = ((state_c == IDLE) || (state_c == START) || (state_c == ADDR_DEVICE) || (state_c == ADDR_FIRST) 
    // || (state_c == ADDR_SECOND) || (state_c == START2) || (state_c == ADDR_DEVICE_R) || (state_c == ACK_MASTER) 
    // || (state_c == NOACK_MASTER) || (state_c == END_R) || (state_c == WRITE_DATA) || (state_c == END_W)) ? 1'b1 : 1'b0 ;
    // output signal
    // inout       wire                sda             ,
    assign  sda = (iic_en) ? sda_out_r : 1'bz ;
    // output		reg                 scl             ,
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            scl  <= 1'b1 ;
        else if(end_cnt_scl && (state_c != IDLE))
            scl  <= ~scl ;
        else if(state_c == IDLE)
            scl  <= 1'b1 ;
        else    
            scl  <=  scl ;
    end
    // output      wire                iic_wr_done     ,
    assign  iic_wr_done = ~write_work && write_work_r ; 
    // output      wire                iic_rd_done     ,
    assign  iic_rd_done = ~read_work && read_work_r ; 
    // output      reg     [7:0]       po_data         ,
    // output      reg                 po_flag     
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            po_data <= 8'd0  ;
            po_flag <= 1'b0  ;
        end
        else begin
            po_data <= po_data_r ;
            po_flag <= po_flag_r ;
        end
    end

ila_0 ila_0_inst (
	.clk(sys_clk), // input wire clk

	.probe0(state_c), // input wire [3:0]  probe0  
	.probe1(write_work), // input wire [0:0]  probe1 
	.probe2(read_work), // input wire [0:0]  probe2 
	.probe3(sda_out), // input wire [0:0]  probe3 
	.probe4(iic_en), // input wire [0:0]  probe4 
	.probe5(scl), // input wire [0:0]  probe5 
	.probe6(sda), // input wire [0:0]  probe6 
	.probe7(iic_wr_flag) // input wire [0:0]  probe7
);

endmodule

仿真：

上板验证：

可优化的地方：

1，存储地址，1字节，2字节。

2，数据的产生，是自己产生的，可以优化成总线的形式。或者数据流的形式。

反思：

1，第一次设计的时候，状态机设计的很烂。要多观察，找状态上的异同。

2，组合逻辑不要过长，多用时序逻辑。防止竞争与冒险。

3，尽量不画完整时序图，写代码锻炼想象力，加强代码与波形之间转换的能力。

核桃_warrior

关注

22
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
ZYNQ_project:IIC_EEPROM

EEPROM(Electrically Erasable Progammable Read Only Memory， E2PROM)是指带电可擦可编程只读存储器，是一种常用的非易失性存储器（掉电数据不丢失）， E2PROM 有多种类型的产品，我们领航者 ZYNQ开发板上使用的是 ATMEL 公司生产的 AT24C 系列的 AT24C64 这一型号。AT24C64 具有高可靠性，可对所存数据保存 100 年，并可多次擦写，擦写次数达一百万次。它的存储容量：256页每页32个字节。
复制链接

扫一扫