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

Merge pull request #1903 from martinbudden/bf_pg_cli2

Browse source 
Improvements to CLI diff command. Fixes to CLI print commands.
This commit is contained in:
Anders Höglund 2016-12-29 00:28:55 +01:00 • committed by GitHub
commit 8e9dec4fa1
1 changed files with 255 additions and 223 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -1091,19 +1091,19 @@ static bool isEmpty(const char *string)
return *string == '\0'; return *string == '\0';
} }
static void printRxFail(uint8_t dumpMask, const rxConfig_t *defaultRxConfig) static void printRxFail(uint8_t dumpMask, const rxConfig_t *rxConfig, const rxConfig_t *defaultRxConfig)
{ {
// print out rxConfig failsafe settings // print out rxConfig failsafe settings
const rxFailsafeChannelConfiguration_t *channelFailsafeConfiguration;
const rxFailsafeChannelConfiguration_t *channelFailsafeConfigurationDefault;
bool equalsDefault;
bool requireValue;
for (uint32_t channel = 0; channel < MAX_SUPPORTED_RC_CHANNEL_COUNT; channel++) { for (uint32_t channel = 0; channel < MAX_SUPPORTED_RC_CHANNEL_COUNT; channel++) {
channelFailsafeConfiguration = &rxConfig()->failsafe_channel_configurations[channel]; const rxFailsafeChannelConfiguration_t *channelFailsafeConfiguration = &rxConfig->failsafe_channel_configurations[channel];
channelFailsafeConfigurationDefault = &defaultRxConfig->failsafe_channel_configurations[channel]; const rxFailsafeChannelConfiguration_t *channelFailsafeConfigurationDefault;
equalsDefault = channelFailsafeConfiguration->mode == channelFailsafeConfigurationDefault->mode bool equalsDefault = true;
&& channelFailsafeConfiguration->step == channelFailsafeConfigurationDefault->step; if (defaultRxConfig) {
requireValue = channelFailsafeConfiguration->mode == RX_FAILSAFE_MODE_SET; channelFailsafeConfigurationDefault = &defaultRxConfig->failsafe_channel_configurations[channel];
equalsDefault = channelFailsafeConfiguration->mode == channelFailsafeConfigurationDefault->mode
&& channelFailsafeConfiguration->step == channelFailsafeConfigurationDefault->step;
}
const bool requireValue = channelFailsafeConfiguration->mode == RX_FAILSAFE_MODE_SET;
if (requireValue) { if (requireValue) {
const char *format = "rxfail %u %c %d\r\n"; const char *format = "rxfail %u %c %d\r\n";
cliDefaultPrintf(dumpMask, equalsDefault, format, cliDefaultPrintf(dumpMask, equalsDefault, format,
@ -1214,24 +1214,27 @@ static void cliRxFail(char *cmdline)
} }
} }
static void printAux(uint8_t dumpMask, 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,
@ -1248,7 +1251,7 @@ static void cliAux(char *cmdline)
char *ptr; char *ptr;
if (isEmpty(cmdline)) { if (isEmpty(cmdline)) {
printAux(DUMP_MASTER, NULL); printAux(DUMP_MASTER, modeActivationProfile(), NULL);
} else { } else {
ptr = cmdline; ptr = cmdline;
i = atoi(ptr++); i = atoi(ptr++);
@ -1282,28 +1285,30 @@ static void cliAux(char *cmdline)
} }
} }
static void printSerial(uint8_t dumpMask, const serialConfig_t *serialConfigDefault) static void printSerial(uint8_t dumpMask, const serialConfig_t *serialConfig, const serialConfig_t *serialConfigDefault)
{ {
const serialConfig_t *serialConfig = serialConfig(); 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,
@ -1321,7 +1326,7 @@ static void cliSerial(char *cmdline)
char *ptr; char *ptr;
if (isEmpty(cmdline)) { if (isEmpty(cmdline)) {
printSerial(DUMP_MASTER, NULL); printSerial(DUMP_MASTER, serialConfig(), NULL);
return; return;
} }
@ -1476,28 +1481,31 @@ static void cliSerialPassthrough(char *cmdline)
} }
#endif #endif
static void printAdjustmentRange(uint8_t dumpMask, 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,
@ -1516,7 +1524,7 @@ static void cliAdjustmentRange(char *cmdline)
char *ptr; char *ptr;
if (isEmpty(cmdline)) { if (isEmpty(cmdline)) {
printAdjustmentRange(DUMP_MASTER, NULL); printAdjustmentRange(DUMP_MASTER, adjustmentProfile(), NULL);
} else { } else {
ptr = cmdline; ptr = cmdline;
i = atoi(ptr++); i = atoi(ptr++);
@ -1571,8 +1579,9 @@ static void cliAdjustmentRange(char *cmdline)
} }
#ifndef USE_QUAD_MIXER_ONLY #ifndef USE_QUAD_MIXER_ONLY
static void printMotorMix(uint8_t dumpMask, 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];
@ -1580,23 +1589,25 @@ static void printMotorMix(uint8_t dumpMask, const motorMixer_t *defaultCustomMot
for (uint32_t i = 0; i < MAX_SUPPORTED_MOTORS; i++) { for (uint32_t i = 0; i < MAX_SUPPORTED_MOTORS; i++) {
if (customMotorMixer(i)->throttle == 0.0f) if (customMotorMixer(i)->throttle == 0.0f)
break; break;
float thr = customMotorMixer(i)->throttle; const float thr = customMotorMixer[i].throttle;
float roll = customMotorMixer(i)->roll; const float roll = customMotorMixer[i].roll;
float pitch = customMotorMixer(i)->pitch; const float pitch = customMotorMixer[i].pitch;
float yaw = customMotorMixer(i)->yaw; const float yaw = customMotorMixer[i].yaw;
float thrDefault = defaultCustomMotorMixer[i].throttle; bool equalsDefault = true;
float rollDefault = defaultCustomMotorMixer[i].roll; if (defaultCustomMotorMixer) {
float pitchDefault = defaultCustomMotorMixer[i].pitch; const float thrDefault = defaultCustomMotorMixer[i].throttle;
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),
@ -1617,7 +1628,7 @@ static void cliMotorMix(char *cmdline)
char *ptr; char *ptr;
if (isEmpty(cmdline)) { if (isEmpty(cmdline)) {
printMotorMix(DUMP_MASTER, NULL); printMotorMix(DUMP_MASTER, customMotorMixer(0), NULL);
} else if (strncasecmp(cmdline, "reset", 5) == 0) { } else if (strncasecmp(cmdline, "reset", 5) == 0) {
// erase custom mixer // erase custom mixer
for (uint32_t i = 0; i < MAX_SUPPORTED_MOTORS; i++) for (uint32_t i = 0; i < MAX_SUPPORTED_MOTORS; i++)
@ -1666,7 +1677,7 @@ static void cliMotorMix(char *cmdline)
if (check != 4) { if (check != 4) {
cliShowParseError(); cliShowParseError();
} else { } else {
printMotorMix(DUMP_MASTER, NULL); printMotorMix(DUMP_MASTER, customMotorMixer(0), NULL);
} }
} else { } else {
cliShowArgumentRangeError("index", 0, MAX_SUPPORTED_MOTORS - 1); cliShowArgumentRangeError("index", 0, MAX_SUPPORTED_MOTORS - 1);
@ -1675,22 +1686,22 @@ static void cliMotorMix(char *cmdline)
#endif #endif
} }
static void printRxRange(uint8_t dumpMask, 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,
@ -1705,7 +1716,7 @@ static void cliRxRange(char *cmdline)
char *ptr; char *ptr;
if (isEmpty(cmdline)) { if (isEmpty(cmdline)) {
printRxRange(DUMP_MASTER, NULL); printRxRange(DUMP_MASTER, rxConfig(), NULL);
} else if (strcasecmp(cmdline, "reset") == 0) { } else if (strcasecmp(cmdline, "reset") == 0) {
resetAllRxChannelRangeConfigurations(rxConfig()->channelRanges); resetAllRxChannelRangeConfigurations(rxConfig()->channelRanges);
} else { } else {
@ -1742,20 +1753,21 @@ static void cliRxRange(char *cmdline)
} }
#ifdef LED_STRIP #ifdef LED_STRIP
static void printLed(uint8_t dumpMask, const ledStripConfig_t *defaultLedStripConfig) static void printLed(uint8_t dumpMask, const ledConfig_t *ledConfigs, const ledConfig_t *defaultLedConfigs)
{ {
ledConfig_t ledConfig; const char *format = "led %u %s\r\n";
ledConfig_t ledConfigDefault;
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++) {
ledConfig = ledStripConfig()->ledConfigs[i]; ledConfig_t ledConfig = ledConfigs[i];
ledConfigDefault = defaultLedStripConfig->ledConfigs[i];
const bool equalsDefault = ledConfig == ledConfigDefault;
generateLedConfig(&ledConfig, ledConfigBuffer, sizeof(ledConfigBuffer)); generateLedConfig(&ledConfig, ledConfigBuffer, sizeof(ledConfigBuffer));
generateLedConfig(&ledConfigDefault, ledConfigDefaultBuffer, sizeof(ledConfigDefaultBuffer)); bool equalsDefault = true;
const char *format = "led %u %s\r\n"; if (defaultLedConfigs) {
cliDefaultPrintf(dumpMask, equalsDefault, format, i, ledConfigDefaultBuffer); ledConfig_t ledConfigDefault = defaultLedConfigs[i];
equalsDefault = ledConfig == ledConfigDefault;
generateLedConfig(&ledConfigDefault, ledConfigDefaultBuffer, sizeof(ledConfigDefaultBuffer));
cliDefaultPrintf(dumpMask, equalsDefault, format, i, ledConfigDefaultBuffer);
}
cliDumpPrintf(dumpMask, equalsDefault, format, i, ledConfigBuffer); cliDumpPrintf(dumpMask, equalsDefault, format, i, ledConfigBuffer);
} }
} }
@ -1766,7 +1778,7 @@ static void cliLed(char *cmdline)
char *ptr; char *ptr;
if (isEmpty(cmdline)) { if (isEmpty(cmdline)) {
printLed(DUMP_MASTER, NULL); printLed(DUMP_MASTER, ledStripConfig()->ledConfigs, NULL);
} else { } else {
ptr = cmdline; ptr = cmdline;
i = atoi(ptr); i = atoi(ptr);
@ -1781,27 +1793,20 @@ static void cliLed(char *cmdline)
} }
} }
static void printColor(uint8_t dumpMask, const ledStripConfig_t *defaultLedStripConfig) 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 = &ledStripConfig()->colors[i]; const hsvColor_t *color = &colors[i];
const hsvColor_t *colorDefault = &defaultLedStripConfig->colors[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
);
} }
} }
@ -1811,7 +1816,7 @@ static void cliColor(char *cmdline)
char *ptr; char *ptr;
if (isEmpty(cmdline)) { if (isEmpty(cmdline)) {
printColor(DUMP_MASTER, NULL); printColor(DUMP_MASTER, ledStripConfig()->colors, NULL);
} else { } else {
ptr = cmdline; ptr = cmdline;
i = atoi(ptr); i = atoi(ptr);
@ -1826,36 +1831,47 @@ static void cliColor(char *cmdline)
} }
} }
static void printModeColor(uint8_t dumpMask, 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++) {
int colorIndex = ledStripConfig()->specialColors.color[j]; const int colorIndex = ledStripConfig->specialColors.color[j];
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);
} }
int ledStripAuxChannel = ledStripConfig()->ledstrip_aux_channel; const int ledStripAuxChannel = ledStripConfig->ledstrip_aux_channel;
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)
{ {
if (isEmpty(cmdline)) { if (isEmpty(cmdline)) {
printModeColor(DUMP_MASTER, NULL); printModeColor(DUMP_MASTER, ledStripConfig(), NULL);
} else { } else {
enum {MODE = 0, FUNCTION, COLOR, ARGS_COUNT}; enum {MODE = 0, FUNCTION, COLOR, ARGS_COUNT};
int args[ARGS_COUNT]; int args[ARGS_COUNT];
@ -1888,26 +1904,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,
@ -2001,32 +2020,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,
@ -2043,17 +2065,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);
}
} }
} }
} }
@ -2344,26 +2374,26 @@ static void cliFlashRead(char *cmdline)
static void printVtx(uint8_t dumpMask, const master_t *defaultConfig) static void printVtx(uint8_t dumpMask, const master_t *defaultConfig)
{ {
// print out vtx channel settings // print out vtx channel settings
vtxChannelActivationCondition_t *cac; const char *format = "vtx %u %u %u %u %u %u\r\n";
vtxChannelActivationCondition_t *cacDefault; bool equalsDefault = true;
bool equalsDefault;
for (uint32_t i = 0; i < MAX_CHANNEL_ACTIVATION_CONDITION_COUNT; i++) { for (uint32_t i = 0; i < MAX_CHANNEL_ACTIVATION_CONDITION_COUNT; i++) {
cac = &masterConfig.vtxChannelActivationConditions[i]; const vtxChannelActivationCondition_t *cac = &masterConfig.vtxChannelActivationConditions[i];
cacDefault = &defaultConfig->vtxChannelActivationConditions[i]; if (defaultConfig) {
equalsDefault = cac->auxChannelIndex == cacDefault->auxChannelIndex const vtxChannelActivationCondition_t *cacDefault = &defaultConfig->vtxChannelActivationConditions[i];
&& cac->band == cacDefault->band equalsDefault = cac->auxChannelIndex == cacDefault->auxChannelIndex
&& cac->channel == cacDefault->channel && cac->band == cacDefault->band
&& cac->range.startStep == cacDefault->range.startStep && cac->channel == cacDefault->channel
&& cac->range.endStep == cacDefault->range.endStep; && cac->range.startStep == cacDefault->range.startStep
const char *format = "vtx %u %u %u %u %u %u\r\n"; && cac->range.endStep == cacDefault->range.endStep;
cliDefaultPrintf(dumpMask, equalsDefault, format, cliDefaultPrintf(dumpMask, equalsDefault, format,
i, i,
cacDefault->auxChannelIndex, cacDefault->auxChannelIndex,
cacDefault->band, cacDefault->band,
cacDefault->channel, cacDefault->channel,
MODE_STEP_TO_CHANNEL_VALUE(cacDefault->range.startStep), MODE_STEP_TO_CHANNEL_VALUE(cacDefault->range.startStep),
MODE_STEP_TO_CHANNEL_VALUE(cacDefault->range.endStep) MODE_STEP_TO_CHANNEL_VALUE(cacDefault->range.endStep)
); );
}
cliDumpPrintf(dumpMask, equalsDefault, format, cliDumpPrintf(dumpMask, equalsDefault, format,
i, i,
cac->auxChannelIndex, cac->auxChannelIndex,
@ -2617,16 +2647,18 @@ static void cliBeeper(char *cmdline)
} }
#endif #endif
static void printMap(uint8_t dumpMask, const rxConfig_t *defaultRxConfig) static void printMap(uint8_t dumpMask, const rxConfig_t *rxConfig, const rxConfig_t *defaultRxConfig)
{ {
bool equalsDefault = true; bool equalsDefault = true;
char buf[16]; char buf[16];
char bufDefault[16]; char bufDefault[16];
uint32_t i; uint32_t i;
for (i = 0; i < MAX_MAPPABLE_RX_INPUTS; i++) { for (i = 0; i < MAX_MAPPABLE_RX_INPUTS; i++) {
buf[rxConfig()->rcmap[i]] = rcChannelLetters[i]; buf[rxConfig->rcmap[i]] = rcChannelLetters[i];
bufDefault[defaultRxConfig->rcmap[i]] = rcChannelLetters[i]; if (defaultRxConfig) {
equalsDefault = equalsDefault && (rxConfig()->rcmap[i] == defaultRxConfig->rcmap[i]); bufDefault[defaultRxConfig->rcmap[i]] = rcChannelLetters[i];
equalsDefault = equalsDefault && (rxConfig->rcmap[i] == defaultRxConfig->rcmap[i]);
}
} }
buf[i] = '\0'; buf[i] = '\0';
@ -2811,7 +2843,7 @@ static void printConfig(char *cmdline, bool doDiff)
cliDumpPrintf(dumpMask, masterConfig.customMotorMixer[0].throttle == 0.0f, "\r\nmmix reset\r\n\r\n"); cliDumpPrintf(dumpMask, masterConfig.customMotorMixer[0].throttle == 0.0f, "\r\nmmix reset\r\n\r\n");
printMotorMix(dumpMask, defaultConfig.customMotorMixer); printMotorMix(dumpMask, customMotorMixer(0), defaultConfig.customMotorMixer);
#ifdef USE_SERVOS #ifdef USE_SERVOS
cliPrintHashLine("servo"); cliPrintHashLine("servo");
@ -2833,30 +2865,30 @@ static void printConfig(char *cmdline, bool doDiff)
#endif #endif
cliPrintHashLine("map"); cliPrintHashLine("map");
printMap(dumpMask, &defaultConfig.rxConfig); printMap(dumpMask, rxConfig(), &defaultConfig.rxConfig);
cliPrintHashLine("serial"); cliPrintHashLine("serial");
printSerial(dumpMask, &defaultConfig.serialConfig); printSerial(dumpMask, serialConfig(), &defaultConfig.serialConfig);
#ifdef LED_STRIP #ifdef LED_STRIP
cliPrintHashLine("led"); cliPrintHashLine("led");
printLed(dumpMask, &defaultConfig.ledStripConfig); printLed(dumpMask, ledStripConfig()->ledConfigs, defaultConfig.ledStripConfig.ledConfigs);
cliPrintHashLine("color"); cliPrintHashLine("color");
printColor(dumpMask, &defaultConfig.ledStripConfig); printColor(dumpMask, ledStripConfig()->colors, defaultConfig.ledStripConfig.colors);
cliPrintHashLine("mode_color"); cliPrintHashLine("mode_color");
printModeColor(dumpMask, &defaultConfig.ledStripConfig); printModeColor(dumpMask, ledStripConfig(), &defaultConfig.ledStripConfig);
#endif #endif
cliPrintHashLine("aux"); cliPrintHashLine("aux");
printAux(dumpMask, &defaultConfig.modeActivationProfile); printAux(dumpMask, modeActivationProfile(), &defaultConfig.modeActivationProfile);
cliPrintHashLine("adjrange"); cliPrintHashLine("adjrange");
printAdjustmentRange(dumpMask, &defaultConfig.adjustmentProfile); printAdjustmentRange(dumpMask, adjustmentProfile(), &defaultConfig.adjustmentProfile);
cliPrintHashLine("rxrange"); cliPrintHashLine("rxrange");
printRxRange(dumpMask, &defaultConfig.rxConfig); printRxRange(dumpMask, rxConfig(), &defaultConfig.rxConfig);
#ifdef VTX #ifdef VTX
cliPrintHashLine("vtx"); cliPrintHashLine("vtx");
@ -2864,7 +2896,7 @@ static void printConfig(char *cmdline, bool doDiff)
#endif #endif
cliPrintHashLine("rxfail"); cliPrintHashLine("rxfail");
printRxFail(dumpMask, &defaultConfig.rxConfig); printRxFail(dumpMask, rxConfig(), &defaultConfig.rxConfig);
cliPrintHashLine("master"); cliPrintHashLine("master");
dumpValues(MASTER_VALUE, dumpMask, &defaultConfig); dumpValues(MASTER_VALUE, dumpMask, &defaultConfig);