嵌入式程序开发3

rust 还没学废 所以先复习c语言吧 准备用rust弄个web服务器的  不想在arm里装nginx

好了下面言归正传

使用C语言实现IIC驱动

简述

    IIC（Inter-Integrated Circuit）其实是IICBus简称，它是一种串行通信总线，使用多主从架构，在STM32开发中经常见到。

    使用面向对象的编程思想封装IIC驱动，将IIC的属性和操作封装成一个库，在需要创建一个IIC设备时只需要实例化一个IIC对象即可，本文是基于STM32和HAL库做进一步封装的。

    底层驱动方法不重要，封装的思想很重要。在完成对IIC驱动的封装之后借助继承特性实现AT24C64存储器的驱动开发，仍使用面向对象的思想封装AT24C64驱动。whaosoft aiot http://143ai.com

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_Initvoid (*IIC_Start)(const struct IIC_Type*);       //IIC_Startvoid (*IIC_Stop)(const struct IIC_Type*);        //IIC_Stopuint8_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 Startstatic 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 Stopstatic 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);//发送nACKelse         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*); //初始化IICuint8_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,4static 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,4static 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_64int 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存储器的封装，最终对外仅提供一个操作对象接口，大大提高了代码的复用性以及封装性。

以上说完了驱动下面介绍一下 通信协议 IIC 与 SPI 最全对比

 现今，在低端数字通信应用领域，我们随处可见IIC(Inter-Integrated Circuit)和 SPI(Serial Peripheral Interface)的身影。原因是这两种通信协议非常适合近距离低速芯片间通信。Philips(for IIC)和Motorola(for SPI)出于不同背景和市场需求制定了这两种标准通信协议。

    IIC开发于1982年，当时是为了给电视机内的CPU和外围芯片提供更简易的互联方式。电视机是最早的嵌入式系统之一，而最初的嵌入系统是使用内存映射(memory-mapped I/O)的方式来互联微控制器和外围设备的。要实现内存映射，设备必须并联入微控制器的数据线和地址线，这种方式在连接多个外设时需大量线路和额外地址解码芯片，很不方便并且成本高。

    为了节省微控制器的引脚和和额外的逻辑芯片，使印刷电路板更简单，成本更低，位于荷兰的Philips实验室开发了“Inter-Integrated Circuit”，IIC或I2C ，一种只使用二根线接连所有外围芯片的总线协议。最初的标准定义总线速度为100kbps。经历几次修订，主要是1995年的400kbps，1998的3.4Mbps。

    有迹象表明，SPI总线首次推出是在1979年，Motorola公司将SPI总线集成在他们第一支改自68000微处理器的微控制器芯片上。SPI总线是微控制器四线的外部总线(相对于内部总线)。与IIC不同，SPI没有明文标准，只是一种事实标准，对通信操作的实现只作一般的抽象描述，芯片厂商与驱动开发者通过data sheets和application notes沟通实现上的细节。

SPI总线介绍

    对于有经验的数字电子工程师来说，用SPI互联两支数字设备是相当直观的。SPI是一种四根信号线协议，如下图。

• SCLK：Serial Clock (output from master)。

• MOSI;SIMO：Master Output，Slave Input(output from master)，

• MISO;SOMI：Master Input，Slave Output(output from slave)。

