Mirror/betaflight
1
0
Fork 0
mirror of https://github.com/betaflight/betaflight.git synced 2025-07-25 17:25:20 +03:00
Code Issues Wiki Activity

Remove d min confusion (#13908)

Browse source 
* rename dMin, remove D_MIN_GAIN_MAX

* rename vars

* fix logic

* fix logic

* Revert "fix tests"

This reverts commit c518c9c444.

* Revert "add yaw and other adjustment cases"

This reverts commit 2cacd4b360.

* Revert "fix unit test"

This reverts commit 3d88f4158a.

* Revert "fix D adjustments change dmax instead of D"

This reverts commit 7ee4e7f8af.

* Revert "Fix telemetry for Spektrum/SRXL (#13814)"

This reverts commit 04fe4b4461.

* review adjustments and test fixes

* Reapply "Fix telemetry for Spektrum/SRXL (#13814)"

This reverts commit eb7f8ee0fd.

* fix logic

* Apply suggestions from code review

Co-authored-by: Jan Post <Rm2k-Freak@web.de>
Co-authored-by: Mark Haslinghuis <mark@numloq.nl>

* fix d_max slider

---------

Co-authored-by: Jan Post <Rm2k-Freak@web.de>
Co-authored-by: Mark Haslinghuis <mark@numloq.nl>
This commit is contained in:
MikeNomatter 2024-09-24 11:28:25 +02:00 • committed by GitHub
parent c0c24d7f52
commit 908f9cc32d
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
16 changed files with 143 additions and 154 deletions
Download patch file Download diff file Expand all files Collapse all files

14
src/main/blackbox/blackbox.c
View file

@ -1465,12 +1465,12 @@ static bool blackboxWriteSysinfo(void)
currentPidProfile->pid[PID_LEVEL].I, currentPidProfile->pid[PID_LEVEL].I,
currentPidProfile->pid[PID_LEVEL].D); currentPidProfile->pid[PID_LEVEL].D);
BLACKBOX_PRINT_HEADER_LINE("magPID", "%d", currentPidProfile->pid[PID_MAG].P); BLACKBOX_PRINT_HEADER_LINE("magPID", "%d", currentPidProfile->pid[PID_MAG].P);
#ifdef USE_D_MIN #ifdef USE_D_MAX
BLACKBOX_PRINT_HEADER_LINE("d_min", "%d,%d,%d", currentPidProfile->d_min[ROLL], BLACKBOX_PRINT_HEADER_LINE("d_max", "%d,%d,%d", currentPidProfile->d_max[ROLL],
currentPidProfile->d_min[PITCH], currentPidProfile->d_max[PITCH],
currentPidProfile->d_min[YAW]); currentPidProfile->d_max[YAW]);
BLACKBOX_PRINT_HEADER_LINE(PARAM_NAME_D_MAX_GAIN, "%d", currentPidProfile->d_min_gain); BLACKBOX_PRINT_HEADER_LINE(PARAM_NAME_D_MAX_GAIN, "%d", currentPidProfile->d_max_gain);
BLACKBOX_PRINT_HEADER_LINE(PARAM_NAME_D_MAX_ADVANCE, "%d", currentPidProfile->d_min_advance); BLACKBOX_PRINT_HEADER_LINE(PARAM_NAME_D_MAX_ADVANCE, "%d", currentPidProfile->d_max_advance);
#endif #endif
BLACKBOX_PRINT_HEADER_LINE(PARAM_NAME_DTERM_LPF1_TYPE, "%d", currentPidProfile->dterm_lpf1_type); BLACKBOX_PRINT_HEADER_LINE(PARAM_NAME_DTERM_LPF1_TYPE, "%d", currentPidProfile->dterm_lpf1_type);
BLACKBOX_PRINT_HEADER_LINE(PARAM_NAME_DTERM_LPF1_STATIC_HZ, "%d", currentPidProfile->dterm_lpf1_static_hz); BLACKBOX_PRINT_HEADER_LINE(PARAM_NAME_DTERM_LPF1_STATIC_HZ, "%d", currentPidProfile->dterm_lpf1_static_hz);
@ -1641,7 +1641,7 @@ static bool blackboxWriteSysinfo(void)
BLACKBOX_PRINT_HEADER_LINE(PARAM_NAME_SIMPLIFIED_I_GAIN, "%d", currentPidProfile->simplified_i_gain); BLACKBOX_PRINT_HEADER_LINE(PARAM_NAME_SIMPLIFIED_I_GAIN, "%d", currentPidProfile->simplified_i_gain);
BLACKBOX_PRINT_HEADER_LINE(PARAM_NAME_SIMPLIFIED_D_GAIN, "%d", currentPidProfile->simplified_d_gain); BLACKBOX_PRINT_HEADER_LINE(PARAM_NAME_SIMPLIFIED_D_GAIN, "%d", currentPidProfile->simplified_d_gain);
BLACKBOX_PRINT_HEADER_LINE(PARAM_NAME_SIMPLIFIED_PI_GAIN, "%d", currentPidProfile->simplified_pi_gain); BLACKBOX_PRINT_HEADER_LINE(PARAM_NAME_SIMPLIFIED_PI_GAIN, "%d", currentPidProfile->simplified_pi_gain);
BLACKBOX_PRINT_HEADER_LINE(PARAM_NAME_SIMPLIFIED_DMAX_GAIN, "%d", currentPidProfile->simplified_dmin_ratio); BLACKBOX_PRINT_HEADER_LINE(PARAM_NAME_SIMPLIFIED_D_MAX_GAIN, "%d", currentPidProfile->simplified_d_max_gain);
BLACKBOX_PRINT_HEADER_LINE(PARAM_NAME_SIMPLIFIED_FEEDFORWARD_GAIN, "%d", currentPidProfile->simplified_feedforward_gain); BLACKBOX_PRINT_HEADER_LINE(PARAM_NAME_SIMPLIFIED_FEEDFORWARD_GAIN, "%d", currentPidProfile->simplified_feedforward_gain);
BLACKBOX_PRINT_HEADER_LINE(PARAM_NAME_SIMPLIFIED_PITCH_D_GAIN, "%d", currentPidProfile->simplified_roll_pitch_ratio); BLACKBOX_PRINT_HEADER_LINE(PARAM_NAME_SIMPLIFIED_PITCH_D_GAIN, "%d", currentPidProfile->simplified_roll_pitch_ratio);
BLACKBOX_PRINT_HEADER_LINE(PARAM_NAME_SIMPLIFIED_PITCH_PI_GAIN, "%d", currentPidProfile->simplified_pitch_pi_gain); BLACKBOX_PRINT_HEADER_LINE(PARAM_NAME_SIMPLIFIED_PITCH_PI_GAIN, "%d", currentPidProfile->simplified_pitch_pi_gain);

2
src/main/build/debug.c
View file

