单片机与物联网 / 系统课时

中断接收与环形缓冲区

中断接收与环形缓冲区

轮询接收会让主循环停在等待函数中,而连续串口数据又可能在程序处理其他任务时到达。本课将使用 HAL_UART_Receive_IT 逐字节触发接收中断,再通过单生产者、单消费者环形缓冲区保存数据,使主循环能够按自己的节奏取出并处理字节。

学习目标

  • 理解 UART 接收中断、回调函数和重新挂接接收之间的关系。
  • 掌握环形缓冲区的 head、tail、空与满判定。
  • 完成一个中断入队、主循环出队并回显的连续接收程序。

中断接收与环形缓冲区

调用 HAL_UART_Receive_IT 后,HAL 只登记目标缓冲区和接收长度,函数很快返回。USART 收到字节时产生中断,HAL_UART_IRQHandler 读取硬件状态并推进接收计数;当本次指定长度全部完成后,HAL 调用 HAL_UART_RxCpltCallback。逐字节接收时,回调末尾必须再次调用 HAL_UART_Receive_IT,否则后续字节不会继续进入同一接收流程。

环形缓冲区使用固定数组保存数据,head 指向下一次写入位置,tail 指向下一次读取位置。本例保留一个空槽来区分空与满:head == tail 表示空,nextHead == tail 表示满,因此长度为 64 的数组实际最多保存 63 个字节。中断只修改 head,主循环只修改 tail,这种单生产者、单消费者约束可避免在每次入队和出队时关闭中断。

UART 中断接收与环形缓冲区数据流

缓冲区满时必须选择明确处理规则。本例丢弃最新到达的字节并增加 rxOverflowCount,这样尚未处理的旧数据不会被覆盖。命令协议若更重视最新状态,也可以改为覆盖最旧数据,但必须同步推进 tail,并让上层知道发生过丢失。

完整可运行示例

下面的 main.c 仍面向 STM32F103 HAL 工程,USART1 使用 PA9 和 PA10,波特率为 115200。代码在中断回调中只完成入队和重新挂接,不执行阻塞发送;主循环取出字节后再调用 HAL_UART_Transmit 回显。若工程中已经存在 USART1_IRQHandler,必须只保留一个同名定义,并确保它调用 HAL_UART_IRQHandler。

c
#include "stm32f1xx_hal.h"

#define UART_RX_BUFFER_SIZE 64U

UART_HandleTypeDef huart1;

static uint8_t rxBuffer[UART_RX_BUFFER_SIZE];
static uint8_t rxByte = 0U;
static volatile uint16_t rxHead = 0U;
static volatile uint16_t rxTail = 0U;
static volatile uint32_t rxOverflowCount = 0U;
static volatile uint8_t rxRestartRequired = 0U;

static void SystemClock_Config(void);
static void USART1_Init(void);
static int RingBuffer_Pop(uint8_t *data);
static void Error_Handler(void);

int main(void)
{
    uint8_t readyMessage[] = "IRQ ring buffer ready\r\n";
    uint8_t data = 0U;

    HAL_Init();
    SystemClock_Config();
    USART1_Init();

    if (HAL_UART_Transmit(
            &huart1,
            readyMessage,
            (uint16_t)(sizeof(readyMessage) - 1U),
            100U) != HAL_OK) {
        Error_Handler();
    }

    if (HAL_UART_Receive_IT(&huart1, &rxByte, 1U) != HAL_OK) {
        Error_Handler();
    }

    while (1) {
        if (rxRestartRequired != 0U) {
            rxRestartRequired = 0U;
            HAL_UART_AbortReceive(&huart1);

            if (HAL_UART_Receive_IT(&huart1, &rxByte, 1U) != HAL_OK) {
                Error_Handler();
            }
        }

        while (RingBuffer_Pop(&data) != 0) {
            if (HAL_UART_Transmit(&huart1, &data, 1U, 10U) != HAL_OK) {
                Error_Handler();
            }
        }
    }
}

void USART1_IRQHandler(void)
{
    HAL_UART_IRQHandler(&huart1);
}

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    if (huart->Instance == USART1) {
        uint16_t nextHead = (uint16_t)((rxHead + 1U) % UART_RX_BUFFER_SIZE);

        if (nextHead != rxTail) {
            rxBuffer[rxHead] = rxByte;
            rxHead = nextHead;
        } else {
            rxOverflowCount++;
        }

        if (HAL_UART_Receive_IT(&huart1, &rxByte, 1U) != HAL_OK) {
            rxRestartRequired = 1U;
        }
    }
}

void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
{
    if (huart->Instance == USART1) {
        rxRestartRequired = 1U;
    }
}

static int RingBuffer_Pop(uint8_t *data)
{
    if (rxTail == rxHead) {
        return 0;
    }

    *data = rxBuffer[rxTail];
    rxTail = (uint16_t)((rxTail + 1U) % UART_RX_BUFFER_SIZE);
    return 1;
}

