Merge remote-tracking branch 'origin/develop' into mueller/tas_ploc_supv_update

mission/devices/devicedefinitions/payloadPcduDefinitions.h

@@ -101,6 +101,9 @@ enum NormalSubmodeBits {
 };
 
 static constexpr Submode_t ALL_OFF_SUBMODE = 0;
+static constexpr Submode_t ALL_ON_SUBMODE = (1 << HPA_ON) | (1 << MPA_ON) | (1 << TX_ON) |
+                                            (1 << X8_ON) | (1 << DRO_ON) |
+                                            (1 << SOLID_STATE_RELAYS_ADC_ON);
 
 // 12 ADC values * 2 + trailing zero
 static constexpr size_t ADC_REPLY_SIZE = 25;

mission/system/objects/CMakeLists.txt

@@ -1,6 +1,7 @@
 target_sources(
   ${LIB_EIVE_MISSION}
   PRIVATE EiveSystem.cpp
+          CamSwitcher.cpp
           AcsSubsystem.cpp
           ComSubsystem.cpp
           PayloadSubsystem.cpp

mission/system/objects/CamSwitcher.cpp

@@ -0,0 +1,5 @@
+#include "CamSwitcher.h"
+
+CamSwitcher::CamSwitcher(object_id_t objectId, PowerSwitchIF &pwrSwitcher,
+                         power::Switch_t pwrSwitch)
+    : PowerSwitcherComponent(objectId, &pwrSwitcher, pwrSwitch) {}

mission/system/objects/CamSwitcher.h

@@ -0,0 +1,13 @@
+#ifndef MISSION_SYSTEM_OBJECTS_CAMSWITCHER_H_
+#define MISSION_SYSTEM_OBJECTS_CAMSWITCHER_H_
+
+#include <fsfw/power/PowerSwitcherComponent.h>
+
+class CamSwitcher : public PowerSwitcherComponent {
+ public:
+  CamSwitcher(object_id_t objectId, PowerSwitchIF &pwrSwitcher, power::Switch_t pwrSwitch);
+
+ private:
+};
+
+#endif /* MISSION_SYSTEM_OBJECTS_CAMSWITCHER_H_ */

mission/system/objects/definitions.h

@@ -16,4 +16,16 @@ enum Submodes : Submode_t { A_SIDE = 0, B_SIDE = 1, DUAL_MODE = 2 };
 
 }  // namespace duallane
 
+namespace payload {
+
+enum Modes { NONE = 0, SUPV_ONLY = 1, MPSOC_STREAM = 2, CAM_STREAM = 3, EARTH_OBSV = 4, SCEX = 5 };
+
+namespace ploc {
+
+enum Modes { OFF = 0, SUPV_ONLY = 1, MPSOC_ON = 2 };
+
+}
+
+}  // namespace payload
+
 #endif /* MISSION_SYSTEM_DEFINITIONS_H_ */

mission/system/tree/CMakeLists.txt

@@ -1 +1,2 @@
-target_sources(${LIB_EIVE_MISSION} PRIVATE acsModeTree.cpp)
+target_sources(${LIB_EIVE_MISSION} PRIVATE acsModeTree.cpp payloadModeTree.cpp
+                                           system.cpp util.cpp)

mission/system/tree/acsModeTree.cpp

@@ -8,19 +8,22 @@
 
 #include "eive/objects.h"
 #include "mission/controller/controllerdefinitions/AcsControllerDefinitions.h"
+#include "util.h"
 
-Subsystem satsystem::ACS_SUBSYSTEM(objects::ACS_SUBSYSTEM, 12, 24);
+Subsystem satsystem::acs::ACS_SUBSYSTEM(objects::ACS_SUBSYSTEM, 12, 24);
+
+namespace {
+// Alias for checker function
+const auto check = subsystem::checkInsert;
 
-void checkInsert(ReturnValue_t result, const char* ctx);
 void buildOffSequence(Subsystem* ss, ModeListEntry& eh);
 void buildDetumbleSequence(Subsystem* ss, ModeListEntry& entryHelper);
 void buildSafeSequence(Subsystem* ss, ModeListEntry& entryHelper);
 void buildIdleSequence(Subsystem* ss, ModeListEntry& entryHelper);
 void buildIdleChargeSequence(Subsystem* ss, ModeListEntry& entryHelper);
 void buildTargetPtSequence(Subsystem* ss, ModeListEntry& entryHelper);
+}  // namespace
 
