编码开关驱动

最新推荐文章于 2024-06-02 23:59:45 发布
最新推荐文章于 2024-06-02 23:59:45 发布
阅读量2k 收藏 3
点赞数 1
分类专栏： linux 文章标签： linux 编码开关
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/azad_yj/article/details/17962699
版权

曾经做amlogic方案时，给一个客户调试过一个编码开关的驱动，两个编码开关，使用四个GPIO口去通过中断检查。代码如下：

在BSP文件中增加如下内容：


#if defined(CONFIG_CODING_KEY_AM) 
#include <linux/input.h>
#include <linux/input/coding_key.h>

#define GPIO_CODING_KEYIRQ1  ((GPIOB_bank_bit0_7(4)<<16) | GPIOB_bit_bit0_7(4)) 
#define GPIO_CODING_KEYIRQ2  ((GPIOB_bank_bit0_7(5)<<16) | GPIOB_bit_bit0_7(5)) 
#define GPIO_CODING_KEYIRQ3  ((GPIOB_bank_bit0_7(6)<<16) | GPIOB_bit_bit0_7(6)) 
#define GPIO_CODING_KEYIRQ4  ((GPIOB_bank_bit0_7(7)<<16) | GPIOB_bit_bit0_7(7)) 
int _key_coding_list[] = {KEY_DOWN,KEY_UP,KEY_RIGHT,KEY_LEFT};


static int read_key_value_num1(void)
{
	int keyirq1,keyirq3;
	udelay(100);
	keyirq1=gpio_get_value(GPIO_CODING_KEYIRQ1);
	udelay(100);	
	keyirq3=gpio_get_value(GPIO_CODING_KEYIRQ3);	

	
	return (keyirq1+(keyirq3<<1));
}

static int read_key_value_num2(void)
{
	int keyirq2,keyirq4;
	udelay(100);
	keyirq2=gpio_get_value(GPIO_CODING_KEYIRQ2);
	udelay(100);	
	keyirq4=gpio_get_value(GPIO_CODING_KEYIRQ4);	

	
	return (keyirq2+(keyirq4<<1));
}

/**
*
*编码开关说明：
*
*coding_key_init_func 是为了初始化，设置中断方式和中断号，四个用于编码开关的四个IO口
*M1	总共有8个IO口中断，分别对应INT_GPIO_0~7  
*gpio_enable_edge_int 是用来设置中断触发方式和对应中断号
*因为引脚是复用脚，在使用时需要清掉其复用功能
*
*azad   2011.12.11
*
**/
static  int coding_key_init_func(void)
{
    /* set input mode */
    CLEAR_CBUS_REG_MASK(PERIPHS_PIN_MUX_2, 1<<19);
    CLEAR_CBUS_REG_MASK(PERIPHS_PIN_MUX_2, 1<<18);
    CLEAR_CBUS_REG_MASK(PERIPHS_PIN_MUX_2, 1<<17);
    CLEAR_CBUS_REG_MASK(PERIPHS_PIN_MUX_2, 1<<16);  //clear SD_D0_C[19:16]
    

    CLEAR_CBUS_REG_MASK(PERIPHS_PIN_MUX_6, 1<<27);  //clear SPI
    
    CLEAR_CBUS_REG_MASK(PERIPHS_PIN_MUX_2, 1<<23);
    CLEAR_CBUS_REG_MASK(PERIPHS_PIN_MUX_2, 1<<22);
    CLEAR_CBUS_REG_MASK(PERIPHS_PIN_MUX_2, 1<<21);
    CLEAR_CBUS_REG_MASK(PERIPHS_PIN_MUX_2, 1<<20);
    
    CLEAR_CBUS_REG_MASK(PERIPHS_PIN_MUX_11, 1<<9);
    CLEAR_CBUS_REG_MASK(PERIPHS_PIN_MUX_11, 1<<8);
    CLEAR_CBUS_REG_MASK(PERIPHS_PIN_MUX_11, 1<<7);
    CLEAR_CBUS_REG_MASK(PERIPHS_PIN_MUX_11, 1<<6);


    gpio_direction_input(GPIO_CODING_KEYIRQ1);
    gpio_direction_input(GPIO_CODING_KEYIRQ2);
    gpio_direction_input(GPIO_CODING_KEYIRQ3);
    gpio_direction_input(GPIO_CODING_KEYIRQ4);

    /* set gpio interrupt #1 source=GPIOB_4, and triggered by falling edge(=1) */
    gpio_enable_edge_int(gpio_to_idx(GPIO_CODING_KEYIRQ1), 1, 1);

    /* set gpio interrupt #2 source=GPIOB_5, and triggered by falling edge(=1) */
    gpio_enable_edge_int(gpio_to_idx(GPIO_CODING_KEYIRQ2), 1, 2);

    /* set gpio interrupt #3 source=GPIOB_6, and triggered by falling edge(=1) */
    gpio_enable_edge_int(gpio_to_idx(GPIO_CODING_KEYIRQ3), 1, 3);

    /* set gpio interrupt #4 source=GPIOB_7, and triggered by falling edge(=1) */
    gpio_enable_edge_int(gpio_to_idx(GPIO_CODING_KEYIRQ4), 1, 4);

    return 0;
}


