Merge branch 'branch-1.8' into debian

95 files changed, 5481 insertions, 883 deletions

diff --git a/src/Makefile b/src/Makefile
index 8420b376..0dafb5ec 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -25,6 +25,7 @@ SDCCDIRS=\
 	telerepeat-v1.0
 
 ARMM3DIRS=\
+	fox1ihu fox1ihu/flash-loader \
 	easymega-v1.0 easymega-v1.0/flash-loader \
 	telemega-v0.1 telemega-v0.1/flash-loader \
 	telemega-v1.0 telemega-v1.0/flash-loader \
@@ -36,13 +37,16 @@ ARMM3DIRS=\
 	telegps-v1.0 telegps-v1.0/flash-loader \
 	telegps-v2.0 telegps-v2.0/flash-loader \
 	telelco-v0.2 telelco-v0.2/flash-loader \
+	telelco-v0.2-cc1200 telelco-v0.2-cc1200/flash-loader \
 	telelco-v0.3 telelco-v0.3/flash-loader \
+	telelco-v2.0 telelco-v2.0/flash-loader \
 	teledongle-v3.0 teledongle-v3.0/flash-loader \
 	teleballoon-v2.0 \
 	telebt-v3.0 telebt-v3.0/flash-loader \
 	telebt-v4.0 telebt-v4.0/flash-loader \
 	telelcotwo-v0.1 telelcotwo-v0.1/flash-loader \
 	telefiretwo-v0.1 telefiretwo-v0.1/flash-loader \
+	telefireeight-v1.0 telefireeight-v1.0/flash-loader 
 
 ARMM0DIRS=\
 	easymini-v1.0 easymini-v1.0/flash-loader \
diff --git a/src/chaoskey-v1.0/Makefile b/src/chaoskey-v1.0/Makefile
index dea5b483..c6cf45bd 100644
--- a/src/chaoskey-v1.0/Makefile
+++ b/src/chaoskey-v1.0/Makefile
@@ -14,6 +14,7 @@ INC = \
 	ao_task.h \
 	ao_adc_fast.h \
 	ao_power.h \
+	ao_flash_readout.h \
 	ao_crc.h \
 	stm32f0.h
 
@@ -34,6 +35,7 @@ ALTOS_SRC = \
 	ao_boot_chain.c \
 	ao_usb_stm.c \
 	ao_trng_send.c \
+	ao_flash_readout.c \
 	ao_task.c \
 	ao_power.c \
 	ao_gpio.c \
@@ -84,7 +86,7 @@ check: $(METAINFO)
 distclean:	clean
 
 clean:
-	rm -f *.o $(PROGNAME)-*.elf $(PROGNAME)-*.ihx
+	rm -f *.o $(PROGNAME)-*.elf $(PROGNAME)-*.ihx *.bin
 	rm -f ao_product.h
 	rm -f *.cab
 
diff --git a/src/chaoskey-v1.0/ao_chaoskey.c b/src/chaoskey-v1.0/ao_chaoskey.c
index c3acd441..1165e454 100644
--- a/src/chaoskey-v1.0/ao_chaoskey.c
+++ b/src/chaoskey-v1.0/ao_chaoskey.c
@@ -20,6 +20,7 @@
 #include <ao_adc_fast.h>
 #include <ao_crc.h>
 #include <ao_trng_send.h>
+#include <ao_flash_readout.h>
 
 void main(void)
 {
@@ -30,6 +31,7 @@ void main(void)
 	ao_dma_init();
 	ao_adc_init();
 	ao_crc_init();
+	ao_flash_readout_init();
 
 	ao_usb_init();
 
diff --git a/src/chaoskey-v1.0/ao_pins.h b/src/chaoskey-v1.0/ao_pins.h
index f2c46d8b..22861d9d 100644
--- a/src/chaoskey-v1.0/ao_pins.h
+++ b/src/chaoskey-v1.0/ao_pins.h
@@ -50,6 +50,7 @@
 #define AO_USB_HAS_OUT			0
 #define AO_USB_HAS_IN			1
 #define AO_USB_HAS_IN2			1
+#define AO_USB_HAS_IN3			1
 #define AO_USB_HAS_INT			0
 #define AO_USB_SELF_POWER		0
 #define AO_USB_DEVICE_ID_SERIAL		1
@@ -58,6 +59,9 @@
 
 #define IS_FLASH_LOADER	0
 
+#define AO_FLASH_READOUT		1
+#define ao_flash_readout_putchar(c)	ao_usb_putchar3(c)
+
 /* ADC */
 
 #define AO_ADC_PIN0_PORT	(&stm_gpioa)
diff --git a/src/drivers/ao_button.c b/src/drivers/ao_button.c
index 07e92c67..f6a9676b 100644
--- a/src/drivers/ao_button.c
+++ b/src/drivers/ao_button.c
@@ -69,6 +69,39 @@ _ao_button_get(uint8_t b)
 #if AO_BUTTON_COUNT > 4
 	case 4: return ao_button_value(4);
 #endif
+#if AO_BUTTON_COUNT > 5
+	case 5: return ao_button_value(5);
+#endif
+#if AO_BUTTON_COUNT > 6
+	case 6: return ao_button_value(6);
+#endif
+#if AO_BUTTON_COUNT > 7
+	case 7: return ao_button_value(7);
+#endif
+#if AO_BUTTON_COUNT > 8
+	case 8: return ao_button_value(8);
+#endif
+#if AO_BUTTON_COUNT > 9
+	case 9: return ao_button_value(9);
+#endif
+#if AO_BUTTON_COUNT > 10
+	case 10: return ao_button_value(10);
+#endif
+#if AO_BUTTON_COUNT > 11
+	case 11: return ao_button_value(11);
+#endif
+#if AO_BUTTON_COUNT > 12
+	case 12: return ao_button_value(12);
+#endif
+#if AO_BUTTON_COUNT > 13
+	case 13: return ao_button_value(13);
+#endif
+#if AO_BUTTON_COUNT > 14
+	case 14: return ao_button_value(14);
+#endif
+#if AO_BUTTON_COUNT > 15
+	case 15: return ao_button_value(15);
+#endif
 	}
 	return 0;
 }
@@ -144,4 +177,40 @@ ao_button_init(void)
 #if AO_BUTTON_COUNT > 4
 	init(4);
 #endif
+#if AO_BUTTON_COUNT > 5
+	init(5);
+#endif
+#if AO_BUTTON_COUNT > 6
+	init(6);
+#endif
+#if AO_BUTTON_COUNT > 7
+	init(7);
+#endif
+#if AO_BUTTON_COUNT > 8
+	init(8);
+#endif
+#if AO_BUTTON_COUNT > 9
+	init(9);
+#endif
+#if AO_BUTTON_COUNT > 10
+	init(10);
+#endif
+#if AO_BUTTON_COUNT > 11
+	init(11);
+#endif
+#if AO_BUTTON_COUNT > 12
+	init(12);
+#endif
+#if AO_BUTTON_COUNT > 13
+	init(13);
+#endif
+#if AO_BUTTON_COUNT > 14
+	init(14);
+#endif
+#if AO_BUTTON_COUNT > 15
+	init(15);
+#endif
+#if AO_BUTTON_COUNT > 16
+	#error too many buttons
+#endif
 }
diff --git a/src/drivers/ao_cc1120.c b/src/drivers/ao_cc1120.c
index efe5f996..2f091485 100644
--- a/src/drivers/ao_cc1120.c
+++ b/src/drivers/ao_cc1120.c
@@ -1447,7 +1447,9 @@ ao_radio_test_recv(void)
 static void
 ao_radio_aprs(void)
 {
+#if PACKET_HAS_SLAVE
 	ao_packet_slave_stop();
+#endif
 	ao_aprs_send();
 }
 #endif
diff --git a/src/drivers/ao_lco.c b/src/drivers/ao_lco.c
index e1806ca3..e892c8c0 100644
--- a/src/drivers/ao_lco.c
+++ b/src/drivers/ao_lco.c
@@ -23,14 +23,8 @@
 #include <ao_quadrature.h>
 #include <ao_lco_func.h>
 #include <ao_radio_cmac.h>
-
-#define DEBUG	1
-
-#if DEBUG
-static uint8_t	ao_lco_debug;
-#define PRINTD(...) do { if (!ao_lco_debug) break; printf ("\r%5u %s: ", ao_tick_count, __func__); printf(__VA_ARGS__); flush(); } while(0)
-#else
-#define PRINTD(...) 
+#if HAS_ADC_SINGLE
+#include <ao_adc_single.h>
 #endif
 
 #define AO_LCO_PAD_DIGIT	0
@@ -40,32 +34,16 @@ static uint8_t	ao_lco_debug;
 #define AO_LCO_DRAG_RACE_START_TIME	AO_SEC_TO_TICKS(5)
 #define AO_LCO_DRAG_RACE_STOP_TIME	AO_SEC_TO_TICKS(2)
 
-#define AO_LCO_VALID_LAST	1
-#define AO_LCO_VALID_EVER	2
-
-static uint8_t	ao_lco_min_box, ao_lco_max_box;
-static uint8_t	ao_lco_selected[AO_PAD_MAX_BOXES];
-static uint8_t	ao_lco_valid[AO_PAD_MAX_BOXES];
-static uint8_t	ao_lco_channels[AO_PAD_MAX_BOXES];
-static uint16_t	ao_lco_tick_offset[AO_PAD_MAX_BOXES];
+#define AO_LCO_BOX_DRAG		0x1000
 
 /* UI values */
-static uint8_t	ao_lco_armed;
-static uint8_t	ao_lco_firing;
 static uint16_t	ao_lco_fire_tick;
 static uint8_t	ao_lco_fire_down;
-static uint8_t	ao_lco_drag_race;
-static uint8_t	ao_lco_pad;
-static int16_t	ao_lco_box;
-
-#define AO_LCO_BOX_DRAG		0x1000
-
-static struct ao_pad_query	ao_pad_query;
 
 static uint8_t	ao_lco_display_mutex;
 
-static void
-ao_lco_set_pad(uint8_t pad)
+void
+ao_lco_show_pad(uint8_t pad)
 {
 	ao_mutex_get(&ao_lco_display_mutex);
 	ao_seven_segment_set(AO_LCO_PAD_DIGIT, pad | (ao_lco_drag_race << 4));
@@ -89,8 +67,8 @@ ao_lco_set_pad(uint8_t pad)
 				 (0 << 5) |	\
 				 (0 << 6))
 
