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_IMU
 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_IMU
 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_IMU
 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_IMU
 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_IMU
 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_IMU
 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         bool    auto_cal;
 461 #if HAS_IMU
 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         up = ao_cmd_decimal();
 468         if (ao_cmd_status != ao_cmd_success)
 469                 return;
 470         down = ao_cmd_decimal();
 471         auto_cal = (up == 0 && ao_cmd_status != ao_cmd_success);
 472         if (auto_cal) {
 473                 up = ao_config_accel_calibrate_auto("up");
 474 #if HAS_IMU
 475                 accel_along_up = accel_cal_along;
 476                 accel_across_up = accel_cal_across;
 477                 accel_through_up = accel_cal_through;
 478 #endif
 479                 down = ao_config_accel_calibrate_auto("down");
 480 #if HAS_IMU
 481                 accel_along_down = accel_cal_along;
 482                 accel_across_down = accel_cal_across;
 483                 accel_through_down = accel_cal_through;
 484 #endif
 485         }
 486         if (up >= down) {
 487                 printf("Invalid accel: up (%d) down (%d)\n",
 488                        up, down);
 489                 return;
 490         }
 491         _ao_config_edit_start();
 492         ao_config.accel_plus_g = up;
 493         ao_config.accel_minus_g = down;
 494 #if HAS_IMU
 495         if (auto_cal) {
 496                 ao_config.accel_zero_along = (accel_along_up + accel_along_down) / 2;
 497                 ao_config.accel_zero_across = (accel_across_up + accel_across_down) / 2;
 498                 ao_config.accel_zero_through = (accel_through_up + accel_through_down) / 2;
 499         } else {
 500                 int16_t v;
 501
 502                 v = ao_cmd_decimal();
 503                 if (ao_cmd_status == ao_cmd_success) {
 504                         ao_config.accel_zero_along = v;
 505                         v = ao_cmd_decimal();
 506                         if (ao_cmd_status == ao_cmd_success) {
 507                                 ao_config.accel_zero_across = v;
 508                                 v = ao_cmd_decimal();
 509                                 if (ao_cmd_status == ao_cmd_success)
 510                                         ao_config.accel_zero_through = v;
 511                         }
 512                 }
 513         }
 514 #endif
 515         _ao_config_edit_finish();
 516 }
 517 #endif /* HAS_ACCEL */
 518
 519 #if HAS_BARO
 520 static void
 521 ao_config_apogee_delay_show(void)
 522 {
 523         printf("Apogee delay: %d seconds\n",
 524                ao_config.apogee_delay);
 525 }
 526
 527 static void
 528 ao_config_apogee_delay_set(void)
 529 {
 530         uint32_t r = ao_cmd_decimal();
 531         if (ao_cmd_status != ao_cmd_success)
 532                 return;
 533         _ao_config_edit_start();
 534         ao_config.apogee_delay = r;
 535         _ao_config_edit_finish();
 536 }
 537
 538 static void
 539 ao_config_apogee_lockout_show(void)
 540 {
 541         printf ("Apogee lockout: %d seconds\n",
 542                 ao_config.apogee_lockout);
 543 }
 544
 545 static void
 546 ao_config_apogee_lockout_set(void)
 547 {
 548         uint16_t r = ao_cmd_decimal();
 549         if (ao_cmd_status != ao_cmd_success)
 550                 return;
 551         _ao_config_edit_start();
 552         ao_config.apogee_lockout = r;
 553         _ao_config_edit_finish();
 554 }
 555 #endif
 556
 557 #endif /* HAS_FLIGHT */
 558
 559 #if HAS_RADIO
 560 static void
 561 ao_config_radio_cal_show(void)
 562 {
 563         printf("Radio cal: %ld\n", ao_config.radio_cal);
 564 }
 565
 566 static void
 567 ao_config_radio_cal_set(void)
 568 {
 569         uint32_t r = ao_cmd_decimal();
 570         if (ao_cmd_status != ao_cmd_success)
 571                 return;
 572         _ao_config_edit_start();
 573         ao_config.radio_cal = r;
 574         ao_config_set_radio();
 575         _ao_config_edit_finish();
 576 }
 577
 578 #endif
 579
 580 #if HAS_RADIO_RATE
 581 #ifndef HAS_TELEMETRY
 582 #error Please define HAS_TELEMETRY
 583 #endif
 584
 585 static void
 586 ao_config_radio_rate_show(void)
 587 {
 588         printf("Telemetry rate: %d\n", ao_config.radio_rate);
 589 }
 590
 591 static void
 592 ao_config_radio_rate_set(void)
 593 {
 594         uint16_t r = ao_cmd_decimal();
 595         if (ao_cmd_status != ao_cmd_success)
 596                 return;
 597         if (AO_RADIO_RATE_MAX < r) {
 598                 ao_cmd_status = ao_cmd_lex_error;
 599                 return;
 600         }
 601         _ao_config_edit_start();
 602         ao_config.radio_rate = r;
 603         _ao_config_edit_finish();
 604 #if HAS_TELEMETRY
 605         ao_telemetry_reset_interval();
 606 #endif
 607 #if HAS_RADIO_RECV
 608         ao_radio_recv_abort();
 609 #endif
 610 }
 611 #endif
 612
 613 #if HAS_LOG
 614
 615 static void
 616 ao_config_log_show(void)
 617 {
 618         printf("Max flight log: %d kB\n", (int16_t) (ao_config.flight_log_max >> 10));
 619 #if FLIGHT_LOG_APPEND
 620         printf("Log fixed: 1\n");
 621 #endif
 622 }
 623
 624 #if FLIGHT_LOG_APPEND && HAS_CONFIG_SAVE
 625 void
 626 ao_config_log_fix_append(void)
 627 {
 628         _ao_config_edit_start();
 629         ao_config.flight_log_max = ao_storage_log_max;
 630         _ao_config_edit_finish();
 631         ao_mutex_get(&ao_config_mutex);
 632         _ao_config_put();
 633         ao_config_dirty = 0;
 634         ao_mutex_put(&ao_config_mutex);
 635 }
 636 #endif
 637
 638 static void
 639 ao_config_log_set(void)
 640 {
 641 #if FLIGHT_LOG_APPEND
 642         printf("Flight log fixed size %u kB\n", (unsigned) (ao_storage_log_max >> 10));
 643 #else
 644         uint32_t        r;
 645
 646         r = ao_cmd_decimal();
 647         if (ao_cmd_status != ao_cmd_success)
 648                 return;
 649         r = r << 10;
 650         if (ao_log_present()) {
 651                 if (r != ao_config.flight_log_max)
 652                         printf("Storage must be empty before changing log size\n");
 653                 return;
 654         }
 655         if (r > ao_storage_log_max) {
 656                 printf("Flight log max %u kB\n", (unsigned) (ao_storage_log_max >> 10));
 657                 return;
 658         }
 659         _ao_config_edit_start();
 660         ao_config.flight_log_max = r & ~(ao_storage_block - 1);
 661         _ao_config_edit_finish();
 662 #endif
 663 }
 664 #endif /* HAS_LOG */
 665
 666 #if HAS_IGNITE
 667 static void
 668 ao_config_ignite_mode_show(void)
 669 {
 670         printf("Ignite mode: %d\n", ao_config.ignite_mode);
 671 }
 672
 673 static void
 674 ao_config_ignite_mode_set(void)
 675 {
 676         uint16_t r = ao_cmd_decimal();
 677         if (ao_cmd_status != ao_cmd_success)
 678                 return;
 679         _ao_config_edit_start();
 680         ao_config.ignite_mode = r;
 681         _ao_config_edit_finish();
 682 }
 683 #endif
 684
 685 #if HAS_ACCEL
 686 static void
 687 ao_config_pad_orientation_show(void)
 688 {
 689         printf("Pad orientation: %d\n", ao_config.pad_orientation);
 690 }
 691
 692 static void
 693 ao_config_pad_orientation_set(void)
 694 {
 695         uint16_t r = ao_cmd_decimal() & 1;
 696         if (ao_cmd_status != ao_cmd_success)
 697                 return;
 698         _ao_config_edit_start();
 699         if (ao_config.pad_orientation != r) {
 700                 accel_t t;
 701                 t = ao_config.accel_plus_g;
 702                 ao_config.accel_plus_g = ao_data_accel_invert(ao_config.accel_minus_g);
 703                 ao_config.accel_minus_g = ao_data_accel_invert(t);
 704         }
 705         ao_config.pad_orientation = r;
 706         _ao_config_edit_finish();
 707 }
 708 #endif
 709
 710 #if HAS_RADIO
 711 static void
 712 ao_config_radio_enable_show(void)
 713 {
 714         printf("Radio enable: %d\n", ao_config.radio_enable);
 715 }
 716
 717 static void
 718 ao_config_radio_enable_set(void)
 719 {
 720         uint16_t r = ao_cmd_decimal();
 721         if (ao_cmd_status != ao_cmd_success)
 722                 return;
 723         _ao_config_edit_start();
 724         ao_config.radio_enable = r;
 725         _ao_config_edit_finish();
 726 #if HAS_TELEMETRY && HAS_RADIO_RATE
 727         ao_telemetry_reset_interval();
 728 #endif
 729 }
 730 #endif /* HAS_RADIO */
 731
 732 #if HAS_AES
 733
 734 uint8_t ao_config_aes_seq = 1;
 735
 736 static void
 737 ao_config_key_show(void)
 738 {
 739         uint8_t i;
 740         printf("AES key: ");
 741         for (i = 0; i < AO_AES_LEN; i++)
 742                 printf ("%02x", ao_config.aes_key[i]);
 743         printf("\n");
 744 }
 745
 746 static void
 747 ao_config_key_set(void)
 748 {
 749         uint8_t i;
 750
 751         _ao_config_edit_start();
 752         for (i = 0; i < AO_AES_LEN; i++) {
 753                 uint8_t b = ao_cmd_hexbyte();
 754                 if (ao_cmd_status != ao_cmd_success)
 755                         break;
 756                 ao_config.aes_key[i] = b;
 757         }
 758         ++ao_config_aes_seq;
 759         _ao_config_edit_finish();
 760 }
 761 #endif
 762
 763 #if HAS_APRS
 764
 765 static void
 766 ao_config_aprs_show(void)
 767 {
 768         printf ("APRS interval: %d\n", ao_config.aprs_interval);
 769 }
 770
 771 static void
 772 ao_config_aprs_set(void)
 773 {
 774         uint16_t r = ao_cmd_decimal();
 775         if (ao_cmd_status != ao_cmd_success)
 776                 return;
 777         _ao_config_edit_start();
 778         ao_config.aprs_interval = r;
 779         _ao_config_edit_finish();
 780         ao_telemetry_reset_interval();
 781 }
 782
 783 static void
 784 ao_config_aprs_offset_show(void)
 785 {
 786         printf ("APRS offset: %d\n", ao_config.aprs_offset);
 787 }
 788
 789 static void
 790 ao_config_aprs_offset_set(void)
 791 {
 792         uint16_t r = ao_cmd_decimal();
 793         if (ao_cmd_status != ao_cmd_success)
 794                 return;
 795         _ao_config_edit_start();
 796         ao_config.aprs_offset = r;
 797         _ao_config_edit_finish();
 798         ao_telemetry_reset_interval();
 799 }
 800
 801 #endif /* HAS_APRS */
 802
 803 #if HAS_RADIO_AMP
 804
 805 void
 806 ao_config_radio_amp_show(void)
 807 {
 808         printf ("Radio amp setting: %d\n", ao_config.radio_amp);
 809 }
 810
 811 void
 812 ao_config_radio_amp_set(void)
 813 {
 814         uint16_t r = ao_cmd_decimal();
 815         if (ao_cmd_status != ao_cmd_success)
 816                 return;
 817         _ao_config_edit_start();
 818         ao_config.radio_amp = r;
 819         _ao_config_edit_finish();
 820 }
 821
 822 #endif
 823
 824 #if HAS_RADIO_POWER
 825
 826 void
 827 ao_config_radio_power_show(void)
 828 {
 829         printf ("Radio power setting: %d\n", ao_config.radio_power);
 830 }
 831
 832 void
 833 ao_config_radio_power_set(void)
 834 {
 835         uint16_t r = ao_cmd_decimal();
 836         if (ao_cmd_status != ao_cmd_success)
 837                 return;
 838         _ao_config_edit_start();
 839         ao_config.radio_power = r;
 840         _ao_config_edit_finish();
 841 }
 842
 843 #endif
 844
 845 #if HAS_BEEP_CONFIG
 846 static void
 847 ao_config_beep_show(void)
 848 {
 849         printf ("Beeper setting: %d\n", ao_config.mid_beep);
 850 }
 851
 852 static void
 853 ao_config_beep_set(void)
 854 {
 855         uint16_t r = ao_cmd_decimal();
 856         if (ao_cmd_status != ao_cmd_success)
 857                 return;
 858         _ao_config_edit_start();
 859         ao_config.mid_beep = r;
 860         _ao_config_edit_finish();
 861 }
 862 #endif
 863
 864 #if HAS_TRACKER
 865 static void
 866 ao_config_tracker_show(void)
 867 {
 868         printf ("Tracker setting: %d %d\n",
 869                 ao_config.tracker_motion,
 870                 ao_config.tracker_interval);
 871 }
 872
 873 static void
 874 ao_config_tracker_set(void)
 875 {
 876         uint16_t        m, i;
 877         m = ao_cmd_decimal();
 878         if (ao_cmd_status != ao_cmd_success)
 879                 return;
 880         i = ao_cmd_decimal();
 881         if (ao_cmd_status != ao_cmd_success)
 882                 return;
 883         _ao_config_edit_start();
 884         ao_config.tracker_motion = m;
 885         ao_config.tracker_interval = i;
 886         _ao_config_edit_finish();
 887 #if HAS_TELEMETRY
 888         ao_telemetry_reset_interval();
 889 #endif
 890 }
 891 #endif /* HAS_TRACKER */
 892
 893 #if AO_PYRO_NUM
 894 static void
 895 ao_config_pyro_time_show(void)
 896 {
 897         printf ("Pyro time: %d\n", ao_config.pyro_time);
 898 }
 899
 900 static void
 901 ao_config_pyro_time_set(void)
 902 {
 903         uint16_t r = ao_cmd_decimal();
 904         if (ao_cmd_status != ao_cmd_success)
 905                 return;
 906         _ao_config_edit_start();
 907         ao_config.pyro_time = r;
 908         _ao_config_edit_finish();
 909 }
 910 #endif
 911
 912 #if HAS_APRS
 913 static void
 914 ao_config_aprs_ssid_show(void)
 915 {
 916         printf ("APRS SSID: %d\n",
 917                 ao_config.aprs_ssid);
 918 }
 919
 920 static void
 921 ao_config_aprs_ssid_set(void)
 922 {
 923         uint16_t r = ao_cmd_decimal();
 924         if (ao_cmd_status != ao_cmd_success)
 925                 return;
 926         if (15 < r) {
 927                 ao_cmd_status = ao_cmd_lex_error;
 928                 return;
 929         }
 930         _ao_config_edit_start();
 931         ao_config.aprs_ssid = r;
 932         _ao_config_edit_finish();
 933 }
 934
 935 static void
 936 ao_config_aprs_format_set(void)
 937 {
 938         uint16_t r = ao_cmd_decimal();
 939         if (ao_cmd_status != ao_cmd_success)
 940                 return;
 941         _ao_config_edit_start();
 942         ao_config.aprs_format = r != 0;
 943         _ao_config_edit_finish();
 944 }
 945
 946 static void
 947 ao_config_aprs_format_show(void)
 948 {
 949         printf ("APRS format: %d\n", ao_config.aprs_format);
 950 }
 951 #endif /* HAS_APRS */
 952
 953 #if HAS_FIXED_PAD_BOX
 954 static void
 955 ao_config_pad_box_show(void)
 956 {
 957         printf ("Pad box: %d\n", ao_config.pad_box);
 958 }
 959
 960 static void
 961 ao_config_pad_box_set(void)
 962 {
 963         uint16_t r = ao_cmd_decimal();
 964         if (ao_cmd_status != ao_cmd_success)
 965                 return;
 966         _ao_config_edit_start();
 967         ao_config.pad_box = r;
 968         _ao_config_edit_finish();
 969 }
 970
 971 static void
 972 ao_config_pad_idle_show(void)
 973 {
 974         printf ("Idle timeout: %d\n", ao_config.pad_idle);
 975 }
 976
 977 static void
 978 ao_config_pad_idle_set(void)
 979 {
 980         uint16_t r = ao_cmd_decimal();
 981         if (ao_cmd_status != ao_cmd_success)
 982                 return;
 983         _ao_config_edit_start();
 984         ao_config.pad_idle = r;
 985         _ao_config_edit_finish();
 986 }
 987 #endif
 988
 989 struct ao_config_var {
 990         const char      *str;
 991         void            (*set)(void);
 992         void            (*show)(void);
 993 };
 994
 995 static void
 996 ao_config_help(void);
 997
 998 static void
 999 ao_config_show(void);
