【5】嵌入式基础知识回顾 | 立创开发板技术文档中心

一本章简介

在正式拿起电烙铁或敲下第一行 STM32 代码之前，我们有必要先把基础知识重新梳理一遍。嵌入式开发不是单纯的软件编程，也不是单纯的电路连接，它横跨了 C 语言、计算机组成、数字电路和模拟电路等多个领域。如果你不理解二进制，就很难看懂寄存器手册；如果你不理解欧姆定律，就很难判断一个 LED、电机或传感器电路是否安全。

本章的任务不是重新讲一遍 C 语言和电路理论，而是把后续教程中常用、容易遗忘、容易出问题的基础知识集中回顾一遍。我会以天空星核心板（STM32F407VET6）为切入点，把这些知识放回真实工程场景中：为什么 HAL 库里大量使用 uint32_t，为什么寄存器操作离不开位运算，为什么 GPIO 不能随便带大负载，为什么电源旁边总有一排电容。

NOTE

本章内容较多，涵盖了进制转换、C 语言工程化技巧、电路基础和电源架构等多个方面。这里的定位是回顾和建立工程直觉，不是深挖语言标准或电路推导。如果你是有经验的工程师，可以快速浏览，重点关注与 STM32 相关的工程实践部分；如果你是初学者，建议通读一遍，遇到不理解的地方先留个印象，等学到后面 GPIO 或串口章节时再回来翻阅。

本章可以按下面的方式阅读：

读者情况	建议阅读方式	重点关注
刚入门	先通读，不要求一次记住所有公式和语法	进制、定宽整数、位操作、电压电流
有 C 语言基础	重点看嵌入式相关差异	`volatile`、指针访问寄存器、结构体对齐、存储区域
有硬件基础	快速浏览电路常识，重点看 STM32 关联点	GPIO 驱动能力、上拉下拉、LDO/DC-DC、原理图追踪
已经做过项目	当作检查清单	类型选择、功耗发热、保护电路、调试思路

1.1 学习目标

序号	学习目标	重要程度
1	掌握二进制、十六进制与十进制的转换逻辑，能一眼看出 `0x55` 对应的位状态	⭐⭐⭐⭐⭐
2	熟练掌握宏定义、结构体、指针、`volatile` 等在 HAL 库中大量使用的 C 语言语法	⭐⭐⭐⭐⭐
3	深刻理解位操作中【置 1】与【清 0】的底层原理，这是操作单片机寄存器的基本功	⭐⭐⭐⭐⭐
4	建立电源、地、信号、电流方向、共地这些最基础的硬件直觉，能避免常见接线错误	⭐⭐⭐⭐⭐
5	掌握欧姆定律、电容滤波、二极管保护及 MOS 管开关特性，为看懂原理图打基础	⭐⭐⭐⭐
6	了解 LDO 与 DC-DC 的区别，明白天空星学习板是如何从 8~24V/5V 得到 5V 和 3.3V 的	⭐⭐⭐⭐
7	理解 STM32 的存储架构（Flash vs RAM），知道变量存在哪里、为什么会栈溢出	⭐⭐⭐⭐
8	能看懂基本的原理图符号，学会追踪网络标号来定位引脚连接关系	⭐⭐⭐

1.2 重点提示

不要试图死记硬背：本章内容很多，如果遇到不理解的，可以先留个印象，等学到后面 GPIO 或串口章节时，再回来翻阅。这些知识是工具，用到的时候自然就记住了，实在记不得就问问各种AI工具吧。
重视 volatile 和指针：在嵌入式中，这两者直接影响程序能否稳定访问外设、中断变量和内存地址。很多初学者遇到的程序跑飞问题，根源就在这里。
关注功率与电压等级：天空星核心板主要工作在 3.3V，误接 5V 到非 5V 容忍引脚可能导致芯片损毁。在后续的 [8]认识GPIO 章节中会详细介绍哪些引脚支持 5V 容忍。
位操作是寄存器编程的灵魂：后续几乎每一章都会用到【置 1】与【清 0】操作，本章务必理解透彻。
电路基础不是选修课：即使你只做软件开发（嵌入式纯软），理解基本的电路知识也能帮你快速定位硬件问题，避免【明明代码没错，但板子就是不工作】的尴尬，当软硬件都是你一个人做的时候，你也没得甩锅了。
纯初学者先保证不烧板：虽然筑基学习板上面做了很多的保护，但希望你不确定某个接口能不能接、某个电压能不能输入、某个负载能不能驱动时，先停下来查原理图和引脚分配表。学习阶段不要把继电器接到市电，筑基学习板的继电器实验建议只连接 36V 以下直流电。

1.3 基础概念与术语

本节给出本章和后续章节会反复出现的术语标准定义。每个条目都按【中文名（英文缩写，英文全称）→ 一句话准确定义 → 在 STM32 中的位置】这个结构组织，便于查阅。

1.3.1 数据与编码

位（Bit）：二进制的最小单位，取值 0 或 1。
字节（Byte）：8 位二进制，可表示 0~255 或 -128~+127。
半字（Half Word）：16 位二进制，对应 uint16_t / int16_t。
字（Word）：在 ARM Cortex-M 体系中指 32 位，对应 uint32_t / int32_t，是 F407 寄存器的标准位宽。
二进制（BIN, Binary）：以 2 为基数的计数系统，每位取值 0 或 1。
十六进制（HEX, Hexadecimal）：以 16 为基数的计数系统，每 4 位二进制对应 1 位十六进制（0~9/A~F），用于紧凑表达寄存器值，前缀 0x。
八进制（Octal）：以 8 为基数的计数系统，C 语言中以前导 0 表示（如 0123），现代嵌入式很少使用，但要警惕不要无意写出，否则可能会出现长时间折磨你的BUG。
MSB / LSB（Most / Least Significant Bit）：最高有效位 / 最低有效位。例如 0xA5 = 1010 0101 中 bit7 是 MSB、bit0 是 LSB。
大端 / 小端（Big-Endian / Little-Endian）：多字节数据在内存中的字节排列顺序。STM32 采用小端：低字节存储在低地址。
有符号 / 无符号（Signed / Unsigned）：是否使用最高位作为符号位。有符号整数用补码表示。
原码 / 反码 / 补码（Sign-Magnitude / One's / Two's Complement）：三种带符号整数表示方法，计算机硬件实际使用补码。
整型提升（Integer Promotion）：C 语言运算时小于 int 的整型会被自动提升到 int 参与运算，是嵌入式位操作的常见陷阱来源。

1.3.2 处理器与总线

ARM Cortex-M4：天空星核心板用的STM32F407 内部使用的 32 位处理器内核，支持 Thumb-2 指令集、DSP 指令、可选单精度 FPU。
FPU（Floating Point Unit）：硬件浮点运算单元，F407 含有单精度 FPU，运行浮点数的时候更快。
DSP 指令（Digital Signal Processing Instructions）：用于加速数字信号处理的扩展指令，例如 SIMD、饱和算术。
NVIC（Nested Vectored Interrupt Controller）：嵌套向量中断控制器，Cortex-M 内核内的中断管理硬件。
SysTick：Cortex-M 内核自带的 24 位向下计数系统节拍定时器。
AHB（Advanced High-performance Bus）：高速系统总线，F407 上 GPIO、DMA、Flash 等挂在 AHB1 / AHB2 / AHB3总线上面。
APB（Advanced Peripheral Bus）：低速外设总线，F407 上 USART、I2C、SPI、TIMx 等挂在 APB1 / APB2。
RCC（Reset and Clock Control）：复位与时钟控制单元，负责系统时钟选择、PLL 配置、所有外设时钟使能。
PLL（Phase Locked Loop）：锁相环，把 HSE / HSI 倍频到 168MHz 主频。
HSE / HSI（High-Speed External / Internal Oscillator）：高速外部 / 内部时钟源。
存储器映射（Memory Map）：CPU 视角下 4GB 地址空间的分布，包括 Code、SRAM、Peripherals、Private Peripheral Bus 等区域。
位带（Bit-Banding）：Cortex-M 提供的一种把单个 bit 映射成一个独立字地址的机制，可实现单 bit 原子读写。

1.3.3 寄存器与外设

寄存器（Register）：CPU 或外设内部的存储单元，绝大多数外设寄存器被映射到固定的内存地址，通过读写其特定 bit 控制硬件行为。
位字段（Bit Field）：寄存器中连续若干 bit 组成的逻辑单元，例如 MODER 中每 2 bit 控制一个引脚的模式。
只读 / 只写 / 读写（RO / WO / RW）：寄存器位的访问属性，参考手册中每个寄存器位都会标注。
写 1 清除（Write-1-to-Clear, W1C）：状态寄存器常见行为——向某 bit 写 1 才能清除该标志，写 0 无效。
GPIO（General Purpose Input/Output）：通用输入输出引脚。
推挽输出（Push-Pull）：输出级既能主动输出高电平也能主动输出低电平，输出能力比较强。
开漏输出（Open-Drain）：输出级只能拉低，输出高电平时引脚处于高阻，需要外部上拉电阻才能形成高电平。
上拉 / 下拉（Pull-up / Pull-down）：通过内部或外部电阻将引脚接到 VDD 或 GND，避免输入端在外部信号未驱动时悬空。
高阻态（Hi-Z, High Impedance）：引脚不被主动驱动，对外呈现极高阻抗，电平完全由外部电路决定。
复用功能（AF, Alternate Function）：GPIO 接入内部外设（USART、SPI、I2C、定时器等）的工作模式。
EXTI（External Interrupt / Event Controller）：外部中断/事件控制器，把 GPIO 边沿变化(从高电平变低电平或者从低电平变高电平)映射为中断。
DMA（Direct Memory Access）：直接存储器访问，外设与内存之间不经过 CPU 的数据搬运通道，可以解放CPU，以后想搞出高性能的数据采集，通讯接收，屏幕刷新等功能，DMA是绕不开的技术。

1.3.4 电源与电平

VDD / VSS / VBAT：芯片正电源 / 地 / 备份电池电源。STM32F407 中 VDD 典型值 3.3V，VBAT 一般 1.65~3.6V。筑基学习板上面的那个的纽扣电池座是CR1220，它可以给内部芯片内部RTC和板载SD3078供 3V。
GND（Ground）：电路参考 0V 电位点，所有电压都相对于 GND 测量。
AGND / DGND：模拟地 / 数字地。STM32F407 内部 ADC 参考的 VSSA 即模拟地。
逻辑电平（Logic Level）：将连续电压划分为 0/1 的电压阈值。STM32 GPIO 在 3.3V 供电下通常 VIH ≥ 0.7 × VDD 视为高，VIL ≤ 0.3 × VDD 视为低。
5V 容忍（5V Tolerant, FT）：部分 IO 允许输入 5V 电平而不损坏，但输出仍为 3.3V，具体引脚见数据手册。
TTL / CMOS / LVTTL：常见的逻辑电平标准。3.3V CMOS 是 STM32 的默认接口电平。
LDO（Low Dropout Regulator）：线性稳压器，通过串联调节管实现稳压，纹波小、效率较低（典型 40%~80%）、压差小（一般 0.1~1V）。筑基学习板上面有三路LDO。
DC-DC 转换器（Switching Converter）：开关型直流变换器，通过电感+开关管+续流二极管以 PWM 方式调节，效率高（典型 85%~95%），适合大功率前级。筑基学习板上的 XL4015E1 就属于DCDC，最高能输出5A的电流。
PWM（Pulse Width Modulation）：脉宽调制，通过改变方波占空比平均输出电压或控制功率器件。
TVS（Transient Voltage Suppressor）：瞬态电压抑制二极管，吸收 ESD、雷击、感性负载尖峰。
ESD（Electrostatic Discharge）：静电放电，是损坏 CMOS IO 的常见原因之一。
光耦（Opto-coupler）：通过 LED + 光敏管实现电气隔离的器件，常用于继电器、CAN、RS485 等隔离接口。筑基学习板上对于继电器部分和外部步进接口部分都使用到了光耦。

1.3.5 软件相关

中断（Interrupt）：外设事件触发 CPU 暂停当前程序执行专门 ISR（Interrupt Service Routine）的硬件机制。
优先级（Priority）：多个中断同时申请时决定响应顺序，F407 NVIC 使用 4 位可编程优先级（最多 16 级）。
抢占优先级 / 子优先级（Preempt / Sub Priority）：高抢占优先级可打断低抢占；同抢占下高子优先级先响应。
原子操作（Atomic Operation）：一次硬件操作完成、过程中不会被中断打断的操作，例如 STM32 GPIO 的 BSRR 单次写入。
临界区（Critical Section）：需要禁止中断或加锁保护的代码段。
栈（Stack）：用于函数调用、局部变量、寄存器保存的内存区域，向下生长。
堆（Heap）：malloc / free 动态分配区域，向上生长。
静态存储期 / 自动存储期（Static / Automatic Storage Duration）：变量生命周期分类，对应 static、全局变量与普通局部变量。
链接脚本（Linker Script）：决定代码段、数据段、向量表、栈、堆在物理存储中如何分布的脚本（Keil 的 sct、STM32CubeIDE 的 ld）。
启动文件（Startup File）：复位后第一段执行的汇编代码，负责初始化栈指针、向量表、调用 SystemInit 与 main。
HAL（Hardware Abstraction Layer）：STM32 官方提供的硬件抽象层驱动库。
LL（Low Layer）：STM32 官方提供的轻量级寄存器级驱动库，与 HAL 互补，执行效率高。
CMSIS（Cortex Microcontroller Software Interface Standard）：ARM 公司定义的 Cortex-M 标准软件接口。

1.4 本章知识和后续章节的关系

本章不是孤立的复习课，它会不断在后面的实验里出现。下面这张表可以当作后续学习时的索引：

本章知识点	后续会在哪里用到	典型场景
二进制、十六进制	GPIO、RCC、定时器、串口寄存器	看懂 `0x40020000`、`0x00000001`、`GPIO_PIN_5`
`uint8_t` / `uint16_t` / `uint32_t`	所有驱动代码	接收串口字节、读取 ADC 值、配置 32 位寄存器
`float` 精度	ADC、电机控制、传感器算法	温度换算、姿态解算、PID 控制
结构体与指针	HAL 库、寄存器映射	`GPIO_InitTypeDef`、`GPIOA->MODER`
位操作	所有寄存器章节	置位、清位、读取状态标志、配置多位字段
`volatile`	中断、DMA、寄存器访问	中断标志、共享变量、外设状态寄存器
欧姆定律与功率	GPIO、LED、电机、继电器	算限流电阻、估算发热、判断 GPIO 能不能直接驱动
上拉/下拉、电平	GPIO、按键、总线通信	防止输入悬空，判断 3.3V/5V 是否兼容
LDO / DC-DC	供电、电机实验、外设扩展	判断用 TYPE-C 供电还是外接电源
共地、电源路径、万用表	所有硬件实验	排查供电不正常、通信失败、模块不工作
电平转换、TVS、光耦隔离	WS2812、HX711、CAN、RS485、继电器	理解为什么有些 5V 外设不能直接接 GPIO
原理图阅读	每一个外设实验	根据网络标号找到 MCU 引脚和外设的连接关系

二进制与数据表示

在嵌入式开发中，我们不会只用十进制思考问题。如果你看到某个工程师在算 255 + 1，他很可能同时会想到 0xFF 溢出变成 0x00。因为寄存器、标志位、掩码和通信数据最终都要落到二进制和十六进制上。

2.1 为什么要学习进制？

STM32 内部其实就是成千上万个微小的开关。为了控制这些开关，芯片设计者把 32 个开关编成一组，称为一个 32 位寄存器。

如果我们用十进制来描述一个寄存器的状态，比如：把寄存器设置为 2863311530 ，这简直是灾难——你完全看不出哪些位是 1，哪些位是 0。而如果用十六进制来表示：0xAAAA AAAA，有经验的工程师一眼就能看出这是 1010 1010 1010 1010 1010 1010 1010 1010——所有偶数位是 1，奇数位是 0。

在后续的 [8]认识GPIO 章节中，我们会频繁地和寄存器打交道。比如 GPIO 的模式寄存器（MODER），每 2 位控制一个引脚的工作模式。如果你不能快速地在二进制和十六进制之间转换，用裸代码来配置寄存器就会变成一场噩梦。

2.2 二进制（Binary）

二进制是计算机最原始的语言。在 STM32 中，所有数据最终都表现为高电平（1）或低电平（0）。

