Драйвер OLED-дисплея 0,96 дюйма на базе STM32F1 с аппаратным/программным I2C

zeruns · 30.Октябрь.2025 14:52:05

Драйвер для OLED-дисплея 0,96 дюйма на базе STM32F103 (4-контактный интерфейс I2C), поддержка аппаратного и программного IIC.

Этот драйвер довольно функционален: вывод английского текста, целых и дробных чисел, китайских иероглифов, изображений, двоичных и шестнадцатеричных значений; поддержка рисования точек, линий, прямоугольников, окружностей, эллипсов, треугольников; несколько шрифтов — по сути упрощённая графическая библиотека.

Программа основана на коде Jiangxie Technology; оригинал работал только с программным I2C, я добавил поддержку аппаратного I2C и возможность переключения через макрос обратно на программную реализацию.

Написано на стандартной библиотеке ST.

Тестировалось на STM32F103C8T6 и AIR32F103CBT6 — оба контроллера работают. При аппаратном I2C STM32 достигает 1,3 Мбит/с, AIR32 — максимум 600 кбит/с.

Принцип работы OLED и инструкция по использованию драйвера — в видео Jiangxie Technology: https://url.zeruns.com/L7j6y

STM32 + аппаратный I2C + датчик SHTC3: https://blog.zeruns.com/archives/692.html

Шаблон проекта STM32F407 с портированной U8g2: https://blog.zeruns.com/archives/722.html

Чат по электронике/микроконтроллерам: 2169025065

Результаты работы

Кратко об I2C

Протокол I²C (Inter-Integrated Circuit) разработан Philips. Требует минимум выводов, прост в железе, легко масштабируется, не нуждается в дополнительных трансиверах (в отличие от USART, CAN и т. д.) и потому широко используется для связи микросхем внутри устройства.

I²C имеет всего одну линию данных SDA (Serial Data Line), по которой информация передаётся последовательно, побитно — полудуплексный режим.

Полудуплекс: двунаправленный обмен, но одновременно передавать можно только в одну сторону; достаточно одной линии данных.

Разделяют физический и протокольный уровни: первый описывает электрические/механические особенности (железо), второй — логику обмена (программное обеспечение).

Физический уровень I²C

Типичное подключение устройств I²C

Шина поддерживает много устройств. «Шина» — общие сигнальные линии. На одной I²C-шине может быть несколько мастеров и несколько ведомых.
Две линии: SDA (данные) и SCL (синхронизация).
Подтяжка к питанию через резисторы. Когда устройство неактивно, оно переходит в высокоимпеданное состояние; если все устройства в этом состоянии, резисторы подтягивают шину к логической «1».

Для I²C выводы микроконтроллера настраиваются как open-drain, иначе возможно короткое замыкание.

Подробнее о STM32 + I²C: https://url.zeruns.com/JC0Ah
Курс Jiangxie Technology по STM32: https://www.bilibili.com/video/BV1th411z7sn?p=31

Необходимые компоненты

Набор для начала работы с STM32: https://u.jd.com/fQS0YAe
Минимальная плата STM32F103: https://s.click.taobao.com/TsFFvwt
OLED-модуль: https://s.click.taobao.com/EF0Evwt
Джамперы: https://s.click.taobao.com/VMkDvwt
Макетная плата: https://s.click.taobao.com/bhg8Txt
DAPLink (заменяет ST-Link, есть виртуальный COM-порт): https://s.click.taobao.com/QVQ8Txt

Набор Jiangxie Technology для начала работы с STM32: https://s.click.taobao.com/NTn9Txt

Проект

Скачать полный архив:

Baidu NetDisk: https://url.zeruns.com/kSxoe Код: wgc3

123 Pan (без ограничения скорости): https://www.123pan.com/s/2Y9Djv-HGcvH.html Код: m7sp

Проект создан в Keil5, разработка вёлась в VScode + EIDE; обе IDE открывают проект без проблем.

Все файлы проекта в кодировке UTF-8; при отображении кракозябр нужно переключить редактор в UTF-8.

Файл main.c:

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"

/**
 * @brief Переключает уровень указанного вывода GPIO.
 * 
 * @param GPIOx Указатель на порт, например GPIOA, GPIOB и т. д.
 * @param GPIO_Pin Номер вывода (можно комбинировать).
 * 
 * Функция читает текущий уровень вывода: если 0 — устанавливает 1, если 1 — сбрасывает в 0.
 */
void GPIO_TogglePin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)
{
    if (GPIO_ReadOutputDataBit(GPIOx, GPIO_Pin) == Bit_RESET)
    {
        GPIO_SetBits(GPIOx, GPIO_Pin);
    }
    else
    {
        GPIO_ResetBits(GPIOx, GPIO_Pin);
    }
}
``````c
int main(void)
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE); // Включить тактирование порта GPIOC
	// Инициализация выводов GPIO
    GPIO_InitTypeDef GPIO_InitStructure;                // Определить структуру для конфигурации GPIO
    GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_Out_PP;   // Режим – push-pull, требуется подтягивающий резистор
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;   // Скорость 50 МГц
    GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_13;        // Выбрать 13-й вывод
    GPIO_Init(GPIOC, &GPIO_InitStructure);              // Инициализировать GPIO

	GPIO_TogglePin(GPIOC, GPIO_Pin_13);	// Мигнуть светодиодом

	/*Инициализация OLED*/
	OLED_Init();
	
	/*Показать символ 'A' в позиции (0, 0), шрифт 8×16*/
	//OLED_ShowChar(0, 0, 'A', OLED_8X16);
	
	/*Показать строку "blog.zeruns.com" в позиции (0, 0), шрифт 8×16*/
	OLED_ShowString(0, 0, "blog.zeruns.com", OLED_8X16);
	
	/*Показать символ 'A' в позиции (0, 18), шрифт 6×8*/
	OLED_ShowChar(0, 18, 'A', OLED_6X8);
	
	/*Показать строку "Hello World!" в позиции (16, 18), шрифт 6×8*/
	OLED_ShowString(16, 18, "Hello World!", OLED_6X8);
	
	/*Показать число 12345 в позиции (0, 28), длина 5, шрифт 6×8*/
	OLED_ShowNum(0, 28, 12345, 5, OLED_6X8);
	
	/*Показать знаковое число -66 в позиции (40, 28), длина 2, шрифт 6×8*/
	OLED_ShowSignedNum(40, 28, -66, 2, OLED_6X8);
	
	/*Показать шестнадцатеричное 0xA5A5 в позиции (70, 28), длина 4, шрифт 6×8*/
	OLED_ShowHexNum(70, 28, 0xA5A5, 4, OLED_6X8);
	
	/*Показать двоичное 0xA5 в позиции (0, 38), длина 8, шрифт 6×8*/
	OLED_ShowBinNum(0, 38, 0xA5, 8, OLED_6X8);
	
	/*Показать float 123.45 в позиции (60, 38), целых 3, дробных 2, шрифт 6×8*/
	OLED_ShowFloatNum(60, 38, 123.45, 3, 2, OLED_6X8);
	
	/*Показать китайские иероглифы "你好，世界。" в позиции (0, 48), фикс. 16×16*/
	OLED_ShowChinese(0, 48, "你好，世界。");
	
	/*Показать изображение 16×16 пикселей в позиции (96, 48), данные – массив Diode*/
	OLED_ShowImage(96, 48, 16, 16, Diode);
	
	/*Вывести форматированную строку "[%02d]" в позиции (96, 18), шрифт 6×8*/
	OLED_Printf(96, 18, OLED_6X8, "[%02d]", 6);
	
	/*Обновить экран OLED*/
	OLED_Update();
	
	/*Задержка 3000 мс для наблюдения*/
	Delay_ms(3000);

	GPIO_TogglePin(GPIOC, GPIO_Pin_13);	// Мигнуть светодиодом
	
	/*Очистить буфер OLED*/
	OLED_Clear();
	
	/*Поставить точку в (5, 8)*/
	OLED_DrawPoint(5, 8);
	
	/*Прочитать состояние точки (5, 8)*/
	if (OLED_GetPoint(5, 8))
	{
		/*Если точка горит – показать "YES" в (10, 4), шрифт 6×8*/
		OLED_ShowString(10, 4, "YES", OLED_6X8);
	}
	else
	{
		/*Иначе – показать "NO " в (10, 4), шрифт 6×8*/
		OLED_ShowString(10, 4, "NO ", OLED_6X8);
	}
	
	/*Нарисовать линию между (40, 0) и (127, 15)*/
	OLED_DrawLine(40, 0, 127, 15);
	
	/*Нарисовать линию между (40, 15) и (127, 0)*/
	OLED_DrawLine(40, 15, 127, 0);
	
	/*Нарисовать прямоугольник 12×15 в (0, 20), не заливать*/
	OLED_DrawRectangle(0, 20, 12, 15, OLED_UNFILLED);
	
	/*Нарисовать прямоугольник 12×15 в (0, 40), заливать*/
	OLED_DrawRectangle(0, 40, 12, 15, OLED_FILLED);
	
	/*Нарисовать треугольник по точкам (20,20)-(40,25)-(30,35), не заливать*/
	OLED_DrawTriangle(20, 20, 40, 25, 30, 35, OLED_UNFILLED);
	
	/*Нарисовать треугольник по точкам (20,40)-(40,45)-(30,55), заливать*/
	OLED_DrawTriangle(20, 40, 40, 45, 30, 55, OLED_FILLED);
	
	/*Нарисовать окружность радиусом 8 в (55, 27), не заливать*/
	OLED_DrawCircle(55, 27, 8, OLED_UNFILLED);
	
	/*Нарисовать окружность радиусом 8 в (55, 47), заливать*/
	OLED_DrawCircle(55, 47, 8, OLED_FILLED);
	
	/*Нарисовать эллипс 12×8 в (82, 27), не заливать*/
	OLED_DrawEllipse(82, 27, 12, 8, OLED_UNFILLED);
	// https://blog.zeruns.com
	/*Нарисовать эллипс 12×8 в (82, 47), заливать*/
	OLED_DrawEllipse(82, 47, 12, 8, OLED_FILLED);
	
	/*Нарисовать дугу радиусом 15, углы 25°–125°, в (110, 18), не заливать*/
	OLED_DrawArc(110, 18, 15, 25, 125, OLED_UNFILLED);
	
	/*Нарисовать дугу радиусом 15, углы 25°–125°, в (110, 38), заливать*/
	OLED_DrawArc(110, 38, 15, 25, 125, OLED_FILLED);
	
	/*Обновить экран OLED*/
	OLED_Update();
	
	/*Задержка 1500 мс для наблюдения*/
	Delay_ms(1500);

	GPIO_TogglePin(GPIOC, GPIO_Pin_13);	// Мигнуть светодиодом
	
	while (1)
	{
		for (uint8_t i = 0; i < 4; i ++)
		{
			/*Инвертировать область 128×16 пикселей, начиная с (0, i*16)*/
			OLED_ReverseArea(0, i * 16, 128, 16);
			
			/*Обновить экран*/
			OLED_Update();
			
			/*Задержка 1000 мс*/
			Delay_ms(1000);
			
			/*Вернуть инверсию обратно*/
			OLED_ReverseArea(0, i * 16, 128, 16);

			GPIO_TogglePin(GPIOC, GPIO_Pin_13);	// Мигнуть светодиодом
		}
		// https://blog.zeruns.com
		/*Инвертировать весь экран*/
		OLED_Reverse();
		
		/*Обновить экран*/
		OLED_Update();
		
		/*Задержка 1000 мс*/
		Delay_ms(1000);

		GPIO_TogglePin(GPIOC, GPIO_Pin_13);	// Мигнуть светодиодом
	}
}

Файл OLED.c:


/***************************************************************************************
 * Эта программа создана Jiangxie Technology и распространяется бесплатно как open-source
 * Вы можете свободно просматривать, использовать и изменять её для своих проектов
 * Авторские права принадлежат Jiangxie Technology; никто не может присвоить её себе
 *
 * Название:			Драйвер OLED-дисплея 0.96" (4-пиновый I2C)
 * Дата создания:			24.10.2023
 * Текущая версия:		V1.1
 * Дата релиза текущей версии:	08.12.2023
 *
 * Официальный сайт Jiangxie Technology:	jiangxiekeji.com
 * Официальный магазин на Taobao:		jiangxiekeji.taobao.com
 * Описание и обновления:			jiangxiekeji.com/tutorial/oled.html
 *
 * Если вы нашли баг или опечатку, пришлите письмо:	[email protected]
 * Перед отправкой проверьте страницу обновлений — возможно, проблема уже исправлена
 ***************************************************************************************
 */

