一，前言

I2C总线支持设备之间的短距离通信，用于处理器和一些外围设备之间数据传输，它只需要两根信号线来就能完成数据传输。在分析I2C总线驱动之前，需要先了解下i2c协议。

二，硬件电路

硬件上的连接一般如下图所示，主控mcu上两根信号线SDA和SCL，多个设备可以同时接入，SDA和SCL必须接上拉电阻，阻值一般为4.7K。从图上可看出，I2C为主从模式，发出SCL的为主，其他为从。两根信号线，一根时钟线、一根数据线决定了它是半双工的通信模式，同一时间只能单向传输数据。
在这里插入图片描述

三，数据传输

I2C协议把传输的消息分为两种类型的帧：一个地址帧和一个或多个数据帧。地址帧表示了主控将和哪个从设备进行通信。数据传输过程中，SDA线上的数据必须在SCL高电平期间保持稳定，在SCL低电平期间才能发生高低电平的转换。
在这里插入图片描述

START：起始信号，当SCL为高电平时，SDA从高电平到低电平转换。
ADDRESS+R/W+ACK：地址帧，包含将进行通信的从设备的地址，1~7位为从设备地址，第8位为读写位（高电平-读，低电平-写），ACK为从机的响应（此时SDA交由从机控制，从机输出低电平表示响应）。
DATA+ACK：将要写给从机的数据，或者将要从从机读取的数据。
STOP：停止信号，当SCL为高电平时，SDA从低电平到高电平转换。

3.1 写操作一般流程

主设备发起一个起始信号
开始传输从设备地址，高七位表示从设备地址，最后一位为0，表示写。
从地址传输完成后，将SDA设为输入状态，读取SDA电平状态，如果为0则表示被从设备拉低，即为一个ACK信号，表示找到了从设备。如果不为0，则表示从设备未响应，主设备发起停止信号，终止传输。
找到从设备后，即开始传输需要将数据写入到从设备内部位置的地址值，和上一步类似。
传输完从设备内部地址后，便可传输需要写到内部地址的数据。判断需要写入的数据大小，以字节为单位传输。
传输完成后，主机发起一个停止信号，终止本次写操作。

3.2 读操作一般流程

读操作，需要先把要读取的从设备内部地址传输给从设备，再执行读操作。

写入要读取的从设备内部地址。步骤见3.1。
主设备发起一个起始信号
开始传输从设备地址，高七位表示从设备地址，最后一位为1，表示读。
从地址传输完成后，将SDA设为输入状态，读取SDA电平状态，如果为0则表示被从设备拉低，即为一个ACK信号，表示找到了从设备。如果不为0，则表示从设备未响应，主设备发起停止信号，终止传输。
找到从设备后，即开始读取从设备内部地址处的数据。
判断需要读取的数据大小，以字节为单位传输。
传输完成后，主机发起一个停止信号，终止本次写操作。

四，IO口模拟I2C

4.1 IO口初始化

void sys_i2c_init_board(void)
{
    //初始化IO口,SCL配置为输出高
    GPIO_InitTypeDef PB6={GPIO_Pin_6,GPIO_Speed_2MHz,GPIO_Mode_Out_OD};
    GPIO_Init(GPIOB, &PB6);
    //初始化IO口，SDA配置为输出高
    GPIO_InitTypeDef PB7={GPIO_Pin_7,GPIO_Speed_2MHz,GPIO_Mode_Out_OD};
    GPIO_Init(GPIOB,&PB7);
}

4.2 起始信号

//START: High -> Low on SDA while SCL is High
void soft_i2c_send_start(void)
{
    SET_SDA_OUT;
    I2C_DELAY();
    
    I2C_SDA(1);
    I2C_SCL(1);
    I2C_DELAY();
    
    I2C_SDA(0);  // scl高电平期间，SDA拉低
    I2C_DELAY();
    
    I2C_SCL(0);
    I2C_DELAY();
}

4.3 停止信号

//STOP: Low -> High on SDA while SCL is High
void soft_i2c_send_stop(void)
{
    I2C_SCL(0);
    SET_SDA_OUT;
    I2C_SDA(0);
    I2C_DELAY();
    
  
    I2C_SCL(1);
    I2C_DELAY();

    I2C_SDA(1);  // scl高电平期间，SDA拉高
    I2C_DELAY();
}

