system folder restructuring

mission/system/objects/AcsBoardAssembly.cpp

@@ -0,0 +1,316 @@
+#include "AcsBoardAssembly.h"
+
+#include <devices/gpioIds.h>
+#include <fsfw/power/PowerSwitchIF.h>
+#include <fsfw/serviceinterface.h>
+
+#include "OBSWConfig.h"
+
+AcsBoardAssembly::AcsBoardAssembly(object_id_t objectId, object_id_t parentId,
+                                   PowerSwitchIF* switcher, AcsBoardHelper helper, GpioIF* gpioIF)
+    : DualLaneAssemblyBase(objectId, parentId, switcher, SWITCH_A, SWITCH_B,
+                           POWER_STATE_MACHINE_TIMEOUT, SIDE_SWITCH_TRANSITION_NOT_ALLOWED,
+                           TRANSITION_OTHER_SIDE_FAILED),
+      helper(helper),
+      gpioIF(gpioIF) {
+  if (switcher == nullptr) {
+    sif::error << "AcsBoardAssembly::AcsBoardAssembly: Invalid Power Switcher "
+                  "IF passed"
+               << std::endl;
+  }
+  if (gpioIF == nullptr) {
+    sif::error << "AcsBoardAssembly::AcsBoardAssembly: Invalid GPIO IF passed" << std::endl;
+  }
+  ModeListEntry entry;
+  initModeTableEntry(helper.mgm0Lis3IdSideA, entry, modeTable);
+  initModeTableEntry(helper.mgm1Rm3100IdSideA, entry, modeTable);
+  initModeTableEntry(helper.mgm2Lis3IdSideB, entry, modeTable);
+  initModeTableEntry(helper.mgm3Rm3100IdSideB, entry, modeTable);
+  initModeTableEntry(helper.gyro0AdisIdSideA, entry, modeTable);
+  initModeTableEntry(helper.gyro1L3gIdSideA, entry, modeTable);
+  initModeTableEntry(helper.gyro2AdisIdSideB, entry, modeTable);
+  initModeTableEntry(helper.gyro3L3gIdSideB, entry, modeTable);
+  initModeTableEntry(helper.gpsId, entry, modeTable);
+}
+
+ReturnValue_t AcsBoardAssembly::commandChildren(Mode_t mode, Submode_t submode) {
+  using namespace duallane;
+  ReturnValue_t result = RETURN_OK;
+  refreshHelperModes();
+  // Initialize the mode table to ensure all devices are in a defined state
+  modeTable[ModeTableIdx::GYRO_0_A].setMode(MODE_OFF);
+  modeTable[ModeTableIdx::GYRO_0_A].setSubmode(SUBMODE_NONE);
+  modeTable[ModeTableIdx::GYRO_1_A].setMode(MODE_OFF);
+  modeTable[ModeTableIdx::GYRO_1_A].setSubmode(SUBMODE_NONE);
+  modeTable[ModeTableIdx::GYRO_2_B].setMode(MODE_OFF);
+  modeTable[ModeTableIdx::GYRO_2_B].setSubmode(SUBMODE_NONE);
+  modeTable[ModeTableIdx::GYRO_3_B].setMode(MODE_OFF);
+  modeTable[ModeTableIdx::GYRO_3_B].setSubmode(SUBMODE_NONE);
+  modeTable[ModeTableIdx::MGM_0_A].setMode(MODE_OFF);
+  modeTable[ModeTableIdx::MGM_0_A].setSubmode(SUBMODE_NONE);
+  modeTable[ModeTableIdx::MGM_1_A].setMode(MODE_OFF);
+  modeTable[ModeTableIdx::MGM_1_A].setSubmode(SUBMODE_NONE);
+  modeTable[ModeTableIdx::MGM_2_B].setMode(MODE_OFF);
+  modeTable[ModeTableIdx::MGM_2_B].setSubmode(SUBMODE_NONE);
+  modeTable[ModeTableIdx::MGM_3_B].setMode(MODE_OFF);
+  modeTable[ModeTableIdx::MGM_3_B].setSubmode(SUBMODE_NONE);
+  modeTable[ModeTableIdx::GPS].setMode(MODE_OFF);
+  modeTable[ModeTableIdx::GPS].setSubmode(SUBMODE_NONE);
+  if (recoveryState != RecoveryState::RECOVERY_STARTED) {
+    if (mode == DeviceHandlerIF::MODE_NORMAL or mode == MODE_ON) {
+      result = handleNormalOrOnModeCmd(mode, submode);
+    }
+  }
+  HybridIterator<ModeListEntry> tableIter(modeTable.begin(), modeTable.end());
+  executeTable(tableIter);
+  return result;
+}
+
+ReturnValue_t AcsBoardAssembly::checkChildrenStateOn(Mode_t wantedMode, Submode_t wantedSubmode) {
+  using namespace duallane;
+  refreshHelperModes();
+  if (wantedSubmode == A_SIDE) {
+    if ((helper.gyro0SideAMode != wantedMode and helper.gyro1SideAMode != wantedMode) or
+        (helper.mgm0SideAMode != wantedMode and helper.mgm1SideAMode != wantedMode) or
+        helper.gpsMode != MODE_ON) {
+      return NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE;
+    }
+    return RETURN_OK;
+  } else if (wantedSubmode == B_SIDE) {
+    if ((helper.gyro2SideBMode != wantedMode and helper.gyro3SideBMode != wantedMode) or
+        (helper.mgm2SideBMode != wantedMode and helper.mgm3SideBMode != wantedMode) or
+        helper.gpsMode != MODE_ON) {
+      return NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE;
+    }
+    return RETURN_OK;
+  } else if (wantedSubmode == DUAL_MODE) {
+    if ((helper.gyro0SideAMode != wantedMode and helper.gyro1SideAMode != wantedMode and
+         helper.gyro2AdisIdSideB != wantedMode and helper.gyro3SideBMode != wantedMode) or
+        (helper.mgm0SideAMode != wantedMode and helper.mgm1SideAMode != wantedMode and
+         helper.mgm2SideBMode != wantedMode and helper.mgm3SideBMode != wantedMode) or
+        helper.gpsMode != MODE_ON) {
+      // Trigger event, but don't start any other transitions. This is the last fallback mode.
+      if (dualModeErrorSwitch) {
+        triggerEvent(NOT_ENOUGH_DEVICES_DUAL_MODE, 0, 0);
+        dualModeErrorSwitch = false;
+      }
+      return RETURN_OK;
+    }
+    return RETURN_OK;
+  }
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t AcsBoardAssembly::handleNormalOrOnModeCmd(Mode_t mode, Submode_t submode) {
+  using namespace duallane;
+  ReturnValue_t result = RETURN_OK;
+  bool needsSecondStep = false;
+  auto cmdSeq = [&](object_id_t objectId, Mode_t devMode, ModeTableIdx tableIdx) {
+    if (mode == devMode) {
+      modeTable[tableIdx].setMode(mode);
+    } else if (mode == DeviceHandlerIF::MODE_NORMAL) {
+      if (isUseable(objectId, devMode)) {
+        if (devMode == MODE_ON) {
+          modeTable[tableIdx].setMode(mode);
+          modeTable[tableIdx].setSubmode(SUBMODE_NONE);
+        } else {
+          modeTable[tableIdx].setMode(MODE_ON);
+          modeTable[tableIdx].setSubmode(SUBMODE_NONE);
+          if (internalState != STATE_SECOND_STEP) {
+            needsSecondStep = true;
+          }
+        }
+      }
+    } else if (mode == MODE_ON) {
+      if (isUseable(objectId, devMode)) {
+        modeTable[tableIdx].setMode(MODE_ON);
+        modeTable[tableIdx].setSubmode(SUBMODE_NONE);
+      }
+    }
+  };
+  bool gpsUsable = isUseable(helper.gpsId, helper.gpsMode);
+  switch (submode) {
+    case (A_SIDE): {
+      modeTable[ModeTableIdx::GYRO_2_B].setMode(MODE_OFF);
+      modeTable[ModeTableIdx::GYRO_2_B].setSubmode(SUBMODE_NONE);
+      modeTable[ModeTableIdx::GYRO_3_B].setMode(MODE_OFF);
+      modeTable[ModeTableIdx::GYRO_3_B].setSubmode(SUBMODE_NONE);
+      modeTable[ModeTableIdx::MGM_2_B].setMode(MODE_OFF);
+      modeTable[ModeTableIdx::MGM_2_B].setSubmode(SUBMODE_NONE);
+      modeTable[ModeTableIdx::MGM_3_B].setMode(MODE_OFF);
+      modeTable[ModeTableIdx::MGM_3_B].setSubmode(SUBMODE_NONE);
+      cmdSeq(helper.gyro0AdisIdSideA, helper.gyro0SideAMode, ModeTableIdx::GYRO_0_A);
+      cmdSeq(helper.gyro1L3gIdSideA, helper.gyro1SideAMode, ModeTableIdx::GYRO_1_A);
+      cmdSeq(helper.mgm0Lis3IdSideA, helper.mgm0SideAMode, ModeTableIdx::MGM_0_A);
+      cmdSeq(helper.mgm1Rm3100IdSideA, helper.mgm1SideAMode, ModeTableIdx::MGM_1_A);
+      if (gpsUsable) {
+        gpioHandler(gpioIds::GNSS_0_NRESET, true,
+                    "AcsBoardAssembly::handleNormalOrOnModeCmd: Could not pull nReset pin"
+                    "of GNSS 0 high (used GNSS)");
+        gpioHandler(gpioIds::GNSS_1_NRESET, false,
+                    "AcsBoardAssembly::handleNormalOrOnModeCmd: Could not pull nReset pin"
+                    "of GNSS 1 low (unused GNSS)");
+        gpioHandler(gpioIds::GNSS_SELECT, false,
+                    "AcsBoardAssembly::handleNormalOrOnModeCmd: Could not pull GNSS select low");
+      }
+      break;
+    }
+    case (B_SIDE): {
+      modeTable[ModeTableIdx::GYRO_0_A].setMode(MODE_OFF);
+      modeTable[ModeTableIdx::GYRO_0_A].setSubmode(SUBMODE_NONE);
+      modeTable[ModeTableIdx::GYRO_1_A].setMode(MODE_OFF);
+      modeTable[ModeTableIdx::GYRO_1_A].setSubmode(SUBMODE_NONE);
+      modeTable[ModeTableIdx::MGM_0_A].setMode(MODE_OFF);
+      modeTable[ModeTableIdx::MGM_0_A].setSubmode(SUBMODE_NONE);
+      modeTable[ModeTableIdx::MGM_1_A].setMode(MODE_OFF);
+      modeTable[ModeTableIdx::MGM_1_A].setSubmode(SUBMODE_NONE);
+      cmdSeq(helper.gyro2AdisIdSideB, helper.gyro2SideBMode, ModeTableIdx::GYRO_2_B);
+      cmdSeq(helper.gyro3L3gIdSideB, helper.gyro3SideBMode, ModeTableIdx::GYRO_3_B);
+      cmdSeq(helper.mgm2Lis3IdSideB, helper.mgm2SideBMode, ModeTableIdx::MGM_2_B);
+      cmdSeq(helper.mgm3Rm3100IdSideB, helper.mgm3SideBMode, ModeTableIdx::MGM_3_B);
+      if (gpsUsable) {
+        gpioHandler(gpioIds::GNSS_0_NRESET, false,
+                    "AcsBoardAssembly::handleNormalOrOnModeCmd: Could not pull nReset pin"
+                    "of GNSS 0 low (unused GNSS)");
+        gpioHandler(gpioIds::GNSS_1_NRESET, true,
+                    "AcsBoardAssembly::handleNormalOrOnModeCmd: Could not pull nReset pin"
+                    "of GNSS 1 high (used GNSS)");
+        gpioHandler(gpioIds::GNSS_SELECT, true,
+                    "AcsBoardAssembly::handleNormalOrOnModeCmd: Could not pull GNSS select high");
+      }
+      break;
+    }
+    case (DUAL_MODE): {
+      cmdSeq(helper.gpsId, helper.gpsMode, ModeTableIdx::GPS);
+      cmdSeq(helper.gyro0AdisIdSideA, helper.gyro0SideAMode, ModeTableIdx::GYRO_0_A);
+      cmdSeq(helper.gyro1L3gIdSideA, helper.gyro1SideAMode, ModeTableIdx::GYRO_1_A);
+      cmdSeq(helper.mgm0Lis3IdSideA, helper.mgm0SideAMode, ModeTableIdx::MGM_0_A);
+      cmdSeq(helper.mgm1Rm3100IdSideA, helper.mgm1SideAMode, ModeTableIdx::MGM_1_A);
+      cmdSeq(helper.gyro2AdisIdSideB, helper.gyro2SideBMode, ModeTableIdx::GYRO_2_B);
+      cmdSeq(helper.gyro3L3gIdSideB, helper.gyro3SideBMode, ModeTableIdx::GYRO_3_B);
+      cmdSeq(helper.mgm2Lis3IdSideB, helper.mgm2SideBMode, ModeTableIdx::MGM_2_B);
+      cmdSeq(helper.mgm3Rm3100IdSideB, helper.mgm3SideBMode, ModeTableIdx::MGM_3_B);
+      ReturnValue_t status = RETURN_OK;
+      if (gpsUsable) {
+        gpioHandler(gpioIds::GNSS_0_NRESET, true,
+                    "AcsBoardAssembly::handleNormalOrOnModeCmd: Could not pull nReset pin"
+                    "of GNSS 0 high (used GNSS)");
+        gpioHandler(gpioIds::GNSS_1_NRESET, true,
+                    "AcsBoardAssembly::handleNormalOrOnModeCmd: Could not pull nReset pin"
+                    "of GNSS 1 high (used GNSS)");
+        if (defaultSubmode == Submodes::A_SIDE) {
+          status = gpioIF->pullLow(gpioIds::GNSS_SELECT);
+        } else {
+          status = gpioIF->pullHigh(gpioIds::GNSS_SELECT);
+        }
+        if (status != HasReturnvaluesIF::RETURN_OK) {
+#if OBSW_VERBOSE_LEVEL >= 1
+          sif::error << "AcsBoardAssembly::handleNormalOrOnModeCmd: Could not pull GNSS select to"
+                        "default side for dual mode"
+                     << std::endl;
+#endif
+        }
+      }
+      break;
+    }
+    default: {
+      sif::error << "AcsBoardAssembly::handleNormalModeCmd: Unknown submode" << std::endl;
+    }
+  }
+  if (gpsUsable) {
+    modeTable[ModeTableIdx::GPS].setMode(MODE_ON);
+    modeTable[ModeTableIdx::GPS].setSubmode(SUBMODE_NONE);
+  }
+  if (needsSecondStep) {
+    result = NEED_SECOND_STEP;
+  }
+  return result;
+}
+
+void AcsBoardAssembly::selectGpsInDualMode(duallane::Submodes side) {
+  using namespace duallane;
+  if (submode != Submodes::DUAL_MODE) {
+    return;
+  }
+  ReturnValue_t result = RETURN_OK;
+  if (side == Submodes::A_SIDE) {
+    result = gpioIF->pullLow(gpioIds::GNSS_SELECT);
+  } else {
+    result = gpioIF->pullHigh(gpioIds::GNSS_SELECT);
+  }
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+#if OBSW_VERBOSE_LEVEL >= 1
+    sif::error << "AcsBoardAssembly::switchGpsInDualMode: Switching GPS failed" << std::endl;
+#endif
+  }
+}
+
+void AcsBoardAssembly::gpioHandler(gpioId_t gpio, bool high, std::string error) {
+  ReturnValue_t result = RETURN_OK;
+  if (high) {
+    result = gpioIF->pullHigh(gpio);
+  } else {
+    result = gpioIF->pullLow(gpio);
+  }
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+#if OBSW_VERBOSE_LEVEL >= 1
+    sif::error << error << std::endl;
+#endif
+  }
+}
+
+void AcsBoardAssembly::refreshHelperModes() {
+  try {
+    helper.gyro0SideAMode = childrenMap.at(helper.gyro0AdisIdSideA).mode;
+    helper.gyro1SideAMode = childrenMap.at(helper.gyro1L3gIdSideA).mode;
+    helper.gyro2SideBMode = childrenMap.at(helper.gyro2AdisIdSideB).mode;
+    helper.gyro3SideBMode = childrenMap.at(helper.gyro2AdisIdSideB).mode;
+    helper.mgm0SideAMode = childrenMap.at(helper.mgm0Lis3IdSideA).mode;
+    helper.mgm1SideAMode = childrenMap.at(helper.mgm1Rm3100IdSideA).mode;
+    helper.mgm2SideBMode = childrenMap.at(helper.mgm2Lis3IdSideB).mode;
+    helper.mgm3SideBMode = childrenMap.at(helper.mgm3Rm3100IdSideB).mode;
+    helper.gpsMode = childrenMap.at(helper.gpsId).mode;
+  } catch (const std::out_of_range& e) {
+    sif::error << "AcsBoardAssembly::refreshHelperModes: Invalid map: " << e.what() << std::endl;
+  }
+}
+
+ReturnValue_t AcsBoardAssembly::initialize() {
+  ReturnValue_t result = registerChild(helper.gyro0AdisIdSideA);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  result = registerChild(helper.gyro1L3gIdSideA);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  result = registerChild(helper.gyro2AdisIdSideB);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  result = registerChild(helper.gyro3L3gIdSideB);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  result = registerChild(helper.mgm0Lis3IdSideA);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  result = registerChild(helper.mgm1Rm3100IdSideA);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  result = registerChild(helper.mgm2Lis3IdSideB);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  result = registerChild(helper.mgm3Rm3100IdSideB);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  result = registerChild(helper.gpsId);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  return AssemblyBase::initialize();
+}

