Merge branch 'master' of ssh://git.gag.com/scm/git/fw/altos

diff --git a/doc/altos.xsl b/doc/altos.xsl
index 295864fe8512bb7290c2d9b88bf0e8d903392d6c..37bb58da0440dae3122f89845f4fad80fa7e14e0 100644 (file)
--- a/doc/altos.xsl
+++ b/doc/altos.xsl
@@ -385,17 +385,6 @@
        will abort the radio receive operation.
       </para>
     </section>
-    <section>
-      <title>ao_wake_task</title>
-      <programlisting>
-       void
-       ao_wake_task(__xdata struct ao_task *task)
-      </programlisting>
-      <para>
-       Force a specific task to wake up, independent of which
-       'wchan' it is waiting for.
-      </para>
-    </section>
     <section>
       <title>ao_start_scheduler</title>
       <programlisting>

diff --git a/src/ao.h b/src/ao.h
index 5721c34484c319f37f16c178aba1a6131b57298b..cef20e61731e869a5a3a517d7a2186cf9fa5c694 100644 (file)
--- a/src/ao.h
+++ b/src/ao.h
@@ -163,6 +163,11 @@ struct ao_adc {
 #endif
 
 #if HAS_ADC
+
+#ifndef HAS_ACCEL_REF
+#error Please define HAS_ACCEL_REF
+#endif
+
 /*
  * ao_adc.c
  */
@@ -178,6 +183,9 @@ struct ao_adc {
  */
 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
 
 /* Trigger a conversion sequence (called from the timer interrupt) */
 void
@@ -649,7 +657,7 @@ enum ao_flight_state {
        ao_flight_invalid = 9
 };
 
-extern __xdata struct ao_adc           ao_flight_data;
+extern __data uint8_t                  ao_flight_adc;
 extern __pdata enum ao_flight_state    ao_flight_state;
 extern __pdata uint16_t                        ao_flight_tick;
 extern __pdata int16_t                 ao_flight_accel;

diff --git a/src/ao_adc.c b/src/ao_adc.c
index 49d2519e209d5c4f2faf594c5afb08da9da42af6..3adf9b2e70277526e252770c7071dec7a400d0b1 100644 (file)
--- a/src/ao_adc.c
+++ b/src/ao_adc.c
@@ -19,24 +19,25 @@
 #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;
 
 void
 ao_adc_poll(void)
 {
+#if HAS_ACCEL_REF
+       ADCCON3 = ADCCON3_EREF_VDD | ADCCON3_EDIV_512 | 2;
+#else
        ADCCON3 = ADCCON3_EREF_VDD | ADCCON3_EDIV_512 | 0;
-}
-
-void
-ao_adc_sleep(void)
-{
-       ao_sleep(&ao_adc_ring);
+#endif
 }
 
 void
 ao_adc_get(__xdata struct ao_adc *packet)
 {
-       uint8_t i = ao_adc_ring_prev(ao_adc_head);
+       uint8_t i = ao_adc_ring_prev(ao_flight_adc);
        memcpy(packet, &ao_adc_ring[i], sizeof (struct ao_adc));
 }
 
@@ -47,25 +48,34 @@ ao_adc_isr(void) __interrupt 1
        uint8_t __xdata *a;
 
        sequence = (ADCCON2 & ADCCON2_SCH_MASK) >> ADCCON2_SCH_SHIFT;
-       if (sequence == ADCCON3_ECH_TEMP)
-               sequence = 2;
-       a = (uint8_t __xdata *) (&ao_adc_ring[ao_adc_head].accel + sequence);
+#if HAS_ACCEL_REF
+       if (sequence == 2) {
+               a = (uint8_t __xdata *) (&ao_accel_ref[ao_adc_head]);
+               sequence = 0;
+       } else
+#endif
+       {
+               if (sequence == ADCCON3_ECH_TEMP)
+                       sequence = 2;
+               a = (uint8_t __xdata *) (&ao_adc_ring[ao_adc_head].accel + sequence);
+               sequence++;
+       }
        a[0] = ADCL;
        a[1] = ADCH;
-       if (sequence < 5) {
+       if (sequence < 6) {
 #if HAS_EXTERNAL_TEMP == 0
                /* start next channel conversion */
                /* v0.2 replaces external temp sensor with internal one */
-               if (sequence == 1)
+               if (sequence == 2)
                        ADCCON3 = ADCCON3_EREF_1_25 | ADCCON3_EDIV_512 | ADCCON3_ECH_TEMP;
                else
 #endif
-                       ADCCON3 = ADCCON3_EREF_VDD | ADCCON3_EDIV_512 | (sequence + 1);
+                       ADCCON3 = ADCCON3_EREF_VDD | ADCCON3_EDIV_512 | sequence;
        } 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(ao_adc_ring);
+               ao_wakeup(DATA_TO_XDATA(&ao_adc_head));
        }
 }
 

diff --git a/src/ao_config.c b/src/ao_config.c
index e97b7eb121192a41d1876fa530e9188d828e75e5..bbee3b443e6a0a7e17bfb9805af311dfba6e3982 100644 (file)
--- a/src/ao_config.c
+++ b/src/ao_config.c
@@ -209,10 +209,10 @@ ao_config_accel_calibrate_auto(char *orientation) __reentrant
        puts("Calibrating..."); flush();
        i = ACCEL_CALIBRATE_SAMPLES;
        accel_total = 0;
-       cal_adc_ring = ao_adc_head;
+       cal_adc_ring = ao_flight_adc;
        while (i) {
-               ao_sleep(&ao_adc_ring);
-               while (i && cal_adc_ring != ao_adc_head) {
+               ao_sleep(DATA_TO_XDATA(&ao_flight_adc));
+               while (i && cal_adc_ring != ao_flight_adc) {
                        accel_total += (int32_t) ao_adc_ring[cal_adc_ring].accel;
                        cal_adc_ring = ao_adc_ring_next(cal_adc_ring);
                        i--;

diff --git a/src/ao_flight.c b/src/ao_flight.c
index e99692a3f21d51df219e819c4413a4ce8db5423b..81aecad3e26e0053059b65a90b7273a9504d627a 100644 (file)
--- a/src/ao_flight.c
+++ b/src/ao_flight.c
@@ -146,16 +146,103 @@ ao_flight(void)
        ao_raw_pres = 0;
        ao_flight_tick = 0;
        for (;;) {
-               ao_sleep(&ao_adc_ring);
+               ao_wakeup(DATA_TO_XDATA(&ao_flight_adc));
+               ao_sleep(DATA_TO_XDATA(&ao_adc_head));
                while (ao_flight_adc != ao_adc_head) {
                        __pdata uint8_t ticks;
                        __pdata int16_t ao_vel_change;
+                       __xdata struct ao_adc *ao_adc;
                        ao_flight_prev_tick = ao_flight_tick;
 
                        /* Capture a sample */
-                       ao_raw_accel = ao_adc_ring[ao_flight_adc].accel;
-                       ao_raw_pres = ao_adc_ring[ao_flight_adc].pres;
-                       ao_flight_tick = ao_adc_ring[ao_flight_adc].tick;
+                       ao_adc = &ao_adc_ring[ao_flight_adc];
+                       ao_flight_tick = ao_adc->tick;
+                       ao_raw_accel = ao_adc->accel;
+#if HAS_ACCEL_REF
+                       /*
+                        * Ok, the math here is a bit tricky.
+                        *
+                        * ao_raw_accel:  ADC output for acceleration
+                        * ao_accel_ref:  ADC output for the 5V reference.
+                        * ao_cook_accel: Corrected acceleration value
+                        * Vcc:           3.3V supply to the CC1111
+                        * Vac:           5V supply to the accelerometer
+                        * accel:         input voltage to accelerometer ADC pin
+                        * ref:           input voltage to 5V reference ADC pin
+                        *
+                        *
+                        * Measured acceleration is ratiometric to Vcc:
+                        *
+                        *     ao_raw_accel   accel
+                        *     ------------ = -----
+                        *        32767        Vcc
+                        *
+                        * Measured 5v reference is also ratiometric to Vcc:
+                        *
+                        *     ao_accel_ref    ref
+                        *     ------------ = -----
+                        *        32767        Vcc
+                        *
+                        *
+                        *      ao_accel_ref = 32767 * (ref / Vcc)
+                        *
+                        * Acceleration is measured ratiometric to the 5V supply,
+                        * so what we want is:
+                        *
+                        *      ao_cook_accel    accel
+                        *      ------------- =  -----
+                        *          32767         ref
+                        *
+                        *
+                        *                      accel    Vcc
+                        *                    = ----- *  ---
+                        *                       Vcc     ref
+                        *
+                        *                      ao_raw_accel       32767
+                        *                    = ------------ *  ------------
+                        *                         32737        ao_accel_ref
+                        *
+                        * Multiply through by 32767:
+                        *
+                        *                      ao_raw_accel * 32767
+                        *      ao_cook_accel = --------------------
+                        *                          ao_accel_ref
+                        *
+                        * Now, the tricky part. Getting this to compile efficiently
+                        * and keeping all of the values in-range.
+                        *
+                        * First off, we need to use a shift of 16 instead of * 32767 as SDCC
+                        * does the obvious optimizations for byte-granularity shifts:
+                        *
+                        *      ao_cook_accel = (ao_raw_accel << 16) / ao_accel_ref
+                        *
+                        * Next, lets check our input ranges:
+                        *
+                        *      0 <= ao_raw_accel <= 0x7fff             (singled ended ADC conversion)
+                        *      0x7000 <= ao_accel_ref <= 0x7fff        (the 5V ref value is close to 0x7fff)
+                        *
+                        * Plugging in our input ranges, we get an output range of 0 - 0x12490,
+                        * which is 17 bits. That won't work. If we take the accel ref and shift
+                        * by a bit, we'll change its range:
+                        *
+                        *      0xe000 <= ao_accel_ref<<1 <= 0xfffe
+                        *
+                        *      ao_cook_accel = (ao_raw_accel << 16) / (ao_accel_ref << 1)
+                        *
+                        * Now the output range is 0 - 0x9248, which nicely fits in 16 bits. It
+                        * is, however, one bit too large for our signed computations. So, we
+                        * take the result and shift that by a bit:
+                        *
+                        *      ao_cook_accel = ((ao_raw_accel << 16) / (ao_accel_ref << 1)) >> 1
+                        *
+                        * This finally creates an output range of 0 - 0x4924. As the ADC only
+                        * provides 11 bits of data, we haven't actually lost any precision,
+                        * just dropped a bit of noise off the low end.
+                        */
+                       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;

diff --git a/src/ao_flight_test.c b/src/ao_flight_test.c
index e0cfa47a2a8e3ecc11ffed2c87b36c39e7a4eae6..5c61951853d63c84ddc6905be651b002a1e9a2d0 100644 (file)
--- a/src/ao_flight_test.c
+++ b/src/ao_flight_test.c
@@ -180,7 +180,7 @@ void
 ao_sleep(void *wchan)
 {
        ao_dump_state();
-       if (wchan == &ao_adc_ring) {
+       if (wchan == &ao_adc_head) {
                char            type;
                uint16_t        tick;
                uint16_t        a, b;
@@ -238,6 +238,8 @@ ao_sleep(void *wchan)
                        switch (type) {
                        case 'F':
                                ao_flight_ground_accel = a;
+                               ao_config.accel_plus_g = a;
+                               ao_config.accel_minus_g = a + 530;
                                ao_flight_started = 1;
                                break;
                        case 'S':

diff --git a/src/ao_ignite.c b/src/ao_ignite.c
index f2b15dd23e741da0d29df0682d7c02d830717890..603fcd25f3e37105487ad1005894cfdbabcc9815 100644 (file)
--- a/src/ao_ignite.c
+++ b/src/ao_ignite.c
@@ -52,7 +52,6 @@ ao_igniter_status(enum ao_igniter igniter)
        __xdata uint8_t request, firing, fired;
 
        __critical {
-               ao_adc_sleep();
                ao_adc_get(&adc);
                request = ao_ignition[igniter].request;
                fired = ao_ignition[igniter].fired;

diff --git a/src/ao_log.c b/src/ao_log.c
index fa0725502332fe10b884adff4090d37e6fb8ad6d..099c5f6ff9683aebf4a7048f2ed212e71578f60e 100644 (file)
--- a/src/ao_log.c
+++ b/src/ao_log.c
@@ -99,10 +99,10 @@ 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_adc_head);
+       ao_log_adc_pos = ao_adc_ring_next(ao_flight_adc);
        for (;;) {
                /* Write samples to EEPROM */
-               while (ao_log_adc_pos != ao_adc_head) {
+               while (ao_log_adc_pos != ao_flight_adc) {
                        log.type = AO_LOG_SENSOR;
                        log.tick = ao_adc_ring[ao_log_adc_pos].tick;
                        log.u.sensor.accel = ao_adc_ring[ao_log_adc_pos].accel;

diff --git a/src/ao_pins.h b/src/ao_pins.h
index 9446964e1f02b7f8427386414157e25ed421638c..2c5b9db5ca749a34f7f7d9f3884c53b848906dae 100644 (file)
--- a/src/ao_pins.h
+++ b/src/ao_pins.h
@@ -31,6 +31,7 @@
        #define AO_LED_RED              1
        #define LEDS_AVAILABLE          (AO_LED_RED)
        #define HAS_EXTERNAL_TEMP       0
+       #define HAS_ACCEL_REF           0
 #endif
 
 #if defined(TELEMETRUM_V_1_1)
@@ -46,6 +47,7 @@
        #define AO_LED_RED              1
        #define LEDS_AVAILABLE          (AO_LED_RED)
        #define HAS_EXTERNAL_TEMP       0
+       #define HAS_ACCEL_REF           1
        #define SPI_CS_ON_P1            1
        #define SPI_CS_ON_P0            0
        #define M25_CS_MASK             0x02    /* CS0 is P1_1 */
@@ -81,6 +83,7 @@
        #define AO_LED_GREEN            1
        #define LEDS_AVAILABLE          (AO_LED_RED|AO_LED_GREEN)
        #define HAS_EXTERNAL_TEMP       1
+       #define HAS_ACCEL_REF           0
        #define SPI_CS_ON_P1            1
        #define SPI_CS_ON_P0            0
 #endif

diff --git a/src/ao_test.c b/src/ao_test.c
index b9f7d33840dfe53ee724674df05485f457cda1c6..14c2eb75c41e2656996673a0cb29d4d4d4973c0f 100644 (file)
--- a/src/ao_test.c
+++ b/src/ao_test.c
@@ -53,7 +53,7 @@ blink_1(void)
        static __xdata struct ao_adc adc;
 
        for (;;) {
-               ao_sleep(&ao_adc_ring);
+               ao_sleep(&ao_adc_head);
                ao_adc_get(&adc);
                if (adc.accel < 15900)
                        ao_led_on(AO_LED_RED);