4.4 读一个字节(该I2C例程内部使用)

static u8 soft_i2c_read_byte(int ack)
{
  u8  data;
  int  j;
  
  SET_SDA_IN;
  
  data = 0;
  for(j = 0; j < 8; j++) 
  {
    I2C_DELAY();
    I2C_SCL(1);
    I2C_DELAY();
    data <<= 1;
    data |= I2C_SDA_VALUE_IN;
    I2C_DELAY();
    I2C_SCL(0);
    I2C_DELAY();
  }
  soft_i2c_send_ack(ack);
  
  return(data);
}

4.5 写一个字节(该I2C例程内部使用)

static int soft_i2c_write_byte(u8 data)
{
  int j;
  int nack;
  
  SET_SDA_OUT;
  for(j = 0; j < 8; j++) 
  {
    I2C_SDA(data & 0x80);
    I2C_DELAY();
    I2C_SCL(1);
    I2C_DELAY();
    I2C_DELAY();
    I2C_SCL(0);
    I2C_DELAY();
    
    data <<= 1;
  }

  /*
   * Look for an <ACK>(negative logic) and return it.
   */
  
  SET_SDA_IN;
  I2C_DELAY();
  I2C_SCL(1);
  I2C_DELAY();
  nack = I2C_SDA_VALUE_IN;
  I2C_DELAY();
  I2C_SCL(0);
  I2C_DELAY();
  
  SET_SDA_OUT;
  //I2C_SDA(1);
  return(nack);	/* not a nack is an ack */
}

4.6 I2C读数据（供外部调用）

int soft_i2c_read(u8 chipaddr, u32 internalAddr, u32 internalAddrLen, u8 *buffer, int len)
{
  int shift;

  /*
   * Do the addressing portion of a write cycle to set the
   * chip's address pointer.  If the address length is zero,
   * don't do the normal write cycle to set the address pointer,
   * there is no address pointer in this chip.
   */
  soft_i2c_send_start();
  if(internalAddrLen > 0) 
  {
    if(soft_i2c_write_byte(chipaddr << 1)) 	/* write cycle */
    {
      soft_i2c_send_stop();
      return(1);
    }
    shift = (internalAddrLen-1) * 8;
    while(internalAddrLen-- > 0) 
    {
      if(soft_i2c_write_byte(internalAddr >> shift)) 
      {
        //printf("i2c_read, internal address not <ACK>ed\n");
        return(1);
      }
      shift -= 8;
    }

  /* Some I2C chips need a stop/start sequence here,
   * other chips don't work with a full stop and need
   * only a start.  Default behaviour is to send the
   * stop/start sequence.
   */
#ifdef CONFIG_SOFT_I2C_READ_REPEATED_START
    soft_i2c_send_start();
#else
    soft_i2c_send_stop();
    soft_i2c_send_start();
#endif
  }
  /*
   * Send the chip address again, this time for a read cycle.
   * Then read the data.  On the last byte, we do a NACK instead
   * of an ACK(len == 0) to terminate the read.
   */
  soft_i2c_write_byte((chipaddr << 1) | 1);	/* read cycle */
  while(len-- > 0) 
  {
      *buffer++ = soft_i2c_read_byte(len == 0);
  }
  soft_i2c_send_stop();
  return(0);
}

4.7 I2C写入数据（供外部调用）

int soft_i2c_write(u8 chipaddr, u32 internalAddr, u32 internalAddrLen, u8 *buffer, int len)
{
    int shift, failures = 0;

    //printf("i2c_write: chip %02X addr %02X alen %d buffer %p len %d\n",chip, addr, alen, buffer, len);

    soft_i2c_send_start();
    if(soft_i2c_write_byte(chipaddr<<1)) 	/* write cycle */
    {	
        soft_i2c_send_stop();
        //printf("i2c_write, no chip responded %02X\n", chipaddr);
        return(1);
    }
    shift = (internalAddrLen-1) * 8;
    while(internalAddrLen-- > 0) 
    {
        if(soft_i2c_write_byte(internalAddr >> shift)) 
        {
            //printf("i2c_write, address not <ACK>ed\n");
            return(1);
        }
        shift -= 8;
    }

    while(len-- > 0) 
    {
        if(soft_i2c_write_byte(*buffer++)) 
        {
            failures++;
        }
    }
    soft_i2c_send_stop();
    return(failures);
}