From 81648829defbaf49fc98c4520540f7a20c50c417 Mon Sep 17 00:00:00 2001
From: Keith Packard <keithp@keithp.com>
Date: Fri, 30 Nov 2012 15:04:21 -0800
Subject: altos: Share getnibble function

Two implementations of the same function, one in cc1111/ao_dbg.c and
the other in core/ao_send_packet.c.

Signed-off-by: Keith Packard <keithp@keithp.com>
---
 src/core/ao.h             |  4 ++++
 src/core/ao_cmd.c         | 16 ++++++++++++++++
 src/core/ao_send_packet.c | 20 ++------------------
 3 files changed, 22 insertions(+), 18 deletions(-)

(limited to 'src/core')

diff --git a/src/core/ao.h b/src/core/ao.h
index 81d92e72..1aff3d49 100644
--- a/src/core/ao.h
+++ b/src/core/ao.h
@@ -170,6 +170,10 @@ ao_cmd_hex(void);
 void
 ao_cmd_decimal(void);
 
+/* Read a single hex nibble off stdin. */
+uint8_t
+ao_getnibble(void);
+
 uint8_t
 ao_match_word(__code char *word);
 
diff --git a/src/core/ao_cmd.c b/src/core/ao_cmd.c
index 1814cecf..a3330974 100644
--- a/src/core/ao_cmd.c
+++ b/src/core/ao_cmd.c
@@ -110,6 +110,22 @@ putnibble(uint8_t v)
 		putchar(v + ('a' - 10));
 }
 
