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