STM32 入门教程

这份教程的重点

你的起点

资料依据

第一部分 · 认识 STM32　第 1-4 章

第二部分 · 程序怎么跑起来　第 5-9 章 ★核心

第三部分 · 外设　第 10-17 章

1.1 从 51 到 STM32：变的不只是主频

你 51 已经学到步进电机了，那 51 的套路是：

sbit LED = P2^0;      // 直接操作一个位
LED = 0;              // 写 1 条指令，引脚立刻变了

STM32 上写同样的功能，代码长这样：

RCC->APB2ENR |= 1 << 2;      // ① 先开 GPIOA 的时钟（51 从不需要这一步！）
GPIOA->CRL &= ~(0xF << 0);   // ② 配 PA0 为推挽输出（51 也不用）
GPIOA->CRL |= (0x2 << 0);
GPIOA->ODR &= ~1;            // ③ 才轮到输出低电平

1.2 一张表看清差别

1.3 学 STM32 要过的三道坎

1.4 本章练习

1. STM32 上操作 GPIO 前必须做的一件事是什么？51 为什么不需要？
2. 20KB RAM 对比 512B，大约是多少倍？能装下多少个 int（4 字节）变量？
3. 为什么说 STM32 是「配置硬件」而 51 是「直接操作硬件」？

2.1 STM32 是什么

课件原文：STM32 是 ST 公司基于 ARM Cortex-M 内核开发的 32 位微控制器。

STM32 = ST（意法半导体，造芯片的）
      + ARM Cortex-M（内核设计公司，只卖 IP 不造芯片）
      + 外设（ST 自己加的 GPIO/ADC/USART…）

2.2 我们的芯片：STM32F103C8T6

2.3 型号怎么读

S T M 32 F 1 0 3 C 8 T 6
│ │ │ │  │ │ │ │ │ │ └─ 温度范围：6 = -40~85℃
│ │ │ │  │ │ │ │ │ └─── 封装：T = LQFP
│ │ │ │  │ │ │ │ └───── 容量：8 = 64KB Flash
│ │ │ │  │ │ │ └─────── 引脚：C = 48 脚
│ │ │ │  │ │ └───────── 子系列：103 = 增强型
│ │ │ │  │ └─────────── 系列：F1 = 主流
│ │ │ │  └───────────── F = 通用型
│ │ │ └──────────────── 32 = 32 位
│ │ └────────────────── M = 微控制器（Microcontroller）
│ └──────────────────── T = ST 公司
└────────────────────── S = 意法半导体

2.4 片上资源（这就是「组成」的清单）

课件第 8 页列出的全部外设 —— 先混个眼熟，后面每章会深入一个：

2.5 本章练习

1. STM32F103C8T6 里，F/C/8/T 各代表什么？
2. 为什么 5V 传感器不能直接接 STM32 引脚？
3. C8T6 有没有 DAC？为什么？

3.1 组成总览：四个部分

STM32 内部可以拆成四块，看图和记名字：

3.2 为什么要有三条总线

参考手册 §2.1 原文：「APB1 操作速度限于 36MHz，APB2 操作于全速（最高 72MHz）。」

3.3 总线矩阵：比「一条总线」更强

51 是单总线，同一时刻只能一个设备用。STM32 是总线矩阵 —— 多条通路并行：

CPU 取指（ICode） ──┐
CPU 取数（DCode） ──┼──→ 总线矩阵 ──→ Flash / SRAM / 外设
DMA 搬运 ──────────┘

所以 CPU 在 Flash 里取指令的同时，DMA 可以往 SRAM 搬数据，不冲突。

3.4 内部还有个大件：启动 ROM

（以上地址来自参考手册 §2.3.3 表 2/表 3，中容量产品）

3.5 本章练习

1. APB1 和 APB2 的最高频率各是多少？为什么不同？
2. 系统存储器里存的是什么？什么情况下会用到？
3. 总线矩阵相比单总线的好处是什么？

4.1 最小系统：能让芯片跑起来的最少元件

4.2 引脚分布（LQFP48）

4.3 和 51 的引脚对比

4.4 本章练习

1. 最小系统里哪几个元件是必须的？各自作用？
2. 为什么 PA13/PA14 不能随便当普通 IO 用？
3. VDDA 和 VDD 有什么区别？

5.1 一句话理解存储器映像

参考手册 §2.2 原文：「程序存储器、数据存储器、寄存器和输入输出端口被组织在同一个 4GB 的线性地址空间内。数据字节以小端格式存放在存储器中。」

5.2 五个必记地址（课件第 101 页原文）

5.3 为什么有两个 Flash 地址

这是最容易懵的地方：

Flash 物理上固定在 0x0800 0000
但 CPU 复位后固定从 0x0000 0000 取向量
→ 所以 Flash 被「别名」映射到 0x0000 0000

