Linux驱动基础(SR501人体感应模块)

简介: Linux驱动基础(SR501人体感应模块)

前言

本篇文章将给大家介绍一下SR501驱动程序的编写。


一、SR501模块介绍

SR501是一种基于红外线感应原理的人体感应模块,通常被用于安防等一系列自动控制场景中。它主要通过红外线传感器检测感应区域内的人体热辐射,当检测到人体进入这个区域时,输出高电平信号;当人体离开这个区域时,输出低电平信号。

SR501模块整体封装在一块小板子上,板子上有两个旋钮,可以通过旋转它们来调节感应灵敏度和输出信号类型,以适应不同的应用场景。此外,模块还具有自动感应和手动感应两种模式,可以通过调节模式选择开关来进行调节。

SR501模块拥有许多优点,例如可以灵敏地探测人体,响应速度快、稳定性好、安装简单等等,因此被广泛应用于各种人体感应应用场景中。

SR501接线:

VCC----电源

GND----GND

OUT-----GPIO(设置为输入模式)


二、设备树编写

这里我将SR501模块接到了GPIO4_19:

这里主要需要注意的就是compatible属性,使用这个属性来和我们编写的驱动进行匹配。

sr501{
        compatible = "my,sr501";
        gpios = <&gpio4 19 GPIO_ACTIVE_HIGH>;
   };

三、驱动编写

1.确定主设备号

主设备设置为0让系统自动帮我们分配主设备号。

static int major=0;/*主设备号*/

2.编写file_operations结构体

我们需要提供这个结构体并且编写其中的open和read函数,供应用程序使用。

static ssize_t sr501_read (struct file *file, char __user *buf, size_t size, loff_t *off)
{
  int err;
  wait_event_interruptible(sr501_wq, sr501_data);
  err = copy_to_user(buf, &sr501_data, 4);
  sr501_data = 0;
  return 0;
}
static int sr501_open (struct inode *inode, struct file *file)
{
  printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
  return 0;
}
static struct file_operations sr501_ops={
  .owner    = THIS_MODULE,
  .open   = sr501_open,
  .read   = sr501_read, 
};

3.注册file_operations结构体

在Linux中注册其实就是指在Linux内核中添加我们自己编写的这个file_operations结构体。这个注册的工作在入口函数中完成。

static int __init sr501_init(void)
{
  int err;
  printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
  /*确定主设备号*/
  major=register_chrdev(major, "mysr501", &sr501_ops);
  /*创建类*/
  sr501_class=class_create(THIS_MODULE, "sr501");
  if (IS_ERR(sr501_class)) {
    printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
    unregister_chrdev(major, "mysr501");
    return PTR_ERR(sr501_class);
  }
  init_waitqueue_head(&sr501_wq);//初始化队列
  err=platform_driver_register(&sr501);
  return 0;
}

4.出口函数编写

有入口函数就会有出口函数,在入口函数中做的是设备的注册等工作,那么出口函数就是做相反的工作,将设备注销。

static void __exit sr501_exit(void)
{
  printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
  platform_driver_unregister(&sr501);
  class_destroy(sr501_class);
  unregister_chrdev(major, "mysr501");  
}
module_init(sr501_init);
module_exit(sr501_exit);
MODULE_LICENSE("GPL");

5.probe函数和remove函数编写

创建platform_driver结构体和of_device_id结构体,使用of_device_id结构体中的compatible 属性和设备树进行匹配,匹配完成后会调用到probe函数。

static const struct of_device_id my_sr501[] = {
    { .compatible = "my,sr501" },
    { },
};
static struct platform_driver sr501={
  .driver = {
    .name = "sr501",
    .of_match_table = my_sr501, 
  },
  .probe = sr501_probe,
  .remove = sr501_remove, 
};
static int sr501_probe(struct platform_device *pdev)
{
  int err;
  printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
  /*1.获取硬件信息*/
  sr501_gpio=gpiod_get(&pdev->dev, NULL, GPIOD_IN);
  if (IS_ERR(sr501_gpio)) {
    printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
  }
  /*得到irq*/
  irq = gpiod_to_irq(sr501_gpio);
  /*申请中断并设置为双边沿触发*/
  err = request_irq(irq, sr501_isr, IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING, "sr501", NULL);
  if (err != 0) {
    printk("request_irq is err\n");
  }
  /*2.创建设备节点*/  
  device_create(sr501_class, NULL, MKDEV(major, 0), NULL, "sr501");
    return 0; 
}
static int sr501_remove(struct platform_device *pdev)
{   
  printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
  device_destroy(sr501_class, MKDEV(major, 0));
  free_irq(irq, NULL);
  gpiod_put(sr501_gpio);
  return 0;
}

