一、阻塞和非阻塞简介

1、IO 概念

2、阻塞与非阻塞

二、等待队列

1、等待队列头

2、等待队列项

3、将队列项添加/移除等待队列头

4、等待唤醒

5、等待事件

三、轮询

1、应用程序的非阻塞函数

2、Linux 驱动下的 poll 操作函数

四、阻塞IO之等待事件唤醒

添加两个头文件

1、makefile修改

2、imx6uirq结构体

2、驱动入口添加等待队列头

编辑

3、imx6uirq_read添加等待

4、在定时器里面添加唤醒

验证

代码

驱动入口

imx6uirq_read

定时器

五、阻塞IO之队列项

代码

六、非阻塞IO之select

imx6uirq_read

构建驱动的poll操作函数

1、添加poll

2、编写imx6uirq_poll函数

编写APP

1、打开方式

2、定义

3、循环读取

代码如下

验证

七、非阻塞IO之poll

1、pollfd 结构体

2、循环读取

代码如下

select函数和poll函数区别

一、阻塞和非阻塞简介

1、IO 概念

这里的“IO”并不是学习单片机的时候所说的“GPIO”(也就是引脚)，这里的 IO 指的是 Input/Output也就是输入/输出，是应用程序对驱动设备的输入/输出操作。

2、阻塞与非阻塞

当应用程序对设备驱动进行操作的时候，如果不能获取到设备资源，那么阻塞式 IO 就会将应用程
序对应的线程挂起，直到设备资源可以获取为止；对于非阻塞 IO，应用程序对应的线程不会起，它要么一直轮询等待，直到设备资源可以使用，要么就直接放弃。

阻塞式 IO 如下图

阻塞 IO 访问图中，read 函数从设备中读取数据，当设备不可用或数据未准备好的时候就会进入到休眠态。等设备可用的时候就会从休眠态唤醒，然后从设备中读取数据返回给应用程序。

非阻塞 IO 如下图

非阻塞 IO 访问图中，应用程序使用非阻塞访问方式从设备读取数据，当设备不可用或数据未准备好的时候会立即向内核返回一个错误码，表示数据读取失败。应用程序会再次重新读取数据，这样一直往复循环，直到数据读取成功。

对于设备驱动文件的默认读取方式就是阻塞式的；如果应用程序要采用非阻塞的方式来访问驱动设备文件，open 函数打开“/dev/xxx_dev”设备文件的时候添加了参数“O_NONBLOCK”，表示以非阻塞方式打开设备，这样从设备中读取数据的时候就是非阻塞方式的了

二、等待队列

涉及到的函数或宏定义会在代码中使用到的时候再作详细解析

1、等待队列头

阻塞访问最大的好处就是当设备文件不可操作的时候进程可以进入休眠态，这样可以将CPU 资源让出来。但是，当设备文件可以操作的时候就必须唤醒进程，一般在中断函数里面完成唤醒工作。
Linux 内核提供了等待队列(wait queue)来实现阻塞进程的唤醒工作，如果要在驱动中使用等待队列，必须创建并初始化一个等待队列头，等待队列头使用结构体wait_queue_head_t 表示， wait_queue_head_t 结构体定义在文件 include/linux/wait.h 中

定义好等待队列头以后需要初始化，使用 init_waitqueue_head 函数初始化等待队列头

也可以使用宏 DECLARE_WAIT_QUEUE_HEAD 来一次性完成等待队列头的定义的初始化

2、等待队列项

等待队列头就是一个等待队列的头部，每个访问设备的进程都是一个队列项，当设备不可用的时候就要将这些进程对应的等待队列添加到等待队列项里面。结构体 wait_queue_t 表示等待队列项

使用宏 DECLARE_WAITQUEUE 定义并初始化一个等待队列项

3、将队列项添加/移除等待队列头

当设备不可访问的时候就需要将进程对应的等待队列项添加到前面创建的等待队列头中，只有添加到等待队列头中以后进程才能进入休眠态。当设备可以访问以后再将进程对应的等待队列项从等待队列头中移除即可

等待队列项添加的 API 函数：add_wait_queue

等待队列项移除的 API 函数：remove_wait_queue

4、等待唤醒

