文章目录

• 1. ringbuffer简单介绍
• 2. ringbuffer的代码实现
• • 2.1 ringbuffer数据结构定义
  • 2.2 ringbuffer初始化
  • 2.3 ringbuffer写数据
  • 2.4 ringbuffer读数据
• 3. 在串口中使用ringbuffer
• • 3.1 为什么需要ringbuffer接收串口数据
  • 3.2 初始化串口和ringbuffer
  • 3.3 串口中断接收数据
• 4. 测试结果
• • 4.1 测试是否丢包
  • 4.2 补充测试

1. ringbuffer简单介绍

环形缓冲区（ringbuffer），实际上就是一种队列数据结构，只不过它不是线性队列，而是环形队列。

关于环形缓冲区（ringbuffer）的详细介绍，网上一搜一大把，这里不重复介绍了，我这里直接上代码。

详细介绍可以参考下面链接里面的介绍：

• https://en.wikipedia.org/wiki/Circular_buffer 介绍环形缓冲区的一个网站，写的非常详细。
• 环形缓冲区（Ring Buffer）使用说明

2. ringbuffer的代码实现

实现环形缓冲区的形式有使用数组的，也可以使用链表。我这里为了实现简单，就用数组作为 ringbuffer 的内存来实现。

在实现 ringbuffer 时，要有两个指针，读指针和写指针。每当向 ringbuffer 中写入一个数据时，写指针加1；同理从 ringbuffer 中读取一个数据时，读指针加1。

对于 ringbuffer 的读写操作，我们有几个重点问题需要考虑：

• 读写指针移动到 ringbuffer 的最大长度之后，如何返回首位置？

  对于 ringbuffer 的读写指针位置的计算，精髓就在于对读写指针进行取模运算。即当读写指针移动一个位置时，然后对 ringbuffer 的大小进行取模运算，这样当读写指针移动到最末尾时，取模运算的结果就是 0，即返回的 ringbuffer 的首位置了。代码表示如下：

  write_index     : 当前写位置
  read_index      : 当前读位置
  ringbuffer_size : ringbuffer 缓冲区的大小
  
  /* 读写指针每移动一个位置，都对 ringbuffer 大小进行取模运算 */
  write_index = (write_index + 1) % ringbuffer_size	
  read_index = (read_index + 1) % ringbuffer_size
  

• 如何判断 ringbuffer 为空？

  读写指针的位置相等时，说明 ringbuffer 为空。

  write_index == read_index
  

• 如何判断 ringbuffer 为满？

  当写指针的下一个位置等于读指针的位置时，那么 ringbuffer 为满。

  (write_index + 1) % ringbuffer_size == read_index
  

2.1 ringbuffer数据结构定义

ringbuffer 的数据结构封装如下，主要成员有读写指针，还有指向用户提供 buffer 的指针和 buffer 的大小。

其中，读写指针的这两个成员，很可能会因为外部一些原因（比如串口中断）造成读写位置的变化，而这个变化编译器很可能不知道，所以为了防止编译器优化而加上 volatile 关键字修饰。

typedef struct _ringbuffer_t
{
	volatile unsigned int read_index;           /* 当前读位置 */
	volatile unsigned int write_index;          /* 当前写位置 */  
	unsigned int buffer_size;					/* ringbuffer大小 */
    unsigned char *buffer_ptr;  				/* 指向ringbuffer */    
} ringbuffer_t;

2.2 ringbuffer初始化

/*
 * 函数作用 : 初始化ringbuffer结构体（句柄）
 * 参数  rb   : 指向ringbuffer句柄
 * 参数  pool : 指向ringbuffer缓冲区，用户调用时一般提供一个数组
 * 参数  size : 缓冲区的大小 
 * 返回值 : 无
 */
void ringbuffer_init(ringbuffer_t *rb, unsigned char *pool, unsigned int size)
{
    /* initialize read and write index */
    rb->read_index = 0;
    rb->write_index = 0;

    /* set buffer pool and size */
    rb->buffer_ptr = pool;
    rb->buffer_size = size;
}

主要是初始化 ringbuffer_t 结构体成员。用户需要提供一个定义好的数组变量，传递到这个初始化函数中，从而使得 buffer_ptr 这个指向具体 buffer 的成员指向用户提供的一个数组。

2.3 ringbuffer写数据

前面已经介绍了，读写指针移动运算的精髓就在于，对 ringbuffer 的大小进行取模运算。

另外，当写指针的下一个位置与当前读位置相等时，说明 ringbuffer 已经满了，这个时候就不再继续向环形缓冲区写入数据了。

代码实现如下：

/*
 * 函数作用 : 向目标缓冲区写入一个字节数据
 * 参数  ch : 要写入ringbuffer的数据
 * 参数  rb : 指向ringbuffer句柄
 * 返回值   : 写入成功返回0，失败返回-1
 */
