I2C协议+实现源码

摘要

参考资料：

【STM32】IIC的基本原理（实例：普通IO口模拟IIC时序读取24C02）
https://blog.csdn.net/qq_38410730/article/details/80312357
STM32下模拟I2C的C语言实现
https://blog.csdn.net/qq_38410730/article/details/80312357
I2C协议小结
https://blog.csdn.net/huangkangying/article/details/73182432

I2C通信协议

简介

• I2C–（IIC，Inter-Integrated Circuit），内部集成电路，两线式串行总线
• 由 SDA 和 SCL 时钟线构成，可发送和接收数据
• 在 CPU 与被控 IC 之间、IC 与 IC 之间进行双向传送
• 通信协议：I2C 协议
• 传输距离：短距离传输
• 同步/异步：同步
• 传输信号：TTL 电平信号
• 通信方式（单/半/全双工）：半双工
• 通信线：两根线，SCL 和 SDA
  • SCL：I2C 是串行同步通信，需要 SCL 线传输同步脉冲信号
  • SDA：用于半双工传输信号，数据/地址/控制信号复用SDA线
• 片选：通过软件地址，发送不同的设备地址，选择与不同的 I2C 设备通信
• I/O接口（I2C 控制器），可能是独立的，也可能和 CPU 集成在一起，如MCU

• IO桥：PC机才有IO桥，单片机没有
• I2C 通信作用：
  • 用于连接各种使用 I2C 通信的设备，这些设备有EEPROM， LCD，AD. RTC (时钟) ，蓝牙、ZigBee、wifi等无线通信模块。
  • 使用 I2C 属于简单通信，使用 I2C 通信的设备也都比较简单
  • 使用 I2C 通信的设备，一般都是直接做在了电路板上。

补充

---

作者：huangkangying
来源：CSDN
原文：https://blog.csdn.net/huangkangying/article/details/73182432
版权声明：本文为博主原创文章，转载请附上博文链接！

• 两线串行协议（SCL, SDA)，主从模式，支持多主控，但在同一时刻只能有一个主控
• 地址组成：7bit 地址数组+1bit读写位， 共8bit。地址范围0~127, 0地址为广播地址。
• 一次发送8bit数据，数据格式为大端模式。
• 速率：标准模式100Kbps, 快速模式400Kbps，高速模式3.4Mbps。
• SCL由master提供，只有master才能同时控制SCL和SDA
• SCL为低电平时才能改变数据，SCL为高电平时，数据有效。
• 起始条件： 当SCL为高电平时，master拉低SDA，总线进入start状态。
• 结束条件： 当SCL为高电平时，master拉高SDA，总线进入stop状态。
• 无论是发送地址还是数据，其后都紧跟着一个ACK/NACK。
• 当master写数据里，ACK和NACK由slave提供。
• 当master读数据里，ACK和NACK由master提供。
• 下面为master写数据示例：ACK：在第9个CLK周期，slave拉低SDA，发送一个ACK
  • NACK: 在第9个CLK周期，slave保持SDA为高，发送一个NACK
  • 一次可以传输多个字节，直到master发送start/stop。
• 如果slave设备来不及处理data，它可以保持SCL为低，强制master进入等待状态。？？？

空闲状态

• 规定空闲状态 SDA 和 SCL 都必须拉高
• SDA保持高电平
• SCL保持高电平

start和stop信号

• 有头有尾还有肚

• 开始信号：SCL 高电平期间，SDA 由高–>低电平

• 停止信号：SCL 高电平期间，SDA 由低–>高电平

• 起始信号：当SCL为高期间， SDA由高到低的跳变；

• 启动信号是一种电平跳变时序信号，而不是一个电平信号。

• 停止信号：当SCL为高期间, SDA由低到高的跳变；

• 停止信号也是一种电平跳变时序信号，而不是一个电平信号。

应答信号

• 应答信号 ACK
• 发送器每发送一个字节（8bit），就在时钟脉冲 9 期间释放数据线，由接收器反馈一个应答信号。
• 应答信号为低电平时，规定为有效应答位（ACK），表示接收器已经成功地接收了该字节；
• 应答信号为高电平时，规定为非应答位（NACK），一般表示接收器该字节接收失败
• 反馈有效应答位的要求：接收器在第 9 个时钟脉冲之前的低电平期间将 SDA 线拉低，并且确保在该时钟（第 9 个时钟脉冲）的高电平期间为稳定的低电平。
• 如果接收机是主机，则它在接收到最后一个字节后，发送一个 NACK 信号，一通知被控发送器（从机）结束数据发送，并释放 SDA 线，以便主控接收器发送一个停止信号。

