rt-thread-official/components/drivers/src/ringbuffer.c

/*
 * File      : ringbuffer.c
 * This file is part of RT-Thread RTOS
 * COPYRIGHT (C) 2012, RT-Thread Development Team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Change Logs:
 * Date           Author       Notes
 * 2012-09-30     Bernard      first version.
 * 2013-05-08     Grissiom     reimplement
 */

#include <rtthread.h>
#include <rtdevice.h>
#include <string.h>

void rt_ringbuffer_init(struct rt_ringbuffer *rb,
                        rt_uint8_t           *pool,
                        rt_int16_t            size)
{
    RT_ASSERT(rb != RT_NULL);
    RT_ASSERT(size > 0)

    /* initialize read and write index */
    rb->read_mirror = rb->read_index = 0;
    rb->write_mirror = rb->write_index = 0;

    /* set buffer pool and size */
    rb->buffer_ptr = pool;
    rb->buffer_size = RT_ALIGN_DOWN(size, RT_ALIGN_SIZE);
}
RTM_EXPORT(rt_ringbuffer_init);

/**
 * put a block of data into ring buffer
 */
rt_size_t rt_ringbuffer_put(struct rt_ringbuffer *rb,
                            const rt_uint8_t     *ptr,
                            rt_uint16_t           length)
{
    rt_uint16_t size;

    RT_ASSERT(rb != RT_NULL);

    /* whether has enough space */
    size = rt_ringbuffer_space_len(rb);

    /* no space */
    if (size == 0)
        return 0;

    /* drop some data */
    if (size < length)
        length = size;

    if (rb->buffer_size - rb->write_index > length)
    {
        /* read_index - write_index = empty space */
        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;
        return length;
    }

    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));

    /* we are going into the other side of the mirror */
    rb->write_mirror = ~rb->write_mirror;
    rb->write_index = length - (rb->buffer_size - rb->write_index);

    return length;
}
RTM_EXPORT(rt_ringbuffer_put);

/**
 * put a block of data into ring buffer
 *
 * When the buffer is full, it will discard the old data.
 */
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;

    RT_ASSERT(rb != RT_NULL);

    space_length = rt_ringbuffer_space_len(rb);

    if (length > space_length)
        length = rb->buffer_size;

    if (rb->buffer_size - rb->write_index > length)
    {
        /* read_index - write_index = empty space */
        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;
    }

    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));

    /* we are going into the other side of the mirror */
    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;
}
RTM_EXPORT(rt_ringbuffer_put_force);

/**
 *  get data from ring buffer
 */
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);

    /* whether has enough data  */
    size = rt_ringbuffer_data_len(rb);

    /* no data */
    if (size == 0)
        return 0;

    /* less data */
    if (size < length)
        length = size;

    if (rb->buffer_size - rb->read_index > length)
    {
        /* copy all of data */
        memcpy(ptr, &rb->buffer_ptr[rb->read_index], length);
        /* this should not cause overflow because there is enough space for
         * length of data in current mirror */
        rb->read_index += length;
        return length;
    }

    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));

    /* we are going into the other side of the mirror */
    rb->read_mirror = ~rb->read_mirror;
    rb->read_index = length - (rb->buffer_size - rb->read_index);

    return length;
}
RTM_EXPORT(rt_ringbuffer_get);

/**
 * put a character into ring buffer
 */
rt_size_t rt_ringbuffer_putchar(struct rt_ringbuffer *rb, const rt_uint8_t ch)
{
    RT_ASSERT(rb != RT_NULL);

    /* whether has enough space */
    if (!rt_ringbuffer_space_len(rb))
        return 0;

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

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

    return 1;
}
RTM_EXPORT(rt_ringbuffer_putchar);

/**
 * put a character into ring buffer
 *
 * When the buffer is full, it will discard one old data.
 */
rt_size_t rt_ringbuffer_putchar_force(struct rt_ringbuffer *rb, const rt_uint8_t ch)
{
    enum rt_ringbuffer_state old_state;

    RT_ASSERT(rb != RT_NULL);

    old_state = rt_ringbuffer_status(rb);

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

    /* flip mirror */
    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;
}
RTM_EXPORT(rt_ringbuffer_putchar_force);

/**
 * get a character from a ringbuffer
 */
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;
}
RTM_EXPORT(rt_ringbuffer_getchar);
fixed the coding style in the components/drivers git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2431 bbd45198-f89e-11dd-88c7-29a3b14d5316 2012-11-22 16:43:40 +08:00			`/*`
			`* File : ringbuffer.c`
			`* This file is part of RT-Thread RTOS`
			`* COPYRIGHT (C) 2012, RT-Thread Development Team`
			`*`
