📚 课程目录第2章硬件抽象层(HAL)设计(上)

硬件抽象层（HAL）设计（上）：HAL层的作用与边界

各位同学，咱们今天聊点实在的。硬件抽象层，英文叫 Hardware Abstraction Layer，简称 HAL。这玩意儿说白了，就是给上层软件和底层硬件之间，加了一层“翻译官”。

我刚开始做嵌入式那会儿，代码都是直接操作寄存器。GPIO 要拉高？直接写 *(volatile uint32_t *)0x40020C14 |= (1 << 12)。当时觉得挺爽，直到项目换了个 MCU 型号……好家伙，所有驱动代码几乎要重写。那叫一个痛苦。

从那以后，我就养成了一个习惯：不管项目多小，先把 HAL 层搭起来。你想想看，如果上层代码只调用 HAL_GPIO_SetPin(GPIO_PORT_A, GPIO_PIN_12)，底层寄存器怎么变，跟它有什么关系？

HAL 层到底管什么？

HAL 层的核心职责就两条：封装硬件差异 和 提供统一接口。它不关心业务逻辑，只关心怎么把 MCU 外设的寄存器操作，包装成上层看得懂的 API。

HAL 层的边界划分原则：

向下：直接操作 MCU 数据手册里的寄存器地址和位域
向上：只暴露功能接口，不暴露寄存器细节
内部：可以包含简单的时序控制（比如延时等待），但不包含业务状态机

举个例子，你写一个 I2C 驱动。HAL 层负责：发起始信号、发地址、发数据、收数据、发停止信号。至于上层是用它读温度传感器，还是写 EEPROM，HAL 层一概不管。

MCU 外设寄存器封装——从“裸奔”到“体面”

寄存器封装是 HAL 层的地基。我见过不少新手，直接在头文件里写一堆宏定义：

#define GPIOA_CRL   (volatile uint32_t *)0x40010800
#define GPIOA_CRH   (volatile uint32_t *)0x40010804
#define GPIOA_ODR   (volatile uint32_t *)0x4001080C

这样写能用，但不好维护。我个人习惯用结构体来封装寄存器组，这样代码可读性高得多：

typedef struct {
    volatile uint32_t CRL;    // 端口配置低寄存器，偏移 0x00
    volatile uint32_t CRH;    // 端口配置高寄存器，偏移 0x04
    volatile uint32_t IDR;    // 端口输入数据寄存器，偏移 0x08
    volatile uint32_t ODR;    // 端口输出数据寄存器，偏移 0x0C
    volatile uint32_t BSRR;   // 端口位设置/清除寄存器，偏移 0x10
    volatile uint32_t BRR;    // 端口位清除寄存器，偏移 0x14
    volatile uint32_t LCKR;   // 端口配置锁定寄存器，偏移 0x18
} GPIO_TypeDef;

#define GPIOA               ((GPIO_TypeDef *)0x40010800)
#define GPIOB               ((GPIO_TypeDef *)0x40010C00)

这样封装之后，操作 GPIOA 的 ODR 寄存器，直接写 GPIOA->ODR = 0x01 就行。结构体成员顺序必须和芯片手册里的寄存器地址偏移严格一致，这一点千万不能搞错。

我曾经踩过的坑： 某次做 STM32F103 的项目，我漏掉了 BSRR 和 BRR 之间的保留地址，结果结构体偏移全乱了，GPIO 死活拉不高。查了两天才发现是结构体对齐的问题。所以，一定要用 __attribute__((packed)) 或者编译器相关指令，确保结构体没有填充字节。

GPIO 驱动分层设计实战

光说不练假把式。咱们拿 GPIO 驱动来走一遍完整的分层设计。GPIO 虽然简单，但麻雀虽小五脏俱全，分层思路是通用的。

我一般把 GPIO 驱动分成三层：

层级	文件名	职责	依赖
HAL 层	`hal_gpio.c/h`	封装寄存器操作，提供 GPIO 初始化、读写、中断配置接口	MCU 寄存器定义
驱动层	`drv_led.c/h`	基于 HAL 层实现具体外设功能（如 LED 亮灭、闪烁）	HAL 层接口
应用层	`app_main.c`	业务逻辑，调用驱动层接口实现功能	驱动层接口

先看 HAL 层的头文件设计。接口要通用，不能跟具体引脚绑定：

// hal_gpio.h
#ifndef _HAL_GPIO_H_
#define _HAL_GPIO_H_

#include <stdint.h>

/* GPIO 端口枚举 */
typedef enum {
    GPIO_PORT_A = 0,
    GPIO_PORT_B,
    GPIO_PORT_C,
    GPIO_PORT_D,
    GPIO_PORT_E,
    GPIO_PORT_MAX
} GPIO_Port_t;

/* GPIO 引脚号 */
typedef enum {
    GPIO_PIN_0  = 0,
    GPIO_PIN_1  = 1,
    // ... 省略中间
    GPIO_PIN_15 = 15,
    GPIO_PIN_MAX
} GPIO_Pin_t;

