2. MCU基础与开发环境

各位同学，今天我们来聊聊GPIO驱动封装。这可以说是MCU开发的"hello world"，但别小看它——我见过太多项目因为GPIO初始化不规范，导致后期调试痛不欲生。

咱们从最底层的寄存器操作讲起，一路走到标准库、HAL库，最后封装出带中断回调的驱动层。说白了，就是让你明白：为什么要有这些封装？它们解决了什么问题？

2.1 三种操作方式：寄存器 vs 标准库 vs HAL库

先看个对比表格，心里有个底：

2.2 寄存器操作：最原始，也最直接

我刚开始做嵌入式那会儿，用的就是寄存器操作。那时候MCU资源紧张，能省一行是一行。来看个点灯的例子：

// STM32F103 GPIOB Pin0 输出高电平（寄存器操作）
#define GPIOB_BASE         0x40010C00
#define GPIOB_CRL          (*(volatile uint32_t *)(GPIOB_BASE + 0x00))
#define GPIOB_BSRR         (*(volatile uint32_t *)(GPIOB_BASE + 0x10))

// 配置PB0为推挽输出，50MHz
GPIOB_CRL &= ~(0xF << 0);   // 先清零
GPIOB_CRL |= (0x3 << 0);    // 设置为推挽输出模式

// 输出高电平
GPIOB_BSRR = (1 << 0);      // 写BSRR的bit0置位

寄存器操作的好处是：你完全掌控硬件。坏处也很明显：换个MCU型号，所有代码都得重写。而且可读性差，过两个月自己都看不懂。

2.3 标准库：函数封装，提升可读性

标准库把寄存器操作封装成函数，比如ST的标准外设库：

// 标准库方式：GPIO初始化结构体
GPIO_InitTypeDef GPIO_InitStruct;

GPIO_InitStruct.GPIO_Pin   = GPIO_Pin_0;
GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_Out_PP;   // 推挽输出
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &GPIO_InitStruct);

// 输出高电平
GPIO_SetBits(GPIOB, GPIO_Pin_0);

你看，代码可读性明显提升了。但有个问题——标准库是芯片厂商提供的，不同厂商的API风格完全不同。我从STM32换到GD32，虽然寄存器兼容，但标准库函数名全变了。

2.4 HAL库：硬件抽象，跨平台利器

HAL库是ST推出的硬件抽象层，目的是让你不用关心底层寄存器。同样的点灯操作：

// HAL库方式
GPIO_InitTypeDef GPIO_InitStruct = {0};

__HAL_RCC_GPIOB_CLK_ENABLE();   // 使能时钟（这个容易忘！）

GPIO_InitStruct.Pin   = GPIO_PIN_0;
GPIO_InitStruct.Mode  = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull  = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

// 输出高电平
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_SET);

HAL库最大的优点是跨系列移植。我从STM32F1换到F4，HAL_GPIO_WritePin这个函数名完全不用改。但代价是代码体积大、执行效率低。

2.5 GPIO输出驱动封装：点灯的艺术

好了，理论讲完，咱们动手封装一个GPIO输出驱动。目标是：上层应用只需要调用一个函数，不用关心底层实现。

先定义结构体：

// gpio_drv.h
typedef struct {
    void (*init)(void);
    void (*set_high)(void);
    void (*set_low)(void);
    void (*toggle)(void);
} gpio_output_t;

// 实例化一个LED对象
extern gpio_output_t led_red;

然后实现：

// gpio_drv.c
static void led_red_init(void) {
    // 这里可以放寄存器、标准库或HAL库的初始化代码
    // 我习惯用标准库，因为可读性好
    GPIO_InitTypeDef GPIO_InitStruct;
    GPIO_InitStruct.GPIO_Pin   = GPIO_Pin_0;
    GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_Out_PP;
    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOB, &GPIO_InitStruct);
}

static void led_red_set_high(void) {
    GPIO_SetBits(GPIOB, GPIO_Pin_0);
}

static void led_red_set_low(void) {
    GPIO_ResetBits(GPIOB, GPIO_Pin_0);
}

static void led_red_toggle(void) {
    if(GPIO_ReadOutputDataBit(GPIOB, GPIO_Pin_0))
        GPIO_ResetBits(GPIOB, GPIO_Pin_0);
    else
        GPIO_SetBits(GPIOB, GPIO_Pin_0);
}

