【模块化设计-10】UART1 驱动 + 环形 FIFO 实现高效串口数据收发

原创已于 2026-05-15 21:10:17 修改 · 365 阅读

10 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

模块化架构设计

于 2026-05-15 21:05:06 首次发布

在嵌入式开发中，串口（UART）是最常用的通信接口之一，而直接采用中断 + 缓冲区的方式处理串口数据，能有效避免数据丢失、提升收发效率。本文将基于实际项目代码，详解UART1 驱动与环形 FIFO（ring_fifo） 结合的实现思路，带你掌握高效串口数据处理的核心逻辑。

一、核心设计思路

串口数据收发的痛点：中断接收数据时若直接处理，易因处理耗时导致后续数据丢失；轮询发送效率低且阻塞主线程。

解决方案：

接收侧：中断接收字节后写入环形 FIFO 缓冲区，主线程按需从 FIFO 读取数据，解耦中断与数据处理；
发送侧：轮询发送（适配小数据量场景），封装字节 / 多字节发送接口，保证数据可靠输出；
环形 FIFO：基于 2 的幂次方实现高效的缓冲区读写，支持 “一个生产者（中断）+ 一个消费者（主线程）” 无锁操作。

二、环形 FIFO 核心实现（ring_fifo）

环形 FIFO 是本次串口驱动的核心缓冲区，先拆解其底层逻辑。

1. 数据结构定义（ring_fifo.h）

struct ring_fifo {
    unsigned int	in;     // 写操作下标（入队指针）
    unsigned int	out;    // 读操作下标（出队指针）
    unsigned int	mask;   // 缓冲区大小掩码（size-1，因size是2^n）
    unsigned char   *data;  // 缓冲区内存指针（大小必须是2的幂次方）
};

核心设计点：缓冲区大小必须是 2 的幂次方，通过mask = size - 1实现下标 “环形” 取模（替代取余运算，提升效率）。

2. 关键函数解析（ring_fifo.c）

（1）初始化函数：ring_fifo_init

int ring_fifo_init(struct ring_fifo *fifo, void *buffer, unsigned int size)
{
    // 校验：缓冲区大小必须是2的幂次方
    if (!is_power_of_2(size)){
        PRINTF_LOG("ring_fifo_init error\n");
        return -1;
    }
    fifo->in = 0;
    fifo->out = 0;
    fifo->data = buffer;
    if (size < 2) {
        fifo->mask = 0;
        return -1;
    }
    fifo->mask = size - 1; // 掩码：用于快速取模
    return 0;
}

功能：初始化 FIFO 结构体，校验缓冲区合法性，设置基础参数。

（2）入队函数：ring_fifo_in

unsigned int ring_fifo_in(struct ring_fifo *fifo, const unsigned char *buf, unsigned int len)
{
    unsigned int l;
    unsigned int off = fifo->in;
    unsigned int size = fifo->mask + 1;

    // 计算剩余可写入空间，超出则只写能容纳的长度
    l = ring_fifo_unused(fifo);
    if (len > l)
        len = l;

    off &= fifo->mask; // 等价于 off % size（因size是2^n）
    // 分两段拷贝（处理缓冲区“绕回”场景）
    l = min(len, size - off);
    memcpy(fifo->data + off, buf, l);       // 第一段：从当前入队位置到缓冲区末尾
    memcpy(fifo->data, buf + l, len - l);   // 第二段：缓冲区开头补足剩余数据

    fifo->in += len; // 更新入队指针
    return len;      // 返回实际写入长度
}

核心逻辑：支持缓冲区 “绕回” 写入，避免因缓冲区满丢失数据，返回实际写入字节数。

（3）出队函数：ring_fifo_out

unsigned int ring_fifo_out(struct ring_fifo *fifo, unsigned char *buf, unsigned int len)
{
    unsigned int l;
    unsigned int off = fifo->out;
    unsigned int size = fifo->mask + 1;

    // 计算可读取数据长度，超出则只读现有数据
    l = fifo->in - fifo->out;
    if (len > l)
        len = l;

    off &= fifo->mask;
    // 分两段拷贝（对应入队的绕回逻辑）
    l = min(len, size - off);
    memcpy(buf, fifo->data + off, l);
    memcpy(buf + l, fifo->data, len - l);

    fifo->out += len; // 更新出队指针
    return len;       // 返回实际读取长度
}

与入队逻辑对称，支持 “绕回” 读取，返回实际读取字节数（区别于ring_fifo_out_peek：peek 只读取不更新 out 指针）。

（4）空判断：ring_fifo_is_empty

unsigned int ring_fifo_is_empty(struct ring_fifo *fifo)
{
    return (fifo->in == fifo->out) ? 1 : 0;
}

通过入队 / 出队指针是否相等，判断缓冲区是否为空。

三、UART1 驱动实现（drv_uart1）

基于上述环形 FIFO，实现 UART1 的初始化、中断接收、读写接口封装。

1. 全局变量与宏定义

#define UART_RING_BUF_SIZE  256    // FIFO缓冲区大小（2^8，符合2^n要求）
static u8 uartl_ringbuf[UART_RING_BUF_SIZE]; // 缓冲区内存
struct ring_fifo g_uart1_ring_fifo;          // UART1专用FIFO结构体