+uint8_t
+ao_getnibble(void)
+{
+	char	c;
+
+	c = getchar();
+	if ('0' <= c && c <= '9')
+		return c - '0';
+	if ('a' <= c && c <= 'f')
+		return c - ('a' - 10);
+	if ('A' <= c && c <= 'F')
+		return c - ('A' - 10);
+	ao_cmd_status = ao_cmd_lex_error;
+	return 0;
+}
+
 void
 ao_cmd_put16(uint16_t v)
 {
diff --git a/src/core/ao_send_packet.c b/src/core/ao_send_packet.c
index 1a8e74de..66315d22 100644
--- a/src/core/ao_send_packet.c
+++ b/src/core/ao_send_packet.c
@@ -21,22 +21,6 @@
 
 static __xdata uint8_t ao_send[AO_MAX_SEND];
 
-static uint8_t
-getnibble(void)
-{
-	char	c;
-
-	c = getchar();
-	if ('0' <= c && c <= '9')
-		return c - '0';
-	if ('a' <= c && c <= 'f')
-		return c - ('a' - 10);
-	if ('A' <= c && c <= 'F')
-		return c - ('A' - 10);
-	ao_cmd_status = ao_cmd_lex_error;
-	return 0;
-}
-
 static void
 ao_send_packet(void)
 {
@@ -53,8 +37,8 @@ ao_send_packet(void)
 		return;
 	}
 	for (i = 0; i < count; i++) {
-		b = getnibble() << 4;
-		b |= getnibble();
+		b = ao_getnibble() << 4;
+		b |= ao_getnibble();
 		if (ao_cmd_status != ao_cmd_success)
 			return;
 		ao_send[i] = b;
-- 
cgit v1.2.3


From 0b65402361f36a0c722977bcb63edb26fda0db28 Mon Sep 17 00:00:00 2001
From: Keith Packard <keithp@keithp.com>
Date: Fri, 30 Nov 2012 16:01:07 -0800
Subject: altos: Make stdio 8-bit clean by making pollchar return int

We were stealing one value (0xff) in the return value from pollchar to
indicate 'not ready yet'. Instead of doing that, use the integer value
-1 and have pollchar return an int instead of a char. That
necessitated cleaning a few other bits to make sure that 0xff wouldn't
get promoted to -1 on accident.

Signed-off-by: Keith Packard <keithp@keithp.com>
---
 src/avr/ao_usb_avr.c    | 10 +++++-----
 src/cc1111/ao_serial.c  |  8 ++++----
 src/cc1111/ao_usb.c     | 12 ++++++------
 src/core/ao.h           |  6 +++---
 src/core/ao_packet.h    |  2 +-
 src/core/ao_serial.h    | 28 ++++++++++++++++++++++++++--
 src/core/ao_stdio.c     |  2 +-
 src/core/ao_usb.h       |  2 +-
 src/drivers/ao_packet.c |  6 +++---
 src/stm/ao_arch.h       | 36 ------------------------------------
 src/stm/ao_arch_funcs.h | 20 ++++++++++++++++++++
 src/stm/ao_serial_stm.c | 24 ++++++++++--------------
 src/stm/ao_usb_stm.c    | 10 +++++-----
 13 files changed, 85 insertions(+), 81 deletions(-)

(limited to 'src/core')

diff --git a/src/avr/ao_usb_avr.c b/src/avr/ao_usb_avr.c
index 9ba407af..2ef546c9 100644
--- a/src/avr/ao_usb_avr.c
+++ b/src/avr/ao_usb_avr.c
@@ -480,10 +480,10 @@ ao_usb_putchar(char c) __critical __reentrant
 	ao_usb_in_flushed = 0;
 }
 
-static char
+static int
 _ao_usb_pollchar(void)
 {
-	char c;
+	uint8_t c;
 	uint8_t	intx;
 
 	if (!ao_usb_running)
@@ -517,10 +517,10 @@ _ao_usb_pollchar(void)
 	return c;
 }
 
-char
+int
 ao_usb_pollchar(void)
 {
-	char	c;
+	int	c;
 	cli();
 	c = _ao_usb_pollchar();
 	sei();
@@ -530,7 +530,7 @@ ao_usb_pollchar(void)
 char
 ao_usb_getchar(void) __critical
 {
-	char	c;
+	int	c;
 
 	cli();
 	while ((c = _ao_usb_pollchar()) == AO_READ_AGAIN)
diff --git a/src/cc1111/ao_serial.c b/src/cc1111/ao_serial.c
index 48383802..2a93bf52 100644
--- a/src/cc1111/ao_serial.c
+++ b/src/cc1111/ao_serial.c
@@ -85,10 +85,10 @@ ao_serial0_getchar(void) __critical
 }
 
 #if USE_SERIAL_0_STDIN
-char
+int
 ao_serial0_pollchar(void) __critical
 {
-	char	c;
+	uint8_t	c;
 	if (ao_fifo_empty(ao_serial0_rx_fifo))
 		return AO_READ_AGAIN;
 	ao_fifo_remove(ao_serial0_rx_fifo,c);
@@ -173,10 +173,10 @@ ao_serial1_getchar(void) __critical
 }
 
 #if USE_SERIAL_1_STDIN
-char
+int
 ao_serial1_pollchar(void) __critical
 {
-	char	c;
+	uint8_t	c;
 	if (ao_fifo_empty(ao_serial1_rx_fifo))
 		return AO_READ_AGAIN;
 	ao_fifo_remove(ao_serial1_rx_fifo,c);
diff --git a/src/cc1111/ao_usb.c b/src/cc1111/ao_usb.c
index ce26e808..81e9074e 100644
--- a/src/cc1111/ao_usb.c
+++ b/src/cc1111/ao_usb.c
@@ -382,19 +382,19 @@ ao_usb_putchar(char c) __critical __reentrant
 		ao_usb_in_send();
 }
 
-char
+int
 ao_usb_pollchar(void) __critical
 {
-	char c;
+	uint8_t c;
 	if (ao_usb_out_bytes == 0) {
 		USBINDEX = AO_USB_OUT_EP;
 		if ((USBCSOL & USBCSOL_OUTPKT_RDY) == 0)
-			return AO_READ_AGAIN;
+			return -1;
 		ao_usb_out_bytes = (USBCNTH << 8) | USBCNTL;
 		if (ao_usb_out_bytes == 0) {
 			USBINDEX = AO_USB_OUT_EP;
 			USBCSOL &= ~USBCSOL_OUTPKT_RDY;
-			return AO_READ_AGAIN;
+			return -1;
 		}
 	}
 	--ao_usb_out_bytes;
@@ -409,9 +409,9 @@ ao_usb_pollchar(void) __critical
 char
 ao_usb_getchar(void) __critical
 {
-	char	c;
+	int	c;
 
-	while ((c = ao_usb_pollchar()) == AO_READ_AGAIN)
+	while ((c = ao_usb_pollchar()) == -1)
 		ao_sleep(&ao_stdin_ready);
 	return c;
 }
diff --git a/src/core/ao.h b/src/core/ao.h
index 1aff3d49..54018b37 100644
--- a/src/core/ao.h
+++ b/src/core/ao.h
@@ -599,10 +599,10 @@ ao_monitor_init(void) __reentrant;
  * ao_stdio.c
  */
 
-#define AO_READ_AGAIN	((char) -1)
+#define AO_READ_AGAIN	(-1)
 
 struct ao_stdio {
-	char	(*pollchar)(void);
+	int	(*pollchar)(void);
 	void	(*putchar)(char c) __reentrant;
 	void	(*flush)(void);
 	uint8_t	echo;
@@ -621,7 +621,7 @@ uint8_t
 ao_echo(void);
 
 int8_t
-ao_add_stdio(char (*pollchar)(void),
+ao_add_stdio(int (*pollchar)(void),
 	     void (*putchar)(char) __reentrant,
 	     void (*flush)(void)) __reentrant;
 
diff --git a/src/core/ao_packet.h b/src/core/ao_packet.h
index 0eafd3b2..08b184d6 100644
--- a/src/core/ao_packet.h
+++ b/src/core/ao_packet.h
@@ -62,7 +62,7 @@ ao_packet_flush(void);
 void
 ao_packet_putchar(char c) __reentrant;
 
-char
+int
 ao_packet_pollchar(void);
 
 #if PACKET_HAS_MASTER
diff --git a/src/core/ao_serial.h b/src/core/ao_serial.h
index 53aa8a89..a799bf2c 100644
--- a/src/core/ao_serial.h
+++ b/src/core/ao_serial.h
@@ -22,6 +22,7 @@
 #define AO_SERIAL_SPEED_9600	1
 #define AO_SERIAL_SPEED_19200	2
 #define AO_SERIAL_SPEED_57600	3
+#define AO_SERIAL_SPEED_115200	4
 
 #if HAS_SERIAL_0
 extern volatile __xdata struct ao_fifo	ao_serial0_rx_fifo;
@@ -30,6 +31,9 @@ extern volatile __xdata struct ao_fifo	ao_serial0_tx_fifo;
 char
 ao_serial0_getchar(void);
 
+int
+ao_serial0_pollchar(void);
+
 void
 ao_serial0_putchar(char c);
 
@@ -47,7 +51,7 @@ extern volatile __xdata struct ao_fifo	ao_serial1_tx_fifo;
 char
 ao_serial1_getchar(void);
 
-char
+int
 ao_serial1_pollchar(void);
 
 void
@@ -67,7 +71,7 @@ extern volatile __xdata struct ao_fifo	ao_serial2_tx_fifo;
 char
 ao_serial2_getchar(void);
 
-char
+int
 ao_serial2_pollchar(void);
 
 void
@@ -80,6 +84,26 @@ void
 ao_serial2_set_speed(uint8_t speed);
 #endif
 
+#if HAS_SERIAL_3
+extern volatile __xdata struct ao_fifo	ao_serial3_rx_fifo;
+extern volatile __xdata struct ao_fifo	ao_serial3_tx_fifo;
+
+char
+ao_serial3_getchar(void);
+
+int
+ao_serial3_pollchar(void);
+
+void
+ao_serial3_putchar(char c);
+
+void
+ao_serial3_drain(void);
+
+void
+ao_serial3_set_speed(uint8_t speed);
+#endif
+
 void
 ao_serial_init(void);
 
diff --git a/src/core/ao_stdio.c b/src/core/ao_stdio.c
index 8cf66a23..4a832487 100644
--- a/src/core/ao_stdio.c
+++ b/src/core/ao_stdio.c
@@ -123,7 +123,7 @@ ao_echo(void)
 }
 
 int8_t
-ao_add_stdio(char (*pollchar)(void),
+ao_add_stdio(int (*pollchar)(void),
 	     void (*putchar)(char),
 	     void (*flush)(void)) __reentrant
 {
diff --git a/src/core/ao_usb.h b/src/core/ao_usb.h
index e051db93..4476ee6b 100644
--- a/src/core/ao_usb.h
+++ b/src/core/ao_usb.h
@@ -33,7 +33,7 @@ ao_usb_getchar(void);
 /* Poll for a charcter on the USB input queue.
  * returns AO_READ_AGAIN if none are available
  */
-char
+int
 ao_usb_pollchar(void);
 
 /* Flush the USB output queue */
diff --git a/src/drivers/ao_packet.c b/src/drivers/ao_packet.c
index 3c1e7a18..91319923 100644
--- a/src/drivers/ao_packet.c
+++ b/src/drivers/ao_packet.c
@@ -21,8 +21,8 @@ __xdata struct ao_packet_recv ao_rx_packet;
 __xdata struct ao_packet ao_tx_packet;
 __pdata uint8_t ao_packet_rx_len, ao_packet_rx_used, ao_packet_tx_used;
 
-static __xdata char tx_data[AO_PACKET_MAX];
-static __xdata char rx_data[AO_PACKET_MAX];
+static __xdata uint8_t tx_data[AO_PACKET_MAX];
+static __xdata uint8_t rx_data[AO_PACKET_MAX];
 static __pdata uint8_t rx_seq;
 
 __xdata struct ao_task	ao_packet_task;
@@ -169,7 +169,7 @@ ao_packet_putchar(char c) __reentrant
 		tx_data[ao_packet_tx_used++] = c;
 }
 
-char
+int
 ao_packet_pollchar(void)
 {
 	/* No need to block interrupts, all variables here
diff --git a/src/stm/ao_arch.h b/src/stm/ao_arch.h
index e270199e..007f7e2e 100644
--- a/src/stm/ao_arch.h
+++ b/src/stm/ao_arch.h
@@ -123,42 +123,6 @@ void ao_lcd_font_init(void);
 
 void ao_lcd_font_string(char *s);
 
-char
-ao_serial1_getchar(void);
-
-void
-ao_serial1_putchar(char c);
-
-char
-ao_serial1_pollchar(void);
-
-void
-ao_serial1_set_speed(uint8_t speed);
-
-char
-ao_serial2_getchar(void);
-
-void
-ao_serial2_putchar(char c);
-
-char
-ao_serial2_pollchar(void);
-
-void
-ao_serial2_set_speed(uint8_t speed);
-
-char
-ao_serial3_getchar(void);
-
-void
-ao_serial3_putchar(char c);
-
-char
-ao_serial3_pollchar(void);
-
-void
-ao_serial3_set_speed(uint8_t speed);
-
 extern const uint32_t	ao_radio_cal;
 
 void
diff --git a/src/stm/ao_arch_funcs.h b/src/stm/ao_arch_funcs.h
index d6ab1465..87bbe73e 100644
--- a/src/stm/ao_arch_funcs.h
+++ b/src/stm/ao_arch_funcs.h
@@ -210,6 +210,26 @@ ao_i2c_recv(void *block, uint16_t len, uint8_t i2c_index, uint8_t stop);
 void
 ao_i2c_init(void);
 
+/* ao_serial_stm.c */
+struct ao_stm_usart {
+	struct ao_fifo		rx_fifo;
+	struct ao_fifo		tx_fifo;
+	struct stm_usart	*reg;
+	uint8_t			tx_started;
+};
+
+#if HAS_SERIAL_1
+extern struct ao_stm_usart	ao_stm_usart1;
+#endif
+
+#if HAS_SERIAL_2
+extern struct ao_stm_usart	ao_stm_usart2;
+#endif
+
+#if HAS_SERIAL_3
+extern struct ao_stm_usart	ao_stm_usart3;
+#endif
+
 #define ARM_PUSH32(stack, val)	(*(--(stack)) = (val))
 
 static inline uint32_t
diff --git a/src/stm/ao_serial_stm.c b/src/stm/ao_serial_stm.c
index 00409f4a..94138edc 100644
--- a/src/stm/ao_serial_stm.c
+++ b/src/stm/ao_serial_stm.c
@@ -17,13 +17,6 @@
 
 #include <ao.h>
 
-struct ao_stm_usart {
-	struct ao_fifo		rx_fifo;
-	struct ao_fifo		tx_fifo;
-	struct stm_usart	*reg;
-	uint8_t			tx_started;
-};
-
 void
 ao_debug_out(char c)
 {
@@ -78,16 +71,19 @@ ao_usart_getchar(struct ao_stm_usart *usart)
 	return c;
 }
 
-char
+int
 ao_usart_pollchar(struct ao_stm_usart *usart)
 {
-	char	c;
+	int	c;
 	
 	ao_arch_block_interrupts();
 	if (ao_fifo_empty(usart->rx_fifo))
 		c = AO_READ_AGAIN;
-	else
-		ao_fifo_remove(usart->rx_fifo,c);
+	else {
+		uint8_t	u;
+		ao_fifo_remove(usart->rx_fifo,u);
+		c = u;
+	}
 	ao_arch_release_interrupts();
 	return c;
 }
@@ -201,7 +197,7 @@ ao_serial1_putchar(char c)
 	ao_usart_putchar(&ao_stm_usart1, c);
 }
 
-char
+int
 ao_serial1_pollchar(void)
 {
 	return ao_usart_pollchar(&ao_stm_usart1);
@@ -232,7 +228,7 @@ ao_serial2_putchar(char c)
 	ao_usart_putchar(&ao_stm_usart2, c);
 }
 
-char
+int
 ao_serial2_pollchar(void)
 {
 	return ao_usart_pollchar(&ao_stm_usart2);
@@ -263,7 +259,7 @@ ao_serial3_putchar(char c)
 	ao_usart_putchar(&ao_stm_usart3, c);
 }
 
-char
+int
 ao_serial3_pollchar(void)
 {
 	return ao_usart_pollchar(&ao_stm_usart3);
diff --git a/src/stm/ao_usb_stm.c b/src/stm/ao_usb_stm.c
index d93a0c17..9379e5cd 100644
--- a/src/stm/ao_usb_stm.c
+++ b/src/stm/ao_usb_stm.c
@@ -873,10 +873,10 @@ _ao_usb_out_recv(void)
 	ao_usb_set_stat_rx(AO_USB_OUT_EPR, STM_USB_EPR_STAT_RX_VALID);
 }
 
-static char
+static int
 _ao_usb_pollchar(void)
 {
-	char c;
+	uint8_t c;
 
 	if (!ao_usb_running)
 		return AO_READ_AGAIN;
@@ -896,10 +896,10 @@ _ao_usb_pollchar(void)
 	return c;
 }
 
-char
+int
 ao_usb_pollchar(void)
 {
-	char	c;
+	int	c;
 	ao_arch_block_interrupts();
 	c = _ao_usb_pollchar();
 	ao_arch_release_interrupts();
@@ -909,7 +909,7 @@ ao_usb_pollchar(void)
 char
 ao_usb_getchar(void)
 {
-	char	c;
+	int	c;
 
 	ao_arch_block_interrupts();
 	while ((c = _ao_usb_pollchar()) == AO_READ_AGAIN)
-- 
cgit v1.2.3


From f2c2d04f07253a90c4f7da49df43c3969119516b Mon Sep 17 00:00:00 2001
From: Keith Packard <keithp@keithp.com>
Date: Fri, 30 Nov 2012 16:04:24 -0800
Subject: altos: Use ao_xmemcpy in ao_log_telem.c

This eliminates the libc generic version in TeleTerra

Signed-off-by: Keith Packard <keithp@keithp.com>
---
 src/core/ao_log_telem.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'src/core')

diff --git a/src/core/ao_log_telem.c b/src/core/ao_log_telem.c
index 18ab85dd..23ebf7dd 100644
--- a/src/core/ao_log_telem.c
+++ b/src/core/ao_log_telem.c
@@ -102,9 +102,9 @@ ao_log_single(void)
 		while (ao_log_running) {
 			/* Write samples to EEPROM */
 			while (ao_log_monitor_pos != ao_monitor_head) {
-				memcpy(&ao_log_single_write_data.telemetry,
-				       &ao_monitor_ring[ao_log_monitor_pos],
-				       AO_LOG_SINGLE_SIZE);
+				ao_xmemcpy(&ao_log_single_write_data.telemetry,
+					   &ao_monitor_ring[ao_log_monitor_pos],
+					   AO_LOG_SINGLE_SIZE);
 				ao_log_single_write();
 				ao_log_monitor_pos = ao_monitor_ring_next(ao_log_monitor_pos);
 				ao_log_telem_track();
-- 
cgit v1.2.3


From ae0ddb0f866a26867f0147e0811717810f74c9ef Mon Sep 17 00:00:00 2001
From: Keith Packard <keithp@keithp.com>
Date: Fri, 30 Nov 2012 16:05:19 -0800
Subject: altos: Add ao_task_minimize_latency to reduce IRQ delays

When set, this causes the task switching code to avoid blocking IRQs
while looking for an idle task as that can increase IRQ latencies
enough to drop characters at 115200 baud on the cc1111. Note that this
*also* eliminates the ability to use low power modes as we cannot know
at any point whether some interrupt has come along and woken a task.

Has no effect when using task queues as those require IRQs to be
blocked while looking at the queue. Shouldn't be a problem there
though as the check for no running tasks is very cheap.

Signed-off-by: Keith Packard <keithp@keithp.com>
---
 src/core/ao_task.c | 11 +++++++++--
 src/core/ao_task.h |  1 +
 2 files changed, 10 insertions(+), 2 deletions(-)

(limited to 'src/core')

diff --git a/src/core/ao_task.c b/src/core/ao_task.c
index 0411fbdd..9cb074b5 100644
--- a/src/core/ao_task.c
+++ b/src/core/ao_task.c
@@ -305,6 +305,8 @@ ao_add_task(__xdata struct ao_task * task, void (*start)(void), __code char *nam
 		);
 }
 
+__data uint8_t	ao_task_minimize_latency;
+
 /* Task switching function. This must not use any stack variables */
 void
 ao_yield(void) ao_arch_naked_define
@@ -331,7 +333,12 @@ ao_yield(void) ao_arch_naked_define
 	}
 
 	ao_arch_isr_stack();
-	ao_arch_block_interrupts();
+#if !HAS_TASK_QUEUE
+	if (ao_task_minimize_latency)
+		ao_arch_release_interrupts();
+	else
+#endif
+		ao_arch_block_interrupts();
 
 #if AO_CHECK_STACK
 	in_yield = 1;
@@ -374,7 +381,7 @@ ao_yield(void) ao_arch_naked_define
 				break;
 
 			/* Wait for interrupts when there's nothing ready */
-			if (ao_cur_task_index == ao_last_task_index)
+			if (ao_cur_task_index == ao_last_task_index && !ao_task_minimize_latency)
 				ao_arch_wait_interrupt();
 		}
 	}
diff --git a/src/core/ao_task.h b/src/core/ao_task.h
index 049f69a7..50bfb220 100644
--- a/src/core/ao_task.h
+++ b/src/core/ao_task.h
@@ -47,6 +47,7 @@ struct ao_task {
 extern __xdata struct ao_task * __xdata ao_tasks[AO_NUM_TASKS];
 extern __data uint8_t ao_num_tasks;
 extern __xdata struct ao_task *__data ao_cur_task;
+extern __data uint8_t ao_task_minimize_latency;	/* Reduce IRQ latency */
 
 /*
  ao_task.c
-- 
cgit v1.2.3


From c1e6fa32b856b91afa355cd272d2d7287d3ccca1 Mon Sep 17 00:00:00 2001
From: Keith Packard <keithp@keithp.com>
Date: Thu, 6 Dec 2012 10:12:11 -0800
Subject: altos: Hook APRS up to the radio

This adds an arbitrary-length packet writing function to the radio
code.

Signed-off-by: Keith Packard <keithp@keithp.com>
---
 src/core/ao.h                |   5 ++
 src/drivers/ao_aprs.c        |  48 +++++-------
 src/drivers/ao_cc1120.c      | 175 +++++++++++++++++++++++++++++++++++++------
 src/megametrum-v0.1/Makefile |   1 +
 src/test/ao_aprs_test.c      |   6 ++
 5 files changed, 183 insertions(+), 52 deletions(-)

(limited to 'src/core')

diff --git a/src/core/ao.h b/src/core/ao.h
index 54018b37..d6e27707 100644
--- a/src/core/ao.h
+++ b/src/core/ao.h
@@ -529,6 +529,11 @@ ao_radio_recv_abort(void);
 void
 ao_radio_test(uint8_t on);
 
+typedef int16_t (*ao_radio_fill_func)(uint8_t *buffer, int16_t len);
+
+void
+ao_radio_send_lots(ao_radio_fill_func fill);
+
 /*
  * Compute the packet length as follows:
  *
diff --git a/src/drivers/ao_aprs.c b/src/drivers/ao_aprs.c
index 1a074ba5..e273908f 100644
--- a/src/drivers/ao_aprs.c
+++ b/src/drivers/ao_aprs.c
@@ -145,11 +145,6 @@
 
 #include <ao_aprs.h>
 
-typedef int bool_t;
-typedef int32_t int32;
-#define false 0
-#define true 1
-
 // Public methods, constants, and data structures for each class.
 
 static void timeInit(void);
@@ -285,9 +280,6 @@ static uint8_t tncLength;
 /// A copy of the last 5 bits we've transmitted to determine if we need to bit stuff on the next bit.
 static uint8_t tncBitStuff;
 
-/// Pointer to TNC buffer as we save each byte during message preparation.
-static uint8_t *tncBufferPnt;
-
 /// Buffer to hold the message portion of the AX.25 packet as we prepare it.
 static uint8_t tncBuffer[TNC_BUFFER_SIZE];
 
@@ -471,18 +463,18 @@ static void tnc1200TimerTick()
 /**
  *   Generate the plain text position packet.
  */
-static void tncPositionPacket(void)
+static int tncPositionPacket(void)
 {
-    int32_t	latitude = 45.4694766 * 10000000;
-    int32_t	longitude = -122.7376250 * 10000000;
-    uint32_t	altitude = 10000;
+    int32_t	latitude = ao_gps_data.latitude;
+    int32_t	longitude = ao_gps_data.longitude;
+    int32_t	altitude = ao_gps_data.altitude;
+
     uint16_t	lat_deg;
     uint16_t	lon_deg;
     uint16_t	lat_min;
     uint16_t	lat_frac;
     uint16_t	lon_min;
     uint16_t	lon_frac;
-    int		c;
 
     char	lat_sign = 'N', lon_sign = 'E';
 
@@ -510,12 +502,15 @@ static void tncPositionPacket(void)
     longitude -= lon_min * 10000000;
     lon_frac = (longitude + 50000) / 100000;
 
-    c = sprintf ((char *) tncBufferPnt, "=%02u%02u.%02u%c\\%03u%02u.%02u%cO /A=%06u\015",
-		lat_deg, lat_min, lat_frac, lat_sign,
-		lon_deg, lon_min, lon_frac, lon_sign,
-		altitude * 100 / 3048);
-    tncBufferPnt += c;
-    tncLength += c;
+    if (altitude < 0)
+	altitude = 0;
+
+    altitude = altitude * (int32_t) 1000 / (int32_t) 3048;
+    
+    return sprintf ((char *) tncBuffer, "=%02u%02u.%02u%c\\%03u%02u.%02u%cO /A=%06u\015",
+		    lat_deg, lat_min, lat_frac, lat_sign,
+		    lon_deg, lon_min, lon_frac, lon_sign,
+		    altitude);
 }
 
 static int16_t
@@ -553,24 +548,15 @@ void ao_aprs_send(void)
     timeInit();
     tncInit();
 
-    // Set a pointer to our TNC output buffer.
-    tncBufferPnt = tncBuffer;
-
-    // Set the message length counter.
-    tncLength = 0;
-
-    tncPositionPacket();
+    tncLength = tncPositionPacket();
 
     // Calculate the CRC for the header and message.
     crc = sysCRC16(TNC_AX25_HEADER, sizeof(TNC_AX25_HEADER), 0xffff);
     crc = sysCRC16(tncBuffer, tncLength, crc ^ 0xffff);
 
     // Save the CRC in the message.
-    *tncBufferPnt++ = crc & 0xff;
-    *tncBufferPnt = (crc >> 8) & 0xff;
-
-    // Update the length to include the CRC bytes.
-    tncLength += 2;
+    tncBuffer[tncLength++] = crc & 0xff;
+    tncBuffer[tncLength++] = (crc >> 8) & 0xff;
 
     // Prepare the variables that are used in the real-time clock interrupt.
     tncBitCount = 0;
diff --git a/src/drivers/ao_cc1120.c b/src/drivers/ao_cc1120.c
index f27958f9..ed26e28d 100644
--- a/src/drivers/ao_cc1120.c
+++ b/src/drivers/ao_cc1120.c
@@ -323,12 +323,12 @@ static const uint16_t packet_rx_setup[] = {
 /*
  * For our RDF beacon, set the symbol rate to 2kBaud (for a 1kHz tone)
  *
- *              (2**20 - DATARATE_M) * 2 ** DATARATE_E
+ *              (2**20 + DATARATE_M) * 2 ** DATARATE_E
  *	Rdata = -------------------------------------- * fosc
  *		             2 ** 39
  *
- *	DATARATE_M = 511705
- *	DATARATE_E = 6
+ *	DATARATE_M = 25166
+ *	DATARATE_E = 5
  *
  * To make the tone last for 200ms, we need 2000 * .2 = 400 bits or 50 bytes
  */
@@ -358,7 +358,64 @@ static const uint16_t rdf_setup[] = {
 				 (0 << CC1120_PKT_CFG0_UART_SWAP_EN)),
 };
 
-static uint8_t ao_radio_mode;
+/*
+ * APRS deviation is 5kHz
+ *
+ *	fdev = fosc >> 24 * (256 + dev_m) << dev_e
+ *
+ *     	32e6Hz / (2 ** 24) * (256 + 71) * (2 ** 3) = 4989
+ */
+
+#define APRS_DEV_E	3
+#define APRS_DEV_M	71
+#define APRS_PACKET_LEN	50
+
+/*
+ * For our APRS beacon, set the symbol rate to 9.6kBaud (8x oversampling for 1200 baud data rate)
+ *
+ *              (2**20 + DATARATE_M) * 2 ** DATARATE_E
+ *	Rdata = -------------------------------------- * fosc
+ *		             2 ** 39
+ *
+ *	DATARATE_M = 239914
+ *	DATARATE_E = 7
+ *
+ *	Rdata = 9599.998593330383301
+ *
+ */
+#define APRS_DRATE_E	5
+#define APRS_DRATE_M	25166
+
+static const uint16_t aprs_setup[] = {
+	CC1120_DEVIATION_M,	APRS_DEV_M,
+	CC1120_MODCFG_DEV_E,	((CC1120_MODCFG_DEV_E_MODEM_MODE_NORMAL << CC1120_MODCFG_DEV_E_MODEM_MODE) |
+				 (CC1120_MODCFG_DEV_E_MOD_FORMAT_2_GFSK << CC1120_MODCFG_DEV_E_MOD_FORMAT) |
+				 (APRS_DEV_E << CC1120_MODCFG_DEV_E_DEV_E)),
+	CC1120_DRATE2,		((APRS_DRATE_E << CC1120_DRATE2_DATARATE_E) |
+				 (((APRS_DRATE_M >> 16) & CC1120_DRATE2_DATARATE_M_19_16_MASK) << CC1120_DRATE2_DATARATE_M_19_16)),
+	CC1120_DRATE1,		((APRS_DRATE_M >> 8) & 0xff),
+	CC1120_DRATE0,		((APRS_DRATE_M >> 0) & 0xff),
+	CC1120_PKT_CFG2,	((CC1120_PKT_CFG2_CCA_MODE_ALWAYS_CLEAR << CC1120_PKT_CFG2_CCA_MODE) |
+				 (CC1120_PKT_CFG2_PKT_FORMAT_NORMAL << CC1120_PKT_CFG2_PKT_FORMAT)),
+	CC1120_PKT_CFG1,	((0 << CC1120_PKT_CFG1_WHITE_DATA) |
+				 (CC1120_PKT_CFG1_ADDR_CHECK_CFG_NONE << CC1120_PKT_CFG1_ADDR_CHECK_CFG) |
+				 (CC1120_PKT_CFG1_CRC_CFG_DISABLED << CC1120_PKT_CFG1_CRC_CFG) |
+				 (0 << CC1120_PKT_CFG1_APPEND_STATUS)),
+};
+
+#define AO_PKT_CFG0_INFINITE ((0 << CC1120_PKT_CFG0_RESERVED7) |	\
+			      (CC1120_PKT_CFG0_LENGTH_CONFIG_INFINITE << CC1120_PKT_CFG0_LENGTH_CONFIG) | \
+			      (0 << CC1120_PKT_CFG0_PKG_BIT_LEN) |	\
+			      (0 << CC1120_PKT_CFG0_UART_MODE_EN) |	\
+			      (0 << CC1120_PKT_CFG0_UART_SWAP_EN))
+
+#define AO_PKT_CFG0_FIXED ((0 << CC1120_PKT_CFG0_RESERVED7) |		\
+			   (CC1120_PKT_CFG0_LENGTH_CONFIG_FIXED << CC1120_PKT_CFG0_LENGTH_CONFIG) | \
+			   (0 << CC1120_PKT_CFG0_PKG_BIT_LEN) |		\
+			   (0 << CC1120_PKT_CFG0_UART_MODE_EN) |	\
+			   (0 << CC1120_PKT_CFG0_UART_SWAP_EN))
+
+static uint16_t ao_radio_mode;
 
 #define AO_RADIO_MODE_BITS_PACKET	1
 #define AO_RADIO_MODE_BITS_PACKET_TX	2
@@ -366,17 +423,22 @@ static uint8_t ao_radio_mode;
 #define AO_RADIO_MODE_BITS_TX_FINISH	8
 #define AO_RADIO_MODE_BITS_PACKET_RX	16
 #define AO_RADIO_MODE_BITS_RDF		32
+#define AO_RADIO_MODE_BITS_APRS		64
+#define AO_RADIO_MODE_BITS_INFINITE	128
+#define AO_RADIO_MODE_BITS_FIXED	256
 
 #define AO_RADIO_MODE_NONE		0
 #define AO_RADIO_MODE_PACKET_TX_BUF	(AO_RADIO_MODE_BITS_PACKET | AO_RADIO_MODE_BITS_PACKET_TX | AO_RADIO_MODE_BITS_TX_BUF)
 #define AO_RADIO_MODE_PACKET_TX_FINISH	(AO_RADIO_MODE_BITS_PACKET | AO_RADIO_MODE_BITS_PACKET_TX | AO_RADIO_MODE_BITS_TX_FINISH)
 #define AO_RADIO_MODE_PACKET_RX		(AO_RADIO_MODE_BITS_PACKET | AO_RADIO_MODE_BITS_PACKET_RX)
 #define AO_RADIO_MODE_RDF		(AO_RADIO_MODE_BITS_RDF | AO_RADIO_MODE_BITS_TX_FINISH)
+#define AO_RADIO_MODE_APRS_BUF		(AO_RADIO_MODE_BITS_APRS | AO_RADIO_MODE_BITS_INFINITE)
+#define AO_RADIO_MODE_APRS_FINISH	(AO_RADIO_MODE_BITS_APRS | AO_RADIO_MODE_BITS_FIXED)
 
 static void
-ao_radio_set_mode(uint8_t new_mode)
+ao_radio_set_mode(uint16_t new_mode)
 {
-	uint8_t	changes;
+	uint16_t changes;
 	int i;
 
 	if (new_mode == ao_radio_mode)
@@ -404,6 +466,17 @@ ao_radio_set_mode(uint8_t new_mode)
 	if (changes & AO_RADIO_MODE_BITS_RDF)
 		for (i = 0; i < sizeof (rdf_setup) / sizeof (rdf_setup[0]); i += 2)
 			ao_radio_reg_write(rdf_setup[i], rdf_setup[i+1]);
+
+	if (changes & AO_RADIO_MODE_BITS_APRS)
+		for (i = 0; i < sizeof (aprs_setup) / sizeof (aprs_setup[0]); i += 2)
+			ao_radio_reg_write(aprs_setup[i], aprs_setup[i+1]);
+
+	if (changes & AO_RADIO_MODE_BITS_INFINITE)
+		ao_radio_reg_write(CC1120_PKT_CFG0, AO_PKT_CFG0_INFINITE);
+
+	if (changes & AO_RADIO_MODE_BITS_FIXED)
+		ao_radio_reg_write(CC1120_PKT_CFG0, AO_PKT_CFG0_FIXED);
+
 	ao_radio_mode = new_mode;
 }
 
@@ -430,11 +503,21 @@ ao_radio_setup(void)
 	ao_radio_configured = 1;
 }
 
+static void
+ao_radio_set_len(uint8_t len)
+{
+	static uint8_t	last_len;
+
+	if (len != last_len) {
+		ao_radio_reg_write(CC1120_PKT_LEN, len);
+		last_len = len;
+	}
+}
+
 static void
 ao_radio_get(uint8_t len)
 {
 	static uint32_t	last_radio_setting;
-	static uint8_t	last_len;
 
 	ao_mutex_get(&ao_radio_mutex);
 	if (!ao_radio_configured)
@@ -445,10 +528,7 @@ ao_radio_get(uint8_t len)
 		ao_radio_reg_write(CC1120_FREQ0, ao_config.radio_setting);
 		last_radio_setting = ao_config.radio_setting;
 	}
-	if (len != last_len) {
-		ao_radio_reg_write(CC1120_PKT_LEN, len);
-		last_len = len;
-	}
+	ao_radio_set_len(len);
 }
 
 #define ao_radio_put()	ao_mutex_put(&ao_radio_mutex)
@@ -562,6 +642,24 @@ ao_radio_test_cmd(void)
 	}
 }
 
