Linux学习笔记（15.2）——LED设备驱动之面向对象演进2

最新推荐文章于 2022-10-20 18:05:54 发布
最新推荐文章于 2022-10-20 18:05:54 发布
阅读量264 收藏
点赞数
分类专栏： Linux 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/glen_cao/article/details/122008007
版权
  1. LED字符设备驱动程序改进——构建led_drv.c文件和led_dev.c文件
  • 将二者都用到的公共部分提取出来，放入到led_dev.h文件当中去
/**
 * @file led_dev.h 
 * @author glen (glen_cao@126.com)
 * @brief 
 * @version 0.1
 * @date 2021-12-17
 * 
 * @copyright Copyright (c) 2021
 */

#ifndef __LED_DEV_H__
#define __LED_DEV_H__

#include <linux/types.h>

struct led_ops {
    u8 num;             /* LED数量 */
    int (* led_init)(u8 idx);
    int (* led_exit)(u8 idx);
    void (* led_ctrl)(u8 idx, u8 status);
};

extern void * get_led_ops(void);

#endif // !__LED_DEV_H__
  • led_dev.c为设备相关函数
/* 
 * 文件名   : led_dev.c
 * 作者     : glen  
 * 描述     : led_dev驱动文件
 */
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>

#include "led_dev.h"

#define LED_NUM     2   /* LED数量 */

#define HIGH  1
#define LOW   0

#define OFF         'C' /* 关灯 */
#define ON          'O' /* 开灯 */

struct phy_regs {
    phys_addr_t ccgr;
    phys_addr_t sw_mux;
    phys_addr_t sw_pad;
    phys_addr_t dr;
    phys_addr_t dir;
};

struct vir_regs {
    void __iomem *ccgr;
    void __iomem *sw_mux;
    void __iomem *sw_pad;
    void __iomem *dr;
    void __iomem *dir;
};

/* LED设备结构体 */
struct gled_device {
    char *name;             /* 设备名称 */
    u8 dft_status[LED_NUM]; /* 默认状态: 打开或关闭 */
    u8 on_level[LED_NUM];   /* 打开时电平: 高或低 */
    u8 clk_shft_bits[LED_NUM];
    u32 pin[LED_NUM];       /* led引脚信息 */
    struct vir_regs vir_io[LED_NUM];
    struct phy_regs phy_io[LED_NUM];
    struct led_ops ops;
};

static void led_ctrl(u8 idx, u8 status);
static int led_init(u8 idx);
static int led_exit(u8 idx);

/* gled设备 */
static struct gled_device gled_dev = {
    .name = "gled_dev",
    .dft_status = { OFF, ON },
    .on_level = {LOW, LOW },
    .clk_shft_bits = {26, 30},
    .pin = {3, 1},
    .phy_io = {
        {   /* IO物理地址 */
            .ccgr   = 0x020C406C, 
            .sw_mux = 0x020E0068,
            .sw_pad = 0x020E02F4,
            .dr     = 0x0209C000,
            .dir    = 0x0209C004
        },
        {
            .ccgr   = 0x020C406C, 
            .sw_mux = 0x0229000C,
            .sw_pad = 0x02290050,
            .dr     = 0x020AC000,
            .dir    = 0x020AC004
        },
    },
    .ops = {
        .num = LED_NUM,
        .led_init = led_init,
        .led_exit = led_exit,
        .led_ctrl = led_ctrl,
    },
};

/**
 * @brief   : 打开/关闭LED 
 * @par     : status    LEDON('O') 打开LED, LEDOFF('C') 关闭LED
 * @retval  : 无
 */
