mobile wallpaper 1mobile wallpaper 2mobile wallpaper 3mobile wallpaper 4
2370 字
6 分钟
STM32-11:循环缓冲区
2026-10-17

循环缓冲区在一块固定大小的内存上首尾相接,用读、写两个索引记录数据的位置,因此不需要反复申请和释放内存,就能实现先进先出的数据暂存。本文章将以串口命令的接收与解析为例,说明如何用循环缓冲区把“接收”和“处理”解耦。


为什么需要循环缓冲区#

串口数据什么时候到达、一次到达多少字节,都不由单片机决定。特别是在使用串口空闲事件接收不定长数据时,一次回调可能收到几个字节,也可能收到一整帧;一帧数据还可能被拆成多次回调。

如果直接在接收中断里解析命令、执行操作甚至阻塞发送,中断占用处理器的时间就会变长。此时下一批数据可能已经到达,却没有得到及时处理,严重时还会导致串口溢出。更合适的做法是:

  1. 中断只负责把刚收到的数据快速复制到缓冲区,然后立刻返回;
  2. 主循环在有空闲时再从缓冲区取出数据,完成拆包、校验和执行命令。

这正是典型的生产者—消费者模型:中断是生产者,主循环是消费者,而循环缓冲区是二者之间的传送带。

NOTE

串口本质上是一段连续的字节流,循环缓冲区不会自动制造“数据包”的边界。下面仍然需要依靠帧头、长度和校验,才能把字节流重新划分成一条条完整的命令。


循环缓冲区的工作原理#

循环缓冲区内部是一个普通数组,另外维护两个索引:

  • readIndex:下一个要读取的位置;
  • writeIndex:下一个要写入的位置。

写入时,把字节放进 buffer[writeIndex],再将 writeIndex 向后移动;读取时,从 buffer[readIndex] 取出字节,再将 readIndex 向后移动。索引到达数组末尾后回到 0,于是数组的首尾在逻辑上连接成一个环。

例如缓冲区长度为 8,当前 readIndex = 6、writeIndex = 2,说明索引 6、7、0、1 中存放着尚未读取的数据。未读字节数可以通过以下公式得到:

(writeIndex - readIndex + BUFFER_SIZE) % BUFFER_SIZE

公式中的 + BUFFER_SIZE 不能省略。索引是无符号数,当 writeIndex < readIndex 时,直接相减会发生下溢,加上缓冲区长度后再取模,才能得到正确的长度。

当 readIndex == writeIndex 时,队列为空。可是队列写满后也会出现两个索引相等的情况,仅凭索引无法区分“空”和“满”。常见处理方法有两种:

  • 额外维护一个计数器;
  • 保留一个空槽位,当 writeIndex 的下一格就是 readIndex 时,认为队列已满。

本文章采用第二种方法。数组虽然定义了 128 个字节,但最多只保存 127 个未读字节;这样无需额外状态,也能明确区分空和满。

下标: 0 1 2 3 4 5 6 7
数据: -- D E F -- -- A B
↑ ↑
readIndex writeIndex

上图中,读取顺序依次是 D、E、F、A、B。写入和读取都会自然地跨过数组末尾,回到下标 0。


工程目标与数据格式#

在本文章中,USART2 接收上位机发来的命令。每次接收完成后的数据先进入大小为 128 字节的循环缓冲区,主循环再从中提取完整、合法的命令帧,并原样返回给上位机。

命令帧的格式如下:

偏移字段长度说明
0帧头1 字节固定为 0xAA
1整帧长度 L1 字节包含帧头、长度、数据和校验
2 至 L-2数据L-3 字节数据内容
L-1校验1 字节前 L-1 个字节逐字节相加后的低 8 位

为了保证一帧中至少有帧头、长度、1 字节数据和校验,长度 L 不能小于 4。例如下面这条命令:

AA 04 01 AF

整帧长度为 0x04,前三个字节之和为 0xAA + 0x04 + 0x01 = 0xAF,因此最后一个字节就是校验值。主循环识别出这帧数据后,会将它原样发送回去。


芯片配置#

  1. 在 Clock Configuration 中将 HCLK 设置为 72MHz;
  2. 在 Connectivity 中选择 USART2,将 Mode 设置为 Asynchronous,波特率保持 115200Bits/s;
  3. 此时 PA2 和 PA3 分别作为 USART2_TX 和 USART2_RX;
  4. 在 USART2 下方的 NVIC Settings 中启用 USART2 global interrupt,用于空闲接收和接收事件回调。

