.idea/cmake.xml

@@ -2,7 +2,6 @@
 <project version="4">
   <component name="CMakeSharedSettings">
     <configurations>
-      <configuration PROFILE_NAME="Debug" ENABLED="true" CONFIG_NAME="Debug" NO_GENERATOR="true" />
       <configuration PROFILE_NAME="Debug Q7S" ENABLED="true" CONFIG_NAME="Debug" TOOLCHAIN_NAME="Q7S" GENERATION_OPTIONS="-DTGT_BSP=&quot;arm/q7s&quot;" NO_GENERATOR="true">
         <ADDITIONAL_GENERATION_ENVIRONMENT>
           <envs>

CHANGELOG.md

@@ -100,6 +100,7 @@ will consitute of a breaking change warranting a new major release:
 
 ## Added
 
+- Version of thermal controller which performs basic control tasks.
 - The event `MEKF_RECOVERY` will be triggered in case the `MEKF` does manage to recover itself.
 - The persistent TM stores now have low priorities and behave like background threads now. This
   should prevent them from blocking or slowing down the system even during dumps
@@ -111,6 +112,8 @@ will consitute of a breaking change warranting a new major release:
 
 ## Changed
 
+- EIVE system fallback and COM system fallback: Perform general subsystem handling first, then
+  event reception, and finally any new transition handling.
 - Rework FSFW OSALs to properly support regular scheduling (NICE priorities) and real-time
   scheduling.
 - STR: Move datalink layer to `StrComHandler` completely. DLL is now completely hidden from
@@ -134,6 +137,7 @@ will consitute of a breaking change warranting a new major release:
 - Bugfix for STR: Some action commands wrongfully declined.
 - STR: No normal command handling while a special request like an image upload is active.
 - RS485 data line was not enabled when the transmitter was switched on.
+>>>>>>> origin/develop
 
 # [v1.39.0] 2023-03-21
 

CMakeLists.txt

@@ -113,7 +113,7 @@ set(OBSW_ADD_TCS_CTRL
     1
     CACHE STRING "Add TCS controllers")
 set(OBSW_ADD_HEATERS
-    ${INIT_VAL}
+    1
     CACHE STRING "Add TCS heaters")
 set(OBSW_ADD_PLOC_SUPERVISOR
     ${INIT_VAL}

bsp_hosted/ObjectFactory.cpp

@@ -11,6 +11,7 @@
 #include "../mission/utility/DummySdCardManager.h"
 #include "OBSWConfig.h"
 #include "fsfw/platform.h"
+#include "fsfw/power/PowerSwitchIF.h"
 #include "fsfw_tests/integration/task/TestTask.h"
 
 #if OBSW_ADD_TMTC_UDP_SERVER == 1
@@ -67,6 +68,12 @@ void ObjectFactory::produce(void* args) {
 
   auto* dummyGpioIF = new DummyGpioIF();
   auto* dummySwitcher = new DummyPowerSwitcher(objects::PCDU_HANDLER, 18, 0);
+  std::vector<ReturnValue_t> switcherList;
+  auto initVal = PowerSwitchIF::SWITCH_OFF;
+  for (unsigned i = 0; i < 18; i++) {
+    switcherList.emplace_back(initVal);
+  }
+  dummySwitcher->setInitialSwitcherList(switcherList);
 #ifdef PLATFORM_UNIX
   new SerialComIF(objects::UART_COM_IF);
 #if OBSW_ADD_PLOC_MPSOC == 1

bsp_hosted/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
  * @brief    Auto-generated event translation file. Contains 284 translations.
  * @details
- * Generated on: 2023-04-01 15:26:43
+ * Generated on: 2023-04-01 16:00:01
  */
 #include "translateEvents.h"
 
@@ -272,10 +272,10 @@ const char *I2C_UNAVAILABLE_REBOOT_STRING = "I2C_UNAVAILABLE_REBOOT";
 const char *NO_VALID_SENSOR_TEMPERATURE_STRING = "NO_VALID_SENSOR_TEMPERATURE";
 const char *NO_HEALTHY_HEATER_AVAILABLE_STRING = "NO_HEALTHY_HEATER_AVAILABLE";
 const char *SYRLINKS_OVERHEATING_STRING = "SYRLINKS_OVERHEATING";
-const char *PLOC_OVERHEATING_STRING = "PLOC_OVERHEATING";
 const char *OBC_OVERHEATING_STRING = "OBC_OVERHEATING";
-const char *HPA_OVERHEATING_STRING = "HPA_OVERHEATING";
+const char *CAMERA_OVERHEATING_STRING = "CAMERA_OVERHEATING";
-const char *PLPCDU_OVERHEATING_STRING = "PLPCDU_OVERHEATING";
+const char *PCDU_SYSTEM_OVERHEATING_STRING = "PCDU_SYSTEM_OVERHEATING";
+const char *HEATER_NOT_OFF_FOR_OFF_MODE_STRING = "HEATER_NOT_OFF_FOR_OFF_MODE";
 const char *TX_TIMER_EXPIRED_STRING = "TX_TIMER_EXPIRED";
 const char *BIT_LOCK_TX_ON_STRING = "BIT_LOCK_TX_ON";
 const char *POSSIBLE_FILE_CORRUPTION_STRING = "POSSIBLE_FILE_CORRUPTION";
@@ -824,14 +824,14 @@ const char *translateEvents(Event event) {
       return NO_HEALTHY_HEATER_AVAILABLE_STRING;
     case (14102):
       return SYRLINKS_OVERHEATING_STRING;
-    case (14103):
-      return PLOC_OVERHEATING_STRING;
     case (14104):
       return OBC_OVERHEATING_STRING;
     case (14105):
-      return HPA_OVERHEATING_STRING;
+      return CAMERA_OVERHEATING_STRING;
     case (14106):
-      return PLPCDU_OVERHEATING_STRING;
+      return PCDU_SYSTEM_OVERHEATING_STRING;
+    case (14107):
+      return HEATER_NOT_OFF_FOR_OFF_MODE_STRING;
     case (14201):
       return TX_TIMER_EXPIRED_STRING;
     case (14202):

bsp_hosted/fsfwconfig/objects/translateObjects.cpp

@@ -2,7 +2,7 @@
  * @brief  Auto-generated object translation file.
  * @details
  * Contains 171 translations.
- * Generated on: 2023-04-01 15:26:43
+ * Generated on: 2023-04-01 16:00:01
  */
 #include "translateObjects.h"
 

bsp_hosted/scheduling.cpp

@@ -156,6 +156,10 @@ void scheduling::initTasks() {
   if (result != returnvalue::OK) {
     scheduling::printAddObjectError("THERMAL_CONTROLLER", objects::THERMAL_CONTROLLER);
   }
+  result = thermalTask->addComponent(objects::HEATER_HANDLER);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("HEATER_HANDLER", objects::HEATER_HANDLER);
+  }
 
   FixedTimeslotTaskIF* pstTask = factory->createFixedTimeslotTask(
       "DUMMY_PST", 75, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.5, missedDeadlineFunc);
@@ -193,7 +197,8 @@ void scheduling::initTasks() {
 #endif /* OBSW_ADD_TEST_CODE == 1 */
 
   PeriodicTaskIF* dummyTask = factory->createPeriodicTask(
-      "DUMMY_TASK", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
+      "DUMMY_TASK", 35, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
+  dummyTask->addComponent(objects::THERMAL_TEMP_INSERTER);
   scheduling::scheduleTmpTempSensors(dummyTask);
   scheduling::scheduleRtdSensors(dummyTask);
   dummyTask->addComponent(objects::SUS_0_N_LOC_XFYFZM_PT_XF);

bsp_q7s/core/ObjectFactory.cpp

@@ -592,7 +592,7 @@ void ObjectFactory::createSolarArrayDeploymentComponents(PowerSwitchIF& pwrSwitc
   }
 
   new SolarArrayDeploymentHandler(objects::SOLAR_ARRAY_DEPL_HANDLER, gpioIF, pwrSwitcher,
-                                  pcdu::Switches::PDU2_CH5_DEPLOYMENT_MECHANISM_8V,
+                                  power::Switches::PDU2_CH5_DEPLOYMENT_MECHANISM_8V,
                                   gpioIds::DEPLSA1, gpioIds::DEPLSA2, *SdCardManager::instance());
 }
 
@@ -608,7 +608,7 @@ void ObjectFactory::createSyrlinksComponents(PowerSwitchIF* pwrSwitcher) {
   auto syrlinksFdir = new SyrlinksFdir(objects::SYRLINKS_HANDLER);
   auto syrlinksHandler =
       new SyrlinksHandler(objects::SYRLINKS_HANDLER, objects::SYRLINKS_COM_HANDLER,
-                          syrlinksUartCookie, pcdu::PDU1_CH1_SYRLINKS_12V, syrlinksFdir);
+                          syrlinksUartCookie, power::PDU1_CH1_SYRLINKS_12V, syrlinksFdir);
   syrlinksHandler->setPowerSwitcher(pwrSwitcher);
   syrlinksHandler->connectModeTreeParent(*syrlinksAssy);
 #if OBSW_DEBUG_SYRLINKS == 1
@@ -620,7 +620,7 @@ void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwit
   using namespace gpio;
   std::stringstream consumer;
   auto* camSwitcher =
-      new CamSwitcher(objects::CAM_SWITCHER, pwrSwitch, pcdu::PDU2_CH8_PAYLOAD_CAMERA);
+      new CamSwitcher(objects::CAM_SWITCHER, pwrSwitch, power::PDU2_CH8_PAYLOAD_CAMERA);
   camSwitcher->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
 #if OBSW_ADD_PLOC_MPSOC == 1
   consumer << "0x" << std::hex << objects::PLOC_MPSOC_HANDLER;
@@ -653,7 +653,7 @@ void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwit
   auto supvHelper = new PlocSupvUartManager(objects::PLOC_SUPERVISOR_HELPER);
   auto* supvHandler = new PlocSupervisorHandler(objects::PLOC_SUPERVISOR_HANDLER, supervisorCookie,
                                                 Gpio(gpioIds::ENABLE_SUPV_UART, gpioComIF),
-                                                pcdu::PDU1_CH6_PLOC_12V, *supvHelper);
+                                                power::PDU1_CH6_PLOC_12V, *supvHelper);
   supvHandler->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
 #endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
   static_cast<void>(consumer);
@@ -730,7 +730,7 @@ void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF,
     rws[idx] = rwHandler;
   }
 
-  createRwAssy(*pwrSwitcher, pcdu::Switches::PDU2_CH2_RW_5V, rws, rwIds);
+  createRwAssy(*pwrSwitcher, power::Switches::PDU2_CH2_RW_5V, rws, rwIds);
 #endif /* OBSW_ADD_RW == 1 */
 }
 
@@ -968,7 +968,7 @@ void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) {
   auto strFdir = new StrFdir(objects::STAR_TRACKER);
   auto starTracker =
       new StarTrackerHandler(objects::STAR_TRACKER, objects::STR_COM_IF, starTrackerCookie,
-                             paramJsonFile, strComIF, pcdu::PDU1_CH2_STAR_TRACKER_5V);
+                             paramJsonFile, strComIF, power::PDU1_CH2_STAR_TRACKER_5V);
   starTracker->setPowerSwitcher(pwrSwitcher);
   starTracker->connectModeTreeParent(*strAssy);
   starTracker->setCustomFdir(strFdir);
@@ -981,7 +981,7 @@ void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enable
   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,
-                                     pcdu::Switches::PDU1_CH3_MGT_5V, enableHkSets);
+                                     power::Switches::PDU1_CH3_MGT_5V, enableHkSets);
   imtqHandler->enableThermalModule(ThermalStateCfg());
   imtqHandler->setPowerSwitcher(pwrSwitcher);
   imtqHandler->connectModeTreeParent(*imtqAssy);

bsp_q7s/em/emObjectFactory.cpp

@@ -137,8 +137,8 @@ void ObjectFactory::produce(void* args) {
                        pcdu::Switches::PDU1_CH5_SOLAR_CELL_EXP_5V);
 #endif
   createAcsController(true, enableHkSets);
-  HeaterHandler* heaterHandler = nullptr;
+  HeaterHandler* heaterHandler;
-  ObjectFactory::createGenericHeaterComponents(*gpioComIF, *pwrSwitcher, heaterHandler);
+  createHeaterComponents(gpioComIF, pwrSwitcher, healthTable, heaterHandler);
   createThermalController(*heaterHandler);
   satsystem::init();
 }

