Clion有优雅的开发STM32——oled

最新推荐文章于 2024-11-10 14:38:54 发布

羽羽加油

最新推荐文章于 2024-11-10 14:38:54 发布

阅读量1.5k

点赞数 54

文章标签： stm32 单片机嵌入式硬件

本文链接：https://blog.csdn.net/m0_68340520/article/details/143629527

版权

Clion有优雅的开发STM32——oled[四角I2C接口]

I2C介绍
代码演示
结果展示

I2C介绍

简介

I2C（Inter-Integrated Circuit）是一种两线式串行总线，用于连接微控制器及其外围设备。

一、主要特点
1.简单性：
只需要两根线：SCL（串行时钟线）和 SDA（串行数据线）。这使得硬件连接非常简洁，减少了电路板上的布线复杂性。
2.多设备连接
可以连接多个设备到同一总线。每个设备都有一个唯一的地址，通过这个地址主设备可以选择与之通信的从设备。
3.双向通信
数据可以在主设备和从设备之间双向传输。主设备可以向从设备发送数据，从设备也可以向主设备发送数据。
4.支持不同速度
I2C 总线可以在不同的速度下工作，标准模式下速度为 100 kbps，快速模式下为 400 kbps，高速模式下可达 3.4 Mbps。这使得它可以适应不同性能要求的设备。
总结：因为只有一根时钟线和一根数据线所以它是串行同步半双工总线，可以挂很多设备，主设备和从设备之间双向传输，三种通信速度

硬件连接

重点：电阻要用4.7k的,主机的SCL(时钟线)连从机SCL,SDA(数据线)连从机的SDA，如果是多从机要把从机并联到总线上。

通信原理

一、角色定义
主机（Master）：
发起通信的设备。它控制总线的时钟信号（SCL），并向从机发送地址和控制信息，以启动数据传输。
主机可以向一个或多个从机发送数据，也可以从从机读取数据。
通常微控制器（MCU）等具有控制能力的设备可以作为主机。
从机（Slave）：
被主机选中进行通信的设备。从机响应主机的请求，根据主机的指令进行数据的发送或接收。
从机不能主动发起通信，只能在被主机选中时参与通信。
各种外围设备，如传感器、存储器、显示器等可以作为从机。
二、区分方式
通信发起：
主机是通信的发起者。当主机需要与某个从机进行通信时，它会在总线上发送起始信号，然后紧跟着发送从机的地址和读写控制位。如果总线上有设备检测到这个地址与自己匹配，并且读写控制位指示的操作是自己能够响应的，那么这个设备就作为从机被选中，开始与主机进行通信。
从机不会主动发送起始信号和地址，而是等待主机的发起。
时钟控制：
主机控制时钟信号（SCL）的产生和变化。在通信过程中，主机通过调整 SCL 的频率来控制数据传输的速度。
从机根据主机产生的时钟信号进行数据的发送和接收，不能主动控制时钟。
地址分配：
每个从机在总线上都有一个唯一的地址。主机通过发送特定的地址来选择要与之通信的从机。
主机自身没有在总线上被其他设备寻址的地址，它只负责发送地址来选择从机。
总结： 主机拥有绝对的控制权叫到谁，谁才能动不然就在自己的地方老实呆在

时序图分析

在这里插入图片描述
其实读懂时序图了理解通信就很简单了
主机SDA拉低SCL不变开始通信，然后主机就叫人（ADDRESS）和发读写位，ACK为答应位（有人回答了主机ACK就有效）然后就他们加开始对话，主机或者从机收到对话就点头示意（ACK有效）依次往复直到他们不想对话(STOP)结束
在这里插入图片描述

代码演示

CubeMX配置：基本的操作就不介绍了在这里插入图片描述
这里配置GPIO口 PB7和PB6因为它是硬件的I2C后期可以用硬件I2C

生成代码
Clion:写代码，先建OLED的.c/.h
先写基本的函数：

