started SUS assembly

fixes for PCDU code and switcher list handling

mission/system/AcsBoardAssembly.cpp

@@ -1,12 +1,11 @@
 #include "AcsBoardAssembly.h"
 
-#include <devices/powerSwitcherList.h>
 #include <fsfw/power/PowerSwitchIF.h>
 #include <fsfw/serviceinterface.h>
 
 AcsBoardAssembly::AcsBoardAssembly(object_id_t objectId, object_id_t parentId,
                                    PowerSwitchIF* switcher, AcsBoardHelper helper)
-    : AssemblyBase(objectId, parentId), switcher(switcher), helper(helper) {
+    : AssemblyBase(objectId, parentId), pwrSwitcher(switcher), helper(helper) {
   if (switcher == nullptr) {
     sif::error << "AcsBoardAssembly::AcsBoardAssembly: Invalid Power Switcher "
                   "IF passed"
@@ -26,34 +25,31 @@ AcsBoardAssembly::AcsBoardAssembly(object_id_t objectId, object_id_t parentId,
 
 ReturnValue_t AcsBoardAssembly::commandChildren(Mode_t mode, Submode_t submode) {
   ReturnValue_t result = RETURN_OK;
-  if (currentMode == mode and submode == currentSubmode) {
-    return result;
-  }
   refreshHelperModes();
-  if (state == States::MODE_COMMANDING) {
-    if (mode == DeviceHandlerIF::MODE_NORMAL or mode == MODE_ON) {
-      powerStateMachine(submode);
+  powerStateMachine(mode, submode);
+  if (mode == DeviceHandlerIF::MODE_NORMAL or mode == MODE_ON) {
+    if (state == States::MODE_COMMANDING) {
       handleNormalOrOnModeCmd(mode, submode);
-    } else {
-      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);
     }
+  } else {
+    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);
   }
 
   HybridIterator<ModeListEntry> tableIter(modeTable.begin(), modeTable.end());
@@ -63,25 +59,25 @@ ReturnValue_t AcsBoardAssembly::commandChildren(Mode_t mode, Submode_t submode)
 
 ReturnValue_t AcsBoardAssembly::checkChildrenStateOn(Mode_t wantedMode, Submode_t wantedSubmode) {
   refreshHelperModes();
-  if(wantedSubmode == A_SIDE) {
-    if((helper.gyro0SideAMode != wantedMode and helper.gyro1SideAMode != wantedMode) or
+  if (wantedSubmode == A_SIDE) {
+    if ((helper.gyro0SideAMode != wantedMode and helper.gyro1SideAMode != wantedMode) or
         (helper.mgm0SideAMode != wantedMode and helper.mgm1SideAMode != wantedMode) or
         helper.gpsMode != wantedMode) {
       return NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE;
     }
     return RETURN_OK;
   } else if (wantedSubmode == B_SIDE) {
-    if((helper.gyro2SideBMode != wantedMode and helper.gyro3SideBMode != wantedMode) or
+    if ((helper.gyro2SideBMode != wantedMode and helper.gyro3SideBMode != wantedMode) or
         (helper.mgm2SideBMode != wantedMode and helper.mgm3SideBMode != wantedMode) or
         helper.gpsMode != wantedMode) {
       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
+  } 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.mgm2SideBMode != wantedMode and helper.mgm3SideBMode != wantedMode) or
         helper.gpsMode != wantedMode) {
       return NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE;
     }
@@ -102,7 +98,7 @@ ReturnValue_t AcsBoardAssembly::handleNormalOrOnModeCmd(Mode_t mode, Submode_t s
   ReturnValue_t result = RETURN_OK;
   Mode_t tgtMode = DeviceHandlerIF::MODE_NORMAL;
   auto cmdSeq = [&](object_id_t objectId, ModeTableIdx tableIdx) {
-    if(tgtMode == DeviceHandlerIF::MODE_NORMAL) {
+    if (tgtMode == DeviceHandlerIF::MODE_NORMAL) {
       if (isUseable(objectId, mode)) {
         if (helper.gyro0SideAMode != MODE_OFF) {
           modeTable[tableIdx].setMode(tgtMode);
@@ -113,7 +109,7 @@ ReturnValue_t AcsBoardAssembly::handleNormalOrOnModeCmd(Mode_t mode, Submode_t s
           modeTable[tableIdx].setSubmode(SUBMODE_NONE);
         }
       }
-    } else if(tgtMode == MODE_ON) {
+    } else if (tgtMode == MODE_ON) {
       if (isUseable(objectId, mode)) {
         modeTable[tableIdx].setMode(MODE_ON);
         modeTable[tableIdx].setSubmode(SUBMODE_NONE);
@@ -172,62 +168,82 @@ ReturnValue_t AcsBoardAssembly::handleNormalOrOnModeCmd(Mode_t mode, Submode_t s
   return result;
 }
 
-void AcsBoardAssembly::powerStateMachine(Submode_t submode) {
-  ReturnValue_t switchStateA = switcher->getSwitchState(pcduSwitches::ACS_BOARD_SIDE_A);
-  ReturnValue_t switchStateB = switcher->getSwitchState(pcduSwitches::ACS_BOARD_SIDE_B);
-  switch (submode) {
-    case (A_SIDE): {
-      if (switchStateA == PowerSwitchIF::SWITCH_ON and switchStateB == PowerSwitchIF::SWITCH_OFF) {
+void AcsBoardAssembly::powerStateMachine(Mode_t mode, Submode_t submode) {
+  ReturnValue_t switchStateA = RETURN_OK;
+  ReturnValue_t switchStateB = RETURN_OK;
+  if (state == States::IDLE or state == States::SWITCHING_POWER) {
+    switchStateA = pwrSwitcher->getSwitchState(SWITCH_A);
+    switchStateB = pwrSwitcher->getSwitchState(SWITCH_B);
+    if (mode == MODE_OFF) {
+      if (switchStateA == PowerSwitchIF::SWITCH_OFF and switchStateB == PowerSwitchIF::SWITCH_OFF) {
         state = States::MODE_COMMANDING;
         return;
       }
-      break;
-    }
-    case (B_SIDE): {
-      if (switchStateA == PowerSwitchIF::SWITCH_OFF and switchStateB == PowerSwitchIF::SWITCH_ON) {
-        state = States::MODE_COMMANDING;
-        return;
-      }
-      break;
-    }
-    case (DUAL_MODE): {
-      if (switchStateA == PowerSwitchIF::SWITCH_ON and switchStateB == PowerSwitchIF::SWITCH_ON) {
-        state = States::MODE_COMMANDING;
-        return;
+    } else {
+      switch (submode) {
+        case (A_SIDE): {
+          if (switchStateA == PowerSwitchIF::SWITCH_ON and
+              switchStateB == PowerSwitchIF::SWITCH_OFF) {
+            state = States::MODE_COMMANDING;
+            return;
+          }
+          break;
+        }
+        case (B_SIDE): {
+          if (switchStateA == PowerSwitchIF::SWITCH_OFF and
+              switchStateB == PowerSwitchIF::SWITCH_ON) {
+            state = States::MODE_COMMANDING;
+            return;
+          }
+          break;
+        }
+        case (DUAL_MODE): {
+          if (switchStateA == PowerSwitchIF::SWITCH_ON and
+              switchStateB == PowerSwitchIF::SWITCH_ON) {
+            state = States::MODE_COMMANDING;
+            return;
+          }
+        }
       }
     }
   }
   if (state == States::IDLE) {
-    switch (submode) {
-      case (A_SIDE): {
-        if (switchStateA != PowerSwitchIF::SWITCH_ON) {
-          // Set A side on first in power switcher IF
-          switcher->sendSwitchCommand(pcduSwitches::ACS_BOARD_SIDE_A, true);
-        }
-        if (switchStateB != PowerSwitchIF::SWITCH_OFF) {
-          switcher->sendSwitchCommand(pcduSwitches::ACS_BOARD_SIDE_B, false);
-        }
-        break;
+    if (mode == MODE_OFF) {
+      if (switchStateA != PowerSwitchIF::SWITCH_OFF) {
+        pwrSwitcher->sendSwitchCommand(SWITCH_A, false);
       }
-      case (B_SIDE): {
-        if (switchStateA != PowerSwitchIF::SWITCH_OFF) {
-          // Set A side on first in power switcher IF
-          switcher->sendSwitchCommand(pcduSwitches::ACS_BOARD_SIDE_A, false);
-        }
-        if (switchStateB != PowerSwitchIF::SWITCH_ON) {
-          switcher->sendSwitchCommand(pcduSwitches::ACS_BOARD_SIDE_B, true);
-        }
-        break;
+      if (switchStateB != PowerSwitchIF::SWITCH_OFF) {
+        pwrSwitcher->sendSwitchCommand(SWITCH_B, false);
       }
-      case (DUAL_MODE): {
-        if (switchStateA != PowerSwitchIF::SWITCH_ON) {
-          // Set A side on first in power switcher IF
-          switcher->sendSwitchCommand(pcduSwitches::ACS_BOARD_SIDE_A, true);
+    } else {
+      switch (submode) {
+        case (A_SIDE): {
+          if (switchStateA != PowerSwitchIF::SWITCH_ON) {
+            pwrSwitcher->sendSwitchCommand(SWITCH_A, true);
+          }
+          if (switchStateB != PowerSwitchIF::SWITCH_OFF) {
+            pwrSwitcher->sendSwitchCommand(SWITCH_B, false);
+          }
+          break;
         }
-        if (switchStateB != PowerSwitchIF::SWITCH_ON) {
-          switcher->sendSwitchCommand(pcduSwitches::ACS_BOARD_SIDE_B, true);
+        case (B_SIDE): {
+          if (switchStateA != PowerSwitchIF::SWITCH_OFF) {
+            pwrSwitcher->sendSwitchCommand(SWITCH_A, false);
+          }
+          if (switchStateB != PowerSwitchIF::SWITCH_ON) {
+            pwrSwitcher->sendSwitchCommand(SWITCH_B, true);
+          }
+          break;
+        }
+        case (DUAL_MODE): {
+          if (switchStateA != PowerSwitchIF::SWITCH_ON) {
+            pwrSwitcher->sendSwitchCommand(SWITCH_A, true);
+          }
+          if (switchStateB != PowerSwitchIF::SWITCH_ON) {
+            pwrSwitcher->sendSwitchCommand(SWITCH_B, true);
+          }
+          break;
         }
-        break;
       }
     }
     state = States::SWITCHING_POWER;
@@ -274,7 +290,7 @@ ReturnValue_t AcsBoardAssembly::initialize() {
 }
 
 ReturnValue_t AcsBoardAssembly::isModeCombinationValid(Mode_t mode, Submode_t submode) {
-  if(submode != A_SIDE and submode != B_SIDE and submode != DUAL_MODE) {
+  if (submode != A_SIDE and submode != B_SIDE and submode != DUAL_MODE) {
     return HasReturnvaluesIF::RETURN_FAILED;
   }
   return HasReturnvaluesIF::RETURN_OK;
@@ -296,6 +312,11 @@ bool AcsBoardAssembly::isUseable(object_id_t object, Mode_t mode) {
   return false;
 }
 
+void AcsBoardAssembly::handleModeReached() {
+  AssemblyBase::handleModeReached();
+  state = States::IDLE;
+}
+
 void AcsBoardAssembly::refreshHelperModes() {
   helper.gyro0SideAMode = childrenMap[helper.gyro0AdisIdSideA].mode;
   helper.gyro1SideAMode = childrenMap[helper.gyro1L3gIdSideA].mode;

mission/system/AcsBoardAssembly.h

@@ -1,6 +1,7 @@
 #ifndef MISSION_SYSTEM_ACSBOARDASSEMBLY_H_
 #define MISSION_SYSTEM_ACSBOARDASSEMBLY_H_
 
+#include <devices/powerSwitcherList.h>
 #include <fsfw/devicehandlers/AssemblyBase.h>
 #include <fsfw/objectmanager/frameworkObjects.h>
 
@@ -52,37 +53,40 @@ enum ModeTableIdx : uint8_t {
   GPS = 8
 };
 
-static constexpr uint8_t NUMBER_DEVICES_MODE_TABLE = 9;
-
 class PowerSwitchIF;
 
 class AcsBoardAssembly : public AssemblyBase {
  public:
-  AcsBoardAssembly(object_id_t objectId, object_id_t parentId, PowerSwitchIF* switcher,
-                   AcsBoardHelper helper);
-
- private:
-  enum class States { IDLE, SWITCHING_POWER, MODE_COMMANDING };
-
-  States state = States::IDLE;
-  Mode_t currentMode = MODE_OFF;
-  Submode_t currentSubmode = A_SIDE;
-  PowerSwitchIF* switcher = nullptr;
-
-  AcsBoardHelper helper;
-  void initModeTableEntry(object_id_t id, ModeListEntry& entry);
-
-  ReturnValue_t initialize() override;
-  FixedArrayList<ModeListEntry, NUMBER_DEVICES_MODE_TABLE> modeTable;
+  static constexpr uint8_t NUMBER_DEVICES_MODE_TABLE = 9;
 
   static constexpr Submode_t A_SIDE = 0;
   static constexpr Submode_t B_SIDE = 1;
   static constexpr Submode_t DUAL_MODE = 2;
 
+  AcsBoardAssembly(object_id_t objectId, object_id_t parentId, PowerSwitchIF* pwrSwitcher,
+                   AcsBoardHelper helper);
+
+ private:
+  static constexpr pcduSwitches::Switches SWITCH_A =
+      pcduSwitches::Switches::PDU1_CH7_ACS_A_SIDE_3V3;
+  static constexpr pcduSwitches::Switches SWITCH_B =
+      pcduSwitches::Switches::PDU2_CH7_ACS_BOARD_SIDE_B_3V3;
+
+  enum class States { IDLE, SWITCHING_POWER, MODE_COMMANDING } state = States::IDLE;
+
+  PowerSwitchIF* pwrSwitcher = nullptr;
+
+  AcsBoardHelper helper;
+  FixedArrayList<ModeListEntry, NUMBER_DEVICES_MODE_TABLE> modeTable;
+  void initModeTableEntry(object_id_t id, ModeListEntry& entry);
+
+  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 isModeCombinationValid(Mode_t mode, Submode_t submode) override;
+  void handleModeReached() override;
 
   /**
    * Check whether it makes sense to send mode commands to the device
@@ -92,7 +96,7 @@ class AcsBoardAssembly : public AssemblyBase {
    */
   bool isUseable(object_id_t object, Mode_t mode);
   ReturnValue_t handleNormalOrOnModeCmd(Mode_t mode, Submode_t submode);
-  void powerStateMachine(Submode_t submode);
+  void powerStateMachine(Mode_t mode, Submode_t submode);
   void refreshHelperModes();
 };
 

mission/system/CMakeLists.txt

@@ -1,5 +1,6 @@
 target_sources(${LIB_EIVE_MISSION} PRIVATE
     AcsBoardAssembly.cpp
+    SusAssembly.cpp
     AcsSubsystem.cpp
     TcsSubsystem.cpp
     EiveSystem.cpp

mission/system/SusAssembly.cpp

@@ -0,0 +1,101 @@
+#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)
+    : AssemblyBase(objectId, parentId), helper(helper), pwrSwitcher(pwrSwitcher) {}
+
+ReturnValue_t SusAssembly::commandChildren(Mode_t mode, Submode_t submode) {
+  ReturnValue_t result = RETURN_OK;
+  refreshHelperModes();
+  return RETURN_OK;
+}
+
+ReturnValue_t SusAssembly::checkChildrenStateOn(Mode_t wantedMode, Submode_t wantedSubmode) {
+  return RETURN_OK;
+}
+
+ReturnValue_t SusAssembly::isModeCombinationValid(Mode_t mode, Submode_t submode) {
+  if (submode != NOMINAL and submode != REDUNDANT and submode != DUAL_MODE) {
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  return HasReturnvaluesIF::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 result;
+}
+
+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::powerStateMachine(Mode_t mode, Submode_t submode) {
+  ReturnValue_t switchStateNom = RETURN_OK;
+  ReturnValue_t switchStateRed = RETURN_OK;
+  if (state == States::IDLE or state == States::SWITCHING_POWER) {
+    switchStateNom = pwrSwitcher->getSwitchState(pcduSwitches::PDU1_CH4_SUS_NOMINAL_3V3);
+    switchStateRed = pwrSwitcher->getSwitchState(pcduSwitches::PDU2_CH4_SUS_REDUNDANT_3V3);
+    if (mode == MODE_OFF) {
+      if (switchStateNom == PowerSwitchIF::SWITCH_OFF and
+          switchStateRed == PowerSwitchIF::SWITCH_OFF) {
+        state = States::MODE_COMMANDING;
+        return;
+      }
+    } else {
+      switch (submode) {
+        case (NOMINAL): {
+          if (switchStateNom == PowerSwitchIF::SWITCH_ON and
+              switchStateRed == PowerSwitchIF::SWITCH_OFF) {
+            state = States::MODE_COMMANDING;
+            return;
+          }
+          break;
+        }
+        case (REDUNDANT): {
+          if (switchStateNom == PowerSwitchIF::SWITCH_OFF and
+              switchStateRed == PowerSwitchIF::SWITCH_ON) {
+            state = States::MODE_COMMANDING;
+            return;
+          }
+          break;
+        }
+        case (DUAL_MODE): {
+          if (switchStateNom == PowerSwitchIF::SWITCH_ON and
+              switchStateRed == PowerSwitchIF::SWITCH_ON) {
+            state = States::MODE_COMMANDING;
+            return;
+          }
+        }
+      }
+    }
+  }
+}
+
+void SusAssembly::refreshHelperModes() {
+  for (uint8_t idx = 0; idx < helper.susModes.size(); idx++) {
+    helper.susModes[idx] = childrenMap[helper.susIds[idx]].mode;
+  }
+}

mission/system/SusAssembly.h

@@ -0,0 +1,52 @@
+#ifndef MISSION_SYSTEM_SUSASSEMBLY_H_
+#define MISSION_SYSTEM_SUSASSEMBLY_H_
+
+#include <fsfw/devicehandlers/AssemblyBase.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 : AssemblyBase {
+ public:
+  static constexpr uint8_t NUMBER_SUN_SENSORS = 12;
+
+  static constexpr Submode_t NOMINAL = 0;
+  static constexpr Submode_t REDUNDANT = 1;
+  static constexpr Submode_t DUAL_MODE = 2;
+
+  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;
+
+  FixedArrayList<ModeListEntry, NUMBER_SUN_SENSORS> modeTable;
+
+  SusAssHelper helper;
+  PowerSwitchIF* pwrSwitcher = nullptr;
+
+  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 isModeCombinationValid(Mode_t mode, Submode_t submode) 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);
+  void refreshHelperModes();
+};
+
+#endif /* MISSION_SYSTEM_SUSASSEMBLY_H_ */