From: SangYoun Kwak Date: Tue, 26 Nov 2024 09:02:11 +0000 (+0900) Subject: doc: Add documentations for the generating references X-Git-Tag: accepted/tizen/9.0/unified/20250116.154257^0 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=cab0010a6c1d850fe43bc42b941a84ee200bed4a;p=platform%2Fhal%2Fapi%2Fsensor.git doc: Add documentations for the generating references To support the generating references for HAL API, 'hal_sensor_doc.h' is added under the 'doc' directory, which is also newly created. This documentation includes hal api functions for sensor module. Also, appropriate documentations were added to the header files below: * hal-sensor-interface-1.h * hal-sensor-types.h Change-Id: I99b7ce60123c2229aa198aaeb201e4516dc58075 Signed-off-by: SangYoun Kwak --- diff --git a/doc/hal_sensor_doc.h b/doc/hal_sensor_doc.h new file mode 100644 index 0000000..6886747 --- /dev/null +++ b/doc/hal_sensor_doc.h @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2025 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +#ifndef __TIZEN_HAL_SENSOR_DOC_H__ +#define __TIZEN_HAL_SENSOR_DOC_H__ + +/** + * @file hal_sensor_doc.h + * @brief This file contains high level documentation of the HAL sensor. + */ + +/** + * @defgroup HALAPI_HAL_SENSOR_MODULE Sensor + * @brief The @ref HALAPI_HAL_SENSOR_MODULE provides functions for geting/putting backend and creating sensor devices. + * + * @section HALAPI_HAL_SENSOR_MODULE_HEADER Required Header + * \#include + * + * @section HALAPI_HAL_SENSOR_MODULE_OVERVIEW Overview + * The Sensor provides functions to get/put backend. + * - int hal_sensor_get_backend(void); + * - int hal_sensor_put_backend(void); + * + * The Sensor provides creating and deleting functions. + * - int hal_sensor_create(uint64_t **sensor_device_ids, size_t *sensor_device_ids_len); + * - int hal_sensor_delete(uint64_t *sensor_device_ids, size_t sensor_device_ids_len); + * + * For the sensors created by hal_sensor_create, Sensor provides operations. + * + * Functions to get poll fd and sensors: + * - int hal_sensor_get_poll_fd(uint64_t sensor_device_id, int *poll_fd); + * - int hal_sensor_get_sensors(uint64_t sensor_device_id, const sensor_info_t **sensors, size_t *sensors_len); + * + * Functions to manipulate the behavior of sensors: + * - int hal_sensor_enable(uint64_t sensor_device_id, uint32_t id); + * - int hal_sensor_disable(uint64_t sensor_device_id, uint32_t id); + * - int hal_sensor_read_fd(uint64_t sensor_device_id, uint32_t **ids, size_t *ids_len); + * - int hal_sensor_get_data(uint64_t sensor_device_id, uint32_t id, sensor_data_t **data, size_t *length); + * - int hal_sensor_set_interval(uint64_t sensor_device_id, uint32_t id, unsigned long val); + * - int hal_sensor_set_batch_latency(uint64_t sensor_device_id, uint32_t id, unsigned long val); + * + * Functions to get/set attributes of sensors: + * - int hal_sensor_set_attribute_int(uint64_t sensor_device_id, uint32_t id, int32_t attribute, int32_t value); + * - int hal_sensor_set_attribute_str(uint64_t sensor_device_id, uint32_t id, int32_t attribute, const char *value, size_t len); + * - int hal_sensor_get_attribute_int(uint64_t sensor_device_id, uint32_t id, int32_t attribute, int32_t *value); + * - int hal_sensor_get_attribute_str(uint64_t sensor_device_id, uint32_t id, int32_t attribute, char **value, size_t *len); + * + * Function to flush sensor datas: + * - int hal_sensor_flush(uint64_t sensor_device_id, uint32_t id); + */ + +#endif /* __TIZEN_HAL_SENSOR_DOC_H__ */ diff --git a/include/hal-sensor-interface-1.h b/include/hal-sensor-interface-1.h index 0801ebf..f244766 100644 --- a/include/hal-sensor-interface-1.h +++ b/include/hal-sensor-interface-1.h @@ -28,31 +28,49 @@ extern "C" { #endif +/** + * @addtogroup HALAPI_HAL_SENSOR_MODULE + * @{ + */ + +/** + * @brief Structure for sensor device functions. + * @since HAL_MODULE_SENSOR 1.0 + */ typedef struct { - int (*get_poll_fd)(uint32_t sensor_device_id, int *poll_fd); - int (*get_sensors)(uint32_t sensor_device_id, const sensor_info_t **sensors, size_t *sensors_len); + int (*get_poll_fd)(uint32_t sensor_device_id, int *poll_fd); /**< Get poll fd for event listening */ + int (*get_sensors)(uint32_t sensor_device_id, const sensor_info_t **sensors, size_t *sensors_len); /**< Get sensor entities */ - int (*enable)(uint32_t sensor_device_id, uint32_t id); - int (*disable)(uint32_t sensor_device_id, uint32_t id); + int (*enable)(uint32_t sensor_device_id, uint32_t id); /**< Enable this sensor */ + int (*disable)(uint32_t sensor_device_id, uint32_t id); /**< Disable this sensor */ - int (*read_fd)(uint32_t sensor_device_id, uint32_t **ids, size_t *ids_len); - int (*get_data)(uint32_t sensor_device_id, uint32_t id, sensor_data_t **data, size_t *length); + int (*read_fd)(uint32_t sensor_device_id, uint32_t **ids, size_t *ids_len); /**< Read sensor and return event ids */ + int (*get_data)(uint32_t sensor_device_id, uint32_t id, sensor_data_t **data, size_t *length); /**< Get sensor data */ - int (*set_interval)(uint32_t sensor_device_id, uint32_t id, unsigned long val); - int (*set_batch_latency)(uint32_t sensor_device_id, uint32_t id, unsigned long val); - int (*set_attribute_int)(uint32_t sensor_device_id, uint32_t id, int32_t attribute, int32_t value); - int (*set_attribute_str)(uint32_t sensor_device_id, uint32_t id, int32_t attribute, const char *value, size_t len); - int (*get_attribute_int)(uint32_t sensor_device_id, uint32_t id, int32_t attribute, int32_t *value); - int (*get_attribute_str)(uint32_t sensor_device_id, uint32_t id, int32_t attribute, char **value, size_t *len); + int (*set_interval)(uint32_t sensor_device_id, uint32_t id, unsigned long val); /**< Set sensor value interval */ + int (*set_batch_latency)(uint32_t sensor_device_id, uint32_t id, unsigned long val); /**< Set batch latency */ + int (*set_attribute_int)(uint32_t sensor_device_id, uint32_t id, int32_t attribute, int32_t value); /**< Set attribute as an integer value */ + int (*set_attribute_str)(uint32_t sensor_device_id, uint32_t id, int32_t attribute, const char *value, size_t len); /**< Set attribute as a string value */ + int (*get_attribute_int)(uint32_t sensor_device_id, uint32_t id, int32_t attribute, int32_t *value); /**< Get integer attribute value */ + int (*get_attribute_str)(uint32_t sensor_device_id, uint32_t id, int32_t attribute, char **value, size_t *len); /**< Get string attribute value */ - int (*flush)(uint32_t sensor_device_id, uint32_t id); + int (*flush)(uint32_t sensor_device_id, uint32_t id); /**< Flush sensor datas */ } sensor_device_s; +/** + * @brief Structure for sensor functions. + * @since HAL_MODULE_SENSOR 1.0 + */ + typedef struct _hal_backend_sensor_funcs { - int (*create_sensor)(sensor_device_s ***sensor_devices, size_t *sensor_devices_len); - int (*delete_sensor)(uint32_t *sensor_device_ids, size_t sensor_device_ids_len); + int (*create_sensor)(sensor_device_s ***sensor_devices, size_t *sensor_devices_len); /**< Create sensor devices */ + int (*delete_sensor)(uint32_t *sensor_device_ids, size_t sensor_device_ids_len); /**< Delete sensors with their ids */ } hal_backend_sensor_funcs; +/** + * @} + */ + #ifdef __cplusplus } #endif diff --git a/include/hal-sensor-types.h b/include/hal-sensor-types.h index 37d135b..79be7d8 100644 --- a/include/hal-sensor-types.h +++ b/include/hal-sensor-types.h @@ -27,538 +27,606 @@ extern "C" { #endif /* __cplusplus */ -/* - * Sensor Types - * These types are used to controll the sensors - * - * - base unit - * acceleration values : meter per second^2 (m/s^2) - * magnetic values : micro-Tesla (uT) - * orientation values : degrees - * gyroscope values : degree/s - * temperature values : degrees centigrade - * proximity valeus : distance - * light values : lux - * pressure values : hectopascal (hPa) - * humidity : relative humidity (%) +/** + * @addtogroup HALAPI_HAL_SENSOR_MODULE + * @{ + */ + +/** + * @brief Enumeration of sensor types for controlling the sensors + * @since HAL_MODULE_SENSOR 1.0 + * @details Base unit + * - acceleration values : meter per second^2 (m/s^2) + * - magnetic values : micro-Tesla (uT) + * - orientation values : degrees + * - gyroscope values : degree/s + * - temperature values : degrees centigrade + * - proximity values : distance + * - light values : lux + * - pressure values : hectopascal (hPa) + * - humidity : relative humidity (%) */ typedef enum { - SENSOR_DEVICE_UNKNOWN = -2, - SENSOR_DEVICE_ALL = -1, - SENSOR_DEVICE_ACCELEROMETER, - SENSOR_DEVICE_GRAVITY, - SENSOR_DEVICE_LINEAR_ACCELERATION, - SENSOR_DEVICE_GEOMAGNETIC, - SENSOR_DEVICE_ROTATION_VECTOR, - SENSOR_DEVICE_ORIENTATION, - SENSOR_DEVICE_GYROSCOPE, - SENSOR_DEVICE_LIGHT, - SENSOR_DEVICE_PROXIMITY, - SENSOR_DEVICE_PRESSURE, - SENSOR_DEVICE_ULTRAVIOLET, - SENSOR_DEVICE_TEMPERATURE, - SENSOR_DEVICE_HUMIDITY, - SENSOR_DEVICE_HRM, - SENSOR_DEVICE_HRM_LED_GREEN, - SENSOR_DEVICE_HRM_LED_IR, - SENSOR_DEVICE_HRM_LED_RED, - SENSOR_DEVICE_GYROSCOPE_UNCAL, - SENSOR_DEVICE_GEOMAGNETIC_UNCAL, - SENSOR_DEVICE_GYROSCOPE_RV, - SENSOR_DEVICE_GEOMAGNETIC_RV, - - SENSOR_DEVICE_SIGNIFICANT_MOTION = 0x100, - - SENSOR_DEVICE_HRM_BATCH = 0x200, - SENSOR_DEVICE_HRM_LED_GREEN_BATCH, - - SENSOR_DEVICE_HUMAN_PEDOMETER = 0x300, - SENSOR_DEVICE_HUMAN_SLEEP_MONITOR, - SENSOR_DEVICE_HUMAN_SLEEP_DETECTOR, - SENSOR_DEVICE_HUMAN_STRESS_MONITOR, - - SENSOR_DEVICE_LIDAR = 1000, - - SENSOR_DEVICE_EXERCISE_WALKING = 0x400, - SENSOR_DEVICE_EXERCISE_RUNNING, - SENSOR_DEVICE_EXERCISE_HIKING, - SENSOR_DEVICE_EXERCISE_CYCLING, - SENSOR_DEVICE_EXERCISE_ELLIPTICAL, - SENSOR_DEVICE_EXERCISE_INDOOR_CYCLING, - SENSOR_DEVICE_EXERCISE_ROWING, - SENSOR_DEVICE_EXERCISE_STEPPER, - - SENSOR_DEVICE_DATA_JOURNAL = 0x500, - SENSOR_DEVICE_MOTION_SENSOR, - SENSOR_DEVICE_FAKE, - SENSOR_DEVICE_TAP_SENSOR, - SENSOR_DEVICE_COLOR_SENSOR, - SENSOR_DEVICE_WIFI_MOTION_DETECTOR, - - SENSOR_DEVICE_FUSION = 0x900, - SENSOR_DEVICE_AUTO_ROTATION, - SENSOR_DEVICE_AUTO_BRIGHTNESS, - SENSOR_DEVICE_MYOTEST, - - SENSOR_DEVICE_GESTURE_MOVEMENT = 0x1200, - SENSOR_DEVICE_GESTURE_WRIST_UP, - SENSOR_DEVICE_GESTURE_WRIST_DOWN, - SENSOR_DEVICE_GESTURE_MOVEMENT_STATE, - SENSOR_DEVICE_GESTURE_PICK_UP, - SENSOR_DEVICE_GESTURE_FACE_DOWN, - - SENSOR_DEVICE_ACTIVITY_TRACKER = 0x1A00, - SENSOR_DEVICE_ACTIVITY_LEVEL_MONITOR, - SENSOR_DEVICE_GPS_BATCH, - SENSOR_DEVICE_PPG_BATCH, - SENSOR_DEVICE_GPS_TIMESYNC, - - SENSOR_DEVICE_HRM_CTRL = 0x1A80, - SENSOR_DEVICE_REG_CTRL, - SENSOR_DEVICE_GPS_CTRL, - - SENSOR_DEVICE_WEAR_STATUS = 0x2000, - SENSOR_DEVICE_WEAR_ON_MONITOR, - SENSOR_DEVICE_NO_MOVE_DETECTOR, - SENSOR_DEVICE_RESTING_HR, - SENSOR_DEVICE_STEP_LEVEL_MONITOR, - SENSOR_DEVICE_EXERCISE_STANDALONE, - SENSOR_DEVICE_EXERCISE_HR, - SENSOR_DEVICE_WORKOUT, - SENSOR_DEVICE_CYCLE_MONITOR, - SENSOR_DEVICE_STAIR_TRACKER, - SENSOR_DEVICE_PRESSURE_INDICATOR, - SENSOR_DEVICE_PRESSURE_ALERT, - SENSOR_DEVICE_HR_CALORIE, - SENSOR_DEVICE_SWIMMING_TRACKER, - SENSOR_DEVICE_STRESS_TRACKER, - SENSOR_DEVICE_FAKE_MOTION, - SENSOR_DEVICE_GEOFENCE, - SENSOR_DEVICE_SWIMMING_OUTDOOR, - SENSOR_DEVICE_AUTO_SWIMMING, - SENSOR_DEVICE_INACTIVITY_DETECTOR, - SENSOR_DEVICE_HRM_BP, - SENSOR_DEVICE_ECG, - SENSOR_DEVICE_FALL_DETECTION, - - SENSOR_DEVICE_CONTEXT = 0x7000, - SENSOR_DEVICE_MOTION, - SENSOR_DEVICE_PIR, - SENSOR_DEVICE_PIR_LONG, - SENSOR_DEVICE_DUST, - SENSOR_DEVICE_THERMOMETER, - SENSOR_DEVICE_PEDOMETER, - SENSOR_DEVICE_FLAT, - SENSOR_DEVICE_HRM_RAW, - SENSOR_DEVICE_TILT, - SENSOR_DEVICE_ROTATION_VECTOR_RAW, - SENSOR_DEVICE_GSR, - SENSOR_DEVICE_SIMSENSE, - SENSOR_DEVICE_PPG, + SENSOR_DEVICE_UNKNOWN = -2, /**< unknown */ + SENSOR_DEVICE_ALL = -1, /**< all */ + SENSOR_DEVICE_ACCELEROMETER, /**< accelerometer */ + SENSOR_DEVICE_GRAVITY, /**< gravity */ + SENSOR_DEVICE_LINEAR_ACCELERATION, /**< linear acceleration */ + SENSOR_DEVICE_GEOMAGNETIC, /**< geomagnetic */ + SENSOR_DEVICE_ROTATION_VECTOR, /**< rotation vector */ + SENSOR_DEVICE_ORIENTATION, /**< orientation */ + SENSOR_DEVICE_GYROSCOPE, /**< gyroscope */ + SENSOR_DEVICE_LIGHT, /**< light */ + SENSOR_DEVICE_PROXIMITY, /**< proximity */ + SENSOR_DEVICE_PRESSURE, /**< pressure */ + SENSOR_DEVICE_ULTRAVIOLET, /**< ultraviolet */ + SENSOR_DEVICE_TEMPERATURE, /**< temperature */ + SENSOR_DEVICE_HUMIDITY, /**< humidity */ + SENSOR_DEVICE_HRM, /**< HRM */ + SENSOR_DEVICE_HRM_LED_GREEN, /**< HRM led green */ + SENSOR_DEVICE_HRM_LED_IR, /**< HRM led ir */ + SENSOR_DEVICE_HRM_LED_RED, /**< HRM led red */ + SENSOR_DEVICE_GYROSCOPE_UNCAL, /**< gyroscope uncalibrated */ + SENSOR_DEVICE_GEOMAGNETIC_UNCAL, /**< geomagnetic uncalibrated */ + SENSOR_DEVICE_GYROSCOPE_RV, /**< gyroscope RV */ + SENSOR_DEVICE_GEOMAGNETIC_RV, /**< geomagnetic RV */ + + SENSOR_DEVICE_SIGNIFICANT_MOTION = 0x100, /**< significant motion */ + + SENSOR_DEVICE_HRM_BATCH = 0x200, /**< HRM batch */ + SENSOR_DEVICE_HRM_LED_GREEN_BATCH, /**< HRM led green batch */ + + SENSOR_DEVICE_HUMAN_PEDOMETER = 0x300, /**< human pedometer */ + SENSOR_DEVICE_HUMAN_SLEEP_MONITOR, /**< human sleep monitor */ + SENSOR_DEVICE_HUMAN_SLEEP_DETECTOR, /**< human sleep detector */ + SENSOR_DEVICE_HUMAN_STRESS_MONITOR, /**< human stress monitor */ + + SENSOR_DEVICE_LIDAR = 1000, /**< lidar */ + + SENSOR_DEVICE_EXERCISE_WALKING = 0x400, /**< exercise walking */ + SENSOR_DEVICE_EXERCISE_RUNNING, /**< exercise running */ + SENSOR_DEVICE_EXERCISE_HIKING, /**< exercise hiking */ + SENSOR_DEVICE_EXERCISE_CYCLING, /**< exercise cycling */ + SENSOR_DEVICE_EXERCISE_ELLIPTICAL, /**< exercise elliptical */ + SENSOR_DEVICE_EXERCISE_INDOOR_CYCLING, /**< exercise indoor cycling */ + SENSOR_DEVICE_EXERCISE_ROWING, /**< exercise rowing */ + SENSOR_DEVICE_EXERCISE_STEPPER, /**< exercise stepper */ + + SENSOR_DEVICE_DATA_JOURNAL = 0x500, /**< data journal */ + SENSOR_DEVICE_MOTION_SENSOR, /**< motion sensor */ + SENSOR_DEVICE_FAKE, /**< fake */ + SENSOR_DEVICE_TAP_SENSOR, /**< tap sensor */ + SENSOR_DEVICE_COLOR_SENSOR, /**< color sensor */ + SENSOR_DEVICE_WIFI_MOTION_DETECTOR, /**< wifi motion detector */ + + SENSOR_DEVICE_FUSION = 0x900, /**< fusion */ + SENSOR_DEVICE_AUTO_ROTATION, /**< auto rotation */ + SENSOR_DEVICE_AUTO_BRIGHTNESS, /**< auto brightness */ + SENSOR_DEVICE_MYOTEST, /**< myotest */ + + SENSOR_DEVICE_GESTURE_MOVEMENT = 0x1200, /**< gesture movement */ + SENSOR_DEVICE_GESTURE_WRIST_UP, /**< gesture wrist up */ + SENSOR_DEVICE_GESTURE_WRIST_DOWN, /**< gesture wrist down */ + SENSOR_DEVICE_GESTURE_MOVEMENT_STATE, /**< gesture movement state */ + SENSOR_DEVICE_GESTURE_PICK_UP, /**< gesture pick up */ + SENSOR_DEVICE_GESTURE_FACE_DOWN, /**< gesture face down */ + + SENSOR_DEVICE_ACTIVITY_TRACKER = 0x1A00, /**< activity tracker */ + SENSOR_DEVICE_ACTIVITY_LEVEL_MONITOR, /**< activity level monitor */ + SENSOR_DEVICE_GPS_BATCH, /**< GPS batch */ + SENSOR_DEVICE_PPG_BATCH, /**< PPG batch */ + SENSOR_DEVICE_GPS_TIMESYNC, /**< GPS timesync */ + + SENSOR_DEVICE_HRM_CTRL = 0x1A80, /**< HRM control */ + SENSOR_DEVICE_REG_CTRL, /**< reg control */ + SENSOR_DEVICE_GPS_CTRL, /**< GPS control */ + + SENSOR_DEVICE_WEAR_STATUS = 0x2000, /**< wear status */ + SENSOR_DEVICE_WEAR_ON_MONITOR, /**< wear on monitor */ + SENSOR_DEVICE_NO_MOVE_DETECTOR, /**< no move detector */ + SENSOR_DEVICE_RESTING_HR, /**< resting HR */ + SENSOR_DEVICE_STEP_LEVEL_MONITOR, /**< step level monitor */ + SENSOR_DEVICE_EXERCISE_STANDALONE, /**< exercise standalone */ + SENSOR_DEVICE_EXERCISE_HR, /**< exercise HR */ + SENSOR_DEVICE_WORKOUT, /**< workout */ + SENSOR_DEVICE_CYCLE_MONITOR, /**< cycle monitor */ + SENSOR_DEVICE_STAIR_TRACKER, /**< stair tracker */ + SENSOR_DEVICE_PRESSURE_INDICATOR, /**< pressure indicator */ + SENSOR_DEVICE_PRESSURE_ALERT, /**< pressure alert */ + SENSOR_DEVICE_HR_CALORIE, /**< HR calorie */ + SENSOR_DEVICE_SWIMMING_TRACKER, /**< swimming tracker */ + SENSOR_DEVICE_STRESS_TRACKER, /**< stress tracker */ + SENSOR_DEVICE_FAKE_MOTION, /**< fake motion */ + SENSOR_DEVICE_GEOFENCE, /**< geofence */ + SENSOR_DEVICE_SWIMMING_OUTDOOR, /**< swimming outdoor */ + SENSOR_DEVICE_AUTO_SWIMMING, /**< auto swimming */ + SENSOR_DEVICE_INACTIVITY_DETECTOR, /**< inactivity detector */ + SENSOR_DEVICE_HRM_BP, /**< HRM BP */ + SENSOR_DEVICE_ECG, /**< ECG */ + SENSOR_DEVICE_FALL_DETECTION, /**< fall detection */ + + SENSOR_DEVICE_CONTEXT = 0x7000, /**< context */ + SENSOR_DEVICE_MOTION, /**< motion */ + SENSOR_DEVICE_PIR, /**< PIR */ + SENSOR_DEVICE_PIR_LONG, /**< PIR long */ + SENSOR_DEVICE_DUST, /**< dust */ + SENSOR_DEVICE_THERMOMETER, /**< thermometer */ + SENSOR_DEVICE_PEDOMETER, /**< pedometer */ + SENSOR_DEVICE_FLAT, /**< flat */ + SENSOR_DEVICE_HRM_RAW, /**< HRM raw */ + SENSOR_DEVICE_TILT, /**< tilt */ + SENSOR_DEVICE_ROTATION_VECTOR_RAW, /**< rotation vector raw */ + SENSOR_DEVICE_GSR, /**< GSR */ + SENSOR_DEVICE_SIMSENSE, /**< simsense */ + SENSOR_DEVICE_PPG, /**< PPG */ } sensor_device_type; -/* - * A platform sensor handler is generated based on this handle - * This id can be assigned from HAL developer. so it has to be unique in 1 - * sensor_device. +/** + * @brief Structure for sensor information data. + * @since HAL_MODULE_SENSOR 1.0 + * @details A platform sensor handler is generated based on this handle.\n + * The 'id' can be assigned from HAL developer, so it has to be \n + * unique per a sensor_device. */ typedef struct sensor_info_t { - uint32_t id; - const char *name; - int type; // sensor_device_type - unsigned int event_type; // for Internal API - const char *model_name; - const char *vendor; - float min_range; - float max_range; - float resolution; - int min_interval; - int max_interval; - int max_batch_count; - bool wakeup_supported; + uint32_t id; /**< Sensor id */ + const char *name; /**< Sensor name */ + int type; /**< Sensor type(sensor_device_type) */ + unsigned int event_type; /**< Event type for Internal API */ + const char *model_name; /**< Model name of sensor */ + const char *vendor; /**< Vendor of sensor */ + float min_range; /**< Minimum range of sensor value */ + float max_range; /**< Maximum range of sensor value */ + float resolution; /**< Resolution of sensor value */ + int min_interval; /**< Minimum interval of sensor value retrieval */ + int max_interval; /**< Maximum interval of sensor value retrieval */ + int max_batch_count; /**< Minimum batch count */ + bool wakeup_supported; /**< Support wakeup or not */ } sensor_info_t; +/** + * @brief Enumeration for sensor accuracy + * @since HAL_MODULE_SENSOR 1.0 + */ enum sensor_accuracy_t { - SENSOR_ACCURACY_UNDEFINED = -1, - SENSOR_ACCURACY_BAD = 0, - SENSOR_ACCURACY_NORMAL = 1, - SENSOR_ACCURACY_GOOD = 2, - SENSOR_ACCURACY_VERYGOOD = 3 + SENSOR_ACCURACY_UNDEFINED = -1, /**< Undefined accuracy */ + SENSOR_ACCURACY_BAD = 0, /**< Bad accuracy */ + SENSOR_ACCURACY_NORMAL = 1, /**< Normal accuracy */ + SENSOR_ACCURACY_GOOD = 2, /**< Good accuracy */ + SENSOR_ACCURACY_VERYGOOD = 3 /**< Very good accuracy */ }; +/** + * @brief Definition of sensor data value size + * @since HAL_MODULE_SENSOR 1.0 + */ #define SENSOR_DATA_VALUE_SIZE 16 -/* sensor_data_t */ +/** + * @brief Structure for sensor data + * @since HAL_MODULE_SENSOR 1.0 + */ typedef struct sensor_data_t { - int accuracy; - unsigned long long timestamp; - int value_count; - float values[SENSOR_DATA_VALUE_SIZE]; + int accuracy; /**< Accuracy of value */ + unsigned long long timestamp; /**< Timestamp of value */ + int value_count; /**< Number of values provided */ + float values[SENSOR_DATA_VALUE_SIZE]; /**< Sensor values(array) */ } sensor_data_t; +/** + * @brief Definition of sensorhub data value size + * @since HAL_MODULE_SENSOR 1.0 + */ #define SENSORHUB_DATA_VALUE_SIZE 4096 -/* sensorhub_data_t */ +/** + * @brief Structure of sensorhub data + * @since HAL_MODULE_SENSOR 1.0 + */ typedef struct sensorhub_data_t { - int accuracy; - unsigned long long timestamp; + int accuracy; /**< Accuracy of value */ + unsigned long long timestamp; /**< Timestamp of value */ - /* - * Use "value_count" instead of "hub_data_size" - * which is going to be removed soon + /** + * @brief Union of number of values + * @since HAL_MODULE_SENSOR 1.0 + * @details Use "value_count" instead of "hub_data_size"(will be removed soon) */ union { - int value_count; - int hub_data_size; /* deprecated */ + int value_count; /**< Number of values */ + int hub_data_size; /**< Number of values (deprecated) */ }; - /* - * Use "values" instead of "hub_data" - * which is going to be removed soon + /** + * @brief Union of values + * @since HAL_MODULE_SENSOR 1.0 + * @details Use "values" instead of "hub_data"(will be removed soon) */ union { - char values[SENSORHUB_DATA_VALUE_SIZE]; - char hub_data[SENSORHUB_DATA_VALUE_SIZE]; /* deprecated */ + char values[SENSORHUB_DATA_VALUE_SIZE]; /**< Values of sensorhub */ + char hub_data[SENSORHUB_DATA_VALUE_SIZE]; /**< Values of sensorhub (deprecated) */ }; } sensorhub_data_t; +/** + * @brief Definition of pedometer data difference array size + * @since HAL_MODULE_SENSOR 1.0 + */ #define SENSOR_PEDOMETER_DATA_DIFFS_SIZE 20 +/** + * @brief Structure of pedometer data + * @since HAL_MODULE_SENSOR 1.0 + */ typedef struct { - int accuracy; - unsigned long long timestamp; - int value_count; /* value_count == 8 */ + int accuracy; /**< Accuracy of value */ + unsigned long long timestamp; /**< Timestamp of value */ + int value_count; /**< Number of values */ + /** + * Values of pedometer sensor + * values = {step count, walk step count, run step count, + * moving distance, calorie burned, last speed, + * last stepping frequency (steps per sec), + * last step status (walking, running, ...)} + */ float values[SENSOR_DATA_VALUE_SIZE]; - /* values = {step count, walk step count, run step count, - moving distance, calorie burned, last speed, - last stepping frequency (steps per sec), - last step status (walking, running, ...)} */ - /* Additional data attributes (not in sensor_data_t)*/ + /** + * Number of struct differences + * Additional data attributes (not in sensor_data_t) + */ int diffs_count; + /** + * @brief Structure of differences of pedometer data + * @since HAL_MODULE_SENSOR 1.0 + * @details Additional data attributes (not in sensor_data_t) + */ struct differences { - int timestamp; - int steps; - int walk_steps; - int run_steps; - int walk_up_steps; - int walk_down_steps; - int run_up_steps; - int run_down_steps; - float distance; - float calories; - float speed; - } diffs[SENSOR_PEDOMETER_DATA_DIFFS_SIZE]; + int timestamp; /**< Timestamp of difference */ + int steps; /**< Difference of steps */ + int walk_steps; /**< Difference of walk steps */ + int run_steps; /**< Difference of run steps */ + int walk_up_steps; /**< Difference of walk up steps */ + int walk_down_steps; /**< Difference of walk down steps */ + int run_up_steps; /**< Difference of run up steps */ + int run_down_steps; /**< Difference of run down steps */ + float distance; /**< Difference of distance */ + float calories; /**< Difference of calories */ + float speed; /**< Difference of speed */ + } diffs[SENSOR_PEDOMETER_DATA_DIFFS_SIZE]; /**< Array of differences of pedometer data */ } sensor_pedometer_data_t; #define CONVERT_TYPE_ATTR(type, index) ((type) << 8 | 0x80 | (index)) +/** + * @brief Structure for attributes of sensor + * @since HAL_MODULE_SENSOR 1.0 + */ enum sensor_attribute { SENSOR_ATTR_ACCELEROMETER_INJECTION = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_ACCELEROMETER, 0xFF), - SENSOR_ATTR_ACTIVITY = CONVERT_TYPE_ATTR(SENSOR_DEVICE_ACTIVITY_TRACKER, 0x1), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_ACCELEROMETER, 0xFF), /**< accelerometer injection */ + SENSOR_ATTR_ACTIVITY = CONVERT_TYPE_ATTR(SENSOR_DEVICE_ACTIVITY_TRACKER, 0x1), /**< activity */ SENSOR_ATTR_HRM_BATCH_OPR_MODE = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_BATCH, 0x1), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_BATCH, 0x1), /**< HRM batch opr mode */ SENSOR_ATTR_HRM_BATCH_ACTIVITY_TYPE = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_BATCH, 0x2), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_BATCH, 0x2), /**< HRM batch activity type */ SENSOR_ATTR_HRM_BATCH_BATCH_DUR = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_BATCH, 0x3), - SENSOR_ATTR_HRM_BATCH_FLUSH = CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_BATCH, 0x4), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_BATCH, 0x3), /**< HRM batch batch dur */ + SENSOR_ATTR_HRM_BATCH_FLUSH = CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_BATCH, 0x4), /**< HRM batch flush */ SENSOR_ATTR_HRM_BATCH_ELEVATED_DUR = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_BATCH, 0x5), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_BATCH, 0x5), /**< HRM batch elevated dur */ SENSOR_ATTR_HRM_BATCH_ELEVATED_THR = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_BATCH, 0x6), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_BATCH, 0x6), /**< HRM batch elevated thr */ SENSOR_ATTR_HRM_BATCH_BPM_RAW = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_BATCH, 0x7), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_BATCH, 0x7), /**< HRM batch bpm raw */ SENSOR_ATTR_HRM_BATCH_LOW_ALERT_DUR = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_BATCH, 0x8), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_BATCH, 0x8), /**< HRM batch low alert dur */ SENSOR_ATTR_HRM_BATCH_LOW_ALERT_THR = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_BATCH, 0x9), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_BATCH, 0x9), /**< HRM batch low alert thr */ SENSOR_ATTR_HRM_LED_GREEN_BATCH_POLLING_INTERVAL = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_LED_GREEN_BATCH, 0x1), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_LED_GREEN_BATCH, 0x1), /**< HRM led green batch polling interval */ SENSOR_ATTR_HRM_LED_GREEN_BATCH_FLUSH = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_LED_GREEN_BATCH, 0x2), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_LED_GREEN_BATCH, 0x2), /**< HRM led green batch flush */ SENSOR_ATTR_HRM_LED_GREEN_BATCH_BATCH_PERIOD = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_LED_GREEN_BATCH, 0x3), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_LED_GREEN_BATCH, 0x3), /**< HRM led green batch batch period */ SENSOR_ATTR_PEDOMETER_HEIGHT = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_PEDOMETER, 0x1), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_PEDOMETER, 0x1), /**< pedometer height */ SENSOR_ATTR_PEDOMETER_WEIGHT = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_PEDOMETER, 0x2), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_PEDOMETER, 0x2), /**< pedometer weight */ SENSOR_ATTR_PEDOMETER_GENDER = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_PEDOMETER, 0x3), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_PEDOMETER, 0x3), /**< pedometer gender */ SENSOR_ATTR_PEDOMETER_AGE = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_PEDOMETER, 0x4), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_PEDOMETER, 0x4), /**< pedometer age */ SENSOR_ATTR_PEDOMETER_FLUSH = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_PEDOMETER, 0x2F), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_PEDOMETER, 0x2F), /**< pedometer flush */ SENSOR_ATTR_STRESS_MONITOR_AGE = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_STRESS_MONITOR, 0x1), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_STRESS_MONITOR, 0x1), /**< stress monitor age */ SENSOR_ATTR_EXERCISE_TYPE = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_STANDALONE, 0x1), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_STANDALONE, 0x1), /**< exercise type */ SENSOR_ATTR_EXERCISE_GPS = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_STANDALONE, 0x2), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_STANDALONE, 0x2), /**< exercise GPS */ SENSOR_ATTR_EXERCISE_BATCH_INTERVAL = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_STANDALONE, 0x3), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_STANDALONE, 0x3), /**< exercise batch interval */ SENSOR_ATTR_EXERCISE_PSERVICE = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_STANDALONE, 0x4), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_STANDALONE, 0x4), /**< exercise pservice */ SENSOR_ATTR_CYCLE_DURATION = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_CYCLE_MONITOR, 0x1), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_CYCLE_MONITOR, 0x1), /**< cycle duration */ SENSOR_ATTR_CYCLE_HOLDING_POSITION = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_CYCLE_MONITOR, 0x2), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_CYCLE_MONITOR, 0x2), /**< cycle holding position */ SENSOR_ATTR_CYCLE_VELOCITY = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_CYCLE_MONITOR, 0x3), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_CYCLE_MONITOR, 0x3), /**< cycle velocity */ SENSOR_ATTR_CYCLE_GET_DATA_TYPE = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_CYCLE_MONITOR, 0x4), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_CYCLE_MONITOR, 0x4), /**< cycle get data type */ SENSOR_ATTR_CYCLE_DATA_FLUSH = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_CYCLE_MONITOR, 0x5), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_CYCLE_MONITOR, 0x5), /**< cycle data flush */ SENSOR_ATTR_CYCLE_GPS_AGREEMENT = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_CYCLE_MONITOR, 0x6), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_CYCLE_MONITOR, 0x6), /**< cycle GPS agreement */ - SENSOR_ATTR_WORKOUT_TYPE = CONVERT_TYPE_ATTR(SENSOR_DEVICE_WORKOUT, 0x1), - SENSOR_ATTR_WORKOUT_DURATION = CONVERT_TYPE_ATTR(SENSOR_DEVICE_WORKOUT, 0x2), + SENSOR_ATTR_WORKOUT_TYPE = CONVERT_TYPE_ATTR(SENSOR_DEVICE_WORKOUT, 0x1), /**< workout type */ + SENSOR_ATTR_WORKOUT_DURATION = CONVERT_TYPE_ATTR(SENSOR_DEVICE_WORKOUT, 0x2), /**< workout duration */ SENSOR_ATTR_RESTING_HR_OPR_MODE = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x1), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x1), /**< resting HR opr mode */ SENSOR_ATTR_RESTING_HR_MAX_RHR = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x2), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x2), /**< resting HR max rhr */ SENSOR_ATTR_RESTING_HR_MIN_RHR = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x3), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x3), /**< resting HR min rhr */ SENSOR_ATTR_RESTING_HR_AVG_RHR = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x4), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x4), /**< resting HR avg rhr */ SENSOR_ATTR_RESTING_HR_HOUR = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x5), - SENSOR_ATTR_RESTING_HR_MIN = CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x6), - SENSOR_ATTR_RESTING_HR_SEC = CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x7), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x5), /**< resting HR hour */ + SENSOR_ATTR_RESTING_HR_MIN = CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x6), /**< resting HR min */ + SENSOR_ATTR_RESTING_HR_SEC = CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x7), /**< resting HR sec */ SENSOR_ATTR_RESTING_HR_PROPERTY_TYPE = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x10), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x10), /**< resting HR property type */ SENSOR_ATTR_RESTING_HR_PROPERTY_HR_TYPE = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x11), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x11), /**< resting HR property HR type */ SENSOR_ATTR_RESTING_HR_PROPERTY_HR_VALUE = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x12), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x12), /**< resting HR property HR value */ SENSOR_ATTR_RESTING_HR_PROPERTY_DURATION = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x13), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x13), /**< resting HR property duration */ SENSOR_ATTR_RESTING_HR_PROPERTY_ACT_TYPE = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x14), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x14), /**< resting HR property act type */ SENSOR_ATTR_RESTING_HR_PROPERTY_ACT_DUR = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x15), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x15), /**< resting HR property act dur */ SENSOR_ATTR_RESTING_HR_PROPERTY_CONT_DUR = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x16), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x16), /**< resting HR property cont dur */ SENSOR_ATTR_RESTING_HR_DATA_TYPE = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x20), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x20), /**< resting HR data type */ SENSOR_ATTR_RESTING_HR_DATA_FLUSH = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x21), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x21), /**< resting HR data flush */ SENSOR_ATTR_STEP_LEVEL_MONITOR_DW_DURATION = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_STEP_LEVEL_MONITOR, 0x1), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_STEP_LEVEL_MONITOR, 0x1), /**< step level monitor dw duration */ SENSOR_ATTR_EXERCISE_HR_OPR_MODE = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_HR, 0x1), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_HR, 0x1), /**< exercise HR opr mode */ SENSOR_ATTR_EXERCISE_HR_ACTIVITY_TYPE = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_HR, 0x2), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_HR, 0x2), /**< exercise HR activity type */ SENSOR_ATTR_EXERCISE_HR_BATCH_DUR = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_HR, 0x3), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_HR, 0x3), /**< exercise HR batch dur */ SENSOR_ATTR_EXERCISE_HR_FLUSH = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_HR, 0x4), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_HR, 0x4), /**< exercise HR flush */ SENSOR_ATTR_EXERCISE_HR_ELEVATED_DUR = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_HR, 0x5), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_HR, 0x5), /**< exercise HR elevated dur */ SENSOR_ATTR_EXERCISE_HR_ELEVATED_THR = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_HR, 0x6), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_HR, 0x6), /**< exercise HR elevated thr */ SENSOR_ATTR_EXERCISE_HR_BPM_RAW = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_HR, 0x7), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_HR, 0x7), /**< exercise HR bpm raw */ SENSOR_ATTR_EXERCISE_HR_LOW_ALERT_DUR = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_HR, 0x8), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_HR, 0x8), /**< exercise HR low alert dur */ SENSOR_ATTR_EXERCISE_HR_LOW_ALERT_THR = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_HR, 0x9), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_HR, 0x9), /**< exercise HR low alert thr */ SENSOR_ATTR_PRESSURE_INDICATOR_START = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_PRESSURE_INDICATOR, 0x1), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_PRESSURE_INDICATOR, 0x1), /**< pressure indicator start */ SENSOR_ATTR_PRESSURE_INDICATOR_STOP = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_PRESSURE_INDICATOR, 0x2), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_PRESSURE_INDICATOR, 0x2), /**< pressure indicator stop */ SENSOR_ATTR_PRESSURE_INDICATOR_FLUSH = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_PRESSURE_INDICATOR, 0x3), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_PRESSURE_INDICATOR, 0x3), /**< pressure indicator flush */ SENSOR_ATTR_PRESSURE_INDICATOR_RESTORE_TIME = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_PRESSURE_INDICATOR, 0x4), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_PRESSURE_INDICATOR, 0x4), /**< pressure indicator restore time */ SENSOR_ATTR_PRESSURE_INDICATOR_RESTORE_VALUE = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_PRESSURE_INDICATOR, 0x5), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_PRESSURE_INDICATOR, 0x5), /**< pressure indicator restore value */ SENSOR_ATTR_PRESSURE_INDICATOR_CURRENT_TIME = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_PRESSURE_INDICATOR, 0x6), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_PRESSURE_INDICATOR, 0x6), /**< pressure indicator current time */ SENSOR_ATTR_PRESSURE_ALERT_START = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_PRESSURE_ALERT, 0x1), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_PRESSURE_ALERT, 0x1), /**< pressure alert start */ SENSOR_ATTR_PRESSURE_ALERT_STOP = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_PRESSURE_ALERT, 0x2), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_PRESSURE_ALERT, 0x2), /**< pressure alert stop */ - SENSOR_ATTR_HR_CALORIE_AGE = CONVERT_TYPE_ATTR(SENSOR_DEVICE_HR_CALORIE, 0x1), + SENSOR_ATTR_HR_CALORIE_AGE = CONVERT_TYPE_ATTR(SENSOR_DEVICE_HR_CALORIE, 0x1), /**< HR calorie age */ SENSOR_ATTR_HR_CALORIE_HEIGHT = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HR_CALORIE, 0x2), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HR_CALORIE, 0x2), /**< HR calorie height */ SENSOR_ATTR_HR_CALORIE_WEIGHT = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HR_CALORIE, 0x3), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HR_CALORIE, 0x3), /**< HR calorie weight */ SENSOR_ATTR_HR_CALORIE_GENDER = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HR_CALORIE, 0x4), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HR_CALORIE, 0x4), /**< HR calorie gender */ SENSOR_ATTR_HR_CALORIE_INST = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HR_CALORIE, 0x10), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HR_CALORIE, 0x10), /**< HR calorie inst */ SENSOR_ATTR_HR_CALORIE_EXERCISE_TYPE = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HR_CALORIE, 0x11), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HR_CALORIE, 0x11), /**< HR calorie exercise type */ SENSOR_ATTR_HR_CALORIE_TARGET_CAL = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HR_CALORIE, 0x12), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HR_CALORIE, 0x12), /**< HR calorie target cal */ SENSOR_ATTR_HR_CALORIE_MAX_HEARTRATE = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HR_CALORIE, 0x13), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HR_CALORIE, 0x13), /**< HR calorie max heartrate */ SENSOR_ATTR_HR_CALORIE_FLUSH = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HR_CALORIE, 0x20), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HR_CALORIE, 0x20), /**< HR calorie flush */ SENSOR_ATTR_SWIMMING_TRACKER_PLACE = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_TRACKER, 0x1), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_TRACKER, 0x1), /**< swimming tracker place */ SENSOR_ATTR_SWIMMING_TRACKER_DISTANCE = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_TRACKER, 0x2), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_TRACKER, 0x2), /**< swimming tracker distance */ SENSOR_ATTR_SWIMMING_TRACKER_FLUSH = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_TRACKER, 0x3), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_TRACKER, 0x3), /**< swimming tracker flush */ SENSOR_ATTR_SWIMMING_TRACKER_BATCH = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_TRACKER, 0x4), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_TRACKER, 0x4), /**< swimming tracker batch */ SENSOR_ATTR_SWIMMING_TRACKER_GOAL_CALORIES = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_TRACKER, 0x5), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_TRACKER, 0x5), /**< swimming tracker goal calories */ SENSOR_ATTR_SWIMMING_TRACKER_GOAL_LAPS = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_TRACKER, 0x6), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_TRACKER, 0x6), /**< swimming tracker goal laps */ SENSOR_ATTR_SWIMMING_TRACKER_TIME_REST = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_TRACKER, 0x7), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_TRACKER, 0x7), /**< swimming tracker time rest */ SENSOR_ATTR_SWIMMING_TRACKER_TIME_TURN = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_TRACKER, 0x8), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_TRACKER, 0x8), /**< swimming tracker time turn */ SENSOR_ATTR_SWIMMING_OUTDOOR_SET_BATCH_LAP_COUNT = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_OUTDOOR, 0x1), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_OUTDOOR, 0x1), /**< swimming outdoor set batch lap count */ SENSOR_ATTR_SWIMMING_OUTDOOR_SETGOAL_LENGTH = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_OUTDOOR, 0x2), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_OUTDOOR, 0x2), /**< swimming outdoor setgoal length */ SENSOR_ATTR_SWIMMING_OUTDOOR_SETGOAL_TIME = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_OUTDOOR, 0x3), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_OUTDOOR, 0x3), /**< swimming outdoor setgoal time */ SENSOR_ATTR_SWIMMING_OUTDOOR_SET_GPS_PERMISSION = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_OUTDOOR, 0x4), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_OUTDOOR, 0x4), /**< swimming outdoor set GPS permission */ SENSOR_ATTR_SWIMMING_OUTDOOR_FLUSH = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_OUTDOOR, 0x6), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_OUTDOOR, 0x6), /**< swimming outdoor flush */ SENSOR_ATTR_AUTO_SWIMMING_DURATION = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_AUTO_SWIMMING, 0x1), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_AUTO_SWIMMING, 0x1), /**< auto swimming duration */ SENSOR_ATTR_INACTIVITY_DETECTOR_LEVEL = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_INACTIVITY_DETECTOR, 0x1), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_INACTIVITY_DETECTOR, 0x1), /**< inactivity detector level */ SENSOR_ATTR_INACTIVITY_DETECTOR_DURATION = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_INACTIVITY_DETECTOR, 0x2), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_INACTIVITY_DETECTOR, 0x2), /**< inactivity detector duration */ SENSOR_ATTR_STRESS_TRACKER_DUR = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_STRESS_TRACKER, 0x1), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_STRESS_TRACKER, 0x1), /**< stress tracker dur */ SENSOR_ATTR_STRESS_TRACKER_FLUSH = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_STRESS_TRACKER, 0x2), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_STRESS_TRACKER, 0x2), /**< stress tracker flush */ SENSOR_ATTR_STRESS_MONITOR_BASE_HR = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_STRESS_MONITOR, 0x1), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_STRESS_MONITOR, 0x1), /**< stress monitor base HR */ SENSOR_ATTR_STRESS_MONITOR_HISTO_INDEX = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_STRESS_MONITOR, 0x2), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_STRESS_MONITOR, 0x2), /**< stress monitor histo index */ SENSOR_ATTR_STRESS_MONITOR_HISTO_VALUE = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_STRESS_MONITOR, 0x3), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_STRESS_MONITOR, 0x3), /**< stress monitor histo value */ SENSOR_ATTR_STRESS_MONITOR_TUNE_INDEX = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_STRESS_MONITOR, 0x4), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_STRESS_MONITOR, 0x4), /**< stress monitor tune index */ SENSOR_ATTR_STRESS_MONITOR_TUNE_VALUE = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_STRESS_MONITOR, 0x5), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_STRESS_MONITOR, 0x5), /**< stress monitor tune value */ SENSOR_ATTR_STRESS_MONITOR_FLUSH = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_STRESS_MONITOR, 0x6), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_STRESS_MONITOR, 0x6), /**< stress monitor flush */ SENSOR_ATTR_STRESS_MONITOR_OPERATION = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_STRESS_MONITOR, 0x7), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_STRESS_MONITOR, 0x7), /**< stress monitor operation */ SENSOR_ATTR_SLEEP_MONITOR_STOP = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_SLEEP_MONITOR, 0x1), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_SLEEP_MONITOR, 0x1), /**< sleep monitor stop */ SENSOR_ATTR_SLEEP_MONITOR_FLUSH = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_SLEEP_MONITOR, 0x2), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_SLEEP_MONITOR, 0x2), /**< sleep monitor flush */ SENSOR_ATTR_SLEEP_DETECTOR_STOP = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_SLEEP_DETECTOR, 0x1), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_SLEEP_DETECTOR, 0x1), /**< sleep detector stop */ SENSOR_ATTR_SLEEP_DETECTOR_SETTING = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_SLEEP_DETECTOR, 0x2), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_SLEEP_DETECTOR, 0x2), /**< sleep detector setting */ SENSOR_ATTR_DATA_JOURNAL_START = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_DATA_JOURNAL, 0x1), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_DATA_JOURNAL, 0x1), /**< data journal start */ SENSOR_ATTR_DATA_JOURNAL_STOP = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_DATA_JOURNAL, 0x2), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_DATA_JOURNAL, 0x2), /**< data journal stop */ SENSOR_ATTR_GPS_BATCH_OPR_MODE = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_GPS_BATCH, 0x1), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_GPS_BATCH, 0x1), /**< GPS batch opr mode */ SENSOR_ATTR_PPG_BATCH_POLLING_INTERVAL = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_PPG_BATCH, 0x1), - SENSOR_ATTR_PPG_BATCH_FLUSH = CONVERT_TYPE_ATTR(SENSOR_DEVICE_PPG_BATCH, 0x2), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_PPG_BATCH, 0x1), /**< PPG batch polling interval */ + SENSOR_ATTR_PPG_BATCH_FLUSH = CONVERT_TYPE_ATTR(SENSOR_DEVICE_PPG_BATCH, 0x2), /**< PPG batch flush */ - SENSOR_ATTR_REG_CTRL_TYPE = CONVERT_TYPE_ATTR(SENSOR_DEVICE_REG_CTRL, 0x1), - SENSOR_ATTR_REG_CTRL_ADDRESS = CONVERT_TYPE_ATTR(SENSOR_DEVICE_REG_CTRL, 0x2), - SENSOR_ATTR_REG_CTRL_VALUE = CONVERT_TYPE_ATTR(SENSOR_DEVICE_REG_CTRL, 0x3), - SENSOR_ATTR_REG_CTRL_MODE = CONVERT_TYPE_ATTR(SENSOR_DEVICE_REG_CTRL, 0x4), + SENSOR_ATTR_REG_CTRL_TYPE = CONVERT_TYPE_ATTR(SENSOR_DEVICE_REG_CTRL, 0x1), /**< reg control type */ + SENSOR_ATTR_REG_CTRL_ADDRESS = CONVERT_TYPE_ATTR(SENSOR_DEVICE_REG_CTRL, 0x2), /**< reg control address */ + SENSOR_ATTR_REG_CTRL_VALUE = CONVERT_TYPE_ATTR(SENSOR_DEVICE_REG_CTRL, 0x3), /**< reg control value */ + SENSOR_ATTR_REG_CTRL_MODE = CONVERT_TYPE_ATTR(SENSOR_DEVICE_REG_CTRL, 0x4), /**< reg control mode */ - SENSOR_ATTR_GPS_CTRL_SETTING = CONVERT_TYPE_ATTR(SENSOR_DEVICE_GPS_CTRL, 0x1), + SENSOR_ATTR_GPS_CTRL_SETTING = CONVERT_TYPE_ATTR(SENSOR_DEVICE_GPS_CTRL, 0x1), /**< GPS control setting */ SENSOR_ATTR_FAKE_MOTION_EVENT_INTERVAL = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_FAKE_MOTION, 0x1), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_FAKE_MOTION, 0x1), /**< fake motion event interval */ SENSOR_ATTR_FAKE_MOTION_EVENT_COUNT = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_FAKE_MOTION, 0x2), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_FAKE_MOTION, 0x2), /**< fake motion event count */ SENSOR_ATTR_FAKE_MOTION_PAUSE_INTERVAL = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_FAKE_MOTION, 0x3), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_FAKE_MOTION, 0x3), /**< fake motion pause interval */ - SENSOR_ATTR_GEOFENCE_ID = CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x1), - SENSOR_ATTR_GEOFENCE_LAT = CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x2), - SENSOR_ATTR_GEOFENCE_LON = CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x3), - SENSOR_ATTR_GEOFENCE_RADIUS = CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x4), + SENSOR_ATTR_GEOFENCE_ID = CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x1), /**< geofence id */ + SENSOR_ATTR_GEOFENCE_LAT = CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x2), /**< geofence lat */ + SENSOR_ATTR_GEOFENCE_LON = CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x3), /**< geofence lon */ + SENSOR_ATTR_GEOFENCE_RADIUS = CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x4), /**< geofence radius */ SENSOR_ATTR_GEOFENCE_PROVIDER = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x5), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x5), /**< geofence provider */ SENSOR_ATTR_GEOFENCE_ACCURACY = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x6), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x6), /**< geofence accuracy */ SENSOR_ATTR_GEOFENCE_TIMESTAMP = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x7), - SENSOR_ATTR_GEOFENCE_CONNECT = CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x8), - SENSOR_ATTR_GEOFENCE_START = CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x10), - SENSOR_ATTR_GEOFENCE_STOP = CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x11), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x7), /**< geofence timestamp */ + SENSOR_ATTR_GEOFENCE_CONNECT = CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x8), /**< geofence connect */ + SENSOR_ATTR_GEOFENCE_START = CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x10), /**< geofence start */ + SENSOR_ATTR_GEOFENCE_STOP = CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x11), /**< geofence stop */ SENSOR_ATTR_GEOFENCE_SET_LOCATION = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x12), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x12), /**< geofence set location */ SENSOR_ATTR_GEOFENCE_BT_CONNECT = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x13), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x13), /**< geofence bt connect */ SENSOR_ATTR_FALL_DETECTION_OPR_MODE = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_FALL_DETECTION, 0x1), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_FALL_DETECTION, 0x1), /**< fall detection opr mode */ HAL_SENSOR_ATTR_PROXIMITY_SENSITIVITY_LEVEL = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_PROXIMITY, 0x1), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_PROXIMITY, 0x1), /**< attr proximity sensitivity level */ HAL_SENSOR_ATTR_LIDAR_POWER_STATE = - CONVERT_TYPE_ATTR(SENSOR_DEVICE_LIDAR, 0x1), + CONVERT_TYPE_ATTR(SENSOR_DEVICE_LIDAR, 0x1), /**< attr lidar power state */ }; +/** + * @brief Enumeration for common attributes of sensor + * @since HAL_MODULE_SENSOR 1.0 + */ enum sensor_attribute_common { - SENSOR_ATTR_COMMON_START = 0x1000000, - SENSOR_ATTR_POWER_STATE = SENSOR_ATTR_COMMON_START + 10001, + SENSOR_ATTR_COMMON_START = 0x1000000, /**< Start of enum */ + SENSOR_ATTR_POWER_STATE = SENSOR_ATTR_COMMON_START + 10001, /**< Power state */ }; +/** + * @brief Enumeration for activity + * @since HAL_MODULE_SENSOR 1.0 + */ enum sensor_activity { - SENSOR_ACTIVITY_UNKNOWN = 1, - SENSOR_ACTIVITY_STILL = 2, - SENSOR_ACTIVITY_WALKING = 4, - SENSOR_ACTIVITY_RUNNING = 8, - SENSOR_ACTIVITY_IN_VEHICLE = 16, - SENSOR_ACTIVITY_ON_BICYCLE = 32, + SENSOR_ACTIVITY_UNKNOWN = 1, /**< Unknown activity */ + SENSOR_ACTIVITY_STILL = 2, /**< Still */ + SENSOR_ACTIVITY_WALKING = 4, /**< Walking */ + SENSOR_ACTIVITY_RUNNING = 8, /**< Running */ + SENSOR_ACTIVITY_IN_VEHICLE = 16, /**< In vehicle */ + SENSOR_ACTIVITY_ON_BICYCLE = 32, /**< On bicycle */ }; -/* HAL_SENSOR_ATTR_PROXIMITY_SENSITIVITY_LEVEL attribute value */ +/** + * @brief Enumeration(hal) for sensitivity level of proximity sensor + * @since HAL_MODULE_SENSOR 1.0 + * @details HAL_SENSOR_ATTR_PROXIMITY_SENSITIVITY_LEVEL attribute value + */ enum hal_sensor_proximity_sensitivity_level { - HAL_SENSOR_PROXIMITY_SENSITIVITY_LEVEL_WEAK = 1, - HAL_SENSOR_PROXIMITY_SENSITIVITY_LEVEL_MEDIUM = 2, - HAL_SENSOR_PROXIMITY_SENSITIVITY_LEVEL_STRONG = 3 + HAL_SENSOR_PROXIMITY_SENSITIVITY_LEVEL_WEAK = 1, /**< Weak */ + HAL_SENSOR_PROXIMITY_SENSITIVITY_LEVEL_MEDIUM = 2, /**< Medium */ + HAL_SENSOR_PROXIMITY_SENSITIVITY_LEVEL_STRONG = 3 /**< Strong */ }; -/* HAL_SENSOR_ATTR_LIDAR_POWER_STATE attribute value */ +/** + * @brief Enumeration(hal) for power state of lidar + * @since HAL_MODULE_SENSOR 1.0 + * @details HAL_SENSOR_ATTR_LIDAR_POWER_STATE attribute value + */ enum hal_sensor_lidar_power_state { - HAL_SENSOR_LIDAR_POWER_STATE_OFF = 0, - HAL_SENSOR_LIDAR_POWER_STATE_ON = 1 + HAL_SENSOR_LIDAR_POWER_STATE_OFF = 0, /**< Off */ + HAL_SENSOR_LIDAR_POWER_STATE_ON = 1 /**< On */ }; +/** + * @} + */ + #ifdef __cplusplus } - #endif /* __cplusplus */ #endif /* __HAL_SENSOR_TYPES__ */