CHANGELOG.md

@@ -16,6 +16,13 @@ will consitute of a breaking change warranting a new major release:
 
 # [unreleased]
 
+## Changed
+
+- 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.
+
 ## Fixed
 
 - TMP1075: Set dataset invalid on shutdown explicitely

CMakeLists.txt

@@ -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

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_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/core/CMakeLists.txt

@@ -1,4 +1 @@
-target_sources(${OBSW_NAME} PRIVATE CoreController.cpp scheduling.cpp
+target_sources(${OBSW_NAME} PRIVATE CoreController.cpp WatchdogHandler.cpp)
-                                    ObjectFactory.cpp WatchdogHandler.cpp)
-
-target_sources(${SIMPLE_OBSW_NAME} PRIVATE scheduling.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);
-
+  p1 = (core::FW_VERSION_MAJOR << 24) | (core::FW_VERSION_MINOR << 16) |
-  if (common::OBSW_VERSION_MAJOR >= 6 or common::OBSW_VERSION_MAJOR == 4) {
+       (core::FW_VERSION_REVISION << 8) | (core::FW_VERSION_HAS_SHA);
-    if (mappedSysRomAddr != nullptr) {
+  std::memcpy(&p2, core::FW_VERSION_GIT_SHA, 4);
-      uint32_t p1Firmware = *(reinterpret_cast<uint32_t *>(mappedSysRomAddr));
+  triggerEvent(FIRMWARE_INFO, p1, p2);
-      uint32_t p2Firmware = *(reinterpret_cast<uint32_t *>(mappedSysRomAddr) + 1);
-      triggerEvent(FIRMWARE_INFO, p1Firmware, p2Firmware);
-    }
-  }
 }
 
 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_
+#ifndef BSP_Q7S_CORE_DEFS_H_
-#define BSP_Q7S_CORE_COREDEFINITIONS_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,6 +62,25 @@ 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},
+  }};
+  const char* tmpI2cDev = q7s::I2C_PS_EIVE;
+  if (core::FW_VERSION_MAJOR >= 4) {
+    tmpI2cDev = q7s::I2C_PL_EIVE;
+  }
+  createTmpComponents(tmpDevsToAdd, tmpI2cDev);
+  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.
@@ -97,8 +118,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 +135,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 +167,6 @@ void ObjectFactory::produce(void* args) {
   createAcsController(true, enableHkSets);
   HeaterHandler* heaterHandler;
   createHeaterComponents(gpioComIF, pwrSwitcher, healthTable, heaterHandler);
-  createThermalController(*heaterHandler);
+  createThermalController(*heaterHandler, true);
   satsystem::init();
 }

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,19 @@ 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},
+  }};
+  const char* tmpI2cDev = q7s::I2C_PS_EIVE;
+  if (core::FW_VERSION_MAJOR >= 4) {
+    tmpI2cDev = q7s::I2C_PL_EIVE;
+  }
+  createTmpComponents(tmpDevsToAdd, tmpI2cDev);
 #endif
   createSolarArrayDeploymentComponents(*pwrSwitcher, *gpioComIF);
   createPlPcduComponents(gpioComIF, spiMainComIF, pwrSwitcher, *stackHandler);