同一块 Flash，两个地址都能访问：
  0x0800 0000  → 原始地址（写保护操作、擦除用这个）
  0x0000 0000  → 别名地址（CPU 取向量用）

参考手册 §2.4 原文：「从主闪存存储器启动：主闪存存储器被映射到启动空间（0x0000 0000），但仍然能够在它原有的地址（0x0800 0000）访问它。」

5.4 用地址直接访问：寄存器就是内存

// 方法一：直接对着地址写（最原始）
#define GPIOA_ODR   (*(volatile unsigned int *)0x4001080C)
GPIOA_ODR = 1;      // 让 PA0 输出高

// 方法二：用结构体指针（固件库的做法）
typedef struct {
    volatile unsigned int CRL;   // 0x00
    volatile unsigned int CRH;   // 0x04
    volatile unsigned int IDR;   // 0x08
    volatile unsigned int ODR;   // 0x0C
    ...
} GPIO_TypeDef;

#define GPIOA  ((GPIO_TypeDef *)0x40010800)

GPIOA->ODR = 1;     // 等价于上一行

5.5 volatile 为什么不能省

volatile unsigned int *p = (volatile unsigned int *)0x4001080C;

5.6 本章练习

1. Flash、SRAM、外设寄存器的起始地址各是多少？
2. 为什么 Flash 要从 0x0800 0000 映射到 0x0000 0000？
3. 不写 volatile 会有什么后果？

6.1 全流程总览

这是本教程最重要的一章。从你按下电源键，到 main() 第一行代码执行，中间经过 8 步：

6.2 逐步拆解

① 复位

三种情况会触发复位：上电、按复位键、看门狗溢出。复位后所有寄存器恢复默认值，CPU 进入已知状态。

② 锁存 BOOT 引脚

参考手册 §2.4 原文：「在系统复位后，SYSCLK 的第 4 个上升沿，BOOT 引脚的值将被锁存。」

③ 取初始 SP

CPU 从地址 0x0000 0000 读 4 个字节，装进主堆栈指针 MSP。

// 假设 Flash 开头是：00 50 00 20
// 小端格式 → 0x20005000
// 这就是栈顶地址（SRAM 里，20KB 的顶部）

④ 取复位向量

CPU 从地址 0x0000 0004 读 4 个字节，装进 PC（程序计数器）。

// 假设是：09 01 00 08
// 小端 → 0x08000109
// 这就是 Reset_Handler 的地址（注意最低位是 1，表示 Thumb 状态）

⑤ 执行 Reset_Handler

这是启动文件 startup_stm32f10x_md.s 里的汇编代码，见第 7 章。

⑥ SystemInit

配置时钟系统：把 HSI 8MHz 切换成 HSE 8MHz → PLL×9 → 72MHz。

⑦ __main

C 库函数，做两件事：

把 .data 段从 Flash 拷贝到 SRAM   ← 已初始化的全局变量
把 .bss  段清零                    ← 未初始化的全局变量

⑧ main()

终于轮到你的代码。注意：此时时钟已经是 72MHz，但外设时钟还是关着的，用之前要自己开。

6.3 如果启动失败，现象是什么

6.4 本章练习

1. CPU 复位后从哪两个地址取数据？分别装进什么寄存器？
2. BOOT0=1、BOOT1=0 时从哪启动？什么场景用？
3. __main 为什么要从 Flash 拷贝 .data 到 SRAM？

7.1 启动文件长什么样

打开 Start/startup_stm32f10x_md.s，最开头是：

Stack_Size      EQU     0x00000400        ; 栈大小 = 1KB

                AREA    STACK, NOINIT, READWRITE, ALIGN=3
Stack_Mem       SPACE   Stack_Size
__initial_sp                              ; ★ 这个标号就是「初始 SP」

Heap_Size       EQU     0x00000200        ; 堆大小 = 512B
                AREA    HEAP, NOINIT, READWRITE, ALIGN=3
__heap_base
Heap_Mem        SPACE   Heap_Size
__heap_limit

7.2 向量表：中断入口的清单

                AREA    RESET, DATA, READONLY