static void SystemClock_Config(void)
{
    RCC_OscInitTypeDef oscillator = {0};
    RCC_ClkInitTypeDef clocks = {0};

    oscillator.OscillatorType = RCC_OSCILLATORTYPE_HSI;
    oscillator.HSIState = RCC_HSI_ON;
    oscillator.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
    oscillator.PLL.PLLState = RCC_PLL_NONE;

    if (HAL_RCC_OscConfig(&oscillator) != HAL_OK) {
        Error_Handler();
    }

    clocks.ClockType = RCC_CLOCKTYPE_HCLK
        | RCC_CLOCKTYPE_SYSCLK
        | RCC_CLOCKTYPE_PCLK1
        | RCC_CLOCKTYPE_PCLK2;
    clocks.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
    clocks.AHBCLKDivider = RCC_SYSCLK_DIV1;
    clocks.APB1CLKDivider = RCC_HCLK_DIV1;
    clocks.APB2CLKDivider = RCC_HCLK_DIV1;

    if (HAL_RCC_ClockConfig(&clocks, FLASH_LATENCY_0) != HAL_OK) {
        Error_Handler();
    }
}

static void USART1_Init(void)
{
    GPIO_InitTypeDef gpio = {0};

    __HAL_RCC_AFIO_CLK_ENABLE();
    __HAL_RCC_GPIOA_CLK_ENABLE();
    __HAL_RCC_USART1_CLK_ENABLE();

    gpio.Pin = GPIO_PIN_9;
    gpio.Mode = GPIO_MODE_AF_PP;
    gpio.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOA, &gpio);

    gpio.Pin = GPIO_PIN_10;
    gpio.Mode = GPIO_MODE_INPUT;
    gpio.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOA, &gpio);

    huart1.Instance = USART1;
    huart1.Init.BaudRate = 115200;
    huart1.Init.WordLength = UART_WORDLENGTH_8B;
    huart1.Init.StopBits = UART_STOPBITS_1;
    huart1.Init.Parity = UART_PARITY_NONE;
    huart1.Init.Mode = UART_MODE_TX_RX;
    huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    huart1.Init.OverSampling = UART_OVERSAMPLING_16;

    if (HAL_UART_Init(&huart1) != HAL_OK) {
        Error_Handler();
    }

    HAL_NVIC_SetPriority(USART1_IRQn, 1U, 0U);
    HAL_NVIC_EnableIRQ(USART1_IRQn);
}

static void Error_Handler(void)
{
    __disable_irq();

    while (1) {
    }
}

预期输出:串口助手关闭本地回显后发送 hello 并附加回车换行,接收到的每个字节会由主循环原样发回。

text
IRQ ring buffer ready
hello

并发边界与调试方法

rxHead、rxTail 和错误计数使用 volatile,目的是让编译器每次都访问实际内存,而不是长期缓存寄存器值。这里成立的前提是单核 Cortex-M、一个中断生产者和一个主循环消费者;若 DMA、中断和多个任务同时修改同一索引,就需要临界区、原子操作或 RTOS 同步机制。

回调中不要调用耗时的格式化输出、阻塞发送或复杂协议解析,否则 USART 中断会占用过长时间,新的字节可能触发溢出。更稳妥的做法是回调只入队并记录状态,主循环或任务再完成解析。调试时可监视 rxHead、rxTail 和 rxOverflowCount,若溢出计数增长,应扩大缓冲区、提高消费速度或改用 DMA。

一个常见错误是只调用一次 HAL_UART_Receive_IT,却没有在完成回调中重新挂接,表现为只能收到第一个字节。另一个错误是把满与空都写成 head == tail,导致未消费数据被错误覆盖。本例通过保留一个空槽,让两种状态具有不同判定条件。

本课练习

  1. 按行接收命令:初始条件为示例程序可以稳定回显。主循环从环形缓冲区取出字节,遇到 \r 或 \n 时结束一行,并将完整命令再次发送。验收条件是连续输入多行短命令时顺序正确,协议解析不放在中断回调中。
  2. 验证溢出处理:把主循环中的处理人为延迟,并快速发送超过 63 个字节。要求通过调试器观察 rxOverflowCount,记录缓冲区满时保留了哪些数据。验收条件是溢出计数能够增长,程序不中断,且能解释“丢弃新字节”规则的结果。

本课总结

  • 中断接收把等待过程交给硬件和 ISR,主循环无需阻塞在接收函数中。
  • 环形缓冲区通过独立的写入、读取索引吸收短时数据突发,并需要明确满缓冲区处理规则。
  • 回调应保持短小,并在每次完成后重新挂接下一次接收。

下一课预告

后续将继续学习更高吞吐量的 UART 接收方式,例如 DMA、空闲线检测和按帧解析,并比较它们与逐字节中断方案在 CPU 占用和数据边界处理上的差异。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

中断接收与环形缓冲区

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通