CMakeLists.txt

@@ -175,6 +175,7 @@ set(LIB_CXX_FS -lstdc++fs)
 set(LIB_CATCH2 Catch2)
 set(LIB_GPS gps)
 set(LIB_JSON_NAME nlohmann_json::nlohmann_json)
+set(LIB_DUMMIES dummies)
 
 # Set path names
 set(FSFW_PATH fsfw)
@@ -182,6 +183,7 @@ set(TEST_PATH test)
 set(UNITTEST_PATH unittest)
 set(LINUX_PATH linux)
 set(COMMON_PATH common)
+set(DUMMY_PATH dummies)
 set(WATCHDOG_PATH watchdog)
 set(COMMON_CONFIG_PATH ${COMMON_PATH}/config)
 set(UNITTEST_CFG_PATH ${UNITTEST_PATH}/testcfg)
@@ -312,6 +314,7 @@ elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
 endif()
 
 add_library(${LIB_EIVE_MISSION})
+add_library(${LIB_DUMMIES})
 
 # Add main executable
 add_executable(${OBSW_NAME})
@@ -357,6 +360,7 @@ if(ADD_CSP_LIB)
 endif()
 
 add_subdirectory(${COMMON_PATH})
+add_subdirectory(${DUMMY_PATH})
 
 add_subdirectory(${LIB_LWGPS_PATH})
 add_subdirectory(${FSFW_PATH})
@@ -430,14 +434,16 @@ endif()
 target_link_libraries(${LIB_EIVE_MISSION}
                       PUBLIC ${LIB_FSFW_NAME} ${LIB_LWGPS_NAME} ${LIB_OS_NAME})
 
-target_link_libraries(${OBSW_NAME} PRIVATE ${LIB_EIVE_MISSION})
+target_link_libraries(${LIB_DUMMIES} PUBLIC ${LIB_FSFW_NAME} ${LIB_JSON_NAME})
+
+target_link_libraries(${OBSW_NAME} PRIVATE ${LIB_EIVE_MISSION} ${LIB_DUMMIES})
 
 if(TGT_BSP MATCHES "arm/q7s")
   target_link_libraries(${LIB_EIVE_MISSION} PUBLIC ${LIB_GPS} ${LIB_ARCSEC})
 endif()
 
 target_link_libraries(${UNITTEST_NAME} PRIVATE Catch2 ${LIB_EIVE_MISSION}
-                                               rapidcsv)
+                                               rapidcsv ${LIB_DUMMIES})
 
 if(TGT_BSP MATCHES "arm/egse")
   target_link_libraries(${OBSW_NAME} PRIVATE ${LIB_ARCSEC})
@@ -462,6 +468,10 @@ target_include_directories(
   ${LIB_EIVE_MISSION} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ${FSFW_CONFIG_PATH}
                              ${CMAKE_CURRENT_BINARY_DIR} ${LIB_ARCSEC_PATH})
 
+target_include_directories(
+  ${LIB_DUMMIES} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ${FSFW_CONFIG_PATH}
+                        ${CMAKE_CURRENT_BINARY_DIR})
+
 if(TGT_BSP MATCHES "arm/q7s" OR TGT_BSP MATCHES "arm/egse")
   target_include_directories(${LIB_EIVE_MISSION} PUBLIC ${ARCSEC_LIB_PATH})
 endif()

bsp_hosted/InitMission.cpp

@@ -1,6 +1,7 @@
 #include "InitMission.h"
 
 #include <OBSWConfig.h>
+#include <bsp_hosted/fsfwconfig/pollingsequence/DummyPst.h>
 #include <fsfw/objectmanager/ObjectManager.h>
 #include <fsfw/objectmanager/ObjectManagerIF.h>
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
@@ -89,9 +90,13 @@ void initmission::initTasks() {
     sif::error << "Object add component failed" << std::endl;
   }
 
-  PeriodicTaskIF* pusEvents = factory->createPeriodicTask(
-      "PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
-  result = pusVerification->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
+  PeriodicTaskIF* eventHandling = factory->createPeriodicTask(
+      "EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+  result = eventHandling->addComponent(objects::EVENT_MANAGER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("EVENT_MNGR", objects::EVENT_MANAGER);
+  }
+  result = eventHandling->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS5", objects::PUS_SERVICE_5_EVENT_REPORTING);
   }
@@ -106,6 +111,10 @@ void initmission::initTasks() {
   if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT);
   }
+  result = pusHighPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS3", objects::PUS_SERVICE_3_HOUSEKEEPING);
+  }
 
   PeriodicTaskIF* pusMedPrio = factory->createPeriodicTask(
       "PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
@@ -129,9 +138,34 @@ void initmission::initTasks() {
     initmission::printAddObjectError("PUS17", objects::PUS_SERVICE_17_TEST);
   }
 
-  PeriodicTaskIF* testTask = factory->createPeriodicTask(
-      "TEST_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
-  static_cast<void>(testTask);
+  PeriodicTaskIF* thermalTask = factory->createPeriodicTask(
+      "THERMAL_CTL_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
+  result = thermalTask->addComponent(objects::RTD_0_IC3_PLOC_HEATSPREADER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("RTD_0_dummy", objects::RTD_0_IC3_PLOC_HEATSPREADER);
+  }
+  result = thermalTask->addComponent(objects::SUS_0_N_LOC_XFYFZM_PT_XF);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("SUS_0_dummy", objects::SUS_0_N_LOC_XFYFZM_PT_XF);
+  }
+
+  result = thermalTask->addComponent(objects::CORE_CONTROLLER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("Core controller dummy", objects::CORE_CONTROLLER);
+  }
+
+  result = thermalTask->addComponent(objects::THERMAL_CONTROLLER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("THERMAL_CONTROLLER", objects::THERMAL_CONTROLLER);
+  }
+
+  FixedTimeslotTaskIF* pstTask = factory->createFixedTimeslotTask(
+      "DUMMY_PST", 75, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.5, missedDeadlineFunc);
+  result = dummy_pst::pst(pstTask);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "Failed to add dummy pst to fixed timeslot task" << std::endl;
+  }
+
 #if OBSW_ADD_TEST_CODE == 1
   result = testTask->addComponent(objects::TEST_TASK);
   if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -145,11 +179,14 @@ void initmission::initTasks() {
   tmtcPollingTask->startTask();
 
   pusVerification->startTask();
-  pusEvents->startTask();
+  eventHandling->startTask();
   pusHighPrio->startTask();
   pusMedPrio->startTask();
   pusLowPrio->startTask();
 
+  pstTask->startTask();
+  thermalTask->startTask();
+
 #if OBSW_ADD_TEST_CODE == 1
   testTask->startTask();
 #endif /* OBSW_ADD_TEST_CODE == 1 */

bsp_hosted/ObjectFactory.cpp

@@ -2,6 +2,7 @@
 
 #include <fsfw/tmtcservices/CommandingServiceBase.h>
 #include <fsfw/tmtcservices/PusServiceBase.h>
+#include <mission/controller/ThermalController.h>
 #include <mission/core/GenericFactory.h>
 #include <mission/utility/TmFunnel.h>
 #include <objects/systemObjectList.h>
@@ -25,6 +26,24 @@
 #include <test/testtasks/TestTask.h>
 #endif
 
+#include <dummies/AcuDummy.h>
+#include <dummies/BpxDummy.h>
+#include <dummies/ComCookieDummy.h>
+#include <dummies/ComIFDummy.h>
+#include <dummies/CoreControllerDummy.h>
+#include <dummies/GyroAdisDummy.h>
+#include <dummies/GyroL3GD20Dummy.h>
+#include <dummies/ImtqDummy.h>
+#include <dummies/MgmLIS3MDLDummy.h>
+#include <dummies/P60DockDummy.h>
+#include <dummies/PduDummy.h>
+#include <dummies/PlPcduDummy.h>
+#include <dummies/RwDummy.h>
+#include <dummies/StarTrackerDummy.h>
+#include <dummies/SusDummy.h>
+#include <dummies/SyrlinksDummy.h>
+#include <dummies/TemperatureSensorsDummy.h>
+
 void Factory::setStaticFrameworkObjectIds() {
   PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
   PusServiceBase::packetDestination = objects::TM_FUNNEL;
@@ -44,5 +63,31 @@ void ObjectFactory::produce(void* args) {
   Factory::setStaticFrameworkObjectIds();
   ObjectFactory::produceGenericObjects();
 
-  new TestTask(objects::TEST_TASK);
+  new ComIFDummy(objects::DUMMY_COM_IF);
+  ComCookieDummy* comCookieDummy = new ComCookieDummy();
+  new BpxDummy(objects::BPX_BATT_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  new CoreControllerDummy(objects::CORE_CONTROLLER);
+  new RwDummy(objects::RW1, objects::DUMMY_COM_IF, comCookieDummy);
+  new RwDummy(objects::RW2, objects::DUMMY_COM_IF, comCookieDummy);
+  new RwDummy(objects::RW3, objects::DUMMY_COM_IF, comCookieDummy);
+  new RwDummy(objects::RW4, objects::DUMMY_COM_IF, comCookieDummy);
+  new StarTrackerDummy(objects::STAR_TRACKER, objects::DUMMY_COM_IF, comCookieDummy);
+  new SyrlinksDummy(objects::SYRLINKS_HK_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  new ImtqDummy(objects::IMTQ_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  new AcuDummy(objects::ACU_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  new PduDummy(objects::PDU1_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  new PduDummy(objects::PDU2_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  new P60DockDummy(objects::P60DOCK_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  new GyroAdisDummy(objects::GYRO_0_ADIS_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  new GyroL3GD20Dummy(objects::GYRO_1_L3G_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  new GyroAdisDummy(objects::GYRO_2_ADIS_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  new GyroL3GD20Dummy(objects::GYRO_3_L3G_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  new MgmLIS3MDLDummy(objects::MGM_0_LIS3_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  new MgmLIS3MDLDummy(objects::MGM_2_LIS3_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  new PlPcduDummy(objects::PLPCDU_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  new TemperatureSensorsDummy();
+  new SusDummy();
+  new ThermalController(objects::THERMAL_CONTROLLER, objects::NO_OBJECT);
+
+  // new TestTask(objects::TEST_TASK);
 }

bsp_hosted/comIF/CMakeLists.txt

@@ -1 +1 @@
-target_sources(${TARGET_NAME} PUBLIC ArduinoComIF.cpp ArduinoCookie.cpp)
+target_sources(${OBSW_NAME} PUBLIC ArduinoComIF.cpp ArduinoCookie.cpp)

bsp_hosted/fsfwconfig/CMakeLists.txt

@@ -13,3 +13,5 @@ if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/objects/translateObjects.cpp")
   target_sources(${OBSW_NAME} PRIVATE events/translateEvents.cpp)
   target_sources(${UNITTEST_NAME} PRIVATE events/translateEvents.cpp)
 endif()
+
+add_subdirectory(pollingsequence)

bsp_hosted/fsfwconfig/FSFWConfig.h.in

@@ -31,8 +31,8 @@
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
 //! Specify whether info events are printed too.
 #define FSFW_DEBUG_INFO 1
-#include "objects/translateObjects.h"
 #include "events/translateEvents.h"
+#include "objects/translateObjects.h"
 #else
 #endif
 
@@ -70,6 +70,6 @@ static constexpr size_t FSFW_PRINT_BUFFER_SIZE = 124;
 
 static constexpr size_t FSFW_MAX_TM_PACKET_SIZE = 2048;
 
-}
+}  // namespace fsfwconfig
 
 #endif /* CONFIG_FSFWCONFIG_H_ */

bsp_hosted/fsfwconfig/objects/systemObjectList.h

@@ -22,10 +22,11 @@ enum sourceObjects : uint32_t {
 
   TEST_TASK = 0x42694269,
   DUMMY_INTERFACE = 0xCAFECAFE,
-  DUMMY_HANDLER = 0x4400AFFE,
-
+  DUMMY_HANDLER = 0x44000001,
   /* 0x49 ('I') for Communication Interfaces **/
-  ARDUINO_COM_IF = 0x49000001
+  ARDUINO_COM_IF = 0x49000001,
+
+  DUMMY_COM_IF = 0x49000002
 };
 }
 

bsp_hosted/fsfwconfig/objects/translateObjects.cpp

@@ -6,6 +6,8 @@
  */
 #include "translateObjects.h"
 
+#include "systemObjectList.h"
+
 const char *TEST_TASK_STRING = "TEST_TASK";
 const char *DUMMY_HANDLER_STRING = "DUMMY_HANDLER";
 const char *ARDUINO_COM_IF_STRING = "ARDUINO_COM_IF";
@@ -36,6 +38,7 @@ const char *IPC_STORE_STRING = "IPC_STORE";
 const char *TIME_STAMPER_STRING = "TIME_STAMPER";
 const char *FSFW_OBJECTS_END_STRING = "FSFW_OBJECTS_END";
 const char *DUMMY_INTERFACE_STRING = "DUMMY_INTERFACE";
+const char *THERMAL_CONTROLLER_STRING = "THERMAL_CONTROLLER";
 const char *NO_OBJECT_STRING = "NO_OBJECT";
 
 const char *translateObject(object_id_t object) {
@@ -100,6 +103,8 @@ const char *translateObject(object_id_t object) {
       return FSFW_OBJECTS_END_STRING;
     case 0xCAFECAFE:
       return DUMMY_INTERFACE_STRING;
+    case objects::THERMAL_CONTROLLER:
+      return THERMAL_CONTROLLER_STRING;
     case 0xFFFFFFFF:
       return NO_OBJECT_STRING;
     default:

bsp_hosted/fsfwconfig/pollingsequence/CMakeLists.txt

@@ -0,0 +1 @@
+target_sources(${OBSW_NAME} PRIVATE DummyPst.cpp)

bsp_hosted/fsfwconfig/pollingsequence/DummyPst.cpp

@@ -0,0 +1,140 @@
+#include "DummyPst.h"
+
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+#include <fsfw/tasks/FixedTimeslotTaskIF.h>
+#include <objects/systemObjectList.h>
+
+ReturnValue_t dummy_pst::pst(FixedTimeslotTaskIF *thisSequence) {
+  uint32_t length = thisSequence->getPeriodMs();
+
+  thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::RW1, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::RW1, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::RW1, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::RW1, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::RW1, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::RW2, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::RW2, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::RW2, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::RW2, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::RW2, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::RW3, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::RW3, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::RW3, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::RW3, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::RW3, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::RW4, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::RW4, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::RW4, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::RW4, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::RW4, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::ACU_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::ACU_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::ACU_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::ACU_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::ACU_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+  if (thisSequence->checkSequence() == HasReturnvaluesIF::RETURN_OK) {
+    return HasReturnvaluesIF::RETURN_OK;
+  } else {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "pst::pollingSequenceInitDefault: Sequence invalid!" << std::endl;
+#endif
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+}

bsp_hosted/fsfwconfig/pollingsequence/DummyPst.h

@@ -0,0 +1,14 @@
+#ifndef POLLINGSEQUENCEFACTORY_H_
+#define POLLINGSEQUENCEFACTORY_H_
+
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+class FixedTimeslotTaskIF;
+
+namespace dummy_pst {
+
+ReturnValue_t pst(FixedTimeslotTaskIF *thisSequence);
+
+}
+
+#endif /* POLLINGSEQUENCEINIT_H_ */

bsp_hosted/main.cpp

@@ -1,9 +1,17 @@
+#include <objects/systemObjectList.h>
+
 #include <iostream>
 
 #include "InitMission.h"
 #include "commonConfig.h"
 #include "fsfw/FSFWVersion.h"
+#include "fsfw/controller/ControllerBase.h"
+#include "fsfw/ipc/QueueFactory.h"
+#include "fsfw/modes/HasModesIF.h"
+#include "fsfw/modes/ModeMessage.h"
+#include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/tasks/TaskFactory.h"
+
 #ifdef WIN32
 static const char* COMPILE_PRINTOUT = "Windows";
 #elif LINUX

bsp_q7s/core/InitMission.cpp

@@ -183,6 +183,7 @@ void initmission::initTasks() {
       objects::RTD_15_IC18_IMTQ,
   };
   tcsTask->addComponent(objects::TCS_BOARD_ASS);
+  tcsTask->addComponent(objects::THERMAL_CONTROLLER);
   for (const auto& rtd : rtdIds) {
     tcsTask->addComponent(rtd, DeviceHandlerIF::PERFORM_OPERATION);
     tcsTask->addComponent(rtd, DeviceHandlerIF::SEND_WRITE);

bsp_q7s/core/ObjectFactory.cpp

@@ -6,7 +6,6 @@
 #include "bsp_q7s/callbacks/pcduSwitchCb.h"
 #include "bsp_q7s/callbacks/q7sGpioCallbacks.h"
 #include "bsp_q7s/callbacks/rwSpiCallback.h"
-#include "bsp_q7s/core/CoreController.h"
 #include "bsp_q7s/memory/FileSystemHandler.h"
 #include "busConf.h"
 #include "ccsdsConfig.h"

bsp_q7s/fmObjectFactory.cpp

@@ -62,4 +62,5 @@ void ObjectFactory::produce(void* args) {
 #endif /* OBSW_ADD_TEST_CODE == 1 */
 
   createMiscComponents();
+  createThermalController();
 }

dummies/AcuDummy.cpp

@@ -0,0 +1,42 @@
+#include "AcuDummy.h"
+
+#include <mission/devices/devicedefinitions/GomspaceDefinitions.h>
+
+AcuDummy::AcuDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
+    : DeviceHandlerBase(objectId, comif, comCookie) {}
+
+AcuDummy::~AcuDummy() {}
+
+void AcuDummy::doStartUp() {}
+
+void AcuDummy::doShutDown() {}
+
+ReturnValue_t AcuDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) { return NOTHING_TO_SEND; }
+
+ReturnValue_t AcuDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t AcuDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                const uint8_t *commandData, size_t commandDataLen) {
+  return RETURN_OK;
+}
+
+ReturnValue_t AcuDummy::scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+                                     size_t *foundLen) {
+  return RETURN_OK;
+}
+
+ReturnValue_t AcuDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
+  return RETURN_OK;
+}
+
+void AcuDummy::fillCommandAndReplyMap() {}
+
+uint32_t AcuDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
+
+ReturnValue_t AcuDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                                LocalDataPoolManager &poolManager) {
+  localDataPoolMap.emplace(P60System::pool::ACU_TEMPERATURES, new PoolEntry<float>(3));
+  return HasReturnvaluesIF::RETURN_OK;
+}

dummies/AcuDummy.h

@@ -0,0 +1,33 @@
+#ifndef DUMMIES_ACUDUMMY_H_
+#define DUMMIES_ACUDUMMY_H_
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+
+class AcuDummy : public DeviceHandlerBase {
+ public:
+  static const DeviceCommandId_t SIMPLE_COMMAND = 1;
+  static const DeviceCommandId_t PERIODIC_REPLY = 2;
+
+  static const uint8_t SIMPLE_COMMAND_DATA = 1;
+  static const uint8_t PERIODIC_REPLY_DATA = 2;
+
+  AcuDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  virtual ~AcuDummy();
+
+ protected:
+  void doStartUp() override;
+  void doShutDown() override;
+  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
+                                        size_t commandDataLen) override;
+  ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+                             size_t *foundLen) override;
+  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
+  void fillCommandAndReplyMap() override;
+  uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                        LocalDataPoolManager &poolManager) override;
+};
+
+#endif /* DUMMIES_ACUDUMMY_H_ */

dummies/BpxDummy.cpp

@@ -0,0 +1,55 @@
+#include "BpxDummy.h"
+
+#include <mission/devices/devicedefinitions/BpxBatteryDefinitions.h>
+
+BpxDummy::BpxDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
+    : DeviceHandlerBase(objectId, comif, comCookie) {}
+
+BpxDummy::~BpxDummy() {}
+
+void BpxDummy::doStartUp() {}
+
+void BpxDummy::doShutDown() {}
+
+ReturnValue_t BpxDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) { return NOTHING_TO_SEND; }
+
+ReturnValue_t BpxDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t BpxDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                const uint8_t *commandData, size_t commandDataLen) {
+  return RETURN_OK;
+}
+
+ReturnValue_t BpxDummy::scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+                                     size_t *foundLen) {
+  return RETURN_OK;
+}
+
+ReturnValue_t BpxDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
+  return RETURN_OK;
+}
+
+void BpxDummy::fillCommandAndReplyMap() {}
+
+uint32_t BpxDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
+
+ReturnValue_t BpxDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                                LocalDataPoolManager &poolManager) {
+  localDataPoolMap.emplace(BpxBattery::BATT_TEMP_1, &battTemp1);
+  localDataPoolMap.emplace(BpxBattery::BATT_TEMP_2, &battTemp2);
+  localDataPoolMap.emplace(BpxBattery::BATT_TEMP_3, &battTemp3);
+  localDataPoolMap.emplace(BpxBattery::BATT_TEMP_4, &battTemp4);
+  localDataPoolMap.emplace(BpxBattery::CHARGE_CURRENT, &chargeCurrent);
+  localDataPoolMap.emplace(BpxBattery::DISCHARGE_CURRENT, &dischargeCurrent);
+  localDataPoolMap.emplace(BpxBattery::HEATER_CURRENT, &heaterCurrent);
+  localDataPoolMap.emplace(BpxBattery::BATT_VOLTAGE, &battVolt);
+  localDataPoolMap.emplace(BpxBattery::REBOOT_COUNTER, &rebootCounter);
+  localDataPoolMap.emplace(BpxBattery::BOOTCAUSE, &bootCause);
+
+  localDataPoolMap.emplace(BpxBattery::BATTERY_HEATER_MODE, &battheatMode);
+  localDataPoolMap.emplace(BpxBattery::BATTHEAT_LOW_LIMIT, &battheatLow);
+  localDataPoolMap.emplace(BpxBattery::BATTHEAT_HIGH_LIMIT, &battheatHigh);
+  return HasReturnvaluesIF::RETURN_OK;
+}

dummies/BpxDummy.h

@@ -0,0 +1,48 @@
+#ifndef DUMMIES_BPXDUMMY_H_
+#define DUMMIES_BPXDUMMY_H_
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+
+class BpxDummy : public DeviceHandlerBase {
+ public:
+  static const DeviceCommandId_t SIMPLE_COMMAND = 1;
+  static const DeviceCommandId_t PERIODIC_REPLY = 2;
+
+  static const uint8_t SIMPLE_COMMAND_DATA = 1;
+  static const uint8_t PERIODIC_REPLY_DATA = 2;
+
+  BpxDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  virtual ~BpxDummy();
+
+ protected:
+  void doStartUp() override;
+  void doShutDown() override;
+  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
+                                        size_t commandDataLen) override;
+  ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+                             size_t *foundLen) override;
+  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
+  void fillCommandAndReplyMap() override;
+  uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                        LocalDataPoolManager &poolManager) override;
+
+ private:
+  PoolEntry<uint16_t> chargeCurrent = PoolEntry<uint16_t>({0});
+  PoolEntry<uint16_t> dischargeCurrent = PoolEntry<uint16_t>({0});
+  PoolEntry<uint16_t> heaterCurrent = PoolEntry<uint16_t>({0});
+  PoolEntry<uint16_t> battVolt = PoolEntry<uint16_t>({0});
+  PoolEntry<int16_t> battTemp1 = PoolEntry<int16_t>({0});
+  PoolEntry<int16_t> battTemp2 = PoolEntry<int16_t>({0});
+  PoolEntry<int16_t> battTemp3 = PoolEntry<int16_t>({0});
+  PoolEntry<int16_t> battTemp4 = PoolEntry<int16_t>({0});
+  PoolEntry<uint32_t> rebootCounter = PoolEntry<uint32_t>({0});
+  PoolEntry<uint8_t> bootCause = PoolEntry<uint8_t>({0});
+  PoolEntry<uint8_t> battheatMode = PoolEntry<uint8_t>({0});
+  PoolEntry<int8_t> battheatLow = PoolEntry<int8_t>({0});
+  PoolEntry<int8_t> battheatHigh = PoolEntry<int8_t>({0});
+};
+
+#endif /* DUMMIES_BPXDUMMY_H_ */

dummies/CMakeLists.txt

@@ -0,0 +1,19 @@
+target_sources(
+  ${LIB_DUMMIES}
+  PUBLIC TemperatureSensorsDummy.cpp
+         SusDummy.cpp
+         BpxDummy.cpp
+         ComIFDummy.cpp
+         ComCookieDummy.cpp
+         RwDummy.cpp
+         StarTrackerDummy.cpp
+         SyrlinksDummy.cpp
+         ImtqDummy.cpp
+         AcuDummy.cpp
+         PduDummy.cpp
+         P60DockDummy.cpp
+         GyroAdisDummy.cpp
+         GyroL3GD20Dummy.cpp
+         MgmLIS3MDLDummy.cpp
+         PlPcduDummy.cpp
+         CoreControllerDummy.cpp)

dummies/ComCookieDummy.cpp

@@ -0,0 +1,5 @@
+#include "ComCookieDummy.h"
+
+ComCookieDummy::ComCookieDummy() {}
+
+ComCookieDummy::~ComCookieDummy() {}

dummies/ComCookieDummy.h

@@ -0,0 +1,12 @@
+#ifndef TESTS_SRC_FSFW_TESTS_UNIT_DEVICEHANDLER_COMCOOKIEDUMMY_H_
+#define TESTS_SRC_FSFW_TESTS_UNIT_DEVICEHANDLER_COMCOOKIEDUMMY_H_
+
+#include "fsfw/devicehandlers/CookieIF.h"
+
+class ComCookieDummy : public CookieIF {
+ public:
+  ComCookieDummy();
+  virtual ~ComCookieDummy();
+};
+
+#endif /* TESTS_SRC_FSFW_TESTS_UNIT_DEVICEHANDLER_COMCOOKIEDUMMY_H_ */

dummies/ComIFDummy.cpp

@@ -0,0 +1,21 @@
+#include "ComIFDummy.h"
+
+ComIFDummy::ComIFDummy(object_id_t objectId) : SystemObject(objectId) {}
+
+ComIFDummy::~ComIFDummy() {}
+
+ReturnValue_t ComIFDummy::initializeInterface(CookieIF *cookie) { return RETURN_OK; }
+
+ReturnValue_t ComIFDummy::sendMessage(CookieIF *cookie, const uint8_t *sendData, size_t sendLen) {
+  return RETURN_OK;
+}
+
+ReturnValue_t ComIFDummy::getSendSuccess(CookieIF *cookie) { return RETURN_OK; }
+
+ReturnValue_t ComIFDummy::requestReceiveMessage(CookieIF *cookie, size_t requestLen) {
+  return RETURN_OK;
+}
+
+ReturnValue_t ComIFDummy::readReceivedMessage(CookieIF *cookie, uint8_t **buffer, size_t *size) {
+  return RETURN_OK;
+}

dummies/ComIFDummy.h

@@ -0,0 +1,26 @@
+#ifndef DUMMIES_COMIFDUMMY_H_
+#define DUMMIES_COMIFDUMMY_H_
+
+#include <fsfw/devicehandlers/DeviceCommunicationIF.h>
+#include <fsfw/objectmanager/SystemObject.h>
+
+/**
+ * @brief	The ComIFMock supports the simulation of various device communication error cases
+ * 			  like incomplete or wrong replies and can be used to test the
+ * DeviceHandlerBase.
+ */
+class ComIFDummy : public DeviceCommunicationIF, public SystemObject {
+ public:
+  ComIFDummy(object_id_t objectId);
+  virtual ~ComIFDummy();
+
+  virtual ReturnValue_t initializeInterface(CookieIF *cookie) override;
+  virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t *sendData,
+                                    size_t sendLen) override;
+  virtual ReturnValue_t getSendSuccess(CookieIF *cookie) override;
+  virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen) override;
+  virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
+                                            size_t *size) override;
+};
+
+#endif /* DUMMIES_COMIFDUMMY_H_ */

dummies/CoreControllerDummy.cpp

@@ -0,0 +1,55 @@
+#include "CoreControllerDummy.h"
+
+#include <bsp_q7s/core/CoreDefinitions.h>
+#include <objects/systemObjectList.h>
+
+#include <cmath>
+#include <cstdlib>
+
+CoreControllerDummy::CoreControllerDummy(object_id_t objectId)
+    : ExtendedControllerBase(objectId, objects::NO_OBJECT) {}
+
+ReturnValue_t CoreControllerDummy::initialize() {
+  static bool done = false;
+  if (not done) {
+    done = true;
+    ReturnValue_t result = ExtendedControllerBase::initialize();
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+  }
+
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t CoreControllerDummy::handleCommandMessage(CommandMessage* message) {
+  return RETURN_FAILED;
+}
+
+void CoreControllerDummy::performControlOperation() { return; }
+
+ReturnValue_t CoreControllerDummy::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+                                                           LocalDataPoolManager& poolManager) {
+  localDataPoolMap.emplace(core::TEMPERATURE, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(core::PS_VOLTAGE, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(core::PL_VOLTAGE, new PoolEntry<float>({0}));
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+LocalPoolDataSetBase* CoreControllerDummy::getDataSetHandle(sid_t sid) {
+  switch (sid.ownerSetId) {
+    default:
+      return nullptr;
+  }
+}
+
+ReturnValue_t CoreControllerDummy::checkModeCommand(Mode_t mode, Submode_t submode,
+                                                    uint32_t* msToReachTheMode) {
+  if (submode != SUBMODE_NONE) {
+    return INVALID_SUBMODE;
+  }
+  if ((mode != MODE_OFF) && (mode != MODE_ON) && (mode != MODE_NORMAL)) {
+    return INVALID_MODE;
+  }
+  return RETURN_OK;
+}

dummies/CoreControllerDummy.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <fsfw/controller/ExtendedControllerBase.h>
+#include <mission/devices/devicedefinitions/SusDefinitions.h>
+
+class CoreControllerDummy : public ExtendedControllerBase {
+ public:
+  CoreControllerDummy(object_id_t objectId);
+
+  ReturnValue_t initialize() override;
+
+ protected:
+  virtual ReturnValue_t handleCommandMessage(CommandMessage* message) override;
+  virtual void performControlOperation() override;
+  virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+                                                LocalDataPoolManager& poolManager) override;
+  virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
+
+  virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+                                         uint32_t* msToReachTheMode) override;
+};

dummies/GyroAdisDummy.cpp

@@ -0,0 +1,45 @@
+#include "GyroAdisDummy.h"
+
+#include "mission/devices/devicedefinitions/GyroADIS1650XDefinitions.h"
+
+GyroAdisDummy::GyroAdisDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
+    : DeviceHandlerBase(objectId, comif, comCookie) {}
+
+GyroAdisDummy::~GyroAdisDummy() {}
+
+void GyroAdisDummy::doStartUp() {}
+
+void GyroAdisDummy::doShutDown() {}
+
+ReturnValue_t GyroAdisDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t GyroAdisDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t GyroAdisDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                     const uint8_t *commandData,
+                                                     size_t commandDataLen) {
+  return RETURN_OK;
+}
+
+ReturnValue_t GyroAdisDummy::scanForReply(const uint8_t *start, size_t len,
+                                          DeviceCommandId_t *foundId, size_t *foundLen) {
+  return RETURN_OK;
+}
+
+ReturnValue_t GyroAdisDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
+  return RETURN_OK;
+}
+
+void GyroAdisDummy::fillCommandAndReplyMap() {}
+
+uint32_t GyroAdisDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
+
+ReturnValue_t GyroAdisDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                                     LocalDataPoolManager &poolManager) {
+  localDataPoolMap.emplace(ADIS1650X::TEMPERATURE, new PoolEntry<float>({0.0}));
+  return HasReturnvaluesIF::RETURN_OK;
+}

dummies/GyroAdisDummy.h

@@ -0,0 +1,33 @@
+#ifndef DUMMIES_GYROADISDUMMY_H_
+#define DUMMIES_GYROADISDUMMY_H_
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+
+class GyroAdisDummy : public DeviceHandlerBase {
+ public:
+  static const DeviceCommandId_t SIMPLE_COMMAND = 1;
+  static const DeviceCommandId_t PERIODIC_REPLY = 2;
+
+  static const uint8_t SIMPLE_COMMAND_DATA = 1;
+  static const uint8_t PERIODIC_REPLY_DATA = 2;
+
+  GyroAdisDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  virtual ~GyroAdisDummy();
+
+ protected:
+  void doStartUp() override;
+  void doShutDown() override;
+  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
+                                        size_t commandDataLen) override;
+  ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+                             size_t *foundLen) override;
+  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
+  void fillCommandAndReplyMap() override;
+  uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                        LocalDataPoolManager &poolManager) override;
+};
+
+#endif /* DUMMIES_GYROADISDUMMY_H_ */

dummies/GyroL3GD20Dummy.cpp

@@ -0,0 +1,48 @@
+#include "GyroL3GD20Dummy.h"
+
+#include "fsfw_hal/devicehandlers/devicedefinitions/GyroL3GD20Definitions.h"
+
+GyroL3GD20Dummy::GyroL3GD20Dummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
+    : DeviceHandlerBase(objectId, comif, comCookie) {}
+
+GyroL3GD20Dummy::~GyroL3GD20Dummy() {}
+
+void GyroL3GD20Dummy::doStartUp() {}
+
+void GyroL3GD20Dummy::doShutDown() {}
+
+ReturnValue_t GyroL3GD20Dummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t GyroL3GD20Dummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t GyroL3GD20Dummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                       const uint8_t *commandData,
+                                                       size_t commandDataLen) {
+  return RETURN_OK;
+}
+
+ReturnValue_t GyroL3GD20Dummy::scanForReply(const uint8_t *start, size_t len,
+                                            DeviceCommandId_t *foundId, size_t *foundLen) {
+  return RETURN_OK;
+}
+
+ReturnValue_t GyroL3GD20Dummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
+  return RETURN_OK;
+}
+
+void GyroL3GD20Dummy::fillCommandAndReplyMap() {}
+
+uint32_t GyroL3GD20Dummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
+
+ReturnValue_t GyroL3GD20Dummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                                       LocalDataPoolManager &poolManager) {
+  localDataPoolMap.emplace(L3GD20H::ANG_VELOC_X, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(L3GD20H::ANG_VELOC_Y, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(L3GD20H::ANG_VELOC_Z, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(L3GD20H::TEMPERATURE, new PoolEntry<float>({0.0}));
+  return HasReturnvaluesIF::RETURN_OK;
+}

dummies/GyroL3GD20Dummy.h

@@ -0,0 +1,33 @@
+#ifndef DUMMIES_GYROL3GD20DUMMY_H_
+#define DUMMIES_GYROL3GD20DUMMY_H_
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+
+class GyroL3GD20Dummy : public DeviceHandlerBase {
+ public:
+  static const DeviceCommandId_t SIMPLE_COMMAND = 1;
+  static const DeviceCommandId_t PERIODIC_REPLY = 2;
+
+  static const uint8_t SIMPLE_COMMAND_DATA = 1;
+  static const uint8_t PERIODIC_REPLY_DATA = 2;
+
+  GyroL3GD20Dummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  virtual ~GyroL3GD20Dummy();
+
+ protected:
+  void doStartUp() override;
+  void doShutDown() override;
+  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
+                                        size_t commandDataLen) override;
+  ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+                             size_t *foundLen) override;
+  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
+  void fillCommandAndReplyMap() override;
+  uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                        LocalDataPoolManager &poolManager) override;
+};
+
+#endif /* DUMMIES_GYROL3GD20DUMMY_H_ */

dummies/ImtqDummy.cpp

