GPIO模拟I2C程序实现

GPIO模拟I2C程序实现.

I2C是由Philips公司发明的一种串行数据通信协议，仅使用两根信号线：SerialClock（简称SCL）和SerialData（简称SDA）。I2C是总线结构，1个Master，1个或多个Slave，各Slave设备以7位地址区分，地址后面再跟1位读写位，表示读（=1）或者写（=0），所以我们有时也可看到8位形式的设备地址，此时每个设备有读、写两个地址，高7位地址其实是相同的。
I2C数据格式如下：
无数据：SCL=1，SDA=1；
开始位（Start）：当SCL=1时，SDA由1向0跳变；
停止位（Stop）：当SCL=1时，SDA由0向1跳变；
数据位：当SCL由0向1跳变时，由发送方控制SDA，此时SDA为有效数据，不可随意改变SDA；
当SCL保持为0时，SDA上的数据可随意改变；
地址位：定义同数据位，但只由Master发给Slave；
应答位（ACK）：当发送方传送完8位时，发送方释放SDA，由接收方控制SDA，且SDA=0；
否应答位（NACK）：当发送方传送完8位时，发送方释放SDA，由接收方控制SDA，且SDA=1。
当数据为单字节传送时，格式为：
开始位，8位地址位（含1位读写位），应答，8位数据，应答，停止位。
当数据为一串字节传送时，格式为：
开始位，8位地址位（含1位读写位），应答，8位数据，应答，8位数据，应答，……，8位数据，应答，停止位。
需要注意的是：
1，SCL一直由Master控制，SDA依照数据传送的方向，读数据时由Slave控制SDA，写数据时由Master控制SDA。当8位数据传送完毕之后，应答位或者否应答位的SDA控制权与数据位传送时相反。
2，开始位“Start”和停止位“Stop”，只能由Master来发出。
3，地址的8位传送完毕后，成功配置地址的Slave设备必须发送“ACK”。否则否则一定时间之后Master视为超时，将放弃数据传送，发送“Stop”。
4，当写数据的时候，Master每发送完8个数据位，Slave设备如果还有空间接受下一个字节应该回答“ACK”，Slave设备如果没有空间接受更多的字节应该回答“NACK”，Master当收到“NACK”或者一定时间之后没收到任何数据将视为超时，此时Master放弃数据传送，发送“Stop”。
5，当读数据的时候，Slave设备每发送完8个数据位，如果Master希望继续读下一个字节，Master应该回答“ACK”以提示Slave准备下一个数据，如果Master不希望读取更多字节，Master应该回答“NACK”以提示Slave设备准备接收Stop信号。
6，当Master速度过快Slave端来不及处理时，Slave设备可以拉低SCL不放（SCL=0将发生“线与”）以阻止Master发送更多的数据。此时Master将视情况减慢或结束数据传送。

7,I²C规程运用主/从双向通讯。器件发送数据到总线上，则定义为发送器，器件接收据

定义为接收器。主器件和从器件都可以工作于接收和发送状态。 总线必须由主器件（通常

为微控制器）控制，主器件产生串行时钟（SCL）控制总线的传输方向，并产生起始和停止

条件。SDA线上的数据状态仅在SCL为低电平的期间才能改变，SCL为高电平的期间，SDA

状态的改变被用来表示起始和停止条件。

 

在实际应用中，并没有强制规定数据接收方必须对于发送的8位数据做出回应，尤其是在Master和Slave端都是用GPIO软件模拟的方法来实现的情况下，编程者可以事先约定数据传送的长度，不发送ACK，有时可以起到减少系统开销的效果。

源码:

/********************************************************************/

void i2c_init(void)
{
PACNT_init;
PADDR_init;
PADAT_init;

SCL_high;
SDA_high;
}

/********************************************************************/

