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

CHANGELOG.md

@@ -16,8 +16,15 @@ will consitute of a breaking change warranting a new major release:
 
 # [unreleased]
 
+## Fixed
+
+- Proper Faulty/External Control handling for the dual lane assemblies.
+- ACS board devices: Go to ON mode instead of going to NORMAL mode directly.
+- SUS device handlers: Go to ON mode on startup instead of NORMAL mode.
+
 ## Changed
 
+- Enabled periodic hosuekeeping generation for release images.
 - Project structure (linux and mission folder) is subsystem centric now.
 
 # [v1.40.0] 2023-03-24

CMakeLists.txt

@@ -297,9 +297,11 @@ include(BuildType)
 set_build_type()
 
 set(FSFW_DEBUG_INFO 0)
+set(OBSW_ENABLE_PERIODIC_HK 1)
 set(Q7S_CHECK_FOR_ALREADY_RUNNING_IMG 0)
 if(RELEASE_BUILD MATCHES 0)
   set(FSFW_DEBUG_INFO 1)
+  set(OBSW_ENABLE_PERIODIC_HK 0)
   set(Q7S_CHECK_FOR_ALREADY_RUNNING_IMG 1)
 endif()
 

bsp_q7s/OBSWConfig.h.in

@@ -13,9 +13,12 @@
 /** All of the following flags should be enabled for mission code  */
 /*******************************************************************/
 
-#define OBSW_ENABLE_PERIODIC_HK                     0
+// This enables a lot of periodically generated telemetry, so it can make sense to
+// disable this for debugging purposes.
+#define OBSW_ENABLE_PERIODIC_HK                     @OBSW_ENABLE_PERIODIC_HK@
+
 // This switch will cause the SW to command the EIVE system object to safe mode. This will
-// trigger a lot of events, so it can make sense to disable this for debugging purposes
+// trigger a lot of events, so it can make sense to disable this for debugging purposes.
 #define OBSW_COMMAND_SAFE_MODE_AT_STARTUP           1
 
 #define OBSW_ADD_GOMSPACE_PCDU                      @OBSW_ADD_GOMSPACE_PCDU@
@@ -28,8 +31,8 @@
 #define OBSW_ADD_SUS_BOARD_ASS                      @OBSW_ADD_SUS_BOARD_ASS@
 #define OBSW_ADD_ACS_BOARD                          @OBSW_ADD_ACS_BOARD@
 #define OBSW_ADD_ACS_CTRL                           1
+#define OBSW_ADD_TCS_CTRL                           1
 #define OBSW_ADD_GPS_CTRL                           @OBSW_ADD_GPS_CTRL@
-#define OBSW_ADD_TCS_CTRL                           @OBSW_ADD_TCS_CTRL@
 #define OBSW_ADD_RW                                 @OBSW_ADD_RW@
 #define OBSW_ADD_RTD_DEVICES                        @OBSW_ADD_RTD_DEVICES@
 #define OBSW_ADD_SA_DEPL                            @OBSW_ADD_SA_DEPL@

bsp_q7s/core/CoreController.cpp

@@ -31,8 +31,10 @@
 xsc::Chip CoreController::CURRENT_CHIP = xsc::Chip::NO_CHIP;
 xsc::Copy CoreController::CURRENT_COPY = xsc::Copy::NO_COPY;
 
-CoreController::CoreController(object_id_t objectId, const std::atomic_uint16_t &i2cErrors)
+CoreController::CoreController(object_id_t objectId, const std::atomic_uint16_t &i2cErrors,
+                               bool enableHkSet)
     : ExtendedControllerBase(objectId, 5),
+      enableHkSet(enableHkSet),
       cmdExecutor(4096),
       cmdReplyBuf(4096, true),
       cmdRepliesSizes(128),
@@ -136,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(), false, 10.0});
+  poolManager.subscribeForRegularPeriodicPacket({hkSet.getSid(), enableHkSet, 12.0});
   return returnvalue::OK;
 }
 

bsp_q7s/core/CoreController.h

