📚 课程目录第3章 GPIO驱动接口封装（二）

3. GPIO驱动接口封装（二）：多平台GPIO驱动实现（STM32 vs ESP32），位带操作与寄存器映射

上一章我们把GPIO的抽象接口定义好了。这一章，咱们得真刀真枪地干——在STM32和ESP32上分别实现这些接口。

你可能会想：「不就是写个GPIO驱动吗？翻手册抄寄存器不就完了？」

嗯，没那么简单。我见过太多人把驱动写得跟芯片绑死，换个平台就得重写。咱们的目标是：接口不变，实现随便换。

3.1 两个平台的硬件差异，先摸个底

写驱动之前，得先搞清楚对手长什么样。STM32和ESP32的GPIO模块，设计哲学完全不同。

对比项	STM32 (F4系列为例)	ESP32
寄存器模型	标准ARM Cortex-M外设总线	Xtensa LX6自定义总线
GPIO组	按PORT分组（GPIOA~GPIOK）	按GPIO编号（0~39）
输出模式	推挽/开漏 + 速度等级	推挽/开漏/仅输入
上下拉	独立配置寄存器	每个GPIO独立配置
中断	EXTI + NVIC	GPIO矩阵 + 中断控制器
位带操作	支持（Cortex-M3/M4特性）	不支持

看到没？STM32有「位带操作」这个杀手锏，ESP32没有。这意味着什么？实现原子位操作的方式完全不同。

3.2 STM32实现：寄存器映射 + 位带操作

我个人习惯，在STM32上做GPIO驱动，优先用位带操作。为什么？因为读-改-写在多任务环境下容易出问题。

先看寄存器映射结构。STM32的GPIO寄存器，每个PORT占用1KB地址空间：

// STM32 GPIO寄存器结构体
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;

// 基地址映射
#define GPIOA_BASE          (AHB1PERIPH_BASE + 0x0000)
#define GPIOB_BASE          (AHB1PERIPH_BASE + 0x0400)
// ... 以此类推

这里有个坑——寄存器地址千万别算错。我曾经在某个项目里，把GPIOE的基地址写成了0x4002 1000，结果PE5死活拉不高。查了两天才发现，GPIOE实际基地址是0x4002 1000没错，但我的AHB1PERIPH_BASE定义错了。嗯，这种低级错误，犯一次就长记性了。

3.2.1 位带操作：让每个bit变成独立的内存地址

位带操作是Cortex-M3/M4的独门绝技。它把每个bit映射到一个32位的地址空间。你往这个地址写1，对应的bit就置1；写0，bit就清0。整个过程是原子操作，不会被中断打断。

// 位带地址计算公式
// 位带别名地址 = 位带基址 + (字节偏移 * 32) + (位号 * 4)

#define BITBAND_PERIPH_BASE    0x42000000
#define PERIPH_BASE            0x40000000

// 计算GPIOA ODR寄存器的第5位对应的位带地址
// GPIOA_ODR地址 = 0x40020014
// 位带地址 = 0x42000000 + (0x20014 * 32) + (5 * 4)
//          = 0x42000000 + 0x400280 + 0x14
//          = 0x42400294

// 封装成宏
#define BITBAND_ADDR(reg, bit) \
    (BITBAND_PERIPH_BASE + (((uint32_t)&(reg) - PERIPH_BASE) * 32) + ((bit) * 4))

#define PAout(n)  (*((volatile uint32_t *)BITBAND_ADDR(GPIOA->ODR, n)))
#define PAin(n)   (*((volatile uint32_t *)BITBAND_ADDR(GPIOA->IDR, n)))

实战技巧：位带操作虽然快，但别滥用。每个位带访问都要经过额外的地址计算，如果频繁操作同一个寄存器，不如直接用BSRR寄存器。BSRR写1置位、写0复位，也是原子操作，而且一次可以操作多个bit。

3.2.2 实现抽象接口

有了位带操作，实现我们的抽象接口就简单了：

// STM32平台实现
static void stm32_gpio_write_pin(void *hw_base, uint8_t pin, uint8_t level)
{
    // 用位带操作，原子写入
    if (level) {
        *((volatile uint32_t *)BITBAND_ADDR(((GPIO_TypeDef *)hw_base)->ODR, pin)) = 1;
    } else {
        *((volatile uint32_t *)BITBAND_ADDR(((GPIO_TypeDef *)hw_base)->ODR, pin)) = 0;
    }
}

static uint8_t stm32_gpio_read_pin(void *hw_base, uint8_t pin)
{
    return *((volatile uint32_t *)BITBAND_ADDR(((GPIO_TypeDef *)hw_base)->IDR, pin));
}

