【嵌入式基础】环形缓冲区ring buffer

已于 2024-05-16 21:48:01 修改
阅读量639 收藏 29
点赞数 14
分类专栏： 嵌入式基础 文章标签： 嵌入式 环形队列 ring buffer
于 2024-05-12 11:22:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36056498/article/details/138749863
版权

目录

1.概述

2. 原理

3. 使用场景

4. 实践

4.1 Github搜索

4.2 编写makefile

4.3 编译运行

5.总结

1.概述

ring buffer称作环形缓冲区，也称作环形队列（circular queue），是一种用于表示一个固定尺寸、头尾相连的缓冲区的数据结构，适合缓存数据流。如下为环形缓冲区（ring buffer） 的概念示意图。

在任务间的通信、串口数据收发、log缓存、网卡处理网络数据包、音频/视频流处理中均有环形缓冲区（ring buffer） 的应用。在RT-Thread的ringbuffer.c和ringbuffer.h文件中，Linux内核文件kfifo.h和kfifo.c中也有环形缓冲区（ring buffer）的代码实现。

图片

环形缓冲区的一些使用特点如下：

  • 当一个数据元素被读取出后，其余数据元素不需要移动其存储位置；

  • 适合于事先明确了缓冲区的最大容量的情形。缓冲区的容量（长度）一般固定，可以用一个静态数组来充当缓冲区，无需重复申请内存；

  • 如果缓冲区的大小需要经常调整，就不适合用环形缓冲区，因为在扩展缓冲区大小时，需要搬移其中的数据，这种场合使用链表更加合适；

  • 因为缓冲区成头尾相连的环形，写操作可能会覆盖未及时读取的数据，有的场景允许这种情况发生，有的场景又严格限制这种情况发生。选择何种策略和具体应用场景相关。

2. 原理

站在巨人的肩膀上，有文章已经介绍的很好了，参考文章：

https://zhuanlan.zhihu.com/p/534098236

3. 使用场景

只要出现数据生产者和的可能速度快于数据消费者场景，就需要使用缓存buffer. 比如在汽车ECU控制器中（如座舱域控制器）MCU和SOC之间的通信（如MCU收到CAN数据，根据情况上传给SOC）肯定需要使用缓存buffer, 这个buffer还需要具有先进行出的特性，那么就需要ring buffer.

4. 实践

如果是学习的话，我们当然可以从0到1自己写一个，这样更加能锻炼我们的代码能力。如果是项目着急使用的话，我们首先考虑站在巨人的肩膀上看有没有开源现成的可以参考。

4.1 Github搜索

github上搜索ringbuffer, 找一个star数相对比较高的项目。

图片

读下项目的README

图片

项目在实际硬件平台上使用过，且有相关的测试代码，但是没有makefile，我们需要编写一个makefile来测试下。

Github链接：https://github.com/netube99/RingBuffer

4.2 编写makefile

makefile参考本公众号的系类文章：

编译链接专题第7篇-变量的高级主题（下）

#makefile
COMPILER := gcc
TARGET := ringbuffer.exe
OBJS := ring_buffer.o ring_buffer_chapter.o main.o
RM := del

$(TARGET) : $(OBJS)
  $(COMPILER) -o $@ $^
    
$(OBJS) : %.o : %.c
  $(COMPILER) -o $@ -c $^
    
.PHONY : rebuild clean all

rebuild : clean all

all : $(TARGET)  
  
clean :
  $(RM) *o $(TARGET)

测试代码：

//引用相关头文件
#include <stdint.h>
#include <stdio.h>
#include "ring_buffer.h"

//创建一个数组作为数据存储空间
#define BUFFER_SIZE 128
static uint8_t buffer[BUFFER_SIZE];

//创建环形缓冲区句柄
static ring_buffer rb;

int main(void)
{
    //初始化环形缓冲区参数
    RB_Init(&rb, buffer, BUFFER_SIZE);

    //写入向环形缓冲区写入数据
    RB_Write_String(&rb, "hello world", 11);
    RB_Write_Byte(&rb, '!');
    RB_Write_Byte(&rb, 0x00);

    //删除环形缓冲区部分数据
    RB_Delete(&rb, 2);

    //获取已储存的数据长度
    uint32_t num = RB_Get_Length(&rb);

    //读出环形缓冲区中的数据并打印
    uint8_t get[16];
    RB_Read_String(&rb, get, num);
    printf("%s", get);
    
    //控制台输出内容
    //llo world!
    return 0;
}