+static uint8_t
+ao_radio_wait_tx(uint8_t wait_fifo)
+{
+	uint8_t	fifo_space = 0;
+
+	do {
+		ao_radio_wake = 0;
+		ao_arch_block_interrupts();
+		while (!ao_radio_wake)
+			ao_sleep(&ao_radio_wake);
+		ao_arch_release_interrupts();
+		if (!wait_fifo)
+			return 0;
+		fifo_space = ao_radio_tx_fifo_space();
+	} while (!fifo_space);
+	return fifo_space;
+}
+
 static uint8_t	tx_data[(AO_RADIO_MAX_SEND + 4) * 2];
 
 void
@@ -601,16 +699,51 @@ ao_radio_send(const void *d, uint8_t size)
 			ao_exti_enable(AO_CC1120_INT_PORT, AO_CC1120_INT_PIN);
 		}
 			
-		do {
-			ao_radio_wake = 0;
-			ao_arch_block_interrupts();
-			while (!ao_radio_wake)
-				ao_sleep(&ao_radio_wake);
-			ao_arch_release_interrupts();
-			if (!encode_len)
-				break;
-			fifo_space = ao_radio_tx_fifo_space();
-		} while (!fifo_space);
+		fifo_space = ao_radio_wait_tx(encode_len != 0);
+	}
+	ao_radio_put();
+}
+
+#define AO_RADIO_LOTS	64
+
+void
+ao_radio_send_lots(ao_radio_fill_func fill)
+{
+	uint8_t	buf[AO_RADIO_LOTS], *b;
+	int	cnt;
+	int	total = 0;
+	uint8_t	done = 0;
+	uint8_t	started = 0;
+	uint8_t	fifo_space;
+
+	ao_radio_get(0xff);
+	fifo_space = CC1120_FIFO_SIZE;
+	while (!done) {
+		cnt = (*fill)(buf, sizeof(buf));
+		if (cnt < 0) {
+			done = 1;
+			cnt = -cnt;
+		}
+		total += cnt;
+		if (done) {
+			ao_radio_set_len(total & 0xff);
+			ao_radio_set_mode(AO_RADIO_MODE_APRS_FINISH);
+		} else
+			ao_radio_set_mode(AO_RADIO_MODE_APRS_BUF);
+		b = buf;
+		while (cnt) {
+			uint8_t	this_len = cnt;
+			if (this_len > fifo_space)
+				this_len = fifo_space;
+			ao_radio_fifo_write(b, this_len);
+			b += this_len;
+			cnt -= this_len;
+			if (!started) {
+				ao_radio_start_tx();
+				started = 1;
+			}
+			fifo_space = ao_radio_wait_tx(!done || cnt);
+		}
 	}
 	ao_radio_put();
 }
