custom FDIR for tmp devices

mission/system/tcs/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(
+  ${LIB_EIVE_MISSION} PRIVATE tcsModeTree.cpp TcsSubsystem.cpp
+                              TcsBoardAssembly.cpp RtdFdir.cpp TmpDevFdir.cpp)

mission/system/tcs/RtdFdir.cpp

@@ -0,0 +1,6 @@
+#include "RtdFdir.h"
+
+#include "eive/objects.h"
+
+RtdFdir::RtdFdir(object_id_t sensorId)
+    : DeviceHandlerFailureIsolation(sensorId, objects::NO_OBJECT) {}

mission/system/tcs/RtdFdir.h

@@ -0,0 +1,11 @@
+#ifndef MISSION_SYSTEM_RTDFDIR_H_
+#define MISSION_SYSTEM_RTDFDIR_H_
+
+#include <fsfw/devicehandlers/DeviceHandlerFailureIsolation.h>
+
+class RtdFdir : public DeviceHandlerFailureIsolation {
+ public:
+  RtdFdir(object_id_t sensorId);
+};
+
+#endif /* MISSION_SYSTEM_RTDFDIR_H_ */

mission/system/tcs/TcsBoardAssembly.cpp

@@ -0,0 +1,179 @@
+#include "TcsBoardAssembly.h"
+
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+#include <fsfw/ipc/QueueFactory.h>
+
+TcsBoardAssembly::TcsBoardAssembly(object_id_t objectId, PowerSwitchIF* pwrSwitcher,
+                                   power::Switch_t theSwitch, TcsBoardHelper helper,
+                                   std::atomic_bool& tcsShortlyUnavailable)
+    : SharedPowerAssemblyBase(objectId, pwrSwitcher, theSwitch, 16),
+      helper(helper),
+      tcsShortlyUnavailable(tcsShortlyUnavailable) {
+  ModeListEntry entry;
+  for (uint8_t idx = 0; idx < NUMBER_RTDS; idx++) {
+    entry.setObject(helper.rtdInfos[idx].first);
+    entry.setMode(MODE_OFF);
+    entry.setSubmode(SUBMODE_NONE);
+    modeTable.insert(entry);
+  }
+}
+
+ReturnValue_t TcsBoardAssembly::commandChildren(Mode_t mode, Submode_t submode) {
+  ReturnValue_t result = returnvalue::OK;
+  // Initialize the mode table to ensure all devices are in a defined state
+  for (uint8_t idx = 0; idx < NUMBER_RTDS; idx++) {
+    modeTable[idx].setMode(MODE_OFF);
+    modeTable[idx].setSubmode(SUBMODE_NONE);
+  }
+  if (recoveryState == RecoveryState::RECOVERY_IDLE) {
+    result = checkAndHandleHealthStates(mode, submode);
+    if (result == NEED_TO_CHANGE_HEALTH) {
+      return returnvalue::OK;
+    }
+  }
+  if (recoveryState != RecoveryState::RECOVERY_STARTED) {
+    if (mode == DeviceHandlerIF::MODE_NORMAL or mode == MODE_ON) {
+      result = handleNormalOrOnModeCmd(mode, submode);
+    }
+  } else {
+    tcsShortlyUnavailable = true;
+  }
+  HybridIterator<ModeListEntry> tableIter(modeTable.begin(), modeTable.end());
+  executeTable(tableIter);
+  return result;
+}
+
+ReturnValue_t TcsBoardAssembly::checkChildrenStateOn(Mode_t wantedMode, Submode_t wantedSubmode) {
+  int devsInWrongMode = 0;
+  try {
+    for (uint8_t idx = 0; idx < NUMBER_RTDS; idx++) {
+      if (childrenMap.at(helper.rtdInfos[idx].first).mode != wantedMode) {
+        devsInWrongMode++;
+      }
+    }
+  } catch (const std::out_of_range& e) {
+    sif::error << "TcsBoardAssembly: Invalid children map: " << e.what() << std::endl;
+  }
+  if (devsInWrongMode == NUMBER_RTDS) {
+    if (warningSwitch) {
+      sif::warning << "TcsBoardAssembly::checkChildrenStateOn: All devices in wrong mode"
+                   << std::endl;
+      warningSwitch = false;
+    }
+    return NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE;
+  }
+  // TODO: Can't really do something other than power cycling if devices in wrong mode.
+  // Might attempt one power-cycle. In any case, trigger an event
+  if (devsInWrongMode > 0) {
+    if (warningSwitch) {
+      sif::warning << "TcsBoardAssembly::checkChildrenStateOn: " << devsInWrongMode << " devices in"
+                   << " wrong mode" << std::endl;
+      warningSwitch = false;
+    }
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t TcsBoardAssembly::isModeCombinationValid(Mode_t mode, Submode_t submode) {
+  if (mode == MODE_ON or mode == MODE_OFF or mode == DeviceHandlerIF::MODE_NORMAL) {
+    return returnvalue::OK;
+  }
+  return HasModesIF::INVALID_MODE;
+}
+
+ReturnValue_t TcsBoardAssembly::handleNormalOrOnModeCmd(Mode_t mode, Submode_t submode) {
+  ReturnValue_t result = returnvalue::OK;
+  bool needsSecondStep = false;
+  Mode_t devMode = 0;
+  object_id_t objId = 0;
+  try {
+    for (uint8_t idx = 0; idx < NUMBER_RTDS; idx++) {
+      devMode = childrenMap.at(helper.rtdInfos[idx].first).mode;
+      objId = helper.rtdInfos[idx].first;
+      if (mode == devMode) {
+        modeTable[idx].setMode(mode);
+      } else if (mode == DeviceHandlerIF::MODE_NORMAL) {
+        if (isUseable(objId, devMode)) {
+          if (devMode == MODE_ON) {
+            modeTable[idx].setMode(mode);
+            modeTable[idx].setSubmode(SUBMODE_NONE);
+          } else {
+            modeTable[idx].setMode(MODE_ON);
+            modeTable[idx].setSubmode(SUBMODE_NONE);
+            if (internalState != STATE_SECOND_STEP) {
+              needsSecondStep = true;
+            }
+          }
+        }
+      } else if (mode == MODE_ON) {
+        if (isUseable(objId, devMode)) {
+          modeTable[idx].setMode(MODE_ON);
+          modeTable[idx].setSubmode(SUBMODE_NONE);
+        }
+      }
+    }
+  } catch (const std::out_of_range& e) {
+    sif::error << "TcsBoardAssembly: Invalid children map: " << e.what() << std::endl;
+  }
+  if (needsSecondStep) {
+    result = NEED_SECOND_STEP;
+  }
+  return result;
+}
+
+bool TcsBoardAssembly::isUseable(object_id_t object, Mode_t mode) {
+  if (healthHelper.healthTable->isFaulty(object)) {
+    return false;
+  }
+
+  // Check if device is already in target mode
+  if (childrenMap[object].mode == mode) {
+    return true;
+  }
+
+  if (healthHelper.healthTable->isCommandable(object)) {
+    return true;
+  }
+  return false;
+}
+
+void TcsBoardAssembly::handleChildrenLostMode(ReturnValue_t result) {
+  triggerEvent(CHILDREN_LOST_MODE, result);
+  startTransition(mode, submode);
+}
+
+ReturnValue_t TcsBoardAssembly::checkAndHandleHealthStates(Mode_t deviceMode,
+                                                           Submode_t deviceSubmode) {
+  ReturnValue_t status = returnvalue::OK;
+  for (const auto& dev : helper.rtdInfos) {
+    HealthState health = healthHelper.healthTable->getHealth(dev.first);
+    if (health == HealthState::HEALTHY) {
+      return returnvalue::OK;
+    }
+  }
+
+  for (const auto& dev : helper.rtdInfos) {
+    HealthState health = healthHelper.healthTable->getHealth(dev.first);
+    if (health == FAULTY or health == PERMANENT_FAULTY) {
+      status = NEED_TO_CHANGE_HEALTH;
+    } else if (health == EXTERNAL_CONTROL) {
+      modeHelper.setForced(true);
+    }
+  }
+  return status;
+}
+
+bool TcsBoardAssembly::checkAndHandleRecovery() {
+  bool recoveryPending = SharedPowerAssemblyBase::checkAndHandleRecovery();
+  tcsShortlyUnavailable = recoveryPending;
+  return recoveryPending;
+}
+
+void TcsBoardAssembly::handleModeTransitionFailed(ReturnValue_t result) {
+  if (targetMode == MODE_OFF) {
+    AssemblyBase::handleModeTransitionFailed(result);
+  } else {
+    // To avoid transitioning back to off
+    triggerEvent(MODE_TRANSITION_FAILED, result);
+  }
+}

mission/system/tcs/TcsBoardAssembly.h

@@ -0,0 +1,59 @@
+#ifndef MISSION_SYSTEM_TCSSUBSYSTEM_H_
+#define MISSION_SYSTEM_TCSSUBSYSTEM_H_
+
+#include <fsfw/container/FixedArrayList.h>
+#include <fsfw/devicehandlers/AssemblyBase.h>
+#include <fsfw/power/PowerSwitcher.h>
+#include <mission/power/defs.h>
+#include <mission/system/SharedPowerAssemblyBase.h>
+
+#include <atomic>
+
+#include "events/subsystemIdRanges.h"
+#include "returnvalues/classIds.h"
+
+struct TcsBoardHelper {
+  TcsBoardHelper(std::array<std::pair<object_id_t, std::string>, 16> rtdInfos)
+      : rtdInfos(std::move(rtdInfos)) {}
+
+  std::array<std::pair<object_id_t, std::string>, 16> rtdInfos = {};
+};
+
+class TcsBoardAssembly : public SharedPowerAssemblyBase {
+ public:
+  static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::TCS_BOARD_ASS;
+  static constexpr Event CHILDREN_LOST_MODE = event::makeEvent(SUBSYSTEM_ID, 0, severity::MEDIUM);
+
+  TcsBoardAssembly(object_id_t objectId, PowerSwitchIF* pwrSwitcher, power::Switch_t switcher,
+                   TcsBoardHelper helper, std::atomic_bool& tcsShortlyUnavailable);
+
+ private:
+  static constexpr uint8_t NUMBER_RTDS = 16;
+  bool warningSwitch = true;
+  TcsBoardHelper helper;
+  FixedArrayList<ModeListEntry, NUMBER_RTDS> modeTable;
+  std::atomic_bool& tcsShortlyUnavailable;
+
+  ReturnValue_t handleNormalOrOnModeCmd(Mode_t mode, Submode_t submode);
+  /**
+   * Check whether it makes sense to send mode commands to the device
+   * @param object
+   * @param mode
+   * @return
+   */
+  bool isUseable(object_id_t object, Mode_t mode);
+
+  // AssemblyBase implementation
+  ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) override;
+  ReturnValue_t checkChildrenStateOn(Mode_t wantedMode, Submode_t wantedSubmode) override;
+  ReturnValue_t isModeCombinationValid(Mode_t mode, Submode_t submode) override;
+  ReturnValue_t checkAndHandleHealthStates(Mode_t deviceMode, Submode_t deviceSubmode);
+  bool checkAndHandleRecovery() override;
+
+  // These two overrides prevent a transition of the whole assembly back to off just because
+  // some devices are not working
+  void handleChildrenLostMode(ReturnValue_t result) override;
+  void handleModeTransitionFailed(ReturnValue_t result) override;
+};
+
+#endif /* MISSION_SYSTEM_TCSSUBSYSTEM_H_ */

mission/system/tcs/TcsSubsystem.cpp

@@ -0,0 +1,27 @@
+#include "TcsSubsystem.h"
+
+#include "fsfw/devicehandlers/DeviceHandlerIF.h"
+
+TcsSubsystem::TcsSubsystem(object_id_t objectId, uint32_t maxNumberOfSequences,
+                           uint32_t maxNumberOfTables)
+    : Subsystem(objectId, maxNumberOfSequences, maxNumberOfTables) {}
+
+void TcsSubsystem::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 << "TCS subsystem is now in " << modeStr << " mode" << std::endl;
+  return Subsystem::announceMode(recursive);
+}