4.3 编译运行

编译这个开源项目，生成可执行文件ringbuffer.exe

图片

执行ringbuffer.exe，结果符合测试代码的预期。

5.总结

本文没有详细赘述ringbuffer的原理（参考文章中有详细介绍），着重介绍了项目中需要使用ringbuffer的场景，同时介绍了实际工程中如何从github中获取开源项目并编译运行起来。

ringbuffer的源码如下：

ring_buffer.h


/**
 * \file ring_buffer.h
 * \brief 简易环形缓冲相关定义与声明
 * \author netube_99\netube@163.com
 * \date 2022.08.20
 * \version v0.4.0
*/
#ifndef _RING_BUFFER_H_
#define _RING_BUFFER_H_

//返回值定义
#define RING_BUFFER_SUCCESS     0x01
#define RING_BUFFER_ERROR       0x00

//环形缓冲区结构体
typedef struct
{
    uint32_t head ;             //操作头指针
    uint32_t tail ;             //操作尾指针
    uint32_t Length ;           //已储存的数据量
    uint8_t *array_addr ;       //缓冲区储存数组基地址
    uint32_t max_Length ;       //缓冲区最大可储存数据量
}ring_buffer;

uint8_t RB_Init(ring_buffer *rb_handle, uint8_t *buffer_addr ,uint32_t buffer_size);               //初始化基础环形缓冲区
uint8_t RB_Delete(ring_buffer *rb_handle, uint32_t Length);                                        //从头指针开始删除指定长度的数据
uint8_t RB_Write_Byte(ring_buffer *rb_handle, uint8_t data);                                       //向缓冲区尾指针写一个字节
uint8_t RB_Write_String(ring_buffer *rb_handle, uint8_t *input_addr, uint32_t write_Length);       //向缓冲区尾指针写指定长度数据
uint8_t RB_Read_Byte(ring_buffer *rb_handle, uint8_t *output_addr);                                //从缓冲区头指针读一个字节
uint8_t RB_Read_String(ring_buffer *rb_handle, uint8_t *output_addr, uint32_t read_Length);        //从缓冲区头指针读指定长度数据
uint32_t RB_Get_Length(ring_buffer *rb_handle);                                                    //获取缓冲区里已储存的数据长度
uint32_t RB_Get_FreeSize(ring_buffer *rb_handle);                                                  //获取缓冲区可用储存空间

#endif//#ifndef _RING_BUFFER_H_

ring_buffer.c


/**
 * \file ring_buffer.c
 * \brief 简易环形缓冲的实现
 * \author netube_99\netube@163.com
 * \date 2022.08.20
 * \version v0.4.0
*/

#include <stdint.h>
#include <string.h>
#include "ring_buffer.h"

/**
 * \brief 初始化新缓冲区
 * \param[out] rb_handle: 待初始化的缓冲区结构体句柄
 * \param[in] buffer_addr: 外部定义的缓冲区数组，类型必须为 uint8_t
 * \param[in] buffer_size: 外部定义的缓冲区数组空间
 * \return 返回缓冲区初始化的结果
 *      \arg RING_BUFFER_SUCCESS: 初始化成功
 *      \arg RING_BUFFER_ERROR: 初始化失败
*/
uint8_t RB_Init(ring_buffer *rb_handle, uint8_t *buffer_addr ,uint32_t buffer_size)
{
    //缓冲区数组空间必须大于2且小于数据类型最大值
    if(buffer_size < 2 || buffer_size == 0xFFFFFFFF)
        return RING_BUFFER_ERROR ; //初始化失败
    rb_handle->head = 0 ; //复位头指针
    rb_handle->tail = 0 ; //复位尾指针
    rb_handle->Length = 0 ; //复位已存储数据长度
    rb_handle->array_addr = buffer_addr ; //缓冲区储存数组基地址
    rb_handle->max_Length = buffer_size ; //缓冲区最大可储存数据量
    return RING_BUFFER_SUCCESS ; //缓冲区初始化成功
}

