核心结论

I2C 学习可以归纳为三层：

电气层：SCL、SDA、开漏输出、上拉电阻
协议层：START、设备地址、数据、ACK、STOP
器件层：寄存器地址、寄存器数据、芯片手册定义

最重要的一句话：

I2C 只负责传输字节；设备地址决定访问哪个芯片，寄存器地址决定访问芯片内部哪个位置，芯片手册决定读回来的字节代表什么。

一、I2C 的硬件结构

I2C 使用两根线：

本次实验连接：

STM32、OLED 和 MPU6050 必须共地。否则即使模块电源灯亮，也不代表通信线路真正连通。

二、为什么需要开漏输出和上拉电阻

I2C 的 SCL、SDA 都是开漏结构：

• 设备可以主动拉低总线
• 设备不能主动输出高电平
• 设备释放总线后，由上拉电阻把线拉高

结构可以表示为：

3.3V
  │
上拉电阻
  │
SCL 或 SDA ───── 多个设备的开漏引脚共同连接

这样允许多个设备共享总线。任何一个设备拉低，总线就为低；所有设备都释放，总线才为高。

当前软件 I2C 将 PB6、PB7 配置为开漏输出，通过 GPIO 控制电平。

三、SCL 和 SDA 的时序规则

最核心的规则：

SDA 只能在 SCL 低电平期间改变，在 SCL 高电平期间必须保持稳定。

主机在 SCL 高电平期间读取 SDA：

SCL       __/‾‾\__/‾‾\__/‾‾\__
             ↑     ↑     ↑
采样        读取   读取   读取

SDA       ‾‾‾‾‾‾‾‾‾\________
          稳定保持    在 SCL 低电平期间变化

每条 I2C 消息都由 START 开始、STOP 结束：

普通数据位不能在高电平期间随意变化，否则可能被误认为 START 或 STOP。

四、设备地址与读写方向

I2C 芯片通常使用 7 位地址。实际发送 8 位：前 7 位选择设备，最低位表示方向。

bit7～bit1：7 位设备地址
bit0：0 = 写，1 = 读

MPU6050 的 7 位地址是 0x68：

0x68 = 1101000

写地址：1101000 0 = 0xD0
读地址：1101000 1 = 0xD1

这里需要准确理解：

• 0xD0 不是单独的“写命令”
• 0xD0 表示“访问 0x68 这个设备，本次方向为写”
• 0xD1 表示“访问 0x68 这个设备，本次方向为读”

OLED 的 7 位地址是 0x3C：

0x3C << 1 = 0x78

所以串口打印的 0x78 与扫描得到的 0x3C 是同一个 OLED 地址，只是一个使用 8 位写法，一个使用 7 位写法。

五、I2C 怎样传输一个字节

每个数据字节包含 8 位，采用高位先发：

bit7 → bit6 → bit5 → bit4 → bit3 → bit2 → bit1 → bit0

发送完 8 位后，还有第 9 个时钟，用于 ACK：

读取多个字节时：

• 非最后一个数据字节：主机发送 ACK，表示继续读
• 最后一个数据字节：主机发送 NACK，表示不再继续

因此“读取一个字节”实际上也需要 9 个时钟：8 个数据时钟加 1 个 ACK 时钟。

0x6B = 0110 1011 只是教学示例。I2C 协议只规定如何传输字节，不规定固定字节内容。

六、写寄存器的完整流程

以 MPU6050 将 PWR_MGMT_1 写成 0x01 为例：

START
  → 0xD0 + ACK       设备地址，方向为写
  → 0x6B + ACK       选择 PWR_MGMT_1 寄存器
  → 0x01 + ACK       写入新值
STOP

对应关系：

普通配置寄存器写入新值后，会覆盖原来的值：

原值：PWR_MGMT_1 = 0x40
写入：PWR_MGMT_1 ← 0x01
结果：PWR_MGMT_1 = 0x01

芯片随后根据新值改变工作方式。特殊命令寄存器也可能采用“写 1 触发动作”等规则，必须查看具体芯片手册。

七、读寄存器的完整流程

读取 MPU6050 的 WHO_AM_I：

START
  → 0xD0 + ACK       设备地址，方向为写
  → 0x75 + ACK       选择 WHO_AM_I 寄存器
  → 重复 START
  → 0xD1 + ACK       设备地址，方向改为读
  → 芯片返回一个字节
  → 主机 NACK
STOP

这里最容易混淆的是：“读取为什么一开始用了写地址？”

原因是读取分为两个阶段：

第一阶段：先选中芯片，并设置内部寄存器指针
第二阶段：重新以读方向访问同一芯片，读取指针所指寄存器的内容

第一阶段并不写入新的配置值，只发送寄存器地址。但从总线层面看，寄存器地址本身也是一个数据字节，因此此时 SDA 上当然有数据。

可以对比为：

写配置：设备写地址 + 寄存器地址 + 新值
读数据：设备写地址 + 寄存器地址 + 重复START + 设备读地址 + 返回数据

不能把“读操作”理解成只发送 0xD1。必须先告诉芯片从哪个寄存器开始读取。

八、为什么使用重复 START

读取过程中：

D0 → 寄存器地址 → 重复START → D1

重复 START 的作用是：

• 不发送 STOP
• 不释放总线
• 直接改变设备访问方向
• 保持之前设置的寄存器指针

如果中间先发送 STOP，部分器件可能退出当前访问状态，后续读地址就不一定从刚才指定的寄存器开始。

九、寄存器地址、寄存器和数据的关系

可以把芯片内部想成一排小存储盒：

重要区别：

• 寄存器地址：选择操作哪个存储位置
• 寄存器值：该位置里面保存的数据
• 写入普通配置寄存器时，新值会覆盖旧值

十、MPU6050 初始化实验

程序先读取 WHO_AM_I：

寄存器地址：0x75
返回内容：0x68

确认芯片身份后，写入五个配置寄存器：

这说明“写数据控制芯片”的本质：

向控制寄存器写入不同值，芯片会改变采样率、量程、滤波、电源状态等行为。

十一、MPU6050 连续读取 14 字节

程序设置起始寄存器 0x3B，连续读取 14 字节。MPU6050 读取一个寄存器后，内部地址会自动递增。

数据顺序固定为：

MPU6050 使用大端格式，高字节在前：

高字节：0x45
低字节：0x16
合并：0x45 << 8 | 0x16 = 0x4516

不能把 0x45 和 0x16 直接相加。

传感器数据是有符号 16 位数。例如：

0xF2B0 → -3408

物理量换算公式：

例如：

0x4516 = 17686
17686 ÷ 16384 ≈ 1.079g

当前实际读取帧示例：

[RAW] 45 16 F2 B0 F3 90 F4 10 FF 00 00 5B 00 7C

拆分后：

AX   = 45 16
AY   = F2 B0
AZ   = F3 90
TEMP = F4 10
GX   = FF 00
GY   = 00 5B
GZ   = 00 7C

十二、SSD1306 OLED 的控制方式

OLED 同样使用“设备地址加后续字节”的结构，但 SSD1306 的第二个字节是控制字节，而不是普通寄存器地址。

发送命令：

START + 0x78 + 0x00 + 命令字节 + STOP

发送像素数据：

START + 0x78 + 0x40 + 显存数据 + STOP

因此，不同器件虽然都使用 I2C，设备地址后面的内容需要按各自手册解释。

SSD1306 中：

• 命令控制屏幕参数和显示模式
• 显存数据决定哪些像素点亮
• 程序先修改本地显存缓冲区，再整屏发送给 OLED

十三、本次实验完成的内容

实验工程：i2c_oled

完成内容：

1. 使用 GPIO 实现软件 I2C。
2. 扫描总线并识别 OLED 和 MPU6050。
3. 读取 MPU6050 的 WHO_AM_I。
4. 写入配置寄存器并启动 MPU6050。
5. 连续读取 14 字节传感器原始数据。
6. 将数据换算成加速度、温度和角速度。
7. 通过串口输出原始帧和物理量。
8. 在 OLED 中显示 MPU6050 温度。
9. 温度页固定显示，每秒更新一次。
10. 验证 OLED 与 MPU6050 可以同时挂在一条 I2C 总线上。

上电后的关键串口输出：

ACK: 0x3C
ACK: 0x68
WHO_AM_I=0x68
TEMP 27.7 C
[RAW] 45 16 F2 B0 F3 90 F4 10 FF 00 00 5B 00 7C

该结果说明：

• 地址扫描成功
• 两个设备都能回应 ACK
• MPU6050 身份识别正确
• 寄存器读写成功
• 14 字节数据读取成功
• OLED 与传感器并联通信正常

十四、本次实验遇到的问题

并联 OLED 和 MPU6050 后，曾经只扫描到 OLED，MPU6050 没有 ACK。检查软件时序、降低速度和尝试交换逻辑引脚都没有解决，最终重新连接模块线路后恢复。

这个故障提供了几个重要经验：

1. 模块电源灯亮不代表 SCL/SDA 已经真正接通。
2. 扫描不到地址时，应优先检查接线、共地、供电和上拉。
3. 0x68 没有 ACK，不一定是程序错误。
4. 总线通信失败应先验证最基础的地址 ACK，再分析寄存器内容。
5. 两设备并联后，要保证每个模块的 SCL 都接总线 SCL，SDA 都接总线 SDA。

十五、软件 I2C 与硬件 I2C

当前实验采用软件 I2C，速度设置为保守低速，优先保证时序容易观察和模块兼容。

软件 I2C 的核心实现包括：

• START：SCL 高时拉低 SDA
• 发送字节：每次先准备 SDA，再产生 SCL 高电平
• 第 9 拍释放 SDA，读取 ACK
• 接收字节：主机释放 SDA，从机驱动 8 位数据
• 最后一字节发送 NACK
• 读寄存器使用重复 START
• STOP：SCL 高时释放 SDA

代码中还包含总线恢复逻辑：如果初始化时发现 SDA 被某个从机持续拉低，则最多发送 9 个 SCL 脉冲，再发送 STOP，让设备释放总线。

十六、I2C、SPI 与场景选择

简单选择原则：

• 设备多、速度要求一般、希望节省引脚：优先考虑 I2C
• 数据量大、刷新速度快：优先考虑 SPI
• 协议学习和时序诊断：软件 I2C 很直观
• 正式产品中追求稳定和降低 CPU 占用：通常使用硬件 I2C

十七、学习新 I2C 芯片的检查表

拿到新器件后依次确认：

1. 7 位设备地址是多少？
2. 地址引脚是否会改变设备地址？
3. SCL/SDA 应接在哪里，是否需要上拉？
4. 控制寄存器有哪些？
5. 每个控制值代表什么功能？
6. 数据寄存器从哪个地址开始？
7. 一次需要读取几个字节？
8. 连续读取时地址是否自动递增？
9. 数据是高字节在前还是低字节在前？
10. 是否是有符号数，需要什么换算公式？
11. 写操作后能否回读同一寄存器确认配置？

十八、最终必须记牢的四个模型

1. 一个设备地址

7 位设备地址 + 读写方向位

2. 一次写操作

设备写地址 → 寄存器地址 → 新值

3. 一次读操作

设备写地址 → 寄存器地址 → 重复START → 设备读地址 → 返回数据

读操作前半段不是写入配置值，而是设置内部寄存器指针。

4. 数据含义

寄存器地址 + 芯片手册 + 配置量程 → 字节含义和物理量

复习时只需回答这五个问题

1. SDA 为什么只能在 SCL 低电平期间变化？
2. 为什么 I2C 总线需要上拉电阻？
3. 0xD0 和 0xD1 分别表示什么？
4. 读取寄存器时为什么先发写地址，再发读地址？
5. 读回一组字节后，怎样判断每个字节代表什么数据？

如果这五个问题都能用自己的话回答，就说明 I2C 的协议、寄存器模型和实验流程已经形成完整理解。

写在前面

MCP6071 是 Microchip（微芯科技）推出的单通道 CMOS 运算放大器，主打低功耗 + 高精度：

• 供电范围 1.8V ~ 6.0V（单节锂电池即可工作）
• 静态电流仅 110µA（典型值）
• 输入失调电压 ±150µV（最大值）
• 输入偏置电流低至 1pA（CMOS 输入，几乎不取电流）
• 轨到轨输入输出（Rail-to-Rail I/O，动态范围吃满）
• 增益带宽积 1.2MHz，单位增益稳定

同一颗芯片，接法不同就是完全不同的电路。本文按四种用法逐一拆解，每种都遵循"看图 → 推导 → 什么时候用"的思路。

一、开环使用：比较器

运放的开环增益极大（MCP6071 约 115dB，即 50 万倍）：

VOUT = A × (V⁺ − V⁻)

输入端哪怕只差 1µV，输出就会被放大 0.5V——任何微小差值都会让输出撞到电源轨（饱和）。所以开环使用时输出只有两种状态：

• V⁺ > V⁻ → 输出顶到 VDD（高电平）
• V⁺ < V⁻ → 输出压到 VSS（低电平）

这正是比较器（Comparator）的行为。典型应用是过零检测：正弦波接 V⁺、地接 V⁻，输入每次过零输出就翻转，正弦波被"整形"成方波。

⚠️ 注意：运放开环当比较器属于"勉强能用"——响应慢、无迟滞易抖动。正经的比较器应用请选专用芯片（如 LM393）。

二、电压跟随器

把输出直接连回反相输入端（−），就得到最简单的负反馈电路。100% 的负反馈让 V⁻ 始终等于 V⁺，而 V⁻ 就是 VOUT，所以：

