📚 课程目录第2章 GPIO深入与模块化封装

2. GPIO深入与模块化封装：GPIO的8种工作模式、寄存器映射、HAL_GPIO_WritePin与HAL_GPIO_TogglePin源码分析、封装LED与按键驱动模块

GPIO 是嵌入式开发里最基础、也最容易被轻视的外设。很多人觉得不就是点个灯、读个按键嘛，能有多复杂？

但说实话，我见过太多因为 GPIO 配置不当导致的诡异问题——比如 IO 口漏电、按键误触发、甚至芯片锁死。这些坑，十有八九都是对 GPIO 的工作模式和寄存器映射理解不够深。

这一章，咱们就把 GPIO 彻底吃透。从 8 种工作模式到寄存器映射，再到 HAL 库源码分析，最后封装出可复用的 LED 和按键驱动模块。嗯，这套封装思路，我在好几个量产项目里都用过，稳定可靠。

2.1 GPIO的8种工作模式

STM32 的 GPIO 引脚，可以配置成 8 种不同的工作模式。说白了，就是每个引脚都能扮演不同的角色——是输出高低电平，还是输入检测信号，或者干脆当个模拟通道用。

模式编号	模式名称	典型用途
1	浮空输入	按键检测、外部中断输入
2	上拉输入	按键检测（默认高电平）
3	下拉输入	按键检测（默认低电平）
4	模拟输入	ADC 采样输入
5	开漏输出	I2C 总线、电平转换
6	推挽输出	LED 控制、普通数字输出
7	复用开漏输出	I2C、USART 等外设复用功能
8	复用推挽输出	SPI、PWM 等外设复用功能

我的习惯：做按键检测时，我一般用上拉输入，外部电路只需要一个按键到地，省掉一个上拉电阻。但要注意，如果板子上已经焊了上拉电阻，就改成浮空输入，避免双重上拉导致电平不准。

2.2 寄存器映射：从物理地址到C语言变量

寄存器映射，说白了就是把芯片手册里那一堆十六进制地址，变成 C 语言里可以直接读写的变量。STM32 的 GPIO 寄存器，每个端口有一组固定的寄存器，比如 GPIOA 的基地址是 0x40020000。

HAL 库已经帮我们做好了映射，但理解背后的原理很重要。你想想看，如果哪天 HAL 库出了 bug，或者你要移植到裸机环境，不懂寄存器映射就只能干瞪眼。

// GPIO 寄存器结构体定义（HAL库已经封装好）
typedef struct {
    volatile uint32_t MODER;    // 模式寄存器，偏移 0x00
    volatile uint32_t OTYPER;   // 输出类型寄存器，偏移 0x04
    volatile uint32_t OSPEEDR;  // 输出速度寄存器，偏移 0x08
    volatile uint32_t PUPDR;    // 上下拉寄存器，偏移 0x0C
    volatile uint32_t IDR;      // 输入数据寄存器，偏移 0x10
    volatile uint32_t ODR;      // 输出数据寄存器，偏移 0x14
    volatile uint32_t BSRR;     // 置位/复位寄存器，偏移 0x18
    volatile uint32_t LCKR;     // 锁定寄存器，偏移 0x1C
    volatile uint32_t AFR[2];   // 复用功能寄存器，偏移 0x20-0x24
} GPIO_TypeDef;

// GPIOA 基地址映射
#define GPIOA_BASE      0x40020000UL
#define GPIOA           ((GPIO_TypeDef *) GPIOA_BASE)

关键点：volatile 关键字不能少。它告诉编译器，这个变量的值可能被硬件修改，每次读取都必须从内存地址重新取，不能优化成寄存器缓存。我遇到过有人忘了加 volatile，结果读按键状态死活不对，折腾了半天才发现是编译器优化掉了。

2.3 HAL_GPIO_WritePin 与 HAL_GPIO_TogglePin 源码分析

这两个函数，应该是嵌入式开发者用得最频繁的 API 了。但你真的看过它们的源码吗？

咱们先看 HAL_GPIO_WritePin：

void HAL_GPIO_WritePin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin, GPIO_PinState PinState)
{
    if (PinState != GPIO_PIN_RESET) {
        GPIOx->BSRR = GPIO_Pin;      // 置位：写 1 到 BSRR 低 16 位
    } else {
        GPIOx->BSRR = (uint32_t)GPIO_Pin << 16U;  // 复位：写 1 到 BSRR 高 16 位
    }
}

这里有个巧妙的设计——BSRR 寄存器。写低 16 位置位对应引脚，写高 16 位复位对应引脚。一次写入就能完成操作，不需要读-改-写，也不会被中断打断。嗯，这就是硬件级别的原子操作。

再看 HAL_GPIO_TogglePin：

void HAL_GPIO_TogglePin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)
{
    GPIOx->ODR ^= GPIO_Pin;  // 异或操作，翻转对应位
}

简单到令人发指，对吧？就是读 ODR 寄存器，异或一下再写回去。但这里有个隐患——如果中断里也操作同一个 GPIO 口，读-改-写不是原子的，可能出问题。

我曾经踩过的坑：在一个多中断并发的项目里，用 TogglePin 翻转 LED，结果 LED 偶尔会闪错状态。后来发现是主循环和定时器中断同时操作同一个 GPIO 口，读-改-写冲突了。解决方案：要么关中断保护，要么改用 BSRR 寄存器自己实现原子翻转。