/**
 * \brief 从头指针开始删除指定长度的数据
 * \param[out] rb_handle: 缓冲区结构体句柄
 * \param[in] Length: 要删除的长度
 * \return 返回删除指定长度数据结果
 *      \arg RING_BUFFER_SUCCESS: 删除成功
 *      \arg RING_BUFFER_ERROR: 删除失败
*/
uint8_t RB_Delete(ring_buffer *rb_handle, uint32_t Length)
{
    if(rb_handle->Length < Length)
        return RING_BUFFER_ERROR ;//已储存的数据量小于需删除的数据量
    else
    {
        if((rb_handle->head + Length) >= rb_handle->max_Length)
            rb_handle->head = Length - (rb_handle->max_Length - rb_handle->head);
        else
            rb_handle->head += Length ;    //头指针向前推进，抛弃数据
        rb_handle->Length -= Length ;      //重新记录有效数据长度
        return RING_BUFFER_SUCCESS ;//已储存的数据量小于需删除的数据量
    }
}

/**
 * \brief 向缓冲区尾部写一个字节
 * \param[out] rb_handle: 缓冲区结构体句柄
 * \param[in] data: 要写入的字节
 * \return 返回缓冲区写字节的结果
 *      \arg RING_BUFFER_SUCCESS: 写入成功
 *      \arg RING_BUFFER_ERROR: 写入失败
*/
uint8_t RB_Write_Byte(ring_buffer *rb_handle, uint8_t data)
{
    //缓冲区数组已满，产生覆盖错误
    if(rb_handle->Length == (rb_handle->max_Length))
        return RING_BUFFER_ERROR ;
    else
    {
        *(rb_handle->array_addr + rb_handle->tail) = data;//基地址+偏移量，存放数据
        rb_handle->Length ++ ;//数据量计数+1
        rb_handle->tail ++ ;//尾指针后移
    }
    //如果尾指针超越了数组末尾，尾指针指向缓冲区数组开头，形成闭环
    if(rb_handle->tail > (rb_handle->max_Length - 1))
        rb_handle->tail = 0 ;
  return RING_BUFFER_SUCCESS ;
}

/**
 * \brief 从缓冲区头指针读取一个字节
 * \param[out] rb_handle: 缓冲区结构体句柄
 * \param[out] output_addr: 读取的字节保存地址
 * \return 返回读取状态
 *      \arg RING_BUFFER_SUCCESS: 读取成功
 *      \arg RING_BUFFER_ERROR: 读取失败
*/
uint8_t RB_Read_Byte(ring_buffer *rb_handle, uint8_t *output_addr)
{
    if (rb_handle->Length != 0)//有数据未读出
    {
        *output_addr = *(rb_handle->array_addr + rb_handle->head);//读取数据
        rb_handle->head ++ ;
        rb_handle->Length -- ;//数据量计数-1
        //如果头指针超越了数组末尾，头指针指向数组开头，形成闭环
        if(rb_handle->head > (rb_handle->max_Length - 1))
            rb_handle->head = 0 ;
        return RING_BUFFER_SUCCESS ;
    }
    return RING_BUFFER_ERROR ;
}

/**
 * \brief 向缓冲区尾部写指定长度的数据
 * \param[out] rb_handle: 缓冲区结构体句柄
 * \param[out] input_addr: 待写入数据的基地址
 * \param[in] write_Length: 要写入的字节数
 * \return 返回缓冲区尾部写指定长度字节的结果
 *      \arg RING_BUFFER_SUCCESS: 写入成功
 *      \arg RING_BUFFER_ERROR: 写入失败
*/
uint8_t RB_Write_String(ring_buffer *rb_handle, uint8_t *input_addr, uint32_t write_Length)
{
    //如果不够存储空间存放新数据,返回错误
    if((rb_handle->Length + write_Length) > (rb_handle->max_Length))
        return RING_BUFFER_ERROR ;
    else
    {
        //设置两次写入长度
        uint32_t write_size_a, write_size_b ;
        //如果顺序可用长度小于需写入的长度，需要将数据拆成两次分别写入
        if((rb_handle->max_Length - rb_handle->tail) < write_Length)
        {
            write_size_a = rb_handle->max_Length - rb_handle->tail ;//从尾指针开始写到储存数组末尾
            write_size_b = write_Length - write_size_a ;//从储存数组开头写数据
            //分别拷贝a、b段数据到储存数组中
            memcpy(rb_handle->array_addr + rb_handle->tail, input_addr, write_size_a);
            memcpy(rb_handle->array_addr, input_addr + write_size_a, write_size_b);
            rb_handle->Length += write_Length ;//记录新存储了多少数据量
            rb_handle->tail = write_size_b ;//重新定位尾指针位置
        }
        else//如果顺序可用长度大于或等于需写入的长度，则只需要写入一次
        {
            write_size_a = write_Length ;//从尾指针开始写到储存数组末尾
            memcpy(rb_handle->array_addr + rb_handle->tail, input_addr, write_size_a);
            rb_handle->Length += write_Length ;//记录新存储了多少数据量
            rb_handle->tail += write_size_a ;//重新定位尾指针位置
            if(rb_handle->tail == rb_handle->max_Length)
                rb_handle->tail = 0 ;//如果写入数据后尾指针刚好写到数组尾部，则回到开头，防止越位
        }
        return RING_BUFFER_SUCCESS ;
    }
}