/*
 * Модифицировано zeruns
 * Изменения:	Добавлена поддержка аппаратного I2C (переключается макросом)
 * Дата:	25.02.2024
 * Блог:	https://blog.zeruns.com
 * Bilibili:	https://space.bilibili.com/8320520
*/

#include "stm32f10x.h"
#include "OLED.h"
#include <cstring>
```.h>
#include <math.h>
#include <stdio.h>
#include <stdarg.h>

// 如果用到中文，编译器附加选项需要加 --no-multibyte-chars

/*
选择OLED驱动方式，默认使用硬件I2C。如果要用软件I2C就将硬件I2C那行的宏定义注释掉，将软件I2C那行的注释取消。
不能同时两个都同时取消注释！
*/
#define OLED_USE_HW_I2C		// 硬件I2C
//#define OLED_USE_SW_I2C	// 软件I2C

/*引脚定义，可在此处修改I2C通信引脚*/
#define OLED_SCL  GPIO_Pin_6 // SCL
#define OLED_SDA  GPIO_Pin_7 // SDA
#define OLED_GPIO GPIOB
#define OLED_RCC  RCC_APB2Periph_GPIOB
/*STM32F103芯片的硬件I2C1: PB6 -- SCL; PB7 -- SDA */

/*I2C接口，定义OLED屏使用哪个I2C接口*/
#define OLED_I2C     I2C1
#define OLED_I2C_RCC RCC_APB1Periph_I2C1

/*OLED从机地址*/
#define OLED_ADDRESS 0x3C << 1	// 0x3C是OLED的7位地址，左移1位最后位做读写位变成0x78

/*I2C超时时间*/
#define OLED_I2C_TIMEOUT 1000

/**
 * 数据存储格式：
 * 纵向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];
/*********************全局变量*/

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

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

/**
 * 函    数：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++)
            ;
    }
#ifdef OLED_USE_HW_I2C
    RCC_APB1PeriphClockCmd(OLED_I2C_RCC, ENABLE); 	// 使能I2C1时钟
#endif
    RCC_APB2PeriphClockCmd(OLED_RCC, ENABLE);		// 使能GPIO时钟

	GPIO_InitTypeDef GPIO_InitStructure;                 // 定义结构体配置GPIO
#ifdef OLED_USE_HW_I2C
    GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF_OD;     // 设置GPIO模式为复用开漏模式，需接上拉电阻
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;    // 设置GPIO速度为50MHz
    GPIO_InitStructure.GPIO_Pin   = OLED_SCL | OLED_SDA; // 设置引脚为OLED_SCL和OLED_SDA
    GPIO_Init(OLED_GPIO, &GPIO_InitStructure);           // 初始化GPIO
#elif defined(OLED_USE_SW_I2C)
 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;	// 设置GPIO模式为开漏输出模式，需接上拉电阻
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Pin   = OLED_SCL | OLED_SDA;// 设置引脚为OLED_SCL和OLED_SDA
 	GPIO_Init(OLED_GPIO, &GPIO_InitStructure);
	/*释放SCL和SDA*/
	OLED_W_SCL(1);
	OLED_W_SDA(1);
#endif

#ifdef OLED_USE_HW_I2C
    I2C_DeInit(OLED_I2C);                                                     // 将外设I2C寄存器重设为缺省值
    I2C_InitTypeDef I2C_InitStructure;                                        // 定义结构体配置I2C
    I2C_InitStructure.I2C_Mode                = I2C_Mode_I2C;                 // 工作模式
    I2C_InitStructure.I2C_DutyCycle           = I2C_DutyCycle_2;              // 时钟占空比，Tlow/Thigh = 2
    I2C_InitStructure.I2C_OwnAddress1         = 0x30;                         // 主机的I2C地址,用不到则随便写，无影响
    I2C_InitStructure.I2C_Ack                 = I2C_Ack_Enable;               // 使能应答位
    I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit; // 设置地址长度7位
    I2C_InitStructure.I2C_ClockSpeed          = 600000;// 设置I2C时钟频率，600kHz，建议设置400kHz(比较稳定)，实测在STM32F103上最高可以跑1.3MHz，在AIR32F103上最高只能跑600kHz。
    I2C_Init(OLED_I2C, &I2C_InitStructure);                                   // 初始化I2C

    I2C_Cmd(OLED_I2C, ENABLE); // 使能I2C
#endif
}

// https://blog.zeruns.com

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

/**
 * 函    数：I2C起始
 * 参    数：无
 * 返 回 值：无
 */
void OLED_I2C_Start(void)
{
#ifdef OLED_USE_HW_I2C
    for(uint16_t i = 0; I2C_GetFlagStatus(OLED_I2C, I2C_FLAG_BUSY) && i < OLED_I2C_TIMEOUT; i++);	// 判断IIC总线是否忙碌
    I2C_GenerateSTART(OLED_I2C, ENABLE); 					// 发送起始信号
    // 检查I2C的事件。事件（Event）是指I2C1状态发生变化时产生的信号。这里检查EV5（表示主模式）事件，直到其发生。这表示I2C已经成功切换到Master模式。
    for(uint16_t i = 0; !I2C_CheckEvent(OLED_I2C, I2C_EVENT_MASTER_MODE_SELECT) && i < OLED_I2C_TIMEOUT; i++);
    I2C_Send7bitAddress(OLED_I2C, OLED_ADDRESS, I2C_Direction_Transmitter); // 发送7位地址，I2C通信进入发送模式。
    for(uint16_t i = 0; !I2C_CheckEvent(OLED_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) && i < OLED_I2C_TIMEOUT; i++); // 检测EV6事件，判断I2C通信是否进入发送模式
#elif defined(OLED_USE_SW_I2C)
	OLED_W_SDA(1);		//释放SDA，确保SDA为高电平
	OLED_W_SCL(1);		//释放SCL，确保SCL为高电平
	OLED_W_SDA(0);		//在SCL高电平期间，拉低SDA，产生起始信号
	OLED_W_SCL(0);		//起始后把SCL也拉低，即为了占用总线，也为了方便总线时序的拼接
#endif
}

/**
 * 函    数：I2C终止
 * 参    数：无
 * 返 回 值：无
 */
void OLED_I2C_Stop(void)
{
#ifdef OLED_USE_HW_I2C
    I2C_GenerateSTOP(OLED_I2C, ENABLE); // 关闭I2C1总线
#elif defined(OLED_USE_SW_I2C)
	OLED_W_SDA(0);		//拉低SDA，确保SDA为低电平
	OLED_W_SCL(1);		//释放SCL，使SCL呈现高电平
	OLED_W_SDA(1);		//在SCL高电平期间，释放SDA，产生终止信号
#endif
}

/**
 * 函    数：I2C发送一个字节
 * 参    数：Byte 要发送的一个字节数据，范围：0x00~0xFF
 * 返 回 值：无
 */
void OLED_I2C_SendByte(uint8_t Byte)
{
#ifdef OLED_USE_HW_I2C
    I2C_SendData(OLED_I2C, Byte);	// 发送一个字节
	// 检测EV8_2事件，判断I2C是否发送完成
    for(uint16_t i = 0; I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED) != 1 && i < OLED_I2C_TIMEOUT; i++);
#elif defined(OLED_USE_SW_I2C)
	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);
#endif
}

/**
 * 函    数：OLED写命令
 * 参    数：Command 要写入的命令值，范围：0x00~0xFF
 * 返 回 值：无
 */
void OLED_WriteCommand(uint8_t Command)
{
    OLED_I2C_Start();           // I2C起始
#ifdef OLED_USE_SW_I2C
	OLED_I2C_SendByte(0x78);		//发送OLED的I2C从机地址
#endif
	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起始
#ifdef OLED_USE_SW_I2C
	OLED_I2C_SendByte(0x78);		//发送OLED的I2C从机地址
#endif
    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 записывает по 8 бит за раз, т.е. 1 страница = 8 пикселей по оси Y
 */
void OLED_SetCursor(uint8_t Page, uint8_t X)
{
    /*Если используется OLED 1.3", раскомментируйте следующую строку*/
    /*У драйвера SH1106 132 колонки, первый пиксель экрана начинается со 2-й*/
    /*Поэтому X нужно сдвинуть на +2*/
    //	X += 2;

    /*Установка страницы и столбца через команды*/
    OLED_WriteCommand(0xB0 | Page);              // Установка страницы
    OLED_WriteCommand(0x10 | ((X & 0xF0) >> 4)); // Старшие 4 бита X
    OLED_WriteCommand(0x00 | (X & 0x0F));        // Младшие 4 бита X
}

/*********************Аппаратная конфигурация*/

/*Служебные функции*********************/

/*Служебные функции используются только внутри модуля*/

/**
 * Функция: возведение в степень
 * Параметры: X — основание
 * Параметры: Y — показатель степени
 * Возвращаемое значение: X в степени Y
 */
uint32_t OLED_Pow(uint32_t X, uint32_t Y)
{
    uint32_t Result = 1; // Результат по умолчанию 1
    while (Y--)          // Умножаем Y раз
    {
        Result *= X;
    }
    return Result;
}

/**
 * Функция: проверка, находится ли точка внутри многоугольника
 * Параметры: nvert — количество вершин многоугольника
 * Параметры: vertx, verty — массивы координат вершин
 * Параметры: testx, testy — координаты проверяемой точки
 * Возвращаемое значение: 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;

    /*Алгоритм У. Рэндольфа Франклина*/
    /*Ссылка: 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_Update или OLED_UpdateArea
 */
void OLED_Update(void)
{
    uint8_t j;
    for (j = 0; j < 8; j++) {
        OLED_SetCursor(j, 0);
        OLED_WriteData(OLED_DisplayBuf[j], 128);
    }
}

/**
 * Функция: частичное обновление буфера дисплея
 * Параметры: X, Y — координаты левого верхнего угла области
 * Параметры: Width, Height — ширина и высота области
 * Возвращаемое значение: нет
 * Примечание: обновляется минимум заданная область
 *             Если область частично покрывает страницу, обновляется вся страница
 */
void OLED_UpdateArea(uint8_t X, uint8_t Y, uint8_t Width, uint8_t Height)
{
    uint8_t j;

    if (X > 127) { return; }
    if (Y > 63) { return; }
    if (X + Width > 128) { Width = 128 - X; }
    if (Y + Height > 64) { Height = 64 - Y; }

    for (j = Y / 8; j < (Y + Height - 1) / 8 + 1; j++) {
        OLED_SetCursor(j, X);
        OLED_WriteData(&OLED_DisplayBuf[j][X], Width);
    }
}

/**
 * Функция: полная очистка буфера дисплея
 * Параметры: нет
 * Возвращаемое значение: нет
 * Примечание: для отображения на экран требуется вызвать обновление
 */
void OLED_Clear(void)
{
    uint8_t i, j;
    for (j = 0; j < 8; j++) {
        for (i = 0; i < 128; i++) {
            OLED_DisplayBuf[j][i] = 0x00;
        }
    }
}

/**
 * Функция: очистка заданной области буфера
 * Параметры: X, Y — координаты левого верхнего угла
 * Параметры: Width, Height — ширина и высота
 * Возвращаемое значение: нет
 */
void OLED_ClearArea(uint8_t X, uint8_t Y, uint8_t Width, uint8_t Height)
{
    uint8_t i, j;

    if (X > 127) { return; }
    if (Y > 63) { return; }
    if (X + Width > 128) { Width = 128 - X; }
    if (Y + Height > 64) { Height = 64 - Y; }

    for (j = Y; j < Y + Height; j++) {
        for (i = X; i < X + Width; i++) {
            OLED_DisplayBuf[j / 8][i] &= ~(0x01 << (j % 8));
        }
    }
}

/**
 * Функция: инвертирование всего буфера
 * Параметры: нет
 * Возвращаемое значение: нет
 */
void OLED_Reverse(void)
{
    uint8_t i, j;
    for (j = 0; j < 8; j++) {
        for (i = 0; i < 128; i++) {
            OLED_DisplayBuf[j][i] ^= 0xFF;
        }
    }
}

/**
 * Функция: инвертирование заданной области буфера
 * Параметры: X, Y — координаты левого верхнего угла
 * Параметры: Width, Height — ширина и высота
 * Возвращаемое значение: нет
 */
void OLED_ReverseArea(uint8_t X, uint8_t Y, uint8_t Width, uint8_t Height)
{
    uint8_t i, j;

    if (X > 127) { return; }
    if (Y > 63) { return; }
    if (X + Width > 128) { Width = 128 - X; }
    if (Y + Height > 64) { Height = 64 - Y; }

    for (j = Y; j < Y + Height; j++) {
        for (i = X; i < X + Width; i++) {
            OLED_DisplayBuf[j / 8][i] ^= 0x01 << (j % 8);
        }
    }
}

/**
 * Функция: вывод одного символа
 * Параметры: X, Y — координаты левого верхнего угла
 * Параметры: Char — символ ASCII
 * Параметры: FontSize — размер шрифта
 *           OLED_8X16: 8×16 пикселей
 *           OLED_6X8: 6×8 пикселей
 * Возвращаемое значение: нет
 */
void OLED_ShowChar(uint8_t X, uint8_t Y, char Char, uint8_t FontSize)
{
    if (FontSize == OLED_8X16) {
        OLED_ShowImage(X, Y, 8, 16, OLED_F8x16[Char - ' ']);
    } else if (FontSize == OLED_6X8) {
        OLED_ShowImage(X, Y, 6, 8, OLED_F6x8[Char - ' ']);
    }
}

/**
 * Функция: вывод строки
 * Параметры: X, Y — координаты левого верхнего угла
 * Параметры: String — строка из символов ASCII
 * Параметры: FontSize — размер шрифта
 * Возвращаемое значение: нет
 */
void OLED_ShowString(uint8_t X, uint8_t Y, char *String, uint8_t FontSize)
{
    uint8_t i;
    for (i = 0; String[i] != '\0'; i++) {
        OLED_ShowChar(X + i * FontSize, Y, String[i], FontSize);
    }
}/**
 * Функция: OLED отображение числа (десятичное, положительное целое)
 * Параметры: X — горизонтальная координата левого верхнего угла числа, диапазон: 0~127
 * Параметры: Y — вертикальная координата левого верхнего угла числа, диапазон: 0~63
 * Параметры: Number — отображаемое число, диапазон: 0~4294967295
 * Параметры: Length — длина числа, диапазон: 0~10
 * Параметры: FontSize — размер шрифта
 *           Диапазон: OLED_8X16        ширина 8 пикселей, высота 16 пикселей
 *                     OLED_6X8         ширина 6 пикселей, высота 8 пикселей
 * Возвращаемое значение: нет
 * Примечание: после вызова этой функции для реального отображения на экране необходимо вызвать функцию обновления
 */
void OLED_ShowNum(uint8_t X, uint8_t Y, uint32_t Number, uint8_t Length, uint8_t FontSize)
{
    uint8_t i;
    for (i = 0; i < Length; i++) // перебираем каждую цифру числа
    {
        /*вызываем OLED_ShowChar для последовательного отображения каждой цифры*/
        /*Number / OLED_Pow(10, Length - i - 1) % 10 извлекает каждую цифру в десятичном формате*/
        /*+ '0' преобразует цифру в символ*/
        OLED_ShowChar(X + i * FontSize, Y, Number / OLED_Pow(10, Length - i - 1) % 10 + '0', FontSize);
    }
}

/**
 * Функция: OLED отображение знакового числа (десятичное, целое)
 * Параметры: X — горизонтальная координата левого верхнего угла числа, диапазон: 0~127
 * Параметры: Y — вертикальная координата левого верхнего угла числа, диапазон: 0~63
 * Параметры: Number — отображаемое число, диапазон: -2147483648~2147483647
 * Параметры: Length — длина числа, диапазон: 0~10
 * Параметры: FontSize — размер шрифта
 *           Диапазон: OLED_8X16        ширина 8 пикселей, высота 16 пикселей
 *                     OLED_6X8         ширина 6 пикселей, высота 8 пикселей
 * Возвращаемое значение: нет
 * Примечание: после вызова этой функции для реального отображения на экране необходимо вызвать функцию обновления
 */
void OLED_ShowSignedNum(uint8_t X, uint8_t Y, int32_t Number, uint8_t Length, uint8_t FontSize)
{
    uint8_t i;
    uint32_t Number1;

    if (Number >= 0) // число больше или равно 0
    {
        OLED_ShowChar(X, Y, '+', FontSize); // отображаем знак +
        Number1 = Number;                   // Number1 равно Number
    } else                                  // число меньше 0
    {
        OLED_ShowChar(X, Y, '-', FontSize); // отображаем знак -
        Number1 = -Number;                  // Number1 равно -Number
    }

    for (i = 0; i < Length; i++) // перебираем каждую цифру числа
    {
        /*вызываем OLED_ShowChar для последовательного отображения каждой цифры*/
        /*Number1 / OLED_Pow(10, Length - i - 1) % 10 извлекает каждую цифру в десятичном формате*/
        /*+ '0' преобразует цифру в символ*/
        OLED_ShowChar(X + (i + 1) * FontSize, Y, Number1 / OLED_Pow(10, Length - i - 1) % 10 + '0', FontSize);
    }
}

/**
 * Функция: OLED отображение шестнадцатеричного числа (шестнадцатеричное, положительное целое)
 * Параметры: X — горизонтальная координата левого верхнего угла числа, диапазон: 0~127
 * Параметры: Y — вертикальная координата левого верхнего угла числа, диапазон: 0~63
 * Параметры: Number — отображаемое число, диапазон: 0x00000000~0xFFFFFFFF
 * Параметры: Length — длина числа, диапазон: 0~8
 * Параметры: FontSize — размер шрифта
 *           Диапазон: OLED_8X16        ширина 8 пикселей, высота 16 пикселей
 *                     OLED_6X8         ширина 6 пикселей, высота 8 пикселей
 * Возвращаемое значение: нет
 * Примечание: после вызова этой функции для реального отображения на экране необходимо вызвать функцию обновления
 */
void OLED_ShowHexNum(uint8_t X, uint8_t Y, uint32_t Number, uint8_t Length, uint8_t FontSize)
{
    uint8_t i, SingleNumber;
    for (i = 0; i < Length; i++) // перебираем каждую цифру числа
    {
        /*извлекаем каждую цифру в шестнадцатеричном формате*/
        SingleNumber = Number / OLED_Pow(16, Length - i - 1) % 16;

        if (SingleNumber < 10) // если цифра меньше 10
        {
            /*вызываем OLED_ShowChar для отображения этой цифры*/
            /*+ '0' преобразует цифру в символ*/
            OLED_ShowChar(X + i * FontSize, Y, SingleNumber + '0', FontSize);
        } else // если цифра больше или равна 10
        {
            /*вызываем OLED_ShowChar для отображения этой цифры*/
            /*+ 'A' преобразует цифру в шестнадцатеричный символ, начиная с A*/
            OLED_ShowChar(X + i * FontSize, Y, SingleNumber - 10 + 'A', FontSize);
        }
    }
}

/**
 * Функция: OLED отображение двоичного числа (двоичное, положительное целое)
 * Параметры: X — горизонтальная координата левого верхнего угла числа, диапазон: 0~127
 * Параметры: Y — вертикальная координата левого верхнего угла числа, диапазон: 0~63
 * Параметры: Number — отображаемое число, диапазон: 0x00000000~0xFFFFFFFF
 * Параметры: Length — длина числа, диапазон: 0~16
 * Параметры: FontSize — размер шрифта
 *           Диапазон: OLED_8X16        ширина 8 пикселей, высота 16 пикселей
 *                     OLED_6X8         ширина 6 пикселей, высота 8 пикселей
 * Возвращаемое значение: нет
 * Примечание: после вызова этой функции для реального отображения на экране необходимо вызвать функцию обновления
 */
void OLED_ShowBinNum(uint8_t X, uint8_t Y, uint32_t Number, uint8_t Length, uint8_t FontSize)
{
    uint8_t i;
    for (i = 0; i < Length; i++) // перебираем каждый бит числа
    {
        /*вызываем OLED_ShowChar для последовательного отображения каждого бита*/
        /*Number / OLED_Pow(2, Length - i - 1) % 2 извлекает каждый бит в двоичном формате*/
        /*+ '0' преобразует бит в символ*/
        OLED_ShowChar(X + i * FontSize, Y, Number / OLED_Pow(2, Length - i - 1) % 2 + '0', FontSize);
    }
}

/**
 * Функция: OLED отображение числа с плавающей точкой (десятичное, дробное)
 * Параметры: X — горизонтальная координата левого верхнего угла числа, диапазон: 0~127
 * Параметры: Y — вертикальная координата левого верхнего угла числа, диапазон: 0~63
 * Параметры: Number — отображаемое число, диапазон: -4294967295.0~4294967295.0
 * Параметры: IntLength — длина целой части, диапазон: 0~10
 * Параметры: FraLength — длина дробной части, диапазон: 0~9, дробная часть округляется
 * Параметры: FontSize — размер шрифта
 *           Диапазон: OLED_8X16        ширина 8 пикселей, высота 16 пикселей
 *                     OLED_6X8         ширина 6 пикселей, высота 8 пикселей
 * Возвращаемое значение: нет
 * Примечание: после вызова этой функции для реального отображения на экране необходимо вызвать функцию обновления
 */
void OLED_ShowFloatNum(uint8_t X, uint8_t Y, double Number, uint8_t IntLength, uint8_t FraLength, uint8_t FontSize)
{
    uint32_t PowNum, IntNum, FraNum;

    if (Number >= 0) // число больше или равно 0
    {
        OLED_ShowChar(X, Y, '+', FontSize); // отображаем знак +
    } else                                  // число меньше 0
    {
        OLED_ShowChar(X, Y, '-', FontSize); // отображаем знак -
        Number = -Number;                   // меняем знак Number
    }

    /*извлекаем целую и дробную части*/
    IntNum = Number;                  // присваиваем целой переменной, извлекаем целую часть
    Number -= IntNum;                 // убираем целую часть из Number, чтобы избежать переполнения при умножении дробной части
    PowNum = OLED_Pow(10, FraLength); // определяем множитель по количеству знаков дробной части
    FraNum = round(Number * PowNum);  // умножаем дробную часть на множитель и округляем, чтобы избежать ошибок отображения
    IntNum += FraNum / PowNum;        // если округление вызвало перенос, добавляем его к целой части

    /*отображаем целую часть*/
    OLED_ShowNum(X + FontSize, Y, IntNum, IntLength, FontSize);

    /*отображаем точку*/
    OLED_ShowChar(X + (IntLength + 1) * FontSize, Y, '.', FontSize);

    /*отображаем дробную часть*/
    OLED_ShowNum(X + (IntLength + 2) * FontSize, Y, FraNum, FraLength, FontSize);
}

/**
 * Функция: OLED отображение строки китайских иероглифов
 * Параметры: X — горизонтальная координата левого верхнего угла строки, диапазон: 0~127
 * Параметры: Y — вертикальная координата левого верхнего угла строки, диапазон: 0~63
 * Параметры: Chinese — строка китайских иероглифов, диапазон: должна содержать только иероглифы или полноширинные символы, не добавлять полуширинные символы
 *           Отображаемые иероглифы должны быть определены в массиве OLED_CF16x16 в файле OLED_Data.c
 *           Если иероглиф не найден, отображается символ по умолчанию (квадрат со знаком вопроса внутри)
 * Возвращаемое значение: нет
 * Примечание: после вызова этой функции для реального отображения на экране необходимо вызвать функцию обновления
 */
void OLED_ShowChinese(uint8_t X, uint8_t Y, char *Chinese)
{
    uint8_t pChinese = 0;
    uint8_t pIndex;
    uint8_t i;
    char SingleChinese[OLED_CHN_CHAR_WIDTH + 1] = {0}; // кодировка UTF-8 занимает 3 байта, +1 для завершающего символа \0

    for (i = 0; Chinese[i] != '\0'; i++) // перебираем строку иероглифов
    {
        SingleChinese[pChinese] = Chinese[i]; // копируем байт иероглифа в массив
        pChinese++;                           // увеличиваем счётчик

        /*когда счётчик достигает OLED_CHN_CHAR_WIDTH, значит, получен полный иероглиф*/
        if (pChinese >= OLED_CHN_CHAR_WIDTH) {
            SingleChinese[pChinese + 1] = '\0'; // добавляем завершающий ноль
            pChinese                    = 0;    // сбрасываем счётчик

            /*перебираем таблицу иероглифов, ищем совпадение*/
            /*если встретили последний элемент (пустую строку), значит, иероглиф не найден*/
            for (pIndex = 0; strcmp(OLED_CF16x16[pIndex].Index, "") != 0; pIndex++) {
                /*найден совпадающий иероглиф*/
                if (strcmp(OLED_CF16x16[pIndex].Index, SingleChinese) == 0) {
                    break; // выходим из цикла, pIndex содержит индекс иероглифа
                }
            }

            /*отображаем данные из OLED_CF16x16 в формате изображения 16×16*/
            OLED_ShowImage(X + ((i + 1) / OLED_CHN_CHAR_WIDTH - 1) * 16, Y, 16, 16, OLED_CF16x16[pIndex].Data);
        }
    }
}

/**
 * Функция: OLED отображение изображения
 * Параметры: X — горизонтальная координата левого верхнего угла изображения, диапазон: 0~127
 * Параметры: Y — вертикальная координата левого верхнего угла изображения, диапазон: 0~63
 * Параметры: Width — ширина изображения, диапазон: 0~128
 * Параметры: Height — высота изображения, диапазон: 0~64
 * Параметры: Image — указатель на массив данных изображения
 * Возвращаемое значение: нет
 * Примечание: после вызова этой функции для реального отображения на экране необходимо вызвать функцию обновления
 */
void OLED_ShowImage(uint8_t X, uint8_t Y, uint8_t Width, uint8_t Height, const uint8_t *Image)
{
    uint8_t i, j;

    /*проверка параметров, чтобы изображение не выходило за границы экрана*/
    if (X > 127) { return; }
    if (Y > 63) { return; }

    /*очищаем область, в которой будет размещено изображение*/
    OLED_ClearArea(X, Y, Width, Height);

    /*перебираем страницы, задействованные изображением*/
    /*(Height - 1) / 8 + 1 эквивалентно округлению вверх Height / 8*/
    for (j = 0; j < (Height - 1) / 8 + 1; j++) {
        /*перебираем столбцы изображения*/
        for (i = 0; i < Width; i++) {
            /*если выходим за границу, пропускаем отображение*/
            if (X + i > 127) { break; }
            if (Y / 8 + j > 7) { return; }

            /*отображаем часть изображения на текущей странице*/
            OLED_DisplayBuf[Y / 8 + j][X + i] |= Image[j * Width + i] << (Y % 8);

            /*если следующая страница выходит за границу, пропускаем*/
            /*continue позволяет продолжить отображение оставшихся столбцов на текущей странице*/
            if (Y / 8 + j + 1 > 7) { continue; }

            /*отображаем часть изображения на следующей странице*/
            OLED_DisplayBuf[Y / 8 + j + 1][X + i] |= Image[j * Width + i] >> (8 - Y % 8);
        }
    }
}/**
 * Функция: Печать форматированной строки на OLED с помощью printf
 * Параметры: X - горизонтальная координата левого верхнего угла форматированной строки, диапазон: 0~127
 * Параметры: Y - вертикальная координата левого верхнего угла форматированной строки, диапазон: 0~63
 * Параметры: FontSize - размер шрифта
 *           Диапазон: OLED_8X16     ширина 8 пикселей, высота 16 пикселей
 *                     OLED_6X8      ширина 6 пикселей, высота 8 пикселей
 * Параметры: format - форматированная строка для отображения, диапазон: строка из видимых символов ASCII
 * Параметры: ... - список параметров форматированной строки
 * Возвращаемое значение: нет
 * Описание: после вызова этой функции для отображения на экране необходимо вызвать функцию обновления
 */
void OLED_Printf(uint8_t X, uint8_t Y, uint8_t FontSize, char *format, ...)
{
    char String[30];                         // определение массива символов
    va_list arg;                             // определение переменной arg типа данных для списка переменных параметров
    va_start(arg, format);                   // начиная с format, принять список параметров в переменную arg
    vsprintf(String, format, arg);           // использование vsprintf для печати форматированной строки и списка параметров в массив символов
    va_end(arg);                             // завершение переменной arg
    OLED_ShowString(X, Y, String, FontSize); // отображение массива символов (строки) на OLED
}

/**
 * Функция: Рисование точки на OLED в указанной позиции
 * Параметры: X - горизонтальная координата точки, диапазон: 0~127
 * Параметры: Y - вертикальная координата точки, диапазон: 0~63
 * Возвращаемое значение: нет
 * Описание: после вызова этой функции для отображения на экране необходимо вызвать функцию обновления
 */
void OLED_DrawPoint(uint8_t X, uint8_t Y)
{
    /*проверка параметров, чтобы указанная позиция не выходила за пределы экрана*/
    if (X > 127) { return; }
    if (Y > 63) { return; }

    /*установка одного бита данных в массиве дисплея в указанной позиции в 1*/
    OLED_DisplayBuf[Y / 8][X] |= 0x01 << (Y % 8);
}

/**
 * Функция: Получение значения точки в указанной позиции на OLED
 * Параметры: X - горизонтальная координата точки, диапазон: 0~127
 * Параметры: Y - вертикальная координата точки, диапазон: 0~63
 * Возвращаемое значение: состояние точки в указанной позиции, 1: включена, 0: выключена
 */
uint8_t OLED_GetPoint(uint8_t X, uint8_t Y)
{
    /*проверка параметров, чтобы указанная позиция не выходила за пределы экрана*/
    if (X > 127) { return 0; }
    if (Y > 63) { return 0; }

    /*проверка данных в указанной позиции*/
    if (OLED_DisplayBuf[Y / 8][X] & 0x01 << (Y % 8)) {
        return 1; // если 1, возвращаем 1
    }

    return 0; // иначе возвращаем 0
}

/**
 * Функция: Рисование линии на OLED
 * Параметры: X0 - горизонтальная координата одного конца, диапазон: 0~127
 * Параметры: Y0 - вертикальная координата одного конца, диапазон: 0~63
 * Параметры: X1 - горизонтальная координата другого конца, диапазон: 0~127
 * Параметры: Y1 - вертикальная координата другого конца, диапазон: 0~63
 * Возвращаемое значение: нет
 * Описание: после вызова этой функции для отображения на экране необходимо вызвать функцию обновления
 */
void OLED_DrawLine(uint8_t X0, uint8_t Y0, uint8_t X1, uint8_t Y1)
{
    int16_t x, y, dx, dy, d, incrE, incrNE, temp;
    int16_t x0 = X0, y0 = Y0, x1 = X1, y1 = Y1;
    uint8_t yflag = 0, xyflag = 0;

    if (y0 == y1) // горизонтальная линия обрабатывается отдельно
    {
        /*если X координата точки 0 больше X координаты точки 1, меняем X координаты местами*/
        if (x0 > x1) {
            temp = x0;
            x0   = x1;
            x1   = temp;
        }

        /*обход X координаты*/
        for (x = x0; x <= x1; x++) {
            OLED_DrawPoint(x, y0); // последовательное рисование точек
        }
    } else if (x0 == x1) // вертикальная линия обрабатывается отдельно
    {
        /*если Y координата точки 0 больше Y координаты точки 1, меняем Y координаты местами*/
        if (y0 > y1) {
            temp = y0;
            y0   = y1;
            y1   = temp;
        }

        /*обход Y координаты*/
        for (i = y0; i <= y1; i++) {
            OLED_DrawPoint(x0, i); // последовательное рисование точек
        }
    } else // наклонная линия
    {
        /*использование алгоритма Брезенхема для рисования прямой линии, позволяет избежать затратных операций с плавающей точкой, более высокая эффективность*/
        /*справочный документ: https://www.cs.montana.edu/courses/spring2009/425/dslectures/Bresenham.pdf*/
        /*справочное руководство: https://www.bilibili.com/video/BV1364y1d7Lo*/

        if (x0 > x1) // X координата точки 0 больше X координаты точки 1
        {
            /*обмен координатами точек*/
            /*после обмена рисование линии не изменяется, но направление рисования изменяется с первой, второй, третьей, четвертой четвертей на первую и четвертую четверти*/
            temp = x0;
            x0   = x1;
            x1   = temp;
            temp = y0;
            y0   = y1;
            y1   = temp;
        }

        if (y0 > y1) // Y координата точки 0 больше Y координаты точки 1
        {
            /*инверсия Y координаты*/
            /*после инверсии влияет на рисование линии, но направление рисования изменяется с первой и четвертой четвертей на первую четверть*/
            y0 = -y0;
            y1 = -y1;

            /*установка флага yflag, чтобы запомнить текущее преобразование и вернуть координаты обратно при последующем рисовании*/
            yflag = 1;
        }

        if (y1 - y0 > x1 - x0) // наклон линии больше 1
        {
            /*обмен X и Y координатами*/
            /*после обмена влияет на рисование линии, но направление рисования изменяется с диапазона 0~90 градусов первой четверти на диапазон 0~45 градусов первой четверти*/
            temp = x0;
            x0   = y0;
            y0   = temp;
            temp = x1;
            x1   = y1;
            y1   = temp;

            /*установка флага xyflag, чтобы запомнить текущее преобразование и вернуть координаты обратно при последующем рисовании*/
            xyflag = 1;
        }

        /*ниже приведен алгоритм Брезенхема для рисования прямой линии*/
        /*алгоритм требует, чтобы направление рисования линии было в диапазоне 0~45 градусов первой четверти*/
        dx     = x1 - x0;
        dy     = y1 - y0;
        incrE  = 2 * dy;
        incrNE = 2 * (dy - dx);
        d      = 2 * dy - dx;
        x      = x0;
        y      = y0;

        /*рисование начальной точки, одновременно проверка флагов и возврат координат обратно*/
        if (yflag && xyflag) {
            OLED_DrawPoint(y, -x);
        } else if (yflag) {
            OLED_DrawPoint(x, -y);
        } else if (xyflag) {
            OLED_DrawPoint(y, x);
        } else {
            OLED_DrawPoint(x, y);
        }

        while (x < x1) // обход каждой точки по оси X
        {
            x++;
            if (d < 0) // следующая точка восточнее текущей
            {
                d += incrE;
            } else // следующая точка северо-восточнее текущей
            {
                y++;
                d += incrNE;
            }

            /*рисование каждой точки, одновременно проверка флагов и возврат координат обратно*/
            if (yflag && xyflag) {
                OLED_DrawPoint(y, -x);
            } else if (yflag) {
                OLED_DrawPoint(x, -y);
            } else if (xyflag) {
                OLED_DrawPoint(y, x);
            } else {
                OLED_DrawPoint(x, y);
            }
        }
    }
}

/**
 * Функция: OLED прямоугольник
 * Параметры: X - горизонтальная координата левого верхнего угла прямоугольника, диапазон: 0~127
 * Параметры: Y - вертикальная координата левого верхнего угла прямоугольника, диапазон: 0~63
 * Параметры: Width - ширина прямоугольника, диапазон: 0~128
 * Параметры: Height - высота прямоугольника, диапазон: 0~64
 * Параметры: IsFilled - заливка прямоугольника
 *           Диапазон: OLED_UNFILLED     не заполнен
 *                     OLED_FILLED       заполнен
 * Возвращаемое значение: нет
 * Описание: после вызова этой функции для отображения на экране необходимо вызвать функцию обновления
 */
void OLED_DrawRectangle(uint8_t X, uint8_t Y, uint8_t Width, uint8_t Height, uint8_t IsFilled)
{
    uint8_t i, j;
    if (!IsFilled) // прямоугольник не заполнен
    {
        /*обход X координат сверху и снизу, рисование верхней и нижней линий прямоугольника*/
        for (i = X; i < X + Width; i++) {
            OLED_DrawPoint(i, Y);
            OLED_DrawPoint(i, Y + Height - 1);
        }
        /*обход Y координат слева и справа, рисование левой и правой линий прямоугольника*/
        for (i = Y; i < Y + Height; i++) {
            OLED_DrawPoint(X, i);
            OLED_DrawPoint(X + Width - 1, i);
        }
    } else // прямоугольник заполнен
    {
        /*обход X координаты*/
        for (i = X; i < X + Width; i++) {
            /*обход Y координаты*/
            for (j = Y; j < Y + Height; j++) {
                /*рисование точки в указанной области, заполнение прямоугольника*/
                OLED_DrawPoint(i, j);
            }
        }
    }
}

/**
 * Функция: OLED треугольник
 * Параметры: X0 - горизонтальная координата первой вершины, диапазон: 0~127
 * Параметры: Y0 - вертикальная координата первой вершины, диапазон: 0~63
 * Параметры: X1 - горизонтальная координата второй вершины, диапазон: 0~127
 * Параметры: Y1 - вертикальная координата второй вершины, диапазон: 0~63
 * Параметры: X2 - горизонтальная координата третьей вершины, диапазон: 0~127
 * Параметры: Y2 - вертикальная координата третьей вершины, диапазон: 0~63
 * Параметры: IsFilled - заливка треугольника
 *           Диапазон: OLED_UNFILLED     не заполнен
 *                     OLED_FILLED       заполнен
 * Возвращаемое значение: нет
 * Описание: после вызова этой функции для отображения на экране необходимо вызвать функцию обновления
 */
void OLED_DrawTriangle(uint8_t X0, uint8_t Y0, uint8_t X1, uint8_t Y1, uint8_t X2, uint8_t Y2, uint8_t IsFilled)
{
    uint8_t minx = X0, miny = Y0, maxx = X0, maxy = Y0;
    uint8_t i, j;
    int16_t vx[] = {X0, X1, X2};
    int16_t vy[] = {Y0, Y1, Y2};

    if (!IsFilled) // треугольник не заполнен
    {
        /*вызов функции рисования линии, соединение трех точек прямыми линиями*/
        OLED_DrawLine(X0, Y0, X1, Y1);
        OLED_DrawLine(X0, Y0, X2, Y2);
        OLED_DrawLine(X1, Y1, X2, Y2);
    } else // треугольник заполнен
    {
        /*поиск минимальных X и Y координат среди трех точек*/
        if (X1 < minx) { minx = X1; }
        if (X2 < minx) { minx = X2; }
        if (Y1 < miny) { miny = Y1; }
        if (Y2 < miny) { miny = Y2; }

        /*поиск максимальных X и Y координат среди трех точек*/
        if (X1 > maxx) { maxx = X1; }
        if (X2 > maxx) { maxx = X2; }
        if (Y1 > maxy) { maxy = Y1; }
        if (Y2 > maxy) { maxy = Y2; }

        /*прямоугольник между минимальными и максимальными координатами является возможной областью для заливки*/
        /*обход всех точек в этой области*/
        /*обход X координаты*/
        for (i = minx; i <= maxx; i++) {
            /*обход Y координаты*/
            for (j = miny; j <= maxy; j++) {
                /*вызов OLED_pnpoly для определения, находится ли указанная точка внутри треугольника*/
                /*если да, рисуем точку, если нет, ничего не делаем*/
                if (OLED_pnpoly(3, vx, vy, i, j)) { OLED_DrawPoint(i, j); }
            }
        }
    }
}

/**
 * Функция: OLED рисование круга
 * Параметры: X - горизонтальная координата центра круга, диапазон: 0~127
 * Параметры: Y - вертикальная координата центра круга, диапазон: 0~63
 * Параметры: Radius - радиус круга, диапазон: 0~255
 * Параметры: IsFilled - заливка круга
 *           Диапазон: OLED_UNFILLED     не заполнен
 *                     OLED_FILLED       заполнен
 * Возвращаемое значение: нет
 * Описание: после вызова этой функции для отображения на экране необходимо вызвать функцию обновления
 */
void OLED_DrawCircle(uint8_t X, uint8_t Y, uint8_t Radius, uint8_t IsFilled)
{
    int16_t x, y, d, j;

    /*использование алгоритма Брезенхема для рисования круга, позволяет избежать затратных операций с плавающей точкой, более высокая эффективность*/
    /*справочный документ: https://www.cs.montana.edu/courses/spring2009/425/dslectures/Bresenham.pdf*/
    /*справочное руководство: https://www.bilibili.com/video/BV1VM4y1u7wJ*/

    d = 1 - Radius;
    x = 0;
    y = Radius;

    /*рисование начальных точек каждой восьмой части окружности*/
    OLED_DrawPoint(X + x, Y + y);
    OLED_DrawPoint(X - x, Y - y);
    OLED_DrawPoint(X + y, Y + x);
    OLED_DrawPoint(X - y, Y - x);```c