VOUT = VIN（增益精确等于 1）

它不放大电压，价值在于阻抗变换：

• 输入阻抗极高（偏置电流仅 1pA，几乎不取电流）
• 输出阻抗极低（带负载后电压不跌）

任何信号源都有内阻，直连负载会被分压衰减。中间加一级跟随器，源内阻被输入端的"无穷大阻抗"架空，负载面对的则是"零内阻理想源"——信号无损传递。

典型场景：高阻传感器（光电二极管、pH 电极、高阻分压网络）接 ADC 采样前的缓冲。

三、同相放大器

在跟随器基础上，把反馈路径改成 Rf / R1 两个电阻分压，就能精确控制增益。信号从同相端（+）进入，R1 从 V⁻ 节点接地，Rf 从输出反馈到 V⁻ 节点。

用两条黄金法则推导——虚短（V⁻ = V⁺ = VIN）+ 虚断（输入端不取电流，流过 R1 和 Rf 的电流相等），三行解出：

VOUT = VIN × (1 + Rf / R1)

例：Rf = 9kΩ、R1 = 1kΩ → 增益 10 倍。

• 增益只取决于电阻比例，与运放自身参数无关 → 1% 电阻即 1% 精度
• 输入阻抗极高 → 不打扰信号源
• 增益 ≥ 1（只能放大，不能衰减）

典型场景：热电偶、传感器桥等弱电压信号的精密放大。

四、反相放大器

信号换了个门：从反相端（−）经 R1 进入，+ 端直接接地。这一换，电路性格全变。

+ 端接地（0V）+ 虚短 → V⁻ ≈ 0V 但没真接地，这个节点叫虚地——电压钉死在 0V，专门"吸收"电流。虚断保证电流进不了运放，所以信号电流的路径是唯一的：

VIN → R1 → 虚地点 → Rf → VOUT

R1 两端压差就是 VIN（虚地是 0V），电流 = VIN / R1；这股电流流过 Rf 产生压降，输出 = 0 − I × Rf：

VOUT = −VIN × (Rf / R1)

例：Rf = 100kΩ、R1 = 10kΩ → 增益 −10。负号代表输出与输入相位差 180°（输入涨输出跌，波形上下镜像）。

• 增益可任意（含 < 1 的衰减）
• 无共模误差（+ 端永远接地）
• 虚地是电流型传感器（光电二极管 TIA）的天然接口
• 代价：输入阻抗只有 R1

五、差分放大器

差分放大器只放大两个信号的差值，无视它们的共同部分：VOUT = 增益 × (V2 − V1)。

为什么需要它？信号经长线传输会捡到环境噪声（工频、电磁干扰），而两根挨着的线捡到的噪声几乎一样——这叫共模信号。差分结构让两线相减：相同的噪声互相抵消，只剩信号差。

电路是前面两招的组合拳：V1 经 R1 进 − 端（反相半，Rf 反馈），V2 经 R3 进 + 端（同相半，R4 接地），四电阻对称匹配 Rf/R1 = R4/R3。

用叠加法推导：只看 V1 时就是反相放大器（VOUT₁ = −(Rf/R1)·V1）；只看 V2 时先经 R3/R4 分压到 + 端再同相放大（VOUT₂ = (Rf/R1)·V2）；两路叠加：

VOUT = (Rf / R1) × (V2 − V1)

数字验证（共模消失）：设两线各带 0.95V 共模噪声、信号差 0.1V——V2=1.05V、V1=0.95V，VOUT = 10 × 0.10 = 1V，0.95V 噪声凭空消失。

局限：输入阻抗只有 R1/R3（10kΩ，高阻电桥带不动）；电阻必须严格匹配（1% 电阻实际 CMRR 约 50dB，芯片自身 89dB 被电阻拖累）；改增益要同时换两个电阻保持对称。高精度场景升级为仪表放大器（两跟随器缓冲 + 差分核心，三运放结构）。

典型场景：称重/压力传感器电桥、热电偶、心电 ECG、工业长线接收端。

结语

以上是 MCP6071 的五种基础用法：开环（比较器）→ 电压跟随器 → 同相放大器 → 反相放大器 → 差分放大器。所有用法都是同一个原理的变形：负反馈 + 虚短虚断。

更多应用——跨阻放大器（TIA 光电检测）、有源滤波器、回转器——后续学习后持续补充。

平台：STM32F103ZET6 @ 72MHz · 工程名 usart_dma · USART1（PA9=TX / PA10=RX）@ 115200 前置知识：USART 中断接收 + 环形缓冲区 + 协议帧（模块 2） 实验日期：2026-10-04 · 两个实验全部验收通过

一、实验背景：CPU 当搬运工的辛酸

在学习 DMA 之前，我的串口架构是这样的：每来一个字节，硬件敲门（RXNE 中断）→ CPU 放下手头的活 → 进中断 → 从 DR 寄存器搬一个字节进缓冲区 → 返回。115200 波特率连续收数据 = 每秒 11520 次中断，CPU 的日程表被"搬字节"切碎。

发送侧更惨：HAL_UART_Transmit 是阻塞式的——发 420 字节，CPU 在函数里干等约 37ms，一步不能离开。

DMA（Direct Memory Access，直接内存访问）= 芯片里一个独立的数据搬运处理器。它挂在 AHB 总线（主干道）上，能自己访问内存和外设。CPU 是经理，DMA 是搬运工：经理填一张搬运单（源地址、目的地址、数量），搬运工自己搬，搬完敲门汇报。期间经理想干嘛干嘛。

二、DMA 原理要点

搬运单六要素

配置一次 DMA 传输 = 填这张单子：

请求（Request）：搬运的节奏控制器

DMA 不是一口气把数据砸进外设，而是盯着外设的"空了"信号——串口每发完一字节，TXE 标志变空 → 硬件向 DMA 发一个请求 → DMA 搬一字节进 DR。传输速率被外设节流（115200 的节奏），DMA 只是随叫随到。

F1 的通道映射是固定死的

DMA1 有 7 个通道、DMA2 有 5 个，每个通道同一时刻只能服务一个外设，对应关系查参考手册的映射表，不能自由组合：USART1_TX 固定走 DMA1 通道 4、USART1_RX 固定走 DMA1 通道 5。（F4 以后的 Stream/Request 才可以任意组合。）

六问速答

挂哪条总线：AHB（第一个住 AHB 楼层的外设，这是它能"直接访问内存"的结构原因）；门控开关：RCC_AHBENR 的 DMA1EN；两种模式：Normal（搬一批停）和 Circular（循环，流式场景）。

三、实验 4.1：阻塞 vs DMA 当面对决

实验设计（含一次重要的设计修正）

同一个 420 字节的字符串，两种发法，用 CPU 计数器当裁判。

最初的设计是：阻塞发送后打印计数（=0），DMA 发送期间 CPU 数数（=几十万）。但我自己发现了这个设计的漏洞：阻塞版的"计数=0"其实是"压根没人数"，不是"想数但数不动"，没有说服力。

关键洞察：你恰恰没法在阻塞期间加计数——CPU 被关在 HAL_UART_Transmit 函数里出不来，一行计数代码都执行不了，"加不进计数"本身就是"阻塞"的定义。

所以要严谨地展示"CPU 被占死"，得请一个不受阻塞影响的观察者——中断。现成的是 SysTick（每 1ms 中断一次，主循环卡死它照跑），用它计时，主循环计数器量工作量，两个维度一起打印：

char msg[512];
int n = 0;
for (int i = 0; i < 10; i++)                                   // 填 10 行 ≈ 420 字节
    n += sprintf(&msg[n], "DMA搬运演示第%d行-0123456789ABCDEFG\r\n", i);
while (1)
{
    // ① 阻塞发送：SysTick 计时（中断观察者，主循环卡死它照跑）
    uint32_t t0 = HAL_GetTick();
    cpu_count = 0;                                // 想数数？看看数不数得起来
    HAL_UART_Transmit(&huart1, (uint8_t *)msg, n, 100);
    // 此刻 cpu_count 必然还是 0——CPU 在函数里出不来
    printf(">>> 阻塞发送 %d 字节：耗时 %lu ms，CPU 计数 = %lu（想数也数不了）\r\n\r\n",
           n, (unsigned long)(HAL_GetTick() - t0), (unsigned long)cpu_count);

    HAL_Delay(1000);

    // ② DMA 发送：CPU 扔下地址就走，期间数数
    uint32_t t1 = HAL_GetTick();
    cpu_count = 0;
    HAL_UART_Transmit_DMA(&huart1, (uint8_t *)msg, n);   // 立即返回！
    while (huart1.gState != HAL_UART_STATE_READY)        // DMA 还在搬
        cpu_count++;                                     // CPU 闲着数圈
    printf(">>> DMA 发送 %d 字节：耗时 %lu ms，CPU 计数 = %lu（全程自由）\r\n\r\n",
           n, (unsigned long)(HAL_GetTick() - t1), (unsigned long)cpu_count);

    HAL_Delay(1000);
}

CubeMX 配置

USART1 → DMA Settings → Add → USART1_TX：Channel=DMA1_Channel4（自动）、Direction=Memory to Peripheral、Mode=Normal、Memory Increment ✅、Peripheral Increment ❌、Data Width=Byte。NVIC 勾 DMA1 channel 4 和 USART1 两个中断。

实测数据与结论

>>> 阻塞发送 420 字节：耗时 38 ms，CPU 计数 = 0（想数也数不了）
>>> DMA 发送 420 字节：耗时 38 ms，CPU 计数 = 101437（全程自由）

两行对比的完整解读：耗时几乎一样（都被 115200 波特率定死——DMA 买不回速度）；差别全在 CPU 计数——DMA 买回的是 CPU 那 38ms 的自由时间。一个维度证"速度没变"，一个维度证"占用天差地别"。

方法论沉淀

要证明"某段代码被卡死"，不能用它自己计数（它数不了），要用不受它影响的观察者（中断/定时器）。以后调试"主循环是不是被某行代码拖死了"，同一招：SysTick 打点前后对比。

四、实验 4.2：DMA 接收 + IDLE 空闲断帧

问题：DMA 只管埋头搬，怎么知道"一帧结束了"？

DMA 接收时字节悄无声息地进缓冲区，CPU 睡着了——谁来叫醒它？答案在 UART 硬件里：IDLE 空闲检测。

IDLE：硬件自带的"断句器"

串口有个天然规律：一帧数据一口气发完（字节间隔 < 1 字符时间），帧与帧之间有静默。UART 硬件的 IDLE 标志：收到数据后总线静默满一个字符时间（115200 下约 87µs），IDLE 置位——这是硬件替你数的"句号"。

AA 55 02 01 01 02 ──────静默 87µs────── 下一帧...
└───────────────┘ └── IDLE 中断! ──┘
 DMA 逐字节默默搬
                  ↑ CPU 只在这里醒一次

整个接收过程：6 个字节 = 0 次中断；帧结束 = 1 次 IDLE 中断——中断数量从"字节数"降到"帧数"，这就是 DMA 高速接收的全部秘密。

不定长的魔法

IDLE 中断里 CPU 醒来后的第一问：这帧多长？DMA 的计数器就是答案：

本次到达字节数 Size = 缓冲区大小 − DMA 剩余计数（CNDTR）

发 6 字节算 6，发 60 字节算 60——不用事先约定长度，来多少算多少，这就是"不定长接收"。HAL 已把这整套打包成 HAL_UARTEx_ReceiveToIdle_DMA，事件回调直接给算好的 Size。

架构：一帧数据的完整旅程

PC 串口助手(HEX)
   │  AA 55 02 01 01 02
   ▼
PA10(RX) ──► USART1 DR ──► [DMA1_CH5 硬件搬运] ──► rxDmaBuf[0..5]
   │              每字节：RXNE→硬件DMA请求→搬一字节→CNDTR减一（0中断）
   ├────────── 87µs ──────────┐
   ▼                          ▼
静默满 → IDLE 置位 ──► IDLE 中断（每帧仅 1 次）
              │ Size = 64 − CNDTR = 6
              ▼
   HAL_UARTEx_RxEventCallback(huart, Size)
              │
              ▼
   frame_parse(rxDmaBuf, Size)   ← 协议层，与模块2.3一字未改
              │ 五状态机推进
              ▼
   frame_exec：LED 点亮 + ACK 经 DMA 回发
              │
              ▼
   重新武装 ReceiveToIdle_DMA ──► 待命等下一帧

核心代码

// 启动（USER CODE 2）：
HAL_UARTEx_ReceiveToIdle_DMA(&huart1, rxDmaBuf, RXBUF_SIZE);

// IDLE 事件回调（USER CODE 4）：
void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size)
{
    if (huart->Instance == USART1 &&
        huart->RxEventType == HAL_UART_RXEVENT_IDLE) {
        frame_parse(rxDmaBuf, Size);                        // Size=本次字节数(不定长)
        HAL_UARTEx_ReceiveToIdle_DMA(huart, rxDmaBuf, RXBUF_SIZE);  // 重新武装
    }
}

（frame_parse/frame_exec 是模块 2.3 的五状态机解析器原封不动搬过来，仅 ACK 回发从阻塞改成 HAL_UART_Transmit_DMA。）

验收：五连测试（串口助手 HEX 模式）

最有价值的发现：协议层一行没改，五连全过——搬运层从"每字节中断"换装成"DMA 批量"，解析器毫无感觉。分层解耦的活证据：换一层，其他层无感。

与模块 2 的账本对比（每帧 6 字节）

五、踩坑实录：MX_DMA_Init 缺失（本次最值钱的教训）