static  struct coding_key_platform_data  coding_key_pdata = {
    .key_code_list = &_key_coding_list[0],
    .key_num = ARRAY_SIZE(_key_coding_list),
    .init_irq = coding_key_init_func,
    .read_key1=read_key_value_num1,
    .read_key2=read_key_value_num2,
};

static struct platform_device coding_device_key = {
    .name = "coding_key",
    .id = 0,
    .num_resources = 0,
    .resource = NULL,
    .dev = {
        .platform_data = &coding_key_pdata,
    }
};
#endif

驱动的代码如下：

/*
 * linux/drivers/input/key_input/key_input.c
 *
 * GPIO Coding Key Driver
 *
 * Copyright (C) 2011 EC3 Corporation
 *
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 * author :   azad Yu
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/types.h>
#include <linux/input.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/mutex.h>
#include <linux/errno.h>
#include <asm/irq.h>
#include <asm/io.h>

#include <mach/am_regs.h>
#include <mach/pinmux.h>
#include <linux/major.h>
#include <linux/slab.h>
#include <asm/uaccess.h>

#include <linux/module.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/types.h>
#include <linux/input.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/mutex.h>
#include <linux/errno.h>
#include <asm/irq.h>
#include <asm/io.h>

#include <mach/am_regs.h>
#include <mach/pinmux.h>
#include <linux/major.h>
#include <linux/slab.h>
#include <asm/uaccess.h>
#include <linux/input/coding_key.h>


static void codingkey_tasklet(unsigned long data);
DECLARE_TASKLET_DISABLED(coding_tasklet, codingkey_tasklet, 0);


struct coding_key {
    struct input_dev *input;
    int major;
    char name[20];
    struct class *class;
    struct device *dev;
    struct coding_key_platform_data *pdata;
};

static struct coding_key *CodingKey = NULL;



static read_coding_key_num1(unsigned long data)
{
	static unsigned char st_num1 =0;
	static unsigned char cw_d_num1 = 0x03;
	unsigned  char  sw_data_num1;

	struct coding_key *coding_data=(struct coding_key *)data;

	sw_data_num1=coding_data->pdata->read_key1();
    
	if(sw_data_num1 == 0x03)
		st_num1=1;

	//printk("the state of the st = %d..sw_data =%d ..cw_d =%d..\n",st,sw_data,cw_d);

	if(st_num1)
	{
		if((sw_data_num1==0x00)&&(cw_d_num1==0x02))
			{
				st_num1=0;
				printk("================up==============\n");
        			input_report_key(coding_data->input, coding_data->pdata->key_code_list[0], 1);
        			input_report_key(coding_data->input, coding_data->pdata->key_code_list[0], 0);

			}
		if((sw_data_num1==0x02)&&(cw_d_num1==0x00))
			{
				st_num1=0;
				printk("===============down=============\n");
        			input_report_key(coding_data->input, coding_data->pdata->key_code_list[1], 1);
        			input_report_key(coding_data->input, coding_data->pdata->key_code_list[1], 0);
			}

	}

	cw_d_num1 = sw_data_num1;


}


static read_coding_key_num2(unsigned long data)
{
	static unsigned char st_num2 =0;
	static unsigned char cw_d_num2 = 0x03;
	unsigned  char  sw_data_num2;

	struct coding_key *coding_data=(struct coding_key *)data;

	sw_data_num2=coding_data->pdata->read_key2();
    
	if(sw_data_num2 == 0x03)
		st_num2=1;

	//printk("the state of the st = %d..sw_data =%d ..cw_d =%d..\n",st,sw_data,cw_d);

	if(st_num2)
	{
		if((sw_data_num2==0x00)&&(cw_d_num2==0x02))
			{
				st_num2=0;
				printk("================up==============\n");
        			input_report_key(coding_data->input, coding_data->pdata->key_code_list[2], 1);
        			input_report_key(coding_data->input, coding_data->pdata->key_code_list[2], 0);

			}
		if((sw_data_num2==0x02)&&(cw_d_num2==0x00))
			{
				st_num2=0;
				printk("===============down=============\n");
        			input_report_key(coding_data->input, coding_data->pdata->key_code_list[3], 1);
        			input_report_key(coding_data->input, coding_data->pdata->key_code_list[3], 0);
			}

	}

	cw_d_num2 = sw_data_num2;


}

static void codingkey_tasklet(unsigned long data)
{


	read_coding_key_num1(data);
	read_coding_key_num2(data);

}

static irqreturn_t coding_key_interrupt(int irq, void *dev)
{

        tasklet_schedule(&coding_tasklet);


    return IRQ_HANDLED;
}
static int
coding_key_open(struct inode *inode, struct file *file)
{
    file->private_data = CodingKey;
    return 0;
}

static int
coding_key_release(struct inode *inode, struct file *file)
{
    file->private_data=NULL;
    return 0;
}

static const struct file_operations coding_key_fops = {
    .owner      = THIS_MODULE,
    .open       = coding_key_open,
    .ioctl      = NULL,
    .release    = coding_key_release,
};
static int register_key_input_dev(struct coding_key  *coding_data)
{
    int ret=0;
    strcpy(coding_data->name,"coding_key_input");
    ret=register_chrdev(0, coding_data->name, &coding_key_fops);
    if(ret<=0)
    {
        printk("register char device error\r\n");
        return  ret ;
    }
    coding_data->major=ret;
    printk("key_input major:%d\r\n",ret);
    coding_data->class=class_create(THIS_MODULE,coding_data->name);
    coding_data->dev=device_create(coding_data->class, NULL,
    		MKDEV(coding_data->major,0), NULL, coding_data->name);
    return ret;
}

static int __init coding_key_probe(struct platform_device *pdev)
{
    struct coding_key  *coding_data = NULL;
    struct input_dev *input_dev = NULL;
    int i,ret = 0;
    struct coding_key_platform_data *pdata = pdev->dev.platform_data;

    if (!pdata) {
        dev_err(&pdev->dev, "platform data is required!\n");
        ret = -EINVAL;
        goto    CATCH_ERR;
    }
    
    coding_data = kzalloc(sizeof(struct coding_key), GFP_KERNEL);
    input_dev = input_allocate_device();
    if (!coding_data ) {
        ret = -ENOMEM;
        goto    CATCH_ERR;
    }
    CodingKey = coding_data;

    platform_set_drvdata(pdev, coding_data);
    coding_data->input = input_dev;
    coding_data->pdata = pdata;

    if(coding_data->pdata->init_irq != NULL)
    {
        if(coding_data->pdata->init_irq() < 0)
        {
            printk(KERN_ERR "coding_data->pdata->init_irq() failed.\n");
            ret = -EINVAL;
            goto    CATCH_ERR;
        }
    }


    /* setup input device */
    set_bit(EV_KEY, input_dev->evbit);
    set_bit(EV_REP, input_dev->evbit);

    for(i = 0; i < pdata->key_num; i++)
    {
        set_bit(pdata->key_code_list[i], input_dev->keybit);
        printk(KERN_INFO "Key %d registed.\n", pdata->key_code_list[i]);
    }
    
    input_dev->name = "coding_key";
    input_dev->phys = "coding_key/input0";
    input_dev->dev.parent = &pdev->dev;

    input_dev->id.bustype = BUS_ISA;
    input_dev->id.vendor = 0x0001;
    input_dev->id.product = 0x0001;
    input_dev->id.version = 0x0100;

    input_dev->rep[REP_DELAY]=0xffffffff;
    input_dev->rep[REP_PERIOD]=0xffffffff;

    input_dev->keycodesize = sizeof(unsigned short);
    input_dev->keycodemax = 0x1ff;

    ret = input_register_device(coding_data->input);
    if (ret < 0) {
        printk(KERN_ERR "Unable to register key input device.\n");
        ret = -EINVAL;
        goto    CATCH_ERR;
    }



        tasklet_enable(&coding_tasklet);
        coding_tasklet.data = (unsigned long)CodingKey;
        //ret = request_irq(INT_GPIO_1, (irq_handler_t) coding_key_interrupt, IRQF_TRIGGER_FALLING, "coding key", coding_data);
        ret = request_irq(INT_GPIO_1, (irq_handler_t) coding_key_interrupt, IRQF_TRIGGER_FALLING, "coding key", NULL);
        ret = request_irq(INT_GPIO_2, (irq_handler_t) coding_key_interrupt, IRQF_TRIGGER_FALLING, "coding key", NULL);
        ret = request_irq(INT_GPIO_3, (irq_handler_t) coding_key_interrupt, IRQF_TRIGGER_FALLING, "coding key", NULL);
        ret = request_irq(INT_GPIO_4, (irq_handler_t) coding_key_interrupt, IRQF_TRIGGER_FALLING, "coding key", NULL);
    if (ret < 0) {
        printk(KERN_ERR "Unable to register key input irq.\n");
        ret = -EINVAL;
        goto    CATCH_ERR;
    }


    printk("Key input register input device completed.\r\n");
    register_key_input_dev(CodingKey);
    return 0;