-// Alias for checker function
-const auto check = checkInsert;
 static const auto OFF = HasModesIF::MODE_OFF;
 static const auto NML = DeviceHandlerIF::MODE_NORMAL;
 
@@ -76,7 +79,7 @@ auto ACS_TABLE_TARGET_PT_TRANS_0 =
 auto ACS_TABLE_TARGET_PT_TRANS_1 =
     std::make_pair((acs::CtrlModes::TARGET_PT << 24) | 3, FixedArrayList<ModeListEntry, 1>());
 
-void satsystem::initAcsSubsystem(object_id_t satSystemObjId) {
+void satsystem::acs::init() {
   ModeListEntry entry;
   buildOffSequence(&ACS_SUBSYSTEM, entry);
   buildSafeSequence(&ACS_SUBSYSTEM, entry);
@@ -87,8 +90,10 @@ void satsystem::initAcsSubsystem(object_id_t satSystemObjId) {
   ACS_SUBSYSTEM.setInitialMode(HasModesIF::MODE_OFF);
 }
 
+namespace {
+
 void buildOffSequence(Subsystem* ss, ModeListEntry& eh) {
-  std::string context = "satsystem::buildOffSequence";
+  std::string context = "satsystem::acs::buildOffSequence";
   auto ctxc = context.c_str();
   // Insert Helper Table
   auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode, ArrayList<ModeListEntry>& table) {
@@ -127,7 +132,7 @@ void buildOffSequence(Subsystem* ss, ModeListEntry& eh) {
 }
 
 void buildSafeSequence(Subsystem* ss, ModeListEntry& eh) {
-  std::string context = "satsystem::buildSafeSequence";
+  std::string context = "satsystem::acs::buildSafeSequence";
   auto ctxc = context.c_str();
   // Insert Helper Table
   auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode,
@@ -176,7 +181,7 @@ void buildSafeSequence(Subsystem* ss, ModeListEntry& eh) {
 }
 
 void buildDetumbleSequence(Subsystem* ss, ModeListEntry& eh) {
-  std::string context = "satsystem::buildDetumbleSequence";
+  std::string context = "satsystem::acs::buildDetumbleSequence";
   auto ctxc = context.c_str();
   // Insert Helper Table
   auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode,
@@ -228,7 +233,7 @@ void buildDetumbleSequence(Subsystem* ss, ModeListEntry& eh) {
 }
 
 void buildIdleSequence(Subsystem* ss, ModeListEntry& eh) {
-  std::string context = "satsystem::buildIdleSequence";
+  std::string context = "satsystem::acs::buildIdleSequence";
   auto ctxc = context.c_str();
   // Insert Helper Table
   auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode,
@@ -275,7 +280,7 @@ void buildIdleSequence(Subsystem* ss, ModeListEntry& eh) {
 }
 
 void buildIdleChargeSequence(Subsystem* ss, ModeListEntry& eh) {
-  std::string context = "satsystem::buildIdleChargeSequence";
+  std::string context = "satsystem::acs::buildIdleChargeSequence";
   auto ctxc = context.c_str();
   // Insert Helper Table
   auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode,
@@ -329,7 +334,7 @@ void buildIdleChargeSequence(Subsystem* ss, ModeListEntry& eh) {
 }
 
 void buildTargetPtSequence(Subsystem* ss, ModeListEntry& eh) {
-  std::string context = "satsystem::buildTargetPtSequence";
+  std::string context = "satsystem::acs::buildTargetPtSequence";
   auto ctxc = context.c_str();
   // Insert Helper Table
   auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode,
@@ -383,15 +388,4 @@ void buildTargetPtSequence(Subsystem* ss, ModeListEntry& eh) {
         ctxc);
 }
 
-void checkInsert(ReturnValue_t result, const char* ctx) {
-  if (result != returnvalue::OK) {
-    sif::warning << "satsystem::checkInsert: Insertion failed at " << ctx;
-    if (result == mapdefs::KEY_ALREADY_EXISTS) {
-      sif::warning << ": Key already exists" << std::endl;
-    } else if (result == mapdefs::MAP_FULL) {
-      sif::warning << ": Map full" << std::endl;
-    } else {
-      sif::warning << std::endl;
-    }
-  }
-}
+}  // namespace

mission/system/tree/acsModeTree.h

@@ -3,9 +3,10 @@
 class Subsystem;
 
 namespace satsystem {
+namespace acs {
 
 extern Subsystem ACS_SUBSYSTEM;
+void init();
 
-void initAcsSubsystem(object_id_t satSystemObjId);
-
+}  // namespace acs
 }  // namespace satsystem

mission/system/tree/payloadModeTree.cpp

@@ -0,0 +1,372 @@
+#include "payloadModeTree.h"
+
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+#include <fsfw/modes/HasModesIF.h>
+#include <fsfw/retval.h>
+#include <fsfw/subsystem/Subsystem.h>
+
+#include "eive/objects.h"
+#include "mission/devices/devicedefinitions/payloadPcduDefinitions.h"
+#include "mission/system/objects/PayloadSubsystem.h"
+#include "mission/system/objects/definitions.h"
+#include "util.h"
+
+namespace {
+void initOffSequence(Subsystem& ss, ModeListEntry& eh);
+void initPlMpsocStreamSequence(Subsystem& ss, ModeListEntry& eh);
+void initPlCamStreamSequence(Subsystem& ss, ModeListEntry& eh);
+void initPlSpvSequence(Subsystem& ss, ModeListEntry& eh);
+void initEarthObsvSequence(Subsystem& ss, ModeListEntry& eh);
+void initScexSequence(Subsystem& ss, ModeListEntry& eh);
+}  // namespace
+
+Subsystem satsystem::pl::SUBSYSTEM = Subsystem(objects::PL_SUBSYSTEM, 12, 24);
+
+const auto check = subsystem::checkInsert;
+static const auto OFF = HasModesIF::MODE_OFF;
+static const auto ON = HasModesIF::MODE_ON;
+static const auto NML = DeviceHandlerIF::MODE_NORMAL;
+
+auto PL_SEQUENCE_OFF = std::make_pair(OFF << 24, FixedArrayList<ModeListEntry, 3>());
+auto PL_TABLE_OFF_TGT = std::make_pair((OFF << 24) | 1, FixedArrayList<ModeListEntry, 0>());
+auto PL_TABLE_OFF_TRANS_0 = std::make_pair((OFF << 24) | 2, FixedArrayList<ModeListEntry, 5>());
+auto PL_TABLE_OFF_TRANS_1 = std::make_pair((OFF << 24) | 3, FixedArrayList<ModeListEntry, 1>());
+
+auto PL_SEQUENCE_MPSOC_STREAM =
+    std::make_pair(payload::Modes::MPSOC_STREAM << 24, FixedArrayList<ModeListEntry, 3>());
+auto PL_TABLE_MPSOC_STREAM_TGT =
+    std::make_pair((payload::Modes::MPSOC_STREAM << 24) | 1, FixedArrayList<ModeListEntry, 5>());
+auto PL_TABLE_MPSOC_STREAM_TRANS_0 =
+    std::make_pair((payload::Modes::MPSOC_STREAM << 24) | 2, FixedArrayList<ModeListEntry, 4>());
+auto PL_TABLE_MPSOC_STREAM_TRANS_1 =
+    std::make_pair((payload::Modes::MPSOC_STREAM << 24) | 3, FixedArrayList<ModeListEntry, 2>());
+
+auto PL_SEQUENCE_CAM_STREAM =
+    std::make_pair(payload::Modes::CAM_STREAM << 24, FixedArrayList<ModeListEntry, 3>());
+auto PL_TABLE_CAM_STREAM_TGT =
+    std::make_pair((payload::Modes::CAM_STREAM << 24) | 1, FixedArrayList<ModeListEntry, 2>());
+auto PL_TABLE_CAM_STREAM_TRANS_0 =
+    std::make_pair((payload::Modes::CAM_STREAM << 24) | 2, FixedArrayList<ModeListEntry, 4>());
+auto PL_TABLE_CAM_STREAM_TRANS_1 =
+    std::make_pair((payload::Modes::CAM_STREAM << 24) | 3, FixedArrayList<ModeListEntry, 2>());
+
+auto PL_SEQUENCE_SUPV_ONLY =
+    std::make_pair(payload::Modes::SUPV_ONLY << 24, FixedArrayList<ModeListEntry, 3>());
+auto PL_TABLE_SUPV_ONLY_TGT =
+    std::make_pair((payload::Modes::SUPV_ONLY << 24) | 1, FixedArrayList<ModeListEntry, 5>());
+auto PL_TABLE_SUPV_ONLY_TRANS_0 =
+    std::make_pair((payload::Modes::SUPV_ONLY << 24) | 2, FixedArrayList<ModeListEntry, 5>());
+auto PL_TABLE_SUPV_ONLY_TRANS_1 =
+    std::make_pair((payload::Modes::SUPV_ONLY << 24) | 3, FixedArrayList<ModeListEntry, 5>());
+
+auto PL_SEQUENCE_EARTH_OBSV =
+    std::make_pair(payload::Modes::EARTH_OBSV << 24, FixedArrayList<ModeListEntry, 3>());
+auto PL_TABLE_EARTH_OBSV_TGT =
+    std::make_pair((payload::Modes::EARTH_OBSV << 24) | 1, FixedArrayList<ModeListEntry, 5>());
+auto PL_TABLE_EARTH_OBSV_TRANS_0 =
+    std::make_pair((payload::Modes::EARTH_OBSV << 24) | 2, FixedArrayList<ModeListEntry, 3>());
+auto PL_TABLE_EARTH_OBSV_TRANS_1 =
+    std::make_pair((payload::Modes::EARTH_OBSV << 24) | 3, FixedArrayList<ModeListEntry, 2>());
+
+auto PL_SEQUENCE_SCEX =
+    std::make_pair(payload::Modes::SCEX << 24, FixedArrayList<ModeListEntry, 2>());
+auto PL_TABLE_SCEX_TGT =
+    std::make_pair((payload::Modes::SCEX << 24) | 1, FixedArrayList<ModeListEntry, 1>());
+auto PL_TABLE_SCEX_TRANS_0 =
+    std::make_pair((payload::Modes::SCEX << 24) | 2, FixedArrayList<ModeListEntry, 1>());
+
+void satsystem::pl::init() {
+  ModeListEntry entry;
+  initOffSequence(SUBSYSTEM, entry);
+  initPlMpsocStreamSequence(SUBSYSTEM, entry);
+  initPlCamStreamSequence(SUBSYSTEM, entry);
+  initPlSpvSequence(SUBSYSTEM, entry);
+  initEarthObsvSequence(SUBSYSTEM, entry);
+  initScexSequence(SUBSYSTEM, entry);
+  SUBSYSTEM.setInitialMode(OFF);
+}
+
+namespace {
+
+void initOffSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::payload::buildOffSequence";
+  auto ctxc = context.c_str();
+  // Insert Helper Table
+  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode,
+                 ArrayList<ModeListEntry>& sequence) {
+    eh.setObject(obj);
+    eh.setMode(mode);
+    eh.setSubmode(submode);
+    check(sequence.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 OFF target. Is empty
+  check(ss.addTable(TableEntry(PL_TABLE_OFF_TGT.first, &PL_TABLE_OFF_TGT.second)), ctxc);
+
+  // Build OFF transition 0
+  iht(objects::CAM_SWITCHER, OFF, 0, PL_TABLE_OFF_TRANS_0.second);
+  iht(objects::SCEX, OFF, 0, PL_TABLE_OFF_TRANS_0.second);
+  iht(objects::PLPCDU_HANDLER, OFF, 0, PL_TABLE_OFF_TRANS_0.second);
+  iht(objects::PLOC_MPSOC_HANDLER, OFF, 0, PL_TABLE_OFF_TRANS_0.second);
+  check(ss.addTable(TableEntry(PL_TABLE_OFF_TRANS_0.first, &PL_TABLE_OFF_TRANS_0.second)), ctxc);
+
+  // Build OFF transition 1
+  iht(objects::PLOC_SUPERVISOR_HANDLER, OFF, 0, PL_TABLE_OFF_TRANS_1.second);
+  check(ss.addTable(TableEntry(PL_TABLE_OFF_TRANS_1.first, &PL_TABLE_OFF_TRANS_1.second)), ctxc);
+
+  // Build OFF sequence
+  ihs(PL_SEQUENCE_OFF.second, PL_TABLE_OFF_TGT.first, 0, false);
+  ihs(PL_SEQUENCE_OFF.second, PL_TABLE_OFF_TRANS_0.first, 0, false);
+  ihs(PL_SEQUENCE_OFF.second, PL_TABLE_OFF_TRANS_1.first, 0, false);
+  check(ss.addSequence(
+            SequenceEntry(PL_SEQUENCE_OFF.first, &PL_SEQUENCE_OFF.second, PL_SEQUENCE_OFF.first)),
+        ctxc);
+}
+
+void initPlMpsocStreamSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::payload::initPlMpsocStreamSequence";
+  auto ctxc = context.c_str();
+  // Insert Helper Table
+  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode,
+                 ArrayList<ModeListEntry>& sequence) {
+    eh.setObject(obj);
+    eh.setMode(mode);
+    eh.setSubmode(submode);
+    check(sequence.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 MPSoC stream target
+  // Camera should always be off to prevent a conflict with the MPSoC streaming
+  // PL PCDU must be on and in normal mode, but this is commanded separately because of the
+  // number of commands invovled
+  iht(objects::PLPCDU_HANDLER, NML, plpcdu::ALL_ON_SUBMODE, PL_TABLE_MPSOC_STREAM_TGT.second);
+  iht(objects::CAM_SWITCHER, OFF, 0, PL_TABLE_MPSOC_STREAM_TGT.second);
+  iht(objects::PLOC_MPSOC_HANDLER, NML, 0, PL_TABLE_MPSOC_STREAM_TGT.second);
+  iht(objects::PLOC_SUPERVISOR_HANDLER, NML, 0, PL_TABLE_MPSOC_STREAM_TGT.second);
+  check(ss.addTable(TableEntry(PL_TABLE_MPSOC_STREAM_TGT.first, &PL_TABLE_MPSOC_STREAM_TGT.second)),
+        ctxc);
+
+  // Build MPSoC stream transition 0
+  iht(objects::CAM_SWITCHER, OFF, 0, PL_TABLE_MPSOC_STREAM_TRANS_0.second);
+  iht(objects::SCEX, OFF, 0, PL_TABLE_MPSOC_STREAM_TRANS_0.second);
+  iht(objects::PLOC_SUPERVISOR_HANDLER, NML, 0, PL_TABLE_MPSOC_STREAM_TRANS_0.second);
+  check(ss.addTable(
+            TableEntry(PL_TABLE_MPSOC_STREAM_TRANS_0.first, &PL_TABLE_MPSOC_STREAM_TRANS_0.second)),
+        ctxc);
+
+  // Build MPSoC stream transition 1
+  iht(objects::PLOC_MPSOC_HANDLER, NML, 0, PL_TABLE_MPSOC_STREAM_TRANS_1.second);
+  check(ss.addTable(
+            TableEntry(PL_TABLE_MPSOC_STREAM_TRANS_1.first, &PL_TABLE_MPSOC_STREAM_TRANS_1.second)),
+        ctxc);
+
+  // Build MPSoC stream sequence
+  ihs(PL_SEQUENCE_MPSOC_STREAM.second, PL_TABLE_MPSOC_STREAM_TGT.first, 0, true);
+  ihs(PL_SEQUENCE_MPSOC_STREAM.second, PL_TABLE_MPSOC_STREAM_TRANS_0.first, 0, true);
+  ihs(PL_SEQUENCE_MPSOC_STREAM.second, PL_TABLE_MPSOC_STREAM_TRANS_1.first, 0, false);
+  check(ss.addSequence(SequenceEntry(PL_SEQUENCE_MPSOC_STREAM.first,
+                                     &PL_SEQUENCE_MPSOC_STREAM.second, PL_SEQUENCE_OFF.first)),
+        ctxc);
+}
+
+void initPlCamStreamSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::payload::initPlCamStreamSequence";
+  auto ctxc = context.c_str();
+  // Insert Helper Table
+  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode,
+                 ArrayList<ModeListEntry>& sequence) {
+    eh.setObject(obj);
+    eh.setMode(mode);
+    eh.setSubmode(submode);
+    check(sequence.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 CAM target
+  // Only check that the PL PCDU is on for now. It might later become necessary to switch on
+  // the PLOC, so we ignore its state.
+  iht(objects::PLPCDU_HANDLER, NML, plpcdu::ALL_ON_SUBMODE, PL_TABLE_CAM_STREAM_TGT.second);
+  check(ss.addTable(TableEntry(PL_TABLE_CAM_STREAM_TGT.first, &PL_TABLE_CAM_STREAM_TGT.second)),
+        ctxc);
+
+  // Build CAM transition 0
+  // PLOC is actively commanded off here
+  iht(objects::PLOC_MPSOC_HANDLER, OFF, 0, PL_TABLE_CAM_STREAM_TRANS_0.second);
+  iht(objects::CAM_SWITCHER, ON, 0, PL_TABLE_CAM_STREAM_TRANS_0.second);
+  iht(objects::SCEX, OFF, 0, PL_TABLE_CAM_STREAM_TRANS_0.second);
+  check(ss.addTable(
+            TableEntry(PL_TABLE_CAM_STREAM_TRANS_0.first, &PL_TABLE_CAM_STREAM_TRANS_0.second)),
+        ctxc);
+
+  // Build CAM transition 1
+  iht(objects::PLOC_SUPERVISOR_HANDLER, OFF, 0, PL_TABLE_CAM_STREAM_TRANS_1.second);
+  check(ss.addTable(
+            TableEntry(PL_TABLE_CAM_STREAM_TRANS_1.first, &PL_TABLE_CAM_STREAM_TRANS_1.second)),
+        ctxc);
+
+  // Build CAM stream sequence
+  ihs(PL_SEQUENCE_CAM_STREAM.second, PL_TABLE_CAM_STREAM_TGT.first, 0, true);
+  ihs(PL_SEQUENCE_CAM_STREAM.second, PL_TABLE_CAM_STREAM_TRANS_0.first, 0, true);
+  ihs(PL_SEQUENCE_CAM_STREAM.second, PL_TABLE_CAM_STREAM_TRANS_1.first, 0, false);
+  check(ss.addSequence(SequenceEntry(PL_SEQUENCE_CAM_STREAM.first, &PL_SEQUENCE_CAM_STREAM.second,
+                                     PL_SEQUENCE_OFF.first)),
+        ctxc);
+}
+
+void initPlSpvSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::payload::initPlSupvSequence";
+  auto ctxc = context.c_str();
+  // Insert Helper Table
+  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode,
+                 ArrayList<ModeListEntry>& sequence) {
+    eh.setObject(obj);
+    eh.setMode(mode);
+    eh.setSubmode(submode);
+    check(sequence.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 Payload Supervisor Only target
+  iht(objects::PLOC_SUPERVISOR_HANDLER, NML, 0, PL_TABLE_SUPV_ONLY_TGT.second);
+  check(ss.addTable(TableEntry(PL_TABLE_SUPV_ONLY_TGT.first, &PL_TABLE_SUPV_ONLY_TGT.second)),
+        ctxc);
+
+  // Build Payload Supervisor Only transition 0
+  iht(objects::PLOC_SUPERVISOR_HANDLER, NML, 0, PL_TABLE_SUPV_ONLY_TRANS_0.second);
+  iht(objects::CAM_SWITCHER, OFF, 0, PL_TABLE_SUPV_ONLY_TRANS_0.second);
+  check(
+      ss.addTable(TableEntry(PL_TABLE_SUPV_ONLY_TRANS_0.first, &PL_TABLE_SUPV_ONLY_TRANS_0.second)),
+      ctxc);
+
+  // Build Payload Supervisor Only transition 1
+  iht(objects::PLOC_MPSOC_HANDLER, OFF, 0, PL_TABLE_SUPV_ONLY_TRANS_1.second);
+  check(
+      ss.addTable(TableEntry(PL_TABLE_SUPV_ONLY_TRANS_1.first, &PL_TABLE_SUPV_ONLY_TRANS_1.second)),
+      ctxc);
+
+  // Build Payload Supervisor Only Sequence
+  ihs(PL_SEQUENCE_SUPV_ONLY.second, PL_TABLE_SUPV_ONLY_TGT.first, 0, true);
+  ihs(PL_SEQUENCE_SUPV_ONLY.second, PL_TABLE_SUPV_ONLY_TRANS_0.first, 0, true);
+  ihs(PL_SEQUENCE_SUPV_ONLY.second, PL_TABLE_SUPV_ONLY_TRANS_1.first, 0, false);
+  check(ss.addSequence(SequenceEntry(PL_SEQUENCE_SUPV_ONLY.first, &PL_SEQUENCE_SUPV_ONLY.second,
+                                     PL_SEQUENCE_OFF.first)),
+        ctxc);
+}
+
+void initEarthObsvSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::payload::initEarthObsvSequence";
+  auto ctxc = context.c_str();
+  // Insert Helper Table
+  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode,
+                 ArrayList<ModeListEntry>& sequence) {
+    eh.setObject(obj);
+    eh.setMode(mode);
+    eh.setSubmode(submode);
+    check(sequence.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 Earth Observation target
+  iht(objects::PLOC_MPSOC_HANDLER, NML, 0, PL_TABLE_EARTH_OBSV_TGT.second);
+  iht(objects::PLOC_SUPERVISOR_HANDLER, NML, 0, PL_TABLE_EARTH_OBSV_TGT.second);
+  iht(objects::CAM_SWITCHER, ON, 0, PL_TABLE_EARTH_OBSV_TGT.second);
+  iht(objects::PLPCDU_HANDLER, OFF, 0, PL_TABLE_EARTH_OBSV_TGT.second);
+  check(ss.addTable(TableEntry(PL_TABLE_EARTH_OBSV_TGT.first, &PL_TABLE_EARTH_OBSV_TGT.second)),
+        ctxc);
+
+  // Build Earth Observation transition 0
+  iht(objects::PLOC_SUPERVISOR_HANDLER, NML, 0, PL_TABLE_EARTH_OBSV_TRANS_0.second);
+  iht(objects::CAM_SWITCHER, ON, 0, PL_TABLE_EARTH_OBSV_TRANS_0.second);
+  iht(objects::PLPCDU_HANDLER, OFF, 0, PL_TABLE_EARTH_OBSV_TRANS_0.second);
+  check(ss.addTable(
+            TableEntry(PL_TABLE_EARTH_OBSV_TRANS_0.first, &PL_TABLE_EARTH_OBSV_TRANS_0.second)),
+        ctxc);
+
+  // Build Earth Observation transition 1
+  iht(objects::PLOC_MPSOC_HANDLER, NML, 0, PL_TABLE_CAM_STREAM_TRANS_1.second);
+  check(ss.addTable(
+            TableEntry(PL_TABLE_EARTH_OBSV_TRANS_1.first, &PL_TABLE_EARTH_OBSV_TRANS_1.second)),
+        ctxc);
+
+  ihs(PL_SEQUENCE_EARTH_OBSV.second, PL_TABLE_EARTH_OBSV_TGT.first, 0, true);
+  ihs(PL_SEQUENCE_EARTH_OBSV.second, PL_TABLE_EARTH_OBSV_TRANS_0.first, 0, true);
+  ihs(PL_SEQUENCE_EARTH_OBSV.second, PL_TABLE_EARTH_OBSV_TRANS_1.first, 0, false);
+  check(ss.addSequence(SequenceEntry(PL_SEQUENCE_EARTH_OBSV.first, &PL_SEQUENCE_EARTH_OBSV.second,
+                                     PL_SEQUENCE_OFF.first)),
+        ctxc);
+}
+
+void initScexSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::payload::initScexSequence";
+  auto ctxc = context.c_str();
+  // Insert Helper Table
+  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode,
+                 ArrayList<ModeListEntry>& sequence) {
+    eh.setObject(obj);
+    eh.setMode(mode);
+    eh.setSubmode(submode);
+    check(sequence.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 SCEX target
+  iht(objects::SCEX, NML, 0, PL_TABLE_SCEX_TGT.second);
+  check(ss.addTable(TableEntry(PL_TABLE_SCEX_TGT.first, &PL_TABLE_SCEX_TGT.second)), ctxc);
+
+  // Build SCEX transition 0
+  iht(objects::SCEX, NML, 0, PL_TABLE_SCEX_TRANS_0.second);
+  check(ss.addTable(TableEntry(PL_TABLE_SCEX_TRANS_0.first, &PL_TABLE_SCEX_TRANS_0.second)), ctxc);
+
+  // Build SCEX sequence
+  ihs(PL_SEQUENCE_SCEX.second, PL_TABLE_SCEX_TGT.first, 0, true);
+  ihs(PL_SEQUENCE_SCEX.second, PL_TABLE_SCEX_TRANS_0.first, 0, false);
+  check(ss.addSequence(
+            SequenceEntry(PL_SEQUENCE_SCEX.first, &PL_SEQUENCE_SCEX.second, PL_SEQUENCE_OFF.first)),
+        ctxc);
+}
+
+}  // namespace

mission/system/tree/payloadModeTree.h

@@ -0,0 +1,17 @@
+#ifndef MISSION_SYSTEM_TREE_PAYLOADMODETREE_H_
+#define MISSION_SYSTEM_TREE_PAYLOADMODETREE_H_
+
+#include <fsfw/subsystem/Subsystem.h>
+
+namespace satsystem {
+
+namespace pl {
+
+extern Subsystem SUBSYSTEM;
+
+void init();
+}  // namespace pl
+
+}  // namespace satsystem
+
+#endif /* MISSION_SYSTEM_TREE_PAYLOADMODETREE_H_ */

mission/system/tree/system.cpp

@@ -0,0 +1,9 @@
+#include "system.h"
+
+#include "acsModeTree.h"
+#include "payloadModeTree.h"
+
+void satsystem::init() {
+  acs::init();
+  pl::init();
+}

mission/system/tree/system.h

@@ -0,0 +1,10 @@
+#ifndef MISSION_SYSTEM_TREE_SYSTEM_H_
+#define MISSION_SYSTEM_TREE_SYSTEM_H_
+
+namespace satsystem {
+
+void init();
+
+}
+
+#endif /* MISSION_SYSTEM_TREE_SYSTEM_H_ */

mission/system/tree/util.cpp

@@ -0,0 +1,19 @@
+#include "util.h"
+
+#include "fsfw/container/FixedMap.h"
+#include "fsfw/serviceinterface.h"
+
+void subsystem::checkInsert(ReturnValue_t result, const char* ctx) {
+  if (result != returnvalue::OK) {
+    sif::warning << "satsystem::checkInsert: Insertion failed at " << ctx;
+    if (result == containers::KEY_ALREADY_EXISTS) {
+      sif::warning << ": Key already exists" << std::endl;
+    } else if (result == containers::MAP_FULL) {
+      sif::warning << ": Map full" << std::endl;
+    } else if (result == containers::LIST_FULL) {
+      sif::warning << ": List full" << std::endl;
+    } else {
+      sif::warning << std::endl;
+    }
+  }
+}

mission/system/tree/util.h

@@ -0,0 +1,12 @@
+#ifndef MISSION_SYSTEM_TREE_UTIL_H_
+#define MISSION_SYSTEM_TREE_UTIL_H_
+
+#include <fsfw/retval.h>
+
+namespace subsystem {
+
+void checkInsert(ReturnValue_t result, const char* ctx);
+
+}
+
+#endif /* MISSION_SYSTEM_TREE_UTIL_H_ */