2.2.1 基本单位

位（Bit）：二进制的最小单位，取值 0 或 1。一个位就像一个灯泡的开关，只有"亮"和"灭"两种状态。
字节（Byte）：8 个位组成一个字节。一个字节能表示 $2^{8} = 256$ 种不同的状态（0~255）。
半字（Half Word）：16 个位，即 2 个字节，对应 STM32 中的 uint16_t。能表示 $2^{16} = 65536$ 种状态。
字（Word）：32 个位，即 4 个字节，对应 STM32 中的 uint32_t。这是 STM32F4 寄存器的"标准位宽"，能表示约 42 亿种状态。

2.2.2 位的编号与权重

在一个字节中，位的编号从右到左，从 0 开始：

每一位的权重就是 $2^{n}$ （n 是位编号）。要把二进制转成十进制，只需要把所有为 1 的位的权重加起来： $128 + 32 + 4 + 1 = 165$ 。

TIP

记住几个关键的权重值会让你的开发效率大幅提升：

Bit 0 = 1，Bit 7 = 128，Bit 8 = 256，Bit 15 = 32768，Bit 16 = 65536
一个字节全 1（0xFF）= 255，两个字节全 1（0xFFFF）= 65535

NOTE

在 C 语言代码中，虽然 C99 标准不直接支持二进制前缀，但现代编译器（如 ARM-GCC、Keil MDK 使用的 ARMCC/ARM Compiler 6）是允许使用 0b 前缀，例如 0b10101010。这在配置寄存器位时非常直观。不过为了代码的可移植性，还是更推荐大家使用十六进制或位移操作。

2.3 十六进制（Hexadecimal）

十六进制是二进制的缩写。由于 4 位二进制正好对应 1 位十六进制（ $2^{4} = 16$ ），这使得转换变得异常简单——只需要把二进制每 4 位一组，分别转换即可。

2.3.1 基本规则

前缀：C 语言中使用 0x 开头表示十六进制，如 0xFF、0x1234。
范围：0~9 对应 0~9，10~15 对应 A~F（大小写均可，0xAB 和 0xab 等价）。
后缀：在某些场景下，你可能会看到 0x1234UL，其中 U 表示无符号（Unsigned），L 表示长整型（Long）。在 STM32 的 HAL 库中经常出现。

2.3.2 为什么嵌入式常用十六进制？

因为 STM32 的寄存器通常是 32 位的，用二进制写出来是 0b10101010101010101010101010101010 一长串，极其难以阅读且容易看错位。而用十六进制只需要 8 个字符，如 0xAAAA AAAA，整齐、专业且易读。

更重要的是，十六进制和二进制之间的转换是无脑的——每 4 位二进制对应 1 位十六进制，不需要做任何数学运算：

2.3.3 十六进制与二进制速查表

作为嵌入式工程师，你必须具备心算 4 位二进制与十六进制转换的能力。下面这张表建议背下来（其实用多了自然就记住了）：

十六进制	二进制	十进制	记忆技巧
0x0	0000	0	全灭
0x1	0001	1	最低位亮
0x2	0010	2	—
0x3	0011	3	低两位全亮
0x4	0100	4	—
0x5	0101	5	奇数位亮（01交替）
0x6	0110	6	—
0x7	0111	7	低三位全亮
0x8	1000	8	最高位亮
0x9	1001	9	—
0xA	1010	10	偶数位亮（10交替）
0xB	1011	11	—
0xC	1100	12	高两位全亮
0xD	1101	13	—
0xE	1110	14	—
0xF	1111	15	全亮

TIP

重点记住 0x0(0000)、0x5(0101)、0xA(1010)、0xF(1111) 这四个，其他的可以通过推算得出。比如 0xC = 0x8 + 0x4 = 1000 + 0100 = 1100。

2.4 八进制（Octal）

八进制以 0 开头（注意不是 0x），每 3 位二进制对应 1 位八进制。在现代嵌入式开发中，八进制的使用频率极低，你几乎不会在 STM32 的代码中看到它。但你必须知道它的存在，因为它可能会在你不经意间制造 Bug。

IMPORTANT

陷阱警告：在 C 语言中，千万不要给十进制数加前导 0。例如：

int a = 012;    // 你以为是 12，实际上是八进制的 012 = 十进制的 10！
int b = 0100;   // 你以为是 100，实际上是八进制的 0100 = 十进制的 64！
int c = 12;     // 这才是十进制的 12

这个陷阱在定义数组大小、延时参数等场景中尤其危险。如果你的程序行为差了一点点，检查一下是不是不小心写了前导零。

2.5 进制转换实战

2.5.1 二进制 ↔ 十六进制（最常用）

这是嵌入式开发中最频繁的转换，方法极其简单：每 4 位二进制对应 1 位十六进制，从右往左分组。

例 1：二进制转十六进制

二进制:  0001 0011 1010 0111
十六进制:  1    3    A    7
结果:    0x13A7

例 2：十六进制转二进制

十六进制:  0x5F
展开:      5       F
二进制:   0101   1111
结果:    0b01011111

2.5.2 二进制 ↔ 十进制

二进制转十进制：把每一位的权重加起来。

0b11001010 = 128 + 64 + 8 + 2 = 202

十进制转二进制：不断除以 2，取余数，从下往上读。

202 ÷ 2 = 101 ... 0
101 ÷ 2 = 50  ... 1
 50 ÷ 2 = 25  ... 0
 25 ÷ 2 = 12  ... 1
 12 ÷ 2 = 6   ... 0
  6 ÷ 2 = 3   ... 0
  3 ÷ 2 = 1   ... 1
  1 ÷ 2 = 0   ... 1
从下往上读: 11001010 = 0xCA

2.5.3 实战例子：配置 GPIO 模式

假设 STM32 的 GPIO 模式寄存器（MODER）每 2 位控制一个引脚。你想把第 0 号引脚设为输出模式（二进制 01），其他引脚保持不变。

寄存器当前值：0xFFFF FFFC

我们来分析末尾的 C：

C 的二进制是 1100
这 4 位对应引脚 1（高 2 位 11）和引脚 0（低 2 位 00）
引脚 0 当前是 00（输入模式），我们要改为 01（输出模式）
修改后：1101，即十六进制的 D
最终寄存器值：0xFFFF FFFD

TIP

在实际开发中，我们不会手动计算这些值，而是使用位操作来精确修改特定的位。这就是后面 3.9 位操作 章节要讲的内容。但理解进制转换是使用位操作的前提。

2.6 原码、反码、补码

单片机硬件里并没有负号这个零件。CPU 的加法器只认识 0 和 1，那它怎么做减法呢？答案就是补码。

2.6.1 三种编码方式

以 8 位（1 字节）为例，表示 -5：

编码方式	表示方法	`-5` 的编码	说明
原码	最高位为符号位（0正1负），其余为数值	`1000 0101`	直观但不方便运算
反码	正数同原码；负数符号位不变，数值位取反	`1111 1010`	过渡形式
补码	正数同原码；负数在反码基础上 +1	`1111 1011`	计算机实际使用的方式

NOTE

正数的原码、反码、补码完全相同。只有负数才需要转换。例如 +5 的三种编码都是 0000 0101。

【负数的补码 = 正数按位取反 + 1】

2.6.2 为什么要用补码？

补码巧妙地让「减去一个数」等价于「加上它的补码」。这样，单片机的加法器只需要一直做加法，就能通吃正负数运算，这样加法和减法可以共用同一个加法器，节省了大量硬件成本，速度也可以做的更快。

我们来验证一下 5 + (-5) 是否等于 0：

  0000 0101  (+5 的补码)
+ 1111 1011  (-5 的补码)
-----------
1 0000 0000  → 溢出的最高位被丢弃，结果为 0000 0000 = 0 ✓

完美！硬件只做了一次加法，就完成了减法运算。

2.6.3 补码的本质

补码不是设计出来的编码规则，它利用了固定宽度二进制的一个特性：

在 8 位系统中：

1111 1111 + 1 = 0000 0000

也就是：

255 + 1 会绕回 0

所以我们可以把靠近 255 的那些数解释成负数：

1111 1111  → -1
1111 1110  → -2
1111 1101  → -3
1111 1100  → -4
1111 1011  → -5

这样一来，负数就变成了【绕到另一边】的正数编码。

所以：

5 + (-5)

实际上就是：

5 + 251

结果是：

而 8 位系统只保留低 8 位：

1 0000 0000  →  0000 0000

最终得到 0。

这就是补码能够工作的根本原因。它利用了固定宽度二进制的【循环计数】特性。

2.6.4 补码的范围

对于 n 位有符号整数，补码的表示范围是 $- 2^{n - 1}$ 到 $2^{n - 1} - 1$ ：

类型	位数	范围	C 语言类型
有符号 8 位	8	-128 ~ +127	`int8_t`
有符号 16 位	16	-32768 ~ +32767	`int16_t`
有符号 32 位	32	-2147483648 ~ +2147483647	`int32_t`
无符号 8 位	8	0 ~ 255	`uint8_t`
无符号 16 位	16	0 ~ 65535	`uint16_t`
无符号 32 位	32	0 ~ 4294967295	`uint32_t`

CAUTION

溢出陷阱：如果你用一个 uint8_t（无符号 8 位）存储 255，再加 1，结果会回绕变成 0，而不是 256。同样，int8_t 存储 127 再加 1，会变成 -128。这种溢出在处理传感器回传的累加数据或定时器计数时非常致命，务必提前考虑数据类型的范围是否够用。

uint8_t counter = 255;
counter++;          // counter 变成 0，不是 256！

int8_t temp = 127;
temp++;             // temp 变成 -128，不是 128！

三 C 语言基础回顾

嵌入式 C 语言与纯软件 C 语言最大的区别在于：我们每一行代码都可能间接影响真实硬件。一个变量类型选错，可能导致计数溢出、通信协议解析错误或控制量异常；一个 volatile 忘了加，可能让中断里已经变化的状态在主循环里一直读不到。

本章不会从 Hello World 讲起，我们来聚焦于那些在嵌入式开发中特别重要、特别容易出问题、在 HAL 库源码中频繁出现的 C 语言特性。

3.1 数据类型与字节

在 STM32F4 这种 32 位架构中，对数据长度的认知必须精确。选错数据类型，轻则浪费内存，重则导致数据截断或溢出。

3.1.1 标准 C 数据类型

在不同的编译器和不同的目标平台下，标准 C 数据类型的长度可能不同。以下是 STM32（ARM Cortex-M4，32 位架构）中的典型长度：

类型	长度（字节）	长度（位）	范围（有符号）	说明
`char`	1	8	-128 ~ 127	最小的整数类型
`short`	2	16	-32768 ~ 32767	短整型
`int`	4	32	约 ±21 亿	STM32 中通常是 4 字节
`long`	4	32	约 ±21 亿	在 32 位 ARM 中和 int 一样长
`long long`	8	64	约 ±9.2×10¹⁸	超大整数
`float`	4	32	±3.4×10³⁸	单精度浮点
`double`	8	64	±1.7×10³⁰⁸	双精度浮点

WARNING

int 的长度在不同平台上可能不同！在 8 位单片机（如 51 单片机）上，int 通常是 2 字节；在 32 位 ARM 上是 4 字节；在 64 位 PC 上也是 4 字节（但指针是 8 字节）。这就是为什么嵌入式开发中强烈推荐使用定宽整数类型。

3.1.2 定宽整数类型（强烈推荐）

为了确保代码在不同芯片间移植时不会崩掉，我们强烈建议包含 <stdint.h> 头文件，使用显式长度的类型：

#include <stdint.h>

uint8_t   led_state;     // 无符号 8 位（0 ~ 255），存 LED 状态绰绰有余
int16_t   temperature;   // 有符号 16 位（-32768 ~ 32767），存温度值
uint32_t  reg_value;     // 无符号 32 位，STM32 寄存器的"标准位宽"

为什么要用这些？

操作一个 32 位的寄存器时，用 uint32_t 能确保你一次性写满了 32 个开关，而不会因为 int 的长度变化导致多写或少写。在 HAL 库的源码中，你会看到大量的 uint32_t、uint16_t、uint8_t，这不是多此一举，而是工程严谨性的体现。

定宽类型	等价含义	常见用途
`uint8_t`	无符号 8 位（0 ~ 255）	GPIO 引脚状态、I2C 数据、SPI 数据
`int8_t`	有符号 8 位（-128 ~ 127）	温度偏移量等小范围有符号数
`uint16_t`	无符号 16 位（0 ~ 65535）	ADC 采样值、定时器计数值
`int16_t`	有符号 16 位（-32768 ~ 32767）	加速度计原始数据、温度值
`uint32_t`	无符号 32 位（0 ~ 4294967295）	寄存器操作、系统时钟计数
`int32_t`	有符号 32 位	大范围有符号计算

3.1.3 浮点数的精度问题

STM32F407 内部带有硬件浮点运算单元，也就是 FPU（Floating Point Unit）。它可以直接用硬件加速 float 类型的加、减、乘、除等运算，所以 STM32F407 处理 float 的速度比没有 FPU 的 STM32F1 系列快很多。

但是，浮点数有一个初学者必须理解的特点：

单片机里的 float 通常采用 IEEE-754 单精度格式，占用 32 位。

它大致由三部分组成：

符号位 + 指数位 + 小数位

可以理解成一种二进制形式的科学计数法：

数值 ≈ ± 1.xxxxx × 2^n

这就带来一个问题：

类似十进制中：

1 / 3 = 0.333333333...

无法用有限位数精确表示。

同理，0.1 在二进制中也无法被 float 精确表示，只能保存一个非常接近它的近似值。

精度问题：

float a = 0.1f;
float b = 0.2f;
float c = a + b;
// c 不等于 0.3！而是 0.30000001192...
// 因为 0.1 和 0.2 在二进制浮点中无法精确表示

工程建议：

比较两个浮点数是否相等时，不要用 ==，而要用差值的绝对值是否小于一个很小的阈值（epsilon）：

// 错误的写法
if (a == 0.3f) { ... }

// 正确的写法
if (fabs(a - 0.3f) < 0.0001f) { ... }

float（单精度，32 位）在大多数嵌入式场景下精度已经足够，且 STM32F4 的 FPU 原生支持 float。
double（双精度，64 位）在 STM32F4 上没有硬件加速，运算速度会慢很多，除非确实需要高精度，否则尽量用 float。

TIP

虽然 F407 有硬件 FPU，但在中断服务函数中应尽量避免复杂的浮点运算，以保证系统的实时性。FPU 的上下文保存和恢复会增加中断延迟。如果必须在中断中使用浮点，需要确保 FPU 的上下文保存已正确配置（FreeRTOS 等 RTOS 一般会自动处理这个问题）。

3.2 宏定义与预处理器

宏定义不是普通的字符串搜索替换，而是由预处理器在正式编译之前进行的【文本展开】。它不理解变量类型，也不参与运行时执行，但它可以在源码层面生成大量重复代码，因此在 STM32 HAL/CMSIS 头文件中被大量使用。

理解 #define，是读懂 HAL 库和芯片头文件的基础之一。

3.2.1 #define 基本用法

定义常量：

#define LED_PIN        GPIO_PIN_2    // 天空星核心板上 PB2 连接的 LED
#define SYSTEM_CLOCK   168000000UL   // STM32F407 的系统时钟频率 168MHz
#define PI             3.14159265f   // 圆周率

使用宏定义常量的好处是：如果硬件改了（比如 LED 换到了另一个引脚），你只需要改一处 #define，而不用在代码里到处找 GPIO_PIN_2 来替换。

带参数的宏（宏函数）：

带参数的宏在底层开发中效率极高，因为它在预处理阶段完成展开，然后才进入正式编译。

#define SET_BIT(REG, BIT)     ((REG) |= (BIT))
#define CLEAR_BIT(REG, BIT)   ((REG) &= ~(BIT))
#define READ_BIT(REG, BIT)    ((REG) & (BIT))
#define MODIFY_REG(REG, CLEARMASK, SETMASK) \
        WRITE_REG((REG), (((READ_REG(REG)) & (~(CLEARMASK))) | (SETMASK)))

上面这些宏你会在 HAL 库的 stm32f4xx.h 中看到，它们是操作寄存器的基础工具。

CAUTION

宏的陷阱——括号不能省！

// 错误的宏定义
#define SQUARE(x) x * x
int result = SQUARE(3 + 1);  // 展开为 3 + 1 * 3 + 1 = 7，而不是 16！

