西门子——UART——空闲&环形缓冲区_西门子环形缓冲区(ring buffer)功能块-CSDN博客

本文链接：https://blog.csdn.net/2301_80480869/article/details/147962921

何为"空闲"？如何检测？

理解 DMA + 空闲中断的关键在于弄清楚这里的"空闲 (Idle)"到底指什么，以及硬件是如何"知道"线路空闲了。

🕰️ "空闲"的定义

在 UART 通信中，当没有数据传输时，通信线路（RX 线）会保持在高电平状态（逻辑 '1'），这被称为"空闲状态"或"标记状态 (Mark State)"。

所谓的"检测到空闲"，是指硬件检测到 RX 线上连续保持高电平的时间，超过了一个完整数据帧（包括起始位、数据位、可能的校验位和停止位）所需要的时间。这通常意味着发送方已经发送完了最后一个字节的停止位，并且之后没有紧接着发送新的起始位，表明一帧（或一个数据包）的传输告一段落。

空闲状态示意：


RX Line: ____    ____----____----____----____----________----____-------------> Time
           Start| Data Bits        | Stop | IDLE (持续高电平)
                |<---- Frame 1 ---->|      |<-- Idle Detected Here
                                      Start| Data ... | Stop |
                                           |<---- Frame 2 ---->|

当高电平持续时间超过一个数据帧所需时间后，硬件即可判定为空闲。

🔍 硬件检测机制

STM32 的 UART/USART 外设内部通常有一个专门的逻辑电路来检测这种空闲状态：

1.启动条件：当调用 `HAL_UARTEx_ReceiveToIdle_DMA`（或其他使能了空闲中断的接收函数）时，HAL库会通过设置相应的移位寄存器（例如：IDLEIE - Idle Interrupt Enable）来"激活"这个检测电路。

2.检测过程：电路会监视RX线。当检测到有效的起始位（从高电平到低电平）时，它内部的一个计时器（与波特率相关）会被复位

3.触发条件：如果计时器没有检测到新的起始位的情况下，一直计数，累计时间超过了一个数据帧的长度（具体阈值由硬件设计决定，通常是 10 到 12 个比特时间），硬件就会认为线路进入了“空闲”状态。

4.中断产生：一旦检测到“空闲”，硬件会自动在状态寄存器中设置一个“空闲标志位“（例如 IDLEF - Idle Line Detected Flag）。如果此时IDLEIE中断使能位也是开启的，那么硬件就会向CPU发送一个UART中断信号

🎯 这就是为什么 `HAL_UART_IRQHandler` 能够捕捉到空闲事件，并最终调用 `HAL_UARTEx_RxEventCallback` 的原因。

"处理到货"：主循环任务 `uart_proc`

当回调函数举起 `uart_flag` 后，主循环中运行的处理任务（或定时器任务）就可以来处理这批数据了：

/**
 * @brief  处理 DMA 接收到的 UART 数据
 * @param  None
 * @retval None
 */
void uart_proc(void)
{
    // 1. 检查"到货通知旗"
    if(uart_flag == 0) 
        return; // 旗子没举起来，说明没新货，直接返回
    
    // 2. 放下旗子，表示我们已经注意到新货了
    //    防止重复处理同一批数据
    uart_flag = 0;
	
    // 3. 处理 "待处理货架" (uart_dma_buffer) 中的数据
    //    这里简单地打印出来，实际应用中会进行解析、执行命令等
    printf("DMA data: %s\n", uart_dma_buffer);
    //    (注意：如果数据不是字符串，需要用其他方式处理，比如按字节解析)
    
    // 4. 清空"待处理货架"，为下次接收做准备
    memset(uart_dma_buffer, 0, sizeof(uart_dma_buffer));
}

这个处理任务的逻辑很简单：

检查标志位 `uart_flag`。
如果标志位为 1，则将其清零，防止重复处理。
处理 `uart_dma_buffer` 中的数据（这里是打印）。
清空 `uart_dma_buffer`。