void OLED_I2C_Init(void)
{
   
    OLED_W_SCL(1);
    OLED_W_SDA(1);
}

/**
  * @brief  I2C开始
  * @param  无
  * @retval 无
  */
void OLED_I2C_Start(void)
{
   
    OLED_W_SDA(1);
    OLED_W_SCL(1);
    OLED_W_SDA(0);
    OLED_W_SCL(0);
}

/**
  * @brief  I2C停止
  * @param  无
  * @retval 无
  */
void OLED_I2C_Stop(void)
{
   
    OLED_W_SDA(0);
    OLED_W_SCL(1);
    OLED_W_SDA(1);
}

/**
  * @brief  I2C发送一个字节
  * @param  Byte 要发送的一个字节
  * @retval 无
  */
void OLED_I2C_SendByte(uint8_t Byte)
{
   
    uint8_t i;
    for (i = 0; i < 8; i++)
    {
   
        OLED_W_SDA(!!(Byte & (0x80 >> i)));
        OLED_W_SCL(1);
        OLED_W_SCL(0);
    }
    OLED_W_SCL(1);	//额外的一个时钟，不处理应答信号
    OLED_W_SCL(0);
}
/**
  * @brief  OLED写命令
  * @param  Command 要写入的命令
  * @retval 无
  */
void OLED_WriteCommand(uint8_t Command)
{
   
    OLED_I2C_Start();
    OLED_I2C_SendByte(0x78);		//从机地址
    OLED_I2C_SendByte(0x00);		//写命令
    OLED_I2C_SendByte(Command);
    OLED_I2C_Stop();
}

/**
  * @brief  OLED写数据
  * @param  Data 要写入的数据
  * @retval 无
  */
void OLED_WriteData(uint8_t Data)
{
   
    OLED_I2C_Start();
    OLED_I2C_SendByte(0x78);		//从机地址
    OLED_I2C_SendByte(0x40);		//写数据
    OLED_I2C_SendByte(Data);
    OLED_I2C_Stop();
}

在这里插入图片描述
这里原理基本上就差不多了再要更深入就要去看SSD1306的驱动了
我直接用的讲协科技的代码OLED.c

//
// Created by 21278 on 2024/11/8.
//
#include "OLED.h"
#include "OLED_Font.h"
#include <string.h>
#include <math.h>
#include <stdio.h>
#include <stdarg.h>

/**
  * 数据存储格式：
  * 纵向8点，高位在下，先从左到右，再从上到下
  * 每一个Bit对应一个像素点
  *
  *      B0 B0                  B0 B0
  *      B1 B1                  B1 B1
  *      B2 B2                  B2 B2
  *      B3 B3  ------------->  B3 B3 --
  *      B4 B4                  B4 B4  |
  *      B5 B5                  B5 B5  |
  *      B6 B6                  B6 B6  |
  *      B7 B7                  B7 B7  |
  *                                    |
  *  -----------------------------------
  *  |
  *  |   B0 B0                  B0 B0
  *  |   B1 B1                  B1 B1
  *  |   B2 B2                  B2 B2
  *  --> B3 B3  ------------->  B3 B3
  *      B4 B4                  B4 B4
  *      B5 B5                  B5 B5
  *      B6 B6                  B6 B6
  *      B7 B7                  B7 B7
  *
  * 坐标轴定义：
  * 左上角为(0, 0)点
  * 横向向右为X轴，取值范围：0~127
  * 纵向向下为Y轴，取值范围：0~63
  *
  *       0             X轴           127
  *      .------------------------------->
  *    0 |
  *      |
  *      |
  *      |
  *  Y轴 |
  *      |
  *      |
  *      |
  *   63 |
  *      v
  *
  */


/*全局变量*********************/

/**
  * OLED显存数组
  * 所有的显示函数，都只是对此显存数组进行读写
  * 随后调用OLED_Update函数或OLED_UpdateArea函数
  * 才会将显存数组的数据发送到OLED硬件，进行显示
  */
uint8_t OLED_DisplayBuf[8][128];

