备忘录

#ifndef __RING_BUFFER_H
#define __RING_BUFFER_H

#include <stdint.h>
#include <stdbool.h>

/* 环形队列结构体 */
typedef struct {
    uint8_t *buffer;            /* 数据缓冲区指针 */
    volatile uint32_t head;     /* 写指针（队头） */
    volatile uint32_t tail;     /* 读指针（队尾） */
    uint32_t capacity;          /* 缓冲区总容量 */
} RingBuffer_t;

/* 核心 API 声明 */
void RingBuffer_Init(RingBuffer_t *rb, uint8_t *buffer, uint32_t capacity);
bool RingBuffer_Push(RingBuffer_t *rb, uint8_t data);
bool RingBuffer_Pop(RingBuffer_t *rb, uint8_t *data);
bool RingBuffer_IsFull(const RingBuffer_t *rb);
bool RingBuffer_IsEmpty(const RingBuffer_t *rb);
uint32_t RingBuffer_GetCount(const RingBuffer_t *rb);
void RingBuffer_Clear(RingBuffer_t *rb);

#endif /* __RING_BUFFER_H */

#include "ring_buffer.h"

void RingBuffer_Init(RingBuffer_t *rb, uint8_t *buffer, uint32_t capacity) {
    rb->buffer = buffer;
    rb->capacity = capacity;
    rb->head = 0;
    rb->tail = 0;
}

bool RingBuffer_IsFull(const RingBuffer_t *rb) {
    return ((rb->head + 1) % rb->capacity) == rb->tail;
}

bool RingBuffer_IsEmpty(const RingBuffer_t *rb) {
    return rb->head == rb->tail;
}

/**
 * @brief 写入数据（覆盖最老数据模式）
 */
bool RingBuffer_Push(RingBuffer_t *rb, uint8_t data) {
    bool was_full = RingBuffer_IsFull(rb);
    
    /* 直接写入数据，并推进写指针 */
    rb->buffer[rb->head] = data;
    rb->head = (rb->head + 1) % rb->capacity; 
    
    if (was_full) {
        /* 如果队列已满，必须将尾指针同步向前推进，丢弃最老数据 */
        rb->tail = (rb->tail + 1) % rb->capacity;
        return false; /* 返回 false 表示发生了旧数据覆盖 */
    }
    
    return true; 
}

/**
 * @brief 读取最老的数据
 */
bool RingBuffer_Pop(RingBuffer_t *rb, uint8_t *data) {
    if (RingBuffer_IsEmpty(rb)) {
        return false; /* 队列空 */
    }
    
    *data = rb->buffer[rb->tail];
    rb->tail = (rb->tail + 1) % rb->capacity;
    
    return true;
}

uint32_t RingBuffer_GetCount(const RingBuffer_t *rb) {
    uint32_t head = rb->head;
    uint32_t tail = rb->tail;
    if (head >= tail) {
        return head - tail;
    } else {
        return rb->capacity - tail + head;
    }
}

void RingBuffer_Clear(RingBuffer_t *rb) {
    rb->head = 0;
    rb->tail = 0;
}

#include "stm32f4xx_hal.h"
#include "ring_buffer.h"
#include <stdio.h>

#define UART_RX_BUFFER_SIZE 128

RingBuffer_t uart_rx_rb;
uint8_t uart_rx_buffer_array[UART_RX_BUFFER_SIZE];
extern UART_HandleTypeDef huart1;
uint8_t rx_temp_byte;

void System_Setup(void) {
    RingBuffer_Init(&uart_rx_rb, uart_rx_buffer_array, UART_RX_BUFFER_SIZE);
    HAL_UART_Receive_IT(&huart1, &rx_temp_byte, 1);
}

/* 中断回调：作为生产者 */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) {
    if (huart->Instance == USART1) {
        /* 队列满了会自动覆盖旧数据，中断中无需加锁 */
        RingBuffer_Push(&uart_rx_rb, rx_temp_byte);
        HAL_UART_Receive_IT(&huart1, &rx_temp_byte, 1);
    }
}

/* 主循环：作为消费者 */
int main(void) {
    HAL_Init();
    // ... 系统与外设初始化 ...
    System_Setup();
    
    uint8_t process_byte;
    
    while (1) {
        if (!RingBuffer_IsEmpty(&uart_rx_rb)) {
            
            /* --- 进入临界区：保护 Pop 操作 --- */
            uint32_t primask_bit = __get_PRIMASK(); /* 保存当前中断掩码状态 */
            __disable_irq();                        /* 关闭全局中断 */
            
            bool has_data = RingBuffer_Pop(&uart_rx_rb, &process_byte);
            
            __set_PRIMASK(primask_bit);             /* 恢复全局中断 */
            /* --- 退出临界区 --- */
            
            if (has_data) {
                // 业务逻辑：处理获取到的数据
                printf("Data: %c\r\n", process_byte);
            }
        }
        // ... 其他后台任务 ...
    }
}