if (IsFilled) // заданная заливка круга
    {
        /*обход начальной координаты Y*/
        for (j = -y; j < y; j++) {
            /*рисуем точки в заданной области, заполняя часть круга*/
            OLED_DrawPoint(X, Y + j);
        }
    }

    while (x < y) // обход каждой точки по оси X
    {
        x++;
        if (d < 0) // следующая точка восточнее текущей
        {
            d += 2 * x + 1;
        } else // следующая точка юго-восточнее текущей
        {
            y--;
            d += 2 * (x - y) + 1;
        }

        /*рисуем точки каждой восьмой дуги окружности*/
        OLED_DrawPoint(X + x, Y + y);
        OLED_DrawPoint(X + y, Y + x);
        OLED_DrawPoint(X - x, Y - y);
        OLED_DrawPoint(X - y, Y - x);
        OLED_DrawPoint(X + x, Y - y);
        OLED_DrawPoint(X + y, Y - x);
        OLED_DrawPoint(X - x, Y + y);
        OLED_DrawPoint(X - y, Y + x);

        if (IsFilled) // заданная заливка круга
        {
            /*обход средней части*/
            for (j = -y; j < y; j++) {
                /*рисуем точки в заданной области, заполняя часть круга*/
                OLED_DrawPoint(X + x, Y + j);
                OLED_DrawPoint(X - x, Y + j);
            }

            /*обход боковых частей*/
            for (j = -x; j < x; j++) {
                /*рисуем точки в заданной области, заполняя часть круга*/
                OLED_DrawPoint(X - y, Y + j);
                OLED_DrawPoint(X + y, Y + j);
            }
        }
    }
}

