你的浏览器版本过低，可能导致网站不能正常访问！
为了你能正常使用网站功能，请使用这些浏览器。

st-img
chrome st-img
firefox st-img
safari st-img
ie8及以上

STM32开发中使用C语言实现IIC驱动

[复制链接]
STMCU-管管 发布时间：2021-6-21 14:39
简述
    IIC（Inter-Integrated Circuit）其实是IICBus简称，它是一种串行通信总线，使用多主从架构，在STM32开发中经常见到。


    关于IIC可以参考之前发的一篇文章《通信协议 IIC 与 SPI 最全对比》来了解。


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


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


IIC驱动面向对象封装
    iic.h头文件主要是类模板的定义，具体如下：

  2. //定义IIC类
  3. typedef struct IIC_Type
  4. {
  5.    //属性
  6.    GPIO_TypeDef  *GPIOx_SCL;  //GPIO_SCL所属的GPIO组(如：GPIOA)
  7.    GPIO_TypeDef  *GPIOx_SDA;  //GPIO_SDA所属的GPIO组(如：GPIOA)
  8.    uint32_t GPIO_SCL;     //GPIO_SCL的IO引脚(如：GPIO_PIN_0)
  9.    uint32_t GPIO_SDA;     //GPIO_SDA的IO引脚(如：GPIO_PIN_0)
  10.    //操作
  11.    void (*IIC_Init)(const struct IIC_Type*);        //IIC_Init
  12.    void (*IIC_Start)(const struct IIC_Type*);       //IIC_Start
  13.    void (*IIC_Stop)(const struct IIC_Type*);        //IIC_Stop
  14.    uint8_t (*IIC_Wait_Ack)(const struct IIC_Type*);    //IIC_Wait_ack,返回wait失败或是成功
  15.    void (*IIC_Ack)(const struct IIC_Type*);       //IIC_Ack,IIC发送ACK信号
  16.    void (*IIC_NAck)(const struct IIC_Type*);       //IIC_NAck,IIC发送NACK信号
  17.    void (*IIC_Send_Byte)(const struct IIC_Type*,uint8_t);       //IIC_Send_Byte，入口参数为要发送的字节
  18.    uint8_t (*IIC_Read_Byte)(const struct IIC_Type*,uint8_t);     //IIC_Send_Byte，入口参数为是否要发送ACK信号
  19.    void (*delay_us)(uint32_t);              //us延时
  20. }IIC_TypeDef;
