21ic电子技术开发论坛 › 单片机与嵌入式系统 › 雅特力AT32 MCU › 【AT-START-F425测评】使用面向对象实现模拟IIC驱动OLED ...
返回列表 发新帖我要提问

[活动专区] 【AT-START-F425测评】使用面向对象实现模拟IIC驱动OLED

[复制链接]
1381|0
 楼主| zhouminjie 发表于 2022-6-1 01:02 | 显示全部楼层 |阅读模式
I2c, 面向对象
#申请原创#
一、简介
使用面向的编程思想封装I2C驱动，将I2C属性、操作封装成库，在需要创建一个I2C设备时只需要实例化一个I2C对象，本文基于AT32F425和标准库做进一步封装。完成I2C驱动的封装后，依据继承特性实现OLED液晶屏的驱动开发及封装。
二、I2C驱动面向对象封装
hal_i2c.h头文件类定义如下：
复制
  1. #ifndef __HAL_I2C_H__
    

  2. #define __HAL_I2C_H__
    


  3. 

  4. #include "at32f425.h"
    


  5. 

  6. #define HAL_ERROR 0
    

  7. #define HAL_OK 1
    


  8. 

  9. //定义I2C类
    

  10. typedef struct I2C_Type
    

  11. {
    

  12.     //属性
    

  13.     gpio_type *GPIOx_SCL; //SCL所属gpio组,如:GPIOA
    

  14.     gpio_type *GPIOx_SDA; //SDA所属gpio组,如:GPIOA
    

  15.     unsigned int GPIO_SCL; //SCL引脚,如:GPIO_PINS_2
    

  16.     unsigned int GPIO_SDA; //SDA引脚,如:GPIO_PINS_2
    

  17.     //操作
    

  18.     void (*I2C_Init)(const struct I2C_Type*);
    

  19.     void (*I2C_Start)(const struct I2C_Type*);
    

  20.     void (*I2C_Stop)(const struct I2C_Type*);
    

  21.     unsigned char (*I2C_Wait_Ack)(const struct I2C_Type*);
    

  22.     void (*I2C_Ack)(const struct I2C_Type*);
    

  23.     void (*I2C_NAck)(const struct I2C_Type*);
    

  24.     void (*I2C_Send_Byte)(const struct I2C_Type*, unsigned char);
    

  25.     unsigned char (*I2C_Read_Byte)(const struct I2C_Type*, unsigned char);
    

  26.     void (*delay_us)(unsigned int);
    


  27. 

  28. } I2C_TypeDef;
    


  29. 

  30. extern I2C_TypeDef I2C_t;
    


  31. 

  32. #endif
