4. 分层架构设计原则

这一章，我们来点实在的。

很多工程师写GPIO驱动，就是直接对着寄存器一顿操作。今天拉高，明天拉低，后天读个电平。项目小的时候还行，一旦代码量上来，你就知道什么叫「牵一发而动全身」。我早期做的一个智能家居项目，就因为GPIO的宏定义散落在各个模块，最后改板换引脚，改到怀疑人生。

所以，咱们得封装。把底层的寄存器操作藏起来，对外提供一套统一的API。这样，上层应用只管调用，底层换了芯片也不怕。

4.1 为什么GPIO需要分层封装？

你想想看，一个LED闪烁，在STM32上是操作ODR寄存器，在NXP上可能是操作GPIO->PSOR。如果每个模块都直接写寄存器，换平台就等于重写一遍。

分层封装的好处很明显：

• 隔离变化：硬件寄存器变了，只改HAL层，应用层不动。
• 统一接口：不管什么芯片，初始化、写、读、翻转，函数名都一样。
• 方便测试：可以mock掉底层，单独测业务逻辑。
• 代码复用：写一次驱动，多个项目都能用。

4.2 从寄存器操作开始

先别急着封装，咱们得先搞清楚底层在干什么。以STM32F4为例，一个GPIO引脚的操作涉及几个关键寄存器：

寄存器	作用	常用操作
MODER	模式选择（输入/输出/复用/模拟）	设置对应位为00/01/10/11
OTYPER	输出类型（推挽/开漏）	0推挽，1开漏
OSPEEDR	输出速度	低速/中速/高速/极高速
PUPDR	上下拉配置	无/上拉/下拉
ODR	输出数据寄存器	写1拉高，写0拉低
IDR	输入数据寄存器	读取引脚电平
BSRR	位设置/复位寄存器	低16位置位，高16位复位

直接操作寄存器的代码长这样：

// 点亮LED：PA5
#define GPIOA_BASE    0x40020000
#define GPIOA_MODER   (*(volatile uint32_t *)(GPIOA_BASE + 0x00))
#define GPIOA_ODR     (*(volatile uint32_t *)(GPIOA_BASE + 0x14))
#define GPIOA_BSRR    (*(volatile uint32_t *)(GPIOA_BASE + 0x18))

void led_on(void) {
    GPIOA_MODER &= ~(0x3 << 10);  // 先清零
    GPIOA_MODER |= (0x1 << 10);   // 设为输出
    GPIOA_BSRR = (1 << 5);        // 通过BSRR拉高，原子操作
}

void led_off(void) {
    GPIOA_BSRR = (1 << (5 + 16)); // 通过BSRR拉低
}

这段代码能跑，但问题很明显：硬编码太多。换一个引脚，所有地方都得改。而且，如果项目里有10个LED，你得写10份类似的代码。

4.3 设计统一的GPIO抽象结构体

要封装，先得有数据结构。我习惯定义一个结构体，把引脚的所有属性都装进去：

typedef enum {
    GPIO_MODE_INPUT  = 0x00,
    GPIO_MODE_OUTPUT = 0x01,
    GPIO_MODE_AF     = 0x02,
    GPIO_MODE_ANALOG = 0x03
} gpio_mode_t;

typedef enum {
    GPIO_PUPD_NONE    = 0x00,
    GPIO_PUPD_PULLUP  = 0x01,
    GPIO_PUPD_PULLDOWN = 0x02
} gpio_pupd_t;

typedef enum {
    GPIO_LEVEL_LOW  = 0,
    GPIO_LEVEL_HIGH = 1
} gpio_level_t;

typedef struct {
    void       *port;      // GPIO端口基地址
    uint16_t    pin;       // 引脚号 (0~15)
    gpio_mode_t mode;      // 模式
    gpio_pupd_t pupd;      // 上下拉
    uint8_t     speed;     // 速度
} gpio_cfg_t;

这个结构体就是咱们的「引脚身份证」。上层应用只需要填充这个结构体，然后调用初始化函数即可。

4.4 实现HAL层API

有了结构体，接下来就是实现操作函数。我一般提供这5个核心API：

// 初始化GPIO引脚
void hal_gpio_init(gpio_cfg_t *cfg);

// 设置引脚输出电平
void hal_gpio_write(gpio_cfg_t *cfg, gpio_level_t level);

// 读取引脚输入电平
gpio_level_t hal_gpio_read(gpio_cfg_t *cfg);

// 翻转引脚输出电平
void hal_gpio_toggle(gpio_cfg_t *cfg);