本工程使用中断方式接收,不需要配置 DMA。串口空闲事件的处理方式可以参考之前的串口通信文章。


代码实现#

在 Core/Inc 下新建 command.h,在 Core/Src 下新建 command.c,分别写入队列的接口和实现。
头文件只暴露两个操作:commandWrite 用于向队列写入一段数据,commandRead 用于取出一条完整合法的命令。

command.h
#ifndef __COMMAND_H__
#define __COMMAND_H__
#include <stdint.h>
uint8_t commandWrite(const uint8_t *data, uint8_t length);//将data中的数据搬入到buffer中
uint8_t commandRead(uint8_t *targetArray);//读取buffer中合法的数据包并将其搬入targetArray中
#endif

队列的写入与读取#

command.c中的完整实现如下:
首先声明内部工具函数:

  • addReadIndex:使readIndex的值增加i,若最终值大于BUFFER_SIZE则取溢出值;
  • readBuffer:获得buffer[i]的值,若i大于BUFFER_SIZE则会取溢出值;
  • bufferGetLength:获得buffer中有多少个元素;
  • appendArray:将appendArray[0]-appendArray[appendLength]复制到baseArray[appendPoint]之后;
  • checkDataPack:检测是否是一个有效的数据包:返回1则表示不是一个有效的数据包,返回2则表示数据包尚未接收完毕。
command.c
#include "command.h"
#define COMMAND_MIN_LENGTH 4
#define BUFFER_SIZE 128
static volatile uint8_t buffer[BUFFER_SIZE];
static volatile uint8_t readIndex = 0;
static volatile uint8_t writeIndex = 0;
static void addReadIndex(uint8_t length){//使readIndex的值增加i,若最终值大于BUFFER_SIZE则取溢出值
readIndex=(readIndex+length)%BUFFER_SIZE;
}
static uint8_t readBuffer(uint8_t i){//获得buffer[i]的值,若i大于BUFFER_SIZE则会取溢出值
return buffer[i%BUFFER_SIZE];
}
static uint8_t bufferGetLength(){//获得buffer中有多少个元素
return (writeIndex-readIndex+BUFFER_SIZE)%BUFFER_SIZE;
}
static void appendArray(uint8_t *baseArray,uint8_t *appendArray,uint8_t appendPoint,uint8_t appendLength){//将appendArray[0]-appendArray[appendLength]复制到baseArray[appendPoint]之后
for(uint8_t i=0;i<appendLength;i++){
baseArray[appendPoint+i]=appendArray[i];
}
return;
}

函数checkDataPack()负责检查是否是一个有效的数据包,返回1则表示不是一个有效的数据包,在之后将readIndex加1后继续寻找,返回2则表示数据包尚未接收完毕,停止寻找数据包:

  1. 首先检查当前指向的元素是否数据包头0xAA,若不是则直接返回1;
  2. 接着检查缓冲区元素数量是否大于最短指令长度,若不是则说明当前接收的数据不全,返回2;
  3. 然后读取数据包中的数据包长度信息,检查缓冲区元素数量是否大于数据包长度,若不是则说明当前接收的数据不全,返回2;
  4. 最后检查校验位,将前几位之和与校验位相比是否相等,若不是则返回1。
static uint8_t checkDataPack(){//检测是否是一个有效的数据包:返回1则表示不是一个有效的数据包,返回2则表示数据包尚未接收完毕
if(readBuffer(readIndex)!=0xAA){
return 1;
}
if(bufferGetLength()<COMMAND_MIN_LENGTH){
return 2;
}
uint8_t length=readBuffer(readIndex+1);
if(bufferGetLength()<length){
return 2;
}
uint8_t sum=0;
for(int i=0;i<length-1;i++){
sum+=readBuffer(readIndex+i);
}
if(sum!=readBuffer(readIndex+length-1)){
return 1;
}
return length;
}

然后是函数commandWrite,实现将接收的数据转移到缓存区buffer中:

uint8_t commandWrite(uint8_t *data,uint8_t length){//将data中的数据搬入到buffer中
if(length>(BUFFER_SIZE-bufferGetLength())){
return 0;
}
if(writeIndex+length<BUFFER_SIZE){
appendArray(buffer,data,writeIndex,length);
writeIndex+=length;
return 1;
}
else{
uint8_t first_length=BUFFER_SIZE-writeIndex;
appendArray(buffer,data,writeIndex,first_length);
appendArray(buffer,data+first_length,0,length-first_length);
writeIndex=length-first_length;
return 1;
}
}

