C语言使用面向对象实现IIC驱动

已于 2024-06-23 17:15:31 修改
阅读量1.5k 收藏 18
点赞数 7
分类专栏： 嵌入式开发 文章标签： 面向对象编程 封装 继承 c语言 驱动程序
于 2021-02-04 13:27:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42700740/article/details/113624909
版权

文章目录

一.简述

  使用面向对象的编程思想封装IIC驱动，将IIC的属性和操作封装成一个库，在需要创建一个IIC设备时只需要实例化一个IIC对象即可，本文是基于STM32和HAL库做进一步封装的。底层驱动方法不重要，封装的思想很重要。
  在完成对IIC驱动的封装之后借助继承特性实现AT24C64存储器的驱动开发，仍使用面向对象的思想封装AT24C64驱动。

二.IIC驱动面向对象封装

iic.h头文件主要是类模板的定义，具体如下：

//定义IIC类
typedef struct IIC_Type
{
	  //属性
	  GPIO_TypeDef  *GPIOx_SCL; 	//GPIO_SCL所属的GPIO组(如：GPIOA)
	  GPIO_TypeDef  *GPIOx_SDA; 	//GPIO_SDA所属的GPIO组(如：GPIOA)
	  uint32_t GPIO_SCL;    	//GPIO_SCL的IO引脚(如：GPIO_PIN_0)
	  uint32_t GPIO_SDA;    	//GPIO_SDA的IO引脚(如：GPIO_PIN_0)
	  //操作
	  void (*IIC_Init)(const struct IIC_Type*);       	//IIC_Init
	  void (*IIC_Start)(const struct IIC_Type*);      	//IIC_Start
	  void (*IIC_Stop)(const struct IIC_Type*);       	//IIC_Stop
	  uint8_t (*IIC_Wait_Ack)(const struct IIC_Type*);   	//IIC_Wait_ack,返回wait失败或是成功
	  void (*IIC_Ack)(const struct IIC_Type*);      	//IIC_Ack,IIC发送ACK信号
	  void (*IIC_NAck)(const struct IIC_Type*);    		 //IIC_NAck,IIC发送NACK信号
	  void (*IIC_Send_Byte)(const struct IIC_Type*,uint8_t);       //IIC_Send_Byte，入口参数为要发送的字节
	  uint8_t (*IIC_Read_Byte)(const struct IIC_Type*,uint8_t);     //IIC_Send_Byte，入口参数为是否要发送ACK信号
	  void (*delay_us)(uint32_t);              //us延时
}IIC_TypeDef;

iic.c源文件主要是类模板具体操作函数的实现，具体如下：

//设置SDA为输入模式
static void SDA_IN(const struct IIC_Type* IIC_Type_t)
{
	 uint8_t io_num = 0;  //定义io Num号
	 switch(IIC_Type_t->GPIO_SDA)
	 {
	  case GPIO_PIN_0:
	   io_num = 0;
	  break;
	  case GPIO_PIN_1:
	   io_num = 1;
	  break; 
	  case GPIO_PIN_2:
	   io_num = 2;
	  break; 
	  case GPIO_PIN_3:
	   io_num = 3;
	  break;
	  case GPIO_PIN_4:
	   io_num = 4;
	  break; 
	   case GPIO_PIN_5:
	   io_num = 5;
	  break; 
	  case GPIO_PIN_6:
	   io_num = 6;
	  break; 
	  case GPIO_PIN_7:
	   io_num = 7;
	  break;
	  case GPIO_PIN_8:
	   io_num = 8;
	  break; 
	  case GPIO_PIN_9:
	   io_num = 9;
	  break;
	  case GPIO_PIN_10:
	   io_num = 10;
	  break;
	  case GPIO_PIN_11:
	   io_num = 11;
	  break; 
	  case GPIO_PIN_12:
	   io_num = 12;
	  break;
	  case GPIO_PIN_13:
	   io_num = 13;
	  break;
	  case GPIO_PIN_14:
	   io_num = 14;
	  break; 
	  case GPIO_PIN_15:
	   io_num = 15;
	  break;
	 }
	 IIC_Type_t->GPIOx_SDA->MODER&=~(3<<(io_num*2)); //将GPIOx_SDA->GPIO_SDA清零
	 IIC_Type_t->GPIOx_SDA->MODER|=0<<(io_num*2);   //将GPIOx_SDA->GPIO_SDA设置为输入模式
}