通过这种方式，数据接收（DMA + 中断回调）和数据处理（主循环任务）实现了分离，CPU 仅在每帧数据结束时被短暂占用，处理任务则可以在 CPU 空闲时执行。

数据流转枢纽：深入环形缓冲区 (Ring Buffer)

在之前的例子中，我们使用的都是线性缓冲区。这是在数据量不大或处理及时的情况下。但当数据产生速度大于数据处理速度时，线性缓冲区就会出现瓶颈（数据出现频繁的溢出或搬移）。这时候就用到环形缓冲区了，它是一种非常高效且常用的数据结构，尤其适用于处理像 UART 这样的串行数据流。

一、什么是环形缓冲区？

想象一条固定长度的传送带，货物（数据）从一端放上，从另一端取下。当传送带转到底时，又会绕回到开头。环形缓冲区就类似这个概念：

它使用一段固定大小的连续内存（就像一个普通数组）。
它维护两个关键的指针（或索引）：一个指向下一个可读数据的位置（"读指针" read_index），另一个指向下一个可写的位置（"写指针" write_index）。
当数据被写入缓冲区时，写指针向前移动；当数据被读取时，读指针向前移动。
关键在于"环形"：当指针移动到缓冲区的末尾时，它会自动"回绕"到缓冲区的开头，继续移动。这使得缓冲区看起来像一个首尾相连的环。

二、工作原理：读写指针与状态判断

缓冲区的精髓在于如何管理读写指针以及判断缓冲区的状态（空、满、或部分填充）。基本操作如下：

✍️写入数据 (Producer):

当有新数据存入时，生产者（比如UART中断服务程序）检查缓冲区是否未满。如果未满，就将数据放入指针write_index 指向的位置，然后将write_index 向前移动一位（如果到达末尾则回绕到开头）。

📖读取数据 (Consumer):

当需要取出数据时，消费者（比如主循环中断处理任务）检查缓冲区是否为非空。如果不为空，就读指针read_index 指向的位置取出数据，然后将read_index 向前移动一位（同样，到达末尾则回绕）。

⚪空状态判断:

通常，当 read_index 等于 write_index 时，表示缓冲区为空。（具体需结合满状态判断方法）

❓ 满状态判断的挑战与策略

棘手之处在于：如果仅用 read_index == write_index 判断空，那么当缓冲区刚好写满时，写指针回绕后也会等于读指针，导致空满状态混淆。常见解决方法有：

方法一：牺牲存储单元

有意保留一个单元不使用。当写指针的下一个位置是读指针时，即认为已满。read_index == write_index 明确表示空。

优点：逻辑简单直观。
缺点：浪费一个存储单元。

方法二：额外计数器

维护一个变量记录有效数据数量。写入时+1，读取时-1。通过计数器判断空(0)或满(size)。

优点：不浪费空间。
缺点：需要额外变量，并发操作计数器可能需加锁。

空状态判断：当 read_index 等于 write_index 时，表示缓冲区为空。这意味着没有数据可供读取，所有数据都已被读取。
满状态判断：当 (write_index + 1) % size == read_index 时，表示缓冲区已满。这意味着写入操作需要等待读取操作释放空间后才能继续写入。

⭐方法三：镜像指示位 (Mirror Bit - 本代码库实现)

为读写索引各分配一个"镜像位"（`read_mirror`, `write_mirror`）。每次指针越过缓冲区末尾（回绕）时，翻转其镜像位。

空: read_index == write_index 且 read_mirror == write_mirror
满: read_index == write_index 但 read_mirror != write_mirror

优点：不浪费空间，无需额外计数器，状态判断精确。
缺点：索引位数减少（本例中为15位，限制容量为32KB），逻辑稍复杂。

三、环形缓冲区的优势

高效利用内存

无需数据搬运

天产者和消费者然解耦生

线程安全（需注意）

结合 `ringbuffer.c`/`.h`：API 详解

源于RT-Thread

核心结构：`struct rt_ringbuffer`