/**
 *  Функция: рисование эллипса на OLED
 *  Параметры: X — горизонтальная координата центра эллипса, диапазон: 0~127
 *  Параметры: Y — вертикальная координата центра эллипса, диапазон: 0~63
 *  Параметры: A — длина горизонтальной полуоси эллипса, диапазон: 0~255
 *  Параметры: B — длина вертикальной полуоси эллипса, диапазон: 0~255
 *  Параметры: IsFilled — заливка эллипса
 *           диапазон: OLED_UNFILLED   не заполнен
 *                    OLED_FILLED      заполнен
 *  Возвращаемое значение: нет
 *  Примечание: после вызова функции для отображения на экране необходимо вызвать функцию обновления
 */
void OLED_DrawEllipse(uint8_t X, uint8_t Y, uint8_t A, uint8_t B, uint8_t IsFilled)
{
    int16_t x, y, j;
    int16_t a = A, b = B;
    float d1, d2;

    /*используем алгоритм Брезенхема для эллипса, избегая части затратных операций с плавающей точкой, более высокая эффективность*/
    /*ссылка для справки: https://blog.csdn.net/myf_666/article/details/128167392*/

    x  = 0;
    y  = b;
    d1 = b * b + a * a * (-b + 0.5);

    if (IsFilled) // заданная заливка эллипса
    {
        /*обход начальной координаты Y*/
        for (j = -y; j < y; j++) {
            /*рисуем точки в заданной области, заполняя часть эллипса*/
            OLED_DrawPoint(X, Y + j);
            OLED_DrawPoint(X, Y + j);
        }
    }

    /*рисуем начальные точки эллипса*/
    OLED_DrawPoint(X + x, Y + y);
    OLED_DrawPoint(X - x, Y - y);
    OLED_DrawPoint(X - x, Y + y);
    OLED_DrawPoint(X + x, Y - y);

    /*рисуем среднюю часть эллипса*/
    while (b * b * (x + 1) < a * a * (y - 0.5)) {
        if (d1 <= 0) // следующая точка восточнее текущей
        {
            d1 += b * b * (2 * x + 3);
        } else // следующая точка юго-восточнее текущей
        {
            d1 += b * b * (2 * x + 3) + a * a * (-2 * y + 2);
            y--;
        }
        x++;

        if (IsFilled) // заданная заливка эллипса
        {
            /*обход средней части*/
            for (j = -y; j < y; j++) {
                /*рисуем точки в заданной области, заполняя часть эллипса*/
                OLED_DrawPoint(X + x, Y + j);
                OLED_DrawPoint(X - x, Y + j);
            }
        }

        /*рисуем дуги средней части эллипса*/
        OLED_DrawPoint(X + x, Y + y);
        OLED_DrawPoint(X - x, Y - y);
        OLED_DrawPoint(X - x, Y + y);
        OLED_DrawPoint(X + x, Y - y);
    }

    /*рисуем боковые части эллипса*/
    d2 = b * b * (x + 0.5) * (x + 0.5) + a * a * (y - 1) * (y - 1) - a * a * b * b;

    while (y > 0) {
        if (d2 <= 0) // следующая точка восточнее текущей
        {
            d2 += b * b * (2 * x + 2) + a * a * (-2 * y + 3);
            x++;

        } else // следующая точка юго-восточнее текущей
        {
            d2 += a * a * (-2 * y + 3);
        }
        y--;

        if (IsFilled) // заданная заливка эллипса
        {
            /*обход боковых частей*/
            for (j = -y; j < y; j++) {
                /*рисуем точки в заданной области, заполняя часть эллипса*/
                OLED_DrawPoint(X + x, Y + j);
                OLED_DrawPoint(X - x, Y + j);
            }
        }

        /*рисуем дуги боковых частей эллипса*/
        OLED_DrawPoint(X + x, Y + y);
        OLED_DrawPoint(X - x, Y - y);
        OLED_DrawPoint(X - x, Y + y);
        OLED_DrawPoint(X + x, Y - y);
    }
}

