STM32从零到量产开发：四路继电器工业控制模块开发-RS232 调试通信驱动模块（bsp_res232）设计说明

1. 模块概述

bsp_rs232 模块是基于 STM32 HAL 库封装的 RS232 串口通信驱动，底层使用 UART4 外设（TX: PC10, RX: PC11）。该模块主要用于与上位机或串口助手进行通信，支持调试输出、参数查询及固件升级等功能。

硬件注意：该接口为 TTL 电平，外部必须连接 RS232 电平转换芯片（如 MAX3232）。

核心特性：

• 发送机制：采用阻塞式发送（HAL_UART_Transmit），无需流控或方向控制。
• 接收机制：采用中断驱动的单字节接收，结合环形缓冲区（Ring Buffer）实现非阻塞读取。
• 协议解析：内置行缓冲读取功能，自动兼容 Windows (\r\n)、Linux (\n) 及老设备 (\r) 的换行格式，支持命令行交互。

2. 关键数据结构与宏定义

2.1 缓冲区配置宏

#define RS232_RX_BUF_SIZE     256u  // 接收环形缓冲区存储上限
#define RS232_TX_BUF_SIZE     256u  // 预留发送缓冲区宏（当前阻塞发送暂未启用）

2.2 静态环形缓冲区结构

接收端采用经典的环形缓冲区设计，通过头尾指针解耦中断写入与主循环读取：

static uint8_t  s_rx_buf[RS232_RX_BUF_SIZE];    // 接收缓存数组
static volatile uint16_t s_rx_head = 0u;        // 写指针（中断上下文写入）
static volatile uint16_t s_rx_tail = 0u;        // 读指针（主循环上下文读取）
static uint8_t  s_rx_byte = 0u;                 // 中断单字节临时接收变量

3. API 接口说明

3.1 初始化与中断回调

3.2 数据发送接口

3.3 数据接收接口

4. 核心机制与注意事项

4.1 中断链路

数据接收遵循以下调用链路：
UART4_IRQHandler → HAL_UART_IRQHandler → HAL_UART_RxCpltCallback → BSP_RS232_OnRxByte

4.2 并发安全保护

在主循环读取数据（ReadByte、Available）时，代码使用了 __disable_irq() 和 __enable_irq() 进行临界区保护。这是为了防止在读取或更新 head/tail 指针时被 UART 接收中断打断，从而避免数据错乱或指针越界。

4.3 错误恢复机制

当发生 ORE（溢出错误）、FE（帧错误）等硬件异常时，BSP_RS232_OnError 会被触发。该函数会强制复位环形缓冲区的读写指针，并重新调用 HAL_UART_Receive_IT 启动接收，确保串口在异常后能够自动恢复工作。

4.4 使用限制

• BSP_RS232_OnRxByte 和 BSP_RS232_OnError 属于底层中断回调，业务代码严禁直接调用，否则会破坏环形缓存的指针状态。
• 当前发送为阻塞模式，若在发送过程中有高频中断或长耗时任务，可能会导致发送超时，需根据实际波特率合理评估超时时间。

/**
  ******************************************************************************
  * @file    bsp_rs232.h
  * @brief   RS232 调试通信驱动 - UART4 (PC10_TX / PC11_RX)
  *
  * 用途: 与上位机/电脑串口助手通信, 用于调试输出、参数查询、固件升级等。
  *       注意: 此接口为 TTL 电平, 外部需接 RS232 电平转换芯片 (如 MAX3232)。
  *
  * 功能:
  *   - 阻塞发送 (printf 重定向基础)
  *   - 中断接收 (环形缓冲区)
  *   - 行缓冲读取 (支持 \r\n 结尾的命令行交互)
  *
  * 宏说明:
  *   RS232_RX_BUF_SIZE：接收环形缓冲区存储上限
  *   RS232_TX_BUF_SIZE：预留发送缓冲区宏，当前底层发送为阻塞模式暂未启用，后续扩展TX FIFO使用
  ******************************************************************************
  */