struct rt_ringbuffer
{
    rt_uint8_t *buffer_ptr;     // 指向实际存储数据的内存区域
    rt_uint16_t read_mirror : 1;  // 读指针的镜像位 (0 或 1)
    rt_uint16_t read_index : 15; // 读指针索引 (0 ~ 32767)
    rt_uint16_t write_mirror : 1;// 写指针的镜像位 (0 或 1)
    rt_uint16_t write_index : 15;// 写指针索引 (0 ~ 32767)
    rt_int16_t buffer_size;     // 缓冲区总大小 (字节)
};

buffer_ptr 指向所分配的用于储存数据的内存块（比如一个全局数组）

read_index / write_index （15位）读写指针它们在 0 到 `buffer_size - 1` 的范围内移动。因为只用了 15 位，所以单个环形缓冲区的最大容量理论上被限制在 32KB。

read_mirror / write_mirror （一位）镜像位，实现空/满状态的判断的关键。

buffer_size 初始化时指定的缓冲区的总大小。

💡

位域 (Bit-fields): C 语言的位域语法 (: 1, : 15) 允许我们将多个变量打包到一个整数类型（这里是 rt_uint16_t，通常是 16 位）的不同位中，以节省内存。这里巧妙地将 1 位用作镜像标志，15 位用作索引。

初始化与重置

void rt_ringbuffer_init(struct rt_ringbuffer *rb, rt_uint8_t *pool, rt_int16_t size);

作用：初始化一个环形缓冲区对象

rb ：指向你要初始化的 rt_ringbuffer 结构体变量的指针。

pool ：指向你已经分配好的内存缓冲区的指针。 ringbuffer 本身并不负责内存分配。

size ：你分配的内存缓冲区的大小（字节）。注意，

代码内部会将其向下对齐到 4 字节 (RT_ALIGN_DOWN(size, 4))，虽然注释说对齐，但实际代码可能是 RT-Thread 特有的对齐宏，我们这里理解为传入的大小即可，尽量保证是整数倍。

void rt_ringbuffer_reset(struct rt_ringbuffer *rb);

作用：清空（重置）一个已经初始化的环形缓冲区。

rb ：指向要重置的环形缓冲区对象的指针。

数据写入（生产者操作）

rt_size_t rt_ringbuffer_put(struct rt_ringbuffer *rb, const rt_uint8_t *ptr, rt_uint16_t length);

作用：向环形缓冲区放入一块数据。

rb：目标环形缓冲区。

ptr：指向要放入的数据据。

length ：要放入数据的长度（字节）。

返回值： 实际成功放入缓冲区的数据长度。如果缓冲区剩余空间不足 length，它只会放入能放下的部分，并返回实际放入的长度。如果缓冲区已满，返回 0。

说明： 这是最常用的写入函数。它会检查剩余空间，不会覆盖未读的数据。

rt_size_t rt_ringbuffer_put_force(struct rt_ringbuffer *rb, const rt_uint8_t *ptr, rt_uint16_t length);

作用：强制向缓冲区放入一块数据。

参数同 rt_ringbuffer_put。

返回值： 实际成功放入缓冲区的数据长度。如果 length 大于缓冲区总大小，只会保留最后 `buffer_size` 个字节放入。

说明： 与 put 不同，如果缓冲区空间不足，此函数会覆盖掉缓冲区中最旧的数据，以腾出空间存放新数据。适用于需要始终保留最新数据，即使旧数据丢失也可以接受的场景。

rt_size_t rt_ringbuffer_putchar(struct rt_ringbuffer *rb, const rt_uint8_t ch);

作用：向缓冲区放入单个字节。

rb: 目标环形缓冲区。
ch: 要放入的字节。

返回值： 成功放入返回 1，如果缓冲区已满则返回 0。

说明： 单字节版本的 put，同样不会覆盖数据。

rt_size_t rt_ringbuffer_putchar_force(struct rt_ringbuffer *rb, const rt_uint8_t ch);

作用： 强制向环形缓冲区放入单个字节。

参数同 rt_ringbuffer_putchar。