现象

烧录后串口只打了一轮"阻塞发送…计数=0"+10 行数据，然后永久冻结。用调试器读 CPU 计数变量：单调增长到 840 万、从不归零——程序卡死在 DMA 等待循环里。

诊断链（gdb 符号级调试，全程远程）

根因

CubeMX 给已有工程加 DMA 后重新生成，偶尔不往 main.c 插 MX_DMA_Init() 调用——dma.c 里时钟使能、中断使能都生成得好好的，但没人调用它们，DMA 房间没通电。症状极具迷惑性：编译零错误、HAL_UART_Transmit_DMA 返回 OK、然后永远等不到完成。

修复

main.c 补两处（MX_DMA_Init 必须在 USART 之前——MspInit 要写 DMA 寄存器）：

#include "dma.h"
...
MX_GPIO_Init();
MX_DMA_Init();              // DMA 时钟+中断使能
MX_USART1_UART_Init();

修复后复测：gState = 0x20（READY，正常循环）、cpu_count = 101437（DMA 期间 CPU 自由计数）——复活。

防复发

以后每次 CubeMX 重新生成，git diff 里专门盯一眼 MX_DMA_Init() 还在不在——被吃掉就补回来。

次级知识点

HAL 的 DMA 发送完成走两步：DMA 中断（数据搬完进 DR）→ USART TC 中断（最后一位移出移位寄存器）→ gState=READY。所以 USART1 的 NVIC 也必须勾，只勾 DMA 通道中断不够。

六、调试手法沉淀（本模块新增）

• gdb 符号级读句柄：p/x huart1.gState、p/x huart1.TxXferCount——比猜寄存器位准得多
• NVIC ISER 读中断使能实况：ISER0/ISER1 对照 IRQ 号（DMA1_CH4=14、USART1=37）
• "没通电"的识别：外设寄存器全零 + 配置写入无效 = 时钟没开
• 证明卡死用独立观察者：SysTick/定时器打点，别让被卡死的代码自己数

七、一句话知识点清单

• DMA=独立搬运工：CPU 填单（源/目的/数量/宽度/方向/增量），DMA 搬完敲门
• DMA1/DMA2 挂 AHB，门控 RCC_AHBENR——第一个 AHB 楼层外设
• F1 通道映射固定：USART1_TX=CH4、RX=CH5，查表不可选
• 请求节流：速率被外设定死——DMA 买的是 CPU 自由时间，不是速度
• IDLE=硬件断句器：静默 1 字符时间置位，帧边界的物理本质
• 不定长 Size = 缓冲区大小 − CNDTR
• HAL_UARTEx_ReceiveToIdle_DMA + RxEventCallback；Normal 模式 IDLE 后必须 re-arm
• DMA TX 完成两步走：DMA 中断 + USART TC 中断——两个 NVIC 都要勾
• MX_DMA_Init 必须在用 DMA 的外设之前调用
• CubeMX 偶发不插 MX_DMA_Init——每次生成 git diff 盯梢
• 分层解耦：搬运层升级，协议层免疫（2.3 解析器零改动上 DMA）
• 证明卡死要用不受影响的观察者（SysTick），不能让卡死者自己数

模块 4 实验记录 · 2026-10-04 · STM32F103ZET6 最小系统板 · 工程名 usart_dma

平台：STM32F103ZET6 @ 72MHz · 工程名 pwm_measure（一个工程跑完三个实验）· 串口 115200（UTF-8）
前置知识：模块 3A（时基、输出比较、PWM 呼吸灯）

引言：从“产生信号”到“测量信号”

模块 3A 让定时器输出信号（PWM 点灯），模块 3B 把方向反过来——用定时器测量外部信号：测一个 PWM 波形的周期和占空比、数旋钮转了多少格、给电机驱动补上安全机制。三个实验共用同一个工程 pwm_measure，一个实验叠一个实验，最后三套功能在同一块板上和平共处——这也是真实项目的形态。

一、3B.1 输入捕获：造一台 PWM 测量仪

1.1 实验目标

测一个未知信号的周期和占空比，串口每秒打印结果——这就是一台“PWM 测量仪”。它是很多应用的地基：测转速（编码器脉冲）、超声波回波计时、红外遥控解码、频率计。

1.2 原理：给定时器装“硬件快门”

朴素思路是“中断+软件时间戳”，但 CPU 响应中断有微秒级抖动（可能被别的事耽误），测出来的时刻不准。

输入捕获（IC）= 硬件快门：捕获通道盯着引脚，设定的边沿（上升/下降）一到达，硬件瞬间把当前 CNT 的值拍进 CCR——零延迟、零抖动，然后才置标志、发中断。你在回调里取走的不是“现在几点”，而是“边沿到达那一刻的照片”。

测量公式：

• 周期 = 两次上升沿快照之差
• 高电平时长 = 上升沿快照 − 下降沿快照
• 占空比 = 高电平时长 ÷ 周期

F1 的硬件限制：捕获极性只有上升/下降两档，没有双沿捕获（双沿是 F2/F4 之后新系列才加的，CubeMX 里找不到 Both Edges 不是操作问题，是芯片能力）。想要双沿效果 → 双通道分工：CH2 守上升沿测周期、CH3 守下降沿测脉宽——这本来就是仪器级的标准做法。

16 位回绕：CNT 数到 65535 会归零。只要信号周期小于定时器溢出周期，用 (uint16_t)(now - last) 的 16 位减法就能自动处理回绕（数学上 mod 65536）。

1.3 实验设计：信号源 + 测量仪，自己测自己

TIM3_CH3 ──PB0──┬──→ PA1 (TIM2_CH2, 上升沿捕获) → 测周期
                │ 两根杜邦线
                └──→ PA2 (TIM2_CH3, 下降沿捕获) → 测高电平时长

三个设计决策：

1. 信号源用已知参数：TIM3 输出 1Hz、50% PWM（PSC=7199、ARR=9999、Pulse=5000）。测量仪读数必须精确等于已知答案——这叫自校准：用已知校准未知，是仪器思维的第一课
2. 测量仪必须用另一个定时器：TIM3 的 CNT 正被自己的 PWM 用着，相位完全同步——上升沿永远发生在 CNT 同一位置，周期会测成 0（混叠）。信号源和测量仪必须时钟独立
3. 分辨率与量程的取舍：测量仪 TIM2 用 PSC=7199（每格 0.1ms）+ ARR=65535（量程 6.55 秒）——覆盖 1 秒信号绰绰有余，回绕减法也成立

1.4 CubeMX 配置

1.5 核心代码

启动（USER CODE 2）：

HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_3); // 信号源：PB0 输出 1Hz 50% PWM
HAL_TIM_IC_Start_IT(&htim2, TIM_CHANNEL_2); // CH2 上升沿：测周期
HAL_TIM_IC_Start_IT(&htim2, TIM_CHANNEL_3); // CH3 下降沿：测高电平时长

捕获回调（USER CODE 4）：

void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim){
    if(htim->Instance != TIM2) return;
    if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_2){ // 上升沿 → 周期
        uint16_t now = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_2);
        period = (uint16_t)(now - cap_rise); // 两次上升沿之差(16位减法自动处理回绕)
        cap_rise = now;
        ready = 1; // 一整周期凑齐
    }else if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_3){ // 下降沿 → 高电平时长
        uint16_t now = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_3);
        width = (uint16_t)(now - cap_rise); // 上升→下降之差
    }
}

主循环每秒打印 周期/高/占空比 三件套（printf 重定向用模块 2 的 __io_putchar 老配方，记得 Includes 区加 #include <stdio.h>）。

1.6 现象与验证

• 串口每秒一行：周期=1000 ms 高=500 ms 占空比=50%——和信号源已知值精确吻合，自校准通过
• 周期在 999/1000 之间偶尔跳变——末位量化误差：信号边沿恰好落在 0.1ms 刻度线附近，捕获有时差一拍。0.1ms 分辨率测 1 秒信号理论精度 ±0.01%，真实仪器的末位跳变就是这么来的
• 实时跟踪验收：用调试器现场把信号源的 CCR3 从 5000 改成 2500（一条 mww 命令，不重新烧录），测量仪下一秒立刻显示 高=250 ms 占空比=25%——仪器追上了活的信号变化

1.7 踩坑实录（这节踩得最密集）

1. F1 无双沿捕获：CubeMX 里 Polarity 只有 Rising/Falling——换双通道分工
2. 主循环代码放错区被吃：代码写在 USER CODE END WHILE 和 BEGIN 3 之间的缝隙（模板自留地），CubeMX 重新生成时被还原——加 USART1 重新生成后 printf 循环凭空消失。正确位置：BEGIN 3 之后
3. TIM2 PSC 填成 72：tick 变成约 1µs，1 秒信号跨 15 次 16 位回绕，减法只救一次——周期打印成 326ms 的乱数（实测变量 period=3261，铁证）
4. CH3 极性忘改 Falling：两个通道都守上升沿，CH2/CH3 在同一个上升沿同时触发，CH2 先算周期更新 cap_rise，CH3 随后算 width=now−cap_rise=0——占空比永远 0%（实测 width=0）
5. USART1 没配：huart1 未声明，编译直接报错
6. 串口中文乱码：固件 printf 是 UTF-8、串口助手默认 GBK——数字和 % 是 ASCII 两边一样所以能认出，中文全花。解法：助手切 UTF-8

排障方法论：变量不对时用调试器直接读运行中的变量（nm 查地址 + mdw 读值）——period=3261、width=0 两个值一出来，两个配置 bug 当场定位，比瞎猜快一百倍。

二、3B.2 编码器接口：让硬件自己数旋钮

2.1 实验目标

读取旋转编码器的位置（累计计数）、方向（顺/逆时针）、速度（单位时间计数变化），串口实时打印。

2.2 原理：AB 正交 + 硬件解码器

旋转编码器（EC11）转起来输出两路方波，玄机在相位差 90°：

顺时针（A 超前 B 90°）：
A: ─┐ ┌─┐ ┌─
    └─┘ └─┘ └
B: ──┐ ┌─┐
     └─┘ └
逆时针（B 超前 A 90°）

• 方向藏在“谁超前谁”里
• 位置藏在累计计数里（每圈 N 个脉冲，EC11 常见 20 个）
• 速度 = 单位时间的计数变化

软件解码的痛：A、B 各接一个 EXTI 中断数边沿判相位——每圈几百次中断、机械触点抖动产生假边沿、判相位容易错。

硬件编码器接口：定时器内置的正交解码器——A 接 CH1、B 接 CH2，硬件实时盯着两相位关系，每个有效边沿自动让 CNT +1 或 −1（顺时针加、逆时针减，方向判断零成本）。你随时读 CNT 就知道位置，零中断、零 CPU。这是“把数数交给硬件”的第三次登场（时基→PWM→编码器）。

三个关键机制：

• 四倍频（x4）：Encoder Mode 选 "TI1 and TI2" = A、B 的每个边沿都计数 → 分辨率 ×4（20 脉冲/圈 = 80 计数/圈），转一格恰好 ±4——“四倍频”名字即来于此
• PSC 失效：编码器模式下 CNT 的心跳来自外部边沿而不是内部时钟——预分频器形同虚设（不用设）
• 16 位双向回绕：顺转加到 65535 回绕到 0，逆转减到 0 回绕到 65535。读位置差用 (int16_t)(now - last)——有符号 16 位减法自动处理双向回绕，还白送一个符号（正=顺、负=逆）

2.3 实验设计

TIM4 编码器模式 + 主循环每 200ms 采样一次 CNT 算速度。引脚重映射实战：TIM4 编码器默认脚是 PB6/PB7，但配置时把引脚点到了 PD12/PD13（TIM4 重映射后的位置）——同一对通道的两个住址，CubeMX 自动生成 __HAL_AFIO_REMAP_TIM4_ENABLE()，和 PB6/PB7 完全等效。这无意中把 F1 的“引脚搬家”（AFIO 重映射）功能用了一遍。

编码器模块五脚（GND/VCC/A/B/C）：VCC→3.3V（别接 5V，模块上拉电平要和 STM32 一致）、GND→GND、A→PD12、B→PD13、C 是按键脚（按下导通，本实验不接，留给 3B.3 当刹车按钮）。

2.4 CubeMX 配置

2.5 核心代码

启动只要一行（无需中断）：

HAL_TIM_Encoder_Start(&htim4, TIM_CHANNEL_ALL); // 启动编码器接口: 硬件开始自动计数

主循环每 200ms 采样：

int16_t now = (int16_t)__HAL_TIM_GET_COUNTER(&htim4); // 读当前位置
int16_t speed = (int16_t)(now - enc_last); // 差值: 正=顺 负=逆 0=静止
enc_last = now;
printf("位置=%d 速度=%d %s\r\n", now, speed,
        speed>0 ? "顺时针" : (speed<0 ? "逆时针" : "静止"));

2.6 现象与验证

串口每 200ms 一行，转动旋钮时：

位置=-25 速度=1 顺时针
位置=-16 速度=8 顺时针
位置=-8 速度=0 静止
位置=-26 速度=-18 逆时针

调试器协同采样（云端定时读 CNT，用户同时转旋钮）：+7 → −13 → +23 → −12 → +21 → −22 → +8 → +17 → +7——双向计数实锤，数值在正负之间摆动对应来回旋转，停下归零。A/B 接反不会坏任何东西，只是方向反过来——对调两根线即可，编码器接线的日常。

2.7 踩坑实录