@ -74,7 +74,7 @@ const char * const debugModeNames[DEBUG_COUNT] = {
[DEBUG_RX_SPEKTRUM_SPI] = "RX_SPEKTRUM_SPI", [DEBUG_RX_SPEKTRUM_SPI] = "RX_SPEKTRUM_SPI",
[DEBUG_DSHOT_RPM_TELEMETRY] = "DSHOT_RPM_TELEMETRY", [DEBUG_DSHOT_RPM_TELEMETRY] = "DSHOT_RPM_TELEMETRY",
[DEBUG_RPM_FILTER] = "RPM_FILTER", [DEBUG_RPM_FILTER] = "RPM_FILTER",
[DEBUG_D_MIN] = "D_MIN", [DEBUG_D_MAX] = "D_MAX",
[DEBUG_AC_CORRECTION] = "AC_CORRECTION", [DEBUG_AC_CORRECTION] = "AC_CORRECTION",
[DEBUG_AC_ERROR] = "AC_ERROR", [DEBUG_AC_ERROR] = "AC_ERROR",
[DEBUG_DUAL_GYRO_SCALED] = "DUAL_GYRO_SCALED", [DEBUG_DUAL_GYRO_SCALED] = "DUAL_GYRO_SCALED",

2
src/main/build/debug.h
View file

@ -76,7 +76,7 @@ typedef enum {
DEBUG_RX_SPEKTRUM_SPI, DEBUG_RX_SPEKTRUM_SPI,
DEBUG_DSHOT_RPM_TELEMETRY, DEBUG_DSHOT_RPM_TELEMETRY,
DEBUG_RPM_FILTER, DEBUG_RPM_FILTER,
DEBUG_D_MIN, DEBUG_D_MAX,
DEBUG_AC_CORRECTION, DEBUG_AC_CORRECTION,
DEBUG_AC_ERROR, DEBUG_AC_ERROR,
DEBUG_DUAL_GYRO_SCALED, DEBUG_DUAL_GYRO_SCALED,

14
src/main/cli/settings.c
View file

@ -1214,12 +1214,12 @@ const clivalue_t valueTable[] = {
{ "integrated_yaw_relax", VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { 0, 255 }, PG_PID_PROFILE, offsetof(pidProfile_t, integrated_yaw_relax) }, { "integrated_yaw_relax", VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { 0, 255 }, PG_PID_PROFILE, offsetof(pidProfile_t, integrated_yaw_relax) },
#endif #endif
#ifdef USE_D_MIN #ifdef USE_D_MAX
{ "d_min_roll", VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { 0, D_MIN_GAIN_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, d_min[FD_ROLL]) }, { "d_max_roll", VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { 0, PID_GAIN_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, d_max[FD_ROLL]) },
{ "d_min_pitch", VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { 0, D_MIN_GAIN_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, d_min[FD_PITCH]) }, { "d_max_pitch", VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { 0, PID_GAIN_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, d_max[FD_PITCH]) },
{ "d_min_yaw", VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { 0, D_MIN_GAIN_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, d_min[FD_YAW]) }, { "d_max_yaw", VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { 0, PID_GAIN_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, d_max[FD_YAW]) },
{ PARAM_NAME_D_MAX_GAIN, VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { 0, 100 }, PG_PID_PROFILE, offsetof(pidProfile_t, d_min_gain) }, { PARAM_NAME_D_MAX_GAIN, VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { 0, 100 }, PG_PID_PROFILE, offsetof(pidProfile_t, d_max_gain) },
{ PARAM_NAME_D_MAX_ADVANCE, VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { 0, 200 }, PG_PID_PROFILE, offsetof(pidProfile_t, d_min_advance) }, { PARAM_NAME_D_MAX_ADVANCE, VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { 0, 200 }, PG_PID_PROFILE, offsetof(pidProfile_t, d_max_advance) },
#endif #endif
{ PARAM_NAME_MOTOR_OUTPUT_LIMIT, VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { MOTOR_OUTPUT_LIMIT_PERCENT_MIN, MOTOR_OUTPUT_LIMIT_PERCENT_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, motor_output_limit) }, { PARAM_NAME_MOTOR_OUTPUT_LIMIT, VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { MOTOR_OUTPUT_LIMIT_PERCENT_MIN, MOTOR_OUTPUT_LIMIT_PERCENT_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, motor_output_limit) },
@ -1268,7 +1268,7 @@ const clivalue_t valueTable[] = {
{ PARAM_NAME_SIMPLIFIED_I_GAIN, VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SIMPLIFIED_TUNING_PIDS_MIN, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_i_gain) }, { PARAM_NAME_SIMPLIFIED_I_GAIN, VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SIMPLIFIED_TUNING_PIDS_MIN, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_i_gain) },
{ PARAM_NAME_SIMPLIFIED_D_GAIN, VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SIMPLIFIED_TUNING_PIDS_MIN, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_d_gain) }, { PARAM_NAME_SIMPLIFIED_D_GAIN, VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SIMPLIFIED_TUNING_PIDS_MIN, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_d_gain) },
{ PARAM_NAME_SIMPLIFIED_PI_GAIN, VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SIMPLIFIED_TUNING_PIDS_MIN, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_pi_gain) }, { PARAM_NAME_SIMPLIFIED_PI_GAIN, VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SIMPLIFIED_TUNING_PIDS_MIN, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_pi_gain) },
{ PARAM_NAME_SIMPLIFIED_DMAX_GAIN, VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { 0, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_dmin_ratio) }, { PARAM_NAME_SIMPLIFIED_D_MAX_GAIN, VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { 0, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_d_max_gain) },
{ PARAM_NAME_SIMPLIFIED_FEEDFORWARD_GAIN, VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { 0, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_feedforward_gain) }, { PARAM_NAME_SIMPLIFIED_FEEDFORWARD_GAIN, VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { 0, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_feedforward_gain) },
{ PARAM_NAME_SIMPLIFIED_PITCH_D_GAIN, VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SIMPLIFIED_TUNING_PIDS_MIN, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_roll_pitch_ratio) }, { PARAM_NAME_SIMPLIFIED_PITCH_D_GAIN, VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SIMPLIFIED_TUNING_PIDS_MIN, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_roll_pitch_ratio) },
{ PARAM_NAME_SIMPLIFIED_PITCH_PI_GAIN, VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SIMPLIFIED_TUNING_PIDS_MIN, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_pitch_pi_gain) }, { PARAM_NAME_SIMPLIFIED_PITCH_PI_GAIN, VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SIMPLIFIED_TUNING_PIDS_MIN, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_pitch_pi_gain) },

56
src/main/cms/cms_menu_imu.c
View file

