src/main/config/config.c

   1 /*
   2  * This file is part of Cleanflight.
   3  *
   4  * Cleanflight 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, either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * Cleanflight is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with Cleanflight.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include <stdbool.h>
  19 #include <stdint.h>
  20 #include <string.h>
  21
  22 #include "platform.h"
  23
  24 #include "build_config.h"
  25
  26 #include "blackbox/blackbox_io.h"
  27
  28 #include "common/color.h"
  29 #include "common/axis.h"
  30 #include "common/maths.h"
  31 #include "common/filter.h"
  32
  33 #include "drivers/sensor.h"
  34 #include "drivers/accgyro.h"
  35 #include "drivers/compass.h"
  36 #include "drivers/system.h"
  37 #include "drivers/gpio.h"
  38 #include "drivers/timer.h"
  39 #include "drivers/pwm_rx.h"
  40 #include "drivers/serial.h"
  41 #include "drivers/pwm_output.h"
  42 #include "drivers/max7456.h"
  43
  44 #include "sensors/sensors.h"
  45 #include "sensors/gyro.h"
  46 #include "sensors/compass.h"
  47 #include "sensors/acceleration.h"
  48 #include "sensors/barometer.h"
  49 #include "sensors/boardalignment.h"
  50 #include "sensors/battery.h"
  51
  52 #include "io/beeper.h"
  53 #include "io/serial.h"
  54 #include "io/gimbal.h"
  55 #include "io/escservo.h"
  56 #include "io/rc_controls.h"
  57 #include "io/rc_curves.h"
  58 #include "io/ledstrip.h"
  59 #include "io/gps.h"
  60 #include "io/osd.h"
  61 #include "io/vtx.h"
  62
  63 #include "rx/rx.h"
  64
  65 #include "telemetry/telemetry.h"
  66
  67 #include "flight/mixer.h"
  68 #include "flight/pid.h"
  69 #include "flight/imu.h"
  70 #include "flight/failsafe.h"
  71 #include "flight/altitudehold.h"
  72 #include "flight/navigation.h"
  73
  74 #include "config/runtime_config.h"
  75 #include "config/config.h"
  76
  77 #include "config/config_profile.h"
  78 #include "config/config_master.h"
  79
  80 #ifndef DEFAULT_RX_FEATURE
  81 #define DEFAULT_RX_FEATURE FEATURE_RX_PARALLEL_PWM
  82 #endif
  83
  84 #define BRUSHED_MOTORS_PWM_RATE 16000
  85 #ifdef STM32F4
  86 #define BRUSHLESS_MOTORS_PWM_RATE 2000
  87 #else
  88 #define BRUSHLESS_MOTORS_PWM_RATE 400
  89 #endif
  90
  91 void useRcControlsConfig(modeActivationCondition_t *modeActivationConditions, escAndServoConfig_t *escAndServoConfigToUse, pidProfile_t *pidProfileToUse);
  92
  93 #if !defined(FLASH_SIZE)
  94 #error "Flash size not defined for target. (specify in KB)"
  95 #endif
  96
  97
  98 #ifndef FLASH_PAGE_SIZE
  99     #ifdef STM32F303xC
 100         #define FLASH_PAGE_SIZE                 ((uint16_t)0x800)
 101     #endif
 102
 103     #ifdef STM32F10X_MD
 104         #define FLASH_PAGE_SIZE                 ((uint16_t)0x400)
 105     #endif
 106
 107     #ifdef STM32F10X_HD
 108         #define FLASH_PAGE_SIZE                 ((uint16_t)0x800)
 109     #endif
 110
 111     #if defined(STM32F40_41xxx)
 112         #define FLASH_PAGE_SIZE                 ((uint32_t)0x20000)
 113     #endif
 114
 115     #if defined (STM32F411xE)
 116         #define FLASH_PAGE_SIZE                 ((uint32_t)0x20000)
 117     #endif
 118
 119 #endif
 120
 121 #if !defined(FLASH_SIZE) && !defined(FLASH_PAGE_COUNT)
 122     #ifdef STM32F10X_MD
 123         #define FLASH_PAGE_COUNT 128
 124     #endif
 125
 126     #ifdef STM32F10X_HD
 127         #define FLASH_PAGE_COUNT 128
 128     #endif
 129 #endif
 130
 131 #if defined(FLASH_SIZE)
 132 #if defined(STM32F40_41xxx)
 133 #define FLASH_PAGE_COUNT 4 // just to make calculations work
 134 #elif defined (STM32F411xE)
 135 #define FLASH_PAGE_COUNT 4 // just to make calculations work
 136 #else
 137 #define FLASH_PAGE_COUNT ((FLASH_SIZE * 0x400) / FLASH_PAGE_SIZE)
 138 #endif
 139 #endif
 140
 141 #if !defined(FLASH_PAGE_SIZE)
 142 #error "Flash page size not defined for target."
 143 #endif
 144
 145 #if !defined(FLASH_PAGE_COUNT)
 146 #error "Flash page count not defined for target."
 147 #endif
 148
 149 #if FLASH_SIZE <= 128
 150 #define FLASH_TO_RESERVE_FOR_CONFIG 0x800
 151 #else
 152 #define FLASH_TO_RESERVE_FOR_CONFIG 0x1000
 153 #endif
 154
 155 // use the last flash pages for storage
 156 #ifdef CUSTOM_FLASH_MEMORY_ADDRESS
 157 size_t custom_flash_memory_address = 0;
 158 #define CONFIG_START_FLASH_ADDRESS (custom_flash_memory_address)
 159 #else
 160 // use the last flash pages for storage
 161 #ifndef CONFIG_START_FLASH_ADDRESS
 162 #define CONFIG_START_FLASH_ADDRESS (0x08000000 + (uint32_t)((FLASH_PAGE_SIZE * FLASH_PAGE_COUNT) - FLASH_TO_RESERVE_FOR_CONFIG))
 163 #endif
 164 #endif
 165
 166 master_t masterConfig;                 // master config struct with data independent from profiles
 167 profile_t *currentProfile;
 168 static uint32_t activeFeaturesLatch = 0;
 169
 170 static uint8_t currentControlRateProfileIndex = 0;
 171 controlRateConfig_t *currentControlRateProfile;
 172
 173 static const uint8_t EEPROM_CONF_VERSION = 141;
 174
 175 static void resetAccelerometerTrims(flightDynamicsTrims_t *accelerometerTrims)
 176 {
 177     accelerometerTrims->values.pitch = 0;
 178     accelerometerTrims->values.roll = 0;
 179     accelerometerTrims->values.yaw = 0;
 180 }
 181
 182 void resetPidProfile(pidProfile_t *pidProfile)
 183 {
 184
 185 #if (defined(STM32F10X))
 186     pidProfile->pidController = PID_CONTROLLER_INTEGER;
 187 #else
 188     pidProfile->pidController = PID_CONTROLLER_FLOAT;
 189 #endif
 190
 191     pidProfile->P8[ROLL] = 45;
 192     pidProfile->I8[ROLL] = 40;
 193     pidProfile->D8[ROLL] = 18;
 194     pidProfile->P8[PITCH] = 50;
 195     pidProfile->I8[PITCH] = 40;
 196     pidProfile->D8[PITCH] = 18;
 197     pidProfile->P8[YAW] = 80;
 198     pidProfile->I8[YAW] = 45;
 199     pidProfile->D8[YAW] = 20;
 200     pidProfile->P8[PIDALT] = 50;
 201     pidProfile->I8[PIDALT] = 0;
 202     pidProfile->D8[PIDALT] = 0;
 203     pidProfile->P8[PIDPOS] = 15;   // POSHOLD_P * 100;
 204     pidProfile->I8[PIDPOS] = 0;    // POSHOLD_I * 100;
 205     pidProfile->D8[PIDPOS] = 0;
 206     pidProfile->P8[PIDPOSR] = 34;  // POSHOLD_RATE_P * 10;
 207     pidProfile->I8[PIDPOSR] = 14;  // POSHOLD_RATE_I * 100;
 208     pidProfile->D8[PIDPOSR] = 53;  // POSHOLD_RATE_D * 1000;
 209     pidProfile->P8[PIDNAVR] = 25;  // NAV_P * 10;
 210     pidProfile->I8[PIDNAVR] = 33;  // NAV_I * 100;
 211     pidProfile->D8[PIDNAVR] = 83;  // NAV_D * 1000;
 212     pidProfile->P8[PIDLEVEL] = 50;
 213     pidProfile->I8[PIDLEVEL] = 50;
 214     pidProfile->D8[PIDLEVEL] = 100;
 215     pidProfile->P8[PIDMAG] = 40;
 216     pidProfile->P8[PIDVEL] = 55;
 217     pidProfile->I8[PIDVEL] = 55;
 218     pidProfile->D8[PIDVEL] = 75;
 219
 220     pidProfile->yaw_p_limit = YAW_P_LIMIT_MAX;
 221     pidProfile->yaw_lpf_hz = 80;
 222     pidProfile->rollPitchItermIgnoreRate = 180;
 223     pidProfile->yawItermIgnoreRate = 35;
 224     pidProfile->dterm_lpf_hz = 100;    // filtering ON by default
 225     pidProfile->deltaMethod = DELTA_FROM_MEASUREMENT;
 226     pidProfile->dynamic_pid = 1;
 227
 228 #ifdef GTUNE
 229     pidProfile->gtune_lolimP[ROLL] = 10;          // [0..200] Lower limit of ROLL P during G tune.
 230     pidProfile->gtune_lolimP[PITCH] = 10;         // [0..200] Lower limit of PITCH P during G tune.
 231     pidProfile->gtune_lolimP[YAW] = 10;           // [0..200] Lower limit of YAW P during G tune.
 232     pidProfile->gtune_hilimP[ROLL] = 100;         // [0..200] Higher limit of ROLL P during G tune. 0 Disables tuning for that axis.
 233     pidProfile->gtune_hilimP[PITCH] = 100;        // [0..200] Higher limit of PITCH P during G tune. 0 Disables tuning for that axis.
 234     pidProfile->gtune_hilimP[YAW] = 100;          // [0..200] Higher limit of YAW P during G tune. 0 Disables tuning for that axis.
 235     pidProfile->gtune_pwr = 0;                    // [0..10] Strength of adjustment
 236     pidProfile->gtune_settle_time = 450;          // [200..1000] Settle time in ms
 237     pidProfile->gtune_average_cycles = 16;        // [8..128] Number of looptime cycles used for gyro average calculation
 238 #endif
 239 }
 240
 241 #ifdef GPS
 242 void resetGpsProfile(gpsProfile_t *gpsProfile)
 243 {
 244     gpsProfile->gps_wp_radius = 200;
 245     gpsProfile->gps_lpf = 20;
 246     gpsProfile->nav_slew_rate = 30;
 247     gpsProfile->nav_controls_heading = 1;
 248     gpsProfile->nav_speed_min = 100;
 249     gpsProfile->nav_speed_max = 300;
 250     gpsProfile->ap_mode = 40;
 251 }
 252 #endif
 253
 254 void resetBarometerConfig(barometerConfig_t *barometerConfig)
 255 {
 256     barometerConfig->baro_sample_count = 21;
 257     barometerConfig->baro_noise_lpf = 0.6f;
 258     barometerConfig->baro_cf_vel = 0.985f;
 259     barometerConfig->baro_cf_alt = 0.965f;
 260 }
 261
 262 void resetSensorAlignment(sensorAlignmentConfig_t *sensorAlignmentConfig)
 263 {
 264     sensorAlignmentConfig->gyro_align = ALIGN_DEFAULT;
 265     sensorAlignmentConfig->acc_align = ALIGN_DEFAULT;
 266     sensorAlignmentConfig->mag_align = ALIGN_DEFAULT;
 267 }
 268
 269 void resetEscAndServoConfig(escAndServoConfig_t *escAndServoConfig)
 270 {
 271 #ifdef BRUSHED_MOTORS
 272     escAndServoConfig->minthrottle = 1000;
 273     escAndServoConfig->maxthrottle = 2000;
 274 #else
 275     escAndServoConfig->minthrottle = 1150;
 276     escAndServoConfig->maxthrottle = 1850;
 277 #endif
 278     escAndServoConfig->mincommand = 1000;
 279     escAndServoConfig->servoCenterPulse = 1500;
 280     escAndServoConfig->escDesyncProtection = 0;
 281 }
 282
 283 void resetFlight3DConfig(flight3DConfig_t *flight3DConfig)
 284 {
 285     flight3DConfig->deadband3d_low = 1406;
 286     flight3DConfig->deadband3d_high = 1514;
 287     flight3DConfig->neutral3d = 1460;
 288     flight3DConfig->deadband3d_throttle = 50;
 289 }
 290
 291 void resetTelemetryConfig(telemetryConfig_t *telemetryConfig)
 292 {
 293     telemetryConfig->telemetry_inversion = 0;
 294     telemetryConfig->telemetry_switch = 0;
 295     telemetryConfig->gpsNoFixLatitude = 0;
 296     telemetryConfig->gpsNoFixLongitude = 0;
 297     telemetryConfig->frsky_coordinate_format = FRSKY_FORMAT_DMS;
 298     telemetryConfig->frsky_unit = FRSKY_UNIT_METRICS;
 299     telemetryConfig->frsky_vfas_precision = 0;
 300     telemetryConfig->frsky_vfas_cell_voltage = 0;
 301     telemetryConfig->hottAlarmSoundInterval = 5;
 302 }
 303
 304 void resetBatteryConfig(batteryConfig_t *batteryConfig)
 305 {
 306     batteryConfig->vbatscale = VBAT_SCALE_DEFAULT;
 307     batteryConfig->vbatresdivval = VBAT_RESDIVVAL_DEFAULT;
 308     batteryConfig->vbatresdivmultiplier = VBAT_RESDIVMULTIPLIER_DEFAULT;
 309     batteryConfig->vbatmaxcellvoltage = 43;
 310     batteryConfig->vbatmincellvoltage = 33;
 311     batteryConfig->vbatwarningcellvoltage = 35;
 312     batteryConfig->vbathysteresis = 1;
 313     batteryConfig->vbatPidCompensation = 0;
 314     batteryConfig->currentMeterOffset = 0;
 315     batteryConfig->currentMeterScale = 400; // for Allegro ACS758LCB-100U (40mV/A)
 316     batteryConfig->batteryCapacity = 0;
 317     batteryConfig->currentMeterType = CURRENT_SENSOR_ADC;
 318 }
 319
 320 #ifdef SWAP_SERIAL_PORT_0_AND_1_DEFAULTS
 321 #define FIRST_PORT_INDEX 1
 322 #define SECOND_PORT_INDEX 0
 323 #else
 324 #define FIRST_PORT_INDEX 0
 325 #define SECOND_PORT_INDEX 1
 326 #endif
 327
 328 void resetSerialConfig(serialConfig_t *serialConfig)
 329 {
 330     uint8_t index;
 331     memset(serialConfig, 0, sizeof(serialConfig_t));
 332
 333     for (index = 0; index < SERIAL_PORT_COUNT; index++) {
 334         serialConfig->portConfigs[index].identifier = serialPortIdentifiers[index];
 335         serialConfig->portConfigs[index].msp_baudrateIndex = BAUD_115200;
 336         serialConfig->portConfigs[index].gps_baudrateIndex = BAUD_57600;
 337         serialConfig->portConfigs[index].telemetry_baudrateIndex = BAUD_AUTO;
 338         serialConfig->portConfigs[index].blackbox_baudrateIndex = BAUD_115200;
 339     }
 340
 341     serialConfig->portConfigs[0].functionMask = FUNCTION_MSP;
 342
 343 #if defined(USE_VCP)
 344     // This allows MSP connection via USART & VCP so the board can be reconfigured.
 345     serialConfig->portConfigs[1].functionMask = FUNCTION_MSP;
 346 #endif
 347
 348     serialConfig->reboot_character = 'R';
 349 }
 350
 351 static void resetControlRateConfig(controlRateConfig_t *controlRateConfig)
 352 {
 353     controlRateConfig->rcRate8 = 100;
 354     controlRateConfig->rcYawRate8 = 100;
 355     controlRateConfig->rcExpo8 = 10;
 356     controlRateConfig->thrMid8 = 50;
 357     controlRateConfig->thrExpo8 = 0;
 358     controlRateConfig->dynThrPID = 20;
 359     controlRateConfig->rcYawExpo8 = 10;
 360     controlRateConfig->tpa_breakpoint = 1650;
 361
 362     for (uint8_t axis = 0; axis < FLIGHT_DYNAMICS_INDEX_COUNT; axis++) {
 363         controlRateConfig->rates[axis] = 70;
 364     }
 365
 366 }
 367
 368 void resetRcControlsConfig(rcControlsConfig_t *rcControlsConfig)
 369 {
 370     rcControlsConfig->deadband = 0;
 371     rcControlsConfig->yaw_deadband = 0;
 372     rcControlsConfig->alt_hold_deadband = 40;
 373     rcControlsConfig->alt_hold_fast_change = 1;
 374 }
 375
 376 void resetMixerConfig(mixerConfig_t *mixerConfig)
 377 {
 378     mixerConfig->yaw_motor_direction = 1;
 379 #ifdef USE_SERVOS
 380     mixerConfig->tri_unarmed_servo = 1;
 381     mixerConfig->servo_lowpass_freq = 400;
 382     mixerConfig->servo_lowpass_enable = 0;
 383 #endif
 384 }
 385
 386 uint8_t getCurrentProfile(void)
 387 {
 388     return masterConfig.current_profile_index;
 389 }
 390
 391 static void setProfile(uint8_t profileIndex)
 392 {
 393     currentProfile = &masterConfig.profile[profileIndex];
 394     currentControlRateProfileIndex = currentProfile->activeRateProfile;
 395     currentControlRateProfile = &currentProfile->controlRateProfile[currentControlRateProfileIndex];
 396 }
 397
 398 uint8_t getCurrentControlRateProfile(void)
 399 {
 400     return currentControlRateProfileIndex;
 401 }
 402
 403 static void setControlRateProfile(uint8_t profileIndex)
 404 {
 405     currentControlRateProfileIndex = profileIndex;
 406     masterConfig.profile[getCurrentProfile()].activeRateProfile = profileIndex;
 407     currentControlRateProfile = &masterConfig.profile[getCurrentProfile()].controlRateProfile[profileIndex];
 408 }
 409
 410 controlRateConfig_t *getControlRateConfig(uint8_t profileIndex)
 411 {
 412     return &masterConfig.profile[profileIndex].controlRateProfile[masterConfig.profile[profileIndex].activeRateProfile];
 413 }
 414
 415 uint16_t getCurrentMinthrottle(void)
 416 {
 417     return masterConfig.escAndServoConfig.minthrottle;
 418 }
 419
 420 // Default settings
 421 static void resetConf(void)
 422 {
 423     // Clear all configuration
 424     memset(&masterConfig, 0, sizeof(master_t));
 425     setProfile(0);
 426
 427     featureClearAll();
 428     featureSet(DEFAULT_RX_FEATURE | FEATURE_FAILSAFE | FEATURE_SUPEREXPO_RATES);
 429 #ifdef DEFAULT_FEATURES
 430     featureSet(DEFAULT_FEATURES);
 431 #endif
 432
 433 #ifdef OSD
 434     resetOsdConfig();
 435 #endif
 436
 437 #ifdef BOARD_HAS_VOLTAGE_DIVIDER
 438     // only enable the VBAT feature by default if the board has a voltage divider otherwise
 439     // the user may see incorrect readings and unexpected issues with pin mappings may occur.
 440     featureSet(FEATURE_VBAT);
 441 #endif
 442
 443     masterConfig.version = EEPROM_CONF_VERSION;
 444     masterConfig.mixerMode = MIXER_QUADX;
 445
 446     // global settings
 447     masterConfig.current_profile_index = 0;     // default profile
 448     masterConfig.dcm_kp = 2500;                // 1.0 * 10000
 449     masterConfig.dcm_ki = 0;                    // 0.003 * 10000
 450     masterConfig.gyro_lpf = 0;                 // 256HZ default
 451 #ifdef STM32F10X
 452     masterConfig.gyro_sync_denom = 8;
 453 #else
 454     masterConfig.gyro_sync_denom = 4;
 455 #endif
 456     masterConfig.gyro_soft_lpf_hz = 100;
 457
 458     masterConfig.pid_process_denom = 2;
 459
 460     masterConfig.debug_mode = 0;
 461
 462     resetAccelerometerTrims(&masterConfig.accZero);
 463
 464     resetSensorAlignment(&masterConfig.sensorAlignmentConfig);
 465
 466     masterConfig.boardAlignment.rollDegrees = 0;
 467     masterConfig.boardAlignment.pitchDegrees = 0;
 468     masterConfig.boardAlignment.yawDegrees = 0;
 469     masterConfig.acc_hardware = ACC_DEFAULT;     // default/autodetect
 470     masterConfig.max_angle_inclination = 700;    // 70 degrees
 471     masterConfig.yaw_control_direction = 1;
 472     masterConfig.gyroConfig.gyroMovementCalibrationThreshold = 32;
 473
 474     // xxx_hardware: 0:default/autodetect, 1: disable
 475     masterConfig.mag_hardware = 0;
 476
 477     masterConfig.baro_hardware = 0;
 478
 479     resetBatteryConfig(&masterConfig.batteryConfig);
 480
 481     resetTelemetryConfig(&masterConfig.telemetryConfig);
 482
 483 #ifdef SERIALRX_PROVIDER
 484     masterConfig.rxConfig.serialrx_provider = SERIALRX_PROVIDER;
 485 #else
 486     masterConfig.rxConfig.serialrx_provider = 0;
 487 #endif
 488     masterConfig.rxConfig.sbus_inversion = 1;
 489     masterConfig.rxConfig.spektrum_sat_bind = 0;
 490     masterConfig.rxConfig.spektrum_sat_bind_autoreset = 1;
 491     masterConfig.rxConfig.midrc = 1500;
 492     masterConfig.rxConfig.mincheck = 1100;
 493     masterConfig.rxConfig.maxcheck = 1900;
 494     masterConfig.rxConfig.rx_min_usec = 885;          // any of first 4 channels below this value will trigger rx loss detection
 495     masterConfig.rxConfig.rx_max_usec = 2115;         // any of first 4 channels above this value will trigger rx loss detection
 496
 497     for (int i = 0; i < MAX_SUPPORTED_RC_CHANNEL_COUNT; i++) {
 498         rxFailsafeChannelConfiguration_t *channelFailsafeConfiguration = &masterConfig.rxConfig.failsafe_channel_configurations[i];
 499         channelFailsafeConfiguration->mode = (i < NON_AUX_CHANNEL_COUNT) ? RX_FAILSAFE_MODE_AUTO : RX_FAILSAFE_MODE_HOLD;
 500         channelFailsafeConfiguration->step = (i == THROTTLE) ? CHANNEL_VALUE_TO_RXFAIL_STEP(masterConfig.rxConfig.rx_min_usec) : CHANNEL_VALUE_TO_RXFAIL_STEP(masterConfig.rxConfig.midrc);
 501     }
 502
 503     masterConfig.rxConfig.rssi_channel = 0;
 504     masterConfig.rxConfig.rssi_scale = RSSI_SCALE_DEFAULT;
 505     masterConfig.rxConfig.rssi_ppm_invert = 0;
 506     masterConfig.rxConfig.rcSmoothInterval = 0; // 0 is predefined
 507     masterConfig.rxConfig.fpvCamAngleDegrees = 0;
 508 #ifdef STM32F4
 509     masterConfig.rxConfig.max_aux_channel = 99;
 510 #else
 511     masterConfig.rxConfig.max_aux_channel = 6;
 512 #endif
 513     masterConfig.rxConfig.airModeActivateThreshold = 1350;
 514
 515     resetAllRxChannelRangeConfigurations(masterConfig.rxConfig.channelRanges);
 516
 517     masterConfig.inputFilteringMode = INPUT_FILTERING_DISABLED;
 518
 519     masterConfig.gyro_cal_on_first_arm = 0;  // TODO - Cleanup retarded arm support
 520     masterConfig.disarm_kill_switch = 1;
 521     masterConfig.auto_disarm_delay = 5;
 522     masterConfig.small_angle = 25;
 523
 524     resetMixerConfig(&masterConfig.mixerConfig);
 525
 526     masterConfig.airplaneConfig.fixedwing_althold_dir = 1;
 527
 528     // Motor/ESC/Servo
 529     resetEscAndServoConfig(&masterConfig.escAndServoConfig);
 530     resetFlight3DConfig(&masterConfig.flight3DConfig);
 531
 532 #ifdef BRUSHED_MOTORS
 533     masterConfig.motor_pwm_rate = BRUSHED_MOTORS_PWM_RATE;
 534     masterConfig.motor_pwm_protocol = PWM_TYPE_BRUSHED;
 535 #else
 536     masterConfig.motor_pwm_rate = BRUSHLESS_MOTORS_PWM_RATE;
 537     masterConfig.motor_pwm_protocol = PWM_TYPE_ONESHOT125;
 538 #endif
 539     masterConfig.servo_pwm_rate = 50;
 540
 541 #ifdef CC3D
 542     masterConfig.use_buzzer_p6 = 0;
 543 #endif
 544
 545 #ifdef GPS
 546     // gps/nav stuff
 547     masterConfig.gpsConfig.provider   = GPS_NMEA;
 548     masterConfig.gpsConfig.sbasMode   = SBAS_AUTO;
 549     masterConfig.gpsConfig.autoConfig = GPS_AUTOCONFIG_ON;
 550     masterConfig.gpsConfig.autoBaud   = GPS_AUTOBAUD_OFF;
 551 #endif
 552
 553     resetSerialConfig(&masterConfig.serialConfig);
 554
 555     masterConfig.emf_avoidance = 0; // TODO - needs removal
 556
 557     resetPidProfile(&currentProfile->pidProfile);
 558
 559     for (int rI = 0; rI<MAX_RATEPROFILES; rI++) {
 560         resetControlRateConfig(&masterConfig.profile[0].controlRateProfile[rI]);
 561     }
 562     resetRollAndPitchTrims(&masterConfig.accelerometerTrims);
 563
 564     masterConfig.mag_declination = 0;
 565     masterConfig.acc_lpf_hz = 10.0f;
 566     masterConfig.accDeadband.xy = 40;
 567     masterConfig.accDeadband.z = 40;
 568     masterConfig.acc_unarmedcal = 1;
 569
 570     resetBarometerConfig(&masterConfig.barometerConfig);
 571
 572     // Radio
 573     parseRcChannels("AETR1234", &masterConfig.rxConfig);
 574
 575     resetRcControlsConfig(&masterConfig.rcControlsConfig);
 576
 577     masterConfig.throttle_correction_value = 0;      // could 10 with althold or 40 for fpv
 578     masterConfig.throttle_correction_angle = 800;    // could be 80.0 deg with atlhold or 45.0 for fpv
 579
 580     // Failsafe Variables
 581     masterConfig.failsafeConfig.failsafe_delay = 10;              // 1sec
 582     masterConfig.failsafeConfig.failsafe_off_delay = 10;          // 1sec
 583     masterConfig.failsafeConfig.failsafe_throttle = 1000;         // default throttle off.
 584     masterConfig.failsafeConfig.failsafe_kill_switch = 0;         // default failsafe switch action is identical to rc link loss
 585     masterConfig.failsafeConfig.failsafe_throttle_low_delay = 100; // default throttle low delay for "just disarm" on failsafe condition
 586     masterConfig.failsafeConfig.failsafe_procedure = 0;           // default full failsafe procedure is 0: auto-landing
 587
 588 #ifdef USE_SERVOS
 589     // servos
 590     for (int i = 0; i < MAX_SUPPORTED_SERVOS; i++) {
 591         masterConfig.servoConf[i].min = DEFAULT_SERVO_MIN;
 592         masterConfig.servoConf[i].max = DEFAULT_SERVO_MAX;
 593         masterConfig.servoConf[i].middle = DEFAULT_SERVO_MIDDLE;
 594         masterConfig.servoConf[i].rate = 100;
 595         masterConfig.servoConf[i].angleAtMin = DEFAULT_SERVO_MIN_ANGLE;
 596         masterConfig.servoConf[i].angleAtMax = DEFAULT_SERVO_MAX_ANGLE;
 597         masterConfig.servoConf[i].forwardFromChannel = CHANNEL_FORWARDING_DISABLED;
 598     }
 599
 600     // gimbal
 601     masterConfig.gimbalConfig.mode = GIMBAL_MODE_NORMAL;
 602 #endif
 603
 604 #ifdef GPS
 605     resetGpsProfile(&masterConfig.gpsProfile);
 606 #endif
 607
 608     // custom mixer. clear by defaults.
 609     for (int i = 0; i < MAX_SUPPORTED_MOTORS; i++) {
 610         masterConfig.customMotorMixer[i].throttle = 0.0f;
 611     }
 612
 613 #ifdef LED_STRIP
 614     applyDefaultColors(masterConfig.colors, CONFIGURABLE_COLOR_COUNT);
 615     applyDefaultLedStripConfig(masterConfig.ledConfigs);
 616     masterConfig.ledstrip_visual_beeper = 0;
 617 #endif
 618
 619 #ifdef VTX
 620     masterConfig.vtx_band = 4;    //Fatshark/Airwaves
 621     masterConfig.vtx_channel = 1; //CH1
 622     masterConfig.vtx_mode = 0;    //CH+BAND mode
 623     masterConfig.vtx_mhz = 5740;  //F0
 624 #endif
 625
 626 #ifdef TRANSPONDER
 627     static const uint8_t defaultTransponderData[6] = { 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC }; // Note, this is NOT a valid transponder code, it's just for testing production hardware
 628
 629     memcpy(masterConfig.transponderData, &defaultTransponderData, sizeof(defaultTransponderData));
 630 #endif
 631
 632 #ifdef BLACKBOX
 633
 634 #if defined(ENABLE_BLACKBOX_LOGGING_ON_SPIFLASH_BY_DEFAULT)
 635     featureSet(FEATURE_BLACKBOX);
 636     masterConfig.blackbox_device = BLACKBOX_DEVICE_FLASH;
 637 #elif defined(ENABLE_BLACKBOX_LOGGING_ON_SDCARD_BY_DEFAULT)
 638     featureSet(FEATURE_BLACKBOX);
 639     masterConfig.blackbox_device = BLACKBOX_DEVICE_SDCARD;
 640 #else
 641     masterConfig.blackbox_device = BLACKBOX_DEVICE_SERIAL;
 642 #endif
 643
 644     masterConfig.blackbox_rate_num = 1;
 645     masterConfig.blackbox_rate_denom = 1;
 646
 647 #endif // BLACKBOX
 648
 649 #ifdef SERIALRX_UART
 650     if (featureConfigured(FEATURE_RX_SERIAL)) {
 651         masterConfig.serialConfig.portConfigs[SERIALRX_UART].functionMask = FUNCTION_RX_SERIAL;
 652     }
 653 #endif
 654
 655     // alternative defaults settings for COLIBRI RACE targets
 656 #if defined(COLIBRI_RACE)
 657     masterConfig.escAndServoConfig.minthrottle = 1025;
 658     masterConfig.escAndServoConfig.maxthrottle = 1980;
 659     masterConfig.batteryConfig.vbatmaxcellvoltage = 45;
 660     masterConfig.batteryConfig.vbatmincellvoltage = 30;
 661 #endif
 662
 663 #if defined(TARGET_CONFIG)
 664     targetConfiguration(&masterConfig);
 665 #endif
 666
 667 #if defined(ALIENFLIGHT)
 668     featureClear(FEATURE_ONESHOT125);
 669 #ifdef ALIENFLIGHTF3
 670     masterConfig.mag_hardware = MAG_NONE;            // disabled by default
 671 #endif
 672     masterConfig.rxConfig.spektrum_sat_bind = 5;
 673     masterConfig.rxConfig.spektrum_sat_bind_autoreset = 1;
 674     masterConfig.motor_pwm_rate = 32000;
 675     masterConfig.failsafeConfig.failsafe_delay = 2;
 676     masterConfig.failsafeConfig.failsafe_off_delay = 0;
 677     currentControlRateProfile->rates[FD_PITCH] = 40;
 678     currentControlRateProfile->rates[FD_ROLL] = 40;
 679     currentControlRateProfile->rates[FD_YAW] = 40;
 680     parseRcChannels("TAER1234", &masterConfig.rxConfig);
 681
 682     masterConfig.customMotorMixer[0] = (motorMixer_t){ 1.0f, -0.414178f,  1.0f, -1.0f };    // REAR_R
 683     masterConfig.customMotorMixer[1] = (motorMixer_t){ 1.0f, -0.414178f, -1.0f,  1.0f };    // FRONT_R
 684     masterConfig.customMotorMixer[2] = (motorMixer_t){ 1.0f,  0.414178f,  1.0f,  1.0f };    // REAR_L
 685     masterConfig.customMotorMixer[3] = (motorMixer_t){ 1.0f,  0.414178f, -1.0f, -1.0f };    // FRONT_L
 686     masterConfig.customMotorMixer[4] = (motorMixer_t){ 1.0f, -1.0f, -0.414178f, -1.0f };    // MIDFRONT_R
 687     masterConfig.customMotorMixer[5] = (motorMixer_t){ 1.0f,  1.0f, -0.414178f,  1.0f };    // MIDFRONT_L
 688     masterConfig.customMotorMixer[6] = (motorMixer_t){ 1.0f, -1.0f,  0.414178f,  1.0f };    // MIDREAR_R
 689     masterConfig.customMotorMixer[7] = (motorMixer_t){ 1.0f,  1.0f,  0.414178f, -1.0f };    // MIDREAR_L#endif
 690 #endif
 691
 692     // copy first profile into remaining profile
 693     for (int i = 1; i < MAX_PROFILE_COUNT; i++) {
 694         memcpy(&masterConfig.profile[i], currentProfile, sizeof(profile_t));
 695     }
 696
 697 }
 698
 699 static uint8_t calculateChecksum(const uint8_t *data, uint32_t length)
 700 {
 701     uint8_t checksum = 0;
 702     const uint8_t *byteOffset;
 703
 704     for (byteOffset = data; byteOffset < (data + length); byteOffset++)
 705         checksum ^= *byteOffset;
 706     return checksum;
 707 }
 708
 709 static bool isEEPROMContentValid(void)
 710 {
 711     const master_t *temp = (const master_t *) CONFIG_START_FLASH_ADDRESS;
 712     uint8_t checksum = 0;
 713
 714     // check version number
 715     if (EEPROM_CONF_VERSION != temp->version)
 716         return false;
 717
 718     // check size and magic numbers
 719     if (temp->size != sizeof(master_t) || temp->magic_be != 0xBE || temp->magic_ef != 0xEF)
 720         return false;
 721
 722     // verify integrity of temporary copy
 723     checksum = calculateChecksum((const uint8_t *) temp, sizeof(master_t));
 724     if (checksum != 0)
 725         return false;
 726
 727     // looks good, let's roll!
 728     return true;
 729 }
 730
 731 void activateControlRateConfig(void)
 732 {
 733     generateThrottleCurve(currentControlRateProfile, &masterConfig.escAndServoConfig);
 734 }
 735
 736 void activateConfig(void)
 737 {
 738     static imuRuntimeConfig_t imuRuntimeConfig;
 739
 740     activateControlRateConfig();
 741
 742     resetAdjustmentStates();
 743
 744     useRcControlsConfig(
 745         masterConfig.modeActivationConditions,
 746         &masterConfig.escAndServoConfig,
 747         &currentProfile->pidProfile
 748     );
 749
 750     gyroUseConfig(&masterConfig.gyroConfig, masterConfig.gyro_soft_lpf_hz);
 751
 752 #ifdef TELEMETRY
 753     telemetryUseConfig(&masterConfig.telemetryConfig);
 754 #endif
 755     pidSetController(currentProfile->pidProfile.pidController);
 756
 757 #ifdef GPS
 758     gpsUseProfile(&masterConfig.gpsProfile);
 759     gpsUsePIDs(&currentProfile->pidProfile);
 760 #endif
 761
 762     useFailsafeConfig(&masterConfig.failsafeConfig);
 763     setAccelerationTrims(&masterConfig.accZero);
 764     setAccelerationFilter(masterConfig.acc_lpf_hz);
 765
 766     mixerUseConfigs(
 767 #ifdef USE_SERVOS
 768         masterConfig.servoConf,
 769         &masterConfig.gimbalConfig,
 770 #endif
 771         &masterConfig.flight3DConfig,
 772         &masterConfig.escAndServoConfig,
 773         &masterConfig.mixerConfig,
 774         &masterConfig.airplaneConfig,
 775         &masterConfig.rxConfig
 776     );
 777
 778     imuRuntimeConfig.dcm_kp = masterConfig.dcm_kp / 10000.0f;
 779     imuRuntimeConfig.dcm_ki = masterConfig.dcm_ki / 10000.0f;
 780     imuRuntimeConfig.acc_unarmedcal = masterConfig.acc_unarmedcal;
 781     imuRuntimeConfig.small_angle = masterConfig.small_angle;
 782
 783     imuConfigure(
 784         &imuRuntimeConfig,
 785         &currentProfile->pidProfile,
 786         &masterConfig.accDeadband,
 787         masterConfig.throttle_correction_angle
 788     );
 789
 790     configureAltitudeHold(
 791         &currentProfile->pidProfile,
 792         &masterConfig.barometerConfig,
 793         &masterConfig.rcControlsConfig,
 794         &masterConfig.escAndServoConfig
 795     );
 796
 797 #ifdef BARO
 798     useBarometerConfig(&masterConfig.barometerConfig);
 799 #endif
 800 }
 801
 802 void validateAndFixConfig(void)
 803 {
 804     if (!(featureConfigured(FEATURE_RX_PARALLEL_PWM) || featureConfigured(FEATURE_RX_PPM) || featureConfigured(FEATURE_RX_SERIAL) || featureConfigured(FEATURE_RX_MSP))) {
 805         featureSet(DEFAULT_RX_FEATURE);
 806     }
 807
 808     if (featureConfigured(FEATURE_RX_PPM)) {
 809         featureClear(FEATURE_RX_PARALLEL_PWM);
 810     }
 811
 812     if (featureConfigured(FEATURE_RX_MSP)) {
 813         featureClear(FEATURE_RX_SERIAL);
 814         featureClear(FEATURE_RX_PARALLEL_PWM);
 815         featureClear(FEATURE_RX_PPM);
 816     }
 817
 818     if (featureConfigured(FEATURE_RX_SERIAL)) {
 819         featureClear(FEATURE_RX_PARALLEL_PWM);
 820         featureClear(FEATURE_RX_PPM);
 821     }
 822
 823     if (featureConfigured(FEATURE_RX_PARALLEL_PWM)) {
 824 #if defined(STM32F10X)
 825         // rssi adc needs the same ports
 826         featureClear(FEATURE_RSSI_ADC);
 827         // current meter needs the same ports
 828         if (masterConfig.batteryConfig.currentMeterType == CURRENT_SENSOR_ADC) {
 829             featureClear(FEATURE_CURRENT_METER);
 830         }
 831 #endif
 832
 833 #if defined(STM32F10X) || defined(CHEBUZZ) || defined(STM32F3DISCOVERY)
 834         // led strip needs the same ports
 835         featureClear(FEATURE_LED_STRIP);
 836 #endif
 837
 838         // software serial needs free PWM ports
 839         featureClear(FEATURE_SOFTSERIAL);
 840     }
 841
 842
 843 #if defined(LED_STRIP) && (defined(USE_SOFTSERIAL1) || defined(USE_SOFTSERIAL2))
 844     if (featureConfigured(FEATURE_SOFTSERIAL) && (
 845             0
 846 #ifdef USE_SOFTSERIAL1
 847             || (WS2811_TIMER == SOFTSERIAL_1_TIMER)
 848 #endif
 849 #ifdef USE_SOFTSERIAL2
 850             || (WS2811_TIMER == SOFTSERIAL_2_TIMER)
 851 #endif
 852     )) {
 853         // led strip needs the same timer as softserial
 854         featureClear(FEATURE_LED_STRIP);
 855     }
 856 #endif
 857
 858 #if defined(NAZE) && defined(SONAR)
 859     if (featureConfigured(FEATURE_RX_PARALLEL_PWM) && featureConfigured(FEATURE_SONAR) && featureConfigured(FEATURE_CURRENT_METER) && masterConfig.batteryConfig.currentMeterType == CURRENT_SENSOR_ADC) {
 860         featureClear(FEATURE_CURRENT_METER);
 861     }
 862 #endif
 863
 864 #if defined(OLIMEXINO) && defined(SONAR)
 865     if (feature(FEATURE_SONAR) && feature(FEATURE_CURRENT_METER) && masterConfig.batteryConfig.currentMeterType == CURRENT_SENSOR_ADC) {
 866         featureClear(FEATURE_CURRENT_METER);
 867     }
 868 #endif
 869
 870 #if defined(CC3D) && defined(DISPLAY) && defined(USE_USART3)
 871     if (doesConfigurationUsePort(SERIAL_PORT_USART3) && feature(FEATURE_DISPLAY)) {
 872         featureClear(FEATURE_DISPLAY);
 873     }
 874 #endif
 875
 876 #ifdef STM32F303xC
 877     // hardware supports serial port inversion, make users life easier for those that want to connect SBus RX's
 878     masterConfig.telemetryConfig.telemetry_inversion = 1;
 879 #endif
 880
 881
 882 /*#if defined(LED_STRIP) && defined(TRANSPONDER) // TODO - Add transponder feature
 883     if ((WS2811_DMA_TC_FLAG == TRANSPONDER_DMA_TC_FLAG) && featureConfigured(FEATURE_TRANSPONDER) && featureConfigured(FEATURE_LED_STRIP)) {
 884         featureClear(FEATURE_LED_STRIP);
 885     }
 886 #endif
 887 */
 888
 889 #if defined(CC3D) && defined(SONAR) && defined(USE_SOFTSERIAL1) && defined(RSSI_ADC_GPIO)
 890     // shared pin
 891     if ((featureConfigured(FEATURE_SONAR) + featureConfigured(FEATURE_SOFTSERIAL) + featureConfigured(FEATURE_RSSI_ADC)) > 1) {
 892         featureClear(FEATURE_SONAR);
 893         featureClear(FEATURE_SOFTSERIAL);
 894         featureClear(FEATURE_RSSI_ADC);
 895     }
 896 #endif
 897
 898 #if defined(COLIBRI_RACE)
 899     masterConfig.serialConfig.portConfigs[0].functionMask = FUNCTION_MSP;
 900     if (featureConfigured(FEATURE_RX_PARALLEL_PWM) || featureConfigured(FEATURE_RX_MSP)) {
 901         featureClear(FEATURE_RX_PARALLEL_PWM);
 902         featureClear(FEATURE_RX_MSP);
 903         featureSet(FEATURE_RX_PPM);
 904     }
 905 #endif
 906
 907     useRxConfig(&masterConfig.rxConfig);
 908
 909     serialConfig_t *serialConfig = &masterConfig.serialConfig;
 910
 911     if (!isSerialConfigValid(serialConfig)) {
 912         resetSerialConfig(serialConfig);
 913     }
 914 }
 915
 916 void initEEPROM(void)
 917 {
 918 }
 919
 920 void readEEPROM(void)
 921 {
 922     // Sanity check
 923     if (!isEEPROMContentValid())
 924         failureMode(FAILURE_INVALID_EEPROM_CONTENTS);
 925
 926     suspendRxSignal();
 927
 928     // Read flash
 929     memcpy(&masterConfig, (char *) CONFIG_START_FLASH_ADDRESS, sizeof(master_t));
 930
 931     if (masterConfig.current_profile_index > MAX_PROFILE_COUNT - 1) // sanity check
 932         masterConfig.current_profile_index = 0;
 933
 934     setProfile(masterConfig.current_profile_index);
 935
 936     validateAndFixConfig();
 937     activateConfig();
 938
 939     resumeRxSignal();
 940 }
 941
 942 void readEEPROMAndNotify(void)
 943 {
 944     // re-read written data
 945     readEEPROM();
 946     beeperConfirmationBeeps(1);
 947 }
 948
 949 void writeEEPROM(void)
 950 {
 951     // Generate compile time error if the config does not fit in the reserved area of flash.
 952     BUILD_BUG_ON(sizeof(master_t) > FLASH_TO_RESERVE_FOR_CONFIG);
 953
 954     FLASH_Status status = 0;
 955     uint32_t wordOffset;
 956     int8_t attemptsRemaining = 3;
 957
 958     suspendRxSignal();
 959
 960     // prepare checksum/version constants
 961     masterConfig.version = EEPROM_CONF_VERSION;
 962     masterConfig.size = sizeof(master_t);
 963     masterConfig.magic_be = 0xBE;
 964     masterConfig.magic_ef = 0xEF;
 965     masterConfig.chk = 0; // erase checksum before recalculating
 966     masterConfig.chk = calculateChecksum((const uint8_t *) &masterConfig, sizeof(master_t));
 967
 968     // write it
 969     FLASH_Unlock();
 970     while (attemptsRemaining--) {
 971 #if defined(STM32F4)
 972         FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);
 973 #elif defined(STM32F303)
 974         FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPERR);
 975 #elif defined(STM32F10X)
 976         FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
 977 #endif
 978         for (wordOffset = 0; wordOffset < sizeof(master_t); wordOffset += 4) {
 979             if (wordOffset % FLASH_PAGE_SIZE == 0) {
 980 #if defined(STM32F40_41xxx)
 981                 status = FLASH_EraseSector(FLASH_Sector_8, VoltageRange_3); //0x08080000 to 0x080A0000
 982 #elif defined (STM32F411xE)
 983                 status = FLASH_EraseSector(FLASH_Sector_7, VoltageRange_3); //0x08060000 to 0x08080000
 984 #else
 985                 status = FLASH_ErasePage(CONFIG_START_FLASH_ADDRESS + wordOffset);
 986 #endif
 987                 if (status != FLASH_COMPLETE) {
 988                     break;
 989                 }
 990             }
 991
 992             status = FLASH_ProgramWord(CONFIG_START_FLASH_ADDRESS + wordOffset,
 993                     *(uint32_t *) ((char *) &masterConfig + wordOffset));
 994             if (status != FLASH_COMPLETE) {
 995                 break;
 996             }
 997         }
 998         if (status == FLASH_COMPLETE) {
 999             break;
1000         }
1001     }
1002     FLASH_Lock();
1003
1004     // Flash write failed - just die now
1005     if (status != FLASH_COMPLETE || !isEEPROMContentValid()) {
1006         failureMode(FAILURE_FLASH_WRITE_FAILED);
1007     }
1008
1009     resumeRxSignal();
1010 }
1011
1012 void ensureEEPROMContainsValidData(void)
1013 {
1014     if (isEEPROMContentValid()) {
1015         return;
1016     }
1017
1018     resetEEPROM();
1019 }
1020
1021 void resetEEPROM(void)
1022 {
1023     resetConf();
1024     writeEEPROM();
1025 }
1026
1027 void saveConfigAndNotify(void)
1028 {
1029     writeEEPROM();
1030     readEEPROMAndNotify();
1031 }
1032
1033 void changeProfile(uint8_t profileIndex)
1034 {
1035     masterConfig.current_profile_index = profileIndex;
1036     writeEEPROM();
1037     readEEPROM();
1038     beeperConfirmationBeeps(profileIndex + 1);
1039 }
1040
1041 void changeControlRateProfile(uint8_t profileIndex)
1042 {
1043     if (profileIndex > MAX_RATEPROFILES) {
1044         profileIndex = MAX_RATEPROFILES - 1;
1045     }
1046     setControlRateProfile(profileIndex);
1047     activateControlRateConfig();
1048 }
1049
1050 void latchActiveFeatures()
1051 {
1052     activeFeaturesLatch = masterConfig.enabledFeatures;
1053 }
1054
1055 bool featureConfigured(uint32_t mask)
1056 {
1057     return masterConfig.enabledFeatures & mask;
1058 }
1059
1060 bool feature(uint32_t mask)
1061 {
1062     return activeFeaturesLatch & mask;
1063 }
1064
1065 void featureSet(uint32_t mask)
1066 {
1067     masterConfig.enabledFeatures |= mask;
1068 }
1069
1070 void featureClear(uint32_t mask)
1071 {
1072     masterConfig.enabledFeatures &= ~(mask);
1073 }
1074
1075 void featureClearAll()
1076 {
1077     masterConfig.enabledFeatures = 0;
1078 }
1079
1080 uint32_t featureMask(void)
1081 {
1082     return masterConfig.enabledFeatures;
1083 }
1084
1085 void beeperOffSet(uint32_t mask)
1086 {
1087     masterConfig.beeper_off_flags |= mask;
1088 }
1089
1090 void beeperOffSetAll(uint8_t beeperCount)
1091 {
1092     masterConfig.beeper_off_flags = (1 << beeperCount) -1;
1093 }
1094
1095 void beeperOffClear(uint32_t mask)
1096 {
1097     masterConfig.beeper_off_flags &= ~(mask);
1098 }
1099
1100 void beeperOffClearAll(void)
1101 {
1102     masterConfig.beeper_off_flags = 0;
1103 }
1104
1105 uint32_t getBeeperOffMask(void)
1106 {
1107     return masterConfig.beeper_off_flags;
1108 }
1109
1110 void setBeeperOffMask(uint32_t mask)
1111 {
1112     masterConfig.beeper_off_flags = mask;
1113 }
1114
1115 uint32_t getPreferredBeeperOffMask(void)
1116 {
1117     return masterConfig.preferred_beeper_off_flags;
1118 }
1119
1120 void setPreferredBeeperOffMask(uint32_t mask)
1121 {
1122     masterConfig.preferred_beeper_off_flags = mask;
1123 }