@@ -135,7 +135,7 @@ class CoreController : public ExtendedControllerBase {
   static constexpr Event I2C_UNAVAILABLE_REBOOT =
       event::makeEvent(SUBSYSTEM_ID, 10, severity::MEDIUM);
 
-  CoreController(object_id_t objectId, const std::atomic_uint16_t& i2cErrors);
+  CoreController(object_id_t objectId, const std::atomic_uint16_t& i2cErrors, bool enableHkSet);
   virtual ~CoreController();
 
   ReturnValue_t initialize() override;
@@ -179,6 +179,7 @@ class CoreController : public ExtendedControllerBase {
   static constexpr uint32_t BOOT_OFFSET_SECONDS = 15;
   static constexpr MutexIF::TimeoutType TIMEOUT_TYPE = MutexIF::TimeoutType::WAITING;
   static constexpr uint32_t MUTEX_TIMEOUT = 20;
+  bool enableHkSet = false;
   GpsHyperion::FixMode gpsFix = GpsHyperion::FixMode::UNKNOWN;
 
   // States for SD state machine, which is used in non-blocking mode

bsp_q7s/core/ObjectFactory.cpp

@@ -187,27 +187,28 @@ void ObjectFactory::createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF,
   //*spiRWComIF = new SpiComIF(objects::SPI_RW_COM_IF, q7s::SPI_RW_DEV, **gpioComIF);
 }
 
-void ObjectFactory::createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF** pwrSwitcher) {
+void ObjectFactory::createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF** pwrSwitcher,
+                                         bool enableHkSets) {
   CspCookie* p60DockCspCookie = new CspCookie(P60Dock::MAX_REPLY_SIZE, addresses::P60DOCK, 500);
   CspCookie* pdu1CspCookie = new CspCookie(PDU::MAX_REPLY_SIZE, addresses::PDU1, 500);
   CspCookie* pdu2CspCookie = new CspCookie(PDU::MAX_REPLY_SIZE, addresses::PDU2, 500);
   CspCookie* acuCspCookie = new CspCookie(ACU::MAX_REPLY_SIZE, addresses::ACU, 500);
 
   auto p60Fdir = new GomspacePowerFdir(objects::P60DOCK_HANDLER);
-  P60DockHandler* p60dockhandler =
+  P60DockHandler* p60dockhandler = new P60DockHandler(objects::P60DOCK_HANDLER, objects::CSP_COM_IF,
-      new P60DockHandler(objects::P60DOCK_HANDLER, objects::CSP_COM_IF, p60DockCspCookie, p60Fdir);
+                                                      p60DockCspCookie, p60Fdir, enableHkSets);
 
   auto pdu1Fdir = new GomspacePowerFdir(objects::PDU1_HANDLER);
-  Pdu1Handler* pdu1handler =
+  Pdu1Handler* pdu1handler = new Pdu1Handler(objects::PDU1_HANDLER, objects::CSP_COM_IF,
-      new Pdu1Handler(objects::PDU1_HANDLER, objects::CSP_COM_IF, pdu1CspCookie, pdu1Fdir);
+                                             pdu1CspCookie, pdu1Fdir, enableHkSets);
 
   auto pdu2Fdir = new GomspacePowerFdir(objects::PDU2_HANDLER);
-  Pdu2Handler* pdu2handler =
+  Pdu2Handler* pdu2handler = new Pdu2Handler(objects::PDU2_HANDLER, objects::CSP_COM_IF,
-      new Pdu2Handler(objects::PDU2_HANDLER, objects::CSP_COM_IF, pdu2CspCookie, pdu2Fdir);
+                                             pdu2CspCookie, pdu2Fdir, enableHkSets);
 
   auto acuFdir = new GomspacePowerFdir(objects::ACU_HANDLER);
-  ACUHandler* acuhandler =
+  ACUHandler* acuhandler = new ACUHandler(objects::ACU_HANDLER, objects::CSP_COM_IF, acuCspCookie,
-      new ACUHandler(objects::ACU_HANDLER, objects::CSP_COM_IF, acuCspCookie, acuFdir);
+                                          acuFdir, enableHkSets);
   auto pcduHandler = new PcduHandler(objects::PCDU_HANDLER, 50);
 
   /**
@@ -963,14 +964,14 @@ void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) {
   starTracker->setCustomFdir(strFdir);
 }
 
-void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher) {
+void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enableHkSets) {
   auto* imtqAssy = new ImtqAssembly(objects::IMTQ_ASSY);
   imtqAssy->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
 
   new ImtqPollingTask(objects::IMTQ_POLLING, I2C_FATAL_ERRORS);
   I2cCookie* imtqI2cCookie = new I2cCookie(addresses::IMTQ, imtq::MAX_REPLY_SIZE, q7s::I2C_PL_EIVE);
   auto imtqHandler = new ImtqHandler(objects::IMTQ_HANDLER, objects::IMTQ_POLLING, imtqI2cCookie,
-                                     power::Switches::PDU1_CH3_MGT_5V);
+                                     pcdu::Switches::PDU1_CH3_MGT_5V, enableHkSets);
   imtqHandler->enableThermalModule(ThermalStateCfg());
   imtqHandler->setPowerSwitcher(pwrSwitcher);
   imtqHandler->connectModeTreeParent(*imtqAssy);
@@ -984,10 +985,10 @@ void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher) {
 #endif
 }
 
-void ObjectFactory::createBpxBatteryComponent() {
+void ObjectFactory::createBpxBatteryComponent(bool enableHkSets) {
   I2cCookie* bpxI2cCookie = new I2cCookie(addresses::BPX_BATTERY, 100, q7s::I2C_PL_EIVE);
-  BpxBatteryHandler* bpxHandler =
+  BpxBatteryHandler* bpxHandler = new BpxBatteryHandler(
-      new BpxBatteryHandler(objects::BPX_BATT_HANDLER, objects::I2C_COM_IF, bpxI2cCookie);
+      objects::BPX_BATT_HANDLER, objects::I2C_COM_IF, bpxI2cCookie, enableHkSets);
   bpxHandler->setStartUpImmediately();
   bpxHandler->setToGoToNormalMode(true);
 #if OBSW_DEBUG_BPX_BATT == 1

bsp_q7s/core/ObjectFactory.h

@@ -53,7 +53,8 @@ void produce(void* args);
 
 void createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF, SerialComIF** uartComIF,
                                    SpiComIF** spiMainComIF, I2cComIF** i2cComIF);
-void createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF** pwrSwitcher);
+void createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF** pwrSwitcher,
+                          bool enableHkSets);
 void createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF,
                             PowerSwitchIF* pwrSwitcher, Stack5VHandler& stackHandler);
 void createTmpComponents();
@@ -63,8 +64,8 @@ void createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF* gpioComIF, Ser
                               PowerSwitchIF& pwrSwitcher);
 void createHeaterComponents(GpioIF* gpioIF, PowerSwitchIF* pwrSwitcher, HealthTableIF* healthTable,
                             HeaterHandler*& heaterHandler);
-void createImtqComponents(PowerSwitchIF* pwrSwitcher);
+void createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enableHkSets);
-void createBpxBatteryComponent();
+void createBpxBatteryComponent(bool enableHkSets);
 void createStrComponents(PowerSwitchIF* pwrSwitcher);
 void createSolarArrayDeploymentComponents(PowerSwitchIF& pwrSwitcher, GpioIF& gpioIF);
 void createSyrlinksComponents(PowerSwitchIF* pwrSwitcher);

bsp_q7s/em/emObjectFactory.cpp

@@ -29,6 +29,11 @@ void ObjectFactory::produce(void* args) {
   StorageManagerIF* ipcStore = nullptr;
   StorageManagerIF* tmStore = nullptr;
 
+  bool enableHkSets = false;
+#if OBSW_ENABLE_PERIODIC_HK == 1
+  enableHkSets = true;
+#endif
+
   PersistentTmStores stores;
   ObjectFactory::produceGenericObjects(&healthTable, &pusFunnel, &cfdpFunnel,
                                        *SdCardManager::instance(), &ipcStore, &tmStore, stores);
@@ -61,12 +66,12 @@ void ObjectFactory::produce(void* args) {
   auto* comCookieDummy = new ComCookieDummy();
   pwrSwitcher = new PcduHandlerDummy(objects::PCDU_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
 #else
-  createPcduComponents(gpioComIF, &pwrSwitcher);
+  createPcduComponents(gpioComIF, &pwrSwitcher, enableHkSets);
 #endif
 
   dummy::createDummies(dummyCfg, *pwrSwitcher, gpioComIF);
 
-  new CoreController(objects::CORE_CONTROLLER, I2C_FATAL_ERRORS);
+  new CoreController(objects::CORE_CONTROLLER, I2C_FATAL_ERRORS, enableHkSets);
 
   // Regular FM code, does not work for EM if the hardware is not connected
   // createPcduComponents(gpioComIF, &pwrSwitcher);
@@ -84,7 +89,7 @@ void ObjectFactory::produce(void* args) {
   // createRadSensorComponent(gpioComIF);
 
 #if OBSW_ADD_ACS_BOARD == 1
-  createAcsBoardComponents(gpioComIF, uartComIF, *pwrSwitcher);
+  createAcsBoardComponents(*spiMainComIF, gpioComIF, uartComIF, *pwrSwitcher);
 #else
   // Still add all GPIOs for EM.
   GpioCookie* acsBoardGpios = new GpioCookie();
@@ -93,7 +98,7 @@ void ObjectFactory::produce(void* args) {
 #endif
 
 #if OBSW_ADD_MGT == 1
-  createImtqComponents(pwrSwitcher);
+  createImtqComponents(pwrSwitcher, enableHkSets);
 #endif
 
 #if OBSW_ADD_SYRLINKS == 1
@@ -105,7 +110,7 @@ void ObjectFactory::produce(void* args) {
 #endif
 
 #if OBSW_ADD_BPX_BATTERY_HANDLER == 1
-  createBpxBatteryComponent();
+  createBpxBatteryComponent(enableHkSets);
 #endif
 
 #if OBSW_ADD_STAR_TRACKER == 1
@@ -131,7 +136,7 @@ void ObjectFactory::produce(void* args) {
   createScexComponents(q7s::UART_SCEX_DEV, pwrSwitcher, *SdCardManager::instance(), false,
                        pcdu::Switches::PDU1_CH5_SOLAR_CELL_EXP_5V);
 #endif
-  createAcsController(true);
+  createAcsController(true, enableHkSets);
   HeaterHandler* heaterHandler = nullptr;
   ObjectFactory::createGenericHeaterComponents(*gpioComIF, *pwrSwitcher, heaterHandler);
   createThermalController(*heaterHandler);

bsp_q7s/fmObjectFactory.cpp

@@ -24,6 +24,11 @@ void ObjectFactory::produce(void* args) {
   StorageManagerIF* ipcStore = nullptr;
   StorageManagerIF* tmStore = nullptr;
 
+  bool enableHkSets = false;
+#if OBSW_ENABLE_PERIODIC_HK == 1
+  enableHkSets = true;
+#endif
+
   PersistentTmStores stores;
   ObjectFactory::produceGenericObjects(&healthTable, &pusFunnel, &cfdpFunnel,
                                        *SdCardManager::instance(), &ipcStore, &tmStore, stores);
@@ -38,8 +43,8 @@ void ObjectFactory::produce(void* args) {
   q7s::gpioCallbacks::initSpiCsDecoder(gpioComIF);
   gpioCallbacks::disableAllDecoder(gpioComIF);
 
-  new CoreController(objects::CORE_CONTROLLER, I2C_FATAL_ERRORS);
+  new CoreController(objects::CORE_CONTROLLER, I2C_FATAL_ERRORS, enableHkSets);
-  createPcduComponents(gpioComIF, &pwrSwitcher);
+  createPcduComponents(gpioComIF, &pwrSwitcher, enableHkSets);
   auto* stackHandler = new Stack5VHandler(*pwrSwitcher);
 
 #if OBSW_ADD_RAD_SENSORS == 1
@@ -66,12 +71,12 @@ void ObjectFactory::produce(void* args) {
   createPayloadComponents(gpioComIF, *pwrSwitcher);
 
 #if OBSW_ADD_MGT == 1
-  createImtqComponents(pwrSwitcher);
+  createImtqComponents(pwrSwitcher, enableHkSets);
 #endif
   createReactionWheelComponents(gpioComIF, pwrSwitcher);
 
 #if OBSW_ADD_BPX_BATTERY_HANDLER == 1
-  createBpxBatteryComponent();
+  createBpxBatteryComponent(enableHkSets);
 #endif
 
 #if OBSW_ADD_STAR_TRACKER == 1
@@ -101,6 +106,6 @@ void ObjectFactory::produce(void* args) {
 
   createMiscComponents();
   createThermalController(*heaterHandler);
-  createAcsController(true);
+  createAcsController(true, enableHkSets);
   satsystem::init();
 }

common/config/eive/definitions.h

@@ -55,6 +55,7 @@ static constexpr uint32_t CFDP_STORE_QUEUE_SIZE = 300;
 
 static constexpr uint32_t MAX_PUS_FUNNEL_QUEUE_DEPTH = 100;
 static constexpr uint32_t MAX_CFDP_FUNNEL_QUEUE_DEPTH = 80;
+static constexpr uint32_t HK_SERVICE_QUEUE_DEPTH = 60;
 
 static constexpr uint32_t MAX_STORED_CMDS_UDP = 150;
 static constexpr uint32_t MAX_STORED_CMDS_TCP = 180;

fsfw

@@ -1 +1 @@
-Subproject commit b814e7198f720cad0fb063f54644d5dbc92c165c
+Subproject commit 314f0fa2cde749ee1021d311e222bb0044cc2e5b

linux/ObjectFactory.cpp

@@ -327,8 +327,8 @@ void ObjectFactory::createScexComponents(std::string uartDev, PowerSwitchIF* pwr
   scexHandler->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
 }
 
-AcsController* ObjectFactory::createAcsController(bool connectSubsystem) {
+AcsController* ObjectFactory::createAcsController(bool connectSubsystem, bool enableHkSets) {
-  auto acsCtrl = new AcsController(objects::ACS_CONTROLLER);
+  auto acsCtrl = new AcsController(objects::ACS_CONTROLLER, enableHkSets);
   if (connectSubsystem) {
     acsCtrl->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
   }

linux/ObjectFactory.h

@@ -30,6 +30,6 @@ void createScexComponents(std::string uartDev, PowerSwitchIF* pwrSwitcher,
 
 void gpioChecker(ReturnValue_t result, std::string output);
 
-AcsController* createAcsController(bool connectSubsystem);
+AcsController* createAcsController(bool connectSubsystem, bool enableHkSets);
 
 }  // namespace ObjectFactory

mission/acs/GyrAdis1650XHandler.cpp

@@ -28,11 +28,7 @@ void GyrAdis1650XHandler::doStartUp() {
     }
     if (breakCountdown.hasTimedOut()) {
       updatePeriodicReply(true, adis1650x::REPLY);
-      if (goToNormalMode) {
-        setMode(MODE_NORMAL);
-      } else {
       setMode(MODE_ON);
-      }
       internalState = InternalState::NONE;
     }
   }
@@ -208,8 +204,6 @@ adis1650x::BurstModes GyrAdis1650XHandler::getBurstMode() {
   return adis1650x::burstModeFromMscCtrl(currentCtrlReg);
 }
 
-void GyrAdis1650XHandler::setToGoToNormalModeImmediately() { goToNormalMode = true; }
-
 void GyrAdis1650XHandler::enablePeriodicPrintouts(bool enable, uint8_t divider) {
   periodicPrintout = enable;
   debugDivider.setDivider(divider);

mission/acs/GyrAdis1650XHandler.h

@@ -21,7 +21,6 @@ class GyrAdis1650XHandler : public DeviceHandlerBase {
                       adis1650x::Type type);
 
   void enablePeriodicPrintouts(bool enable, uint8_t divider);
-  void setToGoToNormalModeImmediately();
 
   // DeviceHandlerBase abstract function implementation
   void doStartUp() override;
@@ -47,7 +46,6 @@ class GyrAdis1650XHandler : public DeviceHandlerBase {
   AdisGyroConfigDataset configDataset;
   double sensitivity = adis1650x::SENSITIVITY_UNSET;
 
-  bool goToNormalMode = false;
   bool warningSwitch = true;
 
   enum class InternalState { NONE, STARTUP, SHUTDOWN };

mission/acs/GyrL3gCustomHandler.cpp

@@ -23,11 +23,7 @@ void GyrL3gCustomHandler::doStartUp() {
 
   if (internalState == InternalState::STARTUP) {
     if (commandExecuted) {
-      if (goNormalModeImmediately) {
+      setMode(MODE_ON);
-        setMode(MODE_NORMAL);
-      } else {
-        setMode(_MODE_TO_ON);
-      }
       internalState = InternalState::NONE;
       commandExecuted = false;
     }
@@ -145,8 +141,6 @@ uint32_t GyrL3gCustomHandler::getTransitionDelayMs(Mode_t from, Mode_t to) {
   return this->transitionDelayMs;
 }
 
-void GyrL3gCustomHandler::setToGoToNormalMode(bool enable) { this->goNormalModeImmediately = true; }
-
 ReturnValue_t GyrL3gCustomHandler::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                            LocalDataPoolManager &poolManager) {
   localDataPoolMap.emplace(l3gd20h::ANG_VELOC_X, new PoolEntry<float>({0.0}));

mission/acs/GyrL3gCustomHandler.h

@@ -32,11 +32,6 @@ class GyrL3gCustomHandler : public DeviceHandlerBase {
    */
   void setAbsoluteLimits(float limitX, float limitY, float limitZ);
 
-  /**
-   * @brief   Configure device handler to go to normal mode immediately
-   */
-  void setToGoToNormalMode(bool enable);
-
  protected:
   /* DeviceHandlerBase overrides */
   ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
@@ -69,7 +64,6 @@ class GyrL3gCustomHandler : public DeviceHandlerBase {
   bool commandExecuted = false;
 
   uint8_t statusReg = 0;
-  bool goNormalModeImmediately = false;
 
   uint8_t ctrlReg1Value = l3gd20h::CTRL_REG_1_VAL;
   uint8_t ctrlReg2Value = l3gd20h::CTRL_REG_2_VAL;

mission/acs/ImtqHandler.cpp

@@ -30,8 +30,9 @@
 static constexpr bool ACTUATION_WIRETAPPING = false;
 
 ImtqHandler::ImtqHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie,
-                         power::Switch_t pwrSwitcher)
+                         power::Switch_t pwrSwitcher, bool enableHkSets)
     : DeviceHandlerBase(objectId, comIF, comCookie),