//设置SDA为输出模式
static void SDA_OUT(const struct IIC_Type* IIC_Type_t)
{
	 uint8_t io_num = 0;  //定义io Num号
	 switch(IIC_Type_t->GPIO_SDA)
	 {
	  case GPIO_PIN_0:
	   io_num = 0;
	  break;
	  case GPIO_PIN_1:
	   io_num = 1;
	  break; 
	  case GPIO_PIN_2:
	   io_num = 2;
	  break; 
	  case GPIO_PIN_3:
	   io_num = 3;
	  break;
	  case GPIO_PIN_4:
	   io_num = 4;
	  break; 
	   case GPIO_PIN_5:
	   io_num = 5;
	  break; 
	  case GPIO_PIN_6:
	   io_num = 6;
	  break; 
	  case GPIO_PIN_7:
	   io_num = 7;
	  break;
	  case GPIO_PIN_8:
	   io_num = 8;
	  break; 
	  case GPIO_PIN_9:
	   io_num = 9;
	  break;
	  case GPIO_PIN_10:
	   io_num = 10;
	  break;
	  case GPIO_PIN_11:
	   io_num = 11;
	  break; 
	  case GPIO_PIN_12:
	   io_num = 12;
	  break;
	  case GPIO_PIN_13:
	   io_num = 13;
	  break;
	  case GPIO_PIN_14:
	   io_num = 14;
	  break; 
	  case GPIO_PIN_15:
	   io_num = 15;
	  break;
	 }
	 IIC_Type_t->GPIOx_SDA->MODER&=~(3<<(io_num*2)); //将GPIOx_SDA->GPIO_SDA清零
	 IIC_Type_t->GPIOx_SDA->MODER|=1<<(io_num*2);   //将GPIOx_SDA->GPIO_SDA设置为输出模式
}
//设置SCL电平
static void IIC_SCL(const struct IIC_Type* IIC_Type_t,int n)
{
	 if(n == 1)
	 {
	  	HAL_GPIO_WritePin(IIC_Type_t->GPIOx_SCL,IIC_Type_t->GPIO_SCL,GPIO_PIN_SET);     //设置SCL为高电平
	 }
	 else{
	  	HAL_GPIO_WritePin(IIC_Type_t->GPIOx_SCL,IIC_Type_t->GPIO_SCL,GPIO_PIN_RESET);     //设置SCL为低电平
	 }
}
//设置SDA电平
static void IIC_SDA(const struct IIC_Type* IIC_Type_t,int n)
{
	 if(n == 1)
	 {
	  	HAL_GPIO_WritePin(IIC_Type_t->GPIOx_SDA,IIC_Type_t->GPIO_SDA,GPIO_PIN_SET);     //设置SDA为高电平
	 }
	 else{
	  	HAL_GPIO_WritePin(IIC_Type_t->GPIOx_SDA,IIC_Type_t->GPIO_SDA,GPIO_PIN_RESET);     //设置SDA为低电平
	 }
}
//读取SDA电平
static uint8_t READ_SDA(const struct IIC_Type* IIC_Type_t)
{
	 return HAL_GPIO_ReadPin(IIC_Type_t->GPIOx_SDA,IIC_Type_t->GPIO_SDA);  //读取SDA电平
}
//IIC初始化
static void IIC_Init_t(const struct IIC_Type* IIC_Type_t)
{
   	  GPIO_InitTypeDef GPIO_Initure;
    
	  //根据GPIO组初始化GPIO时钟
	  if(IIC_Type_t->GPIOx_SCL == GPIOA || IIC_Type_t->GPIOx_SDA == GPIOA)
	  {
	   	__HAL_RCC_GPIOA_CLK_ENABLE();   //使能GPIOA时钟
	  }
	  if(IIC_Type_t->GPIOx_SCL == GPIOB || IIC_Type_t->GPIOx_SDA == GPIOB)
	  {
	   	__HAL_RCC_GPIOB_CLK_ENABLE();   //使能GPIOB时钟
	  }
	  if(IIC_Type_t->GPIOx_SCL == GPIOC || IIC_Type_t->GPIOx_SDA == GPIOC)
	  {
	   	__HAL_RCC_GPIOC_CLK_ENABLE();   //使能GPIOC时钟
	  }
	  if(IIC_Type_t->GPIOx_SCL == GPIOD || IIC_Type_t->GPIOx_SDA == GPIOD)
	  {
	   	__HAL_RCC_GPIOD_CLK_ENABLE();   //使能GPIOD时钟
	  }
	  if(IIC_Type_t->GPIOx_SCL == GPIOE || IIC_Type_t->GPIOx_SDA == GPIOE)
	  {
	   	__HAL_RCC_GPIOE_CLK_ENABLE();   //使能GPIOE时钟
	  } 
	  if(IIC_Type_t->GPIOx_SCL == GPIOH || IIC_Type_t->GPIOx_SDA == GPIOH)
	  {
	   	__HAL_RCC_GPIOH_CLK_ENABLE();   //使能GPIOH时钟
	  }     
	  
	    //GPIO_SCL初始化设置
	    GPIO_Initure.Pin=IIC_Type_t->GPIO_SCL;
	    GPIO_Initure.Mode=GPIO_MODE_OUTPUT_PP;  //推挽输出
	    GPIO_Initure.Pull=GPIO_PULLUP;          //上拉
	    GPIO_Initure.Speed=GPIO_SPEED_FREQ_VERY_HIGH;    //快速
	    HAL_GPIO_Init(IIC_Type_t->GPIOx_SCL,&GPIO_Initure);
	    //GPIO_SDA初始化设置
	    GPIO_Initure.Pin=IIC_Type_t->GPIO_SDA;
	    GPIO_Initure.Mode=GPIO_MODE_OUTPUT_PP;  //推挽输出
	    GPIO_Initure.Pull=GPIO_PULLUP;          //上拉
	    GPIO_Initure.Speed=GPIO_SPEED_FREQ_VERY_HIGH;    //快速
	    HAL_GPIO_Init(IIC_Type_t->GPIOx_SDA,&GPIO_Initure);
	    
            //SCL与SDA的初始化均为高电平
 	    IIC_SCL(IIC_Type_t,1);
  	    IIC_SDA(IIC_Type_t,1);
}
//IIC Start
static void IIC_Start_t(const struct IIC_Type* IIC_Type_t)
{
	 SDA_OUT(IIC_Type_t);      //sda线输出
	 IIC_SDA(IIC_Type_t,1);      
	 IIC_SCL(IIC_Type_t,1);
	 IIC_Type_t->delay_us(4);
	  IIC_SDA(IIC_Type_t,0);  //START:when CLK is high,DATA change form high to low 
	 IIC_Type_t->delay_us(4);
	 IIC_SCL(IIC_Type_t,0);  //钳住I2C总线，准备发送或接收数据 
}
//IIC Stop
static void IIC_Stop_t(const struct IIC_Type* IIC_Type_t)
{
	 SDA_OUT(IIC_Type_t); //sda线输出
	 IIC_SCL(IIC_Type_t,0);
	 IIC_SDA(IIC_Type_t,0); //STOP:when CLK is high DATA change form low to high
	  IIC_Type_t->delay_us(4);
	 IIC_SCL(IIC_Type_t,1); 
	 IIC_SDA(IIC_Type_t,1); //发送I2C总线结束信号
	 IIC_Type_t->delay_us(4); 
}
//IIC_Wait_ack 返回HAL_OK表示wait成功，返回HAL_ERROR表示wait失败
static uint8_t IIC_Wait_Ack_t(const struct IIC_Type* IIC_Type_t)   //IIC_Wait_ack,返回wait失败或是成功
{
	 uint8_t ucErrTime = 0;
	 SDA_IN(IIC_Type_t);      //SDA设置为输入  
	 IIC_SDA(IIC_Type_t,1);IIC_Type_t->delay_us(1);   
	 IIC_SCL(IIC_Type_t,1);IIC_Type_t->delay_us(1);
	 while(READ_SDA(IIC_Type_t))
	 {
	  	ucErrTime++;
	  	if(ucErrTime>250)
	  	{
	   		IIC_Type_t->IIC_Stop(IIC_Type_t);
	   		return HAL_ERROR;
	  	}
	 }
	 IIC_SCL(IIC_Type_t,0);//时钟输出0     
	 return HAL_OK;  
}
//产生ACK应答
static void IIC_Ack_t(const struct IIC_Type* IIC_Type_t)      
{
	 IIC_SCL(IIC_Type_t,0);
	 SDA_OUT(IIC_Type_t);
	 IIC_SDA(IIC_Type_t,0);
	 IIC_Type_t->delay_us(2);  
	 IIC_SCL(IIC_Type_t,1);
	 IIC_Type_t->delay_us(2);  
	 IIC_SCL(IIC_Type_t,0);
}
//产生NACK应答
static void IIC_NAck_t(const struct IIC_Type* IIC_Type_t)      
{
	 IIC_SCL(IIC_Type_t,0);
	 SDA_OUT(IIC_Type_t);
	 IIC_SDA(IIC_Type_t,1);
	 IIC_Type_t->delay_us(2);  
	 IIC_SCL(IIC_Type_t,1);
	 IIC_Type_t->delay_us(2);  
	 IIC_SCL(IIC_Type_t,0);
}
//IIC_Send_Byte，入口参数为要发送的字节
static void IIC_Send_Byte_t(const struct IIC_Type* IIC_Type_t,uint8_t txd)     
{
	    uint8_t t = 0;   
	    SDA_OUT(IIC_Type_t);      
	    IIC_SCL(IIC_Type_t,0);//拉低时钟开始数据传输
	    for(t=0;t<8;t++)
	    {              
	        	IIC_SDA(IIC_Type_t,(txd&0x80)>>7);
	        	txd <<= 1;    
		    	IIC_Type_t->delay_us(2);     //对TEA5767这三个延时都是必须的
		    	IIC_SCL(IIC_Type_t,1);
		    	IIC_Type_t->delay_us(2);  
		    	IIC_SCL(IIC_Type_t,0); 
		    	IIC_Type_t->delay_us(2);  
	    }  
}
//IIC_Send_Byte，入口参数为是否要发送ACK信号
static uint8_t IIC_Read_Byte_t(const struct IIC_Type* IIC_Type_t,uint8_t ack)     
{
	  uint8_t i,receive = 0;
	  SDA_IN(IIC_Type_t);//SDA设置为输入
	  for(i=0;i<8;i++ )
	  {
	     IIC_SCL(IIC_Type_t,0); 
	     IIC_Type_t->delay_us(2);
	     IIC_SCL(IIC_Type_t,1);
	     receive<<=1;
	     if(READ_SDA(IIC_Type_t))receive++;   
	     IIC_Type_t->delay_us(1);
	  }      
	 if (!ack)
	        IIC_Type_t->IIC_NAck(IIC_Type_t);//发送nACK
	 else
	        IIC_Type_t->IIC_Ack(IIC_Type_t); //发送ACK   
	 return receive;
}
//实例化一个IIC1外设，相当于一个结构体变量，可以直接在其他文件中使用
IIC_TypeDef IIC1 = {
	 .GPIOx_SCL = GPIOA,   //GPIO组为GPIOA
	 .GPIOx_SDA = GPIOA,   //GPIO组为GPIOA
	 .GPIO_SCL = GPIO_PIN_5,   //GPIO为PIN5
	 .GPIO_SDA = GPIO_PIN_6,  //GPIO为PIN6
	 .IIC_Init = IIC_Init_t,
	 .IIC_Start = IIC_Start_t,
	 .IIC_Stop = IIC_Stop_t,
	 .IIC_Wait_Ack = IIC_Wait_Ack_t,
	 .IIC_Ack = IIC_Ack_t,
	 .IIC_NAck = IIC_NAck_t,
	 .IIC_Send_Byte = IIC_Send_Byte_t,
	 .IIC_Read_Byte = IIC_Read_Byte_t,
	 .delay_us = delay_us     //需自己外部实现delay_us函数
};

  上述就是IIC驱动的封装，由于没有应用场景暂不测试其实用性，待下面ATC64的驱动缝缝扎黄写完之后一起测试使用。

