从点亮一个像素到跑起一套菜单: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:背光发光 + 液晶控光
┌─────────────┐            ┌─────────────┐
│ ● ● ○ ● ● ○ │  ← 像素自亮 │ ██ 背光层 ██ │  ← 常亮
│ ○ ● ● ○ ● ● │            │ ▓▓ 液晶层 ▓▓ │  ← 当"百叶窗"
└─────────────┘            └─────────────┘
维度OLEDLCD
发光主体有机薄膜自身发光背光灯发光,液晶只负责"挡光"
黑色表现不发光 = 真黑,对比度高背光漏光,黑不下去
结构厚度薄,无需背光模组需要背光层,较厚
视角大依赖面板工艺

一句人话版本:

        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)省引脚、布线简单、速率够
驱动 ICSSD1306资料最多
分辨率128 × 648192 像素
模块尺寸27.5 mm × 27.8 mm—
工作电压3.3 ~ 5 V逻辑电平与 MCU 兼容
从机地址0x3CD/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 条)

逐条对上:

#指令参数作用本项目的值
10xAE—关显示(命令期间不动面板)先关
20xD50x80时钟分频 / 振荡器频率分频 1、fosc 最大
30xA80x3F复用率(MUX)1/64 占空比
40xD30x00垂直显示偏移不偏移
50x40—显示起始行 = RAM 第 0 行起始行 0
60xA1—左右方向:段重映射正常(列 127→SEG0)
70xC8—上下方向:COM 扫描反向正常
80xDA0x12COM 引脚硬件配置交替 + 禁用左/右重映射
90x810x7F对比度127(0xCF 更亮,被注释掉了)
100xD90xF1预充电周期Phase1=1, Phase2=15
110xDB0x30VCOMH 取消选择电压~0.83×Vcc
120xA4—恢复"按 RAM 内容显示"必须,否则可能全亮
130xA6—正常显示(非反相)正常
140x8D0x14电荷泵使能(3.3 V 供电必需)
150xAF—开显示最后开

几个值得展开讲的点:

(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 只有 Page07,掩码应该是 & 0x07。

        用 0x0F 意味着"允许传 815",一旦上层传错(比如把 y=72 当页号算成 9),SSD1306 会收到一个非法页地址,行为未定义。

        这种"参数校验缺失"在本篇会反复出现,先记一笔。

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 占用01024 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);
}

三件事值得说:

  1. buffer[size + 1] 是 C99 的 VLA,长度在运行时才定,分配在栈上。全屏刷一页时 size=128 → 占 129 字节栈。ARM 默认栈 1 KB(startup 文件里 Stack_Size EQU 0x00000400),一次刷新就吃掉 12.5% 的栈;如果哪天有人在中断里调用它,栈很容易爆。
  2. memcpy 是纯粹的浪费:128 字节拷贝在 72 MHz 上大约 1~2 µs,单看不多,但它换来的只是"把控制字节和数据拼成一段"。完全可以避免:
    // 方案 A:先发控制字节,再发数据(两次事务,省掉拷贝,但多一次 START)
    // 方案 B:静态缓冲 + 指针偏移(推荐)
    static uint8_t page_buf[1 + 128];
    page_buf[0] = 0x40;
    memcpy(&page_buf[1], src, 128);   // 还是一样……
    // 方案 C:让 buffer 的第一字节常驻,数据直接写进去(真正零拷贝)
    
    最干净的其实是方案 C:把 oled_data_buffer 定义成 uint8_t [8][129],第 0 字节放 0x40,绘制时全部偏移 1 字节,刷新时整页甩出去——一次 memcpy 都不需要。
  3. 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 = 0xEF
buffer[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:

liney涉及 Page
000, 1
1162, 3
2324, 5
3486, 7

~buffer 是逐位取反:

        原来 0 的位变 1(亮),原来 1 的位变 0(灭)。

        视觉上就是"白底黑字",即反色高亮。

顺便对比一个容易混的点:

        SSD1306 有 0xA6/0xA7 两条"全局反相"命令,那是整屏反色;

        这里的 ~ 是在 RAM 里翻某两页,属于"局部反色"。

        用 0xA7 做菜单高亮的后果是整屏变黑底白字,选中的那一行反而不突出了。

         这个区别面试里问得很勤。

3.8 驱动层的隐患汇总

#位置问题后果
1oled_show_charch - ' ' 无范围检查控制字符/中文 → 越界读 4 KB
2oled_show_image忽略 y % 8y 非 8 对齐时图形跳页错位
3oled_show_image覆盖写而非或写两图无法叠加,必须手动清区
4oled_write_command/dataHAL_MAX_DELAY总线卡死 → 永久阻塞
5同上失败只打日志不返回上层无感知,静默丢帧
6oled_write_dataVLA + memcpy129 B 栈占用 + 每帧 8 次无谓拷贝
7oled_set_cursor页掩码 & 0x0F允许非法页地址 8~15
8OLED_8X16一名三义加字体时判断失效
9oled_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)。

        这不是错,是字体渲染差异:不同字体、不同取模软件的栅格化结果本来就不同,课件自己也写了"字模数据上可能会存在些许差异,这个并无影响"。

只要满足两条,任何一套字模都能用:

  1. 同一套字库内部约定一致(都列行式、都逆向)
  2. 索引关系一致(从 ' ' 开始、顺序连续)

        这也是为什么 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 的位图"的特例。所以做图标不需要新代码:

  1. 在 PCtoLCD2002 里切到图形模式,导入 16×16 的 BMP
  2. 取模参数保持"阴码 + 列行式 + 逆向"
  3. 得到 32 字节(16×16 = 2 页 × 16 列)
  4. 直接 oled_show_image(48, 16, 16, 16, icon_bmp)