最后是函数commandRead,负责搜寻一个合法的数据包并将其转移到targetArray中:

uint8_t commandRead(uint8_t *targetArray){//读取buffer中合法的数据包并将其搬入targetArray中
while (1) {
uint8_t check=checkDataPack();
if(check==1){
addReadIndex(1);
continue;
}
else if(check==2){
return 0;
}
else{
uint8_t length=readBuffer(readIndex+1);
for(uint8_t i=0;i<length;i++){
targetArray[i]=readBuffer(readIndex+i);
buffer[readIndex+i]=0;
}
addReadIndex(length);
return length;
}
}
}

接入串口空闲接收#

在main.c中引入队列接口,并准备接收暂存区和命令输出区:

/* USER CODE BEGIN Includes */
#include "command.h"
#include <stdint.h>
/* USER CODE END Includes */
/* USER CODE BEGIN PV */
uint8_t rxChunk[10];
/* USER CODE END PV */

由于每次接收的数据长度不固定,这里使用HAL_UARTEx_ReceiveToIdle_IT。回调函数中的Size表示本次实际收到的字节数。回调只做两件事:把数据送入循环缓冲区,然后重新开启下一次接收。

/* USER CODE BEGIN 0 */
void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size) {
if (huart == &huart2) {
(void)commandWrite(rxChunk, (uint8_t)Size);
HAL_UARTEx_ReceiveToIdle_IT(&huart2, rxChunk, sizeof(rxChunk));
}
}
/* USER CODE END 0 */

在进入while(1)之前开启第一次接收:

/* USER CODE BEGIN 2 */
HAL_UARTEx_ReceiveToIdle_IT(&huart2, rxChunk, sizeof(rxChunk));
/* USER CODE END 2 */

主循环从队列中尝试取出一条完整命令。只要返回值不为0,就说明已经拿到一帧合法数据,可以执行对应操作。本工程没有定义具体命令,因此先将其原样返回:

/* USER CODE BEGIN 3 */
uint8_t commandLength = commandRead(command);
if (commandLength != 0) {
HAL_UART_Transmit(&huart2, command, commandLength, HAL_MAX_DELAY);
}
HAL_Delay(10);

rxChunk只负责承接 HAL 当前这一次接收,里面的内容会在下一次接收时被覆盖;真正长期保存数据的,是command.c中的buffer。即使一帧数据被拆成多次回调,这些字节仍会按顺序追加在队列中,直到凑够长度字段指定的字节数。


测试#

将串口调试助手切换到 HEX 发送与 HEX 显示模式,然后依次进行以下测试:

  1. 发送AA 04 01 AF,应当收到完全相同的一帧;
  2. 先发送AA 04,暂停后再发送01 AF。单独发送前半帧时不会有返回,补齐后半帧后才会返回整帧,说明队列能够把分多次到达的数据拼接起来;
  3. 发送AA 04 01 AE,校验错误,不应当有返回;
  4. 发送11 22 AA 04 01 AF,主循环会跳过前面的无效字节,最终找到帧头并返回AA 04 01 AF;
  5. 连续快速发送多条合法命令,主循环会依次处理,队列起到短暂缓存的作用。
WARNING

当commandWrite因为空间不足而返回0时,本示例会丢弃这一小段新数据。实际项目中可以增加一个溢出计数器,在调试时观察缓冲区是否长期处于接近写满的状态。如果主循环经常来不及处理,应当减小HAL_Delay、加快命令处理,或适当增大BUFFER_SIZE。


总结#

相关函数#

HAL_UARTEx_ReceiveToIdle_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);//启用不定长数据的中断接收
HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size);//接收事件回调函数
uint8_t commandWrite(const uint8_t *data, uint8_t length);//向循环缓冲区写入一段数据
uint8_t commandRead(uint8_t *targetArray);//从循环缓冲区取出一个完整数据包

循环缓冲区#

循环缓冲区用一块固定大小的数组保存数据,通过读、写索引的首尾回绕实现先进先出。它让中断只做快速的搬运工作,把耗时的解析和执行留给主循环,是串口、DMA、传感器采样等异步数据流中非常常见的缓冲结构。

STM32-11:循环缓冲区
https://nf3eb.github.io/posts/stm32/stm32-11/
作者
NF3eb
发布于
2026-10-17
许可协议
CC BY-NC-SA 4.0

部分信息可能已经过时

目录