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

Check for NULL defaults in CLI print commands

Browse source
This commit is contained in:
Martin Budden 2016-12-27 19:49:23 +00:00
parent 362f857cec
commit e4227b2ec9
1 changed files with 186 additions and 153 deletions
Download patch file Download diff file Expand all files Collapse all files

339
src/main/io/serial_cli.c
View file

@ -1212,22 +1212,25 @@ static void cliRxFail(char *cmdline)
static void printAux(uint8_t dumpMask, const modeActivationProfile_t *modeActivationProfile, const modeActivationProfile_t *defaultModeActivationProfile) static void printAux(uint8_t dumpMask, const modeActivationProfile_t *modeActivationProfile, const modeActivationProfile_t *defaultModeActivationProfile)
{ {
const char *format = "aux %u %u %u %u %u\r\n";
// print out aux channel settings // print out aux channel settings
for (uint32_t i = 0; i < MAX_MODE_ACTIVATION_CONDITION_COUNT; i++) { for (uint32_t i = 0; i < MAX_MODE_ACTIVATION_CONDITION_COUNT; i++) {
const modeActivationCondition_t *mac = &modeActivationProfile->modeActivationConditions[i]; const modeActivationCondition_t *mac = &modeActivationProfile->modeActivationConditions[i];
const modeActivationCondition_t *macDefault = &defaultModeActivationProfile->modeActivationConditions[i]; bool equalsDefault = true;
const bool equalsDefault = mac->modeId == macDefault->modeId if (defaultModeActivationProfile) {
&& mac->auxChannelIndex == macDefault->auxChannelIndex const modeActivationCondition_t *macDefault = &defaultModeActivationProfile->modeActivationConditions[i];
&& mac->range.startStep == macDefault->range.startStep equalsDefault = mac->modeId == macDefault->modeId
&& mac->range.endStep == macDefault->range.endStep; && mac->auxChannelIndex == macDefault->auxChannelIndex
const char *format = "aux %u %u %u %u %u\r\n"; && mac->range.startStep == macDefault->range.startStep
cliDefaultPrintf(dumpMask, equalsDefault, format, && mac->range.endStep == macDefault->range.endStep;
i, cliDefaultPrintf(dumpMask, equalsDefault, format,
macDefault->modeId, i,
macDefault->auxChannelIndex, macDefault->modeId,
MODE_STEP_TO_CHANNEL_VALUE(macDefault->range.startStep), macDefault->auxChannelIndex,
MODE_STEP_TO_CHANNEL_VALUE(macDefault->range.endStep) MODE_STEP_TO_CHANNEL_VALUE(macDefault->range.startStep),
); MODE_STEP_TO_CHANNEL_VALUE(macDefault->range.endStep)
);
}
cliDumpPrintf(dumpMask, equalsDefault, format, cliDumpPrintf(dumpMask, equalsDefault, format,
i, i,
mac->modeId, mac->modeId,
@ -1280,25 +1283,28 @@ static void cliAux(char *cmdline)
static void printSerial(uint8_t dumpMask, const serialConfig_t *serialConfig, const serialConfig_t *serialConfigDefault) static void printSerial(uint8_t dumpMask, const serialConfig_t *serialConfig, const serialConfig_t *serialConfigDefault)
{ {
const char *format = "serial %d %d %ld %ld %ld %ld\r\n";
for (uint32_t i = 0; i < SERIAL_PORT_COUNT; i++) { for (uint32_t i = 0; i < SERIAL_PORT_COUNT; i++) {
if (!serialIsPortAvailable(serialConfig->portConfigs[i].identifier)) { if (!serialIsPortAvailable(serialConfig->portConfigs[i].identifier)) {
continue; continue;
}; };
const bool equalsDefault = serialConfig->portConfigs[i].identifier == serialConfigDefault->portConfigs[i].identifier bool equalsDefault = true;
&& serialConfig->portConfigs[i].functionMask == serialConfigDefault->portConfigs[i].functionMask if (serialConfigDefault) {
&& serialConfig->portConfigs[i].msp_baudrateIndex == serialConfigDefault->portConfigs[i].msp_baudrateIndex equalsDefault = serialConfig->portConfigs[i].identifier == serialConfigDefault->portConfigs[i].identifier
&& serialConfig->portConfigs[i].gps_baudrateIndex == serialConfigDefault->portConfigs[i].gps_baudrateIndex && serialConfig->portConfigs[i].functionMask == serialConfigDefault->portConfigs[i].functionMask
&& serialConfig->portConfigs[i].telemetry_baudrateIndex == serialConfigDefault->portConfigs[i].telemetry_baudrateIndex && serialConfig->portConfigs[i].msp_baudrateIndex == serialConfigDefault->portConfigs[i].msp_baudrateIndex
&& serialConfig->portConfigs[i].blackbox_baudrateIndex == serialConfigDefault->portConfigs[i].blackbox_baudrateIndex; && serialConfig->portConfigs[i].gps_baudrateIndex == serialConfigDefault->portConfigs[i].gps_baudrateIndex
const char *format = "serial %d %d %ld %ld %ld %ld\r\n"; && serialConfig->portConfigs[i].telemetry_baudrateIndex == serialConfigDefault->portConfigs[i].telemetry_baudrateIndex
cliDefaultPrintf(dumpMask, equalsDefault, format, && serialConfig->portConfigs[i].blackbox_baudrateIndex == serialConfigDefault->portConfigs[i].blackbox_baudrateIndex;
serialConfigDefault->portConfigs[i].identifier, cliDefaultPrintf(dumpMask, equalsDefault, format,
serialConfigDefault->portConfigs[i].functionMask, serialConfigDefault->portConfigs[i].identifier,
baudRates[serialConfigDefault->portConfigs[i].msp_baudrateIndex], serialConfigDefault->portConfigs[i].functionMask,
baudRates[serialConfigDefault->portConfigs[i].gps_baudrateIndex], baudRates[serialConfigDefault->portConfigs[i].msp_baudrateIndex],
baudRates[serialConfigDefault->portConfigs[i].telemetry_baudrateIndex], baudRates[serialConfigDefault->portConfigs[i].gps_baudrateIndex],
baudRates[serialConfigDefault->portConfigs[i].blackbox_baudrateIndex] baudRates[serialConfigDefault->portConfigs[i].telemetry_baudrateIndex],
); baudRates[serialConfigDefault->portConfigs[i].blackbox_baudrateIndex]
);
}
cliDumpPrintf(dumpMask, equalsDefault, format, cliDumpPrintf(dumpMask, equalsDefault, format,
serialConfig->portConfigs[i].identifier, serialConfig->portConfigs[i].identifier,
serialConfig->portConfigs[i].functionMask, serialConfig->portConfigs[i].functionMask,
@ -1473,26 +1479,29 @@ static void cliSerialPassthrough(char *cmdline)
static void printAdjustmentRange(uint8_t dumpMask, const adjustmentProfile_t *adjustmentProfile, const adjustmentProfile_t *defaultAdjustmentProfile) static void printAdjustmentRange(uint8_t dumpMask, const adjustmentProfile_t *adjustmentProfile, const adjustmentProfile_t *defaultAdjustmentProfile)
{ {
const char *format = "adjrange %u %u %u %u %u %u %u\r\n";
// print out adjustment ranges channel settings // print out adjustment ranges channel settings
for (uint32_t i = 0; i < MAX_ADJUSTMENT_RANGE_COUNT; i++) { for (uint32_t i = 0; i < MAX_ADJUSTMENT_RANGE_COUNT; i++) {
const adjustmentRange_t *ar = &adjustmentProfile->adjustmentRanges[i]; const adjustmentRange_t *ar = &adjustmentProfile->adjustmentRanges[i];
const adjustmentRange_t *arDefault = &defaultAdjustmentProfile->adjustmentRanges[i]; bool equalsDefault = true;
const bool equalsDefault = ar->auxChannelIndex == arDefault->auxChannelIndex if (defaultAdjustmentProfile) {
&& ar->range.startStep == arDefault->range.startStep const adjustmentRange_t *arDefault = &defaultAdjustmentProfile->adjustmentRanges[i];
&& ar->range.endStep == arDefault->range.endStep equalsDefault = ar->auxChannelIndex == arDefault->auxChannelIndex
&& ar->adjustmentFunction == arDefault->adjustmentFunction && ar->range.startStep == arDefault->range.startStep
&& ar->auxSwitchChannelIndex == arDefault->auxSwitchChannelIndex && ar->range.endStep == arDefault->range.endStep
&& ar->adjustmentIndex == arDefault->adjustmentIndex; && ar->adjustmentFunction == arDefault->adjustmentFunction
const char *format = "adjrange %u %u %u %u %u %u %u\r\n"; && ar->auxSwitchChannelIndex == arDefault->auxSwitchChannelIndex
cliDefaultPrintf(dumpMask, equalsDefault, format, && ar->adjustmentIndex == arDefault->adjustmentIndex;
i, cliDefaultPrintf(dumpMask, equalsDefault, format,
arDefault->adjustmentIndex, i,
arDefault->auxChannelIndex, arDefault->adjustmentIndex,
MODE_STEP_TO_CHANNEL_VALUE(arDefault->range.startStep), arDefault->auxChannelIndex,
MODE_STEP_TO_CHANNEL_VALUE(arDefault->range.endStep), MODE_STEP_TO_CHANNEL_VALUE(arDefault->range.startStep),
arDefault->adjustmentFunction, MODE_STEP_TO_CHANNEL_VALUE(arDefault->range.endStep),
arDefault->auxSwitchChannelIndex arDefault->adjustmentFunction,
); arDefault->auxSwitchChannelIndex
);
}
cliDumpPrintf(dumpMask, equalsDefault, format, cliDumpPrintf(dumpMask, equalsDefault, format,
i, i,
ar->adjustmentIndex, ar->adjustmentIndex,
@ -1568,6 +1577,7 @@ static void cliAdjustmentRange(char *cmdline)
#ifndef USE_QUAD_MIXER_ONLY #ifndef USE_QUAD_MIXER_ONLY
static void printMotorMix(uint8_t dumpMask, const motorMixer_t *customMotorMixer, const motorMixer_t *defaultCustomMotorMixer) static void printMotorMix(uint8_t dumpMask, const motorMixer_t *customMotorMixer, const motorMixer_t *defaultCustomMotorMixer)
{ {
const char *format = "mmix %d %s %s %s %s\r\n";
char buf0[8]; char buf0[8];
char buf1[8]; char buf1[8];
char buf2[8]; char buf2[8];
@ -1579,19 +1589,21 @@ static void printMotorMix(uint8_t dumpMask, const motorMixer_t *customMotorMixer
const float roll = customMotorMixer[i].roll; const float roll = customMotorMixer[i].roll;
const float pitch = customMotorMixer[i].pitch; const float pitch = customMotorMixer[i].pitch;
const float yaw = customMotorMixer[i].yaw; const float yaw = customMotorMixer[i].yaw;
const float thrDefault = defaultCustomMotorMixer[i].throttle; bool equalsDefault = true;
const float rollDefault = defaultCustomMotorMixer[i].roll; if (defaultCustomMotorMixer) {
const float pitchDefault = defaultCustomMotorMixer[i].pitch; const float thrDefault = defaultCustomMotorMixer[i].throttle;
const float yawDefault = defaultCustomMotorMixer[i].yaw; const float rollDefault = defaultCustomMotorMixer[i].roll;
const bool equalsDefault = thr == thrDefault && roll == rollDefault && pitch == pitchDefault && yaw == yawDefault; const float pitchDefault = defaultCustomMotorMixer[i].pitch;
const float yawDefault = defaultCustomMotorMixer[i].yaw;
const bool equalsDefault = thr == thrDefault && roll == rollDefault && pitch == pitchDefault && yaw == yawDefault;
const char *format = "mmix %d %s %s %s %s\r\n"; cliDefaultPrintf(dumpMask, equalsDefault, format,
cliDefaultPrintf(dumpMask, equalsDefault, format, i,
i, ftoa(thrDefault, buf0),
ftoa(thrDefault, buf0), ftoa(rollDefault, buf1),
ftoa(rollDefault, buf1), ftoa(pitchDefault, buf2),
ftoa(pitchDefault, buf2), ftoa(yawDefault, buf3));
ftoa(yawDefault, buf3)); }
cliDumpPrintf(dumpMask, equalsDefault, format, cliDumpPrintf(dumpMask, equalsDefault, format,
i, i,
ftoa(thr, buf0), ftoa(thr, buf0),
@ -1672,20 +1684,20 @@ static void cliMotorMix(char *cmdline)
static void printRxRange(uint8_t dumpMask, const rxConfig_t *rxConfig, const rxConfig_t *defaultRxConfig) static void printRxRange(uint8_t dumpMask, const rxConfig_t *rxConfig, const rxConfig_t *defaultRxConfig)
{ {
const rxChannelRangeConfiguration_t *channelRangeConfiguration; const char *format = "rxrange %u %u %u\r\n";
const rxChannelRangeConfiguration_t *channelRangeConfigurationDefault;
bool equalsDefault;
for (uint32_t i = 0; i < NON_AUX_CHANNEL_COUNT; i++) { for (uint32_t i = 0; i < NON_AUX_CHANNEL_COUNT; i++) {
channelRangeConfiguration = &rxConfig->channelRanges[i]; const rxChannelRangeConfiguration_t *channelRangeConfiguration = &rxConfig->channelRanges[i];
channelRangeConfigurationDefault = &defaultRxConfig->channelRanges[i]; bool equalsDefault = true;
equalsDefault = channelRangeConfiguration->min == channelRangeConfigurationDefault->min if (defaultRxConfig) {
&& channelRangeConfiguration->max == channelRangeConfigurationDefault->max; const rxChannelRangeConfiguration_t *channelRangeConfigurationDefault = &defaultRxConfig->channelRanges[i];
const char *format = "rxrange %u %u %u\r\n"; equalsDefault = channelRangeConfiguration->min == channelRangeConfigurationDefault->min
cliDefaultPrintf(dumpMask, equalsDefault, format, && channelRangeConfiguration->max == channelRangeConfigurationDefault->max;
i, cliDefaultPrintf(dumpMask, equalsDefault, format,
channelRangeConfigurationDefault->min, i,
channelRangeConfigurationDefault->max channelRangeConfigurationDefault->min,
); channelRangeConfigurationDefault->max
);
}
cliDumpPrintf(dumpMask, equalsDefault, format, cliDumpPrintf(dumpMask, equalsDefault, format,
i, i,
channelRangeConfiguration->min, channelRangeConfiguration->min,
@ -1737,18 +1749,21 @@ static void cliRxRange(char *cmdline)
} }
#ifdef LED_STRIP #ifdef LED_STRIP
static void printLed(uint8_t dumpMask, const ledConfig_t *ledConfigs, , const ledConfig_t *defaultLedConfigs) static void printLed(uint8_t dumpMask, const ledConfig_t *ledConfigs, const ledConfig_t *defaultLedConfigs)
{ {
const char *format = "led %u %s\r\n";
char ledConfigBuffer[20]; char ledConfigBuffer[20];
char ledConfigDefaultBuffer[20]; char ledConfigDefaultBuffer[20];
for (uint32_t i = 0; i < LED_MAX_STRIP_LENGTH; i++) { for (uint32_t i = 0; i < LED_MAX_STRIP_LENGTH; i++) {
const ledConfig_t *ledConfig = ledConfigs[i]; ledConfig_t ledConfig = ledConfigs[i];
const ledConfig_t *ledConfigDefault = defaultLedConfigs[i]; generateLedConfig(&ledConfig, ledConfigBuffer, sizeof(ledConfigBuffer));
const bool equalsDefault = *ledConfig == *ledConfigDefault; bool equalsDefault = true;
generateLedConfig(ledConfig, ledConfigBuffer, sizeof(ledConfigBuffer)); if (defaultLedConfigs) {
generateLedConfig(ledConfigDefault, ledConfigDefaultBuffer, sizeof(ledConfigDefaultBuffer)); ledConfig_t ledConfigDefault = defaultLedConfigs[i];
const char *format = "led %u %s\r\n"; equalsDefault = ledConfig == ledConfigDefault;
cliDefaultPrintf(dumpMask, equalsDefault, format, i, ledConfigDefaultBuffer); generateLedConfig(&ledConfigDefault, ledConfigDefaultBuffer, sizeof(ledConfigDefaultBuffer));
cliDefaultPrintf(dumpMask, equalsDefault, format, i, ledConfigDefaultBuffer);
}
cliDumpPrintf(dumpMask, equalsDefault, format, i, ledConfigBuffer); cliDumpPrintf(dumpMask, equalsDefault, format, i, ledConfigBuffer);
} }
} }
@ -1776,25 +1791,18 @@ static void cliLed(char *cmdline)
static void printColor(uint8_t dumpMask, const hsvColor_t *colors, const hsvColor_t *defaultColors) static void printColor(uint8_t dumpMask, const hsvColor_t *colors, const hsvColor_t *defaultColors)
{ {
const char *format = "color %u %d,%u,%u\r\n";
for (uint32_t i = 0; i < LED_CONFIGURABLE_COLOR_COUNT; i++) { for (uint32_t i = 0; i < LED_CONFIGURABLE_COLOR_COUNT; i++) {
const hsvColor_t *color = &colors[i]; const hsvColor_t *color = &colors[i];
const hsvColor_t *colorDefault = &defaultColors[i]; bool equalsDefault = true;
const bool equalsDefault = color->h == colorDefault->h if (defaultColors) {
&& color->s == colorDefault->s const hsvColor_t *colorDefault = &defaultColors[i];
&& color->v == colorDefault->v; equalsDefault = color->h == colorDefault->h
const char *format = "color %u %d,%u,%u\r\n"; && color->s == colorDefault->s
cliDefaultPrintf(dumpMask, equalsDefault, format, && color->v == colorDefault->v;
i, cliDefaultPrintf(dumpMask, equalsDefault, format, i,colorDefault->h, colorDefault->s, colorDefault->v);
colorDefault->h, }
colorDefault->s, cliDumpPrintf(dumpMask, equalsDefault, format, i, color->h, color->s, color->v);
colorDefault->v
);
cliDumpPrintf(dumpMask, equalsDefault, format,
i,
color->h,
color->s,
color->v
);
} }
} }
@ -1821,28 +1829,39 @@ static void cliColor(char *cmdline)
static void printModeColor(uint8_t dumpMask, const ledStripConfig_t *ledStripConfig, const ledStripConfig_t *defaultLedStripConfig) static void printModeColor(uint8_t dumpMask, const ledStripConfig_t *ledStripConfig, const ledStripConfig_t *defaultLedStripConfig)
{ {
const char *format = "mode_color %u %u %u\r\n";
for (uint32_t i = 0; i < LED_MODE_COUNT; i++) { for (uint32_t i = 0; i < LED_MODE_COUNT; i++) {
for (uint32_t j = 0; j < LED_DIRECTION_COUNT; j++) { for (uint32_t j = 0; j < LED_DIRECTION_COUNT; j++) {
int colorIndex = ledStripConfig->modeColors[i].color[j]; int colorIndex = ledStripConfig->modeColors[i].color[j];
int colorIndexDefault = defaultLedStripConfig->modeColors[i].color[j]; bool equalsDefault = true;
const char *format = "mode_color %u %u %u\r\n"; if (defaultLedStripConfig) {
cliDefaultPrintf(dumpMask, colorIndex == colorIndexDefault, format, i, j, colorIndexDefault); int colorIndexDefault = defaultLedStripConfig->modeColors[i].color[j];
cliDumpPrintf(dumpMask, colorIndex == colorIndexDefault, format, i, j, colorIndex); equalsDefault = colorIndex == colorIndexDefault;
cliDefaultPrintf(dumpMask, equalsDefault, format, i, j, colorIndexDefault);
}
cliDumpPrintf(dumpMask, equalsDefault, format, i, j, colorIndex);
} }
} }
const char *format = "mode_color %u %u %u\r\n";
for (uint32_t j = 0; j < LED_SPECIAL_COLOR_COUNT; j++) { for (uint32_t j = 0; j < LED_SPECIAL_COLOR_COUNT; j++) {
const int colorIndex = ledStripConfig->specialColors.color[j]; const int colorIndex = ledStripConfig->specialColors.color[j];
const int colorIndexDefault = defaultLedStripConfig->specialColors.color[j]; bool equalsDefault = true;
cliDefaultPrintf(dumpMask, colorIndex == colorIndexDefault, format, LED_SPECIAL, j, colorIndexDefault); if (defaultLedStripConfig) {
cliDumpPrintf(dumpMask, colorIndex == colorIndexDefault, format, LED_SPECIAL, j, colorIndex); const int colorIndexDefault = defaultLedStripConfig->specialColors.color[j];
equalsDefault = colorIndex == colorIndexDefault;
cliDefaultPrintf(dumpMask, equalsDefault, format, LED_SPECIAL, j, colorIndexDefault);
}
cliDumpPrintf(dumpMask, equalsDefault, format, LED_SPECIAL, j, colorIndex);
} }
const int ledStripAuxChannel = ledStripConfig->ledstrip_aux_channel; const int ledStripAuxChannel = ledStripConfig->ledstrip_aux_channel;
const int ledStripAuxChannelDefault = defaultLedStripConfig->ledstrip_aux_channel; bool equalsDefault = true;
cliDefaultPrintf(dumpMask, ledStripAuxChannel == ledStripAuxChannelDefault, format, LED_AUX_CHANNEL, 0, ledStripAuxChannelDefault); if (defaultLedStripConfig) {
cliDumpPrintf(dumpMask, ledStripAuxChannel == ledStripAuxChannelDefault, format, LED_AUX_CHANNEL, 0, ledStripAuxChannel); const int ledStripAuxChannelDefault = defaultLedStripConfig->ledstrip_aux_channel;
equalsDefault = ledStripAuxChannel == ledStripAuxChannelDefault;
cliDefaultPrintf(dumpMask, equalsDefault, format, LED_AUX_CHANNEL, 0, ledStripAuxChannelDefault);
}
cliDumpPrintf(dumpMask, equalsDefault, format, LED_AUX_CHANNEL, 0, ledStripAuxChannel);
} }
static void cliModeColor(char *cmdline) static void cliModeColor(char *cmdline)
@ -1881,26 +1900,29 @@ static void cliModeColor(char *cmdline)
static void printServo(uint8_t dumpMask, servoProfile_t *defaultServoProfile) static void printServo(uint8_t dumpMask, servoProfile_t *defaultServoProfile)
{ {
// print out servo settings // print out servo settings
const char *format = "servo %u %d %d %d %d %d %d %d\r\n";
for (uint32_t i = 0; i < MAX_SUPPORTED_SERVOS; i++) { for (uint32_t i = 0; i < MAX_SUPPORTED_SERVOS; i++) {
const servoParam_t *servoConf = &servoProfile()->servoConf[i]; const servoParam_t *servoConf = &servoProfile()->servoConf[i];
const servoParam_t *servoConfDefault = &defaultServoProfile->servoConf[i]; bool equalsDefault = true;
const bool equalsDefault = servoConf->min == servoConfDefault->min if (defaultServoProfile) {
&& servoConf->max == servoConfDefault->max const servoParam_t *servoConfDefault = &defaultServoProfile->servoConf[i];
&& servoConf->middle == servoConfDefault->middle equalsDefault = servoConf->min == servoConfDefault->min
&& servoConf->angleAtMin == servoConfDefault->angleAtMax && servoConf->max == servoConfDefault->max
&& servoConf->rate == servoConfDefault->rate && servoConf->middle == servoConfDefault->middle
&& servoConf->forwardFromChannel == servoConfDefault->forwardFromChannel; && servoConf->angleAtMin == servoConfDefault->angleAtMax
const char *format = "servo %u %d %d %d %d %d %d %d\r\n"; && servoConf->rate == servoConfDefault->rate
cliDefaultPrintf(dumpMask, equalsDefault, format, && servoConf->forwardFromChannel == servoConfDefault->forwardFromChannel;
i, cliDefaultPrintf(dumpMask, equalsDefault, format,
servoConfDefault->min, i,
servoConfDefault->max, servoConfDefault->min,
servoConfDefault->middle, servoConfDefault->max,
servoConfDefault->angleAtMin, servoConfDefault->middle,
servoConfDefault->angleAtMax, servoConfDefault->angleAtMin,
servoConfDefault->rate, servoConfDefault->angleAtMax,
servoConfDefault->forwardFromChannel servoConfDefault->rate,
); servoConfDefault->forwardFromChannel
);
}
cliDumpPrintf(dumpMask, equalsDefault, format, cliDumpPrintf(dumpMask, equalsDefault, format,
i, i,
servoConf->min, servoConf->min,
@ -1994,32 +2016,35 @@ static void cliServo(char *cmdline)
#ifdef USE_SERVOS #ifdef USE_SERVOS
static void printServoMix(uint8_t dumpMask, const master_t *defaultConfig) static void printServoMix(uint8_t dumpMask, const master_t *defaultConfig)
{ {
const char *format = "smix %d %d %d %d %d %d %d %d\r\n";
for (uint32_t i = 0; i < MAX_SERVO_RULES; i++) { for (uint32_t i = 0; i < MAX_SERVO_RULES; i++) {
servoMixer_t customServoMixer = *customServoMixer(i); servoMixer_t customServoMixer = *customServoMixer(i);
servoMixer_t customServoMixerDefault = defaultConfig->customServoMixer[i];
if (customServoMixer.rate == 0) { if (customServoMixer.rate == 0) {
break; break;
} }
const bool equalsDefault = customServoMixer.targetChannel == customServoMixerDefault.targetChannel bool equalsDefault = true;
&& customServoMixer.inputSource == customServoMixerDefault.inputSource if (defaultConfig) {
&& customServoMixer.rate == customServoMixerDefault.rate servoMixer_t customServoMixerDefault = defaultConfig->customServoMixer[i];
&& customServoMixer.speed == customServoMixerDefault.speed equalsDefault = customServoMixer.targetChannel == customServoMixerDefault.targetChannel
&& customServoMixer.min == customServoMixerDefault.min && customServoMixer.inputSource == customServoMixerDefault.inputSource
&& customServoMixer.max == customServoMixerDefault.max && customServoMixer.rate == customServoMixerDefault.rate
&& customServoMixer.box == customServoMixerDefault.box; && customServoMixer.speed == customServoMixerDefault.speed
&& customServoMixer.min == customServoMixerDefault.min
&& customServoMixer.max == customServoMixerDefault.max
&& customServoMixer.box == customServoMixerDefault.box;
const char *format = "smix %d %d %d %d %d %d %d %d\r\n"; cliDefaultPrintf(dumpMask, equalsDefault, format,
cliDefaultPrintf(dumpMask, equalsDefault, format, i,
i, customServoMixerDefault.targetChannel,
customServoMixerDefault.targetChannel, customServoMixerDefault.inputSource,
customServoMixerDefault.inputSource, customServoMixerDefault.rate,
customServoMixerDefault.rate, customServoMixerDefault.speed,
customServoMixerDefault.speed, customServoMixerDefault.min,
customServoMixerDefault.min, customServoMixerDefault.max,
customServoMixerDefault.max, customServoMixerDefault.box
customServoMixerDefault.box );
); }
cliDumpPrintf(dumpMask, equalsDefault, format, cliDumpPrintf(dumpMask, equalsDefault, format,
i, i,
customServoMixer.targetChannel, customServoMixer.targetChannel,
@ -2036,17 +2061,25 @@ static void printServoMix(uint8_t dumpMask, const master_t *defaultConfig)
// print servo directions // print servo directions
for (uint32_t i = 0; i < MAX_SUPPORTED_SERVOS; i++) { for (uint32_t i = 0; i < MAX_SUPPORTED_SERVOS; i++) {
const char *format = "smix reverse %d %d r\r\n";
const servoParam_t *servoConf = &servoProfile()->servoConf[i]; const servoParam_t *servoConf = &servoProfile()->servoConf[i];
const servoParam_t *servoConfDefault = &defaultConfig->servoProfile.servoConf[i]; if (defaultConfig) {
bool equalsDefault = servoConf->reversedSources == servoConfDefault->reversedSources; const servoParam_t *servoConfDefault = &defaultConfig->servoProfile.servoConf[i];
for (uint32_t channel = 0; channel < INPUT_SOURCE_COUNT; channel++) { bool equalsDefault = servoConf->reversedSources == servoConfDefault->reversedSources;
equalsDefault = ~(servoConf->reversedSources ^ servoConfDefault->reversedSources) & (1 << channel); for (uint32_t channel = 0; channel < INPUT_SOURCE_COUNT; channel++) {
const char *format = "smix reverse %d %d r\r\n"; equalsDefault = ~(servoConf->reversedSources ^ servoConfDefault->reversedSources) & (1 << channel);
if (servoConfDefault->reversedSources & (1 << channel)) { if (servoConfDefault->reversedSources & (1 << channel)) {
cliDefaultPrintf(dumpMask, equalsDefault, format, i , channel); cliDefaultPrintf(dumpMask, equalsDefault, format, i , channel);
}
if (servoConf->reversedSources & (1 << channel)) {
cliDumpPrintf(dumpMask, equalsDefault, format, i , channel);
}
} }
if (servoConf->reversedSources & (1 << channel)) { } else {
cliDumpPrintf(dumpMask, equalsDefault, format, i , channel); for (uint32_t channel = 0; channel < INPUT_SOURCE_COUNT; channel++) {
if (servoConf->reversedSources & (1 << channel)) {
cliDumpPrintf(dumpMask, true, format, i , channel);
}
} }
} }
} }
@ -2833,7 +2866,7 @@ static void printConfig(char *cmdline, bool doDiff)
#ifdef LED_STRIP #ifdef LED_STRIP
cliPrintHashLine("led"); cliPrintHashLine("led");
printLed(dumpMask, ledStripConfig()->ledConfigs, &defaultConfig.ledStripConfig.ledConfigs); printLed(dumpMask, ledStripConfig()->ledConfigs, defaultConfig.ledStripConfig.ledConfigs);
cliPrintHashLine("color"); cliPrintHashLine("color");
printColor(dumpMask, ledStripConfig()->colors, defaultConfig.ledStripConfig.colors); printColor(dumpMask, ledStripConfig()->colors, defaultConfig.ledStripConfig.colors);