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

CHANGELOG.md

@@ -18,6 +18,24 @@ will consitute of a breaking change warranting a new major release:
 
 ## Changed
 
+- Adapted HK data rates to new table for LEOP SAFE mode.
+- GPS controller HK is now generated periodically as well.
+
+# [v1.43.1] 2023-04-04
+
+## Fixed
+
+- Generic HK handling: Bug where HKs were generated a lot more often than required. This is the case
+  if a device handler `PERFORM_OPERATION` step is performed more than once per PST cycle.
+- Syrlinks now goes to `_MODE_TO_ON` when finishing the `doStartUp` transition.
+
+## Changed
+
+- Doubled GS PST interval instead of scheduling everything twice.
+- Syrlinks now only has one `PERFORM_OPERATION` step, but still has two communication steps.
+- PCDU components only allow setting `NEEDS_RECOVERY`, `HEALTHY` and `EXTERNAL_CONTROL` health
+  states now. TMP sensor components only allow `HEALTHY` , `EXTERNAL_CONTROL`, `FAULTY` and
+  `PERMANENT_FAULTY`.
 - TCS controller now does a sanity check on the temperature values: Values below -80 C or above
   160 C are ignored.
 

CMakeLists.txt

@@ -11,7 +11,7 @@ cmake_minimum_required(VERSION 3.13)
 
 set(OBSW_VERSION_MAJOR 1)
 set(OBSW_VERSION_MINOR 43)
-set(OBSW_VERSION_REVISION 0)
+set(OBSW_VERSION_REVISION 1)
 
 # set(CMAKE_VERBOSE TRUE)
 

bsp_q7s/core/CoreController.cpp

@@ -138,7 +138,7 @@ ReturnValue_t CoreController::initializeLocalDataPool(localpool::DataPool &local
   localDataPoolMap.emplace(core::TEMPERATURE, &tempPoolEntry);
   localDataPoolMap.emplace(core::PS_VOLTAGE, &psVoltageEntry);
   localDataPoolMap.emplace(core::PL_VOLTAGE, &plVoltageEntry);
-  poolManager.subscribeForRegularPeriodicPacket({hkSet.getSid(), enableHkSet, 12.0});
+  poolManager.subscribeForRegularPeriodicPacket({hkSet.getSid(), enableHkSet, 60.0});
   return returnvalue::OK;
 }
 

bsp_q7s/core/ObjectFactory.cpp

@@ -26,7 +26,7 @@
 #include <mission/power/CspCookie.h>
 #include <mission/system/acs/ImtqAssembly.h>
 #include <mission/system/acs/StrAssembly.h>
-#include <mission/system/fdir/StrFdir.h>
+#include <mission/system/acs/StrFdir.h>
 #include <mission/system/objects/CamSwitcher.h>
 #include <mission/system/objects/SyrlinksAssembly.h>
 
@@ -62,9 +62,9 @@
 #include "mission/system/acs/acsModeTree.h"
 #include "mission/system/com/SyrlinksFdir.h"
 #include "mission/system/com/comModeTree.h"
-#include "mission/system/fdir/GomspacePowerFdir.h"
 #include "mission/system/fdir/RtdFdir.h"
 #include "mission/system/objects/TcsBoardAssembly.h"
+#include "mission/system/power/GomspacePowerFdir.h"
 #include "mission/system/tree/payloadModeTree.h"
 #include "mission/system/tree/tcsModeTree.h"
 #include "mission/tmtc/tmFilters.h"
@@ -360,7 +360,8 @@ void ObjectFactory::createAcsBoardGpios(GpioCookie& cookie) {
 }
 
 void ObjectFactory::createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF* gpioComIF,
-                                             SerialComIF* uartComIF, PowerSwitchIF& pwrSwitcher) {
+                                             SerialComIF* uartComIF, PowerSwitchIF& pwrSwitcher,
+                                             bool enableHkSets) {
   using namespace gpio;
   GpioCookie* gpioCookieAcsBoard = new GpioCookie();
   createAcsBoardGpios(*gpioCookieAcsBoard);
@@ -514,8 +515,8 @@ void ObjectFactory::createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF*
 #endif
   RESET_ARGS_GNSS.gpioComIF = gpioComIF;
   RESET_ARGS_GNSS.waitPeriodMs = 100;
-  auto gpsCtrl =
+  auto gpsCtrl = new GpsHyperionLinuxController(objects::GPS_CONTROLLER, objects::NO_OBJECT,
-      new GpsHyperionLinuxController(objects::GPS_CONTROLLER, objects::NO_OBJECT, debugGps);
+                                                enableHkSets, debugGps);
   gpsCtrl->setResetPinTriggerFunction(gps::triggerGpioResetPin, &RESET_ARGS_GNSS);
 
   ObjectFactory::createAcsBoardAssy(pwrSwitcher, assemblyChildren, gpsCtrl, gpioComIF);

bsp_q7s/core/ObjectFactory.h

@@ -62,7 +62,7 @@ void createTmpComponents();
 ReturnValue_t createRadSensorComponent(LinuxLibgpioIF* gpioComIF, Stack5VHandler& handler);
 void createAcsBoardGpios(GpioCookie& cookie);
 void createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF* gpioComIF, SerialComIF* uartComIF,
-                              PowerSwitchIF& pwrSwitcher);
+                              PowerSwitchIF& pwrSwitcher, bool enableHkSets);
 void createHeaterComponents(GpioIF* gpioIF, PowerSwitchIF* pwrSwitcher, HealthTableIF* healthTable,
                             HeaterHandler*& heaterHandler);
 void createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enableHkSets);