mission/system/objects/AcsBoardAssembly.h

@@ -0,0 +1,129 @@
+#ifndef MISSION_SYSTEM_ACSBOARDASSEMBLY_H_
+#define MISSION_SYSTEM_ACSBOARDASSEMBLY_H_
+
+#include <common/config/commonSubsystemIds.h>
+#include <devices/powerSwitcherList.h>
+#include <fsfw/objectmanager/frameworkObjects.h>
+#include <fsfw_hal/common/gpio/gpioDefinitions.h>
+
+#include "DualLaneAssemblyBase.h"
+#include "DualLanePowerStateMachine.h"
+
+struct AcsBoardHelper {
+  AcsBoardHelper(object_id_t mgm0Id, object_id_t mgm1Id, object_id_t mgm2Id, object_id_t mgm3Id,
+                 object_id_t gyro0Id, object_id_t gyro1Id, object_id_t gyro2Id, object_id_t gyro3Id,
+                 object_id_t gpsId)
+      : mgm0Lis3IdSideA(mgm0Id),
+        mgm1Rm3100IdSideA(mgm1Id),
+        mgm2Lis3IdSideB(mgm2Id),
+        mgm3Rm3100IdSideB(mgm3Id),
+        gyro0AdisIdSideA(gyro0Id),
+        gyro1L3gIdSideA(gyro1Id),
+        gyro2AdisIdSideB(gyro2Id),
+        gyro3L3gIdSideB(gyro3Id),
+        gpsId(gpsId) {}
+
+  object_id_t mgm0Lis3IdSideA = objects::NO_OBJECT;
+  object_id_t mgm1Rm3100IdSideA = objects::NO_OBJECT;
+  object_id_t mgm2Lis3IdSideB = objects::NO_OBJECT;
+  object_id_t mgm3Rm3100IdSideB = objects::NO_OBJECT;
+
+  object_id_t gyro0AdisIdSideA = objects::NO_OBJECT;
+  object_id_t gyro1L3gIdSideA = objects::NO_OBJECT;
+  object_id_t gyro2AdisIdSideB = objects::NO_OBJECT;
+  object_id_t gyro3L3gIdSideB = objects::NO_OBJECT;
+
+  object_id_t gpsId = objects::NO_OBJECT;
+
+  Mode_t gyro0SideAMode = HasModesIF::MODE_OFF;
+  Mode_t gyro1SideAMode = HasModesIF::MODE_OFF;
+  Mode_t gyro2SideBMode = HasModesIF::MODE_OFF;
+  Mode_t gyro3SideBMode = HasModesIF::MODE_OFF;
+  Mode_t mgm0SideAMode = HasModesIF::MODE_OFF;
+  Mode_t mgm1SideAMode = HasModesIF::MODE_OFF;
+  Mode_t mgm2SideBMode = HasModesIF::MODE_OFF;
+  Mode_t mgm3SideBMode = HasModesIF::MODE_OFF;
+  Mode_t gpsMode = HasModesIF::MODE_OFF;
+};
+
+enum ModeTableIdx : uint8_t {
+  MGM_0_A = 0,
+  MGM_1_A = 1,
+  MGM_2_B = 2,
+  MGM_3_B = 3,
+  GYRO_0_A = 4,
+  GYRO_1_A = 5,
+  GYRO_2_B = 6,
+  GYRO_3_B = 7,
+  GPS = 8
+};
+
+class PowerSwitchIF;
+class GpioIF;
+
+/**
+ * @brief  Assembly class which manages redundant ACS board sides
+ * @details
+ * This class takes care of ensuring that enough devices on the ACS board are available at all
+ * times. It does so by doing autonomous transitions to the redundant side or activating both sides
+ * if not enough devices are available.
+ *
+ * This class also takes care of switching on the A side and/or B side power lanes. Normally,
+ * doing this task would be performed by the device handlers, but this is not possible for the
+ * ACS board where multiple sensors share the same power supply.
+ */
+class AcsBoardAssembly : public DualLaneAssemblyBase {
+ public:
+  // Use these variables instead of magic numbers when generator was updated
+  // TRANSITION_OTHER_SIDE_FAILED_ID
+  // NOT_ENOUGH_DEVICES_DUAL_MODE_ID
+  // POWER_STATE_MACHINE_TIMEOUT_ID
+  // SIDE_SWITCH_TRANSITION_NOT_ALLOWED_ID
+  static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::ACS_BOARD_ASS;
+  static constexpr Event TRANSITION_OTHER_SIDE_FAILED =
+      event::makeEvent(SUBSYSTEM_ID, 0, severity::HIGH);
+  static constexpr Event NOT_ENOUGH_DEVICES_DUAL_MODE =
+      event::makeEvent(SUBSYSTEM_ID, 1, severity::HIGH);
+  static constexpr Event POWER_STATE_MACHINE_TIMEOUT =
+      event::makeEvent(SUBSYSTEM_ID, 2, severity::MEDIUM);
+  //! [EXPORT] : [COMMENT] Not implemented, would increase already high complexity. Operator
+  //! should instead command the assembly off first and then command the assembly on into the
+  //! desired mode/submode combination
+  static constexpr Event SIDE_SWITCH_TRANSITION_NOT_ALLOWED =
+      event::makeEvent(SUBSYSTEM_ID, 3, severity::LOW);
+
+  static constexpr uint8_t NUMBER_DEVICES_MODE_TABLE = 9;
+
+  AcsBoardAssembly(object_id_t objectId, object_id_t parentId, PowerSwitchIF* pwrSwitcher,
+                   AcsBoardHelper helper, GpioIF* gpioIF);
+
+  /**
+   * In dual mode, the A side or the B side GPS device can be used, but not both.
+   * This function can be used to switch the used GPS device.
+   * @param side
+   */
+  void selectGpsInDualMode(duallane::Submodes side);
+
+ private:
+  static constexpr pcdu::Switches SWITCH_A = pcdu::Switches::PDU1_CH7_ACS_A_SIDE_3V3;
+  static constexpr pcdu::Switches SWITCH_B = pcdu::Switches::PDU2_CH7_ACS_BOARD_SIDE_B_3V3;
+
+  bool tryingOtherSide = false;
+  bool dualModeErrorSwitch = true;
+  AcsBoardHelper helper;
+  GpioIF* gpioIF = nullptr;
+
+  FixedArrayList<ModeListEntry, NUMBER_DEVICES_MODE_TABLE> modeTable;
+  void gpioHandler(gpioId_t gpio, bool high, std::string error);
+
+  ReturnValue_t initialize() override;
+
+  // AssemblyBase overrides
+  ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) override;
+  ReturnValue_t checkChildrenStateOn(Mode_t wantedMode, Submode_t wantedSubmode) override;
+
+  ReturnValue_t handleNormalOrOnModeCmd(Mode_t mode, Submode_t submode);
+  void refreshHelperModes();
+};
+
+#endif /* MISSION_SYSTEM_ACSBOARDASSEMBLY_H_ */

