Renaming uncal_gyro sensor to gyro_uncal sensor

Change-Id: Ib504e2ba4984c2a1631e09ed4abdf88e90470ec3

diff --git a/packaging/sensord.spec b/packaging/sensord.spec
old mode 100644 (file)
new mode 100755 (executable)
index cd89022..8bba933
--- a/packaging/sensord.spec
+++ b/packaging/sensord.spec
@@ -28,7 +28,7 @@ BuildRequires:  pkgconfig(cynara-session)
 %define geomagnetic_rv_state OFF
 %define gaming_rv_state OFF
 %define tilt_state OFF
-%define uncal_gyro_state OFF
+%define gyroscope_uncal_state OFF
 %define build_test_suite ON
 
 %description
@@ -78,7 +78,7 @@ cmake . -DCMAKE_INSTALL_PREFIX=%{_prefix} \
        -DORIENTATION=%{orientation_state} -DGRAVITY=%{gravity_state} \
        -DLINEAR_ACCEL=%{linear_accel_state} -DRV=%{rv_state} \
        -DGEOMAGNETIC_RV=%{geomagnetic_rv_state} -DGAMING_RV=%{gaming_rv_state} \
-       -DUNCAL_GYRO=%{uncal_gyro_state} -DAUTO_ROTATION=%{auto_rotation_state} \
+       -DGYROSCOPE_UNCAL=%{gyroscope_uncal_state} -DAUTO_ROTATION=%{auto_rotation_state} \
        -DTILT=%{tilt_state} -DTEST_SUITE=%{build_test_suite} \
        -DLIBDIR=%{_libdir} -DINCLUDEDIR=%{_includedir}
 