__Vectors       DCD     __initial_sp              ; 0x00  ← 初始 SP
                DCD     Reset_Handler             ; 0x04  ← 复位入口
                DCD     NMI_Handler               ; 0x08
                DCD     HardFault_Handler         ; 0x0C
                DCD     MemManage_Handler         ; 0x10
                DCD     BusFault_Handler          ; 0x14
                DCD     UsageFault_Handler        ; 0x18
                DCD     0                         ; 0x1C 保留
                DCD     0
                DCD     0
                DCD     0
                DCD     SVC_Handler               ; 0x2C
                DCD     DebugMon_Handler          ; 0x30
                DCD     0
                DCD     PendSV_Handler            ; 0x38
                DCD     SysTick_Handler           ; 0x3C
                ; …… 之后是 60 个外设中断
                DCD     WWDG_IRQHandler           ; 窗口看门狗
                DCD     PVD_IRQHandler            ; 电源电压检测
                DCD     TAMPER_IRQHandler         ; 侵入检测
                DCD     RTC_IRQHandler            ; RTC
                DCD     FLASH_IRQHandler          ; Flash 全局
                DCD     RCC_IRQHandler            ; RCC
                DCD     EXTI0_IRQHandler          ; 外部中断 0
                ...

7.3 Reset_Handler：真正的第一段代码

Reset_Handler   PROC
                EXPORT  Reset_Handler             [WEAK]
                IMPORT  __main
                IMPORT  SystemInit
                LDR     R0, =SystemInit       ; ① R0 = SystemInit 地址
                BLX     R0                    ; ② 调用它（配置时钟）
                LDR     R0, =__main           ; ③ R0 = __main 地址
                BX      R0                    ; ④ 跳过去（不返回）
                ENDP

7.4 为什么叫「弱定义」

                EXPORT  Reset_Handler             [WEAK]

[WEAK] 是弱符号：如果别的地方（比如 stm32f10x_it.c）定义了一个同名的强符号，就用那个。

所以中断服务函数你可以在任何 .c 文件里写，只要名字对上，就会覆盖启动文件里的空实现：

// stm32f10x_it.c 里写
void TIM2_IRQHandler(void)   // 名字必须和启动文件里的一致
{
    // 你的中断处理
}

7.5 本章练习

1. 初始 SP 的值是链接时定的还是运行时算的？从哪个标号来？
2. Reset_Handler 里为什么要先调 SystemInit 再调 __main？
3. [WEAK] 是什么意思？为什么中断函数能随便写在哪个 .c 文件？

8.1 一条 C 语句的完整旅程

8.2 源码级拆解

GPIOA->ODR = 0x0001;      // C 源码

① 编译器展开宏

// GPIOA 在 stm32f10x.h 里定义成：
#define GPIOA   ((GPIO_TypeDef *)0x40010800)

// 展开后：
((GPIO_TypeDef *)0x40010800)->ODR = 0x0001;

② 算出成员偏移

// GPIO_TypeDef 结构体里，ODR 是第 4 个成员，前 3 个各 4 字节
// 所以 ODR 的偏移 = 0x0C

// 最终等价于：
*(volatile unsigned int *)(0x40010800 + 0x0C) = 0x0001;
*(volatile unsigned int *)(0x4001080C) = 0x0001;

③ 生成汇编

MOVS    r1, #1                 ; r1 = 1
LDR     r0, =0x4001080C        ; r0 = 目标地址（从常量池加载）
STR     r1, [r0]               ; ★ 把 r1 写到 r0 指向的地址

④ CPU 执行 STR

这条 STR 指令会让 CPU 通过 DCode 总线发出一个写操作，地址 0x4001080C，数据 0x00000001。

⑤ 硬件响应

写操作到达 GPIOA 外设，其 ODR（输出数据寄存器）的 bit0 变成 1 → PA0 引脚的输出驱动器动作 → 引脚电平变为高。

8.3 完整对照表

8.4 反过来：读引脚

unsigned char key = GPIOA->IDR & 0x01;    // 读 PA0 电平

编译成：

LDR  r0, =0x40010808     ; IDR 的地址
LDR  r0, [r0]            ; ★ 读这个地址
AND  r0, r0, #1          ; 取 bit0

8.5 从编译到烧录：文件格式

烧录时，下载器把 .hex/.bin 按地址写入 Flash 0x0800 0000 开始的位置。

8.6 本章练习

1. GPIOA->ODR = 1 最终写到了哪个地址？
2. ODR 和 IDR 有什么区别？什么时候会不一样？
3. STR 指令在硬件层面做了什么？

9.1 时钟树总览

STM32 最反直觉的设计：时钟不是只有一个，而是一棵树。

9.2 五个时钟源

9.3 72MHz 是怎么算出来的

HSE = 8 MHz（外部晶振）
PLL 输入 = HSE / 1 = 8 MHz        （PLLXTPRE 位选择，默认不分频）
PLL 倍频 = ×9                     （PLLMUL 位 = 0111）
PLL 输出 = 8 × 9 = 72 MHz

SYSCLK = PLL 输出 = 72 MHz        （SW 位选择 PLL 作为系统时钟）

AHB 预分频 = /1  → HCLK = 72 MHz
APB2 预分频 = /1 → PCLK2 = 72 MHz
APB1 预分频 = /2 → PCLK1 = 36 MHz  ★ 不能超过 36MHz