当设备可以使用的时候就要唤醒进入休眠态的进程，唤醒可以使用两个函数：

wake_up和wake_up_interruptible

wake_up 函数可以唤醒处于 TASK_INTERRUPTIBLE 和 TASK_UNINTERRUPTIBLE 状态的进程，而 wake_up_interruptible 函数只能唤醒处于 TASK_INTERRUPTIBLE 状态的进程

5、等待事件

除了主动唤醒以外，也可以设置等待队列等待某个事件，当这个事件满足以后就自动唤醒等待队列中的进程，和等待事件有关的 API 函数如表

函数	描述
wait_event(wq, condition)	等待以 wq 为等待队列头的等待队列被唤醒，前提是 condition 条件必须满足(为真)，否则一直阻塞。此函数会将进程设置为 TASK_UNINTERRUPTIBLE 状态
wait_event_timeout(wq, condition, timeout)	功能和 wait_event 类似，但是此函数可以添加超时时间，以 jiffies 为单位。此函数有返回值，如果返回 0 的话表示超时时间到，而且 condition 为假。为 1 的话表示 condition 为真，也就是条件满足了。

wait_event_interruptible(wq, condition)	与 wait_event 函数类似，但是此函数将进程设置为 TASK_INTERRUPTIBLE，就是可以被信号打断。
wait_event_interruptible_timeout(wq, condition, timeout)	与 wait_event_timeout 函数类似，此函数也将进程设置为 TASK_INTERRUPTIBLE，可以被信号打断。

三、轮询

1、应用程序的非阻塞函数

如果用户应用程序以非阻塞的方式访问设备，设备驱动程序就要提供非阻塞的处理方式，也就是轮询。 poll、 epoll 和 select 可以用于处理轮询，应用程序通过 select、 epoll 或 poll 函数来查询设备是否可以操作，如果可以操作的话就从设备读取或者向设备写入数据。当应用程序调用 select、 epoll 或 poll 函数的时候设备驱动程序中的 poll 函数就会执行，因此需要在设备驱动程序中编写 poll 函数

通过 select、 epoll 或 poll 函数一切都设置好以后应用程序就可以通过 epoll_wait 函数来等待事件的发生

2、Linux 驱动下的 poll 操作函数

当应用程序调用 select 或 poll 函数来对驱动程序进行非阻塞访问的时候，驱动程序
file_operations 操作集中的 poll 函数就会执行。所以驱动程序的编写需要提供对应的 poll 函数

需要在驱动程序的 poll 函数中调用 poll_wait 函数， poll_wait 函数不会引起阻塞，只是将应用程序添加到 poll_table 中

四、阻塞IO之等待事件唤醒

在之前的“按键输入驱动”文章有留下的伏笔，使用“top”命令查看开发板运行情况，我们所编写的程序会占用很高的cpu，这显然是不合理的，下面开始解决它

添加两个头文件

#include <linux/wait.h>
#include <linux/ide.h>

1、makefile修改

利用上一个文章的工作区，删除情况如下图左边，makefile编译目标是imx6uirq.o即可

2、imx6uirq结构体

添加等待队列头，要在驱动中使用等待队列，必须创建并初始化一个等待队列头，等待队列头使用结构体wait_queue_head_t 表示

2、驱动入口添加等待队列头

在该函数内添加等待队列头

这里用到init_waitqueue_head 函数初始化等待队列头，原型如下

void init_waitqueue_head(wait_queue_head_t *q)

参数 q 就是要初始化的等待队列头

3、imx6uirq_read添加等待

在该函数内添加等待，应用程序会调用该函数，该函数就会执行，所以就在这设置等待按键有效

这里用函数，wait_event_interruptible原型如下

void wait_event_interruptible(wq, condition)
参数 wq 就是wq 为等待队列头的等待队列

参数 condition就是事件， condition 条件满足(为真)，wq等待队列被唤醒，否则一直阻塞。

这里也可以用wait_event函数，但是wait_event函数会将进程设置为TASK_UNINTERRUPTIBLE 状态，就是不可以被信号打断，wait_event_interruptible函数将进程设置为TASK_INTERRUPTIBLE，就是可以被信号打断

