#ifndef _SENSOR_HAL_H_
#define _SENSOR_HAL_H_
+#include <stdint.h>
+#include <string>
+#include <vector>
+#include <sensor_common.h>
+
+#define SENSOR_HAL_VERSION(maj,min) \
+ ((((maj) & 0xffff) << 24) | ((min) & 0xffff))
+
+/*
+ * 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 (%)
+ */
typedef enum {
- SENSOR_HAL_TYPE_ACCELEROMETER,
- SENSOR_HAL_TYPE_GEOMAGNETIC,
+ SENSOR_HAL_TYPE_ALL = -1,
+ SENSOR_HAL_TYPE_UNKNOWN = 0,
+ SENSOR_HAL_TYPE_ACCELEROMETER = 1,
+ SENSOR_HAL_TYPE_MAGNETIC,
SENSOR_HAL_TYPE_LIGHT,
SENSOR_HAL_TYPE_PROXIMITY,
+ SENSOR_HAL_TYPE_THERMOMETER,
SENSOR_HAL_TYPE_GYROSCOPE,
SENSOR_HAL_TYPE_PRESSURE,
+ SENSOR_HAL_TYPE_MOTION,
+ SENSOR_HAL_TYPE_FUSION,
+ SENSOR_HAL_TYPE_PEDOMETER,
SENSOR_HAL_TYPE_CONTEXT,
- SENSOR_HAL_TYPE_BIO,
- SENSOR_HAL_TYPE_BIO_HRM,
+ SENSOR_HAL_TYPE_FLAT,
+ SENSOR_HAL_TYPE_HRM_RAW,
+ SENSOR_HAL_TYPE_HRM,
+ SENSOR_HAL_TYPE_AUTO_ROTATION,
+ SENSOR_HAL_TYPE_GRAVITY,
+ SENSOR_HAL_TYPE_LINEAR_ACCELERATION,
+ SENSOR_HAL_TYPE_ROTATION_VECTOR,
+ SENSOR_HAL_TYPE_ORIENTATION,
+ SENSOR_HAL_TYPE_TILT,
SENSOR_HAL_TYPE_PIR,
SENSOR_HAL_TYPE_PIR_LONG,
SENSOR_HAL_TYPE_TEMPERATURE,
SENSOR_HAL_TYPE_HUMIDITY,
SENSOR_HAL_TYPE_ULTRAVIOLET,
SENSOR_HAL_TYPE_DUST,
- SENSOR_HAL_TYPE_BIO_LED_IR,
- SENSOR_HAL_TYPE_BIO_LED_RED,
- SENSOR_HAL_TYPE_BIO_LED_GREEN,
- SENSOR_HAL_TYPE_RV_RAW,
+ SENSOR_HAL_TYPE_HRM_LED_GREEN,
+ SENSOR_HAL_TYPE_HRM_LED_IR,
+ SENSOR_HAL_TYPE_HRM_LED_RED,
+ SENSOR_HAL_TYPE_ROTATION_VECTOR_RAW,
SENSOR_HAL_TYPE_GYROSCOPE_UNCAL,
SENSOR_HAL_TYPE_GEOMAGNETIC_UNCAL,
- SENSOR_HAL_TYPE_FUSION,
-} sensor_hal_type_t;
+ SENSOR_HAL_TYPE_GYROSCOPE_RV,
+ SENSOR_HAL_TYPE_GEOMAGNETIC_RV,
+
+ SENSOR_HAL_TYPE_ACTIVITY,
+ SENSOR_HAL_TYPE_WALK,
+ SENSOR_HAL_TYPE_RUN,
+ SENSOR_HAL_TYPE_IN_VEHICLE,
+
+ SENSOR_HAL_TYPE_GETSTURE_WRISTUP,
+ SENSOR_HAL_TYPE_GESTURE_WRISTDOWN,
+
+ SENSOR_HAL_TYPE_HUMAN_PEDOMETER,
+ SENSOR_HAL_TYPE_HUMAN_EXERCISE,
+ SENSOR_HAL_TYPE_HUMAN_SLEEP,
+ SENSOR_HAL_TYPE_CUSTOM = 0x50000000,
+} sensor_hal_type;
+/*
+ * A platform sensor handler is generated based on this handle
+ * ID can be assigned from HAL developer. so it has to be unique in HAL.
+ */
+typedef struct sensor_handle_t {
+ uint32_t id;
+ std::string name;
+ sensor_hal_type type;
+ unsigned int event_type; // for Internal API
+} sensor_handle_t;
+/*
+ * Sensor HAL interface
+ * 1 HAL must be abstracted from 1 device event node
+ */
class sensor_hal
{
public:
- sensor_hal(){};
- virtual ~sensor_hal(){};
-
- virtual std::string get_model_id(void) = 0;
- virtual sensor_hal_type_t get_type(void) = 0;
- virtual bool enable(void) = 0;
- virtual bool disable(void) = 0;
- virtual bool is_data_ready(void) = 0;
- virtual bool set_interval(unsigned long val) = 0;
- virtual int get_sensor_data(sensor_data_t &data) = 0;
- virtual bool get_properties(sensor_properties_s &properties) = 0;
+ uint32_t get_hal_version(void) {
+ return SENSOR_HAL_VERSION(1, 0);
+ }
+
+ virtual int get_poll_fd(void) = 0;
+ virtual bool get_sensors(std::vector<sensor_handle_t> &sensors) = 0;
+
+ /* enable/disable sensor device */
+ virtual bool enable(uint32_t id) = 0;
+ virtual bool disable(uint32_t id) = 0;
+
+ /* set_command or set_option? */
+ virtual bool set_command(uint32_t id, std::string command, std::string value) = 0;
+
+ /* the belows can be merged to one */
+ virtual bool set_interval(uint32_t id, unsigned long val) = 0;
+ virtual bool set_batch_latency(uint32_t id, unsigned long val) = 0;
+
+ /* sensor fw read the data when is_data_ready() is true */
+ virtual bool is_data_ready() = 0;
+ virtual bool get_sensor_data(uint32_t id, sensor_data_t &data) = 0;
+
+ /* TODO: use get_sensors() instead of get_properties() */
+ virtual bool get_properties(uint32_t id, sensor_properties_s &properties) = 0;
};
#endif /*_SENSOR_HAL_H_*/
*
*/
#include <fcntl.h>
+#include <unistd.h>
+#include <sys/types.h>
#include <sys/stat.h>
#include <linux/input.h>
#include <csensor_config.h>
#define INPUT_NAME "accelerometer_sensor"
#define ACCEL_SENSORHUB_POLL_NODE_NAME "accel_poll_delay"
+static const sensor_handle_t handles[] = {
+ {
+ id: 0x1,
+ name: "Accelerometer",
+ type: SENSOR_HAL_TYPE_ACCELEROMETER,
+ event_type: (SENSOR_HAL_TYPE_ACCELEROMETER << 16) | 0x0001
+ },
+ {
+ id: 0x2,
+ name: "Accelerometer RAW",
+ type: SENSOR_HAL_TYPE_ACCELEROMETER,
+ event_type: (SENSOR_HAL_TYPE_ACCELEROMETER << 16) | 0x0002
+ }
+};
+
accel_sensor_hal::accel_sensor_hal()
-: m_x(-1)
+: m_node_handle(-1)
+, m_x(-1)
, m_y(-1)
, m_z(-1)
-, m_node_handle(-1)
-, m_polling_interval(POLL_1HZ_MS)
+, m_polling_interval(0)
, m_fired_time(0)
{
const string sensorhub_interval_node_name = "accel_poll_delay";
};
}
- INFO("accel_sensor is created!\n");
+ INFO("accel_sensor_hal is created!\n");
}
accel_sensor_hal::~accel_sensor_hal()
close(m_node_handle);
m_node_handle = -1;
- INFO("accel_sensor is destroyed!\n");
+ INFO("accel_sensor_hal is destroyed!\n");
}
-string accel_sensor_hal::get_model_id(void)
+bool accel_sensor_hal::get_sensors(std::vector<sensor_handle_t> &sensors)
{
- return m_model_id;
-}
+ int size = ARRAY_SIZE(handles);
-sensor_hal_type_t accel_sensor_hal::get_type(void)
-{
- return SENSOR_HAL_TYPE_ACCELEROMETER;
+ for (int i = 0; i < size; ++i)
+ sensors.push_back(handles[i]);
+
+ return true;
}
-bool accel_sensor_hal::enable(void)
+bool accel_sensor_hal::enable(uint32_t id)
{
set_enable_node(m_enable_node, m_sensorhub_controlled, true, SENSORHUB_ACCELEROMETER_ENABLE_BIT);
- set_interval(m_polling_interval);
+ set_interval(id, m_polling_interval);
m_fired_time = 0;
INFO("Accel sensor real starting");
return true;
}
-bool accel_sensor_hal::disable(void)
+bool accel_sensor_hal::disable(uint32_t id)
{
set_enable_node(m_enable_node, m_sensorhub_controlled, false, SENSORHUB_ACCELEROMETER_ENABLE_BIT);
return true;
}
-bool accel_sensor_hal::set_interval(unsigned long val)
+int accel_sensor_hal::get_poll_fd()
+{
+ return m_node_handle;
+}
+
+bool accel_sensor_hal::set_interval(uint32_t id, unsigned long val)
{
unsigned long long polling_interval_ns;
+
polling_interval_ns = ((unsigned long long)(val) * 1000llu * 1000llu);
if (!set_node_value(m_interval_node, polling_interval_ns)) {
return true;
}
-bool accel_sensor_hal::update_value_input_event()
+bool accel_sensor_hal::set_batch_latency(uint32_t id, unsigned long val)
+{
+ return false;
+}
+
+bool accel_sensor_hal::set_command(uint32_t id, std::string command, std::string value)
+{
+ return false;
+}
+
+bool accel_sensor_hal::is_data_ready(void)
+{
+ bool ret;
+ ret = update_value();
+ return ret;
+}
+
+bool accel_sensor_hal::update_value_input_event(void)
{
int accel_raw[3] = {0,};
bool x,y,z;
return true;
}
-bool accel_sensor_hal::update_value_iio()
+bool accel_sensor_hal::update_value_iio(void)
{
const int READ_LEN = 14;
char data[READ_LEN] = {0,};
return true;
}
-bool accel_sensor_hal::is_data_ready(void)
-{
- bool ret;
- ret = update_value();
- return ret;
-}
-
-int accel_sensor_hal::get_sensor_data(sensor_data_t &data)
+bool accel_sensor_hal::get_sensor_data(uint32_t id, sensor_data_t &data)
{
data.accuracy = SENSOR_ACCURACY_GOOD;
data.timestamp = m_fired_time;
data.values[1] = m_y;
data.values[2] = m_z;
- return 0;
+ raw_to_base(data);
+
+ return true;
+}
+
+void accel_sensor_hal::raw_to_base(sensor_data_t &data)
+{
+ data.value_count = 3;
+ data.values[0] = RAW_DATA_TO_METRE_PER_SECOND_SQUARED_UNIT(data.values[0] * m_raw_data_unit);
+ data.values[1] = RAW_DATA_TO_METRE_PER_SECOND_SQUARED_UNIT(data.values[1] * m_raw_data_unit);
+ data.values[2] = RAW_DATA_TO_METRE_PER_SECOND_SQUARED_UNIT(data.values[2] * m_raw_data_unit);
}
-bool accel_sensor_hal::get_properties(sensor_properties_s &properties)
+bool accel_sensor_hal::get_properties(uint32_t id, sensor_properties_s &properties)
{
properties.name = m_chip_name;
properties.vendor = m_vendor;
public:
accel_sensor_hal();
virtual ~accel_sensor_hal();
- std::string get_model_id(void);
- sensor_hal_type_t get_type(void);
- bool enable(void);
- bool disable(void);
- bool set_interval(unsigned long val);
- bool is_data_ready();
- virtual int get_sensor_data(sensor_data_t &data);
- bool get_properties(sensor_properties_s &properties);
+
+ int get_poll_fd(void);
+ bool get_sensors(std::vector<sensor_handle_t> &sensors);
+ bool enable(uint32_t id);
+ bool disable(uint32_t id);
+ bool set_interval(uint32_t id, unsigned long val);
+ bool set_batch_latency(uint32_t id, unsigned long val);
+ bool set_command(uint32_t id, std::string command, std::string value);
+ bool is_data_ready(void);
+ bool get_sensor_data(uint32_t id, sensor_data_t &data);
+ bool get_properties(uint32_t id, sensor_properties_s &properties);
private:
+ int m_node_handle;
int m_x;
int m_y;
int m_z;
- int m_node_handle;
unsigned long m_polling_interval;
unsigned long long m_fired_time;
bool update_value_input_event(void);
bool update_value_iio(void);
+
+ void raw_to_base(sensor_data_t &data);
};
#endif /*_ACCEL_SENSOR_HAL_CLASS_H_*/
projects / platform / adaptation / tm1 / sensor-hal-tm1.git / commitdiff