hal_i2c.c文件具体操作函数如下：
复制
  1. #include "hal_i2c.h"
    

  2. #include "delay.h"
    


  3. 

  4. //设置SDA输入模式
    

  5. static void SDA_IN(const struct I2C_Type* I2C_Type_t)
    

  6. {
    

  7.     gpio_init_type gpio_init_struct;
    


  8. 

  9.     //GPIO_SDA初始化设置
    

  10.     gpio_init_struct.gpio_pins = I2C_Type_t->GPIO_SDA;
    

  11.     gpio_init_struct.gpio_mode = GPIO_MODE_INPUT;
    

  12.     gpio_init_struct.gpio_out_type = GPIO_OUTPUT_OPEN_DRAIN;
    

  13.     gpio_init_struct.gpio_pull = GPIO_PULL_UP;
    

  14.     gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
    

  15.     gpio_init(I2C_Type_t->GPIOx_SDA, &gpio_init_struct);
    

  16. }
    


  17. 

  18. //设置SDA为输出模式
    

  19. static void SDA_OUT(const struct I2C_Type* I2C_Type_t)
    

  20. {
    

  21.     gpio_init_type gpio_init_struct;
    


  22. 

  23.     //GPIO_SDA初始化设置
    

  24.     gpio_init_struct.gpio_pins = I2C_Type_t->GPIO_SDA;
    

  25.     gpio_init_struct.gpio_mode = GPIO_MODE_OUTPUT;
    

  26.     gpio_init_struct.gpio_out_type = GPIO_OUTPUT_OPEN_DRAIN;
    

  27.     gpio_init_struct.gpio_pull = GPIO_PULL_UP;
    

  28.     gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
    

  29.     gpio_init(I2C_Type_t->GPIOx_SDA, &gpio_init_struct);
    

  30. }
    


  31. 

  32. //设置SCL电平
    

  33. static void I2C_SCL(const struct I2C_Type* I2C_Type_t, int n)
    

  34. {
    

  35.     if(n == 1)
    

  36.     {
    

  37.         gpio_bits_write(I2C_Type_t->GPIOx_SCL, I2C_Type_t->GPIO_SCL, TRUE); //设置SCL为高电平
    

  38.     }
    

  39.     else
    

  40.     {
    

  41.         gpio_bits_write(I2C_Type_t->GPIOx_SCL, I2C_Type_t->GPIO_SCL, FALSE); //设置SCL为低电平
    

  42.     }
    

  43. }
    


  44. 

  45. //设置SDA电平
    

  46. static void I2C_SDA(const struct I2C_Type* I2C_Type_t, int n)
    

  47. {
    

  48.     if(n == 1)
    

  49.     {
    

  50.         gpio_bits_write(I2C_Type_t->GPIOx_SDA, I2C_Type_t->GPIO_SDA, TRUE); //设置SDA为高电平
    

  51.     }
    

  52.     else
    

  53.     {
    

  54.         gpio_bits_write(I2C_Type_t->GPIOx_SDA, I2C_Type_t->GPIO_SDA, FALSE); //设置SDA为低电平
    

  55.     }
    

  56. }
    


  57. 

  58. //读取SDA电平
    

  59. static unsigned char READ_SDA(const struct I2C_Type* I2C_Type_t)
    

  60. {
    

  61.     return gpio_input_data_bit_read(I2C_Type_t->GPIOx_SDA, I2C_Type_t->GPIO_SDA); //读取SDA电平
    

  62. }
    


  63. 

  64. //I2C初始化
    

  65. static void I2C_Init_t(const struct I2C_Type* I2C_Type_t)
    

  66. {
    

  67.     gpio_init_type gpio_init_struct;
    


  68. 

  69.     //根据GPIO组初始化GPIO时钟
    

  70.     if(I2C_Type_t->GPIOx_SCL == GPIOA || I2C_Type_t->GPIOx_SDA == GPIOA)
    

  71.     {
    

  72.         crm_periph_clock_enable(CRM_GPIOA_PERIPH_CLOCK, TRUE); //使能GPIOA时钟
    

  73.     }
    


  74. 

  75.     if(I2C_Type_t->GPIOx_SCL == GPIOB || I2C_Type_t->GPIOx_SDA == GPIOB)
    

  76.     {
    

  77.         crm_periph_clock_enable(CRM_GPIOB_PERIPH_CLOCK, TRUE); //使能GPIOB时钟
    

  78.     }
    


  79. 

  80.     if(I2C_Type_t->GPIOx_SCL == GPIOC || I2C_Type_t->GPIOx_SDA == GPIOC)
    

  81.     {
    

  82.         crm_periph_clock_enable(CRM_GPIOC_PERIPH_CLOCK, TRUE); //使能GPIOC时钟
    

  83.     }
    


  84. 

  85.     if(I2C_Type_t->GPIOx_SCL == GPIOD || I2C_Type_t->GPIOx_SDA == GPIOD)
    

  86.     {
    

  87.         crm_periph_clock_enable(CRM_GPIOD_PERIPH_CLOCK, TRUE); //使能GPIOD时钟
    

  88.     }
    


  89. 

  90.     if(I2C_Type_t->GPIOx_SCL == GPIOF || I2C_Type_t->GPIOx_SDA == GPIOF)
    

  91.     {
    

  92.         crm_periph_clock_enable(CRM_GPIOF_PERIPH_CLOCK, TRUE); //使能GPIOF时钟
    

  93.     }
    


  94. 

  95.     //GPIO_SCL初始化设置
    

  96.     gpio_init_struct.gpio_pins = I2C_Type_t->GPIO_SCL;
    

  97.     gpio_init_struct.gpio_mode = GPIO_MODE_OUTPUT; //gpio output mode
    

  98.     gpio_init_struct.gpio_out_type = GPIO_OUTPUT_OPEN_DRAIN; //output open-drain
    

  99.     gpio_init_struct.gpio_pull = GPIO_PULL_UP; //pull-up
    

  100.     gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER; //stronger sourcing/sinking strength
    

  101.     gpio_init(I2C_Type_t->GPIOx_SCL, &gpio_init_struct);
    

  102.     //GPIO_SDA初始化设置
    

  103.     gpio_init_struct.gpio_pins = I2C_Type_t->GPIO_SDA;
    

  104.     gpio_init_struct.gpio_mode = GPIO_MODE_OUTPUT;
    

  105.     gpio_init_struct.gpio_out_type = GPIO_OUTPUT_OPEN_DRAIN; //output open-drain
    

  106.     gpio_init_struct.gpio_pull = GPIO_PULL_UP;
    

  107.     gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
    

  108.     gpio_init(I2C_Type_t->GPIOx_SDA, &gpio_init_struct);
    

  109.     //SCL、SDA的初始化均为高电平
    

  110.     I2C_SCL(I2C_Type_t, 1);
    

  111.     I2C_SDA(I2C_Type_t, 1);
    

  112. }
    


  113. 

  114. //I2C Start
    

  115. static void I2C_Start_t(const struct I2C_Type* I2C_Type_t)
    

  116. {
    

  117.     SDA_OUT(I2C_Type_t);
    

  118.     I2C_SDA(I2C_Type_t, 1);
    

  119.     I2C_SCL(I2C_Type_t, 1);
    

  120.     I2C_Type_t->delay_us(4);
    

  121.     I2C_SDA(I2C_Type_t, 0); //START:when CLK is high,DATA change form high to low
    

  122.     I2C_Type_t->delay_us(4);
    

  123.     I2C_SCL(I2C_Type_t, 0); //钳住I2C总线,准备发送或接收数据
    

  124. }
    


  125. 

  126. //I2C Stop
    

  127. static void I2C_Stop_t(const struct I2C_Type* I2C_Type_t)
    

  128. {
    

  129.     SDA_OUT(I2C_Type_t);
    

  130.     I2C_SCL(I2C_Type_t, 0);
    

  131.     I2C_SDA(I2C_Type_t, 0); //STOP:when CLK is high DATA change form low to high
    

  132.     I2C_Type_t->delay_us(4);
    

  133.     I2C_SCL(I2C_Type_t, 1);
    

  134.     I2C_SDA(I2C_Type_t, 1); //发送I2C总线结束信号
    

  135.     I2C_Type_t->delay_us(4);
    

  136. }
    


  137. 

  138. //I2C_Wait_ack 返回HAL_OK表示wait成功,返回HAL_ERROR表示wait失败
    

  139. static unsigned char I2C_Wait_Ack_t(const struct I2C_Type* I2C_Type_t) //IIC_Wait_ack,返回wait失败或是成功
    

  140. {
    

  141.     unsigned char ucErrTime = 0;
    


  142. 

  143.     SDA_IN(I2C_Type_t);
    

  144.     I2C_SDA(I2C_Type_t, 1);
    

  145.     I2C_Type_t->delay_us(1);
    

  146.     I2C_SCL(I2C_Type_t, 1);
    

  147.     I2C_Type_t->delay_us(1);
    


  148. 

  149.     while(READ_SDA(I2C_Type_t))
    

  150.     {
    

  151.         ucErrTime++;
    


  152. 

  153.         if(ucErrTime > 250)
    

  154.         {
    

  155.             I2C_Type_t->I2C_Stop(I2C_Type_t);
    

  156.             return HAL_ERROR;
    

  157.         }
    

  158.     }
    


  159. 

  160.     I2C_SCL(I2C_Type_t, 0);
    

  161.     return HAL_OK;
    

  162. }
    


  163. 

  164. //产生ACK应答
    

  165. static void I2C_Ack_t(const struct I2C_Type* I2C_Type_t)
    

  166. {
    

  167.     I2C_SCL(I2C_Type_t, 0);
    

  168.     SDA_OUT(I2C_Type_t);
    

  169.     I2C_SDA(I2C_Type_t, 0);
    

  170.     I2C_Type_t->delay_us(2);
    

  171.     I2C_SCL(I2C_Type_t, 1);
    

  172.     I2C_Type_t->delay_us(2);
    

  173.     I2C_SCL(I2C_Type_t, 0);
    

  174. }
    


  175. 

  176. //产生NACK应答
    

  177. static void I2C_NAck_t(const struct I2C_Type* I2C_Type_t)
    

  178. {
    

  179.     I2C_SCL(I2C_Type_t, 0);
    

  180.     SDA_OUT(I2C_Type_t);
    

  181.     I2C_SDA(I2C_Type_t, 1);
    

  182.     I2C_Type_t->delay_us(2);
    

  183.     I2C_SCL(I2C_Type_t, 1);
    

  184.     I2C_Type_t->delay_us(2);
    

  185.     I2C_SCL(I2C_Type_t, 0);
    

  186. }
    


  187. 

  188. //I2C_Send_Byte,入口参数为要发送的字节
    

  189. static void I2C_Send_Byte_t(const struct I2C_Type* I2C_Type_t, unsigned char txd)
    

  190. {
    

  191.     unsigned char cnt = 0;
    


  192. 

  193.     SDA_OUT(I2C_Type_t);
    

  194.     I2C_SCL(I2C_Type_t, 0);
    


  195. 

  196.     for(cnt = 0; cnt < 8; cnt++)
    

  197.     {
    

  198.         I2C_SDA(I2C_Type_t, (txd & 0x80) >> 7);
    

  199.         txd <<= 1;
    

  200.         //I2C_Type_t->delay_us(2); //OLED显示刷新慢,取消延时
    

  201.         I2C_SCL(I2C_Type_t, 1);
    

  202.         //I2C_Type_t->delay_us(2);
    

  203.         I2C_SCL(I2C_Type_t, 0);
    

  204.         //I2C_Type_t->delay_us(2);
    

  205.     }
    

  206. }
    


  207. 

  208. //I2C_Read_Byte,入口参数为是否要发送ACK信号
    

  209. static unsigned char I2C_Read_Byte_t(const struct I2C_Type* I2C_Type_t, unsigned char ack)
    

  210. {
    

  211.     unsigned char cnt, rec = 0;
    


  212. 

  213.     SDA_IN(I2C_Type_t);
    


  214. 

  215.     for(cnt = 0; cnt < 8; cnt++)
    

  216.     {
    

  217.         I2C_SCL(I2C_Type_t, 0);
    

  218.         //I2C_Type_t->delay_us(2);
    

  219.         I2C_SCL(I2C_Type_t, 1);
    

  220.         rec <<= 1;
    


  221. 

  222.         if(READ_SDA(I2C_Type_t))
    

  223.         {
    

  224.             rec++;
    

  225.         }
    


  226. 

  227.         //I2C_Type_t->delay_us(1);
    

  228.     }
    


  229. 

  230.     if(!ack)
    

  231.     {
    

  232.         I2C_Type_t->I2C_NAck(I2C_Type_t);
    

  233.     }
    

  234.     else
    

  235.     {
    

  236.         I2C_Type_t->I2C_Ack(I2C_Type_t);
    

  237.     }
    


  238. 

  239.     return rec;
    

  240. }
    


  241. 

  242. //实例化一个I2C外设,相当于一个结构体变量,可以直接在其他文件中使用
    

  243. I2C_TypeDef I2C_t =
    

  244. {
    

  245.     .GPIOx_SCL = GPIOF, //GPIO组为GPIOF
    

  246.     .GPIOx_SDA = GPIOF, //GPIO组为GPIOF
    

  247.     .GPIO_SCL = GPIO_PINS_5, //GPIO为PIN5
    

  248.     .GPIO_SDA = GPIO_PINS_4, //GPIO为PIN4
    

  249.     .I2C_Init = I2C_Init_t,
    

  250.     .I2C_Start = I2C_Start_t,
    

  251.     .I2C_Stop = I2C_Stop_t,
    

  252.     .I2C_Wait_Ack = I2C_Wait_Ack_t,
    

  253.     .I2C_Ack = I2C_Ack_t,
    

  254.     .I2C_NAck = I2C_NAck_t,
    

  255.     .I2C_Send_Byte = I2C_Send_Byte_t,
    

  256.     .I2C_Read_Byte = I2C_Read_Byte_t,
    

  257.     .delay_us = Delay_Us, //需自己外部实现delay_us函数
    

  258. };
