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

已于 2022-03-31 18:27:08 修改
阅读量2.7k 收藏 15
点赞数 3
分类专栏： Linux设备驱动 文章标签： linux驱动 其他 c语言
于 2022-03-26 16:57:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36413982/article/details/122674699
版权

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/sh

make ARCH=arm -j4 CROSS_COMPILE=arm-linux-gnueabihf- dtbs

将设备树拷贝系统目录：

debian@npi:~/nfs_root/driver$ cat cp_dtb_to_linux.sh
#!/bin/sh

sudo 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        0

struct 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_LIB
    sr04.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);      
    }
#else
    struct 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);
#endif

    err = 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_LIB
    gpiod_put(sr04.echo_gpio);           /* 释放echo-gpio*/
    gpiod_put(sr04.trig_gpio);           /* 释放trig-gpio*/
#else
    gpio_free(sr04_trig_gpio);
    gpio_free(sr04_echo_gpio);
#endif
    return 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_LIB
    gpiod_put(sr04.echo_gpio);           /* 释放echo-gpio*/
    gpiod_put(sr04.trig_gpio);           /* 释放trig-gpio*/
#else
    gpio_free(sr04_trig_gpio);
    gpio_free(sr04_echo_gpio);
#endif
    printk(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_NONBLOCK

	if (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);
    }
}
通过逻辑分析仪测量获取时间是否准确

逻辑分析仪测量的启动信号:
在这里插入图片描述
逻辑分析仪测量的距离的高电平时间：
在这里插入图片描述

欲盖弥彰1314
关注
  • 3
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 12
    评论
