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

Renamed 'tuning sliders' to 'simplified tuning'.

Browse source
This commit is contained in:
Michael Keller 2020-12-26 01:57:11 +01:00
parent cff19dc113
commit 7fc3c7cea6
13 changed files with 196 additions and 195 deletions
Download patch file Download diff file Expand all files Collapse all files

2
make/source.mk
View file

@ -320,7 +320,7 @@ SIZE_OPTIMISED_SRC := $(SIZE_OPTIMISED_SRC) \
config/config_eeprom.c \
config/feature.c \
config/config_streamer.c \
config/tuning_sliders.c \
config/simplified_tuning.c \
i2c_bst.c \
io/dashboard.c \
io/serial.c \

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

@ -57,7 +57,7 @@ bool cliMode = false;
#include "config/config.h"
#include "config/config_eeprom.h"
#include "config/feature.h"
#include "config/tuning_sliders.h"
#include "config/simplified_tuning.h"
#include "drivers/accgyro/accgyro.h"
#include "drivers/adc.h"
@ -3094,14 +3094,14 @@ static void cliVtxInfo(const char *cmdName, char *cmdline)
}
#endif // USE_VTX_TABLE
#ifdef USE_TUNING_SLIDERS
static void cliTuningSliders(const char *cmdName, char *cmdline)
#ifdef USE_SIMPLIFIED_TUNING
static void cliApplySimplifiedTuning(const char *cmdName, char *cmdline)
{
UNUSED(cmdName);
UNUSED(cmdline);
applyTuningSliders(currentPidProfile);
cliPrintLine("Applied tuning slider calculation");
applySimplifiedTuning(currentPidProfile);
cliPrintLine("Applied tuning based on simplified tuning settings.");
}
#endif
@ -6403,8 +6403,8 @@ static void cliHelp(const char *cmdName, char *cmdline);
// should be sorted a..z for bsearch()
const clicmd_t cmdTable[] = {
CLI_COMMAND_DEF("adjrange", "configure adjustment ranges", "<index> <unused> <range channel> <start> <end> <function> <select channel> [<center> <scale>]", cliAdjustmentRange),
#ifdef USE_TUNING_SLIDERS
CLI_COMMAND_DEF("apply_tuning_sliders", "applies tuning sliders calculation based on slider positions", NULL, cliTuningSliders),
#ifdef USE_SIMPLIFIED_TUNING
CLI_COMMAND_DEF("apply_simplified_tuning", "applies tuning based on simplified tuning settings", NULL, cliApplySimplifiedTuning),
#endif
CLI_COMMAND_DEF("aux", "configure modes", "<index> <mode> <aux> <start> <end> <logic>", cliAux),
#ifdef USE_CLI_BATCH

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

@ -33,7 +33,7 @@
#include "common/utils.h"
#include "common/time.h"
#include "config/tuning_sliders.h"
#include "config/simplified_tuning.h"
#include "drivers/adc.h"
#include "drivers/bus_i2c.h"
@ -502,7 +502,7 @@ static const char * const lookupTableOsdLogoOnArming[] = {
"OFF", "ON", "FIRST_ARMING",
};
#endif
const char * const lookupTableSliderPidsMode[] = {
const char * const lookupTableSimplifiedTuningPidsMode[] = {
"OFF", "RP", "RPY",
};
@ -632,7 +632,7 @@ const lookupTableEntry_t lookupTables[] = {
LOOKUP_TABLE_ENTRY(lookupTableOsdLogoOnArming),
#endif
LOOKUP_TABLE_ENTRY(lookupTableMixerType),
LOOKUP_TABLE_ENTRY(lookupTableSliderPidsMode),
LOOKUP_TABLE_ENTRY(lookupTableSimplifiedTuningPidsMode),
};
#undef LOOKUP_TABLE_ENTRY
@ -1175,21 +1175,21 @@ const clivalue_t valueTable[] = {
#endif
{ "level_race_mode", VAR_UINT8 | PROFILE_VALUE | MODE_LOOKUP, .config.lookup = { TABLE_OFF_ON }, PG_PID_PROFILE, offsetof(pidProfile_t, level_race_mode) },
#ifdef USE_TUNING_SLIDERS
{ "slider_pids_mode", VAR_UINT8 | PROFILE_VALUE | MODE_LOOKUP, .config.lookup = { TABLE_SLIDER_PIDS_MODE }, PG_PID_PROFILE, offsetof(pidProfile_t, slider_pids_mode) },
{ "slider_master_multiplier", VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SLIDER_MIN, SLIDER_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, slider_master_multiplier) },
{ "slider_roll_pitch_ratio", VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SLIDER_MIN, SLIDER_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, slider_roll_pitch_ratio) },
{ "slider_i_gain", VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SLIDER_MIN, SLIDER_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, slider_i_gain) },
{ "slider_pd_ratio", VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SLIDER_MIN, SLIDER_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, slider_pd_ratio) },
{ "slider_pd_gain", VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SLIDER_MIN, SLIDER_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, slider_pd_gain) },
{ "slider_dmin_ratio", VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SLIDER_MIN, SLIDER_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, slider_dmin_ratio) },
{ "slider_ff_gain", VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SLIDER_MIN, SLIDER_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, slider_ff_gain) },
#ifdef USE_SIMPLIFIED_TUNING
{ "simplified_pids_mode", VAR_UINT8 | PROFILE_VALUE | MODE_LOOKUP, .config.lookup = { TABLE_SIMPLIFIED_TUNING_PIDS_MODE }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_pids_mode) },
{ "simplified_master_multiplier", VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_master_multiplier) },
{ "simplified_roll_pitch_ratio", VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_roll_pitch_ratio) },
{ "simplified_i_gain", VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_i_gain) },
{ "simplified_pd_ratio", VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_pd_ratio) },
{ "simplified_pd_gain", VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_pd_gain) },
{ "simplified_dmin_ratio", VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_dmin_ratio) },
{ "simplified_ff_gain", VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_ff_gain) },
{ "slider_dterm_filter", VAR_UINT8 | PROFILE_VALUE | MODE_LOOKUP, .config.lookup = { TABLE_OFF_ON }, PG_PID_PROFILE, offsetof(pidProfile_t, slider_dterm_filter) },
{ "slider_dterm_filter_multiplier", VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SLIDER_MIN, SLIDER_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, slider_dterm_filter_multiplier) },
{ "simplified_dterm_filter", VAR_UINT8 | PROFILE_VALUE | MODE_LOOKUP, .config.lookup = { TABLE_OFF_ON }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_dterm_filter) },
{ "simplified_dterm_filter_multiplier", VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_dterm_filter_multiplier) },
{ "slider_gyro_filter", VAR_UINT8 | PROFILE_VALUE | MODE_LOOKUP, .config.lookup = { TABLE_OFF_ON }, PG_GYRO_CONFIG, offsetof(gyroConfig_t, slider_gyro_filter) },
{ "slider_gyro_filter_multiplier", VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SLIDER_MIN, SLIDER_MAX }, PG_GYRO_CONFIG, offsetof(gyroConfig_t, slider_gyro_filter_multiplier) },
{ "simplified_gyro_filter", VAR_UINT8 | PROFILE_VALUE | MODE_LOOKUP, .config.lookup = { TABLE_OFF_ON }, PG_GYRO_CONFIG, offsetof(gyroConfig_t, simplified_gyro_filter) },
{ "simplified_gyro_filter_multiplier", VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX }, PG_GYRO_CONFIG, offsetof(gyroConfig_t, simplified_gyro_filter_multiplier) },
#endif
// PG_TELEMETRY_CONFIG