2.4 封装LED驱动模块

直接调用 HAL_GPIO_WritePin 当然能点灯，但代码里到处都是 GPIOA、GPIO_PIN_0 这样的硬编码，维护起来就是噩梦。我习惯把 LED 封装成一个模块，用结构体把引脚和端口绑定在一起。

// led.h
#ifndef __LED_H
#define __LED_H

#include "stm32f4xx_hal.h"

typedef struct {
    GPIO_TypeDef* port;
    uint16_t      pin;
    uint8_t       active_level;  // 1: 高电平点亮, 0: 低电平点亮
} LED_HandleTypeDef;

void LED_Init(LED_HandleTypeDef* led);
void LED_On(LED_HandleTypeDef* led);
void LED_Off(LED_HandleTypeDef* led);
void LED_Toggle(LED_HandleTypeDef* led);

#endif

// led.c
#include "led.h"

void LED_Init(LED_HandleTypeDef* led)
{
    // 假设外部已经用 CubeMX 初始化了 GPIO
    // 这里可以加一些断言检查
    LED_Off(led);
}

void LED_On(LED_HandleTypeDef* led)
{
    if (led->active_level) {
        HAL_GPIO_WritePin(led->port, led->pin, GPIO_PIN_SET);
    } else {
        HAL_GPIO_WritePin(led->port, led->pin, GPIO_PIN_RESET);
    }
}

void LED_Off(LED_HandleTypeDef* led)
{
    if (led->active_level) {
        HAL_GPIO_WritePin(led->port, led->pin, GPIO_PIN_RESET);
    } else {
        HAL_GPIO_WritePin(led->port, led->pin, GPIO_PIN_SET);
    }
}

void LED_Toggle(LED_HandleTypeDef* led)
{
    HAL_GPIO_TogglePin(led->port, led->pin);
}

使用示例：

LED_HandleTypeDef led1 = {GPIOA, GPIO_PIN_0, 1};  // PA0, 高电平点亮
LED_Init(&led1);
LED_On(&led1);   // 点亮
LED_Off(&led1);  // 熄灭
LED_Toggle(&led1); // 翻转

2.5 封装按键驱动模块

按键驱动比 LED 复杂一些，因为要处理抖动。硬件上可以加 RC 滤波，但软件消抖更灵活。我常用的方案是：检测到电平变化后，延时 20ms 再读一次，确认状态稳定。

// key.h
#ifndef __KEY_H
#define __KEY_H

#include "stm32f4xx_hal.h"

typedef enum {
    KEY_RELEASED = 0,
    KEY_PRESSED
} KeyState;

typedef struct {
    GPIO_TypeDef* port;
    uint16_t      pin;
    uint8_t       press_level;   // 按下时的电平: 0 或 1
    KeyState      last_state;
    uint32_t      last_tick;     // 上次状态变化的时间戳
} KEY_HandleTypeDef;

void KEY_Init(KEY_HandleTypeDef* key);
KeyState KEY_Read(KEY_HandleTypeDef* key);

#endif

// key.c
#include "key.h"

#define KEY_DEBOUNCE_MS  20

void KEY_Init(KEY_HandleTypeDef* key)
{
    key->last_state = KEY_RELEASED;
    key->last_tick = 0;
}

KeyState KEY_Read(KEY_HandleTypeDef* key)
{
    uint8_t raw_level = HAL_GPIO_ReadPin(key->port, key->pin);
    uint8_t raw_state = (raw_level == key->press_level) ? KEY_PRESSED : KEY_RELEASED;

    // 状态变化了？开始计时消抖
    if (raw_state != key->last_state) {
        key->last_tick = HAL_GetTick();
        key->last_state = raw_state;
    }

    // 状态稳定超过消抖时间，才返回
    if ((HAL_GetTick() - key->last_tick) >= KEY_DEBOUNCE_MS) {
        return raw_state;
    }

    // 还在抖动中，返回上次稳定状态
    return (key->last_state == KEY_PRESSED) ? KEY_RELEASED : KEY_PRESSED;
}

注意：这个消抖方案依赖 HAL_GetTick()，它由 SysTick 中断每 1ms 更新一次。如果你的系统里 SysTick 被禁用了，或者中断优先级被屏蔽了，这个函数就会卡死。我在一个低功耗项目里就吃过这个亏——进休眠前忘了检查 SysTick 状态，结果按键死活读不出来。

2.6 知识结构总览

下面这张图，把本章的核心知识点串起来了。从 GPIO 的 8 种模式，到寄存器映射，再到 HAL 库源码，最后落地到模块化封装。你照着这个思路走，GPIO 这块就算彻底拿下了。

2.7 本章小结

这一章的内容，说白了就是三件事：

理解 GPIO 的 8 种模式——知道什么时候该用哪种模式，别瞎配。
看懂寄存器映射和 HAL 库源码——知其然也知其所以然，遇到问题能自己排查。
封装 LED 和按键驱动模块——把硬件细节藏起来，上层代码只管调用，换芯片也不慌。

嗯，这套封装思路，我在好几个产品里都用过。从 STM32F1 到 F4 再到 G0，底层改几行寄存器地址，上层代码完全不用动。这就是模块化的价值。