HC-SR04超声波模块

工作原理参考：超声波模块_star-air的博客-CSDN博客_超声波模块
https://blog.csdn.net/qq_41262681/article/details/95940707

使用超声波测距的操作步骤：

触发：向T（脉冲触发引脚）发出一个大约10us的高电平。
- 模块就自动发出8个40Khz的超声波，超声波遇到障碍物后反射回来，模块收到返回来的超声波。
回响：模块接收到反射回来的超声波后，Echo引脚输出一个与检测距离成比例的高电平。
计算距离原理：时间 x 速度 = 距离，获取echo引脚维持高电平的时间就可以知道时间T，声速大概340m/s, 由此可计算出距离。

编程实现的两种方法：

顺序执行，通过死等计算高电平时间

伪代码：
disable_irq();
while(Echo == 0);      /* 等待变为高电平 */
while (Echo)      /* 等待变为低电平和计算高电平时间 */
{udelay(1)us++;
}
enable_irq();

利用中断计算

设置Echo引脚为双边沿触发，在上升沿触发中断时记录此刻时刻T0，在下降沿触发中断时记录时刻T1
高电平时间 = T1 - T0内核中获取时间的API ：
ktime_get_ns();          // 获取内核启动到现在的时间，在挂起时会暂停
ktime_get_boottime_ns(); // 获取内核启动到现在的时间，不受挂起影响，是绝对时间
ktime_get_real_ns();     // 获取Unix时间(1970年)到现在的时间，可能涉及闰秒更新，用得比较少
ktime_get_raw_ns();      // 类似ktime_get_ns(),不涉及闰秒更新，用得比较少

参考文档：https://www.kernel.org/doc/html/latest/core-api/timekeeping.html#c.ktime_get_ns

驱动实现

1、设备树编写

imx6ull-mmc-npi.dts

根节点下添加HC-SR04的节点：

hc_sr04 {compatible = "hc_sr04";pinctrl-names = "default";pinctrl-0 = <&pinctrl_sr04_1&pinctrl_sr04_2>;trig-gpios = <&gpio1 4 GPIO_ACTIVE_HIGH>;   echo-gpios = <&gpio5 1 GPIO_ACTIVE_HIGH>;status = "okay"; };

trig-gpios，触发引脚定义
echo-gpios，接收信号引脚
status ，可设置为"okay"或"disabled"，表示启用或者禁用，当其他模块需要使用该gpio，可以直接将状态设置为disabled就可以取消占用，其他模块就可以使用该gpio

设备树编译：

ares@ubuntu:~/work/ebf_linux_kernel-ebf_4.19.35_imx6ul$ cat make_dtb.sh
#!/bin/shmake ARCH=arm -j4 CROSS_COMPILE=arm-linux-gnueabihf- dtbs

将设备树拷贝系统目录：

debian@npi:~/nfs_root/driver$ cat cp_dtb_to_linux.sh
#!/bin/shsudo cp imx6ull-mmc-npi.dtb /usr/lib/linux-image-4.19.35-carp-imx6/

/usr/lib/linux-image-4.19.35-carp-imx6/ ，系统存放设备树的目录

重启系统设备树生效：

sudo reboot

2、驱动编写

头文件数据结构：

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <asm/mach/map.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/io.h>
#include <linux/device.h>
#include <linux/timer.h>
// #include <asm/spinlock.h>
#include <linux/jiffies.h>
#include <linux/platform_device.h>
#include <linux/of_irq.h>
#include <linux/wait.h>
#include <linux/sched/signal.h>
#include <linux/poll.h>
// #include <asm/atomic.h>
#include <linux/atomic.h>#define HC_SR04_DTS_NAME    "hc_sr04"#define DEV_NAME            "hc-sr04"#define USE_GPIO_LIB        0struct hc_sr04 {int irq;                        /* 中断号 */enum of_gpio_flags flag;struct gpio_desc *trig_gpio;    /* trig-gpio */struct gpio_desc *echo_gpio;    /* echo-gpio */dev_t dev_no;                   /* 设备号 */    struct cdev chrdev;             struct class *class;struct mutex  m_lock;           wait_queue_head_t  wq;          /* 等待队列 */
};static struct hc_sr04  sr04;
static int sr04_trig_gpio;
static int sr04_echo_gpio;
static int sr04_data_ns = 0;

两种方式实现一致的地方：