bsp_q7s/fmObjectFactory.cpp

@@ -97,7 +97,7 @@ void ObjectFactory::produce(void* args) {
 
 #if OBSW_ADD_SCEX_DEVICE == 1
   createScexComponents(q7s::UART_SCEX_DEV, pwrSwitcher, *SdCardManager::instance(), false,
-                       pcdu::Switches::PDU1_CH5_SOLAR_CELL_EXP_5V);
+                       power::Switches::PDU1_CH5_SOLAR_CELL_EXP_5V);
 #endif
   /* Test Task */
 #if OBSW_ADD_TEST_CODE == 1

dummies/GyroAdisDummy.cpp

@@ -46,7 +46,7 @@ ReturnValue_t GyroAdisDummy::initializeLocalDataPool(localpool::DataPool &localD
   localDataPoolMap.emplace(adis1650x::ACCELERATION_X, new PoolEntry<double>({0.0}));
   localDataPoolMap.emplace(adis1650x::ACCELERATION_Y, new PoolEntry<double>({0.0}));
   localDataPoolMap.emplace(adis1650x::ACCELERATION_Z, new PoolEntry<double>({0.0}));
-  localDataPoolMap.emplace(adis1650x::TEMPERATURE, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(adis1650x::TEMPERATURE, new PoolEntry<float>({10.0}, true));
 
   return returnvalue::OK;
 }

dummies/Max31865Dummy.cpp

@@ -1,5 +1,7 @@
 #include "Max31865Dummy.h"
 
+#include "fsfw/datapool/PoolReadGuard.h"
+
 using namespace returnvalue;
 
 Max31865Dummy::Max31865Dummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
@@ -28,15 +30,20 @@ ReturnValue_t Max31865Dummy::initializeLocalDataPool(localpool::DataPool &localD
                                                      LocalDataPoolManager &poolManager) {
   using namespace MAX31865;
   localDataPoolMap.emplace(static_cast<lp_id_t>(PoolIds::RTD_VALUE), new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(static_cast<lp_id_t>(PoolIds::TEMPERATURE_C), new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(static_cast<lp_id_t>(PoolIds::TEMPERATURE_C),
+                           new PoolEntry<float>({10.0}, true));
   localDataPoolMap.emplace(static_cast<lp_id_t>(PoolIds::LAST_FAULT_BYTE),
                            new PoolEntry<uint8_t>({0}));
   localDataPoolMap.emplace(static_cast<lp_id_t>(PoolIds::FAULT_BYTE), new PoolEntry<uint8_t>({0}));
   return OK;
 }
 
-void Max31865Dummy::setTemperature(float temperature) {
+void Max31865Dummy::setTemperature(float temperature, bool valid) {
-  set.temperatureCelcius.value = temperature;
+  PoolReadGuard pg(&set);
+  if (pg.getReadResult() == returnvalue::OK) {
+    set.temperatureCelcius.value = temperature;
+    set.setValidity(valid, true);
+  }
 }
 
 LocalPoolDataSetBase *Max31865Dummy::getDataSetHandle(sid_t sid) { return &set; }

dummies/Max31865Dummy.h

@@ -10,7 +10,7 @@ class Max31865Dummy : public DeviceHandlerBase {
   Max31865Dummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
   Max31865Dummy(object_id_t objectId, CookieIF *comCookie);
 
-  void setTemperature(float temperature);
+  void setTemperature(float temperature, bool setValid);
 
  private:
   MAX31865::PrimarySet set;

dummies/MgmLIS3MDLDummy.cpp

@@ -40,7 +40,7 @@ uint32_t MgmLIS3MDLDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) {
 
 ReturnValue_t MgmLIS3MDLDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                        LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(mgmLis3::TEMPERATURE_CELCIUS, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(mgmLis3::TEMPERATURE_CELCIUS, new PoolEntry<float>({10.0}, true));
   localDataPoolMap.emplace(mgmLis3::FIELD_STRENGTHS,
                            new PoolEntry<float>({1.02, 0.56, -0.78}, true));
   return returnvalue::OK;

dummies/P60DockDummy.cpp

@@ -2,6 +2,8 @@
 
 #include <mission/power/gsDefs.h>
 
+#include "fsfw/datapool/PoolReadGuard.h"
+
 P60DockDummy::P60DockDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
     : DeviceHandlerBase(objectId, comif, comCookie) {}
 

dummies/P60DockDummy.h

@@ -3,6 +3,8 @@
 
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
 
+#include "mission/power/gsDefs.h"
+
 class P60DockDummy : public DeviceHandlerBase {
  public:
   static const DeviceCommandId_t SIMPLE_COMMAND = 1;
@@ -15,6 +17,8 @@ class P60DockDummy : public DeviceHandlerBase {
   virtual ~P60DockDummy();
 
  protected:
+  lp_var_t<float> temp1 = lp_var_t<float>(this, P60Dock::pool::P60DOCK_TEMPERATURE_1);
+  lp_var_t<float> temp2 = lp_var_t<float>(this, P60Dock::pool::P60DOCK_TEMPERATURE_2);
   void doStartUp() override;
   void doShutDown() override;
   ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;

dummies/PlocMpsocDummy.h

@@ -2,6 +2,8 @@
 
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
 
+#include "mission/power/defs.h"
+
 class PlocMpsocDummy : public DeviceHandlerBase {
  public:
   static const DeviceCommandId_t SIMPLE_COMMAND = 1;

dummies/PlocSupervisorDummy.cpp

@@ -1,8 +1,10 @@
 #include "PlocSupervisorDummy.h"
 
 PlocSupervisorDummy::PlocSupervisorDummy(object_id_t objectId, object_id_t comif,
-                                         CookieIF *comCookie)
+                                         CookieIF *comCookie, PowerSwitchIF &pwrSwitcher)
-    : DeviceHandlerBase(objectId, comif, comCookie) {}
+    : DeviceHandlerBase(objectId, comif, comCookie) {
+  setPowerSwitcher(&pwrSwitcher);
+}
 
 PlocSupervisorDummy::~PlocSupervisorDummy() {}
 
@@ -42,3 +44,10 @@ ReturnValue_t PlocSupervisorDummy::initializeLocalDataPool(localpool::DataPool &
                                                            LocalDataPoolManager &poolManager) {
   return returnvalue::OK;
 }
+
+ReturnValue_t PlocSupervisorDummy::getSwitches(const uint8_t **switches,
+                                               uint8_t *numberOfSwitches) {
+  *numberOfSwitches = 1;
+  *switches = reinterpret_cast<const uint8_t *>(&switchId);
+  return returnvalue::OK;
+}

dummies/PlocSupervisorDummy.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
+#include <mission/power/defs.h>
 
 class PlocSupervisorDummy : public DeviceHandlerBase {
  public:
@@ -10,10 +11,13 @@ class PlocSupervisorDummy : public DeviceHandlerBase {
   static const uint8_t SIMPLE_COMMAND_DATA = 1;
   static const uint8_t PERIODIC_REPLY_DATA = 2;
 
-  PlocSupervisorDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  PlocSupervisorDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie,
+                      PowerSwitchIF &pwrSwitcher);
   virtual ~PlocSupervisorDummy();
 
  protected:
+  const power::Switches switchId = power::Switches::PDU1_CH6_PLOC_12V;
+
   void doStartUp() override;
   void doShutDown() override;
   ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
@@ -27,4 +31,5 @@ class PlocSupervisorDummy : public DeviceHandlerBase {
   uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
   ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                         LocalDataPoolManager &poolManager) override;
+  ReturnValue_t getSwitches(const uint8_t **switches, uint8_t *numberOfSwitches) override;
 };

dummies/StarTrackerDummy.cpp

@@ -40,7 +40,7 @@ uint32_t StarTrackerDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo)
 
 ReturnValue_t StarTrackerDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                         LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(startracker::MCU_TEMPERATURE, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(startracker::MCU_TEMPERATURE, new PoolEntry<float>({10.0}, true));
 
   localDataPoolMap.emplace(startracker::TICKS_SOLUTION_SET, new PoolEntry<uint32_t>({0}));
   localDataPoolMap.emplace(startracker::TIME_SOLUTION_SET, new PoolEntry<uint64_t>({0}));

dummies/SyrlinksDummy.cpp

@@ -40,7 +40,7 @@ uint32_t SyrlinksDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { r
 
 ReturnValue_t SyrlinksDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                      LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(syrlinks::TEMP_BASEBAND_BOARD, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(syrlinks::TEMP_BASEBAND_BOARD, new PoolEntry<float>({10}, true));
-  localDataPoolMap.emplace(syrlinks::TEMP_POWER_AMPLIFIER, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(syrlinks::TEMP_POWER_AMPLIFIER, new PoolEntry<float>({10}, true));
   return returnvalue::OK;
 }

dummies/TemperatureSensorInserter.cpp

@@ -9,7 +9,7 @@
 TemperatureSensorInserter::TemperatureSensorInserter(object_id_t objectId,
                                                      Max31865DummyMap tempSensorDummies_,
                                                      Tmp1075DummyMap tempTmpSensorDummies_)
-    : SystemObject(objects::THERMAL_TEMP_INSERTER),
+    : SystemObject(objectId),
       max31865DummyMap(std::move(tempSensorDummies_)),
       tmp1075DummyMap(std::move(tempTmpSensorDummies_)) {}
 
@@ -22,6 +22,32 @@ ReturnValue_t TemperatureSensorInserter::initialize() {
 }
 
 ReturnValue_t TemperatureSensorInserter::performOperation(uint8_t opCode) {
+  // TODO: deviceSensors
+  if (not tempsWereInitialized) {
+    for (auto& rtdDummy : max31865DummyMap) {
+      rtdDummy.second->setTemperature(10, true);
+    }
+    for (auto& tmpDummy : tmp1075DummyMap) {
+      tmpDummy.second->setTemperature(10, true);
+    }
+    tempsWereInitialized = true;
+  }
+
+  if (cycles == 10) {
+    max31865DummyMap[objects::RTD_9_IC12_HPA]->setTemperature(-100, true);
+    max31865DummyMap[objects::RTD_11_IC14_MPA]->setTemperature(-100, true);
+  }
+
+  if (cycles == 35) {
+    max31865DummyMap[objects::RTD_9_IC12_HPA]->setTemperature(0, true);
+    max31865DummyMap[objects::RTD_11_IC14_MPA]->setTemperature(0, true);
+    max31865DummyMap[objects::RTD_2_IC5_4K_CAMERA]->setTemperature(-100, true);
+  }
+  if (cycles == 60) {
+    max31865DummyMap[objects::RTD_9_IC12_HPA]->setTemperature(-100, true);
+    max31865DummyMap[objects::RTD_11_IC14_MPA]->setTemperature(0, true);
+  }
+
   /*
   ReturnValue_t result = max31865PlocHeatspreaderSet.read();
   if (result != returnvalue::OK) {
@@ -36,5 +62,7 @@ ReturnValue_t TemperatureSensorInserter::performOperation(uint8_t opCode) {
   }
   max31865PlocHeatspreaderSet.commit();
   */
+  cycles++;
   return returnvalue::OK;
 }
+ReturnValue_t TemperatureSensorInserter::initializeAfterTaskCreation() { return returnvalue::OK; }

dummies/TemperatureSensorInserter.h

@@ -14,6 +14,7 @@ class TemperatureSensorInserter : public ExecutableObjectIF, public SystemObject
                                      Tmp1075DummyMap tempTmpSensorDummies_);
 
   ReturnValue_t initialize() override;
+  ReturnValue_t initializeAfterTaskCreation() override;
 
  protected:
   ReturnValue_t performOperation(uint8_t opCode) override;
@@ -23,6 +24,8 @@ class TemperatureSensorInserter : public ExecutableObjectIF, public SystemObject
   Tmp1075DummyMap tmp1075DummyMap;
   enum TestCase { NONE = 0, COOL_SYRLINKS = 1 };
   int iteration = 0;
+  uint32_t cycles = 0;
+  bool tempsWereInitialized = false;
   bool performTest = false;
   TestCase testCase = TestCase::NONE;
 

dummies/Tmp1075Dummy.cpp

@@ -1,5 +1,6 @@
 #include "Tmp1075Dummy.h"
 
+#include <fsfw/datapool/PoolReadGuard.h>
 #include <mission/tcs/Tmp1075Definitions.h>
 
 using namespace returnvalue;
@@ -26,11 +27,16 @@ ReturnValue_t Tmp1075Dummy::scanForReply(const uint8_t *start, size_t len,
 ReturnValue_t Tmp1075Dummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
   return 0;
 }
+void Tmp1075Dummy::setTemperature(float temperature, bool valid) {
+  PoolReadGuard pg(&set);
+  set.temperatureCelcius.value = temperature;
+  set.setValidity(valid, true);
+}
 void Tmp1075Dummy::fillCommandAndReplyMap() {}
 uint32_t Tmp1075Dummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 1000; }
 ReturnValue_t Tmp1075Dummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                     LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(TMP1075::TEMPERATURE_C_TMP1075, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(TMP1075::TEMPERATURE_C_TMP1075, new PoolEntry<float>({10.0}, true));
   return OK;
 }
 LocalPoolDataSetBase *Tmp1075Dummy::getDataSetHandle(sid_t sid) { return &set; }

dummies/Tmp1075Dummy.h

@@ -8,6 +8,7 @@
 class Tmp1075Dummy : public DeviceHandlerBase {
  public:
   Tmp1075Dummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  void setTemperature(float temperature, bool setValid);
 
  private:
   TMP1075::Tmp1075Dataset set;

dummies/helperFactory.cpp

@@ -57,7 +57,7 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
   rws[1] = new RwDummy(objects::RW2, objects::DUMMY_COM_IF, comCookieDummy);
   rws[2] = new RwDummy(objects::RW3, objects::DUMMY_COM_IF, comCookieDummy);
   rws[3] = new RwDummy(objects::RW4, objects::DUMMY_COM_IF, comCookieDummy);
-  ObjectFactory::createRwAssy(pwrSwitcher, pcdu::Switches::PDU2_CH2_RW_5V, rws, rwIds);
+  ObjectFactory::createRwAssy(pwrSwitcher, power::Switches::PDU2_CH2_RW_5V, rws, rwIds);
   new SaDeplDummy(objects::SOLAR_ARRAY_DEPL_HANDLER);
   auto* strAssy = new StrAssembly(objects::STR_ASSY);
   strAssy->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
@@ -213,7 +213,7 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
     }
   }
   auto* camSwitcher =
-      new CamSwitcher(objects::CAM_SWITCHER, pwrSwitcher, pcdu::Switches::PDU2_CH8_PAYLOAD_CAMERA);
+      new CamSwitcher(objects::CAM_SWITCHER, pwrSwitcher, power::Switches::PDU2_CH8_PAYLOAD_CAMERA);
   camSwitcher->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
   auto* scexDummy = new ScexDummy(objects::SCEX, objects::DUMMY_COM_IF, comCookieDummy);
   scexDummy->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
@@ -224,8 +224,8 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
     auto* plocMpsocDummy =
         new PlocMpsocDummy(objects::PLOC_MPSOC_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
     plocMpsocDummy->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
-    auto* plocSupervisorDummy = new PlocSupervisorDummy(objects::PLOC_SUPERVISOR_HANDLER,
+    auto* plocSupervisorDummy = new PlocSupervisorDummy(
-                                                        objects::DUMMY_COM_IF, comCookieDummy);
+        objects::PLOC_SUPERVISOR_HANDLER, objects::DUMMY_COM_IF, comCookieDummy, pwrSwitcher);
     plocSupervisorDummy->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
   }
 }

fsfw

@@ -1 +1 @@
-Subproject commit 4f632e2c6866cee88dd9920a965aa0d079799aa3
+Subproject commit e2e87b149d91c51196c76d6b84243fce1c77a28a

generators/bsp_hosted_events.csv

@@ -261,13 +261,13 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 14007;0x36b7;REBOOT_COUNTER;INFO;Total reboot counter, which is the sum of the boot count of all individual images.;bsp_q7s/core/CoreController.h
 14008;0x36b8;INDIVIDUAL_BOOT_COUNTS;INFO;Get the boot count of the individual images. P1: First 16 bits boot count of image 0 0, last 16 bits boot count of image 0 1. P2: First 16 bits boot count of image 1 0, last 16 bits boot count of image 1 1.;bsp_q7s/core/CoreController.h
 14010;0x36ba;I2C_UNAVAILABLE_REBOOT;MEDIUM;No description;bsp_q7s/core/CoreController.h
-14100;0x3714;NO_VALID_SENSOR_TEMPERATURE;MEDIUM;No description;mission/controller/ThermalController.h
+14100;0x3714;NO_VALID_SENSOR_TEMPERATURE;MEDIUM;No description;mission/controller/tcsDefs.h
-14101;0x3715;NO_HEALTHY_HEATER_AVAILABLE;MEDIUM;No description;mission/controller/ThermalController.h
+14101;0x3715;NO_HEALTHY_HEATER_AVAILABLE;MEDIUM;No description;mission/controller/tcsDefs.h
-14102;0x3716;SYRLINKS_OVERHEATING;HIGH;No description;mission/controller/ThermalController.h
+14102;0x3716;SYRLINKS_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
-14103;0x3717;PLOC_OVERHEATING;HIGH;No description;mission/controller/ThermalController.h
+14104;0x3718;OBC_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
-14104;0x3718;OBC_OVERHEATING;HIGH;No description;mission/controller/ThermalController.h
+14105;0x3719;CAMERA_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
-14105;0x3719;HPA_OVERHEATING;HIGH;No description;mission/controller/ThermalController.h
+14106;0x371a;PCDU_SYSTEM_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
-14106;0x371a;PLPCDU_OVERHEATING;HIGH;No description;mission/controller/ThermalController.h
+14107;0x371b;HEATER_NOT_OFF_FOR_OFF_MODE;MEDIUM;No description;mission/controller/tcsDefs.h
 14201;0x3779;TX_TIMER_EXPIRED;INFO;The transmit timer to protect the Syrlinks expired P1: The current timer value;mission/system/com/ComSubsystem.h
 14202;0x377a;BIT_LOCK_TX_ON;INFO;Transmitter will be turned on due to detection of bitlock;mission/system/com/ComSubsystem.h
 14300;0x37dc;POSSIBLE_FILE_CORRUPTION;LOW;P1: Result code of TM packet parser. P2: Timestamp of possibly corrupt file as a unix timestamp.;mission/persistentTmStoreDefs.h

generators/bsp_q7s_events.csv

@@ -261,13 +261,13 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 14007;0x36b7;REBOOT_COUNTER;INFO;Total reboot counter, which is the sum of the boot count of all individual images.;bsp_q7s/core/CoreController.h
 14008;0x36b8;INDIVIDUAL_BOOT_COUNTS;INFO;Get the boot count of the individual images. P1: First 16 bits boot count of image 0 0, last 16 bits boot count of image 0 1. P2: First 16 bits boot count of image 1 0, last 16 bits boot count of image 1 1.;bsp_q7s/core/CoreController.h
 14010;0x36ba;I2C_UNAVAILABLE_REBOOT;MEDIUM;No description;bsp_q7s/core/CoreController.h
-14100;0x3714;NO_VALID_SENSOR_TEMPERATURE;MEDIUM;No description;mission/controller/ThermalController.h
+14100;0x3714;NO_VALID_SENSOR_TEMPERATURE;MEDIUM;No description;mission/controller/tcsDefs.h
-14101;0x3715;NO_HEALTHY_HEATER_AVAILABLE;MEDIUM;No description;mission/controller/ThermalController.h
+14101;0x3715;NO_HEALTHY_HEATER_AVAILABLE;MEDIUM;No description;mission/controller/tcsDefs.h
-14102;0x3716;SYRLINKS_OVERHEATING;HIGH;No description;mission/controller/ThermalController.h
+14102;0x3716;SYRLINKS_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
-14103;0x3717;PLOC_OVERHEATING;HIGH;No description;mission/controller/ThermalController.h
+14104;0x3718;OBC_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
-14104;0x3718;OBC_OVERHEATING;HIGH;No description;mission/controller/ThermalController.h
+14105;0x3719;CAMERA_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
-14105;0x3719;HPA_OVERHEATING;HIGH;No description;mission/controller/ThermalController.h
+14106;0x371a;PCDU_SYSTEM_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
-14106;0x371a;PLPCDU_OVERHEATING;HIGH;No description;mission/controller/ThermalController.h
+14107;0x371b;HEATER_NOT_OFF_FOR_OFF_MODE;MEDIUM;No description;mission/controller/tcsDefs.h
 14201;0x3779;TX_TIMER_EXPIRED;INFO;The transmit timer to protect the Syrlinks expired P1: The current timer value;mission/system/com/ComSubsystem.h
 14202;0x377a;BIT_LOCK_TX_ON;INFO;Transmitter will be turned on due to detection of bitlock;mission/system/com/ComSubsystem.h
 14300;0x37dc;POSSIBLE_FILE_CORRUPTION;LOW;P1: Result code of TM packet parser. P2: Timestamp of possibly corrupt file as a unix timestamp.;mission/persistentTmStoreDefs.h

generators/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
  * @brief    Auto-generated event translation file. Contains 284 translations.
  * @details
- * Generated on: 2023-04-01 15:26:43
+ * Generated on: 2023-04-01 16:00:01
  */
 #include "translateEvents.h"
 
@@ -270,10 +270,10 @@ const char *I2C_UNAVAILABLE_REBOOT_STRING = "I2C_UNAVAILABLE_REBOOT";
 const char *NO_VALID_SENSOR_TEMPERATURE_STRING = "NO_VALID_SENSOR_TEMPERATURE";
 const char *NO_HEALTHY_HEATER_AVAILABLE_STRING = "NO_HEALTHY_HEATER_AVAILABLE";
 const char *SYRLINKS_OVERHEATING_STRING = "SYRLINKS_OVERHEATING";
-const char *PLOC_OVERHEATING_STRING = "PLOC_OVERHEATING";
 const char *OBC_OVERHEATING_STRING = "OBC_OVERHEATING";
-const char *HPA_OVERHEATING_STRING = "HPA_OVERHEATING";
+const char *CAMERA_OVERHEATING_STRING = "CAMERA_OVERHEATING";
-const char *PLPCDU_OVERHEATING_STRING = "PLPCDU_OVERHEATING";
+const char *PCDU_SYSTEM_OVERHEATING_STRING = "PCDU_SYSTEM_OVERHEATING";
+const char *HEATER_NOT_OFF_FOR_OFF_MODE_STRING = "HEATER_NOT_OFF_FOR_OFF_MODE";
 const char *TX_TIMER_EXPIRED_STRING = "TX_TIMER_EXPIRED";
 const char *BIT_LOCK_TX_ON_STRING = "BIT_LOCK_TX_ON";
 const char *POSSIBLE_FILE_CORRUPTION_STRING = "POSSIBLE_FILE_CORRUPTION";
@@ -822,14 +822,14 @@ const char *translateEvents(Event event) {
       return NO_HEALTHY_HEATER_AVAILABLE_STRING;
     case (14102):
       return SYRLINKS_OVERHEATING_STRING;
-    case (14103):
-      return PLOC_OVERHEATING_STRING;
     case (14104):
       return OBC_OVERHEATING_STRING;
     case (14105):
-      return HPA_OVERHEATING_STRING;
+      return CAMERA_OVERHEATING_STRING;
     case (14106):
-      return PLPCDU_OVERHEATING_STRING;
+      return PCDU_SYSTEM_OVERHEATING_STRING;
+    case (14107):
+      return HEATER_NOT_OFF_FOR_OFF_MODE_STRING;
     case (14201):
       return TX_TIMER_EXPIRED_STRING;
     case (14202):

generators/objects/translateObjects.cpp

@@ -2,7 +2,7 @@
  * @brief  Auto-generated object translation file.
  * @details
  * Contains 175 translations.
- * Generated on: 2023-04-01 15:26:43
+ * Generated on: 2023-04-01 16:00:01
  */
 #include "translateObjects.h"
 

linux/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
  * @brief    Auto-generated event translation file. Contains 284 translations.
  * @details
- * Generated on: 2023-04-01 15:26:43
+ * Generated on: 2023-04-01 16:00:01
  */
 #include "translateEvents.h"
 
@@ -272,10 +272,10 @@ const char *I2C_UNAVAILABLE_REBOOT_STRING = "I2C_UNAVAILABLE_REBOOT";
 const char *NO_VALID_SENSOR_TEMPERATURE_STRING = "NO_VALID_SENSOR_TEMPERATURE";
 const char *NO_HEALTHY_HEATER_AVAILABLE_STRING = "NO_HEALTHY_HEATER_AVAILABLE";
 const char *SYRLINKS_OVERHEATING_STRING = "SYRLINKS_OVERHEATING";
-const char *PLOC_OVERHEATING_STRING = "PLOC_OVERHEATING";
 const char *OBC_OVERHEATING_STRING = "OBC_OVERHEATING";
-const char *HPA_OVERHEATING_STRING = "HPA_OVERHEATING";
+const char *CAMERA_OVERHEATING_STRING = "CAMERA_OVERHEATING";
-const char *PLPCDU_OVERHEATING_STRING = "PLPCDU_OVERHEATING";
+const char *PCDU_SYSTEM_OVERHEATING_STRING = "PCDU_SYSTEM_OVERHEATING";
+const char *HEATER_NOT_OFF_FOR_OFF_MODE_STRING = "HEATER_NOT_OFF_FOR_OFF_MODE";
 const char *TX_TIMER_EXPIRED_STRING = "TX_TIMER_EXPIRED";
 const char *BIT_LOCK_TX_ON_STRING = "BIT_LOCK_TX_ON";
 const char *POSSIBLE_FILE_CORRUPTION_STRING = "POSSIBLE_FILE_CORRUPTION";
@@ -824,14 +824,14 @@ const char *translateEvents(Event event) {
       return NO_HEALTHY_HEATER_AVAILABLE_STRING;
     case (14102):
       return SYRLINKS_OVERHEATING_STRING;
-    case (14103):
-      return PLOC_OVERHEATING_STRING;
     case (14104):
       return OBC_OVERHEATING_STRING;
     case (14105):
-      return HPA_OVERHEATING_STRING;
+      return CAMERA_OVERHEATING_STRING;
     case (14106):
-      return PLPCDU_OVERHEATING_STRING;
+      return PCDU_SYSTEM_OVERHEATING_STRING;
+    case (14107):
+      return HEATER_NOT_OFF_FOR_OFF_MODE_STRING;
     case (14201):
       return TX_TIMER_EXPIRED_STRING;
     case (14202):

linux/fsfwconfig/objects/translateObjects.cpp

@@ -2,7 +2,7 @@
  * @brief  Auto-generated object translation file.
  * @details
  * Contains 175 translations.
- * Generated on: 2023-04-01 15:26:43
+ * Generated on: 2023-04-01 16:00:01
  */
 #include "translateObjects.h"
 

mission/SolarArrayDeploymentHandler.cpp

@@ -17,7 +17,7 @@ static constexpr bool DEBUG_MODE = true;
 SolarArrayDeploymentHandler::SolarArrayDeploymentHandler(object_id_t setObjectId_,
                                                          GpioIF& gpioInterface,
                                                          PowerSwitchIF& mainLineSwitcher_,
-                                                         pcdu::Switches mainLineSwitch_,
+                                                         power::Switches mainLineSwitch_,
                                                          gpioId_t deplSA1, gpioId_t deplSA2,
                                                          SdCardMountedIF& sdcMountedIF)
     : SystemObject(setObjectId_),

mission/SolarArrayDeploymentHandler.h

@@ -107,7 +107,7 @@ class SolarArrayDeploymentHandler : public ExecutableObjectIF,
    * @param burnTimeMs  Time duration the power will be applied to the burn wires.
    */
   SolarArrayDeploymentHandler(object_id_t setObjectId, GpioIF& gpio,
-                              PowerSwitchIF& mainLineSwitcher, pcdu::Switches mainLineSwitch,
+                              PowerSwitchIF& mainLineSwitcher, power::Switches mainLineSwitch,
                               gpioId_t deplSA1, gpioId_t deplSA2, SdCardMountedIF& sdcMountedIF);
 
   virtual ~SolarArrayDeploymentHandler();

mission/controller/ThermalController.h

@@ -13,7 +13,7 @@
 #include <mission/acs/str/strHelpers.h>
 #include <mission/acs/susMax1227Helpers.h>
 #include <mission/com/syrlinksDefs.h>
-#include <mission/controller/controllerdefinitions/ThermalControllerDefinitions.h>
+#include <mission/controller/tcsDefs.h>
 #include <mission/payload/payloadPcduDefinitions.h>
 #include <mission/power/bpxBattDefs.h>
 #include <mission/power/gsDefs.h>
@@ -45,6 +45,48 @@ struct TempLimits {
   float nopUpperLimit;
 };
 
+struct ThermalState {
+  uint8_t errorCounter;
+  bool heating;
+  uint32_t heaterStartTime;
+};
+
+struct HeaterState {
+  bool switchTransition;
+  HeaterHandler::SwitchState target;
+  uint8_t heaterSwitchControlCycles;
+};
+
+using HeaterSwitchStates = std::array<HeaterHandler::SwitchState, heater::NUMBER_OF_SWITCHES>;
+
+enum ThermalComponents : uint8_t {
+  NONE = 0,
+  ACS_BOARD = 1,
+  MGT = 2,
+  RW = 3,
+  STR = 4,
+  IF_BOARD = 5,
+  TCS_BOARD = 6,
+  OBC = 7,
+  OBCIF_BOARD = 8,
+  SBAND_TRANSCEIVER = 9,
+  PCDUP60_BOARD = 10,
+  PCDUACU = 11,
+  PCDUPDU = 12,
+  PLPCDU_BOARD = 13,
+  PLOCMISSION_BOARD = 14,
+  PLOCPROCESSING_BOARD = 15,
+  DAC = 16,
+  CAMERA = 17,
+  DRO = 18,
+  X8 = 19,
+  HPA = 20,
+  TX = 21,
+  MPA = 22,
+  SCEX_BOARD = 23,
+  NUM_ENTRIES
+};
+
 class ThermalController : public ExtendedControllerBase {
  public:
   static const uint16_t INVALID_TEMPERATURE = 999;
@@ -55,7 +97,19 @@ class ThermalController : public ExtendedControllerBase {
   ReturnValue_t initialize() override;
 
  protected:
-  void performThermalModuleCtrl();
+  struct HeaterContext {
+   public:
+    HeaterContext(heater::Switchers switchNr, heater::Switchers redundantSwitchNr,
+                  const TempLimits& tempLimit)
+        : switchNr(switchNr), redSwitchNr(redundantSwitchNr), tempLimit(tempLimit) {}
+    bool doHeaterHandling = true;
+    heater::Switchers switchNr;
+    HeaterHandler::SwitchState switchState = HeaterHandler::SwitchState::OFF;
+    heater::Switchers redSwitchNr;
+    const TempLimits& tempLimit;
+  };
+
+  void performThermalModuleCtrl(const HeaterSwitchStates& heaterSwitchStates);
   ReturnValue_t handleCommandMessage(CommandMessage* message) override;
   void performControlOperation() override;
   ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
@@ -67,16 +121,7 @@ class ThermalController : public ExtendedControllerBase {
                                  uint32_t* msToReachTheMode) override;
 
  private:
-  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::TCS_CONTROLLER;
+  static const uint32_t INIT_DELAY = 1500;
-  static constexpr Event NO_VALID_SENSOR_TEMPERATURE = MAKE_EVENT(0, severity::MEDIUM);
-  static constexpr Event NO_HEALTHY_HEATER_AVAILABLE = MAKE_EVENT(1, severity::MEDIUM);
-  static constexpr Event SYRLINKS_OVERHEATING = MAKE_EVENT(2, severity::HIGH);
-  static constexpr Event PLOC_OVERHEATING = MAKE_EVENT(3, severity::HIGH);
-  static constexpr Event OBC_OVERHEATING = MAKE_EVENT(4, severity::HIGH);
-  static constexpr Event HPA_OVERHEATING = MAKE_EVENT(5, severity::HIGH);
-  static constexpr Event PLPCDU_OVERHEATING = MAKE_EVENT(6, severity::HIGH);
-
-  static const uint32_t DELAY = 500;
 
   static const uint32_t TEMP_OFFSET = 5;
 
@@ -96,22 +141,22 @@ class ThermalController : public ExtendedControllerBase {
   DeviceHandlerThermalSet imtqThermalSet;
 
   // Temperature Sensors
-  MAX31865::PrimarySet max31865Set0;
+  MAX31865::PrimarySet maxSet0PlocHspd;
-  MAX31865::PrimarySet max31865Set1;
+  MAX31865::PrimarySet maxSet1PlocMissionBrd;
-  MAX31865::PrimarySet max31865Set2;
+  MAX31865::PrimarySet maxSet2PlCam;
-  MAX31865::PrimarySet max31865Set3;
+  MAX31865::PrimarySet maxSet3DacHspd;
-  MAX31865::PrimarySet max31865Set4;
+  MAX31865::PrimarySet maxSet4Str;
-  MAX31865::PrimarySet max31865Set5;
+  MAX31865::PrimarySet maxSet5Rw1MxMy;
-  MAX31865::PrimarySet max31865Set6;
+  MAX31865::PrimarySet maxSet6Dro;
-  MAX31865::PrimarySet max31865Set7;
+  MAX31865::PrimarySet maxSet7Scex;
-  MAX31865::PrimarySet max31865Set8;
+  MAX31865::PrimarySet maxSet8X8;
-  MAX31865::PrimarySet max31865Set9;
+  MAX31865::PrimarySet maxSet9Hpa;
-  MAX31865::PrimarySet max31865Set10;
+  MAX31865::PrimarySet maxSet10EbandTx;
-  MAX31865::PrimarySet max31865Set11;
+  MAX31865::PrimarySet maxSet11Mpa;
-  MAX31865::PrimarySet max31865Set12;
+  MAX31865::PrimarySet maxSet31865Set12;
-  MAX31865::PrimarySet max31865Set13;
+  MAX31865::PrimarySet maxSet13PlPcduHspd;
-  MAX31865::PrimarySet max31865Set14;
+  MAX31865::PrimarySet maxSet14TcsBrd;
-  MAX31865::PrimarySet max31865Set15;
+  MAX31865::PrimarySet maxSet15Imtq;
 
   TMP1075::Tmp1075Dataset tmp1075SetTcs0;
   TMP1075::Tmp1075Dataset tmp1075SetTcs1;
@@ -191,18 +236,38 @@ class ThermalController : public ExtendedControllerBase {
   TempLimits dacLimits = TempLimits(-65.0, -40.0, 113.0, 118.0, 150.0);
   TempLimits cameraLimits = TempLimits(-40.0, -30.0, 60.0, 65.0, 85.0);
   TempLimits droLimits = TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
-  TempLimits x8Limits = TempLimits(-40.0, -30.0, -75.0, 80.0, 90.0);
+  TempLimits x8Limits = TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
-  TempLimits hpaLimits = TempLimits(-40.0, -30.0, -75.0, 80.0, 90.0);
+  TempLimits hpaLimits = TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
-  TempLimits txLimits = TempLimits(-40.0, -30.0, -75.0, 80.0, 90.0);
+  TempLimits txLimits = TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
-  TempLimits mpaLimits = TempLimits(-40.0, -30.0, -75.0, 80.0, 90.0);
+  TempLimits mpaLimits = TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
   TempLimits scexBoardLimits = TempLimits(-60.0, -40.0, 80.0, 85.0, 150.0);
 
   double sensorTemp = INVALID_TEMPERATURE;
+  ThermalComponents thermalComponent = NONE;
   bool redSwitchNrInUse = false;
+  MessageQueueId_t camId = MessageQueueIF::NO_QUEUE;
   bool componentAboveCutOffLimit = false;
+  bool componentAboveUpperLimit = false;
+  Event overHeatEventToTrigger;
+  bool eBandTooHotFlag = false;
+  bool camTooHotOneShotFlag = false;
+  bool scexTooHotFlag = false;
+  bool plocTooHotFlag = false;
+  bool pcduSystemTooHotFlag = false;
+  bool syrlinksTooHotFlag = false;
+  bool obcTooHotFlag = false;
+  bool strTooHotFlag = false;
+  bool rwTooHotFlag = false;
 
-  // Initial delay to make sure all pool variables have been initialized their owners
+  bool transitionToOff = false;
-  Countdown initialCountdown = Countdown(DELAY);
+  uint32_t transitionToOffCycles = 0;
+  uint32_t cycles = 0;
+  std::array<ThermalState, 30> thermalStates{};
+  std::array<HeaterState, 7> heaterStates{};
+
+  // Initial delay to make sure all pool variables have been initialized their owners.
+  // Also, wait for system initialization to complete.
+  Countdown initialCountdown = Countdown(INIT_DELAY);
 
 #if OBSW_THREAD_TRACING == 1
   uint32_t opCounter = 0;
@@ -221,14 +286,18 @@ class ThermalController : public ExtendedControllerBase {
 
   static constexpr dur_millis_t MUTEX_TIMEOUT = 50;
 
+  void startTransition(Mode_t mode, Submode_t submode) override;
+
   void resetSensorsArray();
   void copySensors();
   void copySus();
   void copyDevices();
 
-  void ctrlComponentTemperature(heater::Switchers switchNr, heater::Switchers redSwitchNr,
+  void ctrlComponentTemperature(HeaterContext& heaterContext);
-                                TempLimits& tempLimit);
+  void checkLimitsAndCtrlHeater(HeaterContext& heaterContext);
-  void ctrlHeater(heater::Switchers switchNr, heater::Switchers redSwitchNr, TempLimits& tempLimit);
+  bool heaterCtrlCheckUpperLimits(HeaterContext& heaterContext);
+  void heaterCtrlTempTooHighHandler(HeaterContext& heaterContext, const char* whatLimit);
+
   bool chooseHeater(heater::Switchers& switchNr, heater::Switchers redSwitchNr);
   bool selectAndReadSensorTemp();
 
@@ -255,6 +324,11 @@ class ThermalController : public ExtendedControllerBase {
   void ctrlTx();
   void ctrlMpa();
   void ctrlScexBoard();
+  void heaterTransitionControl(const HeaterSwitchStates& currentHeaterStates);
+  void setMode(Mode_t mode);
+  uint32_t tempFloatToU32() const;
+  bool tooHotHandler(object_id_t object, bool& oneShotFlag);
+  void tooHotHandlerWhichClearsOneShotFlag(object_id_t object, bool& oneShotFlag);
 };
 
 #endif /* MISSION_CONTROLLER_THERMALCONTROLLER_H_ */

mission/controller/tcsDefs.h

@@ -5,9 +5,19 @@
 #include <fsfw/datapoollocal/StaticLocalDataSet.h>
 
 #include "devices/heaterSwitcherList.h"
+#include "eive/eventSubsystemIds.h"
 
 namespace tcsCtrl {
 
+static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::TCS_CONTROLLER;
+static constexpr Event NO_VALID_SENSOR_TEMPERATURE = MAKE_EVENT(0, severity::MEDIUM);
+static constexpr Event NO_HEALTHY_HEATER_AVAILABLE = MAKE_EVENT(1, severity::MEDIUM);
+static constexpr Event SYRLINKS_OVERHEATING = MAKE_EVENT(2, severity::HIGH);
+static constexpr Event OBC_OVERHEATING = MAKE_EVENT(4, severity::HIGH);
+static constexpr Event CAMERA_OVERHEATING = MAKE_EVENT(5, severity::HIGH);
+static constexpr Event PCDU_SYSTEM_OVERHEATING = MAKE_EVENT(6, severity::HIGH);
+static constexpr Event HEATER_NOT_OFF_FOR_OFF_MODE = MAKE_EVENT(7, severity::MEDIUM);
+
 enum SetId : uint32_t {
   SENSOR_TEMPERATURES = 0,
   DEVICE_TEMPERATURES = 1,
@@ -93,34 +103,33 @@ static const uint8_t ENTRIES_SUS_TEMPERATURE_SET = 12;
  */
 class SensorTemperatures : public StaticLocalDataSet<ENTRIES_SENSOR_TEMPERATURE_SET> {
  public:
-  SensorTemperatures(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, SENSOR_TEMPERATURES) {}
+  explicit SensorTemperatures(HasLocalDataPoolIF* owner)
+      : StaticLocalDataSet(owner, SENSOR_TEMPERATURES) {}
 
-  SensorTemperatures(object_id_t objectId)
+  explicit SensorTemperatures(object_id_t objectId)
       : StaticLocalDataSet(sid_t(objectId, SENSOR_TEMPERATURES)) {}
 
-  lp_var_t<float> sensor_ploc_heatspreader =
+  lp_var_t<float> plocHeatspreader =
       lp_var_t<float>(sid.objectId, PoolIds::SENSOR_PLOC_HEATSPREADER, this);
-  lp_var_t<float> sensor_ploc_missionboard =
+  lp_var_t<float> plocMissionboard =
       lp_var_t<float>(sid.objectId, PoolIds::SENSOR_PLOC_MISSIONBOARD, this);
-  lp_var_t<float> sensor_4k_camera = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_4K_CAMERA, this);
+  lp_var_t<float> payload4kCamera = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_4K_CAMERA, this);
-  lp_var_t<float> sensor_dac_heatspreader =
+  lp_var_t<float> dacHeatspreader =
       lp_var_t<float>(sid.objectId, PoolIds::SENSOR_DAC_HEATSPREADER, this);
-  lp_var_t<float> sensor_startracker =
+  lp_var_t<float> startracker = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_STARTRACKER, this);
-      lp_var_t<float>(sid.objectId, PoolIds::SENSOR_STARTRACKER, this);
+  lp_var_t<float> rw1 = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_RW1, this);
-  lp_var_t<float> sensor_rw1 = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_RW1, this);
+  lp_var_t<float> scex = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_SCEX, this);
-  lp_var_t<float> sensor_scex = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_SCEX, this);
+  lp_var_t<float> eBandTx = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_TX_MODUL, this);
-  lp_var_t<float> sensor_tx_modul = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_TX_MODUL, this);
   // E-Band module
-  lp_var_t<float> sensor_dro = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_DRO, this);
+  lp_var_t<float> dro = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_DRO, this);
-  lp_var_t<float> sensor_mpa = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_MPA, this);
+  lp_var_t<float> mpa = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_MPA, this);
-  lp_var_t<float> sensor_x8 = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_X8, this);
+  lp_var_t<float> x8 = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_X8, this);
-  lp_var_t<float> sensor_hpa = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_HPA, this);
+  lp_var_t<float> hpa = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_HPA, this);
-  lp_var_t<float> sensor_acu = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_ACU, this);
+  lp_var_t<float> acu = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_ACU, this);
-  lp_var_t<float> sensor_plpcdu_heatspreader =
+  lp_var_t<float> plpcduHeatspreader =
       lp_var_t<float>(sid.objectId, PoolIds::SENSOR_PLPCDU_HEATSPREADER, this);
