Merge pull request 'v6.1.0' (#740) from prep_v6.1.0 into main

Reviewed-on: #740

CHANGELOG.md

@@ -16,10 +16,68 @@ will consitute of a breaking change warranting a new major release:
 
 # [unreleased]
 
-# [v6.0.0] to be released
+# [v6.1.0] 2023-07-13
 
+- `eive-tmtc`: v5.2.0
+
+## Changed
+
+- TCS: Remove OBC IF board thermal module, which is exactly identical to OBC module and therefore
+  obsolete.
+- Swapped PL and PS I2C, BPX battery and MGT are connected to PS I2C now for firmware versions
+  equal or above v4. However, this software version is compatible to both v3 and v4 of the firmware.
+- The firmware version variables are global statics inititalized early during the program
+  runtime now. This makes it possible to check the firmware version earlier.
+- The TCS controller will now always command heaters OFF when being blind for thermal
+  components (no sensors available), irrespective of current switch state.
+- Make OBSW compatible to prospective FW version v5.0.0, where the Q7 I2C devices were
+  moved to a PL I2C block and the TMP sensor devices were moved to the PS I2C0.
+- Made `Xadc` code a little bit more robust against errors.
+
+## Fixed
+
+- TMP1075: Set dataset invalid on shutdown explicitely
+- Small fixes for TMP1075 FDIR: Use strange and missed reply counters.
+- TCS controller: Last heater (S-band heater) was skipped for transition completion
+  checks.
+- TCS controller: A helper member to track the elapsed heater control cycles was not reset
+  properly, which could lead to switch transitions being completed immediately. This can
+  lead to weird bugs like heaters being commanded ON twice and can potentially lead to
+  other bugs.
+- TMP1075: Devices did not go to OFF mode when being set faulty.
+- Update PL PCDU 1 in TCS mode tree on the EM.
+- TMP1075: Possibly ignored health commands.
+- Bugfix in FSFW where certain packet types could only be sent with source data fields with a
+  maximum size of 255 bytes.
+- TCS CTRL: Limit number of heater handler messages sent in case there are not sensors available
+  anymore.
+- Fix to allow adding real STR device for EM.
+
+# Added
+
+- Two events for heaters being commanded ON and OFF by the TCS controller
+- Upper limit for burn time of TCS heaters. Currently set to 1 hour for each heater.
+  This mechanism will only track the burn time for heaters which were commanded by the
+  TCS controller.
+- TCS controller is now observable by introducing a new HK dataset which exposes some internal
+  fields related to TCS control.
+
+# [v6.0.0] 2023-07-02
+
+- `q7s-package` version v3.2.0
 - Important bugfixes for PTME. See `q7s-package` CHANGELOG.
 
+## Changed
+
+- Added back PTME busy bit polling. This is necessary due to changes to the AXI APB interface
+  to the PTME core.
+
+## Fixed
+
+- For the live channel (VC0), telemetry was still only dumped if the transmitter is active.
+  Please note that this fix will lead to crashes for FW versions below v3.2.
+  However, it might not be an issue for the oldest firmware on the satellite (v2.5.1).
+
 # [v5.2.0] 2023-07-02
 
 ## Fixed

CMakeLists.txt

@@ -9,8 +9,8 @@
 # ##############################################################################
 cmake_minimum_required(VERSION 3.13)
 
-set(OBSW_VERSION_MAJOR 5)
-set(OBSW_VERSION_MINOR 2)
+set(OBSW_VERSION_MAJOR 6)
+set(OBSW_VERSION_MINOR 1)
 set(OBSW_VERSION_REVISION 0)
 
 # set(CMAKE_VERBOSE TRUE)
@@ -150,7 +150,7 @@ set(OBSW_ADD_SYRLINKS
     1
     CACHE STRING "Add Syrlinks module")
 set(OBSW_ADD_TMP_DEVICES
-    ${INIT_VAL}
+    1
     CACHE STRING "Add TMP devices")
 set(OBSW_ADD_GOMSPACE_PCDU
     1

README.md

@@ -964,6 +964,12 @@ used by other software components to read the current chip and copy.
 This is a configuration scripts which runs after the Network Time Protocol has run. This script
 currently sets the static IP address `192.168.133.10` and starts the `can` interface.
 
+## Initial boot delay
+
+You can create a file named `boot_delays_secs.txt` inside the home folder to delay the OBSW boot
+for 6 seconds if the file is empty of for the number of seconds specified inside the file. This
+can be helpful if something inside the OBSW leads to an immediate crash of the OBC.
+
 ## PCDU
 
 Connect to serial console of P60 Dock

bsp_hosted/ObjectFactory.cpp

@@ -113,7 +113,7 @@ void ObjectFactory::produce(void* args) {
   if (heaterHandler == nullptr) {
     sif::error << "HeaterHandler could not be created" << std::endl;
   } else {
-    ObjectFactory::createThermalController(*heaterHandler);
+    ObjectFactory::createThermalController(*heaterHandler, true);
   }
   new TestTask(objects::TEST_TASK);
 }

bsp_hosted/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 296 translations.
+ * @brief    Auto-generated event translation file. Contains 299 translations.
  * @details
- * Generated on: 2023-06-21 19:01:02
+ * Generated on: 2023-07-07 12:06:06
  */
 #include "translateEvents.h"
 
@@ -286,6 +286,9 @@ const char *CAMERA_OVERHEATING_STRING = "CAMERA_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 *MGT_OVERHEATING_STRING = "MGT_OVERHEATING";
+const char *TCS_SWITCHING_HEATER_ON_STRING = "TCS_SWITCHING_HEATER_ON";
+const char *TCS_SWITCHING_HEATER_OFF_STRING = "TCS_SWITCHING_HEATER_OFF";
+const char *TCS_HEATER_MAX_BURN_TIME_REACHED_STRING = "TCS_HEATER_MAX_BURN_TIME_REACHED";
 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";
@@ -866,6 +869,12 @@ const char *translateEvents(Event event) {
       return HEATER_NOT_OFF_FOR_OFF_MODE_STRING;
     case (14108):
       return MGT_OVERHEATING_STRING;
+    case (14109):
+      return TCS_SWITCHING_HEATER_ON_STRING;
+    case (14110):
+      return TCS_SWITCHING_HEATER_OFF_STRING;
+    case (14111):
+      return TCS_HEATER_MAX_BURN_TIME_REACHED_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-06-21 19:01:02
+ * Generated on: 2023-07-07 12:06:06
  */
 #include "translateObjects.h"
 

bsp_q7s/CMakeLists.txt

@@ -7,7 +7,8 @@ target_link_libraries(${SIMPLE_OBSW_NAME} PUBLIC ${LIB_FSFW_NAME})
 target_compile_definitions(${SIMPLE_OBSW_NAME} PRIVATE "Q7S_SIMPLE_MODE")
 add_subdirectory(simple)
 
-target_sources(${OBSW_NAME} PUBLIC main.cpp obsw.cpp)
+target_sources(${OBSW_NAME} PUBLIC main.cpp obsw.cpp scheduling.cpp
+                                   objectFactory.cpp)
 
 add_subdirectory(boardtest)
 

bsp_q7s/boardconfig/busConf.h

@@ -12,6 +12,9 @@ static constexpr char SPI_RW_DEV[] = "/dev/spi_rw";
 static constexpr char I2C_PL_EIVE[] = "/dev/i2c_pl";
 //! I2C bus using the I2C peripheral of the ARM processing system (PS)
 static constexpr char I2C_PS_EIVE[] = "/dev/i2c_ps";
+//! I2C bus using the first I2C peripheral of the ARM processing system (PS).
+//! Named like this because it is used by default for the Q7 devices.
+static constexpr char I2C_Q7_EIVE[] = "/dev/i2c_q7";
 
 static constexpr char UART_GNSS_DEV[] = "/dev/gps0";
 static constexpr char UART_PLOC_MPSOC_DEV[] = "/dev/ul_plmpsoc";
@@ -85,13 +88,9 @@ static constexpr char EN_RW_4[] = "enable_rw_4";
 static constexpr char RAD_SENSOR_CHIP_SELECT[] = "rad_sensor_chip_select";
 static constexpr char ENABLE_RADFET[] = "enable_radfet";
 
-static constexpr char PAPB_BUSY_SIGNAL_VC0[] = "papb_busy_signal_vc0";
 static constexpr char PAPB_EMPTY_SIGNAL_VC0[] = "papb_empty_signal_vc0";
-static constexpr char PAPB_BUSY_SIGNAL_VC1[] = "papb_busy_signal_vc1";
 static constexpr char PAPB_EMPTY_SIGNAL_VC1[] = "papb_empty_signal_vc1";
-static constexpr char PAPB_BUSY_SIGNAL_VC2[] = "papb_busy_signal_vc2";
 static constexpr char PAPB_EMPTY_SIGNAL_VC2[] = "papb_empty_signal_vc2";
-static constexpr char PAPB_BUSY_SIGNAL_VC3[] = "papb_busy_signal_vc3";
 static constexpr char PAPB_EMPTY_SIGNAL_VC3[] = "papb_empty_signal_vc3";
 
 static constexpr char PTME_RESETN[] = "ptme_resetn";

bsp_q7s/core/CMakeLists.txt

@@ -1,4 +1 @@
-target_sources(${OBSW_NAME} PRIVATE CoreController.cpp scheduling.cpp
-                                    ObjectFactory.cpp WatchdogHandler.cpp)
-
-target_sources(${SIMPLE_OBSW_NAME} PRIVATE scheduling.cpp)
+target_sources(${OBSW_NAME} PRIVATE CoreController.cpp WatchdogHandler.cpp)

bsp_q7s/core/CoreController.cpp

@@ -188,17 +188,6 @@ ReturnValue_t CoreController::initialize() {
   }
   triggerEvent(core::REBOOT_SW, CURRENT_CHIP, CURRENT_COPY);
   announceCurrentImageInfo();
-  // This has to come before the version announce because it might be required for retrieving
-  // the firmware version.
-  if (common::OBSW_VERSION_MAJOR >= 6 or common::OBSW_VERSION_MAJOR == 4) {
-    UioMapper sysRomMapper(q7s::UIO_SYS_ROM);
-    result = sysRomMapper.getMappedAdress(&mappedSysRomAddr, UioMapper::Permissions::READ_ONLY);
-    if (result != returnvalue::OK) {
-      // TODO: This might be a reason to switch to another image..
-      sif::error << "Getting mapped SYS ROM UIO address failed" << std::endl;
-      result = ObjectManager::CHILD_INIT_FAILED;
-    }
-  }
   announceVersionInfo();
 
   return result;
@@ -2526,14 +2515,10 @@ void CoreController::announceVersionInfo() {
   }
 
   triggerEvent(VERSION_INFO, p1, p2);
-
-  if (common::OBSW_VERSION_MAJOR >= 6 or common::OBSW_VERSION_MAJOR == 4) {
-    if (mappedSysRomAddr != nullptr) {
-      uint32_t p1Firmware = *(reinterpret_cast<uint32_t *>(mappedSysRomAddr));
-      uint32_t p2Firmware = *(reinterpret_cast<uint32_t *>(mappedSysRomAddr) + 1);
-      triggerEvent(FIRMWARE_INFO, p1Firmware, p2Firmware);
-    }
-  }
+  p1 = (core::FW_VERSION_MAJOR << 24) | (core::FW_VERSION_MINOR << 16) |
+       (core::FW_VERSION_REVISION << 8) | (core::FW_VERSION_HAS_SHA);
+  std::memcpy(&p2, core::FW_VERSION_GIT_SHA, 4);
+  triggerEvent(FIRMWARE_INFO, p1, p2);
 }
 
 void CoreController::announceCurrentImageInfo() {

bsp_q7s/core/CoreController.h

@@ -1,6 +1,7 @@
 #ifndef BSP_Q7S_CORE_CORECONTROLLER_H_
 #define BSP_Q7S_CORE_CORECONTROLLER_H_
 
+#include <bsp_q7s/core/defs.h>
 #include <fsfw/container/DynamicFIFO.h>
 #include <fsfw/container/SimpleRingBuffer.h>
 #include <fsfw/globalfunctions/PeriodicOperationDivider.h>
@@ -14,7 +15,6 @@
 #include <atomic>
 #include <cstddef>
 
-#include "CoreDefinitions.h"
 #include "OBSWConfig.h"
 #include "bsp_q7s/fs/SdCardManager.h"
 #include "events/subsystemIdRanges.h"

bsp_q7s/core/defs.h

@@ -1,10 +1,16 @@
-#ifndef BSP_Q7S_CORE_COREDEFINITIONS_H_
-#define BSP_Q7S_CORE_COREDEFINITIONS_H_
+#ifndef BSP_Q7S_CORE_DEFS_H_
+#define BSP_Q7S_CORE_DEFS_H_
 
 #include <fsfw/datapoollocal/StaticLocalDataSet.h>
 
 namespace core {
 
+extern uint8_t FW_VERSION_MAJOR;
+extern uint8_t FW_VERSION_MINOR;
+extern uint8_t FW_VERSION_REVISION;
+extern bool FW_VERSION_HAS_SHA;
+extern char FW_VERSION_GIT_SHA[4];
+
 static const uint8_t HK_SET_ENTRIES = 3;
 static const uint32_t HK_SET_ID = 5;
 
@@ -36,4 +42,4 @@ class HkSet : public StaticLocalDataSet<HK_SET_ENTRIES> {
 
 }  // namespace core
 
-#endif /* BSP_Q7S_CORE_COREDEFINITIONS_H_ */
+#endif /* BSP_Q7S_CORE_DEFS_H_ */

bsp_q7s/em/emObjectFactory.cpp

@@ -1,4 +1,5 @@
 #include <bsp_q7s/callbacks/q7sGpioCallbacks.h>
+#include <bsp_q7s/objectFactory.h>
 #include <dummies/ComCookieDummy.h>
 #include <dummies/PcduHandlerDummy.h>
 #include <fsfw/health/HealthTableIF.h>
@@ -10,8 +11,8 @@
 
 #include "OBSWConfig.h"
 #include "bsp_q7s/core/CoreController.h"
-#include "bsp_q7s/core/ObjectFactory.h"
 #include "busConf.h"
+#include "common/config/devices/addresses.h"
 #include "devConf.h"
 #include "dummies/helperFactory.h"
 #include "eive/objects.h"
@@ -35,6 +36,7 @@ void ObjectFactory::produce(void* args) {
 #endif
 
   PersistentTmStores stores;
+  readFirmwareVersion();
   ObjectFactory::produceGenericObjects(&healthTable, &pusFunnel, &cfdpFunnel,
                                        *SdCardManager::instance(), &ipcStore, &tmStore, stores, 200,
                                        enableHkSets);
@@ -44,7 +46,7 @@ void ObjectFactory::produce(void* args) {
   SpiComIF* spiMainComIF = nullptr;
   I2cComIF* i2cComIF = nullptr;
   createCommunicationInterfaces(&gpioComIF, &uartComIF, &spiMainComIF, &i2cComIF);
-  /* Adding gpios for chip select decoding to the gpioComIf */
+  // Adding GPIOs for chip select decoding and initializing them.
   q7s::gpioCallbacks::initSpiCsDecoder(gpioComIF);
   gpioCallbacks::disableAllDecoder(gpioComIF);
   createPlI2cResetGpio(gpioComIF);
@@ -60,11 +62,29 @@ void ObjectFactory::produce(void* args) {
 #if OBSW_ADD_PLOC_SUPERVISOR == 1 || OBSW_ADD_PLOC_MPSOC == 1
   dummyCfg.addPlocDummies = false;
 #endif
+#if OBSW_ADD_TMP_DEVICES == 1
+  std::vector<std::pair<object_id_t, address_t>> tmpDevsToAdd = {{
+      {objects::TMP1075_HANDLER_PLPCDU_0, addresses::TMP1075_PLPCDU_0},
+      {objects::TMP1075_HANDLER_PLPCDU_1, addresses::TMP1075_PLPCDU_1},
+      {objects::TMP1075_HANDLER_IF_BOARD, addresses::TMP1075_IF_BOARD},
+  }};
+  createTmpComponents(tmpDevsToAdd);
+  dummy::Tmp1075Cfg tmpCfg{};
+  tmpCfg.addTcsBrd0 = true;
+  tmpCfg.addTcsBrd1 = true;
+  tmpCfg.addPlPcdu0 = false;
+  tmpCfg.addPlPcdu1 = false;
+  tmpCfg.addIfBrd = false;
+  dummyCfg.tmp1075Cfg = tmpCfg;
+#endif
 #if OBSW_ADD_GOMSPACE_PCDU == 1
   dummyCfg.addPowerDummies = false;
   // The ACU broke.
   dummyCfg.addOnlyAcuDummy = true;
 #endif
+#if OBSW_ADD_STAR_TRACKER == 1
+  dummyCfg.addStrDummy = false;
+#endif
 #if OBSW_ADD_BPX_BATTERY_HANDLER == 1
   dummyCfg.addBpxBattDummy = false;
 #endif
@@ -97,8 +117,12 @@ void ObjectFactory::produce(void* args) {
   gpioChecker(gpioComIF->addGpios(acsBoardGpios), "ACS Board");
 #endif
 
+  const char* battAndImtqI2cDev = q7s::I2C_PL_EIVE;
+  if (core::FW_VERSION_MAJOR >= 4) {
+    battAndImtqI2cDev = q7s::I2C_PS_EIVE;
+  }
 #if OBSW_ADD_MGT == 1
-  createImtqComponents(pwrSwitcher, enableHkSets);
+  createImtqComponents(pwrSwitcher, enableHkSets, battAndImtqI2cDev);
 #endif
 
 #if OBSW_ADD_SYRLINKS == 1
@@ -110,7 +134,7 @@ void ObjectFactory::produce(void* args) {
 #endif
 
 #if OBSW_ADD_BPX_BATTERY_HANDLER == 1
-  createBpxBatteryComponent(enableHkSets);
+  createBpxBatteryComponent(enableHkSets, battAndImtqI2cDev);
 #endif
 
 #if OBSW_ADD_STAR_TRACKER == 1
@@ -142,6 +166,6 @@ void ObjectFactory::produce(void* args) {
   createAcsController(true, enableHkSets);
   HeaterHandler* heaterHandler;
   createHeaterComponents(gpioComIF, pwrSwitcher, healthTable, heaterHandler);
-  createThermalController(*heaterHandler);
-  satsystem::init();
+  createThermalController(*heaterHandler, true);
+  satsystem::init(true);
 }

bsp_q7s/fmObjectFactory.cpp

@@ -1,4 +1,5 @@
 #include <bsp_q7s/callbacks/q7sGpioCallbacks.h>
+#include <bsp_q7s/objectFactory.h>
 #include <devices/gpioIds.h>
 #include <fsfw/storagemanager/LocalPool.h>
 #include <fsfw/storagemanager/PoolManager.h>
@@ -7,9 +8,9 @@
 
 #include "OBSWConfig.h"
 #include "bsp_q7s/core/CoreController.h"
-#include "bsp_q7s/core/ObjectFactory.h"
 #include "busConf.h"
 #include "devConf.h"
+#include "devices/addresses.h"
 #include "eive/objects.h"
 #include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
 #include "linux/ObjectFactory.h"
@@ -32,6 +33,7 @@ void ObjectFactory::produce(void* args) {
 #endif
 
   PersistentTmStores stores;
+  readFirmwareVersion();
   ObjectFactory::produceGenericObjects(&healthTable, &pusFunnel, &cfdpFunnel,
                                        *SdCardManager::instance(), &ipcStore, &tmStore, stores, 200,
                                        true);
@@ -67,7 +69,16 @@ void ObjectFactory::produce(void* args) {
   HeaterHandler* heaterHandler;
   createHeaterComponents(gpioComIF, pwrSwitcher, healthTable, heaterHandler);
 #if OBSW_ADD_TMP_DEVICES == 1
-  createTmpComponents();
+  std::vector<std::pair<object_id_t, address_t>> tmpDevsToAdd = {{
+      {objects::TMP1075_HANDLER_TCS_0, addresses::TMP1075_TCS_0},
+      {objects::TMP1075_HANDLER_TCS_1, addresses::TMP1075_TCS_1},
+      {objects::TMP1075_HANDLER_PLPCDU_0, addresses::TMP1075_PLPCDU_0},
+      // damaged
+      // {objects::TMP1075_HANDLER_PLPCDU_1, addresses::TMP1075_PLPCDU_1},
+      {objects::TMP1075_HANDLER_IF_BOARD, addresses::TMP1075_IF_BOARD},
+  }};
+
+  createTmpComponents(tmpDevsToAdd);
 #endif
   createSolarArrayDeploymentComponents(*pwrSwitcher, *gpioComIF);
   createPlPcduComponents(gpioComIF, spiMainComIF, pwrSwitcher, *stackHandler);
@@ -77,13 +88,17 @@ void ObjectFactory::produce(void* args) {
   createRtdComponents(q7s::SPI_DEFAULT_DEV, gpioComIF, pwrSwitcher, spiMainComIF);
   createPayloadComponents(gpioComIF, *pwrSwitcher);
 
+  const char* battAndImtqI2cDev = q7s::I2C_PL_EIVE;
+  if (core::FW_VERSION_MAJOR >= 4) {
+    battAndImtqI2cDev = q7s::I2C_PS_EIVE;
+  }
 #if OBSW_ADD_MGT == 1
-  createImtqComponents(pwrSwitcher, enableHkSets);
+  createImtqComponents(pwrSwitcher, enableHkSets, battAndImtqI2cDev);
 #endif
   createReactionWheelComponents(gpioComIF, pwrSwitcher);
 
 #if OBSW_ADD_BPX_BATTERY_HANDLER == 1
-  createBpxBatteryComponent(enableHkSets);
+  createBpxBatteryComponent(enableHkSets, battAndImtqI2cDev);
 #endif
 
 #if OBSW_ADD_STAR_TRACKER == 1
@@ -113,7 +128,7 @@ void ObjectFactory::produce(void* args) {
 #endif /* OBSW_ADD_TEST_CODE == 1 */
 
   createMiscComponents();
-  createThermalController(*heaterHandler);
+  createThermalController(*heaterHandler, false);
   createAcsController(true, enableHkSets);
-  satsystem::init();
+  satsystem::init(false);
 }

bsp_q7s/objectFactory.cpp

@@ -1,8 +1,9 @@
-#include "ObjectFactory.h"
+#include "objectFactory.h"
 
 #include <fsfw/devicehandlers/HealthDevice.h>
 #include <fsfw/subsystem/Subsystem.h>
 #include <fsfw/tasks/TaskFactory.h>
+#include <fsfw_hal/linux/uio/UioMapper.h>
 #include <linux/acs/AcsBoardPolling.h>
 #include <linux/acs/GpsHyperionLinuxController.h>
 #include <linux/acs/ImtqPollingTask.h>
@@ -32,6 +33,9 @@
 #include <mission/system/objects/CamSwitcher.h>
 #include <mission/system/tcs/TmpDevFdir.h>
 
+#include <cstdint>
+#include <cstring>
+
 #include "OBSWConfig.h"
 #include "bsp_q7s/boardtest/Q7STestTask.h"
 #include "bsp_q7s/callbacks/gnssCallback.h"
@@ -100,6 +104,7 @@
 
 #include <sstream>
 
+#include "bsp_q7s/core/defs.h"
 #include "fsfw/datapoollocal/LocalDataPoolManager.h"
 #include "fsfw/tmtcpacket/pus/tm.h"
 #include "fsfw/tmtcservices/CommandingServiceBase.h"
@@ -130,6 +135,11 @@ ResetArgs RESET_ARGS_GNSS;
 std::atomic_bool LINK_STATE = CcsdsIpCoreHandler::LINK_DOWN;
 std::atomic_bool PTME_LOCKED = false;
 std::atomic_uint16_t I2C_FATAL_ERRORS = 0;
+uint8_t core::FW_VERSION_MAJOR = 0;
+uint8_t core::FW_VERSION_MINOR = 0;
+uint8_t core::FW_VERSION_REVISION = 0;
+bool core::FW_VERSION_HAS_SHA = false;
+char core::FW_VERSION_GIT_SHA[4] = {};
 
 void Factory::setStaticFrameworkObjectIds() {
   PusServiceBase::PUS_DISTRIBUTOR = objects::PUS_PACKET_DISTRIBUTOR;
@@ -151,28 +161,23 @@ void Factory::setStaticFrameworkObjectIds() {
 
 void ObjectFactory::setStatics() { Factory::setStaticFrameworkObjectIds(); }
 
-void ObjectFactory::createTmpComponents() {
-  std::vector<std::pair<object_id_t, address_t>> tmpDevIds = {{
-      {objects::TMP1075_HANDLER_TCS_0, addresses::TMP1075_TCS_0},
-      {objects::TMP1075_HANDLER_TCS_1, addresses::TMP1075_TCS_1},
-      {objects::TMP1075_HANDLER_PLPCDU_0, addresses::TMP1075_PLPCDU_0},
-      // damaged
-      // {objects::TMP1075_HANDLER_PLPCDU_1, addresses::TMP1075_PLPCDU_1},
-      {objects::TMP1075_HANDLER_IF_BOARD, addresses::TMP1075_IF_BOARD},
-  }};
+void ObjectFactory::createTmpComponents(
+    std::vector<std::pair<object_id_t, address_t>> tmpDevsToAdd) {
+  const char* tmpI2cDev = q7s::I2C_PS_EIVE;
+  if (core::FW_VERSION_MAJOR == 4) {
+    tmpI2cDev = q7s::I2C_PL_EIVE;
+  } else if (core::FW_VERSION_MAJOR >= 5) {
+    tmpI2cDev = q7s::I2C_Q7_EIVE;
+  }
   std::vector<I2cCookie*> tmpDevCookies;
 
-  for (size_t idx = 0; idx < tmpDevIds.size(); idx++) {
+  for (size_t idx = 0; idx < tmpDevsToAdd.size(); idx++) {
     tmpDevCookies.push_back(
-        new I2cCookie(tmpDevIds[idx].second, TMP1075::MAX_REPLY_LENGTH, q7s::I2C_PS_EIVE));
+        new I2cCookie(tmpDevsToAdd[idx].second, TMP1075::MAX_REPLY_LENGTH, tmpI2cDev));
     auto* tmpDevHandler =
-        new Tmp1075Handler(tmpDevIds[idx].first, objects::I2C_COM_IF, tmpDevCookies[idx]);
-    tmpDevHandler->setCustomFdir(new TmpDevFdir(tmpDevIds[idx].first));
+        new Tmp1075Handler(tmpDevsToAdd[idx].first, objects::I2C_COM_IF, tmpDevCookies[idx]);
+    tmpDevHandler->setCustomFdir(new TmpDevFdir(tmpDevsToAdd[idx].first));
     tmpDevHandler->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
-    // TODO: Remove this after TCS subsystem was added
-    // These devices are connected to the 3V3 stack and should be powered permanently. Therefore,
-    // we set them to normal mode immediately here.
-    tmpDevHandler->setModeNormal();
   }
 }
 
@@ -731,20 +736,12 @@ ReturnValue_t ObjectFactory::createCcsdsComponents(CcsdsComponentArgs& args) {
   // GPIO definitions of signals connected to the virtual channel interfaces of the PTME IP Core
   GpioCookie* gpioCookiePtmeIp = new GpioCookie;
   GpiodRegularByLineName* gpio = nullptr;
-  gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_BUSY_SIGNAL_VC0, "PAPB VC0");
-  gpioCookiePtmeIp->addGpio(gpioIds::VC0_PAPB_BUSY, gpio);
   gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_EMPTY_SIGNAL_VC0, "PAPB VC0");
   gpioCookiePtmeIp->addGpio(gpioIds::VC0_PAPB_EMPTY, gpio);
-  gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_BUSY_SIGNAL_VC1, "PAPB VC1");
-  gpioCookiePtmeIp->addGpio(gpioIds::VC1_PAPB_BUSY, gpio);
   gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_EMPTY_SIGNAL_VC1, "PAPB VC1");
   gpioCookiePtmeIp->addGpio(gpioIds::VC1_PAPB_EMPTY, gpio);
-  gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_BUSY_SIGNAL_VC2, "PAPB VC2");
-  gpioCookiePtmeIp->addGpio(gpioIds::VC2_PAPB_BUSY, gpio);
   gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_EMPTY_SIGNAL_VC2, "PAPB VC2");
   gpioCookiePtmeIp->addGpio(gpioIds::VC2_PAPB_EMPTY, gpio);
-  gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_BUSY_SIGNAL_VC3, "PAPB VC3");
-  gpioCookiePtmeIp->addGpio(gpioIds::VC3_PAPB_BUSY, gpio);
   gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_EMPTY_SIGNAL_VC3, "PAPB VC3");
   gpioCookiePtmeIp->addGpio(gpioIds::VC3_PAPB_EMPTY, gpio);
   gpio = new GpiodRegularByLineName(q7s::gpioNames::PTME_RESETN, "PTME RESETN",
@@ -753,19 +750,14 @@ ReturnValue_t ObjectFactory::createCcsdsComponents(CcsdsComponentArgs& args) {
   gpioChecker(args.gpioComIF.addGpios(gpioCookiePtmeIp), "PTME PAPB VCs");
 
   // Creating virtual channel interfaces
-  VirtualChannelIF* vc0 =
-      new PapbVcInterface(&args.gpioComIF, gpioIds::VC0_PAPB_BUSY, gpioIds::VC0_PAPB_EMPTY,
-                          q7s::UIO_PTME, q7s::uiomapids::PTME_VC0);
-  VirtualChannelIF* vc1 =
-      new PapbVcInterface(&args.gpioComIF, gpioIds::VC1_PAPB_BUSY, gpioIds::VC1_PAPB_EMPTY,
-                          q7s::UIO_PTME, q7s::uiomapids::PTME_VC1);
-  VirtualChannelIF* vc2 =
-      new PapbVcInterface(&args.gpioComIF, gpioIds::VC2_PAPB_BUSY, gpioIds::VC2_PAPB_EMPTY,
-                          q7s::UIO_PTME, q7s::uiomapids::PTME_VC2);
-  VirtualChannelIF* vc3 =
-      new PapbVcInterface(&args.gpioComIF, gpioIds::VC3_PAPB_BUSY, gpioIds::VC3_PAPB_EMPTY,
-                          q7s::UIO_PTME, q7s::uiomapids::PTME_VC3);
-
+  VirtualChannelIF* vc0 = new PapbVcInterface(&args.gpioComIF, gpioIds::VC0_PAPB_EMPTY,
+                                              q7s::UIO_PTME, q7s::uiomapids::PTME_VC0);
+  VirtualChannelIF* vc1 = new PapbVcInterface(&args.gpioComIF, gpioIds::VC1_PAPB_EMPTY,
+                                              q7s::UIO_PTME, q7s::uiomapids::PTME_VC1);
+  VirtualChannelIF* vc2 = new PapbVcInterface(&args.gpioComIF, gpioIds::VC2_PAPB_EMPTY,
+                                              q7s::UIO_PTME, q7s::uiomapids::PTME_VC2);
+  VirtualChannelIF* vc3 = new PapbVcInterface(&args.gpioComIF, gpioIds::VC3_PAPB_EMPTY,
+                                              q7s::UIO_PTME, q7s::uiomapids::PTME_VC3);
   // Creating ptme object and adding virtual channel interfaces
   Ptme* ptme = new Ptme(objects::PTME);
   ptme->addVcInterface(ccsds::VC0, vc0);
@@ -945,16 +937,7 @@ void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) {
   starTrackerCookie->setNoFixedSizeReply();
   StrComHandler* strComIF = new StrComHandler(objects::STR_COM_IF);
 
-  const char* paramJsonFile = nullptr;
-#ifdef EGSE
-  paramJsonFile = "/home/pi/arcsec/json/flight-config.json";
-#else
-#if OBSW_STAR_TRACKER_GROUND_CONFIG == 1
-  paramJsonFile = "/mnt/sd0/startracker/ground-config.json";
-#else
-  paramJsonFile = "/mnt/sd0/startracker/flight-config.json";
-#endif
-#endif
+  const char* paramJsonFile = "/mnt/sd0/startracker/flight-config.json";
   if (paramJsonFile == nullptr) {
     sif::error << "No valid Star Tracker parameter JSON file" << std::endl;
   }
@@ -967,12 +950,13 @@ void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) {
   starTracker->setCustomFdir(strFdir);
 }
 
-void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enableHkSets) {
+void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enableHkSets,
+                                         const char* i2cDev) {
   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);
+  I2cCookie* imtqI2cCookie = new I2cCookie(addresses::IMTQ, imtq::MAX_REPLY_SIZE, i2cDev);
   auto imtqHandler = new ImtqHandler(objects::IMTQ_HANDLER, objects::IMTQ_POLLING, imtqI2cCookie,
                                      power::Switches::PDU1_CH3_MGT_5V, enableHkSets);
   imtqHandler->enableThermalModule(ThermalStateCfg());
@@ -988,8 +972,8 @@ void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enable
 #endif
 }
 
-void ObjectFactory::createBpxBatteryComponent(bool enableHkSets) {
-  I2cCookie* bpxI2cCookie = new I2cCookie(addresses::BPX_BATTERY, 100, q7s::I2C_PL_EIVE);
+void ObjectFactory::createBpxBatteryComponent(bool enableHkSets, const char* i2cDev) {
+  I2cCookie* bpxI2cCookie = new I2cCookie(addresses::BPX_BATTERY, 100, i2cDev);
   BpxBatteryHandler* bpxHandler = new BpxBatteryHandler(
       objects::BPX_BATT_HANDLER, objects::I2C_COM_IF, bpxI2cCookie, enableHkSets);
   bpxHandler->setStartUpImmediately();
@@ -1045,3 +1029,32 @@ void ObjectFactory::createPlI2cResetGpio(LinuxLibgpioIF* gpioIF) {
     gpioIF->pullHigh(gpioIds::PL_I2C_ARESETN);
   }
 }
+
+ReturnValue_t ObjectFactory::readFirmwareVersion() {
+  uint32_t* mappedSysRomAddr = nullptr;
+  // The SYS ROM FPGA block is only available in those versions.
+  if (not(common::OBSW_VERSION_MAJOR >= 6) or (common::OBSW_VERSION_MAJOR == 4)) {
+    return returnvalue::OK;
+  }
+  // This has to come before the version announce because it might be required for retrieving
+  // the firmware version.
+  UioMapper sysRomMapper(q7s::UIO_SYS_ROM);
+  ReturnValue_t result =
+      sysRomMapper.getMappedAdress(&mappedSysRomAddr, UioMapper::Permissions::READ_ONLY);
+  if (result != returnvalue::OK) {
+    sif::error << "Getting mapped SYS ROM UIO address failed" << std::endl;
+    return returnvalue::FAILED;
+  }
+  if (mappedSysRomAddr != nullptr) {
+    uint32_t firstEntry = *(reinterpret_cast<uint32_t*>(mappedSysRomAddr));
+    uint32_t secondEntry = *(reinterpret_cast<uint32_t*>(mappedSysRomAddr) + 1);
+    core::FW_VERSION_MAJOR = (firstEntry >> 24) & 0xff;
+    core::FW_VERSION_MINOR = (firstEntry >> 16) & 0xff;
+    core::FW_VERSION_REVISION = (firstEntry >> 8) & 0xff;
+    bool hasGitSha = (firstEntry & 0x0b1);
+    if (hasGitSha) {
+      std::memcpy(core::FW_VERSION_GIT_SHA, &secondEntry, 4);
+    }
+  }
+  return returnvalue::OK;
+}

bsp_q7s/objectFactory.h

@@ -58,7 +58,7 @@ void createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF** pwrSwitcher
                           bool enableHkSets);
 void createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF,
                             PowerSwitchIF* pwrSwitcher, Stack5VHandler& stackHandler);
-void createTmpComponents();
+void createTmpComponents(std::vector<std::pair<object_id_t, address_t>> tmpDevsToAdd);
 void createRadSensorChipSelect(LinuxLibgpioIF* gpioIF);
 ReturnValue_t createRadSensorComponent(LinuxLibgpioIF* gpioComIF, Stack5VHandler& handler);
 void createAcsBoardGpios(GpioCookie& cookie);
@@ -67,14 +67,15 @@ void createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF* gpioComIF, Ser
                               adis1650x::Type adisType);
 void createHeaterComponents(GpioIF* gpioIF, PowerSwitchIF* pwrSwitcher, HealthTableIF* healthTable,
                             HeaterHandler*& heaterHandler);
-void createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enableHkSets);
-void createBpxBatteryComponent(bool enableHkSets);
+void createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enableHkSets, const char* i2cDev);
+void createBpxBatteryComponent(bool enableHkSets, const char* i2cDev);
 void createStrComponents(PowerSwitchIF* pwrSwitcher);
 void createSolarArrayDeploymentComponents(PowerSwitchIF& pwrSwitcher, GpioIF& gpioIF);
 void createSyrlinksComponents(PowerSwitchIF* pwrSwitcher);
 void createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF& pwrSwitcher);
 void createReactionWheelComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF* pwrSwitcher);
 ReturnValue_t createCcsdsComponents(CcsdsComponentArgs& args);
+ReturnValue_t readFirmwareVersion();
 void createMiscComponents();
 
 void createTestComponents(LinuxLibgpioIF* gpioComIF);

bsp_q7s/obsw.cpp

@@ -11,13 +11,13 @@
 #include "OBSWConfig.h"
 #include "bsp_q7s/core/WatchdogHandler.h"
 #include "commonConfig.h"
-#include "core/scheduling.h"
 #include "fsfw/tasks/TaskFactory.h"
 #include "fsfw/version.h"
 #include "mission/acs/defs.h"
 #include "mission/com/defs.h"
 #include "mission/system/systemTree.h"
 #include "q7sConfig.h"
+#include "scheduling.h"
 #include "watchdog/definitions.h"
 
 static constexpr int OBSW_ALREADY_RUNNING = -2;

bsp_q7s/scheduling.cpp

@@ -9,7 +9,6 @@
 #include <vector>
 
 #include "OBSWConfig.h"
-#include "bsp_q7s/core/ObjectFactory.h"
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/objectmanager/ObjectManagerIF.h"
 #include "fsfw/platform.h"
@@ -21,6 +20,8 @@
 #include "mission/pollingSeqTables.h"
 #include "mission/scheduling.h"
 #include "mission/utility/InitMission.h"
+#include "objectFactory.h"
+#include "q7sConfig.h"
 
 /* This is configured for linux without CR */
 #ifdef PLATFORM_UNIX
@@ -531,7 +532,15 @@ void scheduling::createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction
   FixedTimeslotTaskIF* i2cPst =
       factory.createFixedTimeslotTask("I2C_PS_PST", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.6,
                                       missedDeadlineFunc, &RR_SCHEDULING);
-  result = pst::pstI2cProcessingSystem(i2cPst);
+  pst::TmpSchedConfig tmpSchedConf;
+#if OBSW_Q7S_EM == 1
+  tmpSchedConf.scheduleTmpDev0 = true;
+  tmpSchedConf.scheduleTmpDev1 = true;
+  tmpSchedConf.schedulePlPcduDev0 = true;
+  tmpSchedConf.schedulePlPcduDev1 = true;
+  tmpSchedConf.scheduleIfBoardDev = true;
+#endif
+  result = pst::pstI2c(tmpSchedConf, i2cPst);
   if (result != returnvalue::OK) {
     if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
       sif::warning << "scheduling::initTasks: I2C PST is empty" << std::endl;

bsp_q7s/xadc/Xadc.cpp

@@ -129,7 +129,7 @@ ReturnValue_t Xadc::readValFromFile(const char* filename, T& val) {
     sif::warning << "Xadc::readValFromFile: Failed to open file " << filename << std::endl;
     return returnvalue::FAILED;
   }
-  char valstring[MAX_STR_LENGTH] = "";
+  char valstring[MAX_STR_LENGTH]{};
   char* returnVal = fgets(valstring, MAX_STR_LENGTH, fp);
   if (returnVal == nullptr) {
     sif::warning << "Xadc::readValFromFile: Failed to read string from file " << filename
@@ -139,6 +139,11 @@ ReturnValue_t Xadc::readValFromFile(const char* filename, T& val) {
   }
   std::istringstream valSstream(valstring);
   valSstream >> val;
+  if (valSstream.bad()) {
+    sif::warning << "Xadc: Conversion of value to target type failed" << std::endl;
+    fclose(fp);
+    return returnvalue::FAILED;
+  }
   fclose(fp);
   return returnvalue::OK;
 }

common/config/devices/gpioIds.h

@@ -96,13 +96,9 @@ enum gpioId_t {
 
   SPI_MUX,
   VC0_PAPB_EMPTY,
-  VC0_PAPB_BUSY,
   VC1_PAPB_EMPTY,
-  VC1_PAPB_BUSY,
   VC2_PAPB_EMPTY,
-  VC2_PAPB_BUSY,
   VC3_PAPB_EMPTY,
-  VC3_PAPB_BUSY,
   PTME_RESETN,
 
   PDEC_RESET,

dummies/CoreControllerDummy.cpp

@@ -1,6 +1,6 @@
 #include "CoreControllerDummy.h"
 
-#include <bsp_q7s/core/CoreDefinitions.h>
+#include <bsp_q7s/core/defs.h>
 #include <objects/systemObjectList.h>
 
 #include <cmath>

dummies/Max31865Dummy.cpp

@@ -7,15 +7,21 @@ using namespace returnvalue;
 Max31865Dummy::Max31865Dummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
     : DeviceHandlerBase(objectId, comif, comCookie), set(this, EiveMax31855::EXCHANGE_SET_ID) {}
 void Max31865Dummy::doStartUp() { setMode(MODE_ON); }
-void Max31865Dummy::doShutDown() { setMode(_MODE_POWER_DOWN); }
+void Max31865Dummy::doShutDown() {
+  PoolReadGuard pg(&set);
+  set.setValidity(false, true);
+  setMode(MODE_OFF);
+}
 ReturnValue_t Max31865Dummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
   return NOTHING_TO_SEND;
 }
-ReturnValue_t Max31865Dummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) { return OK; }
+ReturnValue_t Max31865Dummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
 ReturnValue_t Max31865Dummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
                                                      const uint8_t *commandData,
                                                      size_t commandDataLen) {
-  return 0;
+  return NOTHING_TO_SEND;
 }
 ReturnValue_t Max31865Dummy::scanForReply(const uint8_t *start, size_t len,
                                           DeviceCommandId_t *foundId, size_t *foundLen) {

dummies/TemperatureSensorInserter.cpp

@@ -7,9 +7,9 @@
 #include <cstdlib>
 #include <utility>
 
-TemperatureSensorInserter::TemperatureSensorInserter(object_id_t objectId,
-                                                     Max31865DummyMap tempSensorDummies_,
-                                                     Tmp1075DummyMap tempTmpSensorDummies_)
+TemperatureSensorInserter::TemperatureSensorInserter(
+    object_id_t objectId, Max31865DummyMap tempSensorDummies_,
+    std::optional<Tmp1075DummyMap> tempTmpSensorDummies_)
     : SystemObject(objectId),
       max31865DummyMap(std::move(tempSensorDummies_)),
       tmp1075DummyMap(std::move(tempTmpSensorDummies_)) {}
@@ -25,8 +25,10 @@ ReturnValue_t TemperatureSensorInserter::performOperation(uint8_t opCode) {
     for (auto& rtdDummy : max31865DummyMap) {
       rtdDummy.second->setTemperature(10, true);
     }
-    for (auto& tmpDummy : tmp1075DummyMap) {
-      tmpDummy.second->setTemperature(10, true);
+    if (tmp1075DummyMap.has_value()) {
+      for (auto& tmpDummy : tmp1075DummyMap.value()) {
+        tmpDummy.second->setTemperature(10, true);
+      }
     }
     tempsWereInitialized = true;
   }
@@ -124,6 +126,21 @@ ReturnValue_t TemperatureSensorInserter::performOperation(uint8_t opCode) {
         sif::debug << "Setting CAM temperature back to normal" << std::endl;
         max31865DummyMap[objects::RTD_2_IC5_4K_CAMERA]->setTemperature(0, true);
       }
+      break;
+    }
+    case (TestCase::COLD_PLOC_STAYS_COLD): {
+      if (cycles == 15) {
+        sif::debug << "Setting cold PLOC temperature" << std::endl;
+        max31865DummyMap[objects::RTD_0_IC3_PLOC_HEATSPREADER]->setTemperature(-40, true);
+      }
+      break;
+    }
+    case (TestCase::COLD_CAMERA_STAYS_COLD): {
+      if (cycles == 15) {
+        sif::debug << "Setting cold PLOC temperature" << std::endl;
+        max31865DummyMap[objects::RTD_2_IC5_4K_CAMERA]->setTemperature(-40, true);
+      }
+      break;
     }
   }
   cycles++;

