Merge branch 'develop' into eggert/mgm-calibration-fix

mission/CMakeLists.txt

@@ -7,3 +7,4 @@ add_subdirectory(tmtc)
 add_subdirectory(system)
 add_subdirectory(csp)
 add_subdirectory(cfdp)
+add_subdirectory(config)

mission/comDefs.h

@@ -9,6 +9,23 @@ 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,
+  DATARATE_DEFAULT = 3
+};
+enum class ParameterId : uint8_t { DATARATE = 0 };
+
+}  // namespace com
 
 #endif /* MISSION_COMDEFS_H_ */

mission/config/CMakeLists.txt

@@ -0,0 +1 @@
+target_sources(${LIB_EIVE_MISSION} PRIVATE comCfg.cpp torquer.cpp)

mission/config/comCfg.cpp

@@ -0,0 +1,26 @@
+#include "comCfg.h"
+
+#include <fsfw/ipc/MutexFactory.h>
+#include <fsfw/ipc/MutexGuard.h>
+
+com::Datarate DATARATE_CFG_RAW = com::Datarate::LOW_RATE_MODULATION_BPSK;
+MutexIF* DATARATE_LOCK = nullptr;
+
+MutexIF* lazyLock();
+
+com::Datarate com::getCurrentDatarate() {
+  MutexGuard mg(lazyLock());
+  return DATARATE_CFG_RAW;
+}
+
+void com::setCurrentDatarate(com::Datarate newRate) {
+  MutexGuard mg(lazyLock());
+  DATARATE_CFG_RAW = newRate;
+}
+
+MutexIF* lazyLock() {
+  if (DATARATE_LOCK == nullptr) {
+    return MutexFactory::instance()->createMutex();
+  }
+  return DATARATE_LOCK;
+}

mission/config/comCfg.h

@@ -0,0 +1,15 @@
+#ifndef MISSION_COMCFG_H_
+#define MISSION_COMCFG_H_
+
+#include <fsfw/ipc/MutexIF.h>
+
+#include "mission/comDefs.h"
+
+namespace com {
+
+com::Datarate getCurrentDatarate();
+void setCurrentDatarate(com::Datarate newRate);
+
+}  // namespace com
+
+#endif /* MISSION_COMCFG_H_ */

mission/controller/AcsController.cpp

@@ -2,7 +2,7 @@
 
 #include <fsfw/datapool/PoolReadGuard.h>
 
-#include "mission/devices/torquer.h"
+#include "mission/config/torquer.h"
 
 AcsController::AcsController(object_id_t objectId)
     : ExtendedControllerBase(objectId),

mission/controller/ThermalController.cpp