static void led_ctrl(u8 idx, u8 status)
{
    u32 val = 0;

    if (gled_dev.vir_io[idx].ccgr == NULL) 
        return;

    if (status == ON) {
        val = readl(gled_dev.vir_io[idx].dr);
        if (gled_dev.on_level[idx] == HIGH) {
            val |= (1 << (gled_dev.pin[idx]));
        } else if (gled_dev.on_level[idx] == LOW) {
            val &= ~(1 << gled_dev.pin[idx]);
        }
        writel(val, gled_dev.vir_io[idx].dr);
        printk("The led%d is openned!\r\n", idx);
    } else if (status == OFF) {
        val = readl(gled_dev.vir_io[idx].dr);
        if (gled_dev.on_level[idx] == HIGH) {
            val &= ~(1 << gled_dev.pin[idx]);
        } else if (gled_dev.on_level[idx] == LOW) {
            val |= (1 << (gled_dev.pin[idx]));
        }
        writel(val, gled_dev.vir_io[idx].dr);
        printk("The led%d is closed!\r\n", idx);
    } else {
        printk("Recived parameter is error!\r\n");
    }
}

/**
 * @brief LED状态初始化
 * @param idx LED
 */
static int led_init(u8 idx)
{
    u32 val;

    if (idx >= gled_dev.ops.num) {
        return -EIO;
    }

    /* 寄存器地址映射 */
    gled_dev.vir_io[idx].ccgr    = ioremap(gled_dev.phy_io[idx].ccgr  ,  4);
    gled_dev.vir_io[idx].sw_mux  = ioremap(gled_dev.phy_io[idx].sw_mux,  4);
    gled_dev.vir_io[idx].sw_pad  = ioremap(gled_dev.phy_io[idx].sw_pad,  4);
    gled_dev.vir_io[idx].dr      = ioremap(gled_dev.phy_io[idx].dr    ,  4);
    gled_dev.vir_io[idx].dir     = ioremap(gled_dev.phy_io[idx].dir   ,  4);

    /* 使能GPIO时钟 */
    val = readl(gled_dev.vir_io[idx].ccgr);
    val |= (3 << gled_dev.clk_shft_bits[idx]);
    writel(val, gled_dev.vir_io[idx].ccgr);

    /* 设置gpio1_io03的复用功能 */
    writel(5, gled_dev.vir_io[idx].sw_mux);

    /* 寄存器sw_mux1_io03设置IO属性 */
    writel(0x10B0, gled_dev.vir_io[idx].sw_pad);

    /* 设置gpio1_gdir为输出功能 */
    val = readl(gled_dev.vir_io[idx].dir);
    val |= (1 << gled_dev.pin[idx]);
    writel(val, gled_dev.vir_io[idx].dir);

    /* 设置led为默认状态 */
    val = readl(gled_dev.vir_io[idx].dr);
    if (gled_dev.dft_status[idx] == ON) {
        if (gled_dev.on_level[idx] == HIGH) {
            val |= (1 << gled_dev.pin[idx]);
        } else if (gled_dev.on_level[idx] == LOW) {
            val &= ~(1 << gled_dev.pin[idx]);
        }
    } else if (gled_dev.dft_status[idx] == OFF) {
        if (gled_dev.on_level[idx] == HIGH) {
            val &= ~(1 << gled_dev.pin[idx]);
        } else if (gled_dev.on_level[idx] == LOW) {
            val |= (1 << gled_dev.pin[idx]);
        }
    }
    writel(val, gled_dev.vir_io[idx].dr);

    return 0;
}

/**
 * @brief LED状态解初始化
 * @param idx LED
 */
static int led_exit(u8 idx)
{
    if (idx >= gled_dev.ops.num) {
        return -EIO;
    }
    iounmap(gled_dev.vir_io[idx].ccgr);
    iounmap(gled_dev.vir_io[idx].sw_mux);
    iounmap(gled_dev.vir_io[idx].sw_pad);
    iounmap(gled_dev.vir_io[idx].dr);
    iounmap(gled_dev.vir_io[idx].dir);

    return 0;
}

/**
 * @brief Get the led ops object
 */
void * get_led_ops(void)
{
    return (void *)(&(gled_dev.ops));
}

/* 模块的许可证声明 */
MODULE_LICENSE("GPL");
/* 模块的作者声明 */
MODULE_AUTHOR("glen");
  • led_drv.c为驱动相关函数
