Merge branch 'branch-1.8' into debian

23 files changed, 476 insertions, 380 deletions

diff --git a/src/kernel/ao.h b/src/kernel/ao.h
index e56fbb2e..139050cf 100644
--- a/src/kernel/ao.h
+++ b/src/kernel/ao.h
@@ -78,6 +78,7 @@ typedef AO_PORT_TYPE ao_port_t;
 #define AO_PANIC_SELF_TEST_CC1120	0x40 | 1	/* Self test failure */
 #define AO_PANIC_SELF_TEST_HMC5883	0x40 | 2	/* Self test failure */
 #define AO_PANIC_SELF_TEST_MPU6000	0x40 | 3	/* Self test failure */
+#define AO_PANIC_SELF_TEST_MPU9250	0x40 | 3	/* Self test failure */
 #define AO_PANIC_SELF_TEST_MS5607	0x40 | 4	/* Self test failure */
 
 /* Stop the operating system, beeping and blinking the reason */
diff --git a/src/kernel/ao_cmd.c b/src/kernel/ao_cmd.c
index 881f3500..c1e9cef2 100644
--- a/src/kernel/ao_cmd.c
+++ b/src/kernel/ao_cmd.c
@@ -304,7 +304,7 @@ version(void)
 	       , ao_flight_number
 #endif
 #if HAS_LOG
-	       , ao_log_format
+	       , AO_LOG_FORMAT
 #if !DISABLE_LOG_SPACE
 	       , (unsigned long) ao_storage_log_max
 #endif
diff --git a/src/kernel/ao_data.h b/src/kernel/ao_data.h
index d62852ef..88d0e916 100644
--- a/src/kernel/ao_data.h
+++ b/src/kernel/ao_data.h
@@ -41,6 +41,13 @@
 #define AO_DATA_MPU6000	0
 #endif
 
+#if HAS_MPU9250
+#include <ao_mpu9250.h>
+#define AO_DATA_MPU9250	(1 << 2)
+#else
+#define AO_DATA_MPU9250	0
+#endif
+
 #if HAS_HMC5883
 #include <ao_hmc5883.h>
 #define AO_DATA_HMC5883	(1 << 3)
@@ -57,7 +64,7 @@
 
 #ifdef AO_DATA_RING
 
-#define AO_DATA_ALL	(AO_DATA_ADC|AO_DATA_MS5607|AO_DATA_MPU6000|AO_DATA_HMC5883|AO_DATA_MMA655X)
+#define AO_DATA_ALL	(AO_DATA_ADC|AO_DATA_MS5607|AO_DATA_MPU6000|AO_DATA_HMC5883|AO_DATA_MMA655X|AO_DATA_MPU9250)
 
 struct ao_data {
 	uint16_t			tick;
@@ -74,6 +81,9 @@ struct ao_data {
 	int16_t				z_accel;
 #endif
 #endif
+#if HAS_MPU9250
+	struct ao_mpu9250_sample	mpu9250;
+#endif
 #if HAS_HMC5883
 	struct ao_hmc5883_sample	hmc5883;
 #endif
@@ -320,6 +330,47 @@ typedef int16_t angle_t;	/* in degrees */
 #define ao_data_pitch(packet)	((packet)->mpu6000.gyro_x)
 #define ao_data_yaw(packet)	((packet)->mpu6000.gyro_z)
 
+static inline float ao_convert_gyro(float sensor)
+{
+	return ao_mpu6000_gyro(sensor);
+}
+
+static inline float ao_convert_accel(int16_t sensor)
+{
+	return ao_mpu6000_accel(sensor);
+}
+
+#endif
+
+#if !HAS_GYRO && HAS_MPU9250
+
+#define HAS_GYRO	1
+
+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) */
+/* Z axis is aligned perpendicular to the board (through) */
+
+#define ao_data_along(packet)	((packet)->mpu9250.accel_y)
+#define ao_data_across(packet)	((packet)->mpu9250.accel_x)
+#define ao_data_through(packet)	((packet)->mpu9250.accel_z)
+
+#define ao_data_roll(packet)	((packet)->mpu9250.gyro_y)
+#define ao_data_pitch(packet)	((packet)->mpu9250.gyro_x)
+#define ao_data_yaw(packet)	((packet)->mpu9250.gyro_z)
+
+static inline float ao_convert_gyro(float sensor)
+{
+	return ao_mpu9250_gyro(sensor);
+}
+
+static inline float ao_convert_accel(int16_t sensor)
+{
+	return ao_mpu9250_accel(sensor);
+}
+
 #endif
 
 #if !HAS_MAG && HAS_HMC5883
@@ -334,4 +385,21 @@ typedef int16_t ao_mag_t;		/* in raw sample units */
 
 #endif
 
+#if !HAS_MAG && HAS_MPU9250
+
+#define HAS_MAG		1
+
+typedef int16_t ao_mag_t;		/* in raw sample units */
+
+/* Note that this order is different from the accel and gyro. For some
+ * reason, the mag sensor axes aren't the same as the other two
+ * sensors. Also, the Z axis is flipped in sign.
+ */
+
+#define ao_data_mag_along(packet)	((packet)->mpu9250.mag_x)
+#define ao_data_mag_across(packet)	((packet)->mpu9250.mag_y)
+#define ao_data_mag_through(packet)	((packet)->mpu9250.mag_z)
+
+#endif
+
 #endif /* _AO_DATA_H_ */
diff --git a/src/kernel/ao_flight.c b/src/kernel/ao_flight.c
index f06125cd..cb02c454 100644
--- a/src/kernel/ao_flight.c
+++ b/src/kernel/ao_flight.c
@@ -21,7 +21,7 @@
 #include <ao_log.h>
 #endif
 
-#if HAS_MPU6000
+#if HAS_MPU6000 || HAS_MPU9250
 #include <ao_quaternion.h>
 #endif
 
diff --git a/src/kernel/ao_gps_report.c b/src/kernel/ao_gps_report.c
index 39688fea..75c2f367 100644
--- a/src/kernel/ao_gps_report.c
+++ b/src/kernel/ao_gps_report.c
@@ -45,13 +45,13 @@ ao_gps_report(void)
 			gps_log.u.gps_time.minute = gps_data.minute;
 			gps_log.u.gps_time.second = gps_data.second;
 			gps_log.u.gps_time.flags = gps_data.flags;
-			ao_log_data(&gps_log);
+			ao_log_write(&gps_log);
 			gps_log.type = AO_LOG_GPS_LAT;
 			gps_log.u.gps_latitude = gps_data.latitude;
-			ao_log_data(&gps_log);
+			ao_log_write(&gps_log);
 			gps_log.type = AO_LOG_GPS_LON;
 			gps_log.u.gps_longitude = gps_data.longitude;
-			ao_log_data(&gps_log);
+			ao_log_write(&gps_log);
 			gps_log.type = AO_LOG_GPS_ALT;
 			gps_log.u.gps_altitude.altitude_low = gps_data.altitude_low;
 #if HAS_WIDE_GPS
@@ -59,14 +59,14 @@ ao_gps_report(void)
 #else
 			gps_log.u.gps_altitude.altitude_high = 0xffff;
 #endif
-			ao_log_data(&gps_log);
+			ao_log_write(&gps_log);
 			if (!date_reported && (gps_data.flags & AO_GPS_DATE_VALID)) {
 				gps_log.type = AO_LOG_GPS_DATE;
 				gps_log.u.gps_date.year = gps_data.year;
 				gps_log.u.gps_date.month = gps_data.month;
 				gps_log.u.gps_date.day = gps_data.day;
 				gps_log.u.gps_date.extra = 0;
-				date_reported = ao_log_data(&gps_log);
+				date_reported = ao_log_write(&gps_log);
 			}
 		}
 		if (new & AO_GPS_NEW_TRACKING) {
@@ -78,7 +78,7 @@ ao_gps_report(void)
 					if ((gps_log.u.gps_sat.svid = gps_tracking_data.sats[c].svid))
 					{
 						gps_log.u.gps_sat.c_n = gps_tracking_data.sats[c].c_n_1;
-						ao_log_data(&gps_log);
+						ao_log_write(&gps_log);
 					}
 			}
 		}
