Merge remote-tracking branch 'origin/main' into cfdp-source-handler

mission/system/EiveSystem.cpp

@@ -81,6 +81,55 @@ ReturnValue_t EiveSystem::initialize() {
     return result;
   }
 
+  auto* plSs = ObjectManager::instance()->get<HasModesIF>(objects::PL_SUBSYSTEM);
+  if (plSs == nullptr) {
+    return ObjectManager::CHILD_INIT_FAILED;
+  }
+  plSsQueueId = plSs->getCommandQueue();
+
+  auto* plPcdu = ObjectManager::instance()->get<HasHealthIF>(objects::PLPCDU_HANDLER);
+  if (plPcdu == nullptr) {
+    return ObjectManager::CHILD_INIT_FAILED;
+  }
+  plPcduQueueId = plPcdu->getCommandQueue();
+
+  auto* plocMpsoc = ObjectManager::instance()->get<HasHealthIF>(objects::PLOC_MPSOC_HANDLER);
+  if (plocMpsoc == nullptr) {
+    return ObjectManager::CHILD_INIT_FAILED;
+  }
+  plocMpsocQueueId = plocMpsoc->getCommandQueue();
+
+  auto* plocSupervisor =
+      ObjectManager::instance()->get<HasHealthIF>(objects::PLOC_SUPERVISOR_HANDLER);
+  if (plocSupervisor == nullptr) {
+    return ObjectManager::CHILD_INIT_FAILED;
+  }
+  plocSupervisorQueueId = plocSupervisor->getCommandQueue();
+
+  auto* camera = ObjectManager::instance()->get<HasHealthIF>(objects::CAM_SWITCHER);
+  if (camera == nullptr) {
+    return ObjectManager::CHILD_INIT_FAILED;
+  }
+  cameraQueueId = camera->getCommandQueue();
+
+  auto* scex = ObjectManager::instance()->get<HasHealthIF>(objects::SCEX);
+  if (scex == nullptr) {
+    return ObjectManager::CHILD_INIT_FAILED;
+  }
+  scexQueueId = scex->getCommandQueue();
+
+  auto* radSensor = ObjectManager::instance()->get<HasHealthIF>(objects::RAD_SENSOR);
+  if (radSensor == nullptr) {
+    return ObjectManager::CHILD_INIT_FAILED;
+  }
+  radSensorQueueId = radSensor->getCommandQueue();
+
+  auto* str = ObjectManager::instance()->get<HasHealthIF>(objects::STAR_TRACKER);
+  if (str == nullptr) {
+    return ObjectManager::CHILD_INIT_FAILED;
+  }
+  strQueueId = str->getCommandQueue();
+
   auto* bpxDest = ObjectManager::instance()->get<HasActionsIF>(objects::BPX_BATT_HANDLER);
   if (bpxDest == nullptr) {
     return ObjectManager::CHILD_INIT_FAILED;
@@ -120,6 +169,8 @@ ReturnValue_t EiveSystem::initialize() {
   manager->subscribeToEvent(eventQueue->getId(), event::getEventId(tcsCtrl::OBC_OVERHEATING));
   manager->subscribeToEvent(eventQueue->getId(), event::getEventId(tcsCtrl::MGT_OVERHEATING));
   manager->subscribeToEvent(eventQueue->getId(), event::getEventId(pdec::INVALID_TC_FRAME));
+  manager->subscribeToEvent(eventQueue->getId(), event::getEventId(power::POWER_LEVEL_LOW));
+  manager->subscribeToEvent(eventQueue->getId(), event::getEventId(power::POWER_LEVEL_CRITICAL));
   return Subsystem::initialize();
 }
 
@@ -151,6 +202,20 @@ void EiveSystem::handleEventMessages() {
             commandSelfToSafe();
             break;
           }
+          case power::POWER_LEVEL_LOW: {
+            forceOffPayload();
+            break;
+          }
+          case power::POWER_LEVEL_CRITICAL:
+            CommandMessage msg;
+            HealthMessage::setHealthMessage(&msg, HealthMessage::HEALTH_SET, HasHealthIF::FAULTY);
+            ReturnValue_t result = MessageQueueSenderIF::sendMessage(
+                strQueueId, &msg, MessageQueueIF::NO_QUEUE, false);
+            if (result != returnvalue::OK) {
+              sif::error << "EIVE System: Sending FAULTY command to STR Assembly failed"
+                         << std::endl;
+            }
+            break;
         }
         break;
       default:
@@ -336,6 +401,42 @@ void EiveSystem::pdecRecoveryLogic() {
   }
 }
 
+void EiveSystem::forceOffPayload() {
+  CommandMessage msg;
+  // set PL to faulty
+  HealthMessage::setHealthMessage(&msg, HealthMessage::HEALTH_SET, HasHealthIF::FAULTY);
+
+  ReturnValue_t result = commandQueue->sendMessage(plPcduQueueId, &msg);
+  if (result != returnvalue::OK) {
+    sif::error << "EIVE System: Sending FAULTY command to PL PCDU failed" << std::endl;
+  }
+
+  result = commandQueue->sendMessage(plocMpsocQueueId, &msg);
+  if (result != returnvalue::OK) {
+    sif::error << "EIVE System: Sending FAULTY command to PLOC MPSOC failed" << std::endl;
+  }
+
+  result = commandQueue->sendMessage(plocSupervisorQueueId, &msg);
+  if (result != returnvalue::OK) {
+    sif::error << "EIVE System: Sending FAULTY command to PLOC SUPERVISOR failed" << std::endl;
+  }
+
+  result = commandQueue->sendMessage(cameraQueueId, &msg);
+  if (result != returnvalue::OK) {
+    sif::error << "EIVE System: Sending FAULTY command to PL CAM failed" << std::endl;
+  }
+
+  result = commandQueue->sendMessage(scexQueueId, &msg);
+  if (result != returnvalue::OK) {
+    sif::error << "EIVE System: Sending FAULTY command to SCEX failed" << std::endl;
+  }
+
+  result = commandQueue->sendMessage(radSensorQueueId, &msg);
+  if (result != returnvalue::OK) {
+    sif::error << "EIVE System: Sending FAULTY command to RAD SENSOR failed" << std::endl;
+  }
+}
+
 void EiveSystem::commonI2cRecoverySequenceFinish() {
   alreadyTriedI2cRecovery = true;
   performI2cReboot = false;

mission/system/EiveSystem.h

@@ -49,6 +49,15 @@ class EiveSystem : public Subsystem, public HasActionsIF {
   PowerSwitchIF* powerSwitcher = nullptr;
   std::atomic_uint16_t& i2cErrors;
 
+  MessageQueueId_t plSsQueueId = MessageQueueIF::NO_QUEUE;
+  MessageQueueId_t plPcduQueueId = MessageQueueIF::NO_QUEUE;
+  MessageQueueId_t plocMpsocQueueId = MessageQueueIF::NO_QUEUE;
+  MessageQueueId_t plocSupervisorQueueId = MessageQueueIF::NO_QUEUE;
+  MessageQueueId_t cameraQueueId = MessageQueueIF::NO_QUEUE;
+  MessageQueueId_t scexQueueId = MessageQueueIF::NO_QUEUE;
+  MessageQueueId_t radSensorQueueId = MessageQueueIF::NO_QUEUE;
+  MessageQueueId_t strQueueId = MessageQueueIF::NO_QUEUE;
+
   MessageQueueId_t pdecHandlerQueueId = MessageQueueIF::NO_QUEUE;
 
   MessageQueueId_t bpxBattQueueId = MessageQueueIF::NO_QUEUE;
@@ -68,6 +77,8 @@ class EiveSystem : public Subsystem, public HasActionsIF {
   ReturnValue_t sendFullRebootCommand();
   ReturnValue_t sendSelfRebootCommand();
 
+  void forceOffPayload();
+
   void pdecRecoveryLogic();
 
   void i2cRecoveryLogic();

mission/system/objects/CamSwitcher.cpp

@@ -1,6 +1,6 @@
 #include "CamSwitcher.h"
 
-CamSwitcher::CamSwitcher(object_id_t objectId, PowerSwitchIF &pwrSwitcher,
+CamSwitcher::CamSwitcher(object_id_t objectId, PowerSwitchIF& pwrSwitcher,
                          power::Switch_t pwrSwitch)
     : PowerSwitcherComponent(objectId, &pwrSwitcher, pwrSwitch) {}
 void CamSwitcher::performFaultyOperation() {
@@ -8,3 +8,17 @@ void CamSwitcher::performFaultyOperation() {
     switcher.turnOff();
   }
 }
+
+ReturnValue_t CamSwitcher::checkModeCommand(Mode_t commandedMode, Submode_t commandedSubmode,
+                                            uint32_t* msToReachTheMode) {
+  if (commandedMode != MODE_OFF) {
+    PoolReadGuard pg(&enablePl);
+    if (pg.getReadResult() == returnvalue::OK) {
+      if (enablePl.plUseAllowed.isValid() and not enablePl.plUseAllowed.value) {
+        return TRANS_NOT_ALLOWED;
+      }
+    }
+  }
+  return PowerSwitcherComponent::checkModeCommand(commandedMode, commandedSubmode,
+                                                  msToReachTheMode);
+}

mission/system/objects/CamSwitcher.h

@@ -1,13 +1,19 @@
 #ifndef MISSION_SYSTEM_OBJECTS_CAMSWITCHER_H_
 #define MISSION_SYSTEM_OBJECTS_CAMSWITCHER_H_
 
+#include <common/config/eive/objects.h>
 #include <fsfw/power/PowerSwitcherComponent.h>
+#include <mission/controller/controllerdefinitions/PowerCtrlDefinitions.h>
 
 class CamSwitcher : public PowerSwitcherComponent {
  public:
-  CamSwitcher(object_id_t objectId, PowerSwitchIF &pwrSwitcher, power::Switch_t pwrSwitch);
+  CamSwitcher(object_id_t objectId, PowerSwitchIF& pwrSwitcher, power::Switch_t pwrSwitch);
 
  private:
+  pwrctrl::EnablePl enablePl = pwrctrl::EnablePl(objects::POWER_CONTROLLER);
+  ReturnValue_t checkModeCommand(Mode_t commandedMode, Submode_t commandedSubmode,
+                                 uint32_t* msToReachTheMode) override;
+
   void performFaultyOperation() override;
 };
 

mission/system/power/CMakeLists.txt

@@ -1 +1 @@
-target_sources(${LIB_EIVE_MISSION} PRIVATE GomspacePowerFdir.cpp)
+target_sources(${LIB_EIVE_MISSION} PRIVATE epsModeTree.cpp EpsSubsystem.cpp GomspacePowerFdir.cpp)

mission/system/power/EpsSubsystem.cpp

@@ -0,0 +1,27 @@
+#include <mission/system/power/EpsSubsystem.h>
+
+#include "fsfw/devicehandlers/DeviceHandlerIF.h"
+
+EpsSubsystem::EpsSubsystem(object_id_t objectId, uint32_t maxNumberOfSequences,
+                           uint32_t maxNumberOfTables)
+    : Subsystem(objectId, maxNumberOfSequences, maxNumberOfTables) {}
+
+void EpsSubsystem::announceMode(bool recursive) {
+  const char* modeStr = "UNKNOWN";
+  switch (mode) {
+    case (HasModesIF::MODE_OFF): {
+      modeStr = "OFF";
+      break;
+    }
+    case (HasModesIF::MODE_ON): {
+      modeStr = "ON";
+      break;
+    }
+    case (DeviceHandlerIF::MODE_NORMAL): {
+      modeStr = "NORMAL";
+      break;
+    }
+  }
+  sif::info << "EPS subsystem is now in " << modeStr << " mode" << std::endl;
+  return Subsystem::announceMode(recursive);
+}

mission/system/power/EpsSubsystem.h

@@ -0,0 +1,13 @@
+#ifndef MISSION_SYSTEM_OBJECTS_EPSSUBSYSTEM_H_
+#define MISSION_SYSTEM_OBJECTS_EPSSUBSYSTEM_H_
+#include <fsfw/subsystem/Subsystem.h>
+
+class EpsSubsystem : public Subsystem {
+ public:
+  EpsSubsystem(object_id_t objectId, uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables);
+
+ private:
+  void announceMode(bool recursive) override;
+};
+
+#endif /* MISSION_SYSTEM_OBJECTS_EPSSUBSYSTEM_H_ */

mission/system/power/epsModeTree.cpp

@@ -0,0 +1,104 @@
+#include <mission/system/power/epsModeTree.h>
+
+#include "eive/objects.h"
+#include "fsfw/devicehandlers/DeviceHandlerIF.h"
+#include "fsfw/subsystem/Subsystem.h"
+#include "mission/system/treeUtil.h"
+
+EpsSubsystem satsystem::eps::EPS_SUBSYSTEM(objects::EPS_SUBSYSTEM, 12, 24);
+
+namespace {
+// Alias for checker function
+const auto check = subsystem::checkInsert;
+void buildOffSequence(Subsystem& ss, ModeListEntry& eh);
+void buildNormalSequence(Subsystem& ss, ModeListEntry& eh);
+}  // namespace
+
+static const auto OFF = HasModesIF::MODE_OFF;
+static const auto NML = DeviceHandlerIF::MODE_NORMAL;
+
+auto EPS_SEQUENCE_OFF = std::make_pair(OFF, FixedArrayList<ModeListEntry, 3>());
+auto EPS_TABLE_OFF_TGT = std::make_pair((OFF << 24) | 1, FixedArrayList<ModeListEntry, 2>());
+auto EPS_TABLE_OFF_TRANS_0 = std::make_pair((OFF << 24) | 2, FixedArrayList<ModeListEntry, 2>());
+
+auto EPS_SEQUENCE_NORMAL = std::make_pair(NML, FixedArrayList<ModeListEntry, 3>());
+auto EPS_TABLE_NORMAL_TGT = std::make_pair((NML << 24) | 1, FixedArrayList<ModeListEntry, 2>());
+auto EPS_TABLE_NORMAL_TRANS_0 = std::make_pair((NML << 24) | 2, FixedArrayList<ModeListEntry, 7>());
+
+Subsystem& satsystem::eps::init() {
+  ModeListEntry entry;
+  buildOffSequence(EPS_SUBSYSTEM, entry);
+  buildNormalSequence(EPS_SUBSYSTEM, entry);
+  EPS_SUBSYSTEM.setInitialMode(NML);
+  return EPS_SUBSYSTEM;
+}
+
+namespace {
+
+void buildOffSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::eps::buildOffSequence";
+  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);
+  };
+
+  // OFF target table is empty
+  check(ss.addTable(TableEntry(EPS_TABLE_OFF_TGT.first, &EPS_TABLE_OFF_TGT.second)), ctxc);
+
+  // Transition 0
+  iht(objects::POWER_CONTROLLER, OFF, 0, EPS_TABLE_OFF_TRANS_0.second);
+  check(ss.addTable(TableEntry(EPS_TABLE_OFF_TRANS_0.first, &EPS_TABLE_OFF_TRANS_0.second)), ctxc);
+
+  ihs(EPS_SEQUENCE_OFF.second, EPS_TABLE_OFF_TGT.first, 0, false);
+  ihs(EPS_SEQUENCE_OFF.second, EPS_TABLE_OFF_TRANS_0.first, 0, false);
+  check(ss.addSequence(SequenceEntry(EPS_SEQUENCE_OFF.first, &EPS_SEQUENCE_OFF.second,
+                                     EPS_SEQUENCE_OFF.first)),
+        ctxc);
+}
+
+void buildNormalSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::tcs::buildNormalSequence";
+  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);
+  };
+
+  // Normal table target table is empty
+  check(ss.addTable(TableEntry(EPS_TABLE_NORMAL_TGT.first, &EPS_TABLE_NORMAL_TGT.second)), ctxc);
+
+  // Transition 0
+  iht(objects::POWER_CONTROLLER, NML, 0, EPS_TABLE_NORMAL_TRANS_0.second);
+  check(ss.addTable(TableEntry(EPS_TABLE_NORMAL_TRANS_0.first, &EPS_TABLE_NORMAL_TRANS_0.second)),
+        ctxc);
+
+  ihs(EPS_SEQUENCE_NORMAL.second, EPS_TABLE_NORMAL_TGT.first, 0, false);
+  ihs(EPS_SEQUENCE_NORMAL.second, EPS_TABLE_NORMAL_TRANS_0.first, 0, false);
+  check(ss.addSequence(SequenceEntry(EPS_SEQUENCE_NORMAL.first, &EPS_SEQUENCE_NORMAL.second,
+                                     EPS_SEQUENCE_NORMAL.first)),
+        ctxc);
+}
+}  // namespace

