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; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  17  */
  18
  19 #include "ao.h"
  20 #include "ao_log.h"
  21 #include <ao_config.h>
  22 #if HAS_FLIGHT
  23 #include <ao_sample.h>
  24 #include <ao_data.h>
  25 #endif
  26 #if HAS_BEEP
  27 #include <ao_beep.h>
  28 #endif
  29 #if HAS_TRACKER
  30 #include <ao_tracker.h>
  31 #endif
  32
  33 struct ao_config ao_config;
  34 uint8_t ao_config_loaded;
  35 uint8_t ao_config_dirty;
  36 uint8_t ao_config_mutex;
  37
  38 #if HAS_FORCE_FREQ
  39 uint8_t ao_force_freq;
  40 #endif
  41
  42 #ifndef HAS_CONFIG_SAVE
  43 #define HAS_CONFIG_SAVE HAS_EEPROM
  44 #endif
  45
  46 #ifndef AO_CONFIG_DEFAULT_APRS_INTERVAL
  47 #define AO_CONFIG_DEFAULT_APRS_INTERVAL 0
  48 #endif
  49 #define AO_CONFIG_DEFAULT_MAIN_DEPLOY   250
  50 #define AO_CONFIG_DEFAULT_RADIO_CHANNEL 0
  51 #define AO_CONFIG_DEFAULT_CALLSIGN      "N0CALL"
  52 #define AO_CONFIG_DEFAULT_ACCEL_ZERO_G  16000
  53 #define AO_CONFIG_DEFAULT_APOGEE_DELAY  0
  54 #define AO_CONFIG_DEFAULT_IGNITE_MODE   AO_IGNITE_MODE_DUAL
  55 #define AO_CONFIG_DEFAULT_PAD_ORIENTATION       AO_PAD_ORIENTATION_ANTENNA_UP
  56 #define AO_CONFIG_DEFAULT_PYRO_TIME     AO_MS_TO_TICKS(50)
  57 #if HAS_CONFIG_SAVE
  58 #ifndef USE_INTERNAL_FLASH
  59 #error Please define USE_INTERNAL_FLASH
  60 #endif
  61 #endif
  62
  63 #ifndef AO_CONFIG_DEFAULT_FLIGHT_LOG_MAX
  64 # if FLIGHT_LOG_APPEND
  65 #  define AO_CONFIG_DEFAULT_FLIGHT_LOG_MAX      ao_storage_log_max
  66 # else
  67 #  if USE_INTERNAL_FLASH
  68 #   define AO_CONFIG_DEFAULT_FLIGHT_LOG_MAX     ao_storage_config
  69 #  else
  70 #   define AO_CONFIG_DEFAULT_FLIGHT_LOG_MAX     ((uint32_t) 192 * (uint32_t) 1024)
  71 #  endif
  72 # endif
  73 #endif
  74
  75 #ifndef AO_CONFIG_DEFAULT_RADIO_POWER
  76 #define AO_CONFIG_DEFAULT_RADIO_POWER           0x60
  77 #endif
  78 #define AO_CONFIG_DEFAULT_RADIO_AMP             0
  79 #define AO_CONFIG_DEFAULT_APRS_SSID             (ao_serial_number % 10)
  80 #define AO_CONFIG_DEFAULT_RADIO_RATE            AO_RADIO_RATE_38400
  81
  82 #if HAS_CONFIG_SAVE
  83 static void
  84 _ao_config_put(void)
  85 {
  86         ao_config_setup();
  87         ao_config_erase();
  88         ao_config_write(0, &ao_config, sizeof (ao_config));
  89 #if HAS_FLIGHT && HAS_LOG
  90         ao_log_write_erase(0);
  91 #endif
  92         ao_config_flush();
  93 }
  94
  95 void
  96 ao_config_put(void)
  97 {
  98         ao_mutex_get(&ao_config_mutex);
  99         _ao_config_put();
 100         ao_mutex_put(&ao_config_mutex);
 101 }
 102 #endif
 103
 104 #if HAS_RADIO
 105
 106 #if HAS_RADIO_FORWARD
 107 uint32_t        ao_send_radio_setting;
 108 #endif
 109
 110 void
 111 ao_config_set_radio(void)
 112 {
 113         ao_config.radio_setting = ao_freq_to_set(ao_config.frequency, ao_config.radio_cal);
 114 #if HAS_RADIO_FORWARD
 115         ao_send_radio_setting = ao_freq_to_set(ao_config.send_frequency, ao_config.radio_cal);
 116 #endif
 117 }
 118 #endif /* HAS_RADIO */
 119
 120 static void
 121 _ao_config_get(void)
 122 {
 123         uint8_t minor;
 124
 125         if (ao_config_loaded)
 126                 return;
 127 #if HAS_CONFIG_SAVE
 128         /* Yes, I know ao_storage_read calls ao_storage_setup,
 129          * but ao_storage_setup *also* sets ao_storage_config, which we
 130          * need before calling ao_storage_read here
 131          */
 132         ao_config_setup();
 133         ao_config_read(0, &ao_config, sizeof (ao_config));
 134 #endif
 135         if (ao_config.major != AO_CONFIG_MAJOR) {
 136                 ao_config.major = AO_CONFIG_MAJOR;
 137                 ao_config.minor = 0;
 138
 139                 /* Version 0 stuff */
 140                 ao_config.main_deploy = AO_CONFIG_DEFAULT_MAIN_DEPLOY;
 141                 memset(&ao_config.callsign, '\0', sizeof (ao_config.callsign));
 142                 memcpy(&ao_config.callsign, AO_CONFIG_DEFAULT_CALLSIGN,
 143                        sizeof(AO_CONFIG_DEFAULT_CALLSIGN) - 1);
 144                 ao_config._legacy_radio_channel = 0;
 145         }
 146         minor = ao_config.minor;
 147         if (minor != AO_CONFIG_MINOR) {
 148                 /* Fixups for minor version 1 */
 149                 if (minor < 1)
 150                         ao_config.apogee_delay = AO_CONFIG_DEFAULT_APOGEE_DELAY;
 151                 /* Fixups for minor version 2 */
 152                 if (minor < 2) {
 153                         ao_config.accel_plus_g = 0;
 154                         ao_config.accel_minus_g = 0;
 155                 }
 156                 /* Fixups for minor version 3 */
 157 #if HAS_RADIO
 158                 if (minor < 3)
 159                         ao_config.radio_cal = ao_radio_cal;
 160 #endif
 161                 /* Fixups for minor version 4 */
 162 #if HAS_LOG
 163                 if (minor < 4)
 164                         ao_config.flight_log_max = AO_CONFIG_DEFAULT_FLIGHT_LOG_MAX;
 165 #endif
 166                 /* Fixupes for minor version 5 */
 167                 if (minor < 5)
 168                         ao_config.ignite_mode = AO_CONFIG_DEFAULT_IGNITE_MODE;
 169                 if (minor < 6)
 170                         ao_config.pad_orientation = AO_CONFIG_DEFAULT_PAD_ORIENTATION;
 171                 if (minor < 8)
 172                         ao_config.radio_enable = AO_RADIO_ENABLE_CORE;
 173                 if (minor < 9)
 174                         memset(&ao_config.aes_key, '\0', AO_AES_LEN);
 175                 if (minor < 10)
 176                         ao_config.frequency = 434550 + ao_config._legacy_radio_channel * 100;
 177                 if (minor < 11)
 178                         ao_config.apogee_lockout = 0;
 179 #if AO_PYRO_NUM
 180                 if (minor < 12)
 181                         memset(&ao_config.pyro, '\0', sizeof (ao_config.pyro));
 182 #endif
 183                 if (minor < 13)
 184                         ao_config.aprs_interval = AO_CONFIG_DEFAULT_APRS_INTERVAL;
 185 #if HAS_RADIO_POWER
 186                 if (minor < 14)
 187                         ao_config.radio_power = AO_CONFIG_DEFAULT_RADIO_POWER;
 188                 #endif
 189 #if HAS_RADIO_AMP
 190                 if (minor  < 14)
 191                         ao_config.radio_amp = AO_CONFIG_DEFAULT_RADIO_AMP;
 192 #endif
 193 #if HAS_GYRO
 194                 if (minor < 15) {
 195                         ao_config.accel_zero_along = 0;
 196                         ao_config.accel_zero_across = 0;
 197                         ao_config.accel_zero_through = 0;
 198
 199                         /* Reset the main accel offsets to force
 200                          * re-calibration
 201                          */
 202                         ao_config.accel_plus_g = 0;
 203                         ao_config.accel_minus_g = 0;
 204                 }
 205 #endif
 206 #if HAS_BEEP_CONFIG
 207                 if (minor < 16)
 208                         ao_config.mid_beep = AO_BEEP_MID_DEFAULT;
 209 #endif
 210 #if HAS_TRACKER
 211                 if (minor < 17) {
 212                         ao_config.tracker_motion = AO_TRACKER_MOTION_DEFAULT;
 213                         ao_config.tracker_interval = AO_TRACKER_INTERVAL_DEFAULT;
 214                 }
 215 #endif
 216 #if AO_PYRO_NUM
 217                 if (minor < 18)
 218                         ao_config.pyro_time = AO_CONFIG_DEFAULT_PYRO_TIME;
 219 #endif
 220 #if HAS_APRS
 221                 if (minor < 19)
 222                         ao_config.aprs_ssid = AO_CONFIG_DEFAULT_APRS_SSID;
 223 #endif
 224 #if HAS_RADIO_RATE
 225                 if (minor < 20)
 226                         ao_config.radio_rate = AO_CONFIG_DEFAULT_RADIO_RATE;
 227 #endif
 228 #if HAS_RADIO_FORWARD
 229                 if (minor < 21)
 230                         ao_config.send_frequency = 434550;
 231 #endif
 232 #if HAS_APRS
 233                 if (minor < 22)
 234                         ao_config.aprs_format = AO_CONFIG_DEFAULT_APRS_FORMAT;
 235 #endif
 236 #if HAS_FIXED_PAD_BOX
 237                 if (minor < 22)
 238                         ao_config.pad_box = 1;
 239                 if (minor < 23)
 240                         ao_config.pad_idle = 120;
 241 #endif
 242 #if HAS_APRS
 243                 if (minor < 24)
 244                         ao_config.aprs_offset = 0;
 245 #endif
 246                 ao_config.minor = AO_CONFIG_MINOR;
 247                 ao_config_dirty = 1;
 248         }
 249 #if HAS_RADIO
 250 #if HAS_FORCE_FREQ
 251         if (ao_force_freq) {
 252                 ao_config.frequency = 434550;
 253                 ao_config.radio_cal = ao_radio_cal;
 254 #if HAS_RADIO_RATE
 255                 ao_config.radio_rate = AO_CONFIG_DEFAULT_RADIO_RATE;
 256 #endif
 257                 memcpy(&ao_config.callsign, AO_CONFIG_DEFAULT_CALLSIGN,
 258                        sizeof(AO_CONFIG_DEFAULT_CALLSIGN) - 1);
 259         }
 260 #endif
 261         ao_config_set_radio();
 262 #endif
 263         ao_config_loaded = 1;
 264 }
 265
 266 void
 267 _ao_config_edit_start(void)
 268 {
 269         ao_mutex_get(&ao_config_mutex);
 270         _ao_config_get();
 271 }
 272
 273 void
 274 _ao_config_edit_finish(void)
 275 {
 276         ao_config_dirty = 1;
 277         ao_mutex_put(&ao_config_mutex);
 278 }
 279
 280 void
 281 ao_config_get(void)
 282 {
 283         _ao_config_edit_start();
 284         ao_mutex_put(&ao_config_mutex);
 285 }
 286
 287 #if HAS_RADIO
 288
 289 static void
 290 ao_config_callsign_show(void)
 291 {
 292         printf ("Callsign: \"%s\"\n", ao_config.callsign);
 293 }
 294
 295 static void
 296 ao_config_callsign_set(void)
 297 {
 298         uint8_t c;
 299         static char callsign[AO_MAX_CALLSIGN + 1];
 300
 301         memset(callsign, '\0', sizeof callsign);
 302         ao_cmd_white();
 303         c = 0;
 304         while (ao_cmd_lex_c != '\n') {
 305                 if (c < AO_MAX_CALLSIGN)
 306                         callsign[c++] = ao_cmd_lex_c;
 307                 else
 308                         ao_cmd_status = ao_cmd_lex_error;
 309                 ao_cmd_lex();
 310         }
 311         if (ao_cmd_status != ao_cmd_success)
 312                 return;
 313         _ao_config_edit_start();
 314         memcpy(&ao_config.callsign, &callsign,
 315                AO_MAX_CALLSIGN + 1);
 316         _ao_config_edit_finish();
 317 }
 318
 319 static void
 320 ao_config_frequency_show(void)
 321 {
 322         printf("Frequency: %ld\n",
 323                ao_config.frequency);
 324 }
 325
 326 static void
 327 ao_config_frequency_set(void)
 328 {
 329         uint32_t r = ao_cmd_decimal();
 330         if (ao_cmd_status != ao_cmd_success)
 331                 return;
 332         _ao_config_edit_start();
 333         ao_config.frequency = r;
 334         ao_config_set_radio();
 335         _ao_config_edit_finish();
 336 #if HAS_RADIO_RECV
 337         ao_radio_recv_abort();
 338 #endif
 339 }
 340
 341 #endif
 342
 343 #if HAS_RADIO_FORWARD
 344 void
 345 ao_config_send_frequency_show(void)
 346 {
 347         printf("Send frequency: %ld\n",
 348                ao_config.send_frequency);
 349 }
 350
 351 void
 352 ao_config_send_frequency_set(void)
 353 {
 354         ao_cmd_decimal();
 355         if (ao_cmd_status != ao_cmd_success)
 356                 return;
 357         _ao_config_edit_start();
 358         ao_config.send_frequency = ao_cmd_lex_u32;
 359         ao_config_set_radio();
 360         _ao_config_edit_finish();
 361 #if HAS_RADIO_RECV
 362         ao_radio_recv_abort();
 363 #endif
 364 }
 365
 366 #endif
 367
 368 #if HAS_FLIGHT
 369
 370 #if HAS_BARO
 371
 372 static void
 373 ao_config_main_deploy_show(void)
 374 {
 375         printf("Main deploy: %d meters\n",
 376                ao_config.main_deploy);
 377 }
 378
 379 static void
 380 ao_config_main_deploy_set(void)
 381 {
 382         uint32_t r = ao_cmd_decimal();
 383         if (ao_cmd_status != ao_cmd_success)
 384                 return;
 385         _ao_config_edit_start();
 386         ao_config.main_deploy = r;
 387         _ao_config_edit_finish();
 388 }
 389
 390 #endif
 391
 392 #if HAS_ACCEL
 393 static void
 394 ao_config_accel_calibrate_show(void)
 395 {
 396         printf("Accel cal +1g: %d -1g: %d\n",
 397                ao_config.accel_plus_g, ao_config.accel_minus_g);
 398 #if HAS_GYRO
 399         printf ("IMU cal along %d across %d through %d\n",
 400                 ao_config.accel_zero_along,
 401                 ao_config.accel_zero_across,
 402                 ao_config.accel_zero_through);
 403 #endif
 404 }
 405
 406 #define ACCEL_CALIBRATE_SAMPLES 1024
 407 #define ACCEL_CALIBRATE_SHIFT   10
 408
 409 #if HAS_GYRO
 410 static int16_t accel_cal_along;
 411 static int16_t accel_cal_across;
 412 static int16_t accel_cal_through;
 413 #endif
 414
 415 static int16_t
 416 ao_config_accel_calibrate_auto(char *orientation)
 417 {
 418         uint16_t        i;
 419         int32_t         accel_total;
 420         uint8_t         cal_data_ring;
 421 #if HAS_GYRO
 422         int32_t         accel_along_total = 0;
 423         int32_t         accel_across_total = 0;
 424         int32_t         accel_through_total = 0;
 425 #endif
 426
 427         printf("Orient antenna %s and press a key...", orientation);
 428         flush();
 429         (void) getchar();
 430         puts("\r\n"); flush();
 431         puts("Calibrating..."); flush();
 432         i = ACCEL_CALIBRATE_SAMPLES;
 433         accel_total = 0;
 434         cal_data_ring = ao_sample_data;
 435         while (i) {
 436                 ao_sleep(&ao_sample_data);
 437                 while (i && cal_data_ring != ao_sample_data) {
 438                         accel_total += (int32_t) ao_data_accel(&ao_data_ring[cal_data_ring]);
 439 #if HAS_GYRO
 440                         accel_along_total += (int32_t) ao_data_along(&ao_data_ring[cal_data_ring]);
 441                         accel_across_total += (int32_t) ao_data_across(&ao_data_ring[cal_data_ring]);
 442                         accel_through_total += (int32_t) ao_data_through(&ao_data_ring[cal_data_ring]);
 443 #endif
 444                         cal_data_ring = ao_data_ring_next(cal_data_ring);
 445                         i--;
 446                 }
 447         }
 448 #if HAS_GYRO
 449         accel_cal_along = accel_along_total >> ACCEL_CALIBRATE_SHIFT;
 450         accel_cal_across = accel_across_total >> ACCEL_CALIBRATE_SHIFT;
 451         accel_cal_through = accel_through_total >> ACCEL_CALIBRATE_SHIFT;
 452 #endif
 453         return accel_total >> ACCEL_CALIBRATE_SHIFT;
 454 }
 455
 456 static void
 457 ao_config_accel_calibrate_set(void)
 458 {
 459         int16_t up, down;
 460         uint16_t r;
 461 #if HAS_GYRO
 462         int16_t accel_along_up = 0, accel_along_down = 0;
 463         int16_t accel_across_up = 0, accel_across_down = 0;
 464         int16_t accel_through_up = 0, accel_through_down = 0;
 465 #endif
 466
 467         r = ao_cmd_decimal();
 468         if (ao_cmd_status != ao_cmd_success)
 469                 return;
 470         if (r == 0) {
 471                 up = ao_config_accel_calibrate_auto("up");
 472 #if HAS_GYRO
 473                 accel_along_up = accel_cal_along;
 474                 accel_across_up = accel_cal_across;
 475                 accel_through_up = accel_cal_through;
 476 #endif
 477                 down = ao_config_accel_calibrate_auto("down");
 478 #if HAS_GYRO
 479                 accel_along_down = accel_cal_along;
 480                 accel_across_down = accel_cal_across;
 481                 accel_through_down = accel_cal_through;
 482 #endif
 483         } else {
 484                 up = r;
 485                 r = ao_cmd_decimal();
 486                 if (ao_cmd_status != ao_cmd_success)
 487                         return;
 488                 down = r;
 489         }
 490         if (up >= down) {
 491                 printf("Invalid accel: up (%d) down (%d)\n",
 492                        up, down);
 493                 return;
 494         }
 495         _ao_config_edit_start();
 496         ao_config.accel_plus_g = up;
 497         ao_config.accel_minus_g = down;
 498 #if HAS_GYRO
 499         if (r == 0) {
 500                 ao_config.accel_zero_along = (accel_along_up + accel_along_down) / 2;
 501                 ao_config.accel_zero_across = (accel_across_up + accel_across_down) / 2;
 502                 ao_config.accel_zero_through = (accel_through_up + accel_through_down) / 2;
 503         }
 504 #endif
 505         _ao_config_edit_finish();
 506 }
 507 #endif /* HAS_ACCEL */
 508
 509 #if HAS_BARO
 510 static void
 511 ao_config_apogee_delay_show(void)
 512 {
 513         printf("Apogee delay: %d seconds\n",
 514                ao_config.apogee_delay);
 515 }
 516
 517 static void
 518 ao_config_apogee_delay_set(void)
 519 {
 520         uint32_t r = ao_cmd_decimal();
 521         if (ao_cmd_status != ao_cmd_success)
 522                 return;
 523         _ao_config_edit_start();
 524         ao_config.apogee_delay = r;
 525         _ao_config_edit_finish();
 526 }
 527
 528 static void
 529 ao_config_apogee_lockout_show(void)
 530 {
 531         printf ("Apogee lockout: %d seconds\n",
 532                 ao_config.apogee_lockout);
 533 }
 534
 535 static void
 536 ao_config_apogee_lockout_set(void)
 537 {
 538         uint16_t r = ao_cmd_decimal();
 539         if (ao_cmd_status != ao_cmd_success)
 540                 return;
 541         _ao_config_edit_start();
 542         ao_config.apogee_lockout = r;
 543         _ao_config_edit_finish();
 544 }
 545 #endif
 546
 547 #endif /* HAS_FLIGHT */
 548
 549 #if HAS_RADIO
 550 static void
 551 ao_config_radio_cal_show(void)
 552 {
 553         printf("Radio cal: %ld\n", ao_config.radio_cal);
 554 }
 555
 556 static void
 557 ao_config_radio_cal_set(void)
 558 {
 559         uint32_t r = ao_cmd_decimal();
 560         if (ao_cmd_status != ao_cmd_success)
 561                 return;
 562         _ao_config_edit_start();
 563         ao_config.radio_cal = r;
 564         ao_config_set_radio();
 565         _ao_config_edit_finish();
 566 }
 567
 568 #endif
 569
 570 #if HAS_RADIO_RATE
 571 #ifndef HAS_TELEMETRY
 572 #error Please define HAS_TELEMETRY
 573 #endif
 574
 575 static void
 576 ao_config_radio_rate_show(void)
 577 {
 578         printf("Telemetry rate: %d\n", ao_config.radio_rate);
 579 }
 580
 581 static void
 582 ao_config_radio_rate_set(void)
 583 {
 584         uint16_t r = ao_cmd_decimal();
 585         if (ao_cmd_status != ao_cmd_success)
 586                 return;
 587         if (AO_RADIO_RATE_MAX < r) {
 588                 ao_cmd_status = ao_cmd_lex_error;
 589                 return;
 590         }
 591         _ao_config_edit_start();
 592         ao_config.radio_rate = r;
 593         _ao_config_edit_finish();
 594 #if HAS_TELEMETRY
 595         ao_telemetry_reset_interval();
 596 #endif
 597 #if HAS_RADIO_RECV
 598         ao_radio_recv_abort();
 599 #endif
 600 }
 601 #endif
 602
 603 #if HAS_LOG
 604
 605 static void
 606 ao_config_log_show(void)
 607 {
 608         printf("Max flight log: %d kB\n", (int16_t) (ao_config.flight_log_max >> 10));
 609 #if FLIGHT_LOG_APPEND
 610         printf("Log fixed: 1\n");
 611 #endif
 612 }
 613
 614 #if FLIGHT_LOG_APPEND && HAS_CONFIG_SAVE
 615 void
 616 ao_config_log_fix_append(void)
 617 {
 618         _ao_config_edit_start();
 619         ao_config.flight_log_max = ao_storage_log_max;
 620         _ao_config_edit_finish();
 621         ao_mutex_get(&ao_config_mutex);
 622         _ao_config_put();
 623         ao_config_dirty = 0;
 624         ao_mutex_put(&ao_config_mutex);
 625 }
 626 #endif
 627
 628 static void
 629 ao_config_log_set(void)
 630 {
 631 #if FLIGHT_LOG_APPEND
 632         printf("Flight log fixed size %u kB\n", (unsigned) (ao_storage_log_max >> 10));
 633 #else
 634         uint32_t        r;
 635
 636         r = ao_cmd_decimal();
 637         if (ao_cmd_status != ao_cmd_success)
 638                 return;
 639         r = r << 10;
 640         if (ao_log_present()) {
 641                 if (r != ao_config.flight_log_max)
 642                         printf("Storage must be empty before changing log size\n");
 643                 return;
 644         }
 645         if (r > ao_storage_log_max) {
 646                 printf("Flight log max %u kB\n", (unsigned) (ao_storage_log_max >> 10));
 647                 return;
 648         }
 649         _ao_config_edit_start();
 650         ao_config.flight_log_max = r & ~(ao_storage_block - 1);
 651         _ao_config_edit_finish();
 652 #endif
 653 }
 654 #endif /* HAS_LOG */
 655
 656 #if HAS_IGNITE
 657 static void
 658 ao_config_ignite_mode_show(void)
 659 {
 660         printf("Ignite mode: %d\n", ao_config.ignite_mode);
 661 }
 662
 663 static void
 664 ao_config_ignite_mode_set(void)
 665 {
 666         uint16_t r = ao_cmd_decimal();
 667         if (ao_cmd_status != ao_cmd_success)
 668                 return;
 669         _ao_config_edit_start();
 670         ao_config.ignite_mode = r;
 671         _ao_config_edit_finish();
 672 }
 673 #endif
 674
 675 #if HAS_ACCEL
 676 static void
 677 ao_config_pad_orientation_show(void)
 678 {
 679         printf("Pad orientation: %d\n", ao_config.pad_orientation);
 680 }
 681
 682 static void
 683 ao_config_pad_orientation_set(void)
 684 {
 685         uint16_t r = ao_cmd_decimal() & 1;
 686         if (ao_cmd_status != ao_cmd_success)
 687                 return;
 688         _ao_config_edit_start();
 689         if (ao_config.pad_orientation != r) {
 690                 accel_t t;
 691                 t = ao_config.accel_plus_g;
 692                 ao_config.accel_plus_g = ao_data_accel_invert(ao_config.accel_minus_g);
 693                 ao_config.accel_minus_g = ao_data_accel_invert(t);
 694         }
 695         ao_config.pad_orientation = r;
 696         _ao_config_edit_finish();
 697 }
 698 #endif
 699
 700 #if HAS_RADIO
 701 static void
 702 ao_config_radio_enable_show(void)
 703 {
 704         printf("Radio enable: %d\n", ao_config.radio_enable);
 705 }
 706
 707 static void
 708 ao_config_radio_enable_set(void)
 709 {
 710         uint16_t r = ao_cmd_decimal();
 711         if (ao_cmd_status != ao_cmd_success)
 712                 return;
 713         _ao_config_edit_start();
 714         ao_config.radio_enable = r;
 715         _ao_config_edit_finish();
 716 #if HAS_TELEMETRY && HAS_RADIO_RATE
 717         ao_telemetry_reset_interval();
 718 #endif
 719 }
 720 #endif /* HAS_RADIO */
 721
 722 #if HAS_AES
 723
 724 uint8_t ao_config_aes_seq = 1;
 725
 726 static void
 727 ao_config_key_show(void)
 728 {
 729         uint8_t i;
 730         printf("AES key: ");
 731         for (i = 0; i < AO_AES_LEN; i++)
 732                 printf ("%02x", ao_config.aes_key[i]);
 733         printf("\n");
 734 }
 735
 736 static void
 737 ao_config_key_set(void)
 738 {
 739         uint8_t i;
 740
 741         _ao_config_edit_start();
 742         for (i = 0; i < AO_AES_LEN; i++) {
 743                 uint8_t b = ao_cmd_hexbyte();
 744                 if (ao_cmd_status != ao_cmd_success)
 745                         break;
 746                 ao_config.aes_key[i] = b;
 747         }
 748         ++ao_config_aes_seq;
 749         _ao_config_edit_finish();
 750 }
 751 #endif
 752
 753 #if HAS_APRS
 754
 755 static void
 756 ao_config_aprs_show(void)
 757 {
 758         printf ("APRS interval: %d\n", ao_config.aprs_interval);
 759 }
 760
 761 static void
 762 ao_config_aprs_set(void)
 763 {
 764         uint16_t r = ao_cmd_decimal();
 765         if (ao_cmd_status != ao_cmd_success)
 766                 return;
 767         _ao_config_edit_start();
 768         ao_config.aprs_interval = r;
 769         _ao_config_edit_finish();
 770         ao_telemetry_reset_interval();
 771 }
 772
 773 static void
 774 ao_config_aprs_offset_show(void)
 775 {
 776         printf ("APRS offset: %d\n", ao_config.aprs_offset);
 777 }
 778
 779 static void
 780 ao_config_aprs_offset_set(void)
 781 {
 782         uint16_t r = ao_cmd_decimal();
 783         if (ao_cmd_status != ao_cmd_success)
 784                 return;
 785         _ao_config_edit_start();
 786         ao_config.aprs_offset = r;
 787         _ao_config_edit_finish();
 788         ao_telemetry_reset_interval();
 789 }
 790
 791 #endif /* HAS_APRS */
 792
 793 #if HAS_RADIO_AMP
 794
 795 void
 796 ao_config_radio_amp_show(void)
 797 {
 798         printf ("Radio amp setting: %d\n", ao_config.radio_amp);
 799 }
 800
 801 void
 802 ao_config_radio_amp_set(void)
 803 {
 804         uint16_t r = ao_cmd_decimal();
 805         if (ao_cmd_status != ao_cmd_success)
 806                 return;
 807         _ao_config_edit_start();
 808         ao_config.radio_amp = r;
 809         _ao_config_edit_finish();
 810 }
 811
 812 #endif
 813
 814 #if HAS_RADIO_POWER
 815
 816 void
 817 ao_config_radio_power_show(void)
 818 {
 819         printf ("Radio power setting: %d\n", ao_config.radio_power);
 820 }
 821
 822 void
 823 ao_config_radio_power_set(void)
 824 {
 825         uint16_t r = ao_cmd_decimal();
 826         if (ao_cmd_status != ao_cmd_success)
 827                 return;
 828         _ao_config_edit_start();
 829         ao_config.radio_power = r;
 830         _ao_config_edit_finish();
 831 }
 832
 833 #endif
 834
 835 #if HAS_BEEP_CONFIG
 836 static void
 837 ao_config_beep_show(void)
 838 {
 839         printf ("Beeper setting: %d\n", ao_config.mid_beep);
 840 }
 841
 842 static void
 843 ao_config_beep_set(void)
 844 {
 845         uint16_t r = ao_cmd_decimal();
 846         if (ao_cmd_status != ao_cmd_success)
 847                 return;
 848         _ao_config_edit_start();
 849         ao_config.mid_beep = r;
 850         _ao_config_edit_finish();
 851 }
 852 #endif
 853
 854 #if HAS_TRACKER
 855 static void
 856 ao_config_tracker_show(void)
 857 {
 858         printf ("Tracker setting: %d %d\n",
 859                 ao_config.tracker_motion,
 860                 ao_config.tracker_interval);
 861 }
 862
 863 static void
 864 ao_config_tracker_set(void)
 865 {
 866         uint16_t        m, i;
 867         m = ao_cmd_decimal();
 868         if (ao_cmd_status != ao_cmd_success)
 869                 return;
 870         i = ao_cmd_decimal();
 871         if (ao_cmd_status != ao_cmd_success)
 872                 return;
 873         _ao_config_edit_start();
 874         ao_config.tracker_motion = m;
 875         ao_config.tracker_interval = i;
 876         _ao_config_edit_finish();
 877 #if HAS_TELEMETRY
 878         ao_telemetry_reset_interval();
 879 #endif
 880 }
 881 #endif /* HAS_TRACKER */
 882
 883 #if AO_PYRO_NUM
 884 static void
 885 ao_config_pyro_time_show(void)
 886 {
 887         printf ("Pyro time: %d\n", ao_config.pyro_time);
 888 }
 889
 890 static void
 891 ao_config_pyro_time_set(void)
 892 {
 893         uint16_t r = ao_cmd_decimal();
 894         if (ao_cmd_status != ao_cmd_success)
 895                 return;
 896         _ao_config_edit_start();
 897         ao_config.pyro_time = r;
 898         _ao_config_edit_finish();
 899 }
 900 #endif
 901
 902 #if HAS_APRS
 903 static void
 904 ao_config_aprs_ssid_show(void)
 905 {
 906         printf ("APRS SSID: %d\n",
 907                 ao_config.aprs_ssid);
 908 }
 909
 910 static void
 911 ao_config_aprs_ssid_set(void)
 912 {
 913         uint16_t r = ao_cmd_decimal();
 914         if (ao_cmd_status != ao_cmd_success)
 915                 return;
 916         if (15 < r) {
 917                 ao_cmd_status = ao_cmd_lex_error;
 918                 return;
 919         }
 920         _ao_config_edit_start();
 921         ao_config.aprs_ssid = r;
 922         _ao_config_edit_finish();
 923 }
 924
 925 static void
 926 ao_config_aprs_format_set(void)
 927 {
 928         uint16_t r = ao_cmd_decimal();
 929         if (ao_cmd_status != ao_cmd_success)
 930                 return;
 931         _ao_config_edit_start();
 932         ao_config.aprs_format = r != 0;
 933         _ao_config_edit_finish();
 934 }
 935
 936 static void
 937 ao_config_aprs_format_show(void)
 938 {
 939         printf ("APRS format: %d\n", ao_config.aprs_format);
 940 }
 941 #endif /* HAS_APRS */
 942
 943 #if HAS_FIXED_PAD_BOX
 944 static void
 945 ao_config_pad_box_show(void)
 946 {
 947         printf ("Pad box: %d\n", ao_config.pad_box);
 948 }
 949
 950 static void
 951 ao_config_pad_box_set(void)
 952 {
 953         uint16_t r = ao_cmd_decimal();
 954         if (ao_cmd_status != ao_cmd_success)
 955                 return;
 956         _ao_config_edit_start();
 957         ao_config.pad_box = r;
 958         _ao_config_edit_finish();
 959 }
 960
 961 static void
 962 ao_config_pad_idle_show(void)
 963 {
 964         printf ("Idle timeout: %d\n", ao_config.pad_idle);
 965 }
 966
 967 static void
 968 ao_config_pad_idle_set(void)
 969 {
 970         uint16_t r = ao_cmd_decimal();
 971         if (ao_cmd_status != ao_cmd_success)
 972                 return;
 973         _ao_config_edit_start();
 974         ao_config.pad_idle = r;
 975         _ao_config_edit_finish();
 976 }
 977 #endif
 978
 979 struct ao_config_var {
 980         const char      *str;
 981         void            (*set)(void);
 982         void            (*show)(void);
 983 };
 984
 985 static void
 986 ao_config_help(void);
 987
 988 static void
 989 ao_config_show(void);
 990
 991 #if HAS_CONFIG_SAVE
 992 static void
 993 ao_config_save(void);
 994 #endif
 995
 996 const struct ao_config_var ao_config_vars[] = {
 997 #if HAS_FLIGHT && HAS_BARO
 998         { "m <meters>\0Main deploy (m)",
 999           ao_config_main_deploy_set,    ao_config_main_deploy_show, },
1000         { "d <delay>\0Apogee delay (s)",
1001           ao_config_apogee_delay_set,   ao_config_apogee_delay_show },
1002         { "L <seconds>\0Apogee detect lockout (s)",
1003           ao_config_apogee_lockout_set, ao_config_apogee_lockout_show, },
1004 #endif /* HAS_FLIGHT */
1005 #if HAS_RADIO
1006         { "F <freq>\0Frequency (kHz)",
1007           ao_config_frequency_set, ao_config_frequency_show },
1008 #if HAS_RADIO_FORWARD
1009         { "R <freq>\0Repeater output frequency (kHz)",
1010           ao_config_send_frequency_set, ao_config_send_frequency_show },
1011 #endif
1012         { "c <call>\0Callsign (8 char max)",
1013           ao_config_callsign_set,       ao_config_callsign_show },
1014         { "e <0 disable, 1 enable>\0Enable telemetry and RDF",
1015           ao_config_radio_enable_set, ao_config_radio_enable_show },
1016         { "f <cal>\0Radio calib (cal = rf/(xtal/2^16))",
1017           ao_config_radio_cal_set,      ao_config_radio_cal_show },
1018 #if HAS_RADIO_RATE
1019         { "T <rate>\0Telemetry rate (0=38.4, 1=9.6, 2=2.4)",
1020           ao_config_radio_rate_set,     ao_config_radio_rate_show },
1021 #endif
1022 #if HAS_RADIO_POWER
1023         { "p <setting>\0Radio power setting (0-255)",
1024           ao_config_radio_power_set,    ao_config_radio_power_show },
1025 #endif
1026 #if HAS_RADIO_AMP
1027         { "d <setting>\0Radio amplifier setting (0-3)",
1028           ao_config_radio_amp_set,      ao_config_radio_amp_show },
1029 #endif
1030 #endif /* HAS_RADIO */
1031 #if HAS_ACCEL
1032         { "a <+g> <-g>\0Accel calib (0 for auto)",
1033           ao_config_accel_calibrate_set,ao_config_accel_calibrate_show },
1034         { "o <0 antenna up, 1 antenna down>\0Pad orientation",
1035           ao_config_pad_orientation_set,ao_config_pad_orientation_show },
1036 #endif /* HAS_ACCEL */
1037 #if HAS_LOG
1038         { "l <size>\0Flight log size (kB)",
1039           ao_config_log_set,            ao_config_log_show },
1040 #endif
1041 #if HAS_IGNITE
1042         { "i <0 dual, 1 apogee, 2 main, 3 booster>\0Igniter mode",
1043           ao_config_ignite_mode_set,    ao_config_ignite_mode_show },
1044 #endif
1045 #if HAS_AES
1046         { "k <32 hex digits>\0AES encryption key",
1047           ao_config_key_set, ao_config_key_show },
1048 #endif
1049 #if AO_PYRO_NUM
1050         { "P <n,?>\0Pyro channels",
1051           ao_pyro_set, ao_pyro_show },
1052         { "I <ticks>\0Pyro firing time",
1053           ao_config_pyro_time_set, ao_config_pyro_time_show },
1054 #endif
1055 #if HAS_APRS
1056         { "A <secs>\0APRS packet interval (0 disable)",
1057           ao_config_aprs_set, ao_config_aprs_show },
1058 #endif
1059 #if HAS_BEEP_CONFIG
1060         { "b <val>\0Beeper tone (freq = 1/2 (24e6/32) / beep",
1061           ao_config_beep_set, ao_config_beep_show },
1062 #endif
1063 #if HAS_TRACKER
1064         { "t <motion> <interval>\0Tracker configuration",
1065           ao_config_tracker_set, ao_config_tracker_show },
1066 #endif
1067 #if HAS_APRS
1068         { "S <ssid>\0Set APRS SSID (0-15)",
1069           ao_config_aprs_ssid_set, ao_config_aprs_ssid_show },
1070         { "C <0 compressed, 1 uncompressed>\0APRS format",
1071           ao_config_aprs_format_set, ao_config_aprs_format_show },
1072         { "O <aprs-offset>\0APRS Offset from top of minute",
1073           ao_config_aprs_offset_set, ao_config_aprs_offset_show },
1074 #endif
1075 #if HAS_FIXED_PAD_BOX
1076         { "B <box>\0Set pad box (1-99)",
1077           ao_config_pad_box_set, ao_config_pad_box_show },
1078         { "i <seconds>\0Set idle timeout (0 disable)",
1079           ao_config_pad_idle_set, ao_config_pad_idle_show },
1080 #endif
1081         { "s\0Show",
1082           ao_config_show,               0 },
1083 #if HAS_CONFIG_SAVE
1084         { "w\0Write to eeprom",
1085           ao_config_save,               0 },
1086 #endif
1087         { "?\0Help",
1088           ao_config_help,               0 },
1089         { 0, 0, 0 }
1090 };
1091
1092 static void
1093 ao_config_set(void)
1094 {
1095         char    c;
1096         uint8_t cmd;
1097
1098         ao_cmd_white();
1099         c = ao_cmd_lex_c;
1100         ao_cmd_lex();
1101         for (cmd = 0; ao_config_vars[cmd].str != NULL; cmd++)
1102                 if (ao_config_vars[cmd].str[0] == c) {
1103                         (*ao_config_vars[cmd].set)();
1104                         return;
1105                 }
1106         ao_cmd_status = ao_cmd_syntax_error;
1107 }
1108
1109 static void
1110 ao_config_help(void)
1111 {
1112         uint8_t cmd;
1113         for (cmd = 0; ao_config_vars[cmd].str != NULL; cmd++)
1114                 printf("%-20s %s\n",
1115                        ao_config_vars[cmd].str,
1116                        ao_config_vars[cmd].str+1+
1117                        strlen(ao_config_vars[cmd].str));
1118 }
1119
1120 static void
1121 ao_config_show(void)
1122 {
1123         uint8_t cmd;
1124         ao_config_get();
1125         printf("Config version: %d.%d\n",
1126                ao_config.major, ao_config.minor);
1127         for (cmd = 0; ao_config_vars[cmd].str != NULL; cmd++)
1128                 if (ao_config_vars[cmd].show)
1129                         (*ao_config_vars[cmd].show)();
1130 #if HAS_MS5607
1131         ao_ms5607_info();
1132 #endif
1133 }
1134
1135 #if HAS_CONFIG_SAVE
1136 static void
1137 ao_config_save(void)
1138 {
1139         uint8_t saved = 0;
1140         ao_mutex_get(&ao_config_mutex);
1141         if (ao_config_dirty) {
1142                 _ao_config_put();
1143                 ao_config_dirty = 0;
1144                 saved = 1;
1145         }
1146         ao_mutex_put(&ao_config_mutex);
1147         if (saved)
1148                 puts("Saved");
1149         else
1150                 puts("Nothing to save");
1151 }
1152 #endif
1153
1154 const struct ao_cmds ao_config_cmds[] = {
1155         { ao_config_set,        "c <var> <value>\0Set config (? for help, s to show)" },
1156         { 0, NULL },
1157 };
1158
1159 void
1160 ao_config_init(void)
1161 {
1162         ao_cmd_register(&ao_config_cmds[0]);
1163 }