dummies/TemperatureSensorInserter.h

@@ -12,7 +12,7 @@ class TemperatureSensorInserter : public ExecutableObjectIF, public SystemObject
   using Max31865DummyMap = std::map<object_id_t, Max31865Dummy*>;
   using Tmp1075DummyMap = std::map<object_id_t, Tmp1075Dummy*>;
   explicit TemperatureSensorInserter(object_id_t objectId, Max31865DummyMap tempSensorDummies_,
-                                     Tmp1075DummyMap tempTmpSensorDummies_);
+                                     std::optional<Tmp1075DummyMap> tempTmpSensorDummies_);
 
   ReturnValue_t initialize() override;
   ReturnValue_t initializeAfterTaskCreation() override;
@@ -22,7 +22,7 @@ class TemperatureSensorInserter : public ExecutableObjectIF, public SystemObject
 
  private:
   Max31865DummyMap max31865DummyMap;
-  Tmp1075DummyMap tmp1075DummyMap;
+  std::optional<Tmp1075DummyMap> tmp1075DummyMap;
 
   enum TestCase {
     NONE = 0,
@@ -33,6 +33,8 @@ class TemperatureSensorInserter : public ExecutableObjectIF, public SystemObject
     COLD_STR_CONSECUTIVE = 5,
     COLD_CAMERA = 6,
     COLD_PLOC_CONSECUTIVE = 7,
+    COLD_PLOC_STAYS_COLD = 8,
+    COLD_CAMERA_STAYS_COLD = 9
   };
   int iteration = 0;
   uint32_t cycles = 0;