Embedded GPLv2 license in drivers 2013-06-28 00:36:54 +08:00			`* This program is free software; you can redistribute it and/or modify`
			`* it under the terms of the GNU General Public License as published by`
			`* the Free Software Foundation; either version 2 of the License, or`
			`* (at your option) any later version.`
			`*`
			`* This program is distributed in the hope that it will be useful,`
			`* but WITHOUT ANY WARRANTY; without even the implied warranty of`
			`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
			`* GNU General Public License for more details.`
			`*`
			`* You should have received a copy of the GNU General Public License along`
			`* with this program; if not, write to the Free Software Foundation, Inc.,`
			`* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.`
fixed the coding style in the components/drivers git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2431 bbd45198-f89e-11dd-88c7-29a3b14d5316 2012-11-22 16:43:40 +08:00			`*`
			`* Change Logs:`
			`* Date Author Notes`
			`* 2012-09-30 Bernard first version.`
ringbuffer: format the code to a more symmetric structure 2013-05-08 15:54:30 +08:00			`* 2013-05-08 Grissiom reimplement`
fixed the coding style in the components/drivers git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2431 bbd45198-f89e-11dd-88c7-29a3b14d5316 2012-11-22 16:43:40 +08:00			`*/`

			`#include <rtthread.h>`
			`#include <rtdevice.h>`
			`#include <string.h>`

			`void rt_ringbuffer_init(struct rt_ringbuffer *rb,`
			`rt_uint8_t *pool,`
reimplement ringbuffer The new implementation use the mirroring method to distinguish full buffer and the empty buffer. It also support buffers of arbitrary size. 2013-05-08 15:45:31 +08:00			`rt_int16_t size)`
fixed the coding style in the components/drivers git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2431 bbd45198-f89e-11dd-88c7-29a3b14d5316 2012-11-22 16:43:40 +08:00			`{`
			`RT_ASSERT(rb != RT_NULL);`
reimplement ringbuffer The new implementation use the mirroring method to distinguish full buffer and the empty buffer. It also support buffers of arbitrary size. 2013-05-08 15:45:31 +08:00			`RT_ASSERT(size > 0)`
fixed the coding style in the components/drivers git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2431 bbd45198-f89e-11dd-88c7-29a3b14d5316 2012-11-22 16:43:40 +08:00
			`/* initialize read and write index */`
reimplement ringbuffer The new implementation use the mirroring method to distinguish full buffer and the empty buffer. It also support buffers of arbitrary size. 2013-05-08 15:45:31 +08:00			`rb->read_mirror = rb->read_index = 0;`
			`rb->write_mirror = rb->write_index = 0;`
fixed the coding style in the components/drivers git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2431 bbd45198-f89e-11dd-88c7-29a3b14d5316 2012-11-22 16:43:40 +08:00
			`/* set buffer pool and size */`
			`rb->buffer_ptr = pool;`
			`rb->buffer_size = RT_ALIGN_DOWN(size, RT_ALIGN_SIZE);`
			`}`
			`RTM_EXPORT(rt_ringbuffer_init);`

ringbuffer: add put_force and putchar_force API Add the APIs that will discard the old data when rb is full. 2013-08-19 11:52:04 +08:00			`/**`
			`* put a block of data into ring buffer`
			`*/`
fixed the coding style in the components/drivers git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2431 bbd45198-f89e-11dd-88c7-29a3b14d5316 2012-11-22 16:43:40 +08:00			`rt_size_t rt_ringbuffer_put(struct rt_ringbuffer *rb,`
			`const rt_uint8_t *ptr,`
			`rt_uint16_t length)`
			`{`
			`rt_uint16_t size;`
fixed the coding style in components/drivers/src git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2529 bbd45198-f89e-11dd-88c7-29a3b14d5316 2012-12-26 08:29:42 +08:00
fixed the coding style in the components/drivers git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2431 bbd45198-f89e-11dd-88c7-29a3b14d5316 2012-11-22 16:43:40 +08:00			`RT_ASSERT(rb != RT_NULL);`

			`/* whether has enough space */`