// 正确的宏定义
#define SQUARE(x) ((x) * (x))
int result = SQUARE(3 + 1);  // 展开为 ((3 + 1) * (3 + 1)) = 16 ✓

在宏定义中，每个参数都要加括号，整个表达式也要加括号。这是 C 语言宏最常见、也最值得提前养成的工程习惯。

3.2.2 条件编译

在 HAL 库源码里，你会经常看到：

#ifdef HAL_GPIO_MODULE_ENABLED
  #include "stm32f4xx_hal_gpio.h"
#endif

#ifdef HAL_UART_MODULE_ENABLED
  #include "stm32f4xx_hal_uart.h"
#endif

这意味着：只有在 stm32f4xx_hal_conf.h 中定义了对应的宏（一般是由 CubeMX 自动生成），相关的代码才会被编译进固件。这能有效减小烧录到 Flash 中的程序体积——不用的外设驱动代码就不会占用宝贵的存储空间。

条件编译还常用于区分调试版本和发布版本：

#ifdef DEBUG
  #define LOG(fmt, ...) printf(fmt, ##__VA_ARGS__)
#else
  #define LOG(fmt, ...)  // 发布版本中，LOG 宏展开为空，不产生任何代码
#endif

3.2.3 #include 的工作原理

#include 的本质就是【把指定文件的内容原封不动地复制粘贴到当前位置】。

头文件保护（Include Guard）是必须的，能防止同一个头文件被多次包含导致的【重定义】错误：

#ifndef __MAIN_H    // 如果没有定义过 __MAIN_H
#define __MAIN_H    // 就定义它（相当于做个标记）

// 头文件内容放在这里
void SystemClock_Config(void);
void Error_Handler(void);

#endif /* __MAIN_H */  // 结束条件编译

第二次 #include "main.h" 时，由于 __MAIN_H 已经被定义过了，#ifndef 条件不成立，整个文件内容会被跳过。

TIP

现代编译器也支持 #pragma once 来替代传统的 Include Guard，效果相同但更简洁。不过 HAL 库使用的是传统方式，所以我们也推荐使用传统方式以保持风格一致。

3.2.4 常见的预定义宏

编译器自带了一些非常有用的预定义宏，在调试时可以快速定位问题：

printf("Error at file: %s, line: %d\n", __FILE__, __LINE__);
printf("Compiled on: %s %s\n", __DATE__, __TIME__);
printf("Function: %s\n", __func__);

预定义宏	含义	示例输出
`__FILE__`	当前源文件名	`"main.c"`
`__LINE__`	当前行号	`42`
`__DATE__`	编译日期	`"Mar 31 2026"`
`__TIME__`	编译时间	`"14:30:00"`
`__func__`	当前函数名	`"main"`

在嵌入式开发中，我们经常用这些宏来实现一个简单的断言（Assert）机制：

#define ASSERT(expr) \
    do { \
        if (!(expr)) { \
            printf("ASSERT FAILED: %s, file %s, line %d\n", \
                   #expr, __FILE__, __LINE__); \
            while(1); /* 死循环，方便调试器捕获 */ \
        } \
    } while(0)

// 使用示例
ASSERT(buffer != NULL);  // 如果 buffer 为空，程序会停在这里并打印错误信息

3.3 枚举与 typedef

3.3.1 枚举（enum）

枚举让代码从数字迷宫变成人类语言。在 HAL 库中，枚举被大量使用来定义各种状态和配置选项。

// HAL 库中 GPIO 引脚状态的定义
typedef enum {
    GPIO_PIN_RESET = 0,   // 低电平
    GPIO_PIN_SET          // 高电平（为 1）
} GPIO_PinState;

// HAL 库中函数返回状态的定义
typedef enum {
    HAL_OK       = 0x00U,  // 操作成功
    HAL_ERROR    = 0x01U,  // 操作失败
    HAL_BUSY     = 0x02U,  // 外设忙
    HAL_TIMEOUT  = 0x03U   // 操作超时
} HAL_StatusTypeDef;

写 GPIO_PIN_SET 显然比直接写 1 更不容易出错，阅读代码时也更顺畅。而且编译器会帮你检查类型匹配，减少低级错误。

工程实践：自定义枚举来管理状态机是嵌入式开发的常见模式：

typedef enum {
    STATE_IDLE = 0,    // 空闲状态
    STATE_RUNNING,     // 运行状态
    STATE_ERROR,       // 错误状态
    STATE_SLEEP        // 休眠状态
} SystemState_t;

SystemState_t currentState = STATE_IDLE;

3.3.2 typedef 的妙用

typedef 并不创建新类型，而是给已有类型起个好记的绰号。在嵌入式中，它常与结构体结合，能大幅减少代码的冗余：

// 没有 typedef，每次使用都要写 struct
struct GPIO_Config {
    uint32_t pin;
    uint32_t mode;
};
struct GPIO_Config config;  // 必须带 struct 关键字

// 有了 typedef，使用起来简洁得多
typedef struct {
    uint32_t pin;
    uint32_t mode;
} GPIO_Config_t;
GPIO_Config_t config;       // 不需要 struct 关键字

HAL 库中所有以 _TypeDef 结尾的类型名（如 GPIO_InitTypeDef、UART_HandleTypeDef）都是用 typedef 定义的。

3.4 结构体

结构体是 HAL 库的骨架。几乎所有的外设配置和操作都围绕结构体展开。

3.4.1 基本用法与 HAL 库实例

在 HAL 库中，配置一个外设通常只需要三步：定义结构体 → 填充成员 → 调用初始化函数。

// 第一步：定义一个 GPIO 初始化结构体变量，并清零
GPIO_InitTypeDef GPIO_InitStruct = {0};

// 第二步：填充结构体成员
GPIO_InitStruct.Pin   = GPIO_PIN_9;            // 选择引脚 9
GPIO_InitStruct.Mode  = GPIO_MODE_OUTPUT_PP;   // 推挽输出模式
GPIO_InitStruct.Pull  = GPIO_NOPULL;           // 不使用内部上下拉
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;   // 低速（点灯够用了）

// 第三步：调用初始化函数，传入端口和结构体地址
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

这种封装方式让代码极具可读性——你只需要关注【配置什么】，而不需要关注【往哪个寄存器的哪个位写什么值】。HAL 库在内部帮你完成了所有的寄存器操作。

NOTE

= {0} 这个初始化方式非常重要！它会把结构体的所有成员都清零。如果不这样做，结构体中未赋值的成员会包含随机的【垃圾值】，可能导致外设配置异常。这是一个非常好的编程习惯，建议始终使用，尤其当他是个局部变量的时候需要特别注意。

3.4.2 结构体指针

为什么 HAL_GPIO_Init 传递的是 &GPIO_InitStruct（地址）而不是 GPIO_InitStruct（值）？

// HAL_GPIO_Init 的函数原型
void HAL_GPIO_Init(GPIO_TypeDef *GPIOx, GPIO_InitTypeDef *GPIO_Init);
//                                       ↑ 这里接收的是指针（地址）

原因有两个：

效率：GPIO_InitTypeDef 结构体可能占用十几个字节。如果直接传值，每次调用函数都要把整个结构体复制一份到栈上，浪费时间和内存。传递指针只需要 4 个字节（32 位系统中指针大小固定为 4 字节），效率极高。
修改能力：通过指针，函数内部可以直接修改原始结构体的内容（虽然 HAL_GPIO_Init 不需要修改，但其他函数可能需要）。

3.4.3 内存对齐与 __packed

STM32 是 32 位处理器，默认按 4 字节对齐访问内存。这意味着编译器可能会在结构体成员之间插入【填充字节（Padding）】，以确保每个成员的地址都是其大小的整数倍。

// 不使用 __packed
typedef struct {
    uint8_t  a;    // 1 字节，地址 0x00
                   // 3 字节填充（为了让 b 对齐到 4 字节边界）
    uint32_t b;    // 4 字节，地址 0x04
    uint8_t  c;    // 1 字节，地址 0x08
                   // 3 字节填充（为了让整个结构体大小是 4 的倍数）
} NormalStruct;    // sizeof = 12 字节（不是 6 字节！）

// 使用 __packed（Keil MDK 语法）
typedef __packed struct {
    uint8_t  a;    // 1 字节，地址 0x00
    uint32_t b;    // 4 字节，地址 0x01（紧贴 a 后面）
    uint8_t  c;    // 1 字节，地址 0x05
} PackedStruct;    // sizeof = 6 字节（紧凑排列）

什么时候需要 __packed？

在处理通信协议（如串口数据包、无线透传帧）时，发送方和接收方必须对数据的排列方式达成一致。如果结构体中有填充字节，发送出去的数据就会多出【垃圾(无效字符)】，导致接收方解析错误。此时就需要用 __packed 取消对齐，确保数据紧贴排列。

WARNING

__packed 会降低访问效率（因为 CPU 可能需要多次内存访问来读取一个未对齐的 32 位数据），所以只在确实需要的时候使用。日常的结构体定义不要随意加 __packed。

3.5 位域

位域（Bit Field）允许我们在结构体中按【位(bit)】来定义成员，而不是按【字节】。这在描述硬件寄存器时非常方便：

typedef struct {
    uint32_t mode   : 2;   // 占 2 位：模式选择（00/01/10/11）
    uint32_t otype  : 1;   // 占 1 位：输出类型（0 推挽 / 1 开漏）
    uint32_t speed  : 2;   // 占 2 位：速度选择
    uint32_t pupd   : 2;   // 占 2 位：上拉/下拉选择
    uint32_t reserved : 25; // 剩余 25 位保留
} GPIO_PinConfig_t;

WARNING

虽然位域在描述寄存器时很直观，但由于不同编译器对位域的内部排序（从 MSB 开始还是从 LSB 开始）实现可能不同，在涉及跨平台通信协议时要非常小心。在 STM32 的 HAL 库中，官方并没有使用位域来操作寄存器，而是使用位掩码和位移操作，这种方式更加可靠和可移植。

3.6 指针

指针是嵌入式 C 语言的灵魂，也是新手最怕的东西。但在嵌入式开发中，指针不是可选的高级特性，而是必须掌握的基本功——因为操作寄存器的本质就是操作指针。

3.6.1 指针的本质

指针就是一个变量，它存储的不是普通的数据，而是另一个变量的内存地址。

int  a = 42;       // 变量 a，存储值 42，假设地址是 0x20000000
int *p = &a;       // 指针 p，存储 a 的地址 0x20000000

printf("%d\n", a);   // 输出 42（直接访问）
printf("%d\n", *p);  // 输出 42（通过指针间接访问，* 是"解引用"操作）
printf("%p\n", p);   // 输出 0x20000000（指针本身的值，即 a 的地址）

生活化比喻：如果变量 a 是一栋房子，那么指针 p 就是这栋房子的门牌号。你可以通过门牌号找到房子（解引用），也可以把门牌号告诉别人（传递指针），让别人也能找到这栋房子。

3.6.2 指针与寄存器

寄存器的本质就是一个固定地址的内存单元。STM32 的设计者把每个外设的控制寄存器都映射到了特定的内存地址上。操作寄存器，就是往这些地址读写数据。请大家直接去看这个章节：[8]认识GPIO，理解会更深刻。

如果我们想控制 GPIOA 的输出数据寄存器（ODR，地址为 0x40020014），用最原始的方式就是：

// 方法一：直接操作地址（最原始，最底层）
*(volatile uint32_t *)0x40020014 = 0x01;  // 让 PA0 输出高电平

// 拆解这行代码：
// 0x40020014              → 一个数字（地址）
// (volatile uint32_t *)   → 把这个数字"强制转换"为一个指向 volatile uint32_t 的指针
// *                       → 解引用，访问这个地址上的数据
// = 0x01                  → 往这个地址写入 0x01

但这样写代码简直是噩梦——谁记得住 0x40020014 是什么？所以 HAL 库帮我们做了一层封装：

// 方法二：HAL 库的封装方式（人类友好）
GPIOA->ODR = 0x01;  // 效果完全一样，但可读性天差地别

// GPIOA 是一个指向 GPIO_TypeDef 结构体的指针
// GPIO_TypeDef 结构体的成员按照寄存器的偏移地址排列
// ODR 是结构体中的一个成员，对应偏移地址 0x14
// 所以 GPIOA->ODR 最终访问的就是 0x40020000 + 0x14 = 0x40020014

3.6.3 函数指针与回调函数

函数指针是一个指向函数的指针。它存储的是函数的入口地址，通过它可以间接调用函数。

// 定义一个函数指针类型
typedef void (*CallbackFunc)(void);

// 定义一个普通函数
void LED_Toggle(void) {
    HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_2);
}

// 使用函数指针
CallbackFunc myCallback = LED_Toggle;  // 让函数指针指向 LED_Toggle
myCallback();                          // 通过函数指针调用 LED_Toggle

在 HAL 库的中断处理中，回调函数（Callback）随处可见。当按键触发外部中断时，硬件会自动跳转到中断服务函数，最终调用 HAL_GPIO_EXTI_Callback。你只需要在自己的 .c 文件里重写这个函数，逻辑就接通了：

// HAL 库中已经定义了一个"弱"（__weak）版本的回调函数
// 你只需要在自己的代码中重新定义它，就会自动覆盖弱版本
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {
    if (GPIO_Pin == GPIO_PIN_0) {
        // PA0 的按键被按下了，在这里写你的处理逻辑
        LED_Toggle();
    }
}

NOTE

__weak 关键字是 ARM 编译器的扩展。被 __weak 修饰的函数，如果用户在其他地方定义了同名函数，编译器会自动使用用户的版本。这就是 HAL 库回调机制的核心原理。

3.7 volatile 关键字详解

这是嵌入式开发的护身符，也是面试必考题。如果你只能记住本节的一个知识点，那就记住 volatile。

3.7.1 什么是 volatile？

volatile 告诉编译器：【这个变量随时可能被外部力量（硬件或中断）改变，你不要自作聪明去优化它，每次使用都必须从内存中重新读取】。

【解惑】生活化比喻

想象你在监控一个温度计。如果编译器发现你连续读了两次温度，且中间没做任何修改，它可能会想：反正上次读的是 25 度，这次肯定还是 25 度，我就偷个懒直接用上次的结果吧。其实也不算是偷懒，在工程中，这个叫优化。

但实际情况是，外面的火炉一直在烧，温度计的读数随时在变。volatile 就是强制编译器每次必须睁眼看一眼真实的硬件状态，而不是用缓存的旧值。

3.7.2 没有 volatile 会怎样？

看一个真实的例子：

// 假设这个变量在中断中被修改
uint8_t flag = 0;  // 注意：没有 volatile！

// 中断服务函数
void EXTI0_IRQHandler(void) {
    flag = 1;  // 按键按下，设置标志
}

// 主循环
int main(void) {
    while (1) {
        if (flag == 1) {       // 编译器可能优化为：只读一次 flag，之后一直用缓存值
            flag = 0;
            LED_Toggle();
        }
    }
}

编译器在优化时可能会这样想：flag 在 while 循环内没有被修改过（编译器看不到中断函数会修改它），所以 flag 的值永远不会变，这个 if 永远不会成立，我直接把它优化掉吧。

结果就是：无论你怎么按按键，LED 都不会翻转。程序看起来死了，但其实是编译器自作聪明了。

加上 volatile 后：

volatile uint8_t flag = 0;  // 告诉编译器：这个变量会被外部修改，别优化！

// 现在编译器每次都会从内存中重新读取 flag 的值
// 中断修改 flag 后，主循环能立即感知到变化

3.7.3 必须使用 volatile 的三大场景

场景	说明	示例
硬件寄存器	寄存器的值由硬件逻辑改变，不受 CPU 控制	ADC 转换完成标志、UART 接收数据寄存器
中断共享变量	在主循环和中断服务函数中共同访问的全局变量	按键标志、定时器计数值
DMA 缓冲区	数据由 DMA 控制器直接搬运到内存，CPU 不参与	DMA 接收缓冲区

IMPORTANT

HAL 库中所有的寄存器定义都已经加了 volatile（在 GPIO_TypeDef 等结构体中，每个成员都是 __IO uint32_t，而 __IO 就是 volatile 的别名）。所以通过 HAL 库操作寄存器时，你不需要额外加 volatile。但是，你自己定义的、在中断和主循环之间共享的变量，必须手动加 volatile。

3.7.4 volatile 不是万能的