三.ATC64XX驱动封装实现

at24cxx.h头文件主要是类模板的定义，具体如下：

// 以下是共定义个具体容量存储器的容量
#define AT24C01  127
#define AT24C02  255
#define AT24C04  511
#define AT24C08  1023
#define AT24C16  2047
#define AT24C32  4095
#define AT24C64   8191         //8KBytes
#define AT24C128 16383
#define AT24C256 32767  

//定义AT24CXX类
typedef struct AT24CXX_Type
{
	 //属性
	 u32 EEP_TYPE;           //存储器类型（存储器容量）
	 //操作
	 IIC_TypeDef IIC;       //IIC驱动
	 uint8_t (*AT24CXX_ReadOneByte)(const struct AT24CXX_Type*,uint16_t);  //指定地址读取一个字节
	 void (*AT24CXX_WriteOneByte)(const struct AT24CXX_Type*,uint16_t,uint8_t); //指定地址写入一个字节
	 void (*AT24CXX_WriteLenByte)(uint16_t,uint32_t,uint8_t); //指定地址开始写入指定长度的数据
	 uint32_t (*AT24CXX_ReadLenByte)(uint16_t,uint8_t);   //指定地址开始读取指定长度数据
	 void (*AT24CXX_Write)(uint16_t,uint8_t *,uint16_t);  //指定地址开始写入指定长度的数据
	 void (*AT24CXX_Read)(uint16_t,uint8_t *,uint16_t);   //指定地址开始写入指定长度的数据
	 void (*AT24CXX_Init)(const struct AT24CXX_Type*); //初始化IIC
	 uint8_t (*AT24CXX_Check)(const struct AT24CXX_Type*);   //检查器件
}AT24CXX_TypeDef;

