Mirrors_Framework/rt-thread
1
0
Fork 0
mirror of https://github.com/RT-Thread/rt-thread.git synced 2026-09-22 03:09:16 +08:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Add pipe, data queue implementation; Fix the issue which leaks one item in the available data of ring buffer.

Browse Source 
git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2313 bbd45198-f89e-11dd-88c7-29a3b14d5316
This commit is contained in:
bernard.xiong@gmail.com
2012-09-30 07:33:13 +00:00
parent 5064df210f
commit 4f05dd5426
5 changed files with 754 additions and 181 deletions
Download Patch File Download Diff File Expand all files Collapse all files
components/drivers/src/ringbuffer.c
+53 -66
View File
@@ -1,3 +1,17 @@
/*
* File : ringbuffer.c
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2012, RT-Thread Development Team
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE
*
* Change Logs:
* Date Author Notes
* 2012-09-30 Bernard first version.
*/
#include <rtthread.h>
#include <rtdevice.h>
#include <string.h>
@@ -13,71 +27,64 @@ void rt_ringbuffer_init(struct rt_ringbuffer* rb, rt_uint8_t *pool, rt_uint16_t
rb->buffer_ptr = pool;
rb->buffer_size = RT_ALIGN_DOWN(size, RT_ALIGN_SIZE);
}
RTM_EXPORT(rt_ringbuffer_init);
rt_size_t rt_ringbuffer_put(struct rt_ringbuffer* rb, const rt_uint8_t *ptr, rt_uint16_t length)
{
rt_uint16_t size;
rt_uint16_t mask;
rt_uint16_t write_position;
RT_ASSERT(rb != RT_NULL);
mask = rb->buffer_size - 1;
/* whether has enough space */
size = rb->buffer_size - ((rb->write_index - rb->read_index) & mask);
size = rb->buffer_size - (rb->write_index - rb->read_index);
/* no space */
if (size == 0) return 0;
/* drop some data */
if (size < length) length = size;
if (rb->read_index > rb->write_index)
write_position = (rb->write_index & mask);
if (rb->buffer_size - write_position> length)
{
/* read_index - write_index = empty space */
memcpy(&rb->buffer_ptr[rb->write_index], ptr, length);
rb->write_index += length;
memcpy(&rb->buffer_ptr[write_position], ptr, length);
}
else
{
if (rb->buffer_size - rb->write_index >= length)
{
/* there is enough space after write_index */
memcpy(&rb->buffer_ptr[rb->write_index], ptr, length);
rb->write_index = (rb->write_index + length) & mask;
}
else
{
memcpy(&rb->buffer_ptr[rb->write_index], ptr,
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_index = length - (rb->buffer_size - rb->write_index);
}
memcpy(&rb->buffer_ptr[write_position], ptr, rb->buffer_size - write_position);
memcpy(&rb->buffer_ptr[0], &ptr[rb->buffer_size - write_position],
length - (rb->buffer_size - write_position));
}
rb->write_index += length;
return length;
}
RTM_EXPORT(rt_ringbuffer_put);
/**
* put a character into ring buffer
*/
rt_size_t rt_ringbuffer_putchar(struct rt_ringbuffer* rb, const rt_uint8_t ch)
{
rt_uint16_t next;
rt_uint16_t mask;
RT_ASSERT(rb != RT_NULL);
/* whether has enough space */
mask = rb->buffer_size - 1;
next = (rb->write_index + 1) & mask;
if (next == rb->read_index) return 0;
/* whether has enough space */
if (rb->write_index - rb->read_index == rb->buffer_size) return 0;
/* put character */
rb->buffer_ptr[rb->write_index] = ch;
rb->write_index = next;
rb->buffer_ptr[rb->write_index & mask] = ch;
rb->write_index += 1;
return 1;
}
RTM_EXPORT(rt_ringbuffer_putchar);
/**
* get data from ring buffer
@@ -86,47 +93,42 @@ rt_size_t rt_ringbuffer_get(struct rt_ringbuffer* rb, rt_uint8_t *ptr, rt_uint16
{
rt_size_t size;
rt_uint16_t mask;
rt_uint16_t read_position;
RT_ASSERT(rb != RT_NULL);
/* whether has enough data */
mask = rb->buffer_size - 1;
size = (rb->write_index - rb->read_index) & mask;
size = rb->write_index - rb->read_index;
/* no data */
if (size == 0) return 0;
/* less data */
if (size < length) length = size;
if (rb->read_index > rb->write_index)
read_position = rb->read_index & mask;
if (rb->buffer_size - read_position >= length)
{
if (rb->buffer_size - rb->read_index >= length)
{
/* copy directly */
memcpy(ptr, &rb->buffer_ptr[rb->read_index], length);
rb->read_index = (rb->read_index + length) & mask;
}
else
{
/* copy first and second */
memcpy(ptr, &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_index = length - rb->buffer_size + rb->read_index;
}
/* copy all of data */
memcpy(ptr, &rb->buffer_ptr[read_position], length);
}
else
{
memcpy(ptr, &rb->buffer_ptr[rb->read_index], length);
rb->read_index += length;
/* copy first and second */
memcpy(ptr, &rb->buffer_ptr[read_position], rb->buffer_size - read_position);
memcpy(&ptr[rb->buffer_size - read_position], &rb->buffer_ptr[0],
length - rb->buffer_size + read_position);
}
rb->read_index += length;
return length;
}
RTM_EXPORT(rt_ringbuffer_get);
/**
* get a character from a ringbuffer
*/
rt_size_t rt_ringbuffer_getchar(struct rt_ringbuffer* rb, rt_uint8_t *ch)
{
rt_uint16_t next;
rt_uint16_t mask;
RT_ASSERT(rb != RT_NULL);
@@ -134,40 +136,25 @@ rt_size_t rt_ringbuffer_getchar(struct rt_ringbuffer* rb, rt_uint8_t *ch)
/* ringbuffer is empty */
if (rb->read_index == rb->write_index) return 0;
/* whether has data */
mask = rb->buffer_size - 1;
next = (rb->read_index + 1) & mask;
/* put character */
*ch = rb->buffer_ptr[rb->read_index];
rb->read_index = next;
*ch = rb->buffer_ptr[rb->read_index & mask];
rb->read_index += 1;
return 1;
}
RTM_EXPORT(rt_ringbuffer_getchar);
/**
* get available data size
*/
rt_size_t rt_ringbuffer_available_size(struct rt_ringbuffer* rb)
rt_size_t rt_ringbuffer_get_datasize(struct rt_ringbuffer* rb)
{
rt_size_t size;
rt_uint16_t mask;
RT_ASSERT(rb != RT_NULL);
mask = rb->buffer_size - 1;
size = (rb->write_index - rb->read_index) & mask;
/* return the available size */
return size;
return rb->write_index - rb->read_index;
}
RTM_EXPORT(rt_data_queue_reset);
/**
* get empty space size
*/
rt_size_t rt_ringbuffer_emptry_size(struct rt_ringbuffer* rb)
{
RT_ASSERT(rb != RT_NULL);
return rb->buffer_size - rt_ringbuffer_available_size(rb);
}