STM32串口数据接收环形缓冲区接收实例说明     ...... 矜辰所致

前言

关于环形缓冲区，网上有大量的理论说明文章，在有些操作系统中，会有实现环形缓冲区的代码，比如 RT-Thread 的 ringbuffer.c 和 ringbuffer.h 文件，Linux 内核中的 kfifo.c 和 kfifo.h 文件。

环形缓冲区使用于多种场景，对于单片机领域典型的场合就是串口通讯的实现。在我们使用单片机的时候，如果没有用到操作系统，我们如何使用环形缓冲区来实现串口接收呢？

那么本文我们以 STM32 为例，来说明一下如何使用环形缓冲区实现 STM32 的串口数据接收和数据处理。

我是矜辰所致，全网同名，尽量用心写好每一系列文章，不浮夸，不将就，认真对待学知识的我们，矜辰所致，金石为开！

一、 基础介绍

虽然本文并不会深入的解析环形缓冲区的原理（大家可以自行查看网上理论文章），但是我们有必要简要说明一下环形缓冲区的工作模型，以及工作流程。

因为芯片的内存空间是线性连续的，不可能构成实际上的环形。所谓环形缓冲区，是开辟一段连续的内存空间，通过特别的设计逻辑，使得这段内存空间使用起来像是环形的。

我们来设计的时候，会开辟一段内存空间，比如单片机上定义一个数组。然后定义一个写指针，和一个读指针。

如果有数据写入，把数据放到写指针指向的地址，写指针递增。当开辟的最后一个地址写完以后，写指针指向起始位置。

读取的时候，先判断缓冲区内确实有数据存在，然后从读指针的地址开始读取数据，读指针递增。

简单的流程图如下：

上面是一个简单的示意图，我们在实现的时候，有几个问题需要考虑一下：

• 合理的环形缓冲区大小，太小的话，容易造成数据丢失或者数据阻塞，太大的话需要占用更多的内存空间，在一些 Flash 比较小的 MCU 上，需要合理控制；
• 上图中最后文字提到的，数据满了以后，是覆盖，还是阻塞，这要看自己的应用场景通过自己的程序控制；
• 我们还需要能够随时判断缓冲区是否为空，是否已满，这样才能有利于我们的数据处理 。

简单介绍这么多，下面会出实现代码，然后进行实际使用说明。

二、 实现代码

不墨迹，这里直接给出一个可以使用的环形缓冲区的驱动代码，方便以后用到时候直接复制，这也是很早以前网上下载的，都忘了从哪里弄下来的= =！ 当然环形缓冲区网上的代码也有不同版本，但是大体上的本质都大差不差。

首先是 .c 文件，里面实现了 环形缓冲区初始化，判断缓冲区是否是空/满，写环形缓冲区，读取环形缓冲区 等函数。

ringbuff.c

里面实现了，环形缓冲区的初始化，

