S5PV210 基于设备树点亮LED

最新推荐文章于 2021-10-04 18:04:34 发布
最新推荐文章于 2021-10-04 18:04:34 发布
阅读量389 收藏
点赞数
分类专栏： linux5.10.10之S5PV210
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33472414/article/details/115148351
版权

device tree：

/* 添加 led 节点 */
led {
	#address-cells = <1>;
	#size-cells = <1>;
	compatible = "s5pv210, led";
	ranges; /* 这个非常重要，必须添加，不然of_iomap就不能成功*/

	/* 蓝灯子节点 */
	blue_led@0xe0200240 {
		compatible = "s5pv210, blue_led";
		reg = <
				0xe0200240 0x4
				0xe0200244 0x4
		      >;
		status = "okay";
		pin = <0x3>;
	};

	/* 黄灯子节点 */
	yellow_led@0xe0200240 {
		compatible = "s5pv210, yellow_led";
		reg = <
				0xe0200240 0x4
				0xe0200244 0x4
		      >;
		status = "okay";
		pin = <0x4>;
	};

	/* 红灯子节点 */
	red_led@0xe0200240 {
		compatible = "s5pv210, red_led";
		reg = <
				0xe0200240 0x4
				0xe0200244 0x4
		      >;
		status = "okay";
		pin = <0x5>;
	};

驱动程序：

#include <linux/module.h>		
#include <linux/init.h>
#include <linux/platform_device.h>
#include <asm/io.h>
#include <linux/types.h>
#include <linux/cdev.h>
#include <linux/fs.h>

/* dts */
#include <linux/of.h>
#include <linux/of_address.h>

#define DEV_CNT		(1)
#define DEV_NAME	"s5pv210_led"

struct led_ctrl
{
	void __iomem * blue_led_reg_con;
	void __iomem * blue_led_reg_dat;
	int blue_led_pin;

	void __iomem * yellow_led_reg_con;
	void __iomem * yellow_led_reg_dat;
	int yellow_led_pin;

	void __iomem * red_led_reg_con;
	void __iomem * red_led_reg_dat;
	int red_led_pin;

	/* char device driver*/
	dev_t dev_id;
	struct cdev led_chr_dev;
	struct class * led_class;
	struct device * led_device;
};

static struct led_ctrl g_led_ctrl = {0};

static int led_chr_dev_open(struct inode *inode, struct file *filp)
{
	printk(KERN_INFO "open driver\n");
	return 0;
}

int led_chr_dev_release(struct inode *inode, struct file *filp)
{
	printk(KERN_INFO "release driver\n");
	return 0;
}

static ssize_t led_chr_dev_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
	int ret = -1;
	unsigned int user_data = 0;
	unsigned int reg_data = 0;
	ret = copy_from_user(&user_data, buf, cnt);
	if (ret < 0)
	{
		printk(KERN_INFO "copy_from_user error\n");
		return -EINVAL;
	}
	/* bit[0:7]: blue_led, bit[8:15]: yellow led, bit[16:23]: red led*/
	if (user_data & 0xff)
	{
		reg_data = readl(g_led_ctrl.blue_led_reg_dat);
		reg_data &= ~(0x1 << g_led_ctrl.blue_led_pin );
		writel(reg_data, g_led_ctrl.blue_led_reg_dat);
	}
	else
	{
		reg_data = readl(g_led_ctrl.blue_led_reg_dat);
		reg_data &= ~(0x1 << g_led_ctrl.blue_led_pin );
		reg_data |= (0x1 << g_led_ctrl.blue_led_pin);
		writel(reg_data, g_led_ctrl.blue_led_reg_dat);
	}

	if ((user_data >> 8) & 0xff)
	{
		reg_data = readl(g_led_ctrl.yellow_led_reg_dat);
		reg_data &= ~(0x1 << g_led_ctrl.yellow_led_pin );
		writel(reg_data, g_led_ctrl.yellow_led_reg_dat);
	}
	else
	{
		reg_data = readl(g_led_ctrl.yellow_led_reg_dat);
		reg_data &= ~(0x1 << g_led_ctrl.yellow_led_pin );
		reg_data |= (0x1 << g_led_ctrl.yellow_led_pin);
		writel(reg_data, g_led_ctrl.yellow_led_reg_dat);
	}

	if ((user_data >> 16) & 0xff)
	{
		reg_data = readl(g_led_ctrl.red_led_reg_dat);
		reg_data &= ~(0x1 << g_led_ctrl.red_led_pin );
		writel(reg_data, g_led_ctrl.red_led_reg_dat);
	}
	else
	{
		reg_data = readl(g_led_ctrl.red_led_reg_dat);
		reg_data &= ~(0x1 << g_led_ctrl.red_led_pin );
		reg_data |= (0x1 << g_led_ctrl.red_led_pin);
		writel(reg_data, g_led_ctrl.red_led_reg_dat);
	}
	return 0;
}