/**
 * \brief 从缓冲区头部读指定长度的数据，保存到指定的地址
 * \param[out] rb_handle: 缓冲区结构体句柄
 * \param[out] output_addr: 读取的数据保存地址
 * \param[in] read_Length: 要读取的字节数
 * \return 返回缓冲区头部读指定长度字节的结果
 *      \arg RING_BUFFER_SUCCESS: 读取成功
 *      \arg RING_BUFFER_ERROR: 读取失败
*/
uint8_t RB_Read_String(ring_buffer *rb_handle, uint8_t *output_addr, uint32_t read_Length)
{
    if(read_Length > rb_handle->Length)
        return RING_BUFFER_ERROR ;
    else
    {
        uint32_t Read_size_a, Read_size_b ;
        if(read_Length > (rb_handle->max_Length - rb_handle->head))
        {
            Read_size_a = rb_handle->max_Length - rb_handle->head ;
            Read_size_b = read_Length - Read_size_a ;
            memcpy(output_addr, rb_handle->array_addr + rb_handle->head, Read_size_a);
            memcpy(output_addr + Read_size_a, rb_handle->array_addr, Read_size_b);
            rb_handle->Length -= read_Length ;//记录剩余数据量
            rb_handle->head = Read_size_b ;//重新定位头指针位置
        }
        else
        {
            Read_size_a = read_Length ;
            memcpy(output_addr, rb_handle->array_addr + rb_handle->head, Read_size_a);
            rb_handle->Length -= read_Length ;//记录剩余数据量
            rb_handle->head += Read_size_a ;//重新定位头指针位置
            if(rb_handle->head == rb_handle->max_Length)
                rb_handle->head = 0 ;//如果读取数据后头指针刚好写到数组尾部，则回到开头，防止越位
        }
        return RING_BUFFER_SUCCESS ;
    }
}

/**
 * \brief 获取缓冲区里已储存的数据长度
 * \param[in] rb_handle: 缓冲区结构体句柄
 * \return 返回缓冲区里已储存的数据长度
*/
uint32_t RB_Get_Length(ring_buffer *rb_handle)
{
    return rb_handle->Length ;
}

/**
 * \brief 获取缓冲区可用储存空间
 * \param[in] rb_handle: 缓冲区结构体句柄
 * \return 返回缓冲区可用储存空间
*/
uint32_t RB_Get_FreeSize(ring_buffer *rb_handle)
{
    return (rb_handle->max_Length - rb_handle->Length) ;
}

main.c和makefile文件见前文。

