嵌入式设计实验一：简单字符设备驱动

最新推荐文章于 2024-05-24 15:40:39 发布
最新推荐文章于 2024-05-24 15:40:39 发布
阅读量3.8k 收藏 38
点赞数 6
分类专栏： # 嵌入式系统设计
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sandalphon4869/article/details/105900817
版权

文章目录

一、实验目的

  • 掌握简单字符设备驱动程序编写方法。
  • 编写应用程序对驱动程序进行测试，学习应用程序与驱动程序之间的调用过程。

二、实验环境

ubuntu 12.04 内核3.2.14

三、实验内容及实验原理

写一个简单的字符设备驱动程序，要求：

  • 定义一个全局结构指针，初始值为NULL，该数据结构中包含一个大小为1024的buffer和一个count整形变量
  • 在open中对该全局结构进行NULL判断，为NULL则为其分配内存，并将buffer初始化为0，将count自加
  • 在release中如果count为0，则释放，否则进行count自减
  • 在read里面对该buffer进行读取
  • 在write里面对该buffer进行赋值（任意赋值即可）
    写测试程序进行测试

四、实验结果及其分析

1.编译模块（设备驱动程序）

（1）创建模块文件xxx.c

gedit rwbuf.c
区分版本：这里不同，低版本内核2.6以下的是ioctl，高版本内核2.6及其以上的是unlocked_ioctl。
在这里插入图片描述

// 模块
#include <linux/module.h>
// 内核
#include <linux/kernel.h>
// struct file_operations
#include <linux/fs.h>
// copy_to_user() & copy_from_user
#include <linux/uaccess.h>
// <string.h>不行，用于memset和strcpy
#include <linux/string.h>
// kmalloc和kfree
#include <linux/slab.h>

// rwbuf.c,  driver for virtual char-device
#define RW_CLEAR 0x123
// 设备名
#define DEVICE_NAME "rwbuf"

// buffer数组的最大长度
#define RWBUF_MAX_SIZE 1024
// 设备中存储信息的全局结构体指针
typedef struct Data
{
    // 用于打开和释放的验证，0表示未使用，1表示已使用
    int count;
    // 表示字符串
    char buffer[RWBUF_MAX_SIZE];
} Data, *DataPtr;

DataPtr myDataPtr = NULL;

// 设备的打开：只返回0表示成功无法表示报错
int rwbuf_open(struct inode *inode, struct file *file)
{
    // 如果未被使用
    if (myDataPtr == NULL)
    {
        // 分配堆
        myDataPtr = (DataPtr)kmalloc(sizeof(Data), GFP_KERNEL);
        // 字符数组清零
        memset(myDataPtr->buffer, 0, sizeof(myDataPtr->buffer));
        // 初始化为1,表示有人在使用了
        myDataPtr->count = 1;
        printk("[rwbuf_open-kmalloc-success]myDataPtr->count = %d.\n", myDataPtr->count);
        return 0;
    }
    // 已被使用
    else
    {
        // 增加一个用户
        myDataPtr->count += 1;
        printk("[rwbuf_open-countup]myDataPtr->count = %d.\n", myDataPtr->count);
        return 0;
    }
}

// 设备的关闭：返回-1表示错误；返回0表示成功
int rwbuf_release(struct inode *inode, struct file *file)
{
    // 当未打开时,报错
    if (myDataPtr == NULL)
    {
        printk("[rwbuf_release-error]\n");
        return -1;
    }
    // 当有用户使用时,则自减
    else
    {
        myDataPtr->count -= 1;
        printk("[rwbuf_release-countdown]myDataPtr->count = %d.\n", myDataPtr->count);

        // 当没用用户使用时,释放
        if (myDataPtr->count == 0)
        {
            // 释放堆区
            kfree(myDataPtr);
            // 还要让指针回归NULL，不要野指针
            myDataPtr = NULL;
            printk("[rwbuf_release-free-success]\n");
            return 0;
        }
        return 0;
    }
}

