21ic电子技术开发论坛 › 单片机与嵌入式系统 › 极海MCU › 环形缓冲区ringbuffer在APM32F407串口数据接收中的应用 ...
返回列表 发新帖我要提问本帖赏金: 80.00元(功能说明)

[APM32F4] 环形缓冲区ringbuffer在APM32F407串口数据接收中的应用

[复制链接]
2240|2
 楼主| luobeihai 发表于 2024-12-4 21:47 | 显示全部楼层 |阅读模式
APM32F407, 环形缓冲区, ringbuffer, 大容量数据, 数据接收
本帖最后由 luobeihai 于 2024-12-4 22:09 编辑

#申请原创# @21小跑堂

1. ringbuffer介绍

首先，什么是环形缓冲区（ringbuffer）？环形缓冲区是具有固定的有限大小的缓冲区。它是一种队列数据结构，只不过它不是线性队列，而是环形队列。

环形缓冲区的环形，不是指物理内存上是连成一个环的，而是它在逻辑上是一个环形，它有两个索引值：
  • 写指针：当生产者（比如串口接收到数据）写入数据到缓冲区时，写指针移动到下一个位置。
  • 读指针：当消费者在缓冲区获取到一个数据时，读指针移动到下一个位置。

写入数据时，写指针递增；读出数据时，读指针递增。读指针索引不应该跳过写指针索引， 两个索引在到达缓冲区末端时都应该被赋值为0，这样就可以允许海量的数据流过缓冲区。

但是当写指针的下一个位置等于读指针时，说明缓冲区的数据已经满了，这时再继续往缓冲区写入数据则会覆盖还未来得及处理的数据。

对于环形缓冲区的详细介绍，网上也有很多相关的资源。

这里不过多介绍环形缓冲区的原理，本文着重介绍环形缓冲区在APM32F407串口快速接收大量数据时，如何处理数据做到不丢包。

2. ringbuffer的代码实现

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

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

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

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

    2. read_index      : 当前读位置
      

    3. ringbuffer_size : ringbuffer 缓冲区的大小
      


    4. 

    5. /* 读写指针每移动一个位置，都对 ringbuffer 大小进行取模运算 */
      

    6. write_index = (write_index + 1) % ringbuffer_size        
      

    7. read_index = (read_index + 1) % ringbuffer_size

  • 如何判断 ringbuffer 为空？
    读写指针的位置相等时，说明 ringbuffer 为空。
    复制
    1. write_index == read_index

  • 如何判断 ringbuffer 为满？
    当写指针的下一个位置等于读指针的位置时，那么 ringbuffer 为满。
    复制
    1. (write_index + 1) % ringbuffer_size == read_index

2.1 ringbuffer数据结构定义

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

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

复制
  1. typedef struct _ringbuffer_t
    

  2. {
    

  3.     volatile unsigned int read_index;           /* 当前读位置 */
    

  4.     volatile unsigned int write_index;          /* 当前写位置 */  
    

  5.     unsigned int buffer_size;                   /* ringbuffer大小 */
    

  6.     unsigned char *buffer_ptr;                  /* 指向ringbuffer */   
    

  7. } ringbuffer_t;

2.2 ringbuffer初始化

复制
  1. /*
    

  2. * 函数作用 : 初始化ringbuffer结构体（句柄）
    

  3. * 参数  rb   : 指向ringbuffer句柄
    

  4. * 参数  pool : 指向ringbuffer缓冲区，用户调用时一般提供一个数组
    

  5. * 参数  size : 缓冲区的大小
    

  6. * 返回值 : 无
    

  7. */
    

  8. void ringbuffer_init(ringbuffer_t *rb, unsigned char *pool, unsigned int size)
    

  9. {
    

  10.     /* initialize read and write index */
    

  11.     rb->read_index = 0;
    

  12.     rb->write_index = 0;
    

  13. ​
    

  14.     /* set buffer pool and size */
    

  15.     rb->buffer_ptr = pool;
    

  16.     rb->buffer_size = size;
    

  17. }

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

2.3 ringbuffer写数据

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

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

代码实现如下：

复制
  1. /*
    

  2. * 函数作用 : 向目标缓冲区写入一个字节数据
    

  3. * 参数  ch : 要写入ringbuffer的数据
    

  4. * 参数  rb : 指向ringbuffer句柄
    

  5. * 返回值   : 写入成功返回0，失败返回-1
    

  6. */
    

  7. int ringbuffer_write(unsigned char ch, ringbuffer_t *rb)
    

  8. {
    

  9.     if (rb->read_index == ((rb->write_index + 1) % rb->buffer_size))
    

  10.     {
    

  11.         return -1;
    

  12.     }
    

  13.     else
    

  14.     {
    

  15.         rb->buffer_ptr[rb->write_index] = ch;
    

  16.         rb->write_index = (rb->write_index + 1) % rb->buffer_size;
    

  17.         return 0;
    

  18.     }
    

  19. }

2.4 ringbuffer读数据

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

复制
  1. /*
    

  2. * 函数作用 : 向目标缓冲区读取一个字节数据
    

  3. * 参数  ch : 把读取到的数据保存到ch所指向的内存
    

  4. * 参数  rb : 指向ringbuffer句柄
    

  5. * 返回值   : 读取成功返回0，失败返回-1
    

  6. */
    

  7. int ringbuffer_read(unsigned char *ch, ringbuffer_t *rb)
    

  8. {
    

  9.     if (rb->read_index == rb->write_index)
    

  10.     {
    

  11.         return -1;
    

  12.     }
    

  13.     else
    

  14.     {
    

  15.         *ch = rb->buffer_ptr[rb->read_index];
    

  16.         rb->read_index = (rb->read_index + 1) % rb->buffer_size;
    

  17.         return 0;
    

  18.     }
    

  19. }