/* GPIO 模式 */
typedef enum {
    GPIO_MODE_INPUT         = 0x0,  // 输入模式
    GPIO_MODE_OUTPUT_PP     = 0x1,  // 推挽输出
    GPIO_MODE_OUTPUT_OD     = 0x2,  // 开漏输出
    GPIO_MODE_AF_PP         = 0x3,  // 复用推挽
    GPIO_MODE_AF_OD         = 0x4,  // 复用开漏
    GPIO_MODE_ANALOG        = 0x5   // 模拟模式
} GPIO_Mode_t;

/* GPIO 输出电平 */
typedef enum {
    GPIO_LEVEL_LOW  = 0,
    GPIO_LEVEL_HIGH = 1
} GPIO_Level_t;

/* HAL 层接口 */
void HAL_GPIO_Init(GPIO_Port_t port, GPIO_Pin_t pin, GPIO_Mode_t mode);
void HAL_GPIO_DeInit(GPIO_Port_t port, GPIO_Pin_t pin);
void HAL_GPIO_WritePin(GPIO_Port_t port, GPIO_Pin_t pin, GPIO_Level_t level);
GPIO_Level_t HAL_GPIO_ReadPin(GPIO_Port_t port, GPIO_Pin_t pin);
void HAL_GPIO_TogglePin(GPIO_Port_t port, GPIO_Pin_t pin);

#endif /* _HAL_GPIO_H_ */

实现文件里，核心就是根据端口和引脚号，找到对应的寄存器地址，然后操作位域。这里我贴一段 HAL_GPIO_WritePin 的实现：

// hal_gpio.c
#include "hal_gpio.h"
#include "stm32f10x.h"  // 芯片寄存器定义

void HAL_GPIO_WritePin(GPIO_Port_t port, GPIO_Pin_t pin, GPIO_Level_t level)
{
    GPIO_TypeDef *gpio_base = NULL;

    /* 根据端口号获取基地址 */
    switch (port) {
        case GPIO_PORT_A: gpio_base = GPIOA; break;
        case GPIO_PORT_B: gpio_base = GPIOB; break;
        case GPIO_PORT_C: gpio_base = GPIOC; break;
        // ... 其他端口
        default: return;
    }

    /* 使用 BSRR 寄存器实现原子操作 */
    if (level == GPIO_LEVEL_HIGH) {
        gpio_base->BSRR = (1 << pin);      // 置位
    } else {
        gpio_base->BRR  = (1 << pin);      // 复位
    }
}

小技巧： 为什么用 BSRR/BRR 而不是直接写 ODR？因为 ODR 的读-改-写操作不是原子的，在多任务环境下可能被中断打断。BSRR 和 BRR 是硬件原子操作，写一次就生效，安全得多。

驱动层基于 HAL 层，封装具体外设的行为。比如 LED 驱动：

// drv_led.h
#ifndef _DRV_LED_H_
#define _DRV_LED_H_

#include "hal_gpio.h"

/* LED 对象结构体 */
typedef struct {
    GPIO_Port_t port;
    GPIO_Pin_t  pin;
    uint8_t     active_level;  // 0:低电平亮, 1:高电平亮
} LED_Handle_t;

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

#endif /* _DRV_LED_H_ */

实现的时候，把 HAL 层的通用接口，转换成 LED 的语义：

// drv_led.c
#include "drv_led.h"

void LED_On(LED_Handle_t *led)
{
    GPIO_Level_t level = (led->active_level == 1) ? GPIO_LEVEL_HIGH : GPIO_LEVEL_LOW;
    HAL_GPIO_WritePin(led->port, led->pin, level);
}

void LED_Off(LED_Handle_t *led)
{
    GPIO_Level_t level = (led->active_level == 1) ? GPIO_LEVEL_LOW : GPIO_LEVEL_HIGH;
    HAL_GPIO_WritePin(led->port, led->pin, level);
}

应用层就简单了，直接操作 LED 对象：

// app_main.c
#include "drv_led.h"

LED_Handle_t led_status = {
    .port = GPIO_PORT_B,
    .pin  = GPIO_PIN_12,
    .active_level = 1   // 高电平亮
};

int main(void)
{
    LED_Init(&led_status);

    while (1) {
        LED_On(&led_status);
        delay_ms(500);
        LED_Off(&led_status);
        delay_ms(500);
    }
}

你看，应用层完全不知道寄存器长什么样。哪天项目换成 GD32 或者 AT32，只需要重写 hal_gpio.c，驱动层和应用层一行代码都不用改。

下面这张图，把 GPIO 驱动的三层架构关系画清楚了：

嗯，到这里，HAL 层的作用、边界，以及 GPIO 驱动的分层设计实战，咱们就聊完了。记住一句话：HAL 层是嵌入式软件的“护城河”，挖得越深，上层越安全。