简单来说，如果用wait_event_interruptible函数，运行应用程序，可以用“kill"命令”杀死应用程序，这个就是“kill”信号，而用wait_event函数，则使用“kill”也无法杀死，因为它不可以被信号打断

4、在定时器里面添加唤醒

在定时器消抖之后，再确定按键有效就唤醒进程，这里用到wake_up函数，原型如下

void wake_up(wait_queue_head_t *q)
参数 q 就是要唤醒的等待队列头
wake_up 函数可以唤醒处于TASK_INTERRUPTIBLE和TASK_UNINTERRUPTIBLE状态的进程，而 wake_up_interruptible 函数只能唤醒处于 TASK_INTERRUPTIBLE 状态的进程

验证

加载驱动之后，后台运行上章的app和本章的设备文件，再查看一下后台运行情况，就看到不会像之前那样占用过高，按下按键也会打印

查看运行的应用程序的id是81，使用kill是可以将它“杀死”的

代码

驱动入口


static int __init imx6uirq_init(void){
    int ret = 0;
    imx6uirq.major = 0;
    if(imx6uirq.major){
        imx6uirq.devid =MKDEV(imx6uirq.major,0);
        ret = register_chrdev_region(imx6uirq.devid,IMX6UIRQ_CNT,IMX6UIRQ_NAME);
        if(ret < 0){
            goto fail_devid;
        }
    }else{
        ret = alloc_chrdev_region(&imx6uirq.devid,0,IMX6UIRQ_CNT,IMX6UIRQ_NAME);
        if(ret < 0){
            goto fail_devid;
        }
        imx6uirq.major = MAJOR(imx6uirq.devid);
        imx6uirq.minor = MINOR(imx6uirq.devid);
        printk("imx6uirq major = %d, minor = %d\r\n", imx6uirq.major, imx6uirq.minor);
    }
    imx6uirq.cdev.owner = THIS_MODULE;
    cdev_init(&imx6uirq.cdev, &imx6uirq_fops);
    ret = cdev_add(&imx6uirq.cdev,imx6uirq.devid,IMX6UIRQ_CNT);
    if(ret){
        goto fail_cdevadd;
    }
    imx6uirq.class = class_create(THIS_MODULE,IMX6UIRQ_NAME);
    if(IS_ERR(imx6uirq.class)){
        ret = PTR_ERR(imx6uirq.class);
        goto fail_class;
    }
    imx6uirq.device = device_create(imx6uirq.class,NULL,imx6uirq.devid,NULL,IMX6UIRQ_NAME);
    if(IS_ERR(imx6uirq.device)){
        ret = PTR_ERR(imx6uirq.device);
        goto fail_device;
    }

    /*初始化IO*/
    ret = keyio_init(&imx6uirq);
    if(ret < 0){
        goto fail_keyinit;
    }
    /*初始化原子变量*/
    atomic_set(&imx6uirq.keyvalue,INVAKEY);
    atomic_set(&imx6uirq.releasekey,0);

    /*等待队列头*/
    init_waitqueue_head(&imx6uirq.r_wait);
    
    return 0;
fail_keyinit:
    device_destroy(imx6uirq.class,IMX6UIRQ_CNT);
fail_device:
    class_destroy(imx6uirq.class);
fail_class:
    cdev_del(&imx6uirq.cdev);
fail_cdevadd:
    unregister_chrdev_region(imx6uirq.devid,IMX6UIRQ_CNT);
fail_devid:
    return ret;
}

imx6uirq_read

static ssize_t imx6uirq_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
    int ret = 0;
    unsigned char keyvalue;
    unsigned char releasekey;
    struct imx6uirq_dev *dev = filp->private_data;

    /*等待事件*/
    /*等待按键有效*/
    wait_event_interruptible(dev->r_wait,atomic_read(&dev->releasekey));

    keyvalue = atomic_read(&dev->keyvalue);
    releasekey = atomic_read(&dev->releasekey);
    if(releasekey){/*有效按键*/
        if(keyvalue & 0x80){
            keyvalue &= ~0x80;
            ret=__copy_to_user(buf,&keyvalue,sizeof(keyvalue));
        }else{
            goto data_error;
        }
        atomic_set(&dev->releasekey,0);/*按下标志清零*/
    }else{
         goto data_error;
    }
    return ret;
