sensor.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2016 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef ZEPHYR_INCLUDE_DRIVERS_SENSOR_H_
#define ZEPHYR_INCLUDE_DRIVERS_SENSOR_H_
 
#include <zephyr/types.h>
#include <zephyr/device.h>
#include <errno.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct sensor_value {
        int32_t val1;
        int32_t val2;
};
 
enum sensor_channel {
        SENSOR_CHAN_ACCEL_X,
        SENSOR_CHAN_ACCEL_Y,
        SENSOR_CHAN_ACCEL_Z,
        SENSOR_CHAN_ACCEL_XYZ,
        SENSOR_CHAN_GYRO_X,
        SENSOR_CHAN_GYRO_Y,
        SENSOR_CHAN_GYRO_Z,
        SENSOR_CHAN_GYRO_XYZ,
        SENSOR_CHAN_MAGN_X,
        SENSOR_CHAN_MAGN_Y,
        SENSOR_CHAN_MAGN_Z,
        SENSOR_CHAN_MAGN_XYZ,
        SENSOR_CHAN_DIE_TEMP,
        SENSOR_CHAN_AMBIENT_TEMP,
        SENSOR_CHAN_PRESS,
        SENSOR_CHAN_PROX,
        SENSOR_CHAN_HUMIDITY,
        SENSOR_CHAN_LIGHT,
        SENSOR_CHAN_IR,
        SENSOR_CHAN_RED,
        SENSOR_CHAN_GREEN,
        SENSOR_CHAN_BLUE,
        SENSOR_CHAN_ALTITUDE,
 
        SENSOR_CHAN_PM_1_0,
        SENSOR_CHAN_PM_2_5,
        SENSOR_CHAN_PM_10,
        SENSOR_CHAN_DISTANCE,
 
        SENSOR_CHAN_CO2,
        SENSOR_CHAN_VOC,
        SENSOR_CHAN_GAS_RES,
 
        SENSOR_CHAN_VOLTAGE,
        SENSOR_CHAN_CURRENT,
        SENSOR_CHAN_POWER,
 
        SENSOR_CHAN_RESISTANCE,
 
        SENSOR_CHAN_ROTATION,
 
        SENSOR_CHAN_POS_DX,
        SENSOR_CHAN_POS_DY,
        SENSOR_CHAN_POS_DZ,
 
        SENSOR_CHAN_RPM,
 
        SENSOR_CHAN_GAUGE_VOLTAGE,
        SENSOR_CHAN_GAUGE_AVG_CURRENT,
        SENSOR_CHAN_GAUGE_STDBY_CURRENT,
        SENSOR_CHAN_GAUGE_MAX_LOAD_CURRENT,
        SENSOR_CHAN_GAUGE_TEMP,
        SENSOR_CHAN_GAUGE_STATE_OF_CHARGE,
        SENSOR_CHAN_GAUGE_FULL_CHARGE_CAPACITY,
        SENSOR_CHAN_GAUGE_REMAINING_CHARGE_CAPACITY,
        SENSOR_CHAN_GAUGE_NOM_AVAIL_CAPACITY,
        SENSOR_CHAN_GAUGE_FULL_AVAIL_CAPACITY,
        SENSOR_CHAN_GAUGE_AVG_POWER,
        SENSOR_CHAN_GAUGE_STATE_OF_HEALTH,
        SENSOR_CHAN_GAUGE_TIME_TO_EMPTY,
        SENSOR_CHAN_GAUGE_TIME_TO_FULL,
        SENSOR_CHAN_GAUGE_CYCLE_COUNT,
        SENSOR_CHAN_GAUGE_DESIGN_VOLTAGE,
        SENSOR_CHAN_GAUGE_DESIRED_VOLTAGE,
        SENSOR_CHAN_GAUGE_DESIRED_CHARGING_CURRENT,
 
        SENSOR_CHAN_ALL,
 
        SENSOR_CHAN_COMMON_COUNT,
 
        SENSOR_CHAN_PRIV_START = SENSOR_CHAN_COMMON_COUNT,
 
