STM32F4串口环形缓冲区，接收多字节数据，HAL库中断接收

在使用 HAL 库进行串口接收时，可以使用 HAL_UART_Receive_IT() 函数来启动中断接收。接收到的数据会存储在串口的硬件缓冲区中，我们可以在 HAL_UART_RxCpltCallback() 回调函数中实现对数据的处理。

为了实现接收多字节数据，我们可以使用一个环形缓冲区来存储接收到的数据。具体实现步骤如下：

1. 定义环形缓冲区结构体

typedef struct {
    uint8_t* buffer;  // 缓冲区指针
    uint32_t size;    // 缓冲区大小
    uint32_t head;    // 缓冲区头指针
    uint32_t tail;    // 缓冲区尾指针
} RingBuffer;

2. 初始化环形缓冲区

void RingBuffer_Init(RingBuffer* buffer, uint8_t* data, uint32_t size) {
    buffer->buffer = data;
    buffer->size = size;
    buffer->head = 0;
    buffer->tail = 0;
}

3. 缓冲区写入数据

void RingBuffer_Write(RingBuffer* buffer, uint8_t* data, uint32_t size) {
    uint32_t i;
    for (i = 0; i < size; i++) {
        uint32_t next = (buffer->head + 1) % buffer->size;
        if (next != buffer->tail) {
            buffer->buffer[buffer->head] = data[i];
            buffer->head = next;
        } else {
            // 缓冲区已满
            break;
        }
    }
}

4. 缓冲区读取数据

uint32_t RingBuffer_Read(RingBuffer* buffer, uint8_t* data, uint32_t size) {
    uint32_t i;
    for (i = 0; i < size; i++) {
        if (buffer->tail != buffer->head) {
            data[i] = buffer->buffer[buffer->tail];
            buffer->tail = (buffer->tail + 1) % buffer->size;
        } else {
            // 缓冲区已空
            break;
        }
    }
    return i;
}

5. 在 HAL_UART_RxCpltCallback() 回调函数中实现数据的存储

void HAL_UART_RxCpltCallback(UART_HandleTypeDef* huart) {
    static uint8_t data[64];
    static uint32_t count = 0;
    uint32_t size = 0;
    if (huart->Instance == USARTx) {
        // 读取接收到的数据
        data[count++] = huart->Instance->DR & 0xFF;
        if (count >= sizeof(data)) {
            // 缓冲区已满，存储数据并清空计数器
            RingBuffer_Write(&rx_buffer, data, count);
            count = 0;
        }
        // 继续启动中断接收
        HAL_UART_Receive_IT(huart, &data[count], 1);
    }
}

6. 在主程序中读取缓冲区中的数据

uint8_t data[64];
uint32_t size = RingBuffer_Read(&rx_buffer, data, sizeof(data));
if (size > 0) {
    // 处理接收到的数据
}

通过以上步骤，我们就可以实现在 STM32F4 中使用 HAL 库进行串口接收，并使用环形缓冲区来存储多字节数据。