我的RTOS 之七 -- 调度器

最新推荐文章于 2024-08-20 11:49:10 发布
最新推荐文章于 2024-08-20 11:49:10 发布
阅读量1.8k 收藏 1
点赞数
分类专栏： ARM&RTOS 文章标签： os arm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liujia2100/article/details/50706366
版权

做了一个比较简单的调度器. 可以多任务运行，不支持抢占。

由于这个OS不支持抢占，不需要修改中断服务程序，可以方便的嵌入到ARM任何裸机代码或者OS中。


以后再慢慢完善

运行环境: cygwin  skyeye 2410.

底层api， 需要一个定时器和几行汇编即可


在timer中设置一个全局变量 类似linux中的jiffies

volatile unsigned int jiffies;
void timer_handler(void)
{
	static int count = 0;
	jiffies++;
}


调度器的核心汇编，由于没有抢占，所有不需要在中断中做特殊处理

	.extern void *run_stack
	
	.global enter_wd_task
enter_wd_task:	
	mrs		r1,		cpsr
	str		r1,		[r0]
	stmib	r0!,	{r4-r11, r12, r13, r14}
	
	ldr		r0,		=wd_task_stack
	add		r0,		r0,	#(2048*4)
	mov		sp,		r0		
	bl 		wd_task_main

.global exit_wd_task
exit_wd_task:
	ldr		r1,		[r0]
	msr		cpsr,	r1
	add 	r0,		r0, #4
	ldmfd	r0!,	{ r4-r11, r12, r13, pc}
//	bx 		lr	

	
// r0, the task_run stack, r1 the task stack	
	.global enter_task_schedule
enter_task_schedule:	
	mrs		r2,		cpsr
	str		r2,		[r0]
	stmib	r0!,	{r4-r11, r12, r13, r14}

	ldr		r2,		[r1]
	msr		cpsr,	r2
	add		r1,		r1, #4
	ldmfd	r1!,	{r4-r11, r12, r13, r14, pc}

	.global exit_task_schedule
exit_task_schedule:	
	mov		r2,		sp
	mrs		r3,		cpsr
	stmfd	r2!,	{r14}    //pc	
	stmfd	r2!,	{r3, r4-r11, r12, r13, r14}
	str		r2,		[r1]	//save task context
	
	ldr		r2,		[r0]
	msr		cpsr,	r2
	add 	r0,		r0, #4
	ldmfd	r0!,	{ r4-r11, r12, r13, pc}
	
	.global exit_task_func
exit_task_func:
	ldr		r0,		=run_stack
	ldr		r0,		[r0]
	ldr		r2,		[r0]
	msr		cpsr,	r2
	add 	r0,		r0, #4
	ldmfd	r0!,	{ r4-r11, r12, r13, pc}

task结构体和task运行状态的定义

task_struct.h

#ifndef __TASK_STRUCT__
#define __TASK_STRUCT__
#include <list.h>


#define DEFAULT_TASK_STACK_SIZE	1024

extern volatile unsigned int jiffies;

typedef struct arm_stack_struct {
    unsigned int        cpsr;
    unsigned int        r4;
    unsigned int        r5;
    unsigned int        r6;	
    unsigned int        r7;
    unsigned int        r8;
    unsigned int        r9;
    unsigned int        r10;
    unsigned int        r11;
    unsigned int        r12;
	unsigned int 		r13;
    unsigned int        lr;	
	unsigned int 		pc;
} ARM_STACK;

typedef struct task_struct {
	unsigned int	task_id;//control block id
	unsigned int	task_run_count;
	void			*task_stack_ptr;
	void			*task_stack_start;
	void			*task_stack_top;
	unsigned int 	task_stack_size;
	void 	(*task_entry)(void);
	unsigned int 	task_state;	
	unsigned int 	task_cur_time;
	unsigned int 	task_end_time;
	struct list_node thread_list_node;
	struct task_struct	
					*task_struct_next,
					*task_struct_pre;
					
	char			*task_name;
}TASK_STRUCT;

//task state
#define TASK_INIT		1
#define TASK_READY		2
#define TASK_SUSPEND	3
#define TASK_SLEEP		4
#define TASK_RUN		5
#define TASK_DELETE		6
#define TASK_FINISH		7