#include "ringbuff.h"
#include "stdio.h"
#include <string.h>void RingBuff_Init(RingBuff_t *rb) //初始化函数
{rb->Head = 0; //头指针置于起始位rb->Tail = 0; //尾指针置于起始位rb->Length = 0; //计录当前数据长度 判断是否存有数据//   HAL_UART_Receive_IT(&hlpuart1, &data_tmp, 1); // 开启串口接收中断
}/*** @brief  判断队列是否为空* @note   * @param  *rb: 结构体指针* @retval 返回0和1,1代表空，0代表非空*/
te_cicrleQueueStatus_t RingBuff_IsEmpty(RingBuff_t *rb)
{return (rb->Head == rb->Tail) ? CQ_STATUS_IS_EMPTY : CQ_STATUS_OK;
}
/*** @brief  判断队列是否为满* @note   * @param  *rb: 结构体指针* @retval 返回0和1,1代表满，0代表非满*/
te_cicrleQueueStatus_t RingBuff_IsFull(RingBuff_t *rb)
{return ((rb->Tail + 1) % BUFFER_SIZE == rb->Head) ? CQ_STATUS_IS_FULL : CQ_STATUS_OK;
}/***功能：数据写入环形缓冲区*入参1：要写入的数据*入参2：buffer指针*返回值：buffer是否已满*/
uint8_t Write_RingBuff(RingBuff_t *ringBuff , uint8_t data)
{if(ringBuff->Length >= BUFFER_SIZE) //判断缓冲区是否已满{//如果buffer爆掉了，清空buffer，进行重新初始化   不初始化，会复位死机// memset(ringBuff, 0, BUFFER_SIZE);// RingBuff_Init(&ringBuff);return 1;}//将单字节数据存入到环形buffer的tail尾部ringBuff->Ring_Buff[ringBuff->Tail]=data;    //重新指定环形buffer的尾部地址，防止越界非法访问ringBuff->Tail = ( ringBuff->Tail + 1 ) % BUFFER_SIZE;//存入一个字节数据成功，len加1 ringBuff->Length++;    return 0;
}/***功能：读取缓存区整帧数据-单字节读取*入参1：存放提取数据的指针*入参2：环形区buffer指针*返回值：是否成功提取数据*/
uint8_t Read_RingBuff_Byte(RingBuff_t *ringBuff , uint8_t *rData)
{if(ringBuff->Length == 0)//判断非空{return 1;}//先进先出FIFO，从缓冲区头出，将头位置数据取出*rData = ringBuff->Ring_Buff[ringBuff->Head];//将取出数据的位置，数据清零ringBuff->Ring_Buff[ringBuff->Head] = 0;//重新指定buffer头的位置，防止越界非法访问ringBuff->Head = (ringBuff->Head + 1) % BUFFER_SIZE;//取出一个字节数据后，将数据长度减1ringBuff->Length--;return 0;
}/*
从环形缓冲区读多个字节
*/
te_cicrleQueueStatus_t RingBuff_ReadNByte(RingBuff_t *pRingBuff, uint8_t *pData, int size)
{int i = 0;if(NULL == pRingBuff || NULL == pData)return CQ_STATUS_ERR;for( i = 0; i < size; i++){Read_RingBuff_Byte(pRingBuff, pData+i);}return CQ_STATUS_OK;
}//向环形缓冲区写多个字节
te_cicrleQueueStatus_t RingBuff_WriteNByte(RingBuff_t *pRingBuff, uint8_t *pData, int size)
{int i = 0;if(NULL == pRingBuff || NULL == pData)return CQ_STATUS_ERR;for(i = 0; i < size; i++){Write_RingBuff(pRingBuff, *(pData+i));}return CQ_STATUS_OK;
}//获取当前环形缓冲区中数据长度
int RingBuff_GetLen(RingBuff_t *pRingBuff)
{if(NULL == pRingBuff)return 0;if(pRingBuff->Tail >= pRingBuff->Head){return pRingBuff->Tail - pRingBuff->Head;}return pRingBuff->Tail + BUFFER_SIZE - pRingBuff->Head;
}uint16_t RQBuff_GetBuffLenth(RingBuff_t* RQ_Buff) {return RQ_Buff->Length;
}//获取当前头部数据
unsigned char RingBuff_GetHeadItem(RingBuff_t *pRingBuff)
{if(NULL == pRingBuff)return CQ_STATUS_ERR;return pRingBuff->Ring_Buff[pRingBuff->Head];
}//获取指定下标数据
unsigned char RingBuff_GetIndexItem(RingBuff_t *pRingBuff, int index)
{if(NULL == pRingBuff || index > BUFFER_SIZE-1)return CQ_STATUS_ERR;return pRingBuff->Ring_Buff[index%BUFFER_SIZE];
}

ringbuff.h

#ifndef _RINGBUFF_H_INCLUDED
#define _RINGBUFF_H_INCLUDED#include "main.h"
#include "Datadef.h"
#include "stdio.h"
#include <string.h>
#include "usart.h"#define USART_BUFF_MAX 1024 
#define BUFFER_SIZE 1024        /* 环形缓冲区的大小 */typedef enum {CQ_STATUS_OK = 0,CQ_STATUS_IS_FULL,CQ_STATUS_IS_EMPTY,CQ_STATUS_ERR    // 出错
} te_cicrleQueueStatus_t;typedef struct
{uint32_t Head;uint32_t Tail;uint32_t Length;uint8_t Ring_Buff[BUFFER_SIZE];
} RingBuff_t;extern RingBuff_t  enoceanbuff;te_cicrleQueueStatus_t RingBuff_IsEmpty(RingBuff_t *rb);te_cicrleQueueStatus_t RingBuff_IsFull(RingBuff_t *rb);te_cicrleQueueStatus_t RingBuff_ReadNByte(RingBuff_t *pRingBuff, uint8_t *pData, int size);te_cicrleQueueStatus_t RingBuff_WriteNByte(RingBuff_t *pRingBuff, uint8_t *pData, int size);int RingBuff_GetLen(RingBuff_t *pRingBuff);unsigned char RingBuff_GetIndexItem(RingBuff_t *pRingBuff, int index);uint8_t Write_RingBuff(RingBuff_t *ringBuff , volatile uint8_t data);
uint8_t Read_RingBuff_Byte(RingBuff_t *ringBuff , uint8_t *rData);
void RingBuff_Init(RingBuff_t *rb);uint16_t RQBuff_GetBuffLenth(RingBuff_t* RQ_Buff);#endif //_MOD_BUTTON_H_INCLUDED