@@ -77,13 +91,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 +131,7 @@ void ObjectFactory::produce(void* args) {
 #endif /* OBSW_ADD_TEST_CODE == 1 */
 
   createMiscComponents();
-  createThermalController(*heaterHandler);
+  createThermalController(*heaterHandler, false);
   createAcsController(true, enableHkSets);
   satsystem::init();
 }

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,23 +161,16 @@ void Factory::setStaticFrameworkObjectIds() {
 
 void ObjectFactory::setStatics() { Factory::setStaticFrameworkObjectIds(); }
 
-void ObjectFactory::createTmpComponents() {
+void ObjectFactory::createTmpComponents(std::vector<std::pair<object_id_t, address_t>> tmpDevsToAdd,
-  std::vector<std::pair<object_id_t, address_t>> tmpDevIds = {{
+                                        const char* i2cDev) {
-      {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},
-  }};
   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, i2cDev));
     auto* tmpDevHandler =
-        new Tmp1075Handler(tmpDevIds[idx].first, objects::I2C_COM_IF, tmpDevCookies[idx]);
+        new Tmp1075Handler(tmpDevsToAdd[idx].first, objects::I2C_COM_IF, tmpDevCookies[idx]);
-    tmpDevHandler->setCustomFdir(new TmpDevFdir(tmpDevIds[idx].first));
+    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,
@@ -954,12 +957,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());
@@ -975,8 +979,8 @@ void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enable
 #endif
 }
 
-void ObjectFactory::createBpxBatteryComponent(bool enableHkSets) {
+void ObjectFactory::createBpxBatteryComponent(bool enableHkSets, const char* i2cDev) {
-  I2cCookie* bpxI2cCookie = new I2cCookie(addresses::BPX_BATTERY, 100, q7s::I2C_PL_EIVE);
+  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();
@@ -1032,3 +1036,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,8 @@ 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,
+                         const char* i2cDev);
 void createRadSensorChipSelect(LinuxLibgpioIF* gpioIF);
 ReturnValue_t createRadSensorComponent(LinuxLibgpioIF* gpioComIF, Stack5VHandler& handler);
 void createAcsBoardGpios(GpioCookie& cookie);
@@ -67,14 +68,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 createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enableHkSets, const char* i2cDev);
-void createBpxBatteryComponent(bool enableHkSets);
+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;

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/TemperatureSensorInserter.cpp

@@ -7,9 +7,9 @@
 #include <cstdlib>
 #include <utility>
 
-TemperatureSensorInserter::TemperatureSensorInserter(object_id_t objectId,
+TemperatureSensorInserter::TemperatureSensorInserter(
-                                                     Max31865DummyMap tempSensorDummies_,
+    object_id_t objectId, Max31865DummyMap tempSensorDummies_,
-                                                     Tmp1075DummyMap tempTmpSensorDummies_)
+    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) {
+    if (tmp1075DummyMap.has_value()) {
-      tmpDummy.second->setTemperature(10, true);
+      for (auto& tmpDummy : tmp1075DummyMap.value()) {
+        tmpDummy.second->setTemperature(10, true);
+      }
     }
     tempsWereInitialized = true;
   }

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,

dummies/Tmp1075Dummy.cpp

@@ -8,35 +8,46 @@ 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::doStartUp() { setMode(MODE_ON); }
 void Tmp1075Dummy::doShutDown() { 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;
 }
+
 LocalPoolDataSetBase *Tmp1075Dummy::getDataSetHandle(sid_t sid) { return &set; }

dummies/helperFactory.cpp

