sensor.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
 */
 
#ifndef BT_MESH_SENSOR_H__
#define BT_MESH_SENSOR_H__
 
#include <zephyr/bluetooth/mesh.h>
#include <bluetooth/mesh/model_types.h>
#include <zephyr/drivers/sensor.h>
#include <stdlib.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifndef CONFIG_BT_MESH_SENSOR_CHANNEL_ENCODED_SIZE_MAX
#define CONFIG_BT_MESH_SENSOR_CHANNEL_ENCODED_SIZE_MAX 0
#endif
 
#define BT_MESH_SENSOR_PERIOD_DIV_MAX 15
#define BT_MESH_SENSOR_INTERVAL_MAX 26
 
#define BT_MESH_SENSOR_CH_STR_LEN 23
 
#define BT_MESH_SENSOR_VALUE_IN_RANGE(_value, _start, _end) (                  \
                (_value)->format->cb->compare((_value), (_start)) >= 0 &&      \
                (_value)->format->cb->compare((_end), (_value)) >= 0)
 
enum bt_mesh_sensor_sampling {
        BT_MESH_SENSOR_SAMPLING_UNSPECIFIED,
        BT_MESH_SENSOR_SAMPLING_INSTANTANEOUS,
        BT_MESH_SENSOR_SAMPLING_ARITHMETIC_MEAN,
        BT_MESH_SENSOR_SAMPLING_RMS,
        BT_MESH_SENSOR_SAMPLING_MAXIMUM,
        BT_MESH_SENSOR_SAMPLING_MINIMUM,
        BT_MESH_SENSOR_SAMPLING_ACCUMULATED,
        BT_MESH_SENSOR_SAMPLING_COUNT,
};
 
enum bt_mesh_sensor_cadence {
        BT_MESH_SENSOR_CADENCE_NORMAL,
        BT_MESH_SENSOR_CADENCE_FAST,
};
 
struct bt_mesh_sensor_unit {
        const char *name;
        const char *symbol;
};
 
struct bt_mesh_sensor_format;
 
struct bt_mesh_sensor_channel {
        const struct bt_mesh_sensor_format *format;
#ifdef CONFIG_BT_MESH_SENSOR_LABELS
        const char *name;
#endif
};
 
#define BT_MESH_SENSOR_TYPE_FLAG_SERIES BIT(0)
 
struct bt_mesh_sensor_type {
        uint16_t id;
        uint8_t flags;
        uint8_t channel_count;
        const struct bt_mesh_sensor_channel *channels;
};
 
struct bt_mesh_sensor;
struct bt_mesh_sensor_srv;
 
enum bt_mesh_sensor_value_status {
        BT_MESH_SENSOR_VALUE_NUMBER = 0,
        BT_MESH_SENSOR_VALUE_CONVERSION_ERROR,
        BT_MESH_SENSOR_VALUE_CLAMPED,
        BT_MESH_SENSOR_VALUE_UNKNOWN,
        BT_MESH_SENSOR_VALUE_INVALID,
        BT_MESH_SENSOR_VALUE_MAX_OR_GREATER,
        BT_MESH_SENSOR_VALUE_MIN_OR_LESS,
        BT_MESH_SENSOR_VALUE_TOTAL_DEVICE_LIFE,
};
 
struct bt_mesh_sensor_value {
        const struct bt_mesh_sensor_format *format;
        uint8_t raw[CONFIG_BT_MESH_SENSOR_CHANNEL_ENCODED_SIZE_MAX];
};
 
#define BT_MESH_SENSOR_TOLERANCE_ENCODE(_percent) ((_percent) * 4095) / 100
 
struct bt_mesh_sensor_descriptor {
        struct {
                uint16_t positive:12;
                uint16_t negative:12;
        } tolerance;
        enum bt_mesh_sensor_sampling sampling_type;
        uint64_t period;
        uint64_t update_interval;
};
 
/* Sensor delta triggering values. */
struct bt_mesh_sensor_deltas {
        struct bt_mesh_sensor_value up;
        struct bt_mesh_sensor_value down;
};
 
struct bt_mesh_sensor_threshold {
        struct bt_mesh_sensor_deltas deltas;
 
        struct {
                enum bt_mesh_sensor_cadence cadence;
                struct bt_mesh_sensor_value low;
                struct bt_mesh_sensor_value high;
        } range;
};
 
struct bt_mesh_sensor_column {
        struct bt_mesh_sensor_value start;
        struct bt_mesh_sensor_value width;
};
 
struct bt_mesh_sensor_format_cb {
        bool (*const delta_check)(const struct bt_mesh_sensor_value *current,
                                  const struct bt_mesh_sensor_value *previous,
                                  const struct bt_mesh_sensor_deltas *delta);
 