这里两个文件使用的时候可以直接放到工程里面，比如下面两个工程：

三、 实际使用

上面我们给出了程序源码，然后根据自己的工程框架放到自己工程下面，接下来我们就来实际说明一下怎么使用。

我们这里把标准库 和 HAL 库的串口数据处理都说明一下。

3.1 标准库

首先我们需要定义一个环形缓冲区，在我们的 STM32 上也就是顶一个结构体变量。 在我们上面的 ringbuff.h 文件中有一个名为 RingBuff_t 的结构体，我们需要定义一下：

我们可以通过定义 BUFFER_SIZE 来定义自己的缓冲区大小。

#define BUFFER_SIZE 1024        /* 环形缓冲区的大小 */

然后在程序初始化阶段，使用 RingBuff_Init 初始化一下这个变量，如下图：

数据写入：

好，对于标准库而言，我们串口接收数据一般在串口中断中实现，我们实现的方式如下：

以前我们每次收到数据或许也会放到自己定义的缓冲区中，使用了环形缓冲区，我们直接使用Write_RingBuff 函数即可。

数据读取：

那么怎么读取数据呢？

我们在环形缓冲区实现代码里面有Read_RingBuff_Byte 读取数据的函数，读取的关键在于什么时候读！

有一种通用的方式，就是隔一段时间检查一下环形缓冲区是否为空，如果不为空，就进行读取。这个可以放在 while 循环中进行，我这里给个例子：

当然，除了这种等待一段时间让数据接收完成的方式，对于 STM32 而言，还有利用空闲中断（IDLE）的方式，具体实现如下：

当然，在标准库中使用 IDLE 中断，记得使能一下中断，如下图：

在程序中，如果需要清空缓存，也是直接使用 RingBuff_Init 即可。实际上都不用清空缓冲区内的数据，即便其他位置有数据也没有关系，因为我们判断是否有数据都是先通过指针位置来判断，才进行读写操作，所以内存中即便有数据，也会被覆盖。

3.2 HAL库

接下来说说 HAL 库，其实操作逻辑也是一样的，只不过 HAL 库开启接收中断的时候需要使用 HAL_UART_Receive_IT 函数 。

第一步，当然是定义 RingBuff_t 结构体变量，初始化，流程和标准库一样，只不过初始化函数需要多加上一句话，使用 HAL_UART_Receive_IT 开启接收中断，而且还需要额外定义一个变量，用来配合这个函数 ，具体的如下图：

使用上面 RingBuff_Init 完成初始化。

数据写入：

数据的接收也是在串口中断的时候进行，在 HAL 库中操作如下：

因为定义了一个变量 data_tmp 用来存放接收到的串口数据，而且每次接收完以后，接收到的数据又存放于 data_tmp 。

数据读取：

至于数据读取， HAL 的方式完全和 标准库一样，好像没有什么特别需要注意的，可以循环中判断缓冲区非空，进行读取数据，也可以通过 IDLE 中断，进行读取数据然后处理。

3.3 数据处理的细节说明

上面我们已经掌握了如何存环形缓冲区，什么时候取数据，怎么取数据，这里再补充一下数据处理中的一个问题。

因为我们处理数据都是一帧一帧的，我们不管接受到正确的数据，还是不需要的数据，我们都需要把一帧数据读取完。 否者会影响下一帧数据的处理。 如果不用环形缓冲区，用最简单粗暴的方法就是一旦检测到错误的数据，直接清空缓冲区，但是这在数据量大的时候很容易会导致丢包的情况。我们采用环形缓冲区就是为了尽可能的避免丢包。

所以呢即便我们收到不需要的数据，我们也需要把这个错误的数据读取完毕。

我们接受的数据协议，一般在包头后面都会跟上本条数据的长度，所以，我们可以根据读到的长度信息，使用RingBuff_ReadNByte 把剩余的数据读取完毕。

比如：

知道如何处理不需要的数据，基本上环形缓冲区的使用也没有什么问题了。

结语

本文详细的把 STM32 标准库和 HAL 库如何使用环形缓冲区说明了一遍，相信大家在实际应用中都能够知道怎么使用。

当然上面的都是使用裸机的示例，对于使用 RTOS 该怎么处理，如果有机会用到，我也会来记录说明。

好了，本文就到这里，谢谢大家！