diff --git a/src/kernel/ao_gps_report_mega.c b/src/kernel/ao_gps_report_mega.c
index 8a298655..85614b85 100644
--- a/src/kernel/ao_gps_report_mega.c
+++ b/src/kernel/ao_gps_report_mega.c
@@ -105,7 +105,7 @@ ao_gps_report_mega(void)
 			gps_log.u.gps.hdop = gps_data.hdop;
 			gps_log.u.gps.vdop = gps_data.vdop;
 			gps_log.u.gps.mode = gps_data.mode;
-			ao_log_mega(&gps_log);
+			ao_log_write(&gps_log);
 		}
 		if ((new & AO_GPS_NEW_TRACKING) && (n = gps_tracking_data.channels) != 0) {
 			gps_log.tick = ao_gps_tick;
@@ -120,7 +120,7 @@ ao_gps_report_mega(void)
 						break;
 				}
 			gps_log.u.gps_sat.channels = i;
-			ao_log_mega(&gps_log);
+			ao_log_write(&gps_log);
 		}
 	}
 }
diff --git a/src/kernel/ao_gps_report_metrum.c b/src/kernel/ao_gps_report_metrum.c
index 508f1519..523fb17f 100644
--- a/src/kernel/ao_gps_report_metrum.c
+++ b/src/kernel/ao_gps_report_metrum.c
@@ -47,7 +47,7 @@ ao_gps_report_metrum(void)
 			gps_log.u.gps.longitude = gps_data.longitude;
 			gps_log.u.gps.altitude_low = gps_data.altitude_low;
 			gps_log.u.gps.altitude_high = gps_data.altitude_high;
-			ao_log_metrum(&gps_log);
+			ao_log_write(&gps_log);
 
 			gps_log.type = AO_LOG_GPS_TIME;
 			gps_log.u.gps_time.hour = gps_data.hour;
@@ -58,7 +58,7 @@ ao_gps_report_metrum(void)
 			gps_log.u.gps_time.month = gps_data.month;
 			gps_log.u.gps_time.day = gps_data.day;
 			gps_log.u.gps_time.pdop = gps_data.pdop;
-			ao_log_metrum(&gps_log);
+			ao_log_write(&gps_log);
 		}
 
 		if ((new & AO_GPS_NEW_TRACKING) && (n = gps_tracking_data.channels)) {
@@ -71,7 +71,7 @@ ao_gps_report_metrum(void)
 					if (i == 4) {
 						gps_log.u.gps_sat.channels = i;
 						gps_log.u.gps_sat.more = 1;
-						ao_log_metrum(&gps_log);
+						ao_log_write(&gps_log);
 						i = 0;
 					}
 					gps_log.u.gps_sat.sats[i].svid = svid;
@@ -82,7 +82,7 @@ ao_gps_report_metrum(void)
 			if (i) {
 				gps_log.u.gps_sat.channels = i;
 				gps_log.u.gps_sat.more = 0;
-				ao_log_metrum(&gps_log);
+				ao_log_write(&gps_log);
 			}
 		}
 	}
diff --git a/src/kernel/ao_host.h b/src/kernel/ao_host.h
index a7fa5ec2..50583f52 100644
--- a/src/kernel/ao_host.h
+++ b/src/kernel/ao_host.h
@@ -111,7 +111,7 @@ ao_dump_state(void *wchan);
 void
 ao_sleep(void *wchan);
 
-const char const * const ao_state_names[] = {
+const char * const ao_state_names[] = {
 	"startup", "idle", "pad", "boost", "fast",
 	"coast", "drogue", "main", "landed", "invalid"
 };
diff --git a/src/kernel/ao_log.c b/src/kernel/ao_log.c
index 0589b4b0..f70c7232 100644
--- a/src/kernel/ao_log.c
+++ b/src/kernel/ao_log.c
@@ -29,7 +29,7 @@ __pdata uint32_t ao_log_end_pos;
 __pdata uint32_t ao_log_start_pos;
 __xdata uint8_t	ao_log_running;
 __pdata enum ao_flight_state ao_log_state;
-__xdata uint16_t ao_flight_number;
+__xdata int16_t ao_flight_number;
 
 void
 ao_log_flush(void)
@@ -111,6 +111,85 @@ ao_log_erase_mark(void)
 	ao_config_put();
 }
 
+#ifndef AO_LOG_UNCOMMON
+/*
+ * Common logging functions which depend on the type of the log data
+ * structure.
+ */
+
+__xdata ao_log_type log;
+
+static uint8_t
+ao_log_csum(__xdata uint8_t *b) __reentrant
+{
+	uint8_t	sum = 0x5a;
+	uint8_t	i;
+
+	for (i = 0; i < sizeof (ao_log_type); i++)
+		sum += *b++;
+	return -sum;
+}
+
+uint8_t
+ao_log_write(__xdata ao_log_type *log) __reentrant
+{
+	uint8_t wrote = 0;
+	/* set checksum */
+	log->csum = 0;
+	log->csum = ao_log_csum((__xdata uint8_t *) log);
+	ao_mutex_get(&ao_log_mutex); {
+		if (ao_log_current_pos >= ao_log_end_pos && ao_log_running)
+			ao_log_stop();
+		if (ao_log_running) {
+			wrote = 1;
+			ao_storage_write(ao_log_current_pos,
+					 log,
+					 sizeof (ao_log_type));
+			ao_log_current_pos += sizeof (ao_log_type);
+		}
+	} ao_mutex_put(&ao_log_mutex);
+	return wrote;
+}
+
+uint8_t
+ao_log_check_data(void)
+{
+	if (ao_log_csum((uint8_t *) &log) != 0)
+		return 0;
+	return 1;
+}
+
+uint8_t
+ao_log_check_clear(void)
+{
+	uint8_t *b = (uint8_t *) &log;
+	uint8_t i;
+
+	for (i = 0; i < sizeof (ao_log_type); i++) {
+		if (*b++ != 0xff)
+			return 0;
+	}
+	return 1;
+}
+
+int16_t
+ao_log_flight(uint8_t slot)
+{
+	if (!ao_storage_read(ao_log_pos(slot),
+			     &log,
+			     sizeof (ao_log_type)))
+		return -(int16_t) (slot + 1);
+
+	if (ao_log_check_clear())
+		return 0;
+
+	if (!ao_log_check_data() || log.type != AO_LOG_FLIGHT)
+		return -(int16_t) (slot + 1);
+
+	return log.u.flight.flight;
+}
+#endif
+
 static uint8_t
 ao_log_slots()
 {
@@ -123,21 +202,21 @@ ao_log_pos(uint8_t slot)
 	return ((slot) * ao_config.flight_log_max);
 }
 
