STPK-1429 Add flexibility to sample processing

Move samples processing logic to a dedicated file in
preparation for more advanced transform operations,
both per channel and per sample.

Issue: STPK-1429

Change-Id: I4e4e2e5a0691a3413fd50f85034eb477a006352b
Signed-off-by: Patrick Porlan <patrick.porlan@intel.com>

diff --git a/Android.mk b/Android.mk
index 3a8df41..68f7937 100644 (file)
--- a/Android.mk
+++ b/Android.mk
@@ -14,6 +14,7 @@ src_files := $(src_path)/entry.c \
             $(src_path)/control.c \
             $(src_path)/description.c \
             $(src_path)/utils.c \
+            $(src_path)/transform.c \
 
 LOCAL_C_INCLUDES += $(LOCAL_PATH) vendor/intel/hardware/iio-sensors-hal
 LOCAL_MODULE := iio-sensors-hal

diff --git a/control.c b/control.c
index 4155432..f6f44df 100644 (file)
--- a/control.c
+++ b/control.c
@@ -4,12 +4,12 @@
 
 #include <fcntl.h>
 #include <sys/epoll.h>
-#include <math.h>
 #include <utils/Log.h>
 #include <hardware/sensors.h>
 #include "control.h"
 #include "enumeration.h"
 #include "utils.h"
+#include "transform.h"
 
 /* Currently active sensors count, per device */
 static int poll_sensors_per_dev[MAX_DEVICES];  /* poll-mode sensors */
@@ -488,10 +488,6 @@ static void propagate_sensor_report(int s, struct sensors_event_t* data)
        int num_fields;
        int c;
        unsigned char* current_sample;
-       int sample_size;
-       struct datum_info_t* sample_type;
-       int64_t s64;
-       float val;
 
        memset(data, 0, sizeof(sensors_event_t));
 
@@ -538,12 +534,13 @@ static void propagate_sensor_report(int s, struct sensors_event_t* data)
 
                /* Read values through sysfs rather than from a report buffer */
                for (c=0; c<num_fields; c++) {
-                       val = acquire_immediate_value(s, c);
 
-                       data->data[c] = transform_sample(sensor_type, c, val);
+                       data->data[c] = acquire_immediate_value(s, c);
 
                        ALOGV("\tfield %d: %f\n", c, data->data[c]);
                }
+
+               finalize_sample(s, data);
                return;
        }
 
@@ -552,18 +549,14 @@ static void propagate_sensor_report(int s, struct sensors_event_t* data)
        current_sample = sensor_info[s].report_buffer;
 
        for (c=0; c<num_fields; c++) {
-               sample_size     =  sensor_info[s].channel[c].size;
-               sample_type     = &sensor_info[s].channel[c].type_info;
-
-               s64 = sample_as_int64(current_sample, sample_type);
 
-               val = (sensor_info[s].offset + s64) * sensor_info[s].scale;
-
-               data->data[c] = transform_sample(sensor_type, c, val);
+               data->data[c] = transform_sample(s, c, current_sample);
 
                ALOGV("\tfield %d: %f\n", c, data->data[c]);
-               current_sample += sample_size;
+               current_sample += sensor_info[s].channel[c].size;
        }
+
+       finalize_sample(s, data);
 }
 
 

diff --git a/transform.c b/transform.c
new file mode 100644 (file)
index 0000000..c71e50f
--- /dev/null
+++ b/transform.c
@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2014 Intel Corporation.
+ */
+
+#include <stdlib.h>
+#include <math.h>
+#include <utils/Log.h>
+#include <hardware/sensors.h>
+#include "common.h"
+#include "transform.h"
+
+
+int64_t sample_as_int64(unsigned char* sample, struct datum_info_t* type)
+{
+       uint16_t u16;
+       uint32_t u32;
+       uint64_t u64;
+       int i;
+
+       switch (type->storagebits) {
+               case 64:
+                       u64 = 0;
+
+                       if (type->endianness == 'b')
+                               for (i=0; i<8; i++)
+                                       u64 = (u64 << 8) | sample[i];
+                       else
+                               for (i=7; i>=0; i--)
+                                       u64 = (u64 << 8) | sample[i];
+
+                       if (type->sign == 'u')
+                               return (int64_t) (u64 >> type->shift);
+
+                       return ((int64_t) u64) >> type->shift;
+
+               case 32:
+                       if (type->endianness == 'b')
+                               u32 = (sample[0] << 24) | (sample[1] << 16) |
+                                       (sample[2] << 8) | sample[3];
+                       else
+                               u32 = (sample[3] << 24) | (sample[2] << 16) |
+                                       (sample[1] << 8) | sample[0];
+
+                       if (type->sign == 'u')
+                               return u32 >> type->shift;
+
+                       return ((int32_t) u32) >> type->shift;
+
+               case 16:
+                       if (type->endianness == 'b')
+                               u16 = (sample[0] << 8) | sample[1];
+                       else
+                               u16 = (sample[1] << 8) | sample[0];
+
+                       if (type->sign == 'u')
+                               return u16 >> type->shift;
+
+                       return  ((int16_t) u16) >> type->shift;
+       }
+
+       ALOGE("Unhandled sample storage size\n");
+       return 0;
+}
+
+
+void finalize_sample(int s, struct sensors_event_t* data)
+{
+       int i           = sensor_info[s].catalog_index;
+       int sensor_type = sensor_catalog[i].type;
+
+       switch (sensor_type) {
+               case SENSOR_TYPE_ACCELEROMETER:
+                       /*
+                        * Invert x axis orientation from SI units - see
+                        * /hardware/libhardware/include/hardware/sensors.h
+                        * for a discussion of what Android expects
+                        */
+                       data->data[0] = -data->data[0];
+                       break;
+
+               case SENSOR_TYPE_GYROSCOPE:
+                       /* Limit drift */
+                       if (abs(data->data[0]) < .05 && abs(data->data[1]) < .05
+                               && abs(data->data[2]) < .05) {
+                                       data->data[0] = 0;
+                                       data->data[1] = 0;
+                                       data->data[2] = 0;
+                               }
+                       break;
+       }
+}
+
+
+float transform_sample(int s, int c, unsigned char* sample_data)
+{
+       struct datum_info_t* sample_type = &sensor_info[s].channel[c].type_info;
+       int64_t              s64 = sample_as_int64(sample_data, sample_type);
+
+       /* Apply default scaling rules */
+       return (sensor_info[s].offset + s64) * sensor_info[s].scale;
+}