static atomic_t sr04_atomic = ATOMIC_INIT(1);   /*  定义原子变量 *//* 使设备只能被一个进程打开 */
static int _drv_open (struct inode *node, struct file *file)
{if (!atomic_dec_and_test(&sr04_atomic))  {atomic_inc(&sr04_atomic);return  -EBUSY;               /*  已经打开 */}gpio_direction_input(sr04_echo_gpio);   gpio_direction_output(sr04_trig_gpio, 0);return 0;
}/* 使驱动支持多路复用IO */
static __poll_t _drv_poll(struct file *filp, struct poll_table_struct *wait)
{__poll_t mask = 0;// // wait_event_interruptible// mutex_lock(&sr04.m_lock);// poll_wait(filp, &sr04.wq, wait); // if (sr04_val)// {//     mask |= POLLIN | POLLRDNORM;// }// mutex_unlock(&sr501.m_lock);return mask;
}static int _drv_release(struct inode *node, struct file *file)
{atomic_set(&sr04_atomic, 1);      /* 释放时设置原子变量值为1 */printk("hc-sr04 release\n");return 0;
}static struct file_operations sr04_drv_ops = { .owner = THIS_MODULE,.open   = _drv_open,.read   = _drv_read,.poll   = _drv_poll,.release = _drv_release,
};/* 设备树的匹配列表 */
static struct of_device_id dts_match_table[] = {{.compatible = HC_SR04_DTS_NAME, },                     /* 通过设备树来匹配 */
};static struct platform_driver _platform_driver = {.probe = _driver_probe,.remove = _driver_remove,.driver = {.name = HC_SR04_DTS_NAME,.owner = THIS_MODULE,.of_match_table = dts_match_table,         /* 通过设备树匹配 */},
};/* 入口函数 */
static int __init _driver_init(void)
{int ret;printk("hc-sr04 %s\n", __FUNCTION__);ret = platform_driver_register(&_platform_driver);   //注册platform驱动return ret;
}/*  出口函数 */
static void __exit _driver_exit(void)
{printk("hc-sr04  %s\n", __FUNCTION__);platform_driver_unregister(&_platform_driver);
}module_init(_driver_init);
module_exit(_driver_exit);MODULE_AUTHOR("Ares");
MODULE_LICENSE("GPL");

方式1

static ssize_t _drv_read(struct file *filp, char __user *buf, size_t size, loff_t *offset)
{int ret;int time_us = 0;int timeout = 1000000;unsigned long flags;/* 中断屏蔽 */local_irq_save(flags);/* 启动触发信号 */gpio_set_value(sr04_trig_gpio, 1);  udelay(40);gpio_set_value(sr04_trig_gpio, 0); /* 等接收信号GPIO变为高电平*/while (gpio_get_value(sr04_echo_gpio)==0 && timeout)   {udelay(1);timeout--;}   if (timeout == 0) {local_irq_restore(flags);return -EAGAIN;}timeout = 1000000;while (gpio_get_value(sr04_echo_gpio)==1 && timeout)  {udelay(1);  time_us++;                                /* 计算信号高电平时间 */timeout--;                                /* 超时计算 */}if (timeout == 0) {printk("timeout 2\r\n");local_irq_restore(flags);return -EAGAIN;   }    /* 恢复中断 */local_irq_restore(flags);size = size > 4 ? 4 : size;if (copy_to_user(buf, &time_us, size))     /* 将获取的时间拷贝到用户空间 */{ret = -EFAULT;} else {ret = size;}return ret;
}

需要注意在死等的时候要加超时机制返回，否则等不信号时系统就会卡死

方式2

与普通死等获取的方式不同的是

使用中断方式，在_drv_read中只会发起启动信号
在中断函数hc_sr04_isr中获取超声波时间
在_driver_probe申请中断：request_irq(sr04.irq, hc_sr04_isr, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, DEV_NAME, NULL);
在_driver_remove中记得要释放中断，否则下次再insmod内核模块就使用不了该中断，必须要重启系统