汽车电子嵌入式
关注
  • 14
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
一种为嵌入式系统设计的简单环形缓冲区(环形缓冲区)。- AndersKaloer /环缓冲区
01-27
一种为嵌入式系统设计的简单环形缓冲区(环形缓冲区)。- AndersKaloer /环缓冲区-源码
基于STM32FxUART数据传输环形缓冲区实现
05-08
该工程包含了整个实现代码，并添加了注释，提供了软件计时器多任务创建及调度接口函数，以及环形缓冲区完整接口函数。
环形缓冲区（ringbuffer）
loveliu928的博客
03-29 1万+
环形缓冲区（ringbuffer） 环形缓冲区是嵌入式系统中十分重要的一种数据结构，比如在串口处理中，串口中断接收数据直接往环形缓冲区丢数据，而应用可以从环形缓冲区取数据进行处理，这样数据在读取和写入的时候都可以在这个缓冲区里循环进行，程序员可以根据自己需要的数据大小来决定自己使用的缓冲区大小。 环形缓冲区，顾名思义这个缓冲区是环形的，那么何谓环形这个意思也很好理解，就是用一个指针去访问该缓冲区的最后一个内存位置的的后一位置时回到环形缓冲区的起点。类似一个环一样 在此之前，我们来回顾一下队列的基本概念
网卡的ring buffer调整
热门推荐
badman250的专栏
12-10 4万+
【互联网后台技术】网卡的ring buffer调整  (2011-10-13 13:57:43) 转载▼ 标签：  网卡   ringbuffer   it 分类： 互联网运维技术 服务器的NIC(eth0)上的RX dropped数量一直在增多时可以考虑试着调整ring busffer看看效果
环形缓冲区【转】
08-01 338
本文转载自：http://blog.csdn.net/u013904227/article/details/51168398 1、什么是环形缓冲区 环形缓冲区，顾名思义就是一个环状的存储数据的区域，其空间使用数组进行构造（链表也可以）。环形缓冲区特点是读和写可以是分开的，写入数据之后可以先不去读取，等到需要读取的时候再去读取，并且数据一经读取之后下次就不能再去读取（当然也可以实现...
数据结构-环形缓冲区 ring buffer
chuanpeng0130的专栏
01-08 434
环形缓冲区（Circular Buffer），也称为循环缓冲区或环形队列，是一种常见的数据结构，通常用于在计算机科学和嵌入式系统中实现数据的循环存储。环形缓冲区的特点是固定大小的缓冲区，在缓冲区的尾部写入新数据时，如果到达缓冲区的末尾，则会绕回到缓冲区的开头，形成一个循环。以下是一个简单的环形缓冲区的例子，使用C语言实现。环形缓冲区的概念常常用于实现循环队列，例如，在计算机网络中，可以使用环形缓冲区来管理数据包的接收和发送。当缓冲区的尾部到达物理存储的末尾时，新的数据将从缓冲区的开头重新开始，形成循环。
环形缓冲区（Ring Buffer）使用说明
爬坡的小蜗牛的博客
07-22 5342
源码功能包含：实现环形缓冲区的初始函数；实现环形缓冲区是否为空、是否满功能；实现环形缓冲区读写功能。
环形缓冲区ringbuffer c++类模版实现
小段孩
12-23 2672
@ringbuffer 环形缓冲区ringbuffer c++类模版实现 使用方法： 1、将ringBuffer.h文件拷贝到开发工程中，添加相应的头文件 2、需要g++编译器（开发的项目工程需要支持），编译此类模版 3、支持int、char、bool等类型 #pragma once #include &amp;amp;amp;amp;amp;quot;stdlib.h&amp;amp;amp;amp;amp;quot; #include &amp;amp
RingBuffer 环形缓冲区----镜像指示位
呵呵哒!的博客
08-19 797
称作环形缓冲区，也称作环形队列（circular queue），是一种用于表示一个固定尺寸、头尾相连的缓冲区的数据结构，适合缓存数据流。这个宏定义用于计算向下对齐的地址。size和align。size是要对齐的内存大小，align是所需的对齐大小。这个宏返回一个值，该值是size向下对齐到align边界后的地址。例如，假设我们有一个 32 位的系统，并且我们需要将数据对齐到 64 位的边界。我们可以使用在这个例子中，data数组的大小为 10 个元素，我们需要将其对齐到 8 字节边界。宏返回data。
嵌入式C基础——循环队列 ringbuffer 讲解
weixin_37620587的博客
04-06 1168
ringbuffer的原理讲解以及rtos例子，还有实际举例
基于CAN网络的嵌入式软PLC系统环形缓冲研究
05-23
为降低嵌入式软PLC系统传输数据的误码率和丢包率,设计了嵌入式软PLC系统的环形缓冲区,建立了环形缓冲区数学模型,分析得到了环形缓冲区的状态方程、状态转移概率及其容量和被充满的概率通式。利用仿真得到不同条件下...
电子-stm32f10xdemo环形缓冲区.rar
09-05
电子-stm32f10xdemo环形缓冲区.rar,单片机/嵌入式STM32-F0/F1/F2
stm32f103实现ringbuffer
01-21
使用环形缓冲区接收串口接收数据
嵌入式进阶——数码管2
qiuyeyyy的博客
05-26 567
⛺️心若有所向往,何惧道阻且长。
ESP32-C6构建Matter Wi-Fi和Thread终端设备的利器，启明云端乐鑫代理商
wireless_tag的博客
05-27 241
ESP32-C6 借助Wi-Fi 6的特性，为物联网设备提供了更高的传输效率和更低的功耗。ESP32-C6是首款支持Wi-Fi 6的SoC，集成2.4 GHz Wi-Fi 6、Bluetooth 5 (LE) 和 802.15.4 协议，能够为物联网产品提供行业领先的射频性能、完善的安全机制和丰富的内存资源。随着物联网技术的飞速发展，越来越多的智能设备开始融入我们的日常生活。随着ESP32-C6的推出，我们有理由相信，物联网设备的性能将得到进一步提升，而功耗的降低也将使得更多设备能够实现长时间的稳定运行。
stm32的BOOT0和BOOT1管脚总结
最新发布
sdkdslx的博客
05-27 144
3）系统存储器 = 芯片内部一块特定的区域，芯片出厂时在这个区域预置了一段Bootloader，就是通常说的ISP程序。BOOT1=0 BOOT0=1 从系统存储器启动，这种模式启动的程序功能由厂家设置。BOOT1=1 BOOT0=1 从内置SRAM启动，这种模式可以用于调试。BOOT1=x BOOT0=0 从用户闪存启动，这是正常的工作模式。域的内容在芯片出厂后没有人能够修改或擦除，即它是一个ROM区。2）SRAM = 芯片内置的RAM区，就是内存啦。
嵌入式学习——进线程（进程的创建和结束）——day24
qq_47798402的博客
05-22 524
3.每个进程运行起来后,操作系统都会分配一个内存空间(虚拟地址)子进程复制父进程的0到3g空间和父进程内核中的PCB，但id号不同。2.所有进程所使用的虚拟地址空间都为同一空间(虚拟地址)克隆的进程称为子进程，原有的进程称为 父进程。2.进程:是一个程序动态执行的过程,包括创建、调度和消亡。kill -9 进程PID（9强制关闭）kill。功能：通过该函数可以从当前进程中克隆一个同名新进程。status:进程退出的状态。2.可唤醒等待态 S 睡眠态。status:进程退出状态。
全志T527芯片详解【一】：计算性能
DOT小文哥的博客
05-24 347
内置RISC-V架构MCU，主频可达200MHz独立运行RTOS系统，为工业及机器人系统上的实时处理、高速响应及工业级的稳定运行提供重要保障。内置HiFi4 DSP，频率可达600MHz，广泛应用于图像、音频及数字信号处理的专用领域为 影音娱乐、工业生产提供专属算力。内置8*ARM Cortex-A55，8核主频可运行至1.8GHz，提供更稳健强劲的处理能力。集成2Tops NPU为端侧语音、自然语言处理、图像处理及画质增强等AI应用提供性能支持。
stm32环形缓冲区
01-31
stm32环形缓冲区是一种用于数据传输和存储的数据结构。它由一段连续的内存空间组成，可分为两个部分：读指针和写指针。读指针用于读取数据，写指针用于写入数据。 环形缓冲区被设计成环形的形式，即当写指针超过缓冲区的末尾时，会自动回到缓冲区的开头。这样可以实现循环写入数据的功能。同样地，当读指针超过缓冲区的末尾时，它也会回到开头，实现循环读取数据的功能。 stm32环形缓冲区有几个重要的特点。首先，它可以高效地存储和传输大量的数据，特别适用于实时系统和数据传输要求高的应用。其次，它具有简单、高效的读写操作，可以实现快速的数据读写。第三，由于环形缓冲区的特殊设计，可以有效地解决内存溢出和数据丢失的问题。 stm32环形缓冲区在嵌入式系统中广泛应用，特别是在数据传输和存储方面。它可以用于串口通信、外设数据接收、数据采集和存储等场景。使用环形缓冲区可以提高系统的稳定性和可靠性，保证数据的完整性和准确性。 总之，stm32环形缓冲区是一种非常有用的数据结构，它在嵌入式系统中发挥着重要作用。通过合理的设计和使用，可以更好地实现数据的存储和传输，提高系统的性能和可靠性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

汽车电子嵌入式

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值