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

Further use of config macros

Browse source
This commit is contained in:
Martin Budden 2016-12-21 18:58:35 +00:00
parent 83d5e37d77
commit 0e055b460b
6 changed files with 144 additions and 148 deletions
Download patch file Download diff file Expand all files Collapse all files

5
src/main/config/config_master.h
View file

@ -101,6 +101,9 @@
#define pidConfig(x) (&masterConfig.pidConfig) #define pidConfig(x) (&masterConfig.pidConfig)
#define adjustmentProfile(x) (&masterConfig.adjustmentProfile) #define adjustmentProfile(x) (&masterConfig.adjustmentProfile)
#define modeActivationProfile(x) (&masterConfig.modeActivationProfile) #define modeActivationProfile(x) (&masterConfig.modeActivationProfile)
#define servoProfile(x) (&masterConfig.servoProfile)
#define customMotorMixer(i) (&masterConfig.customMotorMixer[i])
#define customServoMixer(i) (&masterConfig.customServoMixer[i])
// System-wide // System-wide
@ -121,7 +124,7 @@ typedef struct master_s {
servoMixerConfig_t servoMixerConfig; servoMixerConfig_t servoMixerConfig;
servoMixer_t customServoMixer[MAX_SERVO_RULES]; servoMixer_t customServoMixer[MAX_SERVO_RULES];
// Servo-related stuff // Servo-related stuff
servoParam_t servoConf[MAX_SUPPORTED_SERVOS]; // servo configuration servoProfile_t servoProfile;
// gimbal-related configuration // gimbal-related configuration
gimbalConfig_t gimbalConfig; gimbalConfig_t gimbalConfig;
#endif #endif

16
src/main/fc/config.c
View file

@ -783,13 +783,13 @@ void createDefaultConfig(master_t *config)
#ifdef USE_SERVOS #ifdef USE_SERVOS
// servos // servos
for (int i = 0; i < MAX_SUPPORTED_SERVOS; i++) { for (int i = 0; i < MAX_SUPPORTED_SERVOS; i++) {
config->servoConf[i].min = DEFAULT_SERVO_MIN; config->servoProfile.servoConf[i].min = DEFAULT_SERVO_MIN;
config->servoConf[i].max = DEFAULT_SERVO_MAX; config->servoProfile.servoConf[i].max = DEFAULT_SERVO_MAX;
config->servoConf[i].middle = DEFAULT_SERVO_MIDDLE; config->servoProfile.servoConf[i].middle = DEFAULT_SERVO_MIDDLE;
config->servoConf[i].rate = 100; config->servoProfile.servoConf[i].rate = 100;
config->servoConf[i].angleAtMin = DEFAULT_SERVO_MIN_ANGLE; config->servoProfile.servoConf[i].angleAtMin = DEFAULT_SERVO_MIN_ANGLE;
config->servoConf[i].angleAtMax = DEFAULT_SERVO_MAX_ANGLE; config->servoProfile.servoConf[i].angleAtMax = DEFAULT_SERVO_MAX_ANGLE;
config->servoConf[i].forwardFromChannel = CHANNEL_FORWARDING_DISABLED; config->servoProfile.servoConf[i].forwardFromChannel = CHANNEL_FORWARDING_DISABLED;
} }
// gimbal // gimbal
@ -909,7 +909,7 @@ void activateConfig(void)
); );
#ifdef USE_SERVOS #ifdef USE_SERVOS
servoUseConfigs(&masterConfig.servoMixerConfig, masterConfig.servoConf, &masterConfig.gimbalConfig); servoUseConfigs(&masterConfig.servoMixerConfig, masterConfig.servoProfile.servoConf, &masterConfig.gimbalConfig);
#endif #endif

60
src/main/fc/fc_msp.c
View file

