sensing_sensor.h

Go to the documentation of this file.

/*
 * Copyright (c) 2022-2023 Intel Corporation.
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_SENSING_SENSOR_H_
#define ZEPHYR_INCLUDE_SENSING_SENSOR_H_
 
#include <stdbool.h>
#include <zephyr/device.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/sensing/sensing.h>

 
#ifdef __cplusplus
extern "C" {
#endif

struct sensing_sensor_register_info {
        uint16_t flags;

        uint16_t sample_size;

        uint8_t sensitivity_count;

        struct sensing_sensor_version version;
};


enum {
        EVENT_CONFIG_READY, 
        EVENT_SENSOR_POLL,  
};

enum {
        SENSOR_LATER_CFG_BIT, 
        SENSOR_POLL_BIT,      
};

struct sensing_connection {
        sys_snode_t snode;             
        struct sensing_sensor *source; 
        struct sensing_sensor *sink;   
        uint32_t interval;             
        int sensitivity[CONFIG_SENSING_MAX_SENSITIVITY_COUNT];
        void *data;                 
        uint64_t next_consume_time;
        struct sensing_callback_list *callback_list; 
};

struct sensing_sensor {
        const struct device *dev;               
        const struct sensing_sensor_info *info; 
        const struct sensing_sensor_register_info *register_info;
        const uint16_t reporter_num; 
        sys_slist_t client_list;     
        uint32_t interval;           
        uint8_t sensitivity_count;   
        int sensitivity[CONFIG_SENSING_MAX_SENSITIVITY_COUNT];
        enum sensing_sensor_state state;  
        struct rtio_iodev *iodev;         
        struct k_timer timer;             
        struct rtio_sqe *stream_sqe;      
        atomic_t flag;                    
        struct sensing_connection *conns; 
};

#define SENSING_SENSOR_INFO_NAME(node, idx)                                     \
        _CONCAT(_CONCAT(__sensing_sensor_info_, idx), DEVICE_DT_NAME_GET(node))

#define SENSING_SENSOR_INFO_DEFINE(node, idx)                           \
        const static STRUCT_SECTION_ITERABLE(sensing_sensor_info,       \
                        SENSING_SENSOR_INFO_NAME(node, idx)) = {        \
                .type = DT_PROP_BY_IDX(node, sensor_types, idx),        \
                .name = DT_NODE_FULL_NAME(node),                        \
                .friendly_name = DT_PROP(node, friendly_name),          \
                .vendor = DT_NODE_VENDOR_OR(node, NULL),                \
                .model = DT_NODE_MODEL_OR(node, NULL),                  \
                .minimal_interval = DT_PROP(node, minimal_interval),    \
        };

#define SENSING_CONNECTIONS_NAME(node)                                  \
        _CONCAT(__sensing_connections_, DEVICE_DT_NAME_GET(node))

#define SENSING_SENSOR_SOURCE_NAME(idx, node)                           \
        SENSING_SENSOR_NAME(DT_PHANDLE_BY_IDX(node, reporters, idx),    \
                DT_PROP_BY_IDX(node, reporters_index, idx))

#define SENSING_SENSOR_SOURCE_EXTERN(idx, node)                         \
extern struct sensing_sensor SENSING_SENSOR_SOURCE_NAME(idx, node);

#define SENSING_CONNECTION_INITIALIZER(source_name, cb_list_ptr)        \
{                                                                       \
        .callback_list = cb_list_ptr,                                   \
        .source = &source_name,                                         \
}

#define SENSING_CONNECTION_DEFINE(idx, node, cb_list_ptr)               \
        SENSING_CONNECTION_INITIALIZER(SENSING_SENSOR_SOURCE_NAME(idx, node), \
                                       cb_list_ptr)

#define SENSING_CONNECTIONS_DEFINE(node, num, cb_list_ptr)              \
        LISTIFY(num, SENSING_SENSOR_SOURCE_EXTERN,                      \
                                (), node)                               \
        static struct sensing_connection                                \
                        SENSING_CONNECTIONS_NAME(node)[(num)] = {       \
                LISTIFY(num, SENSING_CONNECTION_DEFINE,                 \
                                (,), node, cb_list_ptr)                 \
        };

struct sensing_submit_config {
        enum sensor_channel chan; 
        const int info_index;     
        const bool is_streaming;  
};

extern const struct rtio_iodev_api __sensing_iodev_api;

#define SENSING_SUBMIT_CFG_NAME(node, idx)                                              \
        _CONCAT(_CONCAT(__sensing_submit_cfg_, idx), DEVICE_DT_NAME_GET(node))

#define SENSING_SENSOR_IODEV_NAME(node, idx)                                            \
        _CONCAT(_CONCAT(__sensing_iodev_, idx), DEVICE_DT_NAME_GET(node))

#define SENSING_SENSOR_IODEV_DEFINE(node, idx)                                          \
        static struct sensing_submit_config SENSING_SUBMIT_CFG_NAME(node, idx) = {      \
                .is_streaming = DT_PROP(node, stream_mode),                             \
                .info_index = idx,                                                      \
        };                                                                              \
        RTIO_IODEV_DEFINE(SENSING_SENSOR_IODEV_NAME(node, idx),                         \
                          &__sensing_iodev_api,                                         \
                          &SENSING_SUBMIT_CFG_NAME(node, idx));

#define SENSING_SENSOR_NAME(node, idx)                                  \
        _CONCAT(_CONCAT(__sensing_sensor_, idx), DEVICE_DT_NAME_GET(node))

#define SENSING_SENSOR_DEFINE(node, prop, idx, reg_ptr, cb_list_ptr)    \
        SENSING_SENSOR_INFO_DEFINE(node, idx)                           \
        SENSING_SENSOR_IODEV_DEFINE(node, idx)                          \
        STRUCT_SECTION_ITERABLE(sensing_sensor,                         \
                                SENSING_SENSOR_NAME(node, idx)) = {     \
                .dev = DEVICE_DT_GET(node),                             \
                .info = &SENSING_SENSOR_INFO_NAME(node, idx),           \
                .register_info = reg_ptr,                               \
                .reporter_num = DT_PROP_LEN_OR(node, reporters, 0),     \
                .conns = SENSING_CONNECTIONS_NAME(node),                \
                .iodev = &SENSING_SENSOR_IODEV_NAME(node, idx),         \
        };

#define SENSING_SENSORS_DEFINE(node, reg_ptr, cb_list_ptr)              \
        DT_FOREACH_PROP_ELEM_VARGS(node, sensor_types,                  \
                        SENSING_SENSOR_DEFINE, reg_ptr, cb_list_ptr)


#define SENSING_SENSORS_DT_DEFINE(node, reg_ptr, cb_list_ptr,   \
                                init_fn, pm_device,                     \
                                data_ptr, cfg_ptr, level, prio,         \
                                api_ptr, ...)                           \
        SENSOR_DEVICE_DT_DEFINE(node, init_fn, pm_device,               \
                                data_ptr, cfg_ptr, level, prio,         \
                                api_ptr, __VA_ARGS__);                  \
        SENSING_CONNECTIONS_DEFINE(node,                                \
                                   DT_PROP_LEN_OR(node, reporters, 0),  \
                                   cb_list_ptr);                        \
        SENSING_SENSORS_DEFINE(node, reg_ptr, cb_list_ptr);

#define SENSING_SENSORS_DT_INST_DEFINE(inst, ...)       \
        SENSING_SENSORS_DT_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)

int sensing_sensor_get_reporters(
                const struct device *dev, int type,
                sensing_sensor_handle_t *reporter_handles, int max_handles);

int sensing_sensor_get_reporters_count(
                const struct device *dev, int type);

int sensing_sensor_get_state(
                const struct device *dev,
                enum sensing_sensor_state *state);

 
#ifdef __cplusplus
}
#endif
 
#endif /*ZEPHYR_INCLUDE_SENSING_SENSOR_H_*/