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__ */
projects / platform / hal / api / sensor.git / commitdiff