数据有效性规定

• 犹如物流：

  • 快递车（SCL）运送期间（SCL高电平），货物（数据）在车内（SDA保持）保持不动
  • 当快递车（SCL）停下（SCL低电平），才允许快递小哥（器件）派送（SDA可变）货物（传送数据）

• SCL高电平，SDA须保持

• SCL低电平，SDA可变

• 为了与开始和停止信号区别

• 即：数据在SCL的上升沿到来之前就需准备好。并在下降沿到来之前必须稳定。

数据传输

• 在 I2C 总线上传送的每一位数据都有一个时钟脉冲相对应(或同步控制) ，
• 即在SCL串行时钟的配合下，在 SDA上逐位地串行传送每一位数据。数据位的传输是边沿触发。

延时

I2C协议的实现源码

硬件说明

• 采用了正点原子的 STM32F103RCT6 开发板
• 实验目的：对 24C02 进行操作

头文件

#ifndef __IIC_H
#define __IIC_H
#include "sys.h"  //实现了IO口的位带操作
   	   		   
//IO方向设置，操作寄存器
//简单点：就是把SDA的PC11口设为输入或输出
#define SDA_IN()  {GPIOC->CRH&=0XFFFF0FFF;GPIOC->CRH|=8<<12;}
#define SDA_OUT() {GPIOC->CRH&=0XFFFF0FFF;GPIOC->CRH|=3<<12;}

//IO操作函数，IO口位带操作
//简单点：就是可以对SCL的PC12和SDA的PC11进行赋值操作
#define IIC_SCL    PCout(12) //SCL
#define IIC_SDA    PCout(11) //SDA	 
#define READ_SDA   PCin(11)  //输入SDA 

//IIC所有操作函数
void IIC_Init(void);                //初始化IIC的IO口				 
void IIC_Start(void);				//发送IIC开始信号
void IIC_Stop(void);	  			//发送IIC停止信号
void IIC_Send_Byte(u8 txd);			//IIC发送一个字节
u8 IIC_Read_Byte(unsigned char ack);//IIC读取一个字节
u8 IIC_Wait_Ack(void); 				//IIC等待ACK信号
void IIC_Ack(void);					//IIC发送ACK信号
void IIC_NAck(void);				//IIC不发送ACK信号

void IIC_Write_One_Byte(u8 daddr,u8 addr,u8 data);
u8 IIC_Read_One_Byte(u8 daddr,u8 addr);	  
#endif

sys.h

#ifndef __SYS_H
#define __SYS_H	
#include "stm32f10x.h"

//0,不支持ucos
//1,支持ucos
#define SYSTEM_SUPPORT_OS		0		//定义系统文件夹是否支持UCOS
																	    
//位带操作,实现51类似的GPIO控制功能
//具体实现思想,参考<>第五章(87页~92页).
//IO口操作宏定义
#define BITBAND(addr, bitnum) ((addr & 0xF0000000)+0x2000000+((addr &0xFFFFF)<<5)+(bitnum<<2)) 
#define MEM_ADDR(addr)  *((volatile unsigned long  *)(addr)) 
#define BIT_ADDR(addr, bitnum)   MEM_ADDR(BITBAND(addr, bitnum)) 
//IO口地址映射
#define GPIOA_ODR_Addr    (GPIOA_BASE+12) //0x4001080C 
#define GPIOB_ODR_Addr    (GPIOB_BASE+12) //0x40010C0C 
#define GPIOC_ODR_Addr    (GPIOC_BASE+12) //0x4001100C 
#define GPIOD_ODR_Addr    (GPIOD_BASE+12) //0x4001140C 
#define GPIOE_ODR_Addr    (GPIOE_BASE+12) //0x4001180C 
#define GPIOF_ODR_Addr    (GPIOF_BASE+12) //0x40011A0C    
#define GPIOG_ODR_Addr    (GPIOG_BASE+12) //0x40011E0C    