ringbuffer: fix the ambiguous name RT_RINGBUFFER_SIZE could mean "the size of the whole buffer", "the size of the empty space" or "the size of the data". Moreover, it's never a micro anymore. Change it to rt_ringbuffer_data_len before it's too late. Also, RT_RINGBUFFER_EMPTY is changed to rt_ringbuffer_space_len. 2013-08-19 10:50:20 +08:00			`size = rt_ringbuffer_space_len(rb);`
fixed the coding style in the components/drivers git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2431 bbd45198-f89e-11dd-88c7-29a3b14d5316 2012-11-22 16:43:40 +08:00
			`/* no space */`
			`if (size == 0)`
			`return 0;`
reimplement ringbuffer The new implementation use the mirroring method to distinguish full buffer and the empty buffer. It also support buffers of arbitrary size. 2013-05-08 15:45:31 +08:00
fixed the coding style in the components/drivers git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2431 bbd45198-f89e-11dd-88c7-29a3b14d5316 2012-11-22 16:43:40 +08:00			`/* drop some data */`
			`if (size < length)`
			`length = size;`

reimplement ringbuffer The new implementation use the mirroring method to distinguish full buffer and the empty buffer. It also support buffers of arbitrary size. 2013-05-08 15:45:31 +08:00			`if (rb->buffer_size - rb->write_index > length)`
fixed the coding style in the components/drivers git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2431 bbd45198-f89e-11dd-88c7-29a3b14d5316 2012-11-22 16:43:40 +08:00			`{`
			`/* read_index - write_index = empty space */`
reimplement ringbuffer The new implementation use the mirroring method to distinguish full buffer and the empty buffer. It also support buffers of arbitrary size. 2013-05-08 15:45:31 +08:00			`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;`
			`return length;`
fixed the coding style in the components/drivers git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2431 bbd45198-f89e-11dd-88c7-29a3b14d5316 2012-11-22 16:43:40 +08:00			`}`
reimplement ringbuffer The new implementation use the mirroring method to distinguish full buffer and the empty buffer. It also support buffers of arbitrary size. 2013-05-08 15:45:31 +08:00
			`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));`

			`/* we are going into the other side of the mirror */`
			`rb->write_mirror = ~rb->write_mirror;`
			`rb->write_index = length - (rb->buffer_size - rb->write_index);`
fixed the coding style in the components/drivers git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2431 bbd45198-f89e-11dd-88c7-29a3b14d5316 2012-11-22 16:43:40 +08:00
			`return length;`
			`}`
			`RTM_EXPORT(rt_ringbuffer_put);`

ringbuffer: add put_force and putchar_force API Add the APIs that will discard the old data when rb is full. 2013-08-19 11:52:04 +08:00			`/**`
			`* put a block of data into ring buffer`
			`*`
			`* When the buffer is full, it will discard the old data.`
			`*/`
			`rt_size_t rt_ringbuffer_put_force(struct rt_ringbuffer *rb,`
			`const rt_uint8_t *ptr,`
			`rt_uint16_t length)`
			`{`
[Driver/ringbuffer]: Fix put_force bug OXape reports: http://www.rt-thread.org/phpBB3/topic3939.html driver/ringbuffer: when data length is bigger than space length for rb, the read_index in rb is not update. When length > space, update the read_index, the bug can be fix, and works fine. 2015-01-23 13:27:52 +08:00			`rt_uint16_t space_length;`
ringbuffer: add put_force and putchar_force API Add the APIs that will discard the old data when rb is full. 2013-08-19 11:52:04 +08:00
			`RT_ASSERT(rb != RT_NULL);`

[Driver/ringbuffer]: Fix put_force bug OXape reports: http://www.rt-thread.org/phpBB3/topic3939.html driver/ringbuffer: when data length is bigger than space length for rb, the read_index in rb is not update. When length > space, update the read_index, the bug can be fix, and works fine. 2015-01-23 13:27:52 +08:00			`space_length = rt_ringbuffer_space_len(rb);`
ringbuffer: add put_force and putchar_force API Add the APIs that will discard the old data when rb is full. 2013-08-19 11:52:04 +08:00
[Driver/ringbuffer]: Fix put_force bug OXape reports: http://www.rt-thread.org/phpBB3/topic3939.html driver/ringbuffer: when data length is bigger than space length for rb, the read_index in rb is not update. When length > space, update the read_index, the bug can be fix, and works fine. 2015-01-23 13:27:52 +08:00			`if (length > space_length)`
ringbuffer: add put_force and putchar_force API Add the APIs that will discard the old data when rb is full. 2013-08-19 11:52:04 +08:00			`length = rb->buffer_size;`

			`if (rb->buffer_size - rb->write_index > length)`
			`{`
			`/* read_index - write_index = empty space */`
			`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;`

