src/lib/CONFIG/config.cpp

   1 #include "config.h"
   2 #include "config_legacy.h"
   3 #include "common.h"
   4 #include "POWERMGNT.h"
   5 #include "OTA.h"
   6 #include "helpers.h"
   7 #include "logging.h"
   8
   9 #if defined(TARGET_TX)
  10
  11 #define MODEL_CHANGED       bit(1)
  12 #define VTX_CHANGED         bit(2)
  13 #define MAIN_CHANGED        bit(3) // catch-all for global config item
  14 #define FAN_CHANGED         bit(4)
  15 #define MOTION_CHANGED      bit(5)
  16 #define BUTTON_CHANGED      bit(6)
  17 #define ALL_CHANGED         (MODEL_CHANGED | VTX_CHANGED | MAIN_CHANGED | FAN_CHANGED | MOTION_CHANGED | BUTTON_CHANGED)
  18
  19 // Really awful but safe(?) type punning of model_config_t/v6_model_config_t to and from uint32_t
  20 template<class T> static const void U32_to_Model(uint32_t const u32, T * const model)
  21 {
  22     union {
  23         union {
  24             T model;
  25             uint8_t padding[sizeof(uint32_t)-sizeof(T)];
  26         } val;
  27         uint32_t u32;
  28     } converter = { .u32 = u32 };
  29
  30     *model = converter.val.model;
  31 }
  32
  33 template<class T> static const uint32_t Model_to_U32(T const * const model)
  34 {
  35     // clear the entire union because the assignment will only fill sizeof(T)
  36     union {
  37         union {
  38             T model;
  39             uint8_t padding[sizeof(uint32_t)-sizeof(T)];
  40         } val;
  41         uint32_t u32;
  42     } converter = { 0 };
  43
  44     converter.val.model = *model;
  45     return converter.u32;
  46 }
  47
  48 static uint8_t RateV6toV7(uint8_t rateV6)
  49 {
  50 #if defined(RADIO_SX127X)
  51     if (rateV6 == 0)
  52     {
  53         // 200Hz stays same
  54         return 0;
  55     }
  56
  57     // 100Hz, 50Hz, 25Hz all move up one
  58     // to make room for 100Hz Full
  59     return rateV6 + 1;
  60 #else // RADIO_2400
  61     switch (rateV6)
  62     {
  63         case 0: return 4; // 500Hz
  64         case 1: return 6; // 250Hz
  65         case 2: return 7; // 150Hz
  66         case 3: return 9; // 50Hz
  67         default: return 4; // 500Hz
  68     }
  69 #endif // RADIO_2400
  70 }
  71
  72 static uint8_t RatioV6toV7(uint8_t ratioV6)
  73 {
  74     // All shifted up for Std telem
  75     return ratioV6 + 1;
  76 }
  77
  78 static uint8_t SwitchesV6toV7(uint8_t switchesV6)
  79 {
  80     // 0 was removed, Wide(2) became 0, Hybrid(1) became 1
  81     switch (switchesV6)
  82     {
  83         case 1: return (uint8_t)smHybridOr16ch;
  84         case 2:
  85         default:
  86             return (uint8_t)smWideOr8ch;
  87     }
  88 }
  89
  90 static void ModelV6toV7(v6_model_config_t const * const v6, model_config_t * const v7)
  91 {
  92     v7->rate = RateV6toV7(v6->rate);
  93     v7->tlm = RatioV6toV7(v6->tlm);
  94     v7->power = v6->power;
  95     v7->switchMode = SwitchesV6toV7(v6->switchMode);
  96     v7->modelMatch = v6->modelMatch;
  97     v7->dynamicPower = v6->dynamicPower;
  98     v7->boostChannel = v6->boostChannel;
  99 }
 100
 101 TxConfig::TxConfig() :
 102     m_model(m_config.model_config)
 103 {
 104 }
 105
 106 #if defined(PLATFORM_ESP32)
 107 void TxConfig::Load()
 108 {
 109     m_modified = 0;
 110
 111     // Initialize NVS
 112     esp_err_t err = nvs_flash_init();
 113     if (err == ESP_ERR_NVS_NO_FREE_PAGES || err == ESP_ERR_NVS_NEW_VERSION_FOUND)
 114     {
 115         ESP_ERROR_CHECK(nvs_flash_erase());
 116         err = nvs_flash_init();
 117     }
 118     ESP_ERROR_CHECK( err );
 119     ESP_ERROR_CHECK(nvs_open("ELRS", NVS_READWRITE, &handle));
 120
 121     // Try to load the version and make sure it is a TX config
 122     uint32_t version = 0;
 123     if (nvs_get_u32(handle, "tx_version", &version) == ESP_OK && ((version & CONFIG_MAGIC_MASK) == TX_CONFIG_MAGIC))
 124         version = version & ~CONFIG_MAGIC_MASK;
 125     DBGLN("Config version %u", version);
 126
 127     // Can't upgrade from version <5, or when flashing a previous version, just use defaults.
 128     if (version < 5 || version > TX_CONFIG_VERSION)
 129     {
 130         SetDefaults(true);
 131         return;
 132     }
 133
 134     SetDefaults(false);
 135
 136     uint32_t value;
 137     uint8_t value8;
 138     // vtx (v5)
 139     if (nvs_get_u32(handle, "vtx", &value) == ESP_OK)
 140     {
 141         m_config.vtxBand = value >> 24;
 142         m_config.vtxChannel = value >> 16;
 143         m_config.vtxPower = value >> 8;
 144         m_config.vtxPitmode = value;
 145     }
 146
 147     // fanthresh (v5)
 148     if (nvs_get_u8(handle, "fanthresh", &value8) == ESP_OK)
 149         m_config.powerFanThreshold = value8;
 150
 151     // Both of these were added to config v5 without incrementing the version
 152     if (nvs_get_u32(handle, "fan", &value) == ESP_OK)
 153         m_config.fanMode = value;
 154     if (nvs_get_u32(handle, "motion", &value) == ESP_OK)
 155         m_config.motionMode = value;
 156
 157     if (version >= 6)
 158     {
 159         // dvr (v6)
 160         if (nvs_get_u8(handle, "dvraux", &value8) == ESP_OK)
 161             m_config.dvrAux = value8;
 162         if (nvs_get_u8(handle, "dvrstartdelay", &value8) == ESP_OK)
 163             m_config.dvrStartDelay = value8;
 164         if (nvs_get_u8(handle, "dvrstopdelay", &value8) == ESP_OK)
 165             m_config.dvrStopDelay = value8;
 166     }
 167     else
 168     {
 169         // Need to write the dvr defaults
 170         m_modified |= MAIN_CHANGED;
 171     }
 172
 173     if (version >= 7) {
 174         // load button actions
 175         if (nvs_get_u32(handle, "button1", &value) == ESP_OK)
 176             m_config.buttonColors[0].raw = value;
 177         if (nvs_get_u32(handle, "button2", &value) == ESP_OK)
 178             m_config.buttonColors[1].raw = value;
 179         // backpackdisable was actually added after 7, but if not found will default to 0 (enabled)
 180         if (nvs_get_u8(handle, "backpackdisable", &value8) == ESP_OK)
 181             m_config.backpackDisable = value8;
 182     }
 183
 184     for(unsigned i=0; i<64; i++)
 185     {
 186         char model[10] = "model";
 187         itoa(i, model+5, 10);
 188         if (nvs_get_u32(handle, model, &value) == ESP_OK)
 189         {
 190             if (version >= 7)
 191             {
 192                 U32_to_Model(value, &m_config.model_config[i]);
 193             }
 194             else
 195             {
 196                 // Upgrade v6 to v7 directly writing to nvs instead of calling Commit() over and over
 197                 v6_model_config_t v6model;
 198                 U32_to_Model(value, &v6model);
 199                 model_config_t * const newModel = &m_config.model_config[i];
 200                 ModelV6toV7(&v6model, newModel);
 201                 nvs_set_u32(handle, model, Model_to_U32(newModel));
 202             }
 203         }
 204     } // for each model
 205
 206     if (version != TX_CONFIG_VERSION)
 207     {
 208         Commit();
 209     }
 210 }
 211 #else  // STM32/ESP8266
 212 void TxConfig::Load()
 213 {
 214     m_modified = 0;
 215     m_eeprom->Get(0, m_config);
 216
 217     uint32_t version = 0;
 218     if ((m_config.version & CONFIG_MAGIC_MASK) == TX_CONFIG_MAGIC)
 219         version = m_config.version & ~CONFIG_MAGIC_MASK;
 220     DBGLN("Config version %u", version);
 221
 222     // If version is current, all done
 223     if (version == TX_CONFIG_VERSION)
 224         return;
 225
 226     // Can't upgrade from version <5, or when flashing a previous version, just use defaults.
 227     if (version < 5 || version > TX_CONFIG_VERSION)
 228     {
 229         SetDefaults(true);
 230         return;
 231     }
 232
 233     // Upgrade EEPROM, starting with defaults
 234     SetDefaults(false);
 235
 236     if (version == 5)
 237     {
 238         UpgradeEepromV5ToV6();
 239         version = 6;
 240     }
 241
 242     if (version == 6)
 243     {
 244         UpgradeEepromV6ToV7();
 245     }
 246 }
 247
 248 void TxConfig::UpgradeEepromV5ToV6()
 249 {
 250     v5_tx_config_t v5Config;
 251     v6_tx_config_t v6Config = { 0 }; // default the new fields to 0
 252
 253     // Populate the prev version struct from eeprom
 254     m_eeprom->Get(0, v5Config);
 255
 256     // Copy prev values to current config struct
 257     // This only workse because v5 and v6 are the same up to the new fields
 258     // which have already been set to 0
 259     memcpy(&v6Config, &v5Config, sizeof(v5Config));
 260     v6Config.version = 6U | TX_CONFIG_MAGIC;
 261     m_eeprom->Put(0, v6Config);
 262     m_eeprom->Commit();
 263 }
 264
 265 void TxConfig::UpgradeEepromV6ToV7()
 266 {
 267     v6_tx_config_t v6Config;
 268
 269     // Populate the prev version struct from eeprom
 270     m_eeprom->Get(0, v6Config);
 271
 272     // Manual field copying as some fields have moved
 273     #define LAZY(member) m_config.member = v6Config.member
 274     LAZY(vtxBand);
 275     LAZY(vtxChannel);
 276     LAZY(vtxPower);
 277     LAZY(vtxPitmode);
 278     LAZY(powerFanThreshold);
 279     LAZY(fanMode);
 280     LAZY(motionMode);
 281     LAZY(dvrAux);
 282     LAZY(dvrStartDelay);
 283     LAZY(dvrStopDelay);
 284     #undef LAZY
 285
 286     for (unsigned i=0; i<64; i++)
 287     {
 288         ModelV6toV7(&v6Config.model_config[i], &m_config.model_config[i]);
 289     }
 290
 291     m_modified = ALL_CHANGED;
 292
 293     // Full Commit now
 294     m_config.version = 7U | TX_CONFIG_MAGIC;
 295     Commit();
 296 }
 297 #endif
 298
 299 void
 300 TxConfig::Commit()
 301 {
 302     if (!m_modified)
 303     {
 304         // No changes
 305         return;
 306     }
 307 #if defined(PLATFORM_ESP32)
 308     // Write parts to NVS
 309     if (m_modified & MODEL_CHANGED)
 310     {
 311         uint32_t value = Model_to_U32(m_model);
 312         char model[10] = "model";
 313         itoa(m_modelId, model+5, 10);
 314         nvs_set_u32(handle, model, value);
 315     }
 316     if (m_modified & VTX_CHANGED)
 317     {
 318         uint32_t value =
 319             m_config.vtxBand << 24 |
 320             m_config.vtxChannel << 16 |
 321             m_config.vtxPower << 8 |
 322             m_config.vtxPitmode;
 323         nvs_set_u32(handle, "vtx", value);
 324     }
 325     if (m_modified & FAN_CHANGED)
 326     {
 327         uint32_t value = m_config.fanMode;
 328         nvs_set_u32(handle, "fan", value);
 329     }
 330     if (m_modified & MOTION_CHANGED)
 331     {
 332         uint32_t value = m_config.motionMode;
 333         nvs_set_u32(handle, "motion", value);
 334     }
 335     if (m_modified & MAIN_CHANGED)
 336     {
 337         nvs_set_u8(handle, "fanthresh", m_config.powerFanThreshold);
 338
 339         nvs_set_u8(handle, "backpackdisable", m_config.backpackDisable);
 340         nvs_set_u8(handle, "dvraux", m_config.dvrAux);
 341         nvs_set_u8(handle, "dvrstartdelay", m_config.dvrStartDelay);
 342         nvs_set_u8(handle, "dvrstopdelay", m_config.dvrStopDelay);
 343     }
 344     if (m_modified & BUTTON_CHANGED)
 345     {
 346         nvs_set_u32(handle, "button1", m_config.buttonColors[0].raw);
 347         nvs_set_u32(handle, "button2", m_config.buttonColors[1].raw);
 348     }
 349     nvs_set_u32(handle, "tx_version", m_config.version);
 350     nvs_commit(handle);
 351 #else
 352     // Write the struct to eeprom
 353     m_eeprom->Put(0, m_config);
 354     m_eeprom->Commit();
 355 #endif
 356     m_modified = 0;
 357 }
 358
 359 // Setters
 360 void
 361 TxConfig::SetRate(uint8_t rate)
 362 {
 363     if (GetRate() != rate)
 364     {
 365         m_model->rate = rate;
 366         m_modified |= MODEL_CHANGED;
 367     }
 368 }
 369
 370 void
 371 TxConfig::SetTlm(uint8_t tlm)
 372 {
 373     if (GetTlm() != tlm)
 374     {
 375         m_model->tlm = tlm;
 376         m_modified |= MODEL_CHANGED;
 377     }
 378 }
 379
 380 void
 381 TxConfig::SetPower(uint8_t power)
 382 {
 383     if (GetPower() != power)
 384     {
 385         m_model->power = power;
 386         m_modified |= MODEL_CHANGED;
 387     }
 388 }
 389
 390 void
 391 TxConfig::SetDynamicPower(bool dynamicPower)
 392 {
 393     if (GetDynamicPower() != dynamicPower)
 394     {
 395         m_model->dynamicPower = dynamicPower;
 396         m_modified |= MODEL_CHANGED;
 397     }
 398 }
 399
 400 void
 401 TxConfig::SetBoostChannel(uint8_t boostChannel)
 402 {
 403     if (GetBoostChannel() != boostChannel)
 404     {
 405         m_model->boostChannel = boostChannel;
 406         m_modified |= MODEL_CHANGED;
 407     }
 408 }
 409
 410 void
 411 TxConfig::SetSwitchMode(uint8_t switchMode)
 412 {
 413     if (GetSwitchMode() != switchMode)
 414     {
 415         m_model->switchMode = switchMode;
 416         m_modified |= MODEL_CHANGED;
 417     }
 418 }
 419
 420 void
 421 TxConfig::SetAntennaMode(uint8_t txAntenna)
 422 {
 423     if (GetAntennaMode() != txAntenna)
 424     {
 425         m_model->txAntenna = txAntenna;
 426         m_modified |= MODEL_CHANGED;
 427     }
 428 }
 429
 430 void
 431 TxConfig::SetModelMatch(bool modelMatch)
 432 {
 433     if (GetModelMatch() != modelMatch)
 434     {
 435         m_model->modelMatch = modelMatch;
 436         m_modified |= MODEL_CHANGED;
 437     }
 438 }
 439
 440 void
 441 TxConfig::SetVtxBand(uint8_t vtxBand)
 442 {
 443     if (m_config.vtxBand != vtxBand)
 444     {
 445         m_config.vtxBand = vtxBand;
 446         m_modified |= VTX_CHANGED;
 447     }
 448 }
 449
 450 void
 451 TxConfig::SetVtxChannel(uint8_t vtxChannel)
 452 {
 453     if (m_config.vtxChannel != vtxChannel)
 454     {
 455         m_config.vtxChannel = vtxChannel;
 456         m_modified |= VTX_CHANGED;
 457     }
 458 }
 459
 460 void
 461 TxConfig::SetVtxPower(uint8_t vtxPower)
 462 {
 463     if (m_config.vtxPower != vtxPower)
 464     {
 465         m_config.vtxPower = vtxPower;
 466         m_modified |= VTX_CHANGED;
 467     }
 468 }
 469
 470 void
 471 TxConfig::SetVtxPitmode(uint8_t vtxPitmode)
 472 {
 473     if (m_config.vtxPitmode != vtxPitmode)
 474     {
 475         m_config.vtxPitmode = vtxPitmode;
 476         m_modified |= VTX_CHANGED;
 477     }
 478 }
 479
 480 void
 481 TxConfig::SetPowerFanThreshold(uint8_t powerFanThreshold)
 482 {
 483     if (m_config.powerFanThreshold != powerFanThreshold)
 484     {
 485         m_config.powerFanThreshold = powerFanThreshold;
 486         m_modified |= MAIN_CHANGED;
 487     }
 488 }
 489
 490 void
 491 TxConfig::SetStorageProvider(ELRS_EEPROM *eeprom)
 492 {
 493     if (eeprom)
 494     {
 495         m_eeprom = eeprom;
 496     }
 497 }
 498
 499 void
 500 TxConfig::SetFanMode(uint8_t fanMode)
 501 {
 502     if (m_config.fanMode != fanMode)
 503     {
 504         m_config.fanMode = fanMode;
 505         m_modified |= FAN_CHANGED;
 506     }
 507 }
 508
 509 void
 510 TxConfig::SetMotionMode(uint8_t motionMode)
 511 {
 512     if (m_config.motionMode != motionMode)
 513     {
 514         m_config.motionMode = motionMode;
 515         m_modified |= MOTION_CHANGED;
 516     }
 517 }
 518
 519 void
 520 TxConfig::SetDvrAux(uint8_t dvrAux)
 521 {
 522     if (GetDvrAux() != dvrAux)
 523     {
 524         m_config.dvrAux = dvrAux;
 525         m_modified |= MAIN_CHANGED;
 526     }
 527 }
 528
 529 void
 530 TxConfig::SetDvrStartDelay(uint8_t dvrStartDelay)
 531 {
 532     if (GetDvrStartDelay() != dvrStartDelay)
 533     {
 534         m_config.dvrStartDelay = dvrStartDelay;
 535         m_modified |= MAIN_CHANGED;
 536     }
 537 }
 538
 539 void
 540 TxConfig::SetDvrStopDelay(uint8_t dvrStopDelay)
 541 {
 542     if (GetDvrStopDelay() != dvrStopDelay)
 543     {
 544         m_config.dvrStopDelay = dvrStopDelay;
 545         m_modified |= MAIN_CHANGED;
 546     }
 547 }
 548
 549 void
 550 TxConfig::SetBackpackDisable(bool backpackDisable)
 551 {
 552     if (m_config.backpackDisable != backpackDisable)
 553     {
 554         m_config.backpackDisable = backpackDisable;
 555         m_modified |= MAIN_CHANGED;
 556     }
 557 }
 558
 559 void
 560 TxConfig::SetButtonActions(uint8_t button, tx_button_color_t *action)
 561 {
 562     if (m_config.buttonColors[button].raw != action->raw) {
 563         m_config.buttonColors[button].raw = action->raw;
 564         m_modified |= BUTTON_CHANGED;
 565     }
 566 }
 567
 568 void
 569 TxConfig::SetDefaults(bool commit)
 570 {
 571     // Reset everything to 0/false and then just set anything that zero is not appropriate
 572     memset(&m_config, 0, sizeof(m_config));
 573
 574     m_config.version = TX_CONFIG_VERSION | TX_CONFIG_MAGIC;
 575     m_config.powerFanThreshold = PWR_250mW;
 576     m_modified = ALL_CHANGED;
 577
 578     if (commit)
 579     {
 580         m_modified = ALL_CHANGED;
 581     }
 582
 583     // Set defaults for button 1
 584     tx_button_color_t default_actions1 = {
 585         .val = {
 586             .color = 226,   // R:255 G:0 B:182
 587             .actions = {
 588                 {false, 2, ACTION_BIND},
 589                 {true, 0, ACTION_INCREASE_POWER}
 590             }
 591         }
 592     };
 593     m_config.buttonColors[0].raw = default_actions1.raw;
 594
 595     // Set defaults for button 2
 596     tx_button_color_t default_actions2 = {
 597         .val = {
 598             .color = 3,     // R:0 G:0 B:255
 599             .actions = {
 600                 {false, 1, ACTION_GOTO_VTX_CHANNEL},
 601                 {true, 0, ACTION_SEND_VTX}
 602             }
 603         }
 604     };
 605     m_config.buttonColors[1].raw = default_actions2.raw;
 606
 607     for (unsigned i=0; i<64; i++)
 608     {
 609         SetModelId(i);
 610         #if defined(RADIO_SX127X)
 611             SetRate(enumRatetoIndex(RATE_LORA_200HZ));
 612         #elif defined(RADIO_SX128X)
 613             SetRate(enumRatetoIndex(RATE_LORA_250HZ));
 614         #endif
 615         SetPower(POWERMGNT::getDefaultPower());
 616 #if defined(PLATFORM_ESP32)
 617         // ESP32 nvs needs to commit every model
 618         if (commit)
 619         {
 620             m_modified |= MODEL_CHANGED;
 621             Commit();
 622         }
 623 #endif
 624     }
 625
 626 #if !defined(PLATFORM_ESP32)
 627     // STM32/ESP8266 just needs one commit
 628     if (commit)
 629     {
 630         Commit();
 631     }
 632 #endif
 633
 634     SetModelId(0);
 635     m_modified = 0;
 636 }
 637
 638 /**
 639  * Sets ModelId used for subsequent per-model config gets
 640  * Returns: true if the model has changed
 641  **/
 642 bool
 643 TxConfig::SetModelId(uint8_t modelId)
 644 {
 645     model_config_t *newModel = &m_config.model_config[modelId];
 646     if (newModel != m_model)
 647     {
 648         m_model = newModel;
 649         m_modelId = modelId;
 650         return true;
 651     }
 652
 653     return false;
 654 }
 655 #endif
 656
 657 /////////////////////////////////////////////////////
 658
 659 #if defined(TARGET_RX)
 660
 661 RxConfig::RxConfig()
 662 {
 663 }
 664
 665 void RxConfig::Load()
 666 {
 667     m_modified = false;
 668     m_eeprom->Get(0, m_config);
 669
 670     uint32_t version = 0;
 671     if ((m_config.version & CONFIG_MAGIC_MASK) == RX_CONFIG_MAGIC)
 672         version = m_config.version & ~CONFIG_MAGIC_MASK;
 673     DBGLN("Config version %u", version);
 674
 675     // If version is current, all done
 676     if (version == RX_CONFIG_VERSION)
 677         return;
 678
 679     // Can't upgrade from version <4, or when flashing a previous version, just use defaults.
 680     if (version < 4 || version > RX_CONFIG_VERSION)
 681     {
 682         SetDefaults(true);
 683         return;
 684     }
 685
 686     // Upgrade EEPROM, starting with defaults
 687     SetDefaults(false);
 688     UpgradeEepromV4();
 689     UpgradeEepromV5();
 690     m_config.version = RX_CONFIG_VERSION | RX_CONFIG_MAGIC;
 691     m_modified = true;
 692     Commit();
 693 }
 694
 695 // ========================================================
 696 // V4 Upgrade
 697
 698 static void PwmConfigV4(v4_rx_config_pwm_t const * const v4, rx_config_pwm_t * const current)
 699 {
 700     current->val.failsafe = v4->val.failsafe;
 701     current->val.inputChannel = v4->val.inputChannel;
 702     current->val.inverted = v4->val.inverted;
 703 }
 704
 705 void RxConfig::UpgradeEepromV4()
 706 {
 707     v4_rx_config_t v4Config;
 708     m_eeprom->Get(0, v4Config);
 709
 710     if ((v4Config.version & ~CONFIG_MAGIC_MASK) == 4)
 711     {
 712         m_config.isBound = v4Config.isBound;
 713         m_config.modelId = v4Config.modelId;
 714         memcpy(m_config.uid, v4Config.uid, sizeof(v4Config.uid));
 715
 716         // OG PWMP had only 8 channels
 717         for (unsigned ch=0; ch<8; ++ch)
 718         {
 719             PwmConfigV4(&v4Config.pwmChannels[ch], &m_config.pwmChannels[ch]);
 720         }
 721     }
 722 }
 723
 724 // ========================================================
 725 // V5 Upgrade
 726
 727 static void PwmConfigV5(v5_rx_config_pwm_t const * const v5, rx_config_pwm_t * const current)
 728 {
 729     current->val.failsafe = v5->val.failsafe;
 730     current->val.inputChannel = v5->val.inputChannel;
 731     current->val.inverted = v5->val.inverted;
 732     current->val.narrow = v5->val.narrow;
 733     current->val.mode = v5->val.mode;
 734     if (v5->val.mode > som400Hz)
 735     {
 736         current->val.mode += 1;
 737     }
 738 }
 739
 740 void RxConfig::UpgradeEepromV5()
 741 {
 742     v5_rx_config_t v5Config;
 743     m_eeprom->Get(0, v5Config);
 744     if ((v5Config.version & ~CONFIG_MAGIC_MASK) == 5)
 745     {
 746         memcpy(m_config.uid, v5Config.uid, sizeof(v5Config.uid));
 747         m_config.vbatScale = v5Config.vbatScale;
 748         m_config.isBound = v5Config.isBound;
 749         m_config.power = v5Config.power;
 750         m_config.antennaMode = v5Config.antennaMode;
 751         m_config.forceTlmOff = v5Config.forceTlmOff;
 752         m_config.rateInitialIdx = v5Config.rateInitialIdx;
 753         m_config.modelId = v5Config.modelId;
 754
 755         for (unsigned ch=0; ch<16; ++ch)
 756         {
 757             PwmConfigV5(&v5Config.pwmChannels[ch], &m_config.pwmChannels[ch]);
 758         }
 759     }
 760 }
 761
 762 // ========================================================
 763
 764 void
 765 RxConfig::Commit()
 766 {
 767     if (!m_modified)
 768     {
 769         // No changes
 770         return;
 771     }
 772
 773     // Write the struct to eeprom
 774     m_eeprom->Put(0, m_config);
 775     m_eeprom->Commit();
 776
 777     m_modified = false;
 778 }
 779
 780 // Setters
 781 void
 782 RxConfig::SetIsBound(bool isBound)
 783 {
 784     if (m_config.isBound != isBound)
 785     {
 786         m_config.isBound = isBound;
 787         m_modified = true;
 788     }
 789 }
 790
 791 void
 792 RxConfig::SetUID(uint8_t* uid)
 793 {
 794     for (uint8_t i = 0; i < UID_LEN; ++i)
 795     {
 796         m_config.uid[i] = uid[i];
 797     }
 798     m_modified = true;
 799 }
 800
 801 void
 802 RxConfig::SetOnLoan(bool isLoaned)
 803 {
 804     if (m_config.onLoan != isLoaned)
 805     {
 806         m_config.onLoan = isLoaned;
 807         m_modified = true;
 808     }
 809 }
 810
 811 void
 812 RxConfig::SetOnLoanUID(uint8_t* uid)
 813 {
 814     for (uint8_t i = 0; i < UID_LEN; ++i)
 815     {
 816         m_config.loanUID[i] = uid[i];
 817     }
 818     m_modified = true;
 819 }
 820
 821 void
 822 RxConfig::SetPowerOnCounter(uint8_t powerOnCounter)
 823 {
 824     if (m_config.powerOnCounter != powerOnCounter)
 825     {
 826         m_config.powerOnCounter = powerOnCounter;
 827         m_modified = true;
 828     }
 829 }
 830
 831 void
 832 RxConfig::SetModelId(uint8_t modelId)
 833 {
 834     if (m_config.modelId != modelId)
 835     {
 836         m_config.modelId = modelId;
 837         m_modified = true;
 838     }
 839 }
 840
 841 void
 842 RxConfig::SetPower(uint8_t power)
 843 {
 844     if (m_config.power != power)
 845     {
 846         m_config.power = power;
 847         m_modified = true;
 848     }
 849 }
 850
 851
 852 void
 853 RxConfig::SetAntennaMode(uint8_t antennaMode)
 854 {
 855     //0 and 1 is use for gpio_antenna_select
 856     // 2 is diversity
 857     if (m_config.antennaMode != antennaMode)
 858     {
 859         m_config.antennaMode = antennaMode;
 860         m_modified = true;
 861     }
 862 }
 863
 864 void
 865 RxConfig::SetDefaults(bool commit)
 866 {
 867     // Reset everything to 0/false and then just set anything that zero is not appropriate
 868     memset(&m_config, 0, sizeof(m_config));
 869
 870     m_config.version = RX_CONFIG_VERSION | RX_CONFIG_MAGIC;
 871     m_config.modelId = 0xff;
 872     m_config.power = POWERMGNT::getDefaultPower();
 873     if (GPIO_PIN_ANT_CTRL != UNDEF_PIN)
 874         m_config.antennaMode = 2; // 2 is diversity
 875     if (GPIO_PIN_NSS_2 != UNDEF_PIN)
 876         m_config.antennaMode = 0; // 0 is diversity for dual radio
 877
 878 #if defined(GPIO_PIN_PWM_OUTPUTS)
 879     for (unsigned int ch=0; ch<PWM_MAX_CHANNELS; ++ch)
 880         SetPwmChannel(ch, 512, ch, false, 0, false);
 881     SetPwmChannel(2, 0, 2, false, 0, false); // ch2 is throttle, failsafe it to 988
 882 #endif
 883
 884     if (commit)
 885     {
 886         m_modified = true;
 887         Commit();
 888     }
 889 }
 890
 891 void
 892 RxConfig::SetStorageProvider(ELRS_EEPROM *eeprom)
 893 {
 894     if (eeprom)
 895     {
 896         m_eeprom = eeprom;
 897     }
 898 }
 899
 900 #if defined(GPIO_PIN_PWM_OUTPUTS)
 901 void
 902 RxConfig::SetPwmChannel(uint8_t ch, uint16_t failsafe, uint8_t inputCh, bool inverted, uint8_t mode, bool narrow)
 903 {
 904     if (ch > PWM_MAX_CHANNELS)
 905         return;
 906
 907     rx_config_pwm_t *pwm = &m_config.pwmChannels[ch];
 908     rx_config_pwm_t newConfig;
 909     newConfig.val.failsafe = failsafe;
 910     newConfig.val.inputChannel = inputCh;
 911     newConfig.val.inverted = inverted;
 912     newConfig.val.mode = mode;
 913     newConfig.val.narrow = narrow;
 914     if (pwm->raw == newConfig.raw)
 915         return;
 916
 917     pwm->raw = newConfig.raw;
 918     m_modified = true;
 919 }
 920
 921 void
 922 RxConfig::SetPwmChannelRaw(uint8_t ch, uint32_t raw)
 923 {
 924     if (ch > PWM_MAX_CHANNELS)
 925         return;
 926
 927     rx_config_pwm_t *pwm = &m_config.pwmChannels[ch];
 928     if (pwm->raw == raw)
 929         return;
 930
 931     pwm->raw = raw;
 932     m_modified = true;
 933 }
 934 #endif
 935
 936 void
 937 RxConfig::SetForceTlmOff(bool forceTlmOff)
 938 {
 939     if (m_config.forceTlmOff != forceTlmOff)
 940     {
 941         m_config.forceTlmOff = forceTlmOff;
 942         m_modified = true;
 943     }
 944 }
 945
 946 void
 947 RxConfig::SetRateInitialIdx(uint8_t rateInitialIdx)
 948 {
 949     if (m_config.rateInitialIdx != rateInitialIdx)
 950     {
 951         m_config.rateInitialIdx = rateInitialIdx;
 952         m_modified = true;
 953     }
 954 }
 955
 956
 957 #endif