altos: Make serial, usb, beeper and accelerometer optional components

Not all boards will have these, so fix places that use them to deal
with that.

Signed-off-by: Keith Packard <keithp@keithp.com>

10 files changed, 189 insertions, 43 deletions

diff --git a/src/Makefile.proto b/src/Makefile.proto
index 709cbca7..30cd5798 100644
--- a/src/Makefile.proto
+++ b/src/Makefile.proto
@@ -42,11 +42,15 @@ ALTOS_SRC = \
 # Shared AltOS drivers
 #
 ALTOS_DRIVER_SRC = \
-	ao_beep.c \
 	ao_config.c \
 	ao_led.c \
 	ao_radio.c \
-	ao_stdio.c \
+	ao_stdio.c
+
+BEEP_DRIVER_SRC = \
+	ao_beep.c
+
+USB_DRIVER_SRC = \
 	ao_usb.c
 
 TELE_COMMON_SRC = \
@@ -68,7 +72,12 @@ TELE_RECEIVER_SRC =\
 #
 
 TELE_DRIVER_SRC = \
-	ao_convert.c \
+	ao_convert.c
+
+#
+# Serial port driver
+#
+SERIAL_DRIVER_SRC = \
 	ao_serial.c
 
 #
@@ -89,7 +98,9 @@ DBG_SRC = \
 TM_DRIVER_SRC = \
 	ao_adc.c \
 	ao_gps_report.c \
-	ao_ignite.c
+	ao_ignite.c \
+	$(BEEP_DRIVER_SRC) \
+	$(USB_DRIVER_SRC)
 
 #
 # 25LC1024 driver source
@@ -142,6 +153,7 @@ TM_BASE_SRC = \
 	$(ALTOS_SRC) \
 	$(ALTOS_DRIVER_SRC) \
 	$(TELE_DRIVER_SRC) \
+	$(SERIAL_DRIVER_SRC) \
 	$(TELE_COMMON_SRC) \
 	$(TM_DRIVER_SRC) \
 	$(TM_TASK_SRC) \
@@ -158,6 +170,7 @@ TI_SRC = \
 	$(ALTOS_DRIVER_SRC) \
 	$(TELE_RECEIVER_SRC) \
 	$(TELE_COMMON_SRC) \
+	$(USB_DRIVER_SRC) \
 	$(TI_MAIN_SRC) \
 	$(DBG_SRC)
 
@@ -172,6 +185,7 @@ TT_SRC = \
 	$(TELE_RECEIVER_SRC) \
 	$(TELE_DRIVER_SRC) \
 	$(TELE_COMMON_SRC) \
+	$(USB_DRIVER_SRC) \
 	$(TT_MAIN_SRC)
 
 
@@ -187,6 +201,7 @@ TD_SRC = \
 	$(ALTOS_DRIVER_SRC) \
 	$(TELE_RECEIVER_SRC) \
 	$(TELE_COMMON_SRC) \
+	$(USB_DRIVER_SRC) \
 	$(TD_MAIN_SRC)
 
 include Makefile.defs
