控制风扇 马达 蜂鸣器

最新推荐文章于 2024-07-24 20:44:05 发布
最新推荐文章于 2024-07-24 20:44:05 发布
阅读量227 收藏
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59681498/article/details/131564494
版权
该代码示例展示了如何在Linux环境下使用C语言编写设备驱动程序，通过ioctl系统调用来控制LED、风扇、马达和蜂鸣器。程序首先打开指定设备，然后通过循环接收用户输入，根据输入调用ioctl函数执行开/关操作。设备驱动注册了相应的字符设备，并通过ioremap进行内存映射以访问硬件寄存器。
摘要由CSDN通过智能技术生成

test.c

#include<string.h>
#include<stdlib.h>
#include<stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include<unistd.h>
#include "head.h"
#include <sys/ioctl.h>
int main(int argc, char const *argv[])
{
    int a,b;//控制灯
    int c;//控制风扇
     int d;//控制马达
     int f;//控制蜂鸣器
    char buf[128]={0};
    int fd,fd_fan,fd_mada,fd_bee;
    printf("输入要打开设备 0 灯 1 风扇 2 马达 3 蜂鸣器");
      int t;
     scanf("%d",&t);
    switch(t)
    {
      case 0:
     fd=open("/dev/led0",O_RDWR);
     if(fd<0)
     {
        printf("打开失败\n");
        exit(-1);
        
     }
      //从终端读取
      while(1)
      {
        printf("请选择要实现的功能\n");
        printf("请输入要控制的灯\n");
        printf("led1:1 led2:2 led3:3>>");
        scanf("%d",&a);
        printf("0:开灯 1:关灯");
        scanf("%d",&b);

        if(b==1)
        {
            ioctl(fd,LED_ON,&a);//开灯
        }else if(b==0)
        {
           ioctl(fd,LED_OFF,&a);//关灯
        }
      }
        break;
        case 1:
      fd_fan=open("/dev/fan",O_RDWR);
      if(fd_fan<0)
      {
         printf("打开失败\n");
         exit(-1);
      }
      while(1)
      {
       printf("请选择风扇的功能\n");
         printf("0:关 1:开");
        scanf("%d",&c);
        if(c==1)
        {
            ioctl(fd_fan,FAN_ON);
        }else if(c==0)
        {
           ioctl(fd_fan,FAN_OFF);
        }
      }
        break;
        case 2:
       fd_mada=open("/dev/mada",O_RDWR);
       if(fd_mada<0)
      {
         printf("打开失败\n");
         exit(-1);
      }
      while(1)
      {
       printf("请选择马达的功能\n");
         printf("0:关 1:开");
        scanf("%d",&d);
        if(d==1)
        {
            ioctl(fd_mada,MADA_ON);
        }else if(d==0)
        {
           ioctl(fd_mada,MADA_OFF);
        }
      }
        break;
        case 3:
       fd_bee=open("/dev/bee",O_RDWR);
       if(fd_bee<0)
      {
         printf("打开失败\n");
         exit(-1);
      }
      while(1)
      {
      printf("请选择蜂鸣器的功能\n");
         printf("0:关 1:开");
        scanf("%d",&f);
        if(f==1)
        {
            ioctl(fd_bee,BEE_ON);
        }else if(f==0)
        {
           ioctl(fd_bee,BEE_OFF);
        }
      }
        break;

    }
     close(fd);
     close(fd_fan);
     close(fd_mada);
     close(fd_bee);
    return 0;
}

head.h

#ifndef __HEAD_H__
#define __HEAD_H__

typedef struct
{
    unsigned int MODER;
    unsigned int OTYPER;
    unsigned int OSPEEDR;
    unsigned int PUPDR;
    unsigned int IDR;
    unsigned int ODR;
}gpio_t;
#define PHY_LED1_ADDR 0x50006000  //GPIOE
#define PHY_LED2_ADDR 0x50007000  //GPIOF
#define PHY_LED3_ADDR 0x50006000
#define PHY_RCC_ADDR  0x50000A28
#define GPIOE         0X50006000
#define GPIOF         0x50007000
#define GPIOB         0x50003000
#define LED_ON   _IOW('l',1,int) //开灯
#define LED_OFF  _IOW('l',0,int) //关机
#define FAN_ON   _IO('f',1)//吹
#define FAN_OFF  _IO('f',0)//停止
#define MADA_ON  _IO('m',1)
#define MADA_OFF _IO('M',0)
#define BEE_ON   _IO('b',1)
#define BEE_OFF  _IO('b',0)

