Linux设备驱动开发之流水灯

最新推荐文章于 2022-09-16 10:06:44 发布
最新推荐文章于 2022-09-16 10:06:44 发布
阅读量956 收藏 8
点赞数 1
CC 4.0 BY-SA版权
分类专栏： Linux学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Linux_zhicheng/article/details/107620877 
int register_chrdev(unsigned int major, 
					const char *name,                     
                  const struct file_operations *fops)
功能：注册一个字符设备驱动
参数：
	@major :主设备号
		major>0 系统认为这个major就是主设备号
		major=0 系统自动分配一个主设备号
		
	设备号（32位）=主设备号（高12）+次设备号（低20）
	主设备号：它是哪一类设备 LED UART BEEP WDT
	次设备号：同类中的第几个设备
	
	@name :给你的字符设备驱动起的名字
		通过 cat /proc/devices 可以查看
		Character devices:
		  1 		mem
		  4 		/dev/vc/0
		  4 		tty
		  4 		ttyS
		  5 		/dev/tty
		  5 		/dev/console
		  5 		/dev/ptmx
		  5 		ttyprintk
		  6 		lp
		  7 		vcs
		  |          |
		  主设备号  名字
	
	@fops:操作方法结构体
		vi  -t file_operations
		struct file_operations {
			ssize_t (*read) (struct file *,
				char __user *, size_t, loff_t *);
				
			ssize_t (*write) (struct file *, 
				const char __user *, size_t, loff_t *);
			int (*open) (struct inode *, struct file *);
			int (*release) (struct inode *, struct file *);
		}
	
返回值：
	major>0	 成功返回0，失败返回错误码（负数）
	major=0	 成功返回主设备号，失败返回错误码
void unregister_chrdev(unsigned int major, const char *name)    
 功能：注销一个字符设备驱动
 参数：
	@major：主设备号
	@name : 名字
返回值：无

	指定驱动文件的tags就是内核顶层的tags
	:set tags=/home/linux/kernel/kernel-3.4.39/tags
驱动的测试流程
	1.安装驱动
		sudo insmod mycdev.ko
		
	2.查看字符设备驱动是否创建成功
		cat /proc/devices 
		250       mycdev
		|          |
		主设备号  名字
	3.创建设备文件（mknod）
		sudo mknod 路径（任意）/设备文件的名字  c/b  主设备号   次设备号
		sudo mknod /dev/mycdev c 250 0
		
		
	4.编写应用程序
		在应用程序中调用open  read  write  close函数
		
		
	5.执行应用程序
		sudo ./a.out
		或者
		sudo chmod 777 /dev/mycdev
		./a.out
	6.查看
		dmesg
		如果看到驱动中的open read  write close都打印了
		说明，应用程序调用驱动就成功了。
用户空间和内核空间数据传递
	在内核中有asm/uaccess.h或者asm-generic/uaccess.h
	里面写的都是同样类型的函数，如果包含头文件的时候
	写上其中一种，可能在当前的内核版本中编译能通过，
	换一个内核版本编译就通过不了了，把前面的asm换成
	linux/uaccess.h，这是一个链接文件，它总能链接到正确
	的头文件的位置。
	
	#include <linux/uaccess.h>
	
	unsigned long copy_from_user(void *to, 
		const void __user *from, unsigned long n)
	功能：将数据从用户空间拷贝到内核空间
	参数：
		@to  :内核空间的首地址
		@from:用户空间的首地址
		@n   :拷贝的字节的个数
	返回值：
		成功返回0，失败返回未拷贝的字节的个数
		
	内核中错误码问题：
		vi -t EIO;
		
	unsigned long copy_to_user(void __user *to, 
		const void *from, unsigned long n)
	
	功能：将数据从内核空间拷贝到用户空间
	参数：
		@to  :用户空间的首地址
		@from:内核空间的首地址
		@n   :拷贝的字节的个数
	返回值：
		成功返回0，失败返回未拷贝的字节的个数
驱动和硬件的交互过程
	由于驱动运行在3-4G的虚拟地址中，LED灯的
	控制寄存器它是物理地址。所以如果想在内核空间
	操作物理地址，需要将物理地址映射成虚拟地址。
	
	void *ioremap(phys_addr_t offset, unsigned long size)   
	功能：将物理地址映射成虚拟地址
	参数：
		@offset:物理地址
		@size  :映射的长度(字节)
	返回值：成功返回虚拟地址，失败返回NULL


	void iounmap(void *addr)                                          
	功能：取消映射
	参数：
		@addr:虚拟地址
	返回值：无
ioctl使用
	man ioctl
	
    #include <sys/ioctl.h>
    int ioctl(int fd, int request, ...);
	功能：input /output control device
	参数：
		@fd     :打开设备得到的文件描述符
		@request:通过同宏_IO _IOR _IOW  _IOWR封装的请求码
		@...    :可变参数
---------------------------------------------
fops:long (*unlocked_ioctl) (struct file *,
		unsigned int cmd, unsigned long args);	
		参数：
			cmd:就是用户空间传递过来的request
			args:就是用户空间传递过来的...
	

	应用层的ioctl被调用的时候驱动的fops中的
	unlocked_ioctl就会被执行。

	request这个32位请求码，每个部分的含义
	 31-30  00 - no parameters: uses _IO macro
		10 - read: _IOR
		01 - write: _IOW
		11 - read/write: _IOWR

	 29-16  size of arguments

	 15-8   ascii character supposedly
		unique to each driver

	 7-0    function #
                       
	#define _IO(type,nr)		
		_IOC(_IOC_NONE,(type),(nr),0)
		
	#define _IOR(type,nr,size)	
		_IOC(_IOC_READ,(type),(nr),(sizeof(size)))
	#define _IOW(type,nr,size)	
		_IOC(_IOC_WRITE,(type),(nr),(sizeof(size)))
	#define _IOWR(type,nr,size)	
		_IOC(_IOC_READ|_IOC_WRITE,(type),(nr),(sizeof(size)))


	#define _IOC(dir,type,nr,size) \
	(((dir)  << _IOC_DIRSHIFT) | \
	 ((type) << _IOC_TYPESHIFT) | \
	 ((nr)   << _IOC_NRSHIFT) | \
	 ((size) << _IOC_SIZESHIFT))


	 2       14        8      8
	 dir     size     type    nr
		
	#define VFAT_IOCTL_READDIR_BOTH        
		_IOR('r', 1, struct dirent [2])
	
	
	#define RED_ON   _IO('a',0)
	#define RED_OFF  _IO('a',1)