/* 
 * 文件名   : led_drv.c
 * 作者     : glen  
 * 描述     : led_drv驱动文件
 */
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>

#include "led_dev.h"

/* LED驱动结构体 */
struct gled_driver {
    struct class *drv_class;
    char *name;
    dev_t major;

    struct led_ops *ops;
};

/* gled驱动 */
static struct gled_driver gled_drv = {
    .name  = "gled_drv",
    .major = 0,
    .ops = NULL,
};

/**
 * @brief Get the led ops object
 */
// __weak void *get_led_ops(void) 
// {
//     return NULL;
// }

/**
 * @brief   : 打开设备 
 * @par     : inode 传递给驱动的inode
 *            filp  设备文件, file结构体有个private_data的成员变量, 一般
 *            在open的时候将private_data指向设备结构体
 * @retval  : 0 成功, 其它 失败
 */
static int led_drv_open(struct inode *inode, struct file *filp)
{
    int minor = iminor(inode);
    struct led_ops *ops = gled_drv.ops;

    if (ops == NULL) {
        printk("Please register led_ops instance! \n");
        return 0;
    }

    if (ops->led_init)
        if (ops->led_init(minor) == 0) 
            printk("The led%d has openned successfully! \n", minor);
        else 
            printk("The led%d has openned failure! \n", minor);
    else 
        printk("Please register led_ops instance! \n");
    return 0;
}

/**
 * @brief   : 从设备读取数据 
 * @par     : filp  要打开的设备文件(文件描述符)
 *            buf   返回给用户空间的数据缓冲区
 *            cnt   要读取的数据长度
 *            offt  相对于文件首地址的偏移
 * @retval  : 读取数据长度, 若为负值则表示读取失败
 */
static ssize_t led_drv_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
    return 0;
}

/**
 * @brief   : 向字符设备写入数据 
 * @par     : filp  设备文件, 表示打开的文件描述符
 *            buf   要写给设备的数据
 *            cnt   要写入的数据长度
 *            offt  相对于文件首地址的偏移
 * @retval  : 写入数据长度, 若为负值则表示读取失败
 */
static ssize_t led_drv_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
    int ret = 0;
    u8 data_buf[1];
    u8 led_sta;
    int minor;
    struct inode *inode = file_inode(filp);
    struct led_ops *ops = gled_drv.ops;

    if (ops == NULL) {
        printk("Please register led_ops instance! \n");
        return 0;
    }
    minor = iminor(inode);
    ret = copy_from_user(data_buf, buf, 1);

    if (ret < 0) {
        printk("kenel recive data: %s\r\n", buf);
        return -EFAULT;
    }

    /* 获取状态值 */
    led_sta = data_buf[0];

    if (ops->led_ctrl) 
        ops->led_ctrl(minor, led_sta);

    return 0;

}

/**
 * @brief   : 打开设备 
 * @par     : inode 传递给驱动的inode
 *            filp  要关闭的设备文件(文件描述符)
 * @retval  : 0 成功, 其它 失败
 */
static int led_drv_release(struct inode *inode, struct file *filp)
{
    u8 minor = iminor(inode);
    struct led_ops *ops = gled_drv.ops;

    if (ops == NULL) {
        printk("Please register led_ops instance! \n");
        return 0;
    }

    if (minor >= ops->num)
        return -EINVAL;

    /* 虚拟地址映射销 */
    if (ops->led_exit)
        ops->led_exit(minor);

    printk("The led driver is closed! %s, %s, line %d\n", __FILE__, __FUNCTION__, __LINE__);

    return 0;
}

static struct file_operations led_drv_fops = {
    .owner = THIS_MODULE,
    .open = led_drv_open,
    .read = led_drv_read,
    .write = led_drv_write,
    .release = led_drv_release,
};


/**
 * @brief   : 驱动初始化函数 
 * @par     : 无
 * @retval  : 无
 */
