blob: b899be0cc4d1018ac0ab9664f6bf4fd7533bd286 [file] [log] [blame]
/*
* Copyright (c) 2016 Intel Corporation
*
* SPDX-License-Identifier: Apache-2.0
*/
#define DT_DRV_COMPAT aosong_dht
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/util.h>
#include <zephyr/drivers/sensor.h>
#include <string.h>
#include <zephyr/zephyr.h>
#include <zephyr/logging/log.h>
#include "dht.h"
LOG_MODULE_REGISTER(DHT, CONFIG_SENSOR_LOG_LEVEL);
/**
* @brief Measure duration of signal send by sensor
*
* @param drv_data Pointer to the driver data structure
* @param active Whether current signal is active
*
* @return duration in usec of signal being measured,
* -1 if duration exceeds DHT_SIGNAL_MAX_WAIT_DURATION
*/
static int8_t dht_measure_signal_duration(const struct device *dev,
bool active)
{
const struct dht_config *cfg = dev->config;
uint32_t elapsed_cycles;
uint32_t max_wait_cycles = (uint32_t)(
(uint64_t)DHT_SIGNAL_MAX_WAIT_DURATION *
(uint64_t)sys_clock_hw_cycles_per_sec() /
(uint64_t)USEC_PER_SEC
);
uint32_t start_cycles = k_cycle_get_32();
int rc;
do {
rc = gpio_pin_get_dt(&cfg->dio_gpio);
elapsed_cycles = k_cycle_get_32() - start_cycles;
if ((rc < 0)
|| (elapsed_cycles > max_wait_cycles)) {
return -1;
}
} while ((bool)rc == active);
return (uint64_t)elapsed_cycles *
(uint64_t)USEC_PER_SEC /
(uint64_t)sys_clock_hw_cycles_per_sec();
}
static int dht_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct dht_data *drv_data = dev->data;
const struct dht_config *cfg = dev->config;
int ret = 0;
int8_t signal_duration[DHT_DATA_BITS_NUM];
int8_t max_duration, min_duration, avg_duration;
uint8_t buf[5];
unsigned int i, j;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
/* assert to send start signal */
gpio_pin_set_dt(&cfg->dio_gpio, true);
k_busy_wait(DHT_START_SIGNAL_DURATION);
gpio_pin_set_dt(&cfg->dio_gpio, false);
/* switch to DIR_IN to read sensor signals */
gpio_pin_configure_dt(&cfg->dio_gpio, GPIO_INPUT);
/* wait for sensor active response */
if (dht_measure_signal_duration(dev, false) == -1) {
ret = -EIO;
goto cleanup;
}
/* read sensor response */
if (dht_measure_signal_duration(dev, true) == -1) {
ret = -EIO;
goto cleanup;
}
/* wait for sensor data start */
if (dht_measure_signal_duration(dev, false) == -1) {
ret = -EIO;
goto cleanup;
}
/* read sensor data */
for (i = 0U; i < DHT_DATA_BITS_NUM; i++) {
/* Active signal to indicate a new bit */
if (dht_measure_signal_duration(dev, true) == -1) {
ret = -EIO;
goto cleanup;
}
/* Inactive signal duration indicates bit value */
signal_duration[i] = dht_measure_signal_duration(dev, false);
if (signal_duration[i] == -1) {
ret = -EIO;
goto cleanup;
}
}
/*
* the datasheet says 20-40us HIGH signal duration for a 0 bit and
* 80us for a 1 bit; however, since dht_measure_signal_duration is
* not very precise, compute the threshold for deciding between a
* 0 bit and a 1 bit as the average between the minimum and maximum
* if the durations stored in signal_duration
*/
min_duration = signal_duration[0];
max_duration = signal_duration[0];
for (i = 1U; i < DHT_DATA_BITS_NUM; i++) {
if (min_duration > signal_duration[i]) {
min_duration = signal_duration[i];
}
if (max_duration < signal_duration[i]) {
max_duration = signal_duration[i];
}
}
avg_duration = ((int16_t)min_duration + (int16_t)max_duration) / 2;
/* store bits in buf */
j = 0U;
(void)memset(buf, 0, sizeof(buf));
for (i = 0U; i < DHT_DATA_BITS_NUM; i++) {
if (signal_duration[i] >= avg_duration) {
buf[j] = (buf[j] << 1) | 1;
} else {
buf[j] = buf[j] << 1;
}
if (i % 8 == 7U) {
j++;
}
}
/* verify checksum */
if (((buf[0] + buf[1] + buf[2] + buf[3]) & 0xFF) != buf[4]) {
LOG_DBG("Invalid checksum in fetched sample");
ret = -EIO;
} else {
memcpy(drv_data->sample, buf, 4);
}
cleanup:
/* Switch to output inactive until next fetch. */
gpio_pin_configure_dt(&cfg->dio_gpio, GPIO_OUTPUT_INACTIVE);
return ret;
}
static int dht_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct dht_data *drv_data = dev->data;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_AMBIENT_TEMP
|| chan == SENSOR_CHAN_HUMIDITY);
/* see data calculation example from datasheet */
if (IS_ENABLED(DT_INST_PROP(0, dht22))) {
/*
* use both integral and decimal data bytes; resulted
* 16bit data has a resolution of 0.1 units
*/
int16_t raw_val, sign;
if (chan == SENSOR_CHAN_HUMIDITY) {
raw_val = (drv_data->sample[0] << 8)
+ drv_data->sample[1];
val->val1 = raw_val / 10;
val->val2 = (raw_val % 10) * 100000;
} else { /* chan == SENSOR_CHAN_AMBIENT_TEMP */
raw_val = (drv_data->sample[2] << 8)
+ drv_data->sample[3];
sign = raw_val & 0x8000;
raw_val = raw_val & ~0x8000;
val->val1 = raw_val / 10;
val->val2 = (raw_val % 10) * 100000;
/* handle negative value */
if (sign) {
val->val1 = -val->val1;
val->val2 = -val->val2;
}
}
} else {
/* use only integral data byte */
if (chan == SENSOR_CHAN_HUMIDITY) {
val->val1 = drv_data->sample[0];
val->val2 = 0;
} else { /* chan == SENSOR_CHAN_AMBIENT_TEMP */
val->val1 = drv_data->sample[2];
val->val2 = 0;
}
}
return 0;
}
static const struct sensor_driver_api dht_api = {
.sample_fetch = &dht_sample_fetch,
.channel_get = &dht_channel_get,
};
static int dht_init(const struct device *dev)
{
int rc = 0;
const struct dht_config *cfg = dev->config;
if (!device_is_ready(cfg->dio_gpio.port)) {
LOG_ERR("GPIO device not ready");
return -ENODEV;
}
rc = gpio_pin_configure_dt(&cfg->dio_gpio, GPIO_OUTPUT_INACTIVE);
return rc;
}
#define DHT_DEFINE(inst) \
static struct dht_data dht_data_##inst; \
\
static const struct dht_config dht_config_##inst = { \
.dio_gpio = GPIO_DT_SPEC_INST_GET(inst, dio_gpios), \
}; \
\
DEVICE_DT_INST_DEFINE(inst, &dht_init, NULL, \
&dht_data_##inst, &dht_config_##inst, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, &dht_api); \
DT_INST_FOREACH_STATUS_OKAY(DHT_DEFINE)