搜索
bottom↓
回复: 0

《领航者ZYNQ之嵌入式Linux开发指南_V2.0》第三十五章 异步实验

[复制链接]

出0入234汤圆

发表于 2022-1-22 16:12:13 | 显示全部楼层 |阅读模式
1)实验平台:正点原子领航者V2 ZYNQ开发板
2)  章节摘自【正点原子】《领航者ZYNQ之嵌入式Linux开发指南_V2.0》
3)购买链接:https://detail.tmall.com/item.htm?id=609032204975
4)全套实验源码+手册+视频下载地址:http://www.openedv.com/thread-329957-1-1.html
5)正点原子官方B站:https://space.bilibili.com/394620890
6)正点原子FPGA技术交流QQ群:90562473
1.png

2.jpg


3.png


第三十五章 异步通知实验

       在前面使用阻塞或者非阻塞的方式来读取驱动中按键值都是应用程序主动读取的,对于非阻塞方式来说还需要应用程序通过poll函数不断的轮询。最好的方式就是驱动程序能主动向应用程序发出通知,报告自己可以访问,然后应用程序在从驱动程序中读取或写入数据,类似于我们在SDK例程中讲解的中断。Linux提供了异步通知这个机制来完成此功能,本章我们就来学习一下异步通知以及如何在驱动中添加异步通知相关处理代码。

       1.1异步通知
1.1.1异步通知简介

       我们首先来回顾一下“中断”,中断是处理器提供的一种异步机制,我们配置好中断以后就可以让处理器去处理其他的事情了,当中断发生以后会触发我们事先设置好的中断服务函数,在中断服务函数中做具体的处理。比如我们在《领航者ZYNQ之嵌入式开发指南》第四章中讲解的GPIO按键中断实验,我们不再循环读取GPIO数据获取按键状态,而是采用中断方式,采用中断方式以后处理器就不需要时刻的去查看按键有没有被按下,因为按键按下以后会自动触发中断。同样的,Linux应用程序可以通过阻塞或者非阻塞这两种方式来访问驱动设备,通过阻塞方式访问的话应用程序会处于休眠态,等待驱动设备可以使用,非阻塞方式的话会通过poll函数来不断的轮询,查看驱动设备文件是否可以使用。这两种方式都需要应用程序主动的去查询设备的使用情况,如果能提供一种类似中断的机制,当驱动程序可以访问的时候主动告诉应用程序那就最好了。
      “信号”为此应运而生,信号类似于我们硬件上使用的“中断”,只不过信号是软件层次上的。算是在软件层次上对中断的一种模拟,驱动可以通过主动向应用程序发送信号的方式来报告自己可以访问了,应用程序获取到信号以后就可以从驱动设备中读取或者写入数据了。整个过程就相当于应用程序收到了驱动发送过来了的一个中断,然后应用程序去响应这个中断,在整个处理过程中应用程序并没有去查询驱动设备是否可以访问,一切都是由驱动设备自己告诉给应用程序的。
       阻塞、非阻塞、异步通知,这三种是针对不同的场合提出来的不同的解决方法,没有优劣之分,在实际的工作和学习中,根据自己的实际需求选择合适的处理方法即可。
       异步通知的核心就是信号,在include/uapi/asm-generic/signal.h头文件中定义了Linux所支持的信号,这些信号如下所示:
  1. 示例代码 35.1.1 Linux信号
  2. 34 #define SIGHUP            1                  /* 终端挂起或控制进程终止 */
  3. 35 #define SIGINT                        2                  /* 终端中断(Ctrl+C组合键) */
  4. 36 #define SIGQUIT                3                  /* 终端退出(Ctrl+\组合键) */
  5. 37 #define SIGILL                4                  /* 非法指令 */
  6. 38 #define SIGTRAP            5                  /* debug使用,有断点指令产生 */
  7. 39 #define SIGABRT             6                  /* 由abort(3)发出的退出指令 */
  8. 40 #define SIGIOT                6                  /* IOT指令 */
  9. 41 #define SIGBUS              7                  /* 总线错误 */
  10. 42 #define SIGFPE               8                  /* 浮点运算错误 */
  11. 43 #define SIGKILL             9                  /* 杀死、终止进程 */
  12. 44 #define SIGUSR1                10          /* 用户自定义信号1 */
  13. 45 #define SIGSEGV                  11          /* 段违例(无效的内存段) */
  14. 46 #define SIGUSR2           12          /* 用户自定义信号2 */
  15. 47 #define SIGPIPE            13          /* 向非读管道写入数据 */
  16. 48 #define SIGALRM           14          /* 闹钟 */
  17. 49 #define SIGTERM                  15                  /* 软件终止 */
  18. 50 #define SIGSTKFLT          16          /* 栈异常 */
  19. 51 #define SIGCHLD           17          /* 子进程结束 */
  20. 52 #define SIGCONT            18          /* 进程继续 */
  21. 53 #define SIGSTOP           19          /* 停止进程的执行,只是暂停 */
  22. 54 #define SIGTSTP                   20          /* 停止进程的运行(Ctrl+Z组合键) */
  23. 55 #define SIGTTIN            21          /* 后台进程需要从终端读取数据 */
  24. 56 #define SIGTTOU            22          /* 后台进程需要向终端写数据 */
  25. 57 #define SIGURG             23          /* 有"紧急"数据 */
  26. 58 #define SIGXCPU            24          /* 超过CPU资源限制 */
  27. 59 #define SIGXFSZ            25          /* 文件大小超额 */
  28. 60 #define SIGVTALRM        26          /* 虚拟时钟信号 */
  29. 61 #define SIGPROF            27                  /* 时钟信号描述 */
  30. 62 #define SIGWINCH          28                /* 窗口大小改变 */
  31. 63 #define SIGIO                     29                 /* 可以进行输入/输出操作 */
  32. 64 #define SIGPOLL           SIGIO   
  33. 65 /* #define SIGLOS    29 */
  34. 66 #define SIGPWR            30                 /* 断点重启 */
  35. 67 #define SIGSYS              31          /* 非法的系统调用  */
  36. 68 #define  SIGUNUSED        31          /* 未使用信号 */