@ -251,8 +251,8 @@ static uint8_t cmsx_simplified_roll_pitch_ratio;
static uint8_t cmsx_simplified_i_gain; static uint8_t cmsx_simplified_i_gain;
static uint8_t cmsx_simplified_d_gain; static uint8_t cmsx_simplified_d_gain;
static uint8_t cmsx_simplified_pi_gain; static uint8_t cmsx_simplified_pi_gain;
#ifdef USE_D_MIN #ifdef USE_D_MAX
static uint8_t cmsx_simplified_dmin_ratio; static uint8_t cmsx_simplified_d_max_gain;
#endif #endif
static uint8_t cmsx_simplified_feedforward_gain; static uint8_t cmsx_simplified_feedforward_gain;
static uint8_t cmsx_simplified_pitch_pi_gain; static uint8_t cmsx_simplified_pitch_pi_gain;
@ -280,8 +280,8 @@ static const void *cmsx_simplifiedTuningOnEnter(displayPort_t *pDisp)
cmsx_simplified_i_gain = pidProfile->simplified_i_gain; cmsx_simplified_i_gain = pidProfile->simplified_i_gain;
cmsx_simplified_d_gain = pidProfile->simplified_d_gain; cmsx_simplified_d_gain = pidProfile->simplified_d_gain;
cmsx_simplified_pi_gain = pidProfile->simplified_pi_gain; cmsx_simplified_pi_gain = pidProfile->simplified_pi_gain;
#ifdef USE_D_MIN #ifdef USE_D_MAX
cmsx_simplified_dmin_ratio = pidProfile->simplified_dmin_ratio; cmsx_simplified_d_max_gain = pidProfile->simplified_d_max_gain;
#endif #endif
cmsx_simplified_feedforward_gain = pidProfile->simplified_feedforward_gain; cmsx_simplified_feedforward_gain = pidProfile->simplified_feedforward_gain;
cmsx_simplified_pitch_pi_gain = pidProfile->simplified_pitch_pi_gain; cmsx_simplified_pitch_pi_gain = pidProfile->simplified_pitch_pi_gain;
@ -307,8 +307,8 @@ static const void *cmsx_simplifiedTuningOnExit(displayPort_t *pDisp, const OSD_E
|| pidProfile->simplified_i_gain != cmsx_simplified_i_gain || pidProfile->simplified_i_gain != cmsx_simplified_i_gain
|| pidProfile->simplified_d_gain != cmsx_simplified_d_gain || pidProfile->simplified_d_gain != cmsx_simplified_d_gain
|| pidProfile->simplified_pi_gain != cmsx_simplified_pi_gain || pidProfile->simplified_pi_gain != cmsx_simplified_pi_gain
#ifdef USE_D_MIN #ifdef USE_D_MAX
|| pidProfile->simplified_dmin_ratio != cmsx_simplified_dmin_ratio || pidProfile->simplified_d_max_gain != cmsx_simplified_d_max_gain
#endif #endif
|| pidProfile->simplified_feedforward_gain != cmsx_simplified_feedforward_gain || pidProfile->simplified_feedforward_gain != cmsx_simplified_feedforward_gain
|| pidProfile->simplified_pitch_pi_gain != cmsx_simplified_pitch_pi_gain || pidProfile->simplified_pitch_pi_gain != cmsx_simplified_pitch_pi_gain
@ -324,8 +324,8 @@ static const void *cmsx_simplifiedTuningOnExit(displayPort_t *pDisp, const OSD_E
pidProfile->simplified_i_gain = cmsx_simplified_i_gain; pidProfile->simplified_i_gain = cmsx_simplified_i_gain;
pidProfile->simplified_d_gain = cmsx_simplified_d_gain; pidProfile->simplified_d_gain = cmsx_simplified_d_gain;
pidProfile->simplified_pi_gain = cmsx_simplified_pi_gain; pidProfile->simplified_pi_gain = cmsx_simplified_pi_gain;
#ifdef USE_D_MIN #ifdef USE_D_MAX
pidProfile->simplified_dmin_ratio = cmsx_simplified_dmin_ratio; pidProfile->simplified_d_max_gain = cmsx_simplified_d_max_gain;
#endif #endif
pidProfile->simplified_feedforward_gain = cmsx_simplified_feedforward_gain; pidProfile->simplified_feedforward_gain = cmsx_simplified_feedforward_gain;
pidProfile->simplified_pitch_pi_gain = cmsx_simplified_pitch_pi_gain; pidProfile->simplified_pitch_pi_gain = cmsx_simplified_pitch_pi_gain;
@ -352,8 +352,8 @@ static const OSD_Entry cmsx_menuSimplifiedTuningEntries[] =
{ "FF GAINS", OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_simplified_feedforward_gain, SIMPLIFIED_TUNING_PIDS_MIN, SIMPLIFIED_TUNING_MAX, 5, 10 } }, { "FF GAINS", OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_simplified_feedforward_gain, SIMPLIFIED_TUNING_PIDS_MIN, SIMPLIFIED_TUNING_MAX, 5, 10 } },
{ "-- EXPERT --", OME_Label, NULL, NULL}, { "-- EXPERT --", OME_Label, NULL, NULL},
#ifdef USE_D_MIN #ifdef USE_D_MAX
{ "D MAX", OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_simplified_dmin_ratio, SIMPLIFIED_TUNING_PIDS_MIN, SIMPLIFIED_TUNING_MAX, 5, 10 } }, { "D MAX", OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_simplified_d_max_gain, SIMPLIFIED_TUNING_PIDS_MIN, SIMPLIFIED_TUNING_MAX, 5, 10 } },
#endif #endif
{ "I GAINS", OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_simplified_i_gain, SIMPLIFIED_TUNING_PIDS_MIN, SIMPLIFIED_TUNING_MAX, 5, 10 } }, { "I GAINS", OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_simplified_i_gain, SIMPLIFIED_TUNING_PIDS_MIN, SIMPLIFIED_TUNING_MAX, 5, 10 } },
@ -527,10 +527,10 @@ static uint8_t cmsx_thrustLinearization;
static uint8_t cmsx_antiGravityGain; static uint8_t cmsx_antiGravityGain;
static uint8_t cmsx_motorOutputLimit; static uint8_t cmsx_motorOutputLimit;
static int8_t cmsx_autoProfileCellCount; static int8_t cmsx_autoProfileCellCount;
#ifdef USE_D_MIN #ifdef USE_D_MAX
static uint8_t cmsx_d_min[XYZ_AXIS_COUNT]; static uint8_t cmsx_d_max[XYZ_AXIS_COUNT];
static uint8_t cmsx_d_min_gain; static uint8_t cmsx_d_max_gain;
static uint8_t cmsx_d_min_advance; static uint8_t cmsx_d_max_advance;
#endif #endif
#ifdef USE_BATTERY_VOLTAGE_SAG_COMPENSATION #ifdef USE_BATTERY_VOLTAGE_SAG_COMPENSATION
@ -581,12 +581,12 @@ static const void *cmsx_profileOtherOnEnter(displayPort_t *pDisp)
cmsx_motorOutputLimit = pidProfile->motor_output_limit; cmsx_motorOutputLimit = pidProfile->motor_output_limit;
cmsx_autoProfileCellCount = pidProfile->auto_profile_cell_count; cmsx_autoProfileCellCount = pidProfile->auto_profile_cell_count;
#ifdef USE_D_MIN #ifdef USE_D_MAX
for (unsigned i = 0; i < XYZ_AXIS_COUNT; i++) { for (unsigned i = 0; i < XYZ_AXIS_COUNT; i++) {
cmsx_d_min[i] = pidProfile->d_min[i]; cmsx_d_max[i] = pidProfile->d_max[i];
} }
cmsx_d_min_gain = pidProfile->d_min_gain; cmsx_d_max_gain = pidProfile->d_max_gain;
cmsx_d_min_advance = pidProfile->d_min_advance; cmsx_d_max_advance = pidProfile->d_max_advance;
#endif #endif
#ifdef USE_ITERM_RELAX #ifdef USE_ITERM_RELAX
@ -639,12 +639,12 @@ static const void *cmsx_profileOtherOnExit(displayPort_t *pDisp, const OSD_Entry
pidProfile->motor_output_limit = cmsx_motorOutputLimit; pidProfile->motor_output_limit = cmsx_motorOutputLimit;
pidProfile->auto_profile_cell_count = cmsx_autoProfileCellCount; pidProfile->auto_profile_cell_count = cmsx_autoProfileCellCount;
#ifdef USE_D_MIN #ifdef USE_D_MAX
for (unsigned i = 0; i < XYZ_AXIS_COUNT; i++) { for (unsigned i = 0; i < XYZ_AXIS_COUNT; i++) {
pidProfile->d_min[i] = cmsx_d_min[i]; pidProfile->d_max[i] = cmsx_d_max[i];
} }
pidProfile->d_min_gain = cmsx_d_min_gain; pidProfile->d_max_gain = cmsx_d_max_gain;
pidProfile->d_min_advance = cmsx_d_min_advance; pidProfile->d_max_advance = cmsx_d_max_advance;
#endif #endif
#ifdef USE_ITERM_RELAX #ifdef USE_ITERM_RELAX
@ -713,12 +713,12 @@ static const OSD_Entry cmsx_menuProfileOtherEntries[] = {
{ "AUTO CELL CNT", OME_INT8, NULL, &(OSD_INT8_t) { &cmsx_autoProfileCellCount, AUTO_PROFILE_CELL_COUNT_CHANGE, MAX_AUTO_DETECT_CELL_COUNT, 1} }, { "AUTO CELL CNT", OME_INT8, NULL, &(OSD_INT8_t) { &cmsx_autoProfileCellCount, AUTO_PROFILE_CELL_COUNT_CHANGE, MAX_AUTO_DETECT_CELL_COUNT, 1} },
#ifdef USE_D_MIN #ifdef USE_D_MAX
{ "D_MIN ROLL", OME_UINT8 | SLIDER_RP, NULL, &(OSD_UINT8_t) { &cmsx_d_min[FD_ROLL], 0, 100, 1 } }, { "D_MAX ROLL", OME_UINT8 | SLIDER_RP, NULL, &(OSD_UINT8_t) { &cmsx_d_max[FD_ROLL], 0, 100, 1 } },
{ "D_MIN PITCH", OME_UINT8 | SLIDER_RP, NULL, &(OSD_UINT8_t) { &cmsx_d_min[FD_PITCH], 0, 100, 1 } }, { "D_MAX PITCH", OME_UINT8 | SLIDER_RP, NULL, &(OSD_UINT8_t) { &cmsx_d_max[FD_PITCH], 0, 100, 1 } },
{ "D_MIN YAW", OME_UINT8 | SLIDER_RPY, NULL, &(OSD_UINT8_t) { &cmsx_d_min[FD_YAW], 0, 100, 1 } }, { "D_MAX YAW", OME_UINT8 | SLIDER_RPY, NULL, &(OSD_UINT8_t) { &cmsx_d_max[FD_YAW], 0, 100, 1 } },
{ "D_MIN GAIN", OME_UINT8, NULL, &(OSD_UINT8_t) { &cmsx_d_min_gain, 0, 100, 1 } }, { "D_MAX GAIN", OME_UINT8, NULL, &(OSD_UINT8_t) { &cmsx_d_max_gain, 0, 100, 1 } },
{ "D_MIN ADV", OME_UINT8, NULL, &(OSD_UINT8_t) { &cmsx_d_min_advance, 0, 200, 1 } }, { "D_MAX ADV", OME_UINT8, NULL, &(OSD_UINT8_t) { &cmsx_d_max_advance, 0, 200, 1 } },
#endif #endif
#ifdef USE_BATTERY_VOLTAGE_SAG_COMPENSATION #ifdef USE_BATTERY_VOLTAGE_SAG_COMPENSATION

6
src/main/config/config.c
View file

@ -275,10 +275,10 @@ static void validateAndFixConfig(void)
pidProfilesMutable(i)->auto_profile_cell_count = AUTO_PROFILE_CELL_COUNT_STAY; pidProfilesMutable(i)->auto_profile_cell_count = AUTO_PROFILE_CELL_COUNT_STAY;
} }
// If the d_min value for any axis is >= the D gain then reset d_min to 0 for consistent Configurator behavior // If the d_max value for any axis is <= the D gain then reset d_max to 0 for consistent Configurator behavior
for (unsigned axis = 0; axis <= FD_YAW; axis++) { for (unsigned axis = 0; axis <= FD_YAW; axis++) {
if (pidProfilesMutable(i)->d_min[axis] > pidProfilesMutable(i)->pid[axis].D) { if (pidProfilesMutable(i)->d_max[axis] < pidProfilesMutable(i)->pid[axis].D) {
pidProfilesMutable(i)->d_min[axis] = 0; pidProfilesMutable(i)->d_max[axis] = 0;
} }
} }

