src/main/fc/config.c

   1 /*
   2  * This file is part of Cleanflight and Betaflight.
   3  *
   4  * Cleanflight and Betaflight are free software. You can redistribute
   5  * this software and/or modify this software under the terms of the
   6  * GNU General Public License as published by the Free Software
   7  * Foundation, either version 3 of the License, or (at your option)
   8  * any later version.
   9  *
  10  * Cleanflight and Betaflight are distributed in the hope that they
  11  * will be useful, but WITHOUT ANY WARRANTY; without even the implied
  12  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13  * See the GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this software.
  17  *
  18  * If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <stdbool.h>
  22 #include <stdint.h>
  23 #include <string.h>
  24 #include <math.h>
  25
  26 #include "platform.h"
  27
  28 #include "blackbox/blackbox.h"
  29
  30 #include "build/debug.h"
  31
  32 #include "config/config_eeprom.h"
  33 #include "config/feature.h"
  34
  35 #include "drivers/system.h"
  36
  37 #include "fc/config.h"
  38 #include "fc/controlrate_profile.h"
  39 #include "fc/core.h"
  40 #include "fc/rc.h"
  41 #include "fc/rc_adjustments.h"
  42 #include "fc/rc_controls.h"
  43
  44 #include "flight/failsafe.h"
  45 #include "flight/imu.h"
  46 #include "flight/mixer.h"
  47 #include "flight/pid.h"
  48 #include "flight/servos.h"
  49
  50 #include "io/beeper.h"
  51 #include "io/ledstrip.h"
  52 #include "io/serial.h"
  53 #include "io/gps.h"
  54
  55 #include "pg/beeper.h"
  56 #include "pg/beeper_dev.h"
  57 #include "pg/rx.h"
  58 #include "pg/pg.h"
  59 #include "pg/pg_ids.h"
  60
  61 #include "rx/rx.h"
  62
  63 #include "sensors/acceleration.h"
  64 #include "sensors/battery.h"
  65 #include "sensors/gyro.h"
  66
  67 #include "scheduler/scheduler.h"
  68
  69 pidProfile_t *currentPidProfile;
  70
  71 #ifndef RX_SPI_DEFAULT_PROTOCOL
  72 #define RX_SPI_DEFAULT_PROTOCOL 0
  73 #endif
  74
  75 #define DYNAMIC_FILTER_MAX_SUPPORTED_LOOP_TIME HZ_TO_INTERVAL_US(2000)
  76
  77 PG_REGISTER_WITH_RESET_TEMPLATE(pilotConfig_t, pilotConfig, PG_PILOT_CONFIG, 1);
  78
  79 PG_RESET_TEMPLATE(pilotConfig_t, pilotConfig,
  80     .name = { 0 },
  81     .displayName = { 0 },
  82 );
  83
  84 PG_REGISTER_WITH_RESET_TEMPLATE(systemConfig_t, systemConfig, PG_SYSTEM_CONFIG, 2);
  85
  86 PG_RESET_TEMPLATE(systemConfig_t, systemConfig,
  87     .pidProfileIndex = 0,
  88     .activeRateProfile = 0,
  89     .debug_mode = DEBUG_MODE,
  90     .task_statistics = true,
  91     .cpu_overclock = 0,
  92     .powerOnArmingGraceTime = 5,
  93     .boardIdentifier = TARGET_BOARD_IDENTIFIER,
  94     .hseMhz = SYSTEM_HSE_VALUE,  // Not used for non-F4 targets
  95     .configured = false,
  96     .schedulerOptimizeRate = false,
  97 );
  98
  99 uint8_t getCurrentPidProfileIndex(void)
 100 {
 101     return systemConfig()->pidProfileIndex;
 102 }
 103
 104 static void loadPidProfile(void)
 105 {
 106     currentPidProfile = pidProfilesMutable(systemConfig()->pidProfileIndex);
 107 }
 108
 109 uint8_t getCurrentControlRateProfileIndex(void)
 110 {
 111     return systemConfig()->activeRateProfile;
 112 }
 113
 114 uint16_t getCurrentMinthrottle(void)
 115 {
 116     return motorConfig()->minthrottle;
 117 }
 118
 119 void resetConfigs(void)
 120 {
 121     pgResetAll();
 122
 123 #if defined(USE_TARGET_CONFIG)
 124     targetConfiguration();
 125 #endif
 126 }
 127
 128 static void activateConfig(void)
 129 {
 130     schedulerOptimizeRate(systemConfig()->schedulerOptimizeRate);
 131     loadPidProfile();
 132     loadControlRateProfile();
 133
 134     initRcProcessing();
 135
 136     resetAdjustmentStates();
 137
 138     pidInit(currentPidProfile);
 139
 140     rcControlsInit();
 141
 142     failsafeReset();
 143     setAccelerationTrims(&accelerometerConfigMutable()->accZero);
 144     accInitFilters();
 145
 146     imuConfigure(throttleCorrectionConfig()->throttle_correction_angle, throttleCorrectionConfig()->throttle_correction_value);
 147
 148 #ifdef USE_LED_STRIP
 149     reevaluateLedConfig();
 150 #endif
 151 }
 152
 153 static void validateAndFixConfig(void)
 154 {
 155 #if !defined(USE_QUAD_MIXER_ONLY)
 156     // Reset unsupported mixer mode to default.
 157     // This check will be gone when motor/servo mixers are loaded dynamically
 158     // by configurator as a part of configuration procedure.
 159
 160     mixerMode_e mixerMode = mixerConfigMutable()->mixerMode;
 161
 162     if (!(mixerMode == MIXER_CUSTOM || mixerMode == MIXER_CUSTOM_AIRPLANE || mixerMode == MIXER_CUSTOM_TRI)) {
 163         if (mixers[mixerMode].motorCount && mixers[mixerMode].motor == NULL)
 164             mixerConfigMutable()->mixerMode = MIXER_CUSTOM;
 165 #ifdef USE_SERVOS
 166         if (mixers[mixerMode].useServo && servoMixers[mixerMode].servoRuleCount == 0)
 167             mixerConfigMutable()->mixerMode = MIXER_CUSTOM_AIRPLANE;
 168 #endif
 169     }
 170 #endif
 171
 172     if (!isSerialConfigValid(serialConfig())) {
 173         pgResetFn_serialConfig(serialConfigMutable());
 174     }
 175
 176 #if defined(USE_GPS)
 177     serialPortConfig_t *gpsSerial = findSerialPortConfig(FUNCTION_GPS);
 178     if (gpsConfig()->provider == GPS_MSP && gpsSerial) {
 179         serialRemovePort(gpsSerial->identifier);
 180     }
 181 #endif
 182     if (
 183 #if defined(USE_GPS)
 184         gpsConfig()->provider != GPS_MSP && !gpsSerial &&
 185 #endif
 186         true) {
 187         featureDisable(FEATURE_GPS);
 188     }
 189
 190     if (systemConfig()->activeRateProfile >= CONTROL_RATE_PROFILE_COUNT) {
 191         systemConfigMutable()->activeRateProfile = 0;
 192     }
 193     loadControlRateProfile();
 194
 195     if (systemConfig()->pidProfileIndex >= PID_PROFILE_COUNT) {
 196         systemConfigMutable()->pidProfileIndex = 0;
 197     }
 198     loadPidProfile();
 199
 200     // Prevent invalid notch cutoff
 201     if (currentPidProfile->dterm_notch_cutoff >= currentPidProfile->dterm_notch_hz) {
 202         currentPidProfile->dterm_notch_hz = 0;
 203     }
 204
 205 #ifdef USE_DYN_LPF
 206     //PRevent invalid dynamic lowpass
 207     if (currentPidProfile->dyn_lpf_dterm_min_hz > currentPidProfile->dyn_lpf_dterm_max_hz) {
 208         currentPidProfile->dyn_lpf_dterm_min_hz = 0;
 209     }
 210 #endif
 211
 212     if (currentPidProfile->motor_output_limit > 100 || currentPidProfile->motor_output_limit == 0) {
 213         currentPidProfile->motor_output_limit = 100;
 214     }
 215
 216     if (currentPidProfile->auto_profile_cell_count > MAX_AUTO_DETECT_CELL_COUNT || currentPidProfile->auto_profile_cell_count < AUTO_PROFILE_CELL_COUNT_CHANGE) {
 217         currentPidProfile->auto_profile_cell_count = AUTO_PROFILE_CELL_COUNT_STAY;
 218     }
 219
 220     if (motorConfig()->dev.motorPwmProtocol == PWM_TYPE_BRUSHED) {
 221         featureDisable(FEATURE_3D);
 222
 223         if (motorConfig()->mincommand < 1000) {
 224             motorConfigMutable()->mincommand = 1000;
 225         }
 226     }
 227
 228     if ((motorConfig()->dev.motorPwmProtocol == PWM_TYPE_STANDARD) && (motorConfig()->dev.motorPwmRate > BRUSHLESS_MOTORS_PWM_RATE)) {
 229         motorConfigMutable()->dev.motorPwmRate = BRUSHLESS_MOTORS_PWM_RATE;
 230     }
 231
 232     validateAndFixGyroConfig();
 233
 234     if (!(featureIsEnabled(FEATURE_RX_PARALLEL_PWM) || featureIsEnabled(FEATURE_RX_PPM) || featureIsEnabled(FEATURE_RX_SERIAL) || featureIsEnabled(FEATURE_RX_MSP) || featureIsEnabled(FEATURE_RX_SPI))) {
 235         featureEnable(DEFAULT_RX_FEATURE);
 236     }
 237
 238     if (featureIsEnabled(FEATURE_RX_PPM)) {
 239         featureDisable(FEATURE_RX_SERIAL | FEATURE_RX_PARALLEL_PWM | FEATURE_RX_MSP | FEATURE_RX_SPI);
 240     }
 241
 242     if (featureIsEnabled(FEATURE_RX_MSP)) {
 243         featureDisable(FEATURE_RX_SERIAL | FEATURE_RX_PARALLEL_PWM | FEATURE_RX_PPM | FEATURE_RX_SPI);
 244     }
 245
 246     if (featureIsEnabled(FEATURE_RX_SERIAL)) {
 247         featureDisable(FEATURE_RX_PARALLEL_PWM | FEATURE_RX_MSP | FEATURE_RX_PPM | FEATURE_RX_SPI);
 248     }
 249
 250 #ifdef USE_RX_SPI
 251     if (featureIsEnabled(FEATURE_RX_SPI)) {
 252         featureDisable(FEATURE_RX_SERIAL | FEATURE_RX_PARALLEL_PWM | FEATURE_RX_PPM | FEATURE_RX_MSP);
 253     }
 254 #endif // USE_RX_SPI
 255
 256     if (featureIsEnabled(FEATURE_RX_PARALLEL_PWM)) {
 257         featureDisable(FEATURE_RX_SERIAL | FEATURE_RX_MSP | FEATURE_RX_PPM | FEATURE_RX_SPI);
 258     }
 259
 260 #ifdef USE_SOFTSPI
 261     if (featureIsEnabled(FEATURE_SOFTSPI)) {
 262         featureDisable(FEATURE_RX_PPM | FEATURE_RX_PARALLEL_PWM | FEATURE_SOFTSERIAL);
 263         batteryConfigMutable()->voltageMeterSource = VOLTAGE_METER_NONE;
 264 #if defined(STM32F10X)
 265         featureDisable(FEATURE_LED_STRIP);
 266         // rssi adc needs the same ports
 267         featureDisable(FEATURE_RSSI_ADC);
 268         // current meter needs the same ports
 269         if (batteryConfig()->currentMeterSource == CURRENT_METER_ADC) {
 270             batteryConfigMutable()->currentMeterSource = CURRENT_METER_NONE;
 271         }
 272 #endif // STM32F10X
 273     }
 274 #endif // USE_SOFTSPI
 275
 276 #if defined(USE_ADC)
 277     if (featureIsEnabled(FEATURE_RSSI_ADC)) {
 278         rxConfigMutable()->rssi_channel = 0;
 279         rxConfigMutable()->rssi_src_frame_errors = false;
 280     } else
 281 #endif
 282     if (rxConfigMutable()->rssi_channel
 283 #if defined(USE_PWM) || defined(USE_PPM)
 284         || featureIsEnabled(FEATURE_RX_PPM) || featureIsEnabled(FEATURE_RX_PARALLEL_PWM)
 285 #endif
 286         ) {
 287         rxConfigMutable()->rssi_src_frame_errors = false;
 288     }
 289
 290     if (!rcSmoothingIsEnabled() || rxConfig()->rcInterpolationChannels == INTERPOLATION_CHANNELS_T) {
 291         for (unsigned i = 0; i < PID_PROFILE_COUNT; i++) {
 292             pidProfilesMutable(i)->pid[PID_ROLL].F = 0;
 293             pidProfilesMutable(i)->pid[PID_PITCH].F = 0;
 294         }
 295     }
 296
 297     if (!rcSmoothingIsEnabled() ||
 298         (rxConfig()->rcInterpolationChannels != INTERPOLATION_CHANNELS_RPY &&
 299          rxConfig()->rcInterpolationChannels != INTERPOLATION_CHANNELS_RPYT)) {
 300
 301         for (unsigned i = 0; i < PID_PROFILE_COUNT; i++) {
 302             pidProfilesMutable(i)->pid[PID_YAW].F = 0;
 303         }
 304     }
 305
 306 #if defined(USE_THROTTLE_BOOST)
 307     if (!rcSmoothingIsEnabled() ||
 308         !(rxConfig()->rcInterpolationChannels == INTERPOLATION_CHANNELS_RPYT
 309         || rxConfig()->rcInterpolationChannels == INTERPOLATION_CHANNELS_T
 310         || rxConfig()->rcInterpolationChannels == INTERPOLATION_CHANNELS_RPT)) {
 311         for (unsigned i = 0; i < PID_PROFILE_COUNT; i++) {
 312             pidProfilesMutable(i)->throttle_boost = 0;
 313         }
 314     }
 315 #endif
 316
 317     if (
 318         featureIsEnabled(FEATURE_3D) || !featureIsEnabled(FEATURE_GPS)
 319 #if !defined(USE_GPS) || !defined(USE_GPS_RESCUE)
 320         || true
 321 #endif
 322         ) {
 323         if (failsafeConfig()->failsafe_procedure == FAILSAFE_PROCEDURE_GPS_RESCUE) {
 324             failsafeConfigMutable()->failsafe_procedure = FAILSAFE_PROCEDURE_DROP_IT;
 325         }
 326
 327         if (isModeActivationConditionPresent(BOXGPSRESCUE)) {
 328             removeModeActivationCondition(BOXGPSRESCUE);
 329         }
 330     }
 331
 332 #if defined(USE_ESC_SENSOR)
 333     if (!findSerialPortConfig(FUNCTION_ESC_SENSOR)) {
 334         featureDisable(FEATURE_ESC_SENSOR);
 335     }
 336 #endif
 337
 338 // clear features that are not supported.
 339 // I have kept them all here in one place, some could be moved to sections of code above.
 340
 341 #ifndef USE_PPM
 342     featureDisable(FEATURE_RX_PPM);
 343 #endif
 344
 345 #ifndef USE_SERIAL_RX
 346     featureDisable(FEATURE_RX_SERIAL);
 347 #endif
 348
 349 #if !defined(USE_SOFTSERIAL1) && !defined(USE_SOFTSERIAL2)
 350     featureDisable(FEATURE_SOFTSERIAL);
 351 #endif
 352
 353 #ifndef USE_RANGEFINDER
 354     featureDisable(FEATURE_RANGEFINDER);
 355 #endif
 356
 357 #ifndef USE_TELEMETRY
 358     featureDisable(FEATURE_TELEMETRY);
 359 #endif
 360
 361 #ifndef USE_PWM
 362     featureDisable(FEATURE_RX_PARALLEL_PWM);
 363 #endif
 364
 365 #ifndef USE_RX_MSP
 366     featureDisable(FEATURE_RX_MSP);
 367 #endif
 368
 369 #ifndef USE_LED_STRIP
 370     featureDisable(FEATURE_LED_STRIP);
 371 #endif
 372
 373 #ifndef USE_DASHBOARD
 374     featureDisable(FEATURE_DASHBOARD);
 375 #endif
 376
 377 #ifndef USE_OSD
 378     featureDisable(FEATURE_OSD);
 379 #endif
 380
 381 #ifndef USE_SERVOS
 382     featureDisable(FEATURE_SERVO_TILT | FEATURE_CHANNEL_FORWARDING);
 383 #endif
 384
 385 #ifndef USE_TRANSPONDER
 386     featureDisable(FEATURE_TRANSPONDER);
 387 #endif
 388
 389 #ifndef USE_RX_SPI
 390     featureDisable(FEATURE_RX_SPI);
 391 #endif
 392
 393 #ifndef USE_SOFTSPI
 394     featureDisable(FEATURE_SOFTSPI);
 395 #endif
 396
 397 #ifndef USE_ESC_SENSOR
 398     featureDisable(FEATURE_ESC_SENSOR);
 399 #endif
 400
 401 #ifndef USE_GYRO_DATA_ANALYSE
 402     featureDisable(FEATURE_DYNAMIC_FILTER);
 403 #endif
 404
 405 #if !defined(USE_ADC)
 406     featureDisable(FEATURE_RSSI_ADC);
 407 #endif
 408
 409 #if defined(USE_BEEPER)
 410     if (beeperDevConfig()->frequency && !timerGetByTag(beeperDevConfig()->ioTag)) {
 411         beeperDevConfigMutable()->frequency = 0;
 412     }
 413
 414     if (beeperConfig()->beeper_off_flags & ~BEEPER_ALLOWED_MODES) {
 415         beeperConfigMutable()->beeper_off_flags = 0;
 416     }
 417
 418 #ifdef USE_DSHOT
 419     if (beeperConfig()->dshotBeaconOffFlags & ~DSHOT_BEACON_ALLOWED_MODES) {
 420         beeperConfigMutable()->dshotBeaconOffFlags = 0;
 421     }
 422
 423     if (beeperConfig()->dshotBeaconTone < DSHOT_CMD_BEACON1
 424         || beeperConfig()->dshotBeaconTone > DSHOT_CMD_BEACON5) {
 425         beeperConfigMutable()->dshotBeaconTone = DSHOT_CMD_BEACON1;
 426     }
 427 #endif
 428 #endif
 429
 430 #if defined(USE_DSHOT_TELEMETRY)
 431     if (motorConfig()->dev.useBurstDshot && motorConfig()->dev.useDshotTelemetry) {
 432         motorConfigMutable()->dev.useDshotTelemetry = false;
 433     }
 434 #endif
 435
 436 #if defined(TARGET_VALIDATECONFIG)
 437     targetValidateConfiguration();
 438 #endif
 439 }
 440
 441 void validateAndFixGyroConfig(void)
 442 {
 443 #ifdef USE_GYRO_DATA_ANALYSE
 444     // Disable dynamic filter if gyro loop is less than 2KHz
 445     if (gyro.targetLooptime > DYNAMIC_FILTER_MAX_SUPPORTED_LOOP_TIME) {
 446         featureDisable(FEATURE_DYNAMIC_FILTER);
 447     }
 448 #endif
 449
 450     // Prevent invalid notch cutoff
 451     if (gyroConfig()->gyro_soft_notch_cutoff_1 >= gyroConfig()->gyro_soft_notch_hz_1) {
 452         gyroConfigMutable()->gyro_soft_notch_hz_1 = 0;
 453     }
 454     if (gyroConfig()->gyro_soft_notch_cutoff_2 >= gyroConfig()->gyro_soft_notch_hz_2) {
 455         gyroConfigMutable()->gyro_soft_notch_hz_2 = 0;
 456     }
 457 #ifdef USE_DYN_LPF
 458     //Prevent invalid dynamic lowpass filter
 459     if (gyroConfig()->dyn_lpf_gyro_min_hz > gyroConfig()->dyn_lpf_gyro_max_hz) {
 460         gyroConfigMutable()->dyn_lpf_gyro_min_hz = 0;
 461     }
 462 #endif
 463
 464     if (gyroConfig()->gyro_hardware_lpf == GYRO_HARDWARE_LPF_1KHZ_SAMPLE) {
 465         pidConfigMutable()->pid_process_denom = 1; // When gyro set to 1khz always set pid speed 1:1 to sampling speed
 466         gyroConfigMutable()->gyro_sync_denom = 1;
 467         gyroConfigMutable()->gyro_use_32khz = false;
 468     }
 469
 470     if (gyroConfig()->gyro_use_32khz) {
 471         // F1 and F3 can't handle high sample speed.
 472 #if defined(STM32F1)
 473         gyroConfigMutable()->gyro_sync_denom = MAX(gyroConfig()->gyro_sync_denom, 16);
 474 #elif defined(STM32F3)
 475         gyroConfigMutable()->gyro_sync_denom = MAX(gyroConfig()->gyro_sync_denom, 4);
 476 #endif
 477     } else {
 478 #if defined(STM32F1)
 479         gyroConfigMutable()->gyro_sync_denom = MAX(gyroConfig()->gyro_sync_denom, 3);
 480 #endif
 481     }
 482
 483     float samplingTime;
 484     switch (gyroMpuDetectionResult()->sensor) {
 485     case ICM_20649_SPI:
 486         samplingTime = 1.0f / 9000.0f;
 487         break;
 488     case BMI_160_SPI:
 489         samplingTime = 0.0003125f;
 490         break;
 491     default:
 492         samplingTime = 0.000125f;
 493         break;
 494     }
 495     if (gyroConfig()->gyro_hardware_lpf == GYRO_HARDWARE_LPF_1KHZ_SAMPLE) {
 496         switch (gyroMpuDetectionResult()->sensor) {
 497         case ICM_20649_SPI:
 498             samplingTime = 1.0f / 1100.0f;
 499             break;
 500         default:
 501             samplingTime = 0.001f;
 502             break;
 503         }
 504     }
 505     if (gyroConfig()->gyro_use_32khz) {
 506         samplingTime = 0.00003125;
 507     }
 508
 509     // check for looptime restrictions based on motor protocol. Motor times have safety margin
 510     float motorUpdateRestriction;
 511     switch (motorConfig()->dev.motorPwmProtocol) {
 512     case PWM_TYPE_STANDARD:
 513             motorUpdateRestriction = 1.0f / BRUSHLESS_MOTORS_PWM_RATE;
 514             break;
 515     case PWM_TYPE_ONESHOT125:
 516             motorUpdateRestriction = 0.0005f;
 517             break;
 518     case PWM_TYPE_ONESHOT42:
 519             motorUpdateRestriction = 0.0001f;
 520             break;
 521 #ifdef USE_DSHOT
 522     case PWM_TYPE_DSHOT150:
 523             motorUpdateRestriction = 0.000250f;
 524             break;
 525     case PWM_TYPE_DSHOT300:
 526             motorUpdateRestriction = 0.0001f;
 527             break;
 528 #endif
 529     default:
 530         motorUpdateRestriction = 0.00003125f;
 531         break;
 532     }
 533
 534     if (motorConfig()->dev.useUnsyncedPwm) {
 535         // Prevent overriding the max rate of motors
 536         if ((motorConfig()->dev.motorPwmProtocol <= PWM_TYPE_BRUSHED) && (motorConfig()->dev.motorPwmProtocol != PWM_TYPE_STANDARD)) {
 537             const uint32_t maxEscRate = lrintf(1.0f / motorUpdateRestriction);
 538             motorConfigMutable()->dev.motorPwmRate = MIN(motorConfig()->dev.motorPwmRate, maxEscRate);
 539         }
 540     } else {
 541         const float pidLooptime = samplingTime * gyroConfig()->gyro_sync_denom * pidConfig()->pid_process_denom;
 542         if (pidLooptime < motorUpdateRestriction) {
 543             const uint8_t minPidProcessDenom = constrain(motorUpdateRestriction / (samplingTime * gyroConfig()->gyro_sync_denom), 1, MAX_PID_PROCESS_DENOM);
 544             pidConfigMutable()->pid_process_denom = MAX(pidConfigMutable()->pid_process_denom, minPidProcessDenom);
 545         }
 546     }
 547
 548 #ifdef USE_BLACKBOX
 549 #ifndef USE_FLASHFS
 550     if (blackboxConfig()->device == 1) {  // BLACKBOX_DEVICE_FLASH (but not defined)
 551         blackboxConfigMutable()->device = BLACKBOX_DEVICE_NONE;
 552     }
 553 #endif // USE_FLASHFS
 554
 555 #ifndef USE_SDCARD
 556     if (blackboxConfig()->device == 2) {  // BLACKBOX_DEVICE_SDCARD (but not defined)
 557         blackboxConfigMutable()->device = BLACKBOX_DEVICE_NONE;
 558     }
 559 #endif // USE_SDCARD
 560 #endif // USE_BLACKBOX
 561 }
 562
 563 bool readEEPROM(void)
 564 {
 565     suspendRxPwmPpmSignal();
 566
 567     // Sanity check, read flash
 568     bool success = loadEEPROM();
 569
 570     validateAndFixConfig();
 571
 572     activateConfig();
 573
 574     resumeRxPwmPpmSignal();
 575
 576     return success;
 577 }
 578
 579 static void ValidateAndWriteConfigToEEPROM(bool setConfigured)
 580 {
 581     validateAndFixConfig();
 582
 583     suspendRxPwmPpmSignal();
 584
 585 #ifdef USE_CONFIGURATION_STATE
 586     if (setConfigured) {
 587         systemConfigMutable()->configured = true;
 588     }
 589 #else
 590     UNUSED(setConfigured);
 591 #endif
 592
 593     writeConfigToEEPROM();
 594
 595     resumeRxPwmPpmSignal();
 596 }
 597
 598 void writeEEPROM(void)
 599 {
 600     ValidateAndWriteConfigToEEPROM(true);
 601 }
 602
 603 void writeEEPROMWithFeatures(uint32_t features)
 604 {
 605     featureDisableAll();
 606     featureEnable(features);
 607
 608     ValidateAndWriteConfigToEEPROM(true);
 609 }
 610
 611 void resetEEPROM(void)
 612 {
 613     resetConfigs();
 614
 615     ValidateAndWriteConfigToEEPROM(false);
 616
 617     activateConfig();
 618 }
 619
 620 void ensureEEPROMStructureIsValid(void)
 621 {
 622     if (isEEPROMStructureValid()) {
 623         return;
 624     }
 625     resetEEPROM();
 626 }
 627
 628 void saveConfigAndNotify(void)
 629 {
 630     ValidateAndWriteConfigToEEPROM(true);
 631     readEEPROM();
 632     beeperConfirmationBeeps(1);
 633 }
 634
 635 void changePidProfileFromCellCount(uint8_t cellCount)
 636 {
 637     if (currentPidProfile->auto_profile_cell_count == cellCount || currentPidProfile->auto_profile_cell_count == AUTO_PROFILE_CELL_COUNT_STAY) {
 638         return;
 639     }
 640
 641     unsigned profileIndex = (systemConfig()->pidProfileIndex + 1) % PID_PROFILE_COUNT;
 642     int matchingProfileIndex = -1;
 643     while (profileIndex != systemConfig()->pidProfileIndex) {
 644         if (pidProfiles(profileIndex)->auto_profile_cell_count == cellCount) {
 645             matchingProfileIndex = profileIndex;
 646
 647             break;
 648         } else if (matchingProfileIndex < 0 && pidProfiles(profileIndex)->auto_profile_cell_count == AUTO_PROFILE_CELL_COUNT_STAY) {
 649             matchingProfileIndex = profileIndex;
 650         }
 651
 652         profileIndex = (profileIndex + 1) % PID_PROFILE_COUNT;
 653     }
 654
 655     if (matchingProfileIndex >= 0) {
 656         changePidProfile(matchingProfileIndex);
 657     }
 658 }
 659
 660 void changePidProfile(uint8_t pidProfileIndex)
 661 {
 662     if (pidProfileIndex < PID_PROFILE_COUNT) {
 663         systemConfigMutable()->pidProfileIndex = pidProfileIndex;
 664         loadPidProfile();
 665
 666         pidInit(currentPidProfile);
 667     }
 668
 669     beeperConfirmationBeeps(pidProfileIndex + 1);
 670 }
 671
 672 bool isSystemConfigured(void)
 673 {
 674 #ifdef USE_CONFIGURATION_STATE
 675     return systemConfig()->configured;
 676 #else
 677     return true;
 678 #endif
 679 }