Merge remote-tracking branch 'origin/develop' into thermal_controller

mission/system/CMakeLists.txt

@@ -1,3 +1,7 @@
 add_subdirectory(objects)
 add_subdirectory(tree)
+add_subdirectory(acs)
+add_subdirectory(com)
 add_subdirectory(fdir)
+
+target_sources(${LIB_EIVE_MISSION} PRIVATE DualLanePowerStateMachine.cpp)

mission/system/DualLanePowerStateMachine.h

@@ -5,7 +5,7 @@
 #include <fsfw/modes/HasModesIF.h>
 #include <mission/system/objects/PowerStateMachineBase.h>
 
-#include "definitions.h"
+#include "mission/powerDefs.h"
 
 class AssemblyBase;
 class PowerSwitchIF;

mission/system/acs/AcsBoardAssembly.cpp

@@ -110,27 +110,25 @@ ReturnValue_t AcsBoardAssembly::handleNormalOrOnModeCmd(Mode_t mode, Submode_t s
   using namespace duallane;
   ReturnValue_t result = returnvalue::OK;
   bool needsSecondStep = false;
+  if (sideSwitchState == SideSwitchState::REQUESTED) {
+    sideSwitchState = SideSwitchState::TO_DUAL;
+  }
+  // Switch to dual side first, and later switch back to the otherside
+  if (sideSwitchState == SideSwitchState::TO_DUAL) {
+    targetSubmodeForSideSwitch = static_cast<duallane::Submodes>(submode);
+    submode = Submodes::DUAL_MODE;
+    sideSwitchState = SideSwitchState::DISABLE_OTHER_SIDE;
+    // TODO: Ugly hack. The base class should support arbitrary number of steps..
+    needsSecondStep = true;
+  } else if (sideSwitchState == SideSwitchState::DISABLE_OTHER_SIDE) {
+    submode = targetSubmodeForSideSwitch;
+  }
   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);
-      }
+    } else if (isUseable(objectId, devMode)) {
+      modeTable[tableIdx].setMode(mode);
+      modeTable[tableIdx].setSubmode(SUBMODE_NONE);
     }
   };
   bool gpsUsable = isUseable(helper.gpsId, helper.gpsMode);

mission/system/acs/AcsBoardAssembly.h

@@ -6,8 +6,8 @@
 #include <fsfw_hal/common/gpio/gpioDefinitions.h>
 
 #include "DualLaneAssemblyBase.h"
-#include "DualLanePowerStateMachine.h"
 #include "eive/eventSubsystemIds.h"
