1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
|
/*
* 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>
void rt_ringbuffer_init(struct rt_ringbuffer *rb,
rt_uint8_t *pool,
rt_uint16_t size)
{
RT_ASSERT(rb != RT_NULL);
/* initialize read and write index */
rb->read_index = 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);
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);
/* no space */
if (size == 0)
return 0;
/* drop some data */
if (size < length)
length = size;
write_position = (rb->write_index & mask);
if (rb->buffer_size - write_position> length)
{
/* read_index - write_index = empty space */
memcpy(&rb->buffer_ptr[write_position], ptr, length);
}
else
{
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 mask;
RT_ASSERT(rb != RT_NULL);
/* whether has enough space */
mask = rb->buffer_size - 1;
/* whether has enough space */
if (rb->write_index - rb->read_index == rb->buffer_size)
return 0;
/* put character */
rb->buffer_ptr[rb->write_index & mask] = ch;
rb->write_index += 1;
return 1;
}
RTM_EXPORT(rt_ringbuffer_putchar);
/**
* 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_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;
/* no data */
if (size == 0)
return 0;
/* less data */
if (size < length)
length = size;
read_position = rb->read_index & mask;
if (rb->buffer_size - read_position >= length)
{
/* copy all of data */
memcpy(ptr, &rb->buffer_ptr[read_position], length);
}
else
{
/* 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 mask;
RT_ASSERT(rb != RT_NULL);
/* ringbuffer is empty */
if (rb->read_index == rb->write_index)
return 0;
mask = rb->buffer_size - 1;
/* put character */
*ch = rb->buffer_ptr[rb->read_index & mask];
rb->read_index += 1;
return 1;
}
RTM_EXPORT(rt_ringbuffer_getchar);
|