        int (*const compare)(const struct bt_mesh_sensor_value *op1,
                             const struct bt_mesh_sensor_value *op2);
 
        enum bt_mesh_sensor_value_status (*const to_micro)(
                const struct bt_mesh_sensor_value *sensor_val, int64_t *val);
 
        int (*const from_micro)(
                const struct bt_mesh_sensor_format *format, int64_t val,
                struct bt_mesh_sensor_value *sensor_val);
 
        enum bt_mesh_sensor_value_status (*const to_float)(
                const struct bt_mesh_sensor_value *sensor_val, float *val);
 
        int (*const from_float)(const struct bt_mesh_sensor_format *format,
                                float val,
                                struct bt_mesh_sensor_value *sensor_val);
 
        int (*const from_special_status)(
                const struct bt_mesh_sensor_format *format,
                enum bt_mesh_sensor_value_status status,
                struct bt_mesh_sensor_value *sensor_val);
 
        int (*const to_string)(const struct bt_mesh_sensor_value *sensor_val,
                               char *str, size_t len);
 
        bool (*const value_in_column)(
                const struct bt_mesh_sensor_value *sensor_val,
                const struct bt_mesh_sensor_column *col);
};
 
struct bt_mesh_sensor_format {
        struct bt_mesh_sensor_format_cb *cb;
        void *user_data;
        size_t size;
 
#ifdef CONFIG_BT_MESH_SENSOR_LABELS
        const struct bt_mesh_sensor_unit *unit;
#endif
};
 
struct bt_mesh_sensor_setting {
        const struct bt_mesh_sensor_type *type;
 
        void (*get)(struct bt_mesh_sensor_srv *srv,
                    struct bt_mesh_sensor *sensor,
                    const struct bt_mesh_sensor_setting *setting,
                    struct bt_mesh_msg_ctx *ctx,
                    struct bt_mesh_sensor_value *rsp);
 
        int (*set)(struct bt_mesh_sensor_srv *srv,
                struct bt_mesh_sensor *sensor,
                const struct bt_mesh_sensor_setting *setting,
                struct bt_mesh_msg_ctx *ctx,
                const struct bt_mesh_sensor_value *value);
};
 
struct bt_mesh_sensor_series {
        const struct bt_mesh_sensor_column *columns;
 
        uint32_t column_count;
 
        int (*get)(struct bt_mesh_sensor_srv *srv,
                struct bt_mesh_sensor *sensor,
                struct bt_mesh_msg_ctx *ctx,
                uint32_t column_index,
                struct bt_mesh_sensor_value *value);
};
 
struct bt_mesh_sensor {
        const struct bt_mesh_sensor_type *type;
        const struct bt_mesh_sensor_descriptor *descriptor;
        const struct {
                const struct bt_mesh_sensor_setting *list;
                size_t count;
        } settings;
 
        const struct bt_mesh_sensor_series series;
 
        int (*const get)(struct bt_mesh_sensor_srv *srv,
                         struct bt_mesh_sensor *sensor,
                         struct bt_mesh_msg_ctx *ctx,
                         struct bt_mesh_sensor_value *rsp);
 
        /* Internal state, overwritten on init. Should only be written to by
         * internal modules.
         */
        struct {
                struct bt_mesh_sensor_threshold threshold;
 
                sys_snode_t node;
 
                struct bt_mesh_sensor_value prev;
 
                uint16_t seq;
 
                uint8_t min_int;
 
                uint8_t pub_div : 4;
 
                uint8_t fast_pub : 1;
 
                uint8_t configured : 1;
        } state;
};
 
int bt_mesh_sensor_value_compare(const struct bt_mesh_sensor_value *a,
                                 const struct bt_mesh_sensor_value *b);
 
static inline bool
bt_mesh_sensor_value_status_is_numeric(enum bt_mesh_sensor_value_status status)
{
        return (status == BT_MESH_SENSOR_VALUE_NUMBER ||
                status == BT_MESH_SENSOR_VALUE_CLAMPED ||
                status == BT_MESH_SENSOR_VALUE_MIN_OR_LESS ||
                status == BT_MESH_SENSOR_VALUE_MAX_OR_GREATER);
}
 
enum bt_mesh_sensor_value_status
bt_mesh_sensor_value_to_float(const struct bt_mesh_sensor_value *sensor_val,
                              float *val);
 
int bt_mesh_sensor_value_from_float(const struct bt_mesh_sensor_format *format,
                                    float val,
                                    struct bt_mesh_sensor_value *sensor_val);
 