[Driver/ringbuffer]: Fix put_force bug OXape reports: http://www.rt-thread.org/phpBB3/topic3939.html driver/ringbuffer: when data length is bigger than space length for rb, the read_index in rb is not update. When length > space, update the read_index, the bug can be fix, and works fine. 2015-01-23 13:27:52 +08:00			`if (length > space_length)`
ringbuffer: add put_force and putchar_force API Add the APIs that will discard the old data when rb is full. 2013-08-19 11:52:04 +08:00			`rb->read_index = rb->write_index;`

			`return length;`
			`}`

			`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));`

			`/* we are going into the other side of the mirror */`
			`rb->write_mirror = ~rb->write_mirror;`
			`rb->write_index = length - (rb->buffer_size - rb->write_index);`

[Driver/ringbuffer]: Fix put_force bug OXape reports: http://www.rt-thread.org/phpBB3/topic3939.html driver/ringbuffer: when data length is bigger than space length for rb, the read_index in rb is not update. When length > space, update the read_index, the bug can be fix, and works fine. 2015-01-23 13:27:52 +08:00			`if (length > space_length)`
ringbuffer: add put_force and putchar_force API Add the APIs that will discard the old data when rb is full. 2013-08-19 11:52:04 +08:00			`{`
			`rb->read_mirror = ~rb->read_mirror;`
			`rb->read_index = rb->write_index;`
			`}`

			`return length;`
			`}`
			`RTM_EXPORT(rt_ringbuffer_put_force);`

fixed the coding style in the components/drivers git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2431 bbd45198-f89e-11dd-88c7-29a3b14d5316 2012-11-22 16:43:40 +08:00			`/**`
			`* get data from ring buffer`
			`*/`
			`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);`
reimplement ringbuffer The new implementation use the mirroring method to distinguish full buffer and the empty buffer. It also support buffers of arbitrary size. 2013-05-08 15:45:31 +08:00
fixed the coding style in the components/drivers git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2431 bbd45198-f89e-11dd-88c7-29a3b14d5316 2012-11-22 16:43:40 +08:00			`/* whether has enough data */`
ringbuffer: fix the ambiguous name RT_RINGBUFFER_SIZE could mean "the size of the whole buffer", "the size of the empty space" or "the size of the data". Moreover, it's never a micro anymore. Change it to rt_ringbuffer_data_len before it's too late. Also, RT_RINGBUFFER_EMPTY is changed to rt_ringbuffer_space_len. 2013-08-19 10:50:20 +08:00			`size = rt_ringbuffer_data_len(rb);`
fixed the coding style in the components/drivers git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2431 bbd45198-f89e-11dd-88c7-29a3b14d5316 2012-11-22 16:43:40 +08:00
			`/* no data */`
			`if (size == 0)`
			`return 0;`
reimplement ringbuffer The new implementation use the mirroring method to distinguish full buffer and the empty buffer. It also support buffers of arbitrary size. 2013-05-08 15:45:31 +08:00
fixed the coding style in the components/drivers git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2431 bbd45198-f89e-11dd-88c7-29a3b14d5316 2012-11-22 16:43:40 +08:00			`/* less data */`
			`if (size < length)`
			`length = size;`

reimplement ringbuffer The new implementation use the mirroring method to distinguish full buffer and the empty buffer. It also support buffers of arbitrary size. 2013-05-08 15:45:31 +08:00			`if (rb->buffer_size - rb->read_index > length)`
fixed the coding style in the components/drivers git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2431 bbd45198-f89e-11dd-88c7-29a3b14d5316 2012-11-22 16:43:40 +08:00			`{`
			`/* copy all of data */`
reimplement ringbuffer The new implementation use the mirroring method to distinguish full buffer and the empty buffer. It also support buffers of arbitrary size. 2013-05-08 15:45:31 +08:00			`memcpy(ptr, &rb->buffer_ptr[rb->read_index], length);`
			`/* this should not cause overflow because there is enough space for`
			`* length of data in current mirror */`
			`rb->read_index += length;`
			`return length;`
fixed the coding style in the components/drivers git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2431 bbd45198-f89e-11dd-88c7-29a3b14d5316 2012-11-22 16:43:40 +08:00			`}`
reimplement ringbuffer The new implementation use the mirroring method to distinguish full buffer and the empty buffer. It also support buffers of arbitrary size. 2013-05-08 15:45:31 +08:00
			`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));`

			`/* we are going into the other side of the mirror */`
			`rb->read_mirror = ~rb->read_mirror;`
			`rb->read_index = length - (rb->buffer_size - rb->read_index);`