#define GPIOA_IDR_Addr    (GPIOA_BASE+8) //0x40010808 
#define GPIOB_IDR_Addr    (GPIOB_BASE+8) //0x40010C08 
#define GPIOC_IDR_Addr    (GPIOC_BASE+8) //0x40011008 
#define GPIOD_IDR_Addr    (GPIOD_BASE+8) //0x40011408 
#define GPIOE_IDR_Addr    (GPIOE_BASE+8) //0x40011808 
#define GPIOF_IDR_Addr    (GPIOF_BASE+8) //0x40011A08 
#define GPIOG_IDR_Addr    (GPIOG_BASE+8) //0x40011E08 
 
//IO口操作,只对单一的IO口!
//确保n的值小于16!
#define PAout(n)   BIT_ADDR(GPIOA_ODR_Addr,n)  //输出 
#define PAin(n)    BIT_ADDR(GPIOA_IDR_Addr,n)  //输入 

#define PBout(n)   BIT_ADDR(GPIOB_ODR_Addr,n)  //输出 
#define PBin(n)    BIT_ADDR(GPIOB_IDR_Addr,n)  //输入 

#define PCout(n)   BIT_ADDR(GPIOC_ODR_Addr,n)  //输出 
#define PCin(n)    BIT_ADDR(GPIOC_IDR_Addr,n)  //输入 

#define PDout(n)   BIT_ADDR(GPIOD_ODR_Addr,n)  //输出 
#define PDin(n)    BIT_ADDR(GPIOD_IDR_Addr,n)  //输入 

#define PEout(n)   BIT_ADDR(GPIOE_ODR_Addr,n)  //输出 
#define PEin(n)    BIT_ADDR(GPIOE_IDR_Addr,n)  //输入

#define PFout(n)   BIT_ADDR(GPIOF_ODR_Addr,n)  //输出 
#define PFin(n)    BIT_ADDR(GPIOF_IDR_Addr,n)  //输入

#define PGout(n)   BIT_ADDR(GPIOG_ODR_Addr,n)  //输出 
#define PGin(n)    BIT_ADDR(GPIOG_IDR_Addr,n)  //输入

//以下为汇编函数
void WFI_SET(void);		//执行WFI指令
void INTX_DISABLE(void);//关闭所有中断
void INTX_ENABLE(void);	//开启所有中断
void MSR_MSP(u32 addr);	//设置堆栈地址

#endif

主函数

• 参考24C02的时序图

初始化I2C

• 主机初始化，配置引脚，开启相应的时钟

//初始化IIC
void IIC_Init(void)
{					     
	GPIO_InitTypeDef  GPIO_InitStructure;
   
	//RCC->APB2ENR|=1<<4;		//先使能外设IO PORTC时钟 
	RCC_APB2PeriphClockCmd(	RCC_APB2Periph_GPIOC, ENABLE );	 //使能外设IO PORTC时钟 
	   
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_11; //同时设置PC11和PC12引脚
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ;        //推挽输出
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOC, &GPIO_InitStructure);
 
    //空闲状态，主机的SCL和SDA都要拉高
	IIC_SCL=1;
	IIC_SDA=1;

}

产生开始和停止信号

• 当然这是主机产生

• 思考：

  • 只设置了SDA为输出，SCL不管吗？？？可能是SCL始终是输出，是主机产生的时钟脉冲。而SDA可能是输出也可能是输入。所以需要确保它的状态。
  • 我觉得 I2C 停止信号应该这样写：？？？

  void IIC_Stop(void)
  {
  	SDA_OUT();  	//设置SDA线为输出
  	IIC_SCL=1; 		//SCL置高
  	IIC_SDA=0;		
   	delay_us(4);	//保持一段时间
      
      //发送I2C总线结束信号
  	IIC_SDA=1;		//STOP:when CLK is high, DATA change form low to high
  	delay_us(4);	//保持一段时间						   	
  }
  

//产生IIC起始信号
void IIC_Start(void)
{
	SDA_OUT();     	//设置SDA线为输出，只设置了SDA为输出，SCL不管吗？？？
	IIC_SDA=1;	  	//SDA置高  
	IIC_SCL=1;		//SCL置高
	delay_us(4);    //让数据保持一段时间（电平嘛）传输的是TTL电平信号
    
    //SDA由高-->低跳变，SCL保持高电平
 	IIC_SDA=0;		//START:when CLK is high,DATA change form high to low 
	delay_us(4);    //保持一段时间
    
	IIC_SCL=0;		//钳住I2C总线，准备发送或接收数据 
}