extern AT24CXX_TypeDef AT24C_64;     //外部声明实例化AT24CXX对象

at24cxx.c源文件主要是类模板具体操作函数的实现，具体如下：

//在AT24CXX指定地址读出一个数据
//ReadAddr:开始读数的地址  
//返回值  :读到的数据
static uint8_t AT24CXX_ReadOneByte_t(const struct AT24CXX_Type* AT24CXX_Type_t,uint16_t ReadAddr)
{      
	 uint8_t temp=0;                          
	 AT24CXX_Type_t->IIC.IIC_Start(&AT24CXX_Type_t->IIC);  
	 //根据AT的型号发送不同的地址
	 if(AT24CXX_Type_t->EEP_TYPE > AT24C16)
	 {
	  	AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,0XA0);    //发送写命令
	  	AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);
	  	AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,ReadAddr>>8);//发送高地址     
	 }else AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,0XA0+((ReadAddr/256)<<1));   //发送器件地址0XA0,写数据     
	 AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC); 
	 AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,ReadAddr%256);   //发送低地址
	 AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);     
	 AT24CXX_Type_t->IIC.IIC_Start(&AT24CXX_Type_t->IIC);        
	 AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,0XA1);           //进入接收模式      
	 AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);  
	 temp=AT24CXX_Type_t->IIC.IIC_Read_Byte(&AT24CXX_Type_t->IIC,0);     
	 AT24CXX_Type_t->IIC.IIC_Stop(&AT24CXX_Type_t->IIC);//产生一个停止条件     
	 return temp;
}
//在AT24CXX指定地址写入一个数据
//WriteAddr  :写入数据的目的地址    
//DataToWrite:要写入的数据
static void AT24CXX_WriteOneByte_t(const struct AT24CXX_Type* AT24CXX_Type_t,uint16_t WriteAddr,uint8_t DataToWrite)
{                                
  	AT24CXX_Type_t->IIC.IIC_Start(&AT24CXX_Type_t->IIC);   
 	if(AT24CXX_Type_t->EEP_TYPE > AT24C16)
 	{
  		AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,0XA0);    //发送写命令
  		AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);
  		AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,WriteAddr>>8);//发送高地址     
 	}else AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,0XA0+((WriteAddr/256)<<1));   //发送器件地址0XA0,写数据     
 	AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC); 
  	AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,WriteAddr%256);   //发送低地址
 	AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);               
 	AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,DataToWrite);     //发送字节          
 	AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);            
  	AT24CXX_Type_t->IIC.IIC_Stop(&AT24CXX_Type_t->IIC);//产生一个停止条件 
	AT24CXX_Type_t->IIC.delay_us(10000);  
}
//在AT24CXX里面的指定地址开始写入长度为Len的数据
//该函数用于写入16bit或者32bit的数据.
//WriteAddr  :开始写入的地址  
//DataToWrite:数据数组首地址
//Len        :要写入数据的长度2,4
static void AT24CXX_WriteLenByte_t(uint16_t WriteAddr,uint32_t DataToWrite,uint8_t Len)
{   
 	uint8_t t;
 	for(t=0;t<Len;t++)
 	{
  		AT24CXX_WriteOneByte(WriteAddr+t,(DataToWrite>>(8*t))&0xff);
 	}                
}
//在AT24CXX里面的指定地址开始读出长度为Len的数据
//该函数用于读出16bit或者32bit的数据.
//ReadAddr   :开始读出的地址 
//返回值     :数据
//Len        :要读出数据的长度2,4
static uint32_t AT24CXX_ReadLenByte_t(uint16_t ReadAddr,uint8_t Len)
{   
 	uint8_t t;
 	uint32_t temp=0;
 	for(t=0;t<Len;t++)
 	{
 		 temp<<=8;
  		 temp+=AT24CXX_ReadOneByte(ReadAddr+Len-t-1);          
 	}
 	return temp;                
}
//在AT24CXX里面的指定地址开始写入指定个数的数据
//WriteAddr :开始写入的地址 对24c64为0~8191
//pBuffer   :数据数组首地址
//NumToWrite:要写入数据的个数
static void AT24CXX_Write_t(uint16_t WriteAddr,uint8_t *pBuffer,uint16_t NumToWrite)
{
	 while(NumToWrite--)
	 {
	 	AT24CXX_WriteOneByte(WriteAddr,*pBuffer);
	  	WriteAddr++;
	  	pBuffer++;
	 }
}
//在AT24CXX里面的指定地址开始读出指定个数的数据
//ReadAddr :开始读出的地址 对24c64为0~8191
//pBuffer  :数据数组首地址
//NumToRead:要读出数据的个数
static void AT24CXX_Read_t(uint16_t ReadAddr,uint8_t *pBuffer,uint16_t NumToRead)
{
 	while(NumToRead)
 	{
  		*pBuffer++=AT24CXX_ReadOneByte(ReadAddr++); 
  		NumToRead--;
 	}
} 
//初始化IIC接口
static void AT24CXX_Init_t(const struct AT24CXX_Type* AT24CXX_Type_t)
{
 	AT24CXX_Type_t->IIC.IIC_Init(&AT24CXX_Type_t->IIC);//IIC初始化
}
//检查器件,返回0表示检测成功,返回1表示检测失败
static uint8_t AT24CXX_Check_t(const struct AT24CXX_Type* AT24CXX_Type_t)   
{
	uint8_t temp;
 	temp = AT24CXX_Type_t->AT24CXX_ReadOneByte(AT24CXX_Type_t,AT24CXX_Type_t->EEP_TYPE);//避免每次开机都写AT24CXX      
 	if(temp == 0X33)return 0;     
 	else//排除第一次初始化的情况
 	{
   		 AT24CXX_Type_t->AT24CXX_WriteOneByte(AT24CXX_Type_t,AT24CXX_Type_t->EEP_TYPE,0X33);
     		temp = AT24CXX_Type_t->AT24CXX_ReadOneByte(AT24CXX_Type_t,AT24CXX_Type_t->EEP_TYPE);
    		if(temp==0X33)return 0;
	 }
	 return 1;  
}
//实例化AT24CXX对象
AT24CXX_TypeDef AT24C_64={
 .EEP_TYPE = AT24C64,           //存储器类型（存储器容量）
 //操作
 .IIC={
  .GPIOx_SCL = GPIOA,
  .GPIOx_SDA = GPIOA,
  .GPIO_SCL = GPIO_PIN_5,
  .GPIO_SDA = GPIO_PIN_6,
  .IIC_Init = IIC_Init_t,
  .IIC_Start = IIC_Start_t,
  .IIC_Stop = IIC_Stop_t,
  .IIC_Wait_Ack = IIC_Wait_Ack_t,
  .IIC_Ack = IIC_Ack_t,
  .IIC_NAck = IIC_NAck_t,
  .IIC_Send_Byte = IIC_Send_Byte_t,
  .IIC_Read_Byte = IIC_Read_Byte_t,
  .delay_us = delay_us
 },                   //IIC驱动
 .AT24CXX_ReadOneByte = AT24CXX_ReadOneByte_t,  //指定地址读取一个字节
 .AT24CXX_WriteOneByte = AT24CXX_WriteOneByte_t,//指定地址写入一个字节
 .AT24CXX_WriteLenByte = AT24CXX_WriteLenByte_t, //指定地址开始写入指定长度的数据
 .AT24CXX_ReadLenByte = AT24CXX_ReadLenByte_t,   //指定地址开始读取指定长度数据
 .AT24CXX_Write = AT24CXX_Write_t,  //指定地址开始写入指定长度的数据
 .AT24CXX_Read = AT24CXX_Read_t,   //指定地址开始读取指定长度的数据
 .AT24CXX_Init = AT24CXX_Init_t, //初始化IIC
 .AT24CXX_Check = AT24CXX_Check_t   //检查器件
};

  简单分析：可以看出AT24CXX类中包含了IIC类的成员对象，这是一种包含关系，因为没有属性上的一致性因此谈不上继承。之所以将IIC的类对象作为AT24CXX类的成员是因为AT24CXX的实现需要调用IIC的成员方法，IIC相当于AT24CXX更下层的驱动，因此采用包含关系更合适。因此我们在使用AT24CXX的时候只需要实例化AT24CXX类对象就行了，因为IIC包含在AT24CXX类中间，因此不需要实例化IIC类对象，对外提供了较好的封装接口。下面我们看具体的调用方法。