+#include "mission/system/DualLanePowerStateMachine.h"
 
 struct AcsBoardHelper {
   AcsBoardHelper(object_id_t mgm0Id, object_id_t mgm1Id, object_id_t mgm2Id, object_id_t mgm3Id,

mission/system/acs/AcsSubsystem.cpp

@@ -4,7 +4,7 @@
 #include <fsfw/ipc/QueueFactory.h>
 
 #include "fsfw/modes/ModeMessage.h"
-#include "mission/acsDefs.h"
+#include "mission/acs/defs.h"
 
 AcsSubsystem::AcsSubsystem(object_id_t setObjectId, uint32_t maxNumberOfSequences,
                            uint32_t maxNumberOfTables)

mission/system/acs/CMakeLists.txt

@@ -0,0 +1,11 @@
+target_sources(
+  ${LIB_EIVE_MISSION}
+  PRIVATE AcsBoardAssembly.cpp
+          AcsSubsystem.cpp
+          DualLaneAssemblyBase.cpp
+          ImtqAssembly.cpp
+          RwAssembly.cpp
+          SusAssembly.cpp
+          AcsBoardFdir.cpp
+          acsModeTree.cpp
+          SusFdir.cpp)

mission/system/acs/DualLaneAssemblyBase.cpp

@@ -36,6 +36,7 @@ void DualLaneAssemblyBase::performChildOperation() {
 void DualLaneAssemblyBase::startTransition(Mode_t mode, Submode_t submode) {
   using namespace duallane;
   pwrStateMachine.reset();
+
   if (mode != MODE_OFF) {
     // Special exception: A transition from dual side to single mode must be handled like
     // going OFF.
@@ -45,9 +46,13 @@ void DualLaneAssemblyBase::startTransition(Mode_t mode, Submode_t submode) {
       AssemblyBase::startTransition(mode, submode);
       return;
     }
+    uint8_t pwrSubmode = submode;
+    if (sideSwitchState == SideSwitchState::REQUESTED) {
+      pwrSubmode = duallane::DUAL_MODE;
+    }
     // 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);
+    pwrStateMachine.start(mode, pwrSubmode);
     // Cache these for later after the power state machine has finished
     targetMode = mode;
     targetSubmode = submode;
@@ -111,11 +116,7 @@ ReturnValue_t DualLaneAssemblyBase::isModeCombinationValid(Mode_t mode, Submode_
     return returnvalue::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;
+    sideSwitchState = SideSwitchState::REQUESTED;
   }
   return returnvalue::OK;
 }
@@ -231,9 +232,8 @@ bool DualLaneAssemblyBase::sideSwitchTransition(Mode_t mode, Submode_t submode)
     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) {
+    if ((this->submode == Submodes::A_SIDE and submode == Submodes::B_SIDE) or
+        (this->submode == Submodes::B_SIDE and submode == Submodes::A_SIDE)) {
       return true;
     }
     return false;
@@ -247,6 +247,7 @@ void DualLaneAssemblyBase::finishModeOp() {
   pwrStateMachine.reset();
   powerRetryCounter = 0;
   tryingOtherSide = false;
+  sideSwitchState = SideSwitchState::NONE;
   dualToSingleSideTransition = false;
   dualModeErrorSwitch = true;
 }

mission/system/acs/DualLaneAssemblyBase.h

@@ -2,7 +2,7 @@
 #define MISSION_SYSTEM_DUALLANEASSEMBLYBASE_H_
 
 #include <fsfw/devicehandlers/AssemblyBase.h>
-#include <mission/system/objects/DualLanePowerStateMachine.h>
+#include <mission/system/DualLanePowerStateMachine.h>
 
 /**
  * @brief   Encapsulates assemblies which are also responsible for dual lane power switching
@@ -34,6 +34,11 @@ class DualLaneAssemblyBase : public AssemblyBase, public ConfirmsFailuresIF {
   bool dualToSingleSideTransition = false;
   duallane::Submodes defaultSubmode = duallane::Submodes::A_SIDE;
 
+  enum SideSwitchState { NONE, REQUESTED, TO_DUAL, DISABLE_OTHER_SIDE };
+
+  SideSwitchState sideSwitchState = SideSwitchState::NONE;
+  duallane::Submodes targetSubmodeForSideSwitch = duallane::Submodes::B_SIDE;
+
   enum RecoveryCustomStates {
     IDLE,
     POWER_SWITCHING_OFF,

mission/system/acs/acsModeTree.cpp

@@ -9,9 +9,9 @@
 #include <optional>
 
 #include "eive/objects.h"
-#include "mission/acsDefs.h"
-#include "mission/system/objects/definitions.h"
-#include "util.h"
+#include "mission/acs/defs.h"
+#include "mission/powerDefs.h"
+#include "mission/system/tree/util.h"
 
 AcsSubsystem satsystem::acs::ACS_SUBSYSTEM(objects::ACS_SUBSYSTEM, 12, 24);
 

mission/system/acs/acsModeTree.h

@@ -1,4 +1,4 @@
-#include <mission/system/objects/AcsSubsystem.h>
+#include <mission/system/acs/AcsSubsystem.h>
 
 namespace satsystem {
 namespace acs {

mission/system/com/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(
+  ${LIB_EIVE_MISSION} PRIVATE comModeTree.cpp ComSubsystem.cpp
+                              SyrlinksAssembly.cpp SyrlinksFdir.cpp)

mission/system/com/ComSubsystem.cpp

@@ -6,7 +6,7 @@
 #include <fsfw/ipc/QueueFactory.h>
 #include <fsfw/serviceinterface/ServiceInterface.h>
 #include <linux/ipcore/PdecHandler.h>
-#include <mission/comDefs.h>
+#include <mission/com/defs.h>
 #include <mission/config/comCfg.h>
 #include <mission/controller/controllerdefinitions/tcsCtrlDefs.h>
 

mission/system/com/ComSubsystem.h

@@ -7,7 +7,7 @@
 #include <fsfw/parameters/ParameterHelper.h>
 #include <fsfw/subsystem/Subsystem.h>
 
-#include "mission/comDefs.h"
+#include "mission/com/defs.h"
 
 class ComSubsystem : public Subsystem, public ReceivesParameterMessagesIF {
  public:

mission/system/com/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/com/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_ */

mission/system/com/SyrlinksFdir.cpp

@@ -7,7 +7,7 @@
 #include "fsfw/power/Fuse.h"
 #include "fsfw/serviceinterface/ServiceInterfaceStream.h"
 #include "fsfw/thermal/ThermalComponentIF.h"
-#include "mission/devices/devicedefinitions/SyrlinksDefinitions.h"
+#include "mission/com/syrlinksDefs.h"
 
 SyrlinksFdir::SyrlinksFdir(object_id_t syrlinksId)
     : DeviceHandlerFailureIsolation(syrlinksId, objects::NO_OBJECT) {}
@@ -23,8 +23,7 @@ ReturnValue_t SyrlinksFdir::eventReceived(EventMessage* event) {
     case DeviceHandlerIF::DEVICE_WANTS_HARD_REBOOT:
       // We'll try a recovery as long as defined in MAX_REBOOT.
       // Might cause some AssemblyBase cycles, so keep number low.
-      // handleRecovery(event->getEvent());
-      triggerEvent(syrlinks::FDIR_REACTION_IGNORED, event->getEvent(), 0);
+      handleRecovery(event->getEvent());
       break;
     case DeviceHandlerIF::DEVICE_INTERPRETING_REPLY_FAILED:
     case DeviceHandlerIF::DEVICE_READING_REPLY_FAILED:
@@ -33,8 +32,7 @@ ReturnValue_t SyrlinksFdir::eventReceived(EventMessage* event) {
     case DeviceHandlerIF::DEVICE_BUILDING_COMMAND_FAILED:
       // These faults all mean that there were stupid replies from a device.
       if (strangeReplyCount.incrementAndCheck()) {
-        // handleRecovery(event->getEvent());
-        triggerEvent(syrlinks::FDIR_REACTION_IGNORED, event->getEvent(), 0);
+        handleRecovery(event->getEvent());
       }
       break;
     case DeviceHandlerIF::DEVICE_SENDING_COMMAND_FAILED:
@@ -48,7 +46,6 @@ ReturnValue_t SyrlinksFdir::eventReceived(EventMessage* event) {
       // else
       if (missedReplyCount.incrementAndCheck()) {
         handleRecovery(event->getEvent());
-        // triggerEvent(syrlinks::FDIR_REACTION_IGNORED, event->getEvent(), 0);
       }
       break;
     case StorageManagerIF::GET_DATA_FAILED:
@@ -81,7 +78,6 @@ ReturnValue_t SyrlinksFdir::eventReceived(EventMessage* event) {
     case Fuse::POWER_BELOW_LOW_LIMIT:
       // Device might got stuck during boot, retry.
       handleRecovery(event->getEvent());
-      triggerEvent(syrlinks::FDIR_REACTION_IGNORED, event->getEvent(), 0);
       break;
       //****Thermal*****
     case ThermalComponentIF::COMPONENT_TEMP_LOW:
@@ -113,14 +109,12 @@ void SyrlinksFdir::eventConfirmed(EventMessage* event) {
     case DeviceHandlerIF::DEVICE_REQUESTING_REPLY_FAILED:
     case DeviceHandlerIF::DEVICE_MISSED_REPLY:
       if (missedReplyCount.incrementAndCheck()) {
-        // handleRecovery(event->getEvent());
-        triggerEvent(syrlinks::FDIR_REACTION_IGNORED, event->getEvent(), 0);
+        handleRecovery(event->getEvent());
       }
       break;
     case PowerSwitchIF::SWITCH_WENT_OFF:
       // This means the switch went off only for one device.
-      // handleRecovery(event->getEvent());
-      triggerEvent(syrlinks::FDIR_REACTION_IGNORED, event->getEvent(), 0);
+      handleRecovery(event->getEvent());
       break;
     default:
       break;

mission/system/com/comModeTree.cpp

@@ -5,8 +5,8 @@
 #include <fsfw/subsystem/Subsystem.h>
 
 #include "eive/objects.h"
-#include "mission/comDefs.h"
-#include "util.h"
+#include "mission/com/defs.h"
+#include "mission/system/tree/util.h"
 
 const auto check = subsystem::checkInsert;
 

mission/system/com/comModeTree.h

@@ -2,7 +2,8 @@
 #define MISSION_SYSTEM_TREE_COMMODETREE_H_
 
 #include <fsfw/devicehandlers/DeviceHandlerIF.h>
-#include <mission/system/objects/ComSubsystem.h>
+
+#include "ComSubsystem.h"
 
 namespace satsystem {
 

mission/system/fdir/CMakeLists.txt

@@ -1,4 +1,2 @@
-target_sources(
-  ${LIB_EIVE_MISSION}
-  PRIVATE AcsBoardFdir.cpp RtdFdir.cpp StrFdir.cpp SusFdir.cpp SyrlinksFdir.cpp
-          GomspacePowerFdir.cpp)
+target_sources(${LIB_EIVE_MISSION} PRIVATE RtdFdir.cpp StrFdir.cpp
+                                           GomspacePowerFdir.cpp)

mission/system/fdir/StrFdir.cpp

@@ -1,6 +1,6 @@
 #include "StrFdir.h"
 
-#include "mission/acsDefs.h"
+#include "mission/acs/defs.h"
 
 StrFdir::StrFdir(object_id_t strObject)
     : DeviceHandlerFailureIsolation(strObject, objects::NO_OBJECT) {}

mission/system/objects/CMakeLists.txt

@@ -2,18 +2,9 @@ target_sources(
   ${LIB_EIVE_MISSION}
   PRIVATE EiveSystem.cpp
           CamSwitcher.cpp
-          AcsSubsystem.cpp
-          ComSubsystem.cpp
           TcsSubsystem.cpp
           PayloadSubsystem.cpp
-          AcsBoardAssembly.cpp
-          ImtqAssembly.cpp
-          SyrlinksAssembly.cpp
           Stack5VHandler.cpp
-          SusAssembly.cpp
-          RwAssembly.cpp
-          DualLanePowerStateMachine.cpp
           StrAssembly.cpp
           PowerStateMachineBase.cpp
-          DualLaneAssemblyBase.cpp
           TcsBoardAssembly.cpp)

mission/system/objects/EiveSystem.cpp

@@ -3,7 +3,8 @@
 #include <eive/objects.h>
 #include <fsfw/events/EventManager.h>
 #include <fsfw/ipc/QueueFactory.h>
-#include <mission/acsDefs.h>
+
+#include <mission/acs/defs.h>
 #include <mission/comDefs.h>
 #include <mission/controller/controllerdefinitions/tcsCtrlDefs.h>
 

mission/system/objects/PowerStateMachineBase.h

@@ -5,7 +5,7 @@
 #include <fsfw/power/PowerSwitchIF.h>
 #include <fsfw/timemanager/Countdown.h>
 
-#include "definitions.h"
+#include "mission/powerDefs.h"
 
 class PowerStateMachineBase {
  public:

mission/system/objects/definitions.h

@@ -1,16 +0,0 @@
-#pragma once
-
-#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

mission/system/tree/CMakeLists.txt

@@ -1,4 +1,2 @@
-target_sources(
-  ${LIB_EIVE_MISSION}
-  PRIVATE acsModeTree.cpp payloadModeTree.cpp comModeTree.cpp tcsModeTree.cpp
-          system.cpp util.cpp)
+target_sources(${LIB_EIVE_MISSION} PRIVATE payloadModeTree.cpp tcsModeTree.cpp
+                                           system.cpp util.cpp)

mission/system/tree/payloadModeTree.cpp

@@ -8,8 +8,8 @@
 #include "eive/objects.h"
 #include "mission/devices/devicedefinitions/payloadPcduDefinitions.h"
 #include "mission/payloadDefs.h"
+#include "mission/powerDefs.h"
 #include "mission/system/objects/PayloadSubsystem.h"
-#include "mission/system/objects/definitions.h"
 #include "util.h"
 
 namespace {

mission/system/tree/system.cpp

@@ -2,13 +2,13 @@
 
 #include <fsfw/devicehandlers/DeviceHandlerIF.h>
 #include <fsfw/subsystem/Subsystem.h>
-#include <mission/acsDefs.h>
+#include <mission/acs/defs.h>
 #include <mission/sysDefs.h>
+#include <mission/system/com/comModeTree.h>
 
-#include "acsModeTree.h"
-#include "comModeTree.h"
 #include "eive/objects.h"
-#include "mission/comDefs.h"
+#include "mission/com/defs.h"
+#include "mission/system/acs/acsModeTree.h"
 #include "payloadModeTree.h"
 #include "tcsModeTree.h"
 #include "util.h"