自动创建设备节点的过程
user	hotplug ---------------> udev/mdev
		|                       |----->/dev/设备节点名
		|/sys/class/目录/设备名
--------|-------------------------------------
kernel	|
		|
	1.提交目录
	class_create(owner, name)	
	2.提交设备名
	struct device *device_create(struct class *class,
	struct device *parent,dev_t devt, void *drvdata, 
	const char *fmt, ...)

	创建设备节点的函数接口讲解如下：
	1.class_create(owner, name)
	功能：提交目录
	参数：
		@owner :THIS_MODULE
			(以后所有的驱动遇到owner就写THIS_MODULE,
			编译驱动之后会生成一个文件，这个文件通过this_module
			记录程序的入口和出口)
		@name :目录名
		
	返回值：成功返回struct class *的结构体指针，
			失败返回错误码指针(void *)-5;
	
	
	cls = class_create(owner, name);
	思考如何判断这个函数返回的错误？
	
	*((int *)ret) < 0  错误
	sizeof(*ret) == 4; 错误
	
	IS_ERR(cls)
	如果返回值为真，表示他是一个错误，否则不是一个错误。
	
	ERR_PTR(long error)
	将错误码转化为错误码指针
	
	PTR_ERR(const void *ptr)
	将错误码指针转化为错误码
	
	2.struct device *device_create(struct class *class,
	struct device *parent,dev_t devt, void *drvdata, 
	const char *fmt, ...)
	功能：提交设备节点名
	参数：
		@class ：cls的结构体指针
		@parent：NULL
		@devt  : 设备号
		@drvdata：NULL
		@fmt   ：设备节点的名字
	返回值：成功返回struct device *的结构体指针，
			失败返回错误码指针
	

	MKDEV(ma,mi) //根据主次设备号合成设备号
	MAJOR(dev)   //根据设备号得到主设备号
	MINOR(dev)   //根据设备号得到次设备号
	
	
	void class_destroy(struct class *cls)
	功能：注销class
	
	
	void device_destroy(struct class *class, dev_t devt)
	功能：注销device
myled.c


#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>

#define CNAME "myled" 
#define RED_PHY_BASE 0xc001a000   //a28
#define BLUE_PHY_BASE 0xc001b000  //b12
#define GREEN_PHY_BASE 0xc001e000 //e13

#define OUT    0
#define OUTENB 1
#define ALTFN0 8
#define ALTFN1 9

int major = 0;
char kbuf[2] = {0};

//映射之后产生的虚拟地址
unsigned int *red_virt_base = NULL;
unsigned int *green_virt_base = NULL;
unsigned int *blue_virt_base = NULL;

enum RGB_LED{
	RED,
	GREEN,
	BLUE,
};

int myled_open(struct inode *inode, struct file *file)
{
	printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
	return 0;
}

ssize_t myled_read(struct file *file, 
	char __user *ubuf, size_t size, loff_t *offs)
{
	printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
	return 0;
}

ssize_t myled_write (struct file *file, 
	const char __user *ubuf, size_t size, loff_t *offs)
{
	int ret;

	printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);

	//1.拷贝用户空间的数据
	if(size > sizeof(kbuf)) size = sizeof(kbuf);
	ret = copy_from_user(kbuf,ubuf,size);
	if(ret){
		printk("copy data from user error\n");
		return -EIO;
	}

	//2.根据用户空间的数据进行点灯
	switch(kbuf[0]){
		case   RED: 
			kbuf[1]?(*(red_virt_base + OUT) |= (1<<28)):\
				(*(red_virt_base + OUT ) &= ~(1<<28));
			break;
		case GREEN: 	
			kbuf[1]?(*(green_virt_base + OUT) |= (1<<13)):\
				(*(green_virt_base + OUT) &= ~(1<<13));
			break;
		case  BLUE: 	
			kbuf[1]?(*(blue_virt_base + OUT) |= (1<<12)):\
				(*(blue_virt_base + OUT) &= ~(1<<12));
			break;
	}

	return size;
}

int myled_close(struct inode *inode, struct file *file)
{
	printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
	return 0;
}

const struct file_operations fops = {
	.open = myled_open,
	.read = myled_read,
	.write = myled_write,
	.release = myled_close,
};

static int __init myled_init(void)
{
	//1.注册字符设备驱动
	major = register_chrdev(0,CNAME,&fops);
	if(major < 0){
		printk("register chrdev error\n");
		return major;
	}

	//2.映射RGB_LED灯的地址
	red_virt_base = ioremap(RED_PHY_BASE,40);
	if(red_virt_base == NULL){
		printk("ioremap red led addr error\n");
		return -ENOMEM;
	}
	green_virt_base = ioremap(GREEN_PHY_BASE,40);
	if(green_virt_base == NULL){
		printk("ioremap green led addr error\n");
		return -ENOMEM;
	}
	blue_virt_base = ioremap(BLUE_PHY_BASE,40);
	if(blue_virt_base == NULL){
		printk("ioremap blue led addr error\n");
		return -ENOMEM;
	}

	//3.RGB_LED  INIT ALL OFF
	*(red_virt_base + ALTFN1) &= ~(3<<24);  //altfn1 24:25  gpio
	*(red_virt_base + OUTENB) |= (1<<28);  //outenb 28 输出
	*(red_virt_base + OUT   ) &= ~(1<<28); //out 28 low

	*(blue_virt_base + ALTFN0) &= ~(3<<24); 
	*(blue_virt_base + ALTFN0) |= (2<<24); 
	*(blue_virt_base + OUTENB) |= (1<<12);  
	*(blue_virt_base + OUT   ) &= ~(1<<12); 

	*(green_virt_base + ALTFN0) &= ~(3<<26); 
	*(green_virt_base + OUTENB) |= (1<<13);  
	*(green_virt_base + OUT   ) &= ~(1<<13); 

	
	return 0;
}