CATCH_ERR:
    if(input_dev)
    {
        input_free_device(input_dev);
    }
    if(coding_data)
    {
        kfree(coding_data);
    }
    return ret;
}

static int coding_key_remove(struct platform_device *pdev)
{
    struct coding_key *coding_data = platform_get_drvdata(pdev);


   
        tasklet_disable(&codingkey_tasklet);
        tasklet_kill(&codingkey_tasklet);
        disable_irq(INT_GPIO_1);
        disable_irq(INT_GPIO_2);
        disable_irq(INT_GPIO_3);
        disable_irq(INT_GPIO_4);
        free_irq(INT_GPIO_1, coding_key_interrupt);
        free_irq(INT_GPIO_2, coding_key_interrupt);
        free_irq(INT_GPIO_3, coding_key_interrupt);
        free_irq(INT_GPIO_4, coding_key_interrupt);


    input_unregister_device(coding_data->input);
    input_free_device(coding_data->input);
    unregister_chrdev(coding_data->major,coding_data->name);
    if(coding_data->class)
    {
        if(coding_data->dev)
        device_destroy(coding_data->class,MKDEV(coding_data->major,0));
        class_destroy(coding_data->class);
    }

    kfree(coding_data);
    CodingKey = NULL ;
    return 0;
}

#ifdef CONFIG_PM
static int coding_key_suspend(struct platform_device *dev, pm_message_t state)
{
    return 0;
}