data_error:
    return -EINVAL;
}

定时器

static void timer_func(unsigned long arg){
    int value = 0;
    struct imx6uirq_dev *dev = (struct imx6uirq_dev *)arg;
    value = gpio_get_value(dev->irqkey[0].gpio);
    if(value == 0){
        /*按下*/
        atomic_set(&dev->keyvalue,dev->irqkey[0].value);

    }else if(value == 1){
        /*释放*/
        atomic_set(&dev->keyvalue,0x80 | (dev->irqkey[0].value));
        atomic_set(&dev->releasekey,1);
    }
    /*唤醒进程*/
    if(atomic_read(&dev->releasekey)){
        wake_up(&dev->r_wait);
    }
}

五、阻塞IO之队列项

这个和上面的等待唤醒效果是一样的，只需要修改imx6uirq_read函数即可

66-68行，属于等待唤醒，将其屏蔽

71行，使用宏 DECLARE_WAITQUEUE 定义并初始化一个等待队列项，宏的内容如下：

DECLARE_WAITQUEUE(name, tsk)
name 就是等待队列项的名字， tsk 表示这个等待队列项属于哪个任务(进程)，一般设置为
current ，在 Linux 内核中 current 相当于一个全局变量，表示当前进程。

DECLARE_WAITQUEUE 就是给当前正在运行的进程创建并初始化了一个等待队列项wait

72行，判断按键是否按下，没按下则执行以下操作

73行，当设备不可访问的时候就需要将进程对应的等待队列项添加到前面创建的等待队列头中，只有添加到等待队列头中以后进程才能进入休眠态。这里用到add_wait_queue函数，原型如下

void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)

q：等待队列项要加入的等待队列头。wait：要加入的等待队列项。返回值：无。

74行，使用 __set_current_state() 来设置进程的状态，原型如下

__set_current_state(state_value)

state_value为要设置进程的状态

75行，任务切换，使用schedule()，它没有任何参数和返回值，它的任务是从运行队列中找到一个进程，并随后将CPU分配给这个进程，这里就是当前进程，直接调用schedule()时，如果current进程因缺乏资源也就是没有按下按键，而要立刻被阻塞，就主动调用调度程序，会把current进程插入适当的等待队列，进入休眠。如果有按键按下，那么进入休眠态的进程就会唤醒，然后接着从休眠点开始运行。

78行，判断是否有信号唤醒(比如kill)，用到signal_pending()函数，原型如下

int signal_pending(struct task_struct *p)

p一般为当前进程，也就是current

仅检查当前进程是否有信号处理(不会在这里处理信号)，返回不为0表示有信号需要处理

如果是被信号唤醒，返回-ERESTARTSYS 这个错误码，goto到下图

101-102行与82-83行一样，下面会解释

82行，经过78行判断，如果不是信号唤醒，那就是按键唤醒，设置为运行状态

83行，移除等待队列，这里用到remove_wait_queue（）函数，原型如下

void remove_wait_queue(wait_queue_head_t *q,wait_queue_t *wait)

q：要删除的等待队列项所处的等待队列头。wait：要删除的等待队列项。返回值：无

代码

static ssize_t imx6uirq_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
    int ret = 0;
    unsigned char keyvalue;
    unsigned char releasekey;
    struct imx6uirq_dev *dev = filp->private_data;
#if 0
    /*等待事件*/
    /*等待按键有效*/
    wait_event_interruptible(dev->r_wait,atomic_read(&dev->releasekey));
#endif
    /*定义一个等待队列项*/
    DECLARE_WAITQUEUE(wait, current);
    if(atomic_read(&dev->releasekey) == 0) { /* 没有按键按下 */      
        add_wait_queue(&dev->r_wait,&wait);/*将等待队列项添加到等待队列头*/
        __set_current_state(TASK_INTERRUPTIBLE);/*当前进行设置为可被打断的状态*/
        schedule();/*进行一次任务切换,切换进入睡眠*/
        
        /* 判断是否为信号引起的唤醒 */
        if(signal_pending(current)){
            ret = -ERESTARTSYS;
            goto wait_error;
        }
        __set_current_state(TASK_RUNNING); /*设置为运行状态 */
        remove_wait_queue(&dev->r_wait, &wait); /*将等待队列移除 */
    }

    keyvalue = atomic_read(&dev->keyvalue);
    releasekey = atomic_read(&dev->releasekey);
    if(releasekey){/*有效按键*/
        if(keyvalue & 0x80){
            keyvalue &= ~0x80;
            ret=__copy_to_user(buf,&keyvalue,sizeof(keyvalue));
        }else{
            goto data_error;
        }
        atomic_set(&dev->releasekey,0);/*按下标志清零*/
    }else{
         goto data_error;
    }
    return 0;