//产生IIC停止信号
void IIC_Stop(void)
{
	SDA_OUT();  	//设置SDA线为输出
	IIC_SCL=0;		//SCL置低
	IIC_SDA=0;		//SDA置低
 	delay_us(4);	//保持一段时间
    
	IIC_SCL=1; 		//SCL置高
    
    //发送I2C总线结束信号
	IIC_SDA=1;		//STOP:when CLK is high, DATA change form low to high
	delay_us(4);	//保持一段时间						   	
}

等待应答信号

• 当然是发送方等待（发送方可能是主机也可能是从机）

//等待应答信号到来
//返回值：1，接收应答失败
//       0，接收应答成功
u8 IIC_Wait_Ack(void)
{
	u8 ucErrTime=0;
	SDA_IN();      			//SDA设置为输入  
    
    //等待应答的时候把SDA和SCL线都给拉高  ？？？
	IIC_SDA=1; delay_us(1);
	IIC_SCL=1; delay_us(1);	
    
	while(READ_SDA)   //READ_SDA就是PC11（SDA）引脚，当输入为低时就是（ACK）信号
	{
        //等待接收方应答
		ucErrTime++;
		if(ucErrTime>250)  	//超时传送失败
		{
			IIC_Stop();		//传送失败发送停止信号
			return 1;
		}
	}
    
	IIC_SCL=0;		//主机时钟输出0，为下一步做准备 	   
	return 0;  
} 

产生或不产生应答

• 这里应该是针对主机而言的，此时主机是接收方？？？

• 思考：

  • SCL先置低，再置高，再置低，这恰恰就是第 9 个时钟脉冲
  • 而在 SCL 为高电平这段时间，SDA 要保持低电平或高电平
  • 不可以这样写（违背了在SCL高电平期间，SDA要保持稳定）：

  void IIC_Ack(void)
  {
  	IIC_SCL=0;    	//SCL置低
  	SDA_OUT();		//SDA设为输出
  	
  	IIC_SCL=1;		//SCL置高
  	delay_us(2);	//保持一段时间
      
      IIC_SDA=0;		//SDA置低，表示应答（ACK）
  	delay_us(2);	//保持一段时间
      
  	IIC_SCL=0;		//SCL置低
  }
  

//第 9 个时钟脉冲问题
//产生ACK应答
void IIC_Ack(void)
{
	IIC_SCL=0;    	//SCL置低
	SDA_OUT();		//SDA设为输出
	IIC_SDA=0;		//SDA置低，表示应答（ACK）
	delay_us(2);	//保持一段时间
	IIC_SCL=1;		//SCL置高
	delay_us(2);	//保持一段时间
	IIC_SCL=0;		//SCL置低
}
//不产生ACK应答		    
void IIC_NAck(void)
{
	IIC_SCL=0;   	//SCL置低
	SDA_OUT();   	//SDA设为输出
	IIC_SDA=1;   	//SDA置高，表示非应答（NACK）
	delay_us(2); 	//保持一段时间
	IIC_SCL=1;   	//SCL置高
	delay_us(2); 	//保持一段时间
	IIC_SCL=0;   	//SCL置低
}				

I2C写操作

• 无论读写均由主机触发开始条件和结束条件

• 如果从机接了主机的中断线，也只是提醒主机而已，任然需要主机触发开始条件

• 思考：

  • 拉低时钟开始数据传输，规定SCL低电平，SDA才允许变化，否则就是开始和停止信号了
  • 对TEA5767这三个延时都是必须的？？？为啥
  • SCL同样的先置低，再置高，最后置低，恰好也是一个时钟脉冲，并且只有在SCL低电平期间，SDA才传送数据：验证了这句话（在 I2C 总线上传送的每一位数据都有一个时钟脉冲相对应（或同步控制） ，即在SCL串行时钟的配合下，在 SDA上逐位地串行传送每一位数据。数据位的传输是边沿触发。
  • 如果不能进行位操作，可用如下代码：

 
