FreeRTOS中的空闲任务与阻塞延时(笔记)

已于 2023-05-14 16:58:16 修改
阅读量1.5k 收藏 3
点赞数
分类专栏： STM32 FreeRTOS 文章标签： 笔记 FreeRTOS
于 2023-05-05 23:33:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Naruto_8/article/details/130505843
版权

目录

前言

软件延时是让CPU等待达到延时效果。
而RTOS的优势是可以充分发挥CPU的性能，永远不会让CPU闲着。
RTOS中的延时叫做阻塞延时

空闲任务

当没有其他任务可以运行时，RTOS会为CPU创建一个空闲任务，然后CPU去执行。
在RTOS中，空闲任务是系统在调度器创建的优先级最低的任务，空闲任务主体是主要做一些系统内存的清理工作。

实现空闲任务

1、定义空闲任务栈

在min.c 中定义：

/* 获取空闲任务的内存 */
StackType_t IdleTaskStack[configMINIMAL_STACK_SIZE];
TCB_t IdleTaskTCB;

在FeeRTOSConfig.h中定义的宏

#define configMINIMAL_STACK_SIZE	( ( unsigned short ) 128 )//（字，即512个字节）

2、定义空闲任务的任务控制块

定义空闲任务的任务控制块

TCB_t IdleTaskTCB;

3## 3、定义空闲函数主体
在mask.c 中定义：

#define portTASK_FUNCTION( vFunction, pvParameters ) void vFunction( void *pvParameters )//在protmacro.h
static portTASK_FUNCTION( prvIdleTask, pvParameters ) //prvIdleTask( void *pvParameters )
{
	/* 防止编译器的警告 */
	( void ) pvParameters;
    
    for(;;)
    {
        /* 空闲任务暂时什么都不做 */
    }
}

4、定义空闲任务主体

extern TCB_t IdleTaskTCB;
void vApplicationGetIdleTaskMemory( TCB_t **ppxIdleTaskTCBBuffer, 
                                    StackType_t **ppxIdleTaskStackBuffer, 
                                    uint32_t *pulIdleTaskStackSize );
void vTaskStartScheduler( void )
{
/*======================================创建空闲任务start==============================================*/     
    TCB_t *pxIdleTaskTCBBuffer = NULL;               /* 用于指向空闲任务控制块 */
    StackType_t *pxIdleTaskStackBuffer = NULL;       /* 用于空闲任务栈起始地址 */
    uint32_t ulIdleTaskStackSize;
    
    /* 获取空闲任务的内存：任务栈和任务TCB */
    vApplicationGetIdleTaskMemory( &pxIdleTaskTCBBuffer, 
                                   &pxIdleTaskStackBuffer, 
                                   &ulIdleTaskStackSize );    
    
    xIdleTaskHandle = xTaskCreateStatic( (TaskFunction_t)prvIdleTask,              /* 任务入口 */
					                     (char *)"IDLE",                           /* 任务名称，字符串形式 */
					                     (uint32_t)ulIdleTaskStackSize ,           /* 任务栈大小，单位为字 */
					                     (void *) NULL,                            /* 任务形参 */
					                     (StackType_t *)pxIdleTaskStackBuffer,     /* 任务栈起始地址 */
					                     (TCB_t *)pxIdleTaskTCBBuffer );           /* 任务控制块 */
    /* 将任务添加到就绪列表 */                                 
    vListInsertEnd( &( pxReadyTasksLists[0] ), &( ((TCB_t *)pxIdleTaskTCBBuffer)->xStateListItem ) );
/*======================================创建空闲任务end================================================*/
                                         
    /* 手动指定第一个运行的任务 */
    pxCurrentTCB = &Task1TCB;
                                         
    /* 初始化系统时基计数器 */
    xTickCount = ( TickType_t ) 0U;
    
    /* 启动调度器 */
    if( xPortStartScheduler() != pdFALSE )
    {
        /* 调度器启动成功，则不会返回，即不会来到这里 */
    }
}

vApplicationGetIdleTaskMemory()函数需要用户自己实现：
在main.c中