复制代码
       在示例代码 35.1.1的这些信号中,除了SIGKILL(9)和SIGSTOP(19)这两个信号不能被忽略外,其他的信号都可以忽略。这些信号就相当于中断号,不同的中断号代表了不同的中断,不同的中断所做的处理不同,因此,驱动程序可以通过向应用程序发送不同的信号来实现不同的功能。
       我们使用中断的时候需要设置中断处理函数,同样的,如果要在应用程序中使用信号,那么就必须设置信号所使用的信号处理函数,在应用程序中使用signal函数来设置指定信号的处理函数,signal函数原型如下所示:
  1. sighandler_t signal(int signum, sighandler_t handler)
复制代码
       函数参数和返回值含义如下:
       signum:要设置处理函数的信号。
       handler:信号的处理函数。
       返回值:设置成功的话返回信号的前一个处理函数,设置失败的话返回SIG_ERR。
       信号处理函数原型如下所示:
  1. typedef void (*sighandler_t)(int)
复制代码
       我们前面讲解的使用“kill -9 PID”杀死指定进程的方法就是向指定的进程(PID)发送SIGKILL这个信号。当按下键盘上的CTRL+C组合键以后会向当前正在占用终端的应用程序发出SIGINT信号,SIGINT信号默认的动作是关闭当前应用程序。这里我们修改一下SIGINT信号的默认处理函数,当按下CTRL+C组合键以后先在终端上打印出“SIGINT signal!”这行字符串,然后再关闭当前应用程序。在Ubuntu中新建一个signaltest.c文件,然后输入如下所示内容:
  1. 示例代码 35.1.2 信号测试
  2.   1 #include <stdlib.h>
  3.   2 #include <stdio.h>
  4.   3 #include <signal.h>
  5.   4
  6.   5 void sigint_handler(int num)
  7.   6 {
  8.   7     printf("\r\nSIGINT signal!\r\n");
  9.   8     exit(0);
  10.   9 }
  11. 10
  12. 11 int main(void)
  13. 12 {
  14. 13     signal(SIGINT, sigint_handler);
  15. 14     while(1);
  16. 15     return 0;
  17. 16 }