// 设备的读操作：返回-1表示错误；返回(0, RWBUF_MAX_SIZE]表示成功
ssize_t rwbuf_read(struct file *file, char *buf, size_t count, loff_t *f_pos)
{
    // 判断读取的长度是否有效
    if (strlen(myDataPtr->buffer) > 0 && strlen(myDataPtr->buffer) <= RWBUF_MAX_SIZE)
    {
        // 从内核空间rwbuf复制到用户空间buf
        copy_to_user(buf, myDataPtr->buffer, count);
        printk("[rwbuf_read-success]the size of myDataPtr->buffer after read = %d\n", strlen(myDataPtr->buffer));
        return count;
    }
    else
    {
        printk("[rwbuf_read-error] strlen(myDataPtr->buffer) = %d\n", strlen(myDataPtr->buffer));
        return -1;
    }
}

// 设备的写操作接：返回-1表示错误；返回(0, RWBUF_MAX_SIZE]表示成功
ssize_t rwbuf_write(struct file *file, const char *buf, size_t count, loff_t *f_pos)
{
    // 判断写入的长度是否有效
    if (count > 0 && count <= RWBUF_MAX_SIZE)
    {
        // 从用户空间buf复制到内核空间rwbuf
        copy_from_user(myDataPtr->buffer, buf, count);
        printk("[rwbuf_write-success] the size of myDataPtr->buffer after write = %d\n", strlen(myDataPtr->buffer));
        return count;
    }
    else
    {
        printk("[rwbuf_write-error] length of string = %d\n", count);
        return -1;
    }
}

// 设备的ioctl：返回-1表示错误；返回0表示成功
long rwbuf_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    printk("[RW_CLEAR:%x],[cmd:%x]\n", RW_CLEAR, cmd);
    // 命令
    if (cmd == RW_CLEAR)
    {
        // 表示清零
        memset(myDataPtr->buffer, 0, sizeof(myDataPtr->buffer));
        printk("[rwbuf_ioctl-success] the size of myDataPtr->buffer after ioctl = %d\n", strlen(myDataPtr->buffer));
        return 0;
    }
    // 无此命令时
    else
    {
        printk("[rwbuf_ioctl-error] the size of myDataPtr->buffer after ioctl = %d\n", strlen(myDataPtr->buffer));
        return -1;
    }
}

// rwbuf_fops要在rwf_buf_init()前面声明，因为register_chrdev()函数要使用到
static struct file_operations rwbuf_fops =
    {
        open : rwbuf_open,
        release : rwbuf_release,
        read : rwbuf_read,
        write : rwbuf_write,
        unlocked_ioctl : rwbuf_ioctl
    };

// module_init()内的初始化函数：返回-1表示错误；返回0表示成功
static int __init rwbuf_init()
{
    // 表示注册成功与否：-1表示失败，0表示成功（同register_chrdev返回值）。初始化为-1
    int ret = -1;
    /*
    参数1：设备的种类，即主设备号
    参数2：设备的名称
    参数3：和VFS对接的接口，即上面的结构体变量
    */
    ret = register_chrdev(60, DEVICE_NAME, &rwbuf_fops);
    // 注册失败
    if (ret == -1)
    {
        printk("[rwbuf_init-register-failed]\n");
    }
    // 注册成功
    else
    {
        printk("[rwbuf_init-register-success]\n");
    }
    // 返回ret（同register_chrdev返回值）
    return ret;
}

// module_exit()内的退出函数。
static void __exit rwbuf_exit()
{
    unregister_chrdev(60, DEVICE_NAME);
    printk("[rwbuf_exit-unregister-success]\n");
}

// 内核模块入口,相当于main()函数,完成模块初始化
module_init(rwbuf_init);
// 卸载时调用的函数入口,完成模块卸载
module_exit(rwbuf_exit);
// GPL协议证书
MODULE_LICENSE("GPL");

意思：

结构体static struct file_operations rwbuf_fops是定义函数指针
比如将open指向rwbuf_open，我们调用的时候就打open就是调用rwbuf_open。其中ioctl特殊，调用的时候用ioctl才对，用unlocked_ioctl反而不对，而且定义成旧版本的ioctl，对高版本内核更不对（编译不报错，但读进入的数cmd就成一个莫名其妙的8位十六进制数）。
结构体rwbuf_fops在rwf_buf_init_module()中被用到，生效对结构体变量的操作。
if(register_chrdev(60, DEVICE_NAME, &rwbuf_fops))

