26、宏实现位操作：位域操作的宏封装，寄存器位操作的宏，位掩码生成宏

嵌入式开发里，位操作是家常便饭。说实话，我见过不少新手直接拿数字硬编码去操作寄存器，比如 REG |= 0x80。代码是能跑，但过两个月回来看，谁还记得 0x80 是干嘛的？

用宏封装位操作，说白了就是给这些「魔法数字」起个名字。我个人的习惯是，只要涉及寄存器操作，一律用宏。这习惯帮我省了无数次调试时间。

位掩码生成宏

位掩码是位操作的基础。你要操作某几位，就得先造一个掩码出来。

最常用的掩码生成宏长这样：

// 生成从第 n 位开始的 m 位掩码
#define BIT_MASK(n, m)      (((1U << (m)) - 1) << (n))

// 生成第 n 位的掩码（单 bit）
#define BIT(n)              (1U << (n))

// 生成低位掩码（低 n 位）
#define LOW_MASK(n)         ((1U << (n)) - 1)

举个例子，你想生成第 4 位到第 7 位的掩码：

uint32_t mask = BIT_MASK(4, 4);  // 结果是 0xF0

这里有个坑，我踩过。当 m 等于 32 时，1U << 32 在 C 标准里是未定义行为。所以如果你要操作 32 位寄存器，得单独处理：

#define BIT_MASK_SAFE(n, m)  (((m) == 32) ? 0xFFFFFFFFU : BIT_MASK(n, m))

寄存器位操作的宏封装

操作寄存器，无非就是读、写、置位、清零、翻转。我一般这样封装：

// 读寄存器的值
#define REG_READ(reg)                ((reg))

// 写寄存器的值
#define REG_WRITE(reg, val)          ((reg) = (val))

// 置位（将指定位置 1）
#define REG_SET_BIT(reg, bit)        ((reg) |= (bit))

// 清零（将指定位置 0）
#define REG_CLR_BIT(reg, bit)        ((reg) &= ~(bit))

// 翻转（将指定位取反）
#define REG_TOGGLE_BIT(reg, bit)     ((reg) ^= (bit))

// 读取指定位的值
#define REG_GET_BIT(reg, bit)        (((reg) & (bit)) != 0)

// 读取位域的值
#define REG_GET_FIELD(reg, mask)     ((reg) & (mask))

// 写入位域
#define REG_SET_FIELD(reg, mask, val) ((reg) = ((reg) & ~(mask)) | ((val) & (mask)))

实际项目中，我习惯把寄存器地址也宏定义出来：

#define GPIOA_BASE          0x40020000U
#define GPIOA_MODER         (*(volatile uint32_t *)(GPIOA_BASE + 0x00))
#define GPIOA_ODR           (*(volatile uint32_t *)(GPIOA_BASE + 0x14))

// 使用
REG_SET_BIT(GPIOA_MODER, BIT(10));   // 将 PA5 设为输出模式

位域操作的宏封装

位域（bit field）是 C 语言自带的功能，但我不太推荐直接用。为什么？因为位域的布局是编译器相关的，不同编译器可能把位域从高位到低位排列，也可能反过来。移植性很差。

我更喜欢用宏来模拟位域操作。比如一个 32 位寄存器，第 8-15 位是某个功能：

// 定义位域位置
#define FIELD_POS           8
#define FIELD_WIDTH         8
#define FIELD_MASK          BIT_MASK(FIELD_POS, FIELD_WIDTH)

// 读取位域
#define GET_FIELD(reg)       (((reg) & FIELD_MASK) >> FIELD_POS)

// 写入位域
#define SET_FIELD(reg, val)  ((reg) = ((reg) & ~FIELD_MASK) | ((val) << FIELD_POS))

用起来很直观：

uint32_t temp = REG_READ(GPIOA_MODER);
uint8_t mode = GET_FIELD(temp);      // 读取模式
SET_FIELD(temp, 0x03);               // 设置模式
REG_WRITE(GPIOA_MODER, temp);

如果你觉得每次都要三步操作太啰嗦，可以一步到位：

#define MODIFY_REG(reg, mask, val)   REG_WRITE((reg), (((reg) & ~(mask)) | ((val) & (mask))))

// 使用
MODIFY_REG(GPIOA_MODER, FIELD_MASK, 0x03 << FIELD_POS);

实战：GPIO 输出控制

拿 STM32 的 GPIO 输出来说，你要控制某个引脚的电平：

// 定义引脚
#define LED_PIN             BIT(5)    // PA5

// 点亮 LED
#define LED_ON()            REG_SET_BIT(GPIOA_ODR, LED_PIN)

// 熄灭 LED
#define LED_OFF()           REG_CLR_BIT(GPIOA_ODR, LED_PIN)

// 翻转 LED
#define LED_TOGGLE()        REG_TOGGLE_BIT(GPIOA_ODR, LED_PIN)

这样写的好处是，代码读起来跟自然语言一样。你不需要去查数据手册，就知道 LED_ON() 是干什么的。

避坑指南

我总结几个常见的坑：

• 宏参数不要有副作用：比如 REG_SET_BIT(reg, BIT(i++))，宏展开后 i++ 会被执行多次。我一般会在宏定义里加注释提醒。
• 注意类型宽度：在 32 位系统上，1U 是 32 位。但如果你操作 8 位寄存器，1U << 7 没问题，1U << 8 就溢出了。建议用 uint8_t 或 uint32_t 明确类型。
• volatile 不能丢：寄存器定义里必须有 volatile，否则编译器可能把多次读取优化成一次。
• 位域顺序：别用 C 语言自带的位域结构体，移植性太差。用宏封装更靠谱。

知识体系图

下面这张图总结了本章的核心内容：

总结

宏封装位操作，说白了就是给硬件操作穿上「可读性」的外衣。我个人觉得，写嵌入式代码，可读性比性能更重要——因为代码是给人看的，编译器才不在乎你写的是 REG |= 0x80 还是 REG_SET_BIT(REG, BIT(7))。

嗯，记住一点：宏定义里括号不要省，参数不要有副作用，volatile 不要丢。做到这三点，你的位操作代码就能既清晰又可靠。

---

公众号:蓝海资料掘金营，微信deep3321