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