4
src/main/cli/settings.h
View file

@ -142,7 +142,7 @@ typedef enum {
TABLE_OSD_LOGO_ON_ARMING,
#endif
TABLE_MIXER_TYPE,
TABLE_SLIDER_PIDS_MODE,
TABLE_SIMPLIFIED_TUNING_PIDS_MODE,
LOOKUP_TABLE_COUNT
} lookupTableIndex_e;
@ -264,4 +264,4 @@ extern const char * const lookupTableInterpolatedSetpoint[];
extern const char * const lookupTableOffOn[];
extern const char * const lookupTableSliderPidsMode[];
extern const char * const lookupTableSimplifiedTuningPidsMode[];

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

@ -40,7 +40,7 @@
#include "common/utils.h"
#include "config/feature.h"
#include "config/tuning_sliders.h"
#include "config/simplified_tuning.h"
#include "drivers/pwm_output.h"
@ -229,112 +229,113 @@ static CMS_Menu cmsx_menuPid = {
.entries = cmsx_menuPidEntries
};
#ifdef USE_TUNING_SLIDERS
static uint8_t cmsx_slider_pids_mode;
static uint8_t cmsx_slider_master_multiplier;
static uint8_t cmsx_slider_roll_pitch_ratio;
static uint8_t cmsx_slider_i_gain;
static uint8_t cmsx_slider_pd_ratio;
static uint8_t cmsx_slider_pd_gain;
static uint8_t cmsx_slider_dmin_ratio;
static uint8_t cmsx_slider_ff_gain;
#ifdef USE_SIMPLIFIED_TUNING
static uint8_t cmsx_simplified_pids_mode;
static uint8_t cmsx_simplified_master_multiplier;
static uint8_t cmsx_simplified_roll_pitch_ratio;
static uint8_t cmsx_simplified_i_gain;
static uint8_t cmsx_simplified_pd_ratio;
static uint8_t cmsx_simplified_pd_gain;
static uint8_t cmsx_simplified_dmin_ratio;
static uint8_t cmsx_simplified_ff_gain;
static uint8_t cmsx_slider_dterm_filter;
static uint8_t cmsx_slider_dterm_filter_multiplier;
static uint8_t cmsx_slider_gyro_filter;
static uint8_t cmsx_slider_gyro_filter_multiplier;
static uint8_t cmsx_simplified_dterm_filter;
static uint8_t cmsx_simplified_dterm_filter_multiplier;
static uint8_t cmsx_simplified_gyro_filter;
static uint8_t cmsx_simplified_gyro_filter_multiplier;
static const void *cmsx_slidersOnEnter(displayPort_t *pDisp)
static const void *cmsx_simplifiedTuningOnEnter(displayPort_t *pDisp)
{
UNUSED(pDisp);
const pidProfile_t *pidProfile = pidProfiles(pidProfileIndex);
cmsx_slider_pids_mode = pidProfile->slider_pids_mode;
cmsx_slider_master_multiplier = pidProfile->slider_master_multiplier;
cmsx_slider_roll_pitch_ratio = pidProfile->slider_roll_pitch_ratio;
cmsx_slider_i_gain = pidProfile->slider_i_gain;
cmsx_slider_pd_ratio = pidProfile->slider_pd_ratio;
cmsx_slider_pd_gain = pidProfile->slider_pd_gain;
cmsx_slider_dmin_ratio = pidProfile->slider_dmin_ratio;
cmsx_slider_ff_gain = pidProfile->slider_ff_gain;
cmsx_simplified_pids_mode = pidProfile->simplified_pids_mode;
cmsx_simplified_master_multiplier = pidProfile->simplified_master_multiplier;
cmsx_simplified_roll_pitch_ratio = pidProfile->simplified_roll_pitch_ratio;
cmsx_simplified_i_gain = pidProfile->simplified_i_gain;
cmsx_simplified_pd_ratio = pidProfile->simplified_pd_ratio;
cmsx_simplified_pd_gain = pidProfile->simplified_pd_gain;
cmsx_simplified_dmin_ratio = pidProfile->simplified_dmin_ratio;
cmsx_simplified_ff_gain = pidProfile->simplified_ff_gain;
cmsx_slider_dterm_filter = pidProfile->slider_dterm_filter;
cmsx_slider_dterm_filter_multiplier = pidProfile->slider_dterm_filter_multiplier;
cmsx_slider_gyro_filter = gyroConfig()->slider_gyro_filter;
cmsx_slider_gyro_filter_multiplier = gyroConfig()->slider_gyro_filter_multiplier;
cmsx_simplified_dterm_filter = pidProfile->simplified_dterm_filter;
cmsx_simplified_dterm_filter_multiplier = pidProfile->simplified_dterm_filter_multiplier;
cmsx_simplified_gyro_filter = gyroConfig()->simplified_gyro_filter;
cmsx_simplified_gyro_filter_multiplier = gyroConfig()->simplified_gyro_filter_multiplier;
return 0;
}
static const void *cmsx_slidersOnExit(displayPort_t *pDisp, const OSD_Entry *self)
static const void *cmsx_simplifiedTuningOnExit(displayPort_t *pDisp, const OSD_Entry *self)
{
UNUSED(pDisp);
UNUSED(self);
pidProfile_t *pidProfile = currentPidProfile;
pidProfile->slider_pids_mode = cmsx_slider_pids_mode;
pidProfile->slider_master_multiplier = cmsx_slider_master_multiplier;
pidProfile->slider_roll_pitch_ratio = cmsx_slider_roll_pitch_ratio;
pidProfile->slider_i_gain = cmsx_slider_i_gain;
pidProfile->slider_pd_ratio = cmsx_slider_pd_ratio;
pidProfile->slider_pd_gain = cmsx_slider_pd_gain;
pidProfile->slider_dmin_ratio = cmsx_slider_dmin_ratio;
pidProfile->slider_ff_gain = cmsx_slider_ff_gain;
pidProfile->simplified_pids_mode = cmsx_simplified_pids_mode;
pidProfile->simplified_master_multiplier = cmsx_simplified_master_multiplier;
pidProfile->simplified_roll_pitch_ratio = cmsx_simplified_roll_pitch_ratio;
pidProfile->simplified_i_gain = cmsx_simplified_i_gain;
pidProfile->simplified_pd_ratio = cmsx_simplified_pd_ratio;
pidProfile->simplified_pd_gain = cmsx_simplified_pd_gain;
pidProfile->simplified_dmin_ratio = cmsx_simplified_dmin_ratio;
pidProfile->simplified_ff_gain = cmsx_simplified_ff_gain;
pidProfile->slider_dterm_filter = cmsx_slider_dterm_filter;
pidProfile->slider_dterm_filter_multiplier = cmsx_slider_dterm_filter_multiplier;
gyroConfigMutable()->slider_gyro_filter = cmsx_slider_gyro_filter;
gyroConfigMutable()->slider_gyro_filter_multiplier = cmsx_slider_gyro_filter_multiplier;
pidProfile->simplified_dterm_filter = cmsx_simplified_dterm_filter;
pidProfile->simplified_dterm_filter_multiplier = cmsx_simplified_dterm_filter_multiplier;
gyroConfigMutable()->simplified_gyro_filter = cmsx_simplified_gyro_filter;
gyroConfigMutable()->simplified_gyro_filter_multiplier = cmsx_simplified_gyro_filter_multiplier;
return 0;
}
static const void *cmsx_applyTuningSliders(displayPort_t *pDisp, const void *self)
static const void *cmsx_applySimplifiedTuning(displayPort_t *pDisp, const void *self)
{
UNUSED(pDisp);
UNUSED(self);
applyTuningSliders(currentPidProfile);
applySimplifiedTuning(currentPidProfile);
return 0;
return MENU_CHAIN_BACK;
}
static const OSD_Entry cmsx_menuSlidersEntries[] =
static const OSD_Entry cmsx_menuSimplifiedTuningEntries[] =
{
{ "-- PID SLIDERS --", OME_Label, NULL, NULL, 0},
{ "PID SLIDERS", OME_TAB, NULL, &(OSD_TAB_t) { &cmsx_slider_pids_mode, PID_TUNING_SLIDERS_MODE_COUNT - 1, lookupTableSliderPidsMode }, 0 },
{ "MASTER MULT", OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_slider_master_multiplier, SLIDER_MIN, SLIDER_MAX, 1, 10 }, 0 },
{ "R/P RATIO", OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_slider_roll_pitch_ratio, SLIDER_MIN, SLIDER_MAX, 1, 10 }, 0 },
{ "I GAIN", OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_slider_i_gain, SLIDER_MIN, SLIDER_MAX, 1, 10 }, 0 },
{ "PD RATIO", OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_slider_pd_ratio, SLIDER_MIN, SLIDER_MAX, 1, 10 }, 0 },
{ "PD GAIN", OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_slider_pd_gain, SLIDER_MIN, SLIDER_MAX, 1, 10 }, 0 },
{ "DMIN RATIO", OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_slider_dmin_ratio, SLIDER_MIN, SLIDER_MAX, 1, 10 }, 0 },
{ "FF GAIN", OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_slider_ff_gain, SLIDER_MIN, SLIDER_MAX, 1, 10 }, 0 },
{ "-- SIMPLIFIED PID --", OME_Label, NULL, NULL, 0},
{ "PID TUNING", OME_TAB, NULL, &(OSD_TAB_t) { &cmsx_simplified_pids_mode, PID_SIMPLIFIED_TUNING_MODE_COUNT - 1, lookupTableSimplifiedTuningPidsMode }, 0 },
{ "MASTER MULT", OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_simplified_master_multiplier, SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX, 1, 10 }, 0 },
{ "R/P RATIO", OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_simplified_roll_pitch_ratio, SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX, 1, 10 }, 0 },
{ "I GAIN", OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_simplified_i_gain, SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX, 1, 10 }, 0 },
{ "PD RATIO", OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_simplified_pd_ratio, SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX, 1, 10 }, 0 },
{ "PD GAIN", OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_simplified_pd_gain, SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX, 1, 10 }, 0 },
{ "DMIN RATIO", OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_simplified_dmin_ratio, SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX, 1, 10 }, 0 },
{ "FF GAIN", OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_simplified_ff_gain, SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX, 1, 10 }, 0 },
{ "-- FILTER SLIDERS --", OME_Label, NULL, NULL, 0},
{ "GYRO SLIDER", OME_TAB, NULL, &(OSD_TAB_t) { &cmsx_slider_gyro_filter, 1, lookupTableOffOn }, 0 },
{ "GYRO MULT", OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_slider_gyro_filter_multiplier, SLIDER_MIN, SLIDER_MAX, 1, 10 }, 0 },
{ "DTERM SLIDER", OME_TAB, NULL, &(OSD_TAB_t) { &cmsx_slider_dterm_filter, 1, lookupTableOffOn }, 0 },
{ "DTERM MULT", OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_slider_dterm_filter_multiplier, SLIDER_MIN, SLIDER_MAX, 1, 10 }, 0 },
{ "-- SIMPLIFIED FILTER --", OME_Label, NULL, NULL, 0},
{ "GYRO TUNING", OME_TAB, NULL, &(OSD_TAB_t) { &cmsx_simplified_gyro_filter, 1, lookupTableOffOn }, 0 },
{ "GYRO MULT", OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_simplified_gyro_filter_multiplier, SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX, 1, 10 }, 0 },
{ "DTERM TUNING", OME_TAB, NULL, &(OSD_TAB_t) { &cmsx_simplified_dterm_filter, 1, lookupTableOffOn }, 0 },
{ "DTERM MULT", OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_simplified_dterm_filter_multiplier, SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX, 1, 10 }, 0 },
{ "APPLY SLIDERS", OME_Funcall, cmsx_applyTuningSliders, NULL, 0 },
{ "-- GENERAL --", OME_Label, NULL, NULL, 0},
{ "APPLY TUNING", OME_Funcall, cmsx_applySimplifiedTuning, NULL, 0 },
{ "BACK", OME_Back, NULL, NULL, 0 },
{ NULL, OME_END, NULL, NULL, 0 }
};
static CMS_Menu cmsx_menuSliders = {
static CMS_Menu cmsx_menuSimplifiedTuning = {
#ifdef CMS_MENU_DEBUG
.GUARD_text = "XSLIDER",
.GUARD_text = "XSIMPLIFIED",
.GUARD_type = OME_MENU,
#endif
.onEnter = cmsx_slidersOnEnter,
.onExit = cmsx_slidersOnExit,
.entries = cmsx_menuSlidersEntries,
.onEnter = cmsx_simplifiedTuningOnEnter,
.onExit = cmsx_simplifiedTuningOnExit,
.entries = cmsx_menuSimplifiedTuningEntries,
};
#endif // USE_TUNING_SLIDERS
#endif // USE_SIMPLIFIED_TUNING
//
// Rate & Expo
@ -972,8 +973,8 @@ static const OSD_Entry cmsx_menuImuEntries[] =
{"PID PROF", OME_UINT8, cmsx_profileIndexOnChange, &(OSD_UINT8_t){ &tmpPidProfileIndex, 1, PID_PROFILE_COUNT, 1}, 0},
{"PID", OME_Submenu, cmsMenuChange, &cmsx_menuPid, 0},
#ifdef USE_TUNING_SLIDERS
{"SLIDERS", OME_Submenu, cmsMenuChange, &cmsx_menuSliders, 0},
#ifdef USE_SIMPLIFIED_TUNING
{"SIMPLIFIED TUNING", OME_Submenu, cmsMenuChange, &cmsx_menuSimplifiedTuning, 0},
#endif
{"MISC PP", OME_Submenu, cmsMenuChange, &cmsx_menuProfileOther, 0},
{"FILT PP", OME_Submenu, cmsMenuChange, &cmsx_menuFilterPerProfile, 0},

76
src/main/config/tuning_sliders.c → src/main/config/simplified_tuning.c
View file

@ -21,12 +21,12 @@
#include <math.h>
#include "platform.h"
#ifdef USE_TUNING_SLIDERS
#ifdef USE_SIMPLIFIED_TUNING
#include "common/axis.h"
#include "common/maths.h"
#include "config/tuning_sliders.h"
#include "config/simplified_tuning.h"
#include "sensors/gyro.h"
@ -40,86 +40,86 @@ static void calculateNewPidValues(pidProfile_t *pidProfile)
const int dMinDefaults[FLIGHT_DYNAMICS_INDEX_COUNT] = D_MIN_DEFAULT;
// MASTER MULTIPLIER
for (int axis = FD_ROLL; axis <= pidProfile->slider_pids_mode; ++axis) {
pidProfile->pid[axis].P = constrain(pidDefaults[axis].P * pidProfile->slider_master_multiplier / 100, 0, PID_GAIN_MAX);
pidProfile->pid[axis].I = constrain(pidDefaults[axis].I * pidProfile->slider_master_multiplier / 100, 0, PID_GAIN_MAX);
pidProfile->pid[axis].D = constrain(pidDefaults[axis].D * pidProfile->slider_master_multiplier / 100, 0, PID_GAIN_MAX);
pidProfile->d_min[axis] = constrain(dMinDefaults[axis] * pidProfile->slider_master_multiplier / 100, 0, D_MIN_GAIN_MAX);
pidProfile->pid[axis].F = constrain(pidDefaults[axis].F * pidProfile->slider_master_multiplier / 100, 0, F_GAIN_MAX);
for (int axis = FD_ROLL; axis <= pidProfile->simplified_pids_mode; ++axis) {
pidProfile->pid[axis].P = constrain(pidDefaults[axis].P * pidProfile->simplified_master_multiplier / 100, 0, PID_GAIN_MAX);
pidProfile->pid[axis].I = constrain(pidDefaults[axis].I * pidProfile->simplified_master_multiplier / 100, 0, PID_GAIN_MAX);
pidProfile->pid[axis].D = constrain(pidDefaults[axis].D * pidProfile->simplified_master_multiplier / 100, 0, PID_GAIN_MAX);
pidProfile->d_min[axis] = constrain(dMinDefaults[axis] * pidProfile->simplified_master_multiplier / 100, 0, D_MIN_GAIN_MAX);
pidProfile->pid[axis].F = constrain(pidDefaults[axis].F * pidProfile->simplified_master_multiplier / 100, 0, F_GAIN_MAX);
}
// ROLL PITCH RATIO
pidProfile->pid[FD_ROLL].P = constrain(pidProfile->pid[FD_ROLL].P * pidProfile->slider_roll_pitch_ratio / 100, 0, PID_GAIN_MAX);
pidProfile->pid[FD_ROLL].I = constrain(pidProfile->pid[FD_ROLL].I * pidProfile->slider_roll_pitch_ratio / 100, 0, PID_GAIN_MAX);
pidProfile->pid[FD_ROLL].D = constrain(pidProfile->pid[FD_ROLL].D * pidProfile->slider_roll_pitch_ratio / 100, 0, PID_GAIN_MAX);
pidProfile->d_min[FD_ROLL] = constrain(pidProfile->d_min[FD_ROLL] * pidProfile->slider_roll_pitch_ratio / 100, 0, D_MIN_GAIN_MAX);
pidProfile->pid[FD_ROLL].F = constrain(pidProfile->pid[FD_ROLL].F * pidProfile->slider_roll_pitch_ratio / 100, 0, F_GAIN_MAX);
pidProfile->pid[FD_ROLL].P = constrain(pidProfile->pid[FD_ROLL].P * pidProfile->simplified_roll_pitch_ratio / 100, 0, PID_GAIN_MAX);
pidProfile->pid[FD_ROLL].I = constrain(pidProfile->pid[FD_ROLL].I * pidProfile->simplified_roll_pitch_ratio / 100, 0, PID_GAIN_MAX);
pidProfile->pid[FD_ROLL].D = constrain(pidProfile->pid[FD_ROLL].D * pidProfile->simplified_roll_pitch_ratio / 100, 0, PID_GAIN_MAX);
pidProfile->d_min[FD_ROLL] = constrain(pidProfile->d_min[FD_ROLL] * pidProfile->simplified_roll_pitch_ratio / 100, 0, D_MIN_GAIN_MAX);
pidProfile->pid[FD_ROLL].F = constrain(pidProfile->pid[FD_ROLL].F * pidProfile->simplified_roll_pitch_ratio / 100, 0, F_GAIN_MAX);
// I GAIN
for (int axis = FD_ROLL; axis <= pidProfile->slider_pids_mode; ++axis) {
pidProfile->pid[axis].I = constrain(pidProfile->pid[axis].I * pidProfile->slider_i_gain / 100, 0, PID_GAIN_MAX);
for (int axis = FD_ROLL; axis <= pidProfile->simplified_pids_mode; ++axis) {
pidProfile->pid[axis].I = constrain(pidProfile->pid[axis].I * pidProfile->simplified_i_gain / 100, 0, PID_GAIN_MAX);
}
// PD RATIO - applied only on roll and pitch because on yaw default D gain is 0
const float defaultPDRatio = pidDefaults[FD_ROLL].P / (float)pidDefaults[FD_ROLL].D;
for (int axis = FD_ROLL; axis <= FD_PITCH; ++axis) {
pidProfile->pid[axis].P = constrain(pidProfile->pid[axis].D * defaultPDRatio * pidProfile->slider_pd_ratio / 100, 0, PID_GAIN_MAX);
pidProfile->pid[axis].P = constrain(pidProfile->pid[axis].D * defaultPDRatio * pidProfile->simplified_pd_ratio / 100, 0, PID_GAIN_MAX);
}
// PD GAIN
for (int axis = FD_ROLL; axis <= pidProfile->slider_pids_mode; ++axis) {
pidProfile->pid[axis].P = constrain(pidProfile->pid[axis].P * pidProfile->slider_pd_gain / 100, 0, PID_GAIN_MAX);
pidProfile->pid[axis].D = constrain(pidProfile->pid[axis].D * pidProfile->slider_pd_gain / 100, 0, PID_GAIN_MAX);
pidProfile->d_min[axis] = constrain(pidProfile->d_min[axis] * pidProfile->slider_pd_gain / 100, 0, D_MIN_GAIN_MAX);
for (int axis = FD_ROLL; axis <= pidProfile->simplified_pids_mode; ++axis) {
pidProfile->pid[axis].P = constrain(pidProfile->pid[axis].P * pidProfile->simplified_pd_gain / 100, 0, PID_GAIN_MAX);
pidProfile->pid[axis].D = constrain(pidProfile->pid[axis].D * pidProfile->simplified_pd_gain / 100, 0, PID_GAIN_MAX);
pidProfile->d_min[axis] = constrain(pidProfile->d_min[axis] * pidProfile->simplified_pd_gain / 100, 0, D_MIN_GAIN_MAX);
}
// D MIN RATIO
const float defaultDMinRatio = dMinDefaults[FD_ROLL] / (float)pidDefaults[FD_ROLL].D;
const float scaledDminRatioSliderValue = scaleRangef(pidProfile->slider_dmin_ratio, SLIDER_MIN, SLIDER_MAX, SLIDER_MIN + SLIDER_MAX - 100 / defaultDMinRatio, 100 / defaultDMinRatio);
for (int axis = FD_ROLL; axis <= pidProfile->slider_pids_mode; ++axis) {
if (pidProfile->slider_dmin_ratio == 200) {
pidProfile->d_min[axis] = 0; // disable d_min if slider maxed out
const float scaledDminRatioSimplifiedValue = scaleRangef(pidProfile->simplified_dmin_ratio, SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX, SIMPLIFIED_TUNING_MIN + SIMPLIFIED_TUNING_MAX - 100 / defaultDMinRatio, 100 / defaultDMinRatio);
for (int axis = FD_ROLL; axis <= pidProfile->simplified_pids_mode; ++axis) {
if (pidProfile->simplified_dmin_ratio == 200) {
pidProfile->d_min[axis] = 0; // disable d_min if range maxed out
} else {
pidProfile->d_min[axis] = constrain(constrain(pidProfile->pid[axis].D * defaultDMinRatio * scaledDminRatioSliderValue / 100, 0, pidProfile->pid[axis].D - 1), 0, D_MIN_GAIN_MAX);
pidProfile->d_min[axis] = constrain(constrain(pidProfile->pid[axis].D * defaultDMinRatio * scaledDminRatioSimplifiedValue / 100, 0, pidProfile->pid[axis].D - 1), 0, D_MIN_GAIN_MAX);
}
}
// FF GAIN
for (int axis = FD_ROLL; axis <= pidProfile->slider_pids_mode; ++axis) {
pidProfile->pid[axis].F = constrain(pidProfile->pid[axis].F * pidProfile->slider_ff_gain / 100, 0, F_GAIN_MAX);
for (int axis = FD_ROLL; axis <= pidProfile->simplified_pids_mode; ++axis) {
pidProfile->pid[axis].F = constrain(pidProfile->pid[axis].F * pidProfile->simplified_ff_gain / 100, 0, F_GAIN_MAX);
}
}
static void calculateNewDTermFilterValues(pidProfile_t *pidProfile)
{
pidProfile->dyn_lpf_dterm_min_hz = constrain(DYN_LPF_DTERM_MIN_HZ_DEFAULT * pidProfile->slider_dterm_filter_multiplier / 100, 0, DYN_LPF_FILTER_FREQUENCY_MAX);
pidProfile->dyn_lpf_dterm_max_hz = constrain(DYN_LPF_DTERM_MAX_HZ_DEFAULT * pidProfile->slider_dterm_filter_multiplier / 100, 0, DYN_LPF_FILTER_FREQUENCY_MAX);
pidProfile->dterm_lowpass2_hz = constrain(DTERM_LOWPASS_2_HZ_DEFAULT * pidProfile->slider_dterm_filter_multiplier / 100, 0, FILTER_FREQUENCY_MAX);
pidProfile->dyn_lpf_dterm_min_hz = constrain(DYN_LPF_DTERM_MIN_HZ_DEFAULT * pidProfile->simplified_dterm_filter_multiplier / 100, 0, DYN_LPF_FILTER_FREQUENCY_MAX);
pidProfile->dyn_lpf_dterm_max_hz = constrain(DYN_LPF_DTERM_MAX_HZ_DEFAULT * pidProfile->simplified_dterm_filter_multiplier / 100, 0, DYN_LPF_FILTER_FREQUENCY_MAX);
pidProfile->dterm_lowpass2_hz = constrain(DTERM_LOWPASS_2_HZ_DEFAULT * pidProfile->simplified_dterm_filter_multiplier / 100, 0, FILTER_FREQUENCY_MAX);
pidProfile->dterm_filter_type = FILTER_PT1;
pidProfile->dterm_filter2_type = FILTER_PT1;
}
static void calculateNewGyroFilterValues()
{
gyroConfigMutable()->dyn_lpf_gyro_min_hz = constrain(DYN_LPF_GYRO_MIN_HZ_DEFAULT * gyroConfig()->slider_gyro_filter_multiplier / 100, 0, DYN_LPF_FILTER_FREQUENCY_MAX);
gyroConfigMutable()->dyn_lpf_gyro_max_hz = constrain(DYN_LPF_GYRO_MAX_HZ_DEFAULT * gyroConfig()->slider_gyro_filter_multiplier / 100, 0, DYN_LPF_FILTER_FREQUENCY_MAX);
gyroConfigMutable()->gyro_lowpass2_hz = constrain(GYRO_LOWPASS_2_HZ_DEFAULT * gyroConfig()->slider_gyro_filter_multiplier / 100, 0, FILTER_FREQUENCY_MAX);
gyroConfigMutable()->dyn_lpf_gyro_min_hz = constrain(DYN_LPF_GYRO_MIN_HZ_DEFAULT * gyroConfig()->simplified_gyro_filter_multiplier / 100, 0, DYN_LPF_FILTER_FREQUENCY_MAX);
gyroConfigMutable()->dyn_lpf_gyro_max_hz = constrain(DYN_LPF_GYRO_MAX_HZ_DEFAULT * gyroConfig()->simplified_gyro_filter_multiplier / 100, 0, DYN_LPF_FILTER_FREQUENCY_MAX);
gyroConfigMutable()->gyro_lowpass2_hz = constrain(GYRO_LOWPASS_2_HZ_DEFAULT * gyroConfig()->simplified_gyro_filter_multiplier / 100, 0, FILTER_FREQUENCY_MAX);
gyroConfigMutable()->gyro_lowpass_type = FILTER_PT1;
gyroConfigMutable()->gyro_lowpass2_type = FILTER_PT1;
}
void applyTuningSliders(pidProfile_t *pidProfile)
void applySimplifiedTuning(pidProfile_t *pidProfile)
{
if (pidProfile->slider_pids_mode != PID_TUNING_SLIDERS_OFF) {
if (pidProfile->simplified_pids_mode != PID_SIMPLIFIED_TUNING_OFF) {
calculateNewPidValues(pidProfile);
}
if (pidProfile->slider_dterm_filter) {
if (pidProfile->simplified_dterm_filter) {
calculateNewDTermFilterValues(pidProfile);
}
if (gyroConfig()->slider_gyro_filter) {
if (gyroConfig()->simplified_gyro_filter) {
calculateNewGyroFilterValues();
}
}
#endif // USE_TUNING_SLIDERS
#endif // USE_SIMPLIFIED_TUNING

16
src/main/config/tuning_sliders.h → src/main/config/simplified_tuning.h
View file

@ -22,14 +22,14 @@
#include "flight/pid.h"
#define SLIDER_MIN 50
#define SLIDER_MAX 200
#define SIMPLIFIED_TUNING_MIN 50
#define SIMPLIFIED_TUNING_MAX 200
typedef enum {
PID_TUNING_SLIDERS_OFF = 0,
PID_TUNING_SLIDERS_RP,
PID_TUNING_SLIDERS_RPY,
PID_TUNING_SLIDERS_MODE_COUNT,
} pidTuningSlidersMode_e;
PID_SIMPLIFIED_TUNING_OFF = 0,
PID_SIMPLIFIED_TUNING_RP,
PID_SIMPLIFIED_TUNING_RPY,
PID_SIMPLIFIED_TUNING_MODE_COUNT,
} pidSimplifiedTuningMode_e;
void applyTuningSliders(pidProfile_t *pidProfile);
void applySimplifiedTuning(pidProfile_t *pidProfile);

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

@ -33,7 +33,7 @@
#include "common/maths.h"
#include "config/config_reset.h"
#include "config/tuning_sliders.h"
#include "config/simplified_tuning.h"
#include "drivers/pwm_output.h"
#include "drivers/sound_beeper.h"
@ -210,16 +210,16 @@ void resetPidProfile(pidProfile_t *pidProfile)
.dyn_lpf_curve_expo = 5,
.level_race_mode = false,
.vbat_sag_compensation = 0,
.slider_pids_mode = PID_TUNING_SLIDERS_OFF,
.slider_master_multiplier = 100,
.slider_roll_pitch_ratio = 100,
.slider_i_gain = 100,
.slider_pd_ratio = 100,
.slider_pd_gain = 100,
.slider_dmin_ratio = 100,
.slider_ff_gain = 100,
.slider_dterm_filter = true,
.slider_dterm_filter_multiplier = 100,
.simplified_pids_mode = PID_SIMPLIFIED_TUNING_OFF,
.simplified_master_multiplier = 100,
.simplified_roll_pitch_ratio = 100,
.simplified_i_gain = 100,
.simplified_pd_ratio = 100,
.simplified_pd_gain = 100,
.simplified_dmin_ratio = 100,
.simplified_ff_gain = 100,
.simplified_dterm_filter = true,
.simplified_dterm_filter_multiplier = 100,
);
#ifndef USE_D_MIN
pidProfile->pid[PID_ROLL].D = 30;

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

@ -214,17 +214,17 @@ typedef struct pidProfile_s {
uint8_t level_race_mode; // NFE race mode - when true pitch setpoint calcualtion is gyro based in level mode
uint8_t vbat_sag_compensation; // Reduce motor output by this percentage of the maximum compensation amount
uint8_t slider_pids_mode;
uint8_t slider_master_multiplier;
uint8_t slider_roll_pitch_ratio;
uint8_t slider_i_gain;
uint8_t slider_pd_ratio;
uint8_t slider_pd_gain;
uint8_t slider_dmin_ratio;
uint8_t slider_ff_gain;
uint8_t simplified_pids_mode;
uint8_t simplified_master_multiplier;
uint8_t simplified_roll_pitch_ratio;
uint8_t simplified_i_gain;
uint8_t simplified_pd_ratio;
uint8_t simplified_pd_gain;
uint8_t simplified_dmin_ratio;
uint8_t simplified_ff_gain;
uint8_t slider_dterm_filter;
uint8_t slider_dterm_filter_multiplier;
uint8_t simplified_dterm_filter;
uint8_t simplified_dterm_filter_multiplier;
} pidProfile_t;
PG_DECLARE_ARRAY(pidProfile_t, PID_PROFILE_COUNT, pidProfiles);

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

@ -47,7 +47,7 @@
#include "config/config.h"
#include "config/config_eeprom.h"
#include "config/feature.h"
#include "config/tuning_sliders.h"
#include "config/simplified_tuning.h"
#include "drivers/accgyro/accgyro.h"
#include "drivers/bus_i2c.h"
@ -2088,24 +2088,24 @@ static mspResult_e mspFcProcessOutCommandWithArg(mspDescriptor_t srcDesc, int16_
break;
#endif // USE_VTX_TABLE
#ifdef USE_TUNING_SLIDERS
#ifdef USE_SIMPLIFIED_TUNING
// Added in MSP API 1.43
case MSP_TUNING_SLIDERS:
case MSP_SIMPLIFIED_TUNING:
{
sbufWriteU8(dst, currentPidProfile->slider_pids_mode);
sbufWriteU8(dst, currentPidProfile->slider_master_multiplier);
sbufWriteU8(dst, currentPidProfile->slider_roll_pitch_ratio);
sbufWriteU8(dst, currentPidProfile->slider_i_gain);
sbufWriteU8(dst, currentPidProfile->slider_pd_ratio);
sbufWriteU8(dst, currentPidProfile->slider_pd_gain);
sbufWriteU8(dst, currentPidProfile->slider_dmin_ratio);
sbufWriteU8(dst, currentPidProfile->slider_ff_gain);
sbufWriteU8(dst, currentPidProfile->simplified_pids_mode);
sbufWriteU8(dst, currentPidProfile->simplified_master_multiplier);
sbufWriteU8(dst, currentPidProfile->simplified_roll_pitch_ratio);
sbufWriteU8(dst, currentPidProfile->simplified_i_gain);
sbufWriteU8(dst, currentPidProfile->simplified_pd_ratio);
sbufWriteU8(dst, currentPidProfile->simplified_pd_gain);
sbufWriteU8(dst, currentPidProfile->simplified_dmin_ratio);
sbufWriteU8(dst, currentPidProfile->simplified_ff_gain);
sbufWriteU8(dst, currentPidProfile->slider_dterm_filter);
sbufWriteU8(dst, currentPidProfile->slider_dterm_filter_multiplier);
sbufWriteU8(dst, currentPidProfile->simplified_dterm_filter);
sbufWriteU8(dst, currentPidProfile->simplified_dterm_filter_multiplier);
sbufWriteU8(dst, gyroConfig()->slider_gyro_filter);
sbufWriteU8(dst, gyroConfig()->slider_gyro_filter_multiplier);
sbufWriteU8(dst, gyroConfig()->simplified_gyro_filter);
sbufWriteU8(dst, gyroConfig()->simplified_gyro_filter_multiplier);
}
break;
#endif
@ -3054,25 +3054,25 @@ static mspResult_e mspProcessInCommand(mspDescriptor_t srcDesc, int16_t cmdMSP,
break;
#endif
#ifdef USE_TUNING_SLIDERS
#ifdef USE_SIMPLIFIED_TUNING
// Added in MSP API 1.43
case MSP_SET_TUNING_SLIDERS:
currentPidProfile->slider_pids_mode = sbufReadU8(src);
currentPidProfile->slider_master_multiplier = sbufReadU8(src);
currentPidProfile->slider_roll_pitch_ratio = sbufReadU8(src);
currentPidProfile->slider_i_gain = sbufReadU8(src);
currentPidProfile->slider_pd_ratio = sbufReadU8(src);
currentPidProfile->slider_pd_gain = sbufReadU8(src);
currentPidProfile->slider_dmin_ratio = sbufReadU8(src);
currentPidProfile->slider_ff_gain = sbufReadU8(src);
case MSP_SET_SIMPLIFIED_TUNING:
currentPidProfile->simplified_pids_mode = sbufReadU8(src);
currentPidProfile->simplified_master_multiplier = sbufReadU8(src);
currentPidProfile->simplified_roll_pitch_ratio = sbufReadU8(src);
currentPidProfile->simplified_i_gain = sbufReadU8(src);
currentPidProfile->simplified_pd_ratio = sbufReadU8(src);
currentPidProfile->simplified_pd_gain = sbufReadU8(src);
currentPidProfile->simplified_dmin_ratio = sbufReadU8(src);
currentPidProfile->simplified_ff_gain = sbufReadU8(src);
currentPidProfile->slider_dterm_filter = sbufReadU8(src);
currentPidProfile->slider_dterm_filter_multiplier = sbufReadU8(src);
currentPidProfile->simplified_dterm_filter = sbufReadU8(src);
currentPidProfile->simplified_dterm_filter_multiplier = sbufReadU8(src);
gyroConfigMutable()->slider_gyro_filter = sbufReadU8(src);
gyroConfigMutable()->slider_gyro_filter_multiplier = sbufReadU8(src);
gyroConfigMutable()->simplified_gyro_filter = sbufReadU8(src);
gyroConfigMutable()->simplified_gyro_filter_multiplier = sbufReadU8(src);
applyTuningSliders(currentPidProfile);
applySimplifiedTuning(currentPidProfile);
break;
#endif

4
src/main/msp/msp_protocol.h
View file

@ -285,8 +285,8 @@
#define MSP_VTXTABLE_POWERLEVEL 138 //out message vtxTable powerLevel data
#define MSP_MOTOR_TELEMETRY 139 //out message Per-motor telemetry data (RPM, packet stats, ESC temp, etc.)
#define MSP_TUNING_SLIDERS 140 //out message Tuning slider poisitons and enabled state
#define MSP_SET_TUNING_SLIDERS 141 //in message Set tuning slider positions and apply tuning slider calculation
#define MSP_SIMPLIFIED_TUNING 140 //out message Simplified tuning values and enabled state
#define MSP_SET_SIMPLIFIED_TUNING 141 //in message Set simplified tuning positions and apply the calculated tuning
#define MSP_SET_RAW_RC 200 //in message 8 rc chan
#define MSP_SET_RAW_GPS 201 //in message fix, numsat, lat, lon, alt, speed

4
src/main/sensors/gyro.h
View file

@ -204,8 +204,8 @@ typedef struct gyroConfig_s {
uint8_t gyrosDetected; // What gyros should detection be attempted for on startup. Automatically set on first startup.
uint8_t dyn_lpf_curve_expo; // set the curve for dynamic gyro lowpass filter
uint8_t slider_gyro_filter;
uint8_t slider_gyro_filter_multiplier;
uint8_t simplified_gyro_filter;
uint8_t simplified_gyro_filter_multiplier;
} gyroConfig_t;
PG_DECLARE(gyroConfig_t, gyroConfig);

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

@ -395,5 +395,5 @@
#define USE_CUSTOM_BOX_NAMES
#define USE_BATTERY_VOLTAGE_SAG_COMPENSATION
#define USE_RX_MSP_OVERRIDE
#define USE_TUNING_SLIDERS
#define USE_SIMPLIFIED_TUNING
#endif