三、0.96OLED驱动封装
hal_0.96oled.h头文件类定义如下：
复制
  1. #ifndef __HAL_096OLED_H__
    

  2. #define __HAL_096OLED_H__
    


  3. 

  4. #include "hal_i2c.h"
    


  5. 

  6. //定义0.96OLED类
    

  7. typedef struct OLED_Type
    

  8. {
    

  9.     //属性
    

  10.     //操作
    

  11.     I2C_TypeDef *I2C; //
    

  12.     void (*OLED_Write_CMD)(const struct OLED_Type*, unsigned char); //向设备写命令
    

  13.     void (*OLED_Write_Date)(const struct OLED_Type*, unsigned char); //向设备写数据
    

  14.     void (*OLED_Set_Pos)(const struct OLED_Type*, unsigned char, unsigned char); //坐标设置
    

  15.     void (*OLED_Display_On)(const struct OLED_Type*); //开启OLED显示
    

  16.     void (*OLED_Display_Off)(const struct OLED_Type*); //关闭OLED显示
    

  17.     void (*OLED_Clear)(const struct OLED_Type*); //OLED清屏
    

  18.     void (*OLED_Clear_Row)(const struct OLED_Type*, unsigned char); //OLED清行
    

  19.     void (*OLED_Fill)(const struct OLED_Type*); //OLED填满屏幕
    

  20.     void (*OLED_ShowChar)(const struct OLED_Type*, unsigned char, unsigned char, unsigned char, unsigned char); //指定位置显示一个字符
    

  21.     void (*OLED_ShowNum)(const struct OLED_Type*, unsigned char, unsigned char, unsigned int, unsigned char, unsigned char); //指定位置显示数字
    

  22.     void (*OLED_ShowString)(const struct OLED_Type*, unsigned char, unsigned char, unsigned char*, unsigned char); //指定位置显示字符串
    

  23.     void (*OLED_ShowCHinese)(const struct OLED_Type*, unsigned char, unsigned char, unsigned char); //显示汉字
    

  24.     void (*OLED_DrawBMP)(const struct OLED_Type* OLED_Type_t, unsigned char x0, unsigned char y0, unsigned char x1, unsigned char y1, unsigned char BMP[]); //显示图片
    

  25.     void (*OLED_DrawGIF)(const struct OLED_Type* OLED_Type_t, unsigned char x0, unsigned char y0, unsigned char x1, unsigned char y1, unsigned char k, int m, const unsigned char GIF[][m]); //显示动画
    

  26.     void (*OLED_Init)(const struct OLED_Type*); //初始化OLED
    


  27. 

  28. } OLED_TypeDef;
    


  29. 

  30. extern OLED_TypeDef _0_96OLED;
    


  31. 

  32. #endif