static int __init led_drv_init(void)
{
    u8 err = 0;
    u8 i;

    /* register char device driver */
    gled_drv.major = register_chrdev(gled_drv.major, gled_drv.name, &led_drv_fops);
    if (gled_drv.major == 0) {
        printk("gled driver: Unable to register driver!\n");
        return -EIO;
    }
    printk("gled driver: Register driver successfully!\n");

    gled_drv.drv_class = class_create(THIS_MODULE, "gled");
    if (IS_ERR(gled_drv.drv_class)) {
        err = PTR_ERR(gled_drv.drv_class);
        goto out_chrdev;
    }

    gled_drv.ops = (struct led_ops *)get_led_ops();
    
    if (gled_drv.ops == NULL) {
        printk("Please register led_ops instance! \n");
        err = PTR_ERR(gled_drv.ops);
        goto out_chrdev;
    }

    for (i = 0; i < gled_drv.ops->num; i++) 
        device_create(gled_drv.drv_class, NULL, MKDEV(gled_drv.major, i), NULL, "gled%d", i);

    return 0;

out_chrdev:
    unregister_chrdev(gled_drv.major, gled_drv.name);
    return err;
}


/**
 * @brief   : 驱动退出函数 
 * @par     : 无
 * @retval  : 无
 */
static void __exit led_drv_exit(void)
{
    u8 i;

    for (i = 0; i < gled_drv.ops->num; i++)
        /* 销毁设备 */
        device_destroy(gled_drv.drv_class, MKDEV(gled_drv.major, i));

    class_destroy(gled_drv.drv_class);
    /* 注销字符设备驱动 */
    unregister_chrdev(gled_drv.major, gled_drv.name);
}

/* assign the functions as driver's import function and export function*/

module_init(led_drv_init);
module_exit(led_drv_exit);

/* insert license for module */
MODULE_LICENSE("GPL");

/* insert author information for module */
MODULE_AUTHOR("glen");
  1. Makefile稍作更改，将两个led_drv.c led_dev.c编译进 led_driver.ko
KERNELDIR	:= /home/glen/linux/imx6ull/linux/glen_linux
CURRENT_PATH	:= $(shell pwd)
led_driver-y	:= led_drv.o led_dev.o
obj-m	+= led_driver.o
build:	kernel_modules

kernel_modules:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules

clean:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

【注】：本来是要编译成两个.ko文件，结果led_drv.ko死活insmod不成功，应该是依赖关系没整好，后面再研究吧。
4. 测试程序不做更改，验证参考Linux学习笔记（15）——LED设备驱动