9.4 SystemInit 到底做了什么

void SystemInit(void)
{
    /* ① 打开 HSE */
    RCC->CR |= 1 << 16;              // HSEON = 1
    while (!(RCC->CR & (1 << 17)));  // 等 HSERDY 置位

    /* ② 配置 PLL：HSE 不分频，×9 */
    RCC->CFGR &= ~(0xF << 18);        // 清 PLLMUL
    RCC->CFGR |= (0x7 << 18);         // PLLMUL = 0111 = ×9
    RCC->CFGR |= (1 << 16);           // PLLSRC = 1，选 HSE

    /* ③ 打开 PLL */
    RCC->CR |= 1 << 24;               // PLLON = 1
    while (!(RCC->CR & (1 << 25)));  // 等 PLLRDY

    /* ④ 切换系统时钟到 PLL */
    RCC->CFGR &= ~0x3;                // 清 SW
    RCC->CFGR |= 0x2;                 // SW = 10，选 PLL
    while ((RCC->CFGR & (0x3 << 2)) != (0x2 << 2));  // 等 SWS
}

9.5 外设时钟：为什么要单独开

参考手册 §2.1 原文：「在每一次复位以后，所有除 SRAM 和 FLITF 以外的外设都被关闭，在使用一个外设之前，必须设置寄存器 RCC_AHBENR 来打开该外设的时钟。」

RCC->APB2ENR |= 1 << 2;    // 开 GPIOA 时钟（bit2 = IOPAEN）
RCC->APB2ENR |= 1 << 0;    // 开 AFIO 时钟（bit0，用 EXTI 时必须开）
RCC->APB1ENR |= 1 << 0;    // 开 TIM2 时钟
RCC->AHBENR  |= 1 << 0;    // 开 DMA1 时钟

9.6 本章练习

1. HSE 8MHz 经 PLL ×9 后是多少？AHB/APB2/APB1 各是多少？
2. 为什么 APB1 必须 /2？
3. 复位后默认用哪个时钟？多少 MHz？
4. RCC_APB2ENR 的地址是多少？开 GPIOA 时钟要写哪一位？

10.1 GPIO 的 8 种模式

10.2 寄存器：一个端口 7 个寄存器

GPIOA 基地址 = 0x4001 0800
所以 GPIOA_ODR = 0x4001 0800 + 0x0C = 0x4001 080C ✓

10.3 点灯：三种写法对比

① 直接操作寄存器（最原始，看清本质）

#include "stm32f10x.h"

int main(void)
{
    RCC->APB2ENR |= 1 << 2;        // 开 GPIOA 时钟

    GPIOA->CRL &= ~(0xF << 0);     // 清 PA0 的 4 位配置
    GPIOA->CRL |= (0x2 << 0);      // 00 10 → 推挽输出 2MHz

    while (1)
    {
        GPIOA->ODR &= ~0x0001;     // PA0 低 → 亮
        for (int i = 0; i < 1000000; i++);
        GPIOA->ODR |= 0x0001;       // PA0 高 → 灭
        for (int i = 0; i < 1000000; i++);
    }
}

② 用固件库（江协教程的写法）

#include "stm32f10x.h"

int main(void)
{
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

    GPIO_InitTypeDef GPIO_InitStructure;
    GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_Out_PP;   // 推挽输出
    GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_0;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    while (1)
    {
        GPIO_ResetBits(GPIOA, GPIO_Pin_0);   // 低
        Delay_ms(500);
        GPIO_SetBits(GPIOA, GPIO_Pin_0);     // 高
        Delay_ms(500);
    }
}

10.4 BSRR 为什么比 ODR 好

// 想同时把 PA0 置 1、PA1 清 0：

// ODR 写法（读-改-写，3 条指令，可能被中断打断）
GPIOA->ODR |= 0x0001;
GPIOA->ODR &= ~0x0002;

// BSRR 写法（1 条指令，原子操作，绝对不会被打断）
GPIOA->BSRR = 0x0001 | (0x0002 << 16);
//          低 16 位 = 置 1 的位；高 16 位 = 清 0 的位

10.5 本章练习

1. GPIOA_ODR 的绝对地址是多少？
2. ADC 采样时引脚要配成什么模式？配错了会怎样？
3. BSRR 相比 ODR 的最大优势是什么？

11.1 STM32 的中断体系和 51 的差别

11.2 NVIC：内核里的中断管家

抢占优先级 vs 响应优先级

// 常用分组：NVIC_PriorityGroup_2 → 2 位抢占 + 2 位响应
// 即抢占优先级 0~3，响应优先级 0~3

NVIC_InitTypeDef n;
n.NVIC_IRQChannel = EXTI0_IRQn;
n.NVIC_IRQChannelPreemptionPriority = 2;  // 抢占
n.NVIC_IRQChannelSubPriority = 1;         // 响应
n.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&n);

