CHANGELOG.md

@@ -10,6 +10,23 @@ list yields a list of all related PRs for each release.
 
 # [unreleased]
 
+# [v1.16.0] 18.11.2022
+
+- It is now possible to compile Linux components for the hosted build conditionally
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/322
+- ACS Subsystem. PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/231
+- Payload Subsystem. PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/231
+- Add IRQ mode for PDEC handler. PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/310
+- Extended TM funnels to allow multiple TM recipients.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/312
+- DHB: Transitions to normal mode now possible directly, which simplifies subsystem implementations
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/313
+- MAX3185 Low Level Handler and Device Handler: Simplifications and bugfixes to allow switching
+  off without triggering unrequested replies
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/313
+- Add remaining missing TMP1075 device handlers.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/318
+
 # [v1.15.0] 27.10.2022
 
 - Consistent device file naming
@@ -52,6 +69,7 @@ list yields a list of all related PRs for each release.
 - Fix for EM SW: Always create ACS Task
 - Added Scex device handler and Scex uart reader
   PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/303
+- ACS Subsystem. PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/228
 
 # [v1.13.0] 24.08.2022
 

CMakeLists.txt

@@ -10,7 +10,7 @@
 cmake_minimum_required(VERSION 3.13)
 
 set(OBSW_VERSION_MAJOR_IF_GIT_FAILS 1)
-set(OBSW_VERSION_MINOR_IF_GIT_FAILS 15)
+set(OBSW_VERSION_MINOR_IF_GIT_FAILS 16)
 set(OBSW_VERSION_REVISION_IF_GIT_FAILS 0)
 
 # set(CMAKE_VERBOSE TRUE)