diff --git a/src/megametrum-v0.1/Makefile b/src/megametrum-v0.1/Makefile
index 7d6c7388..25d0ed03 100644
--- a/src/megametrum-v0.1/Makefile
+++ b/src/megametrum-v0.1/Makefile
@@ -90,6 +90,7 @@ ALTOS_SRC = \
 	ao_packet.c \
 	ao_companion.c \
 	ao_pyro.c \
+	ao_aprs.c \
 	$(PROFILE) \
 	$(SAMPLE_PROFILE) \
 	$(STACK_GUARD)
diff --git a/src/test/ao_aprs_test.c b/src/test/ao_aprs_test.c
index d0cfb52d..f16c94e8 100644
--- a/src/test/ao_aprs_test.c
+++ b/src/test/ao_aprs_test.c
@@ -23,6 +23,8 @@
 
 #include <ao_telemetry.h>
 
+struct ao_telemetry_location ao_gps_data;
+
 #define AO_APRS_TEST
 
 typedef int16_t (*ao_radio_fill_func)(uint8_t *buffer, int16_t len);
@@ -91,6 +93,10 @@ int main(int argc, char **argv)
 {
     audio_gap(1);
 
+    ao_gps_data.latitude = 45.4694766 * 10000000;
+    ao_gps_data.longitude = -122.7376250 * 10000000;
+    ao_gps_data.altitude = 83;
+
     /* Transmit one packet */
     ao_aprs_send();
 
-- 
cgit v1.2.3


From f661da527fb4a3a492f5322e2a718d441e1cde83 Mon Sep 17 00:00:00 2001
From: Keith Packard <keithp@keithp.com>
Date: Thu, 6 Dec 2012 10:23:39 -0800
Subject: altos: Hook up APRS to telemetry loop

Send APRS packet once every 2 seconds

Signed-off-by: Keith Packard <keithp@keithp.com>
---
 src/core/ao_telemetry.c       | 21 ++++++++++++++++++++-
 src/drivers/ao_aprs.h         |  2 ++
 src/megametrum-v0.1/ao_pins.h |  1 +
 3 files changed, 23 insertions(+), 1 deletion(-)

(limited to 'src/core')

diff --git a/src/core/ao_telemetry.c b/src/core/ao_telemetry.c
index 52ac9489..79d1bb81 100644
--- a/src/core/ao_telemetry.c
+++ b/src/core/ao_telemetry.c
@@ -22,6 +22,12 @@ static __pdata uint16_t ao_telemetry_interval;
 static __pdata uint8_t ao_rdf = 0;
 static __pdata uint16_t ao_rdf_time;
 
+#if HAS_APRS
+static __pdata uint16_t ao_aprs_time;
+
+#include <ao_aprs.h>
+#endif
+
 #if defined(MEGAMETRUM)
 #define AO_SEND_MEGA	1
 #endif
@@ -288,6 +294,9 @@ ao_telemetry(void)
 		while (ao_telemetry_interval == 0)
 			ao_sleep(&telemetry);
 		time = ao_rdf_time = ao_time();
+#if HAS_APRS
+		ao_aprs_time = time;
+#endif
 		while (ao_telemetry_interval) {
 
 
@@ -325,6 +334,12 @@ ao_telemetry(void)
 #endif
 					ao_radio_rdf();
 			}
+#if HAS_APRS
+			if (ao_rdf && (int16_t) (ao_time() - ao_aprs_time) >= 0) {
+				ao_aprs_time = ao_time() + AO_APRS_INTERVAL_TICKS;
+				ao_aprs_send();
+			}
+#endif
 #endif
 			time += ao_telemetry_interval;
 			delay = time - ao_time();
@@ -389,8 +404,12 @@ ao_rdf_set(uint8_t rdf)
 	ao_rdf = rdf;
 	if (rdf == 0)
 		ao_radio_rdf_abort();
-	else
+	else {
 		ao_rdf_time = ao_time() + AO_RDF_INTERVAL_TICKS;
+#if HAS_APRS
+		ao_aprs_time = ao_time() + AO_APRS_INTERVAL_TICKS;
+#endif
+	}
 }
 
 __xdata struct ao_task	ao_telemetry_task;