3. APM32F407串口中使用ringbuffer接收数据

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

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

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

3.2 初始化串口和ringbuffer

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

复制
  1. static unsigned char uart_rx_buffer[16];  // 环形缓冲区所指向的数组
    

  2. static ringbuffer_t uart_rx_ringbuffer;   // 环形缓冲区句柄
    

  3. ​
    

  4. USART_Config_T usartConfigStruct;
    

  5. ​
    

  6. /* USART configuration */
    

  7. USART_ConfigStructInit(&usartConfigStruct);
    

  8. usartConfigStruct.baudRate      = 115200;
    

  9. usartConfigStruct.mode          = USART_MODE_TX_RX;
    

  10. usartConfigStruct.parity        = USART_PARITY_NONE;
    

  11. usartConfigStruct.stopBits      = USART_STOP_BIT_1;
    

  12. usartConfigStruct.wordLength    = USART_WORD_LEN_8B;
    

  13. usartConfigStruct.hardwareFlow  = USART_HARDWARE_FLOW_NONE;
    

  14. ​
    

  15. /* COM1 init*/
    

  16. APM_COMInit(COM1, &usartConfigStruct);
    

  17. ​
    

  18. /* Enable USART1 RXBNE interrput */
    

  19. USART_EnableInterrupt(USART1, USART_INT_RXBNE);
    

  20. USART_ClearStatusFlag(USART1, USART_FLAG_RXBNE);
    

  21. NVIC_EnableIRQRequest(USART1_IRQn,1,0);
    

  22. ​
    

  23. // systick delay init
    

  24. delay_init();
    

  25. ​
    

  26. /* 初始化ringbuffer，使得ringbuffer指向用户提供的数组 */
    

  27. ringbuffer_init(&uart_rx_ringbuffer, uart_rx_buffer, sizeof(uart_rx_buffer));

​3.3 串口中断接收数据

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

复制
  1. void USART1_IRQHandler(void)
    

  2. {
    

  3.     int ch = -1;
    

  4. ​
    

  5.     if ((USART_ReadStatusFlag(USART1, USART_FLAG_RXBNE) != RESET) &&
    

  6.         (USART_ReadIntFlag(USART1, USART_INT_RXBNE) != RESET))
    

  7.     {
    

  8.         while (1)
    

  9.         {
    

  10.             ch = -1;
    

  11.             if (USART_ReadStatusFlag(USART1, USART_FLAG_RXBNE) != RESET)
    

  12.             {
    

  13.                 ch =  USART1->DATA_B.DATA & 0xff;
    

  14.             }
    

  15.             if (ch == -1)
    

  16.             {
    

  17.                 break;
    

  18.             }
    

  19.             /* 中断接收到的数据，存入 ringbuffer */
    

  20.             ringbuffer_write(ch, &uart_rx_ringbuffer);
    

  21.         }
    

  22.     }
    

  23. }

3.4 主循环

在主循环中，循环等待环形缓冲区是否有数据可读，如果有则把数据回显给串口终端软件。并且故意插入一段时间的延时，这样进行模拟CPU在处理其他的任务，测试是否会出现数据丢包的现象。

主循环示意代码如下：

复制
  1. int main(void)
    

  2. {
    

  3.     // 此处省略串口和ringbuffer的初始化
    

  4. ​
    

  5.     while (1)
    

  6.     {
    

  7.         // 等待环形缓冲区是否有数据
    

  8.         if (ringbuffer_read(&temp, &uart_rx_ringbuffer) == 0)
    

  9.         {
    

  10.             // 环形缓冲区有数据可读，把数据回显到串口终端
    

  11.             USART_TxData(USART1, temp);
    

  12.         }
    

  13. ​
    

  14.         delay_ms(3);  // 故意插入延时，测试是否有丢包现象
    

  15.     }
    

  16. }

4. 测试结果

4.1 测试是否丢包

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

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

image-20241204212229537.png

4.2 制造丢包环境进行补充测试

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

image-20220826180336387.png

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

所以说，如果我们一次性要接收的数据量太大，或者说处理的速度太慢，为了防止数据丢包现象，最好自己评估把 ringbuffer 的大小设置大一点。理论上如果一次介绍的数据量特别大，速度特别快，那么就需要把buffer缓冲区设计的大一些。

下面附件是环形缓冲区应用的工程源码，上传以供大家参考。

APM32F4xx_SDK_V1.4_ringbuffer.zip (1006.08 KB, 下载次数: 14)









回复

收藏1 举报

打赏榜单

21小跑堂 打赏了 80.00 元 2024-12-11
理由：恭喜通过原创审核！期待您更多的原创作品~~

评论

21小跑堂
从环形缓冲区的介绍和简单实现切入，结合APM32F407的串口接收，实现对串口接收数据的缓冲接收，并测试不同情况下的表现情况。  发表于 2024-12-11 10:53

相关帖子
xionghaoyun 发表于 2024-12-14 10:13 | 显示全部楼层
下载学习
回复

收藏1 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

luobeihai Image

23

主题

101

帖子

4

粉丝
快速回复 在线客服 返回列表 返回顶部