实验二 按键

一、实验目的

1.熟悉linux系统，学会简单linux指令

2.熟悉OK6410-A开发板的烧入步骤

3.熟悉ARM寄存器，地址等。

4.系统性的了解UBOOT和linux内核，yaffs2系统映像等知识

二、实验仪器

开发机环境

      操作系统：ubuntu 20.04
      交叉编译环境：arm-linux-gcc 4.6.4 
      6410板子内核源码：linux-3.0.1 

目标板环境

	OK6410-A     linux-3.0.1 

环境配置看这里

三、实验内容（原理）

1.硬件部分

四、实验步骤

1.编写驱动程序

driver_key.c

//driver_key.c
#include <linux/kernel.h>  
 #include <linux/module.h>  
 #include <linux/init.h>  
 #include <linux/fs.h>  
 #include <linux/gpio.h>  
 #include <linux/types.h> 
 #include <linux/cdev.h>  
 #include <linux/interrupt.h>  
 #include <linux/sched.h>  
 #include <linux/device.h>  
 #include <linux/poll.h>  
 #include <linux/semaphore.h>  
 #include <linux/timer.h>  
 #include <asm/irq.h>  
 #include <asm/uaccess.h>  
 #include <mach/hardware.h>  
 #include <mach/irqs.h>  
   MODULE_LICENSE("GPL");  
 #define DEVICE_NAME "keyint"  
 #define KEYNUM 6  
 dev_t devid;  
 //static DEFINE_SEMAPHORE(key_lock);  //declare a mutex lock for keyint  
   //定义一个信号量  
 struct semaphore key_lock;  
 static struct fasync_struct *key_async;   
 static struct timer_list key_timer;  
 struct key_irq_desc {  
     int irq;        //irq num  
     unsigned long flags;    //irq flags,identified the way of irq here,eq.edge,level  
     char *name;        //irq name  
 };  
 static struct key_irq_desc key_irqs[] = {  
     //下降沿产生中断  
     {IRQ_EINT(0), IRQF_TRIGGER_FALLING, "KEY1"},  
     {IRQ_EINT(1), IRQF_TRIGGER_FALLING, "KEY2"},  
     {IRQ_EINT(2), IRQF_TRIGGER_FALLING, "KEY3"},  
     {IRQ_EINT(3), IRQF_TRIGGER_FALLING, "KEY4"},  
     {IRQ_EINT(4), IRQF_TRIGGER_FALLING, "KEY5"},  
     {IRQ_EINT(5), IRQF_TRIGGER_FALLING, "KEY6"},  
 };  
 /*define a waiting queue here*/  
 static DECLARE_WAIT_QUEUE_HEAD(key_waitq);  
 /*define a event flag ev_press*/  
 static volatile int ev_press = 0;  
 static volatile int press_cnt[KEYNUM] = {0,0,0,0,0,0};  
 /*中断处理函数*/  
 static irqreturn_t keys_interrupt(int irq, void *dev_id)  
 { 
     volatile int *press_cnt = (volatile int *) dev_id;  
        /*set the pressed key flag(must do here due to not be static value)*/  
     *press_cnt = *press_cnt + 1;  
     //延时10ms后执行定时器处理函数  
     mod_timer(&key_timer,jiffies+HZ/100);        //start timer after 10ms  
     return IRQ_RETVAL(IRQ_HANDLED);  
 } 
