Paparazzi UAS v7.1_unstable
Paparazzi is a free software Unmanned Aircraft System.
Loading...
Searching...
No Matches
ring_buffer.c
Go to the documentation of this file.
1/*
2 * General purpose circular buffer
3 *
4 * Copyright (C) 2021 Fabien-B <fabien-b@github.com>
5 *
6 * This file is part of paparazzi. See LICENCE file.
7 */
8
9#include "utils/ring_buffer.h"
10#include <string.h>
11
12/*
13 * One producer (write) and one consumer (read) can run in different threads: each only writes its own
14 * offset, with release semantics after the data, and reads the other one with acquire semantics.
15 */
16#define RB_LOAD(_x) __atomic_load_n(&(_x), __ATOMIC_ACQUIRE)
17#define RB_STORE(_x, _v) __atomic_store_n(&(_x), (_v), __ATOMIC_RELEASE)
18
19
20void ring_buffer_init(ring_buffer_t *rb, uint8_t *buf, size_t size) {
21 rb->read_offset = 0;
22 rb->write_offset = 0;
23 rb->size = size;
24 rb->buf = buf;
25}
26
28 size_t read_offset = RB_LOAD(rb->read_offset);
29 size_t write_offset = RB_LOAD(rb->write_offset);
30 if (write_offset >= read_offset) {
31 return write_offset - read_offset;
32 }
33 else {
34 return rb->size - (read_offset - write_offset);
35 }
36}
37
39 // One byte stays free: a full buffer would have the same offsets as an empty one
40 return ring_buffer->size - ring_buffer_available(ring_buffer) - 1;
41}
42
43size_t ring_buffer_write(ring_buffer_t *rb, const uint8_t *data, size_t len) {
44 size_t free_space = ring_buffer_free_space(rb);
45 if (len > free_space) {
46 len = free_space;
47 }
48
49 size_t first_chunk = rb->size - rb->write_offset;
50 if (first_chunk > len) {
51 first_chunk = len;
52 }
53
54 // Copy first chunk
55 memcpy(&rb->buf[rb->write_offset], data, first_chunk);
56
57 // Copy second chunk if wrap needed
58 size_t remaining = len - first_chunk;
59 if (remaining > 0) {
60 memcpy(&rb->buf[0], data + first_chunk, remaining);
61 }
62
63 RB_STORE(rb->write_offset, (rb->write_offset + len) % rb->size);
64
65 return len;
66}
67
68size_t ring_buffer_read(ring_buffer_t *rb, uint8_t *read_buffer, size_t len)
69{
70 size_t available = ring_buffer_available(rb);
71 if (len > available) {
72 len = available;
73 }
74
75 // how much until wrap?
76 size_t first_chunk = rb->size - rb->read_offset;
77 if (first_chunk > len) {
78 first_chunk = len;
79 }
80
81 memcpy(read_buffer, &rb->buf[rb->read_offset], first_chunk);
82
83 size_t remaining = len - first_chunk;
84 if (remaining > 0) {
85 memcpy(read_buffer + first_chunk, &rb->buf[0], remaining);
86 }
87
88 RB_STORE(rb->read_offset, (rb->read_offset + len) % rb->size);
89
90 return len;
91}
#define RB_STORE(_x, _v)
Definition ring_buffer.c:17
size_t ring_buffer_free_space(ring_buffer_t *ring_buffer)
Definition ring_buffer.c:38
size_t ring_buffer_write(ring_buffer_t *rb, const uint8_t *data, size_t len)
Write.
Definition ring_buffer.c:43
#define RB_LOAD(_x)
Definition ring_buffer.c:16
size_t ring_buffer_read(ring_buffer_t *rb, uint8_t *read_buffer, size_t len)
Read.
Definition ring_buffer.c:68
size_t ring_buffer_available(ring_buffer_t *rb)
Definition ring_buffer.c:27
void ring_buffer_init(ring_buffer_t *rb, uint8_t *buf, size_t size)
Init.
Definition ring_buffer.c:20
size_t write_offset
Definition ring_buffer.h:16
uint8_t * buf
Definition ring_buffer.h:18
size_t read_offset
Definition ring_buffer.h:15
unsigned char uint8_t
Typedef defining 8 bit unsigned char type.