static int coding_key_resume(struct platform_device *dev)
{
    return 0;
}
#else
#define key_input_suspend NULL
#define key_input_resume  NULL
#endif

static struct platform_driver coding_key_driver = {
    .probe      = coding_key_probe,
    .remove     = coding_key_remove,
    .suspend    = coding_key_suspend,
    .resume     = coding_key_resume,
    .driver     = {
        .name   = "coding_key",
    },
};

static int __devinit coding_key_init(void)
{
    printk(KERN_INFO "coding Key input Driver init.\n");
    return platform_driver_register(&coding_key_driver);
}

static void __exit coding_key_exit(void)
{
    printk(KERN_INFO "codeing Key input Driver exit.\n");
    platform_driver_unregister(&coding_key_driver);
}

module_init(coding_key_init);
module_exit(coding_key_exit);

MODULE_AUTHOR("azad Yu");
MODULE_DESCRIPTION("Key Input Driver");
MODULE_LICENSE("GPL");




azad_yu
关注
专栏目录
编码开关应用
12-05
开发过程中，需要理解编码开关的工作原理，熟悉1602LCD的接口协议，以及编写相应的驱动代码和用户交互逻辑。这样的实践对于学习嵌入式系统和硬件接口编程非常有帮助，也是许多物联网和智能家居设备的基础组成部分。
新唐芯片学习笔记——GPIO
weixin_46009614的博客
01-21 3626
楼主学习的是新唐NUC029LAN芯片。我会把要学习的模块所记录的笔记分享给大家，如果有理解错的地方麻烦大家指出来，我们共同学习、进步。
mtk_拨码开关的驱动调试
look_distance的博客
07-06 305
拨码开关的调试 平台 mtk 6572 kaios 硬件原理图中引脚为 KROW6_EINT14-> GPIO100中断是下降沿触发 DrvGen中设置GPIO100的 Def.Mode为 EINT14 1、kaios_72_normal\vendor\mediatek\proprietary\scripts\dct\EINT_YuSu.cmp [EINT_variabl...
NXP i.MX6 GPIO原理解析及引脚复用
眺望电子_嵌入式技术分享专区
10-12 2078
项目场景： 在眺望电子TW-IMX6DL-EVM开发板上复用GPIO引脚，并分享其原理。 编译环境及开发包： 主机：ubuntu18.04 交叉编译器：arm-linux-gnueabihf-gcc 开发板：TW-IMX6DL-EVM Linux：Linux-4.1.15 注意:本文章的所有命令涉及到的路径均为眺望电子官方环境路径，需根据自身实际环境改变。本文所演示的平台来自于眺望电子 iMX6 ARM嵌入式平台，这是一个基于NXP iMX6 ARM处理器，支持单核/双核Cortex-A9的核心板。
编码开关驱动代码
无聊达的博客
08-20 3980
下图是我正在使用的编码开关的时序图（可能你用的编码开关的时序图是反过来的，这不重要，稍微改一下就能用了）， 其实鉴别编码开关正反转的关键地方就是找到编码开关正反转时序图不同的地方。 可以发现，正转时，A比B快半个波形，反转时，B比A快半个波形。 A、B管脚容易抖动，建议两个引脚各加105电容到地消抖。 第一种的方法： 我们设置A为下降沿中断 当A下降沿时，判断B的状态，若是...
linux 旋转编码器,基于ARM_Linux的旋转编码器接口与驱动程序的设计
weixin_34377186的博客
05-12 412
旋转编码器作为速度和位移反馈的传感器，广泛应用于角位移或角速率的测量，通常有A，B，Z 三相输出。目前，在实际的应用中，旋转编码器多与PLC、单片机、PC 联合组成控制采集系统，如文献［1 － 2］所述的系统中。在这些控制采集系统中，旋转编码器多接到控制器自身的计数器端口，由其软件进行辨向和加减计数，此方案成本较低，但缺点是实时性、安全稳定性不高，适合于功能不高的简单控制系统中。而随着ARM-Li...
BLDC_Code(HALL).zip_BLDC_BLDC_HALL_霍尔编码器_驱动_驱动程序
07-14
驱动程序则是连接硬件和软件的桥梁，对于BLDC电机来说，驱动程序主要负责处理霍尔传感器提供的位置信息，根据电机的工作模式和速度需求生成适当的 PWM（脉宽调制）信号，控制功率开关器件如MOSFET或IGBT，以调整电机...
STM32单片机控制旋转编码开关
05-18
在本主题中，我们将深入探讨如何使用STM32单片机来控制旋转编码开关，实现精确的位置检测和速度反馈。 旋转编码开关，又称增量式编码器，是一种能够检测角度变化并输出脉冲信号的装置。它通常包含一个机械旋转部分...
用于驱动器和编码器的 RS-485 收发器-电路方案
04-20
EMC 抗扰度（尤其是逆变器开关噪声抗扰度）对于工业驱动器中的位置编码器反馈系统而言非常重要。该设计支持 5 至 15V（标称值为 12V）宽输入电压范围（用作到编码器的输出电压），以满足编码器的宽电源范围要求。该...
xinhaofashengqi.rar_12864 信号_51 信号发生器_9850_编码开关
09-24
《51单片机实现的信号发生器：9850模块、12864液晶显示屏与编码开关的应用详解》 在电子工程领域，信号发生器是一种非常重要的工具，用于产生不同频率、波形和幅度的电信号，广泛应用于教学、科研以及设备测试等...
编码器底层驱动程序EC11
03-16
旋转编码器底层驱动程序EC11，直接调用，包含正传，反转，按键，长按，双击功能。测试可用。
基于51_绝对简洁高效的编码开关扫描程序
08-03
介绍一种编码开关的扫描处理，编码开关一般有外部中断和电平查询两种处理。这里介绍的是电平查询的方法，不需要外部中断资源，普通IO口就可以，更加通用简便高效。方案基于STC12LE4052AD 51单片机，适合单片机初学者借鉴参考。
旋转编码开关(Rotary_Encoder_switch)-使用说明及程序
12-10
旋转编码开关(Rotary_Encoder_switch)-使用说明及程序
数字编码开关程序
08-30
MSP430单片机中断边沿触发判断左右旋转，每转一下，相应的加减一位。
基于ARM-Linux的旋转编码器接口与驱动程序的设计.pdf
09-06
基于ARM-Linux的旋转编码器接口与驱动程序的设计.pdf
linux４．６　EC11旋转编码器的驱动
gouqu5156的博客
04-13 3901
最近项目使用了旋转编码器EC11，遍查内核，发现并没有它的驱动，查了查ＣＳＤＮ，终于找到一篇有用的。根据自己的需要和对最基础的gpio_key.c的理解，我改写出了一份EC11的专用驱动。 感谢下面博主的启发，有了这位高人的指点，我才有信心改写成功。并决定向他学习，将自己成功的代码与大家分享。 https://blog.csdn.net/aifei7320/article/details/50...
Linux下的旋钮驱动
Android开发
12-04 3853
先看一次正旋和反旋波形上差异 可以看出两个波形慢了一个相位，如图中，判断正反旋的一种方法如下 绿色信号线下降开始监听黄色的信号线的状态，如果是下降沿，判断为正旋，如果是上升沿，判断为反旋，绿色信号线上升结束一次监听 正旋输出 反旋输出 #include<linux/module.h> #include<li...
Linux 输入设备调试详解（零基础开发）Rotary_Encoder旋转编码器驱动（EC11）通用GPIO为例 挂载input输入子系统
szembed的博客
07-05 1791
项目中需要使用旋转编码器作为控制器，之前在STM32中使用过EC11旋转编码器STM32CubeMX EC11旋转编码器普通IO口外部中断+定时器实现STM32CubeMX EC11旋转编码器开发心路历程（encode模式 外部中断模式 普通IO口模式 定时器模式探索）所以最初在imx6平台上也是想要延续这种设计思路，但是考虑到实际过程中使用两个中断判断直接写驱动来读取会导致漏掉旋转步数因此没有使用直接使用中断来判断的方法。
嵌入式Linux系统下关于旋钮式编码器的驱动实现
最新发布
m0_46566693的博客
06-02 684
嵌入式Linux系统下关于旋钮式编码器的驱动实现
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值