ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 其他分享> 文章详细

环形缓冲区（ringbuffer）

2021-03-29 21:30:08  阅读：355  来源： 互联网

标签：rt index rb 环形 write ringbuffer 缓冲区


环形缓冲区（ringbuffer）

环形缓冲区是嵌入式系统中十分重要的一种数据结构，比如在串口处理中，串口中断接收数据直接往环形缓冲区丢数据，而应用可以从环形缓冲区取数据进行处理，这样数据在读取和写入的时候都可以在这个缓冲区里循环进行，程序员可以根据自己需要的数据大小来决定自己使用的缓冲区大小。

环形缓冲区，顾名思义这个缓冲区是环形的，那么何谓环形这个意思也很好理解，就是用一个指针去访问该缓冲区的最后一个内存位置的的后一位置时回到环形缓冲区的起点。类似一个环一样

在此之前，我们来回顾一下队列的基本概念：队列 (Queue)：是一种先进先出(First In First Out ,简称 FIFO)的线性表，只允许在一端插入（入队），在另一端进行删除（出队）。

环形缓冲区是队列的一个应用，环形缓冲区（环形队列）的实现：在计算机中，也是没有环形的内存的，只不过是我们将顺序的内存处理过，让某一段内存形成环形，使他们首尾相连，简单来说，这其实就是一个数组，只不过有两个指针，一个指向列队头，一个指向列队尾。指向列队头的指针(Head)是缓冲区可读的数据，指向列队尾的指针(Tail)是缓冲区可写的数据，通过移动这两个指针(Head) &(Tail)即可对缓冲区的数据进行读写操作了，直到缓冲区已满（头尾相接），将数据处理完，可以释放掉数据，又可以进行存储新的数据了。

 

                                                                

下面是环形缓冲区的一些数据结构定义

1.环形缓冲区控制块定义

/* 环形缓冲区控制块 */
struct rt_ringbuffer
{
    rt_uint8_t *buffer_ptr;			//缓冲区指针
    rt_uint16_t read_mirror : 1;	//读取镜像
    rt_uint16_t read_index : 15;	//读取位置
    rt_uint16_t write_mirror : 1;	//写入位置
    rt_uint16_t write_index : 15;	//写入位置
    rt_int16_t buffer_size;			//缓冲区大小
};

2.环形缓冲区状态定义

/* 环形缓冲区状态 */
enum rt_ringbuffer_state
{
    RT_RINGBUFFER_EMPTY,			//环形缓冲区空	
    RT_RINGBUFFER_FULL,				//环形缓冲区满
    RT_RINGBUFFER_HALFFULL,			//环形缓冲区半满
};

环形缓冲区实现方式

1.初始化环形缓冲区，使用静态环形缓冲区前，需要调用该函数进行初始化。该函数将把用户指定的缓冲区空间的指针传递给环形缓冲区控制块，并初始化环形缓冲区控制块的参数。

参数 ：

rb ringbuffer 环形缓冲区句柄

pool 缓冲区指针

size 缓冲区大小 

void rt_ringbuffer_init(struct rt_ringbuffer *rb,
                        rt_uint8_t           *pool,
                        rt_int16_t            size)
{
   
    /* 初始化读写位置及读写镜像 */
    rb->read_mirror = rb->read_index = 0;
    rb->write_mirror = rb->write_index = 0;

    /* 缓冲区空间及大小初始化赋值 */
    rb->buffer_ptr = pool;
    rb->buffer_size = RT_ALIGN_DOWN(size, RT_ALIGN_SIZE);
}

2.往环形缓冲区中写入数据，调用此函数可以往指定环形缓冲区中写入指定长度的数据，如果剩余空间不足将丢弃剩余数据。

参数：

 rb ringbuffer 环形缓冲区句柄

ptr 待写入数据的指针

length 待写入数据的大小，如果 length 大于剩余空间将丢弃剩余的数据 

返回：实际写入字节数。

rt_size_t rt_ringbuffer_put(struct rt_ringbuffer *rb,
                            const rt_uint8_t     *ptr,
                            rt_uint16_t           length)
{
    rt_uint16_t size;

    /* 获取环形缓冲区剩余空间 */
    size = rt_ringbuffer_space_len(rb);

    /* 写入有效长度数据，超过长度则丢弃 */
    if (size < length)
        length = size;

	/* 缓冲区尾部还能存储写入数据长度数据 */
    if (rb->buffer_size - rb->write_index > length)
    {
        /* 将写入数据拷贝到环形缓冲区中 
		 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+
		 * | 0 | 1 |   |   |   |   |   |   |   |   |   |   |   |   |
		 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+
		 *			write_index
		 */
        memcpy(&rb->buffer_ptr[rb->write_index], ptr, length);
        rb->write_index += length;
        return length;
    }
	/* 将写入数据拷贝到环形缓冲区中,需要分成两段计算 
	 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+
	 * |   |   |   | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |   |   |   |
	 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+
	 *			                                    write_index
	 */
    memcpy(&rb->buffer_ptr[rb->write_index],
           &ptr[0],
           rb->buffer_size - rb->write_index);
    memcpy(&rb->buffer_ptr[0],
           &ptr[rb->buffer_size - rb->write_index],
           length - (rb->buffer_size - rb->write_index));

    /* 写入镜像翻转 */
    rb->write_mirror = ~rb->write_mirror;
    rb->write_index = length - (rb->buffer_size - rb->write_index);

    return length;
}