-  lp_var_t<float> sensor_tcs_board = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_TCS_BOARD, this);
+  lp_var_t<float> tcsBoard = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_TCS_BOARD, this);
-  lp_var_t<float> sensor_magnettorquer =
+  lp_var_t<float> mgt = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_MAGNETTORQUER, this);
-      lp_var_t<float>(sid.objectId, PoolIds::SENSOR_MAGNETTORQUER, this);
   lp_var_t<float> tmp1075Tcs0 = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_TMP1075_TCS_0, this);
   lp_var_t<float> tmp1075Tcs1 = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_TMP1075_TCS_1, this);
   lp_var_t<float> tmp1075PlPcdu0 =
@@ -137,9 +146,10 @@ class SensorTemperatures : public StaticLocalDataSet<ENTRIES_SENSOR_TEMPERATURE_
  */
 class DeviceTemperatures : public StaticLocalDataSet<ENTRIES_DEVICE_TEMPERATURE_SET> {
  public:
-  DeviceTemperatures(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, DEVICE_TEMPERATURES) {}
+  explicit DeviceTemperatures(HasLocalDataPoolIF* owner)
+      : StaticLocalDataSet(owner, DEVICE_TEMPERATURES) {}
 
-  DeviceTemperatures(object_id_t objectId)
+  explicit DeviceTemperatures(object_id_t objectId)
       : StaticLocalDataSet(sid_t(objectId, DEVICE_TEMPERATURES)) {}
 
   lp_var_t<float> q7s = lp_var_t<float>(sid.objectId, PoolIds::TEMP_Q7S, this);
@@ -178,9 +188,11 @@ class DeviceTemperatures : public StaticLocalDataSet<ENTRIES_DEVICE_TEMPERATURE_
  */
 class SusTemperatures : public StaticLocalDataSet<ENTRIES_SUS_TEMPERATURE_SET> {
  public:
-  SusTemperatures(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, SUS_TEMPERATURES) {}
+  explicit SusTemperatures(HasLocalDataPoolIF* owner)
+      : StaticLocalDataSet(owner, SUS_TEMPERATURES) {}
 
-  SusTemperatures(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, SUS_TEMPERATURES)) {}
+  explicit SusTemperatures(object_id_t objectId)
+      : StaticLocalDataSet(sid_t(objectId, SUS_TEMPERATURES)) {}
 
   lp_var_t<float> sus_0_n_loc_xfyfzm_pt_xf =
       lp_var_t<float>(sid.objectId, PoolIds::SUS_0_N_LOC_XFYFZM_PT_XF, this);

mission/genericFactory.cpp

@@ -295,7 +295,7 @@ void ObjectFactory::createGenericHeaterComponents(GpioIF& gpioIF, PowerSwitchIF&
       {new HealthDevice(objects::HEATER_7_SYRLINKS, MessageQueueIF::NO_QUEUE), gpioIds::HEATER_7},
   }});
   heaterHandler = new HeaterHandler(objects::HEATER_HANDLER, &gpioIF, helper, &pwrSwitcher,
-                                    pcdu::Switches::PDU2_CH3_TCS_BOARD_HEATER_IN_8V);
+                                    power::Switches::PDU2_CH3_TCS_BOARD_HEATER_IN_8V);
   heaterHandler->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
 }
 