hal_0.96oled.c文件具体操作函数如下：
复制
  1. #include "hal_0.96oled.h"
    

  2. #include "oledfont.h"
    

  3. #include "delay.h"
    


  4. 

  5. //向设备写控制命令
    

  6. static void OLED_Write_CMD_t(const struct OLED_Type* OLED_Type_t, unsigned char cmd)
    

  7. {
    

  8.     OLED_Type_t->I2C->I2C_Start(OLED_Type_t->I2C);
    

  9.     OLED_Type_t->I2C->I2C_Send_Byte(OLED_Type_t->I2C, 0x78);
    

  10.     OLED_Type_t->I2C->I2C_Wait_Ack(OLED_Type_t->I2C);
    

  11.     OLED_Type_t->I2C->I2C_Send_Byte(OLED_Type_t->I2C, 0x00);
    

  12.     OLED_Type_t->I2C->I2C_Wait_Ack(OLED_Type_t->I2C);
    

  13.     OLED_Type_t->I2C->I2C_Send_Byte(OLED_Type_t->I2C, cmd);
    

  14.     OLED_Type_t->I2C->I2C_Wait_Ack(OLED_Type_t->I2C);
    

  15.     OLED_Type_t->I2C->I2C_Stop(OLED_Type_t->I2C);
    

  16. }
    


  17. 

  18. //向设备写数据
    

  19. static void OLED_Write_Date_t(const struct OLED_Type* OLED_Type_t, unsigned char date)
    

  20. {
    

  21.     OLED_Type_t->I2C->I2C_Start(OLED_Type_t->I2C);
    

  22.     OLED_Type_t->I2C->I2C_Send_Byte(OLED_Type_t->I2C, 0x78);
    

  23.     OLED_Type_t->I2C->I2C_Wait_Ack(OLED_Type_t->I2C);
    

  24.     OLED_Type_t->I2C->I2C_Send_Byte(OLED_Type_t->I2C, 0x40);
    

  25.     OLED_Type_t->I2C->I2C_Wait_Ack(OLED_Type_t->I2C);
    

  26.     OLED_Type_t->I2C->I2C_Send_Byte(OLED_Type_t->I2C, date);
    

  27.     OLED_Type_t->I2C->I2C_Wait_Ack(OLED_Type_t->I2C);
    

  28.     OLED_Type_t->I2C->I2C_Stop(OLED_Type_t->I2C);
    

  29. }
    


  30. 

  31. //坐标设置
    

  32. static void OLED_Set_Pos_t(const struct OLED_Type* OLED_Type_t, unsigned char x, unsigned char y)
    

  33. {
    

  34.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0xB0 + y);
    

  35.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, ((x & 0xF0) >> 4) | 0x10);
    

  36.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, x & 0x0F);
    

  37. }
    


  38. 

  39. //开启OLED显示
    

  40. static void OLED_Display_On_t(const struct OLED_Type* OLED_Type_t)
    

  41. {
    

  42.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0x8D); //SET DCDC命令
    

  43.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0x14); //DCDC ON
    

  44.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0xAF); //DISPLAY ON
    

  45. }
    


  46. 

  47. //关闭OLED显示
    

  48. static void OLED_Display_Off_t(const struct OLED_Type* OLED_Type_t)
    

  49. {
    

  50.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0x8D); //SET DCDC命令
    

  51.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0x10); //DCDC OFF
    

  52.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0xAE); //DISPLAY OFF
    

  53. }
    


  54. 

  55. //OLED清屏
    

  56. static void OLED_Clear_t(const struct OLED_Type* OLED_Type_t)
    

  57. {
    

  58.     unsigned char cnt, count;
    


  59. 

  60.     for(cnt = 0; cnt < 8; cnt++)
    

  61.     {
    

  62.         OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0xB0 + cnt);
    

  63.         OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0x00);
    

  64.         OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0x10);
    


  65. 

  66.         for(count = 0; count < 128; count++)
    

  67.         {
    

  68.             OLED_Type_t->OLED_Write_Date(OLED_Type_t, 0x00);
    

  69.         }
    

  70.     }
    

  71. }
    


  72. 

  73. //OLED清行
    

  74. static void OLED_Clear_Row_t(const struct OLED_Type* OLED_Type_t, unsigned char n)
    

  75. {
    

  76.     unsigned char count;
    


  77. 

  78.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0xB0 + n);
    

  79.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0x00);
    

  80.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0x10);
    


  81. 

  82.     for(count = 0; count < 128; count++)
    

  83.     {
    

  84.         OLED_Type_t->OLED_Write_Date(OLED_Type_t, 0x00);
    

  85.     }
    

  86. }
    


  87. 

  88. //OLED填满屏幕
    

  89. static void OLED_Fill_t(const struct OLED_Type* OLED_Type_t)
    

  90. {
    

  91.     unsigned char cnt, count;
    


  92. 

  93.     for(cnt = 0; cnt < 8; cnt++)
    

  94.     {
    

  95.         OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0xB0 + cnt); //设置页地址（0~7）
    

  96.         OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0x00); //设置显示位置—列低地址
    

  97.         OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0x10); //设置显示位置—列高地址
    


  98. 

  99.         for(count = 0; count < 128; count++)
    

  100.         {
    

  101.             OLED_Type_t->OLED_Write_Date(OLED_Type_t, 0x01);
    

  102.         }
    

  103.     }
    

  104. }
    


  105. 

  106. //指定位置显示一个字符
    

  107. //x:0~127
    

  108. //y:0~63
    

  109. //chr:字符
    

  110. //mode:0,反白显示;1,正常显示
    

  111. //size:选择字体 16/12
    

  112. static void OLED_ShowChar_t(const struct OLED_Type* OLED_Type_t, unsigned char x, unsigned char y, unsigned char chr, unsigned char size)
    

  113. {
    

  114.     unsigned char offset = 0, cnt = 0;
    


  115. 

  116.     offset = chr - ' '; //计算偏移量
    


  117. 

  118.     if(x > 128 - 1)
    

  119.     {
    

  120.         x = 0;
    

  121.         y = y + 2;
    

  122.     }
    


  123. 

  124.     if(size == 16)
    

  125.     {
    

  126.         OLED_Type_t->OLED_Set_Pos(OLED_Type_t, x, y);
    


  127. 

  128.         for(cnt = 0; cnt < 8; cnt++)
    

  129.         {
    

  130.             OLED_Type_t->OLED_Write_Date(OLED_Type_t, F8x16[offset * 16 + cnt]);
    

  131.         }
    


  132. 

  133.         OLED_Type_t->OLED_Set_Pos(OLED_Type_t, x, y + 1);
    


  134. 

  135.         for(cnt = 0; cnt < 8; cnt++)
    

  136.         {
    

  137.             OLED_Type_t->OLED_Write_Date(OLED_Type_t, F8x16[offset * 16 + cnt + 8]);
    

  138.         }
    

  139.     }
    

  140.     else
    

  141.     {
    

  142.         OLED_Type_t->OLED_Set_Pos(OLED_Type_t, x, y);
    


  143. 

  144.         for(cnt = 0; cnt < 6; cnt++)
    

  145.         {
    

  146.             OLED_Type_t->OLED_Write_Date(OLED_Type_t, F6x8[offset][cnt]);
    

  147.         }
    

  148.     }
    

  149. }
    


  150. 

  151. unsigned int oled_pow(unsigned char m, unsigned char n)
    

  152. {
    

  153.     unsigned int result = 1;
    


  154. 

  155.     while(n--)
    

  156.     {
    

  157.         result *= m;
    

  158.     }
    


  159. 

  160.     return result;
    

  161. }
    


  162. 

  163. //指定位置显示一个数字
    

  164. //x,y:起点坐标
    

  165. //num:数值(0~4294967295)
    

  166. //len:数字的位数
    

  167. //size:字体大小
    

  168. //mode:模式        0,填充模式;1,叠加模式
    

  169. static void OLED_ShowNum_t(const struct OLED_Type* OLED_Type_t, unsigned char x, unsigned char y, unsigned int num, unsigned char len, unsigned char size)
    

  170. {
    

  171.     unsigned char cnt, temp;
    

  172.     unsigned char show = 0;
    


  173. 

  174.     for(cnt = 0; cnt < len; cnt++)
    

  175.     {
    

  176.         temp = (num / oled_pow(10, len - cnt - 1)) % 10;
    


  177. 

  178.         if(show == 0 && cnt < (len - 1))
    

  179.         {
    

  180.             if(temp == 0)
    

  181.             {
    

  182.                 OLED_Type_t->OLED_ShowChar(OLED_Type_t, x + (size / 2) * cnt, y, ' ', size);
    

  183.                 continue;
    

  184.             }
    

  185.             else
    

  186.             {
    

  187.                 show = 1;
    

  188.             }
    

  189.         }
    


  190. 

  191.         OLED_Type_t->OLED_ShowChar(OLED_Type_t, x + (size / 2) * cnt, y, temp + '0', size);
    

  192.     }
    

  193. }
    


  194. 

  195. //指定位置显示字符串
    

  196. static void OLED_ShowString_t(const struct OLED_Type* OLED_Type_t, unsigned char x, unsigned char y, unsigned char *chr, unsigned char size)
    

  197. {
    

  198.     unsigned char cnt = 0;
    


  199. 

  200.     while(chr[cnt] != '\0')
    

  201.     {
    

  202.         OLED_Type_t->OLED_ShowChar(OLED_Type_t, x, y, chr[cnt], size);
    

  203.         x += 8;
    


  204. 

  205.         if(x > 120)
    

  206.         {
    

  207.             x = 0;
    

  208.             y += 2;
    

  209.         }
    


  210. 

  211.         cnt++;
    

  212.     }
    

  213. }
    


  214. 

  215. //显示汉字
    

  216. static void OLED_ShowCHinese_t(const struct OLED_Type* OLED_Type_t, unsigned char x, unsigned char y, unsigned char no)
    

  217. {
    

  218.     unsigned char cnt, addr = 0;
    


  219. 

  220.     OLED_Type_t->OLED_Set_Pos(OLED_Type_t, x, y);
    


  221. 

  222.     for(cnt = 0; cnt < 16; cnt++)
    

  223.     {
    

  224.         OLED_Type_t->OLED_Write_Date(OLED_Type_t, Hzk[2 * no][cnt]);
    

  225.         addr++;
    

  226.     }
    


  227. 

  228.     OLED_Type_t->OLED_Set_Pos(OLED_Type_t, x, y + 1);
    


  229. 

  230.     for(cnt = 0; cnt < 16; cnt++)
    

  231.     {
    

  232.         OLED_Type_t->OLED_Write_Date(OLED_Type_t, Hzk[2 * no + 1][cnt]);
    

  233.         addr++;
    

  234.     }
    

  235. }
    


  236. 

  237. //显示图片
    

  238. /*
    

  239.         @brief                        显示图片
    

  240.         @param                        x0：起始列地址
    

  241.                                         y0：起始页地址
    

  242.                                         x1：终止列地址
    

  243.                                         y1：终止页地址
    

  244.                                         BMP[]：存放图片代码的数组
    

  245.         @retval                        无
    

  246.  */
    

  247. static void OLED_DrawBMP_t(const struct OLED_Type* OLED_Type_t, unsigned char x0, unsigned char y0, unsigned char x1, unsigned char y1, unsigned char BMP[])
    

  248. {
    

  249.     unsigned int j = 0; //定义变量
    

  250.     unsigned char x, y; //定义变量
    


  251. 

  252.     if(y1 % 8 == 0)
    

  253.     {
    

  254.         y = y1 / 8; //判断终止页是否为8的整数倍
    

  255.     }
    

  256.     else
    

  257.     {
    

  258.         y = y1 / 8 + 1;
    

  259.     }
    


  260. 

  261.     for(y = y0; y < y1; y++) //从起始页开始，画到终止页
    

  262.     {
    

  263.         OLED_Type_t->OLED_Set_Pos(OLED_Type_t, x0, y); //在页的起始列开始画
    


  264. 

  265.         for(x = x0; x < x1; x++) //画x1 - x0 列
    

  266.         {
    

  267.             OLED_Type_t->OLED_Write_Date(OLED_Type_t, BMP[j++]); //画图片的点
    

  268.         }
    

  269.     }
    

  270. }
    


  271. 

  272. //显示动图
    

  273. /*
    

  274.         @brief                        显示动图
    

  275.         @param                        x0：起始列地址
    

  276.                                 y0：起始页地址
    

  277.                                 x1：终止列地址
    

  278.                                 y1：终止页地址
    

  279.                                 k: 帧个数
    

  280.                                 m: 单帧数组大小
    

  281.                                 BMP[][m]：存放动图代码的数组
    

  282.         @retval                        无
    

  283.  */
    

  284. static void OLED_DrawGIF_t(const struct OLED_Type* OLED_Type_t, unsigned char x0, unsigned char y0, unsigned char x1, unsigned char y1, unsigned char k, int m, const unsigned char GIF[][m])
    

  285. {
    

  286.     unsigned int j = 0; //定义变量
    

  287.     unsigned char x, y, i; //定义变量
    


  288. 

  289.     if(y1 % 8 == 0)
    

  290.     {
    

  291.         y = y1 / 8; //判断终止页是否为8的整数倍
    

  292.     }
    

  293.     else
    

  294.     {
    

  295.         y = y1 / 8 + 1;
    

  296.     }
    


  297. 

  298.     for (i = 0; i < k; i++) //从第一帧开始画
    

  299.     {
    

  300.         j = 0;
    


  301. 

  302.         for(y = y0; y < y1; y++) //从起始页开始，画到终止页
    

  303.         {
    

  304.             OLED_Type_t->OLED_Set_Pos(OLED_Type_t, x0, y); //在页的起始列开始画
    


  305. 

  306.             for(x = x0; x < x1; x++) //画x1 - x0 列
    

  307.             {
    

  308.                 OLED_Type_t->OLED_Write_Date(OLED_Type_t, GIF[i][j++]); //画图片的点
    

  309.             }
    

  310.         }
    


  311. 

  312.         //delay_ms(80);
    

  313.     }
    

  314. }
    


  315. 

  316. //OLED初始化
    

  317. static void OLED_Init_t(const struct OLED_Type* OLED_Type_t)
    

  318. {
    

  319.     OLED_Type_t->I2C->I2C_Init(OLED_Type_t->I2C);
    

  320.     Delay_Ms(200);
    

  321.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0xAE); //display off
    

  322.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0x00); //set low column address
    

  323.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0x10); //set high column address
    

  324.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0x40); //set start line address
    

  325.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0xB0); //set page address
    

  326.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0x81); //contract control
    

  327.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0xFF); //128
    

  328.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0xA1); //set segment remap
    

  329.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0xA6); //normal / reverse
    

  330.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0xA8); //set multiplex ratio(1 to 64)
    

  331.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0x3F); //1/32 duty
    

  332.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0xC8); //Com scan direction
    

  333.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0xD3); //set display offset
    

  334.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0x00); //
    

  335.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0xD5); //set osc division
    

  336.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0x80); //
    

  337.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0xD8); //set area color mode off
    

  338.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0x05); //
    

  339.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0xD9); //Set Pre-Charge Period
    

  340.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0xF1); //
    

  341.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0xDA); //set com pin configuartion
    

  342.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0x12); //
    

  343.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0xDB); //set Vcomh
    

  344.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0x30); //
    

  345.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0x8D); //set charge pump enable
    

  346.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0x14); //
    

  347.     OLED_Type_t->OLED_Write_CMD(OLED_Type_t, 0xAF); //turn on oled panel
    

  348. }
    


  349. 

  350. //实例化
    

  351. OLED_TypeDef _0_96OLED =
    

  352. {
    

  353.     .I2C = &I2C_t,
    

  354.     .OLED_Write_CMD = OLED_Write_CMD_t,
    

  355.     .OLED_Write_Date = OLED_Write_Date_t,
    

  356.     .OLED_Set_Pos = OLED_Set_Pos_t,
    

  357.     .OLED_Display_On = OLED_Display_On_t,
    

  358.     .OLED_Display_Off = OLED_Display_Off_t,
    

  359.     .OLED_Clear = OLED_Clear_t,
    

  360.     .OLED_Clear_Row = OLED_Clear_Row_t,
    

  361.     .OLED_Fill = OLED_Fill_t,
    

  362.     .OLED_ShowChar = OLED_ShowChar_t,
    

  363.     .OLED_ShowNum = OLED_ShowNum_t,
    

  364.     .OLED_ShowString = OLED_ShowString_t,
    

  365.     .OLED_ShowCHinese = OLED_ShowCHinese_t,
    

  366.     .OLED_DrawBMP = OLED_DrawBMP_t,
    

  367.     .OLED_DrawGIF = OLED_DrawGIF_t,
    

  368.     .OLED_Init = OLED_Init_t,
    


  369. 

  370. };
