1
#ifndef RINGBUF_H
2
#define RINGBUF_H
3

4
#include <stdint.h>
5
#include <stdbool.h>
6

7
// 写入模式配置
8
#define RINGBUF_MODE_REJECT    0   // 满时拒绝写入
9
#define RINGBUF_MODE_OVERWRITE 1   // 满时覆盖旧数据
10

11
typedef struct ringbuf {
12
    volatile uint32_t wr_idx;   // 写索引，生产者修改
13
    volatile uint32_t rd_idx;   // 读索引，消费者修改
14
    uint8_t *data;              // 数据缓冲区（外部提供）
15
    uint32_t size;              // 缓冲区大小（建议为2的幂）
16
    uint32_t mask;              // size - 1（当size为2的幂时使用）
17
    uint8_t  mode;              // 写入模式
18
    bool     power_of_two;      // 标记size是否为2的幂
19
} ringbuf_t;
20

21
/**
22
 * @brief 初始化环形缓冲区
23
 *
24
 * @param rb   环形缓冲区对象指针
25
 * @param buf  外部提供的字节数组，用作数据存储区
26
 * @param size 缓冲区大小（字节数）
27
 * @param mode 写入模式：RINGBUF_MODE_REJECT 或 RINGBUF_MODE_OVERWRITE
28
 */
29
void ringbuf_init(ringbuf_t *rb, uint8_t *buf, uint32_t size, uint8_t mode);
30

31
/**
32
 * @brief 向环形缓冲区写入一个字节
33
 *
34
 * @param rb 环形缓冲区对象指针
35
 * @param c  待写入的字节数据
36
 * @return true  写入成功（拒绝模式下非满，或覆盖模式下总是成功）
37
 * @return false 写入失败（仅拒绝模式下缓冲区已满时返回false）
38
 */
39
bool ringbuf_write(ringbuf_t *rb, uint8_t c);
40

41
/**
42
 * @brief 从环形缓冲区读取一个字节
43
 *
44
 * @param rb 环形缓冲区对象指针
45
 * @param c  输出指针，用于存储读取到的字节
46
 * @return true  读取成功（缓冲区非空）
47
 * @return false 读取失败（缓冲区为空）
48
 */
49
bool ringbuf_read(ringbuf_t *rb, uint8_t *c);
50

51
/**
52
 * @brief 获取环形缓冲区中当前有效数据的字节数
53
 *
54
 * @param rb 环形缓冲区对象指针
55
 * @return uint32_t 当前数据长度（0 ~ size）
56
 */
57
uint32_t ringbuf_count(const ringbuf_t *rb);
58

59
/**
60
 * @brief 判断环形缓冲区是否为空
61
 *
62
 * @param rb 环形缓冲区对象指针
63
 * @return true  缓冲区为空
64
 * @return false 缓冲区非空
65
 */
66
bool ringbuf_empty(const ringbuf_t *rb);
67

68
/**
69
 * @brief 判断环形缓冲区是否为满（仅对拒绝模式有意义）
70
 *
71
 * @param rb 环形缓冲区对象指针
72
 * @return true  缓冲区已满（拒绝模式下无法再写入；覆盖模式下始终返回false，因为始终可写）
73
 * @return false 缓冲区未满
74
 */
75
bool ringbuf_full(const ringbuf_t *rb);
76

77
/**
78
 * @brief 复位环形缓冲区（清空数据，重置读写索引）
79
 *
80
 * @param rb 环形缓冲区对象指针
81
 */
82
void ringbuf_reset(ringbuf_t *rb);
83

84
#endif // RINGBUF_H

1
#include "ringbuf.h"
2
#include <stddef.h>
3
#include <assert.h>
4

5
// 内部取模函数：根据是否为2的幂选择位运算或取模
6
static inline uint32_t ringbuf_mod(const ringbuf_t *rb, uint32_t val) {
7
    if (rb->power_of_two)
8
        return val & rb->mask; //使用按位与
9
    else
10
        return val % rb->size; //使用取模符号
11
}
12