for(t=0;t<8;t++)
      {   
          //规定从高位开始传输； 
      	if((txd & 0x80) >> 7)//判断最高位是0还是1，然后写入PC11，写入总线
          {
              PC |= （1<<11);   //PC11输出1  
          }
      	else
          {
          	PC &= ~(1<<11);  //PC11输出0
      	}
          txd <<= 1; 	  		//将数据（地址）左移一位
  		delay_us(2);   		//对TEA5767这三个延时都是必须的，为啥？？？
  		IIC_SCL=1;			
  		delay_us(2); 
  		IIC_SCL=0;			
  		delay_us(2);
      }	 

//IIC发送一个字节
//返回从机有无应答，利用上述的 IIC_Wait_Ack 等待应答函数
//1，有应答
//0，无应答			  
void IIC_Send_Byte(u8 txd)
{                        
    u8 t;   
	SDA_OUT(); 					//SDA设为输出
    
    //拉低时钟开始数据传输，规定SCL低电平，SDA才允许变化，否则就是开始和停止信号了
    IIC_SCL=0;
    
    for(t=0;t<8;t++)
    {   
        //规定从高位开始传输；          
        IIC_SDA = (txd & 0x80) >> 7;
        txd <<= 1; 	  
		delay_us(2);   			//对TEA5767这三个延时都是必须的，为啥？？？
		IIC_SCL=1;				//SCL置高
		delay_us(2); 
		IIC_SCL=0;				//SCL置低
		delay_us(2);
    }	 
} 

I2C读操作

• 无论读写均由主机触发开始条件和结束条件
• 思考：
  • SCL先置低，然后置高，再置低，也是一个脉冲
  • 然后在SCL为高电平期间读取SDA的数据，因为SCL高电平期间，SDA数据保持稳定

//读1个字节，ACK=1时，发送ACK，ACK=0，发送NACK   
u8 IIC_Read_Byte(unsigned char ack)
{
	unsigned char i,receive=0;
	SDA_IN();			//SDA设置为输入
    for(i=0; i<8; i++ )
	{
        //从最高位开始发，自然从最高位开始接收
        IIC_SCL=0; 		//SCL置低
        delay_us(2);	//保持
		IIC_SCL=1;		//SCL置高
        
        receive <<= 1;  //等同于乘以2  
        
        //先移位再加，不可先加在移位
        
        //主机通过判断P11输入引脚的电平高低来接收数据
        //高电平就加一，低电平就什么都不做
        if(READ_SDA)receive++;   
		delay_us(1); 
    }					 
    if (ack)
       	IIC_Ack();		//发送ACK  
    else
        IIC_NAck();		//发送nACK
    
    return receive;
}

对24C02操作

• EEPROM（24C02），2就是 2K ，总容量是256（2K/8）个字节
• 详细信息请参考 AT2402 芯片手册

24C02的时序图

• 必须知会24C02的时序图，不同硬件有不同的时序图
• 写时序：

• 读时序：

头文件

#ifndef __24CXX_H
#define __24CXX_H
#include "myiic.h"  

//Mini STM32开发板
//24CXX驱动函数(适合24C01~24C16,24C32~256未经过测试!有待验证!)
//2010/6/10
//V1.2

#define AT24C01		127
#define AT24C02		255
#define AT24C04		511
#define AT24C08		1023
#define AT24C16		2047
#define AT24C32		4095
#define AT24C64	    8191
#define AT24C128	16383
#define AT24C256	32767  
//Mini STM32开发板使用的是24c02，所以定义EE_TYPE为AT24C02
#define EE_TYPE AT24C02
					  
u8 AT24CXX_ReadOneByte(u16 ReadAddr);							//指定地址读取一个字节
void AT24CXX_WriteOneByte(u16 WriteAddr,u8 DataToWrite);		//指定地址写入一个字节
void AT24CXX_WriteLenByte(u16 WriteAddr,u32 DataToWrite,u8 Len);//指定地址开始写入指定长度的数据
u32 AT24CXX_ReadLenByte(u16 ReadAddr,u8 Len);					//指定地址开始读取指定长度数据
void AT24CXX_Write(u16 WriteAddr,u8 *pBuffer,u16 NumToWrite);	//从指定地址开始写入指定长度的数据
void AT24CXX_Read(u16 ReadAddr,u8 *pBuffer,u16 NumToRead);   	//从指定地址开始读出指定长度的数据