专栏目录
hc-sr04_driver:HC SR04 超声波测距模块驱动器
07-11
hc-sr04_driver HC SR04 超声波测距模块驱动器 关于这个驱动程序 驱动程序可以触发 HC SR04 超声波测距模块上的测量。 可以通过向 /dev/us_service 字符设备文件写入任意 32 位整数（注意无缓冲写入！）来触发测量。 可以在 60 毫秒后从 /dev/us_service 读取持续的测量时间（32 位无符号整数）。 可以使用除以 58000 将其转换为厘米距离，或使用除以 148000 以英寸为单位。请阅读文档 。 要求 最初该驱动程序是为 Raspberry Pi 设计的，但它可能应该适用于其他单板计算机，因为没有使用 Raspberry Pi 特定指令。 此外，还需要一个简单的电路来连接 HC SR04。 请查看超声波方案.png 和超声波面包板.png。 构建说明 首先应该从 github ( ) 下载内核源代码并编译。 /lib/mod
Linux驱动基础（HC-SR04超声波模块）
m0_49476241的博客
05-21 1521
本篇文章将讲解HC-SR04超声波模块的驱动程序编写，有了上篇SR501模块驱动程序编写的基础后这篇文章大家将会学的非常轻松。HC-SR04超声波模块是一种常用于距离测量和障碍物检测的模块。它通过发射超声波信号并接收回波来计算所测量物体与传感器之间的距离。HC-SR04超声波模块内置有发射器、接收器和控制电路。当模块接收到输入信号后，发射器将发射出一定频率的超声波脉冲信号，该信号在空气中传播并被障碍物反射后，被接收器检测到并转换成电信号返回给模块。
RK3568开发板外接超声波传感器测距模块-迅为电子
Chihiro_S的专栏
09-18 134
RK3568开发板外接超声波传感器测距模块-迅为电子
HC-SR04超声波测距模块及原理图.zip
05-08
HC-SR04超声波测距模块及原理图
传感器 HC-SR04 超声波模块
01-06
模块简介 HC-SR04超声波测距模块可提供2cm-450cm的非接触式距离感测功能，测距精度可达高到2mm；模块包括超声波发射器、接收器与控制电路。 模块参数 使用电压：DC—5V 静态电流：小于2mA 电平输出：高5V 电平输出：低0V 感应角度：不大于15度 探测距离：2cm-450cm 高精度 可达0.2cm 产品应用领域 机器人避障 物体测距 液位检测 公共安防 停车场检测 kay_2017
超声波模块的驱动（STM32、51单片机等）
最新发布
m0_73931287的博客
01-07 701
超声波模块的驱动（STM32、51单片机等）。单片机对超声波模块的驱动，测量距离和显示
【STM32篇】驱动HC_SR04超声波测距模块
we_long的博客
01-13 5404
使用stm32f10x的外部中断和定时器辅助HC_SR04超声波测距模块完成测距，并通过OLED屏幕显示。
基于STM32的超声波模块驱动程序
01-14
基于STM32F1超声波模块驱动程序，代码细节描述清晰，易于理解阅读
STM32驱动HC-SR04超声波模块
m0_49476241的博客
04-16 4097
本篇文章将带大家使用HAL库驱动HC-SR04超声波模块。超声波模块作为智能小车必备的模块，要学习智能小车的同学是必须掌握好这个模块的使用的。HC-SR04是一种常用的超声波传感器模块，也被称为超声波测距模块，广泛应用于各种自动化控制和测距系统中。它通常由超声波发射器、接收器、控制电路和外壳组成，可以实现非接触式的距离测量。下面是HC-SR04超声波模块的一些特性和技术参数：距离测量范围：2cm ~ 400cm（可调）。测量精度：0.3cm。工作电压：DC 5V。工作电流：15mA。
超声波模块工作原理与STM32F103驱动教程
ByteBox的博客
12-07 689
超声波模块是一种常用于测距、避障和定位的传感器。本教程将详细介绍超声波模块的工作原理，以及如何使用STM32F103微控制器对超声波模块进行驱动。我们将提供接线方式、完整代码和注释，以帮助您快速入门。
STM32 HC-SR04 超声波模块
12-07
使用STM32驱动HC-SR04超声波模块，使用数码管显示数据，只需简单修改参数即可使用。
HC-SR04超声波_原理图_HC-SR04超声波_原理图_
09-30
用于C语言硬件编程，HC-SR04超声波_原理图，对于编程实现其功能提供支持。
sysfs文件接口修改内核模块变量值-fasync源码
07-11
具体的例子来展示设备驱动程序如何实现fasync方法，以及应用程序如何得到来自设备驱动程序的异步通知。这个例了同时也展示了sysfs文件系统在驱动程序中的用法，以及通过Linux设各模型来创建设备节点及其他一些特性（这个看起来很简单的内核模块其实体现了设备驱动程序中一些比较重要且典型的特征)。 首先是设备驱动程序的代码，在代码中，我们将这段代码是用C语言编写的Linux内核模块，用于控制LED。它包含了几个来自Linux内核的头文件，如linux/types.h、linux/kernel.h和linux/delay.h。代码定义了一个led_struct结构体，其中包含了关于LED设备的信息，包括它的设备号、字符设备、类和设备。代码还定义了几个用于与LED交互的函数，包括用于打开LED设备的led_open和用于处理异步通知的led_fasync。 模块使用led_init函数进行初始化，该函数在模块加载到内核时调用。这个函数为LED分配一个字符设备号，为它初始化并注册一个字符设备，并为LED创建一个类和设备。它还在文件系统中创建了一个名为“flag”的文件，可以用来与LED交互。
模拟iic驱动HC-SR04 超声波测距
10-14
模拟iic驱动HC-SR04 超声波测距
Linux驱动 | OLED显示模块驱动(SPI)
欲盖弥彰1314
04-01 2961
设备树 驱动实现 测试程序
Linux驱动 | DHT11驱动
欲盖弥彰1314
03-27 2326
DHT11
Linux驱动 | LED驱动(使用PWM子系统)
欲盖弥彰1314
03-25 2225
Linux驱动 | LED驱动(使用PWM子系统) 1、PWM子系统 PWM子系统用于管理PWM波的输出。PWM子系统一般是由芯片厂商实现默认编译进内核。 PWM子系统在内核
Linux 驱动 | SPI子系统
欲盖弥彰1314
04-01 2128
SPI子系统
hc-sr04超声波模块
09-01
HC-SR04超声波模块是一种常用的测距传感器模块。它通过发射超声波脉冲并接收回波来测量物体与模块之间的距离。该模块具有以下特点和使用介绍： 1. 外观：HC-SR04超声波模块通常由一个发射器和一个接收器组成，外形小巧。 2. 原理图：该模块的工作原理是利用超声波在空气中的传播速度来计算距离。 3. 相关参数：HC-SR04模块的一些相关参数包括工作电压、测量范围、角度范围等。 4. 测量范围：该模块可以测量的距离通常为2厘米到400厘米之间。 5. 计算公式：通过测量超声波的往返时间，可以使用公式来计算距离。 6. 优点：HC-SR04模块具有测量精度高、响应速度快、使用简单等优点。 7. 适用场所：该模块适用于各种需要测量距离的场所，如智能车、机器人、安防系统等。 总结起来，HC-SR04超声波模块是一种常用的测距传感器模块，它通过发射超声波脉冲并接收回波来测量物体与模块之间的距离。该模块具有测量精度高、响应速度快和使用简单等优点，并适用于各种需要测量距离的场所。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [超声波测距模块（HC-SR04模块）特点及使用介绍](https://blog.csdn.net/qq_51712037/article/details/119851725)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

欲盖弥彰1314

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值