HAL库与cubemx系列教程|采用面向对象的方法写一个OLED驱动

发布于:2023-01-20 ⋅ 阅读:(8) ⋅ 点赞:(0) ⋅ 评论:(0)

上一章节主要介绍了什么怎么样实现C语言面向对象编程,本章节来实战看看如何运用在嵌入式开发中

面向对象

...有对象的面向她,没对象的,面向我,开课了...,说起面向对象编程,不得不说说面向过程编程

C语言中一般使用面向过程编程,就是分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步调用,在函数中对数据结构进行处理(执行算法),也就是说数据结构和算法是分开的。

C++语言把数据和算法封装在一起,形成一个整体,无论是对它的属性进行操作、还是对它的行为进行调用,都是通过一个对象来执行,这就是面向对象编程思想(摘自道哥:IOT物联网小镇)。

既然本次要实现面向对象编写OLED驱动,那就要具备上面所说的面向对象的特性,代码较多,大家可以在**文末评论区找到源码链接,直接阅读源码**...

IIC底层驱动封装

  • 测试平台:STM32G030C8T6

  • OLED:096寸OLED(IIC接口)

此部分参考:https://blog.csdn.net/weixin_42700740/article/details/113624909

IIC的协议就不多说了,网络上有很多讲的很形象的例子,接下来主要看代码实现就可以了

先定义一个IIC的“类”,主要包含用到的IO,IIC底层驱动函数等

//定义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;

接下来封装

IO时钟、PIN脚:

//设置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初始化
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时钟
 }

 // 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
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
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失败
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信号:

//产生ACK应答
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信号:

//产生NACK应答
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,入口参数为要发送的字节
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);
 }
}

读取一字节:

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 = GPIOB,  // GPIO组为GPIOB
 .GPIOx_SDA = GPIOB,  // GPIO组为GPIOB
 .GPIO_SCL = GPIO_PIN_9, // GPIO为PIN9
 .GPIO_SDA = GPIO_PIN_8, // GPIO为PIN8
 .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函数
};

OLED封装

依然是先封装一个“OLED类”

//定义RT_OLED类
typedef struct RT_OLED_TYPE
{
 //操作
 IIC_TypeDef IIC;       //IIC驱动

 void (*rt_oled_write_byte)(const struct RT_OLED_TYPE*,uint8_t,uint8_t,uint8_t);
 void (*rt_oled_init)(const struct RT_OLED_TYPE*);
 void (*rt_oled_display_on)(const struct RT_OLED_TYPE*,uint8_t);
 void (*rt_oled_clear)(const struct RT_OLED_TYPE*);
 void (*rt_oled_displayall)(const struct RT_OLED_TYPE*);
 void (*rt_oled_showchar)(const struct RT_OLED_TYPE*,uint8_t,uint8_t,uint8_t,uint8_t);
 void (*rt_oled_shownum)(const struct RT_OLED_TYPE*,uint8_t,uint8_t,uint32_t,uint8_t,uint8_t);
 void (*rt_oled_showstring)(const struct RT_OLED_TYPE*,uint8_t,uint8_t,uint8_t *,uint8_t);
 void (*rt_oled_showchinese)(const struct RT_OLED_TYPE*,uint8_t,uint8_t,uint8_t);
 void (*rt_oled_showbmp)(const struct RT_OLED_TYPE*,uint8_t,uint8_t,uint8_t,uint8_t,unsigned char *);
 void (*rt_oled_fillpicture)(const struct RT_OLED_TYPE*,unsigned char);
}RT_OLED_TypeDef;

extern RT_OLED_TypeDef rt_oled;              //外部声明实例化RT_OLED对象

写数据、命令封装:

/**
 * @author:小飞哥玩嵌入式-小飞哥
 * @TODO: oled写数据
 * @param
 * @return NULL
 */