diff --git a/src/client/client_common.cpp b/src/client/client_common.cpp
index ecbcf1f..51ad05a 100755 (executable)
--- a/src/client/client_common.cpp
+++ b/src/client/client_common.cpp
@@ -45,7 +45,7 @@ log_element g_log_elements[] = {
        FILL_LOG_ELEMENT(LOG_ID_SENSOR_TYPE, GAMING_RV_SENSOR, 0, 1),
        FILL_LOG_ELEMENT(LOG_ID_SENSOR_TYPE, FUSION_SENSOR, 0, 1),
        FILL_LOG_ELEMENT(LOG_ID_SENSOR_TYPE, TILT_SENSOR, 0, 1),
-       FILL_LOG_ELEMENT(LOG_ID_SENSOR_TYPE, UNCAL_GYROSCOPE_SENSOR, 0, 1),
+       FILL_LOG_ELEMENT(LOG_ID_SENSOR_TYPE, GYROSCOPE_UNCAL_SENSOR, 0, 1),
        FILL_LOG_ELEMENT(LOG_ID_SENSOR_TYPE, ULTRAVIOLET_SENSOR, 0, 1),
        FILL_LOG_ELEMENT(LOG_ID_SENSOR_TYPE, BIO_LED_RED_SENSOR, 0, 1),
 
@@ -70,7 +70,7 @@ log_element g_log_elements[] = {
        FILL_LOG_ELEMENT(LOG_ID_EVENT, GAMING_RV_RAW_DATA_EVENT, 0, 10),
        FILL_LOG_ELEMENT(LOG_ID_EVENT, FUSION_EVENT, 0, 10),
        FILL_LOG_ELEMENT(LOG_ID_EVENT, TILT_RAW_DATA_EVENT, 0, 10),
-       FILL_LOG_ELEMENT(LOG_ID_EVENT, UNCAL_GYRO_RAW_DATA_EVENT, 0, 10),
+       FILL_LOG_ELEMENT(LOG_ID_EVENT, GYROSCOPE_UNCAL_RAW_DATA_EVENT, 0, 10),
        FILL_LOG_ELEMENT(LOG_ID_EVENT, ULTRAVIOLET_RAW_DATA_EVENT, 0, 10),
        FILL_LOG_ELEMENT(LOG_ID_EVENT, BIO_LED_RED_RAW_DATA_EVENT, 0, 10),
 };

diff --git a/src/server/plugins/CMakeLists.txt b/src/server/plugins/CMakeLists.txt
index 971fe9b..d2bfdbc 100755 (executable)
--- a/src/server/plugins/CMakeLists.txt
+++ b/src/server/plugins/CMakeLists.txt
@@ -74,9 +74,9 @@ IF("${TILT}" STREQUAL "ON")
 set(SENSOR_FUSION_ENABLE "1")
 set(TILT_ENABLE "1")
 ENDIF()
-IF("${UNCAL_GYRO}" STREQUAL "ON")
+IF("${GYROSCOPE_UNCAL}" STREQUAL "ON")
 set(SENSOR_FUSION_ENABLE "1")
-set(UNCAL_GYRO_ENABLE "1")
+set(GYROSCOPE_UNCAL_ENABLE "1")
 ENDIF()
 IF("${GRAVITY}" STREQUAL "ON")
 set(SENSOR_FUSION_ENABLE "1")
@@ -124,10 +124,10 @@ list (APPEND DIR_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/tilt")
 list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/tilt/tilt_sensor.cpp")
 list (APPEND PLUGIN_DEFS "-DENABLE_TILT")
 ENDIF()
-IF("${UNCAL_GYRO_ENABLE}" STREQUAL "1")
-list (APPEND DIR_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/uncal_gyro")
-list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/uncal_gyro/uncal_gyro_sensor.cpp")
-list (APPEND PLUGIN_DEFS "-DENABLE_UNCAL_GYRO")
+IF("${GYROSCOPE_UNCAL_ENABLE}" STREQUAL "1")
+list (APPEND DIR_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/gyroscope_uncal")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/gyroscope_uncal/gyroscope_uncal_sensor.cpp")
+list (APPEND PLUGIN_DEFS "-DENABLE_GYROSCOPE_UNCAL")
 ENDIF()
 IF("${RV_ENABLE}" STREQUAL "1")
 list (APPEND DIR_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/rotation_vector/rv")

diff --git a/src/server/plugins/fusion/fusion_sensor.cpp b/src/server/plugins/fusion/fusion_sensor.cpp
index 86449a1..669f330 100755 (executable)
--- a/src/server/plugins/fusion/fusion_sensor.cpp
+++ b/src/server/plugins/fusion/fusion_sensor.cpp
@@ -47,7 +47,7 @@ using std::vector;
 #define GEOMAGNETIC_RV_ENABLED 5
 #define ORIENTATION_ENABLED 7
 #define ROTATION_VECTOR_ENABLED 7
-#define UNCAL_GYRO_ENABLED 7
+#define GYROSCOPE_UNCAL_ENABLED 7
 
 #define INITIAL_VALUE -1
 
@@ -280,7 +280,7 @@ void fusion_sensor::synthesize(const sensor_event_t &event, vector<sensor_event_
        if (sensor_base::is_supported(FUSION_ORIENTATION_ENABLED) ||
                        sensor_base::is_supported(FUSION_ROTATION_VECTOR_ENABLED) ||
                        sensor_base::is_supported(FUSION_GEOMAGNETIC_ROTATION_VECTOR_ENABLED) ||
-                       sensor_base::is_supported(FUSION_UNCAL_GYRO_ENABLED)) {
+                       sensor_base::is_supported(FUSION_GYROSCOPE_UNCAL_ENABLED)) {
                if (event.event_type == GEOMAGNETIC_RAW_DATA_EVENT) {
                        diff_time = event.data.timestamp - m_time;
 
@@ -300,7 +300,7 @@ void fusion_sensor::synthesize(const sensor_event_t &event, vector<sensor_event_
        if (sensor_base::is_supported(FUSION_ORIENTATION_ENABLED) ||
                        sensor_base::is_supported(FUSION_ROTATION_VECTOR_ENABLED) ||
                        sensor_base::is_supported(FUSION_GAMING_ROTATION_VECTOR_ENABLED) ||
-                       sensor_base::is_supported(FUSION_UNCAL_GYRO_ENABLED)) {
+                       sensor_base::is_supported(FUSION_GYROSCOPE_UNCAL_ENABLED)) {
                if (event.event_type == GYROSCOPE_RAW_DATA_EVENT) {
                                diff_time = event.data.timestamp - m_time;
 
@@ -322,7 +322,7 @@ void fusion_sensor::synthesize(const sensor_event_t &event, vector<sensor_event_
                        (m_enable_fusion == ROTATION_VECTOR_ENABLED && sensor_base::is_supported(FUSION_ROTATION_VECTOR_ENABLED)) ||
                        (m_enable_fusion == GAMING_RV_ENABLED && sensor_base::is_supported(FUSION_GAMING_ROTATION_VECTOR_ENABLED)) ||
                        (m_enable_fusion == GEOMAGNETIC_RV_ENABLED && sensor_base::is_supported(FUSION_GEOMAGNETIC_ROTATION_VECTOR_ENABLED)) ||
-                       (m_enable_fusion == UNCAL_GYRO_ENABLED && sensor_base::is_supported(FUSION_UNCAL_GYRO_ENABLED))) {
+                       (m_enable_fusion == GYROSCOPE_UNCAL_ENABLED && sensor_base::is_supported(FUSION_GYROSCOPE_UNCAL_ENABLED))) {
                sensor_event_t fusion_event;
 
                m_orientation_filter.m_magnetic_alignment_factor = m_magnetic_alignment_factor;
@@ -331,12 +331,12 @@ void fusion_sensor::synthesize(const sensor_event_t &event, vector<sensor_event_
 
 
 
-               if (m_enable_fusion == UNCAL_GYRO_ENABLED && sensor_base::is_supported(FUSION_UNCAL_GYRO_ENABLED)) {
+               if (m_enable_fusion == GYROSCOPE_UNCAL_ENABLED && sensor_base::is_supported(FUSION_GYROSCOPE_UNCAL_ENABLED)) {
                        m_time = get_timestamp();
                        fusion_event.sensor_id = get_id();
                        fusion_event.data.timestamp = m_time;
                        fusion_event.data.accuracy = SENSOR_ACCURACY_GOOD;
-                       fusion_event.event_type = FUSION_UNCAL_GYRO_EVENT;
+                       fusion_event.event_type = FUSION_GYROSCOPE_UNCAL_EVENT;
                        fusion_event.data.value_count = 3;
                        fusion_event.data.values[0] = m_orientation_filter.m_gyro_bias.m_vec[0];
                        fusion_event.data.values[1] = m_orientation_filter.m_gyro_bias.m_vec[1];
@@ -389,7 +389,7 @@ int fusion_sensor::get_sensor_data(const unsigned int event_type, sensor_data_t
                        event_type != FUSION_GAMING_ROTATION_VECTOR_ENABLED &&
                        event_type != FUSION_TILT_ENABLED &&
                        event_type != FUSION_GEOMAGNETIC_ROTATION_VECTOR_ENABLED &&
-                       event_type != FUSION_UNCAL_GYRO_ENABLED)
+                       event_type != FUSION_GYROSCOPE_UNCAL_ENABLED)
                return -1;
 
        m_accel_sensor->get_sensor_data(ACCELEROMETER_RAW_DATA_EVENT, accel_data);
@@ -399,7 +399,7 @@ int fusion_sensor::get_sensor_data(const unsigned int event_type, sensor_data_t
        if (event_type == FUSION_ORIENTATION_ENABLED ||
                        event_type == FUSION_ROTATION_VECTOR_ENABLED ||
                        event_type == FUSION_GAMING_ROTATION_VECTOR_ENABLED ||
-                       event_type == FUSION_UNCAL_GYRO_ENABLED)
+                       event_type == FUSION_GYROSCOPE_UNCAL_ENABLED)
        {
                m_gyro_sensor->get_sensor_data(GYROSCOPE_RAW_DATA_EVENT, gyro_data);
                pre_process_data(gyro, gyro_data.values, m_gyro_static_bias, m_gyro_rotation_direction_compensation, m_gyro_scale);
@@ -409,7 +409,7 @@ int fusion_sensor::get_sensor_data(const unsigned int event_type, sensor_data_t
        if (event_type == FUSION_ORIENTATION_ENABLED ||
                        event_type == FUSION_ROTATION_VECTOR_ENABLED ||
                        event_type == FUSION_GEOMAGNETIC_ROTATION_VECTOR_ENABLED ||
-                       event_type == FUSION_UNCAL_GYRO_ENABLED)
+                       event_type == FUSION_GYROSCOPE_UNCAL_ENABLED)
        {
                m_magnetic_sensor->get_sensor_data(GEOMAGNETIC_RAW_DATA_EVENT, magnetic_data);
                pre_process_data(magnetic, magnetic_data.values, m_geomagnetic_static_bias, m_geomagnetic_rotation_direction_compensation, m_geomagnetic_scale);
@@ -420,7 +420,7 @@ int fusion_sensor::get_sensor_data(const unsigned int event_type, sensor_data_t
 
        if (event_type == FUSION_ORIENTATION_ENABLED ||
                        event_type == FUSION_ROTATION_VECTOR_ENABLED ||
-                       event_type == FUSION_UNCAL_GYRO_ENABLED)
+                       event_type == FUSION_GYROSCOPE_UNCAL_ENABLED)
                m_orientation_filter_poll.get_device_orientation(&accel, &gyro, &magnetic);
        else if (event_type == FUSION_GAMING_ROTATION_VECTOR_ENABLED)
                m_orientation_filter_poll.get_device_orientation(&accel, &gyro, NULL);
@@ -429,7 +429,7 @@ int fusion_sensor::get_sensor_data(const unsigned int event_type, sensor_data_t
        else if (event_type == FUSION_TILT_ENABLED)
                        m_orientation_filter_poll.get_device_orientation(&accel, NULL, NULL);
 
-       if (event_type == FUSION_UNCAL_GYRO_ENABLED) {
+       if (event_type == FUSION_GYROSCOPE_UNCAL_ENABLED) {
                data.accuracy = SENSOR_ACCURACY_GOOD;
                data.timestamp = get_timestamp();
                data.value_count = 3;

diff --git a/src/server/plugins/uncal_gyro/uncal_gyro_sensor.cpp b/src/server/plugins/gyroscope_uncal/gyroscope_uncal_sensor.cpp
similarity index 69%
rename from src/server/plugins/uncal_gyro/uncal_gyro_sensor.cpp
rename to src/server/plugins/gyroscope_uncal/gyroscope_uncal_sensor.cpp
index e53bff0..cd1ff15 100755 (executable)
--- a/src/server/plugins/uncal_gyro/uncal_gyro_sensor.cpp
+++ b/src/server/plugins/gyroscope_uncal/gyroscope_uncal_sensor.cpp
@@ -27,7 +27,7 @@
 #include <dlfcn.h>
 #include <sensor_logs.h>
 #include <sf_common.h>
-#include <uncal_gyro_sensor.h>
+#include <gyroscope_uncal_sensor.h>
 #include <sensor_plugin_loader.h>
 #include <orientation_filter.h>
 #include <cvirtual_sensor_config.h>
@@ -35,12 +35,12 @@
 using std::vector;
 using std::string;
 
-#define SENSOR_NAME "UNCAL_GYROSCOPE_SENSOR"
-#define SENSOR_TYPE_UNCAL_GYRO         "UNCAL_GYROSCOPE"
+#define SENSOR_NAME "GYROSCOPE_UNCAL_SENSOR"
+#define SENSOR_TYPE_GYROSCOPE_UNCAL            "GYROSCOPE_UNCAL"
 
 #define GYROSCOPE_ENABLED 0x01
 #define GYRO_BIAS_ENABLED 0x02
-#define UNCAL_GYRO_BIAS_ENABLED 3
+#define GYROSCOPE_UNCAL_BIAS_ENABLED 3
 
 #define INITIAL_VALUE -1
 
@@ -56,7 +56,7 @@ using std::string;
 #define ELEMENT_RAW_DATA_UNIT                                                                  "RAW_DATA_UNIT"
 #define ELEMENT_DEFAULT_SAMPLING_TIME                                                  "DEFAULT_SAMPLING_TIME"
 
-uncal_gyro_sensor::uncal_gyro_sensor()
+gyroscope_uncal_sensor::gyroscope_uncal_sensor()
 : m_accel_sensor(NULL)
 , m_magnetic_sensor(NULL)
 , m_gyro_sensor(NULL)
@@ -72,23 +72,23 @@ uncal_gyro_sensor::uncal_gyro_sensor()
                m_hardware_fusion = true;
 
        m_name = string(SENSOR_NAME);
-       register_supported_event(UNCAL_GYRO_RAW_DATA_EVENT);
+       register_supported_event(GYROSCOPE_UNCAL_RAW_DATA_EVENT);
 
-       if (!config.get(SENSOR_TYPE_UNCAL_GYRO, ELEMENT_VENDOR, m_vendor)) {
+       if (!config.get(SENSOR_TYPE_GYROSCOPE_UNCAL, ELEMENT_VENDOR, m_vendor)) {
                ERR("[VENDOR] is empty\n");
                throw ENXIO;
        }
 
        INFO("m_vendor = %s", m_vendor.c_str());
 
-       if (!config.get(SENSOR_TYPE_UNCAL_GYRO, ELEMENT_RAW_DATA_UNIT, m_raw_data_unit)) {
+       if (!config.get(SENSOR_TYPE_GYROSCOPE_UNCAL, ELEMENT_RAW_DATA_UNIT, m_raw_data_unit)) {
                ERR("[RAW_DATA_UNIT] is empty\n");
                throw ENXIO;
        }
 
        INFO("m_raw_data_unit = %s", m_raw_data_unit.c_str());
 
-       if (!config.get(SENSOR_TYPE_UNCAL_GYRO, ELEMENT_DEFAULT_SAMPLING_TIME, &m_default_sampling_time)) {
+       if (!config.get(SENSOR_TYPE_GYROSCOPE_UNCAL, ELEMENT_DEFAULT_SAMPLING_TIME, &m_default_sampling_time)) {
                ERR("[DEFAULT_SAMPLING_TIME] is empty\n");
                throw ENXIO;
        }
@@ -98,12 +98,12 @@ uncal_gyro_sensor::uncal_gyro_sensor()
        m_interval = m_default_sampling_time * MS_TO_US;
 }
 
-uncal_gyro_sensor::~uncal_gyro_sensor()
+gyroscope_uncal_sensor::~gyroscope_uncal_sensor()
 {
-       INFO("uncal_gyro_sensor is destroyed!\n");
+       INFO("gyroscope_uncal_sensor is destroyed!\n");
 }
 
-bool uncal_gyro_sensor::init(void)
+bool gyroscope_uncal_sensor::init(void)
 {
        m_accel_sensor = sensor_plugin_loader::get_instance().get_sensor(ACCELEROMETER_SENSOR);
        m_gyro_sensor = sensor_plugin_loader::get_instance().get_sensor(GYROSCOPE_SENSOR);
@@ -122,12 +122,12 @@ bool uncal_gyro_sensor::init(void)
        return true;
 }
 
-void uncal_gyro_sensor::get_types(vector<sensor_type_t> &types)
+void gyroscope_uncal_sensor::get_types(vector<sensor_type_t> &types)
 {
-       types.push_back(UNCAL_GYROSCOPE_SENSOR);
+       types.push_back(GYROSCOPE_UNCAL_SENSOR);
 }
 
-bool uncal_gyro_sensor::on_start(void)
+bool gyroscope_uncal_sensor::on_start(void)
 {
        AUTOLOCK(m_mutex);
 
@@ -143,9 +143,9 @@ bool uncal_gyro_sensor::on_start(void)
                m_magnetic_sensor->start();
        }
 
-       m_fusion_sensor->register_supported_event(FUSION_UNCAL_GYRO_EVENT);
-       m_fusion_sensor->register_supported_event(FUSION_UNCAL_GYRO_ENABLED);
-       m_fusion_sensor->add_client(FUSION_UNCAL_GYRO_EVENT);
+       m_fusion_sensor->register_supported_event(FUSION_GYROSCOPE_UNCAL_EVENT);
+       m_fusion_sensor->register_supported_event(FUSION_GYROSCOPE_UNCAL_ENABLED);
+       m_fusion_sensor->add_client(FUSION_GYROSCOPE_UNCAL_EVENT);
        m_fusion_sensor->add_interval((intptr_t)this, (m_interval/MS_TO_US), false);
        m_fusion_sensor->start();
 
@@ -153,7 +153,7 @@ bool uncal_gyro_sensor::on_start(void)
        return true;
 }
 
-bool uncal_gyro_sensor::on_stop(void)
+bool gyroscope_uncal_sensor::on_stop(void)
 {
        AUTOLOCK(m_mutex);
 
@@ -169,17 +169,17 @@ bool uncal_gyro_sensor::on_stop(void)
                m_magnetic_sensor->stop();
        }
 
-       m_fusion_sensor->delete_client(FUSION_UNCAL_GYRO_EVENT);
+       m_fusion_sensor->delete_client(FUSION_GYROSCOPE_UNCAL_EVENT);
        m_fusion_sensor->delete_interval((intptr_t)this, false);
-       m_fusion_sensor->unregister_supported_event(FUSION_UNCAL_GYRO_EVENT);
-       m_fusion_sensor->unregister_supported_event(FUSION_UNCAL_GYRO_ENABLED);
+       m_fusion_sensor->unregister_supported_event(FUSION_GYROSCOPE_UNCAL_EVENT);
+       m_fusion_sensor->unregister_supported_event(FUSION_GYROSCOPE_UNCAL_ENABLED);
        m_fusion_sensor->stop();
 
        deactivate();
        return true;
 }
 
-bool uncal_gyro_sensor::add_interval(int client_id, unsigned int interval)
+bool gyroscope_uncal_sensor::add_interval(int client_id, unsigned int interval)
 {
        AUTOLOCK(m_mutex);
 
@@ -194,7 +194,7 @@ bool uncal_gyro_sensor::add_interval(int client_id, unsigned int interval)
        return sensor_base::add_interval(client_id, interval, false);
 }
 
-bool uncal_gyro_sensor::delete_interval(int client_id)
+bool gyroscope_uncal_sensor::delete_interval(int client_id)
 {
        AUTOLOCK(m_mutex);
 
@@ -209,9 +209,9 @@ bool uncal_gyro_sensor::delete_interval(int client_id)
        return sensor_base::delete_interval(client_id, false);
 }
 
-void uncal_gyro_sensor::synthesize(const sensor_event_t &event, vector<sensor_event_t> &outs)
+void gyroscope_uncal_sensor::synthesize(const sensor_event_t &event, vector<sensor_event_t> &outs)
 {
-       sensor_event_t uncal_gyro_event;
+       sensor_event_t gyroscope_uncal_event;
        unsigned long long diff_time;
 
        if (event.event_type == GYROSCOPE_RAW_DATA_EVENT) {
@@ -226,10 +226,10 @@ void uncal_gyro_sensor::synthesize(const sensor_event_t &event, vector<sensor_ev
 
                m_gyro.m_time_stamp = event.data.timestamp;
 
-               m_enable_uncal_gyro |= GYROSCOPE_ENABLED;
+               m_enable_gyroscope_uncal |= GYROSCOPE_ENABLED;
        }
 
-       if (event.event_type == FUSION_UNCAL_GYRO_EVENT) {
+       if (event.event_type == FUSION_GYROSCOPE_UNCAL_EVENT) {
                diff_time = event.data.timestamp - m_time;
 
                if (m_time && (diff_time < m_interval * MIN_DELIVERY_DIFF_FACTOR))
@@ -241,40 +241,40 @@ void uncal_gyro_sensor::synthesize(const sensor_event_t &event, vector<sensor_ev
 
                m_fusion.m_time_stamp = event.data.timestamp;
 
-               m_enable_uncal_gyro |= GYRO_BIAS_ENABLED;
+               m_enable_gyroscope_uncal |= GYRO_BIAS_ENABLED;
        }
 
-       if (m_enable_uncal_gyro == UNCAL_GYRO_BIAS_ENABLED) {
-               m_enable_uncal_gyro = 0;
+       if (m_enable_gyroscope_uncal == GYROSCOPE_UNCAL_BIAS_ENABLED) {
+               m_enable_gyroscope_uncal = 0;
 
                m_time = get_timestamp();
-               uncal_gyro_event.sensor_id = get_id();
-               uncal_gyro_event.event_type = UNCAL_GYRO_RAW_DATA_EVENT;
-               uncal_gyro_event.data.value_count = 6;
-               uncal_gyro_event.data.timestamp = m_time;
-               uncal_gyro_event.data.accuracy = SENSOR_ACCURACY_GOOD;
-               uncal_gyro_event.data.values[0] = m_gyro.m_data.m_vec[0];
-               uncal_gyro_event.data.values[1] = m_gyro.m_data.m_vec[1];
-               uncal_gyro_event.data.values[2] = m_gyro.m_data.m_vec[2];
-
-               uncal_gyro_event.data.values[3] = m_fusion.m_data.m_vec[0];
-               uncal_gyro_event.data.values[4] = m_fusion.m_data.m_vec[1];
-               uncal_gyro_event.data.values[5] = m_fusion.m_data.m_vec[2];
-
-               push(uncal_gyro_event);
+               gyroscope_uncal_event.sensor_id = get_id();
+               gyroscope_uncal_event.event_type = GYROSCOPE_UNCAL_RAW_DATA_EVENT;
+               gyroscope_uncal_event.data.value_count = 6;
+               gyroscope_uncal_event.data.timestamp = m_time;
+               gyroscope_uncal_event.data.accuracy = SENSOR_ACCURACY_GOOD;
+               gyroscope_uncal_event.data.values[0] = m_gyro.m_data.m_vec[0];
+               gyroscope_uncal_event.data.values[1] = m_gyro.m_data.m_vec[1];
+               gyroscope_uncal_event.data.values[2] = m_gyro.m_data.m_vec[2];
+
+               gyroscope_uncal_event.data.values[3] = m_fusion.m_data.m_vec[0];
+               gyroscope_uncal_event.data.values[4] = m_fusion.m_data.m_vec[1];
+               gyroscope_uncal_event.data.values[5] = m_fusion.m_data.m_vec[2];
+
+               push(gyroscope_uncal_event);
        }
 
        return;
 }
 
-int uncal_gyro_sensor::get_sensor_data(const unsigned int event_type, sensor_data_t &data)
+int gyroscope_uncal_sensor::get_sensor_data(const unsigned int event_type, sensor_data_t &data)
 {
        sensor_data_t fusion_data, gyro_data;
 
-       if (event_type != UNCAL_GYRO_RAW_DATA_EVENT)
+       if (event_type != GYROSCOPE_UNCAL_RAW_DATA_EVENT)
                return -1;
 
-       m_fusion_sensor->get_sensor_data(FUSION_UNCAL_GYRO_ENABLED, fusion_data);
+       m_fusion_sensor->get_sensor_data(FUSION_GYROSCOPE_UNCAL_ENABLED, fusion_data);
        m_gyro_sensor->get_sensor_data(GYROSCOPE_RAW_DATA_EVENT, gyro_data);
 
        data.accuracy = fusion_data.accuracy;
@@ -290,7 +290,7 @@ int uncal_gyro_sensor::get_sensor_data(const unsigned int event_type, sensor_dat
        return 0;
 }
 
-bool uncal_gyro_sensor::get_properties(sensor_type_t sensor_type, sensor_properties_s &properties)
+bool gyroscope_uncal_sensor::get_properties(sensor_type_t sensor_type, sensor_properties_s &properties)
 {
        properties.resolution = 0.000001;
        properties.vendor = m_vendor;

diff --git a/src/server/plugins/uncal_gyro/uncal_gyro_sensor.h b/src/server/plugins/gyroscope_uncal/gyroscope_uncal_sensor.h
similarity index 86%
rename from src/server/plugins/uncal_gyro/uncal_gyro_sensor.h
rename to src/server/plugins/gyroscope_uncal/gyroscope_uncal_sensor.h
index f4c6b8c..0edbde4 100755 (executable)
--- a/src/server/plugins/uncal_gyro/uncal_gyro_sensor.h
+++ b/src/server/plugins/gyroscope_uncal/gyroscope_uncal_sensor.h
@@ -17,17 +17,17 @@
  *
  */
 
-#ifndef _UNCAL_GYRO_SENSOR_H_
-#define _UNCAL_GYRO_SENSOR_H_
+#ifndef _GYROSCOPE_UNCAL_SENSOR_H_
+#define _GYROSCOPE_UNCAL_SENSOR_H_
 
 #include <sensor_internal.h>
 #include <virtual_sensor.h>
 #include <orientation_filter.h>
 
-class uncal_gyro_sensor : public virtual_sensor {
+class gyroscope_uncal_sensor : public virtual_sensor {
 public:
-       uncal_gyro_sensor();
-       virtual ~uncal_gyro_sensor();
+       gyroscope_uncal_sensor();
+       virtual ~gyroscope_uncal_sensor();
 
        bool init(void);
 
@@ -51,7 +51,7 @@ private:
 
        cmutex m_value_mutex;
 
-       unsigned int m_enable_uncal_gyro;
+       unsigned int m_enable_gyroscope_uncal;
 
        unsigned long long m_time;
        unsigned int m_interval;
@@ -67,4 +67,4 @@ private:
        bool on_stop(void);
 };
 
-#endif /*_UNCAL_GYRO_SENSOR_H_*/
+#endif /*_GYROSCOPE_UNCAL_SENSOR_H_*/

diff --git a/src/server/sensor_plugin_loader.cpp.in b/src/server/sensor_plugin_loader.cpp.in
index c1c09f2..eb622aa 100644 (file)
--- a/src/server/sensor_plugin_loader.cpp.in
+++ b/src/server/sensor_plugin_loader.cpp.in
@@ -66,8 +66,8 @@
 #ifdef ENABLE_RV
 #include <rv_sensor.h>
 #endif
-#ifdef ENABLE_UNCAL_GYRO
-#include <uncal_gyro_sensor.h>
+#ifdef ENABLE_GYROSCOPE_UNCAL
+#include <gyroscope_uncal_sensor.h>
 #endif
 
 
@@ -357,15 +357,15 @@ bool sensor_plugin_loader::load_plugins(void)
                if (rv_sensor_ptr != NULL)
                        sensors.push_back(rv_sensor_ptr);
 #endif
-#ifdef ENABLE_UNCAL_GYRO
-               uncal_gyro_sensor* uncal_gyro_sensor_ptr = NULL;
+#ifdef ENABLE_GYROSCOPE_UNCAL
+               gyroscope_uncal_sensor* gyroscope_uncal_sensor_ptr = NULL;
                try {
-                       uncal_gyro_sensor_ptr = new(std::nothrow) uncal_gyro_sensor;
+                       gyroscope_uncal_sensor_ptr = new(std::nothrow) gyroscope_uncal_sensor;
                } catch (int err) {
-                       ERR("Failed to create uncal_gyro_sensor module, err: %d, cause: %s", err, strerror(err));
+                       ERR("Failed to create gyroscope_uncal_sensor module, err: %d, cause: %s", err, strerror(err));
                }
-               if (uncal_gyro_sensor_ptr != NULL)
-                       sensors.push_back(uncal_gyro_sensor_ptr);
+               if (gyroscope_uncal_sensor_ptr != NULL)
+                       sensors.push_back(gyroscope_uncal_sensor_ptr);
 #endif
        }
 

diff --git a/src/shared/sensor_types.h b/src/shared/sensor_types.h
index 29a16e9..f1e3778 100644 (file)
--- a/src/shared/sensor_types.h
+++ b/src/shared/sensor_types.h
@@ -42,7 +42,7 @@ typedef enum {
        BIO_LED_IR_SENSOR,
        BIO_LED_RED_SENSOR,
        RV_RAW_SENSOR,
-       UNCAL_GYROSCOPE_SENSOR,
+       GYROSCOPE_UNCAL_SENSOR,
        UNCAL_GEOMAGNETIC_SENSOR
 } sensor_type_t;
 
@@ -106,17 +106,17 @@ enum event_types_t {
 
        TILT_RAW_DATA_EVENT     = (TILT_SENSOR << 16) | 0x0001,
 
-       UNCAL_GYRO_RAW_DATA_EVENT       = (UNCAL_GYROSCOPE_SENSOR << 16) | 0x0001,
+       GYROSCOPE_UNCAL_RAW_DATA_EVENT  = (GYROSCOPE_UNCAL_SENSOR << 16) | 0x0001,
 
        FUSION_EVENT = (FUSION_SENSOR << 16) | 0x0001,
-       FUSION_UNCAL_GYRO_EVENT = (FUSION_SENSOR << 16) | 0x0002,
+       FUSION_GYROSCOPE_UNCAL_EVENT = (FUSION_SENSOR << 16) | 0x0002,
        FUSION_CALIBRATION_NEEDED_EVENT = (FUSION_SENSOR << 16) | 0x0003,
        FUSION_ORIENTATION_ENABLED = (FUSION_SENSOR << 16) | 0x0004,
        FUSION_ROTATION_VECTOR_ENABLED = (FUSION_SENSOR << 16) | 0x0005,
        FUSION_GAMING_ROTATION_VECTOR_ENABLED = (FUSION_SENSOR << 16) | 0x0006,
        FUSION_GEOMAGNETIC_ROTATION_VECTOR_ENABLED = (FUSION_SENSOR << 16) | 0x0007,
        FUSION_TILT_ENABLED = (FUSION_SENSOR << 16) | 0x0008,
-       FUSION_UNCAL_GYRO_ENABLED = (FUSION_SENSOR << 16) | 0x0009,
+       FUSION_GYROSCOPE_UNCAL_ENABLED = (FUSION_SENSOR << 16) | 0x0009,
 };
 
 enum proxi_change_state {

diff --git a/test/src/api-test.c b/test/src/api-test.c
index 6ab4dd0..aa065f9 100755 (executable)
--- a/test/src/api-test.c
+++ b/test/src/api-test.c
@@ -255,8 +255,8 @@ int main(int argc, char **argv)
        result = check_sensor_api(GAMING_RV_RAW_DATA_EVENT, interval);
        fprintf(fp, "Gaming Rotation Vector - RAW_DATA_REPORT_ON_TIME - %d\n", result);
 
-       result = check_sensor_api(UNCAL_GYROSCOPE_SENSOR, interval);
-       fprintf(fp, "Uncal Gyro Sensor - RAW_DATA_REPORT_ON_TIME - %d\n", result);
+       result = check_sensor_api(GYROSCOPE_UNCAL_SENSOR, interval);
+       fprintf(fp, "Gyroscope Uncal Sensor - RAW_DATA_REPORT_ON_TIME - %d\n", result);
 
        result = check_sensor_api(TEMPERATURE_RAW_DATA_EVENT, interval);
        fprintf(fp, "Temperature - RAW_DATA_REPORT_ON_TIME - %d\n", result);

diff --git a/test/src/check-sensor.c b/test/src/check-sensor.c
index 2118390..d70add9 100755 (executable)
--- a/test/src/check-sensor.c
+++ b/test/src/check-sensor.c
@@ -85,8 +85,8 @@ void printpollinglogs(sensor_type_t type,sensor_data_t data)
        case(GAMING_RV_SENSOR):
                printf("Gaming Rv [%lld] [%6.6f] [%6.6f] [%6.6f] [%6.6f]\n\n", data.timestamp, data.values[0], data.values[1], data.values[2], data.values[3]);
                break;
-       case(UNCAL_GYROSCOPE_SENSOR):
-               printf("Uncal gyro [%lld] [%6.6f] [%6.6f] [%6.6f] [%6.6f] [%6.6f] [%6.6f]\n\n", data.timestamp, data.values[0], data.values[1], data.values[2], data.values[3], data.values[4], data.values[5]);
+       case(GYROSCOPE_UNCAL_SENSOR):
+               printf("Gyroscope Uncal [%lld] [%6.6f] [%6.6f] [%6.6f] [%6.6f] [%6.6f] [%6.6f]\n\n", data.timestamp, data.values[0], data.values[1], data.values[2], data.values[3], data.values[4], data.values[5]);
                break;
        default:
                return;
@@ -164,9 +164,9 @@ int get_event(sensor_type_t sensor_type, char str[])
                if (strcmp(str, "RAW_DATA_EVENT") == 0)
                        return GAMING_RV_RAW_DATA_EVENT;
                break;
-       case UNCAL_GYROSCOPE_SENSOR:
+       case GYROSCOPE_UNCAL_SENSOR:
                if (strcmp(str, "RAW_DATA_EVENT") == 0)
-                       return UNCAL_GYRO_RAW_DATA_EVENT;
+                       return GYROSCOPE_UNCAL_RAW_DATA_EVENT;
                break;
 
        default:
@@ -231,8 +231,8 @@ void callback(sensor_t sensor, unsigned int event_type, sensor_data_t *data, voi
        case GAMING_RV_SENSOR:
                printf("Gaming RV [%lld] [%6.6f] [%6.6f] [%6.6f] [%6.6f]\n", data->timestamp, data->values[0], data->values[1], data->values[2], data->values[3]);
                break;
-       case UNCAL_GYROSCOPE_SENSOR:
-               printf("Uncal gyro [%lld] [%6.6f] [%6.6f] [%6.6f] [%6.6f] [%6.6f] [%6.6f]\n\n", data->timestamp, data->values[0], data->values[1], data->values[2], data->values[3], data->values[4], data->values[5]);
+       case GYROSCOPE_UNCAL_SENSOR:
+               printf("Gyroscope Uncal [%lld] [%6.6f] [%6.6f] [%6.6f] [%6.6f] [%6.6f] [%6.6f]\n\n", data->timestamp, data->values[0], data->values[1], data->values[2], data->values[3], data->values[4], data->values[5]);
                break;
 
        default:

diff --git a/test/src/multi-thread-performance-test.c b/test/src/multi-thread-performance-test.c
index 009b1cf..7b0bb1b 100644 (file)
--- a/test/src/multi-thread-performance-test.c
+++ b/test/src/multi-thread-performance-test.c
@@ -53,7 +53,7 @@ void usage()
        printf("[gaming_rv] ");
        printf("[ultraviolet] ");
        printf("[light]\n");
-       printf("[uncal_gyro]");
+       printf("[gyro_uncal]");
 
 }
 

diff --git a/test/src/sensor-test.c b/test/src/sensor-test.c
index 281d8ac..82d27fa 100755 (executable)
--- a/test/src/sensor-test.c
+++ b/test/src/sensor-test.c
@@ -48,7 +48,7 @@ void usage()
        printf("[ultraviolet] ");
        printf("[bio_led_red] ");
        printf("[light]\n");
-       printf("[uncal_gyro]");
+       printf("[gyroscope_uncal]");
        printf("event:");
        printf("[RAW_DATA_EVENT]\n");
        printf("-p: [polling]\n");
@@ -140,9 +140,9 @@ int main(int argc, char **argv)
                 sensor_type = ULTRAVIOLET_SENSOR;
                 event = ULTRAVIOLET_RAW_DATA_EVENT;
        }
-       else if (strcmp(argv[1], "uncal_gyro") == 0) {
-                sensor_type = UNCAL_GYROSCOPE_SENSOR;
-                event = UNCAL_GYRO_RAW_DATA_EVENT;
+       else if (strcmp(argv[1], "gyroscope_uncal") == 0) {
+                sensor_type = GYROSCOPE_UNCAL_SENSOR;
+                event = GYROSCOPE_UNCAL_RAW_DATA_EVENT;
        }
        else if (strcmp(argv[1], "bio_led_red") == 0) {
                 sensor_type = BIO_LED_RED_SENSOR;

diff --git a/virtual_sensors.xml b/virtual_sensors.xml
index 4b2c3e0..32fa33d 100755 (executable)
--- a/virtual_sensors.xml
+++ b/virtual_sensors.xml
@@ -81,7 +81,7 @@
                </TILT>
 
                <UNCAL_GYROSCOPE>
-                       <NAME value="UNCAL_GYROSCOPE_SENSOR" />
+                       <NAME value="GYROSCOPE_UNCAL_SENSOR" />
                        <VENDOR value="SAMSUNG" />
                        <RAW_DATA_UNIT value="DEGREES" />
                        <DEFAULT_SAMPLING_TIME value="100" />
@@ -176,7 +176,7 @@
                </TILT>
 
                <UNCAL_GYROSCOPE>
-                       <NAME value="UNCAL_GYROSCOPE_SENSOR" />
+                       <NAME value="GYROSCOPE_UNCAL_SENSOR" />
                        <VENDOR value="SAMSUNG" />
                        <RAW_DATA_UNIT value="DEGREES" />
                        <DEFAULT_SAMPLING_TIME value="100" />
@@ -271,7 +271,7 @@
                </TILT>
 
                <UNCAL_GYROSCOPE>
-                       <NAME value="UNCAL_GYROSCOPE_SENSOR" />
+                       <NAME value="GYROSCOPE_UNCAL_SENSOR" />
                        <VENDOR value="SAMSUNG" />
                        <RAW_DATA_UNIT value="DEGREES" />
                        <DEFAULT_SAMPLING_TIME value="100" />