/**
 *  Функция: рисование дуги на OLED
 *  Параметры: X — горизонтальная координата центра дуги, диапазон: 0~127
 *  Параметры: Y — вертикальная координата центра дуги, диапазон: 0~63
 *  Параметры: Radius — радиус дуги, диапазон: 0~255
 *  Параметры: StartAngle — начальный угол дуги, диапазон: -180~180
 *           горизонтально вправо — 0°, горизонтально влево — 180° или -180°, вниз — положительные, вверх — отрицательные, по часовой стрелке
 *  Параметры: EndAngle — конечный угол дуги, диапазон: -180~180
 *           горизонтально вправо — 0°, горизонтально влево — 180° или -180°, вниз — положительные, вверх — отрицательные, по часовой стрелке
 *  Параметры: IsFilled — заливка дуги, при заливке получается сектор
 *           диапазон: OLED_UNFILLED   не заполнен
 *                    OLED_FILLED      заполнен
 *  Возвращаемое значение: нет
 *  Примечание: после вызова функции для отображения на экране необходимо вызвать функцию обновления
 */
void OLED_DrawArc(uint8_t X, uint8_t Y, uint8_t Radius, int16_t StartAngle, int16_t EndAngle, uint8_t IsFilled)
{
    int16_t x, y, d, j;

    /*в этой функции используется метод алгоритма Брезенхема для окружности*/

    d = 1 - Radius;
    x = 0;
    y = Radius;

    /*при рисовании каждой точки окружности проверяем, попадает ли она в заданный угол; если да — рисуем, если нет — пропускаем*/
    if (OLED_IsInAngle(x, y, StartAngle, EndAngle)) { OLED_DrawPoint(X + x, Y + y); }
    if (OLED_IsInAngle(-x, -y, StartAngle, EndAngle)) { OLED_DrawPoint(X - x, Y - y); }
    if (OLED_IsInAngle(y, x, StartAngle, EndAngle)) { OLED_DrawPoint(X + y, Y + x); }
    if (OLED_IsInAngle(-y, -x, StartAngle, EndAngle)) { OLED_DrawPoint(X - y, Y - x); }

    if (IsFilled) // заданная заливка дуги
    {
        /*обход начальной координаты Y*/
        for (j = -y; j < y; j++) {
            /*при заливке каждой точки окружности проверяем, попадает ли она в заданный угол; если да — рисуем, если нет — пропускаем*/
            if (OLED_IsInAngle(0, j, StartAngle, EndAngle)) { OLED_DrawPoint(X, Y + j); }
        }
    }

    while (x < y) // обход каждой точки по оси X
    {
        x++;
        if (d < 0) // следующая точка восточнее текущей
        {
            d += 2 * x + 1;
        } else // следующая точка юго-восточнее текущей
        {
            y--;
            d += 2 * (x - y) + 1;
        }

        /*при рисовании каждой точки окружности проверяем, попадает ли она в заданный угол; если да — рисуем, если нет — пропускаем*/
        if (OLED_IsInAngle(x, y, StartAngle, EndAngle)) { OLED_DrawPoint(X + x, Y + y); }
        if (OLED_IsInAngle(y, x, StartAngle, EndAngle)) { OLED_DrawPoint(X + y, Y + x); }
        if (OLED_IsInAngle(-x, -y, StartAngle, EndAngle)) { OLED_DrawPoint(X - x, Y - y); }
        if (OLED_IsInAngle(-y, -x, StartAngle, EndAngle)) { OLED_DrawPoint(X - y, Y - x); }
        if (OLED_IsInAngle(x, -y, StartAngle, EndAngle)) { OLED_DrawPoint(X + x, Y - y); }
        if (OLED_IsInAngle(y, -x, StartAngle, EndAngle)) { OLED_DrawPoint(X + y, Y - x); }
        if (OLED_IsInAngle(-x, y, StartAngle, EndAngle)) { OLED_DrawPoint(X - x, Y + y); }
        if (OLED_IsInAngle(-y, x, StartAngle, EndAngle)) { OLED_DrawPoint(X - y, Y + x); }

        if (IsFilled) // заданная заливка дуги
        {
            /*обход средней части*/
            for (j = -y; j < y; j++) {
                /*при заливке каждой точки окружности проверяем, попадает ли она в заданный угол; если да — рисуем, если нет — пропускаем*/
                if (OLED_IsInAngle(x, j, StartAngle, EndAngle)) { OLED_DrawPoint(X + x, Y + j); }
                if (OLED_IsInAngle(-x, j, StartAngle, EndAngle)) { OLED_DrawPoint(X - x, Y + j); }
            }

            /*обход боковых частей*/
            for (j = -x; j < x; j++) {
                /*при заливке каждой точки окружности проверяем, попадает ли она в заданный угол; если да — рисуем, если нет — пропускаем*/
                if (OLED_IsInAngle(-y, j, StartAngle, EndAngle)) { OLED_DrawPoint(X - y, Y + j); }
                if (OLED_IsInAngle(y, j, StartAngle, EndAngle)) { OLED_DrawPoint(X + y, Y + j); }
            }
        }
    }
}