int wd_task_init(void);
int wd_task_run(void);
void task_sleep(unsigned int delay);
int task_suspend(TASK_STRUCT *t);
int task_resume(TASK_STRUCT *t);
int wd_task_destroy(TASK_STRUCT *t);
TASK_STRUCT *wd_task_create(char *name, void (*entry_fun)(void), unsigned int stack_size);
void wd_task_finish();
#endif

task创建和任务调度代码

wd_task.c

#include <stdio.h>
#include <malloc.h>
#include <task_struct.h>


#define INT_MAXVAL	0xffffffff// for only 49days  in 1ms

TASK_STRUCT *	wd_task_created_ptr;
TASK_STRUCT *	wd_task_created_head;
TASK_STRUCT *	wd_current_task;
static unsigned int task_count_id = 0;
void *run_stack;
extern void exit_task_func();
static void insert_task_list(TASK_STRUCT *t)
{
	TASK_STRUCT * tail;
	
	if(wd_task_created_ptr)
	{
		tail = wd_task_created_ptr->task_struct_pre;
		wd_task_created_ptr->task_struct_pre = t;
		tail->task_struct_next	=	t;
		
		t->task_struct_next = wd_task_created_ptr;
		t->task_struct_pre	= tail;
	
	}
	else
	{
		wd_task_created_ptr = t;
		t->task_struct_next = t;
		t->task_struct_pre	= t;
	}
}
static void remove_task_list(TASK_STRUCT *t)
{
	if(t->task_struct_next == t || t->task_struct_pre == t)
	{
		t = NULL;
	}
	else
	{
		(t->task_struct_next)->task_struct_pre = t->task_struct_pre;
		(t->task_struct_pre)->task_struct_next = t->task_struct_next;
		if(wd_task_created_ptr == t)
			wd_task_created_ptr = t->task_struct_next;
	}
}

TASK_STRUCT *wd_task_create(char *name, void (*entry_fun)(void), unsigned int stack_size)
{

	TASK_STRUCT *t;
	TASK_STRUCT *p_task;
	ARM_STACK *arm_frame;
	void *p_stack;
	unsigned int cpsr;
	
	t = (TASK_STRUCT *)__malloc(sizeof(TASK_STRUCT));
	if(!t)
		return NULL;
	memset(t, 0, sizeof(TASK_STRUCT));
	
	if(stack_size == 0)
		stack_size = DEFAULT_TASK_STACK_SIZE;
	
//	stack_size = (stack_size + 3)&(~0x03);
	p_stack	= (void *)malloc(stack_size);
	if(!p_stack)
		return NULL;
		
	t->task_stack_start			=	p_stack;
	t->task_stack_ptr			=	p_stack;
	t->task_stack_top			=	(void *)(((unsigned int)p_stack + stack_size)&~0x7);
	t->task_stack_size			=	(unsigned int)(t->task_stack_top) - (unsigned int)(t->task_stack_start);
	t->task_id 					= 	task_count_id++;
	t->task_entry 				= 	entry_fun;
	t->task_name				=	name;
	t->task_state				=	TASK_INIT;
	t->task_cur_time			=	jiffies;
	t->task_end_time			=	0;
	t->task_run_count			=	0;
	t->task_struct_next			=	NULL;
	t->task_struct_pre			=	NULL;
	
	arm_frame = (struct arm_stack_struct *)(t->task_stack_top);
	arm_frame --;
	t->task_stack_ptr 			= 	(void *)arm_frame;
	
	memset(arm_frame, 0, sizeof(*arm_frame));
	__asm__ __volatile__("mrs %0, cpsr":"=r"(cpsr));

	arm_frame->cpsr				=	cpsr;
	arm_frame->lr				=	(unsigned int)wd_task_finish;
	arm_frame->pc				=	(unsigned int)entry_fun;
	arm_frame->r13				=	(unsigned int)arm_frame;
	
	if(!wd_task_created_head)
		wd_task_created_head = t;
	else{
		p_task = wd_task_created_head;
		while(p_task->task_struct_next)
		{
			p_task=p_task->task_struct_next;
		}
		p_task->task_struct_next = t;
		
		
	}
	
	return t;
	//insert_task_list(t);
}