缓冲区大小设为 256（2^8），满足环形 FIFO 的大小要求。

2. 串口初始化：drv_uart1_init

void drv_uart1_init(uint32_t bound)
{
    NVIC_InitTypeDef NVIC_InitStructure;

    // 1. 配置串口GPIO、波特率、帧格式等
    UART1_Configuration(bound);

    // 2. 初始化环形FIFO
    ring_fifo_init(&g_uart1_ring_fifo, (void *)uartl_ringbuf, UART_RING_BUF_SIZE);
    
    // 3. 配置串口中断
    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn; 
    NVIC_InitStructure.NVIC_IRQChannelPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
}

3. 串口配置：UART1_Configuration

void UART1_Configuration(uint32_t bound)
{
    GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;

    // 1. 使能时钟：USART1+GPIOA
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA,ENABLE);

    // 2. 配置GPIO复用：PA9(TX)/PA10(RX)
    GPIO_PinAFConfig(GPIOA,GPIO_PinSource9,GPIO_AF_1);
    GPIO_PinAFConfig(GPIOA,GPIO_PinSource10,GPIO_AF_1);
    
    // PA9(TX)：推挽复用输出
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; 
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;    
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    // PA10(RX)：上拉复用输入
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    
    // 3. 配置串口参数：波特率、8位数据位、1位停止位、无校验、收发模式
    USART_InitStructure.USART_BaudRate = bound;
    USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    USART_InitStructure.USART_StopBits = USART_StopBits_1;
    USART_InitStructure.USART_Parity = USART_Parity_No;
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;

    // 4. 使能接收中断（RXNE：接收非空）
    USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);

    // 5. 初始化并使能串口
    USART_Init(USART1, &USART_InitStructure);
    USART_Cmd(USART1, ENABLE);
}

标准 STM32 串口配置流程：时钟→GPIO 复用→串口参数→中断使能→串口使能。

4. 中断服务函数：USART1_IRQHandler

void USART1_IRQHandler(void)
{
    uint16_t cmd;
    u8_t  data;

    // 校验接收非空中断标志
    if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
    {
        cmd = USART_ReceiveData(USART1); // 读取接收数据
        data = cmd & 0xff;               // 保留低8位（8位数据位）
            
        ring_fifo_in(&g_uart1_ring_fifo, &data, 1); // 写入FIFO缓冲区
    }
}

核心：中断中仅做 “读取字节→写入 FIFO” 的轻量操作，避免中断耗时过长，保证数据不丢失。

5. 读写接口封装

（1）读接口：drv_uart1_read

unsigned char drv_uart1_read(unsigned char* buf,unsigned int ulen )
{
    // 缓冲区为空则返回0
    if(ring_fifo_is_empty(&g_uart1_ring_fifo) == 1){
        return 0;
    }
    // 从FIFO读取数据，返回实际读取长度
    return ring_fifo_out(&g_uart1_ring_fifo, buf, ulen);
}

主线程调用该函数读取串口数据，非阻塞（无数据则返回 0）。

（2）写接口：drv_uart1_write/drv_uart1_putchar

// 单字节发送（底层）
int drv_uart1_putchar (int ch)
{
    // 等待上一字节发送完成（TC：发送完成标志）
    while(!USART_GetFlagStatus(USART1,USART_FLAG_TC));
    USART_SendData(USART1, (uint8_t) ch); // 发送字节
    return ch;
}

// 多字节发送（封装）
void drv_uart1_write(unsigned char *data, unsigned char len)
{
    unsigned char i = 0;
    for(i=0; i<len; i++){
        drv_uart1_putchar(data[i]);
    }
}

发送侧采用轮询方式（适合小数据量场景），等待发送完成后再发下一字节，保证数据有序输出。

6. 辅助函数：GetCmd

uint8_t GetCmd(void)
{
    uint8_t tmp = 0;
    // 轮询读取接收数据（非中断方式，备用）
    if(USART_GetFlagStatus(USART1,USART_FLAG_RXNE))
    {
        tmp = USART_ReceiveData(USART1);
    }
    return tmp;
}

轮询方式读取单字节，可作为中断方式的备用方案（适合简单场景）。

四、使用示例

// 初始化：波特率115200
drv_uart1_init(115200);

// 发送数据
unsigned char send_buf[] = "Hello UART1!";
drv_uart1_write(send_buf, sizeof(send_buf)-1);

// 接收数据
unsigned char recv_buf[32];
unsigned int recv_len = drv_uart1_read(recv_buf, 32);
if(recv_len > 0){
    // 处理接收数据
    printf("Recv: %s\r\n", recv_buf);
}

五、优化与注意事项

BUG 修复：drv_uart1_init中中断通道需改为USART1_IRQn，否则中断无法触发；
多生产者 / 消费者：当前 FIFO 无锁，仅支持 “中断（生产者）+ 主线程（消费者）”，若需多线程访问，需在ring_fifo_in/out中加锁（如关中断、互斥量）；
发送优化：若发送大数据量，可改为 “DMA + 中断” 方式，避免轮询阻塞主线程；
缓冲区大小：根据实际场景调整UART_RING_BUF_SIZE（需保持 2^n），避免过小导致数据丢失、过大浪费内存；
中断优先级：合理设置 USART1 中断优先级，避免与高优先级中断冲突。