#ifndef _AO_DATA_H_
#define _AO_DATA_H_
+#define GRAVITY 9.80665
+
#if HAS_ADC
#define AO_DATA_ADC (1 << 0)
#else
#define HAS_GYRO 1
-typedef int16_t gyro_t;
-typedef int32_t angle_t;
+typedef int16_t gyro_t; /* in raw sample units */
+typedef int16_t angle_t; /* in degrees */
/* Y axis is aligned with the direction of motion (along) */
/* X axis is aligned in the other board axis (across) */
#include <ao_log.h>
#endif
+#if HAS_MPU6000
+#include <ao_quaternion.h>
+#endif
+
#ifndef HAS_ACCEL
#error Please define HAS_ACCEL
#endif
else
#endif
ao_avg_height = (ao_avg_height_scaled + 63) >> 7;
-#ifdef AO_FLIGHT_TEST
- ao_sample_prev_tick = ao_sample_tick;
-#endif
}
continue;
break;
-#if HAS_ORIENT
+#if HAS_GYRO
case ao_pyro_orient_less:
if (ao_orient <= pyro->orient_less)
continue;
{ "h<", ao_pyro_height_less, offsetof(struct ao_pyro, height_less), HELP("height less (m)") },
{ "h>", ao_pyro_height_greater, offsetof(struct ao_pyro, height_greater), HELP("height greater (m)") },
-#if HAS_ORIENT
+#if HAS_GYRO
{ "o<", ao_pyro_orient_less, offsetof(struct ao_pyro, orient_less), HELP("orient less (deg)") },
{ "o>", ao_pyro_orient_greater, offsetof(struct ao_pyro, orient_greater), HELP("orient greater (deg)") },
#endif
--- /dev/null
+/*
+ * Copyright © 2013 Keith Packard <keithp@keithp.com>
+ *
+ * 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; version 2 of the License.
+ *
+ * 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, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+#ifndef _AO_QUATERNION_H_
+#define _AO_QUATERNION_H_
+
+#include <math.h>
+
+struct ao_quaternion {
+ float r; /* real bit */
+ float x, y, z; /* imaginary bits */
+};
+
+static inline void ao_quaternion_multiply(struct ao_quaternion *r,
+ struct ao_quaternion *a,
+ struct ao_quaternion *b)
+{
+ struct ao_quaternion t;
+#define T(_a,_b) (((a)->_a) * ((b)->_b))
+ t.r = T(r,r) - T(x,x) - T(y,y) - T(z,z);
+ t.x = T(r,x) + T(x,r) + T(y,z) - T(z,y);
+ t.y = T(r,y) - T(x,z) + T(y,r) + T(z,x);
+ t.z = T(r,z) + T(x,y) - T(y,x) + T(z,r);
+#undef T
+ *r = t;
+}
+
+static inline void ao_quaternion_conjugate(struct ao_quaternion *r,
+ struct ao_quaternion *a)
+{
+ r->r = a->r;
+ r->x = -a->x;
+ r->y = -a->y;
+ r->z = -a->z;
+}
+
+static inline float ao_quaternion_normal(struct ao_quaternion *a)
+{
+#define S(_a) (((a)->_a) * ((a)->_a))
+ return S(r) + S(x) + S(y) + S(z);
+#undef S
+}
+
+static inline void ao_quaternion_scale(struct ao_quaternion *r,
+ struct ao_quaternion *a,
+ float b)
+{
+ r->r = a->r * b;
+ r->x = a->x * b;
+ r->y = a->y * b;
+ r->z = a->z * b;
+}
+
+static inline void ao_quaternion_normalize(struct ao_quaternion *r,
+ struct ao_quaternion *a)
+{
+ float n = ao_quaternion_normal(a);
+
+ if (n > 0)
+ ao_quaternion_scale(r, a, 1/sqrtf(n));
+ else
+ *r = *a;
+}
+
+static inline void ao_quaternion_rotate(struct ao_quaternion *r,
+ struct ao_quaternion *a,
+ struct ao_quaternion *b)
+{
+ struct ao_quaternion c;
+ struct ao_quaternion t;
+
+ ao_quaternion_conjugate(&c, b);
+ ao_quaternion_multiply(&t, b, a);
+ ao_quaternion_multiply(r, &t, &c);
+}
+
+static inline void ao_quaternion_init_vector(struct ao_quaternion *r,
+ float x, float y, float z)
+{
+ r->r = 0;
+ r->x = x;
+ r->y = y;
+ r->z = z;
+}
+
+static inline void ao_quaternion_init_rotation(struct ao_quaternion *r,
+ float x, float y, float z,
+ float s, float c)
+{
+ r->r = c;
+ r->x = s * x;
+ r->y = s * y;
+ r->z = s * z;
+}
+
+static inline void ao_quaternion_init_zero_rotation(struct ao_quaternion *r)
+{
+ r->r = 1;
+ r->x = r->y = r->z = 0;
+}
+
+#endif /* _AO_QUATERNION_H_ */
#include <ao_data.h>
#endif
+#if HAS_GYRO
+#include <ao_quaternion.h>
+#endif
+
/*
* Current sensor values
*/
__pdata gyro_t ao_sample_roll;
__pdata gyro_t ao_sample_pitch;
__pdata gyro_t ao_sample_yaw;
-__pdata angle_t ao_sample_angle;
-__pdata angle_t ao_sample_roll_angle;
+__pdata angle_t ao_orient;
#endif
__data uint8_t ao_sample_data;
__pdata int32_t ao_sample_pitch_sum;
__pdata int32_t ao_sample_yaw_sum;
__pdata int32_t ao_sample_roll_sum;
+static struct ao_quaternion ao_rotation;
+static struct ao_quaternion ao_pad_orientation;
#endif
static void
ao_sample_pitch_sum = 0;
ao_sample_yaw_sum = 0;
ao_sample_roll_sum = 0;
- ao_sample_angle = 0;
+ ao_orient = 0;
+
+ /* No rotation yet */
+ ao_quaternion_init_zero_rotation(&ao_rotation);
+
+ /* XXX Assume we're pointing straight up for now */
+ ao_quaternion_init_vector(&ao_pad_orientation,
+ ao_ground_accel_across,
+ ao_ground_accel_through,
+ -ao_ground_accel_along);
+ ao_quaternion_normalize(&ao_pad_orientation,
+ &ao_pad_orientation);
+
+ printf ("pad r%8.5f x%8.5f y%8.5f z%8.5f\n",
+ ao_pad_orientation.r,
+ ao_pad_orientation.x,
+ ao_pad_orientation.y,
+ ao_pad_orientation.z);
#endif
nsamples = 0;
}
+#if HAS_GYRO
+static void
+ao_sample_rotate(void)
+{
+#ifdef AO_FLIGHT_TEST
+ float dt = (ao_sample_tick - ao_sample_prev_tick) / 100.0;
+#else
+ static const float dt = 1/100.0;
+#endif
+ float x = ao_mpu6000_gyro(ao_sample_pitch - ao_ground_pitch) * dt;
+ float y = ao_mpu6000_gyro(ao_sample_yaw - ao_ground_yaw) * dt;
+ float z = ao_mpu6000_gyro(ao_sample_roll - ao_ground_roll) * dt;
+
+ float n_2, n;
+ float s, c;
+
+ struct ao_quaternion rot;
+ struct ao_quaternion point;
+
+ /* The amount of rotation is just the length of the vector. Now,
+ * here's the trick -- assume that the rotation amount is small. In this case,
+ * sin(x) ≃ x, so we can just make this the sin.
+ */
+
+ n_2 = x*x + y*y + z*z;
+ n = sqrtf(n_2);
+ s = n / 2;
+ if (s > 1)
+ s = 1;
+ c = sqrtf(1 - s*s);
+
+ /* Make unit vector */
+ if (n > 0) {
+ x /= n;
+ y /= n;
+ z /= n;
+ }
+
+ /* Now compute the unified rotation quaternion */
+
+ ao_quaternion_init_rotation(&rot,
+ x, y, z,
+ s, c);
+
+ /* Integrate with the previous rotation amount */
+ ao_quaternion_multiply(&ao_rotation, &ao_rotation, &rot);
+
+ /* And normalize to make sure it remains a unit vector */
+ ao_quaternion_normalize(&ao_rotation, &ao_rotation);
+
+ /* Compute pitch angle from vertical by taking the pad
+ * orientation vector and rotating it by the current total
+ * rotation value. That will be a unit vector pointing along
+ * the airframe axis. The Z value will be the cosine of the
+ * change in the angle from vertical since boost
+ */
+
+ ao_quaternion_rotate(&point, &ao_pad_orientation, &ao_rotation);
+
+ ao_orient = acosf(point.z) * (float) (180.0/M_PI);
+}
+#endif
+
static void
ao_sample_preflight(void)
{
ao_sample_preflight_update();
ao_kalman();
#if HAS_GYRO
- /* do quaternion stuff here... */
+ ao_sample_rotate();
#endif
}
+#ifdef AO_FLIGHT_TEST
+ ao_sample_prev_tick = ao_sample_tick;
+#endif
ao_sample_data = ao_data_ring_next(ao_sample_data);
}
return !ao_preflight;
ao_sample_pitch = 0;
ao_sample_yaw = 0;
ao_sample_roll = 0;
- ao_sample_angle = 0;
+ ao_orient = 0;
#endif
ao_sample_data = ao_data_head;
ao_preflight = TRUE;
* for all further flight computations
*/
-#define GRAVITY 9.80665
-
/*
* Above this height, the baro sensor doesn't work
*/
extern __pdata gyro_t ao_ground_pitch;
extern __pdata gyro_t ao_ground_yaw;
extern __pdata gyro_t ao_ground_roll;
+extern __pdata angle_t ao_orient;
#endif
void ao_sample_init(void);
telemetry.generic.tick = packet->tick;
telemetry.generic.type = AO_TELEMETRY_MEGA_SENSOR;
+ telemetry.mega_sensor.orient = ao_orient;
telemetry.mega_sensor.accel = ao_data_accel(packet);
telemetry.mega_sensor.pres = ao_data_pres(packet);
telemetry.mega_sensor.temp = ao_data_temp(packet);
uint16_t tick; /* 2 */
uint8_t type; /* 4 */
- uint8_t pad5; /* 5 */
+ uint8_t orient; /* 5 angle from vertical */
int16_t accel; /* 6 Z axis */
int32_t pres; /* 8 Pa * 10 */
#define G 981 /* in cm/s² */
+#if 0
static int16_t /* cm/s² */
ao_mpu6000_accel(int16_t v)
{
{
return (int16_t) ((v * (int32_t) 20000) / 32767);
}
+#endif
static uint8_t
ao_mpu6000_accel_check(int16_t normal, int16_t test, char *which)
#ifndef _AO_MPU6000_H_
#define _AO_MPU6000_H_
+#ifndef M_PI
+#define M_PI 3.1415926535897832384626433
+#endif
+
#define MPU6000_ADDR_WRITE 0xd0
#define MPU6000_ADDR_READ 0xd1
/* Self test gyro is approximately 50°/s */
#define MPU6000_ST_GYRO(full_scale) ((int16_t) (((int32_t) 32767 * (int32_t) 50) / (full_scale)))
-#define MPU6000_GYRO_FULLSCALE 2000
+#define MPU6000_GYRO_FULLSCALE ((float) 2000 * M_PI/180.0)
+
+static inline float
+ao_mpu6000_gyro(int16_t sensor) {
+ return (float) sensor * ((float) (MPU6000_GYRO_FULLSCALE / 32767.0));
+}
+
#define MPU6000_ACCEL_FULLSCALE 16
+static inline float
+ao_mpu6000_accel(int16_t sensor) {
+ return (float) sensor * ((float) (MPU6000_ACCEL_FULLSCALE * GRAVITY / 32767.0));
+}
+
struct ao_mpu6000_sample {
int16_t accel_x;
int16_t accel_y;
-vpath % ../stm:../product:../drivers:../core:../util:../kalman:../aes:..
+vpath % ../stm:../product:../drivers:../core:../util:../kalman:../aes:../math:..
vpath make-altitude ../util
vpath make-kalman ../util
vpath kalman.5c ../kalman
CC=$(ARM_CC)
LIBS=-lpdclib-cortex-m3 -lgcc
-AO_CFLAGS=-I. -I../stm -I../core -I../drivers -I..
+AO_CFLAGS=-I. -I../stm -I../core -I../drivers -I../math -I..
STM_CFLAGS=-std=gnu99 -mlittle-endian -mcpu=cortex-m3 -mthumb -ffreestanding -nostdlib $(AO_CFLAGS)
LDFLAGS=-L../stm -Wl,-Taltos.ld
ao_sample_profile.h \
ao_mpu.h \
stm32l.h \
+ math.h \
Makefile
#
#STACK_GUARD=ao_mpu_stm.c
#STACK_GUARD_DEF=-DHAS_STACK_GUARD=1
+MATH_SRC=\
+ ef_acos.c \
+ ef_sqrt.c
+
+# ef_rem_pio2.c \
+# kf_cos.c \
+# kf_sin.c \
+# kf_rem_pio2.c \
+# sf_copysign.c \
+# sf_cos.c \
+# sf_fabs.c \
+# sf_floor.c \
+# sf_scalbn.c
+
ALTOS_SRC = \
ao_boot_chain.c \
ao_interrupt.c \
ao_companion.c \
ao_pyro.c \
ao_aprs.c \
+ $(MATH_SRC) \
$(PROFILE) \
$(SAMPLE_PROFILE) \
$(STACK_GUARD)
-vpath % ..:../core:../drivers:../util:../micropeak:../aes
+vpath % ..:../core:../drivers:../util:../micropeak:../aes:../product
PROGS=ao_flight_test ao_flight_test_baro ao_flight_test_accel ao_flight_test_noisy_accel ao_flight_test_mm \
ao_gps_test ao_gps_test_skytraq ao_gps_test_ublox ao_convert_test ao_convert_pa_test ao_fec_test \
ao_aprs_test ao_micropeak_test ao_fat_test ao_aes_test ao_int64_test \
- ao_ms5607_convert_test
+ ao_ms5607_convert_test ao_quaternion_test
INCS=ao_kalman.h ao_ms5607.h ao_log.h ao_data.h altitude-pa.h altitude.h
KALMAN=make-kalman
-CFLAGS=-I.. -I. -I../core -I../drivers -I../micropeak -O0 -g -Wall
+CFLAGS=-I.. -I. -I../core -I../drivers -I../micropeak -I../product -O0 -g -Wall
all: $(PROGS) ao_aprs_data.wav
ao_ms5607_convert_test: ao_ms5607_convert_test.c ao_ms5607_convert_8051.c ao_int64.c ao_int64.h
cc $(CFLAGS) -o $@ ao_ms5607_convert_test.c
+
+ao_quaternion_test: ao_quaternion_test.c ao_quaternion.h
+ cc $(CFLAGS) -o $@ ao_quaternion_test.c -lm
\ No newline at end of file
#include <getopt.h>
#include <math.h>
+#define GRAVITY 9.80665
+
#define AO_HERTZ 100
#define HAS_ADC 1
#define AO_MS_TO_SPEED(ms) ((int16_t) ((ms) * 16))
#define AO_MSS_TO_ACCEL(mss) ((int16_t) ((mss) * 16))
+#define AO_GPS_NEW_DATA 1
+#define AO_GPS_NEW_TRACKING 2
+
+int ao_gps_new;
+
#if TELEMEGA
#define AO_ADC_NUM_SENSE 6
#define HAS_MS5607 1
#define DATA_TO_XDATA(x) (x)
-#define GRAVITY 9.80665
extern int16_t ao_ground_accel, ao_flight_accel;
extern int16_t ao_accel_2g;
exit(0);
}
-#if HAS_MPU6000
-static double
-ao_mpu6000_accel(int16_t sensor)
-{
- return sensor / 32767.0 * MPU6000_ACCEL_FULLSCALE * GRAVITY;
-}
-
-static double
-ao_mpu6000_gyro(int32_t sensor)
-{
- return sensor / 32767.0 * MPU6000_GYRO_FULLSCALE;
-}
-#endif
-
void
ao_insert(void)
{
if (!ao_summary) {
printf("%7.2f height %8.2f accel %8.3f "
#if TELEMEGA
- "roll %8.3f angle %8.3f qangle %8.3f "
- "accel_x %8.3f accel_y %8.3f accel_z %8.3f gyro_x %8.3f gyro_y %8.3f gyro_z %8.3f "
+ "angle %5d "
+/* "accel_x %8.3f accel_y %8.3f accel_z %8.3f gyro_x %8.3f gyro_y %8.3f gyro_z %8.3f " */
#endif
"state %-8.8s k_height %8.2f k_speed %8.3f k_accel %8.3f avg_height %5d drogue %4d main %4d error %5d\n",
time,
height,
accel,
#if TELEMEGA
- ao_mpu6000_gyro(ao_sample_roll_angle) / 100.0,
- ao_mpu6000_gyro(ao_sample_angle) / 100.0,
- ao_sample_qangle,
+ ao_orient,
+/*
ao_mpu6000_accel(ao_data_static.mpu6000.accel_x),
ao_mpu6000_accel(ao_data_static.mpu6000.accel_y),
ao_mpu6000_accel(ao_data_static.mpu6000.accel_z),
ao_mpu6000_gyro(ao_data_static.mpu6000.gyro_x - ao_ground_mpu6000.gyro_x),
ao_mpu6000_gyro(ao_data_static.mpu6000.gyro_y - ao_ground_mpu6000.gyro_y),
ao_mpu6000_gyro(ao_data_static.mpu6000.gyro_z - ao_ground_mpu6000.gyro_z),
+*/
#endif
ao_state_names[ao_flight_state],
ao_k_height / 65536.0,
static int log_format;
-#if TELEMEGA
-
-static double
-ao_vec_norm(double x, double y, double z)
-{
- return x*x + y*y + z*z;
-}
-
-static void
-ao_vec_normalize(double *x, double *y, double *z)
-{
- double scale = 1/sqrt(ao_vec_norm(*x, *y, *z));
-
- *x *= scale;
- *y *= scale;
- *z *= scale;
-}
-
-struct ao_quat {
- double q0, q1, q2, q3;
-};
-
-static void
-ao_quat_mul(struct ao_quat *r, struct ao_quat *a, struct ao_quat *b)
-{
- r->q0 = a->q0 * b->q0 - a->q1 * b->q1 - a->q2 * b->q2 - a->q3 * b->q3;
- r->q1 = a->q0 * b->q1 + a->q1 * b->q0 + a->q2 * b->q3 - a->q3 * b->q2;
- r->q2 = a->q0 * b->q2 - a->q1 * b->q3 + a->q2 * b->q0 + a->q3 * b->q1;
- r->q3 = a->q0 * b->q3 + a->q1 * b->q2 - a->q2 * b->q1 + a->q3 * b->q0;
-}
-
-#if 0
-static void
-ao_quat_scale(struct ao_quat *r, struct ao_quat *a, double s)
-{
- r->q0 = a->q0 * s;
- r->q1 = a->q1 * s;
- r->q2 = a->q2 * s;
- r->q3 = a->q3 * s;
-}
-#endif
-
-static void
-ao_quat_conj(struct ao_quat *r, struct ao_quat *a)
-{
- r->q0 = a->q0;
- r->q1 = -a->q1;
- r->q2 = -a->q2;
- r->q3 = -a->q3;
-}
-
-static void
-ao_quat_rot(struct ao_quat *r, struct ao_quat *a, struct ao_quat *q)
-{
- struct ao_quat t;
- struct ao_quat c;
- ao_quat_mul(&t, q, a);
- ao_quat_conj(&c, q);
- ao_quat_mul(r, &t, &c);
-}
-
-static void
-ao_quat_from_angle(struct ao_quat *r,
- double x_rad,
- double y_rad,
- double z_rad)
-{
- double angle = sqrt (x_rad * x_rad + y_rad * y_rad + z_rad * z_rad);
- double s = sin(angle/2);
- double c = cos(angle/2);
-
- r->q0 = c;
- r->q1 = x_rad * s / angle;
- r->q2 = y_rad * s / angle;
- r->q3 = z_rad * s / angle;
-}
-
-static void
-ao_quat_from_vector(struct ao_quat *r, double x, double y, double z)
-{
- ao_vec_normalize(&x, &y, &z);
- double x_rad = atan2(z, y);
- double y_rad = atan2(x, z);
- double z_rad = atan2(y, x);
-
- ao_quat_from_angle(r, x_rad, y_rad, z_rad);
-}
-
-static double
-ao_quat_norm(struct ao_quat *a)
-{
- return (a->q0 * a->q0 +
- a->q1 * a->q1 +
- a->q2 * a->q2 +
- a->q3 * a->q3);
-}
-
-static void
-ao_quat_normalize(struct ao_quat *a)
-{
- double norm = ao_quat_norm(a);
-
- if (norm) {
- double m = 1/sqrt(norm);
-
- a->q0 *= m;
- a->q1 *= m;
- a->q2 *= m;
- a->q3 *= m;
- }
-}
-
-static struct ao_quat ao_up, ao_current;
-static struct ao_quat ao_orient;
-static int ao_orient_tick;
-
-void
-set_orientation(double x, double y, double z, int tick)
-{
- struct ao_quat t;
-
- printf ("set_orientation %g %g %g\n", x, y, z);
- ao_quat_from_vector(&ao_orient, x, y, z);
- ao_up.q1 = ao_up.q2 = 0;
- ao_up.q0 = ao_up.q3 = sqrt(2)/2;
- ao_orient_tick = tick;
-
- ao_orient.q0 = 1;
- ao_orient.q1 = 0;
- ao_orient.q2 = 0;
- ao_orient.q3 = 0;
-
- printf ("orient (%g) %g %g %g up (%g) %g %g %g\n",
- ao_orient.q0,
- ao_orient.q1,
- ao_orient.q2,
- ao_orient.q3,
- ao_up.q0,
- ao_up.q1,
- ao_up.q2,
- ao_up.q3);
-
- ao_quat_rot(&t, &ao_up, &ao_orient);
- printf ("pad orient (%g) %g %g %g\n",
- t.q0,
- t.q1,
- t.q2,
- t.q3);
-
-}
-
-void
-update_orientation (double rate_x, double rate_y, double rate_z, int tick)
-{
- struct ao_quat q_dot;
- double lambda;
- double dt = (tick - ao_orient_tick) / 100.0;
-
- ao_orient_tick = tick;
-
-// lambda = 1 - ao_quat_norm(&ao_orient);
- lambda = 0;
-
- q_dot.q0 = -0.5 * (ao_orient.q1 * rate_x + ao_orient.q2 * rate_y + ao_orient.q3 * rate_z) + lambda * ao_orient.q0;
- q_dot.q1 = 0.5 * (ao_orient.q0 * rate_x + ao_orient.q2 * rate_z - ao_orient.q3 * rate_y) + lambda * ao_orient.q1;
- q_dot.q2 = 0.5 * (ao_orient.q0 * rate_y + ao_orient.q3 * rate_x - ao_orient.q1 * rate_z) + lambda * ao_orient.q2;
- q_dot.q3 = 0.5 * (ao_orient.q0 * rate_z + ao_orient.q1 * rate_y - ao_orient.q2 * rate_x) + lambda * ao_orient.q3;
-
-#if 0
- printf ("update_orientation %g %g %g (%g s)\n", rate_x, rate_y, rate_z, dt);
- printf ("q_dot (%g) %g %g %g\n",
- q_dot.q0,
- q_dot.q1,
- q_dot.q2,
- q_dot.q3);
-#endif
-
- ao_orient.q0 += q_dot.q0 * dt;
- ao_orient.q1 += q_dot.q1 * dt;
- ao_orient.q2 += q_dot.q2 * dt;
- ao_orient.q3 += q_dot.q3 * dt;
-
- ao_quat_normalize(&ao_orient);
-
- ao_quat_rot(&ao_current, &ao_up, &ao_orient);
-
- ao_sample_qangle = 180 / M_PI * acos(ao_current.q3 * sqrt(2));
-#if 0
- printf ("orient (%g) %g %g %g current (%g) %g %g %g\n",
- ao_orient.q0,
- ao_orient.q1,
- ao_orient.q2,
- ao_orient.q3,
- ao_current.q0,
- ao_current.q1,
- ao_current.q2,
- ao_current.q3);
-#endif
-}
-#endif
-
void
ao_sleep(void *wchan)
{
#if HAS_MMA655X
ao_data_static.mma655x = int16(bytes, 26);
#endif
- if (ao_records_read == 0)
- ao_ground_mpu6000 = ao_data_static.mpu6000;
- else if (ao_records_read < 10) {
-#define f(f) ao_ground_mpu6000.f = ao_ground_mpu6000.f + ((ao_data_static.mpu6000.f - ao_ground_mpu6000.f) >> 2)
- f(accel_x);
- f(accel_y);
- f(accel_z);
- f(gyro_x);
- f(gyro_y);
- f(gyro_z);
-
- double accel_x = ao_mpu6000_accel(ao_ground_mpu6000.accel_x);
- double accel_y = ao_mpu6000_accel(ao_ground_mpu6000.accel_y);
- double accel_z = ao_mpu6000_accel(ao_ground_mpu6000.accel_z);
-
- /* X and Y are in the ground plane, arbitraryily picked as MPU X and Z axes
- * Z is normal to the ground, the MPU y axis
- */
- set_orientation(accel_x, accel_z, accel_y, tick);
- } else {
- double rate_x = ao_mpu6000_gyro(ao_data_static.mpu6000.gyro_x - ao_ground_mpu6000.gyro_x);
- double rate_y = ao_mpu6000_gyro(ao_data_static.mpu6000.gyro_y - ao_ground_mpu6000.gyro_y);
- double rate_z = ao_mpu6000_gyro(ao_data_static.mpu6000.gyro_z - ao_ground_mpu6000.gyro_z);
-
- update_orientation(rate_x * M_PI / 180, rate_z * M_PI / 180, rate_y * M_PI / 180, tick);
- }
ao_records_read++;
ao_insert();
return;
--- /dev/null
+/*
+ * Copyright © 2013 Keith Packard <keithp@keithp.com>
+ *
+ * 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; version 2 of the License.
+ *
+ * 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, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+#define _GNU_SOURCE
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+#include <getopt.h>
+#include <math.h>
+
+#include "ao_quaternion.h"
+
+static void
+print_q(char *name, struct ao_quaternion *q)
+{
+ printf ("%8.8s: r%8.5f x%8.5f y%8.5f z%8.5f ", name,
+ q->r, q->x, q->y, q->z);
+}
+
+int main(int argc, char **argv)
+{
+ struct ao_quaternion position;
+ struct ao_quaternion rotation;
+ struct ao_quaternion little_rotation;
+ int i;
+
+ /* unit x vector */
+ ao_quaternion_init_vector(&position, 1, 0, 0);
+
+ /* zero rotation */
+ ao_quaternion_init_zero_rotation(&rotation);
+
+ /* π/16 rotation around Z axis */
+ ao_quaternion_init_rotation(&little_rotation, 0, 0, 1,
+ sin((M_PI/16)/2),
+ cos((M_PI/16)/2));
+ for (i = 0; i <= 16; i++) {
+ struct ao_quaternion rotated;
+
+ ao_quaternion_rotate(&rotated, &position, &rotation);
+ print_q("position", &position);
+ print_q("rotated", &rotated);
+ print_q("rotation", &rotation);
+ printf ("\n");
+ ao_quaternion_multiply(&rotation, &rotation, &little_rotation);
+ ao_quaternion_normalize(&rotation, &rotation);
+ }
+ return 0;
+}
+