linux简单的字符设备驱动程序(写的很清晰)

最新推荐文章于 2023-04-08 09:30:00 发布
最新推荐文章于 2023-04-08 09:30:00 发布
阅读量1.5k 收藏 7
点赞数 4
分类专栏： linux设备驱动 文章标签： linux驱动

转自：http://blog.csdn.net/CreazyApple/article/details/7290680

要求：掌握添加设备驱动程序的方法

内容：
采用模块方法，添加一个新的设备驱动程序。
要求添加字符设备的驱动。

编写一个应用程序，测试添加的驱动程序。

linxu系统中，在应用程序看来，硬件设备只是一个设备文件，应用程序可以象操作普通文件一样对硬件设备进行操作。设备驱动程序是内核的一部分，它完成以下的功能：

  1. 对设备初始化和释放.

  2. 把数据从内核传送到硬件和从硬件读取数据.

  3. 读取应用程序传送给设备文件的数据和回送应用程序请求的数据.

  4. 检测和处理设备出现的错误.

          设备分为两种：字符设备和块设备，这里就以简单的字符设备为例。

在设备驱动程序中有一个非常重要的结构file_operations,该结构的每个域都对应着一个系统调用。用户进程利用系统调用在对设备文件进行诸如read/write操作时，系统调用通过设备文件的主设备号找到相应的设备驱动程序，然后读取这个数据结构相应的函数指针，接着把控制权交给该函数。

struct file_operations {

int(*seek) (struct inode * ，structfile *， off_t ，int);
int (*read) (struct inode * ，structfile *， char ，int);
int (*write) (struct inode * ，structfile *， off_t ，int);

……

           }

编写设备驱动程序的主要工作是编写子函数，并填充file_operations的各个域。

例如：

Structfile_operations my_fops={

.read=my_read,

.write=my_write,

.open=my_open,

.release=my_release

}

然后再定义函数my_read,my_write,my_open,my_release相应的函数体。

例如：

  staticssize_t my_open(struct inode *inode,struct file *file){

staticint counter=0;

if(Device_Open)

return-EBUSY;

Device_Open++;

/*写入设备的信息*/

sprintf(msg,"the device hasbeen called %d times\n",counter++);

msg_ptr=msg;

return0;

}

同时对于可卸载的内核模块（LKM）,至少还有两个基本的模块：

my_init用于注册设备，获得设备的主设备号

调用register_chrdev(0,“sky_driver(设备名)”，&my_fops); //第一个参数0代表动态分配主设备号

my_exit用于注销设备

调用unregister_chrdev(my_major,“sky_driver(设备名)”);

然后在程序尾再调用这两个函数

module_init(my_init);

module_exit(my_exit)

MODULE_LICENSE(“GPL”);

不过如果使用特殊函数名

init_module 和cleanup_module,

就不用在程序最后加上上面那三行代码了。


废话少说，以下是实验过程：

首先编写驱动程序。


将后面附上的3个源程序放在一个文件夹中后（也可直接打包下载http://download.csdn.net/detail/creazyapple/4088141）

，开始进行实验：

1.编译驱动程序。  

在控制台下进入文件所在目录，输入命令make。如图：


             看到了吗？提示错误。原来需要用超级用户权限。

没有错误提示，说明make成功，进入文件夹下可以看到多了一些.k，.ko之类的文件。这就是编译好的模块。


2.  装载模块。

同样，必须要是root下才能进行。装载前，我们可以先看看系统中的模块：lsmod

装载，输入命令：   insmod devDrv.ko

完成后，再看看系统中的模块，发现多了一个模块“devDrv”，表示我们成功加载了！

可以用命令查看系统日志信息：dmesg

看到如下信息：

这正是在我们的驱动程序中注册函数输出的内容哦！

3.分配次设备号。

每个文件都有两个设备号，第一个是主设备号，标识驱动程序，第二个是从设备号，标识使用同一个设备驱动程序的不同的硬件设备 ，比如有两个软盘，就可以用从设备号来区分他们.设备文件的的主设备号必须与设备驱动程序在登记时申请的主设备号一致，否则用户进程将无法访问到驱动程序.。

分配前，我们必须要知道主设备号（其实在上一步中我们从dmesg中已经看到主设备好为250）：      cat  /proc/devices

