From a1135dbbc46e8c15c744903da4d6b18f52ca38d2 Mon Sep 17 00:00:00 2001 From: Bruce Luckcuck Date: Sun, 5 May 2019 15:01:40 -0400 Subject: [PATCH] Improve CLI diff output to only include non-empty sections Eliminates the empty blocks for sections that have no changes from defaults. --- src/main/cli/cli.c | 294 +++++++++++++++++++++------------- src/test/Makefile | 3 +- src/test/unit/cli_unittest.cc | 14 +- 3 files changed, 186 insertions(+), 125 deletions(-) diff --git a/src/main/cli/cli.c b/src/main/cli/cli.c index ad365711e1..141905c6b2 100644 --- a/src/main/cli/cli.c +++ b/src/main/cli/cli.c @@ -591,6 +591,16 @@ static bool valuePtrEqualsDefault(const clivalue_t *var, const void *ptr, const 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() { return pidProfileIndexToUse == CURRENT_PROFILE_INDEX ? getCurrentPidProfileIndex() : pidProfileIndexToUse; @@ -632,7 +642,7 @@ const void *cliGetDefaultPointer(const clivalue_t *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); #ifdef DEBUG @@ -647,6 +657,7 @@ static void dumpPgValue(const clivalue_t *value, dumpFlags_t dumpMask) const int valueOffset = getValueOffset(value); const bool equalsDefault = valuePtrEqualsDefault(value, pg->copy + valueOffset, pg->address + valueOffset); + headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr); if (((dumpMask & DO_DIFF) == 0) || !equalsDefault) { if (dumpMask & SHOW_DEFAULTS && !equalsDefault) { cliPrintf(defaultFormat, value->name); @@ -657,6 +668,7 @@ static void dumpPgValue(const clivalue_t *value, dumpFlags_t dumpMask) printValuePointer(value, pg->copy + valueOffset, false); cliPrintLinefeed(); } + return headingStr; } #ifdef USE_PROFILE_NAMES @@ -698,8 +710,10 @@ static void cliPidProfileName(char *cmdline) printPidProfileName(DUMP_MASTER, &pidProfileName()->profile[profileIndex]); } #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 if (valueSection == PROFILE_VALUE) { 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()]); } #endif + for (uint32_t i = 0; i < valueTableEntryCount; i++) { const clivalue_t *value = &valueTable[i]; bufWriterFlush(cliWriter); 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; } -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 + headingStr = cliPrintSectionHeading(dumpMask, false, headingStr); for (uint32_t channel = 0; channel < MAX_SUPPORTED_RC_CHANNEL_COUNT; channel++) { const rxFailsafeChannelConfig_t *channelFailsafeConfig = &rxFailsafeChannelConfigs[channel]; const rxFailsafeChannelConfig_t *defaultChannelFailsafeConfig = &defaultRxFailsafeChannelConfigs[channel]; const bool equalsDefault = !memcmp(channelFailsafeConfig, defaultChannelFailsafeConfig, sizeof(*channelFailsafeConfig)); const bool requireValue = channelFailsafeConfig->mode == RX_FAILSAFE_MODE_SET; + headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr); if (requireValue) { const char *format = "rxfail %u %c %d"; 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"; // print out aux channel settings + headingStr = cliPrintSectionHeading(dumpMask, false, headingStr); for (uint32_t i = 0; i < MAX_MODE_ACTIVATION_CONDITION_COUNT; i++) { const modeActivationCondition_t *mac = &modeActivationConditions[i]; bool equalsDefault = false; if (defaultModeActivationConditions) { const modeActivationCondition_t *macDefault = &defaultModeActivationConditions[i]; equalsDefault = !isModeActivationConditionConfigured(mac, macDefault); + headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr); const box_t *box = findBoxByBoxId(macDefault->modeId); const box_t *linkedTo = findBoxByBoxId(macDefault->linkedTo); if (box) { @@ -1060,7 +1079,7 @@ static void cliAux(char *cmdline) const char *ptr; if (isEmpty(cmdline)) { - printAux(DUMP_MASTER, modeActivationConditions(0), NULL); + printAux(DUMP_MASTER, modeActivationConditions(0), NULL, NULL); } else { ptr = cmdline; 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"; + headingStr = cliPrintSectionHeading(dumpMask, false, headingStr); for (uint32_t i = 0; i < SERIAL_PORT_COUNT; i++) { if (!serialIsPortAvailable(serialConfig->portConfigs[i].identifier)) { continue; @@ -1136,6 +1156,7 @@ static void printSerial(dumpFlags_t dumpMask, const serialConfig_t *serialConfig bool equalsDefault = false; if (serialConfigDefault) { equalsDefault = !memcmp(&serialConfig->portConfigs[i], &serialConfigDefault->portConfigs[i], sizeof(serialConfig->portConfigs[i])); + headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr); cliDefaultPrintLinef(dumpMask, equalsDefault, format, serialConfigDefault->portConfigs[i].identifier, serialConfigDefault->portConfigs[i].functionMask, @@ -1160,7 +1181,7 @@ static void cliSerial(char *cmdline) { const char *format = "serial %d %d %ld %ld %ld %ld"; if (isEmpty(cmdline)) { - printSerial(DUMP_MASTER, serialConfig(), NULL); + printSerial(DUMP_MASTER, serialConfig(), NULL, NULL); return; } serialPortConfig_t portConfig; @@ -1394,16 +1415,18 @@ static void cliSerialPassthrough(char *cmdline) } #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"; // print out adjustment ranges channel settings + headingStr = cliPrintSectionHeading(dumpMask, false, headingStr); for (uint32_t i = 0; i < MAX_ADJUSTMENT_RANGE_COUNT; i++) { const adjustmentRange_t *ar = &adjustmentRanges[i]; bool equalsDefault = false; if (defaultAdjustmentRanges) { const adjustmentRange_t *arDefault = &defaultAdjustmentRanges[i]; equalsDefault = !memcmp(ar, arDefault, sizeof(*ar)); + headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr); cliDefaultPrintLinef(dumpMask, equalsDefault, format, i, arDefault->adjustmentIndex, @@ -1437,7 +1460,7 @@ static void cliAdjustmentRange(char *cmdline) const char *ptr; if (isEmpty(cmdline)) { - printAdjustmentRange(DUMP_MASTER, adjustmentRanges(0), NULL); + printAdjustmentRange(DUMP_MASTER, adjustmentRanges(0), NULL, NULL); } else { ptr = cmdline; i = atoi(ptr++); @@ -1525,7 +1548,7 @@ static void cliAdjustmentRange(char *cmdline) } #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"; 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 bool equalsDefault = thr == thrDefault && roll == rollDefault && pitch == pitchDefault && yaw == yawDefault; + headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr); cliDefaultPrintLinef(dumpMask, equalsDefault, format, i, ftoa(thrDefault, buf0), @@ -1574,7 +1598,7 @@ static void cliMotorMix(char *cmdline) const char *ptr; if (isEmpty(cmdline)) { - printMotorMix(DUMP_MASTER, customMotorMixer(0), NULL); + printMotorMix(DUMP_MASTER, customMotorMixer(0), NULL, NULL); } else if (strncasecmp(cmdline, "reset", 5) == 0) { // erase custom mixer for (uint32_t i = 0; i < MAX_SUPPORTED_MOTORS; i++) { @@ -1624,7 +1648,7 @@ static void cliMotorMix(char *cmdline) if (check != 4) { cliShowParseError(); } else { - printMotorMix(DUMP_MASTER, customMotorMixer(0), NULL); + printMotorMix(DUMP_MASTER, customMotorMixer(0), NULL, NULL); } } else { cliShowArgumentRangeError("INDEX", 0, MAX_SUPPORTED_MOTORS - 1); @@ -1633,13 +1657,15 @@ static void cliMotorMix(char *cmdline) #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"; + headingStr = cliPrintSectionHeading(dumpMask, false, headingStr); for (uint32_t i = 0; i < NON_AUX_CHANNEL_COUNT; i++) { bool equalsDefault = false; if (defaultChannelRangeConfigs) { equalsDefault = !memcmp(&channelRangeConfigs[i], &defaultChannelRangeConfigs[i], sizeof(channelRangeConfigs[i])); + headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr); cliDefaultPrintLinef(dumpMask, equalsDefault, format, i, defaultChannelRangeConfigs[i].min, @@ -1661,7 +1687,7 @@ static void cliRxRange(char *cmdline) const char *ptr; if (isEmpty(cmdline)) { - printRxRange(DUMP_MASTER, rxChannelRangeConfigs(0), NULL); + printRxRange(DUMP_MASTER, rxChannelRangeConfigs(0), NULL, NULL); } else if (strcasecmp(cmdline, "reset") == 0) { resetAllRxChannelRangeConfigurations(rxChannelRangeConfigsMutable(0)); } else { @@ -1704,11 +1730,12 @@ static void cliRxRange(char *cmdline) } #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"; char ledConfigBuffer[20]; char ledConfigDefaultBuffer[20]; + headingStr = cliPrintSectionHeading(dumpMask, false, headingStr); for (uint32_t i = 0; i < LED_MAX_STRIP_LENGTH; i++) { ledConfig_t ledConfig = ledConfigs[i]; generateLedConfig(&ledConfig, ledConfigBuffer, sizeof(ledConfigBuffer)); @@ -1716,6 +1743,7 @@ static void printLed(dumpFlags_t dumpMask, const ledConfig_t *ledConfigs, const if (defaultLedConfigs) { ledConfig_t ledConfigDefault = defaultLedConfigs[i]; equalsDefault = ledConfig == ledConfigDefault; + headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr); generateLedConfig(&ledConfigDefault, ledConfigDefaultBuffer, sizeof(ledConfigDefaultBuffer)); cliDefaultPrintLinef(dumpMask, equalsDefault, format, i, ledConfigDefaultBuffer); } @@ -1731,7 +1759,7 @@ static void cliLed(char *cmdline) const char *ptr; if (isEmpty(cmdline)) { - printLed(DUMP_MASTER, ledStripStatusModeConfig()->ledConfigs, NULL); + printLed(DUMP_MASTER, ledStripStatusModeConfig()->ledConfigs, NULL, NULL); } else { ptr = cmdline; 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"; + headingStr = cliPrintSectionHeading(dumpMask, false, headingStr); for (uint32_t i = 0; i < LED_CONFIGURABLE_COLOR_COUNT; i++) { const hsvColor_t *color = &colors[i]; bool equalsDefault = false; if (defaultColors) { const hsvColor_t *colorDefault = &defaultColors[i]; equalsDefault = !memcmp(color, colorDefault, sizeof(*color)); + headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr); cliDefaultPrintLinef(dumpMask, equalsDefault, format, i,colorDefault->h, colorDefault->s, colorDefault->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"; if (isEmpty(cmdline)) { - printColor(DUMP_MASTER, ledStripStatusModeConfig()->colors, NULL); + printColor(DUMP_MASTER, ledStripStatusModeConfig()->colors, NULL, NULL); } else { const char *ptr = cmdline; 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"; + headingStr = cliPrintSectionHeading(dumpMask, false, headingStr); for (uint32_t i = 0; i < LED_MODE_COUNT; i++) { for (uint32_t j = 0; j < LED_DIRECTION_COUNT; j++) { int colorIndex = ledStripStatusModeConfig->modeColors[i].color[j]; @@ -1796,6 +1827,7 @@ static void printModeColor(dumpFlags_t dumpMask, const ledStripStatusModeConfig_ if (defaultLedStripConfig) { int colorIndexDefault = defaultLedStripConfig->modeColors[i].color[j]; equalsDefault = colorIndex == colorIndexDefault; + headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr); cliDefaultPrintLinef(dumpMask, equalsDefault, format, i, j, colorIndexDefault); } cliDumpPrintLinef(dumpMask, equalsDefault, format, i, j, colorIndex); @@ -1808,6 +1840,7 @@ static void printModeColor(dumpFlags_t dumpMask, const ledStripStatusModeConfig_ if (defaultLedStripConfig) { const int colorIndexDefault = defaultLedStripConfig->specialColors.color[j]; equalsDefault = colorIndex == colorIndexDefault; + headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr); cliDefaultPrintLinef(dumpMask, equalsDefault, format, LED_SPECIAL, j, colorIndexDefault); } cliDumpPrintLinef(dumpMask, equalsDefault, format, LED_SPECIAL, j, colorIndex); @@ -1818,6 +1851,7 @@ static void printModeColor(dumpFlags_t dumpMask, const ledStripStatusModeConfig_ if (defaultLedStripConfig) { const int ledStripAuxChannelDefault = defaultLedStripConfig->ledstrip_aux_channel; equalsDefault = ledStripAuxChannel == ledStripAuxChannelDefault; + headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr); cliDefaultPrintLinef(dumpMask, equalsDefault, format, LED_AUX_CHANNEL, 0, ledStripAuxChannelDefault); } 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) { if (isEmpty(cmdline)) { - printModeColor(DUMP_MASTER, ledStripStatusModeConfig(), NULL); + printModeColor(DUMP_MASTER, ledStripStatusModeConfig(), NULL, NULL); } else { enum {MODE = 0, FUNCTION, COLOR, ARGS_COUNT}; int args[ARGS_COUNT]; @@ -1857,16 +1891,18 @@ static void cliModeColor(char *cmdline) #endif #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 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++) { const servoParam_t *servoConf = &servoParams[i]; bool equalsDefault = false; if (defaultServoParams) { const servoParam_t *defaultServoConf = &defaultServoParams[i]; equalsDefault = !memcmp(servoConf, defaultServoConf, sizeof(*servoConf)); + headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr); cliDefaultPrintLinef(dumpMask, equalsDefault, format, i, defaultServoConf->min, @@ -1923,7 +1959,7 @@ static void cliServo(char *cmdline) char *ptr; if (isEmpty(cmdline)) { - printServo(DUMP_MASTER, servoParams(0), NULL); + printServo(DUMP_MASTER, servoParams(0), NULL, NULL); } else { int validArgumentCount = 0; @@ -1996,9 +2032,10 @@ static void cliServo(char *cmdline) #endif #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"; + headingStr = cliPrintSectionHeading(dumpMask, false, headingStr); for (uint32_t i = 0; i < MAX_SERVO_RULES; i++) { const servoMixer_t customServoMixer = customServoMixers[i]; if (customServoMixer.rate == 0) { @@ -2010,6 +2047,7 @@ static void printServoMix(dumpFlags_t dumpMask, const servoMixer_t *customServoM servoMixer_t customServoMixerDefault = defaultCustomServoMixers[i]; equalsDefault = !memcmp(&customServoMixer, &customServoMixerDefault, sizeof(customServoMixer)); + headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr); cliDefaultPrintLinef(dumpMask, equalsDefault, format, i, customServoMixerDefault.targetChannel, @@ -2032,8 +2070,6 @@ static void printServoMix(dumpFlags_t dumpMask, const servoMixer_t *customServoM customServoMixer.box ); } - - cliPrintLinefeed(); } static void cliServoMix(char *cmdline) @@ -2042,7 +2078,7 @@ static void cliServoMix(char *cmdline) int len = strlen(cmdline); if (len == 0) { - printServoMix(DUMP_MASTER, customServoMixers(0), NULL); + printServoMix(DUMP_MASTER, customServoMixers(0), NULL, NULL); } else if (strncasecmp(cmdline, "reset", 5) == 0) { // erase custom mixer memset(customServoMixers_array(), 0, sizeof(*customServoMixers_array())); @@ -2325,16 +2361,18 @@ static void cliFlashRead(char *cmdline) #endif #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 const char *format = "vtx %u %u %u %u %u %u %u"; + headingStr = cliPrintSectionHeading(dumpMask, false, headingStr); bool equalsDefault = false; for (uint32_t i = 0; i < MAX_CHANNEL_ACTIVATION_CONDITION_COUNT; i++) { const vtxChannelActivationCondition_t *cac = &vtxConfig->vtxChannelActivationConditions[i]; if (vtxConfigDefault) { const vtxChannelActivationCondition_t *cacDefault = &vtxConfigDefault->vtxChannelActivationConditions[i]; equalsDefault = !memcmp(cac, cacDefault, sizeof(*cac)); + headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr); cliDefaultPrintLinef(dumpMask, equalsDefault, format, i, cacDefault->auxChannelIndex, @@ -2364,7 +2402,7 @@ static void cliVtx(char *cmdline) const char *ptr; if (isEmpty(cmdline)) { - printVtx(DUMP_MASTER, vtxConfig(), NULL); + printVtx(DUMP_MASTER, vtxConfig(), NULL, NULL); } else { ptr = cmdline; i = atoi(ptr++); @@ -2444,7 +2482,7 @@ static char *formatVtxTableBandFrequency(const uint16_t *frequency, int channels 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"; bool equalsDefault = false; @@ -2462,12 +2500,14 @@ static void printVtxTableBand(dumpFlags_t dumpMask, int band, const vtxTableConf equalsDefault = false; } } + headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr); char *freqbuf = formatVtxTableBandFrequency(defaultConfig->frequency[band], defaultConfig->channels); cliDefaultPrintLinef(dumpMask, equalsDefault, fmt, band + 1, defaultConfig->bandNames[band], defaultConfig->bandLetters[band], freqbuf); } char *freqbuf = formatVtxTableBandFrequency(currentConfig->frequency[band], currentConfig->channels); cliDumpPrintLinef(dumpMask, equalsDefault, fmt, band + 1, currentConfig->bandNames[band], currentConfig->bandLetters[band], freqbuf); + return headingStr; } static char *formatVtxTablePowerValues(const uint16_t *levels, int count) @@ -2483,7 +2523,7 @@ static char *formatVtxTablePowerValues(const uint16_t *levels, int count) 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"; bool equalsDefault = false; @@ -2494,12 +2534,14 @@ static void printVtxTablePowerValues(dumpFlags_t dumpMask, const vtxTableConfig_ equalsDefault = false; } } + headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr); char *pwrbuf = formatVtxTablePowerValues(defaultConfig->powerValues, VTX_TABLE_MAX_POWER_LEVELS); cliDefaultPrintLinef(dumpMask, equalsDefault, fmt, pwrbuf); } char *pwrbuf = formatVtxTablePowerValues(currentConfig->powerValues, currentConfig->powerLevels); 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) @@ -2520,7 +2562,7 @@ static char *formatVtxTablePowerLabels(const char labels[VTX_TABLE_MAX_POWER_LEV 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"; bool equalsDefault = false; @@ -2531,24 +2573,29 @@ static void printVtxTablePowerLabels(dumpFlags_t dumpMask, const vtxTableConfig_ equalsDefault = false; } } + headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr); char *pwrbuf = formatVtxTablePowerLabels(defaultConfig->powerLabels, VTX_TABLE_MAX_POWER_LEVELS); cliDefaultPrintLinef(dumpMask, equalsDefault, fmt, pwrbuf); } char *pwrbuf = formatVtxTablePowerLabels(currentConfig->powerLabels, currentConfig->powerLevels); 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; char *fmt; + headingStr = cliPrintSectionHeading(dumpMask, false, headingStr); + // bands equalsDefault = false; fmt = "vtxtable bands %d"; if (defaultConfig) { equalsDefault = (defaultConfig->bands == currentConfig->bands); + headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr); cliDefaultPrintLinef(dumpMask, equalsDefault, fmt, defaultConfig->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"; if (defaultConfig) { equalsDefault = (defaultConfig->channels == currentConfig->channels); + headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr); cliDefaultPrintLinef(dumpMask, equalsDefault, fmt, defaultConfig->channels); } cliDumpPrintLinef(dumpMask, equalsDefault, fmt, currentConfig->channels); @@ -2565,7 +2613,7 @@ static void printVtxTable(dumpFlags_t dumpMask, const vtxTableConfig_t *currentC // band for (int band = 0; band < currentConfig->bands; band++) { - printVtxTableBand(dumpMask, band, currentConfig, defaultConfig); + headingStr = printVtxTableBand(dumpMask, band, currentConfig, defaultConfig, headingStr); } // powerlevels @@ -2574,6 +2622,7 @@ static void printVtxTable(dumpFlags_t dumpMask, const vtxTableConfig_t *currentC fmt = "vtxtable powerlevels %d"; if (defaultConfig) { equalsDefault = (defaultConfig->powerLevels == currentConfig->powerLevels); + headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr); cliDefaultPrintLinef(dumpMask, equalsDefault, fmt, defaultConfig->powerLevels); } cliDumpPrintLinef(dumpMask, equalsDefault, fmt, currentConfig->powerLevels); @@ -2581,8 +2630,8 @@ static void printVtxTable(dumpFlags_t dumpMask, const vtxTableConfig_t *currentC // powervalues // powerlabels - printVtxTablePowerValues(dumpMask, currentConfig, defaultConfig); - printVtxTablePowerLabels(dumpMask, currentConfig, defaultConfig); + headingStr = printVtxTablePowerValues(dumpMask, currentConfig, defaultConfig, headingStr); + headingStr = printVtxTablePowerLabels(dumpMask, currentConfig, defaultConfig, headingStr); } static void cliVtxTable(char *cmdline) @@ -2594,7 +2643,7 @@ static void cliVtxTable(char *cmdline) tok = strtok_r(cmdline, " ", &saveptr); if (!tok) { - printVtxTable(DUMP_MASTER | HIDE_UNUSED, vtxTableConfigMutable(), NULL); + printVtxTable(DUMP_MASTER | HIDE_UNUSED, vtxTableConfigMutable(), NULL, NULL); return; } @@ -2793,13 +2842,19 @@ static void cliName(char *cmdline) if (updated) { cliPrintLine("###WARNING: This command will be removed. Use 'set name = ' instead.###"); } - } #if defined(USE_BOARD_INFO) #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) { const unsigned int len = strlen(cmdline); @@ -2810,7 +2865,14 @@ static void cliBoardName(char *cmdline) setBoardName(cmdline); 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); 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 defaultMask = featureConfigDefault->enabledFeatures; + headingStr = cliPrintSectionHeading(dumpMask, false, headingStr); for (uint32_t i = 0; featureNames[i]; i++) { // disabled features first if (strcmp(featureNames[i], emptyString) != 0) { //Skip unused 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]); - 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 @@ -2924,7 +2989,9 @@ static void printFeature(dumpFlags_t dumpMask, const featureConfig_t *featureCon cliDefaultPrintLinef(dumpMask, (~defaultMask | mask) & (1 << i), format, featureNames[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) -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(); for (int32_t i = 0; i < beeperCount - 1; i++) { 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 uint32_t beeperModeMask = beeperModeMaskForTableIndex(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 -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; char buf[16]; char bufDefault[16]; uint32_t i; + + headingStr = cliPrintSectionHeading(dumpMask, false, headingStr); for (i = 0; i < RX_MAPPABLE_CHANNEL_COUNT; i++) { buf[rxConfig->rcmap[i]] = rcChannelLetters[i]; if (defaultRxConfig) { @@ -3145,6 +3217,7 @@ static void printMap(dumpFlags_t dumpMask, const rxConfig_t *rxConfig, const rxC } buf[i] = '\0'; + headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr); const char *formatMap = "map %s"; if (defaultRxConfig) { bufDefault[i] = '\0'; @@ -3790,10 +3863,12 @@ static void cliDumpPidProfile(uint8_t pidProfileIndex, dumpFlags_t dumpMask) pidProfileIndexToUse = pidProfileIndex; - cliPrintHashLine("profile"); - cliProfile(""); cliPrintLinefeed(); - dumpAllValues(PROFILE_VALUE, dumpMask); + cliProfile(""); + + char profileStr[10]; + tfp_sprintf(profileStr, "profile %d", pidProfileIndex); + dumpAllValues(PROFILE_VALUE, dumpMask, profileStr); pidProfileIndexToUse = CURRENT_PROFILE_INDEX; } @@ -3807,10 +3882,12 @@ static void cliDumpRateProfile(uint8_t rateProfileIndex, dumpFlags_t dumpMask) rateProfileIndexToUse = rateProfileIndex; - cliPrintHashLine("rateprofile"); - cliRateProfile(""); 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; } @@ -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); } -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++) { const char* owner = ownerNames[resourceTable[i].owner]; const pgRegistry_t* pg = pgFind(resourceTable[i].pgn); @@ -4602,6 +4680,7 @@ static void printResource(dumpFlags_t dumpMask) const bool equalsDefault = ioTag == ioTagDefault; const char *format = "resource %s %d %c%02d"; const char *formatUnassigned = "resource %s %d NONE"; + headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr); if (ioTagDefault) { cliDefaultPrintLinef(dumpMask, equalsDefault, format, owner, RESOURCE_INDEX(index), IO_GPIOPortIdxByTag(ioTagDefault) + 'A', IO_GPIOPinIdxByTag(ioTagDefault)); } 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 void *currentConfig; @@ -4802,12 +4881,14 @@ static void printPeripheralDmaopt(dmaoptEntry_t *entry, int index, dumpFlags_t d } bool equalsDefault = currentOpt == defaultOpt; + headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr); if (defaultConfig) { printPeripheralDmaoptDetails(entry, index, defaultOpt, equalsDefault, dumpMask, cliDefaultPrintLinef); } printPeripheralDmaoptDetails(entry, index, currentOpt, equalsDefault, dumpMask, cliDumpPrintLinef); + return headingStr; } #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; if (!ioTag) { - return; + return headingStr; } 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; + headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr); if (defaultConfig) { printTimerDmaoptDetails(ioTag, timer, defaultDmaopt, equalsDefault, dumpMask, cliDefaultPrintLinef); } printTimerDmaoptDetails(ioTag, timer, dmaopt, equalsDefault, dumpMask, cliDumpPrintLinef); + return headingStr; } #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++) { dmaoptEntry_t *entry = &dmaoptEntryTable[i]; 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 }; 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) { for (unsigned i = 0; i < MAX_TIMER_PINMAP_COUNT; i++) { if (!defaultIsUsed[i] && defaultConfig[i].ioTag && defaultConfig[i].dmaopt != DMA_OPT_UNUSED) { 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, DMA_OPT_UNUSED, false, dumpMask, cliDumpPrintLinef); @@ -4922,7 +5007,7 @@ static void cliDmaopt(char *cmdline) // Peripheral name or command option pch = strtok_r(cmdline, " ", &saveptr); if (!pch) { - printDmaopt(DUMP_MASTER | HIDE_UNUSED); + printDmaopt(DUMP_MASTER | HIDE_UNUSED, NULL); return; } else if (strcasecmp(pch, "list") == 0) { @@ -5083,7 +5168,7 @@ static void cliResource(char *cmdline) pch = strtok_r(cmdline, " ", &saveptr); if (!pch) { - printResource(DUMP_MASTER | HIDE_UNUSED); + printResource(DUMP_MASTER | HIDE_UNUSED, NULL); return; } 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 timerIOConfig_t *currentConfig; const timerIOConfig_t *defaultConfig; + headingStr = cliPrintSectionHeading(dumpMask, false, headingStr); if (configIsInCopy) { currentConfig = (timerIOConfig_t *)pg->copy; defaultConfig = (timerIOConfig_t *)pg->address; @@ -5229,7 +5315,7 @@ static void printTimer(dumpFlags_t dumpMask) } const bool equalsDefault = defaultTimerIndex == timerIndex; - + headingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, headingStr); if (defaultConfig && defaultTimerIndex) { printTimerDetails(ioTag, defaultTimerIndex, equalsDefault, dumpMask, cliDefaultPrintLinef); } @@ -5240,6 +5326,7 @@ static void printTimer(dumpFlags_t dumpMask) if (defaultConfig) { for (unsigned i = 0; i < MAX_TIMER_PINMAP_COUNT; i++) { 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, 0, false, dumpMask, cliDumpPrintLinef); @@ -5255,7 +5342,7 @@ static void cliTimer(char *cmdline) int len = strlen(cmdline); if (len == 0) { - printTimer(DUMP_MASTER); + printTimer(DUMP_MASTER, NULL); return; } else if (strncasecmp(cmdline, "list", len) == 0) { @@ -5464,8 +5551,8 @@ static void printConfig(char *cmdline, bool doDiff) #if defined(USE_BOARD_INFO) cliPrintLinefeed(); - cliBoardName(""); - cliManufacturerId(""); + printBoardName(dumpMask); + printManufacturerId(dumpMask); #endif if ((dumpMask & DUMP_ALL) && !(dumpMask & BARE)) { @@ -5480,99 +5567,84 @@ static void printConfig(char *cmdline, bool doDiff) } #ifdef USE_RESOURCE_MGMT - cliPrintHashLine("resources"); - printResource(dumpMask); + printResource(dumpMask, "resources"); #if defined(USE_TIMER_MGMT) - cliPrintHashLine("timer"); - printTimer(dumpMask); + printTimer(dumpMask, "timer"); #endif #ifdef USE_DMA_SPEC - cliPrintHashLine("dma"); - printDmaopt(dumpMask); + printDmaopt(dumpMask, "dma"); #endif #endif if (!(dumpMask & HARDWARE_ONLY)) { #ifndef USE_QUAD_MIXER_ONLY - cliPrintHashLine("mixer"); + const char *mixerHeadingStr = "mixer"; const bool equalsDefault = mixerConfig_Copy.mixerMode == mixerConfig()->mixerMode; + mixerHeadingStr = cliPrintSectionHeading(dumpMask, !equalsDefault, mixerHeadingStr); const char *formatMixer = "mixer %s"; cliDefaultPrintLinef(dumpMask, equalsDefault, formatMixer, mixerNames[mixerConfig()->mixerMode - 1]); cliDumpPrintLinef(dumpMask, equalsDefault, formatMixer, mixerNames[mixerConfig_Copy.mixerMode - 1]); 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 - cliPrintHashLine("servo"); - printServo(dumpMask, servoParams_CopyArray, servoParams(0)); + printServo(dumpMask, servoParams_CopyArray, servoParams(0), "servo"); - cliPrintHashLine("servo mix"); - // print custom servo mixer if exists - cliDumpPrintLinef(dumpMask, customServoMixers(0)->rate == 0, "smix reset\r\n"); - printServoMix(dumpMask, customServoMixers_CopyArray, customServoMixers(0)); + const char *servoMixHeadingStr = "servo mixer"; + if (!(dumpMask & DO_DIFF) || customServoMixers(0)->rate != 0) { + cliPrintHashLine(servoMixHeadingStr); + cliPrintLine("smix reset\r\n"); + servoMixHeadingStr = NULL; + } + printServoMix(dumpMask, customServoMixers_CopyArray, customServoMixers(0), servoMixHeadingStr); #endif #endif - cliPrintHashLine("feature"); - printFeature(dumpMask, &featureConfig_Copy, featureConfig()); + printFeature(dumpMask, &featureConfig_Copy, featureConfig(), "feature"); #if defined(USE_BEEPER) - cliPrintHashLine("beeper"); - printBeeper(dumpMask, beeperConfig_Copy.beeper_off_flags, beeperConfig()->beeper_off_flags, "beeper", BEEPER_ALLOWED_MODES); + printBeeper(dumpMask, beeperConfig_Copy.beeper_off_flags, beeperConfig()->beeper_off_flags, "beeper", BEEPER_ALLOWED_MODES, "beeper"); #if defined(USE_DSHOT) - cliPrintHashLine("beacon"); - printBeeper(dumpMask, beeperConfig_Copy.dshotBeaconOffFlags, beeperConfig()->dshotBeaconOffFlags, "beacon", DSHOT_BEACON_ALLOWED_MODES); + printBeeper(dumpMask, beeperConfig_Copy.dshotBeaconOffFlags, beeperConfig()->dshotBeaconOffFlags, "beacon", DSHOT_BEACON_ALLOWED_MODES, "beacon"); #endif #endif // USE_BEEPER - cliPrintHashLine("map"); - printMap(dumpMask, &rxConfig_Copy, rxConfig()); + printMap(dumpMask, &rxConfig_Copy, rxConfig(), "map"); - cliPrintHashLine("serial"); - printSerial(dumpMask, &serialConfig_Copy, serialConfig()); + printSerial(dumpMask, &serialConfig_Copy, serialConfig(), "serial"); #ifdef USE_LED_STRIP_STATUS_MODE - cliPrintHashLine("led"); - printLed(dumpMask, ledStripStatusModeConfig_Copy.ledConfigs, ledStripStatusModeConfig()->ledConfigs); + printLed(dumpMask, ledStripStatusModeConfig_Copy.ledConfigs, ledStripStatusModeConfig()->ledConfigs, "led"); - cliPrintHashLine("color"); - printColor(dumpMask, ledStripStatusModeConfig_Copy.colors, ledStripStatusModeConfig()->colors); + printColor(dumpMask, ledStripStatusModeConfig_Copy.colors, ledStripStatusModeConfig()->colors, "color"); - cliPrintHashLine("mode_color"); - printModeColor(dumpMask, &ledStripStatusModeConfig_Copy, ledStripStatusModeConfig()); + printModeColor(dumpMask, &ledStripStatusModeConfig_Copy, ledStripStatusModeConfig(), "mode_color"); #endif - cliPrintHashLine("aux"); - printAux(dumpMask, modeActivationConditions_CopyArray, modeActivationConditions(0)); + printAux(dumpMask, modeActivationConditions_CopyArray, modeActivationConditions(0), "aux"); - cliPrintHashLine("adjrange"); - printAdjustmentRange(dumpMask, adjustmentRanges_CopyArray, adjustmentRanges(0)); + printAdjustmentRange(dumpMask, adjustmentRanges_CopyArray, adjustmentRanges(0), "adjrange"); - cliPrintHashLine("rxrange"); - printRxRange(dumpMask, rxChannelRangeConfigs_CopyArray, rxChannelRangeConfigs(0)); + printRxRange(dumpMask, rxChannelRangeConfigs_CopyArray, rxChannelRangeConfigs(0), "rxrange"); #ifdef USE_VTX_CONTROL - cliPrintHashLine("vtx"); - printVtx(dumpMask, &vtxConfig_Copy, vtxConfig()); + printVtx(dumpMask, &vtxConfig_Copy, vtxConfig(), "vtx"); #endif #ifdef USE_VTX_TABLE - cliPrintHashLine("vtxtable"); - printVtxTable(dumpMask, &vtxTableConfig_Copy, vtxTableConfig()); + printVtxTable(dumpMask, &vtxTableConfig_Copy, vtxTableConfig(), "vtxtable"); #endif - cliPrintHashLine("rxfail"); - printRxFailsafe(dumpMask, rxFailsafeChannelConfigs_CopyArray, rxFailsafeChannelConfigs(0)); + printRxFailsafe(dumpMask, rxFailsafeChannelConfigs_CopyArray, rxFailsafeChannelConfigs(0), "rxfail"); } - cliPrintHashLine("master"); if (dumpMask & HARDWARE_ONLY) { - dumpAllValues(HARDWARE_VALUE, dumpMask); + dumpAllValues(HARDWARE_VALUE, dumpMask, "master"); } else { - dumpAllValues(MASTER_VALUE, dumpMask); + dumpAllValues(MASTER_VALUE, dumpMask, "master"); if (dumpMask & DUMP_ALL) { for (uint32_t pidProfileIndex = 0; pidProfileIndex < PID_PROFILE_COUNT; pidProfileIndex++) { diff --git a/src/test/Makefile b/src/test/Makefile index e6c2818d9d..70413bed7b 100644 --- a/src/test/Makefile +++ b/src/test/Makefile @@ -98,9 +98,10 @@ blackbox_encoding_unittest_SRC := \ cli_unittest_SRC := \ $(USER_DIR)/cli/cli.c \ + $(USER_DIR)/common/printf.c \ $(USER_DIR)/config/feature.c \ $(USER_DIR)/pg/pg.c \ - $(USER_DIR)/common/typeconversion.c + $(USER_DIR)/common/typeconversion.c cli_unittest_DEFINES := \ USE_OSD= \ diff --git a/src/test/unit/cli_unittest.cc b/src/test/unit/cli_unittest.cc index 7f760ae4f6..650b84be8f 100644 --- a/src/test/unit/cli_unittest.cc +++ b/src/test/unit/cli_unittest.cc @@ -28,6 +28,7 @@ extern "C" { #include "build/version.h" #include "cli/cli.h" #include "cli/settings.h" + #include "common/printf.h" #include "config/feature.h" #include "drivers/buf_writer.h" #include "drivers/vtx_common.h" @@ -227,19 +228,6 @@ uint8_t getMotorCount() { 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 } }; const box_t *findBoxByPermanentId(uint8_t) { return &boxes[0]; } const box_t *findBoxByBoxId(boxId_e) { return &boxes[0]; }