1. 编码器没接就查代码：CNT 六次采样全 0，排查半天——其实是编码器根本还没接线。先确认物理连接再查软件
2. 引脚住址困惑：资料说 TIM4 是 PD12/13，教程说 PB6/7——两个都对，一个是重映射后的住址。跟着固件实际配置接（看 CubeMX 引脚分配或生成代码里的 REMAP 宏）
3. 打印刷屏：主循环 HAL_Delay(10) 没按设计改成 200——每秒 100 行串口刷成瀑布。采样周期决定打印节奏，200ms 才能看清

三、3B.3 高级定时器 TIM1：互补、死区与刹车

3.1 实验目标

输出一对互补 PWM（驱动半桥上下管），插入死区时间（防直通），接上刹车输入（硬件急停）——电机控制的看家本领三件套。

3.2 原理：为半桥而生的安全链

半桥是电机驱动的最小单元：

     ──┬── 电源
 [上管] ← TIM1_CH1 (PE9)
       ├──── 中点 → 接电机
 [下管] ← TIM1_CH1N(PE8)
     ──┴── GND

上下管绝不能同时导通——同时导通=电源对地短路（直通），MOS 管瞬间烧毁。互补 PWM 保证逻辑上不同时通，但 MOS 管关断比开通慢——切换瞬间上管没关干净、下管已经开通，微秒级直通照样炸管。

三个硬件安全机制：

• 互补输出：每个通道两根引脚（CHx/CHxN），输出极性相反，正好驱动上下两管
• 死区时间（DTG）：每次切换插入一段“双管全关”的空档，硬件按 tDTS（72MHz，13.9ns 步进）自动插入，不受 PSC 影响，软件零参与
• 刹车（BKIN）：一个引脚触发时硬件直接清 MOE 总闸（主输出使能），所有输出瞬间进安全态，不等软件反应——过流保护、急停按钮的最后一道保险丝

3.3 实验设计：第三次“自己测自己”

TIM1_CH1(PE9) ──┬──→ PA1 (捕获仪CH2, 上升沿→周期)
                └──→ PA2 (捕获仪CH3, 下降沿→脉宽)
TIM1_CH1N(PE8) ──→ 空着（调试器采样电平验证互补性）
编码器 C 键 ──→ PE15 (BKIN 刹车)

实验参数 vs 工程参数的取舍（重要思维）：真实电机用 20kHz PWM + 几百 ns 死区，但捕获仪最快 1µs 分辨率测不到——所以故意放慢 PWM（100Hz）、加大死区（14µs）让仪器能看见。实验参数为可测性服务，工程参数为效率服务，别混为一谈。

参数计算：

• TIM1：PSC=71（1µs 粒度）、ARR=9999（10ms 周期=100Hz）、Pulse=5000（50%）、DTG=255（0xFF 编码 ≈ 14µs 死区）
• 捕获仪 TIM2：PSC 从 7199 改成 71（分辨率从 0.1ms 提到 1µs）
• 预期读数：周期=10000µs、高=4986µs——理想 5000 被死区啃掉 14 → 死区被直接测出来；占空比 49%（死区吃掉 1% 占空比）

引脚重映射：TIM1 默认脚在板上全被占（CH1N=PA7 是 W25Q16、CH2=PA9 是串口、CH3=PA10 是串口、CH4=PA11 是 USB、BKIN=PA6 是 W25Q16）——全重映射到 PE 口：CH1=PE9、CH1N=PE8、BKIN=PE15（动手前先确认板上排针有引出）。

3.4 CubeMX 配置

刹车选项含义速查：BRK State 刹车电路电源开关；BRK Polarity 什么电平触发（按键按下接地→Low）；Automatic Output State 刹车消失后谁合闸（Enable=硬件自动，真实故障场景用 Disable 等软件确认）；OSSI/OSSR 输出关闭时引脚浮空还是驱动到确定电平（电机场景必开，防栅极浮空误触发）；Lock 给安全配置上锁防篡改。

3.5 核心代码

互补输出要开两个开关（USER CODE 2）：

HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1); // CH1 主输出(顺带开MOE总闸)
HAL_TIMEx_PWMN_Start(&htim1, TIM_CHANNEL_1); // CH1N 互补输出(注意是Ex扩展函数)

printf 换微秒版（tick 已是 1µs，不用再除）：

printf("周期=%u us 高=%u us 占空比=%u%%\r\n",
        period, width, width*100/period);

3.6 现象与验证

• 串口：周期=10000 us 高=4986 us 占空比=49%——5000−4986=14µs 就是死区实测，与 DTG=255 的理论值精确命中
• 互补性铁证（调试器十次采样 PE8/PE9 电平）：PE9=1,PE8=0 → PE8=1,PE9=0 → … 10/10 严格单高——两脚永不同时为高，互补+死区成立
• 刹车实测：按住编码器旋钮（C 键把 PE15 拉低）→ PWM 立即停止、打印冻结；松开 → AOE 自动合闸、打印恢复滚动

3.7 踩坑实录：BKIN 悬空引发的“全链路假故障”（本模块最精彩的一案）

现象：烧录后测量值全 0、串口没有测量数据、输出引脚电平乱跳。

排查链（每一步都有寄存器证据）：

1. 读测量变量：period=0、width=0 → 捕获仪没收到边沿 → PE9 上没有波形
2. 读 TIM1_BDTR=0x54FF：死区/刹车/自动恢复配置全对，但 MOE=0——总闸被拉掉了
3. 读 PE15 电平：低 → 刹车处于触发状态（配的是低有效）
4. 因果链闭合：PE15 低 → 刹车 → 硬件清 MOE → 输出禁 → 无波形 → 测量 0。PE15 电平乱跳还导致刹车反复触发/AOE 反复合闸，MOE 振荡，输出时有时无
5. 查生成代码：PE15 是 GPIO_MODE_INPUT + GPIO_NOPULL——悬空！
6. 修复（配上拉）后仍读低 → 读 CRH（模式=上拉输入 ✓）+ ODR（拉的方向=上 ✓）+ IDR（实际电平=低 ✗）三连——内部上拉生效但读低 = 外部有东西硬拉地
7. 判决性实验：拔掉 PE15 上的线 → 立刻变高、MOE=1、测量值 10000/4986 全部出现——实锤是那根线接着地（模块端插错孔）

教训：刹车电路对电平极度敏感，BKIN 必须接确定电平（上拉），绝不悬空——这本身就是刹车威力的最好反面教材。排查手法沉淀：CRH/ODR/IDR 三连读（配置生效了吗+拉对方向了吗+实际电平是多少），内部上拉打不过外部直连地，拔线是最终的二分判决。

另一个坑：frp 调试偶发“全零假象”——openocd 连接后芯片停在复位态没放行，所有寄存器读复位值 0、RAM 是陈旧值，看起来像全面故障。解法：monitor reset halt + monitor resume 序列。读数全零时先怀疑目标没在跑，再怀疑代码。

结语：三个实验串成的一条线

三个实验其实是同一条思路的三次递进：

• 3B.1：硬件快门记时刻 → 测周期测脉宽（测量时间）
• 3B.2：硬件解码器数边沿 → 测位置测方向（测量旋转）
• 3B.3：硬件死区刹车保安全 → 互补输出驱动半桥（输出+保护）

加上 3A 的时基/PWM，F103 的定时器全家桶至此没有死角。调试手法也攒出一套：nm 查变量地址 + mdw 读运行中的值、compare-sections 鉴别固件身份、mww 不重烧录现场改参数、协同采样（人转旋钮+云端读寄存器）——没有示波器的环境下，调试器就是你的眼睛。

平台：STM32F103ZET6 @ 72MHz · LED=PB5（低电平点亮）· 工程名 tim_led 三个阶段是同一条思路的递进：每一步都把上一课软件干的活移交给硬件

阶段一：时基——1ms 定时，LED 1Hz 闪烁（软件计数版）

思路

先解决"HAL_Delay 会阻塞 CPU"的问题：让定时器硬件自己数数，数满 1ms 敲一次门（中断），CPU 平时自由，只在被敲门时干一小点活。LED 要 1Hz 闪（亮 500ms 灭 500ms），但定时器只会每 1ms 响一次铃——"500ms"这个大时间尺度由软件在回调里数数实现：攒 500 个 1ms 就翻转一次引脚。

CubeMX 配置

注意 +1 陷阱：PSC/ARR 都从 0 数起，所以 71 是"72 档"、999 是"1000 格"。TIM2 挂 APB1（名义 36M），但定时器走 ×2 后门实际吃 72MHz。

完整代码

/* USER CODE BEGIN 2 */
HAL_TIM_Base_Start_IT(&htim2);   // 拧发条：CEN=1 开始数数，UIE=1 数满允许敲门
/* USER CODE END 2 */

/* USER CODE BEGIN 4 */
// TIM2 每 1ms 进来一次（中断上下文：快进快出，只做加减和翻转）
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    if (htim->Instance == TIM2) {
        static uint16_t ms = 0;              // static：跨中断保留进度
        if (++ms >= 500) {                   // 攒满 500 个 1ms
            ms = 0;
            HAL_GPIO_TogglePin(led1_GPIO_Port, led1_Pin);  // 翻转 → 1Hz 闪烁
        }
    }
}
/* USER CODE END 4 */

逐行讲解

• HAL_TIM_Base_Start_IT(&htim2)：CubeMX 的 MX_TIM2_Init 只负责"装填参数"（PSC、ARR 写进寄存器），此时计数器是静止的（CEN=0）。这一行干两件事：CEN=1（开始数）+ UIE=1（允许 Update 事件触发中断）。不调它，配置再对也是死表。
• if (htim->Instance == TIM2)：HAL_TIM_PeriodElapsedCallback 是全局弱符号回调——将来你开 TIM3、TIM4，它们的 Update 事件也进这同一个函数。不判断是谁，就会串台。
• static uint16_t ms = 0：本阶段的灵魂。普通局部变量每次函数返回就消失，static 让它活过函数返回——每次中断进来，ms 都是"上次的值"。没有 static，ms 永远从 0 数起，永远到不了 500，灯永远不闪。
• if (++ms >= 500)：前缀自增（先加再比）。500 个 1ms = 500ms。
• HAL_GPIO_TogglePin：翻转 PB5。亮 500ms、灭 500ms，1Hz。
• 中断纪律：回调里只做加减和写引脚——中断上下文必须快进快出（拖久了下一次 1ms 到点就堆积）。

现象与本质

LED 1Hz 闪烁。本质：硬件管"1ms 这个小周期"，软件数"500 次这个大尺度"。缺点也明显：每秒 1000 次中断，只为数一个数。

阶段二：输出比较——双门槛定点亮灭（零计数版）

思路

阶段一里"500ms"靠软件数——能不能让硬件直接在 500ms 处响铃？输出比较（OC）就是给 CNT 再加一道门槛 CCR：CNT 数到 CCR 的瞬间，Compare 事件爆发。于是周期里有两道硬件门槛：

• Update 事件（CNT 溢出归零，t=0s）→ 点亮
• Compare 事件（CNT 数到 CCR1，t=0.5s）→ 熄灭

回调里一个计数器都不需要——两道门槛把时间点定死，软件只负责"听到铃声做动作"。这就是 PWM 的手工版。

CubeMX 配置

为什么 PSC 从 71 改成 7199？ARR 是 16 位（最大 65535），1µs 粒度最多数 65.5ms——凑 1 秒周期必须先降频。这就是 (PSC, ARR) 的因式分解自由度：先定粒度，再凑周期。

完整代码

/* USER CODE BEGIN 2 */
HAL_TIM_Base_Start_IT(&htim2);              // 数数 + Update中断（周期起点事件）
HAL_TIM_OC_Start_IT(&htim2, TIM_CHANNEL_1);  // 再开CH1比较中断（CCR门槛事件）
/* USER CODE END 2 */

/* USER CODE BEGIN 4 */
// Update事件：CNT溢出归零的瞬间 = 周期起点 → 点亮
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    if (htim->Instance == TIM2)
        HAL_GPIO_WritePin(led1_GPIO_Port, led1_Pin, GPIO_PIN_RESET);  // 低电平=亮
}

// Compare事件：CNT数到CCR1的瞬间 → 熄灭
void HAL_TIM_OC_DelayElapsedCallback(TIM_HandleTypeDef *htim)
{
    if (htim->Instance == TIM2 && htim->Channel == HAL_TIM_ACTIVE_CHANNEL_1)
        HAL_GPIO_WritePin(led1_GPIO_Port, led1_Pin, GPIO_PIN_SET);    // 高电平=灭
}
/* USER CODE END 4 */

逐行讲解

• 两声令：HAL_TIM_Base_Start_IT 开 Update 中断许可（UIE=1）；HAL_TIM_OC_Start_IT 开 CH1 的 Compare 中断许可（CC1IE=1）+ 通道使能。两个 Start 各管各的许可灯，缺一个就少一种铃声。
• 一个入口，两个回调：两种事件走同一个 TIM2_IRQHandler，HAL 在 HAL_TIM_IRQHandler 里查标志分家——UIF 走 PeriodElapsedCallback，CC1IF 走 OC_DelayElapsedCallback。
• OC 回调多判一个 htim->Channel：4 个通道共用一个 OC 回调，Channel 告诉你是哪个通道在响（这里必须确认是 CH1）。
• 两个回调名字都是弱符号：名字一字不差才构成覆盖。笔误一个字母 = 函数成孤儿 = 编译零警告、现象纹丝不动（真实踩过：HLA_TIM_PeriodElapsedClallback）。防御：从 HAL 源码抄、用 VSCode 补全敲、写完 grep 核对。
• 写引脚用 SET/RESET 而不是 Toggle：亮灭动作分别绑定在两道门槛上，语义清晰——这正是 PWM"起点置高、比较处置低"的雏形。