@@ -0,0 +1,43 @@
+#include "ImtqDummy.h"
+
+#include <mission/devices/devicedefinitions/IMTQHandlerDefinitions.h>
+
+ImtqDummy::ImtqDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
+    : DeviceHandlerBase(objectId, comif, comCookie) {}
+
+ImtqDummy::~ImtqDummy() {}
+
+void ImtqDummy::doStartUp() {}
+
+void ImtqDummy::doShutDown() {}
+
+ReturnValue_t ImtqDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) { return NOTHING_TO_SEND; }
+
+ReturnValue_t ImtqDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t ImtqDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                 const uint8_t *commandData,
+                                                 size_t commandDataLen) {
+  return RETURN_OK;
+}
+
+ReturnValue_t ImtqDummy::scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+                                      size_t *foundLen) {
+  return RETURN_OK;
+}
+
+ReturnValue_t ImtqDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
+  return RETURN_OK;
+}
+
+void ImtqDummy::fillCommandAndReplyMap() {}
+
+uint32_t ImtqDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
+
+ReturnValue_t ImtqDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                                 LocalDataPoolManager &poolManager) {
+  localDataPoolMap.emplace(IMTQ::MCU_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  return HasReturnvaluesIF::RETURN_OK;
+}

dummies/ImtqDummy.h

@@ -0,0 +1,33 @@
+#ifndef DUMMIES_IMTQDUMMY_H_
+#define DUMMIES_IMTQDUMMY_H_
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+
+class ImtqDummy : public DeviceHandlerBase {
+ public:
+  static const DeviceCommandId_t SIMPLE_COMMAND = 1;
+  static const DeviceCommandId_t PERIODIC_REPLY = 2;
+
+  static const uint8_t SIMPLE_COMMAND_DATA = 1;
+  static const uint8_t PERIODIC_REPLY_DATA = 2;
+
+  ImtqDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  virtual ~ImtqDummy();
+
+ protected:
+  void doStartUp() override;
+  void doShutDown() override;
+  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
+                                        size_t commandDataLen) override;
+  ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+                             size_t *foundLen) override;
+  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
+  void fillCommandAndReplyMap() override;
+  uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                        LocalDataPoolManager &poolManager) override;
+};
+
+#endif /* DUMMIES_IMTQDUMMY_H_ */

dummies/MgmLIS3MDLDummy.cpp

@@ -0,0 +1,45 @@
+#include "MgmLIS3MDLDummy.h"
+
+#include "fsfw_hal/devicehandlers/devicedefinitions/MgmLIS3HandlerDefs.h"
+
+MgmLIS3MDLDummy::MgmLIS3MDLDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
+    : DeviceHandlerBase(objectId, comif, comCookie) {}
+
+MgmLIS3MDLDummy::~MgmLIS3MDLDummy() {}
+
+void MgmLIS3MDLDummy::doStartUp() {}
+
+void MgmLIS3MDLDummy::doShutDown() {}
+
+ReturnValue_t MgmLIS3MDLDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t MgmLIS3MDLDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t MgmLIS3MDLDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                       const uint8_t *commandData,
+                                                       size_t commandDataLen) {
+  return RETURN_OK;
+}
+
+ReturnValue_t MgmLIS3MDLDummy::scanForReply(const uint8_t *start, size_t len,
+                                            DeviceCommandId_t *foundId, size_t *foundLen) {
+  return RETURN_OK;
+}
+
+ReturnValue_t MgmLIS3MDLDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
+  return RETURN_OK;
+}
+
+void MgmLIS3MDLDummy::fillCommandAndReplyMap() {}
+
+uint32_t MgmLIS3MDLDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
+
+ReturnValue_t MgmLIS3MDLDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                                       LocalDataPoolManager &poolManager) {
+  localDataPoolMap.emplace(MGMLIS3MDL::TEMPERATURE_CELCIUS, new PoolEntry<float>({0.0}));
+  return HasReturnvaluesIF::RETURN_OK;
+}

dummies/MgmLIS3MDLDummy.h

@@ -0,0 +1,33 @@
+#ifndef DUMMIES_MGMLIS3MDLDUMMY_H_
+#define DUMMIES_MGMLIS3MDLDUMMY_H_
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+
+class MgmLIS3MDLDummy : public DeviceHandlerBase {
+ public:
+  static const DeviceCommandId_t SIMPLE_COMMAND = 1;
+  static const DeviceCommandId_t PERIODIC_REPLY = 2;
+
+  static const uint8_t SIMPLE_COMMAND_DATA = 1;
+  static const uint8_t PERIODIC_REPLY_DATA = 2;
+
+  MgmLIS3MDLDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  virtual ~MgmLIS3MDLDummy();
+
+ protected:
+  void doStartUp() override;
+  void doShutDown() override;
+  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
+                                        size_t commandDataLen) override;
+  ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+                             size_t *foundLen) override;
+  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
+  void fillCommandAndReplyMap() override;
+  uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                        LocalDataPoolManager &poolManager) override;
+};
+
+#endif /* DUMMIES_MGMLIS3MDLDUMMY_H_ */

dummies/P60DockDummy.cpp

@@ -0,0 +1,46 @@
+#include "P60DockDummy.h"
+
+#include <mission/devices/devicedefinitions/GomspaceDefinitions.h>
+
+P60DockDummy::P60DockDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
+    : DeviceHandlerBase(objectId, comif, comCookie) {}
+
+P60DockDummy::~P60DockDummy() {}
+
+void P60DockDummy::doStartUp() {}
+
+void P60DockDummy::doShutDown() {}
+
+ReturnValue_t P60DockDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t P60DockDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t P60DockDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                    const uint8_t *commandData,
+                                                    size_t commandDataLen) {
+  return RETURN_OK;
+}
+
+ReturnValue_t P60DockDummy::scanForReply(const uint8_t *start, size_t len,
+                                         DeviceCommandId_t *foundId, size_t *foundLen) {
+  return RETURN_OK;
+}
+
+ReturnValue_t P60DockDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
+  return RETURN_OK;
+}
+
+void P60DockDummy::fillCommandAndReplyMap() {}
+
+uint32_t P60DockDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
+
+ReturnValue_t P60DockDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                                    LocalDataPoolManager &poolManager) {
+  localDataPoolMap.emplace(P60System::pool::P60DOCK_TEMPERATURE_1, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(P60System::pool::P60DOCK_TEMPERATURE_2, new PoolEntry<float>({0}));
+  return HasReturnvaluesIF::RETURN_OK;
+}

dummies/P60DockDummy.h

@@ -0,0 +1,33 @@
+#ifndef DUMMIES_P60DOCKDUMMY_H_
+#define DUMMIES_P60DOCKDUMMY_H_
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+
+class P60DockDummy : public DeviceHandlerBase {
+ public:
+  static const DeviceCommandId_t SIMPLE_COMMAND = 1;
+  static const DeviceCommandId_t PERIODIC_REPLY = 2;
+
+  static const uint8_t SIMPLE_COMMAND_DATA = 1;
+  static const uint8_t PERIODIC_REPLY_DATA = 2;
+
+  P60DockDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  virtual ~P60DockDummy();
+
+ protected:
+  void doStartUp() override;
+  void doShutDown() override;
+  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
+                                        size_t commandDataLen) override;
+  ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+                             size_t *foundLen) override;
+  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
+  void fillCommandAndReplyMap() override;
+  uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                        LocalDataPoolManager &poolManager) override;
+};
+
+#endif /* DUMMIES_P60DOCKDUMMY_H_ */

dummies/PduDummy.cpp

@@ -0,0 +1,42 @@
+#include "PduDummy.h"
+
+#include <mission/devices/devicedefinitions/GomspaceDefinitions.h>
+
+PduDummy::PduDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
+    : DeviceHandlerBase(objectId, comif, comCookie) {}
+
+PduDummy::~PduDummy() {}
+
+void PduDummy::doStartUp() {}
+
+void PduDummy::doShutDown() {}
+
+ReturnValue_t PduDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) { return NOTHING_TO_SEND; }
+
+ReturnValue_t PduDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t PduDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                const uint8_t *commandData, size_t commandDataLen) {
+  return RETURN_OK;
+}
+
+ReturnValue_t PduDummy::scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+                                     size_t *foundLen) {
+  return RETURN_OK;
+}
+
+ReturnValue_t PduDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
+  return RETURN_OK;
+}
+
+void PduDummy::fillCommandAndReplyMap() {}
+
+uint32_t PduDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
+
+ReturnValue_t PduDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                                LocalDataPoolManager &poolManager) {
+  localDataPoolMap.emplace(P60System::pool::PDU_TEMPERATURE, new PoolEntry<float>({0}));
+  return HasReturnvaluesIF::RETURN_OK;
+}

dummies/PduDummy.h

@@ -0,0 +1,33 @@
+#ifndef DUMMIES_PDUDUMMY_H_
+#define DUMMIES_PDUDUMMY_H_
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+
+class PduDummy : public DeviceHandlerBase {
+ public:
+  static const DeviceCommandId_t SIMPLE_COMMAND = 1;
+  static const DeviceCommandId_t PERIODIC_REPLY = 2;
+
+  static const uint8_t SIMPLE_COMMAND_DATA = 1;
+  static const uint8_t PERIODIC_REPLY_DATA = 2;
+
+  PduDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  virtual ~PduDummy();
+
+ protected:
+  void doStartUp() override;
+  void doShutDown() override;
+  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
+                                        size_t commandDataLen) override;
+  ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+                             size_t *foundLen) override;
+  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
+  void fillCommandAndReplyMap() override;
+  uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                        LocalDataPoolManager &poolManager) override;
+};
+
+#endif /* DUMMIES_PDUDUMMY_H_ */

dummies/PlPcduDummy.cpp

@@ -0,0 +1,45 @@
+#include "PlPcduDummy.h"
+
+#include <mission/devices/devicedefinitions/GomspaceDefinitions.h>
+
+PlPcduDummy::PlPcduDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
+    : DeviceHandlerBase(objectId, comif, comCookie) {}
+
+PlPcduDummy::~PlPcduDummy() {}
+
+void PlPcduDummy::doStartUp() {}
+
+void PlPcduDummy::doShutDown() {}
+
+ReturnValue_t PlPcduDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t PlPcduDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t PlPcduDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                   const uint8_t *commandData,
+                                                   size_t commandDataLen) {
+  return RETURN_OK;
+}
+
+ReturnValue_t PlPcduDummy::scanForReply(const uint8_t *start, size_t len,
+                                        DeviceCommandId_t *foundId, size_t *foundLen) {
+  return RETURN_OK;
+}
+
+ReturnValue_t PlPcduDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
+  return RETURN_OK;
+}
+
+void PlPcduDummy::fillCommandAndReplyMap() {}
+
+uint32_t PlPcduDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
+
+ReturnValue_t PlPcduDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                                   LocalDataPoolManager &poolManager) {
+  localDataPoolMap.emplace(plpcdu::PlPcduPoolIds::TEMP, new PoolEntry<float>({0.0}));
+  return HasReturnvaluesIF::RETURN_OK;
+}

dummies/PlPcduDummy.h

@@ -0,0 +1,34 @@
+#ifndef DUMMIES_PLPCDUDUMMY_H_
+#define DUMMIES_PLPCDUDUMMY_H_
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+#include <mission/devices/devicedefinitions/payloadPcduDefinitions.h>
+
+class PlPcduDummy : public DeviceHandlerBase {
+ public:
+  static const DeviceCommandId_t SIMPLE_COMMAND = 1;
+  static const DeviceCommandId_t PERIODIC_REPLY = 2;
+
+  static const uint8_t SIMPLE_COMMAND_DATA = 1;
+  static const uint8_t PERIODIC_REPLY_DATA = 2;
+
+  PlPcduDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  virtual ~PlPcduDummy();
+
+ protected:
+  void doStartUp() override;
+  void doShutDown() override;
+  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
+                                        size_t commandDataLen) override;
+  ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+                             size_t *foundLen) override;
+  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
+  void fillCommandAndReplyMap() override;
+  uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                        LocalDataPoolManager &poolManager) override;
+};
+
+#endif /* DUMMIES_PLPCDUDUMMY_H_ */

dummies/RwDummy.cpp

