3. GPIO模块化封装（二）：完善GPIO驱动

上一章我们把GPIO的基础框架搭好了。说白了，那只是个空壳子——能初始化，但干不了活。这一章我们来填实它：输出高低电平、读取输入电平、位带操作、中断配置，还有回调函数注册机制。

嗯，这些都是实际项目中每天都要用的东西。我记得有一次调试一个电机驱动板，就是因为输出电平的时序差了那么几个微秒，整个系统就抖得跟筛子似的。从那以后，我对GPIO驱动的每一行代码都特别较真。

3.1 输出高低电平——别小看这个

输出电平看似简单，不就是往寄存器里写0或1吗？但封装得好不好，直接影响代码的可读性和可维护性。

我个人习惯把输出操作分成两个层次：

• 底层操作：直接操作寄存器，速度最快
• 上层封装：提供语义化的接口，代码更清晰

先看底层实现：

// gpio_driver.c
#include "gpio_driver.h"

void GPIO_SetPin(GPIO_TypeDef* GPIOx, uint16_t Pin)
{
    GPIOx->BSRR = Pin;  // 写1输出高电平
}

void GPIO_ResetPin(GPIO_TypeDef* GPIOx, uint16_t Pin)
{
    GPIOx->BSRR = (uint32_t)Pin << 16;  // 写1输出低电平
}

void GPIO_TogglePin(GPIO_TypeDef* GPIOx, uint16_t Pin)
{
    GPIOx->ODR ^= Pin;
}

这里有个细节：BSRR寄存器是"写1有效"的。高16位写1对应复位（低电平），低16位写1对应置位（高电平）。同时写同一个引脚的高低位？结果是置位优先。这个特性我在项目里用过一次，用来做精确的脉冲控制。

上层封装我建议这样写：

// gpio_interface.h
typedef enum {
    GPIO_PIN_RESET = 0,
    GPIO_PIN_SET
} GPIO_PinState;

void GPIO_WritePin(GPIO_Handle_t* pHandle, GPIO_PinState state)
{
    if (pHandle == NULL) return;
    
    if (state == GPIO_PIN_SET)
        GPIO_SetPin(pHandle->Instance, pHandle->Config.Pin);
    else
        GPIO_ResetPin(pHandle->Instance, pHandle->Config.Pin);
}

为什么多包一层？因为在实际项目中，你可能会在输出前做状态检查、日志记录，甚至加个互斥锁。有了这层封装，改起来就方便多了。

3.2 读取输入电平——别被毛刺坑了

读取输入电平，最直接的办法是读IDR寄存器：

GPIO_PinState GPIO_ReadPin(GPIO_TypeDef* GPIOx, uint16_t Pin)
{
    return (GPIOx->IDR & Pin) ? GPIO_PIN_SET : GPIO_PIN_RESET;
}

但这里有个坑——毛刺。我在做按键检测时遇到过，明明只按了一下，程序却读到了几十次跳变。为什么？因为机械按键有抖动，GPIO引脚在电平切换时会有短暂的振荡。

我常用的消抖方案有两种：

我个人偏爱连续采样消抖，因为它不阻塞系统：

GPIO_PinState GPIO_ReadPinDebounced(GPIO_TypeDef* GPIOx, uint16_t Pin, uint8_t samples)
{
    uint8_t high_count = 0;
    for (uint8_t i = 0; i < samples; i++)
    {
        if (GPIO_ReadPin(GPIOx, Pin) == GPIO_PIN_SET)
            high_count++;
        // 这里可以加一个微秒级延时，具体值取决于你的系统时钟
    }
    return (high_count > samples / 2) ? GPIO_PIN_SET : GPIO_PIN_RESET;
}

3.3 位带操作封装——让代码像51一样简单

你想想看，STM32的GPIO操作其实有点啰嗦。每次都要传GPIOx和Pin两个参数。能不能像51单片机那样，直接操作某个位？

位带操作就是干这个的。Cortex-M3/M4内核把外设寄存器的每个位都映射到了一个独立的地址空间。你直接读写这个地址，就等于操作对应的位。

STM32的位带区域有两个：

• SRAM区：0x20000000 - 0x200FFFFF（1MB），位带别名区在0x22000000开始
• 外设区：0x40000000 - 0x400FFFFF（1MB），位带别名区在0x42000000开始

GPIO的ODR和IDR寄存器都在外设区，所以可以用位带操作。计算公式如下：

#define BITBAND_PERIPH(addr, bit) \
    (*(volatile uint32_t *)(0x42000000 + ((uint32_t)(addr) - 0x40000000) * 32 + (bit) * 4))

封装成宏之后，用起来就爽了：

// gpio_bitband.h
#define GPIO_ODR_BIT(GPIOx, pin) \
    BITBAND_PERIPH(&(GPIOx)->ODR, pin)

#define GPIO_IDR_BIT(GPIOx, pin) \
    BITBAND_PERIPH(&(GPIOx)->IDR, pin)

