git.gag.com Git - fw/altos/blob - src/core/ao_config.c

   1 /*
   2  * Copyright © 2009 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; version 2 of the License.
   7  *
   8  * This program is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along
  14  * with this program; if not, write to the Free Software Foundation, Inc.,
  15  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  16  */
  17
  18 #include "ao.h"
  19 #include "ao_log.h"
  20 #include <ao_config.h>
  21 #if HAS_FLIGHT
  22 #include <ao_sample.h>
  23 #include <ao_data.h>
  24 #endif
  25
  26 __xdata struct ao_config ao_config;
  27 __pdata uint8_t ao_config_loaded;
  28 __pdata uint8_t ao_config_dirty;
  29 __xdata uint8_t ao_config_mutex;
  30
  31 #ifndef AO_CONFIG_DEFAULT_APRS_INTERVAL
  32 #define AO_CONFIG_DEFAULT_APRS_INTERVAL 0
  33 #endif
  34 #define AO_CONFIG_DEFAULT_MAIN_DEPLOY   250
  35 #define AO_CONFIG_DEFAULT_RADIO_CHANNEL 0
  36 #define AO_CONFIG_DEFAULT_CALLSIGN      "N0CALL"
  37 #define AO_CONFIG_DEFAULT_ACCEL_ZERO_G  16000
  38 #define AO_CONFIG_DEFAULT_APOGEE_DELAY  0
  39 #define AO_CONFIG_DEFAULT_IGNITE_MODE   AO_IGNITE_MODE_DUAL
  40 #define AO_CONFIG_DEFAULT_PAD_ORIENTATION       AO_PAD_ORIENTATION_ANTENNA_UP
  41 #if HAS_EEPROM
  42 #ifndef USE_INTERNAL_FLASH
  43 #error Please define USE_INTERNAL_FLASH
  44 #endif
  45 #endif
  46 #ifndef AO_CONFIG_DEFAULT_FLIGHT_LOG_MAX
  47 #if USE_INTERNAL_FLASH
  48 #define AO_CONFIG_DEFAULT_FLIGHT_LOG_MAX        ao_storage_config
  49 #else
  50 #define AO_CONFIG_DEFAULT_FLIGHT_LOG_MAX        ((uint32_t) 192 * (uint32_t) 1024)
  51 #endif
  52 #endif
  53 #ifndef AO_CONFIG_DEFAULT_RADIO_POWER
  54 #define AO_CONFIG_DEFAULT_RADIO_POWER           0x60
  55 #endif
  56 #define AO_CONFIG_DEFAULT_RADIO_AMP             0
  57
  58 #if HAS_EEPROM
  59 static void
  60 _ao_config_put(void)
  61 {
  62         ao_config_setup();
  63         ao_config_write(&ao_config, sizeof (ao_config));
  64 #if HAS_FLIGHT
  65         ao_log_write_erase(0);
  66 #endif
  67         ao_config_flush();
  68 }
  69
  70 void
  71 ao_config_put(void)
  72 {
  73         ao_mutex_get(&ao_config_mutex);
  74         _ao_config_put();
  75         ao_mutex_put(&ao_config_mutex);
  76 }
  77 #endif
  78
  79 #if HAS_RADIO
  80 void
  81 ao_config_set_radio(void)
  82 {
  83         ao_config.radio_setting = ao_freq_to_set(ao_config.frequency, ao_config.radio_cal);
  84 }
  85 #endif /* HAS_RADIO */
  86
  87 static void
  88 _ao_config_get(void)
  89 {
  90         uint8_t minor;
  91
  92         if (ao_config_loaded)
  93                 return;
  94 #if HAS_EEPROM
  95         /* Yes, I know ao_storage_read calls ao_storage_setup,
  96          * but ao_storage_setup *also* sets ao_storage_config, which we
  97          * need before calling ao_storage_read here
  98          */
  99         ao_config_setup();
 100         ao_config_read(&ao_config, sizeof (ao_config));
 101 #endif
 102         if (ao_config.major != AO_CONFIG_MAJOR) {
 103                 ao_config.major = AO_CONFIG_MAJOR;
 104                 ao_config.minor = 0;
 105
 106                 /* Version 0 stuff */
 107                 ao_config.main_deploy = AO_CONFIG_DEFAULT_MAIN_DEPLOY;
 108                 ao_xmemset(&ao_config.callsign, '\0', sizeof (ao_config.callsign));
 109                 ao_xmemcpy(&ao_config.callsign, CODE_TO_XDATA(AO_CONFIG_DEFAULT_CALLSIGN),
 110                        sizeof(AO_CONFIG_DEFAULT_CALLSIGN) - 1);
 111                 ao_config._legacy_radio_channel = 0;
 112         }
 113         minor = ao_config.minor;
 114         if (minor != AO_CONFIG_MINOR) {
 115                 /* Fixups for minor version 1 */
 116                 if (minor < 1)
 117                         ao_config.apogee_delay = AO_CONFIG_DEFAULT_APOGEE_DELAY;
 118                 /* Fixups for minor version 2 */
 119                 if (minor < 2) {
 120                         ao_config.accel_plus_g = 0;
 121                         ao_config.accel_minus_g = 0;
 122                 }
 123                 /* Fixups for minor version 3 */
 124 #if HAS_RADIO
 125                 if (minor < 3)
 126                         ao_config.radio_cal = ao_radio_cal;
 127 #endif
 128                 /* Fixups for minor version 4 */
 129 #if HAS_FLIGHT
 130                 if (minor < 4)
 131                         ao_config.flight_log_max = AO_CONFIG_DEFAULT_FLIGHT_LOG_MAX;
 132 #endif
 133                 /* Fixupes for minor version 5 */
 134                 if (minor < 5)
 135                         ao_config.ignite_mode = AO_CONFIG_DEFAULT_IGNITE_MODE;
 136                 if (minor < 6)
 137                         ao_config.pad_orientation = AO_CONFIG_DEFAULT_PAD_ORIENTATION;
 138                 if (minor < 8)
 139                         ao_config.radio_enable = AO_RADIO_ENABLE_CORE;
 140                 if (minor < 9)
 141                         ao_xmemset(&ao_config.aes_key, '\0', AO_AES_LEN);
 142                 if (minor < 10)
 143                         ao_config.frequency = 434550 + ao_config._legacy_radio_channel * 100;
 144                 if (minor < 11)
 145                         ao_config.apogee_lockout = 0;
 146 #if AO_PYRO_NUM
 147                 if (minor < 12)
 148                         memset(&ao_config.pyro, '\0', sizeof (ao_config.pyro));
 149 #endif
 150                 if (minor < 13)
 151                         ao_config.aprs_interval = AO_CONFIG_DEFAULT_APRS_INTERVAL;
 152 #if HAS_RADIO_POWER
 153                 if (minor < 14)
 154                         ao_config.radio_power = AO_CONFIG_DEFAULT_RADIO_POWER;
 155                 #endif
 156 #if HAS_RADIO_AMP
 157                 if (minor  < 14)
 158                         ao_config.radio_amp = AO_CONFIG_DEFAULT_RADIO_AMP;
 159 #endif
 160 #if HAS_GYRO
 161                 if (minor < 15) {
 162                         ao_config.accel_zero_along = 0;
 163                         ao_config.accel_zero_across = 0;
 164                         ao_config.accel_zero_through = 0;
 165
 166                         /* Reset the main accel offsets to force
 167                          * re-calibration
 168                          */
 169                         ao_config.accel_plus_g = 0;
 170                         ao_config.accel_minus_g = 0;
 171                 }
 172 #endif
 173                 ao_config.minor = AO_CONFIG_MINOR;
 174                 ao_config_dirty = 1;
 175         }
 176 #if HAS_RADIO
 177 #if HAS_FORCE_FREQ
 178         if (ao_force_freq) {
 179                 ao_config.frequency = 434550;
 180                 ao_config.radio_cal = ao_radio_cal;
 181                 ao_xmemcpy(&ao_config.callsign, CODE_TO_XDATA(AO_CONFIG_DEFAULT_CALLSIGN),
 182                        sizeof(AO_CONFIG_DEFAULT_CALLSIGN) - 1);
 183         }
 184 #endif
 185         ao_config_set_radio();
 186 #endif
 187         ao_config_loaded = 1;
 188 }
 189
 190 void
 191 _ao_config_edit_start(void)
 192 {
 193         ao_mutex_get(&ao_config_mutex);
 194         _ao_config_get();
 195 }
 196
 197 void
 198 _ao_config_edit_finish(void)
 199 {
 200         ao_config_dirty = 1;
 201         ao_mutex_put(&ao_config_mutex);
 202 }
 203
 204 void
 205 ao_config_get(void)
 206 {
 207         _ao_config_edit_start();
 208         ao_mutex_put(&ao_config_mutex);
 209 }
 210
 211 void
 212 ao_config_callsign_show(void)
 213 {
 214         printf ("Callsign: \"%s\"\n", ao_config.callsign);
 215 }
 216
 217 void
 218 ao_config_callsign_set(void) __reentrant
 219 {
 220         uint8_t c;
 221         static __xdata char callsign[AO_MAX_CALLSIGN + 1];
 222
 223         ao_xmemset(callsign, '\0', sizeof callsign);
 224         ao_cmd_white();
 225         c = 0;
 226         while (ao_cmd_lex_c != '\n') {
 227                 if (c < AO_MAX_CALLSIGN)
 228                         callsign[c++] = ao_cmd_lex_c;
 229                 else
 230                         ao_cmd_status = ao_cmd_lex_error;
 231                 ao_cmd_lex();
 232         }
 233         if (ao_cmd_status != ao_cmd_success)
 234                 return;
 235         _ao_config_edit_start();
 236         ao_xmemcpy(&ao_config.callsign, &callsign,
 237                AO_MAX_CALLSIGN + 1);
 238         _ao_config_edit_finish();
 239 }
 240
 241 #if HAS_RADIO
 242
 243 void
 244 ao_config_frequency_show(void) __reentrant
 245 {
 246         printf("Frequency: %ld\n",
 247                ao_config.frequency);
 248 }
 249
 250 void
 251 ao_config_frequency_set(void) __reentrant
 252 {
 253         ao_cmd_decimal();
 254         if (ao_cmd_status != ao_cmd_success)
 255                 return;
 256         _ao_config_edit_start();
 257         ao_config.frequency = ao_cmd_lex_u32;
 258         ao_config_set_radio();
 259         _ao_config_edit_finish();
 260 #if HAS_RADIO_RECV
 261         ao_radio_recv_abort();
 262 #endif
 263 }
 264 #endif
 265
 266 #if HAS_FLIGHT
 267
 268 void
 269 ao_config_main_deploy_show(void) __reentrant
 270 {
 271         printf("Main deploy: %d meters\n",
 272                ao_config.main_deploy);
 273 }
 274
 275 void
 276 ao_config_main_deploy_set(void) __reentrant
 277 {
 278         ao_cmd_decimal();
 279         if (ao_cmd_status != ao_cmd_success)
 280                 return;
 281         _ao_config_edit_start();
 282         ao_config.main_deploy = ao_cmd_lex_i;
 283         _ao_config_edit_finish();
 284 }
 285
 286 #if HAS_ACCEL
 287 void
 288 ao_config_accel_calibrate_show(void) __reentrant
 289 {
 290         printf("Accel cal +1g: %d -1g: %d\n",
 291                ao_config.accel_plus_g, ao_config.accel_minus_g);
 292 #if HAS_GYRO
 293         printf ("IMU cal along %d across %d through %d\n",
 294                 ao_config.accel_zero_along,
 295                 ao_config.accel_zero_across,
 296                 ao_config.accel_zero_through);
 297 #endif
 298 }
 299
 300 #define ACCEL_CALIBRATE_SAMPLES 1024
 301 #define ACCEL_CALIBRATE_SHIFT   10
 302
 303 #if HAS_GYRO
 304 static int16_t accel_cal_along;
 305 static int16_t accel_cal_across;
 306 static int16_t accel_cal_through;
 307 #endif
 308
 309 static int16_t
 310 ao_config_accel_calibrate_auto(char *orientation) __reentrant
 311 {
 312         uint16_t        i;
 313         int32_t         accel_total;
 314         uint8_t         cal_data_ring;
 315 #if HAS_GYRO
 316         int32_t         accel_along_total = 0;
 317         int32_t         accel_across_total = 0;
 318         int32_t         accel_through_total = 0;
 319 #endif
 320
 321         printf("Orient antenna %s and press a key...", orientation);
 322         flush();
 323         (void) getchar();
 324         puts("\r\n"); flush();
 325         puts("Calibrating..."); flush();
 326         i = ACCEL_CALIBRATE_SAMPLES;
 327         accel_total = 0;
 328         cal_data_ring = ao_sample_data;
 329         while (i) {
 330                 ao_sleep(DATA_TO_XDATA(&ao_sample_data));
 331                 while (i && cal_data_ring != ao_sample_data) {
 332                         accel_total += (int32_t) ao_data_accel(&ao_data_ring[cal_data_ring]);
 333 #if HAS_GYRO
 334                         accel_along_total += (int32_t) ao_data_along(&ao_data_ring[cal_data_ring]);
 335                         accel_across_total += (int32_t) ao_data_across(&ao_data_ring[cal_data_ring]);
 336                         accel_through_total += (int32_t) ao_data_through(&ao_data_ring[cal_data_ring]);
 337 #endif
 338                         cal_data_ring = ao_data_ring_next(cal_data_ring);
 339                         i--;
 340                 }
 341         }
 342 #if HAS_GYRO
 343         accel_cal_along = accel_along_total >> ACCEL_CALIBRATE_SHIFT;
 344         accel_cal_across = accel_across_total >> ACCEL_CALIBRATE_SHIFT;
 345         accel_cal_through = accel_through_total >> ACCEL_CALIBRATE_SHIFT;
 346 #endif
 347         return accel_total >> ACCEL_CALIBRATE_SHIFT;
 348 }
 349
 350 void
 351 ao_config_accel_calibrate_set(void) __reentrant
 352 {
 353         int16_t up, down;
 354 #if HAS_GYRO
 355         int16_t accel_along_up, accel_along_down;
 356         int16_t accel_across_up, accel_across_down;
 357         int16_t accel_through_up, accel_through_down;
 358 #endif
 359
 360         ao_cmd_decimal();
 361         if (ao_cmd_status != ao_cmd_success)
 362                 return;
 363         if (ao_cmd_lex_i == 0) {
 364                 up = ao_config_accel_calibrate_auto("up");
 365 #if HAS_GYRO
 366                 accel_along_up = accel_cal_along;
 367                 accel_across_up = accel_cal_across;
 368                 accel_through_up = accel_cal_through;
 369 #endif
 370                 down = ao_config_accel_calibrate_auto("down");
 371 #if HAS_GYRO
 372                 accel_along_down = accel_cal_along;
 373                 accel_across_down = accel_cal_across;
 374                 accel_through_down = accel_cal_through;
 375 #endif
 376         } else {
 377                 up = ao_cmd_lex_i;
 378                 ao_cmd_decimal();
 379                 if (ao_cmd_status != ao_cmd_success)
 380                         return;
 381                 down = ao_cmd_lex_i;
 382         }
 383         if (up >= down) {
 384                 printf("Invalid accel: up (%d) down (%d)\n",
 385                        up, down);
 386                 return;
 387         }
 388         _ao_config_edit_start();
 389         ao_config.accel_plus_g = up;
 390         ao_config.accel_minus_g = down;
 391 #if HAS_GYRO
 392         ao_config.accel_zero_along = (accel_along_up + accel_along_down) / 2;
 393         ao_config.accel_zero_across = (accel_across_up + accel_across_down) / 2;
 394         ao_config.accel_zero_through = (accel_through_up + accel_through_down) / 2;
 395 #endif
 396         _ao_config_edit_finish();
 397 }
 398 #endif /* HAS_ACCEL */
 399
 400 void
 401 ao_config_apogee_delay_show(void) __reentrant
 402 {
 403         printf("Apogee delay: %d seconds\n",
 404                ao_config.apogee_delay);
 405 }
 406
 407 void
 408 ao_config_apogee_delay_set(void) __reentrant
 409 {
 410         ao_cmd_decimal();
 411         if (ao_cmd_status != ao_cmd_success)
 412                 return;
 413         _ao_config_edit_start();
 414         ao_config.apogee_delay = ao_cmd_lex_i;
 415         _ao_config_edit_finish();
 416 }
 417
 418 void
 419 ao_config_apogee_lockout_show(void) __reentrant
 420 {
 421         printf ("Apogee lockout: %d seconds\n",
 422                 ao_config.apogee_lockout);
 423 }
 424
 425 void
 426 ao_config_apogee_lockout_set(void) __reentrant
 427 {
 428         ao_cmd_decimal();
 429         if (ao_cmd_status != ao_cmd_success)
 430                 return;
 431         _ao_config_edit_start();
 432         ao_config.apogee_lockout = ao_cmd_lex_i;
 433         _ao_config_edit_finish();
 434 }
 435
 436 #endif /* HAS_FLIGHT */
 437
 438 #if HAS_RADIO
 439 void
 440 ao_config_radio_cal_show(void) __reentrant
 441 {
 442         printf("Radio cal: %ld\n", ao_config.radio_cal);
 443 }
 444
 445 void
 446 ao_config_radio_cal_set(void) __reentrant
 447 {
 448         ao_cmd_decimal();
 449         if (ao_cmd_status != ao_cmd_success)
 450                 return;
 451         _ao_config_edit_start();
 452         ao_config.radio_cal = ao_cmd_lex_u32;
 453         ao_config_set_radio();
 454         _ao_config_edit_finish();
 455 }
 456 #endif
 457
 458 #if HAS_LOG
 459 void
 460 ao_config_log_show(void) __reentrant
 461 {
 462         printf("Max flight log: %d kB\n", (int16_t) (ao_config.flight_log_max >> 10));
 463 }
 464
 465 void
 466 ao_config_log_set(void) __reentrant
 467 {
 468         uint16_t        block = (uint16_t) (ao_storage_block >> 10);
 469         uint16_t        config = (uint16_t) (ao_storage_config >> 10);
 470
 471         ao_cmd_decimal();
 472         if (ao_cmd_status != ao_cmd_success)
 473                 return;
 474         if (ao_log_present())
 475                 printf("Storage must be empty before changing log size\n");
 476         else if (block > 1024 && (ao_cmd_lex_i & (block - 1)))
 477                 printf("Flight log size must be multiple of %d kB\n", block);
 478         else if (ao_cmd_lex_i > config)
 479                 printf("Flight log max %d kB\n", config);
 480         else {
 481                 _ao_config_edit_start();
 482                 ao_config.flight_log_max = (uint32_t) ao_cmd_lex_i << 10;
 483                 _ao_config_edit_finish();
 484         }
 485 }
 486 #endif /* HAS_LOG */
 487
 488 #if HAS_IGNITE
 489 void
 490 ao_config_ignite_mode_show(void) __reentrant
 491 {
 492         printf("Ignite mode: %d\n", ao_config.ignite_mode);
 493 }
 494
 495 void
 496 ao_config_ignite_mode_set(void) __reentrant
 497 {
 498         ao_cmd_decimal();
 499         if (ao_cmd_status != ao_cmd_success)
 500                 return;
 501         _ao_config_edit_start();
 502         ao_config.ignite_mode = ao_cmd_lex_i;
 503         _ao_config_edit_finish();
 504 }
 505 #endif
 506
 507 #if HAS_ACCEL
 508 void
 509 ao_config_pad_orientation_show(void) __reentrant
 510 {
 511         printf("Pad orientation: %d\n", ao_config.pad_orientation);
 512 }
 513
 514 void
 515 ao_config_pad_orientation_set(void) __reentrant
 516 {
 517         ao_cmd_decimal();
 518         if (ao_cmd_status != ao_cmd_success)
 519                 return;
 520         _ao_config_edit_start();
 521         ao_cmd_lex_i &= 1;
 522         if (ao_config.pad_orientation != ao_cmd_lex_i) {
 523                 uint16_t t;
 524                 t = ao_config.accel_plus_g;
 525                 ao_config.accel_plus_g = 0x7fff - ao_config.accel_minus_g;
 526                 ao_config.accel_minus_g = 0x7fff - t;
 527         }
 528         ao_config.pad_orientation = ao_cmd_lex_i;
 529         _ao_config_edit_finish();
 530 }
 531 #endif
 532
 533 #if HAS_RADIO
 534 void
 535 ao_config_radio_enable_show(void) __reentrant
 536 {
 537         printf("Radio enable: %d\n", ao_config.radio_enable);
 538 }
 539
 540 void
 541 ao_config_radio_enable_set(void) __reentrant
 542 {
 543         ao_cmd_decimal();
 544         if (ao_cmd_status != ao_cmd_success)
 545                 return;
 546         _ao_config_edit_start();
 547         ao_config.radio_enable = ao_cmd_lex_i;
 548         _ao_config_edit_finish();
 549 }
 550 #endif /* HAS_RADIO */
 551
 552 #if HAS_AES
 553
 554 __xdata uint8_t ao_config_aes_seq = 1;
 555
 556 void
 557 ao_config_key_show(void) __reentrant
 558 {
 559         uint8_t i;
 560         printf("AES key: ");
 561         for (i = 0; i < AO_AES_LEN; i++)
 562                 printf ("%02x", ao_config.aes_key[i]);
 563         printf("\n");
 564 }
 565
 566 void
 567 ao_config_key_set(void) __reentrant
 568 {
 569         uint8_t i;
 570
 571         _ao_config_edit_start();
 572         for (i = 0; i < AO_AES_LEN; i++) {
 573                 ao_cmd_hexbyte();
 574                 if (ao_cmd_status != ao_cmd_success)
 575                         break;
 576                 ao_config.aes_key[i] = ao_cmd_lex_i;
 577         }
 578         ++ao_config_aes_seq;
 579         _ao_config_edit_finish();
 580 }
 581 #endif
 582
 583 #if HAS_APRS
 584
 585 void
 586 ao_config_aprs_show(void)
 587 {
 588         printf ("APRS interval: %d\n", ao_config.aprs_interval);
 589 }
 590
 591 void
 592 ao_config_aprs_set(void)
 593 {
 594         ao_cmd_decimal();
 595         if (ao_cmd_status != ao_cmd_success)
 596                 return;
 597         _ao_config_edit_start();
 598         ao_config.aprs_interval = ao_cmd_lex_i;
 599         _ao_config_edit_finish();
 600 }
 601
 602 #endif /* HAS_APRS */
 603
 604 #if HAS_RADIO_AMP
 605
 606 void
 607 ao_config_radio_amp_show(void)
 608 {
 609         printf ("Radio amp setting: %d\n", ao_config.radio_amp);
 610 }
 611
 612 void
 613 ao_config_radio_amp_set(void)
 614 {
 615         ao_cmd_decimal();
 616         if (ao_cmd_status != ao_cmd_success)
 617                 return;
 618         _ao_config_edit_start();
 619         ao_config.radio_amp = ao_cmd_lex_i;
 620         _ao_config_edit_finish();
 621 }
 622
 623 #endif
 624
 625 #if HAS_RADIO_POWER
 626
 627 void
 628 ao_config_radio_power_show(void)
 629 {
 630         printf ("Radio power setting: %d\n", ao_config.radio_power);
 631 }
 632
 633 void
 634 ao_config_radio_power_set(void)
 635 {
 636         ao_cmd_decimal();
 637         if (ao_cmd_status != ao_cmd_success)
 638                 return;
 639         _ao_config_edit_start();
 640         ao_config.radio_power = ao_cmd_lex_i;
 641         _ao_config_edit_finish();
 642 }
 643
 644 #endif
 645
 646 struct ao_config_var {
 647         __code char     *str;
 648         void            (*set)(void) __reentrant;
 649         void            (*show)(void) __reentrant;
 650 };
 651
 652 static void
 653 ao_config_help(void) __reentrant;
 654
 655 static void
 656 ao_config_show(void) __reentrant;
 657
 658 static void
 659 ao_config_save(void) __reentrant;
 660
 661 __code struct ao_config_var ao_config_vars[] = {
 662 #if HAS_FLIGHT
 663         { "m <meters>\0Main deploy (m)",
 664           ao_config_main_deploy_set,    ao_config_main_deploy_show, },
 665         { "d <delay>\0Apogee delay (s)",
 666           ao_config_apogee_delay_set,   ao_config_apogee_delay_show },
 667         { "L <seconds>\0Apogee detect lockout (s)",
 668           ao_config_apogee_lockout_set, ao_config_apogee_lockout_show, },
 669 #endif /* HAS_FLIGHT */
 670 #if HAS_RADIO
 671         { "F <freq>\0Frequency (kHz)",
 672           ao_config_frequency_set, ao_config_frequency_show },
 673         { "c <call>\0Callsign (8 char max)",
 674           ao_config_callsign_set,       ao_config_callsign_show },
 675         { "e <0 disable, 1 enable>\0Enable telemetry and RDF",
 676           ao_config_radio_enable_set, ao_config_radio_enable_show },
 677         { "f <cal>\0Radio calib (cal = rf/(xtal/2^16))",
 678           ao_config_radio_cal_set,      ao_config_radio_cal_show },
 679 #if HAS_RADIO_POWER
 680         { "p <setting>\0Radio power setting (0-255)",
 681           ao_config_radio_power_set,    ao_config_radio_power_show },
 682 #endif
 683 #if HAS_RADIO_AMP
 684         { "d <setting>\0Radio amplifier setting (0-3)",
 685           ao_config_radio_amp_set,      ao_config_radio_amp_show },
 686 #endif
 687 #endif /* HAS_RADIO */
 688 #if HAS_ACCEL
 689         { "a <+g> <-g>\0Accel calib (0 for auto)",
 690           ao_config_accel_calibrate_set,ao_config_accel_calibrate_show },
 691         { "o <0 antenna up, 1 antenna down>\0Set pad orientation",
 692           ao_config_pad_orientation_set,ao_config_pad_orientation_show },
 693 #endif /* HAS_ACCEL */
 694 #if HAS_LOG
 695         { "l <size>\0Flight log size (kB)",
 696           ao_config_log_set,            ao_config_log_show },
 697 #endif
 698 #if HAS_IGNITE
 699         { "i <0 dual, 1 apogee, 2 main>\0Set igniter mode",
 700           ao_config_ignite_mode_set,    ao_config_ignite_mode_show },
 701 #endif
 702 #if HAS_AES
 703         { "k <32 hex digits>\0Set AES encryption key",
 704           ao_config_key_set, ao_config_key_show },
 705 #endif
 706 #if AO_PYRO_NUM
 707         { "P <n,?>\0Configure pyro channels",
 708           ao_pyro_set, ao_pyro_show },
 709 #endif
 710 #if HAS_APRS
 711         { "A <secs>\0APRS packet interval (0 disable)",
 712           ao_config_aprs_set, ao_config_aprs_show },
 713 #endif
 714         { "s\0Show",
 715           ao_config_show,               0 },
 716 #if HAS_EEPROM
 717         { "w\0Write to eeprom",
 718           ao_config_save,               0 },
 719 #endif
 720         { "?\0Help",
 721           ao_config_help,               0 },
 722         { 0, 0, 0 }
 723 };
 724
 725 void
 726 ao_config_set(void)
 727 {
 728         char    c;
 729         uint8_t cmd;
 730
 731         ao_cmd_white();
 732         c = ao_cmd_lex_c;
 733         ao_cmd_lex();
 734         for (cmd = 0; ao_config_vars[cmd].str != NULL; cmd++)
 735                 if (ao_config_vars[cmd].str[0] == c) {
 736                         (*ao_config_vars[cmd].set)();
 737                         return;
 738                 }
 739         ao_cmd_status = ao_cmd_syntax_error;
 740 }
 741
 742 static void
 743 ao_config_help(void) __reentrant
 744 {
 745         uint8_t cmd;
 746         for (cmd = 0; ao_config_vars[cmd].str != NULL; cmd++)
 747                 printf("%-20s %s\n",
 748                        ao_config_vars[cmd].str,
 749                        ao_config_vars[cmd].str+1+
 750                        strlen(ao_config_vars[cmd].str));
 751 }
 752
 753 static void
 754 ao_config_show(void) __reentrant
 755 {
 756         uint8_t cmd;
 757         ao_config_get();
 758         printf("Config version: %d.%d\n",
 759                ao_config.major, ao_config.minor);
 760         for (cmd = 0; ao_config_vars[cmd].str != NULL; cmd++)
 761                 if (ao_config_vars[cmd].show)
 762                         (*ao_config_vars[cmd].show)();
 763 #if HAS_MS5607
 764         ao_ms5607_info();
 765 #endif
 766 }
 767
 768 #if HAS_EEPROM
 769 static void
 770 ao_config_save(void) __reentrant
 771 {
 772         uint8_t saved = 0;
 773         ao_mutex_get(&ao_config_mutex);
 774         if (ao_config_dirty) {
 775                 _ao_config_put();
 776                 ao_config_dirty = 0;
 777                 saved = 1;
 778         }
 779         ao_mutex_put(&ao_config_mutex);
 780         if (saved)
 781                 puts("Saved");
 782         else
 783                 puts("Nothing to save");
 784 }
 785 #endif
 786
 787 __code struct ao_cmds ao_config_cmds[] = {
 788         { ao_config_set,        "c <var> <value>\0Set config (? for help, s to show)" },
 789         { 0, NULL },
 790 };
 791
 792 void
 793 ao_config_init(void)
 794 {
 795         ao_cmd_register(&ao_config_cmds[0]);
 796 }