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 uint8_t         ao_lco_pad;
  22 int16_t         ao_lco_box;
  23 uint8_t         ao_lco_drag_race;
  24
  25 uint8_t         ao_lco_armed;   /* arm active */
  26 uint8_t         ao_lco_firing;  /* fire active */
  27
  28 uint8_t         ao_lco_min_box, ao_lco_max_box;
  29 uint8_t         ao_lco_selected[AO_PAD_MAX_BOXES];
  30 uint8_t         ao_lco_valid[AO_PAD_MAX_BOXES];
  31 uint8_t         ao_lco_channels[AO_PAD_MAX_BOXES];
  32 uint16_t        ao_lco_tick_offset[AO_PAD_MAX_BOXES];
  33
  34 struct ao_pad_query     ao_pad_query;
  35
  36 static AO_LED_TYPE      continuity_led[AO_LED_CONTINUITY_NUM] = {
  37 #ifdef AO_LED_CONTINUITY_0
  38         AO_LED_CONTINUITY_0,
  39 #endif
  40 #ifdef AO_LED_CONTINUITY_1
  41         AO_LED_CONTINUITY_1,
  42 #endif
  43 #ifdef AO_LED_CONTINUITY_2
  44         AO_LED_CONTINUITY_2,
  45 #endif
  46 #ifdef AO_LED_CONTINUITY_3
  47         AO_LED_CONTINUITY_3,
  48 #endif
  49 #ifdef AO_LED_CONTINUITY_4
  50         AO_LED_CONTINUITY_4,
  51 #endif
  52 #ifdef AO_LED_CONTINUITY_5
  53         AO_LED_CONTINUITY_5,
  54 #endif
  55 #ifdef AO_LED_CONTINUITY_6
  56         AO_LED_CONTINUITY_6,
  57 #endif
  58 #ifdef AO_LED_CONTINUITY_7
  59         AO_LED_CONTINUITY_7,
  60 #endif
  61 };
  62
  63 /* Set LEDs to match remote box status */
  64 void
  65 ao_lco_igniter_status(void)
  66 {
  67         uint8_t         c;
  68         uint8_t         t = 0;
  69
  70         for (;;) {
  71                 if (ao_lco_drag_race)
  72                         ao_sleep_for(&ao_pad_query, AO_MS_TO_TICKS(50));
  73                 else
  74                         ao_sleep(&ao_pad_query);
  75                 PRINTD("RSSI %d VALID %d\n", ao_radio_cmac_rssi, ao_lco_valid[ao_lco_box]);
  76                 if (!(ao_lco_valid[ao_lco_box] & AO_LCO_VALID_LAST)) {
  77                         ao_led_on(AO_LED_RED);
  78                         ao_led_off(AO_LED_GREEN|AO_LED_AMBER);
  79                         continue;
  80                 }
  81                 if (ao_radio_cmac_rssi < -90) {
  82                         ao_led_on(AO_LED_AMBER);
  83                         ao_led_off(AO_LED_RED|AO_LED_GREEN);
  84                 } else {
  85                         ao_led_on(AO_LED_GREEN);
  86                         ao_led_off(AO_LED_RED|AO_LED_AMBER);
  87                 }
  88                 if (ao_pad_query.arm_status)
  89                         ao_led_on(AO_LED_REMOTE_ARM);
  90                 else
  91                         ao_led_off(AO_LED_REMOTE_ARM);
  92
  93                 for (c = 0; c < AO_LED_CONTINUITY_NUM; c++) {
  94                         uint8_t status;
  95
  96                         if (ao_pad_query.channels & (1 << c))
  97                                 status = ao_pad_query.igniter_status[c];
  98                         else
  99                                 status = AO_PAD_IGNITER_STATUS_NO_IGNITER_RELAY_OPEN;
 100
 101                         if (ao_lco_drag_race && (ao_lco_selected[ao_lco_box] & (1 << c))) {
 102                                 uint8_t on = 0;
 103                                 if (status == AO_PAD_IGNITER_STATUS_GOOD_IGNITER_RELAY_OPEN) {
 104                                         if (t)
 105                                                 on = 1;
 106                                 } else {
 107                                         if (t == 1)
 108                                                 on = 1;
 109                                 }
 110                                 if (on)
 111                                         ao_led_on(continuity_led[c]);
 112                                 else
 113                                         ao_led_off(continuity_led[c]);
 114                         } else {
 115                                 if (status == AO_PAD_IGNITER_STATUS_GOOD_IGNITER_RELAY_OPEN)
 116                                         ao_led_on(continuity_led[c]);
 117                                 else
 118                                         ao_led_off(continuity_led[c]);
 119                         }
 120                 }
 121                 t = (t + 1) & 3;
 122         }
 123 }
 124
 125 uint8_t
 126 ao_lco_pad_present(uint8_t box, uint8_t pad)
 127 {
 128         /* voltage measurement is always valid */
 129         if (pad == AO_LCO_PAD_VOLTAGE)
 130                 return 1;
 131         if (!ao_lco_channels[box])
 132                 return 0;
 133         if (pad > AO_PAD_MAX_CHANNELS)
 134                 return 0;
 135         return (ao_lco_channels[box] >> (pad - 1)) & 1;
 136 }
 137
 138 uint8_t
 139 ao_lco_pad_first(uint8_t box)
 140 {
 141         uint8_t pad;
 142
 143         for (pad = 1; pad <= AO_PAD_MAX_CHANNELS; pad++)
 144                 if (ao_lco_pad_present(box, pad))
 145                         return pad;
 146         return 0;
 147 }
 148
 149 static uint8_t
 150 ao_lco_get_channels(uint8_t box, struct ao_pad_query *query)
 151 {
 152         int8_t                  r;
 153
 154         r = ao_lco_query(box, query, &ao_lco_tick_offset[box]);
 155         if (r == AO_RADIO_CMAC_OK) {
 156                 ao_lco_channels[box] = query->channels;
 157                 ao_lco_valid[box] = AO_LCO_VALID_LAST | AO_LCO_VALID_EVER;
 158         } else
 159                 ao_lco_valid[box] &= ~AO_LCO_VALID_LAST;
 160         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]);
 161         ao_wakeup(&ao_pad_query);
 162         return ao_lco_valid[box];
 163 }
 164
 165 void
 166 ao_lco_update(void)
 167 {
 168         uint8_t previous_valid = ao_lco_valid[ao_lco_box];
 169
 170         if (ao_lco_get_channels(ao_lco_box, &ao_pad_query) & AO_LCO_VALID_LAST) {
 171                 if (!(previous_valid & AO_LCO_VALID_EVER)) {
 172                         if (ao_lco_pad != AO_LCO_PAD_VOLTAGE)
 173                                 ao_lco_set_pad(ao_lco_pad_first(ao_lco_box));
 174                 }
 175                 if (ao_lco_pad == AO_LCO_PAD_VOLTAGE)
 176                         ao_lco_show_display();
 177         }
 178 }
 179
 180 uint8_t ao_lco_box_mask[AO_LCO_MASK_SIZE(AO_PAD_MAX_BOXES)];
 181
 182 static void
 183 ao_lco_box_reset_present(void)
 184 {
 185         ao_lco_min_box = 0xff;
 186         ao_lco_max_box = 0x00;
 187         memset(ao_lco_box_mask, 0, sizeof (ao_lco_box_mask));
 188 }
 189
 190 static void
 191 ao_lco_box_set_present(uint8_t box)
 192 {
 193         if (box < ao_lco_min_box)
 194                 ao_lco_min_box = box;
 195         if (box > ao_lco_max_box)
 196                 ao_lco_max_box = box;
 197         if (box >= AO_PAD_MAX_BOXES)
 198                 return;
 199         ao_lco_box_mask[AO_LCO_MASK_ID(box)] |= 1 << AO_LCO_MASK_SHIFT(box);
 200 }
 201
 202 void
 203 ao_lco_set_pad(uint8_t new_pad)
 204 {
 205         ao_lco_pad = new_pad;
 206         ao_lco_show_display();
 207 }
 208
 209 void
 210 ao_lco_set_box(uint16_t new_box)
 211 {
 212         ao_lco_box = new_box;
 213 #if AO_LCO_DRAG
 214         if (ao_lco_box != AO_LCO_BOX_DRAG)
 215 #endif
 216                 ao_lco_channels[ao_lco_box] = 0;
 217         ao_lco_pad = 1;
 218         ao_lco_show_display();
 219 }
 220
 221 void
 222 ao_lco_step_pad(int8_t dir)
 223 {
 224         int8_t  new_pad;
 225
 226         new_pad = ao_lco_pad;
 227         do {
 228                 new_pad += dir;
 229                 if (new_pad > AO_PAD_MAX_CHANNELS)
 230                         new_pad = AO_LCO_PAD_VOLTAGE;
 231                 if (new_pad < 0)
 232                         new_pad = AO_PAD_MAX_CHANNELS;
 233                 if (new_pad == ao_lco_pad)
 234                         break;
 235         } while (!ao_lco_pad_present(ao_lco_box, new_pad));
 236         ao_lco_set_pad(new_pad);
 237 }
 238
 239 void
 240 ao_lco_set_armed(uint8_t armed)
 241 {
 242         ao_lco_armed = armed;
 243         PRINTD("Armed %d\n", ao_lco_armed);
 244         if (ao_lco_armed) {
 245                 if (ao_lco_drag_race) {
 246                         uint8_t box;
 247
 248                         for (box = ao_lco_min_box; box <= ao_lco_max_box; box++)
 249                                 if (ao_lco_selected[box])
 250                                         break;
 251                         if (box > ao_lco_max_box)
 252                                 ao_lco_armed = 0;
 253                 } else {
 254                         memset(ao_lco_selected, 0, sizeof (ao_lco_selected));
 255                         if (ao_lco_pad != 0)
 256                                 ao_lco_selected[ao_lco_box] = (1 << (ao_lco_pad - 1));
 257                         else
 258                                 ao_lco_armed = 0;
 259                 }
 260         }
 261         ao_wakeup(&ao_lco_armed);
 262 }
 263
 264 void
 265 ao_lco_set_firing(uint8_t firing)
 266 {
 267         ao_lco_firing = firing;
 268         PRINTD("Firing %d\n", ao_lco_firing);
 269         ao_wakeup(&ao_lco_armed);
 270 }
 271
 272 void
 273 ao_lco_search(void)
 274 {
 275         int8_t          r;
 276         int8_t          try;
 277         uint8_t         box;
 278         uint8_t         boxes = 0;
 279
 280         ao_lco_box_reset_present();
 281         ao_lco_set_pad(0);
 282         for (box = 0; box < AO_PAD_MAX_BOXES; box++) {
 283                 if ((box % 10) == 0) {
 284                         ao_lco_box = box;
 285                         ao_lco_show_display();
 286                 }
 287                 for (try = 0; try < 3; try++) {
 288                         ao_lco_tick_offset[box] = 0;
 289                         r = ao_lco_query(box, &ao_pad_query, &ao_lco_tick_offset[box]);
 290                         PRINTD("box %d result %d offset %d\n", box, r, ao_lco_tick_offset[box]);
 291                         if (r == AO_RADIO_CMAC_OK) {
 292                                 ++boxes;
 293                                 ao_lco_box_set_present(box);
 294                                 ao_lco_set_pad(boxes % 10);
 295                                 ao_delay(AO_MS_TO_TICKS(30));
 296                                 break;
 297                         }
 298                 }
 299         }
 300         if (ao_lco_min_box <= ao_lco_max_box)
 301                 ao_lco_box = ao_lco_min_box;
 302         else
 303                 ao_lco_min_box = ao_lco_max_box = ao_lco_box = 0;
 304         memset(ao_lco_valid, 0, sizeof (ao_lco_valid));
 305         memset(ao_lco_channels, 0, sizeof (ao_lco_channels));
 306         ao_lco_set_box(ao_lco_min_box);
 307 }
 308
 309 void
 310 ao_lco_monitor(void)
 311 {
 312         uint16_t                delay;
 313         uint8_t                 box;
 314
 315         for (;;) {
 316                 PRINTD("monitor armed %d firing %d\n",
 317                        ao_lco_armed, ao_lco_firing);
 318
 319                 if (ao_lco_armed && ao_lco_firing) {
 320                         ao_lco_ignite(AO_PAD_FIRE);
 321                 } else {
 322                         ao_lco_update();
 323                         if (ao_lco_armed) {
 324                                 for (box = ao_lco_min_box; box <= ao_lco_max_box; box++) {
 325                                         if (ao_lco_selected[box]) {
 326                                                 PRINTD("Arming box %d pads %x\n",
 327                                                        box, ao_lco_selected[box]);
 328                                                 if (ao_lco_valid[box] & AO_LCO_VALID_EVER) {
 329                                                         ao_lco_arm(box, ao_lco_selected[box], ao_lco_tick_offset[box]);
 330                                                         ao_delay(AO_MS_TO_TICKS(10));
 331                                                 }
 332                                         }
 333                                 }
 334                         }
 335                 }
 336                 if (ao_lco_armed && ao_lco_firing)
 337                         delay = AO_MS_TO_TICKS(100);
 338                 else
 339                         delay = AO_SEC_TO_TICKS(1);
 340                 ao_sleep_for(&ao_lco_armed, delay);
 341         }
 342 }
 343
 344 #if AO_LCO_DRAG
 345
 346 uint8_t                 ao_lco_drag_beep_count;
 347 static uint8_t          ao_lco_drag_beep_on;
 348 static uint16_t         ao_lco_drag_beep_time;
 349 static uint16_t         ao_lco_drag_warn_time;
 350
 351 #define AO_LCO_DRAG_BEEP_TIME   AO_MS_TO_TICKS(50)
 352 #define AO_LCO_DRAG_WARN_TIME   AO_SEC_TO_TICKS(5)
 353
 354 /* Request 'beeps' additional drag race beeps */
 355 void
 356 ao_lco_drag_add_beeps(uint8_t beeps)
 357 {
 358         PRINTD("beep %d\n", beeps);
 359         if (ao_lco_drag_beep_count == 0)
 360                 ao_lco_drag_beep_time = ao_time();
 361         ao_lco_drag_beep_count += beeps;
 362         ao_wakeup(&ao_lco_drag_beep_count);
 363 }
 364
 365 /* Toggle current pad in drag set */
 366 void
 367 ao_lco_toggle_drag(void)
 368 {
 369         if (ao_lco_drag_race && ao_lco_pad != AO_LCO_PAD_VOLTAGE) {
 370                 ao_lco_selected[ao_lco_box] ^= (1 << (ao_lco_pad - 1));
 371                 PRINTD("Toggle box %d pad %d (pads now %x) to drag race\n",
 372                        ao_lco_pad, ao_lco_box, ao_lco_selected[ao_lco_box]);
 373                 ao_lco_drag_add_beeps(ao_lco_pad);
 374         }
 375 }
 376
 377 /* Check whether it's time to change the beeper status, then either
 378  * turn it on or off as necessary and bump the remaining beep counts
 379  */
 380
 381 uint16_t
 382 ao_lco_drag_beep_check(uint16_t now, uint16_t delay)
 383 {
 384         PRINTD("beep check count %d delta %d\n",
 385                ao_lco_drag_beep_count,
 386                (int16_t) (now - ao_lco_drag_beep_time));
 387         if (ao_lco_drag_beep_count) {
 388                 if ((int16_t) (now - ao_lco_drag_beep_time) >= 0) {
 389                         if (ao_lco_drag_beep_on) {
 390                                 ao_beep(0);
 391                                 PRINTD("beep stop\n");
 392                                 ao_lco_drag_beep_on = 0;
 393                                 if (ao_lco_drag_beep_count) {
 394                                         --ao_lco_drag_beep_count;
 395                                         if (ao_lco_drag_beep_count)
 396                                                 ao_lco_drag_beep_time = now + AO_LCO_DRAG_BEEP_TIME;
 397                                 }
 398                         } else {
 399                                 ao_beep(AO_BEEP_HIGH);
 400                                 PRINTD("beep start\n");
 401                                 ao_lco_drag_beep_on = 1;
 402                                 ao_lco_drag_beep_time = now + AO_LCO_DRAG_BEEP_TIME;
 403                         }
 404                 }
 405         }
 406
 407         if (ao_lco_drag_beep_count) {
 408                 uint16_t beep_delay = 0;
 409
 410                 if (ao_lco_drag_beep_time > now)
 411                         beep_delay = ao_lco_drag_beep_time - now;
 412
 413                 if (delay > beep_delay)
 414                         delay = beep_delay;
 415         }
 416         return delay;
 417 }
 418
 419 void
 420 ao_lco_drag_enable(void)
 421 {
 422         if (!ao_lco_drag_race) {
 423                 PRINTD("Drag enable\n");
 424                 ao_lco_drag_race = 1;
 425                 memset(ao_lco_selected, 0, sizeof (ao_lco_selected));
 426 #ifdef AO_LED_DRAG
 427                 ao_led_on(AO_LED_DRAG);
 428 #endif
 429                 ao_lco_drag_add_beeps(5);
 430                 ao_lco_show_display();
 431         }
 432 }
 433
 434 void
 435 ao_lco_drag_disable(void)
 436 {
 437         if (ao_lco_drag_race) {
 438                 PRINTD("Drag disable\n");
 439                 ao_lco_drag_race = 0;
 440 #ifdef AO_LED_DRAG
 441                 ao_led_off(AO_LED_DRAG);
 442 #endif
 443                 memset(ao_lco_selected, 0, sizeof (ao_lco_selected));
 444                 ao_lco_drag_add_beeps(2);
 445                 ao_lco_show_display();
 446         }
 447 }
 448
 449 /* add a beep if it's time to warn the user that drag race mode is
 450  * active
 451  */
 452
 453 uint16_t
 454 ao_lco_drag_warn_check(uint16_t now, uint16_t delay)
 455 {
 456         if (ao_lco_drag_race) {
 457                 uint16_t        warn_delay;
 458
 459                 if ((int16_t) (now - ao_lco_drag_warn_time) >= 0) {
 460                         ao_lco_drag_add_beeps(1);
 461                         ao_lco_drag_warn_time = now + AO_LCO_DRAG_WARN_TIME;
 462                 }
 463                 warn_delay = ao_lco_drag_warn_time - now;
 464                 if (delay > warn_delay)
 465                         delay = warn_delay;
 466         }
 467         return delay;
 468 }
 469 #endif /* AO_LCO_DRAG */
 470
 471 /* task function for beeping while arm is active */
 472 void
 473 ao_lco_arm_warn(void)
 474 {
 475         for (;;) {
 476                 while (!ao_lco_armed) {
 477 #ifdef AO_LED_FIRE
 478                         ao_led_off(AO_LED_FIRE);
 479 #endif
 480                         ao_sleep(&ao_lco_armed);
 481                 }
 482 #ifdef AO_LED_FIRE
 483                 ao_led_on(AO_LED_FIRE);
 484 #endif
 485                 ao_beep_for(AO_BEEP_MID, AO_MS_TO_TICKS(200));
 486                 ao_delay(AO_MS_TO_TICKS(200));
 487         }
 488 }