dummies/Tmp1075Dummy.cpp

@@ -8,35 +8,57 @@ using namespace returnvalue;
 Tmp1075Dummy::Tmp1075Dummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
     : DeviceHandlerBase(objectId, comif, comCookie), set(this) {}
 
-void Tmp1075Dummy::doStartUp() { setMode(MODE_NORMAL); }
-void Tmp1075Dummy::doShutDown() { setMode(MODE_OFF); }
+void Tmp1075Dummy::doStartUp() { setMode(MODE_ON); }
+void Tmp1075Dummy::doShutDown() {
+  PoolReadGuard pg(&set);
+  set.setValidity(false, true);
+  setMode(MODE_OFF);
+}
 
 ReturnValue_t Tmp1075Dummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
   return NOTHING_TO_SEND;
 }
-ReturnValue_t Tmp1075Dummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) { return OK; }
+
+ReturnValue_t Tmp1075Dummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
 ReturnValue_t Tmp1075Dummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
                                                     const uint8_t *commandData,
                                                     size_t commandDataLen) {
-  return 0;
+  return NOTHING_TO_SEND;
 }
+
 ReturnValue_t Tmp1075Dummy::scanForReply(const uint8_t *start, size_t len,
                                          DeviceCommandId_t *foundId, size_t *foundLen) {
   return 0;
 }
