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