altos/stm32f1: Add ao_adc_single support

[fw/altos] / src / drivers / ao_lco_bits.c

diff --git a/src/drivers/ao_lco_bits.c b/src/drivers/ao_lco_bits.c
index 6e50e44db4f8bec93edf71a42ab72a8f940f64c2..acdea87e3328759d8b292864ee02e28be3497e64 100644 (file)
--- a/src/drivers/ao_lco_bits.c
+++ b/src/drivers/ao_lco_bits.c
@@ -19,12 +19,14 @@
 uint8_t                ao_lco_debug;
 
 uint8_t                ao_lco_pad;
-int16_t                ao_lco_box;
+uint16_t       ao_lco_box;
 
 uint8_t                ao_lco_armed;                                   /* arm active */
 uint8_t                ao_lco_firing;                                  /* fire active */
 
-uint8_t                ao_lco_min_box, ao_lco_max_box;
+uint16_t       ao_lco_min_box, ao_lco_max_box;
+
+uint8_t                ao_lco_pretending;
 
 #if AO_LCO_DRAG
 uint8_t                ao_lco_drag_race;
@@ -33,7 +35,7 @@ uint8_t               ao_lco_drag_race;
 struct ao_pad_query    ao_pad_query;                           /* latest query response */
 
 static uint8_t         ao_lco_channels[AO_PAD_MAX_BOXES];      /* pad channels available on each box */
-static uint16_t                ao_lco_tick_offset[AO_PAD_MAX_BOXES];   /* offset from local to remote tick count */
+static uint16_t                ao_lco_tick_offset[AO_PAD_MAX_BOXES];   /* 16 bit offset from local to remote tick count */
 static uint8_t         ao_lco_selected[AO_PAD_MAX_BOXES];      /* pads selected to fire */
 
 #define AO_LCO_VALID_LAST      1
@@ -136,7 +138,7 @@ ao_lco_igniter_status(void)
 }
 
 uint8_t
-ao_lco_pad_present(uint8_t box, uint8_t pad)
+ao_lco_pad_present(uint16_t box, uint8_t pad)
 {
        /* voltage measurement is always valid */
        if (pad == AO_LCO_PAD_VOLTAGE)
@@ -149,7 +151,7 @@ ao_lco_pad_present(uint8_t box, uint8_t pad)
 }
 
 uint8_t
-ao_lco_pad_first(uint8_t box)
+ao_lco_pad_first(uint16_t box)
 {
        uint8_t pad;
 
@@ -160,7 +162,7 @@ ao_lco_pad_first(uint8_t box)
 }
 
 static uint8_t
-ao_lco_get_channels(uint8_t box, struct ao_pad_query *query)
+ao_lco_get_channels(uint16_t box, struct ao_pad_query *query)
 {
        int8_t                  r;
 
@@ -169,7 +171,7 @@ ao_lco_get_channels(uint8_t box, struct ao_pad_query *query)
                ao_lco_channels[box] = query->channels;
                ao_lco_valid[box] = AO_LCO_VALID_LAST | AO_LCO_VALID_EVER;
        } else
-               ao_lco_valid[box] &= ~AO_LCO_VALID_LAST;
+               ao_lco_valid[box] &= (uint8_t) ~AO_LCO_VALID_LAST;
        PRINTD("ao_lco_get_channels(%d) rssi %d valid %d ret %d offset %d\n", box, ao_radio_cmac_rssi, ao_lco_valid[box], r, ao_lco_tick_offset[box]);
        ao_wakeup(&ao_pad_query);
        return ao_lco_valid[box];
@@ -197,11 +199,12 @@ ao_lco_box_reset_present(void)
 {
        ao_lco_min_box = 0xff;
        ao_lco_max_box = 0x00;
+       ao_lco_pretending = 0;
        memset(ao_lco_box_mask, 0, sizeof (ao_lco_box_mask));
 }
 
 static void