11.3 EXTI：外部中断线

EXTI 有 20 条线，其中 EXTI0~EXTI15 对应 GPIO：

EXTI0  ← PA0 / PB0 / PC0 …（同一时刻只能选一个）
EXTI1  ← PA1 / PB1 / PC1 …
…
EXTI15 ← PA15 / PB15 …

选哪个端口由 AFIO_EXTICR 寄存器决定：

// 把 EXTI0 接到 PA0
AFIO->EXTICR[0] &= ~0xF;      // 清低 4 位
AFIO->EXTICR[0] |= 0x0;        // 0000 = 选 PA
// 选 PB0 就写 0x1，PC0 写 0x2 …

11.4 完整例子：按键触发中断翻转 LED

#include "stm32f10x.h"

void LED_Init(void)
{
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    GPIO_InitTypeDef g;
    g.GPIO_Mode  = GPIO_Mode_Out_PP;
    g.GPIO_Pin   = GPIO_Pin_0;
    g.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &g);
    GPIO_SetBits(GPIOA, GPIO_Pin_0);       // 默认灭
}

void Key_EXTI_Init(void)
{
    /* ① 按键引脚：PB1 上拉输入 */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
    GPIO_InitTypeDef g;
    g.GPIO_Mode  = GPIO_Mode_IPU;          // 上拉输入
    g.GPIO_Pin   = GPIO_Pin_1;
    g.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOB, &g);

    /* ② 开 AFIO 时钟（用 EXTI 必须开！） */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);

    /* ③ 把 EXTI1 接到 PB1 */
    GPIO_EXTILineConfig(GPIO_PortSourceGPIOB, GPIO_PinSource1);

    /* ④ 配置 EXTI1：下降沿触发 */
    EXTI_InitTypeDef e;
    e.EXTI_Line    = EXTI_Line1;
    e.EXTI_Mode    = EXTI_Mode_Interrupt;
    e.EXTI_Trigger = EXTI_Trigger_Falling;
    e.EXTI_LineCmd = ENABLE;
    EXTI_Init(&e);

    /* ⑤ NVIC 使能 */
    NVIC_InitTypeDef n;
    n.NVIC_IRQChannel = EXTI1_IRQn;
    n.NVIC_IRQChannelPreemptionPriority = 2;
    n.NVIC_IRQChannelSubPriority = 1;
    n.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&n);
}

/* ⑥ 中断服务函数：名字必须是 EXTI1_IRQHandler */
void EXTI1_IRQHandler(void)
{
    if (EXTI_GetITStatus(EXTI_Line1) == SET)      // 确认是这条线
    {
        /* 简单消抖 */
        for (int i = 0; i < 20000; i++);

        if (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_1) == 0)   // 确认还在按
        {
            if (GPIO_ReadOutputDataBit(GPIOA, GPIO_Pin_0))
                GPIO_ResetBits(GPIOA, GPIO_Pin_0);
            else
                GPIO_SetBits(GPIOA, GPIO_Pin_0);
        }

        EXTI_ClearITPendingBit(EXTI_Line1);       // ★ 必须手动清标志！
    }
}

int main(void)
{
    LED_Init();
    Key_EXTI_Init();
    while (1) { }
}

11.5 本章练习

1. EXTI0 想接到 PB0，AFIO_EXTICR 应该写什么？
2. 为什么中断服务函数最后必须清标志位？
3. 抢占优先级和响应优先级的区别？

12.1 STM32 的定时器家族

12.2 时基单元：三个寄存器决定一切

时钟源 → [预分频器 PSC] → [计数器 CNT] → [自动重装 ARR] → 溢出/中断

定时时间怎么算

定时时间 = (ARR + 1) × (PSC + 1) / f_CLK

例：TIM2 挂在 APB1，时钟 72MHz（见下面说明）
要定时 1ms：
  设 PSC = 71  → f_cnt = 72MHz / 72 = 1MHz（每计数一次 1μs）
  设 ARR = 999 → 1000 × 1μs = 1ms ✓

12.3 定时中断完整代码

#include "stm32f10x.h"

void Timer2_Init(void)
{
    /* ① 开 TIM2 时钟（在 APB1 上） */
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);

    /* ② 配置时基单元 */
    TIM_TimeBaseInitTypeDef t;
    t.TIM_ClockDivision     = TIM_CKD_DIV1;
    t.TIM_CounterMode       = TIM_CounterMode_Up;   // 向上计数
    t.TIM_Period            = 1000 - 1;             // ARR = 999
    t.TIM_Prescaler         = 72 - 1;               // PSC = 71
    t.TIM_RepetitionCounter = 0;
    TIM_TimeBaseInit(TIM2, &t);

    /* ③ 开更新中断 */
    TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);

    /* ④ NVIC */
    NVIC_InitTypeDef n;
    n.NVIC_IRQChannel = TIM2_IRQn;
    n.NVIC_IRQChannelPreemptionPriority = 2;
    n.NVIC_IRQChannelSubPriority = 1;
    n.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&n);

    /* ⑤ 启动定时器 */
    TIM_Cmd(TIM2, ENABLE);
}

