#include <common.h>
#include <sf_common.h>
+
#include <geo_sensor.h>
#include <sensor_plugin_loader.h>
geo_sensor::geo_sensor()
: m_sensor_hal(NULL)
+, m_resolution(0.0f)
{
m_name = string(SENSOR_NAME);
geo_sensor::~geo_sensor()
{
- INFO("geo_sensor is destroyed!");
+ INFO("geo_sensor is destroyed!\n");
}
bool geo_sensor::init()
return false;
}
- INFO("%s is created!", sensor_base::get_name());
+ sensor_properties_t properties;
+
+ if (m_sensor_hal->get_properties(properties) == false) {
+ ERR("sensor->get_properties() is failed!\n");
+ return false;
+ }
+
+ m_resolution = properties.resolution;
+
+ INFO("%s is created!\n", sensor_base::get_name());
+
return true;
}
bool geo_sensor::working(void *inst)
{
- geo_sensor *sensor = (geo_sensor *)inst;
- return sensor->process_event();
+ geo_sensor *sensor = (geo_sensor*)inst;
+ return sensor->process_event();;
}
bool geo_sensor::process_event(void)
AUTOLOCK(m_mutex);
if (get_client_cnt(GEOMAGNETIC_EVENT_RAW_DATA_REPORT_ON_TIME)) {
+ event.sensor_id = get_id();
event.event_type = GEOMAGNETIC_EVENT_RAW_DATA_REPORT_ON_TIME;
-
+ raw_to_base(event.data);
push(event);
}
bool geo_sensor::on_start(void)
{
- AUTOLOCK(m_mutex);
-
if (!m_sensor_hal->enable()) {
- ERR("m_sensor_hal start fail");
+ ERR("m_sensor_hal start fail\n");
return false;
}
bool geo_sensor::on_stop(void)
{
- AUTOLOCK(m_mutex);
-
if (!m_sensor_hal->disable()) {
- ERR("m_sensor_hal stop fail");
+ ERR("m_sensor_hal stop fail\n");
return false;
}
return stop_poll();
}
-long geo_sensor::set_command(const unsigned int cmd, long value)
-{
- if (m_sensor_hal->set_command(cmd, value) < 0) {
- ERR("m_sensor_hal set_cmd fail");
- return -1;
- }
-
- return 0;
-}
-
-bool geo_sensor::get_properties(const unsigned int type, sensor_properties_t &properties)
+bool geo_sensor::get_properties(sensor_properties_t &properties)
{
return m_sensor_hal->get_properties(properties);
}
-int geo_sensor::get_sensor_data(const unsigned int type, sensor_data_t &data)
+int geo_sensor::get_sensor_data(unsigned int type, sensor_data_t &data)
{
int state;
state = m_sensor_hal->get_sensor_data(data);
if (state < 0) {
- ERR("m_sensor_hal get struct_data fail");
+ ERR("m_sensor_hal get struct_data fail\n");
return -1;
}
AUTOLOCK(m_mutex);
INFO("Polling interval is set to %dms", interval);
+
return m_sensor_hal->set_interval(interval);
}
+void geo_sensor::raw_to_base(sensor_data_t &data)
+{
+ data.value_count = 3;
+ data.values[0] = data.values[0] * m_resolution;
+ data.values[1] = data.values[1] * m_resolution;
+ data.values[2] = data.values[2] * m_resolution;
+}
+
extern "C" void *create(void)
{
geo_sensor *inst;
try {
inst = new geo_sensor();
} catch (int err) {
- ERR("Failed to create geo_sensor class, errno : %d, errstr : %s", err, strerror(err));
+ ERR("geo_sensor class create fail , errno : %d , errstr : %s\n", err, strerror(err));
return NULL;
}
- return (void *)inst;
+ return (void*)inst;
}
extern "C" void destroy(void *inst)
{
- delete (geo_sensor *)inst;
+ delete (geo_sensor*)inst;;
}
/*
- * sensord
+ * geo_sensor_hal
*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
*
* limitations under the License.
*
*/
-
-#include <fstream>
#include <fcntl.h>
#include <sys/stat.h>
-#include <sys/ioctl.h>
#include <dirent.h>
+
#include <linux/input.h>
#include <cconfig.h>
+
#include <geo_sensor_hal.h>
+#include <sys/ioctl.h>
+#include <fstream>
+#include <cconfig.h>
#include <iio_common.h>
using std::ifstream;
-using std::string;
using config::CConfig;
#define SENSOR_TYPE_MAGNETIC "MAGNETIC"
#define ELEMENT_NAME "NAME"
#define ELEMENT_VENDOR "VENDOR"
+#define ELEMENT_RAW_DATA_UNIT "RAW_DATA_UNIT"
+#define ELEMENT_MIN_RANGE "MIN_RANGE"
+#define ELEMENT_MAX_RANGE "MAX_RANGE"
#define ATTR_VALUE "value"
-#define SENSOR_MIN_RANGE -1200
-#define SENSOR_MAX_RANGE 1200
-#define INITIAL_TIME 0
-#define INITIAL_VALUE -1
-#define GAUSS_TO_UTESLA(val) ((val) * 100)
+#define INITIAL_TIME -1
+#define GAUSS_TO_UTESLA(val) ((val) * 100.0f)
geo_sensor_hal::geo_sensor_hal()
-: m_x(INITIAL_VALUE)
-, m_y(INITIAL_VALUE)
-, m_z(INITIAL_VALUE)
+: m_x(0)
+, m_y(0)
+, m_z(0)
+, m_hdst(0)
+, m_node_handle(-1)
, m_polling_interval(POLL_1HZ_MS)
, m_fired_time(INITIAL_TIME)
-, m_sensorhub_supported(false)
{
- if (!check_hw_node())
- {
- ERR("check_hw_node() fail");
+ const string sensorhub_interval_node_name = "mag_poll_delay";
+ CConfig &config = CConfig::get_instance();
+
+ node_path_info_query query;
+ node_path_info info;
+ int input_method = IIO_METHOD;
+
+ if (!get_model_properties(SENSOR_TYPE_MAGNETIC, m_model_id, input_method)) {
+ ERR("Failed to find model_properties");
throw ENXIO;
+
}
- CConfig &config = CConfig::get_instance();
+ query.input_method = input_method;
+ query.sensorhub_controlled = m_sensorhub_controlled = is_sensorhub_controlled(sensorhub_interval_node_name);
+ query.sensor_type = SENSOR_TYPE_MAGNETIC;
+ query.input_event_key = "geomagnetic_sensor";
+ query.iio_enable_node_name = "geomagnetic_enable";
+ query.sensorhub_interval_node_name = sensorhub_interval_node_name;
- if (!config.get(SENSOR_TYPE_MAGNETIC, m_model_id, ELEMENT_VENDOR, m_vendor))
- {
- ERR("[VENDOR] is empty");
+ if (!get_node_path_info(query, info)) {
+ ERR("Failed to get node info");
throw ENXIO;
}
- INFO("m_vendor = %s", m_vendor.c_str());
+ show_node_path_info(info);
+
+ m_data_node = info.data_node_path;
+ m_enable_node = info.enable_node_path;
+ m_interval_node = info.interval_node_path;
+
+ if (input_method == IIO_METHOD) {
+ m_geo_dir = info.base_dir;
+ m_x_node = m_geo_dir + string(X_RAW_VAL_NODE);
+ m_y_node = m_geo_dir + string(Y_RAW_VAL_NODE);
+ m_z_node = m_geo_dir + string(Z_RAW_VAL_NODE);
+ m_x_scale_node = m_geo_dir + string(X_SCALE_NODE);
+ m_y_scale_node = m_geo_dir + string(Y_SCALE_NODE);
+ m_z_scale_node = m_geo_dir + string(Z_SCALE_NODE);
+ INFO("Raw data node X: %s", m_x_node.c_str());
+ INFO("Raw data node Y: %s", m_y_node.c_str());
+ INFO("Raw data node Z: %s", m_z_node.c_str());
+ INFO("scale node X: %s", m_x_scale_node.c_str());
+ INFO("scale node Y: %s", m_y_scale_node.c_str());
+ INFO("scale node Z: %s", m_z_scale_node.c_str());
+ }
- if (!config.get(SENSOR_TYPE_MAGNETIC, m_model_id, ELEMENT_NAME, m_chip_name))
- {
- ERR("[NAME] is empty");
+ if (!config.get(SENSOR_TYPE_MAGNETIC, m_model_id, ELEMENT_VENDOR, m_vendor)) {
+ ERR("[VENDOR] is empty\n");
throw ENXIO;
}
- INFO("m_chip_name = %s", m_chip_name.c_str());
+ INFO("m_vendor = %s", m_vendor.c_str());
- if (!init_resources())
+ if (!config.get(SENSOR_TYPE_MAGNETIC, m_model_id, ELEMENT_NAME, m_chip_name)) {
+ ERR("[NAME] is empty\n");
throw ENXIO;
+ }
- INFO("geo_sensor_hal is created!");
-}
+ init_resources();
+
+ INFO("m_chip_name = %s\n",m_chip_name.c_str());
+ INFO("m_raw_data_unit = %f\n", m_raw_data_unit);
+ INFO("geo_sensor_hal is created!\n");
-geo_sensor_hal::~geo_sensor_hal()
-{
- INFO("geo_sensor_hal is destroyed!");
}
-bool geo_sensor_hal::init_resources(void)
+geo_sensor_hal::~geo_sensor_hal()
{
- ifstream temp_handle;
-
- if (!read_node_value<double>(m_x_scale_node, m_x_scale))
- return false;
-
- if (!read_node_value<double>(m_y_scale_node, m_y_scale))
- return false;
-
- if (!read_node_value<double>(m_z_scale_node, m_z_scale))
- return false;
+ if (m_node_handle > 0)
+ close(m_node_handle);
+ m_node_handle = -1;
- INFO("Scale Values: %f, %f, %f", m_x_scale, m_y_scale, m_z_scale);
- return true;
+ INFO("geo_sensor is destroyed!\n");
}
string geo_sensor_hal::get_model_id(void)
bool geo_sensor_hal::enable(void)
{
- INFO("Resource already enabled. Enable not supported.");
+ m_fired_time = INITIAL_TIME;
+ INFO("Geo sensor real starting");
return true;
}
bool geo_sensor_hal::disable(void)
{
- INFO("Disable not supported.");
+ INFO("Geo sensor real stopping");
return true;
}
{
INFO("Polling interval cannot be changed.");
return true;
+
}
bool geo_sensor_hal::update_value(void)
if (!read_node_value<int>(m_x_node, raw_values[0]))
return false;
-
if (!read_node_value<int>(m_y_node, raw_values[1]))
return false;
-
if (!read_node_value<int>(m_z_node, raw_values[2]))
return false;
m_z = GAUSS_TO_UTESLA(raw_values[2] * m_z_scale);
m_fired_time = INITIAL_TIME;
- INFO("x = %d, y = %d, z = %d, time = %lluus", raw_values[0], raw_values[0], raw_values[0], m_fired_time);
+ INFO("x = %d, y = %d, z = %d, time = %lluus", raw_values[0], raw_values[1], raw_values[2], m_fired_time);
+ INFO("x = %f, y = %f, z = %f, time = %lluus", m_x, m_y, m_z, m_fired_time);
return true;
}
int geo_sensor_hal::get_sensor_data(sensor_data_t &data)
{
- data.data_unit_idx = SENSOR_UNIT_MICRO_TESLA;
+ data.accuracy = SENSOR_ACCURACY_GOOD;
data.timestamp = m_fired_time;
- data.values_num = 3;
+ data.value_count = 3;
data.values[0] = (float)m_x;
data.values[1] = (float)m_y;
data.values[2] = (float)m_z;
bool geo_sensor_hal::get_properties(sensor_properties_t &properties)
{
- properties.sensor_unit_idx = SENSOR_UNIT_MICRO_TESLA;
- properties.sensor_min_range = SENSOR_MIN_RANGE;
- properties.sensor_max_range = SENSOR_MAX_RANGE;
- snprintf(properties.sensor_name, sizeof(properties.sensor_name), "%s", m_chip_name.c_str());
- snprintf(properties.sensor_vendor, sizeof(properties.sensor_vendor), "%s", m_vendor.c_str());
- properties.sensor_resolution = 1;
+ properties.name = m_chip_name;
+ properties.vendor = m_vendor;
+ properties.min_range = m_min_range;
+ properties.max_range = m_max_range;
+ properties.min_interval = 1;
+ properties.resolution = m_raw_data_unit;
+ properties.fifo_count = 0;
+ properties.max_batch_count = 0;
return true;
}
-bool geo_sensor_hal::is_sensorhub_supported(void)
-{
- return false;
-}
-
-bool geo_sensor_hal::check_hw_node(void)
+bool geo_sensor_hal::init_resources(void)
{
- string hw_name;
- string file_name;
- DIR *main_dir = NULL;
- struct dirent *dir_entry = NULL;
- bool find_node = false;
-
- INFO("======================start check_hw_node=============================");
-
- m_sensorhub_supported = is_sensorhub_supported();
- main_dir = opendir(IIO_DIR);
+ ifstream temp_handle;
- if (!main_dir)
- {
- ERR("Could not open IIO directory\n");
+ if (!read_node_value<double>(m_x_scale_node, m_x_scale)) {
+ ERR("Failed to read x scale node");
return false;
}
-
- while (!find_node)
- {
- dir_entry = readdir(main_dir);
- if(dir_entry == NULL)
- break;
-
- if ((strncasecmp(dir_entry->d_name , ".", 1 ) != 0) && (strncasecmp(dir_entry->d_name , "..", 2 ) != 0) && (dir_entry->d_ino != 0))
- {
- file_name = string(IIO_DIR) + string(dir_entry->d_name) + string(NAME_NODE);
- ifstream infile(file_name.c_str());
-
- if (!infile)
- continue;
-
- infile >> hw_name;
-
- if (CConfig::get_instance().is_supported(SENSOR_TYPE_MAGNETIC, hw_name) == true)
- {
- m_name = m_model_id = hw_name;
- INFO("m_model_id = %s", m_model_id.c_str());
-
- string temp = string(IIO_DIR) + string(dir_entry->d_name);
-
- m_x_node = temp + string(X_RAW_VAL_NODE);
- m_y_node = temp + string(Y_RAW_VAL_NODE);
- m_z_node = temp + string(Z_RAW_VAL_NODE);
- m_x_scale_node = temp + string(X_SCALE_NODE);
- m_y_scale_node = temp + string(Y_SCALE_NODE);
- m_z_scale_node = temp + string(Z_SCALE_NODE);
-
- find_node = true;
- break;
- }
- }
+ if (!read_node_value<double>(m_y_scale_node, m_y_scale)) {
+ ERR("Failed to read y scale node");
+ return false;
}
-
- closedir(main_dir);
- return find_node;
+ if (!read_node_value<double>(m_z_scale_node, m_z_scale)) {
+ ERR("Failed to read y scale node");
+ return false;
+ }
+ INFO("Scale Values: %f, %f, %f", m_x_scale, m_y_scale, m_z_scale);
+ return true;
}
extern "C" void *create(void)
{
geo_sensor_hal *inst;
- try
- {
+ try {
inst = new geo_sensor_hal();
- }
- catch (int err)
- {
- ERR("Failed to create geo_sensor_hal class, errno : %d, errstr : %s", err, strerror(err));
+ } catch (int err) {
+ ERR("geo_sensor_hal class create fail , errno : %d , errstr : %s\n", err, strerror(err));
return NULL;
}
- return (void *)inst;
+ return (void*)inst;
}
extern "C" void destroy(void *inst)
{
- delete (geo_sensor_hal *)inst;
+ delete (geo_sensor_hal*)inst;
}
projects / platform / core / system / sensord.git / commitdiff