主题
嵌入式 C 要点
嵌入式 C 的难点不在语法,而在编译器、硬件与中断同时插手你的代码。下面这些点是排查「写对了但不工作」类问题的高频入口。
volatile 到底解决什么问题
volatile 告诉编译器:这个变量可能被当前代码之外的力量改变,每次使用都必须重新从内存读取。它解决的是优化问题,不是并发问题。
c
/* 场景一:硬件寄存器 */
#define GPIOA_IDR (*(volatile unsigned int *)0x40010808UL)
/* 场景二:中断与主循环共享 */
static volatile unsigned int s_tick_ms; /* SysTick 中断里自增 */
void SysTick_Handler(void)
{
s_tick_ms++;
}
void delay_ms(unsigned int ms)
{
unsigned int start = s_tick_ms;
while ((s_tick_ms - start) < ms) { } /* 无 volatile 时可能死循环 */
}1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
三个典型场景:硬件寄存器、中断共享变量、多任务共享变量。反过来,局部变量加 volatile 只会拖慢速度,没有任何正确性收益。
常见误用
volatile 不保证原子性。s_tick_ms++ 在 8 位机上是「读-加-写」三步,主循环读取时可能拿到中间值。32 位对齐变量在 32 位机上是原子的,8 位机上不是。
位操作
寄存器操作只有四种意图:置位、清位、取反、判断。写成宏,避免手写移位出错:
c
#define BIT(n) (1UL << (n))
#define SET_BIT(r, n) ((r) |= BIT(n))
#define CLR_BIT(r, n) ((r) &= ~BIT(n))
#define TGL_BIT(r, n) ((r) ^= BIT(n))
#define GET_BIT(r, n) (((r) >> (n)) & 0x01UL)
/* 多比特位域:先清再写,避免影响同组其它位 */
#define WRITE_FIELD(r, mask, pos, val) \
((r) = ((r) & ~((mask) << (pos))) | (((val) & (mask)) << (pos)))1
2
3
4
5
6
7
8
9
2
3
4
5
6
7
8
9
注意事项:
- 宏参数一律加括号,否则
SET_BIT(x, a + 1)会展开成x |= 1 << a + 1,结果错得很难发现。 - 操作 16 位寄存器时用
1U而不是1UL,避免高位写入产生副作用(部分外设写 1 即清标志)。 - 有些寄存器写 1 清零(如中断标志),此时不能用
&= ~BIT(n),必须直接写BIT(n)。
struct + 函数指针:操作集模式
这是把驱动写成可替换组件的核心手法。上层只依赖接口表,不依赖具体芯片。
c
/* 1. 定义行为接口 */
typedef struct {
int (*init)(void);
int (*read)(float *value);
int (*sleep)(void);
} sensor_ops_t;
/* 2. 定义设备对象:状态 + 行为 */
typedef struct {
const char *name;
const sensor_ops_t *ops;
void *priv; /* 指向具体驱动的私有数据 */
} sensor_t;
/* 3. 具体实现 */
static int sht30_init(void) { /* ... */ return 0; }
static int sht30_read(float *value) { /* ... */ return 0; }
static int sht30_sleep(void) { return 0; }
static const sensor_ops_t sht30_ops = {
.init = sht30_init,
.read = sht30_read,
.sleep = sht30_sleep,
};
/* 4. 对上层只暴露对象 */
sensor_t g_temp_sensor = { "SHT30", &sht30_ops, 0 };
/* 5. 业务代码完全不关心底层是 I2C 还是 SPI */
void task_sample(sensor_t *dev)
{
float v = 0.0f;
if (dev->ops->read(&v) == 0) {
/* 使用 v */
}
}1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
换成另一颗传感器时,只需新增一份 *_ops,业务代码零改动。这就是「可移植性」在 C 里的具体形态。
为什么 const 很关键
static const sensor_ops_t 会被放进 Flash 的只读段,不占 RAM。去掉 const 后,每个驱动都会在 RAM 里多占 3 个指针,小资源芯片上很致命。
环形缓冲:中断收数据的标准答案
串口、ADC、按键扫描都需要「中断写、主循环读」的缓冲。下面这版是无锁单生产者/单消费者的最小实现:
c
#define RB_SIZE 128 /* 必须是 2 的幂 */
typedef struct {
volatile unsigned int head; /* 写入位置,仅中断修改 */
volatile unsigned int tail; /* 读取位置,仅主循环修改 */
unsigned char buf[RB_SIZE];
} ringbuf_t;
static inline unsigned int rb_count(const ringbuf_t *rb)
{
return (rb->head - rb->tail) & (RB_SIZE - 1);
}
/* 中断上下文调用 */
int rb_put(ringbuf_t *rb, unsigned char byte)
{
unsigned int next = (rb->head + 1U) & (RB_SIZE - 1U);
if (next == rb->tail) {
return -1; /* 满,丢弃 */
}
rb->buf[rb->head] = byte;
rb->head = next;
return 0;
}
/* 主循环调用 */
int rb_get(ringbuf_t *rb, unsigned char *byte)
{
if (rb->head == rb->tail) {
return -1; /* 空 */
}
*byte = rb->buf[rb->tail];
rb->tail = (rb->tail + 1U) & (RB_SIZE - 1U);
return 0;
}1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
要点:
- 索引用
& (SIZE-1)代替% SIZE,8 位机上省几十个周期。 - 留一个空位区分「满」和「空」,比维护
count更安全(count需要两边原子更新)。 - 两边的索引都必须是
volatile,缓冲本体不必。
内存对齐与 packed
结构体默认按最大成员对齐,中间会插填充字节:
c
struct bad { unsigned char a; unsigned int b; unsigned char c; }; /* 12 字节 */
struct good { unsigned int b; unsigned char a; unsigned char c; }; /* 8 字节 */1
2
2
通信协议解析时,对端发来的字节流不能直接强转成结构体:
c
/* 危险:未对齐访问,M0 上直接 HardFault,M3/M4 上性能骤降 */
typedef struct __attribute__((packed)) {
unsigned char head;
unsigned short len;
unsigned int payload;
} frame_t;
frame_t *f = (frame_t *)rx_buf; /* rx_buf 可能不是 4 字节对齐 */1
2
3
4
5
6
7
8
2
3
4
5
6
7
8
正确做法是逐字节解析(顺便解决大小端问题):
c
unsigned int read_u32_le(const unsigned char *p)
{
return (unsigned int)p[0] | ((unsigned int)p[1] << 8) |
((unsigned int)p[2] << 16) | ((unsigned int)p[3] << 24);
}1
2
3
4
5
2
3
4
5
整数提升与隐式转换
c
unsigned char a = 200, b = 100;
if (a + b > 300) { } /* 成立:a+b 提升为 int = 300,300 > 300 为假? */1
2
2
实际行为:a + b 提升为 int,结果 300,300 > 300 为假。但如果写成 unsigned short,在某些平台上会先回绕。
必守规则:
- 比较前统一类型,别让编译器替你决定。
- 有符号与无符号混算时,有符号会被转成无符号,负数变巨大正数。
- 移位超过类型宽度是未定义行为,
1 << 32在 32 位机上不是 0。
中断服务函数的三条纪律
c
void TIM2_IRQHandler(void)
{
if (TIM2->SR & TIM_SR_UIF) {
TIM2->SR = ~TIM_SR_UIF; /* 写 0 清标志,注意不是 &= */
s_flag_10ms = 1; /* 只置标志 */
}
}1
2
3
4
5
6
7
2
3
4
5
6
7
- 进函数先清标志,否则退出后立刻再进一次。
- 不做浮点运算、不调用
malloc、不delay。 - 不在中断里调用可能阻塞的库函数(如带等待的
HAL_Delay、printf)。
编译期检查
把能在编译期发现的错误挡在前面:
c
#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
#define STATIC_ASSERT(c, m) typedef char static_assert_##m[(c) ? 1 : -1]
STATIC_ASSERT(sizeof(frame_t) == 8, frame_size);1
2
3
4
2
3
4
配合 -Wall -Wextra -Wconversion,大部分隐式转换问题在编译阶段就能暴露。