Merge branch 'develop' into rework_lock_handling

mission/system/objects/CMakeLists.txt

@@ -7,6 +7,7 @@ target_sources(
           TcsSubsystem.cpp
           PayloadSubsystem.cpp
           AcsBoardAssembly.cpp
+          SyrlinksAssembly.cpp
           Stack5VHandler.cpp
           SusAssembly.cpp
           RwAssembly.cpp

mission/system/objects/ComSubsystem.cpp

@@ -30,6 +30,7 @@ void ComSubsystem::performChildOperation() {
   if (countdownActive) {
     checkTransmitterCountdown();
   }
+
   Subsystem::performChildOperation();
 }
 

mission/system/objects/DualLaneAssemblyBase.cpp

@@ -235,3 +235,8 @@ void DualLaneAssemblyBase::setPreferredSide(duallane::Submodes submode) {
   }
   this->defaultSubmode = submode;
 }
+
+ReturnValue_t DualLaneAssemblyBase::checkAndHandleHealthState(Mode_t deviceMode,
+                                                              Submode_t deviceSubmode) {
+  return returnvalue::OK;
+}

mission/system/objects/DualLaneAssemblyBase.h

@@ -74,6 +74,7 @@ class DualLaneAssemblyBase : public AssemblyBase, public ConfirmsFailuresIF {
   MessageQueueId_t getEventReceptionQueue() override;
 
   bool sideSwitchTransition(Mode_t mode, Submode_t submode);
+  ReturnValue_t checkAndHandleHealthState(Mode_t deviceMode, Submode_t deviceSubmode);
 
   /**
    * Implemented by user. Will be called if a full mode operation has finished.

mission/system/objects/SusAssembly.cpp

@@ -24,6 +24,12 @@ ReturnValue_t SusAssembly::commandChildren(Mode_t mode, Submode_t submode) {
     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);
@@ -148,3 +154,23 @@ void SusAssembly::refreshHelperModes() {
     helper.susModes[idx] = childrenMap[helper.susIds[idx]].mode;
   }
 }
+
+ReturnValue_t SusAssembly::checkAndHandleHealthStates(Mode_t deviceMode, Submode_t deviceSubmode) {
+  using namespace returnvalue;
+  ReturnValue_t status = returnvalue::OK;
+  auto overwriteHealthForOneDev = [&](object_id_t dev) {
+    HealthState health = healthHelper.healthTable->getHealth(dev);
+    if (health == FAULTY or health == PERMANENT_FAULTY) {
+      overwriteDeviceHealth(dev, health);
+      status = NEED_TO_CHANGE_HEALTH;
+    } else if (health == EXTERNAL_CONTROL) {
+      modeHelper.setForced(true);
+    }
+  };
+  if (deviceSubmode == duallane::DUAL_MODE) {
+    for (uint8_t idx = 0; idx < 12; idx++) {
+      overwriteHealthForOneDev(helper.susIds[idx]);
+    }
+  }
+  return status;
+}

mission/system/objects/SusAssembly.h

@@ -66,6 +66,7 @@ class SusAssembly : public DualLaneAssemblyBase {
   void powerStateMachine(Mode_t mode, Submode_t submode);
   ReturnValue_t handleNormalOrOnModeCmd(Mode_t mode, Submode_t submode);
   void refreshHelperModes();
+  ReturnValue_t checkAndHandleHealthStates(Mode_t deviceMode, Submode_t deviceSubmode);
 };
 
 #endif /* MISSION_SYSTEM_SUSASSEMBLY_H_ */

mission/system/objects/SyrlinksAssembly.cpp

@@ -0,0 +1,57 @@
+#include "SyrlinksAssembly.h"
+
+#include <eive/objects.h>
+
+using namespace returnvalue;
+
+SyrlinksAssembly::SyrlinksAssembly(object_id_t objectId) : AssemblyBase(objectId) {
+  ModeListEntry entry;
+  entry.setObject(objects::SYRLINKS_HANDLER);
+  entry.setMode(MODE_OFF);
+  entry.setSubmode(SUBMODE_NONE);
+  commandTable.insert(entry);
+}
+
+ReturnValue_t SyrlinksAssembly::commandChildren(Mode_t mode, Submode_t submode) {
+  commandTable[0].setMode(mode);
+  commandTable[0].setSubmode(submode);
+  HybridIterator<ModeListEntry> iter(commandTable.begin(), commandTable.end());
+  if (recoveryState == RECOVERY_IDLE) {
+    ReturnValue_t result = checkAndHandleHealthState(mode, submode);
+    if (result == NEED_TO_CHANGE_HEALTH) {
+      return OK;
+    }
+  }
+  executeTable(iter);
+  return returnvalue::OK;
+}
+
+ReturnValue_t SyrlinksAssembly::checkChildrenStateOn(Mode_t wantedMode, Submode_t wantedSubmode) {
+  if (childrenMap[objects::SYRLINKS_HANDLER].mode != wantedMode) {
+    return NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE;
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t SyrlinksAssembly::isModeCombinationValid(Mode_t mode, Submode_t submode) {
+  if (mode == MODE_ON or mode == DeviceHandlerIF::MODE_NORMAL or mode == MODE_OFF) {
+    return returnvalue::OK;
+  }
+  return returnvalue::FAILED;
+}
+
+ReturnValue_t SyrlinksAssembly::checkAndHandleHealthState(Mode_t deviceMode,
+                                                          Submode_t deviceSubmode) {
+  HealthState health = healthHelper.healthTable->getHealth(objects::SYRLINKS_HANDLER);
+  if (health == FAULTY or health == PERMANENT_FAULTY) {
+    overwriteDeviceHealth(objects::SYRLINKS_HANDLER, health);
+    return NEED_TO_CHANGE_HEALTH;
+  } else if (health == EXTERNAL_CONTROL) {
+    modeHelper.setForced(true);
+  }
+  return OK;
+}
+
+void SyrlinksAssembly::handleChildrenLostMode(ReturnValue_t result) {
+  startTransition(mode, submode);
+}

mission/system/objects/SyrlinksAssembly.h

@@ -0,0 +1,20 @@
+#ifndef MISSION_SYSTEM_OBJECTS_SYRLINKSASSEMBLY_H_
+#define MISSION_SYSTEM_OBJECTS_SYRLINKSASSEMBLY_H_
+#include <fsfw/devicehandlers/AssemblyBase.h>
+
+class SyrlinksAssembly : public AssemblyBase {
+ public:
+  SyrlinksAssembly(object_id_t objectId);
+
+ private:
+  FixedArrayList<ModeListEntry, 1> commandTable;
+
+  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 handleChildrenLostMode(ReturnValue_t result) override;
+
+  ReturnValue_t checkAndHandleHealthState(Mode_t deviceMode, Submode_t deviceSubmode);
+};
+
+#endif /* MISSION_SYSTEM_OBJECTS_SYRLINKSASSEMBLY_H_ */