diff --git a/src/drivers/ao_aprs.h b/src/drivers/ao_aprs.h
index a033fa0b..e00dd75b 100644
--- a/src/drivers/ao_aprs.h
+++ b/src/drivers/ao_aprs.h
@@ -18,6 +18,8 @@
 #ifndef _AO_APRS_H_
 #define _AO_APRS_H_
 
+#define AO_APRS_INTERVAL_TICKS	AO_SEC_TO_TICKS(2)
+
 void
 ao_aprs_send(void);
 
diff --git a/src/megametrum-v0.1/ao_pins.h b/src/megametrum-v0.1/ao_pins.h
index f07dc26e..083c1b6f 100644
--- a/src/megametrum-v0.1/ao_pins.h
+++ b/src/megametrum-v0.1/ao_pins.h
@@ -70,6 +70,7 @@
 #define HAS_BEEP		1
 #define HAS_RADIO		1
 #define HAS_TELEMETRY		1
+#define HAS_APRS		1
 
 #define HAS_SPI_1		1
 #define SPI_1_PA5_PA6_PA7	1	/* Barometer */
-- 
cgit v1.2.3


From 1f84c0adbfa494ddc7dbe276796d999560be9438 Mon Sep 17 00:00:00 2001
From: Keith Packard <keithp@keithp.com>
Date: Thu, 6 Dec 2012 10:28:14 -0800
Subject: altos: Allow telemetry, rdf and APRS to be individually controlled

But, only when APRS is available so that TeleMetrum and TeleMini don't
change behaviour

Signed-off-by: Keith Packard <keithp@keithp.com>
---
 src/core/ao.h           |  5 +++++
 src/core/ao_config.c    |  2 +-
 src/core/ao_telemetry.c | 31 +++++++++++++++++++++----------
 3 files changed, 27 insertions(+), 11 deletions(-)

(limited to 'src/core')