/*********************Служебные функции*/

/*****************Jiangxiekeji, все права защищены****************/
/*****************jiangxiekeji.com*****************/

Файл OLED.h:

#ifndef __OLED_H
#define __OLED_H

#include <stdint.h>
#include "OLED_Data.h"

/*Макроопределения параметров*********/************/

/*Параметры размера шрифта*/
/*Это значение используется не только для проверки, но и для расчёта горизонтального смещения символов. По умолчанию — ширина шрифта в пикселях*/
#define OLED_8X16				8
#define OLED_6X8				6

/*Значения параметра IsFilled*/
#define OLED_UNFILLED			0
#define OLED_FILLED				1

/*********************Макроопределения параметров*/


/*Объявления функций*********************/

/*Функции инициализации*/
void OLED_Init(void);

/*Функции обновления*/
void OLED_Update(void);
void OLED_UpdateArea(uint8_t X, uint8_t Y, uint8_t Width, uint8_t Height);

/*Функции управления видеопамятью*/
void OLED_Clear(void);
void OLED_ClearArea(uint8_t X, uint8_t Y, uint8_t Width, uint8_t Height);
void OLED_Reverse(void);
void OLED_ReverseArea(uint8_t X, uint8_t Y, uint8_t Width, uint8_t Height);

/*Функции отображения*/
void OLED_ShowChar(uint8_t X, uint8_t Y, char Char, uint8_t FontSize);
void OLED_ShowString(uint8_t X, uint8_t Y, char *String, uint8_t FontSize);
void OLED_ShowNum(uint8_t X, uint8_t Y, uint32_t Number, uint8_t Length, uint8_t FontSize);
void OLED_ShowSignedNum(uint8_t X, uint8_t Y, int32_t Number, uint8_t Length, uint8_t FontSize);
void OLED_ShowHexNum(uint8_t X, uint8_t Y, uint32_t Number, uint8_t Length, uint8_t FontSize);
void OLED_ShowBinNum(uint8_t X, uint8_t Y, uint32_t Number, uint8_t Length, uint8_t FontSize);
void OLED_ShowFloatNum(uint8_t X, uint8_t Y, double Number, uint8_t IntLength, uint8_t FraLength, uint8_t FontSize);
void OLED_ShowChinese(uint8_t X, uint8_t Y, char *Chinese);
void OLED_ShowImage(uint8_t X, uint8_t Y, uint8_t Width, uint8_t Height, const uint8_t *Image);
void OLED_Printf(uint8_t X, uint8_t Y, uint8_t FontSize, char *format, ...);

/*Функции рисования*/
void OLED_DrawPoint(uint8_t X, uint8_t Y);
uint8_t OLED_GetPoint(uint8_t X, uint8_t Y);
void OLED_DrawLine(uint8_t X0, uint8_t Y0, uint8_t X1, uint8_t Y1);
void OLED_DrawRectangle(uint8_t X, uint8_t Y, uint8_t Width, uint8_t Height, uint8_t IsFilled);
void OLED_DrawTriangle(uint8_t X0, uint8_t Y0, uint8_t X1, uint8_t Y1, uint8_t X2, uint8_t Y2, uint8_t IsFilled);
void OLED_DrawCircle(uint8_t X, uint8_t Y, uint8_t Radius, uint8_t IsFilled);
void OLED_DrawEllipse(uint8_t X, uint8_t Y, uint8_t A, uint8_t B, uint8_t IsFilled);
void OLED_DrawArc(uint8_t X, uint8_t Y, uint8_t Radius, int16_t StartAngle, int16_t EndAngle, uint8_t IsFilled);

/*********************Объявления функций*/

#endif

/*****************Jiangxie Technology | Все права защищены****************/
/*****************jiangxiekeji.com*****************/

Файл OLED_Data.c:

#include "OLED_Data.h"

/**
  * Формат хранения данных:
  * Вертикально 8 точек, старший бит внизу, сначала слева направо, затем сверху вниз
  * Каждый бит соответствует одному пикселю
  * 
  *      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
  * 
  */