glen_cao
关注
专栏目录
【嵌入式Linux驱动开发】五、LED驱动完善 – 面向对象·上下分层·左右分离
01-06
除了知情权以外，人也应该拥有不知情权，后者的价值要大得多。它意味着高尚的灵魂不必被那些废话和空谈充斥。过度的信息对一个过着充实生活的人来说，是一种不必要的负担。 一、面向对象·上下分层·左右分离思想 面向对象 字符设备驱动程序抽象出一个 file_operations 结构体； 我们写的程序针对硬件部分抽象出 led_operations 结构体。 上下分层， 比如我们前面写的 LED 驱动程序就分为 2 层： ① 上层实现硬件无关的操作，比如注册字符设备驱动： leddrv.c ② 下层实现硬件相关的操作，比如 board_A.c 实现单板 A 的 LED 操作   这两种思想在之前的程
为什么在串口接收中断函数中打印数据（串口输出数据）会导致出错？
我的博客
06-22 2838
在用华大单片机HC32L110操作时，会出现标题所示的错误，下面是数据手册中的一句话： then,看下实际工程中的代码（无关代码已经删除，保留关键代码），串口配置为接收中断，输出不用中断方式 串口发送： en_result_t Uart_SendData(uint8_t u8Idx, uint8_t u8Data) { Uart_ClrStatus(u8Idx,UartTxEmpty); //发送完成标志位清零=FALSE pstcData->pstcInstance-&...
面向对象地分析Linux内核设备驱动(1):——Linux内核驱动中面向对象的基本规则和实现方法
zhou_chenz的博客
02-07 5338
Linux内核驱动中面向对象的基本规则和实现方法 - 内核版本 Linux Kernel 2.6.34， 与 Robert.Love的《Linux Kernel Development》(第三版)所讲述的内核版本一样 - 源代码下载路径: https://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.34.tar.bz2
Linux驱动_驱动设计的思想（面向对象、设备树)
weixin_44737233的博客
10-20 328
事实上，每一款芯片它的GPIO操作都是类似的，并且这跟主芯片相关，因此就可以针对该芯片写出比较通用的硬件操作代码。如果硬件很多，导致相对应的.c文件很多，造成内核臃肿。因此引入设备树，将硬件的设置文件不放在内核的.c文件中。先后比较1、2、3。如果1不行，就比较2,2不行就比较3.一般2、3用得比较多。一、Linux驱动_驱动设计的思想（面向对象_分层_分离）1、传统方法的缺点如下，于是引用了设备树，使用配置文件。四、LED模板驱动程序的改造_总线设备驱动模型。1、2、3、4部比较过程具体见文件说明。
面向对象地分析Linux内核设备驱动(2)——Linux内核设备模型与总线
zhou_chenz的博客
02-11 3141
Linux内核设备模型与总线 - 内核版本 Linux Kernel 2.6.34， 与 Robert.Love的《Linux Kernel Development》(第三版)所讲述的内核版本一样 - 源代码下载路径: https://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.34.tar.bz2
Linux内核与设备驱动程序学习笔记及源码.zip
01-05
Linux内核与设备驱动程序学习笔记及源码.zip Linux内核与设备驱动程序学习笔记及源码.zip Linux内核与设备驱动程序学习笔记及源码.zip Linux内核与设备驱动程序学习笔记及源码.zip Linux内核与设备驱动程序学习笔记...
Linux内核与设备驱动程序学习资料笔记+源码.zip
最新发布
01-30
Linux内核与设备驱动程序学习资料笔记+源码.zipLinux内核与设备驱动程序学习资料笔记+源码.zipLinux内核与设备驱动程序学习资料笔记+源码.zipLinux内核与设备驱动程序学习资料笔记+源码.zipLinux内核与设备驱动程序...
php学习笔记之面向对象编程
01-20
复制代码 代码如下:<?... //数据库连接 private $options; //SQL选项 private $tableName; //表名 public function __construct($tabName) { $this->tableName = $tabName; $this->db (); } private function db() {...
Java学习笔记之面向对象基本概念
12-22
　面向对象程序设计是将人们认识世界过程中普遍采用的思维方法应用到程序设计中。 　对象是现实世界中存在的事物，它们是有形的，如某个人、某种物品;也可以是无形的，如某项计划、某次商业交易。 　对象是构成...
python学习笔记(十二)面向对象2
12-21
1. 封装：封装是面向对象的基础，它意味着将数据（属性）和操作这些数据的方法结合在一起，形成一个独立的实体——对象。在Python中，通过定义类（class）来实现封装。类可以看作是创建对象的蓝图，其中`__init__`...
linux设备驱动归纳总结(八)3设备模型的分层与面向对象
fh400的专栏
11-02 1126
CU首页 ┊ fh265>>博客 微博 相册 个人中心 好友 消息 [退出] ┊ 随便看看   博文 博主 相册  投票 活动 发博文 公告：缅怀Dennis Ritchie活动开赛啦！ 小白的博客——提升自已，分享别人 xiaobai.blog.chinaunix.net 好的女人可以不共享。好的技术绝对要共享！
Linux驱动体现的编程思想---面向对象的编程思想
young_man
05-15 1030
一、描述一个对象需要该对象属性、对象方法，而在Linux设备驱动中是用一个具体的结构体来描述该设备，在结构体中就包含了设备属性、设备方法。 设备属性：① 与设备通信相关的参数(固定的)    ② 与设备特性相关的参数 (可变的) 设备方法：操作或与该设备通信函数指针 二、继承关系 在描述设备的结构体中，包含了类设备的结构体指针，体现出了该设备继承类设备的所有属性和方法。
Linux驱动编程篇（五）——驱动设计的思想（面向对象）（分层）（分离）
阿——波罗的博客
06-12 1010
Liunx驱动 = 驱动框架 + 硬件操作 ===》Liunx驱动 = 驱动框架 + 单片机
linux设备驱动篇之LED驱动（一）
fulinux的博客
04-05 6072
在学习LED设备驱动期间经历的问题层出不穷，遇到的问题有以下这些： 1、网上很多的LED驱动几乎都是2.6的内核版本，但是3.0内核和2.6的内核驱动编写有很多地方是不同的在2.6上能运行的设备驱动不一定能在3.0内核上运行。这对于刚刚踏入驱动大门人，急于想了解LED驱动是什么样的，他是怎么工作的，与应用程序又是如何协同工作的呢？对于我们可能第一个要去做的就是去找个例程先跑一跑，了解是怎么回事，增强一些自信和在战略上“藐视”设备驱动的气魄。先介绍一下我的工程结构如下说是，第一个是建立在后面第三个文件s3c_
linux设备驱动归纳总结（三）：3面向对象思想和lseek
fh400的专栏
11-02 1217
CU首页 ┊ fh265>>博客 微博 相册 个人中心 好友 消息 [退出] ┊ 随便看看   博文 博主 相册  投票 活动 发博文 公告：缅怀Dennis Ritchie活动开赛啦！ 小白的博客——提升自已，分享别人 xiaobai.blog.chinaunix.net 好的女人可以不共享。好的技术绝对要共享！
【STM32】LED初始化基础以及基本使用方法(CT117E电路)
码上有的博客
03-20 5425
LED灯的初始化 void LED_INIT(void) { // 初始化结构体 GPIO_InitTypeDef GPIO_InitStructure; // 使能我们的时钟 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC | RCC_APB2Periph_GPIOD, ENABLE); // LED配置引脚初始化参数 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9 | GPI...
Linux设备驱动模型——kobject、kset、subsystem的关系
Jason_Linux
02-27 763
kobject Linux内核中有大量的驱动和设备，而这些驱动和设备往往具有类似的结构，根据面向对象的思想，我们就可以将这些共同的部分提取为父类，这个父类就是kobject，也就是驱动编程中使用的.ko文件的由来，而三大类设备驱动都需要包含这个kobject结构，也就是"继承"自kobject。一个kobject对象就对应sys目录中的一个设备，也可以理解为一个kobject就对应sys目录中的一...
Linux学习笔记（23）——基于wm8960的音频设备驱动
glen_cao的博客
07-04 5642
根据WM8960与处理器接口SAI和I2C来修改设备树文件 a) 首先在i2c2节点下增加wm8960子节点 codec: wm8960@1a { compatible = "wlf,wm8960"; /* 兼容属性 */ reg = <0x1a>; /* wm8960的I2C地址 */ clocks = <&clks IMX6UL_CLK_SAI2>; clock-names = "mclk"; wlf,shared-lrclk; .
Linux内核：I2C设备驱动
glen_cao的博客
08-29 3264
I²C(发音:I²C，在内核文档中写成I2C)是由Philips开发的协议。它是一种缓慢的两线协议(可变速度，最高可达400 kHz)，具有高速扩展(3.4 MHz)。它提供了一种廉价的总线，用于连接需要不频繁或低带宽通信的多种设备。I2C广泛应用于嵌入式系统中。一些系统使用不符合品牌要求的变体，因此不标榜为I2C，而是使用不同的名称，例如TWI(两线接口)，IIC。最新的I2C官方规范是NXP Semiconductors发布的《I2C总线规范与用户手册》(UM10204)。......
Linux设备驱动学习笔记：字符设备驱动实战
“Linux设备驱动程序的学习笔记，涵盖了字符设备驱动的编写，包括NFS挂载、字符设备驱动的基本操作如open、write、close的实现，以及file_operations结构体的使用和驱动注册。” 在Linux操作系统中，设备驱动是操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值