@@ -191,25 +191,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;
+    std::optional<TemperatureSensorInserter::Tmp1075DummyMap> tmpSensorDummies;
-    tmpSensorDummies.emplace(
+    if (cfg.addTmpDummies) {
-        objects::TMP1075_HANDLER_TCS_0,
+      TemperatureSensorInserter::Tmp1075DummyMap tmpDummyMap;
-        new Tmp1075Dummy(objects::TMP1075_HANDLER_TCS_0, objects::DUMMY_COM_IF, comCookieDummy));
+      if (cfg.tmp1075Cfg.addTcsBrd0) {
-    tmpSensorDummies.emplace(
+        tmpDummyMap.emplace(objects::TMP1075_HANDLER_TCS_0,
-        objects::TMP1075_HANDLER_TCS_1,
+                            new Tmp1075Dummy(objects::TMP1075_HANDLER_TCS_0, objects::DUMMY_COM_IF,
-        new Tmp1075Dummy(objects::TMP1075_HANDLER_TCS_1, objects::DUMMY_COM_IF, comCookieDummy));
+                                             comCookieDummy));
-    tmpSensorDummies.emplace(
+      }
-        objects::TMP1075_HANDLER_PLPCDU_0,
+      if (cfg.tmp1075Cfg.addTcsBrd1) {
-        new Tmp1075Dummy(objects::TMP1075_HANDLER_PLPCDU_0, objects::DUMMY_COM_IF, comCookieDummy));
+        tmpDummyMap.emplace(objects::TMP1075_HANDLER_TCS_1,
-    // damaged.
+                            new Tmp1075Dummy(objects::TMP1075_HANDLER_TCS_1, objects::DUMMY_COM_IF,
-    //        tmpSensorDummies.emplace(
+                                             comCookieDummy));
-    //            objects::TMP1075_HANDLER_PLPCDU_1,
+      }
-    //            new Tmp1075Dummy(objects::TMP1075_HANDLER_PLPCDU_1, objects::DUMMY_COM_IF,
+      if (cfg.tmp1075Cfg.addPlPcdu0) {
-    //            comCookieDummy));
+        tmpDummyMap.emplace(objects::TMP1075_HANDLER_PLPCDU_0,
-    tmpSensorDummies.emplace(
+                            new Tmp1075Dummy(objects::TMP1075_HANDLER_PLPCDU_0,
-        objects::TMP1075_HANDLER_IF_BOARD,
+                                             objects::DUMMY_COM_IF, comCookieDummy));
-        new Tmp1075Dummy(objects::TMP1075_HANDLER_IF_BOARD, 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 +228,10 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
     for (auto& rtd : rtdSensorDummies) {
       rtd.second->connectModeTreeParent(*tcsBoardAssy);
     }
-    for (auto& tmp : tmpSensorDummies) {
+    if (tmpSensorDummies.has_value()) {
-      tmp.second->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
+      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,8 @@ struct DummyCfg {
   bool addTempSensorDummies = true;
   bool addRtdComIFDummy = true;
   bool addPlocDummies = true;
+  bool addTmpDummies = true;
+  Tmp1075Cfg tmp1075Cfg;
   bool addCamSwitcherDummy = false;
 };
 

mission/controller/ThermalController.cpp

@@ -1,6 +1,6 @@
 #include "ThermalController.h"
 
-#include <bsp_q7s/core/CoreDefinitions.h>
+#include <bsp_q7s/core/defs.h>
 #include <eive/objects.h>
 #include <fsfw/datapool/PoolReadGuard.h>
 #include <fsfw/thermal/ThermalComponentIF.h>
@@ -24,9 +24,11 @@
 #define LOWER_RW_UPPER_LIMITS 0
 
 ThermalController::ThermalController(object_id_t objectId, HeaterHandler& heater,
-                                     const std::atomic_bool& tcsBoardShortUnavailable)
+                                     const std::atomic_bool& tcsBoardShortUnavailable,
+                                     bool pollPcdu1Tmp)
     : ExtendedControllerBase(objectId),
       heaterHandler(heater),
+      pollPcdu1Tmp(pollPcdu1Tmp),
       sensorTemperatures(this),
       susTemperatures(this),
       deviceTemperatures(this),
@@ -55,8 +57,6 @@ ThermalController::ThermalController(object_id_t objectId, HeaterHandler& heater
       tmp1075SetTcs0(objects::TMP1075_HANDLER_TCS_0),
       tmp1075SetTcs1(objects::TMP1075_HANDLER_TCS_1),
       tmp1075SetPlPcdu0(objects::TMP1075_HANDLER_PLPCDU_0),
-      // damaged
-      // tmp1075SetPlPcdu1(objects::TMP1075_HANDLER_PLPCDU_1),
       tmp1075SetIfBoard(objects::TMP1075_HANDLER_IF_BOARD),
       susSet0(objects::SUS_0_N_LOC_XFYFZM_PT_XF),
       susSet1(objects::SUS_1_N_LOC_XBYFZM_PT_XB),
@@ -71,6 +71,9 @@ ThermalController::ThermalController(object_id_t objectId, HeaterHandler& heater
       susSet10(objects::SUS_10_N_LOC_XMYBZF_PT_ZF),
       susSet11(objects::SUS_11_R_LOC_XBYMZB_PT_ZB),
       tcsBrdShortlyUnavailable(tcsBoardShortUnavailable) {
+  if (pollPcdu1Tmp) {
+    tmp1075SetPlPcdu1 = new TMP1075::Tmp1075Dataset(objects::TMP1075_HANDLER_PLPCDU_1);
+  }
   resetSensorsArray();
 }
 
@@ -536,19 +539,19 @@ void ThermalController::copySensors() {
       }
     }
   }
-  // damaged
+  // damaged on FM, and no dummies for now
-  /*
+  if (pollPcdu1Tmp) {
-  {
+    {
-    PoolReadGuard pg(&tmp1075SetPlPcdu1, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+      PoolReadGuard pg(tmp1075SetPlPcdu1, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
-    if (pg.getReadResult() == returnvalue::OK) {
+      if (pg.getReadResult() == returnvalue::OK) {
-      sensorTemperatures.tmp1075PlPcdu1.value = tmp1075SetPlPcdu1.temperatureCelcius.value;
+        sensorTemperatures.tmp1075PlPcdu1.value = tmp1075SetPlPcdu1->temperatureCelcius.value;
-      sensorTemperatures.tmp1075PlPcdu1.setValid(tmp1075SetPlPcdu1.temperatureCelcius.isValid());
+        sensorTemperatures.tmp1075PlPcdu1.setValid(tmp1075SetPlPcdu1->temperatureCelcius.isValid());
-      if (not tmp1075SetPlPcdu1.temperatureCelcius.isValid()) {
+        if (not tmp1075SetPlPcdu1->temperatureCelcius.isValid()) {
-        sensorTemperatures.tmp1075PlPcdu1.value = INVALID_TEMPERATURE;
+          sensorTemperatures.tmp1075PlPcdu1.value = INVALID_TEMPERATURE;
+        }
       }
     }
   }
-  */
   {
     PoolReadGuard pg(&tmp1075SetIfBoard, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg.getReadResult() == returnvalue::OK) {
@@ -1828,6 +1831,12 @@ void ThermalController::heaterSwitchHelperAllOff() {
   }
 }
 
+ThermalController::~ThermalController() {
+  if (tmp1075SetPlPcdu1 != nullptr) {
+    delete tmp1075SetPlPcdu1;
+  }
+}
+
 void ThermalController::tooHotHandlerWhichClearsOneShotFlag(object_id_t object, bool& oneShotFlag) {
   // Clear the one shot flag is the component is in acceptable temperature range.
   if (not tooHotHandler(object, oneShotFlag) and not componentAboveUpperLimit) {

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>
@@ -103,7 +103,8 @@ class ThermalController : public ExtendedControllerBase {
   static constexpr int16_t SANITY_LIMIT_UPPER_TEMP = 160;
 
   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;
 
@@ -142,6 +143,7 @@ class ThermalController : public ExtendedControllerBase {
 
   HeaterHandler& heaterHandler;
 
+  bool pollPcdu1Tmp;
   tcsCtrl::SensorTemperatures sensorTemperatures;
   tcsCtrl::SusTemperatures susTemperatures;
   tcsCtrl::DeviceTemperatures deviceTemperatures;
@@ -173,7 +175,7 @@ class ThermalController : public ExtendedControllerBase {
   TMP1075::Tmp1075Dataset tmp1075SetTcs1;
   TMP1075::Tmp1075Dataset tmp1075SetPlPcdu0;
   // damaged
-  // TMP1075::Tmp1075Dataset tmp1075SetPlPcdu1;
+  TMP1075::Tmp1075Dataset* tmp1075SetPlPcdu1;
   TMP1075::Tmp1075Dataset tmp1075SetIfBoard;
 
   // SUS

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
+  if (schedConf.scheduleTmpDev0) {
-  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.2,
+    thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0,
-                        DeviceHandlerIF::PERFORM_OPERATION);
+                          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, 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.1, 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.1, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.3, DeviceHandlerIF::GET_READ);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.1, DeviceHandlerIF::GET_READ);
+  }
 
-  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.4,
+  if (schedConf.scheduleTmpDev1) {
-                        DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.2,
-  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.4, DeviceHandlerIF::SEND_WRITE);
+                          DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.4, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.2,
-  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.5, DeviceHandlerIF::SEND_READ);
+                          DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.5, DeviceHandlerIF::GET_READ);
+    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,
+  if (schedConf.schedulePlPcduDev0) {
-                        DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.4,
-  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.6,
+                          DeviceHandlerIF::PERFORM_OPERATION);
-                        DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.4,
-  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.6,
+                          DeviceHandlerIF::SEND_WRITE);
-                        DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.4,
-  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.7,
+                          DeviceHandlerIF::GET_WRITE);
-                        DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.5,
-  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.7, DeviceHandlerIF::GET_READ);
+                          DeviceHandlerIF::SEND_READ);
-  // damaged
+    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.5,
-  /*
+                          DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.4,
+  }
-                        DeviceHandlerIF::PERFORM_OPERATION);
+  if (schedConf.schedulePlPcduDev1) {
-  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.4,
+    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.6,
-                        DeviceHandlerIF::SEND_WRITE);
+                          DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.4,
+    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.6,
-                        DeviceHandlerIF::GET_WRITE);
+                          DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.4,
+    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.6,
-                        DeviceHandlerIF::SEND_READ);
+                          DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.4, DeviceHandlerIF::GET_READ);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.7,
-  */
+                          DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.8,
+    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.7,
-                        DeviceHandlerIF::PERFORM_OPERATION);
+                          DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.8,
+  }
-                        DeviceHandlerIF::SEND_WRITE);
+
-  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.8,
+  if (schedConf.scheduleIfBoardDev) {
-                        DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.8,
-  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.9,
+                          DeviceHandlerIF::PERFORM_OPERATION);
-                        DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.8,
-  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.9, DeviceHandlerIF::GET_READ);
+                          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/tcs/TmpDevFdir.cpp