static void rt_oled_write_data_t(const struct RT_OLED_TYPE *rt_oled_type_t, uint8_t chipid, uint8_t dat)
{
 rt_oled_type_t->IIC.IIC_Start(&rt_oled_type_t->IIC);
 rt_oled_type_t->IIC.IIC_Send_Byte(&rt_oled_type_t->IIC, chipid); // D/C#=0; R/W#=0
 rt_oled_type_t->IIC.IIC_Ack(&rt_oled_type_t->IIC);
 rt_oled_type_t->IIC.IIC_Send_Byte(&rt_oled_type_t->IIC, 0x40);
 rt_oled_type_t->IIC.IIC_Ack(&rt_oled_type_t->IIC);
 rt_oled_type_t->IIC.IIC_Send_Byte(&rt_oled_type_t->IIC, dat);
 rt_oled_type_t->IIC.IIC_Ack(&rt_oled_type_t->IIC);
 rt_oled_type_t->IIC.IIC_Stop(&rt_oled_type_t->IIC);
}

/**
 * @author:小飞哥玩嵌入式-小飞哥
 * @TODO: oled写命令
 * @param
 * @return NULL
 */
static void rt_oled_write_cmd_t(const struct RT_OLED_TYPE *rt_oled_type_t, uint8_t chipid, uint8_t cmd)
{
 rt_oled_type_t->IIC.IIC_Start(&rt_oled_type_t->IIC);
 rt_oled_type_t->IIC.IIC_Send_Byte(&rt_oled_type_t->IIC, chipid); // D/C#=0; R/W#=0
 rt_oled_type_t->IIC.IIC_Ack(&rt_oled_type_t->IIC);
 rt_oled_type_t->IIC.IIC_Send_Byte(&rt_oled_type_t->IIC, 0x00);
 rt_oled_type_t->IIC.IIC_Ack(&rt_oled_type_t->IIC);
 rt_oled_type_t->IIC.IIC_Send_Byte(&rt_oled_type_t->IIC, cmd);
 rt_oled_type_t->IIC.IIC_Ack(&rt_oled_type_t->IIC);
 rt_oled_type_t->IIC.IIC_Stop(&rt_oled_type_t->IIC);
}

/**
 * @author:小飞哥玩嵌入式-小飞哥
 * @TODO: oled写数据或者写命令
 * @param
 * @return NULL
 */
static void rt_oled_write_byte_t(const struct RT_OLED_TYPE *rt_oled_type_t, uint8_t chipid, uint8_t dat, uint8_t cmd)
{
 if (cmd) //写数据
 {
  rt_oled_write_data_t(rt_oled_type_t, chipid, dat);
 }
 else //写命令
 {
  rt_oled_write_cmd_t(rt_oled_type_t, chipid, dat);
 }
}

接下来是一些对OLED的显示操作,就不一一介绍了:

/**
 * @author:小飞哥玩嵌入式-小飞哥
 * @TODO: oled坐标设置
 * @param
 * @return NULL
 */

static void rt_oled_setpos_t(const struct RT_OLED_TYPE *rt_oled_type_t, uint8_t x, uint8_t y)
{

 rt_oled_write_byte_t(rt_oled_type_t, 0x780xb0 + y, OLED_CMD);
 rt_oled_write_byte_t(rt_oled_type_t, 0x78, ((x & 0xf0) >> 4) | 0x10, OLED_CMD);
 rt_oled_write_byte_t(rt_oled_type_t, 0x78, (x & 0x0f), OLED_CMD);
}

/**
 * @author:小飞哥玩嵌入式-小飞哥
 * @TODO: oled显示开关
 * @param
 * @return NULL
 */

static void rt_oled_display_on_t(const struct RT_OLED_TYPE *rt_oled_type_t, uint8_t ON)
{
 if (ON)
 {
  rt_oled_write_byte_t(rt_oled_type_t, 0x780X8D, OLED_CMD);
  rt_oled_write_byte_t(rt_oled_type_t, 0x780X14, OLED_CMD);
  rt_oled_write_byte_t(rt_oled_type_t, 0x780XAF, OLED_CMD);
 }
 else
 {
  rt_oled_write_byte_t(rt_oled_type_t, 0x780X8D, OLED_CMD);
  rt_oled_write_byte_t(rt_oled_type_t, 0x780X14, OLED_CMD);
  rt_oled_write_byte_t(rt_oled_type_t, 0x780XAE, OLED_CMD);
 }
}
/**
 * @author:小飞哥玩嵌入式-小飞哥
 * @TODO: oled清屏
 * @param
 * @return NULL
 */