返回值： 总是返回 1。

说明： 单字节版本的 put_force。如果缓冲区满，会覆盖掉最旧的那个字节。

数据读取 (消费者操作)

rt_size_t rt_ringbuffer_get(struct rt_ringbuffer *rb, rt_uint8_t *ptr, rt_uint16_t length);

作用： 从环形缓冲区中取出（读取并移除）一块数据。

rb: 源环形缓冲区。
ptr: 指向用于存放取出数据的缓冲区的指针。
length: 希望取出的数据长度。

返回值： 实际成功取出的数据长度。如果缓冲区中可用数据少于 length，它只会取出所有可用数据，并返回实际取出的长度。如果缓冲区为空，返回 0。

说明： 最常用的读取函数。读取后，数据在环形缓冲区中被视为消耗掉（读指针移动）。

rt_size_t rt_ringbuffer_getchar(struct rt_ringbuffer *rb, rt_uint8_t *ch);

作用： 从环形缓冲区中取出单个字节。

rb: 源环形缓冲区。
ch: 指向用于存放取出字节的变量的指针。

返回值： 成功取出返回 1，如果缓冲区为空则返回 0。

说明： 单字节版本的 get。

rt_size_t rt_ringbuffer_peek(struct rt_ringbuffer *rb, rt_uint8_t **ptr);

作用： 查看（Peeking）缓冲区中可读的数据，但不移除它们。

rb: 源环形缓冲区。
ptr: 一个指向指针的指针。函数执行后，*ptr 会指向环形缓冲区内部存储中第一个可读字节的地址。

返回值： 从 *ptr 指向的位置开始，连续可读的字节数。这个返回值可能小于缓冲区中实际的总数据量 (`rt_ringbuffer_data_len`)，因为它只返回到缓冲区末尾或数据末尾（以先到者为准）的连续块大小。如果发生回绕，需要再次调用 `peek` 来获取剩余部分。

说明： 这个函数比较特殊，它允许你直接访问环形缓冲区内部的数据，而不需要先拷贝出来。适用于需要就地处理数据（如查找特定字符）的场景。注意：使用 `peek` 获取指针后，操作数据要非常小心，并且通常不应跨越返回的 `size` 边界。它会移动读指针，但移动方式与`get`不同，更复杂些，使用时需谨慎理解其文档或源码。

状态查询与工具宏

rt_size_t rt_ringbuffer_data_len(struct rt_ringbuffer *rb);

作用： 获取当前环形缓冲区中有效数据的长度（有多少字节可读）。

返回值： 可读数据的字节数。

说明： 通过内部调用 rt_ringbuffer_status 函数，结合读写指针和镜像位来计算。

#define rt_ringbuffer_space_len(rb) ((rb)->buffer_size - rt_ringbuffer_data_len(rb))

作用： (宏) 获取当前环形缓冲区剩余空间的长度（还能写入多少字节）。

返回值： 可用空间的字节数。

rt_inline rt_uint16_t rt_ringbuffer_get_size(struct rt_ringbuffer *rb);

作用： (内联函数) 获取环形缓冲区的总大小。

返回值： 初始化时设定的 `buffer_size`。

// 内部函数, 但有助于理解
rt_inline enum rt_ringbuffer_state rt_ringbuffer_status(struct rt_ringbuffer *rb);

作用： 判断环形缓冲区的状态。

返回值： 枚举类型 rt_ringbuffer_state 的值：RT_RINGBUFFER_EMPTY, RT_RINGBUFFER_FULL, 或 RT_RINGBUFFER_HALFFULL。

说明： 这是实现空满判断的核心逻辑所在，它比较读写索引和镜像位。

动态内存版本 (可选)

ringbuffer.h 和 ringbuffer.c 中还包含了使用 `malloc` 和 `free` 动态创建和销毁环形缓冲区的函数 (rt_ringbuffer_create, rt_ringbuffer_destroy)，但这通常在裸机或资源受限的嵌入式环境中较少使用，我们这里主要关注基于静态分配内存的用法。