uint8 i2c_write(uint8 slave_address, uint8 *buffer, int byte_count, int freq)
{
    uint8 out_mask = 0x80;
    uint8 value = 0x00;
  uint8 send_byte = 0x00;
  uint8 status = 0x81;
  int count = 8;
  int clk_count = 0;
int i = 0;

/* Set delay value based on frequency. */
int D = (int) ((4000/freq) - 14);

slave_address = (slave_address & 0xFE);
        
  i2c_start();
  delay(500);
  
   send_byte = slave_address;
        
   for(i = 0; i <= byte_count; i++)
   {    
    count = 8;  
    out_mask = 0x80;
        
    /* Send data bytes one bit at a time. */  
    while(count > 0)
    {            
     value = ((send_byte & out_mask) ? 1 : 0);
      if (value == 1)
      {
       PADAT_init;
        SDA_high;}
      else
      {
       PADAT_init;
       SDA_low;}
      
      delay(D);    
                  
        PADAT_init;
      SCL_high;
      
      /* Clock stretching wait statement.  Wait until clock is released
      by slave.  Only effects program on first iteration.  */
   while (((GPIO_PADAT & 0x0200) ? 1 : 0) == 0){;}

      delay(2*D);  
      
      PADAT_init;
      SCL_low;
      delay(D);
      
      out_mask >>= 1;
      count--;  
     }
    
     PADAT_init;
     SDA_high;  /* Let go of data pin. */
     delay(D);
      
     if (((GPIO_PADAT & 0x0400) ? 1 : 0) == 1)
     {
      status = 0xA1; /* Transfer complete, bus busy, acknowledge not received. */
      break; } /* If not acknowledged, exit loop. */
    
    PADAT_init;
     SCL_high;
     delay(2*D);  
    
     PADAT_init;
     SCL_low;
     status = 0xA0;  /* Transfer complete, bus busy, acknowledge received. */
     delay(D);
    
     send_byte = buffer[i];      
    }
    
    PADAT_init;
    SDA_high;
    SCL_low;  
delay(100);
return(status);
}

/********************************************************************/

uint8 i2c_read(uint8 slave_address, uint8 *buffer, int byte_count, int freq)
{
uint8 input_byte = 0x00;
uint8 value = 0x00;
uint8 out_mask = 0x80;
uint8 status = 0x81;
int count = 8;
int clk_count = 0;
int i = 0;

/* Set delay value based on frequency. */
int D = (int) ((4000/freq) - 14);

slave_address = (slave_address | 0x01);
  
i2c_start();
delay(500);
              
/**********  Write Address Procedure **********/
  
   while(count > 0)
   {
    value = ((slave_address & out_mask) ? 1 : 0);
     if (value == 1)
     {
      PADAT_init;
       SDA_high;}
     else
     {
      PADAT_init;
      SDA_low;}
      delay(D);      
                  
      PADAT_init;
     SCL_high;
      
     /* Clock stretching wait.  Wait until clock is released
     by slave.  */
     while (((GPIO_PADAT & 0x0200) ? 1 : 0) == 0){;}

     delay(2*D);
      
     PADAT_init;
     SCL_low;
     delay(D);  
      
     out_mask >>= 1;
     count--;        
  }
    
    PADAT_init;
  SDA_high;  /* Let go of data pin. */
    delay(D);
    SCL_high;
    delay(2*D);  
    
    /* If not acknowleged, set status accordingly and exit read process. */
    if (((GPIO_PADAT & 0x0400) ? 1 : 0) == 1)
    {
     status = 0xA1;
     return(status);}
    
    PADAT_init;
    SCL_low;
    delay(D);

/**********  Begin Read Procedure **********/

/* Release SDA and SCL to initiate transfer. */
PADAT_init;    
SDA_high;
SCL_high;

for(i = 0; i < byte_count; i++)
{
  count = 8;
  input_byte = 0x00;
  
  PADAT_init;
  SCL_high;
  
  /* Clock stretching wait.  Wait until clock is released
     by slave.  */
  while (((GPIO_PADAT & 0x0200) ? 1 : 0) == 0){;}
          
  /* Loop for bit-by-bit read of data. */
  while(count > 0)
  {
    PADAT_init;
    SCL_high;
    delay(D);  
    delay(4); /* Required to make read and write clocks the same freq. */
    
   if ((GPIO_PADAT & 0x0600) == 0x0600)
    input_byte++;
  
   delay(D);  
  
   PADAT_init;
   SCL_low;
   delay(2*D);
      
   if (count == 1)
    break;
   else  
    input_byte <<= 1;
  
   count--;
  }

  /* Write input byte to "read_buffer". */
  buffer[i] = input_byte;
    
  if(i == (byte_count - 1))
   break;
    
     /* Below is the acknowledge procedure. */    
     PADAT_init;
     SDA_low;
     delay(D);  
     SCL_high;    
  delay(2*D);  
    
     PADAT_init;
     SCL_low;
     delay(D);  
     SDA_high;
     status = 0xA0;
}    

/* Standard protocol calls for the last read byte to
    not receive an acknowledge from the master. */    
PADAT_init;
    SDA_high;
    SCL_high;    
delay(2*D);
    
   PADAT_init;
   SCL_low;
   delay(D);  
   SDA_high;
   status = 0xA1;
   return(status);
}

