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