【项目】 智慧监测系统 开发笔记(二) 从点亮一个像素到跑起一套菜单:OLED / 取模 / UI / 按键
从点亮一个像素到跑起一套菜单:OLED / 取模 / UI / 按键
STM32F103 智慧监测系统 · 开发笔记(二)
写完这篇我最大的感受是:所有看起来像"UI"的东西,本质上都是在这四个常量里做算术。
常量 数值 出处 显存容量 1024 字节 = 8 Page × 128 列 SSD1306 的页式显存 单个字符数据 16 字节 8×16 点阵 可排版的字符格 16 列 × 4 行 = 64 格 128/8 = 16,64/16 = 4 可用按键 5 个 PG10 / PG6 / PG8 / PG7 / PC5 一旦这四条被钉死,后面写的每一行
x = 8 * 5、%-4.1f、(num - 1) * 16,都不是"设计感",而是从这个 1024 字节的盒子里抠出来的坐标。理解这一点,比记住 SSD1306 有哪几十条指令重要得多。
先把本轮仓库的增量摆出来,这也是本篇的"取材范围":
文件 干什么 interface/oled.c/oled.hSSD1306 驱动、帧缓冲、绘制原语 Common/font.h95 个 8×16 ASCII 字模 interface/key.c/key.h5 键扫描状态机(中断驱动) User/menu.c/menu.h四个界面 + 阈值结构体 Core/Src/tim.c/Core/Inc/tim.hTIM2:2 ms 时基 ISR/tim_isr.c周期回调 → key_scan()Test/test.c/test.htest_menu()等测试入口User/app.c初始化串联 + g_td阈值Core/Src/main.c/main.h/gpio.cMX_TIM2_Init()、按键引脚定义
一、先把"屏幕"这件事想明白
1.1 0.96 寸到底量的是哪一段
课件在这里花了不少篇幅讲"寸",其实是嵌入式新手最常踩的一个概念坑:
显示器的寸是英寸(inch),不是市寸,而且量的是对角线。
- 1 inch = 2.54 cm
- 0.96 寸 = 0.96 × 2.54 ≈ 2.44 cm(这是对角线的长度,不是屏幕宽)
顺带把市寸也理一下:
1 市尺 ≈ 33.33 cm,1 市寸 ≈ 3.33 cm。
所以"七尺男儿"按现代市尺算是 2.31 m,跟姚明的 2.29 m 差不多——但古代的尺比现代短,这个换算本身就不严谨。
这件事跟硬盘容量其实是一类东西:
厂商按 1000 算 1 TB,操作系统按 1024 算,于是 1 TB 硬盘插上电脑只剩 931 GB。屏幕挑对角线来标尺寸,是因为同样一块矩形,对角线数字最大、最好看。
1.2 OLED 和 LCD 的本质差别
OLED:像素自己发光 LCD:背光发光 + 液晶控光 ┌─────────────┐ ┌─────────────┐ │ ● ● ○ ● ● ○ │ ← 像素自亮 │ ██ 背光层 ██ │ ← 常亮 │ ○ ● ● ○ ● ● │ │ ▓▓ 液晶层 ▓▓ │ ← 当"百叶窗" └─────────────┘ └─────────────┘
维度 OLED LCD 发光主体 有机薄膜自身发光 背光灯发光,液晶只负责"挡光" 黑色表现 不发光 = 真黑,对比度高 背光漏光,黑不下去 结构厚度 薄,无需背光模组 需要背光层,较厚 视角 大 依赖面板工艺 一句人话版本:
OLED 是一屋子员工各自带手电筒,要用就自己开;
LCD 是办公室只开一盏大灯,大家靠拉窗帘控制自己那块亮不亮。
1.3 分辨率 128 × 64 = 8192 个像素
这块屏宽 128 个像素、高 64 个像素,总共 8192 个独立可控的点。
手机发布会说的 2400 × 1080 是同一套语义:横向 2400 个点、纵向 1080 个点。
但这里立刻出现一个问题:
8192 个像素,如果每个像素一根控制线,就要 8192 根引脚。
这在物理上不可能实现。
所以 OLED 模组内部集成了一颗显示驱动芯片(本项目是 SSD1306,同类还有 CH1116、SSD1315),MCU 只需要把"哪一列、哪一页、亮哪几位"告诉它,剩下的像素寻址、刷新、亮度全由它自己完成。
这就是"驱动 IC"存在的全部理由:
把 8192 根线压缩成 2 根 I²C 线 + 一套命令。
理解了这句话,后面所有指令就都不难背了——它们只是这颗芯片对外暴露的"API"。
1.4 页(Page):8 行像素 = 1 个字节
SSD1306 不按"行"管理像素,而是把 每 8 行合成 1 个 Page,64 行 → 8 个 Page(Page0 ~ Page7)。
看到"8 行 = 1 单元",程序员应该立刻反应过来:
这就是 1 个字节,8 个 bit。
于是"某页某列"的 8 个像素,正好用一个 uint8_t 表示。
课件里那个"一栋 8 层楼、每层一个管家"的比喻挺好用:
- 屏幕 = 128 列 × 8 层的楼
- Page = 楼层号(0~7)
- 列地址 = 房间号(0~127)
- 1 个字节 = 这一层这一间房里,8 个格子的灯亮不亮
1.5 关键约定:Bit0 在最上面
这是整套驱动里最容易记反、也最容易导致"字上下颠倒/镜像"的一条:
Page 内的 8 行(从上到下) ┌─────┬─────┬─────┬─────┐ Bit0 │ 1 │ │ │ │ ← 最上面一行 Bit1 │ │ 0 │ │ │ Bit2 │ 1 │ │ │ │ Bit3 │ 1 │ │ │ │ Bit4 │ │ 0 │ │ │ Bit5 │ 1 │ │ │ │ Bit6 │ │ 0 │ │ │ Bit7 │ 1 │ │ │ │ ← 最下面一行 └─────┴─────┴─────┴─────┘1.6 本项目的硬件与地址
项目 值 说明 接口 I²C,4 Pin(VCC/GND/SCL/SDA) 省引脚、布线简单、速率够 驱动 IC SSD1306 资料最多 分辨率 128 × 64 8192 像素 模块尺寸 27.5 mm × 27.8 mm — 工作电压 3.3 ~ 5 V 逻辑电平与 MCU 兼容 从机地址 0x3C D/C#(SA0)接地 → 7 位地址 0111100 SSD1306 的 I²C 地址字节格式是:
b7 b6 b5 b4 b3 b2 b1 b0 0 1 1 1 1 0 SA0 R/W# ↑ ↑ D/C# 0=写 1=读SA0 拉低 → 地址 0x3C;拉高 → 0x3D。
本项目 D/C# 直接接地,所以是 0x3C。
这里有个必须点出来的细节:
HAL 库的
HAL_I2C_Master_Transmit收的是已经左移一位、凑成 8 位格式的地址。所以oled.h里写的是:#define OLED_ADDRESS (0x3C << 1) // = 0x78同理
aht20.h里是#define AHT20_ADDRESS (0x38 << 1)= 0x70。忘了这个左移,现象是"设备有应答但数据全错"或者干脆
HAL_ERROR,因为总线上发的是 0x3C → 被解读成"写 0x1E 号设备"。
二、SSD1306 的"命令语言"与 I²C 写机制
2.1 指令表(本项目实际用到的那 23 条)
逐条对上:
# 指令 参数 作用 本项目的值 1 0xAE— 关显示(命令期间不动面板) 先关 2 0xD50x80时钟分频 / 振荡器频率 分频 1、fosc 最大 3 0xA80x3F复用率(MUX) 1/64 占空比 4 0xD30x00垂直显示偏移 不偏移 5 0x40— 显示起始行 = RAM 第 0 行 起始行 0 6 0xA1— 左右方向:段重映射 正常(列 127→SEG0) 7 0xC8— 上下方向:COM 扫描反向 正常 8 0xDA0x12COM 引脚硬件配置 交替 + 禁用左/右重映射 9 0x810x7F对比度 127(0xCF 更亮,被注释掉了) 10 0xD90xF1预充电周期 Phase1=1, Phase2=15 11 0xDB0x30VCOMH 取消选择电压 ~0.83×Vcc 12 0xA4— 恢复"按 RAM 内容显示" 必须,否则可能全亮 13 0xA6— 正常显示(非反相) 正常 14 0x8D0x14电荷泵 使能(3.3 V 供电必需) 15 0xAF— 开显示 最后开 几个值得展开讲的点:
(1)为什么先
0xAE后0xAF。初始化过程中显存是随机的(上电后 GDDRAM 内容不确定),如果面板一直开着,用户会看到一屏雪花点。
所以标准流程是:关显示 → 配参数 → 清显存 → 开显示。
代码里
0xAF之后立刻oled_clean()+oled_update_screen(),就是补上"清显存"这一步。(2)
0x8D / 0x14是所有新人漏掉后"屏幕完全不亮"的头号原因。SSD1306 内部的 OLED 面板需要 7~9 V 的驱动电压,模组只有 3.3/5 V 供电,靠的是片上电荷泵升压。
电荷泵默认是关的,不发这两条命令,屏就是黑的——而且 I²C 有应答、日志也正常,非常容易误判成"屏坏了"。
(3)
0xA1+0xC8是"方向"这对组合。
0xA0/0xA1管左右,0xC0/0xC8管上下。四个组合能凑出正常、左右镜像、上下镜像、180° 旋转四种效果。
取模的时候如果字是反的,第一反应应该是查这两条,而不是去改字库。
(4)
0xA8 / 0x3F的 0x3F 怎么来的。MUX 参数的有效位是低 6 位,128×64 的屏要 64 路 COM,所以填
64 - 1 = 63 = 0x3F。如果是 128×32 的屏就填 0x1F。填错的现象是:只显示一半、或者上下重复。
(5)
0xDA / 0x12。高 4 位是 COM 引脚的物理接线方式(交替/非交替),低 4 位是左右重映射开关。
128×64 常规模组用
0x12(对应0x02是另一种接线)。2.2 页地址与列地址
页地址指令:
0xB0 + page,page ∈ 0~7。Page0 → 0xB0 Page3 → 0xB3 Page7 → 0xB7列地址要分两条发,因为一条命令只有 4 个有效位:
- 低 4 位:
0x00 ~ 0x0F- 高 4 位:
0x10 ~ 0x1F课件举的例子值得手算一遍:要定位到第 24 列
24 = 0b0001 1000 └─高4─┘ └─低4─┘ 低 4 位 = 1000 → 0x00 | 0x08 = 0x08 高 4 位 = 0001 → 0x10 | 0x01 = 0x11所以顺序是:先
0x08,再0x11。注意 0x11 不是 0x10+1 的巧合,而是"高 4 位值直接填进 0x1x 的空位里"。
如果列号是 100:
100 = 0b0110 0100 低 4 位 = 0100 → 0x04 高 4 位 = 0110 → 0x16仓库里的实现正好是这个逻辑:
static void oled_set_cursor(uint8_t page, uint8_t column) { oled_write_command(0xB0 | (page & 0x0F)); // 页 oled_write_command(0x00 | (column & 0x0F)); // 列低 4 位 oled_write_command(0x10 | ((column >> 4) & 0x0F)); // 列高 4 位 }
page & 0x0F这里有个小瑕疵:128×64 只有 Page0
7,掩码应该是& 0x07。
用15",一旦上层传错(比如把 y=72 当页号算成 9),SSD1306 会收到一个非法页地址,行为未定义。0x0F意味着"允许传 8这种"参数校验缺失"在本篇会反复出现,先记一笔。
2.3 控制字节:0x00 和 0x40 到底在说什么
I²C 写完从机地址之后,紧接着的第一个字节是"控制字节",而不是数据本身。
它的位定义是:
bit7 bit6 bit5~0 Co D/C# 0 │ │ │ └── 0 = 后面跟的是命令;1 = 后面跟的是显存数据 └──────── 0 = 这个控制字节管后面一整串;1 = 只管紧跟着的 1 个字节于是:
0x00=Co=0, D/C=0→ 接下来全是命令0x40=Co=0, D/C=1→ 接下来全是显存数据课件里那句"在 HAL 库里 Co 位实际用不到"说得很到位:
HAL_I2C_Master_Transmit是整包 burst 发送,{0x00, 0xAE}两个字节在一次传输里发完,天然就是"一个控制字节管一个命令";
{0x40, data..., data...}则是"一个控制字节管 128 个数据字节"。只有当你需要"命令和数据混在同一个 I²C 报文里"时,才需要 Co=1 逐字节切换。
2.4
oled_init()逐行精读void oled_init(void) { HAL_Delay(300); // ① 等 OLED 供电稳定 oled_write_command(0xAE); // ② 关显示 oled_write_command(0xD5); oled_write_command(0x80); // ③ 时钟 oled_write_command(0xA8); oled_write_command(0x3F); // ④ 1/64 oled_write_command(0xD3); oled_write_command(0x00); // ⑤ 无偏移 oled_write_command(0x40); // ⑥ 起始行 0 oled_write_command(0xA1); // ⑦ 左右正常 oled_write_command(0xC8); // ⑧ 上下正常 oled_write_command(0xDA); oled_write_command(0x12); // ⑨ COM 配置 oled_write_command(0x81); oled_write_command(0x7F); // ⑩ 对比度 oled_write_command(0xD9); oled_write_command(0xF1); // ⑪ 预充电 oled_write_command(0xDB); oled_write_command(0x30); // ⑫ VCOMH oled_write_command(0xA4); // ⑬ 按 RAM 显示 oled_write_command(0xA6); // ⑭ 正常(非反相) oled_write_command(0x8D); oled_write_command(0x14); // ⑮ 电荷泵使能 oled_write_command(0xAF); // ⑯ 开显示 oled_clean(); // ⑰ 清 RAM 帧缓冲 oled_update_screen(); // ⑱ 把空缓冲推给屏(真清屏) LOG_DEBUG("OLED initialized"); }① 那 300 ms 不是随手写的。
OLED 模组内部的电荷泵和稳压需要时间,上电瞬间就发命令,容易出现"第一条命令丢失、初始化一半失败"。300 ms 是很保守的值,实测 50~100 ms 通常也行,但调试期多等一点不亏。
⑰⑱ 这两行是全篇最值得强调的"概念分界线":
oled_clean()只是把内存里的 1024 字节清 0,屏幕不会有任何变化;必须
oled_update_screen()才能真正推下去。所以后面
menu_threshold_display()、menu_wifi_display()里都是oled_clean()+ 一堆绘制 +oled_update_screen()。只 clean 不 update,是新手最常见的"代码没错但屏不变"的坑。
初始化代价算一笔账(为第 8 节埋伏笔):
项目 数值 I²C 速率 100 kHz → 1 bit = 10 µs 一条命令 = 地址 + 控制 + 命令 = 27 bit + START/STOP ≈ 29 bit ≈ 0.29 ms 23 条命令 ≈ 6.7 ms 加上 HAL_Delay(300)≈ 307 ms 也就是说,从上电到屏上出现第一行字,光 OLED 这一路就要 300 ms 以上;
再加上
aht20_init()里的 40 ms,开机要 350 ms 左右才开始刷界面。这不是 bug,是时序代价。
三、驱动层:帧缓冲 + 六个原语
3.1 为什么必须有 1024 字节的帧缓冲
oled.c的第 13 行:uint8_t oled_data_buffer[8][128] = {0}; // 8 页 × 128 列这 1024 字节就是整块屏的"影子"。
为什么不能像很多"野路子"教程那样直接往屏上写?对比一下:
能力 直写屏(无缓冲) 帧缓冲(本项目) 局部擦除一个字段 要自己算页/列,逐字节读改写
(I²C 读很麻烦)
oled_clean_area()直接改内存反色高亮一整行 做不到(必须先读回原内容) ~buffer[page][x]一行搞定画面闪烁 边画边上屏,能看到"半成品" 画完一次性推,视觉上是原子的 刷新耗时 只刷改动部分,快 每次全推 1024 字节,慢 RAM 占用 0 1024 B(F103ZE 的 64 KB 里占 1.5%) 这块板子内存富余(64 KB),所以"用空间换体验"完全值得。
换成 F103C8(20 KB)也还撑得住;
但如果只有 6~10 KB 的芯片,就得考虑"页缓冲"(只缓存一页 128 B)甚至直写了。
3.2
oled_write_command:把两个字节打成一次事务static void oled_write_command(uint8_t command) { uint8_t control_byte = 0x00; uint8_t buffer[2] = {control_byte, command}; HAL_StatusTypeDef ret = HAL_I2C_Master_Transmit(&OLED_I2C, OLED_ADDRESS, buffer, 2, HAL_MAX_DELAY); if (ret != HAL_OK) LOG_DEBUG("Failed to transmit I2C command"); }
- 为什么是 2 而不是 1:I²C 报文里,控制字节是"额外的第一个字节",不算在命令里。SSD1306 规定"从机地址后的第一个字节必须是控制字节",所以最少 2 字节。
HAL_MAX_DELAY的风险:这个宏是0xFFFFFFFF,意思是"我等一辈子"。如果 SDA 被某个从机拉低(总线卡死),这里会永久阻塞,看门狗都救不了(因为没开)。正确写法应该是给个 5~10 ms 的有限超时,失败就上报。- 失败只打日志不返回错误码:调用方完全不知道命令丢了。第 7 节会看到,这个"吞掉错误"的习惯正是后面一系列诡异现象的源头之一。
3.3
oled_write_data:VLA + memcpy 的代价static void oled_write_data(uint8_t *data, uint16_t size) { uint8_t control_byte = 0x40; uint8_t buffer[size + 1]; // ← 可变长数组(VLA),在栈上 buffer[0] = control_byte; memcpy(&buffer[1], data, size); HAL_I2C_Master_Transmit(&OLED_I2C, OLED_ADDRESS, buffer, size + 1, HAL_MAX_DELAY); }三件事值得说:
buffer[size + 1]是 C99 的 VLA,长度在运行时才定,分配在栈上。全屏刷一页时 size=128 → 占 129 字节栈。ARM 默认栈 1 KB(startup 文件里Stack_Size EQU 0x00000400),一次刷新就吃掉 12.5% 的栈;如果哪天有人在中断里调用它,栈很容易爆。memcpy是纯粹的浪费:128 字节拷贝在 72 MHz 上大约 1~2 µs,单看不多,但它换来的只是"把控制字节和数据拼成一段"。完全可以避免:最干净的其实是方案 C:把// 方案 A:先发控制字节,再发数据(两次事务,省掉拷贝,但多一次 START) // 方案 B:静态缓冲 + 指针偏移(推荐) static uint8_t page_buf[1 + 128]; page_buf[0] = 0x40; memcpy(&page_buf[1], src, 128); // 还是一样…… // 方案 C:让 buffer 的第一字节常驻,数据直接写进去(真正零拷贝)oled_data_buffer定义成uint8_t [8][129],第 0 字节放0x40,绘制时全部偏移 1 字节,刷新时整页甩出去——一次 memcpy 都不需要。- size 没有上限校验:如果有人传
size = 200,栈上就是 201 字节,且 I²C 一次发 201 字节(SSD1306 会一直往 GDDRAM 里灌,跨页回绕),画面直接乱。3.4
oled_clean_area:位掩码是怎么算出来的
这是全文件里最"位运算"的一段,值得逐行拆:
void oled_clean_area(uint8_t x, uint8_t y, uint8_t width, uint8_t height) { if (x > 127) return; if (y > 63) return; if (x + width > 128) width = 128 - x; // 钳位 if (y + height > 64) height = 64 - y; for (uint8_t i = y; i < y + height; i++) // 逐行 { uint8_t page = i / 8; // 行 → 页 uint8_t bit_position = i % 8; // 页内第几位 uint8_t bit_mask = ~(1 << bit_position); // 清这一位的掩码 for (uint8_t j = x; j < x + width; j++) oled_data_buffer[page][j] &= bit_mask; } }举例:清掉 y=20 这一行、x=40 起的 8 列
计算 结果 page = 20 / 82(Page2) bit_position = 20 % 84 1 << 40b0001 0000= 0x10~0x100b1110 1111= 0xEFbuffer[2][40..47] &= 0xEF只清 Bit4,其余 7 位保持不变 为什么要逐行而不是逐页:
因为调用方给的
y不一定 8 对齐(比如 y=48 是页边界,但 y=52 就不是)。逐行 + 掩码的方式对任意 y 都成立,这是这段代码设计得比较扎实的地方。
3.5
oled_show_image:把 16 字节塞进两页void oled_show_image(uint8_t x, uint8_t y, uint8_t width, uint8_t height, const uint8_t *image) { if (x > 127) return; if (y > 63) return; oled_clean_area(x, y, width, height); // ① 先清 uint8_t page_num = (height - 1) / 8 + 1; // ② 向上取整 for (uint8_t page = 0; page < page_num; ++page) { for (uint8_t i = 0; i < width; ++i) { if ((x + i) > 127) break; if ((y / 8 + page) > 7) return; uint8_t page_index = y / 8 + page; oled_data_buffer[page_index][x + i] = image[page * width + i]; // ③ 直接赋值 } } }② 向上取整的写法:
(height - 1) / 8 + 1。height=16 →
15/8+1 = 1+1 = 2页;height=8 →
7/8+1 = 0+1 = 1页;height=24 →
23/8+1 = 2+1 = 3页。这个公式比
(height + 7) / 8更容易溢出(height+7在 uint8_t 里会回绕),所以前者更稳。③ 直接
=赋值,不是|=或运算:这意味着这个函数是"覆盖式绘制",不是"叠加式绘制"。
两个后果:
- 好的一面:一个 8×16 字符格永远是整块替换,不会出现上一帧的残影。
- 坏的一面:不能把两个图形叠在同一片区域(比如图标上再叠一个数字)。这也是为什么
menu.c里风扇状态要"先oled_clean_area再写"——因为不先清干净,上一帧的内容在没有被新内容覆盖到的列上会留着。但这里有一个真正的方法学缺陷:
代码用
y / 8定位页,完全忽略了y % 8。也就是说,它要求
y必须是 8 的倍数。
y = 0/16/32/48(menu 里全是这种)→ 正常工作y = 3(想把图标往下挪 3 个像素)→ 图形会错位到页边界,看起来"往上跳了 3 像素"一个真正通用的实现需要"跨页 + 位偏移",大概是这样的骨架:
/* 支持任意 y 的写法(核心:把 y%8 的偏移量左移进字节) */ uint8_t y_off = y % 8; for (int row = 0; row < height; row++) { int page = (y + row) / 8; int bit = (y + row) % 8; for (int col = 0; col < width; col++) { /* 从源图里取第 row 行的第 col 位(源图自己按页组织,取法要对应) */ ... } }这套写法一旦引入,源图的组织方式(页式/行式)也要跟着约定,复杂度会上升一个量级。
对于"只显示 8×16 字符和 16×16 图标"的项目,不做通用化是完全合理的取舍——但必须写在注释里说清楚"y 必须 8 对齐",否则接手的人一定会踩。
(4)
return和break混用:内层越界用
break(跳过这一列),越页用return(直接退出整个函数)。语义上没问题,但风格上不一致,容易在后续改动里出错。
3.6
oled_update_screen:一帧多少钱void oled_update_screen(void) { for (uint8_t page = 0; page < 8; ++page) { oled_set_cursor(page, 0); // 3 条命令 oled_write_data(oled_data_buffer[page], 128); // 1 条数据包 } }时间账,按 100 kHz 算:
动作 字节数 bit 数 时间 3 条命令(每条 = 地址+控制+命令) 3×3 = 9 字节 81 + 6(START/STOP)≈ 87 bit ≈ 0.87 ms 1 页数据(地址 + 控制 + 128 数据) 130 字节 1170 + 2 ≈ 1172 bit ≈ 11.72 ms 单页合计 — — ≈ 12.6 ms 8 页合计 — — ≈ 100.7 ms 一帧全屏 ≈ 100 ms,也就是 10 fps 上限。
这个数字非常关键,它决定了这个项目的所有时序设计:
- 想把界面做到 25 fps(40 ms/帧)→ 100 kHz 做不到
- 换 400 kHz 快速模式 → 数据量不变,时间 ÷4 ≈ 25 ms/帧(40 fps),但需要在
.ioc里改ClockSpeed,且 OLED 模组的 R1/R2 上拉电阻要够小(通常 4.7 kΩ 已支持)- 局部刷新(只推变化的页)→ 一页 12.6 ms,改一个字段只推 1 页,能到 8 fps 的"分区更新"
- 换 SPI 版模块(课件里右边那块 7 Pin 的)→ 硬件 SPI 可以跑到 10 MHz 以上,一帧 < 2 ms,代价是多占 3 根线
顺带说一句:
1024 字节的数据本身就要 92 ms(1026 字节 × 9 bit / 100 kHz),这是不可压缩的下限。
任何"优化命令"的努力最多只能省掉那 24 条命令的 ~8 ms。
想快,只能提高时钟或减少数据量。
3.7 字符 / 字符串 / 数字 / 定宽 / 反色
void oled_show_char(uint8_t x, uint8_t y, char ch, uint8_t font_size) { if (font_size == OLED_8X16) oled_show_image(x, y, 8, 16, OLED_F8x16[ch - ' ']); // ← 索引 }
ch - ' '是整个字库设计的核心。字库数组从空格(ASCII 0x20)开始,一共 95 个字符(0x20 ~ 0x7E),所以
' '→ 0,'A'→ 65-32 = 33,'~'→ 94。致命的边界问题:
ch是char。ARM 上
char无符号(AAPCS 约定),所以:
ch = 0x1F(控制字符)→ 索引0x1F - 0x20,在无符号里是 -1 → 0xFF →OLED_F8x16[255],读到数组外 2.4 KB 处,显示一坨随机像素ch = 0x80以上(中文、UTF-8 字节)→ 索引 ≥ 96 → 越界一个字符就 16 字节 × 95 = 1520 字节,越界 255 索引就是越过 4 KB,完全踩到别的常量或代码区。正确做法必须加一句:
if (ch < ' ' || ch > '~') return; /* 或者用 '?' 兜底 */
OLED_8X16这个宏一名三义,是全篇最"课程代码味"的设计:#define OLED_8X16 8 // 注释说"宽度 8 像素,高度 16 像素"它同时充当了三个角色:
用法 出现位置 实际含义 字体类型标识 if (font_size == OLED_8X16)"我要 8×16 这套字" 字符宽度(像素) x += font_size步进 8 像素 布局单位的乘数 OLED_8X16 * 5"5 个字符宽 = 40" 这不是 bug,但是坏味道。
一旦以后要加 6×12 或 12×24 字体,
font_size传 12 时x += 12恰好也对(因为步进等于宽),但if (font_size == OLED_8X16)的判断就完全失效。正确的写法是分开两个概念:
ont_id(选哪套字)和char_w(步进多少像素),或者干脆把字宽做成查表。void oled_show_num(uint8_t x, uint8_t y, int32_t num, uint8_t font_size) { char str[12]; snprintf(str, sizeof(str), "%d", num); oled_show_string(x, y, str, font_size); }
str[12]刚好够 int32 的极限:
-2147483648是 11 个字符 +\0= 12。这个数字不是拍的,是算出来的:
int32 最小值的十进制长度是 11 位(含负号)。
如果换成 int64,就必须改成 21。
void oled_show_int_fixed(uint8_t x, uint8_t y, int32_t num, uint8_t width, uint8_t font_size) { char buf[16]; if (width >= sizeof(buf)) width = sizeof(buf) - 1; snprintf(buf, sizeof(buf), "%-*d", width, num); // ← 星号宽度 oled_show_string(x, y, buf, font_size); }
%-*d里的*表示"宽度由参数决定",-表示左对齐。所以
width=4, num=12→"12 "(12 后面两个空格),定宽的目的就是让数字变的时候不串列。但这里有个隐患:
如果
num的位数超过width(比如 width=4、num=10000,5 位数),snprintf会老老实实输出 5 个字符,超出预留字段宽度,压到右边的内容上。
menu.c里那句if (mq2_ppm > 9999) mq2_ppm = 9999;
就是为了防这个——用"篡改数据"来保证排版,属于把 UI 约束反灌进业务逻辑。更好的做法是
oled_show_int_fixed内部钳位或截断,把排版责任留在排版层。void oled_invert_line16(uint8_t line) { if (line >= 4) return; uint8_t y = line * 16; // 行 → 像素 uint8_t page_start = y / 8; // 行 → 起始页 uint8_t page_end = page_start + 1; // 16 像素 = 2 页 for (uint8_t page = page_start; page <= page_end; ++page) for (uint8_t x = 0; x < 128; ++x) oled_data_buffer[page][x] = ~oled_data_buffer[page][x]; }这条函数是菜单高亮的全部实现。
16 像素高 = 2 页,所以 "第 line 行" 对应 Page
2*line和2*line+1:
line y 涉及 Page 0 0 0, 1 1 16 2, 3 2 32 4, 5 3 48 6, 7
~buffer是逐位取反:原来 0 的位变 1(亮),原来 1 的位变 0(灭)。
视觉上就是"白底黑字",即反色高亮。
顺便对比一个容易混的点:
SSD1306 有
0xA6/0xA7两条"全局反相"命令,那是整屏反色;这里的
~是在 RAM 里翻某两页,属于"局部反色"。用 0xA7 做菜单高亮的后果是整屏变黑底白字,选中的那一行反而不突出了。
这个区别面试里问得很勤。
3.8 驱动层的隐患汇总
# 位置 问题 后果 1 oled_show_charch - ' '无范围检查控制字符/中文 → 越界读 4 KB 2 oled_show_image忽略 y % 8y 非 8 对齐时图形跳页错位 3 oled_show_image覆盖写而非或写 两图无法叠加,必须手动清区 4 oled_write_command/dataHAL_MAX_DELAY总线卡死 → 永久阻塞 5 同上 失败只打日志不返回 上层无感知,静默丢帧 6 oled_write_dataVLA + memcpy 129 B 栈占用 + 每帧 8 次无谓拷贝 7 oled_set_cursor页掩码 & 0x0F允许非法页地址 8~15 8 OLED_8X16一名三义 加字体时判断失效 9 oled_update_screen无脏页机制 改 1 个字符也要推 1024 B 10 全文件 无对比度接口 0x81参数写死 0x7F
四、取模:把"字"变成"16 个字节"
4.1 PCtoLCD2002 的每一选项都在对应一条显存约定
PCtoLCD2002 是老软件了,但它的选项组合其实是"显存模型"的翻译器。
课件的设置不是随便选的:
选项 选的值 为什么必须是这个 模式 字符模式 只取单个/多个文字的 ASCII 点阵(图形模式是给 BMP 用的) 点阵格式 阴码 1 = 点亮。SSD1306 里 1 就是亮,反过来就是全屏反相 取模方式 列行式 显存是"先写一列的 8 行,再下一列",所以数据必须按"列优先、每列 8 行"排 取模走向 逆向 低位在前。SSD1306 的 Bit0 = 该列最上像素 自定义格式 C51 格式 输出 0xXX,形式,能直接贴进 C 数组行前缀 / 行后缀 清空 默认会带 {},贴进数组会变成非法语法字体 / 字宽 / 字高 宋体 / 16 / 16 生成 8×16 的英文点阵 "列行式"到底是什么意思(课件讲得有点绕,我用坐标重述一遍):
注意它和"逐列式"的差别:
逐列式是"一列 64 行一次性打完(8 个字节)再下一列",那是给"整屏竖着刷"的场合用的。
列行式是"每列只打 8 行,就跳到下一列",正好对应 SSD1306 的 '一页一行列地址自增' 的写序。
课件说"这跟后续规定的数据显示方式有关",其实更准确的说法是:跟 SSD1306 的页寻址机制有关。
4.2 手算一个 'a'
课件给的 16 字节:
0x00,0x00,0x80,0x80,0x80,0x00,0x00,0x00, ← 上半 8 列(row0~7) 0x00,0x19,0x24,0x24,0x12,0x3F,0x20,0x00 ← 下半 8 列(row8~15)拆开看第一行的第 3 个字节
0x80:0x80 = 0b1000 0000 │└──────┴─ 低 7 位全 0 → 这列上面 7 个像素灭 └─ Bit7 = 1 → 这列最下面那个像素亮因为"逆向"(Bit0 在最上),Bit7=1 意味着这列的第 8 个像素(也就是最下面那个)亮。'a' 是个小写字母,顶部有拱、底部有脚——这 0x80 就是"某一列只有最下面那一点点"的笔画。
如果取模走向误选成"顺向"会怎样?
每个字节的 bit 顺序反了,于是每一列内部的 8 个像素上下颠倒。
整字看起来不是上下镜像(那是 0xC0/0xC8 的事),而是**"每 8 行内部像素顺序乱了"**,字会变成锯齿轮廓——这种错很隐蔽,因为字形还是"在那儿",只是笔画位置全错。
4.3 仓库字库和课件样例不完全一样,而且这没关系
课件第 9 讲举的 'a' 是:
0x00,0x00,0x80,0x80,0x80,0x00,0x00,0x00, 0x00,0x19,0x24,0x24,0x12,0x3F,0x20,0x00仓库
font.h里的 'a' 是:0x00,0x00,0x80,0x80,0x80,0x80,0x00,0x00, 0x00,0x19,0x24,0x22,0x22,0x22,0x3F,0x20差别在 4 个字节(第 5 个 0x80、以及下半部分的 0x22/0x24)。
这不是错,是字体渲染差异:不同字体、不同取模软件的栅格化结果本来就不同,课件自己也写了"字模数据上可能会存在些许差异,这个并无影响"。
只要满足两条,任何一套字模都能用:
- 同一套字库内部约定一致(都列行式、都逆向)
- 索引关系一致(从
' '开始、顺序连续)这也是为什么
oled_show_char能用一句OLED_F8x16[ch - ' ']解决问题——它依赖的不是"这 16 字节长什么样",而是"第 N 个字符在第 N*16 字节"这个索引契约。4.4 "8×16" 到底谁在前
课件专门提醒了一句:
PCtoLCD2002 用的是计算机图形学的 W×H 约定,第一个数是宽度。
所以"英文字符 8×16"= 宽 8 像素、高 16 像素。
而在中文语境里说"长宽比 16:16"很容易被理解成"高 16、宽 8"(也就是 8×16 被读成"高×宽")。
这个歧义会直接导致在 paper 上算错布局:
以为一个字符占 16 像素宽,那 128 像素只能放 8 个字符,界面设计全盘推翻。
正确的账:
宽 8 → 128/8 = 16 列;高 16 → 64/16 = 4 行。
这就是
menu.c里所有OLED_8X16 * N的来源。4.5 字库的内存账
项目 数值 字符数 95(0x20 ~ 0x7E) 每字符 16 字节 总大小 1520 字节 存储位置 static const→ Flash(因为const)
static const这个组合很关键:
const让编译器把数组放进.rodata(Flash),而不是 RAM;
static让它在每个包含font.h的编译单元里都是一份独立的副本。这里有个隐患:
font.h被oled.c、menu.c、test.h都包含了(test.h里#include "font.h"),如果编译器没有把相同内容的static const合并(armclang 默认会做常量合并,但不保证),Flash 里可能出现 2~3 份 1520 字节的副本。标准做法应该是:
font.h里只放extern const uint8_t OLED_F8x16[][16];
font.c里放定义。这样全工程只有一份。在本项目里 Flash 有 512 KB,多 3 KB 无感,但这是个"以后再搬到大项目会翻车"的坏习惯。
4.6 从"字符"到"图标"
oled_show_image()的签名(x, y, w, h, *image)其实是个通用位图接口,字符只是"宽 8 高 16 的位图"的特例。所以做图标不需要新代码:
- 在 PCtoLCD2002 里切到图形模式,导入 16×16 的 BMP
- 取模参数保持"阴码 + 列行式 + 逆向"
- 得到 32 字节(16×16 = 2 页 × 16 列)
- 直接
oled_show_image(48, 16, 16, 16, icon_bmp)唯一要守的规矩还是那条:
y必须 8 对齐。
五、UI:在 16 × 4 的格子里排版
5.1 硬约束先摆出来
参数 计算 结果 横向字符数 128 / 8 16 纵向行数 64 / 16 4 单行像素高 16 2 页 第 N 行 y 坐标 (N-1) * 16 0 / 16 / 32 / 48 所有布局都是在这张表上做加减法。
一旦某个字符串超过 16 个字符,最后几个字符会被
oled_show_image的if (x + i > 127) break;悄悄截掉——不报错、不提示,就是看不见了。5.2 数据显示页:三段式分栏
0 40 72 80 │ │ │ │ tem: 25.6 C ← y=0 hum: 61.2 % ← y=16 mq2: 812 ppm ← y=32 fan: ON rpm ← y=48 └─5 字符─┘└─4 字符─┘└单位─┘ x=0 x=40 x=80void menu_data_display(void) { /* ① 固定标签,从 x=0 起,5 个字符 */ oled_show_string(0, 0, "tem: ", OLED_8X16); oled_show_string(0, 16, "hum: ", OLED_8X16); oled_show_string(0, 32, "mq2: ", OLED_8X16); oled_show_string(0, 48, "fan: ", OLED_8X16); /* ② 单位,从 x = 8*(5+4+1) = 80 起 */ oled_show_string(OLED_8X16 * (5 + 4 + 1), 0, "C", OLED_8X16); oled_show_string(OLED_8X16 * (5 + 4 + 1), 16, "%", OLED_8X16); oled_show_string(OLED_8X16 * (5 + 4 + 1), 32, "ppm", OLED_8X16); oled_show_string(OLED_8X16 * (5 + 4 + 1), 48, "rpm", OLED_8X16); ... }为什么是
5 + 4 + 1? 这串数字是"字符格"的加减法:
段 起始格 长度 结束格 标签 0 5 0~4 留 1 格空隙 — 1 5 数据 — → 实际从第 5 格(x=40) 4 5~8 留 1 格空隙 — 1 9 单位 10(x=80) 1~3 10~12 注意代码里数据是从第 5 格(x=40)开始的,但单位公式里写的是
5+4+1= 第 10 格——这意味着标签区(5 格)和数据区(4 格)之间其实没有空隙,数据紧贴标签;数据区后面才有 1 格空隙。
写
5 + 4 + 1而不是直接写10,是故意把布局参数暴露成可算的表达式,这个习惯值得学——改标签长度的时候只要改一处。然后是数据部分:
aht20_start(); // ← 采集和显示耦合在这 uint8_t message[8]; snprintf((char *)message, 8, "%-4.1f", aht20_data.temperature); oled_show_string(OLED_8X16 * 5, 0, (char *)message, OLED_8X16); snprintf((char *)message, 8, "%-4.1f", aht20_data.humidity); oled_show_string(OLED_8X16 * 5, 16, (char *)message, OLED_8X16); mq2_read_data(); if (mq2_ppm > 9999.0f) mq2_ppm = 9999.0f; // ← 为了排版改数据 snprintf((char *)message, 8, "%-4d", (int)roundf(mq2_ppm)); oled_show_string(OLED_8X16 * 5, 32, (char *)message, OLED_8X16);
%-4.1f的字段宽度到底算几位? 这是 printf 里最容易算错的地方:
.1= 小数点后 1 位4= 最小总宽度 4 个字符(包含小数点和数字本身)-= 左对齐,不足补空格所以:
值 输出 占宽 25.6"25.6"4 ✓ 9.5"9.5 "4 ✓ 100.0"100.0"5 ✗ 溢出 -5.2"-5.2"4 ✓ -10.5"-10.5"5 ✗ 溢出 注意:
%.1f的小数点占 1 位,所以"4 字符宽"实际只能表达99.9以内的正数(25.6是 4 字符)。一旦温度上 100,或者出现两位数负温,这一行就会往右挤进单位列,视觉上变成
tem: 100.0C粘在一起。因为屏上从不 clean,这种"粘字"是永久的——只有下次数值回到 4 字符宽,那多出来的一个字符位置才会被重新覆写。
%-4d给 mq2 用:
812→"812 ",正好 4 字符。但 PPM 上万是常态,所以代码里先钳到 9999。
这就是"用改数据换排版"的典型例子:
业务值被 UI 约束污染了,而且
mq2_ppm是全局变量,被menu.c直接写,其他模块读到的就是被 UI 改过的值。风扇那一段更值得细看:
if (fan_is_running == 0) { oled_clean_area(OLED_8X16 * 5, 48, OLED_8X16 * 2, 16); // 清 2 格 = 16 px oled_show_string(OLED_8X16 * 5, 48, "OFF", OLED_8X16); // 写 3 格 = 24 px } else if (fan_is_running == 1) { oled_clean_area(OLED_8X16 * 5, 48, OLED_8X16 * 3, 16); // 清 3 格 = 24 px oled_show_string(OLED_8X16 * 5, 48, "ON", OLED_8X16); // 写 2 格 = 16 px }这里的清区宽度和写入宽度是反的:
OFF清 2 格却写 3 格,ON清 3 格却写 2 格。因为
oled_show_image是覆盖写,字符格本身会被整块替换,所以"清"其实只负责清掉没有被新字覆盖到的尾部:
ON→OFF:新内容 3 格,旧内容 2 格,旧内容全部被覆盖,清 3 格是多余的OFF→ON:新内容 2 格,旧内容 3 格,第 3 格残留,清 3 格正好清掉所以真正起作用的只有第二条里的
clean_area(..., 3, 16)。两条分支的宽度应该统一写成
OLED_8X16 * 3(按最长文案 OFF 算),写成 2/3 不一致是反复改文案留下的痕迹,容易让人误以为有特殊含义。还有一个语义错误:
fan行的单位写的是"rpm",但显示内容是ON/OFF。状态和转速不是一回事:
要么单位应该去掉(只显示开关状态),要么显示转速数值(
fan: 1200 rpm)。现在这个组合是"单位先写上了,转速还没实现"的半成品。
5.3 阈值调整页:反色高亮 + 光标
void menu_threshold_display(uint8_t num) { oled_clean(); // ① 整屏清空 oled_show_string(8, 0, "tem: ", OLED_8X16); // ② 标签从 x=8 起 oled_show_string(8, 16, "hum: ", OLED_8X16); oled_show_string(8, 32, "mq2: ", OLED_8X16); oled_show_string(8, 48, "fan: ", OLED_8X16); oled_show_int_fixed(8 + 8 * 5, 0, g_td.temp_threshold, 4, OLED_8X16); // ③ x=48 oled_show_int_fixed(8 + 8 * 5, 16, g_td.hum_threshold, 4, OLED_8X16); oled_show_int_fixed(8 + 8 * 5, 32, g_td.mq2_threshold, 4, OLED_8X16); oled_show_int_fixed(8 + 8 * 5, 48, g_td.fan_threshold, 4, OLED_8X16); oled_show_string(0, (num - 1) * 16, ">", OLED_8X16); // ④ 光标 oled_invert_line16(num - 1); // ⑤ 反色高亮 oled_update_screen(); // ⑥ 推屏 }② 为什么这张页从 x=8 起,而数据显示页从 x=0 起?
因为这一页要给第 0 格留出
>光标的位置。x=8 就是"让出一个字符格"。③
8 + 8 * 5 = 48:标签从 8 开始,5 个字符 = 40 像素,所以数据从 48 开始。
这是一种"相对基准"的写法,比硬编码 48 更好维护。
④
(num - 1) * 16:
num是从 1 开始的逻辑行号(菜单习惯),像素坐标从 0 开始,所以必须减 1 再乘 16。这里有个未校验的边界:
传入 num (num-1)*16结果 1~4 0/16/32/48 正常 0 (0-1)在 uint8_t 里 → 255 → y=4080oled_show_string的show_image里y > 63直接 return;invert_line16(255)也直接 return → 静默什么都不画5 64 show_image里y > 63→ return;invert_line16(4)→>= 4→ return所以 num 越界不会崩,但会"高亮消失"——菜单上没有任何一行是反色的,用户会以为按键坏了。
这类"静默失效"比崩溃更难查。正确做法是在函数入口加
if (num < 1 || num > 4) num = 1;。⑤ 的顺序很关键:
先画
>,再整体反色。如果反色在前、画
>在后,那个>就是"黑底白字"的箭头,会显得往外凸出来。现在的顺序让
>也参与反色,视觉上是"选中行整条白底、黑字、黑箭头",很整齐。5.4 WIFI 配置页
void menu_wifi_display(uint8_t num) { oled_clean(); oled_show_string(8, 0, "1.Reset module", OLED_8X16); oled_show_string(8, 16, "2.SoftAP mode", OLED_8X16); oled_show_string(8, 32, "3.Airlink mode", OLED_8X16); oled_show_string(0, (num - 1) * 16, ">", OLED_8X16); oled_invert_line16(num - 1); oled_update_screen(); }字数算一下(这是 16 列约束的实战检验):
文案 字符数 起始 x 结束 x 是否越界 1.Reset module14 8 8 + 112 = 120 ✓ 2.SoftAP mode13 8 112 ✓ 3.Airlink mode14 8 120 ✓ 全都卡在 120 以内,还剩 1 格。 这就是 16 列约束的分量——再多写两个字,比如
1.Reset the module(19 字符),就直接被屏幕截断。这里的 num 边界问题更严重:
这一页只有 3 项,但
invert_line16允许到 line 3。如果按键把 num 加到 4,第 4 行(y=48)是空的,
>会画在空行上,整行反色成一整条白条——看起来像"菜单崩了"。页内菜单的 num 上界必须按该页的条目数钳位,而不是按屏幕总行数。
5.5 WIFI 连接页:16 个字符的进度条
static void menu_oled_show_progress_bar(uint8_t progress) { char bar[17] = {' ', ' ', ...}; // 16 个空格 + 隐含的 '\0' bar[0] = '['; bar[11] = ']'; uint8_t block_num = progress / 10; // 每 10% 一个 '=' for (uint8_t i = 1; i <= block_num; i++) bar[i] = '='; uint8_t units_digit = progress % 10 + '0'; uint8_t tens = ' '; if (progress >= 10) tens = (progress / 10) % 10 + '0'; bar[12] = tens; bar[13] = units_digit; bar[14] = '%'; static uint8_t flag = 0; bar[15] = flag ? '-' : '|'; // 动画指示符 flag = !flag; oled_show_string(0, 16, bar, OLED_8X16); }先把这 16 个字符的"预算表"列出来:
下标 0 1~10 11 12 13 14 15 内容 [=× 10]十位 个位 %` 设计意图很清楚:16 个字符刚好铺满 128 像素,一个不多一个不少。
但
bar[i] = '='从下标 0 开始写,于是:
progress block_num 被覆盖的下标 现象 0 0 无 `[ ] 0% 10 1 0 =把[顶掉了 → `= ]10%50 5 0~4 `===== ]50% 90 9 0~8 `=========]90% 100 10 0~9 ==========]100%-✗
另一个值得注意的设计点:
这是字符串进度条,不是图形进度条。
好处是零额外代码(复用
oled_show_string);代价是分辨率只有 10 级(10% 一档),比"画一条 128 像素长的矩形、按比例填充"粗糙得多。如果要更平滑的进度,应该直接往帧缓冲里画矩形:
/* 图形进度条:x=0..127, y=16..31,用 2 页拼一个 16 像素高的实心条 */ for (uint8_t page = 2; page <= 3; page++) for (uint8_t x = 0; x < (uint8_t)(progress * 128 / 100); x++) oled_data_buffer[page][x] = 0xFF;进度完成分支:
void menu_wifi_connect_display(uint8_t num) { oled_clean(); oled_show_string(0, 0, "Connect WIFI...", OLED_8X16); // 15 字符 = 120 px menu_oled_show_progress_bar(num); if (num >= 100) { oled_clean_area(0, 16, OLED_8X16 * 16, 16); // 清掉进度条那一行 oled_show_string(0, 16, "Connect Success", OLED_8X16); oled_update_screen(); // 先推"成功" HAL_Delay(2000); // 停 2 秒 oled_clean(); // 清内存 } oled_update_screen(); // 再把"空"推下去 }
六、按键:2 ms 的时基从哪来
6.1 TIM2 的时间账
tim.c里两个数字:Prescaler = 71、Period = 1999。推导链条必须从时钟树出发:
步骤 依据 结果 SYSCLK HSE 8 MHz × PLL9 72 MHz HCLK AHB /1 72 MHz PCLK1 APB1 /2 36 MHz TIM2 时钟 APB1 分频 ≠1 时,定时器时钟 = PCLK1 × 2 72 MHz 计数频率 72 MHz / (71 + 1) 1 MHz → 1 tick = 1 µs 更新周期 (1999 + 1) tick 2000 µs = 2 ms 中断频率 1 / 2 ms 500 Hz "APB1 预分频 ≠ 1 时定时器时钟翻倍"这条规则,是 STM32 时钟树里最容易漏的一条:很多人以为 TIM2 跑 36 MHz,算出来周期差一倍(于是消抖变成 40 ms、长按变成 4 s),查半天查不出原因。
记住:APB1 给定时器的时钟是"专用倍频后的",不是 PCLK1 本身。
6.2 中断链路
TIM2 计数到 ARR │ ├─ TIM2_IRQHandler() ← Core/Src/stm32f1xx_it.c │ └─ HAL_TIM_IRQHandler(&htim2) │ └─ 清 SR 的 UIF 标志 │ └─ HAL_TIM_PeriodElapsedCallback(&htim2) ← ISR/tim_isr.c │ └─ key_scan() ← interface/key.c │ └─ key_process() × 5
ISR/tim_isr.c只有 169 字节,全部内容就是这一层转发:void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) { if (htim->Instance == TIM2) key_scan(); }这个回调是所有 HAL 定时器共用的,所以
if (htim->Instance == TIM2)这个判断不能省——以后加了 TIM3 做 PWM,不带判断就会一起触发。NVIC 配置:
HAL_NVIC_SetPriority(TIM2_IRQn, 0, 0)。抢占优先级 0,和第(一)篇批评过的 ADC/I2C 同处最高级。
2 ms 一次的按键扫描本身很短(5 次
HAL_GPIO_ReadPin≈ 几 µs),但它和 ADC 的中断风暴同级,意味着谁也别想抢占谁——ADC 每次 ISR 都很短,所以 TIM2 还能被及时响应;真正的受害者是主循环(第 8 节细讲)。6.3 五个键的引脚
宏 引脚 GPIO 模式 按下电平 KEY1 PG10( SYS_SW1)输入, GPIO_NOPULL低 KEY2 PG6( SYS_SW2)输入, GPIO_NOPULL低 KEY3 PG8( SYS_SW3)输入, GPIO_NOPULL低 KEY4 PG7( SYS_SW4)输入, GPIO_NOPULL低 KEY5 PC5( EC11_KEY)输入, GPIO_NOPULL低 注意 PG8 是 KEY3、PG7 是 KEY4——顺序和编号是"错开"的(PG10→SW1、PG6→SW2、PG8→SW3、PG7→SW4)。
这是
.ioc里手动贴标签的结果,改板子的时候极易接错,值得在注释里写一句引脚对照表。
GPIO_NOPULL是个隐患:这意味着芯片内部既不上拉也不下拉,按键松开时引脚是浮空的。
它依赖板子上有外部上拉电阻。
如果哪天换了块没有外部上拉的板子,浮空引脚读出来的值随机跳动,现象是"按键自己乱触发"。
更稳的做法是
GPIO_PULLUP(F103 的 GPIO 内部上拉 30~50 kΩ,对按键足够),代价是低功耗场景下松开时会有漏电流。
EC11_KEY只有按键引脚(PC5),没有 A/B 相。EC11 是旋转编码器,正常应该有 5 个引脚(A/B/公共/按键两脚)。
.ioc里 PG 上只有 4 个 SW、PC5 一个 EC11_KEY,说明这个编码器在本项目里只当"第 5 个按键"用,旋钮功能没接。这也是"项目没做完"的一处留白——第 11 讲的界面切换、第 12 讲的阈值调整,用旋钮会比用 4 个键舒服得多。
6.4
key_process逐行精读static void key_process(GPIO_PinState state, key_status_t *key) { if (state == GPIO_PIN_SET) // ① 松开 { key->lock_flag = 0; key->cnt = 0; key->cnt2 = 0; if (key->long_flag == 1) // ② 长按后松手 → 上报长按码 { key->long_flag = 0; key_num = key->long_code; } } else if (key->lock_flag == 0) // ③ 刚按下 → 消抖阶段 { key->cnt++; if (key->cnt > KEY_DELAY_TIME) // ④ 连续 11 次低电平 → 确认按下 { key->lock_flag = 1; key->cnt = 0; key_num = key->short_code; // ⑤ 立刻上报短按 } } else if (key->cnt < KEY_CONTINUE_TIME) // ⑥ 已确认,等连发启动 { key->cnt++; } else // ⑦ 进入连发/长按区 { key->cnt++; key->cnt2++; if (key->cnt2 > KEY_CONTINUE_TRIGGER_TIME) // ⑧ 连发 { key->cnt2 = 0; key_num = key->short_code; } if (key->cnt > KEY_LONG_TIME) // ⑨ 判长按 key->long_flag = 1; } }四段时间常数(每 tick = 2 ms):
宏 值 折合时间 含义 KEY_DELAY_TIME= 10cnt > 10→ 第 11 tick22 ms 消抖窗口 KEY_CONTINUE_TIME= 500500 tick 1000 ms 连发开始前要按住的时间 KEY_LONG_TIME= 10001000 tick(从确认按下算起) 2000 ms 长按判定 KEY_CONTINUE_TRIGGER_TIME= 2526 tick 52 ms 连发间隔(约 19 次/秒) 时序推演(按住 KEY1 不放):
时刻 状态 动作 t = 0 按下(读低) cnt从 0 开始每 2 ms +1t = 22 ms cnt = 11 > 10lock_flag=1、cnt=0、key_num = 1(短按码立即上报)t = 22 ~ 1022 ms cnt: 0 → 500只计数,不做事("静默期") t ≈ 1022 ms cnt到 500进入 else 分支,开始 cnt2计数t ≈ 1074 ms cnt2 > 25key_num = 1(第一次连发)每 +52 ms cnt2归零重来key_num再次 = 1(连发)t ≈ 2024 ms cnt > 1000long_flag = 1松手 读高 key_num = long_code(11)注意两个反直觉的设计:
(1)短按是在"按下瞬间"上报的,不是松手时。
好处是响应快(22 ms 内就有反应);坏处是无法区分"按下"和"抬起"两个事件——做"按住加速"、"拖拽滑条"这类交互时,这套状态机就不够用了。
菜单场景(按一下换一行)刚好只需要"按一下"。
(2)长按期间
key_num还在被连发覆盖。具体说,
long_flag在 2 s 置位之后,cnt2的连发逻辑还在继续跑,每 52 ms 仍然把key_num写成短按码。所以一次 3 秒的长按,主循环会依次看到:
1(按下)→1(连发 ×N)→11(松手)。如果菜单里"长按 = 删除阈值",用户会看到列表先飞快地往下跳了十几行,最后才执行删除。 这是这套状态机最该修的地方:
long_flag一旦置位,就应该停掉连发。(3)
cnt2在lock_flag=1后被清零(按下的那一瞬间
cnt=0,但cnt2只在松手时清)。所以第二次按下时
cnt2可能残留旧值——不过因为它只在 else 分支自增,而 else 分支要求cnt >= 500,所以残留值会立刻触发一次"假连发"。实际上
cnt2也应该在lock_flag=1时清 0。6.5 编码方案与注释的错位
key.c第 14 行:key_status_t key[5] = { {1, 11, 0, 0, 0, 0}, // 注释:编号1,短按编码11 {2, 22, 0, 0, 0, 0}, // 注释:编号2,短按编码22 ...而
key.h里的结构体字段顺序是:typedef struct { uint8_t short_code; // ← 第 1 个 uint8_t long_code; // ← 第 2 个 uint8_t long_flag; uint8_t lock_flag; uint16_t cnt; uint16_t cnt2; } key_status_t;所以
{1, 11, ...}的真实含义是short_code = 1, long_code = 11,不是注释说的"编号 1、短按 11"。结果反而是对的:
短按上报 1~5(正好是"编号"),长按上报 11/22/33/44/55(编号 ×11)。
这个编码方案很实用:
主循环只要判断
key_num <= 5就是短按、>= 11就是长按,一个字节就带上了"哪个键 + 什么动作"。顺带说一句:
这个"编号 ×11"的编码有个数学上的好处——所有码值都各不相同且能反解(
id = code % 11;短按code = id,长按code = id * 11)。如果以后要加"双击码",可以扩成 ×111(
1→111、2→222),一个 uint16_t 就能表达三层语义。6.6 按键层的问题汇总
# 位置 问题 后果 1 app.ckey_num未加volatile-O3 下可能被缓存,丢按键 2 key.c注释字段语义写反 后续维护必踩 3 key_process长按后仍继续发短按码 菜单"跳行后再执行",误操作 4 同上 cnt2不在按下时清零第二次按下可能立刻"假连发" 5 key_num单变量,无队列 两键同时按 → 覆盖;快速连按 → 丢事件 6 gpio.cGPIO_NOPULL依赖外部上拉;换板子会乱跳 7 key.c无双击、无"按下/抬起"事件 做不了拖拽类交互 8 app.ckey_num定义在 app 而非 key 模块模块边界混乱 9 全局 test_key()从未被调用按键完全没有被消费(见第 8 节) 6.7 一个更干净的按键模块(可直接替换)
如果要把这套东西做成"能长大"的样子,核心改三件事:
事件队列化、volatile 化、状态语义明确化。
/* key.h —— 事件式接口 */ #pragma once #include "gpio.h" #define KEY_COUNT 5 typedef enum { KEY_EVT_NONE = 0, KEY_EVT_PRESS, /* 按下(消抖后) */ KEY_EVT_RELEASE, /* 抬起 */ KEY_EVT_REPEAT, /* 按住连发 */ KEY_EVT_LONG /* 长按达成(只发一次) */ } key_evt_t; typedef struct { uint8_t id; /* 1..5 */ uint8_t short_code; /* = id */ uint8_t long_code; /* = id * 11 */ } key_cfg_t; void key_init(void); void key_scan(void); /* 仅在 2ms 定时中断里调用 */ uint8_t key_get_event(uint8_t *code, key_evt_t *evt); /* 主循环取事件,1=取到 *//* key.c —— 关键实现 */ #include "key.h" #include "tim.h" #define KEY_SCAN_MS 2 #define KEY_DEBOUNCE_MS 20 #define KEY_REPEAT_MS 1000 /* 按住多久开始连发 */ #define KEY_REPEAT_GAP_MS 60 /* 连发间隔 */ #define KEY_LONG_MS 2000 #define DB_CNT (KEY_DEBOUNCE_MS / KEY_SCAN_MS) /* 10 */ #define REP_START (KEY_REPEAT_MS / KEY_SCAN_MS) /* 500 */ #define REP_GAP (KEY_REPEAT_GAP_MS / KEY_SCAN_MS) /* 30 */ #define LONG_CNT (KEY_LONG_MS / KEY_SCAN_MS) /* 1000*/ #define KEY_QUEUE_LEN 8 static const key_cfg_t s_cfg[KEY_COUNT] = { {1, 1, 11}, {2, 2, 22}, {3, 3, 33}, {4, 4, 44}, {5, 5, 55} }; typedef struct { uint8_t pressed; /* 当前电平:1=按下 */ uint16_t hold; /* 按住 tick 数 */ uint16_t rep; /* 连发计时 */ uint8_t long_sent; /* 长按是否已上报 */ } key_state_t; static key_state_t s_st[KEY_COUNT]; /* 事件队列:ISR 写 head,主循环写 tail —— 单向,所以只要 volatile */ static volatile uint8_t s_q_code[KEY_QUEUE_LEN]; static volatile key_evt_t s_q_evt[KEY_QUEUE_LEN]; static volatile uint8_t s_head = 0, s_tail = 0; static void key_push(uint8_t code, key_evt_t evt) { uint8_t next = (uint8_t)((s_head + 1) % KEY_QUEUE_LEN); if (next == s_tail) return; /* 队列满:丢最旧语义,直接丢弃本次 */ s_q_code[s_head] = code; s_q_evt[s_head] = evt; s_head = next; } uint8_t key_get_event(uint8_t *code, key_evt_t *evt) { if (s_tail == s_head) return 0; *code = s_q_code[s_tail]; *evt = s_q_evt[s_tail]; s_tail = (uint8_t)((s_tail + 1) % KEY_QUEUE_LEN); return 1; } static void key_process(uint8_t idx, uint8_t is_down) { key_state_t *k = &s_st[idx]; const key_cfg_t *c = &s_cfg[idx]; if (!is_down) /* 抬起 */ { if (k->pressed) /* 从按下 → 抬起,才算一次抬起事件 */ { if (!k->long_sent) /* 没发过长按 → 这次是纯短按的结束 */ key_push(c->short_code, KEY_EVT_RELEASE); k->pressed = 0; k->hold = 0; k->rep = 0; k->long_sent = 0; } return; } /* 按下态 */ if (!k->pressed) /* 还没确认按下 */ { if (++k->hold >= DB_CNT) /* 连续 DB_CNT 次低电平 → 确认 */ { k->pressed = 1; k->hold = 0; k->rep = 0; key_push(c->short_code, KEY_EVT_PRESS); } return; } k->hold++; if (!k->long_sent && k->hold >= LONG_CNT) /* 长按:只上报一次,然后停连发 */ { k->long_sent = 1; key_push(c->long_code, KEY_EVT_LONG); return; /* ← 关键:不再走连发 */ } if (k->long_sent) return; /* 已经进长按态,彻底静默 */ if (k->hold >= REP_START) /* 连发区 */ { if (++k->rep >= REP_GAP) { k->rep = 0; key_push(c->short_code, KEY_EVT_REPEAT); } } } void key_scan(void) { key_process(0, HAL_GPIO_ReadPin(SYS_SW1_GPIO_Port, SYS_SW1_Pin) == GPIO_PIN_RESET); key_process(1, HAL_GPIO_ReadPin(SYS_SW2_GPIO_Port, SYS_SW2_Pin) == GPIO_PIN_RESET); key_process(2, HAL_GPIO_ReadPin(SYS_SW3_GPIO_Port, SYS_SW3_Pin) == GPIO_PIN_RESET); key_process(3, HAL_GPIO_ReadPin(SYS_SW4_GPIO_Port, SYS_SW4_Pin) == GPIO_PIN_RESET); key_process(4, HAL_GPIO_ReadPin(EC11_KEY_GPIO_Port, EC11_KEY_Pin) == GPIO_PIN_RESET); } void key_init(void) { HAL_TIM_Base_Start_IT(&htim2); }这个版本解决了原版的五个问题:
问题 原版 新版 丢事件 单变量 key_num被覆盖8 深度事件队列 长按仍连发 一直发短按码 long_sent置位后彻底静默无按下/抬起区分 只有"按下即短按" PRESS/RELEASE分开上报cnt2残留只在松手清 每次确认按下都清 hold/rep多键同时按 互相覆盖 各自独立 key_state_t注意队列设计的一个细节:
s_head只由中断写,s_tail只由主循环写,这是标准单生产者-单消费者模型,所以不需要关中断做临界区——前提是uint8_t的读写在 Cortex-M3 上是原子的(对单个字节确实是原子的,但s_tail = (s_tail + 1) % len是"读-改-写",主循环里只有一个执行流,所以也没问题)。
七、两个设备挤在一条 I²C2 上
这一节是本篇最"架构级"的发现,也是把所有模块串起来的地方。
7.1 现状:同一个
hi2c2,两套完全不同的用法
AHT20 OLED 外设 hi2c2hi2c2地址 0x70(0x38<<1) 0x78(0x3C<<1) 传输方式 DMA + 中断完成回调 轮询阻塞 超时 HAL_MAX_DELAYHAL_MAX_DELAY谁调用 状态机( aht20_start)驱动( oled_update_screen)同一个句柄
hi2c2的State字段是共享的。 HAL 的语义是:
HAL_I2C_STATE_READY→ 可以发起BUSY_TX/BUSY_RX→ 再调任何接口都立刻返回HAL_BUSY(不等待)7.2 现象推演:一次"撞车"能坏多少事
时序上看,一次
menu_data_display()是这样跑的:① 写标签/单位/数据到 RAM 缓冲 (纯内存,无 I2C) ② aht20_start() ← 可能在这里启动 DMA ③ mq2_read_data() (纯内存) ④ oled_update_screen() ← 连续占用总线约 100 ms如果 ② 恰好启动了 AHT20 的 DMA 发送(3 字节,约 0.3 ms),而 ④ 紧接着就要发第一条命令:
t=0 ② 启动 DMA TX (0x70, 3B) → hi2c2.State = BUSY_TX t=+5µs ④ oled_set_cursor → oled_write_command → HAL_I2C_Master_Transmit 检查 State == BUSY_TX → 立刻返回 HAL_BUSY → LOG_DEBUG("Failed to transmit I2C command") t=+300µs AHT20 DMA 完成 → State 回 READY t=+300µs~ 后续 OLED 命令恢复正常结果:
这一次刷新里,
0xB0/0x00/0x11三条定位命令丢了 → 屏会从"当前位置"开始写 128 字节 → 整页错位(看起来像画面横向撕裂了一下)。下一帧如果没撞车,又会自动恢复。
这种"偶尔花一下、下一帧又好"的现象,是最难查的一类 bug——很多人会怀疑电源、怀疑接触不良,其实是软件抢总线。
7.3 更严重的一条:状态机的"静默死锁"
aht20.c里这两段:void aht20_send_measure(void) { if (HAL_I2C_Master_Transmit_DMA(&AHT20_I2C, AHT20_ADDRESS, measure_cmd, 3) != HAL_OK) return; // ← 失败只 return,什么都不告诉调用者 } void aht20_start(void) { if (aht20_status == READ_DATA_INIT) { aht20_send_measure(); aht20_status = SEND_MEASURE_COMMAND_ING; // ← 无论成功失败,状态都推进! }问题在于:状态推进和"启动成功"没有绑定。
状态的唯一出口是 I²C 完成中断:
void HAL_I2C_MasterTxCpltCallback(I2C_HandleTypeDef *hi2c) { if (hi2c == &AHT20_I2C) aht20_status = SEND_MEASURE_COMMAND_FINISH; // 只有它能把状态往前推 }于是有至少三条"永久卡死"的路径:
触发条件 发生什么 现象
HAL_BUSY(总线被 OLED 占着)
DMA 没启动,回调不会来 状态停在 SEND_MEASURE_COMMAND_ING,永远传感器没接/线松 → 从机不 ACK DMA 启动了,但出错走
HAL_I2C_ErrorCallback(本项目未实现这个回调)
同上,卡死 总线上出现错误(BERR/ARLO) 同上 同上 卡死之后的表现:
aht20_start()每帧都被调用,但每个分支都不匹配 → 什么也不做 → 温湿度数值冻结在一个旧值上,屏幕上看起来"在正常工作",日志里一条警告都没有。而且因为
SEND_MEASURE_COMMAND_ING这一状态不再碰总线,OLED 独占 I²C,屏刷得好好的——这使得故障现象极具欺骗性。这解释了一个非常典型的现场问题:
"屏幕在刷新,风扇状态在变,就温度和湿度一直是 23.5/45.0 不动"。
根因不是传感器坏了,是状态机缺超时兜底。
修法(半小时能做完):
/* 1) 记录每个状态的进入时刻,超过时限强制回退 */ static uint32_t state_tick; static void aht20_set_state(aht20_status_t s) { aht20_status = s; /* 记得加 volatile */ state_tick = HAL_GetTick(); } void aht20_start(void) { /* 兜底:任何状态停留超过 200ms 都回 INIT 重来 */ if (aht20_status != READ_DATA_INIT && (HAL_GetTick() - state_tick) > 200) { LOG_DEBUG("AHT20 timeout in state %d, reset", (int)aht20_status); aht20_set_state(READ_DATA_INIT); return; } ... } /* 2) 启动失败就不要推进状态 */ if (aht20_status == READ_DATA_INIT) { if (aht20_send_measure() == HAL_OK) /* 让 send_measure 返回状态 */ aht20_set_state(SEND_MEASURE_COMMAND_ING); return; } /* 3) 实现错误回调,把状态拉回 INIT */ void HAL_I2C_ErrorCallback(I2C_HandleTypeDef *hi2c) { if (hi2c == &AHT20_I2C) aht20_set_state(READ_DATA_INIT); }7.4 三条出路,按代价排序
方案 做法 代价 适用 A. 总线互斥 加 static volatile uint8_t i2c_busy,谁用谁置位,用完释放;拿不到就下一帧再试最小,~20 行 现在就该做的 B. 统一成 DMA OLED 也改成 HAL_I2C_Master_Transmit_DMA,用回调串起 8 页中等,要写"页状态机" 想要不阻塞主循环时 C. 彻底分离 OLED 换 SPI 版模组(课件右边那块 7 Pin 的),AHT20 独占 I²C2 硬件成本 想要高刷 + 零冲突 方案 A 的最小实现:
/* i2c_bus.h */ uint8_t i2c_bus_acquire(void); /* 1 = 拿到,0 = 忙 */ void i2c_bus_release(void);/* i2c_bus.c */ static volatile uint8_t s_busy = 0; uint8_t i2c_bus_acquire(void) { if (s_busy) return 0; s_busy = 1; return 1; } void i2c_bus_release(void) { s_busy = 0; }然后在 OLED 那一层:
void oled_update_screen(void) { if (!i2c_bus_acquire()) return; /* 拿不到总线,这一帧直接放弃,下帧再来 */ for (uint8_t page = 0; page < 8; page++) { oled_set_cursor(page, 0); oled_write_data(oled_data_buffer[page], 128); } i2c_bus_release(); }"这一帧直接放弃"是关键设计:
UI 掉一帧用户根本看不出来(下一帧 100 ms 后就来),但绝不阻塞采集。
这条原则叫"显示是最低优先级"。
八、现在的系统跑起来是什么样
8.1 主循环的时序推演
app.c:void app_start(void) { while (1) { app_handle_light_led(); // 每 500ms 翻转 LED_CTRL test_menu(); // → menu_data_display() } }
menu_data_display()里既有aht20_start(),又有oled_update_screen()。把每一帧的成本加起来:
动作 耗时 依据 写 4 个标签 + 4 个单位 + 3 个数据
(纯内存)
忽略 µs 级 aht20_start()一次状态推进状态机等 75 ms 后才会真正读 见下 mq2_read_data()忽略 读 DR + 浮点运算,µs 级 oled_update_screen()≈ 100 ms 1024 B @ 100 kHz AHT20 的 DATA_PARSE_FINISH分支HAL_Delay(1000)每 5 帧左右撞一次 AHT20 状态机在主循环里的实际推进节奏(因为每帧都调一次
aht20_start(),而一帧 100 ms):
帧 状态 动作 第 1 帧 READ_DATA_INIT发测量命令(DMA)→ SEND_..._ING第 2 帧 SEND_..._ING无分支 → 什么都不做(等 TX 完成中断,早已完成) 第 3 帧 SEND_MEASURE_COMMAND_FINISH检查 >= 75 ms,早已满足 →WAIT_MEASURE_FINISH第 4 帧 WAIT_MEASURE_FINISH启动 RX DMA → READ_DATA_ING第 5 帧 READ_DATA_FINISH解析 → DATA_PARSE_FINISH第 6 帧 DATA_PARSE_FINISH打日志 → READ_DATA_INIT→HAL_Delay(1000)所以整个系统的实际刷新率 ≈ 6 帧 / (6×100 ms + 1000 ms) ≈ 1 帧 / 1.17 s。
这就是"屏幕上的数字半分钟才变一次"的真相:
不是传感器慢(AHT20 一次测量只要 75 ms),不是 OLED 慢(一帧 100 ms),而是"非阻塞状态机被塞进了 1 秒阻塞延时"。
第(一)篇已经点过
DATA_PARSE_FINISH里的HAL_Delay(1000),在第(二)篇里它的后果变得非常直观:一个"非阻塞"的状态机,最后一步是阻塞 1 秒,前面所有的设计都白费了。修法:把
HAL_Delay(1000)换成"时间戳 + 允许重入":else if (aht20_status == DATA_PARSE_FINISH) { static uint32_t last_report = 0; if (HAL_GetTick() - last_report >= 1000) /* 每 1 秒最多汇报一次 */ { last_report = HAL_GetTick(); LOG_DEBUG("Temperature: %.2fC, Humidity: %.2f%%", aht20_data.temperature, aht20_data.humidity); aht20_set_state(READ_DATA_INIT); } /* 没到 1 秒就原地等待,但主循环还在跑 —— 这才是"非阻塞" */ }注意这里有个细节:
aht20_status停在DATA_PARSE_FINISH期间,menu_data_display依然会读aht20_data去显示(数据已经是新的),所以屏上数据是新鲜的,只是下一轮测量被拖慢了 1 秒。这也解释了为什么"数值对但变得慢"。8.2 ADC 中断风暴对 UI 的二次打击
mq2_init()里:HAL_ADCEx_Calibration_Start(&MQ2_ADC); HAL_ADC_Start_IT(&MQ2_ADC);配合
.ioc里的ContinuousConvMode = ENABLE+SamplingTime = 1.5 cycles,ADC 进入了**"转换完立刻开始下一次转换"**的自由运行模式。算一下 EOC 中断的频率:
参数 值 ADCCLK 12 MHz(PCLK2 72 MHz / 6) 单次转换 1.5(采样)+ 12.5(转换)= 14 个 ADC 周期 单次时间 14 / 12 MHz ≈ 1.17 µs EOC 中断频率 ≈ 857 kHz 每秒 85 万次中断。
每次中断(入栈 +
HAL_ADC_IRQHandler+ 回调 + 出栈)大约 50~60 个 CPU 周期,按 72 MHz 算 ≈ 0.75 µs,而转换周期只有 1.17 µs —— CPU 有 60% 以上的时间花在 ADC 中断里。后果:
- 主循环被严重挤压。本来一帧 100 ms 的 OLED 刷新(轮询 I²C,每发一个字节都要在
HAL_I2C_Master_Transmit的 while 里等),被 85 万次/秒的中断反复打断,实际耗时会拉长到 1.5~2 倍。- SysTick 饿死。
TICK_INT_PRIORITY = 15(最低),在 ADC 中断霸占 CPU 的情况下,优先级 15 的 SysTick 几乎排不上队 →HAL_GetTick()不走 →HAL_Delay()卡住、HAL_TIMEOUT全部失效。这是第(一)篇点过的老问题,在第(二)篇里它的表现是"界面偶尔整个僵住好几秒"。- TIM2 仍然能跑(和 ADC 同为优先级 0,每个 ADC ISR 都很短,所以 TIM2 会被及时挂起响应),所以按键是"活"的,界面是"死"的——这个组合会让调试者更加困惑。
修法(三选一):
方案 做法 效果 关连续转换 ContinuousConvMode = DISABLE+ 定时器触发(TIM3 TRGO 1 Hz)中断从 857 kHz 降到 1 Hz 降采样时间 1.5 → 71.5 cycles 只解决采样精度,中断频率仅降 5 倍 改 DMA + 定时读 HAL_ADC_Start_DMA,DMA 循环写 buffer,主循环读中断几乎消失 推荐第一种:一次性转换由软件/定时器触发,
mq2_flag才有"新数据"的真实含义。8.3 完成度自评(第 8~17 讲)
讲 内容 状态 证据 8 OLED 认识与驱动 完成 oled.c全量实现 + 帧缓冲9 PCtoLCD2002 取模 完成 font.h95×16B 字库10 UI 界面(4 页排版) 完成(有 10 处瑕疵 menu.c四个函数齐全11 界面切换 未做 app_start写死menu_data_display12 阈值保存(Flash) 未做 g_td只有 RAM 初值,无写 Flash13 TB6612 电机 未做 fan_is_running只被读不被写;fan行单位写着rpm14 联网(ESP8266) 未做 menu_wifi_*只有界面,num无人驱动15 机智云接入 未做 — 16 语音控制 未做 — 17 SU-03T 接入 未做 —
DAMO开发者矩阵,由阿里巴巴达摩院和中国互联网协会联合发起,致力于探讨最前沿的技术趋势与应用成果,搭建高质量的交流与分享平台,推动技术创新与产业应用链接,围绕“人工智能与新型计算”构建开放共享的开发者生态。
更多推荐
















所有评论(0)