一、实验说明

二、硬件原理图分析

2.1 打开原理图，找到rgb部分

2.2 对RGB的R灯进行寄存器设置

2.2.1 时钟配置

2.2.2 引脚复用GPIO

2.2.3 引脚属性设置

2.2.4 输出电平设置

三、实验代码

3.1 编程思路

3.2 代码分析

3.2.1 添加RGB设备节点

3.2.2 编写驱动函数

3.2.3 编写测试应用程序

四、编译驱动程序

4.1 编译设备树

4.2 编译驱动和应用程序

五、程序运行结果

5.1 实验操作

一、实验说明

本实验使用到ebf6ull-pro开发板上rgb彩灯

二、硬件原理图分析

2.1 打开原理图，找到rgb部分

LED_R的阴极连接到i.MX6ULL芯片上的GPIO1_IO04引脚，LED_G连接到CSI_HSYNC，LED_B连接到CSI_VSYNC。而CSI_HSYNC和CSI_VSYNC作为摄像头的某一功能被复用为GPIO。如下表所示。

LED灯	原理图的标号	具体引脚名	GPIO端口及引脚编号
R灯	GPIO_4	GPIO1_IO04	GPIO1_IO04
G灯	CSI_HSYNC	CSI_HSYNC	GPIO4_IO20
B灯	CSI_VSYNC	CSI_VSYNC	GPIO4_IO19

对于RGB灯的控制进行控制，也就是对上述GPIO的寄存器进行读写操作。可分为以下几个步骤：

使能GPIO时钟
设置引脚复用为GPIO
设置引脚属性（上下拉、速率、驱动能力）
控制GPIO引脚输出高低电平

2.2 对RGB的R灯进行寄存器设置

2.2.1 时钟配置

跟GPIO相关的时钟主要是CCM_CCGR(0-3)寄存器。查看数据手册可以知道GPIO的第26-27两位控制引脚时钟。

数据手册描述

System clock

两个bit的不同取值，设置GPIO时钟的不同属性

00：所有模式下都关闭时钟
01：在运行模式下开启时钟
10：保留
11：在所有模式下都开启时钟

CCM_CCGR1地址为0x20C406C。先对CCM_CCGR1寄存器的第26位、27位值清空，再赋值为11。

2.2.2 引脚复用GPIO

引脚复用相关的寄存器位IOMUXC_SW_MUX_CTL_PAD_GPIO1_IO4

关于该寄存器的配置可见下图

寄存器地址为0x20E006C,对该寄存器第0-3位配置为0101时，MUX_MODE为ALT5，也就是该引脚复用为GPIO。

2.2.3 引脚属性设置

寄存器为IOMUXC_SW_PAD_CTL_PAD_GPIO1_IO04

HYS(bit16):用来使能迟滞比较器。
PUS（bit15-bit14）：用来设置上下拉电阻大小。
PUE（bit13）：当IO作为输入的时候，这个位用来设置IO上下拉还是状态保持器。
PKE（bit12）：用来使能或者禁止上下拉/状态保持器功能。
ODE（bit11）：IO作为输出的时候，此位用来禁止或者使能开漏输出。
SPEED（bit7-bit6）：当IO用作输出的时候，此位用来设置IO速度。
DSE（bit5-bit3）：当IO用作输出的时候用来设置IO的驱动能力。
SRE（bit0）：设置压摆率

寄存器地址位0x20E02F8，对该寄存器写入0x1F838，也就是二进制1 1111 1000 0011 1000，对比上图了解引脚的属性。

2.2.4 输出电平设置

-0：输入 -1：输出

硬件原理以及寄存器配置到此为止，更多硬件上的信息可以查看原理图和芯片手册。

三、实验代码

3.1 编程思路

程序编写的内容主要为添加RGB灯的设备树节点、在驱动程序使用of函数获取设备节点中的属性，编写测试程序。

首先向设备树添加RGB设备节点。
其次编写平台设备驱动框架，主要包含驱动入口函数、驱动注销函数、平台设备结构体定义三部分内容。
实现.probe函数，对rgb进行设备注册和初始化。
实现字符设备操作函数集，这里主要实现.write函数。
编写测试应用程序，对于输入不同的值控制rgb颜色。

3.2 代码分析

3.2.1 添加RGB设备节点

RGB灯实际使用的是一个IO口，控制它所需要的资源几个控制寄存器。