@ -683,25 +683,25 @@ static bool mspFcProcessOutCommand(uint8_t cmdMSP, sbuf_t *dst, mspPostProcessFn
break; break;
case MSP_SERVO_CONFIGURATIONS: case MSP_SERVO_CONFIGURATIONS:
for (int i = 0; i < MAX_SUPPORTED_SERVOS; i++) { for (int i = 0; i < MAX_SUPPORTED_SERVOS; i++) {
sbufWriteU16(dst, masterConfig.servoConf[i].min); sbufWriteU16(dst, servoProfile()->servoConf[i].min);
sbufWriteU16(dst, masterConfig.servoConf[i].max); sbufWriteU16(dst, servoProfile()->servoConf[i].max);
sbufWriteU16(dst, masterConfig.servoConf[i].middle); sbufWriteU16(dst, servoProfile()->servoConf[i].middle);
sbufWriteU8(dst, masterConfig.servoConf[i].rate); sbufWriteU8(dst, servoProfile()->servoConf[i].rate);
sbufWriteU8(dst, masterConfig.servoConf[i].angleAtMin); sbufWriteU8(dst, servoProfile()->servoConf[i].angleAtMin);
sbufWriteU8(dst, masterConfig.servoConf[i].angleAtMax); sbufWriteU8(dst, servoProfile()->servoConf[i].angleAtMax);
sbufWriteU8(dst, masterConfig.servoConf[i].forwardFromChannel); sbufWriteU8(dst, servoProfile()->servoConf[i].forwardFromChannel);
sbufWriteU32(dst, masterConfig.servoConf[i].reversedSources); sbufWriteU32(dst, servoProfile()->servoConf[i].reversedSources);
} }
break; break;
case MSP_SERVO_MIX_RULES: case MSP_SERVO_MIX_RULES:
for (int i = 0; i < MAX_SERVO_RULES; i++) { for (int i = 0; i < MAX_SERVO_RULES; i++) {
sbufWriteU8(dst, masterConfig.customServoMixer[i].targetChannel); sbufWriteU8(dst, customServoMixer(i)->targetChannel);
sbufWriteU8(dst, masterConfig.customServoMixer[i].inputSource); sbufWriteU8(dst, customServoMixer(i)->inputSource);
sbufWriteU8(dst, masterConfig.customServoMixer[i].rate); sbufWriteU8(dst, customServoMixer(i)->rate);
sbufWriteU8(dst, masterConfig.customServoMixer[i].speed); sbufWriteU8(dst, customServoMixer(i)->speed);
sbufWriteU8(dst, masterConfig.customServoMixer[i].min); sbufWriteU8(dst, customServoMixer(i)->min);
sbufWriteU8(dst, masterConfig.customServoMixer[i].max); sbufWriteU8(dst, customServoMixer(i)->max);
sbufWriteU8(dst, masterConfig.customServoMixer[i].box); sbufWriteU8(dst, customServoMixer(i)->box);
} }
break; break;
#endif #endif
@ -1426,14 +1426,14 @@ static mspResult_e mspFcProcessInCommand(uint8_t cmdMSP, sbuf_t *src)
if (i >= MAX_SUPPORTED_SERVOS) { if (i >= MAX_SUPPORTED_SERVOS) {
return MSP_RESULT_ERROR; return MSP_RESULT_ERROR;
} else { } else {
masterConfig.servoConf[i].min = sbufReadU16(src); servoProfile()->servoConf[i].min = sbufReadU16(src);
masterConfig.servoConf[i].max = sbufReadU16(src); servoProfile()->servoConf[i].max = sbufReadU16(src);
masterConfig.servoConf[i].middle = sbufReadU16(src); servoProfile()->servoConf[i].middle = sbufReadU16(src);
masterConfig.servoConf[i].rate = sbufReadU8(src); servoProfile()->servoConf[i].rate = sbufReadU8(src);
masterConfig.servoConf[i].angleAtMin = sbufReadU8(src); servoProfile()->servoConf[i].angleAtMin = sbufReadU8(src);
masterConfig.servoConf[i].angleAtMax = sbufReadU8(src); servoProfile()->servoConf[i].angleAtMax = sbufReadU8(src);
masterConfig.servoConf[i].forwardFromChannel = sbufReadU8(src); servoProfile()->servoConf[i].forwardFromChannel = sbufReadU8(src);
masterConfig.servoConf[i].reversedSources = sbufReadU32(src); servoProfile()->servoConf[i].reversedSources = sbufReadU32(src);
} }
#endif #endif
break; break;
@ -1444,13 +1444,13 @@ static mspResult_e mspFcProcessInCommand(uint8_t cmdMSP, sbuf_t *src)
if (i >= MAX_SERVO_RULES) { if (i >= MAX_SERVO_RULES) {
return MSP_RESULT_ERROR; return MSP_RESULT_ERROR;
} else { } else {
masterConfig.customServoMixer[i].targetChannel = sbufReadU8(src); customServoMixer(i)->targetChannel = sbufReadU8(src);
masterConfig.customServoMixer[i].inputSource = sbufReadU8(src); customServoMixer(i)->inputSource = sbufReadU8(src);
masterConfig.customServoMixer[i].rate = sbufReadU8(src); customServoMixer(i)->rate = sbufReadU8(src);
masterConfig.customServoMixer[i].speed = sbufReadU8(src); customServoMixer(i)->speed = sbufReadU8(src);
masterConfig.customServoMixer[i].min = sbufReadU8(src); customServoMixer(i)->min = sbufReadU8(src);
masterConfig.customServoMixer[i].max = sbufReadU8(src); customServoMixer(i)->max = sbufReadU8(src);
masterConfig.customServoMixer[i].box = sbufReadU8(src); customServoMixer(i)->box = sbufReadU8(src);
loadCustomServoMixer(); loadCustomServoMixer();
} }
#endif #endif

4
src/main/flight/servos.h
View file

@ -110,6 +110,10 @@ typedef struct servoMixerConfig_s{
int8_t servo_lowpass_enable; // enable/disable lowpass filter int8_t servo_lowpass_enable; // enable/disable lowpass filter
} servoMixerConfig_t; } servoMixerConfig_t;
typedef struct servoProfile_s {
servoParam_t servoConf[MAX_SUPPORTED_SERVOS];
} servoProfile_t;
extern int16_t servo[MAX_SUPPORTED_SERVOS]; extern int16_t servo[MAX_SUPPORTED_SERVOS];
void servoTable(void); void servoTable(void);

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