复制代码
       在示例代码 35.1.2中我们设置SIGINT信号的处理函数为sigint_handler,当按下CTRL+C向signaltest发送SIGINT信号以后sigint_handler函数就会执行,此函数先输出一行“SIGINT signal!”字符串,然后调用exit函数关闭signaltest应用程序。
       使用如下命令编译signaltest.c:
  1. gcc signaltest.c -o signaltest
复制代码
       在Ubuntu中执行“./signaltest”命令运行signaltest这个应用程序,然后按下键盘上的CTRL+C组合键,结果如所示:
第三十五章 异步通知实验3913.png

图 35.1.1 signaltest软件运行结果

       从图 35.1.1可以看出,当按下CTRL+C组合键以后sigint_handler这个SIGINT信号处理函数执行了,并且输出了“SIGINT signal!”这行字符串。
1.1.2驱动中的信号处理
      1、fasync_struct结构体
       首先我们需要在驱动程序中定义一个fasync_struct结构体指针变量,该结构体定义在内核源码目录include/linux/fs.h头文件中,fasync_struct结构体内容如下:
  1. 示例代码 35.1.3 fasync_struct发结构体
  2. 1247 struct fasync_struct {
  3. 1248    spinlock_t                fa_lock;
  4. 1249    int                                magic;
  5. 1250    int                                fa_fd;
  6. 1251    struct fasync_struct *fa_next; /* singly linked list */
  7. 1252    struct file                        *fa_file;
  8. 1253    struct rcu_head        fa_rcu;
  9. 1254 };
复制代码
       一般将fasync_struct结构体指针变量定义到设备结构体中,比如在上一章节驱动实验key_dev结构体中添加一个fasync_struct结构体指针变量,结果如下所示:
  1. 示例代码 35.1.4 在设备结构体中添加fasync_struct类型指针变量
  2. 41 /* 按键设备结构体 */
  3. 42 struct key_dev {
  4. 43     dev_t devid;                                        /* 设备号 */
  5. 44     struct cdev cdev;                                /* cdev结构体 */
  6. 45     struct class *class;                                /* 类 */
  7. 46     struct device *device;                        /* 设备 */
  8. 47     int key_gpio;                                        /* GPIO编号 */
  9. 48     int irq_num;                                        /* 中断号 */
  10. 49     struct timer_list timer;                        /* 定时器 */
  11. 50     wait_queue_head_t r_wait;                /* 读等待队列头 */
  12. 51     struct fasync_struct *async_queue;        /* 异步相关结构体 */
  13. 52 };
复制代码
       第51行就是在key_dev中添加了一个fasync_struct结构体指针变量。
       2、fasync函数
       如果要使用异步通知,需要在设备驱动中实现file_operations操作集中的fasync函数,此函数格式如下所示:
  1. int (*fasync) (int fd, struct file *filp, int on)
复制代码
       fasync函数里面一般通过调用fasync_helper函数来初始化前面定义的fasync_struct结构体指针,fasync_helper函数原型如下:
  1. int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp)
复制代码
       fasync_helper函数的前三个参数就是fasync函数的那三个参数,第四个参数就是要初始化的fasync_struct结构体指针变量。当应用程序通过“fcntl(fd, F_SETFL, flags | FASYNC)”改变fasync标记的时候,驱动程序file_operations操作集中的fasync函数就会执行。
       驱动程序中的fasync函数参考示例如下:
  1. 示例代码 35.1.5 驱动中fasync函数参考示例
  2. 1 struct xxx_dev {
  3. 2     ......
  4. 3     struct fasync_struct *async_queue;   /* 异步相关结构体 */
  5. 4  };
  6. 5
  7. 6 static int xxx_fasync(int fd, struct file *filp, int on)
  8. 7 {
  9. 8     struct xxx_dev *dev = (xxx_dev)filp->private_data;
  10. 9
  11. 10     if (fasync_helper(fd, filp, on, &dev->async_queue) < 0)
  12. 11         return -EIO;
  13. 12     return 0;
  14. 13 }
  15. 14
  16. 15 static struct file_operations xxx_ops = {
  17. 16     ......
  18. 17     .fasync = xxx_fasync,
  19. 18     ......
  20. 19 };