6.中断编写

这里我们使用中断来实现SR501的核心功能,因为当检测到有人的时候SR501表现为高电平,没有人的时候SR501则表现为低电平。那么这样我们就可以把SR501的引脚配置为中断引脚,当电平发生变化的时候就会产生中断。

这里使用到了wait_queue_head_t 定义了一个等待队列,当有人的时候使用wake_up函数唤醒等待队列读取数据。

static wait_queue_head_t sr501_wq;/*等待队列*/
static irqreturn_t sr501_isr(int irq, void *dev_id)
{
  int val = gpiod_get_value(sr501_gpio);
  if(val)
  {
    sr501_data = 1;
    wake_up(&sr501_wq);
  }
  return IRQ_HANDLED; // IRQ_WAKE_THREAD;
}

7.测试程序编写

有了驱动程序后相应的也需要一个应用程序来测试驱动代码是否正确,在应用程序中使用read函数来读取数据。

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <poll.h>
#include <signal.h>
#include <unistd.h>
/*
 * ./sr501_test /dev/sr501
 *
 */
int main(int argc, char **argv)
{
  int fd;
  int data;
  /* 1. 判断参数 */
  if (argc != 2) 
  {
    printf("Usage: %s <dev>\n", argv[0]);
    return -1;
  }
  /* 2. 打开文件 */
//  fd = open(argv[1], O_RDWR | O_NONBLOCK);
  fd = open(argv[1], O_RDWR);
  if (fd == -1)
  {
    printf("can not open file %s\n", argv[1]);
    return -1;
  }
  while (1)
  {
    read(fd, &data, 4);
    if (data)
    {
      printf("have people\n");
    }
    else
    {
      printf("no people\n");
    }     
    sleep(1);
  }
  close(fd);
  return 0;
}

8.全部驱动程序

#include <linux/module.h>
#include <linux/poll.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/miscdevice.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/mutex.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/stat.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/tty.h>
#include <linux/kmod.h>
#include <linux/gfp.h>
#include <linux/gpio/consumer.h>
#include <linux/platform_device.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/slab.h>
#include <linux/fcntl.h>
#include <linux/timer.h>
#include <linux/workqueue.h>
#include <asm/current.h>
#include <linux/delay.h>
#include <linux/timex.h>
static int major=0;/*主设备号*/
static struct class *sr501_class;
static struct gpio_desc *sr501_gpio;/*sr501 gpio*/
static int sr501_data = 0;
static int irq;/*中断号*/
static wait_queue_head_t sr501_wq;/*等待队列*/
static ssize_t sr501_read (struct file *file, char __user *buf, size_t size, loff_t *off)
{
  int err;
  wait_event_interruptible(sr501_wq, sr501_data);
  err = copy_to_user(buf, &sr501_data, 4);
  sr501_data = 0;
  return 0;
}
static int sr501_open (struct inode *inode, struct file *file)
{
  printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
  return 0;
}
static struct file_operations sr501_ops={
  .owner    = THIS_MODULE,
  .open   = sr501_open,
  .read   = sr501_read, 
};
static irqreturn_t sr501_isr(int irq, void *dev_id)
{
  int val = gpiod_get_value(sr501_gpio);
  if(val)
  {
    sr501_data = 1;
    wake_up(&sr501_wq);
  }
  return IRQ_HANDLED; // IRQ_WAKE_THREAD;
}
static int sr501_probe(struct platform_device *pdev)
{
  int err;
  printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
  /*1.获取硬件信息*/
  sr501_gpio=gpiod_get(&pdev->dev, NULL, GPIOD_IN);
  if (IS_ERR(sr501_gpio)) {
    printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
  }
  /*得到irq*/
  irq = gpiod_to_irq(sr501_gpio);
  /*申请中断并设置为双边沿触发*/
  err = request_irq(irq, sr501_isr, IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING, "sr501", NULL);
  if (err != 0) {
    printk("request_irq is err\n");
  }
  /*2.创建设备节点*/  
  device_create(sr501_class, NULL, MKDEV(major, 0), NULL, "sr501");
    return 0; 
}
static int sr501_remove(struct platform_device *pdev)
{   
  printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
  device_destroy(sr501_class, MKDEV(major, 0));
  free_irq(irq, NULL);
  gpiod_put(sr501_gpio);
  return 0;
}
static const struct of_device_id my_sr501[] = {
    { .compatible = "my,sr501" },
    { },
};
static struct platform_driver sr501={
  .driver = {
    .name = "sr501",
    .of_match_table = my_sr501, 
  },
  .probe = sr501_probe,
  .remove = sr501_remove, 
};
static int __init sr501_init(void)
{
  int err;
  printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
  /*确定主设备号*/
  major=register_chrdev(major, "mysr501", &sr501_ops);
  /*创建类*/
  sr501_class=class_create(THIS_MODULE, "sr501");
  if (IS_ERR(sr501_class)) {
    printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
    unregister_chrdev(major, "mysr501");
    return PTR_ERR(sr501_class);
  }
  init_waitqueue_head(&sr501_wq);//初始化队列
  err=platform_driver_register(&sr501);
  return 0;
}
static void __exit sr501_exit(void)
{
  printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
  platform_driver_unregister(&sr501);
  class_destroy(sr501_class);
  unregister_chrdev(major, "mysr501");  
}
module_init(sr501_init);
module_exit(sr501_exit);
MODULE_LICENSE("GPL");

