使用了阻塞模型，虽然把资源浪费的问题给解决了，但是又出现了新的问题，当我们没有按下按键时候，进程休眠，如果不按下按键，进程就一直休眠一直阻塞在那里，效率很明显就低了
所以就引出有一种叫做poll/select机制的模型，同时监控多个设备，即使有一个设备堵塞在那里也不会影响其他的设备
首先来看app，要监控多个设备，所以要打开多个设备
fd=open("/dev/qin",O_RDWR);
struct mypollfd pfd[2];
pfd[0].fd=fd;
pfd[0].event=POLLIN;
pfd[1].fd=0;//0代表标准输出，系统宏定义的，不用纠结
pfd[1].event=POLLIN;
定义一个结构体，存放监控设备的信息
struct mypollfd{
int fd;//需要打开的的设备文件
short event;//监控的事件，读，写或者出错
short revents;//内核自动复制，是否可以读写
};
POLLIN代表标准读操作
我们需要在循环里面用poll函数对设备实时监控
返回值大于0，说明监控的设备中有一个发生了相应的事件.
接下来再去判断是哪一个设备触发了事件
if(pfd[0].revents & POLLIN)
{
//做相应的读写操作
}
if(pfd[1].revents & POLLIN)
{
//做相应的读写操作
}
这样就能完成监控多个设备
接下来是驱动程序
在file_operations结构体中实现.poll就行了
static struct file_operations myfops={
.owner=THIS_MODULE,
.open=key_open,
.release=key_close,
.write=key_write,
.read=key_read,
.poll=key_poll,
};
poll函数中
unsigned int key_poll (struct file *file, struct poll_table_struct *fdpoll){
unsigned int mask;
poll_wait(file,&my_key.key_hand_queue,fdpoll);//加入等待队列
if(!my_key.key_state)//判断按键是否按下
{
mask=0;
}
else{
mask=mask | POLLIN;//当按下时候返回POLLLIN会被app捕捉到
}
return mask;
}
这样就完成了对多个设备的监控操作了，即使一个阻塞也不会影响其他的设备
完整驱动代码如下：
#include<linux/init.h>
#include<linux/module.h>
#include<linux/device.h>
#include<linux/fs.h>
#include <asm/uaccess.h>
#include<linux/interrupt.h> //中断注册注销头文件
#include<linux/gpio.h> //gpio相关的头文件
#include<linux/cdev.h>
#include <linux/string.h>
#include<linux/sched.h>
#include<linux/poll.h>
struct key_event{
int code;//按键类型
int value;//按键状态，按下或者抬起( 0 / 1 )
};
struct key_dsc{
int major;
struct cdev *key_cdev;
struct class *key_class;
struct device *key_dev;
int irq;//中断号
unsigned long flag;
struct key_event my_event;
wait_queue_head_t key_hand_queue;
int key_state;
};
#define device_name "qin_key"
#define class_name "qin_class"
#define KEY_ENTER 28
struct key_dsc my_key;
ssize_t key_read(struct file *file, const char __user *buffer, size_t count, loff_t *fpos){
// ****************read函数目的是将案按键的数组传到应用层，kbuf[4] ************
//没有数据将会休眠进行到这一步，不会再往下执行
wait_event_interruptible(my_key.key_hand_queue,my_key.key_state);//将进程休眠，用my_ke中的state状态判断
//有数据将会继续往下执行
if(copy_to_user(buffer,&my_key.my_event,sizeof(struct key_event)))//copy_to_user 返回零代表copy失败，1代表成功
{
printk("\n copy fail!! \n");
}
memset(&my_key.my_event,0,sizeof(struct key_event));
my_key.key_state=0;//本次数据传送完需要将状态置0，继续休眠
return count;
}
ssize_t key_write (struct file *file, const char __user *buf, size_t count, loff_t *fpos){
printk("\n key_ is write!! \n");
}
int key_open (struct inode *inode, struct file *file){
printk("\n key_ is open!! \n");
return 0;
}
int key_close(struct inode *inode, struct file *file){
printk("\n key_ is close!! \n");
}
irqreturn_t key_handle_t(int irq,void *dev_id){
int dn=0;
dn=gpio_get_value(EXYNOS4_GPX3(2));//根据这个函数获取GPX3_2的按键状态
if(!dn)
{
printk("\n key down !! \n");
my_key.my_event.code=KEY_ENTER;
my_key.my_event.value=1;
}
else
{
printk("\n key up !! \n");
my_key.my_event.code=KEY_ENTER;
my_key.my_event.value=0;
}
wake_up_interruptible(&my_key.key_hand_queue);//唤醒进程
my_key.key_state=1;//此时有数据，将状态置1
return IRQ_HANDLED;
}
unsigned int key_poll (struct file *file, struct poll_table_struct *fdpoll){
unsigned int mask;
poll_wait(file,&my_key.key_hand_queue,fdpoll);
if(!my_key.key_state)
{
mask=0;
}
else{
mask=mask | POLLIN;
}
return mask;
}
static struct file_operations myfops={
.owner=THIS_MODULE,
.open=key_open,
.release=key_close,
.write=key_write,
.read=key_read,
.poll=key_poll,
};
static int __init mykey_init(void)
{
my_key.irq=0;
my_key.major=250;
my_key.flag=IRQF_DISABLED |
IRQF_TRIGGER_FALLING |
IRQF_TRIGGER_RISING;//设置属性，上升，下降沿触发
my_key.irq=gpio_to_irq(EXYNOS4_GPX3(2));//获取中断号
request_irq(my_key.irq,key_handle_t,my_key.flag,"key1",NULL);//将这个按键注册到内核，这样才能识别
if(register_chrdev(my_key.major,"qin",&myfops))//返回值为1则失败
{
printk("\nregister is faile !\n");
}
else
{
printk("\nregister is ok !\n");
}
my_key.key_class=class_create(THIS_MODULE,"class");
my_key.key_dev=device_create(my_key.key_class,NULL,MKDEV(my_key.major,0),NULL,"qin");
printk("\nI am key_dev\n");
my_key.key_state=0;
init_waitqueue_head(&my_key.key_hand_queue);//初始化等待队列头
return 0;
}
static int __exit mykey_exit(void)
{
free_irq(my_key.irq,NULL); //注销key1中断
device_destroy(my_key.key_class,MKDEV(my_key.major,0));//注销dev
class_destroy(my_key.key_class);//注销class
unregister_chrdev(my_key.major,"qin");
printk("\n bye bye~~~~~~~\n");
return 0;
}
module_init(mykey_init);
module_exit(mykey_exit);
MODULE_LICENSE("GPL");
app：
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdio.h>
#include<string.h>
#include<poll.h>
#define KEY_ENTER 28
struct key_event{
int code;//按键类型
int value;//按键状态，按下或者抬起( 0 / 1 )
};
struct mypollfd{
int fd;
short event;
short revents;//内核自动复制，是否可以读写
};
int main()
{
char buf[12];
struct key_event key;
int ret=0;
int fd=0;
fd=open("/dev/qin",O_RDWR);
if(fd<0)
{ printf("open file fail!");
}
else
{
printf("\n open file success !!\n");
}
struct mypollfd pfd[2];
pfd[0].fd=fd;
pfd[0].event=POLLIN;
pfd[1].fd=0;
pfd[1].event=POLLIN;
while(1)
{
//printf("\n-------------------------------start poll------------------\n");
ret=poll(pfd,2,-1);
if(ret>0)
{
if(pfd[0].revents & POLLIN)
{
read(pfd[0].fd,&key,sizeof(struct key_event));
if(key.code==KEY_ENTER)
{
if(key.value==0)
{
printf("\n key value is %d \n",key.code);
printf("\n key value is %d \n",key.value);
printf("\n key up!!!!!!!!!! \n");
}
if(key.value==1)
{
printf("\n key value is %d \n",key.code);
printf("\n key value is %d \n",key.value);
printf("\n key down!!!!!!!!!! \n");
}
}
}
if(pfd[1].revents & POLLIN)
{
fgets(buf,128,stdin);
printf("\nstdin ！！！！！！！！！！！！n");
}
}
else
{
perror("\npoll!\n");
return -1;
}
//printf("\n-------------------------------end poll------------------\n");
}
close(fd);
return 0;
}
![【蓝桥杯单片机06】矩阵键盘的基本控制[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)