//task exec finished, will return to run_task.
void wd_task_finish()
{
	wd_current_task->task_state = TASK_FINISH;
	wd_current_task = NULL;
	exit_task_func();
}

int wd_task_destroy(TASK_STRUCT *t)
{
	if(t->task_state == TASK_FINISH || t->task_state == TASK_DELETE)
		return NULL;
		
	t->task_state = TASK_FINISH;
	if(t == wd_current_task)
	{
		wd_current_task = NULL;
		exit_task_func();
	}
	return 0;
}

static int wd_task_delete(TASK_STRUCT *t)
{
	TASK_STRUCT *pt;
	TASK_STRUCT *tmpt;
	if(!t)
		return -1;
		
	if(t == wd_task_created_head)
	{
		t->task_state = TASK_DELETE;
		wd_task_created_head = t->task_struct_next;
		free(t->task_stack_start);
	}
	else
	{
		for(pt = wd_task_created_head; pt != NULL; pt = pt->task_struct_next)
		{
			if(t == pt->task_struct_next)
				break;
		}
		if(t == pt->task_struct_next)
		{
			if(pt->task_struct_next->task_struct_next)
			{
				tmpt = pt->task_struct_next;
				pt->task_struct_next = pt->task_struct_next->task_struct_next;
				tmpt->task_state = TASK_DELETE;
				free(tmpt->task_stack_start);		
			}
			else
			{
				free(pt->task_struct_next->task_stack_start);
				pt->task_struct_next->task_state = TASK_DELETE;
				pt->task_struct_next = NULL;
			}
		}

	}
	return 0;
}

void dump_task_list()
{
	TASK_STRUCT *t;
	for(t = wd_task_created_head; t != NULL; t = t->task_struct_next)
	{
		printf("task:%s,stack_start:%08x,stack_ptr:%08x, shed_count:%d\n", t->task_name,(unsigned int)t->task_stack_start,(unsigned int)t->task_stack_ptr, t->task_run_count);
	}

}
extern void enter_task_schedule(void *run_stack, void *task_stack);
extern void exit_task_schedule(void *run_stack, void *task_stack);

void task_sleep(unsigned int delay)
{
	wd_current_task->task_state = TASK_SLEEP;
	wd_current_task->task_end_time = jiffies + delay;
	exit_task_schedule(run_stack, (void *)(&(wd_current_task->task_stack_ptr)));
	
}

int task_suspend(TASK_STRUCT *t)
{
//	t->task_end_time = INT_MAXVAL;
	if(t == NULL || t == wd_current_task)
	{	
		t = wd_current_task;
		wd_current_task = NULL;
	}
	else if(t->task_state == TASK_DELETE 
	  ||	t->task_state == TASK_SUSPEND
		)
		return 0;
	
	t->task_state = TASK_SUSPEND;
	exit_task_schedule(run_stack, (void *)(&(t->task_stack_ptr)));
	
	return 0;
}

int task_resume(TASK_STRUCT *t)
{
	
	if(t->task_state == TASK_INIT 
	|| t->task_state == TASK_READY 
	|| t->task_state == TASK_RUN 
	|| t->task_state == TASK_DELETE
	)
		return 0;
	t->task_state = TASK_READY;
//	t->task_end_time = INT_MAXVAL;
//	if(t == wd_current_task)
//	exit_task_schedule(run_stack, (void *)(&(t->task_stack_ptr)));
	
	return 0;
}

int wd_task_init(void)
{
	task_count_id = 0;
	wd_task_created_ptr = NULL;
	wd_task_created_head = NULL;
	
	run_stack = (void *)malloc(1024);
	
	if(!run_stack)
		return -1;
	
	return 0;
}