+      enableHkSets(enableHkSets),
       statusSet(this),
       dipoleSet(*this),
       rawMtmNoTorque(this),
@@ -778,9 +779,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(), false, 10.0));
+      subdp::DiagnosticsHkPeriodicParams(hkDatasetNoTorque.getSid(), enableHkSets, 12.0));
   poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(hkDatasetWithTorque.getSid(), false, 10.0));
+      subdp::DiagnosticsHkPeriodicParams(hkDatasetWithTorque.getSid(), enableHkSets, 12.0));
   poolManager.subscribeForDiagPeriodicPacket(
       subdp::DiagnosticsHkPeriodicParams(rawMtmNoTorque.getSid(), false, 10.0));
   poolManager.subscribeForDiagPeriodicPacket(

mission/acs/ImtqHandler.h

@@ -18,7 +18,7 @@ class ImtqHandler : public DeviceHandlerBase {
   enum NormalPollingMode { UNCALIBRATED = 0, CALIBRATED = 1, BOTH = 2 };
 
   ImtqHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie,
-              power::Switch_t pwrSwitcher);
+              power::Switch_t pwrSwitcher, bool enableHkSets);
   virtual ~ImtqHandler();
 
   void setPollingMode(NormalPollingMode pollMode);
@@ -85,6 +85,7 @@ class ImtqHandler : public DeviceHandlerBase {
 
   enum class InternalState { NONE, STARTUP, SHUTDOWN } internalState = InternalState::NONE;
   bool commandExecuted = false;
+  bool enableHkSets = false;
 
   imtq::Request request{};
 

mission/acs/MgmLis3CustomHandler.cpp

@@ -20,7 +20,7 @@ void MgmLis3CustomHandler::doStartUp() {
   }
   if (internalState == InternalState::STARTUP) {
     if (commandExecuted) {
-      setMode(MODE_NORMAL);
+      setMode(MODE_ON);
       internalState = InternalState::NONE;
       commandExecuted = false;
     }

mission/acs/MgmRm3100CustomHandler.cpp

@@ -25,7 +25,7 @@ void MgmRm3100CustomHandler::doStartUp() {
     if (commandExecuted) {
       commandExecuted = false;
       internalState = InternalState::NONE;
-      setMode(MODE_NORMAL);
+      setMode(MODE_ON);
     }
   }
 }

mission/acs/RwHandler.cpp

@@ -33,6 +33,7 @@ void RwHandler::doStartUp() {
     sif::debug << "RwHandler::doStartUp: Failed to pull enable gpio to high";
   }
   updatePeriodicReply(true, rws::REPLY_ID);
+  statusSet.setReportingEnabled(true);
   setMode(_MODE_TO_ON);
 }
 