u8 AT24CXX_Check(void);  //检查器件
void AT24CXX_Init(void); //初始化IIC
#endif

初始化IIC接口

//初始化IIC接口
void AT24CXX_Init(void)
{
	IIC_Init();
}

写数据(一个字节)

//在AT24CXX指定地址写入一个数据
//WriteAddr  :写入数据的目的地址    
//DataToWrite:要写入的数据
void AT24CXX_WriteOneByte(u16 WriteAddr,u8 DataToWrite)
{				   	  	    																 
    IIC_Start();  
	if(EE_TYPE>AT24C16)
	{
		IIC_Send_Byte(0XA0);	    //发送写命令
		IIC_Wait_Ack();
		IIC_Send_Byte(WriteAddr>>8);//发送高地址
 	}else
	{
		IIC_Send_Byte(0XA0+((WriteAddr/256)<<1));   //发送器件地址0XA0,写数据 
	}	 
	IIC_Wait_Ack();	   
    IIC_Send_Byte(WriteAddr%256);   //发送低地址
	IIC_Wait_Ack(); 	 										  		   
	IIC_Send_Byte(DataToWrite);     //发送字节							   
	IIC_Wait_Ack();  		    	   
    IIC_Stop();//产生一个停止条件 
	delay_ms(10);	 
}

写数据（长度为Len）

//在AT24CXX里面的指定地址开始写入长度为Len的数据
//该函数用于写入16bit或者32bit的数据.
//WriteAddr  :开始写入的地址  
//DataToWrite:数据数组首地址
//Len        :要写入数据的长度2,4
void AT24CXX_WriteLenByte(u16 WriteAddr,u32 DataToWrite,u8 Len)
{  	
	u8 t;
	for(t=0;t<Len;t++)
	{
		AT24CXX_WriteOneByte(WriteAddr+t,(DataToWrite>>(8*t))&0xff);
	}												    
}

写数据（指定长度）

//在AT24CXX里面的指定地址开始写入指定个数的数据
//WriteAddr :开始写入的地址 对24c02为0~255
//pBuffer   :数据数组首地址
//NumToWrite:要写入数据的个数
void AT24CXX_Write(u16 WriteAddr,u8 *pBuffer,u16 NumToWrite)
{
	while(NumToWrite--)
	{
		AT24CXX_WriteOneByte(WriteAddr,*pBuffer);
		WriteAddr++;
		pBuffer++;
	}
}

读数据(一个字节)

//在AT24CXX指定地址读出一个数据
//ReadAddr:开始读数的地址  
//返回值  :读到的数据
u8 AT24CXX_ReadOneByte(u16 ReadAddr)
{				  
	u8 temp=0;		  	    																 
    IIC_Start();  
	if(EE_TYPE>AT24C16)
	{
		IIC_Send_Byte(0XA0);	   //发送写命令
		IIC_Wait_Ack();
		IIC_Send_Byte(ReadAddr>>8);//发送高地址
		IIC_Wait_Ack();		 
	}else IIC_Send_Byte(0XA0+((ReadAddr/256)<<1));   //发送器件地址0XA0,写数据 	 

	IIC_Wait_Ack(); 
    IIC_Send_Byte(ReadAddr%256);   //发送低地址
	IIC_Wait_Ack();	    
	IIC_Start();  	 	   
	IIC_Send_Byte(0XA1);           //进入接收模式			   
	IIC_Wait_Ack();	 
    temp=IIC_Read_Byte(0);		   
    IIC_Stop();//产生一个停止条件	    
	return temp;
}

读数据（长度为Len）

//在AT24CXX里面的指定地址开始读出长度为Len的数据
//该函数用于读出16bit或者32bit的数据.
//ReadAddr   :开始读出的地址 
//返回值     :数据
//Len        :要读出数据的长度2,4
u32 AT24CXX_ReadLenByte(u16 ReadAddr,u8 Len)
{  	
	u8 t;
	u32 temp=0;
	for(t=0;t<Len;t++)
	{
		temp<<=8;
		temp+=AT24CXX_ReadOneByte(ReadAddr+Len-t-1); 	 				   
	}
	return temp;												    
}