#endif

led.c

#include<linux/init.h>
#include<linux/module.h>
#include<linux/fs.h>
#include<linux/io.h>
#include<linux/device.h>
#include <linux/uaccess.h>
#include "head.h"
struct class *cls;
struct device *dev;
int major;
char kbuf[128]={0};
gpio_t *vir_led1;
gpio_t *vir_led2;
gpio_t *vir_led3;
unsigned int *vir_rcc;

int mycdev_open (struct inode *inode, struct file *file)
{
   printk("%s %s %d\n",__FILE__,__func__,__LINE__);
   return 0;
}


long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
   int which;
   int ret=copy_from_user(&which,(void*)arg,4);
   if(ret)
   {
      printk("拷贝用户空间数据失败\n");
      return -EIO;
   }
   switch(cmd)
   {
      case LED_ON://开灯
         switch(which)
         {
        case 1:
        vir_led1->ODR|=(0x1<<10);
        break;
         case 2:
        vir_led2->ODR|=(0x1<<10);
        break;
        case 3:
        vir_led3->ODR|=(0x1<<8);
        break;
         }
         break;
        case LED_OFF:
        switch(which)
        {
         case 1:
        vir_led1->ODR&=((~(0x1<<10)));
        break;
        case 2:
        vir_led2->ODR&=((~(0x1<<10)));
        break;
        case 3:
        vir_led3->ODR&=((~(0x1<<8)));
        break;
        }
        break;
   }
   return 0;
}
int mycdev_close (struct inode *inode , struct file * file)
{
     printk("%s %s %d\n",__FILE__,__func__,__LINE__);
   return 0;
}
struct file_operations fops=
{
   .open=mycdev_open,
   .unlocked_ioctl=mycdev_ioctl,
   .release=mycdev_close,

};

int all_led_init(void)
{
   vir_led1=ioremap(PHY_LED1_ADDR,sizeof(gpio_t));
   if(vir_led1==NULL)
   {
      printk("ioremap filed %d\n",__LINE__);
      return -ENOMEM;
   }
   vir_led2=ioremap(PHY_LED2_ADDR,sizeof(gpio_t));
   if(vir_led2==NULL)
   {
      printk("ioremap filed %d\n",__LINE__);
      return -ENOMEM;
   }
   vir_led3=ioremap(PHY_LED3_ADDR,sizeof(gpio_t));
   if(vir_led3==NULL)
   {
      printk("ioremap filed %d\n",__LINE__);
      return -ENOMEM;
   }
   vir_rcc =ioremap(PHY_RCC_ADDR,4);
   if(vir_rcc==NULL)
   {
       printk("ioremap filed %d\n",__LINE__);
      return -ENOMEM;
   }
   printk("物理地址映射成功\n");
   //寄存器初始化rcc
   (*vir_rcc)|=(3<<4);
   //led1
   vir_led1->MODER&=(~(0x3<<20));
   vir_led1->MODER|=(1<<20);
   vir_led1->ODR&=(~(1<<10));
      //led2
   vir_led2->MODER&=(~(0x3<<20));
   vir_led2->MODER|=(1<<20);
   vir_led2->ODR&=(~(1<<10));
      //led3
   vir_led3->MODER&=(~(0x3<<16));
   vir_led3->MODER|=(1<<16);
   vir_led3->ODR&=(~(1<<8));
   printk("寄存器初始化成功\n");
   return 0;
}
static int __init mycdev_init (void)
{
   int i;
   //字符设备驱动注册
   major=register_chrdev(0,"led",&fops);
   if(major<0)
   {
     printk("字符设备驱动注册失败\n");
     return major;
   }
    printk("字符设备驱动注册成功major=%d\n",major);
    //向上提交目录
    cls=class_create(THIS_MODULE,"led");
    if(IS_ERR(cls))
    {
      printk("向上提交目录\n");
      return -PTR_ERR(cls);
    }
    //向上提交设备节点信息
    //为三盏灯创建三个设备文件
    for(i=0;i<3;i++)
    {
     dev=device_create(cls,NULL,MKDEV(major,i),NULL,"led%d",i);
     if(IS_ERR(dev))
     {
      printk("向上提交设备节点信息失败\n");
      return -PTR_ERR(dev);
     }
    }
    all_led_init();
    printk("%d\n",__LINE__);
    return 0;
} 