四.主函数main调用测试

  在main函数中直接使用AT24C_64来完成所有操作，下面结合代码来看：

#include "at24cxx.h"    //为了确定AT24C_64的成员方法和引用操作对象AT24C_64
int main(void)
{
	 /************省略其他初始化工作****************/
	 //第一步：调用对象初始化方法来初始化AT24C64
	 AT24C_64.AT24CXX_Init(&AT24C_64);
	 //第二步：调用对象检测方法来检测AT24C64           
	 if(AT24C_64.AT24CXX_Check(&AT24C_64) == 0)
	 {
	  	printf("AT24C64检测成功\r\n");
	 }
	 else{
	  	printf("AT24C64检测失败\r\n");
	 }
	 return 0;
}

  可以看出所有的操作都是通过AT24C_64对象调用完成的，在我们初始化好AT24C_64对象之后就可以放心大胆的调用其成员方法，这样封装的好处就是一个设备对外只提供一个对象接口，简洁明了。

五.总结

  本文详细介绍了面向对象方法实现IIC驱动封装以及AT24CXX存储器的封装，最终对外仅提供一个操作对象接口，大大提高了代码的复用性以及封装性。

六. 感谢支持

    完结撒花！希望看到这里的小伙伴能点个关注，我后续会持续更新，也欢迎大家广泛交流。
    码字实属不易，如果本文对你有10分帮助，就赏个10分把，感谢各位大佬支持！