@@ -365,7 +365,7 @@ void ObjectFactory::createAcsBoardAssy(PowerSwitchIF& pwrSwitcher,
 TcsBoardAssembly* ObjectFactory::createTcsBoardAssy(PowerSwitchIF& pwrSwitcher) {
   TcsBoardHelper helper(RTD_INFOS);
   auto* tcsBoardAss = new TcsBoardAssembly(objects::TCS_BOARD_ASS, &pwrSwitcher,
-                                           pcdu::Switches::PDU1_CH0_TCS_BOARD_3V3, helper);
+                                           power::Switches::PDU1_CH0_TCS_BOARD_3V3, helper);
   tcsBoardAss->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
   return tcsBoardAss;
 }

mission/power/PcduHandler.cpp

@@ -41,9 +41,9 @@ ReturnValue_t PcduHandler::performOperation(uint8_t counter) {
     PoolReadGuard pg(&switcherSet.p60Dock5VStack);
     if (pg.getReadResult() == returnvalue::OK) {
       if (switcherSet.p60Dock5VStack.value != switchState) {
-        triggerEvent(power::SWITCH_HAS_CHANGED, switchState, pcdu::Switches::P60_DOCK_5V_STACK);
+        triggerEvent(power::SWITCH_HAS_CHANGED, switchState, power::Switches::P60_DOCK_5V_STACK);
         MutexGuard mg(pwrLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
-        switchStates[pcdu::P60_DOCK_5V_STACK] = switchState;
+        switchStates[power::P60_DOCK_5V_STACK] = switchState;
       }
       switcherSet.p60Dock5VStack.setValid(true);
       switcherSet.p60Dock5VStack.value = switchState;
@@ -103,7 +103,7 @@ ReturnValue_t PcduHandler::initialize() {
 void PcduHandler::initializeSwitchStates() {
   using namespace pcdu;
   try {
-    for (uint8_t idx = 0; idx < NUMBER_OF_SWITCHES; idx++) {
+    for (uint8_t idx = 0; idx < power::NUMBER_OF_SWITCHES; idx++) {
       if (idx < PDU::CHANNELS_LEN) {
         switchStates[idx] = INIT_SWITCHES_PDU1.at(idx);
       } else if (idx < PDU::CHANNELS_LEN * 2) {
@@ -181,22 +181,23 @@ void PcduHandler::updatePdu2SwitchStates() {
     }
     switcherSet.pdu2Switches.setValid(true);
     MutexGuard mg(pwrLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
-    checkAndUpdatePduSwitch(pdu, Switches::PDU2_CH0_Q7S, pdu2CoreHk.outputEnables[Channels::Q7S]);
+    checkAndUpdatePduSwitch(pdu, power::PDU2_CH0_Q7S, pdu2CoreHk.outputEnables[Channels::Q7S]);
 
-    checkAndUpdatePduSwitch(pdu, Switches::PDU2_CH1_PL_PCDU_BATT_0_14V8,
+    checkAndUpdatePduSwitch(pdu, power::Switches::PDU2_CH1_PL_PCDU_BATT_0_14V8,
                             pdu2CoreHk.outputEnables[Channels::PAYLOAD_PCDU_CH1]);
-    checkAndUpdatePduSwitch(pdu, Switches::PDU2_CH2_RW_5V, pdu2CoreHk.outputEnables[Channels::RW]);
+    checkAndUpdatePduSwitch(pdu, power::Switches::PDU2_CH2_RW_5V,
-    checkAndUpdatePduSwitch(pdu, Switches::PDU2_CH3_TCS_BOARD_HEATER_IN_8V,
+                            pdu2CoreHk.outputEnables[Channels::RW]);
+    checkAndUpdatePduSwitch(pdu, power::Switches::PDU2_CH3_TCS_BOARD_HEATER_IN_8V,
                             pdu2CoreHk.outputEnables[Channels::TCS_HEATER_IN]);
-    checkAndUpdatePduSwitch(pdu, Switches::PDU2_CH4_SUS_REDUNDANT_3V3,
+    checkAndUpdatePduSwitch(pdu, power::Switches::PDU2_CH4_SUS_REDUNDANT_3V3,
                             pdu2CoreHk.outputEnables[Channels::SUS_REDUNDANT]);
-    checkAndUpdatePduSwitch(pdu, Switches::PDU2_CH5_DEPLOYMENT_MECHANISM_8V,
+    checkAndUpdatePduSwitch(pdu, power::Switches::PDU2_CH5_DEPLOYMENT_MECHANISM_8V,
                             pdu2CoreHk.outputEnables[Channels::DEPY_MECHANISM]);
-    checkAndUpdatePduSwitch(pdu, Switches::PDU2_CH6_PL_PCDU_BATT_1_14V8,
+    checkAndUpdatePduSwitch(pdu, power::Switches::PDU2_CH6_PL_PCDU_BATT_1_14V8,
                             pdu2CoreHk.outputEnables[Channels::PAYLOAD_PCDU_CH6]);
-    checkAndUpdatePduSwitch(pdu, Switches::PDU2_CH7_ACS_BOARD_SIDE_B_3V3,
+    checkAndUpdatePduSwitch(pdu, power::Switches::PDU2_CH7_ACS_BOARD_SIDE_B_3V3,
                             pdu2CoreHk.outputEnables[Channels::ACS_B_SIDE]);
-    checkAndUpdatePduSwitch(pdu, Switches::PDU2_CH8_PAYLOAD_CAMERA,
+    checkAndUpdatePduSwitch(pdu, power::Switches::PDU2_CH8_PAYLOAD_CAMERA,
                             pdu2CoreHk.outputEnables[Channels::PAYLOAD_CAMERA]);
     if (firstSwitchInfoPdu2) {
       firstSwitchInfoPdu2 = false;
@@ -218,23 +219,23 @@ void PcduHandler::updatePdu1SwitchStates() {
     }
     switcherSet.pdu1Switches.setValid(true);
     MutexGuard mg(pwrLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
-    checkAndUpdatePduSwitch(pdu, Switches::PDU1_CH0_TCS_BOARD_3V3,
+    checkAndUpdatePduSwitch(pdu, power::Switches::PDU1_CH0_TCS_BOARD_3V3,
                             pdu1CoreHk.outputEnables[Channels::TCS_BOARD_3V3]);
-    checkAndUpdatePduSwitch(pdu, Switches::PDU1_CH1_SYRLINKS_12V,
+    checkAndUpdatePduSwitch(pdu, power::Switches::PDU1_CH1_SYRLINKS_12V,
                             pdu1CoreHk.outputEnables[Channels::SYRLINKS]);
-    checkAndUpdatePduSwitch(pdu, Switches::PDU1_CH2_STAR_TRACKER_5V,
+    checkAndUpdatePduSwitch(pdu, power::Switches::PDU1_CH2_STAR_TRACKER_5V,
                             pdu1CoreHk.outputEnables[Channels::STR]);
-    checkAndUpdatePduSwitch(pdu, Switches::PDU1_CH3_MGT_5V,
+    checkAndUpdatePduSwitch(pdu, power::Switches::PDU1_CH3_MGT_5V,
                             pdu1CoreHk.outputEnables[Channels::MGT]);
-    checkAndUpdatePduSwitch(pdu, Switches::PDU1_CH4_SUS_NOMINAL_3V3,
+    checkAndUpdatePduSwitch(pdu, power::Switches::PDU1_CH4_SUS_NOMINAL_3V3,
                             pdu1CoreHk.outputEnables[Channels::SUS_NOMINAL]);
-    checkAndUpdatePduSwitch(pdu, Switches::PDU1_CH5_SOLAR_CELL_EXP_5V,
+    checkAndUpdatePduSwitch(pdu, power::Switches::PDU1_CH5_SOLAR_CELL_EXP_5V,
                             pdu1CoreHk.outputEnables[Channels::SOL_CELL_EXPERIMENT]);
-    checkAndUpdatePduSwitch(pdu, Switches::PDU1_CH6_PLOC_12V,
+    checkAndUpdatePduSwitch(pdu, power::Switches::PDU1_CH6_PLOC_12V,
                             pdu1CoreHk.outputEnables[Channels::PLOC]);
-    checkAndUpdatePduSwitch(pdu, Switches::PDU1_CH7_ACS_A_SIDE_3V3,
+    checkAndUpdatePduSwitch(pdu, power::Switches::PDU1_CH7_ACS_A_SIDE_3V3,
                             pdu1CoreHk.outputEnables[Channels::ACS_A_SIDE]);
-    checkAndUpdatePduSwitch(pdu, Switches::PDU1_CH8_UNOCCUPIED,
+    checkAndUpdatePduSwitch(pdu, power::Switches::PDU1_CH8_UNOCCUPIED,
                             pdu1CoreHk.outputEnables[Channels::UNUSED]);
     if (firstSwitchInfoPdu1) {
       firstSwitchInfoPdu1 = false;
@@ -255,99 +256,99 @@ ReturnValue_t PcduHandler::sendSwitchCommand(uint8_t switchNr, ReturnValue_t onO
   GomspaceDeviceHandler* module = nullptr;
 
   switch (switchNr) {
-    case pcdu::PDU1_CH0_TCS_BOARD_3V3: {
+    case power::PDU1_CH0_TCS_BOARD_3V3: {
       memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_TCS_BOARD_3V3;
       module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
       break;
     }
-    case pcdu::PDU1_CH1_SYRLINKS_12V: {
+    case power::PDU1_CH1_SYRLINKS_12V: {
       memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_SYRLINKS;
       module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
       break;
     }
-    case pcdu::PDU1_CH2_STAR_TRACKER_5V: {
+    case power::PDU1_CH2_STAR_TRACKER_5V: {
       memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_STAR_TRACKER;
       module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
       break;
     }
-    case pcdu::PDU1_CH3_MGT_5V: {
+    case power::PDU1_CH3_MGT_5V: {
       memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_MGT;
       module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
       break;
     }
-    case pcdu::PDU1_CH4_SUS_NOMINAL_3V3: {
+    case power::PDU1_CH4_SUS_NOMINAL_3V3: {
       memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_SUS_NOMINAL;
       module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
       break;
     }
-    case pcdu::PDU1_CH5_SOLAR_CELL_EXP_5V: {
+    case power::PDU1_CH5_SOLAR_CELL_EXP_5V: {
       memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_SOLAR_CELL_EXP;
       module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
       break;
     }
-    case pcdu::PDU1_CH6_PLOC_12V: {
+    case power::PDU1_CH6_PLOC_12V: {
       memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_PLOC;
       module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
       break;
     }
-    case pcdu::PDU1_CH7_ACS_A_SIDE_3V3: {
+    case power::PDU1_CH7_ACS_A_SIDE_3V3: {
       memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_ACS_BOARD_SIDE_A;
       module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
       break;
     }
-    case pcdu::PDU1_CH8_UNOCCUPIED: {
+    case power::PDU1_CH8_UNOCCUPIED: {
       memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_CHANNEL8;
       module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
       break;
     }
     // This is a dangerous command. Reject/Igore it for now
-    case pcdu::PDU2_CH0_Q7S: {
+    case power::PDU2_CH0_Q7S: {
       return returnvalue::FAILED;
       // memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_Q7S;
       // pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
       // break;
     }
-    case pcdu::PDU2_CH1_PL_PCDU_BATT_0_14V8: {
+    case power::PDU2_CH1_PL_PCDU_BATT_0_14V8: {
       memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_PAYLOAD_PCDU_CH1;
       module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
       break;
     }
-    case pcdu::PDU2_CH2_RW_5V: {
+    case power::PDU2_CH2_RW_5V: {
       memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_RW;
       module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
       break;
     }
-    case pcdu::PDU2_CH3_TCS_BOARD_HEATER_IN_8V: {
+    case power::PDU2_CH3_TCS_BOARD_HEATER_IN_8V: {
       memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_TCS_BOARD_HEATER_IN;
       module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
       break;
     }
-    case pcdu::PDU2_CH4_SUS_REDUNDANT_3V3: {
+    case power::PDU2_CH4_SUS_REDUNDANT_3V3: {
       memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_SUS_REDUNDANT;
       module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
       break;
     }
-    case pcdu::PDU2_CH5_DEPLOYMENT_MECHANISM_8V: {
+    case power::PDU2_CH5_DEPLOYMENT_MECHANISM_8V: {
       memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_DEPLOYMENT_MECHANISM;
       module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
       break;
     }
-    case pcdu::PDU2_CH6_PL_PCDU_BATT_1_14V8: {
+    case power::PDU2_CH6_PL_PCDU_BATT_1_14V8: {
       memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_PAYLOAD_PCDU_CH6;
       module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
       break;
     }
-    case pcdu::PDU2_CH7_ACS_BOARD_SIDE_B_3V3: {
+    case power::PDU2_CH7_ACS_BOARD_SIDE_B_3V3: {
       memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_ACS_BOARD_SIDE_B;
       module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
       break;
     }
-    case pcdu::PDU2_CH8_PAYLOAD_CAMERA: {
+    case power::PDU2_CH8_PAYLOAD_CAMERA: {
       memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_PAYLOAD_CAMERA;
       module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
       break;
     }
-    case pcdu::P60_DOCK_5V_STACK: {
+    case power::P60_DOCK_5V_STACK: {
       memoryAddress = P60Dock::CONFIG_ADDRESS_OUT_EN_5V_STACK;
       module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::P60DOCK_HANDLER);
       break;
@@ -399,7 +400,7 @@ ReturnValue_t PcduHandler::sendSwitchCommand(uint8_t switchNr, ReturnValue_t onO
 ReturnValue_t PcduHandler::sendFuseOnCommand(uint8_t fuseNr) { return returnvalue::OK; }
 
 ReturnValue_t PcduHandler::getSwitchState(uint8_t switchNr) const {
-  if (switchNr >= pcdu::NUMBER_OF_SWITCHES) {
+  if (switchNr >= power::NUMBER_OF_SWITCHES) {
     sif::debug << "PCDUHandler::getSwitchState: Invalid switch number" << std::endl;
     return returnvalue::FAILED;
   }
@@ -459,7 +460,7 @@ LocalPoolDataSetBase* PcduHandler::getDataSetHandle(sid_t sid) {
   }
 }
 
-void PcduHandler::checkAndUpdatePduSwitch(GOMSPACE::Pdu pdu, pcdu::Switches switchIdx,
+void PcduHandler::checkAndUpdatePduSwitch(GOMSPACE::Pdu pdu, power::Switches switchIdx,
                                           uint8_t setValue) {
   using namespace pcdu;
   if (switchStates[switchIdx] != setValue) {

mission/power/PcduHandler.h

@@ -88,7 +88,7 @@ class PcduHandler : public PowerSwitchIF,
   CCSDSTime::CDS_short timeStampPdu1HkDataset;
 
   uint8_t SWITCH_STATE_UNKNOWN = 2;
-  uint8_t switchStates[pcdu::NUMBER_OF_SWITCHES];
+  uint8_t switchStates[power::NUMBER_OF_SWITCHES];
   /**
    * Pointer to the IPCStore.
    * This caches the pointer received from the objectManager in the constructor.
@@ -137,7 +137,7 @@ class PcduHandler : public PowerSwitchIF,
    */
   void updateHkTableDataset(store_address_t storeId, LocalPoolDataSetBase* dataset,
                             CCSDSTime::CDS_short* datasetTimeStamp);
-  void checkAndUpdatePduSwitch(GOMSPACE::Pdu pdu, pcdu::Switches switchIdx, uint8_t setValue);
+  void checkAndUpdatePduSwitch(GOMSPACE::Pdu pdu, power::Switches switchIdx, uint8_t setValue);
 };
 
 #endif /* MISSION_POWER_PCDUHANDLER_H_ */

mission/power/defs.h

@@ -3,11 +3,38 @@
 
 #include <fsfw/events/Event.h>
 #include <fsfw/modes/ModeMessage.h>
+#include <fsfw/power/definitions.h>
 
 #include "eive/eventSubsystemIds.h"
 
 namespace power {
 
+/* Switches are uint8_t datatype and go from 0 to 255 */
+enum Switches : power::Switch_t {
+  PDU1_CH0_TCS_BOARD_3V3,
+  PDU1_CH1_SYRLINKS_12V,
+  PDU1_CH2_STAR_TRACKER_5V,
+  PDU1_CH3_MGT_5V,
+  PDU1_CH4_SUS_NOMINAL_3V3,
+  PDU1_CH5_SOLAR_CELL_EXP_5V,
+  PDU1_CH6_PLOC_12V,
+  PDU1_CH7_ACS_A_SIDE_3V3,
+  PDU1_CH8_UNOCCUPIED,
+
+  PDU2_CH0_Q7S,
+  PDU2_CH1_PL_PCDU_BATT_0_14V8,
+  PDU2_CH2_RW_5V,
+  PDU2_CH3_TCS_BOARD_HEATER_IN_8V,
+  PDU2_CH4_SUS_REDUNDANT_3V3,
+  PDU2_CH5_DEPLOYMENT_MECHANISM_8V,
+  PDU2_CH6_PL_PCDU_BATT_1_14V8,
+  PDU2_CH7_ACS_BOARD_SIDE_B_3V3,
+  PDU2_CH8_PAYLOAD_CAMERA,
+
+  P60_DOCK_5V_STACK,
+  NUMBER_OF_SWITCHES
+};
+
 static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_HANDLER;
 //! [EXPORT] : [COMMENT] Indicates that a FSFW object requested setting a switch
 //! P1: 1 if on was requested, 0 for off | P2: Switch Index

mission/power/gsDefs.h

@@ -11,6 +11,7 @@
 
 #include "devices/powerSwitcherList.h"
 #include "fsfw/platform.h"
+#include "mission/power/defs.h"
 
 namespace GOMSPACE {
 
@@ -715,32 +716,6 @@ namespace pcdu {
 
 enum PoolIds : uint32_t { PDU1_SWITCHES, PDU2_SWITCHES, P60DOCK_SWITCHES };
 
-/* Switches are uint8_t datatype and go from 0 to 255 */
-enum Switches : power::Switch_t {
-  PDU1_CH0_TCS_BOARD_3V3,
-  PDU1_CH1_SYRLINKS_12V,
-  PDU1_CH2_STAR_TRACKER_5V,
-  PDU1_CH3_MGT_5V,
-  PDU1_CH4_SUS_NOMINAL_3V3,
-  PDU1_CH5_SOLAR_CELL_EXP_5V,
-  PDU1_CH6_PLOC_12V,
-  PDU1_CH7_ACS_A_SIDE_3V3,
-  PDU1_CH8_UNOCCUPIED,
-
-  PDU2_CH0_Q7S,
-  PDU2_CH1_PL_PCDU_BATT_0_14V8,
-  PDU2_CH2_RW_5V,
-  PDU2_CH3_TCS_BOARD_HEATER_IN_8V,
-  PDU2_CH4_SUS_REDUNDANT_3V3,
-  PDU2_CH5_DEPLOYMENT_MECHANISM_8V,
-  PDU2_CH6_PL_PCDU_BATT_1_14V8,
-  PDU2_CH7_ACS_BOARD_SIDE_B_3V3,
-  PDU2_CH8_PAYLOAD_CAMERA,
-
-  P60_DOCK_5V_STACK,
-  NUMBER_OF_SWITCHES
-};
-
 static const uint8_t ON = 1;
 static const uint8_t OFF = 0;
 
@@ -760,7 +735,7 @@ const std::array<uint8_t, PDU::CHANNELS_LEN> INIT_SWITCHES_PDU2 = {ON,  OFF, OFF
 
 static constexpr uint32_t SWITCHER_SET_ID = 0;
 
-class SwitcherStates : public StaticLocalDataSet<NUMBER_OF_SWITCHES> {
+class SwitcherStates : public StaticLocalDataSet<power::NUMBER_OF_SWITCHES> {
  public:
   SwitcherStates(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, SWITCHER_SET_ID) {}
 

mission/system/acs/AcsBoardAssembly.h

@@ -113,8 +113,8 @@ class AcsBoardAssembly : public DualLaneAssemblyBase {
   void selectGpsInDualMode(duallane::Submodes side);
 
  private:
-  static constexpr pcdu::Switches SWITCH_A = pcdu::Switches::PDU1_CH7_ACS_A_SIDE_3V3;
+  static constexpr power::Switches SWITCH_A = power::Switches::PDU1_CH7_ACS_A_SIDE_3V3;
-  static constexpr pcdu::Switches SWITCH_B = pcdu::Switches::PDU2_CH7_ACS_BOARD_SIDE_B_3V3;
+  static constexpr power::Switches SWITCH_B = power::Switches::PDU2_CH7_ACS_BOARD_SIDE_B_3V3;
 
   AcsBoardHelper helper;
   GpioIF* gpioIF = nullptr;

mission/system/acs/DualLaneAssemblyBase.cpp

@@ -5,7 +5,7 @@
 #include "OBSWConfig.h"
 
 DualLaneAssemblyBase::DualLaneAssemblyBase(object_id_t objectId, PowerSwitchIF* pwrSwitcher,
-                                           pcdu::Switches switch1, pcdu::Switches switch2,
+                                           power::Switches switch1, power::Switches switch2,
                                            Event pwrTimeoutEvent, Event sideSwitchNotAllowedEvent,
                                            Event transitionOtherSideFailedEvent)
     : AssemblyBase(objectId, 20),

mission/system/acs/DualLaneAssemblyBase.h

@@ -18,8 +18,8 @@ class DualLaneAssemblyBase : public AssemblyBase, public ConfirmsFailuresIF {
   static constexpr UniqueEventId_t POWER_STATE_MACHINE_TIMEOUT_ID = 2;
   static constexpr UniqueEventId_t SIDE_SWITCH_TRANSITION_NOT_ALLOWED_ID = 3;
 
-  DualLaneAssemblyBase(object_id_t objectId, PowerSwitchIF* pwrSwitcher, pcdu::Switches switch1,
+  DualLaneAssemblyBase(object_id_t objectId, PowerSwitchIF* pwrSwitcher, power::Switches switch1,
-                       pcdu::Switches switch2, Event pwrSwitchTimeoutEvent,
+                       power::Switches switch2, Event pwrSwitchTimeoutEvent,
                        Event sideSwitchNotAllowedEvent, Event transitionOtherSideFailedEvent);
 
  protected:

mission/system/acs/SusAssembly.h

@@ -44,8 +44,8 @@ class SusAssembly : public DualLaneAssemblyBase {
 
  private:
   enum class States { IDLE, SWITCHING_POWER, MODE_COMMANDING } state = States::IDLE;
-  static constexpr pcdu::Switches SWITCH_NOM = pcdu::Switches::PDU1_CH4_SUS_NOMINAL_3V3;
+  static constexpr power::Switches SWITCH_NOM = power::Switches::PDU1_CH4_SUS_NOMINAL_3V3;
-  static constexpr pcdu::Switches SWITCH_RED = pcdu::Switches::PDU2_CH4_SUS_REDUNDANT_3V3;
+  static constexpr power::Switches SWITCH_RED = power::Switches::PDU2_CH4_SUS_REDUNDANT_3V3;
   FixedArrayList<ModeListEntry, NUMBER_SUN_SENSORS> modeTable;
 
   SusAssHelper helper;

mission/system/com/ComSubsystem.cpp

@@ -1,5 +1,6 @@
 #include "ComSubsystem.h"
 
+#include <fsfw/events/Event.h>
 #include <fsfw/events/EventManagerIF.h>
 #include <fsfw/ipc/MutexGuard.h>
 #include <fsfw/ipc/QueueFactory.h>
@@ -7,6 +8,7 @@
 #include <linux/ipcore/PdecHandler.h>
 #include <mission/com/defs.h>
 #include <mission/config/comCfg.h>
+#include <mission/controller/tcsDefs.h>
 
 #include <utility>
 
@@ -21,7 +23,13 @@ ComSubsystem::ComSubsystem(object_id_t setObjectId, uint32_t maxNumberOfSequence
 }
 
 void ComSubsystem::performChildOperation() {
+  Subsystem::performChildOperation();
   readEventQueue();
+  if (performRecoveryToRxOnly and not isInTransition) {
+    startRxOnlyRecovery(true);
+    // To avoid immediately enabling TX after falling back.
+    rememberBitLock = false;
+  }
   // Execute default rate sequence after transition has been completed
   if (rememberBitLock and not isInTransition) {
     startRxAndTxLowRateSeq();
@@ -30,8 +38,6 @@ void ComSubsystem::performChildOperation() {
   if (countdownActive) {
     checkTransmitterCountdown();
   }
-
-  Subsystem::performChildOperation();
 }
 
 MessageQueueId_t ComSubsystem::getCommandQueue() const { return Subsystem::getCommandQueue(); }
@@ -93,7 +99,11 @@ ReturnValue_t ComSubsystem::initialize() {
                     "listener"
                  << std::endl;
 #endif
-    return ObjectManagerIF::CHILD_INIT_FAILED;
+  }
+  result = manager->subscribeToEvent(eventQueue->getId(),
+                                     event::getEventId(tcsCtrl::SYRLINKS_OVERHEATING));
+  if (result != returnvalue::OK) {
+    return ObjectManager::CHILD_INIT_FAILED;
   }
   result = manager->subscribeToEventRange(eventQueue->getId(),
                                           event::getEventId(PdecHandler::CARRIER_LOCK),
@@ -144,6 +154,19 @@ void ComSubsystem::readEventQueue() {
 void ComSubsystem::handleEventMessage(EventMessage *eventMessage) {
   Event event = eventMessage->getEvent();
   switch (event) {
+    case tcsCtrl::SYRLINKS_OVERHEATING: {
+      // This event overrides the bit lock.
+      rememberBitLock = false;
+      if (mode == com::RX_ONLY) {
+        return;
+      }
+      if (isInTransition) {
+        performRecoveryToRxOnly = true;
+        return;
+      }
+      startRxOnlyRecovery(true);
+      break;
+    }
     case PdecHandler::BIT_LOCK_PDEC: {
       handleBitLockEvent();
       break;
@@ -191,6 +214,12 @@ void ComSubsystem::checkTransmitterCountdown() {
   }
 }
 
+void ComSubsystem::startRxOnlyRecovery(bool forced) {
+  modeHelper.setForced(forced);
+  startTransition(com::RX_ONLY, 0);
+  performRecoveryToRxOnly = false;
+}
+
 bool ComSubsystem::isTxMode(Mode_t mode) {
   if ((mode == com::Submode::RX_AND_TX_DEFAULT_DATARATE) ||
       (mode == com::Submode::RX_AND_TX_LOW_DATARATE) ||

mission/system/com/ComSubsystem.h

@@ -57,6 +57,7 @@ class ComSubsystem : public Subsystem, public ReceivesParameterMessagesIF {
    * @brief	Enables transmitter in low rate mode
    */
   void startRxAndTxLowRateSeq();
+  void startRxOnlyRecovery(bool forced);
 
   /**
    * @brief	Returns true if mode is a mode where the transmitter is on
@@ -73,6 +74,7 @@ class ComSubsystem : public Subsystem, public ReceivesParameterMessagesIF {
   MessageQueueIF *eventQueue = nullptr;
 
   bool enableTxWhenCarrierLock = false;
+  bool performRecoveryToRxOnly = false;
 
   // Countdown will be started as soon as the transmitter was enabled
   Countdown transmitterCountdown;

mission/system/objects/CamSwitcher.cpp

@@ -3,3 +3,8 @@
 CamSwitcher::CamSwitcher(object_id_t objectId, PowerSwitchIF &pwrSwitcher,
                          power::Switch_t pwrSwitch)
     : PowerSwitcherComponent(objectId, &pwrSwitcher, pwrSwitch) {}
+void CamSwitcher::performFaultyOperation() {
+  if (not switcher.active() and switcher.getState() != PowerSwitcher::SWITCH_IS_OFF) {
+    switcher.turnOff();
+  }
+}

mission/system/objects/CamSwitcher.h

@@ -8,6 +8,7 @@ class CamSwitcher : public PowerSwitcherComponent {
   CamSwitcher(object_id_t objectId, PowerSwitchIF &pwrSwitcher, power::Switch_t pwrSwitch);
 
  private:
+  void performFaultyOperation() override;
 };
 
 #endif /* MISSION_SYSTEM_OBJECTS_CAMSWITCHER_H_ */

mission/system/objects/EiveSystem.cpp

@@ -4,11 +4,15 @@
 #include <fsfw/events/EventManager.h>
 #include <fsfw/ipc/QueueFactory.h>
 #include <mission/acs/defs.h>
+#include <mission/com/defs.h>
+#include <mission/controller/tcsDefs.h>
+
+#include "mission/sysDefs.h"
 
 EiveSystem::EiveSystem(object_id_t setObjectId, uint32_t maxNumberOfSequences,
                        uint32_t maxNumberOfTables)
     : Subsystem(setObjectId, maxNumberOfSequences, maxNumberOfTables) {
-  auto mqArgs = MqArgs(getObjectId(), static_cast<void*>(this));
+  auto mqArgs = MqArgs(SubsystemBase::getObjectId(), static_cast<void*>(this));
   eventQueue =
       QueueFactory::instance()->createMessageQueue(10, EventMessage::EVENT_MESSAGE_SIZE, &mqArgs);
 }
@@ -16,15 +20,15 @@ EiveSystem::EiveSystem(object_id_t setObjectId, uint32_t maxNumberOfSequences,
 void EiveSystem::announceMode(bool recursive) {
   const char* modeStr = "UNKNOWN";
   switch (mode) {
-    case (acs::AcsMode::OFF): {
+    case (satsystem::Mode::BOOT): {
-      modeStr = "OFF";
+      modeStr = "OFF/BOOT";
       break;
     }
-    case (acs::AcsMode::SAFE): {
+    case (satsystem::Mode::SAFE): {
       modeStr = "SAFE";
       break;
     }
-    case (acs::AcsMode::PTG_IDLE): {
+    case (satsystem::Mode::PTG_IDLE): {
       modeStr = "POINTING IDLE";
       break;
     }
@@ -46,12 +50,16 @@ void EiveSystem::announceMode(bool recursive) {
 }
 
 void EiveSystem::performChildOperation() {
+  Subsystem::performChildOperation();
   handleEventMessages();
-  return Subsystem::performChildOperation();
+  if (not isInTransition and performSafeRecovery) {
+    commandSelfToSafe();
+    performSafeRecovery = false;
+  }
 }
 
 ReturnValue_t EiveSystem::initialize() {
-  EventManagerIF* manager = ObjectManager::instance()->get<EventManagerIF>(objects::EVENT_MANAGER);
+  auto* manager = ObjectManager::instance()->get<EventManagerIF>(objects::EVENT_MANAGER);
   if (manager == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "AcsSubsystem::initialize: Invalid event manager" << std::endl;
@@ -67,21 +75,37 @@ ReturnValue_t EiveSystem::initialize() {
 #endif
     return ObjectManagerIF::CHILD_INIT_FAILED;
   }
+  manager->subscribeToEvent(eventQueue->getId(),
+                            event::getEventId(tcsCtrl::PCDU_SYSTEM_OVERHEATING));
+  manager->subscribeToEvent(eventQueue->getId(), event::getEventId(tcsCtrl::OBC_OVERHEATING));
+
   return Subsystem::initialize();
 }
 
 void EiveSystem::handleEventMessages() {
   EventMessage event;
-  for (ReturnValue_t result = eventQueue->receiveMessage(&event); result == returnvalue::OK;
+  for (ReturnValue_t status = eventQueue->receiveMessage(&event); status == returnvalue::OK;
-       result = eventQueue->receiveMessage(&event)) {
+       status = eventQueue->receiveMessage(&event)) {
     switch (event.getMessageId()) {
       case EventMessage::EVENT_MESSAGE:
+        switch (event.getEvent()) {
+          case tcsCtrl::OBC_OVERHEATING:
+          case tcsCtrl::PCDU_SYSTEM_OVERHEATING: {
+            if (isInTransition) {
+              performSafeRecovery = true;
+              return;
+            }
+
+            commandSelfToSafe();
+            break;
+          }
+        }
         break;
       default:
-        sif::debug << "AcsSubsystem::performChildOperation: Did not subscribe "
+        sif::debug << "EiveSystem: Did not subscribe to event " << event.getEvent() << std::endl;
-                      "to this event message"
-                   << std::endl;
         break;
     }
   }
 }
+
+void EiveSystem::commandSelfToSafe() { startTransition(satsystem::Mode::SAFE, 0); }

mission/system/objects/EiveSystem.h

@@ -8,12 +8,14 @@ class EiveSystem : public Subsystem {
   EiveSystem(object_id_t setObjectId, uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables);
 
  private:
+  MessageQueueIF* eventQueue = nullptr;
+  bool performSafeRecovery = false;
+
   ReturnValue_t initialize() override;
   void performChildOperation() override;
   void announceMode(bool recursive) override;
   void handleEventMessages();
-
+  void commandSelfToSafe();
-  MessageQueueIF* eventQueue = nullptr;
 };
 
 #endif /* MISSION_SYSTEM_EIVESYSTEM_H_ */

mission/system/objects/Stack5VHandler.h

@@ -31,7 +31,7 @@ class Stack5VHandler {
   HandlerState handlerState = HandlerState::IDLE;
   bool radSensorIsOn = false;
   bool plPcduIsOn = false;
-  pcdu::Switches stackSwitch = pcdu::Switches::P60_DOCK_5V_STACK;
+  power::Switches stackSwitch = power::Switches::P60_DOCK_5V_STACK;
 
   bool updateInternalStates();
 };

mission/tcs/HeaterHandler.cpp

@@ -38,7 +38,7 @@ HeaterHandler::HeaterHandler(object_id_t setObjectId_, GpioIF* gpioInterface_, H
       cmdQueueSize, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
 
-HeaterHandler::~HeaterHandler() {}
+HeaterHandler::~HeaterHandler() = default;
 
 ReturnValue_t HeaterHandler::performOperation(uint8_t operationCode) {
   try {
@@ -259,7 +259,7 @@ void HeaterHandler::handleSwitchOnCommand(heater::Switchers heaterIdx) {
   // Check state of main line switch
   ReturnValue_t mainSwitchState = mainLineSwitcher->getSwitchState(mainLineSwitch);
   if (mainSwitchState == PowerSwitchIF::SWITCH_ON) {
-    if (checkSwitchState(heaterIdx) == SwitchState::OFF) {
+    if (getSwitchState(heaterIdx) == SwitchState::OFF) {
       gpioId_t gpioId = heater.gpioId;
       result = gpioInterface->pullHigh(gpioId);
       if (result != returnvalue::OK) {
@@ -292,12 +292,13 @@ void HeaterHandler::handleSwitchOnCommand(heater::Switchers heaterIdx) {
   } else if (mainSwitchState == PowerSwitchIF::SWITCH_OFF && heater.waitMainSwitchOn) {
     // Just waiting for the main switch being set on
     return;
-  } else if (mainSwitchState == PowerSwitchIF::SWITCH_OFF) {
+  } else if (mainSwitchState == PowerSwitchIF::SWITCH_OFF or
+      mainSwitchState == PowerSwitchIF::SWITCH_UNKNOWN) {
     mainLineSwitcher->sendSwitchCommand(mainLineSwitch, PowerSwitchIF::SWITCH_ON);
     heater.mainSwitchCountdown.setTimeout(mainLineSwitcher->getSwitchDelayMs());
     heater.waitMainSwitchOn = true;
   } else {
-    sif::debug << "HeaterHandler::handleSwitchHandling: Failed to get state of"
+    sif::debug << "HeaterHandler::handleSwitchOnCommand: Failed to get state of"
                << " main line switch" << std::endl;
     if (heater.replyQueue != commandQueue->getId()) {
       actionHelper.finish(false, heater.replyQueue, heater.action, mainSwitchState);
@@ -310,7 +311,7 @@ void HeaterHandler::handleSwitchOffCommand(heater::Switchers heaterIdx) {
   ReturnValue_t result = returnvalue::OK;
   auto& heater = heaterVec.at(heaterIdx);
   // Check whether switch is already off
-  if (checkSwitchState(heaterIdx)) {
+  if (getSwitchState(heaterIdx)) {
     gpioId_t gpioId = heater.gpioId;
     result = gpioInterface->pullLow(gpioId);
     if (result != returnvalue::OK) {
@@ -344,7 +345,7 @@ void HeaterHandler::handleSwitchOffCommand(heater::Switchers heaterIdx) {
   heater.cmdActive = false;
 }
 
-HeaterHandler::SwitchState HeaterHandler::checkSwitchState(heater::Switchers switchNr) const {
+HeaterHandler::SwitchState HeaterHandler::getSwitchState(heater::Switchers switchNr) const {
   MutexGuard mg(handlerLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
   return heaterVec.at(switchNr).switchState;
 }
@@ -428,7 +429,7 @@ ReturnValue_t HeaterHandler::getSwitchState(uint8_t switchNr) const {
   if (switchNr > 7) {
     return returnvalue::FAILED;
   }
-  if (checkSwitchState(static_cast<heater::Switchers>(switchNr)) == SwitchState::ON) {
+  if (getSwitchState(static_cast<heater::Switchers>(switchNr)) == SwitchState::ON) {
     return PowerSwitchIF::SWITCH_ON;
   }
   return PowerSwitchIF::SWITCH_OFF;

mission/tcs/HeaterHandler.h

@@ -174,7 +174,7 @@ class HeaterHandler : public ExecutableObjectIF,
    * @brief   Returns the state of a switch (ON - true, or OFF - false).
    * @param switchNr  The number of the switch to check.
    */
-  SwitchState checkSwitchState(heater::Switchers switchNr) const;
+  SwitchState getSwitchState(heater::Switchers switchNr) const;
 
   /**
    * @brief	This function runs commands waiting for execution.

tmtc

@@ -1 +1 @@
-Subproject commit 0f2daf94dfaf3651330275ce5e5868fab263b56f
+Subproject commit cef8d623c9fa11237fc8e51e5fd4dab750a5602b

unittest/controller/testThermalController.cpp

@@ -4,6 +4,7 @@
 #include <fsfw/tasks/PeriodicTaskIF.h>
 #include <fsfw/tasks/TaskFactory.h>
 #include <mission/controller/ThermalController.h>
+#include <mission/system/objects/CamSwitcher.h>
 
 #include <catch2/catch_test_macros.hpp>
 
@@ -19,7 +20,8 @@ TEST_CASE("Thermal Controller", "[ThermalController]") {
   TemperatureSensorInserter::Tmp1075DummyMap map1;
   new TemperatureSensorInserter(objects::THERMAL_TEMP_INSERTER, map0, map1);
   auto dummyGpioIF = new DummyGpioIF();
-  auto dummySwitcher = new DummyPowerSwitcher(objects::PCDU_HANDLER, 18, 0);
+  auto* dummySwitcher = new DummyPowerSwitcher(objects::PCDU_HANDLER, 18, 0);
+  new CamSwitcher(objects::CAM_SWITCHER, *dummySwitcher, power::Switches::PDU2_CH8_PAYLOAD_CAMERA);
   // TODO: Create dummy heater handler
   HeaterHandler* heaterHandler = nullptr;
   // new ThermalController(objects::THERMAL_CONTROLLER);