可见到这一行：250 myDevice，是了，主设备号为250.

现在我们分配从设备号：mknod /dev/myDevice c 250 0

实际上就是在虚拟文件夹/dev/中加一个设备（在系统看来是文件）myDevice ,注意，这个是设备名，在测试文件中真是要利用这个设备名打开设备。最后的0表示从设备号。可以随便分配（只要不冲突）。

此后便可以在/dev/目录下看到新建的设备myDevice了：ls /dev/


一切成功的话，就可以测试我们的驱动程序啦！

4.测试驱动程序。


首先要编译测试程序：gcc drvTest.c -o sb

得到sb可执行程序，再执行 ：./sb

测试程序首先列出所有的设备名，让我们选中一个，当然输入myDevice啦：


正确读出之前存放在设备中的字符串！然后提示让我们输入一个字符串，随便啦：

 

最后是不是正确保存、读出了呢？of course !而且还告诉我们调用了几次这个设备呢！

5.删除设备、模块。

首先删除设备。就像删除普通文件一样：rm /dev/myDevice

删除后，看看/dev/目录下是佛已经木有myDevice 啦？：ls /dev/

接着删除模块：rmmod devDrv.

看看模块列表中是否已经没有devDrv模块了？：lsmod



在本次实验中，还特别添加了一些代码来给设备上锁，实现互斥，以免同时有多个进程读取设备造成混乱。（一般来说，字符设备如打印机是不能共享滴。。）观察驱动程序devDrv.c中两个函数

static int my_open(struct inode *inode, struct file *file)
{
        if(mutex)
                return -EBUSY;
        mutex = 1;//上锁
    printk("<1>main  device : %d\n", MAJOR(inode->i_rdev));
    printk("<1>slave device : %d\n", MINOR(inode->i_rdev));
    printk("<1>%d times to call the device\n", ++counter);
    try_module_get(THIS_MODULE);
    return 0;
}
/* 每次使用完后会release */
static int my_release(struct inode *inode, struct file *file)
{
    printk("Device released!\n");
    module_put(THIS_MODULE);
        mutex = 0;//开锁
    return 0;
}

int 型mutex就是用来上锁的，它被初始化为0，一旦使用该设备，就首先要调用my_open函数，将mutex设置为1，如果此后还想使用该设备，必然因为mutex为1而返回-EBUSY，而终止。使用完该设备后，调用my_release释放设备，将mutex重新设回0.

特别注意，还有一个counter变量，使用来计量使用次数的。

makefile的格式相当严格，比如不能用8个空格来代替一个table键等。

makefile最后有一句：


devDrv一定要对应我们要编译的驱动程序devDrv.c的文件名。

源代码附上。共三个文件，将其放在一个文件夹中

