Move mgos_imu to libs/

libs/mgos_imu/include/mgos_imu.h

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "mgos.h"
+#include "mgos_i2c.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum mgos_imu_acc_type {
+  ACC_NONE = 0,
+  ACC_MPU9250
+};
+
+enum mgos_imu_gyro_type {
+  GYRO_NONE = 0,
+  GYRO_MPU9250
+};
+
+enum mgos_imu_mag_type {
+  MAG_NONE = 0,
+  MAG_AK8963
+};
+
+struct mgos_imu;
+
+struct mgos_imu *mgos_imu_create_i2c(struct mgos_i2c *i2c);
+bool mgos_imu_add_gyroscope_i2c(struct mgos_imu *sensor, uint8_t i2caddr, enum mgos_imu_gyro_type type);
+bool mgos_imu_add_accelerometer_i2c(struct mgos_imu *sensor, uint8_t i2caddr, enum mgos_imu_acc_type type);
+bool mgos_imu_add_magnetometer_i2c(struct mgos_imu *sensor, uint8_t i2caddr, enum mgos_imu_mag_type type);
+
+void mgos_imu_destroy(struct mgos_imu **sensor);
+
+bool mgos_imu_has_accelerometer(struct mgos_imu *sensor);
+bool mgos_imu_has_gyroscope(struct mgos_imu *sensor);
+bool mgos_imu_has_magnetometer(struct mgos_imu *sensor);
+
+/* Read all available sensor data from the IMU */
+bool mgos_imu_read(struct mgos_imu *sensor);
+
+/* Return accelerometer data in units of m/s/s */
+bool mgos_imu_get_accelerometer(struct mgos_imu *sensor, float *x, float *y, float *z);
+
+/* Return accelerometer data in units of deg/sec rotation rate */
+bool mgos_imu_get_gyroscope(struct mgos_imu *sensor, float *x, float *y, float *z);
+
+/* Return magnetometer data in units of microtesla (1 microtesla = 10 milligauss) */
+bool mgos_imu_get_magnetometer(struct mgos_imu *sensor, float *x, float *y, float *z);
+
+/* Return compass heading based on magnetometer data, from [0..359] */
+bool mgos_imu_get_compass_heading(struct mgos_imu *sensor, uint16_t *heading);
+
+/*
+ * Initialization function for MGOS -- currently a noop.
+ */
+bool mgos_imu_init(void);
+
+#ifdef __cplusplus
+}
+#endif

libs/mgos_imu/src/mgos_imu.c

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "mgos.h"
+#include "mgos_imu_internal.h"
+
+// Private functions follow
+// Private functions end
+
+// Public functions follow
+struct mgos_imu *mgos_imu_create_i2c(struct mgos_i2c *i2c) {
+  struct mgos_imu *sensor;
+
+  if (!i2c) {
+    return NULL;
+  }
+
+  sensor = calloc(1, sizeof(struct mgos_imu));
+  if (!sensor) {
+    return NULL;
+  }
+  memset(sensor, 0, sizeof(struct mgos_imu));
+  return sensor;
+}
+
+void mgos_imu_destroy(struct mgos_imu **sensor) {
+  if (!*sensor) {
+    return;
+  }
+  if ((*sensor)->gyro) mgos_imu_gyro_destroy(&((*sensor)->gyro));
+  if ((*sensor)->acc) mgos_imu_acc_destroy(&((*sensor)->acc));
+  if ((*sensor)->mag) mgos_imu_mag_destroy(&((*sensor)->mag));
+
+  free(*sensor);
+  *sensor = NULL;
+  return;
+}
+
+bool mgos_imu_init(void) {
+  return true;
+}
+
+// Public functions end

libs/mgos_imu/src/mgos_imu_acc.c

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "mgos.h"
+#include "mgos_imu_internal.h"
+
+struct mgos_imu_acc *mgos_imu_acc_create(void) {
+  struct mgos_imu_acc *acc;
+  acc = calloc(1, sizeof(struct mgos_imu_acc));
+  if (!acc) return NULL;
+  memset(acc, 0, sizeof(struct mgos_imu_acc));
+
+  acc->type=ACC_NONE;
+  return acc;
+}
+
+bool mgos_imu_acc_destroy(struct mgos_imu_acc **acc) {
+  if (!*acc) return false;
+  free(*acc);
+  *acc=NULL;
+  return true;
+}