复制代码
  iic.c源文件主要是类模板具体操作函数的实现，具体如下：
  1. //设置SDA为输入模式
  2. static void SDA_IN(const struct IIC_Type* IIC_Type_t)
  3. {
  4.   uint8_t io_num = 0;  //定义io Num号
  5.   switch(IIC_Type_t->GPIO_SDA)
  6.   {
  7.    case GPIO_PIN_0:
  8.     io_num = 0;
  9.    break;
  10.    case GPIO_PIN_1:
  11.     io_num = 1;
  12.    break;
  13.    case GPIO_PIN_2:
  14.     io_num = 2;
  15.    break;
  16.    case GPIO_PIN_3:
  17.     io_num = 3;
  18.    break;
  19.    case GPIO_PIN_4:
  20.     io_num = 4;
  21.    break;
  22.     case GPIO_PIN_5:
  23.     io_num = 5;
  24.    break;
  25.    case GPIO_PIN_6:
  26.     io_num = 6;
  27.    break;
  28.    case GPIO_PIN_7:
  29.     io_num = 7;
  30.    break;
  31.    case GPIO_PIN_8:
  32.     io_num = 8;
  33.    break;
  34.    case GPIO_PIN_9:
  35.     io_num = 9;
  36.    break;
  37.    case GPIO_PIN_10:
  38.     io_num = 10;
  39.    break;
  40.    case GPIO_PIN_11:
  41.     io_num = 11;
  42.    break;
  43.    case GPIO_PIN_12:
  44.     io_num = 12;
  45.    break;
  46.    case GPIO_PIN_13:
  47.     io_num = 13;
  48.    break;
  49.    case GPIO_PIN_14:
  50.     io_num = 14;
  51.    break;
  52.    case GPIO_PIN_15:
  53.     io_num = 15;
  54.    break;
  55.   }
  56.   IIC_Type_t->GPIOx_SDA->MODER&=~(3<<(io_num*2)); //将GPIOx_SDA->GPIO_SDA清零
  57.   IIC_Type_t->GPIOx_SDA->MODER|=0<<(io_num*2);   //将GPIOx_SDA->GPIO_SDA设置为输入模式
  58. }

  60. //设置SDA为输出模式
  61. static void SDA_OUT(const struct IIC_Type* IIC_Type_t)
  62. {
  63.   uint8_t io_num = 0;  //定义io Num号
  64.   switch(IIC_Type_t->GPIO_SDA)
  65.   {
  66.    case GPIO_PIN_0:
  67.     io_num = 0;
  68.    break;
  69.    case GPIO_PIN_1:
  70.     io_num = 1;
  71.    break;
  72.    case GPIO_PIN_2:
  73.     io_num = 2;
  74.    break;
  75.    case GPIO_PIN_3:
  76.     io_num = 3;
  77.    break;
  78.    case GPIO_PIN_4:
  79.     io_num = 4;
  80.    break;
  81.     case GPIO_PIN_5:
  82.     io_num = 5;
  83.    break;
  84.    case GPIO_PIN_6:
  85.     io_num = 6;
  86.    break;
  87.    case GPIO_PIN_7:
  88.     io_num = 7;
  89.    break;
  90.    case GPIO_PIN_8:
  91.     io_num = 8;
  92.    break;
  93.    case GPIO_PIN_9:
  94.     io_num = 9;
  95.    break;
  96.    case GPIO_PIN_10:
  97.     io_num = 10;
  98.    break;
  99.    case GPIO_PIN_11:
  100.     io_num = 11;
  101.    break;
  102.    case GPIO_PIN_12:
  103.     io_num = 12;
  104.    break;
  105.    case GPIO_PIN_13:
  106.     io_num = 13;
  107.    break;
  108.    case GPIO_PIN_14:
  109.     io_num = 14;
  110.    break;
  111.    case GPIO_PIN_15:
  112.     io_num = 15;
  113.    break;
  114.   }
  115.   IIC_Type_t->GPIOx_SDA->MODER&=~(3<<(io_num*2)); //将GPIOx_SDA->GPIO_SDA清零
  116.   IIC_Type_t->GPIOx_SDA->MODER|=1<<(io_num*2);   //将GPIOx_SDA->GPIO_SDA设置为输出模式
  117. }
  118. //设置SCL电平
  119. static void IIC_SCL(const struct IIC_Type* IIC_Type_t,int n)
  120. {
  121.   if(n == 1)
  122.   {
  123.     HAL_GPIO_WritePin(IIC_Type_t->GPIOx_SCL,IIC_Type_t->GPIO_SCL,GPIO_PIN_SET);     //设置SCL为高电平
  124.   }
  125.   else{
  126.     HAL_GPIO_WritePin(IIC_Type_t->GPIOx_SCL,IIC_Type_t->GPIO_SCL,GPIO_PIN_RESET);     //设置SCL为低电平
  127.   }
  128. }
  129. //设置SDA电平
  130. static void IIC_SDA(const struct IIC_Type* IIC_Type_t,int n)
  131. {
  132.   if(n == 1)
  133.   {
  134.     HAL_GPIO_WritePin(IIC_Type_t->GPIOx_SDA,IIC_Type_t->GPIO_SDA,GPIO_PIN_SET);     //设置SDA为高电平
  135.   }
  136.   else{
  137.     HAL_GPIO_WritePin(IIC_Type_t->GPIOx_SDA,IIC_Type_t->GPIO_SDA,GPIO_PIN_RESET);     //设置SDA为低电平
  138.   }
  139. }
  140. //读取SDA电平
  141. static uint8_t READ_SDA(const struct IIC_Type* IIC_Type_t)
  142. {
  143.   return HAL_GPIO_ReadPin(IIC_Type_t->GPIOx_SDA,IIC_Type_t->GPIO_SDA);  //读取SDA电平
  144. }
  145. //IIC初始化
  146. static void IIC_Init_t(const struct IIC_Type* IIC_Type_t)
  147. {
  148.       GPIO_InitTypeDef GPIO_Initure;
  149.    
  150.    //根据GPIO组初始化GPIO时钟
  151.    if(IIC_Type_t->GPIOx_SCL == GPIOA || IIC_Type_t->GPIOx_SDA == GPIOA)
  152.    {
  153.      __HAL_RCC_GPIOA_CLK_ENABLE();   //使能GPIOA时钟
  154.    }
  155.    if(IIC_Type_t->GPIOx_SCL == GPIOB || IIC_Type_t->GPIOx_SDA == GPIOB)
  156.    {
  157.      __HAL_RCC_GPIOB_CLK_ENABLE();   //使能GPIOB时钟
  158.    }
  159.    if(IIC_Type_t->GPIOx_SCL == GPIOC || IIC_Type_t->GPIOx_SDA == GPIOC)
  160.    {
  161.      __HAL_RCC_GPIOC_CLK_ENABLE();   //使能GPIOC时钟
  162.    }
  163.    if(IIC_Type_t->GPIOx_SCL == GPIOD || IIC_Type_t->GPIOx_SDA == GPIOD)
  164.    {
  165.      __HAL_RCC_GPIOD_CLK_ENABLE();   //使能GPIOD时钟
  166.    }
  167.    if(IIC_Type_t->GPIOx_SCL == GPIOE || IIC_Type_t->GPIOx_SDA == GPIOE)
  168.    {
  169.      __HAL_RCC_GPIOE_CLK_ENABLE();   //使能GPIOE时钟
  170.    }
  171.    if(IIC_Type_t->GPIOx_SCL == GPIOH || IIC_Type_t->GPIOx_SDA == GPIOH)
  172.    {
  173.      __HAL_RCC_GPIOH_CLK_ENABLE();   //使能GPIOH时钟
  174.    }     
  175.    
  176.      //GPIO_SCL初始化设置
  177.      GPIO_Initure.Pin=IIC_Type_t->GPIO_SCL;
  178.      GPIO_Initure.Mode=GPIO_MODE_OUTPUT_PP;  //推挽输出
  179.      GPIO_Initure.Pull=GPIO_PULLUP;          //上拉
  180.      GPIO_Initure.Speed=GPIO_SPEED_FREQ_VERY_HIGH;    //快速
  181.      HAL_GPIO_Init(IIC_Type_t->GPIOx_SCL,&GPIO_Initure);
  182.      //GPIO_SDA初始化设置
  183.      GPIO_Initure.Pin=IIC_Type_t->GPIO_SDA;
  184.      GPIO_Initure.Mode=GPIO_MODE_OUTPUT_PP;  //推挽输出
  185.      GPIO_Initure.Pull=GPIO_PULLUP;          //上拉
  186.      GPIO_Initure.Speed=GPIO_SPEED_FREQ_VERY_HIGH;    //快速
  187.      HAL_GPIO_Init(IIC_Type_t->GPIOx_SDA,&GPIO_Initure);
  188.      
  189.             //SCL与SDA的初始化均为高电平
  190.       IIC_SCL(IIC_Type_t,1);
  191.        IIC_SDA(IIC_Type_t,1);
  192. }
  193. //IIC Start
  194. static void IIC_Start_t(const struct IIC_Type* IIC_Type_t)
  195. {
  196.   SDA_OUT(IIC_Type_t);      //sda线输出
  197.   IIC_SDA(IIC_Type_t,1);      
  198.   IIC_SCL(IIC_Type_t,1);
  199.   IIC_Type_t->delay_us(4);
  200.    IIC_SDA(IIC_Type_t,0);  //START:when CLK is high,DATA change form high to low
  201.   IIC_Type_t->delay_us(4);
  202.   IIC_SCL(IIC_Type_t,0);  //钳住I2C总线，准备发送或接收数据
  203. }
  204. //IIC Stop
  205. static void IIC_Stop_t(const struct IIC_Type* IIC_Type_t)
  206. {
  207.   SDA_OUT(IIC_Type_t); //sda线输出
  208.   IIC_SCL(IIC_Type_t,0);
  209.   IIC_SDA(IIC_Type_t,0); //STOP:when CLK is high DATA change form low to high
  210.    IIC_Type_t->delay_us(4);
  211.   IIC_SCL(IIC_Type_t,1);
  212.   IIC_SDA(IIC_Type_t,1); //发送I2C总线结束信号
  213.   IIC_Type_t->delay_us(4);
  214. }
  215. //IIC_Wait_ack 返回HAL_OK表示wait成功，返回HAL_ERROR表示wait失败
  216. static uint8_t IIC_Wait_Ack_t(const struct IIC_Type* IIC_Type_t)   //IIC_Wait_ack,返回wait失败或是成功
  217. {
  218.   uint8_t ucErrTime = 0;
  219.   SDA_IN(IIC_Type_t);      //SDA设置为输入  
  220.   IIC_SDA(IIC_Type_t,1);IIC_Type_t->delay_us(1);   
  221.   IIC_SCL(IIC_Type_t,1);IIC_Type_t->delay_us(1);
  222.   while(READ_SDA(IIC_Type_t))
  223.   {
  224.     ucErrTime++;
  225.     if(ucErrTime>250)
  226.     {
  227.       IIC_Type_t->IIC_Stop(IIC_Type_t);
  228.       return HAL_ERROR;
  229.     }
  230.   }
  231.   IIC_SCL(IIC_Type_t,0);//时钟输出0     
  232.   return HAL_OK;  
  233. }
  234. //产生ACK应答
  235. static void IIC_Ack_t(const struct IIC_Type* IIC_Type_t)      
  236. {
  237.   IIC_SCL(IIC_Type_t,0);
  238.   SDA_OUT(IIC_Type_t);
  239.   IIC_SDA(IIC_Type_t,0);
  240.   IIC_Type_t->delay_us(2);  
  241.   IIC_SCL(IIC_Type_t,1);
  242.   IIC_Type_t->delay_us(2);  
  243.   IIC_SCL(IIC_Type_t,0);
  244. }
  245. //产生NACK应答
  246. static void IIC_NAck_t(const struct IIC_Type* IIC_Type_t)      
  247. {
  248.   IIC_SCL(IIC_Type_t,0);
  249.   SDA_OUT(IIC_Type_t);
  250.   IIC_SDA(IIC_Type_t,1);
  251.   IIC_Type_t->delay_us(2);  
  252.   IIC_SCL(IIC_Type_t,1);
  253.   IIC_Type_t->delay_us(2);  
  254.   IIC_SCL(IIC_Type_t,0);
  255. }
  256. //IIC_Send_Byte，入口参数为要发送的字节
  257. static void IIC_Send_Byte_t(const struct IIC_Type* IIC_Type_t,uint8_t txd)     
  258. {
  259.      uint8_t t = 0;   
  260.      SDA_OUT(IIC_Type_t);      
  261.      IIC_SCL(IIC_Type_t,0);//拉低时钟开始数据传输
  262.      for(t=0;t<8;t++)
  263.      {              
  264.           IIC_SDA(IIC_Type_t,(txd&0x80)>>7);
  265.           txd <<= 1;   
  266.        IIC_Type_t->delay_us(2);     //对TEA5767这三个延时都是必须的
  267.        IIC_SCL(IIC_Type_t,1);
  268.        IIC_Type_t->delay_us(2);  
  269.        IIC_SCL(IIC_Type_t,0);
  270.        IIC_Type_t->delay_us(2);  
  271.      }  
  272. }
  273. //IIC_Send_Byte，入口参数为是否要发送ACK信号
  274. static uint8_t IIC_Read_Byte_t(const struct IIC_Type* IIC_Type_t,uint8_t ack)     
  275. {
  276.    uint8_t i,receive = 0;
  277.    SDA_IN(IIC_Type_t);//SDA设置为输入
  278.    for(i=0;i<8;i++ )
  279.    {
  280.       IIC_SCL(IIC_Type_t,0);
  281.       IIC_Type_t->delay_us(2);
  282.       IIC_SCL(IIC_Type_t,1);
  283.       receive<<=1;
  284.       if(READ_SDA(IIC_Type_t))receive++;   
  285.       IIC_Type_t->delay_us(1);
  286.    }      
  287.   if (!ack)
  288.          IIC_Type_t->IIC_NAck(IIC_Type_t);//发送nACK
  289.   else
  290.          IIC_Type_t->IIC_Ack(IIC_Type_t); //发送ACK   
  291.   return receive;
  292. }
  293. //实例化一个IIC1外设，相当于一个结构体变量，可以直接在其他文件中使用
  294. IIC_TypeDef IIC1 = {
  295.   .GPIOx_SCL = GPIOA,   //GPIO组为GPIOA
  296.   .GPIOx_SDA = GPIOA,   //GPIO组为GPIOA
  297.   .GPIO_SCL = GPIO_PIN_5,   //GPIO为PIN5
  298.   .GPIO_SDA = GPIO_PIN_6,  //GPIO为PIN6
  299.   .IIC_Init = IIC_Init_t,
  300.   .IIC_Start = IIC_Start_t,
  301.   .IIC_Stop = IIC_Stop_t,
  302.   .IIC_Wait_Ack = IIC_Wait_Ack_t,
  303.   .IIC_Ack = IIC_Ack_t,
  304.   .IIC_NAck = IIC_NAck_t,
  305.   .IIC_Send_Byte = IIC_Send_Byte_t,
  306.   .IIC_Read_Byte = IIC_Read_Byte_t,
  307.   .delay_us = delay_us     //需自己外部实现delay_us函数
  308. };
