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