现象与本质

现象和阶段一一样是 1Hz 闪烁，但内核换了引擎：中断从 1000 次/秒降到 2 次/秒（CPU 占用差 500 倍），定时精度从"受中断延迟影响"变成"硬件门槛精准到格"。

阶段三：PWM——硬件方波 + 呼吸灯（最终版）

思路

两个硬件事实决定了方案：

1. 硬件 PWM 的规则：通道配成 PWM 模式后，硬件自动执行"CNT < CCR → 引脚高，CNT ≥ CCR → 引脚低"——零中断零 CPU。用 TIM3_CH3（PB0）做硬件 PWM 演示（PA6/PA7 被板载 Flash 占用，选脚先查板载外设）。
2. LED 在 PB5——不属于任何定时器通道，硬件 PWM 够不着它 → 呼吸灯必须软件 PWM。

软件 PWM 的架构是载波与包络分层：

• 载波层：阶段二的双门槛机器，把周期从 1s 缩到 10ms（100Hz）——这个频率不能慢，慢了眼睛看见闪烁
• 包络层：Update 回调每个载波周期推一下占空比 duty（±1，在 0↔100 折返），用 __HAL_TIM_SET_COMPARE 动态写进 CCR1
• 眼睛+LED 是低通滤波器：100Hz 快速亮灭只留平均亮度，正比占空比 → duty 扫 0↔100，灯就呼吸

CubeMX 配置

关键刻度对齐：duty 是 0~100 的百分数，直接写进 CCR1，所以 ARR 必须=99——在 ARR=99 的世界里 100/100=100%，在 ARR=9999 的世界里 100/10000 只有 1%（真实踩过：PSC/ARR 改反，呼吸在 1% 亮度里扫，肉眼等于没亮）。占空比是比值，duty 的尺子必须和 ARR 同刻度。

完整代码

/* USER CODE BEGIN PV */
uint8_t duty = 0;     // 当前占空比 0~100（呼吸的"肺活量"）
int8_t  dir  = 1;     // 呼吸方向：+1 渐亮，-1 渐暗
/* USER CODE END PV */

/* USER CODE BEGIN 2 */
HAL_TIM_Base_Start_IT(&htim2);              // TIM2：呼吸灯的软件PWM机器（阶段二原样）
HAL_TIM_OC_Start_IT(&htim2, TIM_CHANNEL_1);
HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_3);   // TIM3：PB0 硬件PWM，零中断
/* USER CODE END 2 */

/* USER CODE BEGIN 4 */
// Update事件 = 每个PWM周期(10ms)的起点：推进呼吸坡度，装填本周期占空比
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim){
  if(htim->Instance == TIM2){
    duty += dir;                                        // 坡度每周期 ±1
    if(duty >= 100){ duty = 100; dir = -1; }            // 亮到头，折返渐暗
    if(duty <= 0)  { duty = 0;   dir = +1; }             // 暗到头，折返渐亮
    __HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_1, duty); // 门槛=本周期占空比
    if(duty == 0)
      HAL_GPIO_WritePin(led1_GPIO_Port,led1_Pin,GPIO_PIN_SET);   // 0%：直接灭
    else
      HAL_GPIO_WritePin(led1_GPIO_Port,led1_Pin,GPIO_PIN_RESET); // >0%：先亮，等Compare来灭
  }
}

// Compare事件 = CNT数到duty处：熄灭（与阶段二一字不差）
void HAL_TIM_OC_DelayElapsedCallback(TIM_HandleTypeDef *htim){
  if(htim->Instance == TIM2 && htim->Channel == HAL_TIM_ACTIVE_CHANNEL_1){
    HAL_GPIO_WritePin(led1_GPIO_Port,led1_Pin,GPIO_PIN_SET);
  }
}
/* USER CODE END 4 */

逐行讲解

• PV 区两个变量：duty 是当前占空比（呼吸的"肺活量"），dir 是方向（+1 渐亮 / −1 渐暗）。两个变量合起来就是一个微型呼吸状态机。
• HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_3)：硬件 PWM 的启动只要一行，连 NVIC 都不用配——波形完全由硬件按"CNT<CCR3 输出高"的规则自己画，CPU 零参与。
• duty += dir + 两个折返 if：三角波坡度。duty 到 100 掉头向下、到 0 掉头向上，0↔100 来回扫。呼吸节奏 = 200 步 × 10ms = 2 秒一个呼吸。
• __HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_1, duty)：呼吸的全部秘密——CCR 不是死的，运行中随时可改。这个宏把新 duty 写进 CCR1，本周期后半段 Compare 事件就按新门槛触发。
• if (duty == 0) 特判：duty=0 时 CCR1=0，Compare 事件和 Update 在 CNT=0 同一瞬间爆发，而 HAL 先处理 Compare 后处理 Update——不特判，0% 会变成常亮（阶段二调试时那个"常亮 bug"的缩小版）。所以 0% 时 Update 回调里直接写灭，不指望 Compare。
• else 分支先亮：>0% 时周期起点先点亮，熄灭的活儿留给 Compare 事件在"数到 duty"处干——亮多久完全由 duty 说了算。
• Compare 回调：与阶段二一字未改——这就是分层的红利，载波机器不用动，只换包络逻辑。

现象与本质

• PB5 呼吸灯：约 2 秒一个渐亮渐暗循环，亮度平滑变化
• PB0 硬件 PWM：1Hz、50% 方波（调试器实时采样引脚电平验证：6 次采样 0/1 完美交替，PSC/ARR/CCR 寄存器读数 7199/9999/5000 与计算一致）

三阶段演进总览

一句话总结整个模块：定时器的学习史就是一部"移交史"——把"等"从 CPU 移交给硬件（阶段一），把"数"移交给门槛（阶段二），把"开关引脚"移交给比较器（阶段三的硬件 PWM）；CPU 最后只剩一件体面的活：决定呼吸的节奏。

平台：STM32F103ZET6 @ 72MHz · USART1（PA9=TX / PA10=RX）· 115200-8-N-1 · LED=PB5 低电平点亮 前置知识：USART 中断接收 + 环形缓冲区

一、要解决的问题

printf 重定向解决了"怎么发"，中断接收 + 环形缓冲区解决了"怎么收"。但那两课搬运的都只是字节，而真实项目需要的是命令——PC 发一条指令，板子解析、执行、回确认。

核心矛盾在这里：串口是一条无边界字节流。PC 连续发来 12 个字节，串口本身不会告诉你这是"两条 6 字节命令"，还是"一条 12 字节命令"，还是"一堆垃圾 + 一条命令"。噪声、丢字节、粘包、劈包，在串口世界里都是家常便饭。

所以这个课题分两半：

1. 设计帧格式——给字节流加上结构和边界
2. 写解析器——从字节流里可靠地"切"出完整帧，且坏帧不能影响好帧

二、帧格式设计

┌──────┬──────┬──────┬─────────────┬──────────┐
│ 0xAA │ 0x55 │ len  │  data[len]  │  XOR CRC │
└──────┴──────┴──────┴─────────────┴──────────┘
 帧头1   帧头2   长度      数据域         校验

开灯帧逐字节拆解：AA 55 02 01 01 02

• AA 55：帧头
• 02：数据域长度为 2
• 01 01：CMD=0x01（LED 控制），参数=1（亮）
• 02：校验 = 02 ^ 01 ^ 01（长度字节也参与异或，这是收发双方的约定）

两种断帧方案对比

三、运行思路：一台两级节奏的流水线

整台机器是两条流水线 + 一个中转仓库：

PC串口助手(HEX) ──AA 55 02 01 01 02──► CH340 ──► PA10(RX引脚)
                                              │ 每到 1 字节: RXNE→NVIC→中断
                                              ▼
           ┌── 中断上下文【生产者·快进快出】──────────┐
           │  RxCpltCallback:                          │
           │    rxbuf[rxHead]=字节; rxHead++;           │
           │    接力挂单(下一个字节继续中断收)            │
           └──────────────┬─────────────────────────────┘
                          ▼
                 〖环形缓冲区 rxbuf[128]〗←时间解耦的中转仓库
                          │
           ┌── 主循环【消费者·10ms 醒一次】─────────────┐
           │  rb_read() 批量取 → frame_parse()          │
           │  状态机: HDR1→HDR2→LEN→DATA→CRC            │
           └──────────────┬─────────────────────────────┘
                          ▼ CRC 通过(唯一合法入口)
                      frame_exec()
                     ┌─────┴──────┐
                     ▼            ▼
               PB5 拉低→LED亮   组ACK帧→HAL_UART_Transmit
                                   →PA9(TX)→CH340→PC显示

分层的本质是三种节奏的解耦：

• 字节节奏（86.8µs/字节）：115200 波特率 8N1，每字节 10 位。这个节奏由硬件决定，用中断接——轮询要么丢字节要么烧 CPU
• 帧节奏（10ms）：主循环每 10ms 醒一次，把仓库里现有字节一次性搬空喂给解析器。这个值就是命令响应延迟上限
• 中间的环形缓冲区：两种节奏差两个数量级，仓库负责削峰填谷。head 只有中断写、tail 只有主循环写——每个变量单一写者，加 volatile 就够，不用关中断

为什么解析不放中断里做？中断必须快进快出——解析器最坏要跑完一整帧状态机，还会调用阻塞发送回 ACK，这些都不能在中断上下文里干。收字节的归中断，动脑子的归主循环。

四、状态机解析器：代码与逐段说明

五个状态就是帧格式五个区段的镜像：

  状态     等什么      成功去哪     失败去哪
  S_HDR1   0xAA        S_HDR2      原地不动（垃圾字节直接无视）
  S_HDR2   0x55        S_LEN       见AA留下（可能是真帧头），其他回S_HDR1
  S_LEN    1~32        S_DATA      非法长度回S_HDR1（这道闸防住 data[] 溢出）
  S_DATA   收满len个   S_CRC       无失败分支（来者不拒）
  S_CRC    校验字节    通过→执行   无论过不过都回S_HDR1（丢弃式恢复）

帧执行：合法帧的唯一出口

#define FRAME_HDR1 0xAA   // 帧头第1字节：在无边界的字节流里"认出"帧的起跑线
#define FRAME_HDR2 0x55   // 帧头第2字节：双字节帧头，大幅降低随机数据误同步的概率
#define FRAME_MAX  32     // 数据域最大长度：决定 data[] 大小和长度字节的合法上限

// 谁能调用我：只有 frame_parse 的 S_CRC 分支（五关全过才轮到我）
// 参数：p=数据域首地址  len=数据域长度
// 职责：解释数据域含义并执行 + 组确认帧回传（闭环）
void frame_exec(uint8_t *p, uint8_t len)
{
    // 数据域约定格式：[命令码][参数...]
    // len>=2：至少要有"命令码+参数"两个字节，命令才有意义
    if (len >= 2 && p[0] == 0x01) {              // CMD=0x01：LED 控制
        // 板子 LED 共阳接法（3.3V→LED→510Ω→PB5），低电平才亮
        // 参数非0 → 写 RESET(低电平) 点亮；参数0 → 写 SET(高电平) 熄灭
        HAL_GPIO_WritePin(led1_GPIO_Port, led1_Pin,
                          p[1] ? GPIO_PIN_RESET : GPIO_PIN_SET);

        // ---- 组确认帧（ACK）：把收到的帧原样回传 ----
        // 发送方收到一模一样的帧 = "命令已落地"的闭环确认
        uint8_t ack[4 + FRAME_MAX];              // 栈上缓冲：4+32=36字节，装得下最长合法帧
        ack[0] = FRAME_HDR1;                     // 帧头1
        ack[1] = FRAME_HDR2;                     // 帧头2
        ack[2] = len;                            // 长度
        uint8_t crc = len;                       // 校验初值=长度字节（与发送方的约定）
        for (uint8_t i = 0; i < len; i++) {
            ack[3 + i] = p[i];                   // 数据域原样拷贝
            crc ^= p[i];                         // 边拷边异或，一趟干两件事
        }
        ack[3 + len] = crc;                      // 校验字节收尾

        // 阻塞式发送：这是主循环上下文（不是中断），等得起
        // 6字节@115200 约0.5ms发完，100ms 超时只是保险丝
        HAL_UART_Transmit(&huart1, ack, 4 + len, 100);
    }
    // 其他命令码：静默忽略（帧是合法的，只是本机不认识这个命令）
}

状态机主体