@@ -149,6 +149,9 @@ set(OBSW_ADD_RW
 set(OBSW_ADD_SCEX_DEVICE
     ${INIT_VAL}
     CACHE STRING "Add Solar Cell Experiment module")
+set(OBSW_SYRLINKS_SIMULATED
+    ${OBSW_Q7S_EM}
+    CACHE STRING "Syrlinks is simulated")
 
 # ##############################################################################
 # Pre-Sources preparation
@@ -230,7 +233,7 @@ set(LIB_ARCSEC_PATH ${THIRD_PARTY_FOLDER}/arcsec_star_tracker)
 set(LIB_JSON_PATH ${THIRD_PARTY_FOLDER}/json)
 
 set(FSFW_WARNING_SHADOW_LOCAL_GCC OFF)
-set(EIVE_ADD_LINUX_FILES False)
+set(EIVE_ADD_LINUX_FILES OFF)
 
 # Analyse different OS and architecture/target options, determine BSP_PATH,
 # display information about compiler etc.
@@ -250,12 +253,15 @@ if(TGT_BSP)
     set(FSFW_CONFIG_PATH "linux/fsfwconfig")
     if(NOT BUILD_Q7S_SIMPLE_MODE)
       set(EIVE_ADD_LINUX_FILES TRUE)
+      set(EIVE_ADD_LINUX_FSFWCONFIG TRUE)
       set(ADD_GOMSPACE_CSP TRUE)
       set(ADD_GOMSPACE_CLIENTS TRUE)
       set(FSFW_HAL_ADD_LINUX ON)
       set(FSFW_HAL_LINUX_ADD_LIBGPIOD ON)
       set(FSFW_HAL_LINUX_ADD_PERIPHERAL_DRIVERS ON)
     endif()
+  elseif(UNIX)
+    set(EIVE_ADD_LINUX_FILES ON)
   endif()
 
   if(TGT_BSP MATCHES "arm/raspberrypi")
@@ -390,7 +396,7 @@ if(EIVE_ADD_JSON_LIB)
   add_subdirectory(${LIB_JSON_PATH})
 endif()
 
-add_subdirectory(thirdparty/rapidcsv)
+add_subdirectory(thirdparty)
 
 if(EIVE_ADD_LINUX_FILES)
   add_subdirectory(${LIB_ARCSEC_PATH})

README.md

@@ -1108,11 +1108,19 @@ cat /proc/tty/driver
 
 ## I2C
 
-Getting information about I2C device
-````
+Getting information about some I2C device
+
+```sh
 ls /sys/class/i2c-dev/i2c-0/device/device/driver
-````
-This shows the memory mapping of /dev/i2c-0
+```
+This shows the memory mapping of `/dev/i2c-0`.
+
+You can use the `i2cdetect` utility to scan for I2C devices.
+For example, to do this for bus 0 (`/dev/i2c-0`), you can use
+
+```sh
+i2cdetect -r -y 0
+```
 
 ## CAN
 

bsp_egse/ObjectFactory.cpp

@@ -1,8 +1,8 @@
 #include "ObjectFactory.h"
 
 #include <devConf.h>
-#include <fsfw_hal/linux/uart/UartComIF.h>
-#include <fsfw_hal/linux/uart/UartCookie.h>
+#include <fsfw_hal/linux/serial/SerialComIF.h>
+#include <fsfw_hal/linux/serial/SerialCookie.h>
 
 #include "OBSWConfig.h"
 #include "busConf.h"
@@ -39,7 +39,7 @@ void ObjectFactory::produce(void* args) {
   UartCookie* starTrackerCookie =
       new UartCookie(objects::STAR_TRACKER, egse::STAR_TRACKER_UART, UartModes::NON_CANONICAL,
                      uart::STAR_TRACKER_BAUD, startracker::MAX_FRAME_SIZE * 2 + 2);
-  new UartComIF(objects::UART_COM_IF);
+  newSerialComIF(objects::UART_COM_IF);
   starTrackerCookie->setNoFixedSizeReply();
   StrHelper* strHelper = new StrHelper(objects::STR_HELPER);
   StarTrackerHandler* starTrackerHandler = new StarTrackerHandler(

bsp_hosted/ObjectFactory.cpp

@@ -4,7 +4,7 @@
 #include <fsfw/tmtcservices/PusServiceBase.h>
 #include <mission/controller/ThermalController.h>
 #include <mission/core/GenericFactory.h>
-#include <mission/tmtc/TmFunnel.h>
+#include <mission/tmtc/TmFunnelHandler.h>
 #include <objects/systemObjectList.h>
 #include <tmtc/pusIds.h>
 
@@ -59,12 +59,14 @@ void Factory::setStaticFrameworkObjectIds() {
 
 void ObjectFactory::produce(void* args) {
   Factory::setStaticFrameworkObjectIds();
-  ObjectFactory::produceGenericObjects();
+  PusTmFunnel* pusFunnel;
+  CfdpTmFunnel* cfdpFunnel;
+  ObjectFactory::produceGenericObjects(nullptr, &pusFunnel, &cfdpFunnel);
 
   dummy::DummyCfg cfg;
   dummy::createDummies(cfg);
   new TemperatureSensorsDummy();
   new SusDummy();
-  new ThermalController(objects::THERMAL_CONTROLLER, objects::NO_OBJECT);
+  new ThermalController(objects::THERMAL_CONTROLLER);
   new TestTask(objects::TEST_TASK);
 }

bsp_linux_board/CMakeLists.txt

@@ -3,3 +3,4 @@ target_sources(${OBSW_NAME} PUBLIC InitMission.cpp main.cpp gpioInit.cpp
 
 add_subdirectory(boardconfig)
 add_subdirectory(boardtest)
+add_subdirectory(fsfwconfig)

bsp_linux_board/ObjectFactory.cpp

@@ -34,8 +34,8 @@
 #include "fsfw/osal/common/UdpTmTcBridge.h"
 #endif
 
-#include <fsfw_hal/linux/uart/UartComIF.h>
-#include <fsfw_hal/linux/uart/UartCookie.h>
+#include <fsfw_hal/linux/serial/SerialComIF.h>
+#include <fsfw_hal/linux/serial/SerialCookie.h>
 
 #include "fsfw_hal/common/gpio/GpioCookie.h"
 #include "fsfw_hal/devicehandlers/GyroL3GD20Handler.h"
@@ -202,7 +202,7 @@ void ObjectFactory::createTestTasks() {
 #if OBSW_ADD_UART_TEST_CODE == 1
   new UartTestClass(objects::UART_TEST);
 #else
-  new UartComIF(objects::UART_COM_IF);
+  newSerialComIF(objects::UART_COM_IF);
 #endif
 
 #if RPI_LOOPBACK_TEST_GPIO == 1

bsp_q7s/OBSWConfig.h.in

@@ -60,12 +60,12 @@
 /*******************************************************************/
 
 // Can be used to switch device to NORMAL mode immediately
-#define OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP    1
+#define OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP    0
 #define OBSW_PRINT_MISSED_DEADLINES                 1
 
 #define OBSW_MPSOC_JTAG_BOOT                        0
 #define OBSW_STAR_TRACKER_GROUND_CONFIG             1
-#define OBSW_SYRLINKS_SIMULATED                     1
+#define OBSW_SYRLINKS_SIMULATED                     @OBSW_SYRLINKS_SIMULATED@
 #define OBSW_ADD_TEST_CODE                          0
 #define OBSW_ADD_TEST_TASK                          0
 #define OBSW_ADD_TEST_PST                           0
@@ -104,6 +104,7 @@
 #define OBSW_PRINT_CORE_HK                          0
 #define OBSW_DEBUG_PDU1                             0
 #define OBSW_DEBUG_PDU2                             0
+#define OBSW_DEBUG_TMP1075                          0
 #define OBSW_DEBUG_GPS                              0
 #define OBSW_DEBUG_ACU                              0
 #define OBSW_DEBUG_SYRLINKS                         0

bsp_q7s/boardconfig/busConf.h

@@ -8,7 +8,8 @@ static constexpr uint32_t SPI_MAIN_BUS_LOCK_TIMEOUT = 50;
 
 static constexpr char SPI_RW_DEV[] = "/dev/spi_rw";
 
-static constexpr char I2C_DEFAULT_DEV[] = "/dev/i2c_eive";
+static constexpr char I2C_PL_EIVE[] = "/dev/i2c_eive";
+static constexpr char I2C_PS_EIVE[] = "/dev/i2c-2";
 
 static constexpr char UART_GNSS_DEV[] = "/dev/gps0";
 static constexpr char UART_PLOC_MPSOC_DEV[] = "/dev/ul_plmpsoc";
@@ -20,7 +21,8 @@ static constexpr char UART_SCEX_DEV[] = "/dev/scex";
 static constexpr char UIO_PDEC_REGISTERS[] = "/dev/uio_pdec_regs";
 static constexpr char UIO_PTME[] = "/dev/uio_ptme";
 static constexpr char UIO_PDEC_CONFIG_MEMORY[] = "/dev/uio_pdec_cfg_mem";
-static constexpr char UIO_PDEC_RAM[] = "/dev/pdec_ram";
+static constexpr char UIO_PDEC_RAM[] = "/dev/uio_pdec_ram";
+static constexpr char UIO_PDEC_IRQ[] = "/dev/uio_pdec_irq";
 static constexpr int MAP_ID_PTME_CONFIG = 3;
 
 namespace uiomapids {

bsp_q7s/core/CoreController.cpp

@@ -31,10 +31,7 @@ xsc::Chip CoreController::CURRENT_CHIP = xsc::Chip::NO_CHIP;
 xsc::Copy CoreController::CURRENT_COPY = xsc::Copy::NO_COPY;
 
 CoreController::CoreController(object_id_t objectId)
-    : ExtendedControllerBase(objectId, objects::NO_OBJECT, 5),
-      opDivider5(5),
-      opDivider10(10),
-      hkSet(this) {
+    : ExtendedControllerBase(objectId, 5), opDivider5(5), opDivider10(10), hkSet(this) {
   ReturnValue_t result = returnvalue::OK;
   try {
     result = initWatchdogFifo();
@@ -50,10 +47,7 @@ CoreController::CoreController(object_id_t objectId)
       sdcMan->setBlocking(false);
     }
 
-    result = initBootCopy();
-    if (result != returnvalue::OK) {
-      sif::warning << "CoreController::CoreController: Boot copy init" << std::endl;
-    }
+    getCurrentBootCopy(CURRENT_CHIP, CURRENT_COPY);
   } catch (const std::filesystem::filesystem_error &e) {
     sif::error << "CoreController::CoreController: Failed with exception " << e.what() << std::endl;
   }
@@ -98,9 +92,9 @@ void CoreController::performControlOperation() {
 
 ReturnValue_t CoreController::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}));
+  localDataPoolMap.emplace(core::TEMPERATURE, &tempPoolEntry);
+  localDataPoolMap.emplace(core::PS_VOLTAGE, &psVoltageEntry);
+  localDataPoolMap.emplace(core::PL_VOLTAGE, &plVoltageEntry);
   poolManager.subscribeForRegularPeriodicPacket({hkSet.getSid(), false, 10.0});
   return returnvalue::OK;
 }
@@ -178,8 +172,7 @@ ReturnValue_t CoreController::initializeAfterTaskCreation() {
   setenv("PATH", updatedEnvPath.c_str(), true);
   updateProtInfo();
   initPrint();
-  ExtendedControllerBase::initializeAfterTaskCreation();
-  return result;
+  return ExtendedControllerBase::initializeAfterTaskCreation();
 }
 
 ReturnValue_t CoreController::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
@@ -800,7 +793,7 @@ ReturnValue_t CoreController::actionListDirectoryIntoFile(ActionId_t actionId,
   return returnvalue::OK;
 }
 
-ReturnValue_t CoreController::initBootCopy() {
+ReturnValue_t CoreController::initBootCopyFile() {
   if (not std::filesystem::exists(CURR_COPY_FILE)) {
     // This file is created by the systemd service eive-early-config so this should
     // not happen normally
@@ -810,8 +803,6 @@ ReturnValue_t CoreController::initBootCopy() {
       utility::handleSystemError(result, "CoreController::initBootCopy");
     }
   }
-
-  getCurrentBootCopy(CURRENT_CHIP, CURRENT_COPY);
   return returnvalue::OK;
 }
 
@@ -1247,6 +1238,10 @@ void CoreController::performMountedSdCardOperations() {
         std::filesystem::create_directory(path.str());
       }
       initVersionFile();
+      ReturnValue_t result = initBootCopyFile();
+      if (result != returnvalue::OK) {
+        sif::warning << "CoreController::CoreController: Boot copy init" << std::endl;
+      }
       initClockFromTimeFile();
       performRebootFileHandling(false);
     }

bsp_q7s/core/CoreController.h

@@ -226,6 +226,10 @@ class CoreController : public ExtendedControllerBase {
   PeriodicOperationDivider opDivider5;
   PeriodicOperationDivider opDivider10;
 
+  PoolEntry<float> tempPoolEntry = PoolEntry<float>(0.0);
+  PoolEntry<float> psVoltageEntry = PoolEntry<float>(0.0);
+  PoolEntry<float> plVoltageEntry = PoolEntry<float>(0.0);
+
   core::HkSet hkSet;
 
 #if OBSW_SD_CARD_MUST_BE_ON == 1
@@ -243,7 +247,7 @@ class CoreController : public ExtendedControllerBase {
   ReturnValue_t initClockFromTimeFile();
   ReturnValue_t performSdCardCheck();
   ReturnValue_t timeFileHandler();
-  ReturnValue_t initBootCopy();
+  ReturnValue_t initBootCopyFile();
   ReturnValue_t initWatchdogFifo();
   ReturnValue_t initSdCardBlocking();
   bool startSdStateMachine(sd::SdCard targetActiveSd, SdCfgMode mode, MessageQueueId_t commander,

bsp_q7s/core/InitMission.cpp

@@ -67,12 +67,6 @@ void initmission::initTasks() {
   void (*missedDeadlineFunc)(void) = nullptr;
 #endif
 
-  PeriodicTaskIF* sysCtrlTask = factory->createPeriodicTask(
-      "CORE_CTRL", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc);
-  result = sysCtrlTask->addComponent(objects::CORE_CONTROLLER);
-  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("CORE_CTRL", objects::CORE_CONTROLLER);
-  }
 #if OBSW_ADD_SA_DEPL == 1
   // Could add this to the core controller but the core controller does so many thing that I would
   // prefer to have the solar array deployment in a seprate task.
@@ -84,6 +78,17 @@ void initmission::initTasks() {
   }
 #endif
 
+  PeriodicTaskIF* sysTask = factory->createPeriodicTask(
+      "CORE_CTRL", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc);
+  result = sysTask->addComponent(objects::CORE_CONTROLLER);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("CORE_CTRL", objects::CORE_CONTROLLER);
+  }
+  result = sysTask->addComponent(objects::PL_SUBSYSTEM);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("PL_SUBSYSTEM", objects::PL_SUBSYSTEM);
+  }
+
   /* TMTC Distribution */
   PeriodicTaskIF* tmTcDistributor = factory->createPeriodicTask(
       "DIST", 45, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
@@ -127,11 +132,9 @@ void initmission::initTasks() {
     initmission::printAddObjectError("CCSDS Handler", objects::CCSDS_HANDLER);
   }
 
-  // Minimal distance between two received TCs amounts to 0.6 seconds
-  // If a command has not been read before the next one arrives, the old command will be
-  // overwritten by the PDEC.
+  // Runs in IRQ mode, frequency does not really matter
   PeriodicTaskIF* pdecHandlerTask = factory->createPeriodicTask(
-      "PDEC_HANDLER", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
+      "PDEC_HANDLER", 75, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
   result = pdecHandlerTask->addComponent(objects::PDEC_HANDLER);
   if (result != returnvalue::OK) {
     initmission::printAddObjectError("PDEC Handler", objects::PDEC_HANDLER);
@@ -184,6 +187,10 @@ void initmission::initTasks() {
     initmission::printAddObjectError("SUS_BOARD_ASS", objects::SUS_BOARD_ASS);
   }
 #endif
+  result = acsSysTask->addComponent(objects::ACS_SUBSYSTEM);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("ACS_SUBSYSTEM", objects::ACS_SUBSYSTEM);
+  }
 
 #if OBSW_ADD_RTD_DEVICES == 1
   PeriodicTaskIF* tcsPollingTask = factory->createPeriodicTask(
@@ -192,6 +199,7 @@ void initmission::initTasks() {
   if (result != returnvalue::OK) {
     initmission::printAddObjectError("SPI_RTD_POLLING", objects::SPI_RTD_COM_IF);
   }
+
   PeriodicTaskIF* tcsTask = factory->createPeriodicTask(
       "TCS_TASK", 45, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
   std::array<object_id_t, EiveMax31855::NUM_RTDS> rtdIds = {
@@ -270,14 +278,11 @@ void initmission::initTasks() {
   }
 #endif /* OBSW_ADD_PLOC_SUPERVISOR */
 
-#if OBSW_TEST_CCSDS_BRIDGE == 1
-  PeriodicTaskIF* ptmeTestTask = factory->createPeriodicTask(
-      "PTME_TEST", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
-  result = ptmeTestTask->addComponent(objects::CCSDS_IP_CORE_BRIDGE);
-  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("PTME_TEST", objects::CCSDS_IP_CORE_BRIDGE);
-  }
-#endif
+  PeriodicTaskIF* plTask = factory->createPeriodicTask(
+      "PL_TASK", 25, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
+  scheduling::addMpsocSupvHandlers(plTask);
+  plTask->addComponent(objects::CAM_SWITCHER);
+
 #if OBSW_ADD_SCEX_DEVICE == 1
   PeriodicTaskIF* scexDevHandler;
   PeriodicTaskIF* scexReaderTask;
@@ -290,6 +295,14 @@ void initmission::initTasks() {
   createPstTasks(*factory, missedDeadlineFunc, pstTasks);
 
 #if OBSW_ADD_TEST_CODE == 1
+#if OBSW_TEST_CCSDS_BRIDGE == 1
+  PeriodicTaskIF* ptmeTestTask = factory->createPeriodicTask(
+      "PTME_TEST", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+  result = ptmeTestTask->addComponent(objects::CCSDS_IP_CORE_BRIDGE);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("PTME_TEST", objects::CCSDS_IP_CORE_BRIDGE);
+  }
+#endif
   std::vector<PeriodicTaskIF*> testTasks;
   createTestTasks(*factory, missedDeadlineFunc, testTasks);
 #endif
@@ -316,7 +329,7 @@ void initmission::initTasks() {
   pdecHandlerTask->startTask();
 #endif /* OBSW_ADD_CCSDS_IP_CORES == 1 */
 
-  sysCtrlTask->startTask();
+  sysTask->startTask();
 #if OBSW_ADD_SA_DEPL == 1
   solarArrayDeplTask->startTask();
 #endif
@@ -462,7 +475,7 @@ void initmission::createPusTasks(TaskFactory& factory,
   taskVec.push_back(pusEvents);
 
   PeriodicTaskIF* pusHighPrio = factory.createPeriodicTask(
-      "PUS_HIGH_PRIO", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+      "PUS_HIGH_PRIO", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
   result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
   if (result != returnvalue::OK) {
     initmission::printAddObjectError("PUS_2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
@@ -471,6 +484,7 @@ void initmission::createPusTasks(TaskFactory& factory,
   if (result != returnvalue::OK) {
     initmission::printAddObjectError("PUS_9", objects::PUS_SERVICE_9_TIME_MGMT);
   }
+
   taskVec.push_back(pusHighPrio);
 
   PeriodicTaskIF* pusMedPrio = factory.createPeriodicTask(
@@ -500,14 +514,15 @@ void initmission::createPusTasks(TaskFactory& factory,
   if (result != returnvalue::OK) {
     initmission::printAddObjectError("PUS_201", objects::PUS_SERVICE_201_HEALTH);
   }
+  // Used for connection tests, therefore use higher priority
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_17_TEST);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("PUS_17", objects::PUS_SERVICE_17_TEST);
+  }
   taskVec.push_back(pusMedPrio);
 
   PeriodicTaskIF* pusLowPrio = factory.createPeriodicTask(
       "PUS_LOW_PRIO", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.6, missedDeadlineFunc);
-  result = pusLowPrio->addComponent(objects::PUS_SERVICE_17_TEST);
-  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("PUS_17", objects::PUS_SERVICE_17_TEST);
-  }
   result = pusLowPrio->addComponent(objects::INTERNAL_ERROR_REPORTER);
   if (result != returnvalue::OK) {
     initmission::printAddObjectError("ERROR_REPORTER", objects::INTERNAL_ERROR_REPORTER);

bsp_q7s/core/ObjectFactory.cpp

@@ -1,6 +1,7 @@
 #include "ObjectFactory.h"
 
-#include <linux/devices/ScexUartReader.h>
+#include <fsfw/subsystem/Subsystem.h>
+#include <mission/system/objects/CamSwitcher.h>
 
 #include "OBSWConfig.h"
 #include "bsp_q7s/boardtest/Q7STestTask.h"
@@ -23,6 +24,7 @@
 #include "linux/callbacks/gpioCallbacks.h"
 #include "linux/csp/CspComIF.h"
 #include "linux/devices/GPSHyperionLinuxController.h"
+#include "linux/devices/ScexUartReader.h"
 #include "linux/devices/devicedefinitions/PlocMPSoCDefinitions.h"
 #include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
 #include "linux/devices/ploc/PlocMPSoCHandler.h"
@@ -31,18 +33,22 @@
 #include "linux/devices/ploc/PlocSupervisorHandler.h"
 #include "linux/devices/startracker/StarTrackerHandler.h"
 #include "linux/devices/startracker/StrHelper.h"
-#include "linux/obc/AxiPtmeConfig.h"
-#include "linux/obc/PapbVcInterface.h"
-#include "linux/obc/PdecHandler.h"
-#include "linux/obc/Ptme.h"
-#include "linux/obc/PtmeConfig.h"
+#include "linux/ipcore/AxiPtmeConfig.h"
+#include "linux/ipcore/PapbVcInterface.h"
+#include "linux/ipcore/PdecHandler.h"
+#include "linux/ipcore/Ptme.h"
+#include "linux/ipcore/PtmeConfig.h"
 #include "mission/csp/CspCookie.h"
-#include "mission/system/RwAssembly.h"
 #include "mission/system/fdir/AcsBoardFdir.h"
 #include "mission/system/fdir/GomspacePowerFdir.h"
 #include "mission/system/fdir/RtdFdir.h"
 #include "mission/system/fdir/SusFdir.h"
 #include "mission/system/fdir/SyrlinksFdir.h"
+#include "mission/system/objects/AcsSubsystem.h"
+#include "mission/system/objects/RwAssembly.h"
+#include "mission/system/objects/TcsBoardAssembly.h"
+#include "mission/system/tree/acsModeTree.h"
+#include "mission/system/tree/payloadModeTree.h"
 #include "tmtc/pusIds.h"
 #if OBSW_TEST_LIBGPIOD == 1
 #include "linux/boardtest/LibgpiodTest.h"
@@ -63,10 +69,10 @@
 #include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
 #include "fsfw_hal/linux/i2c/I2cComIF.h"
 #include "fsfw_hal/linux/i2c/I2cCookie.h"
+#include "fsfw_hal/linux/serial/SerialComIF.h"
+#include "fsfw_hal/linux/serial/SerialCookie.h"
 #include "fsfw_hal/linux/spi/SpiComIF.h"
 #include "fsfw_hal/linux/spi/SpiCookie.h"
-#include "fsfw_hal/linux/uart/UartComIF.h"
-#include "fsfw_hal/linux/uart/UartCookie.h"
 #include "mission/core/GenericFactory.h"
 #include "mission/devices/ACUHandler.h"
 #include "mission/devices/BpxBatteryHandler.h"
@@ -89,9 +95,9 @@
 #include "mission/devices/devicedefinitions/RwDefinitions.h"
 #include "mission/devices/devicedefinitions/SyrlinksDefinitions.h"
 #include "mission/devices/devicedefinitions/payloadPcduDefinitions.h"
-#include "mission/system/AcsBoardAssembly.h"
-#include "mission/tmtc/CCSDSHandler.h"
-#include "mission/tmtc/TmFunnel.h"
+#include "mission/system/objects/AcsBoardAssembly.h"
+#include "mission/tmtc/CcsdsIpCoreHandler.h"
+#include "mission/tmtc/TmFunnelHandler.h"
 #include "mission/tmtc/VirtualChannel.h"
 
 ResetArgs RESET_ARGS_GNSS;
@@ -117,23 +123,30 @@ void Factory::setStaticFrameworkObjectIds() {
 void ObjectFactory::setStatics() { Factory::setStaticFrameworkObjectIds(); }
 
 void ObjectFactory::createTmpComponents() {
-  I2cCookie* i2cCookieTmp1075tcs1 =
-      new I2cCookie(addresses::TMP1075_TCS_1, TMP1075::MAX_REPLY_LENGTH, q7s::I2C_DEFAULT_DEV);
-  I2cCookie* i2cCookieTmp1075tcs2 =
-      new I2cCookie(addresses::TMP1075_TCS_2, TMP1075::MAX_REPLY_LENGTH, q7s::I2C_DEFAULT_DEV);
+  std::array<std::pair<object_id_t, address_t>, 5> tmpDevIds = {{
+      {objects::TMP1075_HANDLER_TCS_0, addresses::TMP1075_TCS_0},
+      {objects::TMP1075_HANDLER_TCS_1, addresses::TMP1075_TCS_1},
+      {objects::TMP1075_HANDLER_PLPCDU_0, addresses::TMP1075_PLPCDU_0},
+      {objects::TMP1075_HANDLER_PLPCDU_1, addresses::TMP1075_PLPCDU_1},
+      {objects::TMP1075_HANDLER_IF_BOARD, addresses::TMP1075_IF_BOARD},
+  }};
+  std::vector<I2cCookie*> tmpDevCookies;
 
-  /* Temperature sensors */
-  Tmp1075Handler* tmp1075Handler_1 =
-      new Tmp1075Handler(objects::TMP1075_HANDLER_1, objects::I2C_COM_IF, i2cCookieTmp1075tcs1);
-  (void)tmp1075Handler_1;
-  Tmp1075Handler* tmp1075Handler_2 =
-      new Tmp1075Handler(objects::TMP1075_HANDLER_2, objects::I2C_COM_IF, i2cCookieTmp1075tcs2);
-  (void)tmp1075Handler_2;
+  for (size_t idx = 0; idx < tmpDevIds.size(); idx++) {
+    tmpDevCookies.push_back(
+        new I2cCookie(tmpDevIds[idx].second, TMP1075::MAX_REPLY_LENGTH, q7s::I2C_PS_EIVE));
+    auto* tmpDevHandler =
+        new Tmp1075Handler(tmpDevIds[idx].first, objects::I2C_COM_IF, tmpDevCookies[idx]);
+    // TODO: Remove this after TCS subsystem was added
+    // These devices are connected to the 3V3 stack and should be powered permanently. Therefore,
+    // we set them to normal mode immediately here.
+    tmpDevHandler->setModeNormal();
+  }
 }
 
-void ObjectFactory::createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF, UartComIF** uartComIF,
-                                                  SpiComIF** spiMainComIF, I2cComIF** i2cComIF,
-                                                  SpiComIF** spiRWComIF) {
+void ObjectFactory::createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF,
+                                                  SerialComIF** uartComIF, SpiComIF** spiMainComIF,
+                                                  I2cComIF** i2cComIF, SpiComIF** spiRWComIF) {
   if (gpioComIF == nullptr or uartComIF == nullptr or spiMainComIF == nullptr or
       spiRWComIF == nullptr) {
     sif::error << "ObjectFactory::createCommunicationInterfaces: Invalid passed ComIF pointer"
@@ -144,7 +157,7 @@ void ObjectFactory::createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF, Ua
   /* Communication interfaces */
   new CspComIF(objects::CSP_COM_IF);
   *i2cComIF = new I2cComIF(objects::I2C_COM_IF);
-  *uartComIF = new UartComIF(objects::UART_COM_IF);
+  *uartComIF = new SerialComIF(objects::UART_COM_IF);
   *spiMainComIF = new SpiComIF(objects::SPI_MAIN_COM_IF, q7s::SPI_DEFAULT_DEV, **gpioComIF);
   *spiRWComIF = new SpiComIF(objects::SPI_RW_COM_IF, q7s::SPI_RW_DEV, **gpioComIF);
 }
@@ -224,10 +237,11 @@ ReturnValue_t ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF)
   return returnvalue::OK;
 }
 
-void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComIF* uartComIF,
+void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, SerialComIF* uartComIF,
                                              PowerSwitchIF* pwrSwitcher) {
   using namespace gpio;
   GpioCookie* gpioCookieAcsBoard = new GpioCookie();
+  std::vector<std::reference_wrapper<DeviceHandlerBase>> assemblyChildren;
 
   std::stringstream consumer;
   GpiodRegularByLineName* gpio = nullptr;
@@ -332,11 +346,11 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
   SpiCookie* spiCookie =
       new SpiCookie(addresses::MGM_0_LIS3, gpioIds::MGM_0_LIS3_CS, MGMLIS3MDL::MAX_BUFFER_SIZE,
                     spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED);
-  auto mgmLis3Handler = new MgmLIS3MDLHandler(objects::MGM_0_LIS3_HANDLER, objects::SPI_MAIN_COM_IF,
-                                              spiCookie, spi::LIS3_TRANSITION_DELAY);
+  auto mgmLis3Handler0 = new MgmLIS3MDLHandler(
+      objects::MGM_0_LIS3_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, spi::LIS3_TRANSITION_DELAY);
   fdir = new AcsBoardFdir(objects::MGM_0_LIS3_HANDLER);
-  mgmLis3Handler->setCustomFdir(fdir);
-  static_cast<void>(mgmLis3Handler);
+  mgmLis3Handler0->setCustomFdir(fdir);
+  assemblyChildren.push_back(*mgmLis3Handler0);
 #if OBSW_TEST_ACS == 1
   mgmLis3Handler->setStartUpImmediately();
   mgmLis3Handler->setToGoToNormalMode(true);
@@ -347,13 +361,12 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
   spiCookie =
       new SpiCookie(addresses::MGM_1_RM3100, gpioIds::MGM_1_RM3100_CS, RM3100::MAX_BUFFER_SIZE,
                     spi::DEFAULT_RM3100_MODE, spi::DEFAULT_RM3100_SPEED);
-  auto mgmRm3100Handler =
+  auto mgmRm3100Handler1 =
       new MgmRM3100Handler(objects::MGM_1_RM3100_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie,
                            spi::RM3100_TRANSITION_DELAY);
   fdir = new AcsBoardFdir(objects::MGM_1_RM3100_HANDLER);
-  mgmRm3100Handler->setCustomFdir(fdir);
-  mgmRm3100Handler->setParent(objects::ACS_BOARD_ASS);
-  static_cast<void>(mgmRm3100Handler);
+  mgmRm3100Handler1->setCustomFdir(fdir);
+  assemblyChildren.push_back(*mgmRm3100Handler1);
 #if OBSW_TEST_ACS == 1
   mgmRm3100Handler->setStartUpImmediately();
   mgmRm3100Handler->setToGoToNormalMode(true);
@@ -364,12 +377,11 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
   spiCookie =
       new SpiCookie(addresses::MGM_2_LIS3, gpioIds::MGM_2_LIS3_CS, MGMLIS3MDL::MAX_BUFFER_SIZE,
                     spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED);
-  mgmLis3Handler = new MgmLIS3MDLHandler(objects::MGM_2_LIS3_HANDLER, objects::SPI_MAIN_COM_IF,
-                                         spiCookie, spi::LIS3_TRANSITION_DELAY);
+  auto* mgmLis3Handler2 = new MgmLIS3MDLHandler(
+      objects::MGM_2_LIS3_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, spi::LIS3_TRANSITION_DELAY);
   fdir = new AcsBoardFdir(objects::MGM_2_LIS3_HANDLER);
-  mgmLis3Handler->setCustomFdir(fdir);
-  mgmLis3Handler->setParent(objects::ACS_BOARD_ASS);
-  static_cast<void>(mgmLis3Handler);
+  mgmLis3Handler2->setCustomFdir(fdir);
+  assemblyChildren.push_back(*mgmLis3Handler2);
 #if OBSW_TEST_ACS == 1
   mgmLis3Handler->setStartUpImmediately();
   mgmLis3Handler->setToGoToNormalMode(true);
@@ -380,11 +392,12 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
   spiCookie =
       new SpiCookie(addresses::MGM_3_RM3100, gpioIds::MGM_3_RM3100_CS, RM3100::MAX_BUFFER_SIZE,
                     spi::DEFAULT_RM3100_MODE, spi::DEFAULT_RM3100_SPEED);
-  mgmRm3100Handler = new MgmRM3100Handler(objects::MGM_3_RM3100_HANDLER, objects::SPI_MAIN_COM_IF,
-                                          spiCookie, spi::RM3100_TRANSITION_DELAY);
+  auto* mgmRm3100Handler3 =
+      new MgmRM3100Handler(objects::MGM_3_RM3100_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie,
+                           spi::RM3100_TRANSITION_DELAY);
   fdir = new AcsBoardFdir(objects::MGM_3_RM3100_HANDLER);
-  mgmRm3100Handler->setCustomFdir(fdir);
-  mgmRm3100Handler->setParent(objects::ACS_BOARD_ASS);
+  mgmRm3100Handler3->setCustomFdir(fdir);
+  assemblyChildren.push_back(*mgmRm3100Handler3);
 #if OBSW_TEST_ACS == 1
   mgmRm3100Handler->setStartUpImmediately();
   mgmRm3100Handler->setToGoToNormalMode(true);
@@ -402,8 +415,7 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
                                ADIS1650X::Type::ADIS16505);
   fdir = new AcsBoardFdir(objects::GYRO_0_ADIS_HANDLER);
   adisHandler->setCustomFdir(fdir);
-  adisHandler->setParent(objects::ACS_BOARD_ASS);
-  static_cast<void>(adisHandler);
+  assemblyChildren.push_back(*adisHandler);
 #if OBSW_TEST_ACS == 1
   adisHandler->setStartUpImmediately();
   adisHandler->setToGoToNormalModeImmediately();
@@ -414,12 +426,11 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
   // Gyro 1 Side A
   spiCookie = new SpiCookie(addresses::GYRO_1_L3G, gpioIds::GYRO_1_L3G_CS, L3GD20H::MAX_BUFFER_SIZE,
                             spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
-  auto gyroL3gHandler = new GyroHandlerL3GD20H(
+  auto gyroL3gHandler1 = new GyroHandlerL3GD20H(
       objects::GYRO_1_L3G_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, spi::L3G_TRANSITION_DELAY);
   fdir = new AcsBoardFdir(objects::GYRO_1_L3G_HANDLER);
-  gyroL3gHandler->setCustomFdir(fdir);
-  gyroL3gHandler->setParent(objects::ACS_BOARD_ASS);
-  static_cast<void>(gyroL3gHandler);
+  gyroL3gHandler1->setCustomFdir(fdir);
+  assemblyChildren.push_back(*gyroL3gHandler1);
 #if OBSW_TEST_ACS == 1
   gyroL3gHandler->setStartUpImmediately();
   gyroL3gHandler->setToGoToNormalMode(true);
@@ -435,7 +446,7 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
                                          spiCookie, ADIS1650X::Type::ADIS16505);
   fdir = new AcsBoardFdir(objects::GYRO_2_ADIS_HANDLER);
   adisHandler->setCustomFdir(fdir);
-  adisHandler->setParent(objects::ACS_BOARD_ASS);
+  assemblyChildren.push_back(*adisHandler);
 #if OBSW_TEST_ACS == 1
   adisHandler->setStartUpImmediately();
   adisHandler->setToGoToNormalModeImmediately();
@@ -443,11 +454,11 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
   // Gyro 3 Side B
   spiCookie = new SpiCookie(addresses::GYRO_3_L3G, gpioIds::GYRO_3_L3G_CS, L3GD20H::MAX_BUFFER_SIZE,
                             spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
-  gyroL3gHandler = new GyroHandlerL3GD20H(objects::GYRO_3_L3G_HANDLER, objects::SPI_MAIN_COM_IF,
-                                          spiCookie, spi::L3G_TRANSITION_DELAY);
+  auto gyroL3gHandler3 = new GyroHandlerL3GD20H(
+      objects::GYRO_3_L3G_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, spi::L3G_TRANSITION_DELAY);
   fdir = new AcsBoardFdir(objects::GYRO_3_L3G_HANDLER);
-  gyroL3gHandler->setCustomFdir(fdir);
-  gyroL3gHandler->setParent(objects::ACS_BOARD_ASS);
+  gyroL3gHandler3->setCustomFdir(fdir);
+  assemblyChildren.push_back(*gyroL3gHandler3);
 #if OBSW_TEST_ACS == 1
   gyroL3gHandler->setStartUpImmediately();
   gyroL3gHandler->setToGoToNormalMode(true);
@@ -469,9 +480,18 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
       objects::MGM_0_LIS3_HANDLER, objects::MGM_1_RM3100_HANDLER, objects::MGM_2_LIS3_HANDLER,
       objects::MGM_3_RM3100_HANDLER, objects::GYRO_0_ADIS_HANDLER, objects::GYRO_1_L3G_HANDLER,
       objects::GYRO_2_ADIS_HANDLER, objects::GYRO_3_L3G_HANDLER, objects::GPS_CONTROLLER);
-  auto acsAss = new AcsBoardAssembly(objects::ACS_BOARD_ASS, objects::NO_OBJECT, pwrSwitcher,
-                                     acsBoardHelper, gpioComIF);
+  auto acsAss =
+      new AcsBoardAssembly(objects::ACS_BOARD_ASS, pwrSwitcher, acsBoardHelper, gpioComIF);
   static_cast<void>(acsAss);
+  for (auto& assChild : assemblyChildren) {
+    ReturnValue_t result = assChild.get().connectModeTreeParent(*acsAss);
+    if (result != returnvalue::OK) {
+      sif::error << "Connecting assembly for ACS board component " << assChild.get().getObjectId()
+                 << " failed" << std::endl;
+    }
+  }
+  gpsCtrl->connectModeTreeParent(*acsAss);
+  acsAss->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
 #endif /* OBSW_ADD_ACS_HANDLERS == 1 */
 }
 
@@ -559,9 +579,9 @@ void ObjectFactory::createSolarArrayDeploymentComponents(PowerSwitchIF& pwrSwitc
 }
 
 void ObjectFactory::createSyrlinksComponents(PowerSwitchIF* pwrSwitcher) {
-  UartCookie* syrlinksUartCookie =
-      new UartCookie(objects::SYRLINKS_HK_HANDLER, q7s::UART_SYRLINKS_DEV, uart::SYRLINKS_BAUD,
-                     syrlinks::MAX_REPLY_SIZE, UartModes::NON_CANONICAL);
+  auto* syrlinksUartCookie =
+      new SerialCookie(objects::SYRLINKS_HK_HANDLER, q7s::UART_SYRLINKS_DEV, uart::SYRLINKS_BAUD,
+                       syrlinks::MAX_REPLY_SIZE, UartModes::NON_CANONICAL);
   syrlinksUartCookie->setParityEven();
 
   auto syrlinksFdir = new SyrlinksFdir(objects::SYRLINKS_HK_HANDLER);
@@ -574,9 +594,13 @@ void ObjectFactory::createSyrlinksComponents(PowerSwitchIF* pwrSwitcher) {
 #endif
 }
 
-void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF) {
+void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF& pwrSwitch) {
   using namespace gpio;
   std::stringstream consumer;
+  auto* camSwitcher =
+      new CamSwitcher(objects::CAM_SWITCHER, pwrSwitch, pcdu::PDU2_CH8_PAYLOAD_CAMERA);
+  camSwitcher->connectModeTreeParent(satsystem::pl::SUBSYSTEM);
+  // camSwitcher->
 #if OBSW_ADD_PLOC_MPSOC == 1
   consumer << "0x" << std::hex << objects::PLOC_MPSOC_HANDLER;
   auto gpioConfigMPSoC = new GpiodRegularByLineName(q7s::gpioNames::ENABLE_MPSOC_UART,
@@ -585,13 +609,14 @@ void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF) {
   mpsocGpioCookie->addGpio(gpioIds::ENABLE_MPSOC_UART, gpioConfigMPSoC);
   gpioChecker(gpioComIF->addGpios(mpsocGpioCookie), "PLOC MPSoC");
   auto mpsocCookie =
-      new UartCookie(objects::PLOC_MPSOC_HANDLER, q7s::UART_PLOC_MPSOC_DEV, uart::PLOC_MPSOC_BAUD,
-                     mpsoc::MAX_REPLY_SIZE, UartModes::NON_CANONICAL);
+      new SerialCookie(objects::PLOC_MPSOC_HANDLER, q7s::UART_PLOC_MPSOC_DEV, uart::PLOC_MPSOC_BAUD,
+                       mpsoc::MAX_REPLY_SIZE, UartModes::NON_CANONICAL);
   mpsocCookie->setNoFixedSizeReply();
   auto plocMpsocHelper = new PlocMPSoCHelper(objects::PLOC_MPSOC_HELPER);
-  new PlocMPSoCHandler(objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, mpsocCookie,
-                       plocMpsocHelper, Gpio(gpioIds::ENABLE_MPSOC_UART, gpioComIF),
-                       objects::PLOC_SUPERVISOR_HANDLER);
+  auto* mpsocHandler = new PlocMPSoCHandler(
+      objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, mpsocCookie, plocMpsocHelper,
+      Gpio(gpioIds::ENABLE_MPSOC_UART, gpioComIF), objects::PLOC_SUPERVISOR_HANDLER);
+  mpsocHandler->connectModeTreeParent(satsystem::pl::SUBSYSTEM);
 #endif /* OBSW_ADD_PLOC_MPSOC == 1 */
 #if OBSW_ADD_PLOC_SUPERVISOR == 1
   consumer << "0x" << std::hex << objects::PLOC_SUPERVISOR_HANDLER;
@@ -601,13 +626,14 @@ void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF) {
   supvGpioCookie->addGpio(gpioIds::ENABLE_SUPV_UART, gpioConfigSupv);
   gpioComIF->addGpios(supvGpioCookie);
   auto supervisorCookie =
-      new UartCookie(objects::PLOC_SUPERVISOR_HANDLER, q7s::UART_PLOC_SUPERVSIOR_DEV,
-                     uart::PLOC_SUPV_BAUD, supv::MAX_PACKET_SIZE * 20, UartModes::NON_CANONICAL);
+      new SerialCookie(objects::PLOC_SUPERVISOR_HANDLER, q7s::UART_PLOC_SUPERVSIOR_DEV,
+                       uart::PLOC_SUPV_BAUD, supv::MAX_PACKET_SIZE * 20, UartModes::NON_CANONICAL);
   supervisorCookie->setNoFixedSizeReply();
   auto supvHelper = new PlocSupvHelper(objects::PLOC_SUPERVISOR_HELPER);
-  new PlocSupervisorHandler(objects::PLOC_SUPERVISOR_HANDLER, objects::UART_COM_IF,
-                            supervisorCookie, Gpio(gpioIds::ENABLE_SUPV_UART, gpioComIF),
-                            pcdu::PDU1_CH6_PLOC_12V, supvHelper);
+  auto* supvHandler = new PlocSupervisorHandler(
+      objects::PLOC_SUPERVISOR_HANDLER, objects::UART_COM_IF, supervisorCookie,
+      Gpio(gpioIds::ENABLE_SUPV_UART, gpioComIF), pcdu::PDU1_CH6_PLOC_12V, supvHelper);
+  supvHandler->connectModeTreeParent(satsystem::pl::SUBSYSTEM);
 #endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
   static_cast<void>(consumer);
 }
@@ -684,13 +710,21 @@ void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF,
   }
 
   RwHelper rwHelper(rwIds);
-  auto* rwAss = new RwAssembly(objects::RW_ASS, objects::NO_OBJECT, pwrSwitcher,
-                               pcdu::Switches::PDU2_CH2_RW_5V, rwHelper);
-  static_cast<void>(rwAss);
+  auto* rwAss =
+      new RwAssembly(objects::RW_ASS, pwrSwitcher, pcdu::Switches::PDU2_CH2_RW_5V, rwHelper);
+  for (uint8_t idx = 0; idx < rws.size(); idx++) {
+    ReturnValue_t result = rws[idx]->connectModeTreeParent(*rwAss);
+    if (result != returnvalue::OK) {
+      sif::error << "Connecting RW " << static_cast<int>(idx) << " to RW assembly failed"
+                 << std::endl;
+    }
+  }
+  rwAss->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
 #endif /* OBSW_ADD_RW == 1 */
 }
 
-void ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF) {
+ReturnValue_t ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF,
+                                                   CcsdsIpCoreHandler** ipCoreHandler) {
   using namespace gpio;
   // GPIO definitions of signals connected to the virtual channel interfaces of the PTME IP Core
   GpioCookie* gpioCookiePtmeIp = new GpioCookie;
@@ -753,18 +787,19 @@ void ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF) {
 #else
   static const uint32_t TRANSMITTER_TIMEOUT = 900000;  // 15 minutes
 #endif
-  CCSDSHandler* ccsdsHandler = new CCSDSHandler(
+  *ipCoreHandler = new CcsdsIpCoreHandler(
       objects::CCSDS_HANDLER, objects::PTME, objects::CCSDS_PACKET_DISTRIBUTOR, ptmeConfig,
       gpioComIF, gpioIds::RS485_EN_TX_CLOCK, gpioIds::RS485_EN_TX_DATA, TRANSMITTER_TIMEOUT);
   VirtualChannel* vc = nullptr;
   vc = new VirtualChannel(ccsds::VC0, common::VC0_QUEUE_SIZE, objects::CCSDS_HANDLER);
-  ccsdsHandler->addVirtualChannel(ccsds::VC0, vc);
+  (*ipCoreHandler)->addVirtualChannel(ccsds::VC0, vc);
   vc = new VirtualChannel(ccsds::VC1, common::VC1_QUEUE_SIZE, objects::CCSDS_HANDLER);
-  ccsdsHandler->addVirtualChannel(ccsds::VC1, vc);
+  (*ipCoreHandler)->addVirtualChannel(ccsds::VC1, vc);
   vc = new VirtualChannel(ccsds::VC2, common::VC2_QUEUE_SIZE, objects::CCSDS_HANDLER);
-  ccsdsHandler->addVirtualChannel(ccsds::VC2, vc);
+  (*ipCoreHandler)->addVirtualChannel(ccsds::VC2, vc);
   vc = new VirtualChannel(ccsds::VC3, common::VC3_QUEUE_SIZE, objects::CCSDS_HANDLER);
-  ccsdsHandler->addVirtualChannel(ccsds::VC3, vc);
+  (*ipCoreHandler)->addVirtualChannel(ccsds::VC3, vc);
+
   GpioCookie* gpioCookiePdec = new GpioCookie;
   consumer.str("");
   consumer << "0x" << std::hex << objects::PDEC_HANDLER;
@@ -773,8 +808,13 @@ void ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF) {
                                     Levels::LOW);
   gpioCookiePdec->addGpio(gpioIds::PDEC_RESET, gpio);
   gpioChecker(gpioComIF->addGpios(gpioCookiePdec), "PDEC");
+  struct UioNames uioNames {};
+  uioNames.configMemory = q7s::UIO_PDEC_CONFIG_MEMORY;
+  uioNames.ramMemory = q7s::UIO_PDEC_RAM;
+  uioNames.registers = q7s::UIO_PDEC_REGISTERS;
+  uioNames.irq = q7s::UIO_PDEC_IRQ;
   new PdecHandler(objects::PDEC_HANDLER, objects::CCSDS_HANDLER, gpioComIF, gpioIds::PDEC_RESET,
-                  q7s::UIO_PDEC_CONFIG_MEMORY, q7s::UIO_PDEC_RAM, q7s::UIO_PDEC_REGISTERS);
+                  uioNames);
   GpioCookie* gpioRS485Chip = new GpioCookie;
   gpio = new GpiodRegularByLineName(q7s::gpioNames::RS485_EN_TX_CLOCK, "RS485 Transceiver",
                                     Direction::OUT, Levels::LOW);
@@ -790,6 +830,7 @@ void ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF) {
                                     Direction::OUT, Levels::LOW);
   gpioRS485Chip->addGpio(gpioIds::RS485_EN_RX_DATA, gpio);
   gpioChecker(gpioComIF->addGpios(gpioRS485Chip), "RS485 Transceiver");
+  return returnvalue::OK;
 }
 
 void ObjectFactory::createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF,
@@ -853,6 +894,7 @@ void ObjectFactory::createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF*
   plPcduHandler->setToGoToNormalModeImmediately(true);
   plPcduHandler->enablePeriodicPrintout(true, 10);
 #endif
+  plPcduHandler->connectModeTreeParent(satsystem::pl::SUBSYSTEM);
 }
 
 void ObjectFactory::createTestComponents(LinuxLibgpioIF* gpioComIF) {
@@ -861,7 +903,7 @@ void ObjectFactory::createTestComponents(LinuxLibgpioIF* gpioComIF) {
   new SpiTestClass(objects::SPI_TEST, gpioComIF);
 #endif
 #if OBSW_ADD_I2C_TEST_CODE == 1
-  new I2cTestClass(objects::I2C_TEST, q7s::I2C_DEFAULT_DEV);
+  new I2cTestClass(objects::I2C_TEST, q7s::I2C_PL_EIVE);
 #endif
 #if OBSW_ADD_UART_TEST_CODE == 1
   // auto* reader= new ScexUartReader(objects::SCEX_UART_READER);
@@ -870,23 +912,24 @@ void ObjectFactory::createTestComponents(LinuxLibgpioIF* gpioComIF) {
 }
 
 void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) {
-  UartCookie* starTrackerCookie =
-      new UartCookie(objects::STAR_TRACKER, q7s::UART_STAR_TRACKER_DEV, uart::STAR_TRACKER_BAUD,
-                     startracker::MAX_FRAME_SIZE * 2 + 2, UartModes::NON_CANONICAL);
+  auto* starTrackerCookie =
+      new SerialCookie(objects::STAR_TRACKER, q7s::UART_STAR_TRACKER_DEV, uart::STAR_TRACKER_BAUD,
+                       startracker::MAX_FRAME_SIZE * 2 + 2, UartModes::NON_CANONICAL);
   starTrackerCookie->setNoFixedSizeReply();
   StrHelper* strHelper = new StrHelper(objects::STR_HELPER);
   auto starTracker =
       new StarTrackerHandler(objects::STAR_TRACKER, objects::UART_COM_IF, starTrackerCookie,
                              strHelper, pcdu::PDU1_CH2_STAR_TRACKER_5V);
   starTracker->setPowerSwitcher(pwrSwitcher);
+  starTracker->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
 }
 
 void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher) {
-  I2cCookie* imtqI2cCookie =
-      new I2cCookie(addresses::IMTQ, IMTQ::MAX_REPLY_SIZE, q7s::I2C_DEFAULT_DEV);
+  I2cCookie* imtqI2cCookie = new I2cCookie(addresses::IMTQ, IMTQ::MAX_REPLY_SIZE, q7s::I2C_PL_EIVE);
   auto imtqHandler = new ImtqHandler(objects::IMTQ_HANDLER, objects::I2C_COM_IF, imtqI2cCookie,
                                      pcdu::Switches::PDU1_CH3_MGT_5V);
   imtqHandler->setPowerSwitcher(pwrSwitcher);
+  imtqHandler->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
   static_cast<void>(imtqHandler);
 #if OBSW_TEST_IMTQ == 1
   imtqHandler->setStartUpImmediately();
@@ -898,7 +941,7 @@ void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher) {
 }
 
 void ObjectFactory::createBpxBatteryComponent() {
-  I2cCookie* bpxI2cCookie = new I2cCookie(addresses::BPX_BATTERY, 100, q7s::I2C_DEFAULT_DEV);
+  I2cCookie* bpxI2cCookie = new I2cCookie(addresses::BPX_BATTERY, 100, q7s::I2C_PL_EIVE);
   BpxBatteryHandler* bpxHandler =
       new BpxBatteryHandler(objects::BPX_BATT_HANDLER, objects::I2C_COM_IF, bpxI2cCookie);
   bpxHandler->setStartUpImmediately();

bsp_q7s/core/ObjectFactory.h

@@ -2,11 +2,14 @@
 #define BSP_Q7S_OBJECTFACTORY_H_
 
 #include <fsfw/returnvalues/returnvalue.h>
+#include <mission/tmtc/CcsdsIpCoreHandler.h>
+#include <mission/tmtc/CfdpTmFunnel.h>
+#include <mission/tmtc/PusTmFunnel.h>
 
 #include <string>
 
 class LinuxLibgpioIF;
-class UartComIF;
+class SerialComIF;
 class SpiComIF;
 class I2cComIF;
 class PowerSwitchIF;
@@ -19,7 +22,7 @@ namespace ObjectFactory {
 void setStatics();
 void produce(void* args);
 
-void createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF, UartComIF** uartComIF,
+void createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF, SerialComIF** uartComIF,
                                    SpiComIF** spiMainComIF, I2cComIF** i2cComIF,
                                    SpiComIF** spiRwComIF);
 void createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF** pwrSwitcher);
@@ -27,7 +30,7 @@ void createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF,
                             PowerSwitchIF* pwrSwitcher);
 void createTmpComponents();
 ReturnValue_t createRadSensorComponent(LinuxLibgpioIF* gpioComIF);
-void createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComIF* uartComIF,
+void createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, SerialComIF* uartComIF,
                               PowerSwitchIF* pwrSwitcher);
 void createHeaterComponents(GpioIF* gpioIF, PowerSwitchIF* pwrSwitcher, HealthTableIF* healthTable);
 void createImtqComponents(PowerSwitchIF* pwrSwitcher);
@@ -35,9 +38,9 @@ void createBpxBatteryComponent();
 void createStrComponents(PowerSwitchIF* pwrSwitcher);
 void createSolarArrayDeploymentComponents(PowerSwitchIF& pwrSwitcher, GpioIF& gpioIF);
 void createSyrlinksComponents(PowerSwitchIF* pwrSwitcher);
-void createPayloadComponents(LinuxLibgpioIF* gpioComIF);
+void createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF& pwrSwitcher);
 void createReactionWheelComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF* pwrSwitcher);
-void createCcsdsComponents(LinuxLibgpioIF* gpioComIF);
+ReturnValue_t createCcsdsComponents(LinuxLibgpioIF* gpioComIF, CcsdsIpCoreHandler** ipCoreHandler);
 void createMiscComponents();
 
 void createTestComponents(LinuxLibgpioIF* gpioComIF);

bsp_q7s/em/emObjectFactory.cpp

@@ -17,10 +17,12 @@
 void ObjectFactory::produce(void* args) {
   ObjectFactory::setStatics();
   HealthTableIF* healthTable = nullptr;
-  ObjectFactory::produceGenericObjects(&healthTable);
+  PusTmFunnel* pusFunnel = nullptr;
+  CfdpTmFunnel* cfdpFunnel = nullptr;
+  ObjectFactory::produceGenericObjects(&healthTable, &pusFunnel, &cfdpFunnel);
 
   LinuxLibgpioIF* gpioComIF = nullptr;
-  UartComIF* uartComIF = nullptr;
+  SerialComIF* uartComIF = nullptr;
   SpiComIF* spiMainComIF = nullptr;
   I2cComIF* i2cComIF = nullptr;
   SpiComIF* spiRwComIF = nullptr;
@@ -33,6 +35,9 @@ void ObjectFactory::produce(void* args) {
   // level components.
   dummy::DummyCfg dummyCfg;
   dummyCfg.addCoreCtrlCfg = false;
+#if OBSW_ADD_SYRLINKS == 1
+  dummyCfg.addSyrlinksDummies = false;
+#endif
   dummy::createDummies(dummyCfg);
 
   new CoreController(objects::CORE_CONTROLLER);
@@ -63,6 +68,10 @@ void ObjectFactory::produce(void* args) {
   createImtqComponents(pwrSwitcher);
 #endif
 
+#if OBSW_ADD_SYRLINKS == 1
+  createSyrlinksComponents(pwrSwitcher);
+#endif /* OBSW_ADD_SYRLINKS == 1 */
+
 #if OBSW_ADD_RW == 1
   createReactionWheelComponents(gpioComIF, pwrSwitcher);
 #endif
@@ -75,7 +84,11 @@ void ObjectFactory::produce(void* args) {
   createStrComponents(pwrSwitcher);
 #endif /* OBSW_ADD_STAR_TRACKER == 1 */
 #if OBSW_ADD_CCSDS_IP_CORES == 1
-  createCcsdsComponents(gpioComIF);
+  CcsdsIpCoreHandler* ipCoreHandler = nullptr;
+  createCcsdsComponents(gpioComIF, &ipCoreHandler);
+#if OBSW_TM_TO_PTME == 1
+  ObjectFactory::addTmtcIpCoresToFunnels(*ipCoreHandler, *pusFunnel, *cfdpFunnel);
+#endif
 #endif /* OBSW_ADD_CCSDS_IP_CORES == 1 */
   /* Test Task */
 #if OBSW_ADD_TEST_CODE == 1
@@ -85,5 +98,5 @@ void ObjectFactory::produce(void* args) {
   createScexComponents(q7s::UART_SCEX_DEV, pwrSwitcher, *SdCardManager::instance(), true,
                        std::nullopt);
 #endif
-  createAcsController();
+  createAcsController(true);
 }

bsp_q7s/fmObjectFactory.cpp

@@ -11,14 +11,17 @@
 #include "linux/ObjectFactory.h"
 #include "linux/callbacks/gpioCallbacks.h"
 #include "mission/core/GenericFactory.h"
+#include "mission/system/tree/system.h"
 
 void ObjectFactory::produce(void* args) {
   ObjectFactory::setStatics();
   HealthTableIF* healthTable = nullptr;
-  ObjectFactory::produceGenericObjects(&healthTable);
+  PusTmFunnel* pusFunnel = nullptr;
+  CfdpTmFunnel* cfdpFunnel = nullptr;
+  ObjectFactory::produceGenericObjects(&healthTable, &pusFunnel, &cfdpFunnel);
 
   LinuxLibgpioIF* gpioComIF = nullptr;
-  UartComIF* uartComIF = nullptr;
+  SerialComIF* uartComIF = nullptr;
   SpiComIF* spiMainComIF = nullptr;
   I2cComIF* i2cComIF = nullptr;
   PowerSwitchIF* pwrSwitcher = nullptr;
@@ -46,7 +49,7 @@ void ObjectFactory::produce(void* args) {
   createSyrlinksComponents(pwrSwitcher);
 #endif /* OBSW_ADD_SYRLINKS == 1 */
   createRtdComponents(q7s::SPI_DEFAULT_DEV, gpioComIF, pwrSwitcher, spiMainComIF);
-  createPayloadComponents(gpioComIF);
+  createPayloadComponents(gpioComIF, *pwrSwitcher);
 
 #if OBSW_ADD_MGT == 1
   createImtqComponents(pwrSwitcher);
@@ -61,7 +64,11 @@ void ObjectFactory::produce(void* args) {
   createStrComponents(pwrSwitcher);
 #endif /* OBSW_ADD_STAR_TRACKER == 1 */
 #if OBSW_ADD_CCSDS_IP_CORES == 1
-  createCcsdsComponents(gpioComIF);
+  CcsdsIpCoreHandler* ipCoreHandler = nullptr;
+  createCcsdsComponents(gpioComIF, &ipCoreHandler);
+#if OBSW_TM_TO_PTME == 1
+  addTmtcIpCoresToFunnels(*ipCoreHandler, *pusFunnel, *cfdpFunnel);
+#endif
 #endif /* OBSW_ADD_CCSDS_IP_CORES == 1 */
 
 #if OBSW_ADD_SCEX_DEVICE == 1
@@ -75,5 +82,6 @@ void ObjectFactory::produce(void* args) {
 
   createMiscComponents();
   createThermalController();
-  createAcsController();
+  createAcsController(true);
+  satsystem::init();
 }

bsp_te0720_1cfa/ObjectFactory.cpp

@@ -12,8 +12,8 @@
 #include "fsfw/tmtcservices/PusServiceBase.h"
 #include "fsfw_hal/linux/i2c/I2cComIF.h"
 #include "fsfw_hal/linux/i2c/I2cCookie.h"
-#include "fsfw_hal/linux/uart/UartComIF.h"
-#include "fsfw_hal/linux/uart/UartCookie.h"
+#include "fsfw_hal/linux/serial/SerialComIF.h"
+#include "fsfw_hal/linux/serial/SerialCookie.h"
 #include "fsfw_hal/common/gpio/GpioCookie.h"
 #include "linux/ObjectFactory.h"
 #include "linux/devices/ploc/PlocMPSoCHandler.h"
@@ -59,7 +59,7 @@ void ObjectFactory::produce(void* args) {
   ObjectFactory::produceGenericObjects();
 
   LinuxLibgpioIF* gpioComIF = new LinuxLibgpioIF(objects::GPIO_IF);;
-  new UartComIF(objects::UART_COM_IF);
+  newSerialComIF(objects::UART_COM_IF);
 
 #if OBSW_ADD_PLOC_MPSOC == 1
   UartCookie* mpsocUartCookie = new UartCookie(objects::PLOC_MPSOC_HANDLER, te0720_1cfa::MPSOC_UART,

common/config/devConf.h

@@ -4,8 +4,8 @@
 #include <cstdint>
 
 #include "fsfw/timemanager/clockDefinitions.h"
+#include "fsfw_hal/linux/serial/SerialCookie.h"
 #include "fsfw_hal/linux/spi/spiDefinitions.h"
-#include "fsfw_hal/linux/uart/UartCookie.h"
 
 /**
  * SPI configuration will be contained here to let the device handlers remain independent

common/config/eive/objects.h

@@ -39,8 +39,12 @@ enum commonObjects : uint32_t {
   GPS_CONTROLLER = 0x44130045,
 
   IMTQ_HANDLER = 0x44140014,
-  TMP1075_HANDLER_1 = 0x44420004,
-  TMP1075_HANDLER_2 = 0x44420005,
+  TMP1075_HANDLER_TCS_0 = 0x44420004,
+  TMP1075_HANDLER_TCS_1 = 0x44420005,
+  TMP1075_HANDLER_PLPCDU_0 = 0x44420006,
+  TMP1075_HANDLER_PLPCDU_1 = 0x44420007,
+  TMP1075_HANDLER_IF_BOARD = 0x44420008,
+  TMP1075_HANDLER_OBC_IF_BOARD = 0x44420009,
   PCDU_HANDLER = 0x442000A1,
   P60DOCK_HANDLER = 0x44250000,
   PDU1_HANDLER = 0x44250001,
@@ -127,11 +131,15 @@ enum commonObjects : uint32_t {
   SUS_BOARD_ASS = 0x73000002,
   TCS_BOARD_ASS = 0x73000003,
   RW_ASS = 0x73000004,
-  CFDP_HANDLER = 0x73000005,
-  CFDP_DISTRIBUTOR = 0x73000006,
+  CAM_SWITCHER = 0x73000006,
+  ACS_SUBSYSTEM = 0x73010001,
+  PL_SUBSYSTEM = 0x73010002,
+  EIVE_SYSTEM = 0x73010000,
   TM_FUNNEL = 0x73000100,
   PUS_TM_FUNNEL = 0x73000101,
   CFDP_TM_FUNNEL = 0x73000102,
+  CFDP_HANDLER = 0x73000205,
+  CFDP_DISTRIBUTOR = 0x73000206,
 };
 }
 

dummies/CoreControllerDummy.cpp

@@ -6,8 +6,7 @@
 #include <cmath>
 #include <cstdlib>
 
-CoreControllerDummy::CoreControllerDummy(object_id_t objectId)
-    : ExtendedControllerBase(objectId, objects::NO_OBJECT) {}
+CoreControllerDummy::CoreControllerDummy(object_id_t objectId) : ExtendedControllerBase(objectId) {}
 
 ReturnValue_t CoreControllerDummy::initialize() {
   static bool done = false;

dummies/SusDummy.cpp

@@ -5,8 +5,7 @@
 #include <cmath>
 #include <cstdlib>
 
-SusDummy::SusDummy()
-    : ExtendedControllerBase(objects::SUS_0_N_LOC_XFYFZM_PT_XF, objects::NO_OBJECT), susSet(this) {
+SusDummy::SusDummy() : ExtendedControllerBase(objects::SUS_0_N_LOC_XFYFZM_PT_XF), 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);

dummies/TemperatureSensorsDummy.cpp

@@ -6,7 +6,7 @@
 #include <cstdlib>
 
 TemperatureSensorsDummy::TemperatureSensorsDummy()
-    : ExtendedControllerBase(objects::RTD_0_IC3_PLOC_HEATSPREADER, objects::NO_OBJECT),
+    : ExtendedControllerBase(objects::RTD_0_IC3_PLOC_HEATSPREADER),
       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);
@@ -23,8 +23,8 @@ TemperatureSensorsDummy::TemperatureSensorsDummy()
   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);
+  ObjectManager::instance()->insert(objects::TMP1075_HANDLER_TCS_0, this);
+  ObjectManager::instance()->insert(objects::TMP1075_HANDLER_TCS_1, this);
 }
 
 ReturnValue_t TemperatureSensorsDummy::initialize() {

dummies/helpers.cpp

@@ -38,7 +38,9 @@ void dummy::createDummies(DummyCfg cfg) {
   new RwDummy(objects::RW4, objects::DUMMY_COM_IF, comCookieDummy);
   new SaDeplDummy(objects::SOLAR_ARRAY_DEPL_HANDLER);
   new StarTrackerDummy(objects::STAR_TRACKER, objects::DUMMY_COM_IF, comCookieDummy);
-  new SyrlinksDummy(objects::SYRLINKS_HK_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  if (cfg.addSyrlinksDummies) {
+    new SyrlinksDummy(objects::SYRLINKS_HK_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  }
   new ImtqDummy(objects::IMTQ_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
   if (cfg.addPowerDummies) {
     new AcuDummy(objects::ACU_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);

dummies/helpers.h

@@ -5,6 +5,7 @@ namespace dummy {
 struct DummyCfg {
   bool addCoreCtrlCfg = true;
   bool addPowerDummies = true;
+  bool addSyrlinksDummies = true;
   bool addAcsBoardDummies = true;
   bool addSusDummies = true;
   bool addTempSensorDummies = true;

fsfw

@@ -1 +1 @@
-Subproject commit 1b7e94d718ba8f526dd53324d33d0e577cbfc81b
+Subproject commit 160ff799ace61e24708dcf1fdeaf5fafdf23a4ca

generators/bsp_q7s_events.csv

@@ -132,12 +132,13 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 12300;0x300c;SEND_MRAM_DUMP_FAILED;LOW;Failed to send mram dump command to supervisor handler P1: Return value of commandAction function P2: Start address of MRAM to dump with this command;linux/devices/ploc/PlocMemoryDumper.h
 12301;0x300d;MRAM_DUMP_FAILED;LOW;Received completion failure report form PLOC supervisor handler P1: MRAM start address of failing dump command;linux/devices/ploc/PlocMemoryDumper.h
 12302;0x300e;MRAM_DUMP_FINISHED;LOW;MRAM dump finished successfully;linux/devices/ploc/PlocMemoryDumper.h
-12401;0x3071;INVALID_TC_FRAME;HIGH;;linux/obc/PdecHandler.h
-12402;0x3072;INVALID_FAR;HIGH;Read invalid FAR from PDEC after startup;linux/obc/PdecHandler.h
-12403;0x3073;CARRIER_LOCK;INFO;Carrier lock detected;linux/obc/PdecHandler.h
-12404;0x3074;BIT_LOCK_PDEC;INFO;Bit lock detected (data valid);linux/obc/PdecHandler.h
-12405;0x3075;LOST_CARRIER_LOCK_PDEC;INFO;Lost carrier lock;linux/obc/PdecHandler.h
-12406;0x3076;LOST_BIT_LOCK_PDEC;INFO;Lost bit lock;linux/obc/PdecHandler.h
+12401;0x3071;INVALID_TC_FRAME;HIGH;;linux/ipcore/PdecHandler.h
+12402;0x3072;INVALID_FAR;HIGH;Read invalid FAR from PDEC after startup;linux/ipcore/PdecHandler.h
+12403;0x3073;CARRIER_LOCK;INFO;Carrier lock detected;linux/ipcore/PdecHandler.h
+12404;0x3074;BIT_LOCK_PDEC;INFO;Bit lock detected (data valid);linux/ipcore/PdecHandler.h
+12405;0x3075;LOST_CARRIER_LOCK_PDEC;INFO;Lost carrier lock;linux/ipcore/PdecHandler.h
+12406;0x3076;LOST_BIT_LOCK_PDEC;INFO;Lost bit lock;linux/ipcore/PdecHandler.h
+12407;0x3077;POLL_ERROR_PDEC;MEDIUM;;linux/ipcore/PdecHandler.h
 12500;0x30d4;IMAGE_UPLOAD_FAILED;LOW;Image upload failed;linux/devices/startracker/StrHelper.h
 12501;0x30d5;IMAGE_DOWNLOAD_FAILED;LOW;Image download failed;linux/devices/startracker/StrHelper.h
 12502;0x30d6;IMAGE_UPLOAD_SUCCESSFUL;LOW;Uploading image to star tracker was successfulop;linux/devices/startracker/StrHelper.h
@@ -181,15 +182,15 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 12709;0x31a5;I_MPA_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h
 12710;0x31a6;U_HPA_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h
 12711;0x31a7;I_HPA_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h
-12800;0x3200;TRANSITION_OTHER_SIDE_FAILED;HIGH;;mission/system/AcsBoardAssembly.h
-12801;0x3201;NOT_ENOUGH_DEVICES_DUAL_MODE;HIGH;;mission/system/AcsBoardAssembly.h
-12802;0x3202;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;;mission/system/AcsBoardAssembly.h
-12803;0x3203;SIDE_SWITCH_TRANSITION_NOT_ALLOWED;LOW;Not implemented, would increase already high complexity. Operator should instead command the assembly off first and then command the assembly on into the desired mode/submode combination;mission/system/AcsBoardAssembly.h
-12900;0x3264;TRANSITION_OTHER_SIDE_FAILED;HIGH;;mission/system/SusAssembly.h
-12901;0x3265;NOT_ENOUGH_DEVICES_DUAL_MODE;HIGH;;mission/system/SusAssembly.h
-12902;0x3266;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;;mission/system/SusAssembly.h
-12903;0x3267;SIDE_SWITCH_TRANSITION_NOT_ALLOWED;LOW;Not implemented, would increase already high complexity. Operator should instead command the assembly off first and then command the assembly on into the desired mode/submode combination;mission/system/SusAssembly.h
-13000;0x32c8;CHILDREN_LOST_MODE;MEDIUM;;mission/system/TcsBoardAssembly.h
+12800;0x3200;TRANSITION_OTHER_SIDE_FAILED;HIGH;;mission/system/objects/AcsBoardAssembly.h
+12801;0x3201;NOT_ENOUGH_DEVICES_DUAL_MODE;HIGH;;mission/system/objects/AcsBoardAssembly.h
+12802;0x3202;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;;mission/system/objects/AcsBoardAssembly.h
+12803;0x3203;SIDE_SWITCH_TRANSITION_NOT_ALLOWED;LOW;Not implemented, would increase already high complexity. Operator should instead command the assembly off first and then command the assembly on into the desired mode/submode combination;mission/system/objects/AcsBoardAssembly.h
+12900;0x3264;TRANSITION_OTHER_SIDE_FAILED;HIGH;;mission/system/objects/SusAssembly.h
+12901;0x3265;NOT_ENOUGH_DEVICES_DUAL_MODE;HIGH;;mission/system/objects/SusAssembly.h
+12902;0x3266;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;;mission/system/objects/SusAssembly.h
+12903;0x3267;SIDE_SWITCH_TRANSITION_NOT_ALLOWED;LOW;Not implemented, would increase already high complexity. Operator should instead command the assembly off first and then command the assembly on into the desired mode/submode combination;mission/system/objects/SusAssembly.h
+13000;0x32c8;CHILDREN_LOST_MODE;MEDIUM;;mission/system/objects/TcsBoardAssembly.h
 13100;0x332c;GPS_FIX_CHANGE;INFO;Fix has changed. P1: Old fix. P2: New fix 0: Not seen, 1: No Fix, 2: 2D-Fix, 3: 3D-Fix;mission/devices/devicedefinitions/GPSDefinitions.h
 13200;0x3390;P60_BOOT_COUNT;INFO;P60 boot count is broadcasted once at SW startup. P1: Boot count;mission/devices/P60DockHandler.h
 13201;0x3391;BATT_MODE;INFO;Battery mode is broadcasted at startup. P1: Mode;mission/devices/P60DockHandler.h

generators/bsp_q7s_objects.csv

@@ -50,8 +50,12 @@
 0x44330032;SCEX
 0x444100A2;SOLAR_ARRAY_DEPL_HANDLER
 0x444100A4;HEATER_HANDLER
-0x44420004;TMP1075_HANDLER_1
-0x44420005;TMP1075_HANDLER_2
+0x44420004;TMP1075_HANDLER_TCS_0
+0x44420005;TMP1075_HANDLER_TCS_1
+0x44420006;TMP1075_HANDLER_PLPCDU_0
+0x44420007;TMP1075_HANDLER_PLPCDU_1
+0x44420008;TMP1075_HANDLER_IF_BOARD
+0x44420009;TMP1075_HANDLER_OBC_IF_BOARD
 0x44420016;RTD_0_IC3_PLOC_HEATSPREADER
 0x44420017;RTD_1_IC4_PLOC_MISSIONBOARD
 0x44420018;RTD_2_IC5_4K_CAMERA
@@ -131,10 +135,14 @@
 0x73000002;SUS_BOARD_ASS
 0x73000003;TCS_BOARD_ASS
 0x73000004;RW_ASS
-0x73000005;CFDP_HANDLER
-0x73000006;CFDP_DISTRIBUTOR
+0x73000006;CAM_SWITCHER
 0x73000100;TM_FUNNEL
 0x73000101;PUS_TM_FUNNEL
 0x73000102;CFDP_TM_FUNNEL
+0x73000205;CFDP_HANDLER
+0x73000206;CFDP_DISTRIBUTOR
+0x73010000;EIVE_SYSTEM
+0x73010001;ACS_SUBSYSTEM
+0x73010002;PL_SUBSYSTEM
 0x73500000;CCSDS_IP_CORE_BRIDGE
 0xFFFFFFFF;NO_OBJECT

generators/bsp_q7s_returnvalues.csv

@@ -1,13 +1,22 @@
 Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x0000;OK;System-wide code for ok.;0;HasReturnvaluesIF;fsfw/returnvalues/returnvalue.h
 0x0001;Failed;Unspecified system-wide code for failed.;1;HasReturnvaluesIF;fsfw/returnvalues/returnvalue.h
-0x60a0;CCSDS_CommandNotImplemented;Received action message with unknown action id;160;CCSDS_HANDLER;mission/tmtc/CCSDSHandler.h
-0x5d00;GOMS_PacketTooLong;;0;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
-0x5d01;GOMS_InvalidTableId;;1;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
-0x5d02;GOMS_InvalidAddress;;2;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
-0x5d03;GOMS_InvalidParamSize;;3;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
-0x5d04;GOMS_InvalidPayloadSize;;4;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
-0x5d05;GOMS_UnknownReplyId;;5;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
+0x63a0;NVMB_KeyNotExists;Specified key does not exist in json file;160;NVM_PARAM_BASE;mission/memory/NVMParameterBase.h
+0x58a0;SUSS_ErrorUnlockMutex;;160;SUS_HANDLER;mission/devices/SusHandler.h
+0x58a1;SUSS_ErrorLockMutex;;161;SUS_HANDLER;mission/devices/SusHandler.h
+0x66a0;SADPL_CommandNotSupported;;160;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
+0x66a1;SADPL_DeploymentAlreadyExecuting;;161;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
+0x66a2;SADPL_MainSwitchTimeoutFailure;;162;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
+0x66a3;SADPL_SwitchingDeplSa1Failed;;163;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
+0x66a4;SADPL_SwitchingDeplSa2Failed;;164;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
+0x51a0;IMTQ_InvalidCommandCode;;160;IMTQ_HANDLER;mission/devices/ImtqHandler.h
+0x51a1;IMTQ_ParameterMissing;;161;IMTQ_HANDLER;mission/devices/ImtqHandler.h
+0x51a2;IMTQ_ParameterInvalid;;162;IMTQ_HANDLER;mission/devices/ImtqHandler.h
+0x51a3;IMTQ_CcUnavailable;;163;IMTQ_HANDLER;mission/devices/ImtqHandler.h
+0x51a4;IMTQ_InternalProcessingError;;164;IMTQ_HANDLER;mission/devices/ImtqHandler.h
+0x51a5;IMTQ_RejectedWithoutReason;;165;IMTQ_HANDLER;mission/devices/ImtqHandler.h
+0x51a6;IMTQ_CmdErrUnknown;;166;IMTQ_HANDLER;mission/devices/ImtqHandler.h
+0x51a7;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.;167;IMTQ_HANDLER;mission/devices/ImtqHandler.h
 0x52b0;RWHA_SpiWriteFailure;;176;RW_HANDLER;mission/devices/RwHandler.h
 0x52b1;RWHA_SpiReadFailure;Used by the spi send function to tell a failing read call;177;RW_HANDLER;mission/devices/RwHandler.h
 0x52b2;RWHA_MissingStartSign;Can be used by the HDLC decoding mechanism to inform about a missing start sign 0x7E;178;RW_HANDLER;mission/devices/RwHandler.h
@@ -20,21 +29,12 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x52a2;RWHA_SetSpeedCommandInvalidLength;Received set speed command has invalid length. Should be 6.;162;RW_HANDLER;mission/devices/RwHandler.h
 0x52a3;RWHA_ExecutionFailed;Command execution failed;163;RW_HANDLER;mission/devices/RwHandler.h
 0x52a4;RWHA_CrcError;Reaction wheel reply has invalid crc;164;RW_HANDLER;mission/devices/RwHandler.h
-0x4fa1;HEATER_CommandNotSupported;;161;HEATER_HANDLER;mission/devices/HeaterHandler.h
-0x4fa2;HEATER_InitFailed;;162;HEATER_HANDLER;mission/devices/HeaterHandler.h
-0x4fa3;HEATER_InvalidSwitchNr;;163;HEATER_HANDLER;mission/devices/HeaterHandler.h
-0x4fa4;HEATER_MainSwitchSetTimeout;;164;HEATER_HANDLER;mission/devices/HeaterHandler.h
-0x4fa5;HEATER_CommandAlreadyWaiting;;165;HEATER_HANDLER;mission/devices/HeaterHandler.h
-0x58a0;SUSS_ErrorUnlockMutex;;160;SUS_HANDLER;mission/devices/SusHandler.h
-0x58a1;SUSS_ErrorLockMutex;;161;SUS_HANDLER;mission/devices/SusHandler.h
-0x51a0;IMTQ_InvalidCommandCode;;160;IMTQ_HANDLER;mission/devices/ImtqHandler.h
-0x51a1;IMTQ_ParameterMissing;;161;IMTQ_HANDLER;mission/devices/ImtqHandler.h
-0x51a2;IMTQ_ParameterInvalid;;162;IMTQ_HANDLER;mission/devices/ImtqHandler.h
-0x51a3;IMTQ_CcUnavailable;;163;IMTQ_HANDLER;mission/devices/ImtqHandler.h
-0x51a4;IMTQ_InternalProcessingError;;164;IMTQ_HANDLER;mission/devices/ImtqHandler.h
-0x51a5;IMTQ_RejectedWithoutReason;;165;IMTQ_HANDLER;mission/devices/ImtqHandler.h
-0x51a6;IMTQ_CmdErrUnknown;;166;IMTQ_HANDLER;mission/devices/ImtqHandler.h
-0x51a7;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.;167;IMTQ_HANDLER;mission/devices/ImtqHandler.h
+0x5d00;GOMS_PacketTooLong;;0;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
+0x5d01;GOMS_InvalidTableId;;1;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
+0x5d02;GOMS_InvalidAddress;;2;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
+0x5d03;GOMS_InvalidParamSize;;3;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
+0x5d04;GOMS_InvalidPayloadSize;;4;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
+0x5d05;GOMS_UnknownReplyId;;5;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
 0x50a0;SYRLINKS_CrcFailure;;160;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
 0x50a1;SYRLINKS_UartFraminOrParityErrorAck;;161;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
 0x50a2;SYRLINKS_BadCharacterAck;;162;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
@@ -44,130 +44,111 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x50a6;SYRLINKS_BadCrcAck;;166;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
 0x50a7;SYRLINKS_ReplyWrongSize;;167;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
 0x50a8;SYRLINKS_MissingStartFrameCharacter;;168;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x66a0;SADPL_CommandNotSupported;;160;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x66a1;SADPL_DeploymentAlreadyExecuting;;161;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x66a2;SADPL_MainSwitchTimeoutFailure;;162;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x66a3;SADPL_SwitchingDeplSa1Failed;;163;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x66a4;SADPL_SwitchingDeplSa2Failed;;164;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x63a0;NVMB_KeyNotExists;Specified key does not exist in json file;160;NVM_PARAM_BASE;mission/memory/NVMParameterBase.h
-0x2c01;CCS_BcIsSetVrCommand;;1;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2c02;CCS_BcIsUnlockCommand;;2;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cb0;CCS_BcIllegalCommand;;176;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cb1;CCS_BoardReadingNotFinished;;177;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cf0;CCS_NsPositiveW;;240;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cf1;CCS_NsNegativeW;;241;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cf2;CCS_NsLockout;;242;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cf3;CCS_FarmInLockout;;243;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cf4;CCS_FarmInWait;;244;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2ce0;CCS_WrongSymbol;;224;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2ce1;CCS_DoubleStart;;225;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2ce2;CCS_StartSymbolMissed;;226;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2ce3;CCS_EndWithoutStart;;227;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2ce4;CCS_TooLarge;;228;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2ce5;CCS_TooShort;;229;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2ce6;CCS_WrongTfVersion;;230;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2ce7;CCS_WrongSpacecraftId;;231;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2ce8;CCS_NoValidFrameType;;232;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2ce9;CCS_CrcFailed;;233;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cea;CCS_VcNotFound;;234;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2ceb;CCS_ForwardingFailed;;235;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cec;CCS_ContentTooLarge;;236;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2ced;CCS_ResidualData;;237;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cee;CCS_DataCorrupted;;238;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cef;CCS_IllegalSegmentationFlag;;239;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cd0;CCS_IllegalFlagCombination;;208;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cd1;CCS_ShorterThanHeader;;209;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cd2;CCS_TooShortBlockedPacket;;210;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cd3;CCS_TooShortMapExtraction;;211;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x3b00;SPH_ConnBroken;;0;SEMAPHORE_IF;fsfw/src/fsfw/osal/common/TcpTmTcServer.h
-0x2a01;IEC_NoConfigurationTable;;1;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a02;IEC_NoCpuTable;;2;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a03;IEC_InvalidWorkspaceAddress;;3;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a04;IEC_TooLittleWorkspace;;4;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a05;IEC_WorkspaceAllocation;;5;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a06;IEC_InterruptStackTooSmall;;6;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a07;IEC_ThreadExitted;;7;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a08;IEC_InconsistentMpInformation;;8;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a09;IEC_InvalidNode;;9;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a0a;IEC_NoMpci;;10;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a0b;IEC_BadPacket;;11;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a0c;IEC_OutOfPackets;;12;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a0d;IEC_OutOfGlobalObjects;;13;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a0e;IEC_OutOfProxies;;14;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a0f;IEC_InvalidGlobalId;;15;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a10;IEC_BadStackHook;;16;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a11;IEC_BadAttributes;;17;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a12;IEC_ImplementationKeyCreateInconsistency;;18;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a13;IEC_ImplementationBlockingOperationCancel;;19;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a14;IEC_MutexObtainFromBadState;;20;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a15;IEC_UnlimitedAndMaximumIs0;;21;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x4fa1;HEATER_CommandNotSupported;;161;HEATER_HANDLER;mission/devices/HeaterHandler.h
+0x4fa2;HEATER_InitFailed;;162;HEATER_HANDLER;mission/devices/HeaterHandler.h
+0x4fa3;HEATER_InvalidSwitchNr;;163;HEATER_HANDLER;mission/devices/HeaterHandler.h
+0x4fa4;HEATER_MainSwitchSetTimeout;;164;HEATER_HANDLER;mission/devices/HeaterHandler.h
+0x4fa5;HEATER_CommandAlreadyWaiting;;165;HEATER_HANDLER;mission/devices/HeaterHandler.h
+0x60a0;CCSDS_CommandNotImplemented;Received action message with unknown action id;160;CCSDS_HANDLER;mission/tmtc/CcsdsIpCoreHandler.h
+0x4500;HSPI_OpeningFileFailed;;0;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
+0x4501;HSPI_FullDuplexTransferFailed;;1;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
+0x4502;HSPI_HalfDuplexTransferFailed;;2;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
+0x4801;HGIO_UnknownGpioId;;1;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4802;HGIO_DriveGpioFailure;;2;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4803;HGIO_GpioTypeFailure;;3;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4804;HGIO_GpioInvalidInstance;;4;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4805;HGIO_GpioDuplicateDetected;;5;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4806;HGIO_GpioInitFailed;;6;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4807;HGIO_GpioGetValueFailed;;7;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4601;HURT_UartReadFailure;;1;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
+0x4602;HURT_UartReadSizeMissmatch;;2;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
+0x4603;HURT_UartRxBufferTooSmall;;3;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
+0x4400;UXOS_ExecutionFinished;Execution of the current command has finished;0;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4401;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;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4402;UXOS_BytesRead;Some bytes have been read from the executing process;2;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4403;UXOS_CommandError;Command execution failed;3;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4404;UXOS_NoCommandLoadedOrPending;;4;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4406;UXOS_PcloseCallError;;6;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x2801;SM_DataTooLarge;;1;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
+0x2802;SM_DataStorageFull;;2;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
+0x2803;SM_IllegalStorageId;;3;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
+0x2804;SM_DataDoesNotExist;;4;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
+0x2805;SM_IllegalAddress;;5;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
+0x2806;SM_PoolTooLarge;;6;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
+0x0601;PP_DoItMyself;;1;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x0602;PP_PointsToVariable;;2;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x0603;PP_PointsToMemory;;3;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x0604;PP_ActivityCompleted;;4;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x0605;PP_PointsToVectorUint8;;5;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x0606;PP_PointsToVectorUint16;;6;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x0607;PP_PointsToVectorUint32;;7;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x0608;PP_PointsToVectorFloat;;8;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x06a0;PP_DumpNotSupported;;160;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x06e0;PP_InvalidSize;;224;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x06e1;PP_InvalidAddress;;225;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x06e2;PP_InvalidContent;;226;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x06e3;PP_UnalignedAccess;;227;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x06e4;PP_WriteProtected;;228;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x13e0;MH_UnknownCmd;;224;MEMORY_HELPER;fsfw/src/fsfw/memory/MemoryHelper.h
+0x13e1;MH_InvalidAddress;;225;MEMORY_HELPER;fsfw/src/fsfw/memory/MemoryHelper.h
+0x13e2;MH_InvalidSize;;226;MEMORY_HELPER;fsfw/src/fsfw/memory/MemoryHelper.h
+0x13e3;MH_StateMismatch;;227;MEMORY_HELPER;fsfw/src/fsfw/memory/MemoryHelper.h
+0x38a1;SGP4_InvalidEccentricity;;161;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x38a2;SGP4_InvalidMeanMotion;;162;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x38a3;SGP4_InvalidPerturbationElements;;163;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x38a4;SGP4_InvalidSemiLatusRectum;;164;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x38a5;SGP4_InvalidEpochElements;;165;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x38a6;SGP4_SatelliteHasDecayed;;166;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x38b1;SGP4_TleTooOld;;177;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x38b2;SGP4_TleNotInitialized;;178;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x1801;FF_Full;;1;FIFO_CLASS;fsfw/src/fsfw/container/FIFOBase.h
+0x1802;FF_Empty;;2;FIFO_CLASS;fsfw/src/fsfw/container/FIFOBase.h
+0x1601;FMM_MapFull;;1;FIXED_MULTIMAP;fsfw/src/fsfw/container/FixedOrderedMultimap.h
+0x1602;FMM_KeyDoesNotExist;;2;FIXED_MULTIMAP;fsfw/src/fsfw/container/FixedOrderedMultimap.h
+0x3901;MUX_NotEnoughResources;;1;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3902;MUX_InsufficientMemory;;2;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3903;MUX_NoPrivilege;;3;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3904;MUX_WrongAttributeSetting;;4;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3905;MUX_MutexAlreadyLocked;;5;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3906;MUX_MutexNotFound;;6;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3907;MUX_MutexMaxLocks;;7;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3908;MUX_CurrThreadAlreadyOwnsMutex;;8;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3909;MUX_CurrThreadDoesNotOwnMutex;;9;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x390a;MUX_MutexTimeout;;10;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x390b;MUX_MutexInvalidId;;11;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x390c;MUX_MutexDestroyedWhileWaiting;;12;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a01;MQI_Empty;;1;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3a02;MQI_Full;No space left for more messages;2;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3a03;MQI_NoReplyPartner;Returned if a reply method was called without partner;3;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3a04;MQI_DestinationInvalid;Returned if the target destination is invalid.;4;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x0f01;CM_UnknownCommand;;1;COMMAND_MESSAGE;fsfw/src/fsfw/ipc/CommandMessageIF.h
 0x0e01;HM_InvalidMode;;1;HAS_MODES_IF;fsfw/src/fsfw/modes/HasModesIF.h
 0x0e02;HM_TransNotAllowed;;2;HAS_MODES_IF;fsfw/src/fsfw/modes/HasModesIF.h
 0x0e03;HM_InTransition;;3;HAS_MODES_IF;fsfw/src/fsfw/modes/HasModesIF.h
 0x0e04;HM_InvalidSubmode;;4;HAS_MODES_IF;fsfw/src/fsfw/modes/HasModesIF.h
-0x2e01;HPA_InvalidIdentifierId;;1;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
-0x2e02;HPA_InvalidDomainId;;2;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
-0x2e03;HPA_InvalidValue;;3;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
-0x2e05;HPA_ReadOnly;;5;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
-0x2d01;PAW_UnknownDatatype;;1;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2d02;PAW_DatatypeMissmatch;;2;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2d03;PAW_Readonly;;3;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2d04;PAW_TooBig;;4;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2d05;PAW_SourceNotSet;;5;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2d06;PAW_OutOfBounds;;6;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2d07;PAW_NotSet;;7;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2d08;PAW_ColumnOrRowsZero;;8;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x3201;CF_ObjectHasNoFunctions;;1;COMMANDS_ACTIONS_IF;fsfw/src/fsfw/action/CommandsActionsIF.h
-0x3202;CF_AlreadyCommanding;;2;COMMANDS_ACTIONS_IF;fsfw/src/fsfw/action/CommandsActionsIF.h
-0x3301;HF_IsBusy;;1;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
-0x3302;HF_InvalidParameters;;2;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
-0x3303;HF_ExecutionFinished;;3;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
-0x3304;HF_InvalidActionId;;4;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
-0x0201;OM_InsertionFailed;;1;OBJECT_MANAGER_IF;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h
-0x0202;OM_NotFound;;2;OBJECT_MANAGER_IF;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h
-0x0203;OM_ChildInitFailed;;3;OBJECT_MANAGER_IF;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h
-0x0204;OM_InternalErrReporterUninit;;4;OBJECT_MANAGER_IF;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h
-0x2600;FDI_YourFault;;0;HANDLES_FAILURES_IF;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h
-0x2601;FDI_MyFault;;1;HANDLES_FAILURES_IF;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h
-0x2602;FDI_ConfirmLater;;2;HANDLES_FAILURES_IF;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h
-0x2201;TMF_Busy;;1;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2202;TMF_LastPacketFound;;2;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2203;TMF_StopFetch;;3;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2204;TMF_Timeout;;4;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2205;TMF_TmChannelFull;;5;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2206;TMF_NotStored;;6;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2207;TMF_AllDeleted;;7;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2208;TMF_InvalidData;;8;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2209;TMF_NotReady;;9;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2101;TMB_Busy;;1;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2102;TMB_Full;;2;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2103;TMB_Empty;;3;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2104;TMB_NullRequested;;4;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2105;TMB_TooLarge;;5;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2106;TMB_NotReady;;6;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2107;TMB_DumpError;;7;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2108;TMB_CrcError;;8;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2109;TMB_Timeout;;9;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x210a;TMB_IdlePacketFound;;10;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x210b;TMB_TelecommandFound;;11;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x210c;TMB_NoPusATm;;12;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x210d;TMB_TooSmall;;13;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x210e;TMB_BlockNotFound;;14;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x210f;TMB_InvalidRequest;;15;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x1c01;TCD_PacketLost;;1;PACKET_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/TcDistributorBase.h
-0x1c02;TCD_DestinationNotFound;;2;PACKET_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/TcDistributorBase.h
-0x1c03;TCD_ServiceIdAlreadyExists;;3;PACKET_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/TcDistributorBase.h
-0x1b00;TCC_NoDestinationFound;;0;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
-0x1b01;TCC_InvalidCcsdsVersion;;1;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
-0x1b02;TCC_InvalidApid;;2;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
-0x1b03;TCC_InvalidPacketType;;3;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
-0x1b04;TCC_InvalidSecHeaderField;;4;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
-0x1b05;TCC_IncorrectPrimaryHeader;;5;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
-0x1b07;TCC_IncompletePacket;;7;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
-0x1b08;TCC_InvalidPusVersion;;8;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
-0x1b09;TCC_IncorrectChecksum;;9;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
-0x1b0a;TCC_IllegalPacketSubtype;;10;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
-0x1b0b;TCC_IncorrectSecondaryHeader;;11;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x0c02;MS_InvalidEntry;;2;MODE_STORE_IF;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h
+0x0c03;MS_TooManyElements;;3;MODE_STORE_IF;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h
+0x0c04;MS_CantStoreEmpty;;4;MODE_STORE_IF;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h
+0x0b01;SB_ChildNotFound;;1;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
+0x0b02;SB_ChildInfoUpdated;;2;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
+0x0b03;SB_ChildDoesntHaveModes;;3;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
+0x0b04;SB_CouldNotInsertChild;;4;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
+0x0b05;SB_TableContainsInvalidObjectId;;5;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
+0x0d01;SS_SequenceAlreadyExists;;1;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0d02;SS_TableAlreadyExists;;2;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0d03;SS_TableDoesNotExist;;3;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0d04;SS_TableOrSequenceLengthInvalid;;4;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0d05;SS_SequenceDoesNotExist;;5;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0d06;SS_TableContainsInvalidObjectId;;6;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0d07;SS_FallbackSequenceDoesNotExist;;7;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0d08;SS_NoTargetTable;;8;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0d09;SS_SequenceOrTableTooLong;;9;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0d0b;SS_IsFallbackSequence;;11;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0d0c;SS_AccessDenied;;12;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0d0e;SS_TableInUse;;14;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0da1;SS_TargetTableNotReached;;161;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0da2;SS_TableCheckFailed;;162;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x2501;EV_ListenerNotFound;;1;EVENT_MANAGER_IF;fsfw/src/fsfw/events/EventManagerIF.h
 0x04e1;RMP_CommandNoDescriptorsAvailable;;225;RMAP_CHANNEL;fsfw/src/fsfw/rmap/RMAP.h
 0x04e2;RMP_CommandBufferFull;;226;RMAP_CHANNEL;fsfw/src/fsfw/rmap/RMAP.h
 0x04e3;RMP_CommandChannelOutOfRange;;227;RMAP_CHANNEL;fsfw/src/fsfw/rmap/RMAP.h
@@ -208,95 +189,9 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x040a;RMP_ReplyCommandNotImplementedOrNotAuthorised;;10;RMAP_CHANNEL;fsfw/src/fsfw/rmap/RMAP.h
 0x040b;RMP_ReplyRmwDataLengthError;;11;RMAP_CHANNEL;fsfw/src/fsfw/rmap/RMAP.h
 0x040c;RMP_ReplyInvalidTargetLogicalAddress;;12;RMAP_CHANNEL;fsfw/src/fsfw/rmap/RMAP.h
-0x2801;SM_DataTooLarge;;1;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
-0x2802;SM_DataStorageFull;;2;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
-0x2803;SM_IllegalStorageId;;3;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
-0x2804;SM_DataDoesNotExist;;4;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
-0x2805;SM_IllegalAddress;;5;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
-0x2806;SM_PoolTooLarge;;6;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
-0x38a1;SGP4_InvalidEccentricity;;161;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38a2;SGP4_InvalidMeanMotion;;162;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38a3;SGP4_InvalidPerturbationElements;;163;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38a4;SGP4_InvalidSemiLatusRectum;;164;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38a5;SGP4_InvalidEpochElements;;165;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38a6;SGP4_SatelliteHasDecayed;;166;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38b1;SGP4_TleTooOld;;177;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38b2;SGP4_TleNotInitialized;;178;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x2401;MT_NoPacketFound;;1;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/DleParser.h
-0x2402;MT_PossiblePacketLoss;;2;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/DleParser.h
-0x2403;MT_NoMatch;;3;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
-0x2404;MT_Full;;4;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
-0x2405;MT_NewNodeCreated;;5;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
-0x3f01;DLEE_StreamTooShort;;1;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
-0x3f02;DLEE_DecodingError;;2;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
-0x2f01;ASC_TooLongForTargetType;;1;ASCII_CONVERTER;fsfw/src/fsfw/globalfunctions/AsciiConverter.h
-0x2f02;ASC_InvalidCharacters;;2;ASCII_CONVERTER;fsfw/src/fsfw/globalfunctions/AsciiConverter.h
-0x2f03;ASC_BufferTooSmall;;3;ASCII_CONVERTER;fsfw/src/fsfw/globalfunctions/AsciiConverter.h
-0x0f01;CM_UnknownCommand;;1;COMMAND_MESSAGE;fsfw/src/fsfw/ipc/CommandMessageIF.h
-0x3a01;MQI_Empty;;1;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3a02;MQI_Full;No space left for more messages;2;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3a03;MQI_NoReplyPartner;Returned if a reply method was called without partner;3;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3a04;MQI_DestinationInvalid;Returned if the target destination is invalid.;4;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3901;MUX_NotEnoughResources;;1;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3902;MUX_InsufficientMemory;;2;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3903;MUX_NoPrivilege;;3;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3904;MUX_WrongAttributeSetting;;4;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3905;MUX_MutexAlreadyLocked;;5;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3906;MUX_MutexNotFound;;6;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3907;MUX_MutexMaxLocks;;7;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3908;MUX_CurrThreadAlreadyOwnsMutex;;8;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3909;MUX_CurrThreadDoesNotOwnMutex;;9;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x390a;MUX_MutexTimeout;;10;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x390b;MUX_MutexInvalidId;;11;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x390c;MUX_MutexDestroyedWhileWaiting;;12;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3b01;SPH_SemaphoreTimeout;;1;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
-0x3b02;SPH_SemaphoreNotOwned;;2;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
-0x3b03;SPH_SemaphoreInvalid;;3;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
-0x1e00;PUS_InvalidPusVersion;;0;PUS_IF;fsfw/src/fsfw/tmtcpacket/pus/PusIF.h
-0x1e01;PUS_InvalidCrc16;;1;PUS_IF;fsfw/src/fsfw/tmtcpacket/pus/PusIF.h
-0x3601;CFDP_InvalidTlvType;;1;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3602;CFDP_InvalidDirectiveField;;2;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3603;CFDP_InvalidPduDatafieldLen;;3;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3604;CFDP_InvalidAckDirectiveFields;;4;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3605;CFDP_MetadataCantParseOptions;;5;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3606;CFDP_NakCantParseOptions;;6;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3607;CFDP_FinishedCantParseFsResponses;;7;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3608;CFDP_FilestoreRequiresSecondFile;;8;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3609;CFDP_FilestoreResponseCantParseFsMessage;;9;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x360a;CFDP_InvalidPduFormat;;10;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x2901;TC_InvalidTargetState;;1;THERMAL_COMPONENT_IF;fsfw/src/fsfw/thermal/ThermalComponentIF.h
-0x29f1;TC_AboveOperationalLimit;;241;THERMAL_COMPONENT_IF;fsfw/src/fsfw/thermal/ThermalComponentIF.h
-0x29f2;TC_BelowOperationalLimit;;242;THERMAL_COMPONENT_IF;fsfw/src/fsfw/thermal/ThermalComponentIF.h
-0x0c02;MS_InvalidEntry;;2;MODE_STORE_IF;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h
-0x0c03;MS_TooManyElements;;3;MODE_STORE_IF;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h
-0x0c04;MS_CantStoreEmpty;;4;MODE_STORE_IF;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h
-0x0d01;SS_SequenceAlreadyExists;;1;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
-0x0d02;SS_TableAlreadyExists;;2;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
-0x0d03;SS_TableDoesNotExist;;3;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
-0x0d04;SS_TableOrSequenceLengthInvalid;;4;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
-0x0d05;SS_SequenceDoesNotExist;;5;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
-0x0d06;SS_TableContainsInvalidObjectId;;6;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
-0x0d07;SS_FallbackSequenceDoesNotExist;;7;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
-0x0d08;SS_NoTargetTable;;8;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
-0x0d09;SS_SequenceOrTableTooLong;;9;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
-0x0d0b;SS_IsFallbackSequence;;11;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
-0x0d0c;SS_AccessDenied;;12;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
-0x0d0e;SS_TableInUse;;14;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
-0x0da1;SS_TargetTableNotReached;;161;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
-0x0da2;SS_TableCheckFailed;;162;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
-0x0b01;SB_ChildNotFound;;1;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
-0x0b02;SB_ChildInfoUpdated;;2;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
-0x0b03;SB_ChildDoesntHaveModes;;3;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
-0x0b04;SB_CouldNotInsertChild;;4;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
-0x0b05;SB_TableContainsInvalidObjectId;;5;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
-0x3e00;HKM_QueueOrDestinationInvalid;;0;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3e01;HKM_WrongHkPacketType;;1;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3e02;HKM_ReportingStatusUnchanged;;2;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3e03;HKM_PeriodicHelperInvalid;;3;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3e04;HKM_PoolobjectNotFound;;4;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3e05;HKM_DatasetNotFound;;5;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3c00;LPIF_PoolEntryNotFound;;0;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
-0x3c01;LPIF_PoolEntryTypeConflict;;1;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
+0x1401;SE_BufferTooShort;;1;SERIALIZE_IF;fsfw/src/fsfw/serialize/SerializeIF.h
+0x1402;SE_StreamTooShort;;2;SERIALIZE_IF;fsfw/src/fsfw/serialize/SerializeIF.h
+0x1403;SE_TooManyElements;;3;SERIALIZE_IF;fsfw/src/fsfw/serialize/SerializeIF.h
 0x3da0;PVA_InvalidReadWriteMode;;160;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
 0x3da1;PVA_InvalidPoolEntry;;161;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
 0x0801;DPS_InvalidParameterDefinition;;1;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
@@ -305,39 +200,20 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x0804;DPS_DataSetUninitialised;;4;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
 0x0805;DPS_DataSetFull;;5;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
 0x0806;DPS_PoolVarNull;;6;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
-0x1000;TIM_UnsupportedTimeFormat;;0;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
-0x1001;TIM_NotEnoughInformationForTargetFormat;;1;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
-0x1002;TIM_LengthMismatch;;2;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
-0x1003;TIM_InvalidTimeFormat;;3;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
-0x1004;TIM_InvalidDayOfYear;;4;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
-0x1005;TIM_TimeDoesNotFitFormat;;5;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
-0x3701;TSI_BadTimestamp;;1;TIME_STAMPER_IF;fsfw/src/fsfw/timemanager/TimeStampIF.h
-0x1d01;ATC_ActivityStarted;;1;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
-0x1d02;ATC_InvalidSubservice;;2;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
-0x1d03;ATC_IllegalApplicationData;;3;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
-0x1d04;ATC_SendTmFailed;;4;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
-0x1d05;ATC_Timeout;;5;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
-0x4c00;SPPA_NoPacketFound;;0;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
-0x4c01;SPPA_SplitPacket;;1;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
-0x2001;CSB_ExecutionComplete;;1;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x2002;CSB_NoStepMessage;;2;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x2003;CSB_ObjectBusy;;3;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x2004;CSB_Busy;;4;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x2005;CSB_InvalidTc;;5;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x2006;CSB_InvalidObject;;6;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x2007;CSB_InvalidReply;;7;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x1101;AL_Full;;1;ARRAY_LIST;fsfw/src/fsfw/container/ArrayList.h
-0x1801;FF_Full;;1;FIFO_CLASS;fsfw/src/fsfw/container/FIFOBase.h
-0x1802;FF_Empty;;2;FIFO_CLASS;fsfw/src/fsfw/container/FIFOBase.h
-0x1601;FMM_MapFull;;1;FIXED_MULTIMAP;fsfw/src/fsfw/container/FixedOrderedMultimap.h
-0x1602;FMM_KeyDoesNotExist;;2;FIXED_MULTIMAP;fsfw/src/fsfw/container/FixedOrderedMultimap.h
-0x1501;FM_KeyAlreadyExists;;1;FIXED_MAP;fsfw/src/fsfw/container/FixedMap.h
-0x1502;FM_MapFull;;2;FIXED_MAP;fsfw/src/fsfw/container/FixedMap.h
-0x1503;FM_KeyDoesNotExist;;3;FIXED_MAP;fsfw/src/fsfw/container/FixedMap.h
-0x2501;EV_ListenerNotFound;;1;EVENT_MANAGER_IF;fsfw/src/fsfw/events/EventManagerIF.h
-0x1701;HHI_ObjectNotHealthy;;1;HAS_HEALTH_IF;fsfw/src/fsfw/health/HasHealthIF.h
-0x1702;HHI_InvalidHealthState;;2;HAS_HEALTH_IF;fsfw/src/fsfw/health/HasHealthIF.h
-0x1703;HHI_IsExternallyControlled;;3;HAS_HEALTH_IF;fsfw/src/fsfw/health/HasHealthIF.h
+0x1c01;TCD_PacketLost;;1;PACKET_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/TcDistributorBase.h
+0x1c02;TCD_DestinationNotFound;;2;PACKET_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/TcDistributorBase.h
+0x1c03;TCD_ServiceIdAlreadyExists;;3;PACKET_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/TcDistributorBase.h
+0x1b00;TCC_NoDestinationFound;;0;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b01;TCC_InvalidCcsdsVersion;;1;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b02;TCC_InvalidApid;;2;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b03;TCC_InvalidPacketType;;3;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b04;TCC_InvalidSecHeaderField;;4;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b05;TCC_IncorrectPrimaryHeader;;5;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b07;TCC_IncompletePacket;;7;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b08;TCC_InvalidPusVersion;;8;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b09;TCC_IncorrectChecksum;;9;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b0a;TCC_IllegalPacketSubtype;;10;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b0b;TCC_IncorrectSecondaryHeader;;11;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
 0x3001;POS_InPowerTransition;;1;POWER_SWITCHER;fsfw/src/fsfw/power/PowerSwitcher.h
 0x3002;POS_SwitchStateMismatch;;2;POWER_SWITCHER;fsfw/src/fsfw/power/PowerSwitcher.h
 0x0501;PS_SwitchOn;;1;POWER_SWITCH_IF;fsfw/src/fsfw/power/PowerSwitchIF.h
@@ -345,23 +221,76 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x0502;PS_SwitchTimeout;;2;POWER_SWITCH_IF;fsfw/src/fsfw/power/PowerSwitchIF.h
 0x0503;PS_FuseOn;;3;POWER_SWITCH_IF;fsfw/src/fsfw/power/PowerSwitchIF.h
 0x0504;PS_FuseOff;;4;POWER_SWITCH_IF;fsfw/src/fsfw/power/PowerSwitchIF.h
-0x4300;FILS_GenericFileError;;0;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4301;FILS_GenericDirError;;1;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4302;FILS_FilesystemInactive;;2;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4303;FILS_GenericRenameError;;3;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4304;FILS_IsBusy;;4;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4305;FILS_InvalidParameters;;5;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x430a;FILS_FileDoesNotExist;;10;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x430b;FILS_FileAlreadyExists;;11;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x430c;FILS_NotAFile;;12;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x430d;FILS_FileLocked;;13;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x430e;FILS_PermissionDenied;;14;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4315;FILS_DirectoryDoesNotExist;;21;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4316;FILS_DirectoryAlreadyExists;;22;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4317;FILS_NotADirectory;;23;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4318;FILS_DirectoryNotEmpty;;24;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x431e;FILS_SequencePacketMissingWrite;;30;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x431f;FILS_SequencePacketMissingRead;;31;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x3b00;SPH_ConnBroken;;0;SEMAPHORE_IF;fsfw/src/fsfw/osal/common/TcpTmTcServer.h
+0x2a01;IEC_NoConfigurationTable;;1;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a02;IEC_NoCpuTable;;2;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a03;IEC_InvalidWorkspaceAddress;;3;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a04;IEC_TooLittleWorkspace;;4;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a05;IEC_WorkspaceAllocation;;5;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a06;IEC_InterruptStackTooSmall;;6;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a07;IEC_ThreadExitted;;7;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a08;IEC_InconsistentMpInformation;;8;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a09;IEC_InvalidNode;;9;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a0a;IEC_NoMpci;;10;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a0b;IEC_BadPacket;;11;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a0c;IEC_OutOfPackets;;12;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a0d;IEC_OutOfGlobalObjects;;13;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a0e;IEC_OutOfProxies;;14;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a0f;IEC_InvalidGlobalId;;15;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a10;IEC_BadStackHook;;16;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a11;IEC_BadAttributes;;17;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a12;IEC_ImplementationKeyCreateInconsistency;;18;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a13;IEC_ImplementationBlockingOperationCancel;;19;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a14;IEC_MutexObtainFromBadState;;20;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a15;IEC_UnlimitedAndMaximumIs0;;21;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2600;FDI_YourFault;;0;HANDLES_FAILURES_IF;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h
+0x2601;FDI_MyFault;;1;HANDLES_FAILURES_IF;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h
+0x2602;FDI_ConfirmLater;;2;HANDLES_FAILURES_IF;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h
+0x1e00;PUS_InvalidPusVersion;;0;PUS_IF;fsfw/src/fsfw/tmtcpacket/pus/PusIF.h
+0x1e01;PUS_InvalidCrc16;;1;PUS_IF;fsfw/src/fsfw/tmtcpacket/pus/PusIF.h
+0x0201;OM_InsertionFailed;;1;OBJECT_MANAGER_IF;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h
+0x0202;OM_NotFound;;2;OBJECT_MANAGER_IF;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h
+0x0203;OM_ChildInitFailed;;3;OBJECT_MANAGER_IF;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h
+0x0204;OM_InternalErrReporterUninit;;4;OBJECT_MANAGER_IF;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h
+0x2201;TMF_Busy;;1;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2202;TMF_LastPacketFound;;2;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2203;TMF_StopFetch;;3;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2204;TMF_Timeout;;4;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2205;TMF_TmChannelFull;;5;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2206;TMF_NotStored;;6;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2207;TMF_AllDeleted;;7;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2208;TMF_InvalidData;;8;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2209;TMF_NotReady;;9;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2101;TMB_Busy;;1;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2102;TMB_Full;;2;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2103;TMB_Empty;;3;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2104;TMB_NullRequested;;4;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2105;TMB_TooLarge;;5;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2106;TMB_NotReady;;6;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2107;TMB_DumpError;;7;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2108;TMB_CrcError;;8;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2109;TMB_Timeout;;9;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x210a;TMB_IdlePacketFound;;10;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x210b;TMB_TelecommandFound;;11;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x210c;TMB_NoPusATm;;12;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x210d;TMB_TooSmall;;13;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x210e;TMB_BlockNotFound;;14;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x210f;TMB_InvalidRequest;;15;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2d01;PAW_UnknownDatatype;;1;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
+0x2d02;PAW_DatatypeMissmatch;;2;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
+0x2d03;PAW_Readonly;;3;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
+0x2d04;PAW_TooBig;;4;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
+0x2d05;PAW_SourceNotSet;;5;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
+0x2d06;PAW_OutOfBounds;;6;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
+0x2d07;PAW_NotSet;;7;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
+0x2d08;PAW_ColumnOrRowsZero;;8;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
+0x2e01;HPA_InvalidIdentifierId;;1;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
+0x2e02;HPA_InvalidDomainId;;2;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
+0x2e03;HPA_InvalidValue;;3;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
+0x2e05;HPA_ReadOnly;;5;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
+0x3b01;SPH_SemaphoreTimeout;;1;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
+0x3b02;SPH_SemaphoreNotOwned;;2;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
+0x3b03;SPH_SemaphoreInvalid;;3;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
 0x1a01;TRC_NotEnoughSensors;;1;TRIPLE_REDUNDACY_CHECK;fsfw/src/fsfw/monitoring/TriplexMonitor.h
 0x1a02;TRC_LowestValueOol;;2;TRIPLE_REDUNDACY_CHECK;fsfw/src/fsfw/monitoring/TriplexMonitor.h
 0x1a03;TRC_HighestValueOol;;3;TRIPLE_REDUNDACY_CHECK;fsfw/src/fsfw/monitoring/TriplexMonitor.h
@@ -380,34 +309,72 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x31e2;LIM_WrongPid;;226;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
 0x31e3;LIM_WrongLimitId;;227;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
 0x31ee;LIM_MonitorNotFound;;238;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x3601;CFDP_InvalidTlvType;;1;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3602;CFDP_InvalidDirectiveField;;2;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3603;CFDP_InvalidPduDatafieldLen;;3;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3604;CFDP_InvalidAckDirectiveFields;;4;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3605;CFDP_MetadataCantParseOptions;;5;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3606;CFDP_NakCantParseOptions;;6;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3607;CFDP_FinishedCantParseFsResponses;;7;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3608;CFDP_FilestoreRequiresSecondFile;;8;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3609;CFDP_FilestoreResponseCantParseFsMessage;;9;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x360a;CFDP_InvalidPduFormat;;10;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x4300;FILS_GenericFileError;;0;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4301;FILS_GenericDirError;;1;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4302;FILS_FilesystemInactive;;2;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4303;FILS_GenericRenameError;;3;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4304;FILS_IsBusy;;4;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4305;FILS_InvalidParameters;;5;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x430a;FILS_FileDoesNotExist;;10;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x430b;FILS_FileAlreadyExists;;11;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x430c;FILS_NotAFile;;12;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x430d;FILS_FileLocked;;13;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x430e;FILS_PermissionDenied;;14;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4315;FILS_DirectoryDoesNotExist;;21;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4316;FILS_DirectoryAlreadyExists;;22;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4317;FILS_NotADirectory;;23;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4318;FILS_DirectoryNotEmpty;;24;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x431e;FILS_SequencePacketMissingWrite;;30;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x431f;FILS_SequencePacketMissingRead;;31;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x2c01;CCS_BcIsSetVrCommand;;1;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
+0x2c02;CCS_BcIsUnlockCommand;;2;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
+0x2cb0;CCS_BcIllegalCommand;;176;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
+0x2cb1;CCS_BoardReadingNotFinished;;177;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
+0x2cf0;CCS_NsPositiveW;;240;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
+0x2cf1;CCS_NsNegativeW;;241;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
+0x2cf2;CCS_NsLockout;;242;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
+0x2cf3;CCS_FarmInLockout;;243;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
+0x2cf4;CCS_FarmInWait;;244;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
+0x2ce0;CCS_WrongSymbol;;224;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
+0x2ce1;CCS_DoubleStart;;225;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
+0x2ce2;CCS_StartSymbolMissed;;226;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
+0x2ce3;CCS_EndWithoutStart;;227;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
+0x2ce4;CCS_TooLarge;;228;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
+0x2ce5;CCS_TooShort;;229;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
+0x2ce6;CCS_WrongTfVersion;;230;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
+0x2ce7;CCS_WrongSpacecraftId;;231;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
+0x2ce8;CCS_NoValidFrameType;;232;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
+0x2ce9;CCS_CrcFailed;;233;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
+0x2cea;CCS_VcNotFound;;234;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
+0x2ceb;CCS_ForwardingFailed;;235;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
+0x2cec;CCS_ContentTooLarge;;236;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
+0x2ced;CCS_ResidualData;;237;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
+0x2cee;CCS_DataCorrupted;;238;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
+0x2cef;CCS_IllegalSegmentationFlag;;239;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
+0x2cd0;CCS_IllegalFlagCombination;;208;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
+0x2cd1;CCS_ShorterThanHeader;;209;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
+0x2cd2;CCS_TooShortBlockedPacket;;210;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
+0x2cd3;CCS_TooShortMapExtraction;;211;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
 0x4201;PUS11_InvalidTypeTimeWindow;;1;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
 0x4202;PUS11_InvalidTimeWindow;;2;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
 0x4203;PUS11_TimeshiftingNotPossible;;3;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
 0x4204;PUS11_InvalidRelativeTime;;4;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x0601;PP_DoItMyself;;1;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x0602;PP_PointsToVariable;;2;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x0603;PP_PointsToMemory;;3;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x0604;PP_ActivityCompleted;;4;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x0605;PP_PointsToVectorUint8;;5;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x0606;PP_PointsToVectorUint16;;6;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x0607;PP_PointsToVectorUint32;;7;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x0608;PP_PointsToVectorFloat;;8;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x06a0;PP_DumpNotSupported;;160;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x06e0;PP_InvalidSize;;224;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x06e1;PP_InvalidAddress;;225;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x06e2;PP_InvalidContent;;226;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x06e3;PP_UnalignedAccess;;227;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x06e4;PP_WriteProtected;;228;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x13e0;MH_UnknownCmd;;224;MEMORY_HELPER;fsfw/src/fsfw/memory/MemoryHelper.h
-0x13e1;MH_InvalidAddress;;225;MEMORY_HELPER;fsfw/src/fsfw/memory/MemoryHelper.h
-0x13e2;MH_InvalidSize;;226;MEMORY_HELPER;fsfw/src/fsfw/memory/MemoryHelper.h
-0x13e3;MH_StateMismatch;;227;MEMORY_HELPER;fsfw/src/fsfw/memory/MemoryHelper.h
-0x1201;AB_NeedSecondStep;;1;ASSEMBLY_BASE;fsfw/src/fsfw/devicehandlers/AssemblyBase.h
-0x1202;AB_NeedToReconfigure;;2;ASSEMBLY_BASE;fsfw/src/fsfw/devicehandlers/AssemblyBase.h
-0x1203;AB_ModeFallback;;3;ASSEMBLY_BASE;fsfw/src/fsfw/devicehandlers/AssemblyBase.h
-0x1204;AB_ChildNotCommandable;;4;ASSEMBLY_BASE;fsfw/src/fsfw/devicehandlers/AssemblyBase.h
-0x1205;AB_NeedToChangeHealth;;5;ASSEMBLY_BASE;fsfw/src/fsfw/devicehandlers/AssemblyBase.h
-0x12a1;AB_NotEnoughChildrenInCorrectState;;161;ASSEMBLY_BASE;fsfw/src/fsfw/devicehandlers/AssemblyBase.h
+0x3401;DC_NoReplyReceived;;1;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
+0x3402;DC_ProtocolError;;2;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
+0x3403;DC_Nullpointer;;3;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
+0x3404;DC_InvalidCookieType;;4;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
+0x3405;DC_NotActive;;5;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
+0x3406;DC_TooMuchData;;6;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
 0x03a0;DHB_InvalidChannel;;160;DEVICE_HANDLER_BASE;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h
 0x03b0;DHB_AperiodicReply;;176;DEVICE_HANDLER_BASE;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h
 0x03b1;DHB_IgnoreReplyData;;177;DEVICE_HANDLER_BASE;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h
@@ -417,12 +384,12 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x03d0;DHB_NoSwitch;;208;DEVICE_HANDLER_BASE;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h
 0x03e0;DHB_ChildTimeout;;224;DEVICE_HANDLER_BASE;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h
 0x03e1;DHB_SwitchFailed;;225;DEVICE_HANDLER_BASE;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h
-0x3401;DC_NoReplyReceived;;1;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x3402;DC_ProtocolError;;2;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x3403;DC_Nullpointer;;3;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x3404;DC_InvalidCookieType;;4;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x3405;DC_NotActive;;5;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x3406;DC_TooMuchData;;6;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
+0x1201;AB_NeedSecondStep;;1;ASSEMBLY_BASE;fsfw/src/fsfw/devicehandlers/AssemblyBase.h
+0x1202;AB_NeedToReconfigure;;2;ASSEMBLY_BASE;fsfw/src/fsfw/devicehandlers/AssemblyBase.h
+0x1203;AB_ModeFallback;;3;ASSEMBLY_BASE;fsfw/src/fsfw/devicehandlers/AssemblyBase.h
+0x1204;AB_ChildNotCommandable;;4;ASSEMBLY_BASE;fsfw/src/fsfw/devicehandlers/AssemblyBase.h
+0x1205;AB_NeedToChangeHealth;;5;ASSEMBLY_BASE;fsfw/src/fsfw/devicehandlers/AssemblyBase.h
+0x12a1;AB_NotEnoughChildrenInCorrectState;;161;ASSEMBLY_BASE;fsfw/src/fsfw/devicehandlers/AssemblyBase.h
 0x27a0;DHI_NoCommandData;;160;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27a1;DHI_CommandNotSupported;;161;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27a2;DHI_CommandAlreadySent;;162;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
@@ -444,28 +411,58 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x27c3;DHI_DeviceReplyInvalid;;195;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27d0;DHI_InvalidCommandParameter;;208;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27d1;DHI_InvalidNumberOrLengthOfParameters;;209;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x1401;SE_BufferTooShort;;1;SERIALIZE_IF;fsfw/src/fsfw/serialize/SerializeIF.h
-0x1402;SE_StreamTooShort;;2;SERIALIZE_IF;fsfw/src/fsfw/serialize/SerializeIF.h
-0x1403;SE_TooManyElements;;3;SERIALIZE_IF;fsfw/src/fsfw/serialize/SerializeIF.h
-0x4500;HSPI_HalTimeoutRetval;;0;HAL_SPI;fsfw/src/fsfw_hal/stm32h7/spi/spiDefinitions.h
-0x4501;HSPI_HalBusyRetval;;1;HAL_SPI;fsfw/src/fsfw_hal/stm32h7/spi/spiDefinitions.h
-0x4502;HSPI_HalErrorRetval;;2;HAL_SPI;fsfw/src/fsfw_hal/stm32h7/spi/spiDefinitions.h
-0x4601;HURT_UartReadFailure;;1;HAL_UART;fsfw/src/fsfw_hal/linux/uart/UartComIF.h
-0x4602;HURT_UartReadSizeMissmatch;;2;HAL_UART;fsfw/src/fsfw_hal/linux/uart/UartComIF.h
-0x4603;HURT_UartRxBufferTooSmall;;3;HAL_UART;fsfw/src/fsfw_hal/linux/uart/UartComIF.h
-0x4801;HGIO_UnknownGpioId;;1;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4802;HGIO_DriveGpioFailure;;2;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4803;HGIO_GpioTypeFailure;;3;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4804;HGIO_GpioInvalidInstance;;4;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4805;HGIO_GpioDuplicateDetected;;5;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4806;HGIO_GpioInitFailed;;6;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4807;HGIO_GpioGetValueFailed;;7;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4400;UXOS_ExecutionFinished;Execution of the current command has finished;0;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4401;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;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4402;UXOS_BytesRead;Some bytes have been read from the executing process;2;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4403;UXOS_CommandError;Command execution failed;3;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4404;UXOS_NoCommandLoadedOrPending;;4;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4406;UXOS_PcloseCallError;;6;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x2401;MT_TooDetailedRequest;;1;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
+0x2402;MT_TooGeneralRequest;;2;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
+0x2403;MT_NoMatch;;3;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
+0x2404;MT_Full;;4;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
+0x2405;MT_NewNodeCreated;;5;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
+0x3f01;DLEE_NoPacketFound;;1;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleParser.h
+0x3f02;DLEE_PossiblePacketLoss;;2;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleParser.h
+0x2f01;ASC_TooLongForTargetType;;1;ASCII_CONVERTER;fsfw/src/fsfw/globalfunctions/AsciiConverter.h
+0x2f02;ASC_InvalidCharacters;;2;ASCII_CONVERTER;fsfw/src/fsfw/globalfunctions/AsciiConverter.h
+0x2f03;ASC_BufferTooSmall;;3;ASCII_CONVERTER;fsfw/src/fsfw/globalfunctions/AsciiConverter.h
+0x1701;HHI_ObjectNotHealthy;;1;HAS_HEALTH_IF;fsfw/src/fsfw/health/HasHealthIF.h
+0x1702;HHI_InvalidHealthState;;2;HAS_HEALTH_IF;fsfw/src/fsfw/health/HasHealthIF.h
+0x1703;HHI_IsExternallyControlled;;3;HAS_HEALTH_IF;fsfw/src/fsfw/health/HasHealthIF.h
+0x3201;CF_ObjectHasNoFunctions;;1;COMMANDS_ACTIONS_IF;fsfw/src/fsfw/action/CommandsActionsIF.h
+0x3202;CF_AlreadyCommanding;;2;COMMANDS_ACTIONS_IF;fsfw/src/fsfw/action/CommandsActionsIF.h
+0x3301;HF_IsBusy;;1;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
+0x3302;HF_InvalidParameters;;2;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
+0x3303;HF_ExecutionFinished;;3;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
+0x3304;HF_InvalidActionId;;4;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
+0x1000;TIM_UnsupportedTimeFormat;;0;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
+0x1001;TIM_NotEnoughInformationForTargetFormat;;1;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
+0x1002;TIM_LengthMismatch;;2;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
+0x1003;TIM_InvalidTimeFormat;;3;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
+0x1004;TIM_InvalidDayOfYear;;4;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
+0x1005;TIM_TimeDoesNotFitFormat;;5;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
+0x3701;TSI_BadTimestamp;;1;TIME_STAMPER_IF;fsfw/src/fsfw/timemanager/TimeStampIF.h
+0x3c00;LPIF_PoolEntryNotFound;;0;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
+0x3c01;LPIF_PoolEntryTypeConflict;;1;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
+0x3e00;HKM_QueueOrDestinationInvalid;;0;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3e01;HKM_WrongHkPacketType;;1;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3e02;HKM_ReportingStatusUnchanged;;2;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3e03;HKM_PeriodicHelperInvalid;;3;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3e04;HKM_PoolobjectNotFound;;4;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3e05;HKM_DatasetNotFound;;5;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x2901;TC_InvalidTargetState;;1;THERMAL_COMPONENT_IF;fsfw/src/fsfw/thermal/ThermalComponentIF.h
+0x29f1;TC_AboveOperationalLimit;;241;THERMAL_COMPONENT_IF;fsfw/src/fsfw/thermal/ThermalComponentIF.h
+0x29f2;TC_BelowOperationalLimit;;242;THERMAL_COMPONENT_IF;fsfw/src/fsfw/thermal/ThermalComponentIF.h
+0x2001;CSB_ExecutionComplete;;1;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
+0x2002;CSB_NoStepMessage;;2;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
+0x2003;CSB_ObjectBusy;;3;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
+0x2004;CSB_Busy;;4;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
+0x2005;CSB_InvalidTc;;5;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
+0x2006;CSB_InvalidObject;;6;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
+0x2007;CSB_InvalidReply;;7;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
+0x4c00;SPPA_NoPacketFound;;0;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
+0x4c01;SPPA_SplitPacket;;1;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
+0x1d01;ATC_ActivityStarted;;1;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
+0x1d02;ATC_InvalidSubservice;;2;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
+0x1d03;ATC_IllegalApplicationData;;3;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
+0x1d04;ATC_SendTmFailed;;4;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
+0x1d05;ATC_Timeout;;5;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
+0x6b00;SCBU_KeyNotFound;;0;SCRATCH_BUFFER;bsp_q7s/memory/scratchApi.h
 0x64a0;FSHLP_SdNotMounted;SD card specified with path string not mounted;160;FILE_SYSTEM_HELPER;bsp_q7s/fs/FilesystemHelper.h
 0x64a1;FSHLP_FileNotExists;Specified file does not exist on filesystem;161;FILE_SYSTEM_HELPER;bsp_q7s/fs/FilesystemHelper.h
 0x6a00;SDMA_OpOngoing;;0;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
@@ -478,4 +475,3 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x6a0d;SDMA_UnmountError;;13;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
 0x6a0e;SDMA_SystemCallError;;14;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
 0x6a0f;SDMA_PopenCallError;;15;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6b00;SCBU_KeyNotFound;;0;SCRATCH_BUFFER;bsp_q7s/memory/scratchApi.h

generators/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 233 translations.
+ * @brief    Auto-generated event translation file. Contains 234 translations.
  * @details
- * Generated on: 2022-10-27 09:03:07
+ * Generated on: 2022-11-14 17:10:10
  */
 #include "translateEvents.h"
 
@@ -144,6 +144,7 @@ const char *CARRIER_LOCK_STRING = "CARRIER_LOCK";
 const char *BIT_LOCK_PDEC_STRING = "BIT_LOCK_PDEC";
 const char *LOST_CARRIER_LOCK_PDEC_STRING = "LOST_CARRIER_LOCK_PDEC";
 const char *LOST_BIT_LOCK_PDEC_STRING = "LOST_BIT_LOCK_PDEC";
+const char *POLL_ERROR_PDEC_STRING = "POLL_ERROR_PDEC";
 const char *IMAGE_UPLOAD_FAILED_STRING = "IMAGE_UPLOAD_FAILED";
 const char *IMAGE_DOWNLOAD_FAILED_STRING = "IMAGE_DOWNLOAD_FAILED";
 const char *IMAGE_UPLOAD_SUCCESSFUL_STRING = "IMAGE_UPLOAD_SUCCESSFUL";
@@ -515,6 +516,8 @@ const char *translateEvents(Event event) {
       return LOST_CARRIER_LOCK_PDEC_STRING;
     case (12406):
       return LOST_BIT_LOCK_PDEC_STRING;
+    case (12407):
+      return POLL_ERROR_PDEC_STRING;
     case (12500):
       return IMAGE_UPLOAD_FAILED_STRING;
     case (12501):

generators/objects/translateObjects.cpp

@@ -1,8 +1,8 @@
 /**
  * @brief  Auto-generated object translation file.
  * @details
- * Contains 140 translations.
- * Generated on: 2022-10-27 09:03:07
+ * Contains 148 translations.
+ * Generated on: 2022-11-14 17:10:10
  */
 #include "translateObjects.h"
 
@@ -58,8 +58,12 @@ const char *PLOC_SUPERVISOR_HELPER_STRING = "PLOC_SUPERVISOR_HELPER";
 const char *SCEX_STRING = "SCEX";
 const char *SOLAR_ARRAY_DEPL_HANDLER_STRING = "SOLAR_ARRAY_DEPL_HANDLER";
 const char *HEATER_HANDLER_STRING = "HEATER_HANDLER";
-const char *TMP1075_HANDLER_1_STRING = "TMP1075_HANDLER_1";
-const char *TMP1075_HANDLER_2_STRING = "TMP1075_HANDLER_2";
+const char *TMP1075_HANDLER_TCS_0_STRING = "TMP1075_HANDLER_TCS_0";
+const char *TMP1075_HANDLER_TCS_1_STRING = "TMP1075_HANDLER_TCS_1";
+const char *TMP1075_HANDLER_PLPCDU_0_STRING = "TMP1075_HANDLER_PLPCDU_0";
+const char *TMP1075_HANDLER_PLPCDU_1_STRING = "TMP1075_HANDLER_PLPCDU_1";
+const char *TMP1075_HANDLER_IF_BOARD_STRING = "TMP1075_HANDLER_IF_BOARD";
+const char *TMP1075_HANDLER_OBC_IF_BOARD_STRING = "TMP1075_HANDLER_OBC_IF_BOARD";
 const char *RTD_0_IC3_PLOC_HEATSPREADER_STRING = "RTD_0_IC3_PLOC_HEATSPREADER";
 const char *RTD_1_IC4_PLOC_MISSIONBOARD_STRING = "RTD_1_IC4_PLOC_MISSIONBOARD";
 const char *RTD_2_IC5_4K_CAMERA_STRING = "RTD_2_IC5_4K_CAMERA";
@@ -139,11 +143,15 @@ const char *ACS_BOARD_ASS_STRING = "ACS_BOARD_ASS";
 const char *SUS_BOARD_ASS_STRING = "SUS_BOARD_ASS";
 const char *TCS_BOARD_ASS_STRING = "TCS_BOARD_ASS";
 const char *RW_ASS_STRING = "RW_ASS";
-const char *CFDP_HANDLER_STRING = "CFDP_HANDLER";
-const char *CFDP_DISTRIBUTOR_STRING = "CFDP_DISTRIBUTOR";
+const char *CAM_SWITCHER_STRING = "CAM_SWITCHER";
 const char *TM_FUNNEL_STRING = "TM_FUNNEL";
 const char *PUS_TM_FUNNEL_STRING = "PUS_TM_FUNNEL";
 const char *CFDP_TM_FUNNEL_STRING = "CFDP_TM_FUNNEL";
+const char *CFDP_HANDLER_STRING = "CFDP_HANDLER";
+const char *CFDP_DISTRIBUTOR_STRING = "CFDP_DISTRIBUTOR";
+const char *EIVE_SYSTEM_STRING = "EIVE_SYSTEM";
+const char *ACS_SUBSYSTEM_STRING = "ACS_SUBSYSTEM";
+const char *PL_SUBSYSTEM_STRING = "PL_SUBSYSTEM";
 const char *CCSDS_IP_CORE_BRIDGE_STRING = "CCSDS_IP_CORE_BRIDGE";
 const char *NO_OBJECT_STRING = "NO_OBJECT";
 
@@ -254,9 +262,17 @@ const char *translateObject(object_id_t object) {
     case 0x444100A4:
       return HEATER_HANDLER_STRING;
     case 0x44420004:
-      return TMP1075_HANDLER_1_STRING;
+      return TMP1075_HANDLER_TCS_0_STRING;
     case 0x44420005:
-      return TMP1075_HANDLER_2_STRING;
+      return TMP1075_HANDLER_TCS_1_STRING;
+    case 0x44420006:
+      return TMP1075_HANDLER_PLPCDU_0_STRING;
+    case 0x44420007:
+      return TMP1075_HANDLER_PLPCDU_1_STRING;
+    case 0x44420008:
+      return TMP1075_HANDLER_IF_BOARD_STRING;
+    case 0x44420009:
+      return TMP1075_HANDLER_OBC_IF_BOARD_STRING;
     case 0x44420016:
       return RTD_0_IC3_PLOC_HEATSPREADER_STRING;
     case 0x44420017:
@@ -415,16 +431,24 @@ const char *translateObject(object_id_t object) {
       return TCS_BOARD_ASS_STRING;
     case 0x73000004:
       return RW_ASS_STRING;
-    case 0x73000005:
-      return CFDP_HANDLER_STRING;
     case 0x73000006:
-      return CFDP_DISTRIBUTOR_STRING;
+      return CAM_SWITCHER_STRING;
     case 0x73000100:
       return TM_FUNNEL_STRING;
     case 0x73000101:
       return PUS_TM_FUNNEL_STRING;
     case 0x73000102:
       return CFDP_TM_FUNNEL_STRING;
+    case 0x73000205:
+      return CFDP_HANDLER_STRING;
+    case 0x73000206:
+      return CFDP_DISTRIBUTOR_STRING;
+    case 0x73010000:
+      return EIVE_SYSTEM_STRING;
+    case 0x73010001:
+      return ACS_SUBSYSTEM_STRING;
+    case 0x73010002:
+      return PL_SUBSYSTEM_STRING;
     case 0x73500000:
       return CCSDS_IP_CORE_BRIDGE_STRING;
     case 0xFFFFFFFF:

linux/CMakeLists.txt

@@ -3,7 +3,10 @@ add_subdirectory(utility)
 add_subdirectory(callbacks)
 add_subdirectory(boardtest)
 add_subdirectory(devices)
-add_subdirectory(fsfwconfig)
-add_subdirectory(obc)
+add_subdirectory(ipcore)
+
+if(EIVE_ADD_LINUX_FSFWCONFIG)
+  add_subdirectory(fsfwconfig)
+endif()
 
 target_sources(${OBSW_NAME} PUBLIC ObjectFactory.cpp InitMission.cpp)

linux/InitMission.cpp

@@ -6,6 +6,7 @@
 
 #include "OBSWConfig.h"
 #include "ObjectFactory.h"
+#include "eive/objects.h"
 
 void scheduling::schedulingScex(TaskFactory& factory, PeriodicTaskIF*& scexDevHandler,
                                 PeriodicTaskIF*& scexReaderTask) {
@@ -45,3 +46,21 @@ void scheduling::schedulingScex(TaskFactory& factory, PeriodicTaskIF*& scexDevHa
     printAddObjectError("SCEX_UART_READER", objects::SCEX_UART_READER);
   }
 }
+
+void scheduling::addMpsocSupvHandlers(PeriodicTaskIF* plTask) {
+#if OBSW_ADD_PLOC_SUPERVISOR == 1
+  plTask->addComponent(objects::PLOC_SUPERVISOR_HANDLER, DeviceHandlerIF::PERFORM_OPERATION);
+  plTask->addComponent(objects::PLOC_SUPERVISOR_HANDLER, DeviceHandlerIF::SEND_READ);
+  plTask->addComponent(objects::PLOC_SUPERVISOR_HANDLER, DeviceHandlerIF::GET_READ);
+  plTask->addComponent(objects::PLOC_SUPERVISOR_HANDLER, DeviceHandlerIF::SEND_WRITE);
+  plTask->addComponent(objects::PLOC_SUPERVISOR_HANDLER, DeviceHandlerIF::GET_WRITE);
+#endif
+
+#if OBSW_ADD_PLOC_MPSOC == 1
+  plTask->addComponent(objects::PLOC_MPSOC_HANDLER, DeviceHandlerIF::PERFORM_OPERATION);
+  plTask->addComponent(objects::PLOC_MPSOC_HANDLER, DeviceHandlerIF::SEND_READ);
+  plTask->addComponent(objects::PLOC_MPSOC_HANDLER, DeviceHandlerIF::GET_READ);
+  plTask->addComponent(objects::PLOC_MPSOC_HANDLER, DeviceHandlerIF::SEND_WRITE);
+  plTask->addComponent(objects::PLOC_MPSOC_HANDLER, DeviceHandlerIF::GET_WRITE);
+#endif
+}

linux/InitMission.h

@@ -4,4 +4,6 @@
 namespace scheduling {
 void schedulingScex(TaskFactory& factory, PeriodicTaskIF*& scexDevHandler,
                     PeriodicTaskIF*& scexReaderTask);
-}
+void addMpsocSupvHandlers(PeriodicTaskIF* task);
+
+}  // namespace scheduling

linux/ObjectFactory.cpp

@@ -1,12 +1,13 @@
 #include "ObjectFactory.h"
 
 #include <fsfw/power/PowerSwitchIF.h>
+#include <fsfw/subsystem/Subsystem.h>
 #include <fsfw_hal/common/gpio/GpioCookie.h>
 #include <fsfw_hal/common/gpio/GpioIF.h>
 #include <fsfw_hal/common/gpio/gpioDefinitions.h>
+#include <fsfw_hal/linux/serial/SerialCookie.h>
 #include <fsfw_hal/linux/spi/SpiComIF.h>
 #include <fsfw_hal/linux/spi/SpiCookie.h>
-#include <fsfw_hal/linux/uart/UartCookie.h>
 #include <linux/callbacks/gpioCallbacks.h>
 #include <linux/devices/Max31865RtdLowlevelHandler.h>
 #include <mission/controller/AcsController.h>
@@ -15,8 +16,6 @@
 #include <mission/devices/Max31865PT1000Handler.h>
 #include <mission/devices/ScexDeviceHandler.h>
 #include <mission/devices/SusHandler.h>
-#include <mission/system/SusAssembly.h>
-#include <mission/system/TcsBoardAssembly.h>
 #include <mission/system/fdir/RtdFdir.h>
 #include <mission/system/fdir/SusFdir.h>
 
@@ -24,6 +23,11 @@
 #include "devConf.h"
 #include "devices/addresses.h"
 #include "devices/gpioIds.h"
+#include "eive/definitions.h"
+#include "mission/system/objects/SusAssembly.h"
+#include "mission/system/objects/TcsBoardAssembly.h"
+#include "mission/system/tree/acsModeTree.h"
+#include "mission/system/tree/payloadModeTree.h"
 
 void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiComIF,
                                               PowerSwitchIF* pwrSwitcher, std::string spiDev) {
@@ -78,7 +82,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
   susHandlers[0] =
       new SusHandler(objects::SUS_0_N_LOC_XFYFZM_PT_XF, 0, objects::SPI_MAIN_COM_IF, spiCookie);
   fdir = new SusFdir(objects::SUS_0_N_LOC_XFYFZM_PT_XF);
-  susHandlers[0]->setParent(objects::SUS_BOARD_ASS);
   susHandlers[0]->setCustomFdir(fdir);
 
   spiCookie = new SpiCookie(addresses::SUS_1, gpioIds::CS_SUS_1, SUS::MAX_CMD_SIZE,
@@ -86,7 +89,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
   susHandlers[1] =
       new SusHandler(objects::SUS_1_N_LOC_XBYFZM_PT_XB, 1, objects::SPI_MAIN_COM_IF, spiCookie);
   fdir = new SusFdir(objects::SUS_1_N_LOC_XBYFZM_PT_XB);
-  susHandlers[1]->setParent(objects::SUS_BOARD_ASS);
   susHandlers[1]->setCustomFdir(fdir);
 
   spiCookie = new SpiCookie(addresses::SUS_2, gpioIds::CS_SUS_2, SUS::MAX_CMD_SIZE,
@@ -94,7 +96,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
   susHandlers[2] =
       new SusHandler(objects::SUS_2_N_LOC_XFYBZB_PT_YB, 2, objects::SPI_MAIN_COM_IF, spiCookie);
   fdir = new SusFdir(objects::SUS_2_N_LOC_XFYBZB_PT_YB);
-  susHandlers[2]->setParent(objects::SUS_BOARD_ASS);
   susHandlers[2]->setCustomFdir(fdir);
 
   spiCookie = new SpiCookie(addresses::SUS_3, gpioIds::CS_SUS_3, SUS::MAX_CMD_SIZE,
@@ -102,7 +103,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
   susHandlers[3] =
       new SusHandler(objects::SUS_3_N_LOC_XFYBZF_PT_YF, 3, objects::SPI_MAIN_COM_IF, spiCookie);
   fdir = new SusFdir(objects::SUS_3_N_LOC_XFYBZF_PT_YF);
-  susHandlers[3]->setParent(objects::SUS_BOARD_ASS);
   susHandlers[3]->setCustomFdir(fdir);
 
   spiCookie = new SpiCookie(addresses::SUS_4, gpioIds::CS_SUS_4, SUS::MAX_CMD_SIZE,
@@ -110,7 +110,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
   susHandlers[4] =
       new SusHandler(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, 4, objects::SPI_MAIN_COM_IF, spiCookie);
   fdir = new SusFdir(objects::SUS_4_N_LOC_XMYFZF_PT_ZF);
-  susHandlers[4]->setParent(objects::SUS_BOARD_ASS);
   susHandlers[4]->setCustomFdir(fdir);
 
   spiCookie = new SpiCookie(addresses::SUS_5, gpioIds::CS_SUS_5, SUS::MAX_CMD_SIZE,
@@ -118,7 +117,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
   susHandlers[5] =
       new SusHandler(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, 5, objects::SPI_MAIN_COM_IF, spiCookie);
   fdir = new SusFdir(objects::SUS_5_N_LOC_XFYMZB_PT_ZB);
-  susHandlers[5]->setParent(objects::SUS_BOARD_ASS);
   susHandlers[5]->setCustomFdir(fdir);
 
   spiCookie = new SpiCookie(addresses::SUS_6, gpioIds::CS_SUS_6, SUS::MAX_CMD_SIZE,
@@ -126,7 +124,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
   susHandlers[6] =
       new SusHandler(objects::SUS_6_R_LOC_XFYBZM_PT_XF, 6, objects::SPI_MAIN_COM_IF, spiCookie);
   fdir = new SusFdir(objects::SUS_6_R_LOC_XFYBZM_PT_XF);
-  susHandlers[6]->setParent(objects::SUS_BOARD_ASS);
   susHandlers[6]->setCustomFdir(fdir);
 
   spiCookie = new SpiCookie(addresses::SUS_7, gpioIds::CS_SUS_7, SUS::MAX_CMD_SIZE,
@@ -134,7 +131,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
   susHandlers[7] =
       new SusHandler(objects::SUS_7_R_LOC_XBYBZM_PT_XB, 7, objects::SPI_MAIN_COM_IF, spiCookie);
   fdir = new SusFdir(objects::SUS_7_R_LOC_XBYBZM_PT_XB);
-  susHandlers[7]->setParent(objects::SUS_BOARD_ASS);
   susHandlers[7]->setCustomFdir(fdir);
 
   spiCookie = new SpiCookie(addresses::SUS_8, gpioIds::CS_SUS_8, SUS::MAX_CMD_SIZE,
@@ -142,7 +138,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
   susHandlers[8] =
       new SusHandler(objects::SUS_8_R_LOC_XBYBZB_PT_YB, 8, objects::SPI_MAIN_COM_IF, spiCookie);
   fdir = new SusFdir(objects::SUS_8_R_LOC_XBYBZB_PT_YB);
-  susHandlers[8]->setParent(objects::SUS_BOARD_ASS);
   susHandlers[8]->setCustomFdir(fdir);
 
   spiCookie = new SpiCookie(addresses::SUS_9, gpioIds::CS_SUS_9, SUS::MAX_CMD_SIZE,
@@ -150,7 +145,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
   susHandlers[9] =
       new SusHandler(objects::SUS_9_R_LOC_XBYBZB_PT_YF, 9, objects::SPI_MAIN_COM_IF, spiCookie);
   fdir = new SusFdir(objects::SUS_9_R_LOC_XBYBZB_PT_YF);
-  susHandlers[9]->setParent(objects::SUS_BOARD_ASS);
   susHandlers[9]->setCustomFdir(fdir);
 
   spiCookie = new SpiCookie(addresses::SUS_10, gpioIds::CS_SUS_10, SUS::MAX_CMD_SIZE,
@@ -158,7 +152,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
   susHandlers[10] =
       new SusHandler(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, 10, objects::SPI_MAIN_COM_IF, spiCookie);
   fdir = new SusFdir(objects::SUS_10_N_LOC_XMYBZF_PT_ZF);
-  susHandlers[10]->setParent(objects::SUS_BOARD_ASS);
   susHandlers[10]->setCustomFdir(fdir);
 
   spiCookie = new SpiCookie(addresses::SUS_11, gpioIds::CS_SUS_11, SUS::MAX_CMD_SIZE,
@@ -166,11 +159,24 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
   susHandlers[11] =
       new SusHandler(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, 11, objects::SPI_MAIN_COM_IF, spiCookie);
   fdir = new SusFdir(objects::SUS_11_R_LOC_XBYMZB_PT_ZB);
-  susHandlers[11]->setParent(objects::SUS_BOARD_ASS);
   susHandlers[11]->setCustomFdir(fdir);
 
+  std::array<object_id_t, 12> susIds = {
+      objects::SUS_0_N_LOC_XFYFZM_PT_XF,  objects::SUS_1_N_LOC_XBYFZM_PT_XB,
+      objects::SUS_2_N_LOC_XFYBZB_PT_YB,  objects::SUS_3_N_LOC_XFYBZF_PT_YF,
+      objects::SUS_4_N_LOC_XMYFZF_PT_ZF,  objects::SUS_5_N_LOC_XFYMZB_PT_ZB,
+      objects::SUS_6_R_LOC_XFYBZM_PT_XF,  objects::SUS_7_R_LOC_XBYBZM_PT_XB,
+      objects::SUS_8_R_LOC_XBYBZB_PT_YB,  objects::SUS_9_R_LOC_XBYBZB_PT_YF,
+      objects::SUS_10_N_LOC_XMYBZF_PT_ZF, objects::SUS_11_R_LOC_XBYMZB_PT_ZB};
+  SusAssHelper susAssHelper = SusAssHelper(susIds);
+  auto susAss = new SusAssembly(objects::SUS_BOARD_ASS, pwrSwitcher, susAssHelper);
   for (auto& sus : susHandlers) {
     if (sus != nullptr) {
+      ReturnValue_t result = sus->connectModeTreeParent(*susAss);
+      if (result != returnvalue::OK) {
+        sif::error << "Connecting SUS " << sus->getObjectId() << " to SUS assembly failed"
+                   << std::endl;
+      }
 #if OBSW_TEST_SUS == 1
       sus->setStartUpImmediately();
       sus->setToGoToNormalMode(true);
@@ -180,17 +186,7 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
 #endif
     }
   }
-  std::array<object_id_t, 12> susIds = {
-      objects::SUS_0_N_LOC_XFYFZM_PT_XF,  objects::SUS_1_N_LOC_XBYFZM_PT_XB,
-      objects::SUS_2_N_LOC_XFYBZB_PT_YB,  objects::SUS_3_N_LOC_XFYBZF_PT_YF,
-      objects::SUS_4_N_LOC_XMYFZF_PT_ZF,  objects::SUS_5_N_LOC_XFYMZB_PT_ZB,
-      objects::SUS_6_R_LOC_XFYBZM_PT_XF,  objects::SUS_7_R_LOC_XBYBZM_PT_XB,
-      objects::SUS_8_R_LOC_XBYBZB_PT_YB,  objects::SUS_9_R_LOC_XBYBZB_PT_YF,
-      objects::SUS_10_N_LOC_XMYBZF_PT_ZF, objects::SUS_11_R_LOC_XBYMZB_PT_ZB};
-  SusAssHelper susAssHelper = SusAssHelper(susIds);
-  auto susAss =
-      new SusAssembly(objects::SUS_BOARD_ASS, objects::NO_OBJECT, pwrSwitcher, susAssHelper);
-  static_cast<void>(susAss);
+  susAss->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
 #endif /* OBSW_ADD_SUN_SENSORS == 1 */
 }
 
@@ -292,6 +288,11 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
   std::array<SpiCookie*, NUM_RTDS> rtdCookies = {};
   std::array<Max31865EiveHandler*, NUM_RTDS> rtds = {};
   RtdFdir* rtdFdir = nullptr;
+
+  TcsBoardHelper helper(rtdInfos);
+  TcsBoardAssembly* tcsBoardAss = new TcsBoardAssembly(
+      objects::TCS_BOARD_ASS, pwrSwitcher, pcdu::Switches::PDU1_CH0_TCS_BOARD_3V3, helper);
+  static_cast<void>(tcsBoardAss);
   // Create special low level reader communication interface
   new Max31865RtdReader(objects::SPI_RTD_COM_IF, comIF, gpioComIF);
   for (uint8_t idx = 0; idx < NUM_RTDS; idx++) {
@@ -303,7 +304,11 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
     rtds[idx] =
         new Max31865EiveHandler(rtdInfos[idx].first, objects::SPI_RTD_COM_IF, rtdLowLevelCookie);
     rtds[idx]->setDeviceInfo(idx, rtdInfos[idx].second);
-    rtds[idx]->setParent(objects::TCS_BOARD_ASS);
+    ReturnValue_t result = rtds[idx]->connectModeTreeParent(*tcsBoardAss);
+    if (result != returnvalue::OK) {
+      sif::error << "Connecting RTD " << static_cast<int>(idx) << " to RTD Assembly failed"
+                 << std::endl;
+    }
     rtdFdir = new RtdFdir(rtdInfos[idx].first);
     rtds[idx]->setCustomFdir(rtdFdir);
 #if OBSW_DEBUG_RTD == 1
@@ -315,18 +320,13 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
 #endif
   }
 
-  TcsBoardHelper helper(rtdInfos);
-  TcsBoardAssembly* tcsBoardAss =
-      new TcsBoardAssembly(objects::TCS_BOARD_ASS, objects::NO_OBJECT, pwrSwitcher,
-                           pcdu::Switches::PDU1_CH0_TCS_BOARD_3V3, helper);
-  static_cast<void>(tcsBoardAss);
 #endif  // OBSW_ADD_RTD_DEVICES == 1
 }
 
 void ObjectFactory::createScexComponents(std::string uartDev, PowerSwitchIF* pwrSwitcher,
                                          SdCardMountedIF& mountedIF, bool onImmediately,
                                          std::optional<power::Switch_t> switchId) {
-  auto* cookie = new UartCookie(objects::SCEX, uartDev, uart::SCEX_BAUD, 4096);
+  auto* cookie = new SerialCookie(objects::SCEX, uartDev, uart::SCEX_BAUD, 4096);
   cookie->setTwoStopBits();
   // cookie->setParityEven();
   auto scexUartReader = new ScexUartReader(objects::SCEX_UART_READER);
@@ -337,16 +337,29 @@ void ObjectFactory::createScexComponents(std::string uartDev, PowerSwitchIF* pwr
   if (switchId) {
     scexHandler->setPowerSwitcher(*pwrSwitcher, switchId.value());
   }
+  scexHandler->connectModeTreeParent(satsystem::pl::SUBSYSTEM);
 }
 
 void ObjectFactory::createThermalController() {
-  new ThermalController(objects::THERMAL_CONTROLLER, objects::NO_OBJECT);
+  new ThermalController(objects::THERMAL_CONTROLLER);
 }
 
-void ObjectFactory::createAcsController() { new AcsController(objects::ACS_CONTROLLER); }
+AcsController* ObjectFactory::createAcsController(bool connectSubsystem) {
+  auto acsCtrl = new AcsController(objects::ACS_CONTROLLER);
+  if (connectSubsystem) {
+    acsCtrl->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
+  }
+  return acsCtrl;
+}
 
 void ObjectFactory::gpioChecker(ReturnValue_t result, std::string output) {
   if (result != returnvalue::OK) {
     sif::error << "ObjectFactory: Adding GPIOs failed for " << output << std::endl;
   }
 }
+
+void ObjectFactory::addTmtcIpCoresToFunnels(CcsdsIpCoreHandler& ipCoreHandler,
+                                            PusTmFunnel& pusFunnel, CfdpTmFunnel& cfdpFunnel) {
+  cfdpFunnel.addDestination(ipCoreHandler, config::LIVE_TM);
+  pusFunnel.addDestination(ipCoreHandler, config::LIVE_TM);
+}

linux/ObjectFactory.h

@@ -4,6 +4,9 @@
 #include <fsfw/returnvalues/returnvalue.h>
 #include <fsfw_hal/linux/gpio/LinuxLibgpioIF.h>
 #include <mission/memory/SdCardMountedIF.h>
+#include <mission/tmtc/CcsdsIpCoreHandler.h>
+#include <mission/tmtc/CfdpTmFunnel.h>
+#include <mission/tmtc/PusTmFunnel.h>
 
 #include <optional>
 #include <string>
@@ -11,6 +14,7 @@
 class GpioIF;
 class SpiComIF;
 class PowerSwitchIF;
+class AcsController;
 
 namespace ObjectFactory {
 
@@ -26,6 +30,9 @@ void createScexComponents(std::string uartDev, PowerSwitchIF* pwrSwitcher,
 void gpioChecker(ReturnValue_t result, std::string output);
 
 void createThermalController();
-void createAcsController();
+AcsController* createAcsController(bool connectSubsystem);
+
+void addTmtcIpCoresToFunnels(CcsdsIpCoreHandler& ipCoreHandler, PusTmFunnel& pusFunnel,
+                             CfdpTmFunnel& cfdpFunnel);
 
 }  // namespace ObjectFactory

linux/boardtest/SpiTestClass.cpp

@@ -333,14 +333,12 @@ void SpiTestClass::performPeriodicMax1227Test() {
 }
 
 void SpiTestClass::performMax1227Test() {
+  std::string deviceName = "";
 #ifdef XIPHOS_Q7S
-  std::string deviceName = q7s::SPI_DEFAULT_DEV;
+  deviceName = q7s::SPI_DEFAULT_DEV;
 #elif defined(RASPBERRY_PI)
-  std::string deviceName = "";
 #elif defined(EGSE)
-  std::string deviceName = "";
 #elif defined(TE0720_1CFA)
-  std::string deviceName = "";
 #endif
   int fd = 0;
   UnixFileGuard fileHelper(deviceName, &fd, O_RDWR, "SpiComIF::initializeInterface");
@@ -381,8 +379,9 @@ void SpiTestClass::max1227RadSensorTest(int fd) {
                                             DiffSel::NONE_0);
     spiTransferStruct[0].len = 1;
     transfer(fd, gpioIds::CS_RAD_SENSOR);
-    max1227::prepareExternallyClockedRead0ToN(sendBuffer.data(), 7, spiTransferStruct[0].len);
-    size_t tmpLen = spiTransferStruct[0].len;
+    size_t tmpSz = spiTransferStruct[0].len;
+    max1227::prepareExternallyClockedRead0ToN(sendBuffer.data(), 7, tmpSz);
+    size_t tmpLen = tmpSz;
     spiTransferStruct[0].len = 1;
     transfer(fd, gpioIds::CS_RAD_SENSOR);
     std::memcpy(sendBuffer.data(), sendBuffer.data() + 1, tmpLen - 1);
@@ -403,7 +402,8 @@ void SpiTestClass::max1227RadSensorTest(int fd) {
     for (int idx = 0; idx < 8; idx++) {
       sif::info << "ADC raw " << idx << ": " << adcRaw[idx] << std::endl;
     }
-    max1227::prepareExternallyClockedTemperatureRead(sendBuffer.data(), spiTransferStruct[0].len);
+    tmpSz = spiTransferStruct[0].len;
+    max1227::prepareExternallyClockedTemperatureRead(sendBuffer.data(), tmpSz);
     spiTransferStruct[0].len = 1;
     transfer(fd, gpioIds::CS_RAD_SENSOR);
     usleep(65);
@@ -467,7 +467,8 @@ void SpiTestClass::max1227SusTest(int fd, SusTestCfg &cfg) {
     spiTransferStruct[0].len = 1;
     transfer(fd, cfg.gpioId);
 
-    max1227::prepareExternallyClockedRead0ToN(sendBuffer.data(), 5, spiTransferStruct[0].len);
+    size_t tmpSz = spiTransferStruct[0].len;
+    max1227::prepareExternallyClockedRead0ToN(sendBuffer.data(), 5, tmpSz);
     transfer(fd, cfg.gpioId);
     uint16_t adcRaw[6] = {};
     adcRaw[0] = (recvBuffer[1] << 8) | recvBuffer[2];
@@ -552,7 +553,9 @@ void SpiTestClass::max1227PlPcduTest(int fd) {
     spiTransferStruct[0].len = 1;
     transfer(fd, gpioIds::PLPCDU_ADC_CS);
     uint8_t n = 11;
-    max1227::prepareExternallyClockedRead0ToN(sendBuffer.data(), n, spiTransferStruct[0].len);
+    size_t tmpSz = spiTransferStruct[0].len;
+    max1227::prepareExternallyClockedRead0ToN(sendBuffer.data(), n, tmpSz);
+    spiTransferStruct[0].len = tmpSz;
     size_t dummy = 0;
     max1227::prepareExternallyClockedTemperatureRead(sendBuffer.data() + spiTransferStruct[0].len,
                                                      dummy);
@@ -585,9 +588,11 @@ void SpiTestClass::max1227PlPcduTest(int fd) {
     spiTransferStruct[0].len = 1;
     transfer(fd, gpioIds::PLPCDU_ADC_CS);
     uint8_t n = 11;
-    max1227::prepareExternallyClockedRead0ToN(sendBuffer.data(), n, spiTransferStruct[0].len);
+    size_t tmpLen = spiTransferStruct[0].len;
+    max1227::prepareExternallyClockedRead0ToN(sendBuffer.data(), n, tmpLen);
     max1227::prepareExternallyClockedTemperatureRead(sendBuffer.data() + spiTransferStruct[0].len,
-                                                     spiTransferStruct[0].len);
+                                                     tmpLen);
+    spiTransferStruct[0].len = tmpLen;
     transfer(fd, gpioIds::PLPCDU_ADC_CS);
     uint16_t adcRaw[n + 1] = {};
     for (uint8_t idx = 0; idx < n + 1; idx++) {

linux/boardtest/UartTestClass.cpp

@@ -3,7 +3,7 @@
 #include <errno.h>  // Error integer and strerror() function
 #include <fcntl.h>  // Contains file controls like O_RDWR
 #include <fsfw/tasks/TaskFactory.h>
-#include <fsfw_hal/linux/uart/UartCookie.h>
+#include <fsfw_hal/linux/serial/SerialCookie.h>
 #include <linux/devices/ScexDleParser.h>
 #include <linux/devices/ScexHelper.h>
 #include <linux/devices/ScexUartReader.h>
@@ -13,6 +13,7 @@
 #include <string>
 
 #include "OBSWConfig.h"
+#include "eive/objects.h"
 #include "fsfw/globalfunctions/CRC.h"
 #include "fsfw/globalfunctions/DleEncoder.h"
 #include "fsfw/globalfunctions/arrayprinter.h"
@@ -164,7 +165,7 @@ void UartTestClass::scexInit() {
 #else
     std::string devname = "/dev/ul-scex";
 #endif
-    uartCookie = new UartCookie(this->getObjectId(), devname, UartBaudRate::RATE_57600, 4096);
+    uartCookie = new SerialCookie(this->getObjectId(), devname, UartBaudRate::RATE_57600, 4096);
     reader->setDebugMode(false);
     ReturnValue_t result = reader->initializeInterface(uartCookie);
     if (result != OK) {

linux/boardtest/UartTestClass.h

@@ -5,7 +5,7 @@
 #include <fsfw/globalfunctions/DleEncoder.h>
 #include <fsfw/globalfunctions/DleParser.h>
 #include <fsfw/timemanager/Countdown.h>
-#include <fsfw_hal/linux/uart/UartCookie.h>
+#include <fsfw_hal/linux/serial/SerialCookie.h>
 #include <termios.h>  // Contains POSIX terminal control definitions
 
 #include <array>
@@ -57,7 +57,7 @@ class UartTestClass : public TestTask {
   scex::Cmds currCmd = scex::Cmds::PING;
   TestModes mode = TestModes::GPS;
   DleEncoder dleEncoder = DleEncoder();
-  UartCookie* uartCookie = nullptr;
+  SerialCookie* uartCookie = nullptr;
   size_t encodedLen = 0;
   lwgps_t gpsData = {};
   struct termios tty = {};

linux/devices/GPSHyperionLinuxController.cpp

@@ -18,9 +18,7 @@
 
 GPSHyperionLinuxController::GPSHyperionLinuxController(object_id_t objectId, object_id_t parentId,
                                                        bool debugHyperionGps)
-    : ExtendedControllerBase(objectId, objects::NO_OBJECT),
-      gpsSet(this),
-      debugHyperionGps(debugHyperionGps) {
+    : ExtendedControllerBase(objectId), gpsSet(this), debugHyperionGps(debugHyperionGps) {
   timeUpdateCd.resetTimer();
 }
 

linux/devices/Max31865RtdLowlevelHandler.cpp

@@ -50,7 +50,7 @@ ReturnValue_t Max31865RtdReader::performOperation(uint8_t operationCode) {
 }
 
 bool Max31865RtdReader::rtdIsActive(uint8_t idx) {
-  if (rtds[idx]->on and rtds[idx]->active and rtds[idx]->configured) {
+  if (rtds[idx]->on and rtds[idx]->db.active and rtds[idx]->db.configured) {
     return true;
   }
   return false;
@@ -69,7 +69,7 @@ bool Max31865RtdReader::periodicInitHandling() {
     if (rtd == nullptr) {
       continue;
     }
-    if ((rtd->on or rtd->active) and not rtd->configured and rtd->cd.hasTimedOut()) {
+    if ((rtd->on or rtd->db.active) and not rtd->db.configured and rtd->cd.hasTimedOut()) {
       ManualCsLockWrapper mg(csLock, gpioIF, rtd->spiCookie, csTimeoutType, csTimeoutMs);
       if (mg.lockResult != returnvalue::OK or mg.gpioResult != returnvalue::OK) {
         sif::error << "Max31865RtdReader::periodicInitHandling: Manual CS lock failed" << std::endl;
@@ -95,13 +95,7 @@ bool Max31865RtdReader::periodicInitHandling() {
       if (result != returnvalue::OK) {
         handleSpiError(rtd, result, "clearFaultStatus");
       }
-      rtd->configured = true;
       rtd->db.configured = true;
-      if (rtd->active) {
-        rtd->db.active = true;
-      }
-    }
-    if (rtd->active and rtd->configured and not rtd->db.active) {
       rtd->db.active = true;
     }
   }
@@ -241,8 +235,8 @@ ReturnValue_t Max31865RtdReader::sendMessage(CookieIF* cookie, const uint8_t* se
         rtdCookie->cd.setTimeout(MAX31865::WARMUP_MS);
         rtdCookie->cd.resetTimer();
         rtdCookie->on = true;
-        rtdCookie->active = false;
-        rtdCookie->configured = false;
+        rtdCookie->db.active = false;
+        rtdCookie->db.configured = false;
         if (sendLen == 5) {
           thresholdHandler(rtdCookie, sendData);
         }
@@ -254,10 +248,10 @@ ReturnValue_t Max31865RtdReader::sendMessage(CookieIF* cookie, const uint8_t* se
         rtdCookie->cd.setTimeout(MAX31865::WARMUP_MS);
         rtdCookie->cd.resetTimer();
         rtdCookie->on = true;
-        rtdCookie->active = true;
-        rtdCookie->configured = false;
+        rtdCookie->db.active = true;
+        rtdCookie->db.configured = false;
       } else {
-        rtdCookie->active = true;
+        rtdCookie->db.active = true;
       }
       if (sendLen == 5) {
         thresholdHandler(rtdCookie, sendData);
@@ -266,8 +260,8 @@ ReturnValue_t Max31865RtdReader::sendMessage(CookieIF* cookie, const uint8_t* se
     }
     case (EiveMax31855::RtdCommands::OFF): {
       rtdCookie->on = false;
-      rtdCookie->active = false;
-      rtdCookie->configured = false;
+      rtdCookie->db.active = false;
+      rtdCookie->db.configured = false;
       break;
     }
     case (EiveMax31855::RtdCommands::HIGH_TRESHOLD): {

linux/devices/Max31865RtdLowlevelHandler.h

@@ -23,8 +23,6 @@ struct Max31865ReaderCookie : public CookieIF {
   Countdown cd = Countdown(MAX31865::WARMUP_MS);
 
   bool on = false;
-  bool configured = false;
-  bool active = false;
   bool writeLowThreshold = false;
   bool writeHighThreshold = false;
   uint16_t lowThreshold = 0;

linux/devices/ScexUartReader.cpp

@@ -6,7 +6,7 @@
 #include <fsfw/ipc/MutexGuard.h>
 #include <fsfw/tasks/SemaphoreFactory.h>
 #include <fsfw/tasks/TaskFactory.h>
-#include <fsfw_hal/linux/uart/UartCookie.h>
+#include <fsfw_hal/linux/serial/SerialCookie.h>
 #include <unistd.h>  // write(), read(), close()
 
 #include <cerrno>  // Error integer and strerror() function
@@ -58,7 +58,7 @@ ReturnValue_t ScexUartReader::performOperation(uint8_t operationCode) {
           result = tryDleParsing();
         }
 
-        TaskFactory::delayTask(400);
+        TaskFactory::delayTask(150);
       } else if (bytesRead < 0) {
         sif::warning << "ScexUartReader::performOperation: read call failed with error [" << errno
                      << ", " << strerror(errno) << "]" << std::endl;
@@ -84,7 +84,7 @@ ReturnValue_t ScexUartReader::performOperation(uint8_t operationCode) {
 }
 
 ReturnValue_t ScexUartReader::initializeInterface(CookieIF *cookie) {
-  UartCookie *uartCookie = dynamic_cast<UartCookie *>(cookie);
+  SerialCookie *uartCookie = dynamic_cast<SerialCookie *>(cookie);
   if (uartCookie == nullptr) {
     return FAILED;
   }
@@ -213,6 +213,10 @@ ReturnValue_t ScexUartReader::tryDleParsing() {
 void ScexUartReader::reset() {
   lock->lockMutex();
   state = States::FINISH;
+  ipcRingBuf.clear();
+  while (not ipcQueue.empty()) {
+    ipcQueue.pop();
+  }
   lock->unlockMutex();
 }
 

linux/devices/ploc/PlocMPSoCHandler.cpp

@@ -31,7 +31,7 @@ ReturnValue_t PlocMPSoCHandler::initialize() {
   if (result != returnvalue::OK) {
     return result;
   }
-  uartComIf = dynamic_cast<UartComIF*>(communicationInterface);
+  uartComIf = dynamic_cast<SerialComIF*>(communicationInterface);
   if (uartComIf == nullptr) {
     sif::warning << "PlocMPSoCHandler::initialize: Invalid uart com if" << std::endl;
     return ObjectManagerIF::CHILD_INIT_FAILED;

linux/devices/ploc/PlocMPSoCHandler.h

@@ -10,7 +10,7 @@
 #include "fsfw/ipc/QueueFactory.h"
 #include "fsfw/tmtcservices/SourceSequenceCounter.h"
 #include "fsfw_hal/linux/gpio/Gpio.h"
-#include "fsfw_hal/linux/uart/UartComIF.h"
+#include "fsfw_hal/linux/serial/SerialComIF.h"
 #include "linux/devices/devicedefinitions/MPSoCReturnValuesIF.h"
 #include "linux/devices/devicedefinitions/PlocMPSoCDefinitions.h"
 #include "linux/devices/devicedefinitions/PlocSupervisorDefinitions.h"
@@ -123,7 +123,7 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
    */
   DeviceCommandId_t nextReplyId = mpsoc::NONE;
 
-  UartComIF* uartComIf = nullptr;
+  SerialComIF* uartComIf = nullptr;
 
   PlocMPSoCHelper* plocMPSoCHelper = nullptr;
   Gpio uartIsolatorSwitch;

linux/devices/ploc/PlocMPSoCHelper.cpp

@@ -57,7 +57,7 @@ ReturnValue_t PlocMPSoCHelper::performOperation(uint8_t operationCode) {
 }
 
 ReturnValue_t PlocMPSoCHelper::setComIF(DeviceCommunicationIF* communicationInterface_) {
-  uartComIF = dynamic_cast<UartComIF*>(communicationInterface_);
+  uartComIF = dynamic_cast<SerialComIF*>(communicationInterface_);
   if (uartComIF == nullptr) {
     sif::warning << "PlocMPSoCHelper::initialize: Invalid uart com if" << std::endl;
     return returnvalue::FAILED;

linux/devices/ploc/PlocMPSoCHelper.h

@@ -9,7 +9,7 @@
 #include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
 #include "fsfw/tmtcservices/SourceSequenceCounter.h"
-#include "fsfw_hal/linux/uart/UartComIF.h"
+#include "fsfw_hal/linux/serial/SerialComIF.h"
 #include "linux/devices/devicedefinitions/PlocMPSoCDefinitions.h"
 #ifdef XIPHOS_Q7S
 #include "bsp_q7s/fs/SdCardManager.h"
@@ -136,7 +136,7 @@ class PlocMPSoCHelper : public SystemObject, public ExecutableObjectIF {
    * Communication interface of MPSoC responsible for low level access. Must be set by the
    * MPSoC Handler.
    */
-  UartComIF* uartComIF = nullptr;
+  SerialComIF* uartComIF = nullptr;
   // Communication cookie. Must be set by the MPSoC Handler
   CookieIF* comCookie = nullptr;
   // Sequence count, must be set by Ploc MPSoC Handler

linux/devices/ploc/PlocSupervisorHandler.cpp

@@ -46,7 +46,7 @@ ReturnValue_t PlocSupervisorHandler::initialize() {
   if (result != returnvalue::OK) {
     return result;
   }
-  uartComIf = dynamic_cast<UartComIF*>(communicationInterface);
+  uartComIf = dynamic_cast<SerialComIF*>(communicationInterface);
   if (uartComIf == nullptr) {
     sif::warning << "PlocSupervisorHandler::initialize: Invalid uart com if" << std::endl;
     return ObjectManagerIF::CHILD_INIT_FAILED;

linux/devices/ploc/PlocSupervisorHandler.h

@@ -9,7 +9,7 @@
 #include "fsfw/timemanager/Countdown.h"
 #include "fsfw_hal/linux/gpio/Gpio.h"
 #include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
-#include "fsfw_hal/linux/uart/UartComIF.h"
+#include "fsfw_hal/linux/serial/SerialComIF.h"
 #include "linux/devices/devicedefinitions/PlocSupervisorDefinitions.h"
 #include "linux/devices/devicedefinitions/SupvReturnValuesIF.h"
 
@@ -110,7 +110,7 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
    */
   DeviceCommandId_t nextReplyId = supv::NONE;
 
-  UartComIF* uartComIf = nullptr;
+  SerialComIF* uartComIf = nullptr;
   LinuxLibgpioIF* gpioComIF = nullptr;
   Gpio uartIsolatorSwitch;
 

linux/devices/ploc/PlocSupvHelper.cpp

@@ -95,7 +95,7 @@ ReturnValue_t PlocSupvHelper::performOperation(uint8_t operationCode) {
   }
 }
 
-ReturnValue_t PlocSupvHelper::setComIF(UartComIF* uartComIF_) {
+ReturnValue_t PlocSupvHelper::setComIF(SerialComIF* uartComIF_) {
   if (uartComIF_ == nullptr) {
     sif::warning << "PlocSupvHelper::initialize: Provided invalid uart com if" << std::endl;
     return returnvalue::FAILED;

linux/devices/ploc/PlocSupvHelper.h

@@ -9,7 +9,7 @@
 #include "fsfw/osal/linux/BinarySemaphore.h"
 #include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
-#include "fsfw_hal/linux/uart/UartComIF.h"
+#include "fsfw_hal/linux/serial/SerialComIF.h"
 #include "linux/devices/devicedefinitions/PlocSupervisorDefinitions.h"
 
 #ifdef XIPHOS_Q7S
@@ -104,7 +104,7 @@ class PlocSupvHelper : public SystemObject, public ExecutableObjectIF {
   ReturnValue_t initialize() override;
   ReturnValue_t performOperation(uint8_t operationCode = 0) override;
 
-  ReturnValue_t setComIF(UartComIF* uartComfIF_);
+  ReturnValue_t setComIF(SerialComIF* uartComfIF_);
   void setComCookie(CookieIF* comCookie_);
 
   /**
@@ -209,7 +209,7 @@ class PlocSupvHelper : public SystemObject, public ExecutableObjectIF {
   /**
    * Communication interface responsible for data transactions between OBC and Supervisor.
    */
-  UartComIF* uartComIF = nullptr;
+  SerialComIF* uartComIF = nullptr;
   // Communication cookie. Must be set by the supervisor Handler
   CookieIF* comCookie = nullptr;
 

linux/devices/startracker/StarTrackerHandler.cpp

@@ -240,13 +240,12 @@ void StarTrackerHandler::doStartUp() {
       // the device handler's submode to the star tracker's mode
       return;
     case StartupState::DONE:
-      submode = SUBMODE_BOOTLOADER;
       startupState = StartupState::IDLE;
       break;
     default:
       return;
   }
-  setMode(_MODE_TO_ON);
+  setMode(_MODE_TO_ON, SUBMODE_BOOTLOADER);
 }
 
 void StarTrackerHandler::doShutDown() {
@@ -654,7 +653,7 @@ void StarTrackerHandler::fillCommandAndReplyMap() {
 }
 
 ReturnValue_t StarTrackerHandler::isModeCombinationValid(Mode_t mode, Submode_t submode) {
-  if (this->mode == MODE_NORMAL && mode == MODE_ON) {
+  if (getMode() == MODE_NORMAL && mode == MODE_ON) {
     return TRANS_NOT_ALLOWED;
   }
   switch (mode) {
@@ -678,7 +677,7 @@ ReturnValue_t StarTrackerHandler::isModeCombinationValid(Mode_t mode, Submode_t
 }
 
 void StarTrackerHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
-  switch (mode) {
+  switch (getMode()) {
     case _MODE_TO_ON:
       doOnTransition(subModeFrom);
       break;
@@ -698,17 +697,18 @@ void StarTrackerHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
 }
 
 void StarTrackerHandler::doOnTransition(Submode_t subModeFrom) {
-  if (submode == SUBMODE_BOOTLOADER && subModeFrom == SUBMODE_FIRMWARE) {
+  uint8_t dhbSubmode = getSubmode();
+  if (dhbSubmode == SUBMODE_BOOTLOADER && subModeFrom == SUBMODE_FIRMWARE) {
     bootBootloader();
-  } else if (submode == SUBMODE_FIRMWARE && subModeFrom == SUBMODE_FIRMWARE) {
+  } else if (dhbSubmode == SUBMODE_FIRMWARE && subModeFrom == SUBMODE_FIRMWARE) {
     setMode(MODE_ON);
-  } else if (submode == SUBMODE_FIRMWARE && subModeFrom == SUBMODE_BOOTLOADER) {
+  } else if (dhbSubmode == SUBMODE_FIRMWARE && subModeFrom == SUBMODE_BOOTLOADER) {
     bootFirmware(MODE_ON);
-  } else if (submode == SUBMODE_BOOTLOADER && subModeFrom == SUBMODE_BOOTLOADER) {
+  } else if (dhbSubmode == SUBMODE_BOOTLOADER && subModeFrom == SUBMODE_BOOTLOADER) {
     setMode(MODE_ON);
-  } else if (submode == SUBMODE_BOOTLOADER && subModeFrom == SUBMODE_NONE) {
+  } else if (dhbSubmode == SUBMODE_BOOTLOADER && subModeFrom == SUBMODE_NONE) {
     setMode(MODE_ON);
-  } else if (submode == SUBMODE_FIRMWARE && subModeFrom == SUBMODE_NONE) {
+  } else if (dhbSubmode == SUBMODE_FIRMWARE && subModeFrom == SUBMODE_NONE) {
     setMode(MODE_ON);
   }
 }
@@ -2067,13 +2067,13 @@ ReturnValue_t StarTrackerHandler::checkCommand(ActionId_t actionId) {
     case startracker::REQ_SUBSCRIPTION:
     case startracker::REQ_LOG_SUBSCRIPTION:
     case startracker::REQ_DEBUG_CAMERA:
-      if (not(mode == MODE_ON && submode == startracker::Program::FIRMWARE)) {
+      if (not(getMode() == MODE_ON && getSubmode() == startracker::Program::FIRMWARE)) {
         return STARTRACKER_RUNNING_BOOTLOADER;
       }
       break;
     case startracker::FIRMWARE_UPDATE:
     case startracker::FLASH_READ:
-      if (not(mode == MODE_ON && submode == startracker::Program::BOOTLOADER)) {
+      if (not(getMode() == MODE_ON && getSubmode() == startracker::Program::BOOTLOADER)) {
         return STARTRACKER_RUNNING_FIRMWARE;
       }
       break;

linux/devices/startracker/StarTrackerHandler.h

@@ -72,7 +72,7 @@ class StarTrackerHandler : public DeviceHandlerBase {
   ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                         LocalDataPoolManager& poolManager) override;
   /**
-   * @brief   Overwritten here to always read all available data from the UartComIF.
+   * @brief   Overwritten here to always read all available data from theSerialComIF.
    */
   virtual size_t getNextReplyLength(DeviceCommandId_t deviceCommand) override;
   virtual ReturnValue_t doSendReadHook() override;

linux/devices/startracker/StrHelper.cpp

@@ -85,7 +85,7 @@ ReturnValue_t StrHelper::performOperation(uint8_t operationCode) {
 }
 
 ReturnValue_t StrHelper::setComIF(DeviceCommunicationIF* communicationInterface_) {
-  uartComIF = dynamic_cast<UartComIF*>(communicationInterface_);
+  uartComIF = dynamic_cast<SerialComIF*>(communicationInterface_);
   if (uartComIF == nullptr) {
     sif::warning << "StrHelper::initialize: Invalid uart com if" << std::endl;
     return returnvalue::FAILED;

linux/devices/startracker/StrHelper.h

@@ -15,7 +15,7 @@
 #include "fsfw/osal/linux/BinarySemaphore.h"
 #include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
-#include "fsfw_hal/linux/uart/UartComIF.h"
+#include "fsfw_hal/linux/serial/SerialComIF.h"
 
 extern "C" {
 #include "thirdparty/arcsec_star_tracker/client/generated/actionreq.h"
@@ -255,7 +255,7 @@ class StrHelper : public SystemObject, public ExecutableObjectIF {
    * UART communication object responsible for low level access of star tracker
    * Must be set by star tracker handler
    */
-  UartComIF* uartComIF = nullptr;
+  SerialComIF* uartComIF = nullptr;
   // Communication cookie. Must be set by the star tracker handler
   CookieIF* comCookie = nullptr;
 

linux/fsfwconfig/devices/addresses.h

@@ -43,11 +43,14 @@ enum logicalAddresses : address_t {
   DUMMY_GPS1 = 131,
 };
 
-enum i2cAddresses : address_t {
+enum I2cAddress : address_t {
   BPX_BATTERY = 0x07,
   IMTQ = 0x10,
-  TMP1075_TCS_1 = 0x48,
-  TMP1075_TCS_2 = 0x49,
+  TMP1075_TCS_0 = 0x48,
+  TMP1075_TCS_1 = 0x49,
+  TMP1075_PLPCDU_0 = 0x4A,
+  TMP1075_PLPCDU_1 = 0x4B,
+  TMP1075_IF_BOARD = 0x4C,
 };
 
 enum spiAddresses : address_t {

linux/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 233 translations.
+ * @brief    Auto-generated event translation file. Contains 234 translations.
  * @details
- * Generated on: 2022-10-27 09:03:07
+ * Generated on: 2022-11-14 17:10:10
  */
 #include "translateEvents.h"
 
@@ -144,6 +144,7 @@ const char *CARRIER_LOCK_STRING = "CARRIER_LOCK";
 const char *BIT_LOCK_PDEC_STRING = "BIT_LOCK_PDEC";
 const char *LOST_CARRIER_LOCK_PDEC_STRING = "LOST_CARRIER_LOCK_PDEC";
 const char *LOST_BIT_LOCK_PDEC_STRING = "LOST_BIT_LOCK_PDEC";
+const char *POLL_ERROR_PDEC_STRING = "POLL_ERROR_PDEC";
 const char *IMAGE_UPLOAD_FAILED_STRING = "IMAGE_UPLOAD_FAILED";
 const char *IMAGE_DOWNLOAD_FAILED_STRING = "IMAGE_DOWNLOAD_FAILED";
 const char *IMAGE_UPLOAD_SUCCESSFUL_STRING = "IMAGE_UPLOAD_SUCCESSFUL";
@@ -515,6 +516,8 @@ const char *translateEvents(Event event) {
       return LOST_CARRIER_LOCK_PDEC_STRING;
     case (12406):
       return LOST_BIT_LOCK_PDEC_STRING;
+    case (12407):
+      return POLL_ERROR_PDEC_STRING;
     case (12500):
       return IMAGE_UPLOAD_FAILED_STRING;
     case (12501):

linux/fsfwconfig/objects/translateObjects.cpp

@@ -1,8 +1,8 @@
 /**
  * @brief  Auto-generated object translation file.
  * @details
- * Contains 140 translations.
- * Generated on: 2022-10-27 09:03:07
+ * Contains 148 translations.
+ * Generated on: 2022-11-14 17:10:10
  */
 #include "translateObjects.h"
 
@@ -58,8 +58,12 @@ const char *PLOC_SUPERVISOR_HELPER_STRING = "PLOC_SUPERVISOR_HELPER";
 const char *SCEX_STRING = "SCEX";
 const char *SOLAR_ARRAY_DEPL_HANDLER_STRING = "SOLAR_ARRAY_DEPL_HANDLER";
 const char *HEATER_HANDLER_STRING = "HEATER_HANDLER";
-const char *TMP1075_HANDLER_1_STRING = "TMP1075_HANDLER_1";
-const char *TMP1075_HANDLER_2_STRING = "TMP1075_HANDLER_2";
+const char *TMP1075_HANDLER_TCS_0_STRING = "TMP1075_HANDLER_TCS_0";
+const char *TMP1075_HANDLER_TCS_1_STRING = "TMP1075_HANDLER_TCS_1";
+const char *TMP1075_HANDLER_PLPCDU_0_STRING = "TMP1075_HANDLER_PLPCDU_0";
+const char *TMP1075_HANDLER_PLPCDU_1_STRING = "TMP1075_HANDLER_PLPCDU_1";
+const char *TMP1075_HANDLER_IF_BOARD_STRING = "TMP1075_HANDLER_IF_BOARD";
+const char *TMP1075_HANDLER_OBC_IF_BOARD_STRING = "TMP1075_HANDLER_OBC_IF_BOARD";
 const char *RTD_0_IC3_PLOC_HEATSPREADER_STRING = "RTD_0_IC3_PLOC_HEATSPREADER";
 const char *RTD_1_IC4_PLOC_MISSIONBOARD_STRING = "RTD_1_IC4_PLOC_MISSIONBOARD";
 const char *RTD_2_IC5_4K_CAMERA_STRING = "RTD_2_IC5_4K_CAMERA";
@@ -139,11 +143,15 @@ const char *ACS_BOARD_ASS_STRING = "ACS_BOARD_ASS";
 const char *SUS_BOARD_ASS_STRING = "SUS_BOARD_ASS";
 const char *TCS_BOARD_ASS_STRING = "TCS_BOARD_ASS";
 const char *RW_ASS_STRING = "RW_ASS";
-const char *CFDP_HANDLER_STRING = "CFDP_HANDLER";
-const char *CFDP_DISTRIBUTOR_STRING = "CFDP_DISTRIBUTOR";
+const char *CAM_SWITCHER_STRING = "CAM_SWITCHER";
 const char *TM_FUNNEL_STRING = "TM_FUNNEL";
 const char *PUS_TM_FUNNEL_STRING = "PUS_TM_FUNNEL";
 const char *CFDP_TM_FUNNEL_STRING = "CFDP_TM_FUNNEL";
+const char *CFDP_HANDLER_STRING = "CFDP_HANDLER";
+const char *CFDP_DISTRIBUTOR_STRING = "CFDP_DISTRIBUTOR";
+const char *EIVE_SYSTEM_STRING = "EIVE_SYSTEM";
+const char *ACS_SUBSYSTEM_STRING = "ACS_SUBSYSTEM";
+const char *PL_SUBSYSTEM_STRING = "PL_SUBSYSTEM";
 const char *CCSDS_IP_CORE_BRIDGE_STRING = "CCSDS_IP_CORE_BRIDGE";
 const char *NO_OBJECT_STRING = "NO_OBJECT";
 
@@ -254,9 +262,17 @@ const char *translateObject(object_id_t object) {
     case 0x444100A4:
       return HEATER_HANDLER_STRING;
     case 0x44420004:
-      return TMP1075_HANDLER_1_STRING;
+      return TMP1075_HANDLER_TCS_0_STRING;
     case 0x44420005:
-      return TMP1075_HANDLER_2_STRING;
+      return TMP1075_HANDLER_TCS_1_STRING;
+    case 0x44420006:
+      return TMP1075_HANDLER_PLPCDU_0_STRING;
+    case 0x44420007:
+      return TMP1075_HANDLER_PLPCDU_1_STRING;
+    case 0x44420008:
+      return TMP1075_HANDLER_IF_BOARD_STRING;
+    case 0x44420009:
+      return TMP1075_HANDLER_OBC_IF_BOARD_STRING;
     case 0x44420016:
       return RTD_0_IC3_PLOC_HEATSPREADER_STRING;
     case 0x44420017:
@@ -415,16 +431,24 @@ const char *translateObject(object_id_t object) {
       return TCS_BOARD_ASS_STRING;
     case 0x73000004:
       return RW_ASS_STRING;
-    case 0x73000005:
-      return CFDP_HANDLER_STRING;
     case 0x73000006:
-      return CFDP_DISTRIBUTOR_STRING;
+      return CAM_SWITCHER_STRING;
     case 0x73000100:
       return TM_FUNNEL_STRING;
     case 0x73000101:
       return PUS_TM_FUNNEL_STRING;
     case 0x73000102:
       return CFDP_TM_FUNNEL_STRING;
+    case 0x73000205:
+      return CFDP_HANDLER_STRING;
+    case 0x73000206:
+      return CFDP_DISTRIBUTOR_STRING;
+    case 0x73010000:
+      return EIVE_SYSTEM_STRING;
+    case 0x73010001:
+      return ACS_SUBSYSTEM_STRING;
+    case 0x73010002:
+      return PL_SUBSYSTEM_STRING;
     case 0x73500000:
       return CCSDS_IP_CORE_BRIDGE_STRING;
     case 0xFFFFFFFF:

linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp

@@ -55,30 +55,6 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
   thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
   thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
 #endif
-#if OBSW_ADD_TMP_DEVICES == 1
-  thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-#endif
-
-#if OBSW_ADD_TMP_DEVICES == 1
-  thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-#endif
-
-#if OBSW_ADD_TMP_DEVICES == 1
-  thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0.2, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.2, DeviceHandlerIF::GET_WRITE);
-#endif
-
-#if OBSW_ADD_TMP_DEVICES == 1
-  thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0.2, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.2, DeviceHandlerIF::SEND_READ);
-#endif
-
-#if OBSW_ADD_TMP_DEVICES == 1
-  thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0.2, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.2, DeviceHandlerIF::GET_READ);
-#endif
 
 #if OBSW_ADD_SUN_SENSORS == 1
 
@@ -425,33 +401,78 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
   return thisSequence->checkSequence();
 }
 
+// I don't think this needs to be in a PST because linux takes care of bus serialization, but
+// keep it like this for now, it works
 ReturnValue_t pst::pstI2c(FixedTimeslotTaskIF *thisSequence) {
   // Length of a communication cycle
   uint32_t length = thisSequence->getPeriodMs();
   static_cast<void>(length);
 #if OBSW_ADD_MGT == 1
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, 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::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::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);
 #endif
 #if OBSW_ADD_BPX_BATTERY_HANDLER == 1
-  thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0.2,
+                        DeviceHandlerIF::PERFORM_OPERATION);
   thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0.2, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0.25, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0.25, DeviceHandlerIF::GET_READ);
+#endif
+  // These are actually part of another bus, but this works, so keep it like this for now
+#if OBSW_ADD_TMP_DEVICES == 1
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.4,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.4, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.4, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.4, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.4, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.4,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.4, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.4, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.4, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.4, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.4,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.4,
+                        DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.4,
+                        DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.4,
+                        DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.4, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.4,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.4,
+                        DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.4,
+                        DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.4,
+                        DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.4, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.4,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.4,
+                        DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.4,
+                        DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.4,
+                        DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.4, DeviceHandlerIF::GET_READ);
 #endif
   static_cast<void>(length);
   return thisSequence->checkSequence();
@@ -461,26 +482,6 @@ ReturnValue_t pst::pstUart(FixedTimeslotTaskIF *thisSequence) {
   // Length of a communication cycle
   uint32_t length = thisSequence->getPeriodMs();
   static_cast<void>(length);
-#if OBSW_ADD_PLOC_MPSOC == 1
-  thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0,
-                        DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::PLOC_MEMORY_DUMPER, length * 0,
-                        DeviceHandlerIF::PERFORM_OPERATION);
-#endif
-
-#if OBSW_ADD_PLOC_SUPERVISOR == 1
-  thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0,
-                        DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0.2,
-                        DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ);
-#endif
 
 #if OBSW_ADD_SYRLINKS == 1
   thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0,

linux/ipcore/AxiPtmeConfig.cpp

@@ -4,7 +4,7 @@
 #include "fsfw_hal/linux/uio/UioMapper.h"
 
 AxiPtmeConfig::AxiPtmeConfig(object_id_t objectId, std::string axiUio, int mapNum)
-    : SystemObject(objectId), axiUio(axiUio), mapNum(mapNum) {
+    : SystemObject(objectId), axiUio(std::move(axiUio)), mapNum(mapNum) {
   mutex = MutexFactory::instance()->createMutex();
   if (mutex == nullptr) {
     sif::warning << "Failed to create mutex" << std::endl;

linux/ipcore/PapbVcInterface.cpp

@@ -1,5 +1,5 @@
 #include <fsfw_hal/linux/uio/UioMapper.h>
-#include <linux/obc/PapbVcInterface.h>
+#include <linux/ipcore/PapbVcInterface.h>
 
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
@@ -8,7 +8,7 @@ PapbVcInterface::PapbVcInterface(LinuxLibgpioIF* gpioComIF, gpioId_t papbBusyId,
     : gpioComIF(gpioComIF),
       papbBusyId(papbBusyId),
       papbEmptyId(papbEmptyId),
-      uioFile(uioFile),
+      uioFile(std::move(uioFile)),
       mapNum(mapNum) {}
 
 PapbVcInterface::~PapbVcInterface() {}

linux/ipcore/PapbVcInterface.h

@@ -6,7 +6,7 @@
 
 #include "OBSWConfig.h"
 #include "fsfw/returnvalues/returnvalue.h"
-#include "linux/obc/VcInterfaceIF.h"
+#include "linux/ipcore/VcInterfaceIF.h"
 
 /**
  * @brief   This class handles the transmission of data to a virtual channel of the PTME IP Core

linux/ipcore/PdecConfig.cpp

@@ -31,3 +31,8 @@ uint32_t PdecConfig::getConfigWord(uint8_t wordNo) {
   }
   return configWords[wordNo];
 }
+
+uint32_t PdecConfig::getImrReg() {
+  return static_cast<uint32_t>(enableNewFarIrq << 2) |
+         static_cast<uint32_t>(enableTcAbortIrq << 1) | static_cast<uint32_t>(enableTcNewIrq);
+}

linux/ipcore/PdecConfig.h

@@ -23,6 +23,7 @@ class PdecConfig {
    * @brief   Returns the configuration word by specifying the position.
    */
   uint32_t getConfigWord(uint8_t wordNo);
+  uint32_t getImrReg();
 
  private:
   // TC transfer frame configuration parameters
@@ -45,6 +46,9 @@ class PdecConfig {
   static const uint8_t CONFIG_WORDS_NUM = 2;
 
   uint32_t configWords[CONFIG_WORDS_NUM];
+  bool enableTcNewIrq = true;
+  bool enableTcAbortIrq = true;
+  bool enableNewFarIrq = true;
 
   void initialize();
 };

linux/ipcore/PdecHandler.cpp

@@ -1,7 +1,9 @@
 #include "PdecHandler.h"
 
 #include <fcntl.h>
+#include <poll.h>
 #include <sys/mman.h>
+#include <unistd.h>
 
 #include <cstring>
 #include <sstream>
@@ -12,18 +14,21 @@
 #include "fsfw/serviceinterface/ServiceInterface.h"
 #include "fsfw/tmtcservices/TmTcMessage.h"
 #include "fsfw_hal/linux/uio/UioMapper.h"
+#include "pdec.h"
+
+using namespace pdec;
+
+// If this is ever shared, protect it with a mutex!
+uint32_t PdecHandler::CURRENT_FAR = 0;
 
 PdecHandler::PdecHandler(object_id_t objectId, object_id_t tcDestinationId,
-                         LinuxLibgpioIF* gpioComIF, gpioId_t pdecReset, std::string uioConfigMemory,
-                         std::string uioRamMemory, std::string uioRegisters)
+                         LinuxLibgpioIF* gpioComIF, gpioId_t pdecReset, UioNames names)
     : SystemObject(objectId),
       tcDestinationId(tcDestinationId),
       gpioComIF(gpioComIF),
       pdecReset(pdecReset),
-      uioConfigMemory(uioConfigMemory),
-      uioRamMemory(uioRamMemory),
-      uioRegisters(uioRegisters),
-      actionHelper(this, nullptr) {
+      actionHelper(this, nullptr),
+      uioNames(names) {
   auto mqArgs = MqArgs(objectId, static_cast<void*>(this));
   commandQueue = QueueFactory::instance()->createMessageQueue(
       QUEUE_SIZE, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
@@ -47,29 +52,39 @@ ReturnValue_t PdecHandler::initialize() {
 
   ReturnValue_t result = returnvalue::OK;
 
-  UioMapper regMapper(uioRegisters);
+  UioMapper regMapper(uioNames.registers);
   result = regMapper.getMappedAdress(&registerBaseAddress, UioMapper::Permissions::READ_WRITE);
   if (result != returnvalue::OK) {
     return ObjectManagerIF::CHILD_INIT_FAILED;
   }
-  UioMapper configMemMapper(uioConfigMemory);
+  UioMapper configMemMapper(uioNames.configMemory);
   result = configMemMapper.getMappedAdress(&memoryBaseAddress, UioMapper::Permissions::READ_WRITE);
   if (result != returnvalue::OK) {
     return ObjectManagerIF::CHILD_INIT_FAILED;
   }
-  UioMapper ramMapper(uioRamMemory);
+  UioMapper ramMapper(uioNames.ramMemory);
   result = ramMapper.getMappedAdress(&ramBaseAddress, UioMapper::Permissions::READ_WRITE);
   if (result != returnvalue::OK) {
     return ObjectManagerIF::CHILD_INIT_FAILED;
   }
 
-  writePdecConfig();
+  if (OP_MODE == Modes::IRQ and uioNames.irq == nullptr) {
+    sif::error << "Can not use IRQ mode if IRQ UIO name is invalid" << std::endl;
+    return returnvalue::FAILED;
+  }
+  PdecConfig pdecConfig;
+  writePdecConfigDuringReset(pdecConfig);
 
   result = releasePdec();
   if (result != returnvalue::OK) {
     return ObjectManagerIF::CHILD_INIT_FAILED;
   }
 
+  // This configuration must be done while the PDEC is not held in reset.
+  if (OP_MODE == Modes::IRQ) {
+    // Configure interrupt mask register to enable interrupts
+    *(registerBaseAddress + PDEC_IMR_OFFSET) = pdecConfig.getImrReg();
+  }
   result = actionHelper.initialize(commandQueue);
   if (result != returnvalue::OK) {
     return result;
@@ -78,59 +93,16 @@ ReturnValue_t PdecHandler::initialize() {
   return returnvalue::OK;
 }
 
-MessageQueueId_t PdecHandler::getCommandQueue() const { return commandQueue->getId(); }
-
-void PdecHandler::writePdecConfig() {
-  PdecConfig pdecConfig;
-
-  *(memoryBaseAddress + FRAME_HEADER_OFFSET) = pdecConfig.getConfigWord(0);
-  *(memoryBaseAddress + FRAME_HEADER_OFFSET + 1) = pdecConfig.getConfigWord(1);
-
-  // Configure all MAP IDs as invalid
-  for (int idx = 0; idx <= MAX_MAP_ADDR; idx += 4) {
-    *(memoryBaseAddress + MAP_ADDR_LUT_OFFSET + idx / 4) =
-        NO_DESTINATION << 24 | NO_DESTINATION << 16 | NO_DESTINATION << 8 | NO_DESTINATION;
-  }
-
-  // All TCs with MAP ID 7 will be routed to the PM module (can then be read from memory)
-  uint8_t routeToPm = calcMapAddrEntry(PM_BUFFER);
-  *(memoryBaseAddress + MAP_ADDR_LUT_OFFSET + 1) =
-      (NO_DESTINATION << 24) | (NO_DESTINATION << 16) | (NO_DESTINATION << 8) | routeToPm;
-
-  // Write map id clock frequencies
-  for (int idx = 0; idx <= MAX_MAP_ADDR; idx += 4) {
-    *(memoryBaseAddress + MAP_CLK_FREQ_OFFSET + idx / 4) =
-        MAP_CLK_FREQ << 24 | MAP_CLK_FREQ << 16 | MAP_CLK_FREQ << 8 | MAP_CLK_FREQ;
-  }
-}
-
-ReturnValue_t PdecHandler::resetFarStatFlag() {
-  uint32_t pdecFar = *(registerBaseAddress + PDEC_FAR_OFFSET);
-  if (pdecFar != FAR_RESET) {
-    sif::warning << "PdecHandler::resetFarStatFlag: FAR register did not match expected value."
-                 << " Read value: 0x" << std::hex << static_cast<unsigned int>(pdecFar)
-                 << std::endl;
-    return returnvalue::FAILED;
-  }
-#if OBSW_DEBUG_PDEC_HANDLER == 1
-  sif::debug << "PdecHandler::resetFarStatFlag: read FAR with value: 0x" << std::hex << pdecFar
-             << std::endl;
-#endif /* OBSW_DEBUG_PDEC_HANDLER == 1 */
-  return returnvalue::OK;
-}
-
-ReturnValue_t PdecHandler::releasePdec() {
-  ReturnValue_t result = returnvalue::OK;
-  result = gpioComIF->pullHigh(pdecReset);
-  if (result != returnvalue::OK) {
-    sif::error << "PdecHandler::releasePdec: Failed to release PDEC reset signal" << std::endl;
-  }
-  return result;
-}
-
 ReturnValue_t PdecHandler::performOperation(uint8_t operationCode) {
-  ReturnValue_t result = returnvalue::OK;
+  if (OP_MODE == Modes::POLLED) {
+    return polledOperation();
+  } else if (OP_MODE == Modes::IRQ) {
+    return irqOperation();
+  }
+}
 
+ReturnValue_t PdecHandler::polledOperation() {
+  ReturnValue_t result = returnvalue::OK;
   readCommandQueue();
 
   switch (state) {
@@ -153,13 +125,94 @@ ReturnValue_t PdecHandler::performOperation(uint8_t operationCode) {
     case State::WAIT_FOR_RECOVERY:
       break;
     default:
-      sif::debug << "PdecHandler::performOperation: Invalid state" << std::endl;
+      sif::error << "PdecHandler::performOperation: Invalid state" << std::endl;
       break;
   }
 
   return returnvalue::OK;
 }
 
+ReturnValue_t PdecHandler::irqOperation() {
+  ReturnValue_t result = returnvalue::OK;
+  int fd = open(uioNames.irq, O_RDWR);
+  if (fd < 0) {
+    sif::error << "PdecHandler::irqOperation: Opening UIO IRQ file" << uioNames.irq << " failed"
+               << std::endl;
+    return returnvalue::FAILED;
+  }
+
+  struct pollfd fds = {.fd = fd, .events = POLLIN, .revents = 0};
+  // Used to unmask IRQ
+  uint32_t info = 1;
+  ssize_t nb = 0;
+  int ret = 0;
+  // Clear interrupts with dummy read before unmasking the interrupt
+  ret = *(registerBaseAddress + PDEC_PIR_OFFSET);
+
+  while (true) {
+    readCommandQueue();
+    switch (state) {
+      case State::INIT:
+        resetFarStatFlag();
+        if (result != returnvalue::OK) {
+          // Requires reconfiguration and reinitialization of PDEC
+          triggerEvent(INVALID_FAR);
+          state = State::WAIT_FOR_RECOVERY;
+          return result;
+        }
+        state = State::RUNNING;
+        break;
+      case State::RUNNING: {
+        nb = write(fd, &info, sizeof(info));
+        if (nb != static_cast<ssize_t>(sizeof(info))) {
+          sif::error << "PdecHandler::irqOperation: Unmasking IRQ failed" << std::endl;
+          close(fd);
+        }
+
+        ret = poll(&fds, 1, IRQ_TIMEOUT_MS);
+        if (ret == 0) {
+          // No TCs for timeout period
+          checkLocks();
+          lockCheckCd.resetTimer();
+        } else if (ret >= 1) {
+          nb = read(fd, &info, sizeof(info));
+          if (nb == static_cast<ssize_t>(sizeof(info))) {
+            uint32_t pisr = *(registerBaseAddress + PDEC_PISR_OFFSET);
+            if ((pisr & TC_NEW_MASK) == TC_NEW_MASK) {
+              // handle TC
+              handleNewTc();
+            }
+            if ((pisr & TC_ABORT_MASK) == TC_ABORT_MASK) {
+              tcAbortCounter += 1;
+            }
+            if ((pisr & NEW_FAR_MASK) == NEW_FAR_MASK) {
+              // Read FAR here
+              CURRENT_FAR = readFar();
+            }
+            if (lockCheckCd.hasTimedOut()) {
+              checkLocks();
+              lockCheckCd.resetTimer();
+            }
+            // Clear interrupts with dummy read
+            ret = *(registerBaseAddress + PDEC_PIR_OFFSET);
+          }
+        } else {
+          sif::error << "PdecHandler::irqOperation: Poll error with errno " << errno << ": "
+                     << strerror(errno) << std::endl;
+          triggerEvent(POLL_ERROR_PDEC, errno);
+        }
+        break;
+      }
+      case State::WAIT_FOR_RECOVERY:
+        break;
+      default:
+        sif::error << "PdecHandler::performOperation: Invalid state" << std::endl;
+        break;
+    }
+  }
+  return returnvalue::OK;
+}
+
 void PdecHandler::readCommandQueue(void) {
   CommandMessage commandMessage;
   ReturnValue_t result = returnvalue::FAILED;
@@ -177,13 +230,65 @@ void PdecHandler::readCommandQueue(void) {
   }
 }
 
+MessageQueueId_t PdecHandler::getCommandQueue() const { return commandQueue->getId(); }
+
+void PdecHandler::writePdecConfigDuringReset(PdecConfig& pdecConfig) {
+  *(memoryBaseAddress + FRAME_HEADER_OFFSET) = pdecConfig.getConfigWord(0);
+  *(memoryBaseAddress + FRAME_HEADER_OFFSET + 1) = pdecConfig.getConfigWord(1);
+
+  // Configure all MAP IDs as invalid
+  for (int idx = 0; idx <= MAX_MAP_ADDR; idx += 4) {
+    *(memoryBaseAddress + MAP_ADDR_LUT_OFFSET + idx / 4) =
+        NO_DESTINATION << 24 | NO_DESTINATION << 16 | NO_DESTINATION << 8 | NO_DESTINATION;
+  }
+
+  // All TCs with MAP ID 7 will be routed to the PM module (can then be read from memory)
+  uint8_t routeToPm = calcMapAddrEntry(PM_BUFFER);
+  *(memoryBaseAddress + MAP_ADDR_LUT_OFFSET + 1) =
+      (NO_DESTINATION << 24) | (NO_DESTINATION << 16) | (NO_DESTINATION << 8) | routeToPm;
+
+  // Write map id clock frequencies
+  for (int idx = 0; idx <= MAX_MAP_ADDR; idx += 4) {
+    *(memoryBaseAddress + MAP_CLK_FREQ_OFFSET + idx / 4) =
+        MAP_CLK_FREQ << 24 | MAP_CLK_FREQ << 16 | MAP_CLK_FREQ << 8 | MAP_CLK_FREQ;
+  }
+}
+
+ReturnValue_t PdecHandler::resetFarStatFlag() {
+  uint32_t pdecFar = readFar();
+  if ((pdecFar & FAR_STAT_MASK) != 0) {
+    sif::warning << "PdecHandler::resetFarStatFlag: FAR register stat bit is not 0."
+                 << " Read value for FAR: 0x" << std::hex << static_cast<unsigned int>(pdecFar)
+                 << std::endl;
+    CURRENT_FAR = pdecFar;
+    return returnvalue::FAILED;
+  }
+#if OBSW_DEBUG_PDEC_HANDLER == 1
+  sif::debug << "PdecHandler::resetFarStatFlag: read FAR with value: 0x" << std::hex << pdecFar
+             << std::endl;
+#endif /* OBSW_DEBUG_PDEC_HANDLER == 1 */
+  CURRENT_FAR = pdecFar;
+  return returnvalue::OK;
+}
+
+ReturnValue_t PdecHandler::releasePdec() {
+  ReturnValue_t result = returnvalue::OK;
+  result = gpioComIF->pullHigh(pdecReset);
+  if (result != returnvalue::OK) {
+    sif::error << "PdecHandler::releasePdec: Failed to release PDEC reset signal" << std::endl;
+  }
+  return result;
+}
+
 bool PdecHandler::newTcReceived() {
-  uint32_t pdecFar = *(registerBaseAddress + PDEC_FAR_OFFSET);
+  uint32_t pdecFar = readFar();
 
   if (pdecFar >> STAT_POSITION != NEW_FAR_RECEIVED) {
+    CURRENT_FAR = pdecFar;
     return false;
   }
   if (!checkFrameAna(pdecFar)) {
+    CURRENT_FAR = pdecFar;
     return false;
   }
   return true;
@@ -331,7 +436,6 @@ void PdecHandler::handleNewTc() {
   printTC(tcLength);
 #endif /* OBSW_DEBUG_PDEC_HANDLER */
 
-#if OBSW_TC_FROM_PDEC == 1
   store_address_t storeId;
   result = tcStore->addData(&storeId, tcSegment + 1, tcLength - 1);
   if (result != returnvalue::OK) {
@@ -349,7 +453,6 @@ void PdecHandler::handleNewTc() {
     tcStore->deleteData(storeId);
     return;
   }
-#endif /* OBSW_TC_FROM_PDEC == 1 */
 
   return;
 }
@@ -500,6 +603,8 @@ void PdecHandler::printPdecMon() {
   sif::info << std::setw(30) << std::left << "Start sequence lock: " << lock << std::endl;
 }
 
+uint32_t PdecHandler::readFar() { return *(registerBaseAddress + PDEC_FAR_OFFSET); }
+
 std::string PdecHandler::getMonStatusString(uint32_t status) {
   switch (status) {
     case TC_CHANNEL_INACTIVE:

linux/ipcore/PdecHandler.h

@@ -1,6 +1,8 @@
 #ifndef LINUX_OBC_PDECHANDLER_H_
 #define LINUX_OBC_PDECHANDLER_H_
 
+#include <fsfw/timemanager/Countdown.h>
+
 #include "OBSWConfig.h"
 #include "PdecConfig.h"
 #include "fsfw/action/ActionHelper.h"
@@ -13,6 +15,13 @@
 #include "fsfw_hal/common/gpio/gpioDefinitions.h"
 #include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
 
+struct UioNames {
+  const char* configMemory;
+  const char* ramMemory;
+  const char* registers;
+  const char* irq;
+};
+
 /**
  * @brief   This class controls the PDEC IP Core implemented in the programmable logic of the
  *          Zynq-7020. All registers and memories of the PDEC IP Core are accessed via UIO
@@ -33,6 +42,10 @@
  */
 class PdecHandler : public SystemObject, public ExecutableObjectIF, public HasActionsIF {
  public:
+  static constexpr dur_millis_t IRQ_TIMEOUT_MS = 500;
+
+  enum class Modes { POLLED, IRQ };
+
   /**
    * @brief   Constructor
    * @param objectId  Object ID of PDEC handler system object
@@ -43,8 +56,7 @@ class PdecHandler : public SystemObject, public ExecutableObjectIF, public HasAc
    * @param uioregsiters  String of uio device file same mapped to the PDEC register space
    */
   PdecHandler(object_id_t objectId, object_id_t tcDestinationId, LinuxLibgpioIF* gpioComIF,
-              gpioId_t pdecReset, std::string uioConfigMemory, std::string uioRamMemory,
-              std::string uioRegisters);
+              gpioId_t pdecReset, UioNames names);
 
   virtual ~PdecHandler();
 
@@ -74,10 +86,13 @@ class PdecHandler : public SystemObject, public ExecutableObjectIF, public HasAc
   static const Event LOST_CARRIER_LOCK_PDEC = MAKE_EVENT(5, severity::INFO);
   //! [EXPORT] : [COMMENT] Lost bit lock
   static const Event LOST_BIT_LOCK_PDEC = MAKE_EVENT(6, severity::INFO);
+  static constexpr Event POLL_ERROR_PDEC = event::makeEvent(SUBSYSTEM_ID, 7, severity::MEDIUM);
 
  private:
   static const uint8_t INTERFACE_ID = CLASS_ID::PDEC_HANDLER;
 
+  static constexpr Modes OP_MODE = Modes::IRQ;
+
   static const ReturnValue_t ABANDONED_CLTU = MAKE_RETURN_CODE(0xA0);
   static const ReturnValue_t FRAME_DIRTY = MAKE_RETURN_CODE(0xA1);
   static const ReturnValue_t FRAME_ILLEGAL_ONE_REASON = MAKE_RETURN_CODE(0xA2);
@@ -112,48 +127,6 @@ class PdecHandler : public SystemObject, public ExecutableObjectIF, public HasAc
   // Print PDEC monitor register
   static const ActionId_t PRINT_PDEC_MON = 1;
 
-  static const uint8_t STAT_POSITION = 31;
-  static const uint8_t FRAME_ANA_POSITION = 28;
-  static const uint8_t IREASON_POSITION = 25;
-
-  static const uint8_t NEW_FAR_RECEIVED = 0;
-
-  static const uint32_t FRAME_ANA_MASK = 0x70000000;
-  static const uint32_t IREASON_MASK = 0x0E000000;
-
-  static const uint32_t TC_CHANNEL_INACTIVE = 0x0;
-  static const uint32_t TC_CHANNEL_ACTIVE = 0x1;
-  static const uint32_t TC_CHANNEL_TIMEDOUT = 0x2;
-
-  static const uint32_t TC0_STATUS_MASK = 0x3;
-  static const uint32_t TC1_STATUS_MASK = 0xC;
-  static const uint32_t TC2_STATUS_MASK = 0x300;
-  static const uint32_t TC3_STATUS_MASK = 0xC00;
-  static const uint32_t TC4_STATUS_MASK = 0x30000;
-  static const uint32_t TC5_STATUS_MASK = 0xc00000;
-  // Lock register set to 1 when start sequence has been found (CLTU is beeing processed)
-  static const uint32_t LOCK_MASK = 0xc00000;
-
-  static const uint32_t TC0_STATUS_POS = 0;
-  static const uint32_t TC1_STATUS_POS = 2;
-  static const uint32_t TC2_STATUS_POS = 4;
-  static const uint32_t TC3_STATUS_POS = 6;
-  static const uint32_t TC4_STATUS_POS = 8;
-  static const uint32_t TC5_STATUS_POS = 10;
-  // Lock register set to 1 when start sequence has been found (CLTU is beeing processed)
-  static const uint32_t LOCK_POS = 12;
-
-  /**
-   * UIO is 4 byte aligned. Thus offset is calculated with "true offset" / 4
-   * Example: PDEC_FAR = 0x2840 => Offset in virtual address space is 0xA10
-   */
-  static const uint32_t PDEC_FAR_OFFSET = 0xA10;
-  static const uint32_t PDEC_CLCW_OFFSET = 0xA12;
-  static const uint32_t PDEC_BFREE_OFFSET = 0xA24;
-  static const uint32_t PDEC_BPTR_OFFSET = 0xA25;
-  static const uint32_t PDEC_SLEN_OFFSET = 0xA26;
-  static const uint32_t PDEC_MON_OFFSET = 0xA27;
-
 #ifdef TE0720_1CFA
   static const int CONFIG_MEMORY_MAP_SIZE = 0x400;
   static const int RAM_MAP_SIZE = 0x4000;
@@ -227,16 +200,69 @@ class PdecHandler : public SystemObject, public ExecutableObjectIF, public HasAc
 
   enum class State : uint8_t { INIT, RUNNING, WAIT_FOR_RECOVERY };
 
+  static uint32_t CURRENT_FAR;
+
+  Countdown lockCheckCd = Countdown(IRQ_TIMEOUT_MS);
+  object_id_t tcDestinationId;
+
+  AcceptsTelecommandsIF* tcDestination = nullptr;
+
+  LinuxLibgpioIF* gpioComIF = nullptr;
+
+  /**
+   * Reset signal is required to hold PDEC in reset state until the configuration has been
+   * written to the appropriate memory space.
+   * Can also be used to reboot PDEC in case of erros.
+   */
+  gpioId_t pdecReset = gpio::NO_GPIO;
+
+  uint32_t tcAbortCounter = 0;
+
+  ActionHelper actionHelper;
+
+  StorageManagerIF* tcStore = nullptr;
+
+  MessageQueueIF* commandQueue = nullptr;
+
+  State state = State::INIT;
+
+  /**
+   * Pointer pointing to base address of the PDEC memory space.
+   * This address is equivalent with the base address of the section named configuration area in
+   * the PDEC datasheet.
+   */
+  uint32_t* memoryBaseAddress = nullptr;
+
+  uint32_t* ramBaseAddress = nullptr;
+
+  // Pointer pointing to base address of register space
+  uint32_t* registerBaseAddress = nullptr;
+
+  uint8_t tcSegment[TC_SEGMENT_LEN];
+
+  // Used to check carrier and bit lock changes (default set to no rf and no bitlock)
+  uint32_t lastClcw = 0xC000;
+
+  bool carrierLock = false;
+  bool bitLock = false;
+
+  UioNames uioNames;
+
   /**
    * @brief   Reads and handles messages stored in the commandQueue
    */
   void readCommandQueue(void);
 
+  ReturnValue_t polledOperation();
+  ReturnValue_t irqOperation();
+
+  uint32_t readFar();
+
   /**
    * @brief   This functions writes the configuration parameters to the configuration
    *          section of the PDEC.
    */
-  void writePdecConfig();
+  void writePdecConfigDuringReset(PdecConfig& config);
 
   /**
    * @brief   Reading the FAR resets the set stat flag which signals a new TC. Without clearing
@@ -343,58 +369,6 @@ class PdecHandler : public SystemObject, public ExecutableObjectIF, public HasAc
   void printPdecMon();
 
   std::string getMonStatusString(uint32_t status);
-
-  object_id_t tcDestinationId;
-
-  AcceptsTelecommandsIF* tcDestination = nullptr;
-
-  LinuxLibgpioIF* gpioComIF = nullptr;
-
-  /**
-   * Reset signal is required to hold PDEC in reset state until the configuration has been
-   * written to the appropriate memory space.
-   * Can also be used to reboot PDEC in case of erros.
-   */
-  gpioId_t pdecReset = gpio::NO_GPIO;
-
-  // UIO device file giving access to the PDEC configuration memory section
-  std::string uioConfigMemory;
-
-  // UIO device file giving access to the PDEC RAM section
-  std::string uioRamMemory;
-
-  // UIO device file giving access to the PDEC register space
-  std::string uioRegisters;
-
-  ActionHelper actionHelper;
-
-  StorageManagerIF* tcStore = nullptr;
-
-  MessageQueueIF* commandQueue = nullptr;
-
-  State state = State::INIT;
-
-  /**
-   * Pointer pointing to base address of the PDEC memory space.
-   * This address is equivalent with the base address of the section named configuration area in
-   * the PDEC datasheet.
-   */
-  uint32_t* memoryBaseAddress = nullptr;
-
-  uint32_t* ramBaseAddress = nullptr;
-
-  // Pointer pointing to base address of register space
-  uint32_t* registerBaseAddress = nullptr;
-
-  uint32_t pdecFar = 0;
-
-  uint8_t tcSegment[TC_SEGMENT_LEN];
-
-  // Used to check carrier and bit lock changes (default set to no rf and no bitlock)
-  uint32_t lastClcw = 0xC000;
-
-  bool carrierLock = false;
-  bool bitLock = false;
 };
 
 #endif /* LINUX_OBC_PDECHANDLER_H_ */

linux/ipcore/Ptme.cpp

@@ -1,5 +1,5 @@
 #include <fcntl.h>
-#include <linux/obc/Ptme.h>
+#include <linux/ipcore/Ptme.h>
 #include <sys/mman.h>
 #include <unistd.h>
 

linux/ipcore/Ptme.h

@@ -9,8 +9,8 @@
 
 #include "OBSWConfig.h"
 #include "fsfw/returnvalues/returnvalue.h"
-#include "linux/obc/PtmeIF.h"
-#include "linux/obc/VcInterfaceIF.h"
+#include "linux/ipcore/PtmeIF.h"
+#include "linux/ipcore/VcInterfaceIF.h"
 
 /**
  * @brief   This class handles the interfacing to the telemetry (PTME) IP core responsible for the

linux/ipcore/PtmeConfig.h

@@ -4,7 +4,7 @@
 #include "AxiPtmeConfig.h"
 #include "fsfw/objectmanager/SystemObject.h"
 #include "fsfw/returnvalues/returnvalue.h"
-#include "linux/obc/PtmeConfig.h"
+#include "linux/ipcore/PtmeConfig.h"
 #include "returnvalues/classIds.h"
 
 /**

linux/ipcore/pdec.h

@@ -0,0 +1,61 @@
+#ifndef LINUX_OBC_PDEC_H_
+#define LINUX_OBC_PDEC_H_
+
+#include <cstdint>
+
+namespace pdec {
+
+static const uint8_t STAT_POSITION = 31;
+static const uint8_t FRAME_ANA_POSITION = 28;
+static const uint8_t IREASON_POSITION = 25;
+
+static const uint8_t NEW_FAR_RECEIVED = 0;
+
+static constexpr uint32_t NEW_FAR_MASK = 1 << 2;
+static constexpr uint32_t TC_ABORT_MASK = 1 << 1;
+static constexpr uint32_t TC_NEW_MASK = 1 << 0;
+
+static constexpr uint32_t FAR_STAT_MASK = 1 << 31;
+
+static const uint32_t FRAME_ANA_MASK = 0x70000000;
+static const uint32_t IREASON_MASK = 0x0E000000;
+
+static const uint32_t TC_CHANNEL_INACTIVE = 0x0;
+static const uint32_t TC_CHANNEL_ACTIVE = 0x1;
+static const uint32_t TC_CHANNEL_TIMEDOUT = 0x2;
+
+static const uint32_t TC0_STATUS_MASK = 0x3;
+static const uint32_t TC1_STATUS_MASK = 0xC;
+static const uint32_t TC2_STATUS_MASK = 0x300;
+static const uint32_t TC3_STATUS_MASK = 0xC00;
+static const uint32_t TC4_STATUS_MASK = 0x30000;
+static const uint32_t TC5_STATUS_MASK = 0xc00000;
+// Lock register set to 1 when start sequence has been found (CLTU is beeing processed)
+static const uint32_t LOCK_MASK = 0xc00000;
+
+static const uint32_t TC0_STATUS_POS = 0;
+static const uint32_t TC1_STATUS_POS = 2;
+static const uint32_t TC2_STATUS_POS = 4;
+static const uint32_t TC3_STATUS_POS = 6;
+static const uint32_t TC4_STATUS_POS = 8;
+static const uint32_t TC5_STATUS_POS = 10;
+// Lock register set to 1 when start sequence has been found (CLTU is beeing processed)
+static const uint32_t LOCK_POS = 12;
+
+/**
+ * UIO is 4 byte aligned. Thus offset is calculated with "true offset" / 4
+ * Example: PDEC_FAR = 0x2840 => Offset in virtual address space is 0xA10
+ */
+static constexpr uint32_t PDEC_PISR_OFFSET = 0xA02;
+static constexpr uint32_t PDEC_PIR_OFFSET = 0xA03;
+static constexpr uint32_t PDEC_IMR_OFFSET = 0xA04;
+static const uint32_t PDEC_FAR_OFFSET = 0xA10;
+static const uint32_t PDEC_CLCW_OFFSET = 0xA12;
+static const uint32_t PDEC_BFREE_OFFSET = 0xA24;
+static const uint32_t PDEC_BPTR_OFFSET = 0xA25;
+static const uint32_t PDEC_SLEN_OFFSET = 0xA26;
+static const uint32_t PDEC_MON_OFFSET = 0xA27;
+
+}  // namespace pdec
+
+#endif /* LINUX_OBC_PDEC_H_ */

mission/controller/AcsController.cpp

@@ -5,7 +5,7 @@
 #include "mission/devices/torquer.h"
 
 AcsController::AcsController(object_id_t objectId)
-    : ExtendedControllerBase(objectId, objects::NO_OBJECT), mgmData(this) {}
+    : ExtendedControllerBase(objectId), mgmData(this) {}
 
 ReturnValue_t AcsController::handleCommandMessage(CommandMessage *message) {
   return returnvalue::OK;

mission/controller/ThermalController.cpp

@@ -14,8 +14,8 @@
 #include <mission/devices/devicedefinitions/payloadPcduDefinitions.h>
 #include <objects/systemObjectList.h>
 
-ThermalController::ThermalController(object_id_t objectId, object_id_t parentId)
-    : ExtendedControllerBase(objectId, parentId),
+ThermalController::ThermalController(object_id_t objectId)
+    : ExtendedControllerBase(objectId),
       sensorTemperatures(this),
       susTemperatures(this),
       deviceTemperatures(this),
@@ -38,8 +38,11 @@ ThermalController::ThermalController(object_id_t objectId, object_id_t parentId)
                     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),
+      tmp1075SetTcs0(objects::TMP1075_HANDLER_TCS_0),
+      tmp1075SetTcs1(objects::TMP1075_HANDLER_TCS_1),
+      tmp1075SetPlPcdu0(objects::TMP1075_HANDLER_PLPCDU_0),
+      tmp1075SetPlPcdu1(objects::TMP1075_HANDLER_PLPCDU_1),
+      tmp1075SetIfBoard(objects::TMP1075_HANDLER_IF_BOARD),
       susSet0(objects::SUS_0_N_LOC_XFYFZM_PT_XF),
       susSet1(objects::SUS_1_N_LOC_XBYFZM_PT_XB),
       susSet2(objects::SUS_2_N_LOC_XFYBZB_PT_YB),
@@ -128,10 +131,11 @@ ReturnValue_t ThermalController::initializeLocalDataPool(localpool::DataPool& lo
                            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::SENSOR_TMP1075_TCS_0, &tmp1075Tcs0);
+  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_TMP1075_TCS_1, &tmp1075Tcs1);
+  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_TMP1075_PLPCDU_0, &tmp1075PlPcdu0);
+  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_TMP1075_PLPCDU_1, &tmp1075PlPcdu1);
+  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_TMP1075_IF_BOARD, &tmp1075IfBrd);
 
   localDataPoolMap.emplace(thermalControllerDefinitions::SUS_0_N_LOC_XFYFZM_PT_XF,
                            new PoolEntry<float>({0.0}));
@@ -415,23 +419,53 @@ void ThermalController::copySensors() {
   }
 
   {
-    PoolReadGuard pg111(&tmp1075Set1, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
-    if (pg111.getReadResult() == returnvalue::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 pg(&tmp1075SetTcs0, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() == returnvalue::OK) {
+      sensorTemperatures.tmp1075Tcs0.value = tmp1075SetTcs0.temperatureCelcius.value;
+      sensorTemperatures.tmp1075Tcs0.setValid(tmp1075SetTcs0.temperatureCelcius.isValid());
+      if (not tmp1075SetTcs0.temperatureCelcius.isValid()) {
+        sensorTemperatures.tmp1075Tcs0.value = INVALID_TEMPERATURE;
       }
     }
   }
 
   {
-    PoolReadGuard pg112(&tmp1075Set2, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
-    if (pg112.getReadResult() == returnvalue::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;
+    PoolReadGuard pg(&tmp1075SetTcs1, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() == returnvalue::OK) {
+      sensorTemperatures.tmp1075Tcs1.value = tmp1075SetTcs1.temperatureCelcius.value;
+      sensorTemperatures.tmp1075Tcs1.setValid(tmp1075SetTcs1.temperatureCelcius.isValid());
+      if (not tmp1075SetTcs1.temperatureCelcius.isValid()) {
+        sensorTemperatures.tmp1075Tcs1.value = INVALID_TEMPERATURE;
+      }
+    }
+  }
+  {
+    PoolReadGuard pg(&tmp1075SetPlPcdu0, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() == returnvalue::OK) {
+      sensorTemperatures.tmp1075PlPcdu0.value = tmp1075SetPlPcdu0.temperatureCelcius.value;
+      sensorTemperatures.tmp1075PlPcdu0.setValid(tmp1075SetPlPcdu0.temperatureCelcius.isValid());
+      if (not tmp1075SetPlPcdu0.temperatureCelcius.isValid()) {
+        sensorTemperatures.tmp1075PlPcdu0.value = INVALID_TEMPERATURE;
+      }
+    }
+  }
+  {
+    PoolReadGuard pg(&tmp1075SetPlPcdu1, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() == returnvalue::OK) {
+      sensorTemperatures.tmp1075PlPcdu1.value = tmp1075SetPlPcdu1.temperatureCelcius.value;
+      sensorTemperatures.tmp1075PlPcdu1.setValid(tmp1075SetPlPcdu1.temperatureCelcius.isValid());
+      if (not tmp1075SetPlPcdu1.temperatureCelcius.isValid()) {
+        sensorTemperatures.tmp1075PlPcdu1.value = INVALID_TEMPERATURE;
+      }
+    }
+  }
+  {
+    PoolReadGuard pg(&tmp1075SetIfBoard, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() == returnvalue::OK) {
+      sensorTemperatures.tmp1075IfBrd.value = tmp1075SetIfBoard.temperatureCelcius.value;
+      sensorTemperatures.tmp1075IfBrd.setValid(tmp1075SetIfBoard.temperatureCelcius.isValid());
+      if (not tmp1075SetIfBoard.temperatureCelcius.isValid()) {
+        sensorTemperatures.tmp1075IfBrd.value = INVALID_TEMPERATURE;
       }
     }
   }
@@ -573,369 +607,344 @@ void ThermalController::copySus() {
 
 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 != returnvalue::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());
+  {
+    PoolReadGuard pg(&tempQ7s, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() == returnvalue::OK) {
+      deviceTemperatures.q7s = tempQ7s;
+      deviceTemperatures.q7s.setValid(tempQ7s.isValid());
+    } else {
+      deviceTemperatures.q7s.setValid(false);
+      deviceTemperatures.q7s = static_cast<float>(INVALID_TEMPERATURE);
+    }
   }
-  result = tempQ7s.commit();
-  if (result != returnvalue::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);
+    PoolReadGuard pg(&battTemp1, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() != returnvalue::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());
+    }
   }
-  lp_var_t<int16_t> battTemp1 =
-      lp_var_t<int16_t>(objects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_1);
-  result = battTemp1.read();
-  if (result != returnvalue::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());
+
+  {
+    lp_var_t<int16_t> battTemp2 =
+        lp_var_t<int16_t>(objects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_2);
+    PoolReadGuard pg(&battTemp2, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() != returnvalue::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 = battTemp1.commit();
-  if (result != returnvalue::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);
+    PoolReadGuard pg(&battTemp3, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() != returnvalue::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());
+    }
   }
-  lp_var_t<int16_t> battTemp2 =
-      lp_var_t<int16_t>(objects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_2);
-  result = battTemp2.read();
-  if (result != returnvalue::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());
+
+  {
+    lp_var_t<int16_t> battTemp4 =
+        lp_var_t<int16_t>(objects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_4);
+    PoolReadGuard pg(&battTemp4, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() != returnvalue::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 = battTemp2.commit();
-  if (result != returnvalue::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);
+    PoolReadGuard pg(&tempRw1, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() != returnvalue::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;
+    }
   }
-  lp_var_t<int16_t> battTemp3 =
-      lp_var_t<int16_t>(objects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_3);
-  result = battTemp3.read();
-  if (result != returnvalue::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());
+
+  {
+    lp_var_t<int32_t> tempRw2 = lp_var_t<int32_t>(objects::RW2, RwDefinitions::TEMPERATURE_C);
+    PoolReadGuard pg(&tempRw2, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() != returnvalue::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 = battTemp3.commit();
-  if (result != returnvalue::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);
+    PoolReadGuard pg(&tempRw3, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() != returnvalue::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;
+    }
   }
-  lp_var_t<int16_t> battTemp4 =
-      lp_var_t<int16_t>(objects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_4);
-  result = battTemp4.read();
-  if (result != returnvalue::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());
+
+  {
+    lp_var_t<int32_t> tempRw4 = lp_var_t<int32_t>(objects::RW4, RwDefinitions::TEMPERATURE_C);
+    PoolReadGuard pg(&tempRw4, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() != returnvalue::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 = battTemp4.commit();
-  if (result != returnvalue::OK) {
-    sif::warning << "ThermalController: Failed to commit" << std::endl;
+
+  {
+    lp_var_t<float> tempStartracker =
+        lp_var_t<float>(objects::STAR_TRACKER, startracker::MCU_TEMPERATURE);
+    PoolReadGuard pg(&tempStartracker, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() != returnvalue::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;
+    }
   }
-  lp_var_t<int32_t> tempRw1 = lp_var_t<int32_t>(objects::RW1, RwDefinitions::TEMPERATURE_C);
-  result = tempRw1.read();
-  if (result != returnvalue::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;
+
+  {
+    lp_var_t<float> tempSyrlinksPowerAmplifier =
+        lp_var_t<float>(objects::SYRLINKS_HK_HANDLER, syrlinks::TEMP_POWER_AMPLIFIER);
+    PoolReadGuard pg(&tempSyrlinksPowerAmplifier, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() != returnvalue::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 = tempRw1.commit();
-  if (result != returnvalue::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);
+    PoolReadGuard pg(&tempSyrlinksBasebandBoard, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() != returnvalue::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;
+    }
   }
-  lp_var_t<int32_t> tempRw2 = lp_var_t<int32_t>(objects::RW2, RwDefinitions::TEMPERATURE_C);
-  result = tempRw2.read();
-  if (result != returnvalue::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;
+
+  {
+    lp_var_t<int16_t> tempMgt = lp_var_t<int16_t>(objects::IMTQ_HANDLER, IMTQ::MCU_TEMPERATURE);
+    PoolReadGuard pg(&tempMgt, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() != returnvalue::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 = tempRw2.commit();
-  if (result != returnvalue::OK) {
-    sif::warning << "ThermalController: Failed to commit" << std::endl;
+
+  {
+    lp_vec_t<float, 3> tempAcu =
+        lp_vec_t<float, 3>(objects::ACU_HANDLER, ACU::pool::ACU_TEMPERATURES);
+    PoolReadGuard pg(&tempAcu, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() != returnvalue::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;
+    }
   }
-  lp_var_t<int32_t> tempRw3 = lp_var_t<int32_t>(objects::RW3, RwDefinitions::TEMPERATURE_C);
-  result = tempRw3.read();
-  if (result != returnvalue::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;
+
+  {
+    lp_var_t<float> tempPdu1 = lp_var_t<float>(objects::PDU1_HANDLER, PDU::pool::PDU_TEMPERATURE);
+    PoolReadGuard pg(&tempPdu1, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() != returnvalue::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 = tempRw3.commit();
-  if (result != returnvalue::OK) {
-    sif::warning << "ThermalController: Failed to commit" << std::endl;
+
+  {
+    lp_var_t<float> tempPdu2 = lp_var_t<float>(objects::PDU2_HANDLER, PDU::pool::PDU_TEMPERATURE);
+    PoolReadGuard pg(&tempPdu2, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() != returnvalue::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(tempPdu2.isValid());
+      deviceTemperatures.pdu2 = tempPdu2;
+    }
   }
-  lp_var_t<int32_t> tempRw4 = lp_var_t<int32_t>(objects::RW4, RwDefinitions::TEMPERATURE_C);
-  result = tempRw4.read();
-  if (result != returnvalue::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;
+
+  {
+    lp_var_t<float> temp1P60dock =
+        lp_var_t<float>(objects::P60DOCK_HANDLER, P60Dock::pool::P60DOCK_TEMPERATURE_1);
+    PoolReadGuard pg(&temp1P60dock, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() != returnvalue::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 = tempRw4.commit();
-  if (result != returnvalue::OK) {
-    sif::warning << "ThermalController: Failed to commit" << std::endl;
+
+  {
+    lp_var_t<float> temp2P60dock =
+        lp_var_t<float>(objects::P60DOCK_HANDLER, P60Dock::pool::P60DOCK_TEMPERATURE_2);
+    PoolReadGuard pg(&temp2P60dock, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() != returnvalue::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;
+    }
   }
-  lp_var_t<float> tempStartracker =
-      lp_var_t<float>(objects::STAR_TRACKER, startracker::MCU_TEMPERATURE);
-  result = tempStartracker.read();
-  if (result != returnvalue::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;
+
+  {
+    lp_var_t<float> tempGyro0 =
+        lp_var_t<float>(objects::GYRO_0_ADIS_HANDLER, ADIS1650X::TEMPERATURE);
+    PoolReadGuard pg(&tempGyro0, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() != returnvalue::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 = tempStartracker.commit();
-  if (result != returnvalue::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);
+    PoolReadGuard pg(&tempGyro1, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() != returnvalue::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;
+    }
   }
-  lp_var_t<float> tempSyrlinksPowerAmplifier =
-      lp_var_t<float>(objects::SYRLINKS_HK_HANDLER, syrlinks::TEMP_POWER_AMPLIFIER);
-  result = tempSyrlinksPowerAmplifier.read();
-  if (result != returnvalue::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;
+
+  {
+    lp_var_t<float> tempGyro2 =
+        lp_var_t<float>(objects::GYRO_2_ADIS_HANDLER, ADIS1650X::TEMPERATURE);
+    PoolReadGuard pg(&tempGyro2, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() != returnvalue::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 = tempSyrlinksPowerAmplifier.commit();
-  if (result != returnvalue::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);
+    PoolReadGuard pg(&tempGyro3, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() != returnvalue::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;
+    }
   }
-  lp_var_t<float> tempSyrlinksBasebandBoard =
-      lp_var_t<float>(objects::SYRLINKS_HK_HANDLER, syrlinks::TEMP_BASEBAND_BOARD);
-  result = tempSyrlinksBasebandBoard.read();
-  if (result != returnvalue::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;
+
+  {
+    lp_var_t<float> tempMgm0 =
+        lp_var_t<float>(objects::MGM_0_LIS3_HANDLER, MGMLIS3MDL::TEMPERATURE_CELCIUS);
+    PoolReadGuard pg(&tempMgm0, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() != returnvalue::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 = tempSyrlinksBasebandBoard.commit();
-  if (result != returnvalue::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);
+    PoolReadGuard pg(&tempMgm2, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() != returnvalue::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;
+    }
   }
-  lp_var_t<int16_t> tempMgt = lp_var_t<int16_t>(objects::IMTQ_HANDLER, IMTQ::MCU_TEMPERATURE);
-  result = tempMgt.read();
-  if (result != returnvalue::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 != returnvalue::OK) {
-    sif::warning << "ThermalController: Failed to commit" << std::endl;
-  }
-  lp_vec_t<float, 3> tempAcu =
-      lp_vec_t<float, 3>(objects::ACU_HANDLER, ACU::pool::ACU_TEMPERATURES);
-  result = tempAcu.read();
-  if (result != returnvalue::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 != returnvalue::OK) {
-    sif::warning << "ThermalController: Failed to commit" << std::endl;
-  }
-  lp_var_t<float> tempPdu1 = lp_var_t<float>(objects::PDU1_HANDLER, PDU::pool::PDU_TEMPERATURE);
-  result = tempPdu1.read();
-  if (result != returnvalue::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 != returnvalue::OK) {
-    sif::warning << "ThermalController: Failed to commit" << std::endl;
-  }
-  lp_var_t<float> tempPdu2 = lp_var_t<float>(objects::PDU2_HANDLER, PDU::pool::PDU_TEMPERATURE);
-  result = tempPdu2.read();
-  if (result != returnvalue::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 != returnvalue::OK) {
-    sif::warning << "ThermalController: Failed to commit" << std::endl;
-  }
-  lp_var_t<float> temp1P60dock =
-      lp_var_t<float>(objects::P60DOCK_HANDLER, P60Dock::pool::P60DOCK_TEMPERATURE_1);
-  result = temp1P60dock.read();
-  if (result != returnvalue::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 != returnvalue::OK) {
-    sif::warning << "ThermalController: Failed to commit" << std::endl;
-  }
-  lp_var_t<float> temp2P60dock =
-      lp_var_t<float>(objects::P60DOCK_HANDLER, P60Dock::pool::P60DOCK_TEMPERATURE_2);
-  result = temp2P60dock.read();
-  if (result != returnvalue::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 != returnvalue::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 != returnvalue::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 != returnvalue::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 != returnvalue::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 != returnvalue::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 != returnvalue::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 != returnvalue::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 != returnvalue::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 != returnvalue::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 != returnvalue::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 != returnvalue::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 != returnvalue::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 != returnvalue::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 != returnvalue::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 != returnvalue::OK) {
-    sif::warning << "ThermalController: Failed to commit" << std::endl;
+
+  {
+    lp_var_t<float> tempAdcPayloadPcdu = lp_var_t<float>(objects::PLPCDU_HANDLER, plpcdu::TEMP);
+    PoolReadGuard pg(&tempAdcPayloadPcdu, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
+    if (pg.getReadResult() != returnvalue::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;
+    }
   }
 }

mission/controller/ThermalController.h

@@ -12,7 +12,7 @@ class ThermalController : public ExtendedControllerBase {
  public:
   static const uint16_t INVALID_TEMPERATURE = 999;
 
-  ThermalController(object_id_t objectId, object_id_t parentId);
+  ThermalController(object_id_t objectId);
 
   ReturnValue_t initialize() override;
 
@@ -55,8 +55,11 @@ class ThermalController : public ExtendedControllerBase {
   MAX31865::Max31865Set max31865Set13;
   MAX31865::Max31865Set max31865Set14;
   MAX31865::Max31865Set max31865Set15;
-  TMP1075::Tmp1075Dataset tmp1075Set1;
-  TMP1075::Tmp1075Dataset tmp1075Set2;
+  TMP1075::Tmp1075Dataset tmp1075SetTcs0;
+  TMP1075::Tmp1075Dataset tmp1075SetTcs1;
+  TMP1075::Tmp1075Dataset tmp1075SetPlPcdu0;
+  TMP1075::Tmp1075Dataset tmp1075SetPlPcdu1;
+  TMP1075::Tmp1075Dataset tmp1075SetIfBoard;
 
   // SUS
   SUS::SusDataset susSet0;
@@ -75,6 +78,12 @@ class ThermalController : public ExtendedControllerBase {
   // Initial delay to make sure all pool variables have been initialized their owners
   Countdown initialCountdown = Countdown(DELAY);
 
+  PoolEntry<float> tmp1075Tcs0 = PoolEntry<float>(10.0);
+  PoolEntry<float> tmp1075Tcs1 = PoolEntry<float>(10.0);
+  PoolEntry<float> tmp1075PlPcdu0 = PoolEntry<float>(10.0);
+  PoolEntry<float> tmp1075PlPcdu1 = PoolEntry<float>(10.0);
+  PoolEntry<float> tmp1075IfBrd = PoolEntry<float>(10.0);
+
   static constexpr dur_millis_t MUTEX_TIMEOUT = 50;
   void copySensors();
   void copySus();

mission/controller/controllerdefinitions/AcsControllerDefinitions.h

@@ -0,0 +1,14 @@
+#ifndef MISSION_CONTROLLER_CONTROLLERDEFINITIONS_ACSCONTROLLERDEFINITIONS_H_
+#define MISSION_CONTROLLER_CONTROLLERDEFINITIONS_ACSCONTROLLERDEFINITIONS_H_
+
+#include <fsfw/modes/HasModesIF.h>
+
+namespace acs {
+
+enum CtrlModes { OFF = HasModesIF::MODE_OFF, SAFE = 1, DETUMBLE = 2, IDLE = 3, TARGET_PT = 4 };
+
+static constexpr Submode_t IDLE_CHARGE = 1;
+
+}  // namespace acs
+
+#endif /* MISSION_CONTROLLER_CONTROLLERDEFINITIONS_ACSCONTROLLERDEFINITIONS_H_ */

mission/controller/controllerdefinitions/ThermalControllerDefinitions.h

@@ -30,8 +30,11 @@ enum PoolIds : lp_id_t {
   SENSOR_PLPCDU_HEATSPREADER,
   SENSOR_TCS_BOARD,
   SENSOR_MAGNETTORQUER,
-  SENSOR_TMP1075_1,
-  SENSOR_TMP1075_2,
+  SENSOR_TMP1075_TCS_0,
+  SENSOR_TMP1075_TCS_1,
+  SENSOR_TMP1075_PLPCDU_0,
+  SENSOR_TMP1075_PLPCDU_1,
+  SENSOR_TMP1075_IF_BOARD,
 
   SUS_0_N_LOC_XFYFZM_PT_XF,
   SUS_6_R_LOC_XFYBZM_PT_XF,
@@ -75,7 +78,7 @@ enum PoolIds : lp_id_t {
   TEMP_ADC_PAYLOAD_PCDU
 };
 
-static const uint8_t ENTRIES_SENSOR_TEMPERATURE_SET = 18;
+static const uint8_t ENTRIES_SENSOR_TEMPERATURE_SET = 25;
 static const uint8_t ENTRIES_DEVICE_TEMPERATURE_SET = 25;
 static const uint8_t ENTRIES_SUS_TEMPERATURE_SET = 12;
 
@@ -111,8 +114,14 @@ class SensorTemperatures : public StaticLocalDataSet<ENTRIES_SENSOR_TEMPERATURE_
   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);
+  lp_var_t<float> tmp1075Tcs0 = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_TMP1075_TCS_0, this);
+  lp_var_t<float> tmp1075Tcs1 = lp_var_t<float>(sid.objectId, PoolIds::SENSOR_TMP1075_TCS_1, this);
+  lp_var_t<float> tmp1075PlPcdu0 =
+      lp_var_t<float>(sid.objectId, PoolIds::SENSOR_TMP1075_PLPCDU_0, this);
+  lp_var_t<float> tmp1075PlPcdu1 =
+      lp_var_t<float>(sid.objectId, PoolIds::SENSOR_TMP1075_PLPCDU_1, this);
+  lp_var_t<float> tmp1075IfBrd =
+      lp_var_t<float>(sid.objectId, PoolIds::SENSOR_TMP1075_IF_BOARD, this);
 };
 
 /**

mission/core/GenericFactory.cpp

@@ -24,7 +24,7 @@
 #include <fsfw_hal/host/HostFilesystem.h>
 #include <mission/tmtc/CfdpTmFunnel.h>
 #include <mission/tmtc/PusTmFunnel.h>
-#include <mission/tmtc/TmFunnel.h>
+#include <mission/tmtc/TmFunnelHandler.h>
 
 #include "OBSWConfig.h"
 #include "eive/definitions.h"
@@ -66,7 +66,8 @@ EiveFaultHandler EIVE_FAULT_HANDLER;
 
 }  // namespace cfdp
 
-void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_) {
+void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_, PusTmFunnel** pusFunnel,
+                                          CfdpTmFunnel** cfdpFunnel) {
   // Framework objects
   new EventManager(objects::EVENT_MANAGER);
   auto healthTable = new HealthTable(objects::HEALTH_TABLE);
@@ -79,14 +80,14 @@ void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_) {
   StorageManagerIF* tcStore;
   StorageManagerIF* tmStore;
   {
-    PoolManager::LocalPoolConfig poolCfg = {{200, 16},  {200, 32},   {150, 64},
-                                            {100, 128}, {100, 1024}, {100, 2048}};
+    PoolManager::LocalPoolConfig poolCfg = {{250, 16},  {250, 32},   {250, 64},
+                                            {150, 128}, {120, 1024}, {120, 2048}};
     tcStore = new PoolManager(objects::TC_STORE, poolCfg);
   }
 
   {
-    PoolManager::LocalPoolConfig poolCfg = {{300, 16},  {300, 32},   {100, 64},
-                                            {100, 128}, {100, 1024}, {100, 2048}};
+    PoolManager::LocalPoolConfig poolCfg = {{300, 16},  {350, 32},   {350, 64},
+                                            {200, 128}, {150, 1024}, {150, 2048}};
     tmStore = new PoolManager(objects::TM_STORE, poolCfg);
   }
 
@@ -98,12 +99,12 @@ void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_) {
 
 #if OBSW_ADD_TCPIP_BRIDGE == 1
 #if OBSW_USE_TMTC_TCP_BRIDGE == 0
-  auto tmtcBridge = new UdpTmTcBridge(objects::TMTC_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR);
+  auto tcpIpTmtcBridge = new UdpTmTcBridge(objects::TMTC_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR);
   new UdpTcPollingTask(objects::TMTC_POLLING_TASK, objects::TMTC_BRIDGE);
   sif::info << "Created UDP server for TMTC commanding with listener port "
             << udpBridge->getUdpPort() << std::endl;
 #else
-  auto tmtcBridge = new TcpTmTcBridge(objects::TMTC_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR);
+  auto tcpIpTmtcBridge = new TcpTmTcBridge(objects::TMTC_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR);
   auto tcpServer = new TcpTmTcServer(objects::TMTC_POLLING_TASK, objects::TMTC_BRIDGE);
   // TCP is stream based. Use packet ID as start marker when parsing for space packets
   tcpServer->setSpacePacketParsingOptions({common::PUS_PACKET_ID, common::CFDP_PACKET_ID});
@@ -113,23 +114,21 @@ void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_) {
   tcpServer->enableWiretapping(true);
 #endif /* OBSW_TCP_SERVER_WIRETAPPING == 1 */
 #endif /* OBSW_USE_TMTC_TCP_BRIDGE == 0 */
-  tmtcBridge->setMaxNumberOfPacketsStored(300);
+  tcpIpTmtcBridge->setMaxNumberOfPacketsStored(150);
 #endif /* OBSW_ADD_TCPIP_BRIDGE == 1 */
 
   auto* ccsdsDistrib =
       new CcsdsDistributor(config::EIVE_PUS_APID, objects::CCSDS_PACKET_DISTRIBUTOR);
   new PusDistributor(config::EIVE_PUS_APID, objects::PUS_PACKET_DISTRIBUTOR, ccsdsDistrib);
 
-  uint8_t vc = 0;
-#if OBSW_TM_TO_PTME == 1
-  vc = config::LIVE_TM;
+  *cfdpFunnel = new CfdpTmFunnel(objects::CFDP_TM_FUNNEL, config::EIVE_CFDP_APID, *tmStore, 50);
+  *pusFunnel = new PusTmFunnel(objects::PUS_TM_FUNNEL, *timeStamper, *tmStore, 80);
+#if OBSW_ADD_TCPIP_BRIDGE == 1
+  (*cfdpFunnel)->addDestination(*tcpIpTmtcBridge, 0);
+  (*pusFunnel)->addDestination(*tcpIpTmtcBridge, 0);
 #endif
-  auto* cfdpFunnel =
-      new CfdpTmFunnel(objects::CFDP_TM_FUNNEL, config::EIVE_CFDP_APID, *tmtcBridge, *tmStore, vc);
-  auto* pusFunnel =
-      new PusTmFunnel(objects::PUS_TM_FUNNEL, *tmtcBridge, *timeStamper, *tmStore, vc);
   // Every TM packet goes through this funnel
-  new TmFunnel(objects::TM_FUNNEL, *pusFunnel, *cfdpFunnel);
+  new TmFunnelHandler(objects::TM_FUNNEL, **pusFunnel, **cfdpFunnel);
 
   // PUS service stack
   new Service1TelecommandVerification(objects::PUS_SERVICE_1_VERIFICATION, config::EIVE_PUS_APID,
@@ -165,7 +164,7 @@ void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_) {
   new CfdpDistributor(distribCfg);
 
   auto* msgQueue = QueueFactory::instance()->createMessageQueue(32);
-  FsfwHandlerParams params(objects::CFDP_HANDLER, HOST_FS, *cfdpFunnel, *tcStore, *tmStore,
+  FsfwHandlerParams params(objects::CFDP_HANDLER, HOST_FS, **cfdpFunnel, *tcStore, *tmStore,
                            *msgQueue);
   cfdp::IndicationCfg indicationCfg;
   UnsignedByteField<uint16_t> apid(config::EIVE_LOCAL_CFDP_ENTITY_ID);

mission/core/GenericFactory.h

@@ -2,10 +2,13 @@
 #define MISSION_CORE_GENERICFACTORY_H_
 
 class HealthTableIF;
+class PusTmFunnel;
+class CfdpTmFunnel;
 
 namespace ObjectFactory {
 
-void produceGenericObjects(HealthTableIF** healthTable = nullptr);
+void produceGenericObjects(HealthTableIF** healthTable, PusTmFunnel** pusFunnel,
+                           CfdpTmFunnel** cfdpFunnel);
 
 }
 

mission/devices/BpxBatteryHandler.cpp

@@ -216,7 +216,7 @@ ReturnValue_t BpxBatteryHandler::interpretDeviceReply(DeviceCommandId_t id, cons
       if (packet[2] != sentPingByte) {
         return DeviceHandlerIF::INVALID_DATA;
       }
-      if (mode == _MODE_START_UP) {
+      if (getMode() == _MODE_START_UP) {
         commandExecuted = true;
       }
       break;

mission/devices/GomspaceDeviceHandler.cpp

@@ -570,7 +570,7 @@ ReturnValue_t GomspaceDeviceHandler::generateRequestFullCfgTableCmd(DeviceType d
 
 uint32_t GomspaceDeviceHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 0; }
 
-void GomspaceDeviceHandler::setModeNormal() { mode = MODE_NORMAL; }
+void GomspaceDeviceHandler::setModeNormal() { setMode(_MODE_TO_NORMAL); }
 
 ReturnValue_t GomspaceDeviceHandler::printStatus(DeviceCommandId_t cmd) {
   sif::info << "No printHkTable implementation given.." << std::endl;

mission/devices/Max31865EiveHandler.cpp

@@ -30,16 +30,13 @@ void Max31865EiveHandler::doStartUp() {
 }
 
 void Max31865EiveHandler::doShutDown() {
-  updatePeriodicReply(false, EiveMax31855::RtdCommands::EXCHANGE_SET_ID);
   if (state == InternalState::NONE or state == InternalState::ACTIVE or
       state == InternalState::ON) {
     state = InternalState::INACTIVE;
     transitionOk = false;
-  } else {
-    transitionOk = true;
   }
   if (state == InternalState::INACTIVE and transitionOk) {
-    setMode(_MODE_POWER_DOWN);
+    setMode(MODE_OFF);
   }
 }
 
@@ -104,7 +101,7 @@ void Max31865EiveHandler::simpleCommand(EiveMax31855::RtdCommands cmd) {
   rawPacketLen = 1;
 }
 void Max31865EiveHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
-  if (mode == _MODE_TO_NORMAL) {
+  if (getMode() == _MODE_TO_NORMAL) {
     if (state != InternalState::ACTIVE) {
       state = InternalState::ACTIVE;
       transitionOk = false;
@@ -125,7 +122,7 @@ void Max31865EiveHandler::fillCommandAndReplyMap() {
 
 ReturnValue_t Max31865EiveHandler::scanForReply(const uint8_t* start, size_t remainingSize,
                                                 DeviceCommandId_t* foundId, size_t* foundLen) {
-  if (mode == _MODE_POWER_ON or mode == _MODE_WAIT_ON) {
+  if (getMode() == _MODE_POWER_ON or getMode() == _MODE_WAIT_ON) {
     return IGNORE_FULL_PACKET;
   }
   if (remainingSize != structLen) {
@@ -145,12 +142,17 @@ ReturnValue_t Max31865EiveHandler::interpretDeviceReply(DeviceCommandId_t id,
   if (result != returnvalue::OK) {
     return result;
   }
-  if (mode == _MODE_TO_NORMAL and exchangeStruct.active and state == InternalState::ACTIVE) {
+  if (getMode() == _MODE_TO_NORMAL and exchangeStruct.active and state == InternalState::ACTIVE) {
     transitionOk = true;
   }
-  if (mode == _MODE_START_UP and exchangeStruct.configured and state == InternalState::ON) {
+  if (getMode() == _MODE_START_UP and exchangeStruct.configured and state == InternalState::ON) {
     transitionOk = true;
   }
+  if (getMode() == _MODE_SHUT_DOWN and not exchangeStruct.active) {
+    transitionOk = true;
+    return returnvalue::OK;
+  }
+
   // Calculate resistance
   float rtdValue = exchangeStruct.adcCode * EiveMax31855::RTD_RREF_PT1000 / INT16_MAX;
   // calculate approximation

mission/devices/Max31865PT1000Handler.cpp

@@ -302,7 +302,7 @@ ReturnValue_t Max31865PT1000Handler::scanForReply(const uint8_t *start, size_t r
     } else if (internalState == InternalState::CLEAR_FAULT_BYTE) {
       *foundId = MAX31865::CLEAR_FAULT_BYTE;
       *foundLen = 2;
-      if (mode == _MODE_START_UP) {
+      if (getMode() == _MODE_START_UP) {
         commandExecuted = true;
       } else {
         internalState = InternalState::RUNNING;
@@ -524,7 +524,7 @@ void Max31865PT1000Handler::setInstantNormal(bool instantNormal) {
 }
 
 void Max31865PT1000Handler::modeChanged() {
-  if (mode == MODE_OFF) {
+  if (getMode() == MODE_OFF) {
     lastFaultStatus = 0;
     currentFaultStatus = 0;
     sameFaultStatusCounter = 0;

mission/devices/PayloadPcduHandler.cpp

@@ -66,7 +66,7 @@ void PayloadPcduHandler::doShutDown() {
 }
 
 void PayloadPcduHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
-  if (mode == _MODE_TO_NORMAL) {
+  if (getMode() == _MODE_TO_NORMAL) {
     stateMachineToNormal(modeFrom, subModeFrom);
     return;
   }
@@ -76,7 +76,7 @@ void PayloadPcduHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
 ReturnValue_t PayloadPcduHandler::stateMachineToNormal(Mode_t modeFrom, Submode_t subModeFrom) {
   using namespace plpcdu;
   bool doFinish = true;
-  if (((submode >> SOLID_STATE_RELAYS_ADC_ON) & 0b1) == 1) {
+  if (((getSubmode() >> SOLID_STATE_RELAYS_ADC_ON) & 0b1) == 1) {
     if (state == States::PL_PCDU_OFF) {
       sif::error << "PayloadPcduHandler::stateMachineToNormal: Unexpected state PL_PCDU_OFF"
                  << "detected" << std::endl;
@@ -129,7 +129,7 @@ ReturnValue_t PayloadPcduHandler::stateMachineToNormal(Mode_t modeFrom, Submode_
 
   auto switchHandler = [&](NormalSubmodeBits bit, gpioId_t id, std::string info) {
     if (((diffMask >> bit) & 1) == 1) {
-      if (((submode >> bit) & 1) == 1) {
+      if (((getSubmode() >> bit) & 1) == 1) {
 #if OBSW_VERBOSE_LEVEL >= 1
         sif::info << "Enabling PL PCDU " << info << " module" << std::endl;
 #endif
@@ -150,7 +150,7 @@ ReturnValue_t PayloadPcduHandler::stateMachineToNormal(Mode_t modeFrom, Submode_
   switchHandler(MPA_ON, gpioIds::PLPCDU_ENB_MPA, "MPA");
   switchHandler(HPA_ON, gpioIds::PLPCDU_ENB_HPA, "HPA");
   if (doFinish) {
-    setMode(MODE_NORMAL, submode);
+    setMode(MODE_NORMAL);
   }
   return returnvalue::OK;
 }
@@ -177,7 +177,7 @@ ReturnValue_t PayloadPcduHandler::buildTransitionDeviceCommand(DeviceCommandId_t
     *id = plpcdu::SETUP_CMD;
     return buildCommandFromCommand(*id, nullptr, 0);
   }
-  if (mode == _MODE_TO_NORMAL) {
+  if (getMode() == _MODE_TO_NORMAL) {
     return buildNormalDeviceCommand(id);
   }
   return NOTHING_TO_SEND;
@@ -248,7 +248,7 @@ ReturnValue_t PayloadPcduHandler::interpretDeviceReply(DeviceCommandId_t id,
   using namespace plpcdu;
   switch (id) {
     case (SETUP_CMD): {
-      if (mode == _MODE_TO_NORMAL) {
+      if (getMode() == _MODE_TO_NORMAL) {
         adcCmdExecuted = true;
       }
       break;
@@ -540,33 +540,34 @@ bool PayloadPcduHandler::checkCurrent(float val, float upperBound, Event event)
 ReturnValue_t PayloadPcduHandler::isModeCombinationValid(Mode_t mode, Submode_t submode) {
   using namespace plpcdu;
   if (mode == MODE_NORMAL) {
-    diffMask = submode ^ this->submode;
+    uint8_t dhbSubmode = getSubmode();
+    diffMask = submode ^ dhbSubmode;
     // Also deals with the case where the mode is MODE_ON, submode should be 0 here
     if ((((submode >> SOLID_STATE_RELAYS_ADC_ON) & 0b1) == SOLID_STATE_RELAYS_ADC_ON) and
-        (this->mode == MODE_NORMAL and this->submode != ALL_OFF_SUBMODE)) {
+        (getMode() == MODE_NORMAL and dhbSubmode != ALL_OFF_SUBMODE)) {
       return TRANS_NOT_ALLOWED;
     }
     if (((((submode >> DRO_ON) & 1) == 1) and
-         ((this->submode & 0b1) != (1 << SOLID_STATE_RELAYS_ADC_ON)))) {
+         ((dhbSubmode & 0b1) != (1 << SOLID_STATE_RELAYS_ADC_ON)))) {
       return TRANS_NOT_ALLOWED;
     }
     if ((((submode >> X8_ON) & 1) == 1) and
-        ((this->submode & 0b11) != ((1 << SOLID_STATE_RELAYS_ADC_ON) | (1 << DRO_ON)))) {
+        ((dhbSubmode & 0b11) != ((1 << SOLID_STATE_RELAYS_ADC_ON) | (1 << DRO_ON)))) {
       return TRANS_NOT_ALLOWED;
     }
     if (((((submode >> TX_ON) & 1) == 1) and
-         ((this->submode & 0b111) !=
+         ((dhbSubmode & 0b111) !=
           ((1 << X8_ON) | (1 << DRO_ON) | (1 << SOLID_STATE_RELAYS_ADC_ON))))) {
       return TRANS_NOT_ALLOWED;
     }
     if ((((submode >> MPA_ON) & 1) == 1 and
-         ((this->submode & 0b1111) !=
+         ((dhbSubmode & 0b1111) !=
           ((1 << TX_ON) | (1 << X8_ON) | (1 << DRO_ON) | (1 << SOLID_STATE_RELAYS_ADC_ON))))) {
       return TRANS_NOT_ALLOWED;
     }
     if ((((submode >> HPA_ON) & 1) == 1 and
-         ((this->submode & 0b11111) != ((1 << MPA_ON) | (1 << TX_ON) | (1 << X8_ON) |
-                                        (1 << DRO_ON) | (1 << SOLID_STATE_RELAYS_ADC_ON))))) {
+         ((dhbSubmode & 0b11111) != ((1 << MPA_ON) | (1 << TX_ON) | (1 << X8_ON) | (1 << DRO_ON) |
+                                     (1 << SOLID_STATE_RELAYS_ADC_ON))))) {
       return TRANS_NOT_ALLOWED;
     }
     return returnvalue::OK;

mission/devices/PayloadPcduHandler.h

@@ -10,8 +10,8 @@
 #include "fsfw_hal/common/gpio/GpioIF.h"
 #include "mission/devices/devicedefinitions/payloadPcduDefinitions.h"
 #include "mission/memory/SdCardMountedIF.h"
-#include "mission/system/DualLanePowerStateMachine.h"
-#include "mission/system/definitions.h"
+#include "mission/system/objects/DualLanePowerStateMachine.h"
+#include "mission/system/objects/definitions.h"
 
 #ifdef FSFW_OSAL_LINUX
 class SpiComIF;

mission/devices/ScexDeviceHandler.cpp

@@ -28,6 +28,7 @@ void ScexDeviceHandler::doStartUp() { setMode(MODE_ON); }
 void ScexDeviceHandler::doShutDown() {
   reader.reset();
   commandActive = false;
+  multiFileFinishOutstanding = false;
   setMode(_MODE_POWER_DOWN);
 }
 
@@ -96,6 +97,7 @@ ReturnValue_t ScexDeviceHandler::buildCommandFromCommand(DeviceCommandId_t devic
                   << remainingMillis << std::endl;
       }
 
+      multiFileFinishOutstanding = true;
       prepareScexCmd(cmdTyped, {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
                      {commandData + 1, commandDataLen - 1}, tempCheck);
       updatePeriodicReply(true, deviceCommand);
@@ -105,6 +107,7 @@ ReturnValue_t ScexDeviceHandler::buildCommandFromCommand(DeviceCommandId_t devic
       finishCountdown.setTimeout(LONG_CD);
       // countdown starts
       finishCountdown.resetTimer();
+      multiFileFinishOutstanding = true;
       prepareScexCmd(cmdTyped, {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
                      {commandData + 1, commandDataLen - 1}, tempCheck);
       updatePeriodicReply(true, deviceCommand);
@@ -114,6 +117,7 @@ ReturnValue_t ScexDeviceHandler::buildCommandFromCommand(DeviceCommandId_t devic
       finishCountdown.setTimeout(LONG_CD);
       // countdown starts
       finishCountdown.resetTimer();
+      multiFileFinishOutstanding = true;
       prepareScexCmd(cmdTyped, {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
                      {commandData + 1, commandDataLen - 1}, tempCheck);
       updatePeriodicReply(true, deviceCommand);
@@ -173,17 +177,14 @@ ReturnValue_t ScexDeviceHandler::handleValidReply(size_t remSize, DeviceCommandI
         sif::info << "ScexDeviceHandler::handleValidReply: RemMillis: " << remainingMillis
                   << std::endl;
       }
-      finishAction(true, helper.getCmd(), OK);
       result = APERIODIC_REPLY;
       break;
     }
     case (ONE_CELL): {
-      finishAction(true, helper.getCmd(), OK);
       result = APERIODIC_REPLY;
       break;
     }
     case (ALL_CELLS_CMD): {
-      finishAction(true, helper.getCmd(), OK);
       result = APERIODIC_REPLY;
       break;
     }
@@ -191,6 +192,11 @@ ReturnValue_t ScexDeviceHandler::handleValidReply(size_t remSize, DeviceCommandI
       break;
     }
   }
+  if (result == APERIODIC_REPLY and multiFileFinishOutstanding) {
+    finishAction(true, helper.getCmd(), OK);
+    multiFileFinishOutstanding = false;
+  }
+
   *foundId = helper.getCmd();
   *foundLen = remSize;
   return result;
@@ -250,6 +256,7 @@ ReturnValue_t ScexDeviceHandler::interpretDeviceReply(DeviceCommandId_t id, cons
     }
     return OK;
   };
+  id = helper.getCmd();
   switch (id) {
     case (PING): {
       status = oneFileHandler("ping_");

mission/devices/ScexDeviceHandler.h

@@ -28,6 +28,7 @@ class ScexDeviceHandler : public DeviceHandlerBase {
   std::string fileName = "";
   bool fileNameSet = false;
   bool commandActive = false;
+  bool multiFileFinishOutstanding = false;
   bool debugMode = false;
 
   scex::Cmds currCmd = scex::Cmds::PING;

mission/devices/SusHandler.cpp

@@ -150,7 +150,7 @@ ReturnValue_t SusHandler::scanForReply(const uint8_t *start, size_t remainingSiz
 ReturnValue_t SusHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
   switch (id) {
     case SUS::WRITE_SETUP: {
-      if (mode == _MODE_START_UP) {
+      if (getMode() == _MODE_START_UP) {
         commandExecuted = true;
       }
       return returnvalue::OK;

mission/devices/SyrlinksHkHandler.cpp

@@ -630,7 +630,7 @@ ReturnValue_t SyrlinksHkHandler::initializeLocalDataPool(localpool::DataPool& lo
   return returnvalue::OK;
 }
 
-void SyrlinksHkHandler::setModeNormal() { mode = MODE_NORMAL; }
+void SyrlinksHkHandler::setModeNormal() { setMode(MODE_NORMAL); }
 
 float SyrlinksHkHandler::calcTempVal(uint16_t raw) { return 0.126984 * raw - 67.87; }
 

mission/devices/Tmp1075Handler.cpp

@@ -12,7 +12,7 @@ Tmp1075Handler::Tmp1075Handler(object_id_t objectId, object_id_t comIF, CookieIF
 Tmp1075Handler::~Tmp1075Handler() {}
 
 void Tmp1075Handler::doStartUp() {
-  if (mode == _MODE_START_UP) {
+  if (getMode() == _MODE_START_UP) {
     setMode(MODE_ON);
   }
 }
@@ -86,7 +86,7 @@ ReturnValue_t Tmp1075Handler::interpretDeviceReply(DeviceCommandId_t id, const u
       int16_t tempValueRaw = 0;
       tempValueRaw = packet[0] << 4 | packet[1] >> 4;
       float tempValue = ((static_cast<float>(tempValueRaw)) * 0.0625);
-#if OBSW_VERBOSE_LEVEL >= 1
+#if OBSW_DEBUG_TMP1075 == 1
       sif::info << "Tmp1075 with object id: 0x" << std::hex << getObjectId()
                 << ": Temperature: " << tempValue << " °C" << std::endl;
 #endif
@@ -127,3 +127,5 @@ ReturnValue_t Tmp1075Handler::initializeLocalDataPool(localpool::DataPool &local
       subdp::RegularHkPeriodicParams(dataset.getSid(), false, 30.0));
   return returnvalue::OK;
 }
+
+void Tmp1075Handler::setModeNormal() { setMode(_MODE_TO_NORMAL); }

mission/devices/Tmp1075Handler.h

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

mission/devices/devicedefinitions/payloadPcduDefinitions.h

@@ -101,6 +101,9 @@ enum NormalSubmodeBits {
 };
 
 static constexpr Submode_t ALL_OFF_SUBMODE = 0;
+static constexpr Submode_t ALL_ON_SUBMODE = (1 << HPA_ON) | (1 << MPA_ON) | (1 << TX_ON) |
+                                            (1 << X8_ON) | (1 << DRO_ON) |
+                                            (1 << SOLID_STATE_RELAYS_ADC_ON);
 
 // 12 ADC values * 2 + trailing zero
 static constexpr size_t ADC_REPLY_SIZE = 25;

mission/system/AcsSubsystem.cpp

@@ -1,5 +0,0 @@
-#include "AcsSubsystem.h"
-
-AcsSubsystem::AcsSubsystem(object_id_t setObjectId, object_id_t parent,
-                           uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables)
-    : Subsystem(setObjectId, parent, maxNumberOfSequences, maxNumberOfTables) {}

mission/system/CMakeLists.txt

@@ -1,15 +1,3 @@
-target_sources(
-  ${LIB_EIVE_MISSION}
-  PRIVATE EiveSystem.cpp
-          AcsSubsystem.cpp
-          ComSubsystem.cpp
-          PayloadSubsystem.cpp
-          AcsBoardAssembly.cpp
-          RwAssembly.cpp
-          SusAssembly.cpp
-          DualLanePowerStateMachine.cpp
-          PowerStateMachineBase.cpp
-          DualLaneAssemblyBase.cpp
-          TcsBoardAssembly.cpp)
-
+add_subdirectory(objects)
+add_subdirectory(tree)
 add_subdirectory(fdir)

mission/system/ComSubsystem.cpp

@@ -1,5 +0,0 @@
-#include "ComSubsystem.h"
-
-ComSubsystem::ComSubsystem(object_id_t setObjectId, object_id_t parent,
-                           uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables)
-    : Subsystem(setObjectId, parent, maxNumberOfSequences, maxNumberOfTables) {}

mission/system/EiveSystem.cpp

@@ -1,5 +0,0 @@
-#include "EiveSystem.h"
-
-EiveSystem::EiveSystem(object_id_t setObjectId, object_id_t parent, uint32_t maxNumberOfSequences,
-                       uint32_t maxNumberOfTables)
-    : Subsystem(setObjectId, parent, maxNumberOfSequences, maxNumberOfTables) {}

mission/system/PayloadSubsystem.cpp

@@ -1,5 +0,0 @@
-#include "PayloadSubsystem.h"
-
-PayloadSubsystem::PayloadSubsystem(object_id_t setObjectId, object_id_t parent,
-                                   uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables)
-    : Subsystem(setObjectId, parent, maxNumberOfSequences, maxNumberOfTables) {}

mission/system/objects/AcsBoardAssembly.cpp

@@ -6,11 +6,10 @@
 
 #include "OBSWConfig.h"
 
-AcsBoardAssembly::AcsBoardAssembly(object_id_t objectId, object_id_t parentId,
-                                   PowerSwitchIF* switcher, AcsBoardHelper helper, GpioIF* gpioIF)
-    : DualLaneAssemblyBase(objectId, parentId, switcher, SWITCH_A, SWITCH_B,
-                           POWER_STATE_MACHINE_TIMEOUT, SIDE_SWITCH_TRANSITION_NOT_ALLOWED,
-                           TRANSITION_OTHER_SIDE_FAILED),
+AcsBoardAssembly::AcsBoardAssembly(object_id_t objectId, PowerSwitchIF* switcher,
+                                   AcsBoardHelper helper, GpioIF* gpioIF)
+    : DualLaneAssemblyBase(objectId, switcher, SWITCH_A, SWITCH_B, POWER_STATE_MACHINE_TIMEOUT,
+                           SIDE_SWITCH_TRANSITION_NOT_ALLOWED, TRANSITION_OTHER_SIDE_FAILED),
       helper(helper),
       gpioIF(gpioIF) {
   if (switcher == nullptr) {
@@ -275,42 +274,4 @@ void AcsBoardAssembly::refreshHelperModes() {
   }
 }
 
-ReturnValue_t AcsBoardAssembly::initialize() {
-  ReturnValue_t result = registerChild(helper.gyro0AdisIdSideA);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  result = registerChild(helper.gyro1L3gIdSideA);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  result = registerChild(helper.gyro2AdisIdSideB);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  result = registerChild(helper.gyro3L3gIdSideB);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  result = registerChild(helper.mgm0Lis3IdSideA);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  result = registerChild(helper.mgm1Rm3100IdSideA);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  result = registerChild(helper.mgm2Lis3IdSideB);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  result = registerChild(helper.mgm3Rm3100IdSideB);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  result = registerChild(helper.gpsId);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  return AssemblyBase::initialize();
-}
+ReturnValue_t AcsBoardAssembly::initialize() { return AssemblyBase::initialize(); }