enum bt_mesh_sensor_value_status
bt_mesh_sensor_value_to_micro(
        const struct bt_mesh_sensor_value *sensor_val,
        int64_t *val);
 
int bt_mesh_sensor_value_from_micro(
        const struct bt_mesh_sensor_format *format,
        int64_t val,
        struct bt_mesh_sensor_value *sensor_val);
 
enum bt_mesh_sensor_value_status
bt_mesh_sensor_value_to_sensor_value(
        const struct bt_mesh_sensor_value *sensor_val,
        struct sensor_value *val);
 
int bt_mesh_sensor_value_from_sensor_value(
        const struct bt_mesh_sensor_format *format,
        const struct sensor_value *val,
        struct bt_mesh_sensor_value *sensor_val);
 
enum bt_mesh_sensor_value_status
bt_mesh_sensor_value_get_status(const struct bt_mesh_sensor_value *sensor_val);
 
int bt_mesh_sensor_value_from_special_status(
        const struct bt_mesh_sensor_format *format,
        enum bt_mesh_sensor_value_status status,
        struct bt_mesh_sensor_value *sensor_val);
 
bool bt_mesh_sensor_value_in_column(const struct bt_mesh_sensor_value *value,
                                    const struct bt_mesh_sensor_column *col);
 
int bt_mesh_sensor_ch_to_str(const struct bt_mesh_sensor_value *ch, char *str,
                             size_t len);
 
const char *bt_mesh_sensor_ch_str(const struct bt_mesh_sensor_value *ch);
 
const struct bt_mesh_sensor_type *bt_mesh_sensor_type_get(uint16_t id);
 
const struct bt_mesh_sensor_format *
bt_mesh_sensor_column_format_get(const struct bt_mesh_sensor_type *type);
 
#define BT_MESH_SENSOR_OP_DESCRIPTOR_GET BT_MESH_MODEL_OP_2(0x82, 0x30)
#define BT_MESH_SENSOR_OP_DESCRIPTOR_STATUS BT_MESH_MODEL_OP_1(0x51)
#define BT_MESH_SENSOR_OP_GET BT_MESH_MODEL_OP_2(0x82, 0x31)
#define BT_MESH_SENSOR_OP_STATUS BT_MESH_MODEL_OP_1(0x52)
#define BT_MESH_SENSOR_OP_COLUMN_GET BT_MESH_MODEL_OP_2(0x82, 0x32)
#define BT_MESH_SENSOR_OP_COLUMN_STATUS BT_MESH_MODEL_OP_1(0x53)
#define BT_MESH_SENSOR_OP_SERIES_GET BT_MESH_MODEL_OP_2(0x82, 0x33)
#define BT_MESH_SENSOR_OP_SERIES_STATUS BT_MESH_MODEL_OP_1(0x54)
#define BT_MESH_SENSOR_OP_CADENCE_GET BT_MESH_MODEL_OP_2(0x82, 0x34)
#define BT_MESH_SENSOR_OP_CADENCE_SET BT_MESH_MODEL_OP_1(0x55)
#define BT_MESH_SENSOR_OP_CADENCE_SET_UNACKNOWLEDGED BT_MESH_MODEL_OP_1(0x56)
#define BT_MESH_SENSOR_OP_CADENCE_STATUS BT_MESH_MODEL_OP_1(0x57)
#define BT_MESH_SENSOR_OP_SETTINGS_GET BT_MESH_MODEL_OP_2(0x82, 0x35)
#define BT_MESH_SENSOR_OP_SETTINGS_STATUS BT_MESH_MODEL_OP_1(0x58)
#define BT_MESH_SENSOR_OP_SETTING_GET BT_MESH_MODEL_OP_2(0x82, 0x36)
#define BT_MESH_SENSOR_OP_SETTING_SET BT_MESH_MODEL_OP_1(0x59)
#define BT_MESH_SENSOR_OP_SETTING_SET_UNACKNOWLEDGED BT_MESH_MODEL_OP_1(0x5A)
#define BT_MESH_SENSOR_OP_SETTING_STATUS BT_MESH_MODEL_OP_1(0x5B)
 
#ifndef CONFIG_BT_MESH_SENSOR_CHANNELS_MAX
#define CONFIG_BT_MESH_SENSOR_CHANNELS_MAX 0
#endif
 
#ifndef CONFIG_BT_MESH_SENSOR_SRV_SENSORS_MAX
#define CONFIG_BT_MESH_SENSOR_SRV_SENSORS_MAX 0
#endif
 
#define BT_MESH_SENSOR_ENCODED_VALUE_MAXLEN                                    \
        (CONFIG_BT_MESH_SENSOR_CHANNELS_MAX *                                  \
         CONFIG_BT_MESH_SENSOR_CHANNEL_ENCODED_SIZE_MAX)
 