@@ -48,6 +49,7 @@ void RwHandler::doShutDown() {
     statusSet.referenceSpeed = 0.0;
     statusSet.state = 0;
     statusSet.setValidity(false, true);
+    statusSet.setReportingEnabled(false);
   }
   {
     PoolReadGuard pg(&tmDataset);
@@ -304,7 +306,7 @@ ReturnValue_t RwHandler::initializeLocalDataPool(localpool::DataPool& localDataP
   localDataPoolMap.emplace(rws::SPI_REG_OVERRUN_ERRORS, new PoolEntry<uint32_t>({0}));
   localDataPoolMap.emplace(rws::SPI_TOTAL_ERRORS, new PoolEntry<uint32_t>({0}));
   poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(statusSet.getSid(), false, 5.0));
+      subdp::DiagnosticsHkPeriodicParams(statusSet.getSid(), false, 12.0));
   poolManager.subscribeForRegularPeriodicPacket(
       subdp::RegularHkPeriodicParams(tmDataset.getSid(), false, 30.0));
   poolManager.subscribeForRegularPeriodicPacket(

mission/acs/SusHandler.cpp

@@ -20,7 +20,7 @@ void SusHandler::doStartUp() {
   }
   if (internalState == InternalState::STARTUP) {
     if (commandExecuted) {
-      setMode(MODE_NORMAL);
+      setMode(MODE_ON);
       internalState = InternalState::NONE;
       commandExecuted = false;
     }

mission/acs/str/StarTrackerHandler.cpp

@@ -260,6 +260,7 @@ void StarTrackerHandler::doStartUp() {
     default:
       return;
   }
+  solutionSet.setReportingEnabled(true);
   startupState = StartupState::DONE;
   internalState = InternalState::IDLE;
   setMode(_MODE_TO_ON);
@@ -271,6 +272,7 @@ void StarTrackerHandler::doShutDown() {
   internalState = InternalState::IDLE;
   startupState = StartupState::IDLE;
   bootState = FwBootState::NONE;
+  solutionSet.setReportingEnabled(false);
   setMode(_MODE_POWER_DOWN);
 }
 
@@ -1270,7 +1272,7 @@ ReturnValue_t StarTrackerHandler::initializeLocalDataPool(localpool::DataPool& l
   poolManager.subscribeForRegularPeriodicPacket(
       subdp::RegularHkPeriodicParams(interfaceSet.getSid(), false, 10.0));
   poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(solutionSet.getSid(), false, 5.0));
+      subdp::DiagnosticsHkPeriodicParams(solutionSet.getSid(), false, 12.0));
   poolManager.subscribeForRegularPeriodicPacket(
       subdp::RegularHkPeriodicParams(cameraSet.getSid(), false, 10.0));
   poolManager.subscribeForRegularPeriodicPacket(

mission/com/CcsdsIpCoreHandler.h

@@ -36,6 +36,10 @@ struct PtmeGpios {
  *          programmable logic of the Q7S.
  *
  * @details
+ * From a system view, OFF means that the transmitter is off, on means that the transmitter is on.
+ * The handler will only take care of the IP configuration, the actual swithing and configuration
+ * of the COM hardware (Syrlinks for the EIVE project) will be done in a separate device handler.
+ *
  * After reboot default CADU bitrate is always set to 100 kbps (results in downlink rate
  * of 200 kbps due to convolutional code added by syrlinks transceiver). The IP core handler exposes
  * a parameter to enable the priority selection mode for the PTME core.

mission/com/SyrlinksHandler.cpp

@@ -641,12 +641,16 @@ ReturnValue_t SyrlinksHandler::initializeLocalDataPool(localpool::DataPool& loca
   localDataPoolMap.emplace(syrlinks::TEMP_BASEBAND_BOARD, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(syrlinks::TEMP_POWER_AMPLIFIER, new PoolEntry<float>({0}));
 
+  bool enableHkSets = false;
+#if OBSW_ENABLE_PERIODIC_HK == 1
+  enableHkSets = true;
+#endif
   poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(txDataset.getSid(), false, 5.0));
+      subdp::DiagnosticsHkPeriodicParams(txDataset.getSid(), enableHkSets, 60.0));
   poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(rxDataset.getSid(), false, 5.0));
+      subdp::DiagnosticsHkPeriodicParams(rxDataset.getSid(), enableHkSets, 60.0));
   poolManager.subscribeForRegularPeriodicPacket(
-      subdp::RegularHkPeriodicParams(temperatureSet.getSid(), false, 10.0));
+      subdp::RegularHkPeriodicParams(temperatureSet.getSid(), enableHkSets, 20.0));
   return returnvalue::OK;
 }
 