int wd_task_run(void)
{
	TASK_STRUCT *t;
	int task_mask;
	
	if(!run_stack)
		return -1;
	
	if(!wd_task_created_head)
	{
		printf("No threadx");
		return 0;
	}
	while(1)
	{
		task_mask = 0;
		for(t = wd_task_created_head; t != NULL; t = t->task_struct_next)
		{
			task_mask |= t->task_state;
			if(t->task_state == TASK_FINISH)
			{
				wd_task_delete(t);
				break;
			}
			else if(t->task_state == TASK_INIT
				||	t->task_state == TASK_READY
				||	(t->task_state == TASK_SLEEP && t->task_end_time <= jiffies)
				)
			{
				
				t->task_state = TASK_RUN;
				t->task_run_count++;
				wd_current_task = t;
				if(t->task_state == TASK_SLEEP)
					t->task_end_time = INT_MAXVAL;
				
				enter_task_schedule(run_stack, t->task_stack_ptr);
				break;
			}else if(t->task_state == TASK_RUN)
			{
				printf("This is error\n");
				while(1);
			}
		}
		if(task_mask == 0)
		{
			printf("No threadx, will exit\n");
			break;
		}
	}
	return 0;
}

测试代码

main.c

#include <stdio.h>
#include <malloc.h>
#include <task_struct.h>

void uart_init();
extern volatile int counter;

void delay(unsigned long count)
{
	volatile unsigned long i = count;
	while (i--);
}
void check_register(unsigned int arg1, unsigned int arg2)
{

	printf("arg1=0x%08x, arg2=0x%08x\n", arg1, arg2);

}

extern void exit_wd_task(volatile unsigned int *p);
extern void enter_wd_task(volatile unsigned int *p);
//volatile unsigned int pre_context[20];
volatile unsigned int *wd_task_main_stack;
volatile unsigned int wd_task_stack[2048];

int test[100] = {0};
extern void switest(int arg);
extern int __bss_start;
void wd_test()
{
	if(1)
	{
		wd_task_main_stack = (volatile unsigned int *)malloc(20*sizeof(int));
		if(wd_task_main_stack == NULL)
		{
			printf("malloc error\n");
			return;
		}
		enter_wd_task(wd_task_main_stack);
	}

}

void wd_task_main()
{
	printf("wd_task_main\n");
	exit_wd_task(wd_task_main_stack);
}
TASK_STRUCT *t1;
TASK_STRUCT *t2;
TASK_STRUCT *t3;
TASK_STRUCT *t4;
TASK_STRUCT *t5;

void test1(void)
{
	int i;
	i = 0;
	//while(1)
	//{
		printf("t1 = %d\n", ++i);
//		task_sleep(5);
		printf("t1_1 = %d\n", i);
		dump_task_list();
		printf("t1 game over\n");
	//}
}
void test2(void)
{
	int i;
	i = 0;
	while(1)
	{
		printf("t2 = %d\n", ++i);
		task_sleep(10);
//		printf("t2_1 = %d\n", i);
		if(i == 50)
		{
			printf("t2 resume t3\n");
			task_resume(t3);
			printf("t2 break\n");
			break;
		}	
	}
}
void test3(void)
{
	int i;
	i = 0;
	while(1)
	{
		printf("t3 = %d\n", ++i);
		task_sleep(15);
//		printf("t3_1 = %d\n", i);
		if(i == 5)
		{
			printf("t3 suspend self\n");
			task_suspend(NULL);
			printf("t3 destroy t2\n");
			wd_task_destroy(t2);
		}
		if(i == 10)
		{
			printf("t3 finished\n");
			wd_task_finish();
		}
	}
}

void test4(void)
{
	int i;
	i = 0;
	while(1)
	{
		printf("t4 = %d\n", ++i);
		task_sleep(20);
	//	printf("t4_1 = %d\n", i);
		if(i == 5)
		{
			printf("t1 is suspended\n");
			task_suspend(t1);
		}
		if(i == 10)
		{
			printf("t1 is resumed\n");
			task_resume(t1);
		}		
	}
}

void test5(void)
{
	int i;
	i = 0;
	while(1)
	{
		printf("t5\n");
		dump_task_list();
		task_sleep(10);
	}
}

int main(void)
{
	int temp = 0;
	int i;
	int ret;
	uart_init();
	timer_init();
	enable_irq();
	//printf("__bss_start:0x%08x, addr:0x%08x\n", __bss_start, &__bss_start);
	wd_test();
	
	printf("test over\n");
	ret = wd_task_init();
	if(ret < 0)
		printf("task init fail\n");
	t1 = wd_task_create("t1", test1, 1024);
	t2 = wd_task_create("t2", test2, 1024);
	t3 = wd_task_create("t3", test3, 1024);
	t4 = wd_task_create("t4", test4, 1024);
	t5 = wd_task_create("t5", test5, 1024);
	wd_task_run();
	
	while(1);
	return 0;
}