/*---------------------第一部分-----------------------------------------*/
/*
*CCM_CCGR1                         0x020C406C
*IOMUXC_SW_MUX_CTL_PAD_GPIO1_IO04  0x020E006C
*IOMUXC_SW_PAD_CTL_PAD_GPIO1_IO04  0x020E02F8
*GPIO1_GD                          0x0209C000
*GPIO1_GDIR                        0x0209C004
*/


/*
*CCM_CCGR3                         0x020C4074
*IOMUXC_SW_MUX_CTL_PAD_CSI_HSYNC   0x020E01E0
*IOMUXC_SW_PAD_CTL_PAD_CSI_HSYNC   0x020E046C
*GPIO4_GD                          0x020A8000
*GPIO4_GDIR                        0x020A8004
*/


/*
*CCM_CCGR3                         0x020C4074
*IOMUXC_SW_MUX_CTL_PAD_CSI_VSYNC   0x020E01DC
*IOMUXC_SW_PAD_CTL_PAD_CSI_VSYNC   0x020E0468
*GPIO4_GD                          0x020A8000
*GPIO4_GDIR                        0x020A8004
*/

/*---------------------第二部分-----------------------------------------*/
	/*添加led节点*/
	rgb_led{
		#address-cells = <1>;
		#size-cells = <1>;
		compatible = "fire,rgb_led";

/*---------------------第三部分-----------------------------------------*/
		/*红灯节点*/
		ranges;
		rgb_led_red@0x020C406C{
			compatible = "fire,rgb_led_red";
			reg = <0x020C406C 0x00000004
			       0x020E006C 0x00000004
			       0x020E02F8 0x00000004
				   0x0209C000 0x00000004
			       0x0209C004 0x00000004>;
			status = "okay";
		};

		/*绿灯节点*/
		rgb_led_green@0x020C4074{
			compatible = "fire,rgb_led_green";
			reg = <0x020C4074 0x00000004
			       0x020E01E0 0x00000004
			       0x020E046C 0x00000004
				   0x020A8000 0x00000004
			       0x020A8004 0x00000004>;
			status = "okay";
		};

		/*蓝灯节点*/
		rgb_led_blue@0x020C4074{
			compatible = "fire,rgb_led_blue";
			reg = <0x020C4074 0x00000004
			       0x020E01DC 0x00000004
			       0x020E0468 0x00000004
				   0x020A8000 0x00000004
			       0x020A8004 0x00000004>;
			status = "okay";
		};
	};

第一部分：这部分列出了控制RGB灯的三个引脚所使用的寄存器，包含控制时钟寄存器、引脚复用寄存器、引脚属性寄存器、数据输出寄存器（包括引脚是输出还是输入，输出高电平还是低电平）。
第二部分：这部分是RGB灯的设备树节点，节点名为“rgb_led”，由于在根节点下，很明显它的设备树路路径为“/rgb_led”，在驱动程序中我们会用到cells定义它的子节点的reg属性样式。“compatible”属性用于匹配驱动，在驱动我们配置一个和“compatible”一样的参数，这样加载驱动就是自动和这个设备树节点匹配了。
第三部分：reg_led的子节点，RGB灯使用了三个引脚，如上所示，它会用到15个寄存器，为方便管理，每个引脚船舰一个子节点，从上到下依次为红灯控制引脚、绿灯控制引脚、蓝灯控制引脚。在灯的子节点中只定义三个属性，“compatible=“fire，rgb_led_red””表示这是一个红灯子节点。“reg=<...>”定义红灯引脚使用到寄存器。一共有五个，排列顺序于注释中的一致。“status=“okay””定义子节点的状态，要使能这个节点就设置为“okay”。

3.2.2 编写驱动函数

基于设备树的驱动程序与平台总线驱动非常相似，差别是平台总线驱动中的平台驱动要和平台设备进行匹配，使用设备树后设备树取代“平台设备”的作用，平台驱动只需要和与之对应的设备树节点匹配即可

驱动入口函数

驱动入口函数中注册一个平台驱动，如下所示

/*
*驱动初始化函数
*/
static int __init led_platform_driver_init(void)
{
	int DriverState;
	DriverState = platform_driver_register(&led_platform_driver);
	printk(KERN_EMERG "\tDriverState is %d\n", DriverState);
	return 0;
}

在整个入口函数中仅仅调用了“platform_driver_register”函数注册了一个平台驱动。参数是传入了一个平台设备结构体。