13
void ringbuf_init(ringbuf_t *rb, uint8_t *buf, uint32_t size, uint8_t mode) {
14
    assert(rb != NULL && buf != NULL && size > 0);
15
    rb->wr_idx = 0;
16
    rb->rd_idx = 0;
17
    rb->data = buf;
18
    rb->size = size;
19
    rb->mode = mode;
20
    // 判断 size 是否为 2 的幂：size & (size-1) == 0
21
    rb->power_of_two = ((size & (size - 1)) == 0);
22
    rb->mask = rb->power_of_two ? (size - 1) : 0;
23
}

1
bool ringbuf_write(ringbuf_t *rb, uint8_t c) {
2
    assert(rb != NULL && rb->data != NULL);
3

4
    uint32_t next_wr = rb->wr_idx + 1;
5
    uint32_t cur_rd = rb->rd_idx;
6

7
    if (rb->mode == RINGBUF_MODE_REJECT) {
8
        // 检查是否满（留一个空位）
9
        if (ringbuf_mod(rb, next_wr) == ringbuf_mod(rb, cur_rd))
10
            return false;   // 满，拒绝写入
11
    } else { // OVERWRITE 模式
12
        // 如果满，则移动读索引（丢弃最旧数据）
13
        if (ringbuf_mod(rb, next_wr) == ringbuf_mod(rb, cur_rd))
14
            rb->rd_idx++;   // 单调递增，仅在访问数组时取模
15
    }
16
    // 数据写入当前写指针位置
17
    rb->data[ringbuf_mod(rb, rb->wr_idx)] = c;
18
    rb->wr_idx = next_wr;
19
    return true;
20
}

1
bool ringbuf_read(ringbuf_t *rb, uint8_t *c) {
2
    assert(rb != NULL && c != NULL);
3

4
    if (rb->rd_idx == rb->wr_idx)
5
        return false;   // 空
6

7
    *c = rb->data[ringbuf_mod(rb, rb->rd_idx)];
8
    rb->rd_idx++;
9
    return true;
10
}

1
uint32_t ringbuf_count(const ringbuf_t *rb) {
2
    assert(rb != NULL);
3
    uint32_t diff = rb->wr_idx - rb->rd_idx;
4
    if (rb->power_of_two)
5
        return diff & rb->mask;      // 位运算优化
6
    else
7
        return diff % rb->size;
8
}
9

10
bool ringbuf_empty(const ringbuf_t *rb) {
11
    assert(rb != NULL);
12
    return rb->rd_idx == rb->wr_idx;
13
}
14

15
bool ringbuf_full(const ringbuf_t *rb) {
16
    assert(rb != NULL);
17
    if (rb->mode == RINGBUF_MODE_OVERWRITE)
18
        return false;   // 覆盖模式下永远不会“满”
19
    // REJECT 模式：判断是否留一个空位
20
    return ringbuf_mod(rb, rb->wr_idx + 1) == ringbuf_mod(rb, rb->rd_idx);
21
}
22

23
void ringbuf_reset(ringbuf_t *rb) {
24
    assert(rb != NULL);
25
    rb->wr_idx = 0;
26
    rb->rd_idx = 0;
27
    // 注意：不清空 data 缓冲区内容（通常不需要）
28
}

1
#include "ringbuf.h"
2

3
#define UART_BUF_SIZE  64
4
static uint8_t uart_buffer[UART_BUF_SIZE];
5
static ringbuf_t uart_rb;
6

7
// 串口中断服务函数
8
void UART_IRQHandler(void) {
9
    uint8_t data = USART_ReceiveData();
10
    ringbuf_write(&uart_rb, data);   // 根据需求选择覆盖或拒绝模式
11
}
12

13
// 主循环
14
int main(void) {
15
    // 使用覆盖模式，防止中断阻塞
16
    ringbuf_init(&uart_rb, uart_buffer, UART_BUF_SIZE, RINGBUF_MODE_OVERWRITE);
17
    while (1) {
18
        uint8_t byte;
19
        while (ringbuf_read(&uart_rb, &byte)) {
20
            process_byte(byte);   // 协议解析、CRC等耗时操作
21
        }
22
        // 执行其他任务
23
    }
24
}