rusefi
/
atbetaflight
mirror of https://github.com/rusefi/atbetaflight.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Added rx, arming, mixer, and airplane config() macros

This commit is contained in:
Martin Budden 2016-11-30 23:06:42 +00:00
parent 00338cb854
commit c175d304c2
9 changed files with 168 additions and 163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/main/blackbox/blackbox.c
View File

@ -369,7 +369,7 @@ static bool testBlackboxConditionUncached(FlightLogFieldCondition condition)
return motorCount >= condition - FLIGHT_LOG_FIELD_CONDITION_AT_LEAST_MOTORS_1 + 1;
case FLIGHT_LOG_FIELD_CONDITION_TRICOPTER:
return masterConfig.mixerConfig.mixerMode == MIXER_TRI || masterConfig.mixerConfig.mixerMode == MIXER_CUSTOM_TRI;
return mixerConfig()->mixerMode == MIXER_TRI || mixerConfig()->mixerMode == MIXER_CUSTOM_TRI;
case FLIGHT_LOG_FIELD_CONDITION_NONZERO_PID_D_0:
case FLIGHT_LOG_FIELD_CONDITION_NONZERO_PID_D_1:
@ -404,7 +404,7 @@ static bool testBlackboxConditionUncached(FlightLogFieldCondition condition)
#endif
case FLIGHT_LOG_FIELD_CONDITION_RSSI:
return masterConfig.rxConfig.rssi_channel > 0 || feature(FEATURE_RSSI_ADC);
return rxConfig()->rssi_channel > 0 || feature(FEATURE_RSSI_ADC);
case FLIGHT_LOG_FIELD_CONDITION_NOT_LOGGING_EVERY_FRAME:
return masterConfig.blackboxConfig.rate_num < masterConfig.blackboxConfig.rate_denom;
@ -1273,11 +1273,11 @@ static bool blackboxWriteSysinfo()
BLACKBOX_PRINT_HEADER_LINE("acc_hardware:%d", sensorSelectionConfig()->acc_hardware);
BLACKBOX_PRINT_HEADER_LINE("baro_hardware:%d", sensorSelectionConfig()->baro_hardware);
BLACKBOX_PRINT_HEADER_LINE("mag_hardware:%d", sensorSelectionConfig()->mag_hardware);
BLACKBOX_PRINT_HEADER_LINE("gyro_cal_on_first_arm:%d", masterConfig.armingConfig.gyro_cal_on_first_arm);
BLACKBOX_PRINT_HEADER_LINE("rc_interpolation:%d", masterConfig.rxConfig.rcInterpolation);
BLACKBOX_PRINT_HEADER_LINE("rc_interpolation_interval:%d", masterConfig.rxConfig.rcInterpolationInterval);
BLACKBOX_PRINT_HEADER_LINE("airmode_activate_throttle:%d", masterConfig.rxConfig.airModeActivateThreshold);
BLACKBOX_PRINT_HEADER_LINE("serialrx_provider:%d", masterConfig.rxConfig.serialrx_provider);
BLACKBOX_PRINT_HEADER_LINE("gyro_cal_on_first_arm:%d", armingConfig()->gyro_cal_on_first_arm);
BLACKBOX_PRINT_HEADER_LINE("rc_interpolation:%d", rxConfig()->rcInterpolation);
BLACKBOX_PRINT_HEADER_LINE("rc_interpolation_interval:%d", rxConfig()->rcInterpolationInterval);
BLACKBOX_PRINT_HEADER_LINE("airmode_activate_throttle:%d", rxConfig()->airModeActivateThreshold);
BLACKBOX_PRINT_HEADER_LINE("serialrx_provider:%d", rxConfig()->serialrx_provider);
BLACKBOX_PRINT_HEADER_LINE("unsynced_fast_pwm:%d", motorConfig()->useUnsyncedPwm);
BLACKBOX_PRINT_HEADER_LINE("fast_pwm_protocol:%d", motorConfig()->motorPwmProtocol);
BLACKBOX_PRINT_HEADER_LINE("motor_pwm_rate:%d", motorConfig()->motorPwmRate);

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

