RT-Thread 环形缓冲区(ringbuffer)在串口通信中的高效应用

环形缓冲区-----适合在通信中接收数据(例如uart) 当有大量数据的时候,我们不能存储所有的数据,那么计算机处理数据的时候,只能先处理先来的,处理之后就会把数据释放掉,再处理下一个。那么已经处理的数据的内存就会被浪费掉。因为后来的数据只能往后排队,如果要将剩余的数据都往前移动一次,那么效率就会低下了,肯定不现实,所以,环形队列就出现了。环形缓冲区是一项很好的技术,不用频繁的分配内存,而且在大多数情况下,内存的反复使用也使得我们能用更少的内存块做更多的事。 阅读详情

1. 为什么串口通信需要环形缓冲区?

如果你玩过嵌入式开发,尤其是做过串口通信,肯定遇到过这样的场景:串口中断里收到一个字节数据,你赶紧把它存起来,然后主线程慢悠悠地处理。听起来很简单对吧?但实际做起来,坑可不少。

我刚开始做项目的时候,就踩过一个大坑。当时我用的是一个全局数组来存串口数据,中断里收到一个字节就往数组里塞,主线程里再从头到尾读出来处理。看起来没问题,但实际跑起来,数据时不时就丢几个字节,或者莫名其妙多出来一些乱码。调试了半天才发现,问题出在中断和主线程“撞车”了——中断正在往数组里写数据,主线程刚好也在读这个数组,结果读出来的数据一半是旧的,一半是新的,全乱套了。

这就是典型的“数据竞争”问题。在RT-Thread这样的实时操作系统中,中断的优先级比线程高,它可以随时打断线程的执行。如果中断和线程同时操作同一块内存,又没有保护机制,数据混乱几乎是必然的。

那怎么解决呢?最简单的办法是加锁。但串口中断对实时性要求极高,如果每次收一个字节都要加锁、解锁,开销太大,可能还没处理完,下一个字节又来了,导致数据丢失。这时候,环形缓冲区(ringbuffer)就派上用场了。

你可以把环形缓冲区想象成一个圆形的传送带。写数据的人(中断)在传送带的一头放包裹,读数据的人(线程)在另一头取包裹。传送带是固定长度的,当写指针走到尽头时,它会自动回到开头继续写。这样,读写操作可以完全独立进行,只要传送带不满,写操作就不会阻塞;只要传送带不空,读操作就能拿到数据。

在RT-Thread中,环形缓冲区是官方提供的一个IPC(进程间通信)组件,专门用来解决这类“生产者-消费者”问题。它最大的优势就是高效——内存复用,不需要频繁申请释放内存;操作简单,几个API就能搞定;而且特别适合串口这种“数据流”场景。

2. RT-Thread环形缓冲区核心原理拆解

2.1 结构体:镜子里的双胞胎

要理解RT-Thread的环形缓冲区,首先得看懂它的结构体。官方定义在ringbuffer.h里,长这样:

struct rt_ringbuffer {
    rt_uint8_t *buffer_ptr;
    rt_uint16_t read_mirror : 1;
    rt_uint16_t read_index : 15;
    rt_uint16_t write_mirror : 1;
    rt_uint16_t write_index : 15;
    rt_int16_t buffer_size;
};

我来给你翻译一下每个成员是干什么的:

  • buffer_ptr:这个最简单,就是指向实际存储数据的内存块指针。通常我们定义一个数组,然后把数组首地址传给它。
  • buffer_size:缓冲区的大小。这里有个重要建议:最好设置成2的幂次方,比如128、256、512。为什么呢?后面会讲到位运算优化。
  • read_index 和 write_index:读索引和写索引。它们表示当前读、写位置在缓冲区中的偏移量,范围是0到buffer_size-1。
  • read_mirror 和 write_mirror:这是RT-Thread环形缓冲区的精髓所在,我管它们叫“镜子位”。

镜子位只有1个比特,取值0或1。它的作用很巧妙——用来判断缓冲区是空还是满。

想象一下,如果没有镜子位,当read_index和write_index相等时,我们无法区分缓冲区是空的(还没写过数据)还是满的(写满了又绕回来了)。RT-Thread的解决方案是:把缓冲区“镜像”一份,形成一个虚拟的、双倍大小的空间。镜子位为0时,表示操作在原始缓冲区;镜子位为1时,表示操作在镜像缓冲区。

判断逻辑非常优雅:

  • 如果read_index == write_index 且 read_mirror == write_mirror,说明读写指针在同一个镜像里,缓冲区为空。
  • 如果read_index == write_index 但 read_mirror != write_mirror,说明读写指针在不同的镜像里,缓冲区为满。

这种设计避免了每次读写都要做取模运算(%),在资源受限的嵌入式系统中,性能提升很明显。

2.2 关键API:四两拨千斤

RT-Thread提供了一组简洁但功能完整的API,我挑几个最常用的给你讲讲:

初始化与创建

/* 静态初始化:需要提前分配好内存 */
void rt_ringbuffer_init(struct rt_ringbuffer *rb, 
                        rt_uint8_t *pool, 
                        rt_int16_t size);

/* 动态创建:系统从堆上分配内存 */
struct rt_ringbuffer* rt_ringbuffer_create(rt_uint16_t length);

我个人的习惯是,如果缓冲区大小固定且系统资源紧张,就用静态初始化;如果需要灵活调整大小,或者不确定用多大,就用动态创建。不过要注意,动态创建会调用内存分配函数,在实时性要求极高的场景要谨慎使用。

写入数据

/* 正常写入:缓冲区满时丢弃多余数据 */
rt_size_t rt_ringbuffer_put(struct rt_ringbuffer *rb,
                           const rt_uint8_t *ptr,
                           rt_uint16_t length);

/* 强制写入:缓冲区满时覆盖旧数据 */
rt_size_t rt_ringbuffer_put_force(struct rt_ringbuffer *rb,
                                 const rt_uint8_t *ptr,
                                 rt_uint16_t length);

/* 写入单个字节 */
rt_size_t rt_ringbuffer_putchar(struct rt_ringbuffer *rb, const rt_uint8_t ch);