mission/system/power/epsModeTree.h

@@ -0,0 +1,15 @@
+#ifndef MISSION_SYSTEM_TREE_EPSMODETREE_H_
+#define MISSION_SYSTEM_TREE_EPSMODETREE_H_
+
+#include <mission/system/power/EpsSubsystem.h>
+
+namespace satsystem {
+namespace eps {
+
+extern EpsSubsystem EPS_SUBSYSTEM;
+Subsystem& init();
+
+}  // namespace eps
+}  // namespace satsystem
+
+#endif /* MISSION_SYSTEM_TREE_EPSMODETREE_H_ */

mission/system/systemTree.cpp

@@ -12,6 +12,7 @@
 #include "mission/com/defs.h"
 #include "mission/sysDefs.h"
 #include "mission/system/acs/acsModeTree.h"
+#include "mission/system/power/epsModeTree.h"
 #include "mission/system/tcs/tcsModeTree.h"
 #include "mission/system/tree/payloadModeTree.h"
 #include "treeUtil.h"
@@ -41,6 +42,8 @@ void satsystem::init(bool commandPlPcdu1) {
   tcsSubsystem.connectModeTreeParent(EIVE_SYSTEM);
   auto& comSubsystem = com::init();
   comSubsystem.connectModeTreeParent(EIVE_SYSTEM);
+  auto& epsSubsystem = eps::init();
+  epsSubsystem.connectModeTreeParent(EIVE_SYSTEM);
   ModeListEntry entry;
   buildBootSequence(EIVE_SYSTEM, entry);
   buildSafeSequence(EIVE_SYSTEM, entry);
@@ -143,9 +146,11 @@ void buildBootSequence(Subsystem& ss, ModeListEntry& eh) {
   iht(objects::PL_SUBSYSTEM, OFF, 0, EIVE_TABLE_BOOT_TGT.second);
   iht(objects::COM_SUBSYSTEM, com::RX_ONLY, 0, EIVE_TABLE_BOOT_TGT.second);
   iht(objects::TCS_SUBSYSTEM, OFF, 0, EIVE_TABLE_BOOT_TGT.second);
+  iht(objects::EPS_SUBSYSTEM, OFF, 0, EIVE_TABLE_BOOT_TGT.second);
   check(ss.addTable(TableEntry(EIVE_TABLE_BOOT_TGT.first, &EIVE_TABLE_BOOT_TGT.second)), ctxc);
 
-  // Build SAFE transition 0.
+  // Build BOOT transition 0.
+  iht(objects::EPS_SUBSYSTEM, OFF, 0, EIVE_TABLE_BOOT_TRANS_0.second);
   iht(objects::TCS_SUBSYSTEM, OFF, 0, EIVE_TABLE_BOOT_TRANS_0.second);
   iht(objects::COM_SUBSYSTEM, com::RX_ONLY, 0, EIVE_TABLE_BOOT_TRANS_0.second);
   iht(objects::PL_SUBSYSTEM, OFF, 0, EIVE_TABLE_BOOT_TRANS_0.second);
@@ -153,7 +158,7 @@ void buildBootSequence(Subsystem& ss, ModeListEntry& eh) {
   check(ss.addTable(TableEntry(EIVE_TABLE_BOOT_TRANS_0.first, &EIVE_TABLE_BOOT_TRANS_0.second)),
         ctxc);
 
-  // Build Safe sequence
+  // Build BOOT sequence
   ihs(EIVE_SEQUENCE_BOOT.second, EIVE_TABLE_BOOT_TGT.first, 0, false);
   ihs(EIVE_SEQUENCE_BOOT.second, EIVE_TABLE_BOOT_TRANS_0.first, 0, false);
   check(ss.addSequence(SequenceEntry(EIVE_SEQUENCE_BOOT.first, &EIVE_SEQUENCE_BOOT.second,
@@ -189,13 +194,14 @@ void buildSafeSequence(Subsystem& ss, ModeListEntry& eh) {
   check(ss.addTable(TableEntry(EIVE_TABLE_SAFE_TGT.first, &EIVE_TABLE_SAFE_TGT.second)), ctxc);
 
   // Build SAFE transition 0.
+  iht(objects::EPS_SUBSYSTEM, NML, 0, EIVE_TABLE_SAFE_TRANS_0.second);
   iht(objects::TCS_SUBSYSTEM, NML, 0, EIVE_TABLE_SAFE_TRANS_0.second);
   iht(objects::PL_SUBSYSTEM, OFF, 0, EIVE_TABLE_SAFE_TRANS_0.second);
   iht(objects::ACS_SUBSYSTEM, acs::AcsMode::SAFE, 0, EIVE_TABLE_SAFE_TRANS_0.second, true);
   check(ss.addTable(TableEntry(EIVE_TABLE_SAFE_TRANS_0.first, &EIVE_TABLE_SAFE_TRANS_0.second)),
         ctxc);
 
-  // Build Safe sequence
+  // Build SAFE sequence
   ihs(EIVE_SEQUENCE_SAFE.second, EIVE_TABLE_SAFE_TGT.first, 0, false);
   ihs(EIVE_SEQUENCE_SAFE.second, EIVE_TABLE_SAFE_TRANS_0.first, 0, false);
   check(ss.addSequence(SequenceEntry(EIVE_SEQUENCE_SAFE.first, &EIVE_SEQUENCE_SAFE.second,
@@ -226,6 +232,7 @@ void buildIdleSequence(Subsystem& ss, ModeListEntry& eh) {
   check(ss.addTable(TableEntry(EIVE_TABLE_IDLE_TGT.first, &EIVE_TABLE_IDLE_TGT.second)), ctxc);
 
   // Build IDLE transition 0
+  iht(objects::EPS_SUBSYSTEM, NML, 0, EIVE_TABLE_IDLE_TRANS_0.second);
   iht(objects::TCS_SUBSYSTEM, NML, 0, EIVE_TABLE_IDLE_TRANS_0.second);
   iht(objects::ACS_SUBSYSTEM, acs::AcsMode::PTG_IDLE, 0, EIVE_TABLE_IDLE_TRANS_0.second);
   check(ss.addTable(TableEntry(EIVE_TABLE_IDLE_TRANS_0.first, &EIVE_TABLE_IDLE_TRANS_0.second)),
@@ -263,6 +270,7 @@ void buildPtgNadirSequence(Subsystem& ss, ModeListEntry& eh) {
         ctxc);
 
   // Build PTG_NADIR transition 0
+  iht(objects::EPS_SUBSYSTEM, NML, 0, EIVE_TABLE_PTG_NADIR_TRANS_0.second);
   iht(objects::TCS_SUBSYSTEM, NML, 0, EIVE_TABLE_PTG_NADIR_TRANS_0.second);
   iht(objects::ACS_SUBSYSTEM, acs::AcsMode::PTG_NADIR, 0, EIVE_TABLE_PTG_NADIR_TRANS_0.second);
   check(ss.addTable(
@@ -301,6 +309,7 @@ void buildPtgTargetSequence(Subsystem& ss, ModeListEntry& eh) {
         ctxc);
 
   // Build PTG_TARGET transition 0
+  iht(objects::EPS_SUBSYSTEM, NML, 0, EIVE_TABLE_PTG_TARGET_TRANS_0.second);
   iht(objects::TCS_SUBSYSTEM, NML, 0, EIVE_TABLE_PTG_TARGET_TRANS_0.second);
   iht(objects::ACS_SUBSYSTEM, acs::AcsMode::PTG_TARGET, 0, EIVE_TABLE_PTG_TARGET_TRANS_0.second);
   check(ss.addTable(
@@ -340,6 +349,7 @@ void buildPtgTargetGsSequence(Subsystem& ss, ModeListEntry& eh) {
         ctxc);
 
   // Build PTG_TARGET_GS transition 0
+  iht(objects::EPS_SUBSYSTEM, NML, 0, EIVE_TABLE_PTG_TARGET_GS_TRANS_0.second);
   iht(objects::TCS_SUBSYSTEM, NML, 0, EIVE_TABLE_PTG_TARGET_GS_TRANS_0.second);
   iht(objects::ACS_SUBSYSTEM, acs::AcsMode::PTG_TARGET_GS, 0,
       EIVE_TABLE_PTG_TARGET_GS_TRANS_0.second);
@@ -381,6 +391,7 @@ void buildPtgInertialSequence(Subsystem& ss, ModeListEntry& eh) {
         ctxc);
 
   // Build PTG_INERTIAL transition 0
+  iht(objects::EPS_SUBSYSTEM, NML, 0, EIVE_TABLE_PTG_INERTIAL_TRANS_0.second);
   iht(objects::TCS_SUBSYSTEM, NML, 0, EIVE_TABLE_PTG_INERTIAL_TRANS_0.second);
   iht(objects::ACS_SUBSYSTEM, acs::AcsMode::PTG_INERTIAL, 0,
       EIVE_TABLE_PTG_INERTIAL_TRANS_0.second);