复制代码
       在关闭驱动文件的时候需要在file_operations操作集中的release函数中释放fasync_struct,fasync_struct的释放函数同样为fasync_helper,release函数参数参考实例如下:
  1. 示例代码 35.1.6 释放fasync_struct参考示例
  2. 1 static int xxx_release(struct inode *inode, struct file *filp)
  3. 2 {
  4. 3     return xxx_fasync(-1, filp, 0); /* 删除异步通知 */
  5. 4 }
  6. 5
  7. 6 static struct file_operations xxx_ops = {
  8. 7     ......
  9. 8     .release = xxx_release,
  10. 9 };
复制代码
       第3行通过调用示例代码53.1.2.3中的xxx_fasync函数来完成fasync_struct的释放工作,但是,其最终还是通过fasync_helper函数完成释放工作。
       1、kill_fasync函数
       当设备可以访问的时候,驱动程序需要向应用程序发出信号,相当于产生“中断”。kill_fasync函数负责发送指定的信号,kill_fasync函数原型如下所示:
  1. void kill_fasync(struct fasync_struct **fp, int sig, int band)
复制代码
       函数参数和返回值含义如下:
       fp:要操作的fasync_struct。
       sig:要发送的信号。
       band:可读时设置为POLL_IN,可写时设置为POLL_OUT。
       返回值:无。
1.1.3应用程序对异步通知的处理
       应用程序对异步通知的处理包括以下三步:
       1、注册信号处理函数
       应用程序根据驱动程序所使用的信号来设置信号的处理函数,应用程序使用signal函数来设置信号的处理函数。前面已经详细的讲过了,这里就不细讲了。
       2、将本应用程序的进程号告诉给内核
       使用fcntl(fd, F_SETOWN, getpid())将本应用程序的进程号告诉给内核。
       3、开启异步通知
       使用如下两行程序开启异步通知:
  1. flags = fcntl(fd, F_GETFL);                        /* 获取当前的进程状态 */
  2. fcntl(fd, F_SETFL, flags | FASYNC);        /* 开启当前进程异步通知功能 */
复制代码
       重点就是通过fcntl函数设置进程状态为FASYNC,经过这一步,驱动程序中的fasync函数就会执行。
       1.2硬件原理图分析
       本章实验硬件原理图参考31.2小节即可。
       1.3实验程序编写
       本实验对应的例程路径为:领航者ZYNQ开发板光盘资料(A盘)\4_SourceCode\3_Embedded_Linux\Linux驱动例程\16_asyncnoti。
       本章实验我们在上一章实验“15_noblockio”的基础上完成,在其中加入异步通知相关内容即可,当按键按下以后驱动程序向应用程序发送SIGIO信号,应用程序获取到SIGIO信号以后读取按键数据并打印出相应的字符串信息。
1.3.1修改设备树文件
       因为是在实验“15_noblockio”的基础上完成的,因此不需要修改设备树。