static void rt_oled_clear_t(const struct RT_OLED_TYPE *rt_oled_type_t)
{
 uint8_t i, n;
 for (i = 0; i < 8; i++)
 {
  rt_oled_write_byte_t(rt_oled_type_t, 0x780xb0 + i, OLED_CMD);
  rt_oled_write_byte_t(rt_oled_type_t, 0x780x00, OLED_CMD);
  rt_oled_write_byte_t(rt_oled_type_t, 0x780x10, OLED_CMD);

  for (n = 0; n < 128; n++)
   rt_oled_write_byte_t(rt_oled_type_t, 0x780, OLED_DATA);
 } //更新显示
}

/**
 * @author:小飞哥玩嵌入式-小飞哥
 * @TODO: oled全显示
 * @param
 * @return NULL
 */
static void rt_oled_displayall_t(const struct RT_OLED_TYPE *rt_oled_type_t)
{
 uint8_t i, n;
 for (i = 0; i < 8; i++)
 {
  rt_oled_write_byte_t(rt_oled_type_t, 0x780xb0 + i, OLED_CMD);
  rt_oled_write_byte_t(rt_oled_type_t, 0x780x00, OLED_CMD);
  rt_oled_write_byte_t(rt_oled_type_t, 0x780x10, OLED_CMD);

  for (n = 0; n < 128; n++)
   rt_oled_write_byte_t(rt_oled_type_t, 0x781, OLED_DATA);
 } //更新显示
}
/**
 * @author:小飞哥玩嵌入式-小飞哥
 * @TODO: oled显示一个字符
 * @param
 * @return NULL
 */
static void rt_oled_showchar_t(const struct RT_OLED_TYPE *rt_oled_type_t, uint8_t x, uint8_t y, uint8_t chr, uint8_t Char_Size)
{
 unsigned char c = 0, i = 0;
 c = chr - ' '//得到偏移后的值

 if (x > Max_Column - 1)
 {
  x = 0;
  y = y + 2;
 }

 if (Char_Size == 16)
 {
  rt_oled_setpos_t(rt_oled_type_t, x, y);
  for (i = 0; i < 8; i++)
  {
   rt_oled_write_byte_t(rt_oled_type_t, 0x78, F8X16[c * 16 + i], OLED_DATA);
  }
  rt_oled_setpos_t(rt_oled_type_t, x, y + 1);

  for (i = 0; i < 8; i++)
  {
   rt_oled_write_byte_t(rt_oled_type_t, 0x78, F8X16[c * 16 + i + 8], OLED_DATA);
  }
 }
 else
 {
  rt_oled_setpos_t(rt_oled_type_t, x, y);
  for (i = 0; i < 6; i++)
  {
   rt_oled_write_byte_t(rt_oled_type_t, 0x78, F6x8[c][i], OLED_DATA);
  }
 }
}
/**
 * @author:小飞哥玩嵌入式-小飞哥
 * @TODO: oled m^n
 * @param
 * @return NULL
 */
static uint32_t rt_oled_pow_t(uint8_t m, uint8_t n)
{
 uint32_t result = 1;
 while (n--)
  result *= m;
 return result;
}
/**
 * @author:小飞哥玩嵌入式-小飞哥
 * @TODO: oled显示一个字符
 * @param
 * @return NULL

//显示2个数字
//x,y :起点坐标
//len :数字的位数
//size:字体大小
//mode:模式 0,填充模式;1,叠加模式
//num:数值(0~4294967295);
*/
static void rt_oled_shownum_t(const struct RT_OLED_TYPE *rt_oled_type_t, uint8_t x, uint8_t y, uint32_t num, uint8_t size2, uint8_t len)
{
 uint8_t t, temp;
 uint8_t enshow = 0;
 for (t = 0; t < len; t++)
 {
  temp = (num / rt_oled_pow_t(10, len - t - 1)) % 10;
  if (enshow == 0 && t < (len - 1))
  {
   if (temp == 0)
   {
    rt_oled_showchar_t(rt_oled_type_t, x + (size2 / 2) * t, y, ' ', size2);
    continue;
   }
   else
    enshow = 1;
  }
  rt_oled_showchar_t(rt_oled_type_t, x + (size2 / 2) * t, y, temp + '0', size2);
 }
}
/**
 * @author:小飞哥玩嵌入式-小飞哥
 * @TODO: oled显示一个字符号串
 * @param
 * @return NULL
 */