volatile unsigned int cnt = 0;

void TIM2_IRQHandler(void)
{
    if (TIM_GetITStatus(TIM2, TIM_IT_Update) == SET)
    {
        cnt++;
        if (cnt >= 500)      // 500ms × 2 = 1s
        {
            cnt = 0;
            GPIOA->ODR ^= 0x0001;    // 翻转 PA0
        }
        TIM_ClearITPendingBit(TIM2, TIM_IT_Update);   // ★ 清标志
    }
}

int main(void)
{
    LED_Init();          // 同第 10 章
    Timer2_Init();
    while (1) { }
}

12.4 和 51 定时器对比

12.5 本章练习

1. 要定时 20ms，PSC=71 时 ARR 应该多少？
2. 为什么 TIM2 的时钟是 72MHz 而不是 36MHz？
3. 定时器中断里忘了清标志会怎样？

13.1 PWM 是怎么产生的

计数器 CNT 一直从 0 数到 ARR（锯齿波）
同时有个比较值 CCR
  CNT < CCR  → 输出有效电平（高）
  CNT ≥ CCR  → 输出无效电平（低）

于是引脚上就出现了方波，占空比 = CCR / (ARR+1)

13.2 呼吸灯完整代码

#include "stm32f10x.h"

void PWM_Init(void)
{
    /* ①  GPIO：PA0 配成复用推挽（因为要交给 TIM2 控制） */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    GPIO_InitTypeDef g;
    g.GPIO_Mode  = GPIO_Mode_AF_PP;        // ★ 复用推挽，不是普通推挽
    g.GPIO_Pin   = GPIO_Pin_0;
    g.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &g);

    /* ②  TIM2 时基：1kHz */
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
    TIM_TimeBaseInitTypeDef t;
    t.TIM_ClockDivision     = TIM_CKD_DIV1;
    t.TIM_CounterMode       = TIM_CounterMode_Up;
    t.TIM_Period            = 100 - 1;     // ARR = 99 → 100 级
    t.TIM_Prescaler         = 7200 - 1;    // 72MHz/7200 = 10kHz，再 /100 = 100Hz
    t.TIM_RepetitionCounter = 0;
    TIM_TimeBaseInit(TIM2, &t);

    /* ③  输出比较通道 1 */
    TIM_OCInitTypeDef oc;
    TIM_OCStructInit(&oc);
    oc.TIM_OCMode      = TIM_OCMode_PWM1;
    oc.TIM_OutputState = TIM_OutputState_Enable;
    oc.TIM_OCPolarity  = TIM_OCPolarity_High;
    oc.TIM_Pulse       = 0;                // 初始占空比 0
    TIM_OC1Init(TIM2, &oc);
    TIM_OC1PreloadConfig(TIM2, TIM_OCPreload_Enable);

    TIM_Cmd(TIM2, ENABLE);
}

int main(void)
{
    PWM_Init();
    while (1)
    {
        /* 占空比 0 → 99 渐亮 */
        for (int i = 0; i < 100; i++)
        {
            TIM_SetCompare1(TIM2, i);
            Delay_ms(10);
        }
        /* 99 → 0 渐暗 */
        for (int i = 100; i > 0; i--)
        {
            TIM_SetCompare1(TIM2, i);
            Delay_ms(10);
        }
    }
}

13.3 关键点解析

13.4 驱动舵机：PWM 的实际应用

// SG90 舵机：周期 20ms，高电平 0.5~2.5ms 对应 0~180°
// 设 ARR=19999, PSC=71 → 20ms
// 0°   → CCR =  500   (0.5ms)
// 90°  → CCR = 1500   (1.5ms)
// 180° → CCR = 2500   (2.5ms)

void Servo_SetAngle(float angle)
{
    TIM_SetCompare1(TIM2, 500 + angle / 180.0 * 2000);
}

13.5 本章练习

1. PSC=7199、ARR=99 时 PWM 频率是多少？
2. 为什么 PWM 输出引脚要配成「复用推挽」？
3. 舵机要 20ms 周期，ARR 和 PSC 怎么设？

14.1 ADC 是干什么的

把连续变化的电压变成离散的数字。STM32F103 的是 12 位逐次逼近型 ADC。

12 位分辨率 → 2^12 = 4096 个等级
参考电压 3.3V → 每个等级 3.3 / 4096 ≈ 0.806 mV
输入 1.65V → 数字量约 2048