volatile 只保证每次都从内存读取，但它不保证原子性。也就是说，对一个 volatile 变量的读-改-写操作仍然可能被中断打断。如果需要原子操作，还需要配合关中断或使用专门的原子操作指令。这个问题在后续的 [8]认识GPIO 章节中讲解 BSRR 寄存器时会详细讨论。

3.8 static 关键字

static 在 C 语言中有两种完全不同的用法，在嵌入式开发中都非常常见。

3.8.1 static 局部变量

普通的局部变量在函数返回后就消失了（栈空间被回收），下次你再来读取，这个空间中存的这个数据已经不是它本人了。但 static 局部变量不会——它在函数结束后依然保留自己的值，下次调用时还能接着用。

void LED_Blink_Counter(void) {
    static uint32_t count = 0;  // 只在第一次调用时初始化为 0
    count++;                     // 每次调用都会累加

    if (count >= 500) {          // 每调用 500 次翻转一次 LED
        count = 0;
        HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_2);
    }
}

// 在主循环中每 1ms 调用一次，LED 就会每 500ms 翻转一次

static 局部变量非常适合做简单的状态记忆，比如计数器、状态机的当前状态等。它的生命周期和全局变量一样长（程序运行期间一直存在），但作用域仅限于定义它的函数内部，不会污染全局命名空间。

3.8.2 static 全局变量/函数

当 static 用于全局变量或函数时，它的含义完全不同——限制可见性，让变量或函数只能在当前 .c 文件中访问，其他文件无法看到。

// led.c 文件
static uint8_t led_brightness = 0;  // 只有 led.c 能访问这个变量

static void LED_SetPWM(uint8_t duty) {  // 只有 led.c 能调用这个函数
    // 内部实现...
}

void LED_SetBrightness(uint8_t level) {  // 没有 static，其他文件可以调用
    led_brightness = level;
    LED_SetPWM(level);
}

这是实现模块化编程、防止命名冲突的必备手段。在一个大型嵌入式项目中，不同的 .c 文件可能都有叫 count 的变量或叫 init 的函数。如果不加 static，链接器会报【重复定义】错误。加了 static，每个文件的 count 和 init 就是各自独立的，互不干扰。

TIP

工程实践建议：在嵌入式项目中，养成一个好习惯——如果一个全局变量或函数只在当前 .c 文件中使用，就给它加上 static。这不仅能防止命名冲突，还能帮助编译器做更好的优化。

3.9 位操作（重中之重）

位操作是嵌入式 C 语言里最值得认真打磨的一组基本功。它不像 for、if 那样每天出现在业务逻辑里，但只要你开始碰寄存器、GPIO、状态标志、通信协议、传感器数据包，你就一定要彻底掌握它。

先看一个后面 GPIO 章节会遇到的场景：打开 GPIOC 的外设时钟。

RCC->AHB1ENR |= (1U << 2);   // 使能 GPIOC 时钟

这一句代码很短，但里面已经包含了位操作的核心思想：AHB1ENR 是一个 32 位寄存器，GPIOA、GPIOB、GPIOC 等外设时钟各占其中某一位。我们只想把 GPIOC 对应的 bit2 置 1，其他外设的时钟状态不能被误改。

再看一个稍复杂的场景：把 PC13 配置成普通输出模式。GPIO 的 MODER 寄存器中，每个引脚占 2 位，所以 PC13 对应的是 bit[27:26]。

GPIOC->MODER &= ~(0x03U << 26);  // 先清掉 PC13 的模式字段
GPIOC->MODER |=  (0x01U << 26);  // 再写入 01：普通输出模式

寄存器是整体读写的，但硬件功能往往是按 bit 或 bit 字段定义的。位操作负责把整体读写和局部修改连接起来。

IMPORTANT

不要把位操作学成几个固定口诀。口诀只能帮你写出代码，理解【掩码如何选中目标位、位运算如何保护其他位】，才能让你在看任何寄存器时都能自己推出来。

3.9.1 从一张开关面板理解 bit

可以把一个寄存器想象成一排小开关。以 8 位数据为例：

最右边是 bit0，也叫最低有效位；越往左编号越大。STM32 的 32 位寄存器也是这个方向：bit0 在最右边，bit31 在最左边。注意，这里说的是位编号的书写方向，和内存中的大小端存储不是一回事。

当我们说设置 bit6，本质上就是把这排开关里编号为 6 的那个拨到 1；当我们说读取 bit[12:9] ，就是把第 12 到第 9 这几位当成一个小字段取出来。

位操作里还有一个非常重要的词：掩码（mask）。它其实只是一个选择器。哪一位为 1，就表示我们关心哪一位；哪一位为 0，就表示这一位暂时不参与操作。掩码只是选中位置，不是要写入的值。

掩码	二进制含义	表示的目标位
`0x00000004`	只有 bit2 为 1	选中 GPIOC 时钟使能位
`0x00002000`	只有 bit13 为 1	选中第 13 个状态标志
`0x0C000000`	bit27、bit26 为 1	选中 PC13 的模式字段
`0x00000E00`	bit11~bit9 为 1	选中一个 3 位配置字段

实际写代码时，掩码通常用移位生成：

uint32_t gpio_c_clock_mask = (1U << 2);      // 选中 bit2
uint32_t pc13_mode_mask    = (0x03U << 26);  // 选中 bit[27:26]
uint32_t status_group_mask = (0x07U << 9);   // 选中 bit[11:9]

这里的 U 表示无符号整数。寄存器没有正负号，只有一堆 bit，所以位操作建议尽量使用 uint32_t、uint16_t、uint8_t 这类定宽无符号类型。

3.9.2 位运算和逻辑运算不能混用

类别	运算符	作用对象	结果特点
位运算	`&`、`\|`、`^`、`~`	一个一个 bit 地算	结果仍然是一组 bit
逻辑运算	`&&`、`\|\|`、`!`	把整个表达式当真假看	结果通常是 0 或 1

比如有两个字节：

uint8_t sensor_flags = 0x5A; // 0101 1010
uint8_t error_mask   = 0x24; // 0010 0100

uint8_t hit_bits = sensor_flags & error_mask;  // 0000 0000，本次没有命中这些错误位
uint8_t logic_ok = sensor_flags && error_mask; // 1，两个数都非 0

& 会逐位比较，因此能判断某些标志位是否真的出现；&& 只判断两个变量是否非 0，完全不关心哪些 bit 为 1。

再看或运算：

uint8_t tx_option = 0x40 | 0x02;   // 0100 0010，把两个选项合并到一个字节里
uint8_t condition = 0x40 || 0x02;  // 1，只表示逻辑上为真

在配置寄存器、拼接状态字、组合协议字段时，用的是 |；在 if 条件里表达【条件 A 或条件 B 成立】时，用的是 ||。

再看取反：

uint8_t flags = 0x16;      // 0001 0110

uint8_t inv_bits = (uint8_t)(~flags); // 1110 1001，逐位翻转
uint8_t inv_bool = !flags;            // 0，非 0 取逻辑反为 0

~ 用来构造反向掩码，! 用来做真假判断。二者长得不像，但初学者也很容易在取反这个概念上混淆。

WARNING

判断一个引脚是否为高电平，应该写成 (GPIOx->IDR & PIN_MASK) != 0U。如果写成 GPIOx->IDR && PIN_MASK，只是在判断整个输入寄存器和掩码是否非 0，不能代表目标引脚状态。

3.9.3 不用背真值表，只需要要记住工程效果

位运算的真值表很简单，但工程中真正要记住的是它们对目标位的影响：

运算符	你可以把它理解成	常见用途
`&`	保留需要的，屏蔽不要的	读取状态位、清掉某个字段
`\|`	把某些位合进去	打开开关、组合配置选项
`^`	让选中的位反向	软件翻转 LED 状态、切换标志
`~`	把掩码反过来	生成“除了目标位以外都保留”的掩码
`<<`	把数值推到指定 bit 位置	生成寄存器字段值
`>>`	把字段拉回最低位	读取字段后得到普通数值

用一句话总结：

text

& 负责“筛选”
| 负责“合并”
^ 负责“翻转”
~ 负责“反选”
<< 和 >> 负责“移动位置”

这几个词比真值表更贴近工程思维。后面你读到 reg &= ~mask，脑子里应该马上翻译成：把 mask 选中的那些位清掉，其他位保留。

3.9.4 移位：用来把掩码放到正确位置

移位可以做乘除 2 的运算，但在嵌入式编程里，它更常见的用途是：把一个值放到指定 bit 位置。

(1U << 2)   // 选中 bit2
(1U << 13)  // 选中 bit13
(1U << 29)  // 选中 bit29

构造连续多位掩码也很常见：

(0x03U << 26) // 选中 bit[27:26]，常见于 GPIO 模式字段
(0x0FU << 20) // 选中 bit[23:20]，常见于 4 位复用功能字段
(0x07U << 9)  // 选中 bit[11:9]，常见于 3 位配置字段

可以把构造掩码分成两步：

先在最低位写出字段宽度。
再左移到寄存器手册指定的位置。

text

0x03          = 0000 0011    // 2 位字段
0x03 << 26    = bit[27:26] 被选中

0x0F          = 0000 1111    // 4 位字段
0x0F << 20    = bit[23:20] 被选中

CAUTION

移位表达式建议使用无符号常量，例如 1U << n、0x03U << pos。如果用有符号数去构造高位掩码，可能引入溢出、符号位、编译器差异等问题。

移位还和数据类型有关，下面这张表建议先有个印象：

数据类型	左移 `<<`	右移 `>>`	嵌入式建议
无符号数	低位补 0	高位补 0	位操作首选
有符号正数	通常表现为低位补 0	通常高位补 0	不建议用于寄存器掩码
有符号负数	可能产生未定义或溢出风险	可能补符号位，和编译器有关	避免用于位操作

比如 uint32_t value = 0x80000000U; value >> 31 的结果就是 1，含义明确；但如果你对有符号负数右移，具体是补 0 还是补符号位，就容易牵扯到编译器实现。寄存器位操作没有必要冒这个风险，别玩花招就不容易出错。

3.9.5 操作寄存器的核心动作：读、改、写

CPU 往寄存器写数据时，通常是按 32 位整体写进去。但外设寄存器里的功能定义往往很细：某一位控制时钟开关，某两位控制 GPIO 模式，某四位控制复用功能。

因此，修改寄存器时经常要按下面的流程来：

读出寄存器原值。
在原值基础上修改目标位。
把修改后的完整 32 位值写回去。

这就是【读-改-写】。

以 PC13 配置为输出模式为例：

uint32_t temp;

temp = GPIOC->MODER;         // 读出原寄存器值
temp &= ~(0x03U << 26);      // 清掉 PC13 的模式字段 bit[27:26]
temp |=  (0x01U << 26);      // 写入输出模式 01
GPIOC->MODER = temp;         // 写回寄存器

如果直接写：

GPIOC->MODER = (0x01U << 26);

虽然 PC13 的模式字段会被写成输出，但 PC0~PC12、PC14、PC15 的模式字段也可能被你一起清掉。寄存器操作中的很多异常现象，本质就是这种误改。

工程里更推荐把位置和掩码写清楚：

#define PC13_MODE_POS      26U
#define PC13_MODE_MASK     (0x03U << PC13_MODE_POS)
#define GPIO_MODE_OUTPUT   0x01U

GPIOC->MODER = (GPIOC->MODER & ~PC13_MODE_MASK) |
               (GPIO_MODE_OUTPUT << PC13_MODE_POS);

NOTE

读-改-写是常见套路，但不是万能套路。实际还有些状态寄存器是写 1 清除，有些数据寄存器读一次会弹出 FIFO 中的数据，有些 GPIO 提供了专门的原子置位/复位寄存器。真正写底层驱动时，一定要先看参考手册对该寄存器的说明。

3.9.6 单个 bit 的四种基本操作

假设 reg 是一个 32 位变量或寄存器，mask 是目标位的掩码。

1. 置位：把目标位变成 1

reg |= mask;

例：打开 GPIOC 的外设时钟。

RCC->AHB1ENR |= (1U << 2);

| 的效果是合并 1。mask 中为 1 的位会被置 1，mask 中为 0 的位不影响原值。

2. 清位：把目标位变成 0

reg &= ~mask;

例：关闭某个软件状态标志。

system_flags &= ~(1U << 6);

~mask 会把目标位变成 0，其他位变成 1。再用 &，目标位被清掉，其他位保留。

3. 翻转：目标位 0 变 1，1 变 0

reg ^= mask;

例：软件里切换一个 LED 状态标志。

led_shadow ^= (1U << 13);

^ 的特点是：和 1 异或会反向，和 0 异或保持不变。

4. 判断：目标位是否为 1

if ((reg & mask) != 0U)
{
    // 目标位为 1
}
else
{
    // 目标位为 0
}

例：检查某个错误标志是否出现。

if ((error_flags & (1U << 4)) != 0U)
{
    Error_Handler();
}

判断时建议写 != 0U，不要写 == 1U。如果检查的是 bit13，表达式结果可能是 0x2000，不是 1。

不推荐写成：

if ((reg & (1U << n)) == 1U)  // 不推荐

3.9.7 多 bit 字段：先腾位置，再放新值

很多寄存器字段不是 1 位，而是连续几位。例如 GPIO 的每个模式字段占 2 位，复用功能字段占 4 位。对多 bit 字段不能只靠 |=，因为 | 只能把 0 变成 1，不能把旧的 1 变成 0。

多 bit 字段写入可以记成一句话：

先清空目标字段，再把新值移进去。

reg = (reg & ~FIELD_MASK) | ((value << FIELD_POS) & FIELD_MASK);

例：某个配置寄存器的 bit[11:9] 用来选择采样周期，我们要写入 0b101。

#define SAMPLE_POS    9U
#define SAMPLE_MASK   (0x07U << SAMPLE_POS)
#define SAMPLE_SET_CLK  0x05U

reg = (reg & ~SAMPLE_MASK) |
      ((SAMPLE_SET_CLK << SAMPLE_POS) & SAMPLE_MASK);

例：把 PC13 配置为输出模式。

#define PC13_MODE_POS      26U
#define PC13_MODE_MASK     (0x03U << PC13_MODE_POS)
#define GPIO_MODE_OUTPUT   0x01U

GPIOC->MODER = (GPIOC->MODER & ~PC13_MODE_MASK) |
               ((GPIO_MODE_OUTPUT << PC13_MODE_POS) & PC13_MODE_MASK);

这个写法有点长，但它非常工程化：

字段位置清楚。
字段宽度清楚。
不依赖目标字段原来是什么值。
新值会被掩码限制在字段范围内，减少越界污染。

3.9.8 读取字段：先筛出来，再移回去

读取多 bit 字段的过程刚好反过来：

value = (reg & FIELD_MASK) >> FIELD_POS;

先用 & 把目标字段筛出来，再用 >> 把它移动到最低位，变成一个方便比较的普通数值。

例：读取一个 3 位错误等级字段，字段位于 bit[14:12]。

#define ERR_LEVEL_POS    12U
#define ERR_LEVEL_MASK   (0x07U << ERR_LEVEL_POS)

uint32_t err_level;

err_level = (status_reg & ERR_LEVEL_MASK) >> ERR_LEVEL_POS;

if (err_level >= 4U)
{
    Error_Handler();
}

如果不右移，status_reg & ERR_LEVEL_MASK 得到的是仍然停留在 bit[14:12] 位置上的值，不方便直接和 4、5 这类普通数字比较。

再看一个通信协议场景。假设设备返回 1 个状态字节：

text

bit7    : 数据是否有效
bit6~5  : 工作模式
bit4    : 是否过温
bit3~0  : 错误代码

解析时可以这样写：

uint8_t rx = 0xB6; // 1011 0110，仅作为示例

uint8_t valid = (rx & 0x80U) != 0U;
uint8_t mode  = (uint8_t)((rx & 0x60U) >> 5);
uint8_t hot   = (rx & 0x10U) != 0U;
uint8_t code  = (uint8_t)(rx & 0x0FU);

这不是寄存器，但思路和寄存器完全一样：协议字段本质上也是一组 bit。

3.9.9 字段值要计算时，不要直接改整个寄存器

有些字段不是简单写死，而是要基于原值调整。例如某个配置寄存器里 bit[19:16] 表示滤波等级，范围是 0~15。我们希望把滤波等级提高 2 档，但其他字段保持不变。

错误思路是直接对整个寄存器加：

cfg += 2U;  // 错误：你不知道加法会影响哪些位，也可能向高位进位