static void rt_oled_showstring_t(const struct RT_OLED_TYPE *rt_oled_type_t, uint8_t x, uint8_t y, uint8_t *chr, uint8_t charsize)
{
 unsigned char j = 0;
 while (chr[j] != '\0')
 {
  rt_oled_showchar_t(rt_oled_type_t, x, y, chr[j], charsize);
  x += 8;
  if (x > 120)
  {
   x = 0;
   y += 2;
  }
  j++;
 }
}
/**
 * @author:小飞哥玩嵌入式-小飞哥
 * @TODO: oled显示汉字
 * @param
 * @return NULL
 */
static void rt_oled_showchinese_t(const struct RT_OLED_TYPE *rt_oled_type_t, uint8_t x, uint8_t y, uint8_t no)
{
 uint8_t t, adder = 0;
 rt_oled_setpos_t(rt_oled_type_t, x, y);
 for (t = 0; t < 16; t++)
 {
  rt_oled_write_byte_t(rt_oled_type_t, 0x78, Hzk[2 * no][t], OLED_DATA);
  adder += 1;
 }
 rt_oled_setpos_t(rt_oled_type_t, x, y + 1);
 for (t = 0; t < 16; t++)
 {
  rt_oled_write_byte_t(rt_oled_type_t, 0x78, Hzk[2 * no + 1][t], OLED_DATA);
  adder += 1;
 }
}
/**
 * @author:小飞哥玩嵌入式-小飞哥
 * @TODO: 显示显示BMP图片128×64起始点坐标(x,y),x的范围0~127,y为页的范围0~7
 * @param
 * @return NULL
 */
static void rt_oled_showbmp_t(const struct RT_OLED_TYPE *rt_oled_type_t, uint8_t x0, uint8_t y0, uint8_t x1, uint8_t y1, unsigned char BMP[])
{
 unsigned int j = 0;
 unsigned char x, y;

 if (y1 % 8 == 0)
  y = y1 / 8;
 else
  y = y1 / 8 + 1;
 for (y = y0; y < y1; y++)
 {
  rt_oled_setpos_t(rt_oled_type_t, x0, y);
  for (x = x0; x < x1; x++)
  {
   rt_oled_write_byte_t(rt_oled_type_t, 0x78, BMP[j++], OLED_DATA);
  }
 }
}
/**
 * @author:小飞哥玩嵌入式-小飞哥
 * @TODO: oled写数据或者写命令
 * @param
 * @return NULL
 */
static void rt_oled_fillpicture_t(const struct RT_OLED_TYPE *rt_oled_type_t, unsigned char fill_Data)
{
 unsigned char m, n;
 for (m = 0; m < 8; m++)
 {
  rt_oled_write_byte_t(rt_oled_type_t, 0x780xb0 + m, OLED_CMD);
  rt_oled_write_byte_t(rt_oled_type_t, 0x780x00, OLED_CMD);
  rt_oled_write_byte_t(rt_oled_type_t, 0x780x10, OLED_CMD);

  for (n = 0; n < 128; n++)
  {
   rt_oled_write_byte_t(rt_oled_type_t, 0x78, fill_Data, OLED_DATA);
  }
 }
}