这里有个重要选择:用put还是put_force?

  • put是安全模式:缓冲区满了就不写了,返回实际写入的字节数。适合不能丢失数据的场景,比如命令传输。
  • put_force是强制模式:缓冲区满了就把最老的数据挤掉,保证新数据能写入。适合实时数据流,比如传感器采样,最新的数据比旧数据更重要。

我在一个气象站项目里就遇到过这个选择。最初用的put,结果一场暴雨导致数据量暴增,缓冲区满了,新的气象数据写不进去,丢失了关键的变化过程。后来改成put_force,虽然会丢失一些旧数据,但保证了最新数据的连续性,反而更符合业务需求。

读取数据

/* 读取数据 */
rt_size_t rt_ringbuffer_get(struct rt_ringbuffer *rb,
                           rt_uint8_t *ptr,
                           rt_uint16_t length);

/* 查看但不取出数据(peek) */
rt_size_t rt_ringbuffer_peek(struct rt_ringbuffer *rb, rt_uint8_t **ptr);

/* 读取单个字节 */
rt_size_t rt_ringbuffer_getchar(struct rt_ringbuffer *rb, rt_uint8_t *ch);

get和peek的区别很重要:get会把数据从缓冲区移除,peek只是看看,数据还在缓冲区里。什么时候用peek呢?比如你要解析一个数据包,需要先判断包长度、校验和,确认完整无误后再取出,这时候就可以先用peek查看。

状态查询

/* 获取缓冲区中已有数据长度 */
rt_size_t rt_ringbuffer_data_len(struct rt_ringbuffer *rb);

/* 获取缓冲区剩余空间 */
#define rt_ringbuffer_space_len(rb) ((rb)->buffer_size - rt_ringbuffer_data_len(rb))

/* 获取缓冲区状态 */
enum rt_ringbuffer_state rt_ringbuffer_status(struct rt_ringbuffer *rb);

data_len是我调试时最常用的函数。通过在读写前后打印这个值,可以清楚地知道缓冲区的工作状态:是不是快满了?是不是一直空着?数据积压了多少?

3. 手把手实现串口中断+环形缓冲区

3.1 场景分析:为什么这是最佳组合?

串口通信有个特点:数据来的随机,但实时性要求高。一字节数据从串口线传过来,必须在极短的时间内被读取,否则就会被下一字节覆盖。这个“极短时间”有多短呢?以115200波特率为例,传输1字节(8数据位+1停止位)大约需要87微秒。也就是说,从收到数据到读完,你只有不到0.1毫秒的时间。

如果直接在中断里处理数据——比如解析协议、存储到文件系统、通过网络转发——很可能处理不完,导致中断阻塞,后续数据丢失。更糟糕的是,长时间关中断会影响整个系统的实时性。

环形缓冲区的价值就在这里:中断只做最必要的事(读取硬件寄存器,写入缓冲区),复杂处理交给线程。这样中断执行时间极短,通常就几微秒,完全不影响系统实时性。

3.2 完整代码实现:从初始化到数据处理

下面我结合一个实际项目中的代码,给你展示完整的实现流程。这个项目是通过串口接收传感器数据,解析后通过Wi-Fi上传到服务器。

第一步:定义缓冲区和设备

#include <rtthread.h>
#include <rtdevice.h>

/* 定义缓冲区大小:256字节,2的幂次方 */
#define UART_RX_BUFFER_SIZE 256
#define UART_TX_BUFFER_SIZE 128

/* 静态分配缓冲区内存 */
static rt_uint8_t uart_rx_buffer[UART_RX_BUFFER_SIZE];
static rt_uint8_t uart_tx_buffer[UART_TX_BUFFER_SIZE];

/* 环形缓冲区结构体 */
static struct rt_ringbuffer uart_rx_rb;
static struct rt_ringbuffer uart_tx_rb;

/* 串口设备句柄 */
static rt_device_t uart_dev = RT_NULL;

这里我定义了两个缓冲区:一个用于接收(RX),一个用于发送(TX)。实际项目中,接收缓冲区通常要比发送缓冲区大,因为数据来的时间不确定,可能会有“突发”情况。

第二步:串口初始化与回调函数

/* 串口接收中断回调函数 */
static rt_err_t uart_rx_callback(rt_device_t dev, rt_size_t size)
{
    rt_uint8_t ch;
    rt_size_t len;
    
    /* 循环读取所有可用数据 */
    while (size > 0) {
        /* 从串口读取1字节 */
        len = rt_device_read(dev, 0, &ch, 1);
        if (len != 1) {
            break;  /* 读取失败,退出循环 */
        }
        
        /* 进入临界区保护 */
        rt_enter_critical();
        
        /* 写入接收环形缓冲区 */
        rt_ringbuffer_put(&uart_rx_rb, &ch, 1);
        
        /* 退出临界区 */
        rt_exit_critical();
        
        size--;
    }
    
    return RT_EOK;
}

/* 串口初始化函数 */
static void uart_init(void)
{
    struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
    
    /* 1. 初始化环形缓冲区 */
    rt_ringbuffer_init(&uart_rx_rb, uart_rx_buffer, UART_RX_BUFFER_SIZE);
    rt_ringbuffer_init(&uart_tx_rb, uart_tx_buffer, UART_TX_BUFFER_SIZE);
    
    /* 2. 查找串口设备 */
    uart_dev = rt_device_find("uart3");
    if (uart_dev == RT_NULL) {
        rt_kprintf("Error: UART3 device not found!\n");
        return;
    }
    
    /* 3. 配置串口参数 */
    config.baud_rate = BAUD_RATE_115200;
    config.data_bits = DATA_BITS_8;
    config.stop_bits = STOP_BITS_1;
    config.parity = PARITY_NONE;
    config.bufsz = 64;  /* 硬件FIFO缓冲区大小 */
    
    rt_device_control(uart_dev, RT_DEVICE_CTRL_CONFIG, &config);
    
    /* 4. 设置接收回调函数 */
    rt_device_set_rx_indicate(uart_dev, uart_rx_callback);
    
    /* 5. 以中断模式打开串口 */
    if (rt_device_open(uart_dev, RT_DEVICE_FLAG_INT_RX) != RT_EOK) {
        rt_kprintf("Error: Failed to open UART3!\n");
        return;
    }
    
    rt_kprintf("UART3 initialized successfully.\n");
}

