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