mission/controller/AcsController.cpp

@@ -4,8 +4,9 @@
 #include <mission/acs/defs.h>
 #include <mission/config/torquer.h>
 
-AcsController::AcsController(object_id_t objectId)
+AcsController::AcsController(object_id_t objectId, bool enableHkSets)
     : ExtendedControllerBase(objectId),
+      enableHkSets(enableHkSets),
       guidance(&acsParameters),
       safeCtrl(&acsParameters),
       ptgCtrl(&acsParameters),
@@ -574,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(), false, 5.0});
+  poolManager.subscribeForRegularPeriodicPacket({mgmDataProcessed.getSid(), enableHkSets, 12.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);
@@ -605,7 +606,7 @@ 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(), false, 5.0});
+  poolManager.subscribeForRegularPeriodicPacket({susDataProcessed.getSid(), enableHkSets, 12.0});
   // GYR Raw
   localDataPoolMap.emplace(acsctrl::PoolIds::GYR_0_ADIS, &gyr0VecRaw);
   localDataPoolMap.emplace(acsctrl::PoolIds::GYR_1_L3, &gyr1VecRaw);
@@ -618,30 +619,30 @@ ReturnValue_t AcsController::initializeLocalDataPool(localpool::DataPool &localD
   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(), false, 5.0});