正确做法是：取出字段，单独计算，再写回字段。

#define FILTER_POS    16U
#define FILTER_MASK   (0x0FU << FILTER_POS)

uint32_t filter;

filter = (cfg & FILTER_MASK) >> FILTER_POS;

if (filter <= 13U)
{
    filter += 2U;
}
else
{
    filter = 15U;
}

cfg = (cfg & ~FILTER_MASK) |
      ((filter << FILTER_POS) & FILTER_MASK);

这种写法的好处是清楚、可调试，而且不会让普通加法的进位影响其他字段。

3.9.10 一次修改多个字段：先准备清除掩码和写入值

有时一个寄存器里要同时修改多个字段。例如某个外设控制寄存器中：

bit2：模块使能。
bit[6:4]：速度等级。
bit[15:12]：通道选择。

可以把要清掉哪些位和要写入哪些位分开准备：

#define CTRL_EN_MASK       (1U << 2)

#define CTRL_SPEED_POS     4U
#define CTRL_SPEED_MASK    (0x07U << CTRL_SPEED_POS)

#define CTRL_CH_POS        12U
#define CTRL_CH_MASK       (0x0FU << CTRL_CH_POS)

uint32_t clear_mask = CTRL_SPEED_MASK | CTRL_CH_MASK;
uint32_t write_bits = CTRL_EN_MASK |
                      ((3U << CTRL_SPEED_POS) & CTRL_SPEED_MASK) |
                      ((9U << CTRL_CH_POS) & CTRL_CH_MASK);

CTRL_REG = (CTRL_REG & ~clear_mask) | write_bits;

这里没有把 CTRL_EN_MASK 放进 clear_mask，因为我们只打算把它置 1，不需要先清掉。如果某一位要被写成 0，则应该把它放进清除掩码。

这种写法比连续写三四次寄存器更容易审查，也更接近 HAL/CMSIS 宏的设计思路。

3.9.11 宏封装：让位操作更像工程代码

学习阶段可以把位操作展开写，方便理解每一步。工程代码里则常常封装成宏，让代码更像描述意图，而不是每次都手算位移。

HAL/CMSIS 里经常能看到类似宏：

#define SET_BIT(REG, BIT)     ((REG) |= (BIT))
#define CLEAR_BIT(REG, BIT)   ((REG) &= ~(BIT))
#define READ_BIT(REG, BIT)    ((REG) & (BIT))
#define CLEAR_REG(REG)        ((REG) = (0x0))
#define WRITE_REG(REG, VAL)   ((REG) = (VAL))
#define READ_REG(REG)         ((REG))
#define MODIFY_REG(REG, CLEARMASK, SETMASK) \
        WRITE_REG((REG), (((READ_REG(REG)) & (~(CLEARMASK))) | (SETMASK)))

其中 MODIFY_REG 可以理解为：

REG = (REG & ~CLEARMASK) | SETMASK;

如果自己写练习代码，也可以定义更直观的字段宏：

#define BIT_U32(n)              (1UL << (n))
#define BITS_U32(width)         ((1UL << (width)) - 1UL)
#define REG_FIELD_MASK(pos, width) \
        (BITS_U32(width) << (pos))

#define REG_FIELD_PREP(pos, width, value) \
        (((uint32_t)(value) << (pos)) & REG_FIELD_MASK((pos), (width)))

#define REG_FIELD_GET(reg, pos, width) \
        (((uint32_t)(reg) & REG_FIELD_MASK((pos), (width))) >> (pos))

使用示例：

#define PC13_MODE_POS      26U
#define PC13_MODE_WIDTH    2U

GPIOC->MODER = (GPIOC->MODER & ~REG_FIELD_MASK(PC13_MODE_POS, PC13_MODE_WIDTH)) |
               REG_FIELD_PREP(PC13_MODE_POS, PC13_MODE_WIDTH, 0x01U);

uint32_t pc13_mode = REG_FIELD_GET(GPIOC->MODER, PC13_MODE_POS, PC13_MODE_WIDTH);

CAUTION

上面的宏用于教学理解。真实项目里要处理 width 为 0、width 大于等于 32、参数重复求值等边界问题。能使用芯片厂商已经提供的 CMSIS/HAL 宏时，请优先使用官方宏。

3.9.12 常见错误：了解这些坑比语法本身更重要

错误 1：用逻辑运算判断某一位

if (GPIOC->IDR && (1U << 13))  // 错误
{
}

这个条件只是在判断 GPIOC->IDR 和掩码是否都非 0，并不能判断 PC13 的电平。

正确写法：

if ((GPIOC->IDR & (1U << 13)) != 0U)
{
}

错误 2：多位字段只用 |=

GPIOC->MODER |= (0x01U << 26); // 不完整

如果 PC13 原来的模式字段不是 00，只用或操作可能无法得到期望模式。多位字段要先清字段，再写字段。

错误 3：忘记括号导致优先级出错

reg &= ~0x03U << 26;  // 错误风险很高

这行代码容易被误读，也不等价于先生成 bit[27:26] 掩码，再整体取反。应写成：

reg &= ~(0x03U << 26);

位操作里括号不要省，省下来的几个字符不值得。

错误 4：取反后没有意识到类型宽度

uint8_t mask = ~0x20U;

~0x20U 先按 unsigned int 计算，结果不是一个单纯的 8 位值，最后赋给 uint8_t 时才截断。很多时候结果低 8 位是你想要的，但阅读起来不直观。更建议：

uint8_t mask = (uint8_t)~(uint8_t)0x20U;

操作 32 位寄存器时，就统一使用 32 位无符号表达式。

错误 5：移位位数超过类型宽度

uint32_t all_bits = (1UL << 32); // 错误

对于 32 位数，左移位数只能在 0~31 范围内。要生成全 1，可以直接写：

uint32_t all_bits = 0xFFFFFFFFUL;

错误 6：忽略寄存器的特殊写法

USARTx->SR &= ~RX_FLAG; // 不一定正确，要看手册

有些状态标志不是普通变量，不是想清 0 就能用 &=~。例如某些标志位需要按手册规定的顺序读写，有些是写 1 清除，有些由硬件自动清除。寄存器位操作永远要服从参考手册。

3.9.13 练习：换成真实一点的场景

下面的练习，重点是把选中目标位、保护其他位的思路练熟。

练习 1：打开 GPIOC 时钟

RCC->AHB1ENR 的 bit2 用于 GPIOC 时钟使能，写出代码。

RCC->AHB1ENR |= (1U << 2);

练习 2：清除一个软件状态字中的 bit6

system_flags &= ~(1U << 6);

练习 3：翻转 LED 影子变量中的 bit13

led_shadow ^= (1U << 13);

练习 4：判断接收状态字中的 bit4 是否为 1

if ((rx_status & (1U << 4)) != 0U)
{
    // bit4 为 1
}

练习 5：把某寄存器 bit[11:9] 写成 0b101，其他位不变

#define FIELD_POS   9U
#define FIELD_MASK  (0x07U << FIELD_POS)

reg = (reg & ~FIELD_MASK) | ((0x05U << FIELD_POS) & FIELD_MASK);

练习 6：读取状态寄存器 bit[14:12] 作为错误等级

#define ERR_POS   12U
#define ERR_MASK  (0x07U << ERR_POS)

uint32_t err = (status_reg & ERR_MASK) >> ERR_POS;

练习 7：把配置寄存器 bit[19:16] 表示的滤波等级加 2，最大不超过 15

#define FILTER_POS    16U
#define FILTER_MASK   (0x0FU << FILTER_POS)

uint32_t filter = (cfg & FILTER_MASK) >> FILTER_POS;

filter = (filter <= 13U) ? (filter + 2U) : 15U;
cfg = (cfg & ~FILTER_MASK) | ((filter << FILTER_POS) & FILTER_MASK);

练习 8：解析一个 8 位状态字

假设状态字格式如下：

text

bit7    : 数据有效
bit6~5  : 设备模式
bit4    : 过温标志
bit3~0  : 错误码

解析代码：

uint8_t valid = (frame_status & 0x80U) != 0U;
uint8_t mode  = (uint8_t)((frame_status & 0x60U) >> 5);
uint8_t hot   = (frame_status & 0x10U) != 0U;
uint8_t code  = (uint8_t)(frame_status & 0x0FU);

练习 9：一次性配置控制寄存器

要求：

bit2 置 1，表示使能模块。
bit[6:4] 写入速度等级 3。
bit[15:12] 写入通道号 9。

#define CTRL_EN          (1U << 2)

#define SPEED_POS        4U
#define SPEED_MASK       (0x07U << SPEED_POS)

#define CHANNEL_POS      12U
#define CHANNEL_MASK     (0x0FU << CHANNEL_POS)

CTRL_REG = (CTRL_REG & ~(SPEED_MASK | CHANNEL_MASK)) |
           CTRL_EN |
           ((3U << SPEED_POS) & SPEED_MASK) |
           ((9U << CHANNEL_POS) & CHANNEL_MASK);

练习 10：把 PC13 设置为输出模式

#define PC13_MODE_POS    26U
#define PC13_MODE_MASK   (0x03U << PC13_MODE_POS)

GPIOC->MODER = (GPIOC->MODER & ~PC13_MODE_MASK) |
               ((0x01U << PC13_MODE_POS) & PC13_MODE_MASK);

3.9.14 本节小结

位操作不是为了炫技，而是为了让 C 语言能精确控制硬件寄存器。学完这一节，至少要形成下面几条工程直觉：

位操作的核心不是符号本身，而是掩码。
单 bit 操作重点看 |、&~、^、&。
多 bit 字段一定要先清字段，再写字段。
读取字段要先屏蔽，再右移。
移位表达式尽量使用无符号类型。
寄存器不是普通变量，是否能读-改-写要看参考手册。

后续学习 GPIO 时，MODER、OTYPER、OSPEEDR、PUPDR、IDR、ODR、BSRR 都会用到这些方法。位操作一旦理解到位，寄存器就不再是一串吓人的十六进制数字，而是一张可以被你精确控制的开关表。

3.10 存储相关

理解 STM32 的存储架构，能帮你回答很多灵异问题：为什么程序掉电后还在？为什么变量掉电后就没了？为什么定义了一个大数组程序就崩了？

3.10.1 Flash vs RAM

STM32F407VET6（天空星核心板(青春版)所用芯片）有两种主要的存储器：

存储器	大小	特性	比喻	存放内容
Flash	512KB	掉电不丢失，读快写慢	硬盘	程序代码、`const` 常量、初始化值
RAM	192KB	掉电即失，读写都快	内存条	运行时变量、栈、堆

NOTE

天空星高配版（STM32F407VGT6）的 Flash 为 1024KB，是青春版的两倍。RAM 大小相同，都是 192KB。

3.10.2 变量存在哪里？

当你在代码中定义一个变量时，它最终会被放到 Flash 或 RAM 的某个区域。了解这些区域，能帮你更好地管理有限的存储资源。

变量类型	存放位置	生命周期	示例
局部变量	栈（Stack）	函数执行期间	`int i = 0;`（在函数内）
全局变量（有初始值）	Data 段（RAM）	程序运行期间	`int count = 100;`（在函数外）
全局变量（无初始值）	BSS 段（RAM）	程序运行期间	`int buffer[256];`（在函数外）
`static` 变量	Data/BSS 段（RAM）	程序运行期间	`static int state = 0;`
`const` 常量	Flash	永久	`const uint8_t table[] = {1,2,3};`
`malloc` 分配	堆（Heap）	手动释放前	`uint8_t *buf = malloc(100);`

CAUTION

栈溢出（Stack Overflow）：在嵌入式开发中，栈空间通常只有几 KB（STM32 默认配置一般是 1KB~4KB）。千万不要在函数里定义超级大的局部数组：

void bad_function(void) {
 char buf[20000];  // 20KB！远超栈空间，瞬间撑爆！
 // 后果：程序莫名重启、跑飞、进入 HardFault
}

如果确实需要大缓冲区，应该使用全局变量或 static 变量（存放在 Data/BSS 段），或者使用 malloc（存放在堆中，但嵌入式中不推荐频繁使用 malloc，容易产生内存碎片）。

3.10.3 大端与小端

数据在内存中的存放顺序有两种方式：

大端模式（Big-Endian）：高字节存在低地址。就像我们写数字 1234，高位在前。
小端模式（Little-Endian）：低字节存在低地址。就像把 1234 倒着写成 4321。

什么时候需要关心大小端？

当你通过串口、SPI、网络等方式与其他设备通信时，如果对方是大端设备（比如某些网络协议规定使用大端），你发送 0x1234，对方收到的可能是 0x3412。此时就需要做字节序转换。

// 16 位字节序转换
uint16_t swap16(uint16_t val) {
    return (val << 8) | (val >> 8);
}

// 32 位字节序转换
uint32_t swap32(uint32_t val) {
    return ((val & 0xFF000000) >> 24) |
           ((val & 0x00FF0000) >> 8)  |
           ((val & 0x0000FF00) << 8)  |
           ((val & 0x000000FF) << 24);
}

TIP

ARM Cortex-M4 提供了专门的字节序转换指令 REV 和 REV16，CMSIS 库中封装为 __REV() 和 __REV16() 函数，比手写的转换函数效率高得多。

四电路基础回顾

软件工程师可能会觉得电路知识【不是我的活】，但在嵌入式开发中，软件和硬件是一体的。你不需要成为电路设计专家，但至少要能看懂原理图、理解基本的电路原理。否则，当你的程序明明没错但板子就是不工作时，你会束手无策。

这一节面向纯初学者，不从复杂电路理论讲起，而是围绕天空星筑基学习板上真实存在的电路来建立直觉：哪里是电源，哪里是地，哪里是信号，为什么 GPIO 不能直接带电机，为什么有的接口要隔离，为什么有的 5V 外设要电平转换。

IMPORTANT

初学阶段最重要的不是马上把电路讲深，而是先做到不烧板、不烧电脑、不烧外设。凡是涉及外接电源、电机、继电器、5V 模块、排针供电的实验，都要先确认电压、电流、极性和 GND。

4.1 初学者先分清：电源、地、信号

一块开发板上有很多线，但对初学者来说，先把它们分成三类就够了：

类型	作用	在筑基学习板上的例子	初学者要注意
电源	给电路提供能量	8~24V 输入、5V、3.3V、VBAT、隔离 5V	电压不能接错，输出口和输入口不能混用
地 GND	所有电压的参考点，也是电流回路的一部分	GND、AGND、隔离地	通信双方通常必须共地，差分接口除外
信号	传递 0/1、模拟电压或时序信息	GPIO、UART、I2C、SPI、PWM、ADC	信号电平要匹配，不能把 5V 随便送进 3.3V 引脚

很多硬件问题都可以用这三句话先排查：

电源有没有接对？
GND 有没有接对？
信号线是不是接到了正确引脚、正确功能、正确电平？

4.1.1 筑基学习板上的几个电压

结合这里的硬件介绍，筑基学习板上常见电压可以先这样理解：

电压/电源	从哪里来	主要给谁用	备注
8~24V 输入	DC 座或 2P 接线端子	主 DC-DC、电机相关实验	需要驱动电机时使用，输入口二选一
5V	Type-C、调试口 5V，或 DC-DC 输出	舵机、WS2812、功放、部分外设、后级 LDO	不需要电机时，用 5V 供电（TYPE-C）最简单
3.3V	LDO 从 5V 降压得到	STM32、板载 3.3V 传感器、部分扩展排针	STM32 GPIO 的主要逻辑电平
隔离 5V	板载隔离电源	CAN、RS485、继电器、外部步进光耦等隔离侧	隔离侧和普通 GND 不能随便短在一起，他们不是同一个地
VBAT	CR1220 电池座	RTC、备份域	用来掉电保持时间或少量备份数据

如果你只是学习点灯、按键、串口、I2C、SPI、ADC 等普通实验，通常用天空星核心板 Type-C 供电即可。如果要驱动直流电机、步进电机等负载，就必须要根据电机额定电压来选择 12V 或 24V 输入。

WARNING

天空星两边排针及电源旁边的 O3V3 和 O5V0 这类接口是对外输出（无法对内输入），不是给板子反向供电的输入。纯初学者不要随便从排针往板子灌电，尤其不要把 5V、3.3V、GND 接反。

4.1.2 电源适配器标的电流不是强行灌入的电流

很多初学者看到【5V/2A】【12V/3A】会害怕：2A 会不会把板子烧了？这里要分清楚：

