magnetic
authorPaul Kocialkowski <contact@paulk.fr>
Thu, 21 Feb 2013 22:20:53 +0000 (23:20 +0100)
committerPaul Kocialkowski <contact@paulk.fr>
Thu, 21 Feb 2013 22:20:53 +0000 (23:20 +0100)
Signed-off-by: Paul Kocialkowski <contact@paulk.fr>
Android.mk
bh1721.c
bma250.c
piranha_sensors.c
piranha_sensors.h
yas530c.c [new file with mode: 0644]

index 36b7638..9bb6c51 100644 (file)
@@ -23,7 +23,8 @@ LOCAL_SRC_FILES := \
        piranha_sensors.c \
        input.c \
        bma250.c \
-       bh1721.c
+       bh1721.c \
+       yas530c.c
 
 LOCAL_SHARED_LIBRARIES := libutils libcutils liblog libhardware
 LOCAL_PRELINK_MODULE := false
index 256c514..dcf0a26 100644 (file)
--- a/bh1721.c
+++ b/bh1721.c
@@ -191,6 +191,11 @@ int bh1721_set_delay(struct piranha_sensors_handlers *handlers, int64_t delay)
        return 0;
 }
 
+float bh1721_light(int value)
+{
+       return (float) value * 0.712f;
+}
+
 int bh1721_get_data(struct piranha_sensors_handlers *handlers,
        struct sensors_event_t *event)
 {
@@ -216,7 +221,7 @@ int bh1721_get_data(struct piranha_sensors_handlers *handlers,
        event->sensor = handlers->handle;
        event->type = handlers->handle;
        event->timestamp = input_timestamp(&input_event);
-       event->light = (float) input_event.value * 0.712f;
+       event->light = bh1721_light(input_event.value);
 
        return 0;
 }
index f35dc2e..09ada5d 100644 (file)
--- a/bma250.c
+++ b/bma250.c
@@ -234,6 +234,7 @@ int bma250_get_data(struct piranha_sensors_handlers *handlers,
        event->acceleration.x = data->acceleration.x;
        event->acceleration.y = data->acceleration.y;
        event->acceleration.z = data->acceleration.z;
+       event->acceleration.status = SENSOR_STATUS_ACCURACY_MEDIUM;
 
        flag = 0;
        while ((flag & FLAG_ALL) != FLAG_ALL) {
index 4f86537..c1ffd07 100644 (file)
@@ -48,6 +48,7 @@ int piranha_sensors_count = sizeof(piranha_sensors) / sizeof(struct sensor_t);
 struct piranha_sensors_handlers *piranha_sensors_handlers[] = {
        &bma250,
        &bh1721,
+       &yas530c,
 };
 
 int piranha_sensors_handlers_count = sizeof(piranha_sensors_handlers) /
index bd41872..bc03835 100644 (file)
@@ -66,5 +66,6 @@ int sysfs_path_prefix(char *name, char *path_prefix);
 
 extern struct piranha_sensors_handlers bma250;
 extern struct piranha_sensors_handlers bh1721;
+extern struct piranha_sensors_handlers yas530c;
 
 #endif
diff --git a/yas530c.c b/yas530c.c
new file mode 100644 (file)
index 0000000..60af109
--- /dev/null
+++ b/yas530c.c
@@ -0,0 +1,293 @@
+/*
+ * Copyright (C) 2013 Paul Kocialkowski
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdint.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <linux/ioctl.h>
+#include <linux/input.h>
+
+#include <hardware/sensors.h>
+#include <hardware/hardware.h>
+
+#define LOG_TAG "piranha_sensors"
+#include <utils/Log.h>
+
+#include "piranha_sensors.h"
+
+#define FLAG_X         (1 << 0)
+#define FLAG_Y         (1 << 1)
+#define FLAG_Z         (1 << 2)
+#define FLAG_ALL       (FLAG_X | FLAG_Y | FLAG_Z)
+
+struct yas530c_data {
+       char path_enable[PATH_MAX];
+       char path_delay[PATH_MAX];
+
+       sensors_vec_t magnetic;
+};
+
+int yas530c_init(struct piranha_sensors_handlers *handlers)
+{
+       struct yas530c_data *data = NULL;
+       char path[PATH_MAX] = { 0 };
+       int input_fd = -1;
+       int rc;
+
+       LOGD("%s(%p)", __func__, handlers);
+
+       if (handlers == NULL)
+               return -EINVAL;
+
+       input_fd = input_open("geomagnetic");
+       if (input_fd < 0) {
+               LOGE("%s: Unable to open input", __func__);
+               goto error;
+       }
+
+       rc = sysfs_path_prefix("geomagnetic", (char *) &path);
+       if (rc < 0 || path[0] == '\0') {
+               LOGE("%s: Unable to open sysfs", __func__);
+               goto error;
+       }
+
+       data = (struct yas530c_data *) calloc(1, sizeof(struct yas530c_data));
+
+       snprintf(data->path_enable, PATH_MAX, "%s/enable", path);
+       snprintf(data->path_delay, PATH_MAX, "%s/delay", path);
+
+       handlers->poll_fd = input_fd;
+       handlers->data = (void *) data;
+
+       return 0;
+
+error:
+       if (input_fd >= 0)
+               close(input_fd);
+
+       if (data != NULL)
+               free(data);
+
+       handlers->poll_fd = -1;
+       handlers->data = NULL;
+
+       return -1;
+}
+
+int yas530c_deinit(struct piranha_sensors_handlers *handlers)
+{
+       int input_fd;
+
+       LOGD("%s(%p)", __func__, handlers);
+
+       if (handlers == NULL)
+               return -EINVAL;
+
+       input_fd = handlers->poll_fd;
+       if (input_fd >= 0)
+               close(input_fd);
+
+       handlers->poll_fd = -1;
+
+       if (handlers->data != NULL)
+               free(handlers->data);
+
+       handlers->data = NULL;
+
+       return 0;
+}
+
+int yas530c_activate(struct piranha_sensors_handlers *handlers)
+{
+       struct yas530c_data *data;
+       char enable[] = "1\n";
+       int fd;
+
+       LOGD("%s(%p)", __func__, handlers);
+
+       if (handlers == NULL || handlers->data == NULL)
+               return -EINVAL;
+
+       data = (struct yas530c_data *) handlers->data;
+
+       fd = open(data->path_enable, O_WRONLY);
+       if (fd < 0) {
+               LOGE("%s: Unable to open enable path", __func__);
+               return -1;
+       }
+
+       write(fd, &enable, sizeof(enable));
+       close(fd);
+
+       handlers->activated = 1;
+
+       return 0;
+}
+
+int yas530c_deactivate(struct piranha_sensors_handlers *handlers)
+{
+       struct yas530c_data *data;
+       char enable[] = "0\n";
+       int fd;
+
+       LOGD("%s(%p)", __func__, handlers);
+
+       if (handlers == NULL || handlers->data == NULL)
+               return -EINVAL;
+
+       data = (struct yas530c_data *) handlers->data;
+
+       fd = open(data->path_enable, O_WRONLY);
+       if (fd < 0) {
+               LOGE("%s: Unable to open enable path", __func__);
+               return -1;
+       }
+
+       write(fd, &enable, sizeof(enable));
+       close(fd);
+
+       handlers->activated = 0;
+
+       return 0;
+}
+
+int yas530c_set_delay(struct piranha_sensors_handlers *handlers, int64_t delay)
+{
+       struct yas530c_data *data;
+       char *value = NULL;
+       int d;
+       int c;
+       int fd;
+
+//     LOGD("%s(%p, %ld)", __func__, handlers, (long int) delay);
+
+       if (handlers == NULL || handlers->data == NULL)
+               return -EINVAL;
+
+       data = (struct yas530c_data *) handlers->data;
+
+       fd = open(data->path_delay, O_WRONLY);
+       if (fd < 0) {
+               LOGE("%s: Unable to open delay path", __func__);
+               return -1;
+       }
+
+       if (delay < 1000000)
+               d = 0;
+       else
+               d = (int) (delay / 1000000);
+
+       c = asprintf(&value, "%d\n", d);
+
+       write(fd, value, c);
+       close(fd);
+
+       if (value != NULL)
+               free(value);
+
+       return 0;
+}
+
+float yas530c_magnetic(int value)
+{
+       return (float) value / 1000.0f;
+}
+
+int yas530c_get_data(struct piranha_sensors_handlers *handlers,
+       struct sensors_event_t *event)
+{
+       struct yas530c_data *data;
+       struct input_event input_event;
+       int input_fd;
+       int flag;
+       int rc;
+
+       if (handlers == NULL || handlers->data == NULL || event == NULL)
+               return -EINVAL;
+
+       data = (struct yas530c_data *) handlers->data;
+
+       input_fd = handlers->poll_fd;
+       if (input_fd < 0)
+               return -EINVAL;
+
+       event->version = sizeof(struct sensors_event_t);
+       event->sensor = handlers->handle;
+       event->type = handlers->handle;
+
+       event->magnetic.x = data->magnetic.x;
+       event->magnetic.y = data->magnetic.y;
+       event->magnetic.z = data->magnetic.z;
+       event->magnetic.status = SENSOR_STATUS_ACCURACY_MEDIUM;
+
+       flag = 0;
+       while ((flag & FLAG_ALL) != FLAG_ALL) {
+               rc = read(input_fd, &input_event, sizeof(input_event));
+               if (rc < (int) sizeof(input_event)) {
+                       if (flag & FLAG_ALL)
+                               break;
+                       else
+                               return -EINVAL;
+               }
+
+               if (input_event.type != EV_ABS)
+                       continue;
+
+               switch (input_event.code) {
+                       case ABS_X:
+                               flag |= FLAG_X;
+                               event->magnetic.x = yas530c_magnetic(input_event.value);
+                               break;
+                       case ABS_Y:
+                               flag |= FLAG_Y;
+                               event->magnetic.y = yas530c_magnetic(input_event.value);
+                               break;
+                       case ABS_Z:
+                               flag |= FLAG_Z;
+                               event->magnetic.z = yas530c_magnetic(input_event.value);
+                               break;
+                       default:
+                               continue;
+               }
+               event->timestamp = input_timestamp(&input_event);
+       }
+
+       if (data->magnetic.x != event->magnetic.x)
+               data->magnetic.x = event->magnetic.x;
+       if (data->magnetic.y != event->magnetic.y)
+               data->magnetic.y = event->magnetic.y;
+       if (data->magnetic.z != event->magnetic.z)
+               data->magnetic.z = event->magnetic.z;
+
+       return 0;
+}
+
+struct piranha_sensors_handlers yas530c = {
+       .name = "YAS530C",
+       .handle = SENSOR_TYPE_MAGNETIC_FIELD,
+       .init = yas530c_init,
+       .deinit = yas530c_deinit,
+       .activate = yas530c_activate,
+       .deactivate = yas530c_deactivate,
+       .set_delay = yas530c_set_delay,
+       .get_data = yas530c_get_data,
+       .activated = 0,
+       .poll_fd = -1,
+       .data = NULL,
+};