/*********************全局变量*/


/*引脚配置*********************/

/**
  * 函    数：OLED写SCL高低电平
  * 参    数：要写入SCL的电平值，范围：0/1
  * 返 回 值：无
  * 说    明：当上层函数需要写SCL时，此函数会被调用
  *           用户需要根据参数传入的值，将SCL置为高电平或者低电平
  *           当参数传入0时，置SCL为低电平，当参数传入1时，置SCL为高电平
  */
void OLED_W_SCL(uint8_t BitValue)
{
   

    /*根据BitValue的值，将SCL置高电平或者低电平*/
    HAL_GPIO_WritePin(SCL_GPIO_Port, SCL_Pin, BitValue);
    /*如果单片机速度过快，可在此添加适量延时，以避免超出I2C通信的最大速度*/
    //...
}

/**
  * 函    数：OLED写SDA高低电平
  * 参    数：要写入SDA的电平值，范围：0/1
  * 返 回 值：无
  * 说    明：当上层函数需要写SDA时，此函数会被调用
  *           用户需要根据参数传入的值，将SDA置为高电平或者低电平
  *           当参数传入0时，置SDA为低电平，当参数传入1时，置SDA为高电平
  */
void OLED_W_SDA(uint8_t BitValue)
{
   
    /*根据BitValue的值，将SDA置高电平或者低电平*/
    HAL_GPIO_WritePin(SDA_GPIO_Port, SDA_Pin, BitValue);
    /*如果单片机速度过快，可在此添加适量延时，以避免超出I2C通信的最大速度*/
    //...
}

/**
  * 函    数：OLED引脚初始化
  * 参    数：无
  * 返 回 值：无
  * 说    明：当上层函数需要初始化时，此函数会被调用
  *           用户需要将SCL和SDA引脚初始化为开漏模式，并释放引脚
  */
void OLED_GPIO_Init(void)
{
   
    uint32_t i, j;

    /*在初始化前，加入适量延时，待OLED供电稳定*/
    for (i = 0; i < 1000; i ++)
    {
   
        for (j = 0; j < 1000; j ++);
    }
    /*释放SCL和SDA*/
    OLED_W_SCL(1);
    OLED_W_SDA(1);
}

/*********************引脚配置*/


/*通信协议*********************/

/**
  * 函    数：I2C起始
  * 参    数：无
  * 返 回 值：无
  */
void OLED_I2C_Start(void)
{
   
    OLED_W_SDA(1);		//释放SDA，确保SDA为高电平
    OLED_W_SCL(1);		//释放SCL，确保SCL为高电平
    OLED_W_SDA(0);		//在SCL高电平期间，拉低SDA，产生起始信号
    OLED_W_SCL(0);		//起始后把SCL也拉低，即为了占用总线，也为了方便总线时序的拼接
}

/**
  * 函    数：I2C终止
  * 参    数：无
  * 返 回 值：无
  */
void OLED_I2C_Stop(void)
{
   
    OLED_W_SDA(0);		//拉低SDA，确保SDA为低电平
    OLED_W_SCL(1);		//释放SCL，使SCL呈现高电平
    OLED_W_SDA(1);		//在SCL高电平期间，释放SDA，产生终止信号
}

/**
  * 函    数：I2C发送一个字节
  * 参    数：Byte 要发送的一个字节数据，范围：0x00~0xFF
  * 返 回 值：无
  */
void OLED_I2C_SendByte(uint8_t Byte)
{
   
    uint8_t i;

    /*循环8次，主机依次发送数据的每一位*/
    for (i = 0; i < 8; i++)
    {
   
        /*使用掩码的方式取出Byte的指定一位数据并写入到SDA线*/
        /*两个!的作用是，让所有非零的值变为1*/
        OLED_W_SDA(!!(Byte & (0x80 >> i)));
        OLED_W_SCL(1);	//释放SCL，从机在SCL高电平期间读取SDA
        OLED_W_SCL(0);	//拉低SCL，主机开始发送下一位数据
    }

    OLED_W_SCL(1);		//额外的一个时钟，不处理应答信号
    OLED_W_SCL(0);
}

