Merge remote-tracking branch 'origin/main' into update_ptme_code

2023-04-28 15:38:52 +02:00 · 2023-04-28 15:38:52 +02:00 · c137df64ab
commit c137df64ab
parent a919b3d164 4179e8e124
23 changed files with 413 additions and 127 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -16,6 +16,8 @@ will consitute of a breaking change warranting a new major release:

 # [unreleased]

+# [v2.2.0] to be released
+
 TODO: New firmware package version.

 ## Changed
@ -26,6 +28,36 @@ TODO: New firmware package version.

 - Important bugfixes for PTME. See `q7s-package` CHANGELOG.

+# [v2.1.0] to be released
+
+## Changed
+
+- Adapt EM configuration to include all GomSpace PCDU devices except the ACU. For the ACU
+  (which broke), a dummy will still be used.
+- Event Manager queue depth is configurable now.
+- Do not construct and schedule broken TMP1075 device anymore.
+- Do not track payload modes in system mode tables.
+- ACS modes derived from system modes.
+
+## Added
+
+- Add the remaining system modes.
+
+## Fixed
+
+- Host build is working again. Added reduced live TM helper which schedules the PUS and CFDP
+  funnel.
+
+# [v2.0.5] to be released
+
+- The dual lane assembly transition failed handler started new transitions towards the current mode
+  instead of the target mode. This means that if the dual lane assembly never reached the initial
+  submode (e.g. mode normal and submode dual side), it will transition back to the current mode,
+  which miht be `MODE_OFF`. Furthermore, this can lead to invalid internal states, so the subsequent
+  recovery handling becomes stuck in the custom recovery sequence when swichting power back on.
+- The dual lane custom recovery handling was adapted to always perform proper power switch handling
+  irrespective of current or target modes.
+
 # [v2.0.4] 2023-04-19

 ## Fixed
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -11,7 +11,7 @@ cmake_minimum_required(VERSION 3.13)

 set(OBSW_VERSION_MAJOR 2)
 set(OBSW_VERSION_MINOR 0)
-set(OBSW_VERSION_REVISION 3)
+set(OBSW_VERSION_REVISION 4)

 # set(CMAKE_VERBOSE TRUE)

@ -146,8 +146,11 @@ set(OBSW_ADD_TMP_DEVICES
    ${INIT_VAL}
    CACHE STRING "Add TMP devices")
 set(OBSW_ADD_GOMSPACE_PCDU
-    ${INIT_VAL}
+    1
    CACHE STRING "Add GomSpace PCDU modules")
+set(OBSW_ADD_GOMSPACE_ACU
+    ${INIT_VAL}
+    CACHE STRING "Add GomSpace ACU submodule")
 set(OBSW_ADD_RW
    ${INIT_VAL}
    CACHE STRING "Add RW modules")
--- a/bsp_hosted/ObjectFactory.cpp
+++ b/bsp_hosted/ObjectFactory.cpp
@ -64,8 +64,9 @@ void ObjectFactory::produce(void* args) {
  PersistentTmStores persistentStores;
  auto sdcMan = new DummySdCardManager("/tmp");
  ObjectFactory::produceGenericObjects(nullptr, &pusFunnel, &cfdpFunnel, *sdcMan, &ipcStore,
-                                       &tmStore, persistentStores);
+                                       &tmStore, persistentStores, 120);

+  new TmFunnelHandler(objects::LIVE_TM_TASK, *pusFunnel, *cfdpFunnel);
  auto* dummyGpioIF = new DummyGpioIF();
  auto* dummySwitcher = new DummyPowerSwitcher(objects::PCDU_HANDLER, 18, 0);
  std::vector<ReturnValue_t> switcherList;
