done

mission/system/objects/TcsBoardAssembly.cpp

@@ -4,9 +4,11 @@
 #include <fsfw/ipc/QueueFactory.h>
 
 TcsBoardAssembly::TcsBoardAssembly(object_id_t objectId, PowerSwitchIF* pwrSwitcher,
-                                   power::Switch_t theSwitch, TcsBoardHelper helper)
-    : AssemblyBase(objectId, 24), switcher(pwrSwitcher, theSwitch), helper(helper) {
-  eventQueue = QueueFactory::instance()->createMessageQueue(24);
+                                   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);
@@ -16,23 +18,6 @@ TcsBoardAssembly::TcsBoardAssembly(object_id_t objectId, PowerSwitchIF* pwrSwitc
   }
 }
 
-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);
-  }
-}
-
 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
@@ -50,6 +35,8 @@ ReturnValue_t TcsBoardAssembly::commandChildren(Mode_t mode, Submode_t submode)
     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);
@@ -94,25 +81,6 @@ ReturnValue_t TcsBoardAssembly::isModeCombinationValid(Mode_t mode, Submode_t su
   return HasModesIF::INVALID_MODE;
 }
 
-ReturnValue_t TcsBoardAssembly::initialize() { return AssemblyBase::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 = returnvalue::OK;
   bool needsSecondStep = false;
@@ -169,21 +137,6 @@ bool TcsBoardAssembly::isUseable(object_id_t object, Mode_t mode) {
   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) {
   triggerEvent(CHILDREN_LOST_MODE, result);
   startTransition(mode, submode);
@@ -210,6 +163,12 @@ ReturnValue_t TcsBoardAssembly::checkAndHandleHealthStates(Mode_t deviceMode,
   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);

mission/system/objects/TcsBoardAssembly.h

@@ -4,6 +4,10 @@
 #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"
@@ -15,23 +19,20 @@ struct TcsBoardHelper {
   std::array<std::pair<object_id_t, std::string>, 16> rtdInfos = {};
 };
 
-class TcsBoardAssembly : public AssemblyBase, public ConfirmsFailuresIF {
+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);
-
-  ReturnValue_t initialize() override;
+                   TcsBoardHelper helper, std::atomic_bool& tcsShortlyUnavailable);
 
  private:
   static constexpr uint8_t NUMBER_RTDS = 16;
-  PowerSwitcher switcher;
   bool warningSwitch = true;
   TcsBoardHelper helper;
   FixedArrayList<ModeListEntry, NUMBER_RTDS> modeTable;
-  MessageQueueIF* eventQueue = nullptr;
+  std::atomic_bool& tcsShortlyUnavailable;
 
   ReturnValue_t handleNormalOrOnModeCmd(Mode_t mode, Submode_t submode);
   /**
@@ -42,17 +43,12 @@ class TcsBoardAssembly : public AssemblyBase, public ConfirmsFailuresIF {
    */
   bool isUseable(object_id_t object, Mode_t mode);
 
-  // ConfirmFailureIF implementation
-  MessageQueueId_t getEventReceptionQueue() override;
-
   // AssemblyBase implementation
-  void performChildOperation() override;
   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;
   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