fixed the coding style in the components/drivers git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2431 bbd45198-f89e-11dd-88c7-29a3b14d5316 2012-11-22 16:43:40 +08:00
			`return length;`
			`}`
			`RTM_EXPORT(rt_ringbuffer_get);`

ringbuffer: format the code to a more symmetric structure 2013-05-08 15:54:30 +08:00			`/**`
			`* put a character into ring buffer`
			`*/`
			`rt_size_t rt_ringbuffer_putchar(struct rt_ringbuffer *rb, const rt_uint8_t ch)`
			`{`
			`RT_ASSERT(rb != RT_NULL);`

			`/* whether has enough space */`
ringbuffer: fix the ambiguous name RT_RINGBUFFER_SIZE could mean "the size of the whole buffer", "the size of the empty space" or "the size of the data". Moreover, it's never a micro anymore. Change it to rt_ringbuffer_data_len before it's too late. Also, RT_RINGBUFFER_EMPTY is changed to rt_ringbuffer_space_len. 2013-08-19 10:50:20 +08:00			`if (!rt_ringbuffer_space_len(rb))`
ringbuffer: format the code to a more symmetric structure 2013-05-08 15:54:30 +08:00			`return 0;`

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

			`/* flip mirror */`
			`if (rb->write_index == rb->buffer_size-1)`
			`{`
			`rb->write_mirror = ~rb->write_mirror;`
			`rb->write_index = 0;`
			`}`
			`else`
			`{`
			`rb->write_index++;`
			`}`

			`return 1;`
			`}`
			`RTM_EXPORT(rt_ringbuffer_putchar);`

ringbuffer: add put_force and putchar_force API Add the APIs that will discard the old data when rb is full. 2013-08-19 11:52:04 +08:00			`/**`
			`* put a character into ring buffer`
			`*`
			`* When the buffer is full, it will discard one old data.`
			`*/`
			`rt_size_t rt_ringbuffer_putchar_force(struct rt_ringbuffer *rb, const rt_uint8_t ch)`
			`{`
			`enum rt_ringbuffer_state old_state;`

			`RT_ASSERT(rb != RT_NULL);`

			`old_state = rt_ringbuffer_status(rb);`

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

			`/* flip mirror */`
			`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;`
			`}`
			`RTM_EXPORT(rt_ringbuffer_putchar_force);`

fixed the coding style in the components/drivers git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2431 bbd45198-f89e-11dd-88c7-29a3b14d5316 2012-11-22 16:43:40 +08:00			`/**`
			`* get a character from a ringbuffer`
			`*/`
			`rt_size_t rt_ringbuffer_getchar(struct rt_ringbuffer rb, rt_uint8_t ch)`
			`{`
			`RT_ASSERT(rb != RT_NULL);`
reimplement ringbuffer The new implementation use the mirroring method to distinguish full buffer and the empty buffer. It also support buffers of arbitrary size. 2013-05-08 15:45:31 +08:00
fixed the coding style in the components/drivers git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2431 bbd45198-f89e-11dd-88c7-29a3b14d5316 2012-11-22 16:43:40 +08:00			`/* ringbuffer is empty */`
ringbuffer: fix the ambiguous name RT_RINGBUFFER_SIZE could mean "the size of the whole buffer", "the size of the empty space" or "the size of the data". Moreover, it's never a micro anymore. Change it to rt_ringbuffer_data_len before it's too late. Also, RT_RINGBUFFER_EMPTY is changed to rt_ringbuffer_space_len. 2013-08-19 10:50:20 +08:00			`if (!rt_ringbuffer_data_len(rb))`
fixed the coding style in the components/drivers git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2431 bbd45198-f89e-11dd-88c7-29a3b14d5316 2012-11-22 16:43:40 +08:00			`return 0;`

			`/* put character */`
reimplement ringbuffer The new implementation use the mirroring method to distinguish full buffer and the empty buffer. It also support buffers of arbitrary size. 2013-05-08 15:45:31 +08:00			`*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++;`
			`}`
fixed the coding style in the components/drivers git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2431 bbd45198-f89e-11dd-88c7-29a3b14d5316 2012-11-22 16:43:40 +08:00
			`return 1;`
			`}`
			`RTM_EXPORT(rt_ringbuffer_getchar);`
ringbuffer: format the code to a more symmetric structure 2013-05-08 15:54:30 +08:00