src/accel/accel_sensor.cpp

   1 /*
   2  * sensord
   3  *
   4  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include <common.h>
  21 #include <sf_common.h>
  22
  23 #include <accel_sensor.h>
  24 #include <sensor_plugin_loader.h>
  25 #include <algorithm>
  26
  27 using std::bind1st;
  28 using std::mem_fun;
  29
  30 #define GRAVITY 9.80665
  31 #define G_TO_MG 1000
  32
  33 #define RAW_DATA_TO_G_UNIT(X) (((float)(X))/((float)G_TO_MG))
  34 #define RAW_DATA_TO_METRE_PER_SECOND_SQUARED_UNIT(X) (GRAVITY * (RAW_DATA_TO_G_UNIT(X)))
  35
  36 #define SENSOR_NAME "ACCELEROMETER_SENSOR"
  37
  38 accel_sensor::accel_sensor()
  39 : m_sensor_hal(NULL)
  40 , m_interval(POLL_1HZ_MS)
  41 {
  42         m_name = string(SENSOR_NAME);
  43
  44         vector<unsigned int> supported_events = {
  45                 ACCELEROMETER_EVENT_RAW_DATA_REPORT_ON_TIME,
  46         };
  47
  48         for_each(supported_events.begin(), supported_events.end(),
  49                 bind1st(mem_fun(&sensor_base::register_supported_event), this));
  50
  51         physical_sensor::set_poller(accel_sensor::working, this);
  52 }
  53
  54 accel_sensor::~accel_sensor()
  55 {
  56         INFO("accel_sensor is destroyed!\n");
  57 }
  58
  59 bool accel_sensor::init()
  60 {
  61         m_sensor_hal = sensor_plugin_loader::get_instance().get_sensor_hal(ACCELEROMETER_SENSOR);
  62
  63         if (!m_sensor_hal) {
  64                 ERR("cannot load sensor_hal[%s]", sensor_base::get_name());
  65                 return false;
  66         }
  67
  68         sensor_properties_s properties;
  69
  70         if (m_sensor_hal->get_properties(properties) == false) {
  71                 ERR("sensor->get_properties() is failed!\n");
  72                 return false;
  73         }
  74
  75         m_raw_data_unit = properties.resolution / GRAVITY * G_TO_MG;
  76
  77         INFO("m_raw_data_unit accel : [%f]\n", m_raw_data_unit);
  78
  79         INFO("%s is created!\n", sensor_base::get_name());
  80         return true;
  81 }
  82
  83 sensor_type_t accel_sensor::get_type(void)
  84 {
  85         return ACCELEROMETER_SENSOR;
  86 }
  87
  88 bool accel_sensor::working(void *inst)
  89 {
  90         accel_sensor *sensor = (accel_sensor*)inst;
  91         return sensor->process_event();
  92 }
  93
  94 bool accel_sensor::process_event(void)
  95 {
  96         sensor_event_t base_event;
  97
  98         if (!m_sensor_hal->is_data_ready(true))
  99                 return true;
 100
 101         m_sensor_hal->get_sensor_data(base_event.data);
 102
 103         AUTOLOCK(m_mutex);
 104         AUTOLOCK(m_client_info_mutex);
 105
 106         if (get_client_cnt(ACCELEROMETER_EVENT_RAW_DATA_REPORT_ON_TIME)) {
 107                 base_event.sensor_id = get_id();
 108                 base_event.event_type = ACCELEROMETER_EVENT_RAW_DATA_REPORT_ON_TIME;
 109                 raw_to_base(base_event.data);
 110                 push(base_event);
 111         }
 112
 113         return true;
 114 }
 115
 116 bool accel_sensor::on_start(void)
 117 {
 118         if (!m_sensor_hal->enable()) {
 119                 ERR("m_sensor_hal start fail\n");
 120                 return false;
 121         }
 122
 123         return start_poll();
 124 }
 125
 126 bool accel_sensor::on_stop(void)
 127 {
 128         if (!m_sensor_hal->disable()) {
 129                 ERR("m_sensor_hal stop fail\n");
 130                 return false;
 131         }
 132
 133         return stop_poll();
 134 }
 135
 136 bool accel_sensor::get_properties(sensor_properties_s &properties)
 137 {
 138         return m_sensor_hal->get_properties(properties);
 139 }
 140
 141 int accel_sensor::get_sensor_data(unsigned int type, sensor_data_t &data)
 142 {
 143         if (m_sensor_hal->get_sensor_data(data) < 0) {
 144                 ERR("Failed to get sensor data");
 145                 return -1;
 146         }
 147
 148         if (type == ACCELEROMETER_BASE_DATA_SET) {
 149                 raw_to_base(data);
 150         } else {
 151                 ERR("Does not support type: 0x%x", type);
 152                 return -1;
 153         }
 154
 155         return 0;
 156 }
 157
 158 bool accel_sensor::set_interval(unsigned long interval)
 159 {
 160         AUTOLOCK(m_mutex);
 161
 162         m_interval = interval;
 163
 164         INFO("Polling interval is set to %dms", interval);
 165
 166         return m_sensor_hal->set_interval(interval);
 167 }
 168
 169 void accel_sensor::raw_to_base(sensor_data_t &data)
 170 {
 171         data.value_count = 3;
 172         data.values[0] = RAW_DATA_TO_METRE_PER_SECOND_SQUARED_UNIT(data.values[0] * m_raw_data_unit);
 173         data.values[1] = RAW_DATA_TO_METRE_PER_SECOND_SQUARED_UNIT(data.values[1] * m_raw_data_unit);
 174         data.values[2] = RAW_DATA_TO_METRE_PER_SECOND_SQUARED_UNIT(data.values[2] * m_raw_data_unit);
 175 }
 176
 177 extern "C" void *create(void)
 178 {
 179         accel_sensor *inst;
 180
 181         try {
 182                 inst = new accel_sensor();
 183         } catch (int err) {
 184                 ERR("accel_sensor class create fail , errno : %d , errstr : %s\n", err, strerror(err));
 185                 return NULL;
 186         }
 187
 188         return (void*)inst;
 189 }
 190
 191 extern "C" void destroy(void *inst)
 192 {
 193         delete (accel_sensor*)inst;;
 194 }