@@ -746,7 +746,7 @@ void ThermalController::copyDevices() {
 
   {
     lp_var_t<float> tempSyrlinksPowerAmplifier =
-        lp_var_t<float>(objects::SYRLINKS_HK_HANDLER, syrlinks::TEMP_POWER_AMPLIFIER);
+        lp_var_t<float>(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<float> tempSyrlinksBasebandBoard =
-        lp_var_t<float>(objects::SYRLINKS_HK_HANDLER, syrlinks::TEMP_BASEBAND_BOARD);
+        lp_var_t<float>(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"

mission/core/GenericFactory.cpp

@@ -8,7 +8,7 @@
 #include <fsfw/internalerror/InternalErrorReporter.h>
 #include <fsfw/ipc/QueueFactory.h>
 #include <fsfw/pus/CService200ModeCommanding.h>
-#include <fsfw/pus/CService201HealthCommanding.h>
+#include <fsfw/pus/CServiceHealthCommanding.h>
 #include <fsfw/pus/Service17Test.h>
 #include <fsfw/pus/Service1TelecommandVerification.h>
 #include <fsfw/pus/Service20ParameterManagement.h>
@@ -108,7 +108,8 @@ void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_, PusTmFun
 #endif
 #if OBSW_ADD_TMTC_TCP_SERVER == 1
   auto tcpBridge = new TcpTmTcBridge(objects::TCP_TMTC_SERVER, objects::CCSDS_PACKET_DISTRIBUTOR);
-  auto tcpServer = new TcpTmTcServer(objects::TCP_TMTC_POLLING_TASK, objects::TCP_TMTC_SERVER);
+  TcpTmTcServer::TcpConfig cfg(true, true);
+  auto tcpServer = new TcpTmTcServer(objects::TCP_TMTC_POLLING_TASK, objects::TCP_TMTC_SERVER, cfg);
   // TCP is stream based. Use packet ID as start marker when parsing for space packets
   tcpServer->setSpacePacketParsingOptions({common::PUS_PACKET_ID, common::CFDP_PACKET_ID});
   sif::info << "Created TCP server for TMTC commanding with listener port "
@@ -161,8 +162,8 @@ void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_, PusTmFun
                                    pus::PUS_SERVICE_20);
   new CService200ModeCommanding(objects::PUS_SERVICE_200_MODE_MGMT, config::EIVE_PUS_APID,
                                 pus::PUS_SERVICE_200, 8);
-  new CService201HealthCommanding(objects::PUS_SERVICE_201_HEALTH, config::EIVE_PUS_APID,
-                                  pus::PUS_SERVICE_201);
+  HealthServiceCfg healthCfg(objects::PUS_SERVICE_201_HEALTH, config::EIVE_PUS_APID, *healthTable, 20);
+  new CServiceHealthCommanding(healthCfg);
 
 #if OBSW_ADD_CFDP_COMPONENTS == 1
   using namespace cfdp;

mission/devices/CMakeLists.txt

@@ -20,7 +20,6 @@ target_sources(
           SusHandler.cpp
           PayloadPcduHandler.cpp
           SolarArrayDeploymentHandler.cpp
-          ScexDeviceHandler.cpp
-          torquer.cpp)
+          ScexDeviceHandler.cpp)
 
 add_subdirectory(devicedefinitions)

mission/devices/ImtqHandler.cpp

@@ -25,7 +25,7 @@
 #include <cmath>
 #include <fsfw/datapoollocal/LocalPoolVariable.tpp>
 
-#include "mission/devices/torquer.h"
+#include "mission/config/torquer.h"
 
 static constexpr bool ACTUATION_WIRETAPPING = false;
 

mission/devices/SyrlinksHandler.cpp

@@ -3,6 +3,7 @@
 #include <mission/devices/SyrlinksHandler.h>
 
 #include "OBSWConfig.h"
+#include "mission/config/comCfg.h"
 
 SyrlinksHandler::SyrlinksHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie,
                                  power::Switch_t powerSwitch, FailureIsolationBase* customFdir)
@@ -621,7 +622,7 @@ void SyrlinksHandler::parseAgcHighByte(const uint8_t* packet) {
 
 void SyrlinksHandler::setNormalDatapoolEntriesInvalid() {}
 
-uint32_t SyrlinksHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 1500; }
+uint32_t SyrlinksHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 2500; }
 
 ReturnValue_t SyrlinksHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                                        LocalDataPoolManager& poolManager) {
@@ -685,7 +686,7 @@ ReturnValue_t SyrlinksHandler::handleAckReply(const uint8_t* packet) {
     }
     case (syrlinks::SET_TX_MODE_MODULATION):
     case (syrlinks::SET_TX_MODE_CW): {
-      triggerEvent(syrlinks::TX_ON, getSubmode(), datarateCfgRaw);
+      triggerEvent(syrlinks::TX_ON, getSubmode(), static_cast<uint8_t>(com::getCurrentDatarate()));
       break;
     }
   }
@@ -694,7 +695,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;
@@ -706,18 +707,6 @@ ReturnValue_t SyrlinksHandler::getParameter(uint8_t domainId, uint8_t uniqueId,
                                             ParameterWrapper* parameterWrapper,
                                             const ParameterWrapper* newValues,
                                             uint16_t startAtIndex) {
-  if ((domainId == 0) and (uniqueId == static_cast<uint8_t>(syrlinks::ParameterId::DATARATE))) {
-    uint8_t newVal = 0;
-    ReturnValue_t result = newValues->getElement(&newVal);
-    if (result != returnvalue::OK) {
-      return result;
-    }
-    if (newVal >= static_cast<uint8_t>(com::Datarate::NUM_DATARATES)) {
-      return HasParametersIF::INVALID_VALUE;
-    }
-    parameterWrapper->set(datarateCfgRaw);
-    return returnvalue::OK;
-  }
   return DeviceHandlerBase::getParameter(domainId, uniqueId, parameterWrapper, newValues,
                                          startAtIndex);
 }
