• 驱动开发5 阻塞IO实例、IO多路复用

    1 阻塞IO

    进程1

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. int main(int argc, char const *argv[])
    11. {
    12.     char buf[128] = {0};
    13.     int a,b;
    14.     int fd = open("/dev/myled0",O_RDWR);
    15.     if(fd < 0)
    16.     {
    17.         printf("打开设备文件失败\n");
    18.         exit(-1);
    19.     }
    20.     while(1)
    21.     {
    22.         memset(buf,0,sizeof(buf));
    23.         read(fd,buf,sizeof(buf));
    24.         printf("buf:%s\n",buf);
    25.     }
    26. }

    进程2

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. int main(int argc, char const *argv[])
    11. {
    12.     char buf[128] = "hello world";
    13.     int a,b;
    14.     int fd = open("/dev/myled0",O_RDWR);
    15.     if(fd < 0)
    16.     {
    17.         printf("打开设备文件失败\n");
    18.         exit(-1);
    19.     }
    20.     write(fd,buf,sizeof(buf));
    21. }

    驱动程序

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. int major;
    10. char kbuf[128] = {0};
    11.  
    12. unsigned int *vir_rcc;
    13. struct class *cls;
    14. struct device *dev;
    15. //定义等待队列
    16. wait_queue_head_t wq_head;
    17. unsigned int condition=0;
    18. int mycdev_open(struct inode *inode, struct file *file)
    19. {
    20.     printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    21.     return 0;
    22. }
    23.  
    24. ssize_t mycdev_read(struct file *file, char *ubuf, size_t size,loff_t *lof)
    25. {
    26.     printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    27.     if(file->f_flags&O_NONBLOCK)//用户程序以非阻塞读写数据
    28.     {}
    29.     else{
    30.         wait_event_interruptible(wq_head,condition);//判断condition的值，为假则进程休眠
    31.     }
    32.     //将获取到的硬件数据拷贝到用户
    33.     int ret = copy_to_user(ubuf,kbuf,size);
    34.     if(ret)
    35.     {
    36.         printk("copy_to_user filed\n");
    37.         return -EIO;
    38.     }
    39.     condition = 0; //表示下一次数据没有准备就绪
    40.     return 0;
    41. }
    42. ssize_t mycdev_write(struct file *file, const char *ubuf, size_t size,loff_t *lof)
    43. {
    44.     printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    45.     int ret;
    46.     ret = copy_from_user(kbuf,ubuf,size);
    47.     if (ret)
    48.     {
    49.         printk("copy_from_user filed\n");
    50.         return -EIO;
    51.     }
    52.     condition = 1;//表示硬件数据就绪
    53.     wake_up_interruptible(&wq_head);//唤醒休眠的进程
    54.     return 0;
    55. }
    56. int mycdev_close(struct inode *inode, struct file *file)
    57. {
    58.     printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    59.     return 0;
    60. }
    61.  
    62. //定义操作方法结构体变量并赋值
    63. struct file_operations fops={
    64.  
    65.     .open = mycdev_open,
    66.     .read = mycdev_read,
    67.     .write = mycdev_write,
    68.     .release = mycdev_close,
    69. };
    70. static int __init mycdev_init(void)
    71. {
    72.     //初始化等待队列
    73.     init_waitqueue_head(&wq_head);
    74.     //字符设备驱动
    75.     major = register_chrdev(0,"mychrdev",&fops);
    76.     if(major < 0)
    77.     {
    78.         printk("字符设备驱动注册失败\n");
    79.         return major;
    80.     }
    81.     printk("字符设备驱动注册成功:major=%d\n",major);
    82.  
    83.     //向上提交目录 class_create
    84.     cls = class_create(THIS_MODULE,"mychrdev");
    85.     if(IS_ERR(cls))
    86.     {
    87.         printk("向上提交目录失败\n");
    88.         return -PTR_ERR(cls);
    89.     }
    90.     printk("向上提交目录成功\n");
    91.  
    92.     //向上提交设备节点信息 device_create
    93.     int i;
    94.     for(i=0;i<3;i++)
    95.     {
    96.         dev = device_create(cls,NULL,MKDEV(major,i),NULL,"myled%d",i);
    97.         if(IS_ERR(dev))
    98.         {
    99.             printk("向上提交设备节点失败\n");
    100.             return -PTR_ERR(dev);
    101.         }
    102.     }
    103.     printk("向上提交设备节点信息成功\n");
    104.     return 0;
    105. }
    106. static void __exit mycdev_exit(void)
    107. {
    108.     //1.销毁设备节点信息
    109.     int i;
    110.     for(i=0;i<3;i++)
    111.     {
    112.         device_destroy(cls,MKDEV(major,i));
    113.     }
    114.     //2.销毁目录
    115.     class_destroy(cls);
    116.     //3.注销字符设备驱动
    117.     unregister_chrdev(major,"mychrdev");
    118. }
    119. module_init(mycdev_init);
    120. module_exit(mycdev_exit);
    121. MODULE_LICENSE("GPL");

    Makefile

    1. modname ?= demo
    2. arch ?= arm
    3. ifeq ($(arch),arm)  #通过命令行传过来的架构决定怎么编译
    4. #KERBELDIR保存开发板内核源码路径
    5. KERNELDIR := /home/ubuntu/FSMP1A/linux-stm32mp-5.10.61-stm32mp-r2-r0/linux-5.10.61
    6. else
    7. #保存UBUNTU内核源码路径
    8. KERNELDIR := /lib/modules/$(shell uname -r)/build
    9. endif
    10.  
    11. #PWD保存当前内核模块的路径
    12. PWD := $(shell pwd)
    13. all:
    14. #make modules是模块化编译命令
    15. #make -C $(KERNLEDIR) 执行make之前先切换到KERNELDIR对应的路径
    16. #M=$(PWD)表示进行模块化编译的路径是PWD保存的路径
    17. 	make -C $(KERNELDIR) M=$(PWD) modules
    18. clean:
    19. #编译清除
    20. 	make -C $(KERNELDIR) M=$(PWD) clean
    21. #将obj-m保存的文件单独链接为内核模块
    22. obj-m :=  $(modname).o

    效果演示

    2 IO多路复用

    驱动程序

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. int major;
    11. char kbuf[128] = {0};
    12.  
    13. unsigned int *vir_rcc;
    14. struct class *cls;
    15. struct device *dev;
    16. //定义等待队列
    17. wait_queue_head_t wq_head;
    18. unsigned int condition=0;
    19. int mycdev_open(struct inode *inode, struct file *file)
    20. {
    21.     printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    22.     return 0;
    23. }
    24.  
    25. ssize_t mycdev_read(struct file *file, char *ubuf, size_t size,loff_t *lof)
    26. {
    27.     printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    28.     if(file->f_flags&O_NONBLOCK)//用户程序以非阻塞读写数据
    29.     {}
    30.     else{
    31.         // wait_event_interruptible(wq_head,condition);//判断condition的值，为假则进程休眠
    32.     }
    33.     //将获取到的硬件数据拷贝到用户
    34.     int ret = copy_to_user(ubuf,kbuf,size);
    35.     if(ret)
    36.     {
    37.         printk("copy_to_user filed\n");
    38.         return -EIO;
    39.     }
    40.     condition = 0; //表示下一次数据没有准备就绪
    41.     return 0;
    42. }
    43.  
    44. __poll_t mycdev_poll(struct file *file, struct  poll_table_struct *wait)
    45. {
    46.     __poll_t mask = 0;
    47.     // 向上提交等待队列队头
    48.     poll_wait(file, &wq_head, wait);
    49.     // 根据数据是否就绪给定一个合适的返回值
    50.     if (condition)
    51.         mask = POLLIN;
    52.     return mask;
    53. }
    54. ssize_t mycdev_write(struct file *file, const char *ubuf, size_t size,loff_t *lof)
    55. {
    56.     printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    57.     int ret = copy_from_user(kbuf,ubuf,size);
    58.     if (ret)
    59.     {
    60.         printk("copy_from_user filed\n");
    61.         return -EIO;
    62.     }
    63.     condition = 1;//表示硬件数据就绪
    64.     wake_up_interruptible(&wq_head);//唤醒休眠的进程
    65.     return 0;
    66. }
    67. int mycdev_close(struct inode *inode, struct file *file)
    68. {
    69.     printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    70.     return 0;
    71. }
    72.  
    73. //定义操作方法结构体变量并赋值
    74. struct file_operations fops={
    75.     .open = mycdev_open,
    76.     .read = mycdev_read,
    77.     .write = mycdev_write,
    78.     .poll = mycdev_poll,
    79.     .release = mycdev_close,
    80. };
    81.  
    82. static int __init mycdev_init(void)
    83. {
    84.     //初始化等待队列
    85.     init_waitqueue_head(&wq_head);
    86.     //字符设备驱动
    87.     major = register_chrdev(0,"mychrdev",&fops);
    88.     if(major < 0)
    89.     {
    90.         printk("字符设备驱动注册失败\n");
    91.         return major;
    92.     }
    93.     printk("字符设备驱动注册成功:major=%d\n",major);
    94.  
    95.     //向上提交目录 class_create
    96.     cls = class_create(THIS_MODULE,"mychrdev");
    97.     if(IS_ERR(cls))
    98.     {
    99.         printk("向上提交目录失败\n");
    100.         return -PTR_ERR(cls);
    101.     }
    102.     printk("向上提交目录成功\n");
    103.  
    104.     //向上提交设备节点信息 device_create
    105.     int i;
    106.     for(i=0;i<3;i++)
    107.     {
    108.         dev = device_create(cls,NULL,MKDEV(major,i),NULL,"myled%d",i);
    109.         if(IS_ERR(dev))
    110.         {
    111.             printk("向上提交设备节点失败\n");
    112.             return -PTR_ERR(dev);
    113.         }
    114.     }
    115.     printk("向上提交设备节点信息成功\n");
    116.     return 0;
    117. }
    118. static void __exit mycdev_exit(void)
    119. {
    120.     //1.销毁设备节点信息
    121.     int i;
    122.     for(i=0;i<3;i++)
    123.     {
    124.         device_destroy(cls,MKDEV(major,i));
    125.     }
    126.     //2.销毁目录
    127.     class_destroy(cls);
    128.     //3.注销字符设备驱动
    129.     unregister_chrdev(major,"mychrdev");
    130. }
    131. module_init(mycdev_init);
    132. module_exit(mycdev_exit);
    133. MODULE_LICENSE("GPL");

    进程1：监听多个事件

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11.  
    12. int main(int argc, char const *argv[])
    13. {
    14.     char buf[128] = {0};
    15.     int fd1,fd2;
    16.     fd1 = open("/dev/input/mouse0",O_RDWR);
    17.     if(fd1 < 0)
    18.     {
    19.         printf("打开鼠标设备失败\n");
    20.         return -1;
    21.     }
    22.     fd2 = open("/dev/myled0",O_RDWR);
    23.     if(fd2 < 0)
    24.     {
    25.         printf("打开设备失败\n");
    26.         return -1;
    27.     }
    28.     // 定义读事件集合
    29.     fd_set readfds;
    30.     while(1)
    31.     {
    32.         // 清空集合
    33.         FD_ZERO(&readfds);
    34.         // 将要监听的事件添加进集合
    35.         FD_SET(fd1, &readfds);
    36.         FD_SET(fd2, &readfds); 
    37.         // 阻塞监听事件
    38.         int ret;
    39.         ret = select(fd2 + 1, &readfds, NULL, NULL, NULL);
    40.         if(ret < 0)
    41.         {
    42.             printf("select 调用失败\n");
    43.             return -1;
    44.         }
    45.         // 判断事件是否发生
    46.         if(FD_ISSET(fd1, &readfds));
    47.         {
    48.             memset(buf, 0, sizeof(buf));
    49.             read(fd1, buf, sizeof(buf));
    50.             printf("鼠标事件发生buf:%s\n", buf);
    51.         }
    52.         if(FD_ISSET(fd2, &readfds))
    53.         {
    54.             memset(buf,0,sizeof(buf));
    55.             read(fd2,buf,sizeof(buf));
    56.             printf("事件发生buf:%s\n",buf);
    57.         }
    58.     }
    59.     // 关闭文件描述符
    60.     close(fd1);
    61.     close(fd2);
    62.     return 0;
    63. }

    进程2：模拟自定义事件就绪

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. int main(int argc, char const *argv[])
    11. {
    12.     char buf[128] = "hello world";
    13.     int a,b;
    14.     int fd = open("/dev/myled0",O_RDWR);
    15.     if(fd < 0)
    16.     {
    17.         printf("打开设备文件失败\n");
    18.         exit(-1);
    19.     }
    20.     write(fd,buf,sizeof(buf));
    21. }

    效果演示

  • 相关阅读:
    python调用c++版本dll06-返回数组结构体
    C++ 强制类型转换(int double)、查看数据类型、自动决定类型、三元表达式、取反、
    sdkman 安装以及 graalvm安装
    司徒理财：黄金今日多空走势预测！原油最新操作建议
    echarts图表配置
    大学生面试JAVA程序员应该具备的JAVA面试题库
    [ruby on rails]rails6.0升级6.1
    java 数据脱敏
    数据结构与算法之图: Leetcode 417. 太平洋大西洋水流问题 (Typescript版)
    网络编程及套接字
  • 原文地址：https://blog.csdn.net/Smallxu_/article/details/134016483