static ssize_t _drv_read(struct file *filp, char __user *buf, size_t size, loff_t *offset)
{int ret;int timeout;unsigned long flags;/* 中断屏蔽 */local_irq_save(flags);/* 启动触发信号 */gpio_set_value(sr04_trig_gpio, 1);  //gpiod_set_value(sr04.trig_gpio, 1);udelay(40);gpio_set_value(sr04_trig_gpio, 0);//gpiod_set_value(sr04.trig_gpio, 0);    /* 恢复中断 */local_irq_restore(flags);timeout = wait_event_interruptible_timeout(sr04.wq, sr04_data_ns, HZ);    /* wait 1 sec */if (!timeout) return -EAGAIN;if (copy_to_user(buf, &sr04_data_ns, size > 4 ? 4 : size)) {ret = -EFAULT;} else {ret = size;}sr04_data_ns = 0;return ret;
}static irqreturn_t hc_sr04_isr(int irq_num, void *dev)
{if (gpio_get_value(sr04_echo_gpio)){sr04_data_ns = ktime_get_ns();}else{sr04_data_ns = ktime_get_ns() - sr04_data_ns;wake_up(&sr04.wq);                             /* 唤醒等待队列中进入休眠的进程 */}return IRQ_RETVAL(IRQ_HANDLED);
}static int _driver_probe(struct platform_device *pdev)
{ int err;struct device *sr04_dev;struct device_node *node = pdev->dev.of_node;if (!node) {          printk("hc-sr501 dts node can not found!\r\n");    return -EINVAL; }#if USE_GPIO_LIBsr04.trig_gpio = gpiod_get(&pdev->dev, "trig", GPIOD_OUT_LOW);if (IS_ERR(sr04.trig_gpio)) {              dev_err(&pdev->dev, "Failed to get trig-gpio for hc-sr04\n");             return PTR_ERR(sr04.trig_gpio);      }sr04.echo_gpio = gpiod_get(&pdev->dev, "echo", GPIOD_IN);if (IS_ERR(sr04.echo_gpio)) {              dev_err(&pdev->dev, "Failed to get trig-gpio for hc-sr04\n");     gpiod_put(sr04.trig_gpio);           /* 释放trig-gpio */        return PTR_ERR(sr04.echo_gpio);      }
#elsestruct device_node *dev_node = of_find_node_by_path("/hc_sr04");       /* 找到hc-sr04的设备树节点  */if (IS_ERR(dev_node)) {          printk("hc-sr04 DTS Node not found!\r\n"); return PTR_ERR(dev_node); }sr04_trig_gpio = of_get_named_gpio(dev_node, "trig-gpios", 0);   /* 获取trig-gpio的编号 */if (sr04_trig_gpio < 0) {printk("trig-gpio not found!\r\n"); return -EINVAL;}err = gpio_request(sr04_trig_gpio, "trig-gpios");  if(err) {printk("gpio_request trig-gpios is failed!\n");return -EINVAL;}sr04_echo_gpio = of_get_named_gpio(dev_node, "echo-gpios", 0);   /* 获取echo-gpio的编号 */if ( sr04_echo_gpio < 0) {printk("echo-gpio not found!\r\n"); return -EINVAL;}err = gpio_request(sr04_echo_gpio, "echo-gpios");  if(err) {gpio_free(sr04_trig_gpio);printk("gpio_request echo-gpios is failed!\n");return -EINVAL;}printk("trig-gpio %d  echo-gpio %d\n", sr04_trig_gpio, sr04_echo_gpio);sr04.irq = gpio_to_irq(sr04_echo_gpio);
#endiferr = request_irq(sr04.irq, hc_sr04_isr, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, DEV_NAME, NULL);    /* 申请中断 */if (err) {printk(KERN_INFO"failed to request irq %d\r\n", sr04.irq);gpio_free(sr04_trig_gpio);gpio_free(sr04_echo_gpio);return err;}/* 内核自动分配设备号 */err = alloc_chrdev_region(&sr04.dev_no, 0, 1, DEV_NAME);        if (err < 0) {pr_err("Error: failed to register mbochs_dev, err: %d\n", err);return err;}cdev_init(&sr04.chrdev, &sr04_drv_ops);cdev_add(&sr04.chrdev, sr04.dev_no, 1);sr04.class = class_create(THIS_MODULE, DEV_NAME);if (IS_ERR(sr04.class)) { err = PTR_ERR(sr04.class);goto failed1;}/* 创建设备节点 */sr04_dev = device_create(sr04.class , NULL, sr04.dev_no, NULL, DEV_NAME); if (IS_ERR(sr04_dev)) {       /* 判断指针是否合法 */err = PTR_ERR(sr04_dev);goto failed2;}init_waitqueue_head(&sr04.wq);     /* 初始化等待队列头  */mutex_init(&sr04.m_lock);                 /* 初始化互斥锁  */   printk("hc-sr04 probe success\r\n");return 0;
failed2:device_destroy(sr04.class, sr04.dev_no);class_destroy(sr04.class);
failed1:unregister_chrdev_region(sr04.dev_no, 1);cdev_del(&sr04.chrdev);
#if USE_GPIO_LIBgpiod_put(sr04.echo_gpio);           /* 释放echo-gpio*/gpiod_put(sr04.trig_gpio);           /* 释放trig-gpio*/
#elsegpio_free(sr04_trig_gpio);gpio_free(sr04_echo_gpio);
#endifreturn err;
}static int _driver_remove(struct platform_device *pdev)
{device_destroy(sr04.class, sr04.dev_no);class_destroy(sr04.class);unregister_chrdev_region(sr04.dev_no, 1);cdev_del(&sr04.chrdev);free_irq(sr04.irq, NULL);             /* 释放中断*/
#if USE_GPIO_LIBgpiod_put(sr04.echo_gpio);           /* 释放echo-gpio*/gpiod_put(sr04.trig_gpio);           /* 释放trig-gpio*/
#elsegpio_free(sr04_trig_gpio);gpio_free(sr04_echo_gpio);
#endifprintk(KERN_INFO"hc-sr04 drv remove success\n");return 0;
}