static void __exit mycdev_exit(void)
{
    int i;
    //取消地址映射
    iounmap(vir_led1);
    iounmap(vir_led2);
    iounmap(vir_led3);
    iounmap(vir_rcc);
    for(i=0;i<3;i++)
    {
        device_destroy(cls,MKDEV(major,i));
    }
    //销毁目录信息
    class_destroy(cls);
    //注销字符设备驱动
    unregister_chrdev(major,"led");
}
module_init(mycdev_init);
module_exit (mycdev_exit);
MODULE_LICENSE("GPL");

fan.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include "head.h"
struct class *cls;
struct device *dev;
int major;
gpio_t *vir_gpioe;
unsigned int *vir_rcc;

int mycdev_open(struct inode *inode, struct file *file)
{
   printk("%s %s %d\n", __FILE__, __func__, __LINE__);
   return 0;
}

long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{

   switch (cmd)
   {
   case FAN_ON:
      vir_gpioe->ODR |= (0X1 << 9);
      break;
   case FAN_OFF:
      vir_gpioe->ODR &= (~(0X1 << 9));
      break;
   }
   return 0;
}
int mycdev_close(struct inode *inode, struct file *file)
{
   printk("%s %s %d\n", __FILE__, __func__, __LINE__);
   return 0;
}
struct file_operations fops =
    {
        .open = mycdev_open,
        .unlocked_ioctl = mycdev_ioctl,
        .release = mycdev_close,

};

static int __init mycdev_init(void)
{

   // 字符设备驱动注册
   major = register_chrdev(0, "fan", &fops);
   if (major < 0)
   {
      printk("字符设备驱动注册失败\n");
      return major;
   }
   printk("字符设备驱动注册成功major=%d\n", major);
   // 向上提交目录
   cls = class_create(THIS_MODULE, "fan");
   if (IS_ERR(cls))
   {
      printk("向上提交目录失败\n");
      return -PTR_ERR(cls);
   }
   // 向上提交设备节点信息
   dev = device_create(cls, NULL, MKDEV(major, 0), NULL, "fan");
   if (IS_ERR(dev))
   {
      printk("向上提交设备节点失败\n");
      return -PTR_ERR(dev);
   }
   vir_gpioe = ioremap(PHY_LED1_ADDR, sizeof(gpio_t));
   if (vir_gpioe == NULL)
   {
      printk("ioremap filed %d\n", __LINE__);
      return -ENOMEM;
   }
   vir_rcc = ioremap(PHY_RCC_ADDR, 4);
   if (vir_rcc == NULL)
   {
      printk("ioremap filed %d\n", __LINE__);
      return -ENOMEM;
   }
   (*vir_rcc) |= (1 << 4);
   // led1
   vir_gpioe->MODER &= (~(0x3 << 18));
   vir_gpioe->MODER |= (1 << 18);
   vir_gpioe->ODR &= (~(1 << 9));
   return 0;
}