+  poolManager.subscribeForDiagPeriodicPacket({gyrDataProcessed.getSid(), enableHkSets, 12.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(), false, 5.0});
+  poolManager.subscribeForRegularPeriodicPacket({gpsDataProcessed.getSid(), enableHkSets, 12.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(), false, 5.0});
+  poolManager.subscribeForDiagPeriodicPacket({mekfData.getSid(), enableHkSets, 12.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(), false, 5.0});
+  poolManager.subscribeForRegularPeriodicPacket({ctrlValData.getSid(), enableHkSets, 12.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(), false, 5.0});
+  poolManager.subscribeForRegularPeriodicPacket({actuatorCmdData.getSid(), enableHkSets, 12.0});
   return returnvalue::OK;
 }
 

mission/controller/AcsController.h

@@ -28,7 +28,7 @@ class AcsController : public ExtendedControllerBase, public ReceivesParameterMes
  public:
   static constexpr dur_millis_t INIT_DELAY = 500;
 
-  AcsController(object_id_t objectId);
+  AcsController(object_id_t objectId, bool enableHkSets);
 
   MessageQueueId_t getCommandQueue() const;
   ReturnValue_t getParameter(uint8_t domainId, uint8_t parameterId,
@@ -46,6 +46,8 @@ class AcsController : public ExtendedControllerBase, public ReceivesParameterMes
   static constexpr double RW_OFF_TORQUE[4] = {0.0, 0.0, 0.0, 0.0};
   static constexpr int32_t RW_OFF_SPEED[4] = {0, 0, 0, 0};
 
+  bool enableHkSets = false;
+
   AcsParameters acsParameters;
   SensorProcessing sensorProcessing;
   Navigation navigation;

mission/controller/ThermalController.cpp

@@ -223,14 +223,19 @@ ReturnValue_t ThermalController::initializeLocalDataPool(localpool::DataPool& lo
   localDataPoolMap.emplace(tcsCtrl::HEATER_SWITCH_LIST, &heaterSwitchStates);
   localDataPoolMap.emplace(tcsCtrl::HEATER_CURRENT, &heaterCurrent);
 
+  bool enableHkSets = false;
+#if OBSW_ENABLE_PERIODIC_HK == 1
+  enableHkSets = true;
+#endif
   poolManager.subscribeForRegularPeriodicPacket(
-      subdp::RegularHkPeriodicParams(sensorTemperatures.getSid(), false, 10.0));
+      subdp::RegularHkPeriodicParams(sensorTemperatures.getSid(), enableHkSets, 60.0));
   poolManager.subscribeForRegularPeriodicPacket(
-      subdp::RegularHkPeriodicParams(susTemperatures.getSid(), false, 10.0));
+      subdp::RegularHkPeriodicParams(susTemperatures.getSid(), enableHkSets, 60.0));
   poolManager.subscribeForRegularPeriodicPacket(
-      subdp::RegularHkPeriodicParams(deviceTemperatures.getSid(), false, 10.0));
+      subdp::RegularHkPeriodicParams(deviceTemperatures.getSid(), enableHkSets, 60.0));
   poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(heaterInfo.getSid(), false, 10.0));
+      subdp::DiagnosticsHkPeriodicParams(heaterInfo.getSid(), enableHkSets, 30.0));
+
   return returnvalue::OK;
 }
 

mission/genericFactory.cpp

@@ -234,7 +234,7 @@ void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_, PusTmFun
   new Service2DeviceAccess(objects::PUS_SERVICE_2_DEVICE_ACCESS, config::EIVE_PUS_APID,
                            pus::PUS_SERVICE_2, 3, 10);
   new Service3Housekeeping(objects::PUS_SERVICE_3_HOUSEKEEPING, config::EIVE_PUS_APID,
-                           pus::PUS_SERVICE_3);
+                           pus::PUS_SERVICE_3, config::HK_SERVICE_QUEUE_DEPTH);
   new Service5EventReporting(
       PsbParams(objects::PUS_SERVICE_5_EVENT_REPORTING, config::EIVE_PUS_APID, pus::PUS_SERVICE_5),
       40, 120);

mission/power/AcuHandler.cpp