1.驱动程序devDrv.c
[cpp] view plain copy print ?
  1. /*
  2. *  devDrv.c
  3. *  threeProcess
  4. *  Created on: 2012-2-24
  5. *      Author: zhushengben
  6. */ 
  7.  
  8. #include "linux/kernel.h" 
  9. #include "linux/module.h" 
  10. #include "linux/fs.h" 
  11. #include "linux/init.h" 
  12. #include "linux/types.h" 
  13. #include "linux/errno.h" 
  14. #include "linux/uaccess.h" 
  15. #include "linux/kdev_t.h" 
  16. #define MAX_SIZE 1024 
  17.  
  18. staticint my_open(struct inode *inode,struct file *file); 
  19. staticint my_release(struct inode *inode,struct file *file); 
  20. static ssize_t my_read(struct file *file,char __user *user,size_t t, loff_t *f); 
  21. static ssize_t my_write(struct file *file,constchar __user *user,size_t t, loff_t *f); 
  22.  
  23. staticchar message[MAX_SIZE] ="-------congratulations--------!"; 
  24. staticint device_num = 0;//设备号 
  25. staticint counter = 0;//计数用 
  26. staticint mutex = 0;//互斥用 
  27. staticchar* devName ="myDevice";//设备名 
  28.  
  29. struct file_operations pStruct = 
  30. { open:my_open, release:my_release, read:my_read, write:my_write, }; 
  31.  
  32. /* 注册模块 */ 
  33. int init_module() 
  34. { 
  35.     int ret; 
  36.     /* 函数中第一个参数是告诉系统，新注册的设备的主设备号由系统分配，
  37.      * 第二个参数是新设备注册时的设备名字，
  38.      * 第三个参数是指向file_operations的指针，
  39.      * 当用设备号为0创建时，系统一个可以用的设备号创建模块 */ 
  40.     ret = register_chrdev(0, devName, &pStruct); 
  41.     if (ret < 0) 
  42.     { 
  43.         printk("regist failure!\n"); 
  44.         return -1; 
  45.     } 
  46.     else 
  47.     { 
  48.         printk("the device has been registered!\n"); 
  49.         device_num = ret; 
  50.         printk("<1>the virtual device's major number %d.\n", device_num); 
  51.         printk("<1>Or you can see it by using\n"); 
  52.         printk("<1>------more /proc/devices-------\n"); 
  53.         printk("<1>To talk to the driver,create a dev file with\n"); 
  54.         printk("<1>------'mknod /dev/myDevice c %d 0'-------\n", device_num); 
  55.         printk("<1>Use \"rmmode\" to remove the module\n"); 
  56.  
  57.         return 0; 
  58.     } 
  59. } 
  60. /* 注销模块，函数名很特殊 */ 
  61. void cleanup_module() 
  62. { 
  63.     unregister_chrdev(device_num, devName); 
  64.     printk("unregister it success!\n"); 
  65. } 
  66.  
  67. staticint my_open(struct inode *inode,struct file *file) 
  68. { 
  69.     if (mutex) 
  70.         return -EBUSY; 
  71.     mutex = 1;//上锁 
  72.     printk("<1>main  device : %d\n", MAJOR(inode->i_rdev)); 
  73.     printk("<1>slave device : %d\n", MINOR(inode->i_rdev)); 
  74.     printk("<1>%d times to call the device\n", ++counter); 
  75.     try_module_get(THIS_MODULE); 
  76.     return 0; 
  77. } 
  78. /* 每次使用完后会release */ 
  79. staticint my_release(struct inode *inode,struct file *file) 
  80. { 
  81.     printk("Device released!\n"); 
  82.     module_put(THIS_MODULE); 
  83.     mutex = 0;//开锁 
  84.     return 0; 
  85. } 
  86.  
  87. static ssize_t my_read(struct file *file,char __user *user,size_t t, loff_t *f) 
  88. { 
  89.     if(copy_to_user(user,message,sizeof(message))) 
  90.     { 
  91.         return -EFAULT; 
  92.     } 
  93.     returnsizeof(message); 
  94. } 
  95.  
  96. static ssize_t my_write(struct file *file,constchar __user *user,size_t t, loff_t *f) 
  97. { 
  98.     if(copy_from_user(message,user,sizeof(message))) 
  99.     { 
  100.         return -EFAULT; 
  101.     } 
  102.     returnsizeof(message); 
  103. }  
/*
 *  devDrv.c
 *  threeProcess
 *  Created on: 2012-2-24
 *      Author: zhushengben
 */

#include "linux/kernel.h"
#include "linux/module.h"
#include "linux/fs.h"
#include "linux/init.h"
#include "linux/types.h"
#include "linux/errno.h"
#include "linux/uaccess.h"
#include "linux/kdev_t.h"
#define MAX_SIZE 1024

static int my_open(struct inode *inode, struct file *file);
static int my_release(struct inode *inode, struct file *file);
static ssize_t my_read(struct file *file, char __user *user, size_t t, loff_t *f);
static ssize_t my_write(struct file *file, const char __user *user, size_t t, loff_t *f);

static char message[MAX_SIZE] = "-------congratulations--------!";
static int device_num = 0;//设备号
static int counter = 0;//计数用
static int mutex = 0;//互斥用
static char* devName = "myDevice";//设备名

struct file_operations pStruct =
{ open:my_open, release:my_release, read:my_read, write:my_write, };