static void __exit mycdev_exit(void)
{
   // 取消地址映射
   iounmap(vir_gpioe);
   iounmap(vir_rcc);

   device_destroy(cls, MKDEV(major, 0));
   // 销毁目录信息
   class_destroy(cls);
   // 注销字符设备驱动
   unregister_chrdev(major, "fan");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

mada.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include "head.h"
struct class *cls;
struct device *dev;
int major;
gpio_t *vir_gpiof;
unsigned int *vir_rcc;

int mycdev_open(struct inode *inode, struct file *file)
{
   printk("%s %s %d\n", __FILE__, __func__, __LINE__);
   return 0;
}

long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{

   switch (cmd)
   {
   case MADA_ON:
      vir_gpiof->ODR |= (0X1 << 6);
      break;
   case MADA_OFF:
      vir_gpiof->ODR &= (~(0X1 << 6));
      break;
   }
   return 0;
}
int mycdev_close(struct inode *inode, struct file *file)
{
   printk("%s %s %d\n", __FILE__, __func__, __LINE__);
   return 0;
}
struct file_operations fops =
    {
        .open = mycdev_open,
        .unlocked_ioctl = mycdev_ioctl,
        .release = mycdev_close,

};

static int __init mycdev_init(void)
{

   // 字符设备驱动注册
   major = register_chrdev(0, "mada", &fops);
   if (major < 0)
   {
      printk("字符设备驱动注册失败\n");
      return major;
   }
   printk("字符设备驱动注册成功major=%d\n", major);
   // 向上提交目录
   cls = class_create(THIS_MODULE, "mada");
   if (IS_ERR(cls))
   {
      printk("向上提交目录失败\n");
      return -PTR_ERR(cls);
   }
   // 向上提交设备节点信息
   dev = device_create(cls, NULL, MKDEV(major, 0), NULL, "mada");
   if (IS_ERR(dev))
   {
      printk("向上提交设备节点失败\n");
      return -PTR_ERR(dev);
   }
   vir_gpiof = ioremap(GPIOF, sizeof(gpio_t));
   if (vir_gpiof == NULL)
   {
      printk("ioremap filed %d\n", __LINE__);
      return -ENOMEM;
   }
   vir_rcc = ioremap(PHY_RCC_ADDR, 4);
   if (vir_rcc == NULL)
   {
      printk("ioremap filed %d\n", __LINE__);
      return -ENOMEM;
   }
   (*vir_rcc) |= (0x3 << 4);
   
   vir_gpiof->MODER &= (~(0x3 << 12));
   vir_gpiof->MODER |= (1 << 12);
   vir_gpiof->ODR &= (~(1 << 6));
   return 0;
}

static void __exit mycdev_exit(void)
{
   // 取消地址映射
   iounmap(vir_gpiof);
   iounmap(vir_rcc);

   device_destroy(cls, MKDEV(major, 0));
   // 销毁目录信息
   class_destroy(cls);
   // 注销字符设备驱动
   unregister_chrdev(major, "mada");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

bee.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include "head.h"
struct class *cls;
struct device *dev;
int major;
gpio_t *vir_gpiob;
unsigned int *vir_rcc;

int mycdev_open(struct inode *inode, struct file *file)
{
   printk("%s %s %d\n", __FILE__, __func__, __LINE__);
   return 0;
}

long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{

   switch (cmd)
   {
   case BEE_ON:
      vir_gpiob->ODR |= (0X1 << 6);
      break;
   case BEE_OFF:
      vir_gpiob->ODR &= (~(0X1 << 6));
      break;
   }
   return 0;
}
int mycdev_close(struct inode *inode, struct file *file)
{
   printk("%s %s %d\n", __FILE__, __func__, __LINE__);
   return 0;
}
struct file_operations fops =
    {
        .open = mycdev_open,
        .unlocked_ioctl = mycdev_ioctl,
        .release = mycdev_close,

};

static int __init mycdev_init(void)
{

   // 字符设备驱动注册
   major = register_chrdev(0, "bee", &fops);
   if (major < 0)
   {
      printk("字符设备驱动注册失败\n");
      return major;
   }
   printk("字符设备驱动注册成功major=%d\n", major);
   // 向上提交目录
   cls = class_create(THIS_MODULE, "bee");
   if (IS_ERR(cls))
   {
      printk("向上提交目录失败\n");
      return -PTR_ERR(cls);
   }
   // 向上提交设备节点信息
   dev = device_create(cls, NULL, MKDEV(major, 0), NULL, "bee");
   if (IS_ERR(dev))
   {
      printk("向上提交设备节点失败\n");
      return -PTR_ERR(dev);
   }
   vir_gpiob = ioremap(GPIOB, sizeof(gpio_t));
   if (vir_gpiob == NULL)
   {
      printk("ioremap filed %d\n", __LINE__);
      return -ENOMEM;
   }
   vir_rcc = ioremap(PHY_RCC_ADDR, 4);
   if (vir_rcc == NULL)
   {
      printk("ioremap filed %d\n", __LINE__);
      return -ENOMEM;
   }
   (*vir_rcc) |= (1 << 1);
   // led1
   vir_gpiob->MODER &= (~(0x3 << 12));
   vir_gpiob->MODER |= (1 << 12);
   vir_gpiob->ODR &= (~(1 << 6));
   return 0;
}

static void __exit mycdev_exit(void)
{
   // 取消地址映射
   iounmap(vir_gpiob);
   iounmap(vir_rcc);

   device_destroy(cls, MKDEV(major, 0));
   // 销毁目录信息
   class_destroy(cls);
   // 注销字符设备驱动
   unregister_chrdev(major, "bee");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

小白选手–c
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
stm32 马达，风扇，蜂鸣器
m0_72777834的博客
09-21 296
stm32
PWM实现蜂鸣器、马达、风扇
m0_59181734的博客
09-21 333
PWM实现蜂鸣器、马达、风扇。
编写蜂鸣器/风扇/马达代码
weixin_46323325的博客
02-28 530
编写蜂鸣器/风扇/马达代码
PWM实验（控制蜂鸣器，风扇，马达）
yayyy4的博客
10-03 3138
arm
PWM控制蜂鸣器，风扇，马达实验
06-16
2. 蜂鸣器控制： 对于蜂鸣器，PWM可以用来调整其发声的频率和音量。通过改变脉冲的频率，可以改变蜂鸣器发出的声音的音高；通过改变占空比，可以调整音量。这在需要产生不同音频信号或控制音量的应用中非常有用。 ...
基于单片机AT89C52的大棚温度控制系统设计说明.doc
07-16
该系统由单片机AT89C52、数字温度传感器DS18B20、液晶显示器LCD1602、直流马达和蜂鸣器等组成。 系统的主要组成部分包括： * 单片机AT89C52：作为系统的核心组件，负责执行控制指令和处理数据。 * 数字温度传感器...
基于单片机AT89C52的大棚温度控制系统-毕业设计.doc
07-09
- 报警电路：在温度超出预设范围时触发蜂鸣器报警。 总结，基于单片机AT89C52的大棚温度控制系统结合了硬件电路设计与软件编程，实现了大棚环境的智能管理。通过DS18B20传感器获取实时温度，单片机处理数据并控制...
灭火机器人使用说明..docx
03-02
1. **电源管理**：机器人在连接电源并打开总开关时，通过蜂鸣器反馈供电状态。如果蜂鸣器长时间鸣响，表示电压过低，需要充电。闲置时，应关闭开关并断开电源，以防止电池过度放电导致机器人损坏。 2. **红外传感器...
FS-MP1A-Extend-v1.2.pdf
06-14
2. **风扇、震动马达和蜂鸣器**：用于系统冷却、物理反馈和声音提示。 3. **3路按键**：用于用户交互，实现不同功能的触发。 4. **电流测量**：通过特定的电路设计，可以测量电流值。 5. **LED指示灯**：提供视觉...
算法-KMP字符串匹配
xx_xb的博客
07-23 163
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 385
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 642
AtCoder Beginner Contest 363 ABCDE
2024.7.19 刷题总结
TheJustice_的博客
07-19 303
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
插入和选择排序
c23856的博客
07-20 528
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
最新发布
danaaaa的博客
07-24 733
二叉搜索树向左或向右指明方向，不用遍历整个树。
Python鲁汶意外莱顿复杂图拓扑分解算法
跨学科知识视角展现
07-24 743
:dart:算法池化和最佳分区搜索：:pen:网格搜索 | :pen:发现算法池 | :pen:返回指定图的最佳划分 | :pen:返回指定图的最佳分区 | :dart:适应度和聚类比较功能：:pen:图的划分 | :pen:节点度 | :pen:给定算法检测到社群总数 | :pen:图密度 | :pen:社群顶点的度数之和 | :pen:解之间的预期一致 | :pen:联合熵 | :pen:平均内部度、所有可能的节点对的平均路径长度 | :pen:节点指向社群外的边平均比例 | :pen:现有边距离社群比
【常微分方程】
qq_74285286的博客
07-24 242
常微分方程笔记
python实现图像缩放算法
qq_42568323的博客
07-20 397
它通过选择离目标像素最近的原始像素的颜色值来确定目标像素的颜色值。它通过考虑目标像素周围16个像素的颜色值，使用双三次插值公式计算出目标像素的颜色值。相较于双线性插值，双三次插值能生成更平滑、更细腻的图像效果。它通过考虑目标像素周围四个像素的颜色值，使用双线性插值公式计算出目标像素的颜色值。尽管最近邻插值在某些应用场景中足够使用，但在需要更高质量图像的场景中，通常会选择更加复杂的插值方法，如双线性插值或双三次插值。双三次插值是图像缩放中高质量的方法之一，适合需要高质量图像处理的应用场景。
九德松益交流马达控制器详解与技术特性
九德松益交流马达是一款由九德松益股份有限公司推出的高性能交流电机控制器产品，其CT-2000系列专为满足全球市场对电机驱动系统的高效、精准控制需求而设计。这款控制器采用了正弦波脉宽调制（PWM）技术，提供了灵活...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值