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