/* 注册模块 */
int init_module()
{
	int ret;
	/* 函数中第一个参数是告诉系统，新注册的设备的主设备号由系统分配，
	 * 第二个参数是新设备注册时的设备名字，
	 * 第三个参数是指向file_operations的指针，
	 * 当用设备号为0创建时，系统一个可以用的设备号创建模块 */
	ret = register_chrdev(0, devName, &pStruct);
	if (ret < 0)
	{
		printk("regist failure!\n");
		return -1;
	}
	else
	{
		printk("the device has been registered!\n");
		device_num = ret;
		printk("<1>the virtual device's major number %d.\n", device_num);
		printk("<1>Or you can see it by using\n");
		printk("<1>------more /proc/devices-------\n");
		printk("<1>To talk to the driver,create a dev file with\n");
		printk("<1>------'mknod /dev/myDevice c %d 0'-------\n", device_num);
		printk("<1>Use \"rmmode\" to remove the module\n");

		return 0;
	}
}
/* 注销模块，函数名很特殊 */
void cleanup_module()
{
	unregister_chrdev(device_num, devName);
	printk("unregister it success!\n");
}

static int my_open(struct inode *inode, struct file *file)
{
	if (mutex)
		return -EBUSY;
	mutex = 1;//上锁
	printk("<1>main  device : %d\n", MAJOR(inode->i_rdev));
	printk("<1>slave device : %d\n", MINOR(inode->i_rdev));
	printk("<1>%d times to call the device\n", ++counter);
	try_module_get(THIS_MODULE);
	return 0;
}
/* 每次使用完后会release */
static int my_release(struct inode *inode, struct file *file)
{
	printk("Device released!\n");
	module_put(THIS_MODULE);
	mutex = 0;//开锁
	return 0;
}

static ssize_t my_read(struct file *file, char __user *user, size_t t, loff_t *f)
{
	if(copy_to_user(user,message,sizeof(message)))
	{
		return -EFAULT;
	}
	return sizeof(message);
}

static ssize_t my_write(struct file *file, const char __user *user, size_t t, loff_t *f)
{
	if(copy_from_user(message,user,sizeof(message)))
	{
		return -EFAULT;
	}
	return sizeof(message);
}

2.makefile文件。注意，文件名就叫makefile或者Makefile，大小写不可随意更改，关于makefile的编写，参考

http://wiki.ubuntu.org.cn/index.php?title=%E8%B7%9F%E6%88%91%E4%B8%80%E8%B5%B7%E5%86%99Makefile:MakeFile%E4%BB%8B%E7%BB%8D&variant=zh-cn


[cpp] view plain copy print ?
  1. # If KERNELRELEASE is defined, we've been invoked from the 
  2. # kernel build system and can use its language. 
  3. ifeq ($(KERNELRELEASE),) 
  4.     # Assume the source tree is where the running kernel was built 
  5.     # You should set KERNELDIR in the environment if it's elsewhere 
  6.     KERNELDIR ?= /lib/modules/$(shell uname -r)/build 
  7.     # The current directory is passed to sub-makes as argument 
  8.     PWD := $(shell pwd) 
  9. modules: 
  10.     $(MAKE) -C $(KERNELDIR) M=$(PWD) modules 
  11. modules_install: 
  12.     $(MAKE) -C $(KERNELDIR) M=$(PWD) modules_install 
  13. clean: 
  14.     rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions 
  15. .PHONY: modules modules_install clean 
  16. else 
  17.     # called from kernel build system: just declare what our modules are 
  18.     obj-m := devDrv.o 
  19. endif  
# If KERNELRELEASE is defined, we've been invoked from the
# kernel build system and can use its language.
ifeq ($(KERNELRELEASE),)
    # Assume the source tree is where the running kernel was built
    # You should set KERNELDIR in the environment if it's elsewhere
    KERNELDIR ?= /lib/modules/$(shell uname -r)/build
    # The current directory is passed to sub-makes as argument
    PWD := $(shell pwd)
modules:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules
modules_install:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules_install
clean:
	rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions
.PHONY: modules modules_install clean
else
    # called from kernel build system: just declare what our modules are
    obj-m := devDrv.o
endif

3.测试程序test.c