1.3.2程序编写
       在drivers目录下新建名为“16_asyncnoti”的文件夹,将“15_noblockio”实验中的noblockio.c拷贝到16_asyncnoti文件夹中,并重命名为asyncnoti.c。接下来我们就修改asyncnoti.c这个文件,在其中添加异步通知关的代码,完成以后的asyncnoti.c内容如下所示(因为是在上一章实验的noblockio.c文件的基础上修改的,因为了减少篇幅,下面的代码有省略):
  1. 示例代码 35.3.1 asyncnoti.c文件代码段
  2.   1 /***************************************************************
  3.   2  Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
  4.   3  文件名    : asyncnoti.c
  5.   4  作者      : 邓涛
  6.   5  版本      : V1.0
  7.   6  描述      : 异步通知驱动实验
  8.   7  其他      : 无
  9.   8  论坛      : <a href="www.openedv.com" target="_blank">www.openedv.com</a>
  10.   9  日志      : 初版V1.0 2019/1/30 邓涛创建
  11. 10  ***************************************************************/
  12. 11
  13. 12 #include <linux/types.h>
  14. 13 #include <linux/kernel.h>
  15. 14 #include <linux/delay.h>
  16. 15 #include <linux/ide.h>
  17. 16 #include <linux/init.h>
  18. 17 #include <linux/module.h>
  19. 18 #include <linux/errno.h>
  20. 19 #include <linux/gpio.h>
  21. 20 #include <asm/mach/map.h>
  22. 21 #include <asm/uaccess.h>
  23. 22 #include <asm/io.h>
  24. 23 #include <linux/cdev.h>
  25. 24 #include <linux/of.h>
  26. 25 #include <linux/of_address.h>
  27. 26 #include <linux/of_gpio.h>
  28. 27 #include <linux/of_irq.h>
  29. 28 #include <linux/irq.h>
  30. 29 #include <linux/poll.h>
  31. 30 #include <linux/fcntl.h>
  32. 31
  33. 32 #define KEY_CNT                1                /* 设备号个数 */
  34. 33 #define KEY_NAME        "key"        /* 名字 */
  35. 34
  36. 35 /* 定义按键状态 */
  37. 36 enum key_status {
  38. 37     KEY_PRESS = 0,                // 按键按下
  39. 38     KEY_RELEASE,                // 按键松开
  40. 39     KEY_KEEP,                        // 按键状态保持
  41. 40 };
  42. 41
  43. 42 /* 按键设备结构体 */
  44. 43 struct key_dev {
  45. 44     dev_t devid;                                                /* 设备号 */
  46. 45     struct cdev cdev;                                        /* cdev结构体 */
  47. 46     struct class *class;                                        /* 类 */
  48. 47     struct device *device;                                /* 设备 */
  49. 48     int key_gpio;                                                /* GPIO编号 */
  50. 49     int irq_num;                                                /* 中断号 */
  51. 50     struct timer_list timer;                                /* 定时器 */
  52. 51     wait_queue_head_t r_wait;                        /* 读等待队列头 */
  53. 52     struct fasync_struct *async_queue;        /* fasync_struct结构体 */
  54. 53 };
  55. ......
  56. 134 /*
  57. 135  * @description                : fasync函数,用于处理异步通知
  58. 136  * @param – fd                : 文件描述符
  59. 137  * @param – filp                : 要打开的设备文件(文件描述符)
  60. 138  * @param – on                : 模式
  61. 139  * @return                        : 负数表示函数执行失败
  62. 140  */
  63. 141 static int key_fasync(int fd, struct file *filp, int on)
  64. 142 {
  65. 143     return fasync_helper(fd, filp, on, &key.async_queue);
  66. 144 }
  67. 145
  68. 146 /*
  69. 147  * @description                : 关闭/释放设备
  70. 148  * @param – filp                : 要关闭的设备文件(文件描述符)
  71. 149  * @return                        : 0 成功;其他 失败
  72. 150  */
  73. 151 static int key_release(struct inode *inode, struct file *filp)
  74. 152 {
  75. 153     return key_fasync(-1, filp, 0);
  76. 154 }
  77. 155
  78. 156 static void key_timer_function(unsigned long arg)
  79. 157 {
  80. 158     static int last_val = 1;
  81. 159     int current_val;
  82. 160
  83. 161     /* 读取按键值并判断按键当前状态 */
  84. 162     current_val = gpio_get_value(key.key_gpio);
  85. 163     if (0 == current_val && last_val) {                        // 按下
  86. 164         atomic_set(&status, KEY_PRESS);
  87. 165         wake_up_interruptible(&key.r_wait);
  88. 166         if(key.async_queue)
  89. 167             kill_fasync(&key.async_queue, SIGIO, POLL_IN);
  90. 168     }
  91. 169     else if (1 == current_val && !last_val) {                // 松开
  92. 170         atomic_set(&status, KEY_RELEASE);
  93. 171         wake_up_interruptible(&key.r_wait);
  94. 172         if(key.async_queue)
  95. 173             kill_fasync(&key.async_queue, SIGIO, POLL_IN);
  96. 174     }
  97. 175     else
  98. 176         atomic_set(&status, KEY_KEEP);                        // 状态保持
  99. 177
  100. 178     last_val = current_val;
  101. 179 }
  102. ......
  103. 261 /* 设备操作函数 */
  104. 262 static struct file_operations key_fops = {
  105. 263     .owner                = THIS_MODULE,
  106. 264     .open                = key_open,
  107. 265     .read                        = key_read,
  108. 266     .write                = key_write,
  109. 267     .release                = key_release,
  110. 268     .poll                        = key_poll,
  111. 269     .fasync                = key_fasync,
  112. 270 };
  113. ......
  114. 366 /* 驱动模块入口和出口函数注册 */
  115. 367 module_init(mykey_init);
  116. 368 module_exit(mykey_exit);
  117. 369
  118. 370 MODULE_AUTHOR("DengTao <<a href="mailto:773904075@qq.com">773904075@qq.com</a>>");
  119. 371 MODULE_DESCRIPTION("Gpio Key Interrupt Driver");
  120. 372 MODULE_LICENSE("GPL");