--- a/bsp_hosted/scheduling.cpp
+++ b/bsp_hosted/scheduling.cpp
@ -59,19 +59,15 @@ void scheduling::initTasks() {
      "DIST", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
  ReturnValue_t result = tmtcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
  if (result != returnvalue::OK) {
-    sif::error << "adding CCSDS distributor failed" << std::endl;
+    sif::error << "Adding CCSDS distributor failed" << std::endl;
  }
  result = tmtcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
  if (result != returnvalue::OK) {
-    sif::error << "adding PUS distributor failed" << std::endl;
-  }
-  result = tmtcDistributor->addComponent(objects::TM_FUNNEL);
-  if (result != returnvalue::OK) {
-    sif::error << "adding TM funnel failed" << std::endl;
+    sif::error << "Adding PUS distributor failed" << std::endl;
  }
  result = tmtcDistributor->addComponent(objects::CFDP_DISTRIBUTOR);
  if (result != returnvalue::OK) {
-    sif::error << "adding CFDP distributor failed" << std::endl;
+    sif::error << "Adding CFDP distributor failed" << std::endl;
  }
  result = tmtcDistributor->addComponent(objects::UDP_TMTC_SERVER);
  if (result != returnvalue::OK) {
@ -95,6 +91,13 @@ void scheduling::initTasks() {
    sif::error << "Add component UDP Polling failed" << std::endl;
  }

+  PeriodicTaskIF* liveTmTask = factory->createPeriodicTask(
+      "LIVE_TM", 55, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, nullptr, &RR_SCHEDULING);
+  result = liveTmTask->addComponent(objects::LIVE_TM_TASK);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("LIVE_TM", objects::LIVE_TM_TASK);
+  }
+
  PeriodicTaskIF* pusHighPrio = factory->createPeriodicTask(
      "PUS_HIGH_PRIO", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
  result = pusHighPrio->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
@ -149,7 +152,7 @@ void scheduling::initTasks() {
      "THERMAL_CTL_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
  result = thermalTask->addComponent(objects::CORE_CONTROLLER);
  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("Core controller dummy", objects::CORE_CONTROLLER);
+    scheduling::printAddObjectError("CORE_CTRL", objects::CORE_CONTROLLER);
  }
  result = thermalTask->addComponent(objects::THERMAL_CONTROLLER);
  if (result != returnvalue::OK) {
@ -217,6 +220,7 @@ void scheduling::initTasks() {
  tmtcDistributor->startTask();
  udpPollingTask->startTask();
  tcpPollingTask->startTask();
+  liveTmTask->startTask();

  pusHighPrio->startTask();
  pusMedPrio->startTask();
--- a/bsp_q7s/OBSWConfig.h.in
+++ b/bsp_q7s/OBSWConfig.h.in
@ -22,6 +22,9 @@
 #define OBSW_COMMAND_SAFE_MODE_AT_STARTUP           1

 #define OBSW_ADD_GOMSPACE_PCDU                      @OBSW_ADD_GOMSPACE_PCDU@
+// This define is necessary because the EM setup has the P60 dock module, but no ACU on the P60
+// module because it broke.
+#define OBSW_ADD_GOMSPACE_ACU                       @OBSW_ADD_GOMSPACE_ACU@
 #define OBSW_ADD_MGT                                @OBSW_ADD_MGT@
 #define OBSW_ADD_BPX_BATTERY_HANDLER                @OBSW_ADD_BPX_BATTERY_HANDLER@
 #define OBSW_ADD_STAR_TRACKER                       @OBSW_ADD_STAR_TRACKER@
--- a/bsp_q7s/core/ObjectFactory.cpp
+++ b/bsp_q7s/core/ObjectFactory.cpp
@ -189,7 +189,6 @@ void ObjectFactory::createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF,
  *i2cComIF = new I2cComIF(objects::I2C_COM_IF);
  *uartComIF = new SerialComIF(objects::UART_COM_IF);
  *spiMainComIF = new SpiComIF(objects::SPI_MAIN_COM_IF, q7s::SPI_DEFAULT_DEV, **gpioComIF);
-  //*spiRWComIF = new SpiComIF(objects::SPI_RW_COM_IF, q7s::SPI_RW_DEV, **gpioComIF);
 }

 void ObjectFactory::createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF** pwrSwitcher,
@ -197,7 +196,6 @@ void ObjectFactory::createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchI
  CspCookie* p60DockCspCookie = new CspCookie(P60Dock::MAX_REPLY_SIZE, addresses::P60DOCK, 500);
  CspCookie* pdu1CspCookie = new CspCookie(PDU::MAX_REPLY_SIZE, addresses::PDU1, 500);
  CspCookie* pdu2CspCookie = new CspCookie(PDU::MAX_REPLY_SIZE, addresses::PDU2, 500);
-  CspCookie* acuCspCookie = new CspCookie(ACU::MAX_REPLY_SIZE, addresses::ACU, 500);

  auto p60Fdir = new GomspacePowerFdir(objects::P60DOCK_HANDLER);
  P60DockHandler* p60dockhandler = new P60DockHandler(objects::P60DOCK_HANDLER, objects::CSP_COM_IF,
@ -211,9 +209,12 @@ void ObjectFactory::createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchI
  Pdu2Handler* pdu2handler = new Pdu2Handler(objects::PDU2_HANDLER, objects::CSP_COM_IF,
                                             pdu2CspCookie, pdu2Fdir, enableHkSets);

+#if OBSW_ADD_GOMSPACE_ACU == 1
+  CspCookie* acuCspCookie = new CspCookie(ACU::MAX_REPLY_SIZE, addresses::ACU, 500);
  auto acuFdir = new GomspacePowerFdir(objects::ACU_HANDLER);
  ACUHandler* acuhandler = new ACUHandler(objects::ACU_HANDLER, objects::CSP_COM_IF, acuCspCookie,
                                          acuFdir, enableHkSets);
+#endif
  auto pcduHandler = new PcduHandler(objects::PCDU_HANDLER, 50);

  /**
@ -223,7 +224,9 @@ void ObjectFactory::createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchI
  p60dockhandler->setModeNormal();
  pdu1handler->setModeNormal();
  pdu2handler->setModeNormal();
+#if OBSW_ADD_GOMSPACE_ACU == 1
  acuhandler->setModeNormal();
+#endif
  if (pwrSwitcher != nullptr) {
    *pwrSwitcher = pcduHandler;
  }
--- a/bsp_q7s/em/emObjectFactory.cpp
+++ b/bsp_q7s/em/emObjectFactory.cpp
@ -36,7 +36,8 @@ void ObjectFactory::produce(void* args) {

  PersistentTmStores stores;
  ObjectFactory::produceGenericObjects(&healthTable, &pusFunnel, &cfdpFunnel,
-                                       *SdCardManager::instance(), &ipcStore, &tmStore, stores);
+                                       *SdCardManager::instance(), &ipcStore, &tmStore, stores,
+                                       200);

  LinuxLibgpioIF* gpioComIF = nullptr;
  SerialComIF* uartComIF = nullptr;
@ -56,6 +57,11 @@ void ObjectFactory::produce(void* args) {
 #endif
 #if OBSW_ADD_GOMSPACE_PCDU == 1
  dummyCfg.addPowerDummies = false;
+  // The ACU broke.
+  dummyCfg.addOnlyAcuDummy = true;
+#endif
+#if OBSW_ADD_BPX_BATTERY_HANDLER == 1
+  dummyCfg.addBpxBattDummy = false;
 #endif
 #if OBSW_ADD_ACS_BOARD == 1
  dummyCfg.addAcsBoardDummies = false;
@ -89,7 +95,7 @@ void ObjectFactory::produce(void* args) {
  // createRadSensorComponent(gpioComIF);

 #if OBSW_ADD_ACS_BOARD == 1
-  createAcsBoardComponents(*spiMainComIF, gpioComIF, uartComIF, *pwrSwitcher);
+  createAcsBoardComponents(*spiMainComIF, gpioComIF, uartComIF, *pwrSwitcher, true);
 #else
  // Still add all GPIOs for EM.
  GpioCookie* acsBoardGpios = new GpioCookie();
--- a/bsp_q7s/fmObjectFactory.cpp
+++ b/bsp_q7s/fmObjectFactory.cpp
@ -32,7 +32,8 @@ void ObjectFactory::produce(void* args) {

  PersistentTmStores stores;
  ObjectFactory::produceGenericObjects(&healthTable, &pusFunnel, &cfdpFunnel,
-                                       *SdCardManager::instance(), &ipcStore, &tmStore, stores);
+                                       *SdCardManager::instance(), &ipcStore, &tmStore, stores,
+                                       200);

  LinuxLibgpioIF* gpioComIF = nullptr;
  SerialComIF* uartComIF = nullptr;
--- a/dummies/helperFactory.cpp
+++ b/dummies/helperFactory.cpp
@ -45,7 +45,9 @@
 void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpioIF) {
  new ComIFDummy(objects::DUMMY_COM_IF);
  auto* comCookieDummy = new ComCookieDummy();
+  if (cfg.addBpxBattDummy) {
    new BpxDummy(objects::BPX_BATT_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  }
  if (cfg.addCoreCtrlCfg) {
    new CoreControllerDummy(objects::CORE_CONTROLLER);
  }
@ -75,8 +77,9 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
  auto* imtqDummy = new ImtqDummy(objects::IMTQ_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
  imtqDummy->enableThermalModule(ThermalStateCfg());
  imtqDummy->connectModeTreeParent(*imtqAssy);
-  if (cfg.addPowerDummies) {
+  if (cfg.addOnlyAcuDummy) {
    new AcuDummy(objects::ACU_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  } else if (cfg.addPowerDummies) {
    new PduDummy(objects::PDU1_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
    new PduDummy(objects::PDU2_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
    new P60DockDummy(objects::P60DOCK_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
--- a/dummies/helperFactory.h
+++ b/dummies/helperFactory.h
@ -6,9 +6,13 @@ class GpioIF;

 namespace dummy {

+// Default values targeted towards EM.
 struct DummyCfg {
  bool addCoreCtrlCfg = true;
+  // Special variant because the ACU broke. Overrides addPowerDummies, only ACU dummy will be added.
+  bool addOnlyAcuDummy = false;
  bool addPowerDummies = true;
+  bool addBpxBattDummy = true;
  bool addSyrlinksDummies = true;
  bool addAcsBoardDummies = true;
  bool addSusDummies = true;
--- a/mission/acs/GyrAdis1650XHandler.cpp
+++ b/mission/acs/GyrAdis1650XHandler.cpp
@ -37,6 +37,7 @@ void GyrAdis1650XHandler::doStartUp() {
 void GyrAdis1650XHandler::doShutDown() {
  if (internalState != InternalState::SHUTDOWN) {
    commandExecuted = false;
+    PoolReadGuard pg(&primaryDataset);
    primaryDataset.setValidity(false, true);
    internalState = InternalState::SHUTDOWN;
  }
--- a/mission/acs/GyrL3gCustomHandler.cpp
+++ b/mission/acs/GyrL3gCustomHandler.cpp
@ -33,6 +33,7 @@ void GyrL3gCustomHandler::doStartUp() {
 void GyrL3gCustomHandler::doShutDown() {
  if (internalState != InternalState::SHUTDOWN) {
    internalState = InternalState::SHUTDOWN;
+    PoolReadGuard pg(&dataset);
    dataset.setValidity(false, true);
    commandExecuted = false;
  }
--- a/mission/acs/MgmLis3CustomHandler.cpp
+++ b/mission/acs/MgmLis3CustomHandler.cpp
@ -29,6 +29,7 @@ void MgmLis3CustomHandler::doStartUp() {

 void MgmLis3CustomHandler::doShutDown() {
  if (internalState != InternalState::SHUTDOWN) {
+    PoolReadGuard pg(&dataset);
    dataset.setValidity(false, true);
    internalState = InternalState::SHUTDOWN;
    commandExecuted = false;
--- a/mission/acs/MgmRm3100CustomHandler.cpp
+++ b/mission/acs/MgmRm3100CustomHandler.cpp
@ -33,6 +33,7 @@ void MgmRm3100CustomHandler::doStartUp() {
 void MgmRm3100CustomHandler::doShutDown() {
  if (internalState != InternalState::SHUTDOWN) {
    commandExecuted = false;
+    PoolReadGuard pg(&primaryDataset);
    primaryDataset.setValidity(false, true);
    internalState = InternalState::SHUTDOWN;
  }
--- a/mission/acs/SusHandler.cpp
+++ b/mission/acs/SusHandler.cpp
@ -29,6 +29,7 @@ void SusHandler::doStartUp() {

 void SusHandler::doShutDown() {
  if (internalState != InternalState::SHUTDOWN) {
+    PoolReadGuard pg(&dataset);
    dataset.setValidity(false, true);
    internalState = InternalState::SHUTDOWN;
    commandExecuted = false;
--- a/mission/acs/defs.h
+++ b/mission/acs/defs.h
@ -3,6 +3,7 @@

 #include <eive/eventSubsystemIds.h>
 #include <fsfw/modes/HasModesIF.h>
+#include <mission/sysDefs.h>

 namespace acs {

@ -11,12 +12,12 @@ enum class SimpleSensorMode { NORMAL = 0, OFF = 1 };
 // These modes are the modes of the ACS controller and of the ACS subsystem.
 enum AcsMode : Mode_t {
  OFF = HasModesIF::MODE_OFF,
-  SAFE = 10,
-  PTG_IDLE = 11,
-  PTG_NADIR = 12,
-  PTG_TARGET = 13,
-  PTG_TARGET_GS = 14,
-  PTG_INERTIAL = 15,
+  SAFE = satsystem::Mode::SAFE,
+  PTG_IDLE = satsystem::Mode::PTG_IDLE,
+  PTG_NADIR = satsystem::Mode::PTG_NADIR,
+  PTG_TARGET = satsystem::Mode::PTG_TARGET,
+  PTG_TARGET_GS = satsystem::Mode::PTG_TARGET_GS,
+  PTG_INERTIAL = satsystem::Mode::PTG_INERTIAL,
 };

 enum SafeSubmode : Submode_t { DEFAULT = 0, DETUMBLE = 1 };
--- a/mission/genericFactory.cpp
+++ b/mission/genericFactory.cpp
@ -96,9 +96,10 @@ std::atomic_bool tcs::TCS_BOARD_SHORTLY_UNAVAILABLE = false;
 void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_, PusTmFunnel** pusFunnel,
                                          CfdpTmFunnel** cfdpFunnel, SdCardMountedIF& sdcMan,
                                          StorageManagerIF** ipcStore, StorageManagerIF** tmStore,
-                                          PersistentTmStores& stores) {
+                                          PersistentTmStores& stores,
+                                          uint32_t eventManagerQueueDepth) {
  // Framework objects
-  new EventManager(objects::EVENT_MANAGER, 160);
+  new EventManager(objects::EVENT_MANAGER, eventManagerQueueDepth);
  auto healthTable = new HealthTable(objects::HEALTH_TABLE);
  if (healthTable_ != nullptr) {
    *healthTable_ = healthTable;
--- a/mission/genericFactory.h
+++ b/mission/genericFactory.h
@ -45,7 +45,7 @@ namespace ObjectFactory {
 void produceGenericObjects(HealthTableIF** healthTable, PusTmFunnel** pusFunnel,
                           CfdpTmFunnel** cfdpFunnel, SdCardMountedIF& sdcMan,
                           StorageManagerIF** ipcStore, StorageManagerIF** tmStore,
-                           PersistentTmStores& stores);
+                           PersistentTmStores& stores, uint32_t eventManagerQueueDepth);
 void createGenericHeaterComponents(GpioIF& gpioIF, PowerSwitchIF& pwrSwitcher,
                                   HeaterHandler*& heaterHandler);

--- a/mission/scheduling.cpp
+++ b/mission/scheduling.cpp
@ -5,9 +5,11 @@
 #include "fsfw/tasks/PeriodicTaskIF.h"

 void scheduling::scheduleTmpTempSensors(PeriodicTaskIF* tmpTask) {
-  const std::array<object_id_t, 5> tmpIds = {
-      objects::TMP1075_HANDLER_TCS_0, objects::TMP1075_HANDLER_TCS_1,
-      objects::TMP1075_HANDLER_PLPCDU_0, objects::TMP1075_HANDLER_PLPCDU_1,
+  const std::array<object_id_t, 4> tmpIds = {objects::TMP1075_HANDLER_TCS_0,
+                                             objects::TMP1075_HANDLER_TCS_1,
+                                             objects::TMP1075_HANDLER_PLPCDU_0,
+                                             // damaged.
+                                             // objects::TMP1075_HANDLER_PLPCDU_1,
                                             objects::TMP1075_HANDLER_IF_BOARD};
  for (const auto& tmpId : tmpIds) {
    tmpTask->addComponent(tmpId, DeviceHandlerIF::PERFORM_OPERATION);
--- a/mission/sysDefs.h
+++ b/mission/sysDefs.h
@ -1,16 +1,28 @@
 #ifndef MISSION_SYSDEFS_H_
 #define MISSION_SYSDEFS_H_

-#include <atomic>
+#include <fsfw/action/ActionMessage.h>
+#include <fsfw/action/HasActionsIF.h>
+#include <fsfw/modes/ModeMessage.h>
+#include <fsfw/serialize/SerializeIF.h>

-#include "acs/defs.h"
+#include <atomic>
+#include <cstring>

 extern std::atomic_uint16_t I2C_FATAL_ERRORS;

 namespace satsystem {

-enum Mode : Mode_t { BOOT = 5, SAFE = acs::AcsMode::SAFE, PTG_IDLE = acs::AcsMode::PTG_IDLE };
-
+enum Mode : Mode_t {
+  BOOT = 5,
+  // DO NOT CHANGE THE ORDER starting from here, breaks ACS mode checks.
+  SAFE = 10,
+  PTG_IDLE = 11,
+  PTG_NADIR = 12,
+  PTG_TARGET = 13,
+  PTG_TARGET_GS = 14,
+  PTG_INERTIAL = 15,
+};
 }

 namespace xsc {
--- a/mission/system/EiveSystem.cpp
+++ b/mission/system/EiveSystem.cpp
@ -39,18 +39,22 @@ void EiveSystem::announceMode(bool recursive) {
      modeStr = "POINTING IDLE";
      break;
    }
-    case (acs::AcsMode::PTG_INERTIAL): {
-      modeStr = "POINTING INERTIAL";
+    case (satsystem::Mode::PTG_NADIR): {
+      modeStr = "POINTING NADIR";
      break;
    }
-    case (acs::AcsMode::PTG_TARGET): {
+    case (satsystem::Mode::PTG_TARGET): {
      modeStr = "POINTING TARGET";
      break;
    }
-    case (acs::AcsMode::PTG_TARGET_GS): {
+    case (satsystem::Mode::PTG_TARGET_GS): {
      modeStr = "POINTING TARGET GS";
      break;
    }
+    case (satsystem::Mode::PTG_INERTIAL): {
+      modeStr = "POINTING INERTIAL";
+      break;
+    }
  }
  sif::info << "EIVE system is now in " << modeStr << " mode" << std::endl;
  return Subsystem::announceMode(recursive);
--- a/mission/system/acs/DualLaneAssemblyBase.cpp
+++ b/mission/system/acs/DualLaneAssemblyBase.cpp
@ -183,11 +183,11 @@ void DualLaneAssemblyBase::handleModeTransitionFailed(ReturnValue_t result) {
  // transition to dual mode.
  if (not tryingOtherSide) {
    triggerEvent(CANT_KEEP_MODE, mode, submode);
-    startTransition(mode, nextSubmode);
+    startTransition(targetMode, nextSubmode);
    tryingOtherSide = true;
  } else {
-    triggerEvent(transitionOtherSideFailedEvent, mode, targetSubmode);
-    startTransition(mode, Submodes::DUAL_MODE);
+    triggerEvent(transitionOtherSideFailedEvent, targetMode, targetSubmode);
+    startTransition(targetMode, Submodes::DUAL_MODE);
  }
 }

@ -205,7 +205,8 @@ bool DualLaneAssemblyBase::checkAndHandleRecovery() {
    opCode = pwrStateMachine.fsm();
    if (opCode == OpCodes::TO_OFF_DONE or opCode == OpCodes::TIMEOUT_OCCURED) {
      customRecoveryStates = RecoveryCustomStates::POWER_SWITCHING_ON;
-      pwrStateMachine.start(targetMode, targetSubmode);
+      // Command power back on in any case.
+      pwrStateMachine.start(HasModesIF::MODE_ON, targetSubmode);
    }
  }
  if (customRecoveryStates == POWER_SWITCHING_ON) {
--- a/mission/system/systemTree.cpp
+++ b/mission/system/systemTree.cpp
@ -22,6 +22,10 @@ const auto check = subsystem::checkInsert;
 void buildBootSequence(Subsystem& ss, ModeListEntry& eh);
 void buildSafeSequence(Subsystem& ss, ModeListEntry& eh);
 void buildIdleSequence(Subsystem& ss, ModeListEntry& eh);
+void buildPtgNadirSequence(Subsystem& ss, ModeListEntry& eh);
+void buildPtgTargetSequence(Subsystem& ss, ModeListEntry& eh);
+void buildPtgTargetGsSequence(Subsystem& ss, ModeListEntry& eh);
+void buildPtgInertialSequence(Subsystem& ss, ModeListEntry& eh);
 }  // namespace

 static const auto OFF = HasModesIF::MODE_OFF;
@ -40,6 +44,10 @@ void satsystem::init() {
  buildBootSequence(EIVE_SYSTEM, entry);
  buildSafeSequence(EIVE_SYSTEM, entry);
  buildIdleSequence(EIVE_SYSTEM, entry);
+  buildPtgNadirSequence(EIVE_SYSTEM, entry);
+  buildPtgTargetSequence(EIVE_SYSTEM, entry);
+  buildPtgTargetGsSequence(EIVE_SYSTEM, entry);
+  buildPtgInertialSequence(EIVE_SYSTEM, entry);
  EIVE_SYSTEM.setInitialMode(satsystem::Mode::BOOT, 0);
 }

@ -68,88 +76,44 @@ auto EIVE_TABLE_IDLE_TRANS_0 =
 auto EIVE_TABLE_IDLE_TRANS_1 =
    std::make_pair((satsystem::Mode::PTG_IDLE << 24) | 3, FixedArrayList<ModeListEntry, 5>());

+auto EIVE_SEQUENCE_PTG_NADIR =
+    std::make_pair(satsystem::Mode::PTG_NADIR, FixedArrayList<ModeListEntry, 5>());
+auto EIVE_TABLE_PTG_NADIR_TGT =
+    std::make_pair((satsystem::Mode::PTG_NADIR << 24) | 1, FixedArrayList<ModeListEntry, 5>());
+auto EIVE_TABLE_PTG_NADIR_TRANS_0 =
+    std::make_pair((satsystem::Mode::PTG_NADIR << 24) | 2, FixedArrayList<ModeListEntry, 5>());
+auto EIVE_TABLE_PTG_NADIR_TRANS_1 =
+    std::make_pair((satsystem::Mode::PTG_NADIR << 24) | 3, FixedArrayList<ModeListEntry, 5>());
+
+auto EIVE_SEQUENCE_PTG_TARGET =
+    std::make_pair(satsystem::Mode::PTG_TARGET, FixedArrayList<ModeListEntry, 5>());
+auto EIVE_TABLE_PTG_TARGET_TGT =
+    std::make_pair((satsystem::Mode::PTG_TARGET << 24) | 1, FixedArrayList<ModeListEntry, 5>());
+auto EIVE_TABLE_PTG_TARGET_TRANS_0 =
+    std::make_pair((satsystem::Mode::PTG_TARGET << 24) | 2, FixedArrayList<ModeListEntry, 5>());
+auto EIVE_TABLE_PTG_TARGET_TRANS_1 =
+    std::make_pair((satsystem::Mode::PTG_TARGET << 24) | 3, FixedArrayList<ModeListEntry, 5>());
+
+auto EIVE_SEQUENCE_PTG_TARGET_GS =
+    std::make_pair(satsystem::Mode::PTG_TARGET_GS, FixedArrayList<ModeListEntry, 5>());
+auto EIVE_TABLE_PTG_TARGET_GS_TGT =
+    std::make_pair((satsystem::Mode::PTG_TARGET_GS << 24) | 1, FixedArrayList<ModeListEntry, 5>());
+auto EIVE_TABLE_PTG_TARGET_GS_TRANS_0 =
+    std::make_pair((satsystem::Mode::PTG_TARGET_GS << 24) | 2, FixedArrayList<ModeListEntry, 5>());
+auto EIVE_TABLE_PTG_TARGET_GS_TRANS_1 =
+    std::make_pair((satsystem::Mode::PTG_TARGET_GS << 24) | 3, FixedArrayList<ModeListEntry, 5>());
+
+auto EIVE_SEQUENCE_PTG_INERTIAL =
+    std::make_pair(satsystem::Mode::PTG_INERTIAL, FixedArrayList<ModeListEntry, 5>());
+auto EIVE_TABLE_PTG_INERTIAL_TGT =
+    std::make_pair((satsystem::Mode::PTG_INERTIAL << 24) | 1, FixedArrayList<ModeListEntry, 5>());
+auto EIVE_TABLE_PTG_INERTIAL_TRANS_0 =
+    std::make_pair((satsystem::Mode::PTG_INERTIAL << 24) | 2, FixedArrayList<ModeListEntry, 5>());
+auto EIVE_TABLE_PTG_INERTIAL_TRANS_1 =
+    std::make_pair((satsystem::Mode::PTG_INERTIAL << 24) | 3, FixedArrayList<ModeListEntry, 5>());
+
 namespace {

-void buildSafeSequence(Subsystem& ss, ModeListEntry& eh) {
-  std::string context = "satsystem::buildSafeSequence";
-  auto ctxc = context.c_str();
-  // Insert Helper Table
-  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode, ArrayList<ModeListEntry>& table,
-                 bool allowAllSubmodes = false) {
-    eh.setObject(obj);
-    eh.setMode(mode);
-    eh.setSubmode(submode);
-    if (allowAllSubmodes) {
-      eh.allowAllSubmodes();
-    }
-    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);
-  };
-
-  // Do no track submode to allow transitions to DETUMBLE submode.
-  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::SAFE, 0, EIVE_TABLE_SAFE_TGT.second, true);
-  iht(objects::PL_SUBSYSTEM, OFF, 0, EIVE_TABLE_SAFE_TGT.second);
-  check(ss.addTable(TableEntry(EIVE_TABLE_SAFE_TGT.first, &EIVE_TABLE_SAFE_TGT.second)), ctxc);
-
-  // Build SAFE transition 0.
-  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
-  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,
-                                     EIVE_SEQUENCE_SAFE.first)),
-        ctxc);
-}
-
-void buildIdleSequence(Subsystem& ss, ModeListEntry& eh) {
-  std::string context = "satsystem::buildIdleSequence";
-  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);
-  };
-
-  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::PTG_IDLE, 0, EIVE_TABLE_IDLE_TGT.second);
-  check(ss.addTable(TableEntry(EIVE_TABLE_IDLE_TGT.first, &EIVE_TABLE_IDLE_TGT.second)), ctxc);
-
-  // Build IDLE transition 0
-  iht(objects::TCS_SUBSYSTEM, NML, 0, EIVE_TABLE_IDLE_TRANS_0.second);
-  iht(objects::PL_SUBSYSTEM, OFF, 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)),
-        ctxc);
-
-  // Build IDLE sequence
-  ihs(EIVE_SEQUENCE_IDLE.second, EIVE_TABLE_IDLE_TGT.first, 0, false);
-  ihs(EIVE_SEQUENCE_IDLE.second, EIVE_TABLE_IDLE_TRANS_0.first, 0, false);
-  check(ss.addSequence(SequenceEntry(EIVE_SEQUENCE_IDLE.first, &EIVE_SEQUENCE_IDLE.second,
-                                     EIVE_SEQUENCE_SAFE.first)),
-        ctxc);
-}
-
 void buildBootSequence(Subsystem& ss, ModeListEntry& eh) {
  std::string context = "satsystem::buildBootSequence";
  auto ctxc = context.c_str();
@ -194,4 +158,240 @@ void buildBootSequence(Subsystem& ss, ModeListEntry& eh) {
                                     EIVE_SEQUENCE_SAFE.first)),
        ctxc);
 }
+
+void buildSafeSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::buildSafeSequence";
+  auto ctxc = context.c_str();
+  // Insert Helper Table
+  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode, ArrayList<ModeListEntry>& table,
+                 bool allowAllSubmodes = false) {
+    eh.setObject(obj);
+    eh.setMode(mode);
+    eh.setSubmode(submode);
+    if (allowAllSubmodes) {
+      eh.allowAllSubmodes();
+    }
+    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);
+  };
+
+  // Do no track submode to allow transitions to DETUMBLE submode.
+  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::SAFE, 0, EIVE_TABLE_SAFE_TGT.second, true);
+  check(ss.addTable(TableEntry(EIVE_TABLE_SAFE_TGT.first, &EIVE_TABLE_SAFE_TGT.second)), ctxc);
+
+  // Build SAFE transition 0.
+  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
+  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,
+                                     EIVE_SEQUENCE_SAFE.first)),
+        ctxc);
+}
+
+void buildIdleSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::buildIdleSequence";
+  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);
+  };
+
+  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::PTG_IDLE, 0, EIVE_TABLE_IDLE_TGT.second);
+  check(ss.addTable(TableEntry(EIVE_TABLE_IDLE_TGT.first, &EIVE_TABLE_IDLE_TGT.second)), ctxc);
+
+  // Build IDLE transition 0
+  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)),
+        ctxc);
+
+  // Build IDLE sequence
+  ihs(EIVE_SEQUENCE_IDLE.second, EIVE_TABLE_IDLE_TGT.first, 0, false);
+  ihs(EIVE_SEQUENCE_IDLE.second, EIVE_TABLE_IDLE_TRANS_0.first, 0, false);
+  check(ss.addSequence(SequenceEntry(EIVE_SEQUENCE_IDLE.first, &EIVE_SEQUENCE_IDLE.second,
+                                     EIVE_SEQUENCE_SAFE.first)),
+        ctxc);
+}
+
+void buildPtgNadirSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::buildPtgNadirSequence";
+  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);
+  };
+
+  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::PTG_NADIR, 0, EIVE_TABLE_PTG_NADIR_TGT.second);
+  check(ss.addTable(TableEntry(EIVE_TABLE_PTG_NADIR_TGT.first, &EIVE_TABLE_PTG_NADIR_TGT.second)),
+        ctxc);
+
+  // Build PTG_NADIR transition 0
+  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(
+            TableEntry(EIVE_TABLE_PTG_NADIR_TRANS_0.first, &EIVE_TABLE_PTG_NADIR_TRANS_0.second)),
+        ctxc);
+
+  // Build PTG_NADIR sequence
+  ihs(EIVE_SEQUENCE_PTG_NADIR.second, EIVE_TABLE_PTG_NADIR_TGT.first, 0, false);
+  ihs(EIVE_SEQUENCE_PTG_NADIR.second, EIVE_TABLE_PTG_NADIR_TRANS_0.first, 0, false);
+  check(ss.addSequence(SequenceEntry(EIVE_SEQUENCE_PTG_NADIR.first, &EIVE_SEQUENCE_PTG_NADIR.second,
+                                     EIVE_SEQUENCE_IDLE.first)),
+        ctxc);
+}
+
+void buildPtgTargetSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::buildPtgTargetSequence";
+  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);
+  };
+
+  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::PTG_TARGET, 0, EIVE_TABLE_PTG_TARGET_TGT.second);
+  check(ss.addTable(TableEntry(EIVE_TABLE_PTG_TARGET_TGT.first, &EIVE_TABLE_PTG_TARGET_TGT.second)),
+        ctxc);
+
+  // Build PTG_TARGET transition 0
+  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(
+            TableEntry(EIVE_TABLE_PTG_TARGET_TRANS_0.first, &EIVE_TABLE_PTG_TARGET_TRANS_0.second)),
+        ctxc);
+
+  // Build PTG_TARGET sequence
+  ihs(EIVE_SEQUENCE_PTG_TARGET.second, EIVE_TABLE_PTG_TARGET_TGT.first, 0, false);
+  ihs(EIVE_SEQUENCE_PTG_TARGET.second, EIVE_TABLE_PTG_TARGET_TRANS_0.first, 0, false);
+  check(ss.addSequence(SequenceEntry(EIVE_SEQUENCE_PTG_TARGET.first,
+                                     &EIVE_SEQUENCE_PTG_TARGET.second, EIVE_SEQUENCE_IDLE.first)),
+        ctxc);
+}
+
+void buildPtgTargetGsSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::buildPtgTargetGsSequence";
+  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);
+  };
+
+  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::PTG_TARGET_GS, 0, EIVE_TABLE_PTG_TARGET_GS_TGT.second);
+  check(ss.addTable(
+            TableEntry(EIVE_TABLE_PTG_TARGET_GS_TGT.first, &EIVE_TABLE_PTG_TARGET_GS_TGT.second)),
+        ctxc);
+
+  // Build PTG_TARGET_GS transition 0
+  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);
+  check(ss.addTable(TableEntry(EIVE_TABLE_PTG_TARGET_GS_TRANS_0.first,
+                               &EIVE_TABLE_PTG_TARGET_GS_TRANS_0.second)),
+        ctxc);
+
+  // Build PTG_TARGET_GS sequence
+  ihs(EIVE_SEQUENCE_PTG_TARGET_GS.second, EIVE_TABLE_PTG_TARGET_GS_TGT.first, 0, false);
+  ihs(EIVE_SEQUENCE_PTG_TARGET_GS.second, EIVE_TABLE_PTG_TARGET_GS_TRANS_0.first, 0, false);
+  check(
+      ss.addSequence(SequenceEntry(EIVE_SEQUENCE_PTG_TARGET_GS.first,
+                                   &EIVE_SEQUENCE_PTG_TARGET_GS.second, EIVE_SEQUENCE_IDLE.first)),
+      ctxc);
+}
+
+void buildPtgInertialSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::buildPtgInertialSequence";
+  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);
+  };
+
+  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::PTG_INERTIAL, 0, EIVE_TABLE_PTG_INERTIAL_TGT.second);
+  check(ss.addTable(
+            TableEntry(EIVE_TABLE_PTG_INERTIAL_TGT.first, &EIVE_TABLE_PTG_INERTIAL_TGT.second)),
+        ctxc);
+
+  // Build PTG_INERTIAL transition 0
+  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);
+  check(ss.addTable(TableEntry(EIVE_TABLE_PTG_INERTIAL_TRANS_0.first,
+                               &EIVE_TABLE_PTG_INERTIAL_TRANS_0.second)),
+        ctxc);
+
+  // Build PTG_INERTIAL sequence
+  ihs(EIVE_SEQUENCE_PTG_INERTIAL.second, EIVE_TABLE_PTG_INERTIAL_TGT.first, 0, false);
+  ihs(EIVE_SEQUENCE_PTG_INERTIAL.second, EIVE_TABLE_PTG_INERTIAL_TRANS_0.first, 0, false);
+  check(ss.addSequence(SequenceEntry(EIVE_SEQUENCE_PTG_INERTIAL.first,
+                                     &EIVE_SEQUENCE_PTG_INERTIAL.second, EIVE_SEQUENCE_IDLE.first)),
+        ctxc);
+}
+
 }  // namespace