#ifndef __BSP_RS232_H
#define __BSP_RS232_H
#ifdef __cplusplus
extern "C" {
#endif
#include "main.h"
#include "usart.h"

/* RS232 接收环形缓冲区大小 */
#define RS232_RX_BUF_SIZE     256u
/* RS232 发送缓冲区大小，预留宏，当前阻塞发送逻辑未使用 */
#define RS232_TX_BUF_SIZE     256u

/**
  * @brief  初始化 RS232 (UART4), 启动中断接收
  */
void BSP_RS232_Init(void);

/**
  * @brief  发送数据 (阻塞式, 无方向控制需求)
  * @param  data: 数据指针
  * @param  len:  长度
  * @retval 0=成功, 非0=失败
  */
uint8_t BSP_RS232_Send(const uint8_t *data, uint16_t len);

/**
  * @brief  发送字符串 (阻塞式, 自动计算长度)
  * @param  str: 以 '\0' 结尾的字符串
  */
void BSP_RS232_SendString(const char *str);

/**
  * @brief  查询接收缓冲区可读字节数
  * @note  搭配 ReadByte / ReadLine 使用，优先判断缓存有数据再读取，减少无效调用
  */
uint16_t BSP_RS232_Available(void);

/**
  * @brief  读取一个字节 (非阻塞, 无数据返回 -1)
  * @retval >=0 读到字节ASCII值，-1 缓冲区为空
  */
int16_t BSP_RS232_ReadByte(void);

/**
  * @brief  尝试读取一行 (以 \r 或 \n 结尾)
  * @param  buf:   输出缓冲区
  * @param  bufsize: 缓冲区大小，内部自动预留1字节存放字符串结束符'\0'
  * @param  len:   输出实际读取长度 (不含结尾换行符)
  * @retval 1=读到完整行, 0=无完整行，仅半包数据
  * @note  自动兼容 Windows(\r\n) / Linux(\n) / 老设备(\r) 三种换行格式，自动过滤空回车
  */
uint8_t BSP_RS232_ReadLine(uint8_t *buf, uint16_t bufsize, uint16_t *len);

/**
  * @brief  UART 接收完成单字节回调 (由 HAL_UART_RxCpltCallback 调用)
  * @note   仅 stm32f1xx_it.c 中断文件调用，业务代码禁止直接调用本函数，会破坏环形缓存指针
  */
void BSP_RS232_OnRxByte(void);

/**
  * @brief  UART 错误回调 (溢出/帧/奇偶/噪声错误恢复)
  * @param  huart: 当前报错串口句柄
  * @note   仅 stm32f1xx_it.c 错误中断分支调用，业务代码禁止直接调用
  */
void BSP_RS232_OnError(UART_HandleTypeDef *huart);

#ifdef __cplusplus
}
#endif
#endif /* __BSP_RS232_H */

/**
  ******************************************************************************
  * @file    bsp_rs232.c
  * @brief   RS232 调试通信驱动实现 (基于 UART4)
  * @details 接收: 环形缓冲区 + 中断逐字节无阻塞接收
  *          发送: 阻塞式 HAL_UART_Transmit (RS232 全双工, 无方向控制)
  *          中断链路:
  *            UART4_IRQHandler（芯片底层中断入口）
  *         -> HAL_UART_IRQHandler（HAL 库统一中断处理函数）
  *         -> HAL_UART_RxCpltCallback（HAL 库弱回调函数）
  *         -> BSP_RS232_OnRxByte（业务接收函数）
  *         链路错误恢复：UART4_IRQHandler -> HAL_UART_IRQHandler
  *         -> HAL_UART_ErrorCallback -> BSP_RS232_OnError
  ******************************************************************************
  */
#include "bsp_rs232.h"
#include <string.h>

/* ===================== 模块静态环形缓存与单字节变量 ===================== */
/* 接收环形缓冲区 */
static uint8_t  s_rx_buf[RS232_RX_BUF_SIZE];    /* 接收环形缓存数组 */
static volatile uint16_t s_rx_head = 0u;        /* 写指针（中断写入） */
static volatile uint16_t s_rx_tail = 0u;        /* 读指针（主循环读取） */
static uint8_t  s_rx_byte = 0u;                 /* 中断单字节临时缓存 */

/* ===================== 对外公共接口（按数据流：初始化 → 中断回调 → 读取 → 发送） ===================== */
/**
  * @brief  RS232模块初始化，重置缓存并开启单字节接收中断
  * @note   【关联指引】必须在 UART4 硬件初始化 MX_UART4_Init 之后调用；
  *         环形缓存读写指针清零，HAL_UART_Receive_IT 启动中断逐字节接收
  */
void BSP_RS232_Init(void)
{
    /* 清空环形缓存读写指针 */
    s_rx_head = 0u;
    s_rx_tail = 0u;
    /* 启动UART4单字节中断接收 */
    /* HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size) */
    HAL_UART_Receive_IT(&huart4, &s_rx_byte, 1u);
}

/**
  * @brief  UART4串口错误回调
  * @param  huart: 报错串口句柄
  * @note   出现溢出/帧/奇偶/噪声错误时清空脏缓存，重启接收；
  *         仅在 stm32f1xx_it.c 错误中断分支调用，业务层禁止直接调用
  */
void BSP_RS232_OnError(UART_HandleTypeDef *huart)
{
    s_rx_head = 0u;
    s_rx_tail = 0u;
    HAL_UART_Receive_IT(huart, &s_rx_byte, 1u);
}

/**
  * @brief  单字节接收中断回调，写入环形缓存
  * @note   缓存满则丢弃当前字节，持续开启下一次接收；
  *         仅 stm32f1xx_it.c 的 HAL_UART_RxCpltCallback 调用
  */
void BSP_RS232_OnRxByte(void)
{
    uint16_t next = (s_rx_head + 1u) % RS232_RX_BUF_SIZE;
    if (next != s_rx_tail)
    {
        s_rx_buf[s_rx_head] = s_rx_byte;
        s_rx_head = next;
    }
    HAL_UART_Receive_IT(&huart4, &s_rx_byte, 1u);
}

/**
  * @brief  非阻塞读取单个字节
  * @retval >=0读到字节，-1无数据
  * @note   关中断保护读写指针，读取后立即恢复中断，避免数据错乱
  */