在这里插入图片描述

tutu-hu
关注
专栏目录
嵌入式分享合集58
weixin_42051732的博客
07-25 17
一、C面向对象实现-IIC驱动使用面向对象的编程思想封装IIC驱动，将IIC的属性和操作封装成一个库，在需要创建一个IIC设备时只需要实例化一个IIC对象即可，本文是基于STM32和HAL库做进一步封装的。底层驱动方法不重要，封装的思想很重要。在完成对IIC驱动的封装之后借助继承特性实现AT24C64存储器的驱动开发，仍使...
IIC驱动？C语言使用面向对象来实现
李肖遥的专栏
05-24 324
关注、星标公众号，直达精彩内容来源：网路素材一.简述使用面向对象的编程思想封装IIC驱动，将IIC的属性和操作封装成一个库，在需要创建一个IIC设备时只需要实例化一个IIC对象即可，本文是基于STM32和HAL库做进一步封装的。底层驱动方法不重要，封装的思想很重要。在完成对IIC驱动的封装之后借助继承特性实现AT24C64存储器的驱动开发，仍使用面向对象的思想封装...
C语言实现IIC通信
11-02
IIC协议C语言实现，方便理解IIC的时序，读写过程和初始化等
使用面向对象来实现IIC驱动
zhen
05-25 400
文章来源：IIC驱动？C语言使用面向对象来实现 ...一.简述二.IIC驱动面向对象封装三.ATC64XX驱动封装实现四.主函数main调用测试五.总结 一.简述 使用面向对象的编程思想封装IIC驱动，将IIC的属性和操作封装成一个库，在需要创建一个IIC设备时只需要实例化一个IIC对象即可，本文是基于STM32和HAL库做进一步封装的。 底层驱动方法不重要，封装的思想很重要。在完成对IIC驱动的封装之后借助继承特性实现AT24C64存储器的驱动开发，仍使用面向对象的思想封装AT24C64驱动。 二.IIC
I2C总线时序模拟（一）-加深理解总线协议
系统运维
10-16 379
I2C总线时序模拟（一）-加深理解总线协议 #include&lt;reg52.h&gt; #define uchar unsigned char sbit sda=P2^0; sbit scl=P2^1;//用单片机的两个I/O口模拟I2C接口 uchar a; ******************************************************************...
IIC协议的C语言编程详解
weixin_51772979的博客
04-28 847
IIC串行总线一般有两根信号线，一根是双向的数据线SDA，另一根是时钟线SCL，其时钟信号是由主控器件产生。所有接到IIC总线设备上的串行数据SDA都接到总线的SDA上，各设备的时钟线SCL接到总线的SCL上。在传输数据的过程中，我们要保证数据的有效性：SDA 线上的数据必须在时钟的高电平周期保持稳定。数据线的高或低电平状态，只有在SCL 线的时钟信号是低电平时才能改变（如图所示）。首先传输的是数据的最高位。IIC总线在传输数据的过程中一共有三种类型信号，分别为起始信号，终止信号和应答信号。
手把手教你写IIC（要是学不会，来找我）（C语言）
2301_78572193的博客
01-11 656
应答信号：上拉电阻影响下SDA默认为高，而从机拉低SDA就是确认收到数据即ACK，否则NACK。注意：这里面最重要的的就是三个信号（起始信号，终止信号，应答信号）组成，并且都接上拉电阻，确保总线空闲状态为高电平。SCL为高电平期间, SDA从高电平往低电平跳变。SCL为高电平期间, SDA从低电平往高电平跳变。2us的延时, 读写速度在250Khz以内。
[一点五编程]--对于嵌入式开发中 使用面向对象的理念 通过C语言中的结构体和函数指针实现C++三大特性
最新发布
qq_51967985的博客
08-19 567
在灯的设计中 要用到的功能有开灯(led_open) 关灯(led_close)所以typedef函数指针。
51单片机驱动,51单片机蜂鸣器,C,C++
09-10
此外，为了提高代码的可移植性和可维护性，通常会采用面向对象的编程方式，封装传感器的操作接口。 在51单片机上使用C或C++编程，可以利用这两种语言的强大特性，如C++的类和模板，以提高代码的结构和效率。C语言则...
Linux设备驱动开发-platform总线
想坐在电脑前吹空调
07-17 581
在嵌入式系统里面，SoC系统中集成的独立的外设控制器、挂接在SoC内存空间的外设等确不依附于总线。也就是说在嵌入式CPU中，访问外设跟访问内存是一样的。基于这一背景，Linux发明了一种虚拟的总线，称为platform总线，相应的设备称为platform_device，而驱动成为 platform_driver。物理总线：芯片与各个功能外设之间传送信息的公共通信干线，其中又包括数据总线、地址总线和控制总线，以此来传输各种通信时序。驱动总线：负责管理设备和驱动。
IIC经典驱动程序.c
05-14
IIC经典驱动程序，可以驱动IIC系列外围硬件，简单易懂，可以稍加修改放置于自己程序中。 总线信号 ： 　　SDA ：串行数据线 　　SCL ：串行时钟 总线空闲状态 ： 　　SDA ：高电平 　　SCL ：高电平 起始位：SCL为高电平期间 SDA出现下降沿 终止位：SCL为高电平期间 SDA出现上升沿 数据传输 ：SDA的数据在SCL高电平期间被写入从机。所以SDA的数据变化要发生在SCL低电平期间。 IIC时钟频率：不高于400K 应答：当IIC主机（不一定是发送端还是接受端）将8位数据或命令传出后，会将SDA信号设置为输入，等待从机应答（等待SDA由高电平拉为低电平） 若从机正确应答，表明数据或者命令传输成功，否则传输失败，注意，应答信号是数据接收方发送给数据发送方的。 IIC器件地址：每一个IIC器件都有一个器件地址，有的器件地址在出厂时地址就设定好了，用户不可以更改,比如OV7670的地址为0x42。有的器件例如EEPROM，前四个地址已经确定为1010，后三个地址是由硬件链接确定的，所以在这种情况下一 个IIC总线最多能连8个EEPROM芯片。
模拟IIC程序，C代码
06-03
详细实用的IIC模拟实现代码，适用于所有单片机。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
STM32 GPIO 模拟IIC （I2C） c语言 源代码（测试绝对可用）
10-25
STM32 GPIO 模拟IIC （I2C） c语言 源代码（测试绝对可用） 用STM32 GPIO模拟IIC 的c语言源代码，自己的项目中的，绝对可用。
模拟I2C的C语言实现
10-11
模拟I2C的C语言实现
iic,c语言代码
04-07
常用的iic代码，c语言编写，简单易懂，基于stm32f103编写，其他的都修改都可以通用。
常见Linux嵌入式C语言笔试面试题
小桥流水 的专栏
04-09 1224
常见Linux嵌入式C语言笔试面试题
芯片原厂linux驱动开发的分享
嵌入式技术开发
05-31 150
大家好，我是XX，来自湖南XX学院，电子信息18级，也曾在创新基地控制组学习过两三年，毕业后就职于一家芯片原厂的解决方案部，担任驱动工程师的职位，算上实习期，我的工作时长已有两年。在此我想将这两年期间学习与积累到的一些经验输出出来，与大家一同分享。知识面有限，只能简单介绍一些驱动开发方向的一些经验，且由于经验尚浅，文中难免会有一些疏漏和错误之处，还请大家积极地批评指正。
iic标准c语言,I2C总线之(三)---以C语言理解IIC
weixin_33272631的博客
05-18 794
为了加深对I2C总线的理解，用C语言模拟IIC总线，边看源代码边读波形：如下图所示的写操作的时序图：读时序的理解同理。对于时序不理解的朋友请参考“I2C总线之(二)---时序”完整的程序如下：#include#define uchar unsigned char#define uint unsigned int#define write_ADD 0xa0#define read_ADD 0xa1u...
请用C语言帮我实现IIC驱动
07-14
实现I2C驱动需要使用硬件相关的库函数，以及对应的物理接口。这里提供一个简单的示例代码，演示如何通过C语言使用Linux的I2C驱动来读取和写入数据。 ```c #include <stdio.h> #include <fcntl.h> #include <unistd.h> #include <linux/i2c-dev.h> #define I2C_DEVICE "/dev/i2c-1" // I2C设备文件路径 #define I2C_SLAVE_ADDR 0x27 // I2C从设备地址 int main() { int i2c_fd; // 打开I2C设备文件 i2c_fd = open(I2C_DEVICE, O_RDWR); if (i2c_fd < 0) { perror("无法打开I2C设备文件"); return -1; } // 设置I2C从设备地址 if (ioctl(i2c_fd, I2C_SLAVE, I2C_SLAVE_ADDR) < 0) { perror("无法设置I2C从设备地址"); return -1; } // 发送写命令和数据 unsigned char write_data[2] = {0x00, 0xAA}; if (write(i2c_fd, write_data, 2) != 2) { perror("写入数据失败"); return -1; } // 接收读命令和数据 unsigned char read_data[2]; if (read(i2c_fd, read_data, 2) != 2) { perror("读取数据失败"); return -1; } // 打印读取到的数据 printf("读取到的数据：0x%02X, 0x%02X\n", read_data[0], read_data[1]); // 关闭I2C设备文件 close(i2c_fd); return 0; } ``` 请注意，上述代码是在Linux环境下使用I2C驱动的示例。其中，需要根据实际情况修改`I2C_DEVICE`和`I2C_SLAVE_ADDR`的值，以匹配你的I2C设备和从设备地址。 代码中，我们使用`open`函数打开I2C设备文件，使用`ioctl`函数设置I2C从设备地址。然后，通过`write`函数发送写命令和数据，使用`read`函数接收读命令和数据。最后，我们打印读取到的数据。 请注意，实际应用中，还需要根据具体的I2C设备和从设备进行相应的初始化和通信操作。 希望以上信息能对你有所帮助！如果还有其他问题，请随时提问。
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

tutu-hu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值