Stm_common/stm32 环形缓冲/ringbuffer.c

#include "ringbuffer.h"

/**
 * @file
 * 实现 Ring Buffer 函数。
 */

void ring_buffer_init(ring_buffer_t *buffer, char *buf, size_t buf_size) {
  RING_BUFFER_ASSERT(buf_size > 0); // 确保缓冲区大小大于0
  buffer->buffer = buf;
  buffer->buf_size = buf_size;
  buffer->tail_index = 0;
  buffer->head_index = 0;
  buffer->count = 0;  // 新增计数器
}

void ring_buffer_queue(ring_buffer_t *buffer, char data) {
  /* 缓冲区已满吗？ */
  if(ring_buffer_is_full(buffer)) {
    // 覆盖最旧数据并移动尾指针
    buffer->tail_index = (buffer->tail_index + 1) % buffer->buf_size;
    buffer->count--;  // 移除旧数据
  }

  /* 将数据放入缓冲区 */
  buffer->buffer[buffer->head_index] = data;
  buffer->head_index = (buffer->head_index + 1) % buffer->buf_size;
  buffer->count++;  // 添加新数据
}

void ring_buffer_queue_arr(ring_buffer_t *buffer, const char *data, ring_buffer_size_t size) {
  /* 添加字节;一个接一个 */
  ring_buffer_size_t i;
  for(i = 0; i < size; i++) {
    ring_buffer_queue(buffer, data[i]);
  }
}

uint8_t ring_buffer_dequeue(ring_buffer_t *buffer, char *data) {
  if(ring_buffer_is_empty(buffer)) {
    /* 无项目 */
    return 0;
  }
  
  *data = buffer->buffer[buffer->tail_index];
  buffer->tail_index = (buffer->tail_index + 1) % buffer->buf_size;
  buffer->count--;  // 更新计数器
  return 1;
}

ring_buffer_size_t ring_buffer_dequeue_arr(ring_buffer_t *buffer, char *data, ring_buffer_size_t len) {
  if(ring_buffer_is_empty(buffer)) {
    /* 无项目 */
    return 0;
  }

  char *data_ptr = data;
  ring_buffer_size_t cnt = 0;
  while((cnt < len) && ring_buffer_dequeue(buffer, data_ptr)) {
    cnt++;
    data_ptr++;
  }
  return cnt;
}

uint8_t ring_buffer_peek(ring_buffer_t *buffer, char *data, ring_buffer_size_t index) {
  if(index >= ring_buffer_num_items(buffer)) {
    /* 索引处无项目 */
    return 0;
  }
  
  /* 向指针添加索引 */
  ring_buffer_size_t data_index = (buffer->tail_index + index) % buffer->buf_size; // 使用取模运算
  *data = buffer->buffer[data_index];
  return 1;
}

inline uint8_t ring_buffer_is_empty(ring_buffer_t *buffer) {
  return buffer->count == 0;  // 简化判断
}

inline uint8_t ring_buffer_is_full(ring_buffer_t *buffer) {
  return buffer->count == buffer->buf_size;  // 简化判断
}

inline ring_buffer_size_t ring_buffer_num_items(ring_buffer_t *buffer) {
  return buffer->count;  // 直接返回计数器
}

#if 0 //测试函数
#include <stdio.h>
void printf_n(char* info, char* str, int n) {
  printf("%s%2d:", info, n);
  for (size_t i = 0; i < n; i++)
  {
    printf("%c", str[i]);
  }
  printf("\r\n");
}
#ifndef min
#define min(a,b) ((a)<(b)?(a):(b))
#endif
int ring_main()
{
  ring_buffer_t buff;
	char buff_data[8]={0};

  ring_buffer_init(&buff, buff_data, sizeof(buff_data));  //环形大小
	printf("初始化长度: %d\r\n", buff.buf_size);

  ring_buffer_queue_arr(&buff, "0123456789", 10);       //循环覆盖
  printf_n("写入", buff_data, min(10, buff.buf_size));
	printf("当前长度: %d, 剩余长度: %d\r\n", ring_buffer_num_items(&buff), buff.buf_size-ring_buffer_num_items(&buff));

	char data[10]={0}; /* Application working data */
  ring_buffer_size_t len = ring_buffer_dequeue_arr(&buff, data, sizeof(data));
	printf_n("读取", data, len);
  printf("当前长度: %d, 剩余长度: %d\r\n", ring_buffer_num_items(&buff), buff.buf_size-ring_buffer_num_items(&buff));
	return 0;
} 
#endif