static void __exit myled_exit(void)
{
	//1.注销字符设备驱动
	unregister_chrdev(major,CNAME);

	//2.取消映射
	iounmap(red_virt_base);
	iounmap(blue_virt_base);
	iounmap(green_virt_base);
}
module_init(myled_init);
module_exit(myled_exit);
MODULE_LICENSE("GPL");


test.c

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

char ubuf[2] = {0,0};
int main(int argc, const char *argv[])
{
	int fd;
	fd = open("/dev/myled",O_RDWR);
	if(fd == -1){
		perror("open error");
		return -1; 
	}

	while(1){
		sleep(1);
		
		//ubuf[1] = !ubuf[1];  
		
		ubuf[1] = ubuf[1]?0:1;

		write(fd,ubuf,sizeof(ubuf));
	}

	close(fd);
	return 0;
}


Makefile
MODNAME?=demo
#KERNELDIR:= /lib/modules/$(shell uname -r)/build/
KERNELDIR:= /home/linux/kernel/kernel-3.4.39/
PWD:=$(shell pwd)

all:
	make -C $(KERNELDIR) M=$(PWD) modules
clean:
	make -C $(KERNELDIR) M=$(PWD) clean

obj-m:=$(MODNAME).o









myled.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include "cmd.h"

#define CNAME "myled" 
#define RED_PHY_BASE 0xc001a000   //a28
#define BLUE_PHY_BASE 0xc001b000  //b12
#define GREEN_PHY_BASE 0xc001e000 //e13

#define OUT    0
#define OUTENB 1
#define ALTFN0 8
#define ALTFN1 9

int major = 0;
char kbuf[2] = {0};

//映射之后产生的虚拟地址
unsigned int *red_virt_base = NULL;
unsigned int *green_virt_base = NULL;
unsigned int *blue_virt_base = NULL;

enum RGB_LED{
	RED,
	GREEN,
	BLUE,
};

int myled_open(struct inode *inode, struct file *file)
{
	printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
	return 0;
}

ssize_t myled_read(struct file *file, 
	char __user *ubuf, size_t size, loff_t *offs)
{
	printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
	return 0;
}

ssize_t myled_write (struct file *file, 
	const char __user *ubuf, size_t size, loff_t *offs)
{
	int ret;

	printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);

	//1.拷贝用户空间的数据
	if(size > sizeof(kbuf)) size = sizeof(kbuf);
	ret = copy_from_user(kbuf,ubuf,size);
	if(ret){
		printk("copy data from user error\n");
		return -EIO;
	}
	//kbuf[2] = {which,status};
	//2.根据用户空间的数据进行点灯
	switch(kbuf[0]){
		case   RED: 
			kbuf[1]?(*(red_virt_base + OUT) |= (1<<28)):\
				(*(red_virt_base + OUT) &= ~(1<<28));
			break;
		case GREEN: 	
			kbuf[1]?(*(green_virt_base + OUT) |= (1<<13)):\
				(*(green_virt_base + OUT) &= ~(1<<13));
			break;
		case  BLUE: 	
			kbuf[1]?(*(blue_virt_base + OUT) |= (1<<12)):\
				(*(blue_virt_base + OUT) &= ~(1<<12));
			break;
	}

	return size;
}
long myled_ioctl(struct file *file, unsigned int cmd, unsigned long args)
{
	switch(cmd){
		case RED_ON:
			*(red_virt_base + OUT) |= (1<<28);
			break;
		case RED_OFF:
			*(red_virt_base + OUT) &= ~(1<<28);
			break;
	}
	return 0;
}

int myled_close(struct inode *inode, struct file *file)
{
	printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
	return 0;
}

const struct file_operations fops = {
	.open = myled_open,
	.read = myled_read,
	.write = myled_write,
	.unlocked_ioctl = myled_ioctl,
	.release = myled_close,
};

static int __init myled_init(void)
{
	//1.注册字符设备驱动
	major = register_chrdev(0,CNAME,&fops);
	if(major < 0){
		printk("register chrdev error\n");
		return major;
	}

	//2.映射RGB_LED灯的地址
	red_virt_base = ioremap(RED_PHY_BASE,40);
	if(red_virt_base == NULL){
		printk("ioremap red led addr error\n");
		return -ENOMEM;
	}
	green_virt_base = ioremap(GREEN_PHY_BASE,40);
	if(green_virt_base == NULL){
		printk("ioremap green led addr error\n");
		return -ENOMEM;
	}
	blue_virt_base = ioremap(BLUE_PHY_BASE,40);
	if(blue_virt_base == NULL){
		printk("ioremap blue led addr error\n");
		return -ENOMEM;
	}

	//3.RGB_LED  INIT ALL OFF
	*(red_virt_base + ALTFN1) &= ~(3<<24);  //altfn1 24:25  gpio
	*(red_virt_base + OUTENB) |= (1<<28);  //outenb 28 输出
	*(red_virt_base + OUT   ) &= ~(1<<28); //out 28 low

	*(blue_virt_base + ALTFN0) &= ~(3<<24); 
	*(blue_virt_base + ALTFN0) |= (2<<24); 
	*(blue_virt_base + OUTENB) |= (1<<12);  
	*(blue_virt_base + OUT   ) &= ~(1<<12); 

	*(green_virt_base + ALTFN0) &= ~(3<<26); 
	*(green_virt_base + OUTENB) |= (1<<13);  
	*(green_virt_base + OUT   ) &= ~(1<<13); 

	return 0;
}

static void __exit myled_exit(void)
{
	//1.注销字符设备驱动
	unregister_chrdev(major,CNAME);

	//2.取消映射
	iounmap(red_virt_base);
	iounmap(blue_virt_base);
	iounmap(green_virt_base);
}
module_init(myled_init);
module_exit(myled_exit);
MODULE_LICENSE("GPL");





test.c

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

#include "cmd.h"

int main(int argc, const char *argv[])
{
	int fd;
	fd = open("/dev/myled",O_RDWR);
	if(fd == -1){
		perror("open error");
		return -1; 
	}

	while(1){
		ioctl(fd,RED_ON);	
		sleep(1);
		ioctl(fd,RED_OFF);	
		sleep(1);
	}

	close(fd);
	return 0;
}