mission/system/tcs/TcsSubsystem.h

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

mission/system/tcs/TmpDevFdir.cpp

@@ -0,0 +1,91 @@
+#include "TmpDevFdir.h"
+
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+#include <fsfw/modes/HasModesIF.h>
+#include <fsfw/power/Fuse.h>
+#include <fsfw/thermal/ThermalComponentIF.h>
+
+TmpDevFdir::TmpDevFdir(object_id_t sensorId)
+    : DeviceHandlerFailureIsolation(sensorId, objects::NO_OBJECT) {}
+
+ReturnValue_t TmpDevFdir::eventReceived(EventMessage* event) {
+  if (isFdirInActionOrAreWeFaulty(event)) {
+    return returnvalue::OK;
+  }
+  ReturnValue_t result = returnvalue::FAILED;
+  switch (event->getEvent()) {
+    case HasModesIF::MODE_TRANSITION_FAILED:
+    case HasModesIF::OBJECT_IN_INVALID_MODE:
+    case DeviceHandlerIF::DEVICE_WANTS_HARD_REBOOT:
+      // We'll try a recovery as long as defined in MAX_REBOOT.
+      // Might cause some AssemblyBase cycles, so keep number low.
+      // Ignored for TMP device, no way to power cycle it without going to OFF/BOOT mode.
+      // handleRecovery(event->getEvent());
+      break;
+    case DeviceHandlerIF::DEVICE_INTERPRETING_REPLY_FAILED:
+    case DeviceHandlerIF::DEVICE_READING_REPLY_FAILED:
+    case DeviceHandlerIF::DEVICE_UNREQUESTED_REPLY:
+    case DeviceHandlerIF::DEVICE_UNKNOWN_REPLY:  // Some DH's generate generic reply-ids.
+    case DeviceHandlerIF::DEVICE_BUILDING_COMMAND_FAILED:
+      // These faults all mean that there were stupid replies from a device.
+      // With now way to do a recovery, set the device to faulty immediately.
+      setFaulty(event->getEvent());
+      break;
+    case DeviceHandlerIF::DEVICE_SENDING_COMMAND_FAILED:
+    case DeviceHandlerIF::DEVICE_REQUESTING_REPLY_FAILED:
+      // The two above should never be confirmed.
+    case DeviceHandlerIF::DEVICE_MISSED_REPLY:
+      result = sendConfirmationRequest(event);
+      if (result == returnvalue::OK) {
+        break;
+      }
+      // else
+      setFaulty(event->getEvent());
+      break;
+    case StorageManagerIF::GET_DATA_FAILED:
+    case StorageManagerIF::STORE_DATA_FAILED:
+      // Rather strange bugs, occur in RAW mode only. Ignore.
+      break;
+    case DeviceHandlerIF::INVALID_DEVICE_COMMAND:
+      // Ignore, is bad configuration. We can't do anything in flight.
+      break;
+    case HasHealthIF::HEALTH_INFO:
+    case HasModesIF::MODE_INFO:
+    case HasModesIF::CHANGING_MODE:
+      // Do nothing, but mark as handled.
+      break;
+      //****Thermal*****
+    case ThermalComponentIF::COMPONENT_TEMP_LOW:
+    case ThermalComponentIF::COMPONENT_TEMP_HIGH:
+    case ThermalComponentIF::COMPONENT_TEMP_OOL_LOW:
+    case ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH:
+      // Well, the device is not really faulty, but it is required to stay off as long as possible.
+      setFaulty(event->getEvent());
+      break;
+    case ThermalComponentIF::TEMP_NOT_IN_OP_RANGE:
+      // Ignore, is information only.
+      break;
+      //*******Default monitoring variables. Are currently not used.*****
+      //	case DeviceHandlerIF::MONITORING_LIMIT_EXCEEDED:
+      //		setFaulty(event->getEvent());
+      //		break;
+      //	case DeviceHandlerIF::MONITORING_AMBIGUOUS:
+      //		break;
+    default:
+      // We don't know the event, someone else should handle it.
+      return returnvalue::FAILED;
+  }
+  return returnvalue::OK;
+}
+
+void TmpDevFdir::eventConfirmed(EventMessage* event) {
+  switch (event->getEvent()) {
+    case DeviceHandlerIF::DEVICE_SENDING_COMMAND_FAILED:
+    case DeviceHandlerIF::DEVICE_REQUESTING_REPLY_FAILED:
+    case DeviceHandlerIF::DEVICE_MISSED_REPLY:
+      setFaulty(event->getEvent());
+      break;
+    default:
+      break;
+  }
+}

