Skip to content

嵌入式 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 时可能死循环 */
}

三个典型场景:硬件寄存器、中断共享变量、多任务共享变量。反过来,局部变量加 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)))

注意事项:

  • 宏参数一律加括号,否则 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 */
    }
}

换成另一颗传感器时,只需新增一份 *_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;
}

要点:

  • 索引用 & (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 字节 */

通信协议解析时,对端发来的字节流不能直接强转成结构体:

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 字节对齐 */

正确做法是逐字节解析(顺便解决大小端问题):

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);
}

整数提升与隐式转换 ​

c
unsigned char a = 200, b = 100;
if (a + b > 300) { }        /* 成立:a+b 提升为 int = 300,300 > 300 为假? */

实际行为: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. 不做浮点运算、不调用 malloc、不 delay。
  3. 不在中断里调用可能阻塞的库函数(如带等待的 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);

配合 -Wall -Wextra -Wconversion,大部分隐式转换问题在编译阶段就能暴露。

以资料沉淀经验,用产品验证想法 · 嵌入式资料与产品文档