        SENSOR_CHAN_MAX = INT16_MAX,
};
 
enum sensor_trigger_type {
        SENSOR_TRIG_TIMER,
        SENSOR_TRIG_DATA_READY,
        SENSOR_TRIG_DELTA,
        SENSOR_TRIG_NEAR_FAR,
        SENSOR_TRIG_THRESHOLD,
 
        SENSOR_TRIG_TAP,
 
        SENSOR_TRIG_DOUBLE_TAP,
 
        SENSOR_TRIG_FREEFALL,
 
        SENSOR_TRIG_MOTION,
 
        SENSOR_TRIG_STATIONARY,
        SENSOR_TRIG_COMMON_COUNT,
 
        SENSOR_TRIG_PRIV_START = SENSOR_TRIG_COMMON_COUNT,
 
        SENSOR_TRIG_MAX = INT16_MAX,
};
 
struct sensor_trigger {
        enum sensor_trigger_type type;
        enum sensor_channel chan;
};
 
enum sensor_attribute {
        SENSOR_ATTR_SAMPLING_FREQUENCY,
        SENSOR_ATTR_LOWER_THRESH,
        SENSOR_ATTR_UPPER_THRESH,
        SENSOR_ATTR_SLOPE_TH,
        SENSOR_ATTR_SLOPE_DUR,
        /* Hysteresis for trigger thresholds. */
        SENSOR_ATTR_HYSTERESIS,
        SENSOR_ATTR_OVERSAMPLING,
        SENSOR_ATTR_FULL_SCALE,
        SENSOR_ATTR_OFFSET,
        SENSOR_ATTR_CALIB_TARGET,
        SENSOR_ATTR_CONFIGURATION,
        SENSOR_ATTR_CALIBRATION,
        SENSOR_ATTR_FEATURE_MASK,
        SENSOR_ATTR_ALERT,
        SENSOR_ATTR_FF_DUR,
        SENSOR_ATTR_COMMON_COUNT,
 
        SENSOR_ATTR_PRIV_START = SENSOR_ATTR_COMMON_COUNT,
 
        SENSOR_ATTR_MAX = INT16_MAX,
};
 
typedef void (*sensor_trigger_handler_t)(const struct device *dev,
                                         const struct sensor_trigger *trigger);
 
typedef int (*sensor_attr_set_t)(const struct device *dev,
                                 enum sensor_channel chan,
                                 enum sensor_attribute attr,
                                 const struct sensor_value *val);
 
typedef int (*sensor_attr_get_t)(const struct device *dev,
                                 enum sensor_channel chan,
                                 enum sensor_attribute attr,
                                 struct sensor_value *val);
 
typedef int (*sensor_trigger_set_t)(const struct device *dev,
                                    const struct sensor_trigger *trig,
                                    sensor_trigger_handler_t handler);
typedef int (*sensor_sample_fetch_t)(const struct device *dev,
                                     enum sensor_channel chan);
typedef int (*sensor_channel_get_t)(const struct device *dev,
                                    enum sensor_channel chan,
                                    struct sensor_value *val);
 
__subsystem struct sensor_driver_api {
        sensor_attr_set_t attr_set;
        sensor_attr_get_t attr_get;
        sensor_trigger_set_t trigger_set;
        sensor_sample_fetch_t sample_fetch;
        sensor_channel_get_t channel_get;
};
 
__syscall int sensor_attr_set(const struct device *dev,
                              enum sensor_channel chan,
                              enum sensor_attribute attr,
                              const struct sensor_value *val);
 
static inline int z_impl_sensor_attr_set(const struct device *dev,
                                         enum sensor_channel chan,
                                         enum sensor_attribute attr,
                                         const struct sensor_value *val)
{
        const struct sensor_driver_api *api =
                (const struct sensor_driver_api *)dev->api;
 
        if (api->attr_set == NULL) {
                return -ENOSYS;
        }
 
        return api->attr_set(dev, chan, attr, val);
}
 