/********************************************************************/

void i2c_start(void)
{
int clk_count = 0;
uint8 compare = 0x00;

PADAT_init;  
SDA_high;
delay(100);

PADAT_init;  
SCL_high;
delay(100);

/* Clock stretching wait.  Wait until clock is released
    by slave.  */
while (((GPIO_PADAT & 0x0200) ? 1 : 0) == 0){;}    
  
PADAT_init;
SDA_low;
delay(100);
    
    PADAT_init;  
SCL_low;
delay(100);
}

/********************************************************************/

uint8 i2c_stop(void)
{
uint8 status = 0x00;
int clk_count = 0;
  
PADAT_init;
SCL_low;
delay(100);

PADAT_init;
SDA_low;
delay(100);
    
    PADAT_init;
SCL_high;

/* Clock stretching wait statement.  Wait until clock is released
    by slave.  */
while (((GPIO_PADAT & 0x0200) ? 1 : 0) == 0){;}
      
delay(100);
    
    PADAT_init;
SDA_high;
status = 0x81; /* Set bus idle. */
return(status);
}

/********************************************************************/

void delay(int value)
{
int clk_count = 0;
while (clk_count < value)
{clk_count++;}
}

/********************************************************************/

 

第二个例子

函数定义：

gpio_iic.h:

#ifndef __IIC_GPIO__
#define __IIC_GPIO__
void delay();
/*
设置scl引脚电平，0低电平，1高电平，其他值无效，返回值一直为0，留着它用。
*/
int set_scl( int value );

/*
得到scl引脚电平，0低电平，1高电平，必须是这两个值，其他函数需要调用。
*/
int get_scl();

/*
设置sda引脚电平，0低电平，1高电平，其他值无效，返回值一直为0，留着它用。
*/
int set_sda( int value );

/*
得到sda引脚电平，0低电平，1高电平，必须是这两个值，其他函数需要调用。
*/
int get_sda();

/*
重新发送iic start位，这个是在传送数据过程中使用。
*/
void iic_restart();

/*
发送iic start位，这里假设总线空闲，此时SDL与SCL都为高电平。
*/
void iic_start();

/*
发送stop位，这里假设scl此时为低电平。
*/
void iic_stop();

/*
发送一个bit0，这里假设scl此时为低电平,sda电平不定。
*/
void send_bit0();

/*
发送一个bit 1,这里假设scl此时为低电平,sda电平不定。
 */
void send_bit1();

/*
接收一个bit位，返回值只能是0或1。
 */
int receive_bit();

/*
发送ACK，实际上是发送一个bit0.
*/
void send_ack();

/*
接收ACK。
*/
int receive_ack();

/*
接收一个字节。
*/
char receive_byte();

/*
接收一个buf,返回值总是为0，它不能保证从器件一定能收到ACK，也不能保证从器件正在工作。
*/
int receive_buf( char *buf, int buf_size );

/*
发送一个字节，返回ACK的值，发送时，没有收到ACK会重试n次，这是常。
 */
int send_byte( char data_byte );

/*
发送一个buf,返回值是成功发送，收到ACK的字节数量。
*/
int send_buf( char *buf, int buf_size );

#endif

gpio_iic.c:

#include "gpio_iic.h"
//#define __80C52__
#define __MINI2440__
#ifdef __MINI2440__
#include <linux/gpio.h>
#include <linux/delay.h>
#include <mach/regs-gpio.h>
#endif

#ifdef __80C52__
#include <reg52.h>
sbit SCL  = P1^0;
sbit SDA    = P1^1;
#endif

void delay()
{
#ifdef __MINI2440__
     udelay(1);
#endif
#ifdef __80C52__
     int i = 0;
     for( i = 0; i < 10000; i ++ );
#endif
}
/*
设置scl引脚电平，0低电平，1高电平，其他值无效，返回值一直为0，留着它用。
*/
int set_scl( int value )
{

#ifdef __MINI2440__
//    s3c2410_gpio_cfgpin(S3C2410_GPE(15), S3C2410_GPE15_IICSDA);
//     s3c2410_gpio_cfgpin(S3C2410_GPE(14), S3C2410_GPE14_IICSCL);
     s3c2410_gpio_cfgpin(S3C2410_GPE(14), S3C2410_GPIO_OUTPUT);
     switch( value )
     {
     case 0:
      s3c2410_gpio_setpin(S3C2410_GPE(14), 0); // IICSCL
      break;
     case 1:
      s3c2410_gpio_setpin(S3C2410_GPE(14), 1); // IICSCL
      break;
     default:
      break;
     }
#endif

#ifdef __80C52__
     if ( 0 == value )
      SCL = 0;
     else if ( 1 == value )
      SCL = 1;
#endif
     return 0;                 
}

/*
得到scl引脚电平，0低电平，1高电平，必须是这两个值，其他函数需要调用。
*/
int get_scl()
{
#ifdef __MINI2440__
     s3c2410_gpio_cfgpin(S3C2410_GPE(14), S3C2410_GPIO_INPUT);
     return s3c2410_gpio_getpin(S3C2410_GPE(14)) > 0 ? 1: 0;
#endif

#ifdef __80C52__
     return SCL;
#endif
}

 

/*
设置sda引脚电平，0低电平，1高电平，其他值无效，返回值一直为0，留着它用。
*/
int set_sda( int value )
{
#ifdef __MINI2440__
     s3c2410_gpio_cfgpin(S3C2410_GPE(15), S3C2410_GPIO_OUTPUT);
     switch( value )
     {
     case 0:
      s3c2410_gpio_setpin(S3C2410_GPE(15), 0); // IICSDA
      break;
     case 1:
      s3c2410_gpio_setpin(S3C2410_GPE(15), 1); // IICSDA
      break;
     default:
      break;
     }
#endif
#ifdef __80C52__
     if ( 0 == value )
      SDA = 0;
     else if ( 1 == value )
      SDA = 1;   
#endif       
     return 0;
}

 

/*
得到sda引脚电平，0低电平，1高电平，必须是这两个值，其他函数需要调用。
*/
int get_sda()
{
#ifdef __MINI2440__
     int sda_pin = 0;
     s3c2410_gpio_cfgpin(S3C2410_GPE(15), S3C2410_GPIO_INPUT);
     sda_pin = s3c2410_gpio_getpin(S3C2410_GPE(15)) > 0 ? 1:0;
     return sda_pin;
#endif
#ifdef __80C52__
     return SDA;
#endif
}

/*
重新发送iic start位，这个是在传送数据过程中使用。
*/
void iic_restart()
{
     set_scl( 0 );
     delay();
     set_sda( 1 );
     delay();
     set_scl( 1 );
     delay();
     set_sda( 0 );
     delay();
     set_scl( 0 );
     delay();
}

/*
发送iic start位，这里假设总线空闲，此时SDL与SCL都为高电平。
*/
void iic_start()
{
     set_sda( 0 );
     delay();
     set_scl( 0 );
     delay();
}

/*
发送stop位，这里假设scl此时为低电平。
*/
void iic_stop()
{
     set_sda( 0 );
     delay();
     set_scl( 1 );
     delay();
     set_sda( 1 );       
     delay();
}

/*
发送一个bit0，这里假设scl此时为低电平,sda电平不定。
*/
void send_bit0()
{
     set_sda( 0 );
     delay();
     set_scl( 1 );
     delay();
     set_scl( 0 );
     delay();
}