mission/system/objects/AcsBoardFdir.cpp

@@ -0,0 +1,6 @@
+#include "AcsBoardFdir.h"
+
+#include <common/config/commonObjects.h>
+
+AcsBoardFdir::AcsBoardFdir(object_id_t sensorId)
+    : DeviceHandlerFailureIsolation(sensorId, objects::ACS_BOARD_ASS) {}

mission/system/objects/AcsBoardFdir.h

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

mission/system/objects/AcsSubsystem.cpp

@@ -0,0 +1,5 @@
+#include "AcsSubsystem.h"
+
+AcsSubsystem::AcsSubsystem(object_id_t setObjectId, object_id_t parent,
+                           uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables)
+    : Subsystem(setObjectId, parent, maxNumberOfSequences, maxNumberOfTables) {}

mission/system/objects/AcsSubsystem.h

@@ -0,0 +1,14 @@
+#ifndef MISSION_SYSTEM_ACSSUBSYSTEM_H_
+#define MISSION_SYSTEM_ACSSUBSYSTEM_H_
+
+#include <fsfw/subsystem/Subsystem.h>
+
+class AcsSubsystem : public Subsystem {
+ public:
+  AcsSubsystem(object_id_t setObjectId, object_id_t parent, uint32_t maxNumberOfSequences,
+               uint32_t maxNumberOfTables);
+
+ private:
+};
+
+#endif /* MISSION_SYSTEM_ACSSUBSYSTEM_H_ */

mission/system/objects/CMakeLists.txt