这里有几个关键点:

  1. 临界区保护:rt_enter_critical()和rt_exit_critical()是必须的。虽然中断和线程不会同时运行(中断会打断线程),但如果有多个线程都来读这个缓冲区,就需要保护。临界区是最轻量级的保护方式,它只是暂时关中断,开销很小。

  2. 硬件FIFO:config.bufsz = 64设置了串口硬件的FIFO缓冲区大小。有些MCU的串口自带硬件FIFO,可以缓存多个字节再触发中断,这样能减少中断频率。但要注意,FIFO太大会增加数据延迟,需要根据实际需求调整。

  3. 错误处理:每次rt_device_read都要检查返回值。虽然串口读取很少失败,但严谨一点总没错。

第三步:数据处理线程

/* 数据处理线程入口函数 */
static void uart_process_thread_entry(void *parameter)
{
    rt_uint8_t rx_buf[65];  /* 临时缓冲区,64+1用于字符串结束符 */
    rt_size_t data_len, read_len;
    rt_tick_t last_process_time = 0;
    
    while (1) {
        /* 获取缓冲区中数据长度 */
        data_len = rt_ringbuffer_data_len(&uart_rx_rb);
        
        if (data_len > 0) {
            /* 有限读取:最多一次读64字节,避免线程阻塞太久 */
            read_len = (data_len > 64) ? 64 : data_len;
            
            /* 进入临界区读取数据 */
            rt_enter_critical();
            read_len = rt_ringbuffer_get(&uart_rx_rb, rx_buf, read_len);
            rt_exit_critical();
            
            if (read_len > 0) {
                /* 添加字符串结束符(如果处理的是文本数据) */
                rx_buf[read_len] = '\0';
                
                /* 这里进行实际的数据处理 */
                process_received_data(rx_buf, read_len);
                
                last_process_time = rt_tick_get();
            }
        } else {
            /* 缓冲区为空,计算空闲时间 */
            rt_tick_t idle_time = rt_tick_get() - last_process_time;
            
            /* 如果空闲超过1秒,可以进入低功耗模式 */
            if (idle_time > RT_TICK_PER_SECOND) {
                rt_thread_mdelay(10);  /* 让出CPU */
            } else {
                rt_thread_mdelay(1);   /* 短暂休眠,降低CPU占用 */
            }
        }
    }
}

/* 启动串口处理线程 */
static void uart_thread_start(void)
{
    rt_thread_t thread;
    
    thread = rt_thread_create("uart_proc",
                             uart_process_thread_entry,
                             RT_NULL,
                             2048,   /* 栈大小 */
                             8,      /* 优先级:中等 */
                             10);    /* 时间片 */
    
    if (thread != RT_NULL) {
        rt_thread_startup(thread);
        rt_kprintf("UART processing thread started.\n");
    }
}

这个线程的设计有几个技巧:

  1. 有限读取:一次最多读64字节,而不是有多少读多少。这是为了防止一个大数据包占用线程太长时间,影响其他任务的实时性。

  2. 动态休眠:根据缓冲区状态调整休眠时间。有数据时快速处理,没数据时适当休眠,降低CPU占用。如果长时间没数据,还可以让出CPU给其他线程。

  3. 优先级设置:优先级设为8(RT-Thread默认范围是0-31,数字越小优先级越高)。这个优先级要高于普通应用线程,但低于关键系统线程,保证数据能及时处理,又不影响系统稳定性。

3.3 发送数据的优化处理

接收讲完了,发送也很重要。很多教程只讲接收,但实际项目中,发送同样需要优化。

/* 串口发送函数(线程安全) */
static rt_size_t uart_send_data(const rt_uint8_t *data, rt_size_t length)
{
    rt_size_t sent = 0;
    rt_size_t can_send;
    
    if (uart_dev == RT_NULL || data == RT_NULL || length == 0) {
        return 0;
    }
    
    /* 检查发送缓冲区剩余空间 */
    can_send = rt_ringbuffer_space_len(&uart_tx_rb);
    
    if (can_send < length) {
        /* 空间不足,只写入能容纳的部分 */
        length = can_send;
    }
    
    if (length > 0) {
        /* 写入发送缓冲区 */
        rt_enter_critical();
        sent = rt_ringbuffer_put(&uart_tx_rb, data, length);
        rt_exit_critical();
        
        /* 触发发送(如果串口空闲) */
        uart_start_send();
    }
    
    return sent;
}

/* 启动串口发送 */
static void uart_start_send(void)
{
    rt_uint8_t temp_buf[32];
    rt_size_t len;
    
    /* 检查是否正在发送 */
    if (rt_device_write(uart_dev, 0, RT_NULL, 0) < 0) {
        /* 串口忙,等待下次触发 */
        return;
    }
    
    /* 从发送缓冲区读取数据 */
    rt_enter_critical();
    len = rt_ringbuffer_get(&uart_tx_rb, temp_buf, sizeof(temp_buf));
    rt_exit_critical();
    
    if (len > 0) {
        /* 实际发送 */
        rt_device_write(uart_dev, 0, temp_buf, len);
    }
}

/* 串口发送完成回调 */
static rt_err_t uart_tx_complete(rt_device_t dev, rt_size_t size)
{
    /* 继续发送剩余数据 */
    uart_start_send();
    return RT_EOK;
}

发送优化的核心思想是异步化和批量化:

  1. 异步发送:应用线程调用uart_send_data只是把数据放到缓冲区,然后立即返回,不等待实际发送完成。实际发送由uart_start_send函数在合适的时机触发。

  2. 批量发送:一次从缓冲区读取多个字节(比如32字节)一起发送,减少系统调用次数,提高效率。

  3. 发送完成回调:注册uart_tx_complete回调,当硬件发送完成时自动触发下一轮发送,实现“链式发送”。

这种设计特别适合需要连续发送大量数据的场景,比如通过串口传输文件、发送长报文等。

4. 实战技巧与避坑指南

4.1 缓冲区大小怎么定?

这是最常被问到的问题。缓冲区不是越大越好,也不是越小越好。我总结了一个经验公式:

缓冲区大小 = 最大突发数据量 × 安全系数
  • 最大突发数据量:串口一次可能收到的最大数据块。比如你的协议最大包长是128字节,那么突发数据量就是128。
  • 安全系数:考虑到线程处理需要时间,一般取2~4。如果处理线程优先级较低,或者处理逻辑复杂,取大一点。