@@ -0,0 +1,75 @@
+#include "RwDummy.h"
+
+#include <mission/devices/devicedefinitions/RwDefinitions.h>
+
+RwDummy::RwDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
+    : DeviceHandlerBase(objectId, comif, comCookie) {}
+
+RwDummy::~RwDummy() {}
+
+void RwDummy::doStartUp() {}
+
+void RwDummy::doShutDown() {}
+
+ReturnValue_t RwDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) { return NOTHING_TO_SEND; }
+
+ReturnValue_t RwDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t RwDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                               const uint8_t *commandData, size_t commandDataLen) {
+  return RETURN_OK;
+}
+
+ReturnValue_t RwDummy::scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+                                    size_t *foundLen) {
+  return RETURN_OK;
+}
+
+ReturnValue_t RwDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
+  return RETURN_OK;
+}
+
+void RwDummy::fillCommandAndReplyMap() {}
+
+uint32_t RwDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
+
+ReturnValue_t RwDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                               LocalDataPoolManager &poolManager) {
+  localDataPoolMap.emplace(RwDefinitions::TEMPERATURE_C, new PoolEntry<int32_t>({0}));
+
+  localDataPoolMap.emplace(RwDefinitions::CURR_SPEED, new PoolEntry<int32_t>({0}));
+  localDataPoolMap.emplace(RwDefinitions::REFERENCE_SPEED, new PoolEntry<int32_t>({0}));
+  localDataPoolMap.emplace(RwDefinitions::STATE, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(RwDefinitions::CLC_MODE, new PoolEntry<uint8_t>({0}));
+
+  localDataPoolMap.emplace(RwDefinitions::LAST_RESET_STATUS, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(RwDefinitions::CURRRENT_RESET_STATUS, new PoolEntry<uint8_t>({0}));
+
+  localDataPoolMap.emplace(RwDefinitions::TM_LAST_RESET_STATUS, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(RwDefinitions::TM_MCU_TEMPERATURE, new PoolEntry<int32_t>({0}));
+  localDataPoolMap.emplace(RwDefinitions::PRESSURE_SENSOR_TEMPERATURE, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(RwDefinitions::PRESSURE, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(RwDefinitions::TM_RW_STATE, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(RwDefinitions::TM_CLC_MODE, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(RwDefinitions::TM_RW_CURR_SPEED, new PoolEntry<int32_t>({0}));
+  localDataPoolMap.emplace(RwDefinitions::TM_RW_REF_SPEED, new PoolEntry<int32_t>({0}));
+  localDataPoolMap.emplace(RwDefinitions::INVALID_CRC_PACKETS, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(RwDefinitions::INVALID_LEN_PACKETS, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(RwDefinitions::INVALID_CMD_PACKETS, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(RwDefinitions::EXECUTED_REPLIES, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(RwDefinitions::COMMAND_REPLIES, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(RwDefinitions::UART_BYTES_WRITTEN, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(RwDefinitions::UART_BYTES_READ, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(RwDefinitions::UART_PARITY_ERRORS, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(RwDefinitions::UART_NOISE_ERRORS, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(RwDefinitions::UART_FRAME_ERRORS, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(RwDefinitions::UART_REG_OVERRUN_ERRORS, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(RwDefinitions::UART_TOTAL_ERRORS, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(RwDefinitions::SPI_BYTES_WRITTEN, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(RwDefinitions::SPI_BYTES_READ, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(RwDefinitions::SPI_REG_OVERRUN_ERRORS, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(RwDefinitions::SPI_TOTAL_ERRORS, new PoolEntry<uint32_t>({0}));
+  return HasReturnvaluesIF::RETURN_OK;
+}

dummies/RwDummy.h

@@ -0,0 +1,33 @@
+#ifndef DUMMIES_RWDUMMY_H_
+#define DUMMIES_RWDUMMY_H_
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+
+class RwDummy : public DeviceHandlerBase {
+ public:
+  static const DeviceCommandId_t SIMPLE_COMMAND = 1;
+  static const DeviceCommandId_t PERIODIC_REPLY = 2;
+
+  static const uint8_t SIMPLE_COMMAND_DATA = 1;
+  static const uint8_t PERIODIC_REPLY_DATA = 2;
+
+  RwDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  virtual ~RwDummy();
+
+ protected:
+  void doStartUp() override;
+  void doShutDown() override;
+  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
+                                        size_t commandDataLen) override;
+  ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+                             size_t *foundLen) override;
+  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
+  void fillCommandAndReplyMap() override;
+  uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                        LocalDataPoolManager &poolManager) override;
+};
+
+#endif /* DUMMIES_RWDUMMY_H_ */

dummies/StarTrackerDummy.cpp

@@ -0,0 +1,45 @@
+#include "StarTrackerDummy.h"
+
+#include <linux/devices/devicedefinitions/StarTrackerDefinitions.h>
+
+StarTrackerDummy::StarTrackerDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
+    : DeviceHandlerBase(objectId, comif, comCookie) {}
+
+StarTrackerDummy::~StarTrackerDummy() {}
+
+void StarTrackerDummy::doStartUp() {}
+
+void StarTrackerDummy::doShutDown() {}
+
+ReturnValue_t StarTrackerDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t StarTrackerDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t StarTrackerDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                        const uint8_t *commandData,
+                                                        size_t commandDataLen) {
+  return RETURN_OK;
+}
+
+ReturnValue_t StarTrackerDummy::scanForReply(const uint8_t *start, size_t len,
+                                             DeviceCommandId_t *foundId, size_t *foundLen) {
+  return RETURN_OK;
+}
+
+ReturnValue_t StarTrackerDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
+  return RETURN_OK;
+}
+
+void StarTrackerDummy::fillCommandAndReplyMap() {}
+
+uint32_t StarTrackerDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
+
+ReturnValue_t StarTrackerDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                                        LocalDataPoolManager &poolManager) {
+  localDataPoolMap.emplace(startracker::MCU_TEMPERATURE, new PoolEntry<float>({0}));
+  return HasReturnvaluesIF::RETURN_OK;
+}

dummies/StarTrackerDummy.h

@@ -0,0 +1,33 @@
+#ifndef DUMMIES_STARTRACKERDUMMY_H_
+#define DUMMIES_STARTRACKERDUMMY_H_
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+
+class StarTrackerDummy : public DeviceHandlerBase {
+ public:
+  static const DeviceCommandId_t SIMPLE_COMMAND = 1;
+  static const DeviceCommandId_t PERIODIC_REPLY = 2;
+
+  static const uint8_t SIMPLE_COMMAND_DATA = 1;
+  static const uint8_t PERIODIC_REPLY_DATA = 2;
+
+  StarTrackerDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  virtual ~StarTrackerDummy();
+
+ protected:
+  void doStartUp() override;
+  void doShutDown() override;
+  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
+                                        size_t commandDataLen) override;
+  ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+                             size_t *foundLen) override;
+  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
+  void fillCommandAndReplyMap() override;
+  uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                        LocalDataPoolManager &poolManager) override;
+};
+
+#endif /* DUMMIES_STARTRACKERDUMMY_H_ */

dummies/SusDummy.cpp

@@ -0,0 +1,78 @@
+#include "SusDummy.h"
+
+#include <objects/systemObjectList.h>
+
+#include <cmath>
+#include <cstdlib>
+
+SusDummy::SusDummy()
+    : ExtendedControllerBase(objects::SUS_0_N_LOC_XFYFZM_PT_XF, objects::NO_OBJECT), susSet(this) {
+  ObjectManager::instance()->insert(objects::SUS_6_R_LOC_XFYBZM_PT_XF, this);
+  ObjectManager::instance()->insert(objects::SUS_1_N_LOC_XBYFZM_PT_XB, this);
+  ObjectManager::instance()->insert(objects::SUS_7_R_LOC_XBYBZM_PT_XB, this);
+  ObjectManager::instance()->insert(objects::SUS_2_N_LOC_XFYBZB_PT_YB, this);
+  ObjectManager::instance()->insert(objects::SUS_8_R_LOC_XBYBZB_PT_YB, this);
+  ObjectManager::instance()->insert(objects::SUS_3_N_LOC_XFYBZF_PT_YF, this);
+  ObjectManager::instance()->insert(objects::SUS_9_R_LOC_XBYBZB_PT_YF, this);
+  ObjectManager::instance()->insert(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, this);
+  ObjectManager::instance()->insert(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, this);
+  ObjectManager::instance()->insert(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, this);
+  ObjectManager::instance()->insert(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, this);
+}
+
+ReturnValue_t SusDummy::initialize() {
+  static bool done = false;
+  if (not done) {
+    done = true;
+    ReturnValue_t result = ExtendedControllerBase::initialize();
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+  }
+
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t SusDummy::handleCommandMessage(CommandMessage* message) { return RETURN_FAILED; }
+
+void SusDummy::performControlOperation() {
+  iteration++;
+  value = sin(iteration / 80. * M_PI + 10) * 10 - 10;
+
+  susSet.read();
+  susSet.temperatureCelcius = value;
+  if ((iteration % 100) < 20) {
+    susSet.setValidity(false, true);
+  } else {
+    susSet.setValidity(true, true);
+  }
+  susSet.commit();
+}
+
+ReturnValue_t SusDummy::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+                                                LocalDataPoolManager& poolManager) {
+  localDataPoolMap.emplace(SUS::SusPoolIds::TEMPERATURE_C, new PoolEntry<float>({0}, 1, true));
+  localDataPoolMap.emplace(SUS::SusPoolIds::CHANNEL_VEC, new PoolEntry<uint16_t>({0}));
+
+  return RETURN_OK;
+}
+
+LocalPoolDataSetBase* SusDummy::getDataSetHandle(sid_t sid) {
+  switch (sid.ownerSetId) {
+    case SUS::SUS_DATA_SET_ID:
+      return &susSet;
+    default:
+      return nullptr;
+  }
+}
+
+ReturnValue_t SusDummy::checkModeCommand(Mode_t mode, Submode_t submode,
+                                         uint32_t* msToReachTheMode) {
+  if (submode != SUBMODE_NONE) {
+    return INVALID_SUBMODE;
+  }
+  if ((mode != MODE_OFF) && (mode != MODE_ON) && (mode != MODE_NORMAL)) {
+    return INVALID_MODE;
+  }
+  return RETURN_OK;
+}

dummies/SusDummy.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <fsfw/controller/ExtendedControllerBase.h>
+#include <mission/devices/devicedefinitions/SusDefinitions.h>
+
+class SusDummy : public ExtendedControllerBase {
+ public:
+  SusDummy();
+
+  ReturnValue_t initialize() override;
+
+ protected:
+  virtual ReturnValue_t handleCommandMessage(CommandMessage* message) override;
+  virtual void performControlOperation() override;
+  virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+                                                LocalDataPoolManager& poolManager) override;
+  virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
+
+  // Mode abstract functions
+  virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+                                         uint32_t* msToReachTheMode) override;
+
+ private:
+  int iteration = 0;
+  float value = 0;
+  SUS::SusDataset susSet;
+};

dummies/SyrlinksDummy.cpp

@@ -0,0 +1,46 @@
+#include "SyrlinksDummy.h"
+
+#include <mission/devices/devicedefinitions/SyrlinksDefinitions.h>
+
+SyrlinksDummy::SyrlinksDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
+    : DeviceHandlerBase(objectId, comif, comCookie) {}
+
+SyrlinksDummy::~SyrlinksDummy() {}
+
+void SyrlinksDummy::doStartUp() {}
+
+void SyrlinksDummy::doShutDown() {}
+
+ReturnValue_t SyrlinksDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t SyrlinksDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t SyrlinksDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                     const uint8_t *commandData,
+                                                     size_t commandDataLen) {
+  return RETURN_OK;
+}
+
+ReturnValue_t SyrlinksDummy::scanForReply(const uint8_t *start, size_t len,
+                                          DeviceCommandId_t *foundId, size_t *foundLen) {
+  return RETURN_OK;
+}
+
+ReturnValue_t SyrlinksDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
+  return RETURN_OK;
+}
+
+void SyrlinksDummy::fillCommandAndReplyMap() {}
+
+uint32_t SyrlinksDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
+
+ReturnValue_t SyrlinksDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                                     LocalDataPoolManager &poolManager) {
+  localDataPoolMap.emplace(syrlinks::TEMP_BASEBAND_BOARD, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(syrlinks::TEMP_POWER_AMPLIFIER, new PoolEntry<float>({0}));
+  return HasReturnvaluesIF::RETURN_OK;
+}

dummies/SyrlinksDummy.h

@@ -0,0 +1,33 @@
+#ifndef DUMMIES_SYRLINKSDUMMY_H_
+#define DUMMIES_SYRLINKSDUMMY_H_
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+
+class SyrlinksDummy : public DeviceHandlerBase {
+ public:
+  static const DeviceCommandId_t SIMPLE_COMMAND = 1;
+  static const DeviceCommandId_t PERIODIC_REPLY = 2;
+
+  static const uint8_t SIMPLE_COMMAND_DATA = 1;
+  static const uint8_t PERIODIC_REPLY_DATA = 2;
+
+  SyrlinksDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  virtual ~SyrlinksDummy();
+
+ protected:
+  void doStartUp() override;
+  void doShutDown() override;
+  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
+                                        size_t commandDataLen) override;
+  ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+                             size_t *foundLen) override;
+  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
+  void fillCommandAndReplyMap() override;
+  uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                        LocalDataPoolManager &poolManager) override;
+};
+
+#endif /* DUMMIES_SYRLINKSDUMMY_H_ */

dummies/TemperatureSensorsDummy.cpp

@@ -0,0 +1,98 @@
+#include "TemperatureSensorsDummy.h"
+
+#include <objects/systemObjectList.h>
+
+#include <cmath>
+#include <cstdlib>
+
+TemperatureSensorsDummy::TemperatureSensorsDummy()
+    : ExtendedControllerBase(objects::RTD_0_IC3_PLOC_HEATSPREADER, objects::NO_OBJECT),
+      max31865Set(this, MAX31865::MAX31865_SET_ID) {
+  ObjectManager::instance()->insert(objects::RTD_1_IC4_PLOC_MISSIONBOARD, this);
+  ObjectManager::instance()->insert(objects::RTD_2_IC5_4K_CAMERA, this);
+  ObjectManager::instance()->insert(objects::RTD_3_IC6_DAC_HEATSPREADER, this);
+  ObjectManager::instance()->insert(objects::RTD_4_IC7_STARTRACKER, this);
+  ObjectManager::instance()->insert(objects::RTD_5_IC8_RW1_MX_MY, this);
+  ObjectManager::instance()->insert(objects::RTD_6_IC9_DRO, this);
+  ObjectManager::instance()->insert(objects::RTD_7_IC10_SCEX, this);
+  ObjectManager::instance()->insert(objects::RTD_8_IC11_X8, this);
+  ObjectManager::instance()->insert(objects::RTD_9_IC12_HPA, this);
+  ObjectManager::instance()->insert(objects::RTD_10_IC13_PL_TX, this);
+  ObjectManager::instance()->insert(objects::RTD_11_IC14_MPA, this);
+  ObjectManager::instance()->insert(objects::RTD_12_IC15_ACU, this);
+  ObjectManager::instance()->insert(objects::RTD_13_IC16_PLPCDU_HEATSPREADER, this);
+  ObjectManager::instance()->insert(objects::RTD_14_IC17_TCS_BOARD, this);
+  ObjectManager::instance()->insert(objects::RTD_15_IC18_IMTQ, this);
+  ObjectManager::instance()->insert(objects::TMP1075_HANDLER_1, this);
+  ObjectManager::instance()->insert(objects::TMP1075_HANDLER_2, this);
+}
+
+ReturnValue_t TemperatureSensorsDummy::initialize() {
+  static bool done = false;
+  if (not done) {
+    done = true;
+    ReturnValue_t result = ExtendedControllerBase::initialize();
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+  }
+
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TemperatureSensorsDummy::handleCommandMessage(CommandMessage* message) {
+  return RETURN_FAILED;
+}
+
+void TemperatureSensorsDummy::performControlOperation() {
+  iteration++;
+  value = sin(iteration / 80. * M_PI) * 10;
+
+  ReturnValue_t result = max31865Set.read();
+  if (result != RETURN_OK) {
+    sif::warning << "Failed to read temperature from MAX31865 dataset" << std::endl;
+  }
+  max31865Set.rtdValue = value - 5;
+  max31865Set.temperatureCelcius = value;
+  if ((iteration % 100) < 20) {
+    max31865Set.setValidity(false, true);
+  } else {
+    max31865Set.setValidity(true, true);
+  }
+  max31865Set.commit();
+}
+
+ReturnValue_t TemperatureSensorsDummy::initializeLocalDataPool(
+    localpool::DataPool& localDataPoolMap, LocalDataPoolManager& poolManager) {
+  localDataPoolMap.emplace(static_cast<lp_id_t>(MAX31865::PoolIds::RTD_VALUE),
+                           new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(static_cast<lp_id_t>(MAX31865::PoolIds::TEMPERATURE_C),
+                           new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(static_cast<lp_id_t>(MAX31865::PoolIds::LAST_FAULT_BYTE),
+                           new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(static_cast<lp_id_t>(MAX31865::PoolIds::FAULT_BYTE),
+                           new PoolEntry<uint8_t>({0}));
+
+  return RETURN_OK;
+}
+
+LocalPoolDataSetBase* TemperatureSensorsDummy::getDataSetHandle(sid_t sid) {
+  sif::debug << "getHandle" << std::endl;
+  switch (sid.ownerSetId) {
+    case MAX31865::MAX31865_SET_ID:
+      return &max31865Set;
+    default:
+      return nullptr;
+  }
+}
+
+ReturnValue_t TemperatureSensorsDummy::checkModeCommand(Mode_t mode, Submode_t submode,
+                                                        uint32_t* msToReachTheMode) {
+  if (submode != SUBMODE_NONE) {
+    return INVALID_SUBMODE;
+  }
+  if ((mode != MODE_OFF) && (mode != MODE_ON) && (mode != MODE_NORMAL)) {
+    return INVALID_MODE;
+  }
+  return RETURN_OK;
+}

dummies/TemperatureSensorsDummy.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <fsfw/controller/ExtendedControllerBase.h>
+#include <mission/devices/devicedefinitions/Max31865Definitions.h>
+
+class TemperatureSensorsDummy : public ExtendedControllerBase {
+ public:
+  TemperatureSensorsDummy();
+
+  ReturnValue_t initialize() override;
+
+ protected:
+  virtual ReturnValue_t handleCommandMessage(CommandMessage* message) override;
+  virtual void performControlOperation() override;
+  virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+                                                LocalDataPoolManager& poolManager) override;
+  virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
+
+  // Mode abstract functions
+  virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+                                         uint32_t* msToReachTheMode) override;
+
+ private:
+  int iteration = 0;
+  float value = 0;
+  MAX31865::Max31865Set max31865Set;
+
+  void noise();
+};

fsfw

@@ -1 +1 @@
-Subproject commit 95a64e1da3bb6d334c58c9ba78747bcdaccd5a8b
+Subproject commit 7f3e5e42bb209aa6d2f71ce644340fd27e9cc29b

generators/bsp_q7s_returnvalues.csv

@@ -1,11 +1,28 @@
 0x0;OK;System-wide code for ok.;RETURN_OK;HasReturnvaluesIF.h;HasReturnvaluesIF
 0x1;Failed;Unspecified system-wide code for failed.;RETURN_FAILED;HasReturnvaluesIF.h;HasReturnvaluesIF
-0x64a0; CCSDS_CommandNotImplemented;Received action message with unknown action id;0xA0;mission/tmtc/CCSDSHandler.h;CCSDS_HANDLER
-0x6aa0; SADPL_CommandNotSupported;;0xA0;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER
-0x6aa1; SADPL_DeploymentAlreadyExecuting;;0xA1;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER
-0x6aa2; SADPL_MainSwitchTimeoutFailure;;0xA2;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER
-0x6aa3; SADPL_SwitchingDeplSa1Failed;;0xA3;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER
-0x6aa4; SADPL_SwitchingDeplSa2Failed;;0xA4;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER
+0x67a0; NVMB_KeyNotExists;Specified key does not exist in json file;0xA0;mission/memory/NVMParameterBase.h;NVM_PARAM_BASE
+0x55a0; IMTQ_InvalidCommandCode;;0xA0;mission/devices/IMTQHandler.h;IMTQ_HANDLER
+0x55a1; IMTQ_ParameterMissing;;0xA1;mission/devices/IMTQHandler.h;IMTQ_HANDLER
+0x55a2; IMTQ_ParameterInvalid;;0xA2;mission/devices/IMTQHandler.h;IMTQ_HANDLER
+0x55a3; IMTQ_CcUnavailable;;0xA3;mission/devices/IMTQHandler.h;IMTQ_HANDLER
+0x55a4; IMTQ_InternalProcessingError;;0xA4;mission/devices/IMTQHandler.h;IMTQ_HANDLER
+0x55a5; IMTQ_RejectedWithoutReason;;0xA5;mission/devices/IMTQHandler.h;IMTQ_HANDLER
+0x55a6; IMTQ_CmdErrUnknown;;0xA6;mission/devices/IMTQHandler.h;IMTQ_HANDLER
+0x55a7; IMTQ_UnexpectedSelfTestReply;The status reply to a self test command was received but no self test command has been sent. This should normally never happen.;0xA7;mission/devices/IMTQHandler.h;IMTQ_HANDLER
+0x54a0; SYRLINKS_CrcFailure;;0xA0;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER
+0x54a1; SYRLINKS_UartFraminOrParityErrorAck;;0xA1;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER
+0x54a2; SYRLINKS_BadCharacterAck;;0xA2;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER
+0x54a3; SYRLINKS_BadParameterValueAck;;0xA3;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER
+0x54a4; SYRLINKS_BadEndOfFrameAck;;0xA4;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER
+0x54a5; SYRLINKS_UnknownCommandIdAck;;0xA5;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER
+0x54a6; SYRLINKS_BadCrcAck;;0xA6;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER
+0x54a7; SYRLINKS_ReplyWrongSize;;0xA7;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER
+0x54a8; SYRLINKS_MissingStartFrameCharacter;;0xA8;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER
+0x53a1; HEATER_CommandNotSupported;;0xA1;mission/devices/HeaterHandler.h;HEATER_HANDLER
+0x53a2; HEATER_InitFailed;;0xA2;mission/devices/HeaterHandler.h;HEATER_HANDLER
+0x53a3; HEATER_InvalidSwitchNr;;0xA3;mission/devices/HeaterHandler.h;HEATER_HANDLER
+0x53a4; HEATER_MainSwitchSetTimeout;;0xA4;mission/devices/HeaterHandler.h;HEATER_HANDLER
+0x53a5; HEATER_CommandAlreadyWaiting;;0xA5;mission/devices/HeaterHandler.h;HEATER_HANDLER
 0x5ca0; SUSS_ErrorUnlockMutex;;0xA0;mission/devices/SusHandler.h;SUS_HANDLER
 0x5ca1; SUSS_ErrorLockMutex;;0xA1;mission/devices/SusHandler.h;SUS_HANDLER
 0x56b0; RWHA_SpiWriteFailure;;0xB0;mission/devices/RwHandler.h;RW_HANDLER
@@ -20,41 +37,21 @@
 0x56a2; RWHA_SetSpeedCommandInvalidLength;Received set speed command has invalid length. Should be 6.;0xA2;mission/devices/RwHandler.h;RW_HANDLER
 0x56a3; RWHA_ExecutionFailed;Command execution failed;0xA3;mission/devices/RwHandler.h;RW_HANDLER
 0x56a4; RWHA_CrcError;Reaction wheel reply has invalid crc;0xA4;mission/devices/RwHandler.h;RW_HANDLER
-0x55a0; IMTQ_InvalidCommandCode;;0xA0;mission/devices/IMTQHandler.h;IMTQ_HANDLER
-0x55a1; IMTQ_ParameterMissing;;0xA1;mission/devices/IMTQHandler.h;IMTQ_HANDLER
-0x55a2; IMTQ_ParameterInvalid;;0xA2;mission/devices/IMTQHandler.h;IMTQ_HANDLER
-0x55a3; IMTQ_CcUnavailable;;0xA3;mission/devices/IMTQHandler.h;IMTQ_HANDLER
-0x55a4; IMTQ_InternalProcessingError;;0xA4;mission/devices/IMTQHandler.h;IMTQ_HANDLER
-0x55a5; IMTQ_RejectedWithoutReason;;0xA5;mission/devices/IMTQHandler.h;IMTQ_HANDLER
-0x55a6; IMTQ_CmdErrUnknown;;0xA6;mission/devices/IMTQHandler.h;IMTQ_HANDLER
-0x55a7; IMTQ_UnexpectedSelfTestReply;The status reply to a self test command was received but no self test command has been sent. This should normally never happen.;0xA7;mission/devices/IMTQHandler.h;IMTQ_HANDLER
-0x53a1; HEATER_CommandNotSupported;;0xA1;mission/devices/HeaterHandler.h;HEATER_HANDLER
-0x53a2; HEATER_InitFailed;;0xA2;mission/devices/HeaterHandler.h;HEATER_HANDLER
-0x53a3; HEATER_InvalidSwitchNr;;0xA3;mission/devices/HeaterHandler.h;HEATER_HANDLER
-0x53a4; HEATER_MainSwitchSetTimeout;;0xA4;mission/devices/HeaterHandler.h;HEATER_HANDLER
-0x53a5; HEATER_CommandAlreadyWaiting;;0xA5;mission/devices/HeaterHandler.h;HEATER_HANDLER
 0x6100; GOMS_PacketTooLong;;0;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER
 0x6101; GOMS_InvalidTableId;;1;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER
 0x6102; GOMS_InvalidAddress;;2;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER
 0x6103; GOMS_InvalidParamSize;;3;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER
 0x6104; GOMS_InvalidPayloadSize;;4;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER
 0x6105; GOMS_UnknownReplyId;;5;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER
-0x54a0; SYRLINKS_CrcFailure;;0xA0;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER
-0x54a1; SYRLINKS_UartFraminOrParityErrorAck;;0xA1;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER
-0x54a2; SYRLINKS_BadCharacterAck;;0xA2;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER
-0x54a3; SYRLINKS_BadParameterValueAck;;0xA3;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER
-0x54a4; SYRLINKS_BadEndOfFrameAck;;0xA4;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER
-0x54a5; SYRLINKS_UnknownCommandIdAck;;0xA5;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER
-0x54a6; SYRLINKS_BadCrcAck;;0xA6;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER
-0x54a7; SYRLINKS_ReplyWrongSize;;0xA7;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER
-0x54a8; SYRLINKS_MissingStartFrameCharacter;;0xA8;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER
-0x67a0; NVMB_KeyNotExists;Specified key does not exist in json file;0xA0;mission/memory/NVMParameterBase.h;NVM_PARAM_BASE
-0x4400; HSPI_OpeningFileFailed;;0;fsfw/hal/src/fsfw_hal/linux/spi/SpiComIF.h;HAL_SPI
-0x4401; HSPI_FullDuplexTransferFailed;;1;fsfw/hal/src/fsfw_hal/linux/spi/SpiComIF.h;HAL_SPI
-0x4402; HSPI_HalfDuplexTransferFailed;;2;fsfw/hal/src/fsfw_hal/linux/spi/SpiComIF.h;HAL_SPI
-0x4501; HURT_UartReadFailure;;1;fsfw/hal/src/fsfw_hal/linux/uart/UartComIF.h;HAL_UART
-0x4502; HURT_UartReadSizeMissmatch;;2;fsfw/hal/src/fsfw_hal/linux/uart/UartComIF.h;HAL_UART
-0x4503; HURT_UartRxBufferTooSmall;;3;fsfw/hal/src/fsfw_hal/linux/uart/UartComIF.h;HAL_UART
+0x6aa0; SADPL_CommandNotSupported;;0xA0;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER
+0x6aa1; SADPL_DeploymentAlreadyExecuting;;0xA1;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER
+0x6aa2; SADPL_MainSwitchTimeoutFailure;;0xA2;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER
+0x6aa3; SADPL_SwitchingDeplSa1Failed;;0xA3;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER
+0x6aa4; SADPL_SwitchingDeplSa2Failed;;0xA4;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER
+0x64a0; CCSDS_CommandNotImplemented;Received action message with unknown action id;0xA0;mission/tmtc/CCSDSHandler.h;CCSDS_HANDLER
+0x4400; HSPI_HalTimeoutRetval;;0;fsfw/hal/src/fsfw_hal/stm32h7/spi/spiDefinitions.h;HAL_SPI
+0x4401; HSPI_HalBusyRetval;;1;fsfw/hal/src/fsfw_hal/stm32h7/spi/spiDefinitions.h;HAL_SPI
+0x4402; HSPI_HalErrorRetval;;2;fsfw/hal/src/fsfw_hal/stm32h7/spi/spiDefinitions.h;HAL_SPI
 0x4701; HGIO_UnknownGpioId;;1;fsfw/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h;HAL_GPIO
 0x4702; HGIO_DriveGpioFailure;;2;fsfw/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h;HAL_GPIO
 0x4703; HGIO_GpioTypeFailure;;3;fsfw/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h;HAL_GPIO
@@ -62,20 +59,21 @@
 0x4705; HGIO_GpioDuplicateDetected;;5;fsfw/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h;HAL_GPIO
 0x4706; HGIO_GpioInitFailed;;6;fsfw/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h;HAL_GPIO
 0x4707; HGIO_GpioGetValueFailed;;7;fsfw/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h;HAL_GPIO
+0x4501; HURT_UartReadFailure;;1;fsfw/hal/src/fsfw_hal/linux/uart/UartComIF.h;HAL_UART
+0x4502; HURT_UartReadSizeMissmatch;;2;fsfw/hal/src/fsfw_hal/linux/uart/UartComIF.h;HAL_UART
+0x4503; HURT_UartRxBufferTooSmall;;3;fsfw/hal/src/fsfw_hal/linux/uart/UartComIF.h;HAL_UART
 0x4300; UXOS_ExecutionFinished;Execution of the current command has finished;0;fsfw/hal/src/fsfw_hal/linux/CommandExecutor.h;LINUX_OSAL
 0x4301; UXOS_CommandPending;Command is pending. This will also be returned if the user tries to load another command but a command is still pending;1;fsfw/hal/src/fsfw_hal/linux/CommandExecutor.h;LINUX_OSAL
 0x4302; UXOS_BytesRead;Some bytes have been read from the executing process;2;fsfw/hal/src/fsfw_hal/linux/CommandExecutor.h;LINUX_OSAL
 0x4303; UXOS_CommandError;Command execution failed;3;fsfw/hal/src/fsfw_hal/linux/CommandExecutor.h;LINUX_OSAL
 0x4304; UXOS_NoCommandLoadedOrPending;;4;fsfw/hal/src/fsfw_hal/linux/CommandExecutor.h;LINUX_OSAL
 0x4306; UXOS_PcloseCallError;;6;fsfw/hal/src/fsfw_hal/linux/CommandExecutor.h;LINUX_OSAL
-0x3b00; LPIF_PoolEntryNotFound;;0x00;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h;LOCAL_POOL_OWNER_IF
-0x3b01; LPIF_PoolEntryTypeConflict;;0x01;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h;LOCAL_POOL_OWNER_IF
-0x3d00; HKM_QueueOrDestinationInvalid;;0;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER
-0x3d01; HKM_WrongHkPacketType;;1;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER
-0x3d02; HKM_ReportingStatusUnchanged;;2;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER
-0x3d03; HKM_PeriodicHelperInvalid;;3;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER
-0x3d04; HKM_PoolobjectNotFound;;4;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER
-0x3d05; HKM_DatasetNotFound;;5;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER
+0x3201; HF_IsBusy;;1;fsfw/src/fsfw/action/HasActionsIF.h;HAS_ACTIONS_IF
+0x3202; HF_InvalidParameters;;2;fsfw/src/fsfw/action/HasActionsIF.h;HAS_ACTIONS_IF
+0x3203; HF_ExecutionFinished;;3;fsfw/src/fsfw/action/HasActionsIF.h;HAS_ACTIONS_IF
+0x3204; HF_InvalidActionId;;4;fsfw/src/fsfw/action/HasActionsIF.h;HAS_ACTIONS_IF
+0x3101; CF_ObjectHasNoFunctions;;1;fsfw/src/fsfw/action/CommandsActionsIF.h;COMMANDS_ACTIONS_IF
+0x3102; CF_AlreadyCommanding;;2;fsfw/src/fsfw/action/CommandsActionsIF.h;COMMANDS_ACTIONS_IF
 0x3501; CFDP_InvalidTlvType;;1;fsfw/src/fsfw/cfdp/definitions.h;CFDP
 0x3502; CFDP_InvalidDirectiveFields;;2;fsfw/src/fsfw/cfdp/definitions.h;CFDP
 0x3503; CFDP_InvalidPduDatafieldLen;;3;fsfw/src/fsfw/cfdp/definitions.h;CFDP
@@ -84,33 +82,115 @@
 0x3506; CFDP_FinishedCantParseFsResponses;;6;fsfw/src/fsfw/cfdp/definitions.h;CFDP
 0x3508; CFDP_FilestoreRequiresSecondFile;;8;fsfw/src/fsfw/cfdp/definitions.h;CFDP
 0x3509; CFDP_FilestoreResponseCantParseFsMessage;;9;fsfw/src/fsfw/cfdp/definitions.h;CFDP
-0x3101; CF_ObjectHasNoFunctions;;1;fsfw/src/fsfw/action/CommandsActionsIF.h;COMMANDS_ACTIONS_IF
-0x3102; CF_AlreadyCommanding;;2;fsfw/src/fsfw/action/CommandsActionsIF.h;COMMANDS_ACTIONS_IF
-0x3201; HF_IsBusy;;1;fsfw/src/fsfw/action/HasActionsIF.h;HAS_ACTIONS_IF
-0x3202; HF_InvalidParameters;;2;fsfw/src/fsfw/action/HasActionsIF.h;HAS_ACTIONS_IF
-0x3203; HF_ExecutionFinished;;3;fsfw/src/fsfw/action/HasActionsIF.h;HAS_ACTIONS_IF
-0x3204; HF_InvalidActionId;;4;fsfw/src/fsfw/action/HasActionsIF.h;HAS_ACTIONS_IF
-0x2d01; HPA_InvalidIdentifierId;;0x01;fsfw/src/fsfw/parameters/HasParametersIF.h;HAS_PARAMETERS_IF
-0x2d02; HPA_InvalidDomainId;;0x02;fsfw/src/fsfw/parameters/HasParametersIF.h;HAS_PARAMETERS_IF
-0x2d03; HPA_InvalidValue;;0x03;fsfw/src/fsfw/parameters/HasParametersIF.h;HAS_PARAMETERS_IF
-0x2d05; HPA_ReadOnly;;0x05;fsfw/src/fsfw/parameters/HasParametersIF.h;HAS_PARAMETERS_IF
-0x2c01; PAW_UnknownDatatype;;0x01;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
-0x2c02; PAW_DatatypeMissmatch;;0x02;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
-0x2c03; PAW_Readonly;;0x03;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
-0x2c04; PAW_TooBig;;0x04;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
-0x2c05; PAW_SourceNotSet;;0x05;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
-0x2c06; PAW_OutOfBounds;;0x06;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
-0x2c07; PAW_NotSet;;0x07;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
-0x2c08; PAW_ColumnOrRowsZero;;0x08;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
-0x1701; HHI_ObjectNotHealthy;;1;fsfw/src/fsfw/health/HasHealthIF.h;HAS_HEALTH_IF
-0x1702; HHI_InvalidHealthState;;2;fsfw/src/fsfw/health/HasHealthIF.h;HAS_HEALTH_IF
-0x1703; HHI_IsExternallyControlled;;3;fsfw/src/fsfw/health/HasHealthIF.h;HAS_HEALTH_IF
+0x1c01; TCD_PacketLost;;1;fsfw/src/fsfw/tcdistribution/TcDistributor.h;PACKET_DISTRIBUTION
+0x1c02; TCD_DestinationNotFound;;2;fsfw/src/fsfw/tcdistribution/TcDistributor.h;PACKET_DISTRIBUTION
+0x1c03; TCD_ServiceIdAlreadyExists;;3;fsfw/src/fsfw/tcdistribution/TcDistributor.h;PACKET_DISTRIBUTION
+0x1b00; TCC_IllegalApid;;0;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK
+0x1b01; TCC_IncompletePacket;;1;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK
+0x1b02; TCC_IncorrectChecksum;;2;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK
+0x1b03; TCC_IllegalPacketType;;3;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK
+0x1b04; TCC_IllegalPacketSubtype;;4;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK
+0x1b05; TCC_IncorrectPrimaryHeader;;5;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK
+0x1b06; TCC_IncorrectSecondaryHeader;;6;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK
+0x501; PS_SwitchOn;;1;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF
+0x500; PS_SwitchOff;;0;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF
+0x502; PS_SwitchTimeout;;2;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF
+0x503; PS_FuseOn;;3;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF
+0x504; PS_FuseOff;;4;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF
+0x2f01; POS_InPowerTransition;;1;fsfw/src/fsfw/power/PowerSwitcher.h;POWER_SWITCHER
+0x2f02; POS_SwitchStateMismatch;;2;fsfw/src/fsfw/power/PowerSwitcher.h;POWER_SWITCHER
+0x13e0; MH_UnknownCmd;;0xE0;fsfw/src/fsfw/memory/MemoryHelper.h;MEMORY_HELPER
+0x13e1; MH_InvalidAddress;;0xE1;fsfw/src/fsfw/memory/MemoryHelper.h;MEMORY_HELPER
+0x13e2; MH_InvalidSize;;0xE2;fsfw/src/fsfw/memory/MemoryHelper.h;MEMORY_HELPER
+0x13e3; MH_StateMismatch;;0xE3;fsfw/src/fsfw/memory/MemoryHelper.h;MEMORY_HELPER
+0x601; PP_DoItMyself;;1;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
+0x602; PP_PointsToVariable;;2;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
+0x603; PP_PointsToMemory;;3;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
+0x604; PP_ActivityCompleted;;4;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
+0x605; PP_PointsToVectorUint8;;5;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
+0x606; PP_PointsToVectorUint16;;6;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
+0x607; PP_PointsToVectorUint32;;7;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
+0x608; PP_PointsToVectorFloat;;8;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
+0x6a0; PP_DumpNotSupported;;0xA0;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
+0x6e0; PP_InvalidSize;;0xE0;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
+0x6e1; PP_InvalidAddress;;0xE1;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
+0x6e2; PP_InvalidContent;;0xE2;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
+0x6e3; PP_UnalignedAccess;;0xE3;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
+0x6e4; PP_WriteProtected;;0xE4;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
+0x4200; FILS_GenericFileError;;0;fsfw/src/fsfw/memory/HasFileSystemIF.h;FILE_SYSTEM
+0x4201; FILS_IsBusy;;1;fsfw/src/fsfw/memory/HasFileSystemIF.h;FILE_SYSTEM
+0x4202; FILS_InvalidParameters;;2;fsfw/src/fsfw/memory/HasFileSystemIF.h;FILE_SYSTEM
+0x4205; FILS_FileDoesNotExist;;5;fsfw/src/fsfw/memory/HasFileSystemIF.h;FILE_SYSTEM
+0x4206; FILS_FileAlreadyExists;;6;fsfw/src/fsfw/memory/HasFileSystemIF.h;FILE_SYSTEM
+0x4207; FILS_FileLocked;;7;fsfw/src/fsfw/memory/HasFileSystemIF.h;FILE_SYSTEM
+0x420a; FILS_DirectoryDoesNotExist;;10;fsfw/src/fsfw/memory/HasFileSystemIF.h;FILE_SYSTEM
+0x420b; FILS_DirectoryAlreadyExists;;11;fsfw/src/fsfw/memory/HasFileSystemIF.h;FILE_SYSTEM
+0x420c; FILS_DirectoryNotEmpty;;12;fsfw/src/fsfw/memory/HasFileSystemIF.h;FILE_SYSTEM
+0x420f; FILS_SequencePacketMissingWrite;;15;fsfw/src/fsfw/memory/HasFileSystemIF.h;FILE_SYSTEM
+0x4210; FILS_SequencePacketMissingRead;;16;fsfw/src/fsfw/memory/HasFileSystemIF.h;FILE_SYSTEM
+0x1401; SE_BufferTooShort;;1;fsfw/src/fsfw/serialize/SerializeIF.h;SERIALIZE_IF
+0x1402; SE_StreamTooShort;;2;fsfw/src/fsfw/serialize/SerializeIF.h;SERIALIZE_IF
+0x1403; SE_TooManyElements;;3;fsfw/src/fsfw/serialize/SerializeIF.h;SERIALIZE_IF
+0x2101; TMF_Busy;;1;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
+0x2102; TMF_LastPacketFound;;2;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
+0x2103; TMF_StopFetch;;3;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
+0x2104; TMF_Timeout;;4;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
+0x2105; TMF_TmChannelFull;;5;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
+0x2106; TMF_NotStored;;6;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
+0x2107; TMF_AllDeleted;;7;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
+0x2108; TMF_InvalidData;;8;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
+0x2109; TMF_NotReady;;9;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
+0x2001; TMB_Busy;;1;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0x2002; TMB_Full;;2;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0x2003; TMB_Empty;;3;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0x2004; TMB_NullRequested;;4;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0x2005; TMB_TooLarge;;5;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0x2006; TMB_NotReady;;6;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0x2007; TMB_DumpError;;7;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0x2008; TMB_CrcError;;8;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0x2009; TMB_Timeout;;9;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0x200a; TMB_IdlePacketFound;;10;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0x200b; TMB_TelecommandFound;;11;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0x200c; TMB_NoPusATm;;12;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0x200d; TMB_TooSmall;;13;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0x200e; TMB_BlockNotFound;;14;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0x200f; TMB_InvalidRequest;;15;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
 0x2701; SM_DataTooLarge;;1;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF
 0x2702; SM_DataStorageFull;;2;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF
 0x2703; SM_IllegalStorageId;;3;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF
 0x2704; SM_DataDoesNotExist;;4;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF
 0x2705; SM_IllegalAddress;;5;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF
 0x2706; SM_PoolTooLarge;;6;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF
+0x3a00; SPH_ConnBroken;;0;fsfw/src/fsfw/osal/common/TcpTmTcServer.h;SEMAPHORE_IF
+0x2901; IEC_NoConfigurationTable;;0x01;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
+0x2902; IEC_NoCpuTable;;0x02;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
+0x2903; IEC_InvalidWorkspaceAddress;;0x03;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
+0x2904; IEC_TooLittleWorkspace;;0x04;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
+0x2905; IEC_WorkspaceAllocation;;0x05;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
+0x2906; IEC_InterruptStackTooSmall;;0x06;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
+0x2907; IEC_ThreadExitted;;0x07;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
+0x2908; IEC_InconsistentMpInformation;;0x08;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
+0x2909; IEC_InvalidNode;;0x09;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
+0x290a; IEC_NoMpci;;0x0a;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
+0x290b; IEC_BadPacket;;0x0b;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
+0x290c; IEC_OutOfPackets;;0x0c;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
+0x290d; IEC_OutOfGlobalObjects;;0x0d;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
+0x290e; IEC_OutOfProxies;;0x0e;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
+0x290f; IEC_InvalidGlobalId;;0x0f;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
+0x2910; IEC_BadStackHook;;0x10;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
+0x2911; IEC_BadAttributes;;0x11;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
+0x2912; IEC_ImplementationKeyCreateInconsistency;;0x12;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
+0x2913; IEC_ImplementationBlockingOperationCancel;;0x13;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
+0x2914; IEC_MutexObtainFromBadState;;0x14;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
+0x2915; IEC_UnlimitedAndMaximumIs0;;0x15;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
+0x1101; AL_Full;;0x01;fsfw/src/fsfw/container/ArrayList.h;ARRAY_LIST
+0x1501; FM_KeyAlreadyExists;;0x01;fsfw/src/fsfw/container/FixedMap.h;FIXED_MAP
+0x1502; FM_MapFull;;0x02;fsfw/src/fsfw/container/FixedMap.h;FIXED_MAP
+0x1503; FM_KeyDoesNotExist;;0x03;fsfw/src/fsfw/container/FixedMap.h;FIXED_MAP
+0x1801; FF_Full;;1;fsfw/src/fsfw/container/FIFOBase.h;FIFO_CLASS
+0x1802; FF_Empty;;2;fsfw/src/fsfw/container/FIFOBase.h;FIFO_CLASS
+0x1601; FMM_MapFull;;0x01;fsfw/src/fsfw/container/FixedOrderedMultimap.h;FIXED_MULTIMAP
+0x1602; FMM_KeyDoesNotExist;;0x02;fsfw/src/fsfw/container/FixedOrderedMultimap.h;FIXED_MULTIMAP
 0x2301; MT_TooDetailedRequest;;1;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h;MATCH_TREE_CLASS
 0x2302; MT_TooGeneralRequest;;2;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h;MATCH_TREE_CLASS
 0x2303; MT_NoMatch;;3;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h;MATCH_TREE_CLASS
@@ -124,21 +204,139 @@
 0x4101; PUS11_InvalidTypeTimeWindow;;1;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h;PUS_SERVICE_11
 0x4102; PUS11_TimeshiftingNotPossible;;2;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h;PUS_SERVICE_11
 0x4103; PUS11_InvalidRelativeTime;;3;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h;PUS_SERVICE_11
-0x1c01; TCD_PacketLost;;1;fsfw/src/fsfw/tcdistribution/TcDistributor.h;PACKET_DISTRIBUTION
-0x1c02; TCD_DestinationNotFound;;2;fsfw/src/fsfw/tcdistribution/TcDistributor.h;PACKET_DISTRIBUTION
-0x1c03; TCD_ServiceIdAlreadyExists;;3;fsfw/src/fsfw/tcdistribution/TcDistributor.h;PACKET_DISTRIBUTION
-0x1b00; TCC_IllegalApid;;0;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK
-0x1b01; TCC_IncompletePacket;;1;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK
-0x1b02; TCC_IncorrectChecksum;;2;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK
-0x1b03; TCC_IllegalPacketType;;3;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK
-0x1b04; TCC_IllegalPacketSubtype;;4;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK
-0x1b05; TCC_IncorrectPrimaryHeader;;5;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK
-0x1b06; TCC_IncorrectSecondaryHeader;;6;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK
+0x201; OM_InsertionFailed;;1;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h;OBJECT_MANAGER_IF
+0x202; OM_NotFound;;2;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h;OBJECT_MANAGER_IF
+0x203; OM_ChildInitFailed;;3;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h;OBJECT_MANAGER_IF
+0x204; OM_InternalErrReporterUninit;;4;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h;OBJECT_MANAGER_IF
+0x2b01; CCS_BcIsSetVrCommand;;0x01;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2b02; CCS_BcIsUnlockCommand;;0x02;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2bb0; CCS_BcIllegalCommand;;0xB0;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2bb1; CCS_BoardReadingNotFinished;;0xB1;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2bf0; CCS_NsPositiveW;;0xF0;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2bf1; CCS_NsNegativeW;;0xF1;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2bf2; CCS_NsLockout;;0xF2;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2bf3; CCS_FarmInLockout;;0xF3;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2bf4; CCS_FarmInWait;;0xF4;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2be0; CCS_WrongSymbol;;0xE0;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2be1; CCS_DoubleStart;;0xE1;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2be2; CCS_StartSymbolMissed;;0xE2;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2be3; CCS_EndWithoutStart;;0xE3;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2be4; CCS_TooLarge;;0xE4;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2be5; CCS_TooShort;;0xE5;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2be6; CCS_WrongTfVersion;;0xE6;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2be7; CCS_WrongSpacecraftId;;0xE7;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2be8; CCS_NoValidFrameType;;0xE8;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2be9; CCS_CrcFailed;;0xE9;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2bea; CCS_VcNotFound;;0xEA;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2beb; CCS_ForwardingFailed;;0xEB;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2bec; CCS_ContentTooLarge;;0xEC;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2bed; CCS_ResidualData;;0xED;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2bee; CCS_DataCorrupted;;0xEE;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2bef; CCS_IllegalSegmentationFlag;;0xEF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2bd0; CCS_IllegalFlagCombination;;0xD0;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2bd1; CCS_ShorterThanHeader;;0xD1;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2bd2; CCS_TooShortBlockedPacket;;0xD2;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2bd3; CCS_TooShortMapExtraction;;0xD3;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x3ca0; PVA_InvalidReadWriteMode;;0xA0;fsfw/src/fsfw/datapool/PoolVariableIF.h;POOL_VARIABLE_IF
+0x3ca1; PVA_InvalidPoolEntry;;0xA1;fsfw/src/fsfw/datapool/PoolVariableIF.h;POOL_VARIABLE_IF
+0x801; DPS_InvalidParameterDefinition;;1;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS
+0x802; DPS_SetWasAlreadyRead;;2;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS
+0x803; DPS_CommitingWithoutReading;;3;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS
+0x804; DPS_DataSetUninitialised;;4;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS
+0x805; DPS_DataSetFull;;5;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS
+0x806; DPS_PoolVarNull;;6;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS
+0x2500; FDI_YourFault;;0;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h;HANDLES_FAILURES_IF
+0x2501; FDI_MyFault;;1;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h;HANDLES_FAILURES_IF
+0x2502; FDI_ConfirmLater;;2;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h;HANDLES_FAILURES_IF
+0x3301; DC_NoReplyReceived;;0x01;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF
+0x3302; DC_ProtocolError;;0x02;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF
+0x3303; DC_Nullpointer;;0x03;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF
+0x3304; DC_InvalidCookieType;;0x04;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF
+0x3305; DC_NotActive;;0x05;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF
+0x3306; DC_TooMuchData;;0x06;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF
+0x1201; AB_NeedSecondStep;;0x01;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE
+0x1202; AB_NeedToReconfigure;;0x02;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE
+0x1203; AB_ModeFallback;;0x03;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE
+0x1204; AB_ChildNotCommandable;;0x04;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE
+0x1205; AB_NeedToChangeHealth;;0x05;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE
+0x12a1; AB_NotEnoughChildrenInCorrectState;;0xa1;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE
+0x3a0; DHB_InvalidChannel;;0xA0;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE
+0x3b0; DHB_AperiodicReply;;0xB0;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE
+0x3b1; DHB_IgnoreReplyData;;0xB1;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE
+0x3b2; DHB_IgnoreFullPacket;;0xB2;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE
+0x3c0; DHB_NothingToSend;;0xC0;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE
+0x3c2; DHB_CommandMapError;;0xC2;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE
+0x3d0; DHB_NoSwitch;;0xD0;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE
+0x3e0; DHB_ChildTimeout;;0xE0;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE
+0x3e1; DHB_SwitchFailed;;0xE1;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE
+0x26a0; DHI_NoCommandData;;0xA0;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
+0x26a1; DHI_CommandNotSupported;;0xA1;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
+0x26a2; DHI_CommandAlreadySent;;0xA2;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
+0x26a3; DHI_CommandWasNotSent;;0xA3;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
+0x26a4; DHI_CantSwitchAddress;;0xA4;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
+0x26a5; DHI_WrongModeForCommand;;0xA5;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
+0x26a6; DHI_Timeout;;0xA6;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
+0x26a7; DHI_Busy;;0xA7;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
+0x26a8; DHI_NoReplyExpected;;0xA8;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
+0x26a9; DHI_NonOpTemperature;;0xA9;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
+0x26aa; DHI_CommandNotImplemented;;0xAA;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
+0x26b0; DHI_ChecksumError;;0xB0;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
+0x26b1; DHI_LengthMissmatch;;0xB1;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
+0x26b2; DHI_InvalidData;;0xB2;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
+0x26b3; DHI_ProtocolError;;0xB3;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
+0x26c0; DHI_DeviceDidNotExecute;;0xC0;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
+0x26c1; DHI_DeviceReportedError;;0xC1;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
+0x26c2; DHI_UnknownDeviceReply;;0xC2;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
+0x26c3; DHI_DeviceReplyInvalid;;0xC3;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
+0x26d0; DHI_InvalidCommandParameter;;0xD0;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
+0x26d1; DHI_InvalidNumberOrLengthOfParameters;;0xD1;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
+0x1f01; CSB_ExecutionComplete;;1;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE
+0x1f02; CSB_NoStepMessage;;2;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE
+0x1f03; CSB_ObjectBusy;;3;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE
+0x1f04; CSB_Busy;;4;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE
+0x1f05; CSB_InvalidTc;;5;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE
+0x1f06; CSB_InvalidObject;;6;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE
+0x1f07; CSB_InvalidReply;;7;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE
+0x1d01; PUS_ActivityStarted;;1;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF
+0x1d02; PUS_InvalidSubservice;;2;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF
+0x1d03; PUS_IllegalApplicationData;;3;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF
+0x1d04; PUS_SendTmFailed;;4;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF
+0x1d05; PUS_Timeout;;5;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF
+0x4b00; SPPA_NoPacketFound;;0x00;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h;SPACE_PACKET_PARSER
+0x4b01; SPPA_SplitPacket;;0x01;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h;SPACE_PACKET_PARSER
+0x3a01; SPH_SemaphoreTimeout;;1;fsfw/src/fsfw/tasks/SemaphoreIF.h;SEMAPHORE_IF
+0x3a02; SPH_SemaphoreNotOwned;;2;fsfw/src/fsfw/tasks/SemaphoreIF.h;SEMAPHORE_IF
+0x3a03; SPH_SemaphoreInvalid;;3;fsfw/src/fsfw/tasks/SemaphoreIF.h;SEMAPHORE_IF
+0xe01; HM_InvalidMode;;0x01;fsfw/src/fsfw/modes/HasModesIF.h;HAS_MODES_IF
+0xe02; HM_TransNotAllowed;;0x02;fsfw/src/fsfw/modes/HasModesIF.h;HAS_MODES_IF
+0xe03; HM_InTransition;;0x03;fsfw/src/fsfw/modes/HasModesIF.h;HAS_MODES_IF
+0xe04; HM_InvalidSubmode;;0x04;fsfw/src/fsfw/modes/HasModesIF.h;HAS_MODES_IF
+0x3b00; LPIF_PoolEntryNotFound;;0x00;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h;LOCAL_POOL_OWNER_IF
+0x3b01; LPIF_PoolEntryTypeConflict;;0x01;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h;LOCAL_POOL_OWNER_IF
+0x3d00; HKM_QueueOrDestinationInvalid;;0;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER
+0x3d01; HKM_WrongHkPacketType;;1;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER
+0x3d02; HKM_ReportingStatusUnchanged;;2;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER
+0x3d03; HKM_PeriodicHelperInvalid;;3;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER
+0x3d04; HKM_PoolobjectNotFound;;4;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER
+0x3d05; HKM_DatasetNotFound;;5;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER
+0x2401; EV_ListenerNotFound;;1;fsfw/src/fsfw/events/EventManagerIF.h;EVENT_MANAGER_IF
+0x2c01; PAW_UnknownDatatype;;0x01;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
+0x2c02; PAW_DatatypeMissmatch;;0x02;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
+0x2c03; PAW_Readonly;;0x03;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
+0x2c04; PAW_TooBig;;0x04;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
+0x2c05; PAW_SourceNotSet;;0x05;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
+0x2c06; PAW_OutOfBounds;;0x06;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
+0x2c07; PAW_NotSet;;0x07;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
+0x2c08; PAW_ColumnOrRowsZero;;0x08;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
+0x2d01; HPA_InvalidIdentifierId;;0x01;fsfw/src/fsfw/parameters/HasParametersIF.h;HAS_PARAMETERS_IF
+0x2d02; HPA_InvalidDomainId;;0x02;fsfw/src/fsfw/parameters/HasParametersIF.h;HAS_PARAMETERS_IF
+0x2d03; HPA_InvalidValue;;0x03;fsfw/src/fsfw/parameters/HasParametersIF.h;HAS_PARAMETERS_IF
+0x2d05; HPA_ReadOnly;;0x05;fsfw/src/fsfw/parameters/HasParametersIF.h;HAS_PARAMETERS_IF
+0xf01; CM_UnknownCommand;;1;fsfw/src/fsfw/ipc/CommandMessageIF.h;COMMAND_MESSAGE
 0x3901; MQI_Empty;;1;fsfw/src/fsfw/ipc/MessageQueueIF.h;MESSAGE_QUEUE_IF
 0x3902; MQI_Full;No space left for more messages;2;fsfw/src/fsfw/ipc/MessageQueueIF.h;MESSAGE_QUEUE_IF
 0x3903; MQI_NoReplyPartner;Returned if a reply method was called without partner;3;fsfw/src/fsfw/ipc/MessageQueueIF.h;MESSAGE_QUEUE_IF
 0x3904; MQI_DestinationInvalid;Returned if the target destination is invalid.;4;fsfw/src/fsfw/ipc/MessageQueueIF.h;MESSAGE_QUEUE_IF
-0xf01; CM_UnknownCommand;;1;fsfw/src/fsfw/ipc/CommandMessageIF.h;COMMAND_MESSAGE
 0x3801; MUX_NotEnoughResources;;1;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
 0x3802; MUX_InsufficientMemory;;2;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
 0x3803; MUX_NoPrivilege;;3;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
@@ -151,17 +349,6 @@
 0x380a; MUX_MutexTimeout;;10;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
 0x380b; MUX_MutexInvalidId;;11;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
 0x380c; MUX_MutexDestroyedWhileWaiting;;12;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
-0x2801; TC_InvalidTargetState;;1;fsfw/src/fsfw/thermal/ThermalComponentIF.h;THERMAL_COMPONENT_IF
-0x28f1; TC_AboveOperationalLimit;;0xF1;fsfw/src/fsfw/thermal/ThermalComponentIF.h;THERMAL_COMPONENT_IF
-0x28f2; TC_BelowOperationalLimit;;0xF2;fsfw/src/fsfw/thermal/ThermalComponentIF.h;THERMAL_COMPONENT_IF
-0x801; DPS_InvalidParameterDefinition;;1;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS
-0x802; DPS_SetWasAlreadyRead;;2;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS
-0x803; DPS_CommitingWithoutReading;;3;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS
-0x804; DPS_DataSetUninitialised;;4;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS
-0x805; DPS_DataSetFull;;5;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS
-0x806; DPS_PoolVarNull;;6;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS
-0x3ca0; PVA_InvalidReadWriteMode;;0xA0;fsfw/src/fsfw/datapool/PoolVariableIF.h;POOL_VARIABLE_IF
-0x3ca1; PVA_InvalidPoolEntry;;0xA1;fsfw/src/fsfw/datapool/PoolVariableIF.h;POOL_VARIABLE_IF
 0xc02; MS_InvalidEntry;;0x02;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h;MODE_STORE_IF
 0xc03; MS_TooManyElements;;0x03;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h;MODE_STORE_IF
 0xc04; MS_CantStoreEmpty;;0x04;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h;MODE_STORE_IF
@@ -184,48 +371,17 @@
 0xb03; SB_ChildDoesntHaveModes;;0x03;fsfw/src/fsfw/subsystem/SubsystemBase.h;SUBSYSTEM_BASE
 0xb04; SB_CouldNotInsertChild;;0x04;fsfw/src/fsfw/subsystem/SubsystemBase.h;SUBSYSTEM_BASE
 0xb05; SB_TableContainsInvalidObjectId;;0x05;fsfw/src/fsfw/subsystem/SubsystemBase.h;SUBSYSTEM_BASE
-0xb00; SB_ConnBroken;;0;fsfw/src/fsfw/osal/common/TcpTmTcServer.h;SUBSYSTEM_BASE
-0x2901; IEC_NoConfigurationTable;;0x01;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
-0x2902; IEC_NoCpuTable;;0x02;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
-0x2903; IEC_InvalidWorkspaceAddress;;0x03;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
-0x2904; IEC_TooLittleWorkspace;;0x04;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
-0x2905; IEC_WorkspaceAllocation;;0x05;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
-0x2906; IEC_InterruptStackTooSmall;;0x06;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
-0x2907; IEC_ThreadExitted;;0x07;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
-0x2908; IEC_InconsistentMpInformation;;0x08;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
-0x2909; IEC_InvalidNode;;0x09;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
-0x290a; IEC_NoMpci;;0x0a;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
-0x290b; IEC_BadPacket;;0x0b;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
-0x290c; IEC_OutOfPackets;;0x0c;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
-0x290d; IEC_OutOfGlobalObjects;;0x0d;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
-0x290e; IEC_OutOfProxies;;0x0e;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
-0x290f; IEC_InvalidGlobalId;;0x0f;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
-0x2910; IEC_BadStackHook;;0x10;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
-0x2911; IEC_BadAttributes;;0x11;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
-0x2912; IEC_ImplementationKeyCreateInconsistency;;0x12;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
-0x2913; IEC_ImplementationBlockingOperationCancel;;0x13;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
-0x2914; IEC_MutexObtainFromBadState;;0x14;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
-0x2915; IEC_UnlimitedAndMaximumIs0;;0x15;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
-0x1401; SE_BufferTooShort;;1;fsfw/src/fsfw/serialize/SerializeIF.h;SERIALIZE_IF
-0x1402; SE_StreamTooShort;;2;fsfw/src/fsfw/serialize/SerializeIF.h;SERIALIZE_IF
-0x1403; SE_TooManyElements;;3;fsfw/src/fsfw/serialize/SerializeIF.h;SERIALIZE_IF
-0x4b00; SPPA_NoPacketFound;;0x00;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h;SPACE_PACKET_PARSER
-0x4b01; SPPA_SplitPacket;;0x01;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h;SPACE_PACKET_PARSER
-0x1d01; PUS_ActivityStarted;;1;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF
-0x1d02; PUS_InvalidSubservice;;2;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF
-0x1d03; PUS_IllegalApplicationData;;3;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF
-0x1d04; PUS_SendTmFailed;;4;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF
-0x1d05; PUS_Timeout;;5;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF
-0x1f01; CSB_ExecutionComplete;;1;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE
-0x1f02; CSB_NoStepMessage;;2;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE
-0x1f03; CSB_ObjectBusy;;3;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE
-0x1f04; CSB_Busy;;4;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE
-0x1f05; CSB_InvalidTc;;5;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE
-0x1f06; CSB_InvalidObject;;6;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE
-0x1f07; CSB_InvalidReply;;7;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE
-0x2500; FDI_YourFault;;0;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h;HANDLES_FAILURES_IF
-0x2501; FDI_MyFault;;1;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h;HANDLES_FAILURES_IF
-0x2502; FDI_ConfirmLater;;2;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h;HANDLES_FAILURES_IF
+0x2801; TC_InvalidTargetState;;1;fsfw/src/fsfw/thermal/ThermalComponentIF.h;THERMAL_COMPONENT_IF
+0x28f1; TC_AboveOperationalLimit;;0xF1;fsfw/src/fsfw/thermal/ThermalComponentIF.h;THERMAL_COMPONENT_IF
+0x28f2; TC_BelowOperationalLimit;;0xF2;fsfw/src/fsfw/thermal/ThermalComponentIF.h;THERMAL_COMPONENT_IF
+0x37a1; SGP4_InvalidEccentricity;;0xA1;fsfw/src/fsfw/coordinates/Sgp4Propagator.h;SGP4PROPAGATOR_CLASS
+0x37a2; SGP4_InvalidMeanMotion;;0xA2;fsfw/src/fsfw/coordinates/Sgp4Propagator.h;SGP4PROPAGATOR_CLASS
+0x37a3; SGP4_InvalidPerturbationElements;;0xA3;fsfw/src/fsfw/coordinates/Sgp4Propagator.h;SGP4PROPAGATOR_CLASS
+0x37a4; SGP4_InvalidSemiLatusRectum;;0xA4;fsfw/src/fsfw/coordinates/Sgp4Propagator.h;SGP4PROPAGATOR_CLASS
+0x37a5; SGP4_InvalidEpochElements;;0xA5;fsfw/src/fsfw/coordinates/Sgp4Propagator.h;SGP4PROPAGATOR_CLASS
+0x37a6; SGP4_SatelliteHasDecayed;;0xA6;fsfw/src/fsfw/coordinates/Sgp4Propagator.h;SGP4PROPAGATOR_CLASS
+0x37b1; SGP4_TleTooOld;;0xB1;fsfw/src/fsfw/coordinates/Sgp4Propagator.h;SGP4PROPAGATOR_CLASS
+0x37b2; SGP4_TleNotInitialized;;0xB2;fsfw/src/fsfw/coordinates/Sgp4Propagator.h;SGP4PROPAGATOR_CLASS
 0x4e1; RMP_CommandNoDescriptorsAvailable;;0xE1;fsfw/src/fsfw/rmap/RMAP.h;RMAP_CHANNEL
 0x4e2; RMP_CommandBufferFull;;0xE2;fsfw/src/fsfw/rmap/RMAP.h;RMAP_CHANNEL
 0x4e3; RMP_CommandChannelOutOfRange;;0xE3;fsfw/src/fsfw/rmap/RMAP.h;RMAP_CHANNEL
@@ -266,83 +422,6 @@
 0x40a; RMP_ReplyCommandNotImplementedOrNotAuthorised;;10;fsfw/src/fsfw/rmap/RMAP.h;RMAP_CHANNEL
 0x40b; RMP_ReplyRmwDataLengthError;;11;fsfw/src/fsfw/rmap/RMAP.h;RMAP_CHANNEL
 0x40c; RMP_ReplyInvalidTargetLogicalAddress;;12;fsfw/src/fsfw/rmap/RMAP.h;RMAP_CHANNEL
-0x2b01; CCS_BcIsSetVrCommand;;0x01;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2b02; CCS_BcIsUnlockCommand;;0x02;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2bb0; CCS_BcIllegalCommand;;0xB0;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2bb1; CCS_BoardReadingNotFinished;;0xB1;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2bf0; CCS_NsPositiveW;;0xF0;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2bf1; CCS_NsNegativeW;;0xF1;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2bf2; CCS_NsLockout;;0xF2;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2bf3; CCS_FarmInLockout;;0xF3;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2bf4; CCS_FarmInWait;;0xF4;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2be0; CCS_WrongSymbol;;0xE0;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2be1; CCS_DoubleStart;;0xE1;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2be2; CCS_StartSymbolMissed;;0xE2;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2be3; CCS_EndWithoutStart;;0xE3;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2be4; CCS_TooLarge;;0xE4;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2be5; CCS_TooShort;;0xE5;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2be6; CCS_WrongTfVersion;;0xE6;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2be7; CCS_WrongSpacecraftId;;0xE7;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2be8; CCS_NoValidFrameType;;0xE8;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2be9; CCS_CrcFailed;;0xE9;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2bea; CCS_VcNotFound;;0xEA;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2beb; CCS_ForwardingFailed;;0xEB;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2bec; CCS_ContentTooLarge;;0xEC;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2bed; CCS_ResidualData;;0xED;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2bee; CCS_DataCorrupted;;0xEE;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2bef; CCS_IllegalSegmentationFlag;;0xEF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2bd0; CCS_IllegalFlagCombination;;0xD0;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2bd1; CCS_ShorterThanHeader;;0xD1;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2bd2; CCS_TooShortBlockedPacket;;0xD2;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2bd3; CCS_TooShortMapExtraction;;0xD3;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x37a1; SGP4_InvalidEccentricity;;0xA1;fsfw/src/fsfw/coordinates/Sgp4Propagator.h;SGP4PROPAGATOR_CLASS
-0x37a2; SGP4_InvalidMeanMotion;;0xA2;fsfw/src/fsfw/coordinates/Sgp4Propagator.h;SGP4PROPAGATOR_CLASS
-0x37a3; SGP4_InvalidPerturbationElements;;0xA3;fsfw/src/fsfw/coordinates/Sgp4Propagator.h;SGP4PROPAGATOR_CLASS
-0x37a4; SGP4_InvalidSemiLatusRectum;;0xA4;fsfw/src/fsfw/coordinates/Sgp4Propagator.h;SGP4PROPAGATOR_CLASS
-0x37a5; SGP4_InvalidEpochElements;;0xA5;fsfw/src/fsfw/coordinates/Sgp4Propagator.h;SGP4PROPAGATOR_CLASS
-0x37a6; SGP4_SatelliteHasDecayed;;0xA6;fsfw/src/fsfw/coordinates/Sgp4Propagator.h;SGP4PROPAGATOR_CLASS
-0x37b1; SGP4_TleTooOld;;0xB1;fsfw/src/fsfw/coordinates/Sgp4Propagator.h;SGP4PROPAGATOR_CLASS
-0x37b2; SGP4_TleNotInitialized;;0xB2;fsfw/src/fsfw/coordinates/Sgp4Propagator.h;SGP4PROPAGATOR_CLASS
-0x13e0; MH_UnknownCmd;;0xE0;fsfw/src/fsfw/memory/MemoryHelper.h;MEMORY_HELPER
-0x13e1; MH_InvalidAddress;;0xE1;fsfw/src/fsfw/memory/MemoryHelper.h;MEMORY_HELPER
-0x13e2; MH_InvalidSize;;0xE2;fsfw/src/fsfw/memory/MemoryHelper.h;MEMORY_HELPER
-0x13e3; MH_StateMismatch;;0xE3;fsfw/src/fsfw/memory/MemoryHelper.h;MEMORY_HELPER
-0x4200; FILS_GenericFileError;;0;fsfw/src/fsfw/memory/HasFileSystemIF.h;FILE_SYSTEM
-0x4201; FILS_IsBusy;;1;fsfw/src/fsfw/memory/HasFileSystemIF.h;FILE_SYSTEM
-0x4202; FILS_InvalidParameters;;2;fsfw/src/fsfw/memory/HasFileSystemIF.h;FILE_SYSTEM
-0x4205; FILS_FileDoesNotExist;;5;fsfw/src/fsfw/memory/HasFileSystemIF.h;FILE_SYSTEM
-0x4206; FILS_FileAlreadyExists;;6;fsfw/src/fsfw/memory/HasFileSystemIF.h;FILE_SYSTEM
-0x4207; FILS_FileLocked;;7;fsfw/src/fsfw/memory/HasFileSystemIF.h;FILE_SYSTEM
-0x420a; FILS_DirectoryDoesNotExist;;10;fsfw/src/fsfw/memory/HasFileSystemIF.h;FILE_SYSTEM
-0x420b; FILS_DirectoryAlreadyExists;;11;fsfw/src/fsfw/memory/HasFileSystemIF.h;FILE_SYSTEM
-0x420c; FILS_DirectoryNotEmpty;;12;fsfw/src/fsfw/memory/HasFileSystemIF.h;FILE_SYSTEM
-0x420f; FILS_SequencePacketMissingWrite;;15;fsfw/src/fsfw/memory/HasFileSystemIF.h;FILE_SYSTEM
-0x4210; FILS_SequencePacketMissingRead;;16;fsfw/src/fsfw/memory/HasFileSystemIF.h;FILE_SYSTEM
-0x601; PP_DoItMyself;;1;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
-0x602; PP_PointsToVariable;;2;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
-0x603; PP_PointsToMemory;;3;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
-0x604; PP_ActivityCompleted;;4;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
-0x605; PP_PointsToVectorUint8;;5;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
-0x606; PP_PointsToVectorUint16;;6;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
-0x607; PP_PointsToVectorUint32;;7;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
-0x608; PP_PointsToVectorFloat;;8;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
-0x6a0; PP_DumpNotSupported;;0xA0;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
-0x6e0; PP_InvalidSize;;0xE0;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
-0x6e1; PP_InvalidAddress;;0xE1;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
-0x6e2; PP_InvalidContent;;0xE2;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
-0x6e3; PP_UnalignedAccess;;0xE3;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
-0x6e4; PP_WriteProtected;;0xE4;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
-0x201; OM_InsertionFailed;;1;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h;OBJECT_MANAGER_IF
-0x202; OM_NotFound;;2;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h;OBJECT_MANAGER_IF
-0x203; OM_ChildInitFailed;;3;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h;OBJECT_MANAGER_IF
-0x204; OM_InternalErrReporterUninit;;4;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h;OBJECT_MANAGER_IF
-0x501; PS_SwitchOn;;1;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF
-0x500; PS_SwitchOff;;0;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF
-0x502; PS_SwitchTimeout;;2;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF
-0x503; PS_FuseOn;;3;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF
-0x504; PS_FuseOff;;4;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF
-0x2f01; POS_InPowerTransition;;1;fsfw/src/fsfw/power/PowerSwitcher.h;POWER_SWITCHER
-0x2f02; POS_SwitchStateMismatch;;2;fsfw/src/fsfw/power/PowerSwitcher.h;POWER_SWITCHER
 0x1000; TIM_UnsupportedTimeFormat;;0;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS
 0x1001; TIM_NotEnoughInformationForTargetFormat;;1;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS
 0x1002; TIM_LengthMismatch;;2;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS
@@ -350,85 +429,9 @@
 0x1004; TIM_InvalidDayOfYear;;4;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS
 0x1005; TIM_TimeDoesNotFitFormat;;5;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS
 0x3601; TSI_BadTimestamp;;1;fsfw/src/fsfw/timemanager/TimeStamperIF.h;TIME_STAMPER_IF
-0x2101; TMF_Busy;;1;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
-0x2102; TMF_LastPacketFound;;2;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
-0x2103; TMF_StopFetch;;3;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
-0x2104; TMF_Timeout;;4;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
-0x2105; TMF_TmChannelFull;;5;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
-0x2106; TMF_NotStored;;6;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
-0x2107; TMF_AllDeleted;;7;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
-0x2108; TMF_InvalidData;;8;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
-0x2109; TMF_NotReady;;9;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
-0x2001; TMB_Busy;;1;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x2002; TMB_Full;;2;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x2003; TMB_Empty;;3;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x2004; TMB_NullRequested;;4;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x2005; TMB_TooLarge;;5;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x2006; TMB_NotReady;;6;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x2007; TMB_DumpError;;7;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x2008; TMB_CrcError;;8;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x2009; TMB_Timeout;;9;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x200a; TMB_IdlePacketFound;;10;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x200b; TMB_TelecommandFound;;11;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x200c; TMB_NoPusATm;;12;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x200d; TMB_TooSmall;;13;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x200e; TMB_BlockNotFound;;14;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x200f; TMB_InvalidRequest;;15;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0xe01; HM_InvalidMode;;0x01;fsfw/src/fsfw/modes/HasModesIF.h;HAS_MODES_IF
-0xe02; HM_TransNotAllowed;;0x02;fsfw/src/fsfw/modes/HasModesIF.h;HAS_MODES_IF
-0xe03; HM_InTransition;;0x03;fsfw/src/fsfw/modes/HasModesIF.h;HAS_MODES_IF
-0xe04; HM_InvalidSubmode;;0x04;fsfw/src/fsfw/modes/HasModesIF.h;HAS_MODES_IF
-0x1501; FM_KeyAlreadyExists;;0x01;fsfw/src/fsfw/container/FixedMap.h;FIXED_MAP
-0x1502; FM_MapFull;;0x02;fsfw/src/fsfw/container/FixedMap.h;FIXED_MAP
-0x1503; FM_KeyDoesNotExist;;0x03;fsfw/src/fsfw/container/FixedMap.h;FIXED_MAP
-0x1101; AL_Full;;0x01;fsfw/src/fsfw/container/ArrayList.h;ARRAY_LIST
-0x1601; FMM_MapFull;;0x01;fsfw/src/fsfw/container/FixedOrderedMultimap.h;FIXED_MULTIMAP
-0x1602; FMM_KeyDoesNotExist;;0x02;fsfw/src/fsfw/container/FixedOrderedMultimap.h;FIXED_MULTIMAP
-0x1801; FF_Full;;1;fsfw/src/fsfw/container/FIFOBase.h;FIFO_CLASS
-0x1802; FF_Empty;;2;fsfw/src/fsfw/container/FIFOBase.h;FIFO_CLASS
-0x3a0; DHB_InvalidChannel;;0xA0;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE
-0x3b0; DHB_AperiodicReply;;0xB0;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE
-0x3b1; DHB_IgnoreReplyData;;0xB1;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE
-0x3b2; DHB_IgnoreFullPacket;;0xB2;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE
-0x3c0; DHB_NothingToSend;;0xC0;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE
-0x3c2; DHB_CommandMapError;;0xC2;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE
-0x3d0; DHB_NoSwitch;;0xD0;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE
-0x3e0; DHB_ChildTimeout;;0xE0;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE
-0x3e1; DHB_SwitchFailed;;0xE1;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE
-0x1201; AB_NeedSecondStep;;0x01;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE
-0x1202; AB_NeedToReconfigure;;0x02;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE
-0x1203; AB_ModeFallback;;0x03;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE
-0x1204; AB_ChildNotCommandable;;0x04;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE
-0x1205; AB_NeedToChangeHealth;;0x05;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE
-0x12a1; AB_NotEnoughChildrenInCorrectState;;0xa1;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE
-0x26a0; DHI_NoCommandData;;0xA0;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
-0x26a1; DHI_CommandNotSupported;;0xA1;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
-0x26a2; DHI_CommandAlreadySent;;0xA2;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
-0x26a3; DHI_CommandWasNotSent;;0xA3;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
-0x26a4; DHI_CantSwitchAddress;;0xA4;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
-0x26a5; DHI_WrongModeForCommand;;0xA5;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
-0x26a6; DHI_Timeout;;0xA6;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
-0x26a7; DHI_Busy;;0xA7;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
-0x26a8; DHI_NoReplyExpected;;0xA8;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
-0x26a9; DHI_NonOpTemperature;;0xA9;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
-0x26aa; DHI_CommandNotImplemented;;0xAA;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
-0x26b0; DHI_ChecksumError;;0xB0;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
-0x26b1; DHI_LengthMissmatch;;0xB1;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
-0x26b2; DHI_InvalidData;;0xB2;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
-0x26b3; DHI_ProtocolError;;0xB3;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
-0x26c0; DHI_DeviceDidNotExecute;;0xC0;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
-0x26c1; DHI_DeviceReportedError;;0xC1;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
-0x26c2; DHI_UnknownDeviceReply;;0xC2;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
-0x26c3; DHI_DeviceReplyInvalid;;0xC3;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
-0x26d0; DHI_InvalidCommandParameter;;0xD0;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
-0x26d1; DHI_InvalidNumberOrLengthOfParameters;;0xD1;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
-0x3301; DC_NoReplyReceived;;0x01;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF
-0x3302; DC_ProtocolError;;0x02;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF
-0x3303; DC_Nullpointer;;0x03;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF
-0x3304; DC_InvalidCookieType;;0x04;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF
-0x3305; DC_NotActive;;0x05;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF
-0x3306; DC_TooMuchData;;0x06;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF
-0x2401; EV_ListenerNotFound;;1;fsfw/src/fsfw/events/EventManagerIF.h;EVENT_MANAGER_IF
+0x1701; HHI_ObjectNotHealthy;;1;fsfw/src/fsfw/health/HasHealthIF.h;HAS_HEALTH_IF
+0x1702; HHI_InvalidHealthState;;2;fsfw/src/fsfw/health/HasHealthIF.h;HAS_HEALTH_IF
+0x1703; HHI_IsExternallyControlled;;3;fsfw/src/fsfw/health/HasHealthIF.h;HAS_HEALTH_IF
 0x1a01; TRC_NotEnoughSensors;;1;fsfw/src/fsfw/monitoring/TriplexMonitor.h;TRIPLE_REDUNDACY_CHECK
 0x1a02; TRC_LowestValueOol;;2;fsfw/src/fsfw/monitoring/TriplexMonitor.h;TRIPLE_REDUNDACY_CHECK
 0x1a03; TRC_HighestValueOol;;3;fsfw/src/fsfw/monitoring/TriplexMonitor.h;TRIPLE_REDUNDACY_CHECK
@@ -447,9 +450,8 @@
 0x30e2; LIM_WrongPid;;0xE2;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
 0x30e3; LIM_WrongLimitId;;0xE3;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
 0x30ee; LIM_MonitorNotFound;;0xEE;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
-0x3a01; SPH_SemaphoreTimeout;;1;fsfw/src/fsfw/tasks/SemaphoreIF.h;SEMAPHORE_IF
-0x3a02; SPH_SemaphoreNotOwned;;2;fsfw/src/fsfw/tasks/SemaphoreIF.h;SEMAPHORE_IF
-0x3a03; SPH_SemaphoreInvalid;;3;fsfw/src/fsfw/tasks/SemaphoreIF.h;SEMAPHORE_IF
+0x68a0; FSHLP_SdNotMounted;SD card specified with path string not mounted;0xA0;bsp_q7s/memory/FilesystemHelper.h;FILE_SYSTEM_HELPER
+0x68a1; FSHLP_FileNotExists;Specified file does not exist on filesystem;0xA1;bsp_q7s/memory/FilesystemHelper.h;FILE_SYSTEM_HELPER
 0x7300; SDMA_OpOngoing;;0;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER
 0x7301; SDMA_AlreadyOn;;1;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER
 0x7302; SDMA_AlreadyMounted;;2;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER
@@ -461,8 +463,50 @@
 0x730e; SDMA_SystemCallError;;14;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER
 0x730f; SDMA_PopenCallError;;15;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER
 0x7400; SCBU_KeyNotFound;;0;bsp_q7s/memory/scratchApi.h;SCRATCH_BUFFER
-0x68a0; FSHLP_SdNotMounted;SD card specified with path string not mounted;0xA0;bsp_q7s/memory/FilesystemHelper.h;FILE_SYSTEM_HELPER
-0x68a1; FSHLP_FileNotExists;Specified file does not exist on filesystem;0xA1;bsp_q7s/memory/FilesystemHelper.h;FILE_SYSTEM_HELPER
+0x62a0; PLMEMDUMP_MramAddressTooHigh;The capacity of the MRAM amounts to 512 kB. Thus the maximum address must not be higher than 0x7d000.;0xA0;linux/devices/ploc/PlocMemoryDumper.h;PLOC_MEMORY_DUMPER
+0x62a1; PLMEMDUMP_MramInvalidAddressCombination;The specified end address is lower than the start address;0xA1;linux/devices/ploc/PlocMemoryDumper.h;PLOC_MEMORY_DUMPER
+0x69a0; PLMPHLP_FileClosedAccidentally;File accidentally close;0xA0;linux/devices/ploc/PlocMPSoCHelper.h;PLOC_MPSOC_HELPER
+0x5ba0; PLSPVhLP_FileClosedAccidentally;File accidentally close;0xA0;linux/devices/ploc/PlocSupvHelper.h;PLOC_SUPV_HELPER
+0x5ba1; PLSPVhLP_ProcessTerminated;Process has been terminated by command;0xA1;linux/devices/ploc/PlocSupvHelper.h;PLOC_SUPV_HELPER
+0x5ba2; PLSPVhLP_PathNotExists;Received command with invalid pathname;0xA2;linux/devices/ploc/PlocSupvHelper.h;PLOC_SUPV_HELPER
+0x5ba3; PLSPVhLP_EventBufferReplyInvalidApid;Expected event buffer TM but received space packet with other APID;0xA3;linux/devices/ploc/PlocSupvHelper.h;PLOC_SUPV_HELPER
+0x60a0; STRHLP_SdNotMounted;SD card specified in path string not mounted;0xA0;linux/devices/startracker/StrHelper.h;STR_HELPER
+0x60a1; STRHLP_FileNotExists;Specified file does not exist on filesystem;0xA1;linux/devices/startracker/StrHelper.h;STR_HELPER
+0x60a2; STRHLP_PathNotExists;Specified path does not exist;0xA2;linux/devices/startracker/StrHelper.h;STR_HELPER
+0x60a3; STRHLP_FileCreationFailed;Failed to create download image or read flash file;0xA3;linux/devices/startracker/StrHelper.h;STR_HELPER
+0x60a4; STRHLP_RegionMismatch;Region in flash write/read reply does not match expected region;0xA4;linux/devices/startracker/StrHelper.h;STR_HELPER
+0x60a5; STRHLP_AddressMismatch;Address in flash write/read reply does not match expected address;0xA5;linux/devices/startracker/StrHelper.h;STR_HELPER
+0x60a6; STRHLP_LengthMismatch;Length in flash write/read reply does not match expected length;0xA6;linux/devices/startracker/StrHelper.h;STR_HELPER
+0x60a7; STRHLP_StatusError;Status field in reply signals error;0xA7;linux/devices/startracker/StrHelper.h;STR_HELPER
+0x60a8; STRHLP_InvalidTypeId;Reply has invalid type ID (should be of action reply type);0xA8;linux/devices/startracker/StrHelper.h;STR_HELPER
+0x6601; JSONBASE_JsonFileNotExists;Specified json file does not exist;1;linux/devices/startracker/ArcsecJsonParamBase.h;ARCSEC_JSON_BASE
+0x6602; JSONBASE_SetNotExists;Requested set does not exist in json file;2;linux/devices/startracker/ArcsecJsonParamBase.h;ARCSEC_JSON_BASE
+0x6603; JSONBASE_ParamNotExists;Requested parameter does not exist in json file;3;linux/devices/startracker/ArcsecJsonParamBase.h;ARCSEC_JSON_BASE
+0x57a0; STRH_DecInProgress;More data required to complete frame;0xA0;linux/devices/startracker/ArcsecDatalinkLayer.h;STR_HANDLER
+0x57a1; STRH_ReplyTooShort;Data too short to represent a valid frame;0xA1;linux/devices/startracker/ArcsecDatalinkLayer.h;STR_HANDLER
+0x57a2; STRH_CrcFailure;Detected CRC failure in received frame;0xA2;linux/devices/startracker/ArcsecDatalinkLayer.h;STR_HANDLER
+0x57a3; STRH_InterfaceReqFailed;Status in interface reply signals error;0xA3;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
+0x57a4; STRH_PowerReqFailed;Status in power reply signals error;0xA4;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
+0x57a5; STRH_SetParamFailed;Status of reply to parameter set command signals error;0xA5;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
+0x57a6; STRH_ActionFailed;Status of reply to action command signals error;0xA6;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
+0x57a7; STRH_FilePathTooLong;Received invalid path string. Exceeds allowed length;0xA7;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
+0x57a8; STRH_FilenameTooLong;Name of file received with command is too long;0xA8;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
+0x57a9; STRH_InvalidProgram;Received version reply with invalid program ID;0xA9;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
+0x57aa; STRH_ReplyError;Status field reply signals error;0xAA;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
+0x57ab; STRH_CommandTooShort;Received command which is too short (some data is missing for proper execution);0xAB;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
+0x57ac; STRH_InvalidLength;Received command with invalid length (too few or too many parameters);0xAC;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
+0x57ad; STRH_RegionMismatch;Region mismatch between send and received data;0xAD;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
+0x57ae; STRH_AddressMismatch;Address mismatch between send and received data;0xAE;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
+0x57af; STRH_LengthMismatch;Length field mismatch between send and received data;0xAF;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
+0x57b0; STRH_FileNotExists;Specified file does not exist;0xB0;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
+0x57b1; STRH_InvalidType;Download blob pixel command has invalid type field;0xB1;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
+0x57b2; STRH_InvalidId;Received FPGA action command with invalid ID;0xB2;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
+0x57b3; STRH_ReplyTooShort;Received reply is too short;0xB3;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
+0x57b4; STRH_CrcFailure;Received reply with invalid CRC;0xB4;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
+0x57b5; STRH_StrHelperExecuting;Star tracker handler currently executing a command and using the communication interface;0xB5;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
+0x57b6; STRH_StartrackerAlreadyBooted;Star tracker is already in firmware mode;0xB6;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
+0x57b7; STRH_StartrackerRunningFirmware;Star tracker is in firmware mode but must be in bootloader mode to execute this command;0xB7;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
+0x57b8; STRH_StartrackerRunningBootloader;Star tracker is in bootloader mode but must be in firmware mode to execute this command;0xB8;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
 0x6ba0; MPSOCRTVIF_CrcFailure;Space Packet received from PLOC has invalid CRC;0xA0;linux/devices/devicedefinitions/MPSoCReturnValuesIF.h;MPSOC_RETURN_VALUES_IF
 0x6ba1; MPSOCRTVIF_ReceivedAckFailure;Received ACK failure reply from PLOC;0xA1;linux/devices/devicedefinitions/MPSoCReturnValuesIF.h;MPSOC_RETURN_VALUES_IF
 0x6ba2; MPSOCRTVIF_ReceivedExeFailure;Received execution failure reply from PLOC;0xA2;linux/devices/devicedefinitions/MPSoCReturnValuesIF.h;MPSOC_RETURN_VALUES_IF
@@ -495,56 +539,6 @@
 0x6cb3; SPVRTVIF_SupvHelperExecuting;Supervisor helper task ist currently executing a command (wait until helper tas has finished or interrupt by sending the terminate command);0xB3;linux/devices/devicedefinitions/SupvReturnValuesIF.h;SUPV_RETURN_VALUES_IF
 0x58e0; DWLPWRON_InvalidMode;Received command has invalid JESD mode (valid modes are 0 - 5);0xE0;linux/devices/devicedefinitions/PlocMPSoCDefinitions.h;DWLPWRON_CMD
 0x58e1; DWLPWRON_InvalidLaneRate;Received command has invalid lane rate (valid lane rate are 0 - 9);0xE1;linux/devices/devicedefinitions/PlocMPSoCDefinitions.h;DWLPWRON_CMD
-0x62a0; PLMEMDUMP_MramAddressTooHigh;The capacity of the MRAM amounts to 512 kB. Thus the maximum address must not be higher than 0x7d000.;0xA0;linux/devices/ploc/PlocMemoryDumper.h;PLOC_MEMORY_DUMPER
-0x62a1; PLMEMDUMP_MramInvalidAddressCombination;The specified end address is lower than the start address;0xA1;linux/devices/ploc/PlocMemoryDumper.h;PLOC_MEMORY_DUMPER
-0x69a0; PLMPHLP_FileClosedAccidentally;File accidentally close;0xA0;linux/devices/ploc/PlocMPSoCHelper.h;PLOC_MPSOC_HELPER
-0x5ba0; PLSPVhLP_FileClosedAccidentally;File accidentally close;0xA0;linux/devices/ploc/PlocSupvHelper.h;PLOC_SUPV_HELPER
-0x5ba1; PLSPVhLP_ProcessTerminated;Process has been terminated by command;0xA1;linux/devices/ploc/PlocSupvHelper.h;PLOC_SUPV_HELPER
-0x5ba2; PLSPVhLP_PathNotExists;Received command with invalid pathname;0xA2;linux/devices/ploc/PlocSupvHelper.h;PLOC_SUPV_HELPER
-0x5ba3; PLSPVhLP_EventBufferReplyInvalidApid;Expected event buffer TM but received space packet with other APID;0xA3;linux/devices/ploc/PlocSupvHelper.h;PLOC_SUPV_HELPER
-0x6601; JSONBASE_JsonFileNotExists;Specified json file does not exist;1;linux/devices/startracker/ArcsecJsonParamBase.h;ARCSEC_JSON_BASE
-0x6602; JSONBASE_SetNotExists;Requested set does not exist in json file;2;linux/devices/startracker/ArcsecJsonParamBase.h;ARCSEC_JSON_BASE
-0x6603; JSONBASE_ParamNotExists;Requested parameter does not exist in json file;3;linux/devices/startracker/ArcsecJsonParamBase.h;ARCSEC_JSON_BASE
-0x57a0; STRH_TemperatureReqFailed;Status in temperature reply signals error;0xA0;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
-0x57a1; STRH_PingFailed;Ping command failed;0xA1;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
-0x57a2; STRH_VersionReqFailed;Status in version reply signals error;0xA2;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
-0x57a3; STRH_InterfaceReqFailed;Status in interface reply signals error;0xA3;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
-0x57a4; STRH_PowerReqFailed;Status in power reply signals error;0xA4;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
-0x57a5; STRH_SetParamFailed;Status of reply to parameter set command signals error;0xA5;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
-0x57a6; STRH_ActionFailed;Status of reply to action command signals error;0xA6;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
-0x57a7; STRH_FilePathTooLong;Received invalid path string. Exceeds allowed length;0xA7;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
-0x57a8; STRH_FilenameTooLong;Name of file received with command is too long;0xA8;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
-0x57a9; STRH_InvalidProgram;Received version reply with invalid program ID;0xA9;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
-0x57aa; STRH_ReplyError;Status field reply signals error;0xAA;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
-0x57ab; STRH_CommandTooShort;Received command which is too short (some data is missing for proper execution);0xAB;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
-0x57ac; STRH_InvalidLength;Received command with invalid length (too few or too many parameters);0xAC;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
-0x57ad; STRH_RegionMismatch;Region mismatch between send and received data;0xAD;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
-0x57ae; STRH_AddressMismatch;Address mismatch between send and received data;0xAE;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
-0x57af; STRH_LengthMismatch;Length field mismatch between send and received data;0xAF;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
-0x57b0; STRH_FileNotExists;Specified file does not exist;0xB0;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
-0x57b1; STRH_InvalidType;Download blob pixel command has invalid type field;0xB1;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
-0x57b2; STRH_InvalidId;Received FPGA action command with invalid ID;0xB2;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
-0x57b3; STRH_ReplyTooShort;Received reply is too short;0xB3;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
-0x57b4; STRH_CrcFailure;Received reply with invalid CRC;0xB4;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
-0x57b5; STRH_StrHelperExecuting;Star tracker handler currently executing a command and using the communication interface;0xB5;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
-0x57b6; STRH_StartrackerAlreadyBooted;Star tracker is already in firmware mode;0xB6;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
-0x57b7; STRH_StartrackerRunningFirmware;Star tracker is in firmware mode but must be in bootloader mode to execute this command;0xB7;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
-0x57b8; STRH_StartrackerRunningBootloader;Star tracker is in bootloader mode but must be in firmware mode to execute this command;0xB8;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
-0x60a0; STRHLP_SdNotMounted;SD card specified in path string not mounted;0xA0;linux/devices/startracker/StrHelper.h;STR_HELPER
-0x60a1; STRHLP_FileNotExists;Specified file does not exist on filesystem;0xA1;linux/devices/startracker/StrHelper.h;STR_HELPER
-0x60a2; STRHLP_PathNotExists;Specified path does not exist;0xA2;linux/devices/startracker/StrHelper.h;STR_HELPER
-0x60a3; STRHLP_FileCreationFailed;Failed to create download image or read flash file;0xA3;linux/devices/startracker/StrHelper.h;STR_HELPER
-0x60a4; STRHLP_RegionMismatch;Region in flash write/read reply does not match expected region;0xA4;linux/devices/startracker/StrHelper.h;STR_HELPER
-0x60a5; STRHLP_AddressMismatch;Address in flash write/read reply does not match expected address;0xA5;linux/devices/startracker/StrHelper.h;STR_HELPER
-0x60a6; STRHLP_LengthMismatch;Length in flash write/read reply does not match expected length;0xA6;linux/devices/startracker/StrHelper.h;STR_HELPER
-0x60a7; STRHLP_StatusError;Status field in reply signals error;0xA7;linux/devices/startracker/StrHelper.h;STR_HELPER
-0x60a8; STRHLP_InvalidTypeId;Reply has invalid type ID (should be of action reply type);0xA8;linux/devices/startracker/StrHelper.h;STR_HELPER
-0x5da0; IPCI_PapbBusy;;0xA0;linux/obc/PapbVcInterface.h;CCSDS_IP_CORE_BRIDGE
-0x5ea0; PTME_UnknownVcId;;0xA0;linux/obc/Ptme.h;PTME
-0x65a0; RS_RateNotSupported;The commanded rate is not supported by the current FPGA design;0xA0;linux/obc/PtmeConfig.h;RATE_SETTER
-0x65a1; RS_BadBitRate;Bad bitrate has been commanded (e.g. 0);0xA1;linux/obc/PtmeConfig.h;RATE_SETTER
-0x65a2; RS_ClkInversionFailed;Failed to invert clock and thus change the time the data is updated with respect to the tx clock;0xA2;linux/obc/PtmeConfig.h;RATE_SETTER
-0x65a3; RS_TxManipulatorConfigFailed;Failed to change configuration bit of tx clock manipulator;0xA3;linux/obc/PtmeConfig.h;RATE_SETTER
 0x63a0; PDEC_AbandonedCltu;;0xA0;linux/obc/PdecHandler.h;PDEC_HANDLER
 0x63a1; PDEC_FrameDirty;;0xA1;linux/obc/PdecHandler.h;PDEC_HANDLER
 0x63a2; PDEC_FrameIllegalMultipleReasons;;0xA2;linux/obc/PdecHandler.h;PDEC_HANDLER
@@ -560,3 +554,9 @@
 0x63ab; PDEC_InvalidVcIdLsb;;0xAB;linux/obc/PdecHandler.h;PDEC_HANDLER
 0x63ac; PDEC_NsNotZero;;0xAC;linux/obc/PdecHandler.h;PDEC_HANDLER
 0x63ae; PDEC_InvalidBcCc;;0xAE;linux/obc/PdecHandler.h;PDEC_HANDLER
+0x5da0; IPCI_PapbBusy;;0xA0;linux/obc/PapbVcInterface.h;CCSDS_IP_CORE_BRIDGE
+0x65a0; RS_RateNotSupported;The commanded rate is not supported by the current FPGA design;0xA0;linux/obc/PtmeConfig.h;RATE_SETTER
+0x65a1; RS_BadBitRate;Bad bitrate has been commanded (e.g. 0);0xA1;linux/obc/PtmeConfig.h;RATE_SETTER
+0x65a2; RS_ClkInversionFailed;Failed to invert clock and thus change the time the data is updated with respect to the tx clock;0xA2;linux/obc/PtmeConfig.h;RATE_SETTER
+0x65a3; RS_TxManipulatorConfigFailed;Failed to change configuration bit of tx clock manipulator;0xA3;linux/obc/PtmeConfig.h;RATE_SETTER
+0x5ea0; PTME_UnknownVcId;;0xA0;linux/obc/Ptme.h;PTME

generators/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
  * @brief    Auto-generated event translation file. Contains 207 translations.
  * @details
- * Generated on: 2022-05-25 18:41:07
+ * Generated on: 2022-06-10 18:08:57
  */
 #include "translateEvents.h"
 

generators/objects/translateObjects.cpp

@@ -2,7 +2,7 @@
  * @brief  Auto-generated object translation file.
  * @details
  * Contains 131 translations.
- * Generated on: 2022-05-25 18:41:13
+ * Generated on: 2022-06-10 18:08:53
  */
 #include "translateObjects.h"
 

linux/ObjectFactory.cpp

@@ -8,6 +8,7 @@
 #include <fsfw_hal/linux/spi/SpiCookie.h>
 #include <linux/callbacks/gpioCallbacks.h>
 #include <linux/devices/Max31865RtdLowlevelHandler.h>
+#include <mission/controller/ThermalController.h>
 #include <mission/devices/Max31865EiveHandler.h>
 #include <mission/devices/Max31865PT1000Handler.h>
 #include <mission/devices/SusHandler.h>
@@ -319,6 +320,10 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
 #endif  // OBSW_ADD_RTD_DEVICES == 1
 }
 
+void ObjectFactory::createThermalController() {
+  new ThermalController(objects::THERMAL_CONTROLLER, objects::NO_OBJECT);
+}
+
 void ObjectFactory::gpioChecker(ReturnValue_t result, std::string output) {
   if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "ObjectFactory: Adding GPIOs failed for " << output << std::endl;

linux/ObjectFactory.h

@@ -17,4 +17,6 @@ void createRtdComponents(std::string spiDev, GpioIF* gpioComIF, PowerSwitchIF* p
 
 void gpioChecker(ReturnValue_t result, std::string output);
 
+void createThermalController();
+
 }  // namespace ObjectFactory

linux/devices/devicedefinitions/PlocMPSoCDefinitions.h

@@ -125,7 +125,7 @@ namespace status_code {
 static const uint16_t RESERVED_2 = 0x5F2;
 static const uint16_t RESERVED_3 = 0x5F3;
 static const uint16_t RESERVED_4 = 0x5F4;
-}
+}  // namespace status_code
 
 /**
  * @brief   Abstract base class for TC space packet of MPSoC.

linux/devices/ploc/PlocMPSoCHandler.cpp

@@ -693,7 +693,8 @@ ReturnValue_t PlocMPSoCHandler::handleCamCmdRpt(const uint8_t* data) {
   sif::info << "PlocMPSoCHandler: CamCmdRpt Ack value: 0x" << std::hex
             << static_cast<unsigned int>(ackValue) << std::endl;
 #endif /* OBSW_DEBUG_PLOC_MPSOC == 1 */
-  handleDeviceTM(packet.getPacketData() + sizeof(uint16_t), packet.getPacketDataLength() - 1, mpsoc::TM_CAM_CMD_RPT);
+  handleDeviceTM(packet.getPacketData() + sizeof(uint16_t), packet.getPacketDataLength() - 1,
+                 mpsoc::TM_CAM_CMD_RPT);
   return result;
 }
 

linux/devices/ploc/PlocSupervisorHandler.cpp

@@ -142,6 +142,7 @@ ReturnValue_t PlocSupervisorHandler::executeAction(ActionId_t actionId,
 }
 
 void PlocSupervisorHandler::doStartUp() {
+  if (setTimeDuringStartup) {
     switch (startupState) {
       case StartupState::OFF: {
         bootTimeout.resetTimer();
@@ -163,6 +164,10 @@ void PlocSupervisorHandler::doStartUp() {
       default:
         break;
     }
+  } else {
+    uartIsolatorSwitch.pullHigh();
+    setMode(_MODE_TO_ON);
+  }
 }
 
 void PlocSupervisorHandler::doShutDown() {
@@ -887,14 +892,11 @@ ReturnValue_t PlocSupervisorHandler::handleAckReport(const uint8_t* data) {
 
   switch (result) {
     case SupvReturnValuesIF::RECEIVED_ACK_FAILURE: {
-#if OBSW_DEBUG_PLOC_SUPERVISOR == 1
-      sif::debug << "PlocSupervisorHandler: Received Ack failure report with status code: 0x"
-                 << std::hex << ack.getStatusCode() << std::endl;
-#endif /* OBSW_DEBUG_PLOC_SUPERVISOR == 1 */
       DeviceCommandId_t commandId = getPendingCommand();
       if (commandId != DeviceHandlerIF::NO_COMMAND_ID) {
         triggerEvent(SUPV_ACK_FAILURE, commandId, static_cast<uint32_t>(ack.getStatusCode()));
       }
+      printAckFailureInfo(ack.getStatusCode(), commandId);
       sendFailureReport(supv::ACK_REPORT, SupvReturnValuesIF::RECEIVED_ACK_FAILURE);
       disableAllReplies();
       nextReplyId = supv::NONE;
@@ -1944,3 +1946,17 @@ void PlocSupervisorHandler::handleExecutionFailureReport(uint16_t statusCode) {
   sendFailureReport(EXE_REPORT, SupvReturnValuesIF::RECEIVED_EXE_FAILURE);
   disableExeReportReply();
 }
+
+void PlocSupervisorHandler::printAckFailureInfo(uint16_t statusCode, DeviceCommandId_t commandId) {
+  sif::warning << "PlocSupervisorHandler: Received Ack failure report with status code: 0x"
+               << std::hex << statusCode << std::endl;
+  switch (commandId) {
+    case (supv::SET_TIME_REF): {
+      sif::info << "PlocSupervisoHandler: Setting time failed. Make sure the OBC has a valid time"
+                << std::endl;
+      break;
+    }
+    default:
+      break;
+  }
+}

linux/devices/ploc/PlocSupervisorHandler.h

@@ -95,6 +95,8 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
   static const uint32_t BOOT_TIMEOUT = 2000;
   enum class StartupState : uint8_t { OFF, BOOTING, SET_TIME, SET_TIME_EXECUTING, ON };
 
+  bool setTimeDuringStartup = true;
+
   StartupState startupState = StartupState::OFF;
 
   uint8_t commandBuffer[supv::MAX_COMMAND_SIZE];
@@ -369,6 +371,8 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
 
   void handleExecutionSuccessReport(const uint8_t* data);
   void handleExecutionFailureReport(uint16_t statusCode);
+
+  void printAckFailureInfo(uint16_t statusCode, DeviceCommandId_t commandId);
 };
 
 #endif /* MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_ */

linux/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
  * @brief    Auto-generated event translation file. Contains 207 translations.
  * @details
- * Generated on: 2022-05-25 18:41:07
+ * Generated on: 2022-06-10 18:08:57
  */
 #include "translateEvents.h"
 

linux/fsfwconfig/objects/systemObjectList.h

@@ -1,5 +1,5 @@
-#ifndef HOSTED_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
-#define HOSTED_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
+#ifndef LINUX_FSFWCONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
+#define LINUX_FSFWCONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
 
 #include <fsfw/objectmanager/frameworkObjects.h>
 
@@ -61,7 +61,8 @@ enum sourceObjects : uint32_t {
   DUMMY_INTERFACE = 0x5400CAFE,
   DUMMY_HANDLER = 0x5400AFFE,
   P60DOCK_TEST_TASK = 0x00005060,
+  DUMMY_COM_IF = 0x54000040
 };
 }
 
-#endif /* BSP_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_ */
+#endif /* LINUX_FSFWCONFIG_OBJECTS_SYSTEMOBJECTLIST_H_ */

linux/fsfwconfig/objects/translateObjects.cpp

@@ -2,7 +2,7 @@
  * @brief  Auto-generated object translation file.
  * @details
  * Contains 131 translations.
- * Generated on: 2022-05-25 18:41:13
+ * Generated on: 2022-06-10 18:08:53
  */
 #include "translateObjects.h"
 

misc/eclipse/host/eive-linux-host-debug-cmake.launch

@@ -21,7 +21,7 @@
     <stringAttribute key="org.eclipse.cdt.launch.PROGRAM_NAME" value="cmake-build-debug/eive-obsw"/>
     <stringAttribute key="org.eclipse.cdt.launch.PROJECT_ATTR" value="eive-obsw"/>
     <booleanAttribute key="org.eclipse.cdt.launch.PROJECT_BUILD_CONFIG_AUTO_ATTR" value="false"/>
-    <stringAttribute key="org.eclipse.cdt.launch.PROJECT_BUILD_CONFIG_ID_ATTR" value="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473"/>
+    <stringAttribute key="org.eclipse.cdt.launch.PROJECT_BUILD_CONFIG_ID_ATTR" value=""/>
     <listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
         <listEntry value="/eive-obsw"/>
     </listAttribute>

misc/eclipse/host/eive-unittest.launch

@@ -20,12 +20,13 @@
     <stringAttribute key="org.eclipse.cdt.launch.PROGRAM_NAME" value="cmake-build-debug/eive-unittest"/>
     <stringAttribute key="org.eclipse.cdt.launch.PROJECT_ATTR" value="eive-obsw"/>
     <booleanAttribute key="org.eclipse.cdt.launch.PROJECT_BUILD_CONFIG_AUTO_ATTR" value="false"/>
-    <stringAttribute key="org.eclipse.cdt.launch.PROJECT_BUILD_CONFIG_ID_ATTR" value="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.758550634"/>
+    <stringAttribute key="org.eclipse.cdt.launch.PROJECT_BUILD_CONFIG_ID_ATTR" value=""/>
     <listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
         <listEntry value="/eive-obsw"/>
     </listAttribute>
     <listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
         <listEntry value="4"/>
     </listAttribute>
+    <stringAttribute key="org.eclipse.dsf.launch.MEMORY_BLOCKS" value="&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot;?&gt;&lt;memoryBlockExpressionList context=&quot;reserved-for-future-use&quot;/&gt;"/>
     <stringAttribute key="process_factory_id" value="org.eclipse.cdt.dsf.gdb.GdbProcessFactory"/>
 </launchConfiguration>

mission/controller/ThermalController.cpp

@@ -1,40 +1,224 @@
 #include "ThermalController.h"
 
+#include <bsp_q7s/core/CoreDefinitions.h>
+#include <fsfw/datapool/PoolReadGuard.h>
+#include <fsfw_hal/devicehandlers/devicedefinitions/MgmLIS3HandlerDefs.h>
+#include <linux/devices/devicedefinitions/StarTrackerDefinitions.h>
+#include <mission/devices/devicedefinitions/BpxBatteryDefinitions.h>
+#include <mission/devices/devicedefinitions/GomspaceDefinitions.h>
+#include <mission/devices/devicedefinitions/GyroADIS1650XDefinitions.h>
+#include <mission/devices/devicedefinitions/GyroL3GD20Definitions.h>
+#include <mission/devices/devicedefinitions/IMTQHandlerDefinitions.h>
+#include <mission/devices/devicedefinitions/RwDefinitions.h>
+#include <mission/devices/devicedefinitions/SyrlinksDefinitions.h>
+#include <mission/devices/devicedefinitions/payloadPcduDefinitions.h>
+#include <objects/systemObjectList.h>
+
 ThermalController::ThermalController(object_id_t objectId, object_id_t parentId)
     : ExtendedControllerBase(objectId, parentId),
       sensorTemperatures(this),
-      componentTemperatures(this) {}
+      susTemperatures(this),
+      deviceTemperatures(this),
+      max31865Set0(objects::RTD_0_IC3_PLOC_HEATSPREADER,
+                   EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
+      max31865Set1(objects::RTD_1_IC4_PLOC_MISSIONBOARD,
+                   EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
+      max31865Set2(objects::RTD_2_IC5_4K_CAMERA, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
+      max31865Set3(objects::RTD_3_IC6_DAC_HEATSPREADER, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
+      max31865Set4(objects::RTD_4_IC7_STARTRACKER, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
+      max31865Set5(objects::RTD_5_IC8_RW1_MX_MY, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
+      max31865Set6(objects::RTD_6_IC9_DRO, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
+      max31865Set7(objects::RTD_7_IC10_SCEX, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
+      max31865Set8(objects::RTD_8_IC11_X8, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
+      max31865Set9(objects::RTD_9_IC12_HPA, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
+      max31865Set10(objects::RTD_10_IC13_PL_TX, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
+      max31865Set11(objects::RTD_11_IC14_MPA, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
+      max31865Set12(objects::RTD_12_IC15_ACU, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
+      max31865Set13(objects::RTD_13_IC16_PLPCDU_HEATSPREADER,
+                    EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
+      max31865Set14(objects::RTD_14_IC17_TCS_BOARD, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
+      max31865Set15(objects::RTD_15_IC18_IMTQ, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
+      tmp1075Set1(objects::TMP1075_HANDLER_1),
+      tmp1075Set2(objects::TMP1075_HANDLER_2),
+      susSet0(objects::SUS_0_N_LOC_XFYFZM_PT_XF),
+      susSet1(objects::SUS_1_N_LOC_XBYFZM_PT_XB),
+      susSet2(objects::SUS_2_N_LOC_XFYBZB_PT_YB),
+      susSet3(objects::SUS_3_N_LOC_XFYBZF_PT_YF),
+      susSet4(objects::SUS_4_N_LOC_XMYFZF_PT_ZF),
+      susSet5(objects::SUS_5_N_LOC_XFYMZB_PT_ZB),
+      susSet6(objects::SUS_6_R_LOC_XFYBZM_PT_XF),
+      susSet7(objects::SUS_7_R_LOC_XBYBZM_PT_XB),
+      susSet8(objects::SUS_8_R_LOC_XBYBZB_PT_YB),
+      susSet9(objects::SUS_9_R_LOC_XBYBZB_PT_YF),
+      susSet10(objects::SUS_10_N_LOC_XMYBZF_PT_ZF),
+      susSet11(objects::SUS_11_R_LOC_XBYMZB_PT_ZB) {}
 
-ReturnValue_t ThermalController::initialize() { return ControllerBase::initialize(); }
+ReturnValue_t ThermalController::initialize() {
+  auto result = ExtendedControllerBase::initialize();
+  return result;
+}
 
 ReturnValue_t ThermalController::handleCommandMessage(CommandMessage* message) {
   return RETURN_FAILED;
 }
+
 void ThermalController::performControlOperation() {
+  switch (internalState) {
+    case InternalState::STARTUP: {
+      initialCountdown.resetTimer();
+      internalState = InternalState::INITIAL_DELAY;
+      return;
+    }
+    case InternalState::INITIAL_DELAY: {
+      if (initialCountdown.hasTimedOut()) {
+        internalState = InternalState::READY;
+      }
+      return;
+    }
+    case InternalState::READY: {
+      break;
+    }
+    default:
+      break;
+  }
+
   ReturnValue_t result = sensorTemperatures.read();
-  if (result != RETURN_OK) {
-    return;
-  }
-  result = componentTemperatures.read();
-  if (result != RETURN_OK) {
-    return;
-  }
-
-  componentTemperatures.rw = (sensorTemperatures.rw.value + sensorTemperatures.gps.value) / 2;
-
+  if (result == RETURN_OK) {
+    copySensors();
     sensorTemperatures.commit();
-  componentTemperatures.commit();
+  }
+
+  result = susTemperatures.read();
+  if (result == RETURN_OK) {
+    copySus();
+    susTemperatures.commit();
+  }
+
+  result = deviceTemperatures.read();
+  if (result == RETURN_OK) {
+    copyDevices();
+    deviceTemperatures.commit();
+  }
 }
 
 ReturnValue_t ThermalController::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                                          LocalDataPoolManager& poolManager) {
-  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_RW, new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_GPS, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_PLOC_HEATSPREADER,
+                           new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_PLOC_MISSIONBOARD,
+                           new PoolEntry<float>({1.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_4K_CAMERA,
+                           new PoolEntry<float>({2.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_DAC_HEATSPREADER,
+                           new PoolEntry<float>({3.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_STARTRACKER,
+                           new PoolEntry<float>({4.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_RW1, new PoolEntry<float>({5.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_DRO, new PoolEntry<float>({6.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_SCEX, new PoolEntry<float>({7.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_X8, new PoolEntry<float>({8.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_HPA, new PoolEntry<float>({9.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_TX_MODUL,
+                           new PoolEntry<float>({10.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_MPA, new PoolEntry<float>({11.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_ACU, new PoolEntry<float>({12.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_PLPCDU_HEATSPREADER,
+                           new PoolEntry<float>({13.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_TCS_BOARD,
+                           new PoolEntry<float>({14.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_MAGNETTORQUER,
+                           new PoolEntry<float>({15.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_TMP1075_1,
+                           new PoolEntry<float>({15.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_TMP1075_2,
+                           new PoolEntry<float>({15.0}));
+
+  localDataPoolMap.emplace(thermalControllerDefinitions::SUS_0_N_LOC_XFYFZM_PT_XF,
+                           new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SUS_6_R_LOC_XFYBZM_PT_XF,
+                           new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SUS_1_N_LOC_XBYFZM_PT_XB,
+                           new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SUS_7_R_LOC_XBYBZM_PT_XB,
+                           new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SUS_2_N_LOC_XFYBZB_PT_YB,
+                           new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SUS_8_R_LOC_XBYBZB_PT_YB,
+                           new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SUS_3_N_LOC_XFYBZF_PT_YF,
+                           new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SUS_9_R_LOC_XBYBZB_PT_YF,
+                           new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SUS_4_N_LOC_XMYFZF_PT_ZF,
+                           new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SUS_10_N_LOC_XMYBZF_PT_ZF,
+                           new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SUS_5_N_LOC_XFYMZB_PT_ZB,
+                           new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::SUS_11_R_LOC_XBYMZB_PT_ZB,
+                           new PoolEntry<float>({0.0}));
+
   localDataPoolMap.emplace(thermalControllerDefinitions::COMPONENT_RW, new PoolEntry<float>({0.0}));
 
+  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_Q7S, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::BATTERY_TEMP_1,
+                           new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::BATTERY_TEMP_2,
+                           new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::BATTERY_TEMP_3,
+                           new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::BATTERY_TEMP_4,
+                           new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_RW1, new PoolEntry<int32_t>({0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_RW2, new PoolEntry<int32_t>({0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_RW3, new PoolEntry<int32_t>({0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_RW4, new PoolEntry<int32_t>({0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_STAR_TRACKER,
+                           new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_SYRLINKS_POWER_AMPLIFIER,
+                           new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_SYRLINKS_BASEBAND_BOARD,
+                           new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_MGT, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_ACU, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_PDU1, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_PDU2, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_1_P60DOCK, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_2_P60DOCK, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_GYRO_0_SIDE_A,
+                           new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_GYRO_1_SIDE_A,
+                           new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_GYRO_2_SIDE_B,
+                           new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_GYRO_3_SIDE_B,
+                           new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_MGM_0_SIDE_A,
+                           new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_MGM_2_SIDE_B,
+                           new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_ADC_PAYLOAD_PCDU,
+                           new PoolEntry<float>({0.0}));
+
+  poolManager.subscribeForPeriodicPacket(sensorTemperatures.getSid(), true, 1.0, false);
+  poolManager.subscribeForPeriodicPacket(susTemperatures.getSid(), true, 1.0, false);
+  poolManager.subscribeForPeriodicPacket(deviceTemperatures.getSid(), true, 1.0, false);
+
   return RETURN_OK;
 }
-LocalPoolDataSetBase* ThermalController::getDataSetHandle(sid_t sid) { return nullptr; }
+
+LocalPoolDataSetBase* ThermalController::getDataSetHandle(sid_t sid) {
+  switch (sid.ownerSetId) {
+    case thermalControllerDefinitions::SENSOR_TEMPERATURES:
+      return &sensorTemperatures;
+    case thermalControllerDefinitions::SUS_TEMPERATURES:
+      return &susTemperatures;
+    case thermalControllerDefinitions::DEVICE_TEMPERATURES:
+      return &deviceTemperatures;
+    default:
+      return nullptr;
+  }
+}
 
 ReturnValue_t ThermalController::checkModeCommand(Mode_t mode, Submode_t submode,
                                                   uint32_t* msToReachTheMode) {
@@ -46,3 +230,647 @@ ReturnValue_t ThermalController::checkModeCommand(Mode_t mode, Submode_t submode
   }
   return RETURN_OK;
 }
+
+void ThermalController::copySensors() {
+  PoolReadGuard pg0(&max31865Set0);
+  if (pg0.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    sensorTemperatures.sensor_ploc_heatspreader.value = max31865Set0.temperatureCelcius.value;
+    sensorTemperatures.sensor_ploc_heatspreader.setValid(max31865Set0.temperatureCelcius.isValid());
+    if (not sensorTemperatures.sensor_ploc_heatspreader.isValid()) {
+      sensorTemperatures.sensor_ploc_heatspreader.value = INVALID_TEMPERATURE;
+    }
+  }
+
+  PoolReadGuard pg1(&max31865Set1);
+  if (pg1.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    sensorTemperatures.sensor_ploc_missionboard.value = max31865Set1.temperatureCelcius.value;
+    sensorTemperatures.sensor_ploc_missionboard.setValid(max31865Set1.temperatureCelcius.isValid());
+    if (not sensorTemperatures.sensor_ploc_missionboard.isValid()) {
+      sensorTemperatures.sensor_ploc_missionboard.value = INVALID_TEMPERATURE;
+    }
+  }
+
+  PoolReadGuard pg2(&max31865Set2);
+  if (pg2.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    sensorTemperatures.sensor_4k_camera.value = max31865Set2.temperatureCelcius.value;
+    sensorTemperatures.sensor_4k_camera.setValid(max31865Set2.temperatureCelcius.isValid());
+    if (not sensorTemperatures.sensor_4k_camera.isValid()) {
+      sensorTemperatures.sensor_4k_camera.value = INVALID_TEMPERATURE;
+    }
+  }
+
+  PoolReadGuard pg3(&max31865Set3);
+  if (pg3.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    sensorTemperatures.sensor_dac_heatspreader.value = max31865Set3.temperatureCelcius.value;
+    sensorTemperatures.sensor_dac_heatspreader.setValid(max31865Set3.temperatureCelcius.isValid());
+    if (not sensorTemperatures.sensor_dac_heatspreader.isValid()) {
+      sensorTemperatures.sensor_dac_heatspreader.value = INVALID_TEMPERATURE;
+    }
+  }
+
+  PoolReadGuard pg4(&max31865Set4);
+  if (pg4.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    sensorTemperatures.sensor_startracker.value = max31865Set4.temperatureCelcius.value;
+    sensorTemperatures.sensor_startracker.setValid(max31865Set4.temperatureCelcius.isValid());
+    if (not sensorTemperatures.sensor_startracker.isValid()) {
+      sensorTemperatures.sensor_startracker.value = INVALID_TEMPERATURE;
+    }
+  }
+
+  PoolReadGuard pg5(&max31865Set5);
+  if (pg5.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    sensorTemperatures.sensor_rw1.value = max31865Set5.temperatureCelcius.value;
+    sensorTemperatures.sensor_rw1.setValid(max31865Set5.temperatureCelcius.isValid());
+    if (not sensorTemperatures.sensor_rw1.isValid()) {
+      sensorTemperatures.sensor_rw1.value = INVALID_TEMPERATURE;
+    }
+  }
+
+  PoolReadGuard pg6(&max31865Set6);
+  if (pg6.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    sensorTemperatures.sensor_dro.value = max31865Set6.temperatureCelcius.value;
+    sensorTemperatures.sensor_dro.setValid(max31865Set6.temperatureCelcius.isValid());
+    if (not sensorTemperatures.sensor_dro.isValid()) {
+      sensorTemperatures.sensor_dro.value = INVALID_TEMPERATURE;
+    }
+  }
+
+  PoolReadGuard pg7(&max31865Set7);
+  if (pg7.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    sensorTemperatures.sensor_scex.value = max31865Set7.temperatureCelcius.value;
+    sensorTemperatures.sensor_scex.setValid(max31865Set7.temperatureCelcius.isValid());
+    if (not sensorTemperatures.sensor_scex.isValid()) {
+      sensorTemperatures.sensor_scex.value = INVALID_TEMPERATURE;
+    }
+  }
+
+  PoolReadGuard pg8(&max31865Set8);
+  if (pg8.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    sensorTemperatures.sensor_x8.value = max31865Set8.temperatureCelcius.value;
+    sensorTemperatures.sensor_x8.setValid(max31865Set8.temperatureCelcius.isValid());
+    if (not sensorTemperatures.sensor_x8.isValid()) {
+      sensorTemperatures.sensor_x8.value = INVALID_TEMPERATURE;
+    }
+  }
+
+  PoolReadGuard pg9(&max31865Set9);
+  if (pg9.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    sensorTemperatures.sensor_hpa.value = max31865Set9.temperatureCelcius.value;
+    sensorTemperatures.sensor_hpa.setValid(max31865Set9.temperatureCelcius.isValid());
+    if (not sensorTemperatures.sensor_hpa.isValid()) {
+      sensorTemperatures.sensor_hpa.value = INVALID_TEMPERATURE;
+    }
+  }
+
+  PoolReadGuard pg10(&max31865Set10);
+  if (pg10.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    sensorTemperatures.sensor_tx_modul.value = max31865Set10.temperatureCelcius.value;
+    sensorTemperatures.sensor_tx_modul.setValid(max31865Set10.temperatureCelcius.isValid());
+    if (not sensorTemperatures.sensor_tx_modul.isValid()) {
+      sensorTemperatures.sensor_tx_modul.value = INVALID_TEMPERATURE;
+    }
+  }
+
+  PoolReadGuard pg11(&max31865Set11);
+  if (pg11.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    sensorTemperatures.sensor_mpa.value = max31865Set11.temperatureCelcius.value;
+    sensorTemperatures.sensor_mpa.setValid(max31865Set11.temperatureCelcius.isValid());
+    if (not sensorTemperatures.sensor_mpa.isValid()) {
+      sensorTemperatures.sensor_mpa.value = INVALID_TEMPERATURE;
+    }
+  }
+
+  PoolReadGuard pg12(&max31865Set12);
+  if (pg12.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    sensorTemperatures.sensor_acu.value = max31865Set12.temperatureCelcius.value;
+    sensorTemperatures.sensor_acu.setValid(max31865Set12.temperatureCelcius.isValid());
+    if (not sensorTemperatures.sensor_acu.isValid()) {
+      sensorTemperatures.sensor_acu.value = INVALID_TEMPERATURE;
+    }
+  }
+
+  PoolReadGuard pg13(&max31865Set13);
+  if (pg13.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    sensorTemperatures.sensor_plpcdu_heatspreader.value = max31865Set13.temperatureCelcius.value;
+    sensorTemperatures.sensor_plpcdu_heatspreader.setValid(
+        max31865Set13.temperatureCelcius.isValid());
+    if (not sensorTemperatures.sensor_plpcdu_heatspreader.isValid()) {
+      sensorTemperatures.sensor_plpcdu_heatspreader.value = INVALID_TEMPERATURE;
+    }
+  }
+
+  PoolReadGuard pg14(&max31865Set14);
+  if (pg14.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    sensorTemperatures.sensor_tcs_board.value = max31865Set14.temperatureCelcius.value;
+    sensorTemperatures.sensor_tcs_board.setValid(max31865Set14.temperatureCelcius.isValid());
+    if (not sensorTemperatures.sensor_tcs_board.isValid()) {
+      sensorTemperatures.sensor_tcs_board.value = INVALID_TEMPERATURE;
+    }
+  }
+
+  PoolReadGuard pg15(&max31865Set15);
+  if (pg15.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    sensorTemperatures.sensor_magnettorquer.value = max31865Set15.temperatureCelcius.value;
+    sensorTemperatures.sensor_magnettorquer.setValid(max31865Set15.temperatureCelcius.isValid());
+    if (not sensorTemperatures.sensor_magnettorquer.isValid()) {
+      sensorTemperatures.sensor_magnettorquer.value = INVALID_TEMPERATURE;
+    }
+  }
+  PoolReadGuard pg111(&tmp1075Set1);
+  if (pg1.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    sensorTemperatures.sensor_tmp1075_1.value = tmp1075Set1.temperatureCelcius.value;
+    sensorTemperatures.sensor_tmp1075_1.setValid(tmp1075Set1.temperatureCelcius.isValid());
+    if (not tmp1075Set1.temperatureCelcius.isValid()) {
+      sensorTemperatures.sensor_tmp1075_1.value = INVALID_TEMPERATURE;
+    }
+  }
+  PoolReadGuard pg112(&tmp1075Set2);
+  if (pg2.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    sensorTemperatures.sensor_tmp1075_2.value = tmp1075Set2.temperatureCelcius.value;
+    sensorTemperatures.sensor_tmp1075_2.setValid(tmp1075Set2.temperatureCelcius.isValid());
+    if (not tmp1075Set2.temperatureCelcius.isValid()) {
+      sensorTemperatures.sensor_tmp1075_2.value = INVALID_TEMPERATURE;
+    }
+  }
+}
+
+void ThermalController::copySus() {
+  PoolReadGuard pg0(&susSet0);
+  if (pg0.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    susTemperatures.sus_0_n_loc_xfyfzm_pt_xf.value = susSet0.temperatureCelcius.value;
+    susTemperatures.sus_0_n_loc_xfyfzm_pt_xf.setValid(susSet0.temperatureCelcius.isValid());
+    if (not susTemperatures.sus_0_n_loc_xfyfzm_pt_xf.isValid()) {
+      susTemperatures.sus_0_n_loc_xfyfzm_pt_xf.value = INVALID_TEMPERATURE;
+    }
+  }
+
+  PoolReadGuard pg1(&susSet1);
+  if (pg1.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    susTemperatures.sus_6_r_loc_xfybzm_pt_xf.value = susSet1.temperatureCelcius.value;
+    susTemperatures.sus_6_r_loc_xfybzm_pt_xf.setValid(susSet1.temperatureCelcius.isValid());
+    if (not susTemperatures.sus_6_r_loc_xfybzm_pt_xf.isValid()) {
+      susTemperatures.sus_6_r_loc_xfybzm_pt_xf.value = INVALID_TEMPERATURE;
+    }
+  }
+
+  PoolReadGuard pg2(&susSet2);
+  if (pg2.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    susTemperatures.sus_1_n_loc_xbyfzm_pt_xb.value = susSet2.temperatureCelcius.value;
+    susTemperatures.sus_1_n_loc_xbyfzm_pt_xb.setValid(susSet2.temperatureCelcius.isValid());
+    if (not susTemperatures.sus_1_n_loc_xbyfzm_pt_xb.isValid()) {
+      susTemperatures.sus_1_n_loc_xbyfzm_pt_xb.value = INVALID_TEMPERATURE;
+    }
+  }
+
+  PoolReadGuard pg3(&susSet3);
+  if (pg3.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    susTemperatures.sus_7_r_loc_xbybzm_pt_xb.value = susSet3.temperatureCelcius.value;
+    susTemperatures.sus_7_r_loc_xbybzm_pt_xb.setValid(susSet3.temperatureCelcius.isValid());
+    if (not susTemperatures.sus_7_r_loc_xbybzm_pt_xb.isValid()) {
+      susTemperatures.sus_7_r_loc_xbybzm_pt_xb.value = INVALID_TEMPERATURE;
+    }
+  }
+
+  PoolReadGuard pg4(&susSet4);
+  if (pg4.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    susTemperatures.sus_2_n_loc_xfybzb_pt_yb.value = susSet4.temperatureCelcius.value;
+    susTemperatures.sus_2_n_loc_xfybzb_pt_yb.setValid(susSet4.temperatureCelcius.isValid());
+    if (not susTemperatures.sus_2_n_loc_xfybzb_pt_yb.isValid()) {
+      susTemperatures.sus_2_n_loc_xfybzb_pt_yb.value = INVALID_TEMPERATURE;
+    }
+  }
+
+  PoolReadGuard pg5(&susSet5);
+  if (pg5.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    susTemperatures.sus_8_r_loc_xbybzb_pt_yb.value = susSet5.temperatureCelcius.value;
+    susTemperatures.sus_8_r_loc_xbybzb_pt_yb.setValid(susSet5.temperatureCelcius.isValid());
+    if (not susTemperatures.sus_8_r_loc_xbybzb_pt_yb.isValid()) {
+      susTemperatures.sus_8_r_loc_xbybzb_pt_yb.value = INVALID_TEMPERATURE;
+    }
+  }
+
+  PoolReadGuard pg6(&susSet6);
+  if (pg6.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    susTemperatures.sus_3_n_loc_xfybzf_pt_yf.value = susSet6.temperatureCelcius.value;
+    susTemperatures.sus_3_n_loc_xfybzf_pt_yf.setValid(susSet6.temperatureCelcius.isValid());
+    if (not susTemperatures.sus_3_n_loc_xfybzf_pt_yf.isValid()) {
+      susTemperatures.sus_3_n_loc_xfybzf_pt_yf.value = INVALID_TEMPERATURE;
+    }
+  }
+
+  PoolReadGuard pg7(&susSet7);
+  if (pg7.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    susTemperatures.sus_9_r_loc_xbybzb_pt_yf.value = susSet7.temperatureCelcius.value;
+    susTemperatures.sus_9_r_loc_xbybzb_pt_yf.setValid(susSet7.temperatureCelcius.isValid());
+    if (not susTemperatures.sus_9_r_loc_xbybzb_pt_yf.isValid()) {
+      susTemperatures.sus_9_r_loc_xbybzb_pt_yf.value = INVALID_TEMPERATURE;
+    }
+  }
+
+  PoolReadGuard pg8(&susSet8);
+  if (pg8.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    susTemperatures.sus_4_n_loc_xmyfzf_pt_zf.value = susSet8.temperatureCelcius.value;
+    susTemperatures.sus_4_n_loc_xmyfzf_pt_zf.setValid(susSet8.temperatureCelcius.isValid());
+    if (not susTemperatures.sus_4_n_loc_xmyfzf_pt_zf.isValid()) {
+      susTemperatures.sus_4_n_loc_xmyfzf_pt_zf.value = INVALID_TEMPERATURE;
+    }
+  }
+
+  PoolReadGuard pg9(&susSet9);
+  if (pg9.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    susTemperatures.sus_10_n_loc_xmybzf_pt_zf.value = susSet9.temperatureCelcius.value;
+    susTemperatures.sus_10_n_loc_xmybzf_pt_zf.setValid(susSet9.temperatureCelcius.isValid());
+    if (not susTemperatures.sus_10_n_loc_xmybzf_pt_zf.isValid()) {
+      susTemperatures.sus_10_n_loc_xmybzf_pt_zf.value = INVALID_TEMPERATURE;
+    }
+  }
+
+  PoolReadGuard pg10(&susSet10);
+  if (pg10.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    susTemperatures.sus_5_n_loc_xfymzb_pt_zb.value = susSet10.temperatureCelcius.value;
+    susTemperatures.sus_5_n_loc_xfymzb_pt_zb.setValid(susSet10.temperatureCelcius.isValid());
+    if (not susTemperatures.sus_5_n_loc_xfymzb_pt_zb.isValid()) {
+      susTemperatures.sus_5_n_loc_xfymzb_pt_zb.value = INVALID_TEMPERATURE;
+    }
+  }
+
+  PoolReadGuard pg11(&susSet11);
+  if (pg11.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    susTemperatures.sus_11_r_loc_xbymzb_pt_zb.value = susSet11.temperatureCelcius.value;
+    susTemperatures.sus_11_r_loc_xbymzb_pt_zb.setValid(susSet11.temperatureCelcius.isValid());
+    if (not susTemperatures.sus_11_r_loc_xbymzb_pt_zb.isValid()) {
+      susTemperatures.sus_11_r_loc_xbymzb_pt_zb.value = INVALID_TEMPERATURE;
+    }
+  }
+}
+
+void ThermalController::copyDevices() {
+  lp_var_t<float> tempQ7s = lp_var_t<float>(objects::CORE_CONTROLLER, core::PoolIds::TEMPERATURE);
+  ReturnValue_t result = tempQ7s.read();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to read Q7S temperature" << std::endl;
+    deviceTemperatures.q7s.setValid(false);
+    deviceTemperatures.q7s = static_cast<float>(INVALID_TEMPERATURE);
+  } else {
+    deviceTemperatures.q7s = tempQ7s;
+    deviceTemperatures.q7s.setValid(tempQ7s.isValid());
+  }
+  result = tempQ7s.commit();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to commit" << std::endl;
+  }
+  lp_var_t<int16_t> battTemp1 =
+      lp_var_t<int16_t>(objects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_1);
+  result = battTemp1.read();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to read battery temperature 1" << std::endl;
+    deviceTemperatures.batteryTemp1.setValid(false);
+    deviceTemperatures.batteryTemp1 = static_cast<float>(INVALID_TEMPERATURE);
+  } else {
+    deviceTemperatures.batteryTemp1 = battTemp1;
+    deviceTemperatures.batteryTemp1.setValid(battTemp1.isValid());
+  }
+  result = battTemp1.commit();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to commit" << std::endl;
+  }
+  lp_var_t<int16_t> battTemp2 =
+      lp_var_t<int16_t>(objects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_2);
+  result = battTemp2.read();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to read battery temperature 2" << std::endl;
+    deviceTemperatures.batteryTemp2.setValid(false);
+    deviceTemperatures.batteryTemp2 = static_cast<float>(INVALID_TEMPERATURE);
+  } else {
+    deviceTemperatures.batteryTemp2 = battTemp2;
+    deviceTemperatures.batteryTemp2.setValid(battTemp2.isValid());
+  }
+  result = battTemp2.commit();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to commit" << std::endl;
+  }
+  lp_var_t<int16_t> battTemp3 =
+      lp_var_t<int16_t>(objects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_3);
+  result = battTemp3.read();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to read battery temperature 3" << std::endl;
+    deviceTemperatures.batteryTemp3.setValid(false);
+    deviceTemperatures.batteryTemp3 = static_cast<float>(INVALID_TEMPERATURE);
+  } else {
+    deviceTemperatures.batteryTemp3 = battTemp3;
+    deviceTemperatures.batteryTemp3.setValid(battTemp3.isValid());
+  }
+  result = battTemp3.commit();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to commit" << std::endl;
+  }
+  lp_var_t<int16_t> battTemp4 =
+      lp_var_t<int16_t>(objects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_4);
+  result = battTemp4.read();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to read battery temperature 4" << std::endl;
+    deviceTemperatures.batteryTemp4.setValid(false);
+    deviceTemperatures.batteryTemp4 = static_cast<float>(INVALID_TEMPERATURE);
+  } else {
+    deviceTemperatures.batteryTemp4 = battTemp4;
+    deviceTemperatures.batteryTemp4.setValid(battTemp4.isValid());
+  }
+  result = battTemp4.commit();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to commit" << std::endl;
+  }
+  lp_var_t<int32_t> tempRw1 = lp_var_t<int32_t>(objects::RW1, RwDefinitions::TEMPERATURE_C);
+  result = tempRw1.read();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to read reaction wheel 1 temperature" << std::endl;
+    deviceTemperatures.rw1.setValid(false);
+    deviceTemperatures.rw1 = static_cast<int32_t>(INVALID_TEMPERATURE);
+  } else {
+    deviceTemperatures.rw1.setValid(tempRw1.isValid());
+    deviceTemperatures.rw1 = tempRw1;
+  }
+  result = tempRw1.commit();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to commit" << std::endl;
+  }
+  lp_var_t<int32_t> tempRw2 = lp_var_t<int32_t>(objects::RW2, RwDefinitions::TEMPERATURE_C);
+  result = tempRw2.read();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to read reaction wheel 2 temperature" << std::endl;
+    deviceTemperatures.rw2.setValid(false);
+    deviceTemperatures.rw2 = static_cast<int32_t>(INVALID_TEMPERATURE);
+  } else {
+    deviceTemperatures.rw2.setValid(tempRw2.isValid());
+    deviceTemperatures.rw2 = tempRw2;
+  }
+  result = tempRw2.commit();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to commit" << std::endl;
+  }
+  lp_var_t<int32_t> tempRw3 = lp_var_t<int32_t>(objects::RW3, RwDefinitions::TEMPERATURE_C);
+  result = tempRw3.read();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to read reaction wheel 3 temperature" << std::endl;
+    deviceTemperatures.rw3.setValid(false);
+    deviceTemperatures.rw3 = static_cast<int32_t>(INVALID_TEMPERATURE);
+  } else {
+    deviceTemperatures.rw3.setValid(tempRw3.isValid());
+    deviceTemperatures.rw3 = tempRw3;
+  }
+  result = tempRw3.commit();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to commit" << std::endl;
+  }
+  lp_var_t<int32_t> tempRw4 = lp_var_t<int32_t>(objects::RW4, RwDefinitions::TEMPERATURE_C);
+  result = tempRw4.read();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to read reaction wheel 4 temperature" << std::endl;
+    deviceTemperatures.rw4.setValid(false);
+    deviceTemperatures.rw4 = static_cast<int32_t>(INVALID_TEMPERATURE);
+  } else {
+    deviceTemperatures.rw4.setValid(tempRw4.isValid());
+    deviceTemperatures.rw4 = tempRw4;
+  }
+  result = tempRw4.commit();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to commit" << std::endl;
+  }
+  lp_var_t<float> tempStartracker =
+      lp_var_t<float>(objects::STAR_TRACKER, startracker::MCU_TEMPERATURE);
+  result = tempStartracker.read();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to read startracker temperature" << std::endl;
+    deviceTemperatures.startracker.setValid(false);
+    deviceTemperatures.startracker = static_cast<float>(INVALID_TEMPERATURE);
+  } else {
+    deviceTemperatures.startracker.setValid(tempStartracker.isValid());
+    deviceTemperatures.startracker = tempStartracker;
+  }
+  result = tempStartracker.commit();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to commit" << std::endl;
+  }
+  lp_var_t<float> tempSyrlinksPowerAmplifier =
+      lp_var_t<float>(objects::SYRLINKS_HK_HANDLER, syrlinks::TEMP_POWER_AMPLIFIER);
+  result = tempSyrlinksPowerAmplifier.read();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to read syrlinks power amplifier temperature"
+                 << std::endl;
+    deviceTemperatures.syrlinksPowerAmplifier.setValid(false);
+    deviceTemperatures.syrlinksPowerAmplifier = static_cast<float>(INVALID_TEMPERATURE);
+  } else {
+    deviceTemperatures.syrlinksPowerAmplifier.setValid(tempSyrlinksPowerAmplifier.isValid());
+    deviceTemperatures.syrlinksPowerAmplifier = tempSyrlinksPowerAmplifier;
+  }
+  result = tempSyrlinksPowerAmplifier.commit();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to commit" << std::endl;
+  }
+  lp_var_t<float> tempSyrlinksBasebandBoard =
+      lp_var_t<float>(objects::SYRLINKS_HK_HANDLER, syrlinks::TEMP_BASEBAND_BOARD);
+  result = tempSyrlinksBasebandBoard.read();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to read syrlinks baseband board temperature"
+                 << std::endl;
+    deviceTemperatures.syrlinksBasebandBoard.setValid(false);
+    deviceTemperatures.syrlinksBasebandBoard = static_cast<float>(INVALID_TEMPERATURE);
+  } else {
+    deviceTemperatures.syrlinksBasebandBoard.setValid(tempSyrlinksBasebandBoard.isValid());
+    deviceTemperatures.syrlinksBasebandBoard = tempSyrlinksBasebandBoard;
+  }
+  result = tempSyrlinksBasebandBoard.commit();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to commit" << std::endl;
+  }
+  lp_var_t<int16_t> tempMgt = lp_var_t<int16_t>(objects::IMTQ_HANDLER, IMTQ::MCU_TEMPERATURE);
+  result = tempMgt.read();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to read MGT temperature" << std::endl;
+    deviceTemperatures.mgt.setValid(false);
+    deviceTemperatures.mgt = static_cast<int16_t>(INVALID_TEMPERATURE);
+  } else {
+    deviceTemperatures.mgt.setValid(tempMgt.isValid());
+    deviceTemperatures.mgt = tempMgt;
+  }
+  result = tempMgt.commit();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to commit" << std::endl;
+  }
+  lp_vec_t<float, 3> tempAcu =
+      lp_vec_t<float, 3>(objects::ACU_HANDLER, P60System::pool::ACU_TEMPERATURES);
+  result = tempAcu.read();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to read ACU temperatures" << std::endl;
+    deviceTemperatures.acu.setValid(false);
+    deviceTemperatures.acu[0] = static_cast<float>(INVALID_TEMPERATURE);
+    deviceTemperatures.acu[1] = static_cast<float>(INVALID_TEMPERATURE);
+    deviceTemperatures.acu[2] = static_cast<float>(INVALID_TEMPERATURE);
+  } else {
+    deviceTemperatures.acu.setValid(tempAcu.isValid());
+    deviceTemperatures.acu = tempAcu;
+  }
+  result = tempAcu.commit();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to commit" << std::endl;
+  }
+  lp_var_t<float> tempPdu1 =
+      lp_var_t<float>(objects::PDU1_HANDLER, P60System::pool::PDU_TEMPERATURE);
+  result = tempPdu1.read();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to read PDU1 temperature" << std::endl;
+    deviceTemperatures.pdu1.setValid(false);
+    deviceTemperatures.pdu1 = static_cast<float>(INVALID_TEMPERATURE);
+  } else {
+    deviceTemperatures.pdu1.setValid(tempPdu1.isValid());
+    deviceTemperatures.pdu1 = tempPdu1;
+  }
+  result = tempPdu1.commit();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to commit" << std::endl;
+  }
+  lp_var_t<float> tempPdu2 =
+      lp_var_t<float>(objects::PDU2_HANDLER, P60System::pool::PDU_TEMPERATURE);
+  result = tempPdu2.read();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to read PDU2 temperature" << std::endl;
+    deviceTemperatures.pdu2.setValid(false);
+    deviceTemperatures.pdu2 = static_cast<float>(INVALID_TEMPERATURE);
+  } else {
+    deviceTemperatures.pdu2.setValid(tempPdu1.isValid());
+    deviceTemperatures.pdu2 = tempPdu1;
+  }
+  result = tempPdu2.commit();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to commit" << std::endl;
+  }
+  lp_var_t<float> temp1P60dock =
+      lp_var_t<float>(objects::P60DOCK_HANDLER, P60System::pool::P60DOCK_TEMPERATURE_1);
+  result = temp1P60dock.read();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to read P60 dock temperature 1" << std::endl;
+    deviceTemperatures.temp1P60dock.setValid(false);
+    deviceTemperatures.temp1P60dock = static_cast<float>(INVALID_TEMPERATURE);
+  } else {
+    deviceTemperatures.temp1P60dock.setValid(temp1P60dock.isValid());
+    deviceTemperatures.temp1P60dock = temp1P60dock;
+  }
+  result = temp1P60dock.commit();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to commit" << std::endl;
+  }
+  lp_var_t<float> temp2P60dock =
+      lp_var_t<float>(objects::P60DOCK_HANDLER, P60System::pool::P60DOCK_TEMPERATURE_2);
+  result = temp2P60dock.read();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to read P60 dock temperature 2" << std::endl;
+    deviceTemperatures.temp2P60dock.setValid(false);
+    deviceTemperatures.temp2P60dock = static_cast<float>(INVALID_TEMPERATURE);
+  } else {
+    deviceTemperatures.temp2P60dock.setValid(temp2P60dock.isValid());
+    deviceTemperatures.temp2P60dock = temp2P60dock;
+  }
+  result = temp2P60dock.commit();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to commit" << std::endl;
+  }
+  lp_var_t<float> tempGyro0 = lp_var_t<float>(objects::GYRO_0_ADIS_HANDLER, ADIS1650X::TEMPERATURE);
+  result = tempGyro0.read();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to read gyro 0 temperature" << std::endl;
+    deviceTemperatures.gyro0SideA.setValid(false);
+    deviceTemperatures.gyro0SideA = static_cast<float>(INVALID_TEMPERATURE);
+  } else {
+    deviceTemperatures.gyro0SideA.setValid(tempGyro0.isValid());
+    deviceTemperatures.gyro0SideA = tempGyro0;
+  }
+  result = tempGyro0.commit();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to commit" << std::endl;
+  }
+  lp_var_t<float> tempGyro1 = lp_var_t<float>(objects::GYRO_1_L3G_HANDLER, L3GD20H::TEMPERATURE);
+  result = tempGyro1.read();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to read gyro 1 temperature" << std::endl;
+    deviceTemperatures.gyro1SideA.setValid(false);
+    deviceTemperatures.gyro1SideA = static_cast<float>(INVALID_TEMPERATURE);
+  } else {
+    deviceTemperatures.gyro1SideA.setValid(tempGyro1.isValid());
+    deviceTemperatures.gyro1SideA = tempGyro1;
+  }
+  result = tempGyro1.commit();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to commit" << std::endl;
+  }
+  lp_var_t<float> tempGyro2 = lp_var_t<float>(objects::GYRO_2_ADIS_HANDLER, ADIS1650X::TEMPERATURE);
+  result = tempGyro2.read();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to read gyro 2 temperature" << std::endl;
+    deviceTemperatures.gyro2SideB.setValid(false);
+    deviceTemperatures.gyro2SideB = static_cast<float>(INVALID_TEMPERATURE);
+  } else {
+    deviceTemperatures.gyro2SideB.setValid(tempGyro2.isValid());
+    deviceTemperatures.gyro2SideB = tempGyro2;
+  }
+  result = tempGyro2.commit();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to commit" << std::endl;
+  }
+  lp_var_t<float> tempGyro3 = lp_var_t<float>(objects::GYRO_3_L3G_HANDLER, L3GD20H::TEMPERATURE);
+  result = tempGyro3.read();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to read gyro 3 temperature" << std::endl;
+    deviceTemperatures.gyro3SideB.setValid(false);
+    deviceTemperatures.gyro3SideB = static_cast<float>(INVALID_TEMPERATURE);
+  } else {
+    deviceTemperatures.gyro3SideB.setValid(tempGyro3.isValid());
+    deviceTemperatures.gyro3SideB = tempGyro3;
+  }
+  result = tempGyro3.commit();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to commit" << std::endl;
+  }
+  lp_var_t<float> tempMgm0 =
+      lp_var_t<float>(objects::MGM_0_LIS3_HANDLER, MGMLIS3MDL::TEMPERATURE_CELCIUS);
+  result = tempMgm0.read();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to read MGM 0 temperature" << std::endl;
+    deviceTemperatures.mgm0SideA.setValid(false);
+    deviceTemperatures.mgm0SideA = static_cast<float>(INVALID_TEMPERATURE);
+  } else {
+    deviceTemperatures.mgm0SideA.setValid(tempMgm0.isValid());
+    deviceTemperatures.mgm0SideA = tempMgm0;
+  }
+  result = tempMgm0.commit();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to commit" << std::endl;
+  }
+  lp_var_t<float> tempMgm2 =
+      lp_var_t<float>(objects::MGM_2_LIS3_HANDLER, MGMLIS3MDL::TEMPERATURE_CELCIUS);
+  result = tempMgm2.read();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to read MGM 2 temperature" << std::endl;
+    deviceTemperatures.mgm2SideB.setValid(false);
+    deviceTemperatures.mgm2SideB = static_cast<float>(INVALID_TEMPERATURE);
+  } else {
+    deviceTemperatures.mgm2SideB.setValid(tempMgm2.isValid());
+    deviceTemperatures.mgm2SideB = tempMgm2;
+  }
+  result = tempMgm2.commit();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to commit" << std::endl;
+  }
+  lp_var_t<float> tempAdcPayloadPcdu = lp_var_t<float>(objects::PLPCDU_HANDLER, plpcdu::TEMP);
+  result = tempAdcPayloadPcdu.read();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to read payload PCDU ADC temperature" << std::endl;
+    deviceTemperatures.adcPayloadPcdu.setValid(false);
+    deviceTemperatures.adcPayloadPcdu = static_cast<float>(INVALID_TEMPERATURE);
+  } else {
+    deviceTemperatures.adcPayloadPcdu.setValid(tempAdcPayloadPcdu.isValid());
+    deviceTemperatures.adcPayloadPcdu = tempAdcPayloadPcdu;
+  }
+  result = tempAdcPayloadPcdu.commit();
+  if (result != RETURN_OK) {
+    sif::warning << "ThermalController: Failed to commit" << std::endl;
+  }
+}

mission/controller/ThermalController.h

@@ -2,10 +2,16 @@
 #define MISSION_CONTROLLER_THERMALCONTROLLER_H_
 
 #include <fsfw/controller/ExtendedControllerBase.h>
+#include <fsfw/timemanager/Countdown.h>
 #include <mission/controller/controllerdefinitions/ThermalControllerDefinitions.h>
+#include <mission/devices/devicedefinitions/Max31865Definitions.h>
+#include <mission/devices/devicedefinitions/SusDefinitions.h>
+#include <mission/devices/devicedefinitions/Tmp1075Definitions.h>
 
 class ThermalController : public ExtendedControllerBase {
  public:
+  static const uint16_t INVALID_TEMPERATURE = 999;
+
   ThermalController(object_id_t objectId, object_id_t parentId);
 
   ReturnValue_t initialize() override;
@@ -22,8 +28,56 @@ class ThermalController : public ExtendedControllerBase {
                                          uint32_t* msToReachTheMode) override;
 
  private:
+  static const uint32_t DELAY = 500;
+
+  enum class InternalState { STARTUP, INITIAL_DELAY, READY };
+
+  InternalState internalState = InternalState::STARTUP;
+
   thermalControllerDefinitions::SensorTemperatures sensorTemperatures;
-  thermalControllerDefinitions::ComponentTemperatures componentTemperatures;
+  thermalControllerDefinitions::SusTemperatures susTemperatures;
+  thermalControllerDefinitions::DeviceTemperatures deviceTemperatures;
+
+  // Temperature Sensors
+  MAX31865::Max31865Set max31865Set0;
+  MAX31865::Max31865Set max31865Set1;
+  MAX31865::Max31865Set max31865Set2;
+  MAX31865::Max31865Set max31865Set3;
+  MAX31865::Max31865Set max31865Set4;
+  MAX31865::Max31865Set max31865Set5;
+  MAX31865::Max31865Set max31865Set6;
+  MAX31865::Max31865Set max31865Set7;
+  MAX31865::Max31865Set max31865Set8;
+  MAX31865::Max31865Set max31865Set9;
+  MAX31865::Max31865Set max31865Set10;
+  MAX31865::Max31865Set max31865Set11;
+  MAX31865::Max31865Set max31865Set12;
+  MAX31865::Max31865Set max31865Set13;
+  MAX31865::Max31865Set max31865Set14;
+  MAX31865::Max31865Set max31865Set15;
+  TMP1075::Tmp1075Dataset tmp1075Set1;
+  TMP1075::Tmp1075Dataset tmp1075Set2;
+
+  // SUS
+  SUS::SusDataset susSet0;
+  SUS::SusDataset susSet1;
+  SUS::SusDataset susSet2;
+  SUS::SusDataset susSet3;
+  SUS::SusDataset susSet4;
+  SUS::SusDataset susSet5;
+  SUS::SusDataset susSet6;
+  SUS::SusDataset susSet7;
+  SUS::SusDataset susSet8;
+  SUS::SusDataset susSet9;
+  SUS::SusDataset susSet10;
+  SUS::SusDataset susSet11;
+
+  // Initial delay to make sure all pool variables have been initialized their owners
+  Countdown initialCountdown = Countdown(DELAY);
+
+  void copySensors();
+  void copySus();
+  void copyDevices();
 };
 
 #endif /* MISSION_CONTROLLER_THERMALCONTROLLER_H_ */

mission/controller/controllerdefinitions/ThermalControllerDefinitions.h

@@ -6,36 +6,190 @@
 
 namespace thermalControllerDefinitions {
 
-enum SetIds : uint32_t { SENSOR_TEMPERATURES, COMPONENT_TEMPERATURES };
+enum SetIds : uint32_t {
+  SENSOR_TEMPERATURES,
+  DEVICE_TEMPERATURES,
+  SUS_TEMPERATURES,
+  COMPONENT_TEMPERATURES
+};
 
-enum PoolIds : lp_id_t { SENSOR_RW, SENSOR_GPS, COMPONENT_RW };
+enum PoolIds : lp_id_t {
+  SENSOR_PLOC_HEATSPREADER,
+  SENSOR_PLOC_MISSIONBOARD,
+  SENSOR_4K_CAMERA,
+  SENSOR_DAC_HEATSPREADER,
+  SENSOR_STARTRACKER,
+  SENSOR_RW1,
+  SENSOR_DRO,
+  SENSOR_SCEX,
+  SENSOR_X8,
+  SENSOR_HPA,
+  SENSOR_TX_MODUL,
+  SENSOR_MPA,
+  SENSOR_ACU,
+  SENSOR_PLPCDU_HEATSPREADER,
+  SENSOR_TCS_BOARD,
+  SENSOR_MAGNETTORQUER,
+  SENSOR_TMP1075_1,
+  SENSOR_TMP1075_2,
+
+  SUS_0_N_LOC_XFYFZM_PT_XF,
+  SUS_6_R_LOC_XFYBZM_PT_XF,
+  SUS_1_N_LOC_XBYFZM_PT_XB,
+  SUS_7_R_LOC_XBYBZM_PT_XB,
+  SUS_2_N_LOC_XFYBZB_PT_YB,
+  SUS_8_R_LOC_XBYBZB_PT_YB,
+  SUS_3_N_LOC_XFYBZF_PT_YF,
+  SUS_9_R_LOC_XBYBZB_PT_YF,
+  SUS_4_N_LOC_XMYFZF_PT_ZF,
+  SUS_10_N_LOC_XMYBZF_PT_ZF,
+  SUS_5_N_LOC_XFYMZB_PT_ZB,
+  SUS_11_R_LOC_XBYMZB_PT_ZB,
+
+  COMPONENT_RW,
+
+  TEMP_Q7S,
+  BATTERY_TEMP_1,
+  BATTERY_TEMP_2,
+  BATTERY_TEMP_3,
+  BATTERY_TEMP_4,
+  TEMP_RW1,
+  TEMP_RW2,
+  TEMP_RW3,
+  TEMP_RW4,
+  TEMP_STAR_TRACKER,
+  TEMP_SYRLINKS_POWER_AMPLIFIER,
+  TEMP_SYRLINKS_BASEBAND_BOARD,
+  TEMP_MGT,
+  TEMP_ACU,
+  TEMP_PDU1,
+  TEMP_PDU2,
+  TEMP_1_P60DOCK,
+  TEMP_2_P60DOCK,
+  TEMP_GYRO_0_SIDE_A,
+  TEMP_GYRO_1_SIDE_A,
+  TEMP_GYRO_2_SIDE_B,
+  TEMP_GYRO_3_SIDE_B,
+  TEMP_MGM_0_SIDE_A,
+  TEMP_MGM_2_SIDE_B,
+  TEMP_ADC_PAYLOAD_PCDU
+};
+
+static const uint8_t ENTRIES_SENSOR_TEMPERATURE_SET = 18;
+static const uint8_t ENTRIES_DEVICE_TEMPERATURE_SET = 25;
+static const uint8_t ENTRIES_SUS_TEMPERATURE_SET = 12;
 
 /**
  * @brief   This dataset can be used to store the collected temperatures of all temperature sensors
  */
-class SensorTemperatures : public StaticLocalDataSet<2> {
+class SensorTemperatures : public StaticLocalDataSet<ENTRIES_SENSOR_TEMPERATURE_SET> {
  public:
   SensorTemperatures(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, SENSOR_TEMPERATURES) {}
 
   SensorTemperatures(object_id_t objectId)
       : StaticLocalDataSet(sid_t(objectId, SENSOR_TEMPERATURES)) {}
 
-  lp_var_t<float> rw = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_RW, this);
-  lp_var_t<float> gps = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_GPS, this);
+  lp_var_t<float> sensor_ploc_heatspreader =
+      lp_var_t<float>(sid.objectId, PoolIds::SENSOR_PLOC_HEATSPREADER, this);
+  lp_var_t<float> sensor_ploc_missionboard =
+      lp_var_t<float>(sid.objectId, PoolIds::SENSOR_PLOC_MISSIONBOARD, this);
+  lp_var_t<float> sensor_4k_camera = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_4K_CAMERA, this);
+  lp_var_t<float> sensor_dac_heatspreader =
+      lp_var_t<float>(sid.objectId, PoolIds::SENSOR_DAC_HEATSPREADER, this);
+  lp_var_t<float> sensor_startracker =
+      lp_var_t<float>(sid.objectId, PoolIds::SENSOR_STARTRACKER, this);
+  lp_var_t<float> sensor_rw1 = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_RW1, this);
+  lp_var_t<float> sensor_dro = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_DRO, this);
+  lp_var_t<float> sensor_scex = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_SCEX, this);
+  lp_var_t<float> sensor_x8 = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_X8, this);
+  lp_var_t<float> sensor_hpa = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_HPA, this);
+  lp_var_t<float> sensor_tx_modul = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_TX_MODUL, this);
+  lp_var_t<float> sensor_mpa = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_MPA, this);
+  lp_var_t<float> sensor_acu = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_ACU, this);
+  lp_var_t<float> sensor_plpcdu_heatspreader =
+      lp_var_t<float>(sid.objectId, PoolIds::SENSOR_PLPCDU_HEATSPREADER, this);
+  lp_var_t<float> sensor_tcs_board = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_TCS_BOARD, this);
+  lp_var_t<float> sensor_magnettorquer =
+      lp_var_t<float>(sid.objectId, PoolIds::SENSOR_MAGNETTORQUER, this);
+  lp_var_t<float> sensor_tmp1075_1 = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_TMP1075_1, this);
+  lp_var_t<float> sensor_tmp1075_2 = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_TMP1075_2, this);
 };
 
 /**
- * @brief   This dataset can be used to store the collected temperatures of all components
+ * @brief   This dataset can be used to store the collected temperatures of all device temperature
+ *          sensors
  */
-class ComponentTemperatures : public StaticLocalDataSet<2> {
+class DeviceTemperatures : public StaticLocalDataSet<ENTRIES_DEVICE_TEMPERATURE_SET> {
  public:
-  ComponentTemperatures(HasLocalDataPoolIF* owner)
-      : StaticLocalDataSet(owner, SENSOR_TEMPERATURES) {}
+  DeviceTemperatures(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, DEVICE_TEMPERATURES) {}
 
-  ComponentTemperatures(object_id_t objectId)
-      : StaticLocalDataSet(sid_t(objectId, SENSOR_TEMPERATURES)) {}
+  DeviceTemperatures(object_id_t objectId)
+      : StaticLocalDataSet(sid_t(objectId, DEVICE_TEMPERATURES)) {}
 
-  lp_var_t<float> rw = lp_var_t<float>(sid.objectId, PoolIds::COMPONENT_RW, this);
+  lp_var_t<float> q7s = lp_var_t<float>(sid.objectId, PoolIds::TEMP_Q7S, this);
+  lp_var_t<int16_t> batteryTemp1 = lp_var_t<int16_t>(sid.objectId, PoolIds::BATTERY_TEMP_1, this);
+  lp_var_t<int16_t> batteryTemp2 = lp_var_t<int16_t>(sid.objectId, PoolIds::BATTERY_TEMP_2, this);
+  lp_var_t<int16_t> batteryTemp3 = lp_var_t<int16_t>(sid.objectId, PoolIds::BATTERY_TEMP_3, this);
+  lp_var_t<int16_t> batteryTemp4 = lp_var_t<int16_t>(sid.objectId, PoolIds::BATTERY_TEMP_4, this);
+  lp_var_t<int32_t> rw1 = lp_var_t<int32_t>(sid.objectId, PoolIds::TEMP_RW1, this);
+  lp_var_t<int32_t> rw2 = lp_var_t<int32_t>(sid.objectId, PoolIds::TEMP_RW2, this);
+  lp_var_t<int32_t> rw3 = lp_var_t<int32_t>(sid.objectId, PoolIds::TEMP_RW3, this);
+  lp_var_t<int32_t> rw4 = lp_var_t<int32_t>(sid.objectId, PoolIds::TEMP_RW4, this);
+  lp_var_t<float> startracker = lp_var_t<float>(sid.objectId, PoolIds::TEMP_STAR_TRACKER, this);
+  lp_var_t<float> syrlinksPowerAmplifier =
+      lp_var_t<float>(sid.objectId, PoolIds::TEMP_SYRLINKS_POWER_AMPLIFIER, this);
+  lp_var_t<float> syrlinksBasebandBoard =
+      lp_var_t<float>(sid.objectId, PoolIds::TEMP_SYRLINKS_BASEBAND_BOARD, this);
+  lp_var_t<int16_t> mgt = lp_var_t<int16_t>(sid.objectId, PoolIds::TEMP_MGT, this);
+  lp_vec_t<float, 3> acu = lp_vec_t<float, 3>(sid.objectId, PoolIds::TEMP_ACU, this);
+  lp_var_t<float> pdu1 = lp_var_t<float>(sid.objectId, PoolIds::TEMP_PDU1, this);
+  lp_var_t<float> pdu2 = lp_var_t<float>(sid.objectId, PoolIds::TEMP_PDU2, this);
+  lp_var_t<float> temp1P60dock = lp_var_t<float>(sid.objectId, PoolIds::TEMP_1_P60DOCK, this);
+  lp_var_t<float> temp2P60dock = lp_var_t<float>(sid.objectId, PoolIds::TEMP_2_P60DOCK, this);
+  lp_var_t<float> gyro0SideA = lp_var_t<float>(sid.objectId, PoolIds::TEMP_GYRO_0_SIDE_A, this);
+  lp_var_t<float> gyro1SideA = lp_var_t<float>(sid.objectId, PoolIds::TEMP_GYRO_1_SIDE_A, this);
+  lp_var_t<float> gyro2SideB = lp_var_t<float>(sid.objectId, PoolIds::TEMP_GYRO_2_SIDE_B, this);
+  lp_var_t<float> gyro3SideB = lp_var_t<float>(sid.objectId, PoolIds::TEMP_GYRO_3_SIDE_B, this);
+  lp_var_t<float> mgm0SideA = lp_var_t<float>(sid.objectId, PoolIds::TEMP_MGM_0_SIDE_A, this);
+  lp_var_t<float> mgm2SideB = lp_var_t<float>(sid.objectId, PoolIds::TEMP_MGM_2_SIDE_B, this);
+  lp_var_t<float> adcPayloadPcdu =
+      lp_var_t<float>(sid.objectId, PoolIds::TEMP_ADC_PAYLOAD_PCDU, this);
+};
+
+/**
+ * @brief   This dataset can be used to store the collected temperatures of all SUS temperature
+ * sensors
+ */
+class SusTemperatures : public StaticLocalDataSet<ENTRIES_SUS_TEMPERATURE_SET> {
+ public:
+  SusTemperatures(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, SUS_TEMPERATURES) {}
+
+  SusTemperatures(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, SUS_TEMPERATURES)) {}
+
+  lp_var_t<float> sus_0_n_loc_xfyfzm_pt_xf =
+      lp_var_t<float>(sid.objectId, PoolIds::SUS_0_N_LOC_XFYFZM_PT_XF, this);
+  lp_var_t<float> sus_6_r_loc_xfybzm_pt_xf =
+      lp_var_t<float>(sid.objectId, PoolIds::SUS_6_R_LOC_XFYBZM_PT_XF, this);
+  lp_var_t<float> sus_1_n_loc_xbyfzm_pt_xb =
+      lp_var_t<float>(sid.objectId, PoolIds::SUS_1_N_LOC_XBYFZM_PT_XB, this);
+  lp_var_t<float> sus_7_r_loc_xbybzm_pt_xb =
+      lp_var_t<float>(sid.objectId, PoolIds::SUS_7_R_LOC_XBYBZM_PT_XB, this);
+  lp_var_t<float> sus_2_n_loc_xfybzb_pt_yb =
+      lp_var_t<float>(sid.objectId, PoolIds::SUS_2_N_LOC_XFYBZB_PT_YB, this);
+  lp_var_t<float> sus_8_r_loc_xbybzb_pt_yb =
+      lp_var_t<float>(sid.objectId, PoolIds::SUS_8_R_LOC_XBYBZB_PT_YB, this);
+  lp_var_t<float> sus_3_n_loc_xfybzf_pt_yf =
+      lp_var_t<float>(sid.objectId, PoolIds::SUS_3_N_LOC_XFYBZF_PT_YF, this);
+  lp_var_t<float> sus_9_r_loc_xbybzb_pt_yf =
+      lp_var_t<float>(sid.objectId, PoolIds::SUS_9_R_LOC_XBYBZB_PT_YF, this);
+  lp_var_t<float> sus_4_n_loc_xmyfzf_pt_zf =
+      lp_var_t<float>(sid.objectId, PoolIds::SUS_4_N_LOC_XMYFZF_PT_ZF, this);
+  lp_var_t<float> sus_10_n_loc_xmybzf_pt_zf =
+      lp_var_t<float>(sid.objectId, PoolIds::SUS_10_N_LOC_XMYBZF_PT_ZF, this);
+  lp_var_t<float> sus_5_n_loc_xfymzb_pt_zb =
+      lp_var_t<float>(sid.objectId, PoolIds::SUS_5_N_LOC_XFYMZB_PT_ZB, this);
+  lp_var_t<float> sus_11_r_loc_xbymzb_pt_zb =
+      lp_var_t<float>(sid.objectId, PoolIds::SUS_11_R_LOC_XBYMZB_PT_ZB, this);
 };
 
 }  // namespace thermalControllerDefinitions

mission/devices/ACUHandler.cpp

@@ -75,7 +75,8 @@ ReturnValue_t ACUHandler::parseHkTableReply(const uint8_t *packet) {
   dataOffset += 4;
 
   for (size_t idx = 0; idx < 3; idx++) {
-    coreHk.temperatures[idx] = (packet[dataOffset] << 8) | packet[dataOffset + 1];
+    coreHk.temperatures[idx] =
+        static_cast<int16_t>((packet[dataOffset] << 8) | packet[dataOffset + 1]) * 0.1;
     dataOffset += 4;
   }
 
@@ -146,7 +147,7 @@ ReturnValue_t ACUHandler::initializeLocalDataPool(localpool::DataPool &localData
   localDataPoolMap.emplace(pool::ACU_VCC, new PoolEntry<uint16_t>({0}));
   localDataPoolMap.emplace(pool::ACU_VBAT, new PoolEntry<uint16_t>({0}));
 
-  localDataPoolMap.emplace(pool::ACU_TEMPERATURES, new PoolEntry<int16_t>(3));
+  localDataPoolMap.emplace(pool::ACU_TEMPERATURES, new PoolEntry<float>(3));
 
   localDataPoolMap.emplace(pool::ACU_MPPT_MODE, new PoolEntry<uint8_t>({0}));
 

mission/devices/GomspaceDeviceHandler.cpp

@@ -366,7 +366,7 @@ ReturnValue_t GomspaceDeviceHandler::initializePduPool(
 
   localDataPoolMap.emplace(P60System::pool::PDU_VCC, new PoolEntry<int16_t>({0}));
   localDataPoolMap.emplace(P60System::pool::PDU_VBAT, new PoolEntry<int16_t>({0}));
-  localDataPoolMap.emplace(P60System::pool::PDU_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(P60System::pool::PDU_TEMPERATURE, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(P60System::pool::PDU_CONV_EN, new PoolEntry<uint8_t>(3));
 
   localDataPoolMap.emplace(P60System::pool::PDU_OUT_ENABLE,
@@ -472,7 +472,8 @@ ReturnValue_t GomspaceDeviceHandler::parsePduHkTable(PDU::PduCoreHk& coreHk, PDU
   dataOffset += 4;
   auxHk.vbat = *(packet + dataOffset) << 8 | *(packet + dataOffset + 1);
   dataOffset += 4;
-  coreHk.temperature = *(packet + dataOffset) << 8 | *(packet + dataOffset + 1);
+  coreHk.temperature =
+      static_cast<int16_t>(*(packet + dataOffset) << 8 | *(packet + dataOffset + 1)) * 0.1;
   dataOffset += 4;
 
   for (uint8_t idx = 0; idx < 3; idx++) {

mission/devices/HeaterHandler.h

@@ -14,6 +14,7 @@
 #include <fsfw/timemanager/Countdown.h>
 #include <fsfw_hal/common/gpio/GpioIF.h>
 
+#include <array>
 #include <vector>
 
 #include "devices/heaterSwitcherList.h"

mission/devices/IMTQHandler.cpp

@@ -325,10 +325,10 @@ ReturnValue_t IMTQHandler::initializeLocalDataPool(localpool::DataPool& localDat
   localDataPoolMap.emplace(IMTQ::COIL_X_CURRENT, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(IMTQ::COIL_Y_CURRENT, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(IMTQ::COIL_Z_CURRENT, new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(IMTQ::COIL_X_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::COIL_Y_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::COIL_Z_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::MCU_TEMPERATURE, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::COIL_X_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::COIL_Y_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::COIL_Z_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::MCU_TEMPERATURE, new PoolEntry<int16_t>({0}));
 
   /** Entries of calibrated MTM measurement dataset */
   localDataPoolMap.emplace(IMTQ::MTM_CAL_X, new PoolEntry<int32_t>({0}));
@@ -353,9 +353,9 @@ ReturnValue_t IMTQHandler::initializeLocalDataPool(localpool::DataPool& localDat
   localDataPoolMap.emplace(IMTQ::INIT_POS_X_COIL_X_CURRENT, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(IMTQ::INIT_POS_X_COIL_Y_CURRENT, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(IMTQ::INIT_POS_X_COIL_Z_CURRENT, new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(IMTQ::INIT_POS_X_COIL_X_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::INIT_POS_X_COIL_Y_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::INIT_POS_X_COIL_Z_TEMPERATURE, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::INIT_POS_X_COIL_X_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::INIT_POS_X_COIL_Y_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::INIT_POS_X_COIL_Z_TEMPERATURE, new PoolEntry<int16_t>({0}));
 
   /** INIT measurements for negative X axis test */
   localDataPoolMap.emplace(IMTQ::INIT_NEG_X_ERR, new PoolEntry<uint8_t>({0}));
@@ -368,9 +368,9 @@ ReturnValue_t IMTQHandler::initializeLocalDataPool(localpool::DataPool& localDat
   localDataPoolMap.emplace(IMTQ::INIT_NEG_X_COIL_X_CURRENT, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(IMTQ::INIT_NEG_X_COIL_Y_CURRENT, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(IMTQ::INIT_NEG_X_COIL_Z_CURRENT, new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(IMTQ::INIT_NEG_X_COIL_X_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::INIT_NEG_X_COIL_Y_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::INIT_NEG_X_COIL_Z_TEMPERATURE, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::INIT_NEG_X_COIL_X_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::INIT_NEG_X_COIL_Y_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::INIT_NEG_X_COIL_Z_TEMPERATURE, new PoolEntry<int16_t>({0}));
 
   /** INIT measurements for positive Y axis test */
   localDataPoolMap.emplace(IMTQ::INIT_POS_Y_ERR, new PoolEntry<uint8_t>({0}));
@@ -383,9 +383,9 @@ ReturnValue_t IMTQHandler::initializeLocalDataPool(localpool::DataPool& localDat
   localDataPoolMap.emplace(IMTQ::INIT_POS_Y_COIL_X_CURRENT, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(IMTQ::INIT_POS_Y_COIL_Y_CURRENT, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(IMTQ::INIT_POS_Y_COIL_Z_CURRENT, new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(IMTQ::INIT_POS_Y_COIL_X_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::INIT_POS_Y_COIL_Y_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::INIT_POS_Y_COIL_Z_TEMPERATURE, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::INIT_POS_Y_COIL_X_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::INIT_POS_Y_COIL_Y_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::INIT_POS_Y_COIL_Z_TEMPERATURE, new PoolEntry<int16_t>({0}));
 
   /** INIT measurements for negative Y axis test */
   localDataPoolMap.emplace(IMTQ::INIT_NEG_Y_ERR, new PoolEntry<uint8_t>({0}));
@@ -398,9 +398,9 @@ ReturnValue_t IMTQHandler::initializeLocalDataPool(localpool::DataPool& localDat
   localDataPoolMap.emplace(IMTQ::INIT_NEG_Y_COIL_X_CURRENT, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(IMTQ::INIT_NEG_Y_COIL_Y_CURRENT, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(IMTQ::INIT_NEG_Y_COIL_Z_CURRENT, new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(IMTQ::INIT_NEG_Y_COIL_X_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::INIT_NEG_Y_COIL_Y_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::INIT_NEG_Y_COIL_Z_TEMPERATURE, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::INIT_NEG_Y_COIL_X_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::INIT_NEG_Y_COIL_Y_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::INIT_NEG_Y_COIL_Z_TEMPERATURE, new PoolEntry<int16_t>({0}));
 
   /** INIT measurements for positive Z axis test */
   localDataPoolMap.emplace(IMTQ::INIT_POS_Z_ERR, new PoolEntry<uint8_t>({0}));
@@ -413,9 +413,9 @@ ReturnValue_t IMTQHandler::initializeLocalDataPool(localpool::DataPool& localDat
   localDataPoolMap.emplace(IMTQ::INIT_POS_Z_COIL_X_CURRENT, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(IMTQ::INIT_POS_Z_COIL_Y_CURRENT, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(IMTQ::INIT_POS_Z_COIL_Z_CURRENT, new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(IMTQ::INIT_POS_Z_COIL_X_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::INIT_POS_Z_COIL_Y_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::INIT_POS_Z_COIL_Z_TEMPERATURE, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::INIT_POS_Z_COIL_X_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::INIT_POS_Z_COIL_Y_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::INIT_POS_Z_COIL_Z_TEMPERATURE, new PoolEntry<int16_t>({0}));
 
   /** INIT measurements for negative Z axis test */
   localDataPoolMap.emplace(IMTQ::INIT_NEG_Z_ERR, new PoolEntry<uint8_t>({0}));
@@ -428,9 +428,9 @@ ReturnValue_t IMTQHandler::initializeLocalDataPool(localpool::DataPool& localDat
   localDataPoolMap.emplace(IMTQ::INIT_NEG_Z_COIL_X_CURRENT, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(IMTQ::INIT_NEG_Z_COIL_Y_CURRENT, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(IMTQ::INIT_NEG_Z_COIL_Z_CURRENT, new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(IMTQ::INIT_NEG_Z_COIL_X_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::INIT_NEG_Z_COIL_Y_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::INIT_NEG_Z_COIL_Z_TEMPERATURE, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::INIT_NEG_Z_COIL_X_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::INIT_NEG_Z_COIL_Y_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::INIT_NEG_Z_COIL_Z_TEMPERATURE, new PoolEntry<int16_t>({0}));
 
   localDataPoolMap.emplace(IMTQ::POS_X_ERR, new PoolEntry<uint8_t>({0}));
   localDataPoolMap.emplace(IMTQ::POS_X_RAW_MAG_X, new PoolEntry<float>({0}));
@@ -442,9 +442,9 @@ ReturnValue_t IMTQHandler::initializeLocalDataPool(localpool::DataPool& localDat
   localDataPoolMap.emplace(IMTQ::POS_X_COIL_X_CURRENT, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(IMTQ::POS_X_COIL_Y_CURRENT, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(IMTQ::POS_X_COIL_Z_CURRENT, new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(IMTQ::POS_X_COIL_X_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::POS_X_COIL_Y_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::POS_X_COIL_Z_TEMPERATURE, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::POS_X_COIL_X_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::POS_X_COIL_Y_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::POS_X_COIL_Z_TEMPERATURE, new PoolEntry<int16_t>({0}));
 
   localDataPoolMap.emplace(IMTQ::NEG_X_ERR, new PoolEntry<uint8_t>({0}));
   localDataPoolMap.emplace(IMTQ::NEG_X_RAW_MAG_X, new PoolEntry<uint32_t>({0}));
@@ -456,9 +456,9 @@ ReturnValue_t IMTQHandler::initializeLocalDataPool(localpool::DataPool& localDat
   localDataPoolMap.emplace(IMTQ::NEG_X_COIL_X_CURRENT, new PoolEntry<uint16_t>({0}));
   localDataPoolMap.emplace(IMTQ::NEG_X_COIL_Y_CURRENT, new PoolEntry<uint16_t>({0}));
   localDataPoolMap.emplace(IMTQ::NEG_X_COIL_Z_CURRENT, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::NEG_X_COIL_X_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::NEG_X_COIL_Y_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::NEG_X_COIL_Z_TEMPERATURE, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::NEG_X_COIL_X_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::NEG_X_COIL_Y_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::NEG_X_COIL_Z_TEMPERATURE, new PoolEntry<int16_t>({0}));
 
   localDataPoolMap.emplace(IMTQ::POS_Y_ERR, new PoolEntry<uint8_t>({0}));
   localDataPoolMap.emplace(IMTQ::POS_Y_RAW_MAG_X, new PoolEntry<uint32_t>({0}));
@@ -470,9 +470,9 @@ ReturnValue_t IMTQHandler::initializeLocalDataPool(localpool::DataPool& localDat
   localDataPoolMap.emplace(IMTQ::POS_Y_COIL_X_CURRENT, new PoolEntry<uint16_t>({0}));
   localDataPoolMap.emplace(IMTQ::POS_Y_COIL_Y_CURRENT, new PoolEntry<uint16_t>({0}));
   localDataPoolMap.emplace(IMTQ::POS_Y_COIL_Z_CURRENT, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::POS_Y_COIL_X_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::POS_Y_COIL_Y_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::POS_Y_COIL_Z_TEMPERATURE, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::POS_Y_COIL_X_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::POS_Y_COIL_Y_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::POS_Y_COIL_Z_TEMPERATURE, new PoolEntry<int16_t>({0}));
 
   localDataPoolMap.emplace(IMTQ::NEG_Y_ERR, new PoolEntry<uint8_t>({0}));
   localDataPoolMap.emplace(IMTQ::NEG_Y_RAW_MAG_X, new PoolEntry<uint32_t>({0}));
@@ -484,9 +484,9 @@ ReturnValue_t IMTQHandler::initializeLocalDataPool(localpool::DataPool& localDat
   localDataPoolMap.emplace(IMTQ::NEG_Y_COIL_X_CURRENT, new PoolEntry<uint16_t>({0}));
   localDataPoolMap.emplace(IMTQ::NEG_Y_COIL_Y_CURRENT, new PoolEntry<uint16_t>({0}));
   localDataPoolMap.emplace(IMTQ::NEG_Y_COIL_Z_CURRENT, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::NEG_Y_COIL_X_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::NEG_Y_COIL_Y_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::NEG_Y_COIL_Z_TEMPERATURE, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::NEG_Y_COIL_X_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::NEG_Y_COIL_Y_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::NEG_Y_COIL_Z_TEMPERATURE, new PoolEntry<int16_t>({0}));
 
   localDataPoolMap.emplace(IMTQ::POS_Z_ERR, new PoolEntry<uint8_t>({0}));
   localDataPoolMap.emplace(IMTQ::POS_Z_RAW_MAG_X, new PoolEntry<uint32_t>({0}));
@@ -498,9 +498,9 @@ ReturnValue_t IMTQHandler::initializeLocalDataPool(localpool::DataPool& localDat
   localDataPoolMap.emplace(IMTQ::POS_Z_COIL_X_CURRENT, new PoolEntry<uint16_t>({0}));
   localDataPoolMap.emplace(IMTQ::POS_Z_COIL_Y_CURRENT, new PoolEntry<uint16_t>({0}));
   localDataPoolMap.emplace(IMTQ::POS_Z_COIL_Z_CURRENT, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::POS_Z_COIL_X_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::POS_Z_COIL_Y_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::POS_Z_COIL_Z_TEMPERATURE, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::POS_Z_COIL_X_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::POS_Z_COIL_Y_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::POS_Z_COIL_Z_TEMPERATURE, new PoolEntry<int16_t>({0}));
 
   localDataPoolMap.emplace(IMTQ::NEG_Z_ERR, new PoolEntry<uint8_t>({0}));
   localDataPoolMap.emplace(IMTQ::NEG_Z_RAW_MAG_X, new PoolEntry<uint32_t>({0}));
@@ -512,9 +512,9 @@ ReturnValue_t IMTQHandler::initializeLocalDataPool(localpool::DataPool& localDat
   localDataPoolMap.emplace(IMTQ::NEG_Z_COIL_X_CURRENT, new PoolEntry<uint16_t>({0}));
   localDataPoolMap.emplace(IMTQ::NEG_Z_COIL_Y_CURRENT, new PoolEntry<uint16_t>({0}));
   localDataPoolMap.emplace(IMTQ::NEG_Z_COIL_Z_CURRENT, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::NEG_Z_COIL_X_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::NEG_Z_COIL_Y_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::NEG_Z_COIL_Z_TEMPERATURE, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::NEG_Z_COIL_X_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::NEG_Z_COIL_Y_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::NEG_Z_COIL_Z_TEMPERATURE, new PoolEntry<int16_t>({0}));
 
   /** FINA measurements for positive X axis test */
   localDataPoolMap.emplace(IMTQ::FINA_POS_X_ERR, new PoolEntry<uint8_t>({0}));
@@ -527,9 +527,9 @@ ReturnValue_t IMTQHandler::initializeLocalDataPool(localpool::DataPool& localDat
   localDataPoolMap.emplace(IMTQ::FINA_POS_X_COIL_X_CURRENT, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(IMTQ::FINA_POS_X_COIL_Y_CURRENT, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(IMTQ::FINA_POS_X_COIL_Z_CURRENT, new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(IMTQ::FINA_POS_X_COIL_X_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::FINA_POS_X_COIL_Y_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::FINA_POS_X_COIL_Z_TEMPERATURE, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::FINA_POS_X_COIL_X_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::FINA_POS_X_COIL_Y_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::FINA_POS_X_COIL_Z_TEMPERATURE, new PoolEntry<int16_t>({0}));
 
   /** FINA measurements for negative X axis test */
   localDataPoolMap.emplace(IMTQ::FINA_NEG_X_ERR, new PoolEntry<uint8_t>({0}));
@@ -542,9 +542,9 @@ ReturnValue_t IMTQHandler::initializeLocalDataPool(localpool::DataPool& localDat
   localDataPoolMap.emplace(IMTQ::FINA_NEG_X_COIL_X_CURRENT, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(IMTQ::FINA_NEG_X_COIL_Y_CURRENT, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(IMTQ::FINA_NEG_X_COIL_Z_CURRENT, new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(IMTQ::FINA_NEG_X_COIL_X_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::FINA_NEG_X_COIL_Y_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::FINA_NEG_X_COIL_Z_TEMPERATURE, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::FINA_NEG_X_COIL_X_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::FINA_NEG_X_COIL_Y_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::FINA_NEG_X_COIL_Z_TEMPERATURE, new PoolEntry<int16_t>({0}));
 
   /** FINA measurements for positive Y axis test */
   localDataPoolMap.emplace(IMTQ::FINA_POS_Y_ERR, new PoolEntry<uint8_t>({0}));
@@ -557,9 +557,9 @@ ReturnValue_t IMTQHandler::initializeLocalDataPool(localpool::DataPool& localDat
   localDataPoolMap.emplace(IMTQ::FINA_POS_Y_COIL_X_CURRENT, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(IMTQ::FINA_POS_Y_COIL_Y_CURRENT, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(IMTQ::FINA_POS_Y_COIL_Z_CURRENT, new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(IMTQ::FINA_POS_Y_COIL_X_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::FINA_POS_Y_COIL_Y_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::FINA_POS_Y_COIL_Z_TEMPERATURE, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::FINA_POS_Y_COIL_X_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::FINA_POS_Y_COIL_Y_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::FINA_POS_Y_COIL_Z_TEMPERATURE, new PoolEntry<int16_t>({0}));
 
   /** FINA measurements for negative Y axis test */
   localDataPoolMap.emplace(IMTQ::FINA_NEG_Y_ERR, new PoolEntry<uint8_t>({0}));
@@ -572,9 +572,9 @@ ReturnValue_t IMTQHandler::initializeLocalDataPool(localpool::DataPool& localDat
   localDataPoolMap.emplace(IMTQ::FINA_NEG_Y_COIL_X_CURRENT, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(IMTQ::FINA_NEG_Y_COIL_Y_CURRENT, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(IMTQ::FINA_NEG_Y_COIL_Z_CURRENT, new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(IMTQ::FINA_NEG_Y_COIL_X_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::FINA_NEG_Y_COIL_Y_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::FINA_NEG_Y_COIL_Z_TEMPERATURE, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::FINA_NEG_Y_COIL_X_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::FINA_NEG_Y_COIL_Y_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::FINA_NEG_Y_COIL_Z_TEMPERATURE, new PoolEntry<int16_t>({0}));
 
   /** FINA measurements for positive Z axis test */
   localDataPoolMap.emplace(IMTQ::FINA_POS_Z_ERR, new PoolEntry<uint8_t>({0}));
@@ -587,9 +587,9 @@ ReturnValue_t IMTQHandler::initializeLocalDataPool(localpool::DataPool& localDat
   localDataPoolMap.emplace(IMTQ::FINA_POS_Z_COIL_X_CURRENT, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(IMTQ::FINA_POS_Z_COIL_Y_CURRENT, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(IMTQ::FINA_POS_Z_COIL_Z_CURRENT, new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(IMTQ::FINA_POS_Z_COIL_X_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::FINA_POS_Z_COIL_Y_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::FINA_POS_Z_COIL_Z_TEMPERATURE, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::FINA_POS_Z_COIL_X_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::FINA_POS_Z_COIL_Y_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::FINA_POS_Z_COIL_Z_TEMPERATURE, new PoolEntry<int16_t>({0}));
 
   /** FINA measurements for negative Z axis test */
   localDataPoolMap.emplace(IMTQ::FINA_NEG_Z_ERR, new PoolEntry<uint8_t>({0}));
@@ -602,9 +602,9 @@ ReturnValue_t IMTQHandler::initializeLocalDataPool(localpool::DataPool& localDat
   localDataPoolMap.emplace(IMTQ::FINA_NEG_Z_COIL_X_CURRENT, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(IMTQ::FINA_NEG_Z_COIL_Y_CURRENT, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(IMTQ::FINA_NEG_Z_COIL_Z_CURRENT, new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(IMTQ::FINA_NEG_Z_COIL_X_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::FINA_NEG_Z_COIL_Y_TEMPERATURE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::FINA_NEG_Z_COIL_Z_TEMPERATURE, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::FINA_NEG_Z_COIL_X_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::FINA_NEG_Z_COIL_Y_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(IMTQ::FINA_NEG_Z_COIL_Z_TEMPERATURE, new PoolEntry<int16_t>({0}));
 
   poolManager.subscribeForPeriodicPacket(engHkDataset.getSid(), false, 10.0, true);
   poolManager.subscribeForPeriodicPacket(calMtmMeasurementSet.getSid(), false, 10.0, true);
@@ -690,6 +690,8 @@ void IMTQHandler::fillEngHkDataset(const uint8_t* packet) {
   offset += 2;
   engHkDataset.mcuTemperature = (*(packet + offset + 1) << 8 | *(packet + offset));
 
+  engHkDataset.setValidity(true, true);
+
   if (debugMode) {
 #if OBSW_VERBOSE_LEVEL >= 1
     sif::info << "IMTQ digital voltage: " << engHkDataset.digitalVoltageMv << " mV" << std::endl;

mission/devices/Max31865EiveHandler.cpp

@@ -1,5 +1,7 @@
 #include "Max31865EiveHandler.h"
 
+#include <fsfw/datapool/PoolReadGuard.h>
+
 Max31865EiveHandler::Max31865EiveHandler(object_id_t objectId, object_id_t comIF,
                                          CookieIF* comCookie)
     : DeviceHandlerBase(objectId, comIF, comCookie, nullptr),
@@ -154,6 +156,15 @@ ReturnValue_t Max31865EiveHandler::interpretDeviceReply(DeviceCommandId_t id,
   // calculate approximation
   float approxTemp = exchangeStruct.adcCode / 32.0 - 256.0;
 
+  PoolReadGuard pg(&sensorDataset);
+  if (pg.getReadResult() != HasReturnvaluesIF::RETURN_OK) {
+    sif::warning << "Max31865EiveHandler: Failed to read sensor dataset" << std::endl;
+    sensorDataset.temperatureCelcius.setValid(false);
+    return RETURN_OK;
+  }
+  sensorDataset.temperatureCelcius = approxTemp;
+  sensorDataset.temperatureCelcius.setValid(true);
+
   if (debugMode) {
     if (debugDivider.checkAndIncrement()) {
       sif::info << "Max31865: " << std::setw(20) << std::left << locString << std::right
@@ -170,6 +181,8 @@ ReturnValue_t Max31865EiveHandler::initializeLocalDataPool(localpool::DataPool&
   using namespace MAX31865;
   localDataPoolMap.emplace(static_cast<lp_id_t>(PoolIds::RTD_VALUE), new PoolEntry<float>({0}));
   localDataPoolMap.emplace(static_cast<lp_id_t>(PoolIds::TEMPERATURE_C), new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(static_cast<lp_id_t>(PoolIds::LAST_FAULT_BYTE),
+                           new PoolEntry<uint8_t>({0}));
   localDataPoolMap.emplace(static_cast<lp_id_t>(PoolIds::FAULT_BYTE), new PoolEntry<uint8_t>({0}));
   poolManager.subscribeForPeriodicPacket(sensorDataset.getSid(), false, 30.0, false);
   return RETURN_OK;

mission/devices/P60DockHandler.cpp

@@ -57,9 +57,11 @@ void P60DockHandler::parseHkTableReply(const uint8_t *packet) {
     dataOffset += 3;
   }
 
-  coreHk.temperature1 = *(packet + dataOffset) << 8 | *(packet + dataOffset + 1);
+  coreHk.temperature1 =
+      static_cast<int16_t>(*(packet + dataOffset) << 8 | *(packet + dataOffset + 1)) * 0.1;
   dataOffset += 4;
-  coreHk.temperature2 = *(packet + dataOffset) << 8 | *(packet + dataOffset + 1);
+  coreHk.temperature2 =
+      static_cast<int16_t>(*(packet + dataOffset) << 8 | *(packet + dataOffset + 1)) * 0.1;
   dataOffset += 4;
 
   auxHk.bootcause = *(packet + dataOffset) << 24 |
@@ -180,8 +182,8 @@ ReturnValue_t P60DockHandler::initializeLocalDataPool(localpool::DataPool &local
 
   localDataPoolMap.emplace(pool::P60_OUTPUT_ENABLE, &outputEnables);
 
-  localDataPoolMap.emplace(pool::P60DOCK_TEMPERATURE_1, new PoolEntry<int16_t>({0}));
-  localDataPoolMap.emplace(pool::P60DOCK_TEMPERATURE_2, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(pool::P60DOCK_TEMPERATURE_1, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(pool::P60DOCK_TEMPERATURE_2, new PoolEntry<float>({0}));
 
   localDataPoolMap.emplace(pool::P60DOCK_BOOT_CAUSE, new PoolEntry<uint32_t>({0}));
   localDataPoolMap.emplace(pool::P60DOCK_BOOT_CNT, new PoolEntry<uint32_t>({0}));

mission/devices/RadiationSensorHandler.cpp

@@ -2,6 +2,7 @@
 #include <devices/gpioIds.h>
 #include <fsfw/datapool/PoolReadGuard.h>
 #include <mission/devices/RadiationSensorHandler.h>
+#include <mission/devices/max1227.h>
 
 RadiationSensorHandler::RadiationSensorHandler(object_id_t objectId, object_id_t comIF,
                                                CookieIF *comCookie, GpioIF *gpioIF)
@@ -155,8 +156,8 @@ ReturnValue_t RadiationSensorHandler::interpretDeviceReply(DeviceCommandId_t id,
     case RAD_SENSOR::READ_CONVERSIONS: {
       uint8_t offset = 0;
       PoolReadGuard readSet(&dataset);
-      int16_t tempRaw = ((packet[offset] & 0x0f) << 8) | packet[offset + 1];
-      dataset.temperatureCelcius = tempRaw * 0.125;
+      uint16_t tempRaw = ((packet[offset] & 0x0f) << 8) | packet[offset + 1];
+      dataset.temperatureCelcius = max1227::getTemperature(tempRaw);
       offset += 2;
       dataset.ain0 = (*(packet + offset) << 8) | *(packet + offset + 1);
       offset += 2;

mission/devices/RwHandler.cpp

@@ -279,6 +279,7 @@ ReturnValue_t RwHandler::initializeLocalDataPool(localpool::DataPool& localDataP
   localDataPoolMap.emplace(RwDefinitions::SPI_TOTAL_ERRORS, new PoolEntry<uint32_t>({0}));
   poolManager.subscribeForPeriodicPacket(statusSet.getSid(), false, 5.0, true);
   poolManager.subscribeForPeriodicPacket(tmDataset.getSid(), false, 30.0, false);
+  poolManager.subscribeForPeriodicPacket(lastResetStatusSet.getSid(), false, 30.0, false);
   return RETURN_OK;
 }
 

mission/devices/SusHandler.cpp

@@ -160,11 +160,11 @@ ReturnValue_t SusHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8
     }
     case SUS::READ_INT_TIMED_CONVERSIONS: {
       PoolReadGuard readSet(&dataset);
-
       dataset.temperatureCelcius = max1227::getTemperature(((packet[0] & 0x0f) << 8) | packet[1]);
       for (uint8_t idx = 0; idx < 6; idx++) {
         dataset.channels[idx] = packet[idx * 2 + 2] << 8 | packet[idx * 2 + 3];
       }
+      dataset.setValidity(true, true);
       printDataset();
       break;
     }
@@ -173,6 +173,7 @@ ReturnValue_t SusHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8
       for (uint8_t idx = 0; idx < 6; idx++) {
         dataset.channels[idx] = packet[idx * 2 + 1] << 8 | packet[idx * 2 + 2];
       }
+      dataset.channels.setValid(true);
       // Read temperature in next read cycle
       if (clkMode == ClkModes::EXT_CLOCKED_WITH_TEMP) {
         comState = ComStates::EXT_CLOCKED_TEMP;
@@ -183,6 +184,7 @@ ReturnValue_t SusHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8
     case (SUS::READ_EXT_TIMED_TEMPS): {
       PoolReadGuard readSet(&dataset);
       dataset.temperatureCelcius = max1227::getTemperature(((packet[23] & 0x0f) << 8) | packet[24]);
+      dataset.temperatureCelcius.setValid(true);
       comState = ComStates::EXT_CLOCKED_CONVERSIONS;
       break;
     }

mission/devices/SyrlinksHkHandler.cpp

@@ -361,8 +361,8 @@ ReturnValue_t SyrlinksHkHandler::interpretDeviceReply(DeviceCommandId_t id, cons
       rawTempBasebandBoard |= convertHexStringToUint8(
           reinterpret_cast<const char*>(packet + syrlinks::MESSAGE_HEADER_SIZE));
       tempBasebandBoard = calcTempVal(rawTempBasebandBoard);
-      temperatureSet.temperatureBasebandBoard = tempBasebandBoard;
       PoolReadGuard rg(&temperatureSet);
+      temperatureSet.temperatureBasebandBoard = tempBasebandBoard;
       if (debugMode) {
         sif::info << "Syrlinks temperature baseband board: " << tempBasebandBoard << "  °C"
                   << std::endl;
@@ -618,8 +618,8 @@ ReturnValue_t SyrlinksHkHandler::initializeLocalDataPool(localpool::DataPool& lo
   localDataPoolMap.emplace(syrlinks::TX_STATUS, new PoolEntry<uint8_t>({0}));
   localDataPoolMap.emplace(syrlinks::TX_WAVEFORM, new PoolEntry<uint8_t>({0}));
   localDataPoolMap.emplace(syrlinks::TX_AGC_VALUE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(syrlinks::TEMP_BASEBAND_BOARD, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(syrlinks::TEMP_POWER_AMPLIFIER, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(syrlinks::TEMP_BASEBAND_BOARD, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(syrlinks::TEMP_POWER_AMPLIFIER, new PoolEntry<float>({0}));
 
   poolManager.subscribeForPeriodicPacket(txDataset.getSid(), false, 5.0, true);
   poolManager.subscribeForPeriodicPacket(rxDataset.getSid(), false, 5.0, true);

mission/devices/Tmp1075Handler.cpp

@@ -93,7 +93,10 @@ ReturnValue_t Tmp1075Handler::interpretDeviceReply(DeviceCommandId_t id, const u
       ReturnValue_t result = dataset.read();
       if (result == HasReturnvaluesIF::RETURN_OK) {
         dataset.temperatureCelcius = tempValue;
+        dataset.setValidity(true, true);
         dataset.commit();
+      } else {
+        dataset.setValidity(false, true);
       }
       break;
     }

mission/devices/devicedefinitions/GomspaceDefinitions.h

@@ -244,10 +244,10 @@ class CoreHkSet : public StaticLocalDataSet<16> {
   lp_var_t<uint16_t> batteryVoltage =
       lp_var_t<uint16_t>(sid.objectId, P60System::pool::P60DOCK_BATTERY_VOLTAGE, this);
 
-  lp_var_t<int16_t> temperature1 =
-      lp_var_t<int16_t>(sid.objectId, P60System::pool::P60DOCK_TEMPERATURE_1, this);
-  lp_var_t<int16_t> temperature2 =
-      lp_var_t<int16_t>(sid.objectId, P60System::pool::P60DOCK_TEMPERATURE_2, this);
+  lp_var_t<float> temperature1 =
+      lp_var_t<float>(sid.objectId, P60System::pool::P60DOCK_TEMPERATURE_1, this);
+  lp_var_t<float> temperature2 =
+      lp_var_t<float>(sid.objectId, P60System::pool::P60DOCK_TEMPERATURE_2, this);
 };
 /**
  * @brief   This class defines a dataset for the hk table of the P60 Dock.
@@ -368,8 +368,8 @@ class PduCoreHk : public StaticLocalDataSet<9> {
   /** Battery mode: 1 = Critical, 2 = Safe, 3 = Normal, 4 = Full */
   lp_var_t<uint8_t> battMode =
       lp_var_t<uint8_t>(sid.objectId, P60System::pool::PDU_BATT_MODE, this);
-  lp_var_t<int16_t> temperature =
-      lp_var_t<int16_t>(sid.objectId, P60System::pool::PDU_TEMPERATURE, this);
+  lp_var_t<float> temperature =
+      lp_var_t<float>(sid.objectId, P60System::pool::PDU_TEMPERATURE, this);
 };
 
 /**
@@ -575,8 +575,8 @@ class CoreHk : public StaticLocalDataSet<14> {
   lp_vec_t<uint16_t, 6> powerInChannels =
       lp_vec_t<uint16_t, 6>(sid.objectId, P60System::pool::ACU_POWER_IN_CHANNELS, this);
 
-  lp_vec_t<int16_t, 3> temperatures =
-      lp_vec_t<int16_t, 3>(sid.objectId, P60System::pool::ACU_TEMPERATURES, this);
+  lp_vec_t<float, 3> temperatures =
+      lp_vec_t<float, 3>(sid.objectId, P60System::pool::ACU_TEMPERATURES, this);
 
   lp_var_t<uint32_t> bootcnt = lp_var_t<uint32_t>(sid.objectId, P60System::pool::ACU_BOOTCNT, this);
   lp_var_t<uint32_t> uptime = lp_var_t<uint32_t>(sid.objectId, P60System::pool::ACU_UPTIME, this);

mission/devices/devicedefinitions/IMTQHandlerDefinitions.h

@@ -391,10 +391,10 @@ class EngHkDataset : public StaticLocalDataSet<ENG_HK_SET_POOL_ENTRIES> {
   lp_var_t<float> coilYCurrentmA = lp_var_t<float>(sid.objectId, COIL_Y_CURRENT, this);
   lp_var_t<float> coilZCurrentmA = lp_var_t<float>(sid.objectId, COIL_Z_CURRENT, this);
   /** All temperatures in [<5B>C] */
-  lp_var_t<uint16_t> coilXTemperature = lp_var_t<uint16_t>(sid.objectId, COIL_X_TEMPERATURE, this);
-  lp_var_t<uint16_t> coilYTemperature = lp_var_t<uint16_t>(sid.objectId, COIL_Y_TEMPERATURE, this);
-  lp_var_t<uint16_t> coilZTemperature = lp_var_t<uint16_t>(sid.objectId, COIL_Z_TEMPERATURE, this);
-  lp_var_t<uint16_t> mcuTemperature = lp_var_t<uint16_t>(sid.objectId, MCU_TEMPERATURE, this);
+  lp_var_t<int16_t> coilXTemperature = lp_var_t<int16_t>(sid.objectId, COIL_X_TEMPERATURE, this);
+  lp_var_t<int16_t> coilYTemperature = lp_var_t<int16_t>(sid.objectId, COIL_Y_TEMPERATURE, this);
+  lp_var_t<int16_t> coilZTemperature = lp_var_t<int16_t>(sid.objectId, COIL_Z_TEMPERATURE, this);
+  lp_var_t<int16_t> mcuTemperature = lp_var_t<int16_t>(sid.objectId, MCU_TEMPERATURE, this);
 };
 
 /**
@@ -521,12 +521,12 @@ class PosXSelfTestSet : public StaticLocalDataSet<SELF_TEST_DATASET_ENTRIES> {
   lp_var_t<float> coilXCurrent = lp_var_t<float>(sid.objectId, POS_X_COIL_X_CURRENT, this);
   lp_var_t<float> coilYCurrent = lp_var_t<float>(sid.objectId, POS_X_COIL_Y_CURRENT, this);
   lp_var_t<float> coilZCurrent = lp_var_t<float>(sid.objectId, POS_X_COIL_Z_CURRENT, this);
-  lp_var_t<uint16_t> coilXTemperature =
-      lp_var_t<uint16_t>(sid.objectId, POS_X_COIL_X_TEMPERATURE, this);
-  lp_var_t<uint16_t> coilYTemperature =
-      lp_var_t<uint16_t>(sid.objectId, POS_X_COIL_Y_TEMPERATURE, this);
-  lp_var_t<uint16_t> coilZTemperature =
-      lp_var_t<uint16_t>(sid.objectId, POS_X_COIL_Z_TEMPERATURE, this);
+  lp_var_t<int16_t> coilXTemperature =
+      lp_var_t<int16_t>(sid.objectId, POS_X_COIL_X_TEMPERATURE, this);
+  lp_var_t<int16_t> coilYTemperature =
+      lp_var_t<int16_t>(sid.objectId, POS_X_COIL_Y_TEMPERATURE, this);
+  lp_var_t<int16_t> coilZTemperature =
+      lp_var_t<int16_t>(sid.objectId, POS_X_COIL_Z_TEMPERATURE, this);
 
   /** FINA block */
   lp_var_t<uint8_t> finaErr = lp_var_t<uint8_t>(sid.objectId, FINA_POS_X_ERR, this);
@@ -539,12 +539,12 @@ class PosXSelfTestSet : public StaticLocalDataSet<SELF_TEST_DATASET_ENTRIES> {
   lp_var_t<float> finaCoilXCurrent = lp_var_t<float>(sid.objectId, FINA_POS_X_COIL_X_CURRENT, this);
   lp_var_t<float> finaCoilYCurrent = lp_var_t<float>(sid.objectId, FINA_POS_X_COIL_Y_CURRENT, this);
   lp_var_t<float> finaCoilZCurrent = lp_var_t<float>(sid.objectId, FINA_POS_X_COIL_Z_CURRENT, this);
-  lp_var_t<uint16_t> finaCoilXTemperature =
-      lp_var_t<uint16_t>(sid.objectId, FINA_POS_X_COIL_X_TEMPERATURE, this);
-  lp_var_t<uint16_t> finaCoilYTemperature =
-      lp_var_t<uint16_t>(sid.objectId, FINA_POS_X_COIL_Y_TEMPERATURE, this);
-  lp_var_t<uint16_t> finaCoilZTemperature =
-      lp_var_t<uint16_t>(sid.objectId, FINA_POS_X_COIL_Z_TEMPERATURE, this);
+  lp_var_t<int16_t> finaCoilXTemperature =
+      lp_var_t<int16_t>(sid.objectId, FINA_POS_X_COIL_X_TEMPERATURE, this);
+  lp_var_t<int16_t> finaCoilYTemperature =
+      lp_var_t<int16_t>(sid.objectId, FINA_POS_X_COIL_Y_TEMPERATURE, this);
+  lp_var_t<int16_t> finaCoilZTemperature =
+      lp_var_t<int16_t>(sid.objectId, FINA_POS_X_COIL_Z_TEMPERATURE, this);
 };
 
 /**
@@ -580,12 +580,12 @@ class NegXSelfTestSet : public StaticLocalDataSet<SELF_TEST_DATASET_ENTRIES> {
   lp_var_t<float> initCoilXCurrent = lp_var_t<float>(sid.objectId, INIT_NEG_X_COIL_X_CURRENT, this);
   lp_var_t<float> initCoilYCurrent = lp_var_t<float>(sid.objectId, INIT_NEG_X_COIL_Y_CURRENT, this);
   lp_var_t<float> initCoilZCurrent = lp_var_t<float>(sid.objectId, INIT_NEG_X_COIL_Z_CURRENT, this);
-  lp_var_t<uint16_t> initCoilXTemperature =
-      lp_var_t<uint16_t>(sid.objectId, INIT_NEG_X_COIL_X_TEMPERATURE, this);
-  lp_var_t<uint16_t> initCoilYTemperature =
-      lp_var_t<uint16_t>(sid.objectId, INIT_NEG_X_COIL_Y_TEMPERATURE, this);
-  lp_var_t<uint16_t> initCoilZTemperature =
-      lp_var_t<uint16_t>(sid.objectId, INIT_NEG_X_COIL_Z_TEMPERATURE, this);
+  lp_var_t<int16_t> initCoilXTemperature =
+      lp_var_t<int16_t>(sid.objectId, INIT_NEG_X_COIL_X_TEMPERATURE, this);
+  lp_var_t<int16_t> initCoilYTemperature =
+      lp_var_t<int16_t>(sid.objectId, INIT_NEG_X_COIL_Y_TEMPERATURE, this);
+  lp_var_t<int16_t> initCoilZTemperature =
+      lp_var_t<int16_t>(sid.objectId, INIT_NEG_X_COIL_Z_TEMPERATURE, this);
 
   /** -X block */
   lp_var_t<uint8_t> err = lp_var_t<uint8_t>(sid.objectId, NEG_X_ERR, this);
@@ -598,12 +598,12 @@ class NegXSelfTestSet : public StaticLocalDataSet<SELF_TEST_DATASET_ENTRIES> {
   lp_var_t<float> coilXCurrent = lp_var_t<float>(sid.objectId, NEG_X_COIL_X_CURRENT, this);
   lp_var_t<float> coilYCurrent = lp_var_t<float>(sid.objectId, NEG_X_COIL_Y_CURRENT, this);
   lp_var_t<float> coilZCurrent = lp_var_t<float>(sid.objectId, NEG_X_COIL_Z_CURRENT, this);
-  lp_var_t<uint16_t> coilXTemperature =
-      lp_var_t<uint16_t>(sid.objectId, NEG_X_COIL_X_TEMPERATURE, this);
-  lp_var_t<uint16_t> coilYTemperature =
-      lp_var_t<uint16_t>(sid.objectId, NEG_X_COIL_Y_TEMPERATURE, this);
-  lp_var_t<uint16_t> coilZTemperature =
-      lp_var_t<uint16_t>(sid.objectId, NEG_X_COIL_Z_TEMPERATURE, this);
+  lp_var_t<int16_t> coilXTemperature =
+      lp_var_t<int16_t>(sid.objectId, NEG_X_COIL_X_TEMPERATURE, this);
+  lp_var_t<int16_t> coilYTemperature =
+      lp_var_t<int16_t>(sid.objectId, NEG_X_COIL_Y_TEMPERATURE, this);
+  lp_var_t<int16_t> coilZTemperature =
+      lp_var_t<int16_t>(sid.objectId, NEG_X_COIL_Z_TEMPERATURE, this);
 
   /** FINA block */
   lp_var_t<uint8_t> finaErr = lp_var_t<uint8_t>(sid.objectId, FINA_NEG_X_ERR, this);
@@ -616,12 +616,12 @@ class NegXSelfTestSet : public StaticLocalDataSet<SELF_TEST_DATASET_ENTRIES> {
   lp_var_t<float> finaCoilXCurrent = lp_var_t<float>(sid.objectId, FINA_NEG_X_COIL_X_CURRENT, this);
   lp_var_t<float> finaCoilYCurrent = lp_var_t<float>(sid.objectId, FINA_NEG_X_COIL_Y_CURRENT, this);
   lp_var_t<float> finaCoilZCurrent = lp_var_t<float>(sid.objectId, FINA_NEG_X_COIL_Z_CURRENT, this);
-  lp_var_t<uint16_t> finaCoilXTemperature =
-      lp_var_t<uint16_t>(sid.objectId, FINA_NEG_X_COIL_X_TEMPERATURE, this);
-  lp_var_t<uint16_t> finaCoilYTemperature =
-      lp_var_t<uint16_t>(sid.objectId, FINA_NEG_X_COIL_Y_TEMPERATURE, this);
-  lp_var_t<uint16_t> finaCoilZTemperature =
-      lp_var_t<uint16_t>(sid.objectId, FINA_NEG_X_COIL_Z_TEMPERATURE, this);
+  lp_var_t<int16_t> finaCoilXTemperature =
+      lp_var_t<int16_t>(sid.objectId, FINA_NEG_X_COIL_X_TEMPERATURE, this);
+  lp_var_t<int16_t> finaCoilYTemperature =
+      lp_var_t<int16_t>(sid.objectId, FINA_NEG_X_COIL_Y_TEMPERATURE, this);
+  lp_var_t<int16_t> finaCoilZTemperature =
+      lp_var_t<int16_t>(sid.objectId, FINA_NEG_X_COIL_Z_TEMPERATURE, this);
 };
 
 /**
@@ -657,12 +657,12 @@ class PosYSelfTestSet : public StaticLocalDataSet<SELF_TEST_DATASET_ENTRIES> {
   lp_var_t<float> initCoilXCurrent = lp_var_t<float>(sid.objectId, INIT_POS_Y_COIL_X_CURRENT, this);
   lp_var_t<float> initCoilYCurrent = lp_var_t<float>(sid.objectId, INIT_POS_Y_COIL_Y_CURRENT, this);
   lp_var_t<float> initCoilZCurrent = lp_var_t<float>(sid.objectId, INIT_POS_Y_COIL_Z_CURRENT, this);
-  lp_var_t<uint16_t> initCoilXTemperature =
-      lp_var_t<uint16_t>(sid.objectId, INIT_POS_Y_COIL_X_TEMPERATURE, this);
-  lp_var_t<uint16_t> initCoilYTemperature =
-      lp_var_t<uint16_t>(sid.objectId, INIT_POS_Y_COIL_Y_TEMPERATURE, this);
-  lp_var_t<uint16_t> initCoilZTemperature =
-      lp_var_t<uint16_t>(sid.objectId, INIT_POS_Y_COIL_Z_TEMPERATURE, this);
+  lp_var_t<int16_t> initCoilXTemperature =
+      lp_var_t<int16_t>(sid.objectId, INIT_POS_Y_COIL_X_TEMPERATURE, this);
+  lp_var_t<int16_t> initCoilYTemperature =
+      lp_var_t<int16_t>(sid.objectId, INIT_POS_Y_COIL_Y_TEMPERATURE, this);
+  lp_var_t<int16_t> initCoilZTemperature =
+      lp_var_t<int16_t>(sid.objectId, INIT_POS_Y_COIL_Z_TEMPERATURE, this);
 
   /** +Y block */
   lp_var_t<uint8_t> err = lp_var_t<uint8_t>(sid.objectId, POS_Y_ERR, this);
@@ -675,12 +675,12 @@ class PosYSelfTestSet : public StaticLocalDataSet<SELF_TEST_DATASET_ENTRIES> {
   lp_var_t<float> coilXCurrent = lp_var_t<float>(sid.objectId, POS_Y_COIL_X_CURRENT, this);
   lp_var_t<float> coilYCurrent = lp_var_t<float>(sid.objectId, POS_Y_COIL_Y_CURRENT, this);
   lp_var_t<float> coilZCurrent = lp_var_t<float>(sid.objectId, POS_Y_COIL_Z_CURRENT, this);
-  lp_var_t<uint16_t> coilXTemperature =
-      lp_var_t<uint16_t>(sid.objectId, POS_Y_COIL_X_TEMPERATURE, this);
-  lp_var_t<uint16_t> coilYTemperature =
-      lp_var_t<uint16_t>(sid.objectId, POS_Y_COIL_Y_TEMPERATURE, this);
-  lp_var_t<uint16_t> coilZTemperature =
-      lp_var_t<uint16_t>(sid.objectId, POS_Y_COIL_Z_TEMPERATURE, this);
+  lp_var_t<int16_t> coilXTemperature =
+      lp_var_t<int16_t>(sid.objectId, POS_Y_COIL_X_TEMPERATURE, this);
+  lp_var_t<int16_t> coilYTemperature =
+      lp_var_t<int16_t>(sid.objectId, POS_Y_COIL_Y_TEMPERATURE, this);
+  lp_var_t<int16_t> coilZTemperature =
+      lp_var_t<int16_t>(sid.objectId, POS_Y_COIL_Z_TEMPERATURE, this);
 
   /** FINA block */
   lp_var_t<uint8_t> finaErr = lp_var_t<uint8_t>(sid.objectId, FINA_POS_Y_ERR, this);
@@ -693,12 +693,12 @@ class PosYSelfTestSet : public StaticLocalDataSet<SELF_TEST_DATASET_ENTRIES> {
   lp_var_t<float> finaCoilXCurrent = lp_var_t<float>(sid.objectId, FINA_POS_Y_COIL_X_CURRENT, this);
   lp_var_t<float> finaCoilYCurrent = lp_var_t<float>(sid.objectId, FINA_POS_Y_COIL_Y_CURRENT, this);
   lp_var_t<float> finaCoilZCurrent = lp_var_t<float>(sid.objectId, FINA_POS_Y_COIL_Z_CURRENT, this);
-  lp_var_t<uint16_t> finaCoilXTemperature =
-      lp_var_t<uint16_t>(sid.objectId, FINA_POS_Y_COIL_X_TEMPERATURE, this);
-  lp_var_t<uint16_t> finaCoilYTemperature =
-      lp_var_t<uint16_t>(sid.objectId, FINA_POS_Y_COIL_Y_TEMPERATURE, this);
-  lp_var_t<uint16_t> finaCoilZTemperature =
-      lp_var_t<uint16_t>(sid.objectId, FINA_POS_Y_COIL_Z_TEMPERATURE, this);
+  lp_var_t<int16_t> finaCoilXTemperature =
+      lp_var_t<int16_t>(sid.objectId, FINA_POS_Y_COIL_X_TEMPERATURE, this);
+  lp_var_t<int16_t> finaCoilYTemperature =
+      lp_var_t<int16_t>(sid.objectId, FINA_POS_Y_COIL_Y_TEMPERATURE, this);
+  lp_var_t<int16_t> finaCoilZTemperature =
+      lp_var_t<int16_t>(sid.objectId, FINA_POS_Y_COIL_Z_TEMPERATURE, this);
 };
 
 /**
@@ -734,12 +734,12 @@ class NegYSelfTestSet : public StaticLocalDataSet<SELF_TEST_DATASET_ENTRIES> {
   lp_var_t<float> initCoilXCurrent = lp_var_t<float>(sid.objectId, INIT_NEG_Y_COIL_X_CURRENT, this);
   lp_var_t<float> initCoilYCurrent = lp_var_t<float>(sid.objectId, INIT_NEG_Y_COIL_Y_CURRENT, this);
   lp_var_t<float> initCoilZCurrent = lp_var_t<float>(sid.objectId, INIT_NEG_Y_COIL_Z_CURRENT, this);
-  lp_var_t<uint16_t> initCoilXTemperature =
-      lp_var_t<uint16_t>(sid.objectId, INIT_NEG_Y_COIL_X_TEMPERATURE, this);
-  lp_var_t<uint16_t> initCoilYTemperature =
-      lp_var_t<uint16_t>(sid.objectId, INIT_NEG_Y_COIL_Y_TEMPERATURE, this);
-  lp_var_t<uint16_t> initCoilZTemperature =
-      lp_var_t<uint16_t>(sid.objectId, INIT_NEG_Y_COIL_Z_TEMPERATURE, this);
+  lp_var_t<int16_t> initCoilXTemperature =
+      lp_var_t<int16_t>(sid.objectId, INIT_NEG_Y_COIL_X_TEMPERATURE, this);
+  lp_var_t<int16_t> initCoilYTemperature =
+      lp_var_t<int16_t>(sid.objectId, INIT_NEG_Y_COIL_Y_TEMPERATURE, this);
+  lp_var_t<int16_t> initCoilZTemperature =
+      lp_var_t<int16_t>(sid.objectId, INIT_NEG_Y_COIL_Z_TEMPERATURE, this);
 
   /** -Y block */
   lp_var_t<uint8_t> err = lp_var_t<uint8_t>(sid.objectId, NEG_Y_ERR, this);
@@ -752,12 +752,12 @@ class NegYSelfTestSet : public StaticLocalDataSet<SELF_TEST_DATASET_ENTRIES> {
   lp_var_t<float> coilXCurrent = lp_var_t<float>(sid.objectId, NEG_Y_COIL_X_CURRENT, this);
   lp_var_t<float> coilYCurrent = lp_var_t<float>(sid.objectId, NEG_Y_COIL_Y_CURRENT, this);
   lp_var_t<float> coilZCurrent = lp_var_t<float>(sid.objectId, NEG_Y_COIL_Z_CURRENT, this);
-  lp_var_t<uint16_t> coilXTemperature =
-      lp_var_t<uint16_t>(sid.objectId, NEG_Y_COIL_X_TEMPERATURE, this);
-  lp_var_t<uint16_t> coilYTemperature =
-      lp_var_t<uint16_t>(sid.objectId, NEG_Y_COIL_Y_TEMPERATURE, this);
-  lp_var_t<uint16_t> coilZTemperature =
-      lp_var_t<uint16_t>(sid.objectId, NEG_Y_COIL_Z_TEMPERATURE, this);
+  lp_var_t<int16_t> coilXTemperature =
+      lp_var_t<int16_t>(sid.objectId, NEG_Y_COIL_X_TEMPERATURE, this);
+  lp_var_t<int16_t> coilYTemperature =
+      lp_var_t<int16_t>(sid.objectId, NEG_Y_COIL_Y_TEMPERATURE, this);
+  lp_var_t<int16_t> coilZTemperature =
+      lp_var_t<int16_t>(sid.objectId, NEG_Y_COIL_Z_TEMPERATURE, this);
 
   /** FINA block */
   lp_var_t<uint8_t> finaErr = lp_var_t<uint8_t>(sid.objectId, FINA_NEG_Y_ERR, this);
@@ -770,12 +770,12 @@ class NegYSelfTestSet : public StaticLocalDataSet<SELF_TEST_DATASET_ENTRIES> {
   lp_var_t<float> finaCoilXCurrent = lp_var_t<float>(sid.objectId, FINA_NEG_Y_COIL_X_CURRENT, this);
   lp_var_t<float> finaCoilYCurrent = lp_var_t<float>(sid.objectId, FINA_NEG_Y_COIL_Y_CURRENT, this);
   lp_var_t<float> finaCoilZCurrent = lp_var_t<float>(sid.objectId, FINA_NEG_Y_COIL_Z_CURRENT, this);
-  lp_var_t<uint16_t> finaCoilXTemperature =
-      lp_var_t<uint16_t>(sid.objectId, FINA_NEG_Y_COIL_X_TEMPERATURE, this);
-  lp_var_t<uint16_t> finaCoilYTemperature =
-      lp_var_t<uint16_t>(sid.objectId, FINA_NEG_Y_COIL_Y_TEMPERATURE, this);
-  lp_var_t<uint16_t> finaCoilZTemperature =
-      lp_var_t<uint16_t>(sid.objectId, FINA_NEG_Y_COIL_Z_TEMPERATURE, this);
+  lp_var_t<int16_t> finaCoilXTemperature =
+      lp_var_t<int16_t>(sid.objectId, FINA_NEG_Y_COIL_X_TEMPERATURE, this);
+  lp_var_t<int16_t> finaCoilYTemperature =
+      lp_var_t<int16_t>(sid.objectId, FINA_NEG_Y_COIL_Y_TEMPERATURE, this);
+  lp_var_t<int16_t> finaCoilZTemperature =
+      lp_var_t<int16_t>(sid.objectId, FINA_NEG_Y_COIL_Z_TEMPERATURE, this);
 };
 
 /**
@@ -829,12 +829,12 @@ class PosZSelfTestSet : public StaticLocalDataSet<SELF_TEST_DATASET_ENTRIES> {
   lp_var_t<float> coilXCurrent = lp_var_t<float>(sid.objectId, POS_Z_COIL_X_CURRENT, this);
   lp_var_t<float> coilYCurrent = lp_var_t<float>(sid.objectId, POS_Z_COIL_Y_CURRENT, this);
   lp_var_t<float> coilZCurrent = lp_var_t<float>(sid.objectId, POS_Z_COIL_Z_CURRENT, this);
-  lp_var_t<uint16_t> coilXTemperature =
-      lp_var_t<uint16_t>(sid.objectId, POS_Z_COIL_X_TEMPERATURE, this);
-  lp_var_t<uint16_t> coilYTemperature =
-      lp_var_t<uint16_t>(sid.objectId, POS_Z_COIL_Y_TEMPERATURE, this);
-  lp_var_t<uint16_t> coilZTemperature =
-      lp_var_t<uint16_t>(sid.objectId, POS_Z_COIL_Z_TEMPERATURE, this);
+  lp_var_t<int16_t> coilXTemperature =
+      lp_var_t<int16_t>(sid.objectId, POS_Z_COIL_X_TEMPERATURE, this);
+  lp_var_t<int16_t> coilYTemperature =
+      lp_var_t<int16_t>(sid.objectId, POS_Z_COIL_Y_TEMPERATURE, this);
+  lp_var_t<int16_t> coilZTemperature =
+      lp_var_t<int16_t>(sid.objectId, POS_Z_COIL_Z_TEMPERATURE, this);
 
   /** FINA block */
   lp_var_t<uint8_t> finaErr = lp_var_t<uint8_t>(sid.objectId, FINA_POS_Z_ERR, this);
@@ -847,12 +847,12 @@ class PosZSelfTestSet : public StaticLocalDataSet<SELF_TEST_DATASET_ENTRIES> {
   lp_var_t<float> finaCoilXCurrent = lp_var_t<float>(sid.objectId, FINA_POS_Z_COIL_X_CURRENT, this);
   lp_var_t<float> finaCoilYCurrent = lp_var_t<float>(sid.objectId, FINA_POS_Z_COIL_Y_CURRENT, this);
   lp_var_t<float> finaCoilZCurrent = lp_var_t<float>(sid.objectId, FINA_POS_Z_COIL_Z_CURRENT, this);
-  lp_var_t<uint16_t> finaCoilXTemperature =
-      lp_var_t<uint16_t>(sid.objectId, FINA_POS_Z_COIL_X_TEMPERATURE, this);
-  lp_var_t<uint16_t> finaCoilYTemperature =
-      lp_var_t<uint16_t>(sid.objectId, FINA_POS_Z_COIL_Y_TEMPERATURE, this);
-  lp_var_t<uint16_t> finaCoilZTemperature =
-      lp_var_t<uint16_t>(sid.objectId, FINA_POS_Z_COIL_Z_TEMPERATURE, this);
+  lp_var_t<int16_t> finaCoilXTemperature =
+      lp_var_t<int16_t>(sid.objectId, FINA_POS_Z_COIL_X_TEMPERATURE, this);
+  lp_var_t<int16_t> finaCoilYTemperature =
+      lp_var_t<int16_t>(sid.objectId, FINA_POS_Z_COIL_Y_TEMPERATURE, this);
+  lp_var_t<int16_t> finaCoilZTemperature =
+      lp_var_t<int16_t>(sid.objectId, FINA_POS_Z_COIL_Z_TEMPERATURE, this);
 };
 
 /**
@@ -888,12 +888,12 @@ class NegZSelfTestSet : public StaticLocalDataSet<SELF_TEST_DATASET_ENTRIES> {
   lp_var_t<float> initCoilXCurrent = lp_var_t<float>(sid.objectId, INIT_NEG_Z_COIL_X_CURRENT, this);
   lp_var_t<float> initCoilYCurrent = lp_var_t<float>(sid.objectId, INIT_NEG_Z_COIL_Y_CURRENT, this);
   lp_var_t<float> initCoilZCurrent = lp_var_t<float>(sid.objectId, INIT_NEG_Z_COIL_Z_CURRENT, this);
-  lp_var_t<uint16_t> initCoilXTemperature =
-      lp_var_t<uint16_t>(sid.objectId, INIT_NEG_Z_COIL_X_TEMPERATURE, this);
-  lp_var_t<uint16_t> initCoilYTemperature =
-      lp_var_t<uint16_t>(sid.objectId, INIT_NEG_Z_COIL_Y_TEMPERATURE, this);
-  lp_var_t<uint16_t> initCoilZTemperature =
-      lp_var_t<uint16_t>(sid.objectId, INIT_NEG_Z_COIL_Z_TEMPERATURE, this);
+  lp_var_t<int16_t> initCoilXTemperature =
+      lp_var_t<int16_t>(sid.objectId, INIT_NEG_Z_COIL_X_TEMPERATURE, this);
+  lp_var_t<int16_t> initCoilYTemperature =
+      lp_var_t<int16_t>(sid.objectId, INIT_NEG_Z_COIL_Y_TEMPERATURE, this);
+  lp_var_t<int16_t> initCoilZTemperature =
+      lp_var_t<int16_t>(sid.objectId, INIT_NEG_Z_COIL_Z_TEMPERATURE, this);
 
   /** +Z block */
   lp_var_t<uint8_t> err = lp_var_t<uint8_t>(sid.objectId, NEG_Z_ERR, this);
@@ -906,12 +906,12 @@ class NegZSelfTestSet : public StaticLocalDataSet<SELF_TEST_DATASET_ENTRIES> {
   lp_var_t<float> coilXCurrent = lp_var_t<float>(sid.objectId, NEG_Z_COIL_X_CURRENT, this);
   lp_var_t<float> coilYCurrent = lp_var_t<float>(sid.objectId, NEG_Z_COIL_Y_CURRENT, this);
   lp_var_t<float> coilZCurrent = lp_var_t<float>(sid.objectId, NEG_Z_COIL_Z_CURRENT, this);
-  lp_var_t<uint16_t> coilXTemperature =
-      lp_var_t<uint16_t>(sid.objectId, NEG_Z_COIL_X_TEMPERATURE, this);
-  lp_var_t<uint16_t> coilYTemperature =
-      lp_var_t<uint16_t>(sid.objectId, NEG_Z_COIL_Y_TEMPERATURE, this);
-  lp_var_t<uint16_t> coilZTemperature =
-      lp_var_t<uint16_t>(sid.objectId, NEG_Z_COIL_Z_TEMPERATURE, this);
+  lp_var_t<int16_t> coilXTemperature =
+      lp_var_t<int16_t>(sid.objectId, NEG_Z_COIL_X_TEMPERATURE, this);
+  lp_var_t<int16_t> coilYTemperature =
+      lp_var_t<int16_t>(sid.objectId, NEG_Z_COIL_Y_TEMPERATURE, this);
+  lp_var_t<int16_t> coilZTemperature =
+      lp_var_t<int16_t>(sid.objectId, NEG_Z_COIL_Z_TEMPERATURE, this);
 
   /** FINA block */
   lp_var_t<uint8_t> finaErr = lp_var_t<uint8_t>(sid.objectId, FINA_NEG_Z_ERR, this);
@@ -924,12 +924,12 @@ class NegZSelfTestSet : public StaticLocalDataSet<SELF_TEST_DATASET_ENTRIES> {
   lp_var_t<float> finaCoilXCurrent = lp_var_t<float>(sid.objectId, FINA_NEG_Z_COIL_X_CURRENT, this);
   lp_var_t<float> finaCoilYCurrent = lp_var_t<float>(sid.objectId, FINA_NEG_Z_COIL_Y_CURRENT, this);
   lp_var_t<float> finaCoilZCurrent = lp_var_t<float>(sid.objectId, FINA_NEG_Z_COIL_Z_CURRENT, this);
-  lp_var_t<uint16_t> finaCoilXTemperature =
-      lp_var_t<uint16_t>(sid.objectId, FINA_NEG_Z_COIL_X_TEMPERATURE, this);
-  lp_var_t<uint16_t> finaCoilYTemperature =
-      lp_var_t<uint16_t>(sid.objectId, FINA_NEG_Z_COIL_Y_TEMPERATURE, this);
-  lp_var_t<uint16_t> finaCoilZTemperature =
-      lp_var_t<uint16_t>(sid.objectId, FINA_NEG_Z_COIL_Z_TEMPERATURE, this);
+  lp_var_t<int16_t> finaCoilXTemperature =
+      lp_var_t<int16_t>(sid.objectId, FINA_NEG_Z_COIL_X_TEMPERATURE, this);
+  lp_var_t<int16_t> finaCoilYTemperature =
+      lp_var_t<int16_t>(sid.objectId, FINA_NEG_Z_COIL_Y_TEMPERATURE, this);
+  lp_var_t<int16_t> finaCoilZTemperature =
+      lp_var_t<int16_t>(sid.objectId, FINA_NEG_Z_COIL_Z_TEMPERATURE, this);
 };
 
 }  // namespace IMTQ

mission/devices/devicedefinitions/SusDefinitions.h

@@ -61,7 +61,7 @@ static const uint8_t MAX_CMD_SIZE = 32;
 
 static const uint8_t POOL_ENTRIES = 7;
 
-enum Max1227PoolIds : lp_id_t { TEMPERATURE_C, CHANNEL_VEC };
+enum SusPoolIds : lp_id_t { TEMPERATURE_C, CHANNEL_VEC };
 
 class SusDataset : public StaticLocalDataSet<POOL_ENTRIES> {
  public:

mission/devices/devicedefinitions/SyrlinksDefinitions.h

@@ -110,10 +110,10 @@ class TemperatureSet : public StaticLocalDataSet<TEMPERATURE_SET_SIZE> {
 
   TemperatureSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, TEMPERATURE_SET_ID)) {}
 
-  lp_var_t<uint16_t> temperaturePowerAmplifier =
-      lp_var_t<uint16_t>(sid.objectId, TEMP_POWER_AMPLIFIER, this);
-  lp_var_t<uint16_t> temperatureBasebandBoard =
-      lp_var_t<uint16_t>(sid.objectId, TEMP_BASEBAND_BOARD, this);
+  lp_var_t<float> temperaturePowerAmplifier =
+      lp_var_t<float>(sid.objectId, TEMP_POWER_AMPLIFIER, this);
+  lp_var_t<float> temperatureBasebandBoard =
+      lp_var_t<float>(sid.objectId, TEMP_BASEBAND_BOARD, this);
 };
 
 }  // namespace syrlinks

mission/devices/max1227.cpp

@@ -25,4 +25,7 @@ void max1227::prepareExternallyClockedTemperatureRead(uint8_t *spiBuf, size_t &s
   sz += 25;
 }
 
-float max1227::getTemperature(int16_t temp) { return static_cast<float>(temp) * 0.125; }
+float max1227::getTemperature(uint16_t raw) {
+  float temp = static_cast<float>((-2048 * (raw >> 11)) + (raw & 0x7FF)) * 0.125;
+  return temp;
+}

mission/devices/max1227.h

@@ -77,7 +77,7 @@ void prepareExternallyClockedRead0ToN(uint8_t* spiBuf, uint8_t n, size_t& sz);
  */
 void prepareExternallyClockedTemperatureRead(uint8_t* spiBuf, size_t& sz);
 
-float getTemperature(int16_t temp);
+float getTemperature(uint16_t raw);
 
 }  // namespace max1227
 

mission/utility/compileTime.h

@@ -38,18 +38,37 @@
 
 // Custom "glue logic" to convert the month name to a usable number
 #define GET_MONTH(str, i)                                                                         \
-  (str[i] == 'J' && str[i + 1] == 'a' && str[i + 2] == 'n'   ? 1  \
-   : str[i] == 'F' && str[i + 1] == 'e' && str[i + 2] == 'b' ? 2  \
-   : str[i] == 'M' && str[i + 1] == 'a' && str[i + 2] == 'r' ? 3  \
-   : str[i] == 'A' && str[i + 1] == 'p' && str[i + 2] == 'r' ? 4  \
-   : str[i] == 'M' && str[i + 1] == 'a' && str[i + 2] == 'y' ? 5  \
-   : str[i] == 'J' && str[i + 1] == 'u' && str[i + 2] == 'n' ? 6  \
-   : str[i] == 'J' && str[i + 1] == 'u' && str[i + 2] == 'l' ? 7  \
-   : str[i] == 'A' && str[i + 1] == 'u' && str[i + 2] == 'g' ? 8  \
-   : str[i] == 'S' && str[i + 1] == 'e' && str[i + 2] == 'p' ? 9  \
-   : str[i] == 'O' && str[i + 1] == 'c' && str[i + 2] == 't' ? 10 \
-   : str[i] == 'N' && str[i + 1] == 'o' && str[i + 2] == 'v' ? 11 \
-   : str[i] == 'D' && str[i + 1] == 'e' && str[i + 2] == 'c' ? 12 \
+  (str[i] == 'J' && str[i + 1] == 'a' && str[i + 2] == 'n'                                        \
+       ? 1                                                                                        \
+       : str[i] == 'F' && str[i + 1] == 'e' && str[i + 2] == 'b'                                  \
+             ? 2                                                                                  \
+             : str[i] == 'M' && str[i + 1] == 'a' && str[i + 2] == 'r'                            \
+                   ? 3                                                                            \
+                   : str[i] == 'A' && str[i + 1] == 'p' && str[i + 2] == 'r'                      \
+                         ? 4                                                                      \
+                         : str[i] == 'M' && str[i + 1] == 'a' && str[i + 2] == 'y'                \
+                               ? 5                                                                \
+                               : str[i] == 'J' && str[i + 1] == 'u' && str[i + 2] == 'n'          \
+                                     ? 6                                                          \
+                                     : str[i] == 'J' && str[i + 1] == 'u' && str[i + 2] == 'l'    \
+                                           ? 7                                                    \
+                                           : str[i] == 'A' && str[i + 1] == 'u' &&                \
+                                                     str[i + 2] == 'g'                            \
+                                                 ? 8                                              \
+                                                 : str[i] == 'S' && str[i + 1] == 'e' &&          \
+                                                           str[i + 2] == 'p'                      \
+                                                       ? 9                                        \
+                                                       : str[i] == 'O' && str[i + 1] == 'c' &&    \
+                                                                 str[i + 2] == 't'                \
+                                                             ? 10                                 \
+                                                             : str[i] == 'N' &&                   \
+                                                                       str[i + 1] == 'o' &&       \
+                                                                       str[i + 2] == 'v'          \
+                                                                   ? 11                           \
+                                                                   : str[i] == 'D' &&             \
+                                                                             str[i + 1] == 'e' && \
+                                                                             str[i + 2] == 'c'    \
+                                                                         ? 12                     \
                                                                          : 0)
 
 // extract the information from the time string given by __TIME__ and __DATE__

scripts/auto-formatter.sh

@@ -12,6 +12,7 @@ folder_list=(
   "./bsp_egse"
   "./test"
   "./common"
+  "./dummies"
 )
 
 cmake_fmt="cmake-format"

scripts/q7s-port-local.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+echo "Setting up all Q7S ports"
+echo "-L 1534:localhost:1534 root@192.168.155.55 for connection to the TCF agent on the FM"
+echo "-L 1560:localhost:7301 root@192.168.155.55 for TMTC commanding using the TCP/IP IF on the FM"
+
+
+ssh -L 1534:localhost:1534 root@192.168.155.55
+ssh -L 1560:localhost:7301 root@192.168.155.55

tmtc

@@ -1 +1 @@
-Subproject commit ef349856d614be7a408ffadf0c27c677d8be3157
+Subproject commit c9d35df27741f7cd6250c27ed9771e9979c6c5e7

unittest/controller/testThermalController.cpp

@@ -1,4 +1,8 @@
+#include <dummies/SusDummy.h>
+#include <dummies/TemperatureSensorsDummy.h>
 #include <fsfw/ipc/QueueFactory.h>
+#include <fsfw/tasks/PeriodicTaskIF.h>
+#include <fsfw/tasks/TaskFactory.h>
 #include <mission/controller/ThermalController.h>
 
 #include <catch2/catch_test_macros.hpp>
@@ -8,10 +12,20 @@
 TEST_CASE("Thermal Controller", "[ThermalController]") {
   const object_id_t THERMAL_CONTROLLER_ID = 0x123;
 
-  ThermalController controller(THERMAL_CONTROLLER_ID, objects::NO_OBJECT);
+  new TemperatureSensorsDummy();
+  new SusDummy();
 
   testEnvironment::initialize();
 
+  ThermalController controller(THERMAL_CONTROLLER_ID, objects::NO_OBJECT);
+  ReturnValue_t result = controller.initialize();
+  REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+
+  PeriodicTaskIF* thermalTask = TaskFactory::instance()->createPeriodicTask(
+      "THERMAL_CTL_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, nullptr);
+  result = thermalTask->addComponent(THERMAL_CONTROLLER_ID);
+  REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+
   REQUIRE(controller.initializeAfterTaskCreation() == HasReturnvaluesIF::RETURN_OK);
 
   testEnvironment::eventManager->clearEventList();
@@ -34,12 +48,5 @@ TEST_CASE("Thermal Controller", "[ThermalController]") {
               THERMAL_CONTROLLER_ID, HasModesIF::MODE_INFO, ControllerBase::MODE_NORMAL,
               HasModesIF::SUBMODE_NONE) == true);
 
-  thermalControllerDefinitions::ComponentTemperatures componentTemperatures(THERMAL_CONTROLLER_ID);
-
-  componentTemperatures.read();
-  REQUIRE(componentTemperatures.rw == 0);
-
-  componentTemperatures.commit();
-
   QueueFactory::instance()->deleteMessageQueue(commandQueue);
 }

unittest/mocks/HouseKeepingMock.cpp

@@ -1,7 +1,12 @@
 #include "HouseKeepingMock.h"
 
+#include <fsfw/ipc/QueueFactory.h>
 #include <fsfw/objectmanager/frameworkObjects.h>
 
-HouseKeepingMock::HouseKeepingMock() : SystemObject(objects::PUS_SERVICE_3_HOUSEKEEPING) {}
+HouseKeepingMock::HouseKeepingMock() : SystemObject(objects::PUS_SERVICE_3_HOUSEKEEPING) {
+  auto mqArgs = MqArgs(objects::PUS_SERVICE_3_HOUSEKEEPING, static_cast<void*>(this));
+  commandQueue = QueueFactory::instance()->createMessageQueue(
+      5, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+}
 
-MessageQueueId_t HouseKeepingMock::getHkQueue() const { return MessageQueueIF::NO_QUEUE; }
+MessageQueueId_t HouseKeepingMock::getHkQueue() const { return commandQueue->getId(); }

unittest/mocks/HouseKeepingMock.h

@@ -10,6 +10,9 @@ class HouseKeepingMock : public SystemObject, public AcceptsHkPacketsIF {
   HouseKeepingMock();
 
   virtual MessageQueueId_t getHkQueue() const;
+
+ private:
+  MessageQueueIF *commandQueue = nullptr;
 };
 
 #endif /*HOUSEKEEPINGMOCK_H_*/