diff --git a/src/core/ao.h b/src/core/ao.h
index d6e27707..fa873efe 100644
--- a/src/core/ao.h
+++ b/src/core/ao.h
@@ -717,6 +717,11 @@ struct ao_config {
 #define AO_IGNITE_MODE_APOGEE		1
 #define AO_IGNITE_MODE_MAIN		2
 
+#define AO_RADIO_ENABLE_CORE		1
+#define AO_RADIO_ENABLE_APRS		2
+#define AO_RADIO_DISABLE_TELEMETRY	4
+#define AO_RADIO_DISABLE_RDF		8
+
 #define AO_PAD_ORIENTATION_ANTENNA_UP	0
 #define AO_PAD_ORIENTATION_ANTENNA_DOWN	1
 
diff --git a/src/core/ao_config.c b/src/core/ao_config.c
index e85ddcb4..df40ff90 100644
--- a/src/core/ao_config.c
+++ b/src/core/ao_config.c
@@ -128,7 +128,7 @@ _ao_config_get(void)
 		if (minor < 6)
 			ao_config.pad_orientation = AO_CONFIG_DEFAULT_PAD_ORIENTATION;
 		if (minor < 8)
-			ao_config.radio_enable = TRUE;
+			ao_config.radio_enable = AO_RADIO_ENABLE_CORE;
 		if (minor < 9)
 			ao_xmemset(&ao_config.aes_key, '\0', AO_AES_LEN);
 		if (minor < 10)
diff --git a/src/core/ao_telemetry.c b/src/core/ao_telemetry.c
index 79d1bb81..4ff98f9b 100644
--- a/src/core/ao_telemetry.c
+++ b/src/core/ao_telemetry.c
@@ -300,27 +300,35 @@ ao_telemetry(void)
 		while (ao_telemetry_interval) {
 
 
+#if HAS_APRS
+			if (!(ao_config.radio_enable & AO_RADIO_DISABLE_TELEMETRY))
+#endif
+			{
 #ifdef AO_SEND_ALL_BARO
-			ao_send_baro();
+				ao_send_baro();
 #endif
 #ifdef AO_SEND_MEGA
-			ao_send_mega_sensor();
-			ao_send_mega_data();
+				ao_send_mega_sensor();
+				ao_send_mega_data();
 #else
-			ao_send_sensor();
+				ao_send_sensor();
 #endif
 
 #if HAS_COMPANION
-			if (ao_companion_running)
-				ao_send_companion();
+				if (ao_companion_running)
+					ao_send_companion();
 #endif
-			ao_send_configuration();
+				ao_send_configuration();
 #if HAS_GPS
-			ao_send_location();
-			ao_send_satellite();
+				ao_send_location();
+				ao_send_satellite();
 #endif
+			}
 #ifndef AO_SEND_ALL_BARO
 			if (ao_rdf &&
+#if HAS_APRS
+			    !(ao_config.radio_enable & AO_RADIO_DISABLE_RDF) &&
+#endif
 			    (int16_t) (ao_time() - ao_rdf_time) >= 0)
 			{
 #if HAS_IGNITE_REPORT
@@ -335,7 +343,10 @@ ao_telemetry(void)
 					ao_radio_rdf();
 			}
 #if HAS_APRS
-			if (ao_rdf && (int16_t) (ao_time() - ao_aprs_time) >= 0) {
+			if (ao_rdf &&
+			    (ao_config.radio_enable & AO_RADIO_ENABLE_APRS) &&
+			    (int16_t) (ao_time() - ao_aprs_time) >= 0)
+			{
 				ao_aprs_time = ao_time() + AO_APRS_INTERVAL_TICKS;
 				ao_aprs_send();
 			}
-- 
cgit v1.2.3


From 75912f8af04cecc0bbffecb2072d465c3744d4e8 Mon Sep 17 00:00:00 2001
From: Keith Packard <keithp@keithp.com>
Date: Thu, 6 Dec 2012 10:30:46 -0800
Subject: altos: Send APRS packets even during ascent

If you're using APRS, presumably you want to watch the rocket going up too.

Signed-off-by: Keith Packard <keithp@keithp.com>
---
 src/core/ao_telemetry.c | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

(limited to 'src/core')

diff --git a/src/core/ao_telemetry.c b/src/core/ao_telemetry.c
index 4ff98f9b..cfc72e04 100644
--- a/src/core/ao_telemetry.c
+++ b/src/core/ao_telemetry.c
@@ -343,8 +343,7 @@ ao_telemetry(void)
 					ao_radio_rdf();
 			}
 #if HAS_APRS
-			if (ao_rdf &&
-			    (ao_config.radio_enable & AO_RADIO_ENABLE_APRS) &&
+			if ((ao_config.radio_enable & AO_RADIO_ENABLE_APRS) &&
 			    (int16_t) (ao_time() - ao_aprs_time) >= 0)
 			{
 				ao_aprs_time = ao_time() + AO_APRS_INTERVAL_TICKS;
@@ -417,9 +416,6 @@ ao_rdf_set(uint8_t rdf)
 		ao_radio_rdf_abort();
 	else {
 		ao_rdf_time = ao_time() + AO_RDF_INTERVAL_TICKS;
-#if HAS_APRS
-		ao_aprs_time = ao_time() + AO_APRS_INTERVAL_TICKS;
-#endif
 	}
 }
 
-- 
cgit v1.2.3


From 9d095eb1987f35d0d4e6540bf335e1faaa7c86ec Mon Sep 17 00:00:00 2001
From: Keith Packard <keithp@keithp.com>
Date: Thu, 6 Dec 2012 16:29:36 -0800
Subject: altos: Shrink 'ao_version' by calling printf fewer times

Each printf call costs quite a bit of code space on the cc1111, so
instead of making multiple short calls, make one longer one.

Signed-off-by: Keith Packard <keithp@keithp.com>
---
 src/core/ao_cmd.c | 21 +++++++++++++++++----
 1 file changed, 17 insertions(+), 4 deletions(-)

(limited to 'src/core')

diff --git a/src/core/ao_cmd.c b/src/core/ao_cmd.c
index a3330974..9e78a225 100644
--- a/src/core/ao_cmd.c
+++ b/src/core/ao_cmd.c
@@ -265,12 +265,25 @@ ao_reboot(void)
 static void
 version(void)
 {
-	printf("manufacturer     %s\n", ao_manufacturer);
-	printf("product          %s\n", ao_product);
-	printf("serial-number    %u\n", ao_serial_number);
+	printf("manufacturer     %s\n"
+	       "product          %s\n"
+	       "serial-number    %u\n"
+#if HAS_FLIGHT
+	       "flight-number    %u\n"
+#endif
+#if HAS_LOG
+	       "log-format       %u\n"
+#endif
+	       , ao_manufacturer
+	       , ao_product
+	       , ao_serial_number
+#if HAS_FLIGHT
+	       , ao_flight_number
+#endif
 #if HAS_LOG
-	printf("log-format       %u\n", ao_log_format);
+	       , ao_log_format
 #endif
+		);
 #if HAS_MS5607
 	ao_ms5607_info();
 #endif
-- 
cgit v1.2.3


From b4e86af6de52ea0bacf80e3936b6cd17c1cbf898 Mon Sep 17 00:00:00 2001
From: Keith Packard <keithp@keithp.com>
Date: Thu, 6 Dec 2012 17:06:17 -0800
Subject: altos: Change 'flight-number' to 'current-flight'

Avoids ambiguity with stored flight info, which starts lines with 'flight'.

Signed-off-by: Keith Packard <keithp@keithp.com>
---
 src/core/ao_cmd.c    |  2 +-
 src/core/ao_config.c | 12 ++++--------
 2 files changed, 5 insertions(+), 9 deletions(-)

(limited to 'src/core')

diff --git a/src/core/ao_cmd.c b/src/core/ao_cmd.c
index 9e78a225..3d086a57 100644
--- a/src/core/ao_cmd.c
+++ b/src/core/ao_cmd.c
@@ -269,7 +269,7 @@ version(void)
 	       "product          %s\n"
 	       "serial-number    %u\n"
 #if HAS_FLIGHT
-	       "flight-number    %u\n"
+	       "current-flight   %u\n"
 #endif
 #if HAS_LOG
 	       "log-format       %u\n"
diff --git a/src/core/ao_config.c b/src/core/ao_config.c
index e85ddcb4..797fe7ec 100644
--- a/src/core/ao_config.c
+++ b/src/core/ao_config.c
@@ -529,15 +529,15 @@ __code struct ao_config_var ao_config_vars[] = {
 	  ao_config_callsign_set,	ao_config_callsign_show },
 	{ "e <0 disable, 1 enable>\0Enable telemetry and RDF",
 	  ao_config_radio_enable_set, ao_config_radio_enable_show },
+	{ "f <cal>\0Radio calib (cal = rf/(xtal/2^16))",
+	  ao_config_radio_cal_set,  	ao_config_radio_cal_show },
 #endif /* HAS_RADIO */
 #if HAS_ACCEL
 	{ "a <+g> <-g>\0Accel calib (0 for auto)",
 	  ao_config_accel_calibrate_set,ao_config_accel_calibrate_show },
+	{ "o <0 antenna up, 1 antenna down>\0Set pad orientation",
+	  ao_config_pad_orientation_set,ao_config_pad_orientation_show },
 #endif /* HAS_ACCEL */
-#if HAS_RADIO
-	{ "f <cal>\0Radio calib (cal = rf/(xtal/2^16))",
-	  ao_config_radio_cal_set,  	ao_config_radio_cal_show },
-#endif /* HAS_RADIO */
 #if HAS_LOG
 	{ "l <size>\0Flight log size (kB)",
 	  ao_config_log_set,		ao_config_log_show },
@@ -546,10 +546,6 @@ __code struct ao_config_var ao_config_vars[] = {
 	{ "i <0 dual, 1 apogee, 2 main>\0Set igniter mode",
 	  ao_config_ignite_mode_set,	ao_config_ignite_mode_show },
 #endif
-#if HAS_ACCEL
-	{ "o <0 antenna up, 1 antenna down>\0Set pad orientation",
-	  ao_config_pad_orientation_set,ao_config_pad_orientation_show },
-#endif
 #if HAS_AES
 	{ "k <32 hex digits>\0Set AES encryption key",
 	  ao_config_key_set, ao_config_key_show },
-- 
cgit v1.2.3


From c10f9a438ed5789479d21c78153ca7f14c05534c Mon Sep 17 00:00:00 2001
From: Keith Packard <keithp@keithp.com>
Date: Fri, 7 Dec 2012 10:05:51 -0800
Subject: altos: fix functions calling pollchar to use 'int' to hold the value

AO_READ_AGAIN doesn't fit in a char anymore now that stdio is 8-bit
clean, everyone using pollchar must use an 'int' variable to capture
the whole value from pollchar.

Signed-off-by: Keith Packard <keithp@keithp.com>
---
 src/cc1111/ao_usb.c            | 2 +-
 src/core/ao_stdio.c            | 2 +-
 src/drivers/ao_btm.c           | 2 +-
 src/drivers/ao_packet_master.c | 4 ++--
 4 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'src/core')

diff --git a/src/cc1111/ao_usb.c b/src/cc1111/ao_usb.c
index 81e9074e..f66e807c 100644
--- a/src/cc1111/ao_usb.c
+++ b/src/cc1111/ao_usb.c
@@ -411,7 +411,7 @@ ao_usb_getchar(void) __critical
 {
 	int	c;
 
-	while ((c = ao_usb_pollchar()) == -1)
+	while ((c = ao_usb_pollchar()) == AO_READ_AGAIN)
 		ao_sleep(&ao_stdin_ready);
 	return c;
 }
diff --git a/src/core/ao_stdio.c b/src/core/ao_stdio.c
index 4a832487..1748dfe8 100644
--- a/src/core/ao_stdio.c
+++ b/src/core/ao_stdio.c
@@ -98,7 +98,7 @@ __xdata uint8_t ao_stdin_ready;
 char
 getchar(void) __reentrant
 {
-	char c;
+	int c;
 	ao_arch_critical(
 		int8_t stdio = ao_cur_stdio;
 
diff --git a/src/drivers/ao_btm.c b/src/drivers/ao_btm.c
index f3816047..c862200a 100644
--- a/src/drivers/ao_btm.c
+++ b/src/drivers/ao_btm.c
@@ -120,7 +120,7 @@ uint8_t
 ao_btm_get_line(void)
 {
 	uint8_t ao_btm_reply_len = 0;
-	char c;
+	int c;
 
 	for (;;) {
 
diff --git a/src/drivers/ao_packet_master.c b/src/drivers/ao_packet_master.c
index 481232df..023c788b 100644
--- a/src/drivers/ao_packet_master.c
+++ b/src/drivers/ao_packet_master.c
@@ -20,7 +20,7 @@
 static char
 ao_packet_getchar(void)
 {
-	char c;
+	int c;
 	while ((c = ao_packet_pollchar()) == AO_READ_AGAIN) {
 		if (!ao_packet_enable)
 			break;
@@ -35,7 +35,7 @@ ao_packet_getchar(void)
 static void
 ao_packet_echo(void) __reentrant
 {
-	char	c;
+	int	c;
 	while (ao_packet_enable) {
 		c = ao_packet_getchar();
 		if (c != AO_READ_AGAIN)
-- 
cgit v1.2.3


From b28323ce91d23db5e1c3cbd1309c72aafcfbe235 Mon Sep 17 00:00:00 2001
From: Keith Packard <keithp@keithp.com>
Date: Fri, 7 Dec 2012 17:18:32 -0800
Subject: altos: Make APRS interval configurable

This provides a separate configuration value for APRS, allowing the
interval between APRS reports to vary.

Signed-off-by: Keith Packard <keithp@keithp.com>
---
 src/core/ao.h           |  8 ++++----
 src/core/ao_config.c    | 27 +++++++++++++++++++++++++++
 src/core/ao_telemetry.c |  5 ++---
 src/drivers/ao_aprs.h   |  2 --
 4 files changed, 33 insertions(+), 9 deletions(-)

(limited to 'src/core')

diff --git a/src/core/ao.h b/src/core/ao.h
index fa873efe..df5bbf48 100644
--- a/src/core/ao.h
+++ b/src/core/ao.h
@@ -684,7 +684,7 @@ extern __xdata uint8_t ao_force_freq;
 #endif
 
 #define AO_CONFIG_MAJOR	1
-#define AO_CONFIG_MINOR	12
+#define AO_CONFIG_MINOR	13
 
 #define AO_AES_LEN 16
 
@@ -711,6 +711,7 @@ struct ao_config {
 #if AO_PYRO_NUM
 	struct ao_pyro	pyro[AO_PYRO_NUM];	/* minor version 12 */
 #endif
+	uint16_t	aprs_interval;		/* minor version 13 */
 };
 
 #define AO_IGNITE_MODE_DUAL		0
@@ -718,9 +719,8 @@ struct ao_config {
 #define AO_IGNITE_MODE_MAIN		2
 
 #define AO_RADIO_ENABLE_CORE		1
-#define AO_RADIO_ENABLE_APRS		2
-#define AO_RADIO_DISABLE_TELEMETRY	4
-#define AO_RADIO_DISABLE_RDF		8
+#define AO_RADIO_DISABLE_TELEMETRY	2
+#define AO_RADIO_DISABLE_RDF		4
 
 #define AO_PAD_ORIENTATION_ANTENNA_UP	0
 #define AO_PAD_ORIENTATION_ANTENNA_DOWN	1
diff --git a/src/core/ao_config.c b/src/core/ao_config.c
index 63158158..0aac16a6 100644
--- a/src/core/ao_config.c
+++ b/src/core/ao_config.c
@@ -139,6 +139,8 @@ _ao_config_get(void)
 		if (minor < 12)
 			memset(&ao_config.pyro, '\0', sizeof (ao_config.pyro));
 #endif
+		if (minor < 13)
+			ao_config.aprs_interval = 0;
 		ao_config.minor = AO_CONFIG_MINOR;
 		ao_config_dirty = 1;
 	}
@@ -498,6 +500,27 @@ ao_config_key_set(void) __reentrant
 }
 #endif
 
+#if HAS_APRS
+
+void
+ao_config_aprs_show(void)
+{
+	printf ("APRS interval: %d\n", ao_config.aprs_interval);
+}
+
+void
+ao_config_aprs_set(void)
+{
+	ao_cmd_decimal();
+	if (ao_cmd_status != ao_cmd_success)
+		return;
+	_ao_config_edit_start();
+	ao_config.aprs_interval = ao_cmd_lex_i;
+	_ao_config_edit_finish();
+}
+
+#endif /* HAS_APRS */
+
 struct ao_config_var {
 	__code char	*str;
 	void		(*set)(void) __reentrant;
@@ -553,6 +576,10 @@ __code struct ao_config_var ao_config_vars[] = {
 #if AO_PYRO_NUM
 	{ "P <n,?>\0Configure pyro channels",
 	  ao_pyro_set, ao_pyro_show },
+#endif
+#if HAS_APRS
+	{ "A <secs>\0APRS packet interval (0 disable)",
+	  ao_config_aprs_set, ao_config_aprs_show },
 #endif
 	{ "s\0Show",
 	  ao_config_show,		0 },
diff --git a/src/core/ao_telemetry.c b/src/core/ao_telemetry.c
index cfc72e04..8d440e15 100644
--- a/src/core/ao_telemetry.c
+++ b/src/core/ao_telemetry.c
@@ -299,7 +299,6 @@ ao_telemetry(void)
 #endif
 		while (ao_telemetry_interval) {
 
-
 #if HAS_APRS
 			if (!(ao_config.radio_enable & AO_RADIO_DISABLE_TELEMETRY))
 #endif
@@ -343,10 +342,10 @@ ao_telemetry(void)
 					ao_radio_rdf();
 			}
 #if HAS_APRS
-			if ((ao_config.radio_enable & AO_RADIO_ENABLE_APRS) &&
+			if (ao_config.aprs_interval != 0 &&
 			    (int16_t) (ao_time() - ao_aprs_time) >= 0)
 			{
-				ao_aprs_time = ao_time() + AO_APRS_INTERVAL_TICKS;
+				ao_aprs_time = ao_time() + AO_SEC_TO_TICKS(ao_config.aprs_interval);
 				ao_aprs_send();
 			}
 #endif
diff --git a/src/drivers/ao_aprs.h b/src/drivers/ao_aprs.h
index e00dd75b..a033fa0b 100644
--- a/src/drivers/ao_aprs.h
+++ b/src/drivers/ao_aprs.h
@@ -18,8 +18,6 @@
 #ifndef _AO_APRS_H_
 #define _AO_APRS_H_
 
-#define AO_APRS_INTERVAL_TICKS	AO_SEC_TO_TICKS(2)
-
 void
 ao_aprs_send(void);
 
-- 
cgit v1.2.3


From b1d37be4c024e9690107c693d9819229025966fa Mon Sep 17 00:00:00 2001
From: Keith Packard <keithp@keithp.com>
Date: Mon, 17 Dec 2012 17:03:41 -0800
Subject: altos: Average MPU6000 values on ground for later use

Having long-term ground averages recorded to the eeprom file will make
post-flight analysis of the data better.

Signed-off-by: Keith Packard <keithp@keithp.com>
---
 src/core/ao_data.h        | 21 +++++++++++
 src/core/ao_log.h         | 14 +++++--
 src/core/ao_sample.c      | 95 ++++++++++++++++++++++++++++++++++++++++++++++-
 src/core/ao_sqrt.c        |  2 +
 src/test/ao_flight_test.c | 17 ++++++++-
 5 files changed, 142 insertions(+), 7 deletions(-)

(limited to 'src/core')

diff --git a/src/core/ao_data.h b/src/core/ao_data.h
index 6fdd19cb..7e2f85d8 100644
--- a/src/core/ao_data.h
+++ b/src/core/ao_data.h
@@ -288,4 +288,25 @@ typedef int16_t accel_t;
 
 #endif
 
+#if !HAS_GYRO && HAS_MPU6000
+
+#define HAS_GYRO	1
+
+typedef int16_t	gyro_t;
+typedef int32_t angle_t;
+
+/* Y axis is aligned with the direction of motion (along) */
+/* X axis is aligned in the other board axis (across) */
+/* Z axis is aligned perpendicular to the board (through) */
+
+#define ao_data_along(packet)	((packet)->mpu6000.accel_y)
+#define ao_data_across(packet)	((packet)->mpu6000.accel_x)
+#define ao_data_through(packet)	((packet)->mpu6000.accel_z)
+
+#define ao_data_roll(packet)	((packet)->mpu6000.gyro_y)
+#define ao_data_pitch(packet)	((packet)->mpu6000.gyro_x)
+#define ao_data_yaw(packet)	((packet)->mpu6000.gyro_z)
+
+#endif
+
 #endif /* _AO_DATA_H_ */
diff --git a/src/core/ao_log.h b/src/core/ao_log.h
index 4eaed420..93b01778 100644
--- a/src/core/ao_log.h
+++ b/src/core/ao_log.h
@@ -199,10 +199,16 @@ struct ao_log_mega {
 	union {						/* 4 */
 		/* AO_LOG_FLIGHT */
 		struct {
-			uint16_t	flight;		/* 4 */
-			int16_t		ground_accel;	/* 6 */
-			uint32_t	ground_pres;	/* 8 */
-		} flight;				/* 12 */
+			uint16_t	flight;			/* 4 */
+			int16_t		ground_accel;		/* 6 */
+			uint32_t	ground_pres;		/* 8 */
+			int16_t		ground_accel_along;	/* 16 */
+			int16_t		ground_accel_across;	/* 12 */
+			int16_t		ground_accel_through;	/* 14 */
+			int16_t		ground_gyro_roll;	/* 18 */
+			int16_t		ground_gyro_pitch;	/* 20 */
+			int16_t		ground_gyro_yaw;	/* 22 */
+		} flight;					/* 24 */
 		/* AO_LOG_STATE */
 		struct {
 			uint16_t	state;
diff --git a/src/core/ao_sample.c b/src/core/ao_sample.c
index 985c0940..7a1eff8e 100644
--- a/src/core/ao_sample.c
+++ b/src/core/ao_sample.c
@@ -37,6 +37,16 @@ __pdata alt_t		ao_sample_height;
 #if HAS_ACCEL
 __pdata accel_t		ao_sample_accel;
 #endif
+#if HAS_GYRO
+__pdata accel_t		ao_sample_accel_along;
+__pdata accel_t		ao_sample_accel_across;
+__pdata accel_t		ao_sample_accel_through;
+__pdata gyro_t		ao_sample_roll;
+__pdata gyro_t		ao_sample_pitch;
+__pdata gyro_t		ao_sample_yaw;
+__pdata angle_t		ao_sample_angle;
+__pdata angle_t		ao_sample_roll_angle;
+#endif
 
 __data uint8_t		ao_sample_data;
 
@@ -53,6 +63,15 @@ __pdata accel_t		ao_accel_2g;		/* factory accel calibration */
 __pdata int32_t		ao_accel_scale;		/* sensor to m/s² conversion */
 #endif
 
+#if HAS_GYRO
+__pdata accel_t		ao_ground_accel_along;
+__pdata accel_t		ao_ground_accel_across;
+__pdata accel_t		ao_ground_accel_through;
+__pdata gyro_t		ao_ground_pitch;
+__pdata gyro_t		ao_ground_yaw;
+__pdata gyro_t		ao_ground_roll;
+#endif
+
 static __pdata uint8_t	ao_preflight;		/* in preflight mode */
 
 static __pdata uint16_t	nsamples;
@@ -60,6 +79,14 @@ __pdata int32_t ao_sample_pres_sum;
 #if HAS_ACCEL
 __pdata int32_t ao_sample_accel_sum;
 #endif
+#if HAS_GYRO
+__pdata int32_t ao_sample_accel_along_sum;
+__pdata int32_t ao_sample_accel_across_sum;
+__pdata int32_t	ao_sample_accel_through_sum;
+__pdata int32_t ao_sample_pitch_sum;
+__pdata int32_t ao_sample_yaw_sum;
+__pdata int32_t	ao_sample_roll_sum;
+#endif
 
 static void
 ao_sample_preflight_add(void)
@@ -68,6 +95,14 @@ ao_sample_preflight_add(void)
 	ao_sample_accel_sum += ao_sample_accel;
 #endif
 	ao_sample_pres_sum += ao_sample_pres;
+#if HAS_GYRO
+	ao_sample_accel_along_sum += ao_sample_accel_along;
+	ao_sample_accel_across_sum += ao_sample_accel_across;
+	ao_sample_accel_through_sum += ao_sample_accel_through;
+	ao_sample_pitch_sum += ao_sample_pitch;
+	ao_sample_yaw_sum += ao_sample_yaw;
+	ao_sample_roll_sum += ao_sample_roll;
+#endif
 	++nsamples;
 }
 
@@ -80,8 +115,23 @@ ao_sample_preflight_set(void)
 #endif
 	ao_ground_pres = ao_sample_pres_sum >> 9;
 	ao_ground_height = pres_to_altitude(ao_ground_pres);
-	nsamples = 0;
 	ao_sample_pres_sum = 0;
+#if HAS_GYRO
+	ao_ground_accel_along = ao_sample_accel_along_sum >> 9;
+	ao_ground_accel_across = ao_sample_accel_across_sum >> 9;
+	ao_ground_accel_through = ao_sample_accel_through_sum >> 9;
+	ao_ground_pitch = ao_sample_pitch_sum >> 9;
+	ao_ground_yaw = ao_sample_yaw_sum >> 9;
+	ao_ground_roll = ao_sample_roll_sum >> 9;
+	ao_sample_accel_along_sum = 0;
+	ao_sample_accel_across_sum = 0;
+	ao_sample_accel_through_sum = 0;
+	ao_sample_pitch_sum = 0;
+	ao_sample_yaw_sum = 0;
+	ao_sample_roll_sum = 0;
+	ao_sample_angle = 0;
+#endif	
+	nsamples = 0;
 }
 
 static void
@@ -122,6 +172,24 @@ ao_sample_preflight_update(void)
 		ao_sample_preflight_set();
 }
 
+#if HAS_GYRO
+
+static int32_t	p_filt;
+static int32_t	y_filt;
+
+static gyro_t inline ao_gyro(void) {
+	gyro_t	p = ao_sample_pitch - ao_ground_pitch;
+	gyro_t	y = ao_sample_yaw - ao_ground_yaw;
+
+	p_filt = p_filt - (p_filt >> 6) + p;
+	y_filt = y_filt - (y_filt >> 6) + y;
+
+	p = p_filt >> 6;
+	y = y_filt >> 6;
+	return ao_sqrt(p*p + y*y);
+}
+#endif
+
 uint8_t
 ao_sample(void)
 {
@@ -147,6 +215,12 @@ ao_sample(void)
 			ao_sample_accel = ao_data_accel_invert(ao_sample_accel);
 		ao_data_set_accel(ao_data, ao_sample_accel);
 #endif
+#if HAS_GYRO
+		ao_sample_accel_along = ao_data_along(ao_data);
+		ao_sample_pitch = ao_data_pitch(ao_data);
+		ao_sample_yaw = ao_data_yaw(ao_data);
+		ao_sample_roll = ao_data_roll(ao_data);
+#endif
 
 		if (ao_preflight)
 			ao_sample_preflight();
@@ -154,6 +228,10 @@ ao_sample(void)
 			if (ao_flight_state < ao_flight_boost)
 				ao_sample_preflight_update();
 			ao_kalman();
+#if HAS_GYRO
+			ao_sample_angle += ao_gyro();
+			ao_sample_roll_angle += (ao_sample_roll - ao_ground_roll);
+#endif
 		}
 		ao_sample_data = ao_data_ring_next(ao_sample_data);
 	}
@@ -170,6 +248,21 @@ ao_sample_init(void)
 #if HAS_ACCEL
 	ao_sample_accel_sum = 0;
 	ao_sample_accel = 0;
+#endif
+#if HAS_GYRO
+	ao_sample_accel_along_sum = 0;
+	ao_sample_accel_across_sum = 0;
+	ao_sample_accel_through_sum = 0;
+	ao_sample_accel_along = 0;
+	ao_sample_accel_across = 0;
+	ao_sample_accel_through = 0;
+	ao_sample_pitch_sum = 0;
+	ao_sample_yaw_sum = 0;
+	ao_sample_roll_sum = 0;
+	ao_sample_pitch = 0;
+	ao_sample_yaw = 0;
+	ao_sample_roll = 0;
+	ao_sample_angle = 0;
 #endif
 	ao_sample_data = ao_data_head;
 	ao_preflight = TRUE;
diff --git a/src/core/ao_sqrt.c b/src/core/ao_sqrt.c
index 09c2e319..3a550eaa 100644
--- a/src/core/ao_sqrt.c
+++ b/src/core/ao_sqrt.c
@@ -15,7 +15,9 @@
  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  */
 
+#ifndef AO_FLIGHT_TEST
 #include "ao.h"
+#endif
 
 /* Adapted from int_sqrt.c in the linux kernel, which is licensed GPLv2 */
 /**
diff --git a/src/test/ao_flight_test.c b/src/test/ao_flight_test.c
index acdf4d92..cdd1f236 100644
--- a/src/test/ao_flight_test.c
+++ b/src/test/ao_flight_test.c
@@ -236,10 +236,14 @@ extern int32_t	ao_accel_scale;
 extern alt_t	ao_ground_height;
 extern alt_t	ao_sample_alt;
 
+double ao_sample_qangle;
+
 int ao_sample_prev_tick;
 uint16_t	prev_tick;
 
+
 #include "ao_kalman.c"
+#include "ao_sqrt.c"
 #include "ao_sample.c"
 #include "ao_flight.c"
 
@@ -309,7 +313,7 @@ ao_mpu6000_accel(int16_t sensor)
 }
 
 static double
-ao_mpu6000_gyro(int16_t sensor)
+ao_mpu6000_gyro(int32_t sensor)
 {
 	return sensor / 32767.0 * MPU6000_GYRO_FULLSCALE;
 }
@@ -370,6 +374,7 @@ ao_insert(void)
 		if (!ao_summary) {
 			printf("%7.2f height %8.2f accel %8.3f "
 #if MEGAMETRUM
+			       "roll %8.3f angle %8.3f qangle %8.3f "
 			       "accel_x %8.3f accel_y %8.3f accel_z %8.3f gyro_x %8.3f gyro_y %8.3f gyro_z %8.3f "
 #endif
 			       "state %-8.8s k_height %8.2f k_speed %8.3f k_accel %8.3f avg_height %5d drogue %4d main %4d error %5d\n",
@@ -377,6 +382,9 @@ ao_insert(void)
 			       height,
 			       accel,
 #if MEGAMETRUM
+			       ao_mpu6000_gyro(ao_sample_roll_angle) / 100.0,
+			       ao_mpu6000_gyro(ao_sample_angle) / 100.0,
+			       ao_sample_qangle,
 			       ao_mpu6000_accel(ao_data_static.mpu6000.accel_x),
 			       ao_mpu6000_accel(ao_data_static.mpu6000.accel_y),
 			       ao_mpu6000_accel(ao_data_static.mpu6000.accel_z),
@@ -715,12 +723,14 @@ update_orientation (double rate_x, double rate_y, double rate_z, int tick)
 	q_dot.q2 =  0.5 * (ao_orient.q0 * rate_y + ao_orient.q3 * rate_x - ao_orient.q1 * rate_z) + lambda * ao_orient.q2;
 	q_dot.q3 =  0.5 * (ao_orient.q0 * rate_z + ao_orient.q1 * rate_y - ao_orient.q2 * rate_x) + lambda * ao_orient.q3;
 
+#if 0
 	printf ("update_orientation %g %g %g (%g s)\n", rate_x, rate_y, rate_z, dt);
 	printf ("q_dot (%g) %g %g %g\n",
 		q_dot.q0,
 		q_dot.q1,
 		q_dot.q2,
 		q_dot.q3);
+#endif
 
 	ao_orient.q0 += q_dot.q0 * dt;
 	ao_orient.q1 += q_dot.q1 * dt;
@@ -731,6 +741,8 @@ update_orientation (double rate_x, double rate_y, double rate_z, int tick)
 
 	ao_quat_rot(&ao_current, &ao_up, &ao_orient);
 
+	ao_sample_qangle = 180 / M_PI * acos(ao_current.q3 * sqrt(2));
+#if 0
 	printf ("orient (%g) %g %g %g current (%g) %g %g %g\n",
 		ao_orient.q0,
 		ao_orient.q1,
@@ -740,6 +752,7 @@ update_orientation (double rate_x, double rate_y, double rate_z, int tick)
 		ao_current.q1,
 		ao_current.q2,
 		ao_current.q3);
+#endif
 }
 #endif
 
@@ -845,7 +858,7 @@ ao_sleep(void *wchan)
 						double		rate_y = ao_mpu6000_gyro(ao_data_static.mpu6000.gyro_y - ao_ground_mpu6000.gyro_y);
 						double		rate_z = ao_mpu6000_gyro(ao_data_static.mpu6000.gyro_z - ao_ground_mpu6000.gyro_z);
 
-						update_orientation(rate_x, rate_z, rate_y, tick);
+						update_orientation(rate_x * M_PI / 180, rate_z * M_PI / 180, rate_y * M_PI / 180, tick);
 					}
 					ao_records_read++;
 					ao_insert();
-- 
cgit v1.2.3


From 57487e78b90465a21c87cf30deb0aeaba0887332 Mon Sep 17 00:00:00 2001
From: Keith Packard <keithp@keithp.com>
Date: Tue, 18 Dec 2012 23:15:20 -0800
Subject: altos: Actually record ground averages for 6dof sensor

This gets the long-term averages for the 6dof sensors recorded into
the first flight log record.

Signed-off-by: Keith Packard <keithp@keithp.com>
---
 src/core/ao_log.h      | 6 +++---
 src/core/ao_log_mega.c | 8 ++++++++
 src/core/ao_sample.c   | 8 +++++---
 src/core/ao_sample.h   | 8 ++++++++
 4 files changed, 24 insertions(+), 6 deletions(-)

(limited to 'src/core')

diff --git a/src/core/ao_log.h b/src/core/ao_log.h
index 93b01778..036d6f2d 100644
--- a/src/core/ao_log.h
+++ b/src/core/ao_log.h
@@ -205,9 +205,9 @@ struct ao_log_mega {
 			int16_t		ground_accel_along;	/* 16 */
 			int16_t		ground_accel_across;	/* 12 */
 			int16_t		ground_accel_through;	/* 14 */
-			int16_t		ground_gyro_roll;	/* 18 */
-			int16_t		ground_gyro_pitch;	/* 20 */
-			int16_t		ground_gyro_yaw;	/* 22 */
+			int16_t		ground_roll;		/* 18 */
+			int16_t		ground_pitch;		/* 20 */
+			int16_t		ground_yaw;		/* 22 */
 		} flight;					/* 24 */
 		/* AO_LOG_STATE */
 		struct {
diff --git a/src/core/ao_log_mega.c b/src/core/ao_log_mega.c
index ac1590db..e03687ad 100644
--- a/src/core/ao_log_mega.c
+++ b/src/core/ao_log_mega.c
@@ -94,6 +94,14 @@ ao_log(void)
 	log.tick = ao_sample_tick;
 #if HAS_ACCEL
 	log.u.flight.ground_accel = ao_ground_accel;
+#endif
+#if HAS_GYRO
+	log.u.flight.ground_accel_along = ao_ground_accel_along;
+	log.u.flight.ground_accel_across = ao_ground_accel_across;
+	log.u.flight.ground_accel_through = ao_ground_accel_through;
+	log.u.flight.ground_pitch = ao_ground_pitch;
+	log.u.flight.ground_yaw = ao_ground_yaw;
+	log.u.flight.ground_roll = ao_ground_roll;
 #endif
 	log.u.flight.ground_pres = ao_ground_pres;
 	log.u.flight.flight = ao_flight_number;
diff --git a/src/core/ao_sample.c b/src/core/ao_sample.c
index 7a1eff8e..dec44f9f 100644
--- a/src/core/ao_sample.c
+++ b/src/core/ao_sample.c
@@ -172,8 +172,8 @@ ao_sample_preflight_update(void)
 		ao_sample_preflight_set();
 }
 
+#if 0
 #if HAS_GYRO
-
 static int32_t	p_filt;
 static int32_t	y_filt;
 
@@ -189,6 +189,7 @@ static gyro_t inline ao_gyro(void) {
 	return ao_sqrt(p*p + y*y);
 }
 #endif
+#endif
 
 uint8_t
 ao_sample(void)
@@ -217,6 +218,8 @@ ao_sample(void)
 #endif
 #if HAS_GYRO
 		ao_sample_accel_along = ao_data_along(ao_data);
+		ao_sample_accel_across = ao_data_across(ao_data);
+		ao_sample_accel_through = ao_data_through(ao_data);
 		ao_sample_pitch = ao_data_pitch(ao_data);
 		ao_sample_yaw = ao_data_yaw(ao_data);
 		ao_sample_roll = ao_data_roll(ao_data);
@@ -229,8 +232,7 @@ ao_sample(void)
 				ao_sample_preflight_update();
 			ao_kalman();
 #if HAS_GYRO
-			ao_sample_angle += ao_gyro();
-			ao_sample_roll_angle += (ao_sample_roll - ao_ground_roll);
+			/* do quaternion stuff here... */
 #endif
 		}
 		ao_sample_data = ao_data_ring_next(ao_sample_data);
diff --git a/src/core/ao_sample.h b/src/core/ao_sample.h
index 9336bdf9..a2dac979 100644
--- a/src/core/ao_sample.h
+++ b/src/core/ao_sample.h
@@ -111,6 +111,14 @@ extern __pdata accel_t	ao_ground_accel;	/* startup acceleration */
 extern __pdata accel_t 	ao_accel_2g;		/* factory accel calibration */
 extern __pdata int32_t	ao_accel_scale;		/* sensor to m/s² conversion */
 #endif
+#if HAS_GYRO
+extern __pdata accel_t	ao_ground_accel_along;
+extern __pdata accel_t	ao_ground_accel_across;
+extern __pdata accel_t	ao_ground_accel_through;
+extern __pdata gyro_t	ao_ground_pitch;
+extern __pdata gyro_t	ao_ground_yaw;
+extern __pdata gyro_t	ao_ground_roll;
+#endif
 
 void ao_sample_init(void);
 
-- 
cgit v1.2.3