git.gag.com Git - fw/altos/blob - src/telelco-v2.0/ao_lco_v2.c

   1 /*
   2  * Copyright © 2012 Keith Packard <keithp@keithp.com>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  17  */
  18
  19 #include <ao.h>
  20 #include <ao_lco.h>
  21 #include <ao_event.h>
  22 #include <ao_seven_segment.h>
  23 #include <ao_quadrature.h>
  24 #include <ao_lco_func.h>
  25 #include <ao_radio_cmac.h>
  26
  27 #define DEBUG   1
  28
  29 #if DEBUG
  30 static uint8_t  ao_lco_debug;
  31 #define PRINTD(...) do { if (!ao_lco_debug) break; printf ("\r%5u %s: ", ao_tick_count, __func__); printf(__VA_ARGS__); flush(); } while(0)
  32 #else
  33 #define PRINTD(...)
  34 #endif
  35
  36 #define AO_LCO_PAD_DIGIT        0
  37 #define AO_LCO_BOX_DIGIT_1      1
  38 #define AO_LCO_BOX_DIGIT_10     2
  39
  40 #define AO_LCO_DRAG_RACE_START_TIME     AO_SEC_TO_TICKS(5)
  41 #define AO_LCO_DRAG_RACE_STOP_TIME      AO_SEC_TO_TICKS(2)
  42
  43 #define AO_LCO_VALID_LAST       1
  44 #define AO_LCO_VALID_EVER       2
  45
  46 static uint8_t  ao_lco_min_box, ao_lco_max_box;
  47 static uint8_t  ao_lco_selected[AO_PAD_MAX_BOXES];
  48 static uint8_t  ao_lco_valid[AO_PAD_MAX_BOXES];
  49 static uint8_t  ao_lco_channels[AO_PAD_MAX_BOXES];
  50 static uint16_t ao_lco_tick_offset[AO_PAD_MAX_BOXES];
  51
  52 /* UI values */
  53 static uint8_t  ao_lco_armed;
  54 static uint8_t  ao_lco_firing;
  55 static uint8_t  ao_lco_drag_race;
  56 static uint8_t  ao_lco_pad;
  57 static int16_t  ao_lco_box;
  58 static uint8_t  ao_lco_select_mode;
  59 #define AO_LCO_SELECT_PAD       0
  60 #define AO_LCO_SELECT_BOX       1
  61
  62 static struct ao_pad_query      ao_pad_query;
  63
  64 static uint8_t  ao_lco_display_mutex;
  65
  66 static void
  67 ao_lco_set_pad(uint8_t pad)
  68 {
  69         ao_mutex_get(&ao_lco_display_mutex);
  70         ao_seven_segment_set(AO_LCO_PAD_DIGIT, pad | (ao_lco_drag_race << 4));
  71         ao_mutex_put(&ao_lco_display_mutex);
  72 }
  73
  74 #define SEVEN_SEGMENT_d         ((0 << 0) |     \
  75                                  (0 << 1) |     \
  76                                  (1 << 2) |     \
  77                                  (1 << 3) |     \
  78                                  (1 << 4) |     \
  79                                  (1 << 5) |     \
  80                                  (1 << 6))
  81
  82
  83 #define SEVEN_SEGMENT_r         ((0 << 0) |     \
  84                                  (0 << 1) |     \
  85                                  (0 << 2) |     \
  86                                  (1 << 3) |     \
  87                                  (1 << 4) |     \
  88                                  (0 << 5) |     \
  89                                  (0 << 6))
  90
  91 static void
  92 ao_lco_set_box(uint16_t box)
  93 {
  94         ao_mutex_get(&ao_lco_display_mutex);
  95         ao_seven_segment_set(AO_LCO_BOX_DIGIT_1, box % 10 | (ao_lco_drag_race << 4));
  96         ao_seven_segment_set(AO_LCO_BOX_DIGIT_10, box / 10 | (ao_lco_drag_race << 4));
  97         ao_mutex_put(&ao_lco_display_mutex);
  98 }
  99
 100 static void
 101 ao_lco_set_voltage(uint16_t decivolts)
 102 {
 103         uint8_t tens, ones, tenths;
 104
 105         tenths = decivolts % 10;
 106         ones = (decivolts / 10) % 10;
 107         tens = (decivolts / 100) % 10;
 108         ao_mutex_get(&ao_lco_display_mutex);
 109         ao_seven_segment_set(AO_LCO_PAD_DIGIT, tenths);
 110         ao_seven_segment_set(AO_LCO_BOX_DIGIT_1, ones | 0x10);
 111         ao_seven_segment_set(AO_LCO_BOX_DIGIT_10, tens);
 112         ao_mutex_put(&ao_lco_display_mutex);
 113 }
 114
 115 static void
 116 ao_lco_set_display(void)
 117 {
 118         if (ao_lco_pad == 0) {
 119                 ao_lco_set_voltage(ao_pad_query.battery);
 120         } else {
 121                 ao_lco_set_pad(ao_lco_pad);
 122                 ao_lco_set_box(ao_lco_box);
 123         }
 124 }
 125
 126 #define MASK_SIZE(n)    (((n) + 7) >> 3)
 127 #define MASK_ID(n)      ((n) >> 3)
 128 #define MASK_SHIFT(n)   ((n) & 7)
 129
 130 static uint8_t  ao_lco_box_mask[MASK_SIZE(AO_PAD_MAX_BOXES)];
 131
 132 static uint8_t
 133 ao_lco_box_present(uint16_t box)
 134 {
 135         if (box >= AO_PAD_MAX_BOXES)
 136                 return 0;
 137         return (ao_lco_box_mask[MASK_ID(box)] >> MASK_SHIFT(box)) & 1;
 138 }
 139
 140 static uint8_t
 141 ao_lco_pad_present(uint8_t box, uint8_t pad)
 142 {
 143         /* voltage measurement is always valid */
 144         if (pad == 0)
 145                 return 1;
 146         if (!ao_lco_channels[box])
 147                 return 0;
 148         if (pad > AO_PAD_MAX_CHANNELS)
 149                 return 0;
 150         return (ao_lco_channels[box] >> (pad - 1)) & 1;
 151 }
 152
 153 static uint8_t
 154 ao_lco_pad_first(uint8_t box)
 155 {
 156         uint8_t pad;
 157
 158         for (pad = 1; pad <= AO_PAD_MAX_CHANNELS; pad++)
 159                 if (ao_lco_pad_present(box, pad))
 160                         return pad;
 161         return 0;
 162 }
 163
 164 static void
 165 ao_lco_set_select(void)
 166 {
 167         if (ao_lco_armed) {
 168                 ao_led_off(AO_LED_PAD);
 169                 ao_led_off(AO_LED_BOX);
 170         } else {
 171                 switch (ao_lco_select_mode) {
 172                 case AO_LCO_SELECT_PAD:
 173                         ao_led_off(AO_LED_BOX);
 174                         ao_led_on(AO_LED_PAD);
 175                         break;
 176                 case AO_LCO_SELECT_BOX:
 177                         ao_led_off(AO_LED_PAD);
 178                         ao_led_on(AO_LED_BOX);
 179                         break;
 180                 default:
 181                         break;
 182                 }
 183         }
 184 }
 185
 186 static struct ao_task   ao_lco_drag_task;
 187 static uint8_t          ao_lco_drag_active;
 188 static uint8_t          ao_lco_drag_beep_count;
 189 static uint8_t          ao_lco_drag_beep_on;
 190 static uint16_t         ao_lco_drag_beep_time;
 191 static uint16_t         ao_lco_drag_warn_time;
 192
 193 #define AO_LCO_DRAG_BEEP_TIME   AO_MS_TO_TICKS(50)
 194 #define AO_LCO_DRAG_WARN_TIME   AO_SEC_TO_TICKS(5)
 195
 196 static void
 197 ao_lco_drag_beep_start(void)
 198 {
 199         ao_beep(AO_BEEP_HIGH);
 200         PRINTD("beep start\n");
 201         ao_lco_drag_beep_on = 1;
 202         ao_lco_drag_beep_time = ao_time() + AO_LCO_DRAG_BEEP_TIME;
 203 }
 204
 205 static void
 206 ao_lco_drag_beep_stop(void)
 207 {
 208         ao_beep(0);
 209         PRINTD("beep stop\n");
 210         ao_lco_drag_beep_on = 0;
 211         if (ao_lco_drag_beep_count) {
 212                 --ao_lco_drag_beep_count;
 213                 if (ao_lco_drag_beep_count)
 214                         ao_lco_drag_beep_time = ao_time() + AO_LCO_DRAG_BEEP_TIME;
 215         }
 216 }
 217
 218 static void
 219 ao_lco_drag_beep(uint8_t beeps)
 220 {
 221         PRINTD("beep %d\n", beeps);
 222         if (!ao_lco_drag_beep_count)
 223                 ao_lco_drag_beep_start();
 224         ao_lco_drag_beep_count += beeps;
 225 }
 226
 227 static uint16_t
 228 ao_lco_drag_beep_check(uint16_t now, uint16_t delay)
 229 {
 230         PRINTD("beep check count %d delta %d\n",
 231                ao_lco_drag_beep_count,
 232                (int16_t) (now - ao_lco_drag_beep_time));
 233         if (ao_lco_drag_beep_count) {
 234                 if ((int16_t) (now - ao_lco_drag_beep_time) >= 0) {
 235                         if (ao_lco_drag_beep_on)
 236                                 ao_lco_drag_beep_stop();
 237                         else
 238                                 ao_lco_drag_beep_start();
 239                 }
 240         }
 241
 242         if (ao_lco_drag_beep_count) {
 243                 if (delay > AO_LCO_DRAG_BEEP_TIME)
 244                         delay = AO_LCO_DRAG_BEEP_TIME;
 245         }
 246         return delay;
 247 }
 248
 249 static void
 250 ao_lco_drag_enable(void)
 251 {
 252         PRINTD("Drag enable\n");
 253         ao_lco_drag_race = 1;
 254         memset(ao_lco_selected, 0, sizeof (ao_lco_selected));
 255         ao_led_on(AO_LED_DRAG);
 256         ao_lco_drag_beep(5);
 257         ao_lco_set_display();
 258 }
 259
 260 static void
 261 ao_lco_drag_disable(void)
 262 {
 263         PRINTD("Drag disable\n");
 264         ao_lco_drag_race = 0;
 265         ao_led_off(AO_LED_DRAG);
 266         memset(ao_lco_selected, 0, sizeof (ao_lco_selected));
 267         ao_lco_drag_beep(2);
 268         ao_lco_set_display();
 269 }
 270
 271 static uint16_t
 272 ao_lco_drag_warn_check(uint16_t now, uint16_t delay)
 273 {
 274         uint16_t        warn_delay = ~0;
 275
 276         if (ao_lco_drag_race) {
 277                 if ((int16_t) (now - ao_lco_drag_warn_time) >= 0) {
 278                         ao_lco_drag_beep(1);
 279                         ao_lco_drag_warn_time = now + AO_LCO_DRAG_WARN_TIME;
 280                 }
 281                 warn_delay = ao_lco_drag_warn_time - now;
 282         }
 283         if (delay > warn_delay)
 284                 delay = warn_delay;
 285         return delay;
 286 }
 287
 288 static void
 289 ao_lco_drag_monitor(void)
 290 {
 291         uint16_t        delay = ~0;
 292         uint16_t        now;
 293
 294         for (;;) {
 295                 PRINTD("Drag monitor active %d delay %d\n", ao_lco_drag_active, delay);
 296                 if (delay == (uint16_t) ~0)
 297                         ao_sleep(&ao_lco_drag_active);
 298                 else
 299                         ao_sleep_for(&ao_lco_drag_active, delay);
 300
 301                 delay = ~0;
 302                 if (!ao_lco_drag_active)
 303                         continue;
 304
 305                 now = ao_time();
 306                 delay = ao_lco_drag_warn_check(now, delay);
 307                 delay = ao_lco_drag_beep_check(now, delay);
 308
 309                 /* check to see if there's anything left to do here */
 310                 if (!ao_lco_drag_race && !ao_lco_drag_beep_count) {
 311                         delay = ~0;
 312                         ao_lco_drag_active = 0;
 313                 }
 314         }
 315 }
 316
 317 static void
 318 ao_lco_input(void)
 319 {
 320         static struct ao_event  event;
 321         int8_t          dir, new_pad;
 322         int16_t         new_box;
 323
 324         ao_beep_for(AO_BEEP_MID, AO_MS_TO_TICKS(200));
 325         for (;;) {
 326                 ao_event_get(&event);
 327                 PRINTD("event type %d unit %d value %d\n",
 328                        event.type, event.unit, event.value);
 329                 switch (event.type) {
 330                 case AO_EVENT_QUADRATURE:
 331                         switch (event.unit) {
 332                         case AO_QUADRATURE_SELECT:
 333                                 if (!ao_lco_armed) {
 334                                         switch (ao_lco_select_mode) {
 335                                         case AO_LCO_SELECT_PAD:
 336                                                 dir = (int8_t) event.value;
 337                                                 new_pad = ao_lco_pad;
 338                                                 do {
 339                                                         new_pad += dir;
 340                                                         if (new_pad > AO_PAD_MAX_CHANNELS)
 341                                                                 new_pad = 0;
 342                                                         if (new_pad < 0)
 343                                                                 new_pad = AO_PAD_MAX_CHANNELS;
 344                                                         if (new_pad == ao_lco_pad)
 345                                                                 break;
 346                                                 } while (!ao_lco_pad_present(ao_lco_box, new_pad));
 347                                                 if (new_pad != ao_lco_pad) {
 348                                                         ao_lco_pad = new_pad;
 349                                                         ao_lco_set_display();
 350                                                 }
 351                                                 break;
 352                                         case AO_LCO_SELECT_BOX:
 353                                                 dir = (int8_t) event.value;
 354                                                 new_box = ao_lco_box;
 355                                                 do {
 356                                                         new_box += dir;
 357                                                         if (new_box > ao_lco_max_box)
 358                                                                 new_box = ao_lco_min_box;
 359                                                         else if (new_box < ao_lco_min_box)
 360                                                                 new_box = ao_lco_max_box;
 361                                                         if (new_box == ao_lco_box)
 362                                                                 break;
 363                                                 } while (!ao_lco_box_present(new_box));
 364                                                 if (ao_lco_box != new_box) {
 365                                                         ao_lco_box = new_box;
 366                                                         ao_lco_pad = 1;
 367                                                         ao_lco_channels[ao_lco_box] = 0;
 368                                                         ao_lco_set_display();
 369                                                 }
 370                                                 break;
 371                                         default:
 372                                                 break;
 373                                         }
 374                                 }
 375                                 break;
 376                         }
 377                         break;
 378                 case AO_EVENT_BUTTON:
 379                         switch (event.unit) {
 380                         case AO_BUTTON_ARM:
 381                                 ao_lco_armed = event.value;
 382                                 PRINTD("Armed %d\n", ao_lco_armed);
 383                                 if (ao_lco_armed) {
 384                                         if (ao_lco_drag_race) {
 385                                                 uint8_t box;
 386
 387                                                 for (box = ao_lco_min_box; box <= ao_lco_max_box; box++)
 388                                                         if (ao_lco_selected[box])
 389                                                                 break;
 390                                                 if (box > ao_lco_max_box)
 391                                                         ao_lco_armed = 0;
 392                                         } else {
 393                                                 memset(ao_lco_selected, 0, sizeof (ao_lco_selected));
 394                                                 if (ao_lco_pad != 0)
 395                                                         ao_lco_selected[ao_lco_box] = (1 << (ao_lco_pad - 1));
 396                                                 else
 397                                                         ao_lco_armed = 0;
 398                                         }
 399                                 }
 400                                 ao_lco_set_select();
 401                                 ao_wakeup(&ao_lco_armed);
 402                                 break;
 403                         case AO_BUTTON_FIRE:
 404                                 if (ao_lco_armed) {
 405                                         ao_lco_firing = event.value;
 406                                         PRINTD("Firing %d\n", ao_lco_firing);
 407                                         ao_wakeup(&ao_lco_armed);
 408                                 }
 409                                 break;
 410                         case AO_BUTTON_DRAG_SELECT:
 411                                 if (event.value && ao_lco_drag_race) {
 412                                         if (ao_lco_pad != 0) {
 413                                                 ao_lco_selected[ao_lco_box] ^= (1 << (ao_lco_pad - 1));
 414                                                 PRINTD("Toggle box %d pad %d (pads now %x) to drag race\n",
 415                                                        ao_lco_pad, ao_lco_box, ao_lco_selected[ao_lco_box]);
 416                                                 ao_lco_drag_beep(ao_lco_pad);
 417                                         }
 418                                 }
 419                                 break;
 420                         case AO_BUTTON_DRAG_MODE:
 421                                 if (event.value)
 422                                         ao_lco_drag_enable();
 423                                 else
 424                                         ao_lco_drag_disable();
 425                                 break;
 426                         case AO_BUTTON_ENCODER_SELECT:
 427                                 if (event.value) {
 428                                         if (!ao_lco_armed) {
 429                                                 ao_lco_select_mode = 1 - ao_lco_select_mode;
 430                                                 ao_lco_set_select();
 431                                         }
 432                                 }
 433                                 break;
 434                         }
 435                         break;
 436                 }
 437         }
 438 }
 439
 440 static AO_LED_TYPE      continuity_led[AO_LED_CONTINUITY_NUM] = {
 441 #ifdef AO_LED_CONTINUITY_0
 442         AO_LED_CONTINUITY_0,
 443 #endif
 444 #ifdef AO_LED_CONTINUITY_1
 445         AO_LED_CONTINUITY_1,
 446 #endif
 447 #ifdef AO_LED_CONTINUITY_2
 448         AO_LED_CONTINUITY_2,
 449 #endif
 450 #ifdef AO_LED_CONTINUITY_3
 451         AO_LED_CONTINUITY_3,
 452 #endif
 453 #ifdef AO_LED_CONTINUITY_4
 454         AO_LED_CONTINUITY_4,
 455 #endif
 456 #ifdef AO_LED_CONTINUITY_5
 457         AO_LED_CONTINUITY_5,
 458 #endif
 459 #ifdef AO_LED_CONTINUITY_6
 460         AO_LED_CONTINUITY_6,
 461 #endif
 462 #ifdef AO_LED_CONTINUITY_7
 463         AO_LED_CONTINUITY_7,
 464 #endif
 465 };
 466
 467 static uint8_t
 468 ao_lco_get_channels(uint8_t box, struct ao_pad_query *query)
 469 {
 470         int8_t                  r;
 471
 472         r = ao_lco_query(box, query, &ao_lco_tick_offset[box]);
 473         if (r == AO_RADIO_CMAC_OK) {
 474                 ao_lco_channels[box] = query->channels;
 475                 ao_lco_valid[box] = AO_LCO_VALID_LAST | AO_LCO_VALID_EVER;
 476         } else
 477                 ao_lco_valid[box] &= ~AO_LCO_VALID_LAST;
 478         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]);
 479         ao_wakeup(&ao_pad_query);
 480         return ao_lco_valid[box];
 481 }
 482
 483 static void
 484 ao_lco_update(void)
 485 {
 486         uint8_t previous_valid = ao_lco_valid[ao_lco_box];
 487
 488         if (ao_lco_get_channels(ao_lco_box, &ao_pad_query) & AO_LCO_VALID_LAST) {
 489                 if (!(previous_valid & AO_LCO_VALID_EVER)) {
 490                         if (ao_lco_pad != 0)
 491                                 ao_lco_pad = ao_lco_pad_first(ao_lco_box);
 492                         ao_lco_set_display();
 493                 }
 494                 if (ao_lco_pad == 0)
 495                         ao_lco_set_display();
 496         }
 497 }
 498
 499 static void
 500 ao_lco_box_reset_present(void)
 501 {
 502         ao_lco_min_box = 0xff;
 503         ao_lco_max_box = 0x00;
 504         memset(ao_lco_box_mask, 0, sizeof (ao_lco_box_mask));
 505 }
 506
 507 static void
 508 ao_lco_box_set_present(uint8_t box)
 509 {
 510         if (box < ao_lco_min_box)
 511                 ao_lco_min_box = box;
 512         if (box > ao_lco_max_box)
 513                 ao_lco_max_box = box;
 514         if (box >= AO_PAD_MAX_BOXES)
 515                 return;
 516         ao_lco_box_mask[MASK_ID(box)] |= 1 << MASK_SHIFT(box);
 517 }
 518
 519 static void
 520 ao_lco_search(void)
 521 {
 522         int8_t          r;
 523         int8_t          try;
 524         uint8_t         box;
 525         uint8_t         boxes = 0;
 526
 527         ao_lco_box_reset_present();
 528         ao_lco_set_pad(0);
 529         for (box = 0; box < AO_PAD_MAX_BOXES; box++) {
 530                 if ((box % 10) == 0)
 531                         ao_lco_set_box(box);
 532                 for (try = 0; try < 3; try++) {
 533                         ao_lco_tick_offset[box] = 0;
 534                         r = ao_lco_query(box, &ao_pad_query, &ao_lco_tick_offset[box]);
 535                         PRINTD("box %d result %d offset %d\n", box, r, ao_lco_tick_offset[box]);
 536                         if (r == AO_RADIO_CMAC_OK) {
 537                                 ++boxes;
 538                                 ao_lco_box_set_present(box);
 539                                 ao_lco_set_pad(boxes % 10);
 540                                 ao_delay(AO_MS_TO_TICKS(30));
 541                                 break;
 542                         }
 543                 }
 544         }
 545         if (ao_lco_min_box <= ao_lco_max_box)
 546                 ao_lco_box = ao_lco_min_box;
 547         else
 548                 ao_lco_min_box = ao_lco_max_box = ao_lco_box = 0;
 549         memset(ao_lco_valid, 0, sizeof (ao_lco_valid));
 550         memset(ao_lco_channels, 0, sizeof (ao_lco_channels));
 551         ao_lco_pad = 1;
 552         ao_lco_set_display();
 553 }
 554
 555 static void
 556 ao_lco_igniter_status(void)
 557 {
 558         uint8_t         c;
 559         uint8_t         t = 0;
 560
 561         for (;;) {
 562                 ao_sleep(&ao_pad_query);
 563                 PRINTD("RSSI %d VALID %d\n", ao_radio_cmac_rssi, ao_lco_valid[ao_lco_box]);
 564                 if (!(ao_lco_valid[ao_lco_box] & AO_LCO_VALID_LAST)) {
 565                         ao_led_on(AO_LED_RED);
 566                         ao_led_off(AO_LED_GREEN|AO_LED_AMBER);
 567                         continue;
 568                 }
 569                 if (ao_radio_cmac_rssi < -90) {
 570                         ao_led_on(AO_LED_AMBER);
 571                         ao_led_off(AO_LED_RED|AO_LED_GREEN);
 572                 } else {
 573                         ao_led_on(AO_LED_GREEN);
 574                         ao_led_off(AO_LED_RED|AO_LED_AMBER);
 575                 }
 576                 if (ao_pad_query.arm_status)
 577                         ao_led_on(AO_LED_REMOTE_ARM);
 578                 else
 579                         ao_led_off(AO_LED_REMOTE_ARM);
 580
 581                 for (c = 0; c < AO_LED_CONTINUITY_NUM; c++) {
 582                         uint8_t status;
 583
 584                         if (ao_lco_drag_race) {
 585                                 if (ao_lco_selected[ao_lco_box] & (1 << c) && t)
 586                                         ao_led_on(continuity_led[c]);
 587                                 else
 588                                         ao_led_off(continuity_led[c]);
 589                         } else {
 590                                 if (ao_pad_query.channels & (1 << c))
 591                                         status = ao_pad_query.igniter_status[c];
 592                                 else
 593                                         status = AO_PAD_IGNITER_STATUS_NO_IGNITER_RELAY_OPEN;
 594                                 if (status == AO_PAD_IGNITER_STATUS_GOOD_IGNITER_RELAY_OPEN)
 595                                         ao_led_on(continuity_led[c]);
 596                                 else
 597                                         ao_led_off(continuity_led[c]);
 598                         }
 599                 }
 600                 t = 1-t;
 601         }
 602 }
 603
 604 static void
 605 ao_lco_arm_warn(void)
 606 {
 607         for (;;) {
 608                 while (!ao_lco_armed) {
 609                         ao_led_off(AO_LED_FIRE);
 610                         ao_sleep(&ao_lco_armed);
 611                 }
 612                 ao_led_on(AO_LED_FIRE);
 613                 ao_beep_for(AO_BEEP_MID, AO_MS_TO_TICKS(200));
 614                 ao_delay(AO_MS_TO_TICKS(200));
 615         }
 616 }
 617
 618 static struct ao_task ao_lco_input_task;
 619 static struct ao_task ao_lco_monitor_task;
 620 static struct ao_task ao_lco_arm_warn_task;
 621 static struct ao_task ao_lco_igniter_status_task;
 622
 623 static void
 624 ao_lco_monitor(void)
 625 {
 626         uint16_t                delay;
 627         uint8_t                 box;
 628
 629         ao_lco_search();
 630         ao_add_task(&ao_lco_input_task, ao_lco_input, "lco input");
 631         ao_add_task(&ao_lco_arm_warn_task, ao_lco_arm_warn, "lco arm warn");
 632         ao_add_task(&ao_lco_igniter_status_task, ao_lco_igniter_status, "lco igniter status");
 633         ao_add_task(&ao_lco_drag_task, ao_lco_drag_monitor, "drag race");
 634         for (;;) {
 635                 PRINTD("monitor armed %d firing %d\n",
 636                        ao_lco_armed, ao_lco_firing);
 637
 638                 if (ao_lco_armed && ao_lco_firing) {
 639                         ao_lco_ignite(AO_PAD_FIRE);
 640                 } else {
 641                         ao_lco_update();
 642                         if (ao_lco_armed) {
 643                                 for (box = ao_lco_min_box; box <= ao_lco_max_box; box++) {
 644                                         if (ao_lco_selected[box]) {
 645                                                 PRINTD("Arming box %d pads %x\n",
 646                                                        box, ao_lco_selected[box]);
 647                                                 if (ao_lco_valid[box] & AO_LCO_VALID_EVER) {
 648                                                         ao_lco_arm(box, ao_lco_selected[box], ao_lco_tick_offset[box]);
 649                                                         ao_delay(AO_MS_TO_TICKS(10));
 650                                                 }
 651                                         }
 652                                 }
 653                         }
 654                 }
 655                 if (ao_lco_armed && ao_lco_firing)
 656                         delay = AO_MS_TO_TICKS(100);
 657                 else
 658                         delay = AO_SEC_TO_TICKS(1);
 659                 ao_sleep_for(&ao_lco_armed, delay);
 660         }
 661 }
 662
 663 #if DEBUG
 664 void
 665 ao_lco_set_debug(void)
 666 {
 667         ao_cmd_decimal();
 668         if (ao_cmd_status == ao_cmd_success)
 669                 ao_lco_debug = ao_cmd_lex_i != 0;
 670 }
 671
 672 __code struct ao_cmds ao_lco_cmds[] = {
 673         { ao_lco_set_debug,     "D <0 off, 1 on>\0Debug" },
 674         { ao_lco_search,        "s\0Search for pad boxes" },
 675         { 0, NULL }
 676 };
 677 #endif
 678
 679 void
 680 ao_lco_init(void)
 681 {
 682         ao_add_task(&ao_lco_monitor_task, ao_lco_monitor, "lco monitor");
 683 #if DEBUG
 684         ao_cmd_register(&ao_lco_cmds[0]);
 685 #endif
 686 }