void vApplicationGetIdleTaskMemory( TCB_t **ppxIdleTaskTCBBuffer, 
                                    StackType_t **ppxIdleTaskStackBuffer, 
                                    uint32_t *pulIdleTaskStackSize )
{
		*ppxIdleTaskTCBBuffer=&IdleTaskTCB;//任务控制块
		*ppxIdleTaskStackBuffer=IdleTaskStack; //任务栈的起始地址
		*pulIdleTaskStackSize=configMINIMAL_STACK_SIZE;//任务栈的大小
}

其中，prvIdleTask在task.c中定义的空闲任务的任务句柄

static TaskHandle_t xIdleTaskHandle					= NULL;//实现空闲任务的任务句柄
  1. 空闲任务只有在CPU空闲时才会执行。
  2. 空闲任务优先级最低是不能被阻塞的。
  3. 空闲任务主要做内存清理等辅助性工作如检查变量等。

实现阻塞延时

阻塞延时是指任务调用该延时函数后，任务会被剥夺CPU的使用权，然后进入阻塞状态，直到延时结束，任务重新获得CPU使用权才继续执行任务。

在FreeRTOS.h中的任务控制块定义中，增加了一个成员，用于记录需要延时的时间

typedef struct tskTaskControlBlock
{
	volatile StackType_t    *pxTopOfStack;    /* 栈顶 */

	ListItem_t			    xStateListItem;   /* 任务节点 */
    
    StackType_t             *pxStack;         /* 任务栈起始地址 */
	                                          /* 任务名称，字符串形式 */
	char                    pcTaskName[ configMAX_TASK_NAME_LEN ];

    TickType_t xTicksToDelay; /* 用于延时 */    
} tskTCB;
typedef tskTCB TCB_t;

vTaskDelay()函数

void vTaskDelay( const TickType_t xTicksToDelay )
{
    TCB_t *pxTCB = NULL;
    
    /* 获取当前任务的TCB */
    pxTCB = pxCurrentTCB;
    
    /* 设置延时时间 */
    pxTCB->xTicksToDelay = xTicksToDelay;
    
    /* 任务切换 */
    taskYIELD();
}

任务与空闲任务切换的例子：vTaskSwitchContext()函数

思路：
如果当前是执行的任务是空闲任务就去尝试执行任务1和任务2，看看这两个任务的延时时间是否结束，如果没有到期，返回继续执行空闲函数。
如果当前是执行的任务是任务1或者任务2，检查一下下一个任务，如果另一个任务不在延时中，就切换到该任务。否则，判断当前任务是否应该进入延时状态，如果是就切换到空闲任务，否则就不做任务切换。

void vTaskSwitchContext( void )
{
	/* 如果当前线程是空闲线程，那么就去尝试执行线程1或者线程2，
       看看他们的延时时间是否结束，如果线程的延时时间均没有到期，
       那就返回继续执行空闲线程 */
	if( pxCurrentTCB == &IdleTaskTCB )
	{
		if(Task1TCB.xTicksToDelay == 0)
		{            
            pxCurrentTCB =&Task1TCB;
		}
		else if(Task2TCB.xTicksToDelay == 0)
		{
            pxCurrentTCB =&Task2TCB;
		}
		else
		{
			return;		/* 线程延时均没有到期则返回，继续执行空闲线程 */
		} 
	}
	else
	{
		/*如果当前线程是线程1或者线程2的话，检查下另外一个线程,如果另外的线程不在延时中，就切换到该线程
        否则，判断下当前线程是否应该进入延时状态，如果是的话，就切换到空闲线程。否则就不进行任何切换 */
		if(pxCurrentTCB == &Task1TCB)
		{
			if(Task2TCB.xTicksToDelay == 0)
			{
                pxCurrentTCB =&Task2TCB;
			}
			else if(pxCurrentTCB->xTicksToDelay != 0)
			{
                pxCurrentTCB = &IdleTaskTCB;
			}
			else 
			{
				return;		/* 返回，不进行切换，因为两个线程都处于延时中 */
			}
		}
		else if(pxCurrentTCB == &Task2TCB)
		{
			if(Task1TCB.xTicksToDelay == 0)
			{
                pxCurrentTCB =&Task1TCB;
			}
			else if(pxCurrentTCB->xTicksToDelay != 0)
			{
                pxCurrentTCB = &IdleTaskTCB;
			}
			else 
			{
				return;		/* 返回，不进行切换，因为两个线程都处于延时中 */
			}
		}
	}
}