-static void
-ao_lco_set_box(uint16_t box)
+void
+ao_lco_show_box(uint16_t box)
 {
 	ao_mutex_get(&ao_lco_display_mutex);
 	if (box == AO_LCO_BOX_DRAG) {
@@ -104,7 +82,7 @@ ao_lco_set_box(uint16_t box)
 }
 
 static void
-ao_lco_set_voltage(uint16_t decivolts)
+ao_lco_show_voltage(uint16_t decivolts)
 {
 	uint8_t	tens, ones, tenths;
 
@@ -118,27 +96,21 @@ ao_lco_set_voltage(uint16_t decivolts)
 	ao_mutex_put(&ao_lco_display_mutex);
 }
 
-static void
-ao_lco_set_display(void)
+void
+ao_lco_show(void)
 {
-	if (ao_lco_pad == 0 && ao_lco_box != AO_LCO_BOX_DRAG) {
-		ao_lco_set_voltage(ao_pad_query.battery);
+	if (ao_lco_pad == AO_LCO_PAD_VOLTAGE && ao_lco_box != AO_LCO_BOX_DRAG) {
+		ao_lco_show_voltage(ao_pad_query.battery);
 	} else {
 		if (ao_lco_box == AO_LCO_BOX_DRAG)
-			ao_lco_set_pad(ao_lco_drag_race);
+			ao_lco_show_pad(ao_lco_drag_race);
 		else
-			ao_lco_set_pad(ao_lco_pad);
-		ao_lco_set_box(ao_lco_box);
+			ao_lco_show_pad(ao_lco_pad);
+		ao_lco_show_box(ao_lco_box);
 	}
 }
 
-#define MASK_SIZE(n)	(((n) + 7) >> 3)
-#define MASK_ID(n)	((n) >> 3)
-#define MASK_SHIFT(n)	((n) & 7)
-
-static uint8_t	ao_lco_box_mask[MASK_SIZE(AO_PAD_MAX_BOXES)];
-
-static uint8_t
+uint8_t
 ao_lco_box_present(uint16_t box)
 {
 	if (box == AO_LCO_BOX_DRAG)
@@ -146,117 +118,11 @@ ao_lco_box_present(uint16_t box)
 
 	if (box >= AO_PAD_MAX_BOXES)
 		return 0;
-	return (ao_lco_box_mask[MASK_ID(box)] >> MASK_SHIFT(box)) & 1;
-}
-
-static uint8_t
-ao_lco_pad_present(uint8_t box, uint8_t pad)
-{
-	/* voltage measurement is always valid */
-	if (pad == 0)
-		return 1;
-	if (!ao_lco_channels[box])
-		return 0;
-	if (pad > AO_PAD_MAX_CHANNELS)
-		return 0;
-	return (ao_lco_channels[box] >> (pad - 1)) & 1;
-}
-
-static uint8_t
-ao_lco_pad_first(uint8_t box)
-{
-	uint8_t	pad;
-
-	for (pad = 1; pad <= AO_PAD_MAX_CHANNELS; pad++)
-		if (ao_lco_pad_present(box, pad))
-			return pad;
-	return 0;
+	return (ao_lco_box_mask[AO_LCO_MASK_ID(box)] >> AO_LCO_MASK_SHIFT(box)) & 1;
 }
 
 static struct ao_task	ao_lco_drag_task;
 static uint8_t		ao_lco_drag_active;
-static uint8_t		ao_lco_drag_beep_count;
-static uint8_t		ao_lco_drag_beep_on;
-static uint16_t		ao_lco_drag_beep_time;
-static uint16_t		ao_lco_drag_warn_time;
-
-#define AO_LCO_DRAG_BEEP_TIME	AO_MS_TO_TICKS(50)
-#define AO_LCO_DRAG_WARN_TIME	AO_SEC_TO_TICKS(5)
-
-static void
-ao_lco_drag_beep_start(void)
-{
-	ao_beep(AO_BEEP_HIGH);
-	PRINTD("beep start\n");
-	ao_lco_drag_beep_on = 1;
-	ao_lco_drag_beep_time = ao_time() + AO_LCO_DRAG_BEEP_TIME;
-}
-
-static void
-ao_lco_drag_beep_stop(void)
-{
-	ao_beep(0);
-	PRINTD("beep stop\n");
-	ao_lco_drag_beep_on = 0;
-	if (ao_lco_drag_beep_count) {
-		--ao_lco_drag_beep_count;
-		if (ao_lco_drag_beep_count)
-			ao_lco_drag_beep_time = ao_time() + AO_LCO_DRAG_BEEP_TIME;
-	}
-}
-
-static void
-ao_lco_drag_beep(uint8_t beeps)
-{
-	PRINTD("beep %d\n", beeps);
-	if (!ao_lco_drag_beep_count)
-		ao_lco_drag_beep_start();
-	ao_lco_drag_beep_count += beeps;
-}
-
-static uint16_t
-ao_lco_drag_beep_check(uint16_t now, uint16_t delay)
-{
-	PRINTD("beep check count %d delta %d\n",
-	       ao_lco_drag_beep_count,
-	       (int16_t) (now - ao_lco_drag_beep_time));
-	if (ao_lco_drag_beep_count) {
-		if ((int16_t) (now - ao_lco_drag_beep_time) >= 0) {
-			if (ao_lco_drag_beep_on)
-				ao_lco_drag_beep_stop();
-			else
-				ao_lco_drag_beep_start();
-		}
-	}
-
-	if (ao_lco_drag_beep_count) {
-		if (delay > AO_LCO_DRAG_BEEP_TIME)
-			delay = AO_LCO_DRAG_BEEP_TIME;
-	}
-	return delay;
-}
-
-static void
-ao_lco_drag_enable(void)
-{
-	PRINTD("Drag enable\n");
-	ao_lco_drag_race = 1;
-	memset(ao_lco_selected, 0, sizeof (ao_lco_selected));
-	ao_lco_drag_beep(5);
-	ao_lco_set_display();
-	ao_lco_fire_down = 0;
-}
-
-static void
-ao_lco_drag_disable(void)
-{
-	PRINTD("Drag disable\n");
-	ao_lco_drag_race = 0;
-	memset(ao_lco_selected, 0, sizeof (ao_lco_selected));
-	ao_lco_drag_beep(2);
-	ao_lco_set_display();
-	ao_lco_fire_down = 0;
-}
 
 static uint16_t
 ao_lco_drag_button_check(uint16_t now, uint16_t delay)
@@ -269,13 +135,17 @@ ao_lco_drag_button_check(uint16_t now, uint16_t delay)
 	 */
 	if (ao_lco_fire_down) {
 		if (ao_lco_drag_race) {
-			if ((int16_t) (now - ao_lco_fire_tick) >= AO_LCO_DRAG_RACE_STOP_TIME)
+			if ((int16_t) (now - ao_lco_fire_tick) >= AO_LCO_DRAG_RACE_STOP_TIME) {
 				ao_lco_drag_disable();
+				ao_lco_fire_down = 0;
+			}
 			else
 				button_delay = ao_lco_fire_tick + AO_LCO_DRAG_RACE_STOP_TIME - now;
 		} else {
-			if ((int16_t) (now - ao_lco_fire_tick) >= AO_LCO_DRAG_RACE_START_TIME)
+			if ((int16_t) (now - ao_lco_fire_tick) >= AO_LCO_DRAG_RACE_START_TIME) {
 				ao_lco_drag_enable();
+				ao_lco_fire_down = 0;
+			}
 			else
 				button_delay = ao_lco_fire_tick + AO_LCO_DRAG_RACE_START_TIME - now;
 		}
@@ -285,35 +155,20 @@ ao_lco_drag_button_check(uint16_t now, uint16_t delay)
 	return delay;
 }
 
-static uint16_t
-ao_lco_drag_warn_check(uint16_t now, uint16_t delay)
-{
-	uint16_t	warn_delay = ~0;
-
-	if (ao_lco_drag_race) {
-		if ((int16_t) (now - ao_lco_drag_warn_time) >= 0) {
-			ao_lco_drag_beep(1);
-			ao_lco_drag_warn_time = now + AO_LCO_DRAG_WARN_TIME;
-		}
-		warn_delay = ao_lco_drag_warn_time - now;
-	}
-	if (delay > warn_delay)
-		delay = warn_delay;
-	return delay;
-}
-
 static void
 ao_lco_drag_monitor(void)
 {
 	uint16_t	delay = ~0;
 	uint16_t	now;
 
+	ao_beep_for(AO_BEEP_MID, AO_MS_TO_TICKS(200));
 	for (;;) {
-		PRINTD("Drag monitor active %d delay %d\n", ao_lco_drag_active, delay);
+		PRINTD("Drag monitor count %d active %d delay %d\n",
+		       ao_lco_drag_beep_count, ao_lco_drag_active, delay);
 		if (delay == (uint16_t) ~0)
-			ao_sleep(&ao_lco_drag_active);
+			ao_sleep(&ao_lco_drag_beep_count);
 		else
-			ao_sleep_for(&ao_lco_drag_active, delay);
+			ao_sleep_for(&ao_lco_drag_beep_count, delay);
 
 		delay = ~0;
 		if (!ao_lco_drag_active)
@@ -333,13 +188,33 @@ ao_lco_drag_monitor(void)
 }
 
 static void
+ao_lco_step_box(int8_t dir)
+{
+	int16_t new_box = ao_lco_box;
+	do {
+		if (new_box == AO_LCO_BOX_DRAG) {
+			if (dir < 0)
+				new_box = ao_lco_max_box;
+			else
+				new_box = ao_lco_min_box;
+		} else {
+			new_box += dir;
+			if (new_box > ao_lco_max_box)
+				new_box = AO_LCO_BOX_DRAG;
+			else if (new_box < ao_lco_min_box)
+				new_box = AO_LCO_BOX_DRAG;
+		}
+		if (new_box == ao_lco_box)
+			break;
+	} while (!ao_lco_box_present(new_box));
+	ao_lco_set_box(new_box);
+}
+
+static void
 ao_lco_input(void)
 {
 	static struct ao_event	event;
-	int8_t		dir, new_pad;
-	int16_t		new_box;
 
-	ao_beep_for(AO_BEEP_MID, AO_MS_TO_TICKS(200));
 	for (;;) {
 		ao_event_get(&event);
 		PRINTD("event type %d unit %d value %d\n",
@@ -348,106 +223,38 @@ ao_lco_input(void)
 		case AO_EVENT_QUADRATURE:
 			switch (event.unit) {
 			case AO_QUADRATURE_PAD:
-				if (!ao_lco_armed) {
-					dir = (int8_t) event.value;
-					new_pad = ao_lco_pad;
-					do {
-						new_pad += dir;
-						if (new_pad > AO_PAD_MAX_CHANNELS)
-							new_pad = 0;
-						if (new_pad < 0)
-							new_pad = AO_PAD_MAX_CHANNELS;
-						if (new_pad == ao_lco_pad)
-							break;
-					} while (!ao_lco_pad_present(ao_lco_box, new_pad));
-					if (new_pad != ao_lco_pad) {
-						ao_lco_pad = new_pad;
-						ao_lco_set_display();
-					}
-				}
+				if (!ao_lco_armed)
+					ao_lco_step_pad((int8_t) event.value);
 				break;
 			case AO_QUADRATURE_BOX:
-				if (!ao_lco_armed) {
-					dir = (int8_t) event.value;
-					new_box = ao_lco_box;
-					do {
-						if (new_box == AO_LCO_BOX_DRAG) {
-							if (dir < 0)
-								new_box = ao_lco_max_box;
-							else
-								new_box = ao_lco_min_box;
-						} else {
-							new_box += dir;
-							if (new_box > ao_lco_max_box)
-								new_box = AO_LCO_BOX_DRAG;
-							else if (new_box < ao_lco_min_box)
-								new_box = AO_LCO_BOX_DRAG;
-						}
-						if (new_box == ao_lco_box)
-							break;
-					} while (!ao_lco_box_present(new_box));
-					if (ao_lco_box != new_box) {
-						ao_lco_box = new_box;
-						ao_lco_pad = 1;
-						if (ao_lco_box != AO_LCO_BOX_DRAG)
-							ao_lco_channels[ao_lco_box] = 0;
-						ao_lco_set_display();
-					}
-				}
+				if (!ao_lco_armed)
+					ao_lco_step_box((int8_t) event.value);
 				break;
 			}
 			break;
 		case AO_EVENT_BUTTON:
 			switch (event.unit) {
 			case AO_BUTTON_ARM:
-				ao_lco_armed = event.value;
-				PRINTD("Armed %d\n", ao_lco_armed);
-				if (ao_lco_armed) {
-					if (ao_lco_drag_race) {
-						uint8_t	box;
-
-						for (box = ao_lco_min_box; box <= ao_lco_max_box; box++) {
-							if (ao_lco_selected[box]) {
-								ao_wakeup(&ao_lco_armed);
-								break;
-							}
-						}
-					} else {
-						memset(ao_lco_selected, 0, sizeof (ao_lco_selected));
-						if (ao_lco_pad != 0 && ao_lco_box != AO_LCO_BOX_DRAG)
-							ao_lco_selected[ao_lco_box] = (1 << (ao_lco_pad - 1));
-						else
-							ao_lco_armed = 0;
-					}
-				}
-				ao_wakeup(&ao_lco_armed);
+				ao_lco_set_armed(event.value);
 				break;
 			case AO_BUTTON_FIRE:
 				if (ao_lco_armed) {
 					ao_lco_fire_down = 0;
-					ao_lco_firing = event.value;
-					PRINTD("Firing %d\n", ao_lco_firing);
-					ao_wakeup(&ao_lco_armed);
+					ao_lco_set_firing(event.value);
 				} else {
 					if (event.value) {
 						if (ao_lco_box == AO_LCO_BOX_DRAG) {
 							ao_lco_fire_down = 1;
 							ao_lco_fire_tick = ao_time();
 							ao_lco_drag_active = 1;
+							ao_wakeup(&ao_lco_drag_beep_count);
+						} else {
+							ao_lco_toggle_drag();
 						}
-						if (ao_lco_drag_race) {
-							if (ao_lco_pad != 0 && ao_lco_box != AO_LCO_BOX_DRAG) {
-								ao_lco_selected[ao_lco_box] ^= (1 << (ao_lco_pad - 1));
-								PRINTD("Toggle box %d pad %d (pads now %x) to drag race\n",
-								       ao_lco_pad, ao_lco_box, ao_lco_selected[ao_lco_box]);
-								ao_lco_drag_beep(ao_lco_pad);
-							}
-						}
-						ao_wakeup(&ao_lco_drag_active);
 					} else {
 						ao_lco_fire_down = 0;
 						if (ao_lco_drag_active)
-							ao_wakeup(&ao_lco_drag_active);
+							ao_wakeup(&ao_lco_drag_beep_count);
 					}
 				}
 				break;
@@ -457,188 +264,36 @@ ao_lco_input(void)
 	}
 }
 
-static AO_LED_TYPE	continuity_led[AO_LED_CONTINUITY_NUM] = {
-#ifdef AO_LED_CONTINUITY_0
-	AO_LED_CONTINUITY_0,
-#endif
-#ifdef AO_LED_CONTINUITY_1
-	AO_LED_CONTINUITY_1,
-#endif
-#ifdef AO_LED_CONTINUITY_2
-	AO_LED_CONTINUITY_2,
-#endif
-#ifdef AO_LED_CONTINUITY_3
-	AO_LED_CONTINUITY_3,
-#endif
-#ifdef AO_LED_CONTINUITY_4
-	AO_LED_CONTINUITY_4,
-#endif
-#ifdef AO_LED_CONTINUITY_5
-	AO_LED_CONTINUITY_5,
-#endif
-#ifdef AO_LED_CONTINUITY_6
-	AO_LED_CONTINUITY_6,
-#endif
-#ifdef AO_LED_CONTINUITY_7
-	AO_LED_CONTINUITY_7,
-#endif
-};
-
-static uint8_t
-ao_lco_get_channels(uint8_t box, struct ao_pad_query *query)
-{
-	int8_t			r;
-
-	r = ao_lco_query(box, query, &ao_lco_tick_offset[box]);
-	if (r == AO_RADIO_CMAC_OK) {
-		ao_lco_channels[box] = query->channels;
-		ao_lco_valid[box] = AO_LCO_VALID_LAST | AO_LCO_VALID_EVER;
-	} else
-		ao_lco_valid[box] &= ~AO_LCO_VALID_LAST;
-	PRINTD("ao_lco_get_channels(%d) rssi %d valid %d ret %d offset %d\n", box, ao_radio_cmac_rssi, ao_lco_valid[box], r, ao_lco_tick_offset[box]);
-	ao_wakeup(&ao_pad_query);
-	return ao_lco_valid[box];
-}
-
-static void
-ao_lco_update(void)
-{
-	if (ao_lco_box != AO_LCO_BOX_DRAG) {
-		uint8_t	previous_valid = ao_lco_valid[ao_lco_box];
-
-		if (ao_lco_get_channels(ao_lco_box, &ao_pad_query) & AO_LCO_VALID_LAST) {
-			if (!(previous_valid & AO_LCO_VALID_EVER)) {
-				if (ao_lco_pad != 0)
-					ao_lco_pad = ao_lco_pad_first(ao_lco_box);
-				ao_lco_set_display();
-			}
-			if (ao_lco_pad == 0)
-				ao_lco_set_display();
-		}
-	}
-}
-
-static void
-ao_lco_box_reset_present(void)
-{
-	ao_lco_min_box = 0xff;
-	ao_lco_max_box = 0x00;
-	memset(ao_lco_box_mask, 0, sizeof (ao_lco_box_mask));
-}
-
-static void
-ao_lco_box_set_present(uint8_t box)
-{
-	if (box < ao_lco_min_box)
-		ao_lco_min_box = box;
-	if (box > ao_lco_max_box)
-		ao_lco_max_box = box;
-	if (box >= AO_PAD_MAX_BOXES)
-		return;
-	ao_lco_box_mask[MASK_ID(box)] |= 1 << MASK_SHIFT(box);
-}
-
+/*
+ * Light up everything for a second at power on to let the user
+ * visually inspect the system for correct operation
+ */
 static void
-ao_lco_search(void)
+ao_lco_display_test()
 {
-	int8_t		r;
-	int8_t		try;
-	uint8_t		box;
-	uint8_t		boxes = 0;
-
-	ao_lco_box_reset_present();
-	ao_lco_set_pad(0);
-	for (box = 0; box < AO_PAD_MAX_BOXES; box++) {
-		if ((box % 10) == 0)
-			ao_lco_set_box(box);
-		for (try = 0; try < 3; try++) {
-			ao_lco_tick_offset[box] = 0;
-			r = ao_lco_query(box, &ao_pad_query, &ao_lco_tick_offset[box]);
-			PRINTD("box %d result %d offset %d\n", box, r, ao_lco_tick_offset[box]);
-			if (r == AO_RADIO_CMAC_OK) {
-				++boxes;
-				ao_lco_box_set_present(box);
-				ao_lco_set_pad(boxes % 10);
-				ao_delay(AO_MS_TO_TICKS(30));
-				break;
-			}
-		}
-	}
-	if (ao_lco_min_box <= ao_lco_max_box)
-		ao_lco_box = ao_lco_min_box;
-	else
-		ao_lco_min_box = ao_lco_max_box = ao_lco_box = 0;
-	memset(ao_lco_valid, 0, sizeof (ao_lco_valid));
-	memset(ao_lco_channels, 0, sizeof (ao_lco_channels));
-	ao_lco_pad = 1;
-	ao_lco_set_display();
+	ao_mutex_get(&ao_lco_display_mutex);
+	ao_seven_segment_set(AO_LCO_PAD_DIGIT, 8 | 0x10);
+	ao_seven_segment_set(AO_LCO_BOX_DIGIT_1, 8 | 0x10);
+	ao_seven_segment_set(AO_LCO_BOX_DIGIT_10, 8 | 0x10);
+	ao_mutex_put(&ao_lco_display_mutex);
+	ao_led_on(LEDS_AVAILABLE);
+	ao_delay(AO_MS_TO_TICKS(1000));
+	ao_led_off(LEDS_AVAILABLE);
 }
 
+#if HAS_ADC_SINGLE
 static void
-ao_lco_igniter_status(void)
+ao_lco_batt_voltage(void)
 {
-	uint8_t		c;
-	uint8_t		t = 0;
-
-	for (;;) {
-		ao_sleep(&ao_pad_query);
-		PRINTD("RSSI %d VALID %d\n", ao_radio_cmac_rssi, ao_lco_box == AO_LCO_BOX_DRAG ? -1 : ao_lco_valid[ao_lco_box]);
-		if (ao_lco_box == AO_LCO_BOX_DRAG) {
-			ao_led_off(AO_LED_RED|AO_LED_GREEN|AO_LED_AMBER);
-			for (c = 0; c < AO_LED_CONTINUITY_NUM; c++)
-				ao_led_off(continuity_led[c]);
-		} else {
-			if (!(ao_lco_valid[ao_lco_box] & AO_LCO_VALID_LAST)) {
-				ao_led_on(AO_LED_RED);
-				ao_led_off(AO_LED_GREEN|AO_LED_AMBER);
-				continue;
-			}
-			if (ao_radio_cmac_rssi < -90) {
-				ao_led_on(AO_LED_AMBER);
-				ao_led_off(AO_LED_RED|AO_LED_GREEN);
-			} else {
-				ao_led_on(AO_LED_GREEN);
-				ao_led_off(AO_LED_RED|AO_LED_AMBER);
-			}
-			if (ao_pad_query.arm_status)
-				ao_led_on(AO_LED_REMOTE_ARM);
-			else
-				ao_led_off(AO_LED_REMOTE_ARM);
-
-			for (c = 0; c < AO_LED_CONTINUITY_NUM; c++) {
-				uint8_t	status;
+	struct ao_adc	packet;
+	int16_t		decivolt;
 
-				if (ao_lco_drag_race) {
-					if (ao_lco_selected[ao_lco_box] & (1 << c) && t)
-						ao_led_on(continuity_led[c]);
-					else
-						ao_led_off(continuity_led[c]);
-				} else {
-					if (ao_pad_query.channels & (1 << c))
-						status = ao_pad_query.igniter_status[c];
-					else
-						status = AO_PAD_IGNITER_STATUS_NO_IGNITER_RELAY_OPEN;
-					if (status == AO_PAD_IGNITER_STATUS_GOOD_IGNITER_RELAY_OPEN)
-						ao_led_on(continuity_led[c]);
-					else
-						ao_led_off(continuity_led[c]);
-				}
-			}
-			t = 1-t;
-		}
-	}
-}
-
-static void
-ao_lco_arm_warn(void)
-{
-	for (;;) {
-		while (!ao_lco_armed)
-			ao_sleep(&ao_lco_armed);
-		ao_beep_for(AO_BEEP_MID, AO_MS_TO_TICKS(200));
-		ao_delay(AO_MS_TO_TICKS(200));
-	}
+	ao_adc_single_get(&packet);
+	decivolt = ao_battery_decivolt(packet.v_batt);
+	ao_lco_show_voltage(decivolt);
+	ao_delay(AO_MS_TO_TICKS(1000));
 }
+#endif
 
 static struct ao_task ao_lco_input_task;
 static struct ao_task ao_lco_monitor_task;
@@ -646,43 +301,18 @@ static struct ao_task ao_lco_arm_warn_task;
 static struct ao_task ao_lco_igniter_status_task;
 
 static void
-ao_lco_monitor(void)
+ao_lco_main(void)
 {
-	uint16_t		delay;
-	uint8_t			box;
-
+	ao_lco_display_test();
+#if HAS_ADC_SINGLE
+	ao_lco_batt_voltage();
+#endif
 	ao_lco_search();
 	ao_add_task(&ao_lco_input_task, ao_lco_input, "lco input");
 	ao_add_task(&ao_lco_arm_warn_task, ao_lco_arm_warn, "lco arm warn");
 	ao_add_task(&ao_lco_igniter_status_task, ao_lco_igniter_status, "lco igniter status");
 	ao_add_task(&ao_lco_drag_task, ao_lco_drag_monitor, "drag race");
-	for (;;) {
-		PRINTD("monitor armed %d firing %d\n",
-		       ao_lco_armed, ao_lco_firing);
-
-		if (ao_lco_armed && ao_lco_firing) {
-			ao_lco_ignite(AO_PAD_FIRE);
-		} else {
-			ao_lco_update();
-			if (ao_lco_armed) {
-				for (box = ao_lco_min_box; box <= ao_lco_max_box; box++) {
-					if (ao_lco_selected[box]) {
-						PRINTD("Arming box %d pads %x\n",
-						       box, ao_lco_selected[box]);
-						if (ao_lco_valid[box] & AO_LCO_VALID_EVER) {
-							ao_lco_arm(box, ao_lco_selected[box], ao_lco_tick_offset[box]);
-							ao_delay(AO_MS_TO_TICKS(10));
-						}
-					}
-				}
-			}
-		}
-		if (ao_lco_armed && ao_lco_firing)
-			delay = AO_MS_TO_TICKS(100);
-		else
-			delay = AO_SEC_TO_TICKS(1);
-		ao_sleep_for(&ao_lco_armed, delay);
-	}
+	ao_lco_monitor();
 }
 
 #if DEBUG
@@ -704,7 +334,7 @@ __code struct ao_cmds ao_lco_cmds[] = {
 void
 ao_lco_init(void)
 {
-	ao_add_task(&ao_lco_monitor_task, ao_lco_monitor, "lco monitor");
+	ao_add_task(&ao_lco_monitor_task, ao_lco_main, "lco monitor");
 #if DEBUG
 	ao_cmd_register(&ao_lco_cmds[0]);
 #endif
diff --git a/src/drivers/ao_lco.h b/src/drivers/ao_lco.h
index 5721eed5..2958fbcc 100644
--- a/src/drivers/ao_lco.h
+++ b/src/drivers/ao_lco.h
@@ -19,7 +19,126 @@
 #ifndef _AO_LCO_H_
 #define _AO_LCO_H_
 
+#include <ao_lco_func.h>
+
+#ifndef AO_LCO_DRAG
+#define AO_LCO_DRAG	1
+#endif
+
+#define DEBUG	1
+
+#if DEBUG
+extern uint8_t	ao_lco_debug;
+#define PRINTD(...) do { if (!ao_lco_debug) break; printf ("\r%5u %s: ", ao_tick_count, __func__); printf(__VA_ARGS__); flush(); } while(0)
+#else
+#define PRINTD(...) 
+#endif
+
+#if AO_LCO_DRAG
+extern uint8_t	ao_lco_drag_race;	/* TRUE when drag race mode enabled */
+#endif
+
+extern uint8_t	ao_lco_pad;		/* Currently selected pad */
+extern int16_t	ao_lco_box;		/* Currently selected box */
+
+extern uint8_t	ao_lco_armed;		/* armed mode active */
+extern uint8_t	ao_lco_firing;		/* fire button pressed */
+
+extern struct ao_pad_query	ao_pad_query;	/* Last received QUERY from pad */
+
+#define AO_LCO_PAD_VOLTAGE	0		/* Pad number to show box voltage */
+
+extern uint8_t	ao_lco_min_box, ao_lco_max_box;
+
+#define AO_LCO_MASK_SIZE(n)	(((n) + 7) >> 3)
+#define AO_LCO_MASK_ID(n)	((n) >> 3)
+#define AO_LCO_MASK_SHIFT(n)	((n) & 7)
+
+extern uint8_t	ao_lco_box_mask[AO_LCO_MASK_SIZE(AO_PAD_MAX_BOXES)];
+
+/*
+ * Shared functions
+ */
+
+void
+ao_lco_igniter_status(void);
+
+void
+ao_lco_update(void);
+
+uint8_t
+ao_lco_pad_present(uint8_t box, uint8_t pad);
+
+uint8_t
+ao_lco_pad_first(uint8_t box);
+
+void
+ao_lco_set_pad(uint8_t new_pad);
+
+void
+ao_lco_step_pad(int8_t dir);
+
+void
+ao_lco_set_box(uint16_t new_box);
+
+void
+ao_lco_set_armed(uint8_t armed);
+
+void
+ao_lco_set_firing(uint8_t firing);
+
+void
+ao_lco_toggle_drag(void);
+
+void
+ao_lco_search(void);
+
+void
+ao_lco_monitor(void);
+
+extern uint8_t			ao_lco_drag_beep_count;
+
+/* enable drag race mode */
+void
+ao_lco_drag_enable(void);
+
+/* disable drag race mode */
+void
+ao_lco_drag_disable(void);
+
+/* Handle drag beeps, return new delay */
+uint16_t
+ao_lco_drag_beep_check(uint16_t now, uint16_t delay);
+
+/* Check if it's time to beep during drag race. Return new delay */
+uint16_t
+ao_lco_drag_warn_check(uint16_t now, uint16_t delay);
+
+/* Request 'beeps' additional drag race beeps */
+void
+ao_lco_drag_add_beeps(uint8_t beeps);
+
+/* task function for beeping while arm is active */
+void
+ao_lco_arm_warn(void);
+
+/*
+ * Provided by the hw-specific driver code
+ */
+
+void
+ao_lco_show_pad(uint8_t pad);
+
+void
+ao_lco_show_box(uint16_t box);
+
+void
+ao_lco_show(void);
+
 void
 ao_lco_init(void);
 
+uint8_t
+ao_lco_box_present(uint16_t box);
+
 #endif /* _AO_LCO_H_ */
diff --git a/src/drivers/ao_lco_bits.c b/src/drivers/ao_lco_bits.c
new file mode 100644
index 00000000..6e50e44d
--- /dev/null
+++ b/src/drivers/ao_lco_bits.c
@@ -0,0 +1,501 @@
+/*
+ * Copyright © 2018 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, either version 2 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.
+ */
+
+#include <ao.h>
+#include <ao_lco.h>
+#include <ao_radio_cmac.h>
+
+uint8_t		ao_lco_debug;
+
+uint8_t		ao_lco_pad;
+int16_t		ao_lco_box;
+
+uint8_t		ao_lco_armed;					/* arm active */
+uint8_t		ao_lco_firing;					/* fire active */
+
+uint8_t		ao_lco_min_box, ao_lco_max_box;
+
+#if AO_LCO_DRAG
+uint8_t		ao_lco_drag_race;
+#endif
+
+struct ao_pad_query	ao_pad_query;				/* latest query response */
+
+static uint8_t		ao_lco_channels[AO_PAD_MAX_BOXES];	/* pad channels available on each box */
+static uint16_t		ao_lco_tick_offset[AO_PAD_MAX_BOXES];	/* offset from local to remote tick count */
+static uint8_t		ao_lco_selected[AO_PAD_MAX_BOXES];	/* pads selected to fire */
+
+#define AO_LCO_VALID_LAST	1
+#define AO_LCO_VALID_EVER	2
+
+static uint8_t		ao_lco_valid[AO_PAD_MAX_BOXES];		/* AO_LCO_VALID bits per box */
+
+static const AO_LED_TYPE	continuity_led[AO_LED_CONTINUITY_NUM] = {
+#ifdef AO_LED_CONTINUITY_0
+	AO_LED_CONTINUITY_0,
+#endif
+#ifdef AO_LED_CONTINUITY_1
+	AO_LED_CONTINUITY_1,
+#endif
+#ifdef AO_LED_CONTINUITY_2
+	AO_LED_CONTINUITY_2,
+#endif
+#ifdef AO_LED_CONTINUITY_3
+	AO_LED_CONTINUITY_3,
+#endif
+#ifdef AO_LED_CONTINUITY_4
+	AO_LED_CONTINUITY_4,
+#endif
+#ifdef AO_LED_CONTINUITY_5
+	AO_LED_CONTINUITY_5,
+#endif
+#ifdef AO_LED_CONTINUITY_6
+	AO_LED_CONTINUITY_6,
+#endif
+#ifdef AO_LED_CONTINUITY_7
+	AO_LED_CONTINUITY_7,
+#endif
+};
+
+/* Set LEDs to match remote box status */
+void
+ao_lco_igniter_status(void)
+{
+	uint8_t		c;
+	uint8_t		t = 0;
+
+	for (;;) {
+#if AO_LCO_DRAG
+		if (ao_lco_drag_race)
+			ao_sleep_for(&ao_pad_query, AO_MS_TO_TICKS(50));
+		else
+#endif
+			ao_sleep(&ao_pad_query);
+		PRINTD("RSSI %d VALID %d\n", ao_radio_cmac_rssi, ao_lco_valid[ao_lco_box]);
+		if (!(ao_lco_valid[ao_lco_box] & AO_LCO_VALID_LAST)) {
+			ao_led_on(AO_LED_RED);
+			ao_led_off(AO_LED_GREEN|AO_LED_AMBER);
+			continue;
+		}
+		if (ao_radio_cmac_rssi < -90) {
+			ao_led_on(AO_LED_AMBER);
+			ao_led_off(AO_LED_RED|AO_LED_GREEN);
+		} else {
+			ao_led_on(AO_LED_GREEN);
+			ao_led_off(AO_LED_RED|AO_LED_AMBER);
+		}
+		if (ao_pad_query.arm_status)
+			ao_led_on(AO_LED_REMOTE_ARM);
+		else
+			ao_led_off(AO_LED_REMOTE_ARM);
+
+		for (c = 0; c < AO_LED_CONTINUITY_NUM; c++) {
+			uint8_t	status;
+
+			if (ao_pad_query.channels & (1 << c))
+				status = ao_pad_query.igniter_status[c];
+			else
+				status = AO_PAD_IGNITER_STATUS_NO_IGNITER_RELAY_OPEN;
+
+#if AO_LCO_DRAG
+			if (ao_lco_drag_race && (ao_lco_selected[ao_lco_box] & (1 << c))) {
+				uint8_t	on = 0;
+				if (status == AO_PAD_IGNITER_STATUS_GOOD_IGNITER_RELAY_OPEN) {
+					if (t)
+						on = 1;
+				} else {
+					if (t == 1)
+						on = 1;
+				}
+				if (on)
+					ao_led_on(continuity_led[c]);
+				else
+					ao_led_off(continuity_led[c]);
+			} else
+#endif
+			{
+				if (status == AO_PAD_IGNITER_STATUS_GOOD_IGNITER_RELAY_OPEN)
+					ao_led_on(continuity_led[c]);
+				else
+					ao_led_off(continuity_led[c]);
+			}
+		}
+		t = (t + 1) & 3;
+	}
+}
+
+uint8_t
+ao_lco_pad_present(uint8_t box, uint8_t pad)
+{
+	/* voltage measurement is always valid */
+	if (pad == AO_LCO_PAD_VOLTAGE)
+		return 1;
+	if (!ao_lco_channels[box])
+		return 0;
+	if (pad > AO_PAD_MAX_CHANNELS)
+		return 0;
+	return (ao_lco_channels[box] >> (pad - 1)) & 1;
+}
+
+uint8_t
+ao_lco_pad_first(uint8_t box)
+{
+	uint8_t	pad;
+
+	for (pad = 1; pad <= AO_PAD_MAX_CHANNELS; pad++)
+		if (ao_lco_pad_present(box, pad))
+			return pad;
+	return 0;
+}
+
+static uint8_t
+ao_lco_get_channels(uint8_t box, struct ao_pad_query *query)
+{
+	int8_t			r;
+
+	r = ao_lco_query(box, query, &ao_lco_tick_offset[box]);
+	if (r == AO_RADIO_CMAC_OK) {
+		ao_lco_channels[box] = query->channels;
+		ao_lco_valid[box] = AO_LCO_VALID_LAST | AO_LCO_VALID_EVER;
+	} else
+		ao_lco_valid[box] &= ~AO_LCO_VALID_LAST;
+	PRINTD("ao_lco_get_channels(%d) rssi %d valid %d ret %d offset %d\n", box, ao_radio_cmac_rssi, ao_lco_valid[box], r, ao_lco_tick_offset[box]);
+	ao_wakeup(&ao_pad_query);
+	return ao_lco_valid[box];
+}
+
+void
+ao_lco_update(void)
+{
+	uint8_t	previous_valid = ao_lco_valid[ao_lco_box];
+
+	if (ao_lco_get_channels(ao_lco_box, &ao_pad_query) & AO_LCO_VALID_LAST) {
+		if (!(previous_valid & AO_LCO_VALID_EVER)) {
+			if (ao_lco_pad != AO_LCO_PAD_VOLTAGE)
+				ao_lco_set_pad(ao_lco_pad_first(ao_lco_box));
+		}
+		if (ao_lco_pad == AO_LCO_PAD_VOLTAGE)
+			ao_lco_show();
+	}
+}
+
+uint8_t	ao_lco_box_mask[AO_LCO_MASK_SIZE(AO_PAD_MAX_BOXES)];
+
+static void
+ao_lco_box_reset_present(void)
+{
+	ao_lco_min_box = 0xff;
+	ao_lco_max_box = 0x00;
+	memset(ao_lco_box_mask, 0, sizeof (ao_lco_box_mask));
+}
+
+static void
+ao_lco_box_set_present(uint8_t box)
+{
+	if (box < ao_lco_min_box)
+		ao_lco_min_box = box;
+	if (box > ao_lco_max_box)
+		ao_lco_max_box = box;
+	if (box >= AO_PAD_MAX_BOXES)
+		return;
+	ao_lco_box_mask[AO_LCO_MASK_ID(box)] |= 1 << AO_LCO_MASK_SHIFT(box);
+}
+
+void
+ao_lco_set_pad(uint8_t new_pad)
+{
+	ao_lco_pad = new_pad;
+	ao_lco_show();
+}
+
+void
+ao_lco_set_box(uint16_t new_box)
+{
+	ao_lco_box = new_box;
+	if (ao_lco_box < AO_PAD_MAX_BOXES)
+		ao_lco_channels[ao_lco_box] = 0;
+	ao_lco_pad = 1;
+	ao_lco_show();
+}
+
+void
+ao_lco_step_pad(int8_t dir)
+{
+	int8_t	new_pad;
+
+	new_pad = ao_lco_pad;
+	do {
+		new_pad += dir;
+		if (new_pad > AO_PAD_MAX_CHANNELS)
+			new_pad = AO_LCO_PAD_VOLTAGE;
+		if (new_pad < 0)
+			new_pad = AO_PAD_MAX_CHANNELS;
+		if (new_pad == ao_lco_pad)
+			break;
+	} while (!ao_lco_pad_present(ao_lco_box, new_pad));
+	ao_lco_set_pad(new_pad);
+}
+
+void
+ao_lco_set_armed(uint8_t armed)
+{
+	ao_lco_armed = armed;
+	PRINTD("Armed %d\n", ao_lco_armed);
+	if (ao_lco_armed) {
+#if AO_LCO_DRAG
+		if (ao_lco_drag_race) {
+			uint8_t	box;
+
+			for (box = ao_lco_min_box; box <= ao_lco_max_box; box++)
+				if (ao_lco_selected[box])
+					break;
+			if (box > ao_lco_max_box)
+				ao_lco_armed = 0;
+		} else
+#endif
+		{
+			memset(ao_lco_selected, 0, sizeof (ao_lco_selected));
+			if (ao_lco_pad != 0)
+				ao_lco_selected[ao_lco_box] = (1 << (ao_lco_pad - 1));
+			else
+				ao_lco_armed = 0;
+		}
+	}
+	ao_wakeup(&ao_lco_armed);
+}
+
+void
+ao_lco_set_firing(uint8_t firing)
+{
+	ao_lco_firing = firing;
+	PRINTD("Firing %d\n", ao_lco_firing);
+	ao_wakeup(&ao_lco_armed);
+}
+
+void
+ao_lco_search(void)
+{
+	int8_t		r;
+	int8_t		try;
+	uint8_t		box;
+	uint8_t		boxes = 0;
+
+	ao_lco_box_reset_present();
+	ao_lco_show_box(0);
+	ao_lco_show_pad(0);
+	for (box = 0; box < AO_PAD_MAX_BOXES; box++) {
+		if ((box % 10) == 0)
+			ao_lco_show_box(box);
+		for (try = 0; try < 3; try++) {
+			ao_lco_tick_offset[box] = 0;
+			r = ao_lco_query(box, &ao_pad_query, &ao_lco_tick_offset[box]);
+			PRINTD("box %d result %d offset %d\n", box, r, ao_lco_tick_offset[box]);
+			if (r == AO_RADIO_CMAC_OK) {
+				++boxes;
+				ao_lco_box_set_present(box);
+				ao_lco_show_pad(boxes % 10);
+				ao_delay(AO_MS_TO_TICKS(30));
+				break;
+			}
+		}
+	}
+	if (ao_lco_min_box <= ao_lco_max_box)
+		ao_lco_box = ao_lco_min_box;
+	else
+		ao_lco_min_box = ao_lco_max_box = ao_lco_box = 0;
+	memset(ao_lco_valid, 0, sizeof (ao_lco_valid));
+	memset(ao_lco_channels, 0, sizeof (ao_lco_channels));
+	ao_lco_set_box(ao_lco_min_box);
+}
+
+void
+ao_lco_monitor(void)
+{
+	uint16_t		delay;
+	uint8_t			box;
+
+	for (;;) {
+		PRINTD("monitor armed %d firing %d\n",
+		       ao_lco_armed, ao_lco_firing);
+
+		if (ao_lco_armed && ao_lco_firing) {
+			ao_lco_ignite(AO_PAD_FIRE);
+		} else {
+			ao_lco_update();
+			if (ao_lco_armed) {
+				for (box = ao_lco_min_box; box <= ao_lco_max_box; box++) {
+					if (ao_lco_selected[box]) {
+						PRINTD("Arming box %d pads %x\n",
+						       box, ao_lco_selected[box]);
+						if (ao_lco_valid[box] & AO_LCO_VALID_EVER) {
+							ao_lco_arm(box, ao_lco_selected[box], ao_lco_tick_offset[box]);
+							ao_delay(AO_MS_TO_TICKS(10));
+						}
+					}
+				}
+			}
+		}
+		if (ao_lco_armed && ao_lco_firing)
+			delay = AO_MS_TO_TICKS(100);
+		else
+			delay = AO_SEC_TO_TICKS(1);
+		ao_sleep_for(&ao_lco_armed, delay);
+	}
+}
+
+#if AO_LCO_DRAG
+
+uint8_t			ao_lco_drag_beep_count;
+static uint8_t		ao_lco_drag_beep_on;
+static uint16_t		ao_lco_drag_beep_time;
+static uint16_t		ao_lco_drag_warn_time;
+
+#define AO_LCO_DRAG_BEEP_TIME	AO_MS_TO_TICKS(50)
+#define AO_LCO_DRAG_WARN_TIME	AO_SEC_TO_TICKS(5)
+
+/* Request 'beeps' additional drag race beeps */
+void
+ao_lco_drag_add_beeps(uint8_t beeps)
+{
+	PRINTD("beep %d\n", beeps);
+	if (ao_lco_drag_beep_count == 0)
+		ao_lco_drag_beep_time = ao_time();
+	ao_lco_drag_beep_count += beeps;
+	ao_wakeup(&ao_lco_drag_beep_count);
+}
+
+/* Toggle current pad in drag set */
+void
+ao_lco_toggle_drag(void)
+{
+	if (ao_lco_drag_race && ao_lco_pad != AO_LCO_PAD_VOLTAGE) {
+		ao_lco_selected[ao_lco_box] ^= (1 << (ao_lco_pad - 1));
+		PRINTD("Toggle box %d pad %d (pads now %x) to drag race\n",
+		       ao_lco_pad, ao_lco_box, ao_lco_selected[ao_lco_box]);
+		ao_lco_drag_add_beeps(ao_lco_pad);
+	}
+}
+
+/* Check whether it's time to change the beeper status, then either
+ * turn it on or off as necessary and bump the remaining beep counts
+ */
+
+uint16_t
+ao_lco_drag_beep_check(uint16_t now, uint16_t delay)
+{
+	PRINTD("beep check count %d delta %d\n",
+	       ao_lco_drag_beep_count,
+	       (int16_t) (now - ao_lco_drag_beep_time));
+	if (ao_lco_drag_beep_count) {
+		if ((int16_t) (now - ao_lco_drag_beep_time) >= 0) {
+			if (ao_lco_drag_beep_on) {
+				ao_beep(0);
+				PRINTD("beep stop\n");
+				ao_lco_drag_beep_on = 0;
+				if (ao_lco_drag_beep_count) {
+					--ao_lco_drag_beep_count;
+					if (ao_lco_drag_beep_count)
+						ao_lco_drag_beep_time = now + AO_LCO_DRAG_BEEP_TIME;
+				}
+			} else {
+				ao_beep(AO_BEEP_HIGH);
+				PRINTD("beep start\n");
+				ao_lco_drag_beep_on = 1;
+				ao_lco_drag_beep_time = now + AO_LCO_DRAG_BEEP_TIME;
+			}
+		}
+	}
+
+	if (ao_lco_drag_beep_count) {
+		uint16_t beep_delay = 0;
+
+		if (ao_lco_drag_beep_time > now)
+			beep_delay = ao_lco_drag_beep_time - now;
+
+		if (delay > beep_delay)
+			delay = beep_delay;
+	}
+	return delay;
+}
+
+void
+ao_lco_drag_enable(void)
+{
+	if (!ao_lco_drag_race) {
+		PRINTD("Drag enable\n");
+		ao_lco_drag_race = 1;
+		memset(ao_lco_selected, 0, sizeof (ao_lco_selected));
+#ifdef AO_LED_DRAG
+		ao_led_on(AO_LED_DRAG);
+#endif
+		ao_lco_drag_add_beeps(5);
+		ao_lco_show();
+	}
+}
+
+void
+ao_lco_drag_disable(void)
+{
+	if (ao_lco_drag_race) {
+		PRINTD("Drag disable\n");
+		ao_lco_drag_race = 0;
+#ifdef AO_LED_DRAG
+		ao_led_off(AO_LED_DRAG);
+#endif
+		memset(ao_lco_selected, 0, sizeof (ao_lco_selected));
+		ao_lco_drag_add_beeps(2);
+		ao_lco_show();
+	}
+}
+
+/* add a beep if it's time to warn the user that drag race mode is
+ * active
+ */
+
+uint16_t
+ao_lco_drag_warn_check(uint16_t now, uint16_t delay)
+{
+	if (ao_lco_drag_race) {
+		uint16_t	warn_delay;
+
+		if ((int16_t) (now - ao_lco_drag_warn_time) >= 0) {
+			ao_lco_drag_add_beeps(1);
+			ao_lco_drag_warn_time = now + AO_LCO_DRAG_WARN_TIME;
+		}
+		warn_delay = ao_lco_drag_warn_time - now;
+		if (delay > warn_delay)
+			delay = warn_delay;
+	}
+	return delay;
+}
+#endif /* AO_LCO_DRAG */
+
+/* task function for beeping while arm is active */
+void
+ao_lco_arm_warn(void)
+{
+	for (;;) {
+		while (!ao_lco_armed) {
+#ifdef AO_LED_FIRE
+			ao_led_off(AO_LED_FIRE);
+#endif
+			ao_sleep(&ao_lco_armed);
+		}
+#ifdef AO_LED_FIRE
+		ao_led_on(AO_LED_FIRE);
+#endif
+		ao_beep_for(AO_BEEP_MID, AO_MS_TO_TICKS(200));
+		ao_delay(AO_MS_TO_TICKS(200));
+	}
+}
diff --git a/src/drivers/ao_lco_cmd.c b/src/drivers/ao_lco_cmd.c
index 8de21fb6..dba9a76a 100644
--- a/src/drivers/ao_lco_cmd.c
+++ b/src/drivers/ao_lco_cmd.c
@@ -22,6 +22,10 @@
 #include <ao_lco_func.h>
 #include <ao_radio_cmac.h>
 
+#ifndef HAS_STATIC_TEST
+#define HAS_STATIC_TEST	1
+#endif
+
 static __pdata uint16_t	lco_box;
 static __pdata uint8_t	lco_channels;
 static __pdata uint16_t	tick_offset;
@@ -150,6 +154,7 @@ lco_fire_cmd(void) __reentrant
 	}
 }
 
+#if HAS_STATIC_TEST
 static void
 lco_static_cmd(void) __reentrant
 {
@@ -182,6 +187,7 @@ lco_static_cmd(void) __reentrant
 		ao_delay(AO_MS_TO_TICKS(100));
 	}
 }
+#endif
 
 static void
 lco_arm_cmd(void) __reentrant
@@ -208,18 +214,21 @@ lco_ignite_cmd(void) __reentrant
 }
 
 
+#if HAS_STATIC_TEST
 static void
 lco_endstatic_cmd(void) __reentrant
 {
 	lco_ignite(AO_PAD_ENDSTATIC);
 }
+#endif
 
 static __code struct ao_cmds ao_lco_cmds[] = {
 	{ lco_report_cmd,	"l <box> <channel>\0Get remote status" },
 	{ lco_fire_cmd,		"F <box> <channel> <secs>\0Fire remote igniters" },
-	{ lco_fire_cmd,		"F <box> <channel> <secs>\0Fire remote igniters" },
+#if HAS_STATIC_TEST
 	{ lco_static_cmd,	"S <box> <channel> <secs>\0Initiate static test" },
 	{ lco_endstatic_cmd,	"D\0End static test (and download someday)" },
+#endif
 	{ lco_arm_cmd,		"a <box> <channel>\0Arm remote igniter" },
 	{ lco_ignite_cmd,	"i <box> <channel>\0Pulse remote igniter" },
 	{ 0, NULL },
diff --git a/src/drivers/ao_lco_two.c b/src/drivers/ao_lco_two.c
index e2f86745..6f2d81ff 100644
--- a/src/drivers/ao_lco_two.c
+++ b/src/drivers/ao_lco_two.c
@@ -23,64 +23,13 @@
 #include <ao_lco_func.h>
 #include <ao_radio_cmac.h>
 
-#define DEBUG	1
-
-#if DEBUG
-static uint8_t	ao_lco_debug;
-#define DEBUG_EVENT	1
-#define DEBUG_STATUS	2
-#define PRINTD(l, ...) do { if (!(ao_lco_debug & l)) break; printf ("\r%5u %s: ", ao_tick_count, __func__); printf(__VA_ARGS__); flush(); } while(0)
-#else
-#define PRINTD(l,...)
-#endif
-
-#define AO_LCO_VALID_LAST	1
-#define AO_LCO_VALID_EVER	2
-
 static uint8_t	ao_lco_suspended;
-static uint8_t	ao_lco_valid;
-static uint8_t	ao_lco_channels;
-static uint16_t	ao_lco_tick_offset;
-
-/* UI values */
-static uint8_t	ao_lco_armed;
-static uint8_t	ao_lco_firing;
-static uint8_t	ao_lco_box;
-
-static struct ao_pad_query	ao_pad_query;
-
-/* TeleFireTwo boxes have a single pad */
-#define ao_lco_pad	0
-
-static void
-ao_lco_set_box(int box)
-{
-	ao_lco_box = ao_config.pad_box + box;
-	ao_lco_valid = 0;
-	ao_lco_armed = 0;
-	ao_wakeup(&ao_lco_armed);
-}
-
-static void
-ao_lco_set_armed(int armed)
-{
-	uint8_t	bit = (1 << ao_lco_pad);
-
-	if (armed) {
-		ao_lco_armed = bit;
-	} else {
-		ao_lco_armed = 0;
-	}
-	PRINTD(DEBUG_EVENT, "pad %d bit 0x%x armed %d ao_lco_armed 0x%x\n",
-	       ao_lco_pad, bit, armed, ao_lco_armed);
-	ao_wakeup(&ao_lco_armed);
-}
 
 static void
 ao_lco_suspend(void)
 {
 	if (!ao_lco_suspended) {
-		PRINTD(DEBUG_EVENT, "suspend\n");
+		PRINTD("suspend\n");
 		ao_lco_suspended = 1;
 		ao_lco_armed = 0;
 		ao_wakeup(&ao_pad_query);
@@ -96,6 +45,23 @@ ao_lco_wakeup(void)
 	}
 }
 
+void
+ao_lco_show_pad(uint8_t pad)
+{
+	(void) pad;
+}
+
+void
+ao_lco_show_box(uint16_t box)
+{
+	(void) box;
+}
+
+void
+ao_lco_show(void)
+{
+}
+
 static void
 ao_lco_input(void)
 {
@@ -113,23 +79,21 @@ ao_lco_input(void)
 			ao_event_get(&event);
 		}
 		ao_lco_wakeup();
-		PRINTD(DEBUG_EVENT, "event type %d unit %d value %d\n",
+		PRINTD("event type %d unit %d value %d\n",
 		       event.type, event.unit, event.value);
 		switch (event.type) {
 		case AO_EVENT_BUTTON:
 			switch (event.unit) {
 			case AO_BUTTON_BOX:
 				ao_lco_set_box(event.value);
+				ao_lco_set_armed(0);
 				break;
 			case AO_BUTTON_ARM:
 				ao_lco_set_armed(event.value);
 				break;
 			case AO_BUTTON_FIRE:
-				if (ao_lco_armed) {
-					ao_lco_firing = event.value;
-					PRINTD(DEBUG_EVENT, "Firing %d\n", ao_lco_firing);
-					ao_wakeup(&ao_lco_armed);
-				}
+				if (ao_lco_armed)
+					ao_lco_set_firing(event.value);
 				break;
 			}
 			break;
@@ -137,140 +101,14 @@ ao_lco_input(void)
 	}
 }
 
-static AO_LED_TYPE	continuity_led[AO_LED_CONTINUITY_NUM] = {
-#ifdef AO_LED_CONTINUITY_0
-	AO_LED_CONTINUITY_0,
-#endif
-#ifdef AO_LED_CONTINUITY_1
-	AO_LED_CONTINUITY_1,
-#endif
-#ifdef AO_LED_CONTINUITY_2
-	AO_LED_CONTINUITY_2,
-#endif
-#ifdef AO_LED_CONTINUITY_3
-	AO_LED_CONTINUITY_3,
-#endif
-#ifdef AO_LED_CONTINUITY_4
-	AO_LED_CONTINUITY_4,
-#endif
-#ifdef AO_LED_CONTINUITY_5
-	AO_LED_CONTINUITY_5,
-#endif
-#ifdef AO_LED_CONTINUITY_6
-	AO_LED_CONTINUITY_6,
-#endif
-#ifdef AO_LED_CONTINUITY_7
-	AO_LED_CONTINUITY_7,
-#endif
-};
-
-static uint8_t
-ao_lco_get_channels(void)
-{
-	int8_t			r;
-
-	r = ao_lco_query(ao_lco_box, &ao_pad_query, &ao_lco_tick_offset);
-	if (r == AO_RADIO_CMAC_OK) {
-		ao_lco_channels = ao_pad_query.channels;
-		ao_lco_valid = AO_LCO_VALID_LAST | AO_LCO_VALID_EVER;
-	} else
-		ao_lco_valid &= ~AO_LCO_VALID_LAST;
-	PRINTD(DEBUG_STATUS, "ao_lco_get_channels() rssi %d valid %d ret %d offset %d\n", ao_radio_cmac_rssi, ao_lco_valid, r, ao_lco_tick_offset);
-	ao_wakeup(&ao_pad_query);
-	return ao_lco_valid;
-}
-
-static void
-ao_lco_igniter_status(void)
-{
-	uint8_t		c;
-	uint8_t		t = 0;
-
-	for (;;) {
-		uint8_t	all_status;
-		ao_sleep(&ao_pad_query);
-		while (ao_lco_suspended) {
-			ao_led_off(AO_LED_GREEN|AO_LED_AMBER|AO_LED_RED|AO_LED_REMOTE_ARM);
-			for (c = 0; c < AO_LED_CONTINUITY_NUM; c++)
-				ao_led_off(continuity_led[c]);
-			ao_sleep(&ao_lco_suspended);
-		}
-		PRINTD(DEBUG_STATUS, "RSSI %d VALID %d channels %d arm_status %d\n",
-		       ao_radio_cmac_rssi, ao_lco_valid,
-		       ao_lco_channels, ao_pad_query.arm_status);
-		if (!(ao_lco_valid & AO_LCO_VALID_LAST)) {
-			ao_led_on(AO_LED_RED);
-			ao_led_off(AO_LED_GREEN|AO_LED_AMBER);
-			memset(&ao_pad_query, '\0', sizeof (ao_pad_query));
-		} else if (ao_radio_cmac_rssi < -90) {
-			ao_led_on(AO_LED_AMBER);
-			ao_led_off(AO_LED_RED|AO_LED_GREEN);
-		} else {
-			ao_led_on(AO_LED_GREEN);
-			ao_led_off(AO_LED_RED|AO_LED_AMBER);
-		}
-		if (ao_pad_query.arm_status)
-			ao_led_on(AO_LED_REMOTE_ARM);
-		else
-			ao_led_off(AO_LED_REMOTE_ARM);
-
-		all_status = AO_PAD_IGNITER_STATUS_NO_IGNITER_RELAY_OPEN;
-		for (c = 0; c < 8; c++) {
-			if (ao_pad_query.channels & (1 << c)) {
-				uint8_t status = ao_pad_query.igniter_status[c];
-				if (status > all_status)
-					all_status = status;
-				PRINTD(DEBUG_STATUS, "\tchannel %d status %d\n", c, status);
-			}
-		}
-		for (c = 0; c < AO_LED_CONTINUITY_NUM; c++) {
-			uint8_t	on = 0;
-			if (c == (ao_lco_box - ao_config.pad_box) % AO_LED_CONTINUITY_NUM) {
-				switch (all_status) {
-				case AO_PAD_IGNITER_STATUS_GOOD_IGNITER_RELAY_OPEN:
-					on = 1;
-					break;
-				case AO_PAD_IGNITER_STATUS_NO_IGNITER_RELAY_CLOSED:
-				case AO_PAD_IGNITER_STATUS_UNKNOWN:
-					on = t & 1;
-				}
-			}
-			if (on)
-				ao_led_on(continuity_led[c]);
-			else
-				ao_led_off(continuity_led[c]);
-		}
-		t = 1-t;
-	}
-}
-
-static void
-ao_lco_arm_warn(void)
-{
-	int	i;
-	for (;;) {
-		while (ao_lco_suspended)
-			ao_sleep(&ao_lco_suspended);
-		while (!ao_lco_armed)
-			ao_sleep(&ao_lco_armed);
-		for (i = 0; i < ao_lco_armed; i++) {
-			ao_beep_for(AO_BEEP_MID, AO_MS_TO_TICKS(100));
-			ao_delay(AO_MS_TO_TICKS(100));
-		}
-		ao_delay(AO_MS_TO_TICKS(300));
-	}
-}
-
 static struct ao_task ao_lco_input_task;
 static struct ao_task ao_lco_monitor_task;
 static struct ao_task ao_lco_arm_warn_task;
 static struct ao_task ao_lco_igniter_status_task;
 
 static void
-ao_lco_monitor(void)
+ao_lco_main(void)
 {
-	uint16_t		delay;
-
 	ao_config_get();
 	ao_lco_set_box(ao_button_get(AO_BUTTON_BOX));
 	ao_add_task(&ao_lco_input_task, ao_lco_input, "lco input");
@@ -279,33 +117,7 @@ ao_lco_monitor(void)
 	ao_led_on(~0);
 	ao_beep_for(AO_BEEP_MID, AO_MS_TO_TICKS(200));
 	ao_led_off(~0);
-	for (;;) {
-		while (ao_lco_suspended)
-			ao_sleep(&ao_lco_suspended);
-
-		PRINTD(DEBUG_STATUS, "monitor armed %d firing %d\n",
-		       ao_lco_armed, ao_lco_firing);
-
-		if (ao_lco_armed && ao_lco_firing) {
-			ao_lco_ignite(AO_PAD_FIRE);
-		} else {
-			ao_lco_get_channels();
-			if (ao_lco_armed) {
-				PRINTD(DEBUG_STATUS, "Arming pads %x\n",
-				       ao_lco_armed);
-				if (ao_lco_valid & AO_LCO_VALID_EVER) {
-					ao_lco_arm(ao_lco_box, ao_lco_armed, ao_lco_tick_offset);
-					ao_delay(AO_MS_TO_TICKS(10));
-				}
-			}
-		}
-		if (ao_lco_armed && ao_lco_firing)
-			delay = AO_MS_TO_TICKS(100);
-		else {
-			delay = AO_SEC_TO_TICKS(1);
-		}
-		ao_sleep_for(&ao_lco_armed, delay);
-	}
+	ao_lco_monitor();
 }
 
 #if DEBUG
@@ -326,7 +138,7 @@ __code struct ao_cmds ao_lco_cmds[] = {
 void
 ao_lco_init(void)
 {
-	ao_add_task(&ao_lco_monitor_task, ao_lco_monitor, "lco monitor");
+	ao_add_task(&ao_lco_monitor_task, ao_lco_main, "lco monitor");
 #if DEBUG
 	ao_cmd_register(&ao_lco_cmds[0]);
 #endif
diff --git a/src/drivers/ao_pad.c b/src/drivers/ao_pad.c
index 16b4ae60..c6efc311 100644
--- a/src/drivers/ao_pad.c
+++ b/src/drivers/ao_pad.c
@@ -17,6 +17,7 @@
  */
 
 #include <ao.h>
+#include <ao_exti.h>
 #include <ao_pad.h>
 #include <ao_74hc165.h>
 #include <ao_radio_cmac.h>
@@ -69,10 +70,20 @@ ao_strobe(uint8_t v)
 #endif
 }
 
+#ifdef AO_PAD_PORT_0
+#define pins_pad(pad)	(*((AO_PAD_ ## pad ## _PORT) == AO_PAD_PORT_0 ? (&pins0) : (&pins1)))
+#else
+#define pins_pad(pad)	pins0
+#define AO_PAD_PORT_0 AO_PAD_PORT
+#endif
+
 static void
 ao_pad_run(void)
 {
-	AO_PORT_TYPE	pins;
+	AO_PORT_TYPE	pins0;
+#ifdef AO_PAD_PORT_1
+	AO_PORT_TYPE	pins1;
+#endif
 
 	for (;;) {
 		while (!ao_pad_ignite)
@@ -80,58 +91,116 @@ ao_pad_run(void)
 		/*
 		 * Actually set the pad bits
 		 */
-		pins = 0;
+		pins0 = 0;
+#ifdef AO_PAD_PORT_1
+		pins1 = 0;
+#endif
 #if AO_PAD_NUM > 0
 		if (ao_pad_ignite & (1 << 0))
-			pins |= (1 << AO_PAD_PIN_0);
+			pins_pad(0) |= (1 << AO_PAD_PIN_0);
 #endif
 #if AO_PAD_NUM > 1
 		if (ao_pad_ignite & (1 << 1))
-			pins |= (1 << AO_PAD_PIN_1);
+			pins_pad(1) |= (1 << AO_PAD_PIN_1);
 #endif
 #if AO_PAD_NUM > 2
 		if (ao_pad_ignite & (1 << 2))
-			pins |= (1 << AO_PAD_PIN_2);
+			pins_pad(2) |= (1 << AO_PAD_PIN_2);
 #endif
 #if AO_PAD_NUM > 3
 		if (ao_pad_ignite & (1 << 3))
-			pins |= (1 << AO_PAD_PIN_3);
+			pins_pad(3) |= (1 << AO_PAD_PIN_3);
+#endif
+#if AO_PAD_NUM > 4
+		if (ao_pad_ignite & (1 << 4))
+			pins_pad(4) |= (1 << AO_PAD_PIN_4);
+#endif
+#if AO_PAD_NUM > 5
+		if (ao_pad_ignite & (1 << 5))
+			pins_pad(5) |= (1 << AO_PAD_PIN_5);
+#endif
+#if AO_PAD_NUM > 6
+		if (ao_pad_ignite & (1 << 6))
+			pins_pad(6) |= (1 << AO_PAD_PIN_6);
+#endif
+#if AO_PAD_NUM > 7
+		if (ao_pad_ignite & (1 << 7))
+			pins_pad(7) |= (1 << AO_PAD_PIN_7);
+#endif
+#ifdef AO_PAD_PORT_1
+		PRINTD("ignite pins 0x%x 0x%x\n", pins0, pins1);
+		ao_gpio_set_bits(AO_PAD_PORT_0, pins0);
+		ao_gpio_set_bits(AO_PAD_PORT_1, pins1);
+#else
+		PRINTD("ignite pins 0x%x\n", pins0);
+		ao_gpio_set_bits(AO_PAD_PORT_0, pins0);
 #endif
-		PRINTD("ignite pins 0x%x\n", pins);
-		ao_gpio_set_bits(AO_PAD_PORT, pins);
 		while (ao_pad_ignite) {
 			ao_pad_ignite = 0;
 
 			ao_delay(AO_PAD_FIRE_TIME);
 		}
-		ao_gpio_clr_bits(AO_PAD_PORT, pins);
-		PRINTD("turn off pins 0x%x\n", pins);
+#ifdef AO_PAD_PORT_1
+		ao_gpio_clr_bits(AO_PAD_PORT_0, pins0);
+		ao_gpio_clr_bits(AO_PAD_PORT_1, pins1);
+		PRINTD("turn off pins 0x%x 0x%x\n", pins0, pins1);
+#else
+		ao_gpio_set_bits(AO_PAD_PORT_0, pins0);
+		PRINTD("turn off pins 0x%x\n", pins0);
+#endif
 	}
 }
 
 #define AO_PAD_ARM_SIREN_INTERVAL	200
 
-#ifndef AO_PYRO_R_PYRO_SENSE
-#define AO_PYRO_R_PYRO_SENSE	100
-#define AO_PYRO_R_SENSE_GND	27
-#define AO_FIRE_R_POWER_FET	100
-#define AO_FIRE_R_FET_SENSE	100
-#define AO_FIRE_R_SENSE_GND	27
-#endif
+/* Resistor values needed for various voltage test ratios:
+ *
+ *	Net names involved:
+ *
+ *	V_BATT		Battery power, after the initial power switch
+ *	V_PYRO		Pyro power, after the pyro power switch (and initial power switch)
+ *	PYRO_SENSE	ADC input to sense V_PYRO voltage
+ *	BATT_SENSE	ADC input to sense V_BATT voltage
+ *	IGNITER		FET output to pad (the other pad lead hooks to V_PYRO)
+ *	IGNITER_SENSE	ADC input to sense igniter voltage
+ *
+ *	AO_PAD_R_V_BATT_BATT_SENSE	Resistor from battery rail to battery sense input
+ *	AO_PAD_R_BATT_SENSE_GND		Resistor from battery sense input to ground
+ *
+ *	AO_PAD_R_V_BATT_V_PYRO		Resistor from battery rail to pyro rail
+ *	AO_PAD_R_V_PYRO_PYRO_SENSE	Resistor from pyro rail to pyro sense input
+ *	AO_PAD_R_PYRO_SENSE_GND		Resistor from pyro sense input to ground
+ *
+ *	AO_PAD_R_V_PYRO_IGNITER		Optional resistors from pyro rail to FET igniter output
+ *	AO_PAD_R_IGNITER_IGNITER_SENSE	Resistors from FET igniter output to igniter sense ADC inputs
+ *	AO_PAD_R_IGNITER_SENSE_GND	Resistors from igniter sense ADC inputs to ground
+ */
+
+int16_t
+ao_pad_decivolt(int16_t adc, int16_t r_plus, int16_t r_minus)
+{
+	int32_t	mul = (int32_t) AO_ADC_REFERENCE_DV * (r_plus + r_minus);
+	int32_t div = (int32_t) AO_ADC_MAX * r_minus;
+	return ((int32_t) adc * mul + mul/2) / div;
+}
 
 static void
 ao_pad_monitor(void)
 {
 	uint8_t			c;
 	uint8_t			sample;
-	__pdata uint8_t		prev = 0, cur = 0;
+	__pdata AO_LED_TYPE	prev = 0, cur = 0;
 	__pdata uint8_t		beeping = 0;
 	__xdata volatile struct ao_data	*packet;
 	__pdata uint16_t	arm_beep_time = 0;
 
 	sample = ao_data_head;
+	ao_led_set(LEDS_AVAILABLE);
+	ao_delay(AO_MS_TO_TICKS(1000));
+	ao_led_set(0);
 	for (;;) {
 		__pdata int16_t			pyro;
+
 		ao_arch_critical(
 			while (sample == ao_data_head)
 				ao_sleep((void *) DATA_TO_XDATA(&ao_data_head));
@@ -141,28 +210,18 @@ ao_pad_monitor(void)
 		packet = &ao_data_ring[sample];
 		sample = ao_data_ring_next(sample);
 
-		pyro = packet->adc.pyro;
-
-#define VOLTS_TO_PYRO(x) ((int16_t) ((x) * ((1.0 * AO_PYRO_R_SENSE_GND) / \
-					    (1.0 * (AO_PYRO_R_SENSE_GND + AO_PYRO_R_PYRO_SENSE)) / 3.3 * AO_ADC_MAX)))
-
+		/* Reply battery voltage */
+		query.battery = ao_pad_decivolt(packet->adc.batt, AO_PAD_R_V_BATT_BATT_SENSE, AO_PAD_R_BATT_SENSE_GND);
 
-#define VOLTS_TO_FIRE(x) ((int16_t) ((x) * ((1.0 * AO_FIRE_R_SENSE_GND) / \
-					    (1.0 * (AO_FIRE_R_SENSE_GND + AO_FIRE_R_FET_SENSE)) / 3.3 * AO_ADC_MAX)))
+		/* Current pyro voltage */
+		pyro = ao_pad_decivolt(packet->adc.pyro,
+				       AO_PAD_R_V_PYRO_PYRO_SENSE,
+				       AO_PAD_R_PYRO_SENSE_GND);
 
-		/* convert ADC value to voltage in tenths, then add .2 for the diode drop */
-		query.battery = (packet->adc.batt + 96) / 192 + 2;
 		cur = 0;
-		if (pyro > VOLTS_TO_PYRO(10)) {
+		if (pyro > query.battery * 7 / 8) {
 			query.arm_status = AO_PAD_ARM_STATUS_ARMED;
 			cur |= AO_LED_ARMED;
-#if AO_FIRE_R_POWER_FET
-		} else if (pyro > VOLTS_TO_PYRO(5)) {
-			if ((ao_time() % 100) < 50)
-				cur |= AO_LED_ARMED;
-			query.arm_status = AO_PAD_ARM_STATUS_UNKNOWN;
-			arm_beep_time = 0;
-#endif
 		} else {
 			query.arm_status = AO_PAD_ARM_STATUS_DISARMED;
 			arm_beep_time = 0;
@@ -175,54 +234,50 @@ ao_pad_monitor(void)
 			cur |= AO_LED_GREEN;
 
 		for (c = 0; c < AO_PAD_NUM; c++) {
-			int16_t		sense = packet->adc.sense[c];
+			int16_t		sense = ao_pad_decivolt(packet->adc.sense[c],
+								AO_PAD_R_IGNITER_IGNITER_SENSE,
+								AO_PAD_R_IGNITER_SENSE_GND);
 			uint8_t	status = AO_PAD_IGNITER_STATUS_UNKNOWN;
 
 			/*
-			 *	pyro is run through a divider, so pyro = v_pyro * 27 / 127 ~= v_pyro / 20
-			 *	v_pyro = pyro * 127 / 27
+			 *	Here's the resistor stack on each
+			 *	igniter channel. Note that
+			 *	AO_PAD_R_V_PYRO_IGNITER is optional
 			 *
-			 *		v_pyro \
-			 *	100k		igniter
-			 *		output /
-			 *	100k           \
-			 *		sense   relay
-			 *	27k            /
-			 *		gnd ---
+			 *					v_pyro \
+			 *	AO_PAD_R_V_PYRO_IGNITER			igniter
+			 *					output /
+			 *	AO_PAD_R_IGNITER_IGNITER_SENSE         \
+			 *					sense   relay
+			 *	AO_PAD_R_IGNITER_SENSE_GND	       /
+			 *					gnd ---
 			 *
-			 *		v_pyro \
-			 *	200k		igniter
-			 *		output /
-			 *	200k           \
-			 *		sense   relay
-			 *	22k            /
-			 *		gnd ---
-			 *
-			 *	If the relay is closed, then sense will be 0
-			 *	If no igniter is present, then sense will be v_pyro * 27k/227k = pyro * 127 / 227 ~= pyro/2
-			 *	If igniter is present, then sense will be v_pyro * 27k/127k ~= v_pyro / 20 = pyro
 			 */
 
-#if AO_FIRE_R_POWER_FET
+#ifdef AO_PAD_R_V_PYRO_IGNITER
 			if (sense <= pyro / 8) {
+				/* close to zero → relay is closed */
 				status = AO_PAD_IGNITER_STATUS_NO_IGNITER_RELAY_CLOSED;
 				if ((ao_time() % 100) < 50)
 					cur |= AO_LED_CONTINUITY(c);
-			} else
-			if (pyro / 8 * 3 <= sense && sense <= pyro / 8 * 5)
-				status = AO_PAD_IGNITER_STATUS_NO_IGNITER_RELAY_OPEN;
-			else if (pyro / 8 * 7 <= sense) {
-				status = AO_PAD_IGNITER_STATUS_GOOD_IGNITER_RELAY_OPEN;
-				cur |= AO_LED_CONTINUITY(c);
-			}
-#else
-			if (sense >= pyro / 8 * 5) {
-				status = AO_PAD_IGNITER_STATUS_GOOD_IGNITER_RELAY_OPEN;
-				cur |= AO_LED_CONTINUITY(c);
-			} else {
-				status = AO_PAD_IGNITER_STATUS_NO_IGNITER_RELAY_OPEN;
 			}
+			else
 #endif
+			{
+				if (sense >= (pyro * 7) / 8) {
+
+					/* sense close to pyro voltage; igniter is good
+					 */
+					status = AO_PAD_IGNITER_STATUS_GOOD_IGNITER_RELAY_OPEN;
+					cur |= AO_LED_CONTINUITY(c);
+				} else {
+
+					/* relay not shorted (if we can tell),
+					 * and igniter not obviously present
+					 */
+					status = AO_PAD_IGNITER_STATUS_NO_IGNITER_RELAY_OPEN;
+				}
+			}
 			query.igniter_status[c] = status;
 		}
 		if (cur != prev) {
@@ -284,6 +339,23 @@ ao_pad_read_box(void)
 }
 #endif
 
+#ifdef AO_PAD_SELECTOR_PORT
+static int ao_pad_read_box(void) {
+	AO_PORT_TYPE	value = ao_gpio_get_all(AO_PAD_SELECTOR_PORT);
+	unsigned	pin;
+	int		select = 1;
+
+	for (pin = 0; pin < sizeof (AO_PORT_TYPE) * 8; pin++) {
+		if (AO_PAD_SELECTOR_PINS & (1 << pin)) {
+			if ((value & (1 << pin)) == 0)
+				return select;
+			select++;
+		}
+	}
+	return ao_config.pad_box;
+}
+#else
+
 #if HAS_FIXED_PAD_BOX
 #define ao_pad_read_box()	ao_config.pad_box
 #endif
@@ -292,6 +364,8 @@ ao_pad_read_box(void)
 #define ao_pad_read_box()	PAD_BOX
 #endif
 
+#endif
+
 static void
 ao_pad(void)
 {
@@ -299,7 +373,6 @@ ao_pad(void)
 	int8_t	ret;
 
 	ao_pad_box = 0;
-	ao_led_set(0);
 	for (;;) {
 		FLUSHD();
 		while (ao_pad_disabled)
@@ -497,20 +570,51 @@ __code struct ao_cmds ao_pad_cmds[] = {
 	{ 0, NULL }
 };
 
+#ifndef AO_PAD_PORT_1
+#define AO_PAD_0_PORT	AO_PAD_PORT
+#define AO_PAD_1_PORT	AO_PAD_PORT
+#define AO_PAD_2_PORT	AO_PAD_PORT
+#define AO_PAD_3_PORT	AO_PAD_PORT
+#define AO_PAD_4_PORT	AO_PAD_PORT
+#define AO_PAD_5_PORT	AO_PAD_PORT
+#define AO_PAD_6_PORT	AO_PAD_PORT
+#define AO_PAD_7_PORT	AO_PAD_PORT
+#endif
+
 void
 ao_pad_init(void)
 {
+#ifdef AO_PAD_SELECTOR_PORT
+	unsigned pin;
+
+	for (pin = 0; pin < sizeof (AO_PORT_TYPE) * 8; pin++) {
+		if (AO_PAD_SELECTOR_PINS & (1 << pin))
+			ao_enable_input(AO_PAD_SELECTOR_PORT, pin, AO_EXTI_MODE_PULL_UP);
+	}
+#endif
 #if AO_PAD_NUM > 0
-	ao_enable_output(AO_PAD_PORT, AO_PAD_PIN_0, AO_PAD_0, 0);
+	ao_enable_output(AO_PAD_0_PORT, AO_PAD_PIN_0, AO_PAD_0, 0);
 #endif
 #if AO_PAD_NUM > 1
-	ao_enable_output(AO_PAD_PORT, AO_PAD_PIN_1, AO_PAD_1, 0);
+	ao_enable_output(AO_PAD_1_PORT, AO_PAD_PIN_1, AO_PAD_1, 0);
 #endif
 #if AO_PAD_NUM > 2
-	ao_enable_output(AO_PAD_PORT, AO_PAD_PIN_2, AO_PAD_2, 0);
+	ao_enable_output(AO_PAD_2_PORT, AO_PAD_PIN_2, AO_PAD_2, 0);
 #endif
 #if AO_PAD_NUM > 3
-	ao_enable_output(AO_PAD_PORT, AO_PAD_PIN_3, AO_PAD_3, 0);
+	ao_enable_output(AO_PAD_3_PORT, AO_PAD_PIN_3, AO_PAD_3, 0);
+#endif
+#if AO_PAD_NUM > 4
+	ao_enable_output(AO_PAD_4_PORT, AO_PAD_PIN_4, AO_PAD_4, 0);
+#endif
+#if AO_PAD_NUM > 5
+	ao_enable_output(AO_PAD_5_PORT, AO_PAD_PIN_5, AO_PAD_5, 0);
+#endif
+#if AO_PAD_NUM > 5
+	ao_enable_output(AO_PAD_6_PORT, AO_PAD_PIN_6, AO_PAD_6, 0);
+#endif
+#if AO_PAD_NUM > 7
+	ao_enable_output(AO_PAD_7_PORT, AO_PAD_PIN_7, AO_PAD_7, 0);
 #endif
 #ifdef AO_STROBE
 	ao_enable_output(AO_STROBE_PORT, AO_STROBE_PIN, AO_STROBE, 0);
diff --git a/src/drivers/ao_quadrature.c b/src/drivers/ao_quadrature.c
index deecfb79..250e035f 100644
--- a/src/drivers/ao_quadrature.c
+++ b/src/drivers/ao_quadrature.c
@@ -23,6 +23,10 @@
 #include <ao_event.h>
 
 __xdata int32_t ao_quadrature_count[AO_QUADRATURE_COUNT];
+#ifndef AO_QUADRATURE_SINGLE_CODE
+static int8_t ao_quadrature_step[AO_QUADRATURE_COUNT];
+#endif
+
 static uint8_t  ao_quadrature_state[AO_QUADRATURE_COUNT];
 
 struct ao_debounce {
@@ -39,20 +43,25 @@ static struct ao_debounce ao_debounce_state[AO_QUADRATURE_COUNT][2];
 #define pinb(q) AO_QUADRATURE_ ## q ## _B ## _PIN
 #define isr(q)  ao_quadrature_isr_ ## q
 
-#define DEBOUNCE	10
+#ifndef AO_QUADRATURE_DEBOUNCE
+#error must define AO_QUADRATURE_DEBOUNCE
+#endif
 
 static uint8_t
 ao_debounce(uint8_t cur, struct ao_debounce *debounce)
 {
-	if (cur == debounce->state)
-		debounce->count = 0;
-	else {
-		if (++debounce->count == DEBOUNCE) {
-			debounce->state = cur;
-			debounce->count = 0;
-		}
+#if AO_QUADRATURE_DEBOUNCE > 0
+	if (debounce->count > 0) {
+		debounce->count--;
+	} else if (cur != debounce->state) {
+		debounce->state = cur;
+		debounce->count = AO_QUADRATURE_DEBOUNCE;
 	}
 	return debounce->state;
+#else
+	(void) debounce;
+	return cur;
+#endif
 }
 
 static uint16_t
@@ -70,8 +79,21 @@ ao_quadrature_read(struct stm_gpio *gpio, uint8_t pin_a, uint8_t pin_b, struct a
 #define _ao_quadrature_get(q)	ao_quadrature_read(port(q), bita(q), bitb(q), ao_debounce_state[q])
 
 static void
-_ao_quadrature_queue(uint8_t q, int8_t step)
+_ao_quadrature_step(uint8_t q, int8_t step)
 {
+#ifndef AO_QUADRATURE_SINGLE_CODE
+	ao_quadrature_step[q] += step;
+	if (ao_quadrature_state[q] != 0)
+		return;
+	if (ao_quadrature_step[q] >= 4) {
+		ao_quadrature_step[q] = 0;
+		step = 1;
+	} else if (ao_quadrature_step[q] <= -4) {
+		ao_quadrature_step[q] = 0;
+		step = -1;
+	} else
+		return;
+#endif
 	ao_quadrature_count[q] += step;
 #if AO_EVENT
 	ao_event_put_isr(AO_EVENT_QUADRATURE, q, step);
@@ -79,17 +101,29 @@ _ao_quadrature_queue(uint8_t q, int8_t step)
 	ao_wakeup(&ao_quadrature_count[q]);
 }
 
+static const struct {
+	uint8_t prev, next;
+} ao_quadrature_steps[4] = {
+	[0] { .prev = 2, .next = 1 },
+	[1] { .prev = 0, .next = 3 },
+	[3] { .prev = 1, .next = 2 },
+	[2] { .prev = 3, .next = 0 },
+};
+
 static void
-_ao_quadrature_set(uint8_t q, uint8_t new) {
-	uint8_t	old = ao_quadrature_state[q];
-
-	if (old != new && new == 0) {
-		if (old & 2)
-			_ao_quadrature_queue(q, 1);
-		else if (old & 1)
-			_ao_quadrature_queue(q, -1);
-	}
+_ao_quadrature_set(uint8_t q, uint8_t new)
+{
+	uint8_t	old;
+
+	ao_arch_block_interrupts();
+	old = ao_quadrature_state[q];
 	ao_quadrature_state[q] = new;
+	ao_arch_release_interrupts();
+
+	if (new == ao_quadrature_steps[old].next)
+		_ao_quadrature_step(q, 1);
+	else if (new == ao_quadrature_steps[old].prev)
+		_ao_quadrature_step(q, -1);
 }
 
 static void
@@ -103,6 +137,14 @@ ao_quadrature_isr(void)
 #endif
 }
 
+static void
+_ao_quadrature_start_one(uint8_t q, uint8_t new)
+{
+	ao_arch_block_interrupts();
+	ao_quadrature_state[q] = new;
+	ao_arch_release_interrupts();
+}
+
 int32_t
 ao_quadrature_poll(uint8_t q)
 {
@@ -124,21 +166,32 @@ ao_quadrature_test(void)
 	uint8_t	q;
 	int32_t	c;
 	uint8_t	s;
+#ifndef AO_QUADRATURE_SINGLE_CODE
+	int8_t t = 0;
+#endif
 
 	ao_cmd_decimal();
 	q = ao_cmd_lex_i;
-	if (q >= AO_QUADRATURE_COUNT) {
+	if (q >= AO_QUADRATURE_COUNT)
 		ao_cmd_status = ao_cmd_syntax_error;
+	if (ao_cmd_status != ao_cmd_success)
 		return;
-	}
 
 	c = -10000;
 	s = 0;
 	while (ao_quadrature_count[q] != 10) {
 		if (ao_quadrature_count[q] != c ||
-		    ao_quadrature_state[q] != s) {
+#ifndef AO_QUADRATURE_SINGLE_CODE
+		    ao_quadrature_step[q] != t ||
+#endif
+		    ao_quadrature_state[q] != s)
+		{
 			c = ao_quadrature_count[q];
 			s = ao_quadrature_state[q];
+#ifndef AO_QUADRATURE_SINGLE_CODE
+			t = ao_quadrature_step[q];
+			printf("step %3d ", t);
+#endif
 			printf ("count %3d state %2x\n", c, s);
 			flush();
 		}
@@ -160,9 +213,10 @@ static const struct ao_cmds ao_quadrature_cmds[] = {
 	{ 0, NULL }
 };
 
-#define init(q) do {					\
-		ao_enable_input(port(q), bita(q), 0);	\
-		ao_enable_input(port(q), bitb(q), 0);	\
+#define init(q) do {							\
+		ao_enable_input(port(q), bita(q), 0);			\
+		ao_enable_input(port(q), bitb(q), 0);			\
+		_ao_quadrature_start_one(q, _ao_quadrature_get(q));	\
 	} while (0)
 
 void
diff --git a/src/fox1ihu/.gitignore b/src/fox1ihu/.gitignore
new file mode 100644
index 00000000..538cf8b2
--- /dev/null
+++ b/src/fox1ihu/.gitignore
@@ -0,0 +1,2 @@
+ao_product.h
+fox1ihu-*.elf
diff --git a/src/fox1ihu/Makefile b/src/fox1ihu/Makefile
new file mode 100644
index 00000000..e3226a24
--- /dev/null
+++ b/src/fox1ihu/Makefile
@@ -0,0 +1,89 @@
+#
+# AltOS build
+#
+#
+
+include ../stm/Makefile.defs
+
+INC = \
+	ao.h \
+	ao_arch.h \
+	ao_arch_funcs.h \
+	ao_pins.h \
+	ao_product.h \
+	ao_watchdog.h \
+	ao_storage.h \
+	ao_task.h \
+	stm32l.h \
+	ao_sdcard.h \
+	ao_bufio.h \
+	ao_fat.h \
+	Makefile
+
+#PROFILE=ao_profile.c
+#PROFILE_DEF=-DAO_PROFILE=1
+
+#SAMPLE_PROFILE=ao_sample_profile.c \
+#	ao_sample_profile_timer.c
+#SAMPLE_PROFILE_DEF=-DHAS_SAMPLE_PROFILE=1
+
+#STACK_GUARD=ao_mpu_stm.c
+#STACK_GUARD_DEF=-DHAS_STACK_GUARD=1
+
+ALTOS_SRC = \
+	ao_boot_chain.c \
+	ao_interrupt.c \
+	ao_product.c \
+	ao_romconfig.c \
+	ao_cmd.c \
+	ao_task.c \
+	ao_led.c \
+	ao_stdio.c \
+	ao_panic.c \
+	ao_timer.c \
+	ao_mutex.c \
+	ao_dma_stm.c \
+	ao_spi_stm.c \
+	ao_usb_stm.c \
+	ao_exti_stm.c \
+	ao_adc_stm.c \
+	ao_data.c \
+	ao_storage.c \
+	ao_mr25.c \
+	ao_sdcard.c \
+	ao_bufio.c \
+	ao_fat.c \
+	ao_watchdog.c
+
+PRODUCT=Fox1IHU-v2
+PRODUCT_DEF=-DFOX
+IDPRODUCT=0x0024
+
+CFLAGS = $(PRODUCT_DEF) $(STM_CFLAGS) $(PROFILE_DEF) $(SAMPLE_PROFILE_DEF) $(STACK_GUARD_DEF) -Os -g
+
+PROGNAME=fox1ihu-v0.1
+PROG=$(PROGNAME)-$(VERSION).elf
+HEX=$(PROGNAME)-$(VERSION).ihx
+
+SRC=$(ALTOS_SRC) ao_fox1ihu.c
+OBJ=$(SRC:.c=.o)
+
+all: $(PROG) $(HEX)
+
+$(PROG): Makefile $(OBJ) altos.ld
+	$(call quiet,CC) $(LDFLAGS) $(CFLAGS) -o $(PROG) $(OBJ) $(LIBS)
+
+$(OBJ): $(INC)
+
+ao_product.h: ao-make-product.5c ../Version
+	$(call quiet,NICKLE,$<) $< -m altusmetrum.org -i $(IDPRODUCT) -p $(PRODUCT) -v $(VERSION) > $@
+
+distclean:	clean
+
+clean:
+	rm -f *.o $(PROGNAME)-*.elf
+	rm -f ao_product.h
+
+install:
+
+uninstall:
diff --git a/src/fox1ihu/ao_fox1ihu.c b/src/fox1ihu/ao_fox1ihu.c
new file mode 100644
index 00000000..2e1a2fdf
--- /dev/null
+++ b/src/fox1ihu/ao_fox1ihu.c
@@ -0,0 +1,56 @@
+/*
+ * Copyright © 2012 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.
+ */
+
+#include <ao.h>
+#include <ao_exti.h>
+#include <ao_watchdog.h>
+#include <ao_storage.h>
+#include <ao_fat.h>
+
+int
+main(void)
+{
+	ao_clock_init();
+	
+#if HAS_STACK_GUARD
+	ao_mpu_init();
+#endif
+
+	ao_task_init();
+	ao_led_init(LEDS_AVAILABLE);
+	ao_led_on(AO_LED_RED|AO_LED_GREEN|AO_LED_RED_2|AO_LED_GREEN_2);
+	ao_timer_init();
+
+	ao_spi_init();
+	ao_dma_init();
+	ao_exti_init();
+
+	ao_adc_init();
+
+	ao_cmd_init();
+
+	ao_usb_init();
+
+	ao_storage_init();
+
+	ao_watchdog_init();
+
+	ao_fat_init();
+
+	ao_start_scheduler();
+	return 0;
+}
diff --git a/src/fox1ihu/ao_pins.h b/src/fox1ihu/ao_pins.h
new file mode 100644
index 00000000..b5dd7283
--- /dev/null
+++ b/src/fox1ihu/ao_pins.h
@@ -0,0 +1,317 @@
+/*
+ * Copyright © 2012 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_PINS_H_
+#define _AO_PINS_H_
+
+#define HAS_TASK_QUEUE		1
+
+/* 8MHz High speed external crystal */
+#define AO_HSE			8000000
+
+/* PLLVCO = 96MHz (so that USB will work) */
+#define AO_PLLMUL		12
+#define AO_RCC_CFGR_PLLMUL	(STM_RCC_CFGR_PLLMUL_12)
+
+/* SYSCLK = 32MHz (no need to go faster than CPU) */
+#define AO_PLLDIV		3
+#define AO_RCC_CFGR_PLLDIV	(STM_RCC_CFGR_PLLDIV_3)
+
+/* HCLK = 32MHz (CPU clock) */
+#define AO_AHB_PRESCALER	1
+#define AO_RCC_CFGR_HPRE_DIV	STM_RCC_CFGR_HPRE_DIV_1
+
+/* Run APB1 at 16MHz (HCLK/2) */
+#define AO_APB1_PRESCALER	2
+#define AO_RCC_CFGR_PPRE1_DIV	STM_RCC_CFGR_PPRE2_DIV_2
+
+/* Run APB2 at 16MHz (HCLK/2) */
+#define AO_APB2_PRESCALER	2
+#define AO_RCC_CFGR_PPRE2_DIV	STM_RCC_CFGR_PPRE2_DIV_2
+
+#define HAS_SERIAL_1		1
+#define USE_SERIAL_1_STDIN	0
+#define SERIAL_1_PB6_PB7	0
+#define SERIAL_1_PA9_PA10	1
+
+#define HAS_SERIAL_2		0
+#define USE_SERIAL_2_STDIN	0
+#define SERIAL_2_PA2_PA3	0
+#define SERIAL_2_PD5_PD6	0
+
+#define HAS_SERIAL_3		0
+#define USE_SERIAL_3_STDIN	0
+#define SERIAL_3_PB10_PB11	0
+#define SERIAL_3_PC10_PC11	1
+#define SERIAL_3_PD8_PD9	0
+
+#define HAS_EEPROM		0
+#define USE_INTERNAL_FLASH	0
+#define HAS_USB			1
+#define HAS_BEEP		0
+#define HAS_RADIO		0
+#define HAS_TELEMETRY		0
+
+#define HAS_SPI_1		1
+#define SPI_1_PA5_PA6_PA7	0
+#define SPI_1_PB3_PB4_PB5	0
+#define SPI_1_PE13_PE14_PE15	1	/* */
+#define SPI_1_OSPEEDR		STM_OSPEEDR_10MHz
+
+#define HAS_SPI_2		1
+#define SPI_2_PB13_PB14_PB15	1	/* */
+#define SPI_2_PD1_PD3_PD4	0
+#define SPI_2_OSPEEDR		STM_OSPEEDR_10MHz
+#define HAS_STORAGE_DEBUG	1
+
+#define SPI_2_PORT		(&stm_gpiob)
+#define SPI_2_SCK_PIN		13
+#define SPI_2_MISO_PIN		14
+#define SPI_2_MOSI_PIN		15
+
+#define HAS_I2C_1		1
+#define I2C_1_PB6_PB7		1
+#define I2C_1_PB8_PB9		0
+
+#define HAS_I2C_2		1
+#define I2C_2_PB10_PB11		1
+
+#define PACKET_HAS_SLAVE	0
+#define PACKET_HAS_MASTER	0
+
+#define LOW_LEVEL_DEBUG		0
+
+#define LED_PORT_0_ENABLE	STM_RCC_AHBENR_GPIOCEN
+#define LED_PORT_0		(&stm_gpioc)
+#define LED_PORT_0_MASK		(0xff)
+#define LED_PORT_0_SHIFT	0
+#define LED_PIN_RED		6
+#define LED_PIN_GREEN		7
+#define LED_PIN_RED_2		8
+#define LED_PIN_GREEN_2		9
+#define AO_LED_RED		(1 << LED_PIN_RED)
+#define AO_LED_GREEN		(1 << LED_PIN_GREEN)
+#define AO_LED_RED_2		(1 << LED_PIN_RED_2)
+#define AO_LED_GREEN_2		(1 << LED_PIN_GREEN_2)
+
+#define LEDS_AVAILABLE		(AO_LED_RED | AO_LED_GREEN | AO_LED_RED_2 | AO_LED_GREEN_2)
+
+#define HAS_GPS			0
+#define HAS_FLIGHT		0
+#define HAS_ADC			1
+#define HAS_ADC_TEMP		1
+#define HAS_LOG			0
+
+/*
+ * ADC
+ */
+#define AO_DATA_RING		32
+
+struct ao_adc {
+	int16_t			tx_pa_current;	/* 0 ADC_IN0 */
+	int16_t			tx_temp;	/* 1 ADC_IN1 */
+	int16_t			exp4_temp;	/* 2 ADC_IN2 */
+	int16_t			rx_temp;	/* 3 ADC_IN3 */
+	int16_t			tx_analog_1;	/* 4 ADC_IN4 */
+	int16_t			sense_batt;	/* 5 ADC_IN5 */
+	int16_t			rx_analog_1;	/* 6 ADC_IN6 */
+	int16_t			rx_rssi;	/* 7 ADC_IN8 */
+	int16_t			rx_cd;		/* 8 ADC_IN9 */
+	int16_t			ant_sense_1;	/* 9 ADC_IN10 */
+	int16_t			ant_sense_2;	/* 10 ADC_IN11 */
+	int16_t			gyro_x_1;	/* 11 ADC_IN12 */
+	int16_t			gyro_z_1;	/* 12 ADC_IN13 */
+	int16_t			gyro_vref_1;	/* 13 ADC_IN24 */
+	int16_t			gyro_x_2;	/* 14 ADC_IN14 */
+	int16_t			gyro_z_2;	/* 15 ADC_IN15 */
+	int16_t			gyro_vref_2;	/* 16 ADC_IN25 */
+};
+
+#define AO_ADC_TX_PA_CURRENT		0
+#define AO_ADC_TX_PA_CURRENT_PORT	(&stm_gpioa)
+#define AO_ADC_TX_PA_CURRENT_PIN	0
+
+#define AO_ADC_TX_TEMP			1
+#define AO_ADC_TX_TEMP_PORT		(&stm_gpioa)
+#define AO_ADC_TX_TEMP_PIN		1
+
+#define AO_ADC_EXP4_TEMP		2
+#define AO_ADC_EXP4_TEMP_PORT		(&stm_gpioa)
+#define AO_ADC_EXP4_TEMP_PIN		2
+
+#define AO_ADC_RX_TEMP			3
+#define AO_ADC_RX_TEMP_PORT		(&stm_gpioa)
+#define AO_ADC_RX_TEMP_PIN		3
+
+#define AO_ADC_TX_ANALOG_1		4
+#define AO_ADC_TX_ANALOG_1_PORT		(&stm_gpioa)
+#define AO_ADC_TX_ANALOG_1_PIN		4
+
+#define AO_ADC_SENSE_BATT		5
+#define AO_ADC_SENSE_BATT_PORT		(&stm_gpioa)
+#define AO_ADC_SENSE_BATT_PIN		5
+
+#define AO_ADC_RX_ANALOG_1		6
+#define AO_ADC_RX_ANALOG_1_PORT		(&stm_gpioa)
+#define AO_ADC_RX_ANALOG_1_PIN		6
+
+#define AO_ADC_RX_RSSI			8
+#define AO_ADC_RX_RSSI_PORT		(&stm_gpiob)
+#define AO_ADC_RX_RSSI_PIN		0
+
+#define AO_ADC_RX_CD			9
+#define AO_ADC_RX_CD_PORT		(&stm_gpiob)
+#define AO_ADC_RX_CD_PIN		1
+
+#define AO_ADC_ANT_SENSE_1		10
+#define AO_ADC_ANT_SENSE_1_PORT		(&stm_gpioc)
+#define AO_ADC_ANT_SENSE_1_PIN		0
+
+#define AO_ADC_ANT_SENSE_2		11
+#define AO_ADC_ANT_SENSE_2_PORT		(&stm_gpioc)
+#define AO_ADC_ANT_SENSE_2_PIN		1
+
+#define AO_ADC_GYRO_X_1			12
+#define AO_ADC_GYRO_X_1_PORT		(&stm_gpioc)
+#define AO_ADC_GYRO_X_1_PIN		2
+
+#define AO_ADC_GYRO_Z_1			13
+#define AO_ADC_GYRO_Z_1_PORT		(&stm_gpioc)
+#define AO_ADC_GYRO_Z_1_PIN		3
+
+#define AO_ADC_GYRO_VREF_1		24
+#define AO_ADC_GYRO_VREF_1_PORT		(&stm_gpioe)
+#define AO_ADC_GYRO_VREF_1_PIN		9
+
+#define AO_ADC_GYRO_X_2			14
+#define AO_ADC_GYRO_X_2_PORT		(&stm_gpioc)
+#define AO_ADC_GYRO_X_2_PIN		4
+
+#define AO_ADC_GYRO_Z_2			15
+#define AO_ADC_GYRO_Z_2_PORT		(&stm_gpioc)
+#define AO_ADC_GYRO_Z_2_PIN		5
+
+#define AO_ADC_GYRO_VREF_2		25
+#define AO_ADC_GYRO_VREF_2_PORT		(&stm_gpioe)
+#define AO_ADC_GYRO_VREF_2_PIN		10
+
+#define AO_ADC_TEMP			16
+
+#define AO_ADC_RCC_AHBENR	((1 << STM_RCC_AHBENR_GPIOAEN) | \
+				 (1 << STM_RCC_AHBENR_GPIOBEN) | \
+				 (1 << STM_RCC_AHBENR_GPIOCEN) | \
+				 (1 << STM_RCC_AHBENR_GPIOEEN))
+
+#define AO_NUM_ADC_PIN		(17)
+
+#define AO_ADC_PIN0_PORT	AO_ADC_TX_PA_CURRENT_PORT
+#define AO_ADC_PIN0_PIN		AO_ADC_TX_PA_CURRENT_PIN
+#define AO_ADC_PIN1_PORT	AO_ADC_TX_TEMP_PORT
+#define AO_ADC_PIN1_PIN		AO_ADC_TX_TEMP_PIN
+#define AO_ADC_PIN2_PORT	AO_ADC_EXP4_TEMP_PORT
+#define AO_ADC_PIN2_PIN		AO_ADC_EXP4_TEMP_PIN
+#define AO_ADC_PIN3_PORT	AO_ADC_RX_TEMP_PORT
+#define AO_ADC_PIN3_PIN		AO_ADC_RX_TEMP_PIN
+#define AO_ADC_PIN4_PORT	AO_ADC_TX_ANALOG_1_PORT
+#define AO_ADC_PIN4_PIN		AO_ADC_TX_ANALOG_1_PIN
+#define AO_ADC_PIN5_PORT	AO_ADC_SENSE_BATT_PORT
+#define AO_ADC_PIN5_PIN		AO_ADC_SENSE_BATT_PIN
+#define AO_ADC_PIN6_PORT	AO_ADC_RX_ANALOG_1_PORT
+#define AO_ADC_PIN6_PIN		AO_ADC_RX_ANALOG_1_PIN
+#define AO_ADC_PIN7_PORT	AO_ADC_RX_RSSI_PORT
+#define AO_ADC_PIN7_PIN		AO_ADC_RX_RSSI_PIN
+#define AO_ADC_PIN8_PORT	AO_ADC_RX_CD_PORT
+#define AO_ADC_PIN8_PIN		AO_ADC_RX_CD_PIN
+#define AO_ADC_PIN9_PORT	AO_ADC_ANT_SENSE_1_PORT
+#define AO_ADC_PIN9_PIN		AO_ADC_ANT_SENSE_1_PIN
+#define AO_ADC_PIN10_PORT	AO_ADC_ANT_SENSE_2_PORT
+#define AO_ADC_PIN10_PIN	AO_ADC_ANT_SENSE_2_PIN
+#define AO_ADC_PIN11_PORT	AO_ADC_GYRO_X_1_PORT
+#define AO_ADC_PIN11_PIN	AO_ADC_GYRO_X_1_PIN
+#define AO_ADC_PIN12_PORT	AO_ADC_GYRO_Z_1_PORT
+#define AO_ADC_PIN12_PIN	AO_ADC_GYRO_Z_1_PIN
+#define AO_ADC_PIN13_PORT	AO_ADC_GYRO_VREF_1_PORT
+#define AO_ADC_PIN13_PIN	AO_ADC_GYRO_VREF_1_PIN
+#define AO_ADC_PIN14_PORT	AO_ADC_GYRO_X_2_PORT
+#define AO_ADC_PIN14_PIN	AO_ADC_GYRO_X_2_PIN
+#define AO_ADC_PIN15_PORT	AO_ADC_GYRO_Z_2_PORT
+#define AO_ADC_PIN15_PIN	AO_ADC_GYRO_Z_2_PIN
+#define AO_ADC_PIN16_PORT	AO_ADC_GYRO_VREF_2_PORT
+#define AO_ADC_PIN16_PIN	AO_ADC_GYRO_VREF_2_PIN
+
+#define AO_NUM_ADC	       	(AO_NUM_ADC_PIN + 1)	/* Add internal temp sensor */
+
+#define AO_ADC_SQ1		AO_ADC_TX_PA_CURRENT
+#define AO_ADC_SQ1_NAME		"tx_pa_current"
+#define AO_ADC_SQ2		AO_ADC_TX_TEMP
+#define AO_ADC_SQ2_NAME		"tx_temp"
+#define AO_ADC_SQ3		AO_ADC_EXP4_TEMP
+#define AO_ADC_SQ3_NAME		"expr_temp"
+#define AO_ADC_SQ4		AO_ADC_RX_TEMP
+#define AO_ADC_SQ4_NAME		"rx_temp"
+#define AO_ADC_SQ5		AO_ADC_TX_ANALOG_1
+#define AO_ADC_SQ5_NAME		"tx_analog_1"
+#define AO_ADC_SQ6		AO_ADC_SENSE_BATT
+#define AO_ADC_SQ6_NAME		"sense_batt"
+#define AO_ADC_SQ7		AO_ADC_RX_ANALOG_1
+#define AO_ADC_SQ7_NAME		"rx_analog_1"
+#define AO_ADC_SQ8		AO_ADC_RX_RSSI
+#define AO_ADC_SQ8_NAME		"rx_rssi"
+#define AO_ADC_SQ9		AO_ADC_RX_CD
+#define AO_ADC_SQ9_NAME		"rx_cd"
+#define AO_ADC_SQ10		AO_ADC_ANT_SENSE_1
+#define AO_ADC_SQ10_NAME	"ant_sense_1"
+#define AO_ADC_SQ11		AO_ADC_ANT_SENSE_2
+#define AO_ADC_SQ11_NAME	"ant_sense_2"
+#define AO_ADC_SQ12		AO_ADC_GYRO_X_1
+#define AO_ADC_SQ12_NAME	"gyro_x_1"
+#define AO_ADC_SQ13		AO_ADC_GYRO_Z_1
+#define AO_ADC_SQ13_NAME	"gyro_z_1"
+#define AO_ADC_SQ14		AO_ADC_GYRO_VREF_1
+#define AO_ADC_SQ14_NAME	"gyro_vref_1"
+#define AO_ADC_SQ15		AO_ADC_GYRO_X_2
+#define AO_ADC_SQ15_NAME	"gyro_x_2"
+#define AO_ADC_SQ16		AO_ADC_GYRO_Z_2
+#define AO_ADC_SQ16_NAME	"gyro_z_2"
+#define AO_ADC_SQ17		AO_ADC_GYRO_VREF_2
+#define AO_ADC_SQ17_NAME	"gyro_vref_2"
+#define AO_ADC_SQ18		AO_ADC_TEMP
+#define AO_ADC_SQ18_NAME	"temp"
+
+/* Watchdog timer */
+
+#define AO_WATCHDOG_INTERVAL	AO_MS_TO_TICKS(40)
+#define AO_WATCHDOG_PORT	(&stm_gpiod)
+#define AO_WATCHDOG_BIT		3
+
+/* MRAM device */
+
+#define AO_MR25_SPI_CS_PORT	(&stm_gpiod)
+#define AO_MR25_SPI_CS_PIN	0
+#define AO_MR25_SPI_BUS		AO_SPI_2_PB13_PB14_PB15
+
+/* SD card */
+
+#define AO_SDCARD_SPI_CS_PORT	(&stm_gpiod)
+#define AO_SDCARD_SPI_CS_PIN	1
+#define AO_SDCARD_SPI_BUS	AO_SPI_2_PB13_PB14_PB15
+#define AO_SDCARD_SPI_PORT	(&stm_gpiob)
+#define AO_SDCARD_SPI_SCK_PIN	13
+#define AO_SDCARD_SPI_MISO_PIN	14
+#define AO_SDCARD_SPI_MOSI_PIN	15
+
+#endif /* _AO_PINS_H_ */
diff --git a/src/fox1ihu/flash-loader/Makefile b/src/fox1ihu/flash-loader/Makefile
new file mode 100644
index 00000000..454bc6fb
--- /dev/null
+++ b/src/fox1ihu/flash-loader/Makefile
@@ -0,0 +1,8 @@
+#
+# AltOS flash loader build
+#
+#
+
+TOPDIR=../..
+HARDWARE=fox1ihu
+include $(TOPDIR)/stm/Makefile-flash.defs
diff --git a/src/fox1ihu/flash-loader/ao_pins.h b/src/fox1ihu/flash-loader/ao_pins.h
new file mode 100644
index 00000000..19f29b08
--- /dev/null
+++ b/src/fox1ihu/flash-loader/ao_pins.h
@@ -0,0 +1,59 @@
+/*
+ * 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_PINS_H_
+#define _AO_PINS_H_
+
+/* External crystal at 8MHz */
+#define AO_HSE		8000000
+
+#define AO_WATCHDOG_PORT	(&stm_gpiod)
+#define AO_WATCHDOG_PORT_BIT	(1 << STM_RCC_AHBENR_GPIODEN)
+#define AO_WATCHDOG_BIT		3
+#define AO_WATCHDOG_VALUE	0
+
+#define AO_RADIO_CONTROL_PORT		(&stm_gpioe)
+#define AO_RADIO_CONTROL_PORT_BIT	(1 << STM_RCC_AHBENR_GPIOEEN)
+#define AO_RADIO_CONTROL_BIT		12
+#define AO_RADIO_CONTROL_VALUE		1
+
+#define AO_FLASH_LOADER_INIT do {					\
+		stm_rcc.ahbenr |= AO_WATCHDOG_PORT_BIT | AO_RADIO_CONTROL_PORT_BIT; \
+									\
+		stm_gpio_set(AO_WATCHDOG_PORT, AO_WATCHDOG_BIT, AO_WATCHDOG_VALUE); \
+		stm_moder_set(AO_WATCHDOG_PORT, AO_WATCHDOG_BIT, STM_MODER_OUTPUT); \
+									\
+		stm_gpio_set(AO_RADIO_CONTROL_PORT, AO_RADIO_CONTROL_BIT, AO_RADIO_CONTROL_VALUE); \
+		stm_moder_set(AO_RADIO_CONTROL_PORT, AO_RADIO_CONTROL_BIT, STM_MODER_OUTPUT); \
+	} while (0)
+
+#define AO_TIMER_HOOK	do {						\
+		AO_WATCHDOG_PORT->odr ^= (1 << AO_WATCHDOG_BIT);	\
+	} while (0)
+
+#define HAS_TICK		1
+#include <ao_flash_stm_pins.h>
+
+/* Attached signal, PB8 */
+
+#define AO_BOOT_PIN		1
+#define AO_BOOT_APPLICATION_GPIO	stm_gpiob
+#define AO_BOOT_APPLICATION_PIN		8
+#define AO_BOOT_APPLICATION_VALUE	0
+#define AO_BOOT_APPLICATION_MODE	0
+
+#endif /* _AO_PINS_H_ */
diff --git a/src/kernel/ao_flash_readout.c b/src/kernel/ao_flash_readout.c
new file mode 100644
index 00000000..46b5ba7a
--- /dev/null
+++ b/src/kernel/ao_flash_readout.c
@@ -0,0 +1,50 @@
+/*
+ * Copyright © 2018 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, either version 2 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.
+ */
+
+#include <ao.h>
+#include <ao_usb.h>
+#include <ao_flash_readout.h>
+
+#ifndef AO_FLASH_READOUT_BASE
+#define AO_FLASH_READOUT_BASE	AO_BOOT_LOADER_BASE
+#define AO_FLASH_READOUT_BOUND	AO_BOOT_APPLICATION_BOUND
+#endif
+
+static void
+ao_flash_readout(void)
+{
+	uint8_t	*base = (uint8_t *) AO_FLASH_READOUT_BASE;
+	uint8_t	*bound = (uint8_t *) AO_FLASH_READOUT_BOUND;
+	uint8_t	*p = base;
+
+	for (;;) {
+		ao_arch_block_interrupts();
+		while (!ao_usb_running) {
+			p = base;
+			ao_sleep(&ao_usb_running);
+		}
+		ao_arch_release_interrupts();
+		ao_flash_readout_putchar(*p++);
+		if (p == bound)
+			p = base;
+	}
+}
+
+static struct ao_task	ao_flash_readout_task;
+
+void
+ao_flash_readout_init(void)
+{
+	ao_add_task(&ao_flash_readout_task, ao_flash_readout, "flash_readout");
+}
diff --git a/src/kernel/ao_flash_readout.h b/src/kernel/ao_flash_readout.h
new file mode 100644
index 00000000..5eee53cc
--- /dev/null
+++ b/src/kernel/ao_flash_readout.h
@@ -0,0 +1,20 @@
+/*
+ * Copyright © 2018 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, either version 2 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.
+ */
+
+#ifndef _AO_FLASH_READOUT_H_
+#define _AO_FLASH_READOUT_H_
+
+void	ao_flash_readout_init(void);
+
+#endif /* _AO_FLASH_READOUT_H_ */
diff --git a/src/kernel/ao_flight.c b/src/kernel/ao_flight.c
index cb02c454..c2700d20 100644
--- a/src/kernel/ao_flight.c
+++ b/src/kernel/ao_flight.c
@@ -48,7 +48,8 @@
 /* Main flight thread. */
 
 __pdata enum ao_flight_state	ao_flight_state;	/* current flight state */
-__pdata uint16_t		ao_boost_tick;		/* time of launch detect */
+__pdata uint16_t		ao_boost_tick;		/* time of most recent boost detect */
+__pdata uint16_t		ao_launch_tick;		/* time of first boost detect */
 __pdata uint16_t		ao_motor_number;	/* number of motors burned so far */
 
 #if HAS_SENSOR_ERRORS
@@ -199,7 +200,7 @@ ao_flight(void)
 				)
 			{
 				ao_flight_state = ao_flight_boost;
-				ao_boost_tick = ao_sample_tick;
+				ao_launch_tick = ao_boost_tick = ao_sample_tick;
 
 				/* start logging data */
 				ao_log_start();
@@ -233,7 +234,7 @@ ao_flight(void)
 			 * deceleration, or by waiting until the maximum burn duration
 			 * (15 seconds) has past.
 			 */
-			if ((ao_accel < AO_MSS_TO_ACCEL(-2.5) && ao_height > AO_M_TO_HEIGHT(100)) ||
+			if ((ao_accel < AO_MSS_TO_ACCEL(-2.5)) ||
 			    (int16_t) (ao_sample_tick - ao_boost_tick) > BOOST_TICKS_MAX)
 			{
 #if HAS_ACCEL
@@ -269,7 +270,7 @@ ao_flight(void)
 			 * number of seconds.
 			 */
 			if (ao_config.apogee_lockout) {
-				if ((int16_t) (ao_sample_tick - ao_boost_tick) <
+				if ((int16_t) (ao_sample_tick - ao_launch_tick) <
 				    AO_SEC_TO_TICKS(ao_config.apogee_lockout))
 					break;
 			}
@@ -310,7 +311,7 @@ ao_flight(void)
 #if HAS_ACCEL
 			else {
 			check_re_boost:
-				ao_coast_avg_accel = ao_coast_avg_accel - (ao_coast_avg_accel >> 6) + (ao_accel >> 6);
+				ao_coast_avg_accel = ao_coast_avg_accel + ((ao_accel - ao_coast_avg_accel) >> 5);
 				if (ao_coast_avg_accel > AO_MSS_TO_ACCEL(20)) {
 					ao_boost_tick = ao_sample_tick;
 					ao_flight_state = ao_flight_boost;
diff --git a/src/kernel/ao_flight.h b/src/kernel/ao_flight.h
index 6894fe59..005c7e84 100644
--- a/src/kernel/ao_flight.h
+++ b/src/kernel/ao_flight.h
@@ -40,6 +40,7 @@ enum ao_flight_state {
 
 extern __pdata enum ao_flight_state	ao_flight_state;
 extern __pdata uint16_t			ao_boost_tick;
+extern __pdata uint16_t			ao_launch_tick;
 extern __pdata uint16_t			ao_motor_number;
 
 #if HAS_IMU || HAS_MMA655X
diff --git a/src/kernel/ao_kalman.c b/src/kernel/ao_kalman.c
index ac41085d..e4cc6d4b 100644
--- a/src/kernel/ao_kalman.c
+++ b/src/kernel/ao_kalman.c
@@ -45,7 +45,11 @@ static __pdata ao_k_t		ao_avg_height_scaled;
 __xdata ao_v_t			ao_avg_height;
 
 __pdata ao_v_t			ao_error_h;
-#if !HAS_ACCEL
+#if !HAS_ACCEL || AO_FLIGHT_TEST
+#define AO_ERROR_H_SQ_AVG	1
+#endif
+
+#if AO_ERROR_H_SQ_AVG
 __pdata ao_v_t			ao_error_h_sq_avg;
 #endif
 
@@ -85,7 +89,7 @@ ao_kalman_predict(void)
 static void
 ao_kalman_err_height(void)
 {
-#if !HAS_ACCEL
+#if AO_ERROR_H_SQ_AVG
 	ao_v_t	e;
 #endif
 	ao_v_t height_distrust;
@@ -95,7 +99,7 @@ ao_kalman_err_height(void)
 
 	ao_error_h = ao_sample_height - (ao_v_t) (ao_k_height >> 16);
 
-#if !HAS_ACCEL
+#if AO_ERROR_H_SQ_AVG
 	e = ao_error_h;
 	if (e < 0)
 		e = -e;
diff --git a/src/kernel/ao_product.c b/src/kernel/ao_product.c
index c4df9f26..4c2d83ef 100644
--- a/src/kernel/ao_product.c
+++ b/src/kernel/ao_product.c
@@ -55,7 +55,7 @@ const char ao_product[] = AO_iProduct_STRING;
 
 #define HEADER_LEN	       	9
 #define CONTROL_CLASS_LEN	35
-#define DATA_LEN		(9 + 7 * AO_USB_HAS_OUT + 7 * AO_USB_HAS_IN + 7 * AO_USB_HAS_IN2)
+#define DATA_LEN		(9 + 7 * AO_USB_HAS_OUT + 7 * AO_USB_HAS_IN + 7 * AO_USB_HAS_IN2 + 7 * AO_USB_HAS_IN3)
 
 #define TOTAL_LENGTH		(HEADER_LEN + AO_USB_HAS_INT * CONTROL_CLASS_LEN + DATA_LEN)
 #define NUM_INTERFACES		(AO_USB_HAS_INT + 1)
@@ -141,7 +141,7 @@ AO_ROMCONFIG_SYMBOL(0x00aa) uint8_t ao_usb_descriptors [] =
 	AO_USB_DESC_INTERFACE,
 	AO_USB_HAS_INT,			/* bInterfaceNumber */
 	0x00,				/* bAlternateSetting */
-	AO_USB_HAS_OUT + AO_USB_HAS_IN + AO_USB_HAS_IN2,	/* bNumEndPoints */
+	AO_USB_HAS_OUT + AO_USB_HAS_IN + AO_USB_HAS_IN2 + AO_USB_HAS_IN3,	/* bNumEndPoints */
 	AO_USB_INTERFACE_CLASS_DATA,	/* bInterfaceClass = data */
 	0x00,				/* bInterfaceSubClass */
 	0x00,				/* bInterfaceProtocol */
@@ -177,6 +177,16 @@ AO_ROMCONFIG_SYMBOL(0x00aa) uint8_t ao_usb_descriptors [] =
 	0x00,			/* bInterval */
 #endif
 
+#if AO_USB_HAS_IN3
+	/* Data EP in 3 */
+	0x07,
+	AO_USB_DESC_ENDPOINT,
+	AO_USB_IN3_EP|0x80,	/* bEndpointAddress */
+	0x02,			/* bmAttributes = bulk */
+	LE_WORD(AO_USB_IN_SIZE),/* wMaxPacketSize */
+	0x00,			/* bInterval */
+#endif
+
 	/* String descriptors */
 	0x04,
 	AO_USB_DESC_STRING,
diff --git a/src/kernel/ao_pyro.c b/src/kernel/ao_pyro.c
index e5c30eec..527112ac 100644
--- a/src/kernel/ao_pyro.c
+++ b/src/kernel/ao_pyro.c
@@ -81,6 +81,19 @@ int pyro_dbg;
 #define DBG(...)
 #endif
 
+static angle_t
+ao_sample_max_orient(void)
+{
+	uint8_t	i;
+	angle_t	max = ao_sample_orients[0];
+
+	for (i = 1; i < AO_NUM_ORIENT; i++) {
+		angle_t a = ao_sample_orients[i];
+		if (a > max)
+			max = a;
+	}
+	return max;
+}
 /*
  * Given a pyro structure, figure out
  * if the current flight state satisfies all
@@ -90,6 +103,9 @@ static uint8_t
 ao_pyro_ready(struct ao_pyro *pyro)
 {
 	enum ao_pyro_flag flag, flags;
+#if HAS_GYRO
+	angle_t max_orient;
+#endif
 
 	flags = pyro->flags;
 	while (flags != ao_pyro_none) {
@@ -130,26 +146,28 @@ ao_pyro_ready(struct ao_pyro *pyro)
 
 #if HAS_GYRO
 		case ao_pyro_orient_less:
-			if (ao_sample_orient <= pyro->orient_less)
+			max_orient = ao_sample_max_orient();
+			if (max_orient <= pyro->orient_less)
 				continue;
-			DBG("orient %d > %d\n", ao_sample_orient, pyro->orient_less);
+			DBG("orient %d > %d\n", max_orient, pyro->orient_less);
 			break;
 		case ao_pyro_orient_greater:
-			if (ao_sample_orient >= pyro->orient_greater)
+			max_orient = ao_sample_max_orient();
+			if (max_orient >= pyro->orient_greater)
 				continue;
-			DBG("orient %d < %d\n", ao_sample_orient, pyro->orient_greater);
+			DBG("orient %d < %d\n", max_orient, pyro->orient_greater);
 			break;
 #endif
 
 		case ao_pyro_time_less:
-			if ((int16_t) (ao_time() - ao_boost_tick) <= pyro->time_less)
+			if ((int16_t) (ao_time() - ao_launch_tick) <= pyro->time_less)
 				continue;
-			DBG("time %d > %d\n", (int16_t)(ao_time() - ao_boost_tick), pyro->time_less);
+			DBG("time %d > %d\n", (int16_t)(ao_time() - ao_launch_tick), pyro->time_less);
 			break;
 		case ao_pyro_time_greater:
-			if ((int16_t) (ao_time() - ao_boost_tick) >= pyro->time_greater)
+			if ((int16_t) (ao_time() - ao_launch_tick) >= pyro->time_greater)
 				continue;
-			DBG("time %d < %d\n", (int16_t)(ao_time() - ao_boost_tick), pyro->time_greater);
+			DBG("time %d < %d\n", (int16_t)(ao_time() - ao_launch_tick), pyro->time_greater);
 			break;
 
 		case ao_pyro_ascending:
@@ -164,7 +182,7 @@ ao_pyro_ready(struct ao_pyro *pyro)
 			break;
 
 		case ao_pyro_after_motor:
-			if (ao_motor_number == pyro->motor)
+			if (ao_motor_number >= pyro->motor)
 				continue;
 			DBG("motor %d != %d\n", ao_motor_number, pyro->motor);
 			break;
diff --git a/src/kernel/ao_sample.c b/src/kernel/ao_sample.c
index 61519478..f8012e34 100644
--- a/src/kernel/ao_sample.c
+++ b/src/kernel/ao_sample.c
@@ -50,6 +50,8 @@ __pdata gyro_t		ao_sample_roll;
 __pdata gyro_t		ao_sample_pitch;
 __pdata gyro_t		ao_sample_yaw;
 __pdata angle_t		ao_sample_orient;
+__pdata angle_t		ao_sample_orients[AO_NUM_ORIENT];
+__pdata uint8_t		ao_sample_orient_pos;
 #endif
 
 __data uint8_t		ao_sample_data;
@@ -115,6 +117,53 @@ ao_sample_preflight_add(void)
 	++nsamples;
 }
 
+#if HAS_GYRO
+static void
+ao_sample_set_all_orients(void)
+{
+	int i;
+	for (i = 0; i < AO_NUM_ORIENT; i++)
+		ao_sample_orients[i] = ao_sample_orient;
+	ao_sample_orient_pos = 0;
+}
+
+static void
+ao_sample_set_one_orient(void)
+{
+	ao_sample_orients[ao_sample_orient_pos] = ao_sample_orient;
+	ao_sample_orient_pos = (ao_sample_orient_pos + 1) % AO_NUM_ORIENT;
+}
+
+static void
+ao_sample_compute_orient(void)
+{
+	/* 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.
+	 *
+	 * rot = ao_rotation * vertical * ao_rotation°
+	 * rot = ao_rotation * (0,0,0,1) * ao_rotation°
+	 *     = ((a.z, a.y, -a.x, a.r) * (a.r, -a.x, -a.y, -a.z)) .z
+	 *
+	 *     = (-a.z * -a.z) + (a.y * -a.y) - (-a.x * -a.x) + (a.r * a.r)
+	 *     = a.z² - a.y² - a.x² + a.r²
+	 *
+	 * rot = ao_rotation * (0, 0, 0, -1) * ao_rotation°
+	 *     = ((-a.z, -a.y, a.x, -a.r) * (a.r, -a.x, -a.y, -a.z)) .z
+	 *
+	 *     = (a.z * -a.z) + (-a.y * -a.y) - (a.x * -a.x) + (-a.r * a.r)
+	 *     = -a.z² + a.y² + a.x² - a.r²
+	 */
+
+	float rotz;
+	rotz = ao_rotation.z * ao_rotation.z - ao_rotation.y * ao_rotation.y - ao_rotation.x * ao_rotation.x + ao_rotation.r * ao_rotation.r;
+
+	ao_sample_orient = acosf(rotz) * (float) (180.0/M_PI);
+}
+#endif /* HAS_GYRO */
+
 static void
 ao_sample_preflight_set(void)
 {
@@ -138,7 +187,7 @@ ao_sample_preflight_set(void)
 	ao_sample_pitch_sum = 0;
 	ao_sample_yaw_sum = 0;
 	ao_sample_roll_sum = 0;
-	ao_sample_orient = 0;
+	ao_sample_set_all_orients();
 
 	struct ao_quaternion	orient;
 
@@ -168,6 +217,9 @@ ao_sample_preflight_set(void)
 	if (ao_orient_test)
 		printf("\n\treset\n");
 #endif	
+
+	ao_sample_compute_orient();
+	ao_sample_set_all_orients();
 #endif
 	nsamples = 0;
 }
@@ -195,31 +247,6 @@ ao_sample_rotate(void)
 	/* 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.
-	 *
-	 * rot = ao_rotation * vertical * ao_rotation°
-	 * rot = ao_rotation * (0,0,0,1) * ao_rotation°
-	 *     = ((a.z, a.y, -a.x, a.r) * (a.r, -a.x, -a.y, -a.z)) .z
-	 *
-	 *     = (-a.z * -a.z) + (a.y * -a.y) - (-a.x * -a.x) + (a.r * a.r)
-	 *     = a.z² - a.y² - a.x² + a.r²
-	 *
-	 * rot = ao_rotation * (0, 0, 0, -1) * ao_rotation°
-	 *     = ((-a.z, -a.y, a.x, -a.r) * (a.r, -a.x, -a.y, -a.z)) .z
-	 *
-	 *     = (a.z * -a.z) + (-a.y * -a.y) - (a.x * -a.x) + (-a.r * a.r)
-	 *     = -a.z² + a.y² + a.x² - a.r²
-	 */
-
-	float rotz;
-	rotz = ao_rotation.z * ao_rotation.z - ao_rotation.y * ao_rotation.y - ao_rotation.x * ao_rotation.x + ao_rotation.r * ao_rotation.r;
-
-	ao_sample_orient = acosf(rotz) * (float) (180.0/M_PI);
-
 #if HAS_FLIGHT_DEBUG
 	if (ao_orient_test) {
 		printf ("rot %d %d %d orient %d     \r",
@@ -229,7 +256,8 @@ ao_sample_rotate(void)
 			ao_sample_orient);
 	}
 #endif
-
+	ao_sample_compute_orient();
+	ao_sample_set_one_orient();
 }
 #endif
 
@@ -367,6 +395,7 @@ ao_sample_init(void)
 	ao_sample_yaw = 0;
 	ao_sample_roll = 0;
 	ao_sample_orient = 0;
+	ao_sample_set_all_orients();
 #endif
 	ao_sample_data = ao_data_head;
 	ao_preflight = TRUE;
diff --git a/src/kernel/ao_sample.h b/src/kernel/ao_sample.h
index fbef031d..5ae389be 100644
--- a/src/kernel/ao_sample.h
+++ b/src/kernel/ao_sample.h
@@ -146,7 +146,10 @@ extern __pdata accel_t	ao_sample_accel_through;
 extern __pdata gyro_t	ao_sample_roll;
 extern __pdata gyro_t	ao_sample_pitch;
 extern __pdata gyro_t	ao_sample_yaw;
+#define AO_NUM_ORIENT	64
 extern __pdata angle_t	ao_sample_orient;
+extern __pdata angle_t	ao_sample_orients[AO_NUM_ORIENT];
+extern __pdata uint8_t	ao_sample_orient_pos;
 #endif
 
 void ao_sample_init(void);
diff --git a/src/kernel/ao_usb.h b/src/kernel/ao_usb.h
index 936d939b..40516de1 100644
--- a/src/kernel/ao_usb.h
+++ b/src/kernel/ao_usb.h
@@ -41,7 +41,23 @@ ao_usb_pollchar(void);
 void
 ao_usb_flush(void);
 
+#if AO_USB_HAS_IN2
+void
+ao_usb_flush2(void);
+
+void
+ao_usb_putchar2(char c);
+#endif
+
+#if AO_USB_HAS_IN3
+void
+ao_usb_flush3(void);
+
+void
+ao_usb_putchar3(char c);
+#endif
 /* Enable the USB controller */
+
 void
 ao_usb_enable(void);
 
@@ -107,6 +123,7 @@ extern __code __at (0x00aa) uint8_t ao_usb_descriptors [];
 #define AO_USB_OUT_EP		4
 #define AO_USB_IN_EP		5
 #define AO_USB_IN2_EP		6
+#define AO_USB_IN3_EP		7
 #endif
 
 #ifndef AO_USB_HAS_OUT
@@ -125,6 +142,10 @@ extern __code __at (0x00aa) uint8_t ao_usb_descriptors [];
 #define AO_USB_HAS_IN2	0
 #endif
 
+#ifndef AO_USB_HAS_IN3
+#define AO_USB_HAS_IN3	0
+#endif
+
 /*
  * USB bulk packets can only come in 8, 16, 32 and 64
  * byte sizes, so we'll use 64 for everything
diff --git a/src/mpusb-v3.0/.gitignore b/src/mpusb-v3.0/.gitignore
new file mode 100644
index 00000000..7c1cb599
--- /dev/null
+++ b/src/mpusb-v3.0/.gitignore
@@ -0,0 +1,2 @@
+ao_product.h
+mpusb-v3.0-*
diff --git a/src/mpusb-v3.0/Makefile b/src/mpusb-v3.0/Makefile
new file mode 100644
index 00000000..96156741
--- /dev/null
+++ b/src/mpusb-v3.0/Makefile
@@ -0,0 +1,68 @@
+#
+# AltOS build
+#
+#
+
+include ../stmf0/Makefile.defs
+
+INC = \
+	ao.h \
+	ao_arch.h \
+	ao_arch_funcs.h \
+	ao_boot.h \
+	ao_pins.h \
+	ao_product.h \
+	ao_task.h \
+	ao_whiten.h \
+	stm32f0.h \
+	Makefile
+
+ALTOS_SRC = \
+	ao_boot_chain.c \
+	ao_interrupt.c \
+	ao_product.c \
+	ao_romconfig.c \
+	ao_cmd.c \
+	ao_dma_stm.c \
+	ao_task.c \
+	ao_stdio.c \
+	ao_panic.c \
+	ao_timer.c \
+	ao_mutex.c \
+	ao_usb_stm.c \
+	ao_power.c \
+	ao_gpio.c \
+	ao_serial_stm.c
+
+PRODUCT=MicroPeakUSB-v3.0
+PRODUCT_DEF=-DMPUSB
+IDPRODUCT=0x002b
+
+CFLAGS = $(PRODUCT_DEF) $(STMF0_CFLAGS) -Os -g
+
+PROGNAME=mpusb-v3.0
+PROG=$(PROGNAME)-$(VERSION).elf
+HEX=$(PROGNAME)-$(VERSION).ihx
+
+SRC=$(ALTOS_SRC) ao_mpusb.c
+OBJ=$(SRC:.c=.o)
+
+all: $(PROG) $(HEX)
+
+$(PROG): Makefile $(OBJ) altos.ld
+	$(call quiet,CC) $(LDFLAGS) $(CFLAGS) -o $(PROG) $(OBJ) $(LIBS)
+
+ao_product.h: ao-make-product.5c ../Version
+	$(call quiet,NICKLE,$<) $< -m altusmetrum.org -i $(IDPRODUCT) -p $(PRODUCT) -v $(VERSION) > $@
+
+$(OBJ): $(INC)
+
+distclean:	clean
+
+clean:
+	rm -f *.o $(PROGNAME)-*.elf $(PROGNAME)-*.ihx
+	rm -f ao_product.h
+
+install:
+
+uninstall:
diff --git a/src/mpusb-v3.0/ao_mpusb.c b/src/mpusb-v3.0/ao_mpusb.c
new file mode 100644
index 00000000..dc30e197
--- /dev/null
+++ b/src/mpusb-v3.0/ao_mpusb.c
@@ -0,0 +1,61 @@
+/*
+ * Copyright © 2012 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.
+ */
+
+#include <ao.h>
+#include <ao_serial.h>
+
+static struct ao_task ao_report_task;
+
+static void
+ao_report(void)
+{
+	int	c;
+	ao_up_set_speed(AO_SERIAL_SPEED_9600);
+	for (;;) {
+		ao_arch_block_interrupts();
+		c = _ao_up_pollchar();
+		ao_arch_release_interrupts();
+		if (c == AO_READ_AGAIN) {
+			flush();
+			c = ao_up_getchar();
+		}
+		putchar(c);
+	}
+}
+
+int
+main(void)
+{
+	ao_clock_init();
+
+	ao_task_init();
+
+	ao_timer_init();
+
+	ao_serial_init();
+
+	ao_dma_init();
+
+	ao_cmd_init();
+
+	ao_usb_init();
+
+	ao_add_task(&ao_report_task, ao_report, "report");
+
+	ao_start_scheduler();
+	return 0;
+}
diff --git a/src/mpusb-v3.0/ao_pins.h b/src/mpusb-v3.0/ao_pins.h
new file mode 100644
index 00000000..3e79aad3
--- /dev/null
+++ b/src/mpusb-v3.0/ao_pins.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright © 2012 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.
+ */
+
+/* Using TeleMetrum v1.9 board */
+
+#ifndef _AO_PINS_H_
+#define _AO_PINS_H_
+
+#define HAS_TASK_QUEUE		1
+
+#define IS_FLASH_LOADER	0
+
+#define AO_POWER_MANAGEMENT	1
+
+/* 48MHz clock based on USB */
+#define AO_HSI48	1
+
+/* HCLK = 48MHz */
+#define AO_AHB_PRESCALER	1
+#define AO_RCC_CFGR_HPRE_DIV	STM_RCC_CFGR_HPRE_DIV_1
+
+/* APB = 48MHz */
+#define AO_APB_PRESCALER	1
+#define AO_RCC_CFGR_PPRE_DIV	STM_RCC_CFGR_PPRE_DIV_1
+
+#define HAS_EEPROM		0
+#define USE_INTERNAL_FLASH	0
+#define USE_STORAGE_CONFIG	0
+#define USE_EEPROM_CONFIG	0
+
+#define HAS_BEEP		0
+
+#define HAS_USB			1
+#define AO_USB_DIRECTIO		0
+#define AO_PA11_PA12_RMP	1
+
+#define HAS_SPI_0		0
+
+#define LOW_LEVEL_DEBUG		0
+
+#define HAS_SERIAL_2		1
+#define USE_SERIAL_2_STDIN	0
+#define SERIAL_2_PA2_PA3	1
+#define SERIAL_2_SWAP		0
+#define USE_SERIAL_2_FLOW	0
+#define USE_SERIAL_2_SW_FLOW	0
+
+#define ao_up_getchar		ao_serial2_getchar
+#define ao_up_putchar		ao_serial2_putchar
+#define _ao_up_pollchar		_ao_serial2_pollchar
+#define ao_up_set_speed		ao_serial2_set_speed
+
+#endif /* _AO_PINS_H_ */
diff --git a/src/mpusb-v3.0/flash-loader/.gitignore b/src/mpusb-v3.0/flash-loader/.gitignore
new file mode 100644
index 00000000..1f8b3545
--- /dev/null
+++ b/src/mpusb-v3.0/flash-loader/.gitignore
@@ -0,0 +1,2 @@
+ao_product.h
+mpusb*
diff --git a/src/mpusb-v3.0/flash-loader/Makefile b/src/mpusb-v3.0/flash-loader/Makefile
new file mode 100644
index 00000000..8d0f9e42
--- /dev/null
+++ b/src/mpusb-v3.0/flash-loader/Makefile
@@ -0,0 +1,7 @@
+#
+# AltOS flash loader build
+#
+
+TOPDIR=../..
+HARDWARE=mpusb-v3.0
+include $(TOPDIR)/stmf0/Makefile-flash.defs
diff --git a/src/mpusb-v3.0/flash-loader/ao_pins.h b/src/mpusb-v3.0/flash-loader/ao_pins.h
new file mode 100644
index 00000000..7feb9362
--- /dev/null
+++ b/src/mpusb-v3.0/flash-loader/ao_pins.h
@@ -0,0 +1,34 @@
+/*
+ * 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_PINS_H_
+#define _AO_PINS_H_
+
+#include <ao_flash_stm_pins.h>
+
+/* Debug port PA15 (pin 23) */
+
+#define AO_BOOT_PIN			1
+#define AO_BOOT_APPLICATION_GPIO	(stm_gpioa)
+#define AO_BOOT_APPLICATION_PIN		15
+#define AO_BOOT_APPLICATION_VALUE	1
+#define AO_BOOT_APPLICATION_MODE	AO_EXTI_MODE_PULL_UP
+
+#define AO_USB_DIRECTIO		0
+#define AO_PA11_PA12_RMP	1
+
+#endif /* _AO_PINS_H_ */
diff --git a/src/product/ao_flash_pins.h b/src/product/ao_flash_pins.h
index ff8d3273..019b5425 100644
--- a/src/product/ao_flash_pins.h
+++ b/src/product/ao_flash_pins.h
@@ -25,6 +25,7 @@
 
 #define HAS_USB			1
 #define USE_USB_STDIO		0
+#define HAS_USB_DISABLE		0
 #define HAS_BEEP		0
 #define HAS_TASK		0
 #define HAS_ECHO		0
diff --git a/src/stm-demo/Makefile b/src/stm-demo/Makefile
index 869fb32f..d4569c1a 100644
--- a/src/stm-demo/Makefile
+++ b/src/stm-demo/Makefile
@@ -30,6 +30,8 @@ ALTOS_SRC = \
 	ao_lcd_stm.c \
 	ao_lcd_font.c \
 	ao_mutex.c \
+	ao_storage.c \
+	ao_m25.c \
 	ao_dma_stm.c \
 	ao_spi_stm.c \
 	ao_adc_stm.c \
diff --git a/src/stm-demo/ao_demo.c b/src/stm-demo/ao_demo.c
index db432c2a..f6c8e3df 100644
--- a/src/stm-demo/ao_demo.c
+++ b/src/stm-demo/ao_demo.c
@@ -223,11 +223,12 @@ main(void)
 	ao_cmd_init();
 //	ao_lcd_stm_init();
 //	ao_lcd_font_init();
-//	ao_spi_init();
+	ao_spi_init();
 //	ao_i2c_init();
 //	ao_exti_init();
 //	ao_quadrature_init();
 //	ao_button_init();
+	ao_storage_init();
 
 //	ao_timer_set_adc_interval(100);
 
diff --git a/src/stm-demo/ao_pins.h b/src/stm-demo/ao_pins.h
index 233537df..2b4c5ab0 100644
--- a/src/stm-demo/ao_pins.h
+++ b/src/stm-demo/ao_pins.h
@@ -59,11 +59,14 @@
 #define SERIAL_3_PC10_PC11	0
 #define SERIAL_3_PD8_PD9	1
 
-#define HAS_SPI_1		1
+#define HAS_SPI_1		0
 #define SPI_1_PB3_PB4_PB5	1
 #define SPI_1_OSPEEDR		STM_OSPEEDR_10MHz
 
-#define HAS_SPI_2		0
+#define HAS_SPI_2		1
+#define SPI_2_PB13_PB14_PB15	1	/* Flash, Companion, Radio */
+#define SPI_2_PD1_PD3_PD4	0
+#define SPI_2_OSPEEDR		STM_OSPEEDR_10MHz
 
 #define HAS_USB			1
 #define HAS_BEEP		0
@@ -200,4 +203,11 @@ struct ao_adc {
 #define AO_TICK_TYPE		uint32_t
 #define AO_TICK_SIGNED		int32_t
 
+#define M25_MAX_CHIPS		1
+#define AO_M25_SPI_CS_PORT	(&stm_gpiob)
+#define AO_M25_SPI_CS_MASK	(1 << 12)
+#define AO_M25_SPI_BUS		AO_SPI_2_PB13_PB14_PB15
+
+#define AO_LOG_FORMAT				AO_LOG_FORMAT_TELEMEGA
+
 #endif /* _AO_PINS_H_ */
diff --git a/src/stm/ao_adc_single.h b/src/stm/ao_adc_single.h
new file mode 100644
index 00000000..f9d953ca
--- /dev/null
+++ b/src/stm/ao_adc_single.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright © 2018 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, either version 2 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.
+ */
+
+#ifndef _AO_ADC_SINGLE_H_
+#define _AO_ADC_SINGLE_H_
+
+void
+ao_adc_single_get(struct ao_adc *packet);
+
+void
+ao_adc_single_init(void);
+
+#endif /* _AO_ADC_SINGLE_H_ */
diff --git a/src/stm/ao_adc_single_stm.c b/src/stm/ao_adc_single_stm.c
new file mode 100644
index 00000000..8a7fda4a
--- /dev/null
+++ b/src/stm/ao_adc_single_stm.c
@@ -0,0 +1,297 @@
+/*
+ * Copyright © 2012 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; either version 2 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, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+#include <ao.h>
+#include <ao_data.h>
+
+static uint8_t			ao_adc_ready;
+
+#define AO_ADC_CR2_VAL		((0 << STM_ADC_CR2_SWSTART) |		\
+				 (STM_ADC_CR2_EXTEN_DISABLE << STM_ADC_CR2_EXTEN) | \
+				 (0 << STM_ADC_CR2_EXTSEL) |		\
+				 (0 << STM_ADC_CR2_JWSTART) |		\
+				 (STM_ADC_CR2_JEXTEN_DISABLE << STM_ADC_CR2_JEXTEN) | \
+				 (0 << STM_ADC_CR2_JEXTSEL) |		\
+				 (0 << STM_ADC_CR2_ALIGN) |		\
+				 (0 << STM_ADC_CR2_EOCS) |		\
+				 (1 << STM_ADC_CR2_DDS) |		\
+				 (1 << STM_ADC_CR2_DMA) |		\
+				 (STM_ADC_CR2_DELS_UNTIL_READ << STM_ADC_CR2_DELS) | \
+				 (0 << STM_ADC_CR2_CONT) |		\
+				 (1 << STM_ADC_CR2_ADON))
+
+/*
+ * Callback from DMA ISR
+ *
+ * Shut down DMA engine, signal anyone waiting
+ */
+static void ao_adc_done(int index)
+{
+	(void) index;
+	ao_dma_done_transfer(STM_DMA_INDEX(STM_DMA_CHANNEL_ADC1));
+	ao_adc_ready = 1;
+	ao_wakeup((void *) &ao_adc_ready);
+}
+
+/*
+ * Start the ADC sequence using the DMA engine
+ */
+static void
+ao_adc_poll(struct ao_adc *packet)
+{
+	ao_adc_ready = 0;
+	stm_adc.sr = 0;
+	ao_dma_set_transfer(STM_DMA_INDEX(STM_DMA_CHANNEL_ADC1),
+			    &stm_adc.dr,
+			    (void *) packet,
+			    AO_NUM_ADC,
+			    (0 << STM_DMA_CCR_MEM2MEM) |
+			    (STM_DMA_CCR_PL_HIGH << STM_DMA_CCR_PL) |
+			    (STM_DMA_CCR_MSIZE_16 << STM_DMA_CCR_MSIZE) |
+			    (STM_DMA_CCR_PSIZE_16 << STM_DMA_CCR_PSIZE) |
+			    (1 << STM_DMA_CCR_MINC) |
+			    (0 << STM_DMA_CCR_PINC) |
+			    (0 << STM_DMA_CCR_CIRC) |
+			    (STM_DMA_CCR_DIR_PER_TO_MEM << STM_DMA_CCR_DIR));
+	ao_dma_set_isr(STM_DMA_INDEX(STM_DMA_CHANNEL_ADC1), ao_adc_done);
+	ao_dma_start(STM_DMA_INDEX(STM_DMA_CHANNEL_ADC1));
+
+	stm_adc.cr2 = AO_ADC_CR2_VAL | (1 << STM_ADC_CR2_SWSTART);
+}
+
+/*
+ * Fetch a copy of the most recent ADC data
+ */
+void
+ao_adc_single_get(struct ao_adc *packet)
+{
+	ao_adc_poll(packet);
+	ao_arch_block_interrupts();
+	while (!ao_adc_ready)
+		ao_sleep(&ao_adc_ready);
+	ao_arch_release_interrupts();
+}
+
+static void
+ao_adc_dump(void)
+{
+	struct ao_adc	packet;
+	ao_adc_single_get(&packet);
+	AO_ADC_DUMP(&packet);
+}
+
+__code struct ao_cmds ao_adc_cmds[] = {
+	{ ao_adc_dump,	"a\0Display current ADC values" },
+	{ 0, NULL },
+};
+
+void
+ao_adc_single_init(void)
+{
+#ifdef AO_ADC_PIN0_PORT
+	stm_rcc.ahbenr |= AO_ADC_RCC_AHBENR;
+#endif
+
+#ifdef AO_ADC_PIN0_PORT
+	stm_moder_set(AO_ADC_PIN0_PORT, AO_ADC_PIN0_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN1_PORT
+	stm_moder_set(AO_ADC_PIN1_PORT, AO_ADC_PIN1_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN2_PORT
+	stm_moder_set(AO_ADC_PIN2_PORT, AO_ADC_PIN2_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN3_PORT
+	stm_moder_set(AO_ADC_PIN3_PORT, AO_ADC_PIN3_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN4_PORT
+	stm_moder_set(AO_ADC_PIN4_PORT, AO_ADC_PIN4_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN5_PORT
+	stm_moder_set(AO_ADC_PIN5_PORT, AO_ADC_PIN5_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN6_PORT
+	stm_moder_set(AO_ADC_PIN6_PORT, AO_ADC_PIN6_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN7_PORT
+	stm_moder_set(AO_ADC_PIN7_PORT, AO_ADC_PIN7_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN8_PORT
+	stm_moder_set(AO_ADC_PIN8_PORT, AO_ADC_PIN8_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN9_PORT
+	stm_moder_set(AO_ADC_PIN9_PORT, AO_ADC_PIN9_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN10_PORT
+	stm_moder_set(AO_ADC_PIN10_PORT, AO_ADC_PIN10_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN11_PORT
+	stm_moder_set(AO_ADC_PIN11_PORT, AO_ADC_PIN11_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN12_PORT
+	stm_moder_set(AO_ADC_PIN12_PORT, AO_ADC_PIN12_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN13_PORT
+	stm_moder_set(AO_ADC_PIN13_PORT, AO_ADC_PIN13_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN14_PORT
+	stm_moder_set(AO_ADC_PIN14_PORT, AO_ADC_PIN14_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN15_PORT
+	stm_moder_set(AO_ADC_PIN15_PORT, AO_ADC_PIN15_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN16_PORT
+	stm_moder_set(AO_ADC_PIN16_PORT, AO_ADC_PIN16_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN17_PORT
+	stm_moder_set(AO_ADC_PIN17_PORT, AO_ADC_PIN17_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN18_PORT
+	stm_moder_set(AO_ADC_PIN18_PORT, AO_ADC_PIN18_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN19_PORT
+	stm_moder_set(AO_ADC_PIN19_PORT, AO_ADC_PIN19_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN20_PORT
+	stm_moder_set(AO_ADC_PIN20_PORT, AO_ADC_PIN20_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN21_PORT
+	stm_moder_set(AO_ADC_PIN21_PORT, AO_ADC_PIN21_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN22_PORT
+	stm_moder_set(AO_ADC_PIN22_PORT, AO_ADC_PIN22_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN23_PORT
+	stm_moder_set(AO_ADC_PIN23_PORT, AO_ADC_PIN23_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN24_PORT
+	#error "Too many ADC ports"
+#endif
+
+	stm_rcc.apb2enr |= (1 << STM_RCC_APB2ENR_ADC1EN);
+
+	/* Turn off ADC during configuration */
+	stm_adc.cr2 = 0;
+
+	stm_adc.cr1 = ((0 << STM_ADC_CR1_OVRIE ) |
+		       (STM_ADC_CR1_RES_12 << STM_ADC_CR1_RES ) |
+		       (0 << STM_ADC_CR1_AWDEN ) |
+		       (0 << STM_ADC_CR1_JAWDEN ) |
+		       (0 << STM_ADC_CR1_PDI ) |
+		       (0 << STM_ADC_CR1_PDD ) |
+		       (0 << STM_ADC_CR1_DISCNUM ) |
+		       (0 << STM_ADC_CR1_JDISCEN ) |
+		       (0 << STM_ADC_CR1_DISCEN ) |
+		       (0 << STM_ADC_CR1_JAUTO ) |
+		       (0 << STM_ADC_CR1_AWDSGL ) |
+		       (1 << STM_ADC_CR1_SCAN ) |
+		       (0 << STM_ADC_CR1_JEOCIE ) |
+		       (0 << STM_ADC_CR1_AWDIE ) |
+		       (0 << STM_ADC_CR1_EOCIE ) |
+		       (0 << STM_ADC_CR1_AWDCH ));
+
+	/* 384 cycle sample time for everyone */
+	stm_adc.smpr1 = 0x3ffff;
+	stm_adc.smpr2 = 0x3fffffff;
+	stm_adc.smpr3 = 0x3fffffff;
+
+	stm_adc.sqr1 = ((AO_NUM_ADC - 1) << 20);
+	stm_adc.sqr2 = 0;
+	stm_adc.sqr3 = 0;
+	stm_adc.sqr4 = 0;
+	stm_adc.sqr5 = 0;
+#if AO_NUM_ADC > 0
+	stm_adc.sqr5 |= (AO_ADC_SQ1 << 0);
+#endif
+#if AO_NUM_ADC > 1
+	stm_adc.sqr5 |= (AO_ADC_SQ2 << 5);
+#endif
+#if AO_NUM_ADC > 2
+	stm_adc.sqr5 |= (AO_ADC_SQ3 << 10);
+#endif
+#if AO_NUM_ADC > 3
+	stm_adc.sqr5 |= (AO_ADC_SQ4 << 15);
+#endif
+#if AO_NUM_ADC > 4
+	stm_adc.sqr5 |= (AO_ADC_SQ5 << 20);
+#endif
+#if AO_NUM_ADC > 5
+	stm_adc.sqr5 |= (AO_ADC_SQ6 << 25);
+#endif
+#if AO_NUM_ADC > 6
+	stm_adc.sqr4 |= (AO_ADC_SQ7 << 0);
+#endif
+#if AO_NUM_ADC > 7
+	stm_adc.sqr4 |= (AO_ADC_SQ8 << 5);
+#endif
+#if AO_NUM_ADC > 8
+	stm_adc.sqr4 |= (AO_ADC_SQ9 << 10);
+#endif
+#if AO_NUM_ADC > 9
+	stm_adc.sqr4 |= (AO_ADC_SQ10 << 15);
+#endif
+#if AO_NUM_ADC > 10
+	stm_adc.sqr4 |= (AO_ADC_SQ11 << 20);
+#endif
+#if AO_NUM_ADC > 11
+	stm_adc.sqr4 |= (AO_ADC_SQ12 << 25);
+#endif
+#if AO_NUM_ADC > 12
+	stm_adc.sqr3 |= (AO_ADC_SQ13 << 0);
+#endif
+#if AO_NUM_ADC > 13
+	stm_adc.sqr3 |= (AO_ADC_SQ14 << 5);
+#endif
+#if AO_NUM_ADC > 14
+	stm_adc.sqr3 |= (AO_ADC_SQ15 << 10);
+#endif
+#if AO_NUM_ADC > 15
+	stm_adc.sqr3 |= (AO_ADC_SQ16 << 15);
+#endif
+#if AO_NUM_ADC > 16
+	stm_adc.sqr3 |= (AO_ADC_SQ17 << 20);
+#endif
+#if AO_NUM_ADC > 17
+	stm_adc.sqr3 |= (AO_ADC_SQ18 << 25);
+#endif
+#if AO_NUM_ADC > 18
+#error "need to finish stm_adc.sqr settings"
+#endif
+
+	/* Turn ADC on */
+	stm_adc.cr2 = AO_ADC_CR2_VAL;
+
+	/* Wait for ADC to be ready */
+	while (!(stm_adc.sr & (1 << STM_ADC_SR_ADONS)))
+		;
+
+#ifndef HAS_ADC_TEMP
+#error Please define HAS_ADC_TEMP
+#endif
+#if HAS_ADC_TEMP
+	stm_adc.ccr = ((1 << STM_ADC_CCR_TSVREFE));
+#else
+	stm_adc.ccr = 0;
+#endif
+	/* Clear any stale status bits */
+	stm_adc.sr = 0;
+
+	ao_dma_alloc(STM_DMA_INDEX(STM_DMA_CHANNEL_ADC1));
+
+	ao_cmd_register(&ao_adc_cmds[0]);
+}
diff --git a/src/stm/ao_arch.h b/src/stm/ao_arch.h
index 5f033b66..679dba44 100644
--- a/src/stm/ao_arch.h
+++ b/src/stm/ao_arch.h
@@ -30,8 +30,6 @@
 #define AO_STACK_SIZE	512
 #endif
 
-#define AO_LED_TYPE	uint16_t
-
 #ifndef AO_TICK_TYPE
 #define AO_TICK_TYPE	uint16_t
 #define AO_TICK_SIGNED	int16_t
@@ -153,6 +151,10 @@ ao_adc_init();
 #define AO_BOOT_LOADER_BASE		((uint32_t *) 0x08000000)
 #define HAS_BOOT_LOADER			1
 
+#ifndef AO_LED_TYPE
+#define AO_LED_TYPE uint16_t
+#endif
+
 #endif /* _AO_ARCH_H_ */
 
 
diff --git a/src/stm/ao_led.c b/src/stm/ao_led.c
index 0f39befb..a7033dbb 100644
--- a/src/stm/ao_led.c
+++ b/src/stm/ao_led.c
@@ -18,11 +18,73 @@
 
 #include "ao.h"
 
-__pdata uint16_t ao_led_enable;
+#if LED_PER_LED
+static const struct {
+	struct stm_gpio	*port;
+	uint16_t	pin;
+} ao_leds[] = {
+#ifdef LED_0_PORT
+    [0] { LED_0_PORT, LED_0_PIN },
+#endif
+#ifdef LED_1_PORT
+    [1] { LED_1_PORT, LED_1_PIN },
+#endif
+#ifdef LED_2_PORT
+    [2] { LED_2_PORT, LED_2_PIN },
+#endif
+#ifdef LED_3_PORT
+    [3] { LED_3_PORT, LED_3_PIN },
+#endif
+#ifdef LED_4_PORT
+    [4] { LED_4_PORT, LED_4_PIN },
+#endif
+#ifdef LED_5_PORT
+    [5] { LED_5_PORT, LED_5_PIN },
+#endif
+#ifdef LED_6_PORT
+    [6] { LED_6_PORT, LED_6_PIN },
+#endif
+#ifdef LED_7_PORT
+    [7] { LED_7_PORT, LED_7_PIN },
+#endif
+#ifdef LED_8_PORT
+    [8] { LED_8_PORT, LED_8_PIN },
+#endif
+#ifdef LED_9_PORT
+    [9] { LED_9_PORT, LED_9_PIN },
+#endif
+#ifdef LED_10_PORT
+    [10] { LED_10_PORT, LED_10_PIN },
+#endif
+#ifdef LED_11_PORT
+    [11] { LED_11_PORT, LED_11_PIN },
+#endif
+#ifdef LED_12_PORT
+    [12] { LED_12_PORT, LED_12_PIN },
+#endif
+#ifdef LED_13_PORT
+    [13] { LED_13_PORT, LED_13_PIN },
+#endif
+#ifdef LED_14_PORT
+    [14] { LED_14_PORT, LED_14_PIN },
+#endif
+#ifdef LED_15_PORT
+    [15] { LED_15_PORT, LED_15_PIN },
+#endif
+};
+#define N_LED	(sizeof (ao_leds)/sizeof(ao_leds[0]))
+#endif
+static AO_LED_TYPE ao_led_enable;
 
 void
-ao_led_on(uint16_t colors)
+ao_led_on(AO_LED_TYPE colors)
 {
+#ifdef LED_PER_LED
+	AO_LED_TYPE i;
+	for (i = 0; i < N_LED; i++)
+		if (colors & (1 << i))
+			ao_gpio_set(ao_leds[i].port, ao_leds[i].pin, foo, 1);
+#else
 #ifdef LED_PORT
 	LED_PORT->bsrr = (colors & ao_led_enable);
 #else
@@ -33,11 +95,18 @@ ao_led_on(uint16_t colors)
 	LED_PORT_1->bsrr = ((colors & ao_led_enable) & LED_PORT_1_MASK) << LED_PORT_1_SHIFT;
 #endif
 #endif
+#endif
 }
 
 void
-ao_led_off(uint16_t colors)
+ao_led_off(AO_LED_TYPE colors)
 {
+#ifdef LED_PER_LED
+	AO_LED_TYPE i;
+	for (i = 0; i < N_LED; i++)
+		if (colors & (1 << i))
+			ao_gpio_set(ao_leds[i].port, ao_leds[i].pin, foo, 0);
+#else
 #ifdef LED_PORT
 	LED_PORT->bsrr = (uint32_t) (colors & ao_led_enable) << 16;
 #else
@@ -48,21 +117,28 @@ ao_led_off(uint16_t colors)
 	LED_PORT_1->bsrr = ((uint32_t) (colors & ao_led_enable) & LED_PORT_1_MASK) << (LED_PORT_1_SHIFT + 16);
 #endif
 #endif
+#endif
 }
 
 void
-ao_led_set(uint16_t colors)
+ao_led_set(AO_LED_TYPE colors)
 {
-	uint16_t	on = colors & ao_led_enable;
-	uint16_t	off = ~colors & ao_led_enable;
+	AO_LED_TYPE	on = colors & ao_led_enable;
+	AO_LED_TYPE	off = ~colors & ao_led_enable;
 
 	ao_led_off(off);
 	ao_led_on(on);
 }
 
 void
-ao_led_toggle(uint16_t colors)
+ao_led_toggle(AO_LED_TYPE colors)
 {
+#ifdef LED_PER_LED
+	AO_LED_TYPE i;
+	for (i = 0; i < N_LED; i++)
+		if (colors & (1 << i))
+			ao_gpio_set(ao_leds[i].port, ao_leds[i].pin, foo, ~ao_gpio_get(ao_leds[i].port, ao_leds[i].pin, foo));
+#else
 #ifdef LED_PORT
 	LED_PORT->odr ^= (colors & ao_led_enable);
 #else
@@ -73,10 +149,11 @@ ao_led_toggle(uint16_t colors)
 	LED_PORT_1->odr ^= ((colors & ao_led_enable) & LED_PORT_1_MASK) << LED_PORT_1_SHIFT;
 #endif
 #endif
+#endif
 }
 
 void
-ao_led_for(uint16_t colors, uint16_t ticks) __reentrant
+ao_led_for(AO_LED_TYPE colors, AO_LED_TYPE ticks) __reentrant
 {
 	ao_led_on(colors);
 	ao_delay(ticks);
@@ -89,11 +166,15 @@ ao_led_for(uint16_t colors, uint16_t ticks) __reentrant
 	} while (0)
 
 void
-ao_led_init(uint16_t enable)
+ao_led_init(AO_LED_TYPE enable)
 {
-	int	bit;
+	AO_LED_TYPE	bit;
 
 	ao_led_enable = enable;
+#if LED_PER_LED
+	for (bit = 0; bit < N_LED; bit++)
+		ao_enable_output(ao_leds[bit].port, ao_leds[bit].pin, foo, 0);
+#else
 #ifdef LED_PORT
 	stm_rcc.ahbenr |= (1 << LED_PORT_ENABLE);
 	LED_PORT->odr &= ~enable;
@@ -106,6 +187,10 @@ ao_led_init(uint16_t enable)
 	stm_rcc.ahbenr |= (1 << LED_PORT_1_ENABLE);
 	LED_PORT_1->odr &= ~((enable & ao_led_enable) & LED_PORT_1_MASK) << LED_PORT_1_SHIFT;
 #endif
+#ifdef LED_PORT_2
+	stm_rcc.ahbenr |= (1 << LED_PORT_1_ENABLE);
+	LED_PORT_1->odr &= ~((enable & ao_led_enable) & LED_PORT_1_MASK) << LED_PORT_1_SHIFT;
+#endif
 #endif
 	for (bit = 0; bit < 16; bit++) {
 		if (enable & (1 << bit)) {
@@ -120,7 +205,12 @@ ao_led_init(uint16_t enable)
 			if (LED_PORT_1_MASK & (1 << bit))
 				init_led_pin(LED_PORT_1, bit + LED_PORT_1_SHIFT);
 #endif
+#ifdef LED_PORT_2
+			if (LED_PORT_2_MASK & (1 << bit))
+				init_led_pin(LED_PORT_2, bit + LED_PORT_2_SHIFT);
+#endif
 #endif
 		}
 	}
+#endif
 }
diff --git a/src/stm/ao_romconfig.c b/src/stm/ao_romconfig.c
index 9d5fd6fb..63a48bec 100644
--- a/src/stm/ao_romconfig.c
+++ b/src/stm/ao_romconfig.c
@@ -24,5 +24,6 @@ AO_ROMCONFIG_SYMBOL (0) uint16_t ao_serial_number = 0;
 #ifndef AO_RADIO_CAL_DEFAULT
 #define AO_RADIO_CAL_DEFAULT 0x01020304
 #endif
+#if HAS_RADIO
 AO_ROMCONFIG_SYMBOL (0) uint32_t ao_radio_cal = AO_RADIO_CAL_DEFAULT;
-
+#endif
diff --git a/src/stm/ao_timer.c b/src/stm/ao_timer.c
index 1576a6c9..7b526902 100644
--- a/src/stm/ao_timer.c
+++ b/src/stm/ao_timer.c
@@ -149,7 +149,7 @@ ao_clock_init(void)
 #define STM_RCC_CFGR_PLLSRC_TARGET_CLOCK	(0 << STM_RCC_CFGR_PLLSRC)
 #endif
 
-#if !AO_HSE || HAS_ADC
+#if !AO_HSE || HAS_ADC || HAS_ADC_SINGLE
 	/* Enable HSI RC clock 16MHz */
 	stm_rcc.cr |= (1 << STM_RCC_CR_HSION);
 	while (!(stm_rcc.cr & (1 << STM_RCC_CR_HSIRDY)))
diff --git a/src/stm/ao_usb_stm.c b/src/stm/ao_usb_stm.c
index 595bddac..b06814d2 100644
--- a/src/stm/ao_usb_stm.c
+++ b/src/stm/ao_usb_stm.c
@@ -446,15 +446,11 @@ ao_usb_write_short(uint16_t data, uint32_t *base, uint16_t offset)
 }
 
 static void
-ao_usb_write(const uint8_t *src, uint32_t *base, uint16_t offset, uint16_t bytes)
+ao_usb_write(const uint8_t *src, uint32_t *base, uint16_t bytes)
 {
+	uint16_t offset = 0;
 	if (!bytes)
 		return;
-	if (offset & 1) {
-		debug_data (" %02x", src[0]);
-		ao_usb_write_byte(*src++, base, offset++);
-		bytes--;
-	}
 	while (bytes >= 2) {
 		debug_data (" %02x %02x", src[0], src[1]);
 		ao_usb_write_short((src[1] << 8) | src[0], base, offset);
@@ -531,7 +527,7 @@ ao_usb_ep0_flush(void)
 	ao_usb_ep0_in_len -= this_len;
 
 	debug_data ("Flush EP0 len %d:", this_len);
-	ao_usb_write(ao_usb_ep0_in_data, ao_usb_ep0_tx_buffer, 0, this_len);
+	ao_usb_write(ao_usb_ep0_in_data, ao_usb_ep0_tx_buffer, this_len);
 	debug_data ("\n");
 	ao_usb_ep0_in_data += this_len;
 
@@ -850,7 +846,7 @@ _ao_usb_in_send(void)
 	ao_usb_in_pending = 1;
 	if (ao_usb_tx_count != AO_USB_IN_SIZE)
 		ao_usb_in_flushed = 1;
-	ao_usb_write(ao_usb_tx_buffer, ao_usb_in_tx_buffer, 0, ao_usb_tx_count);
+	ao_usb_write(ao_usb_tx_buffer, ao_usb_in_tx_buffer, ao_usb_tx_count);
 	ao_usb_bdt[AO_USB_IN_EPR].single.count_tx = ao_usb_tx_count;
 	ao_usb_tx_count = 0;
 	_ao_usb_set_stat_tx(AO_USB_IN_EPR, STM_USB_EPR_STAT_TX_VALID);
@@ -974,6 +970,11 @@ ao_usb_getchar(void)
 	return c;
 }
 
+#ifndef HAS_USB_DISABLE
+#define HAS_USB_DISABLE 1
+#endif
+
+#if HAS_USB_DISABLE
 void
 ao_usb_disable(void)
 {
@@ -991,6 +992,7 @@ ao_usb_disable(void)
 	stm_rcc.apb1enr &= ~(1 << STM_RCC_APB1ENR_USBEN);
 	ao_arch_release_interrupts();
 }
+#endif
 
 void
 ao_usb_enable(void)
diff --git a/src/stm/stm32l.h b/src/stm/stm32l.h
index 201f4f36..1da817e7 100644
--- a/src/stm/stm32l.h
+++ b/src/stm/stm32l.h
@@ -1454,6 +1454,9 @@ struct stm_adc {
 
 extern struct stm_adc stm_adc;
 
+#define STM_ADC_SQ_TEMP		16
+#define STM_ADC_SQ_V_REF	17
+
 #define STM_ADC_SR_JCNR		9
 #define STM_ADC_SR_RCNR		8
 #define STM_ADC_SR_ADONS	6
diff --git a/src/stmf0/ao_arch_funcs.h b/src/stmf0/ao_arch_funcs.h
index 56a3bc75..96c033f9 100644
--- a/src/stmf0/ao_arch_funcs.h
+++ b/src/stmf0/ao_arch_funcs.h
@@ -171,10 +171,12 @@ ao_spi_try_get_mask(struct stm_gpio *reg, uint16_t mask, uint8_t bus, uint32_t s
 #define ao_spi_get_bit(reg,bit,pin,bus,speed) ao_spi_get_mask(reg,(1<<bit),bus,speed)
 #define ao_spi_put_bit(reg,bit,pin,bus) ao_spi_put_mask(reg,(1<<bit),bus)
 
+#if AO_POWER_MANAGEMENT
 extern struct ao_power	ao_power_gpioa;
 extern struct ao_power	ao_power_gpiob;
 extern struct ao_power	ao_power_gpioc;
 extern struct ao_power	ao_power_gpiof;
+#endif
 
 static inline void ao_enable_port(struct stm_gpio *port)
 {
diff --git a/src/stmf0/ao_flash_loader_stm.c b/src/stmf0/ao_flash_loader_stm.c
index a8d1701b..18bf272c 100644
--- a/src/stmf0/ao_flash_loader_stm.c
+++ b/src/stmf0/ao_flash_loader_stm.c
@@ -34,7 +34,7 @@ main(void)
 
 #ifdef AO_FLASH_LOADER_INIT
 	AO_FLASH_LOADER_INIT;
-#endif	
+#endif
 	ao_flash_task();
 	return 0;
 }
diff --git a/src/stmf0/ao_interrupt.c b/src/stmf0/ao_interrupt.c
index fcd330f1..a67f6f1a 100644
--- a/src/stmf0/ao_interrupt.c
+++ b/src/stmf0/ao_interrupt.c
@@ -69,20 +69,24 @@ stm_flash_size(void) {
 
 void start(void)
 {
-#ifdef AO_BOOT_CHAIN
+#if AO_BOOT_CHAIN
 	if (ao_boot_check_chain()) {
-#ifdef AO_BOOT_PIN
+#if AO_BOOT_PIN
 		ao_boot_check_pin();
 #endif
 	}
 #endif
-#if RELOCATE_INTERRUPT
 	/* Turn on syscfg */
 	stm_rcc.apb2enr |= (1 << STM_RCC_APB2ENR_SYSCFGCOMPEN);
 
+#if RELOCATE_INTERRUPT
 	memcpy(&__interrupt_start__, &__interrupt_rom__, &__interrupt_end__ - &__interrupt_start__);
 	stm_syscfg.cfgr1 = (stm_syscfg.cfgr1 & ~(STM_SYSCFG_CFGR1_MEM_MODE_MASK << STM_SYSCFG_CFGR1_MEM_MODE)) |
 		(STM_SYSCFG_CFGR1_MEM_MODE_SRAM << STM_SYSCFG_CFGR1_MEM_MODE);
+#else
+	/* Switch to Main Flash mode (DFU loader leaves us in System mode) */
+	stm_syscfg.cfgr1 = (stm_syscfg.cfgr1 & ~(STM_SYSCFG_CFGR1_MEM_MODE_MASK << STM_SYSCFG_CFGR1_MEM_MODE)) |
+		(STM_SYSCFG_CFGR1_MEM_MODE_MAIN_FLASH << STM_SYSCFG_CFGR1_MEM_MODE);
 #endif
 	memcpy(&__data_start__, &__text_end__, &__data_end__ - &__data_start__);
 	memset(&__bss_start__, '\0', &__bss_end__ - &__bss_start__);
diff --git a/src/stmf0/ao_usb_stm.c b/src/stmf0/ao_usb_stm.c
index bf08abc1..c4860d8e 100644
--- a/src/stmf0/ao_usb_stm.c
+++ b/src/stmf0/ao_usb_stm.c
@@ -113,6 +113,12 @@ static uint8_t	ao_usb_in_tx2_which;
 static uint8_t	ao_usb_tx2_count;
 #endif
 
+#if AO_USB_HAS_IN3
+static uint16_t ao_usb_in_tx3_offset;
+static uint8_t	ao_usb_in_tx3_which;
+static uint8_t	ao_usb_tx3_count;
+#endif
+
 /*
  * End point register indices
  */
@@ -122,6 +128,7 @@ static uint8_t	ao_usb_tx2_count;
 #define AO_USB_OUT_EPR		2
 #define AO_USB_IN_EPR		3
 #define AO_USB_IN2_EPR		4
+#define AO_USB_IN3_EPR		5
 
 /* Marks when we don't need to send an IN packet.
  * This happens only when the last IN packet is not full,
@@ -146,6 +153,16 @@ static uint16_t	in2_count;
 static uint8_t	ao_usb_in2_flushed;
 #endif
 
+#if AO_USB_HAS_IN3
+/* Marks when we have delivered an IN packet to the hardware
+ * and it has not been received yet. ao_sleep on this address
+ * to wait for it to be delivered.
+ */
+static uint8_t	ao_usb_in3_pending;
+static uint16_t	in3_count;
+static uint8_t	ao_usb_in3_flushed;
+#endif
+
 /* Marks when an OUT packet has been received by the hardware
  * but not pulled to the shadow buffer.
  */
@@ -423,6 +440,11 @@ ao_usb_alloc_buffers(void)
 	ao_usb_in_tx2_offset = sram_addr;
 	sram_addr += AO_USB_IN_SIZE * 2;
 #endif
+#if AO_USB_HAS_IN3
+	sram_addr += (sram_addr & 1);
+	ao_usb_in_tx3_offset = sram_addr;
+	sram_addr += AO_USB_IN_SIZE * 2;
+#endif
 }
 
 static void
@@ -558,6 +580,25 @@ ao_usb_set_configuration(void)
 	ao_usb_in_tx2_which = 0;
 #endif
 
+#if AO_USB_HAS_IN3
+	/* Set up the IN3 end point */
+	stm_usb_bdt[AO_USB_IN3_EPR].double_tx[0].addr = ao_usb_in_tx3_offset;
+	stm_usb_bdt[AO_USB_IN3_EPR].double_tx[0].count = 0;
+	stm_usb_bdt[AO_USB_IN3_EPR].double_tx[1].addr = ao_usb_in_tx3_offset + AO_USB_IN_SIZE;
+	stm_usb_bdt[AO_USB_IN3_EPR].double_tx[1].count = 0;
+
+	ao_usb_init_ep(AO_USB_IN3_EPR,
+		       AO_USB_IN3_EP,
+		       STM_USB_EPR_EP_TYPE_BULK,
+		       STM_USB_EPR_STAT_RX_DISABLED,
+		       STM_USB_EPR_STAT_TX_NAK,
+		       STM_USB_EPR_EP_KIND_DBL_BUF,
+		       0, 1);
+
+	/* First transmit data goes to buffer 0 */
+	ao_usb_in_tx3_which = 0;
+#endif
+
 	ao_usb_in_flushed = 0;
 	ao_usb_in_pending = 0;
 	ao_wakeup(&ao_usb_in_pending);
@@ -567,6 +608,12 @@ ao_usb_set_configuration(void)
 	ao_wakeup(&ao_usb_in2_pending);
 #endif
 
+#if AO_USB_HAS_IN3
+	ao_usb_in3_flushed = 0;
+	ao_usb_in3_pending = 0;
+	ao_wakeup(&ao_usb_in3_pending);
+#endif
+
 	ao_usb_out_avail = 0;
 	ao_usb_configuration = 0;
 
@@ -996,6 +1043,16 @@ stm_usb_isr(void)
 			}
 			break;
 #endif
+#if AO_USB_HAS_IN3
+		case AO_USB_IN3_EPR:
+			++in3_count;
+			_tx_dbg1("TX3 ISR", epr);
+			if (ao_usb_epr_ctr_tx(epr)) {
+				ao_usb_in3_pending = 0;
+				ao_wakeup(&ao_usb_in3_pending);
+			}
+			break;
+#endif
 		case AO_USB_INT_EPR:
 #if USB_STATUS
 			++int_count;
@@ -1132,6 +1189,9 @@ _ao_usb_in2_send(void)
 	/* Toggle our usage */
 	ao_usb_in_tx2_which = 1 - ao_usb_in_tx2_which;
 
+	/* Toggle the SW_BUF flag */
+	_ao_usb_toggle_dtog(AO_USB_IN2_EPR, 1, 0);
+
 	/* Mark the outgoing buffer as valid */
 	_ao_usb_set_stat_tx(AO_USB_IN2_EPR, STM_USB_EPR_STAT_TX_VALID);
 
@@ -1199,6 +1259,94 @@ ao_usb_putchar2(char c)
 }
 #endif
 
+#if AO_USB_HAS_IN3
+/* Queue the current IN buffer for transmission */
+static void
+_ao_usb_in3_send(void)
+{
+	_tx_dbg0("in3_send start");
+	debug ("send3 %d\n", ao_usb_tx3_count);
+	while (ao_usb_in3_pending)
+		ao_sleep(&ao_usb_in3_pending);
+	ao_usb_in3_pending = 1;
+	if (ao_usb_tx3_count != AO_USB_IN_SIZE)
+		ao_usb_in3_flushed = 1;
+	stm_usb_bdt[AO_USB_IN3_EPR].double_tx[ao_usb_in_tx3_which].count = ao_usb_tx3_count;
+	ao_usb_tx3_count = 0;
+
+	/* Toggle our usage */
+	ao_usb_in_tx3_which = 1 - ao_usb_in_tx3_which;
+
+	/* Toggle the SW_BUF flag */
+	_ao_usb_toggle_dtog(AO_USB_IN3_EPR, 1, 0);
+
+	/* Mark the outgoing buffer as valid */
+	_ao_usb_set_stat_tx(AO_USB_IN3_EPR, STM_USB_EPR_STAT_TX_VALID);
+
+	_tx_dbg0("in3_send end");
+}
+
+/* Wait for a free IN buffer. Interrupts are blocked */
+static void
+_ao_usb_in3_wait(void)
+{
+	for (;;) {
+		/* Check if the current buffer is writable */
+		if (ao_usb_tx3_count < AO_USB_IN_SIZE)
+			break;
+
+		_tx_dbg0("in3_wait top");
+		/* Wait for an IN buffer to be ready */
+		while (ao_usb_in3_pending)
+			ao_sleep(&ao_usb_in3_pending);
+		_tx_dbg0("in_wait bottom");
+	}
+}
+
+void
+ao_usb_flush3(void)
+{
+	if (!ao_usb_running)
+		return;
+
+	/* Anytime we've sent a character since
+	 * the last time we flushed, we'll need
+	 * to send a packet -- the only other time
+	 * we would send a packet is when that
+	 * packet was full, in which case we now
+	 * want to send an empty packet
+	 */
+	ao_arch_block_interrupts();
+	while (!ao_usb_in3_flushed) {
+		_tx_dbg0("flush3 top");
+		_ao_usb_in3_send();
+		_tx_dbg0("flush3 end");
+	}
+	ao_arch_release_interrupts();
+}
+
+void
+ao_usb_putchar3(char c)
+{
+	if (!ao_usb_running)
+		return;
+
+	ao_arch_block_interrupts();
+	_ao_usb_in3_wait();
+
+	ao_usb_in3_flushed = 0;
+	ao_usb_tx_byte(ao_usb_in_tx3_offset + AO_USB_IN_SIZE * ao_usb_in_tx3_which + ao_usb_tx3_count++, c);
+
+	/* Send the packet when full */
+	if (ao_usb_tx3_count == AO_USB_IN_SIZE) {
+		_tx_dbg0("putchar3 full");
+		_ao_usb_in3_send();
+		_tx_dbg0("putchar3 flushed");
+	}
+	ao_arch_release_interrupts();
+}
+#endif
+
 #if AO_USB_HAS_OUT
 static void
 _ao_usb_out_recv(void)
@@ -1447,7 +1595,7 @@ ao_usb_enable(void)
 
 	ao_arch_release_interrupts();
 
-	for (t = 0; t < 1000; t++)
+	for (t = 0; t < 50000; t++)
 		ao_arch_nop();
 
 	/* Enable USB pull-up */
@@ -1541,9 +1689,9 @@ struct ao_usb_dbg {
 #endif
 };
 
-#define NUM_USB_DBG	128
+#define NUM_USB_DBG	16
 
-struct ao_usb_dbg dbg[128];
+struct ao_usb_dbg dbg[NUM_USB_DBG];
 int dbg_i;
 
 static void _dbg(int line, char *msg, uint32_t value)
@@ -1555,11 +1703,11 @@ static void _dbg(int line, char *msg, uint32_t value)
 	asm("mrs %0,primask" : "=&r" (primask));
 	dbg[dbg_i].primask = primask;
 #if TX_DBG
-	dbg[dbg_i].in_count = in_count;
-	dbg[dbg_i].in_epr = stm_usb.epr[AO_USB_IN_EPR];
-	dbg[dbg_i].in_pending = ao_usb_in_pending;
-	dbg[dbg_i].tx_count = ao_usb_tx_count;
-	dbg[dbg_i].in_flushed = ao_usb_in_flushed;
+	dbg[dbg_i].in_count = in3_count;
+	dbg[dbg_i].in_epr = stm_usb.epr[AO_USB_IN3_EPR].r;
+	dbg[dbg_i].in_pending = ao_usb_in3_pending;
+	dbg[dbg_i].tx_count = ao_usb_tx3_count;
+	dbg[dbg_i].in_flushed = ao_usb_in3_flushed;
 #endif
 #if RX_DBG
 	dbg[dbg_i].rx_count = ao_usb_rx_count;
diff --git a/src/telefire-v0.1/ao_pins.h b/src/telefire-v0.1/ao_pins.h
index ee0ca716..8266589e 100644
--- a/src/telefire-v0.1/ao_pins.h
+++ b/src/telefire-v0.1/ao_pins.h
@@ -100,10 +100,17 @@
 #define AO_STROBE_PIN		1
 #define AO_STROBE		P1_1
 
-/* test these values with real igniters */
-#define AO_PAD_RELAY_CLOSED	3524
-#define AO_PAD_NO_IGNITER	16904
-#define AO_PAD_GOOD_IGNITER	22514
+#define AO_ADC_REFERENCE_DV	33
+#define AO_PAD_R_V_BATT_BATT_SENSE	100
+#define AO_PAD_R_BATT_SENSE_GND		27
+
+#define AO_PAD_R_V_BATT_V_PYRO		100
+#define AO_PAD_R_V_PYRO_PYRO_SENSE	100
+#define AO_PAD_R_PYRO_SENSE_GND		27
+
+#define AO_PAD_R_V_PYRO_IGNITER		100
+#define AO_PAD_R_IGNITER_IGNITER_SENSE	100
+#define AO_PAD_R_IGNITER_SENSE_GND	27
 
 #define AO_PAD_ADC_PYRO		4
 #define AO_PAD_ADC_BATT		5
diff --git a/src/telefire-v0.2/ao_pins.h b/src/telefire-v0.2/ao_pins.h
index 4faeb65f..65f5bdcc 100644
--- a/src/telefire-v0.2/ao_pins.h
+++ b/src/telefire-v0.2/ao_pins.h
@@ -111,15 +111,24 @@
 #define AO_STROBE		P2_4
 
 /* test these values with real igniters */
-#define AO_PAD_RELAY_CLOSED	3524
-#define AO_PAD_NO_IGNITER	16904
-#define AO_PAD_GOOD_IGNITER	22514
-
 #define AO_PAD_ADC_PYRO		4
 #define AO_PAD_ADC_BATT		5
 
 #define AO_ADC_FIRST_PIN	0
 
+#define AO_ADC_REFERENCE_DV	33
+#define AO_PAD_R_V_BATT_BATT_SENSE	100
+#define AO_PAD_R_BATT_SENSE_GND		27
+
+#define AO_PAD_R_V_BATT_V_PYRO		100
+#define AO_PAD_R_V_PYRO_PYRO_SENSE	100
+#define AO_PAD_R_PYRO_SENSE_GND		27
+
+#define AO_PAD_R_V_PYRO_IGNITER		100
+#define AO_PAD_R_IGNITER_IGNITER_SENSE	100
+#define AO_PAD_R_IGNITER_SENSE_GND	27
+
+
 struct ao_adc {
 	int16_t		sense[AO_PAD_NUM];
 	int16_t		pyro;
diff --git a/src/telefireeight-v1.0/.gitignore b/src/telefireeight-v1.0/.gitignore
new file mode 100644
index 00000000..22f7e9ef
--- /dev/null
+++ b/src/telefireeight-v1.0/.gitignore
@@ -0,0 +1,2 @@
+telefireeight-*
+ao_product.h
diff --git a/src/telefireeight-v1.0/Makefile b/src/telefireeight-v1.0/Makefile
new file mode 100644
index 00000000..200c3150
--- /dev/null
+++ b/src/telefireeight-v1.0/Makefile
@@ -0,0 +1,90 @@
+#
+# TeleFire build file
+#
+
+include ../stm/Makefile.defs
+
+INC = \
+	ao.h \
+	ao_pins.h \
+	ao_arch.h \
+	ao_arch_funcs.h \
+	ao_pad.h \
+	ao_product.h \
+	ao_radio_spi.h \
+	ao_radio_cmac.h \
+	ao_cc1200_CC1200.h \
+	ao_cc1200.h \
+	stm32l.h
+#
+# Common AltOS sources
+#
+
+#PROFILE=ao_profile.c
+#PROFILE_DEF=-DAO_PROFILE=1
+
+ALTOS_SRC = \
+	ao_boot_chain.c \
+	ao_interrupt.c \
+	ao_product.c \
+	ao_romconfig.c \
+	ao_cmd.c \
+	ao_adc_stm.c \
+	ao_data.c \
+	ao_config.c \
+	ao_task.c \
+	ao_led.c \
+	ao_stdio.c \
+	ao_panic.c \
+	ao_timer.c \
+	ao_mutex.c \
+	ao_freq.c \
+	ao_dma_stm.c \
+	ao_spi_stm.c \
+	ao_beep_stm.c \
+	ao_eeprom_stm.c \
+	ao_usb_stm.c \
+	ao_exti_stm.c \
+	ao_cc1200.c \
+	ao_radio_cmac.c \
+	ao_aes.c \
+	ao_aes_tables.c \
+	ao_pad.c \
+	ao_radio_cmac_cmd.c
+
+PRODUCT_SRC = \
+	ao_telefireeight.c
+
+PRODUCT=TeleFireEight-v1.0
+PRODUCT_DEF=-DTELEFIREEIGHT_V_1_0
+IDPRODUCT=0x000f
+
+CFLAGS = $(PRODUCT_DEF) $(STM_CFLAGS) $(PROFILE_DEF) -Os -g
+
+PROGNAME = telefireeight-v1.0
+PROG = $(PROGNAME)-$(VERSION).elf
+HEX = $(PROGNAME)-$(VERSION).ihx
+
+SRC = $(ALTOS_SRC) $(PRODUCT_SRC)
+OBJ=$(SRC:.c=.o)
+
+all: $(PROG) $(HEX)
+
+$(PROG): Makefile $(OBJ) altos.ld
+	$(call quiet,CC) $(LDFLAGS) $(CFLAGS) -o $(PROG) $(OBJ) $(LIBS)
+
+$(OBJ): $(INC)
+
+ao_product.h: ao-make-product.5c ../Version
+	$(call quiet,NICKLE,$<) $< -m altusmetrum.org -i $(IDPRODUCT) -p $(PRODUCT) -v $(VERSION) > $@
+
+distclean:	clean
+
+clean:
+	rm -f *.o $(PROGNAME)-*.elf $(PROGNAME)-*.ihx
+	rm -f ao_product.h
+
+install:
+
+uninstall:
+
diff --git a/src/telefireeight-v1.0/ao_pins.h b/src/telefireeight-v1.0/ao_pins.h
new file mode 100644
index 00000000..15e1fa11
--- /dev/null
+++ b/src/telefireeight-v1.0/ao_pins.h
@@ -0,0 +1,341 @@
+/*
+ * Copyright © 2010 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; either version 2 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, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+#ifndef _AO_PINS_H_
+#define _AO_PINS_H_
+
+#define HAS_RADIO		1
+#define HAS_RADIO_RATE		1
+#define HAS_TELEMETRY		0
+#define HAS_FLIGHT		0
+#define HAS_USB			1
+#define HAS_BEEP		0
+#define HAS_GPS			0
+#define HAS_SERIAL_1		0
+#define HAS_ADC			1
+#define HAS_DBG			0
+#define HAS_EEPROM		1
+#define HAS_LOG			0
+#define HAS_PAD			1
+#define USE_INTERNAL_FLASH	1
+#define IGNITE_ON_P0		0
+#define PACKET_HAS_MASTER	0
+#define PACKET_HAS_SLAVE	0
+#define AO_DATA_RING		32
+#define USE_EEPROM_CONFIG	1
+#define USE_STORAGE_CONFIG	0
+#define HAS_AES			1
+
+/* 8MHz High speed external crystal */
+#define AO_HSE			8000000
+
+/* PLLVCO = 96MHz (so that USB will work) */
+#define AO_PLLMUL		12
+#define AO_RCC_CFGR_PLLMUL	(STM_RCC_CFGR_PLLMUL_12)
+
+#define AO_CC1200_FOSC		40000000
+
+/* SYSCLK = 32MHz (no need to go faster than CPU) */
+#define AO_PLLDIV		3
+#define AO_RCC_CFGR_PLLDIV	(STM_RCC_CFGR_PLLDIV_3)
+
+/* HCLK = 32MHz (CPU clock) */
+#define AO_AHB_PRESCALER	1
+#define AO_RCC_CFGR_HPRE_DIV	STM_RCC_CFGR_HPRE_DIV_1
+
+/* Run APB1 at 16MHz (HCLK/2) */
+#define AO_APB1_PRESCALER	2
+#define AO_RCC_CFGR_PPRE1_DIV	STM_RCC_CFGR_PPRE2_DIV_2
+
+/* Run APB2 at 16MHz (HCLK/2) */
+#define AO_APB2_PRESCALER	2
+#define AO_RCC_CFGR_PPRE2_DIV	STM_RCC_CFGR_PPRE2_DIV_2
+
+#define HAS_SPI_1		1
+#define SPI_1_PA5_PA6_PA7	0
+#define SPI_1_PB3_PB4_PB5	0
+#define SPI_1_PE13_PE14_PE15	1
+#define SPI_1_GPIO		(&stm_gpioe)
+#define SPI_1_SCK		13
+#define SPI_1_MISO		14
+#define SPI_1_MOSI		15
+#define SPI_1_OSPEEDR		STM_OSPEEDR_10MHz
+
+#define HAS_SPI_2		0
+#define SPI_2_PB13_PB14_PB15	0
+#define SPI_2_PD1_PD3_PD4	0
+
+#define HAS_I2C_1		0
+
+#define HAS_I2C_2		0
+
+#define PACKET_HAS_SLAVE	0
+#define PACKET_HAS_MASTER	0
+
+#define FAST_TIMER_FREQ		10000	/* .1ms for debouncing */
+
+/*
+ * Radio is a cc1200 connected via SPI
+ */
+
+#define AO_RADIO_CAL_DEFAULT 	5695733
+
+#define AO_CC1200_SPI_CS_PORT	(&stm_gpioe)
+#define AO_CC1200_SPI_CS_PIN	11
+#define AO_CC1200_SPI_BUS	AO_SPI_1_PE13_PE14_PE15
+#define AO_CC1200_SPI		stm_spi1
+#define AO_CC1200_SPI_SPEED	AO_SPI_SPEED_FAST
+
+#define AO_CC1200_INT_PORT	(&stm_gpioe)
+#define AO_CC1200_INT_PIN	(12)
+
+#define AO_CC1200_INT_GPIO	2
+#define AO_CC1200_INT_GPIO_IOCFG	CC1200_IOCFG2
+
+#define LED_PER_LED		1
+#define LED_TYPE		uint16_t
+
+/* Continuity leds 1-8 */
+#define LED_0_PORT		(&stm_gpiob)
+#define LED_0_PIN		13
+#define LED_1_PORT		(&stm_gpiob)
+#define LED_1_PIN		12
+#define LED_2_PORT		(&stm_gpiob)
+#define LED_2_PIN		11
+#define LED_3_PORT		(&stm_gpiob)
+#define LED_3_PIN		10
+#define LED_4_PORT		(&stm_gpioc)
+#define LED_4_PIN		9
+#define LED_5_PORT		(&stm_gpioa)
+#define LED_5_PIN		8
+#define LED_6_PORT		(&stm_gpioa)
+#define LED_6_PIN		9
+#define LED_7_PORT		(&stm_gpioa)
+#define LED_7_PIN		10
+
+#define LED_PIN_CONTINUITY_0	0
+#define LED_PIN_CONTINUITY_1	1
+#define LED_PIN_CONTINUITY_2	2
+#define LED_PIN_CONTINUITY_3	3
+#define LED_PIN_CONTINUITY_4	4
+#define LED_PIN_CONTINUITY_5	5
+#define LED_PIN_CONTINUITY_6	6
+#define LED_PIN_CONTINUITY_7	7
+
+/* ARM */
+#define LED_8_PORT		(&stm_gpioe)
+#define LED_8_PIN		3
+
+#define LED_PIN_ARMED		8
+
+/* RF good/marginal/poor */
+#define LED_9_PORT		(&stm_gpioe)
+#define LED_9_PIN		4
+#define LED_10_PORT		(&stm_gpioe)
+#define LED_10_PIN		5
+#define LED_11_PORT		(&stm_gpioe)
+#define LED_11_PIN		6
+
+#define LED_PIN_GREEN		9
+#define LED_PIN_AMBER		10
+#define LED_PIN_RED		11
+
+#define AO_LED_CONTINUITY(c)	(1 << (c))
+#define AO_LED_CONTINUITY_MASK	(0xff)
+
+#define AO_LED_ARMED		(1 << LED_PIN_ARMED)
+#define AO_LED_GREEN		(1 << LED_PIN_GREEN)
+#define AO_LED_AMBER		(1 << LED_PIN_AMBER)
+#define AO_LED_RED		(1 << LED_PIN_RED)
+
+#define LEDS_AVAILABLE		(0xfff)
+
+/* Alarm A */
+#define AO_SIREN
+#define AO_SIREN_PORT		(&stm_gpiod)
+#define AO_SIREN_PIN		10
+
+/* Alarm B */
+#define AO_STROBE
+#define AO_STROBE_PORT		(&stm_gpiod)
+#define AO_STROBE_PIN		11
+
+/* Pad selector is on PD0-7 */
+
+#define HAS_FIXED_PAD_BOX	1
+#define AO_PAD_SELECTOR_PORT	(&stm_gpiod)
+#define AO_PAD_SELECTOR_PINS	(0xff)
+
+#define SPI_CONST	0x00
+
+#define AO_PAD_NUM		8
+#define	AO_PAD_PORT_0		(&stm_gpiod)
+#define	AO_PAD_PORT_1		(&stm_gpiob)
+
+#define AO_PAD_PIN_0		9
+#define AO_PAD_0_PORT		(&stm_gpiod)
+#define AO_ADC_SENSE_PAD_0	3
+#define AO_ADC_SENSE_PAD_0_PORT	(&stm_gpioa)
+#define AO_ADC_SENSE_PAD_0_PIN	3
+
+#define AO_PAD_PIN_1		8
+#define AO_PAD_1_PORT		(&stm_gpiod)
+#define AO_ADC_SENSE_PAD_1	2
+#define AO_ADC_SENSE_PAD_1_PORT	(&stm_gpioa)
+#define AO_ADC_SENSE_PAD_1_PIN	2
+
+#define AO_PAD_PIN_2		15
+#define AO_PAD_2_PORT		(&stm_gpiob)
+#define AO_ADC_SENSE_PAD_2	1
+#define AO_ADC_SENSE_PAD_2_PORT	(&stm_gpioa)
+#define AO_ADC_SENSE_PAD_2_PIN	1
+
+#define AO_PAD_PIN_3		14
+#define AO_PAD_3_PORT		(&stm_gpiob)
+#define AO_ADC_SENSE_PAD_3	0
+#define AO_ADC_SENSE_PAD_3_PORT	(&stm_gpioa)
+#define AO_ADC_SENSE_PAD_3_PIN	0
+
+#define AO_PAD_PIN_4		12
+#define AO_PAD_4_PORT		(&stm_gpiod)
+#define AO_ADC_SENSE_PAD_4	7
+#define AO_ADC_SENSE_PAD_4_PORT	(&stm_gpioa)
+#define AO_ADC_SENSE_PAD_4_PIN	7
+
+#define AO_PAD_PIN_5		13
+#define AO_PAD_5_PORT		(&stm_gpiod)
+#define AO_ADC_SENSE_PAD_5	6
+#define AO_ADC_SENSE_PAD_5_PORT	(&stm_gpioa)
+#define AO_ADC_SENSE_PAD_5_PIN	6
+
+#define AO_PAD_PIN_6		14
+#define AO_PAD_6_PORT		(&stm_gpiod)
+#define AO_ADC_SENSE_PAD_6	5
+#define AO_ADC_SENSE_PAD_6_PORT	(&stm_gpioa)
+#define AO_ADC_SENSE_PAD_6_PIN	5
+
+#define AO_PAD_PIN_7		15
+#define AO_PAD_7_PORT		(&stm_gpiod)
+#define AO_ADC_SENSE_PAD_7	4
+#define AO_ADC_SENSE_PAD_7_PORT	(&stm_gpioa)
+#define AO_ADC_SENSE_PAD_7_PIN	4
+
+#define AO_ADC_PYRO		8
+#define AO_ADC_PYRO_PORT	(&stm_gpiob)
+#define AO_ADC_PYRO_PIN		0
+
+#define AO_ADC_BATT		15
+#define AO_ADC_BATT_PORT	(&stm_gpioc)
+#define AO_ADC_BATT_PIN		5
+
+#define AO_ADC_PIN0_PORT	AO_ADC_SENSE_PAD_0_PORT
+#define AO_ADC_PIN0_PIN		AO_ADC_SENSE_PAD_0_PIN
+
+#define AO_ADC_PIN1_PORT	AO_ADC_SENSE_PAD_1_PORT
+#define AO_ADC_PIN1_PIN		AO_ADC_SENSE_PAD_1_PIN
+
+#define AO_ADC_PIN2_PORT	AO_ADC_SENSE_PAD_2_PORT
+#define AO_ADC_PIN2_PIN		AO_ADC_SENSE_PAD_2_PIN
+
+#define AO_ADC_PIN3_PORT	AO_ADC_SENSE_PAD_3_PORT
+#define AO_ADC_PIN3_PIN		AO_ADC_SENSE_PAD_3_PIN
+
+#define AO_ADC_PIN4_PORT	AO_ADC_SENSE_PAD_4_PORT
+#define AO_ADC_PIN4_PIN		AO_ADC_SENSE_PAD_4_PIN
+
+#define AO_ADC_PIN5_PORT	AO_ADC_SENSE_PAD_5_PORT
+#define AO_ADC_PIN5_PIN		AO_ADC_SENSE_PAD_5_PIN
+
+#define AO_ADC_PIN6_PORT	AO_ADC_SENSE_PAD_6_PORT
+#define AO_ADC_PIN6_PIN		AO_ADC_SENSE_PAD_6_PIN
+
+#define AO_ADC_PIN7_PORT	AO_ADC_SENSE_PAD_7_PORT
+#define AO_ADC_PIN7_PIN		AO_ADC_SENSE_PAD_7_PIN
+
+#define AO_ADC_PIN8_PORT	AO_ADC_PYRO_PORT
+#define AO_ADC_PIN8_PIN		AO_ADC_PYRO_PIN
+
+#define AO_ADC_PIN9_PORT	AO_ADC_BATT_PORT
+#define AO_ADC_PIN9_PIN		AO_ADC_BATT_PIN
+
+#define AO_PAD_ALL_CHANNELS	(0xff)
+
+/* test these values with real igniters */
+#define AO_PAD_RELAY_CLOSED	3524
+#define AO_PAD_NO_IGNITER	16904
+#define AO_PAD_GOOD_IGNITER	22514
+
+#define AO_ADC_FIRST_PIN	0
+
+#define AO_NUM_ADC		10
+
+#define AO_ADC_SQ1		AO_ADC_SENSE_PAD_0
+#define AO_ADC_SQ2		AO_ADC_SENSE_PAD_1
+#define AO_ADC_SQ3		AO_ADC_SENSE_PAD_2
+#define AO_ADC_SQ4		AO_ADC_SENSE_PAD_3
+#define AO_ADC_SQ5		AO_ADC_SENSE_PAD_4
+#define AO_ADC_SQ6		AO_ADC_SENSE_PAD_5
+#define AO_ADC_SQ7		AO_ADC_SENSE_PAD_6
+#define AO_ADC_SQ8		AO_ADC_SENSE_PAD_7
+#define AO_ADC_SQ9		AO_ADC_PYRO
+#define AO_ADC_SQ10		AO_ADC_BATT
+
+#define AO_ADC_REFERENCE_DV	33
+
+#define AO_ADC_RCC_AHBENR	((1 << STM_RCC_AHBENR_GPIOAEN) | \
+				 (1 << STM_RCC_AHBENR_GPIOBEN) | \
+				 (1 << STM_RCC_AHBENR_GPIOCEN))
+
+
+#define AO_PAD_R_V_BATT_BATT_SENSE	200
+#define AO_PAD_R_BATT_SENSE_GND		22
+
+#define AO_PAD_R_V_BATT_V_PYRO		200
+#define AO_PAD_R_V_PYRO_PYRO_SENSE	200
+#define AO_PAD_R_PYRO_SENSE_GND		22
+
+#undef AO_PAD_R_V_PYRO_IGNITER
+#define AO_PAD_R_IGNITER_IGNITER_SENSE	200
+#define AO_PAD_R_IGNITER_SENSE_GND	22
+
+#define HAS_ADC_TEMP		0
+
+struct ao_adc {
+	int16_t		sense[AO_PAD_NUM];
+	int16_t		pyro;
+	int16_t		batt;
+};
+
+#define AO_ADC_DUMP(p)							\
+	printf ("tick: %5u "						\
+		"0: %5d 1: %5d 2: %5d 3: %5d "				\
+		"4: %5d 5: %5d 6: %5d 7: %5d "				\
+		"pyro: %5d batt: %5d\n",				\
+		(p)->tick,						\
+		(p)->adc.sense[0],					\
+		(p)->adc.sense[1],					\
+		(p)->adc.sense[2],					\
+		(p)->adc.sense[3],					\
+		(p)->adc.sense[4],					\
+		(p)->adc.sense[5],					\
+		(p)->adc.sense[6],					\
+		(p)->adc.sense[7],					\
+		(p)->adc.pyro,						\
+		(p)->adc.batt)
+
+#endif /* _AO_PINS_H_ */
diff --git a/src/telefireeight-v1.0/ao_telefireeight.c b/src/telefireeight-v1.0/ao_telefireeight.c
new file mode 100644
index 00000000..bdcf3213
--- /dev/null
+++ b/src/telefireeight-v1.0/ao_telefireeight.c
@@ -0,0 +1,55 @@
+/*
+ * Copyright © 2012 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; either version 2 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, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+#include <ao.h>
+#include <ao_pad.h>
+#include <ao_exti.h>
+#include <ao_radio_cmac_cmd.h>
+
+void
+main(void)
+{
+	ao_clock_init();
+
+	ao_led_init(LEDS_AVAILABLE);
+
+	ao_task_init();
+
+	ao_timer_init();
+	ao_spi_init();
+	ao_dma_init();
+	ao_exti_init();
+
+	ao_cmd_init();
+
+	ao_adc_init();
+
+	ao_eeprom_init();
+
+	ao_radio_init();
+
+	ao_usb_init();
+
+	ao_config_init();
+
+	ao_pad_init();
+
+//	ao_radio_cmac_cmd_init();
+
+	ao_start_scheduler();
+}
diff --git a/src/telefireeight-v1.0/flash-loader/.gitignore b/src/telefireeight-v1.0/flash-loader/.gitignore
new file mode 100644
index 00000000..65fe7eab
--- /dev/null
+++ b/src/telefireeight-v1.0/flash-loader/.gitignore
@@ -0,0 +1,2 @@
+*.elf
+*.ihx
diff --git a/src/telefireeight-v1.0/flash-loader/Makefile b/src/telefireeight-v1.0/flash-loader/Makefile
new file mode 100644
index 00000000..baf0e3f3
--- /dev/null
+++ b/src/telefireeight-v1.0/flash-loader/Makefile
@@ -0,0 +1,8 @@
+#
+# AltOS flash loader build
+#
+#
+
+TOPDIR=../..
+HARDWARE=telefireeight-v1.0
+include $(TOPDIR)/stm/Makefile-flash.defs
diff --git a/src/telefireeight-v1.0/flash-loader/ao_pins.h b/src/telefireeight-v1.0/flash-loader/ao_pins.h
new file mode 100644
index 00000000..889feef6
--- /dev/null
+++ b/src/telefireeight-v1.0/flash-loader/ao_pins.h
@@ -0,0 +1,33 @@
+/*
+ * 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; either version 2 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, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+#ifndef _AO_PINS_H_
+#define _AO_PINS_H_
+
+/* External crystal at 8MHz */
+#define AO_HSE		8000000
+
+#include <ao_flash_stm_pins.h>
+
+#define AO_BOOT_PIN			1
+#define AO_BOOT_APPLICATION_GPIO	stm_gpioe
+#define AO_BOOT_APPLICATION_PIN		2
+#define AO_BOOT_APPLICATION_VALUE	1
+#define AO_BOOT_APPLICATION_MODE	AO_EXTI_MODE_PULL_UP
+
+#endif /* _AO_PINS_H_ */
diff --git a/src/telefiretwo-v0.1/ao_pins.h b/src/telefiretwo-v0.1/ao_pins.h
index 1e5c0d09..dedd0fad 100644
--- a/src/telefiretwo-v0.1/ao_pins.h
+++ b/src/telefiretwo-v0.1/ao_pins.h
@@ -191,6 +191,19 @@
 
 #define HAS_ADC_TEMP		0
 
+#define AO_ADC_REFERENCE_DV	33
+
+#define AO_PAD_R_V_BATT_BATT_SENSE	200
+#define AO_PAD_R_BATT_SENSE_GND		22
+
+#define AO_PAD_R_V_BATT_V_PYRO		200
+#define AO_PAD_R_V_PYRO_PYRO_SENSE	200
+#define AO_PAD_R_PYRO_SENSE_GND		22
+
+#undef AO_PAD_R_V_PYRO_IGNITER
+#define AO_PAD_R_IGNITER_IGNITER_SENSE	200
+#define AO_PAD_R_IGNITER_SENSE_GND	22
+
 struct ao_adc {
 	int16_t		sense[AO_PAD_NUM];
 	int16_t		pyro;
diff --git a/src/telelco-v0.2-cc1200/Makefile b/src/telelco-v0.2-cc1200/Makefile
new file mode 100644
index 00000000..4ccf494c
--- /dev/null
+++ b/src/telelco-v0.2-cc1200/Makefile
@@ -0,0 +1,109 @@
+#
+# AltOS build for TeleLCO
+#
+#
+
+include ../stm/Makefile.defs
+
+INC = \
+	ao.h \
+	ao_arch.h \
+	ao_arch_funcs.h \
+	ao_boot.h \
+	ao_companion.h \
+	ao_data.h \
+	ao_sample.h \
+	ao_pins.h \
+	ao_product.h \
+	ao_seven_segment.h \
+	ao_lco.h \
+	ao_lco_cmd.h \
+	ao_lco_func.h \
+	ao_radio_spi.h \
+	ao_radio_cmac.h \
+	ao_cc1200_CC1200.h \
+	ao_cc1200.h \
+	stm32l.h
+
+#
+# Common AltOS sources
+#
+
+#PROFILE=ao_profile.c
+#PROFILE_DEF=-DAO_PROFILE=1
+
+ALTOS_SRC = \
+	ao_boot_chain.c \
+	ao_interrupt.c \
+	ao_product.c \
+	ao_romconfig.c \
+	ao_cmd.c \
+	ao_config.c \
+	ao_task.c \
+	ao_led.c \
+	ao_stdio.c \
+	ao_panic.c \
+	ao_timer.c \
+	ao_mutex.c \
+	ao_freq.c \
+	ao_dma_stm.c \
+	ao_spi_stm.c \
+	ao_beep_stm.c \
+	ao_eeprom_stm.c \
+	ao_adc_single_stm.c \
+	ao_convert_volt.c \
+	ao_fast_timer.c \
+	ao_lcd_stm.c \
+	ao_usb_stm.c \
+	ao_exti_stm.c \
+	ao_cc1200.c \
+	ao_radio_cmac.c \
+	ao_aes.c \
+	ao_aes_tables.c \
+	ao_fec_tx.c \
+	ao_fec_rx.c \
+	ao_seven_segment.c \
+	ao_quadrature.c \
+	ao_button.c \
+	ao_event.c \
+	ao_lco.c \
+	ao_lco_bits.c \
+	ao_lco_cmd.c \
+	ao_lco_func.c \
+	ao_radio_cmac_cmd.c
+
+PRODUCT=TeleLCO-v0.2
+PRODUCT_DEF=-DTELELCO
+IDPRODUCT=0x0023
+
+CFLAGS = $(PRODUCT_DEF) $(STM_CFLAGS) $(PROFILE_DEF) -Os -g
+
+PROGNAME=telelco-v0.2
+PROG=$(PROGNAME)-$(VERSION).elf
+HEX=$(PROGNAME)-$(VERSION).ihx
+
+SRC=$(ALTOS_SRC) ao_telelco.c
+OBJ=$(SRC:.c=.o)
+
+all: $(PROG) $(HEX)
+
+$(PROG): Makefile $(OBJ) altos.ld
+	$(call quiet,CC) $(LDFLAGS) $(CFLAGS) -o $(PROG) $(OBJ) $(LIBS)
+
+../altitude.h: make-altitude
+	nickle $< > $@
+
+$(OBJ): $(INC)
+
+ao_product.h: ao-make-product.5c ../Version
+	$(call quiet,NICKLE,$<) $< -m altusmetrum.org -i $(IDPRODUCT) -p $(PRODUCT) -v $(VERSION) > $@
+
+distclean:	clean
+
+clean:
+	rm -f *.o $(PROGNAME)-*.elf $(PROGNAME)-*.ihx
+	rm -f ao_product.h
+
+install:
+
+uninstall:
diff --git a/src/telelco-v0.2-cc1200/ao_pins.h b/src/telelco-v0.2-cc1200/ao_pins.h
new file mode 100644
index 00000000..bc325e06
--- /dev/null
+++ b/src/telelco-v0.2-cc1200/ao_pins.h
@@ -0,0 +1,324 @@
+/*
+ * Copyright © 2012 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; either version 2 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, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+#ifndef _AO_PINS_H_
+#define _AO_PINS_H_
+
+/* 8MHz High speed external crystal */
+#define AO_HSE			8000000
+
+/* PLLVCO = 96MHz (so that USB will work) */
+#define AO_PLLMUL		12
+#define AO_RCC_CFGR_PLLMUL	(STM_RCC_CFGR_PLLMUL_12)
+
+#define AO_CC1200_FOSC		32000000
+
+/* SYSCLK = 32MHz (no need to go faster than CPU) */
+#define AO_PLLDIV		3
+#define AO_RCC_CFGR_PLLDIV	(STM_RCC_CFGR_PLLDIV_3)
+
+/* HCLK = 32MHz (CPU clock) */
+#define AO_AHB_PRESCALER	1
+#define AO_RCC_CFGR_HPRE_DIV	STM_RCC_CFGR_HPRE_DIV_1
+
+/* Run APB1 at 16MHz (HCLK/2) */
+#define AO_APB1_PRESCALER	2
+#define AO_RCC_CFGR_PPRE1_DIV	STM_RCC_CFGR_PPRE2_DIV_2
+
+/* Run APB2 at 16MHz (HCLK/2) */
+#define AO_APB2_PRESCALER	2
+#define AO_RCC_CFGR_PPRE2_DIV	STM_RCC_CFGR_PPRE2_DIV_2
+
+#define HAS_EEPROM		1
+#define USE_INTERNAL_FLASH	1
+#define USE_EEPROM_CONFIG	1
+#define USE_STORAGE_CONFIG	0
+#define HAS_USB			1
+#define HAS_BEEP		1
+#define HAS_RADIO		1
+#define HAS_RADIO_RATE		1
+#define HAS_TELEMETRY		0
+#define HAS_AES			1
+#define HAS_STATIC_TEST		0
+
+
+#define HAS_SPI_1		0
+#define SPI_1_PA5_PA6_PA7	0
+#define SPI_1_PB3_PB4_PB5	0
+#define SPI_1_PE13_PE14_PE15	0
+
+#define HAS_SPI_2		1	/* CC1120 */
+#define SPI_2_PB13_PB14_PB15	0
+#define SPI_2_PD1_PD3_PD4	1
+#define SPI_2_GPIO		(&stm_gpiod)
+#define SPI_2_SCK		1
+#define SPI_2_MISO		3
+#define SPI_2_MOSI		4
+#define SPI_2_OSPEEDR		STM_OSPEEDR_10MHz
+
+#define HAS_I2C_1		0
+
+#define HAS_I2C_2		0
+
+#define PACKET_HAS_SLAVE	0
+#define PACKET_HAS_MASTER	0
+
+#define FAST_TIMER_FREQ		10000	/* .1ms for debouncing */
+
+/*
+ * Radio is a cc1200 connected via SPI
+ */
+
+#define AO_RADIO_CAL_DEFAULT 	5695733
+
+#define AO_FEC_DEBUG		0
+#define AO_CC1200_SPI_CS_PORT	(&stm_gpiod)
+#define AO_CC1200_SPI_CS_PIN	0
+#define AO_CC1200_SPI_BUS	AO_SPI_2_PD1_PD3_PD4
+#define AO_CC1200_SPI		stm_spi2
+#define AO_CC1200_SPI_SPEED	AO_SPI_SPEED_FAST
+
+#define AO_CC1200_INT_PORT		(&stm_gpioc)
+#define AO_CC1200_INT_PIN		(15)
+
+#define AO_CC1200_INT_GPIO	2
+#define AO_CC1200_INT_GPIO_IOCFG	CC1200_IOCFG2
+
+#define LOW_LEVEL_DEBUG		0
+
+#define LED_PORT_ENABLE		STM_RCC_AHBENR_GPIOCEN
+#define LED_PORT		(&stm_gpioc)
+#define LED_PIN_RED		7
+#define LED_PIN_AMBER		8
+#define LED_PIN_GREEN		9
+#define LED_PIN_CONTINUITY_3	10
+#define LED_PIN_CONTINUITY_2	11
+#define LED_PIN_CONTINUITY_1	12
+#define LED_PIN_CONTINUITY_0	13
+#define LED_PIN_REMOTE_ARM	14
+#define AO_LED_RED		(1 << LED_PIN_RED)
+#define AO_LED_AMBER		(1 << LED_PIN_AMBER)
+#define AO_LED_GREEN		(1 << LED_PIN_GREEN)
+#define AO_LED_CONTINUITY_3	(1 << LED_PIN_CONTINUITY_3)
+#define AO_LED_CONTINUITY_2	(1 << LED_PIN_CONTINUITY_2)
+#define AO_LED_CONTINUITY_1	(1 << LED_PIN_CONTINUITY_1)
+#define AO_LED_CONTINUITY_0	(1 << LED_PIN_CONTINUITY_0)
+
+#define AO_LED_CONTINUITY_NUM	4
+
+#define AO_LED_REMOTE_ARM	(1 << LED_PIN_REMOTE_ARM)
+
+#define LEDS_AVAILABLE		(AO_LED_RED |		\
+				 AO_LED_AMBER |		\
+				 AO_LED_GREEN |		\
+				 AO_LED_CONTINUITY_3 |	\
+				 AO_LED_CONTINUITY_2 |	\
+				 AO_LED_CONTINUITY_1 |	\
+				 AO_LED_CONTINUITY_0 |	\
+				 AO_LED_REMOTE_ARM)
+
+/* LCD displays */
+
+#define LCD_DEBUG		0
+#define SEVEN_SEGMENT_DEBUG	0
+
+#define AO_LCD_STM_SEG_ENABLED_0 (		\
+		(1 << 0) | /* PA1 */		\
+		(1 << 1) | /* PA2 */		\
+		(1 << 2) | /* PA3 */		\
+		(1 << 3) | /* PA6 */		\
+		(1 << 4) | /* PA7 */		\
+		(1 << 5) | /* PB0 */		\
+		(1 << 6) | /* PB1 */		\
+		(1 << 7) | /* PB3 */		\
+		(1 << 8) | /* PB4 */		\
+		(1 << 9) | /* PB5 */		\
+		(1 << 10) | /* PB10 */		\
+		(1 << 11) | /* PB11 */		\
+		(1 << 12) | /* PB12 */		\
+		(1 << 13) | /* PB13 */		\
+		(1 << 14) | /* PB14 */		\
+		(1 << 15) | /* PB15 */		\
+		(1 << 16) | /* PB8 */		\
+		(1 << 17) | /* PA15 */		\
+		(1 << 18) | /* PC0 */		\
+		(1 << 19) | /* PC1 */		\
+		(1 << 20) | /* PC2 */		\
+		(1 << 21) | /* PC3 */		\
+		(1 << 22) | /* PC4 */		\
+		(1 << 23) | /* PC5 */		\
+		(0 << 24) | /* PC6 */		\
+		(0 << 25) | /* PC7 */		\
+		(0 << 26) | /* PC8 */		\
+		(0 << 27) | /* PC9 */		\
+		(0 << 28) | /* PC10 or PD8 */	\
+		(0 << 29) | /* PC11 or PD9 */	\
+		(0 << 30) | /* PC12 or PD10 */	\
+		(0 << 31))  /* PD2 or PD11 */
+
+#define AO_LCD_STM_SEG_ENABLED_1 (		\
+		(0 << 0) | /* PD12 */		\
+		(0 << 1) | /* PD13 */		\
+		(0 << 2) | /* PD14 */		\
+		(0 << 3) | /* PD15 */		\
+		(0 << 4) | /* PE0 */		\
+		(0 << 5) | /* PE1 */		\
+		(0 << 6) | /* PE2 */		\
+		(0 << 7))  /* PE3 */
+
+#define AO_LCD_STM_COM_ENABLED (		\
+		(1 << 0) | /* PA8 */		\
+		(0 << 1) | /* PA9 */		\
+		(0 << 2) | /* PA10 */		\
+		(0 << 3) | /* PB9 */		\
+		(0 << 4) | /* PC10 */		\
+		(0 << 5) | /* PC11 */		\
+		(0 << 6)) /* PC12 */
+
+#define AO_LCD_28_ON_C	0
+
+#define AO_LCD_DUTY	STM_LCD_CR_DUTY_STATIC
+
+#define AO_LCD_PER_DIGIT	1
+
+#define AO_LCD_DIGITS		3
+#define AO_LCD_SEGMENTS		8
+
+#define AO_SEGMENT_MAP {			\
+		/* pad segments */		\
+		{ 0, 14 },			\
+		{ 0, 13 },			\
+		{ 0, 15 },			\
+		{ 0, 17 },			\
+		{ 0, 16 },			\
+		{ 0, 8 },			\
+		{ 0, 9 },			\
+		{ 0, 7 },			\
+		/* box1 segments */		\
+		{ 0, 10 },			\
+		{ 0, 6 },			\
+		{ 0, 11 },			\
+		{ 0, 12 },			\
+		{ 0, 21 },			\
+		{ 0, 19 },			\
+		{ 0, 20 },			\
+		{ 0, 18 },			\
+		/* box0 segments */		\
+		{ 0, 22 },			\
+		{ 0, 4 },			\
+		{ 0, 23 },			\
+		{ 0, 5 },			\
+		{ 0, 3 },			\
+		{ 0, 1 },			\
+		{ 0, 2 },			\
+		{ 0, 0 },			\
+}
+
+/*
+ * Use event queue for input devices
+ */
+
+#define AO_EVENT		1
+
+/*
+ * Knobs
+ */
+
+#define AO_QUADRATURE_COUNT	2
+
+#define AO_QUADRATURE_0_PORT	&stm_gpioe
+#define AO_QUADRATURE_0_A	3
+#define AO_QUADRATURE_0_B	2
+
+#define AO_QUADRATURE_PAD	0
+
+#define AO_QUADRATURE_1_PORT	&stm_gpioe
+#define AO_QUADRATURE_1_A	1
+#define AO_QUADRATURE_1_B	0
+
+#define AO_QUADRATURE_BOX	1
+#define AO_QUADRATURE_DEBOUNCE	10
+
+/*
+ * Buttons
+ */
+
+#define AO_BUTTON_COUNT		2
+#define AO_BUTTON_MODE		AO_EXTI_MODE_PULL_UP
+
+#define AO_BUTTON_0_PORT	&stm_gpioe
+#define AO_BUTTON_0		4
+
+#define AO_BUTTON_ARM		0
+
+#define AO_BUTTON_1_PORT	&stm_gpioe
+#define AO_BUTTON_1		5
+
+#define AO_BUTTON_FIRE		1
+
+/* ADC */
+
+#define HAS_ADC_SINGLE		1
+#define HAS_BATTERY_REPORT	1
+
+struct ao_adc {
+	int16_t		v_batt;
+	int16_t		temp;
+	int16_t		v_ref;
+};
+
+#if HAS_ADC_SINGLE
+#define AO_ADC_DUMP(p) \
+	printf("batt: %5d temp: %5d v_ref: %5d\n", \
+	       (p)->v_batt, (p)->temp, (p)->v_ref)
+#endif
+#if HAS_ADC
+#define AO_ADC_DUMP(p) \
+	printf("%5d: batt: %5d temp %5d v_ref %5d\n", \
+	       (p)->tick, (p)->adc.v_batt, (p)->adc.temp, (p)->adc.v_ref)
+#endif
+
+#define HAS_ADC_TEMP		1
+
+#define AO_ADC_V_BATT		0
+#define AO_ADC_V_BATT_PORT	(&stm_gpioa)
+#define AO_ADC_V_BATT_PIN	0
+
+#define AO_ADC_RCC_AHBENR	(1 << STM_RCC_AHBENR_GPIOAEN)
+
+#define AO_ADC_PIN0_PORT	AO_ADC_V_BATT_PORT
+#define AO_ADC_PIN0_PIN		AO_ADC_V_BATT_PIN
+
+#define AO_ADC_SQ1		AO_ADC_V_BATT
+#define AO_ADC_SQ2		STM_ADC_SQ_TEMP
+#define AO_ADC_SQ3		STM_ADC_SQ_V_REF
+
+#define AO_NUM_ADC		3
+
+/*
+ * Voltage divider on ADC battery sampler
+ */
+#define AO_BATTERY_DIV_PLUS	15	/* 15k */
+#define AO_BATTERY_DIV_MINUS	27	/* 27k */
+
+/*
+ * ADC reference in decivolts
+ */
+#define AO_ADC_REFERENCE_DV	33
+
+#endif /* _AO_PINS_H_ */
diff --git a/src/telelco-v0.2-cc1200/ao_telelco.c b/src/telelco-v0.2-cc1200/ao_telelco.c
new file mode 100644
index 00000000..3266da00
--- /dev/null
+++ b/src/telelco-v0.2-cc1200/ao_telelco.c
@@ -0,0 +1,79 @@
+/*
+ * Copyright © 2011 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; either version 2 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, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+#include <ao.h>
+#include <ao_exti.h>
+#include <ao_packet.h>
+#include <ao_companion.h>
+#include <ao_profile.h>
+#include <ao_pyro.h>
+#include <ao_aes.h>
+#include <ao_seven_segment.h>
+#include <ao_quadrature.h>
+#include <ao_button.h>
+#include <ao_lco.h>
+#include <ao_lco_cmd.h>
+#include <ao_radio_cmac_cmd.h>
+#include <ao_eeprom.h>
+#if HAS_ADC_SINGLE
+#include <ao_adc_single.h>
+#endif
+#if HAS_ADC
+#include <ao_adc.h>
+#endif
+
+int
+main(void)
+{
+	ao_clock_init();
+	ao_task_init();
+	ao_timer_init();
+	ao_dma_init();
+
+	ao_led_init(LEDS_AVAILABLE);
+	ao_led_on(AO_LED_GREEN);
+
+
+	ao_spi_init();
+	ao_exti_init();
+
+	ao_beep_init();
+	ao_cmd_init();
+
+	ao_lcd_stm_init();
+	ao_seven_segment_init();
+	ao_quadrature_init();
+	ao_button_init();
+
+	ao_adc_single_init();
+
+	ao_eeprom_init();
+
+	ao_radio_init();
+
+	ao_usb_init();
+
+	ao_config_init();
+
+	ao_lco_init();
+	ao_lco_cmd_init();
+//	ao_radio_cmac_cmd_init();
+
+	ao_start_scheduler();
+	return 0;
+}
diff --git a/src/telelco-v0.2-cc1200/flash-loader/.gitignore b/src/telelco-v0.2-cc1200/flash-loader/.gitignore
new file mode 100644
index 00000000..a32ec26e
--- /dev/null
+++ b/src/telelco-v0.2-cc1200/flash-loader/.gitignore
@@ -0,0 +1,2 @@
+ao_product.h
+telelco*.elf
diff --git a/src/telelco-v0.2-cc1200/flash-loader/Makefile b/src/telelco-v0.2-cc1200/flash-loader/Makefile
new file mode 100644
index 00000000..679e61ba
--- /dev/null
+++ b/src/telelco-v0.2-cc1200/flash-loader/Makefile
@@ -0,0 +1,8 @@
+#
+# AltOS flash loader build
+#
+#
+
+TOPDIR=../..
+HARDWARE=telelco-v0.2
+include $(TOPDIR)/stm/Makefile-flash.defs
diff --git a/src/telelco-v0.2-cc1200/flash-loader/ao_pins.h b/src/telelco-v0.2-cc1200/flash-loader/ao_pins.h
new file mode 100644
index 00000000..72f840c0
--- /dev/null
+++ b/src/telelco-v0.2-cc1200/flash-loader/ao_pins.h
@@ -0,0 +1,35 @@
+/*
+ * 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; either version 2 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, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+#ifndef _AO_PINS_H_
+#define _AO_PINS_H_
+
+/* External crystal at 8MHz */
+#define AO_HSE		8000000
+
+#include <ao_flash_stm_pins.h>
+
+/* Arm switch. Press at power on to get boot loader */
+
+#define AO_BOOT_PIN		1
+#define AO_BOOT_APPLICATION_GPIO	stm_gpioe
+#define AO_BOOT_APPLICATION_PIN		4
+#define AO_BOOT_APPLICATION_VALUE	1
+#define AO_BOOT_APPLICATION_MODE	AO_EXTI_MODE_PULL_UP
+
+#endif /* _AO_PINS_H_ */
diff --git a/src/telelco-v0.2/Makefile b/src/telelco-v0.2/Makefile
index 8c1ced6c..8279cac1 100644
--- a/src/telelco-v0.2/Makefile
+++ b/src/telelco-v0.2/Makefile
@@ -64,6 +64,7 @@ ALTOS_SRC = \
 	ao_button.c \
 	ao_event.c \
 	ao_lco.c \
+	ao_lco_bits.c \
 	ao_lco_cmd.c \
 	ao_lco_func.c \
 	ao_radio_cmac_cmd.c
diff --git a/src/telelco-v0.2/ao_pins.h b/src/telelco-v0.2/ao_pins.h
index b90fca8b..f0da4fe4 100644
--- a/src/telelco-v0.2/ao_pins.h
+++ b/src/telelco-v0.2/ao_pins.h
@@ -253,6 +253,7 @@
 #define AO_QUADRATURE_1_B	0
 
 #define AO_QUADRATURE_BOX	1
+#define AO_QUADRATURE_DEBOUNCE	10
 
 /*
  * Buttons
diff --git a/src/telelco-v0.3/Makefile b/src/telelco-v0.3/Makefile
index 0bb0f9dc..c2592bf8 100644
--- a/src/telelco-v0.3/Makefile
+++ b/src/telelco-v0.3/Makefile
@@ -65,6 +65,7 @@ ALTOS_SRC = \
 	ao_button.c \
 	ao_event.c \
 	ao_lco.c \
+	ao_lco_bits.c \
 	ao_lco_cmd.c \
 	ao_lco_func.c \
 	ao_radio_cmac_cmd.c
diff --git a/src/telelco-v0.3/ao_pins.h b/src/telelco-v0.3/ao_pins.h
index dd4aaafb..6023739c 100644
--- a/src/telelco-v0.3/ao_pins.h
+++ b/src/telelco-v0.3/ao_pins.h
@@ -54,6 +54,8 @@
 #define HAS_RADIO_RATE		1
 #define HAS_TELEMETRY		0
 #define HAS_AES			1
+#define HAS_STATIC_TEST		0
+
 
 #define HAS_SPI_1		0
 #define SPI_1_PA5_PA6_PA7	0
@@ -250,6 +252,7 @@
 #define AO_QUADRATURE_1_B	0
 
 #define AO_QUADRATURE_BOX	1
+#define AO_QUADRATURE_DEBOUNCE	10
 
 /*
  * Buttons
diff --git a/src/telelco-v2.0/.gitignore b/src/telelco-v2.0/.gitignore
new file mode 100644
index 00000000..a32ec26e
--- /dev/null
+++ b/src/telelco-v2.0/.gitignore
@@ -0,0 +1,2 @@
+ao_product.h
+telelco*.elf
diff --git a/src/telelco-v2.0/Makefile b/src/telelco-v2.0/Makefile
new file mode 100644
index 00000000..43295fd3
--- /dev/null
+++ b/src/telelco-v2.0/Makefile
@@ -0,0 +1,106 @@
+#
+# AltOS build for TeleLCO v2.0
+#
+#
+
+include ../stm/Makefile.defs
+
+INC = \
+	ao.h \
+	ao_arch.h \
+	ao_arch_funcs.h \
+	ao_boot.h \
+	ao_companion.h \
+	ao_data.h \
+	ao_sample.h \
+	ao_pins.h \
+	ao_product.h \
+	ao_seven_segment.h \
+	ao_lco.h \
+	ao_lco_cmd.h \
+	ao_lco_func.h \
+	ao_radio_spi.h \
+	ao_radio_cmac.h \
+	ao_cc1200_CC1200.h \
+	ao_cc1200.h \
+	stm32l.h
+
+#
+# Common AltOS sources
+#
+
+#PROFILE=ao_profile.c
+#PROFILE_DEF=-DAO_PROFILE=1
+
+ALTOS_SRC = \
+	ao_boot_chain.c \
+	ao_interrupt.c \
+	ao_product.c \
+	ao_romconfig.c \
+	ao_cmd.c \
+	ao_config.c \
+	ao_task.c \
+	ao_led.c \
+	ao_stdio.c \
+	ao_panic.c \
+	ao_timer.c \
+	ao_mutex.c \
+	ao_freq.c \
+	ao_dma_stm.c \
+	ao_spi_stm.c \
+	ao_beep_stm.c \
+	ao_eeprom_stm.c \
+	ao_adc_single_stm.c \
+	ao_convert_volt.c \
+	ao_fast_timer.c \
+	ao_lcd_stm.c \
+	ao_usb_stm.c \
+	ao_exti_stm.c \
+	ao_cc1200.c \
+	ao_radio_cmac.c \
+	ao_aes.c \
+	ao_aes_tables.c \
+	ao_fec_tx.c \
+	ao_fec_rx.c \
+	ao_seven_segment.c \
+	ao_quadrature.c \
+	ao_button.c \
+	ao_event.c \
+	ao_lco_bits.c \
+	ao_lco_v2.c \
+	ao_lco_cmd.c \
+	ao_lco_func.c \
+	ao_radio_cmac_cmd.c
+
+PRODUCT=TeleLCO-v2.0
+PRODUCT_DEF=-DTELELCO
+IDPRODUCT=0x0023
+
+CFLAGS = $(PRODUCT_DEF) $(STM_CFLAGS) $(PROFILE_DEF) -Os -g
+
+PROGNAME=telelco-v2.0
+PROG=$(PROGNAME)-$(VERSION).elf
+HEX=$(PROGNAME)-$(VERSION).ihx
+
+SRC=$(ALTOS_SRC) ao_telelco.c
+OBJ=$(SRC:.c=.o)
+
+all: $(PROG) $(HEX)
+
+$(PROG): Makefile $(OBJ) altos.ld
+	$(call quiet,CC) $(LDFLAGS) $(CFLAGS) -o $(PROG) $(OBJ) $(LIBS)
+
+$(OBJ): $(INC)
+
+ao_product.h: ao-make-product.5c ../Version
+	$(call quiet,NICKLE,$<) $< -m altusmetrum.org -i $(IDPRODUCT) -p $(PRODUCT) -v $(VERSION) > $@
+
+distclean:	clean
+
+clean:
+	rm -f *.o $(PROGNAME)-*.elf $(PROGNAME)-*.ihx
+	rm -f ao_product.h
+
+install:
+
+uninstall:
diff --git a/src/telelco-v2.0/ao_lco_v2.c b/src/telelco-v2.0/ao_lco_v2.c
new file mode 100644
index 00000000..a9933d59
--- /dev/null
+++ b/src/telelco-v2.0/ao_lco_v2.c
@@ -0,0 +1,304 @@
+/*
+ * Copyright © 2012 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; either version 2 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, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+#include <ao.h>
+#include <ao_lco.h>
+#include <ao_event.h>
+#include <ao_seven_segment.h>
+#include <ao_quadrature.h>
+#include <ao_radio_cmac.h>
+#include <ao_adc_single.h>
+
+#define AO_LCO_PAD_DIGIT	0
+#define AO_LCO_BOX_DIGIT_1	1
+#define AO_LCO_BOX_DIGIT_10	2
+
+#define AO_LCO_DRAG_RACE_START_TIME	AO_SEC_TO_TICKS(5)
+#define AO_LCO_DRAG_RACE_STOP_TIME	AO_SEC_TO_TICKS(2)
+
+/* UI values */
+static uint8_t	ao_lco_select_mode;
+#define AO_LCO_SELECT_PAD	0
+#define AO_LCO_SELECT_BOX	1
+
+static uint8_t	ao_lco_display_mutex;
+
+void
+ao_lco_show_pad(uint8_t pad)
+{
+	ao_mutex_get(&ao_lco_display_mutex);
+	ao_seven_segment_set(AO_LCO_PAD_DIGIT, pad | (ao_lco_drag_race << 4));
+	ao_mutex_put(&ao_lco_display_mutex);
+}
+
+#define SEVEN_SEGMENT_d		((0 << 0) |	\
+				 (0 << 1) |	\
+				 (1 << 2) |	\
+				 (1 << 3) |	\
+				 (1 << 4) |	\
+				 (1 << 5) |	\
+				 (1 << 6))
+
+
+#define SEVEN_SEGMENT_r		((0 << 0) |	\
+				 (0 << 1) |	\
+				 (0 << 2) |	\
+				 (1 << 3) |	\
+				 (1 << 4) |	\
+				 (0 << 5) |	\
+				 (0 << 6))
+
+void
+ao_lco_show_box(uint16_t box)
+{
+	ao_mutex_get(&ao_lco_display_mutex);
+	ao_seven_segment_set(AO_LCO_BOX_DIGIT_1, box % 10 | (ao_lco_drag_race << 4));
+	ao_seven_segment_set(AO_LCO_BOX_DIGIT_10, box / 10 | (ao_lco_drag_race << 4));
+	ao_mutex_put(&ao_lco_display_mutex);
+}
+
+static void
+ao_lco_show_voltage(uint16_t decivolts)
+{
+	uint8_t	tens, ones, tenths;
+
+	PRINTD("voltage %d\n", decivolts);
+	tenths = decivolts % 10;
+	ones = (decivolts / 10) % 10;
+	tens = (decivolts / 100) % 10;
+	ao_mutex_get(&ao_lco_display_mutex);
+	ao_seven_segment_set(AO_LCO_PAD_DIGIT, tenths);
+	ao_seven_segment_set(AO_LCO_BOX_DIGIT_1, ones | 0x10);
+	ao_seven_segment_set(AO_LCO_BOX_DIGIT_10, tens);
+	ao_mutex_put(&ao_lco_display_mutex);
+}
+
+void
+ao_lco_show(void)
+{
+	if (ao_lco_pad == AO_LCO_PAD_VOLTAGE) {
+		ao_lco_show_voltage(ao_pad_query.battery);
+	} else {
+		ao_lco_show_pad(ao_lco_pad);
+		ao_lco_show_box(ao_lco_box);
+	}
+}
+
+uint8_t
+ao_lco_box_present(uint16_t box)
+{
+	if (box >= AO_PAD_MAX_BOXES)
+		return 0;
+	return (ao_lco_box_mask[AO_LCO_MASK_ID(box)] >> AO_LCO_MASK_SHIFT(box)) & 1;
+}
+
+static void
+ao_lco_set_select(void)
+{
+	if (ao_lco_armed) {
+		ao_led_off(AO_LED_PAD);
+		ao_led_off(AO_LED_BOX);
+	} else {
+		switch (ao_lco_select_mode) {
+		case AO_LCO_SELECT_PAD:
+			ao_led_off(AO_LED_BOX);
+			ao_led_on(AO_LED_PAD);
+			break;
+		case AO_LCO_SELECT_BOX:
+			ao_led_off(AO_LED_PAD);
+			ao_led_on(AO_LED_BOX);
+			break;
+		default:
+			break;
+		}
+	}
+}
+
+static void
+ao_lco_step_box(int8_t dir)
+{
+	int16_t new_box = ao_lco_box;
+
+	do {
+		new_box += dir;
+		if (new_box > ao_lco_max_box)
+			new_box = ao_lco_min_box;
+		else if (new_box < ao_lco_min_box)
+			new_box = ao_lco_max_box;
+		if (new_box == ao_lco_box)
+			break;
+	} while (!ao_lco_box_present(new_box));
+	ao_lco_set_box(new_box);
+}
+
+static struct ao_task	ao_lco_drag_task;
+
+static void
+ao_lco_drag_monitor(void)
+{
+	uint16_t	delay = ~0;
+	uint16_t	now;
+
+	ao_beep_for(AO_BEEP_MID, AO_MS_TO_TICKS(200));
+	for (;;) {
+		PRINTD("Drag monitor count %d delay %d\n", ao_lco_drag_beep_count, delay);
+		if (delay == (uint16_t) ~0)
+			ao_sleep(&ao_lco_drag_beep_count);
+		else
+			ao_sleep_for(&ao_lco_drag_beep_count, delay);
+
+		delay = ~0;
+		now = ao_time();
+		delay = ao_lco_drag_warn_check(now, delay);
+		delay = ao_lco_drag_beep_check(now, delay);
+	}
+}
+
+static void
+ao_lco_input(void)
+{
+	static struct ao_event	event;
+
+	for (;;) {
+		ao_event_get(&event);
+		PRINTD("event type %d unit %d value %d\n",
+		       event.type, event.unit, event.value);
+		switch (event.type) {
+		case AO_EVENT_QUADRATURE:
+			switch (event.unit) {
+			case AO_QUADRATURE_SELECT:
+				if (!ao_lco_armed) {
+					switch (ao_lco_select_mode) {
+					case AO_LCO_SELECT_PAD:
+						ao_lco_step_pad((int8_t) event.value);
+						break;
+					case AO_LCO_SELECT_BOX:
+						ao_lco_step_box((int8_t) event.value);
+						break;
+					default:
+						break;
+					}
+				}
+				break;
+			}
+			break;
+		case AO_EVENT_BUTTON:
+			switch (event.unit) {
+			case AO_BUTTON_ARM:
+				ao_lco_set_armed(event.value);
+				ao_lco_set_select();
+				break;
+			case AO_BUTTON_FIRE:
+				if (ao_lco_armed)
+					ao_lco_set_firing(event.value);
+				break;
+			case AO_BUTTON_DRAG_SELECT:
+				if (event.value)
+					ao_lco_toggle_drag();
+				break;
+			case AO_BUTTON_DRAG_MODE:
+				if (event.value)
+					ao_lco_drag_enable();
+				else
+					ao_lco_drag_disable();
+				break;
+			case AO_BUTTON_ENCODER_SELECT:
+				if (event.value) {
+					if (!ao_lco_armed) {
+						ao_lco_select_mode = 1 - ao_lco_select_mode;
+						ao_lco_set_select();
+					}
+				}
+				break;
+			}
+			break;
+		}
+	}
+}
+
+/*
+ * Light up everything for a second at power on to let the user
+ * visually inspect the system for correct operation
+ */
+static void
+ao_lco_display_test()
+{
+	ao_mutex_get(&ao_lco_display_mutex);
+	ao_seven_segment_set(AO_LCO_PAD_DIGIT, 8 | 0x10);
+	ao_seven_segment_set(AO_LCO_BOX_DIGIT_1, 8 | 0x10);
+	ao_seven_segment_set(AO_LCO_BOX_DIGIT_10, 8 | 0x10);
+	ao_mutex_put(&ao_lco_display_mutex);
+	ao_led_on(LEDS_AVAILABLE);
+	ao_delay(AO_MS_TO_TICKS(1000));
+	ao_led_off(LEDS_AVAILABLE);
+}
+
+static void
+ao_lco_batt_voltage(void)
+{
+	struct ao_adc	packet;
+	int16_t		decivolt;
+
+	ao_adc_single_get(&packet);
+	decivolt = ao_battery_decivolt(packet.v_batt);
+	ao_lco_show_voltage(decivolt);
+	ao_delay(AO_MS_TO_TICKS(1000));
+}
+
+static struct ao_task ao_lco_input_task;
+static struct ao_task ao_lco_monitor_task;
+static struct ao_task ao_lco_arm_warn_task;
+static struct ao_task ao_lco_igniter_status_task;
+
+static void
+ao_lco_main(void)
+{
+	ao_lco_display_test();
+	ao_lco_batt_voltage();
+	ao_lco_search();
+	ao_add_task(&ao_lco_input_task, ao_lco_input, "lco input");
+	ao_add_task(&ao_lco_arm_warn_task, ao_lco_arm_warn, "lco arm warn");
+	ao_add_task(&ao_lco_igniter_status_task, ao_lco_igniter_status, "lco igniter status");
+	ao_add_task(&ao_lco_drag_task, ao_lco_drag_monitor, "drag race");
+	ao_lco_monitor();
+}
+
+#if DEBUG
+void
+ao_lco_set_debug(void)
+{
+	ao_cmd_decimal();
+	if (ao_cmd_status == ao_cmd_success)
+		ao_lco_debug = ao_cmd_lex_i != 0;
+}
+
+__code struct ao_cmds ao_lco_cmds[] = {
+	{ ao_lco_set_debug,	"D <0 off, 1 on>\0Debug" },
+	{ ao_lco_search,	"s\0Search for pad boxes" },
+	{ 0, NULL }
+};
+#endif
+
+void
+ao_lco_init(void)
+{
+	ao_add_task(&ao_lco_monitor_task, ao_lco_main, "lco monitor");
+#if DEBUG
+	ao_cmd_register(&ao_lco_cmds[0]);
+#endif
+}
diff --git a/src/telelco-v2.0/ao_pins.h b/src/telelco-v2.0/ao_pins.h
new file mode 100644
index 00000000..95998dc7
--- /dev/null
+++ b/src/telelco-v2.0/ao_pins.h
@@ -0,0 +1,398 @@
+/*
+ * Copyright © 2012 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; either version 2 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, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+#ifndef _AO_PINS_H_
+#define _AO_PINS_H_
+
+/* 8MHz High speed external crystal */
+#define AO_HSE			8000000
+
+/* PLLVCO = 96MHz (so that USB will work) */
+#define AO_PLLMUL		12
+#define AO_RCC_CFGR_PLLMUL	(STM_RCC_CFGR_PLLMUL_12)
+
+#define AO_CC1200_FOSC		40000000
+
+/* SYSCLK = 32MHz (no need to go faster than CPU) */
+#define AO_PLLDIV		3
+#define AO_RCC_CFGR_PLLDIV	(STM_RCC_CFGR_PLLDIV_3)
+
+/* HCLK = 32MHz (CPU clock) */
+#define AO_AHB_PRESCALER	1
+#define AO_RCC_CFGR_HPRE_DIV	STM_RCC_CFGR_HPRE_DIV_1
+
+/* Run APB1 at 16MHz (HCLK/2) */
+#define AO_APB1_PRESCALER	2
+#define AO_RCC_CFGR_PPRE1_DIV	STM_RCC_CFGR_PPRE2_DIV_2
+
+/* Run APB2 at 16MHz (HCLK/2) */
+#define AO_APB2_PRESCALER	2
+#define AO_RCC_CFGR_PPRE2_DIV	STM_RCC_CFGR_PPRE2_DIV_2
+
+#define HAS_EEPROM		1
+#define USE_INTERNAL_FLASH	1
+#define USE_EEPROM_CONFIG	1
+#define USE_STORAGE_CONFIG	0
+#define HAS_USB			1
+#define HAS_BEEP		1
+#define HAS_RADIO		1
+#define HAS_RADIO_RATE		1
+#define HAS_TELEMETRY		0
+#define HAS_AES			1
+#define HAS_STATIC_TEST		0
+
+#define HAS_SPI_1		0
+#define SPI_1_PA5_PA6_PA7	0
+#define SPI_1_PB3_PB4_PB5	0
+#define SPI_1_PE13_PE14_PE15	0
+
+#define HAS_SPI_2		1	/* CC1200 */
+#define SPI_2_PB13_PB14_PB15	0
+#define SPI_2_PD1_PD3_PD4	1
+#define SPI_2_GPIO		(&stm_gpiod)
+#define SPI_2_SCK		1
+#define SPI_2_MISO		3
+#define SPI_2_MOSI		4
+#define SPI_2_OSPEEDR		STM_OSPEEDR_10MHz
+
+#define HAS_I2C_1		0
+
+#define HAS_I2C_2		0
+
+#define PACKET_HAS_SLAVE	0
+#define PACKET_HAS_MASTER	0
+
+#define FAST_TIMER_FREQ		10000	/* .1ms for debouncing */
+
+/*
+ * Radio is a cc1200 connected via SPI
+ */
+
+#define AO_RADIO_CAL_DEFAULT 	5695733
+
+#define AO_CC1200_SPI_CS_PORT	(&stm_gpiod)
+#define AO_CC1200_SPI_CS_PIN	0
+#define AO_CC1200_SPI_BUS	AO_SPI_2_PD1_PD3_PD4
+#define AO_CC1200_SPI		stm_spi2
+#define AO_CC1200_SPI_SPEED	AO_SPI_SPEED_FAST
+
+#define AO_CC1200_INT_PORT		(&stm_gpiod)
+#define AO_CC1200_INT_PIN		(5)
+
+#define AO_CC1200_INT_GPIO	2
+#define AO_CC1200_INT_GPIO_IOCFG	CC1200_IOCFG2
+
+#define LOW_LEVEL_DEBUG		0
+
+#define LED_PER_LED		1
+#define LED_TYPE		uint16_t
+
+#define LED_ENABLE_BITS		((1 << STM_RCC_AHBENR_GPIOAEN) |	\
+				 (1 << STM_RCC_AHBENR_GPIOCEN) |	\
+				 (1 << STM_RCC_AHBENR_GPIODEN) |	\
+				 (1 << STM_RCC_AHBENR_GPIOEEN))
+
+/* PC7 - PC9, LED 0 - 2 */
+#define LED_0_PORT		(&stm_gpioc)
+#define LED_0_PIN		7
+#define LED_1_PORT		(&stm_gpioc)
+#define LED_1_PIN		8
+#define LED_2_PORT		(&stm_gpioc)
+#define LED_2_PIN		9
+
+/* PD8 - PD10, LED 3 - 5 */
+#define LED_3_PORT		(&stm_gpiod)
+#define LED_3_PIN		8
+#define LED_4_PORT		(&stm_gpiod)
+#define LED_4_PIN		9
+#define LED_5_PORT		(&stm_gpiod)
+#define LED_5_PIN		10
+
+/* PE2 - PE11 (not PE6), LED 6-14 */
+#define LED_6_PORT		(&stm_gpioe)
+#define LED_6_PIN		2
+#define LED_7_PORT		(&stm_gpioe)
+#define LED_7_PIN		3
+#define LED_8_PORT		(&stm_gpioe)
+#define LED_8_PIN		4
+#define LED_9_PORT		(&stm_gpioe)
+#define LED_9_PIN		5
+#define LED_10_PORT		(&stm_gpioe)
+#define LED_10_PIN		7
+#define LED_11_PORT		(&stm_gpioe)
+#define LED_11_PIN		8
+#define LED_12_PORT		(&stm_gpioe)
+#define LED_12_PIN		9
+#define LED_13_PORT		(&stm_gpioe)
+#define LED_13_PIN		10
+#define LED_14_PORT		(&stm_gpioe)
+#define LED_14_PIN		11
+
+/* PA5, LED 15 */
+#define LED_15_PORT		(&stm_gpioa)
+#define LED_15_PIN		5
+
+#define LED_PIN_RED		0
+#define LED_PIN_AMBER		1
+#define LED_PIN_GREEN		2
+#define LED_PIN_BOX		3
+#define LED_PIN_PAD		4
+#define LED_PIN_DRAG		5
+#define LED_PIN_CONTINUITY_7	6
+#define LED_PIN_CONTINUITY_6	7
+#define LED_PIN_CONTINUITY_5	8
+#define LED_PIN_CONTINUITY_4	9
+#define LED_PIN_CONTINUITY_3	10
+#define LED_PIN_CONTINUITY_2	11
+#define LED_PIN_CONTINUITY_1	12
+#define LED_PIN_CONTINUITY_0	13
+#define LED_PIN_REMOTE_ARM	14
+#define LED_PIN_FIRE		15
+#define AO_LED_RED		(1 << LED_PIN_RED)
+#define AO_LED_AMBER		(1 << LED_PIN_AMBER)
+#define AO_LED_GREEN		(1 << LED_PIN_GREEN)
+#define AO_LED_BOX		(1 << LED_PIN_BOX)
+#define AO_LED_PAD		(1 << LED_PIN_PAD)
+#define AO_LED_DRAG		(1 << LED_PIN_DRAG)
+#define AO_LED_CONTINUITY_7	(1 << LED_PIN_CONTINUITY_7)
+#define AO_LED_CONTINUITY_6	(1 << LED_PIN_CONTINUITY_6)
+#define AO_LED_CONTINUITY_5	(1 << LED_PIN_CONTINUITY_5)
+#define AO_LED_CONTINUITY_4	(1 << LED_PIN_CONTINUITY_4)
+#define AO_LED_CONTINUITY_3	(1 << LED_PIN_CONTINUITY_3)
+#define AO_LED_CONTINUITY_2	(1 << LED_PIN_CONTINUITY_2)
+#define AO_LED_CONTINUITY_1	(1 << LED_PIN_CONTINUITY_1)
+#define AO_LED_CONTINUITY_0	(1 << LED_PIN_CONTINUITY_0)
+#define AO_LED_CONTINUITY_NUM	8
+#define AO_LED_REMOTE_ARM	(1 << LED_PIN_REMOTE_ARM)
+#define AO_LED_FIRE		(1 << LED_PIN_FIRE)
+
+#define LEDS_AVAILABLE		(AO_LED_RED |		\
+				 AO_LED_AMBER |		\
+				 AO_LED_GREEN |		\
+				 AO_LED_BOX |		\
+				 AO_LED_PAD |		\
+				 AO_LED_DRAG |		\
+				 AO_LED_CONTINUITY_7 |	\
+				 AO_LED_CONTINUITY_6 |	\
+				 AO_LED_CONTINUITY_5 |	\
+				 AO_LED_CONTINUITY_4 |	\
+				 AO_LED_CONTINUITY_3 |	\
+				 AO_LED_CONTINUITY_2 |	\
+				 AO_LED_CONTINUITY_1 |	\
+				 AO_LED_CONTINUITY_0 |	\
+				 AO_LED_REMOTE_ARM |	\
+				 AO_LED_FIRE)
+
+/* LCD displays */
+
+#define LCD_DEBUG		0
+#define SEVEN_SEGMENT_DEBUG	0
+
+#define AO_LCD_STM_SEG_ENABLED_0 (		\
+		(1 << 0) | /* PA1 */		\
+		(1 << 1) | /* PA2 */		\
+		(1 << 2) | /* PA3 */		\
+		(1 << 3) | /* PA6 */		\
+		(1 << 4) | /* PA7 */		\
+		(1 << 5) | /* PB0 */		\
+		(1 << 6) | /* PB1 */		\
+		(1 << 7) | /* PB3 */		\
+		(1 << 8) | /* PB4 */		\
+		(1 << 9) | /* PB5 */		\
+		(1 << 10) | /* PB10 */		\
+		(1 << 11) | /* PB11 */		\
+		(1 << 12) | /* PB12 */		\
+		(1 << 13) | /* PB13 */		\
+		(1 << 14) | /* PB14 */		\
+		(1 << 15) | /* PB15 */		\
+		(1 << 16) | /* PB8 */		\
+		(1 << 17) | /* PA15 */		\
+		(1 << 18) | /* PC0 */		\
+		(1 << 19) | /* PC1 */		\
+		(1 << 20) | /* PC2 */		\
+		(1 << 21) | /* PC3 */		\
+		(1 << 22) | /* PC4 */		\
+		(1 << 23) | /* PC5 */		\
+		(0 << 24) | /* PC6 */		\
+		(0 << 25) | /* PC7 */		\
+		(0 << 26) | /* PC8 */		\
+		(0 << 27) | /* PC9 */		\
+		(0 << 28) | /* PC10 or PD8 */	\
+		(0 << 29) | /* PC11 or PD9 */	\
+		(0 << 30) | /* PC12 or PD10 */	\
+		(0 << 31))  /* PD2 or PD11 */
+
+#define AO_LCD_STM_SEG_ENABLED_1 (		\
+		(0 << 0) | /* PD12 */		\
+		(0 << 1) | /* PD13 */		\
+		(0 << 2) | /* PD14 */		\
+		(0 << 3) | /* PD15 */		\
+		(0 << 4) | /* PE0 */		\
+		(0 << 5) | /* PE1 */		\
+		(0 << 6) | /* PE2 */		\
+		(0 << 7))  /* PE3 */
+
+#define AO_LCD_STM_COM_ENABLED (		\
+		(1 << 0) | /* PA8 */		\
+		(0 << 1) | /* PA9 */		\
+		(0 << 2) | /* PA10 */		\
+		(0 << 3) | /* PB9 */		\
+		(0 << 4) | /* PC10 */		\
+		(0 << 5) | /* PC11 */		\
+		(0 << 6)) /* PC12 */
+
+#define AO_LCD_28_ON_C	0
+
+#define AO_LCD_DUTY	STM_LCD_CR_DUTY_STATIC
+
+#define AO_LCD_PER_DIGIT	1
+
+#define AO_LCD_DIGITS		3
+#define AO_LCD_SEGMENTS		8
+
+#define AO_SEGMENT_MAP {			\
+		/* pad segments */		\
+		{ 0, 14 },			\
+		{ 0, 13 },			\
+		{ 0, 15 },			\
+		{ 0, 17 },			\
+		{ 0, 16 },			\
+		{ 0, 8 },			\
+		{ 0, 9 },			\
+		{ 0, 7 },			\
+		/* box1 segments */		\
+		{ 0, 10 },			\
+		{ 0, 6 },			\
+		{ 0, 11 },			\
+		{ 0, 12 },			\
+		{ 0, 21 },			\
+		{ 0, 19 },			\
+		{ 0, 20 },			\
+		{ 0, 18 },			\
+		/* box0 segments */		\
+		{ 0, 22 },			\
+		{ 0, 4 },			\
+		{ 0, 23 },			\
+		{ 0, 5 },			\
+		{ 0, 3 },			\
+		{ 0, 1 },			\
+		{ 0, 2 },			\
+		{ 0, 0 },			\
+}
+
+/*
+ * Use event queue for input devices
+ */
+
+#define AO_EVENT		1
+
+/*
+ * Knobs
+ */
+
+#define AO_QUADRATURE_COUNT	1
+#define AO_QUADRATURE_DEBOUNCE	0
+#define AO_QUADRATURE_SINGLE_CODE	1
+
+#define AO_QUADRATURE_0_PORT	&stm_gpioe
+#define AO_QUADRATURE_0_A	15
+#define AO_QUADRATURE_0_B	14
+
+#define AO_QUADRATURE_SELECT	0
+
+/*
+ * Buttons
+ */
+
+#define AO_BUTTON_COUNT		9
+#define AO_BUTTON_MODE		AO_EXTI_MODE_PULL_UP
+
+#define AO_BUTTON_DRAG_MODE	0
+#define AO_BUTTON_0_PORT	&stm_gpioe
+#define AO_BUTTON_0		1
+
+#define AO_BUTTON_DRAG_SELECT	1
+#define AO_BUTTON_1_PORT	&stm_gpioe
+#define AO_BUTTON_1		0
+
+#define AO_BUTTON_SPARE1       	2
+#define AO_BUTTON_2_PORT	&stm_gpiob
+#define AO_BUTTON_2		9
+
+#define AO_BUTTON_SPARE2      	3
+#define AO_BUTTON_3_PORT	&stm_gpiob
+#define AO_BUTTON_3		7
+
+#define AO_BUTTON_SPARE3       	4
+#define AO_BUTTON_4_PORT	&stm_gpiob
+#define AO_BUTTON_4		6
+
+#define AO_BUTTON_ARM		5
+#define AO_BUTTON_5_PORT	&stm_gpioe
+#define AO_BUTTON_5		12
+
+#define AO_BUTTON_FIRE		6
+#define AO_BUTTON_6_PORT	&stm_gpioa
+#define AO_BUTTON_6		4
+
+#define AO_BUTTON_SPARE4	7
+#define AO_BUTTON_7_PORT	&stm_gpiod
+#define AO_BUTTON_7		11
+
+#define AO_BUTTON_ENCODER_SELECT	8
+#define AO_BUTTON_8_PORT	&stm_gpioe
+#define AO_BUTTON_8		13
+
+/* ADC */
+
+struct ao_adc {
+	int16_t		v_batt;
+};
+
+#define AO_ADC_DUMP(p) \
+	printf("batt: %5d\n", (p)->v_batt)
+
+#define HAS_ADC_SINGLE		1
+#define HAS_ADC_TEMP		0
+#define HAS_BATTERY_REPORT	1
+
+#define AO_ADC_V_BATT		0
+#define AO_ADC_V_BATT_PORT	(&stm_gpioa)
+#define AO_ADC_V_BATT_PIN	0
+
+#define AO_ADC_RCC_AHBENR	(1 << STM_RCC_AHBENR_GPIOAEN)
+
+#define AO_ADC_PIN0_PORT	AO_ADC_V_BATT_PORT
+#define AO_ADC_PIN0_PIN		AO_ADC_V_BATT_PIN
+
+#define AO_ADC_SQ1		AO_ADC_V_BATT
+
+#define AO_NUM_ADC		1
+
+/*
+ * Voltage divider on ADC battery sampler
+ */
+#define AO_BATTERY_DIV_PLUS	15	/* 15k */
+#define AO_BATTERY_DIV_MINUS	27	/* 27k */
+
+/*
+ * ADC reference in decivolts
+ */
+#define AO_ADC_REFERENCE_DV	33
+
+#endif /* _AO_PINS_H_ */
diff --git a/src/telelco-v2.0/ao_telelco.c b/src/telelco-v2.0/ao_telelco.c
new file mode 100644
index 00000000..9693c657
--- /dev/null
+++ b/src/telelco-v2.0/ao_telelco.c
@@ -0,0 +1,73 @@
+/*
+ * Copyright © 2011 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; either version 2 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, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+#include <ao.h>
+#include <ao_exti.h>
+#include <ao_packet.h>
+#include <ao_companion.h>
+#include <ao_profile.h>
+#include <ao_pyro.h>
+#include <ao_aes.h>
+#include <ao_seven_segment.h>
+#include <ao_quadrature.h>
+#include <ao_button.h>
+#include <ao_lco.h>
+#include <ao_lco_cmd.h>
+#include <ao_radio_cmac_cmd.h>
+#include <ao_eeprom.h>
+#include <ao_adc_single.h>
+
+int
+main(void)
+{
+	ao_clock_init();
+	
+	ao_led_init(LEDS_AVAILABLE);
+	ao_led_on(AO_LED_GREEN);
+	ao_task_init();
+
+	ao_timer_init();
+
+	ao_spi_init();
+	ao_dma_init();
+	ao_exti_init();
+	ao_adc_single_init();
+
+	ao_beep_init();
+	ao_cmd_init();
+
+	ao_lcd_stm_init();
+	ao_seven_segment_init();
+	ao_quadrature_init();
+	ao_button_init();
+
+	ao_eeprom_init();
+	
+	ao_radio_init();
+
+	ao_usb_init();
+
+	ao_config_init();
+	
+	ao_lco_init();
+	ao_lco_cmd_init();
+//	ao_radio_cmac_cmd_init();
+	
+	ao_start_scheduler();
+	return 0;
+}
diff --git a/src/telelco-v2.0/flash-loader/.gitignore b/src/telelco-v2.0/flash-loader/.gitignore
new file mode 100644
index 00000000..a32ec26e
--- /dev/null
+++ b/src/telelco-v2.0/flash-loader/.gitignore
@@ -0,0 +1,2 @@
+ao_product.h
+telelco*.elf
diff --git a/src/telelco-v2.0/flash-loader/Makefile b/src/telelco-v2.0/flash-loader/Makefile
new file mode 100644
index 00000000..b4ec2dad
--- /dev/null
+++ b/src/telelco-v2.0/flash-loader/Makefile
@@ -0,0 +1,8 @@
+#
+# AltOS flash loader build
+#
+#
+
+TOPDIR=../..
+HARDWARE=telelco-v2.0
+include $(TOPDIR)/stm/Makefile-flash.defs
diff --git a/src/telelco-v2.0/flash-loader/ao_pins.h b/src/telelco-v2.0/flash-loader/ao_pins.h
new file mode 100644
index 00000000..2292f03c
--- /dev/null
+++ b/src/telelco-v2.0/flash-loader/ao_pins.h
@@ -0,0 +1,35 @@
+/*
+ * 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; either version 2 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, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+#ifndef _AO_PINS_H_
+#define _AO_PINS_H_
+
+/* External crystal at 8MHz */
+#define AO_HSE		8000000
+
+#include <ao_flash_stm_pins.h>
+
+/* Drag race select button. Press at power on to get boot loader */
+
+#define AO_BOOT_PIN		1
+#define AO_BOOT_APPLICATION_GPIO	stm_gpioe
+#define AO_BOOT_APPLICATION_PIN		0
+#define AO_BOOT_APPLICATION_VALUE	1
+#define AO_BOOT_APPLICATION_MODE	AO_EXTI_MODE_PULL_UP
+
+#endif /* _AO_PINS_H_ */
diff --git a/src/telelcotwo-v0.1/Makefile b/src/telelcotwo-v0.1/Makefile
index 42188bb2..c68f3eb5 100644
--- a/src/telelcotwo-v0.1/Makefile
+++ b/src/telelcotwo-v0.1/Makefile
@@ -58,6 +58,7 @@ ALTOS_SRC = \
 	ao_button.c \
 	ao_event.c \
 	ao_lco_two.c \
+	ao_lco_bits.c \
 	ao_lco_func.c \
 	ao_lco_cmd.c \
 	ao_radio_cmac_cmd.c
diff --git a/src/telelcotwo-v0.1/ao_pins.h b/src/telelcotwo-v0.1/ao_pins.h
index 60e94c67..1941e03d 100644
--- a/src/telelcotwo-v0.1/ao_pins.h
+++ b/src/telelcotwo-v0.1/ao_pins.h
@@ -141,6 +141,8 @@
 				 AO_LED_CONTINUITY_0 |	\
 				 AO_LED_REMOTE_ARM)
 
+#define AO_LCO_DRAG		0
+
 /*
  * Use event queue for input devices
  */
diff --git a/src/test/ao_flight_test.c b/src/test/ao_flight_test.c
index 2d862f82..746a6814 100644
--- a/src/test/ao_flight_test.c
+++ b/src/test/ao_flight_test.c
@@ -305,7 +305,7 @@ struct ao_task {
 #define AO_MS_TO_TICKS(ms)	((ms) / 10)
 #define AO_SEC_TO_TICKS(s)	((s) * 100)
 
-#define AO_FLIGHT_TEST
+#define AO_FLIGHT_TEST	1
 
 int	ao_flight_debug;
 
@@ -438,10 +438,6 @@ static uint16_t	pyros_fired;
 static struct ao_mpu6000_sample	ao_ground_mpu6000;
 #endif
 
-#if HAS_ACCEL
-int ao_error_h_sq_avg;
-#endif
-
 void
 ao_test_exit(void)
 {
@@ -504,7 +500,7 @@ ao_insert(void)
 	ao_data_ring[ao_data_head] = ao_data_static;
 	if (ao_flight_state != ao_flight_startup) {
 #if HAS_ACCEL
-		double  accel = ((ao_flight_ground_accel - ao_data_accel_cook(&ao_data_static)) * GRAVITY * 2.0) /
+		double  accel = ((ao_flight_ground_accel - ao_data_accel(&ao_data_static)) * GRAVITY * 2.0) /
 			(ao_config.accel_minus_g - ao_config.accel_plus_g);
 #else
 		double	accel = 0.0;
@@ -515,7 +511,12 @@ ao_insert(void)
 			tick_offset = -ao_data_static.tick;
 		if ((prev_tick - ao_data_static.tick) > 0x400)
 			tick_offset += 65536;
-		simple_speed += accel * (ao_data_static.tick - prev_tick) / 100.0;
+		if (prev_tick) {
+			int ticks = ao_data_static.tick - prev_tick;
+			if (ticks < 0)
+				ticks += 65536;
+			simple_speed += accel * ticks / 100.0;
+		}
 		prev_tick = ao_data_static.tick;
 		time = (double) (ao_data_static.tick + tick_offset) / 100;
 
@@ -653,7 +654,7 @@ ao_insert(void)
 
 #if 1
 			printf("%7.2f height %8.2f accel %8.3f accel_speed %8.3f "
-			       "state %-8.8s k_height %8.2f k_speed %8.3f k_accel %8.3f avg_height %5d drogue %4d main %4d error %5d"
+			       "state %d k_height %8.2f k_speed %8.3f k_accel %8.3f avg_height %5d drogue %4d main %4d error %5d"
 #if TELEMEGA
 			       " 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 mag_x %8d mag_y %8d, mag_z %8d mag_angle %4d "
@@ -663,7 +664,7 @@ ao_insert(void)
 			       height,
 			       accel,
 			       simple_speed > -100.0 ? simple_speed : -100.0,
-			       ao_state_names[ao_flight_state],
+			       ao_flight_state * 10,
 			       ao_k_height / 65536.0,
 			       ao_k_speed / 65536.0 / 16.0,
 			       ao_k_accel / 65536.0 / 16.0,
diff --git a/src/test/plottest b/src/test/plottest
index 95337f10..5b30cfa5 100755
--- a/src/test/plottest
+++ b/src/test/plottest
@@ -1,17 +1,33 @@
+#!/bin/bash
+
+LINEWIDTH=2
+
 gnuplot -persist << EOF
+set title "$1"
 set ylabel "altitude (m)"
 set y2label "velocity (m/s), acceleration(m/s²)"
 set xlabel "time (s)"
 set xtics border out nomirror
 set ytics border out nomirror
 set y2tics border out nomirror
-plot "$1" using 1:3 with lines axes x1y1 title "raw height",\
-"$1" using 1:5 with lines axes x1y2 title "raw accel",\
-"$1" using 1:7 with lines axes x1y2 title "accel speed",\
-"$1" using 1:11 with lines axes x1y1 title "height",\
-"$1" using 1:13 with lines axes x1y2 title "speed",\
-"$1" using 1:15 with lines axes x1y2 title "accel",\
-"$1" using 1:19 with lines axes x1y1 title "drogue",\
-"$1" using 1:21 with lines axes x1y1 title "main",\
-"$1" using 1:23 with lines axes x1y1 title "error"
+set style line 1 linewidth $LINEWIDTH
+set style line 2 linewidth $LINEWIDTH
+set style line 3 linewidth $LINEWIDTH
+set style line 4 linewidth $LINEWIDTH
+set style line 5 linewidth $LINEWIDTH
+set style line 6 linewidth $LINEWIDTH
+set style line 7 linewidth $LINEWIDTH dashtype 2
+set style line 8 linewidth $LINEWIDTH dashtype 2
+set style line 9 linewidth $LINEWIDTH dashtype 2
+set style line 10 linewidth $LINEWIDTH dashtype 2
+plot "$1" using 1:3 with lines axes x1y1 title "raw height" ls 1,\
+"$1" using 1:5 with lines axes x1y2 title "raw accel" ls 2,\
+"$1" using 1:7 with lines axes x1y2 title "accel speed" ls 3,\
+"$1" using 1:11 with lines axes x1y1 title "height" ls 4,\
+"$1" using 1:13 with lines axes x1y2 title "speed" ls 5,\
+"$1" using 1:15 with lines axes x1y2 title "accel" ls 6,\
+"$1" using 1:19 with lines axes x1y1 title "drogue" ls 7,\
+"$1" using 1:21 with lines axes x1y1 title "main" ls 8,\
+"$1" using 1:23 with lines axes x1y1 title "error" ls 9,\
+"$1" using 1:9 with lines axes x1y2 title "state" ls 10
 EOF
diff --git a/src/tmgps-v2.0/.gitignore b/src/tmgps-v2.0/.gitignore
new file mode 100644
index 00000000..611e845e
--- /dev/null
+++ b/src/tmgps-v2.0/.gitignore
@@ -0,0 +1,2 @@
+ao_product.h
+tmgps-*.elf
diff --git a/src/tmgps-v2.0/Makefile b/src/tmgps-v2.0/Makefile
new file mode 100644
index 00000000..9e3965c6
--- /dev/null
+++ b/src/tmgps-v2.0/Makefile
@@ -0,0 +1,117 @@
+#
+# AltOS build
+#
+#
+
+include ../stm/Makefile.defs
+
+INC = \
+	ao.h \
+	ao_arch.h \
+	ao_arch_funcs.h \
+	ao_boot.h \
+	ao_companion.h \
+	ao_data.h \
+	ao_sample.h \
+	ao_pins.h \
+	ao_kalman.h \
+	ao_product.h \
+	ao_cc1120_CC1120.h \
+	ao_profile.h \
+	ao_task.h \
+	ao_whiten.h \
+	ao_sample_profile.h \
+	ao_mpu.h \
+	stm32l.h \
+	Makefile
+
+#PROFILE=ao_profile.c
+#PROFILE_DEF=-DAO_PROFILE=1
+
+#SAMPLE_PROFILE=ao_sample_profile.c \
+#	ao_sample_profile_timer.c
+#SAMPLE_PROFILE_DEF=-DHAS_SAMPLE_PROFILE=1
+
+#STACK_GUARD=ao_mpu_stm.c
+#STACK_GUARD_DEF=-DHAS_STACK_GUARD=1
+
+MATH_SRC=\
+	ef_log.c
+
+ALTOS_SRC = \
+	ao_boot_chain.c \
+	ao_interrupt.c \
+	ao_product.c \
+	ao_romconfig.c \
+	ao_cmd.c \
+	ao_config.c \
+	ao_task.c \
+	ao_led.c \
+	ao_stdio.c \
+	ao_panic.c \
+	ao_timer.c \
+	ao_mutex.c \
+	ao_serial_stm.c \
+	ao_gps_ublox.c \
+	ao_gps_show.c \
+	ao_freq.c \
+	ao_dma_stm.c \
+	ao_spi_stm.c \
+	ao_cc1120.c \
+	ao_fec_tx.c \
+	ao_fec_rx.c \
+	ao_data.c \
+	ao_adc_stm.c \
+	ao_storage.c \
+	ao_m25.c \
+	ao_usb_stm.c \
+	ao_exti_stm.c \
+	ao_eeprom_stm.c \
+	ao_convert_volt.c \
+	ao_log.c \
+	ao_log_gps.c \
+	ao_distance.c \
+	ao_sqrt.c \
+	ao_tracker.c \
+	ao_telemetry.c \
+	ao_aprs.c \
+	$(MATH_SRC) \
+	$(PROFILE) \
+	$(SAMPLE_PROFILE) \
+	$(STACK_GUARD)
+
+PRODUCT=TMGPS-v2.0
+PRODUCT_DEF=-DTMGPS_V_2_0
+IDPRODUCT=0x0025
+
+CFLAGS = $(PRODUCT_DEF) $(STM_CFLAGS) $(PROFILE_DEF) $(SAMPLE_PROFILE_DEF) $(STACK_GUARD_DEF) -Os -g
+
+PROGNAME=tmgps-v2.0
+PROG=$(PROGNAME)-$(VERSION).elf
+HEX=$(PROGNAME)-$(VERSION).ihx
+
+SRC=$(ALTOS_SRC) ao_tmgps.c
+OBJ=$(SRC:.c=.o)
+
+all: $(PROG) $(HEX)
+
+$(PROG): Makefile $(OBJ) altos.ld
+	$(call quiet,CC) $(LDFLAGS) $(CFLAGS) -o $(PROG) $(OBJ) $(LIBS)
+
+../altitude-pa.h: make-altitude-pa
+	nickle $< > $@
+
+$(OBJ): $(INC)
+
+ao_product.h: ao-make-product.5c ../Version
+	$(call quiet,NICKLE,$<) $< -m altusmetrum.org -i $(IDPRODUCT) -p $(PRODUCT) -v $(VERSION) > $@
+
+distclean:	clean
+
+clean:
+	rm -f *.o $(PROGNAME)-*.elf $(PROGNAME)-*.ihx
+	rm -f ao_product.h
+
+install:
+
+uninstall:
diff --git a/src/tmgps-v2.0/ao_pins.h b/src/tmgps-v2.0/ao_pins.h
new file mode 100644
index 00000000..b4dcc10c
--- /dev/null
+++ b/src/tmgps-v2.0/ao_pins.h
@@ -0,0 +1,236 @@
+/*
+ * Copyright © 2012 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; either version 2 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, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+#ifndef _AO_PINS_H_
+#define _AO_PINS_H_
+
+#define HAS_TASK_QUEUE		1
+
+/* 8MHz High speed external crystal */
+#define AO_HSE			8000000
+
+/* PLLVCO = 96MHz (so that USB will work) */
+#define AO_PLLMUL		12
+#define AO_RCC_CFGR_PLLMUL	(STM_RCC_CFGR_PLLMUL_12)
+
+/* SYSCLK = 32MHz (no need to go faster than CPU) */
+#define AO_PLLDIV		3
+#define AO_RCC_CFGR_PLLDIV	(STM_RCC_CFGR_PLLDIV_3)
+
+/* HCLK = 32MHz (CPU clock) */
+#define AO_AHB_PRESCALER	1
+#define AO_RCC_CFGR_HPRE_DIV	STM_RCC_CFGR_HPRE_DIV_1
+
+/* Run APB1 at 16MHz (HCLK/2) */
+#define AO_APB1_PRESCALER	2
+#define AO_RCC_CFGR_PPRE1_DIV	STM_RCC_CFGR_PPRE2_DIV_2
+
+/* Run APB2 at 16MHz (HCLK/2) */
+#define AO_APB2_PRESCALER	2
+#define AO_RCC_CFGR_PPRE2_DIV	STM_RCC_CFGR_PPRE2_DIV_2
+
+#define HAS_SERIAL_1		0
+#define USE_SERIAL_1_STDIN	0
+#define SERIAL_1_PB6_PB7	0
+#define SERIAL_1_PA9_PA10	1
+
+#define HAS_SERIAL_2		0
+#define USE_SERIAL_2_STDIN	0
+#define SERIAL_2_PA2_PA3	0
+#define SERIAL_2_PD5_PD6	0
+
+#define HAS_SERIAL_3		1
+#define USE_SERIAL_3_STDIN	0
+#define SERIAL_3_PB10_PB11	1
+#define SERIAL_3_PC10_PC11	0
+#define SERIAL_3_PD8_PD9	0
+
+#define AO_CONFIG_DEFAULT_FLIGHT_LOG_MAX	(512 * 1024)
+#define AO_CONFIG_MAX_SIZE			1024
+#define LOG_ERASE_MARK				0x55
+#define LOG_MAX_ERASE				128
+
+#define HAS_EEPROM		1
+#define USE_INTERNAL_FLASH	0
+#define USE_EEPROM_CONFIG	1
+#define USE_STORAGE_CONFIG	0
+#define HAS_USB			1
+#define HAS_BEEP		0
+#define HAS_RADIO		1
+#define HAS_TELEMETRY		1
+#define HAS_RDF			1
+#define HAS_APRS		1
+#define HAS_COMPANION		0
+
+#define HAS_SPI_1		1
+#define SPI_1_PA5_PA6_PA7	1	/* Barometer */
+#define SPI_1_PB3_PB4_PB5	1	/* Accelerometer */
+#define SPI_1_PE13_PE14_PE15	0
+#define SPI_1_OSPEEDR		STM_OSPEEDR_10MHz
+
+#define HAS_SPI_2		1
+#define SPI_2_PB13_PB14_PB15	1	/* Flash, Companion, Radio */
+#define SPI_2_PD1_PD3_PD4	0
+#define SPI_2_OSPEEDR		STM_OSPEEDR_10MHz
+
+#define SPI_2_PORT		(&stm_gpiob)
+#define SPI_2_SCK_PIN		13
+#define SPI_2_MISO_PIN		14
+#define SPI_2_MOSI_PIN		15
+
+#define HAS_I2C_1		0
+#define I2C_1_PB8_PB9		0
+
+#define HAS_I2C_2		0
+#define I2C_2_PB10_PB11		0
+
+#define PACKET_HAS_SLAVE	0
+#define PACKET_HAS_MASTER	0
+
+#define LOW_LEVEL_DEBUG		0
+
+#define LED_PORT_ENABLE		STM_RCC_AHBENR_GPIOCEN
+#define LED_PORT		(&stm_gpioc)
+#define LED_PIN_RED		14
+#define LED_PIN_GREEN		15
+#define AO_LED_RED		(1 << LED_PIN_RED)
+#define AO_LED_GREEN		(1 << LED_PIN_GREEN)
+
+#define AO_LED_PANIC	AO_LED_RED
+#define AO_LED_GPS_LOCK	AO_LED_GREEN
+
+#define LEDS_AVAILABLE		(AO_LED_RED | AO_LED_GREEN)
+
+#define HAS_GPS			1
+#define HAS_FLIGHT		0
+#define HAS_ADC			1
+#define HAS_ADC_TEMP		0
+#define HAS_LOG			1
+#define HAS_TRACKER		1
+#define LOG_ADC			0
+#define AO_LOG_FORMAT				AO_LOG_FORMAT_TELEGPS
+
+/*
+ * ADC
+ */
+#define AO_DATA_RING		32
+#define AO_ADC_NUM_SENSE	2
+
+struct ao_adc {
+	int16_t			v_batt;
+};
+
+#define AO_ADC_DUMP(p) \
+	printf("tick: %5u batt: %5d\n", \
+	       (p)->tick, \
+	       (p)->adc.v_batt);
+
+#define AO_ADC_V_BATT		8
+#define AO_ADC_V_BATT_PORT	(&stm_gpiob)
+#define AO_ADC_V_BATT_PIN	0
+
+#define AO_ADC_RCC_AHBENR	((1 << STM_RCC_AHBENR_GPIOBEN))
+
+#define AO_NUM_ADC_PIN		1
+
+#define AO_ADC_PIN0_PORT	AO_ADC_V_BATT_PORT
+#define AO_ADC_PIN0_PIN		AO_ADC_V_BATT_PIN
+
+#define AO_NUM_ADC	       	(AO_NUM_ADC_PIN)
+
+#define AO_ADC_SQ1		AO_ADC_V_BATT
+
+/*
+ * Voltage divider on ADC battery sampler
+ */
+#define AO_BATTERY_DIV_PLUS	56	/* 5.6k */
+#define AO_BATTERY_DIV_MINUS	100	/* 10k */
+
+/*
+ * ADC reference in decivolts
+ */
+#define AO_ADC_REFERENCE_DV	33
+
+/*
+ * GPS
+ */
+
+#define AO_SERIAL_SPEED_UBLOX	AO_SERIAL_SPEED_9600
+
+#define ao_gps_getchar		ao_serial3_getchar
+#define ao_gps_putchar		ao_serial3_putchar
+#define ao_gps_set_speed	ao_serial3_set_speed
+#define ao_gps_fifo		(ao_stm_usart3.rx_fifo)
+
+/*
+ * SPI Flash memory
+ */
+
+#define M25_MAX_CHIPS		1
+#define AO_M25_SPI_CS_PORT	(&stm_gpiob)
+#define AO_M25_SPI_CS_MASK	(1 << 8)
+#define AO_M25_SPI_BUS		AO_SPI_2_PB13_PB14_PB15
+
+/*
+ * Radio (cc1120)
+ */
+
+/* gets pretty close to 434.550 */
+
+#define AO_RADIO_CAL_DEFAULT 	0x6ca333
+
+#define AO_FEC_DEBUG		0
+#define AO_CC1120_SPI_CS_PORT	(&stm_gpioa)
+#define AO_CC1120_SPI_CS_PIN	2
+#define AO_CC1120_SPI_BUS	AO_SPI_2_PB13_PB14_PB15
+#define AO_CC1120_SPI		stm_spi2
+
+#define AO_CC1120_INT_PORT		(&stm_gpioa)
+#define AO_CC1120_INT_PIN		(3)
+#define AO_CC1120_MCU_WAKEUP_PORT	(&stm_gpioa)
+#define AO_CC1120_MCU_WAKEUP_PIN	(4)
+
+#define AO_CC1120_INT_GPIO	2
+#define AO_CC1120_INT_GPIO_IOCFG	CC1120_IOCFG2
+
+#define AO_CC1120_MARC_GPIO	3
+#define AO_CC1120_MARC_GPIO_IOCFG	CC1120_IOCFG3
+
+#define HAS_BOOT_RADIO		0
+
+#define NUM_CMDS		16
+
+/*
+ * Monitor
+ */
+
+#define HAS_MONITOR		0
+#define LEGACY_MONITOR		0
+#define HAS_MONITOR_PUT		1
+#define AO_MONITOR_LED		0
+#define HAS_RSSI		0
+
+/*
+ * Profiling Viterbi decoding
+ */
+
+#ifndef AO_PROFILE
+#define AO_PROFILE	       	0
+#endif
+
+#endif /* _AO_PINS_H_ */
diff --git a/src/tmgps-v2.0/ao_tmgps.c b/src/tmgps-v2.0/ao_tmgps.c
new file mode 100644
index 00000000..cbd58eb2
--- /dev/null
+++ b/src/tmgps-v2.0/ao_tmgps.c
@@ -0,0 +1,81 @@
+/*
+ * Copyright © 2011 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; either version 2 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, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+#include <ao.h>
+#include <ao_log.h>
+#include <ao_exti.h>
+#include <ao_tracker.h>
+#include <ao_eeprom.h>
+#include <ao_profile.h>
+#if HAS_SAMPLE_PROFILE
+#include <ao_sample_profile.h>
+#endif
+#if HAS_STACK_GUARD
+#include <ao_mpu.h>
+#endif
+
+int
+main(void)
+{
+	ao_clock_init();
+
+#if HAS_STACK_GUARD
+	ao_mpu_init();
+#endif
+
+	ao_task_init();
+	ao_cmd_init();
+	ao_config_init();
+
+	/* Turn on all of the LEDs to test them */
+	ao_led_init(LEDS_AVAILABLE);
+	ao_led_on(LEDS_AVAILABLE);
+
+	/* Internal systems */
+	ao_timer_init();
+	ao_dma_init();
+	ao_exti_init();
+
+	/* SoC hardware */
+	ao_spi_init();
+	ao_adc_init();
+	ao_serial_init();
+	ao_usb_init();
+	ao_eeprom_init();
+
+	/* External hardware */
+	ao_storage_init();
+	ao_radio_init();
+	ao_gps_init();
+
+	/* Services */
+	ao_log_init();
+	ao_telemetry_init();
+	ao_tracker_init();
+
+#if AO_PROFILE
+	ao_profile_init();
+#endif
+#if HAS_SAMPLE_PROFILE
+	ao_sample_profile_init();
+#endif
+	ao_led_off(LEDS_AVAILABLE);
+
+	ao_start_scheduler();
+	return 0;
+}
diff --git a/src/vidtime/.gitignore b/src/vidtime/.gitignore
new file mode 100644
index 00000000..471b7fd9
--- /dev/null
+++ b/src/vidtime/.gitignore
@@ -0,0 +1,2 @@
+ao_product.h
+vidtime-*
diff --git a/src/vidtime/Makefile b/src/vidtime/Makefile
new file mode 100644
index 00000000..327614bc
--- /dev/null
+++ b/src/vidtime/Makefile
@@ -0,0 +1,65 @@
+#
+# AltOS build
+#
+#
+
+include ../stmf0/Makefile.defs
+
+INC = \
+	ao.h \
+	ao_arch.h \
+	ao_arch_funcs.h \
+	ao_boot.h \
+	ao_pins.h \
+	ao_product.h \
+	ao_task.h \
+	stm32f0.h \
+	Makefile
+
+ALTOS_SRC = \
+	ao_boot_chain.c \
+	ao_interrupt.c \
+	ao_product.c \
+	ao_romconfig.c \
+	ao_cmd.c \
+	ao_dma_stm.c \
+	ao_exti_stm.c \
+	ao_task.c \
+	ao_stdio.c \
+	ao_panic.c \
+	ao_timer.c \
+	ao_mutex.c \
+	ao_usb_stm.c
+
+PRODUCT=VidTime
+PRODUCT_DEF=-DVIDTIME
+IDPRODUCT=0x002b
+
+CFLAGS = $(PRODUCT_DEF) $(STMF0_CFLAGS) -Os -g
+
+PROGNAME=vidtime-v1.0
+PROG=$(PROGNAME)-$(VERSION).elf
+HEX=$(PROGNAME)-$(VERSION).ihx
+
+SRC=$(ALTOS_SRC) ao_vidtime.c
+OBJ=$(SRC:.c=.o)
+
+all: $(PROG) $(HEX)
+
+$(PROG): Makefile $(OBJ) altos.ld
+	$(call quiet,CC) $(LDFLAGS) $(CFLAGS) -o $(PROG) $(OBJ) $(LIBS)
+
+ao_product.h: ao-make-product.5c ../Version
+	$(call quiet,NICKLE,$<) $< -m altusmetrum.org -i $(IDPRODUCT) -p $(PRODUCT) -v $(VERSION) > $@
+
+$(OBJ): $(INC)
+
+distclean:	clean
+
+clean:
+	rm -f *.o $(PROGNAME)-*.elf $(PROGNAME)-*.ihx
+	rm -f ao_product.h
+
+install:
+
+uninstall:
diff --git a/src/vidtime/ao_pins.h b/src/vidtime/ao_pins.h
new file mode 100644
index 00000000..fe9d3879
--- /dev/null
+++ b/src/vidtime/ao_pins.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright © 2012 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_PINS_H_
+#define _AO_PINS_H_
+
+#define HAS_TASK_QUEUE		1
+
+#define IS_FLASH_LOADER	0
+
+#define AO_POWER_MANAGEMENT	0
+
+/* 48MHz clock based on USB */
+#define AO_HSI48	1
+
+/* HCLK = 48MHz */
+#define AO_AHB_PRESCALER	1
+#define AO_RCC_CFGR_HPRE_DIV	STM_RCC_CFGR_HPRE_DIV_1
+
+/* APB = 48MHz */
+#define AO_APB_PRESCALER	1
+#define AO_RCC_CFGR_PPRE_DIV	STM_RCC_CFGR_PPRE_DIV_1
+
+#define HAS_EEPROM		0
+#define USE_INTERNAL_FLASH	0
+#define USE_STORAGE_CONFIG	0
+#define USE_EEPROM_CONFIG	0
+
+#define HAS_BEEP		0
+
+#define HAS_USB			1
+#define AO_USB_DIRECTIO		0
+#define AO_PA11_PA12_RMP	1
+
+#define HAS_SPI_0		0
+
+#define AO_SENSOR_PORT		(&stm_gpioa)
+#define AO_SENSOR_PIN		3
+
+#define LOW_LEVEL_DEBUG		0
+
+#endif /* _AO_PINS_H_ */
diff --git a/src/vidtime/ao_vidtime.c b/src/vidtime/ao_vidtime.c
new file mode 100644
index 00000000..1b9b9e1c
--- /dev/null
+++ b/src/vidtime/ao_vidtime.c
@@ -0,0 +1,97 @@
+/*
+ * Copyright © 2012 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.
+ */
+
+#include <ao.h>
+#include <ao_exti.h>
+
+static uint8_t	sensor_value;
+static uint8_t	vidtime_monitor;
+
+static void
+vidtime(void)
+{
+	uint8_t	old = 0, got;
+
+	ao_exti_enable(AO_SENSOR_PORT, AO_SENSOR_PIN);
+	for (;;) {
+		while (!vidtime_monitor)
+			ao_sleep(&vidtime_monitor);
+		while ((got = sensor_value) == old)
+			ao_sleep(&sensor_value);
+		printf("%d\n", got);
+		flush();
+		old = got;
+	}
+}
+
+static void
+sensor_interrupt(void)
+{
+	sensor_value = ao_gpio_get(AO_SENSOR_PORT, AO_SENSOR_PIN, foo);
+	ao_wakeup(&sensor_value);
+}
+
+static struct ao_task	vidtime_task;
+
+static void
+ao_init_vidtime(void)
+{
+	ao_enable_port(AO_SENSOR_PORT);
+	ao_exti_setup(AO_SENSOR_PORT, AO_SENSOR_PIN,
+		      AO_EXTI_MODE_RISING|
+		      AO_EXTI_MODE_FALLING|
+		      AO_EXTI_MODE_PULL_NONE|
+		      AO_EXTI_PRIORITY_MED,
+		      sensor_interrupt);
+	ao_add_task(&vidtime_task, vidtime, "vidtime");
+}
+
+static void
+ao_set_vidtime(void)
+{
+	ao_cmd_decimal();
+	if (ao_cmd_status == ao_cmd_success) {
+		vidtime_monitor = ao_cmd_lex_i != 0;
+		ao_wakeup(&vidtime_monitor);
+	}
+}
+
+const struct ao_cmds	ao_vidtime_cmds[] = {
+	{ ao_set_vidtime, "V <0 off, 1 on>\0Enable/disable timing monitor" },
+	{ 0, NULL }
+};
+
+void main(void)
+{
+	ao_clock_init();
+
+	ao_task_init();
+
+	ao_timer_init();
+
+	ao_dma_init();
+
+	ao_init_vidtime();
+
+	ao_usb_init();
+
+	ao_cmd_init();
+
+	ao_cmd_register(&ao_vidtime_cmds[0]);
+
+	ao_start_scheduler();
+}
diff --git a/src/vidtime/flash-loader/.gitignore b/src/vidtime/flash-loader/.gitignore
new file mode 100644
index 00000000..05f1a4dc
--- /dev/null
+++ b/src/vidtime/flash-loader/.gitignore
@@ -0,0 +1,2 @@
+ao_product.h
+vidtime*
diff --git a/src/vidtime/flash-loader/Makefile b/src/vidtime/flash-loader/Makefile
new file mode 100644
index 00000000..57c65b5e
--- /dev/null
+++ b/src/vidtime/flash-loader/Makefile
@@ -0,0 +1,7 @@
+#
+# AltOS flash loader build
+#
+
+TOPDIR=../..
+HARDWARE=vidtime-v1.0
+include $(TOPDIR)/stmf0/Makefile-flash.defs
diff --git a/src/vidtime/flash-loader/ao_pins.h b/src/vidtime/flash-loader/ao_pins.h
new file mode 100644
index 00000000..7feb9362
--- /dev/null
+++ b/src/vidtime/flash-loader/ao_pins.h
@@ -0,0 +1,34 @@
+/*
+ * 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_PINS_H_
+#define _AO_PINS_H_
+
+#include <ao_flash_stm_pins.h>
+
+/* Debug port PA15 (pin 23) */
+
+#define AO_BOOT_PIN			1
+#define AO_BOOT_APPLICATION_GPIO	(stm_gpioa)
+#define AO_BOOT_APPLICATION_PIN		15
+#define AO_BOOT_APPLICATION_VALUE	1
+#define AO_BOOT_APPLICATION_MODE	AO_EXTI_MODE_PULL_UP
+
+#define AO_USB_DIRECTIO		0
+#define AO_PA11_PA12_RMP	1
+
+#endif /* _AO_PINS_H_ */