// 反初始化（恢复默认状态）
void hal_gpio_deinit(gpio_cfg_t *cfg);

以 hal_gpio_init 为例，它的内部实现会操作寄存器：

void hal_gpio_init(gpio_cfg_t *cfg) {
    uint32_t *moder = (uint32_t *)((uint32_t)cfg->port + 0x00);
    uint32_t *pupdr = (uint32_t *)((uint32_t)cfg->port + 0x0C);
    uint32_t *ospeedr = (uint32_t *)((uint32_t)cfg->port + 0x08);
    
    uint32_t pin_pos = cfg->pin * 2;
    
    // 配置模式
    *moder &= ~(0x3 << pin_pos);
    *moder |= (cfg->mode << pin_pos);
    
    // 配置上下拉
    *pupdr &= ~(0x3 << pin_pos);
    *pupdr |= (cfg->pupd << pin_pos);
    
    // 配置速度（输出模式才需要）
    if (cfg->mode == GPIO_MODE_OUTPUT) {
        *ospeedr &= ~(0x3 << pin_pos);
        *ospeedr |= (cfg->speed << pin_pos);
    }
}

你看，底层还是操作寄存器，但上层调用者完全不需要知道这些细节。

4.5 实战：用封装好的API控制LED和按键

理论说完了，咱们直接上实战。假设板子上有一个LED（PA5）和一个按键（PC13，按下为低电平）。

4.5.1 定义引脚配置

// led_config.c
#include "hal_gpio.h"

gpio_cfg_t led_cfg = {
    .port  = (void *)0x40020000,  // GPIOA
    .pin   = 5,
    .mode  = GPIO_MODE_OUTPUT,
    .pupd  = GPIO_PUPD_NONE,
    .speed = 2                    // 高速
};

gpio_cfg_t key_cfg = {
    .port  = (void *)0x40020800,  // GPIOC
    .pin   = 13,
    .mode  = GPIO_MODE_INPUT,
    .pupd  = GPIO_PUPD_PULLUP,   // 内部上拉
    .speed = 0
};

4.5.2 应用层代码

// app.c
#include "hal_gpio.h"

extern gpio_cfg_t led_cfg;
extern gpio_cfg_t key_cfg;

void app_init(void) {
    hal_gpio_init(&led_cfg);
    hal_gpio_init(&key_cfg);
}

void app_loop(void) {
    // 读取按键状态
    gpio_level_t key_level = hal_gpio_read(&key_cfg);
    
    if (key_level == GPIO_LEVEL_LOW) {
        // 按键按下，点亮LED
        hal_gpio_write(&led_cfg, GPIO_LEVEL_HIGH);
    } else {
        // 按键松开，熄灭LED
        hal_gpio_write(&led_cfg, GPIO_LEVEL_LOW);
    }
    
    // 或者用翻转函数实现闪烁效果
    // hal_gpio_toggle(&led_cfg);
    // delay_ms(500);
}

这段代码，你拿去给任何一个嵌入式工程师看，他都能秒懂。这就是统一API的价值。

4.6 封装后的架构层次

咱们用一张图来看看整个分层结构：

从这张图可以看得很清楚：应用层只跟HAL API层打交道，HAL API层封装了寄存器操作，寄存器操作直接面向硬件。每一层各司其职，互不干扰。

4.7 避坑指南与个人经验

封装说起来简单，但实际落地时有些坑得注意：

• 不要过度封装：有些场景下，比如中断里需要极速翻转引脚，直接操作BSRR寄存器反而更合适。HAL层提供通用接口，但也要留出「后门」让高级用户直接操作寄存器。
• 注意原子操作：读写ODR寄存器不是原子的，多线程或中断里容易出问题。我习惯用BSRR来设置和清除引脚，它是原子操作，安全得多。
• 配置集中管理：所有引脚配置放在一个文件里，不要散落在各个模块。我曾经接手过一个项目，LED的引脚配置藏在三个不同的.c文件里，改起来简直噩梦。
• 初始化顺序：有些MCU需要先使能GPIO时钟，再配置寄存器。这个步骤一定要放在HAL层的最前面，否则配置不生效。

4.8 小结

这一章，我们从最底层的寄存器操作开始，一步步封装出了统一的GPIO API。你学会了：

• 为什么GPIO需要分层封装
• 如何设计GPIO配置结构体
• 如何实现5个核心HAL API
• 如何用封装后的API控制LED和按键
• 分层架构的完整视图