diff --git a/bsp_q7s/core/ObjectFactory.cpp b/bsp_q7s/core/ObjectFactory.cpp index de0e5fb8..c6b53e68 100644 --- a/bsp_q7s/core/ObjectFactory.cpp +++ b/bsp_q7s/core/ObjectFactory.cpp @@ -580,13 +580,13 @@ void ObjectFactory::createSolarArrayDeploymentComponents(PowerSwitchIF& pwrSwitc void ObjectFactory::createSyrlinksComponents(PowerSwitchIF* pwrSwitcher) { auto* syrlinksUartCookie = - new SerialCookie(objects::SYRLINKS_HK_HANDLER, q7s::UART_SYRLINKS_DEV, uart::SYRLINKS_BAUD, + new SerialCookie(objects::SYRLINKS_HANDLER, q7s::UART_SYRLINKS_DEV, uart::SYRLINKS_BAUD, syrlinks::MAX_REPLY_SIZE, UartModes::NON_CANONICAL); syrlinksUartCookie->setParityEven(); - auto syrlinksFdir = new SyrlinksFdir(objects::SYRLINKS_HK_HANDLER); + auto syrlinksFdir = new SyrlinksFdir(objects::SYRLINKS_HANDLER); auto syrlinksHandler = - new SyrlinksHandler(objects::SYRLINKS_HK_HANDLER, objects::UART_COM_IF, syrlinksUartCookie, + new SyrlinksHandler(objects::SYRLINKS_HANDLER, objects::UART_COM_IF, syrlinksUartCookie, pcdu::PDU1_CH1_SYRLINKS_12V, syrlinksFdir); syrlinksHandler->setPowerSwitcher(pwrSwitcher); syrlinksHandler->setStartUpImmediately(); diff --git a/common/config/eive/objects.h b/common/config/eive/objects.h index 840b188c..6cd4ebbe 100644 --- a/common/config/eive/objects.h +++ b/common/config/eive/objects.h @@ -117,7 +117,8 @@ enum commonObjects : uint32_t { SUS_5_N_LOC_XFYMZB_PT_ZB = 0x44120037, SUS_11_R_LOC_XBYMZB_PT_ZB = 0x44120043, - SYRLINKS_HK_HANDLER = 0x445300A3, + SYRLINKS_HANDLER = 0x445300A3, + CCSDS_IP_CORE_BRIDGE = 0x73500000, /* 0x49 ('I') for Communication Interfaces */ SPI_RTD_COM_IF = 0x49020006, diff --git a/dummies/helpers.cpp b/dummies/helpers.cpp index 0ffb724f..b47d74ef 100644 --- a/dummies/helpers.cpp +++ b/dummies/helpers.cpp @@ -41,7 +41,7 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitch) { new SaDeplDummy(objects::SOLAR_ARRAY_DEPL_HANDLER); new StarTrackerDummy(objects::STAR_TRACKER, objects::DUMMY_COM_IF, comCookieDummy); if (cfg.addSyrlinksDummies) { - new SyrlinksDummy(objects::SYRLINKS_HK_HANDLER, objects::DUMMY_COM_IF, comCookieDummy); + new SyrlinksDummy(objects::SYRLINKS_HANDLER, objects::DUMMY_COM_IF, comCookieDummy); } new ImtqDummy(objects::IMTQ_HANDLER, objects::DUMMY_COM_IF, comCookieDummy); if (cfg.addPowerDummies) { diff --git a/linux/fsfwconfig/objects/systemObjectList.h b/linux/fsfwconfig/objects/systemObjectList.h index 8f36b013..7624cd5f 100644 --- a/linux/fsfwconfig/objects/systemObjectList.h +++ b/linux/fsfwconfig/objects/systemObjectList.h @@ -39,8 +39,6 @@ enum sourceObjects : uint32_t { FW_ADDRESS_END = TIME_STAMPER, PUS_SERVICE_6 = 0x51000500, - CCSDS_IP_CORE_BRIDGE = 0x73500000, - /* 0x49 ('I') for Communication Interfaces **/ ARDUINO_COM_IF = 0x49000000, CSP_COM_IF = 0x49050001, diff --git a/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp b/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp index 5dd87e0b..5fec0cd6 100644 --- a/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp +++ b/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp @@ -487,12 +487,11 @@ ReturnValue_t pst::pstUart(FixedTimeslotTaskIF *thisSequence) { static_cast(length); #if OBSW_ADD_SYRLINKS == 1 - thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0, - DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); + thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ); #endif #if OBSW_ADD_STAR_TRACKER == 1 diff --git a/mission/comDefs.h b/mission/comDefs.h index bda8027f..a271ba31 100644 --- a/mission/comDefs.h +++ b/mission/comDefs.h @@ -9,6 +9,17 @@ enum class Datarate : uint8_t { NUM_DATARATES }; -} +enum Submode : uint8_t { + RX_ONLY, + RX_AND_TX_DEFAULT_DATARATE, + RX_AND_TX_LOW_DATARATE, + RX_AND_TX_HIGH_DATARATE, + RX_AND_TX_CW, + NUM_SUBMODES +}; + +enum class CcsdsSubmode : uint8_t { UNSET = 0, DATARATE_LOW = 1, DATARATE_HIGH = 2 }; + +} // namespace com #endif /* MISSION_COMDEFS_H_ */ diff --git a/mission/controller/ThermalController.cpp b/mission/controller/ThermalController.cpp index f0356f66..08244c03 100644 --- a/mission/controller/ThermalController.cpp +++ b/mission/controller/ThermalController.cpp @@ -746,7 +746,7 @@ void ThermalController::copyDevices() { { lp_var_t tempSyrlinksPowerAmplifier = - lp_var_t(objects::SYRLINKS_HK_HANDLER, syrlinks::TEMP_POWER_AMPLIFIER); + lp_var_t(objects::SYRLINKS_HANDLER, syrlinks::TEMP_POWER_AMPLIFIER); PoolReadGuard pg(&tempSyrlinksPowerAmplifier, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT); if (pg.getReadResult() != returnvalue::OK) { sif::warning << "ThermalController: Failed to read syrlinks power amplifier temperature" @@ -761,7 +761,7 @@ void ThermalController::copyDevices() { { lp_var_t tempSyrlinksBasebandBoard = - lp_var_t(objects::SYRLINKS_HK_HANDLER, syrlinks::TEMP_BASEBAND_BOARD); + lp_var_t(objects::SYRLINKS_HANDLER, syrlinks::TEMP_BASEBAND_BOARD); PoolReadGuard pg(&tempSyrlinksBasebandBoard, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT); if (pg.getReadResult() != returnvalue::OK) { sif::warning << "ThermalController: Failed to read syrlinks baseband board temperature" diff --git a/mission/devices/SyrlinksHandler.cpp b/mission/devices/SyrlinksHandler.cpp index 4c58a053..92c656ec 100644 --- a/mission/devices/SyrlinksHandler.cpp +++ b/mission/devices/SyrlinksHandler.cpp @@ -694,7 +694,7 @@ ReturnValue_t SyrlinksHandler::handleAckReply(const uint8_t* packet) { ReturnValue_t SyrlinksHandler::isModeCombinationValid(Mode_t mode, Submode_t submode) { if (mode == HasModesIF::MODE_ON or mode == DeviceHandlerIF::MODE_NORMAL) { - if (submode >= syrlinks::Submode::NUM_SUBMODES) { + if (submode >= com::Submode::NUM_SUBMODES) { return HasModesIF::INVALID_SUBMODE; } return returnvalue::OK; @@ -772,7 +772,7 @@ void SyrlinksHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) { }; if (tgtMode == HasModesIF::MODE_ON or tgtMode == DeviceHandlerIF::MODE_NORMAL) { switch (getSubmode()) { - case (syrlinks::Submode::RX_AND_TX_DEFAULT_DATARATE): { + case (com::Submode::RX_AND_TX_DEFAULT_DATARATE): { if (datarateCfgRaw == static_cast(com::Datarate::LOW_RATE_MODULATION_BPSK)) { if (txOnHandler(InternalState::SELECT_MODULATION_BPSK)) { return; @@ -785,23 +785,23 @@ void SyrlinksHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) { } break; } - case (syrlinks::Submode::RX_AND_TX_LOW_DATARATE): { + case (com::Submode::RX_AND_TX_LOW_DATARATE): { if (txOnHandler(InternalState::SELECT_MODULATION_BPSK)) { return; } break; } - case (syrlinks::Submode::RX_AND_TX_HIGH_DATARATE): { + case (com::Submode::RX_AND_TX_HIGH_DATARATE): { if (txOnHandler(InternalState::SELECT_MODULATION_0QPSK)) { return; } break; } - case (syrlinks::Submode::RX_ONLY): { + case (com::Submode::RX_ONLY): { txStandbyHandler(); return; } - case (syrlinks::Submode::RX_AND_TX_CW): { + case (com::Submode::RX_AND_TX_CW): { if (internalState == InternalState::IDLE) { internalState = InternalState::SET_TX_STANDBY; commandExecuted = false; diff --git a/mission/devices/devicedefinitions/SyrlinksDefinitions.h b/mission/devices/devicedefinitions/SyrlinksDefinitions.h index bb36b793..0e25501a 100644 --- a/mission/devices/devicedefinitions/SyrlinksDefinitions.h +++ b/mission/devices/devicedefinitions/SyrlinksDefinitions.h @@ -8,15 +8,6 @@ namespace syrlinks { enum class ParameterId : uint8_t { DATARATE = 0 }; -enum Submode { - RX_ONLY, - RX_AND_TX_DEFAULT_DATARATE, - RX_AND_TX_LOW_DATARATE, - RX_AND_TX_HIGH_DATARATE, - RX_AND_TX_CW, - NUM_SUBMODES -}; - static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYRLINKS; static constexpr Event FDIR_REACTION_IGNORED = event::makeEvent(SUBSYSTEM_ID, 0, severity::MEDIUM); diff --git a/mission/system/tree/CMakeLists.txt b/mission/system/tree/CMakeLists.txt index 9c5fecd5..08d44e87 100644 --- a/mission/system/tree/CMakeLists.txt +++ b/mission/system/tree/CMakeLists.txt @@ -1,2 +1,4 @@ -target_sources(${LIB_EIVE_MISSION} PRIVATE acsModeTree.cpp payloadModeTree.cpp comModeTree.cpp - tcsModeTree.cpp system.cpp util.cpp) +target_sources( + ${LIB_EIVE_MISSION} + PRIVATE acsModeTree.cpp payloadModeTree.cpp comModeTree.cpp tcsModeTree.cpp + system.cpp util.cpp) diff --git a/mission/system/tree/comModeTree.cpp b/mission/system/tree/comModeTree.cpp index 7a788317..36fd0609 100644 --- a/mission/system/tree/comModeTree.cpp +++ b/mission/system/tree/comModeTree.cpp @@ -1,11 +1,12 @@ #include "comModeTree.h" -#include "eive/objects.h" #include #include #include #include +#include "eive/objects.h" +#include "mission/comDefs.h" #include "util.h" const auto check = subsystem::checkInsert; @@ -16,30 +17,47 @@ static const auto OFF = HasModesIF::MODE_OFF; static const auto ON = HasModesIF::MODE_ON; static const auto NML = DeviceHandlerIF::MODE_NORMAL; -auto COM_SEQUENCE_TX_OFF = std::make_pair(NML << 24, FixedArrayList()); -auto COM_TABLE_TX_OFF_TGT = std::make_pair((NML << 24) | 1, FixedArrayList()); -auto COM_TABLE_TX_OFF_TRANS = std::make_pair((NML << 24) | 2, FixedArrayList()); +auto COM_SEQUENCE_RX_ONLY = std::make_pair(NML, FixedArrayList()); +auto COM_TABLE_RX_ONLY_TGT = std::make_pair((NML << 24) | 1, FixedArrayList()); +auto COM_TABLE_RX_ONLY_TRANS_0 = + std::make_pair((NML << 24) | 2, FixedArrayList()); +auto COM_TABLE_RX_ONLY_TRANS_1 = + std::make_pair((NML << 24) | 3, FixedArrayList()); -auto COM_SEQUENCE_TX_ON = std::make_pair(NML << 24, FixedArrayList()); -auto COM_TABLE_TX_ON_TGT = std::make_pair((NML << 24) | 1, FixedArrayList()); -auto COM_TABLE_TX_ON_TRANS = std::make_pair((NML << 24) | 2, FixedArrayList()); +auto COM_SEQUENCE_RX_AND_TX_LOW_RATE = std::make_pair(NML, FixedArrayList()); +auto COM_TABLE_RX_AND_TX_LOW_RATE_TGT = + std::make_pair((NML << 24) | 1, FixedArrayList()); +auto COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_0 = + std::make_pair((NML << 24) | 2, FixedArrayList()); +auto COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_1 = + std::make_pair((NML << 24) | 2, FixedArrayList()); + +auto COM_SEQUENCE_RX_AND_TX_HIGH_RATE = std::make_pair(NML, FixedArrayList()); +auto COM_TABLE_RX_AND_TX_HIGH_RATE_TGT = + std::make_pair((NML << 24) | 1, FixedArrayList()); +auto COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_0 = + std::make_pair((NML << 24) | 2, FixedArrayList()); +auto COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_1 = + std::make_pair((NML << 24) | 2, FixedArrayList()); namespace { -void buildTxOffSequence(Subsystem& ss, ModeListEntry& eh); -void buildTxOnSequence(Subsystem& ss, ModeListEntry& eh); +void buildRxOnlySequence(Subsystem& ss, ModeListEntry& eh); +void buildTxAndRxLowRateSequence(Subsystem& ss, ModeListEntry& eh); +void buildTxAndRxHighRateSequence(Subsystem& ss, ModeListEntry& eh); } // namespace void satsystem::com::init() { ModeListEntry entry; - buildTxOffSequence(SUBSYSTEM, entry); - buildTxOnSequence(SUBSYSTEM, entry); - SUBSYSTEM.setInitialMode(NML, 0 /* TODO: Which submode? */); + buildRxOnlySequence(SUBSYSTEM, entry); + buildTxAndRxLowRateSequence(SUBSYSTEM, entry); + buildTxAndRxHighRateSequence(SUBSYSTEM, entry); + SUBSYSTEM.setInitialMode(NML, ::com::Submode::RX_ONLY); } namespace { -void buildTxOffSequence(Subsystem& ss, ModeListEntry& eh) { - std::string context = "satsystem::com::buildTxOffSequence"; +void buildRxOnlySequence(Subsystem& ss, ModeListEntry& eh) { + std::string context = "satsystem::com::buildRxOnlySequence"; auto ctxc = context.c_str(); // Insert Helper Table auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode, ArrayList& table) { @@ -57,24 +75,33 @@ void buildTxOffSequence(Subsystem& ss, ModeListEntry& eh) { check(sequence.insert(eh), ctxc); }; - // Build TX OFF table - iht(objects::SYRLINKS_HK_HANDLER, NML, 0/* TODO */, COM_TABLE_TX_OFF_TGT.second); - check(ss.addTable(TableEntry(COM_SEQUENCE_TX_OFF.first, &COM_TABLE_TX_OFF_TGT.second)), ctxc); + // Build RX Only table. We could track the state of the CCSDS IP core handler + // as well but I do not think this is necessary because enabling that should + // not intefere with the Syrlinks Handler. + iht(objects::SYRLINKS_HANDLER, NML, ::com::Submode::RX_ONLY, COM_TABLE_RX_ONLY_TGT.second); + check(ss.addTable(TableEntry(COM_TABLE_RX_ONLY_TGT.first, &COM_TABLE_RX_ONLY_TGT.second)), ctxc); - // Build TX OFF transition - iht(objects::SYRLINKS_HK_HANDLER, NML, 0/* TODO */, COM_TABLE_TX_OFF_TRANS.second); - check(ss.addTable(TableEntry(COM_SEQUENCE_TX_OFF.first, &COM_TABLE_TX_OFF_TRANS.second)), ctxc); + // Build RX Only transition 0 + iht(objects::SYRLINKS_HANDLER, NML, ::com::Submode::RX_ONLY, COM_TABLE_RX_ONLY_TRANS_0.second); + check(ss.addTable(TableEntry(COM_TABLE_RX_ONLY_TRANS_0.first, &COM_TABLE_RX_ONLY_TRANS_0.second)), + ctxc); + + // Build RX Only transition 1 + iht(objects::CCSDS_IP_CORE_BRIDGE, OFF, 0, COM_TABLE_RX_ONLY_TRANS_1.second); + check(ss.addTable(TableEntry(COM_TABLE_RX_ONLY_TRANS_1.first, &COM_TABLE_RX_ONLY_TRANS_1.second)), + ctxc); // Build TX OFF sequence - ihs(COM_SEQUENCE_TX_OFF.second, COM_TABLE_TX_OFF_TGT.first, 0, false); - ihs(COM_SEQUENCE_TX_OFF.second, COM_TABLE_TX_OFF_TRANS.first, 0, false); - check(ss.addSequence(SequenceEntry(COM_TABLE_TX_OFF_TRANS.first, &COM_TABLE_TX_OFF_TRANS.second, - COM_TABLE_TX_OFF_TRANS.first)), + ihs(COM_SEQUENCE_RX_ONLY.second, COM_TABLE_RX_ONLY_TGT.first, 0, true); + ihs(COM_SEQUENCE_RX_ONLY.second, COM_TABLE_RX_ONLY_TRANS_0.first, 0, true); + ihs(COM_SEQUENCE_RX_ONLY.second, COM_TABLE_RX_ONLY_TRANS_1.first, 0, true); + check(ss.addSequence(SequenceEntry(COM_SEQUENCE_RX_ONLY.first, &COM_SEQUENCE_RX_ONLY.second, + COM_SEQUENCE_RX_ONLY.first)), ctxc); } -void buildTxOnSequence(Subsystem& ss, ModeListEntry& eh) { - std::string context = "satsystem::com::buildTxOnSequence"; +void buildTxAndRxLowRateSequence(Subsystem& ss, ModeListEntry& eh) { + std::string context = "satsystem::com::buildTxAndRxLowRateSequence"; auto ctxc = context.c_str(); // Insert Helper Table auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode, ArrayList& table) { @@ -92,19 +119,90 @@ void buildTxOnSequence(Subsystem& ss, ModeListEntry& eh) { check(sequence.insert(eh), ctxc); }; - // Build TX ON table - iht(objects::SYRLINKS_HK_HANDLER, NML, /*TODO*/0, COM_TABLE_TX_ON_TGT.second); - check(ss.addTable(TableEntry(COM_SEQUENCE_TX_ON.first, &COM_TABLE_TX_ON_TGT.second)), ctxc); + // Build RX and TX low datarate table. + iht(objects::SYRLINKS_HANDLER, NML, ::com::Submode::RX_AND_TX_LOW_DATARATE, + COM_TABLE_RX_AND_TX_LOW_RATE_TGT.second); + iht(objects::CCSDS_IP_CORE_BRIDGE, ON, static_cast(::com::CcsdsSubmode::DATARATE_LOW), + COM_TABLE_RX_AND_TX_LOW_RATE_TGT.second); + check(ss.addTable(TableEntry(COM_TABLE_RX_AND_TX_LOW_RATE_TGT.first, + &COM_TABLE_RX_AND_TX_LOW_RATE_TGT.second)), + ctxc); - // Build TX ON transition - iht(objects::SYRLINKS_HK_HANDLER, NML, /*TODO*/0, COM_TABLE_TX_ON_TRANS.second); - check(ss.addTable(TableEntry(COM_SEQUENCE_TX_ON.first, &COM_TABLE_TX_ON_TRANS.second)), ctxc); + // Build TX and RX low datarate transition 0, switch CCSDS handler first + iht(objects::CCSDS_IP_CORE_BRIDGE, ON, static_cast(::com::CcsdsSubmode::DATARATE_LOW), + COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_0.second); + check(ss.addTable(TableEntry(COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_0.first, + &COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_0.second)), + ctxc); - // Build TX ON sequence - ihs(COM_SEQUENCE_TX_ON.second, COM_TABLE_TX_ON_TGT.first, 0, false); - ihs(COM_SEQUENCE_TX_ON.second, COM_TABLE_TX_ON_TRANS.first, 0, false); - check(ss.addSequence(SequenceEntry(COM_TABLE_TX_ON_TRANS.first, &COM_TABLE_TX_ON_TRANS.second, - COM_TABLE_TX_ON_TRANS.first)), + // Build TX and RX low transition 1 + iht(objects::SYRLINKS_HANDLER, NML, ::com::Submode::RX_AND_TX_LOW_DATARATE, + COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_1.second); + check(ss.addTable(TableEntry(COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_1.first, + &COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_1.second)), + ctxc); + + // Build TX and RX low datarate sequence + ihs(COM_SEQUENCE_RX_AND_TX_LOW_RATE.second, COM_TABLE_RX_AND_TX_LOW_RATE_TGT.first, 0, true); + ihs(COM_SEQUENCE_RX_AND_TX_LOW_RATE.second, COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_0.first, 0, true); + ihs(COM_SEQUENCE_RX_AND_TX_LOW_RATE.second, COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_1.first, 0, true); + check(ss.addSequence(SequenceEntry(COM_SEQUENCE_RX_AND_TX_LOW_RATE.first, + &COM_SEQUENCE_RX_AND_TX_LOW_RATE.second, + COM_SEQUENCE_RX_ONLY.first)), + ctxc); +} + +void buildTxAndRxHighRateSequence(Subsystem& ss, ModeListEntry& eh) { + std::string context = "satsystem::com::buildTxAndRxHighRateSequence"; + auto ctxc = context.c_str(); + // Insert Helper Table + auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode, ArrayList& table) { + eh.setObject(obj); + eh.setMode(mode); + eh.setSubmode(submode); + check(table.insert(eh), ctxc); + }; + // Insert Helper Sequence + auto ihs = [&](ArrayList& sequence, Mode_t tableId, uint32_t waitSeconds, + bool checkSuccess) { + eh.setTableId(tableId); + eh.setWaitSeconds(waitSeconds); + eh.setCheckSuccess(checkSuccess); + check(sequence.insert(eh), ctxc); + }; + + // Build RX and TX low datarate table. + iht(objects::SYRLINKS_HANDLER, NML, ::com::Submode::RX_AND_TX_HIGH_DATARATE, + COM_TABLE_RX_AND_TX_HIGH_RATE_TGT.second); + iht(objects::CCSDS_IP_CORE_BRIDGE, ON, static_cast(::com::CcsdsSubmode::DATARATE_HIGH), + COM_TABLE_RX_AND_TX_HIGH_RATE_TGT.second); + check(ss.addTable(TableEntry(COM_TABLE_RX_AND_TX_HIGH_RATE_TGT.first, + &COM_TABLE_RX_AND_TX_HIGH_RATE_TGT.second)), + ctxc); + + // Build TX and RX low datarate transition 0, switch CCSDS handler first + iht(objects::CCSDS_IP_CORE_BRIDGE, ON, static_cast(::com::CcsdsSubmode::DATARATE_HIGH), + COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_0.second); + check(ss.addTable(TableEntry(COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_0.first, + &COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_0.second)), + ctxc); + + // Build TX and RX low transition 1 + iht(objects::SYRLINKS_HANDLER, NML, ::com::Submode::RX_AND_TX_HIGH_DATARATE, + COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_1.second); + check(ss.addTable(TableEntry(COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_1.first, + &COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_1.second)), + ctxc); + + // Build TX and RX low datarate sequence + ihs(COM_SEQUENCE_RX_AND_TX_HIGH_RATE.second, COM_TABLE_RX_AND_TX_HIGH_RATE_TGT.first, 0, true); + ihs(COM_SEQUENCE_RX_AND_TX_HIGH_RATE.second, COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_0.first, 0, + true); + ihs(COM_SEQUENCE_RX_AND_TX_HIGH_RATE.second, COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_1.first, 0, + true); + check(ss.addSequence(SequenceEntry(COM_SEQUENCE_RX_AND_TX_HIGH_RATE.first, + &COM_SEQUENCE_RX_AND_TX_HIGH_RATE.second, + COM_SEQUENCE_RX_ONLY.first)), ctxc); } diff --git a/mission/system/tree/comModeTree.h b/mission/system/tree/comModeTree.h index 7b6dc1e2..edee6da7 100644 --- a/mission/system/tree/comModeTree.h +++ b/mission/system/tree/comModeTree.h @@ -9,7 +9,7 @@ namespace com { extern Subsystem SUBSYSTEM; void init(); -} +} // namespace com } // namespace satsystem diff --git a/mission/tmtc/CcsdsIpCoreHandler.cpp b/mission/tmtc/CcsdsIpCoreHandler.cpp index 9a2195eb..21966feb 100644 --- a/mission/tmtc/CcsdsIpCoreHandler.cpp +++ b/mission/tmtc/CcsdsIpCoreHandler.cpp @@ -228,12 +228,12 @@ ReturnValue_t CcsdsIpCoreHandler::executeAction(ActionId_t actionId, MessageQueu ReturnValue_t result = returnvalue::OK; switch (actionId) { case SET_LOW_RATE: { - submode = static_cast(Submode::DATARATE_LOW); + submode = static_cast(com::CcsdsSubmode::DATARATE_LOW); result = ptmeConfig->setRate(RATE_100KBPS); break; } case SET_HIGH_RATE: { - submode = static_cast(Submode::DATARATE_HIGH); + submode = static_cast(com::CcsdsSubmode::DATARATE_HIGH); result = ptmeConfig->setRate(RATE_500KBPS); break; } @@ -365,8 +365,8 @@ void CcsdsIpCoreHandler::getMode(Mode_t* mode, Submode_t* submode) { ReturnValue_t CcsdsIpCoreHandler::checkModeCommand(Mode_t mode, Submode_t submode, uint32_t* msToReachTheMode) { if (mode == HasModesIF::MODE_ON) { - if (submode != static_cast(Submode::DATARATE_HIGH) and - submode != static_cast(Submode::DATARATE_LOW)) { + if (submode != static_cast(com::CcsdsSubmode::DATARATE_HIGH) and + submode != static_cast(com::CcsdsSubmode::DATARATE_LOW)) { return HasModesIF::INVALID_SUBMODE; } } else if (mode != HasModesIF::MODE_OFF) { @@ -379,12 +379,12 @@ ReturnValue_t CcsdsIpCoreHandler::checkModeCommand(Mode_t mode, Submode_t submod void CcsdsIpCoreHandler::startTransition(Mode_t mode, Submode_t submode) { if (mode == HasModesIF::MODE_ON) { enableTransmit(); - if (submode == static_cast(Submode::DATARATE_HIGH)) { + if (submode == static_cast(com::CcsdsSubmode::DATARATE_HIGH)) { ReturnValue_t result = ptmeConfig->setRate(RATE_500KBPS); if (result == returnvalue::OK) { mode = HasModesIF::MODE_ON; } - } else if (submode == static_cast(Submode::DATARATE_LOW)) { + } else if (submode == static_cast(com::CcsdsSubmode::DATARATE_LOW)) { ReturnValue_t result = ptmeConfig->setRate(RATE_100KBPS); if (result == returnvalue::OK) { mode = HasModesIF::MODE_ON; diff --git a/mission/tmtc/CcsdsIpCoreHandler.h b/mission/tmtc/CcsdsIpCoreHandler.h index 25e15c79..c9c85033 100644 --- a/mission/tmtc/CcsdsIpCoreHandler.h +++ b/mission/tmtc/CcsdsIpCoreHandler.h @@ -22,8 +22,7 @@ #include "fsfw_hal/common/gpio/GpioIF.h" #include "fsfw_hal/common/gpio/gpioDefinitions.h" #include "linux/ipcore/PtmeConfig.h" - -enum class Submode : uint8_t { UNSET = 0, DATARATE_LOW = 1, DATARATE_HIGH = 2 }; +#include "mission/comDefs.h" /** * @brief This class handles the data exchange with the CCSDS IP cores implemented in the @@ -139,7 +138,7 @@ class CcsdsIpCoreHandler : public SystemObject, ActionHelper actionHelper; Mode_t mode = HasModesIF::MODE_OFF; - Submode_t submode = static_cast(Submode::UNSET); + Submode_t submode = static_cast(com::CcsdsSubmode::UNSET); ModeHelper modeHelper; MessageQueueId_t tcDistributorQueueId = MessageQueueIF::NO_QUEUE;