/*字符设备操作函数集*/
static struct file_operations led_chr_dev_fops =
{
	.owner = THIS_MODULE,
	.open = led_chr_dev_open,
	.write = led_chr_dev_write,
};

static int s5pv210_led_probe(struct platform_device * device)
{
	int ret = -1;
	unsigned int reg_data = 0;
	struct device_node	* s5pv210_led = NULL;
	struct device_node	* s5pv210_led_blue = NULL;
	struct device_node	* s5pv210_led_yellow = NULL;
	struct device_node	* s5pv210_led_red = NULL;

	/*
	find led in /
	*/
	s5pv210_led = of_find_node_by_path("/led");
	if (NULL == s5pv210_led)
	{
		printk(KERN_INFO "of_find_node_by_path error\n");
		goto blue_led_reg_con_err;
	}

	/*
	child blue_led
	*/
	s5pv210_led_blue = of_find_node_by_name(s5pv210_led, "blue_led");
	if (NULL == s5pv210_led_blue)
	{
		printk(KERN_INFO "of_find_node_by_name error\n");
		goto blue_led_reg_con_err; 
	}
	ret = of_property_read_u32(s5pv210_led_blue, "pin", &(g_led_ctrl.blue_led_pin));
    if (ret)
	{
		printk(KERN_ERR "of_property_read_u32 error\n");
		goto blue_led_reg_con_err;
	}

	g_led_ctrl.blue_led_reg_con = of_iomap(s5pv210_led_blue, 0);
	if (NULL == g_led_ctrl.blue_led_reg_con)
	{
		printk(KERN_INFO "of_iomap blue_led_reg_con error\n");
		goto blue_led_reg_con_err;
	}

	g_led_ctrl.blue_led_reg_dat = of_iomap(s5pv210_led_blue, 1);
	if (NULL == g_led_ctrl.blue_led_reg_dat)
	{
		printk(KERN_INFO "of_iomap blue_led_reg_dat error\n");
		goto blue_led_reg_dat_err;
	}

	reg_data = readl(g_led_ctrl.blue_led_reg_con);
	reg_data &= ~(0xf << (g_led_ctrl.blue_led_pin * 4));
	reg_data |= (0x1 << (g_led_ctrl.blue_led_pin * 4));
	writel(reg_data, g_led_ctrl.blue_led_reg_con);

	reg_data = readl(g_led_ctrl.blue_led_reg_dat);
	reg_data &= ~(0x1 << g_led_ctrl.blue_led_pin );
	reg_data |= (0x1 << g_led_ctrl.blue_led_pin);
	writel(reg_data, g_led_ctrl.blue_led_reg_dat);

	/*
	child yellow_led
	*/
	s5pv210_led_yellow = of_find_node_by_name(s5pv210_led, "yellow_led");
	if (NULL == s5pv210_led_yellow)
	{
		printk(KERN_INFO "of_find_node_by_name error\n");
		goto blue_led_reg_dat_err; 
	}
	ret = of_property_read_u32(s5pv210_led_yellow, "pin",
		&(g_led_ctrl.yellow_led_pin));
	if (ret)
	{
		printk(KERN_ERR "of_property_read_u32 error\n");
		goto blue_led_reg_dat_err;
	}
	g_led_ctrl.yellow_led_reg_con = of_iomap(s5pv210_led_yellow, 0);
	if (NULL == g_led_ctrl.yellow_led_reg_con)
	{
		printk(KERN_INFO "of_iomap yellow_led_reg_con error\n");
		goto yellow_led_reg_con_err;
	}
	g_led_ctrl.yellow_led_reg_dat = of_iomap(s5pv210_led_yellow, 1);
	if (NULL == g_led_ctrl.yellow_led_reg_dat)
	{
		printk(KERN_INFO "of_iomap yellow_led_reg_dat error\n");
		goto yellow_led_reg_dat_err;
	}
	reg_data = readl(g_led_ctrl.yellow_led_reg_con);
	reg_data &= ~(0xf << (g_led_ctrl.yellow_led_pin * 4));
	reg_data |= (0x1 << (g_led_ctrl.yellow_led_pin * 4));
	writel(reg_data, g_led_ctrl.yellow_led_reg_con);

	reg_data = readl(g_led_ctrl.yellow_led_reg_dat);
	reg_data &= ~(0x1 << g_led_ctrl.yellow_led_pin );
	reg_data |= (0x1 << g_led_ctrl.yellow_led_pin);
	writel(reg_data, g_led_ctrl.yellow_led_reg_dat);

	/*
	child red_led
	*/
	s5pv210_led_red = of_find_node_by_name(s5pv210_led, "red_led");
	if (NULL == s5pv210_led_red)
	{
		printk(KERN_INFO "of_find_node_by_name error\n");
		goto yellow_led_reg_dat_err;
	}
	ret = of_property_read_u32(s5pv210_led_red, "pin",
		&(g_led_ctrl.red_led_pin));
	if (ret)
	{
		printk(KERN_ERR "of_property_read_u32 error\n");
		goto yellow_led_reg_dat_err;
	}
	g_led_ctrl.red_led_reg_con = of_iomap(s5pv210_led_red, 0);
	if (NULL == g_led_ctrl.red_led_reg_con)
	{
		printk(KERN_INFO "of_iomap red_led_reg_con error\n");
		goto red_led_reg_con_err;
	}
	g_led_ctrl.red_led_reg_dat = of_iomap(s5pv210_led_red, 1);
	if (NULL == g_led_ctrl.red_led_reg_dat)
	{
		printk(KERN_INFO "of_iomap red_led_reg_con error\n");
		goto red_led_reg_dat_err;
	}
	reg_data = readl(g_led_ctrl.red_led_reg_con);
	reg_data &= ~(0xf << (g_led_ctrl.red_led_pin * 4));
	reg_data |= (0x1 << (g_led_ctrl.red_led_pin * 4));
	writel(reg_data, g_led_ctrl.red_led_reg_con);

	reg_data = readl(g_led_ctrl.red_led_reg_dat);
	reg_data &= ~(0x1 << g_led_ctrl.red_led_pin );
	reg_data |= (0x1 << g_led_ctrl.red_led_pin);
	writel(reg_data, g_led_ctrl.red_led_reg_dat);

	/* char device driver*/
	ret = alloc_chrdev_region(&g_led_ctrl.dev_id, 0, DEV_CNT, DEV_NAME);
	if (ret)
	{
		printk(KERN_INFO "alloc_chrdev_region error\n");
		goto red_led_reg_dat_err;
	}
	g_led_ctrl.led_chr_dev.owner = THIS_MODULE;
	cdev_init(&g_led_ctrl.led_chr_dev, &led_chr_dev_fops);
	ret = cdev_add(&g_led_ctrl.led_chr_dev, g_led_ctrl.dev_id, DEV_CNT);
	if (ret)
	{
		printk(KERN_INFO "cdev_add error\n");
		goto cdev_add_err;
	}
	g_led_ctrl.led_class = class_create(THIS_MODULE, DEV_NAME);
	if (NULL == g_led_ctrl.led_class)
	{
		printk(KERN_INFO "class_create error\n");
		goto class_create_err;
	}
	g_led_ctrl.led_device = device_create(g_led_ctrl.led_class, NULL, g_led_ctrl.dev_id, NULL, DEV_NAME);
	if (NULL == g_led_ctrl.led_device)
	{
		printk(KERN_INFO "device_create error\n");
		goto device_create_err;
	}
	return 0;
device_create_err:
	class_destroy(g_led_ctrl.led_class);
class_create_err:
	cdev_del(&g_led_ctrl.led_chr_dev);
cdev_add_err:
	unregister_chrdev_region(g_led_ctrl.dev_id, DEV_CNT);
red_led_reg_dat_err:
	iounmap(g_led_ctrl.red_led_reg_con);
red_led_reg_con_err:
	iounmap(g_led_ctrl.yellow_led_reg_dat);
yellow_led_reg_dat_err:
	iounmap(g_led_ctrl.yellow_led_reg_con);
yellow_led_reg_con_err:
	iounmap(g_led_ctrl.blue_led_reg_dat);
blue_led_reg_dat_err:
	iounmap(g_led_ctrl.blue_led_reg_con);
blue_led_reg_con_err:
	return -EINVAL;
}