-ao_lco_box_set_present(uint8_t box)
+ao_lco_box_set_present(uint16_t box)
 {
        if (box < ao_lco_min_box)
                ao_lco_min_box = box;
@@ -209,7 +212,7 @@ ao_lco_box_set_present(uint8_t box)
                ao_lco_max_box = box;
        if (box >= AO_PAD_MAX_BOXES)
                return;
-       ao_lco_box_mask[AO_LCO_MASK_ID(box)] |= 1 << AO_LCO_MASK_SHIFT(box);
+       ao_lco_box_mask[AO_LCO_MASK_ID(box)] |= (uint8_t) (1 << AO_LCO_MASK_SHIFT(box));
 }
 
 void
@@ -223,8 +226,12 @@ void
 ao_lco_set_box(uint16_t new_box)
 {
        ao_lco_box = new_box;
-       if (ao_lco_box < AO_PAD_MAX_BOXES)
-               ao_lco_channels[ao_lco_box] = 0;
+       if (ao_lco_box < AO_PAD_MAX_BOXES) {
+               if (ao_lco_pretending)
+                       ao_lco_channels[ao_lco_box] = 0xff;
+               else
+                       ao_lco_channels[ao_lco_box] = 0;
+       }
        ao_lco_pad = 1;
        ao_lco_show();
 }
@@ -232,9 +239,9 @@ ao_lco_set_box(uint16_t new_box)
 void
 ao_lco_step_pad(int8_t dir)
 {
-       int8_t  new_pad;
+       int16_t new_pad;
 
-       new_pad = ao_lco_pad;
+       new_pad = (int16_t) ao_lco_pad;
        do {
                new_pad += dir;
                if (new_pad > AO_PAD_MAX_CHANNELS)
@@ -243,8 +250,8 @@ ao_lco_step_pad(int8_t dir)
                        new_pad = AO_PAD_MAX_CHANNELS;
                if (new_pad == ao_lco_pad)
                        break;
-       } while (!ao_lco_pad_present(ao_lco_box, new_pad));
-       ao_lco_set_pad(new_pad);
+       } while (!ao_lco_pad_present(ao_lco_box, (uint8_t) new_pad));
+       ao_lco_set_pad((uint8_t) new_pad);
 }
 
 void