运行如图：



下载链接：

http://download.csdn.net/detail/liujia2100/9437893

编译命令：make

运行命令： skyeye -e wd_task



liujia2100
关注
专栏目录
FreeRTOS学习：三.任务调度器
m0_46692957的博客
10-27 321
FreeRTOS学习之路三：任务调度器 前面两节讲了任务栈、任务内容、任务列表的联系，当我们创建好多个任务并把它添加到任务列表时，系统是如何来进行任务间的切换与调度。就靠freertos系统里面的调度器进行这项工作。 先看看freertos一般创建任务开始调度的代码流程。 流程就是创建任务，任何启动调度器。xTaskCreateStatic是一个静态内存任务创建函数，在前面已经说过，来看看这个函数的参数。 1.任务入口：也就是函数名，函数名也就代表任务起始地址。 2.任务名称：一段字符串。 3.任务栈大小
RTOS（实时操作系统）--任务调度器
MHD0815的博客
03-21 1043
RTOS（实时操作系统）的任务调度器是系统内核的关键组件，负责管理多个并发执行的任务（也称为线程或进程）。TCB中包含了任务执行所需的所有信息，如任务的状态（就绪、运行、阻塞等）、优先级、堆栈指针、上下文（CPU寄存器的当前值）等。： 当调度器决定切换任务时，它会保存当前任务的CPU上下文（如寄存器状态），然后恢复下一个将要执行的任务的上下文。综上所述，RTOS的任务调度器是实时操作系统中实现多任务并发执行、满足实时性要求的核心部件，它确保了系统能够在有限的硬件资源下有序、高效地管理多个任务的执行流程。
RTOS--常见实时操作系统汇总
最新发布
MHD0815的博客
08-20 731
实时操作系统（RTOS, Real-Time Operating System）是一种特殊类型的操作系统，设计用于满足实时应用的需求，这些应用要求系统能够在确定的时间内响应外部事件。下面是一些常见的RTOS：
FreeRTOS实现调度器
weixin_45589030的博客
02-23 190
调度器是操作系统的核心，主要功能是实现任务的切换，即从就绪列表里面找到优先级最高的任务，然后去执行该任务。 调度器函数实现： void vTaskStartScheduler( void ) { BaseType_t xReturn; /* 添加空闲任务，这块先不看，还没学到 */ #if( configSUPPORT_STATIC_ALLOCATION == 1 ) { StaticTask_t *pxIdleTaskTCBBuffer = NULL; StackType_t *pxIdl
RTOS（实时操作系统）--调度机制
MHD0815的博客
03-21 1526
RTOS（实时操作系统）通过一系列机制来管理任务的状态并调度其他任务。这些机制确保了任务能够按照预定的规则在系统中运行，从而满足实时性的要求。
FreeRTOS 任务与调度器
weixin_42760021的博客
08-12 124
https://www.cnblogs.com/HongYi-Liang/p/9901242.html
基于8051内核的极简RTOS------easyos
12-20
EasyOS是一个针对8051微控制器设计的轻量级实时操作系统（RTOS），它的主要目标是为8051平台提供基本的多任务调度、内存管理和中断处理等功能，使得开发者能够在有限的硬件资源上实现复杂的软件系统。8051内核是一种...
ESP8266资料 ESP8266-RTOS-SDK-3.4
04-27
2. **FreeRTOS**：ESP8266-RTOS-SDK基于FreeRTOS，一个轻量级、开源的RTOS，适合微控制器环境。FreeRTOS提供了任务管理、信号量、互斥锁、队列等功能，支持优先级抢占和时间片轮转调度。 3. ** lwIP 网络栈**：lwIP...
CMSIS-RTOS_Presentation-pdf_rtos_CMSISRTOS_CMSIS-RTOS_
10-03
**CMSIS-RTOS：实时操作系统的核心** CMSIS（Cortex Microcontroller Software Interface Standard）RTOS是ARM公司为嵌入式系统设计的一套实时操作系统（RTOS）API标准，它旨在提供一个统一的接口，使得开发者能够...
ESP8266_RTOS_SDK-v3.4.zip
04-30
RTOS确保了任务调度的确定性，提高了系统的响应速度和稳定性，尤其适合需要处理多并发操作的物联网设备。 3. **SDK概述**: ESP8266_RTOS_SDK包含了编译工具链、驱动程序、库文件以及示例代码，方便开发者进行固件...
RTOS之UCOS（二）---任务调度器
流云
06-03 3036
一、什么是任务调度器 1.1 多任务并行机制 对很多人来说，多任务并行机制挺神秘的，甚至对很多有多线程并发编程经验的工程师来说也是如此。前面我用五篇文章谈了C++多线程并发编程的原理与技巧，但对操作系统的多任务并行机制并没有过多阐述。现在回顾下从单任务顺序执行到多任务并行执行的演变过程，有利于打破多任务并行机制的神秘感。 多任务并行机制从技术上来说就是程序流折断 + 现场（在操作系统里叫上下文）保...
实时操作系统 RTOS的任务调度器的理解
坚韧与专注
04-25 3099
实时操作系统 RTOS的任务调度器的理解
【08】FreeRTOS的任务调度
小浪宝宝的博客
02-04 1762
程序在运行过程中需要一定的栈空间来保存局部变量等一些信息。当有信息保存到栈中时， MCU 会自动更新 SP 指针（也就是R13主堆栈指针（MSP）:它由 OS 内核、异常服务例程以及所有需要特权访问的应用程序代码来使用。进程堆栈指针（PSP）:用于常规的应用程序代码（不处于异常服务例程中时）。在FreeRTOS中，中断使用MSP（主堆栈），中断以外使用PSP（进程堆栈）。在FreeRTOS中使用的是双堆栈指针，裸机无论是进程还是中断都是使用的MSP主堆栈指针。
深入探究RTOS的任务调度
m0_74976404的博客
06-18 1819
阅读引言： 此文将会从一个过程文件， 一步一步的分析RTOS的任务调度实现， 这里选用FreeRTOS分析， 别的也差不多的， 可能在细节上有少许不一样。
FreeRTOS学习——任务调度
qq_47172243的博客
01-09 2790
1. 高优先级任务，优先执行；2. 高优先级任务不停止，低优先级任务无法执行；3. 被抢占的任务将会进入就绪态。
一文带你详细了解FreeRTOS调度器开启过程
m0_73931287的博客
02-24 1461
FreeRTOS任务调度器开启的相关函数、内核相关硬件初始化函数分析、使能FPU的相关函数分析、启动第一个任务、SVC中断服务函数、空闲任务
RTOS关键技术指标
03-09 1090
评价一个实时操作系统的优劣可以用一下几个技术指标来衡量。 1）任务调度算法：一个实时操作系统的任务调度算法，在很大程度上决定了其系统实时性和其多任务调度能力。常用的任务调度算法有优先级调度策略和时间片轮转调度策略；调度的方式可分为抢占式、不可抢占式和选择可抢占式等；常用的调度算法有Rate Monotonic（发生率单调）、优先级与发生率成正比、Lottery Scheduler（彩票调度）等。
RTOS应用中的几种调度策略
qq_41854911的博客
03-07 1090
但使用RTOS有许多优势，例如简化应用集成，支持任务抢占调度，当开发人员使用复杂的32位微控制器，且可以获取足够的Flash和RAM空间时，使用RTOS开始变得有意义。调度程序基于时钟监控任务时间，任务处于相关优先级，按照先进先出的原则执行分配到的时间片，时间到了，即使当前任务还没有完成，任务也将CPU时间传递给下一个任务。任务按优先级排序，并且是事件驱动类型的，一旦正在运行的任务完成，或者任务主动调用OS服务放弃CPU，就绪运行的优先级最高的任务才可以获得CPU使用权。任务切换比中断占用更多的时间。
RTOS与Linux
surper9527的博客
02-06 9567
在嵌入式系统中，我们使用RTOS，而在服务器或个人电脑等性能要求更高的地方我们经常使用Linux，这两者到底有什么区别？本文较详细的介绍了RTOS与Linux系统的特点，并做了简单的对比。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值