/*
发送一个bit 1,这里假设scl此时为低电平,sda电平不定。
 */
void send_bit1()
{
     set_sda( 1 );
     delay();
     set_scl( 1 );
     delay();
     set_scl( 0 );
     delay();
}

/*
接收一个bit位，返回值只能是0或1。
 */
int receive_bit()
{
     int value = -1;

     set_sda( 1 );
     delay();
     set_scl( 0 );
     delay();
     set_scl( 1 );
     delay();
     value = get_sda();
     set_scl( 0 );
     return value;   
}

/*
发送ACK，实际上是发送一个bit0.
*/
void send_ack( )
{
     send_bit0();
}

/*
接收ACK。
*/
int receive_ack()
{
     int ack = 1;
     set_sda( 1 );
     delay();
     set_scl( 1 );
     delay();
     ack = get_sda();       
     delay();
     set_scl( 0 );
     return ack;
}

/*
接收一个字节。
*/
char receive_byte( )
{
     int i = 0;
     int recv_data = 0;
     for ( i = 0; i < 8; i++ )
     {
      recv_data = recv_data | receive_bit();
      if ( 7 == i )
           break;
      recv_data <<= 1;
     }
     send_ack();
     return recv_data;   
}

/*
接收一个buf,返回值总是为0，它不能保证从器件一定能收到ACK，也不能保证从器件正在工作。
*/
int receive_buf( char *buf, int buf_size )
{
     int i = 0;
     for( i = 0; i < buf_size; i ++ )
     {
      buf[i] = receive_byte();
     }
     return buf_size;
}

/*
发送一个字节，返回ACK的值，发送时，没有收到ACK会重试n次，这是常。
 */
int send_byte( char data_byte )
{
     int retry_count = 8;//重试次数。
     int i = 0;
     int ack = 1;       
     char send_data = 0;
     send_data = data_byte;
     do{
      for ( i = 0; i < 8; i ++ )
      {
           if ( 0x80 & send_data )
            send_bit1();
           else
            send_bit0();
           send_data <<= 1;
      }
      ack = receive_ack();
      if ( 0 == ack )
           break;
      send_data = data_byte;
      retry_count --;
     }
     while( retry_count >= 0 );
     return ack;
}

/*
发送一个buf,返回值是成功发送，收到ACK的字节数量。
*/
int send_buf( char *buf, int buf_size )
{
     int i = 0;
     int count = 0;
     for ( i = 0; i < buf_size; i ++ )
     {
      if (0 != send_byte( buf[i] ) )
           break;
      count ++;
     }
     return count;       
}

 

下面是可以用来读写at24c02的测试代码，在mini2440板测试通过,

static void m24c02_send( int addr, char *buf,  int buf_size)
{
     int count = 0;
     int rev = -1;
    iic_start();
    rev = send_byte( 0xa0 );
    rev = send_byte( (addr >> 0) & 0xff );
    count = send_buf( buf, buf_size );
    iic_stop();
 
}

static void m24c02_recv( int addr , char *buf, int buf_size )
{
      iic_start();
    send_byte( 0xa0 );
    send_byte( (addr >> 0) & 0xff );
      iic_restart();
    send_byte( 0xa1 );
    receive_buf( buf, buf_size );
    iic_stop();
}

 

 

（1）基础宏定义

#define GPIO_SCL             S3C2410_GPF3

#define GPIO_SDA             S3C2410_GPF0

#define GPIO_SDA_OUTP   S3C2410_GPF0_OUTP  //设定SDA输出

#define GPIO_SDA_INP      S3C2410_GPF0_INP     //设定SDA输入

#define GPIO_SCL_OUTP   S3C2410_GPF3_OUTP  //设定SCL输出

void I2C_SCL_OUTP( void )

{

      s3c2410_gpio_cfgpin(GPIO_SCL,GPIO_SCL_OUTP);

}

void I2C_SCL_Output(u8 value)

{

      if(value)

      {                                               

            s3c2410_gpio_setpin(GPIO_SCL,value); 

      }

      else

      {

            s3c2410_gpio_setpin(GPIO_SCL,value ); 

      }

}

