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

Improve CLI diff output to only include non-empty sections

Browse source 
Eliminates the empty blocks for sections that have no changes from defaults.
This commit is contained in:
Bruce Luckcuck 2019-05-05 15:01:40 -04:00
parent 1cbff2b9aa
commit a1135dbbc4
3 changed files with 186 additions and 125 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -591,6 +591,16 @@ static bool valuePtrEqualsDefault(const clivalue_t *var, const void *ptr, const
return result; return result;
} }
static const char *cliPrintSectionHeading(dumpFlags_t dumpMask, bool outputFlag, const char *headingStr)
{
if (headingStr && (!(dumpMask & DO_DIFF) || outputFlag)) {
cliPrintHashLine(headingStr);
return NULL;
} else {
return headingStr;
}
}
static uint8_t getPidProfileIndexToUse() static uint8_t getPidProfileIndexToUse()
{ {
return pidProfileIndexToUse == CURRENT_PROFILE_INDEX ? getCurrentPidProfileIndex() : pidProfileIndexToUse; return pidProfileIndexToUse == CURRENT_PROFILE_INDEX ? getCurrentPidProfileIndex() : pidProfileIndexToUse;
@ -632,7 +642,7 @@ const void *cliGetDefaultPointer(const clivalue_t *value)
return rec->address + getValueOffset(value); return rec->address + getValueOffset(value);
} }
static void dumpPgValue(const clivalue_t *value, dumpFlags_t dumpMask) static const char *dumpPgValue(const clivalue_t *value, dumpFlags_t dumpMask, const char *headingStr)
{ {
const pgRegistry_t *pg = pgFind(value->pgn); const pgRegistry_t *pg = pgFind(value->pgn);
#ifdef DEBUG #ifdef DEBUG
@ -647,6 +657,7 @@ static void dumpPgValue(const clivalue_t *value, dumpFlags_t dumpMask)
const int valueOffset = getValueOffset(value); const int valueOffset = getValueOffset(value);
const bool equalsDefault = valuePtrEqualsDefault(value, pg->copy + valueOffset, pg->address + valueOffset); const bool equalsDefault = valuePtrEqualsDefault(value, pg->copy + valueOffset, pg->address + valueOffset);
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
if (((dumpMask & DO_DIFF) == 0) || !equalsDefault) { if (((dumpMask & DO_DIFF) == 0) || !equalsDefault) {
if (dumpMask & SHOW_DEFAULTS && !equalsDefault) { if (dumpMask & SHOW_DEFAULTS && !equalsDefault) {
cliPrintf(defaultFormat, value->name); cliPrintf(defaultFormat, value->name);
@ -657,6 +668,7 @@ static void dumpPgValue(const clivalue_t *value, dumpFlags_t dumpMask)
printValuePointer(value, pg->copy + valueOffset, false); printValuePointer(value, pg->copy + valueOffset, false);
cliPrintLinefeed(); cliPrintLinefeed();
} }
return headingStr;
} }
#ifdef USE_PROFILE_NAMES #ifdef USE_PROFILE_NAMES
@ -698,8 +710,10 @@ static void cliPidProfileName(char *cmdline)
printPidProfileName(DUMP_MASTER, &pidProfileName()->profile[profileIndex]); printPidProfileName(DUMP_MASTER, &pidProfileName()->profile[profileIndex]);
} }
#endif #endif
static void dumpAllValues(uint16_t valueSection, dumpFlags_t dumpMask)
static void dumpAllValues(uint16_t valueSection, dumpFlags_t dumpMask, const char *headingStr)
{ {
headingStr = cliPrintSectionHeading(dumpMask, false, headingStr);
#ifdef USE_PROFILE_NAMES #ifdef USE_PROFILE_NAMES
if (valueSection == PROFILE_VALUE) { if (valueSection == PROFILE_VALUE) {
printPidProfileName(DUMP_MASTER, &pidProfileName()->profile[getPidProfileIndexToUse()]); printPidProfileName(DUMP_MASTER, &pidProfileName()->profile[getPidProfileIndexToUse()]);
@ -709,11 +723,12 @@ static void dumpAllValues(uint16_t valueSection, dumpFlags_t dumpMask)
printRateProfileName(DUMP_MASTER, &rateProfileName()->profile[getRateProfileIndexToUse()]); printRateProfileName(DUMP_MASTER, &rateProfileName()->profile[getRateProfileIndexToUse()]);
} }
#endif #endif
for (uint32_t i = 0; i < valueTableEntryCount; i++) { for (uint32_t i = 0; i < valueTableEntryCount; i++) {
const clivalue_t *value = &valueTable[i]; const clivalue_t *value = &valueTable[i];
bufWriterFlush(cliWriter); bufWriterFlush(cliWriter);
if ((value->type & VALUE_SECTION_MASK) == valueSection || ((valueSection == MASTER_VALUE) && (value->type & VALUE_SECTION_MASK) == HARDWARE_VALUE)) { if ((value->type & VALUE_SECTION_MASK) == valueSection || ((valueSection == MASTER_VALUE) && (value->type & VALUE_SECTION_MASK) == HARDWARE_VALUE)) {
dumpPgValue(value, dumpMask); headingStr = dumpPgValue(value, dumpMask, headingStr);
} }
} }
} }
@ -898,14 +913,16 @@ static bool isEmpty(const char *string)
return (string == NULL || *string == '\0') ? true : false; return (string == NULL || *string == '\0') ? true : false;
} }
static void printRxFailsafe(dumpFlags_t dumpMask, const rxFailsafeChannelConfig_t *rxFailsafeChannelConfigs, const rxFailsafeChannelConfig_t *defaultRxFailsafeChannelConfigs) static void printRxFailsafe(dumpFlags_t dumpMask, const rxFailsafeChannelConfig_t *rxFailsafeChannelConfigs, const rxFailsafeChannelConfig_t *defaultRxFailsafeChannelConfigs, const char *headingStr)
{ {
// print out rxConfig failsafe settings // print out rxConfig failsafe settings
headingStr = cliPrintSectionHeading(dumpMask, false, headingStr);
for (uint32_t channel = 0; channel < MAX_SUPPORTED_RC_CHANNEL_COUNT; channel++) { for (uint32_t channel = 0; channel < MAX_SUPPORTED_RC_CHANNEL_COUNT; channel++) {
const rxFailsafeChannelConfig_t *channelFailsafeConfig = &rxFailsafeChannelConfigs[channel]; const rxFailsafeChannelConfig_t *channelFailsafeConfig = &rxFailsafeChannelConfigs[channel];
const rxFailsafeChannelConfig_t *defaultChannelFailsafeConfig = &defaultRxFailsafeChannelConfigs[channel]; const rxFailsafeChannelConfig_t *defaultChannelFailsafeConfig = &defaultRxFailsafeChannelConfigs[channel];
const bool equalsDefault = !memcmp(channelFailsafeConfig, defaultChannelFailsafeConfig, sizeof(*channelFailsafeConfig)); const bool equalsDefault = !memcmp(channelFailsafeConfig, defaultChannelFailsafeConfig, sizeof(*channelFailsafeConfig));
const bool requireValue = channelFailsafeConfig->mode == RX_FAILSAFE_MODE_SET; const bool requireValue = channelFailsafeConfig->mode == RX_FAILSAFE_MODE_SET;
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
if (requireValue) { if (requireValue) {
const char *format = "rxfail %u %c %d"; const char *format = "rxfail %u %c %d";
cliDefaultPrintLinef(dumpMask, equalsDefault, format, cliDefaultPrintLinef(dumpMask, equalsDefault, format,
@ -1014,16 +1031,18 @@ static void cliRxFailsafe(char *cmdline)
} }
} }
static void printAux(dumpFlags_t dumpMask, const modeActivationCondition_t *modeActivationConditions, const modeActivationCondition_t *defaultModeActivationConditions) static void printAux(dumpFlags_t dumpMask, const modeActivationCondition_t *modeActivationConditions, const modeActivationCondition_t *defaultModeActivationConditions, const char *headingStr)
{ {
const char *format = "aux %u %u %u %u %u %u %u"; const char *format = "aux %u %u %u %u %u %u %u";
// print out aux channel settings // print out aux channel settings
headingStr = cliPrintSectionHeading(dumpMask, false, headingStr);
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 = &modeActivationConditions[i]; const modeActivationCondition_t *mac = &modeActivationConditions[i];
bool equalsDefault = false; bool equalsDefault = false;
if (defaultModeActivationConditions) { if (defaultModeActivationConditions) {
const modeActivationCondition_t *macDefault = &defaultModeActivationConditions[i]; const modeActivationCondition_t *macDefault = &defaultModeActivationConditions[i];
equalsDefault = !isModeActivationConditionConfigured(mac, macDefault); equalsDefault = !isModeActivationConditionConfigured(mac, macDefault);
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
const box_t *box = findBoxByBoxId(macDefault->modeId); const box_t *box = findBoxByBoxId(macDefault->modeId);
const box_t *linkedTo = findBoxByBoxId(macDefault->linkedTo); const box_t *linkedTo = findBoxByBoxId(macDefault->linkedTo);
if (box) { if (box) {
@ -1060,7 +1079,7 @@ static void cliAux(char *cmdline)
const char *ptr; const char *ptr;
if (isEmpty(cmdline)) { if (isEmpty(cmdline)) {
printAux(DUMP_MASTER, modeActivationConditions(0), NULL); printAux(DUMP_MASTER, modeActivationConditions(0), NULL, NULL);
} else { } else {
ptr = cmdline; ptr = cmdline;
i = atoi(ptr++); i = atoi(ptr++);
@ -1126,9 +1145,10 @@ static void cliAux(char *cmdline)
} }
} }
static void printSerial(dumpFlags_t dumpMask, const serialConfig_t *serialConfig, const serialConfig_t *serialConfigDefault) static void printSerial(dumpFlags_t dumpMask, const serialConfig_t *serialConfig, const serialConfig_t *serialConfigDefault, const char *headingStr)
{ {
const char *format = "serial %d %d %ld %ld %ld %ld"; const char *format = "serial %d %d %ld %ld %ld %ld";
headingStr = cliPrintSectionHeading(dumpMask, false, headingStr);
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;
@ -1136,6 +1156,7 @@ static void printSerial(dumpFlags_t dumpMask, const serialConfig_t *serialConfig
bool equalsDefault = false; bool equalsDefault = false;
if (serialConfigDefault) { if (serialConfigDefault) {
equalsDefault = !memcmp(&serialConfig->portConfigs[i], &serialConfigDefault->portConfigs[i], sizeof(serialConfig->portConfigs[i])); equalsDefault = !memcmp(&serialConfig->portConfigs[i], &serialConfigDefault->portConfigs[i], sizeof(serialConfig->portConfigs[i]));
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
cliDefaultPrintLinef(dumpMask, equalsDefault, format, cliDefaultPrintLinef(dumpMask, equalsDefault, format,
serialConfigDefault->portConfigs[i].identifier, serialConfigDefault->portConfigs[i].identifier,
serialConfigDefault->portConfigs[i].functionMask, serialConfigDefault->portConfigs[i].functionMask,
@ -1160,7 +1181,7 @@ static void cliSerial(char *cmdline)
{ {
const char *format = "serial %d %d %ld %ld %ld %ld"; const char *format = "serial %d %d %ld %ld %ld %ld";
if (isEmpty(cmdline)) { if (isEmpty(cmdline)) {
printSerial(DUMP_MASTER, serialConfig(), NULL); printSerial(DUMP_MASTER, serialConfig(), NULL, NULL);
return; return;
} }
serialPortConfig_t portConfig; serialPortConfig_t portConfig;
@ -1394,16 +1415,18 @@ static void cliSerialPassthrough(char *cmdline)
} }
#endif #endif
static void printAdjustmentRange(dumpFlags_t dumpMask, const adjustmentRange_t *adjustmentRanges, const adjustmentRange_t *defaultAdjustmentRanges) static void printAdjustmentRange(dumpFlags_t dumpMask, const adjustmentRange_t *adjustmentRanges, const adjustmentRange_t *defaultAdjustmentRanges, const char *headingStr)
{ {
const char *format = "adjrange %u %u %u %u %u %u %u %u %u"; const char *format = "adjrange %u %u %u %u %u %u %u %u %u";
// print out adjustment ranges channel settings // print out adjustment ranges channel settings
headingStr = cliPrintSectionHeading(dumpMask, false, headingStr);
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 = &adjustmentRanges[i]; const adjustmentRange_t *ar = &adjustmentRanges[i];
bool equalsDefault = false; bool equalsDefault = false;
if (defaultAdjustmentRanges) { if (defaultAdjustmentRanges) {
const adjustmentRange_t *arDefault = &defaultAdjustmentRanges[i]; const adjustmentRange_t *arDefault = &defaultAdjustmentRanges[i];
equalsDefault = !memcmp(ar, arDefault, sizeof(*ar)); equalsDefault = !memcmp(ar, arDefault, sizeof(*ar));
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
cliDefaultPrintLinef(dumpMask, equalsDefault, format, cliDefaultPrintLinef(dumpMask, equalsDefault, format,
i, i,
arDefault->adjustmentIndex, arDefault->adjustmentIndex,
@ -1437,7 +1460,7 @@ static void cliAdjustmentRange(char *cmdline)
const char *ptr; const char *ptr;
if (isEmpty(cmdline)) { if (isEmpty(cmdline)) {
printAdjustmentRange(DUMP_MASTER, adjustmentRanges(0), NULL); printAdjustmentRange(DUMP_MASTER, adjustmentRanges(0), NULL, NULL);
} else { } else {
ptr = cmdline; ptr = cmdline;
i = atoi(ptr++); i = atoi(ptr++);
@ -1525,7 +1548,7 @@ static void cliAdjustmentRange(char *cmdline)
} }
#ifndef USE_QUAD_MIXER_ONLY #ifndef USE_QUAD_MIXER_ONLY
static void printMotorMix(dumpFlags_t dumpMask, const motorMixer_t *customMotorMixer, const motorMixer_t *defaultCustomMotorMixer) static void printMotorMix(dumpFlags_t dumpMask, const motorMixer_t *customMotorMixer, const motorMixer_t *defaultCustomMotorMixer, const char *headingStr)
{ {
const char *format = "mmix %d %s %s %s %s"; const char *format = "mmix %d %s %s %s %s";
char buf0[FTOA_BUFFER_LENGTH]; char buf0[FTOA_BUFFER_LENGTH];
@ -1547,6 +1570,7 @@ static void printMotorMix(dumpFlags_t dumpMask, const motorMixer_t *customMotorM
const float yawDefault = defaultCustomMotorMixer[i].yaw; const float yawDefault = defaultCustomMotorMixer[i].yaw;
const bool equalsDefault = thr == thrDefault && roll == rollDefault && pitch == pitchDefault && yaw == yawDefault; const bool equalsDefault = thr == thrDefault && roll == rollDefault && pitch == pitchDefault && yaw == yawDefault;
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
cliDefaultPrintLinef(dumpMask, equalsDefault, format, cliDefaultPrintLinef(dumpMask, equalsDefault, format,
i, i,
ftoa(thrDefault, buf0), ftoa(thrDefault, buf0),
@ -1574,7 +1598,7 @@ static void cliMotorMix(char *cmdline)
const char *ptr; const char *ptr;
if (isEmpty(cmdline)) { if (isEmpty(cmdline)) {
printMotorMix(DUMP_MASTER, customMotorMixer(0), NULL); printMotorMix(DUMP_MASTER, customMotorMixer(0), NULL, 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++) {
@ -1624,7 +1648,7 @@ static void cliMotorMix(char *cmdline)
if (check != 4) { if (check != 4) {
cliShowParseError(); cliShowParseError();
} else { } else {
printMotorMix(DUMP_MASTER, customMotorMixer(0), NULL); printMotorMix(DUMP_MASTER, customMotorMixer(0), NULL, NULL);
} }
} else { } else {
cliShowArgumentRangeError("INDEX", 0, MAX_SUPPORTED_MOTORS - 1); cliShowArgumentRangeError("INDEX", 0, MAX_SUPPORTED_MOTORS - 1);
@ -1633,13 +1657,15 @@ static void cliMotorMix(char *cmdline)
#endif #endif
} }
static void printRxRange(dumpFlags_t dumpMask, const rxChannelRangeConfig_t *channelRangeConfigs, const rxChannelRangeConfig_t *defaultChannelRangeConfigs) static void printRxRange(dumpFlags_t dumpMask, const rxChannelRangeConfig_t *channelRangeConfigs, const rxChannelRangeConfig_t *defaultChannelRangeConfigs, const char *headingStr)
{ {
const char *format = "rxrange %u %u %u"; const char *format = "rxrange %u %u %u";
headingStr = cliPrintSectionHeading(dumpMask, false, headingStr);
for (uint32_t i = 0; i < NON_AUX_CHANNEL_COUNT; i++) { for (uint32_t i = 0; i < NON_AUX_CHANNEL_COUNT; i++) {
bool equalsDefault = false; bool equalsDefault = false;
if (defaultChannelRangeConfigs) { if (defaultChannelRangeConfigs) {
equalsDefault = !memcmp(&channelRangeConfigs[i], &defaultChannelRangeConfigs[i], sizeof(channelRangeConfigs[i])); equalsDefault = !memcmp(&channelRangeConfigs[i], &defaultChannelRangeConfigs[i], sizeof(channelRangeConfigs[i]));
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
cliDefaultPrintLinef(dumpMask, equalsDefault, format, cliDefaultPrintLinef(dumpMask, equalsDefault, format,
i, i,
defaultChannelRangeConfigs[i].min, defaultChannelRangeConfigs[i].min,
@ -1661,7 +1687,7 @@ static void cliRxRange(char *cmdline)
const char *ptr; const char *ptr;
if (isEmpty(cmdline)) { if (isEmpty(cmdline)) {
printRxRange(DUMP_MASTER, rxChannelRangeConfigs(0), NULL); printRxRange(DUMP_MASTER, rxChannelRangeConfigs(0), NULL, NULL);
} else if (strcasecmp(cmdline, "reset") == 0) { } else if (strcasecmp(cmdline, "reset") == 0) {
resetAllRxChannelRangeConfigurations(rxChannelRangeConfigsMutable(0)); resetAllRxChannelRangeConfigurations(rxChannelRangeConfigsMutable(0));
} else { } else {
@ -1704,11 +1730,12 @@ static void cliRxRange(char *cmdline)
} }
#ifdef USE_LED_STRIP_STATUS_MODE #ifdef USE_LED_STRIP_STATUS_MODE
static void printLed(dumpFlags_t dumpMask, const ledConfig_t *ledConfigs, const ledConfig_t *defaultLedConfigs) static void printLed(dumpFlags_t dumpMask, const ledConfig_t *ledConfigs, const ledConfig_t *defaultLedConfigs, const char *headingStr)
{ {
const char *format = "led %u %s"; const char *format = "led %u %s";
char ledConfigBuffer[20]; char ledConfigBuffer[20];
char ledConfigDefaultBuffer[20]; char ledConfigDefaultBuffer[20];
headingStr = cliPrintSectionHeading(dumpMask, false, headingStr);
for (uint32_t i = 0; i < LED_MAX_STRIP_LENGTH; i++) { for (uint32_t i = 0; i < LED_MAX_STRIP_LENGTH; i++) {
ledConfig_t ledConfig = ledConfigs[i]; ledConfig_t ledConfig = ledConfigs[i];
generateLedConfig(&ledConfig, ledConfigBuffer, sizeof(ledConfigBuffer)); generateLedConfig(&ledConfig, ledConfigBuffer, sizeof(ledConfigBuffer));
@ -1716,6 +1743,7 @@ static void printLed(dumpFlags_t dumpMask, const ledConfig_t *ledConfigs, const
if (defaultLedConfigs) { if (defaultLedConfigs) {
ledConfig_t ledConfigDefault = defaultLedConfigs[i]; ledConfig_t ledConfigDefault = defaultLedConfigs[i];
equalsDefault = ledConfig == ledConfigDefault; equalsDefault = ledConfig == ledConfigDefault;
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
generateLedConfig(&ledConfigDefault, ledConfigDefaultBuffer, sizeof(ledConfigDefaultBuffer)); generateLedConfig(&ledConfigDefault, ledConfigDefaultBuffer, sizeof(ledConfigDefaultBuffer));
cliDefaultPrintLinef(dumpMask, equalsDefault, format, i, ledConfigDefaultBuffer); cliDefaultPrintLinef(dumpMask, equalsDefault, format, i, ledConfigDefaultBuffer);
} }
@ -1731,7 +1759,7 @@ static void cliLed(char *cmdline)
const char *ptr; const char *ptr;
if (isEmpty(cmdline)) { if (isEmpty(cmdline)) {
printLed(DUMP_MASTER, ledStripStatusModeConfig()->ledConfigs, NULL); printLed(DUMP_MASTER, ledStripStatusModeConfig()->ledConfigs, NULL, NULL);
} else { } else {
ptr = cmdline; ptr = cmdline;
i = atoi(ptr); i = atoi(ptr);
@ -1749,15 +1777,17 @@ static void cliLed(char *cmdline)
} }
} }
static void printColor(dumpFlags_t dumpMask, const hsvColor_t *colors, const hsvColor_t *defaultColors) static void printColor(dumpFlags_t dumpMask, const hsvColor_t *colors, const hsvColor_t *defaultColors, const char *headingStr)
{ {
const char *format = "color %u %d,%u,%u"; const char *format = "color %u %d,%u,%u";
headingStr = cliPrintSectionHeading(dumpMask, false, headingStr);
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];
bool equalsDefault = false; bool equalsDefault = false;
if (defaultColors) { if (defaultColors) {
const hsvColor_t *colorDefault = &defaultColors[i]; const hsvColor_t *colorDefault = &defaultColors[i];
equalsDefault = !memcmp(color, colorDefault, sizeof(*color)); equalsDefault = !memcmp(color, colorDefault, sizeof(*color));
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
cliDefaultPrintLinef(dumpMask, equalsDefault, format, i,colorDefault->h, colorDefault->s, colorDefault->v); cliDefaultPrintLinef(dumpMask, equalsDefault, format, i,colorDefault->h, colorDefault->s, colorDefault->v);
} }
cliDumpPrintLinef(dumpMask, equalsDefault, format, i, color->h, color->s, color->v); cliDumpPrintLinef(dumpMask, equalsDefault, format, i, color->h, color->s, color->v);
@ -1768,7 +1798,7 @@ static void cliColor(char *cmdline)
{ {
const char *format = "color %u %d,%u,%u"; const char *format = "color %u %d,%u,%u";
if (isEmpty(cmdline)) { if (isEmpty(cmdline)) {
printColor(DUMP_MASTER, ledStripStatusModeConfig()->colors, NULL); printColor(DUMP_MASTER, ledStripStatusModeConfig()->colors, NULL, NULL);
} else { } else {
const char *ptr = cmdline; const char *ptr = cmdline;
const int i = atoi(ptr); const int i = atoi(ptr);
@ -1786,9 +1816,10 @@ static void cliColor(char *cmdline)
} }
} }
static void printModeColor(dumpFlags_t dumpMask, const ledStripStatusModeConfig_t *ledStripStatusModeConfig, const ledStripStatusModeConfig_t *defaultLedStripConfig) static void printModeColor(dumpFlags_t dumpMask, const ledStripStatusModeConfig_t *ledStripStatusModeConfig, const ledStripStatusModeConfig_t *defaultLedStripConfig, const char *headingStr)
{ {
const char *format = "mode_color %u %u %u"; const char *format = "mode_color %u %u %u";
headingStr = cliPrintSectionHeading(dumpMask, false, headingStr);
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 = ledStripStatusModeConfig->modeColors[i].color[j]; int colorIndex = ledStripStatusModeConfig->modeColors[i].color[j];
@ -1796,6 +1827,7 @@ static void printModeColor(dumpFlags_t dumpMask, const ledStripStatusModeConfig_
if (defaultLedStripConfig) { if (defaultLedStripConfig) {
int colorIndexDefault = defaultLedStripConfig->modeColors[i].color[j]; int colorIndexDefault = defaultLedStripConfig->modeColors[i].color[j];
equalsDefault = colorIndex == colorIndexDefault; equalsDefault = colorIndex == colorIndexDefault;
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
cliDefaultPrintLinef(dumpMask, equalsDefault, format, i, j, colorIndexDefault); cliDefaultPrintLinef(dumpMask, equalsDefault, format, i, j, colorIndexDefault);
} }
cliDumpPrintLinef(dumpMask, equalsDefault, format, i, j, colorIndex); cliDumpPrintLinef(dumpMask, equalsDefault, format, i, j, colorIndex);
@ -1808,6 +1840,7 @@ static void printModeColor(dumpFlags_t dumpMask, const ledStripStatusModeConfig_
if (defaultLedStripConfig) { if (defaultLedStripConfig) {
const int colorIndexDefault = defaultLedStripConfig->specialColors.color[j]; const int colorIndexDefault = defaultLedStripConfig->specialColors.color[j];
equalsDefault = colorIndex == colorIndexDefault; equalsDefault = colorIndex == colorIndexDefault;
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
cliDefaultPrintLinef(dumpMask, equalsDefault, format, LED_SPECIAL, j, colorIndexDefault); cliDefaultPrintLinef(dumpMask, equalsDefault, format, LED_SPECIAL, j, colorIndexDefault);
} }
cliDumpPrintLinef(dumpMask, equalsDefault, format, LED_SPECIAL, j, colorIndex); cliDumpPrintLinef(dumpMask, equalsDefault, format, LED_SPECIAL, j, colorIndex);
@ -1818,6 +1851,7 @@ static void printModeColor(dumpFlags_t dumpMask, const ledStripStatusModeConfig_
if (defaultLedStripConfig) { if (defaultLedStripConfig) {
const int ledStripAuxChannelDefault = defaultLedStripConfig->ledstrip_aux_channel; const int ledStripAuxChannelDefault = defaultLedStripConfig->ledstrip_aux_channel;
equalsDefault = ledStripAuxChannel == ledStripAuxChannelDefault; equalsDefault = ledStripAuxChannel == ledStripAuxChannelDefault;
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
cliDefaultPrintLinef(dumpMask, equalsDefault, format, LED_AUX_CHANNEL, 0, ledStripAuxChannelDefault); cliDefaultPrintLinef(dumpMask, equalsDefault, format, LED_AUX_CHANNEL, 0, ledStripAuxChannelDefault);
} }
cliDumpPrintLinef(dumpMask, equalsDefault, format, LED_AUX_CHANNEL, 0, ledStripAuxChannel); cliDumpPrintLinef(dumpMask, equalsDefault, format, LED_AUX_CHANNEL, 0, ledStripAuxChannel);
@ -1826,7 +1860,7 @@ static void printModeColor(dumpFlags_t dumpMask, const ledStripStatusModeConfig_
static void cliModeColor(char *cmdline) static void cliModeColor(char *cmdline)
{ {
if (isEmpty(cmdline)) { if (isEmpty(cmdline)) {
printModeColor(DUMP_MASTER, ledStripStatusModeConfig(), NULL); printModeColor(DUMP_MASTER, ledStripStatusModeConfig(), NULL, 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];
@ -1857,16 +1891,18 @@ static void cliModeColor(char *cmdline)
#endif #endif
#ifdef USE_SERVOS #ifdef USE_SERVOS
static void printServo(dumpFlags_t dumpMask, const servoParam_t *servoParams, const servoParam_t *defaultServoParams) static void printServo(dumpFlags_t dumpMask, const servoParam_t *servoParams, const servoParam_t *defaultServoParams, const char *headingStr)
{ {
// print out servo settings // print out servo settings
const char *format = "servo %u %d %d %d %d %d"; const char *format = "servo %u %d %d %d %d %d";
headingStr = cliPrintSectionHeading(dumpMask, false, headingStr);
for (uint32_t i = 0; i < MAX_SUPPORTED_SERVOS; i++) { for (uint32_t i = 0; i < MAX_SUPPORTED_SERVOS; i++) {
const servoParam_t *servoConf = &servoParams[i]; const servoParam_t *servoConf = &servoParams[i];
bool equalsDefault = false; bool equalsDefault = false;
if (defaultServoParams) { if (defaultServoParams) {
const servoParam_t *defaultServoConf = &defaultServoParams[i]; const servoParam_t *defaultServoConf = &defaultServoParams[i];
equalsDefault = !memcmp(servoConf, defaultServoConf, sizeof(*servoConf)); equalsDefault = !memcmp(servoConf, defaultServoConf, sizeof(*servoConf));
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
cliDefaultPrintLinef(dumpMask, equalsDefault, format, cliDefaultPrintLinef(dumpMask, equalsDefault, format,
i, i,
defaultServoConf->min, defaultServoConf->min,
@ -1923,7 +1959,7 @@ static void cliServo(char *cmdline)
char *ptr; char *ptr;
if (isEmpty(cmdline)) { if (isEmpty(cmdline)) {
printServo(DUMP_MASTER, servoParams(0), NULL); printServo(DUMP_MASTER, servoParams(0), NULL, NULL);
} else { } else {
int validArgumentCount = 0; int validArgumentCount = 0;
@ -1996,9 +2032,10 @@ static void cliServo(char *cmdline)
#endif #endif
#ifdef USE_SERVOS #ifdef USE_SERVOS
static void printServoMix(dumpFlags_t dumpMask, const servoMixer_t *customServoMixers, const servoMixer_t *defaultCustomServoMixers) static void printServoMix(dumpFlags_t dumpMask, const servoMixer_t *customServoMixers, const servoMixer_t *defaultCustomServoMixers, const char *headingStr)
{ {
const char *format = "smix %d %d %d %d %d %d %d %d"; const char *format = "smix %d %d %d %d %d %d %d %d";
headingStr = cliPrintSectionHeading(dumpMask, false, headingStr);
for (uint32_t i = 0; i < MAX_SERVO_RULES; i++) { for (uint32_t i = 0; i < MAX_SERVO_RULES; i++) {
const servoMixer_t customServoMixer = customServoMixers[i]; const servoMixer_t customServoMixer = customServoMixers[i];
if (customServoMixer.rate == 0) { if (customServoMixer.rate == 0) {
@ -2010,6 +2047,7 @@ static void printServoMix(dumpFlags_t dumpMask, const servoMixer_t *customServoM
servoMixer_t customServoMixerDefault = defaultCustomServoMixers[i]; servoMixer_t customServoMixerDefault = defaultCustomServoMixers[i];
equalsDefault = !memcmp(&customServoMixer, &customServoMixerDefault, sizeof(customServoMixer)); equalsDefault = !memcmp(&customServoMixer, &customServoMixerDefault, sizeof(customServoMixer));
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
cliDefaultPrintLinef(dumpMask, equalsDefault, format, cliDefaultPrintLinef(dumpMask, equalsDefault, format,
i, i,
customServoMixerDefault.targetChannel, customServoMixerDefault.targetChannel,
@ -2032,8 +2070,6 @@ static void printServoMix(dumpFlags_t dumpMask, const servoMixer_t *customServoM
customServoMixer.box customServoMixer.box
); );
} }
cliPrintLinefeed();
} }
static void cliServoMix(char *cmdline) static void cliServoMix(char *cmdline)
@ -2042,7 +2078,7 @@ static void cliServoMix(char *cmdline)
int len = strlen(cmdline); int len = strlen(cmdline);
if (len == 0) { if (len == 0) {
printServoMix(DUMP_MASTER, customServoMixers(0), NULL); printServoMix(DUMP_MASTER, customServoMixers(0), NULL, NULL);
} else if (strncasecmp(cmdline, "reset", 5) == 0) { } else if (strncasecmp(cmdline, "reset", 5) == 0) {
// erase custom mixer // erase custom mixer
memset(customServoMixers_array(), 0, sizeof(*customServoMixers_array())); memset(customServoMixers_array(), 0, sizeof(*customServoMixers_array()));
@ -2325,16 +2361,18 @@ static void cliFlashRead(char *cmdline)
#endif #endif
#ifdef USE_VTX_CONTROL #ifdef USE_VTX_CONTROL
static void printVtx(dumpFlags_t dumpMask, const vtxConfig_t *vtxConfig, const vtxConfig_t *vtxConfigDefault) static void printVtx(dumpFlags_t dumpMask, const vtxConfig_t *vtxConfig, const vtxConfig_t *vtxConfigDefault, const char *headingStr)
{ {
// print out vtx channel settings // print out vtx channel settings
const char *format = "vtx %u %u %u %u %u %u %u"; const char *format = "vtx %u %u %u %u %u %u %u";
headingStr = cliPrintSectionHeading(dumpMask, false, headingStr);
bool equalsDefault = false; bool equalsDefault = false;
for (uint32_t i = 0; i < MAX_CHANNEL_ACTIVATION_CONDITION_COUNT; i++) { for (uint32_t i = 0; i < MAX_CHANNEL_ACTIVATION_CONDITION_COUNT; i++) {
const vtxChannelActivationCondition_t *cac = &vtxConfig->vtxChannelActivationConditions[i]; const vtxChannelActivationCondition_t *cac = &vtxConfig->vtxChannelActivationConditions[i];
if (vtxConfigDefault) { if (vtxConfigDefault) {
const vtxChannelActivationCondition_t *cacDefault = &vtxConfigDefault->vtxChannelActivationConditions[i]; const vtxChannelActivationCondition_t *cacDefault = &vtxConfigDefault->vtxChannelActivationConditions[i];
equalsDefault = !memcmp(cac, cacDefault, sizeof(*cac)); equalsDefault = !memcmp(cac, cacDefault, sizeof(*cac));
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
cliDefaultPrintLinef(dumpMask, equalsDefault, format, cliDefaultPrintLinef(dumpMask, equalsDefault, format,
i, i,
cacDefault->auxChannelIndex, cacDefault->auxChannelIndex,
@ -2364,7 +2402,7 @@ static void cliVtx(char *cmdline)
const char *ptr; const char *ptr;
if (isEmpty(cmdline)) { if (isEmpty(cmdline)) {
printVtx(DUMP_MASTER, vtxConfig(), NULL); printVtx(DUMP_MASTER, vtxConfig(), NULL, NULL);
} else { } else {
ptr = cmdline; ptr = cmdline;
i = atoi(ptr++); i = atoi(ptr++);
@ -2444,7 +2482,7 @@ static char *formatVtxTableBandFrequency(const uint16_t *frequency, int channels
return freqbuf; return freqbuf;
} }
static void printVtxTableBand(dumpFlags_t dumpMask, int band, const vtxTableConfig_t *currentConfig, const vtxTableConfig_t *defaultConfig) static const char *printVtxTableBand(dumpFlags_t dumpMask, int band, const vtxTableConfig_t *currentConfig, const vtxTableConfig_t *defaultConfig, const char *headingStr)
{ {
char *fmt = "vtxtable band %d %s %c%s"; char *fmt = "vtxtable band %d %s %c%s";
bool equalsDefault = false; bool equalsDefault = false;
@ -2462,12 +2500,14 @@ static void printVtxTableBand(dumpFlags_t dumpMask, int band, const vtxTableConf
equalsDefault = false; equalsDefault = false;
} }
} }
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
char *freqbuf = formatVtxTableBandFrequency(defaultConfig->frequency[band], defaultConfig->channels); char *freqbuf = formatVtxTableBandFrequency(defaultConfig->frequency[band], defaultConfig->channels);
cliDefaultPrintLinef(dumpMask, equalsDefault, fmt, band + 1, defaultConfig->bandNames[band], defaultConfig->bandLetters[band], freqbuf); cliDefaultPrintLinef(dumpMask, equalsDefault, fmt, band + 1, defaultConfig->bandNames[band], defaultConfig->bandLetters[band], freqbuf);
} }
char *freqbuf = formatVtxTableBandFrequency(currentConfig->frequency[band], currentConfig->channels); char *freqbuf = formatVtxTableBandFrequency(currentConfig->frequency[band], currentConfig->channels);
cliDumpPrintLinef(dumpMask, equalsDefault, fmt, band + 1, currentConfig->bandNames[band], currentConfig->bandLetters[band], freqbuf); cliDumpPrintLinef(dumpMask, equalsDefault, fmt, band + 1, currentConfig->bandNames[band], currentConfig->bandLetters[band], freqbuf);
return headingStr;
} }
static char *formatVtxTablePowerValues(const uint16_t *levels, int count) static char *formatVtxTablePowerValues(const uint16_t *levels, int count)
@ -2483,7 +2523,7 @@ static char *formatVtxTablePowerValues(const uint16_t *levels, int count)
return pwrbuf; return pwrbuf;
} }
static void printVtxTablePowerValues(dumpFlags_t dumpMask, const vtxTableConfig_t *currentConfig, const vtxTableConfig_t *defaultConfig) static const char *printVtxTablePowerValues(dumpFlags_t dumpMask, const vtxTableConfig_t *currentConfig, const vtxTableConfig_t *defaultConfig, const char *headingStr)
{ {
char *fmt = "vtxtable powervalues %s"; char *fmt = "vtxtable powervalues %s";
bool equalsDefault = false; bool equalsDefault = false;
@ -2494,12 +2534,14 @@ static void printVtxTablePowerValues(dumpFlags_t dumpMask, const vtxTableConfig_
equalsDefault = false; equalsDefault = false;
} }
} }
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
char *pwrbuf = formatVtxTablePowerValues(defaultConfig->powerValues, VTX_TABLE_MAX_POWER_LEVELS); char *pwrbuf = formatVtxTablePowerValues(defaultConfig->powerValues, VTX_TABLE_MAX_POWER_LEVELS);
cliDefaultPrintLinef(dumpMask, equalsDefault, fmt, pwrbuf); cliDefaultPrintLinef(dumpMask, equalsDefault, fmt, pwrbuf);
} }
char *pwrbuf = formatVtxTablePowerValues(currentConfig->powerValues, currentConfig->powerLevels); char *pwrbuf = formatVtxTablePowerValues(currentConfig->powerValues, currentConfig->powerLevels);
cliDumpPrintLinef(dumpMask, equalsDefault, fmt, pwrbuf); cliDumpPrintLinef(dumpMask, equalsDefault, fmt, pwrbuf);
return headingStr;
} }
static char *formatVtxTablePowerLabels(const char labels[VTX_TABLE_MAX_POWER_LEVELS][VTX_TABLE_POWER_LABEL_LENGTH + 1], int count) static char *formatVtxTablePowerLabels(const char labels[VTX_TABLE_MAX_POWER_LEVELS][VTX_TABLE_POWER_LABEL_LENGTH + 1], int count)
@ -2520,7 +2562,7 @@ static char *formatVtxTablePowerLabels(const char labels[VTX_TABLE_MAX_POWER_LEV
return pwrbuf; return pwrbuf;
} }
static void printVtxTablePowerLabels(dumpFlags_t dumpMask, const vtxTableConfig_t *currentConfig, const vtxTableConfig_t *defaultConfig) static const char *printVtxTablePowerLabels(dumpFlags_t dumpMask, const vtxTableConfig_t *currentConfig, const vtxTableConfig_t *defaultConfig, const char *headingStr)
{ {
char *fmt = "vtxtable powerlabels%s"; char *fmt = "vtxtable powerlabels%s";
bool equalsDefault = false; bool equalsDefault = false;
@ -2531,24 +2573,29 @@ static void printVtxTablePowerLabels(dumpFlags_t dumpMask, const vtxTableConfig_
equalsDefault = false; equalsDefault = false;
} }
} }
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
char *pwrbuf = formatVtxTablePowerLabels(defaultConfig->powerLabels, VTX_TABLE_MAX_POWER_LEVELS); char *pwrbuf = formatVtxTablePowerLabels(defaultConfig->powerLabels, VTX_TABLE_MAX_POWER_LEVELS);
cliDefaultPrintLinef(dumpMask, equalsDefault, fmt, pwrbuf); cliDefaultPrintLinef(dumpMask, equalsDefault, fmt, pwrbuf);
} }
char *pwrbuf = formatVtxTablePowerLabels(currentConfig->powerLabels, currentConfig->powerLevels); char *pwrbuf = formatVtxTablePowerLabels(currentConfig->powerLabels, currentConfig->powerLevels);
cliDumpPrintLinef(dumpMask, equalsDefault, fmt, pwrbuf); cliDumpPrintLinef(dumpMask, equalsDefault, fmt, pwrbuf);
return headingStr;
} }
static void printVtxTable(dumpFlags_t dumpMask, const vtxTableConfig_t *currentConfig, const vtxTableConfig_t *defaultConfig) static void printVtxTable(dumpFlags_t dumpMask, const vtxTableConfig_t *currentConfig, const vtxTableConfig_t *defaultConfig, const char *headingStr)
{ {
bool equalsDefault; bool equalsDefault;
char *fmt; char *fmt;
headingStr = cliPrintSectionHeading(dumpMask, false, headingStr);
// bands // bands
equalsDefault = false; equalsDefault = false;
fmt = "vtxtable bands %d"; fmt = "vtxtable bands %d";
if (defaultConfig) { if (defaultConfig) {
equalsDefault = (defaultConfig->bands == currentConfig->bands); equalsDefault = (defaultConfig->bands == currentConfig->bands);
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
cliDefaultPrintLinef(dumpMask, equalsDefault, fmt, defaultConfig->bands); cliDefaultPrintLinef(dumpMask, equalsDefault, fmt, defaultConfig->bands);
} }
cliDumpPrintLinef(dumpMask, equalsDefault, fmt, currentConfig->bands); cliDumpPrintLinef(dumpMask, equalsDefault, fmt, currentConfig->bands);
@ -2558,6 +2605,7 @@ static void printVtxTable(dumpFlags_t dumpMask, const vtxTableConfig_t *currentC
fmt = "vtxtable channels %d"; fmt = "vtxtable channels %d";
if (defaultConfig) { if (defaultConfig) {
equalsDefault = (defaultConfig->channels == currentConfig->channels); equalsDefault = (defaultConfig->channels == currentConfig->channels);
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
cliDefaultPrintLinef(dumpMask, equalsDefault, fmt, defaultConfig->channels); cliDefaultPrintLinef(dumpMask, equalsDefault, fmt, defaultConfig->channels);
} }
cliDumpPrintLinef(dumpMask, equalsDefault, fmt, currentConfig->channels); cliDumpPrintLinef(dumpMask, equalsDefault, fmt, currentConfig->channels);
@ -2565,7 +2613,7 @@ static void printVtxTable(dumpFlags_t dumpMask, const vtxTableConfig_t *currentC
// band // band
for (int band = 0; band < currentConfig->bands; band++) { for (int band = 0; band < currentConfig->bands; band++) {
printVtxTableBand(dumpMask, band, currentConfig, defaultConfig); headingStr = printVtxTableBand(dumpMask, band, currentConfig, defaultConfig, headingStr);
} }
// powerlevels // powerlevels
@ -2574,6 +2622,7 @@ static void printVtxTable(dumpFlags_t dumpMask, const vtxTableConfig_t *currentC
fmt = "vtxtable powerlevels %d"; fmt = "vtxtable powerlevels %d";
if (defaultConfig) { if (defaultConfig) {
equalsDefault = (defaultConfig->powerLevels == currentConfig->powerLevels); equalsDefault = (defaultConfig->powerLevels == currentConfig->powerLevels);
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
cliDefaultPrintLinef(dumpMask, equalsDefault, fmt, defaultConfig->powerLevels); cliDefaultPrintLinef(dumpMask, equalsDefault, fmt, defaultConfig->powerLevels);
} }
cliDumpPrintLinef(dumpMask, equalsDefault, fmt, currentConfig->powerLevels); cliDumpPrintLinef(dumpMask, equalsDefault, fmt, currentConfig->powerLevels);
@ -2581,8 +2630,8 @@ static void printVtxTable(dumpFlags_t dumpMask, const vtxTableConfig_t *currentC
// powervalues // powervalues
// powerlabels // powerlabels
printVtxTablePowerValues(dumpMask, currentConfig, defaultConfig); headingStr = printVtxTablePowerValues(dumpMask, currentConfig, defaultConfig, headingStr);
printVtxTablePowerLabels(dumpMask, currentConfig, defaultConfig); headingStr = printVtxTablePowerLabels(dumpMask, currentConfig, defaultConfig, headingStr);
} }
static void cliVtxTable(char *cmdline) static void cliVtxTable(char *cmdline)
@ -2594,7 +2643,7 @@ static void cliVtxTable(char *cmdline)
tok = strtok_r(cmdline, " ", &saveptr); tok = strtok_r(cmdline, " ", &saveptr);
if (!tok) { if (!tok) {
printVtxTable(DUMP_MASTER | HIDE_UNUSED, vtxTableConfigMutable(), NULL); printVtxTable(DUMP_MASTER | HIDE_UNUSED, vtxTableConfigMutable(), NULL, NULL);
return; return;
} }
@ -2793,13 +2842,19 @@ static void cliName(char *cmdline)
if (updated) { if (updated) {
cliPrintLine("###WARNING: This command will be removed. Use 'set name = ' instead.###"); cliPrintLine("###WARNING: This command will be removed. Use 'set name = ' instead.###");
} }
} }
#if defined(USE_BOARD_INFO) #if defined(USE_BOARD_INFO)
#define ERROR_MESSAGE "%s CANNOT BE CHANGED. CURRENT VALUE: '%s'" #define ERROR_MESSAGE "%s CANNOT BE CHANGED. CURRENT VALUE: '%s'"
static void printBoardName(dumpFlags_t dumpMask)
{
if (!(dumpMask & DO_DIFF) || strlen(getBoardName())) {
cliPrintLinef("board_name %s", getBoardName());
}
}
static void cliBoardName(char *cmdline) static void cliBoardName(char *cmdline)
{ {
const unsigned int len = strlen(cmdline); const unsigned int len = strlen(cmdline);
@ -2810,7 +2865,14 @@ static void cliBoardName(char *cmdline)
setBoardName(cmdline); setBoardName(cmdline);
boardInformationUpdated = true; boardInformationUpdated = true;
} }
cliPrintLinef("board_name %s", getBoardName()); printBoardName(DUMP_ALL);
}
}
static void printManufacturerId(dumpFlags_t dumpMask)
{
if (!(dumpMask & DO_DIFF) || strlen(getManufacturerId())) {
cliPrintLinef("manufacturer_id %s", getManufacturerId());
} }
} }
@ -2824,7 +2886,7 @@ static void cliManufacturerId(char *cmdline)
setManufacturerId(cmdline); setManufacturerId(cmdline);
boardInformationUpdated = true; boardInformationUpdated = true;
} }
cliPrintLinef("manufacturer_id %s", getManufacturerId()); printManufacturerId(DUMP_ALL);
} }
} }
@ -2906,15 +2968,18 @@ static uint32_t getFeatureMask(const uint32_t featureMask)
} }
} }
static void printFeature(dumpFlags_t dumpMask, const featureConfig_t *featureConfig, const featureConfig_t *featureConfigDefault) static void printFeature(dumpFlags_t dumpMask, const featureConfig_t *featureConfig, const featureConfig_t *featureConfigDefault, const char *headingStr)
{ {
const uint32_t mask = getFeatureMask(featureConfig->enabledFeatures); const uint32_t mask = getFeatureMask(featureConfig->enabledFeatures);
const uint32_t defaultMask = featureConfigDefault->enabledFeatures; const uint32_t defaultMask = featureConfigDefault->enabledFeatures;
headingStr = cliPrintSectionHeading(dumpMask, false, headingStr);
for (uint32_t i = 0; featureNames[i]; i++) { // disabled features first for (uint32_t i = 0; featureNames[i]; i++) { // disabled features first
if (strcmp(featureNames[i], emptyString) != 0) { //Skip unused if (strcmp(featureNames[i], emptyString) != 0) { //Skip unused
const char *format = "feature -%s"; const char *format = "feature -%s";
const bool equalsDefault = (~defaultMask | mask) & (1 << i);
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
cliDefaultPrintLinef(dumpMask, (defaultMask | ~mask) & (1 << i), format, featureNames[i]); cliDefaultPrintLinef(dumpMask, (defaultMask | ~mask) & (1 << i), format, featureNames[i]);
cliDumpPrintLinef(dumpMask, (~defaultMask | mask) & (1 << i), format, featureNames[i]); cliDumpPrintLinef(dumpMask, equalsDefault, format, featureNames[i]);
} }
} }
for (uint32_t i = 0; featureNames[i]; i++) { // enabled features for (uint32_t i = 0; featureNames[i]; i++) { // enabled features
@ -2924,7 +2989,9 @@ static void printFeature(dumpFlags_t dumpMask, const featureConfig_t *featureCon
cliDefaultPrintLinef(dumpMask, (~defaultMask | mask) & (1 << i), format, featureNames[i]); cliDefaultPrintLinef(dumpMask, (~defaultMask | mask) & (1 << i), format, featureNames[i]);
} }
if (mask & (1 << i)) { if (mask & (1 << i)) {
cliDumpPrintLinef(dumpMask, (defaultMask | ~mask) & (1 << i), format, featureNames[i]); const bool equalsDefault = (defaultMask | ~mask) & (1 << i);
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
cliDumpPrintLinef(dumpMask, equalsDefault, format, featureNames[i]);
} }
} }
} }
@ -3005,8 +3072,9 @@ static void cliFeature(char *cmdline)
} }
#if defined(USE_BEEPER) #if defined(USE_BEEPER)
static void printBeeper(dumpFlags_t dumpMask, const uint32_t offFlags, const uint32_t offFlagsDefault, const char *name, const uint32_t allowedFlags) static void printBeeper(dumpFlags_t dumpMask, const uint32_t offFlags, const uint32_t offFlagsDefault, const char *name, const uint32_t allowedFlags, const char *headingStr)
{ {
headingStr = cliPrintSectionHeading(dumpMask, false, headingStr);
const uint8_t beeperCount = beeperTableEntryCount(); const uint8_t beeperCount = beeperTableEntryCount();
for (int32_t i = 0; i < beeperCount - 1; i++) { for (int32_t i = 0; i < beeperCount - 1; i++) {
if (beeperModeMaskForTableIndex(i) & allowedFlags) { if (beeperModeMaskForTableIndex(i) & allowedFlags) {
@ -3014,7 +3082,9 @@ static void printBeeper(dumpFlags_t dumpMask, const uint32_t offFlags, const uin
const char *formatOn = "%s %s"; const char *formatOn = "%s %s";
const uint32_t beeperModeMask = beeperModeMaskForTableIndex(i); const uint32_t beeperModeMask = beeperModeMaskForTableIndex(i);
cliDefaultPrintLinef(dumpMask, ~(offFlags ^ offFlagsDefault) & beeperModeMask, offFlags & beeperModeMask ? formatOn : formatOff, name, beeperNameForTableIndex(i)); cliDefaultPrintLinef(dumpMask, ~(offFlags ^ offFlagsDefault) & beeperModeMask, offFlags & beeperModeMask ? formatOn : formatOff, name, beeperNameForTableIndex(i));
cliDumpPrintLinef(dumpMask, ~(offFlags ^ offFlagsDefault) & beeperModeMask, offFlags & beeperModeMask ? formatOff : formatOn, name, beeperNameForTableIndex(i)); const bool equalsDefault = ~(offFlags ^ offFlagsDefault) & beeperModeMask;
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
cliDumpPrintLinef(dumpMask, equalsDefault, offFlags & beeperModeMask ? formatOff : formatOn, name, beeperNameForTableIndex(i));
} }
} }
} }
@ -3130,12 +3200,14 @@ void cliRxSpiBind(char *cmdline){
} }
#endif #endif
static void printMap(dumpFlags_t dumpMask, const rxConfig_t *rxConfig, const rxConfig_t *defaultRxConfig) static void printMap(dumpFlags_t dumpMask, const rxConfig_t *rxConfig, const rxConfig_t *defaultRxConfig, const char *headingStr)
{ {
bool equalsDefault = true; bool equalsDefault = true;
char buf[16]; char buf[16];
char bufDefault[16]; char bufDefault[16];
uint32_t i; uint32_t i;
headingStr = cliPrintSectionHeading(dumpMask, false, headingStr);
for (i = 0; i < RX_MAPPABLE_CHANNEL_COUNT; i++) { for (i = 0; i < RX_MAPPABLE_CHANNEL_COUNT; i++) {
buf[rxConfig->rcmap[i]] = rcChannelLetters[i]; buf[rxConfig->rcmap[i]] = rcChannelLetters[i];
if (defaultRxConfig) { if (defaultRxConfig) {
@ -3145,6 +3217,7 @@ static void printMap(dumpFlags_t dumpMask, const rxConfig_t *rxConfig, const rxC
} }
buf[i] = '\0'; buf[i] = '\0';
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
const char *formatMap = "map %s"; const char *formatMap = "map %s";
if (defaultRxConfig) { if (defaultRxConfig) {
bufDefault[i] = '\0'; bufDefault[i] = '\0';
@ -3790,10 +3863,12 @@ static void cliDumpPidProfile(uint8_t pidProfileIndex, dumpFlags_t dumpMask)
pidProfileIndexToUse = pidProfileIndex; pidProfileIndexToUse = pidProfileIndex;
cliPrintHashLine("profile");
cliProfile("");
cliPrintLinefeed(); cliPrintLinefeed();
dumpAllValues(PROFILE_VALUE, dumpMask); cliProfile("");
char profileStr[10];
tfp_sprintf(profileStr, "profile %d", pidProfileIndex);
dumpAllValues(PROFILE_VALUE, dumpMask, profileStr);
pidProfileIndexToUse = CURRENT_PROFILE_INDEX; pidProfileIndexToUse = CURRENT_PROFILE_INDEX;
} }
@ -3807,10 +3882,12 @@ static void cliDumpRateProfile(uint8_t rateProfileIndex, dumpFlags_t dumpMask)
rateProfileIndexToUse = rateProfileIndex; rateProfileIndexToUse = rateProfileIndex;
cliPrintHashLine("rateprofile");
cliRateProfile("");
cliPrintLinefeed(); cliPrintLinefeed();
dumpAllValues(PROFILE_RATE_VALUE, dumpMask); cliRateProfile("");
char rateProfileStr[14];
tfp_sprintf(rateProfileStr, "rateprofile %d", rateProfileIndex);
dumpAllValues(PROFILE_RATE_VALUE, dumpMask, rateProfileStr);
rateProfileIndexToUse = CURRENT_PROFILE_INDEX; rateProfileIndexToUse = CURRENT_PROFILE_INDEX;
} }
@ -4577,8 +4654,9 @@ static ioTag_t *getIoTag(const cliResourceValue_t value, uint8_t index)
return CONST_CAST(ioTag_t *, rec->address + value.stride * index + value.offset); return CONST_CAST(ioTag_t *, rec->address + value.stride * index + value.offset);
} }
static void printResource(dumpFlags_t dumpMask) static void printResource(dumpFlags_t dumpMask, const char *headingStr)
{ {
headingStr = cliPrintSectionHeading(dumpMask, false, headingStr);
for (unsigned int i = 0; i < ARRAYLEN(resourceTable); i++) { for (unsigned int i = 0; i < ARRAYLEN(resourceTable); i++) {
const char* owner = ownerNames[resourceTable[i].owner]; const char* owner = ownerNames[resourceTable[i].owner];
const pgRegistry_t* pg = pgFind(resourceTable[i].pgn); const pgRegistry_t* pg = pgFind(resourceTable[i].pgn);
@ -4602,6 +4680,7 @@ static void printResource(dumpFlags_t dumpMask)
const bool equalsDefault = ioTag == ioTagDefault; const bool equalsDefault = ioTag == ioTagDefault;
const char *format = "resource %s %d %c%02d"; const char *format = "resource %s %d %c%02d";
const char *formatUnassigned = "resource %s %d NONE"; const char *formatUnassigned = "resource %s %d NONE";
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
if (ioTagDefault) { if (ioTagDefault) {
cliDefaultPrintLinef(dumpMask, equalsDefault, format, owner, RESOURCE_INDEX(index), IO_GPIOPortIdxByTag(ioTagDefault) + 'A', IO_GPIOPinIdxByTag(ioTagDefault)); cliDefaultPrintLinef(dumpMask, equalsDefault, format, owner, RESOURCE_INDEX(index), IO_GPIOPortIdxByTag(ioTagDefault) + 'A', IO_GPIOPinIdxByTag(ioTagDefault));
} else if (defaultConfig) { } else if (defaultConfig) {
@ -4778,7 +4857,7 @@ static void printPeripheralDmaoptDetails(dmaoptEntry_t *entry, int index, const
} }
} }
static void printPeripheralDmaopt(dmaoptEntry_t *entry, int index, dumpFlags_t dumpMask) static const char *printPeripheralDmaopt(dmaoptEntry_t *entry, int index, dumpFlags_t dumpMask, const char *headingStr)
{ {
const pgRegistry_t* pg = pgFind(entry->pgn); const pgRegistry_t* pg = pgFind(entry->pgn);
const void *currentConfig; const void *currentConfig;
@ -4802,12 +4881,14 @@ static void printPeripheralDmaopt(dmaoptEntry_t *entry, int index, dumpFlags_t d
} }
bool equalsDefault = currentOpt == defaultOpt; bool equalsDefault = currentOpt == defaultOpt;
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
if (defaultConfig) { if (defaultConfig) {
printPeripheralDmaoptDetails(entry, index, defaultOpt, equalsDefault, dumpMask, cliDefaultPrintLinef); printPeripheralDmaoptDetails(entry, index, defaultOpt, equalsDefault, dumpMask, cliDefaultPrintLinef);
} }
printPeripheralDmaoptDetails(entry, index, currentOpt, equalsDefault, dumpMask, cliDumpPrintLinef); printPeripheralDmaoptDetails(entry, index, currentOpt, equalsDefault, dumpMask, cliDumpPrintLinef);
return headingStr;
} }
#if defined(USE_TIMER_MGMT) #if defined(USE_TIMER_MGMT)
@ -4841,12 +4922,12 @@ static void printTimerDmaoptDetails(const ioTag_t ioTag, const timerHardware_t *
} }
} }
static void printTimerDmaopt(const timerIOConfig_t *currentConfig, const timerIOConfig_t *defaultConfig, unsigned index, dumpFlags_t dumpMask, bool defaultIsUsed[]) static const char *printTimerDmaopt(const timerIOConfig_t *currentConfig, const timerIOConfig_t *defaultConfig, unsigned index, dumpFlags_t dumpMask, bool defaultIsUsed[], const char *headingStr)
{ {
const ioTag_t ioTag = currentConfig[index].ioTag; const ioTag_t ioTag = currentConfig[index].ioTag;
if (!ioTag) { if (!ioTag) {
return; return headingStr;
} }
const timerHardware_t *timer = timerGetByTagAndIndex(ioTag, currentConfig[index].index); const timerHardware_t *timer = timerGetByTagAndIndex(ioTag, currentConfig[index].index);
@ -4865,21 +4946,24 @@ static void printTimerDmaopt(const timerIOConfig_t *currentConfig, const timerIO
} }
const bool equalsDefault = defaultDmaopt == dmaopt; const bool equalsDefault = defaultDmaopt == dmaopt;
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
if (defaultConfig) { if (defaultConfig) {
printTimerDmaoptDetails(ioTag, timer, defaultDmaopt, equalsDefault, dumpMask, cliDefaultPrintLinef); printTimerDmaoptDetails(ioTag, timer, defaultDmaopt, equalsDefault, dumpMask, cliDefaultPrintLinef);
} }
printTimerDmaoptDetails(ioTag, timer, dmaopt, equalsDefault, dumpMask, cliDumpPrintLinef); printTimerDmaoptDetails(ioTag, timer, dmaopt, equalsDefault, dumpMask, cliDumpPrintLinef);
return headingStr;
} }
#endif #endif
static void printDmaopt(dumpFlags_t dumpMask) static void printDmaopt(dumpFlags_t dumpMask, const char *headingStr)
{ {
headingStr = cliPrintSectionHeading(dumpMask, false, headingStr);
for (size_t i = 0; i < ARRAYLEN(dmaoptEntryTable); i++) { for (size_t i = 0; i < ARRAYLEN(dmaoptEntryTable); i++) {
dmaoptEntry_t *entry = &dmaoptEntryTable[i]; dmaoptEntry_t *entry = &dmaoptEntryTable[i];
for (int index = 0; index < entry->maxIndex; index++) { for (int index = 0; index < entry->maxIndex; index++) {
printPeripheralDmaopt(entry, index, dumpMask); headingStr = printPeripheralDmaopt(entry, index, dumpMask, headingStr);
} }
} }
@ -4898,13 +4982,14 @@ static void printDmaopt(dumpFlags_t dumpMask)
bool defaultIsUsed[MAX_TIMER_PINMAP_COUNT] = { false }; bool defaultIsUsed[MAX_TIMER_PINMAP_COUNT] = { false };
for (unsigned i = 0; i < MAX_TIMER_PINMAP_COUNT; i++) { for (unsigned i = 0; i < MAX_TIMER_PINMAP_COUNT; i++) {
printTimerDmaopt(currentConfig, defaultConfig, i, dumpMask, defaultIsUsed); headingStr = printTimerDmaopt(currentConfig, defaultConfig, i, dumpMask, defaultIsUsed, headingStr);
} }
if (defaultConfig) { if (defaultConfig) {
for (unsigned i = 0; i < MAX_TIMER_PINMAP_COUNT; i++) { for (unsigned i = 0; i < MAX_TIMER_PINMAP_COUNT; i++) {
if (!defaultIsUsed[i] && defaultConfig[i].ioTag && defaultConfig[i].dmaopt != DMA_OPT_UNUSED) { if (!defaultIsUsed[i] && defaultConfig[i].ioTag && defaultConfig[i].dmaopt != DMA_OPT_UNUSED) {
const timerHardware_t *timer = timerGetByTagAndIndex(defaultConfig[i].ioTag, defaultConfig[i].index); const timerHardware_t *timer = timerGetByTagAndIndex(defaultConfig[i].ioTag, defaultConfig[i].index);
headingStr = cliPrintSectionHeading(dumpMask, true, headingStr);
printTimerDmaoptDetails(defaultConfig[i].ioTag, timer, defaultConfig[i].dmaopt, false, dumpMask, cliDefaultPrintLinef); printTimerDmaoptDetails(defaultConfig[i].ioTag, timer, defaultConfig[i].dmaopt, false, dumpMask, cliDefaultPrintLinef);
printTimerDmaoptDetails(defaultConfig[i].ioTag, timer, DMA_OPT_UNUSED, false, dumpMask, cliDumpPrintLinef); printTimerDmaoptDetails(defaultConfig[i].ioTag, timer, DMA_OPT_UNUSED, false, dumpMask, cliDumpPrintLinef);
@ -4922,7 +5007,7 @@ static void cliDmaopt(char *cmdline)
// Peripheral name or command option // Peripheral name or command option
pch = strtok_r(cmdline, " ", &saveptr); pch = strtok_r(cmdline, " ", &saveptr);
if (!pch) { if (!pch) {
printDmaopt(DUMP_MASTER | HIDE_UNUSED); printDmaopt(DUMP_MASTER | HIDE_UNUSED, NULL);
return; return;
} else if (strcasecmp(pch, "list") == 0) { } else if (strcasecmp(pch, "list") == 0) {
@ -5083,7 +5168,7 @@ static void cliResource(char *cmdline)
pch = strtok_r(cmdline, " ", &saveptr); pch = strtok_r(cmdline, " ", &saveptr);
if (!pch) { if (!pch) {
printResource(DUMP_MASTER | HIDE_UNUSED); printResource(DUMP_MASTER | HIDE_UNUSED, NULL);
return; return;
} else if (strcasecmp(pch, "show") == 0) { } else if (strcasecmp(pch, "show") == 0) {
@ -5192,12 +5277,13 @@ static void printTimerDetails(const ioTag_t ioTag, const unsigned timerIndex, co
} }
} }
static void printTimer(dumpFlags_t dumpMask) static void printTimer(dumpFlags_t dumpMask, const char *headingStr)
{ {
const pgRegistry_t* pg = pgFind(PG_TIMER_IO_CONFIG); const pgRegistry_t* pg = pgFind(PG_TIMER_IO_CONFIG);
const timerIOConfig_t *currentConfig; const timerIOConfig_t *currentConfig;
const timerIOConfig_t *defaultConfig; const timerIOConfig_t *defaultConfig;
headingStr = cliPrintSectionHeading(dumpMask, false, headingStr);
if (configIsInCopy) { if (configIsInCopy) {
currentConfig = (timerIOConfig_t *)pg->copy; currentConfig = (timerIOConfig_t *)pg->copy;
defaultConfig = (timerIOConfig_t *)pg->address; defaultConfig = (timerIOConfig_t *)pg->address;
@ -5229,7 +5315,7 @@ static void printTimer(dumpFlags_t dumpMask)
} }
const bool equalsDefault = defaultTimerIndex == timerIndex; const bool equalsDefault = defaultTimerIndex == timerIndex;
headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr);
if (defaultConfig && defaultTimerIndex) { if (defaultConfig && defaultTimerIndex) {
printTimerDetails(ioTag, defaultTimerIndex, equalsDefault, dumpMask, cliDefaultPrintLinef); printTimerDetails(ioTag, defaultTimerIndex, equalsDefault, dumpMask, cliDefaultPrintLinef);
} }
@ -5240,6 +5326,7 @@ static void printTimer(dumpFlags_t dumpMask)
if (defaultConfig) { if (defaultConfig) {
for (unsigned i = 0; i < MAX_TIMER_PINMAP_COUNT; i++) { for (unsigned i = 0; i < MAX_TIMER_PINMAP_COUNT; i++) {
if (!defaultIsUsed[i] && defaultConfig[i].ioTag) { if (!defaultIsUsed[i] && defaultConfig[i].ioTag) {
headingStr = cliPrintSectionHeading(DO_DIFF, true, headingStr);
printTimerDetails(defaultConfig[i].ioTag, defaultConfig[i].index, false, dumpMask, cliDefaultPrintLinef); printTimerDetails(defaultConfig[i].ioTag, defaultConfig[i].index, false, dumpMask, cliDefaultPrintLinef);
printTimerDetails(defaultConfig[i].ioTag, 0, false, dumpMask, cliDumpPrintLinef); printTimerDetails(defaultConfig[i].ioTag, 0, false, dumpMask, cliDumpPrintLinef);
@ -5255,7 +5342,7 @@ static void cliTimer(char *cmdline)
int len = strlen(cmdline); int len = strlen(cmdline);
if (len == 0) { if (len == 0) {
printTimer(DUMP_MASTER); printTimer(DUMP_MASTER, NULL);
return; return;
} else if (strncasecmp(cmdline, "list", len) == 0) { } else if (strncasecmp(cmdline, "list", len) == 0) {
@ -5464,8 +5551,8 @@ static void printConfig(char *cmdline, bool doDiff)
#if defined(USE_BOARD_INFO) #if defined(USE_BOARD_INFO)
cliPrintLinefeed(); cliPrintLinefeed();
cliBoardName(""); printBoardName(dumpMask);
cliManufacturerId(""); printManufacturerId(dumpMask);
#endif #endif
if ((dumpMask & DUMP_ALL) && !(dumpMask & BARE)) { if ((dumpMask & DUMP_ALL) && !(dumpMask & BARE)) {
@ -5480,99 +5567,84 @@ static void printConfig(char *cmdline, bool doDiff)
} }
#ifdef USE_RESOURCE_MGMT #ifdef USE_RESOURCE_MGMT
cliPrintHashLine("resources"); printResource(dumpMask, "resources");
printResource(dumpMask);
#if defined(USE_TIMER_MGMT) #if defined(USE_TIMER_MGMT)
cliPrintHashLine("timer"); printTimer(dumpMask, "timer");
printTimer(dumpMask);
#endif #endif
#ifdef USE_DMA_SPEC #ifdef USE_DMA_SPEC
cliPrintHashLine("dma"); printDmaopt(dumpMask, "dma");
printDmaopt(dumpMask);
#endif #endif
#endif #endif
if (!(dumpMask & HARDWARE_ONLY)) { if (!(dumpMask & HARDWARE_ONLY)) {
#ifndef USE_QUAD_MIXER_ONLY #ifndef USE_QUAD_MIXER_ONLY
cliPrintHashLine("mixer"); const char *mixerHeadingStr = "mixer";
const bool equalsDefault = mixerConfig_Copy.mixerMode == mixerConfig()->mixerMode; const bool equalsDefault = mixerConfig_Copy.mixerMode == mixerConfig()->mixerMode;
mixerHeadingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, mixerHeadingStr);
const char *formatMixer = "mixer %s"; const char *formatMixer = "mixer %s";
cliDefaultPrintLinef(dumpMask, equalsDefault, formatMixer, mixerNames[mixerConfig()->mixerMode - 1]); cliDefaultPrintLinef(dumpMask, equalsDefault, formatMixer, mixerNames[mixerConfig()->mixerMode - 1]);
cliDumpPrintLinef(dumpMask, equalsDefault, formatMixer, mixerNames[mixerConfig_Copy.mixerMode - 1]); cliDumpPrintLinef(dumpMask, equalsDefault, formatMixer, mixerNames[mixerConfig_Copy.mixerMode - 1]);
cliDumpPrintLinef(dumpMask, customMotorMixer(0)->throttle == 0.0f, "\r\nmmix reset\r\n"); cliDumpPrintLinef(dumpMask, customMotorMixer(0)->throttle == 0.0f, "\r\nmmix reset\r\n");
printMotorMix(dumpMask, customMotorMixer_CopyArray, customMotorMixer(0)); printMotorMix(dumpMask, customMotorMixer_CopyArray, customMotorMixer(0), mixerHeadingStr);
#ifdef USE_SERVOS #ifdef USE_SERVOS
cliPrintHashLine("servo"); printServo(dumpMask, servoParams_CopyArray, servoParams(0), "servo");
printServo(dumpMask, servoParams_CopyArray, servoParams(0));
cliPrintHashLine("servo mix"); const char *servoMixHeadingStr = "servo mixer";
// print custom servo mixer if exists if (!(dumpMask & DO_DIFF) || customServoMixers(0)->rate != 0) {
cliDumpPrintLinef(dumpMask, customServoMixers(0)->rate == 0, "smix reset\r\n"); cliPrintHashLine(servoMixHeadingStr);
printServoMix(dumpMask, customServoMixers_CopyArray, customServoMixers(0)); cliPrintLine("smix reset\r\n");
servoMixHeadingStr = NULL;
}
printServoMix(dumpMask, customServoMixers_CopyArray, customServoMixers(0), servoMixHeadingStr);
#endif #endif
#endif #endif
cliPrintHashLine("feature"); printFeature(dumpMask, &featureConfig_Copy, featureConfig(), "feature");
printFeature(dumpMask, &featureConfig_Copy, featureConfig());
#if defined(USE_BEEPER) #if defined(USE_BEEPER)
cliPrintHashLine("beeper"); printBeeper(dumpMask, beeperConfig_Copy.beeper_off_flags, beeperConfig()->beeper_off_flags, "beeper", BEEPER_ALLOWED_MODES, "beeper");
printBeeper(dumpMask, beeperConfig_Copy.beeper_off_flags, beeperConfig()->beeper_off_flags, "beeper", BEEPER_ALLOWED_MODES);
#if defined(USE_DSHOT) #if defined(USE_DSHOT)
cliPrintHashLine("beacon"); printBeeper(dumpMask, beeperConfig_Copy.dshotBeaconOffFlags, beeperConfig()->dshotBeaconOffFlags, "beacon", DSHOT_BEACON_ALLOWED_MODES, "beacon");
printBeeper(dumpMask, beeperConfig_Copy.dshotBeaconOffFlags, beeperConfig()->dshotBeaconOffFlags, "beacon", DSHOT_BEACON_ALLOWED_MODES);
#endif #endif
#endif // USE_BEEPER #endif // USE_BEEPER
cliPrintHashLine("map"); printMap(dumpMask, &rxConfig_Copy, rxConfig(), "map");
printMap(dumpMask, &rxConfig_Copy, rxConfig());
cliPrintHashLine("serial"); printSerial(dumpMask, &serialConfig_Copy, serialConfig(), "serial");
printSerial(dumpMask, &serialConfig_Copy, serialConfig());
#ifdef USE_LED_STRIP_STATUS_MODE #ifdef USE_LED_STRIP_STATUS_MODE
cliPrintHashLine("led"); printLed(dumpMask, ledStripStatusModeConfig_Copy.ledConfigs, ledStripStatusModeConfig()->ledConfigs, "led");
printLed(dumpMask, ledStripStatusModeConfig_Copy.ledConfigs, ledStripStatusModeConfig()->ledConfigs);
cliPrintHashLine("color"); printColor(dumpMask, ledStripStatusModeConfig_Copy.colors, ledStripStatusModeConfig()->colors, "color");
printColor(dumpMask, ledStripStatusModeConfig_Copy.colors, ledStripStatusModeConfig()->colors);
cliPrintHashLine("mode_color"); printModeColor(dumpMask, &ledStripStatusModeConfig_Copy, ledStripStatusModeConfig(), "mode_color");
printModeColor(dumpMask, &ledStripStatusModeConfig_Copy, ledStripStatusModeConfig());
#endif #endif
cliPrintHashLine("aux"); printAux(dumpMask, modeActivationConditions_CopyArray, modeActivationConditions(0), "aux");
printAux(dumpMask, modeActivationConditions_CopyArray, modeActivationConditions(0));
cliPrintHashLine("adjrange"); printAdjustmentRange(dumpMask, adjustmentRanges_CopyArray, adjustmentRanges(0), "adjrange");
printAdjustmentRange(dumpMask, adjustmentRanges_CopyArray, adjustmentRanges(0));
cliPrintHashLine("rxrange"); printRxRange(dumpMask, rxChannelRangeConfigs_CopyArray, rxChannelRangeConfigs(0), "rxrange");
printRxRange(dumpMask, rxChannelRangeConfigs_CopyArray, rxChannelRangeConfigs(0));
#ifdef USE_VTX_CONTROL #ifdef USE_VTX_CONTROL
cliPrintHashLine("vtx"); printVtx(dumpMask, &vtxConfig_Copy, vtxConfig(), "vtx");
printVtx(dumpMask, &vtxConfig_Copy, vtxConfig());
#endif #endif
#ifdef USE_VTX_TABLE #ifdef USE_VTX_TABLE
cliPrintHashLine("vtxtable"); printVtxTable(dumpMask, &vtxTableConfig_Copy, vtxTableConfig(), "vtxtable");
printVtxTable(dumpMask, &vtxTableConfig_Copy, vtxTableConfig());
#endif #endif
cliPrintHashLine("rxfail"); printRxFailsafe(dumpMask, rxFailsafeChannelConfigs_CopyArray, rxFailsafeChannelConfigs(0), "rxfail");
printRxFailsafe(dumpMask, rxFailsafeChannelConfigs_CopyArray, rxFailsafeChannelConfigs(0));
} }
cliPrintHashLine("master");
if (dumpMask & HARDWARE_ONLY) { if (dumpMask & HARDWARE_ONLY) {
dumpAllValues(HARDWARE_VALUE, dumpMask); dumpAllValues(HARDWARE_VALUE, dumpMask, "master");
} else { } else {
dumpAllValues(MASTER_VALUE, dumpMask); dumpAllValues(MASTER_VALUE, dumpMask, "master");
if (dumpMask & DUMP_ALL) { if (dumpMask & DUMP_ALL) {
for (uint32_t pidProfileIndex = 0; pidProfileIndex < PID_PROFILE_COUNT; pidProfileIndex++) { for (uint32_t pidProfileIndex = 0; pidProfileIndex < PID_PROFILE_COUNT; pidProfileIndex++) {

3
src/test/Makefile
View file

@ -98,9 +98,10 @@ blackbox_encoding_unittest_SRC := \
cli_unittest_SRC := \ cli_unittest_SRC := \
$(USER_DIR)/cli/cli.c \ $(USER_DIR)/cli/cli.c \
$(USER_DIR)/common/printf.c \
$(USER_DIR)/config/feature.c \ $(USER_DIR)/config/feature.c \
$(USER_DIR)/pg/pg.c \ $(USER_DIR)/pg/pg.c \
$(USER_DIR)/common/typeconversion.c $(USER_DIR)/common/typeconversion.c
cli_unittest_DEFINES := \ cli_unittest_DEFINES := \
USE_OSD= \ USE_OSD= \

14
src/test/unit/cli_unittest.cc
View file

@ -28,6 +28,7 @@ extern "C" {
#include "build/version.h" #include "build/version.h"
#include "cli/cli.h" #include "cli/cli.h"
#include "cli/settings.h" #include "cli/settings.h"
#include "common/printf.h"
#include "config/feature.h" #include "config/feature.h"
#include "drivers/buf_writer.h" #include "drivers/buf_writer.h"
#include "drivers/vtx_common.h" #include "drivers/vtx_common.h"
@ -227,19 +228,6 @@ uint8_t getMotorCount() {
void setPrintfSerialPort(struct serialPort_s) {} void setPrintfSerialPort(struct serialPort_s) {}
void tfp_printf(const char * expectedFormat, ...) {
va_list args;
va_start(args, expectedFormat);
vprintf(expectedFormat, args);
va_end(args);
}
void tfp_format(void *, void (*) (void *, char), const char * expectedFormat, va_list va) {
vprintf(expectedFormat, va);
}
static const box_t boxes[] = { { 0, "DUMMYBOX", 0 } }; static const box_t boxes[] = { { 0, "DUMMYBOX", 0 } };
const box_t *findBoxByPermanentId(uint8_t) { return &boxes[0]; } const box_t *findBoxByPermanentId(uint8_t) { return &boxes[0]; }
const box_t *findBoxByBoxId(boxId_e) { return &boxes[0]; } const box_t *findBoxByBoxId(boxId_e) { return &boxes[0]; }