举个例子:协议最大包128字节,处理线程优先级一般,我取安全系数3,那么缓冲区大小就是128×3=384字节。取最近的2的幂次方,就是512字节。

实际项目中,我还会加一个监控机制:

static void buffer_monitor_thread(void *parameter)
{
    rt_size_t max_used = 0;
    rt_size_t current_len;
    
    while (1) {
        current_len = rt_ringbuffer_data_len(&uart_rx_rb);
        
        if (current_len > max_used) {
            max_used = current_len;
            rt_kprintf("Buffer usage updated: %d/%d\n", 
                      max_used, UART_RX_BUFFER_SIZE);
        }
        
        /* 如果缓冲区使用率超过90%,告警 */
        if (current_len > UART_RX_BUFFER_SIZE * 0.9) {
            rt_kprintf("WARNING: Buffer nearly full! %d/%d\n",
                      current_len, UART_RX_BUFFER_SIZE);
        }
        
        rt_thread_mdelay(1000);  /* 每秒检查一次 */
    }
}

运行一段时间后,看max_used的值,就能知道缓冲区大小是否合适。如果经常接近缓冲区大小,说明需要扩容;如果一直很小,可以适当缩小,节省内存。

4.2 多线程读写怎么办?

如果多个线程都要读同一个环形缓冲区,比如一个线程解析数据,另一个线程备份数据,就需要额外的同步机制。RT-Thread提供了多种IPC组件:

/* 使用互斥锁保护多线程访问 */
static rt_mutex_t rb_mutex = RT_NULL;

/* 初始化互斥锁 */
rb_mutex = rt_mutex_create("rb_mutex", RT_IPC_FLAG_FIFO);

/* 线程中读写缓冲区时 */
rt_mutex_take(rb_mutex, RT_WAITING_FOREVER);
/* 操作缓冲区 */
rt_mutex_release(rb_mutex);

但要注意,中断中不能使用互斥锁,因为互斥锁可能导致上下文切换,而中断上下文不允许调度。所以中断里只能用临界区保护。

我的建议是:如果只有中断写、线程读,用临界区就够了;如果多个线程都要读写,用互斥锁+临界区组合:

/* 线程读函数 */
rt_size_t safe_rb_read(struct rt_ringbuffer *rb, rt_uint8_t *buf, rt_size_t len)
{
    rt_size_t ret;
    
    /* 线程间同步 */
    rt_mutex_take(rb_mutex, RT_WAITING_FOREVER);
    
    /* 防止中断打断 */
    rt_enter_critical();
    ret = rt_ringbuffer_get(rb, buf, len);
    rt_exit_critical();
    
    rt_mutex_release(rb_mutex);
    return ret;
}

4.3 数据粘包与断包处理

串口是流式传输,没有边界。发送方发来"HelloWorld",接收方可能一次收到"HelloWorld",也可能分两次收到"Hello"和"World",甚至可能收到"He"、"llo"、"Wor"、"ld"。

环形缓冲区只负责存储,不负责解析。你需要在应用层处理粘包/断包问题。常见的方法有:

方法一:定长协议

#define PACKET_SIZE 32

static rt_uint8_t packet_buffer[PACKET_SIZE];
static rt_size_t packet_index = 0;

static void process_stream_data(rt_uint8_t *data, rt_size_t len)
{
    for (rt_size_t i = 0; i < len; i++) {
        packet_buffer[packet_index++] = data[i];
        
        if (packet_index >= PACKET_SIZE) {
            /* 收到完整包,处理 */
            handle_packet(packet_buffer, PACKET_SIZE);
            packet_index = 0;
        }
    }
}

方法二:变长协议(长度头)

enum parse_state {
    STATE_HEADER,
    STATE_LENGTH,
    STATE_DATA
};

static enum parse_state state = STATE_HEADER;
static rt_uint16_t expected_len = 0;
static rt_uint16_t received_len = 0;
static rt_uint8_t *packet_buf = RT_NULL;

static void parse_variable_packet(rt_uint8_t byte)
{
    switch (state) {
    case STATE_HEADER:
        if (byte == 0xAA) {  /* 帧头 */
            state = STATE_LENGTH;
        }
        break;
        
    case STATE_LENGTH:
        expected_len = byte;
        packet_buf = rt_malloc(expected_len);
        if (packet_buf) {
            state = STATE_DATA;
            received_len = 0;
        } else {
            state = STATE_HEADER;  /* 分配失败,重新开始 */
        }
        break;
        
    case STATE_DATA:
        if (packet_buf && received_len < expected_len) {
            packet_buf[received_len++] = byte;
            
            if (received_len >= expected_len) {
                /* 完整包 */
                handle_packet(packet_buf, expected_len);
                rt_free(packet_buf);
                state = STATE_HEADER;
            }
        } else {
            state = STATE_HEADER;  /* 异常情况,重置状态机 */
        }
        break;
    }
}

方法三:分隔符协议

static void parse_by_delimiter(rt_uint8_t *data, rt_size_t len)
{
    static rt_uint8_t temp_buf[256];
    static rt_size_t temp_index = 0;
    
    for (rt_size_t i = 0; i < len; i++) {
        if (data[i] == '\n') {  /* 换行符作为分隔符 */
            if (temp_index > 0) {
                temp_buf[temp_index] = '\0';
                handle_line(temp_buf, temp_index);
                temp_index = 0;
            }
        } else {
            if (temp_index < sizeof(temp_buf) - 1) {
                temp_buf[temp_index++] = data[i];
            } else {
                /* 缓冲区满,丢弃或处理 */
                temp_index = 0;
            }
        }
    }
}

我个人的经验是,对于简单的控制命令,用分隔符协议最方便;对于二进制数据,用长度头协议最可靠;对于固定格式的数据,用定长协议最简单。

4.4 性能优化技巧

技巧一:使用DMA+环形缓冲区组合

如果MCU支持串口DMA,可以进一步降低CPU占用:

/* DMA接收完成中断 */
void UART_DMA_RX_Complete_IRQHandler(void)
{
    rt_size_t received_len;
    
    /* 获取DMA接收的数据长度 */
    received_len = UART_RX_BUFFER_SIZE - DMA_GetCurrDataCounter(DMA_RX_CH);
    
    /* 直接将DMA缓冲区数据拷贝到环形缓冲区 */
    rt_enter_critical();
    rt_ringbuffer_put(&uart_rx_rb, dma_rx_buffer, received_len);
    rt_exit_critical();
    
    /* 重新配置DMA */
    DMA_Reset(DMA_RX_CH);
    DMA_Config(DMA_RX_CH, dma_rx_buffer, UART_RX_BUFFER_SIZE);
}

DMA模式下,硬件自动将串口数据搬运到内存,攒够一定数量或超时才触发中断,大大减少了中断频率。

技巧二:批量处理优化

/* 批量处理,减少临界区进入次数 */
static void process_batch_data(void)
{
    rt_uint8_t batch_buf[128];
    rt_size_t available, to_read;
    
    /* 先查看有多少数据 */
    available = rt_ringbuffer_data_len(&uart_rx_rb);
    
    if (available == 0) {
        return;
    }
    
    /* 确定本次读取量 */
    to_read = (available > sizeof(batch_buf)) ? sizeof(batch_buf) : available;
    
    /* 一次性读取 */
    rt_enter_critical();
    rt_ringbuffer_get(&uart_rx_rb, batch_buf, to_read);
    rt_exit_critical();
    
    /* 处理数据(在临界区外) */
    process_data_batch(batch_buf, to_read);
}

批量处理的关键是减少进入临界区的次数。每次进入临界区(关中断)都有成本,能一次做完就不要分多次。

技巧三:动态调整线程优先级

static void adaptive_priority_adjust(void)
{
    rt_size_t data_len = rt_ringbuffer_data_len(&uart_rx_rb);
    rt_thread_t self = rt_thread_self();
    rt_uint8_t current_prio = self->current_priority;
    
    /* 根据缓冲区负载动态调整优先级 */
    if (data_len > UART_RX_BUFFER_SIZE * 0.7) {
        /* 数据积压,提高优先级 */
        if (current_prio > 2) {
            rt_thread_control(self, RT_THREAD_CTRL_CHANGE_PRIORITY, (void*)2);
        }
    } else if (data_len < UART_RX_BUFFER_SIZE * 0.2) {
        /* 数据较少,恢复默认优先级 */
        if (current_prio != 8) {
            rt_thread_control(self, RT_THREAD_CTRL_CHANGE_PRIORITY, (void*)8);
        }
    }
}

这个技巧在数据流量波动大的场景特别有用。平时用低优先级节省CPU,数据多时自动提高优先级加快处理。

5. 调试与问题排查

5.1 常见问题及解决方法

问题一:数据丢失

症状:发送方发了100字节,接收方只收到90字节。

排查步骤:

  1. 检查缓冲区大小是否足够
  2. 检查中断优先级是否被其他中断抢占
  3. 检查线程处理速度是否跟得上数据到达速度
  4. 使用rt_ringbuffer_data_len监控缓冲区使用情况

问题二:数据错乱

症状:收到的数据顺序不对,或者混入了奇怪的数据。

排查步骤:

  1. 检查是否有多线程/中断同时读写而没有保护
  2. 检查缓冲区索引是否溢出(特别是非2的幂次方大小)
  3. 检查内存是否被其他代码意外修改

问题三:系统卡死

症状:运行一段时间后,整个系统无响应。

排查步骤:

  1. 检查临界区是否嵌套或忘记退出
  2. 检查互斥锁是否死锁
  3. 检查线程栈是否溢出(增大栈大小试试)

5.2 调试工具与技巧

技巧一:添加调试统计

struct ringbuffer_stats {
    rt_size_t total_received;
    rt_size_t total_processed;
    rt_size_t max_usage;
    rt_size_t overflow_count;
    rt_tick_t last_report;
};

static struct ringbuffer_stats rb_stats = {0};

/* 在接收回调中统计 */
static rt_err_t uart_rx_callback_with_stats(rt_device_t dev, rt_size_t size)
{
    rt_size_t before_len = rt_ringbuffer_data_len(&uart_rx_rb);
    
    /* 原有接收逻辑... */
    
    rt_size_t after_len = rt_ringbuffer_data_len(&uart_rx_rb);
    
    /* 更新统计 */
    rb_stats.total_received += size;
    if (after_len > rb_stats.max_usage) {
        rb_stats.max_usage = after_len;
    }
    
    /* 检查是否溢出 */
    if (before_len + size > after_len + size) {
        rb_stats.overflow_count++;
    }
    
    /* 定期报告 */
    if (rt_tick_get() - rb_stats.last_report > RT_TICK_PER_SECOND * 5) {
        rt_kprintf("[Stats] Received: %d, Processed: %d, MaxUsage: %d/%d, Overflows: %d\n",
                  rb_stats.total_received, rb_stats.total_processed,
                  rb_stats.max_usage, UART_RX_BUFFER_SIZE,
                  rb_stats.overflow_count);
        rb_stats.last_report = rt_tick_get();
    }
    
    return RT_EOK;
}

技巧二:使用RT-Thread的finsh查看状态

#ifdef RT_USING_FINSH
#include <finsh.h>

static void rb_status(int argc, char **argv)
{
    rt_size_t data_len = rt_ringbuffer_data_len(&uart_rx_rb);
    rt_size_t space_len = rt_ringbuffer_space_len(&uart_rx_rb);
    
    rt_kprintf("UART RingBuffer Status:\n");
    rt_kprintf("  Buffer Size: %d\n", UART_RX_BUFFER_SIZE);
    rt_kprintf("  Data Length: %d (%.1f%%)\n", 
              data_len, (data_len * 100.0) / UART_RX_BUFFER_SIZE);
    rt_kprintf("  Free Space: %d (%.1f%%)\n",
              space_len, (space_len * 100.0) / UART_RX_BUFFER_SIZE);
    rt_kprintf("  Stats: Received=%d, Processed=%d\n",
              rb_stats.total_received, rb_stats.total_processed);
}
MSH_CMD_EXPORT(rb_status, show ringbuffer status);
#endif

这样,在finsh命令行输入rb_status就能实时查看缓冲区状态。

技巧三:压力测试