定义平台设备结构体

注册平台驱动时会用到平台设备结构体，在平台设备结构体主要作用时指定平台驱动的.probe函数、指定与平台驱动匹配的平台设备，使用了设备树就是指定与平台驱动匹配的设备树节点。

/*-------------------第一部分-----------------------------*/
static const struct of_device_id rgb_led[] = {
	{.compatible = "fire,rgb_led"},
	{/* sentinel */}};

/*--------------------第二部分-----------------------------*/
/*定义平台设备结构体*/
struct platform_driver led_platform_driver = {
	.probe = led_probe,
	.driver = {
		.name = "rgb-leds-platform",
		.owner = THIS_MODULE,
		.of_match_table = rgb_led,
	}
	};

第一部分：定义了匹配表
第二部分：就是定义的平台设备结构体。其中“.probe=led_probe,”指定.probe函数。.pro函数比较特殊，当平台驱动和设备树节点匹配后会自动执行.probe函数，后面的RGB灯的初始化以及字符设备的注册都在这个函数中为实现（也可以在其他函数中实现）。".driver={...}"定义driver的一些属性，包括名字、所有者等，其中最需要注意的时“.of_match_table”属性，它指定这个驱动的匹配表。这里只定义了一个匹配值“.compatible = "fire,rgb_led"”,这个驱动将会和设备树中“compatible = “fire,reb_led””的相对根节点的子节点匹配。在根节点下定义了rgb_led子节点，并且设置“compatible = fire,reg_led”；所以正常情况下，驱动会和这个子节点匹配。

实现.probe函数

如上文所述，当驱动和设备树节点匹配成功后会自动执行.probe函数，所以在.probe函数中实现一些初始化工作。本实验将RGB初始化以及字符设备的初始化全部放到.probe函数中实现，.probe函数较长，但包含大量的简单、重复性的初始化代码。

.probe函数内容：

/*----------------------------第一部分--------------------------------------*/
/*定义 led 资源结构体，保存获取得到的节点信息以及转换后的虚拟寄存器地址*/
struct led_resource
{
	struct device_node *device_node; //rgb_led_red的设备树节点
	void __iomem *virtual_CCM_CCGR;
	void __iomem *virtual_IOMUXC_SW_MUX_CTL_PAD;
	void __iomem *virtual_IOMUXC_SW_PAD_CTL_PAD;
	void __iomem *virtual_DR;
	void __iomem *virtual_GDIR;
};

/*定义 R G B 三个灯的led_resource 结构体，保存获取得到的节点信息*/
struct led_resource led_red;
struct led_resource led_green;
struct led_resource led_blue;