// 定义对象
gpio_output_t led_red = {
    .init     = led_red_init,
    .set_high = led_red_set_high,
    .set_low  = led_red_set_low,
    .toggle   = led_red_toggle
};

上层调用：

// main.c
led_red.init();
led_red.set_high();   // 点亮
delay_ms(500);
led_red.set_low();    // 熄灭

2.6 GPIO输入驱动封装：按键检测

按键检测比点灯复杂一些，主要涉及消抖和边沿检测。先看封装：

// gpio_input.h
typedef enum {
    EDGE_NONE = 0,
    EDGE_RISING,
    EDGE_FALLING,
    EDGE_BOTH
} edge_type_t;

typedef struct {
    void (*init)(void);
    uint8_t (*read)(void);
    edge_type_t (*get_edge)(void);
} gpio_input_t;

extern gpio_input_t btn_user;

实现时要注意消抖：

// gpio_input.c
static uint8_t last_state = 1;  // 默认高电平（上拉）
static uint8_t stable_state = 1;
static edge_type_t edge = EDGE_NONE;

static void btn_user_init(void) {
    GPIO_InitTypeDef GPIO_InitStruct;
    GPIO_InitStruct.GPIO_Pin   = GPIO_Pin_1;
    GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_IPU;  // 上拉输入
    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOB, &GPIO_InitStruct);
}

static uint8_t btn_user_read(void) {
    uint8_t current = GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_1);
    
    // 简单的软件消抖：连续两次采样一致才认为有效
    if(current == last_state) {
        if(current != stable_state) {
            stable_state = current;
            // 检测边沿
            if(stable_state == 0) edge = EDGE_FALLING;
            else edge = EDGE_RISING;
        } else {
            edge = EDGE_NONE;
        }
    }
    last_state = current;
    return stable_state;
}

static edge_type_t btn_user_get_edge(void) {
    edge_type_t e = edge;
    edge = EDGE_NONE;  // 读取后清除
    return e;
}

gpio_input_t btn_user = {
    .init      = btn_user_init,
    .read      = btn_user_read,
    .get_edge  = btn_user_get_edge
};

2.7 中断回调函数封装：让驱动主动通知

轮询方式浪费CPU，中断才是王道。但中断服务函数（ISR）里不能放太多逻辑，所以我们需要回调机制。

先定义回调接口：

// gpio_irq.h
typedef void (*gpio_callback_t)(void *arg);

typedef struct {
    void (*register_callback)(gpio_callback_t cb, void *arg);
    void (*enable_irq)(void);
    void (*disable_irq)(void);
} gpio_irq_t;

extern gpio_irq_t irq_key;

实现：

// gpio_irq.c
static gpio_callback_t user_cb = NULL;
static void *user_arg = NULL;

static void irq_key_register(gpio_callback_t cb, void *arg) {
    user_cb = cb;
    user_arg = arg;
}

static void irq_key_enable(void) {
    // 配置外部中断
    EXTI_InitTypeDef EXTI_InitStruct;
    EXTI_InitStruct.EXTI_Line = EXTI_Line1;
    EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt;
    EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Falling;
    EXTI_InitStruct.EXTI_LineCmd = ENABLE;
    EXTI_Init(&EXTI_InitStruct);
    
    NVIC_EnableIRQ(EXTI1_IRQn);
}

// 中断服务函数
void EXTI1_IRQHandler(void) {
    if(EXTI_GetITStatus(EXTI_Line1) != RESET) {
        // 调用回调函数
        if(user_cb != NULL) {
            user_cb(user_arg);
        }
        EXTI_ClearITPendingBit(EXTI_Line1);
    }
}

上层使用：

// main.c
void key_pressed_callback(void *arg) {
    // 按键按下，切换LED
    led_red.toggle();
}

int main(void) {
    irq_key.register_callback(key_pressed_callback, NULL);
    irq_key.enable_irq();
    
    while(1) {
        // 主循环可以干别的事
    }
}

2.8 整体架构图

下面这张图展示了我们这一章搭建的GPIO驱动分层架构：

2.9 本章小结

这一章我们走完了GPIO驱动的完整封装路径：

• 寄存器操作：最底层，效率最高，但移植性差
• 标准库：函数封装，可读性好，适合中小项目
• HAL库：硬件抽象，跨平台，适合大型项目
• 输出封装：用函数指针结构体实现解耦
• 输入封装：状态机消抖，边沿检测
• 中断回调：ISR与业务逻辑分离，提高响应速度