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 <zephyr/sensing/sensing.h>
#include <zephyr/device.h>
#include <stdbool.h>
#include <zephyr/drivers/sensor.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;
};
 
struct sensing_sensor_ctx {
 
        void *priv_ptr;
 
        const struct sensing_sensor_register_info *register_info;
 
        void *const sensor_ctx_ptr;
};
 
static inline int sensing_sensor_dev_init(
                const struct device *dev)
{
        return 0;
}
 
#define SENSING_SENSOR_DT_DEFINE(node_id, reg_ptr, ctx_ptr, api_ptr)                    \
        static struct sensing_sensor_ctx                                                        \
                _CONCAT(__sensing_sensor_ctx_, Z_DEVICE_DT_DEV_ID(node_id)) = {         \
                        .register_info = reg_ptr,                                       \
                        .sensor_ctx_ptr = ctx_ptr,                                      \
                };                                                                      \
        DEVICE_DT_DEFINE(node_id, sensing_sensor_dev_init, NULL,                        \
                        &_CONCAT(__sensing_sensor_ctx_, Z_DEVICE_DT_DEV_ID(node_id)),   \
                        NULL, POST_KERNEL, 99, api_ptr)
 
static inline void *sensing_sensor_get_ctx_data(
                const struct device *dev)
{
        struct sensing_sensor_ctx *data = dev->data;
 
        return data->sensor_ctx_ptr;
}
 
int sensing_sensor_post_data(
                const struct device *dev,
                void *buf, int size);
 
int sensing_sensor_get_reporters(
                const struct device *dev, int type,
                const int *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);
 
int sensing_sensor_notify_data_ready(
                const struct device *dev);
 
int sensing_sensor_set_data_ready(
                const struct device *dev, bool data_ready);
 
typedef int (*sensing_sensor_init_t)(
                const struct device *dev, const struct sensing_sensor_info *info,
                const sensing_sensor_handle_t *reporter_handles, int reporters_count);
 
typedef int (*sensing_sensor_deinit_t)(
                const struct device *dev);
 
typedef int (*sensing_sensor_reset_t)(
                const struct device *dev);
 
typedef int (*sensing_sensor_read_sample_t)(
                const struct device *dev,
                void *buf, int size);
 
typedef int (*sensing_sensor_process_t)(
                const struct device *dev,
                int reporter,
                void *buf, int size);
 
typedef int (*sensing_sensor_self_calibration_t)(
                const struct device *dev);
 
typedef int (*sensing_sensor_sensitivity_test_t)(
                const struct device *dev,
                int index, uint32_t sensitivity,
                void *last_sample_buf, int last_sample_size,
                void *current_sample_buf, int current_sample_size);
 
typedef int (*sensing_sensor_set_interval_t)(
                const struct device *dev,
                uint32_t value);
 
typedef int (*sensing_sensor_get_interval_t)(
                const struct device *dev,
                uint32_t *value);
 
typedef int (*sensing_sensor_set_sensitivity_t)(
                const struct device *dev,
                int index, uint32_t value);
 
typedef int (*sensing_sensor_get_sensitivity_t)(
                const struct device *dev,
                int index, uint32_t *value);
 
typedef int (*sensing_sensor_set_range_t)(
                const struct device *dev,
                int index, uint32_t value);
 
typedef int (*sensing_sensor_get_range_t)(
                const struct device *dev,
                int index, uint32_t *value);
 
typedef int (*sensing_sensor_set_fifo_t)(
                const struct device *dev,
                uint32_t samples);
 
typedef int (*sensing_sensor_get_fifo_t)(
                const struct device *dev,
                uint32_t *samples);
 
typedef int (*sensing_sensor_set_offset_t)(
                const struct device *dev,
                int index, int32_t value);
 
typedef int (*sensing_sensor_get_offset_t)(
                const struct device *dev,
                int index, int32_t *value);
struct sensing_sensor_api {
        sensing_sensor_init_t init;
        sensing_sensor_reset_t reset;
        sensing_sensor_deinit_t deinit;
        sensing_sensor_set_interval_t set_interval;
        sensing_sensor_get_interval_t get_interval;
        sensing_sensor_set_range_t set_range;
        sensing_sensor_get_range_t get_range;
        sensing_sensor_set_offset_t set_offset;
        sensing_sensor_get_offset_t get_offset;
        sensing_sensor_get_fifo_t get_fifo;
        sensing_sensor_set_fifo_t set_fifo;
        sensing_sensor_set_sensitivity_t set_sensitivity;
        sensing_sensor_get_sensitivity_t get_sensitivity;
        sensing_sensor_read_sample_t read_sample;
        sensing_sensor_process_t process;
        sensing_sensor_sensitivity_test_t sensitivity_test;
        sensing_sensor_self_calibration_t self_calibration;
};
 
#ifdef __cplusplus
}
#endif
 
#endif /*ZEPHYR_INCLUDE_SENSING_SENSOR_H_*/