复制代码
上述就是IIC驱动的封装，由于没有应用场景暂不测试其实用性，待下面ATC64的驱动缝缝扎黄写完之后一起测试使用。


ATC64XX驱动封装实现
    at24cxx.h头文件主要是类模板的定义，具体如下：

  1. // 以下是共定义个具体容量存储器的容量
  2. #define AT24C01  127
  3. #define AT24C02  255
  4. #define AT24C04  511
  5. #define AT24C08  1023
  6. #define AT24C16  2047
  7. #define AT24C32  4095
  8. #define AT24C64   8191         //8KBytes
  9. #define AT24C128 16383
  10. #define AT24C256 32767  

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

  29. extern AT24CXX_TypeDef AT24C_64;     //外部声明实例化AT24CXX对象
复制代码
at24cxx.c源文件主要是类模板具体操作函数的实现，具体如下：
  1. //在AT24CXX指定地址读出一个数据
  2. //ReadAddr:开始读数的地址  
  3. //返回值  :读到的数据
  4. static uint8_t AT24CXX_ReadOneByte_t(const struct AT24CXX_Type* AT24CXX_Type_t,uint16_t ReadAddr)
  5. {      
  6.   uint8_t temp=0;                          
  7.   AT24CXX_Type_t->IIC.IIC_Start(&AT24CXX_Type_t->IIC);  
  8.   //根据AT的型号发送不同的地址
  9.   if(AT24CXX_Type_t->EEP_TYPE > AT24C16)
  10.   {
  11.     AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,0XA0);    //发送写命令
  12.     AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);
  13.     AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,ReadAddr>>8);//发送高地址     
  14.   }else AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,0XA0+((ReadAddr/256)<<1));   //发送器件地址0XA0,写数据     
  15.   AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);
  16.   AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,ReadAddr%256);   //发送低地址
  17.   AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);     
  18.   AT24CXX_Type_t->IIC.IIC_Start(&AT24CXX_Type_t->IIC);        
  19.   AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,0XA1);           //进入接收模式      
  20.   AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);  
  21.   temp=AT24CXX_Type_t->IIC.IIC_Read_Byte(&AT24CXX_Type_t->IIC,0);     
  22.   AT24CXX_Type_t->IIC.IIC_Stop(&AT24CXX_Type_t->IIC);//产生一个停止条件     
  23.   return temp;
  24. }
  25. //在AT24CXX指定地址写入一个数据
  26. //WriteAddr  :写入数据的目的地址   
  27. //DataToWrite:要写入的数据
  28. static void AT24CXX_WriteOneByte_t(const struct AT24CXX_Type* AT24CXX_Type_t,uint16_t WriteAddr,uint8_t DataToWrite)
  29. {                                
  30.    AT24CXX_Type_t->IIC.IIC_Start(&AT24CXX_Type_t->IIC);   
  31.   if(AT24CXX_Type_t->EEP_TYPE > AT24C16)
  32.   {
  33.     AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,0XA0);    //发送写命令
  34.     AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);
  35.     AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,WriteAddr>>8);//发送高地址     
  36.   }else AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,0XA0+((WriteAddr/256)<<1));   //发送器件地址0XA0,写数据     
  37.   AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);
  38.    AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,WriteAddr%256);   //发送低地址
  39.   AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);               
  40.   AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,DataToWrite);     //发送字节         
  41.   AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);            
  42.    AT24CXX_Type_t->IIC.IIC_Stop(&AT24CXX_Type_t->IIC);//产生一个停止条件
  43. AT24CXX_Type_t->IIC.delay_us(10000);  
  44. }
  45. //在AT24CXX里面的指定地址开始写入长度为Len的数据
  46. //该函数用于写入16bit或者32bit的数据.
  47. //WriteAddr  :开始写入的地址  
  48. //DataToWrite:数据数组首地址
  49. //Len        :要写入数据的长度2,4
  50. static void AT24CXX_WriteLenByte_t(uint16_t WriteAddr,uint32_t DataToWrite,uint8_t Len)
  51. {   
  52.   uint8_t t;
  53.   for(t=0;t<Len;t++)
  54.   {
  55.     AT24CXX_WriteOneByte(WriteAddr+t,(DataToWrite>>(8*t))&0xff);
  56.   }               
  57. }
  58. //在AT24CXX里面的指定地址开始读出长度为Len的数据
  59. //该函数用于读出16bit或者32bit的数据.
  60. //ReadAddr   :开始读出的地址
  61. //返回值     :数据
  62. //Len        :要读出数据的长度2,4
  63. static uint32_t AT24CXX_ReadLenByte_t(uint16_t ReadAddr,uint8_t Len)
  64. {   
  65.   uint8_t t;
  66.   uint32_t temp=0;
  67.   for(t=0;t<Len;t++)
  68.   {
  69.     temp<<=8;
  70.      temp+=AT24CXX_ReadOneByte(ReadAddr+Len-t-1);         
  71.   }
  72.   return temp;               
  73. }
  74. //在AT24CXX里面的指定地址开始写入指定个数的数据
  75. //WriteAddr :开始写入的地址 对24c64为0~8191
  76. //pBuffer   :数据数组首地址
  77. //NumToWrite:要写入数据的个数
  78. static void AT24CXX_Write_t(uint16_t WriteAddr,uint8_t *pBuffer,uint16_t NumToWrite)
  79. {
  80.   while(NumToWrite--)
  81.   {
  82.    AT24CXX_WriteOneByte(WriteAddr,*pBuffer);
  83.     WriteAddr++;
  84.     pBuffer++;
  85.   }
  86. }
  87. //在AT24CXX里面的指定地址开始读出指定个数的数据
  88. //ReadAddr :开始读出的地址 对24c64为0~8191
  89. //pBuffer  :数据数组首地址
  90. //NumToRead:要读出数据的个数
  91. static void AT24CXX_Read_t(uint16_t ReadAddr,uint8_t *pBuffer,uint16_t NumToRead)
  92. {
  93.   while(NumToRead)
  94.   {
  95.     *pBuffer++=AT24CXX_ReadOneByte(ReadAddr++);
  96.     NumToRead--;
  97.   }
  98. }
  99. //初始化IIC接口
  100. static void AT24CXX_Init_t(const struct AT24CXX_Type* AT24CXX_Type_t)
  101. {
  102.   AT24CXX_Type_t->IIC.IIC_Init(&AT24CXX_Type_t->IIC);//IIC初始化
  103. }
  104. //检查器件,返回0表示检测成功,返回1表示检测失败
  105. static uint8_t AT24CXX_Check_t(const struct AT24CXX_Type* AT24CXX_Type_t)   
  106. {
  107. uint8_t temp;
  108.   temp = AT24CXX_Type_t->AT24CXX_ReadOneByte(AT24CXX_Type_t,AT24CXX_Type_t->EEP_TYPE);//避免每次开机都写AT24CXX      
  109.   if(temp == 0X33)return 0;     
  110.   else//排除第一次初始化的情况
  111.   {
  112.       AT24CXX_Type_t->AT24CXX_WriteOneByte(AT24CXX_Type_t,AT24CXX_Type_t->EEP_TYPE,0X33);
  113.        temp = AT24CXX_Type_t->AT24CXX_ReadOneByte(AT24CXX_Type_t,AT24CXX_Type_t->EEP_TYPE);
  114.       if(temp==0X33)return 0;
  115.   }
  116.   return 1;  
  117. }
  118. //实例化AT24CXX对象
  119. AT24CXX_TypeDef AT24C_64={
  120. .EEP_TYPE = AT24C64,           //存储器类型（存储器容量）
  121. //操作
  122. .IIC={
  123.   .GPIOx_SCL = GPIOA,
  124.   .GPIOx_SDA = GPIOA,
  125.   .GPIO_SCL = GPIO_PIN_5,
  126.   .GPIO_SDA = GPIO_PIN_6,
  127.   .IIC_Init = IIC_Init_t,
  128.   .IIC_Start = IIC_Start_t,
  129.   .IIC_Stop = IIC_Stop_t,
  130.   .IIC_Wait_Ack = IIC_Wait_Ack_t,
  131.   .IIC_Ack = IIC_Ack_t,
  132.   .IIC_NAck = IIC_NAck_t,
  133.   .IIC_Send_Byte = IIC_Send_Byte_t,
  134.   .IIC_Read_Byte = IIC_Read_Byte_t,
  135.   .delay_us = delay_us
  136. },                   //IIC驱动
  137. .AT24CXX_ReadOneByte = AT24CXX_ReadOneByte_t,  //指定地址读取一个字节
  138. .AT24CXX_WriteOneByte = AT24CXX_WriteOneByte_t,//指定地址写入一个字节
  139. .AT24CXX_WriteLenByte = AT24CXX_WriteLenByte_t, //指定地址开始写入指定长度的数据
  140. .AT24CXX_ReadLenByte = AT24CXX_ReadLenByte_t,   //指定地址开始读取指定长度数据
  141. .AT24CXX_Write = AT24CXX_Write_t,  //指定地址开始写入指定长度的数据
  142. .AT24CXX_Read = AT24CXX_Read_t,   //指定地址开始读取指定长度的数据
  143. .AT24CXX_Init = AT24CXX_Init_t, //初始化IIC
  144. .AT24CXX_Check = AT24CXX_Check_t   //检查器件
  145. };