-static uint16_t
+static int16_t
 ao_log_max_flight(void)
 {
 	uint8_t		log_slot;
 	uint8_t		log_slots;
-	uint16_t	log_flight;
-	uint16_t	max_flight = 0;
+	int16_t		log_flight;
+	int16_t		max_flight = 0;
 
 	/* Scan the log space looking for the biggest flight number */
 	log_slots = ao_log_slots();
 	for (log_slot = 0; log_slot < log_slots; log_slot++) {
 		log_flight = ao_log_flight(log_slot);
-		if (!log_flight)
+		if (log_flight <= 0)
 			continue;
-		if (max_flight == 0 || (int16_t) (log_flight - max_flight) > 0)
+		if (max_flight == 0 || log_flight > max_flight)
 			max_flight = log_flight;
 	}
 	return max_flight;
@@ -228,24 +307,24 @@ ao_log_scan(void) __reentrant
 
 	if (ao_flight_number) {
 		uint32_t	full = ao_log_current_pos;
-		uint32_t	empty = ao_log_end_pos - ao_log_size;
+		uint32_t	empty = ao_log_end_pos - AO_LOG_SIZE;
 
 		/* If there's already a flight started, then find the
 		 * end of it
 		 */
 		for (;;) {
 			ao_log_current_pos = (full + empty) >> 1;
-			ao_log_current_pos -= ao_log_current_pos % ao_log_size;
+			ao_log_current_pos -= ao_log_current_pos % AO_LOG_SIZE;
 
 			if (ao_log_current_pos == full) {
-				if (ao_log_check(ao_log_current_pos))
-					ao_log_current_pos += ao_log_size;
+				if (ao_log_check(ao_log_current_pos) != AO_LOG_EMPTY)
+					ao_log_current_pos += AO_LOG_SIZE;
 				break;
 			}
 			if (ao_log_current_pos == empty)
 				break;
 
-			if (ao_log_check(ao_log_current_pos)) {
+			if (ao_log_check(ao_log_current_pos) != AO_LOG_EMPTY) {
 				full = ao_log_current_pos;
 			} else {
 				empty = ao_log_current_pos;
@@ -259,10 +338,11 @@ ao_log_scan(void) __reentrant
 	ao_wakeup(&ao_flight_number);
 	return ret;
 #else
-
-	if (ao_flight_number)
-		if (++ao_flight_number == 0)
+	if (ao_flight_number) {
+		++ao_flight_number;
+		if (ao_flight_number <= 0)
 			ao_flight_number = 1;
+	}
 
 	ao_log_find_max_erase_flight();
 
@@ -330,7 +410,7 @@ ao_log_list(void) __reentrant
 {
 	uint8_t	slot;
 	uint8_t slots;
-	uint16_t flight;
+	int16_t flight;
 
 	slots = ao_log_slots();
 	for (slot = 0; slot < slots; slot++)
@@ -350,18 +430,25 @@ ao_log_delete(void) __reentrant
 {
 	uint8_t slot;
 	uint8_t slots;
+	int16_t cmd_flight = 1;
 
+	ao_cmd_white();
+	if (ao_cmd_lex_c == '-') {
+		cmd_flight = -1;
+		ao_cmd_lex();
+	}
 	ao_cmd_decimal();
 	if (ao_cmd_status != ao_cmd_success)
 		return;
+	cmd_flight *= (int16_t) ao_cmd_lex_i;
 
 	slots = ao_log_slots();
 	/* Look for the flight log matching the requested flight */
-	if (ao_cmd_lex_i) {
+	if (cmd_flight) {
 		for (slot = 0; slot < slots; slot++) {
-			if (ao_log_flight(slot) == ao_cmd_lex_i) {
+			if (ao_log_flight(slot) == cmd_flight) {
 #if HAS_TRACKER
-				ao_tracker_erase_start(ao_cmd_lex_i);
+				ao_tracker_erase_start(cmd_flight);
 #endif
 				ao_log_erase(slot);
 #if HAS_TRACKER
@@ -372,7 +459,7 @@ ao_log_delete(void) __reentrant
 			}
 		}
 	}
-	printf("No such flight: %d\n", ao_cmd_lex_i);
+	printf("No such flight: %d\n", cmd_flight);
 }
 
 __code struct ao_cmds ao_log_cmds[] = {
diff --git a/src/kernel/ao_log.h b/src/kernel/ao_log.h
index aca669db..5f04ef9a 100644
--- a/src/kernel/ao_log.h
+++ b/src/kernel/ao_log.h
@@ -29,7 +29,7 @@
  * the log. Tasks may wait for this to be initialized
  * by sleeping on this variable.
  */
-extern __xdata uint16_t ao_flight_number;
+extern __xdata int16_t ao_flight_number;
 extern __xdata uint8_t	ao_log_mutex;
 extern __pdata uint32_t ao_log_current_pos;
 extern __pdata uint32_t ao_log_end_pos;
@@ -54,17 +54,28 @@ extern __pdata enum ao_flight_state ao_log_state;
 #define AO_LOG_FORMAT_TELEMINI3		12	/* 16-byte MS5607 baro only, 3.3V supply, stm32f042 SoC */
 #define AO_LOG_FORMAT_TELEFIRETWO	13	/* 32-byte test stand data */
 #define AO_LOG_FORMAT_EASYMINI2		14	/* 16-byte MS5607 baro only, 3.3V supply, stm32f042 SoC */
+#define AO_LOG_FORMAT_TELEMEGA_3	15	/* 32 byte typed telemega records with 32 bit gyro cal and mpu9250 */
 #define AO_LOG_FORMAT_NONE		127	/* No log at all */
 
-extern __code uint8_t ao_log_format;
-extern __code uint8_t ao_log_size;
+/* Return the flight number from the given log slot, 0 if none, -slot on failure */
 
-/* Return the flight number from the given log slot, 0 if none */
-uint16_t
+int16_t
 ao_log_flight(uint8_t slot);
 
-/* Check if there is valid log data at the specified location */
+/* Checksum the loaded log record */
+uint8_t
+ao_log_check_data(void);
+
+/* Check to see if the loaded log record is empty */
 uint8_t
+ao_log_check_clear(void);
+
+/* Check if there is valid log data at the specified location */
+#define AO_LOG_VALID	1
+#define AO_LOG_EMPTY	0
+#define AO_LOG_INVALID 	-1
+
+int8_t
 ao_log_check(uint32_t pos);
 
 /* Flush the log */
@@ -463,21 +474,48 @@ struct ao_log_gps {
 	} u;
 };
 
-/* Write a record to the eeprom log */
-uint8_t
-ao_log_data(__xdata struct ao_log_record *log) __reentrant;
+#if AO_LOG_FORMAT == AO_LOG_FOMAT_TELEMEGA_OLD || AO_LOG_FORMAT == AO_LOG_FORMAT_TELEMEGA || AO_LOG_FORMAT == AO_LOG_FORMAT_TELEMEGA_3
+typedef struct ao_log_mega ao_log_type;
+#endif
 
-uint8_t
-ao_log_mega(__xdata struct ao_log_mega *log) __reentrant;
+#if AO_LOG_FORMAT == AO_LOG_FORMAT_TELEMETRUM
+typedef struct ao_log_metrum ao_log_type;
+#endif
 
-uint8_t
-ao_log_metrum(__xdata struct ao_log_metrum *log) __reentrant;
+#if AO_LOG_FORMAT == AO_LOG_FORMAT_EASYMINI1 || AO_LOG_FORMAT == AO_LOG_FORMAT_EASYMINI2 || AO_LOG_FORMAT == AO_LOG_FORMAT_TELEMINI2 || AO_LOG_FORMAT == AO_LOG_FORMAT_TELEMINI3
+typedef struct ao_log_mini ao_log_type;
+#endif
 
-uint8_t
-ao_log_mini(__xdata struct ao_log_mini *log) __reentrant;
+#if AO_LOG_FORMAT == AO_LOG_FORMAT_TELEGPS
+typedef struct ao_log_gps ao_log_type;
+#endif
+
+#if AO_LOG_FORMAT == AO_LOG_FORMAT_FULL
+typedef struct ao_log_record ao_log_type;
+#endif
+
+#if AO_LOG_FORMAT == AO_LOG_FORMAT_TINY
+#define AO_LOG_UNCOMMON	1
+#endif
+
+#if AO_LOG_FORMAT == AO_LOG_FORMAT_TELEMETRY
+#define AO_LOG_UNCOMMON	1
+#endif
+
+#if AO_LOG_FORMAT == AO_LOG_FORMAT_TELESCIENCE
+#define AO_LOG_UNCOMMON	1
+#endif
+
+#ifndef AO_LOG_UNCOMMON
+extern __xdata ao_log_type log;
+
+#define AO_LOG_SIZE sizeof(ao_log_type)
+
+/* Write a record to the eeprom log */
 
 uint8_t
-ao_log_gps(__xdata struct ao_log_gps *log) __reentrant;
+ao_log_write(__xdata ao_log_type *log) __reentrant;
+#endif
 
 void
 ao_log_flush(void);
diff --git a/src/kernel/ao_log_big.c b/src/kernel/ao_log_big.c
index e32abd1a..28a893c7 100644
--- a/src/kernel/ao_log_big.c
+++ b/src/kernel/ao_log_big.c
@@ -18,50 +18,6 @@
 
 #include "ao.h"
 
-static __xdata struct ao_log_record log;
-
-__code uint8_t ao_log_format = AO_LOG_FORMAT_FULL;
-
-static uint8_t
-ao_log_csum(__xdata uint8_t *b) __reentrant
-{
-	uint8_t	sum = 0x5a;
-	uint8_t	i;
-
-	for (i = 0; i < sizeof (struct ao_log_record); i++)
-		sum += *b++;
-	return -sum;
-}
-
-uint8_t
-ao_log_data(__xdata struct ao_log_record *log) __reentrant
-{
-	uint8_t wrote = 0;
-	/* set checksum */
-	log->csum = 0;
-	log->csum = ao_log_csum((__xdata uint8_t *) log);
-	ao_mutex_get(&ao_log_mutex); {
-		if (ao_log_current_pos >= ao_log_end_pos && ao_log_running)
-			ao_log_stop();
-		if (ao_log_running) {
-			wrote = 1;
-			ao_storage_write(ao_log_current_pos,
-					 log,
-					 sizeof (struct ao_log_record));
-			ao_log_current_pos += sizeof (struct ao_log_record);
-		}
-	} ao_mutex_put(&ao_log_mutex);
-	return wrote;
-}
-
-static uint8_t
-ao_log_dump_check_data(void)
-{
-	if (ao_log_csum((uint8_t *) &log) != 0)
-		return 0;
-	return 1;
-}
-
 static __data uint8_t	ao_log_data_pos;
 
 /* a hack to make sure that ao_log_records fill the eeprom block in even units */
@@ -91,7 +47,7 @@ ao_log(void)
 	log.u.flight.ground_accel = ao_ground_accel;
 #endif
 	log.u.flight.flight = ao_flight_number;
-	ao_log_data(&log);
+	ao_log_write(&log);
 
 	/* Write the whole contents of the ring to the log
 	 * when starting up.
@@ -107,7 +63,7 @@ ao_log(void)
 				log.type = AO_LOG_SENSOR;
 				log.u.sensor.accel = ao_data_ring[ao_log_data_pos].adc.accel;
 				log.u.sensor.pres = ao_data_ring[ao_log_data_pos].adc.pres;
-				ao_log_data(&log);
+				ao_log_write(&log);
 				if (ao_log_state <= ao_flight_coast)
 					next_sensor = log.tick + AO_SENSOR_INTERVAL_ASCENT;
 				else
@@ -117,11 +73,11 @@ ao_log(void)
 				log.type = AO_LOG_TEMP_VOLT;
 				log.u.temp_volt.temp = ao_data_ring[ao_log_data_pos].adc.temp;
 				log.u.temp_volt.v_batt = ao_data_ring[ao_log_data_pos].adc.v_batt;
-				ao_log_data(&log);
+				ao_log_write(&log);
 				log.type = AO_LOG_DEPLOY;
 				log.u.deploy.drogue = ao_data_ring[ao_log_data_pos].adc.sense_d;
 				log.u.deploy.main = ao_data_ring[ao_log_data_pos].adc.sense_m;
-				ao_log_data(&log);
+				ao_log_write(&log);
 				next_other = log.tick + AO_OTHER_INTERVAL;
 			}
 			ao_log_data_pos = ao_data_ring_next(ao_log_data_pos);
@@ -133,7 +89,7 @@ ao_log(void)
 			log.tick = ao_sample_tick;
 			log.u.state.state = ao_log_state;
 			log.u.state.reason = 0;
-			ao_log_data(&log);
+			ao_log_write(&log);
 
 			if (ao_log_state == ao_flight_landed)
 				ao_log_stop();
@@ -147,16 +103,3 @@ ao_log(void)
 			ao_sleep(&ao_log_running);
 	}
 }
-
-uint16_t
-ao_log_flight(uint8_t slot)
-{
-	if (!ao_storage_read(ao_log_pos(slot),
-			     &log,
-			     sizeof (struct ao_log_record)))
-		return 0;
-
-	if (ao_log_dump_check_data() && log.type == AO_LOG_FLIGHT)
-		return log.u.flight.flight;
-	return 0;
-}
diff --git a/src/kernel/ao_log_gps.c b/src/kernel/ao_log_gps.c
index 02551169..a55d93f1 100644
--- a/src/kernel/ao_log_gps.c
+++ b/src/kernel/ao_log_gps.c
@@ -24,50 +24,13 @@
 #include <ao_distance.h>
 #include <ao_tracker.h>
 
-static __xdata struct ao_log_gps log;
-
-__code uint8_t ao_log_format = AO_LOG_FORMAT_TELEGPS;
-__code uint8_t ao_log_size = sizeof (struct ao_log_gps);
-
-static uint8_t
-ao_log_csum(__xdata uint8_t *b) __reentrant
-{
-	uint8_t	sum = 0x5a;
-	uint8_t	i;
-
-	for (i = 0; i < sizeof (struct ao_log_gps); i++)
-		sum += *b++;
-	return -sum;
-}
-
-uint8_t
-ao_log_gps(__xdata struct ao_log_gps *log) __reentrant
-{
-	uint8_t wrote = 0;
-	/* set checksum */
-	log->csum = 0;
-	log->csum = ao_log_csum((__xdata uint8_t *) log);
-	ao_mutex_get(&ao_log_mutex); {
-		if (ao_log_current_pos >= ao_log_end_pos && ao_log_running)
-			ao_log_stop();
-		if (ao_log_running) {
-			wrote = 1;
-			ao_storage_write(ao_log_current_pos,
-					 log,
-					 sizeof (struct ao_log_gps));
-			ao_log_current_pos += sizeof (struct ao_log_gps);
-		}
-	} ao_mutex_put(&ao_log_mutex);
-	return wrote;
-}
-
 void
 ao_log_gps_flight(void)
 {
 	log.type = AO_LOG_FLIGHT;
 	log.tick = ao_time();
 	log.u.flight.flight = ao_flight_number;
-	ao_log_gps(&log);
+	ao_log_write(&log);
 }
 
 void
@@ -94,7 +57,7 @@ ao_log_gps_data(uint16_t tick, struct ao_telemetry_location *gps_data)
 	log.u.gps.hdop = gps_data->hdop;
 	log.u.gps.vdop = gps_data->vdop;
 	log.u.gps.mode = gps_data->mode;
-	ao_log_gps(&log);
+	ao_log_write(&log);
 }
 
 void
@@ -115,39 +78,21 @@ ao_log_gps_tracking(uint16_t tick, struct ao_telemetry_satellite *gps_tracking_d
 				break;
 		}
 	log.u.gps_sat.channels = i;
-	ao_log_gps(&log);
+	ao_log_write(&log);
 }
 
-static uint8_t
-ao_log_dump_check_data(void)
-{
-	if (ao_log_csum((uint8_t *) &log) != 0)
-		return 0;
-	return 1;
-}
-
-uint16_t
-ao_log_flight(uint8_t slot)
-{
-	if (!ao_storage_read(ao_log_pos(slot),
-			     &log,
-			     sizeof (struct ao_log_gps)))
-		return 0;
-
-	if (ao_log_dump_check_data() && log.type == AO_LOG_FLIGHT)
-		return log.u.flight.flight;
-	return 0;
-}
-
-uint8_t
+int8_t
 ao_log_check(uint32_t pos)
 {
 	if (!ao_storage_read(pos,
 			     &log,
 			     sizeof (struct ao_log_gps)))
-		return 0;
+		return AO_LOG_INVALID;
+
+	if (ao_log_check_clear())
+		return AO_LOG_EMPTY;
 
-	if (ao_log_dump_check_data())
-		return 1;
-	return 0;
+	if (!ao_log_check_data())
+		return AO_LOG_INVALID;
+	return AO_LOG_VALID;
 }
diff --git a/src/kernel/ao_log_mega.c b/src/kernel/ao_log_mega.c
index b86abe7a..c6bdf1e2 100644
--- a/src/kernel/ao_log_mega.c
+++ b/src/kernel/ao_log_mega.c
@@ -21,50 +21,6 @@
 #include <ao_data.h>
 #include <ao_flight.h>
 
-static __xdata struct ao_log_mega log;
-
-__code uint8_t ao_log_format = AO_LOG_FORMAT_TELEMEGA;
-
-static uint8_t
-ao_log_csum(__xdata uint8_t *b) __reentrant
-{
-	uint8_t	sum = 0x5a;
-	uint8_t	i;
-
-	for (i = 0; i < sizeof (struct ao_log_mega); i++)
-		sum += *b++;
-	return -sum;
-}
-
-uint8_t
-ao_log_mega(__xdata struct ao_log_mega *log) __reentrant
-{
-	uint8_t wrote = 0;
-	/* set checksum */
-	log->csum = 0;
-	log->csum = ao_log_csum((__xdata uint8_t *) log);
-	ao_mutex_get(&ao_log_mutex); {
-		if (ao_log_current_pos >= ao_log_end_pos && ao_log_running)
-			ao_log_stop();
-		if (ao_log_running) {
-			wrote = 1;
-			ao_storage_write(ao_log_current_pos,
-					 log,
-					 sizeof (struct ao_log_mega));
-			ao_log_current_pos += sizeof (struct ao_log_mega);
-		}
-	} ao_mutex_put(&ao_log_mutex);
-	return wrote;
-}
-
-static uint8_t
-ao_log_dump_check_data(void)
-{
-	if (ao_log_csum((uint8_t *) &log) != 0)
-		return 0;
-	return 1;
-}
-
 #if HAS_FLIGHT
 static __data uint8_t	ao_log_data_pos;
 
@@ -106,7 +62,7 @@ ao_log(void)
 #endif
 	log.u.flight.ground_pres = ao_ground_pres;
 	log.u.flight.flight = ao_flight_number;
-	ao_log_mega(&log);
+	ao_log_write(&log);
 #endif
 
 	/* Write the whole contents of the ring to the log
@@ -138,8 +94,19 @@ ao_log(void)
 				log.u.sensor.mag_z = ao_data_ring[ao_log_data_pos].hmc5883.z;
 				log.u.sensor.mag_y = ao_data_ring[ao_log_data_pos].hmc5883.y;
 #endif
+#if HAS_MPU9250
+				log.u.sensor.accel_x = ao_data_ring[ao_log_data_pos].mpu9250.accel_x;
+				log.u.sensor.accel_y = ao_data_ring[ao_log_data_pos].mpu9250.accel_y;
+				log.u.sensor.accel_z = ao_data_ring[ao_log_data_pos].mpu9250.accel_z;
+				log.u.sensor.gyro_x = ao_data_ring[ao_log_data_pos].mpu9250.gyro_x;
+				log.u.sensor.gyro_y = ao_data_ring[ao_log_data_pos].mpu9250.gyro_y;
+				log.u.sensor.gyro_z = ao_data_ring[ao_log_data_pos].mpu9250.gyro_z;
+				log.u.sensor.mag_x = ao_data_ring[ao_log_data_pos].mpu9250.mag_x;
+				log.u.sensor.mag_z = ao_data_ring[ao_log_data_pos].mpu9250.mag_z;
+				log.u.sensor.mag_y = ao_data_ring[ao_log_data_pos].mpu9250.mag_y;
+#endif
 				log.u.sensor.accel = ao_data_accel(&ao_data_ring[ao_log_data_pos]);
-				ao_log_mega(&log);
+				ao_log_write(&log);
 				if (ao_log_state <= ao_flight_coast)
 					next_sensor = log.tick + AO_SENSOR_INTERVAL_ASCENT;
 				else
@@ -153,7 +120,7 @@ ao_log(void)
 				for (i = 0; i < AO_ADC_NUM_SENSE; i++)
 					log.u.volt.sense[i] = ao_data_ring[ao_log_data_pos].adc.sense[i];
 				log.u.volt.pyro = ao_pyro_fired;
-				ao_log_mega(&log);
+				ao_log_write(&log);
 				next_other = log.tick + AO_OTHER_INTERVAL;
 			}
 			ao_log_data_pos = ao_data_ring_next(ao_log_data_pos);
@@ -166,7 +133,7 @@ ao_log(void)
 			log.tick = ao_time();
 			log.u.state.state = ao_log_state;
 			log.u.state.reason = 0;
-			ao_log_mega(&log);
+			ao_log_write(&log);
 
 			if (ao_log_state == ao_flight_landed)
 				ao_log_stop();
@@ -185,15 +152,3 @@ ao_log(void)
 }
 #endif /* HAS_FLIGHT */
 
-uint16_t
-ao_log_flight(uint8_t slot)
-{
-	if (!ao_storage_read(ao_log_pos(slot),
-			     &log,
-			     sizeof (struct ao_log_mega)))
-		return 0;
-
-	if (ao_log_dump_check_data() && log.type == AO_LOG_FLIGHT)
-		return log.u.flight.flight;
-	return 0;
-}
diff --git a/src/kernel/ao_log_metrum.c b/src/kernel/ao_log_metrum.c
index 154b1740..afb8f637 100644
--- a/src/kernel/ao_log_metrum.c
+++ b/src/kernel/ao_log_metrum.c
@@ -21,50 +21,6 @@
 #include <ao_data.h>
 #include <ao_flight.h>
 
-static __xdata struct ao_log_metrum log;
-
-__code uint8_t ao_log_format = AO_LOG_FORMAT_TELEMETRUM;
-
-static uint8_t
-ao_log_csum(__xdata uint8_t *b) __reentrant
-{
-	uint8_t	sum = 0x5a;
-	uint8_t	i;
-
-	for (i = 0; i < sizeof (struct ao_log_metrum); i++)
-		sum += *b++;
-	return -sum;
-}
-
-uint8_t
-ao_log_metrum(__xdata struct ao_log_metrum *log) __reentrant
-{
-	uint8_t wrote = 0;
-	/* set checksum */
-	log->csum = 0;
-	log->csum = ao_log_csum((__xdata uint8_t *) log);
-	ao_mutex_get(&ao_log_mutex); {
-		if (ao_log_current_pos >= ao_log_end_pos && ao_log_running)
-			ao_log_stop();
-		if (ao_log_running) {
-			wrote = 1;
-			ao_storage_write(ao_log_current_pos,
-					 log,
-					 sizeof (struct ao_log_metrum));
-			ao_log_current_pos += sizeof (struct ao_log_metrum);
-		}
-	} ao_mutex_put(&ao_log_mutex);
-	return wrote;
-}
-
-static uint8_t
-ao_log_dump_check_data(void)
-{
-	if (ao_log_csum((uint8_t *) &log) != 0)
-		return 0;
-	return 1;
-}
-
 #if HAS_ADC
 static __data uint8_t	ao_log_data_pos;
 
@@ -97,7 +53,7 @@ ao_log(void)
 #endif
 	log.u.flight.ground_pres = ao_ground_pres;
 	log.u.flight.flight = ao_flight_number;
-	ao_log_metrum(&log);
+	ao_log_write(&log);
 #endif
 
 	/* Write the whole contents of the ring to the log
@@ -119,7 +75,7 @@ ao_log(void)
 #if HAS_ACCEL
 				log.u.sensor.accel = ao_data_accel(&ao_data_ring[ao_log_data_pos]);
 #endif
-				ao_log_metrum(&log);
+				ao_log_write(&log);
 				if (ao_log_state <= ao_flight_coast)
 					next_sensor = log.tick + AO_SENSOR_INTERVAL_ASCENT;
 				else
@@ -130,7 +86,7 @@ ao_log(void)
 				log.u.volt.v_batt = ao_data_ring[ao_log_data_pos].adc.v_batt;
 				log.u.volt.sense_a = ao_data_ring[ao_log_data_pos].adc.sense_a;
 				log.u.volt.sense_m = ao_data_ring[ao_log_data_pos].adc.sense_m;
-				ao_log_metrum(&log);
+				ao_log_write(&log);
 				next_other = log.tick + AO_OTHER_INTERVAL;
 			}
 			ao_log_data_pos = ao_data_ring_next(ao_log_data_pos);
@@ -143,7 +99,7 @@ ao_log(void)
 			log.tick = ao_time();
 			log.u.state.state = ao_log_state;
 			log.u.state.reason = 0;
-			ao_log_metrum(&log);
+			ao_log_write(&log);
 
 			if (ao_log_state == ao_flight_landed)
 				ao_log_stop();
@@ -161,16 +117,3 @@ ao_log(void)
 	}
 }
 #endif
-
-uint16_t
-ao_log_flight(uint8_t slot)
-{
-	if (!ao_storage_read(ao_log_pos(slot),
-			     &log,
-			     sizeof (struct ao_log_metrum)))
-		return 0;
-
-	if (ao_log_dump_check_data() && log.type == AO_LOG_FLIGHT)
-		return log.u.flight.flight;
-	return 0;
-}
diff --git a/src/kernel/ao_log_mini.c b/src/kernel/ao_log_mini.c
index d5735cdc..af2fa605 100644
--- a/src/kernel/ao_log_mini.c
+++ b/src/kernel/ao_log_mini.c
@@ -21,50 +21,6 @@
 #include <ao_data.h>
 #include <ao_flight.h>
 
-static __xdata struct ao_log_mini log;
-
-__code uint8_t ao_log_format = AO_LOG_FORMAT;
-
-static uint8_t
-ao_log_csum(__xdata uint8_t *b) __reentrant
-{
-	uint8_t	sum = 0x5a;
-	uint8_t	i;
-
-	for (i = 0; i < sizeof (struct ao_log_mini); i++)
-		sum += *b++;
-	return -sum;
-}
-
-uint8_t
-ao_log_mini(__xdata struct ao_log_mini *log) __reentrant
-{
-	uint8_t wrote = 0;
-	/* set checksum */
-	log->csum = 0;
-	log->csum = ao_log_csum((__xdata uint8_t *) log);
-	ao_mutex_get(&ao_log_mutex); {
-		if (ao_log_current_pos >= ao_log_end_pos && ao_log_running)
-			ao_log_stop();
-		if (ao_log_running) {
-			wrote = 1;
-			ao_storage_write(ao_log_current_pos,
-					 log,
-					 sizeof (struct ao_log_mini));
-			ao_log_current_pos += sizeof (struct ao_log_mini);
-		}
-	} ao_mutex_put(&ao_log_mutex);
-	return wrote;
-}
-
-static uint8_t
-ao_log_dump_check_data(void)
-{
-	if (ao_log_csum((uint8_t *) &log) != 0)
-		return 0;
-	return 1;
-}
-
 static __data uint8_t	ao_log_data_pos;
 
 /* a hack to make sure that ao_log_minis fill the eeprom block in even units */
@@ -92,7 +48,7 @@ ao_log(void)
 	log.tick = ao_sample_tick;
 	log.u.flight.flight = ao_flight_number;
 	log.u.flight.ground_pres = ao_ground_pres;
-	ao_log_mini(&log);
+	ao_log_write(&log);
 #endif
 
 	/* Write the whole contents of the ring to the log
@@ -116,7 +72,7 @@ ao_log(void)
 				log.u.sensor.sense_m = ao_data_ring[ao_log_data_pos].adc.sense_m;
 				log.u.sensor.v_batt = ao_data_ring[ao_log_data_pos].adc.v_batt;
 #endif
-				ao_log_mini(&log);
+				ao_log_write(&log);
 				if (ao_log_state <= ao_flight_coast)
 					next_sensor = log.tick + AO_SENSOR_INTERVAL_ASCENT;
 				else
@@ -132,7 +88,7 @@ ao_log(void)
 			log.tick = ao_time();
 			log.u.state.state = ao_log_state;
 			log.u.state.reason = 0;
-			ao_log_mini(&log);
+			ao_log_write(&log);
 
 			if (ao_log_state == ao_flight_landed)
 				ao_log_stop();
@@ -149,16 +105,3 @@ ao_log(void)
 			ao_sleep(&ao_log_running);
 	}
 }
-
-uint16_t
-ao_log_flight(uint8_t slot)
-{
-	if (!ao_storage_read(ao_log_pos(slot),
-			     &log,
-			     sizeof (struct ao_log_mini)))
-		return 0;
-
-	if (ao_log_dump_check_data() && log.type == AO_LOG_FLIGHT)
-		return log.u.flight.flight;
-	return 0;
-}
diff --git a/src/kernel/ao_log_tiny.c b/src/kernel/ao_log_tiny.c
index 7769b7b5..0b8e39d6 100644
--- a/src/kernel/ao_log_tiny.c
+++ b/src/kernel/ao_log_tiny.c
@@ -29,8 +29,6 @@ static __data uint16_t	ao_log_tiny_interval;
 #define AO_PAD_RING	2
 #endif
 
-__code uint8_t ao_log_format = AO_LOG_FORMAT_TINY;
-
 void
 ao_log_tiny_set_interval(uint16_t ticks)
 {
@@ -149,7 +147,7 @@ ao_log(void)
 	}
 }
 
-uint16_t
+int16_t
 ao_log_flight(uint8_t slot)
 {
 	static __xdata uint16_t flight;
diff --git a/src/kernel/ao_pyro.c b/src/kernel/ao_pyro.c
index 9543b3ef..e5c30eec 100644
--- a/src/kernel/ao_pyro.c
+++ b/src/kernel/ao_pyro.c
@@ -76,7 +76,7 @@ uint16_t	ao_pyro_fired;
 
 #if PYRO_DBG
 int pyro_dbg;
-#define DBG(...)	do { if (pyro_dbg) printf("\t%d: ", (int) (pyro - ao_config.pyro)); printf(__VA_ARGS__); } while (0)
+#define DBG(...)	do { if (pyro_dbg) { printf("\t%d: ", (int) (pyro - ao_config.pyro)); printf(__VA_ARGS__); } } while (0)
 #else
 #define DBG(...)
 #endif
@@ -239,11 +239,8 @@ ao_pyro_pins_fire(uint16_t fire)
 	}
 	ao_delay(ao_config.pyro_time);
 	for (p = 0; p < AO_PYRO_NUM; p++) {
-		if (fire & (1 << p)) {
+		if (fire & (1 << p))
 			ao_pyro_pin_set(p, 0);
-			ao_config.pyro[p].fired = 1;
-			ao_pyro_fired |= (1 << p);
-		}
 	}
 	ao_delay(AO_MS_TO_TICKS(50));
 }
@@ -261,7 +258,7 @@ ao_pyro_check(void)
 
 		/* Ignore igniters which have already fired
 		 */
-		if (pyro->fired)
+		if (ao_pyro_fired & (1 << p))
 			continue;
 
 		/* Ignore disabled igniters
@@ -296,7 +293,7 @@ ao_pyro_check(void)
 			 * by setting the fired bit
 			 */
 			if (!ao_pyro_ready(pyro)) {
-				pyro->fired = 1;
+				ao_pyro_fired |= (1 << p);
 				continue;
 			}
 
@@ -307,8 +304,10 @@ ao_pyro_check(void)
 		fire |= (1 << p);
 	}
 
-	if (fire)
+	if (fire) {
+		ao_pyro_fired |= fire;
 		ao_pyro_pins_fire(fire);
+	}
 
 	return any_waiting;
 }
@@ -482,7 +481,7 @@ ao_pyro_set(void)
 			break;
 
 		for (c = 0; c < AO_PYRO_NAME_LEN - 1; c++) {
-			if (ao_cmd_is_white())
+			if (ao_cmd_is_white() || ao_cmd_lex_c == '\n')
 				break;
 			name[c] = ao_cmd_lex_c;
 			ao_cmd_lex();
diff --git a/src/kernel/ao_pyro.h b/src/kernel/ao_pyro.h
index a730ef19..3ab5af3b 100644
--- a/src/kernel/ao_pyro.h
+++ b/src/kernel/ao_pyro.h
@@ -63,7 +63,7 @@ struct ao_pyro {
 	uint8_t			state_less, state_greater_or_equal;
 	int16_t			motor;
 	uint16_t		delay_done;
-	uint8_t			fired;
+	uint8_t			_unused;	/* was 'fired' */
 };
 
 #define AO_PYRO_8_BIT_VALUE	(ao_pyro_state_less|ao_pyro_state_greater_or_equal)
diff --git a/src/kernel/ao_sample.c b/src/kernel/ao_sample.c
index f0ab0169..61519478 100644
--- a/src/kernel/ao_sample.c
+++ b/src/kernel/ao_sample.c
@@ -184,9 +184,9 @@ ao_sample_rotate(void)
 #else
 	static const float dt = 1/TIME_DIV;
 #endif
-	float	x = ao_mpu6000_gyro((float) ((ao_sample_pitch << 9) - ao_ground_pitch) / 512.0f) * dt;
-	float	y = ao_mpu6000_gyro((float) ((ao_sample_yaw << 9) - ao_ground_yaw) / 512.0f) * dt;
-	float	z = ao_mpu6000_gyro((float) ((ao_sample_roll << 9) - ao_ground_roll) / 512.0f) * dt;
+	float	x = ao_convert_gyro((float) ((ao_sample_pitch << 9) - ao_ground_pitch) / 512.0f) * dt;
+	float	y = ao_convert_gyro((float) ((ao_sample_yaw << 9) - ao_ground_yaw) / 512.0f) * dt;
+	float	z = ao_convert_gyro((float) ((ao_sample_roll << 9) - ao_ground_roll) / 512.0f) * dt;
 	struct ao_quaternion	rot;
 
 	ao_quaternion_init_half_euler(&rot, x, y, z);
diff --git a/src/kernel/ao_stdio.c b/src/kernel/ao_stdio.c
index f0ee0a14..dc09b5c7 100644
--- a/src/kernel/ao_stdio.c
+++ b/src/kernel/ao_stdio.c
@@ -84,7 +84,7 @@ __pdata int8_t ao_cur_stdio;
 #endif
 
 void
-putchar(char c)
+ao_putchar(char c)
 {
 #if LOW_LEVEL_DEBUG
 	if (!ao_cur_task) {
@@ -110,7 +110,7 @@ flush(void)
 __xdata uint8_t ao_stdin_ready;
 
 char
-getchar(void) __reentrant
+ao_getchar(void) __reentrant
 {
 	int c;
 	int8_t stdio;
diff --git a/src/kernel/ao_storage.c b/src/kernel/ao_storage.c
index bee9293e..400751de 100644
--- a/src/kernel/ao_storage.c
+++ b/src/kernel/ao_storage.c
@@ -22,6 +22,9 @@
 uint8_t
 ao_storage_read(ao_pos_t pos, __xdata void *buf, uint16_t len) __reentrant
 {
+#ifdef CC1111
+	return ao_storage_device_read(pos, buf, len);
+#else
 	uint16_t this_len;
 	uint16_t this_off;
 
@@ -47,11 +50,15 @@ ao_storage_read(ao_pos_t pos, __xdata void *buf, uint16_t len) __reentrant
 		pos += this_len;
 	}
 	return 1;
+#endif
 }
 
 uint8_t
 ao_storage_write(ao_pos_t pos, __xdata void *buf, uint16_t len) __reentrant
 {
+#ifdef CC1111
+	return ao_storage_device_write(pos, buf, len);
+#else
 	uint16_t this_len;
 	uint16_t this_off;
 
@@ -77,9 +84,10 @@ ao_storage_write(ao_pos_t pos, __xdata void *buf, uint16_t len) __reentrant
 		pos += this_len;
 	}
 	return 1;
+#endif
 }
 
-static __xdata uint8_t storage_data[8];
+static __xdata uint8_t storage_data[128];
 
 static void
 ao_storage_dump(void) __reentrant
@@ -159,6 +167,154 @@ ao_storage_zapall(void) __reentrant
 		ao_storage_erase(pos);
 }
 
+#if AO_STORAGE_TEST
+
+static void
+ao_storage_failure(uint32_t pos, char *format, ...)
+{
+	va_list a;
+	printf("TEST FAILURE AT %08x: ", pos);
+	va_start(a, format);
+	vprintf(format, a);
+	va_end(a);
+}
+
+static uint8_t
+ao_storage_check_block(uint32_t pos, uint8_t value)
+{
+	uint32_t	offset;
+	uint32_t	byte;
+
+	for (offset = 0; offset < ao_storage_block; offset += sizeof (storage_data)) {
+		if (!ao_storage_read(pos + offset, storage_data, sizeof (storage_data))) {
+			ao_storage_failure(pos + offset, "read failed\n");
+			return 0;
+		}
+		for (byte = 0; byte < sizeof (storage_data); byte++)
+			if (storage_data[byte] != value) {
+				ao_storage_failure(pos + offset + byte,
+						   "want %02x got %02x\n",
+						   value, storage_data[byte]);
+				return 0;
+			}
+	}
+	return 1;
+}
+
+static uint8_t
+ao_storage_fill_block(uint32_t pos, uint8_t value)
+{
+	uint32_t	offset;
+	uint32_t	byte;
+
+	for (byte = 0; byte < sizeof (storage_data); byte++)
+		storage_data[byte] = value;
+	for (offset = 0; offset < ao_storage_block; offset += sizeof (storage_data)) {
+		if (!ao_storage_write(pos + offset, storage_data, sizeof (storage_data))) {
+			ao_storage_failure(pos + offset, "write failed\n");
+			return 0;
+		}
+	}
+	return 1;
+}
+
+static uint8_t
+ao_storage_check_incr_block(uint32_t pos)
+{
+	uint32_t	offset;
+	uint32_t	byte;
+
+	for (offset = 0; offset < ao_storage_block; offset += sizeof (storage_data)) {
+		if (!ao_storage_read(pos + offset, storage_data, sizeof (storage_data))) {
+			ao_storage_failure(pos + offset, "read failed\n");
+			return 0;
+		}
+		for (byte = 0; byte < sizeof (storage_data); byte++) {
+			uint8_t value = offset + byte;
+			if (storage_data[byte] != value) {
+				ao_storage_failure(pos + offset + byte,
+						   "want %02x got %02x\n",
+						   value, storage_data[byte]);
+				return 0;
+			}
+		}
+	}
+	return 1;
+}
+
+static uint8_t
+ao_storage_fill_incr_block(uint32_t pos)
+{
+	uint32_t	offset;
+	uint32_t	byte;
+
+	for (offset = 0; offset < ao_storage_block; offset += sizeof (storage_data)) {
+		for (byte = 0; byte < sizeof (storage_data); byte++)
+			storage_data[byte] = offset + byte;
+		if (!ao_storage_write(pos + offset, storage_data, sizeof (storage_data))) {
+			ao_storage_failure(pos + offset, "write failed\n");
+			return 0;
+		}
+	}
+	return 1;
+}
+
+static uint8_t
+ao_storage_fill_check_block(uint32_t pos, uint8_t value)
+{
+	return ao_storage_fill_block(pos, value) && ao_storage_check_block(pos, value);
+}
+
+static uint8_t
+ao_storage_incr_check_block(uint32_t pos)
+{
+	return ao_storage_fill_incr_block(pos) && ao_storage_check_incr_block(pos);
+}
+
+static uint8_t
+ao_storage_test_block(uint32_t pos) __reentrant
+{
+	ao_storage_erase(pos);
+	printf(" erase"); flush();
+	if (!ao_storage_check_block(pos, 0xff))
+		return 0;
+	printf(" zero"); flush();
+	if (!ao_storage_fill_check_block(pos, 0x00))
+		return 0;
+	ao_storage_erase(pos);
+	printf(" 0xaa"); flush();
+	if (!ao_storage_fill_check_block(pos, 0xaa))
+		return 0;
+	ao_storage_erase(pos);
+	printf(" 0x55"); flush();
+	if (!ao_storage_fill_check_block(pos, 0x55))
+		return 0;
+	ao_storage_erase(pos);
+	printf(" increment"); flush();
+	if (!ao_storage_incr_check_block(pos))
+		return 0;
+	ao_storage_erase(pos);
+	printf(" pass\n"); flush();
+	return 1;
+}
+
+static void
+ao_storage_test(void) __reentrant
+{
+	uint32_t	pos;
+
+	ao_cmd_white();
+	if (!ao_match_word("DoIt"))
+		return;
+	for (pos = 0; pos < ao_storage_log_max; pos += ao_storage_block) {
+		printf("Testing block 0x%08x:", pos); flush();
+		if (!ao_storage_test_block(pos))
+			break;
+	}
+	printf("Test complete\n");
+}
+#endif /* AO_STORAGE_TEST */
+
 void
 ao_storage_info(void) __reentrant
 {
@@ -176,6 +332,9 @@ __code struct ao_cmds ao_storage_cmds[] = {
 #endif
 	{ ao_storage_zap, "z <block>\0Erase <block>" },
 	{ ao_storage_zapall,"Z <key>\0Erase all. <key> is doit with D&I" },
+#if AO_STORAGE_TEST
+	{ ao_storage_test, "V <key>\0Validate flash (destructive). <key> is doit with D&I" },
+#endif
 	{ 0, NULL },
 };
 
diff --git a/src/kernel/ao_task.h b/src/kernel/ao_task.h
index 30b018ff..7549b598 100644
--- a/src/kernel/ao_task.h
+++ b/src/kernel/ao_task.h
@@ -44,6 +44,9 @@ struct ao_task {
 	ao_arch_task_members		/* any architecture-specific fields */
 	uint8_t task_id;		/* unique id */
 	__code char *name;		/* task name */
+#ifdef NEWLIB
+	int __errno;			/* storage for errno in newlib libc */
+#endif
 #if HAS_TASK_QUEUE
 	struct ao_list	queue;
 	struct ao_list	alarm_queue;
diff --git a/src/kernel/ao_telemetry.c b/src/kernel/ao_telemetry.c
index 2ae1e41b..9ed612ce 100644
--- a/src/kernel/ao_telemetry.c
+++ b/src/kernel/ao_telemetry.c
@@ -141,7 +141,7 @@ ao_send_mega_sensor(void)
 	telemetry.generic.tick = packet->tick;
 	telemetry.generic.type = AO_TELEMETRY_MEGA_SENSOR;
 
-#if HAS_MPU6000
+#if HAS_MPU6000 || HAS_MPU9250
 	telemetry.mega_sensor.orient = ao_sample_orient;
 #endif
 	telemetry.mega_sensor.accel = ao_data_accel(packet);
@@ -164,6 +164,20 @@ ao_send_mega_sensor(void)
 	telemetry.mega_sensor.mag_y = packet->hmc5883.y;
 #endif
 
+#if HAS_MPU9250
+	telemetry.mega_sensor.accel_x = packet->mpu9250.accel_x;
+	telemetry.mega_sensor.accel_y = packet->mpu9250.accel_y;
+	telemetry.mega_sensor.accel_z = packet->mpu9250.accel_z;
+
+	telemetry.mega_sensor.gyro_x = packet->mpu9250.gyro_x;
+	telemetry.mega_sensor.gyro_y = packet->mpu9250.gyro_y;
+	telemetry.mega_sensor.gyro_z = packet->mpu9250.gyro_z;
+
+	telemetry.mega_sensor.mag_x = packet->mpu9250.mag_x;
+	telemetry.mega_sensor.mag_z = packet->mpu9250.mag_z;
+	telemetry.mega_sensor.mag_y = packet->mpu9250.mag_y;
+#endif
+
 	ao_telemetry_send();
 }