+
 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>({10.0}, true));
   return OK;
 }
+
+ReturnValue_t Tmp1075Dummy::setHealth(HealthState health) {
+  if (health == FAULTY or health == PERMANENT_FAULTY) {
+    setMode(_MODE_SHUT_DOWN);
+  }
+  return DeviceHandlerBase::setHealth(health);
+}
+
 LocalPoolDataSetBase *Tmp1075Dummy::getDataSetHandle(sid_t sid) { return &set; }

dummies/Tmp1075Dummy.h

@@ -26,6 +26,7 @@ class Tmp1075Dummy : public DeviceHandlerBase {
   uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
   ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                         LocalDataPoolManager &poolManager) override;
+  ReturnValue_t setHealth(HealthState health) override;
 
  protected:
   LocalPoolDataSetBase *getDataSetHandle(sid_t sid) override;

dummies/helperFactory.cpp

@@ -63,11 +63,14 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
   rws[3] = new RwDummy(objects::RW4, objects::DUMMY_COM_IF, comCookieDummy);
   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);
-  auto* strDummy =
-      new StarTrackerDummy(objects::STAR_TRACKER, objects::DUMMY_COM_IF, comCookieDummy);
-  strDummy->connectModeTreeParent(*strAssy);
+
+  if (cfg.addStrDummy) {
+    auto* strAssy = new StrAssembly(objects::STR_ASSY);
+    strAssy->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
+    auto* strDummy =
+        new StarTrackerDummy(objects::STAR_TRACKER, objects::DUMMY_COM_IF, comCookieDummy);
+    strDummy->connectModeTreeParent(*strAssy);
+  }
   if (cfg.addSyrlinksDummies) {
     auto* syrlinksDummy =
         new SyrlinksDummy(objects::SYRLINKS_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
@@ -191,25 +194,36 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
         objects::RTD_15_IC18_IMTQ,
         new Max31865Dummy(objects::RTD_15_IC18_IMTQ, objects::DUMMY_COM_IF, comCookieDummy));
 
-    std::map<object_id_t, Tmp1075Dummy*> tmpSensorDummies;
-    tmpSensorDummies.emplace(
-        objects::TMP1075_HANDLER_TCS_0,
-        new Tmp1075Dummy(objects::TMP1075_HANDLER_TCS_0, objects::DUMMY_COM_IF, comCookieDummy));
-    tmpSensorDummies.emplace(
-        objects::TMP1075_HANDLER_TCS_1,
-        new Tmp1075Dummy(objects::TMP1075_HANDLER_TCS_1, objects::DUMMY_COM_IF, comCookieDummy));
-    tmpSensorDummies.emplace(
-        objects::TMP1075_HANDLER_PLPCDU_0,
-        new Tmp1075Dummy(objects::TMP1075_HANDLER_PLPCDU_0, objects::DUMMY_COM_IF, comCookieDummy));
-    // damaged.
-    //        tmpSensorDummies.emplace(
-    //            objects::TMP1075_HANDLER_PLPCDU_1,
-    //            new Tmp1075Dummy(objects::TMP1075_HANDLER_PLPCDU_1, objects::DUMMY_COM_IF,
-    //            comCookieDummy));
-    tmpSensorDummies.emplace(
-        objects::TMP1075_HANDLER_IF_BOARD,
-        new Tmp1075Dummy(objects::TMP1075_HANDLER_IF_BOARD, objects::DUMMY_COM_IF, comCookieDummy));
-
+    std::optional<TemperatureSensorInserter::Tmp1075DummyMap> tmpSensorDummies;
+    if (cfg.addTmpDummies) {
+      TemperatureSensorInserter::Tmp1075DummyMap tmpDummyMap;
+      if (cfg.tmp1075Cfg.addTcsBrd0) {
+        tmpDummyMap.emplace(objects::TMP1075_HANDLER_TCS_0,
+                            new Tmp1075Dummy(objects::TMP1075_HANDLER_TCS_0, objects::DUMMY_COM_IF,
+                                             comCookieDummy));
+      }
+      if (cfg.tmp1075Cfg.addTcsBrd1) {
+        tmpDummyMap.emplace(objects::TMP1075_HANDLER_TCS_1,
+                            new Tmp1075Dummy(objects::TMP1075_HANDLER_TCS_1, objects::DUMMY_COM_IF,
+                                             comCookieDummy));
+      }
+      if (cfg.tmp1075Cfg.addPlPcdu0) {
+        tmpDummyMap.emplace(objects::TMP1075_HANDLER_PLPCDU_0,
+                            new Tmp1075Dummy(objects::TMP1075_HANDLER_PLPCDU_0,
+                                             objects::DUMMY_COM_IF, comCookieDummy));
+      }
+      if (cfg.tmp1075Cfg.addPlPcdu1) {
+        tmpDummyMap.emplace(objects::TMP1075_HANDLER_PLPCDU_1,
+                            new Tmp1075Dummy(objects::TMP1075_HANDLER_PLPCDU_1,
+                                             objects::DUMMY_COM_IF, comCookieDummy));
+      }
+      if (cfg.tmp1075Cfg.addIfBrd) {
+        tmpDummyMap.emplace(objects::TMP1075_HANDLER_IF_BOARD,
+                            new Tmp1075Dummy(objects::TMP1075_HANDLER_IF_BOARD,
+                                             objects::DUMMY_COM_IF, comCookieDummy));
+      }
+      tmpSensorDummies = std::move(tmpDummyMap);
+    }
     new TemperatureSensorInserter(objects::THERMAL_TEMP_INSERTER, rtdSensorDummies,
                                   tmpSensorDummies);
     TcsBoardAssembly* tcsBoardAssy =
@@ -217,8 +231,10 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
     for (auto& rtd : rtdSensorDummies) {
       rtd.second->connectModeTreeParent(*tcsBoardAssy);
     }
-    for (auto& tmp : tmpSensorDummies) {
-      tmp.second->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
+    if (tmpSensorDummies.has_value()) {
+      for (auto& tmp : tmpSensorDummies.value()) {
+        tmp.second->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
+      }
     }
   }
   if (cfg.addCamSwitcherDummy) {

dummies/helperFactory.h

@@ -6,6 +6,14 @@ class GpioIF;
 
 namespace dummy {
 
+struct Tmp1075Cfg {
+  bool addTcsBrd0 = true;
+  bool addTcsBrd1 = true;
+  bool addPlPcdu0 = true;
+  bool addPlPcdu1 = true;
+  bool addIfBrd = true;
+};
+
 // Default values targeted towards EM.
 struct DummyCfg {
   bool addCoreCtrlCfg = true;
@@ -19,6 +27,9 @@ struct DummyCfg {
   bool addTempSensorDummies = true;
   bool addRtdComIFDummy = true;
   bool addPlocDummies = true;
+  bool addStrDummy = true;
+  bool addTmpDummies = true;
+  Tmp1075Cfg tmp1075Cfg;
   bool addCamSwitcherDummy = false;
 };
 

generators/bsp_hosted_events.csv

@@ -280,6 +280,9 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 14106;0x371a;PCDU_SYSTEM_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
 14107;0x371b;HEATER_NOT_OFF_FOR_OFF_MODE;MEDIUM;No description;mission/controller/tcsDefs.h
 14108;0x371c;MGT_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
+14109;0x371d;TCS_SWITCHING_HEATER_ON;INFO;P1: Module index. P2: Heater index;mission/controller/tcsDefs.h
+14110;0x371e;TCS_SWITCHING_HEATER_OFF;INFO;P1: Module index. P2: Heater index;mission/controller/tcsDefs.h
+14111;0x371f;TCS_HEATER_MAX_BURN_TIME_REACHED;MEDIUM;P1: Heater index. P2: Maximum burn time for heater.;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

@@ -280,6 +280,9 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 14106;0x371a;PCDU_SYSTEM_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
 14107;0x371b;HEATER_NOT_OFF_FOR_OFF_MODE;MEDIUM;No description;mission/controller/tcsDefs.h
 14108;0x371c;MGT_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
+14109;0x371d;TCS_SWITCHING_HEATER_ON;INFO;P1: Module index. P2: Heater index;mission/controller/tcsDefs.h
+14110;0x371e;TCS_SWITCHING_HEATER_OFF;INFO;P1: Module index. P2: Heater index;mission/controller/tcsDefs.h
+14111;0x371f;TCS_HEATER_MAX_BURN_TIME_REACHED;MEDIUM;P1: Heater index. P2: Maximum burn time for heater.;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 296 translations.
+ * @brief    Auto-generated event translation file. Contains 299 translations.
  * @details
- * Generated on: 2023-06-21 19:01:02
+ * Generated on: 2023-07-07 12:06:06
  */
 #include "translateEvents.h"
 
@@ -286,6 +286,9 @@ const char *CAMERA_OVERHEATING_STRING = "CAMERA_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 *MGT_OVERHEATING_STRING = "MGT_OVERHEATING";
+const char *TCS_SWITCHING_HEATER_ON_STRING = "TCS_SWITCHING_HEATER_ON";
+const char *TCS_SWITCHING_HEATER_OFF_STRING = "TCS_SWITCHING_HEATER_OFF";
+const char *TCS_HEATER_MAX_BURN_TIME_REACHED_STRING = "TCS_HEATER_MAX_BURN_TIME_REACHED";
 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";
@@ -866,6 +869,12 @@ const char *translateEvents(Event event) {
       return HEATER_NOT_OFF_FOR_OFF_MODE_STRING;
     case (14108):
       return MGT_OVERHEATING_STRING;
+    case (14109):
+      return TCS_SWITCHING_HEATER_ON_STRING;
+    case (14110):
+      return TCS_SWITCHING_HEATER_OFF_STRING;
+    case (14111):
+      return TCS_HEATER_MAX_BURN_TIME_REACHED_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-06-21 19:01:02
+ * Generated on: 2023-07-07 12:06:06
  */
 #include "translateObjects.h"
 

linux/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 296 translations.
+ * @brief    Auto-generated event translation file. Contains 299 translations.
  * @details
- * Generated on: 2023-06-21 19:01:02
+ * Generated on: 2023-07-07 12:06:06
  */
 #include "translateEvents.h"
 
@@ -286,6 +286,9 @@ const char *CAMERA_OVERHEATING_STRING = "CAMERA_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 *MGT_OVERHEATING_STRING = "MGT_OVERHEATING";
+const char *TCS_SWITCHING_HEATER_ON_STRING = "TCS_SWITCHING_HEATER_ON";
+const char *TCS_SWITCHING_HEATER_OFF_STRING = "TCS_SWITCHING_HEATER_OFF";
+const char *TCS_HEATER_MAX_BURN_TIME_REACHED_STRING = "TCS_HEATER_MAX_BURN_TIME_REACHED";
 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";
@@ -866,6 +869,12 @@ const char *translateEvents(Event event) {
       return HEATER_NOT_OFF_FOR_OFF_MODE_STRING;
     case (14108):
       return MGT_OVERHEATING_STRING;
+    case (14109):
+      return TCS_SWITCHING_HEATER_ON_STRING;
+    case (14110):
+      return TCS_SWITCHING_HEATER_OFF_STRING;
+    case (14111):
+      return TCS_HEATER_MAX_BURN_TIME_REACHED_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-06-21 19:01:02
+ * Generated on: 2023-07-07 12:06:06
  */
 #include "translateObjects.h"
 

linux/ipcore/PapbVcInterface.cpp

@@ -7,20 +7,16 @@
 
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
-PapbVcInterface::PapbVcInterface(LinuxLibgpioIF* gpioComIF, gpioId_t papbBusyId,
-                                 gpioId_t papbEmptyId, std::string uioFile, int mapNum)
-    : gpioComIF(gpioComIF),
-      papbBusyId(papbBusyId),
-      papbEmptyId(papbEmptyId),
-      uioFile(std::move(uioFile)),
-      mapNum(mapNum) {}
+PapbVcInterface::PapbVcInterface(LinuxLibgpioIF* gpioComIF, gpioId_t papbEmptyId,
+                                 std::string uioFile, int mapNum)
+    : gpioComIF(gpioComIF), papbEmptyId(papbEmptyId), uioFile(std::move(uioFile)), mapNum(mapNum) {}
 
 PapbVcInterface::~PapbVcInterface() {}
 
 ReturnValue_t PapbVcInterface::initialize() {
   UioMapper uioMapper(uioFile, mapNum);
   ReturnValue_t result = uioMapper.getMappedAdress(const_cast<uint32_t**>(&vcBaseReg),
-                                                   UioMapper::Permissions::WRITE_ONLY);
+                                                   UioMapper::Permissions::READ_WRITE);
   if (result != returnvalue::OK) {
     return result;
   }
@@ -32,63 +28,27 @@ ReturnValue_t PapbVcInterface::write(const uint8_t* data, size_t size) {
   if (size < 4) {
     return returnvalue::FAILED;
   }
-  if (pollInterfaceReadiness(0, true) == returnvalue::OK) {
+  if (pollReadyForPacket()) {
     startPacketTransfer(ByteWidthCfg::ONE);
   } else {
     return DirectTmSinkIF::IS_BUSY;
   }
-  // TODO: This should work but does not.. :(
-  //  size_t idx = 0;
-  //  while (idx < size) {
-  //
-  //    nanosleep(&BETWEEN_POLL_DELAY, &remDelay);
-  //    if ((size - idx) < 4) {
-  //      *vcBaseReg = CONFIG_DATA_INPUT | (size - idx - 1);
-  //      usleep(1);
-  //    }
-  //    if (pollPapbBusySignal(2) == returnvalue::OK) {
-  //      //      vcBaseReg + DATA_REG_OFFSET + 3 = static_cast<uint8_t>(data + idx);
-  //      //      vcBaseReg + DATA_REG_OFFSET + 2 = static_cast<uint8_t>(data + idx + 1);
-  //      //      vcBaseReg + DATA_REG_OFFSET + 1 = static_cast<uint8_t>(data + idx + 2);
-  //      //      vcBaseReg + DATA_REG_OFFSET = static_cast<uint8_t>(data + idx + 3);
-  //
-  //      // std::memcpy((vcBaseReg + DATA_REG_OFFSET), data + idx , nextWriteSize);
-  //      *(vcBaseReg + DATA_REG_OFFSET) = *reinterpret_cast<const uint32_t*>(data + idx);
-  //      //uint8_t* byteReg = reinterpret_cast<uint8_t*>(vcBaseReg + DATA_REG_OFFSET);
-  //
-  //      //byteReg[0] = data[idx];
-  //      //byteReg[1] = data[idx];
-  //    } else {
-  //      abortPacketTransfer();
-  //      return returnvalue::FAILED;
-  //    }
-  //    // TODO: Change this after the bugfix. Right now, the PAPB ignores the content of the byte
-  //    // width configuration.5
-  //    // It's okay to increment by a larger amount for the last segment here, loop will be over
-  //    // in any case.
-  //    idx += 4;
-  //  }
-  for (size_t idx = 0; idx < size; idx++) {
-    // This delay is super-important, DO NOT REMOVE!
-    // Polling the GPIO or the config register too often messes up the scheduler.
-    // TODO: Maybe this should not be done like this. It would be better if there was a custom
-    // FPGA module which can accept packets and then takes care of dumping that packet into
-    // the PTME. DMA would be an ideal solution for this.
-    nanosleep(&BETWEEN_POLL_DELAY, &remDelay);
-    if (pollInterfaceReadiness(2, false) == returnvalue::OK) {
-      *(vcBaseReg + DATA_REG_OFFSET) = static_cast<uint32_t>(data[idx]);
-    } else {
-      abortPacketTransfer();
-      return returnvalue::FAILED;
-    }
-  }
-  nanosleep(&BETWEEN_POLL_DELAY, &remDelay);
-  if (pollInterfaceReadiness(2, false) == returnvalue::OK) {
-    completePacketTransfer();
-  } else {
+  if (not pollReadyForOctet(MAX_BUSY_POLLS)) {
     abortPacketTransfer();
     return returnvalue::FAILED;
   }
+  for (size_t idx = 0; idx < size; idx++) {
+    if (not pollReadyForOctet(MAX_BUSY_POLLS)) {
+      abortPacketTransfer();
+      return returnvalue::FAILED;
+    }
+    *(vcBaseReg + DATA_REG_OFFSET) = static_cast<uint32_t>(data[idx]);
+  }
+  if (not pollReadyForOctet(MAX_BUSY_POLLS)) {
+    abortPacketTransfer();
+    return returnvalue::FAILED;
+  }
+  completePacketTransfer();
   return returnvalue::OK;
 }
 
@@ -98,63 +58,49 @@ void PapbVcInterface::startPacketTransfer(ByteWidthCfg initWidth) {
 
 void PapbVcInterface::completePacketTransfer() { *vcBaseReg = CONFIG_END; }
 
-ReturnValue_t PapbVcInterface::pollInterfaceReadiness(uint32_t maxPollRetries,
-                                                      bool checkReadyState) const {
-  uint32_t busyIdx = 0;
-  nextDelay.tv_nsec = FIRST_DELAY_PAPB_POLLING_NS;
-
-  while (true) {
-    // Check if PAPB interface is ready to receive data. Use the configuration register for this.
-    // Bit 5, see PTME ptme_001_01-0-7-r2 Table 31.
-    uint32_t reg = *vcBaseReg;
-    bool busy = (reg >> 5) & 0b1;
-    bool ready = (reg >> 6) & 0b1;
-    if (not busy) {
-      return returnvalue::OK;
-    }
-    if (checkReadyState and not ready) {
-      return PAPB_BUSY;
-    }
-
-    busyIdx++;
-    if (busyIdx >= maxPollRetries) {
-      return PAPB_BUSY;
-    }
-
-    // Ignore signal handling here for now.
-    nanosleep(&nextDelay, &remDelay);
-    // Adaptive delay.
-    if (nextDelay.tv_nsec * 2 <= MAX_DELAY_PAPB_POLLING_NS) {
-      nextDelay.tv_nsec *= 2;
-    }
-  }
-  return returnvalue::OK;
+bool PapbVcInterface::pollReadyForPacket() const {
+  //  Check if PAPB interface is ready to receive data. Use the configuration register for this.
+  //  Bit 5, see PTME ptme_001_01-0-7-r2 Table 31.
+  uint32_t reg = *vcBaseReg;
+  return (reg >> 6) & 0b1;
 }
 
-void PapbVcInterface::isVcInterfaceBufferEmpty() {
+bool PapbVcInterface::isVcInterfaceBufferEmpty() {
   ReturnValue_t result = returnvalue::OK;
   gpio::Levels papbEmptyState = gpio::Levels::HIGH;
 
   result = gpioComIF->readGpio(papbEmptyId, papbEmptyState);
 
   if (result != returnvalue::OK) {
-    sif::warning << "PapbVcInterface::isVcInterfaceBufferEmpty: Failed to read papb empty signal"
-                 << std::endl;
-    return;
+    sif::error << "PapbVcInterface::isVcInterfaceBufferEmpty: Failed to read papb empty signal"
+               << std::endl;
+    return true;
   }
 
   if (papbEmptyState == gpio::Levels::HIGH) {
-    sif::debug << "PapbVcInterface::isVcInterfaceBufferEmpty: Buffer is empty" << std::endl;
-  } else {
-    sif::debug << "PapbVcInterface::isVcInterfaceBufferEmpty: Buffer is not empty" << std::endl;
+    return true;
   }
-  return;
+  return false;
 }
 
-bool PapbVcInterface::isBusy() const { return pollInterfaceReadiness(0, true) == PAPB_BUSY; }
+bool PapbVcInterface::isBusy() const { return not pollReadyForPacket(); }
 
 void PapbVcInterface::cancelTransfer() { abortPacketTransfer(); }
 
+inline bool PapbVcInterface::pollReadyForOctet(uint32_t maxCycles) const {
+  uint32_t reg;
+  uint32_t idx = 0;
+  while (idx < maxCycles) {
+    reg = *vcBaseReg;
+    // Busy bit.
+    if (not((reg >> 5) & 0b1)) {
+      return true;
+    }
+    idx++;
+  }
+  return false;
+}
+
 ReturnValue_t PapbVcInterface::sendTestFrame() {
   /** Size of one complete transfer frame data field amounts to 1105 bytes */
   uint8_t testPacket[1105];

linux/ipcore/PapbVcInterface.h

@@ -30,8 +30,7 @@ class PapbVcInterface : public VirtualChannelIF {
    * @param uioFile       UIO file providing access to the PAPB bus
    * @param mapNum        Map number of UIO map associated with this virtual channel
    */
-  PapbVcInterface(LinuxLibgpioIF* gpioComIF, gpioId_t papbBusyId, gpioId_t papbEmptyId,
-                  std::string uioFile, int mapNum);
+  PapbVcInterface(LinuxLibgpioIF* gpioComIF, gpioId_t papbEmptyId, std::string uioFile, int mapNum);
   virtual ~PapbVcInterface();
 
   bool isBusy() const override;
@@ -81,11 +80,9 @@ class PapbVcInterface : public VirtualChannelIF {
 
   static constexpr long int FIRST_DELAY_PAPB_POLLING_NS = 10;
   static constexpr long int MAX_DELAY_PAPB_POLLING_NS = 40;
+  static constexpr uint32_t MAX_BUSY_POLLS = 1000;
 
   LinuxLibgpioIF* gpioComIF = nullptr;
-
-  /** Pulled to low when virtual channel not ready to receive data */
-  gpioId_t papbBusyId = gpio::NO_GPIO;
   /** High when external buffer memory of virtual channel is empty */
   gpioId_t papbEmptyId = gpio::NO_GPIO;
 
@@ -120,13 +117,15 @@ class PapbVcInterface : public VirtualChannelIF {
    *
    * @return  returnvalue::OK when ready to receive data else PAPB_BUSY.
    */
-  inline ReturnValue_t pollInterfaceReadiness(uint32_t maxPollRetries, bool checkReadyState) const;
+  inline bool pollReadyForPacket() const;
+
+  inline bool pollReadyForOctet(uint32_t maxCycles) const;
 
   /**
    * @brief   This function can be used for debugging to check whether there are packets in
    *          the packet buffer of the virtual channel or not.
    */
-  void isVcInterfaceBufferEmpty();
+  bool isVcInterfaceBufferEmpty();
 
   /**
    * @brief   This function sends a complete telemetry transfer frame data field (1105 bytes)

mission/com/LiveTmTask.cpp

@@ -19,13 +19,8 @@ LiveTmTask::LiveTmTask(object_id_t objectId, PusTmFunnel& pusFunnel, CfdpTmFunne
 ReturnValue_t LiveTmTask::performOperation(uint8_t opCode) {
   readCommandQueue();
   while (true) {
-    bool performWriteOp = true;
-    if (mode == MODE_OFF or ptmeLocked) {
-      performWriteOp = false;
-    }
-
     // The funnel tasks are scheduled here directly as well.
-    ReturnValue_t result = channel.handleNextTm(performWriteOp);
+    ReturnValue_t result = channel.handleNextTm(!ptmeLocked);
     if (result == DirectTmSinkIF::IS_BUSY) {
       sif::error << "Lost live TM, PAPB busy" << std::endl;
     }

mission/com/PersistentLogTmStoreTask.cpp

@@ -42,13 +42,7 @@ ReturnValue_t PersistentLogTmStoreTask::performOperation(uint8_t opCode) {
     if (not someonesBusy) {
       TaskFactory::delayTask(100);
     } else if (vcBusyDuringDump) {
-      // TODO: Might not be necessary
-      sif::debug << "VC busy, delaying" << std::endl;
       TaskFactory::delayTask(10);
-    } else {
-      // TODO: Would be best to remove this, but not delaying here can lead to evil issues.
-      // Polling the PAPB of the PTME core too often leads to scheuduling issues.
-      TaskFactory::delayTask(2);
     }
   }
 }

mission/com/PersistentSingleTmStoreTask.cpp

@@ -24,13 +24,7 @@ ReturnValue_t PersistentSingleTmStoreTask::performOperation(uint8_t opCode) {
     if (not busy) {
       TaskFactory::delayTask(100);
     } else if (dumpContext.vcBusyDuringDump) {
-      sif::debug << "VC busy, delaying" << std::endl;
-      // TODO: Might not be necessary
       TaskFactory::delayTask(10);
-    } else {
-      // TODO: Would be best to remove this, but not delaying here can lead to evil issues.
-      // Polling the PAPB of the PTME core too often leads to scheuduling issues.
-      TaskFactory::delayTask(2);
     }
   }
 }

mission/controller/ThermalController.h

@@ -1,7 +1,7 @@
 #ifndef MISSION_CONTROLLER_THERMALCONTROLLER_H_
 #define MISSION_CONTROLLER_THERMALCONTROLLER_H_
 
-#include <bsp_q7s/core/CoreDefinitions.h>
+#include <bsp_q7s/core/defs.h>
 #include <fsfw/controller/ExtendedControllerBase.h>
 #include <fsfw/devicehandlers/DeviceHandlerThermalSet.h>
 #include <fsfw/timemanager/Countdown.h>
@@ -24,74 +24,7 @@
 
 #include <atomic>
 #include <list>
-
-/**
- * NOP Limit: Hard limit for device, usually from datasheet. Device damage is possible lif NOP limit
- * is exceeded.
- * OP Limit: Soft limit. Device should be switched off or TCS controller should take action if the
- * limit is exceeded to avoid reaching NOP limit
- */
-struct TempLimits {
-  TempLimits(float nopLowerLimit, float opLowerLimit, float cutOffLimit, float opUpperLimit,
-             float nopUpperLimit)
-      : opLowerLimit(opLowerLimit),
-        opUpperLimit(opUpperLimit),
-        cutOffLimit(cutOffLimit),
-        nopLowerLimit(nopLowerLimit),
-        nopUpperLimit(nopUpperLimit) {}
-  float opLowerLimit;
-  float opUpperLimit;
-  float cutOffLimit;
-  float nopLowerLimit;
-  float nopUpperLimit;
-};
-
-struct ThermalState {
-  uint8_t errorCounter;
-  // Is heating on for that thermal module?
-  bool heating = false;
-  heater::Switch heaterSwitch = heater::Switch::NUMBER_OF_SWITCHES;
-  // Heater start time and end times as UNIX seconds. Please note that these times will be updated
-  // when a switch command is sent, with no guarantess that the heater actually went on.
-  uint32_t heaterStartTime = 0;
-  uint32_t heaterEndTime = 0;
-};
-
-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
-};
+#include <optional>
 
 class ThermalController : public ExtendedControllerBase {
  public:
@@ -102,8 +35,28 @@ class ThermalController : public ExtendedControllerBase {
   static constexpr int16_t SANITY_LIMIT_LOWER_TEMP = -80;
   static constexpr int16_t SANITY_LIMIT_UPPER_TEMP = 160;
 
+  // 1 hour
+  static constexpr uint32_t DEFAULT_MAX_HEATER_ON_DURATION_MS = 60 * 60 * 1000;
+  static constexpr uint32_t MAX_HEATER_ON_DURATIONS_MS[8] = {// PLOC PROC board
+                                                             DEFAULT_MAX_HEATER_ON_DURATION_MS,
+                                                             // PCDU PDU
+                                                             DEFAULT_MAX_HEATER_ON_DURATION_MS,
+                                                             // ACS Board
+                                                             DEFAULT_MAX_HEATER_ON_DURATION_MS,
+                                                             // OBC Board
+                                                             DEFAULT_MAX_HEATER_ON_DURATION_MS,
+                                                             // Camera
+                                                             DEFAULT_MAX_HEATER_ON_DURATION_MS,
+                                                             // STR
+                                                             DEFAULT_MAX_HEATER_ON_DURATION_MS,
+                                                             // DRO
+                                                             DEFAULT_MAX_HEATER_ON_DURATION_MS,
+                                                             // S-Band
+                                                             DEFAULT_MAX_HEATER_ON_DURATION_MS};
+
   ThermalController(object_id_t objectId, HeaterHandler& heater,
-                    const std::atomic_bool& tcsBoardShortUnavailable);
+                    const std::atomic_bool& tcsBoardShortUnavailable, bool pollPcdu1Tmp);
+  virtual ~ThermalController();
 
   ReturnValue_t initialize() override;
 
@@ -111,16 +64,16 @@ class ThermalController : public ExtendedControllerBase {
   struct HeaterContext {
    public:
     HeaterContext(heater::Switch switchNr, heater::Switch redundantSwitchNr,
-                  const TempLimits& tempLimit)
+                  const tcsCtrl::TempLimits& tempLimit)
         : switchNr(switchNr), redSwitchNr(redundantSwitchNr), tempLimit(tempLimit) {}
     bool doHeaterHandling = true;
     heater::Switch switchNr;
-    HeaterHandler::SwitchState switchState = HeaterHandler::SwitchState::OFF;
+    heater::SwitchState switchState = heater::SwitchState::OFF;
     heater::Switch redSwitchNr;
-    const TempLimits& tempLimit;
+    const tcsCtrl::TempLimits& tempLimit;
   };
 
-  void performThermalModuleCtrl(const HeaterSwitchStates& heaterSwitchStates);
+  void performThermalModuleCtrl(const tcsCtrl::HeaterSwitchStates& heaterSwitchStates);
   ReturnValue_t handleCommandMessage(CommandMessage* message) override;
   void performControlOperation() override;
   ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
@@ -142,12 +95,12 @@ class ThermalController : public ExtendedControllerBase {
 
   HeaterHandler& heaterHandler;
 
+  bool pollPcdu1Tmp;
   tcsCtrl::SensorTemperatures sensorTemperatures;
   tcsCtrl::SusTemperatures susTemperatures;
   tcsCtrl::DeviceTemperatures deviceTemperatures;
   tcsCtrl::HeaterInfo heaterInfo;
-  lp_vec_t<int16_t, 9> currentVecPdu2 =
-      lp_vec_t<int16_t, 9>(gp_id_t(objects::PDU2_HANDLER, PDU::pool::PDU_CURRENTS));
+  tcsCtrl::TcsCtrlInfo tcsCtrlInfo;
 
   DeviceHandlerThermalSet imtqThermalSet;
 
@@ -173,7 +126,7 @@ class ThermalController : public ExtendedControllerBase {
   TMP1075::Tmp1075Dataset tmp1075SetTcs1;
   TMP1075::Tmp1075Dataset tmp1075SetPlPcdu0;
   // damaged
-  // TMP1075::Tmp1075Dataset tmp1075SetPlPcdu1;
+  TMP1075::Tmp1075Dataset* tmp1075SetPlPcdu1;
   TMP1075::Tmp1075Dataset tmp1075SetIfBoard;
 
   // SUS
@@ -227,57 +180,67 @@ class ThermalController : public ExtendedControllerBase {
   lp_var_t<float> tempMgm2 =
       lp_var_t<float>(objects::MGM_2_LIS3_HANDLER, mgmLis3::TEMPERATURE_CELCIUS);
   lp_var_t<float> tempAdcPayloadPcdu = lp_var_t<float>(objects::PLPCDU_HANDLER, plpcdu::TEMP);
+  lp_vec_t<int16_t, 9> currentVecPdu2 =
+      lp_vec_t<int16_t, 9>(gp_id_t(objects::PDU2_HANDLER, PDU::pool::PDU_CURRENTS));
 
   // TempLimits
-  TempLimits acsBoardLimits = TempLimits(-40.0, -40.0, 80.0, 85.0, 85.0);
-  TempLimits mgtLimits = TempLimits(-40.0, -40.0, 65.0, 70.0, 70.0);
-  TempLimits rwLimits = TempLimits(-40.0, -40.0, 80.0, 85.0, 85.0);
-  TempLimits strLimits = TempLimits(-30.0, -20.0, 65.0, 70.0, 80.0);
-  TempLimits ifBoardLimits = TempLimits(-65.0, -40.0, 80.0, 85.0, 150.0);
-  TempLimits tcsBoardLimits = TempLimits(-60.0, -40.0, 80.0, 85.0, 130.0);
-  TempLimits obcLimits = TempLimits(-40.0, -40.0, 80.0, 85.0, 85.0);
-  TempLimits obcIfBoardLimits = TempLimits(-65.0, -40.0, 80.0, 85.0, 125.0);
-  TempLimits sBandTransceiverLimits = TempLimits(-40.0, -25.0, 35.0, 40.0, 65.0);
-  TempLimits pcduP60BoardLimits = TempLimits(-35.0, -35.0, 80.0, 85.0, 85.0);
-  TempLimits pcduAcuLimits = TempLimits(-35.0, -35.0, 80.0, 85.0, 85.0);
-  TempLimits pcduPduLimits = TempLimits(-35.0, -35.0, 80.0, 85.0, 85.0);
-  TempLimits plPcduBoardLimits = TempLimits(-55.0, -40.0, 80.0, 85.0, 125.0);
-  TempLimits plocMissionBoardLimits = TempLimits(-30.0, -10.0, 40.0, 45.0, 60);
-  TempLimits plocProcessingBoardLimits = TempLimits(-30.0, -10.0, 40.0, 45.0, 60.0);
-  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 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 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);
+  tcsCtrl::TempLimits acsBoardLimits = tcsCtrl::TempLimits(-40.0, -40.0, 80.0, 85.0, 85.0);
+  tcsCtrl::TempLimits mgtLimits = tcsCtrl::TempLimits(-40.0, -40.0, 65.0, 70.0, 70.0);
+  tcsCtrl::TempLimits rwLimits = tcsCtrl::TempLimits(-40.0, -40.0, 80.0, 85.0, 85.0);
+  tcsCtrl::TempLimits strLimits = tcsCtrl::TempLimits(-30.0, -20.0, 65.0, 70.0, 80.0);
+  tcsCtrl::TempLimits ifBoardLimits = tcsCtrl::TempLimits(-65.0, -40.0, 80.0, 85.0, 150.0);
+  tcsCtrl::TempLimits tcsBoardLimits = tcsCtrl::TempLimits(-60.0, -40.0, 80.0, 85.0, 130.0);
+  tcsCtrl::TempLimits obcLimits = tcsCtrl::TempLimits(-40.0, -40.0, 80.0, 85.0, 85.0);
+  tcsCtrl::TempLimits obcIfBoardLimits = tcsCtrl::TempLimits(-65.0, -40.0, 80.0, 85.0, 125.0);
+  tcsCtrl::TempLimits sBandTransceiverLimits = tcsCtrl::TempLimits(-40.0, -25.0, 35.0, 40.0, 65.0);
+  tcsCtrl::TempLimits pcduP60BoardLimits = tcsCtrl::TempLimits(-35.0, -35.0, 80.0, 85.0, 85.0);
+  tcsCtrl::TempLimits pcduAcuLimits = tcsCtrl::TempLimits(-35.0, -35.0, 80.0, 85.0, 85.0);
+  tcsCtrl::TempLimits pcduPduLimits = tcsCtrl::TempLimits(-35.0, -35.0, 80.0, 85.0, 85.0);
+  tcsCtrl::TempLimits plPcduBoardLimits = tcsCtrl::TempLimits(-55.0, -40.0, 80.0, 85.0, 125.0);
+  tcsCtrl::TempLimits plocMissionBoardLimits = tcsCtrl::TempLimits(-30.0, -10.0, 40.0, 45.0, 60);
+  tcsCtrl::TempLimits plocProcessingBoardLimits =
+      tcsCtrl::TempLimits(-30.0, -10.0, 40.0, 45.0, 60.0);
+  tcsCtrl::TempLimits dacLimits = tcsCtrl::TempLimits(-65.0, -40.0, 113.0, 118.0, 150.0);
+  tcsCtrl::TempLimits cameraLimits = tcsCtrl::TempLimits(-40.0, -30.0, 60.0, 65.0, 85.0);
+  tcsCtrl::TempLimits droLimits = tcsCtrl::TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
+  tcsCtrl::TempLimits x8Limits = tcsCtrl::TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
+  tcsCtrl::TempLimits hpaLimits = tcsCtrl::TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
+  tcsCtrl::TempLimits txLimits = tcsCtrl::TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
+  tcsCtrl::TempLimits mpaLimits = tcsCtrl::TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
+  tcsCtrl::TempLimits scexBoardLimits = tcsCtrl::TempLimits(-60.0, -40.0, 80.0, 85.0, 150.0);
+
+  struct CtrlContext {
+    double sensorTemp = INVALID_TEMPERATURE;
+    uint8_t currentSensorIndex = 0;
+    tcsCtrl::ThermalComponents thermalComponent = tcsCtrl::NONE;
+    bool redSwitchNrInUse = false;
+    bool componentAboveCutOffLimit = false;
+    bool componentAboveUpperLimit = false;
+    Event overHeatEventToTrigger;
+  } ctrlCtx;
 
-  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 mgtTooHotFlag = false;
-  bool strTooHotFlag = false;
-  bool rwTooHotFlag = false;
+
+  struct TooHotFlags {
+    bool eBandTooHotFlag = false;
+    bool camTooHotOneShotFlag = false;
+    bool scexTooHotFlag = false;
+    bool plocTooHotFlag = false;
+    bool pcduSystemTooHotFlag = false;
+    bool syrlinksTooHotFlag = false;
+    bool obcTooHotFlag = false;
+    bool mgtTooHotFlag = false;
+    bool strTooHotFlag = false;
+    bool rwTooHotFlag = false;
+  } tooHotFlags;
 
   bool transitionWhenHeatersOff = false;
   uint32_t transitionWhenHeatersOffCycles = 0;
   Mode_t targetMode = MODE_OFF;
   Submode_t targetSubmode = SUBMODE_NONE;
   uint32_t cycles = 0;
-  std::array<ThermalState, ThermalComponents::NUM_ENTRIES> thermalStates{};
-  std::array<HeaterState, heater::NUMBER_OF_SWITCHES> heaterStates{};
+  std::array<tcsCtrl::ThermalState, tcsCtrl::NUM_THERMAL_COMPONENTS> thermalStates{};
+  std::array<tcsCtrl::HeaterState, heater::NUMBER_OF_SWITCHES> heaterStates{};
 
   // Initial delay to make sure all pool variables have been initialized their owners.
   // Also, wait for system initialization to complete.
@@ -298,6 +261,12 @@ class ThermalController : public ExtendedControllerBase {
   PoolEntry<uint8_t> heaterSwitchStates = PoolEntry<uint8_t>(heater::NUMBER_OF_SWITCHES);
   PoolEntry<int16_t> heaterCurrent = PoolEntry<int16_t>();
 
+  PoolEntry<uint8_t> tcsCtrlHeaterOn = PoolEntry<uint8_t>(tcsCtrl::NUM_THERMAL_COMPONENTS);
+  PoolEntry<uint8_t> tcsCtrlSensorIdx = PoolEntry<uint8_t>(tcsCtrl::NUM_THERMAL_COMPONENTS);
+  PoolEntry<uint8_t> tcsCtrlHeaterIdx = PoolEntry<uint8_t>(tcsCtrl::NUM_THERMAL_COMPONENTS);
+  PoolEntry<uint32_t> tcsCtrlStartTimes = PoolEntry<uint32_t>(tcsCtrl::NUM_THERMAL_COMPONENTS);
+  PoolEntry<uint32_t> tcsCtrlEndTimes = PoolEntry<uint32_t>(tcsCtrl::NUM_THERMAL_COMPONENTS);
+
   static constexpr dur_millis_t MUTEX_TIMEOUT = 50;
 
   void startTransition(Mode_t mode, Submode_t submode) override;
@@ -319,8 +288,8 @@ class ThermalController : public ExtendedControllerBase {
   bool selectAndReadSensorTemp(HeaterContext& htrCtx);
 
   void heaterSwitchHelperAllOff();
-  void heaterSwitchHelper(heater::Switch switchNr, HeaterHandler::SwitchState state,
-                          unsigned componentIdx);
+  void heaterSwitchHelper(heater::Switch switchNr, heater::SwitchState state,
+                          std::optional<unsigned> componentIdx);
 
   void ctrlAcsBoard();
   void ctrlMgt();
@@ -329,7 +298,6 @@ class ThermalController : public ExtendedControllerBase {
   void ctrlIfBoard();
   void ctrlTcsBoard();
   void ctrlObc();
-  void ctrlObcIfBoard();
   void ctrlSBandTransceiver();
   void ctrlPcduP60Board();
   void ctrlPcduAcu();
@@ -345,7 +313,22 @@ class ThermalController : public ExtendedControllerBase {
   void ctrlTx();
   void ctrlMpa();
   void ctrlScexBoard();
-  void heaterTransitionControl(const HeaterSwitchStates& currentHeaterStates);
+
+  /**
+   * The transition of heaters might take some time. As long as a transition is
+   * going on, the TCS controller works in a reduced form. This function takes care
+   * of tracking transition and capturing their completion.
+   * @param currentHeaterStates
+   */
+  void heaterTransitionControl(const tcsCtrl::HeaterSwitchStates& currentHeaterStates);
+  /**
+   * Control tasks to prevent heaters being on for prolonged periods. Ideally, this
+   * should never happen, but this task prevents bugs from causing heaters to stay on
+   * for a long time, which draws a lot of power.
+   * @param currentHeaterStates
+   */
+  void heaterMaxDurationControl(const tcsCtrl::HeaterSwitchStates& currentHeaterStates);
+  void crossCheckHeaterStateOfComponentsWhenHeaterGoesOff(heater::Switch switchIdx);
   void setMode(Mode_t mode, Submode_t submode);
   uint32_t tempFloatToU32() const;
   bool tooHotHandler(object_id_t object, bool& oneShotFlag);

mission/controller/tcsDefs.h

@@ -9,6 +9,85 @@
 
 namespace tcsCtrl {
 
+/**
+ * NOP Limit: Hard limit for device, usually from datasheet. Device damage is possible lif NOP limit
+ * is exceeded.
+ * OP Limit: Soft limit. Device should be switched off or TCS controller should take action if the
+ * limit is exceeded to avoid reaching NOP limit
+ */
+struct TempLimits {
+  TempLimits(float nopLowerLimit, float opLowerLimit, float cutOffLimit, float opUpperLimit,
+             float nopUpperLimit)
+      : opLowerLimit(opLowerLimit),
+        opUpperLimit(opUpperLimit),
+        cutOffLimit(cutOffLimit),
+        nopLowerLimit(nopLowerLimit),
+        nopUpperLimit(nopUpperLimit) {}
+  float opLowerLimit;
+  float opUpperLimit;
+  float cutOffLimit;
+  float nopLowerLimit;
+  float nopUpperLimit;
+};
+
+/**
+ * Abstraction for the state of a single thermal component
+ */
+struct ThermalState {
+  uint8_t noSensorAvailableCounter;
+  // Which sensor is used for this component?
+  uint8_t sensorIndex = 0;
+  // Is heating on for that thermal module?
+  bool heating = false;
+  // Which switch is being used for heating the component
+  heater::Switch heaterSwitch = heater::Switch::HEATER_NONE;
+  // Heater start time and end times as UNIX seconds. Please note that these times will be updated
+  // when a switch command is sent, with no guarantess that the heater actually went on.
+  uint32_t heaterStartTime = 0;
+  uint32_t heaterEndTime = 0;
+};
+
+/**
+ * Abstraction for the state of a single heater.
+ */
+struct HeaterState {
+  bool switchTransition = false;
+  heater::SwitchState target = heater::SwitchState::OFF;
+  uint8_t heaterSwitchControlCycles = 0;
+  bool trackHeaterMaxBurnTime = false;
+  Countdown heaterOnMaxBurnTime;
+};
+
+using HeaterSwitchStates = std::array<heater::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,
+  LEGACY_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_THERMAL_COMPONENTS
+};
+
 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);
@@ -18,6 +97,12 @@ 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);
 static constexpr Event MGT_OVERHEATING = MAKE_EVENT(8, severity::HIGH);
+//! [EXPORT] : [COMMENT] P1: Module index. P2: Heater index
+static constexpr Event TCS_SWITCHING_HEATER_ON = MAKE_EVENT(9, severity::INFO);
+//! [EXPORT] : [COMMENT] P1: Module index. P2: Heater index
+static constexpr Event TCS_SWITCHING_HEATER_OFF = MAKE_EVENT(10, severity::INFO);
+//! [EXPORT] : [COMMENT] P1: Heater index. P2: Maximum burn time for heater.
+static constexpr Event TCS_HEATER_MAX_BURN_TIME_REACHED = MAKE_EVENT(11, severity::MEDIUM);
 
 enum SetId : uint32_t {
   SENSOR_TEMPERATURES = 0,
@@ -25,6 +110,7 @@ enum SetId : uint32_t {
   SUS_TEMPERATURES = 2,
   COMPONENT_TEMPERATURES = 3,
   HEATER_SET = 4,
+  TCS_CTRL_INFO = 5
 };
 
 enum PoolIds : lp_id_t {
@@ -92,7 +178,13 @@ enum PoolIds : lp_id_t {
   TEMP_ADC_PAYLOAD_PCDU,
 
   HEATER_SWITCH_LIST,
-  HEATER_CURRENT
+  HEATER_CURRENT,
+
+  HEATER_ON_FOR_COMPONENT_VEC,
+  SENSOR_USED_FOR_TCS_CTRL,
+  HEATER_IDX_USED_FOR_TCS_CTRL,
+  HEATER_START_TIME,
+  HEATER_END_TIME
 };
 
 static const uint8_t ENTRIES_SENSOR_TEMPERATURE_SET = 25;
@@ -232,6 +324,29 @@ class HeaterInfo : public StaticLocalDataSet<3> {
   lp_var_t<int16_t> heaterCurrent = lp_var_t<int16_t>(sid.objectId, PoolIds::HEATER_CURRENT, this);
 };
 
+class TcsCtrlInfo : public StaticLocalDataSet<6> {
+ public:
+  explicit TcsCtrlInfo(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, TCS_CTRL_INFO) {}
+
+  explicit TcsCtrlInfo(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, TCS_CTRL_INFO)) {}
+
+  lp_vec_t<uint8_t, tcsCtrl::NUM_THERMAL_COMPONENTS> heatingOnVec =
+      lp_vec_t<uint8_t, tcsCtrl::NUM_THERMAL_COMPONENTS>(
+          sid.objectId, PoolIds::HEATER_ON_FOR_COMPONENT_VEC, this);
+  lp_vec_t<uint8_t, tcsCtrl::NUM_THERMAL_COMPONENTS> sensorIdxUsedForTcsCtrl =
+      lp_vec_t<uint8_t, tcsCtrl::NUM_THERMAL_COMPONENTS>(sid.objectId,
+                                                         PoolIds::SENSOR_USED_FOR_TCS_CTRL, this);
+  lp_vec_t<uint8_t, tcsCtrl::NUM_THERMAL_COMPONENTS> heaterSwitchIdx =
+      lp_vec_t<uint8_t, tcsCtrl::NUM_THERMAL_COMPONENTS>(
+          sid.objectId, PoolIds::HEATER_IDX_USED_FOR_TCS_CTRL, this);
+  lp_vec_t<uint32_t, tcsCtrl::NUM_THERMAL_COMPONENTS> heaterStartTimes =
+      lp_vec_t<uint32_t, tcsCtrl::NUM_THERMAL_COMPONENTS>(sid.objectId, PoolIds::HEATER_START_TIME,
+                                                          this);
+  lp_vec_t<uint32_t, tcsCtrl::NUM_THERMAL_COMPONENTS> heaterEndTimes =
+      lp_vec_t<uint32_t, tcsCtrl::NUM_THERMAL_COMPONENTS>(sid.objectId, PoolIds::HEATER_END_TIME,
+                                                          this);
+};
+
 }  // namespace tcsCtrl
 
 #endif /* MISSION_CONTROLLER_CONTROLLERDEFINITIONS_THERMALCONTROLLERDEFINITIONS_H_ */

mission/genericFactory.cpp

@@ -311,9 +311,9 @@ void ObjectFactory::createGenericHeaterComponents(GpioIF& gpioIF, PowerSwitchIF&
   heaterHandler->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
 }
 
-void ObjectFactory::createThermalController(HeaterHandler& heaterHandler) {
+void ObjectFactory::createThermalController(HeaterHandler& heaterHandler, bool pollPlPcduTmp1) {
   auto* tcsCtrl = new ThermalController(objects::THERMAL_CONTROLLER, heaterHandler,
-                                        tcs::TCS_BOARD_SHORTLY_UNAVAILABLE);
+                                        tcs::TCS_BOARD_SHORTLY_UNAVAILABLE, pollPlPcduTmp1);
   tcsCtrl->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
 }
 void ObjectFactory::createRwAssy(PowerSwitchIF& pwrSwitcher, power::Switch_t theSwitch,

mission/genericFactory.h

@@ -50,7 +50,7 @@ void produceGenericObjects(HealthTableIF** healthTable, PusTmFunnel** pusFunnel,
 void createGenericHeaterComponents(GpioIF& gpioIF, PowerSwitchIF& pwrSwitcher,
                                    HeaterHandler*& heaterHandler);
 
-void createThermalController(HeaterHandler& heaterHandler);
+void createThermalController(HeaterHandler& heaterHandler, bool pollPlPcduTmp1);
 void createRwAssy(PowerSwitchIF& pwrSwitcher, power::Switch_t theSwitch,
                   std::array<DeviceHandlerBase*, 4> rws, std::array<object_id_t, 4> rwIds);
 void createSusAssy(PowerSwitchIF& pwrSwitcher, std::array<DeviceHandlerBase*, 12> suses);

mission/pollingSeqTables.cpp

@@ -39,56 +39,67 @@ ReturnValue_t pst::pstSyrlinks(FixedTimeslotTaskIF *thisSequence) {
 
 // I don't think this needs to be in a PST because linux takes care of bus serialization, but
 // keep it like this for now, it works
-ReturnValue_t pst::pstI2cProcessingSystem(FixedTimeslotTaskIF *thisSequence) {
+ReturnValue_t pst::pstI2c(TmpSchedConfig schedConf, FixedTimeslotTaskIF *thisSequence) {
   // Length of a communication cycle
   uint32_t length = thisSequence->getPeriodMs();
   static_cast<void>(length);
 
-  // These are actually part of another bus, but this works, so keep it like this for now
-  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.2,
-                        DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.2, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.3, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.3, DeviceHandlerIF::GET_READ);
+  if (schedConf.scheduleTmpDev0) {
+    thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0, DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.1, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.1, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.1, DeviceHandlerIF::GET_READ);
+  }
 
-  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.4,
-                        DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.4, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.5, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.5, DeviceHandlerIF::GET_READ);
+  if (schedConf.scheduleTmpDev1) {
+    thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.2,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.2,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.2, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.3, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.3, DeviceHandlerIF::GET_READ);
+  }
 
-  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.6,
-                        DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.6,
-                        DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.6,
-                        DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.7,
-                        DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.7, DeviceHandlerIF::GET_READ);
-  // damaged
-  /*
-  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.4,
-                        DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.4,
-                        DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.4,
-                        DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.4,
-                        DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.4, DeviceHandlerIF::GET_READ);
-  */
-  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.8,
-                        DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.8,
-                        DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.8,
-                        DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.9,
-                        DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.9, DeviceHandlerIF::GET_READ);
+  if (schedConf.schedulePlPcduDev0) {
+    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.4,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.4,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.4,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.5,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.5,
+                          DeviceHandlerIF::GET_READ);
+  }
+  if (schedConf.schedulePlPcduDev1) {
+    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.6,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.6,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.6,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.7,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.7,
+                          DeviceHandlerIF::GET_READ);
+  }
+
+  if (schedConf.scheduleIfBoardDev) {
+    thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.8,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.8,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.8,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.9,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.9,
+                          DeviceHandlerIF::GET_READ);
+  }
   static_cast<void>(length);
   return thisSequence->checkSequence();
 }

mission/pollingSeqTables.h

@@ -39,6 +39,16 @@ struct AcsPstCfg {
   bool scheduleStr = true;
 };
 
+// Default config is for FM.
+struct TmpSchedConfig {
+  bool scheduleTmpDev0 = true;
+  bool scheduleTmpDev1 = true;
+  bool schedulePlPcduDev0 = true;
+  // damaged on FM
+  bool schedulePlPcduDev1 = false;
+  bool scheduleIfBoardDev = true;
+};
+
 /**
  * @brief	This function creates the PST for all gomspace devices.
  * @details
@@ -51,7 +61,7 @@ ReturnValue_t pstSyrlinks(FixedTimeslotTaskIF* thisSequence);
 
 ReturnValue_t pstTcsAndAcs(FixedTimeslotTaskIF* thisSequence, AcsPstCfg cfg);
 
-ReturnValue_t pstI2cProcessingSystem(FixedTimeslotTaskIF* thisSequence);
+ReturnValue_t pstI2c(TmpSchedConfig schedConf, FixedTimeslotTaskIF* thisSequence);
 
 /**
  * Generic test PST

mission/system/systemTree.cpp

@@ -31,12 +31,12 @@ void buildPtgInertialSequence(Subsystem& ss, ModeListEntry& eh);
 static const auto OFF = HasModesIF::MODE_OFF;
 static const auto NML = DeviceHandlerIF::MODE_NORMAL;
 
-void satsystem::init() {
+void satsystem::init(bool commandPlPcdu1) {
   auto& acsSubsystem = acs::init();
   acsSubsystem.connectModeTreeParent(EIVE_SYSTEM);
   auto& payloadSubsystem = payload::init();
   payloadSubsystem.connectModeTreeParent(EIVE_SYSTEM);
-  auto& tcsSubsystem = tcs::init();
+  auto& tcsSubsystem = tcs::init(commandPlPcdu1);
   tcsSubsystem.connectModeTreeParent(EIVE_SYSTEM);
   auto& comSubsystem = com::init();
   comSubsystem.connectModeTreeParent(EIVE_SYSTEM);

mission/system/systemTree.h

@@ -5,7 +5,7 @@
 
 namespace satsystem {
 
-void init();
+void init(bool commandPlPcdu1);
 
 extern EiveSystem EIVE_SYSTEM;
 

mission/system/tcs/TmpDevFdir.cpp

@@ -20,7 +20,7 @@ ReturnValue_t TmpDevFdir::eventReceived(EventMessage* event) {
       // We'll try a recovery as long as defined in MAX_REBOOT.
       // Might cause some AssemblyBase cycles, so keep number low.
       // Ignored for TMP device, no way to power cycle it without going to OFF/BOOT mode.
-      // handleRecovery(event->getEvent());
+      setFaulty(event->getEvent());
       break;
     case DeviceHandlerIF::DEVICE_INTERPRETING_REPLY_FAILED:
     case DeviceHandlerIF::DEVICE_READING_REPLY_FAILED:
@@ -28,8 +28,10 @@ ReturnValue_t TmpDevFdir::eventReceived(EventMessage* event) {
     case DeviceHandlerIF::DEVICE_UNKNOWN_REPLY:  // Some DH's generate generic reply-ids.
     case DeviceHandlerIF::DEVICE_BUILDING_COMMAND_FAILED:
       // These faults all mean that there were stupid replies from a device.
-      // With now way to do a recovery, set the device to faulty immediately.
-      setFaulty(event->getEvent());
+      // With no way to do a recovery, set the device to faulty instead of trying a recovery.
+      if (strangeReplyCount.incrementAndCheck()) {
+        setFaulty(event->getEvent());
+      }
       break;
     case DeviceHandlerIF::DEVICE_SENDING_COMMAND_FAILED:
     case DeviceHandlerIF::DEVICE_REQUESTING_REPLY_FAILED:
@@ -40,7 +42,9 @@ ReturnValue_t TmpDevFdir::eventReceived(EventMessage* event) {
         break;
       }
       // else
-      setFaulty(event->getEvent());
+      if (missedReplyCount.incrementAndCheck()) {
+        setFaulty(event->getEvent());
+      }
       break;
     case StorageManagerIF::GET_DATA_FAILED:
     case StorageManagerIF::STORE_DATA_FAILED:

mission/system/tcs/tcsModeTree.cpp

@@ -10,8 +10,8 @@ TcsSubsystem satsystem::tcs::SUBSYSTEM(objects::TCS_SUBSYSTEM, 12, 24);
 namespace {
 // Alias for checker function
 const auto check = subsystem::checkInsert;
-void buildOffSequence(Subsystem& ss, ModeListEntry& eh);
-void buildNormalSequence(Subsystem& ss, ModeListEntry& eh);
+void buildOffSequence(Subsystem& ss, ModeListEntry& eh, bool commandPlPcdu1);
+void buildNormalSequence(Subsystem& ss, ModeListEntry& eh, bool commandPlPcdu1);
 }  // namespace
 
 static const auto OFF = HasModesIF::MODE_OFF;
@@ -27,17 +27,17 @@ auto TCS_TABLE_NORMAL_TGT = std::make_pair((NML << 24) | 1, FixedArrayList<ModeL
 auto TCS_TABLE_NORMAL_TRANS_0 = std::make_pair((NML << 24) | 2, FixedArrayList<ModeListEntry, 7>());
 auto TCS_TABLE_NORMAL_TRANS_1 = std::make_pair((NML << 24) | 3, FixedArrayList<ModeListEntry, 2>());
 
-Subsystem& satsystem::tcs::init() {
+Subsystem& satsystem::tcs::init(bool commandPlPcdu1) {
   ModeListEntry entry;
-  buildOffSequence(SUBSYSTEM, entry);
-  buildNormalSequence(SUBSYSTEM, entry);
+  buildOffSequence(SUBSYSTEM, entry, commandPlPcdu1);
+  buildNormalSequence(SUBSYSTEM, entry, commandPlPcdu1);
   SUBSYSTEM.setInitialMode(OFF);
   return SUBSYSTEM;
 }
 
 namespace {
 
-void buildOffSequence(Subsystem& ss, ModeListEntry& eh) {
+void buildOffSequence(Subsystem& ss, ModeListEntry& eh, bool commandPlPcdu1) {
   std::string context = "satsystem::tcs::buildOffSequence";
   auto ctxc = context.c_str();
   // Insert Helper Table
@@ -67,7 +67,9 @@ void buildOffSequence(Subsystem& ss, ModeListEntry& eh) {
   iht(objects::TMP1075_HANDLER_TCS_0, OFF, 0, TCS_TABLE_OFF_TRANS_1.second);
   iht(objects::TMP1075_HANDLER_TCS_1, OFF, 0, TCS_TABLE_OFF_TRANS_1.second);
   iht(objects::TMP1075_HANDLER_PLPCDU_0, OFF, 0, TCS_TABLE_OFF_TRANS_1.second);
-  // TMP PL PCDU 1 is damaged
+  if (commandPlPcdu1) {
+    iht(objects::TMP1075_HANDLER_PLPCDU_1, OFF, 0, TCS_TABLE_OFF_TRANS_1.second);
+  }
   iht(objects::TMP1075_HANDLER_IF_BOARD, OFF, 0, TCS_TABLE_OFF_TRANS_1.second);
   check(ss.addTable(TableEntry(TCS_TABLE_OFF_TRANS_1.first, &TCS_TABLE_OFF_TRANS_1.second)), ctxc);
 
@@ -79,7 +81,7 @@ void buildOffSequence(Subsystem& ss, ModeListEntry& eh) {
         ctxc);
 }
 
-void buildNormalSequence(Subsystem& ss, ModeListEntry& eh) {
+void buildNormalSequence(Subsystem& ss, ModeListEntry& eh, bool commandPlPcdu1) {
   std::string context = "satsystem::tcs::buildNormalSequence";
   auto ctxc = context.c_str();
   // Insert Helper Table
@@ -105,7 +107,9 @@ void buildNormalSequence(Subsystem& ss, ModeListEntry& eh) {
   iht(objects::TMP1075_HANDLER_TCS_0, NML, 0, TCS_TABLE_NORMAL_TRANS_0.second);
   iht(objects::TMP1075_HANDLER_TCS_1, NML, 0, TCS_TABLE_NORMAL_TRANS_0.second);
   iht(objects::TMP1075_HANDLER_PLPCDU_0, NML, 0, TCS_TABLE_NORMAL_TRANS_0.second);
-  // TMP PL PCDU 1 is damaged
+  if (commandPlPcdu1) {
+    iht(objects::TMP1075_HANDLER_PLPCDU_1, NML, 0, TCS_TABLE_NORMAL_TRANS_0.second);
+  }
   iht(objects::TMP1075_HANDLER_IF_BOARD, NML, 0, TCS_TABLE_NORMAL_TRANS_0.second);
   check(ss.addTable(TableEntry(TCS_TABLE_NORMAL_TRANS_0.first, &TCS_TABLE_NORMAL_TRANS_0.second)),
         ctxc);

mission/system/tcs/tcsModeTree.h

@@ -7,7 +7,7 @@ namespace satsystem {
 namespace tcs {
 
 extern TcsSubsystem SUBSYSTEM;
-Subsystem& init();
+Subsystem& init(bool commandPlPcdu1);
 
 }  // namespace tcs
 }  // namespace satsystem

mission/tcs/HeaterHandler.cpp

@@ -97,7 +97,7 @@ ReturnValue_t HeaterHandler::initialize() {
 
 ReturnValue_t HeaterHandler::initializeHeaterMap() {
   for (power::Switch_t switchNr = 0; switchNr < heater::NUMBER_OF_SWITCHES; switchNr++) {
-    heaterVec.push_back(HeaterWrapper(helper.heaters[switchNr], SwitchState::OFF));
+    heaterVec.push_back(HeaterWrapper(helper.heaters[switchNr], heater::SwitchState::OFF));
   }
   return returnvalue::OK;
 }
@@ -214,7 +214,7 @@ ReturnValue_t HeaterHandler::sendSwitchCommand(uint8_t switchNr, ReturnValue_t o
 void HeaterHandler::handleSwitchHandling() {
   for (uint8_t idx = 0; idx < heater::NUMBER_OF_SWITCHES; idx++) {
     auto health = heaterVec[idx].healthDevice->getHealth();
-    if (heaterVec[idx].switchState == SwitchState::ON) {
+    if (heaterVec[idx].switchState == heater::SwitchState::ON) {
       // If a heater is still on but the device was marked faulty by the operator, the SW
       // will shut down the heater
       if (health == HasHealthIF::FAULTY or health == HasHealthIF::PERMANENT_FAULTY) {
@@ -277,7 +277,7 @@ void HeaterHandler::handleSwitchOnCommand(heater::Switch heaterIdx) {
       triggerEvent(HEATER_WENT_ON, heaterIdx, 0);
       {
         MutexGuard mg(handlerLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
-        heater.switchState = ON;
+        heater.switchState = heater::SwitchState::ON;
       }
       EventManagerIF::triggerEvent(helper.heaters[heaterIdx].first->getObjectId(), MODE_INFO,
                                    MODE_ON, 0);
@@ -326,10 +326,10 @@ void HeaterHandler::handleSwitchOffCommand(heater::Switch heaterIdx) {
   }
   if (result == returnvalue::OK) {
     // Check whether switch is already off
-    if (getSwitchState(heaterIdx) == SwitchState::ON) {
+    if (getSwitchState(heaterIdx) == heater::SwitchState::ON) {
       {
         MutexGuard mg(handlerLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
-        heater.switchState = OFF;
+        heater.switchState = heater::SwitchState::OFF;
       }
       triggerEvent(HEATER_WENT_OFF, heaterIdx, 0);
     } else {
@@ -356,15 +356,15 @@ void HeaterHandler::handleSwitchOffCommand(heater::Switch heaterIdx) {
   heater.cmdActive = false;
 }
 
-HeaterHandler::SwitchState HeaterHandler::getSwitchState(heater::Switch switchNr) const {
+heater::SwitchState HeaterHandler::getSwitchState(heater::Switch switchNr) const {
   MutexGuard mg(handlerLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
   return heaterVec.at(switchNr).switchState;
 }
 
-ReturnValue_t HeaterHandler::switchHeater(heater::Switch heater, SwitchState switchState) {
-  if (switchState == SwitchState::ON) {
+ReturnValue_t HeaterHandler::switchHeater(heater::Switch heater, heater::SwitchState switchState) {
+  if (switchState == heater::SwitchState::ON) {
     return sendSwitchCommand(heater, PowerSwitchIF::SWITCH_ON);
-  } else if (switchState == SwitchState::OFF) {
+  } else if (switchState == heater::SwitchState::OFF) {
     return sendSwitchCommand(heater, PowerSwitchIF::SWITCH_OFF);
   }
   return returnvalue::FAILED;
@@ -373,10 +373,10 @@ ReturnValue_t HeaterHandler::switchHeater(heater::Switch heater, SwitchState swi
 void HeaterHandler::announceMode(bool recursive) {
   triggerEvent(MODE_INFO, mode, submode);
 
-  std::array<SwitchState, 8> states;
+  std::array<heater::SwitchState, 8> states;
   getAllSwitchStates(states);
   for (unsigned idx = 0; idx < helper.heaters.size(); idx++) {
-    if (states[idx] == ON) {
+    if (states[idx] == heater::SwitchState::ON) {
       EventManagerIF::triggerEvent(helper.heaters[idx].first->getObjectId(), MODE_INFO, MODE_ON, 0);
     } else {
       EventManagerIF::triggerEvent(helper.heaters[idx].first->getObjectId(), MODE_INFO, MODE_OFF,
@@ -405,7 +405,7 @@ ModeTreeChildIF& HeaterHandler::getModeTreeChildIF() { return *this; }
 
 object_id_t HeaterHandler::getObjectId() const { return SystemObject::getObjectId(); }
 
-ReturnValue_t HeaterHandler::getAllSwitchStates(std::array<SwitchState, 8>& statesBuf) {
+ReturnValue_t HeaterHandler::getAllSwitchStates(std::array<heater::SwitchState, 8>& statesBuf) {
   {
     MutexGuard mg(handlerLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
     if (mg.getLockResult() != returnvalue::OK) {
@@ -419,13 +419,13 @@ ReturnValue_t HeaterHandler::getAllSwitchStates(std::array<SwitchState, 8>& stat
 }
 
 bool HeaterHandler::allSwitchesOff() {
-  bool allSwitchesOrd = false;
   MutexGuard mg(handlerLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
-  /* Or all switches. As soon one switch is on, allSwitchesOrd will be true */
   for (power::Switch_t switchNr = 0; switchNr < heater::NUMBER_OF_SWITCHES; switchNr++) {
-    allSwitchesOrd = allSwitchesOrd || heaterVec.at(switchNr).switchState;
+    if (heaterVec.at(switchNr).switchState == heater::SwitchState::ON) {
+      return false;
+    }
   }
-  return !allSwitchesOrd;
+  return true;
 }
 
 MessageQueueId_t HeaterHandler::getCommandQueue() const { return commandQueue->getId(); }
@@ -440,7 +440,7 @@ ReturnValue_t HeaterHandler::getSwitchState(uint8_t switchNr) const {
   if (switchNr > 7) {
     return returnvalue::FAILED;
   }
-  if (getSwitchState(static_cast<heater::Switch>(switchNr)) == SwitchState::ON) {
+  if (getSwitchState(static_cast<heater::Switch>(switchNr)) == heater::SwitchState::ON) {
     return PowerSwitchIF::SWITCH_ON;
   }
   return PowerSwitchIF::SWITCH_OFF;

mission/tcs/HeaterHandler.h

@@ -60,7 +60,6 @@ class HeaterHandler : public ExecutableObjectIF,
   static const ReturnValue_t COMMAND_ALREADY_WAITING = MAKE_RETURN_CODE(0xA5);
 
   enum CmdSourceParam : uint8_t { INTERNAL = 0, EXTERNAL = 1 };
-  enum SwitchState : uint8_t { ON = 1, OFF = 0 };
 
   /** Device command IDs */
   static const DeviceCommandId_t SWITCH_HEATER = 0x0;
@@ -69,14 +68,14 @@ class HeaterHandler : public ExecutableObjectIF,
                 PowerSwitchIF* mainLineSwitcherObjectId, power::Switch_t mainLineSwitch);
 
   ReturnValue_t connectModeTreeParent(HasModeTreeChildrenIF& parent) override;
-  ReturnValue_t getAllSwitchStates(std::array<SwitchState, 8>& statesBuf);
+  ReturnValue_t getAllSwitchStates(std::array<heater::SwitchState, 8>& statesBuf);
 
   virtual ~HeaterHandler();
 
  protected:
   enum SwitchAction : uint8_t { SET_SWITCH_OFF, SET_SWITCH_ON, NONE };
 
-  ReturnValue_t switchHeater(heater::Switch heater, SwitchState switchState);
+  ReturnValue_t switchHeater(heater::Switch heater, heater::SwitchState switchState);
   HasHealthIF::HealthState getHealth(heater::Switch heater);
 
   ReturnValue_t performOperation(uint8_t operationCode = 0) override;
@@ -121,14 +120,14 @@ class HeaterHandler : public ExecutableObjectIF,
    * @param mainSwitchCountdown   Sets timeout to wait for main switch being set on.
    */
   struct HeaterWrapper {
-    HeaterWrapper(HeaterPair pair, SwitchState initState)
+    HeaterWrapper(HeaterPair pair, heater::SwitchState initState)
         : healthDevice(pair.first), gpioId(pair.second), switchState(initState) {}
     HealthDevice* healthDevice = nullptr;
     gpioId_t gpioId = gpio::NO_GPIO;
     SwitchAction action = SwitchAction::NONE;
     MessageQueueId_t replyQueue = MessageQueueIF::NO_QUEUE;
     bool cmdActive = false;
-    SwitchState switchState = SwitchState::OFF;
+    heater::SwitchState switchState = heater::SwitchState::OFF;
     bool waitMainSwitchOn = false;
     Countdown mainSwitchCountdown;
   };
@@ -177,7 +176,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 getSwitchState(heater::Switch switchNr) const;
+  heater::SwitchState getSwitchState(heater::Switch switchNr) const;
 
   /**
    * @brief	This function runs commands waiting for execution.

mission/tcs/Tmp1075Handler.cpp

@@ -1,4 +1,5 @@
 #include <OBSWConfig.h>
+#include <fsfw/datapool/PoolReadGuard.h>
 #include <mission/tcs/Tmp1075Definitions.h>
 #include <mission/tcs/Tmp1075Handler.h>
 
@@ -11,14 +12,12 @@ Tmp1075Handler::Tmp1075Handler(object_id_t objectId, object_id_t comIF, CookieIF
 
 Tmp1075Handler::~Tmp1075Handler() {}
 
-void Tmp1075Handler::doStartUp() {
-  if (getMode() == _MODE_START_UP) {
-    setMode(MODE_ON);
-  }
-}
+void Tmp1075Handler::doStartUp() { setMode(MODE_ON); }
 
 void Tmp1075Handler::doShutDown() {
   communicationStep = CommunicationStep::START_ADC_CONVERSION;
+  PoolReadGuard pg(&dataset);
+  dataset.setValidity(false, true);
   setMode(_MODE_POWER_DOWN);
 }
 
@@ -134,12 +133,14 @@ ReturnValue_t Tmp1075Handler::initializeLocalDataPool(localpool::DataPool &local
   return returnvalue::OK;
 }
 
-void Tmp1075Handler::setModeNormal() { setMode(_MODE_TO_NORMAL); }
-
 ReturnValue_t Tmp1075Handler::setHealth(HealthState health) {
   if (health != FAULTY and health != PERMANENT_FAULTY and health != HEALTHY and
       health != EXTERNAL_CONTROL) {
     return returnvalue::FAILED;
   }
-  return returnvalue::OK;
+  // Required because we do not have an assembly.
+  if (health == FAULTY or health == PERMANENT_FAULTY) {
+    setMode(_MODE_SHUT_DOWN);
+  }
+  return DeviceHandlerBase::setHealth(health);
 }

mission/tcs/Tmp1075Handler.h

@@ -20,8 +20,6 @@ class Tmp1075Handler : public DeviceHandlerBase {
   Tmp1075Handler(object_id_t objectId, object_id_t comIF, CookieIF *comCookie);
   virtual ~Tmp1075Handler();
 
-  void setModeNormal();
-
  protected:
   void doStartUp() override;
   void doShutDown() override;

mission/tcs/defs.h

@@ -4,6 +4,7 @@
 #include <cstdint>
 
 namespace heater {
+
 enum Switch : uint8_t {
   HEATER_0_PLOC_PROC_BRD,
   HEATER_1_PCDU_PDU,
@@ -13,9 +14,13 @@ enum Switch : uint8_t {
   HEATER_5_STR,
   HEATER_6_DRO,
   HEATER_7_S_BAND,
-  NUMBER_OF_SWITCHES
+  NUMBER_OF_SWITCHES = 8,
+  HEATER_NONE = 0xff
 };
-}
+
+enum SwitchState : uint8_t { ON = 1, OFF = 0 };
+
+}  // namespace heater
 
 namespace tcs {
 

unittest/controller/testThermalController.cpp

@@ -30,7 +30,8 @@ TEST_CASE("Thermal Controller", "[ThermalController]") {
 
   // testEnvironment::initialize();
 
-  ThermalController controller(THERMAL_CONTROLLER_ID, *heaterHandler, tcsBrdShortlyUnavailable);
+  ThermalController controller(THERMAL_CONTROLLER_ID, *heaterHandler, tcsBrdShortlyUnavailable,
+                               true);
   ReturnValue_t result = controller.initialize();
   REQUIRE(result == returnvalue::OK);