1000
1001 #if HAS_CONFIG_SAVE
1002 static void
1003 ao_config_save(void);
1004 #endif
1005
1006 const struct ao_config_var ao_config_vars[] = {
1007 #if HAS_FLIGHT && HAS_BARO
1008         { "m <meters>\0Main deploy (m)",
1009           ao_config_main_deploy_set,    ao_config_main_deploy_show, },
1010         { "d <delay>\0Apogee delay (s)",
1011           ao_config_apogee_delay_set,   ao_config_apogee_delay_show },
1012         { "L <seconds>\0Apogee detect lockout (s)",
1013           ao_config_apogee_lockout_set, ao_config_apogee_lockout_show, },
1014 #endif /* HAS_FLIGHT */
1015 #if HAS_RADIO
1016         { "F <freq>\0Frequency (kHz)",
1017           ao_config_frequency_set, ao_config_frequency_show },
1018 #if HAS_RADIO_FORWARD
1019         { "R <freq>\0Repeater output frequency (kHz)",
1020           ao_config_send_frequency_set, ao_config_send_frequency_show },
1021 #endif
1022         { "c <call>\0Callsign (8 char max)",
1023           ao_config_callsign_set,       ao_config_callsign_show },
1024         { "e <0 disable, 1 enable>\0Enable telemetry and RDF",
1025           ao_config_radio_enable_set, ao_config_radio_enable_show },
1026         { "f <cal>\0Radio calib (cal = rf/(xtal/2^16))",
1027           ao_config_radio_cal_set,      ao_config_radio_cal_show },
1028 #if HAS_RADIO_RATE
1029         { "T <rate>\0Telemetry rate (0=38.4, 1=9.6, 2=2.4)",
1030           ao_config_radio_rate_set,     ao_config_radio_rate_show },
1031 #endif
1032 #if HAS_RADIO_POWER
1033         { "p <setting>\0Radio power setting (0-255)",
1034           ao_config_radio_power_set,    ao_config_radio_power_show },
1035 #endif
1036 #if HAS_RADIO_AMP
1037         { "d <setting>\0Radio amplifier setting (0-3)",
1038           ao_config_radio_amp_set,      ao_config_radio_amp_show },
1039 #endif
1040 #endif /* HAS_RADIO */
1041 #if HAS_ACCEL
1042         { "a <+g> <-g>\0Accel calib (0 for auto)",
1043           ao_config_accel_calibrate_set,ao_config_accel_calibrate_show },
1044         { "o <0 antenna up, 1 antenna down>\0Pad orientation",
1045           ao_config_pad_orientation_set,ao_config_pad_orientation_show },
1046 #endif /* HAS_ACCEL */
1047 #if HAS_LOG
1048         { "l <size>\0Flight log size (kB)",
1049           ao_config_log_set,            ao_config_log_show },
1050 #endif
1051 #if HAS_IGNITE
1052         { "i <0 dual, 1 apogee, 2 main, 3 booster>\0Igniter mode",
1053           ao_config_ignite_mode_set,    ao_config_ignite_mode_show },
1054 #endif
1055 #if HAS_AES
1056         { "k <32 hex digits>\0AES encryption key",
1057           ao_config_key_set, ao_config_key_show },
1058 #endif
1059 #if AO_PYRO_NUM
1060         { "P <n,?>\0Pyro channels",
1061           ao_pyro_set, ao_pyro_show },
1062         { "I <ticks>\0Pyro firing time",
1063           ao_config_pyro_time_set, ao_config_pyro_time_show },
1064 #endif
1065 #if HAS_APRS
1066         { "A <secs>\0APRS packet interval (0 disable)",
1067           ao_config_aprs_set, ao_config_aprs_show },
1068 #endif
1069 #if HAS_BEEP_CONFIG
1070         { "b <val>\0Beeper tone (freq = 1/2 (24e6/32) / beep",
1071           ao_config_beep_set, ao_config_beep_show },
1072 #endif
1073 #if HAS_TRACKER
1074         { "t <motion> <interval>\0Tracker configuration",
1075           ao_config_tracker_set, ao_config_tracker_show },
1076 #endif
1077 #if HAS_APRS
1078         { "S <ssid>\0Set APRS SSID (0-15)",
1079           ao_config_aprs_ssid_set, ao_config_aprs_ssid_show },
1080         { "C <0 compressed, 1 uncompressed>\0APRS format",
1081           ao_config_aprs_format_set, ao_config_aprs_format_show },
1082         { "O <aprs-offset>\0APRS Offset from top of minute",
1083           ao_config_aprs_offset_set, ao_config_aprs_offset_show },
1084 #endif
1085 #if HAS_FIXED_PAD_BOX
1086         { "B <box>\0Set pad box (1-99)",
1087           ao_config_pad_box_set, ao_config_pad_box_show },
1088         { "i <seconds>\0Set idle timeout (0 disable)",
1089           ao_config_pad_idle_set, ao_config_pad_idle_show },
1090 #endif
1091         { "s\0Show",
1092           ao_config_show,               0 },
1093 #if HAS_CONFIG_SAVE
1094         { "w\0Write to eeprom",
1095           ao_config_save,               0 },
1096 #endif
1097         { "?\0Help",
1098           ao_config_help,               0 },
1099         { 0, 0, 0 }
1100 };
1101
1102 static void
1103 ao_config_set(void)
1104 {
1105         char    c;
1106         uint8_t cmd;
1107
1108         ao_cmd_white();
1109         c = ao_cmd_lex_c;
1110         ao_cmd_lex();
1111         for (cmd = 0; ao_config_vars[cmd].str != NULL; cmd++)
1112                 if (ao_config_vars[cmd].str[0] == c) {
1113                         (*ao_config_vars[cmd].set)();
1114                         return;
1115                 }
1116         ao_cmd_status = ao_cmd_syntax_error;
1117 }
1118
1119 static void
1120 ao_config_help(void)
1121 {
1122         uint8_t cmd;
1123         for (cmd = 0; ao_config_vars[cmd].str != NULL; cmd++)
1124                 printf("%-20s %s\n",
1125                        ao_config_vars[cmd].str,
1126                        ao_config_vars[cmd].str+1+
1127                        strlen(ao_config_vars[cmd].str));
1128 }
1129
1130 static void
1131 ao_config_show(void)
1132 {
1133         uint8_t cmd;
1134         ao_config_get();
1135         printf("Config version: %d.%d\n",
1136                ao_config.major, ao_config.minor);
1137         for (cmd = 0; ao_config_vars[cmd].str != NULL; cmd++)
1138                 if (ao_config_vars[cmd].show)
1139                         (*ao_config_vars[cmd].show)();
1140 #if HAS_MS5607
1141         ao_ms5607_info();
1142 #endif
1143 }
1144
1145 #if HAS_CONFIG_SAVE
1146 static void
1147 ao_config_save(void)
1148 {
1149         uint8_t saved = 0;
1150         ao_mutex_get(&ao_config_mutex);
1151         if (ao_config_dirty) {
1152                 _ao_config_put();
1153                 ao_config_dirty = 0;
1154                 saved = 1;
1155         }
1156         ao_mutex_put(&ao_config_mutex);
1157         if (saved)
1158                 puts("Saved");
1159         else
1160                 puts("Nothing to save");
1161 }
1162 #endif
1163
1164 const struct ao_cmds ao_config_cmds[] = {
1165         { ao_config_set,        "c <var> <value>\0Set config (? for help, s to show)" },
1166         { 0, NULL },
1167 };
1168
1169 void
1170 ao_config_init(void)
1171 {
1172         ao_cmd_register(&ao_config_cmds[0]);
1173 }