[cpp] view plain copy print ?
  1. /*
  2. *  drvTest.c
  3. *  threeProcess
  4. *  Created on: 2012-2-24
  5. *      Author: zhushengben
  6. */ 
  7.  
  8. #include <sys/types.h> 
  9. #include <sys/stat.h> 
  10. #include <stdlib.h> 
  11. #include <string.h> 
  12. #include <stdio.h> 
  13. #include <fcntl.h> 
  14. #include <unistd.h> 
  15. #define MAX_SIZE 1024 
  16.  
  17. int main(void) 
  18. { 
  19.     int fd; 
  20.     char buf[MAX_SIZE]; 
  21.     char get[MAX_SIZE]; 
  22.     char devName[20], dir[50] ="/dev/"; 
  23.     system("ls /dev/"); 
  24.     printf("Please input the device's name you wanna to use :"); 
  25.     gets(devName); 
  26.     strcat(dir, devName); 
  27.     fd = open(dir, O_RDWR | O_NONBLOCK); 
  28.     if (fd != -1) 
  29.     { 
  30.         read(fd, buf, sizeof(buf)); 
  31.         printf("The device was inited with a string : %s\n", buf); 
  32.         /* 测试写 */ 
  33.         printf("Please input a string  :\n"); 
  34.         gets(get); 
  35.         write(fd, get, sizeof(get)); 
  36.         /* 测试读 */ 
  37.         read(fd, buf, sizeof(buf)); 
  38.         system("dmesg"); 
  39.         printf("\nThe string in the device now is : %s\n", buf); 
  40.         close(fd); 
  41.         return 0; 
  42.     } 
  43.     else 
  44.     { 
  45.         printf("Device open failed\n"); 
  46.         return -1; 
  47.     } 
  48. }  
/*
 *  drvTest.c
 *  threeProcess
 *  Created on: 2012-2-24
 *      Author: zhushengben
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#define MAX_SIZE 1024

int main(void)
{
	int fd;
	char buf[MAX_SIZE];
	char get[MAX_SIZE];
	char devName[20], dir[50] = "/dev/";
	system("ls /dev/");
	printf("Please input the device's name you wanna to use :");
	gets(devName);
	strcat(dir, devName);
	fd = open(dir, O_RDWR | O_NONBLOCK);
	if (fd != -1)
	{
		read(fd, buf, sizeof(buf));
		printf("The device was inited with a string : %s\n", buf);
		/* 测试写 */
		printf("Please input a string  :\n");
		gets(get);
		write(fd, get, sizeof(get));
		/* 测试读 */
		read(fd, buf, sizeof(buf));
		system("dmesg");
		printf("\nThe string in the device now is : %s\n", buf);
		close(fd);
		return 0;
	}
	else
	{
		printf("Device open failed\n");
		return -1;
	}
}

参考资料：

linux设备驱动程序（hello world ）：http://ibeyond.blog.51cto.com/1988404/400267

linux设备驱动程序：http://www.knowsky.com/340884.html

file_operation 结构详解：http://www.chineselinuxuniversity.net/articles/45406.shtml

linux字符设备驱动程序：http://blog.csdn.net/r91987/article/details/5336974