wait_error:
    __set_current_state(TASK_RUNNING);/*将当前任务设置为运行状态*/
    remove_wait_queue(&dev->r_wait,&wait);/*将对应的队列项从等待队列头删除*/
    return ret;
data_error:
    return -EINVAL;
}

因为效果和上面等待唤醒一样的，不再截图

六、非阻塞IO之select

复制上面的内容，创建新的工作区

先添加头文件#include <linux/poll.h>

imx6uirq_read

非阻塞IO也是在 imx6uirq_read函数里面添加，添加如图

67行，判断是否为非阻塞，“f_flags"是文件标志，专门标识阻塞和非阻塞，检查用户请求是否是非堵塞式的操作，“O_NONBLOCK”表示采用非阻塞的文件IO方法

68-69行，如果是非阻塞操作，判断按键是否有效，无效直接返回错误值

71-74行，如果是阻塞操作，直接按上面的阻塞io的内容处理，这里用等待唤醒方式阻塞

构建驱动的poll操作函数

当应用程序调用 select 或 poll 函数来对驱动程序进行非阻塞访问的时候，驱动程序
file_operations 操作集中的 poll 函数就会执行，主要用来返回状态信息

1、添加poll

在操作集里面添加poll

2、编写imx6uirq_poll函数

128行， poll 函数原型如下

unsigned int (*poll) (struct file *filp, struct poll_table_struct *wait)
filp：要打开的设备文件(文件描述符)。
wait：结构体 poll_table_struct 类型指针，由应用程序传递进来的。一般将此参数传递给
poll_wait 函数。
返回值:向应用程序返回设备或者资源状态

131行，设置私有数据

132行，需要在驱动程序的 poll 函数中调用 poll_wait 函数， poll_wait 函数不会引起阻塞，只是
将应用程序添加到 poll_table 中，原型如下：

void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)
参数 wait_address 是要添加到 poll_table 中的等待队列头

参数 p 就是 poll_table，就是file_operations 中 poll 函数的 wait 参数

134-137行，判断按键是否按下，如果按下就返回的资源状态，POLLIN 有数据可以读取，POLLRDNORM 等同于 POLLIN，普通数据可读

编写APP

先添加头文件#include <sys/select.h>

1、打开方式

打开文件用非阻塞方式打开

2、定义

24行，比如现在要从一个设备文件中读取数据，那么就可以定义一个 fd_set 变量，这个变量
要传递给readfds，readfds 用于监视指定描述符集的读变化，也就是监视这些文件是否可以读取，只要这些集合里面有一个文件可以读取那么 seclect 就会返回一个大于 0 的值表示文件可以读取。如果没有文件可以读取，那么就会根据 timeout 参数来判断是否超时

25行，timeout:超时时间，当我们调用 select 函数等待某些文件描述符可以设置超时时间，超时时
间使用结构体 timeval 表示，结构体定义如下

struct timeval {

long tv_sec; /* 秒*/
long tv_usec; /* 微妙*/

};

当 timeout 为 NULL 的时候就表示无限期的等待。

3、循环读取

46-47行，在24行定义好一个 fd_set 变量以后可以使用如下一些宏进行操作

void FD_ZERO(fd_set *set)
void FD_SET(int fd, fd_set *set)
FD_ZERO 用于将 fd_set 变量的所有位都清零

FD_SET 用于将 fd_set 变量的某个位置 1，也就是向 fd_set 添加一个文件描述符，参数 fd 就是要加入的文件描述符。

59-50行，构造超时时间为1秒

51，使用select函数，原型如下

