非阻塞IO是“应用程序”对“驱动设备”进行操作，若不能获取到设备资源，则非阻塞IO应用程序的线程不会被“挂起”，即线程不进入休眠，而是一直“轮询”，直到获取到设备资源为止，或者直接放弃。
非阻塞IO应用举例：
1、添加“EXTI3.c”
#include "EXTI3.h"
#include <linux/gpio.h>
//使能gpio_request(),gpio_free(),gpio_direction_input(),
//使能gpio_direction_output(),gpio_get_value(),gpio_set_value()
#include <linux/of_gpio.h>
//使能of_gpio_named_count(),of_gpio_count(),of_get_named_gpio()
#include <linux/delay.h>
//Linux内核中用到的延时函数
//使能ndelay()，udelay()，mdelay()
#include <linux/of_irq.h>
//使能irq_of_parse_and_map()
#include <linux/interrupt.h>
//request_irq(),free_irq(),enable_irq(),disable_irq(),disable_irq_nosync()
struct Button_dev strButton;
int Get_gpio_Button_num(void);
int Button_gpio_request(void);
void Button_free(void);
int Read_Button(void);
static irqreturn_t key_interrupt_fun(int irq, void *dev_id)
{
atomic_set(&strButton.button_irq_status, 1);
/*设置原子变量值strButton.button_irq_status.counter=1*/
//wake_up_interruptible(&strButton.read_wait); /* 唤醒 */
//应用程序按照固定时间轮询,则该语句可以屏蔽，否则要打开
return IRQ_HANDLED;
}
int Get_gpio_Button_num(void)
{
int ret = 0;
const char *str;
strButton.button_irq_status = (atomic_t)ATOMIC_INIT(0);
/*初始化原子变量*/
atomic_set(&strButton.button_irq_status, 0);
/*设置原子变量初始值strButton.button_irq_status.counter=0*/
init_waitqueue_head(&strButton.read_wait);
/* 初始化等待队列头 */
strButton.keyvalue=0;
/* 设置Button所使用的GPIO */
/* 1、获取设备节点：strButton */
strButton.nd = of_find_node_by_path("/key0");
//path="/key0，使用“全路径的节点名“在“stm32mp157d-atk.dts“中查找节点“key0”
//返回值:返回找到的节点，如果为NULL，表示查找失败。
if(strButton.nd == NULL) {
printk("key0 device node not find!\r\n");
return -EINVAL;
}
/* 2.读取status属性 */
ret = of_property_read_string(strButton.nd, "status", &str);
//在key0节点中，status = "okay";
//指定的设备节点strButton.nd
//proname="status"，给定要读取的属性名字
//out_string=str:返回读取到的属性值
//返回值:0，读取成功，负值，读取失败。
if(ret < 0) return -EINVAL;
if(strcmp(str, "okay")) return -EINVAL;
//strcmp(s1,s2),当s1<s2时，返回值为负数
//strcmp(s1,s2),当s1>2时，返回值为正数
//strcmp(s1,s2),当s1=s2时，返回值为0
/* 3、获取compatible属性值并进行匹配 */
ret = of_property_read_string(strButton.nd, "compatible", &str);
//在key0节点中，compatible = "zgq,key";
//指定的设备节点strButton.nd
//proname="compatible"，给定要读取的属性名字
//out_string=str:返回读取到的属性值
//返回值:0，读取成功，负值，读取失败。
if(ret < 0) {
printk("key0 node: Failed to get compatible property\n");
return -EINVAL;
}
if (strcmp(str, "zgq,key")) {
printk("key0 node: Compatible match failed\n");
return -EINVAL;
}
/* 4、 根据设备树中的"key-gpio"属性，得到key0所使用的key0编号 */
strButton.button_gpio_number = of_get_named_gpio(strButton.nd, "key-gpio", 0);
//在key0节点中，key-gpio = <&gpiog 3 GPIO_ACTIVE_LOW>
//np=strButton.nd,指定的“设备节点”
//propname="key-gpio"，给定要读取的属性名字
//Index=0,给定的GPIO索引为0
//返回值：正值，获取到的GPIO编号；负值，失败。
if(strButton.button_gpio_number < 0) {
printk("can't get key-gpio");
return -EINVAL;
}
/* 5 、获取GPIO对应的中断号 */
strButton.irq_num = irq_of_parse_and_map(strButton.nd, 0);
//dev=strButton.nd：为设备节点;
//Index=0：索引号，intemrupts属性可能包含多条中断信息，通过index指定要获取的信息；
//返回值：中断号；
if(!strButton.irq_num){
return -EINVAL;
}
printk("key-gpio num = %d\r\n", strButton.button_gpio_number);
//打印结果为：“key-gpio num = 99“
//因为GPIO编号是从0开始的，GPIOG端口的序号是6，每个端口有16个IO口，因此GPIOI0的编号为6*16 + 3 = 99
return 0;
}
int Button_gpio_request(void)
{
int ret = 0;
unsigned long irq_flags;
/* 5.向gpio子系统申请使用“gpio编号” */
ret = gpio_request(strButton.button_gpio_number, "Button0");
//gpio=strButton.button_gpio_number，指定要申请的“gpio编号”
//label="Button"，给这个gpio引脚设置个名字为"Button"
//返回值：0，申请“gpio编号”成功;其他值，申请“gpio编号”失败；
if (ret) {
printk(KERN_ERR "Button: Failed to request key0\n");
return ret;
}
/* 6、设置PG3为输入模式*/
ret = gpio_direction_input(strButton.button_gpio_number);
//gpio=strButton.button_gpio_number,指定的“gpio编号”
if(ret < 0) {
printk("can't set gpio!\r\n");
}
/* 获取设备树中指定的中断触发类型 */
irq_flags = irq_get_trigger_type(strButton.irq_num);
//strButton.irq_num为中断号
if ( irq_flags==IRQF_TRIGGER_NONE )
irq_flags = IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING;
/*申请中断*/
ret = request_irq(strButton.irq_num, key_interrupt_fun, irq_flags, "Key0_IRQ", NULL);
//irq=strButton.irq_num：要申请中断的中断号；
//handler=key_interrupt_fun：中断处理函数，当中断发生以后就会执行此中断处理函数；
//fags=irq_flags：中断标志；可以在文件“include/linux/interrupt.h”里面查看所有的中断标志；
//name="Key0_IRQ"：中断名字，设置以后可以在“/proc/interrupts”文件中看到对应的中断名字；
//dev=NULL：如果将flags设置为IRQF_SHARED的话，dev用来区分不同的中断。
//一般情况下将dev设置为“设备结构体”，dev会传递给中断处理函数irg_handler_t的第二个参数。
//返回值：0表示中断申请成功，如果返回“-EBUSY”的话表示中断已经被申请过了, 其他负值，表示中断申请失败。
if (ret) {
printk(KERN_ERR "Button: Failed to request irq\n");
return ret;
}
return 0;
}
//函数功能：释放Button的gpio
void Button_free(void)
{
free_irq(strButton.irq_num, NULL); /* 释放中断 */
gpio_free(strButton.button_gpio_number);/* 释放IO */
}
//读取按键的值
int Read_Button(void)
{
u8 ch;
int status;
if(atomic_read(&strButton.button_irq_status) ==0)
{
return -EAGAIN;//无按钮按下
}
ch=10;
while(ch)//消抖
{
mdelay(20);//延时20毫秒消抖
if(gpio_get_value(strButton.button_gpio_number) == 0) ch=10;
ch--;
}
ch=0;
if(strButton.keyvalue) ch=1;
if(ch)//关灯
{
strButton.keyvalue=KEY_OFF;//准备中断返回值
printk("Button: off\r\n");
}
else//开灯
{
strButton.keyvalue=KEY_ON;//准备中断返回值
printk("Button: on\r\n");
}
status=strButton.keyvalue;//发送中断返回值
//atomic_set(&strButton.button_irq_status, 0);
/*原子变量初始值strButton.button_irq_status.counter=0, 状态重置 */
return status;
}
2、添加“EXTI3.h”
#ifndef __EXTI3_H
#define __EXTI3_H
#include <linux/types.h>
/*
数据类型重命名
使能bool,u8,u16,u32,u64, uint8_t, uint16_t, uint32_t, uint64_t
使能s8,s16,s32,s64,int8_t,int16_t,int32_t,int64_t
*/
#include <linux/of.h> //使能device_node结构
#include <linux/wait.h> //使能wait_queue_head_t结构
#define KEY_ON 1 /* 按键按下 */
#define KEY_OFF 0 /* 按键松开 */
struct Button_dev{
struct device_node *nd; /*设备节点*/
int button_gpio_number; /*Button所使用的GPIO编号*/
int irq_num; /* 中断号 */
atomic_t button_irq_status; /*原子变量*/
wait_queue_head_t read_wait; /* 读等待队列头 */
int keyvalue;
};
extern struct Button_dev strButton;
extern int Get_gpio_Button_num(void);
extern int Button_gpio_request(void);
extern void Button_free(void);
extern int Read_Button(void);
#endif3、添加“EXTI3_drv.c”
#include "EXTI3_drv.h"
#include "EXTI3.h"
#include <linux/types.h>
//数据类型重命名
//使能bool,u8,u16,u32,u64, uint8_t, uint16_t, uint32_t, uint64_t
//使能s8,s16,s32,s64,int8_t,int16_t,int32_t,int64_t
#include <linux/ide.h>
//使能copy_from_user(),copy_to_user()
#include <linux/module.h>
//使能EXTI3Driver_init(),EXTI3Driver_exit()
#include <linux/gpio.h>
//使能gpio_request(),gpio_free(),gpio_direction_input(),
//gpio_direction_output(),gpio_get_value(),gpio_set_value()
#include <linux/spinlock.h>
//使能DEFINE_SPINLOCK()，spin_lock_init(),spin_lock(),spin_trylock(),spin_is_locked()
//spin_lock_irq(),spin_unlock_irq(),spin_lock_irqsave(),spin_unlock_irqrestore()
#include <linux/delay.h>
//Linux内核中用到的延时函数
//使能ndelay()，udelay()，mdelay()
#include <linux/poll.h>
//使能poll(),poll_wait()
#define EXTI3Driver_CNT 1 //定义设备数量为1
#define EXTI3Driver_NAME "EXTI3Driver" //定义设备的名字
struct EXTI3Driver_dev strEXTI3Driver;
/* 打开设备 */
static int EXTI3Driver_open(struct inode *inode, struct file *filp)
{
/*通过判断原子变量的值来检查EXTI3有没有被别的应用使用*/
if (!atomic_dec_and_test(&strEXTI3Driver.lock))
{
//当strEXTI3Driver.lock.counter=1时，atomic_dec_and_test()返回1
//从strEXTI3Driver.lock.counter减1，如果结果为0就返回1，否则返回0;
atomic_inc(&strEXTI3Driver.lock);/*小于0的话就加1,使其原子变量等于0*/
return -EBUSY; /* EXTI3被使用，返回忙*/
}
filp->private_data = &strEXTI3Driver; /*设置私有数据*/
printk("EXTI3Driver_open!\r\n");
return 0;
}
/* 从设备读取数据，保存到首地址为buf的数据块中，长度为cnt个字节 */
//file结构指针变量flip表示要打开的设备文件
//buf表示用户数据块的首地址
//cnt表示用户数据的长度，单位为字节
//loff_t结构指针变量offt表示“相对于文件首地址的偏移”
static ssize_t EXTI3Driver_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
int ret;
int value;
value = Read_Button();
if( value == -EAGAIN ) ret = value;
else
{
ret = copy_to_user(buf, &value, sizeof(value));
//将value拷贝到buf[]中
atomic_set(&strButton.button_irq_status, 0);
/*原子变量初始值strButton.button_irq_status.counter=0, 状态重置 */
}
return ret;
}
/*
poll函数，用于处理非阻塞访问
filp: 要打开的设备文件(文件描述符)
wait: 等待列表(poll_table)
返回值: 设备或者资源状态，
*/
static unsigned int EXTI3Driver_poll(struct file *filp, struct poll_table_struct *wait)
{
unsigned int mask = 0;
poll_wait(filp, &strButton.read_wait, wait);
//poll_wait()函数不会引起阻塞，只是将“应用程序”添加到poll_table中
//wait_address=&strButton.read_wait是要添加到poll_table中的等待队列头;
//p=wait是poll_table型指针，就是file_operations中poll()函数的wait参数；
if( atomic_read(&strButton.button_irq_status) !=0 ) // 按键按下或松开动作发生
mask = POLLIN | POLLRDNORM; // 返回PLLIN
return mask;
}
/* 向设备写数据，将数据块首地址为buf的数据，长度为cnt个字节，发送给用户 */
//file结构指针变量flip表示要打开的设备文件
//buf表示用户数据块的首地址
//cnt表示用户数据的长度，单位为字节
//loff_t结构指针变量offt表示“相对于文件首地址的偏移”
static ssize_t EXTI3Driver_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
return 0;
}
/* 关闭/释放设备 */
static int EXTI3Driver_release(struct inode *inode, struct file *filp)
{
struct EXTI3Driver_dev *dev = filp->private_data;
atomic_inc(&dev->lock);
/*关闭驱动文件的时候释放原子变量，便于其它线程使用*/
printk("EXTI3Driver_release!\r\n");
return 0;
}
/*声明file_operations结构变量MyCharDevice_fops*/
/*它是指向设备的操作函数集合变量*/
const struct file_operations EXTI3Driver_fops = {
.owner = THIS_MODULE,
.open = EXTI3Driver_open,
.read = EXTI3Driver_read,
.write = EXTI3Driver_write,
.release = EXTI3Driver_release,
.poll = EXTI3Driver_poll,
};
/*驱动入口函数 */
static int __init EXTI3Driver_init(void)
{
int ret;
strEXTI3Driver.lock = (atomic_t)ATOMIC_INIT(0);
/*初始化原子变量*/
atomic_set(&strEXTI3Driver.lock, 1);
/*原子变量初始值strEXTI3Driver.lock.counter=1*/
ret=Get_gpio_Button_num();//读引脚编号
if(ret < 0) return ret;
/* 1、申请“gpio编号”*/
ret=Button_gpio_request();//申请“gpio编号”
if(ret < 0) return ret;//向gpio子系统申请使用“gpio编号” 失败
/*2、申请设备号*/
strEXTI3Driver.major=0;
if(strEXTI3Driver.major)/*如果指定了主设备号*/
{
strEXTI3Driver.devid = MKDEV(strEXTI3Driver.major, 0);
//输入参数strEXTI3Driver.major为“主设备号”
//输入参数0为“次设备号”，大部分驱动次设备号都选择0
//将strEXTI3Driver.major左移20位，再与0相或，就得到“Linux设备号”
ret=register_chrdev_region( strEXTI3Driver.devid,\
EXTI3Driver_CNT, \
EXTI3Driver_NAME );
//strEXTI3Driver.devid表示起始设备号
//EXTI3Driver_CNT表示次设备号的数量
//EXTI3Driver_NAME表示设备名
if(ret < 0)
goto free_gpio;
}
else
{ /* 没有定义设备号 */
ret=alloc_chrdev_region( &strEXTI3Driver.devid,\
0, \
EXTI3Driver_CNT,\
EXTI3Driver_NAME);
/* 申请设备号 */
//strEXTI3Driver.devid：保存申请到的设备号
//0：次设备号的起始地址
//EXTI3Driver_CNT：要申请的次设备号数量；
//EXTI3Driver_NAME：表示“设备名字”
if(ret < 0)
goto free_gpio;
strEXTI3Driver.major = MAJOR(strEXTI3Driver.devid);
/* 获取分配号的主设备号 */
//输入参数strEXTI3Driver.devid为“Linux设备号”
//将strEXTI3Driver.devid右移20位得到“主设备号”
strEXTI3Driver.minor = MINOR(strEXTI3Driver.devid);
/* 获取分配号的次设备号 */
//输入参数strEXTI3Driver.devid为“Linux设备号”
//将strEXTI3Driver.devid与0xFFFFF相与后得到“次设备号”
}
/*3、注册字符设备*/
strEXTI3Driver.cdev.owner = THIS_MODULE;
//使用THIS_MODULE将owner指针指向当前这个模块
cdev_init(&strEXTI3Driver.cdev,&EXTI3Driver_fops);
//注册字符设备，初始化“字符设备结构变量strEXTI3Driver.cdev”
//strEXTI3Driver.cdev是等待初始化的结构体变量
//EXTI3Driver_fops就是字符设备文件操作函数集合
/*4、添加字符设备*/
ret=cdev_add(&strEXTI3Driver.cdev,strEXTI3Driver.devid,EXTI3Driver_CNT);
//添加字符设备
/*&strEXTI3Driver.cdev表示指向要添加的字符设备，即字符设备结构strEXTI3Driver.cdev变量*/
//strEXTI3Driver.devid表示设备号
//EXTI3Driver_CNT表示需要添加的设备数量
if(ret < 0 ) //添加字符设备失败
goto del_register;
printk("dev id major = %d,minor = %d\r\n", strEXTI3Driver.major, strEXTI3Driver.minor);
printk("EXTI3Driver_init is ok!!!\r\n");
/*5、自动创建设备节点 */
strEXTI3Driver.class =class_create(THIS_MODULE, EXTI3Driver_NAME);
if (IS_ERR(strEXTI3Driver.class)){
goto del_cdev;
}
/*6、创建设备 */
strEXTI3Driver.device = device_create(strEXTI3Driver.class, NULL, strEXTI3Driver.devid, NULL, EXTI3Driver_NAME);
//创建设备
//设备要创建在strEXTI3Driver.class类下面
//NULL表示没有父设备
//strEXTI3Driver.devid是设备号;
//参数drvdata=NULL，设备没有使用数据
//EXTI3Driver_NAME是设备名字
//如果设置fmt=EXTI3Driver_NAME 的话，就会生成/dev/EXTI3Driver_NAME设备文件。
//返回值就是创建好的设备。
if (IS_ERR(strEXTI3Driver.device)){
goto destroy_class;
}
return 0;
destroy_class:
class_destroy(strEXTI3Driver.class);
//删除类
//strEXTI3Driver.class就是要删除的类
del_cdev:
cdev_del(&strEXTI3Driver.cdev);
//删除字符设备
//&strEXTI3Driver.cdev表示指向需要删除的字符设备，即字符设备结构strEXTI3Driver.cdev变量
del_register:
unregister_chrdev_region(strEXTI3Driver.devid, EXTI3Driver_CNT);
/* 释放设备号 */
//strEXTI3Driver.devid：需要释放的起始设备号
//EXTI3Driver_CNT：需要释放的次设备号数量；
free_gpio://申请设备号失败
/*释放gpio编号*/
Button_free();
return -EIO;
}
/*驱动出口函数 */
static void __exit EXTI3Driver_exit(void)
{
/*1、删除字符设备*/
cdev_del(&strEXTI3Driver.cdev);
/*删除字符设备*/
/*&strEXTI3Driver.cdev表示指向需要删除的字符设备，即字符设备结构&strEXTI3Driver.cdev变量*/
/*2、 释放设备号 */
unregister_chrdev_region(strEXTI3Driver.devid, EXTI3Driver_CNT);
/*释放设备号 */
//strEXTI3Driver.devid：需要释放的起始设备号
//EXTI3Driver_CNT：需要释放的次设备号数;
/*3、 删除设备 */
device_destroy(strEXTI3Driver.class, strEXTI3Driver.devid);
//删除创建的设备
//strEXTI3Driver.class是要删除的设备所处的类
//strEXTI3Driver.devid是要删除的设备号
/*4、删除类*/
class_destroy(strEXTI3Driver.class);
//删除类
//strEXTI3Driver.class就是要删除的类
/*5、释放gpio编号*/
Button_free();
}
module_init(EXTI3Driver_init);
//指定EXTI3Driver_init()为驱动入口函数
module_exit(EXTI3Driver_exit);
//指定EXTI3Driver_exit()为驱动出口函数
MODULE_AUTHOR("Zhanggong");//添加作者名字
MODULE_LICENSE("GPL");//LICENSE采用“GPL协议”
MODULE_INFO(intree,"Y");
//去除显示“loading out-of-tree module taints kernel.”
4、添加“EXTI3_drv.h”
#ifndef __EXTI3_DRIVER_H
#define __EXTI3_DRIVER_H
#include <linux/types.h>
/*
数据类型重命名
使能bool,u8,u16,u32,u64, uint8_t, uint16_t, uint32_t, uint64_t
使能s8,s16,s32,s64,int8_t,int16_t,int32_t,int64_t
*/
#include <linux/cdev.h> //使能cdev结构
#include <linux/cdev.h> //使能class结构和device结构
struct EXTI3Driver_dev{
dev_t devid; /*声明32位变量devid用来给保存设备号*/
int major; /*主设备号*/
int minor; /*次设备号*/
struct cdev cdev; /*字符设备结构变量cdev */
struct class *class; /*类*/
struct device *device; /*设备*/
atomic_t lock; /*原子变量*/
};
extern struct EXTI3Driver_dev strEXTI3Driver;
#endif
5、添加“LED.c”
略，见“Linux第87步_阻塞IO实验”
6、添加“LED.h”
略，见“Linux第87步_阻塞IO实验”
7、添加“LED_drv.c”
略，见“Linux第87步_阻塞IO实验”
8、添加“LED_drv.h”
略，见“Linux第87步_阻塞IO实验”
9、添加“ButtonLED_APP.c”
应用程序按照100ms轮询一次驱动程序
#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"
#include <unistd.h>
//Linux系统编程下用到的延时函数
//使能usleep(),sleep()
//#include <delay.h>
//Linux内核中用到的延时函数
//使能ndelay()，udelay()，mdelay()
#include <poll.h>
//FD_ZERO(),FD_SET(),select(),FD_CLR(),FD_ISSET()
#define LED_OFF 0 /* 关灯 */
#define LED_ON 1 /* 开灯 */
/*
参数argc: argv[]数组元素个数
参数argv[]:是一个指针数组
返回值: 0 成功;其他 失败
./ButtonLED_APP /dev/EXTI3Driver /dev/LEDDriver
*/
int main(int argc, char *argv[])
{
fd_set readfds;
int ret;
int fd_button;
int fd_led;
int retvalue;
int keyvalue;
int status;
struct timeval timeout; /* 超时结构体 */
/* 1. 判断参数 */
if(argc != 3)
{
printf("Error Usage!\r\n");
return -1;
}
//argv[]是指向输入参数“./ButtonLED_APP /dev/EXTI3Driver /dev/LEDDriver”
/* 2. 打开文件 */
fd_button = open(argv[1], O_RDONLY | O_NONBLOCK);
//O_RDONLY表示只读模式；
//O_NONBLOCK表示如果路径名指向FIFO/块文字/字符文件，则把文件的打开和后继I/O设置为非阻塞；
//如果打开“/dev/EXTI3Driver”文件成功，则fd_button为“文件描述符”,argv[1]="/dev/EXTI3Driver"
if(fd_button < 0)
{
printf("Can't open file %s\r\n", argv[1]);
return -1;
}
fd_led = open(argv[2], O_RDWR);
//如果打开“/dev/LEDDriver”文件成功，则fd_led为“文件描述符”,argv[2]=“/dev/LEDDriver”
if(fd_led < 0)
{
printf("Can't open file %s\r\n", argv[2]);
return -1;
}
FD_ZERO(&readfds);
//将fd_set型变量readfds的所有位都清零，即将所有的文件描述符从readfds中删除；
FD_SET(fd_button, &readfds);
//将fd_set型变量readfds的某个位置1，即向readfds添加一个文件描述符；
//fd_button是要加入的文件描述符
/* 构造超时时间 */
timeout.tv_sec = 0;
timeout.tv_usec = 100000; /*设置超时时间为100ms */
/* 3. 读文件 */
while(1)
{
ret = select(fd_button + 1, &readfds, NULL, NULL, &timeout);
//select()用于处理轮询，这里设置100ms轮询一次
//当应用程序调用poll()、epoll()或select()函数时，设备驱动程序中的poll()函数就会被执行
//nfds=fd_button + 1，所要监视的这“三类文件描述集合”中，“最大文件描述符”加1；
/*readfds用于监视指定描述符集的“读变化”，监视这些文件是否可以读取；
若可以读取，则返回大于0的值；若没有文件可以读取，则根据timeout判断是否超时；*/
/*writefds=NULL用于监视指定描述符集的“写变化”，监视这些文件是否可以写入；
若文件可以执行写操作，则返回大于0的值；若没有文件可以写入，则根据timeout判断是否超时；*/
//exceptfds=NULL，用于监视文件的异常
//timeout=NULL，超时时间，表示无限期等待
switch (ret)
{
case 0: /* 超时 */
// printf("timeout!\r\n");
/* 构造超时时间 */
timeout.tv_sec = 0;
timeout.tv_usec = 100000; /*设置超时时间为100ms */
FD_ZERO(&readfds);
//将fd_set型变量readfds的所有位都清零，即将所有的文件描述符从readfds中删除；
FD_SET(fd_button, &readfds);
//将fd_set型变量readfds的某个位置1，即向readfds添加一个文件描述符；
//fd_button是要加入的文件描述符
break;
case -1: /* 错误 */
printf("error!\r\n");
break;
default:
if(FD_ISSET(fd_button, &readfds))
{//测试一个文件是否属于某个集合,参数readfds就是要判断的文件描述符
read(fd_button, &keyvalue, sizeof(keyvalue));
if (keyvalue == LED_ON)
{
//如果按键按下
printf("KEY0 Press, value = %#X\r\n", keyvalue);/* 按下 */
status = LED_ON;
write(fd_led, &status, 1);
}
else if (keyvalue == LED_OFF)
{
//如果按键松开
printf("KEY0 Press, value = %#X\r\n", keyvalue);/* 按下 */
status = LED_OFF;
write(fd_led, &status, 1);
//file结构指针变量fd_led表示要打开的设备文件
//buf=&status表示用户数据块的首地址
//cnt=1表示用户数据的长度，单位为字节
}
}
break;
}
}
/* 关闭设备 */
retvalue = close(fd_button);
//fd_button表示要关闭的“文件描述符”
//返回值等于0表示关闭成功
//返回值小于0表示关闭失败
if(retvalue < 0)
{
printf("Can't close file %s\r\n", argv[1]);
return -1;
}
retvalue = close(fd_led);
//fd_led表示要关闭的“文件描述符”
//返回值等于0表示关闭成功
//返回值小于0表示关闭失败
if(retvalue < 0)
{
printf("Can't close file %s\r\n", argv[2]);
return -1;
}
return 0;
}应用程序无限期等待驱动唤醒
#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"
#include <unistd.h>
//Linux系统编程下用到的延时函数
//使能usleep(),sleep()
//#include <delay.h>
//Linux内核中用到的延时函数
//使能ndelay()，udelay()，mdelay()
#include <poll.h>
//FD_ZERO(),FD_SET(),select(),FD_CLR(),FD_ISSET()
#define LED_OFF 0 /* 关灯 */
#define LED_ON 1 /* 开灯 */
/*
参数argc: argv[]数组元素个数
参数argv[]:是一个指针数组
返回值: 0 成功;其他 失败
./ButtonLED_APP /dev/EXTI3Driver /dev/LEDDriver
*/
int main(int argc, char *argv[])
{
fd_set readfds;
int ret;
int fd_button;
int fd_led;
int retvalue;
int keyvalue;
int status;
/* 1. 判断参数 */
if(argc != 3)
{
printf("Error Usage!\r\n");
return -1;
}
//argv[]是指向输入参数“./ButtonLED_APP /dev/EXTI3Driver /dev/LEDDriver”
/* 2. 打开文件 */
fd_button = open(argv[1], O_RDONLY | O_NONBLOCK);
//O_RDONLY表示只读模式；
//O_NONBLOCK表示如果路径名指向FIFO/块文字/字符文件，则把文件的打开和后继I/O设置为非阻塞；
//如果打开“/dev/EXTI3Driver”文件成功，则fd_button为“文件描述符”,argv[1]="/dev/EXTI3Driver"
if(fd_button < 0)
{
printf("Can't open file %s\r\n", argv[1]);
return -1;
}
fd_led = open(argv[2], O_RDWR);
//如果打开“/dev/LEDDriver”文件成功，则fd_led为“文件描述符”,argv[2]=“/dev/LEDDriver”
if(fd_led < 0)
{
printf("Can't open file %s\r\n", argv[2]);
return -1;
}
FD_ZERO(&readfds);
//将fd_set型变量readfds的所有位都清零，即将所有的文件描述符从readfds中删除；
FD_SET(fd_button, &readfds);
//将fd_set型变量readfds的某个位置1，即向readfds添加一个文件描述符；
//fd_button是要加入的文件描述符
/* 3. 读文件 */
while(1)
{
ret = select(fd_button + 1, &readfds, NULL, NULL, NULL);
//nfds=fd_button + 1，所要监视的这“三类文件描述集合”中，“最大文件描述符”加1；
/*readfds用于监视指定描述符集的“读变化”，监视这些文件是否可以读取；
若可以读取，则返回大于0的值；若没有文件可以读取，则根据timeout判断是否超时；*/
/*writefds=NULL用于监视指定描述符集的“写变化”，监视这些文件是否可以写入；
若文件可以执行写操作，则返回大于0的值；若没有文件可以写入，则根据timeout判断是否超时；*/
//exceptfds=NULL，用于监视文件的异常
//timeout=NULL，超时时间，表示无限期等待
switch (ret)
{
case 0: /* 超时 */
break;
case -1: /* 错误 */
break;
default:
if(FD_ISSET(fd_button, &readfds))
{//测试一个文件是否属于某个集合,参数readfds就是要判断的文件描述符
read(fd_button, &keyvalue, sizeof(keyvalue));
if (keyvalue == LED_ON)
{
//如果按键按下
printf("KEY0 Press, value = %#X\r\n", keyvalue);/* 按下 */
status = LED_ON;
write(fd_led, &status, 1);
}
else if (keyvalue == LED_OFF)
{
//如果按键松开
printf("KEY0 Press, value = %#X\r\n", keyvalue);/* 按下 */
status = LED_OFF;
write(fd_led, &status, 1);
//file结构指针变量fd_led表示要打开的设备文件
//buf=&status表示用户数据块的首地址
//cnt=1表示用户数据的长度，单位为字节
}
}
break;
}
}
/* 关闭设备 */
retvalue = close(fd_button);
//fd_button表示要关闭的“文件描述符”
//返回值等于0表示关闭成功
//返回值小于0表示关闭失败
if(retvalue < 0)
{
printf("Can't close file %s\r\n", argv[1]);
return -1;
}
retvalue = close(fd_led);
//fd_led表示要关闭的“文件描述符”
//返回值等于0表示关闭成功
//返回值小于0表示关闭失败
if(retvalue < 0)
{
printf("Can't close file %s\r\n", argv[2]);
return -1;
}
return 0;
}
10、添加“Makefile”
略，见“Linux第87步_阻塞IO实验”
11、添加“c_cpp_properties.json”
{
"configurations": [
{
"name": "Linux",
"includePath": [
"${workspaceFolder}/**",
"/home/zgq/linux/atk-mp1/linux/my_linux/linux-5.4.31",
"/home/zgq/linux/Linux_Drivers/IO_Unblock",
"/home/zgq/linux/atk-mp1/linux/my_linux/linux-5.4.31/arch/arm/include",
"/home/zgq/linux/atk-mp1/linux/my_linux/linux-5.4.31/include",
"/home/zgq/linux/atk-mp1/linux/my_linux/linux-5.4.31/arch/arm/include/generated"
],
"defines": [],
"compilerPath": "/usr/bin/gcc",
"cStandard": "gnu11",
"cppStandard": "gnu++14",
"intelliSenseMode": "gcc-x64"
}
],
"version": 4
}12、编译
输入“make clean回车”
输入“make drv回车”
输入“make app回车”
输入“make install回车”
输入“ls /home/zgq/linux/nfs/rootfs/lib/modules/5.4.31/ -l回车”查看是存在“ButtonLED_APP,MyButton.ko和MyLED.ko”
13、测试
启动开发板，从网络下载程序
输入“root”
输入“cd /lib/modules/5.4.31/回车”
切换到“/lib/modules/5.4.31/”目录
注意：“lib/modules/5.4.31/”在虚拟机中是位于“/home/zgq/linux/nfs/rootfs/”目录下，但在开发板中，却是位于根目录中。
输入“ls -l”查看“ButtonLED_APP,MyButton.ko和MyLED.ko”是否存在
输入“depmod”,驱动在第一次执行时，需要运行“depmod”
输入“modprobe MyButton.ko”，加载“MyButton.ko”模块
输入“modprobe MyLED.ko”，加载“MyLED.ko”模块
输入“lsmod”查看有哪些驱动在工作
输入“cat /proc/interrupts”，查看中断是否注册；
输入“ls /dev/EXTI3Driver -l回车”，发现节点文件“/dev/EXTI3Driver”
输入“ls /dev/LEDDriver -l回车”，发现节点文件“/dev/LEDDriver”
输入“./ButtonLED_APP /dev/EXTI3Driver /dev/LEDDriver回车”
按下按钮，等待串口输出“KEY0 Press, value = 0X1”，同时LED会亮。
14、测试结果