int16_t BSP_RS232_ReadByte(void)
{
    __disable_irq();    /* 关闭全部可屏蔽中断，防止读取中途被接收中断改写 head/tail */
    int16_t ret = -1;
    if (s_rx_tail != s_rx_head)
    {
        ret = (int16_t)s_rx_buf[s_rx_tail];
        s_rx_tail = (s_rx_tail + 1u) % RS232_RX_BUF_SIZE;
    }
    __enable_irq();     /* 打开全部可屏蔽中断，恢复串口接收 */
    return ret;
}

/**
  * @brief  读取一整行(\r/\n结尾)
  * @param  buf:     输出缓存
  * @param  bufsize: 缓存最大长度
  * @param  len:     输出有效字符长度
  * @retval 1读到完整行，0仅半包数据
  * @note   自动兼容CRLF、单独\r、单独\n，过滤空回车；
  *         1. Windows：\r 紧接着\n（两个字符代表一行结束）
  *         2. Linux/Mac：只有\n
  *         3. 部分老设备：只有\r
  */
uint8_t BSP_RS232_ReadLine(uint8_t *buf, uint16_t bufsize, uint16_t *len)
{
    uint16_t i = 0u;    /* i = 已经存了多少个字符到buf */
    int16_t ch;         /* 存每次读到的1个字节，-1代表没数据 */
    *len = 0u;          /* 先把输出长度清零 */

    while ((ch = BSP_RS232_ReadByte()) >= 0)
    {
        /* 判断：读到回车\r 或者 换行\n，代表一行结束 */
        if (ch == '\r' || ch == '\n')
        {
            /* 如果是 Windows 格式 \r\n，多读后面的 \n 扔掉 */
            if (ch == '\r')
            {
                int16_t nxt = BSP_RS232_ReadByte();    /* nxt 为读取字符的ASCII数值 */
                if (nxt == '\n')
                {
                    /* 读到配对\n，直接丢弃，不存进字符串 */
                }
            }
            /* 过滤空行：只敲回车、没有任何文字，跳过不返回 */
            if (i == 0u)
            {
                continue;
            }
            buf[i] = '\0';    /* 字符串末尾加结束符，方便打印 */
            *len = i;         /* 把有效字符数量传给上层 */
            return 1u;        /* 返回1：成功读到完整一行 */
        }
        /* 不是换行符，是普通文字，存进buf */
        /* bufsize-1 留1个位置给最后的'\0'，防止溢出 */
        if (i < bufsize - 1u)
        {
            buf[i++] = (uint8_t)ch;
        }
        /* 超出缓存长度的字符直接丢掉，避免数组越界 */
    }
    /* 循环走完，缓冲区读完了也没碰到换行，只有半段不完整文字 */
    *len = i;
    return 0u;        /* 返回0：没有完整一行，只有半包数据 */
}

/**
  * @brief  查询缓存有效未读字节数量
  * @retval 当前可读取字节数
  * @note   关中断保护计算，避免 head/tail 中途被改写；兼容缓存绕圈场景
  */
uint16_t BSP_RS232_Available(void)
{
    __disable_irq();    /* 关闭全部可屏蔽中断，防止计算中途串口中断改写head/tail，数据错乱 */
    uint16_t count;
    /* 写指针head在读指针tail后面，缓存没绕圈 */
    if (s_rx_head >= s_rx_tail)
    {
        count = s_rx_head - s_rx_tail;
    }
    /* head绕到缓存开头，超过tail，数据分段存在数组头尾 */
    else
    {
        count = RS232_RX_BUF_SIZE - s_rx_tail + s_rx_head;
    }
    __enable_irq();     /* 计算完成，重新打开中断，恢复串口接收 */
    return count;       /* 返回剩余未读字节总数 */
}

/**
  * @brief  二进制阻塞发送底层接口
  * @param  data: 待发送数据指针
  * @param  len:  数据长度
  * @retval 0成功 / 1失败(空指针/超时)
  * @note   超时按每字节 20ms 估算 +50ms 兜底；RS232 全双工无需方向控制
  */
uint8_t BSP_RS232_Send(const uint8_t *data, uint16_t len)
{
    if (len == 0u || data == NULL)
    {
        return 1u;
    }
    uint32_t timeout = (uint32_t)len * 20u + 50u;  /* 每个字节20ms, +50总时长兜底 */
    /* HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, const uint8_t *pData, uint16_t Size, uint32_t Timeout) */
    HAL_StatusTypeDef st = HAL_UART_Transmit(&huart4, data, len, timeout);
    return (st == HAL_OK) ? 0u : 1u;
}

/**
  * @brief  便捷字符串发送封装，打印输出工具，简化调用，无需返回值
  * @param  str: 以'\0'结尾字符串
  * @note   空指针内部保护；将 char* 字符串强转为底层无符号字节数组接口
  */
void BSP_RS232_SendString(const char *str)
{
    if (str == NULL)
    {
        return;
    }
    /* 将char*字符串强转为底层无符号字节数组接口 */
    BSP_RS232_Send((const uint8_t *)str, (uint16_t)strlen(str));
}