//定时器处理函数  
 static void key_timer_func(unsigned long data)  
 {
     ev_press = 1;  
     //唤醒等待队列  
     wake_up_interruptible(&key_waitq);  
     kill_fasync(&key_async, SIGIO, POLL_IN);  
 }  
 static int key_fasync(int fd, struct file *filp, int on)  
 {  
     printk("Function key_fasync\n");  
     return fasync_helper(fd,filp,on,&key_async);  
 }  
 static unsigned key_poll(struct file *file, poll_table *wait)  
 {  
     unsigned int mask=0;  
     //指明要使用的等待队列  
     poll_wait(file,&key_waitq,wait);  
    //返回掩码  
     if(ev_press)  
     mask |= POLL_IN | POLLRDNORM; 
     printk("poll wait\n"); 
     return mask;  
 }  
 static int key_open(struct inode *inode, struct file *file)  
 {  
     int num;  
     if(file->f_flags & O_NONBLOCK) {  
       if(down_trylock(&key_lock)) return -EBUSY;  
     }  
     else {  
       down(&key_lock);  
     }  
     //为每个按键注册中断处理程序  
     for(num=0;num<KEYNUM;num++) {  
       request_irq(key_irqs[num].irq, keys_interrupt, key_irqs[num].flags, key_irqs[num].name, (void *)&press_cnt[num]);  
     } 
     return 0;  
 }
 static int key_close(struct inode *inode, struct file *file)  
 { 
     int num;  
     //释放中断号  
     for(num=0;num<6;num++) {  
       free_irq(key_irqs[num].irq, (void *)&press_cnt[num]);  
     }  
     up(&key_lock);  
     printk("key_close free irqs\n");  
     return 0;  
 }  
 static int key_read(struct file *filp, char __user *buff, size_t count, loff_t *offp)  
 {  
 //    unsigned int err;  
     //判断是阻塞读还是非阻塞读  
     if(filp->f_flags & O_NONBLOCK) {  
       if(!ev_press)  return -EAGAIN;  
     } 
     else {  
       /*if ev_press==0,then sleep*/  
       /*阻塞，当有按键按下时(中断)被唤醒*/  
       wait_event_interruptible(key_waitq,ev_press);  
     }  
     //阻塞结束，有键按下了  
     ev_press = 0;  
     //拷贝数据到用户空间  
     copy_to_user(buff,(const void *)press_cnt,min(sizeof(press_cnt),count));  
     memset((void *)press_cnt,0,sizeof(press_cnt));  
 //    printk("read and clean press_cnt\n");  
     return 1;  
 }  
 static struct file_operations key_ops = {  
     .owner     = THIS_MODULE,  
     .open     = key_open,  
     .release = key_close,  
     .read     = key_read,  
     .poll     = key_poll,  
     .fasync     = key_fasync,  
 };  
 static struct cdev *cdev_keyint;  
 static struct class *keyint_class;  
 //模块初始化函数  
 static int __init s3c6410_keyint_init(void) {  
     int val; 
     /*timer initial */  
     init_timer(&key_timer);  
     key_timer.function = key_timer_func;  
     add_timer(&key_timer);  
         /*初始化信号量*/  
        init_MUTEX(&key_lock);  
     /*register device*/  
     val = alloc_chrdev_region(&devid,0,1,DEVICE_NAME);  
     if(val) {  
       return -1;  
       printk("register keyint error\n");  
     }  
     cdev_keyint = cdev_alloc();  
     cdev_init(cdev_keyint, &key_ops);  
     cdev_keyint->owner = THIS_MODULE;  
     cdev_keyint->ops   = &key_ops;  
     val = cdev_add(cdev_keyint,devid,1); 
     if(val) {
       return -1;  
       printk("add device error\n");  
     }  
     keyint_class = class_create(THIS_MODULE,DEVICE_NAME);  
     device_create(keyint_class,NULL,devid,NULL,"%s",DEVICE_NAME);  
     printk("KEY initialezed ^_^\n");  
     return 0;  
 }  
 static void __exit s3c6410_keyint_exit(void)  
 { 
      cdev_del(cdev_keyint);  
     device_destroy(keyint_class,devid);  
     class_destroy(keyint_class);  
     unregister_chrdev_region(devid,1); 
 } 
 module_init(s3c6410_keyint_init);  
 module_exit(s3c6410_keyint_exit); 

2.编写Makefile文件

ifneq ($(KERNELRELEASE),)
obj-m := driver_key.o
else 
KDIR := /home/kk/Desktop/forlinx/linux-3.0.1
all:
	make -C $(KDIR) M=$(PWD) modules ARCH=arm CROSS_COMPILE=arm-linux-
clean:
	 rm -f *.ko *.o *.mod.o *.mod.c *.symvers
endif

3.编写执行文件

app_key.c