void frame_parse(uint8_t *buf, uint16_t n)
{
    typedef enum { S_HDR1, S_HDR2, S_LEN, S_DATA, S_CRC } PState;
    static PState st = S_HDR1;      // static：跨调用保留 → 帧劈成两半也能拼回
    static uint8_t data[FRAME_MAX]; // static：半成品帧的暂存区（每次清零就拼不回了）
    static uint8_t idx = 0;         // 已收数据字节数
    static uint8_t len = 0;         // 本帧数据域长度
    static uint8_t crc = 0;         // 边收边算的校验值

    for (uint16_t i = 0; i < n; i++) {         // 这批字节逐个喂进状态机
        uint8_t b = buf[i];
        switch (st) {

        case S_HDR1:                            // 状态1：扫帧头第1字节
            if (b == FRAME_HDR1) st = S_HDR2;   // 见AA → 前进一步
            // 不是AA：原地不动（重新同步的第1道闸）
            break;

        case S_HDR2:                            // 状态2：等帧头第2字节
            if (b == FRAME_HDR2)      st = S_LEN;  // AA 55 → 帧头成立
            else if (b == FRAME_HDR1) st = S_HDR2; // AA AA：这个AA可能是真帧头，
                                                   // 留在原地再等一个55
            else                      st = S_HDR1; // 前面那个AA是假帧头，回炉重扫
            break;

        case S_LEN:                             // 状态3：长度字节
            if (b > 0 && b <= FRAME_MAX) {      // 合法区间 1~32（data[] 装得下的范围）
                len = b;                       // 记住本帧数据域长度
                idx = 0;                       // 新帧新起点：计数器清零
                crc = b;                       // 校验初值=长度字节（约定）
                st = S_DATA;
            }
            else st = S_HDR1;                   // 0或>32 → 非法，丢弃重新同步
            break;

        case S_DATA:                            // 状态4：收数据域
            data[idx++] = b;                    // 存入半成品区，计数+1
            crc ^= b;                           // 边收边异或，收完校验值也算完
            if (idx == len) st = S_CRC;          // 收满 → 去校验关
            break;

        case S_CRC:                             // 状态5：对校验字节
            if (crc == b) frame_exec(data, len);// 算出的==送来的 → 合法帧，执行！
            st = S_HDR1;                        // 无论过不过都回起点：坏帧不回ACK，
            break;                              // 发送方超时重发即可（丢弃式恢复）
        }
    }
}

主循环（消费者侧）

uint8_t tmp[RXBUF_SIZE];                    // 主循环的提货筐：一次最多搬128字节
while (1)
{
    uint16_t n = rb_read(tmp, sizeof(tmp));  // 消费者：把环形缓冲区现有字节一次搬空
    if (n) frame_parse(tmp, n);             // 有货就整批喂给状态机
    HAL_Delay(10);                          // 10ms轮询节奏 = 命令响应延迟上限
}

三个关键机制

1. static 跨调用记忆：一帧 6 字节可能这批来 3 个、下批来 3 个（发送方分两次发、或主循环轮询切在中间）。状态机的进度存在 static 变量里，函数返回也不丢——帧劈开也能拼回。这是它和"一次性处理完整帧"思路的本质区别
2. AA AA 55 分支：收到 AA AA 55 时，第一个 AA 之后等来的是又一个 AA——它可能是真帧头。所以留在 S_HDR2 原地再等一个 55，而不是回 S_HDR1。没有这个分支，AA AA 55 ... 开头的帧会丢
3. 丢弃式错误恢复：CRC 不过，整帧丢弃、回 S_HDR1、不回任何东西。实现最简，且坏帧不回 ACK 本身就是信号——发送方超时没等到确认，重发即可

五、验收与踩坑

验收五连（串口助手 HEX 模式）：①开灯 AA 55 02 01 01 02→灯亮+回同帧；②关灯 AA 55 02 01 00 03→灯灭+回同帧；③坏CRC AA 55 02 01 01 99→彻底沉默；④垃圾前缀 12 34 56+好帧→重新同步成功；⑤双AA AA AA 55 02 01 01 02→第二个AA当真帧头。①②验常规通路，③④⑤专考状态机的防御分支。

实战踩过两个坑，都值得记一辈子：

• HAL_Delay 单位是毫秒：把 10ms 写成 HAL_Delay(10000)，编译零警告、逻辑全对，但命令响应延迟变成 0~10 秒随机。这类 bug 最阴险：不报错，只让系统慢得莫名其妙
• 长度判断 off-by-one：b < FRAME_MAX 会把 len=32 的满帧也拒掉（data[32] 下标 0~31，len=32 完全合法），正确写法 b <= FRAME_MAX。教训：边界值必须专门测——len=0、1、31、32、33 各来一发

另一个强烈推荐的手法：主机侧仿真测试——上真机前把解析器原样搬到 PC，HAL 调用换成记录桩（HAL_GPIO_WritePin 写个 led 变量、HAL_UART_Transmit 把字节拷进内存），本机 gcc 毫秒级跑完全部测试向量。不碰硬件、可回归、出错定位在逻辑层而不是"板子抽风"。

六、要点速记

• 串口是无边界字节流，协议帧 = 自己造边界（帧头+长度+校验）
• 双字节帧头把误同步概率降到 1/65536；长度断帧不依赖发送方时序
• 状态机五状态 = 帧格式五区段的镜像；static 让帧劈开也能拼回
• AA AA 55：S_HDR2 见 AA 留原地；长度闸门（1~32）防数组溢出
• 丢弃式恢复：坏帧不回 ACK，靠发送方超时重发；ACK 原样回传 = 闭环确认
• 收字节的归中断（快进快出），动脑子的归主循环；环形缓冲区是两种节奏之间的仓库
• 10ms 轮询 = 命令响应延迟上限；HAL_Delay 单位是毫秒
• 上真机前，主机侧仿真先跑一遍测试向量

内容来源：数电教材第一章 + STC8A8K64D4 手册，全部图表重绘 用途：数制与逻辑门速查卡片

一、数制对照表

三个要点：

• 十六进制是二进制的速记法：16 = 2⁴，一位十六进制恰好对应四位二进制——8/16/32 位二进制整齐地写成 2/4/8 位十六进制，书写程序十分简便
• 两个关键行：十进制 8 → 八进制 10（逢八进位，没有 8 这个数字）；十进制 10 → 十六进制 A（从 10 开始用字母 A~F）
• 最大值公式：n 位 b 进制的最大值 = bⁿ − 1。1111B = 15、7777O = 4095、FFFFH = 65535——嵌入式里 0xFF（8位满量程）、0xFFF（12位ADC满量程）、0xFFFF（16位上限）全是这一族

二、奇偶校验码

数据在存取、运算和传送过程中难免出错（1 错成 0、0 错成 1）。奇偶校验码 = 信息位 + 1 位校验位，让整个码字中 1 的个数凑成奇数（奇校验）或偶数（偶校验）。

• 能抓：任何 1 位翻转（1 的个数 ±1，奇偶性破坏立刻露馅）
• 抓不住：同时翻 2 位（个数 ±2 或不变，奇偶性完好——天生盲区）

嵌入式对应：串口配置里的 UART_PARITY_EVEN / ODD / NONE 就是它。代价是每字节多 1 位（12.5% 开销），且只能发现不能纠正，所以正经链路升级用 CRC。

三、三种基本逻辑运算

真值表不用死记：与 = 乘法（0 乘啥都 0）、或 = 加法（但 1+1=1）、非 = 取反。

对应 C 语言的位操作：

• 置位：P1 |= 0x10（或）
• 清位：P1 &= ~0x20（与 + 非）
• 取反：P1 = ~P1（非）

四、组合门：与非、或非、与或非

• 与非门是万能门：只用与非门一种就能拼出全部逻辑（非 = 与非(A,A)；或 = 与非(A′,B′)）。74LS00（四与非门）曾是地球上产量最大的芯片，NAND Flash 之名即源于此
• 德摩根律：(A·B)′ = A′ + B′——与非门输出端的小圆圈挪到输入端就变成或门。圆圈可以在输入/输出之间"漂移"，这是看懂和化简逻辑电路图的核心技巧
• 与或非：Y = (A·B + C·D)′，16 行真值表仅 7 行为 0（AB=11 或 CD=11 时）。典型用途：地址译码、比较器（74HC51）

五、异或与同或

异或（不同为 1）是比较器，同或（相同为 1）是相等判断器，两者互为取反。

异或的四个神技（嵌入式天天用）：

1. 翻转位：P1 ^= 0x01——按一下翻一次
2. 求奇偶：把数据位全部异或 = 偶校验位（奇偶校验本质上就是异或数奇偶）
3. 免临时变量交换：a^=b; b^=a; a^=b;（因为 A⊕A=0、A⊕0=A）
4. 半加器：A⊕B = 不带进位的和，A·B = 进位——CPU 加法器的地基

状态监测经典用法：changed = new ^ old——一行异或，变了的位全亮出来。

六、一页总览

一句话收尾：与或非是地基，与非是万能砖，异或是比较器——八种运算，一张表带走。

适用场景：串口/传感器/键盘等"数据碎片化到达"场景的裸机开发 阅读基础：了解 C 语言、中断的基本概念

0. 引子：两个世界的节奏差

串口中断接收有一个根本矛盾：

• 中断世界：字节什么时候来，由对方（发送方）决定——随时可能来，也可能一秒钟来一百个

• 主循环世界：什么时候有空处理，由程序逻辑决定——可能正在刷屏、算滤波、睡觉

115200 波特率下每个字节间隔约 87µs，72MHz 的 CPU 在这 87µs 里能执行约 6000 条指令。如果让 CPU 死盯串口（轮询），这 6000 条指令全浪费；如果主循环去干别的，字节来了没人管，下一个字节一到就把上一个挤丢（硬件溢出 ORE）。

环形缓冲区就是两个世界的"时差消化器"：中断是快递员（只管把包裹塞进快递柜，几微秒走人），主循环是收件人（有空时一次性取走所有包裹慢慢拆），缓冲区是快递柜，丢包计数器是登记簿

1. 为什么是"环形"

普通数组当缓冲区有两条死路：

• 写到头就停 → 空间浪费一半

• 写到头搬回开头 → 每次搬移 O(n)，CPU 干无用功

环形的答案：两个下标各自前进、互不等待，数组用完就绕回开头——一条首尾相接的传送带：

        ┌──▶ [0][1][2][3][4][5][6][7] ──┐
        │      ↑tail          head↑     │
        └────────── 绕回开头 ─────────────┘

• rxHead（写下标）：数据往哪存，只有生产者（中断）动它

• rxTail（读下标）：数据从哪取，只有消费者（主循环）动它

• 存一个字节 head 前进一步，取一个字节 tail 前进一步，追上对方就停

2. 三件套与三个精妙设计

2.0 数据与下标定义

#define RXBUF_SIZE 128                     // 2 的幂：可用 & (RXBUF_SIZE-1) 代替 % 取模（单周期）
uint8_t  rxbuf[RXBUF_SIZE];                // 存储区
volatile uint16_t rxHead = 0;              // 写下标：只有中断动它
volatile uint16_t rxTail = 0;              // 读下标：只有主循环动它
volatile uint32_t rxErr = 0;               // 丢包账本：满了没挤进来的字节数

2.1 设计一：牺牲一格——区分"满"和"空"

最坑的问题：head == tail 到底是"空"还是"满"？两种状态长得一模一样！

解法：宁可少用一个格子——留一格空作为"满"的标志：

• 空：rxHead == rxTail（两者重合）

• 满：(rxHead + 1) % RXBUF_SIZE == rxTail（还差一格重合）

128 格的缓冲区有效容量是 127。用一格容量换一个无歧义的状态判断，值。

2.2 设计二：count 用公式算——派生量不另存

// 当前存量字节数
uint16_t rb_count(void)
{
    return (rxHead - rxTail + RXBUF_SIZE) % RXBUF_SIZE;
}

两个细节：

为什么要 +RXBUF_SIZE 再取模？ 环形回绕后 head 可能数值上小于 tail（比如 head=5、tail=120），直接相减得 -115；加上 128 再取模得 13，才是真实存量。C 语言负数取模还是负数，这一步是环形计算的标配。

为什么不用 count 变量存着、每次加减？ 因为 count 会被两边（生产/消费）同时维护——两个写者 = 竞态 = 会漂移的死账本。能从现有状态推导出来的量，永远不要另存一份（单一事实来源原则）。

2.3 设计三：volatile + 单一写者——不加锁的秘密

两层保护各管一件事：

• volatile 管"看得见"：禁止编译器把读优化成寄存器缓存。没有它，主循环可能永远读不到中断更新后的值——嵌入式三大玄学 bug 之一（症状：加 printf 就好了、开 -O0 就好了）

• 归属权管"不打架"：每个下标只有一个写者，不存在写冲突

这就是这套代码全程不用关中断的原因。

3. 完整架构与代码

3.1 数据流全景

【生产者：中断世界】               【缓冲区】              【消费者：主循环世界】
电脑串口发字节                     ┌────────────┐        while(1)
  → RX 引脚 → 移位寄存器 → DR      │  rxbuf[128] │          ├─ rb_read(tmp,128) 批量取
  → RXNE=1 → 中断                  │  rxHead 写下标│◄─中断写  ├─ 逐字节处理（回显/解析）
  → HAL 读 DR → 回调               │  rxTail 读下标│◄─主循环写 ├─ 报账（buf/err）
    ├─ 有空位：存 + head++        │  rxErr 总账本 │          └─ HAL_Delay(10)
    ├─ 满了：rxErr++（丢新）      └────────────┘
    └─ 挂下一单 Receive_IT
  → 中断退出（全程几微秒）

3.2 中断侧：回调三件事（存、记、挂）

uint8_t rxbyte;   // HAL 的落地字节

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    if (huart->Instance == USART1) {
        uint16_t next = (rxHead + 1) % RXBUF_SIZE;
        if (next != rxTail) {                      // 没满：写入
            rxbuf[rxHead] = rxbyte;
            rxHead = next;
        } else {                                   // 满了：进不来（丢新策略），记一笔账
            rxErr++;
        }
        HAL_UART_Receive_IT(huart, &rxbyte, 1);    // 挂下一单（不断链）
    }
}

三个细节：

• 挂单不能忘：HAL_UART_Receive_IT 是"一单制"——收完这单就结束，回调里不续挂，链路就断（症状：只响应第一个字节，之后任你怎么发都装死）

• 中断快进快出：三件事加起来几微秒，这是中断的铁律