@@ -28,7 +28,7 @@ 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.
+      // With no way to do a recovery, set the device to faulty instead of trying a recovery.
       if (strangeReplyCount.incrementAndCheck()) {
         setFaulty(event->getEvent());
       }

mission/tcs/Tmp1075Handler.cpp

@@ -1,5 +1,5 @@
-#include <fsfw/datapool/PoolReadGuard.h>
 #include <OBSWConfig.h>
+#include <fsfw/datapool/PoolReadGuard.h>
 #include <mission/tcs/Tmp1075Definitions.h>
 #include <mission/tcs/Tmp1075Handler.h>
 
@@ -12,11 +12,7 @@ Tmp1075Handler::Tmp1075Handler(object_id_t objectId, object_id_t comIF, CookieIF
 
 Tmp1075Handler::~Tmp1075Handler() {}
 
-void Tmp1075Handler::doStartUp() {
+void Tmp1075Handler::doStartUp() { setMode(MODE_ON); }
-  if (getMode() == _MODE_START_UP) {
-    setMode(MODE_ON);
-  }
-}
 
 void Tmp1075Handler::doShutDown() {
   communicationStep = CommunicationStep::START_ADC_CONVERSION;

tmtc

@@ -1 +1 @@
-Subproject commit 18304c31fa423b1af6ff47764d4be81c7f20c8f2
+Subproject commit c48f04eed5152f319b217870292968fb67b763d4

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);