anti desync depricated // Replaced by motor_accel_limit

src/main/config/config.c

@@ -278,7 +278,7 @@ void resetEscAndServoConfig(escAndServoConfig_t *escAndServoConfig)
 #endif
     escAndServoConfig->mincommand = 1000;
     escAndServoConfig->servoCenterPulse = 1500;
-    escAndServoConfig->escDesyncProtection = 0;
+    escAndServoConfig->accelerationLimitPercent = 15;
 }
 
 void resetFlight3DConfig(flight3DConfig_t *flight3DConfig)

src/main/flight/mixer.c

@@ -830,17 +830,40 @@ void mixTable(void)
             rollPitchYawMix[i] =  qMultiply(mixReduction,rollPitchYawMix[i]);
         }
         // Get the maximum correction by setting offset to center
-        if (!escAndServoConfig->escDesyncProtection) throttleMin = throttleMax = throttleMin + (throttleRange / 2);
+        throttleMin = throttleMax = throttleMin + (throttleRange / 2);
     } else {
         throttleMin = throttleMin + (rollPitchYawMixRange / 2);
         throttleMax = throttleMax - (rollPitchYawMixRange / 2);
     }
 
+    // Keep track for motor update timing
+    float motorDtms;
+    if (escAndServoConfig->accelerationLimitPercent) {
+        static uint32_t previousMotorTime;
+        uint32_t currentMotorTime = micros();
+        motorDtms = (float) (currentMotorTime - previousMotorTime) / 1000.0f;
+        previousMotorTime = currentMotorTime;
+    }
+
     // Now add in the desired throttle, but keep in a range that doesn't clip adjusted
     // roll/pitch/yaw. This could move throttle down, but also up for those low throttle flips.
     for (i = 0; i < motorCount; i++) {
         motor[i] = rollPitchYawMix[i] + constrain(throttle * currentMixer[i].throttle, throttleMin, throttleMax);
 
+        // Accel limit. Prevent PID controller to output huge ramps to the motors. Only limiting acceleration.
+        if (escAndServoConfig->accelerationLimitPercent) {
+            static int16_t lastFilteredMotor[MAX_SUPPORTED_MOTORS];
+
+            // acceleration limit
+            float delta    = motor[i] - lastFilteredMotor[i];
+            const float maxDeltaPerMs = throttleRange * ((float)escAndServoConfig->accelerationLimitPercent / 100.0f);
+            float maxDelta = maxDeltaPerMs * motorDtms;
+            if (delta > maxDelta) { // accelerating too hard
+                motor[i] = lastFilteredMotor[i] + maxDelta;
+            }
+            lastFilteredMotor[i] = motor[i];
+        }
+
         if (isFailsafeActive) {
             motor[i] = constrain(motor[i], escAndServoConfig->mincommand, escAndServoConfig->maxthrottle);
         } else if (feature(FEATURE_3D)) {
@@ -859,19 +882,6 @@ void mixTable(void)
                 motor[i] = escAndServoConfig->mincommand;
             }
         }
-
-        // Experimental Code. Anti Desync feature for ESC's
-        if (escAndServoConfig->escDesyncProtection) {
-            const int16_t maxThrottleStep = constrain(escAndServoConfig->escDesyncProtection / (1000 / targetPidLooptime), 5, 10000);
-
-            // Only makes sense when it's within the range
-            if (maxThrottleStep < throttleRange) {
-                static int16_t motorPrevious[MAX_SUPPORTED_MOTORS];
-
-                motor[i] = constrain(motor[i], motorPrevious[i] - maxThrottleStep, motorPrevious[i] + maxThrottleStep);
-                motorPrevious[i] = motor[i];
-            }
-        }
     }
 
     // Disarmed mode

src/main/io/escservo.h

@@ -24,5 +24,5 @@ typedef struct escAndServoConfig_s {
     uint16_t maxthrottle;                   // This is the maximum value for the ESCs at full power this value can be increased up to 2000
     uint16_t mincommand;                    // This is the value for the ESCs when they are not armed. In some cases, this value must be lowered down to 900 for some specific ESCs
     uint16_t servoCenterPulse;              // This is the value for servos when they should be in the middle. e.g. 1500.
-    uint16_t escDesyncProtection;           // Value that a motor is allowed to increase or decrease in a period of 1ms
+    uint16_t accelerationLimitPercent;      // Percentage that motor is allowed to increase or decrease in a period of 1ms
 } escAndServoConfig_t;

src/main/io/serial_cli.c

@@ -601,7 +601,7 @@ const clivalue_t valueTable[] = {
     { "min_throttle",               VAR_UINT16 | MASTER_VALUE,  &masterConfig.escAndServoConfig.minthrottle, .config.minmax = { PWM_RANGE_ZERO,  PWM_RANGE_MAX } },
     { "max_throttle",               VAR_UINT16 | MASTER_VALUE,  &masterConfig.escAndServoConfig.maxthrottle, .config.minmax = { PWM_RANGE_ZERO,  PWM_RANGE_MAX } },
     { "min_command",                VAR_UINT16 | MASTER_VALUE,  &masterConfig.escAndServoConfig.mincommand, .config.minmax = { PWM_RANGE_ZERO,  PWM_RANGE_MAX } },
-    { "anti_desync_power_step",     VAR_UINT16 | MASTER_VALUE,  &masterConfig.escAndServoConfig.escDesyncProtection, .config.minmax = { 0,  10000 } },
+    { "motor_accel_limit_percent",  VAR_UINT16 | MASTER_VALUE,  &masterConfig.escAndServoConfig.accelerationLimitPercent, .config.minmax = { 0,  10000 } },
     { "servo_center_pulse",         VAR_UINT16 | MASTER_VALUE,  &masterConfig.escAndServoConfig.servoCenterPulse, .config.minmax = { PWM_RANGE_ZERO,  PWM_RANGE_MAX } },
 
     { "3d_deadband_low",            VAR_UINT16 | MASTER_VALUE,  &masterConfig.flight3DConfig.deadband3d_low, .config.minmax = { PWM_RANGE_ZERO,  PWM_RANGE_MAX } }, // FIXME upper limit should match code in the mixer, 1500 currently

src/main/io/serial_msp.c

@@ -1226,7 +1226,7 @@ static bool processOutCommand(uint8_t cmdMSP)
         serialize8(currentControlRateProfile->rcYawRate8);
         serialize16(masterConfig.rxConfig.airModeActivateThreshold);
         serialize8(masterConfig.rxConfig.rcSmoothInterval);
-        serialize16(masterConfig.escAndServoConfig.escDesyncProtection);
+        serialize16(masterConfig.escAndServoConfig.accelerationLimitPercent);
         break;
     case MSP_SENSOR_CONFIG:
         headSerialReply(3);
@@ -1801,7 +1801,7 @@ static bool processInCommand(void)
         currentControlRateProfile->rcYawRate8 = read8();
         masterConfig.rxConfig.airModeActivateThreshold = read16();
         masterConfig.rxConfig.rcSmoothInterval = read8();
-        masterConfig.escAndServoConfig.escDesyncProtection = read16();
+        masterConfig.escAndServoConfig.accelerationLimitPercent = read16();
         break;
     case MSP_SET_SENSOR_CONFIG:
         masterConfig.acc_hardware = read8();