//初始化SSD1306
void rt_oled_init_t(const struct RT_OLED_TYPE *rt_oled_type_t)
{
 rt_oled_type_t->IIC.IIC_Init(&rt_oled_type_t->IIC); // IIC初始化

 HAL_Delay(800);
 rt_oled_write_byte_t(rt_oled_type_t, CHIPID, 0xAE, OLED_CMD); //--display off
 rt_oled_write_byte_t(rt_oled_type_t, CHIPID, 0x00, OLED_CMD); //---set low column address
 rt_oled_write_byte_t(rt_oled_type_t, CHIPID, 0x10, OLED_CMD); //---set high column address
 rt_oled_write_byte_t(rt_oled_type_t, CHIPID, 0x40, OLED_CMD); //--set start line address
 rt_oled_write_byte_t(rt_oled_type_t, CHIPID, 0xB0, OLED_CMD); //--set page address
 rt_oled_write_byte_t(rt_oled_type_t, CHIPID, 0x81, OLED_CMD); // contract control
 rt_oled_write_byte_t(rt_oled_type_t, CHIPID, 0xFF, OLED_CMD); //--128
 rt_oled_write_byte_t(rt_oled_type_t, CHIPID, 0xA1, OLED_CMD); // set segment remap
 rt_oled_write_byte_t(rt_oled_type_t, CHIPID, 0xA6, OLED_CMD); //--normal / reverse
 rt_oled_write_byte_t(rt_oled_type_t, CHIPID, 0xA8, OLED_CMD); //--set multiplex ratio(1 to 64)
 rt_oled_write_byte_t(rt_oled_type_t, CHIPID, 0x3F, OLED_CMD); //--1/32 duty
 rt_oled_write_byte_t(rt_oled_type_t, CHIPID, 0xC8, OLED_CMD); // Com scan direction
 rt_oled_write_byte_t(rt_oled_type_t, CHIPID, 0xD3, OLED_CMD); //-set display offset
 rt_oled_write_byte_t(rt_oled_type_t, CHIPID, 0x00, OLED_CMD); //

 rt_oled_write_byte_t(rt_oled_type_t, CHIPID, 0xD5, OLED_CMD); // set osc division
 rt_oled_write_byte_t(rt_oled_type_t, CHIPID, 0x80, OLED_CMD); //

 rt_oled_write_byte_t(rt_oled_type_t, CHIPID, 0xD8, OLED_CMD); // set area color mode off
 rt_oled_write_byte_t(rt_oled_type_t, CHIPID, 0x05, OLED_CMD); //

 rt_oled_write_byte_t(rt_oled_type_t, CHIPID, 0xD9, OLED_CMD); // Set Pre-Charge Period
 rt_oled_write_byte_t(rt_oled_type_t, CHIPID, 0xF1, OLED_CMD); //

 rt_oled_write_byte_t(rt_oled_type_t, CHIPID, 0xDA, OLED_CMD); // set com pin configuartion
 rt_oled_write_byte_t(rt_oled_type_t, CHIPID, 0x12, OLED_CMD); //

 rt_oled_write_byte_t(rt_oled_type_t, CHIPID, 0xDB, OLED_CMD); // set Vcomh
 rt_oled_write_byte_t(rt_oled_type_t, CHIPID, 0x30, OLED_CMD); //

 rt_oled_write_byte_t(rt_oled_type_t, CHIPID, 0x8D, OLED_CMD); // set charge pump enable
 rt_oled_write_byte_t(rt_oled_type_t, CHIPID, 0x14, OLED_CMD); //

 rt_oled_write_byte_t(rt_oled_type_t, CHIPID, 0xAF, OLED_CMD); //--turn on oled panel
}

实例化OLED对象:

//实例化RT_OLED对象
RT_OLED_TypeDef rt_oled = {
 //操作
 .IIC = {
  .GPIOx_SCL = GPIOB,
  .GPIOx_SDA = GPIOB,
  .GPIO_SCL = OLED_SCL_Pin,
  .GPIO_SDA = OLED_SDA_Pin,
  .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驱动
 .rt_oled_write_byte = rt_oled_write_byte_t,
 .rt_oled_init = rt_oled_init_t,
 .rt_oled_display_on = rt_oled_display_on_t,
 .rt_oled_displayall = rt_oled_displayall_t,
 .rt_oled_showchar = rt_oled_showchar_t,
 .rt_oled_shownum = rt_oled_shownum_t,
 .rt_oled_showstring = rt_oled_showstring_t,
 .rt_oled_showchinese = rt_oled_showchinese_t,
 .rt_oled_showbmp = rt_oled_showbmp_t,
 .rt_oled_fillpicture = rt_oled_fillpicture_t,
 .rt_oled_clear = rt_oled_clear_t
 };

如何调用?

对于使用者来讲,面向对象最终要实现的效果是他不需要关注底层驱动,只需要应用层即可,直接调用“类”中的“方法”即可,非常简单

看看实现效果:

 

经验交流

欢迎关注关注小飞哥玩嵌入式!


网站公告

欢迎关注微信公众号

今日签到

点亮在社区的每一天
签到