int select (int nfds
                fd_set *readfds,
                fd_set *writefds,
                fd_set        *exceptfds,
                 struct timeval *timeout) 返回值： 0，表示的话就表示超时发生，但是没有任何文件描述符可以进行操作； -1，发生错误；
               其他值，可以进行操作的文件描述符个数

nfds：所要监视的这三类文件描述集合中，最大文件描述符加 1
上面24行定义的就是参数readfds，监视指定描述符集的读变化

writefds 和 readfs 类似，只是 writefs 用于监视这些文件是否可以进行写操作。 exceptfds 用于监视这些文件的异常，这里设置为NULL

上面25行定义的就是参数timeout，设置超时时间

52-68行，判断返回值，为0打印超时；为-1错误结束；其他值，使用fd_set 变量FD_ISSET
宏进行操作，原型如下

int FD_ISSET(int fd, fd_set *set)
FD_ISSET 用于测试一个文件是否属于某个集合，参数 fd 就是要判断的文件描述符

这里用来判断文件变化是不是属于readfds集合引起的，如果是就执行60-65行操作，也就是按下按键会打印值

代码如下

imx6uirq_read

static ssize_t imx6uirq_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
    int ret = 0;
    unsigned char keyvalue;
    unsigned char releasekey;
    struct imx6uirq_dev *dev = filp->private_data;

    if(filp->f_flags & O_NONBLOCK){/*非阻塞*/
        if(atomic_read(&dev->releasekey) == 0){
            return -EAGAIN;
        }
    }else {
        /*等待按键有效*/
        wait_event_interruptible(dev->r_wait,atomic_read(&dev->releasekey));
        }
    

    keyvalue = atomic_read(&dev->keyvalue);
    releasekey = atomic_read(&dev->releasekey);
    if(releasekey){/*有效按键*/
        if(keyvalue & 0x80){
            keyvalue &= ~0x80;
            ret=__copy_to_user(buf,&keyvalue,sizeof(keyvalue));
        }else{
            goto data_error;
        }
        atomic_set(&dev->releasekey,0);/*按下标志清零*/
    }else{
         goto data_error;
    }
    return 0;

data_error:
    return -EINVAL;
}

操作集

static const  struct file_operations imx6uirq_fops = {
    .owner	=   THIS_MODULE,
    .open   =   imx6uirq_open,
    .read   =   imx6uirq_read,
    .write  =   imx6uirq_write,
    .release =  imx6uirq_release,
    .poll   =   imx6uirq_poll,
};

imx6uirq_poll函数

static unsigned int imx6uirq_poll(struct file *filp, struct poll_table_struct * wait)
{
    int mask = 0;
    struct imx6uirq_dev *dev = filp->private_data;
    poll_wait(filp, &dev->r_wait,wait);
    /*是否可读*/
    if(atomic_read(&dev->releasekey)){/*按键按下，可读*/
        mask = POLLIN | POLLRDNORM ; /*返回pollin*/
        
    }

    return mask;
}

imx6uirqAPP

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


#define CLOSE_CMD _IO(0XEF ,1)  /*关闭命令*/
#define OPEN_CMD _IO(0XEF,2)    /*打开命令*/
#define SETPERIOD_CMD _IO(0XEF,3) /*设置周期*/

/*
    argc:应用程序参数个数（argv数组元素个数）
    argv:具体参数,也可以写作char **argv
    ./imx6uirqAPP <filename>    
    ./imx6uirqAPP  /dev/imx6uirq
*/
int main(int argc, char *argv[])
{
    fd_set readfds;/* 读操作文件描述符集 */
    struct timeval timeout;/* 超时结构体 */
    
    int fd,ret;
    char *filename;
    unsigned char data;
    
    /*判断命令行输入参数是否正确*/
    if(argc != 2){
        printf("error usage!\r\n");
        return -1;
    }
    /*用指针指向文件*/
    filename = argv[1];
    /*打开文件,非阻塞打开*/
    fd = open(filename , O_RDWR | O_NONBLOCK);
    if(fd < 0){
        printf("file open failed\r\n",filename);
        return -1;
    }
    /*循环读取*/
    while(1){
        FD_ZERO(&readfds);/* 清除 readfds */
        FD_SET(fd, &readfds);/* 将 fd 添加到 readfds 里面 */
        /* 构造超时时间 */
        timeout.tv_sec = 1;
        timeout.tv_usec = 0;/*1s*/
        ret  = select(fd + 1 ,&readfds , NULL,NULL,&timeout );
        switch(ret){
            case 0:/*超时*/
            printf("select timeout!\r\n");
                break;
            case -1:/*错误*/
                break;
            default:/*可读取数据*/
                if(FD_ISSET(fd,&readfds)){/* 判断是否为 fd 文件描述符 */
                    ret = read(fd,&data,sizeof(data));/* 使用 read 函数读取数据 */
                    if(ret<0){

                    }else{
                        if(data)
                        printf(" key vaule = %d\r\n",data);
                    }
                }
                break;
        }
    }
   
    /*关闭文件*/
    close(fd);

    return 0;
}