/*----------------平台驱动函数集-----------------*/
static int led_probe(struct platform_device *pdv)
{

	int ret = -1; //保存错误状态码
	unsigned int register_data = 0;

	printk(KERN_EMERG "\t  match successed  \n");

/*----------------------------第二部分--------------------------------------*/
	/*获取rgb_led的设备树节点*/
	rgb_led_device_node = of_find_node_by_path("/rgb_led");	
	if (rgb_led_device_node == NULL)
	{
		printk(KERN_ERR "\t  get rgb_led failed!  \n");
		return -1;
	}

/*----------------------------第三部分--------------------------------------*/
	/*获取rgb_led节点的红灯子节点*/
	led_red.device_node = of_find_node_by_name(rgb_led_device_node,"rgb_led_red");
	if (led_red.device_node == NULL)
	{
		printk(KERN_ERR "\n get rgb_led_red_device_node failed ! \n");
		return -1;
	}


	/*获取 reg 属性并转化为虚拟地址*/
	led_red.virtual_CCM_CCGR = of_iomap(led_red.device_node, 0);
	led_red.virtual_IOMUXC_SW_MUX_CTL_PAD = of_iomap(led_red.device_node, 1);
	led_red.virtual_IOMUXC_SW_PAD_CTL_PAD = of_iomap(led_red.device_node, 2);
	led_red.virtual_DR = of_iomap(led_red.device_node, 3);
	led_red.virtual_GDIR = of_iomap(led_red.device_node, 4);

	/*初始化红灯*/
	register_data = readl(led_red.virtual_CCM_CCGR);
	register_data |= (0x03 << 26);
	writel(register_data, led_red.virtual_CCM_CCGR); //开启时钟

	register_data = readl(led_red.virtual_IOMUXC_SW_MUX_CTL_PAD);
	register_data &= ~(0xf << 0);
	register_data |= (0x05 << 0);
	writel(register_data, led_red.virtual_IOMUXC_SW_MUX_CTL_PAD); //设置复用功能

	register_data = readl(led_red.virtual_IOMUXC_SW_PAD_CTL_PAD);
	register_data = (0x10B0);
	writel(register_data, led_red.virtual_IOMUXC_SW_PAD_CTL_PAD); //设置PAD 属性

	register_data = readl(led_red.virtual_GDIR);
	register_data |= (0x01 << 4);
	writel(register_data, led_red.virtual_GDIR); //设置GPIO1_04 为输出模式

	register_data = readl(led_red.virtual_DR);
	register_data |= (0x01 << 4);
	writel(register_data, led_red.virtual_DR); //设置 GPIO1_04 默认输出高电平

	/*获取rgb_led节点的绿灯子节点*/
	led_green.device_node = of_find_node_by_name(rgb_led_device_node,"rgb_led_green");
	if (led_green.device_node == NULL)
	{
		printk(KERN_ERR "\n get rgb_led_green_device_node failed ! \n");
		return -1;
	}

	/*获取 reg 属性并转化为虚拟地址*/
	led_green.virtual_CCM_CCGR = of_iomap(led_green.device_node, 0);
	led_green.virtual_IOMUXC_SW_MUX_CTL_PAD = of_iomap(led_green.device_node, 1);
	led_green.virtual_IOMUXC_SW_PAD_CTL_PAD = of_iomap(led_green.device_node, 2);
	led_green.virtual_DR = of_iomap(led_green.device_node, 3);
	led_green.virtual_GDIR = of_iomap(led_green.device_node, 4);

	/*初始化绿灯*/
	register_data = readl(led_green.virtual_CCM_CCGR);
	register_data |= (0x03 << 12);
	writel(register_data, led_green.virtual_CCM_CCGR); //开启时钟

	register_data = readl(led_green.virtual_IOMUXC_SW_MUX_CTL_PAD);
	register_data &= ~(0xf << 0);
	register_data |= (0x05 << 0);
	writel(register_data, led_green.virtual_IOMUXC_SW_MUX_CTL_PAD); //设置复用功能

	register_data = readl(led_green.virtual_IOMUXC_SW_PAD_CTL_PAD);
	register_data = (0x10B0);
	writel(register_data, led_green.virtual_IOMUXC_SW_PAD_CTL_PAD); //设置PAD 属性

	register_data = readl(led_green.virtual_GDIR);
	register_data |= (0x01 << 20);
	writel(register_data, led_green.virtual_GDIR); //设置GPIO4_IO20 为输出模式

	register_data = readl(led_green.virtual_DR);
	register_data |= (0x01 << 20);
	writel(register_data, led_green.virtual_DR); //设置 GPIO4_IO20 默认输出高电平

	/*获取rgb_led节点的蓝灯子节点*/
	led_blue.device_node = of_find_node_by_name(rgb_led_device_node,"rgb_led_blue");
	if (led_blue.device_node == NULL)
	{
		printk(KERN_ERR "\n get rgb_led_blue_device_node failed ! \n");
		return -1;
	}

	/*获取 reg 属性并转化为虚拟地址*/
	led_blue.virtual_CCM_CCGR = of_iomap(led_blue.device_node, 0);
	led_blue.virtual_IOMUXC_SW_MUX_CTL_PAD = of_iomap(led_blue.device_node, 1);
	led_blue.virtual_IOMUXC_SW_PAD_CTL_PAD = of_iomap(led_blue.device_node, 2);
	led_blue.virtual_DR = of_iomap(led_blue.device_node, 3);
	led_blue.virtual_GDIR = of_iomap(led_blue.device_node, 4);

	/*初始化蓝灯*/
	register_data = readl(led_blue.virtual_CCM_CCGR);
	register_data |= (0x03 << 12);
	writel(register_data, led_blue.virtual_CCM_CCGR); //开启时钟

	register_data = readl(led_blue.virtual_IOMUXC_SW_MUX_CTL_PAD);
	register_data &= ~(0xf << 0);
	register_data |= (0x05 << 0);
	writel(register_data, led_blue.virtual_IOMUXC_SW_MUX_CTL_PAD); //设置复用功能

	register_data = readl(led_blue.virtual_IOMUXC_SW_PAD_CTL_PAD);
	register_data = (0x10B0);
	writel(register_data, led_blue.virtual_IOMUXC_SW_PAD_CTL_PAD); //设置PAD 属性

	register_data = readl(led_blue.virtual_GDIR);
	register_data |= (0x01 << 19);
	writel(register_data, led_blue.virtual_GDIR); //设置GPIO4_IO19 为输出模式

	register_data = readl(led_blue.virtual_DR);
	register_data |= (0x01 << 19);
	writel(register_data, led_blue.virtual_DR); //设置 GPIO4_IO19 默认输出高电平

/*----------------------------第四部分--------------------------------------*/
	/*---------------------注册 字符设备部分-----------------*/

	//第一步
	//采用动态分配的方式，获取设备编号，次设备号为0，
	//设备名称为rgb-leds，可通过命令cat  /proc/devices查看
	//DEV_CNT为1，当前只申请一个设备编号
	ret = alloc_chrdev_region(&led_devno, 0, DEV_CNT, DEV_NAME);
	if (ret < 0)
	{
		printk("fail to alloc led_devno\n");
		goto alloc_err;
	}
	//第二步
	//关联字符设备结构体cdev与文件操作结构体file_operations
	led_chr_dev.owner = THIS_MODULE;
	cdev_init(&led_chr_dev, &led_chr_dev_fops);
	//第三步
	//添加设备至cdev_map散列表中
	ret = cdev_add(&led_chr_dev, led_devno, DEV_CNT);
	if (ret < 0)
	{
		printk("fail to add cdev\n");
		goto add_err;
	}

	//第四步
	/*创建类 */
	class_led = class_create(THIS_MODULE, DEV_NAME);

	/*创建设备*/
	device = device_create(class_led, NULL, led_devno, NULL, DEV_NAME);

	return 0;

add_err:
	//添加设备失败时，需要注销设备号
	unregister_chrdev_region(led_devno, DEV_CNT);
	printk("\n error! \n");
alloc_err:

	return -1;
}

