S5PV210 基于设备树点亮LED

最新推荐文章于 2024-09-04 15:04:20 发布
最新推荐文章于 2024-09-04 15:04:20 发布
阅读量431 收藏
点赞数
分类专栏： 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
关注
专栏目录
S5PV210学习笔记——(1) 点亮LED
m0_57198657的博客
10-04 502
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跑马灯
03-25
4. **X210 开发板**：X210是一款基于S5PV210的开发平台，为开发者提供了一个实验和调试硬件的环境。开发板上集成了各种外设接口，方便用户进行硬件原型设计和软件测试。在这个项目中，X210开发板提供了连接4个LED所...
S5PV210开发板移植Linux4.4.1内核并使用设备树传参
TNT的博客
01-30 2543
-----最近手头之前学习使用的是九鼎的X210开发板，使用的是S5PV210 SOC，目前210 的学习资料也比较丰富，易于学习。可是目前最多的资料都是基于Linux2.6.35.7这个内核版本来学习的。今天下载了Linux4.4.1版本的内核，发现该版本上使用设备树传参已经很好的支持了S5PV210，特此打算移植4.4.1版本的内核并且使用设备树传参来启动内核。 说干就干，从官网下载Linux...
Linux平台S5PV210按键驱动全注释详解
最新发布
weixin_31591833的博客
09-04 1281
本文还有配套的精品资源，点击获取 简介：在Linux操作系统中，驱动程序是连接硬件和内核的桥梁，特别是对于ARM架构的S5PV210处理器，编写高效的按键驱动对于提高用户交互体验和系统响应至关重要。本文将详细探讨Linux按键驱动的基础知识、结构设计和实现过程，以及如何在S5PV210平台上进行应用和调试。文章通过提供全注释的S5PV210按键驱动代码、应用程序和Makef...
S5PV210 之点灯
liujia2100的专栏
01-31 1251
//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裸机第一个裸机实验点亮LED
hwf1877655的博客
07-27 512
作为一个嵌入式点灯工程师对点亮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驱动学习之点灯程序
YK的专栏
10-30 680
今天成功利用自己
S5PV210 友善之臂开发板 led跑马灯
06-06
【标题】"S5PV210 友善之臂开发板 led跑马灯"涉及的是基于S5PV210处理器的友善之臂开发板上的一个LED跑马灯程序，该程序通过QT图形用户界面进行操作，并依赖mygpio.ko驱动来控制硬件。 【描述】说明了这个项目是为...
S5PV210 led驱动
10-23
对于S5PV210的LED驱动，描述中的"一个misc设备驱动"是指利用Linux内核的Misc设备框架。Misc设备框架是一种通用的设备驱动模型，适用于那些没有特定设备模型的小型设备。LED驱动注册为Misc设备后，可以通过标准的设备...
led_test.rar_s5pv210
09-14
这个"led_test.rar_s5pv210"文件是针对这款处理器进行LED控制的一个测试项目，主要包含两个源代码文件：led_drv.c和led_app.c。下面我们将深入探讨这两个文件以及它们在LED测试中的作用。 1. **S5PV210处理器**：S5...
S5PV210三星原厂开发板使用说明+完整原理图
04-11
S5PV210三星原厂开发板使用说明+完整原理图，英文版的
S5PV210-Led.zip LED设备驱动
03-28
S5PV210-Led.zip LED设备驱动 S5PV210-Led.zip LED设备驱动
S5PV210 u-boot移植详细教程及移植好工程
05-06
S5pv210 u-boot移植好工程及详细教程说明文档..............................................................
S5PV210流水灯工程
04-07
S5PV210流水灯工程 第一个在windows下编译的工程 使用TKSTUDIO GCC
深入浅析Linux下uboot之（二）-----------------------：uboot的目录分析
weixin_42432281的博客
07-30 447
一般我们uboot可以通过3种途径去下载获得：uboot官方、SoC官方、具体开发板的官方。 所有uboot源头的源代码是uboot官网下载的。SoC厂商在推出一款SoC后，厂商的工程师会去uboot官网下载一个uboot，根据自己的SoC进行第一步的移植，移植的目标是厂商推出的开发板。（譬如三星的S5PV210芯片厂商出的开发板就叫SMDKV210）.所以三星的工程师移植的uboot是根据他们...
S5PV210 LINUX内核移植
lchmcu的专栏
12-21 6730
环境：debian 6 linux 2.6.35.7 arm-linux-gcc:   LINUX只是一个内核，不能算是操作系统。操作系统还包括更多的东西，比如用户界面。我们要做的第一步是要让内核在目标版运行起来。 移植准备 1. 目标板 已经安装bootloader目标板。 2.交叉工具链 可以网上下载已经编译好的工具链，需要将路径放入环境变量
S5PV210开发 -- QT4.8 移植
不积跬步，无以至千里
11-10 1356
如需转载请注明出处：https://blog.csdn.net/qq_29350001/article/details/78498784 今天应网友要求给他，生成一下nand平台的根文件系统。由此简单的来讲解一下。 一、安装交叉编译器 前面讲过了，参看：S5PV210开发 -- 交叉编译器 二、安装 QT4.8 源码包 将光盘中的 QT4.8 源码包 qt_x210v3s_16030...
S5PV210(TQ210)学习笔记——LED驱动
chuxiao0930的博客
09-06 877
　　1、看电路图，找到led连接哪个引脚。由图可见，开发板上的两个led分别连接在GPC0_3和GPC0_4的两个引脚上。 　　2、打开s5pv210的芯片手册，搜索一下GPC0CON[4]在2-48页找到GPC0CON的地址为 ：Address = 0xE020_0060，下面还有GP...
S5PV210开发板LED测试代码分析
资源摘要信息:"本资源包含了基于S5PV210开发板的LED测试代码，主要面向嵌入式系统开发者。代码包含两个主要的C语言源文件：led_drv.c 和 led_app.c，分别涉及LED驱动程序的编写和LED应用层程序的实现。S5PV210是三星...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值