mission/system/tcs/TmpDevFdir.h

@@ -0,0 +1,20 @@
+#ifndef MISSION_SYSTEM_TCS_TMPDEVFDIR_H_
+#define MISSION_SYSTEM_TCS_TMPDEVFDIR_H_
+#include <fsfw/devicehandlers/DeviceHandlerFailureIsolation.h>
+
+/**
+ * Special FDIR because we can not simply power cycle the TMP devices which are powered by the
+ * 3.3 V stack and there is also no way to logically reset or re-configure the TMP devices in
+ * any way. In general, instead of doing a recovery, the TMP devices should be set faulty
+ * immediately for the EIVE project.
+ */
+class TmpDevFdir : public DeviceHandlerFailureIsolation {
+ public:
+  TmpDevFdir(object_id_t sensorId);
+
+ private:
+  ReturnValue_t eventReceived(EventMessage* event) override;
+  void eventConfirmed(EventMessage* event) override;
+};
+
+#endif /* MISSION_SYSTEM_TCS_TMPDEVFDIR_H_ */

mission/system/tcs/tcsModeTree.cpp

@@ -0,0 +1,126 @@
+#include "tcsModeTree.h"
+
+#include "eive/objects.h"
+#include "fsfw/devicehandlers/DeviceHandlerIF.h"
+#include "fsfw/subsystem/Subsystem.h"
+#include "mission/system/treeUtil.h"
+
+TcsSubsystem satsystem::tcs::SUBSYSTEM(objects::TCS_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 TCS_SEQUENCE_OFF = std::make_pair(OFF, FixedArrayList<ModeListEntry, 3>());
+auto TCS_TABLE_OFF_TGT = std::make_pair((OFF << 24) | 1, FixedArrayList<ModeListEntry, 2>());
+auto TCS_TABLE_OFF_TRANS_0 = std::make_pair((OFF << 24) | 2, FixedArrayList<ModeListEntry, 2>());
+auto TCS_TABLE_OFF_TRANS_1 = std::make_pair((OFF << 24) | 3, FixedArrayList<ModeListEntry, 7>());
+
+auto TCS_SEQUENCE_NORMAL = std::make_pair(NML, FixedArrayList<ModeListEntry, 3>());
+auto TCS_TABLE_NORMAL_TGT = std::make_pair((NML << 24) | 1, FixedArrayList<ModeListEntry, 2>());
+auto TCS_TABLE_NORMAL_TRANS_0 = std::make_pair((NML << 24) | 2, FixedArrayList<ModeListEntry, 7>());
+auto TCS_TABLE_NORMAL_TRANS_1 = std::make_pair((NML << 24) | 3, FixedArrayList<ModeListEntry, 2>());
+
+Subsystem& satsystem::tcs::init() {
+  ModeListEntry entry;
+  buildOffSequence(SUBSYSTEM, entry);
+  buildNormalSequence(SUBSYSTEM, entry);
+  SUBSYSTEM.setInitialMode(OFF);
+  return SUBSYSTEM;
+}
+
+namespace {
+
+void buildOffSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::tcs::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(TCS_TABLE_OFF_TGT.first, &TCS_TABLE_OFF_TGT.second)), ctxc);
+
+  // Transition 1
+  iht(objects::THERMAL_CONTROLLER, OFF, 0, TCS_TABLE_OFF_TRANS_0.second);
+  check(ss.addTable(TableEntry(TCS_TABLE_OFF_TRANS_0.first, &TCS_TABLE_OFF_TRANS_0.second)), ctxc);
+
+  iht(objects::TCS_BOARD_ASS, OFF, 0, TCS_TABLE_OFF_TRANS_1.second);
+  iht(objects::TMP1075_HANDLER_TCS_0, OFF, 0, TCS_TABLE_OFF_TRANS_1.second);
+  iht(objects::TMP1075_HANDLER_TCS_1, OFF, 0, TCS_TABLE_OFF_TRANS_1.second);
+  iht(objects::TMP1075_HANDLER_PLPCDU_0, OFF, 0, TCS_TABLE_OFF_TRANS_1.second);
+  // TMP PL PCDU 1 is damaged
+  iht(objects::TMP1075_HANDLER_IF_BOARD, OFF, 0, TCS_TABLE_OFF_TRANS_1.second);
+  check(ss.addTable(TableEntry(TCS_TABLE_OFF_TRANS_1.first, &TCS_TABLE_OFF_TRANS_1.second)), ctxc);
+
+  ihs(TCS_SEQUENCE_OFF.second, TCS_TABLE_OFF_TGT.first, 0, false);
+  ihs(TCS_SEQUENCE_OFF.second, TCS_TABLE_OFF_TRANS_0.first, 0, false);
+  ihs(TCS_SEQUENCE_OFF.second, TCS_TABLE_OFF_TRANS_1.first, 0, false);
+  check(ss.addSequence(SequenceEntry(TCS_SEQUENCE_OFF.first, &TCS_SEQUENCE_OFF.second,
+                                     TCS_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 target table is empty
+  check(ss.addTable(TableEntry(TCS_TABLE_NORMAL_TGT.first, &TCS_TABLE_NORMAL_TGT.second)), ctxc);
+
+  iht(objects::TCS_BOARD_ASS, NML, 0, TCS_TABLE_NORMAL_TRANS_0.second);
+  iht(objects::TMP1075_HANDLER_TCS_0, NML, 0, TCS_TABLE_NORMAL_TRANS_0.second);
+  iht(objects::TMP1075_HANDLER_TCS_1, NML, 0, TCS_TABLE_NORMAL_TRANS_0.second);
+  iht(objects::TMP1075_HANDLER_PLPCDU_0, NML, 0, TCS_TABLE_NORMAL_TRANS_0.second);
+  // TMP PL PCDU 1 is damaged
+  iht(objects::TMP1075_HANDLER_IF_BOARD, NML, 0, TCS_TABLE_NORMAL_TRANS_0.second);
+  check(ss.addTable(TableEntry(TCS_TABLE_NORMAL_TRANS_0.first, &TCS_TABLE_NORMAL_TRANS_0.second)),
+        ctxc);
+
+  // Transition 1
+  iht(objects::THERMAL_CONTROLLER, HasModesIF::MODE_ON, 0, TCS_TABLE_NORMAL_TRANS_1.second);
+  check(ss.addTable(TableEntry(TCS_TABLE_NORMAL_TRANS_1.first, &TCS_TABLE_NORMAL_TRANS_1.second)),
+        ctxc);
+
+  ihs(TCS_SEQUENCE_NORMAL.second, TCS_TABLE_NORMAL_TGT.first, 0, false);
+  ihs(TCS_SEQUENCE_NORMAL.second, TCS_TABLE_NORMAL_TRANS_0.first, 0, false);
+  ihs(TCS_SEQUENCE_NORMAL.second, TCS_TABLE_NORMAL_TRANS_1.first, 0, false);
+  check(ss.addSequence(SequenceEntry(TCS_SEQUENCE_NORMAL.first, &TCS_SEQUENCE_NORMAL.second,
+                                     TCS_SEQUENCE_NORMAL.first)),
+        ctxc);
+}
+
+}  // namespace

mission/system/tcs/tcsModeTree.h

@@ -0,0 +1,15 @@
+#ifndef MISSION_SYSTEM_TREE_TCSMODETREE_H_
+#define MISSION_SYSTEM_TREE_TCSMODETREE_H_
+
+#include <mission/system/tcs/TcsSubsystem.h>
+
+namespace satsystem {
+namespace tcs {
+
+extern TcsSubsystem SUBSYSTEM;
+Subsystem& init();
+
+}  // namespace tcs
+}  // namespace satsystem
+
+#endif /* MISSION_SYSTEM_TREE_TCSMODETREE_H_ */