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