@@ -3,8 +3,8 @@
 #include "OBSWConfig.h"
 
 ACUHandler::ACUHandler(object_id_t objectId, object_id_t comIF, CookieIF *comCookie,
-                       FailureIsolationBase *customFdir)
+                       FailureIsolationBase *customFdir, bool enableHkSets)
-    : GomspaceDeviceHandler(objectId, comIF, comCookie, cfg, customFdir),
+    : GomspaceDeviceHandler(objectId, comIF, comCookie, cfg, customFdir, enableHkSets),
       coreHk(this),
       auxHk(this) {
   cfg.maxConfigTableAddress = ACU::MAX_CONFIGTABLE_ADDRESS;
@@ -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(), false, 10.0));
+      subdp::DiagnosticsHkPeriodicParams(coreHk.getSid(), enableHkSets, 20.0));
   poolManager.subscribeForRegularPeriodicPacket(
-      subdp::RegularHkPeriodicParams(auxHk.getSid(), false, 30.0));
+      subdp::RegularHkPeriodicParams(auxHk.getSid(), enableHkSets, 3000.0));
   return returnvalue::OK;
 }
 

mission/power/AcuHandler.h

@@ -13,7 +13,7 @@
 class ACUHandler : public GomspaceDeviceHandler {
  public:
   ACUHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie,
-             FailureIsolationBase* customFdir);
+             FailureIsolationBase* customFdir, bool enableHkSets);
   virtual ~ACUHandler();
 
   void setDebugMode(bool enable);

mission/power/BpxBatteryHandler.cpp

@@ -1,8 +1,12 @@
 #include <fsfw/datapool/PoolReadGuard.h>
 #include <mission/power/BpxBatteryHandler.h>
 
-BpxBatteryHandler::BpxBatteryHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie)
+BpxBatteryHandler::BpxBatteryHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie,
-    : DeviceHandlerBase(objectId, comIF, comCookie), hkSet(this), cfgSet(this) {}
+                                     bool enableHkSets)
+    : DeviceHandlerBase(objectId, comIF, comCookie),
+      enableHkSets(enableHkSets),
+      hkSet(this),
+      cfgSet(this) {}
 
 BpxBatteryHandler::~BpxBatteryHandler() {}
 
@@ -267,8 +271,9 @@ ReturnValue_t BpxBatteryHandler::initializeLocalDataPool(localpool::DataPool& lo
   localDataPoolMap.emplace(BpxBattery::BATTERY_HEATER_MODE, &battheatMode);
   localDataPoolMap.emplace(BpxBattery::BATTHEAT_LOW_LIMIT, &battheatLow);
   localDataPoolMap.emplace(BpxBattery::BATTHEAT_HIGH_LIMIT, &battheatHigh);
+
   poolManager.subscribeForRegularPeriodicPacket(
-      subdp::RegularHkPeriodicParams(hkSet.getSid(), false, 30.0));
+      subdp::RegularHkPeriodicParams(hkSet.getSid(), enableHkSets, 20.0));
   poolManager.subscribeForRegularPeriodicPacket(
       subdp::RegularHkPeriodicParams(cfgSet.getSid(), false, 30.0));
   return returnvalue::OK;

mission/power/BpxBatteryHandler.h

@@ -7,7 +7,8 @@
 
 class BpxBatteryHandler : public DeviceHandlerBase {
  public:
-  BpxBatteryHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie);
+  BpxBatteryHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie,
+                    bool enableHkSets);
   virtual ~BpxBatteryHandler();
 
   void setToGoToNormalMode(bool enable);
@@ -19,6 +20,7 @@ class BpxBatteryHandler : public DeviceHandlerBase {
     IDLE = 1,
   };
 
+  bool enableHkSets = false;
   States state = States::CHECK_COM;
   bool commandExecuted = false;
   bool debugMode = false;

mission/power/GomspaceDeviceHandler.cpp