验证

可以看到，后台运行下，如果没按下按键一秒就打印一次超时，按下就会打印值，而且cpu占用也不多

七、非阻塞IO之poll

这里只需要改APP即可，添加头文件#include <poll.h>

1、pollfd 结构体

结构体原型如下

struct pollfd {        int fd;/* 文件描述符*/
                                short events;/* 请求的事件*/
                                short revents;/* 返回的事件*/

}

fd 是要监视的文件描述符，如果 fd 无效的话那么 events 监视事件也就无效，并且 revents
返回 0。

events 是要监视的事件，可监视的事件类型如; POLLIN（有数据可读）和 POLLRDNORM（等同POLLIN）等等

revents 是返回参数，也就是返回的事件，由 Linux 内核设置具体的返回事

2、循环读取

80-81行，设置文件描述符和请求的事件，也就是监视的事件POLLIN

83行，用到poll 函数，用来监控事件的发生，原型如下

int poll(struct pollfd *fds,
nfds_t nfds,
int timeout)

可以看到，这里的fds就是上面30行定义的

nfds： poll 函数要监视的文件描述符数量，这里就监控事件POLLIN，所以为1

timeout：超时时间，单位为 ms，这里设置500ms

返回值：返回 revents 域中不为 0 的 pollfd 结构体个数，也就是发生事件或错误的文件描述符数量； 0，超时； -1，发生错误，并且设置 errno 为错误类型。

84-100行，根据返回值进行具体操作，和上面的select函数的差不多一样

验证

效果也是和上面select函数的一样

代码如下

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/select.h>
#include <poll.h>


#define CLOSE_CMD _IO(0XEF ,1)  /*关闭命令*/
#define OPEN_CMD _IO(0XEF,2)    /*打开命令*/
#define SETPERIOD_CMD _IO(0XEF,3) /*设置周期*/

/*
    argc:应用程序参数个数（argv数组元素个数）
    argv:具体参数,也可以写作char **argv
    ./imx6uirqAPP <filename>    
    ./imx6uirqAPP  /dev/imx6uirq
*/
int main(int argc, char *argv[])
{
#if 0
    fd_set readfds;/* 读操作文件描述符集 */
    struct timeval timeout;/* 超时结构体 */
  #endif
    
    struct pollfd fds;/*要监视的文件描述符集合以及要监视的事件*/

    int fd,ret;
    char *filename;
    unsigned char data;
    
    /*判断命令行输入参数是否正确*/
    if(argc != 2){
        printf("error usage!\r\n");
        return -1;
    }
    /*用指针指向文件*/
    filename = argv[1];
    /*打开文件,非阻塞打开*/
    fd = open(filename , O_RDWR | O_NONBLOCK);
    if(fd < 0){
        printf("file open failed\r\n",filename);
        return -1;
    }

   /*循环读取*/
    while(1){
        fds.fd = fd;
        fds.events = POLLIN;

        ret  = poll(&fds ,1, 500);/*超时时间500ms*/
        if(ret == 0){/*超时*/
            printf("select timeout!\r\n");
        }else if (ret < 0)/*错误*/
        {
            
        }else{
            if(fds.revents & POLLIN){/*可读取*/
                ret = read(fd,&data,sizeof(data));/* 使用 read 函数读取数据 */
                    if(ret<0){

                    }else{
                        if(data)
                        printf(" key vaule = %d\r\n",data);
                    }
            }
        }
    }
    /*关闭文件*/
    close(fd);

    return 0;
}