static int s5pv210_led_remove(struct platform_device * device)
{
	device_destroy(g_led_ctrl.led_class, g_led_ctrl.dev_id);
	class_destroy(g_led_ctrl.led_class);
	cdev_del(&g_led_ctrl.led_chr_dev);
	unregister_chrdev_region(g_led_ctrl.dev_id, DEV_CNT);
	iounmap(g_led_ctrl.blue_led_reg_con);
	iounmap(g_led_ctrl.blue_led_reg_dat);
	iounmap(g_led_ctrl.yellow_led_reg_con);
	iounmap(g_led_ctrl.yellow_led_reg_dat);
	iounmap(g_led_ctrl.red_led_reg_con);
	iounmap(g_led_ctrl.red_led_reg_dat);
	return 0;
}

static const struct of_device_id s5pv210_led_of_match_table[] =
{
	{.compatible = "s5pv210, led",},
	{},
};

static struct platform_driver s5pv210_led_driver = 
{
	.probe = s5pv210_led_probe,
	.remove = s5pv210_led_remove,
	.driver = {
		.name = "s5pv210_led",
		.owner = THIS_MODULE,
		.of_match_table = s5pv210_led_of_match_table,
	}
};

// 模块安装函数
static int __init chrdev_init(void)
{
	int ret = platform_driver_register(&s5pv210_led_driver);
	if (ret)
	{
		printk(KERN_INFO "platform_driver_register fail\n");
		return -EINVAL; 
	}
	printk(KERN_INFO "platform_driver_register ok\n");
	return 0;
}