/*Данные шаблона символов ASCII*********************//*ширина 8 пикселей, высота 16 пикселей*/
const uint8_t OLED_F8x16[][16] =
{
	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//   0
	0x00,0x00,0x00,0xF8,0x00,0x00,0x00,0x00,
	0x00,0x00,0x00,0x33,0x30,0x00,0x00,0x00,// ! 1
	0x00,0x16,0x0E,0x00,0x16,0x0E,0x00,0x00,
	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,// " 2
	0x40,0xC0,0x78,0x40,0xC0,0x78,0x40,0x00,
	0x04,0x3F,0x04,0x04,0x3F,0x04,0x04,0x00,// # 3
	0x00,0x70,0x88,0xFC,0x08,0x30,0x00,0x00,
	0x00,0x18,0x20,0xFF,0x21,0x1E,0x00,0x00,// $ 4
	0xF0,0x08,0xF0,0x00,0xE0,0x18,0x00,0x00,
	0x00,0x21,0x1C,0x03,0x1E,0x21,0x1E,0x00,// % 5
	0x00,0xF0,0x08,0x88,0x70,0x00,0x00,0x00,
	0x1E,0x21,0x23,0x24,0x19,0x27,0x21,0x10,// & 6
	0x00,0x00,0x00,0x16,0x0E,0x00,0x00,0x00,
	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,// ' 7
	0x00,0x00,0x00,0xE0,0x18,0x04,0x02,0x00,
	0x00,0x00,0x00,0x07,0x18,0x20,0x40,0x00,// ( 8
	0x00,0x02,0x04,0x18,0xE0,0x00,0x00,0x00,
	0x00,0x40,0x20,0x18,0x07,0x00,0x00,0x00,// ) 9
	0x40,0x40,0x80,0xF0,0x80,0x40,0x40,0x00,
	0x02,0x02,0x01,0x0F,0x01,0x02,0x02,0x00,// * 10
	0x00,0x00,0x00,0xF0,0x00,0x00,0x00,0x00,
	0x01,0x01,0x01,0x1F,0x01,0x01,0x01,0x00,// + 11
	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	0x00,0xB0,0x70,0x00,0x00,0x00,0x00,0x00,// , 12
	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	0x00,0x01,0x01,0x01,0x01,0x01,0x01,0x01,// - 13
	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	0x00,0x30,0x30,0x00,0x00,0x00,0x00,0x00,// . 14
	0x00,0x00,0x00,0x00,0x80,0x60,0x18,0x04,
	0x00,0x60,0x18,0x06,0x01,0x00,0x00,0x00,// / 15
	0x00,0xE0,0x10,0x08,0x08,0x10,0xE0,0x00,
	0x00,0x0F,0x10,0x20,0x20,0x10,0x0F,0x00,// 0 16
	0x00,0x10,0x10,0xF8,0x00,0x00,0x00,0x00,
	0x00,0x20,0x20,0x3F,0x20,0x20,0x00,0x00,// 1 17
	0x00,0x70,0x08,0x08,0x08,0x88,0x70,0x00,
	0x00,0x30,0x28,0x24,0x22,0x21,0x30,0x00,// 2 18
	0x00,0x30,0x08,0x88,0x88,0x48,0x30,0x00,
	0x00,0x18,0x20,0x20,0x20,0x11,0x0E,0x00,// 3 19
	0x00,0x00,0xC0,0x20,0x10,0xF8,0x00,0x00,
	0x00,0x07,0x04,0x24,0x24,0x3F,0x24,0x00,// 4 20
	0x00,0xF8,0x08,0x88,0x88,0x08,0x08,0x00,
	0x00,0x19,0x21,0x20,0x20,0x11,0x0E,0x00,// 5 21
	0x00,0xE0,0x10,0x88,0x88,0x18,0x00,0x00,
	0x00,0x0F,0x11,0x20,0x20,0x11,0x0E,0x00,// 6 22
	0x00,0x38,0x08,0x08,0xC8,0x38,0x08,0x00,
	0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x00,// 7 23
	0x00,0x70,0x88,0x08,0x08,0x88,0x70,0x00,
	0x00,0x1C,0x22,0x21,0x21,0x22,0x1C,0x00,// 8 24
	0x00,0xE0,0x10,0x08,0x08,0x10,0xE0,0x00,
	0x00,0x00,0x31,0x22,0x22,0x11,0x0F,0x00,// 9 25
	0x00,0x00,0x00,0xC0,0xC0,0x00,0x00,0x00,
	0x00,0x00,0x00,0x30,0x30,0x00,0x00,0x00,// : 26
	0x00,0x00,0x00,0xC0,0xC0,0x00,0x00,0x00,
	0x00,0x00,0x80,0xB0,0x70,0x00,0x00,0x00,// ; 27
	0x00,0x00,0x80,0x40,0x20,0x10,0x08,0x00,
	0x00,0x01,0x02,0x04,0x08,0x10,0x20,0x00,// < 28
	0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x00,
	0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x00,// = 29
	0x00,0x08,0x10,0x20,0x40,0x80,0x00,0x00,
	0x00,0x20,0x10,0x08,0x04,0x02,0x01,0x00,// > 30
	0x00,0x70,0x48,0x08,0x08,0x08,0xF0,0x00,
	0x00,0x00,0x00,0x30,0x36,0x01,0x00,0x00,// ? 31? 31
	0xC0,0x30,0xC8,0x28,0xE8,0x10,0xE0,0x00,
	0x07,0x18,0x27,0x24,0x23,0x14,0x0B,0x00,// @ 32
	0x00,0x00,0xC0,0x38,0xE0,0x00,0x00,0x00,
	0x20,0x3C,0x23,0x02,0x02,0x27,0x38,0x20,// A 33
	0x08,0xF8,0x88,0x88,0x88,0x70,0x00,0x00,
	0x20,0x3F,0x20,0x20,0x20,0x11,0x0E,0x00,// B 34
	0xC0,0x30,0x08,0x08,0x08,0x08,0x38,0x00,
	0x07,0x18,0x20,0x20,0x20,0x10,0x08,0x00,// C 35
	0x08,0xF8,0x08,0x08,0x08,0x10,0xE0,0x00,
	0x20,0x3F,0x20,0x20,0x20,0x10,0x0F,0x00,// D 36
	0x08,0xF8,0x88,0x88,0xE8,0x08,0x10,0x00,
	0x20,0x3F,0x20,0x20,0x23,0x20,0x18,0x00,// E 37
	0x08,0xF8,0x88,0x88,0xE8,0x08,0x10,0x00,
	0x20,0x3F,0x20,0x00,0x03,0x00,0x00,0x00,// F 38
	0xC0,0x30,0x08,0x08,0x08,0x38,0x00,0x00,
	0x07,0x18,0x20,0x20,0x22,0x1E,0x02,0x00,// G 39
	0x08,0xF8,0x08,0x00,0x00,0x08,0xF8,0x08,
	0x20,0x3F,0x21,0x01,0x01,0x21,0x3F,0x20,// H 40
	0x00,0x08,0x08,0xF8,0x08,0x08,0x00,0x00,
	0x00,0x20,0x20,0x3F,0x20,0x20,0x00,0x00,// I 41
	0x00,0x00,0x08,0x08,0xF8,0x08,0x08,0x00,
	0xC0,0x80,0x80,0x80,0x7F,0x00,0x00,0x00,// J 42
	0x08,0xF8,0x88,0xC0,0x28,0x18,0x08,0x00,
	0x20,0x3F,0x20,0x01,0x26,0x38,0x20,0x00,// K 43
	0x08,0xF8,0x08,0x00,0x00,0x00,0x00,0x00,
	0x20,0x3F,0x20,0x20,0x20,0x20,0x30,0x00,// L 44
	0x08,0xF8,0xF8,0x00,0xF8,0xF8,0x08,0x00,
	0x20,0x3F,0x00,0x3F,0x00,0x3F,0x20,0x00,// M 45
	0x08,0xF8,0x30,0xC0,0x00,0x08,0xF8,0x08,
	0x20,0x3F,0x20,0x00,0x07,0x18,0x3F,0x00,// N 46
	0xE0,0x10,0x08,0x08,0x08,0x10,0xE0,0x00,
	0x0F,0x10,0x20,0x20,0x20,0x10,0x0F,0x00,// O 47
	0x08,0xF8,0x08,0x08,0x08,0x08,0xF0,0x00,
	0x20,0x3F,0x21,0x01,0x01,0x01,0x00,0x00,// P 48
	0xE0,0x10,0x08,0x08,0x08,0x10,0xE0,0x00,
	0x0F,0x18,0x24,0x24,0x38,0x50,0x4F,0x00,// Q 49
	0x08,0xF8,0x88,0x88,0x88,0x88,0x70,0x00,
	0x20,0x3F,0x20,0x00,0x03,0x0C,0x30,0x20,// R 50
	0x00,0x70,0x88,0x08,0x08,0x08,0x38,0x00,
	0x00,0x38,0x20,0x21,0x21,0x22,0x1C,0x00,// S 51
	0x18,0x08,0x08,0xF8,0x08,0x08,0x18,0x00,
	0x00,0x00,0x20,0x3F,0x20,0x00,0x00,0x00,// T 52
	0x08,0xF8,0x08,0x00,0x00,0x08,0xF8,0x08,
	0x00,0x1F,0x20,0x20,0x20,0x20,0x1F,0x00,// U 53
	0x08,0x78,0x88,0x00,0x00,0xC8,0x38,0x08,
	0x00,0x00,0x07,0x38,0x0E,0x01,0x00,0x00,// V 54
	0xF8,0x08,0x00,0xF8,0x00,0x08,0xF8,0x00,
	0x03,0x3C,0x07,0x00,0x07,0x3C,0x03,0x00,// W 55
	0x08,0x18,0x68,0x80,0x80,0x68,0x18,0x08,
	0x20,0x30,0x2C,0x03,0x03,0x2C,0x30,0x20,// X 56
	0x08,0x38,0xC8,0x00,0xC8,0x38,0x08,0x00,
	0x00,0x00,0x20,0x3F,0x20,0x00,0x00,0x00,// Y 57
	0x10,0x08,0x08,0x08,0xC8,0x38,0x08,0x00,
	0x20,0x38,0x26,0x21,0x20,0x20,0x18,0x00,// Z 58
	0x00,0x00,0x00,0xFE,0x02,0x02,0x02,0x00,
	0x00,0x00,0x00,0x7F,0x40,0x40,0x40,0x00,// [ 59
	0x00,0x0C,0x30,0xC0,0x00,0x00,0x00,0x00,
	0x00,0x00,0x00,0x01,0x06,0x38,0xC0,0x00,// \ 60
	0x00,0x02,0x02,0x02,0xFE,0x00,0x00,0x00,
	0x00,0x40,0x40,0x40,0x7F,0x00,0x00,0x00,// ] 61
	0x00,0x20,0x10,0x08,0x04,0x08,0x10,0x20,
	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,// ^ 62
	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,// _ 63
	0x00,0x02,0x04,0x08,0x00,0x00,0x00,0x00,
	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,// ` 64
	0x00,0x00,0x80,0x80,0x80,0x80,0x00,0x00,
	0x00,0x19,0x24,0x22,0x22,0x22,0x3F,0x20,// a 65
	0x08,0xF8,0x00,0x80,0x80,0x00,0x00,0x00,
	0x00,0x3F,0x11,0x20,0x20,0x11,0x0E,0x00,// b 66
	0x00,0x00,0x00,0x80,0x80,0x80,0x00,0x00,
	0x00,0x0E,0x11,0x20,0x20,0x20,0x11,0x00,// c 67
	0x00,0x00,0x00,0x80,0x80,0x88,0xF8,0x00,
	0x00,0x0E,0x11,0x20,0x20,0x10,0x3F,0x20,// d 68
	0x00,0x00,0x80,0x80,0x80,0x80,0x00,0x00,
	0x00,0x1F,0x22,0x22,0x22,0x22,0x13,0x00,// e 69
	0x00,0x80,0x80,0xF0,0x88,0x88,0x88,0x18,
	0x00,0x20,0x20,0x3F,0x20,0x20,0x00,0x00,// f 70
	0x00,0x00,0x80,0x80,0x80,0x80,0x80,0x00,
	0x00,0x6B,0x94,0x94,0x94,0x93,0x60,0x00,// g 71
	0x08,0xF8,0x00,0x80,0x80,0x80,0x00,0x00,
	0x20,0x3F,0x21,0x00,0x00,0x20,0x3F,0x20,// h 72
	0x00,0x80,0x98,0x98,0x00,0x00,0x00,0x00,
	0x00,0x20,0x20,0x3F,0x20,0x20,0x00,0x00,// i 73
	0x00,0x00,0x00,0x80,0x98,0x98,0x00,0x00,
	0x00,0xC0,0x80,0x80,0x80,0x7F,0x00,0x00,// j 74
	0x08,0xF8,0x00,0x00,0x80,0x80,0x80,0x00,
	0x20,0x3F,0x24,0x02,0x2D,0x30,0x20,0x00,// k 75
	0x00,0x08,0x08,0xF8,0x00,0x00,0x00,0x00,
	0x00,0x20,0x20,0x3F,0x20,0x20,0x00,0x00,// l 76
	0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x00,
	0x20,0x3F,0x20,0x00,0x3F,0x20,0x00,0x3F,// m 77
	0x00,0x80,0x80,0x00,0x80,0x80,0x00,0x00,
	0x00,0x20,0x3F,0x21,0x00,0x20,0x3F,0x20,// n 78
	0x00,0x00,0x80,0x80,0x80,0x80,0x00,0x00,
	0x00,0x1F,0x20,0x20,0x20,0x20,0x1F,0x00,// o 79
	0x80,0x80,0x00,0x80,0x80,0x00,0x00,0x00,
	0x80,0xFF,0xA1,0x20,0x20,0x11,0x0E,0x00,// p 80
	0x00,0x00,0x00,0x80,0x80,0x80,0x80,0x00,
	0x00,0x0E,0x11,0x20,0x20,0xA0,0xFF,0x80,// q 81
	0x80,0x80,0x80,0x00,0x80,0x80,0x80,0x00,
	0x20,0x20,0x3F,0x21,0x20,0x00,0x01,0x00,// r 82
	0x00,0x00,0x80,0x80,0x80,0x80,0x80,0x00,
	0x00,0x33,0x24,0x24,0x24,0x24,0x19,0x00,// s 83
	0x00,0x80,0x80,0xE0,0x80,0x80,0x00,0x00,
	0x00,0x00,0x00,0x1F,0x20,0x20,0x00,0x00,// t 84
	0x80,0x80,0x00,0x00,0x00,0x80,0x80,0x00,
	0x00,0x1F,0x20,0x20,0x20,0x10,0x3F,0x20,// u 85
	0x80,0x80,0x80,0x00,0x00,0x80,0x80,0x80,
	0x00,0x01,0x0E,0x30,0x08,0x06,0x01,0x00,// v 86
	0x80,0x80,0x00,0x80,0x00,0x80,0x80,0x80,
	0x0F,0x30,0x0C,0x03,0x0C,0x30,0x0F,0x00,// w 87
	0x00,0x80,0x80,0x00,0x80,0x80,0x80,0x00,
	0x00,0x20,0x31,0x2E,0x0E,0x31,0x20,0x00,// x 88
	0x80,0x80,0x80,0x00,0x00,0x80,0x80,0x80,
	0x80,0x81,0x8E,0x70,0x18,0x06,0x01,0x00,// y 89
	0x00,0x80,0x80,0x80,0x80,0x80,0x80,0x00,
	0x00,0x21,0x30,0x2C,0x22,0x21,0x30,0x00,// z 90
	0x00,0x00,0x00,0x00,0x80,0x7C,0x02,0x02,
	0x00,0x00,0x00,0x00,0x00,0x3F,0x40,0x40,// { 91
	0x00,0x00,0x00,0x00,0xFF,0x00,0x00,0x00,
	0x00,0x00,0x00,0x00,0xFF,0x00,0x00,0x00,// | 92
	0x00,0x02,0x02,0x7C,0x80,0x00,0x00,0x00,
	0x00,0x40,0x40,0x3F,0x00,0x00,0x00,0x00,// } 93
	0x00,0x80,0x40,0x40,0x80,0x00,0x00,0x80,
	0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x00,// ~ 94
};/*Ширина 6 пикселей, высота 8 пикселей*/
const uint8_t OLED_F6x8[][6] = 
{
	0x00,0x00,0x00,0x00,0x00,0x00,//   0
	0x00,0x00,0x00,0x2F,0x00,0x00,// ! 1
	0x00,0x00,0x07,0x00,0x07,0x00,// " 2
	0x00,0x14,0x7F,0x14,0x7F,0x14,// # 3
	0x00,0x24,0x2A,0x7F,0x2A,0x12,// $ 4
	0x00,0x23,0x13,0x08,0x64,0x62,// % 5
	0x00,0x36,0x49,0x55,0x22,0x50,// & 6
	0x00,0x00,0x00,0x07,0x00,0x00,// ' 7
	0x00,0x00,0x1C,0x22,0x41,0x00,// ( 8
	0x00,0x00,0x41,0x22,0x1C,0x00,// ) 9
	0x00,0x14,0x08,0x3E,0x08,0x14,// * 10
	0x00,0x08,0x08,0x3E,0x08,0x08,// + 11
	0x00,0x00,0x00,0xA0,0x60,0x00,// , 12
	0x00,0x08,0x08,0x08,0x08,0x08,// - 13
	0x00,0x00,0x60,0x60,0x00,0x00,// . 14
	0x00,0x20,0x10,0x08,0x04,0x02,// / 15
	0x00,0x3E,0x51,0x49,0x45,0x3E,// 0 16
	0x00,0x00,0x42,0x7F,0x40,0x00,// 1 17
	0x00,0x42,0x61,0x51,0x49,0x46,// 2 18
	0x00,0x21,0x41,0x45,0x4B,0x31,// 3 19
	0x00,0x18,0x14,0x12,0x7F,0x10,// 4 20
	0x00,0x27,0x45,0x45,0x45,0x39,// 5 21
	0x00,0x3C,0x4A,0x49,0x49,0x30,// 6 22
	0x00,0x01,0x71,0x09,0x05,0x03,// 7 23
	0x00,0x36,0x49,0x49,0x49,0x36,// 8 24
	0x00,0x06,0x49,0x49,0x29,0x1E,// 9 25
	0x00,0x00,0x36,0x36,0x00,0x00,// : 26
	0x00,0x00,0x56,0x36,0x00,0x00,// ; 27
	0x00,0x08,0x14,0x22,0x41,0x00,// < 28
	0x00,0x14,0x14,0x14,0x14,0x14,// = 29
	0x00,0x00,0x41,0x22,0x14,0x08,// > 30
	0x00,0x02,0x01,0x51,0x09,0x06,// ? 31
	0x00,0x3E,0x49,0x55,0x59,0x2E,// @ 32
	0x00,0x7C,0x12,0x11,0x12,0x7C,// A 33
	0x00,0x7F,0x49,0x49,0x49,0x36,// B 34
	0x00,0x3E,0x41,0x41,0x41,0x22,// C 35
	0x00,0x7F,0x41,0x41,0x22,0x1C,// D 36
	0x00,0x7F,0x49,0x49,0x49,0x41,// E 37
	0x00,0x7F,0x09,0x09,0x09,0x01,// F 38
	0x00,0x3E,0x41,0x49,0x49,0x7A,// G 39
	0x00,0x7F,0x08,0x08,0x08,0x7F,// H 40
	0x00,0x00,0x41,0x7F,0x41,0x00,// I 41
	0x00,0x20,0x40,0x41,0x3F,0x01,// J 42
	0x00,0x7F,0x08,0x14,0x22,0x41,// K 43
	0x00,0x7F,0x40,0x40,0x40,0x40,// L 44
	0x00,0x7F,0x02,0x0C,0x02,0x7F,// M 45
	0x00,0x7F,0x04,0x08,0x10,0x7F,// N 46
	0x00,0x3E,0x41,0x41,0x41,0x3E,// O 47
	0x00,0x7F,0x09,0x09,0x09,0x06,// P 48
	0x00,0x3E,0x41,0x51,0x21,0x5E,// Q 49
	0x00,0x7F,0x09,0x19,0x29,0x46,// R 50
	0x00,0x46,0x49,0x49,0x49,0x31,// S 51
	0x00,0x01,0x01,0x7F,0x01,0x01,// T 52
	0x00,0x3F,0x40,0x40,0x40,0x3F,// U 53
	0x00,0x1F,0x20,0x40,0x20,0x1F,// V 54
	0x00,0x3F,0x40,0x38,0x40,0x3F,// W 55
	0x00,0x63,0x14,0x08,0x14,0x63,// X 56
	0x00,0x07,0x08,0x70,0x08,0x07,// Y 57
	0x00,0x61,0x51,0x49,0x45,0x43,// Z 58
	0x00,0x00,0x7F,0x41,0x41,0x00,// [ 59
	0x00,0x02,0x04,0x08,0x10,0x20,// \ 60
	0x00,0x00,0x41,0x41,0x7F,0x00,// ] 61
	0x00,0x04,0x02,0x01,0x02,0x04,// ^ 62
	0x00,0x40,0x40,0x40,0x40,0x40,// _ 63
	0x00,0x00,0x01,0x02,0x04,0x00,// ` 64
	0x00,0x20,0x54,0x54,0x54,0x78,// a 65
	0x00,0x7F,0x48,0x44,0x44,0x38,// b 66
	0x00,0x38,0x44,0x44,0x44,0x20,// c 67
	0x00,0x38,0x44,0x44,0x48,0x7F,// d 68
	0x00,0x38,0x54,0x54,0x54,0x18,// e 69
	0x00,0x08,0x7E,0x09,0x01,0x02,// f 70
	0x00,0x18,0xA4,0xA4,0xA4,0x7C,// g 71
	0x00,0x7F,0x08,0x04,0x04,0x78,// h 72
	0x00,0x00,0x44,0x7D,0x40,0x00,// i 73
	0x00,0x40,0x80,0x84,0x7D,0x00,// j 74
	0x00,0x7F,0x10,0x28,0x44,0x00,// k 75
	0x00,0x00,0x41,0x7F,0x40,0x00,// l 76
	0x00,0x7C,0x04,0x18,0x04,0x78,// m 77
	0x00,0x7C,0x08,0x04,0x04,0x78,// n 78
	0x00,0x38,0x44,0x44,0x44,0x38,// o 79
	0x00,0xFC,0x24,0x24,0x24,0x18,// p 80
	0x00,0x18,0x24,0x24,0x18,0xFC,// q 81
	0x00,0x7C,0x08,0x04,0x04,0x08,// r 82
	0x00,0x48,0x54,0x54,0x54,0x20,// s 83
	0x00,0x04,0x3F,0x44,0x40,0x20,// t 84
	0x00,0x3C,0x40,0x40,0x20,0x7C,// u 85
	0x00,0x1C,0x20,0x40,0x20,0x1C,// v 86
	0x00,0x3C,0x40,0x30,0x40,0x3C,// w 87
	0x00,0x44,0x28,0x10,0x28,0x44,// x 88
	0x00,0x1C,0xA0,0xA0,0xA0,0x7C,// y 89
	0x00,0x44,0x64,0x54,0x4C,0x44,// z 90
	0x00,0x00,0x08,0x7F,0x41,0x00,// { 91
	0x00,0x00,0x00,0x7F,0x00,0x00,// | 92
	0x00,0x00,0x41,0x7F,0x08,0x00,// } 93
	0x00,0x08,0x04,0x08,0x10,0x08,// ~ 94
};
/*********************Данные ASCII-растра*/