• SS：Slave Select (active low，outputfrom master)。

    SPI是单主设备(single-master)通信协议，这意味着总线中的只有一支中心设备能发起通信。当SPI主设备想读/写从设备时，它首先拉低从设备对应的SS线(SS是低电平有效)，接着开始发送工作脉冲到时钟线上，在相应的脉冲时间上，主设备把信号发到MOSI实现“写”，同时可对MISO采样而实现“读”，如下图。

    SPI有四种操作模式：模式0、模式1、模式2和模式3.它们的区别是定义了在时钟脉冲的哪条边沿转换(toggles)输出信号，哪条边沿采样输入信号，还有时钟脉冲的稳定电平值(即时钟信号无效时是高还是低)。每种模式由一对参数刻画，它们称为时钟极(clock polarity)CPOL与时钟期(clock phase)CPHA。

    主从设备必须使用相同的工作参数——SCLK\CPOL和CPHA，才能正常工作。如果有多个从设备，并且它们使用了不同的工作参数，那么主设备必须在读写不同从设备间重新配置这些参数。

    SPI不规定最大传输速率，没有地址方案；SPI也没规定通信应答机制，没有规定流控制规则。事实上，SPI主设备甚至并不知道指定的从设备是否存在。这些通信控制都得通过SPI协议以外自行实现。例如，要用SPI连接一支“命令-响应控制型”解码芯片，则必须在SPI的基础上实现更高级的通信协议。

    SPI并不关心物理接口的电气特性，例如信号的标准电压。在最初，大多数SPI应用都是使用间断性时钟脉冲和以字节为单位传输数据的，但现在有很多变种实现了连续性时间脉冲和任意长度的数据帧。

IIC总线介绍

    与SPI的单主设备不同，IIC是多主设备的总线，IIC没有物理的芯片选择信号线，没有仲裁逻辑电路，只使用两条信号线——serial data(SDA)和serial clock(SCL)。

    IIC协议规定：

• 每一支IIC设备都有一个唯一的七位设备地址。

• 数据帧大小为8位的字节。