3.往环形缓冲区中强制压入数据，调用此函数可以往指定环形缓冲区中强制写入指定长度的数据，如果剩余空间不足将覆盖原有数据。

参数 ：

rb ringbuffer 环形缓冲区句柄

ptr 待压入数据的指针 length 待压入数据的大小，如果 length 大于剩余空间将丢弃剩余的数据

返回 ：实际写入字节数。

rt_size_t rt_ringbuffer_put_force(struct rt_ringbuffer *rb,
                                  const rt_uint8_t     *ptr,
                                  rt_uint16_t           length)
{
    rt_uint16_t space_length;

	/* 获取环形缓冲区剩余空间 */
    space_length = rt_ringbuffer_space_len(rb);

    if (length > rb->buffer_size)
    {
        ptr = &ptr[length - rb->buffer_size];
        length = rb->buffer_size;
    }

    if (rb->buffer_size - rb->write_index > length)
    {
        /* 将写入数据拷贝到环形缓冲区中 
		 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+
		 * | 0 | 1 |   |   |   |   |   |   |   |   |   |   |   |   |
		 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+
		 *			write_index
		 */
        memcpy(&rb->buffer_ptr[rb->write_index], ptr, length);
        /* this should not cause overflow because there is enough space for
         * length of data in current mirror */
        rb->write_index += length;

        if (length > space_length)
            rb->read_index = rb->write_index;

        return length;
    }
	/* 将写入数据拷贝到环形缓冲区中 
	 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+
	 * |   |   |   | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |   |   |   |
	 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+
	 *			                                    write_index
	 */
    memcpy(&rb->buffer_ptr[rb->write_index],
           &ptr[0],
           rb->buffer_size - rb->write_index);
    memcpy(&rb->buffer_ptr[0],
           &ptr[rb->buffer_size - rb->write_index],
           length - (rb->buffer_size - rb->write_index));

	/* 写入镜像翻转 */
    rb->write_mirror = ~rb->write_mirror;
    rb->write_index = length - (rb->buffer_size - rb->write_index);

    if (length > space_length)
    {
        rb->read_mirror = ~rb->read_mirror;
        rb->read_index = rb->write_index;
    }

    return length;
}

4.从环形缓冲区中取出数据，调用此函数可以从环形缓冲区中读取指定长度的数据。

参数 ：

rb ringbuffer 环形缓冲区句柄

ptr 取出数据的写入地址 length 待取出数据的大小

返回 ：实际取出数据的字节数

rt_size_t rt_ringbuffer_get(struct rt_ringbuffer *rb,
                            rt_uint8_t           *ptr,
                            rt_uint16_t           length)
{
    rt_size_t size;

    RT_ASSERT(rb != RT_NULL);

    /* 获取环形缓冲区中数据长度 */
    size = rt_ringbuffer_data_len(rb);

	/* 拷贝环形缓冲区中数据  */
    if (rb->buffer_size - rb->read_index > length)
    {
		 /* 从环形缓冲区中读取数据
		 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+
		 * | 0 | 1 | 2 | 3 |   |   |   |   |   |   |   |   |   |   |
		 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+
		 *  read_index
		 */
        memcpy(ptr, &rb->buffer_ptr[rb->read_index], length);
        rb->read_index += length;
        return length;
    }
	/* 从环形缓冲区中读取数据 
	 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+
	 * | 0 | 1 | 2 |   |   |   |   |   |   |   |   | 3 | 4 | 5 |
	 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+
	 *			                                    read_index
	 */
    memcpy(&ptr[0],
           &rb->buffer_ptr[rb->read_index],
           rb->buffer_size - rb->read_index);
    memcpy(&ptr[rb->buffer_size - rb->read_index],
           &rb->buffer_ptr[0],
           length - (rb->buffer_size - rb->read_index));

    /* 读取镜像翻转 */
    rb->read_mirror = ~rb->read_mirror;
    rb->read_index = length - (rb->buffer_size - rb->read_index);

    return length;
}

5.往环形缓冲区中写入一个字节，调用此函数可以往指定环形缓冲区中写入一个字节的数据，如果剩余空间不足将写入失败。

参数：

rb ringbuffer 环形缓冲区句柄

ch 待写入数据

返回 ：写入成功返回1；环形缓冲区已满，写入失败则返回0。

