使用了阻塞模型，雖然把資源浪費的問題給解決了，但是又出現了新的問題，當我們沒有按下按鍵時候，程序休眠，如果不按下按鍵，程序就一直休眠一直阻塞在那裡，效率很明顯就低了
是以就引出有一種叫做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=)