/* 压力测试线程:模拟高速数据流 */
static void stress_test_thread(void *parameter)
{
    rt_uint8_t test_data[64];
    rt_size_t sent_total = 0;
    rt_tick_t start_tick = rt_tick_get();
    
    /* 填充测试数据 */
    for (int i = 0; i < sizeof(test_data); i++) {
        test_data[i] = i & 0xFF;
    }
    
    while (1) {
        /* 高速写入 */
        for (int i = 0; i < 100; i++) {
            rt_ringbuffer_put_force(&uart_rx_rb, test_data, sizeof(test_data));
            sent_total += sizeof(test_data);
        }
        
        rt_thread_mdelay(10);
        
        /* 每秒钟报告一次速率 */
        if (rt_tick_get() - start_tick > RT_TICK_PER_SECOND) {
            rt_kprintf("Stress test: %d bytes/sec\n", sent_total);
            sent_total = 0;
            start_tick = rt_tick_get();
        }
    }
}

压力测试可以帮助你找到系统的极限在哪里,缓冲区多大才够用,处理线程需要多高的优先级。

5.3 真实案例:智能家居网关的串口优化

去年我做了一个智能家居网关项目,需要同时处理4个串口:一个接Wi-Fi模块,一个接Zigbee协调器,一个接蓝牙模块,还有一个用于调试。最初的设计是每个串口一个线程+一个环形缓冲区,结果发现内存不够用(芯片只有64KB RAM),而且线程切换开销大。

优化后的方案:

/* 统一管理多个串口的环形缓冲区 */
struct uart_channel {
    rt_device_t dev;
    struct rt_ringbuffer rb;
    rt_uint8_t *buffer;
    rt_size_t buf_size;
    rt_thread_t thread;
    rt_bool_t enabled;
};

static struct uart_channel channels[4];

/* 统一的中断回调 */
static rt_err_t unified_uart_callback(rt_device_t dev, rt_size_t size)
{
    for (int i = 0; i < 4; i++) {
        if (channels[i].dev == dev && channels[i].enabled) {
            /* 找到对应的通道,处理数据 */
            process_channel_rx(&channels[i], size);
            break;
        }
    }
    return RT_EOK;
}

/* 统一的数据处理线程 */
static void unified_process_thread(void *parameter)
{
    rt_uint8_t temp_buf[64];
    
    while (1) {
        for (int i = 0; i < 4; i++) {
            if (!channels[i].enabled) continue;
            
            rt_size_t data_len = rt_ringbuffer_data_len(&channels[i].rb);
            
            if (data_len > 0) {
                rt_size_t to_read = (data_len > 64) ? 64 : data_len;
                
                rt_enter_critical();
                rt_ringbuffer_get(&channels[i].rb, temp_buf, to_read);
                rt_exit_critical();
                
                /* 根据通道ID分发处理 */
                dispatch_to_handler(i, temp_buf, to_read);
            }
        }
        
        rt_thread_mdelay(1);
    }
}

这个方案的好处:

  1. 内存共享:只需要一个处理线程,节省了3个线程栈
  2. 统一调度:避免多个线程竞争CPU
  3. 灵活配置:可以动态启用/禁用某个通道

最终,内存占用从原来的35KB降低到18KB,CPU使用率从42%降低到28%,系统稳定性大幅提升。

6. 进阶话题:环形块缓冲区(RBB)

RT-Thread除了普通的环形缓冲区,还提供了环形块缓冲区(RBB)。这是环形缓冲区的高级版本,适合更复杂的场景。

6.1 什么是RBB?

普通环形缓冲区是以字节为单位的,而RBB是以“块”为单位的。每个块可以有不同的长度,这在处理变长数据包时特别有用。

/* RBB结构体 */
struct rt_rbb_blk {
    rt_uint8_t *buf;
    rt_size_t size;
    rt_slist_t list;
};

struct rt_rbb {
    rt_uint8_t *buf;
    rt_size_t buf_size;
    rt_size_t blk_max_num;
    /* ... 其他内部字段 ... */
};

6.2 RBB在串口通信中的应用

假设你要通过串口接收不同长度的数据包,比如:

  • 心跳包:8字节
  • 传感器数据:32字节
  • 配置命令:可变长度,最大256字节

用普通环形缓冲区,你需要自己解析包边界;用RBB,可以这样:

/* 接收变长包 */
static void receive_variable_packet(void)
{
    rt_rbb_blk_t blk;
    rt_size_t header_len = 2;  /* 假设包头2字节 */
    rt_uint8_t header[2];
    
    /* 先读取包头 */
    if (rt_ringbuffer_get(&uart_rx_rb, header, header_len) == header_len) {
        /* 从包头解析出数据长度 */
        rt_size_t data_len = (header[0] << 8) | header[1];
        
        /* 从RBB分配一个块 */
        blk = rt_rbb_blk_alloc(rbb, data_len);
        if (blk) {
            /* 读取数据到块中 */
            rt_ringbuffer_get(&uart_rx_rb, blk->buf, data_len);
            
            /* 放入RBB队列 */
            rt_rbb_blk_put(blk);
            
            /* 应用线程从队列中获取完整块 */
            process_rbb_block(rbb);
        }
    }
}

6.3 RBB vs 普通环形缓冲区

特性普通环形缓冲区环形块缓冲区(RBB)
数据单位字节数据块
内存管理连续内存块式管理
适合场景流式数据、定长包变长数据包、消息队列
使用复杂度简单中等
内存开销小稍大(需要块头)
零拷贝支持有限(peek)好(直接传递块指针)

选择建议:

  • 如果是简单的数据流,或者数据格式固定,用普通环形缓冲区
  • 如果需要处理多种长度的数据包,或者要实现消息队列,用RBB
  • 如果内存非常紧张,优先考虑普通环形缓冲区

我在实际项目中,通常先用普通环形缓冲区实现核心功能,等需要更复杂的功能时再考虑升级到RBB。毕竟,简单可靠才是嵌入式系统的首要原则。

最后,无论用哪种缓冲区,都要记住:先让程序跑起来,再让它跑得好。不要一开始就追求完美的架构,先实现基本功能,再根据实际遇到的问题进行优化。嵌入式开发很多时候是权衡的艺术,在资源、性能、复杂度之间找到最适合当前项目的平衡点。