// 注册到抽象层
const gpio_driver_t stm32_gpio_driver = {
    .write_pin = stm32_gpio_write_pin,
    .read_pin  = stm32_gpio_read_pin,
    .config    = stm32_gpio_config,
};

3.3 ESP32实现：寄存器映射 + 掩码操作

ESP32没有位带操作，怎么办？用掩码+读-改-写。但要注意，读-改-写不是原子的，中断里操作同一个寄存器会出问题。

ESP32的GPIO寄存器设计比较分散，每个功能都有独立的寄存器：

// ESP32 GPIO关键寄存器
// 输出寄存器
#define GPIO_OUT_REG            (DR_REG_GPIO_BASE + 0x0004)
#define GPIO_OUT_W1TS_REG       (DR_REG_GPIO_BASE + 0x0008)  // 写1置位
#define GPIO_OUT_W1TC_REG       (DR_REG_GPIO_BASE + 0x000C)  // 写1清零

// 输入寄存器
#define GPIO_IN_REG             (DR_REG_GPIO_BASE + 0x003C)

// 使能寄存器
#define GPIO_ENABLE_REG         (DR_REG_GPIO_BASE + 0x0020)
#define GPIO_ENABLE_W1TS_REG    (DR_REG_GPIO_BASE + 0x0024)
#define GPIO_ENABLE_W1TC_REG    (DR_REG_GPIO_BASE + 0x0028)

看到没？ESP32提供了W1TS（写1置位）和W1TC（写1清零）寄存器。这其实是一种硬件级别的原子操作——你往W1TS写某个bit的掩码，对应的输出pin就置位；往W1TC写，就清零。不需要读-改-写。

    核心思路：STM32用位带操作实现原子写，ESP32用W1TS/W1TC实现原子写。殊途同归。

3.3.1 实现抽象接口

// ESP32平台实现
static void esp32_gpio_write_pin(void *hw_base, uint8_t pin, uint8_t level)
{
    // 用W1TS/W1TC实现原子写入
    if (level) {
        REG_WRITE(GPIO_OUT_W1TS_REG, (1 << pin));
    } else {
        REG_WRITE(GPIO_OUT_W1TC_REG, (1 << pin));
    }
}

static uint8_t esp32_gpio_read_pin(void *hw_base, uint8_t pin)
{
    uint32_t reg_val = REG_READ(GPIO_IN_REG);
    return (reg_val >> pin) & 0x01;
}

// 注册到抽象层
const gpio_driver_t esp32_gpio_driver = {
    .write_pin = esp32_gpio_write_pin,
    .read_pin  = esp32_gpio_read_pin,
    .config    = esp32_gpio_config,
};

3.4 两种实现方式的对比

特性	STM32位带操作	ESP32 W1TS/W1TC
原子性	硬件原子	硬件原子
代码可读性	中等（地址计算复杂）	高（寄存器语义明确）
性能	快（单次内存访问）	快（单次寄存器写）
可移植性	仅限Cortex-M3/M4	仅限ESP32
批量操作	需多次位带访问	一次掩码写即可

避坑指南：我曾经在ESP32上犯过一个错误——用读-改-写的方式操作GPIO_OUT_REG。结果在中断里和主循环同时操作同一个pin，导致输出状态随机跳变。后来换成W1TS/W1TC才解决。记住：只要硬件提供了原子写寄存器，就别用读-改-写。

3.5 抽象层的统一调度

现在两个平台的驱动都实现了，怎么让上层代码无感切换？答案就是函数指针表。

// 抽象层统一接口
typedef struct {
    void (*write_pin)(void *hw_base, uint8_t pin, uint8_t level);
    uint8_t (*read_pin)(void *hw_base, uint8_t pin);
    int (*config)(void *hw_base, uint8_t pin, gpio_config_t *cfg);
} gpio_driver_t;

// 平台选择（编译时决定）
#if defined(STM32F4)
    #define GPIO_DRIVER &stm32_gpio_driver
#elif defined(ESP32)
    #define GPIO_DRIVER &esp32_gpio_driver
#endif

// 上层调用
void gpio_set_level(gpio_port_t port, uint8_t pin, uint8_t level)
{
    GPIO_DRIVER->write_pin(port->hw_base, pin, level);
}

你看，上层代码根本不知道底层是位带操作还是W1TS。这就是抽象的魅力。

3.6 知识结构图

下面这张图，把本章的核心逻辑串起来了：

3.7 写在最后

这一章我们干了三件事：

摸清了STM32和ESP32的GPIO硬件差异
用位带操作实现了STM32的原子写
用W1TS/W1TC实现了ESP32的原子写

核心思想就一句话：接口统一，实现隔离。你写应用层代码的时候，根本不用关心底下是位带还是掩码。这就是抽象层的价值。