libs/mgos_imu/src/mgos_imu_gyro.c

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "mgos.h"
+#include "mgos_imu_internal.h"
+
+struct mgos_imu_gyro *mgos_imu_gyro_create(void) {
+  struct mgos_imu_gyro *gyro;
+  gyro = calloc(1, sizeof(struct mgos_imu_gyro));
+  if (!gyro) return NULL;
+  memset(gyro, 0, sizeof(struct mgos_imu_gyro));
+
+  gyro->type=GYRO_NONE;
+  return gyro;
+}
+
+bool mgos_imu_gyro_destroy(struct mgos_imu_gyro **gyro) {
+  if (!*gyro) return false;
+  free(*gyro);
+  *gyro=NULL;
+  return true;
+}

libs/mgos_imu/src/mgos_imu_internal.h

@@ -0,0 +1,103 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "mgos.h"
+#include "mgos_imu.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct mgos_imu_mag;
+struct mgos_imu_acc;
+struct mgos_imu_gyro;
+
+struct mgos_imu {
+  struct mgos_imu_mag * mag;
+  struct mgos_imu_acc * acc;
+  struct mgos_imu_gyro *gyro;
+};
+
+// Magnetometer
+typedef bool (*mgos_imu_mag_detect_fn)(struct mgos_imu_mag *dev);
+typedef bool (*mgos_imu_mag_start_fn)(struct mgos_imu_mag *dev);
+typedef bool (*mgos_imu_mag_read_fn)(struct mgos_imu_mag *dev);
+
+struct mgos_imu_mag {
+  mgos_imu_mag_detect_fn detect;
+  mgos_imu_mag_start_fn  start;
+  mgos_imu_mag_read_fn   read;
+
+  struct mgos_i2c *      i2c;
+  uint8_t                i2caddr;
+  enum mgos_imu_mag_type type;
+
+  float                  gain[3];
+  int16_t                data[3];
+};
+
+struct mgos_imu_mag *mgos_imu_mag_create(void);
+bool mgos_imu_mag_destroy(struct mgos_imu_mag **mag);
+
+// Accelerometer
+typedef bool (*mgos_imu_acc_detect_fn)(struct mgos_imu_acc *dev);
+typedef bool (*mgos_imu_acc_start_fn)(struct mgos_imu_acc *dev);
+typedef bool (*mgos_imu_acc_read_fn)(struct mgos_imu_acc *dev);
+
+struct mgos_imu_acc {
+  mgos_imu_acc_detect_fn detect;
+  mgos_imu_acc_start_fn  start;
+  mgos_imu_acc_read_fn   read;
+
+  struct mgos_i2c *      i2c;
+  uint8_t                i2caddr;
+  enum mgos_imu_acc_type type;
+
+  float                  scale;
+  int16_t                data[3];
+};
+
+struct mgos_imu_acc *mgos_imu_acc_create(void);
+bool mgos_imu_acc_destroy(struct mgos_imu_acc **acc);
+
+// Gyroscope
+typedef bool (*mgos_imu_gyro_detect_fn)(struct mgos_imu_gyro *dev);
+typedef bool (*mgos_imu_gyro_start_fn)(struct mgos_imu_gyro *dev);
+typedef bool (*mgos_imu_gyro_read_fn)(struct mgos_imu_gyro *dev);
+
+struct mgos_imu_gyro {
+  mgos_imu_gyro_detect_fn detect;
+  mgos_imu_gyro_start_fn  start;
+  mgos_imu_gyro_read_fn   read;
+
+  struct mgos_i2c *       i2c;
+  uint8_t                 i2caddr;
+  enum mgos_imu_gyro_type type;
+
+  float                   scale;
+  float                   bias[3];
+  int16_t                 data[3];
+  int16_t                 temperature;
+};
+
+struct mgos_imu_gyro *mgos_imu_gyro_create(void);
+bool mgos_imu_gyro_destroy(struct mgos_imu_gyro **gyro);
+
+#ifdef __cplusplus
+}
+#endif

libs/mgos_imu/src/mgos_imu_mag.c

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "mgos.h"
+#include "mgos_imu_internal.h"
+
+struct mgos_imu_mag *mgos_imu_mag_create(void) {
+  struct mgos_imu_mag *mag;
+  mag = calloc(1, sizeof(struct mgos_imu_mag));
+  if (!mag) return NULL;
+  memset(mag, 0, sizeof(struct mgos_imu_mag));
+
+  mag->type=MAG_NONE;
+  return mag;
+}
+
+bool mgos_imu_mag_destroy(struct mgos_imu_mag **mag) {
+  if (!*mag) return false;
+  free(*mag);
+  *mag=NULL;
+  return true;
+}