19
src/main/config/simplified_tuning.c
View file

@ -36,8 +36,8 @@ static void calculateNewPidValues(pidProfile_t *pidProfile)
[PID_YAW] = PID_YAW_DEFAULT, [PID_YAW] = PID_YAW_DEFAULT,
}; };
#ifdef USE_D_MIN #ifdef USE_D_MAX
const int dMinDefaults[FLIGHT_DYNAMICS_INDEX_COUNT] = D_MIN_DEFAULT; const int dMaxDefaults[FLIGHT_DYNAMICS_INDEX_COUNT] = D_MAX_DEFAULT;
#endif #endif
const float masterMultiplier = pidProfile->simplified_master_multiplier / 100.0f; const float masterMultiplier = pidProfile->simplified_master_multiplier / 100.0f;
const float piGain = pidProfile->simplified_pi_gain / 100.0f; const float piGain = pidProfile->simplified_pi_gain / 100.0f;
@ -50,14 +50,15 @@ static void calculateNewPidValues(pidProfile_t *pidProfile)
const float pitchPiGain = (axis == FD_PITCH) ? pidProfile->simplified_pitch_pi_gain / 100.0f : 1.0f; const float pitchPiGain = (axis == FD_PITCH) ? pidProfile->simplified_pitch_pi_gain / 100.0f : 1.0f;
pidProfile->pid[axis].P = constrain(pidDefaults[axis].P * masterMultiplier * piGain * pitchPiGain, 0, PID_GAIN_MAX); pidProfile->pid[axis].P = constrain(pidDefaults[axis].P * masterMultiplier * piGain * pitchPiGain, 0, PID_GAIN_MAX);
pidProfile->pid[axis].I = constrain(pidDefaults[axis].I * masterMultiplier * piGain * iGain * pitchPiGain, 0, PID_GAIN_MAX); pidProfile->pid[axis].I = constrain(pidDefaults[axis].I * masterMultiplier * piGain * iGain * pitchPiGain, 0, PID_GAIN_MAX);
#ifdef USE_D_MIN pidProfile->pid[axis].D = constrain(pidDefaults[axis].D * masterMultiplier * dGain * pitchDGain, 0, PID_GAIN_MAX);
const float dminRatio = (dMinDefaults[axis] > 0) ? 1.0f + (((float)pidDefaults[axis].D - dMinDefaults[axis]) / dMinDefaults[axis]) * (pidProfile->simplified_dmin_ratio / 100.0f) : 1.0f;
pidProfile->pid[axis].D = constrain(dMinDefaults[axis] * masterMultiplier * dGain * pitchDGain * dminRatio, 0, PID_GAIN_MAX);
pidProfile->d_min[axis] = constrain(dMinDefaults[axis] * masterMultiplier * dGain * pitchDGain, 0, PID_GAIN_MAX);
#else
pidProfile->pid[axis].D = constrain(dMinDefaults[axis] * masterMultiplier * dGain * pitchDGain, 0, PID_GAIN_MAX);
#endif
pidProfile->pid[axis].F = constrain(pidDefaults[axis].F * masterMultiplier * pitchPiGain * feedforwardGain, 0, F_GAIN_MAX); pidProfile->pid[axis].F = constrain(pidDefaults[axis].F * masterMultiplier * pitchPiGain * feedforwardGain, 0, F_GAIN_MAX);
#ifdef USE_D_MAX
const float dMaxGain = (dMaxDefaults[axis] > 0)
? pidProfile->simplified_d_max_gain / 100.0f + (1 - pidProfile->simplified_d_max_gain / 100.0f) * pidDefaults[axis].D / dMaxDefaults[axis]
: 1.0f;
pidProfile->d_max[axis] = constrain(dMaxDefaults[axis] * masterMultiplier * dGain * pitchDGain * dMaxGain, 0, PID_GAIN_MAX);
#endif
} }
} }

2
src/main/fc/parameter_names.h
View file

@ -133,7 +133,7 @@
#define PARAM_NAME_SIMPLIFIED_I_GAIN "simplified_i_gain" #define PARAM_NAME_SIMPLIFIED_I_GAIN "simplified_i_gain"
#define PARAM_NAME_SIMPLIFIED_D_GAIN "simplified_d_gain" #define PARAM_NAME_SIMPLIFIED_D_GAIN "simplified_d_gain"
#define PARAM_NAME_SIMPLIFIED_PI_GAIN "simplified_pi_gain" #define PARAM_NAME_SIMPLIFIED_PI_GAIN "simplified_pi_gain"
#define PARAM_NAME_SIMPLIFIED_DMAX_GAIN "simplified_dmax_gain" #define PARAM_NAME_SIMPLIFIED_D_MAX_GAIN "simplified_d_max_gain"
#define PARAM_NAME_SIMPLIFIED_FEEDFORWARD_GAIN "simplified_feedforward_gain" #define PARAM_NAME_SIMPLIFIED_FEEDFORWARD_GAIN "simplified_feedforward_gain"
#define PARAM_NAME_SIMPLIFIED_PITCH_D_GAIN "simplified_pitch_d_gain" #define PARAM_NAME_SIMPLIFIED_PITCH_D_GAIN "simplified_pitch_d_gain"
#define PARAM_NAME_SIMPLIFIED_PITCH_PI_GAIN "simplified_pitch_pi_gain" #define PARAM_NAME_SIMPLIFIED_PITCH_PI_GAIN "simplified_pitch_pi_gain"

18
src/main/fc/rc_adjustments.c
View file