（2）Makefile

gedit Makefile
内容：

obj-m := rwbuf.o
KERNELDIR := /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)
modules:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules
clean:
	rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions modules.order  Module.symvers

（3）编译

sudo make
在这里插入图片描述

2.创建设备文件（设备进入点）

（1）创建

sudo mknod /dev/rwbuf c 60 0

意思：
在/dev目录下创建一个名为rwbuf的设备文件
设备文件的类型是c（字符型设备）
主设备号是60
次设备号是0

（2）赋权

sudo chmod 777 /dev/rwbuf
更改设备的权限。没有读写权限的话，就会读出一堆无意义的乱码。

3.插入内核模块（加载设备驱动程序）

先清理一下缓存，不然一会就可能输出一大堆多余东西，影响到我们想要看到的输出东西
sudo dmesg -c
插入内核模块（加载设备驱动程序）
sudo insmod rwbuf.ko
查看是否成功
dmesg
在这里插入图片描述

4.测试用户应用程序（调用驱动程序）

（1）读写

gedit writeAndRead.c
#include <stdio.h>
// 为了open()中的O_RDWR
#include <fcntl.h>

// 定义设备进入点（设备名）
#define DEVICE_NAME "/dev/rwbuf"

int main()
{
    // 声明文件描述符
    int fd;
    // 记录关闭设备的返回值
    int ret;
    // 写入到设备的内容
    char buff_write[10] = "volume";
    // 读取到设备的结果
    char buff_read[10] = "";

    // 调用打开设备函数。注意O_RDWR是字母O
    fd = open(DEVICE_NAME, O_RDWR);
    // 打开失败
    if (fd == -1)
    {
        printf("[open-error]\n");
        return 0;
    }
    else
    {
        printf("[open-success]\n");
    }

    // 调用驱动程序的写操作接口函数
    if (write(fd, buff_write, 5) == -1)
    {
        printf("[write-error]\n");
        return 0;
    }
    // 写入成功
    else
    {
        printf("[write-success] %s\n", buff_write);
    }

    // 调用驱动程序的读操作接口函数
    if (read(fd, buff_read, 5) == -1)
    {
        printf("[read-error]\n");
        return 0;
    }
    // 读取成功
    else
    {
        buff_read[5] = '\0';
        printf("[read-success] %s\n", buff_read);
    }

    // 设备关闭
    close(fd);
    printf("[close-success]\n");

    return 0;
}

运行：
gcc -o writeAndRead.out -g writeAndRead.c
./writeAndRead.out
在这里插入图片描述
在这里插入图片描述

（2）清除程序

gedit ioctl.c

#include <stdio.h>
// 为了open()中的O_RDWR
#include <fcntl.h>

// 定义设备进入点（设备名）
#define DEVICE_NAME "/dev/rwbuf"

int main()
{
    // 声明文件描述符
    int fd;
    // 记录关闭设备的返回值
    int ret;
    // 写入到设备的内容
    char buff_write[10] = "volume";
    // 读取到设备的结果
    char buff_read[10] = "";
    // 控制命令
    unsigned int cmd = 0x123;

    // 调用打开设备函数。注意O_RDWR是字母O
    fd = open(DEVICE_NAME, O_RDWR);
    // 打开失败
    if (fd == -1)
    {
        printf("[open-error]\n");
        return 0;
    }
    else
    {
        printf("[open-success]\n");
    }

    // 调用驱动程序的写操作接口函数
    if (write(fd, buff_write, 5) == -1)
    {
        printf("[write-error]\n");
        return 0;
    }
    // 写入成功
    else
    {
        printf("[write-success] %s\n", buff_write);
    }

    // 调用驱动程序的写操作接口函数
    if (ioctl(fd, cmd) == -1)
    {
        printf("[ioctl-error]\n");
        return 0;
    }
    else
    {
        printf("[ioctl-success]\n");
    }

    // 调用驱动程序的读操作接口函数
    if (read(fd, buff_read, 5) == -1)
    {
        printf("[read-error]\n");
        return 0;
    }
    // 读取成功
    else
    {
        buff_read[5] = '\0';
        printf("[read-success] %s\n", buff_read);
    }

    // 设备关闭
    close(fd);
    printf("[close-success]\n");

    return 0;
}