串口开发之环形缓冲区 串口接收数据长度位置,频率未知,不要求实时处理的场景。缓冲队列来解决在处理的时候来的数据包就“丢失”的问题。 阅读详情

相关推荐

环形缓冲区优点及实现

使用环形缓冲区时存放sensor的x和y位置时,读与写互不干扰:读数据根据读指针读取,只有TaskReadPosition任务能够修改读指针位置;写数据使用写指针写数据,只有TaskWritePosition任务能够修改写指针的位置。环形缓冲区所有的push和pop操作都是在一个固定的存储空间内进行,相比队列方式,少掉了对于缓冲区元素所用存储空间的分配、释放。这是环形缓冲区的一个主要优势。环形缓冲区是一种特殊的缓冲区,其读指针和写指针都指向同一个缓冲区,通过移动指针来实现数据的读取和写入。

studyingdda的博客 3455

串口环形缓冲区

串口环形缓冲区应用于嵌入式、物联网开发时,当串口接收数据量过大,此时MCU来不及处理而设计的一套算法,将接收的数据存入一个数组,等待空闲时再做处理。

小途的博客 3545

RT-Thread串口通信实战:如何用ringbuffer搞定中断与线程的数据交换(附避坑指南)

本文深入探讨了在RT-Thread实时操作系统中,如何利用环形缓冲区(ringbuffer)高效、可靠地解决串口通信中中断与线程间的数据交换难题。通过剖析ringbuffer的核心机制、提供实战代码框架,并分享常见问题与避坑指南,帮助嵌入式开发者构建稳定、高性能的串口通信系统。

bash7scripter的博客 631

环形缓冲区(ringbuffer)

环形缓冲区(ringbuffer) 环形缓冲区是嵌入式系统中十分重要的一种数据结构,比如在串口处理中,串口中断接收数据直接往环形缓冲区丢数据,而应用可以从环形缓冲区取数据进行处理,这样数据在读取和写入的时候都可以在这个缓冲区里循环进行,程序员可以根据自己需要的数据大小来决定自己使用的缓冲区大小。 环形缓冲区,顾名思义这个缓冲区是环形的,那么何谓环形这个意思也很好理解,就是用一个指针去访问该缓冲区的最后一个内存位置的的后一位置时回到环形缓冲区的起点。类似一个环一样 在此之前,我们来回顾一下队列的基本概念

loveliu928的博客 1万+

RT-Thread串口通信实战:如何用ringbuffer搞定DMA接收数据不丢包

本文针对嵌入式开发中串口DMA接收数据易丢失的难题,详细介绍了基于RT-Thread的ringbuffer(环形缓冲区)解决方案。通过分析数据丢失的根本原因,并结合实战代码,阐述了如何利用ringbuffer实现硬件中断与数据处理线程的解耦,从而在高负载下确保数据完整接收,有效解决数据丢失问题。

4k5l6j7h8的博客 236

RT-Thread串口中断接收配置实战:从驱动层到应用层的完整指南

串口通信是嵌入式系统中最基础且广泛使用的数据交换方式,其核心原理是通过异步串行传输实现设备间的可靠通信。在实时操作系统(RTOS)环境下,中断接收模式能有效提升CPU利用率,避免轮询带来的资源浪费。RT-Thread作为一款国产开源RTOS,其设备驱动框架通过标准化的设备模型,将硬件中断事件与内核线程通信机制(如信号量、消息队列)无缝衔接,实现了高效的数据吞吐与任务调度。这一技术方案在工业控制、物联网终端、智能硬件等场景中具有重要价值,尤其适用于Modbus、GPS解析、AT指令处理等需要实时响应串口数据的

weixin_34239169的博客 416

RT-Thread Bootloader高波特率串口通信优化(协议栈)

本文将介绍RT-Thread Bootloader高波特率串口通信优化方案。该方案基于RT-Thread实时操作系统,针对921600及以上高波特率场景进行系统优化,采用分层架构设计。

Where there is life, there is hope. 854

linuxcnc移植igh搭建的ethercat主站的cnc系统,采用工控机带三台迈信伺服驱动电机和艾莫迅的远程IO组成 控制系统,资料涵盖:ethercat主站配置的文件,hal文件,ini文件

linuxcnc移植igh搭建的ethercat主站的cnc系统,采用工控机带三台迈信伺服驱动电机和艾莫迅的远程IO组成 控制系统,ethercat主站配置xml文件,hal文件,ini文件。

RT-Thread 系统 ringbuffer(环形缓冲区)的使用

ringbufferbuffer_ptr 缓冲区基地址:实际存储数据的内存数组(通常为字节数组)。buffer_size 缓冲区大小:建议设置为2的幂次方(如128、256字节),利用位运算优化索引计算。读指针(read_index):指向当前可读取数据的位置。写指针(write_index):指向当前可写入数据的位置。read_mirror 和 write_mirror:可以理解为一种镜像值。

weixin_46158019的博客 3076

UVM自学笔记3——项目之三——从零开始搭建ahb_sramc验证平台

创建如下所示的目录结构: 2.在tb的文件下:顶层的testbench如下:在tb中,第24行的代码将uvm宏相关的内容include进来,第26行的代码把uvm_pkg包导入进来,然后将agent相关的包(ahb_pkg/sram_pkg),testcase相关的包(uvm_ahb_sram_test_pkg)以及env相关的包(uvm_ahb_sram_env_pkg)都导入进来,在第38行和39行将接口以virtual interface的形式配置给ahb_agent和sramc_agent下

ZhangShuHuai11的博客 9482

MT25QL256完整操作指南:从ID读取到4KB扇区擦除(附华大SPI例程)

本文提供了MT25QL256 NOR FLASH在华大MCU上的完整驱动开发指南。内容涵盖从SPI初始化、器件ID读取、状态寄存器查询,到核心的页编程和4KB扇区擦除操作,并分享了构建健壮驱动框架、处理跨页写入及常见调试问题的实战经验。

tt34567的博客 888

RT-Thread 环形缓冲区实战:从原理到串口通信应用