diff --git a/transform.h b/transform.h
new file mode 100644 (file)
index 0000000..2a6a03e
--- /dev/null
+++ b/transform.h
@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2014 Intel Corporation.
+ */
+
+#ifndef __TRANSFORM_H__
+#define __TRANSFORM_H__
+
+#include "common.h"
+
+float transform_sample (int sensor, int channel, unsigned char* sample_data);
+
+void finalize_sample   (int s, struct sensors_event_t* data);
+
+
+#endif
+
+
+

diff --git a/utils.c b/utils.c
index fcde830..9e4fb27 100644 (file)
--- a/utils.c
+++ b/utils.c
@@ -6,6 +6,7 @@
 #include <fcntl.h>
 #include <utils/Log.h>
 #include <hardware/sensors.h>
+#include "common.h"
 #include "utils.h"
 
 
@@ -219,84 +220,6 @@ int decode_type_spec(      const char type_buf[MAX_TYPE_SPEC_LEN],
 }
 
 
-int64_t sample_as_int64(unsigned char* sample, struct datum_info_t* type)
-{
-       uint16_t u16;
-       uint32_t u32;
-       uint64_t u64;
-       int i;
-
-       switch (type->storagebits) {
-               case 64:
-                       u64 = 0;
-
-                       if (type->endianness == 'b')
-                               for (i=0; i<8; i++)
-                                       u64 = (u64 << 8) | sample[i];
-                       else
-                               for (i=7; i>=0; i--)
-                                       u64 = (u64 << 8) | sample[i];
-
-                       if (type->sign == 'u')
-                               return (int64_t) (u64 >> type->shift);
-
-                       return ((int64_t) u64) >> type->shift;
-
-               case 32:
-                       if (type->endianness == 'b')
-                               u32 = (sample[0] << 24) | (sample[1] << 16) |
-                                       (sample[2] << 8) | sample[3];
-                       else
-                               u32 = (sample[3] << 24) | (sample[2] << 16) |
-                                       (sample[1] << 8) | sample[0];
-
-                       if (type->sign == 'u')
-                               return u32 >> type->shift;
-
-                       return ((int32_t) u32) >> type->shift;
-
-               case 16:
-                       if (type->endianness == 'b')
-                               u16 = (sample[0] << 8) | sample[1];
-                       else
-                               u16 = (sample[1] << 8) | sample[0];
-
-                       if (type->sign == 'u')
-                               return u16 >> type->shift;
-
-                       return  ((int16_t) u16) >> type->shift;
-       }
-
-       ALOGE("Unhandled sample storage size\n");
-       return 0;
-}
-
-
-float transform_sample (int sensor_type, int channel, float val)
-{
-       /* Last opportunity to alter sample data before it goes to Android */
-       switch (sensor_type) {
-               case SENSOR_TYPE_ACCELEROMETER:
-                       /*
-                        * Invert x axis orientation from SI units - see
-                        * /hardware/libhardware/include/hardware/sensors.h
-                        * for a discussion of what Android expects
-                        */
-                       if (channel == 0)
-                               return -val;
-                       break;
-
-               case SENSOR_TYPE_GYROSCOPE:
-                       /* Limit drift */
-                       if (val > -0.05 && val < 0.05)
-                               return 0;
-                       break;
-       }
-
-       return val;
-}
-
-
 int64_t get_timestamp(void)
 {
        struct timespec ts = {0};
@@ -305,5 +228,3 @@ int64_t get_timestamp(void)
 
        return 1000000000LL * ts.tv_sec + ts.tv_nsec;
 }
-
-

diff --git a/utils.h b/utils.h
index 6f827d3..1ed20cc 100644 (file)
--- a/utils.h
+++ b/utils.h
@@ -18,10 +18,6 @@ int  sysfs_read_float(const char path[PATH_MAX], float *value);
 int    decode_type_spec(const char type_buf[MAX_TYPE_SPEC_LEN],
                         struct datum_info_t *type_info);
 
-int64_t sample_as_int64        (unsigned char* sample, struct datum_info_t* type);
-
-float  transform_sample(int sensor_type, int channel, float val);
-
 int64_t        get_timestamp   (void);
 
 #endif