using std::bind1st;
using std::mem_fun;
-#define SENSOR_NAME "PRESSURE_SENSOR"
-#define SENSOR_TYPE_PRESSURE "PRESSURE"
+#define SENSOR_NAME "PRESSURE_SENSOR"
+#define SENSOR_TYPE_PRESSURE "PRESSURE"
#define ELEMENT_NAME "NAME"
#define ELEMENT_VENDOR "VENDOR"
#define ELEMENT_TEMPERATURE_RESOLUTION "TEMPERATURE_RESOLUTION"
#define ELEMENT_TEMPERATURE_OFFSET "TEMPERATURE_OFFSET"
#define ATTR_VALUE "value"
-#define SEA_LEVEL_RESOLUTION 0.01
-#define ALT_CONST1 44330.0
-#define ALT_CONST2 (1.0f/5.255f)
+#define SEA_LEVEL_RESOLUTION 0.01
pressure_sensor::pressure_sensor()
: m_sensor_hal(NULL)
{
m_sensor_hal = sensor_plugin_loader::get_instance().get_sensor_hal(PRESSURE_SENSOR);
- if (!m_sensor_hal)
- {
+ if (!m_sensor_hal) {
ERR("cannot load sensor_hal[%s]", sensor_base::get_name());
return false;
}
sensor_properties_t properties;
- if (m_sensor_hal->get_properties(properties) == false)
- {
+ if (!m_sensor_hal->get_properties(properties)) {
ERR("sensor->get_properties() is failed!\n");
return false;
}
- m_resolution = properties.sensor_resolution;
+ m_resolution = properties.resolution;
string model_id = m_sensor_hal->get_model_id();
double temperature_resolution;
- if (!config.get(SENSOR_TYPE_PRESSURE, model_id, ELEMENT_TEMPERATURE_RESOLUTION, temperature_resolution))
- {
+ if (!config.get(SENSOR_TYPE_PRESSURE, model_id, ELEMENT_TEMPERATURE_RESOLUTION, temperature_resolution)) {
ERR("[TEMPERATURE_RESOLUTION] is empty\n");
throw ENXIO;
}
double temperature_offset;
- if (!config.get(SENSOR_TYPE_PRESSURE, model_id, ELEMENT_TEMPERATURE_OFFSET, temperature_offset))
- {
+ if (!config.get(SENSOR_TYPE_PRESSURE, model_id, ELEMENT_TEMPERATURE_OFFSET, temperature_offset)) {
ERR("[TEMPERATURE_OFFSET] is empty\n");
throw ENXIO;
}
bool pressure_sensor::process_event(void)
{
sensor_event_t event;
- int pressure;
if (!m_sensor_hal->is_data_ready(true))
return true;
AUTOLOCK(m_client_info_mutex);
- if (get_client_cnt(PRESSURE_EVENT_RAW_DATA_REPORT_ON_TIME))
- {
+ if (get_client_cnt(PRESSURE_EVENT_RAW_DATA_REPORT_ON_TIME)) {
+ event.sensor_id = get_id();
event.event_type = PRESSURE_EVENT_RAW_DATA_REPORT_ON_TIME;
raw_to_base(event.data);
push(event);
bool pressure_sensor::on_start(void)
{
- if (!m_sensor_hal->enable())
- {
+ if (!m_sensor_hal->enable()) {
ERR("m_sensor_hal start fail\n");
return false;
}
bool pressure_sensor::on_stop(void)
{
- if (!m_sensor_hal->disable())
- {
+ if (!m_sensor_hal->disable()) {
ERR("m_sensor_hal stop fail\n");
return false;
}
return stop_poll();
}
-bool pressure_sensor::get_properties(const unsigned int type, sensor_properties_t &properties)
+bool pressure_sensor::get_properties(sensor_properties_t &properties)
{
return m_sensor_hal->get_properties(properties);
}
-int pressure_sensor::get_sensor_data(const unsigned int type, sensor_data_t &data)
+int pressure_sensor::get_sensor_data(unsigned int type, sensor_data_t &data)
{
int ret;
if (ret < 0)
return -1;
- if (type == PRESSURE_BASE_DATA_SET)
- {
+ if (type == PRESSURE_BASE_DATA_SET) {
raw_to_base(data);
return 0;
}
float pressure_sensor::pressure_to_altitude(float pressure)
{
- return ALT_CONST1 * (1.0f - pow(pressure/m_sea_level_pressure, ALT_CONST2));
+ return 44330.0f * (1.0f - pow(pressure/m_sea_level_pressure, 1.0f/5.255f));
}
void pressure_sensor::raw_to_base(sensor_data_t &data)
{
m_sea_level_pressure = data.values[1] * SEA_LEVEL_RESOLUTION;
data.values[1] = pressure_to_altitude(data.values[0]);
+ data.value_count = 3;
}
extern "C" void *create(void)
{
pressure_sensor *inst;
- try
- {
+ try {
inst = new pressure_sensor();
- }
- catch (int err)
- {
+ } catch (int err) {
ERR("pressure_sensor class create fail , errno : %d , errstr : %s\n", err, strerror(err));
return NULL;
}
#include <dirent.h>
#include <linux/input.h>
#include <csensor_config.h>
-#include <pressure_sensor_hal.h>
#include <sys/ioctl.h>
+#include <pressure_sensor_hal.h>
#include <fstream>
+#include <string>
#include <iio_common.h>
using std::ifstream;
+using std::string;
using config::csensor_config;
#define SENSOR_TYPE_PRESSURE "PRESSURE"
#define ELEMENT_NAME "NAME"
#define ELEMENT_VENDOR "VENDOR"
#define ELEMENT_RAW_DATA_UNIT "RAW_DATA_UNIT"
+#define ELEMENT_RESOLUTION "RESOLUTION"
#define ELEMENT_MIN_RANGE "MIN_RANGE"
#define ELEMENT_MAX_RANGE "MAX_RANGE"
+#define ELEMENT_TEMPERATURE_RESOLUTION "TEMPERATURE_RESOLUTION"
+#define ELEMENT_TEMPERATURE_OFFSET "TEMPERATURE_OFFSET"
+#define ATTR_VALUE "value"
+
+#define SEA_LEVEL_PRESSURE 101325.0
-#define ENABLE_VAL true
-#define DISABLE_VAL false
-#define SEA_LEVEL_PRESSURE 101325.0
-#define NO_FLAG 0
-#define TIMEOUT 1
+#define EVENT_EN_NODE "events/in_pressure_mag_either_en"
+#define PRESSURE_SCALE "/in_pressure_scale"
+#define PRESSURE_RAW "/in_pressure_raw"
+#define TEMP_OFFSET "/in_temp_offset"
+#define TEMP_SCALE "/in_temp_scale"
+#define TEMP_RAW "/in_temp_raw"
+#define NO_FLAG 0
+#define TIMEOUT 1
pressure_sensor_hal::pressure_sensor_hal()
: m_pressure(0)
, m_temperature(0)
, m_polling_interval(POLL_1HZ_MS)
, m_fired_time(0)
-, m_sensorhub_supported(false)
+, m_node_handle(-1)
{
- int fd, ret;
- string file_name;
+ const string sensorhub_interval_node_name = "pressure_poll_delay";
+ csensor_config &config = csensor_config::get_instance();
- if (!check_hw_node())
- {
- ERR("check_hw_node() fail");
+ node_path_info_query query;
+ node_path_info info;
+ int input_method = IIO_METHOD;
+
+ if (!get_model_properties(SENSOR_TYPE_PRESSURE, m_model_id, input_method)) {
+ ERR("Failed to find model_properties");
throw ENXIO;
+
}
- csensor_config &config = csensor_config::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_PRESSURE;
+ query.input_event_key = "pressure_sensor";
+ query.iio_enable_node_name = EVENT_EN_NODE;
+ query.sensorhub_interval_node_name = sensorhub_interval_node_name;
+
+ if (!get_node_path_info(query, info)) {
+ ERR("Failed to get node info");
+ throw ENXIO;
+ }
+ m_data_node = info.data_node_path;
+ m_pressure_dir = info.base_dir;
+ m_enable_node = info.enable_node_path;
+ m_pressure_node = m_pressure_dir + string(PRESSURE_RAW);
+ m_temp_node = m_pressure_dir + string(TEMP_RAW);
+
+ INFO("m_data_node:%s",m_data_node.c_str());
+ INFO("m_pressure_dir:%s",m_pressure_dir.c_str());
+ INFO("m_enable_node:%s",m_enable_node.c_str());
- if (!config.get(SENSOR_TYPE_PRESSURE, m_model_id, ELEMENT_VENDOR, m_vendor))
- {
+ if (!config.get(SENSOR_TYPE_PRESSURE, m_model_id, ELEMENT_VENDOR, m_vendor)) {
ERR("[VENDOR] is empty\n");
throw ENXIO;
}
INFO("m_vendor = %s", m_vendor.c_str());
- if (!config.get(SENSOR_TYPE_PRESSURE, m_model_id, ELEMENT_NAME, m_chip_name))
- {
+ if (!config.get(SENSOR_TYPE_PRESSURE, m_model_id, ELEMENT_NAME, m_chip_name)) {
ERR("[NAME] is empty\n");
throw ENXIO;
}
double min_range;
- if (!config.get(SENSOR_TYPE_PRESSURE, m_model_id, ELEMENT_MIN_RANGE, min_range))
- {
+ if (!config.get(SENSOR_TYPE_PRESSURE, m_model_id, ELEMENT_MIN_RANGE, min_range)) {
ERR("[MIN_RANGE] is empty\n");
throw ENXIO;
}
double max_range;
- if (!config.get(SENSOR_TYPE_PRESSURE, m_model_id, ELEMENT_MAX_RANGE, max_range))
- {
+ if (!config.get(SENSOR_TYPE_PRESSURE, m_model_id, ELEMENT_MAX_RANGE, max_range)) {
ERR("[MAX_RANGE] is empty\n");
throw ENXIO;
}
double raw_data_unit;
- if (!config.get(SENSOR_TYPE_PRESSURE, m_model_id, ELEMENT_RAW_DATA_UNIT, raw_data_unit))
- {
+ if (!config.get(SENSOR_TYPE_PRESSURE, m_model_id, ELEMENT_RAW_DATA_UNIT, raw_data_unit)) {
ERR("[RAW_DATA_UNIT] is empty\n");
throw ENXIO;
}
m_raw_data_unit = (float)(raw_data_unit);
INFO("m_raw_data_unit = %f\n", m_raw_data_unit);
- file_name = string(IIO_DIR) + m_pressure_dir + string(TEMP_SCALE);
+ string file_name;
+
+ file_name = m_pressure_dir + string(TEMP_SCALE);
if (!read_node_value<int>(file_name, m_temp_scale))
throw ENXIO;
- file_name = string(IIO_DIR) + m_pressure_dir + string(TEMP_OFFSET);
+ file_name = m_pressure_dir + string(TEMP_OFFSET);
if (!read_node_value<float>(file_name, m_temp_offset))
throw ENXIO;
- file_name = string(IIO_DIR) + m_pressure_dir + string(PRESSURE_SCALE);
+ file_name = m_pressure_dir + string(PRESSURE_SCALE);
if (!read_node_value<int>(file_name, m_pressure_scale))
throw ENXIO;
INFO("Temperature offset:%f", m_temp_offset);
INFO("Pressure scale:%d", m_pressure_scale);
- fd = open(m_event_resource.c_str(), NO_FLAG);
- if (fd == -1)
- {
+ int fd, ret;
+ fd = open(m_data_node.c_str(), NO_FLAG);
+ if (fd == -1) {
ERR("Could not open event resource");
throw ENXIO;
}
- ret = ioctl(fd, IOCTL_IIO_EVENT_FD, &m_event_fd);
+ ret = ioctl(fd, IOCTL_IIO_EVENT_FD, &m_node_handle);
close(fd);
- if ((ret == -1) || (m_event_fd == -1))
- {
- ERR("Failed to retrieve event fd");
+ if ((ret == -1) || (m_node_handle == -1)) {
+ ERR("Failed to retrieve node handle from event node: %s", m_data_node.c_str());
throw ENXIO;
}
pressure_sensor_hal::~pressure_sensor_hal()
{
- close(m_event_fd);
+ close(m_node_handle);
+ m_node_handle = -1;
+
INFO("pressure_sensor_hal is destroyed!\n");
}
return PRESSURE_SENSOR;
}
-bool pressure_sensor_hal::enable_resource(bool enable)
-{
- update_sysfs_num(m_enable_resource.c_str(), enable);
- return true;
-}
-
bool pressure_sensor_hal::enable(void)
{
AUTOLOCK(m_mutex);
-
- enable_resource(ENABLE_VAL);
+ update_sysfs_num(m_enable_node.c_str(), true);
+ set_interval(m_polling_interval);
m_fired_time = 0;
INFO("Pressure sensor real starting");
{
AUTOLOCK(m_mutex);
- enable_resource(DISABLE_VAL);
+ update_sysfs_num(m_enable_node.c_str(), false);
INFO("Pressure sensor real stopping");
return true;
bool pressure_sensor_hal::set_interval(unsigned long val)
{
+ INFO("set_interval not supported");
return true;
}
FD_ZERO(&readfds);
FD_ZERO(&exceptfds);
- FD_SET(m_event_fd, &readfds);
- FD_SET(m_event_fd, &exceptfds);
+ FD_SET(m_node_handle, &readfds);
+ FD_SET(m_node_handle, &exceptfds);
- if (wait)
- {
+ if (wait) {
tv.tv_sec = TIMEOUT;
tv.tv_usec = 0;
}
- else
- {
+ else {
tv.tv_sec = 0;
tv.tv_usec = 0;
}
- ret = select(m_event_fd + 1, &readfds, NULL, &exceptfds, &tv);
+ ret = select(m_node_handle + 1, &readfds, NULL, &exceptfds, &tv);
- if (ret == -1)
- {
- ERR("select error:%s m_event_fd:d", strerror(errno), m_event_fd);
+ if (ret == -1) {
+ ERR("select error:%s m_node_handle:d", strerror(errno), m_node_handle);
return false;
}
- else if (!ret)
- {
+ else if (!ret) {
DBG("select timeout");
return false;
}
- if (FD_ISSET(m_event_fd, &exceptfds))
- {
+ if (FD_ISSET(m_node_handle, &exceptfds)) {
ERR("select exception occurred!");
return false;
}
- if (FD_ISSET(m_event_fd, &readfds))
- {
+ if (FD_ISSET(m_node_handle, &readfds)) {
INFO("pressure event detection!");
- int len = read(m_event_fd, &pressure_event, sizeof(pressure_event));
+ int len = read(m_node_handle, &pressure_event, sizeof(pressure_event));
- if (len == -1)
- {
- DBG("Error in read(m_event_fd):%s.", strerror(errno));
+ if (len == -1) {
+ ERR("Error in read(m_event_fd):%s.", strerror(errno));
return false;
}
m_fired_time = pressure_event.timestamp;
m_pressure = ((float)raw_pressure_count)/((float)m_pressure_scale);
m_temperature = m_temp_offset + ((float)raw_temp_count)/((float)m_temp_scale);
}
- else
- {
+ else {
ERR("No pressure event data available to read");
return false;
}
return true;
+
}
bool pressure_sensor_hal::is_data_ready(bool wait)
int pressure_sensor_hal::get_sensor_data(sensor_data_t &data)
{
AUTOLOCK(m_value_mutex);
- data.data_accuracy = SENSOR_ACCURACY_GOOD;
- data.data_unit_idx = SENSOR_UNIT_HECTOPASCAL;
+ data.accuracy = SENSOR_ACCURACY_GOOD;
data.timestamp = m_fired_time ;
- data.values_num = 3;
+ data.value_count = 3;
data.values[0] = m_pressure;
data.values[1] = SEA_LEVEL_PRESSURE;
data.values[2] = m_temperature;
return 0;
}
+
bool pressure_sensor_hal::get_properties(sensor_properties_t &properties)
{
- properties.sensor_unit_idx = SENSOR_UNIT_HECTOPASCAL;
- properties.sensor_min_range = m_min_range;
- properties.sensor_max_range = m_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 = m_raw_data_unit;
+ 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 pressure_sensor_hal::is_sensorhub_supported(void)
-{
- return false;
-}
-
-bool pressure_sensor_hal::check_hw_node(void)
-{
- string name_node;
- string hw_name;
- string file_name;
-
- DIR *main_dir = NULL;
- struct dirent *dir_entry = NULL;
- bool find_node = false;
-
- INFO("======================start check_hw_node=============================\n");
-
- m_sensorhub_supported = is_sensorhub_supported();
-
- main_dir = opendir(IIO_DIR);
-
- if (!main_dir)
- {
- ERR("Could not open IIO directory\n");
- 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 (strncmp(dir_entry->d_name, IIO_DEV_BASE_NAME, IIO_DEV_STR_LEN) == 0)
- {
- if (CConfig::get_instance().is_supported(SENSOR_TYPE_PRESSURE, hw_name) == true)
- {
- m_name = m_model_id = hw_name;
- m_pressure_dir = string(dir_entry->d_name);
- m_enable_resource = string(IIO_DIR) + m_pressure_dir + string(EVENT_DIR) + string(EVENT_EN_NODE);
- m_event_resource = string(DEV_DIR) + m_pressure_dir;
- m_pressure_node = string(IIO_DIR) + m_pressure_dir + string(PRESSURE_RAW);
- m_temp_node = string(IIO_DIR) + m_pressure_dir + string(TEMP_RAW);
-
- INFO("m_enable_resource = %s", m_enable_resource.c_str());
- INFO("m_model_id = %s", m_model_id.c_str());
- INFO("m_pressure_dir = %s", m_pressure_dir.c_str());
- INFO("m_event_resource = %s", m_event_resource.c_str());
-
- find_node = true;
- break;
- }
- }
- }
- }
-
- closedir(main_dir);
- return find_node;
-}
-
extern "C" void *create(void)
{
pressure_sensor_hal *inst;
- try
- {
+ try {
inst = new pressure_sensor_hal();
- }
- catch (int err)
- {
+ } catch (int err) {
ERR("pressure_sensor_hal class create fail , errno : %d , errstr : %s\n", err, strerror(err));
return NULL;
}
projects / platform / core / system / sensord.git / commitdiff