//app_key.c
#include <stdio.h>  
 #include <stdlib.h>  
 #include <unistd.h>  
 #include <sys/ioctl.h>  
 int main(int argc, char **argv)  
 {  
     int fd;  
     int val;  
     int i;  
     int key_value[6];  
     fd = open("/dev/keyint",0);  
     if(fd<0) {  
       printf("open devie error\n");  
       return -1;  
     }  
     while(1) {  
       val = read(fd,key_value, sizeof(key_value));  
       if(val<0) {  
         printf("read error\n");  
         continue;  
       }  
       for (i=0;i<6;i++) {  
          if(key_value[i])  
          printf("KEY%d pressed\n",(i+1),key_value[i]);  
       }   
     }  
     close(fd);  
     return 0;  
 }  

4.编译驱动程序与测试程序

 #make

将编译生成 driver_key.ko等文件

#arm-linux-gcc  app_key.c  -o  anjian

将生成anjian可执行文件

最后呈现以下文件

5.修改系统内核文件

在原有到内核中，按键的GPIO口被占用，需要进行相应到修改才能达到预期到效果，首先需要做的是安装libncurses 的相关软件，来实现对内核到编写
内核编写过程：
找到内核

make menuconfig

按照下面一路选择
Device Drivers
Input device support
keyboards
有GPIO Buttons
把这个选项去掉

make zImage

生成zImage镜像文件
之后重新烧写

6.格式化SD卡，把 SD 卡格式化为 FAT32 格式。

7.用SD_Writer将 mmc.bin 烧写到 SD 卡中

1.以管理员身份运行
2.点击”Scan”，这个步骤是自动搜寻 SD 卡所在盘符。如果"Scan"没有正确设置 SD 卡所在盘符，就需要手动 调整 SD Volume，把盘符号调整为 SD 卡所在盘符（比如说，PC 的 USB 口接了两个或者两个以上的 U 盘或 者 SD 卡，就有可能错误到扫描 SD 卡盘符）。
3.将”SD Type”更改为 auto。这个步骤是为了让 SD_Writer 自动识别 SD 卡类型。
4.将”OS Type”更改为 Linux。这个步骤是选择要烧写的系统类型。
5.点击”Select Boot”, 选择适合自己开发板的 mmc.bin
mmc_ram128.bin 适用于 128M 内存的开发板
mmc_ram256.bin 适用于 256M 内存的开发板
6.点击”Program”，出现”It’s OK”表示操作成功。

8.拷贝系统文件

首先，将 u-boot.bin 拷贝到 SD 卡中。
u-boot_ram128.bin 专门用于 128M 内存开发板。
u-boot_ram256.bin 专门用于 256M 内存开发板。
将与开发板对应的 u-boot 拷贝到 SD 卡中。接着在 SD 卡中将文件名改为u-boot.bin 即可。

然后，将 zImage 拷贝到 SD 卡中。zImage 是 Linux 的内核映像文件。

最后，将 rootfs.yaffs2 拷贝到 SD 卡中。
rootfs.yaffs2-nand256m 专门用于 128M 内存，256M NandFlash开发板。
rootfs.yaffs2-nand2g 专门用于 256M 内存，1G 或 2G 或者 4G Nandflash 的开发板

9.拷贝驱动程序与测试程序

将driver_led.ko与test拷贝到SD卡上

10.烧写Linux到开发板的NandFlash

步骤 1. 将制作好的 SD 卡插入开发板 SD 的插槽。

步骤 2. 接好 5V 直流电源（飞凌提供此电源，请使用飞凌提供的电源）。

步骤 3. 拨码开关设置为 SD 卡启动。

拨码开关在底板SD 卡启动的拨码开关设置如下：

11. 测试

1.打开终端
2.加载驱动
#insmod /sdcard/driver_key.ko
3.创建设备文件
#mknod /dev/my_led c 240 0
4.测试
./anjian
5.卸载驱动
#rmmod driver_key

五、实验程序（包括流程图）

1.编写驱动程序

driver_key.c