第一部分：自定义led资源结构体，用于保存获得到的设备节点信息以及转换后的虚拟寄存器地址。
第二部分：使用of_find_node_by_path函数获取设备树节点“/rgb_led”,获取成功后会返回“rgb_led”节点的“设备节点结构体”后面的代码就可以根据这个“设备节点结构体”访问它的字节点。
第三部分：依次初始化红、绿、蓝灯，这三部分非常相似，这里仅介绍第三部分红灯初始化部分。初始化过程如下：
- 获取红灯子节点，这里使用函数“of_find_node_by_name”,参数rgb_led_device_node指定从rgb_led节点开始搜索，参数“rgb_led_red”指定要获取那个节点，这里时rgb_led节点下rgb_led_red子节点。
- 获取并转换reg属性，我们直到reg属性保存的就是寄存器地址（物理地址），这里使用“of_iomap”函数，获取并完成物理地址到虚拟地址的转换。
- 初始化寄存器，注意的时这里只能用系统提供的API函数（例如这里读写的时32位数据，使用writel和readl），不能像裸机那样直接使用“=”、“&=”、“|=”等等那样直接修改寄存器。
第四部分：注册一个字符设备，字符设备的注册过程与之讲解的字符驱动设备驱动非常相似。

static dev_t led_devno;					 //定义字符设备的设备号
static struct cdev led_chr_dev;			 //定义字符设备结构体chr_dev
struct class *class_led;				 //保存创建的类
struct device *device;					 // 保存创建的设备

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

第四部分：第一步：使用“alloc_chrdev_region”动态申请主设备号，并保存到“led_devno”结构体中。
第四部分：第二步：使用“cdev_init”初始化字符设备。
第四部分：第三步：使用“cdev_add”将字符设备添加到系统。如果需要驱动自动创建设备节点，则还需要创建类和设备。
第四部分：第四步：使用“class_create”函数创建类。
第四部分：第五步：使用“device_create”创建设备，其中参数“DEV_NAME”用于指定设备节点名，这个名字在应用程序中会用到。

如果驱动和设备树节点完成匹配，系统会自动执行.probe函数，从上方代码可知，.probe函数完成了RGB灯的初始化和字符设备的创建。下一步只需要在字符设备的操作函数集中控制RGB灯即可。

