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_pad = ao_lco_pad_first(ao_lco_box);
 174                         ao_lco_set_display();
 175                 }
 176                 if (ao_lco_pad == AO_LCO_PAD_VOLTAGE)
 177                         ao_lco_set_display();
 178         }
 179 }
 180
 181 uint8_t ao_lco_box_mask[AO_LCO_MASK_SIZE(AO_PAD_MAX_BOXES)];
 182
 183 static void
 184 ao_lco_box_reset_present(void)
 185 {
 186         ao_lco_min_box = 0xff;
 187         ao_lco_max_box = 0x00;
 188         memset(ao_lco_box_mask, 0, sizeof (ao_lco_box_mask));
 189 }
 190
 191 static void
 192 ao_lco_box_set_present(uint8_t box)
 193 {
 194         if (box < ao_lco_min_box)
 195                 ao_lco_min_box = box;
 196         if (box > ao_lco_max_box)
 197                 ao_lco_max_box = box;
 198         if (box >= AO_PAD_MAX_BOXES)
 199                 return;
 200         ao_lco_box_mask[AO_LCO_MASK_ID(box)] |= 1 << AO_LCO_MASK_SHIFT(box);
 201 }
 202
 203 void
 204 ao_lco_step_pad(int8_t dir)
 205 {
 206         int8_t  new_pad;
 207
 208         new_pad = ao_lco_pad;
 209         do {
 210                 new_pad += dir;
 211                 if (new_pad > AO_PAD_MAX_CHANNELS)
 212                         new_pad = AO_LCO_PAD_VOLTAGE;
 213                 if (new_pad < 0)
 214                         new_pad = AO_PAD_MAX_CHANNELS;
 215                 if (new_pad == ao_lco_pad)
 216                         break;
 217         } while (!ao_lco_pad_present(ao_lco_box, new_pad));
 218         if (new_pad != ao_lco_pad) {
 219                 ao_lco_pad = new_pad;
 220                 ao_lco_set_display();
 221         }
 222 }
 223
 224 void
 225 ao_lco_set_armed(uint8_t armed)
 226 {
 227         ao_lco_armed = armed;
 228         PRINTD("Armed %d\n", ao_lco_armed);
 229         if (ao_lco_armed) {
 230                 if (ao_lco_drag_race) {
 231                         uint8_t box;
 232
 233                         for (box = ao_lco_min_box; box <= ao_lco_max_box; box++)
 234                                 if (ao_lco_selected[box])
 235                                         break;
 236                         if (box > ao_lco_max_box)
 237                                 ao_lco_armed = 0;
 238                 } else {
 239                         memset(ao_lco_selected, 0, sizeof (ao_lco_selected));
 240                         if (ao_lco_pad != 0)
 241                                 ao_lco_selected[ao_lco_box] = (1 << (ao_lco_pad - 1));
 242                         else
 243                                 ao_lco_armed = 0;
 244                 }
 245         }
 246         ao_wakeup(&ao_lco_armed);
 247 }
 248
 249 void
 250 ao_lco_set_firing(uint8_t firing)
 251 {
 252         ao_lco_firing = firing;
 253         PRINTD("Firing %d\n", ao_lco_firing);
 254         ao_wakeup(&ao_lco_armed);
 255 }
 256
 257 void
 258 ao_lco_toggle_drag(void)
 259 {
 260         if (ao_lco_drag_race && ao_lco_pad != AO_LCO_PAD_VOLTAGE) {
 261                 ao_lco_selected[ao_lco_box] ^= (1 << (ao_lco_pad - 1));
 262                 PRINTD("Toggle box %d pad %d (pads now %x) to drag race\n",
 263                        ao_lco_pad, ao_lco_box, ao_lco_selected[ao_lco_box]);
 264                 ao_lco_drag_add_beeps(ao_lco_pad);
 265         }
 266 }
 267
 268 void
 269 ao_lco_search(void)
 270 {
 271         int8_t          r;
 272         int8_t          try;
 273         uint8_t         box;
 274         uint8_t         boxes = 0;
 275
 276         ao_lco_box_reset_present();
 277         ao_lco_set_pad(0);
 278         for (box = 0; box < AO_PAD_MAX_BOXES; box++) {
 279                 if ((box % 10) == 0)
 280                         ao_lco_set_box(box);
 281                 for (try = 0; try < 3; try++) {
 282                         ao_lco_tick_offset[box] = 0;
 283                         r = ao_lco_query(box, &ao_pad_query, &ao_lco_tick_offset[box]);
 284                         PRINTD("box %d result %d offset %d\n", box, r, ao_lco_tick_offset[box]);
 285                         if (r == AO_RADIO_CMAC_OK) {
 286                                 ++boxes;
 287                                 ao_lco_box_set_present(box);
 288                                 ao_lco_set_pad(boxes % 10);
 289                                 ao_delay(AO_MS_TO_TICKS(30));
 290                                 break;
 291                         }
 292                 }
 293         }
 294         if (ao_lco_min_box <= ao_lco_max_box)
 295                 ao_lco_box = ao_lco_min_box;
 296         else
 297                 ao_lco_min_box = ao_lco_max_box = ao_lco_box = 0;
 298         memset(ao_lco_valid, 0, sizeof (ao_lco_valid));
 299         memset(ao_lco_channels, 0, sizeof (ao_lco_channels));
 300         ao_lco_pad = 1;
 301         ao_lco_set_display();
 302 }
 303
 304 void
 305 ao_lco_monitor(void)
 306 {
 307         uint16_t                delay;
 308         uint8_t                 box;
 309
 310         for (;;) {
 311                 PRINTD("monitor armed %d firing %d\n",
 312                        ao_lco_armed, ao_lco_firing);
 313
 314                 if (ao_lco_armed && ao_lco_firing) {
 315                         ao_lco_ignite(AO_PAD_FIRE);
 316                 } else {
 317                         ao_lco_update();
 318                         if (ao_lco_armed) {
 319                                 for (box = ao_lco_min_box; box <= ao_lco_max_box; box++) {
 320                                         if (ao_lco_selected[box]) {
 321                                                 PRINTD("Arming box %d pads %x\n",
 322                                                        box, ao_lco_selected[box]);
 323                                                 if (ao_lco_valid[box] & AO_LCO_VALID_EVER) {
 324                                                         ao_lco_arm(box, ao_lco_selected[box], ao_lco_tick_offset[box]);
 325                                                         ao_delay(AO_MS_TO_TICKS(10));
 326                                                 }
 327                                         }
 328                                 }
 329                         }
 330                 }
 331                 if (ao_lco_armed && ao_lco_firing)
 332                         delay = AO_MS_TO_TICKS(100);
 333                 else
 334                         delay = AO_SEC_TO_TICKS(1);
 335                 ao_sleep_for(&ao_lco_armed, delay);
 336         }
 337 }
 338
 339 uint8_t                 ao_lco_drag_beep_count;
 340 static uint8_t          ao_lco_drag_beep_on;
 341 static uint16_t         ao_lco_drag_beep_time;
 342 static uint16_t         ao_lco_drag_warn_time;
 343
 344 #define AO_LCO_DRAG_BEEP_TIME   AO_MS_TO_TICKS(50)
 345 #define AO_LCO_DRAG_WARN_TIME   AO_SEC_TO_TICKS(5)
 346
 347 /* Request 'beeps' additional drag race beeps */
 348 void
 349 ao_lco_drag_add_beeps(uint8_t beeps)
 350 {
 351         PRINTD("beep %d\n", beeps);
 352         if (ao_lco_drag_beep_count == 0)
 353                 ao_lco_drag_beep_time = ao_time();
 354         ao_lco_drag_beep_count += beeps;
 355         ao_wakeup(&ao_lco_drag_beep_count);
 356 }
 357
 358 /* Check whether it's time to change the beeper status, then either
 359  * turn it on or off as necessary and bump the remaining beep counts
 360  */
 361
 362 uint16_t
 363 ao_lco_drag_beep_check(uint16_t now, uint16_t delay)
 364 {
 365         PRINTD("beep check count %d delta %d\n",
 366                ao_lco_drag_beep_count,
 367                (int16_t) (now - ao_lco_drag_beep_time));
 368         if (ao_lco_drag_beep_count) {
 369                 if ((int16_t) (now - ao_lco_drag_beep_time) >= 0) {
 370                         if (ao_lco_drag_beep_on) {
 371                                 ao_beep(0);
 372                                 PRINTD("beep stop\n");
 373                                 ao_lco_drag_beep_on = 0;
 374                                 if (ao_lco_drag_beep_count) {
 375                                         --ao_lco_drag_beep_count;
 376                                         if (ao_lco_drag_beep_count)
 377                                                 ao_lco_drag_beep_time = now + AO_LCO_DRAG_BEEP_TIME;
 378                                 }
 379                         } else {
 380                                 ao_beep(AO_BEEP_HIGH);
 381                                 PRINTD("beep start\n");
 382                                 ao_lco_drag_beep_on = 1;
 383                                 ao_lco_drag_beep_time = now + AO_LCO_DRAG_BEEP_TIME;
 384                         }
 385                 }
 386         }
 387
 388         if (ao_lco_drag_beep_count) {
 389                 uint16_t beep_delay = 0;
 390
 391                 if (ao_lco_drag_beep_time > now)
 392                         beep_delay = ao_lco_drag_beep_time - now;
 393
 394                 if (delay > beep_delay)
 395                         delay = beep_delay;
 396         }
 397         return delay;
 398 }
 399
 400 void
 401 ao_lco_drag_enable(void)
 402 {
 403         if (!ao_lco_drag_race) {
 404                 PRINTD("Drag enable\n");
 405                 ao_lco_drag_race = 1;
 406                 memset(ao_lco_selected, 0, sizeof (ao_lco_selected));
 407 #ifdef AO_LED_DRAG
 408                 ao_led_on(AO_LED_DRAG);
 409 #endif
 410                 ao_lco_drag_add_beeps(5);
 411                 ao_lco_set_display();
 412         }
 413 }
 414
 415 void
 416 ao_lco_drag_disable(void)
 417 {
 418         if (ao_lco_drag_race) {
 419                 PRINTD("Drag disable\n");
 420                 ao_lco_drag_race = 0;
 421 #ifdef AO_LED_DRAG
 422                 ao_led_off(AO_LED_DRAG);
 423 #endif
 424                 memset(ao_lco_selected, 0, sizeof (ao_lco_selected));
 425                 ao_lco_drag_add_beeps(2);
 426                 ao_lco_set_display();
 427         }
 428 }
 429
 430 /* add a beep if it's time to warn the user that drag race mode is
 431  * active
 432  */
 433
 434 uint16_t
 435 ao_lco_drag_warn_check(uint16_t now, uint16_t delay)
 436 {
 437         if (ao_lco_drag_race) {
 438                 uint16_t        warn_delay;
 439
 440                 if ((int16_t) (now - ao_lco_drag_warn_time) >= 0) {
 441                         ao_lco_drag_add_beeps(1);
 442                         ao_lco_drag_warn_time = now + AO_LCO_DRAG_WARN_TIME;
 443                 }
 444                 warn_delay = ao_lco_drag_warn_time - now;
 445                 if (delay > warn_delay)
 446                         delay = warn_delay;
 447         }
 448         return delay;
 449 }
 450
 451 /* task function for beeping while arm is active */
 452 void
 453 ao_lco_arm_warn(void)
 454 {
 455         for (;;) {
 456                 while (!ao_lco_armed) {
 457 #ifdef AO_LED_FIRE
 458                         ao_led_off(AO_LED_FIRE);
 459 #endif
 460                         ao_sleep(&ao_lco_armed);
 461                 }
 462 #ifdef AO_LED_FIRE
 463                 ao_led_on(AO_LED_FIRE);
 464 #endif
 465                 ao_beep_for(AO_BEEP_MID, AO_MS_TO_TICKS(200));
 466                 ao_delay(AO_MS_TO_TICKS(200));
 467         }
 468 }