git.gag.com Git - fw/altos/blob - src/drivers/ao_lco_bits.c

   1 /*
   2  * Copyright © 2018 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
  15 #include <ao.h>
  16 #include <ao_lco.h>
  17 #include <ao_radio_cmac.h>
  18
  19 uint8_t         ao_lco_debug;
  20
  21 int8_t          ao_lco_pad;
  22 int16_t         ao_lco_box;
  23
  24 uint8_t         ao_lco_armed;                                   /* arm active */
  25 uint8_t         ao_lco_firing;                                  /* fire active */
  26
  27 int16_t         ao_lco_min_box, ao_lco_max_box;
  28
  29 uint8_t         ao_lco_pretending;
  30
  31 #if AO_LCO_DRAG
  32 uint8_t         ao_lco_drag_race;
  33 #endif
  34
  35 struct ao_pad_query     ao_pad_query;                           /* latest query response */
  36
  37 static uint8_t          ao_lco_channels[AO_PAD_MAX_BOXES];      /* pad channels available on each box */
  38 static uint16_t         ao_lco_tick_offset[AO_PAD_MAX_BOXES];   /* 16 bit offset from local to remote tick count */
  39 static uint8_t          ao_lco_selected[AO_PAD_MAX_BOXES];      /* pads selected to fire */
  40
  41 uint8_t         ao_lco_valid[AO_PAD_MAX_BOXES];         /* AO_LCO_VALID bits per box */
  42
  43 static const AO_LED_TYPE        continuity_led[AO_LED_CONTINUITY_NUM] = {
  44 #ifdef AO_LED_CONTINUITY_0
  45         AO_LED_CONTINUITY_0,
  46 #endif
  47 #ifdef AO_LED_CONTINUITY_1
  48         AO_LED_CONTINUITY_1,
  49 #endif
  50 #ifdef AO_LED_CONTINUITY_2
  51         AO_LED_CONTINUITY_2,
  52 #endif
  53 #ifdef AO_LED_CONTINUITY_3
  54         AO_LED_CONTINUITY_3,
  55 #endif
  56 #ifdef AO_LED_CONTINUITY_4
  57         AO_LED_CONTINUITY_4,
  58 #endif
  59 #ifdef AO_LED_CONTINUITY_5
  60         AO_LED_CONTINUITY_5,
  61 #endif
  62 #ifdef AO_LED_CONTINUITY_6
  63         AO_LED_CONTINUITY_6,
  64 #endif
  65 #ifdef AO_LED_CONTINUITY_7
  66         AO_LED_CONTINUITY_7,
  67 #endif
  68 };
  69
  70 /* Set LEDs to match remote box status */
  71 void
  72 ao_lco_igniter_status(void)
  73 {
  74         uint8_t         c;
  75         uint8_t         t = 0;
  76
  77         for (;;) {
  78 #if AO_LCO_DRAG
  79                 if (ao_lco_drag_race)
  80                         ao_sleep_for(&ao_pad_query, AO_MS_TO_TICKS(50));
  81                 else
  82 #endif
  83                         ao_sleep(&ao_pad_query);
  84                 if (ao_lco_box_pseudo(ao_lco_box)) {
  85                         ao_led_off(AO_LED_GREEN|AO_LED_AMBER|AO_LED_RED);
  86                         continue;
  87                 }
  88                 PRINTD("RSSI %d VALID %d\n", ao_radio_cmac_rssi, ao_lco_valid[ao_lco_box]);
  89                 if (!(ao_lco_valid[ao_lco_box] & AO_LCO_VALID_LAST)) {
  90                         ao_led_on(AO_LED_RED);
  91                         ao_led_off(AO_LED_GREEN|AO_LED_AMBER);
  92                         continue;
  93                 }
  94                 if (ao_radio_cmac_rssi < -90) {
  95                         ao_led_on(AO_LED_AMBER);
  96                         ao_led_off(AO_LED_RED|AO_LED_GREEN);
  97                 } else {
  98                         ao_led_on(AO_LED_GREEN);
  99                         ao_led_off(AO_LED_RED|AO_LED_AMBER);
 100                 }
 101                 if (ao_pad_query.arm_status)
 102                         ao_led_on(AO_LED_REMOTE_ARM);
 103                 else
 104                         ao_led_off(AO_LED_REMOTE_ARM);
 105
 106                 for (c = 0; c < AO_LED_CONTINUITY_NUM; c++) {
 107                         uint8_t status;
 108
 109                         if (ao_pad_query.channels & (1 << c))
 110                                 status = ao_pad_query.igniter_status[c];
 111                         else
 112                                 status = AO_PAD_IGNITER_STATUS_NO_IGNITER_RELAY_OPEN;
 113
 114 #if AO_LCO_DRAG
 115                         if (ao_lco_drag_race && (ao_lco_selected[ao_lco_box] & (1 << c))) {
 116                                 uint8_t on = 0;
 117                                 if (status == AO_PAD_IGNITER_STATUS_GOOD_IGNITER_RELAY_OPEN) {
 118                                         if (t)
 119                                                 on = 1;
 120                                 } else {
 121                                         if (t == 1)
 122                                                 on = 1;
 123                                 }
 124                                 if (on)
 125                                         ao_led_on(continuity_led[c]);
 126                                 else
 127                                         ao_led_off(continuity_led[c]);
 128                         } else
 129 #endif
 130                         {
 131                                 if (status == AO_PAD_IGNITER_STATUS_GOOD_IGNITER_RELAY_OPEN)
 132                                         ao_led_on(continuity_led[c]);
 133                                 else
 134                                         ao_led_off(continuity_led[c]);
 135                         }
 136                 }
 137                 t = (t + 1) & 3;
 138         }
 139 }
 140
 141 uint8_t
 142 ao_lco_pad_present(int16_t box, int8_t pad)
 143 {
 144         /* voltage measurement is always valid */
 145         if (ao_lco_pad_pseudo(pad))
 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 int8_t
 155 ao_lco_pad_first(int16_t box)
 156 {
 157         int8_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 uint8_t
 166 ao_lco_get_channels(int16_t box, struct ao_pad_query *query)
 167 {
 168         int8_t                  r;
 169
 170         r = ao_lco_query((uint16_t) box, query, &ao_lco_tick_offset[box]);
 171         if (r == AO_RADIO_CMAC_OK) {
 172                 ao_lco_channels[box] = query->channels;
 173                 ao_lco_valid[box] = AO_LCO_VALID_LAST | AO_LCO_VALID_EVER;
 174         } else
 175                 ao_lco_valid[box] &= (uint8_t) ~AO_LCO_VALID_LAST;
 176         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]);
 177         ao_wakeup(&ao_pad_query);
 178         return ao_lco_valid[box];
 179 }
 180
 181 void
 182 ao_lco_update(void)
 183 {
 184         if (ao_lco_box_pseudo(ao_lco_box)) {
 185                 ao_lco_show();
 186                 return;
 187         }
 188
 189         uint8_t previous_valid = ao_lco_valid[ao_lco_box];
 190
 191         if (ao_lco_get_channels(ao_lco_box, &ao_pad_query) & AO_LCO_VALID_LAST) {
 192                 if (!(previous_valid & AO_LCO_VALID_EVER)) {
 193                         if (!ao_lco_pad_pseudo(ao_lco_pad))
 194                                 ao_lco_set_pad(ao_lco_pad_first(ao_lco_box));
 195                 }
 196                 if (ao_lco_pad_pseudo(ao_lco_pad))
 197                         ao_lco_show();
 198         }
 199 }
 200
 201 uint8_t ao_lco_box_mask[AO_LCO_MASK_SIZE(AO_PAD_MAX_BOXES)];
 202
 203 static void
 204 ao_lco_box_reset_present(void)
 205 {
 206         ao_lco_min_box = 0xff;
 207         ao_lco_max_box = 0x00;
 208         ao_lco_pretending = 0;
 209         memset(ao_lco_box_mask, 0, sizeof (ao_lco_box_mask));
 210 }
 211
 212 static void
 213 ao_lco_box_set_present(int16_t box)
 214 {
 215         if (box < ao_lco_min_box)
 216                 ao_lco_min_box = box;
 217         if (box > ao_lco_max_box)
 218                 ao_lco_max_box = box;
 219         if (box >= AO_PAD_MAX_BOXES)
 220                 return;
 221         ao_lco_box_mask[AO_LCO_MASK_ID(box)] |= (uint8_t) (1 << AO_LCO_MASK_SHIFT(box));
 222 }
 223
 224 void
 225 ao_lco_set_pad(int8_t new_pad)
 226 {
 227         ao_lco_pad = new_pad;
 228         ao_lco_show();
 229 }
 230
 231 void
 232 ao_lco_set_box(int16_t new_box)
 233 {
 234         ao_lco_box = new_box;
 235         if (!ao_lco_box_pseudo(ao_lco_box)) {
 236                 if (ao_lco_box < AO_PAD_MAX_BOXES) {
 237                         if (ao_lco_pretending)
 238                                 ao_lco_channels[ao_lco_box] = 0xff;
 239                         else
 240                                 ao_lco_channels[ao_lco_box] = 0;
 241                 }
 242         }
 243         ao_lco_pad = 1;
 244         ao_lco_show();
 245 }
 246
 247 void
 248 ao_lco_step_pad(int8_t dir)
 249 {
 250         int16_t new_pad;
 251
 252         switch (ao_lco_box) {
 253 #ifdef AO_LCO_HAS_CONTRAST
 254         case AO_LCO_CONTRAST: {
 255                 int32_t contrast = ao_lco_get_contrast();
 256
 257                 contrast = (contrast + AO_LCO_CONTRAST_STEP - 1) / AO_LCO_CONTRAST_STEP;
 258                 contrast += dir;
 259                 contrast *= AO_LCO_CONTRAST_STEP;
 260                 if (contrast < AO_LCO_MIN_CONTRAST)
 261                         contrast = AO_LCO_MIN_CONTRAST;
 262                 if (contrast > AO_LCO_MAX_CONTRAST)
 263                         contrast = AO_LCO_MAX_CONTRAST;
 264                 ao_lco_set_contrast(contrast);
 265                 ao_lco_show();
 266                 break;
 267         }
 268 #endif
 269 #ifdef AO_LCO_HAS_BACKLIGHT
 270         case AO_LCO_BACKLIGHT: {
 271                 int32_t backlight = ao_lco_get_backlight();
 272
 273                 backlight = (backlight + AO_LCO_BACKLIGHT_STEP - 1) / AO_LCO_BACKLIGHT_STEP;
 274                 backlight += dir;
 275                 backlight *= AO_LCO_BACKLIGHT_STEP;
 276                 if (backlight < AO_LCO_MIN_BACKLIGHT)
 277                         backlight = AO_LCO_MIN_BACKLIGHT;
 278                 if (backlight > AO_LCO_MAX_BACKLIGHT)
 279                         backlight = AO_LCO_MAX_BACKLIGHT;
 280                 ao_lco_set_backlight(backlight);
 281                 ao_lco_show();
 282                 break;
 283         }
 284 #endif
 285 #ifdef AO_LCO_HAS_INFO
 286         case AO_LCO_INFO: {
 287 #if AO_LCO_MIN_INFO_PAGE < AO_LCO_MAX_INFO_PAGE
 288                 int32_t info_page = ao_lco_get_info_page();
 289
 290                 info += dir;
 291                 if (info_page < AO_LCO_MIN_INFO_PAGE)
 292                         info_page = AO_LCO_MIN_INFO_PAGE;
 293                 if (info_page > AO_LCO_MAX_INFO_PAGE)
 294                         info_page = AO_LCO_MAX_INFO_PAGE;
 295                 ao_lco_set_info_page();
 296 #endif
 297                 break;
 298         }
 299 #endif
 300         default:
 301                 new_pad = (int16_t) ao_lco_pad;
 302                 do {
 303                         new_pad += dir;
 304                         if (new_pad > AO_PAD_MAX_CHANNELS)
 305                                 new_pad = AO_LCO_PAD_FIRST;
 306                         if (new_pad < AO_LCO_PAD_FIRST)
 307                                 new_pad = AO_PAD_MAX_CHANNELS;
 308                         if (new_pad == ao_lco_pad)
 309                                 break;
 310                 } while (!ao_lco_pad_present(ao_lco_box, (int8_t) new_pad));
 311                 PRINTD("New pad %d\n", new_pad);
 312                 ao_lco_set_pad((int8_t) new_pad);
 313                 break;
 314         }
 315 }
 316
 317 uint8_t
 318 ao_lco_box_present(int16_t box)
 319 {
 320         if (ao_lco_box_pseudo(box))
 321                 return 1;
 322         if (box >= AO_PAD_MAX_BOXES)
 323                 return 0;
 324         return (ao_lco_box_mask[AO_LCO_MASK_ID(box)] >> AO_LCO_MASK_SHIFT(box)) & 1;
 325 }
 326
 327 void
 328 ao_lco_step_box(int8_t dir)
 329 {
 330         int16_t new_box = ao_lco_box;
 331
 332         do {
 333                 new_box += dir;
 334                 if (new_box > ao_lco_max_box)
 335                         new_box = AO_LCO_BOX_FIRST;
 336                 else if (new_box < AO_LCO_BOX_FIRST)
 337                         new_box = ao_lco_max_box;
 338                 if (new_box == ao_lco_box)
 339                         break;
 340         } while (!ao_lco_box_present(new_box));
 341         PRINTD("New box %d\n", new_box);
 342         ao_lco_set_box(new_box);
 343 }
 344
 345 void
 346 ao_lco_set_armed(uint8_t armed)
 347 {
 348         if (ao_lco_box_pseudo(ao_lco_box))
 349                 return;
 350
 351         ao_lco_armed = armed;
 352         PRINTD("Armed %d\n", ao_lco_armed);
 353         if (ao_lco_armed) {
 354 #if AO_LCO_DRAG
 355                 if (ao_lco_drag_race) {
 356                         int16_t box;
 357
 358                         for (box = ao_lco_min_box; box <= ao_lco_max_box; box++)
 359                                 if (ao_lco_selected[box])
 360                                         break;
 361                         if (box > ao_lco_max_box)
 362                                 ao_lco_armed = 0;
 363                 } else
 364 #endif
 365                 {
 366                         memset(ao_lco_selected, 0, sizeof (ao_lco_selected));
 367                         if (ao_lco_pad != 0)
 368                                 ao_lco_selected[ao_lco_box] = (1 << (ao_lco_pad - 1));
 369                         else
 370                                 ao_lco_armed = 0;
 371                 }
 372         }
 373         ao_wakeup(&ao_lco_armed);
 374 }
 375
 376 void
 377 ao_lco_set_firing(uint8_t firing)
 378 {
 379         ao_lco_firing = firing;
 380         PRINTD("Firing %d\n", ao_lco_firing);
 381         ao_wakeup(&ao_lco_armed);
 382 }
 383
 384 void
 385 ao_lco_search(void)
 386 {
 387         int8_t          r;
 388         int8_t          try;
 389         int16_t         box;
 390         uint16_t        boxes = 0;
 391
 392         ao_lco_box_reset_present();
 393 #ifdef AO_LCO_SEARCH_API
 394         ao_lco_search_start();
 395 #else
 396         ao_lco_show_box(0);
 397         ao_lco_show_pad(0);
 398 #endif
 399         for (box = 0; box < AO_PAD_MAX_BOXES; box++) {
 400 #ifdef AO_LCO_SEARCH_API
 401                 ao_lco_search_box_check(box);
 402 #else
 403                 if ((box % 10) == 0)
 404                         ao_lco_show_box(box);
 405 #endif
 406                 for (try = 0; try < 3; try++) {
 407                         ao_lco_tick_offset[box] = 0;
 408                         r = ao_lco_query((uint16_t) box, &ao_pad_query, &ao_lco_tick_offset[box]);
 409                         PRINTD("box %d result %d offset %d\n", box, r, ao_lco_tick_offset[box]);
 410                         if (r == AO_RADIO_CMAC_OK) {
 411                                 ++boxes;
 412                                 ao_lco_box_set_present(box);
 413 #ifdef AO_LCO_SEARCH_API
 414                                 ao_lco_search_box_present(box);
 415 #else
 416                                 ao_lco_show_pad((uint8_t) (boxes % 10));
 417 #endif
 418                                 ao_delay(AO_MS_TO_TICKS(30));
 419                                 break;
 420                         }
 421                 }
 422         }
 423         if (ao_lco_min_box <= ao_lco_max_box)
 424                 ao_lco_box = ao_lco_min_box;
 425         else
 426                 ao_lco_min_box = ao_lco_max_box = ao_lco_box = 0;
 427         memset(ao_lco_valid, 0, sizeof (ao_lco_valid));
 428         memset(ao_lco_channels, 0, sizeof (ao_lco_channels));
 429 #ifdef AO_LCO_SEARCH_API
 430         ao_lco_search_done();
 431 #endif
 432         ao_lco_set_box(ao_lco_min_box);
 433 }
 434
 435 void
 436 ao_lco_pretend(void)
 437 {
 438         int16_t box;
 439
 440         ao_lco_pretending = 1;
 441         ao_lco_min_box = 1;
 442         ao_lco_max_box = AO_PAD_MAX_BOXES - 1;
 443         for (box = ao_lco_min_box; box <= ao_lco_max_box; box++)
 444                 ao_lco_box_set_present(box);
 445         ao_lco_box = ao_lco_min_box;
 446         memset(ao_lco_valid, 0, sizeof (ao_lco_valid));
 447         memset(ao_lco_channels, 0, sizeof (ao_lco_channels));
 448         ao_lco_set_box(ao_lco_min_box);
 449 }
 450
 451 void
 452 ao_lco_monitor(void)
 453 {
 454         AO_TICK_TYPE    delay;
 455         int16_t         box;
 456
 457         for (;;) {
 458                 PRINTD("monitor armed %d firing %d\n",
 459                        ao_lco_armed, ao_lco_firing);
 460
 461                 if (ao_lco_armed && ao_lco_firing) {
 462                         ao_lco_ignite(AO_PAD_FIRE);
 463                 } else {
 464                         ao_lco_update();
 465                         if (ao_lco_armed) {
 466                                 for (box = ao_lco_min_box; box <= ao_lco_max_box; box++) {
 467                                         if (ao_lco_selected[box]) {
 468                                                 PRINTD("Arming box %d pads %x\n",
 469                                                        box, ao_lco_selected[box]);
 470                                                 if (ao_lco_valid[box] & AO_LCO_VALID_EVER) {
 471                                                         ao_lco_arm((uint16_t) box, ao_lco_selected[box], ao_lco_tick_offset[box]);
 472                                                         ao_delay(AO_MS_TO_TICKS(10));
 473                                                 }
 474                                         }
 475                                 }
 476                         }
 477                 }
 478                 if (ao_lco_armed && ao_lco_firing)
 479                         delay = AO_MS_TO_TICKS(100);
 480                 else
 481                         delay = AO_SEC_TO_TICKS(1);
 482                 ao_sleep_for(&ao_lco_armed, delay);
 483         }
 484 }
 485
 486 #if AO_LCO_DRAG
 487
 488 int8_t                  ao_lco_drag_beep_count;
 489 static uint8_t          ao_lco_drag_beep_on;
 490 static AO_TICK_TYPE     ao_lco_drag_beep_time;
 491 static AO_TICK_TYPE     ao_lco_drag_warn_time;
 492
 493 #define AO_LCO_DRAG_BEEP_TIME   AO_MS_TO_TICKS(50)
 494 #define AO_LCO_DRAG_WARN_TIME   AO_SEC_TO_TICKS(5)
 495
 496 /* Request 'beeps' additional drag race beeps */
 497 void
 498 ao_lco_drag_add_beeps(int8_t beeps)
 499 {
 500         PRINTD("beep %d\n", beeps);
 501         if (ao_lco_drag_beep_count == 0)
 502                 ao_lco_drag_beep_time = ao_time();
 503         ao_lco_drag_beep_count += beeps;
 504         ao_wakeup(&ao_lco_drag_beep_count);
 505 }
 506
 507 /* Toggle current pad in drag set */
 508 void
 509 ao_lco_toggle_drag(void)
 510 {
 511         if (ao_lco_drag_race && !ao_lco_pad_pseudo(ao_lco_pad) && !ao_lco_box_pseudo(ao_lco_box)) {
 512                 ao_lco_selected[ao_lco_box] ^= (uint8_t) (1 << (ao_lco_pad - 1));
 513                 PRINTD("Toggle box %d pad %d (pads now %x) to drag race\n",
 514                        ao_lco_pad, ao_lco_box, ao_lco_selected[ao_lco_box]);
 515                 ao_lco_drag_add_beeps(ao_lco_pad);
 516         }
 517 }
 518
 519 /* Check whether it's time to change the beeper status, then either
 520  * turn it on or off as necessary and bump the remaining beep counts
 521  */
 522
 523 AO_TICK_TYPE
 524 ao_lco_drag_beep_check(AO_TICK_TYPE now, AO_TICK_TYPE delay)
 525 {
 526         PRINTD("beep check count %d delta %ld\n",
 527                ao_lco_drag_beep_count,
 528                (long) (AO_TICK_SIGNED) (now - ao_lco_drag_beep_time));
 529         if (ao_lco_drag_beep_count) {
 530                 if ((AO_TICK_SIGNED) (now - ao_lco_drag_beep_time) >= 0) {
 531                         if (ao_lco_drag_beep_on) {
 532                                 ao_beep(0);
 533                                 PRINTD("beep stop\n");
 534                                 ao_lco_drag_beep_on = 0;
 535                                 if (ao_lco_drag_beep_count) {
 536                                         --ao_lco_drag_beep_count;
 537                                         if (ao_lco_drag_beep_count)
 538                                                 ao_lco_drag_beep_time = now + AO_LCO_DRAG_BEEP_TIME;
 539                                 }
 540                         } else {
 541                                 ao_beep(AO_BEEP_HIGH);
 542                                 PRINTD("beep start\n");
 543                                 ao_lco_drag_beep_on = 1;
 544                                 ao_lco_drag_beep_time = now + AO_LCO_DRAG_BEEP_TIME;
 545                         }
 546                 }
 547         }
 548
 549         if (ao_lco_drag_beep_count) {
 550                 AO_TICK_TYPE beep_delay = 0;
 551
 552                 if (ao_lco_drag_beep_time > now)
 553                         beep_delay = ao_lco_drag_beep_time - now;
 554
 555                 if (delay > beep_delay)
 556                         delay = beep_delay;
 557         }
 558         return delay;
 559 }
 560
 561 void
 562 ao_lco_drag_enable(void)
 563 {
 564         if (!ao_lco_drag_race) {
 565                 PRINTD("Drag enable\n");
 566                 ao_lco_drag_race = 1;
 567                 memset(ao_lco_selected, 0, sizeof (ao_lco_selected));
 568 #ifdef AO_LED_DRAG
 569                 ao_led_on(AO_LED_DRAG);
 570 #endif
 571                 ao_lco_drag_add_beeps(5);
 572                 ao_lco_show();
 573         }
 574 }
 575
 576 void
 577 ao_lco_drag_disable(void)
 578 {
 579         if (ao_lco_drag_race) {
 580                 PRINTD("Drag disable\n");
 581                 ao_lco_drag_race = 0;
 582 #ifdef AO_LED_DRAG
 583                 ao_led_off(AO_LED_DRAG);
 584 #endif
 585                 memset(ao_lco_selected, 0, sizeof (ao_lco_selected));
 586                 ao_lco_drag_add_beeps(2);
 587                 ao_lco_show();
 588         }
 589 }
 590
 591 /* add a beep if it's time to warn the user that drag race mode is
 592  * active
 593  */
 594
 595 AO_TICK_TYPE
 596 ao_lco_drag_warn_check(AO_TICK_TYPE now, AO_TICK_TYPE delay)
 597 {
 598         if (ao_lco_drag_race) {
 599                 AO_TICK_TYPE    warn_delay;
 600
 601                 if ((AO_TICK_SIGNED) (now - ao_lco_drag_warn_time) >= 0) {
 602                         ao_lco_drag_add_beeps(1);
 603                         ao_lco_drag_warn_time = now + AO_LCO_DRAG_WARN_TIME;
 604                 }
 605                 warn_delay = ao_lco_drag_warn_time - now;
 606                 if (delay > warn_delay)
 607                         delay = warn_delay;
 608         }
 609         return delay;
 610 }
 611 #endif /* AO_LCO_DRAG */
 612
 613 /* task function for beeping while arm is active */
 614 void
 615 ao_lco_arm_warn(void)
 616 {
 617         for (;;) {
 618                 while (!ao_lco_armed) {
 619 #ifdef AO_LED_FIRE
 620                         ao_led_off(AO_LED_FIRE);
 621 #endif
 622                         ao_sleep(&ao_lco_armed);
 623                 }
 624 #ifdef AO_LED_FIRE
 625                 ao_led_on(AO_LED_FIRE);
 626 #endif
 627                 ao_beep_for(AO_BEEP_MID, AO_MS_TO_TICKS(200));
 628                 ao_delay(AO_MS_TO_TICKS(200));
 629         }
 630 }