14.2 单通道 ADC 完整代码

#include "stm32f10x.h"

void ADC1_Init(void)
{
    /* ① GPIO：PA0 必须配「模拟输入」！ */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    GPIO_InitTypeDef g;
    g.GPIO_Mode = GPIO_Mode_AIN;       // ★ 模拟输入，不是上拉！
    g.GPIO_Pin  = GPIO_Pin_0;
    GPIO_Init(GPIOA, &g);

    /* ② ADC 时钟：APB2/6 = 12MHz（ADC 最高不能超 14MHz） */
    RCC_ADCCLKConfig(RCC_PCLK2_Div6);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);

    /* ③ 配置 ADC */
    ADC_InitTypeDef a;
    a.ADC_Mode               = ADC_Mode_Independent;
    a.ADC_ScanConvMode       = DISABLE;          // 单通道
    a.ADC_ContinuousConvMode = DISABLE;          // 单次
    a.ADC_ExternalTrigConv   = ADC_ExternalTrigConv_None;
    a.ADC_DataAlign          = ADC_DataAlign_Right;
    a.ADC_NbrOfChannel       = 1;
    ADC_Init(ADC1, &a);

    /* ④ 规则组：通道 0，采样时间 55.5 个周期 */
    ADC_RegularChannelConfig(ADC1, ADC_Channel_0, 1, ADC_SampleTime_55Cycles5);

    /* ⑤ 使能 + 校准 */
    ADC_Cmd(ADC1, ENABLE);
    ADC_ResetCalibration(ADC1);
    while (ADC_GetResetCalibrationStatus(ADC1));
    ADC_StartCalibration(ADC1);
    while (ADC_GetCalibrationStatus(ADC1));
}

unsigned int ADC_Read(void)
{
    ADC_SoftwareStartConvCmd(ADC1, ENABLE);          // 启动转换
    while (!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC));  // 等转换完成
    return ADC_GetConversionValue(ADC1);             // 读结果（0~4095）
}

int main(void)
{
    ADC1_Init();
    while (1)
    {
        unsigned int val = ADC_Read();
        // 转成电压（mV）：val * 3300 / 4095
        volatile unsigned int mv = val * 3300 / 4095;
        Delay_ms(100);
    }
}

14.3 为什么必须校准

ADC 内部有电容和比较器，存在制造偏差。校准让硬件自动测出这个偏差并补偿。不校准会导致读数系统性偏移。

14.4 本章练习

1. 3.3V 参考、12 位 ADC，数字量 4095 对应多少伏？
2. GPIO 必须配成什么模式？为什么？
3. ADC 时钟为什么不能超过 14MHz？

15.1 DMA 解决什么问题

没有 DMA：
  ADC 转换完 → CPU 读 ADC_DR → CPU 写数组 → 循环 100 次

有 DMA：
  配置一次 → DMA 自动搬 100 次 → 全部搬完发个中断
  CPU 全程可以去算别的东西

15.2 关键概念

15.3 代码框架

#define BUF_SIZE 100
uint16_t adc_buf[BUF_SIZE];

void DMA_Init(void)
{
    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);   // ★ DMA 在 AHB 上

    DMA_InitTypeDef d;
    d.DMA_PeripheralBaseAddr = (uint32_t)&ADC1->DR;      // 源：ADC 数据寄存器
    d.DMA_MemoryBaseAddr     = (uint32_t)adc_buf;         // 目标：数组
    d.DMA_DIR                = DMA_DIR_PeripheralSRC;     // 外设 → 内存
    d.DMA_BufferSize         = BUF_SIZE;
    d.DMA_PeripheralInc      = DMA_PeripheralInc_Disable; // 外设地址不变
    d.DMA_MemoryInc          = DMA_MemoryInc_Enable;      // 内存地址递增
    d.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
    d.DMA_MemoryDataSize     = DMA_MemoryDataSize_HalfWord;
    d.DMA_Mode               = DMA_Mode_Circular;         // 循环模式
    d.DMA_Priority           = DMA_Priority_Medium;
    d.DMA_M2M                = DMA_M2M_Disable;
    DMA_Init(DMA1_Channel1, &d);

    DMA_Cmd(DMA1_Channel1, ENABLE);
}

// ADC 侧要打开 DMA 请求
ADC_DMACmd(ADC1, ENABLE);

15.4 和 51 的对比

15.5 本章练习

1. DMA 挂在哪条总线上？开时钟用哪个寄存器？
2. 为什么外设地址不递增，内存地址要递增？
3. 连续采样为什么必须开循环模式？

16.1 和 51 串口的差别

16.2 波特率怎么算

USART1 在 APB2（72MHz）：
波特率 = f_CLK / (16 × USARTDIV)