//driver_key.c
#include <linux/kernel.h>  
 #include <linux/module.h>  
 #include <linux/init.h>  
 #include <linux/fs.h>  
 #include <linux/gpio.h>  
 #include <linux/types.h> 
 #include <linux/cdev.h>  
 #include <linux/interrupt.h>  
 #include <linux/sched.h>  
 #include <linux/device.h>  
 #include <linux/poll.h>  
 #include <linux/semaphore.h>  
 #include <linux/timer.h>  
 #include <asm/irq.h>  
 #include <asm/uaccess.h>  
 #include <mach/hardware.h>  
 #include <mach/irqs.h>  
   MODULE_LICENSE("GPL");  
 #define DEVICE_NAME "keyint"  
 #define KEYNUM 6  
 dev_t devid;  
 //static DEFINE_SEMAPHORE(key_lock);  //declare a mutex lock for keyint  
   //定义一个信号量  
 struct semaphore key_lock;  
 static struct fasync_struct *key_async;   
 static struct timer_list key_timer;  
 struct key_irq_desc {  
     int irq;        //irq num  
     unsigned long flags;    //irq flags,identified the way of irq here,eq.edge,level  
     char *name;        //irq name  
 };  
 static struct key_irq_desc key_irqs[] = {  
     //下降沿产生中断  
     {IRQ_EINT(0), IRQF_TRIGGER_FALLING, "KEY1"},  
     {IRQ_EINT(1), IRQF_TRIGGER_FALLING, "KEY2"},  
     {IRQ_EINT(2), IRQF_TRIGGER_FALLING, "KEY3"},  
     {IRQ_EINT(3), IRQF_TRIGGER_FALLING, "KEY4"},  
     {IRQ_EINT(4), IRQF_TRIGGER_FALLING, "KEY5"},  
     {IRQ_EINT(5), IRQF_TRIGGER_FALLING, "KEY6"},  
 };  
 /*define a waiting queue here*/  
 static DECLARE_WAIT_QUEUE_HEAD(key_waitq);  
 /*define a event flag ev_press*/  
 static volatile int ev_press = 0;  
 static volatile int press_cnt[KEYNUM] = {0,0,0,0,0,0};  
 /*中断处理函数*/  
 static irqreturn_t keys_interrupt(int irq, void *dev_id)  
 { 
     volatile int *press_cnt = (volatile int *) dev_id;  
        /*set the pressed key flag(must do here due to not be static value)*/  
     *press_cnt = *press_cnt + 1;  
     //延时10ms后执行定时器处理函数  
     mod_timer(&key_timer,jiffies+HZ/100);        //start timer after 10ms  
     return IRQ_RETVAL(IRQ_HANDLED);  
 } 