cmd.h

#ifndef __CMD_H__
#define __CMD_H__

#define RED_ON  _IO('a',0)
#define RED_OFF _IO('a',1)



#endif






Makefile


MODNAME?=demo
#KERNELDIR:= /lib/modules/$(shell uname -r)/build/
KERNELDIR:= /home/linux/kernel/kernel-3.4.39/
PWD:=$(shell pwd)

all:
	make -C $(KERNELDIR) M=$(PWD) modules
clean:
	make -C $(KERNELDIR) M=$(PWD) clean

obj-m:=$(MODNAME).o




myled.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include "cmd.h"

#define CNAME "myled" 
#define RED_PHY_BASE 0xc001a000   //a28
#define BLUE_PHY_BASE 0xc001b000  //b12
#define GREEN_PHY_BASE 0xc001e000 //e13

#define OUT    0
#define OUTENB 1
#define ALTFN0 8
#define ALTFN1 9

int major = 0;
char kbuf[2] = {0};
int data = 0;
//映射之后产生的虚拟地址
unsigned int *red_virt_base = NULL;
unsigned int *green_virt_base = NULL;
unsigned int *blue_virt_base = NULL;

enum RGB_LED{
	RED,
	GREEN,
	BLUE,
};

int myled_open(struct inode *inode, struct file *file)
{
	printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
	return 0;
}

ssize_t myled_read(struct file *file, 
	char __user *ubuf, size_t size, loff_t *offs)
{
	printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
	return 0;
}

ssize_t myled_write (struct file *file, 
	const char __user *ubuf, size_t size, loff_t *offs)
{
	int ret;

	printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);

	//1.拷贝用户空间的数据
	if(size > sizeof(kbuf)) size = sizeof(kbuf);
	ret = copy_from_user(kbuf,ubuf,size);
	if(ret){
		printk("copy data from user error\n");
		return -EIO;
	}
	//kbuf[2] = {which,status};
	//2.根据用户空间的数据进行点灯
	switch(kbuf[0]){
		case   RED: 
			kbuf[1]?(*(red_virt_base + OUT) |= (1<<28)):\
				(*(red_virt_base + OUT) &= ~(1<<28));
			break;
		case GREEN: 	
			kbuf[1]?(*(green_virt_base + OUT) |= (1<<13)):\
				(*(green_virt_base + OUT) &= ~(1<<13));
			break;
		case  BLUE: 	
			kbuf[1]?(*(blue_virt_base + OUT) |= (1<<12)):\
				(*(blue_virt_base + OUT) &= ~(1<<12));
			break;
	}

	return size;
}
long myled_ioctl(struct file *file, unsigned int cmd, unsigned long args)
{
	int ret;
	switch(cmd){
		case RED_ON:
			*(red_virt_base + OUT) |= (1<<28);
			break;
		case RED_OFF:
			*(red_virt_base + OUT) &= ~(1<<28);
			break;
		case ACCESS_DATA_R:
			ret = copy_to_user((void *)args,&data,4);
			if(ret){
				printk("ioctl:copy data to user error\n");
				return -EINVAL;
			}

			break;
		case ACCESS_DATA_W:
			ret = copy_from_user(&data,(void *)args,4);
			if(ret){
				printk("ioctl:copy data from user error\n");
				return -EINVAL;
			}
			break;	
	}

	return 0;
}

int myled_close(struct inode *inode, struct file *file)
{
	printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
	return 0;
}

const struct file_operations fops = {
	.open = myled_open,
	.read = myled_read,
	.write = myled_write,
	.unlocked_ioctl = myled_ioctl,
	.release = myled_close,
};

static int __init myled_init(void)
{
	//1.注册字符设备驱动
	major = register_chrdev(0,CNAME,&fops);
	if(major < 0){
		printk("register chrdev error\n");
		return major;
	}

	//2.映射RGB_LED灯的地址
	red_virt_base = ioremap(RED_PHY_BASE,40);
	if(red_virt_base == NULL){
		printk("ioremap red led addr error\n");
		return -ENOMEM;
	}
	green_virt_base = ioremap(GREEN_PHY_BASE,40);
	if(green_virt_base == NULL){
		printk("ioremap green led addr error\n");
		return -ENOMEM;
	}
	blue_virt_base = ioremap(BLUE_PHY_BASE,40);
	if(blue_virt_base == NULL){
		printk("ioremap blue led addr error\n");
		return -ENOMEM;
	}

	//3.RGB_LED  INIT ALL OFF
	*(red_virt_base + ALTFN1) &= ~(3<<24);  //altfn1 24:25  gpio
	*(red_virt_base + OUTENB) |= (1<<28);  //outenb 28 输出
	*(red_virt_base + OUT   ) &= ~(1<<28); //out 28 low

	*(blue_virt_base + ALTFN0) &= ~(3<<24); 
	*(blue_virt_base + ALTFN0) |= (2<<24); 
	*(blue_virt_base + OUTENB) |= (1<<12);  
	*(blue_virt_base + OUT   ) &= ~(1<<12); 

	*(green_virt_base + ALTFN0) &= ~(3<<26); 
	*(green_virt_base + OUTENB) |= (1<<13);  
	*(green_virt_base + OUT   ) &= ~(1<<13); 

	return 0;
}

static void __exit myled_exit(void)
{
	//1.注销字符设备驱动
	unregister_chrdev(major,CNAME);

	//2.取消映射
	iounmap(red_virt_base);
	iounmap(blue_virt_base);
	iounmap(green_virt_base);
}
module_init(myled_init);
module_exit(myled_exit);
MODULE_LICENSE("GPL");


test.c


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

#include "cmd.h"

int main(int argc, const char *argv[])
{
	int fd;
	int data = 50;
	fd = open("/dev/myled",O_RDWR);
	if(fd == -1){
		perror("open error");
		return -1; 
	}

	while(1){
		ioctl(fd,RED_ON);	
		sleep(1);
		ioctl(fd,RED_OFF);	
		sleep(1);
		ioctl(fd,ACCESS_DATA_W,&data);
		sleep(1);
		data = 0;
		ioctl(fd,ACCESS_DATA_R,&data);
		printf("data = %d\n",data);
	}

	close(fd);
	return 0;
}


