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