//定时器处理函数  
 static void key_timer_func(unsigned long data)  
 {
     ev_press = 1;  
     //唤醒等待队列  
     wake_up_interruptible(&key_waitq);  
     kill_fasync(&key_async, SIGIO, POLL_IN);  
 }  
 static int key_fasync(int fd, struct file *filp, int on)  
 {  
     printk("Function key_fasync\n");  
     return fasync_helper(fd,filp,on,&key_async);  
 }  
 static unsigned key_poll(struct file *file, poll_table *wait)  
 {  
     unsigned int mask=0;  
     //指明要使用的等待队列  
     poll_wait(file,&key_waitq,wait);  
    //返回掩码  
     if(ev_press)  
     mask |= POLL_IN | POLLRDNORM; 
     printk("poll wait\n"); 
     return mask;  
 }  
 static int key_open(struct inode *inode, struct file *file)  
 {  
     int num;  
     if(file->f_flags & O_NONBLOCK) {  
       if(down_trylock(&key_lock)) return -EBUSY;  
     }  
     else {  
       down(&key_lock);  
     }  
     //为每个按键注册中断处理程序  
     for(num=0;num<KEYNUM;num++) {  
       request_irq(key_irqs[num].irq, keys_interrupt, key_irqs[num].flags, key_irqs[num].name, (void *)&press_cnt[num]);  
     } 
     return 0;  
 }
 static int key_close(struct inode *inode, struct file *file)  
 { 
     int num;  
     //释放中断号  
     for(num=0;num<6;num++) {  
       free_irq(key_irqs[num].irq, (void *)&press_cnt[num]);  
     }  
     up(&key_lock);  
     printk("key_close free irqs\n");  
     return 0;  
 }  
 static int key_read(struct file *filp, char __user *buff, size_t count, loff_t *offp)  
 {  
 //    unsigned int err;  
     //判断是阻塞读还是非阻塞读  
     if(filp->f_flags & O_NONBLOCK) {  
       if(!ev_press)  return -EAGAIN;  
     } 
     else {  
       /*if ev_press==0,then sleep*/  
       /*阻塞，当有按键按下时(中断)被唤醒*/  
       wait_event_interruptible(key_waitq,ev_press);  
     }  
     //阻塞结束，有键按下了  
     ev_press = 0;  
     //拷贝数据到用户空间  
     copy_to_user(buff,(const void *)press_cnt,min(sizeof(press_cnt),count));  
     memset((void *)press_cnt,0,sizeof(press_cnt));  
 //    printk("read and clean press_cnt\n");  
     return 1;  
 }  
 static struct file_operations key_ops = {  
     .owner     = THIS_MODULE,  
     .open     = key_open,  
     .release = key_close,  
     .read     = key_read,  
     .poll     = key_poll,  
     .fasync     = key_fasync,  
 };  
 static struct cdev *cdev_keyint;  
 static struct class *keyint_class;  
 //模块初始化函数  
 static int __init s3c6410_keyint_init(void) {  
     int val; 
     /*timer initial */  
     init_timer(&key_timer);  
     key_timer.function = key_timer_func;  
     add_timer(&key_timer);  
         /*初始化信号量*/  
        init_MUTEX(&key_lock);  
     /*register device*/  
     val = alloc_chrdev_region(&devid,0,1,DEVICE_NAME);  
     if(val) {  
       return -1;  
       printk("register keyint error\n");  
     }  
     cdev_keyint = cdev_alloc();  
     cdev_init(cdev_keyint, &key_ops);  
     cdev_keyint->owner = THIS_MODULE;  
     cdev_keyint->ops   = &key_ops;  
     val = cdev_add(cdev_keyint,devid,1); 
     if(val) {
       return -1;  
       printk("add device error\n");  
     }  
     keyint_class = class_create(THIS_MODULE,DEVICE_NAME);  
     device_create(keyint_class,NULL,devid,NULL,"%s",DEVICE_NAME);  
     printk("KEY initialezed ^_^\n");  
     return 0;  
 }  
 static void __exit s3c6410_keyint_exit(void)  
 { 
      cdev_del(cdev_keyint);  
     device_destroy(keyint_class,devid);  
     class_destroy(keyint_class);  
     unregister_chrdev_region(devid,1); 
 } 
 module_init(s3c6410_keyint_init);  
 module_exit(s3c6410_keyint_exit); 

2.编写Makefile文件

ifneq ($(KERNELRELEASE),)
obj-m := driver_key.o
else 
KDIR := /home/kk/Desktop/forlinx/linux-3.0.1
all:
	make -C $(KDIR) M=$(PWD) modules ARCH=arm CROSS_COMPILE=arm-linux-
clean:
	 rm -f *.ko *.o *.mod.o *.mod.c *.symvers
endif

3.编写执行文件

app_key.c

//app_key.c
#include <stdio.h>  
 #include <stdlib.h>  
 #include <unistd.h>  
 #include <sys/ioctl.h>  
 int main(int argc, char **argv)  
 {  
     int fd;  
     int val;  
     int i;  
     int key_value[6];  
     fd = open("/dev/keyint",0);  
     if(fd<0) {  
       printf("open devie error\n");  
       return -1;  
     }  
     while(1) {  
       val = read(fd,key_value, sizeof(key_value));  
       if(val<0) {  
         printf("read error\n");  
         continue;  
       }  
       for (i=0;i<6;i++) {  
          if(key_value[i])  
          printf("KEY%d pressed\n",(i+1),key_value[i]);  
       }   
     }  
     close(fd);  
     return 0;  
 }  

4.流程图

六、运行结果

按键按下的屏幕显示：

七、心得体会