// 模块卸载函数
static void __exit chrdev_exit(void)
{
	platform_driver_unregister(&s5pv210_led_driver);
	printk(KERN_INFO "platform_driver_unregister\n");
}


module_init(chrdev_init);
module_exit(chrdev_exit);

// MODULE_xxx这种宏作用是用来添加模块描述信息
MODULE_LICENSE("GPL");				// 描述模块的许可证
MODULE_AUTHOR("Mark");				// 描述模块的作者
MODULE_DESCRIPTION("test for driver");	// 描述模块的介绍信息
MODULE_ALIAS("alias test");			// 描述模块的别名信息

应用程序：

#include <iostream>
#include <thread>

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

#define ON   	(true)
#define OFF     (false)

#define DEVICE_NAME	"/dev/s5pv210_led"

class Led
{
public:
	Led(int on_off);
	~Led(void);

	void ctrlSubBlueLed(int on_off);
	void ctrlSubYellowLed(int on_off);
	void ctrlSubRedLed(int on_off);
	void ctrlAllLed(int on_off);
private:
	unsigned char subBlueStatus;
	unsigned char subYellowStatus;
	unsigned char subRedStatus;

	int fd;
};

Led::Led(int on_off) : fd(0)
{
	unsigned int status = 0;
	subBlueStatus = on_off;
	subYellowStatus = on_off;
	subRedStatus = on_off;

	fd = open(DEVICE_NAME, O_RDWR);
	if (fd < 0)
	{
		std::cout << DEVICE_NAME << "open fail\n";
		return;
	}
	status = (subBlueStatus) | (subYellowStatus << 8) | (subRedStatus << 16);
	write(fd, &status, sizeof(status));
}

Led::~Led(void)
{
	unsigned int status = 0;
	if (0 != fd)
	{
		write(fd, &status, sizeof(status));
		close(fd);
	}
}