读数据（指定长度）

//在AT24CXX里面的指定地址开始读出指定个数的数据
//ReadAddr :开始读出的地址 对24c02为0~255
//pBuffer  :数据数组首地址
//NumToRead:要读出数据的个数
void AT24CXX_Read(u16 ReadAddr,u8 *pBuffer,u16 NumToRead)
{
	while(NumToRead)
	{
		*pBuffer++=AT24CXX_ReadOneByte(ReadAddr++);	
		NumToRead--;
	}
}  

检查AT24CXX是否正常

//检查AT24CXX是否正常
//这里用了24XX的最后一个地址(255)来存储标志字.
//如果用其他24C系列,这个地址要修改
//返回1:检测失败
//返回0:检测成功
u8 AT24CXX_Check(void)
{
	u8 temp;
	temp=AT24CXX_ReadOneByte(255);//避免每次开机都写AT24CXX			   
	if(temp==0X55)return 0;		   
	else//排除第一次初始化的情况
	{
		AT24CXX_WriteOneByte(255,0X55);
	    temp=AT24CXX_ReadOneByte(255);	  
		if(temp==0X55)return 0;
	}
	return 1;											  
}

主函数

#include "led.h"
#include "delay.h"
#include "sys.h"
#include "usart.h"
#include "lcd.h"
#include "key.h"  
#include "24cxx.h" 
#include "myiic.h"


//要写入到24c02的字符串数组
const u8 TEXT_Buffer[]={"MiniSTM32 IIC TEST"};

#define SIZE sizeof(TEXT_Buffer)	//获取字节个数	

 int main(void)
 { 
	u8 key;
	u16 i=0;
	u8 datatemp[SIZE];
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置中断优先级分组2
	delay_init();	    	//延时函数初始化	  
	uart_init(9600);	 	//串口初始化为9600
	LED_Init();		  		//初始化与LED连接的硬件接口
 	LCD_Init();	
	KEY_Init();				//按键初始化
     
	AT24CXX_Init();			//IIC初始化 

    //用LCD显示屏显示出来 
 	POINT_COLOR=RED;//设置字体为红色 
	LCD_ShowString(60,50,200,16,16,"Mini STM32");	
	LCD_ShowString(60,70,200,16,16,"IIC TEST");	
	LCD_ShowString(60,90,200,16,16,"ATOM@ALIENTEK");
	LCD_ShowString(60,110,200,16,16,"2014/3/9");	
	LCD_ShowString(60,130,200,16,16,"WK_UP:Write  KEY0:Read");	//显示提示信息
     
 	while(AT24CXX_Check())//检测不到24c02
	{
		LCD_ShowString(60,150,200,16,16,"24C02 Check Failed!");
		delay_ms(500);
		LCD_ShowString(60,150,200,16,16,"Please Check!      ");
		delay_ms(500);
		LED0=!LED0;//DS0闪烁
	}
	LCD_ShowString(60,150,200,16,16,"24C02 Ready!");    
 	POINT_COLOR=BLUE;//设置字体为蓝色
     
	while(1)
	{
		key=KEY_Scan(0);
		if(key==WKUP_PRES)//WK_UP 按下,写入24C02
		{
			LCD_Fill(0,170,239,319,WHITE);//清除半屏    
 			LCD_ShowString(60,170,200,16,16,"Start Write 24C02....");
			AT24CXX_Write(0,(u8*)TEXT_Buffer,SIZE);
			LCD_ShowString(60,170,200,16,16,"24C02 Write Finished!");//提示传送完成
		}
		if(key==KEY0_PRES)//KEY0 按下,读取字符串并显示
		{
 			LCD_ShowString(60,170,200,16,16,"Start Read 24C02.... ");
			AT24CXX_Read(0,datatemp,SIZE);
			LCD_ShowString(60,170,200,16,16,"The Data Readed Is:  ");//提示传送完成
			LCD_ShowString(60,190,200,16,16,datatemp);//显示读到的字符串
		}
		i++;
		delay_ms(10);
		if(i==20)
		{
			LED0=!LED0;//提示系统正在运行	
			i=0;
		}		   
	}
}

实验结果截图

• 实验结果视频地址：

  视频地址：http://t.cn/EoZQHMm?m=4368576113101384&u=5955627170