rt_size_t rt_ringbuffer_putchar(struct rt_ringbuffer *rb, const rt_uint8_t ch)
{


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

    if (rb->write_index == rb->buffer_size - 1)
    {
        rb->write_mirror = ~rb->write_mirror;
        rb->write_index = 0;
    }
    else
    {
        rb->write_index++;
    }

    return 1;
}

6.往环形缓冲区中强制写入一个字节，调用此函数可以往指定环形缓冲区中强制写入一个字节的数据，如果剩余空间不足将覆盖原有数据。

参数 ：

rb ringbuffer 环形缓冲区句柄

ch 待写入数据

返回 ：写入成功返回1，如果缓冲区已满将覆盖已有数据

rt_size_t rt_ringbuffer_putchar_force(struct rt_ringbuffer *rb, const rt_uint8_t ch)
{
    enum rt_ringbuffer_state old_state;

   

    old_state = rt_ringbuffer_status(rb);

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


    if (rb->write_index == rb->buffer_size - 1)
    {
        rb->write_mirror = ~rb->write_mirror;
        rb->write_index = 0;
        if (old_state == RT_RINGBUFFER_FULL)
        {
            rb->read_mirror = ~rb->read_mirror;
            rb->read_index = rb->write_index;
        }
    }
    else
    {
        rb->write_index++;
        if (old_state == RT_RINGBUFFER_FULL)
            rb->read_index = rb->write_index;
    }

    return 1;
}

7.从环形缓冲区中取出一个字节的数据，调用此函数可以从环形缓冲区中读取一个字节的数据。

参数：

rb ringbuffer 环形缓冲区句柄

ch 存储待取出字节的变量

返回 ：0 环形缓冲区已空，取出失败；1 成功取出

rt_size_t rt_ringbuffer_getchar(struct rt_ringbuffer *rb, rt_uint8_t *ch)
{
    RT_ASSERT(rb != RT_NULL);

    /* ringbuffer is empty */
    if (!rt_ringbuffer_data_len(rb))
        return 0;

    /* put character */
    *ch = rb->buffer_ptr[rb->read_index];

    if (rb->read_index == rb->buffer_size - 1)
    {
        rb->read_mirror = ~rb->read_mirror;
        rb->read_index = 0;
    }
    else
    {
        rb->read_index++;
    }

    return 1;
}

8.获取环形缓冲区中已使用的空间大小，调用此函数可以获取环形缓冲区中已被使用的字节数。

参数： rb 环形缓冲区句柄

返回 ：已使用的大小；0 则表示环形缓冲区已空

rt_size_t rt_ringbuffer_data_len(struct rt_ringbuffer *rb)
{
    switch (rt_ringbuffer_status(rb))
    {
        case RT_RINGBUFFER_EMPTY:
            return 0;
        case RT_RINGBUFFER_FULL:
            return rb->buffer_size;
        case RT_RINGBUFFER_HALFFULL:
        default:
            if (rb->write_index > rb->read_index)
                return rb->write_index - rb->read_index;
            else
                return rb->buffer_size - (rb->read_index - rb->write_index);
    };
}

9.复位环形缓冲区，调用此函数将复位环形缓冲区，环形缓冲区控制块中的读写指针被置0。

参数 ：rb ringbuffer 环形缓冲区句柄

void rt_ringbuffer_reset(struct rt_ringbuffer *rb)
{
    RT_ASSERT(rb != RT_NULL);

    rb->read_mirror = 0;
    rb->read_index = 0;
    rb->write_mirror = 0;
    rb->write_index = 0;
}

10.创建环形缓冲区对象，调用该函数将释放缓冲区和唤醒缓冲区控制块所占的内存空间。

参数 ：size 环形缓冲区大小

struct rt_ringbuffer *rt_ringbuffer_create(rt_uint16_t size)
{
    struct rt_ringbuffer *rb;
    rt_uint8_t *pool;


	/* 申请环形缓冲区对象*/
    size = RT_ALIGN_DOWN(size, RT_ALIGN_SIZE);

    rb = (struct rt_ringbuffer *)rt_malloc(sizeof(struct rt_ringbuffer));
    if (rb == RT_NULL)
        goto exit;
	/* 申请环形缓冲区空间 */
    pool = (rt_uint8_t *)rt_malloc(size);
    if (pool == RT_NULL)
    {
        rt_free(rb);
        rb = RT_NULL;
        goto exit;
    }
	/* 初始化环形缓冲区 */
    rt_ringbuffer_init(rb, pool, size);

exit:
    return rb;
}

11.销毁环形缓冲区，调用该函数将释放缓冲区和唤醒缓冲区控制块所占的内存空间。

参数 ：rb ringbuffer 环形缓冲区句柄

void rt_ringbuffer_destroy(struct rt_ringbuffer *rb)
{
    RT_ASSERT(rb != RT_NULL);

    rt_free(rb->buffer_ptr);
    rt_free(rb);
}

 

 

标签：rt,index,rb,环形,write,ringbuffer,缓冲区
来源： https://blog.csdn.net/loveliu928/article/details/115311136

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有