@@ -772,36 +761,36 @@ 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): {
-        if (datarateCfgRaw == static_cast<uint8_t>(com::Datarate::LOW_RATE_MODULATION_BPSK)) {
+      case (com::Submode::RX_AND_TX_DEFAULT_DATARATE): {
+        auto currentDatarate = com::getCurrentDatarate();
+        if (currentDatarate == com::Datarate::LOW_RATE_MODULATION_BPSK) {
           if (txOnHandler(InternalState::SELECT_MODULATION_BPSK)) {
             return;
           }
-        } else if (datarateCfgRaw ==
-                   static_cast<uint8_t>(com::Datarate::HIGH_RATE_MODULATION_0QPSK)) {
+        } else if (currentDatarate == com::Datarate::HIGH_RATE_MODULATION_0QPSK) {
           if (txOnHandler(InternalState::SELECT_MODULATION_0QPSK)) {
             return;
           }
         }
         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;

mission/devices/SyrlinksHandler.h

@@ -104,9 +104,6 @@ class SyrlinksHandler : public DeviceHandlerBase {
   syrlinks::TemperatureSet temperatureSet;
 
   const power::Switch_t powerSwitch = power::NO_SWITCH;
-  // Use uint8_t for compatibility with parameter interface
-  uint8_t datarateCfgRaw = static_cast<uint8_t>(com::Datarate::LOW_RATE_MODULATION_BPSK);
-  // com::Datarate datarateCfg = com::Datarate::LOW_RATE_MODULATION_BPSK;
 
   bool debugMode = false;
   uint8_t agcValueHighByte = 0;

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);

mission/system/objects/ComSubsystem.cpp

@@ -1,5 +1,48 @@
 #include "ComSubsystem.h"
 
+#include <fsfw/ipc/MutexGuard.h>
+
+#include "mission/config/comCfg.h"
+
 ComSubsystem::ComSubsystem(object_id_t setObjectId, uint32_t maxNumberOfSequences,
                            uint32_t maxNumberOfTables)
-    : Subsystem(setObjectId, maxNumberOfSequences, maxNumberOfTables) {}
+    : Subsystem(setObjectId, maxNumberOfSequences, maxNumberOfTables), paramHelper(this) {
+  com::setCurrentDatarate(com::Datarate::LOW_RATE_MODULATION_BPSK);
+}
+
+MessageQueueId_t ComSubsystem::getCommandQueue() const { return Subsystem::getCommandQueue(); }
+
+ReturnValue_t ComSubsystem::getParameter(uint8_t domainId, uint8_t uniqueIdentifier,
+                                         ParameterWrapper *parameterWrapper,
+                                         const ParameterWrapper *newValues, uint16_t startAtIndex) {
+  if ((domainId == 0) and (uniqueIdentifier == static_cast<uint8_t>(com::ParameterId::DATARATE))) {
+    uint8_t newVal = 0;
+    ReturnValue_t result = newValues->getElement(&newVal);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    if (newVal >= static_cast<uint8_t>(com::Datarate::NUM_DATARATES)) {
+      return HasParametersIF::INVALID_VALUE;
+    }
+    parameterWrapper->set(datarateCfg);
+    com::setCurrentDatarate(static_cast<com::Datarate>(newVal));
+    return returnvalue::OK;
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t ComSubsystem::handleCommandMessage(CommandMessage *message) {
+  ReturnValue_t result = paramHelper.handleParameterMessage(message);
+  if (result == returnvalue::OK) {
+    return result;
+  }
+  return Subsystem::handleCommandMessage(message);
+}
+
+ReturnValue_t ComSubsystem::initialize() {
+  ReturnValue_t result = paramHelper.initialize();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  return Subsystem::initialize();
+}

mission/system/objects/ComSubsystem.h

@@ -1,13 +1,29 @@
 #ifndef MISSION_SYSTEM_COMSUBSYSTEM_H_
 #define MISSION_SYSTEM_COMSUBSYSTEM_H_
 
+#include <fsfw/parameters/HasParametersIF.h>
+#include <fsfw/parameters/ParameterHelper.h>
 #include <fsfw/subsystem/Subsystem.h>
 
-class ComSubsystem : public Subsystem {
+#include "mission/comDefs.h"
+
+class ComSubsystem : public Subsystem, public ReceivesParameterMessagesIF {
  public:
   ComSubsystem(object_id_t setObjectId, uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables);
+  virtual ~ComSubsystem() = default;
+
+  MessageQueueId_t getCommandQueue() const override;
+  ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueIdentifier,
+                             ParameterWrapper *parameterWrapper, const ParameterWrapper *newValues,
+                             uint16_t startAtIndex) override;
 
  private:
+  ReturnValue_t handleCommandMessage(CommandMessage *message) override;
+
+  ReturnValue_t initialize() override;
+
+  uint8_t datarateCfg = static_cast<uint8_t>(com::Datarate::LOW_RATE_MODULATION_BPSK);
+  ParameterHelper paramHelper;
 };
 
 #endif /* MISSION_SYSTEM_COMSUBSYSTEM_H_ */

mission/system/tree/CMakeLists.txt

@@ -1,2 +1,4 @@
-target_sources(${LIB_EIVE_MISSION} PRIVATE acsModeTree.cpp payloadModeTree.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)

mission/system/tree/comModeTree.cpp

@@ -0,0 +1,281 @@
+#include "comModeTree.h"
+
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+#include <fsfw/modes/HasModesIF.h>
+#include <fsfw/returnvalues/returnvalue.h>
+#include <fsfw/subsystem/Subsystem.h>
+
+#include "eive/objects.h"
+#include "mission/comDefs.h"
+#include "util.h"
+
+const auto check = subsystem::checkInsert;
+
+ComSubsystem satsystem::com::SUBSYSTEM = ComSubsystem(objects::COM_SUBSYSTEM, 12, 24);
+
+static const auto OFF = HasModesIF::MODE_OFF;
+static const auto ON = HasModesIF::MODE_ON;
+static const auto NML = DeviceHandlerIF::MODE_NORMAL;
+
+auto COM_SEQUENCE_RX_ONLY =
+    std::make_pair(::com::Submode::RX_ONLY, FixedArrayList<ModeListEntry, 3>());
+auto COM_TABLE_RX_ONLY_TGT =
+    std::make_pair((::com::Submode::RX_ONLY << 24) | 1, FixedArrayList<ModeListEntry, 3>());
+auto COM_TABLE_RX_ONLY_TRANS_0 =
+    std::make_pair((::com::Submode::RX_ONLY << 24) | 2, FixedArrayList<ModeListEntry, 3>());
+auto COM_TABLE_RX_ONLY_TRANS_1 =
+    std::make_pair((::com::Submode::RX_ONLY << 24) | 3, FixedArrayList<ModeListEntry, 3>());
+
+auto COM_SEQUENCE_RX_AND_TX_LOW_RATE =
+    std::make_pair(::com::Submode::RX_AND_TX_LOW_DATARATE, FixedArrayList<ModeListEntry, 3>());
+auto COM_TABLE_RX_AND_TX_LOW_RATE_TGT = std::make_pair(
+    (::com::Submode::RX_AND_TX_LOW_DATARATE << 24) | 1, FixedArrayList<ModeListEntry, 3>());
+auto COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_0 = std::make_pair(
+    (::com::Submode::RX_AND_TX_LOW_DATARATE << 24) | 2, FixedArrayList<ModeListEntry, 3>());
+auto COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_1 = std::make_pair(
+    (::com::Submode::RX_AND_TX_LOW_DATARATE << 24) | 3, FixedArrayList<ModeListEntry, 3>());
+
+auto COM_SEQUENCE_RX_AND_TX_HIGH_RATE =
+    std::make_pair(::com::Submode::RX_AND_TX_HIGH_DATARATE, FixedArrayList<ModeListEntry, 3>());
+auto COM_TABLE_RX_AND_TX_HIGH_RATE_TGT = std::make_pair(
+    (::com::Submode::RX_AND_TX_HIGH_DATARATE << 24) | 1, FixedArrayList<ModeListEntry, 3>());
+auto COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_0 = std::make_pair(
+    (::com::Submode::RX_AND_TX_HIGH_DATARATE << 24) | 2, FixedArrayList<ModeListEntry, 3>());
+auto COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_1 = std::make_pair(
+    (::com::Submode::RX_AND_TX_HIGH_DATARATE << 24) | 3, FixedArrayList<ModeListEntry, 3>());
+
+auto COM_SEQUENCE_RX_AND_TX_DEFAULT_RATE =
+    std::make_pair(::com::Submode::RX_AND_TX_DEFAULT_DATARATE, FixedArrayList<ModeListEntry, 3>());
+auto COM_TABLE_RX_AND_TX_DEFAULT_RATE_TGT = std::make_pair(
+    (::com::Submode::RX_AND_TX_DEFAULT_DATARATE << 24) | 1, FixedArrayList<ModeListEntry, 3>());
+auto COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_0 = std::make_pair(
+    (::com::Submode::RX_AND_TX_DEFAULT_DATARATE << 24) | 2, FixedArrayList<ModeListEntry, 3>());
+auto COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_1 = std::make_pair(
+    (::com::Submode::RX_AND_TX_DEFAULT_DATARATE << 24) | 3, FixedArrayList<ModeListEntry, 3>());
+
+namespace {
+
+void buildRxOnlySequence(Subsystem& ss, ModeListEntry& eh);
+void buildTxAndRxLowRateSequence(Subsystem& ss, ModeListEntry& eh);
+void buildTxAndRxHighRateSequence(Subsystem& ss, ModeListEntry& eh);
+void buildTxAndRxDefaultRateSequence(Subsystem& ss, ModeListEntry& eh);
+
+}  // namespace
+
+void satsystem::com::init() {
+  ModeListEntry entry;
+  buildRxOnlySequence(SUBSYSTEM, entry);
+  buildTxAndRxLowRateSequence(SUBSYSTEM, entry);
+  buildTxAndRxHighRateSequence(SUBSYSTEM, entry);
+  buildTxAndRxDefaultRateSequence(SUBSYSTEM, entry);
+  SUBSYSTEM.setInitialMode(NML, ::com::Submode::RX_ONLY);
+}
+
+namespace {
+
+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<ModeListEntry>& table) {
+    eh.setObject(obj);
+    eh.setMode(mode);
+    eh.setSubmode(submode);
+    check(table.insert(eh), ctxc);
+  };
+  // Insert Helper Sequence
+  auto ihs = [&](ArrayList<ModeListEntry>& 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 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 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_HANDLER, 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_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, false);
+  ihs(COM_SEQUENCE_RX_ONLY.second, COM_TABLE_RX_ONLY_TRANS_1.first, 0, false);
+  check(ss.addSequence(SequenceEntry(COM_SEQUENCE_RX_ONLY.first, &COM_SEQUENCE_RX_ONLY.second,
+                                     COM_SEQUENCE_RX_ONLY.first)),
+        ctxc);
+}
+
+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<ModeListEntry>& table) {
+    eh.setObject(obj);
+    eh.setMode(mode);
+    eh.setSubmode(submode);
+    check(table.insert(eh), ctxc);
+  };
+  // Insert Helper Sequence
+  auto ihs = [&](ArrayList<ModeListEntry>& 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_LOW_DATARATE,
+      COM_TABLE_RX_AND_TX_LOW_RATE_TGT.second);
+  iht(objects::CCSDS_HANDLER, ON, static_cast<Submode_t>(::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 and RX low datarate transition 0, switch CCSDS handler first
+  iht(objects::CCSDS_HANDLER, ON, static_cast<Submode_t>(::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 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, false);
+  ihs(COM_SEQUENCE_RX_AND_TX_LOW_RATE.second, COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_1.first, 0, false);
+  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<ModeListEntry>& table) {
+    eh.setObject(obj);
+    eh.setMode(mode);
+    eh.setSubmode(submode);
+    check(table.insert(eh), ctxc);
+  };
+  // Insert Helper Sequence
+  auto ihs = [&](ArrayList<ModeListEntry>& 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 high 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_HANDLER, ON, static_cast<Submode_t>(::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 high datarate transition 0, switch CCSDS handler first
+  iht(objects::CCSDS_HANDLER, ON, static_cast<Submode_t>(::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 high 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,
+      false);
+  ihs(COM_SEQUENCE_RX_AND_TX_HIGH_RATE.second, COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_1.first, 0,
+      false);
+  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);
+}
+
+void buildTxAndRxDefaultRateSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::com::buildTxAndRxDefaultRateSequence";
+  auto ctxc = context.c_str();
+  // Insert Helper Table
+  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode, ArrayList<ModeListEntry>& table) {
+    eh.setObject(obj);
+    eh.setMode(mode);
+    eh.setSubmode(submode);
+    check(table.insert(eh), ctxc);
+  };
+  // Insert Helper Sequence
+  auto ihs = [&](ArrayList<ModeListEntry>& 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 default datarate table.
+  iht(objects::SYRLINKS_HANDLER, NML, ::com::Submode::RX_AND_TX_DEFAULT_DATARATE,
+      COM_TABLE_RX_AND_TX_DEFAULT_RATE_TGT.second);
+  iht(objects::CCSDS_HANDLER, ON, static_cast<Submode_t>(::com::CcsdsSubmode::DATARATE_DEFAULT),
+      COM_TABLE_RX_AND_TX_DEFAULT_RATE_TGT.second);
+  check(ss.addTable(TableEntry(COM_TABLE_RX_AND_TX_DEFAULT_RATE_TGT.first,
+                               &COM_TABLE_RX_AND_TX_DEFAULT_RATE_TGT.second)),
+        ctxc);
+
+  // Build TX and RX low datarate transition 0, switch CCSDS handler first
+  iht(objects::CCSDS_HANDLER, ON, static_cast<Submode_t>(::com::CcsdsSubmode::DATARATE_DEFAULT),
+      COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_0.second);
+  check(ss.addTable(TableEntry(COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_0.first,
+                               &COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_0.second)),
+        ctxc);
+
+  // Build TX and RX default transition 1
+  iht(objects::SYRLINKS_HANDLER, NML, ::com::Submode::RX_AND_TX_DEFAULT_DATARATE,
+      COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_1.second);
+  check(ss.addTable(TableEntry(COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_1.first,
+                               &COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_1.second)),
+        ctxc);
+
+  // Build TX and RX default datarate sequence
+  ihs(COM_SEQUENCE_RX_AND_TX_DEFAULT_RATE.second, COM_TABLE_RX_AND_TX_DEFAULT_RATE_TGT.first, 0,
+      true);
+  ihs(COM_SEQUENCE_RX_AND_TX_DEFAULT_RATE.second, COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_0.first, 0,
+      false);
+  ihs(COM_SEQUENCE_RX_AND_TX_DEFAULT_RATE.second, COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_1.first, 0,
+      false);
+  check(ss.addSequence(SequenceEntry(COM_SEQUENCE_RX_AND_TX_DEFAULT_RATE.first,
+                                     &COM_SEQUENCE_RX_AND_TX_DEFAULT_RATE.second,
+                                     COM_SEQUENCE_RX_ONLY.first)),
+        ctxc);
+}
+
+}  // namespace

mission/system/tree/comModeTree.h

@@ -0,0 +1,16 @@
+#ifndef MISSION_SYSTEM_TREE_COMMODETREE_H_
+#define MISSION_SYSTEM_TREE_COMMODETREE_H_
+
+#include <mission/system/objects/ComSubsystem.h>
+
+namespace satsystem {
+
+namespace com {
+extern ComSubsystem SUBSYSTEM;
+
+void init();
+}  // namespace com
+
+}  // namespace satsystem
+
+#endif /* MISSION_SYSTEM_TREE_COMMODETREE_H_ */

mission/system/tree/system.cpp

@@ -1,6 +1,7 @@
 #include "system.h"
 
 #include "acsModeTree.h"
+#include "comModeTree.h"
 #include "payloadModeTree.h"
 #include "tcsModeTree.h"
 
@@ -8,4 +9,5 @@ void satsystem::init() {
   acs::init();
   pl::init();
   tcs::init();
+  com::init();
 }

mission/tmtc/CcsdsIpCoreHandler.cpp

@@ -1,7 +1,9 @@
 #include "CcsdsIpCoreHandler.h"
 
+#include <fsfw/subsystem/helper.h>
 #include <linux/ipcore/PdecHandler.h>
 #include <linux/ipcore/PtmeConfig.h>
+#include <mission/config/comCfg.h>
 
 #include "eive/definitions.h"
 #include "fsfw/events/EventManagerIF.h"
@@ -133,10 +135,12 @@ ReturnValue_t CcsdsIpCoreHandler::initialize() {
     return ObjectManagerIF::CHILD_INIT_FAILED;
   }
 
+  transmitterCountdown.setTimeout(transmitterTimeout);
+  transmitterCountdown.timeOut();
+
 #if OBSW_SYRLINKS_SIMULATED == 1
   // Update data on rising edge
   ptmeConfig->invertTxClock(false);
-  transmitterCountdown.setTimeout(transmitterTimeout);
   linkState = UP;
   forwardLinkstate();
 #endif /* OBSW_SYRLINKS_SIMULATED == 1*/
@@ -228,12 +232,12 @@ ReturnValue_t CcsdsIpCoreHandler::executeAction(ActionId_t actionId, MessageQueu
   ReturnValue_t result = returnvalue::OK;
   switch (actionId) {
     case SET_LOW_RATE: {
-      submode = static_cast<Submode_t>(Submode::DATARATE_LOW);
+      submode = static_cast<Submode_t>(com::CcsdsSubmode::DATARATE_LOW);
       result = ptmeConfig->setRate(RATE_100KBPS);
       break;
     }
     case SET_HIGH_RATE: {
-      submode = static_cast<Submode_t>(Submode::DATARATE_HIGH);
+      submode = static_cast<Submode_t>(com::CcsdsSubmode::DATARATE_HIGH);
       result = ptmeConfig->setRate(RATE_500KBPS);
       break;
     }
@@ -346,6 +350,9 @@ void CcsdsIpCoreHandler::enableTransmit() {
   gpioIF->pullHigh(enTxClock);
   gpioIF->pullHigh(enTxData);
 #endif
+  linkState = UP;
+  forwardLinkstate();
+  transmitterCountdown.resetTimer();
 }
 
 void CcsdsIpCoreHandler::checkTxTimer() {
@@ -354,6 +361,7 @@ void CcsdsIpCoreHandler::checkTxTimer() {
   }
   if (transmitterCountdown.hasTimedOut()) {
     disableTransmit();
+    //TODO: set mode to off (move timer to subsystem)
   }
 }
 
@@ -365,8 +373,9 @@ 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_t>(Submode::DATARATE_HIGH) and
-        submode != static_cast<Submode_t>(Submode::DATARATE_LOW)) {
+    if (submode != static_cast<Submode_t>(com::CcsdsSubmode::DATARATE_HIGH) and
+        submode != static_cast<Submode_t>(com::CcsdsSubmode::DATARATE_LOW) and
+        submode != static_cast<Submode_t>(com::CcsdsSubmode::DATARATE_DEFAULT)) {
       return HasModesIF::INVALID_SUBMODE;
     }
   } else if (mode != HasModesIF::MODE_OFF) {
@@ -377,24 +386,40 @@ ReturnValue_t CcsdsIpCoreHandler::checkModeCommand(Mode_t mode, Submode_t submod
 }
 
 void CcsdsIpCoreHandler::startTransition(Mode_t mode, Submode_t submode) {
+  auto rateHigh = [&]() {
+    ReturnValue_t result = ptmeConfig->setRate(RATE_500KBPS);
+    if (result == returnvalue::OK) {
+      this->mode = HasModesIF::MODE_ON;
+    }
+  };
+  auto rateLow = [&]() {
+    ReturnValue_t result = ptmeConfig->setRate(RATE_100KBPS);
+    if (result == returnvalue::OK) {
+      this->mode = HasModesIF::MODE_ON;
+    }
+  };
   if (mode == HasModesIF::MODE_ON) {
     enableTransmit();
-    if (submode == static_cast<Submode_t>(Submode::DATARATE_HIGH)) {
-      ReturnValue_t result = ptmeConfig->setRate(RATE_500KBPS);
-      if (result == returnvalue::OK) {
-        mode = HasModesIF::MODE_ON;
-      }
-    } else if (submode == static_cast<Submode_t>(Submode::DATARATE_LOW)) {
-      ReturnValue_t result = ptmeConfig->setRate(RATE_100KBPS);
-      if (result == returnvalue::OK) {
-        mode = HasModesIF::MODE_ON;
+    if (submode == static_cast<Submode_t>(com::CcsdsSubmode::DATARATE_DEFAULT)) {
+      com::Datarate currentDatarate = com::getCurrentDatarate();
+      if (currentDatarate == com::Datarate::LOW_RATE_MODULATION_BPSK) {
+        rateLow();
+      } else if (currentDatarate == com::Datarate::HIGH_RATE_MODULATION_0QPSK) {
+        rateHigh();
       }
+    } else if (submode == static_cast<Submode_t>(com::CcsdsSubmode::DATARATE_HIGH)) {
+      rateHigh();
+    } else if (submode == static_cast<Submode_t>(com::CcsdsSubmode::DATARATE_LOW)) {
+      rateLow();
     }
+
   } else if (mode == HasModesIF::MODE_OFF) {
     disableTransmit();
-    mode = HasModesIF::MODE_OFF;
+    this->mode = HasModesIF::MODE_OFF;
   }
+  this->submode = submode;
   modeHelper.modeChanged(mode, submode);
+  announceMode(false);
 }
 
 void CcsdsIpCoreHandler::announceMode(bool recursive) { triggerEvent(MODE_INFO, mode, submode); }
@@ -406,7 +431,19 @@ void CcsdsIpCoreHandler::disableTransmit() {
 #endif
   linkState = DOWN;
   forwardLinkstate();
-  transmitterCountdown.setTimeout(0);
+  transmitterCountdown.timeOut();
 }
 
 const char* CcsdsIpCoreHandler::getName() const { return "CCSDS Handler"; }
+
+const HasHealthIF* CcsdsIpCoreHandler::getOptHealthIF() const { return nullptr; }
+
+const HasModesIF& CcsdsIpCoreHandler::getModeIF() const { return *this; }
+
+ReturnValue_t CcsdsIpCoreHandler::connectModeTreeParent(HasModeTreeChildrenIF& parent) {
+  return modetree::connectModeTreeParent(parent, *this, nullptr, modeHelper);
+}
+
+ModeTreeChildIF& CcsdsIpCoreHandler::getModeTreeChildIF() { return *this; }
+
+object_id_t CcsdsIpCoreHandler::getObjectId() const { return SystemObject::getObjectId(); }

mission/tmtc/CcsdsIpCoreHandler.h

@@ -15,6 +15,7 @@
 #include "fsfw/objectmanager/SystemObject.h"
 #include "fsfw/parameters/ParameterHelper.h"
 #include "fsfw/returnvalues/returnvalue.h"
+#include "fsfw/subsystem/ModeTreeConnectionIF.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
 #include "fsfw/timemanager/Countdown.h"
 #include "fsfw/tmtcservices/AcceptsTelecommandsIF.h"
@@ -22,8 +23,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
@@ -36,6 +36,8 @@ enum class Submode : uint8_t { UNSET = 0, DATARATE_LOW = 1, DATARATE_HIGH = 2 };
  */
 class CcsdsIpCoreHandler : public SystemObject,
                            public ExecutableObjectIF,
+                           public ModeTreeChildIF,
+                           public ModeTreeConnectionIF,
                            public HasModesIF,
                            public AcceptsTelemetryIF,
                            public AcceptsTelecommandsIF,
@@ -92,6 +94,11 @@ class CcsdsIpCoreHandler : public SystemObject,
 
   virtual ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
                                       const uint8_t* data, size_t size);
+  const HasHealthIF* getOptHealthIF() const override;
+  const HasModesIF& getModeIF() const override;
+  object_id_t getObjectId() const override;
+  ReturnValue_t connectModeTreeParent(HasModeTreeChildrenIF& parent) override;
+  ModeTreeChildIF& getModeTreeChildIF() override;
 
  private:
   static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_HANDLER;
@@ -139,7 +146,7 @@ class CcsdsIpCoreHandler : public SystemObject,
 
   ActionHelper actionHelper;
   Mode_t mode = HasModesIF::MODE_OFF;
-  Submode_t submode = static_cast<Submode_t>(Submode::UNSET);
+  Submode_t submode = static_cast<Submode_t>(com::CcsdsSubmode::UNSET);
   ModeHelper modeHelper;
 
   MessageQueueId_t tcDistributorQueueId = MessageQueueIF::NO_QUEUE;