3、测试程序编写

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <sys/ioctl.h>
#include <poll.h>#define DEV_NAME   "/dev/hc-sr04"void sleep_ms(unsigned int ms)
{struct timeval delay;delay.tv_sec = 0;delay.tv_usec = ms * 1000; select(0, NULL, NULL, NULL, &delay);
}int main(int argc, char **argv)
{int fd;int ret;struct pollfd fds[1];/* 2. 打开文件 */fd = open(DEV_NAME, O_RDWR);   // | O_NONBLOCKif (fd < 0){printf("can not open file %s, %d\n", DEV_NAME, fd);return -1;}int time_ns;while (1){if ((ret = read(fd, &time_ns, 4)) == 4){printf("time %d ns %d ms, distance %d mm %d cm\r\n", time_ns, time_ns/1000000, time_ns*340/2/1000000, time_ns*340/2/1000000/10);}else{printf("not get time, err %d\r\n", ret);}sleep_ms(500);}
}

通过逻辑分析仪测量获取时间是否准确

逻辑分析仪测量的启动信号:

逻辑分析仪测量的距离的高电平时间：

Linux驱动 | HC-SR04超声波模块驱动相关推荐

US-100超声波模块驱动
文章目录驱动US-100超声波模块模块概述即参数串口触发时序使用说明反馈温度反馈距离注意事项最坑之处!!! 部分代码无人机上机调试驱动US-100超声波模块由于最近在搞无人机, ...
ESP32设备驱动-Si4703调频收音机模块驱动
Si4703调频收音机模块驱动文章目录 Si4703调频收音机模块驱动 1.Si4703介绍 2.硬件准备 3.软件准备 4.驱动实现 1.Si4703介绍 Si4702/03 FM 无线电接收器系 ...
JSN-SR04T超声波模块驱动（模式三、STM32）
一.前期准备单片机:STM32F103C8T6 开发环境:MDK5.14 库函数:标准库V3.5 JSN-SR04T模块:淘宝有售二.实验效果三.驱动原理此模块分3中模式: (1)模式一:R2 ...
ubuntu加载4G模块驱动的调试过程记录
一个工业平板电脑,原本安装的是win7系统,希望改用ubuntu系统.其他的驱动都好说,关键是有个4G模块,平板电脑厂家使用的是一个小品牌的,ubuntu内部没有集成驱动,需要自己编译驱动.这个对li ...
K_A08_013 基于 STM32等单片机驱动大功率MOS管模块按键控制直流电机加减速启停
目录一.资源说明二.基本参数参数引脚说明三.驱动说明大功率MOS模块驱动对应程序: 四.部分代码说明接线说明 STC89C52RC+大功率MOS模块 STM32F103C8T6+大功率 ...
ESP32设备驱动-RFID-RC522模块驱动
RFID-RC522模块驱动文章目录 RFID-RC522模块驱动 1.RFID-RC522介绍 2.硬件准备 3.软件准备 4.驱动实现 1.RFID-RC522介绍基于 NXP 的 MFRC5 ...
树莓派开发之超声波模块
1.超声波模块介绍 HC-SR04超声波模块基本工作原理: 超声波发射器向某一方向发射超声波,在发射的时刻开始计时,超声波在空气中传播,途中碰到障碍物就立即返回来,超声波接收器收到反射波就立即停止计时 ...
基于51单片机驱动HC-SR04超声波模块（LCD1602显示）
基于51单片机驱动HC-SR04超声波模块(LCD1602显示) 一.基本参数二.通信时序三.部分代码展示四.实际效果总结一.基本参数点击图片购买 HC- SR04+是一款宽电压工作的超声 ...
华为4g模块 linux驱动程序,定制Android之4G-LTE模块驱动
定制Android之4G-LTE模块驱动一．简介本文讲述在Android内核中,添加中国移动4G-LTE制式华为MU909模块驱动,实现通过4G上网业务,电话业务,短信业务. CP ...

Linux驱动 | HC-SR04超声波模块驱动