I2C通信

项目之前研究了I2C通信协议的实现，完成FPGA对视频解码芯片SAA7111A的初始化配置，设计实现了I2C主机对从机（SAA7111A）32个寄存器的写操作，因此只简单实现了I2C的写时序。

这次重新梳理学习了I2C协议，借助黑金开发板设计I2C主机控制器完成对EEPROM（24LC02）的读写操作，设计单字节的写时序和随机读时序。通过按键将数据先入EEPROM，再通过按键选择将数据显示在数码管上进行验证。

1. 时序介绍

主要的时序如下所示：

数据线SDA在空闲状态时为高电平，在SCL高电平时拉低SDA表示开始，在SCL低电平时拉高SDA表示结束。数据在SCL低电平时变化，8位数据，高位在前，低位在后。一个数据字节后，接收器需要产生一个低电平，即拉低SDA，表示接收正确。

写时序:

读时序：

其中，应答位一般由接收器产生，在读时序时主机接收数据一般不产生应答位（NO ACK），除了在连续读模式下，一个数据读完需要拉低SDA产生应答位。

2. 串行时钟线（SCL）

首先要确定SCL时钟，根据系统时钟利用计数器完成SCL的100KHz的设置，这里SCL作为输出信号，因此为输出单向口。

         //分频部分
 reg[:] cnt;    // cnt=0:scl上升沿，cnt=1:scl高电平中间，cnt=2:scl下降沿，cnt=3:scl低电平中间
 reg[:] cnt_delay;    //500循环计数，产生iic所需要的时钟
 reg scl_r;        //时钟脉冲寄存器

 always @ (posedge clk or negedge rst_n)
     if(!rst_n) cnt_delay <= 'd0;
     else if(cnt_delay == 'd499) cnt_delay <= 9'd0;    //计数到10us为scl的周期，即100KHz
     else cnt_delay <= cnt_delay+'b1;    //时钟计数

 always @ (posedge clk or negedge rst_n) begin
     if(!rst_n) cnt <= 'd5;
     else begin
         case (cnt_delay)
             'd124:    cnt <= 3'd1;    //cnt=1:scl高电平中间,用于数据采样
             'd249:    cnt <= 3'd2;    //cnt=2:scl下降沿
             'd374:    cnt <= 3'd3;    //cnt=3:scl低电平中间,用于数据变化
             'd499:    cnt <= 3'd0;    //cnt=0:scl上升沿
             default: cnt <= 'd5;
             endcase
         end
 end

 `define SCL_POS        (cnt=='d0)        //cnt=0:scl上升沿
 `define SCL_HIG        (cnt=='d1)        //cnt=1:scl高电平中间,用于数据采样
 `define SCL_NEG        (cnt=='d2)        //cnt=2:scl下降沿
 `define SCL_LOW        (cnt=='d3)        //cnt=3:scl低电平中间,用于数据变化

 always @ (posedge clk or negedge rst_n)
     if(!rst_n) scl_r <= 'b0;
     else if(cnt=='d0) scl_r <= 1'b1;    //scl信号上升沿
        else if(cnt=='d2) scl_r <= 1'b0;    //scl信号下降沿

 assign scl = scl_r;    //产生iic所需要的时钟

分频产生SCL

根据计数器的计数结果获得SCL的上升沿、高电平中间时刻、下降沿和低电平中间时刻。四个信号作为系统时钟的使能信号，保持信号的同步，完成发送和接收。

3. 串行数据线（SDA）

串行数据线是双向口，作为输出口时，完成开始信号、结束信号、从机地址、字节地址和写数据的输出；作为输入口时，完成从机应答位和读数据的输入。因此需要实现一个三态口控制:

assign sda = sda_link ? sda_r:1'bz;

本实验设计了一段式的状态机控制串行数据口的输入和输出，涉及单字节写时序和随机读时序。

由时序可知，前两次数据字节操作一样，可共享代码。在第3个数据字节处理时，写时序进行之前同样的操作即可，最后产生停止位；读时序时先发送从机地址读操作命令字节（最后一位为1），然后SDA口设置为输入口读取数据，最后FPGA无需产生应答位而产生停止位即可。返回IDLE状态前，产生清零标志以清零上次按键结果。

写一个字节：

             IDLE:    begin
                     sda_link <= 'b1;            //数据线sda为output
                     sda_r <= 'b1;
                     if(!sw1_r || !sw2_r) begin    //SW1,SW2键有一个被按下
                         db_r <= `DEVICE_WRITE;    //送器件地址（写操作） //写读控制字节
                         cstate <= START1;
                         end
                     else cstate <= IDLE;    //没有任何键被按下
                 end
             START1:if(`SCL_HIG) begin        //scl为高电平期间
                         sda_link <= 'b1;    //数据线sda为output
                         sda_r <= 'b0;        //拉低数据线sda，产生起始位信号
                         cstate <= ADD1;
                         num <= 'd0;        //num计数清零
                         end
                      else cstate <= START1; //等待scl高电平中间位置到来

             ADD1:    if(`SCL_LOW) begin
                             if(num == 'd8) begin
                                     num <= 'd0;            //num计数清零
 //                                    sda_r <= 1'b1;
                                     sda_link <= 'b0;        //sda置为高阻态(input)
                                     cstate <= ACK1;
                                 end
                             else begin
                                     cstate <= ADD1;
                                     num <= num+'b1;
                                     case (num)
                                         'd0: sda_r <= db_r[7];
                                         'd1: sda_r <= db_r[6];
                                         'd2: sda_r <= db_r[5];
                                         'd3: sda_r <= db_r[4];
                                         'd4: sda_r <= db_r[3];
                                         'd5: sda_r <= db_r[2];
                                         'd6: sda_r <= db_r[1];
                                         'd7: sda_r <= db_r[0];
                                         default: ;
                                         endcase
                             //        sda_r <= db_r[4'd7-num];    //送器件地址，从高位开始
                                 end
                         end
             //        else if(`SCL_POS) db_r <= {db_r[6:0],1'b0};    //器件地址左移1bit
                     else cstate <= ADD1;

             ACK1:
 //                    if(/*!sda*/`SCL_NEG) begin    //注：24C01/02/04/08/16器件可以不考虑应答位
                     if(`SCL_HIG && !sda) begin   // SCL_HIG高电平时sda稳定，可以考虑`SCL_HIG && !sda和!sda效果一样
                             cstate <= ADD2;    //从机响应信号
                             db_r <= `BYTE_ADDR;    // 存储器读写地址
                         end
                     else cstate <= ACK1;        //等待从机响应

读一个字节：

 //*********读操作起始位,先拉高SDA，再拉低SDA    ******************************//
             START2:if(`SCL_LOW) begin   //等待应答位高电平过去，检测一下个SCL的低电平！！！！
                         sda_link <= 'b1;    //sda作为output
                         sda_r <= 'b1;        //拉高数据线sda
                         cstate <= READ;
                         end
                     else cstate <= START2;

             READ: if(`SCL_HIG) begin    //scl为高电平中间
                         sda_r <= 'b0;        //拉低数据线sda，产生起始位信号
                         cstate <= ADD3;
                 end    

             ADD3:    //送读控制字节
                     if(`SCL_LOW) begin
                             if(num=='d8) begin
                                     num <= 'd0;            //num计数清零
 //                                    sda_r <= 1'b1;
                                     sda_link <= 'b0;        //sda置为高阻态(input)
                                     cstate <= ACK3;
                                 end
                             else begin
                                     num <= num+'b1;
                                     case (num)
                                         'd0: sda_r <= db_r[7];
                                         'd1: sda_r <= db_r[6];
                                         'd2: sda_r <= db_r[5];
                                         'd3: sda_r <= db_r[4];
                                         'd4: sda_r <= db_r[3];
                                         'd5: sda_r <= db_r[2];
                                         'd6: sda_r <= db_r[1];
                                         'd7: sda_r <= db_r[0];
                                         default: ;
                                         endcase
                                 //    sda_r <= db_r[4'd7-num];    //送EEPROM地址（高bit开始）
                                     cstate <= ADD3;
                                 end
                         end
                 //    else if(`SCL_POS) db_r <= {db_r[6:0],1'b0};    //器件地址左移1bit
                     else cstate <= ADD3;        

             ACK3:    begin
 //                    if(/*!sda*/`SCL_NEG) begin
                     if(`SCL_HIG && !sda) begin
                             cstate <= wait_L;    //从机响应信号
 //                            sda_link <= 1'b0;
                         end
                     else cstate <= ACK3;         //等待从机响应
                 end

             wait_L: if(/*`SCL_NEG*/`SCL_LOW) cstate <= DATA; //等待应答位高电平过去，检测一下个SCL的低电平！！！！

             DATA:    if(!sw2_r) begin      //读操作
                             if((`SCL_LOW) && (num=='d8)) begin
                                 num <= 'd0;            //num计数清零
                                 cstate <= NO_ACK;
                             end
                             else if(`SCL_HIG && (num<='d7) ) begin
                                     num <= num+'b1;
                                     case (num)
                                         'd0: read_data[7] <= sda;
                                         'd1: read_data[6] <= sda;
                                         'd2: read_data[5] <= sda;
                                         'd3: read_data[4] <= sda;
                                         'd4: read_data[3] <= sda;
                                         'd5: read_data[2] <= sda;
                                         'd6: read_data[1] <= sda;
                                         'd7: read_data[0] <= sda;
                                         default: ;
                                     endcase
                     //                read_data[4'd7-num] <= sda;    //读数据（高bit开始）
                                    cstate <= DATA;
                 //                else if(`SCL_NEG) read_data <= {read_data[6:0],read_data[7]};    //数据循环右移
                             end
                             else cstate <= DATA;
                     end