__syscall int sensor_attr_get(const struct device *dev,
                              enum sensor_channel chan,
                              enum sensor_attribute attr,
                              struct sensor_value *val);
 
static inline int z_impl_sensor_attr_get(const struct device *dev,
                                         enum sensor_channel chan,
                                         enum sensor_attribute attr,
                                         struct sensor_value *val)
{
        const struct sensor_driver_api *api =
                (const struct sensor_driver_api *)dev->api;
 
        if (api->attr_get == NULL) {
                return -ENOSYS;
        }
 
        return api->attr_get(dev, chan, attr, val);
}
 
static inline int sensor_trigger_set(const struct device *dev,
                                     const struct sensor_trigger *trig,
                                     sensor_trigger_handler_t handler)
{
        const struct sensor_driver_api *api =
                (const struct sensor_driver_api *)dev->api;
 
        if (api->trigger_set == NULL) {
                return -ENOSYS;
        }
 
        return api->trigger_set(dev, trig, handler);
}
 
__syscall int sensor_sample_fetch(const struct device *dev);
 
static inline int z_impl_sensor_sample_fetch(const struct device *dev)
{
        const struct sensor_driver_api *api =
                (const struct sensor_driver_api *)dev->api;
 
        return api->sample_fetch(dev, SENSOR_CHAN_ALL);
}
 
__syscall int sensor_sample_fetch_chan(const struct device *dev,
                                       enum sensor_channel type);
 
static inline int z_impl_sensor_sample_fetch_chan(const struct device *dev,
                                                  enum sensor_channel type)
{
        const struct sensor_driver_api *api =
                (const struct sensor_driver_api *)dev->api;
 
        return api->sample_fetch(dev, type);
}
 
__syscall int sensor_channel_get(const struct device *dev,
                                 enum sensor_channel chan,
                                 struct sensor_value *val);
 
static inline int z_impl_sensor_channel_get(const struct device *dev,
                                            enum sensor_channel chan,
                                            struct sensor_value *val)
{
        const struct sensor_driver_api *api =
                (const struct sensor_driver_api *)dev->api;
 
        return api->channel_get(dev, chan, val);
}
 
#define SENSOR_G                9806650LL
 
#define SENSOR_PI               3141592LL
 
static inline int32_t sensor_ms2_to_g(const struct sensor_value *ms2)
{
        int64_t micro_ms2 = ms2->val1 * 1000000LL + ms2->val2;
 
        if (micro_ms2 > 0) {
                return (micro_ms2 + SENSOR_G / 2) / SENSOR_G;
        } else {
                return (micro_ms2 - SENSOR_G / 2) / SENSOR_G;
        }
}
 
static inline void sensor_g_to_ms2(int32_t g, struct sensor_value *ms2)
{
        ms2->val1 = ((int64_t)g * SENSOR_G) / 1000000LL;
        ms2->val2 = ((int64_t)g * SENSOR_G) % 1000000LL;
}
 
static inline int32_t sensor_ms2_to_ug(const struct sensor_value *ms2)
{
        int64_t micro_ms2 = ms2->val1 * 1000000LL + ms2->val2;
 
        return (micro_ms2 * 1000000LL) / SENSOR_G;
}
 
static inline void sensor_ug_to_ms2(int32_t ug, struct sensor_value *ms2)
{
        ms2->val1 = ((int64_t)ug * SENSOR_G / 1000000LL) / 1000000LL;
        ms2->val2 = ((int64_t)ug * SENSOR_G / 1000000LL) % 1000000LL;
}
 
static inline int32_t sensor_rad_to_degrees(const struct sensor_value *rad)
{
        int64_t micro_rad_s = rad->val1 * 1000000LL + rad->val2;
 
        if (micro_rad_s > 0) {
                return (micro_rad_s * 180LL + SENSOR_PI / 2) / SENSOR_PI;
        } else {
                return (micro_rad_s * 180LL - SENSOR_PI / 2) / SENSOR_PI;
        }
}
 
