3、中间件层设计：环形缓冲区、软件定时器、消息队列的实现与封装

中间件层，说白了就是连接硬件驱动和业务逻辑的那层“胶水”。我早年做项目时，经常把业务逻辑和底层操作混在一起写，结果一个按键消抖改了三次，中断服务程序里塞满了各种标志位。后来才明白，没有中间件层的代码，就像没有交通信号灯的路口——谁都能走，但谁都走不快。

这一章，我们聚焦三个最常用的中间件组件：环形缓冲区、软件定时器和消息队列。它们不依赖具体硬件，却能让你的代码结构清晰一个数量级。

3.1 环形缓冲区：最朴素的数据暂存池

环形缓冲区，也叫循环队列。它的核心思想很简单：一块固定大小的内存，写指针追着读指针转圈。为什么不用链表？在单片机上，动态内存分配是灾难——你不知道什么时候会碎片化到分配失败。环形缓冲区是静态的，大小编译时就定好了，运行时零分配。

我习惯把环形缓冲区做成不覆盖模式——写满时直接返回失败，而不是覆盖旧数据。为什么？因为覆盖意味着数据丢失是静默的，调试时你根本不知道丢了什么。我曾经在一个串口接收模块里用了覆盖模式，结果上位机发来的指令偶尔被吞掉，排查了两天才发现是缓冲区溢出覆盖了未处理的命令。

// 环形缓冲区结构体定义
typedef struct {
    uint8_t *buffer;
    uint32_t size;
    uint32_t head;  // 写指针
    uint32_t tail;  // 读指针
} ringbuf_t;

// 写入一个字节
int ringbuf_write(ringbuf_t *rb, uint8_t data) {
    uint32_t next = (rb->head + 1) % rb->size;
    if (next == rb->tail) {
        return -1;  // 缓冲区满
    }
    rb->buffer[rb->head] = data;
    rb->head = next;
    return 0;
}

// 读取一个字节
int ringbuf_read(ringbuf_t *rb, uint8_t *data) {
    if (rb->head == rb->tail) {
        return -1;  // 缓冲区空
    }
    *data = rb->buffer[rb->tail];
    rb->tail = (rb->tail + 1) % rb->size;
    return 0;
}

3.2 软件定时器：摆脱硬件定时器数量限制

硬件定时器是稀缺资源，一个STM32F103也就四五个。但你的项目可能需要同时管理按键消抖、LED闪烁、超时检测、周期性数据采集……怎么办？软件定时器就是答案。

它的原理很简单：一个全局的“心跳”计数器（通常由1ms的硬件定时器中断驱动），每个软件定时器记录自己的到期时间。主循环里轮询，到期就执行回调。

我见过有人把软件定时器的回调函数直接放在中断里执行——千万别这么做。回调里如果操作了临界资源，死锁只是时间问题。正确的做法是：在中断里只设置一个标志位，主循环里检查并执行回调。

// 软件定时器结构体
typedef struct {
    uint32_t period;       // 定时周期(ms)
    uint32_t remaining;    // 剩余时间
    void (*callback)(void *arg);
    void *arg;
    uint8_t mode;          // 0:单次 1:周期
    uint8_t active;        // 1:运行中
} soft_timer_t;

// 定时器列表（静态分配）
#define MAX_TIMERS 16
static soft_timer_t timers[MAX_TIMERS];

// 1ms心跳调用此函数
void soft_timer_tick(void) {
    for (int i = 0; i < MAX_TIMERS; i++) {
        if (timers[i].active && timers[i].remaining > 0) {
            timers[i].remaining--;
            if (timers[i].remaining == 0) {
                // 设置回调标志，不在中断中直接执行
                timer_ready[i] = 1;
            }
        }
    }
}

3.3 消息队列：任务间通信的“邮局”

消息队列比环形缓冲区更高级。它传递的不是字节，而是“消息”——可以是结构体指针、命令码、或者一个事件ID。消息队列天然支持多生产者、多消费者，而且自带阻塞/非阻塞机制。

在单片机上，我通常用定长消息的队列。为什么？变长消息需要动态内存管理，而单片机最怕这个。定长消息的每个槽位大小固定，队列深度编译时确定，简单可靠。

// 消息队列结构体
typedef struct {
    void *pool;           // 消息存储池
    uint32_t msg_size;    // 每条消息大小(字节)
    uint32_t queue_len;   // 队列深度
    uint32_t head;
    uint32_t tail;
    uint32_t count;
} msg_queue_t;

// 发送消息（非阻塞）
int msg_queue_send(msg_queue_t *mq, const void *msg) {
    if (mq->count >= mq->queue_len) {
        return -1;  // 队列满
    }
    uint8_t *dest = (uint8_t *)mq->pool + mq->head * mq->msg_size;
    memcpy(dest, msg, mq->msg_size);
    mq->head = (mq->head + 1) % mq->queue_len;
    mq->count++;
    return 0;
}

// 接收消息（非阻塞）
int msg_queue_recv(msg_queue_t *mq, void *msg) {
    if (mq->count == 0) {
        return -1;  // 队列空
    }
    uint8_t *src = (uint8_t *)mq->pool + mq->tail * mq->msg_size;
    memcpy(msg, src, mq->msg_size);
    mq->tail = (mq->tail + 1) % mq->queue_len;
    mq->count--;
    return 0;
}

3.4 三者关系与整体架构

这三个组件不是孤立的。在实际项目中，它们经常配合使用：

• UART中断把收到的字节写入环形缓冲区
• 解析线程从缓冲区读取完整帧，打包成消息发到消息队列
• 软件定时器定期触发数据采集，结果也发到消息队列
• 主循环从消息队列取消息，根据消息类型分发处理

下面这张图展示了它们之间的协作关系：

3.5 封装与接口抽象

这三个组件虽然功能不同，但封装思路是一致的：

1. 隐藏内部实现：用户只通过函数接口操作，不直接访问结构体成员
2. 静态分配内存：所有内存编译时确定，运行时无malloc/free
3. 返回状态码：每个操作都返回成功/失败，不静默吞错误
4. 可重入设计：如果要在中断和主循环间共享，加临界区保护

这种接口设计的好处是：底层实现可以随时替换。比如你一开始用数组实现环形缓冲区，后来想改成链表——只要接口不变，上层代码一行都不用改。这就是抽象的价值。