• rxErr 记账：丢可以（策略决定），但必须数出来——无声丢数据是最恶劣的 bug

3.3 消费者侧：批量读 + 排空式消费

// 批量读：最多取 n 个字节放进 buf，返回实际取到的个数（0 = 空）
uint16_t rb_read(uint8_t *buf, uint16_t n)
{
    uint16_t avail = (rxHead - rxTail + RXBUF_SIZE) % RXBUF_SIZE;
    if (n > avail) n = avail;              // 要 100 只有 30 就只给 30，不越界
    for (uint16_t i = 0; i < n; i++) {
        buf[i] = rxbuf[rxTail];
        rxTail = (rxTail + 1) % RXBUF_SIZE;
    }
    return n;
}

// 主循环
uint8_t tmp[RXBUF_SIZE];
while (1)
{
    uint16_t n = rb_read(tmp, sizeof(tmp));    // 排空式：有多少取多少
    for (uint16_t i = 0; i < n; i++) {
        // 逐字节处理（回显 / 喂协议解析器 / 执行命令）
    }
    HAL_Delay(10);                            // 轮询周期 = 响应延迟上限
}

为什么必须批量读：如果主循环每次只取 1 个字节就去睡觉，积压 8 个字节要 8 个周期才消费完（睡 2 秒的话要 16 秒）。批量取让"消费速率"和"到达速率"彻底解耦——睡觉时中断照样收货，醒来一口气处理完。

4. 丢包策略：丢新 vs 丢旧

缓冲区满了怎么办？两种相反的策略：

丢旧的实现与代价：

// 进阶变体：丢旧不丢新
void rb_put_old(uint8_t c)                    // 中断里调用
{
    uint16_t next = (rxHead + 1) % RXBUF_SIZE;
    if (next == rxTail) {                     // 满了
        rxTail = (rxTail + 1) % RXBUF_SIZE;   // 中断里挤掉最老的（中断改 rxTail 不会被主循环插队，安全）
        rxErr++;
    }
    rxbuf[rxHead] = c;                        // 无论如何都写入
    rxHead = next;
}

int rb_get_old(void)                          // 主循环里调用
{
    if (rxTail == rxHead) return -1;
    uint8_t c = rxbuf[rxTail];
    __disable_irq();                          // ★ 丢旧策略的代价：读方更新 rxTail 要关中断
    rxTail = (rxTail + 1) % RXBUF_SIZE;       //   否则会被中断的"挤掉"动作覆盖掉
    __enable_irq();
    return c;
}

选型口诀：命令流要最新 → 丢旧；协议帧 → 加大缓冲区，靠 err 发现不够用。

5. 错误账本：可观测性

丢包有两种来源，都要记账：

// 硬件错误回调：溢出等错误发生时 HAL 会终止接收，这里记账 + 重新挂单自愈
void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
{
    if (huart->Instance == USART1) {
        rxErr++;
        HAL_UART_Receive_IT(huart, &rxbyte, 1);
    }
}

没有 ErrorCallback 的后果：一次溢出后 HAL 静默终止接收，串口从此"装死"，直到重新上电。

一个数字看链路健康度：err=0 一切正常；err 涨了，要么缓冲区不够大，要么中断里干活太慢。

6. 同一个原子操作的三张面孔

"取一个字节"的两行核心（取数 + 下标前移），包装成三种接口：

// 面孔一：取一个，空返回 -1（轮询式消费）
int rb_get(void) { /* 判空 → 取 → tail++ → 返回 */ }

// 面孔二：取一批，返回实际个数（排空式消费）
uint16_t rb_read(uint8_t *buf, uint16_t n) { /* ... */ }

// 面孔三：取一个，空就等（阻塞式，scanf/getchar 的入口）
int __io_getchar(void)
{
    while (rxTail == rxHead) { }         // 空：原地等（中断会把字节放进来）
    uint8_t c = rxbuf[rxTail];
    rxTail = (rxTail + 1) % RXBUF_SIZE;
    return c;
}

基础原子学扎实，三种包装随手就来。

7. 实验验证（现象即证据）

8. 三个反面案例（读别人代码时的找茬题）

真实项目的环形缓冲区常见三个坑，读代码时值得带着怀疑去找：

① 命名撒谎：函数叫 isEmpty，返回 1 却表示"有数据"——所有调用处都得写 == 0 才敢用。命名的诚实度就是代码的可维护性。

② count 死账本：写方和读方都维护 count 变量（两个写者 = 竞态 = 漂移），结果查询函数干脆不用它、用公式重算。派生量别另存——本文 2.2 节从第一天就做对了。

③ 腾位不用：丢旧实现里满了挤掉一个老字节后直接 return——当前字节也没写进去。持续过载时效果是"丢一个旧、丢一个新、再收一个"约丢一半，新旧交错。读代码时自己推演一遍边界行为，是最好的练习。

9. 扩展视野

• 2 的幂优化：% RXBUF_SIZE 换成 & (RXBUF_SIZE-1)——与指令单周期，除法指令要多周期。取模对任何大小都能用，2 的幂的真正好处是这个位运算技巧

• 多实例化：把下标打包成结构体、缓冲区由 init 传入（数据与控制器分离），一套代码实例化 N 个队列（多串口各收发一个）

• 发送也进队列：send 只塞 TX 缓冲区，TXE 中断慢慢搬——非阻塞发送

• DMA + 环形缓冲：DMA 往缓冲区搬字节，CPU 只管处理——性能天花板

• 现实世界：操作系统内核、网络协议栈、键盘缓冲、音频缓冲——全是这一套

10. 总结

一句话收尾：环形缓冲区是嵌入式世界的万能骨架——中断是快递员，缓冲区是快递柜，主循环是收件人，err 是登记簿。

一、编译成功的标志：size 汇总

make 输出的最后一行是 size 汇总，看到它就代表编译、链接全部通过：

text    data     bss     dec     hex filename
   4736      12    1644    6392    18f8 build/uart.elf

三个关键数的读法：

这三个数就是程序对 512KB Flash / 64KB SRAM 的占用量

二、elf / hex / bin / map：一次编译全出

CubeMX Makefile 的 all 目标是 elf + hex + bin 三件套一起出，编译完去 uart/build/ 目录就能看到（连同 map 共四样）：

三、调试：F5 全流程

先编译，再调试

Ctrl+Shift+B 编译。云端 launch.json 没配 preLaunchTask，F5 不会自动编译——改了代码直接 F5、现象没变，99% 是忘了编译（烧的还是旧 elf）。

启动与自动流程

• F5 → 第一次会让你选调试配置，选 Remote openocd (frp)（之后记住选择不再问）

• 自动流程：连隧道 → 复位 → 烧录 → 停在 main 入口

常用操作

左侧三个面板：

• VARIABLES — 局部/全局变量实时值

• WATCH — 右键变量 → Add to Watch

• CALL STACK — 调用堆栈

DEBUG CONSOLE 里可以直接输表达式读寄存器，比如看 GPIOA 输出寄存器：

p/x *(volatile unsigned int*)0x4001080C

外设寄存器图形面板（CORTEX PERIPHERALS）目前 launch.json 还没配 svdFile，可能为空——用控制台表达式读完全够用，想图形化加一行配置即可。

两个正常现象

1. 断点暂停 = 芯片被 halt，串口停发 abc；F5 继续后恢复

2. 调试会话独占 openocd——F5 期间跑 flash-remote.sh 会连不上，先 Shift+F5 退出

一、CubeMX 参数配置详解

在 CubeMX 的 USART1 配置页中，核心参数如下：

逐项原理说明：

• Baud Rate（波特率）：每秒传输的比特数。115200 是嵌入式最常用速率，由 BRR 寄存器分频得到：BRR = f_PCLK / 波特率（USART1 挂 APB2 = 72MHz，72000000/115200 = 625，无误差）。
• Word Length（字长）：一个数据帧的数据位长度。注意 HAL 的 8B 是"含校验位"的——若开启奇偶校验，实际有效数据只有 7 位；无校验时才是完整 8 位。
• Parity（校验）：None / Even（偶校验）/ Odd（奇校验）。无校验最常用；开启后校验位占用数据帧一位。
• Stop Bits（停止位）：帧尾电平保持时间，1 位最常用（0.5/1/1.5/2 可选）。
• Data Direction（模式）：TX_RX 同时使能发送与接收（对应 CR1 寄存器的 TE、RE 位）。
• Over Sampling（过采样）：16 倍过采样对每位采样 16 次取多数，抗干扰强，是默认推荐；8 倍过采样可支撑更高波特率但容错差。

一帧完整格式：起始位(1) + 数据位(8) + 校验位(0) + 停止位(1)，即 115200-8-N-1。

二、CubeMX 生成的初始化代码

usart.c 中的核心结构体与初始化函数：

UART_HandleTypeDef huart1;

void MX_USART1_UART_Init(void)
{
  huart1.Instance           = USART1;
  huart1.Init.BaudRate      = 115200;
  huart1.Init.WordLength    = UART_WORDLENGTH_8B;
  huart1.Init.StopBits      = UART_STOPBITS_1;
  huart1.Init.Parity        = UART_PARITY_NONE;
  huart1.Init.Mode          = UART_MODE_TX_RX;
  huart1.Init.HwFlowCtl     = UART_HWCONTROL_NONE;
  huart1.Init.OverSampling  = UART_OVERSAMPLING_16;
  HAL_UART_Init(&huart1);
}

结构体字段与硬件的对应关系：

HAL_UART_Init() 内部依次完成：参数校验 → 调用 HAL_UART_MspInit()（CubeMX 生成在 usart.c 底部：使能 USART1 与 GPIOA 时钟、配置 PA9/PA10 复用推挽）→ 按 Init 结构体写入 CR1/CR2/CR3/BRR → 使能外设。

为什么代码里看不到 RCC 和 GPIO 配置？ 因为 CubeMX 把"芯片级初始化"（时钟使能、引脚复用）拆进了 HAL_UART_MspInit()，与"协议参数配置"（MX_USART1_UART_Init()）分离——前者管硬件资源，后者管通信格式，各司其职。

三、HAL_UART_Transmit 发送函数

HAL_StatusTypeDef HAL_UART_Transmit(
    UART_HandleTypeDef *huart,  // 串口句柄
    uint8_t *pData,             // 数据指针
    uint16_t Size,              // 数据长度
    uint32_t Timeout            // 超时(ms)
);

工作流程（阻塞式发送）：

1. 逐字节把数据写入 DR（数据寄存器）
2. 等待 TXE（发送数据寄存器空）标志，再写下一字节
3. 全部写完后等待 TC（发送完成）标志
4. 期间用 Timeout 计数，超时则放弃并返回 HAL_TIMEOUT

返回值：

使用示例：

uint8_t msg[] = "Hello USART1\r\n";
HAL_UART_Transmit(&huart1, msg, sizeof(msg) - 1, 100);  // 100ms 超时

要点：

• 阻塞式发送——CPU 停在函数里等硬件搬完，期间不能干别的；大数据量场景应改用中断（HAL_UART_Transmit_IT）或 DMA 版本。
• sizeof(msg) - 1 减掉字符串末尾的 \0，串口不需要发它。
• 发送速率由波特率决定：115200bps 下每字节约 87μs，发 100 字节约 8.7ms。

一、六个标准问题

① 挂哪条总线

USART1 挂 APB2（72MHz）。

回顾：F103 有三个 USART（大容量 ZET6 有 USART1/2/3 + UART4/5），总线分配不同：

USART1 是唯一挂在 APB2 的串口，时钟直接 72MHz，不需要倍频补偿，波特率计算最精确。这也是为什么调试串口首选 USART1。

② 时钟来源与特殊倍频

HSE 8MHz → PLL×9 → SYSCLK 72MHz
                              → HCLK 72MHz
                                  → PCLK2 72MHz（APB2 不分频）
                                      → USART1 72MHz

USART1 时钟 = PCLK2 = 72MHz，无倍频、无分频，直接用。

对比：USART2/3/4/5 挂 APB1，PCLK1=36MHz，波特率计算时基准时钟是 36MHz。

③ 门控开关

USART1 的时钟使能位在 RCC_APB2ENR 的 bit14（USART1EN）：

RCC_APB2ENR |= RCC_APB2ENR_USART1EN;  // 开 USART1 时钟

同时，USART1 用 PA9/PA10，GPIOA 也要开：

RCC_APB2ENR |= RCC_APB2ENR_IOPAEN;    // 开 GPIOA 时钟

配电箱比喻：

总闸 SYSCLK 72MHz
  └─ 分闸 APB2ENR（72MHz 母线）
       ├─ IOPAEN  → GPIOA 房间（PA9/PA10 引脚）
       └─ USART1EN → USART1 房间（波特率发生器/收发器）

两个开关都要开，缺一不可：GPIO 负责引脚电平物理输出，USART 负责协议帧时序。

④ CubeMX 中对应配置

CubeMX 中配置 USART1 非常简单，大部分参数 CubeMX 自动处理：

注意：GPIOA 的时钟使能（IOPAEN）在 CubeMX 界面无可见开关，选了 PA9/PA10 后自动推断生成。这和你学 GPIO 时 IOPBEN 不可见是同样的道理。

⑤ 寄存器参数（USART 核心寄存器）

USART 外设核心寄存器就几个，理解这 5 个就够：

波特率计算公式（异步模式）：

波特率 = fPCLK / (16 × DIV)

其中 fPCLK = 72MHz（USART1），DIV = BRR 里的分频值（整数+小数，共12位整数+4位小数）。

以 115200 为例：