复制代码
       第30行,添加fcntl.h头文件,因为要用到相关的API函数。
       第52行,在设备结构体key_dev中添加fasync_struct指针变量。
       第141~144行,设备操作函数集file_operations结构体中的fasync函数key_fasync,该函数中直接调用fasync_helper函数进行相关处理。
       第153行,在key_release函数中也调用key_fasync函数释放fasync_struct指针变量。
       第156~175行,在key_timer_function函数中,当按键按下或松开动作发生时调用kill_fasync函数向应用程序发送SIGIO信号,通知应用程序按键数据可以进行读取了。
       第269行,将key_fasync函数绑定到key_fops变量的fasync函数指针中。
1.3.3编写测试APP
       测试APP要实现的内容很简单,设置SIGIO信号的处理函数为sigio_signal_func,当驱动程序向应用程序发送SIGIO信号以后sigio_signal_func函数就会执行。sigio_signal_func函数内容很简单,就是通过read函数读取按键状态数据并打印信息。在16_asyncnoti目录下新建名为asyncKeyApp.c的文件,然后输入如下所示内容:
  1. 示例代码 35.3.2 asyncKeyApp.c文件代码段
  2.   1 /***************************************************************
  3.   2  Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
  4.   3  文件名                 : asyncKeyApp.c
  5.   4  作者                   : 邓涛
  6.   5  版本                   : V1.0
  7.   6  描述                   : 异步通知测试程序
  8.   7  其他                   : 无
  9.   8  使用方法               : ./asyncKeyApp /dev/key
  10.   9  论坛                   : <a href="www.openedv.com" target="_blank">www.openedv.com</a>
  11. 10  日志                   : 初版V1.0 2019/1/30 邓涛创建
  12. 11  ***************************************************************/
  13. 12
  14. 13 #include <stdio.h>
  15. 14 #include <unistd.h>
  16. 15 #include <sys/types.h>
  17. 16 #include <sys/stat.h>
  18. 17 #include <fcntl.h>
  19. 18 #include <stdlib.h>
  20. 19 #include <string.h>
  21. 20 #include <signal.h>
  22. 21
  23. 22 static int fd;
  24. 23
  25. 24 /*
  26. 25  * SIGIO信号处理函数
  27. 26  * @param – signum                : 信号值
  28. 27  * @return                                : 无
  29. 28  */
  30. 29 static void sigio_signal_func(int signum)
  31. 30 {
  32. 31     unsigned int key_val = 0;
  33. 32
  34. 33     read(fd, &key_val, sizeof(unsigned int));
  35. 34     if (0 == key_val)
  36. 35         printf("Key Press\n");
  37. 36     else if (1 == key_val)
  38. 37         printf("Key Release\n");
  39. 38 }
  40. 39
  41. 40
  42. 41 /*
  43. 42  * @description                : main主程序
  44. 43  * @param – argc                : argv数组元素个数
  45. 44  * @param – argv                : 具体参数
  46. 45  * @return                        : 0 成功;其他 失败
  47. 46  */
  48. 47 int main(int argc, char *argv[])
  49. 48 {
  50. 49     int flags = 0;
  51. 50
  52. 51     /* 判断传参个数是否正确 */
  53. 52     if(2 != argc) {
  54. 53         printf("Usage:\n"
  55. 54                "\t./asyncKeyApp /dev/key\n"
  56. 55               );
  57. 56         return -1;
  58. 57     }
  59. 58
  60. 59     /* 打开设备 */
  61. 60     fd = open(argv[1], O_RDONLY | O_NONBLOCK);
  62. 61     if(0 > fd) {
  63. 62         printf("ERROR: %s file open failed!\n", argv[1]);
  64. 63         return -1;
  65. 64     }
  66. 65
  67. 66     /* 设置信号SIGIO的处理函数 */
  68. 67     signal(SIGIO, sigio_signal_func);
  69. 68     fcntl(fd, F_SETOWN, getpid());                        // 将当前进程的进程号告诉给内核
  70. 69     flags = fcntl(fd, F_GETFD);                                // 获取当前的进程状态
  71. 70     fcntl(fd, F_SETFL, flags | FASYNC);                // 设置进程启用异步通知功能
  72. 71
  73. 72
  74. 73     /* 循环轮训读取按键数据 */
  75. 74     for ( ; ; ) {
  76. 75
  77. 76         sleep(2);
  78. 77     }
  79. 78
  80. 79     /* 关闭设备 */
  81. 80     close(fd);
  82. 81     return 0;
  83. 82 }
