Драйвер для OLED-дисплея 0,96" (SSD1306) на базе STM32G474 (4-пиновый интерфейс I2C), поддержка аппаратного/программного IIC, версия на HAL-библиотеке.
Драйвер довольно функционален: вывод английского текста, целых и дробных чисел, китайских иероглифов, изображений, двоичных и шестнадцатеричных данных; поддержка рисования точек, линий, прямоугольников, окружностей, эллипсов, треугольников; несколько шрифтов — фактически упрощённая графическая библиотека.
Программа создана на основе кода Jiangxie Technology; оригинал был под STM32F103 и работал только с программным I2C. Я добавил поддержку аппаратного I2C и оставил возможность переключения на программный через изменение макроса.
Тестовая плата — NUCLEO-G474RE.
Принцип работы 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
- Драйвер OLED 0,96" на STM32F1 с аппаратным/программным I2C: https://blog.zeruns.com/archives/769.html
Чат по электронике/микроконтроллерам: 2169025065
Результат
Кратко об I²C
Протокол I²C (Inter-Integrated Circuit) разработан Philips. Отличается минимальным количеством выводов, простотой аппаратной реализации, хорошей масштабируемостью и не требует внешних трансиверов (как, например, USART или CAN). Широко используется для связи между микросхемами внутри устройства.
I²C имеет всего одну линию данных SDA (Serial Data Line) — последовательная шина, передача идёт побитно, полудуплексный режим.
Полудуплекс: возможен двусторонний обмен, но одновременно передаётся только в одном направлении; достаточно одной линии данных.
Разделяют физический и протокольный уровни:
- Физический — механические/электрические характеристики (железо).
- Протокольный — логика обмена, формат пакетов (программное обеспечение).
Физический уровень I²C
Типичное подключение устройств I²C
- Поддержка множества устройств на одной шине.
- Две линии: SDA (данные) и SCL (синхронизация).
- Подтяжка к питанию через резисторы. В простое устройство переходит в высокоимпедансное состояние; когда все устройства в простое, резисторы устанавливают высокий уровень.
Для работы с I²C выводы МК должны быть настроены как open-drain, иначе возможно короткое замыкание.
Подробнее об I²C на STM32: https://url.zeruns.com/JC0Ah
Видео-курс Jiangxie Technology по STM32: https://www.bilibili.com/video/BV1th411z7sn?p=31
Инструкция по применению
По умолчанию используется аппаратный I²C (I2C3): SCL — PA8, SDA — PC9.
Аппаратный I²C
STM32CubeMX: выберите нужные выводы I2C3 и назначьте им функции SCL/SDA (на рис. — SCL I2C3).
Включите I2C3, режим скорости — Fast Mode Plus, 1000 кГц, остальное по умолчанию.
GPIO: после назначения выводы автоматически станут альтернативными open-drain. Установите скорость Very High и метки I2C3_SCL, I2C3_SDA (если используете другой I²C — измените в коде). Сгенерируйте проект.
В файле OLED.c закомментируйте #define OLED_USE_SW_I2C и раскомментируйте #define OLED_USE_HW_I2C. При необходимости замените I2C3_SCL/I2C3_SDA на свои метки.
Программный I²C
STM32CubeMX: назначьте два произвольных вывода, установите метки I2C3_SCL и I2C3_SDA, режим — open-drain, выход по умолчанию высокий, подтяжка, максимальная скорость.
В OLED.c закомментируйте #define OLED_USE_HW_I2C, раскомментируйте #define OLED_USE_SW_I2C. При необходимости поправьте имена выводов.
Необходимые компоненты
- Набор для начала работы со STM32: https://u.jd.com/fQS0YAe
- Плата STM32G474: https://s.click.taobao.com/8OwQ8vt
- Модуль 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Набор для начинающих STM32 от Jiangxie Technology: https://s.click.taobao.com/NTn9Txt
Программа
Ссылка для скачивания полного проекта:
Baidu Netdisk: ссылка: https://url.zeruns.com/0CQJG код: 0169
123 Netdisk (без ограничения скорости): https://www.123pan.com/s/2Y9Djv-O0cvH.html код: vvDt
Адрес открытого кода на Gitee: https://gitee.com/zeruns/STM32-HAL-OLED-I2C
Адрес открытого кода на GitHub: https://github.com/zeruns/STM32G4-OLED-SSD1306-I2C-HAL
Пожалуйста, поставьте Star
Проект создан в Keil5, разработка ведётся в Vscode + EIDE, обе IDE могут открыть этот проект.
Все файлы проекта в кодировке UTF-8; если при открытии отображаются кракозябры, установите в редакторе кодировку UTF-8.
Основной файл OLED.c:
/***************************************************************************************
* Эта программа создана Jiangxie Technology и распространяется бесплатно как open-source
* Вы можете свободно просматривать, использовать и изменять её, применяя в своих проектах
* Авторские права на программу принадлежат Jiangxie Technology, никто не может присвоить её себе
*
* Название программы: Драйвер 0.96" OLED-дисплея (4-контактный интерфейс I2C)
* Дата создания программы: 24.10.2023
* Текущая версия программы: V1.1
* Дата выпуска текущей версии: 08.12.2023
*
* Официальный сайт Jiangxie Technology: jiangxiekeji.com
* Официальный магазин Jiangxie Technology на Taobao: jiangxiekeji.taobao.com
* Описание и обновления: jiangxiekeji.com/tutorial/oled.html
*
* Если вы обнаружите ошибку или опечатку, сообщите нам по почте: [email protected]
* Перед отправкой письма проверьте страницу обновлений — возможно, проблема уже исправлена
***************************************************************************************
*/
/*
* Программа модифицирована zeruns
* Изменения: переведена с StdPeriph на HAL, добавлена поддержка аппаратного I2C,
* переключение на аппаратный I2C осуществляется изменением макроса
* Дата изменения: 16.03.2024
* Блог: https://blog.zeruns.com
* Домашняя страница Bilibili: https://space.bilibili.com/8320520
*/
#include "main.h"
#include "OLED.h"
#include <str
```#include <stdio.h>
#include <math.h>th.h>
#include <stdio.h>
#include <stdarg.h>
// 如果用到中文，编译器附加选项需要加 --no-multibyte-chars (用AC6编译器的不用加)
/*
选择OLED驱动方式，默认使用硬件I2C。如果要用软件I2C就将硬件I2C那行的宏定义注释掉，将软件I2C那行的注释取消。
不能同时两个都同时取消注释！
在stm32cubemx中初始化时需要将SCL和SDA引脚的"user lable"分别设置为I2C3_SCL和I2C3_SDA。
*/
#define OLED_USE_HW_I2C // 硬件I2C
//#define OLED_USE_SW_I2C // 软件I2C
/*引脚定义，可在此处修改I2C通信引脚*/
#define OLED_SCL I2C3_SCL_Pin // SCL
#define OLED_SDA I2C3_SDA_Pin // SDA
#define OLED_SCL_GPIO_Port I2C3_SCL_GPIO_Port
#define OLED_SDA_GPIO_Port I2C3_SDA_GPIO_Port
/*STM32G474芯片的硬件I2C3: PA8 -- SCL; PC9 -- SDA */
#ifdef OLED_USE_HW_I2C
/*I2C接口，定义OLED屏使用哪个I2C接口*/
#define OLED_I2C hi2c3
extern I2C_HandleTypeDef hi2c3; //HAL库使用，指定硬件IIC接口
#endif
/*OLED从机地址*/
#define OLED_ADDRESS 0x3C << 1 // 0x3C是OLED的7位地址，左移1位最后位做读写位变成0x78
/*I2C超时时间*/
#define OLED_I2C_TIMEOUT 10
/*软件I2C用的延时时间，下面数值为170MHz主频要延时的值，如果你的主频不一样可以修改一下，100MHz以内的主频改成0就行*/
#define Delay_time 3
/**
* 数据存储格式：
* 纵向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
/**
* @brief 向 OLED_SCL 写高低电平
* 根据 BitValue 的值，将 OLED_SCL 置高电平或低电平。
* @param BitValue 位值，0 或 1
*/
void OLED_W_SCL(uint8_t BitValue)
{
/*根据BitValue的值，将SCL置高电平或者低电平*/
HAL_GPIO_WritePin(OLED_SCL_GPIO_Port, OLED_SCL, (GPIO_PinState)BitValue);
/*如果单片机速度过快，可在此添加适量延时，以避免超出I2C通信的最大速度*/
for (volatile uint16_t i = 0; i < Delay_time; i++){
//for (uint16_t j = 0; j < 10; j++);
}
}
/**
* @brief OLED写SDA高低电平
* @param 要写入SDA的电平值，范围：0/1
* @return 无
* @note 当上层函数需要写SDA时，此函数会被调用
* 用户需要根据参数传入的值，将SDA置为高电平或者低电平
* 当参数传入0时，置SDA为低电平，当参数传入1时，置SDA为高电平
*/
void OLED_W_SDA(uint8_t BitValue)
{
/*根据BitValue的值，将SDA置高电平或者低电平*/
HAL_GPIO_WritePin(OLED_SDA_GPIO_Port, OLED_SDA, (GPIO_PinState)BitValue);
/*如果单片机速度过快，可在此添加适量延时，以避免超出I2C通信的最大速度*/
for (volatile uint16_t i = 0; i < Delay_time; i++){
//for (uint16_t j = 0; j < 10; j++);
}
}
#endif
/**
* @brief OLED引脚初始化
* @param 无
* @retval 无
* @note 当上层函数需要初始化时，此函数会被调用,
* 用户需要将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_SW_I2C
__HAL_RCC_GPIOC_CLK_ENABLE(); // 使能GPIOC时钟
__HAL_RCC_GPIOA_CLK_ENABLE(); // 使能GPIOA时钟
GPIO_InitTypeDef GPIO_InitStruct = {0}; // 定义结构体配置GPIO
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD; // 设置GPIO模式为开漏输出模式
GPIO_InitStruct.Pull = GPIO_PULLUP; // 内部上拉电阻
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; // 设置GPIO速度为高速
GPIO_InitStruct.Pin = I2C3_SDA_Pin; // 设置引脚
HAL_GPIO_Init(I2C3_SDA_GPIO_Port, &GPIO_InitStruct);// 初始化GPIO
GPIO_InitStruct.Pin = I2C3_SCL_Pin;
HAL_GPIO_Init(I2C3_SCL_GPIO_Port, &GPIO_InitStruct);
/*释放SCL和SDA*/
OLED_W_SCL(1);
OLED_W_SDA(1);
#endif
}
// https://blog.zeruns.com
/*通信协议*********************/
/**
* @brief I2C起始
* @param 无
* @return 无
*/
void OLED_I2C_Start(void)
{
#ifdef 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
}
/**
* @brief I2C终止
* @param 无
* @return 无
*/
void OLED_I2C_Stop(void)
{
#ifdef OLED_USE_SW_I2C
OLED_W_SDA(0); //拉低SDA，确保SDA为低电平
OLED_W_SCL(1); //释放SCL，使SCL呈现高电平
OLED_W_SDA(1); //在SCL高电平期间，释放SDA，产生终止信号
#endif
}
/**
* @brief I2C发送一个字节
* @param Byte 要发送的一个字节数据，范围：0x00~0xFF
* @return 无
*/
void OLED_I2C_SendByte(uint8_t Byte)
{
#ifdef 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
}
/**
* @brief OLED写命令
* @param Command 要写入的命令值，范围：0x00~0xFF
* @return 无
*/
void OLED_WriteCommand(uint8_t Command)
{
#ifdef OLED_USE_SW_I2C
OLED_I2C_Start(); // I2C起始
OLED_I2C_SendByte(0x78); //发送OLED的I2C从机地址
OLED_I2C_SendByte(0x00); //控制字节，给0x00，表示即将写命令
OLED_I2C_SendByte(Command); // 写入指定的命令
OLED_I2C_Stop(); // I2C终止
#elif defined(OLED_USE_HW_I2C)
uint8_t TxData[2] = {0x00, Command};
HAL_I2C_Master_Transmit(&OLED_I2C, OLED_ADDRESS, (uint8_t*)TxData, 2, OLED_I2C_TIMEOUT);
#endif
}
/**
* @brief OLED写数据
* @param Data 要写入数据的起始地址
* @param Count 要写入数据的数量
* @return 无
*/
void OLED_WriteData(uint8_t *Data, uint8_t Count)
{
uint8_t i;
#ifdef OLED_USE_SW_I2C
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终止
#elif defined(OLED_USE_HW_I2C)
uint8_t TxData[Count + 1]; // 分配一个新的数组，大小是Count + 1
TxData[0] = 0x40; // 起始字节
// 将Data指向的数据复制到TxData数组的剩余部分
for (i = 0; i < Count; i++) {
TxData[i + 1] = Data[i];
}
HAL_I2C_Master_Transmit(&OLED_I2C, OLED_ADDRESS, (uint8_t*)TxData, Count + 1, OLED_I2C_TIMEOUT);
#endif
}
/*********************通信协议*/
/*硬件配置*********************/
/**
* @brief OLED初始化
* @param 无
* @return 无
* @note 使用前，需要调用此初始化函数
*/
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(); // 更新显示，清屏，防止初始化后未显示内容时花屏
}
/**
* @brief OLED设置显示光标位置
* @param Page 指定光标所在的页，范围：0-7
* @param X 指定光标所在的X轴坐标，范围：0-127
* @return 无
* @note 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位
}/*********************Аппаратная конфигурация*/
/*Служебные функции*********************/
/*Служебные функции предназначены только для внутреннего использования части функций*/
/**
* @brief Функция возведения в степень
* @param X основание
* @param Y показатель степени
* @return равно 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;
}
/**
* @brief Проверка, находится ли заданная точка внутри указанного многоугольника
* @param nvert количество вершин многоугольника
* @param vertx verty массивы, содержащие координаты x и y вершин многоугольника
* @param testx testy координаты X и Y тестовой точки
* @return находится ли заданная точка внутри указанного многоугольника, 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;
}
/**
* @brief Проверка, находится ли заданная точка внутри указанного угла
* @param X Y координаты заданной точки
* @param StartAngle EndAngle начальный и конечный углы, диапазон: -180-180
* горизонтально вправо — 0°, горизонтально влево — 180° или -180°, вниз — положительные, вверх — отрицательные, по часовой стрелке
* @return находится ли заданная точка внутри указанного угла, 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; // Если не выполняются вышеуказанные условия, считаем, что точка не внутри угла
}
/*********************Служебные функции*/
/*Функции возможностей*********************/
/**
* @brief Обновление массива видеопамяти OLED на экране OLED
* @param нет
* @return нет
* @note Все функции отображения только читают и записывают массив видеопамяти 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);
}
}
/**
* @brief Частичное обновление массива видеопамяти OLED на экране OLED
* @param X горизонтальная координата левого верхнего угла указанной области, диапазон: 0-127
* @param Y вертикальная координата левого верхнего угла указанной области, диапазон: 0-63
* @param Width ширина указанной области, диапазон: 0-128
* @param Height высота указанной области, диапазон: 0-64
* @return нет
* @note Эта функция обновит как минимум указанную область
* Если обновляемая область по оси Y содержит только часть страницы, остальная часть той же страницы также обновится
* @note Все функции отображения только читают и записывают массив видеопамяти OLED
* затем вызывают функцию OLED_Update или OLED_UpdateArea
* только после этого данные массива видеопамяти отправляются в OLED-аппаратное обеспечение для отображения
* поэтому после вызова функции отображения для реального отображения на экране нужно вызвать функцию обновления
*/
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; }
/*Проходим по соответствующим страницам, охватываемым указанной областью*/
/*(Y + Height - 1) / 8 + 1 нужен для округления вверх (Y + Height) / 8*/
for (j = Y / 8; j < (Y + Height - 1) / 8 + 1; j++) {
/*Устанавливаем позицию курсора в указанный столбец соответствующей страницы*/
OLED_SetCursor(j, X);
/*Последовательно записываем Width данных, записывая данные массива видеопамяти в OLED-аппаратное обеспечение*/
OLED_WriteData(&OLED_DisplayBuf[j][X], Width);
}
}
/**
* @brief Полная очистка массива видеопамяти OLED
* @param нет
* @return нет
* @note После вызова этой функции для реального отображения на экране нужно вызвать функцию обновления
*/
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; // Полностью обнуляем данные массива видеопамяти
}
}
}
/**
* @brief Частичная очистка массива видеопамяти OLED
* @param X горизонтальная координата левого верхнего угла указанной области, диапазон: 0-127
* @param Y вертикальная координата левого верхнего угла указанной области, диапазон: 0-63
* @param Width ширина указанной области, диапазон: 0-128
* @param Height высота указанной области, диапазон: 0-64
* @return нет
* @note После вызова этой функции для реального отображения на экране нужно вызвать функцию обновления
*/
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)); // Обнуляем указанные данные массива видеопамяти
}
}
}
/**
* @brief Инвертирование всего массива видеопамяти OLED
* @param нет
* @return нет
* @note После вызова этой функции для реального отображения на экране нужно вызвать функцию обновления
*/
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; // Инвертируем все данные массива видеопамяти
}
}
}
/**
* @brief Частичное инвертирование массива видеопамяти OLED
* @param X горизонтальная координата левого верхнего угла указанной области, диапазон: 0-127
* @param Y вертикальная координата левого верхнего угла указанной области, диапазон: 0-63
* @param Width ширина указанной области, диапазон: 0-128
* @param Height высота указанной области, диапазон: 0-64
* @return нет
* @note После вызова этой функции для реального отображения на экране нужно вызвать функцию обновления
*/
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); // Инвертируем указанные данные массива видеопамяти
}
}
}
/**
* @brief Отображение одного символа на OLED
* @param X горизонтальная координата левого верхнего угла символа, диапазон: 0-127
* @param Y вертикальная координата левого верхнего угла символа, диапазон: 0-63
* @param Char символ для отображения, диапазон: видимые символы ASCII
* @param FontSize размер шрифта
* диапазон: OLED_8X16\t\tширина 8 пикселей, высота 16 пикселей
* OLED_6X8\t\tширина 6 пикселей, высота 8 пикселей
* @return нет
* @note После вызова этой функции для реального отображения на экране нужно вызвать функцию обновления
*/
void OLED_ShowChar(uint8_t X, uint8_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 - ' ']);
}
}
/**
* @brief Отображение строки на OLED
* @param X горизонтальная координата левого верхнего угла строки, диапазон: 0-127
* @param Y вертикальная координата левого верхнего угла строки, диапазон: 0-63
* @param String строка для отображения, диапазон: строка из видимых символов ASCII
* @param FontSize размер шрифта
* диапазон: OLED_8X16\t\tширина 8 пикселей, высота 16 пикселей
* OLED_6X8\t\tширина 6 пикселей, высота 8 пикселей
* @return нет
* @note После вызова этой функции для реального отображения на экране нужно вызвать функцию обновления
*/
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, последовательно отображая каждый символ*/
OLED_ShowChar(X + i * FontSize, Y, String[i], FontSize);
}
}
/**
* @brief Отображение числа (десятичное, положительное целое) на OLED
* @param X горизонтальная координата левого верхнего угла числа, диапазон: 0-127
* @param Y вертикальная координата левого верхнего угла числа, диапазон: 0-63
* @param Number число для отображения, диапазон: 0-4294967295
* @param Length длина числа, диапазон: 0-10
* @param FontSize размер шрифта
* диапазон: OLED_8X16\t\tширина 8 пикселей, высота 16 пикселей
* OLED_6X8\t\tширина 6 пикселей, высота 8 пикселей
* @return нет
* @note После вызова этой функции для реального отображения на экране нужно вызвать функцию обновления
*/
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);
}
}
/**
* @brief Отображение знакового числа (десятичное, целое) на OLED
* @param X горизонтальная координата левого верхнего угла числа, диапазон: 0-127
* @param Y вертикальная координата левого верхнего угла числа, диапазон: 0-63
* @param Number число для отображения, диапазон: -2147483648-2147483647
* @param Length длина числа, диапазон: 0-10
* @param FontSize размер шрифта
* диапазон: OLED_8X16\t\tширина 8 пикселей, высота 16 пикселей
* OLED_6X8\t\tширина 6 пикселей, высота 8 пикселей
* @return нет
* @note После вызова этой функции для реального отображения на экране нужно вызвать функцию обновления
*/
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);
}
}
/**
* @brief OLED вывод шестнадцатеричного числа (hex, положительное)
* @param X горизонтальная координата левого верхнего угла, 0~127
* @param Y вертикальная координата левого верхнего угла, 0~63
* @param Number число для показа, 0x00000000~0xFFFFFFFF
* @param Length длина числа в символах, 0~8
* @param FontSize размер шрифта
* OLED_8X16 8×16 пикселей
* OLED_6X8 6×8 пикселей
* @return нет
* @note после вызова нужно вызвать обновление экрана
*/
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) // цифра 0-9
{
OLED_ShowChar(X + i * FontSize, Y, SingleNumber + '0', FontSize);
}
else // цифра A-F
{
OLED_ShowChar(X + i * FontSize, Y, SingleNumber - 10 + 'A', FontSize);
}
}
}
/**
* @brief OLED вывод двоичного числа (bin, положительное)
* @param X горизонтальная координата левого верхнего угла, 0~127
* @param Y вертикальная координата левого верхнего угла, 0~63
* @param Number число для показа, 0x00000000~0xFFFFFFFF
* @param Length длина числа в битах, 0~16
* @param FontSize размер шрифта
* OLED_8X16 8×16 пикселей
* OLED_6X8 6×8 пикселей
* @return нет
* @note после вызова нужно вызвать обновление экрана
*/
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(X + i * FontSize, Y, Number / OLED_Pow(2, Length - i - 1) % 2 + '0', FontSize);
}
}
/**
* @brief OLED вывод числа с плавающей точкой (десятичное, дробное)
* @param X горизонтальная координата левого верхнего угла, 0-127
* @param Y вертикальная координата левого верхнего угла, 0-63
* @param Number число, -4294967295.0~4294967295.0
* @param IntLength количество цифр целой части, 0-10
* @param FraLength количество цифр дробной части, 0-9 (округление)
* @param FontSize размер шрифта
* OLED_8X16 8×16 пикселей
* OLED_6X8 6×8 пикселей
* @return нет
* @note после вызова нужно вызвать обновление экрана
*/
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;
}
/*извлекаем целую и дробную части*/
IntNum = Number;
Number -= IntNum;
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);
}
/**
* @brief OLED вывод китайского текста
* @param X горизонтальная координата левого верхнего угла, 0-127
* @param Y вертикальная координата левого верхнего угла, 0-63
* @param Chinese строка китайских иероглифов (только полноширинные символы)
* символы должны быть определены в массиве OLED_CF16x16 (OLED_Data.c)
* если символ не найден, выводится «□?»
* @return нет
* @note после вызова нужно вызвать обновление экрана
*/
void OLED_ShowChinese(uint8_t X, uint8_t Y, char *Chinese)
{
uint8_t pChinese = 0, pIndex, i;
char SingleChinese[OLED_CHN_CHAR_WIDTH + 1] = {0}; // UTF-8 3 байта + '\0'
for (i = 0; Chinese[i] != '\0'; i++)
{
SingleChinese[pChinese++] = Chinese[i];
if (pChinese >= OLED_CHN_CHAR_WIDTH)
{
SingleChinese[pChinese] = '\0';
pChinese = 0;
for (pIndex = 0; strcmp(OLED_CF16x16[pIndex].Index, "") != 0; pIndex++)
{
if (strcmp(OLED_CF16x16[pIndex].Index, SingleChinese) == 0) break;
}
OLED_ShowImage(X + ((i + 1) / OLED_CHN_CHAR_WIDTH - 1) * 16, Y, 16, 16, OLED_CF16x16[pIndex].Data);
}
}
}
/**
* @brief OLED вывод изображения
* @param X горизонтальная координата левого верхнего угла, 0-127
* @param Y вертикальная координата левого верхнего угла, 0-63
* @param Width ширина изображения, 0-128
* @param Height высота изображения, 0-64
* @param Image массив пикселей
* @return нет
* @note после вызова нужно вызвать обновление экрана
*/
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);
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);
if (Y / 8 + j + 1 > 7) continue;
OLED_DisplayBuf[Y / 8 + j + 1][X + i] |= Image[j * Width + i] >> (8 - Y % 8);
}
}
}
/**
* @brief OLED форматированный вывод через printf
* @param X горизонтальная координата левого верхнего угла, 0-127
* @param Y вертикальная координата левого верхнего угла, 0-63
* @param FontSize размер шрифта
* OLED_8X16 8×16 пикселей
* OLED_6X8 6×8 пикселей
* @param format строка формата (только ASCII)
* @param ... аргументы формата
* @return нет
* @note после вызова нужно вызвать обновление экрана
*/
void OLED_Printf(uint8_t X, uint8_t Y, uint8_t FontSize, char *format, ...)
{
char String[30];
va_list arg;
va_start(arg, format);
vsprintf(String, format, arg);
va_end(arg);
OLED_ShowString(X, Y, String, FontSize);
}
/**
* @brief OLED рисование точки
* @param X горизонтальная координата, 0-127
* @param Y вертикальная координата, 0-63
* @return нет
* @note после вызова нужно вызвать обновление экрана
*/
void OLED_DrawPoint(uint8_t X, uint8_t Y)
{
if (X > 127) return;
if (Y > 63) return;
OLED_DisplayBuf[Y / 8][X] |= 0x01 << (Y % 8);
}
/**
* @brief OLED получение состояния точки
* @param X горизонтальная координата, 0-127
* @param Y вертикальная координата, 0-63
* @return 1 — точка установлена, 0 — сброшена
*/
uint8_t OLED_GetPoint(uint8_t X, uint8_t Y)
{
if (X > 127) return 0;
if (Y > 63) return 0;
return (OLED_DisplayBuf[Y / 8][X] & (0x01 << (Y % 8))) ? 1 : 0;
}
/**
* @brief OLED рисование линии
* @param X0 горизонтальная координата первого конца, 0-127
* @param Y0 вертикальная координата первого конца, 0-63
* @param X1 горизонтальная координата второго конца, 0-127
* @param Y1 вертикальная координата второго конца, 0-63
* @return нет
* @note после вызова нужно вызвать обновление экрана
*/
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 (y = y0; y <= y1; y++) {
OLED_DrawPoint(x0, y); // последовательно рисуем точки
}
} 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);
}
}
}
}
/**
* @brief OLED-прямоугольник
* @param X горизонтальная координата левого верхнего угла, диапазон: 0~127
* @param Y вертикальная координата левого верхнего угла, диапазон: 0~63
* @param Width ширина прямоугольника, диапазон: 0~128
* @param Height высота прямоугольника, диапазон: 0~64
* @param IsFilled заливка прямоугольника
* диапазон: OLED_UNFILLED\t\tбез заливки
* OLED_FILLED\t\t\tс заливкой
* @return нет
* @note после вызова этой функции для отображения на экране необходимо вызвать функцию обновления
*/
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);
}
}
}
}
/**
* @brief OLED-треугольник
* @param X0 горизонтальная координата первой вершины, диапазон: 0-127
* @param Y0 вертикальная координата первой вершины, диапазон: 0-63
* @param X1 горизонтальная координата второй вершины, диапазон: 0-127
* @param Y1 вертикальная координата второй вершины, диапазон: 0-63
* @param X2 горизонтальная координата третьей вершины, диапазон: 0-127
* @param Y2 вертикальная координата третьей вершины, диапазон: 0-63
* @param IsFilled заливка треугольника
* диапазон: OLED_UNFILLED\t\tбез заливки
* OLED_FILLED\t\t\tс заливкой
* @return нет
* @note после вызова этой функции для отображения на экране необходимо вызвать функцию обновления
*/
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); }
}
}
}
}
/**
* @brief OLED-окружность
* @param X горизонтальная координата центра, диапазон: 0~127
* @param Y вертикальная координата центра, диапазон: 0~63
* @param Radius радиус окружности, диапазон: 0~255
* @param IsFilled заливка окружности
* диапазон: OLED_UNFILLED\t\tбез заливки
* OLED_FILLED\t\t\tс заливкой
* @return нет
* @note после вызова этой функции для отображения на экране необходимо вызвать функцию обновления
*/
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);
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);
}
}
}
}
/**
* @brief OLED-эллипс
* @param X горизонтальная координата центра, диапазон: 0~127
* @param Y вертикальная координата центра, диапазон: 0~63
* @param A длина горизонтальной полуоси, диапазон: 0~255
* @param B длина вертикальной полуоси, диапазон: 0~255
* @param IsFilled заливка эллипса
* диапазон: OLED_UNFILLED\t\tбез заливки
* OLED_FILLED\t\t\tс заливкой
* @return нет
* @note после вызова этой функции для отображения на экране необходимо вызвать функцию обновления
*/
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);```c
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);
}
}
/**
* @brief рисуем дугу на OLED
* @param X горизонтальная координата центра дуги, диапазон: 0~127
* @param Y вертикальная координата центра дуги, диапазон: 0~63
* @param Radius радиус дуги, диапазон: 0~255
* @param StartAngle начальный угол дуги, диапазон: -180~180
* 0° — горизонтально вправо, 180° или -180° — горизонтально влево, положительные значения — внизу, отрицательные — вверху, поворот по часовой стрелке
* @param EndAngle конечный угол дуги, диапазон: -180~180
* 0° — горизонтально вправо, 180° или -180° — горизонтально влево, положительные значения — внизу, отрицательные — вверху, поворот по часовой стрелке
* @param IsFilled флаг заливки дуги, при заполнении получается сектор
* диапазон: OLED_UNFILLED\t\tбез заливки
* OLED_FILLED\t\t\tс заливкой
* @return нет
* @note после вызова функции для отображения на экране необходимо вызвать функцию обновления
*/
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); }
}
}
}
}
/*********************Служебные функции*/
/*****************Jiangxie Technology, все права защищены****************/
/*****************jiangxiekeji.com*****************/
Рекомендуем к прочтению
- Бюджетные и дешёвые VPS/облачные серверы: https://blog.zeruns.com/archives/383.html
- Сделал трёхфазный измеритель электроэнергии и выложил как open-source, удобно отслеживать потребление дома: https://blog.zeruns.com/archives/771.html
- Руководство по запуску сервера Minecraft: https://blog.zeruns.com/tag/mc/
- Руководство по запуску сервера Palworld: https://blog.zeruns.com/tag/PalWorld/
- Краткий обзор RD6012P — цифрового лабораторного блока питания 60 В 12 А: https://blog.zeruns.com/archives/740.html
- Опыт распаковки 3D-принтера Bambu Lab P1SC: https://blog.zeruns.com/archives/770.html
- Сравнение различных типов и брендов конденсаторов и индуктивностей (D, Q, ESR, X): https://blog.zeruns.com/archives/765.html