/**
  * 函    数：OLED写命令
  * 参    数：Command 要写入的命令值，范围：0x00~0xFF
  * 返 回 值：无
  */
void OLED_WriteCommand(uint8_t Command)
{
   
    OLED_I2C_Start();				//I2C起始
    OLED_I2C_SendByte(0x78);		//发送OLED的I2C从机地址
    OLED_I2C_SendByte(0x00);		//控制字节，给0x00，表示即将写命令
    OLED_I2C_SendByte(Command);		//写入指定的命令
    OLED_I2C_Stop();				//I2C终止
}

/**
  * 函    数：OLED写数据
  * 参    数：Data 要写入数据的起始地址
  * 参    数：Count 要写入数据的数量
  * 返 回 值：无
  */
void OLED_WriteData(uint8_t *Data, uint8_t Count)
{
   
    uint8_t i;

    OLED_I2C_Start();				//I2C起始
    OLED_I2C_SendByte(0x78);		//发送OLED的I2C从机地址
    OLED_I2C_SendByte(0x40);		//控制字节，给0x40，表示即将写数据
    /*循环Count次，进行连续的数据写入*/
    for (i = 0; i < Count; i ++)
    {
   
        OLED_I2C_SendByte(Data[i]);	//依次发送Data的每一个数据
    }
    OLED_I2C_Stop();				//I2C终止
}

/*********************通信协议*/


/*硬件配置*********************/

/**
  * 函    数：OLED初始化
  * 参    数：无
  * 返 回 值：无
  * 说    明：使用前，需要调用此初始化函数
  */
void OLED_Init(void)
{
   
    OLED_GPIO_Init();			//先调用底层的端口初始化

    /*写入一系列的命令，对OLED进行初始化配置*/
    OLED_WriteCommand(0xAE);	//设置显示开启/关闭，0xAE关闭，0xAF开启

    OLED_WriteCommand(0xD5);	//设置显示时钟分频比/振荡器频率
    OLED_WriteCommand(0x80);	//0x00~0xFF

    OLED_WriteCommand(0xA8);	//设置多路复用率
    OLED_WriteCommand(0x3F);	//0x0E~0x3F

    OLED_WriteCommand(0xD3);	//设置显示偏移
    OLED_WriteCommand(0x00);	//0x00~0x7F

    OLED_WriteCommand(0x40);	//设置显示开始行，0x40~0x7F

    OLED_WriteCommand(0xA1);	//设置左右方向，0xA1正常，0xA0左右反置

    OLED_WriteCommand(0xC8);	//设置上下方向，0xC8正常，0xC0上下反置

    OLED_WriteCommand(0xDA);	//设置COM引脚硬件配置
    OLED_WriteCommand(0x12);

    OLED_WriteCommand(0x81);	//设置对比度
    OLED_WriteCommand(0xCF);	//0x00~0xFF

    OLED_WriteCommand(0xD9);	//设置预充电周期
    OLED_WriteCommand(0xF1);

    OLED_WriteCommand(0xDB);	//设置VCOMH取消选择级别
    OLED_WriteCommand(0x30);

    OLED_WriteCommand(0xA4);	//设置整个显示打开/关闭

    OLED_WriteCommand(0xA6);	//设置正常/反色显示，0xA6正常，0xA7反色

    OLED_WriteCommand(0x8D);	//设置充电泵
    OLED_WriteCommand(0x14);

    OLED_WriteCommand(0xAF);	//开启显示

    OLED_Clear();				//清空显存数组
    OLED_Update();				//更新显示，清屏，防止初始化后未显示内容时花屏
}

/**
  * 函    数：OLED设置显示光标位置
  * 参    数：Page 指定光标所在的页，范围：0~7
  * 参    数：X 指定光标所在的X轴坐标，范围：0~127
  * 返 回 值：无
  * 说    明：OLED默认的Y轴，只能8个Bit为一组写入，即1页等于8个Y轴坐标
  */