cmd.h

#ifndef __CMD_H__
#define __CMD_H__

#define RED_ON  _IO('a',0)
#define RED_OFF _IO('a',1)

#define ACCESS_DATA_R _IOR('a',0,int)
#define ACCESS_DATA_W _IOW('a',0,int)

#endif





Makefile



MODNAME?=myled
#KERNELDIR:= /lib/modules/$(shell uname -r)/build/
KERNELDIR:= /home/linux/kernel/kernel-3.4.39/
PWD:=$(shell pwd)

all:
	make -C $(KERNELDIR) M=$(PWD) modules
	arm-none-linux-gnueabi-gcc test.c -o APP-myled
	 cp *.ko APP-myled ~/rootfs/
clean:
	make -C $(KERNELDIR) M=$(PWD) clean

obj-m:=$(MODNAME).o






myled.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include "cmd.h"

#define CNAME "myled" 
#define RED_PHY_BASE 0xc001a000   //a28
#define BLUE_PHY_BASE 0xc001b000  //b12
#define GREEN_PHY_BASE 0xc001e000 //e13

#define OUT    0
#define OUTENB 1
#define ALTFN0 8
#define ALTFN1 9

int major = 0;
char kbuf[2] = {0};
int data = 0;
char sbuf[50] = {0};
//映射之后产生的虚拟地址
unsigned int *red_virt_base = NULL;
unsigned int *green_virt_base = NULL;
unsigned int *blue_virt_base = NULL;

enum RGB_LED{
	RED,
	GREEN,
	BLUE,
};

int myled_open(struct inode *inode, struct file *file)
{
	printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
	return 0;
}

ssize_t myled_read(struct file *file, 
	char __user *ubuf, size_t size, loff_t *offs)
{
	printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
	return 0;
}

ssize_t myled_write (struct file *file, 
	const char __user *ubuf, size_t size, loff_t *offs)
{
	int ret;

	printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);

	//1.拷贝用户空间的数据
	if(size > sizeof(kbuf)) size = sizeof(kbuf);
	ret = copy_from_user(kbuf,ubuf,size);
	if(ret){
		printk("copy data from user error\n");
		return -EIO;
	}
	//kbuf[2] = {which,status};
	//2.根据用户空间的数据进行点灯
	switch(kbuf[0]){
		case   RED: 
			kbuf[1]?(*(red_virt_base + OUT) |= (1<<28)):\
				(*(red_virt_base + OUT) &= ~(1<<28));
			break;
		case GREEN: 	
			kbuf[1]?(*(green_virt_base + OUT) |= (1<<13)):\
				(*(green_virt_base + OUT) &= ~(1<<13));
			break;
		case  BLUE: 	
			kbuf[1]?(*(blue_virt_base + OUT) |= (1<<12)):\
				(*(blue_virt_base + OUT) &= ~(1<<12));
			break;
	}

	return size;
}
long myled_ioctl(struct file *file, unsigned int cmd, unsigned long args)
{
	int ret;
	switch(cmd){
		case RED_ON:
			*(red_virt_base + OUT) |= (1<<28);
			break;
		case RED_OFF:
			*(red_virt_base + OUT) &= ~(1<<28);
			break;
		case ACCESS_DATA_R:
			ret = copy_to_user((void *)args,&data,4);
			if(ret){
				printk("ioctl:copy data to user error\n");
				return -EINVAL;
			}

			break;
		case ACCESS_DATA_W:
			ret = copy_from_user(&data,(void *)args,4);
			if(ret){
				printk("ioctl:copy data from user error\n");
				return -EINVAL;
			}
			break;	
		case ACCESS_STRING_W:
			printk("size = %d\n",(ACCESS_STRING_W>>16)&0x3fff);
			ret = copy_from_user(sbuf,(void *)args,(ACCESS_STRING_W>>16)&0x3fff);
			if(ret){
				printk("ioctl:copy string from user error\n");
				return -EINVAL;
			}
			break;
		case ACCESS_STRING_R:
			ret = copy_to_user((void *)args,sbuf,(ACCESS_STRING_W>>16)&0x3fff);
			if(ret){
				printk("ioctl:copy string to user error\n");
				return -EINVAL;
			}
			break;
			
	}

	return 0;
}

int myled_close(struct inode *inode, struct file *file)
{
	printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
	return 0;
}

const struct file_operations fops = {
	.open = myled_open,
	.read = myled_read,
	.write = myled_write,
	.unlocked_ioctl = myled_ioctl,
	.release = myled_close,
};

static int __init myled_init(void)
{
	//1.注册字符设备驱动
	major = register_chrdev(0,CNAME,&fops);
	if(major < 0){
		printk("register chrdev error\n");
		return major;
	}

	//2.映射RGB_LED灯的地址
	red_virt_base = ioremap(RED_PHY_BASE,40);
	if(red_virt_base == NULL){
		printk("ioremap red led addr error\n");
		return -ENOMEM;
	}
	green_virt_base = ioremap(GREEN_PHY_BASE,40);
	if(green_virt_base == NULL){
		printk("ioremap green led addr error\n");
		return -ENOMEM;
	}
	blue_virt_base = ioremap(BLUE_PHY_BASE,40);
	if(blue_virt_base == NULL){
		printk("ioremap blue led addr error\n");
		return -ENOMEM;
	}

	//3.RGB_LED  INIT ALL OFF
	*(red_virt_base + ALTFN1) &= ~(3<<24);  //altfn1 24:25  gpio
	*(red_virt_base + OUTENB) |= (1<<28);  //outenb 28 输出
	*(red_virt_base + OUT   ) &= ~(1<<28); //out 28 low

	*(blue_virt_base + ALTFN0) &= ~(3<<24); 
	*(blue_virt_base + ALTFN0) |= (2<<24); 
	*(blue_virt_base + OUTENB) |= (1<<12);  
	*(blue_virt_base + OUT   ) &= ~(1<<12); 

	*(green_virt_base + ALTFN0) &= ~(3<<26); 
	*(green_virt_base + OUTENB) |= (1<<13);  
	*(green_virt_base + OUT   ) &= ~(1<<13); 

	return 0;
}

