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