复制代码
简单分析：可以看出AT24CXX类中包含了IIC类的成员对象，这是一种包含关系，因为没有属性上的一致性因此谈不上继承。


    之所以将IIC的类对象作为AT24CXX类的成员是因为AT24CXX的实现需要调用IIC的成员方法，IIC相当于AT24CXX更下层的驱动，因此采用包含关系更合适。


    因此我们在使用AT24CXX的时候只需要实例化AT24CXX类对象就行了，因为IIC包含在AT24CXX类中间，因此不需要实例化IIC类对象，对外提供了较好的封装接口。下面我们看具体的调用方法。


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


  2. #include "at24cxx.h"    //为了确定AT24C_64的成员方法和引用操作对象AT24C_64
  3. int main(void)
  4. {
  5.   /************省略其他初始化工作****************/
  6.   //第一步：调用对象初始化方法来初始化AT24C64
  7.   AT24C_64.AT24CXX_Init(&AT24C_64);
  8.   //第二步：调用对象检测方法来检测AT24C64           
  9.   if(AT24C_64.AT24CXX_Check(&AT24C_64) == 0)
  10.   {
  11.     printf("AT24C64检测成功\r\n");
  12.   }
  13.   else{
  14.     printf("AT24C64检测失败\r\n");
  15.   }
  16.   return 0;
  17. }
复制代码
可以看出所有的操作都是通过AT24C_64对象调用完成的，在我们初始化好AT24C_64对象之后就可以放心大胆的调用其成员方法，这样封装的好处就是一个设备对外只提供一个对象接口，简洁明了。


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



赞 收藏 评论0 发布时间：2021-6-21 14:39

举报

0个回答

所属标签

STM32团队

STM32团队

意法半导体微控制器和微处理器拥有广泛的产品线，包含低成本的8位单片机和基于ARM® Cortex®-M0、M0+、M3、M4、M33、M7及A7内核并具备丰富外设选择的32位微控制器及微处理器。关注该话题即可发布文章！

最新内容

关于
意法半导体
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
STM32N6 AI生态系统
STM32MCU,MPU高性能GUI
ST ACEPACK电源模块
意法半导体生物传感器
STM32Cube扩展软件包
关注我们
st-img 微信公众号
st-img 手机版