电压是电源主动提供的，接错电压很危险。
电流主要由负载决定，电源标的 2A/3A 是最多能提供多少，不是一定会强行输出多少。

例如一块板子在 5V 下只需要 300mA，你用 5V/2A 的适配器供电，正常情况下它也只会取大约 300mA；但如果你把 12V 接到只能承受 5V 的接口上，那就不是多给一点余量，而是直接超压，有可能会有魔法烟雾跑出来。

4.1.3 共地：很多通信失败都卡在这里

两个设备之间传信号，必须有共同的参考点。比如你用外部串口模块连接 STM32：

只接 TX/RX 不接 GND，双方对【0V】的理解可能不同，信号高低电平就没有共同基准，通信大概率是失败的。

但 CAN、RS485、继电器、外部步进光耦这些地方又用到了隔离电源和光耦隔离。隔离的目的就是让两边不要直接共地，从而提高抗干扰和安全性。所以判断要不要共地，不能只背一句话，要结合具体电路：

普通 UART/I2C/SPI/GPIO 模块：通常需要共地。
已经通过隔离芯片/光耦/隔离电源连接的接口：不要随便把隔离两侧的地短起来。比如筑基学习板上面的外部步进电机接口，RS485和CAN接口等都是隔离的。

4.1.4 万用表第一课：先会测电压

纯初学者建议尽早准备一块数字万用表。刚开始不用学太复杂，先掌握三件事：

要测什么	表笔怎么接	常见用途
电压	并联测量，黑表笔接 GND，红表笔接被测点	确认 5V、3.3V 是否正常
电阻	断电后测量	判断电阻值、检查是否短路
通断	断电后测量	检查两点是否连在一起

CAUTION

不要把万用表打到电流档后直接去量电源两端。电流档相当于一个很小的电阻，直接并到电源上会接近短路，轻则烧保险丝，重则烧表、烧板。

4.2 欧姆定律

U = I \times R

这三个字母决定了你的电路会不会烧掉。欧姆定律是所有电路分析的基础，无论多复杂的电路，最终都可以用这个公式来分析。

4.2.1 电压、电流与电阻

电压（U，单位：伏特 V）：就像水压，是推动电流流动的力。天空星核心板的核心工作电压是 3.3V。
电流（I，单位：安培 A）：就像单位时间内流过水管的水量，是单位时间内通过导体的电荷量。电流过大，元件会发热甚至烧毁。
电阻（R，单位：欧姆 Ω）：就像水管的粗细，阻碍电流流动。电阻越大，同样电压下电流越小。

常用单位换算：

1A = 1000mA（毫安）= 1000000μA（微安）
1kΩ = 1000Ω，1MΩ = 1000000Ω
1V = 1000mV（毫伏）

这里有两个纯初学者一定要建立的概念：

电压接错最危险：把 12V 接到 5V 输入口，或者把 5V 接到不耐 5V 的 ADC/GPIO，通常会直接损坏器件。
电流要看负载：电源能提供 2A，不代表板子一定吃 2A；但如果负载短路或电机堵转，电流可能瞬间变得很大。

所以看电路时，不要只问这个电源多少伏，还要问这个负载大概吃多少电流，板子和线能不能承受。

4.2.2 功率计算

P = U \times I = I^{2} \times R = \frac{U^{2}}{R}

功率（P，单位：瓦特 W）表示电路消耗能量的速度。在电源设计中，发热是最大的敌人。

实际案例：天空星学习板的 LDO 发热分析

天空星筑基学习板使用 LDO（SCJA1117B-3.3）将 5V 降到 3.3V。假设负载电流为 500mA：

LDO 上的压差： $5 V - 3.3 V = 1.7 V$
LDO 的功耗： $P = 1.7 V \times 0.5 A = 0.85 W$

这 0.85W 的能量全部变成了热量。如果电流更大（比如 1A），功耗就是 1.7W，不加散热片的话，芯片表面温度可能超过 80°C，烫手是肯定的。这也是为什么天空星筑基学习板在大压差场景下使用 DC-DC（XL4015E1）而不是 LDO 的原因——DC-DC 的效率可以达到 85%~95%，发热量小得多。

4.2.3 限流电阻计算

实际案例：给天空星核心板上的 LED 计算限流电阻

天空星核心板上的绿色 LED 串联了一个 2kΩ 的电阻。我们来验算一下电流：

LED 的正向压降约 2V（绿色 LED 典型值）
电阻两端的电压： $3.3 V - 2 V = 1.3 V$
通过 LED 的电流： $I = 1.3 V / 2000 Ω = 0.65 m A$

0.65mA 的电流已经足够让 LED 明亮可见了，而且远低于 STM32 GPIO 的最大输出电流（25mA），非常安全。而且即使用了2K欧姆的电阻，直接目视的话也是比较刺眼的。

TIP

在实际项目中，LED 的限流电阻一般选择 330Ω~2kΩ。电阻越小，LED 越亮，但电流越大。对于指示灯来说，1~5mA 的电流通常已经足够，没必要一味追求高亮度，亮度太高还会导致刺眼的问题。

4.2.4 用欧姆定律判断 GPIO 能不能直接驱动

STM32 的 GPIO 适合输出控制信号，不适合直接输出大电流。以一个小型直流电机为例，即使空载电流只有 100mA，启动瞬间和堵转时也可能达到几百 mA 甚至更高，而 STM32 单个 GPIO 长期建议电流通常应控制在几 mA 量级。

如果你把电机直接接在 GPIO 和 GND 之间，问题不是【转不转】，而是：

GPIO 输出管可能过流损坏。
电机启动和关断会产生干扰，导致芯片复位或通信异常。
电机是电感性负载，关断瞬间可能产生反向高压。

实际工程中，我们会让 GPIO 只负责发命令，真正的大电流交给驱动器件：

筑基学习板上的直流电机不是由 STM32 引脚直接驱动的，是由 AT8236 H 桥驱动芯片驱动；步进电机则由 TMC2209 驱动。

4.3 电阻

电阻是电路中最基本、最常见的元件。在天空星学习板的原理图上，你会看到大量的电阻，它们各有各的用途。

4.3.1 常见用途

限流：

最典型的应用就是给 LED 串联限流电阻。如果不加电阻，LED 会因为电流过大瞬间烧毁（LED 的内阻非常小，直接接 3.3V 电流会远超额定值）。

分压：

通过两个电阻的比例，可以把高电压分成低电压。这在 ADC 采集、电平转换等场景中非常常见。

分压公式： $V_{O U T} = V_{I N} \times \frac{R 2}{R 1 + R 2}$

实际案例：天空星筑基学习板的 DC-DC 反馈电阻

在天空星筑基学习板套件介绍中提到，XL4015E1 的输出电压由反馈电阻决定：

V_{O U T} = 1.25 \times (1 + \frac{R 6}{R 10}) = 1.25 \times (1 + \frac{10 k Ω}{3.3 k Ω}) \approx 5.04 V

这就是分压原理的实际应用。

采样：

有些电阻不是为了挡住电流，而是为了把电流变成一个可以测量的小电压。筑基学习板上的 INA226 电源监控芯片就需要配合采样电阻来测量电流，基本思路是：

这个电阻通常很小，比如十几毫欧到几百毫欧。如果电阻太大，会影响供电，会导致电源压降太大；如果太小，压差太小又不容易测准。在筑基学习板上面，用的是15m欧姆的采样电阻。

终端匹配：

CAN、RS485 这类长线通信总线经常会看到 120Ω 终端电阻。它不是随便放的，而是用来减少信号在长线末端反射，提高通信稳定性。筑基学习板的隔离 CAN 和隔离 RS485 接口都提供了终端电阻，后续讲通信总线时会详细展开。

0Ω 电阻：

原理图里有时会看到 0Ω 电阻，它看起来像多余的导线，但很有用：

方便调试时断开或改接某一路信号。
方便同一块 PCB 兼容不同芯片或不同配置。
方便测电流时临时拆掉，串入电流表。

天空星核心板和筑基学习板都存在不少兼容设计思路，0Ω 电阻、预留焊盘、默认不贴器件就是常见的手段。

4.3.2 上拉/下拉电阻

在 [8]认识GPIO 章节中我们会详细介绍，这里先简单说明。

当一个 GPIO 引脚悬空（既没有接高电平也没有接低电平）时，它的电平状态是不确定的，会受到周围电磁干扰的影响而随机跳变。这在数字电路中是绝对不允许的。

上拉电阻：一端接引脚，另一端接 VDD（3.3V）。没有外部信号时，引脚被拉到高电平。
下拉电阻：一端接引脚，另一端接 GND。没有外部信号时，引脚被拉到低电平。

实际案例：天空星核心板的复位按键

正常情况下，NRST 引脚通过 10kΩ 上拉电阻保持高电平（3.3V），芯片正常运行。按下按键时，NRST 被直接拉到 GND（低电平），触发芯片复位。松开按键后，上拉电阻又把 NRST 拉回高电平，芯片重新启动。

实际案例：I2C 为什么需要上拉？

I2C 总线的 SCL 和 SDA 通常是开漏结构，设备只能主动拉低，不能主动输出高电平。所以总线上必须有上拉电阻，把空闲状态拉到高电平。筑基学习板的 I2C1 上挂了 ES8388、SD3078、AHT20、INA226、AT24C02、PCA9555PW 等多个设备，并通过 PCA9517 做了 I2C 缓冲增强。

初学时只要先记住：如果某条 I2C 总线没有上拉电阻，通信大概率会失败；如果挂载设备太多、线太长、上拉不合适，也会出现扫描不到设备或偶发通信错误。

4.3.3 电阻的封装与标识

在天空星学习板的原理图和 PCB 上，你会看到各种封装的电阻：

封装	尺寸（mm）	常见用途	功率
0201	0.6 × 0.3	手机等极小空间	1/20W
0402	1.0 × 0.5	密集布局	1/16W
0603	1.6 × 0.8	最常用	1/10W
0805	2.0 × 1.25	手焊友好	1/8W
1206	3.2 × 1.6	大功率场景	1/4W

天空星学习板上大部分电阻使用 0402 或 0603 封装。

4.3.4 串联与并联

串联和并联是看懂电路的基本语言。很多初学者看原理图时觉得复杂，其实把电路拆开后，很多地方就是几个元件串起来或者几个元件并起来。

电阻串联：

串联时，电流相同，总电阻相加：

R_{t o t a l} = R 1 + R 2

典型应用是分压。前面讲到的 ADC 电压采样、DC-DC 反馈电阻，本质上都是利用串联电阻把一个较高电压按比例分成较低电压。

电阻并联：

并联时，电压相同，总电阻会变小：

\frac{1}{R_{t o t a l}} = \frac{1}{R 1} + \frac{1}{R 2}

如果两个电阻相同，比如两个 10kΩ 并联，总电阻就是 5kΩ。工程上有时会用并联电阻来凑阻值、分担功耗，或者在调试阶段临时调整反馈电阻比例。

电容串联和并联：

电容的规律和电阻有点相反：

连接方式	电阻规律	电容规律	常见用途
串联	总电阻变大	总电容变小	分压、限流、提高耐压
并联	总电阻变小	总电容变大	去耦、滤波、储能

在单片机板子上，最常见的是电容并联。例如一个芯片电源脚旁边可能同时放 100nF + 1μF + 10μF：

100nF 负责吸收高频毛刺。
1μF 负责处理中等频率的电源波动。
10μF 负责提供更大的本地储能。

NOTE

看到多个电容并在同一条电源线上，不是重复放料，而是在覆盖不同频率范围的电源噪声。后续看 GPIO、ADC、通信接口时，如果遇到电源不稳、采样跳变或偶发复位，去耦电容和电源路径往往是第一批要检查的对象。

4.4 电容

电容就像一个微型的储水桶 ——它能存储电荷（能量），也能释放电荷。在嵌入式开发中，电容最重要的应用是去耦和滤波。

4.4.1 电容的基本特性

充电：当电压施加到电容两端时，电容会吸收电荷，电压逐渐升高。
放电：当外部电压消失时，电容会释放存储的电荷，维持一段时间的电压。
隔直通交：电容不允许直流电流通过（充满后就不再有电流），但允许交流信号通过（不断充放电）。

电容还有一个初学者必须注意的点：有些电容有极性。陶瓷电容一般不分正负，电解电容、钽电容通常分正负。极性电容接反可能发热、鼓包甚至损坏。开发板上常见的小贴片陶瓷电容大多不分极性，但如果你以后自己外接大容量电容，一定要先确认正负极。

4.4.2 去耦电容（极其重要）

在天空星学习板的原理图上，你会发现每个芯片的电源引脚旁边都有一个或多个小电容（通常是 100nF 即 0.1μF，有时还会并联一个 1μF 或 10μF）。这些就是去耦电容（Decoupling Capacitor）。

为什么需要去耦电容？

当芯片内部的数字电路快速切换时（比如 GPIO 从低电平跳到高电平），会在极短的时间内从电源线上抽取一大股电流。如果电源线上没有就近的能量储备，这股瞬间的大电流会导致电源电压短暂下降（称为电源毛刺或电源噪声）。

去耦电容就像一个本地小水桶，紧挨着芯片放置。当芯片需要瞬间大电流时，去耦电容立即释放存储的电荷来满足需求，避免电源电压波动。

没有这些电容，你的单片机可能一跑大程序就莫名死机、ADC 采样值乱跳、通信数据出错。

IMPORTANT

去耦电容必须尽可能靠近芯片的电源引脚放置，走线要短。这是 PCB 设计的铁律。如果你将来自己设计电路板，千万不要忘记给每个芯片的电源脚加去耦电容。而且尽量要先经过电容再进入管脚，更多细节看这里的内容。

筑基学习板的主 5V 电源由 DC-DC 输出，后面还配有低 ESR 固态电容。它们负责更大的电流波动，比如电机、舵机、功放、RGB 灯等负载变化。可以这样理解：

芯片旁边的 100nF 是就近小水杯，负责高频瞬间电流。
电源入口或 DC-DC 输出处的大电容是水桶，负责较大能量波动。
两者不是互相替代，而是分工不同。

4.4.3 常见电容值与用途

电容值	用途	说明
100nF (0.1μF)	高频去耦	最常见，几乎每个芯片电源脚都有
1μF ~ 10μF	低频去耦/储能	配合 100nF 使用，滤除低频噪声
10μF ~ 100μF	电源滤波	放在电源入口处，平滑电压波动
10pF ~ 33pF	晶振匹配	与晶振配合使用，影响振荡频率

4.5 电感基础

电感有【阻碍电流突变】的脾气——当电流试图突然增大时，电感会产生一个反向电压来阻止；当电流试图突然减小时，电感会产生一个正向电压来维持。

这个特性使得电感在两个场景中非常有用：

电源滤波：和电容配合，组成 LC 滤波器，滤除电源线上的高频噪声。
DC-DC 储能：在开关电源（DC-DC）中，电感充当能量仓库。开关导通时，电感储存能量；开关断开时，电感释放能量给负载。天空星筑基学习板上的 XL4015E1 DC-DC 电路中就有一个一体成型的金属电感。

NOTE

对于初学者来说，电感的原理不需要深入理解。只需要知道：在 DC-DC 电路中看到电感是正常的，它是开关电源工作的核心元件之一。

4.6 二极管基础

二极管是最简单的半导体器件，它的核心特性就一个字：单向导电。

4.6.1 基本特性

正向导通：电流从阳极（A）流向阴极（K）时，二极管导通，但会产生一个正向压降（硅二极管约 0.7V，肖特基二极管约 0.3V）。
反向截止：电流试图从阴极流向阳极时，二极管截止（不导通），相当于断路。
反向击穿：如果反向电压超过二极管的耐压值，二极管会被击穿导通（普通二极管会损坏，稳压二极管则利用这个特性来稳压）。

4.6.2 常见二极管类型及在天空星学习板上的应用

类型	特点	天空星学习板上的应用
普通二极管	正向压降约 0.7V	续流二极管（蜂鸣器、继电器旁边）
肖特基二极管	压降小（约 0.3V），反应快	DC-DC 电路中的整流
TVS 二极管	能吸收瞬间高压脉冲	USB 接口、CAN/RS485 接口的 ESD 保护
稳压二极管（齐纳）	反向击穿电压精确可控	电压钳位保护
LED（发光二极管）	正向导通时发光	电源指示灯、状态指示灯

实际案例：天空星筑基学习板的接口保护