kakadeyisheng1990
关注
专栏目录
字符设备驱动程序实现读写功能
01-10
这是字符设备驱动的经典程序，globalmem可以实现对设备的读写操作，很有意思，希望大神们多多指教。
Linux LED字符设备驱动，基于平台驱动的LED字符设备驱动，支持多个LED灯，没有体现分层设计思想
03-04
本文将深入探讨一种特定类型的驱动——LED字符设备驱动，特别是基于平台驱动的实现，以及如何支持多个LED灯。 首先，我们要理解什么是Linux平台驱动。在Linux内核中，平台驱动是一种通用的驱动模型，用于处理那些...
linux简单的字符设备驱动程序
朱胜本的专栏
02-24 532
要求：掌握添加设备驱动程序的方法 内容： 采用模块方法，添加一个新的设备驱动程序。 要求添加字符设备的驱动。 编写一个应用程序，测试添加的驱动程序。 &lt;style type="text/css"&gt; &lt;!-- p {margin-bottom:0.21cm} --&gt; &lt;/style&gt; linxu系统中，在应用程序看来，硬件设备只是一个设备文...
蜕变成蝶~Linux设备驱动之字符设备驱动
weixin_34161064的博客
04-15 138
一、linux系统将设备分为3类：字符设备、块设备、网络设备。使用驱动程序： 字符设备：是指只能一个字节一个字节读写的设备，不能随机读取设备内存中的某一数据，读取数据需要按照先后数据。字符设备是面向流的设备，常见的字符设备有鼠标、键盘、串口、控制台和LED设备等。 块设备：是指可以从设备的任意位置读取一定长度数据的设备。块设备包括硬盘、磁盘、U盘和SD卡等。 　　每一个字符设备或...
Linux之字符设备驱动
xiao小青年
06-05 121
一、结构体： a、字符设备结构体： <include/linux/cdev.h> struct cdev { struct kobject kobj; //内嵌的内核对象. struct module *owner; //该字符设备所在的内核模块的对象指针. const struct file_...
linux之字符设备驱动
刘一儿(嵌入式)
04-06 236
最近由于工作需要，因此回顾了下字符设备驱动。 具体的内容我就不多说了，直接看这位博主写的： Linux设备驱动（二）—— 字符设备驱动（三）——自动创建设备节点_Thanos Yan的博客-CSDN博客 写的是相当详细。 此处我主要介绍我使用的示例： app-write.c build.sh epoll_read.c Makefile memdev.c memdev.h memdev.c memdev.h是我的驱动示例文件 app-write.c 向字符设备驱动写一段十六进制
Linux设备驱动程序（中文版第三版）
08-24
字符设备驱动程序管理那些一次性读写一个或多个字符的设备，比如键盘或串口；块设备驱动程序处理以块为单位读写数据的设备，如硬盘驱动器；网络设备驱动程序则负责管理网络接口，实现数据包的发送和接收。 第三版的...
Linux设备驱动程序框架
03-23
### Linux设备驱动程序框架详解 #### 一、Linux设备驱动程序与外界的接口 Linux设备驱动程序作为连接硬件和操作系统的桥梁，其设计遵循一定的框架和原则，以便于更好地管理和控制硬件资源。根据Linux设备驱动程序...
Linux驱动-字符设备驱动
Vis-Lin的博客
11-30 3737
本文章： 1. Linux系统下字符设备驱动的开发 2. 介绍file_operations和地址映射 3. 字符设备驱动开发过程中涉及的函数 4. 展示了LED驱动的代码
Linux驱动——字符设备驱动
最新发布
Linux驱动开发工程师，熟悉Linux/Android底层驱动、TP、显示、IIC、网络等通用外设调试适配，Linux上层应用开发，主要集中在瑞芯微和全志平台。
04-08 2707
1.使用什么工具来写驱动代码：安装source insight工具（1）找到软件提示把工具安装激活（2）把Linux内核代码解压到windows目录中（3）打开工具添加查看的项目第一个对话框：第一个文本框：输入工程名字第二个文本框：路径(默认)第二个对话框： 在项目源码位置，选择 Linux内核代码位置 点击OK 第三个对话框： 选择需要查看的Linux内核代码的包含的源码文件（要查看的内核目录）需要添加的目录：driver/iicinclude。
Linux字符设备驱动
Louis@L.M.的博客
04-01 490
1. Linux字符设备驱动的概念     字符设备是 Linux 驱动中最基本的一类设备，它是能够像字节流一样被访问的设备，也就是说对它的读写是以字节为单位的。比如我们最常见的点灯、按键、 IIC、 SPI，LCD 等都是字符设备，这些设备的驱动就叫做字符设备驱动。字符设备的驱动程序实现了open、close、read、write等系统调用，应用程序可以通过设备文件(例如/dev/led)来访问...
Linux 字符设备驱动
haigand的专栏
04-29 321
https://www.cnblogs.com/cainiaoaixuexi/p/3684641.html http://www.cnblogs.com/qlee/archive/2011/07/27/2118406.html
linux字符设备驱动
liangqiuJL的博客
05-29 538
linux字符设备驱动 字符设备文件和字符设备驱动通过主设备号联系 主设备号对应设备类型 次设备区分同类型的设备 内核如何如何描述设备号? 用dev_t 实质为12+20位的整数 MAJOR MINOR 怎样申请设备驱动？ 1.静态申请 2.动态分配 int alloc_chrdev_region 安装后/proc/devices查看设备名 不用设备时，注销设备号
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值