@@ -12,8 +12,10 @@ using namespace GOMSPACE;
 
 GomspaceDeviceHandler::GomspaceDeviceHandler(object_id_t objectId, object_id_t comIF,
                                              CookieIF* comCookie, TableConfig& tableConfig,
-                                             FailureIsolationBase* customFdir)
+                                             FailureIsolationBase* customFdir, bool enableHkSets)
-    : DeviceHandlerBase(objectId, comIF, comCookie, customFdir), tableCfg(tableConfig) {
+    : DeviceHandlerBase(objectId, comIF, comCookie, customFdir),
+      enableHkSets(enableHkSets),
+      tableCfg(tableConfig) {
   if (comCookie == nullptr) {
     sif::error << "GomspaceDeviceHandler::GomspaceDeviceHandler: Invalid com cookie" << std::endl;
   }

mission/power/GomspaceDeviceHandler.h

@@ -45,7 +45,8 @@ class GomspaceDeviceHandler : public DeviceHandlerBase {
    * 							device.
    */
   GomspaceDeviceHandler(object_id_t objectId, object_id_t comIF, CookieIF *comCookie,
-                        TableConfig &tableConfig, FailureIsolationBase *customFdir);
+                        TableConfig &tableConfig, FailureIsolationBase *customFdir,
+                        bool enableHkSets);
   virtual ~GomspaceDeviceHandler();
 
   /**
@@ -59,6 +60,7 @@ class GomspaceDeviceHandler : public DeviceHandlerBase {
   static const uint8_t PARAM_SET_OK = 1;
   static const uint8_t PING_REPLY_SIZE = 2;
 
+  bool enableHkSets = false;
   uint8_t rememberRequestedSize = 0;
   uint8_t rememberCommandId = GOMSPACE::NONE;
   uint8_t cspPacket[MAX_PACKET_LEN];

mission/power/P60DockHandler.cpp

@@ -4,8 +4,8 @@
 #include "OBSWConfig.h"
 
 P60DockHandler::P60DockHandler(object_id_t objectId, object_id_t comIF, CookieIF *comCookie,
-                               FailureIsolationBase *customFdir)
+                               FailureIsolationBase *customFdir, bool enableHkSets)
-    : GomspaceDeviceHandler(objectId, comIF, comCookie, cfg, customFdir),
+    : GomspaceDeviceHandler(objectId, comIF, comCookie, cfg, customFdir, enableHkSets),
       coreHk(this),
       auxHk(this) {
   cfg.maxConfigTableAddress = P60Dock::MAX_CONFIGTABLE_ADDRESS;
@@ -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(), false, 10.0));
+      subdp::DiagnosticsHkPeriodicParams(coreHk.getSid(), enableHkSets, 20.0));
   poolManager.subscribeForRegularPeriodicPacket(
-      subdp::RegularHkPeriodicParams(auxHk.getSid(), false, 30.0));
+      subdp::RegularHkPeriodicParams(auxHk.getSid(), enableHkSets, 3000.0));
   return returnvalue::OK;
 }
 

mission/power/P60DockHandler.h

@@ -22,7 +22,7 @@ class P60DockHandler : public GomspaceDeviceHandler {
   static constexpr Event BATT_MODE_CHANGED = event::makeEvent(SUBSYSTEM_ID, 2, severity::MEDIUM);
 
   P60DockHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie,
-                 FailureIsolationBase* customFdir);
+                 FailureIsolationBase* customFdir, bool enableHkSets);
   virtual ~P60DockHandler();
 
   void setDebugMode(bool enable);

mission/power/Pdu1Handler.cpp

@@ -5,8 +5,8 @@
 #include "devices/powerSwitcherList.h"
 
 Pdu1Handler::Pdu1Handler(object_id_t objectId, object_id_t comIF, CookieIF *comCookie,
-                         FailureIsolationBase *customFdir)
+                         FailureIsolationBase *customFdir, bool enableHkSets)
-    : GomspaceDeviceHandler(objectId, comIF, comCookie, cfg, customFdir),
+    : GomspaceDeviceHandler(objectId, comIF, comCookie, cfg, customFdir, enableHkSets),
       coreHk(this),
       auxHk(this) {
   initPduConfigTable();
@@ -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(), false, 10.0));
+      subdp::DiagnosticsHkPeriodicParams(coreHk.getSid(), enableHkSets, 20.0));
   poolManager.subscribeForRegularPeriodicPacket(
-      subdp::RegularHkPeriodicParams(auxHk.getSid(), false, 30.0));
+      subdp::RegularHkPeriodicParams(auxHk.getSid(), enableHkSets, 3000.0));
   return returnvalue::OK;
 }
 

mission/power/Pdu1Handler.h

@@ -22,7 +22,7 @@
 class Pdu1Handler : public GomspaceDeviceHandler {
  public:
   Pdu1Handler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie,
-              FailureIsolationBase* customFdir);
+              FailureIsolationBase* customFdir, bool enableHkSets);
   virtual ~Pdu1Handler();
 
   virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,

mission/power/Pdu2Handler.cpp

@@ -5,8 +5,8 @@
 #include "devices/powerSwitcherList.h"
 
 Pdu2Handler::Pdu2Handler(object_id_t objectId, object_id_t comIF, CookieIF *comCookie,
-                         FailureIsolationBase *customFdir)
+                         FailureIsolationBase *customFdir, bool enableHkSets)
-    : GomspaceDeviceHandler(objectId, comIF, comCookie, cfg, customFdir),
+    : GomspaceDeviceHandler(objectId, comIF, comCookie, cfg, customFdir, enableHkSets),
       coreHk(this),
       auxHk(this) {
   initPduConfigTable();
@@ -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(), false, 10.0));
+      subdp::DiagnosticsHkPeriodicParams(coreHk.getSid(), enableHkSets, 10.0));
   poolManager.subscribeForRegularPeriodicPacket(
-      subdp::RegularHkPeriodicParams(auxHk.getSid(), false, 30.0));
+      subdp::RegularHkPeriodicParams(auxHk.getSid(), enableHkSets, 30.0));
   return returnvalue::OK;
 }
 

mission/power/Pdu2Handler.h

@@ -21,7 +21,7 @@
 class Pdu2Handler : public GomspaceDeviceHandler {
  public:
   Pdu2Handler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie,
-              FailureIsolationBase* customFdir);
+              FailureIsolationBase* customFdir, bool enableHkSets);
   virtual ~Pdu2Handler();
 
   virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,

mission/tmtc/PersistentLogTmStoreTask.cpp

@@ -33,12 +33,8 @@ ReturnValue_t PersistentLogTmStoreTask::performOperation(uint8_t opCode) {
     stateHandlingForStore(handleOneStore(stores.miscStore, miscStoreContext));
     if (not someonesBusy) {
       TaskFactory::delayTask(100);
-    } else /* and graceDelayDuringDumping.hasTimedOut()*/ {
+    } else if (someFileWasSwapped) {
-      if (someFileWasSwapped) {
+      TaskFactory::delayTask(10);
-        TaskFactory::delayTask(20);
-      }
-      //      TaskFactory::delayTask(2);
-      //      graceDelayDuringDumping.resetTimer();
     }
   }
 }

mission/tmtc/PersistentSingleTmStoreTask.cpp

@@ -18,14 +18,8 @@ ReturnValue_t PersistentSingleTmStoreTask::performOperation(uint8_t opCode) {
     bool busy = handleOneStore(storeWithQueue, dumpContext);
     if (not busy) {
       TaskFactory::delayTask(100);
-    } else {
+    } else if (fileHasSwapped) {
-      if (fileHasSwapped) {
+      TaskFactory::delayTask(10);
-        TaskFactory::delayTask(20);
-      }
-      //      if (fileHasSwapped and graceDelayDuringDumping.hasTimedOut()) {
-      //        TaskFactory::delayTask(2);
-      //        graceDelayDuringDumping.resetTimer();
-      //      }
     }
   }
 }

tmtc

@@ -1 +1 @@
-Subproject commit be7b3f54c7d4dc5735d5ec98f28c869c752d75cb
+Subproject commit f2897fa6060e178ef8d11c9d29faa058896c9253