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,I2C规程运用主/从双向通讯。器件发送数据到总线上，则定义为发送器，器件接收据 定义为接收器。主器件和从器件都可以工作于接收和发送状态。 总线必须由主器件（通常 为微控制器）控制，主器件产生串行时钟（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
#include
#include
#endif #ifdef __80C52__
#include
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( 0 );
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( 0 );
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; }
| 
热门文章
更多
分拣机器人的工作原理是什么
APP下载
登录