diff --git a/src/ao.h b/src/ao.h
index 791064e8..5bbe5158 100644
--- a/src/ao.h
+++ b/src/ao.h
@@ -164,9 +164,13 @@ struct ao_adc {
 
 #if HAS_ADC
 
+#if HAS_ACCEL
 #ifndef HAS_ACCEL_REF
 #error Please define HAS_ACCEL_REF
 #endif
+#else
+#define HAS_ACCEL_REF 0
+#endif
 
 /*
  * ao_adc.c
@@ -303,7 +307,14 @@ extern __code __at (0x00a0) uint16_t ao_romconfig_version;
 extern __code __at (0x00a2) uint16_t ao_romconfig_check;
 extern __code __at (0x00a4) uint16_t ao_serial_number;
 extern __code __at (0x00a6) uint32_t ao_radio_cal;
+
+#ifndef HAS_USB
+#error Please define HAS_USB
+#endif
+
+#if HAS_USB
 extern __code __at (0x00aa) uint8_t ao_usb_descriptors [];
+#endif
 
 /*
  * ao_usb.c
@@ -327,9 +338,11 @@ ao_usb_pollchar(void);
 void
 ao_usb_flush(void);
 
+#if HAS_USB
 /* USB interrupt handler */
 void
 ao_usb_isr(void) __interrupt 6;
+#endif
 
 /* Enable the USB controller */
 void
@@ -1062,7 +1075,6 @@ ao_rssi_init(uint8_t rssi_led);
  * each instance of a product
  */
 
-extern __code __at(0x00aa) uint8_t ao_usb_descriptors [];
 extern const char ao_version[];
 extern const char ao_manufacturer[];
 extern const char ao_product[];
diff --git a/src/ao_flight.c b/src/ao_flight.c
index 81aecad3..843865e8 100644
--- a/src/ao_flight.c
+++ b/src/ao_flight.c
@@ -19,39 +19,57 @@
 #include "ao.h"
 #endif
 
+#ifndef HAS_ACCEL
+#error Please define HAS_ACCEL
+#endif
+
+#ifndef HAS_GPS
+#error Please define HAS_GPS
+#endif
+
+#ifndef HAS_USB
+#error Please define HAS_USB
+#endif
+
 /* Main flight thread. */
 
 __pdata enum ao_flight_state	ao_flight_state;	/* current flight state */
 __pdata uint16_t		ao_flight_tick;		/* time of last data */
 __pdata uint16_t		ao_flight_prev_tick;	/* time of previous data */
-__pdata int16_t			ao_flight_accel;	/* filtered acceleration */
 __pdata int16_t			ao_flight_pres;		/* filtered pressure */
 __pdata int16_t			ao_ground_pres;		/* startup pressure */
-__pdata int16_t			ao_ground_accel;	/* startup acceleration */
 __pdata int16_t			ao_min_pres;		/* minimum recorded pressure */
 __pdata uint16_t		ao_launch_tick;		/* time of launch detect */
 __pdata int16_t			ao_main_pres;		/* pressure to eject main */
+#if HAS_ACCEL
+__pdata int16_t			ao_flight_accel;	/* filtered acceleration */
+__pdata int16_t			ao_ground_accel;	/* startup acceleration */
+#endif
 
 /*
  * track min/max data over a long interval to detect
  * resting
  */
 __pdata uint16_t		ao_interval_end;
-__pdata int16_t			ao_interval_cur_min_accel;
-__pdata int16_t			ao_interval_cur_max_accel;
 __pdata int16_t			ao_interval_cur_min_pres;
 __pdata int16_t			ao_interval_cur_max_pres;
-__pdata int16_t			ao_interval_min_accel;
-__pdata int16_t			ao_interval_max_accel;
 __pdata int16_t			ao_interval_min_pres;
 __pdata int16_t			ao_interval_max_pres;
+#if HAS_ACCEL
+__pdata int16_t			ao_interval_cur_min_accel;
+__pdata int16_t			ao_interval_cur_max_accel;
+__pdata int16_t			ao_interval_min_accel;
+__pdata int16_t			ao_interval_max_accel;
+#endif
 
 __data uint8_t ao_flight_adc;
-__pdata int16_t ao_raw_accel, ao_raw_accel_prev, ao_raw_pres;
-__pdata int16_t ao_accel_2g;
-
+__pdata int16_t ao_raw_pres;
 __xdata uint8_t ao_flight_force_idle;
 
+#if HAS_ACCEL
+__pdata int16_t ao_raw_accel, ao_raw_accel_prev;
+__pdata int16_t ao_accel_2g;
+
 /* Accelerometer calibration
  *
  * We're sampling the accelerometer through a resistor divider which
@@ -84,6 +102,8 @@ __xdata uint8_t ao_flight_force_idle;
 #define ACCEL_VEL_MACH	VEL_MPS_TO_COUNT(200)
 #define ACCEL_VEL_BOOST	VEL_MPS_TO_COUNT(5)
 
+#endif
+
 /*
  * Barometer calibration
  *
@@ -117,6 +137,7 @@ __xdata uint8_t ao_flight_force_idle;
 
 #define BOOST_TICKS_MAX	AO_SEC_TO_TICKS(15)
 
+#if HAS_ACCEL
 /* This value is scaled in a weird way. It's a running total of accelerometer
  * readings minus the ground accelerometer reading. That means it measures
  * velocity, and quite accurately too. As it gets updated 100 times a second,
@@ -126,7 +147,10 @@ __pdata int32_t	ao_flight_vel;
 __pdata int32_t ao_min_vel;
 __pdata int32_t	ao_old_vel;
 __pdata int16_t ao_old_vel_tick;
-__xdata int32_t ao_raw_accel_sum, ao_raw_pres_sum;
+__xdata int32_t ao_raw_accel_sum;
+#endif
+
+__xdata int32_t ao_raw_pres_sum;
 
 /* Landing is detected by getting constant readings from both pressure and accelerometer
  * for a fairly long time (AO_INTERVAL_TICKS)
@@ -141,22 +165,31 @@ ao_flight(void)
 	__pdata static uint16_t	nsamples = 0;
 
 	ao_flight_adc = ao_adc_head;
+	ao_raw_pres = 0;
+#if HAS_ACCEL
 	ao_raw_accel_prev = 0;
 	ao_raw_accel = 0;
-	ao_raw_pres = 0;
+#endif
 	ao_flight_tick = 0;
 	for (;;) {
 		ao_wakeup(DATA_TO_XDATA(&ao_flight_adc));
 		ao_sleep(DATA_TO_XDATA(&ao_adc_head));
 		while (ao_flight_adc != ao_adc_head) {
+#if HAS_ACCEL
 			__pdata uint8_t ticks;
 			__pdata int16_t ao_vel_change;
+#endif
 			__xdata struct ao_adc *ao_adc;
 			ao_flight_prev_tick = ao_flight_tick;
 
 			/* Capture a sample */
 			ao_adc = &ao_adc_ring[ao_flight_adc];
 			ao_flight_tick = ao_adc->tick;
+			ao_raw_pres = ao_adc->pres;
+			ao_flight_pres -= ao_flight_pres >> 4;
+			ao_flight_pres += ao_raw_pres >> 4;
+
+#if HAS_ACCEL
 			ao_raw_accel = ao_adc->accel;
 #if HAS_ACCEL_REF
 			/*
@@ -242,12 +275,9 @@ ao_flight(void)
 			ao_raw_accel = (uint16_t) ((((uint32_t) ao_raw_accel << 16) / (ao_accel_ref[ao_flight_adc] << 1))) >> 1;
 			ao_adc->accel = ao_raw_accel;
 #endif
-			ao_raw_pres = ao_adc->pres;
 
 			ao_flight_accel -= ao_flight_accel >> 4;
 			ao_flight_accel += ao_raw_accel >> 4;
-			ao_flight_pres -= ao_flight_pres >> 4;
-			ao_flight_pres += ao_raw_pres >> 4;
 			/* Update velocity
 			 *
 			 * The accelerometer is mounted so that
@@ -264,12 +294,14 @@ ao_flight(void)
 				ao_flight_vel += (int32_t) ao_vel_change;
 			else
 				ao_flight_vel += (int32_t) ao_vel_change * (int32_t) ticks;
+#endif
 
 			ao_flight_adc = ao_adc_ring_next(ao_flight_adc);
 		}
 
 		if (ao_flight_pres < ao_min_pres)
 			ao_min_pres = ao_flight_pres;
+#if HAS_ACCEL
 		if (ao_flight_vel >= 0) {
 			if (ao_flight_vel < ao_min_vel)
 			    ao_min_vel = ao_flight_vel;
@@ -277,6 +309,7 @@ ao_flight(void)
 			if (-ao_flight_vel < ao_min_vel)
 			    ao_min_vel = -ao_flight_vel;
 		}
+#endif
 
 		switch (ao_flight_state) {
 		case ao_flight_startup:
@@ -287,21 +320,27 @@ ao_flight(void)
 			 * data and average them to find the resting values
 			 */
 			if (nsamples < 512) {
+#if HAS_ACCEL
 				ao_raw_accel_sum += ao_raw_accel;
+#endif
 				ao_raw_pres_sum += ao_raw_pres;
 				++nsamples;
 				continue;
 			}
+#if HAS_ACCEL
 			ao_ground_accel = ao_raw_accel_sum >> 9;
+#endif
 			ao_ground_pres = ao_raw_pres_sum >> 9;
 			ao_min_pres = ao_ground_pres;
 			ao_config_get();
 			ao_main_pres = ao_altitude_to_pres(ao_pres_to_altitude(ao_ground_pres) + ao_config.main_deploy);
+#if HAS_ACCEL
 			ao_accel_2g = ao_config.accel_minus_g - ao_config.accel_plus_g;
 			ao_flight_vel = 0;
 			ao_min_vel = 0;
 			ao_old_vel = ao_flight_vel;
 			ao_old_vel_tick = ao_flight_tick;
+#endif
 
 			/* Check to see what mode we should go to.
 			 *  - Invalid mode if accel cal appears to be out
@@ -309,6 +348,7 @@ ao_flight(void)
 			 *  - idle mode otherwise
 			 */
 			ao_config_get();
+#if HAS_ACCEL
 			if (ao_config.accel_plus_g == 0 ||
 			    ao_config.accel_minus_g == 0 ||
 			    ao_flight_accel < ao_config.accel_plus_g - ACCEL_NOSE_UP ||
@@ -323,17 +363,23 @@ ao_flight(void)
 				 */
 				ao_packet_slave_start();
 
-			} else if (ao_flight_accel < ao_config.accel_plus_g + ACCEL_NOSE_UP &&
-			           !ao_flight_force_idle)
+			} else
+#endif
+				if (!ao_flight_force_idle
+#if HAS_ACCEL
+				    && ao_flight_accel < ao_config.accel_plus_g + ACCEL_NOSE_UP
+#endif
+					)
  			{
 				/* Set pad mode - we can fly! */
 				ao_flight_state = ao_flight_pad;
 
+#if HAS_USB
 				/* Disable the USB controller in flight mode
 				 * to save power
 				 */
 				ao_usb_disable();
-
+#endif
 				/* Turn on telemetry system */
 				ao_rdf_set(1);
 				ao_telemetry_set_interval(AO_TELEMETRY_INTERVAL_PAD);
@@ -356,6 +402,7 @@ ao_flight(void)
 			break;
 		case ao_flight_pad:
 
+#if HAS_ACCEL
 			/* Trim velocity
 			 *
 			 * Once a second, remove any velocity from
@@ -366,6 +413,7 @@ ao_flight(void)
 				ao_flight_vel -= ao_old_vel;
 				ao_old_vel = ao_flight_vel;
 			}
+#endif
 			/* pad to boost:
 			 *
 			 * accelerometer: > 2g AND velocity > 5m/s
@@ -376,11 +424,18 @@ ao_flight(void)
 			 * the barometer, but we use both to make sure this
 			 * transition is detected
 			 */
-			if ((ao_flight_accel < ao_ground_accel - ACCEL_BOOST &&
-			     ao_flight_vel > ACCEL_VEL_BOOST) ||
+			if (
+#if HAS_ACCEL
+				(ao_flight_accel < ao_ground_accel - ACCEL_BOOST &&
+				 ao_flight_vel > ACCEL_VEL_BOOST) ||
+#endif
 			    ao_flight_pres < ao_ground_pres - BARO_LAUNCH)
 			{
+#if HAS_ACCEL
 				ao_flight_state = ao_flight_boost;
+#else
+				ao_flight_state = ao_flight_coast;
+#endif
 				ao_launch_tick = ao_flight_tick;
 
 				/* start logging data */
@@ -392,14 +447,17 @@ ao_flight(void)
 				/* disable RDF beacon */
 				ao_rdf_set(0);
 
+#if HAS_GPS
 				/* Record current GPS position by waking up GPS log tasks */
 				ao_wakeup(&ao_gps_data);
 				ao_wakeup(&ao_gps_tracking_data);
+#endif
 
 				ao_wakeup(DATA_TO_XDATA(&ao_flight_state));
 				break;
 			}
 			break;
+#if HAS_ACCEL
 		case ao_flight_boost:
 
 			/* boost to fast:
@@ -448,6 +506,7 @@ ao_flight(void)
 				ao_wakeup(DATA_TO_XDATA(&ao_flight_state));
 			}
 			break;
+#endif
 		case ao_flight_coast:
 
 			/* apogee detect: coast to drogue deploy:
@@ -478,8 +537,10 @@ ao_flight(void)
 				/* Set the 'last' limits to max range to prevent
 				 * early resting detection
 				 */
+#if HAS_ACCEL
 				ao_interval_min_accel = 0;
 				ao_interval_max_accel = 0x7fff;
+#endif
 				ao_interval_min_pres = 0;
 				ao_interval_max_pres = 0x7fff;
 
@@ -487,7 +548,9 @@ ao_flight(void)
 				ao_interval_end = ao_flight_tick + AO_INTERVAL_TICKS;
 
 				ao_interval_cur_min_pres = ao_interval_cur_max_pres = ao_flight_pres;
+#if HAS_ACCEL
 				ao_interval_cur_min_accel = ao_interval_cur_max_accel = ao_flight_accel;
+#endif
 
 				/* and enter drogue state */
 				ao_flight_state = ao_flight_drogue;
@@ -530,21 +593,28 @@ ao_flight(void)
 				ao_interval_cur_min_pres = ao_flight_pres;
 			if (ao_flight_pres > ao_interval_cur_max_pres)
 				ao_interval_cur_max_pres = ao_flight_pres;
+#if HAS_ACCEL
 			if (ao_flight_accel < ao_interval_cur_min_accel)
 				ao_interval_cur_min_accel = ao_flight_accel;
 			if (ao_flight_accel > ao_interval_cur_max_accel)
 				ao_interval_cur_max_accel = ao_flight_accel;
+#endif
 
 			if ((int16_t) (ao_flight_tick - ao_interval_end) >= 0) {
 				ao_interval_max_pres = ao_interval_cur_max_pres;
 				ao_interval_min_pres = ao_interval_cur_min_pres;
+				ao_interval_cur_min_pres = ao_interval_cur_max_pres = ao_flight_pres;
+#if HAS_ACCEL
 				ao_interval_max_accel = ao_interval_cur_max_accel;
 				ao_interval_min_accel = ao_interval_cur_min_accel;
-				ao_interval_end = ao_flight_tick + AO_INTERVAL_TICKS;
-				ao_interval_cur_min_pres = ao_interval_cur_max_pres = ao_flight_pres;
 				ao_interval_cur_min_accel = ao_interval_cur_max_accel = ao_flight_accel;
+#endif
+				ao_interval_end = ao_flight_tick + AO_INTERVAL_TICKS;
 
-				if ((uint16_t) (ao_interval_max_accel - ao_interval_min_accel) < (uint16_t) ACCEL_INT_LAND &&
+				if (
+#if HAS_ACCEL
+					(uint16_t) (ao_interval_max_accel - ao_interval_min_accel) < (uint16_t) ACCEL_INT_LAND &&
+#endif
 				    ao_flight_pres > ao_ground_pres - BARO_LAND &&
 				    (uint16_t) (ao_interval_max_pres - ao_interval_min_pres) < (uint16_t) BARO_INT_LAND)
 				{
diff --git a/src/ao_flight_test.c b/src/ao_flight_test.c
index 0c2006d5..e75bc8df 100644
--- a/src/ao_flight_test.c
+++ b/src/ao_flight_test.c
@@ -155,6 +155,15 @@ struct ao_config ao_config;
 
 #define DATA_TO_XDATA(x) (x)
 
+#define HAS_FLIGHT 1
+#define HAS_ADC 1
+#define HAS_USB 1
+#define HAS_GPS 1
+#ifndef HAS_ACCEL
+#define HAS_ACCEL 1
+#endif
+#define HAS_ACCEL_REF 0
+
 #include "ao_flight.c"
 
 void
diff --git a/src/ao_log.c b/src/ao_log.c
index 1b10961d..817d3e6f 100644
--- a/src/ao_log.c
+++ b/src/ao_log.c
@@ -92,7 +92,9 @@ ao_log(void)
 
 	log.type = AO_LOG_FLIGHT;
 	log.tick = ao_flight_tick;
+#if HAS_ACCEL
 	log.u.flight.ground_accel = ao_ground_accel;
+#endif
 	log.u.flight.flight = ao_flight_number;
 	ao_log_data(&log);
 
diff --git a/src/ao_panic.c b/src/ao_panic.c
index e996371e..fdada201 100644
--- a/src/ao_panic.c
+++ b/src/ao_panic.c
@@ -17,6 +17,14 @@
 
 #include "ao.h"
 
+#ifndef HAS_BEEP
+#error Please define HAS_BEEP
+#endif
+
+#if !HAS_BEEP
+#define ao_beep(x)
+#endif
+
 static void
 ao_panic_delay(uint8_t n)
 {
diff --git a/src/ao_pins.h b/src/ao_pins.h
index 2c5b9db5..59604588 100644
--- a/src/ao_pins.h
+++ b/src/ao_pins.h
@@ -19,6 +19,9 @@
 #define _AO_PINS_H_
 
 #if defined(TELEMETRUM_V_1_0)
+	#define HAS_USB			1
+	#define HAS_BEEP		1
+	#define HAS_GPS			1
 	#define HAS_SERIAL_1		1
 	#define HAS_ADC			1
 	#define HAS_EEPROM		1
@@ -32,9 +35,13 @@
 	#define LEDS_AVAILABLE		(AO_LED_RED)
 	#define HAS_EXTERNAL_TEMP	0
 	#define HAS_ACCEL_REF		0
+	#define HAS_ACCEL		1
 #endif
 
 #if defined(TELEMETRUM_V_1_1)
+	#define HAS_USB			1
+	#define HAS_BEEP		1
+	#define HAS_GPS			1
 	#define HAS_SERIAL_1		1
 	#define HAS_ADC			1
 	#define HAS_EEPROM		1
@@ -52,9 +59,12 @@
 	#define SPI_CS_ON_P0		0
 	#define M25_CS_MASK		0x02	/* CS0 is P1_1 */
 	#define M25_MAX_CHIPS		1
+	#define HAS_ACCEL		1
 #endif
 
 #if defined(TELEDONGLE_V_0_2)
+	#define HAS_USB			1
+	#define HAS_BEEP		0
 	#define HAS_SERIAL_1		0
 	#define HAS_ADC			0
 	#define HAS_DBG			1
@@ -71,6 +81,9 @@
 #endif
 
 #if defined(TELEMETRUM_V_0_1)
+	#define HAS_USB			1
+	#define HAS_BEEP		1
+	#define HAS_GPS			1
 	#define HAS_SERIAL_1		1
 	#define HAS_ADC			1
 	#define HAS_DBG			0
@@ -86,9 +99,12 @@
 	#define HAS_ACCEL_REF		0
 	#define SPI_CS_ON_P1		1
 	#define SPI_CS_ON_P0		0
+	#define HAS_ACCEL		1
 #endif
 
 #if defined(TELEDONGLE_V_0_1)
+	#define HAS_USB			1
+	#define HAS_BEEP		0
 	#define HAS_SERIAL_1		0
 	#define HAS_ADC			0
 	#define HAS_DBG			0
@@ -105,6 +121,8 @@
 #endif
 
 #if defined(TIDONGLE)
+	#define HAS_USB			1
+	#define HAS_BEEP		0
 	#define HAS_SERIAL_1		0
 	#define HAS_ADC			0
 	#define HAS_DBG			1
diff --git a/src/ao_product.c b/src/ao_product.c
index 82d6298f..54ba2a14 100644
--- a/src/ao_product.c
+++ b/src/ao_product.c
@@ -16,7 +16,6 @@
  */
 
 #include "ao.h"
-#include "ao_usb.h"
 #include PRODUCT_DEFS
 
 /* Defines which mark this particular AltOS product */
@@ -27,6 +26,8 @@ const char ao_product[] = AO_iProduct_STRING;
 
 #define LE_WORD(x)    ((x)&0xFF),((uint8_t) (((uint16_t) (x))>>8))
 
+#if HAS_USB
+#include "ao_usb.h"
 /* USB descriptors in one giant block of bytes */
 __code __at(0x00aa) uint8_t ao_usb_descriptors [] =
 {
@@ -151,3 +152,4 @@ __code __at(0x00aa) uint8_t ao_usb_descriptors [] =
 	/* Terminating zero */
 	0
 };
+#endif
diff --git a/src/ao_report.c b/src/ao_report.c
index cc8b512b..c9ee7cae 100644
--- a/src/ao_report.c
+++ b/src/ao_report.c
@@ -37,10 +37,14 @@ static const uint8_t flight_reports[] = {
 	MORSE4(1,0,0,1),	/* invalid 'X' */
 };
 
-#if 1
-#define signal(time)	ao_beep_for(AO_BEEP_MID, time)
+#if HAS_BEEP
+#define low(time)	ao_beep_for(AO_BEEP_LOW, time)
+#define mid(time)	ao_beep_for(AO_BEEP_MID, time)
+#define high(time)	ao_beep_for(AO_BEEP_HIGH, time)
 #else
-#define signal(time)	ao_led_for(AO_LED_RED, time)
+#define low(time)	ao_led_for(AO_LED_RED, time)
+#define mid(time)	ao_led_for(AO_LED_RED|AO_LED_GREEN, time)
+#define high(time)	ao_led_for(AO_LED_GREEN, time)
 #endif
 #define pause(time)	ao_delay(time)
 
@@ -56,9 +60,9 @@ ao_report_beep(void) __reentrant
 		return;
 	while (l--) {
 		if (r & 8)
-			signal(AO_MS_TO_TICKS(600));
+			mid(AO_MS_TO_TICKS(600));
 		else
-			signal(AO_MS_TO_TICKS(200));
+			mid(AO_MS_TO_TICKS(200));
 		pause(AO_MS_TO_TICKS(200));
 		r >>= 1;
 	}
@@ -69,12 +73,12 @@ static void
 ao_report_digit(uint8_t digit) __reentrant
 {
 	if (!digit) {
-		signal(AO_MS_TO_TICKS(500));
+		mid(AO_MS_TO_TICKS(500));
 		pause(AO_MS_TO_TICKS(200));
 	} else {
 		while (digit--) {
-			signal(AO_MS_TO_TICKS(200));
-			pause(AO_MS_TO_TICKS(200));
+			mid(AO_MS_TO_TICKS(200));
+			mid(AO_MS_TO_TICKS(200));
 		}
 	}
 	pause(AO_MS_TO_TICKS(300));
@@ -118,24 +122,24 @@ ao_report_continuity(void) __reentrant
 		     (ao_report_igniter_ready(ao_igniter_main) << 1));
 	if (c) {
 		while (c--) {
-			ao_beep_for(AO_BEEP_HIGH, AO_MS_TO_TICKS(25));
+			high(AO_MS_TO_TICKS(25));
 			pause(AO_MS_TO_TICKS(100));
 		}
 	} else {
 		c = 10;
 		while (c--) {
-			ao_beep_for(AO_BEEP_HIGH, AO_MS_TO_TICKS(20));
-			ao_beep_for(AO_BEEP_LOW, AO_MS_TO_TICKS(20));
+			high(AO_MS_TO_TICKS(20));
+			low(AO_MS_TO_TICKS(20));
 		}
 	}
 	if (ao_log_full()) {
 		pause(AO_MS_TO_TICKS(100));
 		c = 2;
 		while (c--) {
-			ao_beep_for(AO_BEEP_LOW, AO_MS_TO_TICKS(100));
-			ao_beep_for(AO_BEEP_MID, AO_MS_TO_TICKS(100));
-			ao_beep_for(AO_BEEP_HIGH, AO_MS_TO_TICKS(100));
-			ao_beep_for(AO_BEEP_MID, AO_MS_TO_TICKS(100));
+			low(AO_MS_TO_TICKS(100));
+			mid(AO_MS_TO_TICKS(100));
+			high(AO_MS_TO_TICKS(100));
+			mid(AO_MS_TO_TICKS(100));
 		}
 	}
 	c = 50;
diff --git a/src/ao_telemetry.c b/src/ao_telemetry.c
index 7aad929f..dd79f3fc 100644
--- a/src/ao_telemetry.c
+++ b/src/ao_telemetry.c
@@ -42,16 +42,22 @@ ao_telemetry(void)
 		while (ao_telemetry_interval == 0)
 			ao_sleep(&ao_telemetry_interval);
 		telemetry.flight_state = ao_flight_state;
+#if HAS_ACCEL
 		telemetry.flight_accel = ao_flight_accel;
 		telemetry.ground_accel = ao_ground_accel;
 		telemetry.flight_vel = ao_flight_vel;
+#endif
 		telemetry.flight_pres = ao_flight_pres;
 		telemetry.ground_pres = ao_ground_pres;
+#if HAS_ADC
 		ao_adc_get(&telemetry.adc);
+#endif
+#if HAS_GPS
 		ao_mutex_get(&ao_gps_mutex);
 		memcpy(&telemetry.gps, &ao_gps_data, sizeof (struct ao_gps_data));
 		memcpy(&telemetry.gps_tracking, &ao_gps_tracking_data, sizeof (struct ao_gps_tracking_data));
 		ao_mutex_put(&ao_gps_mutex);
+#endif
 		ao_radio_send(&telemetry, sizeof (telemetry));
 		ao_delay(ao_telemetry_interval);
 		if (ao_rdf &&