#define BT_MESH_SENSOR_STATUS_MAXLEN (3 + BT_MESH_SENSOR_ENCODED_VALUE_MAXLEN)
 
#define BT_MESH_SENSOR_MSG_MINLEN_DESCRIPTOR_GET 0
#define BT_MESH_SENSOR_MSG_MAXLEN_DESCRIPTOR_GET 2
#define BT_MESH_SENSOR_MSG_MINLEN_DESCRIPTOR_STATUS 2
#define BT_MESH_SENSOR_MSG_MAXLEN_DESCRIPTOR_STATUS 8
#define BT_MESH_SENSOR_MSG_MINLEN_GET 0
#define BT_MESH_SENSOR_MSG_MAXLEN_GET 2
#define BT_MESH_SENSOR_MSG_MINLEN_STATUS 0
#define BT_MESH_SENSOR_MSG_MINLEN_COLUMN_GET 2
#define BT_MESH_SENSOR_MSG_MAXLEN_COLUMN_GET                                   \
        (2 + CONFIG_BT_MESH_SENSOR_CHANNEL_ENCODED_SIZE_MAX)
#define BT_MESH_SENSOR_MSG_MINLEN_COLUMN_STATUS 2
#define BT_MESH_SENSOR_MSG_MAXLEN_COLUMN_STATUS                                \
        (2 + CONFIG_BT_MESH_SENSOR_CHANNEL_ENCODED_SIZE_MAX * 3)
#define BT_MESH_SENSOR_MSG_MINLEN_SERIES_GET 2
#define BT_MESH_SENSOR_MSG_MAXLEN_SERIES_GET                                   \
        (2 + 2 * CONFIG_BT_MESH_SENSOR_CHANNEL_ENCODED_SIZE_MAX)
#define BT_MESH_SENSOR_MSG_MINLEN_SERIES_STATUS 2
#define BT_MESH_SENSOR_MSG_LEN_CADENCE_GET 2
#define BT_MESH_SENSOR_MSG_MINLEN_CADENCE_SET 8
#define BT_MESH_SENSOR_MSG_MAXLEN_CADENCE_SET                                  \
        (4 + CONFIG_BT_MESH_SENSOR_CHANNEL_ENCODED_SIZE_MAX * 4)
#define BT_MESH_SENSOR_MSG_MINLEN_CADENCE_STATUS 2
#define BT_MESH_SENSOR_MSG_MAXLEN_CADENCE_STATUS                               \
        (4 + 4 * CONFIG_BT_MESH_SENSOR_CHANNEL_ENCODED_SIZE_MAX)
#define BT_MESH_SENSOR_MSG_LEN_SETTINGS_GET 2
#define BT_MESH_SENSOR_MSG_MINLEN_SETTINGS_STATUS 2
#define BT_MESH_SENSOR_MSG_LEN_SETTING_GET 4
#define BT_MESH_SENSOR_MSG_MINLEN_SETTING_SET 4
#define BT_MESH_SENSOR_MSG_MAXLEN_SETTING_SET                                  \
        (4 + BT_MESH_SENSOR_ENCODED_VALUE_MAXLEN)
#define BT_MESH_SENSOR_MSG_MINLEN_SETTING_STATUS 4
#define BT_MESH_SENSOR_MSG_MAXLEN_SETTING_STATUS                               \
        (4 + BT_MESH_SENSOR_ENCODED_VALUE_MAXLEN)
 
#define BT_MESH_SENSOR_SRV_PUB_MAXLEN(_count)                                  \
        BT_MESH_MODEL_BUF_LEN(BT_MESH_SENSOR_OP_STATUS,                        \
                              MAX(CONFIG_BT_MESH_SENSOR_SRV_SENSORS_MAX,       \
                                  _count) *                                    \
                                      BT_MESH_SENSOR_STATUS_MAXLEN)
 
#define BT_MESH_SENSOR_SETUP_SRV_PUB_MAXLEN                                    \
        MAX(BT_MESH_MODEL_BUF_LEN(BT_MESH_SENSOR_OP_SETTING_STATUS,            \
                                  BT_MESH_SENSOR_MSG_MAXLEN_SETTING_STATUS),   \
            BT_MESH_MODEL_BUF_LEN(BT_MESH_SENSOR_OP_CADENCE_STATUS,            \
                                  BT_MESH_SENSOR_MSG_MAXLEN_CADENCE_STATUS))
#ifdef __cplusplus
}
#endif
 
#endif /* BT_MESH_SENSOR_H__ */