git.gag.com Git - fw/altos/blob - src/core/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_storage.h>
  21 #if HAS_FLIGHT
  22 #include <ao_sample.h>
  23 #include <ao_data.h>
  24 #endif
  25
  26 __xdata struct ao_config ao_config;
  27 __pdata uint8_t ao_config_loaded;
  28 __pdata uint8_t ao_config_dirty;
  29 __xdata uint8_t ao_config_mutex;
  30
  31 #define AO_CONFIG_DEFAULT_MAIN_DEPLOY   250
  32 #define AO_CONFIG_DEFAULT_RADIO_CHANNEL 0
  33 #define AO_CONFIG_DEFAULT_CALLSIGN      "N0CALL"
  34 #define AO_CONFIG_DEFAULT_ACCEL_ZERO_G  16000
  35 #define AO_CONFIG_DEFAULT_APOGEE_DELAY  0
  36 #define AO_CONFIG_DEFAULT_IGNITE_MODE   AO_IGNITE_MODE_DUAL
  37 #define AO_CONFIG_DEFAULT_PAD_ORIENTATION       AO_PAD_ORIENTATION_ANTENNA_UP
  38 #if HAS_EEPROM
  39 #ifndef USE_INTERNAL_FLASH
  40 #error Please define USE_INTERNAL_FLASH
  41 #endif
  42 #endif
  43 #ifndef AO_CONFIG_DEFAULT_FLIGHT_LOG_MAX
  44 #if USE_INTERNAL_FLASH
  45 #define AO_CONFIG_DEFAULT_FLIGHT_LOG_MAX        ao_storage_config
  46 #else
  47 #define AO_CONFIG_DEFAULT_FLIGHT_LOG_MAX        ((uint32_t) 192 * (uint32_t) 1024)
  48 #endif
  49 #endif
  50 #define AO_CONFIG_DEFAULT_RADIO_POWER           0x60
  51 #define AO_CONFIG_DEFAULT_RADIO_AMP             0
  52
  53 #if HAS_EEPROM
  54 static void
  55 _ao_config_put(void)
  56 {
  57         ao_storage_setup();
  58         ao_storage_erase(ao_storage_config);
  59         ao_storage_write(ao_storage_config, &ao_config, sizeof (ao_config));
  60 #if HAS_FLIGHT
  61         ao_log_write_erase(0);
  62 #endif
  63         ao_storage_flush();
  64 }
  65
  66 void
  67 ao_config_put(void)
  68 {
  69         ao_mutex_get(&ao_config_mutex);
  70         _ao_config_put();
  71         ao_mutex_put(&ao_config_mutex);
  72 }
  73 #endif
  74
  75 #if HAS_RADIO
  76 void
  77 ao_config_set_radio(void)
  78 {
  79         ao_config.radio_setting = ao_freq_to_set(ao_config.frequency, ao_config.radio_cal);
  80 }
  81 #endif /* HAS_RADIO */
  82
  83 static void
  84 _ao_config_get(void)
  85 {
  86         uint8_t minor;
  87
  88         if (ao_config_loaded)
  89                 return;
  90 #if HAS_EEPROM
  91         /* Yes, I know ao_storage_read calls ao_storage_setup,
  92          * but ao_storage_setup *also* sets ao_storage_config, which we
  93          * need before calling ao_storage_read here
  94          */
  95         ao_storage_setup();
  96         ao_storage_read(ao_storage_config, &ao_config, sizeof (ao_config));
  97 #endif
  98         if (ao_config.major != AO_CONFIG_MAJOR) {
  99                 ao_config.major = AO_CONFIG_MAJOR;
 100                 ao_config.minor = 0;
 101
 102                 /* Version 0 stuff */
 103                 ao_config.main_deploy = AO_CONFIG_DEFAULT_MAIN_DEPLOY;
 104                 ao_xmemset(&ao_config.callsign, '\0', sizeof (ao_config.callsign));
 105                 ao_xmemcpy(&ao_config.callsign, CODE_TO_XDATA(AO_CONFIG_DEFAULT_CALLSIGN),
 106                        sizeof(AO_CONFIG_DEFAULT_CALLSIGN) - 1);
 107                 ao_config._legacy_radio_channel = 0;
 108         }
 109         minor = ao_config.minor;
 110         if (minor != AO_CONFIG_MINOR) {
 111                 /* Fixups for minor version 1 */
 112                 if (minor < 1)
 113                         ao_config.apogee_delay = AO_CONFIG_DEFAULT_APOGEE_DELAY;
 114                 /* Fixups for minor version 2 */
 115                 if (minor < 2) {
 116                         ao_config.accel_plus_g = 0;
 117                         ao_config.accel_minus_g = 0;
 118                 }
 119                 /* Fixups for minor version 3 */
 120 #if HAS_RADIO
 121                 if (minor < 3)
 122                         ao_config.radio_cal = ao_radio_cal;
 123 #endif
 124                 /* Fixups for minor version 4 */
 125                 if (minor < 4)
 126                         ao_config.flight_log_max = AO_CONFIG_DEFAULT_FLIGHT_LOG_MAX;
 127                 /* Fixupes for minor version 5 */
 128                 if (minor < 5)
 129                         ao_config.ignite_mode = AO_CONFIG_DEFAULT_IGNITE_MODE;
 130                 if (minor < 6)
 131                         ao_config.pad_orientation = AO_CONFIG_DEFAULT_PAD_ORIENTATION;
 132                 if (minor < 8)
 133                         ao_config.radio_enable = AO_RADIO_ENABLE_CORE;
 134                 if (minor < 9)
 135                         ao_xmemset(&ao_config.aes_key, '\0', AO_AES_LEN);
 136                 if (minor < 10)
 137                         ao_config.frequency = 434550 + ao_config._legacy_radio_channel * 100;
 138                 if (minor < 11)
 139                         ao_config.apogee_lockout = 0;
 140 #if AO_PYRO_NUM
 141                 if (minor < 12)
 142                         memset(&ao_config.pyro, '\0', sizeof (ao_config.pyro));
 143 #endif
 144                 if (minor < 13)
 145                         ao_config.aprs_interval = 0;
 146 #if HAS_RADIO_POWER
 147                 if (minor < 14)
 148                         ao_config.radio_power = AO_CONFIG_DEFAULT_RADIO_POWER;
 149                 #endif
 150 #if HAS_RADIO_AMP
 151                 if (minor  < 14)
 152                         ao_config.radio_amp = AO_CONFIG_DEFAULT_RADIO_AMP;
 153 #endif
 154                 ao_config.minor = AO_CONFIG_MINOR;
 155                 ao_config_dirty = 1;
 156         }
 157 #if HAS_RADIO
 158 #if HAS_FORCE_FREQ
 159         if (ao_force_freq) {
 160                 ao_config.frequency = 434550;
 161                 ao_config.radio_cal = ao_radio_cal;
 162                 ao_xmemcpy(&ao_config.callsign, CODE_TO_XDATA(AO_CONFIG_DEFAULT_CALLSIGN),
 163                        sizeof(AO_CONFIG_DEFAULT_CALLSIGN) - 1);
 164         }
 165 #endif
 166         ao_config_set_radio();
 167 #endif
 168         ao_config_loaded = 1;
 169 }
 170
 171 void
 172 _ao_config_edit_start(void)
 173 {
 174         ao_mutex_get(&ao_config_mutex);
 175         _ao_config_get();
 176 }
 177
 178 void
 179 _ao_config_edit_finish(void)
 180 {
 181         ao_config_dirty = 1;
 182         ao_mutex_put(&ao_config_mutex);
 183 }
 184
 185 void
 186 ao_config_get(void)
 187 {
 188         _ao_config_edit_start();
 189         ao_mutex_put(&ao_config_mutex);
 190 }
 191
 192 void
 193 ao_config_callsign_show(void)
 194 {
 195         printf ("Callsign: \"%s\"\n", ao_config.callsign);
 196 }
 197
 198 void
 199 ao_config_callsign_set(void) __reentrant
 200 {
 201         uint8_t c;
 202         static __xdata char callsign[AO_MAX_CALLSIGN + 1];
 203
 204         ao_xmemset(callsign, '\0', sizeof callsign);
 205         ao_cmd_white();
 206         c = 0;
 207         while (ao_cmd_lex_c != '\n') {
 208                 if (c < AO_MAX_CALLSIGN)
 209                         callsign[c++] = ao_cmd_lex_c;
 210                 else
 211                         ao_cmd_status = ao_cmd_lex_error;
 212                 ao_cmd_lex();
 213         }
 214         if (ao_cmd_status != ao_cmd_success)
 215                 return;
 216         _ao_config_edit_start();
 217         ao_xmemcpy(&ao_config.callsign, &callsign,
 218                AO_MAX_CALLSIGN + 1);
 219         _ao_config_edit_finish();
 220 }
 221
 222 #if HAS_RADIO
 223
 224 void
 225 ao_config_frequency_show(void) __reentrant
 226 {
 227         printf("Frequency: %ld\n",
 228                ao_config.frequency);
 229 }
 230
 231 void
 232 ao_config_frequency_set(void) __reentrant
 233 {
 234         ao_cmd_decimal();
 235         if (ao_cmd_status != ao_cmd_success)
 236                 return;
 237         _ao_config_edit_start();
 238         ao_config.frequency = ao_cmd_lex_u32;
 239         ao_config_set_radio();
 240         _ao_config_edit_finish();
 241 #if HAS_RADIO_RECV
 242         ao_radio_recv_abort();
 243 #endif
 244 }
 245 #endif
 246
 247 #if HAS_FLIGHT
 248
 249 void
 250 ao_config_main_deploy_show(void) __reentrant
 251 {
 252         printf("Main deploy: %d meters\n",
 253                ao_config.main_deploy);
 254 }
 255
 256 void
 257 ao_config_main_deploy_set(void) __reentrant
 258 {
 259         ao_cmd_decimal();
 260         if (ao_cmd_status != ao_cmd_success)
 261                 return;
 262         _ao_config_edit_start();
 263         ao_config.main_deploy = ao_cmd_lex_i;
 264         _ao_config_edit_finish();
 265 }
 266
 267 #if HAS_ACCEL
 268 void
 269 ao_config_accel_calibrate_show(void) __reentrant
 270 {
 271         printf("Accel cal +1g: %d -1g: %d\n",
 272                ao_config.accel_plus_g, ao_config.accel_minus_g);
 273 }
 274
 275 #define ACCEL_CALIBRATE_SAMPLES 1024
 276 #define ACCEL_CALIBRATE_SHIFT   10
 277
 278 static int16_t
 279 ao_config_accel_calibrate_auto(char *orientation) __reentrant
 280 {
 281         uint16_t        i;
 282         int32_t         accel_total;
 283         uint8_t         cal_data_ring;
 284
 285         printf("Orient antenna %s and press a key...", orientation);
 286         flush();
 287         (void) getchar();
 288         puts("\r\n"); flush();
 289         puts("Calibrating..."); flush();
 290         i = ACCEL_CALIBRATE_SAMPLES;
 291         accel_total = 0;
 292         cal_data_ring = ao_sample_data;
 293         while (i) {
 294                 ao_sleep(DATA_TO_XDATA(&ao_sample_data));
 295                 while (i && cal_data_ring != ao_sample_data) {
 296                         accel_total += (int32_t) ao_data_accel(&ao_data_ring[cal_data_ring]);
 297                         cal_data_ring = ao_data_ring_next(cal_data_ring);
 298                         i--;
 299                 }
 300         }
 301         return accel_total >> ACCEL_CALIBRATE_SHIFT;
 302 }
 303
 304 void
 305 ao_config_accel_calibrate_set(void) __reentrant
 306 {
 307         int16_t up, down;
 308         ao_cmd_decimal();
 309         if (ao_cmd_status != ao_cmd_success)
 310                 return;
 311         if (ao_cmd_lex_i == 0) {
 312                 up = ao_config_accel_calibrate_auto("up");
 313                 down = ao_config_accel_calibrate_auto("down");
 314         } else {
 315                 up = ao_cmd_lex_i;
 316                 ao_cmd_decimal();
 317                 if (ao_cmd_status != ao_cmd_success)
 318                         return;
 319                 down = ao_cmd_lex_i;
 320         }
 321         if (up >= down) {
 322                 printf("Invalid accel: up (%d) down (%d)\n",
 323                        up, down);
 324                 return;
 325         }
 326         _ao_config_edit_start();
 327         ao_config.accel_plus_g = up;
 328         ao_config.accel_minus_g = down;
 329         _ao_config_edit_finish();
 330 }
 331 #endif /* HAS_ACCEL */
 332
 333 void
 334 ao_config_apogee_delay_show(void) __reentrant
 335 {
 336         printf("Apogee delay: %d seconds\n",
 337                ao_config.apogee_delay);
 338 }
 339
 340 void
 341 ao_config_apogee_delay_set(void) __reentrant
 342 {
 343         ao_cmd_decimal();
 344         if (ao_cmd_status != ao_cmd_success)
 345                 return;
 346         _ao_config_edit_start();
 347         ao_config.apogee_delay = ao_cmd_lex_i;
 348         _ao_config_edit_finish();
 349 }
 350
 351 void
 352 ao_config_apogee_lockout_show(void) __reentrant
 353 {
 354         printf ("Apogee lockout: %d seconds\n",
 355                 ao_config.apogee_lockout);
 356 }
 357
 358 void
 359 ao_config_apogee_lockout_set(void) __reentrant
 360 {
 361         ao_cmd_decimal();
 362         if (ao_cmd_status != ao_cmd_success)
 363                 return;
 364         _ao_config_edit_start();
 365         ao_config.apogee_lockout = ao_cmd_lex_i;
 366         _ao_config_edit_finish();
 367 }
 368
 369 #endif /* HAS_FLIGHT */
 370
 371 #if HAS_RADIO
 372 void
 373 ao_config_radio_cal_show(void) __reentrant
 374 {
 375         printf("Radio cal: %ld\n", ao_config.radio_cal);
 376 }
 377
 378 void
 379 ao_config_radio_cal_set(void) __reentrant
 380 {
 381         ao_cmd_decimal();
 382         if (ao_cmd_status != ao_cmd_success)
 383                 return;
 384         _ao_config_edit_start();
 385         ao_config.radio_cal = ao_cmd_lex_u32;
 386         ao_config_set_radio();
 387         _ao_config_edit_finish();
 388 }
 389 #endif
 390
 391 #if HAS_LOG
 392 void
 393 ao_config_log_show(void) __reentrant
 394 {
 395         printf("Max flight log: %d kB\n", (int16_t) (ao_config.flight_log_max >> 10));
 396 }
 397
 398 void
 399 ao_config_log_set(void) __reentrant
 400 {
 401         uint16_t        block = (uint16_t) (ao_storage_block >> 10);
 402         uint16_t        config = (uint16_t) (ao_storage_config >> 10);
 403
 404         ao_cmd_decimal();
 405         if (ao_cmd_status != ao_cmd_success)
 406                 return;
 407         if (ao_log_present())
 408                 printf("Storage must be empty before changing log size\n");
 409         else if (block > 1024 && (ao_cmd_lex_i & (block - 1)))
 410                 printf("Flight log size must be multiple of %d kB\n", block);
 411         else if (ao_cmd_lex_i > config)
 412                 printf("Flight log max %d kB\n", config);
 413         else {
 414                 _ao_config_edit_start();
 415                 ao_config.flight_log_max = (uint32_t) ao_cmd_lex_i << 10;
 416                 _ao_config_edit_finish();
 417         }
 418 }
 419 #endif /* HAS_LOG */
 420
 421 #if HAS_IGNITE
 422 void
 423 ao_config_ignite_mode_show(void) __reentrant
 424 {
 425         printf("Ignite mode: %d\n", ao_config.ignite_mode);
 426 }
 427
 428 void
 429 ao_config_ignite_mode_set(void) __reentrant
 430 {
 431         ao_cmd_decimal();
 432         if (ao_cmd_status != ao_cmd_success)
 433                 return;
 434         _ao_config_edit_start();
 435         ao_config.ignite_mode = ao_cmd_lex_i;
 436         _ao_config_edit_finish();
 437 }
 438 #endif
 439
 440 #if HAS_ACCEL
 441 void
 442 ao_config_pad_orientation_show(void) __reentrant
 443 {
 444         printf("Pad orientation: %d\n", ao_config.pad_orientation);
 445 }
 446
 447 void
 448 ao_config_pad_orientation_set(void) __reentrant
 449 {
 450         ao_cmd_decimal();
 451         if (ao_cmd_status != ao_cmd_success)
 452                 return;
 453         _ao_config_edit_start();
 454         ao_cmd_lex_i &= 1;
 455         if (ao_config.pad_orientation != ao_cmd_lex_i) {
 456                 uint16_t t;
 457                 t = ao_config.accel_plus_g;
 458                 ao_config.accel_plus_g = 0x7fff - ao_config.accel_minus_g;
 459                 ao_config.accel_minus_g = 0x7fff - t;
 460         }
 461         ao_config.pad_orientation = ao_cmd_lex_i;
 462         _ao_config_edit_finish();
 463 }
 464 #endif
 465
 466 #if HAS_RADIO
 467 void
 468 ao_config_radio_enable_show(void) __reentrant
 469 {
 470         printf("Radio enable: %d\n", ao_config.radio_enable);
 471 }
 472
 473 void
 474 ao_config_radio_enable_set(void) __reentrant
 475 {
 476         ao_cmd_decimal();
 477         if (ao_cmd_status != ao_cmd_success)
 478                 return;
 479         _ao_config_edit_start();
 480         ao_config.radio_enable = ao_cmd_lex_i;
 481         _ao_config_edit_finish();
 482 }
 483 #endif /* HAS_RADIO */
 484
 485 #if HAS_AES
 486
 487 __xdata uint8_t ao_config_aes_seq = 1;
 488
 489 void
 490 ao_config_key_show(void) __reentrant
 491 {
 492         uint8_t i;
 493         printf("AES key: ");
 494         for (i = 0; i < AO_AES_LEN; i++)
 495                 printf ("%02x", ao_config.aes_key[i]);
 496         printf("\n");
 497 }
 498
 499 void
 500 ao_config_key_set(void) __reentrant
 501 {
 502         uint8_t i;
 503
 504         _ao_config_edit_start();
 505         for (i = 0; i < AO_AES_LEN; i++) {
 506                 ao_cmd_hexbyte();
 507                 if (ao_cmd_status != ao_cmd_success)
 508                         break;
 509                 ao_config.aes_key[i] = ao_cmd_lex_i;
 510         }
 511         ++ao_config_aes_seq;
 512         _ao_config_edit_finish();
 513 }
 514 #endif
 515
 516 #if HAS_APRS
 517
 518 void
 519 ao_config_aprs_show(void)
 520 {
 521         printf ("APRS interval: %d\n", ao_config.aprs_interval);
 522 }
 523
 524 void
 525 ao_config_aprs_set(void)
 526 {
 527         ao_cmd_decimal();
 528         if (ao_cmd_status != ao_cmd_success)
 529                 return;
 530         _ao_config_edit_start();
 531         ao_config.aprs_interval = ao_cmd_lex_i;
 532         _ao_config_edit_finish();
 533 }
 534
 535 #endif /* HAS_APRS */
 536
 537 #if HAS_RADIO_AMP
 538
 539 void
 540 ao_config_radio_amp_show(void)
 541 {
 542         printf ("Radio amp setting: %d\n", ao_config.radio_amp);
 543 }
 544
 545 void
 546 ao_config_radio_amp_set(void)
 547 {
 548         ao_cmd_decimal();
 549         if (ao_cmd_status != ao_cmd_success)
 550                 return;
 551         _ao_config_edit_start();
 552         ao_config.radio_amp = ao_cmd_lex_i;
 553         _ao_config_edit_finish();
 554 }
 555
 556 #endif
 557
 558 #if HAS_RADIO_POWER
 559
 560 void
 561 ao_config_radio_power_show(void)
 562 {
 563         printf ("Radio power setting: %d\n", ao_config.radio_power);
 564 }
 565
 566 void
 567 ao_config_radio_power_set(void)
 568 {
 569         ao_cmd_decimal();
 570         if (ao_cmd_status != ao_cmd_success)
 571                 return;
 572         _ao_config_edit_start();
 573         ao_config.radio_power = ao_cmd_lex_i;
 574         _ao_config_edit_finish();
 575 }
 576
 577 #endif
 578
 579 struct ao_config_var {
 580         __code char     *str;
 581         void            (*set)(void) __reentrant;
 582         void            (*show)(void) __reentrant;
 583 };
 584
 585 static void
 586 ao_config_help(void) __reentrant;
 587
 588 static void
 589 ao_config_show(void) __reentrant;
 590
 591 static void
 592 ao_config_write(void) __reentrant;
 593
 594 __code struct ao_config_var ao_config_vars[] = {
 595 #if HAS_FLIGHT
 596         { "m <meters>\0Main deploy (m)",
 597           ao_config_main_deploy_set,    ao_config_main_deploy_show, },
 598         { "d <delay>\0Apogee delay (s)",
 599           ao_config_apogee_delay_set,   ao_config_apogee_delay_show },
 600         { "L <seconds>\0Apogee detect lockout (s)",
 601           ao_config_apogee_lockout_set, ao_config_apogee_lockout_show, },
 602 #endif /* HAS_FLIGHT */
 603 #if HAS_RADIO
 604         { "F <freq>\0Frequency (kHz)",
 605           ao_config_frequency_set, ao_config_frequency_show },
 606         { "c <call>\0Callsign (8 char max)",
 607           ao_config_callsign_set,       ao_config_callsign_show },
 608         { "e <0 disable, 1 enable>\0Enable telemetry and RDF",
 609           ao_config_radio_enable_set, ao_config_radio_enable_show },
 610         { "f <cal>\0Radio calib (cal = rf/(xtal/2^16))",
 611           ao_config_radio_cal_set,      ao_config_radio_cal_show },
 612 #if HAS_RADIO_POWER
 613         { "p <setting>\0Radio power setting (0-255)",
 614           ao_config_radio_power_set,    ao_config_radio_power_show },
 615 #endif
 616 #if HAS_RADIO_AMP
 617         { "d <setting>\0Radio amplifier setting (0-3)",
 618           ao_config_radio_amp_set,      ao_config_radio_amp_show },
 619 #endif
 620 #endif /* HAS_RADIO */
 621 #if HAS_ACCEL
 622         { "a <+g> <-g>\0Accel calib (0 for auto)",
 623           ao_config_accel_calibrate_set,ao_config_accel_calibrate_show },
 624         { "o <0 antenna up, 1 antenna down>\0Set pad orientation",
 625           ao_config_pad_orientation_set,ao_config_pad_orientation_show },
 626 #endif /* HAS_ACCEL */
 627 #if HAS_LOG
 628         { "l <size>\0Flight log size (kB)",
 629           ao_config_log_set,            ao_config_log_show },
 630 #endif
 631 #if HAS_IGNITE
 632         { "i <0 dual, 1 apogee, 2 main>\0Set igniter mode",
 633           ao_config_ignite_mode_set,    ao_config_ignite_mode_show },
 634 #endif
 635 #if HAS_AES
 636         { "k <32 hex digits>\0Set AES encryption key",
 637           ao_config_key_set, ao_config_key_show },
 638 #endif
 639 #if AO_PYRO_NUM
 640         { "P <n,?>\0Configure pyro channels",
 641           ao_pyro_set, ao_pyro_show },
 642 #endif
 643 #if HAS_APRS
 644         { "A <secs>\0APRS packet interval (0 disable)",
 645           ao_config_aprs_set, ao_config_aprs_show },
 646 #endif
 647         { "s\0Show",
 648           ao_config_show,               0 },
 649 #if HAS_EEPROM
 650         { "w\0Write to eeprom",
 651           ao_config_write,              0 },
 652 #endif
 653         { "?\0Help",
 654           ao_config_help,               0 },
 655         { 0, 0, 0 }
 656 };
 657
 658 void
 659 ao_config_set(void)
 660 {
 661         char    c;
 662         uint8_t cmd;
 663
 664         ao_cmd_white();
 665         c = ao_cmd_lex_c;
 666         ao_cmd_lex();
 667         for (cmd = 0; ao_config_vars[cmd].str != NULL; cmd++)
 668                 if (ao_config_vars[cmd].str[0] == c) {
 669                         (*ao_config_vars[cmd].set)();
 670                         return;
 671                 }
 672         ao_cmd_status = ao_cmd_syntax_error;
 673 }
 674
 675 static void
 676 ao_config_help(void) __reentrant
 677 {
 678         uint8_t cmd;
 679         for (cmd = 0; ao_config_vars[cmd].str != NULL; cmd++)
 680                 printf("%-20s %s\n",
 681                        ao_config_vars[cmd].str,
 682                        ao_config_vars[cmd].str+1+
 683                        strlen(ao_config_vars[cmd].str));
 684 }
 685
 686 static void
 687 ao_config_show(void) __reentrant
 688 {
 689         uint8_t cmd;
 690         ao_config_get();
 691         printf("Config version: %d.%d\n",
 692                ao_config.major, ao_config.minor);
 693         for (cmd = 0; ao_config_vars[cmd].str != NULL; cmd++)
 694                 if (ao_config_vars[cmd].show)
 695                         (*ao_config_vars[cmd].show)();
 696 #if HAS_MS5607
 697         ao_ms5607_info();
 698 #endif
 699 }
 700
 701 #if HAS_EEPROM
 702 static void
 703 ao_config_write(void) __reentrant
 704 {
 705         uint8_t saved = 0;
 706         ao_mutex_get(&ao_config_mutex);
 707         if (ao_config_dirty) {
 708                 _ao_config_put();
 709                 ao_config_dirty = 0;
 710                 saved = 1;
 711         }
 712         ao_mutex_put(&ao_config_mutex);
 713         if (saved)
 714                 puts("Saved");
 715         else
 716                 puts("Nothing to save");
 717 }
 718 #endif
 719
 720 __code struct ao_cmds ao_config_cmds[] = {
 721         { ao_config_set,        "c <var> <value>\0Set config (? for help, s to show)" },
 722         { 0, NULL },
 723 };
 724
 725 void
 726 ao_config_init(void)
 727 {
 728         ao_cmd_register(&ao_config_cmds[0]);
 729 }