Robin Mueller
1742371c14
All checks were successful
EIVE/eive-obsw/pipeline/pr-develop This commit looks good
344 lines
14 KiB
C++
344 lines
14 KiB
C++
#include "AcsBoardAssembly.h"
|
|
|
|
#include <devices/gpioIds.h>
|
|
#include <fsfw/power/PowerSwitchIF.h>
|
|
#include <fsfw/serviceinterface.h>
|
|
|
|
AcsBoardAssembly::AcsBoardAssembly(object_id_t objectId, object_id_t parentId,
|
|
PowerSwitchIF* switcher, AcsBoardHelper helper, GpioIF* gpioIF)
|
|
: DualLaneAssemblyBase(objectId, parentId, switcher, SWITCH_A, SWITCH_B,
|
|
POWER_STATE_MACHINE_TIMEOUT),
|
|
helper(helper),
|
|
gpioIF(gpioIF) {
|
|
if (switcher == nullptr) {
|
|
sif::error << "AcsBoardAssembly::AcsBoardAssembly: Invalid Power Switcher "
|
|
"IF passed"
|
|
<< std::endl;
|
|
}
|
|
if (gpioIF == nullptr) {
|
|
sif::error << "AcsBoardAssembly::AcsBoardAssembly: Invalid GPIO IF passed" << std::endl;
|
|
}
|
|
ModeListEntry entry;
|
|
initModeTableEntry(helper.mgm0Lis3IdSideA, entry, modeTable);
|
|
initModeTableEntry(helper.mgm1Rm3100IdSideA, entry, modeTable);
|
|
initModeTableEntry(helper.mgm2Lis3IdSideB, entry, modeTable);
|
|
initModeTableEntry(helper.mgm3Rm3100IdSideB, entry, modeTable);
|
|
initModeTableEntry(helper.gyro0AdisIdSideA, entry, modeTable);
|
|
initModeTableEntry(helper.gyro1L3gIdSideA, entry, modeTable);
|
|
initModeTableEntry(helper.gyro2AdisIdSideB, entry, modeTable);
|
|
initModeTableEntry(helper.gyro3L3gIdSideB, entry, modeTable);
|
|
initModeTableEntry(helper.gpsId, entry, modeTable);
|
|
}
|
|
|
|
ReturnValue_t AcsBoardAssembly::commandChildren(Mode_t mode, Submode_t submode) {
|
|
using namespace duallane;
|
|
ReturnValue_t result = RETURN_OK;
|
|
refreshHelperModes();
|
|
if (mode == DeviceHandlerIF::MODE_NORMAL or mode == MODE_ON) {
|
|
result = handleNormalOrOnModeCmd(mode, submode);
|
|
} else {
|
|
modeTable[ModeTableIdx::GYRO_0_A].setMode(MODE_OFF);
|
|
modeTable[ModeTableIdx::GYRO_0_A].setSubmode(SUBMODE_NONE);
|
|
modeTable[ModeTableIdx::GYRO_1_A].setMode(MODE_OFF);
|
|
modeTable[ModeTableIdx::GYRO_1_A].setSubmode(SUBMODE_NONE);
|
|
modeTable[ModeTableIdx::GYRO_2_B].setMode(MODE_OFF);
|
|
modeTable[ModeTableIdx::GYRO_2_B].setSubmode(SUBMODE_NONE);
|
|
modeTable[ModeTableIdx::GYRO_3_B].setMode(MODE_OFF);
|
|
modeTable[ModeTableIdx::GYRO_3_B].setSubmode(SUBMODE_NONE);
|
|
modeTable[ModeTableIdx::MGM_0_A].setMode(MODE_OFF);
|
|
modeTable[ModeTableIdx::MGM_0_A].setSubmode(SUBMODE_NONE);
|
|
modeTable[ModeTableIdx::MGM_1_A].setMode(MODE_OFF);
|
|
modeTable[ModeTableIdx::MGM_1_A].setSubmode(SUBMODE_NONE);
|
|
modeTable[ModeTableIdx::MGM_2_B].setMode(MODE_OFF);
|
|
modeTable[ModeTableIdx::MGM_2_B].setSubmode(SUBMODE_NONE);
|
|
modeTable[ModeTableIdx::MGM_3_B].setMode(MODE_OFF);
|
|
modeTable[ModeTableIdx::MGM_3_B].setSubmode(SUBMODE_NONE);
|
|
modeTable[ModeTableIdx::GPS].setMode(MODE_OFF);
|
|
modeTable[ModeTableIdx::GPS].setSubmode(SUBMODE_NONE);
|
|
}
|
|
HybridIterator<ModeListEntry> tableIter(modeTable.begin(), modeTable.end());
|
|
executeTable(tableIter);
|
|
return result;
|
|
}
|
|
|
|
ReturnValue_t AcsBoardAssembly::checkChildrenStateOn(Mode_t wantedMode, Submode_t wantedSubmode) {
|
|
using namespace duallane;
|
|
refreshHelperModes();
|
|
if (wantedSubmode == A_SIDE) {
|
|
if ((helper.gyro0SideAMode != wantedMode and helper.gyro1SideAMode != wantedMode) or
|
|
(helper.mgm0SideAMode != wantedMode and helper.mgm1SideAMode != wantedMode) or
|
|
helper.gpsMode != MODE_ON) {
|
|
return NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE;
|
|
}
|
|
return RETURN_OK;
|
|
} else if (wantedSubmode == B_SIDE) {
|
|
if ((helper.gyro2SideBMode != wantedMode and helper.gyro3SideBMode != wantedMode) or
|
|
(helper.mgm2SideBMode != wantedMode and helper.mgm3SideBMode != wantedMode) or
|
|
helper.gpsMode != MODE_ON) {
|
|
return NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE;
|
|
}
|
|
return RETURN_OK;
|
|
} else if (wantedSubmode == DUAL_MODE) {
|
|
if ((helper.gyro0SideAMode != wantedMode and helper.gyro1SideAMode != wantedMode and
|
|
helper.gyro2AdisIdSideB != wantedMode and helper.gyro3SideBMode != wantedMode) or
|
|
(helper.mgm0SideAMode != wantedMode and helper.mgm1SideAMode != wantedMode and
|
|
helper.mgm2SideBMode != wantedMode and helper.mgm3SideBMode != wantedMode) or
|
|
helper.gpsMode != MODE_ON) {
|
|
// Trigger event, but don't start any other transitions. This is the last fallback mode.
|
|
if (dualModeErrorSwitch) {
|
|
triggerEvent(NOT_ENOUGH_DEVICES_DUAL_MODE, 0, 0);
|
|
dualModeErrorSwitch = false;
|
|
}
|
|
return RETURN_OK;
|
|
}
|
|
return RETURN_OK;
|
|
}
|
|
return HasReturnvaluesIF::RETURN_OK;
|
|
}
|
|
|
|
ReturnValue_t AcsBoardAssembly::handleNormalOrOnModeCmd(Mode_t mode, Submode_t submode) {
|
|
using namespace duallane;
|
|
ReturnValue_t result = RETURN_OK;
|
|
auto cmdSeq = [&](object_id_t objectId, Mode_t devMode, ModeTableIdx tableIdx) {
|
|
if (mode == DeviceHandlerIF::MODE_NORMAL) {
|
|
if (isUseable(objectId, devMode)) {
|
|
if (devMode == MODE_ON) {
|
|
modeTable[tableIdx].setMode(mode);
|
|
modeTable[tableIdx].setSubmode(SUBMODE_NONE);
|
|
|
|
} else {
|
|
modeTable[tableIdx].setMode(MODE_ON);
|
|
modeTable[tableIdx].setSubmode(SUBMODE_NONE);
|
|
}
|
|
}
|
|
} else if (mode == MODE_ON) {
|
|
if (isUseable(objectId, devMode)) {
|
|
modeTable[tableIdx].setMode(MODE_ON);
|
|
modeTable[tableIdx].setSubmode(SUBMODE_NONE);
|
|
}
|
|
}
|
|
};
|
|
if (this->mode == MODE_OFF and mode == DeviceHandlerIF::MODE_NORMAL) {
|
|
if (internalState != STATE_SECOND_STEP) {
|
|
result = NEED_SECOND_STEP;
|
|
}
|
|
}
|
|
switch (submode) {
|
|
case (A_SIDE): {
|
|
cmdSeq(helper.gyro0AdisIdSideA, helper.gyro0SideAMode, ModeTableIdx::GYRO_0_A);
|
|
cmdSeq(helper.gyro1L3gIdSideA, helper.gyro1SideAMode, ModeTableIdx::GYRO_1_A);
|
|
cmdSeq(helper.mgm0Lis3IdSideA, helper.mgm0SideAMode, ModeTableIdx::MGM_0_A);
|
|
cmdSeq(helper.mgm1Rm3100IdSideA, helper.mgm1SideAMode, ModeTableIdx::MGM_1_A);
|
|
modeTable[ModeTableIdx::GPS].setMode(MODE_ON);
|
|
modeTable[ModeTableIdx::GPS].setSubmode(SUBMODE_NONE);
|
|
if (gpioIF->pullLow(gpioIds::GNSS_SELECT) != HasReturnvaluesIF::RETURN_OK) {
|
|
#if OBSW_VERBOSE_LEVEL >= 1
|
|
sif::error << "AcsBoardAssembly::handleNormalOrOnModeCmd: Could not pull GNSS select low"
|
|
<< std::endl;
|
|
#endif
|
|
}
|
|
modeTable[ModeTableIdx::GYRO_2_B].setMode(MODE_OFF);
|
|
modeTable[ModeTableIdx::GYRO_2_B].setSubmode(SUBMODE_NONE);
|
|
modeTable[ModeTableIdx::GYRO_3_B].setMode(MODE_OFF);
|
|
modeTable[ModeTableIdx::GYRO_3_B].setSubmode(SUBMODE_NONE);
|
|
modeTable[ModeTableIdx::MGM_2_B].setMode(MODE_OFF);
|
|
modeTable[ModeTableIdx::MGM_2_B].setSubmode(SUBMODE_NONE);
|
|
modeTable[ModeTableIdx::MGM_3_B].setMode(MODE_OFF);
|
|
modeTable[ModeTableIdx::MGM_3_B].setSubmode(SUBMODE_NONE);
|
|
return result;
|
|
}
|
|
case (B_SIDE): {
|
|
cmdSeq(helper.gyro2AdisIdSideB, helper.gyro2SideBMode, ModeTableIdx::GYRO_2_B);
|
|
cmdSeq(helper.gyro3L3gIdSideB, helper.gyro3SideBMode, ModeTableIdx::GYRO_3_B);
|
|
cmdSeq(helper.mgm2Lis3IdSideB, helper.mgm2SideBMode, ModeTableIdx::MGM_2_B);
|
|
cmdSeq(helper.mgm3Rm3100IdSideB, helper.mgm3SideBMode, ModeTableIdx::MGM_3_B);
|
|
cmdSeq(helper.gpsId, helper.gpsMode, ModeTableIdx::GPS);
|
|
if (gpioIF->pullHigh(gpioIds::GNSS_SELECT) != HasReturnvaluesIF::RETURN_OK) {
|
|
#if OBSW_VERBOSE_LEVEL >= 1
|
|
sif::error << "AcsBoardAssembly::handleNormalOrOnModeCmd: Could not pull GNSS select high"
|
|
<< std::endl;
|
|
#endif
|
|
}
|
|
modeTable[ModeTableIdx::GYRO_0_A].setMode(MODE_OFF);
|
|
modeTable[ModeTableIdx::GYRO_0_A].setSubmode(SUBMODE_NONE);
|
|
modeTable[ModeTableIdx::GYRO_1_A].setMode(MODE_OFF);
|
|
modeTable[ModeTableIdx::GYRO_1_A].setSubmode(SUBMODE_NONE);
|
|
modeTable[ModeTableIdx::MGM_0_A].setMode(MODE_OFF);
|
|
modeTable[ModeTableIdx::MGM_0_A].setSubmode(SUBMODE_NONE);
|
|
modeTable[ModeTableIdx::MGM_1_A].setMode(MODE_OFF);
|
|
modeTable[ModeTableIdx::MGM_1_A].setSubmode(SUBMODE_NONE);
|
|
return result;
|
|
}
|
|
case (DUAL_MODE): {
|
|
cmdSeq(helper.gpsId, helper.gpsMode, ModeTableIdx::GPS);
|
|
cmdSeq(helper.gyro0AdisIdSideA, helper.gyro0SideAMode, ModeTableIdx::GYRO_0_A);
|
|
cmdSeq(helper.gyro1L3gIdSideA, helper.gyro1SideAMode, ModeTableIdx::GYRO_1_A);
|
|
cmdSeq(helper.mgm0Lis3IdSideA, helper.mgm0SideAMode, ModeTableIdx::MGM_0_A);
|
|
cmdSeq(helper.mgm1Rm3100IdSideA, helper.mgm1SideAMode, ModeTableIdx::MGM_1_A);
|
|
cmdSeq(helper.gyro2AdisIdSideB, helper.gyro2SideBMode, ModeTableIdx::GYRO_2_B);
|
|
cmdSeq(helper.gyro3L3gIdSideB, helper.gyro3SideBMode, ModeTableIdx::GYRO_3_B);
|
|
cmdSeq(helper.mgm2Lis3IdSideB, helper.mgm2SideBMode, ModeTableIdx::MGM_2_B);
|
|
cmdSeq(helper.mgm3Rm3100IdSideB, helper.mgm3SideBMode, ModeTableIdx::MGM_3_B);
|
|
ReturnValue_t status = RETURN_OK;
|
|
if (defaultSubmode == Submodes::A_SIDE) {
|
|
status = gpioIF->pullLow(gpioIds::GNSS_SELECT);
|
|
} else {
|
|
status = gpioIF->pullHigh(gpioIds::GNSS_SELECT);
|
|
}
|
|
if (status != HasReturnvaluesIF::RETURN_OK) {
|
|
#if OBSW_VERBOSE_LEVEL >= 1
|
|
sif::error << "AcsBoardAssembly::handleNormalOrOnModeCmd: Could not pull GNSS select to"
|
|
"default side for dual mode"
|
|
<< std::endl;
|
|
#endif
|
|
}
|
|
return result;
|
|
}
|
|
default: {
|
|
sif::error << "AcsBoardAssembly::handleNormalModeCmd: Unknown submode" << std::endl;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
ReturnValue_t AcsBoardAssembly::isModeCombinationValid(Mode_t mode, Submode_t submode) {
|
|
using namespace duallane;
|
|
if (submode != A_SIDE and submode != B_SIDE and submode != DUAL_MODE) {
|
|
return HasReturnvaluesIF::RETURN_FAILED;
|
|
}
|
|
return HasReturnvaluesIF::RETURN_OK;
|
|
}
|
|
|
|
void AcsBoardAssembly::handleChildrenLostMode(ReturnValue_t result) {
|
|
using namespace duallane;
|
|
// Some ACS board components are required for Safe-Mode. It would be good if the software
|
|
// transitions from A side to B side and from B side to dual mode autonomously
|
|
// to ensure that that enough sensors are available without an operators intervention.
|
|
// Therefore, the lost mode handler was overwritten to start these transitions
|
|
Submode_t nextSubmode = Submodes::A_SIDE;
|
|
if (submode == Submodes::A_SIDE) {
|
|
nextSubmode = Submodes::B_SIDE;
|
|
}
|
|
if (not tryingOtherSide) {
|
|
triggerEvent(CANT_KEEP_MODE, mode, submode);
|
|
startTransition(mode, nextSubmode);
|
|
tryingOtherSide = true;
|
|
} else {
|
|
// Not sure when this would happen. This flag is reset if the mode was reached. If it
|
|
// was not reached, the transition failure handler should be called.
|
|
sif::error << "AcsBoardAssembly::handleChildrenLostMode: Wrong handler called" << std::endl;
|
|
triggerEvent(TRANSITION_OTHER_SIDE_FAILED, mode, targetSubmode);
|
|
startTransition(mode, Submodes::DUAL_MODE);
|
|
}
|
|
}
|
|
|
|
void AcsBoardAssembly::handleModeTransitionFailed(ReturnValue_t result) {
|
|
using namespace duallane;
|
|
Submode_t nextSubmode = Submodes::A_SIDE;
|
|
if (submode == Submodes::A_SIDE) {
|
|
nextSubmode = Submodes::B_SIDE;
|
|
}
|
|
// Check whether the transition was started because the mode could not be kept (not commanded).
|
|
// If this is not the case, start transition to other side. If it is the case, start
|
|
// transition to dual mode.
|
|
if (not tryingOtherSide) {
|
|
triggerEvent(CANT_KEEP_MODE, mode, submode);
|
|
startTransition(mode, nextSubmode);
|
|
tryingOtherSide = true;
|
|
} else {
|
|
triggerEvent(TRANSITION_OTHER_SIDE_FAILED, mode, targetSubmode);
|
|
startTransition(mode, Submodes::DUAL_MODE);
|
|
}
|
|
}
|
|
|
|
void AcsBoardAssembly::setPreferredSide(duallane::Submodes submode) {
|
|
using namespace duallane;
|
|
if (submode != Submodes::A_SIDE and submode != Submodes::B_SIDE) {
|
|
return;
|
|
}
|
|
this->defaultSubmode = submode;
|
|
}
|
|
|
|
void AcsBoardAssembly::selectGpsInDualMode(duallane::Submodes side) {
|
|
using namespace duallane;
|
|
if (submode != Submodes::DUAL_MODE) {
|
|
return;
|
|
}
|
|
ReturnValue_t result = RETURN_OK;
|
|
if (side == Submodes::A_SIDE) {
|
|
result = gpioIF->pullLow(gpioIds::GNSS_SELECT);
|
|
} else {
|
|
result = gpioIF->pullHigh(gpioIds::GNSS_SELECT);
|
|
}
|
|
if (result != HasReturnvaluesIF::RETURN_OK) {
|
|
#if OBSW_VERBOSE_LEVEL >= 1
|
|
sif::error << "AcsBoardAssembly::switchGpsInDualMode: Switching GPS failed" << std::endl;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
void AcsBoardAssembly::refreshHelperModes() {
|
|
try {
|
|
helper.gyro0SideAMode = childrenMap.at(helper.gyro0AdisIdSideA).mode;
|
|
helper.gyro1SideAMode = childrenMap.at(helper.gyro1L3gIdSideA).mode;
|
|
helper.gyro2SideBMode = childrenMap.at(helper.gyro2AdisIdSideB).mode;
|
|
helper.gyro3SideBMode = childrenMap.at(helper.gyro2AdisIdSideB).mode;
|
|
helper.mgm0SideAMode = childrenMap.at(helper.mgm0Lis3IdSideA).mode;
|
|
helper.mgm1SideAMode = childrenMap.at(helper.mgm1Rm3100IdSideA).mode;
|
|
helper.mgm2SideBMode = childrenMap.at(helper.mgm2Lis3IdSideB).mode;
|
|
helper.mgm3SideBMode = childrenMap.at(helper.mgm3Rm3100IdSideB).mode;
|
|
helper.gpsMode = childrenMap.at(helper.gpsId).mode;
|
|
} catch (const std::out_of_range& e) {
|
|
sif::error << "AcsBoardAssembly::refreshHelperModes: Invalid map: " << e.what() << std::endl;
|
|
}
|
|
}
|
|
|
|
void AcsBoardAssembly::finishModeOp() {
|
|
using namespace duallane;
|
|
AssemblyBase::handleModeReached();
|
|
pwrStateMachine.reset();
|
|
powerRetryCounter = 0;
|
|
tryingOtherSide = false;
|
|
dualModeErrorSwitch = true;
|
|
}
|
|
|
|
ReturnValue_t AcsBoardAssembly::initialize() {
|
|
ReturnValue_t result = registerChild(helper.gyro0AdisIdSideA);
|
|
if (result != HasReturnvaluesIF::RETURN_OK) {
|
|
return result;
|
|
}
|
|
result = registerChild(helper.gyro1L3gIdSideA);
|
|
if (result != HasReturnvaluesIF::RETURN_OK) {
|
|
return result;
|
|
}
|
|
result = registerChild(helper.gyro2AdisIdSideB);
|
|
if (result != HasReturnvaluesIF::RETURN_OK) {
|
|
return result;
|
|
}
|
|
result = registerChild(helper.gyro3L3gIdSideB);
|
|
if (result != HasReturnvaluesIF::RETURN_OK) {
|
|
return result;
|
|
}
|
|
result = registerChild(helper.mgm0Lis3IdSideA);
|
|
if (result != HasReturnvaluesIF::RETURN_OK) {
|
|
return result;
|
|
}
|
|
result = registerChild(helper.mgm1Rm3100IdSideA);
|
|
if (result != HasReturnvaluesIF::RETURN_OK) {
|
|
return result;
|
|
}
|
|
result = registerChild(helper.mgm2Lis3IdSideB);
|
|
if (result != HasReturnvaluesIF::RETURN_OK) {
|
|
return result;
|
|
}
|
|
result = registerChild(helper.mgm3Rm3100IdSideB);
|
|
if (result != HasReturnvaluesIF::RETURN_OK) {
|
|
return result;
|
|
}
|
|
result = registerChild(helper.gpsId);
|
|
if (result != HasReturnvaluesIF::RETURN_OK) {
|
|
return result;
|
|
}
|
|
return AssemblyBase::initialize();
|
|
}
|