@ -364,8 +364,8 @@ static int applyStepAdjustment(controlRateConfig_t *controlRateConfig, uint8_t a
break; break;
case ADJUSTMENT_PITCH_ROLL_D: case ADJUSTMENT_PITCH_ROLL_D:
case ADJUSTMENT_PITCH_D: case ADJUSTMENT_PITCH_D:
newValue = constrain((int)currentPidProfile->d_min[FD_PITCH] + delta, 0, 200); // FIXME magic numbers repeated in cli.c newValue = constrain((int)currentPidProfile->pid[PID_PITCH].D + delta, 0, 200); // FIXME magic numbers repeated in cli.c
currentPidProfile->d_min[FD_PITCH] = newValue; currentPidProfile->pid[PID_PITCH].D = newValue;
blackboxLogInflightAdjustmentEvent(ADJUSTMENT_PITCH_D, newValue); blackboxLogInflightAdjustmentEvent(ADJUSTMENT_PITCH_D, newValue);
if (adjustmentFunction == ADJUSTMENT_PITCH_D) { if (adjustmentFunction == ADJUSTMENT_PITCH_D) {
break; break;
@ -373,8 +373,8 @@ static int applyStepAdjustment(controlRateConfig_t *controlRateConfig, uint8_t a
// fall through for combined ADJUSTMENT_PITCH_ROLL_D // fall through for combined ADJUSTMENT_PITCH_ROLL_D
FALLTHROUGH; FALLTHROUGH;
case ADJUSTMENT_ROLL_D: case ADJUSTMENT_ROLL_D:
newValue = constrain((int)currentPidProfile->d_min[FD_ROLL] + delta, 0, 200); // FIXME magic numbers repeated in cli.c newValue = constrain((int)currentPidProfile->pid[PID_ROLL].D + delta, 0, 200); // FIXME magic numbers repeated in cli.c
currentPidProfile->d_min[FD_ROLL] = newValue; currentPidProfile->pid[PID_ROLL].D = newValue;
blackboxLogInflightAdjustmentEvent(ADJUSTMENT_ROLL_D, newValue); blackboxLogInflightAdjustmentEvent(ADJUSTMENT_ROLL_D, newValue);
break; break;
case ADJUSTMENT_YAW_P: case ADJUSTMENT_YAW_P:
@ -388,8 +388,8 @@ static int applyStepAdjustment(controlRateConfig_t *controlRateConfig, uint8_t a
blackboxLogInflightAdjustmentEvent(ADJUSTMENT_YAW_I, newValue); blackboxLogInflightAdjustmentEvent(ADJUSTMENT_YAW_I, newValue);
break; break;
case ADJUSTMENT_YAW_D: case ADJUSTMENT_YAW_D:
newValue = constrain((int)currentPidProfile->d_min[FD_YAW] + delta, 0, 200); // FIXME magic numbers repeated in cli.c newValue = constrain((int)currentPidProfile->pid[PID_YAW].D + delta, 0, 200); // FIXME magic numbers repeated in cli.c
currentPidProfile->d_min[FD_YAW] = newValue; currentPidProfile->pid[PID_YAW].D = newValue;
blackboxLogInflightAdjustmentEvent(ADJUSTMENT_YAW_D, newValue); blackboxLogInflightAdjustmentEvent(ADJUSTMENT_YAW_D, newValue);
break; break;
case ADJUSTMENT_RC_RATE_YAW: case ADJUSTMENT_RC_RATE_YAW:
@ -528,7 +528,7 @@ static int applyAbsoluteAdjustment(controlRateConfig_t *controlRateConfig, adjus
case ADJUSTMENT_PITCH_ROLL_D: case ADJUSTMENT_PITCH_ROLL_D:
case ADJUSTMENT_PITCH_D: case ADJUSTMENT_PITCH_D:
newValue = constrain(value, 0, 200); // FIXME magic numbers repeated in cli.c newValue = constrain(value, 0, 200); // FIXME magic numbers repeated in cli.c
currentPidProfile->d_min[FD_PITCH] = newValue; currentPidProfile->pid[PID_PITCH].D = newValue;
blackboxLogInflightAdjustmentEvent(ADJUSTMENT_PITCH_D, newValue); blackboxLogInflightAdjustmentEvent(ADJUSTMENT_PITCH_D, newValue);
if (adjustmentFunction == ADJUSTMENT_PITCH_D) { if (adjustmentFunction == ADJUSTMENT_PITCH_D) {
break; break;
@ -537,7 +537,7 @@ static int applyAbsoluteAdjustment(controlRateConfig_t *controlRateConfig, adjus
FALLTHROUGH; FALLTHROUGH;
case ADJUSTMENT_ROLL_D: case ADJUSTMENT_ROLL_D:
newValue = constrain(value, 0, 200); // FIXME magic numbers repeated in cli.c newValue = constrain(value, 0, 200); // FIXME magic numbers repeated in cli.c
currentPidProfile->d_min[FD_ROLL] = newValue; currentPidProfile->pid[PID_ROLL].D = newValue;
blackboxLogInflightAdjustmentEvent(ADJUSTMENT_ROLL_D, newValue); blackboxLogInflightAdjustmentEvent(ADJUSTMENT_ROLL_D, newValue);
break; break;
case ADJUSTMENT_YAW_P: case ADJUSTMENT_YAW_P:
@ -552,7 +552,7 @@ static int applyAbsoluteAdjustment(controlRateConfig_t *controlRateConfig, adjus
break; break;
case ADJUSTMENT_YAW_D: case ADJUSTMENT_YAW_D:
newValue = constrain(value, 0, 200); // FIXME magic numbers repeated in cli.c newValue = constrain(value, 0, 200); // FIXME magic numbers repeated in cli.c
currentPidProfile->d_min[FD_YAW] = newValue; currentPidProfile->pid[PID_YAW].D = newValue;
blackboxLogInflightAdjustmentEvent(ADJUSTMENT_YAW_D, newValue); blackboxLogInflightAdjustmentEvent(ADJUSTMENT_YAW_D, newValue);
break; break;
case ADJUSTMENT_RC_RATE_YAW: case ADJUSTMENT_RC_RATE_YAW:

47
src/main/flight/pid.c
View file

@ -186,9 +186,9 @@ void resetPidProfile(pidProfile_t *pidProfile)
.use_integrated_yaw = false, .use_integrated_yaw = false,
.integrated_yaw_relax = 200, .integrated_yaw_relax = 200,
.thrustLinearization = 0, .thrustLinearization = 0,
.d_min = D_MIN_DEFAULT, .d_max = D_MAX_DEFAULT,
.d_min_gain = 37, .d_max_gain = 37,
.d_min_advance = 20, .d_max_advance = 20,
.motor_output_limit = 100, .motor_output_limit = 100,
.auto_profile_cell_count = AUTO_PROFILE_CELL_COUNT_STAY, .auto_profile_cell_count = AUTO_PROFILE_CELL_COUNT_STAY,
.transient_throttle_limit = 0, .transient_throttle_limit = 0,
@ -213,7 +213,7 @@ void resetPidProfile(pidProfile_t *pidProfile)
.simplified_i_gain = SIMPLIFIED_TUNING_DEFAULT, .simplified_i_gain = SIMPLIFIED_TUNING_DEFAULT,
.simplified_d_gain = SIMPLIFIED_TUNING_D_DEFAULT, .simplified_d_gain = SIMPLIFIED_TUNING_D_DEFAULT,
.simplified_pi_gain = SIMPLIFIED_TUNING_DEFAULT, .simplified_pi_gain = SIMPLIFIED_TUNING_DEFAULT,
.simplified_dmin_ratio = SIMPLIFIED_TUNING_D_DEFAULT, .simplified_d_max_gain = SIMPLIFIED_TUNING_D_DEFAULT,
.simplified_feedforward_gain = SIMPLIFIED_TUNING_DEFAULT, .simplified_feedforward_gain = SIMPLIFIED_TUNING_DEFAULT,
.simplified_pitch_pi_gain = SIMPLIFIED_TUNING_DEFAULT, .simplified_pitch_pi_gain = SIMPLIFIED_TUNING_DEFAULT,
.simplified_dterm_filter = true, .simplified_dterm_filter = true,
@ -247,11 +247,6 @@ void resetPidProfile(pidProfile_t *pidProfile)
.tpa_curve_pid_thr100 = 70, .tpa_curve_pid_thr100 = 70,
.tpa_curve_expo = 20, .tpa_curve_expo = 20,
); );
#ifndef USE_D_MIN
pidProfile->pid[PID_ROLL].D = 30;
pidProfile->pid[PID_PITCH].D = 32;
#endif
} }
void pgResetFn_pidProfiles(pidProfile_t *pidProfiles) void pgResetFn_pidProfiles(pidProfile_t *pidProfiles)
@ -1187,7 +1182,7 @@ void FAST_CODE pidController(const pidProfile_t *pidProfile, timeUs_t currentTim
pidSetpointDelta = getFeedforward(axis); pidSetpointDelta = getFeedforward(axis);
} }
#endif #endif
pidRuntime.previousPidSetpoint[axis] = currentPidSetpoint; // this is the value sent to blackbox, and used for Dmin setpoint pidRuntime.previousPidSetpoint[axis] = currentPidSetpoint; // this is the value sent to blackbox, and used for D-max setpoint
// disable D if launch control is active // disable D if launch control is active
if ((pidRuntime.pidCoefficient[axis].Kd > 0) && !launchControlActive) { if ((pidRuntime.pidCoefficient[axis].Kd > 0) && !launchControlActive) {
@ -1205,27 +1200,27 @@ void FAST_CODE pidController(const pidProfile_t *pidProfile, timeUs_t currentTim
} }
#endif #endif
#if defined(USE_D_MIN) #ifdef USE_D_MAX
float dMinFactor = 1.0f; float dMaxFactor = 1.0f;
if (pidRuntime.dMinPercent[axis] > 0) { if (pidRuntime.dMaxPercent[axis] > 0) {
float dMinGyroFactor = pt2FilterApply(&pidRuntime.dMinRange[axis], delta); float dMaxGyroFactor = pt2FilterApply(&pidRuntime.dMaxRange[axis], delta);
dMinGyroFactor = fabsf(dMinGyroFactor) * pidRuntime.dMinGyroGain; dMaxGyroFactor = fabsf(dMaxGyroFactor) * pidRuntime.dMaxGyroGain;
const float dMinSetpointFactor = (fabsf(pidSetpointDelta)) * pidRuntime.dMinSetpointGain; const float dMaxSetpointFactor = fabsf(pidSetpointDelta) * pidRuntime.dMaxSetpointGain;
dMinFactor = MAX(dMinGyroFactor, dMinSetpointFactor); dMaxFactor = MAX(dMaxGyroFactor, dMaxSetpointFactor);
dMinFactor = pidRuntime.dMinPercent[axis] + (1.0f - pidRuntime.dMinPercent[axis]) * dMinFactor; dMaxFactor = 1.0f + (1.0f - pidRuntime.dMaxPercent[axis]) * dMaxFactor;
dMinFactor = pt2FilterApply(&pidRuntime.dMinLowpass[axis], dMinFactor); dMaxFactor = pt2FilterApply(&pidRuntime.dMaxLowpass[axis], dMaxFactor);
dMinFactor = MIN(dMinFactor, 1.0f); dMaxFactor = MIN(dMaxFactor, 1.0f / pidRuntime.dMaxPercent[axis]);
if (axis == FD_ROLL) { if (axis == FD_ROLL) {
DEBUG_SET(DEBUG_D_MIN, 0, lrintf(dMinGyroFactor * 100)); DEBUG_SET(DEBUG_D_MAX, 0, lrintf(dMaxGyroFactor * 100));
DEBUG_SET(DEBUG_D_MIN, 1, lrintf(dMinSetpointFactor * 100)); DEBUG_SET(DEBUG_D_MAX, 1, lrintf(dMaxSetpointFactor * 100));
DEBUG_SET(DEBUG_D_MIN, 2, lrintf(pidRuntime.pidCoefficient[axis].Kd * dMinFactor * 10 / DTERM_SCALE)); DEBUG_SET(DEBUG_D_MAX, 2, lrintf(pidRuntime.pidCoefficient[axis].Kd * dMaxFactor * 10 / DTERM_SCALE));
} else if (axis == FD_PITCH) { } else if (axis == FD_PITCH) {
DEBUG_SET(DEBUG_D_MIN, 3, lrintf(pidRuntime.pidCoefficient[axis].Kd * dMinFactor * 10 / DTERM_SCALE)); DEBUG_SET(DEBUG_D_MAX, 3, lrintf(pidRuntime.pidCoefficient[axis].Kd * dMaxFactor * 10 / DTERM_SCALE));
} }
} }
// Apply the dMinFactor // Apply the dMaxFactor
preTpaD *= dMinFactor; preTpaD *= dMaxFactor;
#endif #endif
pidData[axis].D = preTpaD * pidRuntime.tpaFactor; pidData[axis].D = preTpaD * pidRuntime.tpaFactor;

28
src/main/flight/pid.h
View file

@ -40,7 +40,6 @@
#define PID_GAIN_MAX 250 #define PID_GAIN_MAX 250
#define F_GAIN_MAX 1000 #define F_GAIN_MAX 1000
#define D_MIN_GAIN_MAX 250
// Scaling factors for Pids for better tunable range in configurator for betaflight pid controller. The scaling is based on legacy pid controller or previous float // Scaling factors for Pids for better tunable range in configurator for betaflight pid controller. The scaling is based on legacy pid controller or previous float
#define PTERM_SCALE 0.032029f #define PTERM_SCALE 0.032029f
@ -61,10 +60,10 @@
#define ITERM_ACCELERATOR_GAIN_OFF 0 #define ITERM_ACCELERATOR_GAIN_OFF 0
#define ITERM_ACCELERATOR_GAIN_MAX 250 #define ITERM_ACCELERATOR_GAIN_MAX 250
#define PID_ROLL_DEFAULT { 45, 80, 40, 120, 0 } #define PID_ROLL_DEFAULT { 45, 80, 30, 120, 0 }
#define PID_PITCH_DEFAULT { 47, 84, 46, 125, 0 } #define PID_PITCH_DEFAULT { 47, 84, 34, 125, 0 }
#define PID_YAW_DEFAULT { 45, 80, 0, 120, 0 } #define PID_YAW_DEFAULT { 45, 80, 0, 120, 0 }
#define D_MIN_DEFAULT { 30, 34, 0 } #define D_MAX_DEFAULT { 40, 46, 0 }
#define DTERM_LPF1_DYN_MIN_HZ_DEFAULT 75 #define DTERM_LPF1_DYN_MIN_HZ_DEFAULT 75
#define DTERM_LPF1_DYN_MAX_HZ_DEFAULT 150 #define DTERM_LPF1_DYN_MAX_HZ_DEFAULT 150
@ -222,9 +221,9 @@ typedef struct pidProfile_s {
uint8_t use_integrated_yaw; // Selects whether the yaw pidsum should integrated uint8_t use_integrated_yaw; // Selects whether the yaw pidsum should integrated
uint8_t integrated_yaw_relax; // Specifies how much integrated yaw should be reduced to offset the drag based yaw component uint8_t integrated_yaw_relax; // Specifies how much integrated yaw should be reduced to offset the drag based yaw component
uint8_t thrustLinearization; // Compensation factor for pid linearization uint8_t thrustLinearization; // Compensation factor for pid linearization
uint8_t d_min[XYZ_AXIS_COUNT]; // Minimum D value on each axis uint8_t d_max[XYZ_AXIS_COUNT]; // Maximum D value on each axis
uint8_t d_min_gain; // Gain factor for amount of gyro / setpoint activity required to boost D uint8_t d_max_gain; // Gain factor for amount of gyro / setpoint activity required to boost D
uint8_t d_min_advance; // Percentage multiplier for setpoint input to boost algorithm uint8_t d_max_advance; // Percentage multiplier for setpoint input to boost algorithm
uint8_t motor_output_limit; // Upper limit of the motor output (percent) uint8_t motor_output_limit; // Upper limit of the motor output (percent)
int8_t auto_profile_cell_count; // Cell count for this profile to be used with if auto PID profile switching is used int8_t auto_profile_cell_count; // Cell count for this profile to be used with if auto PID profile switching is used
uint8_t transient_throttle_limit; // Maximum DC component of throttle change to mix into throttle to prevent airmode mirroring noise uint8_t transient_throttle_limit; // Maximum DC component of throttle change to mix into throttle to prevent airmode mirroring noise
@ -256,7 +255,7 @@ typedef struct pidProfile_s {
uint8_t simplified_i_gain; uint8_t simplified_i_gain;
uint8_t simplified_d_gain; uint8_t simplified_d_gain;
uint8_t simplified_pi_gain; uint8_t simplified_pi_gain;
uint8_t simplified_dmin_ratio; uint8_t simplified_d_max_gain;
uint8_t simplified_feedforward_gain; uint8_t simplified_feedforward_gain;
uint8_t simplified_dterm_filter; uint8_t simplified_dterm_filter;
uint8_t simplified_dterm_filter_multiplier; uint8_t simplified_dterm_filter_multiplier;
@ -401,12 +400,13 @@ typedef struct pidRuntime_s {
float oldSetpointCorrection[XYZ_AXIS_COUNT]; float oldSetpointCorrection[XYZ_AXIS_COUNT];
#endif #endif
#ifdef USE_D_MIN #ifdef USE_D_MAX
pt2Filter_t dMinRange[XYZ_AXIS_COUNT]; pt2Filter_t dMaxRange[XYZ_AXIS_COUNT];
pt2Filter_t dMinLowpass[XYZ_AXIS_COUNT]; pt2Filter_t dMaxLowpass[XYZ_AXIS_COUNT];
float dMinPercent[XYZ_AXIS_COUNT]; float dMaxPercent[XYZ_AXIS_COUNT];
float dMinGyroGain; uint8_t dMax[XYZ_AXIS_COUNT];
float dMinSetpointGain; float dMaxGyroGain;
float dMaxSetpointGain;
#endif #endif
#ifdef USE_AIRMODE_LPF #ifdef USE_AIRMODE_LPF

34
src/main/flight/pid_init.c
View file

@ -47,11 +47,11 @@
#include "pid_init.h" #include "pid_init.h"
#if defined(USE_D_MIN) #ifdef USE_D_MAX
#define D_MIN_RANGE_HZ 85 // PT2 lowpass input cutoff to peak D around propwash frequencies #define D_MAX_RANGE_HZ 85 // PT2 lowpass input cutoff to peak D around propwash frequencies
#define D_MIN_LOWPASS_HZ 35 // PT2 lowpass cutoff to smooth the boost effect #define D_MAX_LOWPASS_HZ 35 // PT2 lowpass cutoff to smooth the boost effect
#define D_MIN_GAIN_FACTOR 0.00008f #define D_MAX_GAIN_FACTOR 0.00008f
#define D_MIN_SETPOINT_GAIN_FACTOR 0.00008f #define D_MAX_SETPOINT_GAIN_FACTOR 0.00008f
#endif #endif
#define ATTITUDE_CUTOFF_HZ 50 #define ATTITUDE_CUTOFF_HZ 50
@ -219,14 +219,14 @@ void pidInitFilters(const pidProfile_t *pidProfile)
} }
#endif #endif
#if defined(USE_D_MIN) #ifdef USE_D_MAX
// Initialize the filters for all axis even if the d_min[axis] value is 0 // Initialize the filters for all axis even if the d_max[axis] value is 0
// Otherwise if the pidProfile->d_min_xxx parameters are ever added to // Otherwise if the pidProfile->d_max_xxx parameters are ever added to
// in-flight adjustments and transition from 0 to > 0 in flight the feature // in-flight adjustments and transition from 0 to > 0 in flight the feature
// won't work because the filter wasn't initialized. // won't work because the filter wasn't initialized.
for (int axis = FD_ROLL; axis <= FD_YAW; axis++) { for (int axis = FD_ROLL; axis <= FD_YAW; axis++) {
pt2FilterInit(&pidRuntime.dMinRange[axis], pt2FilterGain(D_MIN_RANGE_HZ, pidRuntime.dT)); pt2FilterInit(&pidRuntime.dMaxRange[axis], pt2FilterGain(D_MAX_RANGE_HZ, pidRuntime.dT));
pt2FilterInit(&pidRuntime.dMinLowpass[axis], pt2FilterGain(D_MIN_LOWPASS_HZ, pidRuntime.dT)); pt2FilterInit(&pidRuntime.dMaxLowpass[axis], pt2FilterGain(D_MAX_LOWPASS_HZ, pidRuntime.dT));
} }
#endif #endif
@ -445,17 +445,17 @@ void pidInitConfig(const pidProfile_t *pidProfile)
pidRuntime.throttleCompensateAmount = pidRuntime.thrustLinearization - 0.5f * sq(pidRuntime.thrustLinearization); pidRuntime.throttleCompensateAmount = pidRuntime.thrustLinearization - 0.5f * sq(pidRuntime.thrustLinearization);
#endif #endif
#if defined(USE_D_MIN) #ifdef USE_D_MAX
for (int axis = FD_ROLL; axis <= FD_YAW; ++axis) { for (int axis = FD_ROLL; axis <= FD_YAW; ++axis) {
const uint8_t dMin = pidProfile->d_min[axis]; const uint8_t dMax = pidProfile->d_max[axis];
if ((dMin > 0) && (dMin < pidProfile->pid[axis].D)) { if ((dMax > 0) && (dMax > pidProfile->pid[axis].D)) {
pidRuntime.dMinPercent[axis] = dMin / (float)(pidProfile->pid[axis].D); pidRuntime.dMaxPercent[axis] = (float) pidProfile->pid[axis].D / dMax;
} else { } else {
pidRuntime.dMinPercent[axis] = 0; pidRuntime.dMaxPercent[axis] = 0;
} }
} }
pidRuntime.dMinGyroGain = D_MIN_GAIN_FACTOR * pidProfile->d_min_gain / D_MIN_LOWPASS_HZ; pidRuntime.dMaxGyroGain = D_MAX_GAIN_FACTOR * pidProfile->d_max_gain / D_MAX_LOWPASS_HZ;
pidRuntime.dMinSetpointGain = D_MIN_SETPOINT_GAIN_FACTOR * pidProfile->d_min_gain * pidProfile->d_min_advance / 100.0f / D_MIN_LOWPASS_HZ; pidRuntime.dMaxSetpointGain = D_MAX_SETPOINT_GAIN_FACTOR * pidProfile->d_max_gain * pidProfile->d_max_advance / 100.0f / D_MAX_LOWPASS_HZ;
// lowpass included inversely in gain since stronger lowpass decreases peak effect // lowpass included inversely in gain since stronger lowpass decreases peak effect
#endif #endif

36
src/main/msp/msp.c
View file

@ -1988,12 +1988,12 @@ case MSP_NAME:
sbufWriteU16(dst, currentPidProfile->pid[PID_PITCH].F); sbufWriteU16(dst, currentPidProfile->pid[PID_PITCH].F);
sbufWriteU16(dst, currentPidProfile->pid[PID_YAW].F); sbufWriteU16(dst, currentPidProfile->pid[PID_YAW].F);
sbufWriteU8(dst, 0); // was currentPidProfile->antiGravityMode sbufWriteU8(dst, 0); // was currentPidProfile->antiGravityMode
#if defined(USE_D_MIN) #ifdef USE_D_MAX
sbufWriteU8(dst, currentPidProfile->d_min[PID_ROLL]); sbufWriteU8(dst, currentPidProfile->d_max[PID_ROLL]);
sbufWriteU8(dst, currentPidProfile->d_min[PID_PITCH]); sbufWriteU8(dst, currentPidProfile->d_max[PID_PITCH]);
sbufWriteU8(dst, currentPidProfile->d_min[PID_YAW]); sbufWriteU8(dst, currentPidProfile->d_max[PID_YAW]);
sbufWriteU8(dst, currentPidProfile->d_min_gain); sbufWriteU8(dst, currentPidProfile->d_max_gain);
sbufWriteU8(dst, currentPidProfile->d_min_advance); sbufWriteU8(dst, currentPidProfile->d_max_advance);
#else #else
sbufWriteU8(dst, 0); sbufWriteU8(dst, 0);
sbufWriteU8(dst, 0); sbufWriteU8(dst, 0);
@ -2197,8 +2197,8 @@ static void readSimplifiedPids(pidProfile_t* pidProfile, sbuf_t *src)
pidProfile->simplified_i_gain = sbufReadU8(src); pidProfile->simplified_i_gain = sbufReadU8(src);
pidProfile->simplified_d_gain = sbufReadU8(src); pidProfile->simplified_d_gain = sbufReadU8(src);
pidProfile->simplified_pi_gain = sbufReadU8(src); pidProfile->simplified_pi_gain = sbufReadU8(src);
#ifdef USE_D_MIN #ifdef USE_D_MAX
pidProfile->simplified_dmin_ratio = sbufReadU8(src); pidProfile->simplified_d_max_gain = sbufReadU8(src);
#else #else
sbufReadU8(src); sbufReadU8(src);
#endif #endif
@ -2217,8 +2217,8 @@ static void writeSimplifiedPids(const pidProfile_t *pidProfile, sbuf_t *dst)
sbufWriteU8(dst, pidProfile->simplified_i_gain); sbufWriteU8(dst, pidProfile->simplified_i_gain);
sbufWriteU8(dst, pidProfile->simplified_d_gain); sbufWriteU8(dst, pidProfile->simplified_d_gain);
sbufWriteU8(dst, pidProfile->simplified_pi_gain); sbufWriteU8(dst, pidProfile->simplified_pi_gain);
#ifdef USE_D_MIN #ifdef USE_D_MAX
sbufWriteU8(dst, pidProfile->simplified_dmin_ratio); sbufWriteU8(dst, pidProfile->simplified_d_max_gain);
#else #else
sbufWriteU8(dst, 0); sbufWriteU8(dst, 0);
#endif #endif
@ -2307,7 +2307,7 @@ static void writePidfs(pidProfile_t* pidProfile, sbuf_t *dst)
sbufWriteU8(dst, pidProfile->pid[i].P); sbufWriteU8(dst, pidProfile->pid[i].P);
sbufWriteU8(dst, pidProfile->pid[i].I); sbufWriteU8(dst, pidProfile->pid[i].I);
sbufWriteU8(dst, pidProfile->pid[i].D); sbufWriteU8(dst, pidProfile->pid[i].D);
sbufWriteU8(dst, pidProfile->d_min[i]); sbufWriteU8(dst, pidProfile->d_max[i]);
sbufWriteU16(dst, pidProfile->pid[i].F); sbufWriteU16(dst, pidProfile->pid[i].F);
} }
} }
@ -2495,7 +2495,7 @@ static mspResult_e mspFcProcessOutCommandWithArg(mspDescriptor_t srcDesc, int16_
tempPidProfile.pid[i].P == currentPidProfile->pid[i].P && tempPidProfile.pid[i].P == currentPidProfile->pid[i].P &&
tempPidProfile.pid[i].I == currentPidProfile->pid[i].I && tempPidProfile.pid[i].I == currentPidProfile->pid[i].I &&
tempPidProfile.pid[i].D == currentPidProfile->pid[i].D && tempPidProfile.pid[i].D == currentPidProfile->pid[i].D &&
tempPidProfile.d_min[i] == currentPidProfile->d_min[i] && tempPidProfile.d_max[i] == currentPidProfile->d_max[i] &&
tempPidProfile.pid[i].F == currentPidProfile->pid[i].F; tempPidProfile.pid[i].F == currentPidProfile->pid[i].F;
} }
@ -3197,12 +3197,12 @@ static mspResult_e mspProcessInCommand(mspDescriptor_t srcDesc, int16_t cmdMSP,
} }
if (sbufBytesRemaining(src) >= 7) { if (sbufBytesRemaining(src) >= 7) {
// Added in MSP API 1.41 // Added in MSP API 1.41
#if defined(USE_D_MIN) #ifdef USE_D_MAX
currentPidProfile->d_min[PID_ROLL] = sbufReadU8(src); currentPidProfile->d_max[PID_ROLL] = sbufReadU8(src);
currentPidProfile->d_min[PID_PITCH] = sbufReadU8(src); currentPidProfile->d_max[PID_PITCH] = sbufReadU8(src);
currentPidProfile->d_min[PID_YAW] = sbufReadU8(src); currentPidProfile->d_max[PID_YAW] = sbufReadU8(src);
currentPidProfile->d_min_gain = sbufReadU8(src); currentPidProfile->d_max_gain = sbufReadU8(src);
currentPidProfile->d_min_advance = sbufReadU8(src); currentPidProfile->d_max_advance = sbufReadU8(src);
#else #else
sbufReadU8(src); sbufReadU8(src);
sbufReadU8(src); sbufReadU8(src);

2
src/main/osd/osd_elements.c
View file

@ -458,7 +458,7 @@ static void osdFormatPID(char * buff, const char * label, uint8_t axis)
currentPidProfile->pid[axis].P, currentPidProfile->pid[axis].P,
currentPidProfile->pid[axis].I, currentPidProfile->pid[axis].I,
currentPidProfile->pid[axis].D, currentPidProfile->pid[axis].D,
currentPidProfile->d_min[axis], currentPidProfile->d_max[axis],
currentPidProfile->pid[axis].F); currentPidProfile->pid[axis].F);
} }