在天空星筑基学习板套件介绍中提到，电源输入、USB、调试接口、CAN/RS485、ADC 输入等位置都能看到保护设计。这里要分清几类保护：

防反接：防止电源正负极接反，常见做法有二极管、MOS 管、防反接芯片等。
过流保护：电流异常增大时切断或限制电流，常见于自恢复保险丝、限流开关等。
TVS/ESD 保护：吸收静电或瞬间高压脉冲，保护后面的芯片输入脚。

TVS 很适合吸收瞬间的尖峰，但它不是用来长期承受错误接线的万能保险。接线前确认极性和电压，永远比指望保护电路靠谱。

4.6.3 续流二极管

在天空星筑基学习板的蜂鸣器电路中，你会看到蜂鸣器两端并联了一个二极管。这就是续流二极管。

蜂鸣器和继电器内部都有线圈（电感性负载）。当驱动信号突然关断时，线圈中的电流不能瞬间消失（电感的特性），会产生一个很高的反向电压尖峰（可能达到几十伏甚至上百伏）。这个电压尖峰会击穿驱动三极管或 MOS 管。

续流二极管为这股无处可去的电流提供了一条回路，让它安全地消耗掉，保护驱动器件不被击穿。

4.7 三极管与 MOS 管

它们是电子世界的水龙头开关——用一个小信号来控制一个大电流的通断。

4.7.1 三极管（BJT）

三极管有三个引脚：基极（B）、集电极（C）、发射极（E）。

NPN 型：基极给高电平（相对于发射极），三极管导通，集电极到发射极之间的电流可以流过。
PNP 型：基极给低电平（相对于发射极），三极管导通。

三极管是电流控制型器件——需要持续提供基极电流来维持导通状态。

4.7.2 MOS 管

MOS 管也有三个引脚：栅极（G）、漏极（D）、源极（S）。

N-MOS：栅极给高电平，MOS 管导通（漏极到源极之间导通）。就像一个"下拉开关"。
P-MOS：栅极给低电平，MOS 管导通。就像一个"上拉开关"。

MOS 管是电压控制型器件——只需要在栅极施加电压即可，几乎不需要电流。这使得它非常适合被单片机的 GPIO 直接驱动。

为什么单片机更常用 MOS 管？

MOS 管是电压控制，GPIO 只需要输出高低电平即可，不需要提供额外的驱动电流。
MOS 管的导通电阻（Rds_on）可以做到非常小（几毫欧到几十毫欧），发热量小。
MOS 管的开关速度快，适合 PWM 控制。

实际案例：在 [8]认识GPIO 章节中，你会发现 STM32 GPIO 的内部输出部分就是由一对 P-MOS 和 N-MOS 组成的推挽结构——P-MOS 负责输出高电平（连接到 VDD），N-MOS 负责输出低电平（连接到 GND）。

4.7.3 为什么 GPIO 不能直接驱动大电流负载？

STM32 的 GPIO 输出电流能力有限（建议 ≤ 8mA，最大 25mA）。如果你想驱动一个电机（可能需要几百毫安甚至几安培的电流），就必须用 GPIO 去控制一个 MOS 管或三极管，再由 MOS 管或三极管去驱动电机。

天空星筑基学习板上的直流电机驱动（AT8236）和步进电机驱动（TMC2209）就是这个原理——GPIO 输出控制信号，驱动芯片内部的 MOS 管来驱动电机。

4.7.4 H 桥：为什么直流电机能正反转？

直流电机要正转或反转，本质是改变电机两端电流方向。H 桥就是由四个开关组成的电路，形状像字母 H：

实际 H 桥会有四个 MOS 管，通过不同组合导通，让电流从左到右或从右到左流过电机。筑基学习板的 AT8236 就是双路直流电机 H 桥驱动芯片，MCU 只需要输出 PWM 或者高低电瓶这类控制信号，真正的大电流由驱动芯片承担。

WARNING

不要用杜邦线把电机直接接到 STM32 引脚上测试。即使电机很小，启动电流和反向电压也可能让 GPIO 损坏。

4.8 接口、电平与保护

前面讲的是单个元器件，这一节把它们放回开发板接口里看。纯初学者做实验时，最常遇到的不是复杂公式，而是下面这些问题：这个模块是 3.3V 还是 5V？要不要共地？能不能直接接 GPIO？为什么有些地方要光耦隔离？

4.8.1 3.3V 和 5V：电源电压与信号电平不是一回事

STM32F407 的核心供电和 GPIO 逻辑主要是 3.3V，但筑基学习板上有不少 5V 外设：

外设/接口	为什么会出现 5V	板上如何处理
WS2812 RGB 灯	常见 WS2812 使用 5V 供电，数据信号也更偏向 5V 逻辑	使用电平转换芯片把 3.3V 信号转成 5V
舵机接口	常见舵机电源为 5V，控制信号常用 5V 更稳	板上对控制信号用MOS管来做了电平转换
HX711 称重模块	5V 供电时性能和抗干扰能力更好	使用电平转换芯片在 3.3V MCU 和 5V HX711 间转换，单向转换
CAN/RS485 隔离侧	总线侧由隔离电源供电	通过隔离芯片/收发器连接

这里要特别强调：外设用 5V 供电，不代表它的信号脚可以直接接 STM32。 有些外设可以识别 3.3V 高电平，有些不行；有些输出是 5V，高电平直接送进 STM32 可能损坏引脚。是否能直连，要看双方数据手册和原理图。

4.8.2 ADC 输入最怕超压

ADC 引脚读取的是模拟电压。STM32 的 ADC 输入范围通常不能超过参考电压范围，天空星核心板一般按 3.3V 系统理解。也就是说，ADC 采集的外部电压不要超过 3.3V。

筑基学习板上的外部 ADC 输入排针带有 TVS 和保护电阻，但保护不是让你随便接高压的理由。正确做法是：

先确认被测电压范围。
如果超过 3.3V，用电阻分压或专用采样电路降到安全范围。
用万用表先测一遍，再接到 ADC。

板载 10kΩ 可调电位器接到 PC0(ADC123_IN10)，非常适合初学者学习 ADC，因为它输出的是板内安全范围内的模拟电压。

4.8.3 光耦隔离：让危险和干扰离 MCU 远一点

光耦可以用光来传递信号，输入侧和输出侧电气上不直接相连。筑基学习板上的继电器控制、外部步进接口、CAN/RS485 等场景都使用了隔离或隔离电源相关设计。

隔离的好处是：

外部强干扰不容易直接串进 MCU。
外部设备地电位波动不容易影响核心板。
在继电器、工业总线、电机控制这类场景中更安全。

但隔离也意味着：隔离两侧的电源和地是分开的。初学者不要为了它们看起来更像普通电路而随便把隔离两侧 GND 短接。

4.8.4 继电器不是让初学者直接碰市电的理由

继电器可以用小信号控制较大电压或较大电流的负载。筑基学习板上的继电器控制信号经过光耦，再驱动继电器，本身设计上考虑了隔离和安全。

但是，本教程面向初学者，学习阶段请遵守一个简单规则：

市电实验涉及触电、火灾、安规、绝缘距离、保险丝、外壳、防护接地等一整套安全问题，不属于入门阶段该做的内容。

4.8.5 引脚复用也是一种电路连接

筑基学习板为了在有限的 STM32 引脚上连接尽可能多的外设，使用了八路拨码开关、模拟开关和 PCA9555PW IO 扩展芯片来切换部分信号路径。比如：

PB0/PB1 可以在 HX711 和外部 ADC 输入之间切换。
PB10/PC2/PC3 可以在 SPI2 和 I2S2 音频之间切换。
PB14/PB15 可以在舵机和直流电机 2 之间切换。
PA3 可以在板载 RGB 灯和外部 RGB 灯条之间切换。
插入 TF 卡时，SDIO 相关排针会被硬件动态切换到 TF 卡。

这意味着：代码里初始化了某个引脚，不代表这个引脚的信号一定已经连到你想要的外设。 如果外设不工作，要同时检查代码、拨码开关、PCA9555 配置、TF 卡插入状态和原理图。

TIP

后续做任何外设实验前，建议先看 这个在线工具，确认当前外设有没有和其他功能冲突，这里做的很详细：

五 LDO 与 DC-DC

电源是开发板的心脏。天空星学习板上同时使用了 LDO 和 DC-DC 两种电源方案，它们各有优劣，适用于不同的场景。理解它们的区别，不仅能帮你看懂电源电路，还能在将来自己设计电路时做出正确的选择。

5.1 LDO（低压差线性稳压器）

天空星学习板使用了三颗 LDO（SCJA1117B-3.3），分别给天空星核心板、板载传感器和外接排针供电。

5.1.1 工作原理

LDO 的原理非常简单——它内部就是一个可调电阻（实际上是一个 MOS 管工作在线性区）。输入电压减去输出电压的差值，全部以热量的形式消耗在这个电阻上。

5.1.2 优缺点

优点	缺点
输出纹波极小（μV 级），电源质量高	效率低，压差大时发热严重
电路简单，外围元件少（只需输入输出电容）	输入电压必须高于输出电压（有最小压差要求）
成本低	不适合大电流、大压差场景
无开关噪声，不会干扰模拟电路	—

5.1.3 效率计算

η = \frac{V_{O U T}}{V_{I N}} \times 100 %

5V 转 3.3V： $η = 3.3 / 5 = 66 %$ （还行）
12V 转 3.3V： $η = 3.3 / 12 = 27.5 %$ （灾难！72.5% 的能量变成热量）

这就是为什么天空星筑基学习板不用 LDO 直接从 12V/24V 降到 3.3V，而是先用 DC-DC 降到 5V，再用 LDO 从 5V 降到 3.3V。

5.1.4 适用场景

给 STM32 等精密数字芯片供电（对纹波敏感）
给 ADC 基准电压供电（对电源质量要求极高）
给音频电路供电（开关噪声会引入底噪）
压差小、电流小的场景（如 5V 转 3.3V，电流 < 500mA）

5.2 DC-DC（开关电源）

天空星筑基学习板使用了 XL4015E1 作为主 DC-DC 降压芯片，将 8~24V 输入降到 5V。

5.2.1 工作原理

DC-DC 的原理完全不同于 LDO。它通过一个高频开关（通常是 MOS 管）不断地开和关，配合电感和电容来实现电压转换。

简化过程：

开关导通：电流流过电感，电感储存能量（磁场）。
开关断开：电感释放储存的能量，通过二极管给输出电容充电。
重复：以几十 kHz 到几 MHz 的频率不断重复上述过程。

通过调节开关的导通时间与断开时间的比例（占空比），就能精确控制输出电压。

5.2.2 优缺点

优点	缺点
效率高（85%~95%），发热小	输出纹波较大（mV 级）
支持大压差转换（24V→5V 轻松搞定）	电路复杂，外围元件多（电感、二极管、电容）
支持大电流输出	有开关噪声，可能干扰模拟电路
支持升压、降压、升降压多种拓扑	成本相对较高

5.2.3 效率对比

以 12V 输入、3.3V 输出、500mA 电流为例：

方案	效率	功耗	发热
LDO 直接降压	27.5%	4.35W	非常严重，需要大散热片
DC-DC 降压	~90%	0.18W	几乎不发热

差距一目了然。这就是为什么天空星筑基学习板的主电源使用 DC-DC 而不是 LDO。

5.2.4 适用场景

大压差降压（12V/24V → 5V）
大电流输出（> 500mA）
电池供电设备（效率高 = 续航长）
驱动电机、LED 灯带等大功耗设备

5.3 天空星学习板的电源架构

天空星筑基学习板采用了 DC-DC + LDO + 多路保护/隔离 的电源方案。纯初学者可以先把它理解成三层：

输入层：从 Type-C、调试口 5V、DC 座或接线端子获得电源。
转换层：用 DC-DC 把 8~24V 高效降到 5V，用 LDO 把 5V 降到干净的 3.3V。
分配层：把 5V、3.3V、隔离 5V 分给不同外设，并用限流、过压、隔离等方式保护。

这种设计的思路是：

DC-DC 负责[粗活]：把高压大电流高效地降到 5V，减少发热。
LDO 负责[细活]：把 5V 进一步降到 3.3V，提供干净、低纹波的电源给精密芯片。
三路独立 LDO：核心板、板载设备、外接设备各用一路，减少相互影响。某一路异常时，不至于把整块板所有 3.3V 设备一起拖垮。
隔离电源负责工业接口：CAN、RS485、继电器、外部步进光耦等接口面对的是外部世界，干扰更大，所以用隔离电源和隔离器件把风险隔开。

TIP

如果你不需要驱动电机，可以直接用天空星核心板上的 TYPE-C 接口供电（5V），此时 DC-DC 不工作，所有设备由 TYPE-C 的 5V 通过 LDO 降压供电。这在日常学习中是最方便的方式。

5.4 初学者应该怎么给板子供电？

结合第 1 章的说明，可以按下面方式选择：

使用场景	推荐供电方式	说明
点灯、按键、串口、I2C、SPI、ADC 等基础实验	天空星核心板 Type-C 供电	最简单，接线少，适合刚开始学习
使用 DAPLink 调试并顺便供电	调试口 5V + GND	注意调试器供电能力，外设负载不要太大
驱动舵机、功放或较多 5V 外设	使用能力足够的 5V 电源	看负载电流，必要时单独供电并共地
驱动板载直流电机或步进电机	DC 座或 2P 接线端子输入 12V/24V	根据电机额定电压选择，注意输入方式二选一
只想从排针取电给小模块	使用 3.3V/5V 输出排针	注意这是输出，不是随便给板子供电的入口

纯初学者可以先记住三条：

不接电机时，优先 Type-C 供电。
接电机时，按电机额定电压接 12V 或 24V 输入。
不知道某个排针是输入还是输出电源时，不要接电源。

5.4.1 电机实验要更谨慎

电机和普通 LED、按键、传感器不一样。它有几个麻烦点：

启动电流大。
堵转电流更大。
关断时会产生反向电压。
会给电源带来明显噪声。
机械运动本身也有安全风险。

筑基学习板的直流电机驱动 AT8236 设置了过流保护，步进电机驱动 TMC2209 也有电流调节和保护机制，但保护机制不是让你随意接负载。做电机实验前应确认电机额定电压、电流、接线顺序和散热情况。

5.4.2 5V/5A、5V/2A、3.3V/0.7A 怎么理解？

这里也提到，筑基学习板各个接口提供不同电源输出能力，例如 5V/5A、5V/2A、3.3V/0.7A。这里的含义是「这一路最多按这个能力设计」，不是每个接口都能对外设提供很大的电流。

初学者使用外接模块时，可以按下面思路判断：

小传感器、普通逻辑模块：通常几十 mA 以内。
舵机、功放、RGB 灯条：可能几百 mA 到几 A。
电机：启动和堵转时电流可能远高于正常运行电流。

如果外设电流不确定，先查模块资料，再用万用表或电源表观察实际电流。不要把多个大功率负载都接在同一路小电流输出上。

六数字电路基础——逻辑门

虽然我们写代码时看到的是 if (a && b)，但在芯片内部，条件判断、寄存器控制、复用选择等功能都由大量逻辑门组合完成。STM32 的 GPIO、定时器、中断控制器等外设，底层都离不开这些基本逻辑结构。了解逻辑门，能帮你理解芯片手册中的功能框图。

6.1 基本逻辑门

逻辑门	符号	规则	C 语言等价
与门 (AND)	&	所有输入都为 1，输出才为 1	`a & b`
或门 (OR)	\|	只要有一个输入为 1，输出就为 1	`a \| b`
非门 (NOT)	~	输入取反	`~a`
异或门 (XOR)	^	输入不同时输出为 1	`a ^ b`
与非门 (NAND)	—	AND 的结果取反	`~(a & b)`
或非门 (NOR)	—	OR 的结果取反	`~(a \| b)`

6.2 逻辑门在 STM32 中的体现

可能有些同学觉得逻辑门离自己很远，每次操作寄存器时，我们都在和逻辑门打交道：

置 1 操作 REG |= (1 << n) 本质上就是一个或门——有 1 则 1。
清 0 操作 REG &= ~(1 << n) 本质上就是一个与门——有 0 则 0。
翻转操作 REG ^= (1 << n) 本质上就是一个异或门——不同则 1。

在 [8]认识GPIO 章节的 GPIO 框图中，你会看到施密特触发器、多路选择器等组件，它们的内部都是由逻辑门构成的。