复制代码
       第29~38行,sigio_signal_func函数,SIGIO信号的处理函数,当驱动程序有效按键按下以后就会发送SIGIO信号,此函数就会执行。此函数通过read函数读取按键状态数据,然后通过printf函数打印在终端上。
       第67行,通过signal函数设置SIGIO信号的处理函数为sigio_signal_func。
       第68~70行,设置当前进程的状态,开启异步通知的功能。
       第74~77行,for循环,等待信号产生。
       1.4运行测试
1.4.1编译驱动程序和测试APP
      1、编译驱动程序
       编写Makefile文件,将15_noblockio实验目录下的Makefile文件拷贝本实验目录下,打开Makefile文件,将obj-m变量的值改为asyncnoti.o,Makefile内容如下所示:
  1. 示例代码 35.4.1 Makefile文件
  2.   1 KERN_DIR := /home/zynq/linux/kernel/linux-xlnx-xilinx-v2018.3
  3.   2
  4.   3 obj-m := asyncnoti.o
  5.   4
  6.   5 all:
  7.   6         make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- -C $(KERN_DIR) M=`pwd` modules
  8.   7
  9.   8 clean:
  10.   9         make -C $(KERN_DIR) M=`pwd` clean
复制代码
       第3行,设置obj-m变量的值为asyncnoti.o。
       文件修改完成之后保存退出,输入如下命令编译出驱动模块文件:
  1. make
复制代码
       编译成功以后就会生成一个名为“asyncnoti.ko”的驱动模块文件,如下所示:
第三十五章 异步通知实验14903.png

图 35.4.1 编译驱动模块

       2、编译测试APP
       输入如下命令编译测试asyncnotiApp.c这个测试程序:
  1. arm-linux-gnueabihf-gcc asyncKeyApp.c -o asyncKeyApp
复制代码
       编译成功以后就会生成asyncKeyApp这个应用程序。
1.4.2运行测试
       将上一小节编译出来asyncnoti.ko和asyncKeyApp这两个文件拷贝到开发板根文件系统/lib/modules/4.14.0-xilinx目录中,重启开发板,进入到目录/lib/modules/4.14.0-xilinx中,输入如下命令加载asyncnoti.ko驱动模块:
  1. depmod                                //第一次加载驱动的时候需要运行此命令
  2. modprobe asyncnoti.ko        //加载驱动
复制代码
      驱动加载成功以后使用如下命令来测试中断:
  1. ./asyncKeyApp /dev/key
复制代码
      按下开发板上的PS_KEY0键,当按键按下或按键松开时终端就会打印出相应的信息,如图 35.4.2所示:
第三十五章 异步通知实验15417.png

图 35.4.2 应用程序测试结果

       从图 35.4.2可以看出,捕获到SIGIO信号,并且按键值获取成功,大家可以自行以后台模式运行asyncKeyApp,使用top命令查看一下这个应用程序的CPU使用率,这里就不给大家演示了。
       如果要卸载驱动的话输入如下命令即可:
  1. rmmod asyncnoti.ko
复制代码

回帖提示: 反政府言论将被立即封锁ID 在按“提交”前,请自问一下:我这样表达会给举报吗,会给自己惹麻烦吗? 另外:尽量不要使用Mark、顶等没有意义的回复。不得大量使用大字体和彩色字。
您需要登录后才可以回帖 登录 | 注册

本版积分规则

手机版|Archiver|amobbs.com 阿莫电子论坛 ( 公安交互式论坛备案:44190002001997 粤ICP备09047143号 )

GMT+8, 2022-7-7 03:35

© Since 2004 www.amobbs.com, 原www.ourdev.cn, 原www.ouravr.com

快速回复 返回顶部 返回列表