总结

本篇文章就讲解到这里,只要掌握Linux驱动的核心框架写一个驱动程序并不是那么困难。

相关文章
|
2月前
|
Unix Linux 网络安全
python中连接linux好用的模块paramiko(附带案例)
该文章详细介绍了如何使用Python的Paramiko模块来连接Linux服务器,包括安装配置及通过密码或密钥进行身份验证的示例。
76 1
|
2月前
|
编解码 Linux 开发工具
Linux平台x86_64|aarch64架构RTMP推送|轻量级RTSP服务模块集成说明
支持x64_64架构、aarch64架构(需要glibc-2.21及以上版本的Linux系统, 需要libX11.so.6, 需要GLib–2.0, 需安装 libstdc++.so.6.0.21、GLIBCXX_3.4.21、 CXXABI_1.3.9)。
|
3月前
|
Java Linux API
Linux设备驱动开发详解2
Linux设备驱动开发详解
43 6
|
3月前
|
消息中间件 算法 Unix
Linux设备驱动开发详解1
Linux设备驱动开发详解
49 5
|
3月前
|
NoSQL Linux Android开发
内核实验(三):编写简单Linux内核模块,使用Qemu加载ko做测试
本文介绍了如何在QEMU中挂载虚拟分区、创建和编译简单的Linux内核模块,并在QEMU虚拟机中加载和测试这些内核模块,包括创建虚拟分区、编写内核模块代码、编译、部署以及在QEMU中的加载和测试过程。
197 0
内核实验(三):编写简单Linux内核模块,使用Qemu加载ko做测试
|
3月前
|
Ubuntu NoSQL Linux
Linux内核和驱动
Linux内核和驱动
29 2
|
3月前
|
负载均衡 应用服务中间件 Linux
在Linux中,常用的 Nginx 模块有哪些,常来做什么?
在Linux中,常用的 Nginx 模块有哪些,常来做什么?
|
3月前
|
安全 Linux 开发者
在Linux中,内核模块是什么以及如何加载和卸载它们?
在Linux中,内核模块是什么以及如何加载和卸载它们?
|
3月前
|
数据采集 Linux
Linux源码阅读笔记20-PCI设备驱动详解
Linux源码阅读笔记20-PCI设备驱动详解
|
2月前
|
Linux API
Linux里的高精度时间计时器(HPET)驱动 【ChatGPT】
Linux里的高精度时间计时器(HPET)驱动 【ChatGPT】