altos: Make telemetrum-v1.1 compile with new ao_data structure

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

diff --git a/src/cc1111/ao_adc.c b/src/cc1111/ao_adc.c
index 1688eceb8f6c84e43fad6fa71e4e5784ac2c9def..1e3d8cabc7b94359645ad1594221f5c7923cc27e 100644 (file)
--- a/src/cc1111/ao_adc.c
+++ b/src/cc1111/ao_adc.c
@@ -16,13 +16,9 @@
  */
 
 #include "ao.h"
-#include "ao_pins.h"
 
-volatile __xdata struct ao_adc ao_adc_ring[AO_ADC_RING];
-#if HAS_ACCEL_REF
-volatile __xdata uint16_t      ao_accel_ref[AO_ADC_RING];
-#endif
-volatile __data uint8_t                ao_adc_head;
+volatile __xdata struct ao_data        ao_data_ring[AO_DATA_RING];
+volatile __data uint8_t                ao_data_head;
 
 void
 ao_adc_poll(void)
@@ -39,14 +35,14 @@ ao_adc_poll(void)
 }
 
 void
-ao_adc_get(__xdata struct ao_adc *packet)
+ao_data_get(__xdata struct ao_data *packet)
 {
 #if HAS_FLIGHT
-       uint8_t i = ao_adc_ring_prev(ao_sample_adc);
+       uint8_t i = ao_data_ring_prev(ao_sample_data);
 #else
-       uint8_t i = ao_adc_ring_prev(ao_adc_head);
+       uint8_t i = ao_data_ring_prev(ao_data_head);
 #endif
-       ao_xmemcpy(packet, &ao_adc_ring[i], sizeof (struct ao_adc));
+       ao_xmemcpy(packet, (void __xdata *) &ao_data_ring[i], sizeof (struct ao_data));
 }
 
 void
@@ -60,14 +56,14 @@ ao_adc_isr(void) __interrupt 1
        /* TeleMetrum readings */
 #if HAS_ACCEL_REF
        if (sequence == 2) {
-               a = (uint8_t __xdata *) (&ao_accel_ref[ao_adc_head]);
+               a = (uint8_t __xdata *) (&ao_data_ring[ao_data_head].accel_ref);
                sequence = 0;
        } else
 #endif
        {
                if (sequence == ADCCON3_ECH_TEMP)
                        sequence = 2;
-               a = (uint8_t __xdata *) (&ao_adc_ring[ao_adc_head].accel + sequence);
+               a = (uint8_t __xdata *) (&ao_data_ring[ao_data_head].adc.accel + sequence);
                sequence++;
        }
 #define GOT_ADC
@@ -87,7 +83,7 @@ ao_adc_isr(void) __interrupt 1
 
 #if IGNITE_ON_P0
        /* TeleMini readings */