void OLED_SetCursor(uint8_t Page, uint8_t X)
{
   
    /*如果使用此程序驱动1.3寸的OLED显示屏，则需要解除此注释*/
    /*因为1.3寸的OLED驱动芯片（SH1106）有132列*/
    /*屏幕的起始列接在了第2列，而不是第0列*/
    /*所以需要将X加2，才能正常显示*/
//	X += 2;

    /*通过指令设置页地址和列地址*/
    OLED_WriteCommand(0xB0 | Page);					//设置页位置
    OLED_WriteCommand(0x10 | ((X & 0xF0) >> 4));	//设置X位置高4位
    OLED_WriteCommand(0x00 | (X & 0x0F));			//设置X位置低4位
}

/*********************硬件配置*/


/*工具函数*********************/

/*工具函数仅供内部部分函数使用*/

/**
  * 函    数：次方函数
  * 参    数：X 底数
  * 参    数：Y 指数
  * 返 回 值：等于X的Y次方
  */
uint32_t OLED_Pow(uint32_t X, uint32_t Y)
{
   
    uint32_t Result = 1;	//结果默认为1
    while (Y --)			//累乘Y次
    {
   
        Result *= X;		//每次把X累乘到结果上
    }
    return Result;
}

/**
  * 函    数：判断指定点是否在指定多边形内部
  * 参    数：nvert 多边形的顶点数
  * 参    数：vertx verty 包含多边形顶点的x和y坐标的数组
  * 参    数：testx testy 测试点的X和y坐标
  * 返 回 值：指定点是否在指定多边形内部，1：在内部，0：不在内部
  */
uint8_t OLED_pnpoly(uint8_t nvert, int16_t *vertx, int16_t *verty, int16_t testx, int16_t testy)
{
   
    int16_t i, j, c = 0;

    /*此算法由W. Randolph Franklin提出*/
    /*参考链接：https://wrfranklin.org/Research/Short_Notes/pnpoly.html*/
    for (i = 0, j = nvert - 1; i < nvert; j = i++)
    {
   
        if (((verty[i] > testy) != (verty[j] > testy)) &&
            (testx < (vertx[j] - vertx[i]) * (testy - verty[i]) / (verty[j] - verty[i]) + vertx[i]))
        {
   
            c = !c;
        }
    }
    return c;
}

/**
  * 函    数：判断指定点是否在指定角度内部
  * 参    数：X Y 指定点的坐标
  * 参    数：StartAngle EndAngle 起始角度和终止角度，范围：-180~180
  *           水平向右为0度，水平向左为180度或-180度，下方为正数，上方为负数，顺时针旋转
  * 返 回 值：指定点是否在指定角度内部，1：在内部，0：不在内部
  */
uint8_t OLED_IsInAngle(int16_t X, int16_t Y, int16_t StartAngle, int16_t EndAngle)
{
   
    int16_t PointAngle;
    PointAngle = atan2(Y, X) / 3.14 * 180;	//计算指定点的弧度，并转换为角度表示
    if (StartAngle < EndAngle)	//起始角度小于终止角度的情况
    {
   
        /*如果指定角度在起始终止角度之间，则判定指定点在指定角度*/
        if (PointAngle >= StartAngle && PointAngle <= EndAngle)
        {
   
            return 1;
        }
    }
    else			//起始角度大于于终止角度的情况
    {
   
        /*如果指定角度大于起始角度或者小于终止角度，则判定指定点在指定角度*/
        if (PointAngle >= StartAngle || PointAngle <= EndAngle)
        {
   
            return 1;
        }
    }
    return 0;		//不满足以上条件，则判断判定指定点不在指定角度
}

/*********************工具函数*/


/*功能函数*********************/