运行：
gcc -o ioctl.out -g ioctl.c
./ioctl.out

在这里插入图片描述
在这里插入图片描述

5.野指针问题

这个属于个人书写代码的规范不好，
在这里插入图片描述

如果kfree(myDataPrt)后没有将myDataPrt=NULL;就会再次打开后判读此条件失败，从而count是乱值。

五、心得体会与建议

感觉还是遇到了不少的难处，并没有看着那么简单

1.隐式声明函数‘copy_from_user’

2.总结copy_from_user()和copy_to_user()

编译内核函数copy_from_user()和copy_to_user()

3.\xffffffe7\xffffffa4\xffffffba\问题

Linux驱动开发：\xffffffe7\xffffffa4\xffffffba\问题

4.调整代码结构

（1）问题

驱动程序

// buffer数组的最大长度
#define RWBUF_MAX_SIZE 1024
// 设备中存储信息的全局结构体指针
typedef struct Data
{
    // 用于打开和释放的验证，0表示未使用，1表示已使用
    int count;
    // 表示字符串
    char buffer[RWBUF_MAX_SIZE];
} Data, *DataPtr;

DataPtr myDataPtr = NULL;

// 设备的关闭：返回-1表示错误；返回0表示成功
int rwbuf_release(struct inode *inode, struct file *file)
{
    // 当未打开时,报错
    if (myDataPtr == NULL)
    {
        printk("[rwbuf_release-error]\n");
        return -1;
    }
    // 当没用用户使用时,释放
    if (myDataPtr->count == 0)
    {
        kfree(myDataPtr);
        printk("[rwbuf_release-free-success]myDataPtr->count = %d.\n", myDataPtr->count);
        return 0;
    }
    // 当有用户使用时,则自减
    else
    {
        myDataPtr->count -= 1;
        printk("[rwbuf_release-countdown]myDataPtr->count = %d.\n", myDataPtr->count);
        return 0;
    }
}

在这里插入图片描述

用户测试程序

// 设备关闭
close(fd);
printf("[close-success]\n");

close(fd);
printf("[close-release-success]\n");

在这里插入图片描述

可以看到没出现对应printk("[rwbuf_release-free-success]myDataPtr->count = %d.\n", myDataPtr->count);的结果，即没有释放成功。

（2）解决

既然close(fd)只能生效一次，那么移动到里面就行了。

// 设备的关闭：返回-1表示错误；返回0表示成功
int rwbuf_release(struct inode *inode, struct file *file)
{
    // 当未打开时,报错
    if (myDataPtr == NULL)
    {
        printk("[rwbuf_release-error]\n");
        return -1;
    }
    // 当有用户使用时,则自减
    else
    {
        myDataPtr->count -= 1;
        printk("[rwbuf_release-countdown]myDataPtr->count = %d.\n", myDataPtr->count);

        // 当没用用户使用时,释放
        if (myDataPtr->count == 0)
        {
            kfree(myDataPtr);
            printk("[rwbuf_release-free-success]\n");
            return 0;
        }
        return 0;
    }
}

在这里插入图片描述