@ -122,8 +122,8 @@ void cliDfu(char *cmdLine);
static void cliDump(char *cmdLine); static void cliDump(char *cmdLine);
static void cliDiff(char *cmdLine); static void cliDiff(char *cmdLine);
static void printConfig(char *cmdLine, bool doDiff); static void printConfig(char *cmdLine, bool doDiff);
static void cliDumpProfile(uint8_t profileIndex, uint8_t dumpMask, master_t *defaultProfile); static void cliDumpProfile(uint8_t profileIndex, uint8_t dumpMask, const master_t *defaultProfile);
static void cliDumpRateProfile(uint8_t rateProfileIndex, uint8_t dumpMask, master_t *defaultProfile) ; static void cliDumpRateProfile(uint8_t rateProfileIndex, uint8_t dumpMask, const master_t *defaultProfile) ;
static void cliExit(char *cmdline); static void cliExit(char *cmdline);
static void cliFeature(char *cmdline); static void cliFeature(char *cmdline);
static void cliMotor(char *cmdline); static void cliMotor(char *cmdline);
@ -155,7 +155,7 @@ static void cliTasks(char *cmdline);
static void cliVersion(char *cmdline); static void cliVersion(char *cmdline);
static void cliRxRange(char *cmdline); static void cliRxRange(char *cmdline);
#if (FLASH_SIZE > 64) #if (FLASH_SIZE > 64)
static void printResource(uint8_t dumpMask, master_t *defaultConfig); static void printResource(uint8_t dumpMask, const master_t *defaultConfig);
static void cliResource(char *cmdline); static void cliResource(char *cmdline);
#endif #endif
#ifdef GPS #ifdef GPS
@ -1012,7 +1012,7 @@ typedef union {
static void cliSetVar(const clivalue_t *var, const int_float_value_t value); static void cliSetVar(const clivalue_t *var, const int_float_value_t value);
static void cliPrintVar(const clivalue_t *var, uint32_t full); static void cliPrintVar(const clivalue_t *var, uint32_t full);
static void cliPrintVarDefault(const clivalue_t *var, uint32_t full, master_t *defaultConfig); static void cliPrintVarDefault(const clivalue_t *var, uint32_t full, const master_t *defaultConfig);
static void cliPrintVarRange(const clivalue_t *var); static void cliPrintVarRange(const clivalue_t *var);
static void cliPrint(const char *str); static void cliPrint(const char *str);
static void cliPrintf(const char *fmt, ...); static void cliPrintf(const char *fmt, ...);
@ -1209,16 +1209,13 @@ static void cliRxFail(char *cmdline)
} }
} }
static void printAux(uint8_t dumpMask, master_t *defaultConfig) static void printAux(uint8_t dumpMask, const modeActivationProfile_t *defaultModeActivationProfile)
{ {
// print out aux channel settings // print out aux channel settings
modeActivationCondition_t *mac;
modeActivationCondition_t *macDefault;
bool equalsDefault;
for (uint32_t i = 0; i < MAX_MODE_ACTIVATION_CONDITION_COUNT; i++) { for (uint32_t i = 0; i < MAX_MODE_ACTIVATION_CONDITION_COUNT; i++) {
mac = &modeActivationProfile()->modeActivationConditions[i]; const modeActivationCondition_t *mac = &modeActivationProfile()->modeActivationConditions[i];
macDefault = &defaultConfig->modeActivationProfile.modeActivationConditions[i]; const modeActivationCondition_t *macDefault = &defaultModeActivationProfile->modeActivationConditions[i];
equalsDefault = mac->modeId == macDefault->modeId const bool equalsDefault = mac->modeId == macDefault->modeId
&& mac->auxChannelIndex == macDefault->auxChannelIndex && mac->auxChannelIndex == macDefault->auxChannelIndex
&& mac->range.startStep == macDefault->range.startStep && mac->range.startStep == macDefault->range.startStep
&& mac->range.endStep == macDefault->range.endStep; && mac->range.endStep == macDefault->range.endStep;
@ -1283,12 +1280,11 @@ static void cliAux(char *cmdline)
static void printSerial(uint8_t dumpMask, const serialConfig_t *serialConfigDefault) static void printSerial(uint8_t dumpMask, const serialConfig_t *serialConfigDefault)
{ {
const serialConfig_t *serialConfig = serialConfig(); const serialConfig_t *serialConfig = serialConfig();
bool equalsDefault;
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;
}; };
equalsDefault = serialConfig->portConfigs[i].identifier == serialConfigDefault->portConfigs[i].identifier const bool equalsDefault = serialConfig->portConfigs[i].identifier == serialConfigDefault->portConfigs[i].identifier
&& serialConfig->portConfigs[i].functionMask == serialConfigDefault->portConfigs[i].functionMask && serialConfig->portConfigs[i].functionMask == serialConfigDefault->portConfigs[i].functionMask
&& serialConfig->portConfigs[i].msp_baudrateIndex == serialConfigDefault->portConfigs[i].msp_baudrateIndex && serialConfig->portConfigs[i].msp_baudrateIndex == serialConfigDefault->portConfigs[i].msp_baudrateIndex
&& serialConfig->portConfigs[i].gps_baudrateIndex == serialConfigDefault->portConfigs[i].gps_baudrateIndex && serialConfig->portConfigs[i].gps_baudrateIndex == serialConfigDefault->portConfigs[i].gps_baudrateIndex
@ -1475,16 +1471,13 @@ static void cliSerialPassthrough(char *cmdline)
} }
#endif #endif
static void printAdjustmentRange(uint8_t dumpMask, master_t *defaultConfig) static void printAdjustmentRange(uint8_t dumpMask, const adjustmentProfile_t *defaultAdjustmentProfile)
{ {
// print out adjustment ranges channel settings // print out adjustment ranges channel settings
adjustmentRange_t *ar;
adjustmentRange_t *arDefault;
bool equalsDefault;
for (uint32_t i = 0; i < MAX_ADJUSTMENT_RANGE_COUNT; i++) { for (uint32_t i = 0; i < MAX_ADJUSTMENT_RANGE_COUNT; i++) {
ar = &adjustmentProfile()->adjustmentRanges[i]; const adjustmentRange_t *ar = &adjustmentProfile()->adjustmentRanges[i];
arDefault = &defaultConfig->adjustmentProfile.adjustmentRanges[i]; const adjustmentRange_t *arDefault = &defaultAdjustmentProfile->adjustmentRanges[i];
equalsDefault = ar->auxChannelIndex == arDefault->auxChannelIndex const bool equalsDefault = ar->auxChannelIndex == arDefault->auxChannelIndex
&& ar->range.startStep == arDefault->range.startStep && ar->range.startStep == arDefault->range.startStep
&& ar->range.endStep == arDefault->range.endStep && ar->range.endStep == arDefault->range.endStep
&& ar->adjustmentFunction == arDefault->adjustmentFunction && ar->adjustmentFunction == arDefault->adjustmentFunction
@ -1573,24 +1566,24 @@ static void cliAdjustmentRange(char *cmdline)
} }
#ifndef USE_QUAD_MIXER_ONLY #ifndef USE_QUAD_MIXER_ONLY
static void printMotorMix(uint8_t dumpMask, master_t *defaultConfig) static void printMotorMix(uint8_t dumpMask, const motorMixer_t *defaultCustomMotorMixer)
{ {
char buf0[8]; char buf0[8];
char buf1[8]; char buf1[8];
char buf2[8]; char buf2[8];
char buf3[8]; char buf3[8];
for (uint32_t i = 0; i < MAX_SUPPORTED_MOTORS; i++) { for (uint32_t i = 0; i < MAX_SUPPORTED_MOTORS; i++) {
if (masterConfig.customMotorMixer[i].throttle == 0.0f) if (customMotorMixer(i)->throttle == 0.0f)
break; break;
float thr = masterConfig.customMotorMixer[i].throttle; float thr = customMotorMixer(i)->throttle;
float roll = masterConfig.customMotorMixer[i].roll; float roll = customMotorMixer(i)->roll;
float pitch = masterConfig.customMotorMixer[i].pitch; float pitch = customMotorMixer(i)->pitch;
float yaw = masterConfig.customMotorMixer[i].yaw; float yaw = customMotorMixer(i)->yaw;
float thrDefault = defaultConfig->customMotorMixer[i].throttle; float thrDefault = defaultCustomMotorMixer[i].throttle;
float rollDefault = defaultConfig->customMotorMixer[i].roll; float rollDefault = defaultCustomMotorMixer[i].roll;
float pitchDefault = defaultConfig->customMotorMixer[i].pitch; float pitchDefault = defaultCustomMotorMixer[i].pitch;
float yawDefault = defaultConfig->customMotorMixer[i].yaw; float yawDefault = defaultCustomMotorMixer[i].yaw;
bool equalsDefault = thr == thrDefault && roll == rollDefault && pitch == pitchDefault && yaw == yawDefault; const bool equalsDefault = thr == thrDefault && roll == rollDefault && pitch == pitchDefault && yaw == yawDefault;
const char *format = "mmix %d %s %s %s %s\r\n"; const char *format = "mmix %d %s %s %s %s\r\n";
cliDefaultPrintf(dumpMask, equalsDefault, format, cliDefaultPrintf(dumpMask, equalsDefault, format,
@ -1623,7 +1616,7 @@ static void cliMotorMix(char *cmdline)
} 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++)
masterConfig.customMotorMixer[i].throttle = 0.0f; customMotorMixer(i)->throttle = 0.0f;
} else if (strncasecmp(cmdline, "load", 4) == 0) { } else if (strncasecmp(cmdline, "load", 4) == 0) {
ptr = nextArg(cmdline); ptr = nextArg(cmdline);
if (ptr) { if (ptr) {
@ -1647,22 +1640,22 @@ static void cliMotorMix(char *cmdline)
if (i < MAX_SUPPORTED_MOTORS) { if (i < MAX_SUPPORTED_MOTORS) {
ptr = nextArg(ptr); ptr = nextArg(ptr);
if (ptr) { if (ptr) {
masterConfig.customMotorMixer[i].throttle = fastA2F(ptr); customMotorMixer(i)->throttle = fastA2F(ptr);
check++; check++;
} }
ptr = nextArg(ptr); ptr = nextArg(ptr);
if (ptr) { if (ptr) {
masterConfig.customMotorMixer[i].roll = fastA2F(ptr); customMotorMixer(i)->roll = fastA2F(ptr);
check++; check++;
} }
ptr = nextArg(ptr); ptr = nextArg(ptr);
if (ptr) { if (ptr) {
masterConfig.customMotorMixer[i].pitch = fastA2F(ptr); customMotorMixer(i)->pitch = fastA2F(ptr);
check++; check++;
} }
ptr = nextArg(ptr); ptr = nextArg(ptr);
if (ptr) { if (ptr) {
masterConfig.customMotorMixer[i].yaw = fastA2F(ptr); customMotorMixer(i)->yaw = fastA2F(ptr);
check++; check++;
} }
if (check != 4) { if (check != 4) {
@ -1746,7 +1739,6 @@ static void cliRxRange(char *cmdline)
#ifdef LED_STRIP #ifdef LED_STRIP
static void printLed(uint8_t dumpMask, const ledStripConfig_t *defaultLedStripConfig) static void printLed(uint8_t dumpMask, const ledStripConfig_t *defaultLedStripConfig)
{ {
bool equalsDefault;
ledConfig_t ledConfig; ledConfig_t ledConfig;
ledConfig_t ledConfigDefault; ledConfig_t ledConfigDefault;
char ledConfigBuffer[20]; char ledConfigBuffer[20];
@ -1754,7 +1746,7 @@ static void printLed(uint8_t dumpMask, const ledStripConfig_t *defaultLedStripCo
for (uint32_t i = 0; i < LED_MAX_STRIP_LENGTH; i++) { for (uint32_t i = 0; i < LED_MAX_STRIP_LENGTH; i++) {
ledConfig = ledStripConfig()->ledConfigs[i]; ledConfig = ledStripConfig()->ledConfigs[i];
ledConfigDefault = defaultLedStripConfig->ledConfigs[i]; ledConfigDefault = defaultLedStripConfig->ledConfigs[i];
equalsDefault = ledConfig == ledConfigDefault; const bool equalsDefault = ledConfig == ledConfigDefault;
generateLedConfig(&ledConfig, ledConfigBuffer, sizeof(ledConfigBuffer)); generateLedConfig(&ledConfig, ledConfigBuffer, sizeof(ledConfigBuffer));
generateLedConfig(&ledConfigDefault, ledConfigDefaultBuffer, sizeof(ledConfigDefaultBuffer)); generateLedConfig(&ledConfigDefault, ledConfigDefaultBuffer, sizeof(ledConfigDefaultBuffer));
const char *format = "led %u %s\r\n"; const char *format = "led %u %s\r\n";
@ -1786,13 +1778,10 @@ static void cliLed(char *cmdline)
static void printColor(uint8_t dumpMask, const ledStripConfig_t *defaultLedStripConfig) static void printColor(uint8_t dumpMask, const ledStripConfig_t *defaultLedStripConfig)
{ {
const hsvColor_t *color;
const hsvColor_t *colorDefault;
bool equalsDefault;
for (uint32_t i = 0; i < LED_CONFIGURABLE_COLOR_COUNT; i++) { for (uint32_t i = 0; i < LED_CONFIGURABLE_COLOR_COUNT; i++) {
color = &ledStripConfig()->colors[i]; const hsvColor_t *color = &ledStripConfig()->colors[i];
colorDefault = &defaultLedStripConfig->colors[i]; const hsvColor_t *colorDefault = &defaultLedStripConfig->colors[i];
equalsDefault = color->h == colorDefault->h const bool equalsDefault = color->h == colorDefault->h
&& color->s == colorDefault->s && color->s == colorDefault->s
&& color->v == colorDefault->v; && color->v == colorDefault->v;
const char *format = "color %u %d,%u,%u\r\n"; const char *format = "color %u %d,%u,%u\r\n";
@ -1891,13 +1880,13 @@ static void cliModeColor(char *cmdline)
#endif #endif
#ifdef USE_SERVOS #ifdef USE_SERVOS
static void printServo(uint8_t dumpMask, master_t *defaultConfig) static void printServo(uint8_t dumpMask, servoProfile_t *defaultServoProfile)
{ {
// print out servo settings // print out servo settings
for (uint32_t i = 0; i < MAX_SUPPORTED_SERVOS; i++) { for (uint32_t i = 0; i < MAX_SUPPORTED_SERVOS; i++) {
servoParam_t *servoConf = &masterConfig.servoConf[i]; const servoParam_t *servoConf = &servoProfile()->servoConf[i];
servoParam_t *servoConfDefault = &defaultConfig->servoConf[i]; const servoParam_t *servoConfDefault = &defaultServoProfile->servoConf[i];
bool equalsDefault = servoConf->min == servoConfDefault->min const bool equalsDefault = servoConf->min == servoConfDefault->min
&& servoConf->max == servoConfDefault->max && servoConf->max == servoConfDefault->max
&& servoConf->middle == servoConfDefault->middle && servoConf->middle == servoConfDefault->middle
&& servoConf->angleAtMin == servoConfDefault->angleAtMax && servoConf->angleAtMin == servoConfDefault->angleAtMax
@ -1977,7 +1966,7 @@ static void cliServo(char *cmdline)
return; return;
} }
servo = &masterConfig.servoConf[i]; servo = &servoProfile()->servoConf[i];
if ( if (
arguments[MIN] < PWM_PULSE_MIN || arguments[MIN] > PWM_PULSE_MAX || arguments[MIN] < PWM_PULSE_MIN || arguments[MIN] > PWM_PULSE_MAX ||
@ -2005,16 +1994,16 @@ static void cliServo(char *cmdline)
#endif #endif
#ifdef USE_SERVOS #ifdef USE_SERVOS
static void printServoMix(uint8_t dumpMask, master_t *defaultConfig) static void printServoMix(uint8_t dumpMask, const master_t *defaultConfig)
{ {
for (uint32_t i = 0; i < MAX_SERVO_RULES; i++) { for (uint32_t i = 0; i < MAX_SERVO_RULES; i++) {
servoMixer_t customServoMixer = masterConfig.customServoMixer[i]; servoMixer_t customServoMixer = *customServoMixer(i);
servoMixer_t customServoMixerDefault = defaultConfig->customServoMixer[i]; servoMixer_t customServoMixerDefault = defaultConfig->customServoMixer[i];
if (customServoMixer.rate == 0) { if (customServoMixer.rate == 0) {
break; break;
} }
bool equalsDefault = customServoMixer.targetChannel == customServoMixerDefault.targetChannel const bool equalsDefault = customServoMixer.targetChannel == customServoMixerDefault.targetChannel
&& customServoMixer.inputSource == customServoMixerDefault.inputSource && customServoMixer.inputSource == customServoMixerDefault.inputSource
&& customServoMixer.rate == customServoMixerDefault.rate && customServoMixer.rate == customServoMixerDefault.rate
&& customServoMixer.speed == customServoMixerDefault.speed && customServoMixer.speed == customServoMixerDefault.speed
@ -2049,8 +2038,8 @@ static void printServoMix(uint8_t dumpMask, master_t *defaultConfig)
// print servo directions // print servo directions
for (uint32_t i = 0; i < MAX_SUPPORTED_SERVOS; i++) { for (uint32_t i = 0; i < MAX_SUPPORTED_SERVOS; i++) {
servoParam_t *servoConf = &masterConfig.servoConf[i]; const servoParam_t *servoConf = &servoProfile()->servoConf[i];
servoParam_t *servoConfDefault = &defaultConfig->servoConf[i]; const servoParam_t *servoConfDefault = &defaultConfig->servoProfile.servoConf[i];
bool equalsDefault = servoConf->reversedSources == servoConfDefault->reversedSources; bool equalsDefault = servoConf->reversedSources == servoConfDefault->reversedSources;
for (uint32_t channel = 0; channel < INPUT_SOURCE_COUNT; channel++) { for (uint32_t channel = 0; channel < INPUT_SOURCE_COUNT; channel++) {
equalsDefault = ~(servoConf->reversedSources ^ servoConfDefault->reversedSources) & (1 << channel); equalsDefault = ~(servoConf->reversedSources ^ servoConfDefault->reversedSources) & (1 << channel);
@ -2078,7 +2067,7 @@ static void cliServoMix(char *cmdline)
// erase custom mixer // erase custom mixer
memset(masterConfig.customServoMixer, 0, sizeof(masterConfig.customServoMixer)); memset(masterConfig.customServoMixer, 0, sizeof(masterConfig.customServoMixer));
for (uint32_t i = 0; i < MAX_SUPPORTED_SERVOS; i++) { for (uint32_t i = 0; i < MAX_SUPPORTED_SERVOS; i++) {
masterConfig.servoConf[i].reversedSources = 0; servoProfile()->servoConf[i].reversedSources = 0;
} }
} else if (strncasecmp(cmdline, "load", 4) == 0) { } else if (strncasecmp(cmdline, "load", 4) == 0) {
ptr = nextArg(cmdline); ptr = nextArg(cmdline);
@ -2111,7 +2100,7 @@ static void cliServoMix(char *cmdline)
for (uint32_t servoIndex = 0; servoIndex < MAX_SUPPORTED_SERVOS; servoIndex++) { for (uint32_t servoIndex = 0; servoIndex < MAX_SUPPORTED_SERVOS; servoIndex++) {
cliPrintf("%d", servoIndex); cliPrintf("%d", servoIndex);
for (uint32_t inputSource = 0; inputSource < INPUT_SOURCE_COUNT; inputSource++) for (uint32_t inputSource = 0; inputSource < INPUT_SOURCE_COUNT; inputSource++)
cliPrintf("\t%s ", (masterConfig.servoConf[servoIndex].reversedSources & (1 << inputSource)) ? "r" : "n"); cliPrintf("\t%s ", (servoProfile()->servoConf[servoIndex].reversedSources & (1 << inputSource)) ? "r" : "n");
cliPrintf("\r\n"); cliPrintf("\r\n");
} }
return; return;
@ -2132,9 +2121,9 @@ static void cliServoMix(char *cmdline)
&& args[INPUT] >= 0 && args[INPUT] < INPUT_SOURCE_COUNT && args[INPUT] >= 0 && args[INPUT] < INPUT_SOURCE_COUNT
&& (*ptr == 'r' || *ptr == 'n')) { && (*ptr == 'r' || *ptr == 'n')) {
if (*ptr == 'r') if (*ptr == 'r')
masterConfig.servoConf[args[SERVO]].reversedSources |= 1 << args[INPUT]; servoProfile()->servoConf[args[SERVO]].reversedSources |= 1 << args[INPUT];
else else
masterConfig.servoConf[args[SERVO]].reversedSources &= ~(1 << args[INPUT]); servoProfile()->servoConf[args[SERVO]].reversedSources &= ~(1 << args[INPUT]);
} else } else
cliShowParseError(); cliShowParseError();
@ -2161,13 +2150,13 @@ static void cliServoMix(char *cmdline)
args[MIN] >= 0 && args[MIN] <= 100 && args[MIN] >= 0 && args[MIN] <= 100 &&
args[MAX] >= 0 && args[MAX] <= 100 && args[MIN] < args[MAX] && args[MAX] >= 0 && args[MAX] <= 100 && args[MIN] < args[MAX] &&
args[BOX] >= 0 && args[BOX] <= MAX_SERVO_BOXES) { args[BOX] >= 0 && args[BOX] <= MAX_SERVO_BOXES) {
masterConfig.customServoMixer[i].targetChannel = args[TARGET]; customServoMixer(i)->targetChannel = args[TARGET];
masterConfig.customServoMixer[i].inputSource = args[INPUT]; customServoMixer(i)->inputSource = args[INPUT];
masterConfig.customServoMixer[i].rate = args[RATE]; customServoMixer(i)->rate = args[RATE];
masterConfig.customServoMixer[i].speed = args[SPEED]; customServoMixer(i)->speed = args[SPEED];
masterConfig.customServoMixer[i].min = args[MIN]; customServoMixer(i)->min = args[MIN];
masterConfig.customServoMixer[i].max = args[MAX]; customServoMixer(i)->max = args[MAX];
masterConfig.customServoMixer[i].box = args[BOX]; customServoMixer(i)->box = args[BOX];
cliServoMix(""); cliServoMix("");
} else { } else {
cliShowParseError(); cliShowParseError();
@ -2347,7 +2336,7 @@ static void cliFlashRead(char *cmdline)
#endif #endif
#ifdef VTX #ifdef VTX
static void printVtx(uint8_t dumpMask, master_t *defaultConfig) static void printVtx(uint8_t dumpMask, const master_t *defaultConfig)
{ {
// print out vtx channel settings // print out vtx channel settings
vtxChannelActivationCondition_t *cac; vtxChannelActivationCondition_t *cac;
@ -2448,7 +2437,7 @@ static void cliName(char *cmdline)
printName(DUMP_MASTER); printName(DUMP_MASTER);
} }
static void printFeature(uint8_t dumpMask, master_t *defaultConfig) static void printFeature(uint8_t dumpMask, const master_t *defaultConfig)
{ {
uint32_t mask = featureMask(); uint32_t mask = featureMask();
uint32_t defaultMask = defaultConfig->enabledFeatures; uint32_t defaultMask = defaultConfig->enabledFeatures;
@ -2540,7 +2529,7 @@ static void cliFeature(char *cmdline)
} }
#ifdef BEEPER #ifdef BEEPER
static void printBeeper(uint8_t dumpMask, master_t *defaultConfig) static void printBeeper(uint8_t dumpMask, const master_t *defaultConfig)
{ {
uint8_t beeperCount = beeperTableEntryCount(); uint8_t beeperCount = beeperTableEntryCount();
uint32_t mask = getBeeperOffMask(); uint32_t mask = getBeeperOffMask();
@ -2683,12 +2672,12 @@ void *getValuePointer(const clivalue_t *value)
return ptr; return ptr;
} }
static void *getDefaultPointer(void *valuePointer, master_t *defaultConfig) static void *getDefaultPointer(void *valuePointer, const master_t *defaultConfig)
{ {
return ((uint8_t *)valuePointer) - (uint32_t)&masterConfig + (uint32_t)defaultConfig; return ((uint8_t *)valuePointer) - (uint32_t)&masterConfig + (uint32_t)defaultConfig;
} }
static bool valueEqualsDefault(const clivalue_t *value, master_t *defaultConfig) static bool valueEqualsDefault(const clivalue_t *value, const master_t *defaultConfig)
{ {
void *ptr = getValuePointer(value); void *ptr = getValuePointer(value);
@ -2723,7 +2712,7 @@ static bool valueEqualsDefault(const clivalue_t *value, master_t *defaultConfig)
return result; return result;
} }
static void dumpValues(uint16_t valueSection, uint8_t dumpMask, master_t *defaultConfig) static void dumpValues(uint16_t valueSection, uint8_t dumpMask, const master_t *defaultConfig)
{ {
const clivalue_t *value; const clivalue_t *value;
for (uint32_t i = 0; i < VALUE_COUNT; i++) { for (uint32_t i = 0; i < VALUE_COUNT; i++) {
@ -2823,13 +2812,13 @@ static void printConfig(char *cmdline, bool doDiff)
cliDumpPrintf(dumpMask, masterConfig.customMotorMixer[0].throttle == 0.0f, "\r\nmmix reset\r\n\r\n"); cliDumpPrintf(dumpMask, masterConfig.customMotorMixer[0].throttle == 0.0f, "\r\nmmix reset\r\n\r\n");
printMotorMix(dumpMask, &defaultConfig); printMotorMix(dumpMask, defaultConfig.customMotorMixer);
#ifdef USE_SERVOS #ifdef USE_SERVOS
#ifndef CLI_MINIMAL_VERBOSITY #ifndef CLI_MINIMAL_VERBOSITY
cliPrint("\r\n# servo\r\n"); cliPrint("\r\n# servo\r\n");
#endif #endif
printServo(dumpMask, &defaultConfig); printServo(dumpMask, &defaultConfig.servoProfile);
#ifndef CLI_MINIMAL_VERBOSITY #ifndef CLI_MINIMAL_VERBOSITY
cliPrint("\r\n# servo mix\r\n"); cliPrint("\r\n# servo mix\r\n");
@ -2882,12 +2871,12 @@ static void printConfig(char *cmdline, bool doDiff)
#ifndef CLI_MINIMAL_VERBOSITY #ifndef CLI_MINIMAL_VERBOSITY
cliPrint("\r\n# aux\r\n"); cliPrint("\r\n# aux\r\n");
#endif #endif
printAux(dumpMask, &defaultConfig); printAux(dumpMask, &defaultConfig.modeActivationProfile);
#ifndef CLI_MINIMAL_VERBOSITY #ifndef CLI_MINIMAL_VERBOSITY
cliPrint("\r\n# adjrange\r\n"); cliPrint("\r\n# adjrange\r\n");
#endif #endif
printAdjustmentRange(dumpMask, &defaultConfig); printAdjustmentRange(dumpMask, &defaultConfig.adjustmentProfile);
#ifndef CLI_MINIMAL_VERBOSITY #ifndef CLI_MINIMAL_VERBOSITY
cliPrint("\r\n# rxrange\r\n"); cliPrint("\r\n# rxrange\r\n");
@ -2950,7 +2939,7 @@ static void printConfig(char *cmdline, bool doDiff)
} }
} }
static void cliDumpProfile(uint8_t profileIndex, uint8_t dumpMask, master_t *defaultConfig) static void cliDumpProfile(uint8_t profileIndex, uint8_t dumpMask, const master_t *defaultConfig)
{ {
if (profileIndex >= MAX_PROFILE_COUNT) { if (profileIndex >= MAX_PROFILE_COUNT) {
// Faulty values // Faulty values
@ -2966,7 +2955,7 @@ static void cliDumpProfile(uint8_t profileIndex, uint8_t dumpMask, master_t *def
cliRateProfile(""); cliRateProfile("");
} }
static void cliDumpRateProfile(uint8_t rateProfileIndex, uint8_t dumpMask, master_t *defaultConfig) static void cliDumpRateProfile(uint8_t rateProfileIndex, uint8_t dumpMask, const master_t *defaultConfig)
{ {
if (rateProfileIndex >= MAX_RATEPROFILES) { if (rateProfileIndex >= MAX_RATEPROFILES) {
// Faulty values // Faulty values
@ -3404,7 +3393,7 @@ static void cliPrintVar(const clivalue_t *var, uint32_t full)
printValuePointer(var, ptr, full); printValuePointer(var, ptr, full);
} }
static void cliPrintVarDefault(const clivalue_t *var, uint32_t full, master_t *defaultConfig) static void cliPrintVarDefault(const clivalue_t *var, uint32_t full, const master_t *defaultConfig)
{ {
void *ptr = getValuePointer(var); void *ptr = getValuePointer(var);
@ -3843,7 +3832,7 @@ const cliResourceValue_t resourceTable[] = {
#endif #endif
}; };
static void printResource(uint8_t dumpMask, master_t *defaultConfig) static void printResource(uint8_t dumpMask, const master_t *defaultConfig)
{ {
for (unsigned int i = 0; i < ARRAYLEN(resourceTable); i++) { for (unsigned int i = 0; i < ARRAYLEN(resourceTable); i++) {
const char* owner; const char* owner;

60
src/main/target/COLIBRI_RACE/i2c_bst.c
View file

@ -627,25 +627,25 @@ static bool bstSlaveProcessFeedbackCommand(uint8_t bstRequest)
break; break;
case BST_SERVO_CONFIGURATIONS: case BST_SERVO_CONFIGURATIONS:
for (i = 0; i < MAX_SUPPORTED_SERVOS; i++) { for (i = 0; i < MAX_SUPPORTED_SERVOS; i++) {
bstWrite16(masterConfig.servoConf[i].min); bstWrite16(servoProfile()->servoConf[i].min);
bstWrite16(masterConfig.servoConf[i].max); bstWrite16(servoProfile()->servoConf[i].max);
bstWrite16(masterConfig.servoConf[i].middle); bstWrite16(servoProfile()->servoConf[i].middle);
bstWrite8(masterConfig.servoConf[i].rate); bstWrite8(servoProfile()->servoConf[i].rate);
bstWrite8(masterConfig.servoConf[i].angleAtMin); bstWrite8(servoProfile()->servoConf[i].angleAtMin);
bstWrite8(masterConfig.servoConf[i].angleAtMax); bstWrite8(servoProfile()->servoConf[i].angleAtMax);
bstWrite8(masterConfig.servoConf[i].forwardFromChannel); bstWrite8(servoProfile()->servoConf[i].forwardFromChannel);
bstWrite32(masterConfig.servoConf[i].reversedSources); bstWrite32(servoProfile()->servoConf[i].reversedSources);
} }
break; break;
case BST_SERVO_MIX_RULES: case BST_SERVO_MIX_RULES:
for (i = 0; i < MAX_SERVO_RULES; i++) { for (i = 0; i < MAX_SERVO_RULES; i++) {
bstWrite8(masterConfig.customServoMixer[i].targetChannel); bstWrite8(customServoMixer(i)->targetChannel);
bstWrite8(masterConfig.customServoMixer[i].inputSource); bstWrite8(customServoMixer(i)->inputSource);
bstWrite8(masterConfig.customServoMixer[i].rate); bstWrite8(customServoMixer(i)->rate);
bstWrite8(masterConfig.customServoMixer[i].speed); bstWrite8(customServoMixer(i)->speed);
bstWrite8(masterConfig.customServoMixer[i].min); bstWrite8(customServoMixer(i)->min);
bstWrite8(masterConfig.customServoMixer[i].max); bstWrite8(customServoMixer(i)->max);
bstWrite8(masterConfig.customServoMixer[i].box); bstWrite8(customServoMixer(i)->box);
} }
break; break;
#endif #endif
@ -1157,14 +1157,14 @@ static bool bstSlaveProcessWriteCommand(uint8_t bstWriteCommand)
if (i >= MAX_SUPPORTED_SERVOS) { if (i >= MAX_SUPPORTED_SERVOS) {
ret = BST_FAILED; ret = BST_FAILED;
} else { } else {
masterConfig.servoConf[i].min = bstRead16(); servoProfile()->servoConf[i].min = bstRead16();
masterConfig.servoConf[i].max = bstRead16(); servoProfile()->servoConf[i].max = bstRead16();
masterConfig.servoConf[i].middle = bstRead16(); servoProfile()->servoConf[i].middle = bstRead16();
masterConfig.servoConf[i].rate = bstRead8(); servoProfile()->servoConf[i].rate = bstRead8();
masterConfig.servoConf[i].angleAtMin = bstRead8(); servoProfile()->servoConf[i].angleAtMin = bstRead8();
masterConfig.servoConf[i].angleAtMax = bstRead8(); servoProfile()->servoConf[i].angleAtMax = bstRead8();
masterConfig.servoConf[i].forwardFromChannel = bstRead8(); servoProfile()->servoConf[i].forwardFromChannel = bstRead8();
masterConfig.servoConf[i].reversedSources = bstRead32(); servoProfile()->servoConf[i].reversedSources = bstRead32();
} }
#endif #endif
break; break;
@ -1174,13 +1174,13 @@ static bool bstSlaveProcessWriteCommand(uint8_t bstWriteCommand)
if (i >= MAX_SERVO_RULES) { if (i >= MAX_SERVO_RULES) {
ret = BST_FAILED; ret = BST_FAILED;
} else { } else {
masterConfig.customServoMixer[i].targetChannel = bstRead8(); customServoMixer(i)->targetChannel = bstRead8();
masterConfig.customServoMixer[i].inputSource = bstRead8(); customServoMixer(i)->inputSource = bstRead8();
masterConfig.customServoMixer[i].rate = bstRead8(); customServoMixer(i)->rate = bstRead8();
masterConfig.customServoMixer[i].speed = bstRead8(); customServoMixer(i)->speed = bstRead8();
masterConfig.customServoMixer[i].min = bstRead8(); customServoMixer(i)->min = bstRead8();
masterConfig.customServoMixer[i].max = bstRead8(); customServoMixer(i)->max = bstRead8();
masterConfig.customServoMixer[i].box = bstRead8(); customServoMixer(i)->box = bstRead8();
loadCustomServoMixer(); loadCustomServoMixer();
} }
#endif #endif