/**
  * 函    数：将OLED显存数组更新到OLED屏幕
  * 参    数：无
  * 返 回 值：无
  * 说    明：所有的显示函数，都只是对OLED显存数组进行读写
  *           随后调用OLED_Update函数或OLED_UpdateArea函数
  *           才会将显存数组的数据发送到OLED硬件，进行显示
  *           故调用显示函数后，要想真正地呈现在屏幕上，还需调用更新函数
  */
void OLED_Update(void)
{
   
    uint8_t j;
    /*遍历每一页*/
    for (j = 0; j < 8; j ++)
    {
   
        /*设置光标位置为每一页的第一列*/
        OLED_SetCursor(j, 0);
        /*连续写入128个数据，将显存数组的数据写入到OLED硬件*/
        OLED_WriteData(OLED_DisplayBuf[j], 128);
    }
}

/**
  * 函    数：将OLED显存数组部分更新到OLED屏幕
  * 参    数：X 指定区域左上角的横坐标，范围：-32768~32767，屏幕区域：0~127
  * 参    数：Y 指定区域左上角的纵坐标，范围：-32768~32767，屏幕区域：0~63
  * 参    数：Width 指定区域的宽度，范围：0~128
  * 参    数：Height 指定区域的高度，范围：0~64
  * 返 回 值：无
  * 说    明：此函数会至少更新参数指定的区域
  *           如果更新区域Y轴只包含部分页，则同一页的剩余部分会跟随一起更新
  * 说    明：所有的显示函数，都只是对OLED显存数组进行读写
  *           随后调用OLED_Update函数或OLED_UpdateArea函数
  *           才会将显存数组的数据发送到OLED硬件，进行显示
  *           故调用显示函数后，要想真正地呈现在屏幕上，还需调用更新函数
  */
void OLED_UpdateArea(int16_t X, int16_t Y, uint8_t Width, uint8_t Height)
{
   
    int16_t j;
    int16_t Page, Page1;

    /*负数坐标在计算页地址时需要加一个偏移*/
    /*(Y + Height - 1) / 8 + 1的目的是(Y + Height) / 8并向上取整*/
    Page = Y / 8;
    Page1 = (Y + Height - 1) / 8 + 1;
    if (Y < 0)
    {
   
        Page -= 1;
        Page1 -= 1;
    }

    /*遍历指定区域涉及的相关页*/
    for (j = Page; j < Page1; j ++)
    {
   
        if (X >= 0 && X <= 127 && j >= 0 && j <= 7)		//超出屏幕的内容不显示
        {
   
            /*设置光标位置为相关页的指定列*/
            OLED_SetCursor(j, X);
            /*连续写入Width个数据，将显存数组的数据写入到OLED硬件*/
            OLED_WriteData(&OLED_DisplayBuf[j][X], Width);
        }
    }
}

/**
  * 函    数：将OLED显存数组全部清零
  * 参    数：无
  * 返 回 值：无
  * 说    明：调用此函数后，要想真正地呈现在屏幕上，还需调用更新函数
  */
void OLED_Clear(void)
{
   
    uint8_t i, j;
    for (j = 0; j < 8; j ++)				//遍历8页
    {
   
        for (i = 0; i < 128; i ++)			//遍历128列
        {
   
            OLED_DisplayBuf[j][i] = 0x00;	//将显存数组数据全部清零
        }
    }
}

/**
  * 函    数：将OLED显存数组部分清零
  * 参    数：X 指定区域左上角的横坐标，范围：-32768~32767，屏幕区域：0~127
  * 参    数：Y 指定区域左上角的纵坐标，范围：-32768~32767，屏幕区域：0~63
  * 参    数：Width 指定区域的宽度，范围：0~128
  * 参    数：Height 指定区域的高度，范围：0~64
  * 返 回 值：无
  * 说    明：调用此函数后，要想真正地呈现在屏幕上，还需调用更新函数
  */