@@ -0,0 +1,17 @@
+target_sources(${LIB_EIVE_MISSION} PRIVATE
+    EiveSystem.cpp
+    AcsSubsystem.cpp
+    ComSubsystem.cpp
+    PayloadSubsystem.cpp
+
+    AcsBoardAssembly.cpp
+    SusAssembly.cpp
+    DualLanePowerStateMachine.cpp
+    PowerStateMachineBase.cpp
+    DualLaneAssemblyBase.cpp
+    TcsBoardAssembly.cpp
+
+    AcsBoardFdir.cpp
+    SusFdir.cpp
+    RtdFdir.cpp
+)

mission/system/objects/ComSubsystem.cpp

@@ -0,0 +1,5 @@
+#include "ComSubsystem.h"
+
+ComSubsystem::ComSubsystem(object_id_t setObjectId, object_id_t parent,
+                           uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables)
+    : Subsystem(setObjectId, parent, maxNumberOfSequences, maxNumberOfTables) {}

mission/system/objects/ComSubsystem.h

@@ -0,0 +1,14 @@
+#ifndef MISSION_SYSTEM_COMSUBSYSTEM_H_
+#define MISSION_SYSTEM_COMSUBSYSTEM_H_
+
+#include <fsfw/subsystem/Subsystem.h>
+
+class ComSubsystem : public Subsystem {
+ public:
+  ComSubsystem(object_id_t setObjectId, object_id_t parent, uint32_t maxNumberOfSequences,
+               uint32_t maxNumberOfTables);
+
+ private:
+};
+
+#endif /* MISSION_SYSTEM_COMSUBSYSTEM_H_ */

mission/system/objects/DualLaneAssemblyBase.cpp