void I2C_SDA_Mode(u8 v_mode)   //SDA输出方向

{

       if(v_mode)

       {                                               

              s3c2410_gpio_cfgpin(GPIO_SDA, GPIO_SDA_OUTP);  

       }

       else

       {

              s3c2410_gpio_cfgpin(GPIO_SDA, GPIO_SDA_INP);  

       }

}

void I2C_SDA_Output(u8 value)

{

       if(value)

       {                                               

               s3c2410_gpio_setpin(GPIO_SDA,value); 

       }

       else

       {

                s3c2410_gpio_setpin(GPIO_SDA,value ); 

       }

}

u8 I2C_SDA_Read(void)    //SDA读数据

{

       return s3c2410_gpio_getpin(GPIO_SDA); 

}

（2）基础段

void I2C_Init(void)

{

      I2C_SDA_Output(1);

      I2C_SCL_Output(1);      //默认拉高

}

void I2C_Wait(void)

{

      u16 i;

      for(i=0;i<200;i++);

}

void I2C_Start(void)

{

      I2C_SDA_Output(1);

      I2C_SCL_Output(1);

      I2C_Wait();

      I2C_SDA_Output(0);

      I2C_Wait();

      I2C_SCL_Output(0);

}

void I2C_Stop(void)

{

      I2C_SDA_Output(0);

      I2C_Wait();

      I2C_SCL_Output(1);

      I2C_Wait();

      I2C_SDA_Output(1);

}

 

（3）读写单个字节的段

u8 I2C_Send_Byte(u8 bytedata)

{

      u8 i,ack;

      I2C_SDA_Mode(1);  //SDA输出

      I2C_SCL_OUTP();

      for (i = 0; i < 8; i++) 

      {

              if (bytedata & 0x80)

              {

                     I2C_SDA_Output(1);

              }

              else

              {

                    I2C_SDA_Output(0);

              }

              bytedata <<= 1;

            

              I2C_SCL_Output(1);

              udelay(3);

              I2C_SCL_Output(0);

              udelay(1);

       }    

  

        I2C_SDA_Output(1);  //release

        udelay(3);

       

        I2C_SDA_Mode(0);  //设定SDA输入

        I2C_SCL_Output(1);  

        udelay(3);

        ack = I2C_SDA_Read();   //读应答

        I2C_SDA_Mode(1);

        I2C_SCL_Output(0);

        udelay(3);

      

        return ack;  

}

u8 I2C_Receive_Byte(void) 

{

       u8 i;

       u8 bytedata = 0x00;

       u8 temp;

       I2C_SDA_Mode(0);

       for ( i = 0; i < 8; i++)

       {

             I2C_SCL_Output(1);

             udelay(3);

             bytedata <<= 1;

             temp = I2C_SDA_Read();

             printk("reda SDA'value is:%d\n",temp);

             if (temp)

                   bytedata |= 0x01;

             printk("  bytedata is:%x\n",bytedata);

             I2C_SCL_Output(0);

             udelay(1);

       }

       I2C_SDA_Mode(1);

       return bytedata;

}

（4）读写单个字节的I2C应用函数

u8 I2C_Byte_Write(u8 device_ID,u8 address,u8 bytedata)

{  

       u8 ack;

       printk("device_ID is:%x\n",device_ID);

       printk("address is:%x\n",address);

       printk("date is:%x\n",bytedata);

       I2C_Start(); 

       ack=I2C_Send_Byte(device_ID);

       printk("ack is:%d\n",ack);

       if(ack)

             I2C_Stop();

       I2C_Send_Byte(address);

       I2C_Send_Byte(bytedata);

       I2C_Stop();

       I2C_Wait();

       return 0;

}

u8 I2C_Byte_Read(u8 device_ID,u8 address)

{  

       u8 bytedata;

       I2C_Start();

       I2C_Send_Byte(device_ID);

       I2C_Send_Byte(address);

       I2C_Start();

       I2C_Send_Byte(device_ID+1);

       bytedata = I2C_Receive_Byte();  //读单个字节，不需要再发应答

       I2C_Stop();   

       return bytedata;

}