void Led::ctrlSubBlueLed(int on_off)
{
	unsigned int status = 0;
	subBlueStatus = on_off;
	status |= subBlueStatus;
	write(fd, &status, sizeof(status));
}

void Led::ctrlSubYellowLed(int on_off)
{
	unsigned int status = 0;
	subYellowStatus = on_off;
	status |= (subYellowStatus << 8);
	write(fd, &status, sizeof(status));
}

void Led::ctrlSubRedLed(int on_off)
{
	unsigned int status = 0;
	subRedStatus = on_off;
	status |= (subRedStatus << 16);
	write(fd, &status, sizeof(status));
}

void Led::ctrlAllLed(int on_off)
{
	unsigned int status = 0;
	subBlueStatus = on_off;
	subYellowStatus = on_off;
	subRedStatus = on_off;
	status = (subBlueStatus) | (subYellowStatus << 8) | (subRedStatus << 16);
	write(fd, &status, sizeof(status));
}

void ledShowTask(void)
{
	Led ledCtrlObj(OFF);
	std::string cmd = "";
	while (1)
	{
		ledCtrlObj.ctrlAllLed(ON);
		usleep(500 * 1000);
		ledCtrlObj.ctrlAllLed(OFF);
		usleep(500 * 1000);
		ledCtrlObj.ctrlSubBlueLed(ON);
		usleep(500 * 1000);
		ledCtrlObj.ctrlSubBlueLed(OFF);
		usleep(500 * 1000);
		ledCtrlObj.ctrlSubYellowLed(ON);
		usleep(500 * 1000);
		ledCtrlObj.ctrlSubYellowLed(OFF);
		usleep(500 * 1000);
		ledCtrlObj.ctrlSubRedLed(ON);
		usleep(500 * 1000);
		ledCtrlObj.ctrlSubRedLed(OFF);
		usleep(500 * 1000);
	}
}

