304 lines
7.7 KiB
C
304 lines
7.7 KiB
C
/*
|
|
* SRF04: ultrasonic sensor for distance measuring by using GPIOs
|
|
*
|
|
* Copyright (c) 2017 Andreas Klinger <ak@it-klinger.de>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* For details about the device see:
|
|
* http://www.robot-electronics.co.uk/htm/srf04tech.htm
|
|
*
|
|
* the measurement cycle as timing diagram looks like:
|
|
*
|
|
* +---+
|
|
* GPIO | |
|
|
* trig: --+ +------------------------------------------------------
|
|
* ^ ^
|
|
* |<->|
|
|
* udelay(10)
|
|
*
|
|
* ultra +-+ +-+ +-+
|
|
* sonic | | | | | |
|
|
* burst: ---------+ +-+ +-+ +-----------------------------------------
|
|
* .
|
|
* ultra . +-+ +-+ +-+
|
|
* sonic . | | | | | |
|
|
* echo: ----------------------------------+ +-+ +-+ +----------------
|
|
* . .
|
|
* +------------------------+
|
|
* GPIO | |
|
|
* echo: -------------------+ +---------------
|
|
* ^ ^
|
|
* interrupt interrupt
|
|
* (ts_rising) (ts_falling)
|
|
* |<---------------------->|
|
|
* pulse time measured
|
|
* --> one round trip of ultra sonic waves
|
|
*/
|
|
#include <linux/err.h>
|
|
#include <linux/gpio/consumer.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/of.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/property.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/iio/iio.h>
|
|
#include <linux/iio/sysfs.h>
|
|
|
|
struct srf04_data {
|
|
struct device *dev;
|
|
struct gpio_desc *gpiod_trig;
|
|
struct gpio_desc *gpiod_echo;
|
|
struct mutex lock;
|
|
int irqnr;
|
|
ktime_t ts_rising;
|
|
ktime_t ts_falling;
|
|
struct completion rising;
|
|
struct completion falling;
|
|
};
|
|
|
|
static irqreturn_t srf04_handle_irq(int irq, void *dev_id)
|
|
{
|
|
struct iio_dev *indio_dev = dev_id;
|
|
struct srf04_data *data = iio_priv(indio_dev);
|
|
ktime_t now = ktime_get();
|
|
|
|
if (gpiod_get_value(data->gpiod_echo)) {
|
|
data->ts_rising = now;
|
|
complete(&data->rising);
|
|
} else {
|
|
data->ts_falling = now;
|
|
complete(&data->falling);
|
|
}
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static int srf04_read(struct srf04_data *data)
|
|
{
|
|
int ret;
|
|
ktime_t ktime_dt;
|
|
u64 dt_ns;
|
|
u32 time_ns, distance_mm;
|
|
|
|
/*
|
|
* just one read-echo-cycle can take place at a time
|
|
* ==> lock against concurrent reading calls
|
|
*/
|
|
mutex_lock(&data->lock);
|
|
|
|
reinit_completion(&data->rising);
|
|
reinit_completion(&data->falling);
|
|
|
|
gpiod_set_value(data->gpiod_trig, 1);
|
|
udelay(10);
|
|
gpiod_set_value(data->gpiod_trig, 0);
|
|
|
|
/* it cannot take more than 20 ms */
|
|
ret = wait_for_completion_killable_timeout(&data->rising, HZ/50);
|
|
if (ret < 0) {
|
|
mutex_unlock(&data->lock);
|
|
return ret;
|
|
} else if (ret == 0) {
|
|
mutex_unlock(&data->lock);
|
|
return -ETIMEDOUT;
|
|
}
|
|
|
|
ret = wait_for_completion_killable_timeout(&data->falling, HZ/50);
|
|
if (ret < 0) {
|
|
mutex_unlock(&data->lock);
|
|
return ret;
|
|
} else if (ret == 0) {
|
|
mutex_unlock(&data->lock);
|
|
return -ETIMEDOUT;
|
|
}
|
|
|
|
ktime_dt = ktime_sub(data->ts_falling, data->ts_rising);
|
|
|
|
mutex_unlock(&data->lock);
|
|
|
|
dt_ns = ktime_to_ns(ktime_dt);
|
|
/*
|
|
* measuring more than 3 meters is beyond the capabilities of
|
|
* the sensor
|
|
* ==> filter out invalid results for not measuring echos of
|
|
* another us sensor
|
|
*
|
|
* formula:
|
|
* distance 3 m
|
|
* time = ---------- = --------- = 9404389 ns
|
|
* speed 319 m/s
|
|
*
|
|
* using a minimum speed at -20 °C of 319 m/s
|
|
*/
|
|
if (dt_ns > 9404389)
|
|
return -EIO;
|
|
|
|
time_ns = dt_ns;
|
|
|
|
/*
|
|
* the speed as function of the temperature is approximately:
|
|
*
|
|
* speed = 331,5 + 0,6 * Temp
|
|
* with Temp in °C
|
|
* and speed in m/s
|
|
*
|
|
* use 343 m/s as ultrasonic speed at 20 °C here in absence of the
|
|
* temperature
|
|
*
|
|
* therefore:
|
|
* time 343
|
|
* distance = ------ * -----
|
|
* 10^6 2
|
|
* with time in ns
|
|
* and distance in mm (one way)
|
|
*
|
|
* because we limit to 3 meters the multiplication with 343 just
|
|
* fits into 32 bit
|
|
*/
|
|
distance_mm = time_ns * 343 / 2000000;
|
|
|
|
return distance_mm;
|
|
}
|
|
|
|
static int srf04_read_raw(struct iio_dev *indio_dev,
|
|
struct iio_chan_spec const *channel, int *val,
|
|
int *val2, long info)
|
|
{
|
|
struct srf04_data *data = iio_priv(indio_dev);
|
|
int ret;
|
|
|
|
if (channel->type != IIO_DISTANCE)
|
|
return -EINVAL;
|
|
|
|
switch (info) {
|
|
case IIO_CHAN_INFO_RAW:
|
|
ret = srf04_read(data);
|
|
if (ret < 0)
|
|
return ret;
|
|
*val = ret;
|
|
return IIO_VAL_INT;
|
|
case IIO_CHAN_INFO_SCALE:
|
|
/*
|
|
* theoretical maximum resolution is 3 mm
|
|
* 1 LSB is 1 mm
|
|
*/
|
|
*val = 0;
|
|
*val2 = 1000;
|
|
return IIO_VAL_INT_PLUS_MICRO;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
static const struct iio_info srf04_iio_info = {
|
|
.read_raw = srf04_read_raw,
|
|
};
|
|
|
|
static const struct iio_chan_spec srf04_chan_spec[] = {
|
|
{
|
|
.type = IIO_DISTANCE,
|
|
.info_mask_separate =
|
|
BIT(IIO_CHAN_INFO_RAW) |
|
|
BIT(IIO_CHAN_INFO_SCALE),
|
|
},
|
|
};
|
|
|
|
static int srf04_probe(struct platform_device *pdev)
|
|
{
|
|
struct device *dev = &pdev->dev;
|
|
struct srf04_data *data;
|
|
struct iio_dev *indio_dev;
|
|
int ret;
|
|
|
|
indio_dev = devm_iio_device_alloc(dev, sizeof(struct srf04_data));
|
|
if (!indio_dev) {
|
|
dev_err(dev, "failed to allocate IIO device\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
data = iio_priv(indio_dev);
|
|
data->dev = dev;
|
|
|
|
mutex_init(&data->lock);
|
|
init_completion(&data->rising);
|
|
init_completion(&data->falling);
|
|
|
|
data->gpiod_trig = devm_gpiod_get(dev, "trig", GPIOD_OUT_LOW);
|
|
if (IS_ERR(data->gpiod_trig)) {
|
|
dev_err(dev, "failed to get trig-gpios: err=%ld\n",
|
|
PTR_ERR(data->gpiod_trig));
|
|
return PTR_ERR(data->gpiod_trig);
|
|
}
|
|
|
|
data->gpiod_echo = devm_gpiod_get(dev, "echo", GPIOD_IN);
|
|
if (IS_ERR(data->gpiod_echo)) {
|
|
dev_err(dev, "failed to get echo-gpios: err=%ld\n",
|
|
PTR_ERR(data->gpiod_echo));
|
|
return PTR_ERR(data->gpiod_echo);
|
|
}
|
|
|
|
if (gpiod_cansleep(data->gpiod_echo)) {
|
|
dev_err(data->dev, "cansleep-GPIOs not supported\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
data->irqnr = gpiod_to_irq(data->gpiod_echo);
|
|
if (data->irqnr < 0) {
|
|
dev_err(data->dev, "gpiod_to_irq: %d\n", data->irqnr);
|
|
return data->irqnr;
|
|
}
|
|
|
|
ret = devm_request_irq(dev, data->irqnr, srf04_handle_irq,
|
|
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
|
|
pdev->name, indio_dev);
|
|
if (ret < 0) {
|
|
dev_err(data->dev, "request_irq: %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
platform_set_drvdata(pdev, indio_dev);
|
|
|
|
indio_dev->name = "srf04";
|
|
indio_dev->dev.parent = &pdev->dev;
|
|
indio_dev->info = &srf04_iio_info;
|
|
indio_dev->modes = INDIO_DIRECT_MODE;
|
|
indio_dev->channels = srf04_chan_spec;
|
|
indio_dev->num_channels = ARRAY_SIZE(srf04_chan_spec);
|
|
|
|
return devm_iio_device_register(dev, indio_dev);
|
|
}
|
|
|
|
static const struct of_device_id of_srf04_match[] = {
|
|
{ .compatible = "devantech,srf04", },
|
|
{},
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(of, of_srf04_match);
|
|
|
|
static struct platform_driver srf04_driver = {
|
|
.probe = srf04_probe,
|
|
.driver = {
|
|
.name = "srf04-gpio",
|
|
.of_match_table = of_srf04_match,
|
|
},
|
|
};
|
|
|
|
module_platform_driver(srf04_driver);
|
|
|
|
MODULE_AUTHOR("Andreas Klinger <ak@it-klinger.de>");
|
|
MODULE_DESCRIPTION("SRF04 ultrasonic sensor for distance measuring using GPIOs");
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_ALIAS("platform:srf04");
|