static void __exit myled_exit(void)
{
	//1.注销字符设备驱动
	unregister_chrdev(major,CNAME);

	//2.取消映射
	iounmap(red_virt_base);
	iounmap(blue_virt_base);
	iounmap(green_virt_base);
}
module_init(myled_init);
module_exit(myled_exit);
MODULE_LICENSE("GPL");





test.c


#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <string.h>
#include "cmd.h"
char ubuf[50] = "hello everyone.............";
int main(int argc, const char *argv[])
{
	int fd;
	int data = 50;
	fd = open("/dev/myled",O_RDWR);
	if(fd == -1){
		perror("open error");
		return -1; 
	}

	while(1){
		ioctl(fd,RED_ON);	
		sleep(1);
		ioctl(fd,RED_OFF);	
		sleep(1);
		ioctl(fd,ACCESS_DATA_W,&data);
		sleep(1);
		data = 0;
		ioctl(fd,ACCESS_DATA_R,&data);
		printf("data = %d\n",data);

		ioctl(fd,ACCESS_STRING_W,ubuf);
		memset(ubuf,0,sizeof(ubuf));
		ioctl(fd,ACCESS_STRING_R,ubuf);
		printf("ubuf = %s\n",ubuf);

	}

	close(fd);
	return 0;
}





cmd.h

#ifndef __CMD_H__
#define __CMD_H__

#define RED_ON  _IO('a',0)
#define RED_OFF _IO('a',1)

#define ACCESS_DATA_R _IOR('a',0,int)
#define ACCESS_DATA_W _IOW('a',0,int)

#define ACCESS_STRING_W _IOW('a',0,char [50])
#define ACCESS_STRING_R _IOR('a',0,char [50])



#endif



Makefile


MODNAME?=myled
#KERNELDIR:= /lib/modules/$(shell uname -r)/build/
KERNELDIR:= /home/linux/kernel/kernel-3.4.39/
PWD:=$(shell pwd)

all:
	make -C $(KERNELDIR) M=$(PWD) modules
	arm-none-linux-gnueabi-gcc test.c -o APP-myled
	 cp *.ko APP-myled ~/rootfs/
clean:
	make -C $(KERNELDIR) M=$(PWD) clean

obj-m:=$(MODNAME).o




myled.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/device.h>
#include "cmd.h"

#define CNAME "myled" 
#define RED_PHY_BASE 0xc001a000   //a28
#define BLUE_PHY_BASE 0xc001b000  //b12
#define GREEN_PHY_BASE 0xc001e000 //e13

#define OUT    0
#define OUTENB 1
#define ALTFN0 8
#define ALTFN1 9

int major = 0;
char kbuf[2] = {0};
int data = 0;
char sbuf[50] = {0};
//映射之后产生的虚拟地址
unsigned int *red_virt_base = NULL;
unsigned int *green_virt_base = NULL;
unsigned int *blue_virt_base = NULL;
struct class *cls = NULL;
struct device *dev = NULL;

enum RGB_LED{
	RED,
	GREEN,
	BLUE,
};

int myled_open(struct inode *inode, struct file *file)
{
	printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
	return 0;
}

ssize_t myled_read(struct file *file, 
	char __user *ubuf, size_t size, loff_t *offs)
{
	printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
	return 0;
}

ssize_t myled_write (struct file *file, 
	const char __user *ubuf, size_t size, loff_t *offs)
{
	int ret;

	printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);

	//1.拷贝用户空间的数据
	if(size > sizeof(kbuf)) size = sizeof(kbuf);
	ret = copy_from_user(kbuf,ubuf,size);
	if(ret){
		printk("copy data from user error\n");
		return -EIO;
	}
	//kbuf[2] = {which,status};
	//2.根据用户空间的数据进行点灯
	switch(kbuf[0]){
		case   RED: 
			kbuf[1]?(*(red_virt_base + OUT) |= (1<<28)):\
				(*(red_virt_base + OUT) &= ~(1<<28));
			break;
		case GREEN: 	
			kbuf[1]?(*(green_virt_base + OUT) |= (1<<13)):\
				(*(green_virt_base + OUT) &= ~(1<<13));
			break;
		case  BLUE: 	
			kbuf[1]?(*(blue_virt_base + OUT) |= (1<<12)):\
				(*(blue_virt_base + OUT) &= ~(1<<12));
			break;
	}

	return size;
}
long myled_ioctl(struct file *file, unsigned int cmd, unsigned long args)
{
	int ret;
	switch(cmd){
		case RED_ON:
			*(red_virt_base + OUT) |= (1<<28);
			break;
		case RED_OFF:
			*(red_virt_base + OUT) &= ~(1<<28);
			break;
		case ACCESS_DATA_R:
			ret = copy_to_user((void *)args,&data,4);
			if(ret){
				printk("ioctl:copy data to user error\n");
				return -EINVAL;
			}

			break;
		case ACCESS_DATA_W:
			ret = copy_from_user(&data,(void *)args,4);
			if(ret){
				printk("ioctl:copy data from user error\n");
				return -EINVAL;
			}
			break;	
		case ACCESS_STRING_W:
			printk("size = %d\n",(ACCESS_STRING_W>>16)&0x3fff);
			ret = copy_from_user(sbuf,(void *)args,(ACCESS_STRING_W>>16)&0x3fff);
			if(ret){
				printk("ioctl:copy string from user error\n");
				return -EINVAL;
			}
			break;
		case ACCESS_STRING_R:
			ret = copy_to_user((void *)args,sbuf,(ACCESS_STRING_R>>16)&0x3fff);
			if(ret){
				printk("ioctl:copy string to user error\n");
				return -EINVAL;
			}
			break;
			
	}

	return 0;
}

int myled_close(struct inode *inode, struct file *file)
{
	printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
	return 0;
}

const struct file_operations fops = {
	.open = myled_open,
	.read = myled_read,
	.write = myled_write,
	.unlocked_ioctl = myled_ioctl,
	.release = myled_close,
};