static inline void sensor_degrees_to_rad(int32_t d, struct sensor_value *rad)
{
        rad->val1 = ((int64_t)d * SENSOR_PI / 180LL) / 1000000LL;
        rad->val2 = ((int64_t)d * SENSOR_PI / 180LL) % 1000000LL;
}
 
static inline int32_t sensor_rad_to_10udegrees(const struct sensor_value *rad)
{
        int64_t micro_rad_s = rad->val1 * 1000000LL + rad->val2;
 
        return (micro_rad_s * 180LL * 100000LL) / SENSOR_PI;
}
 
static inline void sensor_10udegrees_to_rad(int32_t d, struct sensor_value *rad)
{
        rad->val1 = ((int64_t)d * SENSOR_PI / 180LL / 100000LL) / 1000000LL;
        rad->val2 = ((int64_t)d * SENSOR_PI / 180LL / 100000LL) % 1000000LL;
}
 
static inline double sensor_value_to_double(const struct sensor_value *val)
{
        return (double)val->val1 + (double)val->val2 / 1000000;
}
 
static inline int sensor_value_from_double(struct sensor_value *val, double inp)
{
        if (inp < INT32_MIN || inp > INT32_MAX) {
                return -ERANGE;
        }
 
        double val2 = (inp - (int32_t)inp) * 1000000.0;
 
        if (val2 < INT32_MIN || val2 > INT32_MAX) {
                return -ERANGE;
        }
 
        val->val1 = (int32_t)inp;
        val->val2 = (int32_t)val2;
 
        return 0;
}
 
#ifdef CONFIG_SENSOR_INFO
 
struct sensor_info {
        const struct device *dev;
        const char *vendor;
        const char *model;
        const char *friendly_name;
};
 
#define SENSOR_INFO_INITIALIZER(_dev, _vendor, _model, _friendly_name)  \
        {                                                               \
                .dev = _dev,                                            \
                .vendor = _vendor,                                      \
                .model = _model,                                        \
                .friendly_name = _friendly_name,                        \
        }
 
#define SENSOR_INFO_DEFINE(name, ...)                                   \
        static const STRUCT_SECTION_ITERABLE(sensor_info, name) =       \
                SENSOR_INFO_INITIALIZER(__VA_ARGS__)
 
#define SENSOR_INFO_DT_NAME(node_id)                                    \
        _CONCAT(__sensor_info, DEVICE_DT_NAME_GET(node_id))
 
#define SENSOR_INFO_DT_DEFINE(node_id)                                  \
        SENSOR_INFO_DEFINE(SENSOR_INFO_DT_NAME(node_id),                \
                           DEVICE_DT_GET(node_id),                      \
                           DT_NODE_VENDOR_OR(node_id, NULL),            \
                           DT_NODE_MODEL_OR(node_id, NULL),             \
                           DT_PROP_OR(node_id, friendly_name, NULL))    \
 
#else
 
#define SENSOR_INFO_DEFINE(name, ...)
#define SENSOR_INFO_DT_DEFINE(node_id)
 
#endif /* CONFIG_SENSOR_INFO */
 
#define SENSOR_DEVICE_DT_DEFINE(node_id, init_fn, pm_device,            \
                                data_ptr, cfg_ptr, level, prio,         \
                                api_ptr, ...)                           \
        DEVICE_DT_DEFINE(node_id, init_fn, pm_device,                   \
                         data_ptr, cfg_ptr, level, prio,                \
                         api_ptr, __VA_ARGS__);                         \
                                                                        \
        SENSOR_INFO_DT_DEFINE(node_id);
 
#define SENSOR_DEVICE_DT_INST_DEFINE(inst, ...)                         \
        SENSOR_DEVICE_DT_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)
 
static inline int64_t sensor_value_to_milli(struct sensor_value *val)
{
        return ((int64_t)val->val1 * 1000) + val->val2 / 1000;
}
 
static inline int64_t sensor_value_to_micro(struct sensor_value *val)
{
        return ((int64_t)val->val1 * 1000000) + val->val2;
}
 
#ifdef __cplusplus
}
#endif
 
#include <syscalls/sensor.h>
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_SENSOR_H_ */