int ringbuffer_write(unsigned char ch, ringbuffer_t *rb)
{
    if (rb->read_index == ((rb->write_index + 1) % rb->buffer_size))
    {
        return -1;
    }
    else
    {
        rb->buffer_ptr[rb->write_index] = ch;
        rb->write_index = (rb->write_index + 1) % rb->buffer_size;
        return 0;
    }
}

2.4 ringbuffer读数据

当读写指针相等时，ringbuffer 为空。具体代码实现如下：

/*
 * 函数作用 : 向目标缓冲区读取一个字节数据
 * 参数  ch : 把读取到的数据保存到ch所指向的内存
 * 参数  rb : 指向ringbuffer句柄
 * 返回值   : 读取成功返回0，失败返回-1
 */
int ringbuffer_read(unsigned char *ch, ringbuffer_t *rb)
{
    if (rb->read_index == rb->write_index)
    {
        return -1;
    }
    else
    {
        *ch = rb->buffer_ptr[rb->read_index];
        rb->read_index = (rb->read_index + 1) % rb->buffer_size;
        return 0;
    }
}

3. 在串口中使用ringbuffer

3.1 为什么需要ringbuffer接收串口数据

串口中断接收数据时，每接收到一个字节数据就会触发一次中断，然后我们再把这一字节的数据交给上一层的程序进行处理。很多时候，如果我们接收到一个字节数据就处理一下，太过于频繁。有时也可能因为数据量太大，或者接收数据太快，而上层代码来不及处理数据，等到下一次接收的数据来到时，很可能会覆盖掉没来得及处理的数据。这是就会出现丢包的现象。

为了防止丢包，我们可以在中断中暂时先把接收到的数据放到一个缓冲区里面，等到CPU去处理时，一次性就把所有的数据都取出来进行处理。而对于这种对数据的读和写的过程，使用环形缓冲区是非常适合的。

3.2 初始化串口和ringbuffer

使用串口接收数据，先对串口进行初始化，以及对 ringbuffer 进行初始化。

static unsigned char uart_rx_buffer[16];  // 环形缓冲区所指向的数组
static ringbuffer_t uart_rx_ringbuffer;   // 环形缓冲区句柄
UART_HandleTypeDef huart1;

void MX_USART1_UART_Init(void)
{
    /* 初始化ringbuffer，使得ringbuffer指向用户提供的数组 */
    ringbuffer_init(&uart_rx_ringbuffer, uart_rx_buffer, sizeof(uart_rx_buffer));
	
    /* 串口参数配置 */
    huart1.Instance = USART1;
    huart1.Init.BaudRate = 115200;
    huart1.Init.WordLength = UART_WORDLENGTH_8B;
    huart1.Init.StopBits = UART_STOPBITS_1;
    huart1.Init.Parity = UART_PARITY_NONE;
    huart1.Init.Mode = UART_MODE_TX_RX;
    huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    
    /* 串口引脚初始化 */
    if (HAL_UART_Init(&huart1) != HAL_OK)
    {
        Error_Handler();
    }
    
    /* 串口中断配置 */
    HAL_NVIC_SetPriority(USART1_IRQn, 4, 0);		// 中断优先级配置
    HAL_NVIC_EnableIRQ(USART1_IRQn);				// 使能串口1中断
    __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE);	// 使能串口1接收中断
}

3.3 串口中断接收数据

在串口中断中，把接收到的数据保存到我们刚刚定义的 ringbuffer 中。

void USART1_IRQHandler(void)
{
    int ch = -1;

    if ((__HAL_UART_GET_FLAG(&(huart1), UART_FLAG_RXNE) != RESET) &&
        (__HAL_UART_GET_IT_SOURCE(&(huart1), UART_IT_RXNE) != RESET))
    {
        while (1)
        {
            ch = -1;
            if (__HAL_UART_GET_FLAG(&(huart1), UART_FLAG_RXNE) != RESET)
            {
                ch =  huart1.Instance->DR & 0xff;
            }
            if (ch == -1)
            {
                break;
            }
            /* 中断接收到的数据，存入 ringbuffer */
            ringbuffer_write(ch, &uart_rx_ringbuffer);
        }
    }
}

4. 测试结果

4.1 测试是否丢包

使用串口助手，每隔 10ms 自动发送一次数据，而在 main 函数故意延时20ms再去把 ringbuffer 的数据读出来在发送到串口助手上。

我们前面的代码定义的 ringbuffer 的大小是 16 字节，在串口助手中，当我们每隔 10ms 发送 5 个字节时，main 函数延时 20ms 再接收。这时可以发现是没有出现丢包的现象的，实验结果如下：

4.2 补充测试

但是，如果我们一次性发送的数据大于 ringbuffer 的大小（16字节）时，那么就会出现丢包的现象了。

另外，如果每 10ms 一次性发送 10 个字节，由于 main 函数延时了 20ms 才去处理数据，如果长期堆积下去的话，这时也会造成数据丢包的现象。

所以说，如果我们一次性要接收的数据量太大，或者说处理的速度太慢，为了防止数据丢包现象，最好自己评估把 ringbuffer 的大小设置大一点。