void OLED_ClearArea(int16_t X, int16_t Y, uint8_t Width, uint8_t Height)
{
   
    int16_t i, j;

    for (j = Y; j < Y + Height; j ++)		//遍历指定页
    {
   
        for (i = X; i < X + Width; i ++)	//遍历指定列
        {
   
            if (i >= 0 && i <= 127 && j >=0 && j <= 63)				//超出屏幕的内容不显示
            {
   
                OLED_DisplayBuf[j / 8][i] &= ~(0x01 << (j % 8));	//将显存数组指定数据清零
            }
        }
    }
}

/**
  * 函    数：将OLED显存数组全部取反
  * 参    数：无
  * 返 回 值：无
  * 说    明：调用此函数后，要想真正地呈现在屏幕上，还需调用更新函数
  */
void OLED_Reverse(void)
{
   
    uint8_t i, j;
    for (j = 0; j < 8; j ++)				//遍历8页
    {
   
        for (i = 0; i < 128; i ++)			//遍历128列
        {
   
            OLED_DisplayBuf[j][i] ^= 0xFF;	//将显存数组数据全部取反
        }
    }
}

/**
  * 函    数：将OLED显存数组部分取反
  * 参    数：X 指定区域左上角的横坐标，范围：-32768~32767，屏幕区域：0~127
  * 参    数：Y 指定区域左上角的纵坐标，范围：-32768~32767，屏幕区域：0~63
  * 参    数：Width 指定区域的宽度，范围：0~128
  * 参    数：Height 指定区域的高度，范围：0~64
  * 返 回 值：无
  * 说    明：调用此函数后，要想真正地呈现在屏幕上，还需调用更新函数
  */
void OLED_ReverseArea(int16_t X, int16_t Y, uint8_t Width, uint8_t Height)
{
   
    int16_t i, j;

    for (j = Y; j < Y + Height; j ++)		//遍历指定页
    {
   
        for (i = X; i < X + Width; i ++)	//遍历指定列
        {
   
            if (i >= 0 && i <= 127 && j >=0 && j <= 63)			//超出屏幕的内容不显示
            {
   
                OLED_DisplayBuf[j / 8][i] ^= 0x01 << (j % 8);	//将显存数组指定数据取反
            }
        }
    }
}

/**
  * 函    数：OLED显示一个字符
  * 参    数：X 指定字符左上角的横坐标，范围：-32768~32767，屏幕区域：0~127
  * 参    数：Y 指定字符左上角的纵坐标，范围：-32768~32767，屏幕区域：0~63
  * 参    数：Char 指定要显示的字符，范围：ASCII码可见字符
  * 参    数：FontSize 指定字体大小
  *           范围：OLED_8X16		宽8像素，高16像素
  *                 OLED_6X8		宽6像素，高8像素
  * 返 回 值：无
  * 说    明：调用此函数后，要想真正地呈现在屏幕上，还需调用更新函数
  */
void OLED_ShowChar(int16_t X, int16_t Y, char Char, uint8_t FontSize)
{
   
    if (FontSize == OLED_8X16)		//字体为宽8像素，高16像素
    {
   
        /*将ASCII字模库OLED_F8x16的指定数据以8*16的图像格式显示*/
        OLED_ShowImage(X, Y, 8, 16, OLED_F8x16[Char - ' ']);
    }
    else if(FontSize == OLED_6X8)	//字体为宽6像素，高8像素
    {
   
        /*将ASCII字模库OLED_F6x8的指定数据以6*8的图像格式显示*/
        OLED_ShowImage(X, Y, 6, 8, OLED_F6x8[Char - ' ']);
    }
}

/**
  * 函    数：OLED显示字符串（支持ASCII码和中文混合写入）
  * 参    数：X 指定字符串左上角的横坐标，范围：-32768~32767，屏幕区域：0~127
  * 参    数：Y 指定字符串左上角的纵坐标，范围：-32768~32767，屏幕区域：0~63
  * 参    数：String 指定要显示的字符串，范围：ASCII码可见字符或中文字符组成的字符串
  * 参    数：FontSize 指定字体大小
  *           范围：OLED_8X16		宽8像素，高16像素
  *                 OLED_6X8		宽6像素，高8像素
  * 返 回 值：无
  * 说    明：显示的中文字符需要在OLED_Data.c里的OLED_CF16x16数组定义
  *           未找到指定中文字符时，会显示默认图形（一个方框，内部一个问号）
  *           当字体大小为OLED_8X16时，中文字符以16*16点阵正常显示
  *           当字体大小为OLED_6X8时，中文字符以6*8点阵显示'?'
  * 说    明：调用此函数后，要想真正地呈现在屏幕上，还需调用更新函数
  */