要 115200：
USARTDIV = 72000000 / (16 × 115200) = 39.0625
整数部分 = 39 = 0x27 → 写进 BRR 的 [15:4]
小数部分 = 0.0625 × 16 = 1 → 写进 BRR 的 [3:0]
BRR = 0x271 = 625

16.3 串口发送完整代码

#include "stm32f10x.h"

void USART1_Init(uint32_t baud)
{
    /* ① GPIO：PA9 = TX（复用推挽），PA10 = RX（浮空输入） */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_USART1, ENABLE);

    GPIO_InitTypeDef g;
    g.GPIO_Mode  = GPIO_Mode_AF_PP;
    g.GPIO_Pin   = GPIO_Pin_9;
    g.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &g);

    g.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    g.GPIO_Pin  = GPIO_Pin_10;
    GPIO_Init(GPIOA, &g);

    /* ② USART 配置 */
    USART_InitTypeDef u;
    u.USART_BaudRate            = baud;
    u.USART_WordLength          = USART_WordLength_8b;
    u.USART_StopBits            = USART_StopBits_1;
    u.USART_Parity              = USART_Parity_No;
    u.USART_Mode                = USART_Mode_Tx | USART_Mode_Rx;
    u.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_Init(USART1, &u);

    USART_Cmd(USART1, ENABLE);
}

void USART1_SendByte(uint8_t b)
{
    while (!USART_GetFlagStatus(USART1, USART_FLAG_TXE));  // 等发送寄存器空
    USART_SendData(USART1, b);
}

void USART1_SendString(char *s)
{
    while (*s) USART1_SendByte(*s++);
}

int main(void)
{
    USART1_Init(115200);
    while (1)
    {
        USART1_SendString("Hello STM32\r\n");
        Delay_ms(1000);
    }
}

16.4 接收：中断方式

// 初始化里加上
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);

NVIC_InitTypeDef n;
n.NVIC_IRQChannel = USART1_IRQn;
n.NVIC_IRQChannelPreemptionPriority = 2;
n.NVIC_IRQChannelSubPriority = 1;
n.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&n);

// 中断函数
void USART1_IRQHandler(void)
{
    if (USART_GetITStatus(USART1, USART_IT_RXNE) == SET)
    {
        uint8_t dat = USART_ReceiveData(USART1);
        USART_SendData(USART1, dat);        // 回显
        USART_ClearITPendingBit(USART1, USART_IT_RXNE);
    }
}

16.5 本章练习

1. 115200 波特率、APB2=72MHz，BRR 应该写多少？
2. PA9/PA10 各是什么功能？要配成什么模式？
3. USART1 挂在哪条总线上？USART2 呢？

17.1 I2C：两根线串起一堆设备

// 软件 I2C 的两条基本操作（GPIO 模拟）
void I2C_Start(void)   { SDA_H; SCL_H; delay; SDA_L; delay; SCL_L; }
void I2C_Stop(void)    { SDA_L; SCL_H; delay; SDA_H; delay; }
// 起始 = SCL 高电平期间 SDA 由高变低
// 停止 = SCL 高电平期间 SDA 由低变高

17.2 SPI：四根线，更快

I2C：2 根线，有地址，速度 100~400kHz
SPI：4 根线，靠 CS 选设备，速度可达 18MHz（快 45 倍）

17.3 RTC 实时时钟

RTC 用 LSE 32.768kHz 晶振，只要 VBAT 有电就一直走，主电源断了也不停。

32.768kHz / 32768 = 1Hz  → 每秒加 1
// 这就是为什么选 32.768k 这个怪数字（2 的 15 次方）

17.4 看门狗：防止程序跑飞

// 独立看门狗：1 秒超时
IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable);
IWDG_SetPrescaler(IWDG_Prescaler_64);   // 40kHz/64 = 625Hz
IWDG_SetReload(625);                    // 625/625 = 1s
IWDG_ReloadCounter();                   // 喂一次
IWDG_Enable();

// 主循环里定期喂
while (1)
{
    // ... 干正事 ...
    IWDG_ReloadCounter();     // 忘了这句 → 1 秒后芯片复位
}

17.5 内部 FLASH 读写

// 读：直接指针访问
uint32_t data = *(volatile uint32_t *)0x0800FC00;

// 写：必须先解锁 → 擦除 → 写入
FLASH_Unlock();
FLASH_ErasePage(0x0800FC00);            // 按页擦（1KB 或 2KB）
FLASH_ProgramWord(0x0800FC00, 0x12345678);
FLASH_Lock();

17.6 本章练习

1. I2C 为什么必须用开漏输出？
2. RTC 为什么用 32.768kHz？
3. Flash 写入前为什么必须先擦除？
4. 看门狗「喂狗」是在做什么？