6.3 多路选择器（MUX）

多路选择器在 STM32 中非常常见。它的功能就像一个旋转开关——根据选择信号，从多个输入中选择一个输出。

在 GPIO 的复用功能中，每个引脚最多有 16 个复用功能可选（AF0~AF15）。选择哪个功能，就是通过一个 16 选 1 的多路选择器来实现的，选择信号就是 AFRL/AFRH 寄存器中对应引脚的 4 位配置值。

天空星筑基学习板上的单刀双掷模拟开关（在 [1]天空星筑基学习板套件介绍中详细介绍过）也是类似的原理——通过控制信号选择将 MCU 引脚连接到哪个外设。

七如何阅读原理图

看懂原理图是嵌入式开发的基本功。即使你只做软件开发，也需要通过原理图来确认引脚连接关系、了解外设电路、排查硬件问题。

7.1 基本符号

原理图中的元器件都有标准的符号和标识。以下是最常见的：

符号前缀	代表元件	示例	说明
R	电阻 (Resistor)	R1, R24	最常见的元件
C	电容 (Capacitor)	C1, C10	去耦、滤波
L	电感 (Inductor)	L1, L2	DC-DC 储能、滤波
D	二极管 (Diode)	D1, D3	包括 LED、TVS、肖特基等
Q	晶体管 (Transistor)	Q1, Q2	三极管或 MOS 管
U	集成电路 (IC)	U3, U47	芯片
J	连接器 (Connector)	J1, J2	排针、排母、接口
SW	开关 (Switch)	SW1, SW7	按键、拨码开关
H	排针/排母 (Header)	H1, H2	天空星核心板的插座
P	接线端子 (Terminal)	P3	螺钉端子等

7.2 网络标号（Net Label）

在原理图中，如果两条线虽然没有直接连在一起，但都标注了相同的名称（如 LED_R、PA0、BUZZER_PWM），那它们在物理上是连通的。这就是网络标号。

网络标号的作用是避免原理图变成一团乱麻——如果所有连接都用实际的线画出来，一张复杂的原理图会密密麻麻到无法阅读。

实际案例：在天空星筑基学习板的原理图中，你会看到 BUZZER_PWM 这个网络标号出现在多个地方：

在引脚分配页面，它连接到 PA6（天空星核心板的引脚）
在蜂鸣器页面，它连接到模拟开关的输入端

虽然这两个地方在原理图上可能相隔好几页，但通过相同的网络标号，我们知道它们在物理上是同一根线。

7.3 电源符号

原理图中的电源符号通常是特殊的网络标号：

符号	含义	天空星学习板上的典型电压
VCC / VDD	正电源	3.3V 或 5V
GND / VSS	电源地（0V）	0V
VDDA	模拟电源	3.3V（给 ADC 等模拟外设供电）
VBAT	备用电池电源	3V（纽扣电池，给 RTC 供电）
DCDC_OUT_VCC_5V	DC-DC 输出的 5V	5V
ONBOARD_3V3	板载设备的 3.3V	3.3V
IPS1_VCC_5V	隔离电源 1 的 5V	5V（隔离供电）

NOTE

在天空星筑基学习板的原理图中，不同的电源网络有不同的名称（如 SKYSTAR_+3V3、ONBOARD_+3V3、EXT_+3V3_OUT），虽然它们的电压都是 3.3V，但它们是由不同的 LDO 供电的，且每一路都进行了过流短路保护，物理上是隔离的。这种设计是为了防止某一路短路影响其他路，几乎每一路电源笔者都做了过流保护。

7.4 信号追踪实战

任务：找出天空星核心板上的 PA0 引脚最终连接到了筑基学习板上的什么设备。

步骤：

在天空星核心板的原理图中，找到 PA0 引脚，它通过排针引出。
在筑基学习板的 PIN_OUT 页面（第 1 页原理图），找到排母上对应的 PA0 网络标号。
在筑基学习板的其他页面中搜索 PA0 这个网络标号，找到它连接到了哪里。
你会发现 PA0 连接到了一个按键（SW5/SW6 之一）和天空星核心板上的用户按键。

通过这种「追踪网络标」的方法，你可以清晰地看到任何一个引脚的完整连接路径。这在排查硬件问题时非常有用——如果某个引脚的行为不符合预期，先看看原理图上它到底连到了哪里。

7.5 阅读原理图的一般步骤

先看电源：了解板子的供电方式、电压等级、电源路径。
看引脚分配：找到 MCU 的引脚分配表，了解每个引脚连接到了什么外设。
看具体外设：根据需要，查看具体外设的电路（如 LED、按键、传感器等）。
追踪信号：通过网络标号，追踪信号从 MCU 引脚到外设的完整路径。
注意保护电路：留意 TVS、限流电阻、去耦电容等保护元件的位置和参数。

大家也可以直接去看这个天空星·筑基学习板-引脚分配速查交互式文档，会比原理图更清晰。

TIP

天空星筑基学习板的原理图共有 20 页，每一页都有详细的中文注释。建议各位在学习每个外设之前，先花几分钟看看对应的原理图页面，了解硬件连接关系。这会让你的软件开发事半功倍。

7.6 结合引脚分配表排查问题

筑基学习板和普通最小系统板最大的不同，是它接入了非常多外设。STM32F407 的 100 脚看起来很多，但真正能自由分配的 IO 仍然有限，所以板子上使用了模拟开关、拨码开关、IO 扩展芯片来解决引脚复用问题。

这意味着，排查问题时不能只看代码，还要看【信号当前到底被硬件接到哪里了】。

7.6.1 外设不工作时的排查顺序

如果你写了代码，但某个外设没有反应，建议按下面顺序排查：

电源是否正常：用万用表测 5V、3.3V 是否存在。
GND 是否正确：外接模块是否和开发板共地，隔离接口是否按隔离方式连接。
引脚是否正确：对照 [9]筑基学习板引脚分配表，确认 MCU 引脚和外设名称。
拨码开关是否正确：检查 SW7 （板子左下角那个红色拨动开关）是否把信号切到了目标外设。
PCA9555 是否接管了开关：如果软件配置了 PCA9555，软件优先级是会高于物理拨码的。
是否存在动态冲突：例如 TF 卡插入后，SDIO 相关排针会被硬件切断给 TF 卡使用。
外设初始化是否正确：最后再回头检查 GPIO 模式、时钟、复用功能、通信参数。

初学者常常一上来就怀疑代码，其实很多问题是硬件路径没接到。例如同样是 PB14/PB15，它们可以通过拨码开关选择去舵机，也可以去直流电机 2。如果拨码状态和代码期望不一致，程序再正确也没有效果。

7.6.2 什么是软件优先级高于拨码开关？

筑基学习板的 PCA9555PW 不仅能驱动 8 颗白色 LED，还能控制部分模拟开关。也就是说，某些信号路径既可以由物理拨码开关决定，也可以由软件通过 I2C1 控制。想更深入理解请看这里的文档。

纯初学阶段建议：

先用物理拨码开关，不急着用 PCA9555 控制模拟开关的IO选择。
每次实验前拍照或记录拨码状态。
如果后面代码里初始化了 PCA9555，就要明确知道自己有没有改变信号路径。

这个设计很有工程意义：它让一块板子能覆盖更多外设，也让软件可以自动切换资源。我那时候想这个方案可是想了很久。但对初学者来说，它也增加了一个排查维度，所以这个筑基学习有可能对纯初学者的适配性不够高。

7.6.3 看到接口先问三个问题

以后看到一个接口，不管是 I2C 排针、SPI 排针、ADC 输入、舵机、CAN、RS485、继电器，都先问：

问题	为什么要问
它需要几伏供电？	防止 5V/3.3V/12V 接错
它的信号电平是多少？	防止 5V 信号直接打到 3.3V 引脚
它有没有和其他外设复用？	防止拨码开关或 TF 卡状态导致信号没接到目标外设

这三个问题能帮你避开大部分入门硬件坑。

八本章小结

本章我们好像啥也没干，但我们补齐了通向嵌入式开发最重要的几块基石。

回顾了进制转换——这是你与寄存器对话的工具，后续每次配置外设都离不开十六进制和二进制的快速转换。梳理了 C 语言的工程化特性——volatile、指针、位操作、结构体，这些是你阅读和编写 HAL 库代码的钥匙。复习了电路基础——电源、地、信号、欧姆定律、电容去耦、二极管保护、MOS 管开关，这些是你理解原理图、保护硬件的护身符。我们还了解了 LDO 和 DC-DC 的区别，明白了天空星筑基学习板为什么会同时存在 8~24V 输入、5V、3.3V、隔离 5V 等多种电源。

请务必记住以下几个核心知识点，因为在接下来的学习中它们会反复出现：

位操作的四大技巧：置 1（|=）、清 0（&= ~）、翻转（^=）、检查（&）
volatile 关键字：中断共享变量必须加 volatile，否则编译器优化会让你的程序异常
指针与寄存器：GPIOA->ODR = 0x01 的本质就是往地址 0x40020014 写数据
欧姆定律： $U = I \times R$ ，算限流电阻、判断功耗、评估发热都靠它，以后选贴片电阻的封装最重要的参考就是这个电阻上所承载的最高功率
去耦电容：每个芯片电源脚旁边的 0.1μF 电容不是摆设，天空星核心板的每个去偶电容都是先经过电容再去到芯片引脚的，没有它可能会出现复位、ADC 跳变或通信异常
电源、地、信号：接线前先确认电压、GND 和信号电平，很多硬件问题不是代码错，有可能连接关系错
驱动与隔离：GPIO 只适合输出控制信号，电机、继电器、总线等信号要通过驱动芯片、光耦、隔离电源或收发器来连接
引脚复用检查：筑基学习板外设很多，做实验前要确认拨码开关、PCA9555 和 TF 卡动态切换状态

在后面的 [8]认识GPIO 章节中，我们会正式使用这些基础知识去点亮第一颗 LED。到那时你会发现，本章的知识对于纯初学者来说有多重要了。

GPIO基础

定时器与PWM基础

​

一 本章简介 ​

1.1 学习目标 ​

1.2 重点提示 ​

1.3 基础概念与术语 ​

1.3.1 数据与编码 ​

1.3.2 处理器与总线 ​

1.3.3 寄存器与外设 ​

1.3.4 电源与电平 ​

1.3.5 软件相关 ​

1.4 本章知识和后续章节的关系 ​

二 进制与数据表示 ​

2.1 为什么要学习进制？ ​

2.2 二进制（Binary） ​

2.2.1 基本单位 ​

2.2.2 位的编号与权重 ​

2.3 十六进制（Hexadecimal） ​

2.3.1 基本规则 ​

2.3.2 为什么嵌入式常用十六进制？ ​

2.3.3 十六进制与二进制速查表 ​

2.4 八进制（Octal） ​

2.5 进制转换实战 ​

2.5.1 二进制 ↔ 十六进制（最常用） ​

2.5.2 二进制 ↔ 十进制 ​

2.5.3 实战例子：配置 GPIO 模式 ​

2.6 原码、反码、补码 ​

2.6.1 三种编码方式 ​

2.6.2 为什么要用补码？ ​

2.6.3 补码的本质 ​

2.6.4 补码的范围 ​

三 C 语言基础回顾 ​

3.1 数据类型与字节 ​

3.1.1 标准 C 数据类型 ​

3.1.2 定宽整数类型（强烈推荐） ​

3.1.3 浮点数的精度问题 ​

3.2 宏定义与预处理器 ​

3.2.1 #define 基本用法 ​

3.2.2 条件编译 ​

3.2.3 #include 的工作原理 ​

3.2.4 常见的预定义宏 ​

3.3 枚举与 typedef ​

3.3.1 枚举（enum） ​

3.3.2 typedef 的妙用 ​

3.4 结构体 ​

3.4.1 基本用法与 HAL 库实例 ​

3.4.2 结构体指针 ​

3.4.3 内存对齐与 __packed ​

3.5 位域 ​

3.6 指针 ​

3.6.1 指针的本质 ​

3.6.2 指针与寄存器 ​

3.6.3 函数指针与回调函数 ​

3.7 volatile 关键字详解 ​

3.7.1 什么是 volatile？ ​

3.7.2 没有 volatile 会怎样？ ​

3.7.3 必须使用 volatile 的三大场景 ​

3.7.4 volatile 不是万能的 ​

3.8 static 关键字 ​

3.8.1 static 局部变量 ​

3.8.2 static 全局变量/函数 ​

3.9 位操作（重中之重） ​

3.9.1 从一张 开关面板 理解 bit ​

3.9.2 位运算和逻辑运算不能混用 ​

3.9.3 不用背真值表，只需要要记住工程效果 ​

3.9.4 移位：用来把掩码放到正确位置 ​

3.9.5 操作寄存器的核心动作：读、改、写 ​

3.9.6 单个 bit 的四种基本操作 ​

3.9.7 多 bit 字段：先腾位置，再放新值 ​

3.9.8 读取字段：先筛出来，再移回去 ​

3.9.9 字段值要计算时，不要直接改整个寄存器 ​

3.9.10 一次修改多个字段：先准备清除掩码和写入值 ​

3.9.11 宏封装：让位操作更像工程代码 ​

3.9.12 常见错误：了解这些坑比语法本身更重要 ​

3.9.13 练习：换成真实一点的场景 ​

3.9.14 本节小结 ​

3.10 存储相关 ​

3.10.1 Flash vs RAM ​

3.10.2 变量存在哪里？ ​

一本章简介

1.1 学习目标

1.2 重点提示

1.3 基础概念与术语

1.3.1 数据与编码

1.3.2 处理器与总线

1.3.3 寄存器与外设

1.3.4 电源与电平

1.3.5 软件相关

1.4 本章知识和后续章节的关系

二进制与数据表示

2.1 为什么要学习进制？

2.2 二进制（Binary）

2.2.1 基本单位

2.2.2 位的编号与权重

2.3 十六进制（Hexadecimal）

2.3.1 基本规则

2.3.2 为什么嵌入式常用十六进制？

2.3.3 十六进制与二进制速查表

2.4 八进制（Octal）

2.5 进制转换实战

2.5.1 二进制 ↔ 十六进制（最常用）

2.5.2 二进制 ↔ 十进制

2.5.3 实战例子：配置 GPIO 模式

2.6 原码、反码、补码

2.6.1 三种编码方式

2.6.2 为什么要用补码？

2.6.3 补码的本质

2.6.4 补码的范围

三 C 语言基础回顾

3.1 数据类型与字节

3.1.1 标准 C 数据类型

3.1.2 定宽整数类型（强烈推荐）

3.1.3 浮点数的精度问题

3.2 宏定义与预处理器

3.2.1 #define 基本用法

3.2.2 条件编译

3.2.3 #include 的工作原理

3.2.4 常见的预定义宏

3.3 枚举与 typedef

3.3.1 枚举（enum）

3.3.2 typedef 的妙用

3.4 结构体

3.4.1 基本用法与 HAL 库实例

3.4.2 结构体指针

3.4.3 内存对齐与 __packed

3.5 位域

3.6 指针

3.6.1 指针的本质

3.6.2 指针与寄存器

3.6.3 函数指针与回调函数

3.7 volatile 关键字详解

3.7.1 什么是 volatile？

3.7.2 没有 volatile 会怎样？

3.7.3 必须使用 volatile 的三大场景

3.7.4 volatile 不是万能的

3.8 static 关键字

3.8.1 static 局部变量

3.8.2 static 全局变量/函数

3.9 位操作（重中之重）

3.9.1 从一张开关面板理解 bit

3.9.2 位运算和逻辑运算不能混用

3.9.3 不用背真值表，只需要要记住工程效果

3.9.4 移位：用来把掩码放到正确位置

3.9.5 操作寄存器的核心动作：读、改、写

3.9.6 单个 bit 的四种基本操作

3.9.7 多 bit 字段：先腾位置，再放新值

3.9.8 读取字段：先筛出来，再移回去

3.9.9 字段值要计算时，不要直接改整个寄存器

3.9.10 一次修改多个字段：先准备清除掩码和写入值

3.9.11 宏封装：让位操作更像工程代码

3.9.12 常见错误：了解这些坑比语法本身更重要

3.9.13 练习：换成真实一点的场景

3.9.14 本节小结

3.10 存储相关

3.10.1 Flash vs RAM

3.10.2 变量存在哪里？

3.10.3 大端与小端

四电路基础回顾

4.1 初学者先分清：电源、地、信号