void OLED_ShowString(int16_t X, int16_t Y, char *String, uint8_t FontSize)
{
   
    uint16_t i = 0;
    char SingleChar[5];
    uint8_t CharLength = 0;
    uint16_t XOffset = 0;
    uint16_t pIndex;

    while (String[i] != '\0')	//遍历字符串
    {
   

#ifdef OLED_CHARSET_UTF8						//定义字符集为UTF8
        /*此段代码的目的是，提取UTF8字符串中的一个字符，转存到SingleChar子字符串中*/
		/*判断UTF8编码第一个字节的标志位*/
		if ((String[i] & 0x80) == 0x00)			//第一个字节为0xxxxxxx
		{
   
			CharLength = 1;						//字符为1字节
			SingleChar[0] = String[i ++];		//将第一个字节写入SingleChar第0个位置，随后i指向下一个字节
			SingleChar[1] = '\0';				//为SingleChar添加字符串结束标志位
		}
		else if ((String[i] & 0xE0) == 0xC0)	//第一个字节为110xxxxx
		{
   
			CharLength = 2;						//字符为2字节
			SingleChar[0] = String[i ++];		//将第一个字节写入SingleChar第0个位置，随后i指向下一个字节
			if (String[i] == '\0') {
   break;}		//意外情况，跳出循环，结束显示
			SingleChar[1] = String[i ++];		//将第二个字节写入SingleChar第1个位置，随后i指向下一个字节
			SingleChar[2] = '\0';				//为SingleChar添加字符串结束标志位
		}
		else if ((String[i] & 0xF0) == 0xE0)	//第一个字节为1110xxxx
		{
   
			CharLength = 3;						//字符为3字节
			SingleChar[0] = String[i ++];
			if (String[i] == '\0') {
   break;}
			SingleChar[1] = String[i ++];
			if (String[i] == '\0') {
   break;}
			SingleChar[2] = String[i ++];
			SingleChar[3] = '\0';
		}
		else if ((String[i] & 0xF8) == 0xF0)	//第一个字节为11110xxx
		{
   
			CharLength = 4;						//字符为4字节
			SingleChar[0] = String[i ++];
			if (String[i] == '\0') {
   break;}
			SingleChar[1] = String[i ++];
			if (String[i] == '\0') {
   break;}
			SingleChar[2] = String[i ++];
			if (String[i] == '\0') {
   break;}
			SingleChar[3] = String[i ++];
			SingleChar[4] = '\0';
		}
		else
		{
   
			i ++;			//意外情况，i指向下一个字节，忽略此字节，继续判断下一个字节
			continue;
		}
#endif

#ifdef OLED_CHARSET_GB2312						//定义字符集为GB2312
        /*此段代码的目的是，提取GB2312字符串中的一个字符，转存到SingleChar子字符串中*/
		/*判断GB2312字节的最高位标志位*/
		if ((String[i] & 0x80) == 0x00)			//最高位为0
		{
   
			CharLength = 1;						//字符为1字节
			SingleChar[0] = String[i ++];		//将第一个字节写入SingleChar第0个位置，随后i指向下一个字节
			SingleChar[1] = '\0';				//为SingleChar添加字符串结束标志位
		}
		else									//最高位为1
		{
   
			CharLength = 2;						//字符为2字节
			SingleChar[0] = String[i ++];		//将第一个字节写入SingleChar第0个位置，随后i指向下一个字节
			if (String[i] == '\0'

最低0.47元/天解锁文章