DIV = 72000000 / (16 × 115200) = 39.0625
整数部分 = 39 = 0x27
小数部分 = 0.0625 × 16 = 1 = 0x1
BRR = 0x271

CubeMX 填 115200 后自动算好写进 BRR，不用手算。但原理要知道。

⑥ 硬件行为（数据从发送到接收的完整链路）

发送链路（STM32 → 电脑）：

写 DR 寄存器
  → 移位寄存器逐位输出
    → TX 引脚(PA9) 按协议帧输出 TTL 电平
      → CH340K 收到 TTL 信号，转成 USB 协议
        → USB 线传到电脑
          → 电脑端 CH340 驱动转为虚拟 COM 口
            → 串口助手软件显示数据

接收链路（电脑 → STM32）：

串口助手发送数据
  → 电脑 USB → CH340K
    → CH340K 转 TTL → PA10(RX) 引脚
      → USART1 接收移位寄存器逐位采样
        → 收满一帧 → 数据写入 DR
          → 置 RXNE 标志 → 可读 DR 获取数据

二、CH340K 连接电路（TX/RX 交叉）

这是最容易接错的地方，务必记住：TX→RX，RX→TX，交叉连接。

STM32                CH340K
PA9  (USART1_TX) ──→ RXD
PA10 (USART1_RX) ←── TXD
GND ─────────────── GND    （共地！必须接）

为什么必须交叉？TX 是输出，RX 是输入。如果 TX→TX，两个输出对冲，谁也收不到数据。就像打电话，你的嘴（TX）要对对方的耳朵（RX），不可能嘴对嘴。

你开发板上 CH340K 和 STM32 已经在 PCB 上固定连好了（PA9→CH340 RX、PA10→CH340 TX、共地），用一根 USB 线接电脑即可，不用飞线。

三、完整挂载使能总链路图

把六层串起来，这是整个 USART1 的全景：

Cortex-M3 内核
  │
  ▼ SYSCLK = 72MHz（HSE 8MHz × PLL9）
  │
  ▼ HCLK = 72MHz
  │
  ▼ PCLK2 = 72MHz（APB2，不分频）
  │
  ├── RCC_APB2ENR.IOPAEN ───→ GPIOA 使能
  │                                ├── PA9  → 复用推挽输出（USART1_TX）
  │                                └── PA10 → 浮空/上拉输入（USART1_RX）
  │
  └── RCC_APB2ENR.USART1EN ─→ USART1 使能
                                   ├── BRR  = 0x271（115200bps）
                                   ├── CR1  = UE|TE|RE（使能+收发）
                                   ├── SR.TXE → 发送缓冲空，可写 DR
                                   ├── SR.RXNE → 接收缓冲有数据，可读 DR
                                   └── DR  → 读写数据
                                        │
                                        ▼
                                   PA9/PA10 引脚电平变化
                                        │
                                        ▼
                                   CH340K（TTL↔USB）
                                        │
                                        ▼
                                   电脑 USB → 虚拟 COM → 串口助手

四、PA9/PA10 的 GPIO 模式

USART 用的是复用功能（AF），GPIO 模式和普通 IO 不同：

关键理解：一旦开启 USART 的 TE（发送使能），PA9 的输出控制权就从 GPIO 模块移交给了 USART 外设，此时写 GPIO_ODR 无效，数据要写 USART_DR 才会从 PA9 发出。这就是"复用"的含义——引脚被外设"借用"了。

CubeMX 中你只需选 PA9 = USART1_TX、PA10 = USART1_RX，GPIO 模式自动配好，不用手动设。

好问题，这正是理解 STM32F1 架构的关键点。RCC 的位置其实有"两个身份"，很多人混淆就在这里。

一、RCC 到底在哪一层？——双重身份

物理上：RCC 是挂在 AHB 总线上的一颗"外设"

• 地址 0x40021000，有自己的寄存器组（CR、CFGR、AHBENR、APB1ENR、APB2ENR...）

• 和 DMA、SDIO、CRC 一样是 AHB 总线上的成员

逻辑上：RCC 是整个芯片的"时钟分发中心"（中枢）

• 它决定 SYSCLK 来源（HSI/HSE/PLL）、各总线分频（HCLK/PCLK1/PCLK2）

• 它掌管每个外设的时钟使能（门控开关）——不开就点不亮

特殊性：RCC 是唯一不需要别人给它开时钟的外设。上电后芯片默认用 HSI 8MHz 直接运行，RCC 自己就能工作，然后它再去"点亮"其他所有人。所以它既是"外设"，又是所有外设依赖链的第一环。

             Cortex-M3
                │
        SYSCLK（系统时钟）
                │
     ┌──────────┴──────────┐
     │   AHB 总线 (72MHz)   │
     └──┬──────┬─────┬─────┘
        │      │     │
     ┌──▼──┐ ┌▼───┐ ┌▼────────────┐
     │ DMA │ │SDIO│ │ RCC ◄──── 时钟中枢 │
     │ CRC │ │Flash│ │(自己先跑起来，再发   │
     └─────┘ └────┘ │ 时钟给所有外设)    │
                    └──────┬───────────┘
              ┌────────────┼────────────┐
        ┌─────▼─────┐ ┌────▼─────┐
        │ APB2 总线  │ │ APB1 总线 │
        │ (72MHz)   │ │ (36MHz)  │
        └───────────┘ └──────────┘

二、F1 时钟树：RCC 输出哪些时钟

HSE 8MHz ──────┐
               ├─→ PLL(×9) ──→ SYSCLK 72MHz ──→ HCLK 72MHz
HSI 8MHz ──────┘                 │                 │
                          ┌──────┴──────┐   ┌──────┴──────┐
                          │ APB1 分频 /2 │   │ APB2 分频 /1 │
                          ▼             ▼   ▼             ▼
                     PCLK1 = 36MHz  PCLK2 = 72MHz
LSE 32.768KHz ──→ RTC（独立于总线）
LSI 40KHz ──────→ IWDG（独立于总线）
PLL ─────────────→ USB 48MHz（专门输出）

三、各外设挂在哪个总线（F1 特例注意！）

APB2（高速 72MHz）——注意 F1 的 GPIO 在 APB2（F4 在 AHB1，别混）：

APB1（低速 36MHz）：

AHB（72MHz）：DMA1/2、SDIO、CRC、Flash 接口

独立时钟源（不经过总线）：IWDG←LSI、RTC←LSE/LSI

四、各外设完整依赖链（重点）

每个外设不是"开自己的时钟就行"，它的完整依赖链如下（★=必须，☆=可选）：

1. GPIO（最基础）

★ RCC 使能 GPIOx 时钟 → ★ 配置 MODER/OTYPER/PUPDR → (无 AFIO/NVIC)

只依赖 RCC，这就是为什么它排在阶段 1 最前。

2. AFIO（复用接线员）

★ RCC 使能 AFIO 时钟 → ★ 配置复用重映射

依赖 RCC；它本身是 GPIO"切换成外设功能"的桥梁。

3. EXTI 外部中断

★ RCC 使能 AFIO（EXTI 源选择在 AFIO 里）
★ GPIO 配输入模式
★ 配置 EXTI 线路 + 边沿
★ NVIC 使能 + 优先级

依赖：RCC + GPIO + AFIO + NVIC（四层全占）。

4. USART1（阶段 2）

★ RCC 使能 USART1（APB2）
★ RCC 使能 GPIOA
★ PA9/PA10 配置复用（AFIO）
★ 配置波特率/数据位
☆ NVIC（中断接收）
☆ DMA（DMA1_CH4=TX、CH5=RX）

依赖：RCC + GPIO + AFIO +（NVIC/DMA）。

5. TIM（阶段 3）

★ RCC 使能 TIMx
★ 配置 PSC/ARR/计数模式
☆ GPIO 复用（PWM 输出、输入捕获、编码器才需要）
☆ NVIC（定时中断）

基础定时只依赖 RCC；输出功能再加 GPIO。

6. ADC（阶段 7）

★ RCC 使能 ADCx（APB2）
★ RCC 使能 GPIO（模拟输入模式！）
★ ADC 时钟分频（APB2 72MHz → ADC ≤14MHz，如 /6=12MHz）
★ 校准 → 配置通道/采样时间
☆ DMA（ADC1→DMA1_CH1，多通道必备）

注意：模拟输入引脚不能配推挽/复用，要配 Analog 模式。

7. SPI（阶段 5）

★ RCC 使能 SPIx
★ RCC 使能 GPIO（PA5~7 或 PB13~15）
★ 复用功能配置
★ 配置速率/CPOL/CPHA
★ CS 用普通 GPIO 软件控制（F1 硬件 NSS 常不用）

8. I2C（阶段 6）

★ RCC 使能 I2Cx（APB1）
★ RCC 使能 GPIOB（PB6/7）
★ 复用**开漏**输出（I2C 特殊性！）
★ 上拉（内部或外部）

9. DMA（阶段 4）

★ RCC 使能 DMA1/2（AHB）
★ 配置通道/方向/源/目的/模式
☆ NVIC（传输完成中断）

DMA 自身只依赖 RCC，但它的意义是服务 USART/ADC/SPI，所以放在它们前面学。

10. CAN / USB（阶段 11/12，协议级）

CAN：★ RCC(CAN1) ★ GPIO(PA11/12 复用) ★ 波特率/滤波器 ★ 外部收发器 TJA1050
USB：★ RCC(USB) ★ PLL 输出 48MHz ★ GPIO(PA11/12 复用) ★ NVIC ★ USB 协议库

USB 是唯一额外要求"PLL 同时输出 48MHz"的外设，时钟配置最特殊。

11. RTC / IWDG（阶段 9/10，备份域与独立源）

RTC：★ RCC(PWR+BKP) → ★ 解锁备份域写保护(DBP) → ★ LSE 32.768KHz → ★ 配置分频
IWDG：★ 直接用 LSI，不开任何总线时钟（写保护解除即可）

五、一张图看懂"谁依赖谁"

              RCC（时钟中枢，第一环）
              │
     ┌────────┼──────────────────┐
     ▼        ▼                  ▼
   GPIO    AFIO ←──GPIO的复用功能──┐
     │        │                  │
     ▼        ▼                  │
   EXTI ←──NVIC←──所有中断的入口──┤
     │                           │
     ▼                           ▼
  USART/TIM/ADC/SPI/I2C/CAN/USB   DMA（服务它们的数据搬运）
     │                           │
     └──────────┬────────────────┘
                ▼
        综合项目（全部串联）

关键结论：

1. RCC 在 AHB 上，但它是时钟中枢——所有外设的第一依赖

2. GPIO + AFIO + NVIC 是三大公共前置——几乎所有通信/中断外设都要先过这三关

3. DMA 只依赖 RCC，但服务于外设——所以它早学（阶段 4），因为 USART/ADC/SPI 后面都要用

4. IWDG/RTC 是"独立王国"——不依赖总线时钟，学的时候不用管 RCC

这也正好解释了目录顺序为什么是 RCC→GPIO→AFIO→SysTick→EXTI→NVIC，先把公共前置全部打通，后面的外设实验就只剩"该外设自己的参数配置"了。

本课目标（2.2 PWM 呼吸灯）

• 理解 PWM：占空比 = CCR ÷ ARR，频率 = 时钟 ÷ (PSC+1) ÷ (ARR+1)

• 用定时器通道输出 PWM，用改变 CCR 的办法让 LED 平滑地“亮→暗→亮”

• 验收标准：LED 亮度连续变化、不闪烁（仿真里用逻辑分析仪看 PA1 波形更直观）

概念：呼吸灯是怎么“骗”过眼睛的

LED 其实是在快速开关，只是开关太快人眼看不出来。亮的时间占一个周期的比例叫占空比：占空比 0% = 全灭，100% = 全亮，50% = 半亮。呼吸灯就是让占空比从 0 慢慢加到 100%，再慢慢减回 0%。

• ARR（Period）决定周期：一个周期数多少个计数

• CCR（Pulse）决定占空比：一个周期里高电平多少个计数

• 在 8MHz、PSC=79、ARR=999 下，PWM 频率 = 8M÷80÷1000 = 100Hz，人眼完全看不出闪

② 三段式记忆（和 EXTI 完全同构）：

定时器版：  TIM2_IRQHandler → HAL_TIM_IRQHandler → HAL_TIM_PeriodElapsedCallback
按键版：    EXTI15_10_IRQHandler → HAL_GPIO_EXTI_IRQHandler → HAL_GPIO_EXTI_Callback
结构：      硬件入口 → HAL 中转 → 你的回调

记住一个模板，两个外设都通：

xxx_IRQHandler 是入口（Cube 生成），HAL_xxx_IRQHandler 是公共处理（清标志），HAL_xxx_Callback 是你干活的地方。

③ 几个容易混的点：

• Base：表示"基础计时"，只数数不用 PWM 通道；以后学 PWM 是 HAL_TIM_PWM_Start；

• IT：Interrupt 的缩写，代表"中断方式"。还有不带 IT 的版本：

  • HAL_TIM_Base_Start() = 只启动计数，不产生中断（轮询用）；

  • HAL_TIM_Base_Start_IT() = 启动计数 + 开中断；

• PeriodElapsed = "周期流逝/到点"——定时器数满一圈那一刻。以后串口还有 HAL_UART_RxCpltCallback（接收完成），都是"事件 + Callback"。

④ 一句话口诀：

启动用 Start_IT，入口找 IRQHandler，干活进 PeriodElapsedCallback；
定时器 = TIM + 事件名 + Callback，和按键中断同一套骨架。