sandalphon4869
关注
  • 6
    点赞
  • 踩
  • 38
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
字符设备驱动数据结构
qq_36412526的博客
11-13 574
前言 数据结构是字符设备驱动的核心,其它很多代码都是围绕数据结构展开的,所以有必要对字符设备驱动数据结构做一个梳理,先看两张图,便于从宏观上了解字符设备驱动程序. 一. 定义: static struct char_device_struct { struct char_device_struct *next; unsigned int major; // 主设备号 unsigned int ...
嵌入式系统实验1-简单字符设备驱动实验
qq_40427276的博客
04-24 2348
写一个简单的字符设备驱动程序，要求： 定义一个全局结构指针，初始值为NULL，该数据结构中包含一个大小为1024的buffer和一个count整形变量 在open中对该全局结构进行NULL判断，为NULL则为其分配内存，并将buffer初始化为0，将count自加 在release中如果count为0，则释放，否则进行count自减 在read里面对该buffer进行读取 在write里面对该bu...
【linux-IMX6ULL-字符设备驱动简单框架实验】
最新发布
w384829981的博客
05-24 656
目前的驱动开发一般是分为三类，第一类就是字符设备驱动、块设备驱动、和网络驱动三类，其中字符设备驱动是最多最杂的，现在对字符设备驱动进行一个简要的介绍：通过设备注册使设备能被系统识别；注销则相反；通常包含open,read,write,realse等；处理设备产生的中断，以响应特定事件；通过字符型设备驱动，可以使系统方便统一管理不同的设备，这样就可以给上层应用提供相应的接口函数，方便应用程序与设备之间进行数据交换和通信；
使用ioctl传递字符数组和结构体
Vpipiguai的博客
03-17 398
入门嵌入式
【嵌入式环境下linux内核及驱动学习笔记-（4-字符驱动实例）】
weixin_45499326的博客
04-16 588
使用一个内存缓冲虚拟一个字符型设备，进行字符驱动的模拟实例。
UNIX网络编程——ioctl 函数的用法详解
weixin_33754913的博客
08-04 374
1.介绍 Linux网络程序与内核交互的方法是通过ioctl来实现的，ioctl与网络协议栈进行交互，可得到网络接口的信息，网卡设备的映射属性和配置网络接口。并且还能够查看，修改，删除ARP高速缓存的信息，所以，我们有必要了解一下ioctl函数的具体实现。2.相关结构体与相关函数#include <sys/ioctl.h> int ioctl(int d,int re...
驱动——ioctl数组及结构体传递
ww1106的博客
11-17 1105
2>在long mydev_ioctl (struct file *file, unsigned int cmd, unsigned long arg)接口函数内，使用copy_from_user接收用户空间拷贝过来的信息，并进行打印，再使用copy_to_user函数将修改后的结构体信息拷贝到用户空间。4>通过dmesg查看内核层的打印信息，结果如下所示，应用层传递的数组信息以及结构体信息成功传递到内核层。3>编写用户程序，通过ioctl函数传递信息给内核空间，从而达到想要的操作结果，并进行打印。
XDU嵌入式驱动程序设计 实验一 简单字符设备驱动
08-10
实验题目： 简单字符设备驱动 一、实验目的 1.掌握简单字符设备驱动程序编写方法。 2.编写应用程序对驱动程序进行测试，学习应用程序与驱动程序之间的调用过程。 二、实验环境 Linux 3.14.0 嵌入式开发板 三、...
基于ARM9的Linux嵌入式字符驱动GPIO设计
01-29
为了实现嵌入式linux的移植和开发，本文采用了ARM9完成了的嵌入式Linux字符驱动开发，为后续更复杂的开发奠定了基础。本文介绍了设计字符驱动开发的基本流程，完成了linux的移植以及驱动程序的开发，并且利用LED和...
嵌入式系统原理与设计实验报告
06-09
我们将在 2410RP 这一实验开发平台上进行了诸多嵌入式的基础实验，并将其中两个具有代表性的实验的原理、内容、结果以及驱动和测试程序写出来。 实验一：数码管显示 实验目的：掌握数码管显示的原理和设计方法，...
Linux 高级字符驱动实验
06-06
Linux 高级字符驱动实验是计算机科学与技术系的一门实验课程，旨在通过Linux操作系统的基本IO接口驱动实验，掌握嵌入式Linux GPIO设备操作步骤。实验的主要内容包括编译一个简单的字符设备驱动内核模块，掌握利用...
操作系统课程设计-简单字符设备和块设备驱动程序
01-30
配合我写的两篇关于简单字符设备和块设备驱动使用，这里是两个驱动程序的完整文件，使用的是 Ubuntu 16.0 的系统环境
简单linux字符设备驱动程序与编程小技巧
02-16
简单linux字符设备驱动程序与编程小技巧 代码分析请看http://blog.csdn.net/jiebaoabcabc/article/details/19242621 http://blog.csdn.net/jiebaoabcabc/article/details/19283859
Linux字符设备驱动实验代码
01-08
简单的字符设备的驱动程序，并对所编写的设备驱动程序进行测试，了解Linux操作系统如何管理字符设备。由于网上许多资源不完整，本资源整合了许多内容。包括驱动程序memdev.c，memdev.h，app-mem.c，MakeFile文件。执行步骤： a) cat /proc/devices看看有哪些编号已经被使用，我们选一个没有使用的XXX。 b) insmod memdev.ko c) 通过"mknod /dev/memdev0 c XXX 0"命令创建"/dev/memdev0"设备节点。 d) 交叉编译app-mem.c文件，下载并执行
XDU嵌入式驱动程序设计 实验二 模块参数及Proc文件系统
08-10
写一个简单的字符驱动设备，要求： ①定义一个全局结构指针，初始值为NULL，该数据结构中包含一个大小为N的buffer； ②在open中对该全局结构进行NULL判断，为NULL则为其分配内存，并将buffer初始化为0； ③在...
使用ioctl和内核交换数据
liuqiang_mail的专栏
08-21 686
使用ioctl和内核交换数据 1. 前言 使用ioctl系统调用是用户空间向内核交换数据的常用方法之一，从ioctl这个名称上看，本意是针对I/O设备进行的控制操作，但实际并不限制是真正的I/O设备，能是所有一个内核设备即可。 2. 基本过程 在内核空间中ioctl是非常多内核操作结构的一个成员函数，如文件操作结构struct file_operations(include/linux/f
嵌入式字符设备驱动程序
zhm1949的博客
04-23 492
嵌入式字符设备驱动程序hello驱动程序的测试程序 前面分享了不涉及硬件操作的hello字符驱动程序的设计过程，这次分享一下相应的测试程序。 后面我会结合STM32MP157开发板，给大家分享涉及硬件操作的字符设备的驱动程序该如何实现。并给大家演示在开发板上的操作。 五一假期我也会在公众号（河边小乌龟爬）带着大家用五天的时间完成一个嵌入式相关的小项目：基于QT的视频监控系统。 通过这个项目大家能够掌握QT界面设计及编程的基本知识，与开发板实现UDP通信，多线程编程，v4l2视频处理模块，及开发板设备驱动节点
嵌入式实验报告（linux实验）
热门推荐
codes_first的博客
06-27 1万+
1 LED 灯驱动程序1.1 “文件”的实现设备驱动作为操作系统的一部分，是操作系统对设备进行操作的接口。操作系统规定了设备驱动需要实现的接口，而我们在裸机实验中也用到了控制设备所用到的接口。为了实现我们嵌入式实验箱的linux 驱动程序，我们需要将这两个接口好好的“对接”一下。参考ours_led.c 文件，我们做如下分析：首先，我们定义设备的i 节点名称, 这样我们就能在我们的文件系统中找到我...
linux字符设备驱动 实验
12-08
Linux字符设备驱动实验是指在Linux操作系统中编写和测试字符设备驱动程序的过程。字符设备驱动程序负责与字符设备进行交互，包括输入输出数据、控制设备和处理设备的状态等。 在进行Linux字符设备驱动实验之前，首先需要了解字符设备和字符设备驱动的基本概念及其工作原理。字符设备是指以字符为单位进行输入输出的设备，如串口、打印机等。字符设备驱动是指将操作系统与字符设备进行交互的程序。 在实验中，我们通常需要编写一个字符设备驱动程序，包括初始化设备、读写数据、控制设备等功能。首先，我们需要定义字符设备驱动的数据结构，包括设备号、驱动程序打开、关闭等函数的实现。然后，我们需要实现字符设备驱动的读写函数来实现数据的输入输出。最后，我们可以进行一些附加功能的实现，如控制设备的状态、处理中断等。 在实验过程中，我们需要使用Linux内核提供的字符设备接口来进行字符设备驱动的编写和测试。可以使用一些工具和命令来加载和测试字符设备驱动程序，如insmod、rmmod等。通过这些工具和命令，我们可以加载和卸载字符设备驱动程序，并在用户空间进行数据的读写操作，来测试字符设备驱动的功能和性能。 Linux字符设备驱动实验可以帮助我们深入了解字符设备和字符设备驱动的工作原理，并学习Linux内核的开发和调试技术。通过实验，我们可以更好地理解操作系统和驱动程序之间的关系，提高我们在Linux系统开发和嵌入式系统开发中的能力。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值