// 使用示例
GPIO_ODR_BIT(GPIOA, 5) = 1;   // PA5输出高电平
uint8_t val = GPIO_IDR_BIT(GPIOB, 3);  // 读取PB3输入

不过要注意：位带操作只适用于单个位。如果你想同时操作多个引脚（比如一次输出一个字节），还是得用标准寄存器操作。

3.4 中断配置与回调函数注册机制

这部分是GPIO驱动的核心。没有中断，MCU就只能轮询，效率低得可怜。但中断配置又特别容易出错——我在早期项目里就吃过亏，中断优先级配错了，导致系统死锁。

先看中断配置的步骤：

1. 使能SYSCFG时钟（用于配置EXTI）
2. 选择中断引脚（SYSCFG_EXTICR寄存器）
3. 配置中断触发方式（EXTI_RTSR/EXTI_FTSR）
4. 使能中断线（EXTI_IMR）
5. 配置NVIC（优先级、使能）
6. 编写中断服务函数

我把它封装成了一个函数：

// gpio_interrupt.c
void GPIO_ConfigInterrupt(GPIO_Handle_t* pHandle)
{
    uint8_t exti_num = __builtin_ctz(pHandle->Config.Pin);  // 获取引脚号
    
    // 1. 使能SYSCFG时钟
    RCC->APB2ENR |= RCC_APB2ENR_SYSCFGEN;
    
    // 2. 配置EXTI引脚映射
    uint8_t port_num = (uint32_t)pHandle->Instance >> 10;
    SYSCFG->EXTICR[exti_num >> 2] &= ~(0xF << ((exti_num & 0x3) * 4));
    SYSCFG->EXTICR[exti_num >> 2] |= (port_num << ((exti_num & 0x3) * 4));
    
    // 3. 配置触发方式
    if (pHandle->Config.Trigger & GPIO_TRIGGER_RISING)
        EXTI->RTSR |= (1 << exti_num);
    if (pHandle->Config.Trigger & GPIO_TRIGGER_FALLING)
        EXTI->FTSR |= (1 << exti_num);
    
    // 4. 使能中断线
    EXTI->IMR |= (1 << exti_num);
    
    // 5. 配置NVIC
    NVIC_SetPriority(EXTI0_IRQn + exti_num, pHandle->Config.Priority);
    NVIC_EnableIRQ(EXTI0_IRQn + exti_num);
}

这里有个关键点：__builtin_ctz是GCC的内建函数，用来计算引脚号的。如果你用其他编译器，可能需要自己实现一个查表法。

回调函数注册机制

中断服务函数（ISR）里最忌讳的就是写业务逻辑。正确的做法是：ISR只做最必要的事——清除中断标志，然后调用一个注册好的回调函数。

我设计的回调注册机制是这样的：

// gpio_callback.h
#define MAX_GPIO_CALLBACKS 16

typedef struct {
    uint16_t Pin;
    void (*callback)(void* arg);
    void* arg;
} GPIO_Callback_t;

static GPIO_Callback_t gpio_callbacks[MAX_GPIO_CALLBACKS];
static uint8_t callback_count = 0;

// 注册回调函数
int GPIO_RegisterCallback(uint16_t Pin, void (*callback)(void*), void* arg)
{
    if (callback_count >= MAX_GPIO_CALLBACKS)
        return -1;  // 回调表已满
    
    gpio_callbacks[callback_count].Pin = Pin;
    gpio_callbacks[callback_count].callback = callback;
    gpio_callbacks[callback_count].arg = arg;
    callback_count++;
    return 0;
}

// 在ISR中调用
void EXTI0_IRQHandler(void)
{
    if (EXTI->PR & EXTI_PR_PR0)
    {
        EXTI->PR = EXTI_PR_PR0;  // 清除标志
        
        // 遍历回调表
        for (uint8_t i = 0; i < callback_count; i++)
        {
            if (gpio_callbacks[i].Pin == GPIO_PIN_0)
            {
                if (gpio_callbacks[i].callback)
                    gpio_callbacks[i].callback(gpio_callbacks[i].arg);
                break;
            }
        }
    }
}

使用起来也很直观：

// 用户代码
void ButtonPressHandler(void* arg)
{
    uint8_t* button_id = (uint8_t*)arg;
    // 处理按键按下事件
    printf("Button %d pressed!\n", *button_id);
}

uint8_t btn_id = 1;
GPIO_RegisterCallback(GPIO_PIN_0, ButtonPressHandler, &btn_id);

3.5 本章知识体系

下面这张图把本章的核心内容串起来了。你可以看到，GPIO驱动从底层寄存器操作，到上层回调机制，是一个完整的层次结构。

从这张图可以看得很清楚：用户应用层在最上面，通过回调函数与驱动层交互。驱动层内部又分了三层——中断配置、功能模块、寄存器操作。每一层只做自己的事，互不干扰。

嗯，这就是模块化编程的精髓。你想想看，如果哪天要换MCU，只需要重写最底层的寄存器操作，上面的代码几乎不用动。我在一次芯片选型变更中，就靠这种分层设计，只花了两天就完成了移植。