@@ -0,0 +1,238 @@
+#include "DualLaneAssemblyBase.h"
+
+#include <fsfw/ipc/QueueFactory.h>
+
+#include "OBSWConfig.h"
+
+DualLaneAssemblyBase::DualLaneAssemblyBase(object_id_t objectId, object_id_t parentId,
+                                           PowerSwitchIF* pwrSwitcher, pcdu::Switches switch1,
+                                           pcdu::Switches switch2, Event pwrTimeoutEvent,
+                                           Event sideSwitchNotAllowedEvent,
+                                           Event transitionOtherSideFailedEvent)
+    : AssemblyBase(objectId, parentId, 20),
+      pwrStateMachine(switch1, switch2, pwrSwitcher),
+      pwrTimeoutEvent(pwrTimeoutEvent),
+      sideSwitchNotAllowedEvent(sideSwitchNotAllowedEvent),
+      transitionOtherSideFailedEvent(transitionOtherSideFailedEvent) {
+  eventQueue = QueueFactory::instance()->createMessageQueue(10);
+}
+
+void DualLaneAssemblyBase::performChildOperation() {
+  using namespace duallane;
+  if (pwrStateMachine.active()) {
+    pwrStateMachineWrapper();
+  }
+  // Only perform the regular child operation if the power state machine is not active.
+  // It does not make any sense to command device modes while the power switcher is busy
+  // switching off or on devices.
+  if (not pwrStateMachine.active()) {
+    AssemblyBase::performChildOperation();
+    // TODO: Handle Event Queue
+  }
+}
+
+void DualLaneAssemblyBase::startTransition(Mode_t mode, Submode_t submode) {
+  // doStartTransition(mode, submode);
+  using namespace duallane;
+  pwrStateMachine.reset();
+  if (mode != MODE_OFF) {
+    // If anything other than MODE_OFF is commanded, perform power state machine first
+    // Cache the target modes, required by power state machine
+    pwrStateMachine.start(mode, submode);
+    // Cache these for later after the power state machine has finished
+    targetMode = mode;
+    targetSubmode = submode;
+  } else {
+    AssemblyBase::startTransition(mode, submode);
+  }
+}
+
+bool DualLaneAssemblyBase::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;
+}
+
+ReturnValue_t DualLaneAssemblyBase::pwrStateMachineWrapper() {
+  using namespace power;
+  OpCodes opCode = pwrStateMachine.fsm();
+  if (customRecoveryStates == RecoveryCustomStates::IDLE) {
+    if (opCode == OpCodes::NONE) {
+      return RETURN_OK;
+    } else if (opCode == OpCodes::TO_OFF_DONE) {
+      // Will be called for transitions to MODE_OFF, where everything is done after power switching
+      finishModeOp();
+    } else if (opCode == OpCodes::TO_NOT_OFF_DONE) {
+      // Will be called for transitions from MODE_OFF to anything else, where the mode still has
+      // to be commanded after power switching
+      AssemblyBase::startTransition(targetMode, targetSubmode);
+    } else if (opCode == OpCodes::TIMEOUT_OCCURED) {
+      if (powerRetryCounter == 0) {
+        powerRetryCounter++;
+        pwrStateMachine.reset();
+      } else {
+#if OBSW_VERBOSE_LEVEL >= 1
+        sif::warning << "Timeout occured in power state machine" << std::endl;
+#endif
+        triggerEvent(pwrTimeoutEvent, 0, 0);
+        return RETURN_FAILED;
+      }
+    }
+  }
+  return RETURN_OK;
+}
+
+ReturnValue_t DualLaneAssemblyBase::isModeCombinationValid(Mode_t mode, Submode_t submode) {
+  using namespace duallane;
+  if (submode != A_SIDE and submode != B_SIDE and submode != DUAL_MODE) {
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  if (sideSwitchTransition(mode, submode)) {
+    // I could implement this but this would increase the already high complexity. This is not
+    // necessary. The operator should can send a command to switch the assembly off first and
+    // then send a command to turn on the other side, either to ON or to NORMAL
+    triggerEvent(SIDE_SWITCH_TRANSITION_NOT_ALLOWED_ID, 0, 0);
+    return TRANS_NOT_ALLOWED;
+  }
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+void DualLaneAssemblyBase::handleModeReached() {
+  using namespace duallane;
+  if (targetMode == MODE_OFF) {
+    pwrStateMachine.start(targetMode, targetSubmode);
+    // Now we can switch off the power. After that, the AssemblyBase::handleModeReached function
+    // will be called
+    pwrStateMachineWrapper();
+  } else {
+    finishModeOp();
+  }
+}
+
+MessageQueueId_t DualLaneAssemblyBase::getEventReceptionQueue() { return eventQueue->getId(); }
+
+void DualLaneAssemblyBase::handleChildrenLostMode(ReturnValue_t result) {
+  using namespace duallane;
+  // Some ACS board components are required for Safe-Mode. It would be good if the software
+  // transitions from A side to B side and from B side to dual mode autonomously
+  // to ensure that that enough sensors are available without an operators intervention.
+  // Therefore, the lost mode handler was overwritten to start these transitions
+  Submode_t nextSubmode = Submodes::A_SIDE;
+  if (submode == Submodes::A_SIDE) {
+    nextSubmode = Submodes::B_SIDE;
+  }
+  if (not tryingOtherSide) {
+    triggerEvent(CANT_KEEP_MODE, mode, submode);
+    startTransition(mode, nextSubmode);
+    tryingOtherSide = true;
+  } else {
+    // Not sure when this would happen. This flag is reset if the mode was reached. If it
+    // was not reached, the transition failure handler should be called.
+    sif::error << "DualLaneAssemblyBase::handleChildrenLostMode: Wrong handler called" << std::endl;
+    triggerEvent(transitionOtherSideFailedEvent, mode, targetSubmode);
+    startTransition(mode, Submodes::DUAL_MODE);
+  }
+}
+
+void DualLaneAssemblyBase::handleModeTransitionFailed(ReturnValue_t result) {
+  using namespace duallane;
+  Submode_t nextSubmode = Submodes::A_SIDE;
+  if (submode == Submodes::A_SIDE) {
+    nextSubmode = Submodes::B_SIDE;
+  }
+  // Check whether the transition was started because the mode could not be kept (not commanded).
+  // If this is not the case, start transition to other side. If it is the case, start
+  // transition to dual mode.
+  if (not tryingOtherSide) {
+    triggerEvent(CANT_KEEP_MODE, mode, submode);
+    startTransition(mode, nextSubmode);
+    tryingOtherSide = true;
+  } else {
+    triggerEvent(transitionOtherSideFailedEvent, mode, targetSubmode);
+    startTransition(mode, Submodes::DUAL_MODE);
+  }
+}
+
+bool DualLaneAssemblyBase::checkAndHandleRecovery() {
+  using namespace power;
+  OpCodes opCode = OpCodes::NONE;
+  if (recoveryState == RECOVERY_IDLE) {
+    return AssemblyBase::checkAndHandleRecovery();
+  }
+  if (customRecoveryStates == IDLE) {
+    pwrStateMachine.start(MODE_OFF, 0);
+    customRecoveryStates = RecoveryCustomStates::POWER_SWITCHING_OFF;
+  }
+  if (customRecoveryStates == POWER_SWITCHING_OFF) {
+    opCode = pwrStateMachine.fsm();
+    if (opCode == OpCodes::TO_OFF_DONE or opCode == OpCodes::TIMEOUT_OCCURED) {
+      customRecoveryStates = RecoveryCustomStates::POWER_SWITCHING_ON;
+      pwrStateMachine.start(targetMode, targetSubmode);
+    }
+  }
+  if (customRecoveryStates == POWER_SWITCHING_ON) {
+    opCode = pwrStateMachine.fsm();
+    if (opCode == OpCodes::TO_NOT_OFF_DONE or opCode == OpCodes::TIMEOUT_OCCURED) {
+      customRecoveryStates = RecoveryCustomStates::DONE;
+    }
+  }
+  if (customRecoveryStates == DONE) {
+    bool pendingRecovery = AssemblyBase::checkAndHandleRecovery();
+    if (not pendingRecovery) {
+      pwrStateMachine.reset();
+      customRecoveryStates = RecoveryCustomStates::IDLE;
+    }
+    // For a recovery on one side, only do the recovery once
+    for (auto& child : childrenMap) {
+      if (healthHelper.healthTable->getHealth(child.first) == HasHealthIF::NEEDS_RECOVERY) {
+        sendHealthCommand(child.second.commandQueue, HEALTHY);
+        child.second.healthChanged = false;
+      }
+    }
+    return pendingRecovery;
+  }
+  return true;
+}
+
+bool DualLaneAssemblyBase::sideSwitchTransition(Mode_t mode, Submode_t submode) {
+  using namespace duallane;
+  if (this->mode == MODE_OFF) {
+    return false;
+  }
+  if (this->mode == MODE_ON or this->mode == DeviceHandlerIF::MODE_NORMAL) {
+    if (this->submode == Submodes::A_SIDE and submode == Submodes::B_SIDE) {
+      return true;
+    } else if (this->submode == Submodes::B_SIDE and submode == Submodes::A_SIDE) {
+      return true;
+    }
+    return false;
+  }
+  return false;
+}
+
+void DualLaneAssemblyBase::finishModeOp() {
+  using namespace duallane;
+  AssemblyBase::handleModeReached();
+  pwrStateMachine.reset();
+  powerRetryCounter = 0;
+  tryingOtherSide = false;
+  dualModeErrorSwitch = true;
+}
+
+void DualLaneAssemblyBase::setPreferredSide(duallane::Submodes submode) {
+  using namespace duallane;
+  if (submode != Submodes::A_SIDE and submode != Submodes::B_SIDE) {
+    return;
+  }
+  this->defaultSubmode = submode;
+}

mission/system/objects/DualLaneAssemblyBase.h

@@ -0,0 +1,102 @@
+#ifndef MISSION_SYSTEM_DUALLANEASSEMBLYBASE_H_
+#define MISSION_SYSTEM_DUALLANEASSEMBLYBASE_H_
+
+#include <fsfw/devicehandlers/AssemblyBase.h>
+#include <mission/system/objects/DualLanePowerStateMachine.h>
+
+/**
+ * @brief   Encapsulates assemblies which are also responsible for dual lane power switching
+ * @details
+ * This is the base class for both the ACS board and the SUS board. Both boards have redundant
+ * power lanes and are required for the majority of satellite modes. Therefore, there is a lot
+ * of common code, for example the power switching.
+ */
+class DualLaneAssemblyBase : public AssemblyBase, public ConfirmsFailuresIF {
+ public:
+  static constexpr UniqueEventId_t TRANSITION_OTHER_SIDE_FAILED_ID = 0;
+  static constexpr UniqueEventId_t NOT_ENOUGH_DEVICES_DUAL_MODE_ID = 1;
+  static constexpr UniqueEventId_t POWER_STATE_MACHINE_TIMEOUT_ID = 2;
+  static constexpr UniqueEventId_t SIDE_SWITCH_TRANSITION_NOT_ALLOWED_ID = 3;
+
+  DualLaneAssemblyBase(object_id_t objectId, object_id_t parentId, PowerSwitchIF* pwrSwitcher,
+                       pcdu::Switches switch1, pcdu::Switches switch2, Event pwrSwitchTimeoutEvent,
+                       Event sideSwitchNotAllowedEvent, Event transitionOtherSideFailedEvent);
+
+ protected:
+  // This helper object complete encapsulates power switching
+  DualLanePowerStateMachine pwrStateMachine;
+  Event pwrTimeoutEvent;
+  Event sideSwitchNotAllowedEvent;
+  Event transitionOtherSideFailedEvent;
+  uint8_t powerRetryCounter = 0;
+  bool tryingOtherSide = false;
+  bool dualModeErrorSwitch = true;
+  duallane::Submodes defaultSubmode = duallane::Submodes::A_SIDE;
+
+  enum RecoveryCustomStates {
+    IDLE,
+    POWER_SWITCHING_OFF,
+    POWER_SWITCHING_ON,
+    DONE
+  } customRecoveryStates = RecoveryCustomStates::IDLE;
+
+  MessageQueueIF* eventQueue = nullptr;
+
+  /**
+   * 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);
+
+  /**
+   * Thin wrapper function which is required because the helper class
+   * can not access protected member functions.
+   * @param mode
+   * @param submode
+   */
+  virtual ReturnValue_t pwrStateMachineWrapper();
+  virtual ReturnValue_t isModeCombinationValid(Mode_t mode, Submode_t submode) override;
+  /**
+   * Custom recovery implementation to ensure that the power lines are commanded off for a
+   * recovery.
+   * @return
+   */
+  virtual bool checkAndHandleRecovery() override;
+  void setPreferredSide(duallane::Submodes submode);
+  virtual void performChildOperation() override;
+  virtual void startTransition(Mode_t mode, Submode_t submode) override;
+  virtual void handleChildrenLostMode(ReturnValue_t result) override;
+  virtual void handleModeTransitionFailed(ReturnValue_t result) override;
+  virtual void handleModeReached() override;
+
+  MessageQueueId_t getEventReceptionQueue() override;
+
+  bool sideSwitchTransition(Mode_t mode, Submode_t submode);
+
+  /**
+   * Implemented by user. Will be called if a full mode operation has finished.
+   * This includes both the regular mode state machine operations and the power state machine
+   * operations
+   */
+  virtual void finishModeOp();
+
+  template <size_t MAX_SIZE>
+  void initModeTableEntry(object_id_t id, ModeListEntry& entry,
+                          FixedArrayList<ModeListEntry, MAX_SIZE>& modeTable);
+
+ private:
+};
+
+template <size_t MAX_SIZE>
+inline void DualLaneAssemblyBase::initModeTableEntry(
+    object_id_t id, ModeListEntry& entry, FixedArrayList<ModeListEntry, MAX_SIZE>& modeTable) {
+  entry.setObject(id);
+  entry.setMode(MODE_OFF);
+  entry.setSubmode(SUBMODE_NONE);
+  entry.setInheritSubmode(false);
+  modeTable.insert(entry);
+}
+
+#endif /* MISSION_SYSTEM_DUALLANEASSEMBLYBASE_H_ */

mission/system/objects/DualLanePowerStateMachine.cpp

@@ -0,0 +1,111 @@
+#include "DualLanePowerStateMachine.h"
+
+#include <fsfw/devicehandlers/AssemblyBase.h>
+#include <fsfw/power/PowerSwitchIF.h>
+
+DualLanePowerStateMachine::DualLanePowerStateMachine(power::Switch_t switchA,
+                                                     power::Switch_t switchB,
+                                                     PowerSwitchIF* pwrSwitcher,
+                                                     dur_millis_t checkTimeout)
+    : PowerStateMachineBase(pwrSwitcher, checkTimeout), SWITCH_A(switchA), SWITCH_B(switchB) {}
+
+power::OpCodes DualLanePowerStateMachine::fsm() {
+  using namespace duallane;
+  ReturnValue_t switchStateA = RETURN_OK;
+  ReturnValue_t switchStateB = RETURN_OK;
+  if (state == power::States::IDLE or state == power::States::MODE_COMMANDING) {
+    return opResult;
+  }
+  if (state == power::States::SWITCHING_POWER or state == power::States::CHECKING_POWER) {
+    switchStateA = pwrSwitcher->getSwitchState(SWITCH_A);
+    switchStateB = pwrSwitcher->getSwitchState(SWITCH_B);
+  } else {
+    return opResult;
+  }
+  if (targetMode == HasModesIF::MODE_OFF) {
+    if (switchStateA == PowerSwitchIF::SWITCH_OFF and switchStateB == PowerSwitchIF::SWITCH_OFF) {
+      state = power::States::IDLE;
+      opResult = power::OpCodes::TO_OFF_DONE;
+      return opResult;
+    }
+  } else {
+    switch (targetSubmode) {
+      case (A_SIDE): {
+        if (switchStateA == PowerSwitchIF::SWITCH_ON and
+            switchStateB == PowerSwitchIF::SWITCH_OFF) {
+          state = power::States::MODE_COMMANDING;
+          opResult = power::OpCodes::TO_NOT_OFF_DONE;
+          return opResult;
+        }
+        break;
+      }
+      case (B_SIDE): {
+        if (switchStateA == PowerSwitchIF::SWITCH_OFF and
+            switchStateB == PowerSwitchIF::SWITCH_ON) {
+          state = power::States::MODE_COMMANDING;
+          opResult = power::OpCodes::TO_NOT_OFF_DONE;
+          return opResult;
+        }
+        break;
+      }
+      case (DUAL_MODE): {
+        if (switchStateA == PowerSwitchIF::SWITCH_ON and switchStateB == PowerSwitchIF::SWITCH_ON) {
+          state = power::States::MODE_COMMANDING;
+          opResult = power::OpCodes::TO_NOT_OFF_DONE;
+          return opResult;
+        }
+      }
+    }
+  }
+  if (state == power::States::SWITCHING_POWER) {
+    if (targetMode == HasModesIF::MODE_OFF) {
+      if (switchStateA != PowerSwitchIF::SWITCH_OFF) {
+        pwrSwitcher->sendSwitchCommand(SWITCH_A, PowerSwitchIF::SWITCH_OFF);
+      }
+      if (switchStateB != PowerSwitchIF::SWITCH_OFF) {
+        pwrSwitcher->sendSwitchCommand(SWITCH_B, PowerSwitchIF::SWITCH_OFF);
+      }
+      checkTimeout.resetTimer();
+    } else {
+      switch (targetSubmode) {
+        case (A_SIDE): {
+          if (switchStateA != PowerSwitchIF::SWITCH_ON) {
+            pwrSwitcher->sendSwitchCommand(SWITCH_A, PowerSwitchIF::SWITCH_ON);
+          }
+          if (switchStateB != PowerSwitchIF::SWITCH_OFF) {
+            pwrSwitcher->sendSwitchCommand(SWITCH_B, PowerSwitchIF::SWITCH_OFF);
+          }
+          checkTimeout.resetTimer();
+          break;
+        }
+        case (B_SIDE): {
+          if (switchStateA != PowerSwitchIF::SWITCH_OFF) {
+            pwrSwitcher->sendSwitchCommand(SWITCH_A, PowerSwitchIF::SWITCH_OFF);
+          }
+          if (switchStateB != PowerSwitchIF::SWITCH_ON) {
+            pwrSwitcher->sendSwitchCommand(SWITCH_B, PowerSwitchIF::SWITCH_ON);
+          }
+          checkTimeout.resetTimer();
+          break;
+        }
+        case (DUAL_MODE): {
+          if (switchStateA != PowerSwitchIF::SWITCH_ON) {
+            pwrSwitcher->sendSwitchCommand(SWITCH_A, PowerSwitchIF::SWITCH_ON);
+          }
+          if (switchStateB != PowerSwitchIF::SWITCH_ON) {
+            pwrSwitcher->sendSwitchCommand(SWITCH_B, PowerSwitchIF::SWITCH_ON);
+          }
+          checkTimeout.resetTimer();
+          break;
+        }
+      }
+    }
+    state = power::States::CHECKING_POWER;
+  }
+  if (state == power::States::CHECKING_POWER) {
+    if (checkTimeout.hasTimedOut()) {
+      return power::OpCodes::TIMEOUT_OCCURED;
+    }
+  }
+  return opResult;
+}

mission/system/objects/DualLanePowerStateMachine.h

@@ -0,0 +1,25 @@
+#ifndef MISSION_SYSTEM_DUALLANEPOWERSTATEMACHINE_H_
+#define MISSION_SYSTEM_DUALLANEPOWERSTATEMACHINE_H_
+
+#include <devices/powerSwitcherList.h>
+#include <fsfw/modes/HasModesIF.h>
+#include <mission/system/objects/PowerStateMachineBase.h>
+
+#include "definitions.h"
+
+class AssemblyBase;
+class PowerSwitchIF;
+
+class DualLanePowerStateMachine : public PowerStateMachineBase {
+ public:
+  DualLanePowerStateMachine(power::Switch_t switchA, power::Switch_t switchB,
+                            PowerSwitchIF* pwrSwitcher, dur_millis_t checkTimeout = 5000);
+  power::OpCodes fsm() override;
+
+  const power::Switch_t SWITCH_A;
+  const power::Switch_t SWITCH_B;
+
+ private:
+};
+
+#endif /* MISSION_SYSTEM_DUALLANEPOWERSTATEMACHINE_H_ */

mission/system/objects/EiveSystem.cpp

@@ -0,0 +1,5 @@
+#include "EiveSystem.h"
+
+EiveSystem::EiveSystem(object_id_t setObjectId, object_id_t parent, uint32_t maxNumberOfSequences,
+                       uint32_t maxNumberOfTables)
+    : Subsystem(setObjectId, parent, maxNumberOfSequences, maxNumberOfTables) {}

mission/system/objects/EiveSystem.h

@@ -0,0 +1,14 @@
+#ifndef MISSION_SYSTEM_EIVESYSTEM_H_
+#define MISSION_SYSTEM_EIVESYSTEM_H_
+
+#include <fsfw/subsystem/Subsystem.h>
+
+class EiveSystem : public Subsystem {
+ public:
+  EiveSystem(object_id_t setObjectId, object_id_t parent, uint32_t maxNumberOfSequences,
+             uint32_t maxNumberOfTables);
+
+ private:
+};
+
+#endif /* MISSION_SYSTEM_EIVESYSTEM_H_ */

mission/system/objects/PayloadSubsystem.cpp

@@ -0,0 +1,5 @@
+#include "PayloadSubsystem.h"
+
+PayloadSubsystem::PayloadSubsystem(object_id_t setObjectId, object_id_t parent,
+                                   uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables)
+    : Subsystem(setObjectId, parent, maxNumberOfSequences, maxNumberOfTables) {}

mission/system/objects/PayloadSubsystem.h

@@ -0,0 +1,14 @@
+#ifndef MISSION_SYSTEM_PAYLOADSUBSYSTEM_H_
+#define MISSION_SYSTEM_PAYLOADSUBSYSTEM_H_
+
+#include <fsfw/subsystem/Subsystem.h>
+
+class PayloadSubsystem : public Subsystem {
+ public:
+  PayloadSubsystem(object_id_t setObjectId, object_id_t parent, uint32_t maxNumberOfSequences,
+                   uint32_t maxNumberOfTables);
+
+ private:
+};
+
+#endif /* MISSION_SYSTEM_PAYLOADSUBSYSTEM_H_ */

mission/system/objects/PowerStateMachineBase.cpp

@@ -0,0 +1,33 @@
+#include "PowerStateMachineBase.h"
+
+PowerStateMachineBase::PowerStateMachineBase(PowerSwitchIF *pwrSwitcher, dur_millis_t checkTimeout)
+    : pwrSwitcher(pwrSwitcher), checkTimeout(checkTimeout) {}
+
+void PowerStateMachineBase::reset() {
+  state = power::States::IDLE;
+  opResult = power::OpCodes::NONE;
+  targetMode = HasModesIF::MODE_OFF;
+  targetSubmode = 0;
+  checkTimeout.resetTimer();
+}
+
+void PowerStateMachineBase::setCheckTimeout(dur_millis_t timeout) {
+  checkTimeout.setTimeout(timeout);
+}
+
+void PowerStateMachineBase::start(Mode_t mode, Submode_t submode) {
+  reset();
+  checkTimeout.resetTimer();
+  targetMode = mode;
+  targetSubmode = submode;
+  state = power::States::SWITCHING_POWER;
+}
+
+power::States PowerStateMachineBase::getState() const { return state; }
+
+bool PowerStateMachineBase::active() {
+  if (state == power::States::IDLE or state == power::States::MODE_COMMANDING) {
+    return false;
+  }
+  return true;
+}

mission/system/objects/PowerStateMachineBase.h

@@ -0,0 +1,31 @@
+#ifndef MISSION_SYSTEM_POWERSTATEMACHINE_H_
+#define MISSION_SYSTEM_POWERSTATEMACHINE_H_
+
+#include <fsfw/modes/HasModesIF.h>
+#include <fsfw/power/PowerSwitchIF.h>
+#include <fsfw/timemanager/Countdown.h>
+
+#include "definitions.h"
+
+class PowerStateMachineBase : public HasReturnvaluesIF {
+ public:
+  PowerStateMachineBase(PowerSwitchIF* pwrSwitcher, dur_millis_t checkTimeout);
+
+  virtual power::OpCodes fsm() = 0;
+
+  void setCheckTimeout(dur_millis_t timeout);
+  void reset();
+  void start(Mode_t mode, Submode_t submode);
+  bool active();
+  power::States getState() const;
+
+ protected:
+  power::OpCodes opResult = power::OpCodes::NONE;
+  power::States state = power::States::IDLE;
+  PowerSwitchIF* pwrSwitcher = nullptr;
+  Mode_t targetMode = HasModesIF::MODE_OFF;
+  Submode_t targetSubmode = 0;
+  Countdown checkTimeout;
+};
+
+#endif /* MISSION_SYSTEM_POWERSTATEMACHINE_H_ */

mission/system/objects/RtdFdir.cpp

@@ -0,0 +1,6 @@
+#include "RtdFdir.h"
+
+#include <common/config/commonObjects.h>
+
+RtdFdir::RtdFdir(object_id_t sensorId)
+    : DeviceHandlerFailureIsolation(sensorId, objects::TCS_BOARD_ASS) {}

mission/system/objects/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/objects/SusAssembly.cpp

@@ -0,0 +1,155 @@
+#include "SusAssembly.h"
+
+#include <devices/powerSwitcherList.h>
+#include <fsfw/power/PowerSwitchIF.h>
+#include <fsfw/serviceinterface.h>
+
+SusAssembly::SusAssembly(object_id_t objectId, object_id_t parentId, PowerSwitchIF* pwrSwitcher,
+                         SusAssHelper helper)
+    : DualLaneAssemblyBase(objectId, parentId, pwrSwitcher, SWITCH_NOM, SWITCH_RED,
+                           POWER_STATE_MACHINE_TIMEOUT, SIDE_SWITCH_TRANSITION_NOT_ALLOWED,
+                           TRANSITION_OTHER_SIDE_FAILED),
+      helper(helper),
+      pwrSwitcher(pwrSwitcher) {
+  ModeListEntry entry;
+  for (uint8_t idx = 0; idx < NUMBER_SUN_SENSORS; idx++) {
+    initModeTableEntry(helper.susIds[idx], entry, modeTable);
+  }
+}
+
+ReturnValue_t SusAssembly::commandChildren(Mode_t mode, Submode_t submode) {
+  ReturnValue_t result = RETURN_OK;
+  refreshHelperModes();
+  // Initialize the mode table to ensure all devices are in a defined state
+  for (uint8_t idx = 0; idx < NUMBER_SUN_SENSORS; idx++) {
+    modeTable[idx].setMode(MODE_OFF);
+    modeTable[idx].setSubmode(SUBMODE_NONE);
+  }
+  if (recoveryState != RecoveryState::RECOVERY_STARTED) {
+    if (mode == DeviceHandlerIF::MODE_NORMAL or mode == MODE_ON) {
+      result = handleNormalOrOnModeCmd(mode, submode);
+    }
+  }
+
+  HybridIterator<ModeListEntry> tableIter(modeTable.begin(), modeTable.end());
+  executeTable(tableIter);
+  return result;
+}
+
+ReturnValue_t SusAssembly::handleNormalOrOnModeCmd(Mode_t mode, Submode_t submode) {
+  using namespace duallane;
+  ReturnValue_t result = RETURN_OK;
+  bool needsSecondStep = false;
+  auto cmdSeq = [&](object_id_t objectId, Mode_t devMode, uint8_t tableIdx) {
+    if (mode == devMode) {
+      modeTable[tableIdx].setMode(mode);
+    } else if (mode == DeviceHandlerIF::MODE_NORMAL) {
+      if (isUseable(objectId, devMode)) {
+        if (devMode == MODE_ON) {
+          modeTable[tableIdx].setMode(mode);
+          modeTable[tableIdx].setSubmode(SUBMODE_NONE);
+        } else {
+          modeTable[tableIdx].setMode(MODE_ON);
+          modeTable[tableIdx].setSubmode(SUBMODE_NONE);
+          if (internalState != STATE_SECOND_STEP) {
+            needsSecondStep = true;
+          }
+        }
+      }
+    } else if (mode == MODE_ON) {
+      if (isUseable(objectId, devMode)) {
+        modeTable[tableIdx].setMode(MODE_ON);
+        modeTable[tableIdx].setSubmode(SUBMODE_NONE);
+      }
+    }
+  };
+  switch (submode) {
+    case (A_SIDE): {
+      for (uint8_t idx = 0; idx < NUMBER_SUN_SENSORS_ONE_SIDE; idx++) {
+        cmdSeq(helper.susIds[idx], helper.susModes[idx], idx);
+        // Switch off devices on redundant side
+        modeTable[idx + NUMBER_SUN_SENSORS_ONE_SIDE].setMode(MODE_OFF);
+        modeTable[idx + NUMBER_SUN_SENSORS_ONE_SIDE].setSubmode(SUBMODE_NONE);
+      }
+      break;
+    }
+    case (B_SIDE): {
+      for (uint8_t idx = NUMBER_SUN_SENSORS_ONE_SIDE; idx < NUMBER_SUN_SENSORS; idx++) {
+        cmdSeq(helper.susIds[idx], helper.susModes[idx], idx);
+        // Switch devices on nominal side
+        modeTable[idx - NUMBER_SUN_SENSORS_ONE_SIDE].setMode(MODE_OFF);
+        modeTable[idx - NUMBER_SUN_SENSORS_ONE_SIDE].setSubmode(SUBMODE_NONE);
+      }
+      break;
+    }
+    case (DUAL_MODE): {
+      for (uint8_t idx = 0; idx < NUMBER_SUN_SENSORS; idx++) {
+        cmdSeq(helper.susIds[idx], helper.susModes[idx], idx);
+      }
+      break;
+    }
+  }
+  if (needsSecondStep) {
+    result = NEED_SECOND_STEP;
+  }
+  return result;
+}
+
+ReturnValue_t SusAssembly::checkChildrenStateOn(Mode_t wantedMode, Submode_t wantedSubmode) {
+  using namespace duallane;
+  refreshHelperModes();
+  if (wantedSubmode == A_SIDE) {
+    for (uint8_t idx = 0; idx < NUMBER_SUN_SENSORS_ONE_SIDE; idx++) {
+      if (helper.susModes[idx] != wantedMode) {
+        return NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE;
+      }
+    }
+    return RETURN_OK;
+  } else if (wantedSubmode == B_SIDE) {
+    for (uint8_t idx = NUMBER_SUN_SENSORS_ONE_SIDE; idx < NUMBER_SUN_SENSORS; idx++) {
+      if (helper.susModes[idx] != wantedMode) {
+        return NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE;
+      }
+    }
+    return RETURN_OK;
+  } else {
+    // Trigger event if devices are faulty? This is the last fallback mode, returning
+    // a failure here would trigger a transition to MODE_OFF unless handleModeTransitionFailed
+    // is overriden
+    return RETURN_OK;
+  }
+  return RETURN_OK;
+}
+
+ReturnValue_t SusAssembly::initialize() {
+  ReturnValue_t result = RETURN_OK;
+  for (const auto& id : helper.susIds) {
+    result = registerChild(id);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+  }
+  return AssemblyBase::initialize();
+}
+
+bool SusAssembly::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 SusAssembly::refreshHelperModes() {
+  for (uint8_t idx = 0; idx < helper.susModes.size(); idx++) {
+    helper.susModes[idx] = childrenMap[helper.susIds[idx]].mode;
+  }
+}

mission/system/objects/SusAssembly.h

@@ -0,0 +1,72 @@
+#ifndef MISSION_SYSTEM_SUSASSEMBLY_H_
+#define MISSION_SYSTEM_SUSASSEMBLY_H_
+
+#include <devices/powerSwitcherList.h>
+#include <fsfw/devicehandlers/AssemblyBase.h>
+
+#include "DualLaneAssemblyBase.h"
+
+struct SusAssHelper {
+ public:
+  SusAssHelper(std::array<object_id_t, 12> susIds) : susIds(susIds) {}
+  std::array<object_id_t, 12> susIds = {objects::NO_OBJECT};
+  std::array<Mode_t, 12> susModes = {HasModesIF::MODE_OFF};
+};
+
+class PowerSwitchIF;
+
+class SusAssembly : public DualLaneAssemblyBase {
+ public:
+  static constexpr uint8_t NUMBER_SUN_SENSORS_ONE_SIDE = 6;
+  static constexpr uint8_t NUMBER_SUN_SENSORS = 12;
+
+  // Use these variables instead of magic numbers when generator was updated
+  // TRANSITION_OTHER_SIDE_FAILED_ID
+  // NOT_ENOUGH_DEVICES_DUAL_MODE_ID
+  // POWER_STATE_MACHINE_TIMEOUT_ID
+  // SIDE_SWITCH_TRANSITION_NOT_ALLOWED_ID
+  static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SUS_BOARD_ASS;
+  static constexpr Event TRANSITION_OTHER_SIDE_FAILED =
+      event::makeEvent(SUBSYSTEM_ID, 0, severity::HIGH);
+  static constexpr Event NOT_ENOUGH_DEVICES_DUAL_MODE =
+      event::makeEvent(SUBSYSTEM_ID, 1, severity::HIGH);
+  static constexpr Event POWER_STATE_MACHINE_TIMEOUT =
+      event::makeEvent(SUBSYSTEM_ID, 2, severity::MEDIUM);
+  //! [EXPORT] : [COMMENT] Not implemented, would increase already high complexity. Operator
+  //! should instead command the assembly off first and then command the assembly on into the
+  //! desired mode/submode combination
+  static constexpr Event SIDE_SWITCH_TRANSITION_NOT_ALLOWED =
+      event::makeEvent(SUBSYSTEM_ID, 3, severity::LOW);
+
+  SusAssembly(object_id_t objectId, object_id_t parentId, PowerSwitchIF* pwrSwitcher,
+              SusAssHelper helper);
+
+ private:
+  enum class States { IDLE, SWITCHING_POWER, MODE_COMMANDING } state = States::IDLE;
+  static constexpr pcdu::Switches SWITCH_NOM = pcdu::Switches::PDU1_CH4_SUS_NOMINAL_3V3;
+  static constexpr pcdu::Switches SWITCH_RED = pcdu::Switches::PDU2_CH4_SUS_REDUNDANT_3V3;
+  FixedArrayList<ModeListEntry, NUMBER_SUN_SENSORS> modeTable;
+
+  SusAssHelper helper;
+  PowerSwitchIF* pwrSwitcher = nullptr;
+  bool tryingOtherSide = false;
+  bool dualModeErrorSwitch = true;
+  ReturnValue_t initialize() override;
+
+  // AssemblyBase overrides
+  ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) override;
+  ReturnValue_t checkChildrenStateOn(Mode_t wantedMode, Submode_t wantedSubmode) override;
+
+  /**
+   * 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);
+  void powerStateMachine(Mode_t mode, Submode_t submode);
+  ReturnValue_t handleNormalOrOnModeCmd(Mode_t mode, Submode_t submode);
+  void refreshHelperModes();
+};
+
+#endif /* MISSION_SYSTEM_SUSASSEMBLY_H_ */

mission/system/objects/SusFdir.cpp

@@ -0,0 +1,6 @@
+#include "SusFdir.h"
+
+#include <common/config/commonObjects.h>
+
+SusFdir::SusFdir(object_id_t sensorId)
+    : DeviceHandlerFailureIsolation(sensorId, objects::SUS_BOARD_ASS) {}

mission/system/objects/SusFdir.h

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

mission/system/objects/TcsBoardAssembly.cpp

@@ -0,0 +1,206 @@
+#include "TcsBoardAssembly.h"
+
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+#include <fsfw/ipc/QueueFactory.h>
+
+TcsBoardAssembly::TcsBoardAssembly(object_id_t objectId, object_id_t parentId,
+                                   PowerSwitchIF* pwrSwitcher, power::Switch_t theSwitch,
+                                   TcsBoardHelper helper)
+    : AssemblyBase(objectId, parentId, 24), switcher(pwrSwitcher, theSwitch), helper(helper) {
+  eventQueue = QueueFactory::instance()->createMessageQueue(24);
+  ModeListEntry entry;
+  for (uint8_t idx = 0; idx < NUMBER_RTDS; idx++) {
+    entry.setObject(helper.rtdIds[idx]);
+    entry.setMode(MODE_OFF);
+    entry.setSubmode(SUBMODE_NONE);
+    entry.setInheritSubmode(false);
+    modeTable.insert(entry);
+  }
+}
+
+void TcsBoardAssembly::performChildOperation() {
+  auto state = switcher.getState();
+  if (state != PowerSwitcher::WAIT_OFF and state != PowerSwitcher::WAIT_ON) {
+    AssemblyBase::performChildOperation();
+    return;
+  }
+  switcher.doStateMachine();
+  if (state == PowerSwitcher::WAIT_OFF and switcher.getState() == PowerSwitcher::SWITCH_IS_OFF) {
+    // Indicator that a transition to off is finished
+    AssemblyBase::handleModeReached();
+  } else if (state == PowerSwitcher::WAIT_ON and
+             switcher.getState() == PowerSwitcher::SWITCH_IS_ON) {
+    // Indicator that mode commanding can be performed now
+    AssemblyBase::startTransition(targetMode, targetSubmode);
+    // AssemblyBase::performChildOperation();
+  }
+}
+
+ReturnValue_t TcsBoardAssembly::commandChildren(Mode_t mode, Submode_t submode) {
+  ReturnValue_t result = RETURN_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_STARTED) {
+    if (mode == DeviceHandlerIF::MODE_NORMAL or mode == MODE_ON) {
+      result = handleNormalOrOnModeCmd(mode, submode);
+    }
+  }
+  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.rtdIds[idx]).mode != wantedMode) {
+        devsInWrongMode++;
+      }
+    }
+  } catch (const std::out_of_range& e) {
+    sif::error << "TcsBoardAssembly: Invalid children map: " << e.what() << std::endl;
+  }
+  if (devsInWrongMode >= 3) {
+    if (warningSwitch) {
+      sif::warning << "TcsBoardAssembly::checkChildrenStateOn: " << devsInWrongMode << " 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 RETURN_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 RETURN_OK;
+  }
+  return HasModesIF::INVALID_MODE;
+}
+
+ReturnValue_t TcsBoardAssembly::initialize() {
+  ReturnValue_t result = RETURN_OK;
+  for (const auto& obj : helper.rtdIds) {
+    result = registerChild(obj);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+  }
+  return SubsystemBase::initialize();
+}
+
+void TcsBoardAssembly::startTransition(Mode_t mode, Submode_t submode) {
+  if (mode != MODE_OFF) {
+    switcher.turnOn(true);
+    switcher.doStateMachine();
+    if (switcher.getState() == PowerSwitcher::SWITCH_IS_ON) {
+      AssemblyBase::startTransition(mode, submode);
+    } else {
+      // Need to wait with mode commanding until power switcher is done
+      targetMode = mode;
+      targetSubmode = submode;
+    }
+  } else {
+    // Perform regular mode commanding first
+    AssemblyBase::startTransition(mode, submode);
+  }
+}
+
+ReturnValue_t TcsBoardAssembly::handleNormalOrOnModeCmd(Mode_t mode, Submode_t submode) {
+  ReturnValue_t result = RETURN_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.rtdIds[idx]).mode;
+      objId = helper.rtdIds[idx];
+      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;
+}
+
+MessageQueueId_t TcsBoardAssembly::getEventReceptionQueue() { return eventQueue->getId(); }
+
+void TcsBoardAssembly::handleModeReached() {
+  if (targetMode == MODE_OFF) {
+    switcher.turnOff(true);
+    switcher.doStateMachine();
+    // Need to wait with call to AssemblyBase::handleModeReached until power switcher is done
+    if (switcher.getState() == PowerSwitcher::SWITCH_IS_OFF) {
+      AssemblyBase::handleModeReached();
+    }
+  } else {
+    AssemblyBase::handleModeReached();
+  }
+}
+
+void TcsBoardAssembly::handleChildrenLostMode(ReturnValue_t result) {
+  // TODO: Maybe try a reboot once here?
+  triggerEvent(CHILDREN_LOST_MODE, result);
+  return;
+}
+
+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/objects/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>
+
+struct TcsBoardHelper {
+  TcsBoardHelper(std::array<object_id_t, 16> rtdIds) : rtdIds(rtdIds) {}
+
+  std::array<object_id_t, 16> rtdIds = {};
+};
+
+class TcsBoardAssembly : public AssemblyBase, public ConfirmsFailuresIF {
+ 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, object_id_t parentId, PowerSwitchIF* pwrSwitcher,
+                   power::Switch_t switcher, TcsBoardHelper helper);
+
+  ReturnValue_t initialize() override;
+
+  void performChildOperation() override;
+
+ private:
+  static constexpr uint8_t NUMBER_RTDS = 16;
+  PowerSwitcher switcher;
+  bool warningSwitch = true;
+  TcsBoardHelper helper;
+  FixedArrayList<ModeListEntry, NUMBER_RTDS> modeTable;
+  MessageQueueIF* eventQueue = nullptr;
+
+  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);
+
+  // ConfirmFailureIF implementation
+  MessageQueueId_t getEventReceptionQueue() override;
+
+  // 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;
+  void startTransition(Mode_t mode, Submode_t submode) override;
+  void handleModeReached() 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/objects/definitions.h

@@ -0,0 +1,19 @@
+#ifndef MISSION_SYSTEM_DEFINITIONS_H_
+#define MISSION_SYSTEM_DEFINITIONS_H_
+
+#include <fsfw/modes/ModeMessage.h>
+
+namespace power {
+
+enum class States { IDLE, SWITCHING_POWER, CHECKING_POWER, MODE_COMMANDING };
+enum class OpCodes { NONE, TO_OFF_DONE, TO_NOT_OFF_DONE, TIMEOUT_OCCURED };
+
+}  // namespace power
+
+namespace duallane {
+
+enum Submodes : Submode_t { A_SIDE = 0, B_SIDE = 1, DUAL_MODE = 2 };
+
+}  // namespace duallane
+
+#endif /* MISSION_SYSTEM_DEFINITIONS_H_ */