bsp_q7s/core/scheduling.cpp

@@ -538,7 +538,7 @@ void scheduling::createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction
 
   FixedTimeslotTaskIF* gomSpacePstTask =
       factory.createFixedTimeslotTask("GS_PST_TASK", 65, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4,
-                                      0.5, missedDeadlineFunc, &RR_SCHEDULING);
+                                      0.25, missedDeadlineFunc, &RR_SCHEDULING);
   result = pst::pstGompaceCan(gomSpacePstTask);
   if (result != returnvalue::OK) {
     if (result != FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {

bsp_q7s/fmObjectFactory.cpp

@@ -55,7 +55,7 @@ void ObjectFactory::produce(void* args) {
 #endif
 
 #if OBSW_ADD_ACS_BOARD == 1
-  createAcsBoardComponents(*spiMainComIF, gpioComIF, uartComIF, *pwrSwitcher);
+  createAcsBoardComponents(*spiMainComIF, gpioComIF, uartComIF, *pwrSwitcher, true);
 #endif
   HeaterHandler* heaterHandler;
   createHeaterComponents(gpioComIF, pwrSwitcher, healthTable, heaterHandler);

linux/acs/GpsHyperionLinuxController.cpp

@@ -18,8 +18,11 @@
 #include <ctime>
 
 GpsHyperionLinuxController::GpsHyperionLinuxController(object_id_t objectId, object_id_t parentId,
-                                                       bool debugHyperionGps)
+                                                       bool enableHkSets, bool debugHyperionGps)
-    : ExtendedControllerBase(objectId), gpsSet(this), debugHyperionGps(debugHyperionGps) {}
+    : ExtendedControllerBase(objectId),
+      gpsSet(this),
+      enableHkSets(enableHkSets),
+      debugHyperionGps(debugHyperionGps) {}
 
 GpsHyperionLinuxController::~GpsHyperionLinuxController() {
   gps_stream(&gps, WATCH_DISABLE, nullptr);
@@ -86,7 +89,7 @@ ReturnValue_t GpsHyperionLinuxController::initializeLocalDataPool(
   localDataPoolMap.emplace(GpsHyperion::SATS_IN_USE, new PoolEntry<uint8_t>());
   localDataPoolMap.emplace(GpsHyperion::SATS_IN_VIEW, new PoolEntry<uint8_t>());
   localDataPoolMap.emplace(GpsHyperion::FIX_MODE, new PoolEntry<uint8_t>());
-  poolManager.subscribeForRegularPeriodicPacket({gpsSet.getSid(), false, 30.0});
+  poolManager.subscribeForRegularPeriodicPacket({gpsSet.getSid(), enableHkSets, 30.0});
   return returnvalue::OK;
 }
 

linux/acs/GpsHyperionLinuxController.h

@@ -29,7 +29,7 @@ class GpsHyperionLinuxController : public ExtendedControllerBase {
 
   enum ReadModes { SHM = 0, SOCKET = 1 };
 
-  GpsHyperionLinuxController(object_id_t objectId, object_id_t parentId,
+  GpsHyperionLinuxController(object_id_t objectId, object_id_t parentId, bool enableHkSets,
                              bool debugHyperionGps = false);
   virtual ~GpsHyperionLinuxController();
 
@@ -58,6 +58,7 @@ class GpsHyperionLinuxController : public ExtendedControllerBase {
  private:
   GpsPrimaryDataset gpsSet;
   gps_data_t gps = {};
+  bool enableHkSets = false;
   const char* currentClientBuf = nullptr;
   ReadModes readMode = ReadModes::SOCKET;
   Countdown maxTimeToReachFix = Countdown(MAX_SECONDS_TO_REACH_FIX * 1000);

mission/acs/ImtqHandler.cpp

@@ -795,9 +795,9 @@ ReturnValue_t ImtqHandler::initializeLocalDataPool(localpool::DataPool& localDat
   localDataPoolMap.emplace(imtq::FINA_NEG_Z_COIL_Z_TEMPERATURE, new PoolEntry<int16_t>({0}));
 
   poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(hkDatasetNoTorque.getSid(), enableHkSets, 12.0));
+      subdp::DiagnosticsHkPeriodicParams(hkDatasetNoTorque.getSid(), enableHkSets, 30.0));
   poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(hkDatasetWithTorque.getSid(), enableHkSets, 12.0));
+      subdp::DiagnosticsHkPeriodicParams(hkDatasetWithTorque.getSid(), enableHkSets, 30.0));
   poolManager.subscribeForDiagPeriodicPacket(
       subdp::DiagnosticsHkPeriodicParams(rawMtmNoTorque.getSid(), false, 10.0));
   poolManager.subscribeForDiagPeriodicPacket(

mission/com/SyrlinksHandler.cpp

@@ -21,15 +21,15 @@ SyrlinksHandler::~SyrlinksHandler() = default;
 
 void SyrlinksHandler::doStartUp() {
   if (internalState == InternalState::OFF) {
-    transitionCommandPending = false;
     internalState = InternalState::ENABLE_TEMPERATURE_PROTECTION;
     commandExecuted = false;
   }
   if (internalState == InternalState::ENABLE_TEMPERATURE_PROTECTION) {
     if (commandExecuted) {
       // Go to normal mode immediately and disable transmitter on startup.
-      setMode(_MODE_TO_NORMAL);
+      setMode(_MODE_TO_ON);
       internalState = InternalState::IDLE;
+      transState = TransitionState::IDLE;
       commandExecuted = false;
     }
   }
@@ -37,15 +37,16 @@ void SyrlinksHandler::doStartUp() {
 
 void SyrlinksHandler::doShutDown() {
   // In any case, always disable TX first.
-  if (internalState != InternalState::SET_TX_STANDBY) {
+  if (internalState != InternalState::TX_TRANSITION) {
-    internalState = InternalState::SET_TX_STANDBY;
+    internalState = InternalState::TX_TRANSITION;
-    transitionCommandPending = false;
+    transState = TransitionState::SET_TX_STANDBY;
     commandExecuted = false;
   }
-  if (internalState == InternalState::SET_TX_STANDBY) {
+  if (internalState == InternalState::TX_TRANSITION) {
     if (commandExecuted) {
       temperatureSet.setValidity(false, true);
       internalState = InternalState::OFF;
+      transState = TransitionState::IDLE;
       commandExecuted = false;
       setMode(_MODE_POWER_DOWN);
     }
@@ -99,30 +100,43 @@ ReturnValue_t SyrlinksHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
 }
 
 ReturnValue_t SyrlinksHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
+  if (transState == TransitionState::CMD_PENDING or transState == TransitionState::DONE) {
+    return NOTHING_TO_SEND;
+  }
   switch (internalState) {
     case InternalState::ENABLE_TEMPERATURE_PROTECTION: {
       *id = syrlinks::WRITE_LCL_CONFIG;
+      transState = TransitionState::CMD_PENDING;
       return buildCommandFromCommand(*id, nullptr, 0);
     }
-    case InternalState::SET_TX_MODULATION: {
+    case InternalState::TX_TRANSITION: {
-      *id = syrlinks::SET_TX_MODE_MODULATION;
+      switch (transState) {
-      return buildCommandFromCommand(*id, nullptr, 0);
+        case TransitionState::SET_TX_MODULATION: {
-    }
+          *id = syrlinks::SET_TX_MODE_MODULATION;
-    case InternalState::SELECT_MODULATION_BPSK: {
+          return buildCommandFromCommand(*id, nullptr, 0);
-      *id = syrlinks::SET_WAVEFORM_BPSK;
+        }
-      return buildCommandFromCommand(*id, nullptr, 0);
+        case TransitionState::SELECT_MODULATION_BPSK: {
-    }
+          *id = syrlinks::SET_WAVEFORM_BPSK;
-    case InternalState::SELECT_MODULATION_0QPSK: {
+          return buildCommandFromCommand(*id, nullptr, 0);
-      *id = syrlinks::SET_WAVEFORM_0QPSK;
+        }
-      return buildCommandFromCommand(*id, nullptr, 0);
+        case TransitionState::SELECT_MODULATION_0QPSK: {
-    }
+          *id = syrlinks::SET_WAVEFORM_0QPSK;
-    case InternalState::SET_TX_CW: {
+          return buildCommandFromCommand(*id, nullptr, 0);
-      *id = syrlinks::SET_TX_MODE_CW;
+        }
-      return buildCommandFromCommand(*id, nullptr, 0);
+        case TransitionState::SET_TX_CW: {
-    }
+          *id = syrlinks::SET_TX_MODE_CW;
-    case InternalState::SET_TX_STANDBY: {
+          return buildCommandFromCommand(*id, nullptr, 0);
-      *id = syrlinks::SET_TX_MODE_STANDBY;
+        }
-      return buildCommandFromCommand(*id, nullptr, 0);
+        case TransitionState::SET_TX_STANDBY: {
+          *id = syrlinks::SET_TX_MODE_STANDBY;
+          return buildCommandFromCommand(*id, nullptr, 0);
+        }
+        default: {
+          return NOTHING_TO_SEND;
+        }
+      }
+      transState = TransitionState::CMD_PENDING;
+      break;
     }
     default: {
       break;
@@ -622,8 +636,6 @@ void SyrlinksHandler::parseAgcHighByte(const uint8_t* packet) {
   agcValueHighByte = convertHexStringToUint8(reinterpret_cast<const char*>(packet + offset));
 }
 
-void SyrlinksHandler::setNormalDatapoolEntriesInvalid() {}
-
 uint32_t SyrlinksHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 2500; }
 
 ReturnValue_t SyrlinksHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
@@ -652,11 +664,11 @@ ReturnValue_t SyrlinksHandler::initializeLocalDataPool(localpool::DataPool& loca
   poolManager.subscribeForDiagPeriodicPacket(
       subdp::DiagnosticsHkPeriodicParams(rxDataset.getSid(), enableHkSets, 60.0));
   poolManager.subscribeForRegularPeriodicPacket(
-      subdp::RegularHkPeriodicParams(temperatureSet.getSid(), enableHkSets, 20.0));
+      subdp::RegularHkPeriodicParams(temperatureSet.getSid(), enableHkSets, 120.0));
   return returnvalue::OK;
 }
 
-void SyrlinksHandler::setModeNormal() { setMode(MODE_NORMAL); }
+void SyrlinksHandler::setModeNormal() { setMode(_MODE_TO_NORMAL); }
 
 float SyrlinksHandler::calcTempVal(uint16_t raw) { return 0.126984 * raw - 67.87; }
 
@@ -675,12 +687,31 @@ ReturnValue_t SyrlinksHandler::handleAckReply(const uint8_t* packet) {
       break;
     }
     case (syrlinks::SET_WAVEFORM_BPSK):
-    case (syrlinks::SET_WAVEFORM_0QPSK):
+    case (syrlinks::SET_WAVEFORM_0QPSK): {
-    case (syrlinks::SET_TX_MODE_STANDBY):
+      if (result == returnvalue::OK and isTransitionalMode()) {
-    case (syrlinks::SET_TX_MODE_MODULATION):
+        transState = TransitionState::SET_TX_MODULATION;
+        commandExecuted = true;
+      }
+      break;
+    }
+    case (syrlinks::SET_TX_MODE_STANDBY): {
+      if (result == returnvalue::OK and isTransitionalMode()) {
+        transState = TransitionState::DONE;
+        commandExecuted = true;
+      }
+      break;
+    }
+    case (syrlinks::SET_TX_MODE_MODULATION): {
+      if (result == returnvalue::OK and isTransitionalMode()) {
+        transState = TransitionState::DONE;
+        commandExecuted = true;
+      }
+      break;
+    }
     case (syrlinks::SET_TX_MODE_CW): {
       if (result == returnvalue::OK and isTransitionalMode()) {
         commandExecuted = true;
+        transState = TransitionState::DONE;
       }
       break;
     }
@@ -704,7 +735,7 @@ ReturnValue_t SyrlinksHandler::handleAckReply(const uint8_t* packet) {
 
 ReturnValue_t SyrlinksHandler::isModeCombinationValid(Mode_t mode, Submode_t submode) {
   if (mode == HasModesIF::MODE_ON or mode == DeviceHandlerIF::MODE_NORMAL) {
-    if (submode >= com::Submode::NUM_SUBMODES) {
+    if (submode >= com::Submode::NUM_SUBMODES or submode < com::Submode::RX_ONLY) {
       return HasModesIF::INVALID_SUBMODE;
     }
     return returnvalue::OK;
@@ -731,72 +762,54 @@ void SyrlinksHandler::setDebugMode(bool enable) { this->debugMode = enable; }
 
 void SyrlinksHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
   Mode_t tgtMode = getBaseMode(getMode());
-  auto commandDone = [&]() {
+  auto doneHandler = [&]() {
-    setMode(tgtMode);
-    transitionCommandPending = false;
     internalState = InternalState::IDLE;
+    transState = TransitionState::IDLE;
+    DeviceHandlerBase::doTransition(modeFrom, subModeFrom);
   };
-  auto txOnHandler = [&](InternalState selMod) {
+  if (transState == TransitionState::DONE) {
-    if (internalState == InternalState::IDLE) {
+    return doneHandler();
-      transitionCommandPending = false;
+  }
-      commandExecuted = false;
-      internalState = selMod;
-    }
-    // Select modulation first (BPSK or 0QPSK).
-    if (internalState == selMod) {
-      if (commandExecuted) {
-        transitionCommandPending = false;
-        internalState = InternalState::SET_TX_MODULATION;
-        commandExecuted = false;
-      }
-    }
-    // Now go into modulation mode.
-    if (internalState == InternalState::SET_TX_MODULATION) {
-      if (commandExecuted) {
-        commandDone();
-        return true;
-      }
-    }
-    return false;
-  };
   auto txStandbyHandler = [&]() {
-    if (internalState == InternalState::IDLE) {
+    txDataset.setReportingEnabled(false);
-      transitionCommandPending = false;
+    poolManager.changeCollectionInterval(temperatureSet.getSid(), 60.0);
-      internalState = InternalState::SET_TX_STANDBY;
+    transState = TransitionState::SET_TX_STANDBY;
-      commandExecuted = false;
+    internalState = InternalState::TX_TRANSITION;
-    }
-    if (internalState == InternalState::SET_TX_STANDBY) {
-      if (commandExecuted) {
-        commandDone();
-        return;
-      }
-    }
   };
+  auto txOnHandler = [&](TransitionState tgtTransitionState) {
+    txDataset.setReportingEnabled(true);
+    poolManager.changeCollectionInterval(txDataset.getSid(), 10.0);
+    poolManager.changeCollectionInterval(temperatureSet.getSid(), 5.0);
+    transState = tgtTransitionState;
+    internalState = InternalState::TX_TRANSITION;
+  };
+
   if (tgtMode == HasModesIF::MODE_ON or tgtMode == DeviceHandlerIF::MODE_NORMAL) {
+    // If submode has not changed, no special transition handling necessary.
+    if (getSubmode() == subModeFrom) {
+      return doneHandler();
+    }
+    // Transition is on-going, wait for it to finish.
+    if (transState != TransitionState::IDLE) {
+      return;
+    }
+    // Transition start logic.
     switch (getSubmode()) {
       case (com::Submode::RX_AND_TX_DEFAULT_DATARATE): {
         auto currentDatarate = com::getCurrentDatarate();
         if (currentDatarate == com::Datarate::LOW_RATE_MODULATION_BPSK) {
-          if (txOnHandler(InternalState::SELECT_MODULATION_BPSK)) {
+          txOnHandler(TransitionState::SELECT_MODULATION_BPSK);
-            return;
-          }
         } else if (currentDatarate == com::Datarate::HIGH_RATE_MODULATION_0QPSK) {
-          if (txOnHandler(InternalState::SELECT_MODULATION_0QPSK)) {
+          txOnHandler(TransitionState::SELECT_MODULATION_0QPSK);
-            return;
-          }
         }
         break;
       }
       case (com::Submode::RX_AND_TX_LOW_DATARATE): {
-        if (txOnHandler(InternalState::SELECT_MODULATION_BPSK)) {
+        txOnHandler(TransitionState::SELECT_MODULATION_BPSK);
-          return;
-        }
         break;
       }
       case (com::Submode::RX_AND_TX_HIGH_DATARATE): {
-        if (txOnHandler(InternalState::SELECT_MODULATION_0QPSK)) {
+        txOnHandler(TransitionState::SELECT_MODULATION_0QPSK);
-          return;
-        }
         break;
       }
       case (com::Submode::RX_ONLY): {
@@ -804,21 +817,17 @@ void SyrlinksHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
         return;
       }
       case (com::Submode::RX_AND_TX_CW): {
-        if (internalState == InternalState::IDLE) {
+        txOnHandler(TransitionState::SET_TX_CW);
-          internalState = InternalState::SET_TX_STANDBY;
-          commandExecuted = false;
-        }
-        if (commandExecuted) {
-          commandDone();
-          return;
-        }
         break;
       }
       default: {
-        commandDone();
+        sif::error << "SyrlinksHandler: Unexpected submode " << getSubmode() << std::endl;
+        DeviceHandlerBase::doTransition(modeFrom, subModeFrom);
       }
     }
   } else if (tgtMode == HasModesIF::MODE_OFF) {
     txStandbyHandler();
+  } else {
+    return doneHandler();
   }
 }

mission/com/SyrlinksHandler.h

@@ -46,7 +46,6 @@ class SyrlinksHandler : public DeviceHandlerBase {
                              size_t* foundLen) override;
   ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) override;
   ReturnValue_t getSwitches(const uint8_t** switches, uint8_t* numberOfSwitches) override;
-  void setNormalDatapoolEntriesInvalid() override;
   uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
   ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                         LocalDataPoolManager& poolManager) override;
@@ -112,22 +111,26 @@ class SyrlinksHandler : public DeviceHandlerBase {
   float tempPowerAmplifier = 0;
   float tempBasebandBoard = 0;
   bool commandExecuted = false;
-  bool transitionCommandPending = false;
 
   uint8_t commandBuffer[syrlinks::MAX_COMMAND_SIZE];
 
   enum class InternalState {
     OFF,
     ENABLE_TEMPERATURE_PROTECTION,
+    TX_TRANSITION,
+    IDLE
+  } internalState = InternalState::OFF;
+
+  enum class TransitionState {
+    IDLE,
     SELECT_MODULATION_BPSK,
     SELECT_MODULATION_0QPSK,
     SET_TX_MODULATION,
     SET_TX_CW,
     SET_TX_STANDBY,
-    IDLE
+    CMD_PENDING,
-  };
+    DONE
-
+  } transState = TransitionState::IDLE;
-  InternalState internalState = InternalState::OFF;
 
   /**
    * This object is used to store the id of the next command to execute. This controls the

mission/controller/AcsController.cpp

@@ -565,7 +565,7 @@ ReturnValue_t AcsController::initializeLocalDataPool(localpool::DataPool &localD
   localDataPoolMap.emplace(acsctrl::PoolIds::MGM_3_RM3100_UT, &mgm3VecRaw);
   localDataPoolMap.emplace(acsctrl::PoolIds::MGM_IMTQ_CAL_NT, &imtqMgmVecRaw);
   localDataPoolMap.emplace(acsctrl::PoolIds::MGM_IMTQ_CAL_ACT_STATUS, &imtqCalActStatus);
-  poolManager.subscribeForRegularPeriodicPacket({mgmDataRaw.getSid(), false, 5.0});
+  poolManager.subscribeForRegularPeriodicPacket({mgmDataRaw.getSid(), false, 10.0});
   // MGM Processed
   localDataPoolMap.emplace(acsctrl::PoolIds::MGM_0_VEC, &mgm0VecProc);
   localDataPoolMap.emplace(acsctrl::PoolIds::MGM_1_VEC, &mgm1VecProc);
@@ -575,7 +575,7 @@ ReturnValue_t AcsController::initializeLocalDataPool(localpool::DataPool &localD
   localDataPoolMap.emplace(acsctrl::PoolIds::MGM_VEC_TOT, &mgmVecTot);
   localDataPoolMap.emplace(acsctrl::PoolIds::MGM_VEC_TOT_DERIVATIVE, &mgmVecTotDer);
   localDataPoolMap.emplace(acsctrl::PoolIds::MAG_IGRF_MODEL, &magIgrf);
-  poolManager.subscribeForRegularPeriodicPacket({mgmDataProcessed.getSid(), enableHkSets, 12.0});
+  poolManager.subscribeForRegularPeriodicPacket({mgmDataProcessed.getSid(), enableHkSets, 10.0});
   // SUS Raw
   localDataPoolMap.emplace(acsctrl::PoolIds::SUS_0_N_LOC_XFYFZM_PT_XF, &sus0ValRaw);
   localDataPoolMap.emplace(acsctrl::PoolIds::SUS_1_N_LOC_XBYFZM_PT_XB, &sus1ValRaw);
@@ -589,7 +589,7 @@ ReturnValue_t AcsController::initializeLocalDataPool(localpool::DataPool &localD
   localDataPoolMap.emplace(acsctrl::PoolIds::SUS_9_R_LOC_XBYBZB_PT_YF, &sus9ValRaw);
   localDataPoolMap.emplace(acsctrl::PoolIds::SUS_10_N_LOC_XMYBZF_PT_ZF, &sus10ValRaw);
   localDataPoolMap.emplace(acsctrl::PoolIds::SUS_11_R_LOC_XBYMZB_PT_ZB, &sus11ValRaw);
-  poolManager.subscribeForRegularPeriodicPacket({susDataRaw.getSid(), false, 5.0});
+  poolManager.subscribeForRegularPeriodicPacket({susDataRaw.getSid(), false, 10.0});
   // SUS Processed
   localDataPoolMap.emplace(acsctrl::PoolIds::SUS_0_VEC, &sus0VecProc);
   localDataPoolMap.emplace(acsctrl::PoolIds::SUS_1_VEC, &sus1VecProc);
@@ -606,43 +606,43 @@ ReturnValue_t AcsController::initializeLocalDataPool(localpool::DataPool &localD
   localDataPoolMap.emplace(acsctrl::PoolIds::SUS_VEC_TOT, &susVecTot);
   localDataPoolMap.emplace(acsctrl::PoolIds::SUS_VEC_TOT_DERIVATIVE, &susVecTotDer);
   localDataPoolMap.emplace(acsctrl::PoolIds::SUN_IJK_MODEL, &sunIjk);
-  poolManager.subscribeForRegularPeriodicPacket({susDataProcessed.getSid(), enableHkSets, 12.0});
+  poolManager.subscribeForRegularPeriodicPacket({susDataProcessed.getSid(), enableHkSets, 10.0});
   // GYR Raw
   localDataPoolMap.emplace(acsctrl::PoolIds::GYR_0_ADIS, &gyr0VecRaw);
   localDataPoolMap.emplace(acsctrl::PoolIds::GYR_1_L3, &gyr1VecRaw);
   localDataPoolMap.emplace(acsctrl::PoolIds::GYR_2_ADIS, &gyr2VecRaw);
   localDataPoolMap.emplace(acsctrl::PoolIds::GYR_3_L3, &gyr3VecRaw);
-  poolManager.subscribeForDiagPeriodicPacket({gyrDataRaw.getSid(), false, 5.0});
+  poolManager.subscribeForDiagPeriodicPacket({gyrDataRaw.getSid(), false, 10.0});
   // GYR Processed
   localDataPoolMap.emplace(acsctrl::PoolIds::GYR_0_VEC, &gyr0VecProc);
   localDataPoolMap.emplace(acsctrl::PoolIds::GYR_1_VEC, &gyr1VecProc);
   localDataPoolMap.emplace(acsctrl::PoolIds::GYR_2_VEC, &gyr2VecProc);
   localDataPoolMap.emplace(acsctrl::PoolIds::GYR_3_VEC, &gyr3VecProc);
   localDataPoolMap.emplace(acsctrl::PoolIds::GYR_VEC_TOT, &gyrVecTot);
-  poolManager.subscribeForDiagPeriodicPacket({gyrDataProcessed.getSid(), enableHkSets, 12.0});
+  poolManager.subscribeForDiagPeriodicPacket({gyrDataProcessed.getSid(), enableHkSets, 10.0});
   // GPS Processed
   localDataPoolMap.emplace(acsctrl::PoolIds::GC_LATITUDE, &gcLatitude);
   localDataPoolMap.emplace(acsctrl::PoolIds::GD_LONGITUDE, &gdLongitude);
   localDataPoolMap.emplace(acsctrl::PoolIds::ALTITUDE, &altitude);
   localDataPoolMap.emplace(acsctrl::PoolIds::GPS_POSITION, &gpsPosition);
   localDataPoolMap.emplace(acsctrl::PoolIds::GPS_VELOCITY, &gpsVelocity);
-  poolManager.subscribeForRegularPeriodicPacket({gpsDataProcessed.getSid(), enableHkSets, 12.0});
+  poolManager.subscribeForRegularPeriodicPacket({gpsDataProcessed.getSid(), enableHkSets, 30.0});
   // MEKF
   localDataPoolMap.emplace(acsctrl::PoolIds::QUAT_MEKF, &quatMekf);
   localDataPoolMap.emplace(acsctrl::PoolIds::SAT_ROT_RATE_MEKF, &satRotRateMekf);
   localDataPoolMap.emplace(acsctrl::PoolIds::MEKF_STATUS, &mekfStatus);
-  poolManager.subscribeForDiagPeriodicPacket({mekfData.getSid(), enableHkSets, 12.0});
+  poolManager.subscribeForDiagPeriodicPacket({mekfData.getSid(), enableHkSets, 10.0});
   // Ctrl Values
   localDataPoolMap.emplace(acsctrl::PoolIds::TGT_QUAT, &tgtQuat);
   localDataPoolMap.emplace(acsctrl::PoolIds::ERROR_QUAT, &errQuat);
   localDataPoolMap.emplace(acsctrl::PoolIds::ERROR_ANG, &errAng);
   localDataPoolMap.emplace(acsctrl::PoolIds::TGT_ROT_RATE, &tgtRotRate);
-  poolManager.subscribeForRegularPeriodicPacket({ctrlValData.getSid(), enableHkSets, 12.0});
+  poolManager.subscribeForRegularPeriodicPacket({ctrlValData.getSid(), enableHkSets, 10.0});
   // Actuator CMD
   localDataPoolMap.emplace(acsctrl::PoolIds::RW_TARGET_TORQUE, &rwTargetTorque);
   localDataPoolMap.emplace(acsctrl::PoolIds::RW_TARGET_SPEED, &rwTargetSpeed);
   localDataPoolMap.emplace(acsctrl::PoolIds::MTQ_TARGET_DIPOLE, &mtqTargetDipole);
-  poolManager.subscribeForRegularPeriodicPacket({actuatorCmdData.getSid(), enableHkSets, 12.0});
+  poolManager.subscribeForRegularPeriodicPacket({actuatorCmdData.getSid(), enableHkSets, 10.0});
   return returnvalue::OK;
 }
 

mission/controller/ThermalController.cpp

@@ -260,13 +260,13 @@ ReturnValue_t ThermalController::initializeLocalDataPool(localpool::DataPool& lo
   enableHkSets = true;
 #endif
   poolManager.subscribeForRegularPeriodicPacket(
-      subdp::RegularHkPeriodicParams(sensorTemperatures.getSid(), enableHkSets, 60.0));
+      subdp::RegularHkPeriodicParams(sensorTemperatures.getSid(), enableHkSets, 120.0));
   poolManager.subscribeForRegularPeriodicPacket(
-      subdp::RegularHkPeriodicParams(susTemperatures.getSid(), enableHkSets, 60.0));
+      subdp::RegularHkPeriodicParams(susTemperatures.getSid(), enableHkSets, 240.0));
   poolManager.subscribeForRegularPeriodicPacket(
-      subdp::RegularHkPeriodicParams(deviceTemperatures.getSid(), enableHkSets, 60.0));
+      subdp::RegularHkPeriodicParams(deviceTemperatures.getSid(), enableHkSets, 120.0));
   poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(heaterInfo.getSid(), enableHkSets, 30.0));
+      subdp::DiagnosticsHkPeriodicParams(heaterInfo.getSid(), enableHkSets, 120.0));
 
   return returnvalue::OK;
 }

mission/pollingSeqTables.cpp

@@ -26,8 +26,7 @@ ReturnValue_t pst::pstSyrlinks(FixedTimeslotTaskIF *thisSequence) {
   thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
   thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.25, DeviceHandlerIF::SEND_READ);
   thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.25, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.4,
+
-                        DeviceHandlerIF::PERFORM_OPERATION);
   thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.4, DeviceHandlerIF::SEND_WRITE);
   thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
   thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.75, DeviceHandlerIF::SEND_READ);
@@ -114,40 +113,15 @@ ReturnValue_t pst::pstGompaceCan(FixedTimeslotTaskIF *thisSequence) {
   thisSequence->addSlot(objects::PDU2_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
   thisSequence->addSlot(objects::ACU_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
 
-  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.25, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.5, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.25, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.5, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.25, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.5, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::ACU_HANDLER, length * 0.25, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::ACU_HANDLER, length * 0.5, DeviceHandlerIF::SEND_READ);
 
-  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.25, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.5, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.25, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.5, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.25, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.5, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::ACU_HANDLER, length * 0.25, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::ACU_HANDLER, length * 0.5, DeviceHandlerIF::GET_READ);
-
-  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.5, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.5, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.5, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::ACU_HANDLER, length * 0.5, DeviceHandlerIF::PERFORM_OPERATION);
-
-  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.5, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.5, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.5, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::ACU_HANDLER, length * 0.5, DeviceHandlerIF::SEND_WRITE);
-
-  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.5, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.5, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.5, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::ACU_HANDLER, length * 0.5, DeviceHandlerIF::GET_WRITE);
-
-  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.75, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.75, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.75, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::ACU_HANDLER, length * 0.75, DeviceHandlerIF::SEND_READ);
-
-  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.75, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.75, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.75, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::ACU_HANDLER, length * 0.75, DeviceHandlerIF::GET_READ);
   if (thisSequence->checkSequence() != returnvalue::OK) {
     sif::error << "GomSpace PST initialization failed" << std::endl;
     return returnvalue::FAILED;

mission/power/AcuHandler.cpp

@@ -149,9 +149,9 @@ ReturnValue_t ACUHandler::initializeLocalDataPool(localpool::DataPool &localData
   localDataPoolMap.emplace(pool::ACU_WDT_GND_LEFT, new PoolEntry<uint32_t>({0}));
 
   poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(coreHk.getSid(), enableHkSets, 20.0));
+      subdp::DiagnosticsHkPeriodicParams(coreHk.getSid(), enableHkSets, 30.0));
   poolManager.subscribeForRegularPeriodicPacket(
-      subdp::RegularHkPeriodicParams(auxHk.getSid(), enableHkSets, 3000.0));
+      subdp::RegularHkPeriodicParams(auxHk.getSid(), enableHkSets, 6000.0));
   return returnvalue::OK;
 }
 

mission/power/GomspaceDeviceHandler.cpp

@@ -642,3 +642,11 @@ ReturnValue_t GomspaceDeviceHandler::parsePduHkTable(PDU::PduCoreHk& coreHk, PDU
   }
   return returnvalue::OK;
 }
+
+ReturnValue_t GomspaceDeviceHandler::setHealth(HealthState health) {
+  if (health != HealthState::HEALTHY and health != HealthState::EXTERNAL_CONTROL and
+      health != HealthState::NEEDS_RECOVERY) {
+    return returnvalue::FAILED;
+  }
+  return returnvalue::OK;
+}

mission/power/GomspaceDeviceHandler.h

@@ -80,6 +80,9 @@ class GomspaceDeviceHandler : public DeviceHandlerBase {
   ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
   void setNormalDatapoolEntriesInvalid() override;
   uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
+
+  ReturnValue_t setHealth(HealthState health) override;
+
   /**
    * @brief   The command to generate a request to receive the full housekeeping table is device
    *          specific. Thus the child has to build this command.

mission/power/P60DockHandler.cpp

@@ -166,9 +166,9 @@ ReturnValue_t P60DockHandler::initializeLocalDataPool(localpool::DataPool &local
   localDataPoolMap.emplace(pool::P60DOCK_ANT6_DEPL, new PoolEntry<int8_t>({0}));
   localDataPoolMap.emplace(pool::P60DOCK_AR6_DEPL, new PoolEntry<int8_t>({0}));
   poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(coreHk.getSid(), enableHkSets, 20.0));
+      subdp::DiagnosticsHkPeriodicParams(coreHk.getSid(), enableHkSets, 30.0));
   poolManager.subscribeForRegularPeriodicPacket(
-      subdp::RegularHkPeriodicParams(auxHk.getSid(), enableHkSets, 3000.0));
+      subdp::RegularHkPeriodicParams(auxHk.getSid(), enableHkSets, 6000.0));
   return returnvalue::OK;
 }
 

mission/power/Pdu1Handler.cpp

@@ -90,9 +90,9 @@ ReturnValue_t Pdu1Handler::initializeLocalDataPool(localpool::DataPool &localDat
                                                    LocalDataPoolManager &poolManager) {
   initializePduPool(localDataPoolMap, poolManager, pcdu::INIT_SWITCHES_PDU1);
   poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(coreHk.getSid(), enableHkSets, 20.0));
+      subdp::DiagnosticsHkPeriodicParams(coreHk.getSid(), enableHkSets, 30.0));
   poolManager.subscribeForRegularPeriodicPacket(
-      subdp::RegularHkPeriodicParams(auxHk.getSid(), enableHkSets, 3000.0));
+      subdp::RegularHkPeriodicParams(auxHk.getSid(), enableHkSets, 6000.0));
   return returnvalue::OK;
 }
 

mission/power/Pdu2Handler.cpp

@@ -49,9 +49,9 @@ ReturnValue_t Pdu2Handler::initializeLocalDataPool(localpool::DataPool &localDat
                                                    LocalDataPoolManager &poolManager) {
   initializePduPool(localDataPoolMap, poolManager, pcdu::INIT_SWITCHES_PDU2);
   poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(coreHk.getSid(), enableHkSets, 10.0));
+      subdp::DiagnosticsHkPeriodicParams(coreHk.getSid(), enableHkSets, 30.0));
   poolManager.subscribeForRegularPeriodicPacket(
-      subdp::RegularHkPeriodicParams(auxHk.getSid(), enableHkSets, 30.0));
+      subdp::RegularHkPeriodicParams(auxHk.getSid(), enableHkSets, 6000.0));
   return returnvalue::OK;
 }
 

mission/system/CMakeLists.txt

@@ -3,5 +3,6 @@ add_subdirectory(tree)
 add_subdirectory(acs)
 add_subdirectory(com)
 add_subdirectory(fdir)
+add_subdirectory(power)
 
 target_sources(${LIB_EIVE_MISSION} PRIVATE DualLanePowerStateMachine.cpp)

mission/system/acs/AcsBoardAssembly.cpp

@@ -291,8 +291,7 @@ ReturnValue_t AcsBoardAssembly::checkAndHandleHealthStates(Mode_t deviceMode,
   } else if (healthHelper.healthTable->getHealth(helper.healthDevGps1) == PERMANENT_FAULTY and
              healthHelper.healthTable->getHealth(helper.healthDevGps0) == FAULTY) {
     overwriteDeviceHealth(helper.healthDevGps0, FAULTY);
-    healthNeedsToBeOverwritten = true;
+  } else if (healthHelper.healthTable->isFaulty(helper.healthDevGps0) and
-  } else if (healthHelper.healthTable->isFaulty(helper.healthDevGps0) or
              healthHelper.healthTable->isFaulty(helper.healthDevGps1)) {
     overwriteDeviceHealth(helper.healthDevGps0,
                           healthHelper.healthTable->getHealth(helper.healthDevGps0));

mission/system/acs/CMakeLists.txt

@@ -9,4 +9,5 @@ target_sources(
           SusAssembly.cpp
           AcsBoardFdir.cpp
           acsModeTree.cpp
-          SusFdir.cpp)
+          SusFdir.cpp
+          StrFdir.cpp)

mission/system/fdir/CMakeLists.txt

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

mission/system/power/CMakeLists.txt

@@ -0,0 +1 @@
+target_sources(${LIB_EIVE_MISSION} PRIVATE GomspacePowerFdir.cpp)

mission/tcs/Tmp1075Handler.cpp

@@ -132,3 +132,11 @@ ReturnValue_t Tmp1075Handler::initializeLocalDataPool(localpool::DataPool &local
 }
 
 void Tmp1075Handler::setModeNormal() { setMode(_MODE_TO_NORMAL); }
+
+ReturnValue_t Tmp1075Handler::setHealth(HealthState health) {
+  if (health != FAULTY and health != PERMANENT_FAULTY and health != HEALTHY and
+      health != EXTERNAL_CONTROL) {
+    return returnvalue::FAILED;
+  }
+  return returnvalue::OK;
+}

mission/tcs/Tmp1075Handler.h

@@ -37,6 +37,7 @@ class Tmp1075Handler : public DeviceHandlerBase {
   uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
   ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                         LocalDataPoolManager &poolManager) override;
+  ReturnValue_t setHealth(HealthState health) override;
 
  private:
   /**