@@ -255,7 +262,7 @@ ao_lco_set_armed(uint8_t armed)
        if (ao_lco_armed) {
 #if AO_LCO_DRAG
                if (ao_lco_drag_race) {
-                       uint8_t box;
+                       uint16_t        box;
 
                        for (box = ao_lco_min_box; box <= ao_lco_max_box; box++)
                                if (ao_lco_selected[box])
@@ -288,8 +295,8 @@ ao_lco_search(void)
 {
        int8_t          r;
        int8_t          try;
-       uint8_t         box;
-       uint8_t         boxes = 0;
+       uint16_t        box;
+       uint16_t        boxes = 0;
 
        ao_lco_box_reset_present();
        ao_lco_show_box(0);
@@ -304,7 +311,7 @@ ao_lco_search(void)
                        if (r == AO_RADIO_CMAC_OK) {
                                ++boxes;
                                ao_lco_box_set_present(box);
-                               ao_lco_show_pad(boxes % 10);
+                               ao_lco_show_pad((uint8_t) (boxes % 10));
                                ao_delay(AO_MS_TO_TICKS(30));
                                break;
                        }
@@ -319,11 +326,27 @@ ao_lco_search(void)
        ao_lco_set_box(ao_lco_min_box);
 }
 
+void
+ao_lco_pretend(void)
+{
+       uint16_t box;
+
+       ao_lco_pretending = 1;
+       ao_lco_min_box = 1;
+       ao_lco_max_box = AO_PAD_MAX_BOXES - 1;
+       for (box = ao_lco_min_box; box < ao_lco_max_box; box++)
+               ao_lco_box_set_present(box);
+       ao_lco_box = ao_lco_min_box;
+       memset(ao_lco_valid, 0, sizeof (ao_lco_valid));
+       memset(ao_lco_channels, 0, sizeof (ao_lco_channels));
+       ao_lco_set_box(ao_lco_min_box);
+}
+
 void
 ao_lco_monitor(void)
 {
-       uint16_t                delay;
-       uint8_t                 box;
+       AO_TICK_TYPE            delay;
+       uint16_t                box;
 
        for (;;) {
                PRINTD("monitor armed %d firing %d\n",
@@ -358,8 +381,8 @@ ao_lco_monitor(void)
 
 uint8_t                        ao_lco_drag_beep_count;
 static uint8_t         ao_lco_drag_beep_on;
-static uint16_t                ao_lco_drag_beep_time;
-static uint16_t                ao_lco_drag_warn_time;
+static AO_TICK_TYPE    ao_lco_drag_beep_time;
+static AO_TICK_TYPE    ao_lco_drag_warn_time;
 
 #define AO_LCO_DRAG_BEEP_TIME  AO_MS_TO_TICKS(50)
 #define AO_LCO_DRAG_WARN_TIME  AO_SEC_TO_TICKS(5)
@@ -380,7 +403,7 @@ void
 ao_lco_toggle_drag(void)
 {
        if (ao_lco_drag_race && ao_lco_pad != AO_LCO_PAD_VOLTAGE) {
-               ao_lco_selected[ao_lco_box] ^= (1 << (ao_lco_pad - 1));
+               ao_lco_selected[ao_lco_box] ^= (uint8_t) (1 << (ao_lco_pad - 1));
                PRINTD("Toggle box %d pad %d (pads now %x) to drag race\n",
                       ao_lco_pad, ao_lco_box, ao_lco_selected[ao_lco_box]);
                ao_lco_drag_add_beeps(ao_lco_pad);
@@ -391,14 +414,14 @@ ao_lco_toggle_drag(void)
  * turn it on or off as necessary and bump the remaining beep counts
  */
 
-uint16_t
-ao_lco_drag_beep_check(uint16_t now, uint16_t delay)
+AO_TICK_TYPE
+ao_lco_drag_beep_check(AO_TICK_TYPE now, AO_TICK_TYPE delay)
 {
-       PRINTD("beep check count %d delta %d\n",
+       PRINTD("beep check count %d delta %ld\n",
               ao_lco_drag_beep_count,
-              (int16_t) (now - ao_lco_drag_beep_time));
+              (long) (AO_TICK_SIGNED) (now - ao_lco_drag_beep_time));
        if (ao_lco_drag_beep_count) {
-               if ((int16_t) (now - ao_lco_drag_beep_time) >= 0) {
+               if ((AO_TICK_SIGNED) (now - ao_lco_drag_beep_time) >= 0) {
                        if (ao_lco_drag_beep_on) {
                                ao_beep(0);
                                PRINTD("beep stop\n");
@@ -418,7 +441,7 @@ ao_lco_drag_beep_check(uint16_t now, uint16_t delay)
        }
 
        if (ao_lco_drag_beep_count) {
-               uint16_t beep_delay = 0;
+               AO_TICK_TYPE beep_delay = 0;
 
                if (ao_lco_drag_beep_time > now)
                        beep_delay = ao_lco_drag_beep_time - now;
@@ -463,13 +486,13 @@ ao_lco_drag_disable(void)
  * active
  */
 
-uint16_t
-ao_lco_drag_warn_check(uint16_t now, uint16_t delay)
+AO_TICK_TYPE
+ao_lco_drag_warn_check(AO_TICK_TYPE now, AO_TICK_TYPE delay)
 {
        if (ao_lco_drag_race) {
-               uint16_t        warn_delay;
+               AO_TICK_TYPE    warn_delay;
 
-               if ((int16_t) (now - ao_lco_drag_warn_time) >= 0) {
+               if ((AO_TICK_SIGNED) (now - ao_lco_drag_warn_time) >= 0) {
                        ao_lco_drag_add_beeps(1);
                        ao_lco_drag_warn_time = now + AO_LCO_DRAG_WARN_TIME;
                }