-       a = (uint8_t __xdata *) (&ao_adc_ring[ao_adc_head].pres);
+       a = (uint8_t __xdata *) (&ao_data_ring[ao_data_head].pres);
 #ifdef TELEMINI_V_1_0
        switch (sequence) {
        case 0:
@@ -149,20 +145,20 @@ ao_adc_isr(void) __interrupt 1
 
        else {
                /* record this conversion series */
-               ao_adc_ring[ao_adc_head].tick = ao_time();
-               ao_adc_head = ao_adc_ring_next(ao_adc_head);
-               ao_wakeup(DATA_TO_XDATA(&ao_adc_head));
+               ao_data_ring[ao_data_head].tick = ao_time();
+               ao_data_head = ao_data_ring_next(ao_data_head);
+               ao_wakeup(DATA_TO_XDATA(&ao_data_head));
        }
 }
 
 static void
 ao_adc_dump(void) __reentrant
 {
-       static __xdata struct ao_adc    packet;
-       ao_adc_get(&packet);
+       static __xdata struct ao_data   packet;
+       ao_data_get(&packet);
        printf("tick: %5u accel: %5d pres: %5d temp: %5d batt: %5d drogue: %5d main: %5d\n",
-              packet.tick, packet.accel, packet.pres, packet.temp,
-              packet.v_batt, packet.sense_d, packet.sense_m);
+              packet.tick, packet.adc.accel, packet.adc.pres, packet.adc.temp,
+              packet.adc.v_batt, packet.adc.sense_d, packet.adc.sense_m);
 }
 
 __code struct ao_cmds ao_adc_cmds[] = {

diff --git a/src/cc1111/ao_arch.h b/src/cc1111/ao_arch.h
index 9d0643b4ba4f0f7d0135b7b81b4a45859d619a60..704ae4f911c2db6356bce656e893c79f02d7d0f6 100644 (file)
--- a/src/cc1111/ao_arch.h
+++ b/src/cc1111/ao_arch.h
@@ -199,7 +199,6 @@ extern __code __at (0x00a6) uint32_t ao_radio_cal;
 #define ao_arch_critical(b) __critical { b }
 
 struct ao_adc {
-       uint16_t        tick;           /* tick when the sample was read */
        int16_t         accel;          /* accelerometer */
        int16_t         pres;           /* pressure sensor */
        int16_t         temp;           /* temperature sensor */
@@ -208,7 +207,7 @@ struct ao_adc {
        int16_t         sense_m;        /* main continuity sense */
 };
 
-#define AO_ADC_RING    32
+#define AO_DATA_RING   32
 
 /* ao_button.c */
 #ifdef HAS_BUTTON

diff --git a/src/cc1111/ao_ignite.c b/src/cc1111/ao_ignite.c
index dd5290881e7af443539ac1b210a1d37108274be6..cf07dfe8ee212b373834660935e64b135a9e350f 100644 (file)
--- a/src/cc1111/ao_ignite.c
+++ b/src/cc1111/ao_ignite.c
@@ -16,6 +16,7 @@
  */
 
 #include "ao.h"
+#include <ao_data.h>
 
 __xdata struct ao_ignition ao_ignition[2];
 
@@ -29,12 +30,12 @@ ao_ignite(enum ao_igniter igniter) __critical
 enum ao_igniter_status
 ao_igniter_status(enum ao_igniter igniter)
 {
-       __xdata struct ao_adc adc;
+       __xdata struct ao_data packet;
        __pdata int16_t value;
        __pdata uint8_t request, firing, fired;
 
        __critical {
-               ao_adc_get(&adc);
+               ao_data_get(&packet);
                request = ao_ignition[igniter].request;
                fired = ao_ignition[igniter].fired;
                firing = ao_ignition[igniter].firing;
@@ -45,10 +46,10 @@ ao_igniter_status(enum ao_igniter igniter)
        value = (AO_IGNITER_CLOSED>>1);
        switch (igniter) {
        case ao_igniter_drogue:
-               value = adc.sense_d;
+               value = packet.adc.sense_d;
                break;
        case ao_igniter_main:
-               value = adc.sense_m;
+               value = packet.adc.sense_m;
                break;
        }
        if (value < AO_IGNITER_OPEN)

diff --git a/src/core/ao_adc.h b/src/core/ao_adc.h
index 8ec740c458ae7b497329e581c43f0c556546c8fa..0dd87080037686a1c099c11bc024aaa0039ea06f 100644 (file)
--- a/src/core/ao_adc.h
+++ b/src/core/ao_adc.h
@@ -18,29 +18,7 @@
 #ifndef _AO_ADC_H_
 #define _AO_ADC_H_
 
-/*
- * One set of samples read from the A/D converter or telemetry
- */
-
-#if AO_ADC_RING
-/*
- * ao_adc.c
- */
-
-#define ao_adc_ring_next(n)    (((n) + 1) & (AO_ADC_RING - 1))
-#define ao_adc_ring_prev(n)    (((n) - 1) & (AO_ADC_RING - 1))
-
-
-/*
- * A/D data is stored in a ring, with the next sample to be written
- * at ao_adc_head
- */
-extern volatile __xdata struct ao_adc  ao_adc_ring[AO_ADC_RING];
-extern volatile __data uint8_t         ao_adc_head;
-#if HAS_ACCEL_REF
-extern volatile __xdata uint16_t       ao_accel_ref[AO_ADC_RING];
-#endif
-#endif
+#include <ao_data.h>
 
 /* Trigger a conversion sequence (called from the timer interrupt) */
 void
@@ -50,9 +28,9 @@ ao_adc_poll(void);
 void
 ao_adc_sleep(void);
 
-/* Get a copy of the last complete A/D sample set */
+/* Get a copy of the last complete sample set */
 void
-ao_adc_get(__xdata struct ao_adc *packet);
+ao_data_get(__xdata struct ao_data *packet);
 
 /* Initialize the A/D converter */
 void

diff --git a/src/core/ao_data.h b/src/core/ao_data.h
index d28730a8af6cc29232dad17496d8b85e0c06f14d..bd7e2d54a356ae087981d25f657deead36daf770 100644 (file)
--- a/src/core/ao_data.h
+++ b/src/core/ao_data.h
@@ -96,7 +96,7 @@ typedef int16_t accel_t;
 
 typedef int16_t accel_t;
 #define ao_data_accel(packet)                  ((packet)->adc.accel)
-#define ao_data_set_accel(packet, accel)       ((packet)->adc.accel = (accel))
+#define ao_data_set_accel(packet, a)           ((packet)->adc.accel = (a))
 #define ao_data_accel_invert(a)                        (0x7fff -(a))
 
 /*

diff --git a/src/core/ao_log_big.c b/src/core/ao_log_big.c
index 43b3aa0c33f7d308e3a753877de8c2fb86eaa5e5..50eca069ea0487f37b9779cf171db0e6a5aa6d8a 100644 (file)
--- a/src/core/ao_log_big.c
+++ b/src/core/ao_log_big.c
@@ -60,7 +60,7 @@ ao_log_dump_check_data(void)
        return 1;
 }
 
-static __data uint8_t  ao_log_adc_pos;
+static __data uint8_t  ao_log_data_pos;
 
 /* a hack to make sure that ao_log_records fill the eeprom block in even units */
 typedef uint8_t check_log_size[1-(256 % sizeof(struct ao_log_record))] ;
@@ -94,17 +94,17 @@ ao_log(void)
        /* Write the whole contents of the ring to the log
         * when starting up.
         */
-       ao_log_adc_pos = ao_adc_ring_next(ao_sample_adc);
-       next_other = next_sensor = ao_adc_ring[ao_log_adc_pos].tick;
+       ao_log_data_pos = ao_data_ring_next(ao_sample_data);
+       next_other = next_sensor = ao_data_ring[ao_log_data_pos].tick;
        ao_log_state = ao_flight_startup;
        for (;;) {
                /* Write samples to EEPROM */
-               while (ao_log_adc_pos != ao_sample_adc) {
-                       log.tick = ao_adc_ring[ao_log_adc_pos].tick;
+               while (ao_log_data_pos != ao_sample_data) {
+                       log.tick = ao_data_ring[ao_log_data_pos].tick;
                        if ((int16_t) (log.tick - next_sensor) >= 0) {
                                log.type = AO_LOG_SENSOR;
-                               log.u.sensor.accel = ao_adc_ring[ao_log_adc_pos].accel;
-                               log.u.sensor.pres = ao_adc_ring[ao_log_adc_pos].pres;
+                               log.u.sensor.accel = ao_data_ring[ao_log_data_pos].adc.accel;
+                               log.u.sensor.pres = ao_data_ring[ao_log_data_pos].adc.pres;
                                ao_log_data(&log);
                                if (ao_log_state <= ao_flight_coast)
                                        next_sensor = log.tick + AO_SENSOR_INTERVAL_ASCENT;
@@ -113,16 +113,16 @@ ao_log(void)
                        }
                        if ((int16_t) (log.tick - next_other) >= 0) {
                                log.type = AO_LOG_TEMP_VOLT;
-                               log.u.temp_volt.temp = ao_adc_ring[ao_log_adc_pos].temp;
-                               log.u.temp_volt.v_batt = ao_adc_ring[ao_log_adc_pos].v_batt;
+                               log.u.temp_volt.temp = ao_data_ring[ao_log_data_pos].adc.temp;
+                               log.u.temp_volt.v_batt = ao_data_ring[ao_log_data_pos].adc.v_batt;
                                ao_log_data(&log);
                                log.type = AO_LOG_DEPLOY;
-                               log.u.deploy.drogue = ao_adc_ring[ao_log_adc_pos].sense_d;
-                               log.u.deploy.main = ao_adc_ring[ao_log_adc_pos].sense_m;
+                               log.u.deploy.drogue = ao_data_ring[ao_log_data_pos].adc.sense_d;
+                               log.u.deploy.main = ao_data_ring[ao_log_data_pos].adc.sense_m;
                                ao_log_data(&log);
                                next_other = log.tick + AO_OTHER_INTERVAL;
                        }
-                       ao_log_adc_pos = ao_adc_ring_next(ao_log_adc_pos);
+                       ao_log_data_pos = ao_data_ring_next(ao_log_data_pos);
                }
                /* Write state change to EEPROM */
                if (ao_flight_state != ao_log_state) {

diff --git a/src/core/ao_telemetry.c b/src/core/ao_telemetry.c
index 46d726095a35c63b6fbbd6a1ee33fd94645798ca..800adfcba9bee010bafed3784dccea979a358510 100644 (file)
--- a/src/core/ao_telemetry.c
+++ b/src/core/ao_telemetry.c
@@ -53,23 +53,23 @@ static __xdata union ao_telemetry_all       telemetry;
 static void
 ao_send_sensor(void)
 {
-       uint8_t         sample = ao_adc_ring_prev(ao_sample_adc);
+       uint8_t         sample = ao_data_ring_prev(ao_sample_data);
                        
-       telemetry.generic.tick = ao_adc_ring[sample].tick;
+       telemetry.generic.tick = ao_data_ring[sample].tick;
        telemetry.generic.type = AO_TELEMETRY_SENSOR;
 
        telemetry.sensor.state = ao_flight_state;
 #if HAS_ACCEL
-       telemetry.sensor.accel = ao_adc_ring[sample].accel;
+       telemetry.sensor.accel = ao_data_ring[sample].adc.accel;
 #else
        telemetry.sensor.accel = 0;
 #endif
-       telemetry.sensor.pres = ao_adc_ring[sample].pres;
-       telemetry.sensor.temp = ao_adc_ring[sample].temp;
-       telemetry.sensor.v_batt = ao_adc_ring[sample].v_batt;
+       telemetry.sensor.pres = ao_data_ring[sample].adc.pres;
+       telemetry.sensor.temp = ao_data_ring[sample].adc.temp;
+       telemetry.sensor.v_batt = ao_data_ring[sample].adc.v_batt;
 #if HAS_IGNITE
-       telemetry.sensor.sense_d = ao_adc_ring[sample].sense_d;
-       telemetry.sensor.sense_m = ao_adc_ring[sample].sense_m;
+       telemetry.sensor.sense_d = ao_data_ring[sample].adc.sense_d;
+       telemetry.sensor.sense_m = ao_data_ring[sample].adc.sense_m;
 #else
        telemetry.sensor.sense_d = 0;
        telemetry.sensor.sense_m = 0;
@@ -99,19 +99,19 @@ static uint8_t              ao_baro_sample;
 static void
 ao_send_baro(void)
 {
-       uint8_t         sample = ao_sample_adc;
-       uint8_t         samples = (sample - ao_baro_sample) & (AO_ADC_RING - 1);
+       uint8_t         sample = ao_sample_data;
+       uint8_t         samples = (sample - ao_baro_sample) & (AO_DATA_RING - 1);
 
        if (samples > 12) {
-               ao_baro_sample = (ao_baro_sample + (samples - 12)) & (AO_ADC_RING - 1);
+               ao_baro_sample = (ao_baro_sample + (samples - 12)) & (AO_DATA_RING - 1);
                samples = 12;
        }
-       telemetry.generic.tick = ao_adc_ring[sample].tick;
+       telemetry.generic.tick = ao_data_ring[sample].tick;
        telemetry.generic.type = AO_TELEMETRY_BARO;
        telemetry.baro.samples = samples;
        for (sample = 0; sample < samples; sample++) {
-               telemetry.baro.baro[sample] = ao_adc_ring[ao_baro_sample].pres;
-               ao_baro_sample = ao_adc_ring_next(ao_baro_sample);
+               telemetry.baro.baro[sample] = ao_data_ring[ao_baro_sample].adc.pres;
+               ao_baro_sample = ao_data_ring_next(ao_baro_sample);
        }
        ao_radio_send(&telemetry, sizeof (telemetry));
 }

diff --git a/src/product/Makefile.telemetrum b/src/product/Makefile.telemetrum
index e4f55f8872fe9423d2c5642ac64d76ef17a59882..b111105316814210bd923e4dbf9017a532cd004e 100644 (file)
--- a/src/product/Makefile.telemetrum
+++ b/src/product/Makefile.telemetrum
@@ -34,8 +34,8 @@ CORE_SRC = \
        ao_stdio.c \
        ao_storage.c \
        ao_task.c \
-       ao_flight.c \
-       ao_sample.c \
+       ao_flight_mm.c \
+       ao_sample_mm.c \
        ao_kalman.c \
        ao_log.c \
        ao_log_big.c \

diff --git a/src/stm/ao_adc_stm.c b/src/stm/ao_adc_stm.c
index 02187205eb18a82b4256c9669c33ee5cde2bb4ee..ea9e25e48a9f94d0438c7d4ca03e908be1c89c99 100644 (file)
--- a/src/stm/ao_adc_stm.c
+++ b/src/stm/ao_adc_stm.c
@@ -104,14 +104,22 @@ ao_adc_poll(void)
 void
 ao_adc_get(__xdata struct ao_adc *packet)
 {
+#if HAS_FLIGHT
+       uint8_t i = ao_data_ring_prev(ao_sample_data);
+#else
        uint8_t i = ao_data_ring_prev(ao_data_head);
+#endif
        memcpy(packet, (void *) &ao_data_ring[i].adc, sizeof (struct ao_adc));
 }
 
 void
 ao_data_get(__xdata struct ao_data *packet)
 {
+#if HAS_FLIGHT
+       uint8_t i = ao_data_ring_prev(ao_sample_data);
+#else
        uint8_t i = ao_data_ring_prev(ao_data_head);
+#endif
        memcpy(packet, (void *) &ao_data_ring[i], sizeof (struct ao_data));
 }