static int __init myled_init(void)
{
	//1.注册字符设备驱动
	major = register_chrdev(0,CNAME,&fops);
	if(major < 0){
		printk("register chrdev error\n");
		return major;
	}

	//2.映射RGB_LED灯的地址
	red_virt_base = ioremap(RED_PHY_BASE,40);
	if(red_virt_base == NULL){
		printk("ioremap red led addr error\n");
		return -ENOMEM;
	}
	green_virt_base = ioremap(GREEN_PHY_BASE,40);
	if(green_virt_base == NULL){
		printk("ioremap green led addr error\n");
		return -ENOMEM;
	}
	blue_virt_base = ioremap(BLUE_PHY_BASE,40);
	if(blue_virt_base == NULL){
		printk("ioremap blue led addr error\n");
		return -ENOMEM;
	}

	//3.RGB_LED  INIT ALL OFF
	*(red_virt_base + ALTFN1) &= ~(3<<24);  //altfn1 24:25  gpio
	*(red_virt_base + OUTENB) |= (1<<28);  //outenb 28 输出
	*(red_virt_base + OUT   ) &= ~(1<<28); //out 28 low

	*(blue_virt_base + ALTFN0) &= ~(3<<24); 
	*(blue_virt_base + ALTFN0) |= (2<<24); 
	*(blue_virt_base + OUTENB) |= (1<<12);  
	*(blue_virt_base + OUT   ) &= ~(1<<12); 

	*(green_virt_base + ALTFN0) &= ~(3<<26); 
	*(green_virt_base + OUTENB) |= (1<<13);  
	*(green_virt_base + OUT   ) &= ~(1<<13); 


	//4.创建设备节点
	cls = class_create(THIS_MODULE,"aaaa");
	if(IS_ERR(cls)){
		printk("class create error\n");
		return PTR_ERR(cls);
	}
	//major<<20|0  =设备号
	//设备号=主设备号(12) +次设备号(20)
	//MKDEV(ma,mi) //通过主设备和次设备号合成设备号
	dev =  device_create(cls,NULL,MKDEV(major,0),NULL,"myled");
	if(IS_ERR(dev)){
		printk("class device error\n");
		return PTR_ERR(dev);
	}
	
	return 0;
}

static void __exit myled_exit(void)
{
	//1.注销设备节点
	device_destroy(cls,MKDEV(major,0));
	class_destroy(cls);
	
	//2.取消映射
	iounmap(red_virt_base);
	iounmap(blue_virt_base);
	iounmap(green_virt_base);
	
	//3.注销字符设备驱动
	unregister_chrdev(major,CNAME);

}
module_init(myled_init);
module_exit(myled_exit);
MODULE_LICENSE("GPL");





test.c


#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <string.h>
#include "cmd.h"
char ubuf[50] = "hello everyone.............";
int main(int argc, const char *argv[])
{
	int fd;
	int data = 50;
	fd = open("/dev/myled",O_RDWR);
	if(fd == -1){
		perror("open error");
		return -1; 
	}

	while(1){
		ioctl(fd,RED_ON);	
		sleep(1);
		ioctl(fd,RED_OFF);	
		sleep(1);
		ioctl(fd,ACCESS_DATA_W,&data);
		sleep(1);
		data = 0;
		ioctl(fd,ACCESS_DATA_R,&data);
		printf("data = %d\n",data);

		ioctl(fd,ACCESS_STRING_W,ubuf);
		memset(ubuf,0,sizeof(ubuf));
		ioctl(fd,ACCESS_STRING_R,ubuf);
		printf("ubuf = %s\n",ubuf);

	}

	close(fd);
	return 0;
}




cmd.h

#ifndef __CMD_H__
#define __CMD_H__

#define RED_ON  _IO('a',0)
#define RED_OFF _IO('a',1)

#define ACCESS_DATA_R _IOR('a',0,int)
#define ACCESS_DATA_W _IOW('a',0,int)

#define ACCESS_STRING_W _IOW('a',0,char [50])
#define ACCESS_STRING_R _IOR('a',0,char [50])



#endif






Makefile



MODNAME?=myled
#KERNELDIR:= /lib/modules/$(shell uname -r)/build/
KERNELDIR:= /home/linux/kernel/kernel-3.4.39/
PWD:=$(shell pwd)

all:
	make -C $(KERNELDIR) M=$(PWD) modules
	arm-none-linux-gnueabi-gcc test.c -o APP-myled
	 cp *.ko APP-myled ~/rootfs/
clean:
	make -C $(KERNELDIR) M=$(PWD) clean

obj-m:=$(MODNAME).o

 