• 数据(帧)中的某些数据位，用于控制通信的开始、停止、方向(读写)和应答机制。

    IIC数据传输速率有标准模式(100kbps)、快速模式(400kbps)和高速模式(3.4Mbps），另外一些变种实现了低速模式(10kbps)和快速+模式(1Mbps)。

    物理实现上，IIC总线由两根信号线和一根地线组成。两根信号线都是双向传输的，参考下图。IIC协议标准规定发起通信的设备称为主设备，主设备发起一次通信后，其它设备均为从设备。

    IIC通信过程大概如下。首先，主设备发一个START信号，这个信号就像对所有其它设备喊：请大家注意！然后其它设备开始监听总线以准备接收数据。接着，主设备发送一个7位设备地址加一位的读写操作的数据帧。当所设备接收数据后，比对地址自己是否目标设备。如果比对不符，设备进入等待状态，等待STOP信号的来临；如果比对相符，设备会发送一个应答信号——ACKNOWLEDGE作回应。

    当主设备收到应答后便开始传送或接收数据。数据帧大小为8位，尾随一位的应答信号。主设备发送数据，从设备应答；相反主设备接数据，主设备应答。当数据传送完毕，主设备发送一个STOP信号，向其它设备宣告释放总线，其它设备回到初始状态。

    基于IIC总线的物理结构，总线上的START和STOP信号必定是唯一的。另外，IIC总线标准规定：SDA线的数据转换必须在SCL线的低电平期，在SCL线的高电平期，SDA线的上数据是稳定的。

    在物理实现上，SCL线和SDA线都是漏极开路(open-drain)，通过上拉电阻外加一个电压源。当把线路接地时，线路为逻辑0，当释放线路，线路空闲时，线路为逻辑1。基于这些特性，IIC设备对总线的操作仅有“把线路接地”——输出逻辑0。

    IIC总线设计只使用了两条线，但相当优雅地实现任意数目设备间无缝通信，堪称完美。我们设想一下，如果有两支设备同时向SCL线和SDA线发送信息会出现什么情况。

    基于IIC总线的设计，线路上不可能出现电平冲突现象。如果一支设备发送逻辑0，其它发送逻辑1，那么线路看到的只有逻辑0。也就是说，如果出现电平冲突，发送逻辑0的始终是“赢家”。

    总线的物理结构亦允许主设备在往总线写数据的同时读取数据。这样，任何设备都可以检测冲突的发生。当两支主设备竞争总线的时候，“赢家”并不知道竞争的发生，只有“输家”发现了冲突——当它写一个逻辑1，却读到0时——而退出竞争。

十位设备地址

    任何IIC设备都有一个7位地址，理论上，现实中只能有127种不同的IIC设备。实际上，已有IIC的设备种类远远多于这个限制，在一条总线上出现相同的地址的IIC设备的概率相当高。为了突破这个限制，很多设备使用了双重地址——7位地址加引脚地址(external configuration pins)。IIC标准也预知了这种限制，提出10位的地址方案。

    10位的地址方案对IIC协议的影响有两点：

    第一，地址帧为两个字节长，原来的是一个字节。

    第二，第一个字节前五位最高有效位用作10位地址标识，约定是“11110”。

    除了10位地址标识，标准还预留了一些地址码用作其它用途，如下表：

时钟拉伸

    在IIC通信中，主设备决定了时钟速度。因为时钟脉冲信号是由主设备显式发出的。但是，当从设备没办法跟上主设备的速度时，从设备需要一种机制来请求主设备慢一点，这种机制称为时钟拉伸。而基于IIC结构的特殊性，这种机制得到实现。当从设备需要降低传输的速度的时候，它可以按下时钟线，逼迫主设备进入等待状态，直到从设备释放时钟线，通信才继续。

高速模式

    原理上讲，使用上拉电阻来设置逻辑1，会限制总线的最大传输速度。而速度是限制总线应用的因素之一。这也说明为什么要引入高速模式(3.4Mbps)。在发起一次高速模式传输前，主设备必须先在低速的模式下(例如快速模式)发出特定的“High Speed Master”信号。为缩短信号的周期和提高总线速度，高速模式必须使用额外的I/O缓冲区。另外，总线仲裁在高速模式下可屏蔽掉。更多的信息请参与总线标准文档。

IIC与SPI对比

    我们来对比一下IIC和SPI的一些关键点。

    1、总线拓扑结构\信号路由\硬件资源耗费

    IIC只需两根信号线，而标准SPI至少四根信号，如果有多个从设备，信号需要更多。一些SPI变种虽然只使用三根线——SCLK、SS和双向的MISO/MOSI，但SS线还是要和从设备一对一根。另外，如果SPI要实现多主设备结构，总线系统需额外的逻辑和线路。用IIC构建系统总线唯一的问题是有限的7位地址空间，但这个问题新标准已经解决——使用10位地址。从第一点上看，IIC是明显的大赢家。

    2、数据吞吐\传输速度

    如果应用中必须使用高速数据传输，那么SPI是必然的选择。因为SPI是全双工，IIC的不是。SPI没有定义速度限制，一般的实现通常能达到甚至超过10Mbps。IIC最高的速度也就快速+模式(1Mbps)和高速模式(3.4Mbps)，后面的模式还需要额外的I/O缓冲区，还并不是总是容易实现的。

    3、优雅性

    IIC常被称更优雅于SPI。公正的说，笔者更倾向于认为两者同等优雅和健壮。IIC的优雅在于它的特色——用很轻盈的架构实现了多主设备仲裁和设备路由。但是对使用的工程师来讲，理解总线结构更费劲，而且总线的性能不高。

    SPI的优点在于它的结构相当的直观简单，容易实现，并且有很好扩展性。SPI的简单性不足称其优雅，因为要用SPI搭建一个有用的通信平台，还需要在SPI之上构建特定的通信协议软件。也就是说要想获得SPI特有而IIC没有的特性——高速性能，工程师们需要付出更多的劳动。另外，这种自定的工作是完全自由的，这也说明为什么SPI没有官方标准。IIC和SPI都对低速设备通信提供了很好的支持，不过，SPI适合数据流应用，而IIC更适合“字节设备”的多主设备应用。

总结

    在数字通信协议簇中，IIC和SPI常称为“小”协议，相对Ethernet、USB、SATA、PCI-Express等传输速度达数百上千兆字节每秒的总线。但是，我们不能忘记的是各种总线的用途是什么。“大”协议是用于系统外的整个系统之间通信的，“小”协议是用于系统内各芯片间的通信，没有迹象表明“大”协议有必要取代“小”协议。IIC和SPI的存在和流行体现了“够用就好”的哲学。回应文首，IIC和SPI如此流行，它是任何一位嵌入式工程师必备的工具。