本文深入解析了RT-Thread环形缓冲区(ringbuffer)的核心原理与实战应用。通过剖析其独特的镜像指针设计,详细介绍了如何高效解决中断与线程间的数据传递难题。文章以串口通信为例,提供了从基础实现到结合DMA优化的完整代码示例,并总结了常见陷阱与进阶应用场景,是嵌入式开发中实现高效、可靠数据缓冲的实用指南。

gitlab7runner的博客 472

Vivado实战:如何用BUFGMUX_CTRL实现FPGA双时钟热切换(附时序约束模板)

本文详细介绍了如何使用Xilinx FPGA中的BUFGMUX_CTRL原语实现双时钟热切换的工业级解决方案。通过分析BUFGMUX_CTRL的核心机制、PCB布局约束和电源噪声抑制方法,提供Vivado实现全流程和时序约束模板,帮助工程师在工业自动化、车载电子等场景中提升系统可靠性。

weixin_29186249的博客 585

RT-Thread串口通信实战:如何用ringbuffer搞定中断与线程数据交换(附避坑指南)

本文详细介绍了如何在RT-Thread中使用ringbuffer实现串口中断与线程间的高效数据交换。通过环形缓冲区的核心原理、实战配置及优化技巧,解决嵌入式开发中的数据丢失与系统卡死问题,并附有避坑指南与性能优化方案,帮助开发者构建稳定可靠的通信通道。

qsc9012345的博客 282

MATLAB闪退别慌!5分钟搞定Windows系统预设文件修复(附详细截图)

本文针对MATLAB在Windows系统下频繁闪退的问题,提供了快速有效的解决方案。核心在于修复或重置损坏的MATLAB预设文件,通过图文并茂的五步法,指导用户定位AppData目录、重命名预设文件夹,从而让MATLAB自动生成全新配置以解决闪退。文章还涵盖了问题诊断、设置备份及进阶排查方法,帮助用户彻底根除启动故障。

weixin_29234423的博客 928

CDD数据库文件制作(二)——DTC配置

1.DTC库 2.新建DTC DTC相关介绍:https://blog.csdn.net/LOVE135149/article/details/122565443 ① 选择DTC数据库 ② 点击新建DTC ③ DTC参数编辑 3.将DTC库中的DTC加载到Variant中 找到Fault Memory的DTC Table,鼠标放在DTC Table区域,右键点击选择Copy … Reference from Available DTCs…,即可将DTC库中的故障码加载至Variant中。 虽然选择Co

LOVE135149的博客 1万+

从Linux到RT-Thread:环形缓冲区设计的5个关键差异(附性能对比测试)

本文深入对比了Linux内核kfifo与RT-Thread环形缓冲区在嵌入式实时系统中的五大核心设计差异,包括内存模型、线程安全、数据覆盖策略、API设计及性能表现。通过详尽的性能对比测试,为开发者在不同应用场景下选择最合适的ringbuffer实现提供了关键依据。

weixin_29191669的博客 373

【保姆级教程】YOLOv8_OBB旋转目标检测:训练自己的数据集

【保姆级教程】YOLOv8_OBB旋转目标检测:训练自己的数据集

m0_51579041的博客 1万+

STM32标准库移植RT-Thread Nano添加FinSH与控制台

添加过shell后 首先要在 rtconfig.h中定义 #define RT_USING_FINSH 为了方便,串口相关函数添加在board.c中 使用串口中断实现命令的接收 /* * Copyright (c) 2006-2019, RT-Thread Development Team * * SPDX-License-Identifier: Apache-2.0 * * Change Logs: * Date Author Notes * 2017-0

点灯师的博客 2156

【报错解决】OpenClaw 报错 ENOENT: no such file or directory, open ‘/root/.npmrc‘:配置文件路径不存在

本文分析了OpenClaw平台在国产操作系统环境下运行时出现的ENOENT: no such file or directory, open '/root/.npmrc'错误。该问题源于容器环境中root用户的npm配置文件缺失,导致插件依赖安装失败。文章详细解释了npm配置加载机制和容器环境的特殊性,提出了四种解决方案:手动创建配置文件、写入基础配置、使用全局配置替代以及容器启动时自动初始化。最后指出该错误暴露了工程中对默认路径盲目信任的问题,强调显式声明运行环境依赖的重要性。

博客 2016

复数值神经网络可能是深度学习的未来

复数这种东西,在人的头脑中似乎抽象、似乎复杂,然而,对于计算机来说,一点也不抽象,不复杂,那么,将复数概念推广到神经网络会是什么结果呢?本篇介绍国外的一些同行的尝试实践,请我们注意观察他们的进展。

gongdiwudu的专栏 6621

从RT-Thread到Linux:一文吃透环形缓冲区的6种实现变体与选型建议

本文深入剖析了从RT-Thread到Linux系统中环形缓冲区的核心原理与6种主要实现变体,包括字节流、块状、双缓冲、链式、无锁及硬件加速缓冲区。重点对比了RT-Thread的镜像指针法与Linux内核kfifo的2的幂次方优化等设计哲学,并提供了基于不同应用场景(如嵌入式MCU、多核服务器、DMA传输)的实战选型建议与性能优化技巧。

weixin_29161785的博客 282

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

(五)RT-Thread设备驱动实战--IO模型PIN与UART

要点内容I/O设备模型三层架构:管理层 → 框架层 → 驱动层设备操作流程PIN设备writereadattach_irqUART设备支持轮询/中断/DMA三种模式Ringbuffer串口数据缓存利器,注意线程安全自动初始化简化启动流程掌握了设备驱动框架,你就能自如地操控各种硬件外设。

2401_88718801的博客 942

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

告别轮询!用RT-Thread Studio 2.1.0为STM32串口DMA接收打造一个高效的应用层封装

本文详细介绍了如何在RT-Thread Studio 2.1.0环境下为STM32打造高效的串口DMA接收框架,通过模块化设计实现跨平台移植性和线程安全。文章重点讲解了DMA缓冲区管理、空闲中断处理及RT-Thread设备框架下的封装策略,帮助开发者提升串口通信效率并降低CPU占用率。

weixin_30263073的博客 413
上一篇: 电源新手必看5——锂离子电池充电电路设计全解析
下一篇: 图像生成新思路:Masked Diffusion在CIFAR-10上的惊人表现(含与PixelCNN++对比)
jump7
博客等级 码龄1天 0粉丝 1273原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值