linux 心跳灯_Linux下实现流水灯等功能的LED驱动代码及测试实例
weixin_39974557的博客
12-20 277
#include #include#include#include#include#include#include#include#include#include#include#include#include#include#include#include#include#include//-------------class_create,device_create------#include...
LINUX驱动程序_LED+定时器实现流水灯
08-16
在linux的gcc编译器下，用c编写的led驱动程序实现流水灯功能。
第一个Linux驱动-流水灯
系统运维
07-03 403
水平有限，描述不当之处请指出，转载请注明出处http://blog.youkuaiyun.com/vanbreaker/article/details/7711695 本节介绍如何利用板载的Led和Linux的内核定时器实现一个简单的流水灯的驱动，所使用的开发板是TQ2440，内核版本2.6.30.4。 程序比较简单，也没涉及到什么机制，直接上代码了！关于定时器的使用模板可以参考&lt;&lt;Linux...
Linux驱动修炼之道-流水灯
helloyesyes
04-02 161
哈尔滨理工大学软件工程专业08-7李万鹏原创作品，转载请标明出处 http://blog.youkuaiyun.com/woshixingaaa/archive/2011/04/02/6299318.aspx module.h包含可装载模块需要的大量符号和函数定义，包含init.h的目的是指定初始化和清除代码，struct file是在&lt;linux/fs.h&gt;中定义的。注册字符设备使用int ...
Linux流水灯驱动程序,leds流水灯驱动 linux流水灯驱动程序
weixin_32142107的博客
05-06 357
讲解：cortexa8 leds流水灯驱动编写步骤一、led底层驱动1、模块许可2、加载函数1)构建设备号，MKDEV2)申请设备号register_chrdev_region3)注册字符设备cdev_initcdev_add4)映射相应的寄存器 ioremap5)初始化控制寄存器, readl和writel3、卸载函数1)注销字符设备 cdev_del2)释放设备号unregister_chr...
基于Linux的嵌入式虚拟实验平台的应用——以GPIO流水灯驱动开发为例.pdf
09-06
基于Linux的嵌入式虚拟实验平台的应用——以GPIO流水灯驱动开发为例 本文提出了一种基于Linux的嵌入式虚拟实验平台的搭建方法，以解决高校嵌入式实验平台缺乏的问题。该方法首先介绍VMware虚拟机的安装方法，然后...
混杂设备驱动led流水灯实现
最新发布
05-21
本文将详细介绍如何实现一个混杂设备驱动程序来控制LED流水灯。 首先，我们需要了解混杂设备驱动程序的基本原理。在Linux内核中，所有的设备驱动程序都需要注册一个或多个字符设备或块设备。混杂设备（misc device...
FL2440平台Linux驱动实现流水灯效果教程
现在我们来具体分析一下在FL2440开发板上使用linux-2.6.28.7内核来开发流水灯驱动的流程： - **硬件准备**: 开发者首先需要准备FL2440开发板以及一套流水灯硬件设备。 - **环境搭建**: 开发者需要在宿主机上安装...
leds.rar_linux arm led_流水灯
09-24
这个实验是嵌入式系统开发中的一个经典案例，它可以帮助开发者更好地理解和掌握底层硬件控制以及Linux驱动程序的编写。 标题“leds.rar_linux arm led_流水灯”暗示了这是一个针对Linux操作系统的ARM处理器的LED...
Linux内核LED驱动实现与流水灯测试应用
通过上述分析，我们可以看到，一个简单的“驱动点灯2.6内核”涵盖了Linux内核编程、内核模块管理、硬件驱动开发等多方面的知识。对于那些希望深入了解Linux操作系统如何与硬件设备交互的开发者来说，这是一个非常...
Linux下实现流水灯等功能的LED驱动代码及测试实例
weixin_30668887的博客
08-26 685
驱动代码： #include <linux/errno.h> #include <linux/kernel.h> #include <linux/module.h> #include <linux/slab.h> #include <linux/input.h> #include <linux/init.h> ...
基于Linux的流水灯驱动实验,Linux下实现流水灯等功能的LED驱动代码及测试实例...
weixin_33093323的博客
05-15 305
) {for (j=0;j<4;j++)gpio_set_value(led_table[j],0);mdelay(400); //delay 400msfor (j=0;j<4;j++)gpio_set_value(led_table[j],1);mdelay(400);}break;}caseIOCTL_LED_ALLON:printk("in the IOCTL_LED_ALLO...
Linux驱动开发③--LED流水灯驱动示例
欢迎光临
01-06 1647
#include #include #include #include #include #include #include #include #include #include #include #include #include #include #define DEVICE_NAME "FLOWLED" #define LED_MAJOR 246 /* 主设
我在这块牛X的A40i Linux开发板上点了个流水灯
qq_16519885的博客
09-16 602
非常不错的LINUX开发板，可惜用来点了灯...
Linux流水灯驱动程序,linux设备驱动学习笔记7------led流水灯的驱动编写
weixin_36263738的博客
05-06 340
本实验的基于sep4020EVB 1.5开发板的一个小实验，实现流水灯的功能。利用的端口是GPB0-GPB4 这5个端口底层的驱动程序：#include #include #include #include #include #include #include #include //#include #include #include #include #include #include #def...
linux线程实现流水灯,52单片机四种方法实现流水灯
weixin_42301816的博客
05-09 664
52单片机IO口输出-流水灯流水灯电路分析流水灯电路图电源→限流电阻→发光二极管→74HC573输出端→单片机P1组IO口因为单片机的IO口输出电流非常小，无法直接用IO口驱动发光二极管，所以我们需要用到74HC573这个芯片(可以理解为电流放大的芯片)。74HC573芯片图从图中可以看出74HC573有20个引脚，Vcc和GND是电源的正负极，2 ~ 9的引脚是输入端，12 ~ 19的引脚是输出...
Tiny6410流水灯——在已经启动的ARM Linux系统上Ｃ程实现
zzwpublic的专栏
11-01 1620
Tiny6410流水灯——在已经启动的ARMLinux系统上Ｃ程实现 拿到开发板有几个月了，一直想弄个流水灯程序，以验证一下怎么下载程序和运行程序。刚开始弄个裸机程序试试，但不想破坏原NandFlash中的系统，在SD卡上启动倒是也可以，但老是插拔SD卡也不方便，何况有时候接触不好读不出。后来想想，干脆弄个C程序在已经启动的系统上试验一下流水灯吧。可是我对这个还是不太熟悉，只好上网baidu一下
【Linux系统开发】Study210利用SD运行流水灯程序
以放的博客
04-17 671
文章目录裸机开发环境的搭建1.安装ecilpse（1）确认自己的PC机开发环境。开发板光盘中有如下四个eclipse包：（2）配置好eclipse的环境变量2.开始工程的创建（1）首先双击eclipse.exe文件进入，初次进入需要选择一个存储位置作为工程存放处（workplace）（2）建一个流水灯工程3.下载源码到SD卡4.实例演示（1）清除开发板中的bootloader（2）通过SD卡运行裸机程序 裸机开发环境的搭建 1.安装ecilpse （1）确认自己的PC机开发环境。开发板光盘中有如下四个ecl
嵌入式linux流水灯,嵌入式版"Hello world"之流水灯实验
weixin_35903340的博客
05-06 1019
在短短的两周内，我们集中学习了ARM体系结构相关课程和ucos基础课程，并第一次深入一个操作系统的内部进行详细的学习探究。在学习了ucos和相关工具下的demo之后，我终于将汇编、hex、c等底层代码和硬件联系在了一起。一直做web、桌面应用开发，我这次算是体验到了另外的世界和开发思路。关注于：代码计数用大小k关注效率关注空间注意赋值--掩码赋值学会看芯片时序图看清引脚等等下面开始我们的Hello...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值