/*Данные китайского растра*********************/

/*Одинаковые китайские символы нужно определить только один раз, порядок не важен*/
/*Допускаются только китайские символы или полноширинные символы, не добавляйте полуширинные*/

/*Ширина 16 пикселей, высота 16 пикселей*/
const ChineseCell_t OLED_CF16x16[] = {
	"，",
	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	0x00,0x00,0x58,0x38,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	
	"。",
	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	0x00,0x00,0x18,0x24,0x24,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

	"你",
	0x00,0x80,0x60,0xF8,0x07,0x40,0x20,0x18,0x0F,0x08,0xC8,0x08,0x08,0x28,0x18,0x00,
	0x01,0x00,0x00,0xFF,0x00,0x10,0x0C,0x03,0x40,0x80,0x7F,0x00,0x01,0x06,0x18,0x00,

	"好",
	0x10,0x10,0xF0,0x1F,0x10,0xF0,0x00,0x80,0x82,0x82,0xE2,0x92,0x8A,0x86,0x80,0x00,
	0x40,0x22,0x15,0x08,0x16,0x61,0x00,0x00,0x40,0x80,0x7F,0x00,0x00,0x00,0x00,0x00,

	"世",
	0x20,0x20,0x20,0xFE,0x20,0x20,0xFF,0x20,0x20,0x20,0xFF,0x20,0x20,0x20,0x20,0x00,
	0x00,0x00,0x00,0x7F,0x40,0x40,0x47,0x44,0x44,0x44,0x47,0x40,0x40,0x40,0x00,0x00,

	"界",
	0x00,0x00,0x00,0xFE,0x92,0x92,0x92,0xFE,0x92,0x92,0x92,0xFE,0x00,0x00,0x00,0x00,
	0x08,0x08,0x04,0x84,0x62,0x1E,0x01,0x00,0x01,0xFE,0x02,0x04,0x04,0x08,0x08,0x00,
	/*Добавьте новые китайские символы в этом месте в указанном выше формате*/
	//...
	
	/*Графика по умолчанию, отображаемая при отсутствии указанного китайского символа (рамка с вопросом внутри), убедитесь, что она находится в конце массива*/
	"",		
	0xFF,0x01,0x01,0x01,0x31,0x09,0x09,0x09,0x09,0x89,0x71,0x01,0x01,0x01,0x01,0xFF,
	0xFF,0x80,0x80,0x80,0x80,0x80,0x80,0x96,0x81,0x80,0x80,0x80,0x80,0x80,0x80,0xFF,
};

/*********************Данные китайского растра*/


/*Данные изображений*********************/

/*Тестовое изображение (рамка с символом диода внутри), ширина 16 пикселей, высота 16 пикселей*/
const uint8_t Diode[] = {
	0xFF,0x01,0x81,0x81,0x81,0xFD,0x89,0x91,0xA1,0xC1,0xFD,0x81,0x81,0x81,0x01,0xFF,
	0xFF,0x80,0x80,0x80,0x80,0x9F,0x88,0x84,0x82,0x81,0x9F,0x80,0x80,0x80,0x80,0xFF,
};

/*Добавьте новые изображения в этом месте в указанном выше формате*/
//...

/*********************Данные изображений*/


/*****************Jiangxie Technology | Все права защищены****************/
/*****************jiangxiekeji.com*****************/


**Файл OLED_Data.h:**

```c
#ifndef __OLED_DATA_H
#define __OLED_DATA_H

#include <stdint.h>

/*Байтовая ширина китайского символа*/
#define OLED_CHN_CHAR_WIDTH			3		//Для UTF-8 установите 3, для GB2312 установите 2

/*Базовая ячейка растра*/
typedef struct 
{
	char Index[OLED_CHN_CHAR_WIDTH + 1];	//Индекс китайского символа
	uint8_t Data[32];						//Данные растра
} ChineseCell_t;

/*Объявление данных ASCII-растра*/
extern const uint8_t OLED_F8x16[][16];
extern const uint8_t OLED_F6x8[][6];

/*Объявление данных китайского растра*/
extern const ChineseCell_t OLED_CF16x16[];

/*Объявление данных изображений*/
extern const uint8_t Diode[];
/*Добавьте новые объявления изображений в этом месте в указанном выше формате*/
//...

#endif


/*****************Jiangxie Technology | Все права защищены****************/
/*****************jiangxiekeji.com*****************/

Тема	Ответов	Просм.
基于STM32G4的0.96寸OLED显示屏驱动程序（HAL库），支持硬件/软件I2C 开源项目 / Open-Source Project STM32 , IIC , OLED , Open-Source	25	30.10.2025
STM32读取SHT3x系列温湿度传感器，标准库和HAL库开源项目 / Open-Source Project STMicroelectronics , STM32 , IIC , Open-Source	17	30.10.2025
STM32单片机读取AHT10温湿度传感器数据嵌入式系统 / Embedded Systems STMicroelectronics , STM32 , IIC , Open-Source	7	30.10.2025
STM32使用硬件I2C读取SHTC3温湿度传感器开源项目 / Open-Source Project STM32 , C , IIC , Open-Source	4	30.10.2025
STM32软件I2C读取AM2320温湿度传感器数据开源项目 / Open-Source Project STMicroelectronics , STM32 , IIC , Open-Source	10	30.10.2025