2
src/main/target/common_pre.h
View file

@ -321,7 +321,7 @@
#define USE_GYRO_LPF2 #define USE_GYRO_LPF2
#define USE_DYN_LPF #define USE_DYN_LPF
#define USE_D_MIN #define USE_D_MAX
#define USE_THROTTLE_BOOST #define USE_THROTTLE_BOOST
#define USE_INTEGRATED_YAW_CONTROL #define USE_INTEGRATED_YAW_CONTROL

15
src/test/unit/rc_controls_unittest.cc
View file

@ -550,10 +550,6 @@ TEST_F(RcControlsAdjustmentsTest, processPIDIncreasePidController0)
pidProfile.pid[PID_YAW].I = 17; pidProfile.pid[PID_YAW].I = 17;
pidProfile.pid[PID_YAW].D = 27; pidProfile.pid[PID_YAW].D = 27;
pidProfile.d_min[FD_PITCH] = 19;
pidProfile.d_min[FD_ROLL] = 19;
pidProfile.d_min[FD_YAW] = 19;
// and // and
controlRateConfig_t controlRateConfig; controlRateConfig_t controlRateConfig;
memset(&controlRateConfig, 0, sizeof(controlRateConfig)); memset(&controlRateConfig, 0, sizeof(controlRateConfig));
@ -564,7 +560,7 @@ TEST_F(RcControlsAdjustmentsTest, processPIDIncreasePidController0)
const timedAdjustmentState_t *adjustmentState4 = configureStepwiseAdjustment(AUX1 - NON_AUX_CHANNEL_COUNT, ADJUSTMENT_YAW_P_INDEX); const timedAdjustmentState_t *adjustmentState4 = configureStepwiseAdjustment(AUX1 - NON_AUX_CHANNEL_COUNT, ADJUSTMENT_YAW_P_INDEX);
const timedAdjustmentState_t *adjustmentState5 = configureStepwiseAdjustment(AUX2 - NON_AUX_CHANNEL_COUNT, ADJUSTMENT_YAW_I_INDEX); const timedAdjustmentState_t *adjustmentState5 = configureStepwiseAdjustment(AUX2 - NON_AUX_CHANNEL_COUNT, ADJUSTMENT_YAW_I_INDEX);
const timedAdjustmentState_t *adjustmentState6 = configureStepwiseAdjustment(AUX3 - NON_AUX_CHANNEL_COUNT, ADJUSTMENT_YAW_D_INDEX); const timedAdjustmentState_t *adjustmentState6 = configureStepwiseAdjustment(AUX3 - NON_AUX_CHANNEL_COUNT, ADJUSTMENT_YAW_D_INDEX);
// and // and
for (int index = AUX1; index < MAX_SUPPORTED_RC_CHANNEL_COUNT; index++) { for (int index = AUX1; index < MAX_SUPPORTED_RC_CHANNEL_COUNT; index++) {
rcData[index] = PWM_RANGE_MIDDLE; rcData[index] = PWM_RANGE_MIDDLE;
@ -596,16 +592,13 @@ TEST_F(RcControlsAdjustmentsTest, processPIDIncreasePidController0)
// and // and
EXPECT_EQ(1, pidProfile.pid[PID_PITCH].P); EXPECT_EQ(1, pidProfile.pid[PID_PITCH].P);
EXPECT_EQ(11, pidProfile.pid[PID_PITCH].I); EXPECT_EQ(11, pidProfile.pid[PID_PITCH].I);
EXPECT_EQ(20, pidProfile.pid[PID_PITCH].D); EXPECT_EQ(21, pidProfile.pid[PID_PITCH].D);
EXPECT_EQ(20, pidProfile.d_min[FD_PITCH]);
EXPECT_EQ(6, pidProfile.pid[PID_ROLL].P); EXPECT_EQ(6, pidProfile.pid[PID_ROLL].P);
EXPECT_EQ(16, pidProfile.pid[PID_ROLL].I); EXPECT_EQ(16, pidProfile.pid[PID_ROLL].I);
EXPECT_EQ(25, pidProfile.pid[PID_ROLL].D); EXPECT_EQ(26, pidProfile.pid[PID_ROLL].D);
EXPECT_EQ(20, pidProfile.d_min[FD_ROLL]);
EXPECT_EQ(8, pidProfile.pid[PID_YAW].P); EXPECT_EQ(8, pidProfile.pid[PID_YAW].P);
EXPECT_EQ(18, pidProfile.pid[PID_YAW].I); EXPECT_EQ(18, pidProfile.pid[PID_YAW].I);
EXPECT_EQ(27, pidProfile.pid[PID_YAW].D); EXPECT_EQ(28, pidProfile.pid[PID_YAW].D);
EXPECT_EQ(20, pidProfile.d_min[FD_YAW]);
} }
extern "C" { extern "C" {