@ -80,6 +80,11 @@
#define rcControlsConfig(x) (&masterConfig.rcControlsConfig)
#define gpsProfile(x) (&masterConfig.gpsProfile)
#define gpsConfig(x) (&masterConfig.gpsConfig)
#define rxConfig(x) (&masterConfig.rxConfig)
#define armingConfig(x) (&masterConfig.armingConfig)
#define mixerConfig(x) (&masterConfig.mixerConfig)
#define airplaneConfig(x) (&masterConfig.airplaneConfig)
// System-wide
typedef struct master_s {

102
src/main/fc/fc_msp.c
View File

@ -313,7 +313,7 @@ void initActiveBoxIds(void)
activeBoxIds[activeBoxIdCount++] = BOXFAILSAFE;
}
if (masterConfig.mixerConfig.mixerMode == MIXER_FLYING_WING || masterConfig.mixerConfig.mixerMode == MIXER_AIRPLANE) {
if (mixerConfig()->mixerMode == MIXER_FLYING_WING || mixerConfig()->mixerMode == MIXER_AIRPLANE) {
activeBoxIds[activeBoxIdCount++] = BOXPASSTHRU;
}
@ -360,7 +360,7 @@ void initActiveBoxIds(void)
#endif
#ifdef USE_SERVOS
if (masterConfig.mixerConfig.mixerMode == MIXER_CUSTOM_AIRPLANE) {
if (mixerConfig()->mixerMode == MIXER_CUSTOM_AIRPLANE) {
activeBoxIds[activeBoxIdCount++] = BOXSERVO1;
activeBoxIds[activeBoxIdCount++] = BOXSERVO2;
activeBoxIds[activeBoxIdCount++] = BOXSERVO3;
@ -563,7 +563,7 @@ static bool mspFcProcessOutCommand(uint8_t cmdMSP, sbuf_t *dst, mspPostProcessFn
// DEPRECATED - Use MSP_API_VERSION
case MSP_IDENT:
sbufWriteU8(dst, MW_VERSION);
sbufWriteU8(dst, masterConfig.mixerConfig.mixerMode);
sbufWriteU8(dst, mixerConfig()->mixerMode);
sbufWriteU8(dst, MSP_PROTOCOL_VERSION);
sbufWriteU32(dst, CAP_DYNBALANCE); // "capability"
break;
@ -700,8 +700,8 @@ static bool mspFcProcessOutCommand(uint8_t cmdMSP, sbuf_t *dst, mspPostProcessFn
break;
case MSP_ARMING_CONFIG:
sbufWriteU8(dst, masterConfig.armingConfig.auto_disarm_delay);
sbufWriteU8(dst, masterConfig.armingConfig.disarm_kill_switch);
sbufWriteU8(dst, armingConfig()->auto_disarm_delay);
sbufWriteU8(dst, armingConfig()->disarm_kill_switch);
break;
case MSP_LOOP_TIME:
@ -776,7 +776,7 @@ static bool mspFcProcessOutCommand(uint8_t cmdMSP, sbuf_t *dst, mspPostProcessFn
break;
case MSP_MISC:
sbufWriteU16(dst, masterConfig.rxConfig.midrc);
sbufWriteU16(dst, rxConfig()->midrc);
sbufWriteU16(dst, motorConfig()->minthrottle);
sbufWriteU16(dst, motorConfig()->maxthrottle);
@ -794,7 +794,7 @@ static bool mspFcProcessOutCommand(uint8_t cmdMSP, sbuf_t *dst, mspPostProcessFn
sbufWriteU8(dst, 0); // gps_ubx_sbas
#endif
sbufWriteU8(dst, batteryConfig()->multiwiiCurrentMeterOutput);
sbufWriteU8(dst, masterConfig.rxConfig.rssi_channel);
sbufWriteU8(dst, rxConfig()->rssi_channel);
sbufWriteU8(dst, 0);
sbufWriteU16(dst, compassConfig()->mag_declination / 10);
@ -886,23 +886,23 @@ static bool mspFcProcessOutCommand(uint8_t cmdMSP, sbuf_t *dst, mspPostProcessFn
break;
case MSP_MIXER:
sbufWriteU8(dst, masterConfig.mixerConfig.mixerMode);
sbufWriteU8(dst, mixerConfig()->mixerMode);
break;
case MSP_RX_CONFIG:
sbufWriteU8(dst, masterConfig.rxConfig.serialrx_provider);
sbufWriteU16(dst, masterConfig.rxConfig.maxcheck);
sbufWriteU16(dst, masterConfig.rxConfig.midrc);
sbufWriteU16(dst, masterConfig.rxConfig.mincheck);
sbufWriteU8(dst, masterConfig.rxConfig.spektrum_sat_bind);
sbufWriteU16(dst, masterConfig.rxConfig.rx_min_usec);
sbufWriteU16(dst, masterConfig.rxConfig.rx_max_usec);
sbufWriteU8(dst, masterConfig.rxConfig.rcInterpolation);
sbufWriteU8(dst, masterConfig.rxConfig.rcInterpolationInterval);
sbufWriteU16(dst, masterConfig.rxConfig.airModeActivateThreshold);
sbufWriteU8(dst, masterConfig.rxConfig.rx_spi_protocol);
sbufWriteU32(dst, masterConfig.rxConfig.rx_spi_id);
sbufWriteU8(dst, masterConfig.rxConfig.rx_spi_rf_channel_count);
sbufWriteU8(dst, rxConfig()->serialrx_provider);
sbufWriteU16(dst, rxConfig()->maxcheck);
sbufWriteU16(dst, rxConfig()->midrc);
sbufWriteU16(dst, rxConfig()->mincheck);
sbufWriteU8(dst, rxConfig()->spektrum_sat_bind);
sbufWriteU16(dst, rxConfig()->rx_min_usec);
sbufWriteU16(dst, rxConfig()->rx_max_usec);
sbufWriteU8(dst, rxConfig()->rcInterpolation);
sbufWriteU8(dst, rxConfig()->rcInterpolationInterval);
sbufWriteU16(dst, rxConfig()->airModeActivateThreshold);
sbufWriteU8(dst, rxConfig()->rx_spi_protocol);
sbufWriteU32(dst, rxConfig()->rx_spi_id);
sbufWriteU8(dst, rxConfig()->rx_spi_rf_channel_count);
break;
case MSP_FAILSAFE_CONFIG:
@ -916,27 +916,27 @@ static bool mspFcProcessOutCommand(uint8_t cmdMSP, sbuf_t *dst, mspPostProcessFn
case MSP_RXFAIL_CONFIG:
for (int i = 0; i < rxRuntimeConfig.channelCount; i++) {
sbufWriteU8(dst, masterConfig.rxConfig.failsafe_channel_configurations[i].mode);
sbufWriteU16(dst, RXFAIL_STEP_TO_CHANNEL_VALUE(masterConfig.rxConfig.failsafe_channel_configurations[i].step));
sbufWriteU8(dst, rxConfig()->failsafe_channel_configurations[i].mode);
sbufWriteU16(dst, RXFAIL_STEP_TO_CHANNEL_VALUE(rxConfig()->failsafe_channel_configurations[i].step));
}
break;
case MSP_RSSI_CONFIG:
sbufWriteU8(dst, masterConfig.rxConfig.rssi_channel);
sbufWriteU8(dst, rxConfig()->rssi_channel);
break;
case MSP_RX_MAP:
for (int i = 0; i < MAX_MAPPABLE_RX_INPUTS; i++) {
sbufWriteU8(dst, masterConfig.rxConfig.rcmap[i]);
sbufWriteU8(dst, rxConfig()->rcmap[i]);
}
break;
case MSP_BF_CONFIG:
sbufWriteU8(dst, masterConfig.mixerConfig.mixerMode);
sbufWriteU8(dst, mixerConfig()->mixerMode);
sbufWriteU32(dst, featureMask());
sbufWriteU8(dst, masterConfig.rxConfig.serialrx_provider);
sbufWriteU8(dst, rxConfig()->serialrx_provider);
sbufWriteU16(dst, boardAlignment()->rollDegrees);
sbufWriteU16(dst, boardAlignment()->pitchDegrees);
@ -1247,8 +1247,8 @@ static mspResult_e mspFcProcessInCommand(uint8_t cmdMSP, sbuf_t *src)
masterConfig.accelerometerTrims.values.roll = sbufReadU16(src);
break;
case MSP_SET_ARMING_CONFIG:
masterConfig.armingConfig.auto_disarm_delay = sbufReadU8(src);
masterConfig.armingConfig.disarm_kill_switch = sbufReadU8(src);
armingConfig()->auto_disarm_delay = sbufReadU8(src);
armingConfig()->disarm_kill_switch = sbufReadU8(src);
break;
case MSP_SET_LOOP_TIME:
@ -1335,7 +1335,7 @@ static mspResult_e mspFcProcessInCommand(uint8_t cmdMSP, sbuf_t *src)
case MSP_SET_MISC:
tmp = sbufReadU16(src);
if (tmp < 1600 && tmp > 1400)
masterConfig.rxConfig.midrc = tmp;
rxConfig()->midrc = tmp;
motorConfig()->minthrottle = sbufReadU16(src);
motorConfig()->maxthrottle = sbufReadU16(src);
@ -1353,7 +1353,7 @@ static mspResult_e mspFcProcessInCommand(uint8_t cmdMSP, sbuf_t *src)
sbufReadU8(src); // gps_ubx_sbas
#endif
batteryConfig()->multiwiiCurrentMeterOutput = sbufReadU8(src);
masterConfig.rxConfig.rssi_channel = sbufReadU8(src);
rxConfig()->rssi_channel = sbufReadU8(src);
sbufReadU8(src);
compassConfig()->mag_declination = sbufReadU16(src) * 10;
@ -1664,29 +1664,29 @@ static mspResult_e mspFcProcessInCommand(uint8_t cmdMSP, sbuf_t *src)
#ifndef USE_QUAD_MIXER_ONLY
case MSP_SET_MIXER:
masterConfig.mixerConfig.mixerMode = sbufReadU8(src);
mixerConfig()->mixerMode = sbufReadU8(src);
break;
#endif
case MSP_SET_RX_CONFIG:
masterConfig.rxConfig.serialrx_provider = sbufReadU8(src);
masterConfig.rxConfig.maxcheck = sbufReadU16(src);
masterConfig.rxConfig.midrc = sbufReadU16(src);
masterConfig.rxConfig.mincheck = sbufReadU16(src);
masterConfig.rxConfig.spektrum_sat_bind = sbufReadU8(src);
rxConfig()->serialrx_provider = sbufReadU8(src);
rxConfig()->maxcheck = sbufReadU16(src);
rxConfig()->midrc = sbufReadU16(src);
rxConfig()->mincheck = sbufReadU16(src);
rxConfig()->spektrum_sat_bind = sbufReadU8(src);
if (dataSize > 8) {
masterConfig.rxConfig.rx_min_usec = sbufReadU16(src);
masterConfig.rxConfig.rx_max_usec = sbufReadU16(src);
rxConfig()->rx_min_usec = sbufReadU16(src);
rxConfig()->rx_max_usec = sbufReadU16(src);
}
if (dataSize > 12) {
masterConfig.rxConfig.rcInterpolation = sbufReadU8(src);
masterConfig.rxConfig.rcInterpolationInterval = sbufReadU8(src);
masterConfig.rxConfig.airModeActivateThreshold = sbufReadU16(src);
rxConfig()->rcInterpolation = sbufReadU8(src);
rxConfig()->rcInterpolationInterval = sbufReadU8(src);
rxConfig()->airModeActivateThreshold = sbufReadU16(src);
}
if (dataSize > 16) {
masterConfig.rxConfig.rx_spi_protocol = sbufReadU8(src);
masterConfig.rxConfig.rx_spi_id = sbufReadU32(src);
masterConfig.rxConfig.rx_spi_rf_channel_count = sbufReadU8(src);
rxConfig()->rx_spi_protocol = sbufReadU8(src);
rxConfig()->rx_spi_id = sbufReadU32(src);
rxConfig()->rx_spi_rf_channel_count = sbufReadU8(src);
}
break;
@ -1702,20 +1702,20 @@ static mspResult_e mspFcProcessInCommand(uint8_t cmdMSP, sbuf_t *src)
case MSP_SET_RXFAIL_CONFIG:
i = sbufReadU8(src);
if (i < MAX_SUPPORTED_RC_CHANNEL_COUNT) {
masterConfig.rxConfig.failsafe_channel_configurations[i].mode = sbufReadU8(src);
masterConfig.rxConfig.failsafe_channel_configurations[i].step = CHANNEL_VALUE_TO_RXFAIL_STEP(sbufReadU16(src));
rxConfig()->failsafe_channel_configurations[i].mode = sbufReadU8(src);
rxConfig()->failsafe_channel_configurations[i].step = CHANNEL_VALUE_TO_RXFAIL_STEP(sbufReadU16(src));
} else {
return MSP_RESULT_ERROR;
}
break;
case MSP_SET_RSSI_CONFIG:
masterConfig.rxConfig.rssi_channel = sbufReadU8(src);
rxConfig()->rssi_channel = sbufReadU8(src);
break;
case MSP_SET_RX_MAP:
for (int i = 0; i < MAX_MAPPABLE_RX_INPUTS; i++) {
masterConfig.rxConfig.rcmap[i] = sbufReadU8(src);
rxConfig()->rcmap[i] = sbufReadU8(src);
}
break;
@ -1723,13 +1723,13 @@ static mspResult_e mspFcProcessInCommand(uint8_t cmdMSP, sbuf_t *src)
#ifdef USE_QUAD_MIXER_ONLY
sbufReadU8(src); // mixerMode ignored
#else
masterConfig.mixerConfig.mixerMode = sbufReadU8(src); // mixerMode
mixerConfig()->mixerMode = sbufReadU8(src); // mixerMode
#endif
featureClearAll();
featureSet(sbufReadU32(src)); // features bitmap
masterConfig.rxConfig.serialrx_provider = sbufReadU8(src); // serialrx_type
rxConfig()->serialrx_provider = sbufReadU8(src); // serialrx_type
boardAlignment()->rollDegrees = sbufReadU16(src); // board_align_roll
boardAlignment()->pitchDegrees = sbufReadU16(src); // board_align_pitch

4
src/main/fc/fc_tasks.c
View File

@ -255,10 +255,10 @@ void fcTasksInit(void)
#ifdef TELEMETRY
setTaskEnabled(TASK_TELEMETRY, feature(FEATURE_TELEMETRY));
if (feature(FEATURE_TELEMETRY)) {
if (masterConfig.rxConfig.serialrx_provider == SERIALRX_JETIEXBUS) {
if (rxConfig()->serialrx_provider == SERIALRX_JETIEXBUS) {
// Reschedule telemetry to 500hz for Jeti Exbus
rescheduleTask(TASK_TELEMETRY, TASK_PERIOD_HZ(500));
} else if (masterConfig.rxConfig.serialrx_provider == SERIALRX_CRSF) {
} else if (rxConfig()->serialrx_provider == SERIALRX_CRSF) {
// Reschedule telemetry to 500hz, 2ms for CRSF
rescheduleTask(TASK_TELEMETRY, TASK_PERIOD_HZ(500));
}

56
src/main/fc/mw.c
View File

@ -183,15 +183,15 @@ void calculateSetpointRate(int axis, int16_t rc) {
}
void scaleRcCommandToFpvCamAngle(void) {
//recalculate sin/cos only when masterConfig.rxConfig.fpvCamAngleDegrees changed
//recalculate sin/cos only when rxConfig()->fpvCamAngleDegrees changed
static uint8_t lastFpvCamAngleDegrees = 0;
static float cosFactor = 1.0;
static float sinFactor = 0.0;
if (lastFpvCamAngleDegrees != masterConfig.rxConfig.fpvCamAngleDegrees){
lastFpvCamAngleDegrees = masterConfig.rxConfig.fpvCamAngleDegrees;
cosFactor = cos_approx(masterConfig.rxConfig.fpvCamAngleDegrees * RAD);
sinFactor = sin_approx(masterConfig.rxConfig.fpvCamAngleDegrees * RAD);
if (lastFpvCamAngleDegrees != rxConfig()->fpvCamAngleDegrees){
lastFpvCamAngleDegrees = rxConfig()->fpvCamAngleDegrees;
cosFactor = cos_approx(rxConfig()->fpvCamAngleDegrees * RAD);
sinFactor = sin_approx(rxConfig()->fpvCamAngleDegrees * RAD);
}
int16_t roll = rcCommand[ROLL];
@ -208,15 +208,15 @@ void processRcCommand(void)
uint16_t rxRefreshRate;
bool readyToCalculateRate = false;
if (masterConfig.rxConfig.rcInterpolation || flightModeFlags) {
if (rxConfig()->rcInterpolation || flightModeFlags) {
if (isRXDataNew) {
// Set RC refresh rate for sampling and channels to filter
switch (masterConfig.rxConfig.rcInterpolation) {
switch (rxConfig()->rcInterpolation) {
case(RC_SMOOTHING_AUTO):
rxRefreshRate = constrain(getTaskDeltaTime(TASK_RX), 1000, 20000) + 1000; // Add slight overhead to prevent ramps
break;
case(RC_SMOOTHING_MANUAL):
rxRefreshRate = 1000 * masterConfig.rxConfig.rcInterpolationInterval;
rxRefreshRate = 1000 * rxConfig()->rcInterpolationInterval;
break;
case(RC_SMOOTHING_OFF):
case(RC_SMOOTHING_DEFAULT):
@ -255,7 +255,7 @@ void processRcCommand(void)
if (readyToCalculateRate || isRXDataNew) {
// Scaling of AngleRate to camera angle (Mixing Roll and Yaw)
if (masterConfig.rxConfig.fpvCamAngleDegrees && IS_RC_MODE_ACTIVE(BOXFPVANGLEMIX) && !FLIGHT_MODE(HEADFREE_MODE))
if (rxConfig()->fpvCamAngleDegrees && IS_RC_MODE_ACTIVE(BOXFPVANGLEMIX) && !FLIGHT_MODE(HEADFREE_MODE))
scaleRcCommandToFpvCamAngle();
for (int axis = 0; axis < 3; axis++) calculateSetpointRate(axis, rcCommand[axis]);
@ -282,7 +282,7 @@ void updateRcCommands(void)
// non coupled PID reduction scaler used in PID controller 1 and PID controller 2.
PIDweight[axis] = prop;
int32_t tmp = MIN(ABS(rcData[axis] - masterConfig.rxConfig.midrc), 500);
int32_t tmp = MIN(ABS(rcData[axis] - rxConfig()->midrc), 500);
if (axis == ROLL || axis == PITCH) {
if (tmp > rcControlsConfig()->deadband) {
tmp -= rcControlsConfig()->deadband;
@ -298,7 +298,7 @@ void updateRcCommands(void)
}
rcCommand[axis] = tmp * -rcControlsConfig()->yaw_control_direction;
}
if (rcData[axis] < masterConfig.rxConfig.midrc) {
if (rcData[axis] < rxConfig()->midrc) {
rcCommand[axis] = -rcCommand[axis];
}
}
@ -308,14 +308,14 @@ void updateRcCommands(void)
tmp = constrain(rcData[THROTTLE], PWM_RANGE_MIN, PWM_RANGE_MAX);
tmp = (uint32_t)(tmp - PWM_RANGE_MIN);
} else {
tmp = constrain(rcData[THROTTLE], masterConfig.rxConfig.mincheck, PWM_RANGE_MAX);
tmp = (uint32_t)(tmp - masterConfig.rxConfig.mincheck) * PWM_RANGE_MIN / (PWM_RANGE_MAX - masterConfig.rxConfig.mincheck);
tmp = constrain(rcData[THROTTLE], rxConfig()->mincheck, PWM_RANGE_MAX);
tmp = (uint32_t)(tmp - rxConfig()->mincheck) * PWM_RANGE_MIN / (PWM_RANGE_MAX - rxConfig()->mincheck);
}
rcCommand[THROTTLE] = rcLookupThrottle(tmp);
if (feature(FEATURE_3D) && IS_RC_MODE_ACTIVE(BOX3DDISABLESWITCH) && !failsafeIsActive()) {
fix12_t throttleScaler = qConstruct(rcCommand[THROTTLE] - 1000, 1000);
rcCommand[THROTTLE] = masterConfig.rxConfig.midrc + qMultiply(throttleScaler, PWM_RANGE_MAX - masterConfig.rxConfig.midrc);
rcCommand[THROTTLE] = rxConfig()->midrc + qMultiply(throttleScaler, PWM_RANGE_MAX - rxConfig()->midrc);
}
if (FLIGHT_MODE(HEADFREE_MODE)) {
@ -387,7 +387,7 @@ void mwArm(void)
{
static bool firstArmingCalibrationWasCompleted;
if (masterConfig.armingConfig.gyro_cal_on_first_arm && !firstArmingCalibrationWasCompleted) {
if (armingConfig()->gyro_cal_on_first_arm && !firstArmingCalibrationWasCompleted) {
gyroSetCalibrationCycles();
armingCalibrationWasInitialised = true;
firstArmingCalibrationWasCompleted = true;
@ -416,7 +416,7 @@ void mwArm(void)
startBlackbox();
}
#endif
disarmAt = millis() + masterConfig.armingConfig.auto_disarm_delay * 1000; // start disarm timeout, will be extended when throttle is nonzero
disarmAt = millis() + armingConfig()->auto_disarm_delay * 1000; // start disarm timeout, will be extended when throttle is nonzero
//beep to indicate arming
#ifdef GPS
@ -462,7 +462,7 @@ void handleInflightCalibrationStickPosition(void)
static void updateInflightCalibrationState(void)
{
if (AccInflightCalibrationArmed && ARMING_FLAG(ARMED) && rcData[THROTTLE] > masterConfig.rxConfig.mincheck && !IS_RC_MODE_ACTIVE(BOXARM)) { // Copter is airborne and you are turning it off via boxarm : start measurement
if (AccInflightCalibrationArmed && ARMING_FLAG(ARMED) && rcData[THROTTLE] > rxConfig()->mincheck && !IS_RC_MODE_ACTIVE(BOXARM)) { // Copter is airborne and you are turning it off via boxarm : start measurement
InflightcalibratingA = 50;
AccInflightCalibrationArmed = false;
}
@ -518,7 +518,7 @@ void processRx(uint32_t currentTime)
throttleStatus_e throttleStatus = calculateThrottleStatus(&masterConfig.rxConfig, flight3DConfig()->deadband3d_throttle);
if (isAirmodeActive() && ARMING_FLAG(ARMED)) {
if (rcCommand[THROTTLE] >= masterConfig.rxConfig.airModeActivateThreshold) airmodeIsActivated = true; // Prevent Iterm from being reset
if (rcCommand[THROTTLE] >= rxConfig()->airModeActivateThreshold) airmodeIsActivated = true; // Prevent Iterm from being reset
} else {
airmodeIsActivated = false;
}
@ -546,7 +546,7 @@ void processRx(uint32_t currentTime)
) {
if (isUsingSticksForArming()) {
if (throttleStatus == THROTTLE_LOW) {
if (masterConfig.armingConfig.auto_disarm_delay != 0
if (armingConfig()->auto_disarm_delay != 0
&& (int32_t)(disarmAt - millis()) < 0
) {
// auto-disarm configured and delay is over
@ -559,9 +559,9 @@ void processRx(uint32_t currentTime)
}
} else {
// throttle is not low
if (masterConfig.armingConfig.auto_disarm_delay != 0) {
if (armingConfig()->auto_disarm_delay != 0) {
// extend disarm time
disarmAt = millis() + masterConfig.armingConfig.auto_disarm_delay * 1000;
disarmAt = millis() + armingConfig()->auto_disarm_delay * 1000;
}
if (armedBeeperOn) {
@ -581,7 +581,7 @@ void processRx(uint32_t currentTime)
}
}
processRcStickPositions(&masterConfig.rxConfig, throttleStatus, masterConfig.armingConfig.disarm_kill_switch);
processRcStickPositions(&masterConfig.rxConfig, throttleStatus, armingConfig()->disarm_kill_switch);
if (feature(FEATURE_INFLIGHT_ACC_CAL)) {
updateInflightCalibrationState();
@ -659,7 +659,7 @@ void processRx(uint32_t currentTime)
DISABLE_FLIGHT_MODE(PASSTHRU_MODE);
}
if (masterConfig.mixerConfig.mixerMode == MIXER_FLYING_WING || masterConfig.mixerConfig.mixerMode == MIXER_AIRPLANE) {
if (mixerConfig()->mixerMode == MIXER_FLYING_WING || mixerConfig()->mixerMode == MIXER_AIRPLANE) {
DISABLE_FLIGHT_MODE(HEADFREE_MODE);
}
@ -691,7 +691,7 @@ void subTaskPidController(void)
&currentProfile->pidProfile,
masterConfig.max_angle_inclination,
&masterConfig.accelerometerTrims,
masterConfig.rxConfig.midrc
rxConfig()->midrc
);
if (debugMode == DEBUG_PIDLOOP || debugMode == DEBUG_SCHEDULER) {debug[1] = micros() - startTime;}
}
@ -730,13 +730,13 @@ void subTaskMainSubprocesses(void)
// sticks, do not process yaw input from the rx. We do this so the
// motors do not spin up while we are trying to arm or disarm.
// Allow yaw control for tricopters if the user wants the servo to move even when unarmed.
if (isUsingSticksForArming() && rcData[THROTTLE] <= masterConfig.rxConfig.mincheck
if (isUsingSticksForArming() && rcData[THROTTLE] <= rxConfig()->mincheck
#ifndef USE_QUAD_MIXER_ONLY
#ifdef USE_SERVOS
&& !((masterConfig.mixerConfig.mixerMode == MIXER_TRI || masterConfig.mixerConfig.mixerMode == MIXER_CUSTOM_TRI) && servoMixerConfig()->tri_unarmed_servo)
&& !((mixerConfig()->mixerMode == MIXER_TRI || mixerConfig()->mixerMode == MIXER_CUSTOM_TRI) && servoMixerConfig()->tri_unarmed_servo)
#endif
&& masterConfig.mixerConfig.mixerMode != MIXER_AIRPLANE
&& masterConfig.mixerConfig.mixerMode != MIXER_FLYING_WING
&& mixerConfig()->mixerMode != MIXER_AIRPLANE
&& mixerConfig()->mixerMode != MIXER_FLYING_WING
#endif
) {
rcCommand[YAW] = 0;

68
src/main/io/serial_cli.c
View File

@ -686,17 +686,17 @@ typedef struct {
} clivalue_t;
const clivalue_t valueTable[] = {
{ "mid_rc", VAR_UINT16 | MASTER_VALUE, &masterConfig.rxConfig.midrc, .config.minmax = { 1200, 1700 } },
{ "min_check", VAR_UINT16 | MASTER_VALUE, &masterConfig.rxConfig.mincheck, .config.minmax = { PWM_RANGE_ZERO, PWM_RANGE_MAX } },
{ "max_check", VAR_UINT16 | MASTER_VALUE, &masterConfig.rxConfig.maxcheck, .config.minmax = { PWM_RANGE_ZERO, PWM_RANGE_MAX } },
{ "rssi_channel", VAR_INT8 | MASTER_VALUE, &masterConfig.rxConfig.rssi_channel, .config.minmax = { 0, MAX_SUPPORTED_RC_CHANNEL_COUNT } },
{ "rssi_scale", VAR_UINT8 | MASTER_VALUE, &masterConfig.rxConfig.rssi_scale, .config.minmax = { RSSI_SCALE_MIN, RSSI_SCALE_MAX } },
{ "rc_interpolation", VAR_UINT8 | MASTER_VALUE | MODE_LOOKUP, &masterConfig.rxConfig.rcInterpolation, .config.lookup = { TABLE_RC_INTERPOLATION } },
{ "rc_interpolation_interval", VAR_UINT8 | MASTER_VALUE, &masterConfig.rxConfig.rcInterpolationInterval, .config.minmax = { 1, 50 } },
{ "rssi_ppm_invert", VAR_INT8 | MASTER_VALUE | MODE_LOOKUP, &masterConfig.rxConfig.rssi_ppm_invert, .config.lookup = { TABLE_OFF_ON } },
{ "mid_rc", VAR_UINT16 | MASTER_VALUE, &rxConfig()->midrc, .config.minmax = { 1200, 1700 } },
{ "min_check", VAR_UINT16 | MASTER_VALUE, &rxConfig()->mincheck, .config.minmax = { PWM_RANGE_ZERO, PWM_RANGE_MAX } },
{ "max_check", VAR_UINT16 | MASTER_VALUE, &rxConfig()->maxcheck, .config.minmax = { PWM_RANGE_ZERO, PWM_RANGE_MAX } },
{ "rssi_channel", VAR_INT8 | MASTER_VALUE, &rxConfig()->rssi_channel, .config.minmax = { 0, MAX_SUPPORTED_RC_CHANNEL_COUNT } },
{ "rssi_scale", VAR_UINT8 | MASTER_VALUE, &rxConfig()->rssi_scale, .config.minmax = { RSSI_SCALE_MIN, RSSI_SCALE_MAX } },
{ "rc_interpolation", VAR_UINT8 | MASTER_VALUE | MODE_LOOKUP, &rxConfig()->rcInterpolation, .config.lookup = { TABLE_RC_INTERPOLATION } },
{ "rc_interpolation_interval", VAR_UINT8 | MASTER_VALUE, &rxConfig()->rcInterpolationInterval, .config.minmax = { 1, 50 } },
{ "rssi_ppm_invert", VAR_INT8 | MASTER_VALUE | MODE_LOOKUP, &rxConfig()->rssi_ppm_invert, .config.lookup = { TABLE_OFF_ON } },
{ "input_filtering_mode", VAR_INT8 | MASTER_VALUE | MODE_LOOKUP, &masterConfig.inputFilteringMode, .config.lookup = { TABLE_OFF_ON } },
{ "roll_yaw_cam_mix_degrees", VAR_UINT8 | MASTER_VALUE, &masterConfig.rxConfig.fpvCamAngleDegrees, .config.minmax = { 0, 50 } },
{ "max_aux_channels", VAR_UINT8 | MASTER_VALUE, &masterConfig.rxConfig.max_aux_channel, .config.minmax = { 0, 13 } },
{ "roll_yaw_cam_mix_degrees", VAR_UINT8 | MASTER_VALUE, &rxConfig()->fpvCamAngleDegrees, .config.minmax = { 0, 50 } },
{ "max_aux_channels", VAR_UINT8 | MASTER_VALUE, &rxConfig()->max_aux_channel, .config.minmax = { 0, 13 } },
{ "debug_mode", VAR_UINT8 | MASTER_VALUE | MODE_LOOKUP, &masterConfig.debug_mode, .config.lookup = { TABLE_DEBUG } },
{ "min_throttle", VAR_UINT16 | MASTER_VALUE, &motorConfig()->minthrottle, .config.minmax = { PWM_RANGE_ZERO, PWM_RANGE_MAX } },
@ -716,12 +716,12 @@ const clivalue_t valueTable[] = {
{ "motor_pwm_protocol", VAR_UINT8 | MASTER_VALUE | MODE_LOOKUP, &motorConfig()->motorPwmProtocol, .config.lookup = { TABLE_MOTOR_PWM_PROTOCOL } },
{ "motor_pwm_rate", VAR_UINT16 | MASTER_VALUE, &motorConfig()->motorPwmRate, .config.minmax = { 200, 32000 } },
{ "disarm_kill_switch", VAR_UINT8 | MASTER_VALUE | MODE_LOOKUP, &masterConfig.armingConfig.disarm_kill_switch, .config.lookup = { TABLE_OFF_ON } },
{ "gyro_cal_on_first_arm", VAR_UINT8 | MASTER_VALUE | MODE_LOOKUP, &masterConfig.armingConfig.gyro_cal_on_first_arm, .config.lookup = { TABLE_OFF_ON } },
{ "auto_disarm_delay", VAR_UINT8 | MASTER_VALUE, &masterConfig.armingConfig.auto_disarm_delay, .config.minmax = { 0, 60 } },
{ "disarm_kill_switch", VAR_UINT8 | MASTER_VALUE | MODE_LOOKUP, &armingConfig()->disarm_kill_switch, .config.lookup = { TABLE_OFF_ON } },
{ "gyro_cal_on_first_arm", VAR_UINT8 | MASTER_VALUE | MODE_LOOKUP, &armingConfig()->gyro_cal_on_first_arm, .config.lookup = { TABLE_OFF_ON } },
{ "auto_disarm_delay", VAR_UINT8 | MASTER_VALUE, &armingConfig()->auto_disarm_delay, .config.minmax = { 0, 60 } },
{ "small_angle", VAR_UINT8 | MASTER_VALUE, &imuConfig()->small_angle, .config.minmax = { 0, 180 } },
{ "fixedwing_althold_dir", VAR_INT8 | MASTER_VALUE, &masterConfig.airplaneConfig.fixedwing_althold_dir, .config.minmax = { -1, 1 } },
{ "fixedwing_althold_dir", VAR_INT8 | MASTER_VALUE, &airplaneConfig()->fixedwing_althold_dir, .config.minmax = { -1, 1 } },
{ "reboot_character", VAR_UINT8 | MASTER_VALUE, &masterConfig.serialConfig.reboot_character, .config.minmax = { 48, 126 } },
@ -765,14 +765,14 @@ const clivalue_t valueTable[] = {
#endif
#ifdef SERIAL_RX
{ "serialrx_provider", VAR_UINT8 | MASTER_VALUE | MODE_LOOKUP, &masterConfig.rxConfig.serialrx_provider, .config.lookup = { TABLE_SERIAL_RX } },
{ "serialrx_provider", VAR_UINT8 | MASTER_VALUE | MODE_LOOKUP, &rxConfig()->serialrx_provider, .config.lookup = { TABLE_SERIAL_RX } },
#endif
{ "sbus_inversion", VAR_UINT8 | MASTER_VALUE | MODE_LOOKUP, &masterConfig.rxConfig.sbus_inversion, .config.lookup = { TABLE_OFF_ON } },
{ "sbus_inversion", VAR_UINT8 | MASTER_VALUE | MODE_LOOKUP, &rxConfig()->sbus_inversion, .config.lookup = { TABLE_OFF_ON } },
#ifdef SPEKTRUM_BIND
{ "spektrum_sat_bind", VAR_UINT8 | MASTER_VALUE, &masterConfig.rxConfig.spektrum_sat_bind, .config.minmax = { SPEKTRUM_SAT_BIND_DISABLED, SPEKTRUM_SAT_BIND_MAX} },
{ "spektrum_sat_bind_autoreset",VAR_UINT8 | MASTER_VALUE, &masterConfig.rxConfig.spektrum_sat_bind_autoreset, .config.minmax = { 0, 1} },
{ "spektrum_sat_bind", VAR_UINT8 | MASTER_VALUE, &rxConfig()->spektrum_sat_bind, .config.minmax = { SPEKTRUM_SAT_BIND_DISABLED, SPEKTRUM_SAT_BIND_MAX} },
{ "spektrum_sat_bind_autoreset",VAR_UINT8 | MASTER_VALUE, &rxConfig()->spektrum_sat_bind_autoreset, .config.minmax = { 0, 1} },
#endif
#ifdef TELEMETRY
@ -833,7 +833,7 @@ const clivalue_t valueTable[] = {
{ "yaw_control_direction", VAR_INT8 | MASTER_VALUE, &rcControlsConfig()->yaw_control_direction, .config.minmax = { -1, 1 } },
{ "yaw_motor_direction", VAR_INT8 | MASTER_VALUE, &masterConfig.mixerConfig.yaw_motor_direction, .config.minmax = { -1, 1 } },
{ "yaw_motor_direction", VAR_INT8 | MASTER_VALUE, &mixerConfig()->yaw_motor_direction, .config.minmax = { -1, 1 } },
{ "yaw_p_limit", VAR_UINT16 | PROFILE_VALUE, &masterConfig.profile[0].pidProfile.yaw_p_limit, .config.minmax = { YAW_P_LIMIT_MIN, YAW_P_LIMIT_MAX } },
{ "pidsum_limit", VAR_FLOAT | PROFILE_VALUE, &masterConfig.profile[0].pidProfile.pidSumLimit, .config.minmax = { 0.1, 1.0 } },
#ifdef USE_SERVOS
@ -856,7 +856,7 @@ const clivalue_t valueTable[] = {
{ "yaw_srate", VAR_UINT8 | PROFILE_RATE_VALUE, &masterConfig.profile[0].controlRateProfile[0].rates[FD_YAW], .config.minmax = { 0, CONTROL_RATE_CONFIG_YAW_RATE_MAX } },
{ "tpa_rate", VAR_UINT8 | PROFILE_RATE_VALUE, &masterConfig.profile[0].controlRateProfile[0].dynThrPID, .config.minmax = { 0, CONTROL_RATE_CONFIG_TPA_MAX} },
{ "tpa_breakpoint", VAR_UINT16 | PROFILE_RATE_VALUE, &masterConfig.profile[0].controlRateProfile[0].tpa_breakpoint, .config.minmax = { PWM_RANGE_MIN, PWM_RANGE_MAX} },
{ "airmode_activate_throttle", VAR_UINT16 | MASTER_VALUE, &masterConfig.rxConfig.airModeActivateThreshold, .config.minmax = {1000, 2000 } },
{ "airmode_activate_throttle", VAR_UINT16 | MASTER_VALUE, &rxConfig()->airModeActivateThreshold, .config.minmax = {1000, 2000 } },
{ "failsafe_delay", VAR_UINT8 | MASTER_VALUE, &masterConfig.failsafeConfig.failsafe_delay, .config.minmax = { 0, 200 } },
{ "failsafe_off_delay", VAR_UINT8 | MASTER_VALUE, &masterConfig.failsafeConfig.failsafe_off_delay, .config.minmax = { 0, 200 } },
@ -865,8 +865,8 @@ const clivalue_t valueTable[] = {
{ "failsafe_throttle_low_delay",VAR_UINT16 | MASTER_VALUE, &masterConfig.failsafeConfig.failsafe_throttle_low_delay, .config.minmax = { 0, 300 } },
{ "failsafe_procedure", VAR_UINT8 | MASTER_VALUE | MODE_LOOKUP, &masterConfig.failsafeConfig.failsafe_procedure, .config.lookup = { TABLE_FAILSAFE } },
{ "rx_min_usec", VAR_UINT16 | MASTER_VALUE, &masterConfig.rxConfig.rx_min_usec, .config.minmax = { PWM_PULSE_MIN, PWM_PULSE_MAX } },
{ "rx_max_usec", VAR_UINT16 | MASTER_VALUE, &masterConfig.rxConfig.rx_max_usec, .config.minmax = { PWM_PULSE_MIN, PWM_PULSE_MAX } },
{ "rx_min_usec", VAR_UINT16 | MASTER_VALUE, &rxConfig()->rx_min_usec, .config.minmax = { PWM_PULSE_MIN, PWM_PULSE_MAX } },
{ "rx_max_usec", VAR_UINT16 | MASTER_VALUE, &rxConfig()->rx_max_usec, .config.minmax = { PWM_PULSE_MIN, PWM_PULSE_MAX } },
{ "acc_hardware", VAR_UINT8 | MASTER_VALUE | MODE_LOOKUP, &sensorSelectionConfig()->acc_hardware, .config.lookup = { TABLE_ACC_HARDWARE } },
{ "acc_lpf_hz", VAR_UINT16 | MASTER_VALUE, &accelerometerConfig()->acc_lpf_hz, .config.minmax = { 0, 400 } },
@ -1080,7 +1080,7 @@ static void printRxFail(uint8_t dumpMask, master_t *defaultConfig)
bool equalsDefault;
bool requireValue;
for (uint32_t channel = 0; channel < MAX_SUPPORTED_RC_CHANNEL_COUNT; channel++) {
channelFailsafeConfiguration = &masterConfig.rxConfig.failsafe_channel_configurations[channel];
channelFailsafeConfiguration = &rxConfig()->failsafe_channel_configurations[channel];
channelFailsafeConfigurationDefault = &defaultConfig->rxConfig.failsafe_channel_configurations[channel];
equalsDefault = channelFailsafeConfiguration->mode == channelFailsafeConfigurationDefault->mode
&& channelFailsafeConfiguration->step == channelFailsafeConfigurationDefault->step;
@ -1126,7 +1126,7 @@ static void cliRxFail(char *cmdline)
channel = atoi(ptr++);
if ((channel < MAX_SUPPORTED_RC_CHANNEL_COUNT)) {
rxFailsafeChannelConfiguration_t *channelFailsafeConfiguration = &masterConfig.rxConfig.failsafe_channel_configurations[channel];
rxFailsafeChannelConfiguration_t *channelFailsafeConfiguration = &rxConfig()->failsafe_channel_configurations[channel];
uint16_t value;
rxFailsafeChannelType_e type = (channel < NON_AUX_CHANNEL_COUNT) ? RX_FAILSAFE_TYPE_FLIGHT : RX_FAILSAFE_TYPE_AUX;
@ -1672,7 +1672,7 @@ static void printRxRange(uint8_t dumpMask, master_t *defaultConfig)
rxChannelRangeConfiguration_t *channelRangeConfigurationDefault;
bool equalsDefault;
for (uint32_t i = 0; i < NON_AUX_CHANNEL_COUNT; i++) {
channelRangeConfiguration = &masterConfig.rxConfig.channelRanges[i];
channelRangeConfiguration = &rxConfig()->channelRanges[i];
channelRangeConfigurationDefault = &defaultConfig->rxConfig.channelRanges[i];
equalsDefault = channelRangeConfiguration->min == channelRangeConfigurationDefault->min
&& channelRangeConfiguration->max == channelRangeConfigurationDefault->max;
@ -1698,7 +1698,7 @@ static void cliRxRange(char *cmdline)
if (isEmpty(cmdline)) {
printRxRange(DUMP_MASTER, NULL);
} else if (strcasecmp(cmdline, "reset") == 0) {
resetAllRxChannelRangeConfigurations(masterConfig.rxConfig.channelRanges);
resetAllRxChannelRangeConfigurations(rxConfig()->channelRanges);
} else {
ptr = cmdline;
i = atoi(ptr);
@ -1722,7 +1722,7 @@ static void cliRxRange(char *cmdline)
} else if (rangeMin < PWM_PULSE_MIN || rangeMin > PWM_PULSE_MAX || rangeMax < PWM_PULSE_MIN || rangeMax > PWM_PULSE_MAX) {
cliShowParseError();
} else {
rxChannelRangeConfiguration_t *channelRangeConfiguration = &masterConfig.rxConfig.channelRanges[i];
rxChannelRangeConfiguration_t *channelRangeConfiguration = &rxConfig()->channelRanges[i];
channelRangeConfiguration->min = rangeMin;
channelRangeConfiguration->max = rangeMax;
}
@ -2602,9 +2602,9 @@ static void printMap(uint8_t dumpMask, master_t *defaultConfig)
char bufDefault[16];
uint32_t i;
for (i = 0; i < MAX_MAPPABLE_RX_INPUTS; i++) {
buf[masterConfig.rxConfig.rcmap[i]] = rcChannelLetters[i];
buf[rxConfig()->rcmap[i]] = rcChannelLetters[i];
bufDefault[defaultConfig->rxConfig.rcmap[i]] = rcChannelLetters[i];
equalsDefault = equalsDefault && (masterConfig.rxConfig.rcmap[i] == defaultConfig->rxConfig.rcmap[i]);
equalsDefault = equalsDefault && (rxConfig()->rcmap[i] == defaultConfig->rxConfig.rcmap[i]);
}
buf[i] = '\0';
@ -2635,7 +2635,7 @@ static void cliMap(char *cmdline)
cliPrint("Map: ");
uint32_t i;
for (i = 0; i < 8; i++)
out[masterConfig.rxConfig.rcmap[i]] = rcChannelLetters[i];
out[rxConfig()->rcmap[i]] = rcChannelLetters[i];
out[i] = '\0';
cliPrintf("%s\r\n", out);
}
@ -2788,10 +2788,10 @@ static void printConfig(char *cmdline, bool doDiff)
#ifndef CLI_MINIMAL_VERBOSITY
cliPrint("\r\n# mixer\r\n");
#endif
const bool equalsDefault = masterConfig.mixerConfig.mixerMode == defaultConfig.mixerConfig.mixerMode;
const bool equalsDefault = mixerConfig()->mixerMode == defaultConfig.mixerConfig.mixerMode;
const char *formatMixer = "mixer %s\r\n";
cliDefaultPrintf(dumpMask, equalsDefault, formatMixer, mixerNames[defaultConfig.mixerConfig.mixerMode - 1]);
cliDumpPrintf(dumpMask, equalsDefault, formatMixer, mixerNames[masterConfig.mixerConfig.mixerMode - 1]);
cliDumpPrintf(dumpMask, equalsDefault, formatMixer, mixerNames[mixerConfig()->mixerMode - 1]);
cliDumpPrintf(dumpMask, masterConfig.customMotorMixer[0].throttle == 0.0f, "\r\nmmix reset\r\n\r\n");
@ -3086,7 +3086,7 @@ static void cliMixer(char *cmdline)
len = strlen(cmdline);
if (len == 0) {
cliPrintf("Mixer: %s\r\n", mixerNames[masterConfig.mixerConfig.mixerMode - 1]);
cliPrintf("Mixer: %s\r\n", mixerNames[mixerConfig()->mixerMode - 1]);
return;
} else if (strncasecmp(cmdline, "list", len) == 0) {
cliPrint("Available mixers: ");
@ -3105,7 +3105,7 @@ static void cliMixer(char *cmdline)
return;
}
if (strncasecmp(cmdline, mixerNames[i], len) == 0) {
masterConfig.mixerConfig.mixerMode = i + 1;
mixerConfig()->mixerMode = i + 1;
break;
}
}

6
src/main/main.c
View File

@ -220,7 +220,7 @@ void init(void)
#ifdef SPEKTRUM_BIND
if (feature(FEATURE_RX_SERIAL)) {
switch (masterConfig.rxConfig.serialrx_provider) {
switch (rxConfig()->serialrx_provider) {
case SERIALRX_SPEKTRUM1024:
case SERIALRX_SPEKTRUM2048:
// Spektrum satellite binding if enabled on startup.
@ -249,7 +249,7 @@ void init(void)
serialInit(&masterConfig.serialConfig, feature(FEATURE_SOFTSERIAL), SERIAL_PORT_NONE);
#endif
mixerInit(masterConfig.mixerConfig.mixerMode, masterConfig.customMotorMixer);
mixerInit(mixerConfig()->mixerMode, masterConfig.customMotorMixer);
#ifdef USE_SERVOS
servoMixerInit(masterConfig.customServoMixer);
#endif
@ -540,7 +540,7 @@ void init(void)
initBlackbox();
#endif
if (masterConfig.mixerConfig.mixerMode == MIXER_GIMBAL) {
if (mixerConfig()->mixerMode == MIXER_GIMBAL) {
accSetCalibrationCycles(CALIBRATING_ACC_CYCLES);
}
gyroSetCalibrationCycles();

74
src/main/target/COLIBRI_RACE/i2c_bst.c
View File

@ -556,7 +556,7 @@ static bool bstSlaveProcessFeedbackCommand(uint8_t bstRequest)
// DEPRECATED - Use MSP_API_VERSION
case BST_IDENT:
bstWrite8(MW_VERSION);
bstWrite8(masterConfig.mixerConfig.mixerMode);
bstWrite8(mixerConfig()->mixerMode);
bstWrite8(BST_PROTOCOL_VERSION);
bstWrite32(CAP_DYNBALANCE); // "capability"
break;
@ -683,8 +683,8 @@ static bool bstSlaveProcessFeedbackCommand(uint8_t bstRequest)
bstWrite16((int16_t)constrain(amperage, -0x8000, 0x7FFF)); // send amperage in 0.01 A steps, range is -320A to 320A
break;
case BST_ARMING_CONFIG:
bstWrite8(masterConfig.armingConfig.auto_disarm_delay);
bstWrite8(masterConfig.armingConfig.disarm_kill_switch);
bstWrite8(armingConfig()->auto_disarm_delay);
bstWrite8(armingConfig()->disarm_kill_switch);
break;
case BST_LOOP_TIME:
//bstWrite16(masterConfig.looptime);
@ -749,7 +749,7 @@ static bool bstSlaveProcessFeedbackCommand(uint8_t bstRequest)
}
break;
case BST_MISC:
bstWrite16(masterConfig.rxConfig.midrc);
bstWrite16(rxConfig()->midrc);
bstWrite16(motorConfig()->minthrottle);
bstWrite16(motorConfig()->maxthrottle);
@ -767,7 +767,7 @@ static bool bstSlaveProcessFeedbackCommand(uint8_t bstRequest)
bstWrite8(0); // gps_ubx_sbas
#endif
bstWrite8(batteryConfig()->multiwiiCurrentMeterOutput);
bstWrite8(masterConfig.rxConfig.rssi_channel);
bstWrite8(rxConfig()->rssi_channel);
bstWrite8(0);
bstWrite16(compassConfig()->mag_declination / 10);
@ -869,17 +869,17 @@ static bool bstSlaveProcessFeedbackCommand(uint8_t bstRequest)
break;
case BST_MIXER:
bstWrite8(masterConfig.mixerConfig.mixerMode);
bstWrite8(mixerConfig()->mixerMode);
break;
case BST_RX_CONFIG:
bstWrite8(masterConfig.rxConfig.serialrx_provider);
bstWrite16(masterConfig.rxConfig.maxcheck);
bstWrite16(masterConfig.rxConfig.midrc);
bstWrite16(masterConfig.rxConfig.mincheck);
bstWrite8(masterConfig.rxConfig.spektrum_sat_bind);
bstWrite16(masterConfig.rxConfig.rx_min_usec);
bstWrite16(masterConfig.rxConfig.rx_max_usec);
bstWrite8(rxConfig()->serialrx_provider);
bstWrite16(rxConfig()->maxcheck);
bstWrite16(rxConfig()->midrc);
bstWrite16(rxConfig()->mincheck);
bstWrite8(rxConfig()->spektrum_sat_bind);
bstWrite16(rxConfig()->rx_min_usec);
bstWrite16(rxConfig()->rx_max_usec);
break;
case BST_FAILSAFE_CONFIG:
@ -890,26 +890,26 @@ static bool bstSlaveProcessFeedbackCommand(uint8_t bstRequest)
case BST_RXFAIL_CONFIG:
for (i = NON_AUX_CHANNEL_COUNT; i < rxRuntimeConfig.channelCount; i++) {
bstWrite8(masterConfig.rxConfig.failsafe_channel_configurations[i].mode);
bstWrite16(RXFAIL_STEP_TO_CHANNEL_VALUE(masterConfig.rxConfig.failsafe_channel_configurations[i].step));
bstWrite8(rxConfig()->failsafe_channel_configurations[i].mode);
bstWrite16(RXFAIL_STEP_TO_CHANNEL_VALUE(rxConfig()->failsafe_channel_configurations[i].step));
}
break;
case BST_RSSI_CONFIG:
bstWrite8(masterConfig.rxConfig.rssi_channel);
bstWrite8(rxConfig()->rssi_channel);
break;
case BST_RX_MAP:
for (i = 0; i < MAX_MAPPABLE_RX_INPUTS; i++)
bstWrite8(masterConfig.rxConfig.rcmap[i]);
bstWrite8(rxConfig()->rcmap[i]);
break;
case BST_BF_CONFIG:
bstWrite8(masterConfig.mixerConfig.mixerMode);
bstWrite8(mixerConfig()->mixerMode);
bstWrite32(featureMask());
bstWrite8(masterConfig.rxConfig.serialrx_provider);
bstWrite8(rxConfig()->serialrx_provider);
bstWrite16(boardAlignment()->rollDegrees);
bstWrite16(boardAlignment()->pitchDegrees);
@ -1034,8 +1034,8 @@ static bool bstSlaveProcessWriteCommand(uint8_t bstWriteCommand)
masterConfig.accelerometerTrims.values.roll = bstRead16();
break;
case BST_SET_ARMING_CONFIG:
masterConfig.armingConfig.auto_disarm_delay = bstRead8();
masterConfig.armingConfig.disarm_kill_switch = bstRead8();
armingConfig()->auto_disarm_delay = bstRead8();
armingConfig()->disarm_kill_switch = bstRead8();
break;
case BST_SET_LOOP_TIME:
//masterConfig.looptime = bstRead16();
@ -1112,7 +1112,7 @@ static bool bstSlaveProcessWriteCommand(uint8_t bstWriteCommand)
case BST_SET_MISC:
tmp = bstRead16();
if (tmp < 1600 && tmp > 1400)
masterConfig.rxConfig.midrc = tmp;
rxConfig()->midrc = tmp;
motorConfig()->minthrottle = bstRead16();
motorConfig()->maxthrottle = bstRead16();
@ -1130,7 +1130,7 @@ static bool bstSlaveProcessWriteCommand(uint8_t bstWriteCommand)
bstRead8(); // gps_ubx_sbas
#endif
batteryConfig()->multiwiiCurrentMeterOutput = bstRead8();
masterConfig.rxConfig.rssi_channel = bstRead8();
rxConfig()->rssi_channel = bstRead8();
bstRead8();
compassConfig()->mag_declination = bstRead16() * 10;
@ -1274,19 +1274,19 @@ static bool bstSlaveProcessWriteCommand(uint8_t bstWriteCommand)
#ifndef USE_QUAD_MIXER_ONLY
case BST_SET_MIXER:
masterConfig.mixerConfig.mixerMode = bstRead8();
mixerConfig()->mixerMode = bstRead8();
break;
#endif
case BST_SET_RX_CONFIG:
masterConfig.rxConfig.serialrx_provider = bstRead8();
masterConfig.rxConfig.maxcheck = bstRead16();
masterConfig.rxConfig.midrc = bstRead16();
masterConfig.rxConfig.mincheck = bstRead16();
masterConfig.rxConfig.spektrum_sat_bind = bstRead8();
rxConfig()->serialrx_provider = bstRead8();
rxConfig()->maxcheck = bstRead16();
rxConfig()->midrc = bstRead16();
rxConfig()->mincheck = bstRead16();
rxConfig()->spektrum_sat_bind = bstRead8();
if (bstReadDataSize() > 8) {
masterConfig.rxConfig.rx_min_usec = bstRead16();
masterConfig.rxConfig.rx_max_usec = bstRead16();
rxConfig()->rx_min_usec = bstRead16();
rxConfig()->rx_max_usec = bstRead16();
}
break;
case BST_SET_FAILSAFE_CONFIG:
@ -1301,18 +1301,18 @@ static bool bstSlaveProcessWriteCommand(uint8_t bstWriteCommand)
ret = BST_FAILED;
} else {
for (i = NON_AUX_CHANNEL_COUNT; i < channelCount; i++) {
masterConfig.rxConfig.failsafe_channel_configurations[i].mode = bstRead8();
masterConfig.rxConfig.failsafe_channel_configurations[i].step = CHANNEL_VALUE_TO_RXFAIL_STEP(bstRead16());
rxConfig()->failsafe_channel_configurations[i].mode = bstRead8();
rxConfig()->failsafe_channel_configurations[i].step = CHANNEL_VALUE_TO_RXFAIL_STEP(bstRead16());
}
}
}
break;
case BST_SET_RSSI_CONFIG:
masterConfig.rxConfig.rssi_channel = bstRead8();
rxConfig()->rssi_channel = bstRead8();
break;
case BST_SET_RX_MAP:
for (i = 0; i < MAX_MAPPABLE_RX_INPUTS; i++) {
masterConfig.rxConfig.rcmap[i] = bstRead8();
rxConfig()->rcmap[i] = bstRead8();
}
break;
case BST_SET_BF_CONFIG:
@ -1320,13 +1320,13 @@ static bool bstSlaveProcessWriteCommand(uint8_t bstWriteCommand)
#ifdef USE_QUAD_MIXER_ONLY
bstRead8(); // mixerMode ignored
#else
masterConfig.mixerConfig.mixerMode = bstRead8(); // mixerMode
mixerConfig()->mixerMode = bstRead8(); // mixerMode
#endif
featureClearAll();
featureSet(bstRead32()); // features bitmap
masterConfig.rxConfig.serialrx_provider = bstRead8(); // serialrx_type
rxConfig()->serialrx_provider = bstRead8(); // serialrx_type
boardAlignment()->rollDegrees = bstRead16(); // board_align_roll
boardAlignment()->pitchDegrees = bstRead16(); // board_align_pitch

2
src/main/telemetry/mavlink.c
View File

@ -437,7 +437,7 @@ void mavlinkSendHUDAndHeartbeat(void)
mavModes |= MAV_MODE_FLAG_SAFETY_ARMED;
uint8_t mavSystemType;
switch(masterConfig.mixerConfig.mixerMode)
switch(mixerConfig()->mixerMode)
{
case MIXER_TRI:
mavSystemType = MAV_TYPE_TRICOPTER;