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