当前位置：首页 > news >正文

循环队列通用模版

news 2026/5/12 18:08:04

循环队列：

RingQ.h

#ifndef RINGQ_H
#define RINGQ_H#include <stdint.h>
#include <stddef.h>
#include "stm32g4xx_hal.h"#ifndef RINGQ_DEFAULT_CAP
#define RINGQ_DEFAULT_CAP  (2048U)   // 默认 2KB
#endif// 可选：RTOS/中断临界区（按需在编译单元里重定义）
#ifndef RINGQ_ENTER_CRITICAL
#define RINGQ_ENTER_CRITICAL() __disable_irq()
#endif
#ifndef RINGQ_EXIT_CRITICAL
#define RINGQ_EXIT_CRITICAL() __enable_irq()
#endif#ifdef __cplusplus
extern "C" {
#endif// 基础循环队列核心（把它放进你自己的结构体即可）
typedef struct {uint8_t  *buf;           // 缓冲区uint32_t  cap;           // 容量（字节）volatile uint32_t head;  // 写索引 [0..cap-1]volatile uint32_t tail;  // 读索引 [0..cap-1]volatile uint32_t size;  // 已用字节数 [0..cap]
} RingQ;// ① 注册/初始化：绑定缓冲并清零
void     RingQ_Register(RingQ *q, void *buf, uint32_t cap);// ② 写入：把 src 的 len 字节写入队列；返回实际写入（空间不足则部分写入）
uint32_t RingQ_Write   (RingQ *q, const void *src, uint32_t len);// ③ 读取：从队列读最多 want_len 字节到 dst；返回实际读到的字节数
uint32_t RingQ_Read    (RingQ *q, void *dst, uint32_t want_len);// 便捷宏：静态声明一个队列与其缓冲，并提供 init
#define RINGQ_DECLARE(name, capacity)                                  \static uint8_t name##_buf[(capacity)];                              \static RingQ   name;                                                \static inline void name##_init(void){                               \RingQ_Register(&name, name##_buf, (capacity));                  \}#ifdef __cplusplus
}
#endif#endif // RINGQ_H

RingQ.c

#include "ringq.h"
#include <string.h>static inline uint32_t _min_u32(uint32_t a, uint32_t b){ return (a<b)?a:b; }void RingQ_Register(RingQ *q, void *buf, uint32_t cap){if (!q || !buf || cap == 0) return;q->buf  = (uint8_t*)buf;q->cap  = cap;q->head = 0;q->tail = 0;q->size = 0;
}uint32_t RingQ_Write(RingQ *q, const void *src_, uint32_t len){if (!q || !src_ || q->cap == 0 || len == 0) return 0;const uint8_t *src = (const uint8_t*)src_;RINGQ_ENTER_CRITICAL();uint32_t free = q->cap - q->size;uint32_t to_write = _min_u32(len, free);uint32_t widx = q->head;uint32_t first  = _min_u32(to_write, q->cap - widx);  // 尾部连续可写if (first) memcpy(&q->buf[widx], src, first);uint32_t second = to_write - first;                   // 环回到起始if (second) memcpy(&q->buf[0], src + first, second);q->head = (widx + to_write) % q->cap;q->size += to_write;RINGQ_EXIT_CRITICAL();return to_write;
}uint32_t RingQ_Read(RingQ *q, void *dst_, uint32_t want_len){if (!q || !dst_ || q->cap == 0 || want_len == 0) return 0;uint8_t *dst = (uint8_t*)dst_;RINGQ_ENTER_CRITICAL();uint32_t used = q->size;uint32_t to_read = _min_u32(want_len, used);uint32_t ridx = q->tail;uint32_t first  = _min_u32(to_read, q->cap - ridx);  // 尾部连续可读if (first) memcpy(dst, &q->buf[ridx], first);uint32_t second = to_read - first;                   // 环回到起始if (second) memcpy(dst + first, &q->buf[0], second);q->tail = (ridx + to_read) % q->cap;q->size -= to_read;RINGQ_EXIT_CRITICAL();return to_read;
}