int main(int argc, char const *argv[])
{
	std::thread ledShow(ledShowTask);
	ledShow.join();
	return 0;
}
Mark wyz
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
S5PV210三星原厂开发板使用说明+完整原理图
04-11
S5PV210三星原厂开发板使用说明+完整原理图，英文版的
S5PV210 之点灯
liujia2100的专栏
01-31 1227
//start.s .global _start _start: ldr sp, =0xD0030000 @初始化堆栈 b main //main.c #define GPH0CON (*(volatile unsigned int *)0xE0200C00) #define GPH0DAT (*(volatile unsigned int *)0xE0200
S5PV210开发板移植Linux4.4.1内核并使用设备树传参
TNT的博客
01-30 2419
-----最近手头之前学习使用的是九鼎的X210开发板，使用的是S5PV210 SOC，目前210 的学习资料也比较丰富，易于学习。可是目前最多的资料都是基于Linux2.6.35.7这个内核版本来学习的。今天下载了Linux4.4.1版本的内核，发现该版本上使用设备树传参已经很好的支持了S5PV210，特此打算移植4.4.1版本的内核并且使用设备树传参来启动内核。 说干就干，从官网下载Linux...
S5PV210裸机第一个裸机实验点亮LED
hwf1877655的博客
07-27 421
作为一个嵌入式点灯工程师对点亮LED的能力不能少，下面是学习S5PV210的第一个裸机程序，点亮LED （1）了解硬件结构LED两端引脚的连接特性 通过原理图的连接可以看出LED一端接到了VCC，一端接到了S5PV210的GPJ_3、GPJ_4、GPJ_5，所以配置IO口输出低电平进使LED被点亮； （2）阅读datasheet查询GPIO的相关寄存器 通过数据手册SYSTEM可以找到GPIO介绍的部分，有关控制·GPIO的寄存器有GPJ0CON, GPJ0DAT, GPJ0PUD, GPJ0DRV,
S5PV210学习笔记——(1) 点亮LED
m0_57198657的博客
10-04 461
5.1第一个程序——点亮LED 5.1.1相关寄存器 由原理图，我们这里可以看到三个LED是由GPJ0_3、GPJ0_4、GPJ0_5控制的，来看一下GPJ0的相关寄存器 在手册中可以找到2.2.1节可以找到GPJ0的相关寄存器，点灯我们用到的就是GPJ0CON、GPJ0DAT两个而已 ​ 5.1.1.1 GPJ0控制寄存器 GPJ0CON, R/W, Address = 0xE020_0240 由寄存器介绍可以得知这个寄存器每四个位用来控制对应引脚的模式，...
S5PV210-Led.zip LED设备驱动
03-28
S5PV210-Led.zip LED设备驱动 S5PV210-Led.zip LED设备驱动
三星S5PV210数据手册
02-20
主要是关于三星公司的一款S5PV210芯片的数据手册，帮助开发者学习以及更好的使用该芯片。
smart210 s5pv210关闭mmu操作演示
07-04
smart210 s5pv210关闭mmu操作演示
led_test.rar_s5pv210
09-14
这是一个嵌入式相关的，s5pv210开发板的led测试代码
基于S5PV210的智能家居系统设计
01-29
提出了一种基于S5PV210芯片的智能家居系统的设计方法。在基于S5PV210处理器和linux2.6.30内核的嵌入式系统平台上使用QT开发了软件系统和人机交互界面，控制各种传感器采集信息以及TC35i等模块，并配置实现了Boa...
S5PV210 u-boot移植详细教程及移植好工程
05-06
S5pv210 u-boot移植好工程及详细教程说明文档..............................................................
S5PV210流水灯工程
04-07
S5PV210流水灯工程 第一个在windows下编译的工程 使用TKSTUDIO GCC
S5PV210按键控制LED
06-23
S5PV210按键控制LED，有需要的可以去下载哈
s5pv210 按键控制LED灯
08-21
通过unbutu写代码（C和汇编混合），然后tftp加载到A8开发板，按键控制s5pv210的LED灯.代码的构架也很合理。
s5pv210驱动学习之点灯程序
YK的专栏
10-30 643
今天成功利用自己
深入浅析Linux下uboot之（二）-----------------------：uboot的目录分析
weixin_42432281的博客
07-30 413
一般我们uboot可以通过3种途径去下载获得：uboot官方、SoC官方、具体开发板的官方。 所有uboot源头的源代码是uboot官网下载的。SoC厂商在推出一款SoC后，厂商的工程师会去uboot官网下载一个uboot，根据自己的SoC进行第一步的移植，移植的目标是厂商推出的开发板。（譬如三星的S5PV210芯片厂商出的开发板就叫SMDKV210）.所以三星的工程师移植的uboot是根据他们...
S5PV210 LINUX内核移植
lchmcu的专栏
12-21 6664
环境：debian 6 linux 2.6.35.7 arm-linux-gcc:   LINUX只是一个内核，不能算是操作系统。操作系统还包括更多的东西，比如用户界面。我们要做的第一步是要让内核在目标版运行起来。 移植准备 1. 目标板 已经安装bootloader目标板。 2.交叉工具链 可以网上下载已经编译好的工具链，需要将路径放入环境变量
S5PV210开发 -- QT4.8 移植
不积跬步，无以至千里
11-10 1299
如需转载请注明出处：https://blog.csdn.net/qq_29350001/article/details/78498784 今天应网友要求给他，生成一下nand平台的根文件系统。由此简单的来讲解一下。 一、安装交叉编译器 前面讲过了，参看：S5PV210开发 -- 交叉编译器 二、安装 QT4.8 源码包 将光盘中的 QT4.8 源码包 qt_x210v3s_16030...
S5PV210(TQ210)学习笔记——LED驱动
chuxiao0930的博客
09-06 792
　　1、看电路图，找到led连接哪个引脚。由图可见，开发板上的两个led分别连接在GPC0_3和GPC0_4的两个引脚上。 　　2、打开s5pv210的芯片手册，搜索一下GPC0CON[4]在2-48页找到GPC0CON的地址为 ：Address = 0xE020_0060，下面还有GP...
基于s5pv210和qt的仓库管理系统
最新发布
07-16
基于S5PV210和QT的仓库管理系统，是一种利用S5PV210嵌入式处理器和QT开发框架实现的仓库管理软件。 仓库管理系统是为了提高仓库内存储和管理效率而开发的，可以对仓库内的物品进行入库、出库、库存管理等操作。基于...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值