唯一要守的规矩还是那条:y 必须 8 对齐。


五、UI:在 16 × 4 的格子里排版

5.1 硬约束先摆出来

参数计算结果
横向字符数128 / 816
纵向行数64 / 164
单行像素高162 页
第 N 行 y 坐标(N-1) * 160 / 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=80
void 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? 这串数字是"字符格"的加减法:

段起始格长度结束格
标签050~4
留 1 格空隙—15
数据— → 实际从第 5 格(x=40)45~8
留 1 格空隙—19
单位10(x=80)1~310~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~40/16/32/48正常
0(0-1) 在 uint8_t 里 → 255 → y=4080oled_show_string 的 show_image 里 y > 63 直接 return;invert_line16(255) 也直接 return → 静默什么都不画
564show_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 module1488 + 112 = 120✓
2.SoftAP mode138112✓
3.Airlink mode148120✓

        全都卡在 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 个字符的"预算表"列出来:

下标01~101112131415
内容[= × 10]十位个位%`

设计意图很清楚:16 个字符刚好铺满 128 像素,一个不多一个不少。

但 bar[i] = '=' 从下标 0 开始写,于是:

progressblock_num被覆盖的下标现象
00无`[ ] 0%
1010= 把 [ 顶掉了 → `= ]10%
5050~4`===== ]50%
9090~8`=========]90%
100100~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。

推导链条必须从时钟树出发:

步骤依据结果
SYSCLKHSE 8 MHz × PLL972 MHz
HCLKAHB /172 MHz
PCLK1APB1 /236 MHz
TIM2 时钟APB1 分频 ≠1 时,定时器时钟 = PCLK1 × 272 MHz
计数频率72 MHz / (71 + 1)1 MHz → 1 tick = 1 µs
更新周期(1999 + 1) tick2000 µs = 2 ms
中断频率1 / 2 ms500 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 模式按下电平
KEY1PG10(SYS_SW1)输入,GPIO_NOPULL低
KEY2PG6(SYS_SW2)输入,GPIO_NOPULL低
KEY3PG8(SYS_SW3)输入,GPIO_NOPULL低
KEY4PG7(SYS_SW4)输入,GPIO_NOPULL低
KEY5PC5(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 tick1000 ms连发开始前要按住的时间
KEY_LONG_TIME = 10001000 tick(从确认按下算起)2000 ms长按判定
KEY_CONTINUE_TRIGGER_TIME = 2526 tick52 ms连发间隔(约 19 次/秒)

时序推演(按住 KEY1 不放):

时刻状态动作
t = 0按下(读低)cnt 从 0 开始每 2 ms +1
t = 22 mscnt = 11 > 10lock_flag=1、cnt=0、key_num = 1(短按码立即上报)
t = 22 ~ 1022 mscnt: 0 → 500只计数,不做事("静默期")
t ≈ 1022 mscnt 到 500进入 else 分支,开始 cnt2 计数
t ≈ 1074 mscnt2 > 25key_num = 1(第一次连发)
每 +52 mscnt2 归零重来key_num 再次 = 1(连发)
t ≈ 2024 mscnt > 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 按键层的问题汇总

#位置问题后果
1app.ckey_num 未加 volatile-O3 下可能被缓存,丢按键
2key.c 注释字段语义写反后续维护必踩
3key_process长按后仍继续发短按码菜单"跳行后再执行",误操作
4同上cnt2 不在按下时清零第二次按下可能立刻"假连发"
5key_num单变量,无队列两键同时按 → 覆盖;快速连按 → 丢事件
6gpio.cGPIO_NOPULL依赖外部上拉;换板子会乱跳
7key.c无双击、无"按下/抬起"事件做不了拖拽类交互
8app.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,两套完全不同的用法

AHT20OLED
外设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. 统一成 DMAOLED 也改成 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 ms1024 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 中断的频率:

参数值
ADCCLK12 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 中断里。

后果:

  1. 主循环被严重挤压。本来一帧 100 ms 的 OLED 刷新(轮询 I²C,每发一个字节都要在 HAL_I2C_Master_Transmit 的 while 里等),被 85 万次/秒的中断反复打断,实际耗时会拉长到 1.5~2 倍。
  2. SysTick 饿死。TICK_INT_PRIORITY = 15(最低),在 ADC 中断霸占 CPU 的情况下,优先级 15 的 SysTick 几乎排不上队 → HAL_GetTick() 不走 → HAL_Delay() 卡住、HAL_TIMEOUT 全部失效。这是第(一)篇点过的老问题,在第(二)篇里它的表现是"界面偶尔整个僵住好几秒"。
  3. 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 讲)

讲内容状态证据
8OLED 认识与驱动完成oled.c 全量实现 + 帧缓冲
9PCtoLCD2002 取模完成font.h 95×16B 字库
10UI 界面(4 页排版)完成(有 10 处瑕疵menu.c 四个函数齐全
11界面切换未做app_start 写死 menu_data_display
12阈值保存(Flash)未做g_td 只有 RAM 初值,无写 Flash
13TB6612 电机未做fan_is_running 只被读不被写;fan 行单位写着 rpm
14联网(ESP8266)未做menu_wifi_* 只有界面,num 无人驱动
15机智云接入未做—
16语音控制未做—
17SU-03T 接入未做—

Logo

DAMO开发者矩阵,由阿里巴巴达摩院和中国互联网协会联合发起,致力于探讨最前沿的技术趋势与应用成果,搭建高质量的交流与分享平台,推动技术创新与产业应用链接,围绕“人工智能与新型计算”构建开放共享的开发者生态。

更多推荐