实现字符设备操作函数集

这里仅仅实现了字符设备操作函数集中的.write函数，.write函数根据收到的信息控制RGB灯的亮、灭。代码如下：

/*字符设备操作函数集，open函数*/
static int led_chr_dev_open(struct inode *inode, struct file *filp)
{
	printk("\n open form driver \n");
	return 0;
}

/*字符设备操作函数集，write函数*/
static ssize_t led_chr_dev_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{

	unsigned int register_data = 0; //暂存读取得到的寄存器数据
	unsigned char write_data; //用于保存接收到的数据

/*-----------------------------第一部分---------------------------------------------*/
	int error = copy_from_user(&write_data, buf, cnt);
	if (error < 0)
	{
		return -1;
	}

/*-----------------------------第二部分---------------------------------------------*/
	/*设置 GPIO1_04 输出电平*/
	if (write_data & 0x04)
	{
		register_data = readl(led_red.virtual_DR);
		register_data &= ~(0x01 << 4);
		writel(register_data, led_red.virtual_DR); // GPIO1_04引脚输出低电平，红灯亮
	}
	else
	{
		register_data = readl(led_red.virtual_DR);
		register_data |= (0x01 << 4);
		writel(register_data, led_red.virtual_DR); // GPIO1_04引脚输出高电平，红灯灭
	}

	/*设置 GPIO4_20 输出电平*/
	if (write_data & 0x02)
	{
		register_data = readl(led_green.virtual_DR);
		register_data &= ~(0x01 << 20);
		writel(register_data, led_green.virtual_DR); // GPIO4_20引脚输出低电平，绿灯亮
	}
	else
	{
		register_data = readl(led_green.virtual_DR);
		register_data |= (0x01 << 20);
		writel(register_data, led_green.virtual_DR); // GPIO4_20引脚输出高电平，绿灯灭
	}

	/*设置 GPIO4_19 输出电平*/
	if (write_data & 0x01)
	{
		register_data = readl(led_blue.virtual_DR);
		register_data &= ~(0x01 << 19);
		writel(register_data, led_blue.virtual_DR); //GPIO4_19引脚输出低电平，蓝灯亮
	}
	else
	{
		register_data = readl(led_blue.virtual_DR);
		register_data |= (0x01 << 19);
		writel(register_data, led_blue.virtual_DR); //GPIO4_19引脚输出高电平，蓝灯灭
	}

	return 0;
}

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

这里仅实现了两个字符设备操作函数，open对应led_chr_dev_open函数这是一个空函数。.write对应led_chr_dev_write函数，这两个函数接收应用程序传回的命令，根据命令控制RGB三个灯的亮、灭。

第一部分：使用copy_from_user函数将用户空间的数据拷贝到内核空间。这里传递的数据是一个无符号整型数据。
第二部分：解析命令，如何解析由我们自己决定。本例中使用数字的后三位从高到低依次对应红灯、绿灯、蓝灯，对应位是1则亮灯否则熄灭。例如0x03表示红灯灭，绿灯和蓝灯亮。0x07表示全亮。

3.2.3 编写测试应用程序

在驱动程序中采用自动创建设备节点的方式创建了字符设备的设备节点文件，文件名可自定义，写测试应用程序时记得文件名即可。测试程序很简单，源码如下所示。

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
int main(int argc, char *argv[])
{
    printf("led_tiny test\n");

/*------------------------------第一部分------------------------------------*/
    /*判断输入的命令是否合法*/
    if(argc != 2)
    {
        printf(" commend error ! \n");
        return -1;
    }

/*------------------------------第二部分------------------------------------*/
    /*打开文件*/
    int fd = open("/dev/rgb_led", O_RDWR);
    if(fd < 0)
    {
		printf("open file : %s failed !\n", argv[0]);
		return -1;
	}

/*------------------------------第三部分------------------------------------*/
    unsigned char commend = atoi(argv[1]);  //将受到的命令值转化为数字;

/*------------------------------第四部分------------------------------------*/
    /*写入命令*/
    int error = write(fd,&commend,sizeof(commend));
    if(error < 0)
    {
        printf("write file error! \n");
        close(fd);
        /*判断是否关闭成功*/
    }
/*------------------------------第五部分------------------------------------*/
    /*关闭文件*/
    error = close(fd);
    if(error < 0)
    {
        printf("close file error! \n");
    }
    
    return 0;
}