SysTick中断服务函数

如果一个任务需要延时，一开始xTicksToDelay肯定不为0，当xTicksToDelay变为0时，表示延时结束。
但是，存在一个问题，xTicksToDelay是以什么周期递减，在哪里递减的。

在FreeRTOS中，这个周期由SysTick中断提供，操作系统中最小的时间单位就是SysTick的中断周期，我们称之为一个tick。
SysTick中断服务函数在port.c中实现。

void xPortSysTickHandler( void )
{
	/* 关中断 */
    vPortRaiseBASEPRI();
    
    /* 更新系统时基 */
    xTaskIncrementTick();

	/* 开中断 */
    vPortClearBASEPRIFromISR();
}

更新系统时基

void xTaskIncrementTick( void )
{
    TCB_t *pxTCB = NULL;
    BaseType_t i = 0;
    
    /* 更新系统时基计数器xTickCount，xTickCount是一个在port.c中定义的全局变量 */
    const TickType_t xConstTickCount = xTickCount + 1;
    xTickCount = xConstTickCount;

    
    /* 扫描就绪列表中所有线程的xTicksToDelay，如果不为0，则减1 */
	for(i=0; i<configMAX_PRIORITIES; i++)
	{
        pxTCB = ( TCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( ( &pxReadyTasksLists[i] ) );
		if(pxTCB->xTicksToDelay > 0)
		{
			pxTCB->xTicksToDelay --;
		}
	}
    
    /* 任务切换 */
    portYIELD();
}

SysTick初始化函数

SysTick的中断服务函数想要被顺利执行，则SysTick必须先初始化。SysTick的初始化函数vPortSetupTimerInterrupt()在port.c中定义

void vPortSetupTimerInterrupt( void )
{
     /* 设置重装载寄存器的值 */
    portNVIC_SYSTICK_LOAD_REG = ( configSYSTICK_CLOCK_HZ / configTICK_RATE_HZ ) - 1UL;
    
    /* 设置系统定时器的时钟等于内核时钟
       使能SysTick 定时器中断
       使能SysTick 定时器 */
    portNVIC_SYSTICK_CTRL_REG = ( portNVIC_SYSTICK_CLK_BIT | 
                                  portNVIC_SYSTICK_INT_BIT |
                                  portNVIC_SYSTICK_ENABLE_BIT ); 
}

configSYSTICK_CLOCK_HZ 为系统时钟，port.c中被重定义

#ifndef configSYSTICK_CLOCK_HZ
	#define configSYSTICK_CLOCK_HZ configCPU_CLOCK_HZ
	/* 确保SysTick的时钟与内核时钟一致 */
	#define portNVIC_SYSTICK_CLK_BIT	( 1UL << 2UL )
#else
	#define portNVIC_SYSTICK_CLK_BIT	( 0 )
#endif

其中，configCPU_CLOCK_HZ的原始定义在FreeRTOSconfig.h中定义

#define configCPU_CLOCK_HZ			( ( unsigned long ) 25000000 )

configTICK_RATE_HZ 为系统时基，在FreeRTOSconfig.h中定义

#define configTICK_RATE_HZ			( ( TickType_t ) 100 )

这里系统时钟频率为25Mhz，即1s有25000000Tick，那么1ms就有25000Tick。而每个周期中断100次，中断周期为25Mhz/100=250000Tick，因此中断一次为250000Tick/25000Tick=10ms.

可以参考《STM32F10xxx Cortex-M3 programming manual》手册，在port.c中定义为偏移：

#define portNVIC_SYSTICK_INT_BIT			( 1UL << 1UL )
#define portNVIC_SYSTICK_ENABLE_BIT			( 1UL << 0UL )

实验

把软件延时替换时钟延时

#include "FreeRTOS.h"
#include "task.h"

extern List_t pxReadyTasksLists[ configMAX_PRIORITIES ];

TaskHandle_t Task1_Handle;
#define TASK1_STACK_SIZE                    128
StackType_t Task1Stack[TASK1_STACK_SIZE];
TCB_t Task1TCB;

TaskHandle_t Task2_Handle;
#define TASK2_STACK_SIZE                    128
StackType_t Task2Stack[TASK2_STACK_SIZE];
TCB_t Task2TCB;

void delay (uint32_t count);
void Task1_Entry( void *p_arg );
void Task2_Entry( void *p_arg );

int main(void)
{	
    /* 硬件初始化 */
	/* 将硬件相关的初始化放在这里，如果是软件仿真则没有相关初始化代码 */
    
    /* 初始化与任务相关的列表，如就绪列表 */
    prvInitialiseTaskLists();
    
    /* 创建任务 */
    Task1_Handle = xTaskCreateStatic( (TaskFunction_t)Task1_Entry,   /* 任务入口 */
					                  (char *)"Task1",               /* 任务名称，字符串形式 */
					                  (uint32_t)TASK1_STACK_SIZE ,   /* 任务栈大小，单位为字 */
					                  (void *) NULL,                 /* 任务形参 */
					                  (StackType_t *)Task1Stack,     /* 任务栈起始地址 */
					                  (TCB_t *)&Task1TCB );   /* 任务控制块 */
    /* 将任务添加到就绪列表 */                                 
    vListInsertEnd( &( pxReadyTasksLists[1] ), &( ((TCB_t *)(&Task1TCB))->xStateListItem ) );
                                
    Task2_Handle = xTaskCreateStatic( (TaskFunction_t)Task2_Entry,   /* 任务入口 */
					                  (char *)"Task2",               /* 任务名称，字符串形式 */
					                  (uint32_t)TASK2_STACK_SIZE ,   /* 任务栈大小，单位为字 */
					                  (void *) NULL,                 /* 任务形参 */
					                  (StackType_t *)Task2Stack,     /* 任务栈起始地址 */
					                  (TCB_t *)&Task2TCB );   /* 任务控制块 */
    /* 将任务添加到就绪列表 */                                 
    vListInsertEnd( &( pxReadyTasksLists[2] ), &( ((TCB_t *)(&Task2TCB))->xStateListItem ) );
                                      
    /* 启动调度器，开始多任务调度，启动成功则不返回 */
    vTaskStartScheduler();                                      
    
    for(;;)
	{
		/* 系统启动成功不会到达这里 */
	}
}

/* 软件延时 */
void delay (uint32_t count)
{
	for(; count!=0; count--);
}
/* 任务1 */
void Task1_Entry( void *p_arg )
{
	for( ;; )
	{
#if 0        
		flag1 = 1;
		delay( 100 );		
		flag1 = 0;
		delay( 100 );
		
		/* 线程切换，这里是手动切换 */
        portYIELD();
#else
		flag1 = 1;
        vTaskDelay( 2 ); //延时20ms
		flag1 = 0;
        vTaskDelay( 2 );
#endif        
	}
}

/* 任务2 */
void Task2_Entry( void *p_arg )
{
	for( ;; )
	{
#if 0        
		flag2 = 1;
		delay( 100 );		
		flag2 = 0;
		delay( 100 );
		
		/* 线程切换，这里是手动切换 */
        portYIELD();
#else
		flag2 = 1;
        vTaskDelay( 2 );		
		flag2 = 0;
        vTaskDelay( 2 );
#endif        
	}
}

/* 获取空闲任务的内存 */
StackType_t IdleTaskStack[configMINIMAL_STACK_SIZE];
TCB_t IdleTaskTCB;
void vApplicationGetIdleTaskMemory( TCB_t **ppxIdleTaskTCBBuffer, 
                                    StackType_t **ppxIdleTaskStackBuffer, 
                                    uint32_t *pulIdleTaskStackSize )
{
		*ppxIdleTaskTCBBuffer=&IdleTaskTCB;
		*ppxIdleTaskStackBuffer=IdleTaskStack; 
		*pulIdleTaskStackSize=configMINIMAL_STACK_SIZE;
}

仿真

在这里插入图片描述
宏观上看几乎是同时运行的

从微观上看
在这里插入图片描述
在这里插入图片描述
高低电平是几近20ms的，实验结果与代码相符。

学习于《FreeRTOS内核实现与应用开发实战指南–基于stm32》
b站视频地址：https://www.bilibili.com/video/BV1Jx411X7NS/

Asita_c
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
跟着野火学FreeRTOS：第一段（空闲任务与阻塞延时的实现）
12-21
跟着野火学FreeRTOS：第一段（空闲任务与阻塞延时的实现）
FreeRTOS延时
sscb0521的博客
06-20 142
将当前任务添加到阻塞列表pxDelayedTaskList，任务进入阻塞态。FreeRTOS的系统时钟节拍计数器是xTickCount，在SysTick中断加1。将当前任务添加到阻塞列表pxDelayedTaskList，任务进入阻塞态。
FreeRTOS高级篇9---FreeRTOS系统延时分析
热门推荐
朱工的专栏
06-18 7万+
FreeRTOS提供了两个系统延时函数：相对延时函数vTaskDelay()和绝对延时函数vTaskDelayUntil()。相对延时是指每次延时都是从任务执行函数vTaskDelay()开始，延时指定的时间结束；绝对延时是指每隔指定的时间，执行一次调用vTaskDelayUntil()函数的任务。换句话说：任务以固定的频率执行。在《FreeRTOS系列第11篇---FreeRTOS任务控制》一文...
FreeRTOS笔记（八）任务通知
m0_58575472的博客
06-08 63
我们使用队列、信号量、事件组等等方法时，并不知道对方是谁。使用任务通知时，可以明确指定：通知哪个任务。
【11】FreeRTOS的延时函数
小浪宝宝的博客
02-22 3486
函数描述相对延时绝对延时相对延时：指每次延时都是从执行函数vTaskDelay()开始，直到延时指定的时间结束（任务被阻塞的时间，到调用此函数开始的时间）；绝对延时：指将整个任务的运行周期看成一个整体，适用于需要按照一定频率运行的任务（整个任务执行的时间，从头到尾的时间）。[^1]上图中的为绝对延时时间（假如绝对延时时间为100ms，那么以下三部分之和为100ms），包括以下三部分：(1)为任务主体，也就是任务真正要做的工作；
FreeRTOS的学习（五）——系统延时
LEOD的博客
05-04 6607
在前面的学习过程中大概了解了FreeRTOS的每个任务可以相互独立的编程，通过系统定时中断进行任务级别的切换。其中延时函数vTaskDelay()作为FreeRTOS的延时函数，其也具有任务切换的功能，即延时函数会将当前任务放入阻塞态等待延时时间结束，然后重新将该任务放入就绪态，按优先级运行。 freeRTOS的系统延时又分为两种模式：一种是相对模式，容易由于任务主体时间影响而导致任务执行的时间太长。另一种是绝对模式，绝对模式可以很好的解决相对模式的问题，因为其延时时间是一个周期值，即任务周期运行的时间，
浅析 FreeRTOS SysTick 和任务延时
wangyx1234的博客
10-14 5202
FreeRTOS 提供的最小时间单元为一个 SysTick，举例：假设配置 RTOS 的 SysTick 为 100Hz，则 RTOS 能提供的最小时间单位为 1/100 s，即 10ms. 即一个 RTOS 的系统始终为 10ms.上述示例计算code()共消耗了多少个 SysTick，假设当前的 SysTick 为 上述的 100Hz，当前消耗了 10个 SysTick，则实际消耗时间为 10* 10ms = 100ms.将 10 SysTick 转为 ms 单位，使用即可。
【FreeRTOS】03 任务的运行、就绪、阻塞、挂起
小白白学电子
05-08 1万+
讲到操作系统的任务，就不得不提任务的状态和切换，这是操作系统的最核心功能。本节将会重点讲解freeRTOS任务的几种状态——运行、就绪、阻塞、挂起。
FreeRTOS-时间片与任务阻塞的实现
k666499436的博客
10-08 6000
本文将详细阐述FreeRTOS多优先级的实现，时间片的轮转，以及深入理解任务在就绪态与阻塞态如何相互转换，这一切的本质都基于链表，然后在加上一些简单的算法，只要掌握了链表一切都不是什么大问题。《FreeRTOS-链表的源码解析》《FreeRTOS-实现任务调度器》1.定义延时链表与延时链表指针2.任务延时链表初始化prvInitialiseTaskLists()函数。
FreeRTOS实时操作系统（九）时间延时函数及消息队列
贾saisai的博客
07-02 905
队列是任务到任务、任务到中断、中断到任务数据交流的一种机制（消息传递）一般情况下，全局变量的数据无保护，导致数据不安全，当多个任务同时对该变量操作时，数据易受损。当然，如果每次我们都采用临界区代码保护也可以，但是读写队列自带这样的操作，用起来简便在队列中可以存储数量有限、大小固定的数据。队列中的每一个数据叫做“队列项目”，队列能够存储“队列项目”的最大数量称为队列的长度，在创建队列时，指定队列长度以及队列项目的大小。
NXP i.MX RT1052 FreeRTOS实战：空闲任务与阻塞延时的实现
12-01
NXP i.MX RT1052 FreeRTOS实战。NXP i.MX RT1052驱动程序。资源代码可直接编译、运行。
空闲任务与阻塞延时（1）.zip
06-28
这是配合我的一篇文章的代码，配合使用效果更佳。欢迎下载学习！如有错误，欢迎批评指正！欢迎交流学习！您的鼓励是我创作的动力！
stm32f103 FreeRTOS空闲任务钩子函数实验.zip
03-07
此程序为STM32F103 移植FreeRTOS系统工程源码，有需要可以学习参考，特别适合刚入门， 或者还没有入门的单片机开发者，可以提高代码开发周期，提升编程水平
基于 FreeRTOS任务挂起和恢复程序设计_freertos_FreeRTOS任务挂起与恢复_
10-02
基于STM32F407的FreeRTOS的任务挂起与恢复的程序设计，下载后可直接在STM32 F4上跑。
java学习笔记13
最新发布
hanq2016的博客
05-04 432
java学习笔记，持续更新，非常完整，Math, Random
python学习笔记----循环语句（四）
取个名字太难了a的博客
04-28 1067
随机数种子在生成随机数的过程中起到一个非常重要的作用。它是用于初始化随机数生成算法（伪随机数生成器）的初始值。随机数种子的作用可重复性：当你使用特定的种子值初始化随机数生成器时，即使在不同的运行环境或不同时间，生成的随机数序列都将是相同的。这对于调试和测试非常重要，因为它允许程序的行为在使用随机数时保持一致。控制随机性：种子提供了一种方法来控制随机数生成过程。通过改变种子，你可以获得不同的随机数序列，这对于模拟和其他需要随机输入的应用非常有用。
Spring Cloud学习笔记（Hystrix）：execute，queue，observe，toObservable样例和特性
sinat_38393872的博客
04-29 706
这是本人学习的总结，主要学习资料如下马士兵教育。
公文写作笔记
332295505的博客
04-29 219
最后一行的日期，后边占4个格子。落款单位在日期的正上方。③结尾：简单的总结（字数紧张时，可以省略）②主题：对策（别人做得好，就借鉴）
python学习笔记----函数进阶（七）
取个名字太难了a的博客
05-01 498
假设我们正在编写一个购物应用，需要根据不同的促销策略来计算商品的最终价格。我们可以定义几种不同的促销计算函数，然后将这些函数作为参数传递给另一个函数，这个函数负责应用这些促销策略来显示最终价格。
freertos 中 空闲任务函数 prvidletask（）具体内容是啥
07-11
在 FreeRTOS 中，空闲任务函数 `prvidletask()` 是由 FreeRTOS 内核自动创建和管理的一个特殊任务。它的主要作用是在系统没有其他任务可运行时执行一些低优先级的操作，以充分利用处理器资源。 `prvidletask()` 的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Asita_c

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值