以上可看出OLED类中包含I2C类的成员对象，由于OLED的实现需要调用I2C的成员方法，I2C相当于OLED的下一层的驱动，因此将I2C类对象作为OLED类的成员；我们在使用OLED的时候需要实例化OLED类对象，由于I2C和OLED是分别在不同的.c文件中，在实例化OLED外设时，结构体中包含的是I2C设备的指针，而不是实体，同时在I2C.c文件中应完成实例化一个I2C对象；从而对外提供了OLED的封装接口。
四、main调用
在main中直接使用_0_96OLED来实现所有操作，如下：
复制
  1. int main(void)
    

  2. {
    

  3.     /* initial system clock */
    

  4.     system_clock_config();
    


  5. 

  6.     /* config nvic priority group */
    

  7.     nvic_priority_group_config(NVIC_PRIORITY_GROUP_4);
    


  8. 

  9.     Delay_Init();
    

  10.     hal_ledInit();
    

  11.     hal_timerInit();
    


  12. 

  13.     //I2C_t.I2C_Init(&I2C_t);
    

  14.     _0_96OLED.OLED_Init(&_0_96OLED);
    

  15.     _0_96OLED.OLED_Clear(&_0_96OLED);
    


  16. 

  17.     _0_96OLED.OLED_ShowString(&_0_96OLED, 16, 0, "www.21ic.com", 16);
    

  18.     _0_96OLED.OLED_ShowString(&_0_96OLED, 14, 2, "AT32F425 TEST", 16);
    

  19.     _0_96OLED.OLED_ShowString(&_0_96OLED, 28, 4, "2022/5/31", 16);
    

  20.     _0_96OLED.OLED_ShowString(&_0_96OLED, 14, 6, "ID:zhouminjie", 16);
    


  21. 

  22.     Delay_Ms(1000);
    


  23. 

  24.     while(1)
    

  25.     {
    

  26.         _0_96OLED.OLED_DrawGIF(&_0_96OLED, 0, 0, 128, 8, 29, 1024, GIF);
    

  27.     }
    

  28. }
五、总结
面向对象方法实现I2C驱动封装及OLED驱动封装，对外仅提供一个OLED操作对象接口，提高了代码的复用性及封装性，方便了代码后期的维护修改。
参考：https://blog.csdn.net/weixin_42700740/article/details/113624909
六、效果及测试代码
056af8253c3e38c5e4efcf483c3777c8_ (1).gif

AT32F425_SW_I2C_0.96OLED_oo.zip (382.25 KB, 下载次数: 23)


回复

收藏1 举报

相关帖子
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

zhouminjie

33

主题

140

帖子

3

粉丝
快速回复 在线客服 返回列表 返回顶部