Merge pull request 'v1.16.0' (#323 ) from develop into main

Reviewed-on: #323
bump version and changelog
2022-11-18 14:23:22 +01:00 · 2022-11-18 14:22:00 +01:00 · 2022-11-18 14:20:57 +01:00 · 2022-11-15 13:41:39 +01:00 · 2022-11-15 13:40:16 +01:00 · 2022-11-15 13:35:18 +01:00
481 changed files with 13101 additions and 22768 deletions
--- a/.gitmodules
+++ b/.gitmodules
@ -22,3 +22,6 @@
 [submodule "thirdparty/rapidcsv"]
 	path = thirdparty/rapidcsv
 	url = https://github.com/d99kris/rapidcsv.git
+[submodule "thirdparty/gomspace-sw"]
+	path = thirdparty/gomspace-sw
+	url = https://egit.irs.uni-stuttgart.de/eive/gomspace-sw.git
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -10,6 +10,72 @@ 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
+- Remove rad sensor from EM build, lead to weird bugs on EM which
+  prevented `xsc_boot_copy` from working properly
+- CFDP closure handling is now working
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/307
+- Safety mechanism for SD card handling on graceful reboots
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/308
+- Solar Array Deployment handler update
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/305
+- IMTQ updates as preparation for ACS controller expansion
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/306
+- P60 Module: Reduce number of set IDs, use same set IDs for core, auxiliary
+  and config HK set across the three PCDU modules
+
+# [v1.14.1] 11.10.2022
+
+- Various bugfixes and regression fixes
+- General file handling at program initialization now works properly again
+- Scratch buffer preferred SD card handling works again
+- Use scoped locks in TCS controller to avoid deadlocks
+
+# [v1.14.0] 10.10.2022
+
+- Provide full SW update capability for the OBSW.
+  This includes very basic CFDP integration, a software update
+  procedure specified in detail in the README and some high level
+  commands to make this easier for operators.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/302
+- Update for FSFW: `HasReturnvaluesIF` class replaced by namespace `returnvalue`
+- Add some GomSpace clients as a submodule dependency. Use this dependency to deserialize the
+  GomSpace TM tables
+- Add API to retrieve GomSpace device parameter tables
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/287
+- Add API to save and load GomSpace config tables
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/293
+- Increase number of allowed consescutive action commands from 3 to 16
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/294
+- 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
+
+- Added first version of ACS Controller with gathers MGM data in a set
+- Some tweaks for IMTQ handler
+
 # [v1.12.1] 05.07.2022

 - Disable periodic TCS controller HK generation by default
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -9,8 +9,8 @@
 # ##############################################################################
 cmake_minimum_required(VERSION 3.13)

-set(OBSW_VERSION_MAJOR_IF_GIT_FAILS 0)
-set(OBSW_VERSION_MINOR_IF_GIT_FAILS 0)
+set(OBSW_VERSION_MAJOR_IF_GIT_FAILS 1)
+set(OBSW_VERSION_MINOR_IF_GIT_FAILS 16)
 set(OBSW_VERSION_REVISION_IF_GIT_FAILS 0)

 # set(CMAKE_VERBOSE TRUE)
@ -95,9 +95,36 @@ set(OBSW_ADD_SUS_BOARD_ASS
 set(OBSW_ADD_ACS_BOARD
    ${INIT_VAL}
    CACHE STRING "Add ACS board module")
-set(OBSW_ADD_ACS_HANDLERS
+set(OBSW_ADD_GPS_CTRL
    ${INIT_VAL}
-    CACHE STRING "Add ACS handlers")
+    CACHE STRING "Add GPS controllers")
+set(OBSW_ADD_CCSDS_IP_CORES
+    1
+    CACHE STRING "Add CCSDS IP cores")
+set(OBSW_TM_TO_PTME
+    1
+    CACHE STRING "Send telemetry to PTME IP core")
+set(OBSW_TC_FROM_PDEC
+    1
+    CACHE STRING "Poll telecommand from PDEC IP core")
+set(OBSW_ADD_TCS_CTRL
+    ${INIT_VAL}
+    CACHE STRING "Add TCS controllers")
+set(OBSW_ADD_HEATERS
+    ${INIT_VAL}
+    CACHE STRING "Add TCS heaters")
+set(OBSW_ADD_PLOC_SUPERVISOR
+    ${INIT_VAL}
+    CACHE STRING "Add PLOC supervisor handler")
+set(OBSW_ADD_SA_DEPL
+    ${INIT_VAL}
+    CACHE STRING "Add SA deployment handler")
+set(OBSW_ADD_PLOC_MPSOC
+    ${INIT_VAL}
+    CACHE STRING "Add MPSoC handler")
+set(OBSW_ADD_ACS_CTRL
+    ${INIT_VAL}
+    CACHE STRING "Add ACS controller")
 set(OBSW_ADD_RTD_DEVICES
    ${INIT_VAL}
    CACHE STRING "Add RTD devices")
@ -119,6 +146,12 @@ set(OBSW_ADD_GOMSPACE_PCDU
 set(OBSW_ADD_RW
    ${INIT_VAL}
    CACHE STRING "Add RW modules")
+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
@ -170,6 +203,9 @@ set(LIB_ETL_TARGET etl::etl)
 set(LIB_CSP_NAME libcsp)
 set(LIB_LWGPS_NAME lwgps)
 set(LIB_ARCSEC wire)
+set(LIB_GOMSPACE_CLIENTS gs_clients)
+set(LIB_GOMSPACE_CSP gs_csp)
+
 set(THIRD_PARTY_FOLDER thirdparty)
 set(LIB_CXX_FS -lstdc++fs)
 set(LIB_CATCH2 Catch2)
@ -182,6 +218,7 @@ set(FSFW_PATH fsfw)
 set(TEST_PATH test)
 set(UNITTEST_PATH unittest)
 set(LINUX_PATH linux)
+set(LIB_GOMSPACE_PATH ${THIRD_PARTY_FOLDER}/gomspace-sw)
 set(COMMON_PATH common)
 set(DUMMY_PATH dummies)
 set(WATCHDOG_PATH watchdog)
@ -189,7 +226,6 @@ set(COMMON_CONFIG_PATH ${COMMON_PATH}/config)
 set(UNITTEST_CFG_PATH ${UNITTEST_PATH}/testcfg)

 set(LIB_EIVE_MISSION_PATH mission)
-set(LIB_CSP_PATH ${THIRD_PARTY_FOLDER}/libcsp)
 set(LIB_ETL_PATH ${THIRD_PARTY_FOLDER}/etl)
 set(LIB_CATCH2_PATH ${THIRD_PARTY_FOLDER}/Catch2)
 set(LIB_LWGPS_PATH ${THIRD_PARTY_FOLDER}/lwgps)
@ -197,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.
@ -217,9 +253,15 @@ if(TGT_BSP)
    set(FSFW_CONFIG_PATH "linux/fsfwconfig")
    if(NOT BUILD_Q7S_SIMPLE_MODE)
      set(EIVE_ADD_LINUX_FILES TRUE)
-      set(ADD_CSP_LIB 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")
@ -278,31 +320,6 @@ set(FSFW_ADDITIONAL_INC_PATHS "${COMMON_PATH}/config"

 # global compiler options need to be set before adding executables
 if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-  add_compile_options(
-    "-Wall"
-    "-Wextra"
-    "-Wimplicit-fallthrough=1"
-    "-Wno-unused-parameter"
-    "-Wno-psabi"
-    "-Wduplicated-cond" # check for duplicate conditions
-    "-Wduplicated-branches" # check for duplicate branches
-    "-Wlogical-op" # Search for bitwise operations instead of logical
-    "-Wnull-dereference" # Search for NULL dereference
-    "-Wundef" # Warn if undefind marcos are used
-    "-Wformat=2" # Format string problem detection
-    "-Wformat-overflow=2" # Formatting issues in printf
-    "-Wformat-truncation=2" # Formatting issues in printf
-    "-Wformat-security" # Search for dangerous printf operations
-    "-Wstrict-overflow=3" # Warn if integer overflows might happen
-    "-Warray-bounds=2" # Some array bounds violations will be found
-    "-Wshift-overflow=2" # Search for bit left shift overflows (<c++14)
-    "-Wcast-qual" # Warn if the constness is cast away
-    "-Wstringop-overflow=4"
-    # -Wstack-protector # Emits a few false positives for low level access
-    # -Wconversion # Creates many false positives -Warith-conversion # Use with
-    # Wconversion to find more implicit conversions -fanalyzer # Should be used
-    # to look through problems
-  )
  # Remove unused sections.
  add_compile_options("-ffunction-sections" "-fdata-sections")

@ -320,6 +337,37 @@ add_library(${LIB_DUMMIES})
 add_executable(${OBSW_NAME})
 set(OBSW_BIN_NAME ${CMAKE_PROJECT_NAME})

+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+  set(WARNING_FLAGS
+      "-Wall"
+      "-Wextra"
+      "-Wimplicit-fallthrough=1"
+      "-Wno-unused-parameter"
+      "-Wno-psabi"
+      "-Wduplicated-cond" # check for duplicate conditions
+      "-Wduplicated-branches" # check for duplicate branches
+      "-Wlogical-op" # Search for bitwise operations instead of logical
+      "-Wnull-dereference" # Search for NULL dereference
+      "-Wundef" # Warn if undefind marcos are used
+      "-Wformat=2" # Format string problem detection
+      "-Wformat-overflow=2" # Formatting issues in printf
+      "-Wformat-truncation=2" # Formatting issues in printf
+      "-Wformat-security" # Search for dangerous printf operations
+      "-Wstrict-overflow=3" # Warn if integer overflows might happen
+      "-Warray-bounds=2" # Some array bounds violations will be found
+      "-Wshift-overflow=2" # Search for bit left shift overflows (<c++14)
+      "-Wcast-qual" # Warn if the constness is cast away
+      "-Wstringop-overflow=4"
+      # -Wstack-protector # Emits a few false positives for low level access
+      # -Wconversion # Creates many false positives -Warith-conversion # Use
+      # with Wconversion to find more implicit conversions -fanalyzer # Should
+      # be used to look through problems
+  )
+  target_compile_options(${OBSW_NAME} PRIVATE ${WARNING_FLAGS})
+  target_compile_options(${LIB_EIVE_MISSION} PRIVATE ${WARNING_FLAGS})
+  target_compile_options(${LIB_DUMMIES} PRIVATE ${WARNING_FLAGS})
+endif()
+
 set_target_properties(${OBSW_NAME} PROPERTIES OUTPUT_NAME ${OBSW_BIN_NAME})

 # Watchdog
@ -348,15 +396,16 @@ 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})
  add_subdirectory(${LINUX_PATH})
 endif()
 add_subdirectory(${BSP_PATH})
-if(ADD_CSP_LIB)
-  add_subdirectory(${LIB_CSP_PATH})
+
+if(UNIX)
+  add_subdirectory(${LIB_GOMSPACE_PATH})
 endif()

 add_subdirectory(${COMMON_PATH})
@ -370,21 +419,19 @@ add_subdirectory(${TEST_PATH})
 add_subdirectory(${UNITTEST_PATH})

 # This should have already been downloaded by the FSFW Still include it to be
-# safe
-find_package(etl ${FSFW_ETL_LIB_MAJOR_VERSION} CONFIG QUIET)
-# Not installed, so use FetchContent to download and provide etl
-if(NOT etl_FOUND)
-  message(
-    STATUS
-      "No ETL installation was found with find_package. Installing and providing "
-      "etl with FindPackage")
-  include(FetchContent)
-  FetchContent_Declare(
-    etl
-    GIT_REPOSITORY https://github.com/ETLCPP/etl
-    GIT_TAG ${FSFW_ETL_LIB_VERSION})
-  list(APPEND FSFW_FETCH_CONTENT_TARGETS etl)
-endif()
+# safe find_package(etl ${FSFW_ETL_LIB_MAJOR_VERSION} CONFIG QUIET) Not
+# installed, so use FetchContent to download and provide etl if(NOT etl_FOUND)
+message(
+  STATUS
+    "No ETL installation was found with find_package. Installing and providing "
+    "etl with FindPackage")
+include(FetchContent)
+FetchContent_Declare(
+  etl
+  GIT_REPOSITORY https://github.com/ETLCPP/etl
+  GIT_TAG ${FSFW_ETL_LIB_VERSION})
+list(APPEND FSFW_FETCH_CONTENT_TARGETS etl)
+# endif()

 # Use same Catch2 version as framework
 if(NOT (TGT_BSP MATCHES "arm/te0720-1cfa")
@ -449,8 +496,8 @@ if(TGT_BSP MATCHES "arm/egse")
  target_link_libraries(${OBSW_NAME} PRIVATE ${LIB_ARCSEC})
 endif()

-if(ADD_CSP_LIB)
-  target_link_libraries(${OBSW_NAME} PRIVATE ${LIB_CSP_NAME})
+if(UNIX)
+  target_link_libraries(${OBSW_NAME} PRIVATE ${LIB_GOMSPACE_CLIENTS})
 endif()

 if(EIVE_ADD_ETL_LIB)
--- a/README.md
+++ b/README.md
@ -152,6 +152,78 @@ When using Windows, run theses steps in MSYS2.
   cmake --build . -j
   ```

+## Preparing and executing an OBSW update
+
+A OBSW update consists of a `xz` compressed file `eive-sw-update.tar.xz`
+which contains the following two files:
+
+1. Stripped OBSW binary `eive-obsw-stripped`
+2. OBSW version text file with the name `obsw_version.txt`
+
+These files can be created manually:
+
+1. Build the release image inside `cmake-build-release-q7s`
+2. Switch into the build directory
+3. Run the following command to create the version file
+
+   ```sh
+   git describe --tags --always --exclude docker_* > obsw_version.txt
+   ```
+
+   You can also use the `create-version-file.sh` helper shell script
+   located in the `scripts` folder to do this.
+
+4. Set the Q7S user as the file owner for both files
+
+   ```sh
+   sudo chown root:root eive-obsw-stripped
+   sudo chown root:root obsw_version.txt
+   ```
+
+5. Run the following command to create the compressed archive
+
+   ```sh
+   tar -cJvf eive-sw-update.tar.xz eive-obsw-stripped obsw_version.txt
+   ```
+
+You can also use the helper script `create-sw-update.sh` inside the build folder
+after sourcing the `q7s-env.sh` helper script to perform all steps including
+a rebuild.
+
+After creating these files, they need to be transferred onto the Q7S
+to either the `/mnt/sd0/bin` or `/mnt/sd1/bin` folder if the OBSW update
+is performed from the SD card. It can also be transferred to the `/tmp` folder
+to perform the update from a temporary directory, which does not rely on any
+of the SD cards being on and mounted. However, all files in the temporary
+directory will be deleted if the Linux OS is rebooted for any reason.
+
+After both files are in place (this is checked by the OBSW), the example command
+sequence is used by the OBSW to write the OBSW update to the QSPI chip 0 and
+slot 0 using SD card 0:
+
+```sh
+tar -xJvf eive-update.tar.xz
+xsc_mount_copy 0 0
+cp eive-obsw-stripped /tmp/mntupdate-xdi-qspi0-nom-rootfs/usr/bin/eive-obsw
+cp obsw_update.txt /tmp/mntupdate-xdi-qspi0-nom-rootfs/usr/share/obsw_update.txt
+writeprotect 0 0 1
+```
+
+Some context information about the used commands:
+
+1. It mounts the target chip and copy combination into the `/tmp` folder
+   using the `xsc_mount_copy <chip> <copy>` utility. This also unlocks the
+   writeprotection for the chip. The mount point name inside `/tmp` depends
+   on which chip and copy is used
+
+   - Chip 0 Copy 0: `/tmp/mntupdate-xdi-qspi0-nom-rootfs`
+   - Chip 0 Copy 1: `/tmp/mntupdate-xdi-qspi0-gold-rootfs`
+   - Slot 1 Copy 0: `/tmp/mntupdate-xdi-qspi1-nom-rootfs`
+   - Slot 1 Copy 1: `/tmp/mntupdate-xdi-qspi1-gold-rootfs`
+
+2. Writing the file with a regular `cp <source> <target>` command
+3. Enabling the writeprotection using the `writeprotect <chip> <copy> 1` utility.
+
 ## Build for the Q7S target root filesystem with `yocto`

 The EIVE root filesystem will contain the EIVE OBSW and the Watchdog component.
@ -1036,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

--- a/bsp_egse/InitMission.cpp
+++ b/bsp_egse/InitMission.cpp
@ -2,7 +2,7 @@

 #include <fsfw/objectmanager/ObjectManager.h>
 #include <fsfw/objectmanager/ObjectManagerIF.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/returnvalues/returnvalue.h>
 #include <fsfw/serviceinterface/ServiceInterface.h>
 #include <fsfw/tasks/FixedTimeslotTaskIF.h>
 #include <fsfw/tasks/PeriodicTaskIF.h>
@ -40,7 +40,7 @@ void initmission::initMission() {

 void initmission::initTasks() {
  TaskFactory* factory = TaskFactory::instance();
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
  if (factory == nullptr) {
    /* Should never happen ! */
    return;
@ -55,28 +55,28 @@ void initmission::initTasks() {
  PeriodicTaskIF* tmtcDistributor = factory->createPeriodicTask(
      "DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
  result = tmtcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "Object add component failed" << std::endl;
  }
  result = tmtcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "Object add component failed" << std::endl;
  }
  result = tmtcDistributor->addComponent(objects::TM_FUNNEL);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "Object add component failed" << std::endl;
  }

  PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask(
      "TMTC_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
  result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "Add component TMTC Bridge failed" << std::endl;
  }
  PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask(
      "TMTC_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
  result = tmtcPollingTask->addComponent(objects::TMTC_POLLING_TASK);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "Add component TMTC Polling failed" << std::endl;
  }

@ -88,7 +88,7 @@ void initmission::initTasks() {
  FixedTimeslotTaskIF* pst = factory->createFixedTimeslotTask(
      "STAR_TRACKER_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.5, missedDeadlineFunc);
  result = pst::pstUart(pst);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
  }
  pstTasks.push_back(pst);
@ -96,7 +96,7 @@ void initmission::initTasks() {
  PeriodicTaskIF* strHelperTask = factory->createPeriodicTask(
      "STR_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
  result = strHelperTask->addComponent(objects::STR_HELPER);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("STR_HELPER", objects::STR_HELPER);
  }
  pstTasks.push_back(strHelperTask);
@ -125,11 +125,11 @@ void initmission::initTasks() {
 void initmission::createPusTasks(TaskFactory& factory,
                                 TaskDeadlineMissedFunction missedDeadlineFunc,
                                 std::vector<PeriodicTaskIF*>& taskVec) {
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
  PeriodicTaskIF* pusVerification = factory.createPeriodicTask(
      "PUS_VERIF", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
  result = pusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "Object add component failed" << std::endl;
  }
  taskVec.push_back(pusVerification);
@ -137,11 +137,11 @@ void initmission::createPusTasks(TaskFactory& factory,
  PeriodicTaskIF* pusEvents = factory.createPeriodicTask(
      "PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
  result = pusEvents->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS_EVENTS", objects::PUS_SERVICE_5_EVENT_REPORTING);
  }
  result = pusEvents->addComponent(objects::EVENT_MANAGER);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS_MGMT", objects::EVENT_MANAGER);
  }
  taskVec.push_back(pusEvents);
@ -149,11 +149,11 @@ void initmission::createPusTasks(TaskFactory& factory,
  PeriodicTaskIF* pusHighPrio = factory.createPeriodicTask(
      "PUS_HIGH_PRIO", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
  result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
  }
  result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT);
  }
  taskVec.push_back(pusHighPrio);
@ -161,19 +161,19 @@ void initmission::createPusTasks(TaskFactory& factory,
  PeriodicTaskIF* pusMedPrio = factory.createPeriodicTask(
      "PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
  result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
  }
  result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS200", objects::PUS_SERVICE_200_MODE_MGMT);
  }
  result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS20", objects::PUS_SERVICE_20_PARAMETERS);
  }
  result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS3", objects::PUS_SERVICE_3_HOUSEKEEPING);
  }
  taskVec.push_back(pusMedPrio);
@ -181,11 +181,11 @@ void initmission::createPusTasks(TaskFactory& factory,
  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 != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS17", objects::PUS_SERVICE_17_TEST);
  }
  result = pusLowPrio->addComponent(objects::INTERNAL_ERROR_REPORTER);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("INT_ERR_RPRT", objects::INTERNAL_ERROR_REPORTER);
  }
  taskVec.push_back(pusLowPrio);
--- a/bsp_egse/ObjectFactory.cpp
+++ b/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(
--- a/bsp_hosted/InitMission.cpp
+++ b/bsp_hosted/InitMission.cpp
@ -4,7 +4,7 @@
 #include <bsp_hosted/fsfwconfig/pollingsequence/DummyPst.h>
 #include <fsfw/objectmanager/ObjectManager.h>
 #include <fsfw/objectmanager/ObjectManagerIF.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/returnvalues/returnvalue.h>
 #include <fsfw/serviceinterface/ServiceInterfaceStream.h>
 #include <fsfw/tasks/FixedTimeslotTaskIF.h>
 #include <fsfw/tasks/PeriodicTaskIF.h>
@ -56,15 +56,15 @@ void initmission::initTasks() {
  PeriodicTaskIF* tmTcDistributor = factory->createPeriodicTask(
      "DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
  ReturnValue_t result = tmTcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "Object add component failed" << std::endl;
  }
  result = tmTcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "Object add component failed" << std::endl;
  }
  result = tmTcDistributor->addComponent(objects::TM_FUNNEL);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "Object add component failed" << std::endl;
  }

@ -72,13 +72,13 @@ void initmission::initTasks() {
  PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask(
      "TMTC_UNIX_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
  result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "Add component UDP Unix Bridge failed" << std::endl;
  }
  PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask(
      "UDP_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
  result = tmtcPollingTask->addComponent(objects::TMTC_POLLING_TASK);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "Add component UDP Polling failed" << std::endl;
  }

@ -86,89 +86,89 @@ void initmission::initTasks() {
  PeriodicTaskIF* pusVerification = factory->createPeriodicTask(
      "PUS_VERIF", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
  result = pusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "Object add component failed" << std::endl;
  }

  PeriodicTaskIF* eventHandling = factory->createPeriodicTask(
      "EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
  result = eventHandling->addComponent(objects::EVENT_MANAGER);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("EVENT_MNGR", objects::EVENT_MANAGER);
  }
  result = eventHandling->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS5", objects::PUS_SERVICE_5_EVENT_REPORTING);
  }

  PeriodicTaskIF* pusHighPrio = factory->createPeriodicTask(
      "PUS_HIGH_PRIO", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
  result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
  }
  result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT);
  }
  result = pusHighPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS3", objects::PUS_SERVICE_3_HOUSEKEEPING);
  }

  PeriodicTaskIF* pusMedPrio = factory->createPeriodicTask(
      "PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
  result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
  }
  result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS200", objects::PUS_SERVICE_200_MODE_MGMT);
  }
  result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS20", objects::PUS_SERVICE_20_PARAMETERS);
  }

  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 != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS17", objects::PUS_SERVICE_17_TEST);
  }

  PeriodicTaskIF* thermalTask = factory->createPeriodicTask(
      "THERMAL_CTL_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
  result = thermalTask->addComponent(objects::RTD_0_IC3_PLOC_HEATSPREADER);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("RTD_0_dummy", objects::RTD_0_IC3_PLOC_HEATSPREADER);
  }
  result = thermalTask->addComponent(objects::SUS_0_N_LOC_XFYFZM_PT_XF);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("SUS_0_dummy", objects::SUS_0_N_LOC_XFYFZM_PT_XF);
  }

  result = thermalTask->addComponent(objects::CORE_CONTROLLER);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("Core controller dummy", objects::CORE_CONTROLLER);
  }

  result = thermalTask->addComponent(objects::THERMAL_CONTROLLER);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("THERMAL_CONTROLLER", objects::THERMAL_CONTROLLER);
  }

  FixedTimeslotTaskIF* pstTask = factory->createFixedTimeslotTask(
      "DUMMY_PST", 75, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.5, missedDeadlineFunc);
  result = dummy_pst::pst(pstTask);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "Failed to add dummy pst to fixed timeslot task" << std::endl;
  }

 #if OBSW_ADD_TEST_CODE == 1
  result = testTask->addComponent(objects::TEST_TASK);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("TEST_TASK", objects::TEST_TASK);
  }
 #endif /* OBSW_ADD_TEST_CODE == 1 */
--- a/bsp_hosted/ObjectFactory.cpp
+++ b/bsp_hosted/ObjectFactory.cpp
@ -4,12 +4,12 @@
 #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/apid.h>
 #include <tmtc/pusIds.h>

 #include "OBSWConfig.h"
+#include "eive/definitions.h"
 #include "fsfw_tests/integration/task/TestTask.h"

 #if OBSW_USE_TMTC_TCP_BRIDGE == 0
@ -44,50 +44,29 @@
 #include <dummies/SyrlinksDummy.h>
 #include <dummies/TemperatureSensorsDummy.h>

+#include "dummies/helpers.h"
+#include "mission/utility/GlobalConfigHandler.h"
+
 void Factory::setStaticFrameworkObjectIds() {
-  PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
-  PusServiceBase::packetDestination = objects::TM_FUNNEL;
+  PusServiceBase::PUS_DISTRIBUTOR = objects::PUS_PACKET_DISTRIBUTOR;
+  PusServiceBase::PACKET_DESTINATION = objects::TM_FUNNEL;

  CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
  CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;

-  TmFunnel::downlinkDestination = objects::TMTC_BRIDGE;
-  // No storage object for now.
-  TmFunnel::storageDestination = objects::NO_OBJECT;
-
-  VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
-  TmPacketBase::timeStamperId = objects::TIME_STAMPER;
+  VerificationReporter::DEFAULT_RECEIVER = objects::PUS_SERVICE_1_VERIFICATION;
 }

 void ObjectFactory::produce(void* args) {
  Factory::setStaticFrameworkObjectIds();
-  ObjectFactory::produceGenericObjects();
+  PusTmFunnel* pusFunnel;
+  CfdpTmFunnel* cfdpFunnel;
+  ObjectFactory::produceGenericObjects(nullptr, &pusFunnel, &cfdpFunnel);

-  new ComIFDummy(objects::DUMMY_COM_IF);
-  ComCookieDummy* comCookieDummy = new ComCookieDummy();
-  new BpxDummy(objects::BPX_BATT_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
-  new CoreControllerDummy(objects::CORE_CONTROLLER);
-  new RwDummy(objects::RW1, objects::DUMMY_COM_IF, comCookieDummy);
-  new RwDummy(objects::RW2, objects::DUMMY_COM_IF, comCookieDummy);
-  new RwDummy(objects::RW3, objects::DUMMY_COM_IF, comCookieDummy);
-  new RwDummy(objects::RW4, objects::DUMMY_COM_IF, comCookieDummy);
-  new StarTrackerDummy(objects::STAR_TRACKER, objects::DUMMY_COM_IF, comCookieDummy);
-  new SyrlinksDummy(objects::SYRLINKS_HK_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
-  new ImtqDummy(objects::IMTQ_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
-  new AcuDummy(objects::ACU_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
-  new PduDummy(objects::PDU1_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
-  new PduDummy(objects::PDU2_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
-  new P60DockDummy(objects::P60DOCK_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
-  new GyroAdisDummy(objects::GYRO_0_ADIS_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
-  new GyroL3GD20Dummy(objects::GYRO_1_L3G_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
-  new GyroAdisDummy(objects::GYRO_2_ADIS_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
-  new GyroL3GD20Dummy(objects::GYRO_3_L3G_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
-  new MgmLIS3MDLDummy(objects::MGM_0_LIS3_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
-  new MgmLIS3MDLDummy(objects::MGM_2_LIS3_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
-  new PlPcduDummy(objects::PLPCDU_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  dummy::DummyCfg cfg;
+  dummy::createDummies(cfg);
  new TemperatureSensorsDummy();
  new SusDummy();
-  new ThermalController(objects::THERMAL_CONTROLLER, objects::NO_OBJECT);
-
-  // new TestTask(objects::TEST_TASK);
+  new ThermalController(objects::THERMAL_CONTROLLER);
+  new TestTask(objects::TEST_TASK);
 }
--- a/bsp_hosted/comIF/ArduinoComIF.cpp
+++ b/bsp_hosted/comIF/ArduinoComIF.cpp
@ -129,9 +129,7 @@ ArduinoComIF::~ArduinoComIF() {
  CloseHandle(hCom);
 #endif
 }
-ReturnValue_t ArduinoComIF::initializeInterface(CookieIF *cookie) {
-  return HasReturnvaluesIF::RETURN_OK;
-}
+ReturnValue_t ArduinoComIF::initializeInterface(CookieIF *cookie) { return returnvalue::OK; }

 ReturnValue_t ArduinoComIF::sendMessage(CookieIF *cookie, const uint8_t *data, size_t len) {
  ArduinoCookie *arduinoCookie = dynamic_cast<ArduinoCookie *>(cookie);
@ -142,10 +140,10 @@ ReturnValue_t ArduinoComIF::sendMessage(CookieIF *cookie, const uint8_t *data, s
  return sendMessage(arduinoCookie->command, arduinoCookie->address, data, len);
 }

-ReturnValue_t ArduinoComIF::getSendSuccess(CookieIF *cookie) { return RETURN_OK; }
+ReturnValue_t ArduinoComIF::getSendSuccess(CookieIF *cookie) { return returnvalue::OK; }

 ReturnValue_t ArduinoComIF::requestReceiveMessage(CookieIF *cookie, size_t requestLen) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t ArduinoComIF::readReceivedMessage(CookieIF *cookie, uint8_t **buffer, size_t *size) {
@ -158,7 +156,7 @@ ReturnValue_t ArduinoComIF::readReceivedMessage(CookieIF *cookie, uint8_t **buff

  *buffer = arduinoCookie->replyBuffer.data();
  *size = arduinoCookie->receivedDataLen;
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t ArduinoComIF::sendMessage(uint8_t command, uint8_t address, const uint8_t *data,
@ -178,14 +176,14 @@ ReturnValue_t ArduinoComIF::sendMessage(uint8_t command, uint8_t address, const

  ReturnValue_t result =
      DleEncoder::encode(&command, 1, currentPosition, remainingLen, &encodedLen, false);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  currentPosition += encodedLen;
  remainingLen -= encodedLen;  // DleEncoder will never return encodedLen > remainingLen

  result = DleEncoder::encode(&address, 1, currentPosition, remainingLen, &encodedLen, false);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  currentPosition += encodedLen;
@ -199,7 +197,7 @@ ReturnValue_t ArduinoComIF::sendMessage(uint8_t command, uint8_t address, const

  result =
      DleEncoder::encode(temporaryBuffer, 2, currentPosition, remainingLen, &encodedLen, false);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  currentPosition += encodedLen;
@ -207,7 +205,7 @@ ReturnValue_t ArduinoComIF::sendMessage(uint8_t command, uint8_t address, const

  // encoding the actual data
  result = DleEncoder::encode(data, dataLen, currentPosition, remainingLen, &encodedLen, false);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  currentPosition += encodedLen;
@ -224,7 +222,7 @@ ReturnValue_t ArduinoComIF::sendMessage(uint8_t command, uint8_t address, const

  result =
      DleEncoder::encode(temporaryBuffer, 2, currentPosition, remainingLen, &encodedLen, false);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  currentPosition += encodedLen;
@ -241,16 +239,16 @@ ReturnValue_t ArduinoComIF::sendMessage(uint8_t command, uint8_t address, const
  ssize_t writtenlen = ::write(serialPort, sendBuffer, encodedLen);
  if (writtenlen < 0) {
    // we could try to find out what happened...
-    return RETURN_FAILED;
+    return returnvalue::FAILED;
  }
  if (writtenlen != encodedLen) {
    // the OS failed us, we do not try to block until everything is written, as
    // we can not block the whole system here
-    return RETURN_FAILED;
+    return returnvalue::FAILED;
  }
-  return RETURN_OK;
+  return returnvalue::OK;
 #elif WIN32
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 #endif
 }

@ -297,7 +295,7 @@ void ArduinoComIF::handleSerialPortRx() {
                                            packet, sizeof(packet), &packetLen);

  size_t toDelete = firstSTXinRawData;
-  if (result == HasReturnvaluesIF::RETURN_OK) {
+  if (result == returnvalue::OK) {
    handlePacket(packet, packetLen);

    // after handling the packet, we can delete it from the raw stream,
--- a/bsp_hosted/comIF/ArduinoComIF.h
+++ b/bsp_hosted/comIF/ArduinoComIF.h
@ -5,7 +5,7 @@
 #include <fsfw/container/SimpleRingBuffer.h>
 #include <fsfw/devicehandlers/DeviceCommunicationIF.h>
 #include <fsfw/objectmanager/SystemObject.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/returnvalues/returnvalue.h>

 #include <cstdint>
 #include <map>
--- a/bsp_hosted/fsfwconfig/OBSWConfig.h.in
+++ b/bsp_hosted/fsfwconfig/OBSWConfig.h.in
@ -16,7 +16,7 @@
 debugging. */
 #define OBSW_VEBOSE_LEVEL                           1

-#define OBSW_USE_CCSDS_IP_CORE                      0
+#define OBSW_ADD_CCSDS_IP_CORES                     0
 // Set to 1 if all telemetry should be sent to the PTME IP Core
 #define OBSW_TM_TO_PTME                             0
 // Set to 1 if telecommands are received via the PDEC IP Core
--- a/bsp_hosted/fsfwconfig/events/subsystemIdRanges.h
+++ b/bsp_hosted/fsfwconfig/events/subsystemIdRanges.h
@ -1,10 +1,10 @@
 #ifndef CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_
 #define CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_

-#include <common/config/commonSubsystemIds.h>
-
 #include <cstdint>

+#include "eive/eventSubsystemIds.h"
+
 /**
 * These IDs are part of the ID for an event thrown by a subsystem.
 * Numbers 0-80 are reserved for FSFW Subsystem IDs (framework/events/)
--- a/bsp_hosted/fsfwconfig/objects/systemObjectList.h
+++ b/bsp_hosted/fsfwconfig/objects/systemObjectList.h
@ -1,10 +1,10 @@
 #ifndef HOSTED_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
 #define HOSTED_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_

-#include <commonObjects.h>
-
 #include <cstdint>

+#include "eive/objects.h"
+
 // The objects will be instantiated in the ID order
 namespace objects {
 enum sourceObjects : uint32_t {
@ -16,8 +16,6 @@ enum sourceObjects : uint32_t {
  PUS_SERVICE_23 = 0x51002300,
  PUS_SERVICE_201 = 0x51020100,

-  TM_FUNNEL = 0x52000002,
-
  /* Test Task */

  TEST_TASK = 0x42694269,
--- a/bsp_hosted/fsfwconfig/pollingsequence/DummyPst.cpp
+++ b/bsp_hosted/fsfwconfig/pollingsequence/DummyPst.cpp
@ -129,12 +129,12 @@ ReturnValue_t dummy_pst::pst(FixedTimeslotTaskIF *thisSequence) {
  thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
  thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::GET_READ);

-  if (thisSequence->checkSequence() == HasReturnvaluesIF::RETURN_OK) {
-    return HasReturnvaluesIF::RETURN_OK;
+  if (thisSequence->checkSequence() == returnvalue::OK) {
+    return returnvalue::OK;
  } else {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::error << "pst::pollingSequenceInitDefault: Sequence invalid!" << std::endl;
 #endif
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
  }
 }
--- a/bsp_hosted/fsfwconfig/pollingsequence/DummyPst.h
+++ b/bsp_hosted/fsfwconfig/pollingsequence/DummyPst.h
@ -1,7 +1,7 @@
 #ifndef POLLINGSEQUENCEFACTORY_H_
 #define POLLINGSEQUENCEFACTORY_H_

-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/returnvalues/returnvalue.h>

 class FixedTimeslotTaskIF;

--- a/bsp_hosted/fsfwconfig/returnvalues/classIds.h
+++ b/bsp_hosted/fsfwconfig/returnvalues/classIds.h
@ -3,7 +3,7 @@

 #include <fsfw/returnvalues/FwClassIds.h>

-#include "commonClassIds.h"
+#include "eive/resultClassIds.h"

 /**
 * Source IDs starts at 73 for now
--- a/bsp_hosted/main.cpp
+++ b/bsp_hosted/main.cpp
@ -31,6 +31,9 @@ int main(void) {
            << "v" << common::OBSW_VERSION << " | FSFW v" << fsfw::FSFW_VERSION << " --"
            << std::endl;
  std::cout << "-- " << __DATE__ << " " << __TIME__ << " --" << std::endl;
+  std::cout << "-- "
+            << " BSP HOSTED"
+            << " --" << std::endl;

  initmission::initMission();

--- a/bsp_linux_board/CMakeLists.txt
+++ b/bsp_linux_board/CMakeLists.txt
@ -1,5 +1,6 @@
 target_sources(${OBSW_NAME} PUBLIC InitMission.cpp main.cpp gpioInit.cpp
-                                   ObjectFactory.cpp)
+                                   ObjectFactory.cpp RPiSdCardManager.cpp)

 add_subdirectory(boardconfig)
 add_subdirectory(boardtest)
+add_subdirectory(fsfwconfig)
--- a/bsp_linux_board/InitMission.cpp
+++ b/bsp_linux_board/InitMission.cpp
@ -1,12 +1,14 @@
 #include "InitMission.h"

+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
 #include <fsfw/objectmanager/ObjectManager.h>
 #include <fsfw/objectmanager/ObjectManagerIF.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/returnvalues/returnvalue.h>
 #include <fsfw/serviceinterface/ServiceInterface.h>
 #include <fsfw/tasks/FixedTimeslotTaskIF.h>
 #include <fsfw/tasks/PeriodicTaskIF.h>
 #include <fsfw/tasks/TaskFactory.h>
+#include <linux/InitMission.h>
 #include <mission/utility/InitMission.h>

 #include <iostream>
@ -36,7 +38,7 @@ void initmission::initMission() {

 void initmission::initTasks() {
  TaskFactory* factory = TaskFactory::instance();
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
  if (factory == nullptr) {
    /* Should never happen ! */
    return;
@ -51,15 +53,15 @@ void initmission::initTasks() {
  PeriodicTaskIF* tmTcDistributor = factory->createPeriodicTask(
      "DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
  result = tmTcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "Object add component failed" << std::endl;
  }
  result = tmTcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "Object add component failed" << std::endl;
  }
  result = tmTcDistributor->addComponent(objects::TM_FUNNEL);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "Object add component failed" << std::endl;
  }

@ -67,16 +69,22 @@ void initmission::initTasks() {
  PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask(
      "TMTC_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
  result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "Add component TMTC Bridge failed" << std::endl;
  }
  PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask(
      "TMTC_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
  result = tmtcPollingTask->addComponent(objects::TMTC_POLLING_TASK);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "Add component TMTC Polling failed" << std::endl;
  }

+#if OBSW_ADD_SCEX_DEVICE == 1
+  PeriodicTaskIF* scexDevHandler;
+  PeriodicTaskIF* scexReaderTask;
+  scheduling::schedulingScex(*factory, scexDevHandler, scexReaderTask);
+#endif
+
  /* PUS Services */
  std::vector<PeriodicTaskIF*> pusTasks;
  createPusTasks(*factory, missedDeadlineFunc, pusTasks);
@ -109,6 +117,10 @@ void initmission::initTasks() {
 #endif /* OBSW_ADD_TEST_CODE == 1 */
  taskStarter(pstTasks, "PST Tasks");

+#if OBSW_ADD_SCEX_DEVICE == 1
+  scexDevHandler->startTask();
+  scexReaderTask->startTask();
+#endif
 #if OBSW_ADD_TEST_PST == 1
  if (startTestPst) {
    pstTestTask->startTask();
@ -120,11 +132,11 @@ void initmission::initTasks() {
 void initmission::createPusTasks(TaskFactory& factory,
                                 TaskDeadlineMissedFunction missedDeadlineFunc,
                                 std::vector<PeriodicTaskIF*>& taskVec) {
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
  PeriodicTaskIF* pusVerification = factory.createPeriodicTask(
      "PUS_VERIF", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
  result = pusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "Object add component failed" << std::endl;
  }
  taskVec.push_back(pusVerification);
@ -132,11 +144,11 @@ void initmission::createPusTasks(TaskFactory& factory,
  PeriodicTaskIF* pusEvents = factory.createPeriodicTask(
      "PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
  result = pusEvents->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS_EVENTS", objects::PUS_SERVICE_5_EVENT_REPORTING);
  }
  result = pusEvents->addComponent(objects::EVENT_MANAGER);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS_MGMT", objects::EVENT_MANAGER);
  }
  taskVec.push_back(pusEvents);
@ -144,11 +156,11 @@ void initmission::createPusTasks(TaskFactory& factory,
  PeriodicTaskIF* pusHighPrio = factory.createPeriodicTask(
      "PUS_HIGH_PRIO", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
  result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
  }
  result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT);
  }
  taskVec.push_back(pusHighPrio);
@ -156,19 +168,19 @@ void initmission::createPusTasks(TaskFactory& factory,
  PeriodicTaskIF* pusMedPrio = factory.createPeriodicTask(
      "PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
  result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
  }
  result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS200", objects::PUS_SERVICE_200_MODE_MGMT);
  }
  result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS20", objects::PUS_SERVICE_20_PARAMETERS);
  }
  result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS3", objects::PUS_SERVICE_3_HOUSEKEEPING);
  }
  taskVec.push_back(pusMedPrio);
@ -176,11 +188,11 @@ void initmission::createPusTasks(TaskFactory& factory,
  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 != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS17", objects::PUS_SERVICE_17_TEST);
  }
  result = pusLowPrio->addComponent(objects::INTERNAL_ERROR_REPORTER);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("INT_ERR_RPRT", objects::INTERNAL_ERROR_REPORTER);
  }
  taskVec.push_back(pusLowPrio);
@ -189,45 +201,55 @@ void initmission::createPusTasks(TaskFactory& factory,
 void initmission::createPstTasks(TaskFactory& factory,
                                 TaskDeadlineMissedFunction missedDeadlineFunc,
                                 std::vector<PeriodicTaskIF*>& taskVec) {
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
 #if OBSW_ADD_SPI_TEST_CODE == 0
  FixedTimeslotTaskIF* spiPst = factory.createFixedTimeslotTask(
      "SPI_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 1.0, missedDeadlineFunc);
  result = pst::pstSpi(spiPst);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
-    sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
+  if (result != returnvalue::OK) {
+    if (result != FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
+      sif::error << "InitMission::createPstTasks: Creating PST failed!" << std::endl;
+    }
+  } else {
+    taskVec.push_back(spiPst);
  }
-  taskVec.push_back(spiPst);
 #endif
 }

 void initmission::createTestTasks(TaskFactory& factory,
                                  TaskDeadlineMissedFunction missedDeadlineFunc,
                                  std::vector<PeriodicTaskIF*>& taskVec) {
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
  PeriodicTaskIF* testTask = factory.createPeriodicTask(
      "TEST_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
  result = testTask->addComponent(objects::TEST_TASK);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("TEST_TASK", objects::TEST_TASK);
  }
 #if OBSW_ADD_SPI_TEST_CODE == 1
  result = testTask->addComponent(objects::SPI_TEST);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("SPI_TEST", objects::SPI_TEST);
  }
 #endif /* RPI_ADD_SPI_TEST == 1 */
 #if RPI_ADD_GPIO_TEST == 1
  result = testTask->addComponent(objects::LIBGPIOD_TEST);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("GPIOD_TEST", objects::LIBGPIOD_TEST);
  }
 #endif /* RPI_ADD_GPIO_TEST == 1 */
 #if OBSW_ADD_UART_TEST_CODE == 1
  result = testTask->addComponent(objects::UART_TEST);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("UART_TEST", objects::UART_TEST);
  }
+  PeriodicTaskIF* scexReaderTask = factory.createPeriodicTask(
+      "SCEX_UART_READER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+  result = scexReaderTask->addComponent(objects::SCEX_UART_READER);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("SCEX_UART_READER", objects::SCEX_UART_READER);
+  }
+  taskVec.push_back(scexReaderTask);
 #endif /* RPI_ADD_GPIO_TEST == 1 */
  taskVec.push_back(testTask);

@ -237,7 +259,7 @@ void initmission::createTestTasks(TaskFactory& factory,
  FixedTimeslotTaskIF* pstTestTask = factory->createFixedTimeslotTask(
      "TEST_PST", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 2.0, missedDeadlineFunc);
  result = pst::pstTest(pstTestTask);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::info << "initmission::initTasks: ACS PST empty or invalid" << std::endl;
    startTestPst = false;
  }
--- a/bsp_linux_board/OBSWConfig.h.in
+++ b/bsp_linux_board/OBSWConfig.h.in
@ -28,6 +28,7 @@
 #define OBSW_ADD_RTD_DEVICES                        0
 #define OBSW_ADD_PL_PCDU                            0
 #define OBSW_ADD_TMP_DEVICES                        0
+#define OBSW_ADD_SCEX_DEVICE                        1
 #define OBSW_ADD_RAD_SENSORS                        0
 #define OBSW_ADD_SYRLINKS                           0
 #define OBSW_STAR_TRACKER_GROUND_CONFIG             1
@ -102,6 +103,12 @@
 /*******************************************************************/
 #cmakedefine EIVE_BUILD_GPSD_GPS_HANDLER

+#define OBSW_ADD_CCSDS_IP_CORES                     0
+// Set to 1 if all telemetry should be sent to the PTME IP Core
+#define OBSW_TM_TO_PTME                             0
+// Set to 1 if telecommands are received via the PDEC IP Core
+#define OBSW_TC_FROM_PDEC                           0
+
 #cmakedefine LIBGPS_VERSION_MAJOR @LIBGPS_VERSION_MAJOR@
 #cmakedefine LIBGPS_VERSION_MINOR @LIBGPS_VERSION_MINOR@

--- a/bsp_linux_board/ObjectFactory.cpp
+++ b/bsp_linux_board/ObjectFactory.cpp
@ -1,5 +1,8 @@
 #include "ObjectFactory.h"

+#include <bsp_linux_board/RPiSdCardManager.h>
+#include <linux/devices/ScexUartReader.h>
+
 #include "OBSWConfig.h"
 #include "devConf.h"
 #include "devices/addresses.h"
@ -18,9 +21,8 @@
 #include "mission/core/GenericFactory.h"
 #include "mission/devices/GPSHyperionHandler.h"
 #include "mission/devices/GyroADIS1650XHandler.h"
-#include "mission/utility/TmFunnel.h"
+#include "mission/tmtc/TmFunnel.h"
 #include "objects/systemObjectList.h"
-#include "tmtc/apid.h"
 #include "tmtc/pusIds.h"

 /* UDP server includes */
@ -32,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"
@ -45,8 +47,8 @@
 #include "fsfw_hal/linux/spi/SpiCookie.h"

 void Factory::setStaticFrameworkObjectIds() {
-  PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
-  PusServiceBase::packetDestination = objects::TM_FUNNEL;
+  PusServiceBase::PUS_DISTRIBUTOR = objects::PUS_PACKET_DISTRIBUTOR;
+  PusServiceBase::PACKET_DESTINATION = objects::TM_FUNNEL;

  CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
  CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
@ -54,9 +56,6 @@ void Factory::setStaticFrameworkObjectIds() {
  TmFunnel::downlinkDestination = objects::TMTC_BRIDGE;
  // No storage object for now.
  TmFunnel::storageDestination = objects::NO_OBJECT;
-
-  VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
-  TmPacketBase::timeStamperId = objects::TIME_STAMPER;
 }

 void ObjectFactory::produce(void* args) {
@ -76,12 +75,17 @@ void ObjectFactory::produce(void* args) {
  createRpiAcsBoard(gpioIF, spiDev);
 #endif

-#if OBSW_ADD_SUN_SENSORS == 1 || defined(OBSW_ADD_RTD_DEVICES)
+#if OBSW_ADD_SUN_SENSORS == 1 || OBSW_ADD_RTD_DEVICES == 1
 #ifdef RASPBERRY_PI
  rpi::gpio::initSpiCsDecoder(gpioIF);
 #endif
 #endif

+#if OBSW_ADD_SCEX_DEVICE == 1
+  auto* sdcMan = new RPiSdCardManager("/tmp");
+  createScexComponents(uart::DEV, pwrSwitcher, *sdcMan, true, std::nullopt);
+#endif
+
 #if OBSW_ADD_SUN_SENSORS == 1
  createSunSensorComponents(gpioIF, spiComIF, pwrSwitcher, spi::DEV);
 #endif
@ -198,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
--- a/bsp_linux_board/RPiSdCardManager.cpp
+++ b/bsp_linux_board/RPiSdCardManager.cpp
@ -0,0 +1,13 @@
+#include "RPiSdCardManager.h"
+
+RPiSdCardManager::RPiSdCardManager(std::string prefix) : prefix(std::move(prefix)) {}
+
+const std::string& RPiSdCardManager::getCurrentMountPrefix() const { return prefix; }
+
+bool RPiSdCardManager::isSdCardUsable(sd::SdCard sdCard) { return true; }
+
+std::optional<sd::SdCard> RPiSdCardManager::getPreferredSdCard() const { return std::nullopt; }
+
+void RPiSdCardManager::setActiveSdCard(sd::SdCard sdCard) {}
+
+std::optional<sd::SdCard> RPiSdCardManager::getActiveSdCard() const { return std::nullopt; }
--- a/bsp_linux_board/RPiSdCardManager.h
+++ b/bsp_linux_board/RPiSdCardManager.h
@ -0,0 +1,18 @@
+#ifndef BSP_LINUX_BOARD_RPISDCARDMANAGER_H_
+#define BSP_LINUX_BOARD_RPISDCARDMANAGER_H_
+#include <mission/memory/SdCardMountedIF.h>
+
+class RPiSdCardManager : public SdCardMountedIF {
+ public:
+  RPiSdCardManager(std::string prefix);
+  const std::string& getCurrentMountPrefix() const override;
+  bool isSdCardUsable(sd::SdCard sdCard) override;
+  std::optional<sd::SdCard> getPreferredSdCard() const override;
+  void setActiveSdCard(sd::SdCard sdCard) override;
+  std::optional<sd::SdCard> getActiveSdCard() const override;
+
+ private:
+  std::string prefix;
+};
+
+#endif /* BSP_LINUX_BOARD_RPISDCARDMANAGER_H_ */
--- a/bsp_linux_board/definitions.h
+++ b/bsp_linux_board/definitions.h
@ -13,6 +13,12 @@ static constexpr char DEV[] = "/dev/spidev0.1";

 }

+namespace uart {
+
+static constexpr char DEV[] = "/dev/serial0";
+
+}
+
 /* Adapt these values accordingly */
 namespace gpio {
 static constexpr uint8_t MGM_0_BCM_PIN = 17;
--- a/bsp_linux_board/gpioInit.cpp
+++ b/bsp_linux_board/gpioInit.cpp
@ -40,14 +40,14 @@ void rpi::gpio::initSpiCsDecoder(GpioIF* gpioComIF) {
  for (const auto& info : muxInfo) {
    result = createRpiGpioConfig(spiMuxGpios, info.gpioId, info.bcmNum, info.consumer,
                                 Direction::OUT, Levels::LOW);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
      sif::error << "Creating Raspberry Pi SPI Mux GPIO failed with code " << result << std::endl;
      return;
    }
  }

  result = gpioComIF->addGpios(spiMuxGpios);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "initSpiCsDecoder: Failed to add mux bit gpios to gpioComIF" << std::endl;
    return;
  }
--- a/bsp_q7s/CMakeLists.txt
+++ b/bsp_q7s/CMakeLists.txt
@ -24,3 +24,4 @@ endif()
 add_subdirectory(memory)
 add_subdirectory(callbacks)
 add_subdirectory(xadc)
+add_subdirectory(fs)
--- a/bsp_q7s/OBSWConfig.h.in
+++ b/bsp_q7s/OBSWConfig.h.in
@ -14,31 +14,38 @@
 /** All of the following flags should be enabled for mission code  */
 /*******************************************************************/

-#define OBSW_USE_CCSDS_IP_CORE                      1
-// Set to 1 if all telemetry should be sent to the PTME IP Core
-#define OBSW_TM_TO_PTME                             0
-// Set to 1 if telecommands are received via the PDEC IP Core
-#define OBSW_TC_FROM_PDEC                           0
-
-#define OBSW_ENABLE_TIMERS                          1
 #define OBSW_ADD_GOMSPACE_PCDU                      @OBSW_ADD_GOMSPACE_PCDU@
 #define OBSW_ADD_MGT                                @OBSW_ADD_MGT@
 #define OBSW_ADD_BPX_BATTERY_HANDLER                @OBSW_ADD_BPX_BATTERY_HANDLER@
 #define OBSW_ADD_STAR_TRACKER                       @OBSW_ADD_STAR_TRACKER@
-#define OBSW_ADD_PLOC_SUPERVISOR                    1
-#define OBSW_ADD_PLOC_MPSOC                         1
+#define OBSW_ADD_PLOC_SUPERVISOR                    @OBSW_ADD_PLOC_SUPERVISOR@
+#define OBSW_ADD_PLOC_MPSOC                         @OBSW_ADD_PLOC_MPSOC@
 #define OBSW_ADD_SUN_SENSORS                        @OBSW_ADD_SUN_SENSORS@
 #define OBSW_ADD_SUS_BOARD_ASS                      @OBSW_ADD_SUS_BOARD_ASS@
 #define OBSW_ADD_ACS_BOARD                          @OBSW_ADD_ACS_BOARD@
-#define OBSW_ADD_ACS_HANDLERS                       @OBSW_ADD_ACS_HANDLERS@
+#define OBSW_ADD_ACS_CTRL                           @OBSW_ADD_ACS_CTRL@
+#define OBSW_ADD_GPS_CTRL                           @OBSW_ADD_GPS_CTRL@
+#define OBSW_ADD_TCS_CTRL                           @OBSW_ADD_TCS_CTRL@
 #define OBSW_ADD_RW                                 @OBSW_ADD_RW@
 #define OBSW_ADD_RTD_DEVICES                        @OBSW_ADD_RTD_DEVICES@
+#define OBSW_ADD_SA_DEPL                            @OBSW_ADD_SA_DEPL@
+#define OBSW_ADD_SCEX_DEVICE                        @OBSW_ADD_SCEX_DEVICE@
+#define OBSW_ADD_HEATERS                            @OBSW_ADD_HEATERS@
 #define OBSW_ADD_TMP_DEVICES                        @OBSW_ADD_TMP_DEVICES@
 #define OBSW_ADD_RAD_SENSORS                        @OBSW_ADD_RAD_SENSORS@
 #define OBSW_ADD_PL_PCDU                            @OBSW_ADD_PL_PCDU@
 #define OBSW_ADD_SYRLINKS                           @OBSW_ADD_SYRLINKS@
+#define OBSW_ADD_CCSDS_IP_CORES                     @OBSW_ADD_CCSDS_IP_CORES@
+// Set to 1 if all telemetry should be sent to the PTME IP Core
+#define OBSW_TM_TO_PTME                             @OBSW_TM_TO_PTME@
+// Set to 1 if telecommands are received via the PDEC IP Core
+#define OBSW_TC_FROM_PDEC                           @OBSW_TC_FROM_PDEC@
 #define OBSW_ENABLE_SYRLINKS_TRANSMIT_TIMEOUT       0
-#define OBSW_MPSOC_JTAG_BOOT                        0
+
+// Configuration parameter which causes the core controller to try to keep at least one SD card
+// working
+#define OBSW_SD_CARD_MUST_BE_ON                     1
+#define OBSW_ENABLE_TIMERS                          1

 // This is a really tricky switch.. It initializes the PCDU switches to their default states
 // at powerup. I think it would be better
@ -53,11 +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
@ -96,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
@ -115,7 +124,6 @@
 #cmakedefine LIBGPS_VERSION_MAJOR @LIBGPS_VERSION_MAJOR@
 #cmakedefine LIBGPS_VERSION_MINOR @LIBGPS_VERSION_MINOR@

-
 #ifdef __cplusplus

 #include "objects/systemObjectList.h"
--- a/bsp_q7s/boardconfig/busConf.h
+++ b/bsp_q7s/boardconfig/busConf.h
@ -3,23 +3,26 @@

 namespace q7s {

-static constexpr char SPI_DEFAULT_DEV[] = "/dev/spi-main";
+static constexpr char SPI_DEFAULT_DEV[] = "/dev/spi_main";
 static constexpr uint32_t SPI_MAIN_BUS_LOCK_TIMEOUT = 50;

-static constexpr char SPI_RW_DEV[] = "/dev/spi-rw";
+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";
-static constexpr char UART_PLOC_SUPERVSIOR_DEV[] = "/dev/ul-plsv";
-static constexpr char UART_SYRLINKS_DEV[] = "/dev/ul-syrlinks";
-static constexpr char UART_STAR_TRACKER_DEV[] = "/dev/ul-str";
+static constexpr char UART_PLOC_MPSOC_DEV[] = "/dev/ul_plmpsoc";
+static constexpr char UART_PLOC_SUPERVSIOR_DEV[] = "/dev/ul_plsv";
+static constexpr char UART_SYRLINKS_DEV[] = "/dev/ul_syrlinks";
+static constexpr char UART_STAR_TRACKER_DEV[] = "/dev/ul_str";
+static constexpr char UART_SCEX_DEV[] = "/dev/scex";

-static constexpr char UIO_PDEC_REGISTERS[] = "/dev/uio0";
-static constexpr char UIO_PTME[] = "/dev/uio1";
-static constexpr char UIO_PDEC_CONFIG_MEMORY[] = "/dev/uio2";
-static constexpr char UIO_PDEC_RAM[] = "/dev/uio3";
+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/uio_pdec_ram";
+static constexpr char UIO_PDEC_IRQ[] = "/dev/uio_pdec_irq";
 static constexpr int MAP_ID_PTME_CONFIG = 3;

 namespace uiomapids {
--- a/bsp_q7s/boardconfig/q7sConfig.h.in
+++ b/bsp_q7s/boardconfig/q7sConfig.h.in
@ -16,16 +16,6 @@
 /** Other flags                                                    */
 /*******************************************************************/

-#define Q7S_SD_NONE                                 0
-#define Q7S_SD_COLD_REDUNDANT                       1
-#define Q7S_SD_HOT_REDUNDANT                        2
-// The OBSW will perform different actions to set up the SD cards depending on the flag set here
-// Set to Q7S_SD_NONE: Don't do anything
-// Set to Q7S_COLD_REDUNDANT: On startup, get the prefered SD card, turn it on and mount it, and 
-//     turn off the second SD card if it is on
-// Set to Q7S_HOT_REDUNDANT: On startup, turn on both SD cards and mount them  
-#define Q7S_SD_CARD_CONFIG                          Q7S_SD_COLD_REDUNDANT
-
 // Probably better if this is disabled for mission code. Convenient for development
 #define Q7S_CHECK_FOR_ALREADY_RUNNING_IMG           1

--- a/bsp_q7s/boardtest/Q7STestTask.cpp
+++ b/bsp_q7s/boardtest/Q7STestTask.cpp
@ -1,11 +1,14 @@
 #include "Q7STestTask.h"

 #include <bsp_q7s/core/CoreController.h>
-#include <bsp_q7s/memory/FileSystemHandler.h>
 #include <bsp_q7s/xadc/Xadc.h>
+#include <fsfw/globalfunctions/arrayprinter.h>
 #include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw_hal/host/HostFilesystem.h>
 #include <gps.h>
 #include <libgpsmm.h>
+#include <param/param_string.h>
+#include <param/rparam_client.h>

 #include <cstdio>
 #include <ctime>
@ -14,12 +17,17 @@
 #include <iostream>
 #include <nlohmann/json.hpp>

-#include "bsp_q7s/memory/SdCardManager.h"
+#include "OBSWConfig.h"
+#include "bsp_q7s/fs/SdCardManager.h"
+#include "bsp_q7s/fs/helpers.h"
 #include "bsp_q7s/memory/scratchApi.h"
 #include "fsfw/tasks/TaskFactory.h"
 #include "fsfw/timemanager/Stopwatch.h"
+#include "p60pdu.h"
 #include "test/DummyParameter.h"

+using namespace returnvalue;
+
 Q7STestTask::Q7STestTask(object_id_t objectId) : TestTask(objectId) {
  doTestSdCard = false;
  doTestScratchApi = false;
@ -35,13 +43,42 @@ ReturnValue_t Q7STestTask::performOneShotAction() {
  if (doTestScratchApi) {
    testScratchApi();
  }
+  if (DO_TEST_GOMSPACE_API) {
+    uint8_t p60pdu_node = 3;
+    uint8_t hk_mem[P60PDU_HK_SIZE];
+    param_index_t p60pdu_hk{};
+    p60pdu_hk.physaddr = hk_mem;
+    if (!p60pdu_get_hk(&p60pdu_hk, p60pdu_node, 1000)) {
+      printf("Error getting p60pdu hk\n");
+    } else {
+      param_list(&p60pdu_hk, 1);
+    }
+  }
+
+  if (DO_TEST_GOMSPACE_GET_CONFIG) {
+    uint8_t p60pdu_node = 3;
+    param_index_t requestStruct{};
+    requestStruct.table = p60pdu_config;
+    requestStruct.mem_id = P60PDU_PARAM;
+    uint8_t hk_mem[P60PDU_PARAM_SIZE];
+    requestStruct.count = p60pdu_config_count;
+    requestStruct.size = P60PDU_PARAM_SIZE;
+    requestStruct.physaddr = hk_mem;
+    int result = rparam_get_full_table(&requestStruct, p60pdu_node, P60_PORT_RPARAM,
+                                       requestStruct.mem_id, 1000);
+    param_list(&requestStruct, 1);
+    return (result == 0);
+  }
+
  // testJsonLibDirect();
  // testDummyParams();
  if (doTestProtHandler) {
    testProtHandler();
  }
-  FsOpCodes opCode = FsOpCodes::APPEND_TO_FILE;
-  testFileSystemHandlerDirect(opCode);
+  if (DO_TEST_FS_HANDLER) {
+    FsOpCodes opCode = FsOpCodes::CREATE_EMPTY_FILE_IN_TMP;
+    testFileSystemHandlerDirect(opCode);
+  }
  return TestTask::performOneShotAction();
 }

@ -95,23 +132,23 @@ void Q7STestTask::fileTests() {

 void Q7STestTask::testScratchApi() {
  ReturnValue_t result = scratch::writeNumber("TEST", 1);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::debug << "Q7STestTask::scratchApiTest: Writing number failed" << std::endl;
  }
  int number = 0;
  result = scratch::readNumber("TEST", number);
  sif::info << "Q7STestTask::testScratchApi: Value for key \"TEST\": " << number << std::endl;
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::debug << "Q7STestTask::scratchApiTest: Reading number failed" << std::endl;
  }

  result = scratch::writeString("TEST2", "halloWelt");
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::debug << "Q7STestTask::scratchApiTest: Writing string failed" << std::endl;
  }
  std::string string;
  result = scratch::readString("TEST2", string);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::debug << "Q7STestTask::scratchApiTest: Reading number failed" << std::endl;
  }
  sif::info << "Q7STestTask::testScratchApi: Value for key \"TEST2\": " << string << std::endl;
@ -143,7 +180,7 @@ void Q7STestTask::testDummyParams() {
  }

  ReturnValue_t result = param.readJsonFile();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
  }

  param.setValue(DummyParameter::DUMMY_KEY_PARAM_1, 3);
@ -154,13 +191,13 @@ void Q7STestTask::testDummyParams() {

  int test = 0;
  result = param.getValue<int>(DummyParameter::DUMMY_KEY_PARAM_1, test);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::warning << "Q7STestTask::testDummyParams: Key " << DummyParameter::DUMMY_KEY_PARAM_1
                 << " does not exist" << std::endl;
  }
  std::string test2;
  result = param.getValue<std::string>(DummyParameter::DUMMY_KEY_PARAM_2, test2);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::warning << "Q7STestTask::testDummyParams: Key " << DummyParameter::DUMMY_KEY_PARAM_1
                 << " does not exist" << std::endl;
  }
@ -179,18 +216,18 @@ ReturnValue_t Q7STestTask::initialize() {

 void Q7STestTask::testProtHandler() {
  bool opPerformed = false;
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
  // If any chips are unlocked, lock them here
  result = coreController->setBootCopyProtection(xsc::Chip::ALL_CHIP, xsc::Copy::ALL_COPY, true,
                                                 opPerformed, true);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
  }

  // unlock own copy
  result = coreController->setBootCopyProtection(xsc::Chip::SELF_CHIP, xsc::Copy::SELF_COPY, false,
                                                 opPerformed, true);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
  }
  if (not opPerformed) {
@ -204,7 +241,7 @@ void Q7STestTask::testProtHandler() {
  // lock own copy
  result = coreController->setBootCopyProtection(xsc::Chip::SELF_CHIP, xsc::Copy::SELF_COPY, true,
                                                 opPerformed, true);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
  }
  if (not opPerformed) {
@ -218,7 +255,7 @@ void Q7STestTask::testProtHandler() {
  // unlock specific copy
  result = coreController->setBootCopyProtection(xsc::Chip::CHIP_1, xsc::Copy::COPY_1, false,
                                                 opPerformed, true);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
  }
  if (not opPerformed) {
@ -232,7 +269,7 @@ void Q7STestTask::testProtHandler() {
  // lock specific copy
  result = coreController->setBootCopyProtection(xsc::Chip::CHIP_1, xsc::Copy::COPY_1, true,
                                                 opPerformed, true);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
  }
  if (not opPerformed) {
@ -335,150 +372,28 @@ void Q7STestTask::testGpsDaemonSocket() {
 }

 void Q7STestTask::testFileSystemHandlerDirect(FsOpCodes opCode) {
-  auto fsHandler = ObjectManager::instance()->get<FileSystemHandler>(objects::FILE_SYSTEM_HANDLER);
-  if (fsHandler == nullptr) {
-    sif::warning << "Q7STestTask::testFileSystemHandlerDirect: No FS handler running.."
-                 << std::endl;
-  }
-  FileSystemHandler::FsCommandCfg cfg = {};
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-
-  // Lambda for common code
-  auto createNonEmptyTmpDir = [&]() {
-    if (not std::filesystem::exists("/tmp/test")) {
-      result = fsHandler->createDirectory("/tmp", "test", false, &cfg);
-      if (result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-      }
+  HostFilesystem hostFs;
+  auto* sdcMan = SdCardManager::instance();
+  std::string mountPrefix = sdcMan->getCurrentMountPrefix();
+  sif::info << "Current mount prefix: " << mountPrefix << std::endl;
+  auto prefixedPath = fshelpers::getPrefixedPath(*sdcMan, "conf/test.txt");
+  sif::info << "Prefixed path: " << prefixedPath << std::endl;
+  if (opCode == FsOpCodes::CREATE_EMPTY_FILE_IN_TMP) {
+    FilesystemParams params("/tmp/hello.txt");
+    auto res = hostFs.createFile(params);
+    if (res != OK) {
+      sif::warning << "Creating empty file in /tmp failed" << std::endl;
    }
-    // Creating sample files
-    sif::info << "Creating sample files in directory" << std::endl;
-    result = fsHandler->createFile("/tmp/test", "test1.txt", nullptr, 0, &cfg);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-      return result;
-    }
-    result = fsHandler->createFile("/tmp/test", "test2.txt", nullptr, 0, &cfg);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-      return result;
-    }
-    return result;
-  };
-
-  switch (opCode) {
-    case (FsOpCodes::CREATE_EMPTY_FILE_IN_TMP): {
-      // No mount prefix, cause file is created in tmp
-      cfg.useMountPrefix = false;
-      sif::info << "Creating empty file in /tmp folder" << std::endl;
-      // Do not delete file, user can check existence in shell
-      fsHandler->createFile("/tmp/", "test.txt", nullptr, 0, &cfg);
-      break;
-    }
-    case (FsOpCodes::REMOVE_TMP_FILE): {
-      sif::info << "Deleting /tmp/test.txt sample file" << std::endl;
-      // No mount prefix, cause file is created in tmp
-      cfg.useMountPrefix = false;
-      if (not std::filesystem::exists("/tmp/test.txt")) {
-        // Creating sample file
-        sif::info << "Creating sample file /tmp/test.txt to delete" << std::endl;
-        fsHandler->createFile("/tmp/", "test.txt", nullptr, 0, &cfg);
-      }
-      result = fsHandler->removeFile("/tmp", "test.txt", &cfg);
-      if (result == HasReturnvaluesIF::RETURN_OK) {
-        sif::info << "File removed successfully" << std::endl;
-      } else {
-        sif::warning << "File removal failed!" << std::endl;
-      }
-      break;
-    }
-    case (FsOpCodes::CREATE_DIR_IN_TMP): {
-      // No mount prefix, cause file is created in tmp
-      cfg.useMountPrefix = false;
-      sif::info << "Creating empty file in /tmp folder" << std::endl;
-      // Do not delete file, user can check existence in shell
-      ReturnValue_t result = fsHandler->createDirectory("/tmp/", "test", false, &cfg);
-      if (result == HasReturnvaluesIF::RETURN_OK) {
-        sif::info << "Directory created successfully" << std::endl;
-      } else {
-        sif::warning << "Directory creation failed!" << std::endl;
-      }
-      break;
-    }
-    case (FsOpCodes::REMOVE_EMPTY_DIR_IN_TMP): {
-      // No mount prefix, cause file is created in tmp
-      cfg.useMountPrefix = false;
-      if (not std::filesystem::exists("/tmp/test")) {
-        result = fsHandler->createDirectory("/tmp", "test", false, &cfg);
-      } else {
-        // Delete any leftover files to regular dir removal works
-        std::remove("/tmp/test/*");
-      }
-      result = fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
-      if (result == HasReturnvaluesIF::RETURN_OK) {
-        sif::info << "Directory removed successfully" << std::endl;
-      } else {
-        sif::warning << "Directory removal failed!" << std::endl;
-      }
-      break;
-    }
-    case (FsOpCodes::REMOVE_FILLED_DIR_IN_TMP): {
-      result = createNonEmptyTmpDir();
-      if (result != HasReturnvaluesIF::RETURN_OK) {
-        return;
-      }
-      result = fsHandler->removeDirectory("/tmp/", "test", true, &cfg);
-      if (result == HasReturnvaluesIF::RETURN_OK) {
-        sif::info << "Directory removed recursively successfully" << std::endl;
-      } else {
-        sif::warning << "Recursive directory removal failed!" << std::endl;
-      }
-      break;
-    }
-    case (FsOpCodes::ATTEMPT_DIR_REMOVAL_NON_EMPTY): {
-      result = createNonEmptyTmpDir();
-      if (result != HasReturnvaluesIF::RETURN_OK) {
-        return;
-      }
-      result = fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
-      if (result != HasReturnvaluesIF::RETURN_OK) {
-        sif::info << "Directory removal attempt failed as expected" << std::endl;
-      } else {
-        sif::warning << "Directory removal worked when it should not have!" << std::endl;
-      }
-      break;
-    }
-    case (FsOpCodes::RENAME_FILE): {
-      // No mount prefix, cause file is created in tmp
-      cfg.useMountPrefix = false;
-      if (std::filesystem::exists("/tmp/test.txt")) {
-        fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
-      }
-      sif::info << "Creating empty file /tmp/test.txt and rename to /tmp/test2.txt" << std::endl;
-      // Do not delete file, user can check existence in shell
-      fsHandler->createFile("/tmp/", "test.txt", nullptr, 0, &cfg);
-      fsHandler->renameFile("/tmp/", "test.txt", "test2.txt", &cfg);
-      break;
-    }
-    case (FsOpCodes::APPEND_TO_FILE): {
-      // No mount prefix, cause file is created in tmp
-      cfg.useMountPrefix = false;
-      if (std::filesystem::exists("/tmp/test.txt")) {
-        fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
-      }
-      if (std::filesystem::exists("/tmp/test.txt")) {
-        fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
-      }
-      sif::info << "Creating empty file /tmp/test.txt and adding content" << std::endl;
-      std::string content = "Hello World\n";
-      // Do not delete file, user can check existence in shell
-      fsHandler->createFile("/tmp/", "test.txt", nullptr, 0, &cfg);
-      fsHandler->appendToFile("/tmp/", "test.txt", reinterpret_cast<const uint8_t*>(content.data()),
-                              content.size(), 0, &cfg);
+    bool fileExists = std::filesystem::exists("/tmp/hello.txt");
+    if (not fileExists) {
+      sif::warning << "File was not created!" << std::endl;
    }
+    hostFs.removeFile("/tmp/hello.txt");
  }
 }

 void Q7STestTask::xadcTest() {
-  ReturnValue_t result = RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
  float temperature = 0;
  float vccPint = 0;
  float vccPaux = 0;
@ -490,39 +405,39 @@ void Q7STestTask::xadcTest() {
  float vrefn = 0;
  Xadc xadc;
  result = xadc.getTemperature(temperature);
-  if (result == HasReturnvaluesIF::RETURN_OK) {
+  if (result == returnvalue::OK) {
    sif::info << "Q7STestTask::xadcTest: Chip Temperature: " << temperature << " °C" << std::endl;
  }
  result = xadc.getVccPint(vccPint);
-  if (result == HasReturnvaluesIF::RETURN_OK) {
+  if (result == returnvalue::OK) {
    sif::info << "Q7STestTask::xadcTest: VCC PS internal: " << vccPint << " mV" << std::endl;
  }
  result = xadc.getVccPaux(vccPaux);
-  if (result == HasReturnvaluesIF::RETURN_OK) {
+  if (result == returnvalue::OK) {
    sif::info << "Q7STestTask::xadcTest: VCC PS auxilliary: " << vccPaux << " mV" << std::endl;
  }
  result = xadc.getVccInt(vccInt);
-  if (result == HasReturnvaluesIF::RETURN_OK) {
+  if (result == returnvalue::OK) {
    sif::info << "Q7STestTask::xadcTest: VCC PL internal: " << vccInt << " mV" << std::endl;
  }
  result = xadc.getVccAux(vccAux);
-  if (result == HasReturnvaluesIF::RETURN_OK) {
+  if (result == returnvalue::OK) {
    sif::info << "Q7STestTask::xadcTest: VCC PL auxilliary: " << vccAux << " mV" << std::endl;
  }
  result = xadc.getVccBram(vccBram);
-  if (result == HasReturnvaluesIF::RETURN_OK) {
+  if (result == returnvalue::OK) {
    sif::info << "Q7STestTask::xadcTest: VCC BRAM: " << vccBram << " mV" << std::endl;
  }
  result = xadc.getVccOddr(vccOddr);
-  if (result == HasReturnvaluesIF::RETURN_OK) {
+  if (result == returnvalue::OK) {
    sif::info << "Q7STestTask::xadcTest: VCC PS I/O DDR : " << vccOddr << " mV" << std::endl;
  }
  result = xadc.getVrefp(vrefp);
-  if (result == HasReturnvaluesIF::RETURN_OK) {
+  if (result == returnvalue::OK) {
    sif::info << "Q7STestTask::xadcTest: Vrefp : " << vrefp << " mV" << std::endl;
  }
  result = xadc.getVrefn(vrefn);
-  if (result == HasReturnvaluesIF::RETURN_OK) {
+  if (result == returnvalue::OK) {
    sif::info << "Q7STestTask::xadcTest: Vrefn : " << vrefn << " mV" << std::endl;
  }
 }
--- a/bsp_q7s/boardtest/Q7STestTask.h
+++ b/bsp_q7s/boardtest/Q7STestTask.h
@ -16,6 +16,9 @@ class Q7STestTask : public TestTask {
 private:
  bool doTestSdCard = false;
  bool doTestScratchApi = false;
+  static constexpr bool DO_TEST_GOMSPACE_API = false;
+  static constexpr bool DO_TEST_GOMSPACE_GET_CONFIG = false;
+  static constexpr bool DO_TEST_FS_HANDLER = false;
  bool doTestGpsShm = false;
  bool doTestGpsSocket = false;
  bool doTestProtHandler = false;
--- a/bsp_q7s/callbacks/gnssCallback.cpp
+++ b/bsp_q7s/callbacks/gnssCallback.cpp
@ -11,10 +11,10 @@ ReturnValue_t gps::triggerGpioResetPin(const uint8_t* actionData, size_t len, vo
  }
  ResetArgs* resetArgs = reinterpret_cast<ResetArgs*>(args);
  if (args == nullptr) {
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
  }
  if (resetArgs->gpioComIF == nullptr) {
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
  }
  gpioId_t gpioId;
  if (actionData[0] == 0) {
@ -25,5 +25,5 @@ ReturnValue_t gps::triggerGpioResetPin(const uint8_t* actionData, size_t len, vo
  resetArgs->gpioComIF->pullLow(gpioId);
  TaskFactory::delayTask(resetArgs->waitPeriodMs);
  resetArgs->gpioComIF->pullHigh(gpioId);
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
--- a/bsp_q7s/callbacks/gnssCallback.h
+++ b/bsp_q7s/callbacks/gnssCallback.h
@ -1,7 +1,7 @@
 #ifndef BSP_Q7S_CALLBACKS_GNSSCALLBACK_H_
 #define BSP_Q7S_CALLBACKS_GNSSCALLBACK_H_

-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"

 struct ResetArgs {
--- a/bsp_q7s/callbacks/q7sGpioCallbacks.cpp
+++ b/bsp_q7s/callbacks/q7sGpioCallbacks.cpp
@ -47,7 +47,7 @@ void q7s::gpioCallbacks::initSpiCsDecoder(GpioIF* gpioComIF) {
  spiMuxGpios->addGpio(gpioIds::EN_RW_CS, enRwDecoder);

  result = gpioComIF->addGpios(spiMuxGpios);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "initSpiCsDecoder: Failed to add SPI MUX bit GPIOs" << std::endl;
    return;
  }
--- a/bsp_q7s/callbacks/rwSpiCallback.cpp
+++ b/bsp_q7s/callbacks/rwSpiCallback.cpp
@ -29,32 +29,32 @@ void closeSpi(int fd, gpioId_t gpioId, GpioIF* gpioIF, MutexIF* mutex);
 ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sendData,
                          size_t sendLen, void* args) {
  // Stopwatch watch;
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;

  RwHandler* handler = reinterpret_cast<RwHandler*>(args);
  if (handler == nullptr) {
    sif::error << "rwSpiCallback::spiCallback: Pointer to handler is invalid" << std::endl;
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
  }

  uint8_t writeBuffer[2] = {};
  uint8_t writeSize = 0;

  gpioId_t gpioId = cookie->getChipSelectPin();
-  GpioIF* gpioIF = comIf->getGpioInterface();
+  GpioIF& gpioIF = comIf->getGpioInterface();
  MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
  uint32_t timeoutMs = 0;
  MutexIF* mutex = comIf->getCsMutex();
  cookie->getMutexParams(timeoutType, timeoutMs);
-  if (mutex == nullptr or gpioIF == nullptr) {
+  if (mutex == nullptr) {
    sif::debug << "rwSpiCallback::spiCallback: Mutex or GPIO interface invalid" << std::endl;
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
  }

  int fileDescriptor = 0;
  const std::string& dev = comIf->getSpiDev();
-  result = openSpi(dev, O_RDWR, gpioIF, gpioId, mutex, timeoutType, timeoutMs, fileDescriptor);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  result = openSpi(dev, O_RDWR, &gpioIF, gpioId, mutex, timeoutType, timeoutMs, fileDescriptor);
+  if (result != returnvalue::OK) {
    return result;
  }

@ -75,7 +75,7 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen

  if (write(fileDescriptor, writeBuffer, writeSize) != static_cast<ssize_t>(writeSize)) {
    sif::error << "rwSpiCallback::spiCallback: Write failed!" << std::endl;
-    closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+    closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
    return RwHandler::SPI_WRITE_FAILURE;
  }

@ -100,7 +100,7 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
    }
    if (write(fileDescriptor, writeBuffer, writeSize) != static_cast<ssize_t>(writeSize)) {
      sif::error << "rwSpiCallback::spiCallback: Write failed!" << std::endl;
-      closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+      closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
      return RwHandler::SPI_WRITE_FAILURE;
    }
    idx++;
@ -112,14 +112,14 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen

  if (write(fileDescriptor, writeBuffer, writeSize) != static_cast<ssize_t>(writeSize)) {
    sif::error << "rwSpiCallback::spiCallback: Write failed!" << std::endl;
-    closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+    closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
    return RwHandler::SPI_WRITE_FAILURE;
  }

  uint8_t* rxBuf = nullptr;
  result = comIf->getReadBuffer(cookie->getSpiAddress(), &rxBuf);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
-    closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+  if (result != returnvalue::OK) {
+    closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
    return result;
  }

@ -127,10 +127,10 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen

  // There must be a delay of at least 20 ms after sending the command.
  // Delay for 70 ms here and release the SPI bus for that duration.
-  closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+  closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
  usleep(RwDefinitions::SPI_REPLY_DELAY);
-  result = openSpi(dev, O_RDWR, gpioIF, gpioId, mutex, timeoutType, timeoutMs, fileDescriptor);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  result = openSpi(dev, O_RDWR, &gpioIF, gpioId, mutex, timeoutType, timeoutMs, fileDescriptor);
+  if (result != returnvalue::OK) {
    return result;
  }

@ -142,13 +142,13 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
  for (int idx = 0; idx < 10; idx++) {
    if (read(fileDescriptor, &byteRead, 1) != 1) {
      sif::error << "rwSpiCallback::spiCallback: Read failed" << std::endl;
-      closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+      closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
      return RwHandler::SPI_READ_FAILURE;
    }
    if (idx == 0) {
      if (byteRead != FLAG_BYTE) {
        sif::error << "Invalid data, expected start marker" << std::endl;
-        closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+        closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
        return RwHandler::NO_START_MARKER;
      }
    }
@ -159,7 +159,7 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen

    if (idx == 9) {
      sif::error << "rwSpiCallback::spiCallback: Empty frame timeout" << std::endl;
-      closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+      closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
      return RwHandler::NO_REPLY;
    }
  }
@ -199,7 +199,7 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
        continue;
      } else {
        sif::error << "rwSpiCallback::spiCallback: Invalid substitute" << std::endl;
-        closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+        closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
        result = RwHandler::INVALID_SUBSTITUTE;
        break;
      }
@ -228,12 +228,12 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
        break;
      }
    }
-    result = HasReturnvaluesIF::RETURN_OK;
+    result = returnvalue::OK;
  }

  cookie->setTransferSize(decodedFrameLen);

-  closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+  closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);

  return result;
 }
@ -244,7 +244,7 @@ ReturnValue_t openSpi(const std::string& devname, int flags, GpioIF* gpioIF, gpi
                      MutexIF* mutex, MutexIF::TimeoutType timeoutType, uint32_t timeoutMs,
                      int& fd) {
  ReturnValue_t result = mutex->lockMutex(timeoutType, timeoutMs);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::debug << "rwSpiCallback::spiCallback: Failed to lock mutex" << std::endl;
    return result;
  }
@ -258,21 +258,21 @@ ReturnValue_t openSpi(const std::string& devname, int flags, GpioIF* gpioIF, gpi
  // Pull SPI CS low. For now, no support for active high given
  if (gpioId != gpio::NO_GPIO) {
    result = gpioIF->pullLow(gpioId);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
      sif::error << "rwSpiCallback::spiCallback: Failed to pull chip select low" << std::endl;
      return result;
    }
  }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 void closeSpi(int fd, gpioId_t gpioId, GpioIF* gpioIF, MutexIF* mutex) {
  close(fd);
  if (gpioId != gpio::NO_GPIO) {
-    if (gpioIF->pullHigh(gpioId) != HasReturnvaluesIF::RETURN_OK) {
+    if (gpioIF->pullHigh(gpioId) != returnvalue::OK) {
      sif::error << "closeSpi: Failed to pull chip select high" << std::endl;
    }
  }
-  if (mutex->unlockMutex() != HasReturnvaluesIF::RETURN_OK) {
+  if (mutex->unlockMutex() != returnvalue::OK) {
    sif::error << "rwSpiCallback::closeSpi: Failed to unlock mutex" << std::endl;
    ;
  }
--- a/bsp_q7s/callbacks/rwSpiCallback.h
+++ b/bsp_q7s/callbacks/rwSpiCallback.h
@ -1,7 +1,7 @@
 #ifndef BSP_Q7S_RW_SPI_CALLBACK_H_
 #define BSP_Q7S_RW_SPI_CALLBACK_H_

-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw_hal/common/gpio/GpioCookie.h"
 #include "fsfw_hal/linux/spi/SpiComIF.h"

--- a/bsp_q7s/core/CoreController.cpp
+++ b/bsp_q7s/core/CoreController.cpp
--- a/bsp_q7s/core/CoreController.h
+++ b/bsp_q7s/core/CoreController.h
@ -7,7 +7,8 @@
 #include <cstddef>

 #include "CoreDefinitions.h"
-#include "bsp_q7s/memory/SdCardManager.h"
+#include "OBSWConfig.h"
+#include "bsp_q7s/fs/SdCardManager.h"
 #include "events/subsystemIdRanges.h"
 #include "fsfw/controller/ExtendedControllerBase.h"
 #include "mission/devices/devicedefinitions/GPSDefinitions.h"
@ -51,22 +52,41 @@ class CoreController : public ExtendedControllerBase {
  static constexpr char CHIP_PROT_SCRIPT[] = "get-chip-prot-status.sh";
  static constexpr char CHIP_STATE_FILE[] = "/tmp/chip_prot_status.txt";
  static constexpr char CURR_COPY_FILE[] = "/tmp/curr_copy.txt";
+
  static constexpr char CONF_FOLDER[] = "conf";
+
  static constexpr char VERSION_FILE_NAME[] = "version.txt";
  static constexpr char REBOOT_FILE_NAME[] = "reboot.txt";
  static constexpr char TIME_FILE_NAME[] = "time.txt";
+
  const std::string VERSION_FILE =
      "/" + std::string(CONF_FOLDER) + "/" + std::string(VERSION_FILE_NAME);
  const std::string REBOOT_FILE =
      "/" + std::string(CONF_FOLDER) + "/" + std::string(REBOOT_FILE_NAME);
  const std::string TIME_FILE = "/" + std::string(CONF_FOLDER) + "/" + std::string(TIME_FILE_NAME);

+  static constexpr char CHIP_0_COPY_0_MOUNT_DIR[] = "/tmp/mntupdate-xdi-qspi0-nom-rootfs";
+  static constexpr char CHIP_0_COPY_1_MOUNT_DIR[] = "/tmp/mntupdate-xdi-qspi0-gold-rootfs";
+  static constexpr char CHIP_1_COPY_0_MOUNT_DIR[] = "/tmp/mntupdate-xdi-qspi1-nom-rootfs";
+  static constexpr char CHIP_1_COPY_1_MOUNT_DIR[] = "/tmp/mntupdate-xdi-qspi1-gold-rootfs";
+
+  static constexpr dur_millis_t INIT_SD_CARD_CHECK_TIMEOUT = 5000;
+  static constexpr dur_millis_t DEFAULT_SD_CARD_CHECK_TIMEOUT = 60000;
+
  static constexpr ActionId_t LIST_DIRECTORY_INTO_FILE = 0;
  static constexpr ActionId_t SWITCH_REBOOT_FILE_HANDLING = 5;
  static constexpr ActionId_t RESET_REBOOT_COUNTERS = 6;
  static constexpr ActionId_t SWITCH_IMG_LOCK = 7;
  static constexpr ActionId_t SET_MAX_REBOOT_CNT = 8;

+  static constexpr ActionId_t OBSW_UPDATE_FROM_SD_0 = 10;
+  static constexpr ActionId_t OBSW_UPDATE_FROM_SD_1 = 11;
+  static constexpr ActionId_t OBSW_UPDATE_FROM_TMP = 12;
+
+  static constexpr ActionId_t SWITCH_TO_SD_0 = 16;
+  static constexpr ActionId_t SWITCH_TO_SD_1 = 17;
+  static constexpr ActionId_t SWITCH_TO_BOTH_SD_CARDS = 18;
+
  //! Reboot using the xsc_boot_copy command
  static constexpr ActionId_t XSC_REBOOT_OBC = 32;
  static constexpr ActionId_t MOUNT_OTHER_COPY = 33;
@ -86,6 +106,9 @@ class CoreController : public ExtendedControllerBase {
      event::makeEvent(SUBSYSTEM_ID, 2, severity::MEDIUM);
  //! Trying to find a way how to determine that the reboot came from ProASIC3 or PCDU..
  static constexpr Event REBOOT_HW = event::makeEvent(SUBSYSTEM_ID, 3, severity::MEDIUM);
+  //! [EXPORT] : [COMMENT] No SD card was active. Core controller will attempt to re-initialize
+  //! a SD card.
+  static constexpr Event NO_SD_CARD_ACTIVE = event::makeEvent(SUBSYSTEM_ID, 4, severity::HIGH);

  CoreController(object_id_t objectId);
  virtual ~CoreController();
@ -107,6 +130,7 @@ class CoreController : public ExtendedControllerBase {
  static ReturnValue_t generateChipStateFile();
  static ReturnValue_t incrementAllocationFailureCount();
  static void getCurrentBootCopy(xsc::Chip& chip, xsc::Copy& copy);
+  static const char* getXscMountDir(xsc::Chip chip, xsc::Copy copy);

  ReturnValue_t updateProtInfo(bool regenerateChipStateFile = true);

@ -151,39 +175,46 @@ class CoreController : public ExtendedControllerBase {
    SKIP_CYCLE_BEFORE_INFO_UPDATE,
    UPDATE_INFO,
    // SD initialization done
-    IDLE,
-    // Used if SD switches or mount commands are issued via telecommand
-    SET_STATE_FROM_COMMAND,
+    IDLE
  };
+
+  enum class SwUpdateSources { SD_0, SD_1, TMP_DIR };
+
  static constexpr bool BLOCKING_SD_INIT = false;

  SdCardManager* sdcMan = nullptr;
  MessageQueueIF* eventQueue = nullptr;

-  struct SdInfo {
-    sd::SdCard pref = sd::SdCard::NONE;
+  SdStates sdFsmState = SdStates::START;
+  enum SdCfgMode { PASSIVE, COLD_REDUNDANT, HOT_REDUNDANT };
+
+  struct SdFsmParams {
+    SdCfgMode cfgMode = SdCfgMode::COLD_REDUNDANT;
+    sd::SdCard active = sd::SdCard::NONE;
    sd::SdCard other = sd::SdCard::NONE;
-    sd::SdState prefState = sd::SdState::OFF;
+    sd::SdState activeState = sd::SdState::OFF;
    sd::SdState otherState = sd::SdState::OFF;
-    std::string prefChar = "0";
+    std::string activeChar = "0";
    std::string otherChar = "1";
    std::pair<bool, bool> mountSwitch = {true, true};
-    SdStates state = SdStates::START;
    // Used to track whether a command was executed
    bool commandExecuted = true;
    bool initFinished = false;
    SdCardManager::SdStatePair currentState;
    uint16_t cycleCount = 0;
-    // These two flags are related to external commanding
-    bool commandIssued = false;
-    bool commandFinished = false;
-    sd::SdState currentlyCommandedState = sd::SdState::OFF;
-    sd::SdCard commandedCard = sd::SdCard::NONE;
-    sd::SdState commandedState = sd::SdState::OFF;
  } sdInfo;
+
+  struct SdCommanding {
+    bool cmdPending = false;
+    MessageQueueId_t commander = MessageQueueIF::NO_QUEUE;
+    DeviceCommandId_t actionId;
+  } sdCommandingInfo;
+
  RebootFile rebootFile = {};
  std::string currMntPrefix;
-  bool performOneShotSdCardOpsSwitch = true;
+  bool performOneShotSdCardOpsSwitch = false;
+  uint8_t shortSdCardCdCounter = 0;
+  Countdown sdCardCheckCd = Countdown(INIT_SD_CARD_CHECK_TIMEOUT);

  /**
   * Index 0: Chip 0 Copy 0
@ -195,11 +226,19 @@ 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
+  bool remountAttemptFlag = true;
+#endif
+
  ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                        LocalDataPoolManager& poolManager) override;
-  Countdown sdCardCheckCd = Countdown(120000);
+
  LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode, uint32_t* msToReachTheMode);
  void performMountedSdCardOperations();
@ -208,15 +247,18 @@ 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,
+                           DeviceCommandId_t actionId);
  void initPrint();

  ReturnValue_t sdStateMachine();
  void updateSdInfoOther();
  ReturnValue_t sdCardSetup(sd::SdCard sdCard, sd::SdState targetState, std::string sdChar,
                            bool printOutput = true);
+  ReturnValue_t executeSwUpdate(SwUpdateSources sourceDir, const uint8_t* data, size_t size);
  ReturnValue_t sdColdRedundantBlockingInit();

  void currentStateSetter(sd::SdCard sdCard, sd::SdState newState);
--- a/bsp_q7s/core/InitMission.cpp
+++ b/bsp_q7s/core/InitMission.cpp
@ -1,6 +1,7 @@
 #include "bsp_q7s/core/InitMission.h"

 #include <fsfw/devicehandlers/DeviceCommunicationIF.h>
+#include <linux/InitMission.h>

 #include <iostream>
 #include <vector>
@ -10,7 +11,7 @@
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/objectmanager/ObjectManagerIF.h"
 #include "fsfw/platform.h"
-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw/serviceinterface/ServiceInterfaceStream.h"
 #include "fsfw/tasks/FixedTimeslotTaskIF.h"
 #include "fsfw/tasks/PeriodicTaskIF.h"
@ -55,7 +56,7 @@ void initmission::initMission() {

 void initmission::initTasks() {
  TaskFactory* factory = TaskFactory::instance();
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
  if (factory == nullptr) {
    /* Should never happen ! */
    return;
@ -66,102 +67,139 @@ void initmission::initTasks() {
  void (*missedDeadlineFunc)(void) = nullptr;
 #endif

-  PeriodicTaskIF* coreController = factory->createPeriodicTask(
+#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.
+  PeriodicTaskIF* solarArrayDeplTask = factory->createPeriodicTask(
+      "SOLAR_ARRAY_DEPL", 65, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc);
+  result = solarArrayDeplTask->addComponent(objects::SOLAR_ARRAY_DEPL_HANDLER);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("SOLAR_ARRAY_DEPL", objects::SOLAR_ARRAY_DEPL_HANDLER);
+  }
+#endif
+
+  PeriodicTaskIF* sysTask = factory->createPeriodicTask(
      "CORE_CTRL", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc);
-  result = coreController->addComponent(objects::CORE_CONTROLLER);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  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", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+      "DIST", 45, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+#if OBSW_ADD_TCPIP_BRIDGE == 1
+  result = tmTcDistributor->addComponent(objects::TMTC_BRIDGE);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("TMTC_BRIDGE", objects::TMTC_BRIDGE);
+  }
+#endif
  result = tmTcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("CCSDS_DISTRIB", objects::CCSDS_PACKET_DISTRIBUTOR);
  }
  result = tmTcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS_PACKET_DISTRIB", objects::PUS_PACKET_DISTRIBUTOR);
  }
+  result = tmTcDistributor->addComponent(objects::CFDP_DISTRIBUTOR);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("CFDP_DISTRIBUTOR", objects::CFDP_DISTRIBUTOR);
+  }
  result = tmTcDistributor->addComponent(objects::TM_FUNNEL);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("TM_FUNNEL", objects::TM_FUNNEL);
  }

 #if OBSW_ADD_TCPIP_BRIDGE == 1
-  // TMTC bridge
-  PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask(
-      "TCPIP_TMTC_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
-  result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
-    initmission::printAddObjectError("TMTC_BRIDGE", objects::TMTC_BRIDGE);
-  }
  PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask(
      "TMTC_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
  result = tmtcPollingTask->addComponent(objects::TMTC_POLLING_TASK);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("UDP_POLLING", objects::TMTC_POLLING_TASK);
  }
 #endif

-#if OBSW_USE_CCSDS_IP_CORE == 1
+#if OBSW_ADD_CCSDS_IP_CORES == 1
  PeriodicTaskIF* ccsdsHandlerTask = factory->createPeriodicTask(
      "CCSDS_HANDLER", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
  result = ccsdsHandlerTask->addComponent(objects::CCSDS_HANDLER);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    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 != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PDEC Handler", objects::PDEC_HANDLER);
  }
-#endif /* OBSW_USE_CCSDS_IP_CORE == 1 */
+#endif /* OBSW_ADD_CCSDS_IP_CORE == 1 */

-#if OBSW_ADD_ACS_HANDLERS == 1
-  PeriodicTaskIF* acsTask = factory->createPeriodicTask(
+#if OBSW_ADD_CFDP_COMPONENTS == 1
+  PeriodicTaskIF* cfdpTask = factory->createPeriodicTask(
+      "CFDP Handler", 45, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc);
+  result = cfdpTask->addComponent(objects::CFDP_HANDLER);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("CFDP Handler", objects::CFDP_HANDLER);
+  }
+#endif
+
+  PeriodicTaskIF* acsCtrlTask = factory->createPeriodicTask(
      "ACS_TASK", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
-  result = acsTask->addComponent(objects::GPS_CONTROLLER);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+#if OBSW_ADD_GPS_CTRL == 1
+  result = acsCtrlTask->addComponent(objects::GPS_CONTROLLER);
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("GPS_CTRL", objects::GPS_CONTROLLER);
  }
-#endif /* OBSW_ADD_ACS_HANDLERS */
+#endif /* OBSW_ADD_GPS_CTRL */

-  PeriodicTaskIF* sysTask = factory->createPeriodicTask(
+#if OBSW_ADD_ACS_CTRL == 1
+  acsCtrlTask->addComponent(objects::ACS_CONTROLLER);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("ACS_CTRL", objects::ACS_CONTROLLER);
+  }
+#endif
+
+  PeriodicTaskIF* acsSysTask = factory->createPeriodicTask(
      "SYS_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
-  static_cast<void>(sysTask);
-#if OBSW_ADD_ACS_HANDLERS == 1
-  result = sysTask->addComponent(objects::ACS_BOARD_ASS);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  static_cast<void>(acsSysTask);
+#if OBSW_ADD_ACS_BOARD == 1
+  result = acsSysTask->addComponent(objects::ACS_BOARD_ASS);
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("ACS_BOARD_ASS", objects::ACS_BOARD_ASS);
  }
 #endif /* OBSW_ADD_ACS_HANDLERS */
 #if OBSW_ADD_RW == 1
-  result = sysTask->addComponent(objects::RW_ASS);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  result = acsSysTask->addComponent(objects::RW_ASS);
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("RW_ASS", objects::RW_ASS);
  }
 #endif
 #if OBSW_ADD_SUS_BOARD_ASS == 1
-  result = sysTask->addComponent(objects::SUS_BOARD_ASS);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  result = acsSysTask->addComponent(objects::SUS_BOARD_ASS);
+  if (result != returnvalue::OK) {
    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(
      "TCS_POLLING_TASK", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.5, missedDeadlineFunc);
  result = tcsPollingTask->addComponent(objects::SPI_RTD_COM_IF);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  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 = {
@ -182,8 +220,7 @@ void initmission::initTasks() {
      objects::RTD_14_IC17_TCS_BOARD,
      objects::RTD_15_IC18_IMTQ,
  };
-  tcsTask->addComponent(objects::TCS_BOARD_ASS);
-  tcsTask->addComponent(objects::THERMAL_CONTROLLER);
+
  for (const auto& rtd : rtdIds) {
    tcsTask->addComponent(rtd, DeviceHandlerIF::PERFORM_OPERATION);
    tcsTask->addComponent(rtd, DeviceHandlerIF::SEND_WRITE);
@ -191,22 +228,34 @@ void initmission::initTasks() {
    tcsTask->addComponent(rtd, DeviceHandlerIF::SEND_READ);
    tcsTask->addComponent(rtd, DeviceHandlerIF::GET_READ);
  }
-#endif /* OBSW_ADD_RTD_DEVICES */
+#endif

-  // FS task, task interval does not matter because it runs in permanent loop, priority low
-  // because it is a non-essential background task
-  PeriodicTaskIF* fsTask = factory->createPeriodicTask(
-      "FILE_SYSTEM_TASK", 25, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc);
-  result = fsTask->addComponent(objects::FILE_SYSTEM_HANDLER);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
-    initmission::printAddObjectError("FILE_SYSTEM_TASK", objects::FILE_SYSTEM_HANDLER);
+  PeriodicTaskIF* tcsSystemTask = factory->createPeriodicTask(
+      "TCS_TASK", 45, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.5, missedDeadlineFunc);
+#if OBSW_ADD_RTD_DEVICES == 1
+  result = tcsSystemTask->addComponent(objects::TCS_BOARD_ASS);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("TCS_BOARD_ASS", objects::TCS_BOARD_ASS);
  }
+#endif /* OBSW_ADD_RTD_DEVICES */
+#if OBSW_ADD_TCS_CTRL == 1
+  result = tcsSystemTask->addComponent(objects::THERMAL_CONTROLLER);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("THERMAL_CONTROLLER", objects::THERMAL_CONTROLLER);
+  }
+#endif
+#if OBSW_ADD_HEATERS == 1
+  result = tcsSystemTask->addComponent(objects::HEATER_HANDLER);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("HEATER_HANDLER", objects::HEATER_HANDLER);
+  }
+#endif

 #if OBSW_ADD_STAR_TRACKER == 1
  PeriodicTaskIF* strHelperTask = factory->createPeriodicTask(
      "STR_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
  result = strHelperTask->addComponent(objects::STR_HELPER);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("STR_HELPER", objects::STR_HELPER);
  }
 #endif /* OBSW_ADD_STAR_TRACKER == 1 */
@ -215,7 +264,7 @@ void initmission::initTasks() {
  PeriodicTaskIF* mpsocHelperTask = factory->createPeriodicTask(
      "PLOC_MPSOC_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
  result = mpsocHelperTask->addComponent(objects::PLOC_MPSOC_HELPER);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PLOC_MPSOC_HELPER", objects::PLOC_MPSOC_HELPER);
  }
 #endif /* OBSW_ADD_PLOC_MPSOC */
@ -224,18 +273,20 @@ void initmission::initTasks() {
  PeriodicTaskIF* supvHelperTask = factory->createPeriodicTask(
      "PLOC_SUPV_HELPER", 10, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
  result = supvHelperTask->addComponent(objects::PLOC_SUPERVISOR_HELPER);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PLOC_SUPV_HELPER", objects::PLOC_SUPERVISOR_HELPER);
  }
 #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 != HasReturnvaluesIF::RETURN_OK) {
-    initmission::printAddObjectError("PTME_TEST", objects::CCSDS_IP_CORE_BRIDGE);
-  }
+  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;
+  scheduling::schedulingScex(*factory, scexDevHandler, scexReaderTask);
 #endif

  std::vector<PeriodicTaskIF*> pusTasks;
@ -244,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
@ -262,56 +321,68 @@ void initmission::initTasks() {
  tmTcDistributor->startTask();

 #if OBSW_ADD_TCPIP_BRIDGE == 1
-  tmtcBridgeTask->startTask();
  tmtcPollingTask->startTask();
 #endif

-#if OBSW_USE_CCSDS_IP_CORE == 1
+#if OBSW_ADD_CCSDS_IP_CORES == 1
  ccsdsHandlerTask->startTask();
  pdecHandlerTask->startTask();
-#endif /* OBSW_USE_CCSDS_IP_CORE == 1 */
+#endif /* OBSW_ADD_CCSDS_IP_CORES == 1 */

-  coreController->startTask();
+  sysTask->startTask();
+#if OBSW_ADD_SA_DEPL == 1
+  solarArrayDeplTask->startTask();
+#endif

  taskStarter(pstTasks, "PST task vector");
  taskStarter(pusTasks, "PUS task vector");
-#if OBSW_ADD_TEST_CODE == 1
-  taskStarter(testTasks, "Test task vector");
+#if OBSW_ADD_SCEX_DEVICE == 1
+  scexDevHandler->startTask();
+  scexReaderTask->startTask();
 #endif

 #if OBSW_TEST_CCSDS_BRIDGE == 1
  ptmeTestTask->startTask();
 #endif

-  fsTask->startTask();
+#if OBSW_ADD_CFDP_COMPONENTS == 1
+  cfdpTask->startTask();
+#endif
+
 #if OBSW_ADD_STAR_TRACKER == 1
  strHelperTask->startTask();
 #endif /* OBSW_ADD_STAR_TRACKER == 1 */

-#if OBSW_ADD_ACS_HANDLERS == 1
-  acsTask->startTask();
-#endif /* OBSW_ADD_ACS_HANDLERS == 1 */
-  sysTask->startTask();
+  acsCtrlTask->startTask();
+  acsSysTask->startTask();
 #if OBSW_ADD_RTD_DEVICES == 1
  tcsPollingTask->startTask();
  tcsTask->startTask();
 #endif /* OBSW_ADD_RTD_DEVICES == 1 */
+  if (not tcsSystemTask->isEmpty()) {
+    tcsSystemTask->startTask();
+  }
 #if OBSW_ADD_PLOC_SUPERVISOR == 1
  supvHelperTask->startTask();
 #endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
+
+#if OBSW_ADD_TEST_CODE == 1
+  taskStarter(testTasks, "Test task vector");
+#endif
+
  sif::info << "Tasks started.." << std::endl;
 }

 void initmission::createPstTasks(TaskFactory& factory,
                                 TaskDeadlineMissedFunction missedDeadlineFunc,
                                 std::vector<PeriodicTaskIF*>& taskVec) {
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
  /* Polling Sequence Table Default */
 #if OBSW_ADD_SPI_TEST_CODE == 0
  FixedTimeslotTaskIF* spiPst = factory.createFixedTimeslotTask(
      "MAIN_SPI", 75, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.5, missedDeadlineFunc);
  result = pst::pstSpi(spiPst);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
      sif::warning << "InitMission::initTasks: SPI PST is empty" << std::endl;
    } else {
@ -326,7 +397,7 @@ void initmission::createPstTasks(TaskFactory& factory,
  FixedTimeslotTaskIF* rwPstTask = factory.createFixedTimeslotTask(
      "RW_SPI", 65, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 1.0, missedDeadlineFunc);
  result = pst::pstSpiRw(rwPstTask);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
      sif::warning << "InitMission::initTasks: SPI PST is empty" << std::endl;
    } else {
@ -340,7 +411,7 @@ void initmission::createPstTasks(TaskFactory& factory,
  FixedTimeslotTaskIF* uartPst = factory.createFixedTimeslotTask(
      "UART_PST", 65, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.2, missedDeadlineFunc);
  result = pst::pstUart(uartPst);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
      sif::warning << "InitMission::initTasks: UART PST is empty" << std::endl;
    } else {
@ -350,23 +421,11 @@ void initmission::createPstTasks(TaskFactory& factory,
    taskVec.push_back(uartPst);
  }

-  FixedTimeslotTaskIF* gpioPst = factory.createFixedTimeslotTask(
-      "GPIO_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.2, missedDeadlineFunc);
-  result = pst::pstGpio(gpioPst);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
-    if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
-      sif::warning << "InitMission::initTasks: GPIO PST is empty" << std::endl;
-    } else {
-      sif::error << "InitMission::initTasks: Creating GPIO PST failed!" << std::endl;
-    }
-  } else {
-    taskVec.push_back(gpioPst);
-  }
 #if OBSW_ADD_I2C_TEST_CODE == 0
  FixedTimeslotTaskIF* i2cPst = factory.createFixedTimeslotTask(
      "I2C_PST", 65, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.2, missedDeadlineFunc);
  result = pst::pstI2c(i2cPst);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
      sif::warning << "InitMission::initTasks: I2C PST is empty" << std::endl;
    } else {
@ -381,7 +440,7 @@ void initmission::createPstTasks(TaskFactory& factory,
  FixedTimeslotTaskIF* gomSpacePstTask = factory.createFixedTimeslotTask(
      "GS_PST_TASK", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 1.0, missedDeadlineFunc);
  result = pst::pstGompaceCan(gomSpacePstTask);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    if (result != FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
      sif::error << "InitMission::initTasks: GomSpace PST initialization failed!" << std::endl;
    }
@ -393,12 +452,12 @@ void initmission::createPstTasks(TaskFactory& factory,
 void initmission::createPusTasks(TaskFactory& factory,
                                 TaskDeadlineMissedFunction missedDeadlineFunc,
                                 std::vector<PeriodicTaskIF*>& taskVec) {
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
  /* PUS Services */
  PeriodicTaskIF* pusVerification = factory.createPeriodicTask(
      "PUS_VERIF", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
  result = pusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS_VERIF", objects::PUS_SERVICE_1_VERIFICATION);
  }
  taskVec.push_back(pusVerification);
@ -406,64 +465,66 @@ void initmission::createPusTasks(TaskFactory& factory,
  PeriodicTaskIF* pusEvents = factory.createPeriodicTask(
      "PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
  result = pusEvents->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS_EVENTS", objects::PUS_SERVICE_5_EVENT_REPORTING);
  }
  result = pusEvents->addComponent(objects::EVENT_MANAGER);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS_MGMT", objects::EVENT_MANAGER);
  }
  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 != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS_2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
  }
  result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS_9", objects::PUS_SERVICE_9_TIME_MGMT);
  }
+
  taskVec.push_back(pusHighPrio);

  PeriodicTaskIF* pusMedPrio = factory.createPeriodicTask(
      "PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);

  result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS_3", objects::PUS_SERVICE_3_HOUSEKEEPING);
  }
  result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS_8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
  }
  result = pusMedPrio->addComponent(objects::PUS_SERVICE_11_TC_SCHEDULER);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS_11", objects::PUS_SERVICE_11_TC_SCHEDULER);
  }
  result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS_20", objects::PUS_SERVICE_20_PARAMETERS);
  }
  result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS_200", objects::PUS_SERVICE_200_MODE_MGMT);
  }
  result = pusMedPrio->addComponent(objects::PUS_SERVICE_201_HEALTH);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  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 != HasReturnvaluesIF::RETURN_OK) {
-    initmission::printAddObjectError("PUS_17", objects::PUS_SERVICE_17_TEST);
-  }
  result = pusLowPrio->addComponent(objects::INTERNAL_ERROR_REPORTER);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("ERROR_REPORTER", objects::INTERNAL_ERROR_REPORTER);
  }
  taskVec.push_back(pusLowPrio);
@ -473,32 +534,32 @@ void initmission::createTestTasks(TaskFactory& factory,
                                  TaskDeadlineMissedFunction missedDeadlineFunc,
                                  std::vector<PeriodicTaskIF*>& taskVec) {
 #if OBSW_ADD_TEST_TASK == 1 && OBSW_ADD_TEST_CODE == 1
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
  static_cast<void>(result);  // supress warning in case it is not used

  PeriodicTaskIF* testTask = factory.createPeriodicTask(
      "TEST_TASK", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1, missedDeadlineFunc);

  result = testTask->addComponent(objects::TEST_TASK);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("TEST_TASK", objects::TEST_TASK);
  }

 #if OBSW_ADD_SPI_TEST_CODE == 1
  result = testTask->addComponent(objects::SPI_TEST);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("SPI_TEST", objects::SPI_TEST);
  }
 #endif
 #if OBSW_ADD_I2C_TEST_CODE == 1
  result = testTask->addComponent(objects::I2C_TEST);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("I2C_TEST", objects::I2C_TEST);
  }
 #endif
 #if OBSW_ADD_UART_TEST_CODE == 1
  result = testTask->addComponent(objects::UART_TEST);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("UART_TEST", objects::UART_TEST);
  }
 #endif
--- a/bsp_q7s/core/ObjectFactory.cpp
+++ b/bsp_q7s/core/ObjectFactory.cpp
@ -1,18 +1,21 @@
 #include "ObjectFactory.h"

+#include <fsfw/subsystem/Subsystem.h>
+#include <mission/system/objects/CamSwitcher.h>
+
 #include "OBSWConfig.h"
 #include "bsp_q7s/boardtest/Q7STestTask.h"
 #include "bsp_q7s/callbacks/gnssCallback.h"
 #include "bsp_q7s/callbacks/pcduSwitchCb.h"
 #include "bsp_q7s/callbacks/q7sGpioCallbacks.h"
 #include "bsp_q7s/callbacks/rwSpiCallback.h"
-#include "bsp_q7s/memory/FileSystemHandler.h"
 #include "busConf.h"
 #include "ccsdsConfig.h"
 #include "devConf.h"
 #include "devices/addresses.h"
 #include "devices/gpioIds.h"
 #include "devices/powerSwitcherList.h"
+#include "eive/definitions.h"
 #include "fsfw/ipc/QueueFactory.h"
 #include "linux/ObjectFactory.h"
 #include "linux/boardtest/I2cTestClass.h"
@ -20,8 +23,8 @@
 #include "linux/boardtest/UartTestClass.h"
 #include "linux/callbacks/gpioCallbacks.h"
 #include "linux/csp/CspComIF.h"
-#include "linux/csp/CspCookie.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"
@ -30,22 +33,28 @@
 #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 "mission/system/RwAssembly.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/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 "tmtc/apid.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"
 #endif
+#include <mission/devices/ImtqHandler.h>
+
 #include <sstream>

 #include "fsfw/datapoollocal/LocalDataPoolManager.h"
@ -60,16 +69,15 @@
 #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"
 #include "mission/devices/GyroADIS1650XHandler.h"
 #include "mission/devices/HeaterHandler.h"
-#include "mission/devices/IMTQHandler.h"
 #include "mission/devices/Max31865PT1000Handler.h"
 #include "mission/devices/P60DockHandler.h"
 #include "mission/devices/PCDUHandler.h"
@ -87,19 +95,19 @@
 #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;

 void Factory::setStaticFrameworkObjectIds() {
-  PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
-  PusServiceBase::packetDestination = objects::TM_FUNNEL;
+  PusServiceBase::PUS_DISTRIBUTOR = objects::PUS_PACKET_DISTRIBUTOR;
+  PusServiceBase::PACKET_DESTINATION = objects::PUS_TM_FUNNEL;

  CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
-  CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
+  CommandingServiceBase::defaultPacketDestination = objects::PUS_TM_FUNNEL;

 #if OBSW_Q7S_EM == 1
  DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
@ -107,40 +115,38 @@ void Factory::setStaticFrameworkObjectIds() {
  DeviceHandlerBase::powerSwitcherId = objects::PCDU_HANDLER;
 #endif /* OBSW_Q7S_EM == 1 */

-#if OBSW_TM_TO_PTME == 1
-  TmFunnel::downlinkDestination = objects::CCSDS_HANDLER;
-#else
-  TmFunnel::downlinkDestination = objects::TMTC_BRIDGE;
-#endif /* OBSW_TM_TO_PTME == 1 */
-  // No storage object for now.
-  TmFunnel::storageDestination = objects::NO_OBJECT;
-
  LocalDataPoolManager::defaultHkDestination = objects::PUS_SERVICE_3_HOUSEKEEPING;

-  VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
-  TmPacketBase::timeStamperId = objects::TIME_STAMPER;
+  VerificationReporter::DEFAULT_RECEIVER = objects::PUS_SERVICE_1_VERIFICATION;
 }

 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"
@ -151,18 +157,16 @@ 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);
-  *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);
-  /* Adding gpios for chip select decoding to the gpioComIf */
-  q7s::gpioCallbacks::initSpiCsDecoder(*gpioComIF);
+  *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);
 }

 void ObjectFactory::createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF** pwrSwitcher) {
-  CspCookie* p60DockCspCookie = new CspCookie(P60Dock::MAX_REPLY_LENGTH, addresses::P60DOCK);
-  CspCookie* pdu1CspCookie = new CspCookie(PDU::MAX_REPLY_LENGTH, addresses::PDU1);
-  CspCookie* pdu2CspCookie = new CspCookie(PDU::MAX_REPLY_LENGTH, addresses::PDU2);
-  CspCookie* acuCspCookie = new CspCookie(ACU::MAX_REPLY_LENGTH, addresses::ACU);
+  CspCookie* p60DockCspCookie = new CspCookie(P60Dock::MAX_REPLY_SIZE, addresses::P60DOCK, 500);
+  CspCookie* pdu1CspCookie = new CspCookie(PDU::MAX_REPLY_SIZE, addresses::PDU1, 500);
+  CspCookie* pdu2CspCookie = new CspCookie(PDU::MAX_REPLY_SIZE, addresses::PDU2, 500);
+  CspCookie* acuCspCookie = new CspCookie(ACU::MAX_REPLY_SIZE, addresses::ACU, 500);

  auto p60Fdir = new GomspacePowerFdir(objects::P60DOCK_HANDLER);
  P60DockHandler* p60dockhandler =
@ -200,8 +204,11 @@ void ObjectFactory::createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchI
 #endif
 }

-void ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF) {
+ReturnValue_t ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF) {
  using namespace gpio;
+  if (gpioComIF == nullptr) {
+    return returnvalue::FAILED;
+  }
  GpioCookie* gpioCookieRadSensor = new GpioCookie;
  std::stringstream consumer;
  consumer << "0x" << std::hex << objects::RAD_SENSOR;
@ -227,12 +234,14 @@ void ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF) {
 #if OBSW_DEBUG_RAD_SENSOR == 1
  radSensor->enablePeriodicDataPrint(true);
 #endif
+  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,16 +341,16 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
  AcsBoardFdir* fdir = nullptr;
  static_cast<void>(fdir);

-#if OBSW_ADD_ACS_HANDLERS == 1
+#if OBSW_ADD_ACS_BOARD == 1
  std::string spiDev = q7s::SPI_DEFAULT_DEV;
  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);
@ -352,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);
@ -369,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);
@ -385,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);
@ -407,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();
@ -419,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);
@ -440,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();
@ -448,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);
@ -474,14 +480,19 @@ 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 */
-
-#if OBSW_USE_CCSDS_IP_CORE == 1
-  createCcsdsComponents(gpioComIF);
-#endif /* OBSW_USE_CCSDS_IP_CORE == 1 */
 }

 void ObjectFactory::createHeaterComponents(GpioIF* gpioIF, PowerSwitchIF* pwrSwitcher,
@ -543,7 +554,8 @@ void ObjectFactory::createHeaterComponents(GpioIF* gpioIF, PowerSwitchIF* pwrSwi
                    pcdu::Switches::PDU2_CH3_TCS_BOARD_HEATER_IN_8V);
 }

-void ObjectFactory::createSolarArrayDeploymentComponents() {
+void ObjectFactory::createSolarArrayDeploymentComponents(PowerSwitchIF& pwrSwitcher,
+                                                         GpioIF& gpioIF) {
  using namespace gpio;
  GpioCookie* solarArrayDeplCookie = new GpioCookie;
  GpiodRegularByLineName* gpio = nullptr;
@ -556,18 +568,20 @@ void ObjectFactory::createSolarArrayDeploymentComponents() {
  gpio = new GpiodRegularByLineName(q7s::gpioNames::SA_DPL_PIN_1, consumer.str(), Direction::OUT,
                                    Levels::LOW);
  solarArrayDeplCookie->addGpio(gpioIds::DEPLSA2, gpio);
+  ReturnValue_t result = gpioIF.addGpios(solarArrayDeplCookie);
+  if (result != returnvalue::OK) {
+    sif::error << "Adding Solar Array Deployment GPIO cookie failed" << std::endl;
+  }

-  // TODO: Find out burn time. For now set to 1000 ms.
-  new SolarArrayDeploymentHandler(objects::SOLAR_ARRAY_DEPL_HANDLER, objects::GPIO_IF,
-                                  solarArrayDeplCookie, objects::PCDU_HANDLER,
+  new SolarArrayDeploymentHandler(objects::SOLAR_ARRAY_DEPL_HANDLER, gpioIF, pwrSwitcher,
                                  pcdu::Switches::PDU2_CH5_DEPLOYMENT_MECHANISM_8V,
-                                  gpioIds::DEPLSA1, gpioIds::DEPLSA2, 1000);
+                                  gpioIds::DEPLSA1, gpioIds::DEPLSA2, *SdCardManager::instance());
 }

 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);
@ -580,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,
@ -591,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;
@ -607,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);
 }
@ -690,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;
@ -759,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;
@ -779,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);
@ -796,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,
@ -859,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) {
@ -867,31 +903,33 @@ 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);
  new UartTestClass(objects::UART_TEST);
 #endif
 }

 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);
-  auto imtqHandler = new IMTQHandler(objects::IMTQ_HANDLER, objects::I2C_COM_IF, imtqI2cCookie,
+  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();
@ -903,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();
@ -913,17 +951,14 @@ void ObjectFactory::createBpxBatteryComponent() {
 #endif
 }

-void ObjectFactory::createMiscComponents() {
-  new FileSystemHandler(objects::FILE_SYSTEM_HANDLER);
-  new PlocMemoryDumper(objects::PLOC_MEMORY_DUMPER);
-}
+void ObjectFactory::createMiscComponents() { new PlocMemoryDumper(objects::PLOC_MEMORY_DUMPER); }

 void ObjectFactory::testAcsBrdAss(AcsBoardAssembly* acsAss) {
  CommandMessage msg;
  ModeMessage::setModeMessage(&msg, ModeMessage::CMD_MODE_COMMAND, DeviceHandlerIF::MODE_NORMAL,
                              duallane::A_SIDE);
  ReturnValue_t result = MessageQueueSenderIF::sendMessage(acsAss->getCommandQueue(), &msg);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::warning << "Sending mode command failed" << std::endl;
  }
 }
--- a/bsp_q7s/core/ObjectFactory.h
+++ b/bsp_q7s/core/ObjectFactory.h
@ -1,12 +1,15 @@
 #ifndef BSP_Q7S_OBJECTFACTORY_H_
 #define BSP_Q7S_OBJECTFACTORY_H_

-#include <fsfw/returnvalues/HasReturnvaluesIF.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,25 +22,25 @@ 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);
 void createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF,
                            PowerSwitchIF* pwrSwitcher);
 void createTmpComponents();
-void createRadSensorComponent(LinuxLibgpioIF* gpioComIF);
-void createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComIF* uartComIF,
+ReturnValue_t createRadSensorComponent(LinuxLibgpioIF* gpioComIF);
+void createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, SerialComIF* uartComIF,
                              PowerSwitchIF* pwrSwitcher);
 void createHeaterComponents(GpioIF* gpioIF, PowerSwitchIF* pwrSwitcher, HealthTableIF* healthTable);
 void createImtqComponents(PowerSwitchIF* pwrSwitcher);
 void createBpxBatteryComponent();
 void createStrComponents(PowerSwitchIF* pwrSwitcher);
-void createSolarArrayDeploymentComponents();
+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);
--- a/bsp_q7s/em/emObjectFactory.cpp
+++ b/bsp_q7s/em/emObjectFactory.cpp
@ -1,11 +1,14 @@
+#include <bsp_q7s/callbacks/q7sGpioCallbacks.h>
 #include <fsfw/health/HealthTableIF.h>
+#include <fsfw/power/DummyPowerSwitcher.h>

 #include "OBSWConfig.h"
 #include "bsp_q7s/core/CoreController.h"
 #include "bsp_q7s/core/ObjectFactory.h"
 #include "busConf.h"
-#include "commonObjects.h"
 #include "devConf.h"
+#include "dummies/helpers.h"
+#include "eive/objects.h"
 #include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
 #include "linux/ObjectFactory.h"
 #include "linux/callbacks/gpioCallbacks.h"
@ -14,43 +17,64 @@
 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;
  SpiComIF* spiRwComIF = nullptr;
  createCommunicationInterfaces(&gpioComIF, &uartComIF, &spiMainComIF, &i2cComIF, &spiRwComIF);
-  createTmpComponents();
+  /* Adding gpios for chip select decoding to the gpioComIf */
+  q7s::gpioCallbacks::initSpiCsDecoder(gpioComIF);
+  gpioCallbacks::disableAllDecoder(gpioComIF);
+
+  // Hardware is usually not connected to EM, so we need to create dummies which replace lower
+  // 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);

-  gpioCallbacks::disableAllDecoder(gpioComIF);
-  createPcduComponents(gpioComIF, &pwrSwitcher);
-  createRadSensorComponent(gpioComIF);
-  createSunSensorComponents(gpioComIF, spiMainComIF, pwrSwitcher, q7s::SPI_DEFAULT_DEV);
+  PowerSwitchIF* pwrSwitcher = new DummyPowerSwitcher(objects::PCDU_HANDLER, 18, 0);
+  static_cast<void>(pwrSwitcher);
+
+  // Regular FM code, does not work for EM if the hardware is not connected
+  // createPcduComponents(gpioComIF, &pwrSwitcher);
+  // createPlPcduComponents(gpioComIF, spiMainComIF, pwrSwitcher);
+  // createSyrlinksComponents(pwrSwitcher);
+  // createSunSensorComponents(gpioComIF, spiMainComIF, pwrSwitcher, q7s::SPI_DEFAULT_DEV);
+  // createRtdComponents(q7s::SPI_DEFAULT_DEV, gpioComIF, pwrSwitcher, spiMainComIF);
+  // createTmpComponents();
+  // createSolarArrayDeploymentComponents();
+  // createPayloadComponents(gpioComIF);
+  // createHeaterComponents(gpioComIF, pwrSwitcher, healthTable);
+
+  // TODO: Careful! Switching this on somehow messes with the communication with the ProASIC
+  //       and will cause xsc_boot_copy commands to always boot to 0 0
+  // createRadSensorComponent(gpioComIF);

 #if OBSW_ADD_ACS_BOARD == 1
  createAcsBoardComponents(gpioComIF, uartComIF, pwrSwitcher);
 #endif
-  createHeaterComponents(gpioComIF, pwrSwitcher, healthTable);
-  createSolarArrayDeploymentComponents();
-  createPlPcduComponents(gpioComIF, spiMainComIF, pwrSwitcher);
-#if OBSW_ADD_SYRLINKS == 1
-#if OBSW_Q7S_EM == 1
-  createSyrlinksComponents(nullptr);
-#else
-  createSyrlinksComponents(pwrSwitcher);
-#endif /* OBSW_Q7S_EM == 1 */
-#endif /* OBSW_ADD_SYRLINKS == 1 */
-  createRtdComponents(q7s::SPI_DEFAULT_DEV, gpioComIF, pwrSwitcher, spiMainComIF);
-  createPayloadComponents(gpioComIF);

 #if OBSW_ADD_MGT == 1
  createImtqComponents(pwrSwitcher);
 #endif
+
+#if OBSW_ADD_SYRLINKS == 1
+  createSyrlinksComponents(pwrSwitcher);
+#endif /* OBSW_ADD_SYRLINKS == 1 */
+
+#if OBSW_ADD_RW == 1
  createReactionWheelComponents(gpioComIF, pwrSwitcher);
+#endif

 #if OBSW_ADD_BPX_BATTERY_HANDLER == 1
  createBpxBatteryComponent();
@ -59,13 +83,20 @@ void ObjectFactory::produce(void* args) {
 #if OBSW_ADD_STAR_TRACKER == 1
  createStrComponents(pwrSwitcher);
 #endif /* OBSW_ADD_STAR_TRACKER == 1 */
-#if OBSW_USE_CCSDS_IP_CORE == 1
-  createCcsdsComponents(gpioComIF);
-#endif /* OBSW_USE_CCSDS_IP_CORE == 1 */
+#if OBSW_ADD_CCSDS_IP_CORES == 1
+  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
  createTestComponents(gpioComIF);
 #endif /* OBSW_ADD_TEST_CODE == 1 */
-
-  createMiscComponents();
+#if OBSW_ADD_SCEX_DEVICE == 1
+  createScexComponents(q7s::UART_SCEX_DEV, pwrSwitcher, *SdCardManager::instance(), true,
+                       std::nullopt);
+#endif
+  createAcsController(true);
 }
--- a/bsp_q7s/fmObjectFactory.cpp
+++ b/bsp_q7s/fmObjectFactory.cpp
@ -1,30 +1,37 @@
+#include <bsp_q7s/callbacks/q7sGpioCallbacks.h>
+#include <mission/devices/devicedefinitions/GomspaceDefinitions.h>
+
 #include "OBSWConfig.h"
 #include "bsp_q7s/core/CoreController.h"
 #include "bsp_q7s/core/ObjectFactory.h"
 #include "busConf.h"
-#include "commonObjects.h"
 #include "devConf.h"
+#include "eive/objects.h"
 #include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
 #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;
  SpiComIF* spiRwComIF = nullptr;
  createCommunicationInterfaces(&gpioComIF, &uartComIF, &spiMainComIF, &i2cComIF, &spiRwComIF);
-  createTmpComponents();
-  new CoreController(objects::CORE_CONTROLLER);
-
+  /* Adding gpios for chip select decoding to the gpioComIf */
+  q7s::gpioCallbacks::initSpiCsDecoder(gpioComIF);
  gpioCallbacks::disableAllDecoder(gpioComIF);
+
+  new CoreController(objects::CORE_CONTROLLER);
  createPcduComponents(gpioComIF, &pwrSwitcher);
  createRadSensorComponent(gpioComIF);
  createSunSensorComponents(gpioComIF, spiMainComIF, pwrSwitcher, q7s::SPI_DEFAULT_DEV);
@ -33,13 +40,16 @@ void ObjectFactory::produce(void* args) {
  createAcsBoardComponents(gpioComIF, uartComIF, pwrSwitcher);
 #endif
  createHeaterComponents(gpioComIF, pwrSwitcher, healthTable);
-  createSolarArrayDeploymentComponents();
+#if OBSW_ADD_TMP_DEVICES == 1
+  createTmpComponents();
+#endif
+  createSolarArrayDeploymentComponents(*pwrSwitcher, *gpioComIF);
  createPlPcduComponents(gpioComIF, spiMainComIF, pwrSwitcher);
 #if OBSW_ADD_SYRLINKS == 1
  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);
@ -53,9 +63,18 @@ void ObjectFactory::produce(void* args) {
 #if OBSW_ADD_STAR_TRACKER == 1
  createStrComponents(pwrSwitcher);
 #endif /* OBSW_ADD_STAR_TRACKER == 1 */
-#if OBSW_USE_CCSDS_IP_CORE == 1
-  createCcsdsComponents(gpioComIF);
-#endif /* OBSW_USE_CCSDS_IP_CORE == 1 */
+#if OBSW_ADD_CCSDS_IP_CORES == 1
+  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
+  createScexComponents(q7s::UART_SCEX_DEV, pwrSwitcher, *SdCardManager::instance(), false,
+                       pcdu::Switches::PDU1_CH5_SOLAR_CELL_EXP_5V);
+#endif
  /* Test Task */
 #if OBSW_ADD_TEST_CODE == 1
  createTestComponents(gpioComIF);
@ -63,4 +82,6 @@ void ObjectFactory::produce(void* args) {

  createMiscComponents();
  createThermalController();
+  createAcsController(true);
+  satsystem::init();
 }
--- a/bsp_q7s/fs/CMakeLists.txt
+++ b/bsp_q7s/fs/CMakeLists.txt
@ -0,0 +1,2 @@
+target_sources(${OBSW_NAME} PRIVATE helpers.cpp SdCardManager.cpp
+                                    FilesystemHelper.cpp)
--- a/bsp_q7s/memory/FilesystemHelper.cpp
+++ b/bsp_q7s/memory/FilesystemHelper.cpp
@ -3,8 +3,9 @@
 #include <filesystem>
 #include <fstream>

-#include "bsp_q7s/memory/SdCardManager.h"
-#include "fsfw/serviceinterface/ServiceInterfaceStream.h"
+#include "SdCardManager.h"
+#include "eive/definitions.h"
+#include "fsfw/serviceinterface.h"

 FilesystemHelper::FilesystemHelper() {}

@ -12,27 +13,26 @@ ReturnValue_t FilesystemHelper::checkPath(std::string path) {
  SdCardManager* sdcMan = SdCardManager::instance();
  if (sdcMan == nullptr) {
    sif::warning << "FilesystemHelper::checkPath: Invalid SD card manager" << std::endl;
-    return RETURN_FAILED;
+    return returnvalue::FAILED;
  }
-  if (path.substr(0, sizeof(SdCardManager::SD_0_MOUNT_POINT)) ==
-      std::string(SdCardManager::SD_0_MOUNT_POINT)) {
-    if (!sdcMan->isSdCardMounted(sd::SLOT_0)) {
+  if (path.substr(0, sizeof(config::SD_0_MOUNT_POINT)) == std::string(config::SD_0_MOUNT_POINT)) {
+    if (!sdcMan->isSdCardUsable(sd::SLOT_0)) {
      sif::warning << "FilesystemHelper::checkPath: SD card 0 not mounted" << std::endl;
      return SD_NOT_MOUNTED;
    }
-  } else if (path.substr(0, sizeof(SdCardManager::SD_1_MOUNT_POINT)) ==
-             std::string(SdCardManager::SD_1_MOUNT_POINT)) {
-    if (!sdcMan->isSdCardMounted(sd::SLOT_0)) {
+  } else if (path.substr(0, sizeof(config::SD_1_MOUNT_POINT)) ==
+             std::string(config::SD_1_MOUNT_POINT)) {
+    if (!sdcMan->isSdCardUsable(sd::SLOT_0)) {
      sif::warning << "FilesystemHelper::checkPath: SD card 1 not mounted" << std::endl;
      return SD_NOT_MOUNTED;
    }
  }
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t FilesystemHelper::fileExists(std::string file) {
  if (not std::filesystem::exists(file)) {
    return FILE_NOT_EXISTS;
  }
-  return RETURN_OK;
+  return returnvalue::OK;
 }
--- a/bsp_q7s/memory/FilesystemHelper.h
+++ b/bsp_q7s/memory/FilesystemHelper.h
@ -3,15 +3,15 @@

 #include <string>

-#include "commonClassIds.h"
-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "eive/resultClassIds.h"
+#include "fsfw/returnvalues/returnvalue.h"

 /**
 * @brief   This class implements often used functions related to the file system management.
 *
 * @author  J. Meier
 */
-class FilesystemHelper : public HasReturnvaluesIF {
+class FilesystemHelper {
 public:
  static const uint8_t INTERFACE_ID = CLASS_ID::FILE_SYSTEM_HELPER;

@ -26,7 +26,7 @@ class FilesystemHelper : public HasReturnvaluesIF {
   *
   * @param path  Path to check
   *
-   * @return  RETURN_OK if path points to SD card and the appropriate SD card is mounted or if
+   * @return  returnvalue::OK if path points to SD card and the appropriate SD card is mounted or if
   *          path does not point to SD card.
   *          Return error code if path points to SD card and the corresponding SD card is not
   *          mounted.
@ -38,7 +38,7 @@ class FilesystemHelper : public HasReturnvaluesIF {
   *
   * @param file   File to check
   *
-   * @return  RETURN_OK if file exists, otherwise return error code.
+   * @return  returnvalue::OK if file exists, otherwise return error code.
   */
  static ReturnValue_t fileExists(std::string file);

--- a/bsp_q7s/memory/SdCardManager.cpp
+++ b/bsp_q7s/memory/SdCardManager.cpp
@ -10,28 +10,28 @@
 #include <memory>

 #include "OBSWConfig.h"
-#include "common/config/commonObjects.h"
+#include "bsp_q7s/memory/scratchApi.h"
+#include "eive/definitions.h"
+#include "eive/objects.h"
 #include "fsfw/ipc/MutexFactory.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 #include "linux/utility/utility.h"
-#include "scratchApi.h"

 SdCardManager* SdCardManager::INSTANCE = nullptr;

 SdCardManager::SdCardManager() : SystemObject(objects::SDC_MANAGER), cmdExecutor(256) {
  mutex = MutexFactory::instance()->createMutex();
  ReturnValue_t result = mutex->lockMutex();
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "SdCardManager::SdCardManager: Mutex lock failed" << std::endl;
  }
  uint8_t prefSdRaw = 0;
  result = scratch::readNumber(scratch::PREFERED_SDC_KEY, prefSdRaw);
-  result = mutex->unlockMutex();
-  if (result != RETURN_OK) {
+  if (mutex->unlockMutex() != returnvalue::OK) {
    sif::error << "SdCardManager::SdCardManager: Mutex unlock failed" << std::endl;
  }

-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    if (result == scratch::KEY_NOT_FOUND) {
      sif::warning << "CoreController::sdCardInit: "
                      "Preferred SD card not set. Setting to 0"
@ -65,7 +65,7 @@ SdCardManager* SdCardManager::instance() {

 ReturnValue_t SdCardManager::switchOnSdCard(sd::SdCard sdCard, bool doMountSdCard,
                                            SdStatePair* statusPair) {
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
  if (doMountSdCard) {
    if (not blocking) {
      sif::warning << "SdCardManager::switchOnSdCard: Two-step command but manager is"
@ -80,7 +80,7 @@ ReturnValue_t SdCardManager::switchOnSdCard(sd::SdCard sdCard, bool doMountSdCar
    sdStatusPtr = std::make_unique<SdStatePair>();
    statusPair = sdStatusPtr.get();
    result = getSdCardsStatus(*statusPair);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
      return result;
    }
  }
@ -89,7 +89,7 @@ ReturnValue_t SdCardManager::switchOnSdCard(sd::SdCard sdCard, bool doMountSdCar
  if (sdCard == sd::SdCard::BOTH) {
    sif::warning << "SdCardManager::switchOffSdCard: API does not allow sd::SdStatus::BOTH"
                 << std::endl;
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
  }

  sd::SdState currentState;
@ -113,10 +113,10 @@ ReturnValue_t SdCardManager::switchOnSdCard(sd::SdCard sdCard, bool doMountSdCar
  } else if (currentState == sd::SdState::OFF) {
    result = setSdCardState(sdCard, true);
  } else {
-    result = HasReturnvaluesIF::RETURN_FAILED;
+    result = returnvalue::FAILED;
  }

-  if (result != HasReturnvaluesIF::RETURN_OK or not doMountSdCard) {
+  if (result != returnvalue::OK or not doMountSdCard) {
    return result;
  }

@ -127,7 +127,7 @@ ReturnValue_t SdCardManager::switchOffSdCard(sd::SdCard sdCard, bool doUnmountSd
                                             SdStatePair* statusPair) {
  std::pair<sd::SdState, sd::SdState> active;
  ReturnValue_t result = getSdCardsStatus(active);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  if (doUnmountSdCard) {
@ -142,7 +142,7 @@ ReturnValue_t SdCardManager::switchOffSdCard(sd::SdCard sdCard, bool doUnmountSd
  if (sdCard == sd::SdCard::BOTH) {
    sif::warning << "SdCardManager::switchOffSdCard: API does not allow sd::SdStatus::BOTH"
                 << std::endl;
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
  }
  if (sdCard == sd::SdCard::SLOT_0) {
    if (active.first == sd::SdState::OFF) {
@ -156,7 +156,7 @@ ReturnValue_t SdCardManager::switchOffSdCard(sd::SdCard sdCard, bool doUnmountSd

  if (doUnmountSdCard) {
    result = unmountSdCard(sdCard);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
      return result;
    }
  }
@ -187,7 +187,7 @@ ReturnValue_t SdCardManager::setSdCardState(sd::SdCard sdCard, bool on) {
  command << "q7hw sd set " << sdstring << " " << statestring;
  cmdExecutor.load(command.str(), blocking, printCmdOutput);
  ReturnValue_t result = cmdExecutor.execute();
-  if (blocking and result != HasReturnvaluesIF::RETURN_OK) {
+  if (blocking and result != returnvalue::OK) {
    utility::handleSystemError(cmdExecutor.getLastError(), "SdCardManager::setSdCardState");
  }
  return result;
@ -212,7 +212,10 @@ ReturnValue_t SdCardManager::getSdCardsStatus(SdStatePair& active) {
  while (std::getline(sdStatus, line)) {
    processSdStatusLine(active, line, idx, currentSd);
  }
-  return HasReturnvaluesIF::RETURN_OK;
+  if (active.first != sd::SdState::MOUNTED && active.second != sd::SdState::MOUNTED) {
+    sdCardActive = false;
+  }
+  return returnvalue::OK;
 }

 ReturnValue_t SdCardManager::mountSdCard(sd::SdCard sdCard) {
@ -223,16 +226,16 @@ ReturnValue_t SdCardManager::mountSdCard(sd::SdCard sdCard) {
  if (sdCard == sd::SdCard::BOTH) {
    sif::warning << "SdCardManager::mountSdCard: API does not allow sd::SdStatus::BOTH"
                 << std::endl;
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
  }
  string mountDev;
  string mountPoint;
  if (sdCard == sd::SdCard::SLOT_0) {
    mountDev = SD_0_DEV_NAME;
-    mountPoint = SD_0_MOUNT_POINT;
+    mountPoint = config::SD_0_MOUNT_POINT;
  } else if (sdCard == sd::SdCard::SLOT_1) {
    mountDev = SD_1_DEV_NAME;
-    mountPoint = SD_1_MOUNT_POINT;
+    mountPoint = config::SD_1_MOUNT_POINT;
  }
  if (not filesystem::exists(mountDev)) {
    sif::warning << "SdCardManager::mountSdCard: Device file does not exists. Make sure to"
@ -247,7 +250,7 @@ ReturnValue_t SdCardManager::mountSdCard(sd::SdCard sdCard) {
  string sdMountCommand = "mount " + mountDev + " " + mountPoint;
  cmdExecutor.load(sdMountCommand, blocking, printCmdOutput);
  ReturnValue_t result = cmdExecutor.execute();
-  if (blocking and result != HasReturnvaluesIF::RETURN_OK) {
+  if (blocking and result != returnvalue::OK) {
    utility::handleSystemError(cmdExecutor.getLastError(), "SdCardManager::mountSdCard");
  }
  return result;
@ -261,13 +264,13 @@ ReturnValue_t SdCardManager::unmountSdCard(sd::SdCard sdCard) {
  if (sdCard == sd::SdCard::BOTH) {
    sif::warning << "SdCardManager::unmountSdCard: API does not allow sd::SdStatus::BOTH"
                 << std::endl;
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
  }
  string mountPoint;
  if (sdCard == sd::SdCard::SLOT_0) {
-    mountPoint = SD_0_MOUNT_POINT;
+    mountPoint = config::SD_0_MOUNT_POINT;
  } else if (sdCard == sd::SdCard::SLOT_1) {
-    mountPoint = SD_1_MOUNT_POINT;
+    mountPoint = config::SD_1_MOUNT_POINT;
  }
  if (not filesystem::exists(mountPoint)) {
    sif::error << "SdCardManager::unmountSdCard: Default mount point " << mountPoint
@ -285,7 +288,7 @@ ReturnValue_t SdCardManager::unmountSdCard(sd::SdCard sdCard) {
  }
  cmdExecutor.load(sdUnmountCommand, blocking, printCmdOutput);
  ReturnValue_t result = cmdExecutor.execute();
-  if (blocking and result != HasReturnvaluesIF::RETURN_OK) {
+  if (blocking and result != returnvalue::OK) {
    utility::handleSystemError(cmdExecutor.getLastError(), "SdCardManager::unmountSdCard");
  }
  return result;
@ -293,18 +296,13 @@ ReturnValue_t SdCardManager::unmountSdCard(sd::SdCard sdCard) {

 ReturnValue_t SdCardManager::sanitizeState(SdStatePair* statusPair, sd::SdCard prefSdCard) {
  std::unique_ptr<SdStatePair> sdStatusPtr;
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
  // Enforce blocking operation for now. Be careful to reset it when returning prematurely!
  bool resetNonBlockingState = false;
  if (not this->blocking) {
    blocking = true;
    resetNonBlockingState = true;
  }
-  if (prefSdCard == sd::SdCard::NONE) {
-    result = getPreferredSdCard();
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-    }
-  }
  if (statusPair == nullptr) {
    sdStatusPtr = std::make_unique<SdStatePair>();
    statusPair = sdStatusPtr.get();
@ -379,10 +377,10 @@ void SdCardManager::processSdStatusLine(std::pair<sd::SdState, sd::SdState>& act
  idx++;
 }

-sd::SdCard SdCardManager::getPreferredSdCard() const {
+std::optional<sd::SdCard> SdCardManager::getPreferredSdCard() const {
  MutexGuard mg(mutex);
  auto res = mg.getLockResult();
-  if (res != RETURN_OK) {
+  if (res != returnvalue::OK) {
    sif::error << "SdCardManager::getPreferredSdCard: Lock error" << std::endl;
  }
  return sdInfo.pref;
@ -391,7 +389,7 @@ sd::SdCard SdCardManager::getPreferredSdCard() const {
 ReturnValue_t SdCardManager::setPreferredSdCard(sd::SdCard sdCard) {
  MutexGuard mg(mutex);
  if (sdCard == sd::SdCard::BOTH) {
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
  }
  sdInfo.pref = sdCard;
  return scratch::writeNumber(scratch::PREFERED_SDC_KEY, static_cast<uint8_t>(sdCard));
@ -406,19 +404,15 @@ ReturnValue_t SdCardManager::updateSdCardStateFile() {
  std::string updateCmd = "q7hw sd info all > " + std::string(SD_STATE_FILE);
  cmdExecutor.load(updateCmd, blocking, printCmdOutput);
  ReturnValue_t result = cmdExecutor.execute();
-  if (blocking and result != HasReturnvaluesIF::RETURN_OK) {
+  if (blocking and result != returnvalue::OK) {
    utility::handleSystemError(cmdExecutor.getLastError(), "SdCardManager::mountSdCard");
  }
  return result;
 }

-std::string SdCardManager::getCurrentMountPrefix() const {
+const std::string& SdCardManager::getCurrentMountPrefix() const {
  MutexGuard mg(mutex);
-  if (sdInfo.active == sd::SdCard::SLOT_0) {
-    return SD_0_MOUNT_POINT;
-  } else {
-    return SD_1_MOUNT_POINT;
-  }
+  return currentPrefix;
 }

 SdCardManager::OpStatus SdCardManager::checkCurrentOp(Operations& currentOp) {
@ -448,10 +442,10 @@ SdCardManager::OpStatus SdCardManager::checkCurrentOp(Operations& currentOp) {
      case (CommandExecutor::EXECUTION_FINISHED): {
        return OpStatus::SUCCESS;
      }
-      case (HasReturnvaluesIF::RETURN_OK): {
+      case (returnvalue::OK): {
        return OpStatus::ONGOING;
      }
-      case (HasReturnvaluesIF::RETURN_FAILED): {
+      case (returnvalue::FAILED): {
        return OpStatus::FAIL;
      }
      default: {
@ -465,28 +459,45 @@ void SdCardManager::setBlocking(bool blocking) { this->blocking = blocking; }

 void SdCardManager::setPrintCommandOutput(bool print) { this->printCmdOutput = print; }

-bool SdCardManager::isSdCardMounted(sd::SdCard sdCard) {
+bool SdCardManager::isSdCardUsable(std::optional<sd::SdCard> sdCard) {
+  {
+    MutexGuard mg(mutex);
+    if (markedUnusable) {
+      return false;
+    }
+  }
+
  SdCardManager::SdStatePair active;
  ReturnValue_t result = this->getSdCardsStatus(active);

-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::debug << "SdCardManager::isSdCardMounted: Failed to get SD card active state";
    return false;
  }
+  if (not sdCard) {
+    if (active.first == sd::MOUNTED or active.second == sd::MOUNTED) {
+      return true;
+    }
+    return false;
+  }
  if (sdCard == sd::SLOT_0) {
    if (active.first == sd::MOUNTED) {
      return true;
    } else {
      return false;
    }
-  } else if (sdCard == sd::SLOT_1) {
+  }
+  if (sdCard == sd::SLOT_1) {
    if (active.second == sd::MOUNTED) {
      return true;
    } else {
      return false;
    }
-  } else {
-    sif::debug << "SdCardManager::isSdCardMounted: Unknown SD card specified" << std::endl;
+  }
+  if (sdCard == sd::BOTH) {
+    if (active.first == sd::MOUNTED && active.second == sd::MOUNTED) {
+      return true;
+    }
  }
  return false;
 }
@ -494,20 +505,22 @@ bool SdCardManager::isSdCardMounted(sd::SdCard sdCard) {
 ReturnValue_t SdCardManager::isSdCardMountedReadOnly(sd::SdCard sdcard, bool& readOnly) {
  std::ostringstream command;
  if (sdcard == sd::SdCard::SLOT_0) {
-    command << "grep -q '" << SD_0_MOUNT_POINT << " vfat ro,' /proc/mounts";
+    command << "grep -q '" << config::SD_0_MOUNT_POINT << " vfat ro,' /proc/mounts";
+  } else if (sdcard == sd::SdCard::SLOT_1) {
+    command << "grep -q '" << config::SD_1_MOUNT_POINT << " vfat ro,' /proc/mounts";
  } else {
-    command << "grep -q '" << SD_1_MOUNT_POINT << " vfat ro,' /proc/mounts";
+    return returnvalue::FAILED;
  }
  ReturnValue_t result = cmdExecutor.load(command.str(), true, false);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  result = cmdExecutor.execute();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    int exitStatus = cmdExecutor.getLastError();
    if (exitStatus == 1) {
      readOnly = false;
-      return RETURN_OK;
+      return returnvalue::OK;
    }
    return result;
  }
@ -517,18 +530,18 @@ ReturnValue_t SdCardManager::isSdCardMountedReadOnly(sd::SdCard sdcard, bool& re
    readOnly = false;
  }
  readOnly = true;
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t SdCardManager::remountReadWrite(sd::SdCard sdcard) {
  std::ostringstream command;
  if (sdcard == sd::SdCard::SLOT_0) {
-    command << "mount -o remount,rw " << SD_0_DEV_NAME << " " << SD_0_MOUNT_POINT;
+    command << "mount -o remount,rw " << SD_0_DEV_NAME << " " << config::SD_0_MOUNT_POINT;
  } else {
-    command << "mount -o remount,rw " << SD_1_DEV_NAME << " " << SD_1_MOUNT_POINT;
+    command << "mount -o remount,rw " << SD_1_DEV_NAME << " " << config::SD_1_MOUNT_POINT;
  }
  ReturnValue_t result = cmdExecutor.load(command.str(), true, false);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  return cmdExecutor.execute();
@ -542,16 +555,35 @@ ReturnValue_t SdCardManager::performFsck(sd::SdCard sdcard, bool printOutput, in
    command << "fsck -y " << SD_1_DEV_NAME;
  }
  ReturnValue_t result = cmdExecutor.load(command.str(), true, printOutput);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  result = cmdExecutor.execute();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    linuxError = cmdExecutor.getLastError();
  }
  return result;
 }

-void SdCardManager::setActiveSdCard(sd::SdCard sdCard) { sdInfo.active = sdCard; }
+void SdCardManager::setActiveSdCard(sd::SdCard sdCard) {
+  MutexGuard mg(mutex);
+  sdInfo.active = sdCard;
+  if (sdInfo.active == sd::SdCard::SLOT_0) {
+    currentPrefix = config::SD_0_MOUNT_POINT;
+  } else {
+    currentPrefix = config::SD_1_MOUNT_POINT;
+  }
+}

-sd::SdCard SdCardManager::getActiveSdCard() const { return sdInfo.active; }
+std::optional<sd::SdCard> SdCardManager::getActiveSdCard() const {
+  MutexGuard mg(mutex);
+  if (markedUnusable) {
+    return std::nullopt;
+  }
+  return sdInfo.active;
+}
+
+void SdCardManager::markUnusable() {
+  MutexGuard mg(mutex);
+  markedUnusable = true;
+}
--- a/bsp_q7s/memory/SdCardManager.h
+++ b/bsp_q7s/memory/SdCardManager.h
@ -12,7 +12,7 @@

 #include "events/subsystemIdRanges.h"
 #include "fsfw/events/Event.h"
-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw_hal/linux/CommandExecutor.h"
 #include "mission/memory/SdCardMountedIF.h"
 #include "mission/memory/definitions.h"
@ -24,7 +24,7 @@ class MutexIF;
 * @brief   Manages handling of SD cards like switching them on or off or getting the current
 *          state
 */
-class SdCardManager : public SystemObject, public HasReturnvaluesIF, public SdCardMountedIF {
+class SdCardManager : public SystemObject, public SdCardMountedIF {
  friend class SdCardAccess;

 public:
@ -44,22 +44,17 @@ class SdCardManager : public SystemObject, public HasReturnvaluesIF, public SdCa

  static constexpr uint8_t INTERFACE_ID = CLASS_ID::SD_CARD_MANAGER;

-  static constexpr ReturnValue_t OP_ONGOING = HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 0);
-  static constexpr ReturnValue_t ALREADY_ON = HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 1);
-  static constexpr ReturnValue_t ALREADY_MOUNTED =
-      HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 2);
-  static constexpr ReturnValue_t ALREADY_OFF = HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 3);
-  static constexpr ReturnValue_t STATUS_FILE_NEXISTS =
-      HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 10);
+  static constexpr ReturnValue_t OP_ONGOING = returnvalue::makeCode(INTERFACE_ID, 0);
+  static constexpr ReturnValue_t ALREADY_ON = returnvalue::makeCode(INTERFACE_ID, 1);
+  static constexpr ReturnValue_t ALREADY_MOUNTED = returnvalue::makeCode(INTERFACE_ID, 2);
+  static constexpr ReturnValue_t ALREADY_OFF = returnvalue::makeCode(INTERFACE_ID, 3);
+  static constexpr ReturnValue_t STATUS_FILE_NEXISTS = returnvalue::makeCode(INTERFACE_ID, 10);
  static constexpr ReturnValue_t STATUS_FILE_FORMAT_INVALID =
-      HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 11);
-  static constexpr ReturnValue_t MOUNT_ERROR = HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 12);
-  static constexpr ReturnValue_t UNMOUNT_ERROR =
-      HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 13);
-  static constexpr ReturnValue_t SYSTEM_CALL_ERROR =
-      HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 14);
-  static constexpr ReturnValue_t POPEN_CALL_ERROR =
-      HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 15);
+      returnvalue::makeCode(INTERFACE_ID, 11);
+  static constexpr ReturnValue_t MOUNT_ERROR = returnvalue::makeCode(INTERFACE_ID, 12);
+  static constexpr ReturnValue_t UNMOUNT_ERROR = returnvalue::makeCode(INTERFACE_ID, 13);
+  static constexpr ReturnValue_t SYSTEM_CALL_ERROR = returnvalue::makeCode(INTERFACE_ID, 14);
+  static constexpr ReturnValue_t POPEN_CALL_ERROR = returnvalue::makeCode(INTERFACE_ID, 15);

  static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FILE_SYSTEM;

@ -69,8 +64,7 @@ class SdCardManager : public SystemObject, public HasReturnvaluesIF, public SdCa
  // C++17 does not support constexpr std::string yet
  static constexpr char SD_0_DEV_NAME[] = "/dev/mmcblk0p1";
  static constexpr char SD_1_DEV_NAME[] = "/dev/mmcblk1p1";
-  static constexpr char SD_0_MOUNT_POINT[] = "/mnt/sd0";
-  static constexpr char SD_1_MOUNT_POINT[] = "/mnt/sd1";
+
  static constexpr char SD_STATE_FILE[] = "/tmp/sd_status.txt";

  virtual ~SdCardManager();
@ -97,7 +91,7 @@ class SdCardManager : public SystemObject, public HasReturnvaluesIF, public SdCa
   * @param sdCard
   * @return
   */
-  sd::SdCard getPreferredSdCard() const override;
+  std::optional<sd::SdCard> getPreferredSdCard() const override;

  /**
   * Switch on the specified SD card.
@ -105,7 +99,7 @@ class SdCardManager : public SystemObject, public HasReturnvaluesIF, public SdCa
   * @param doMountSdCard     Mount the SD card after switching it on, which is necessary
   *                          to use it
   * @param statusPair        If the status pair is already available, it can be passed here
-   * @return - RETURN_OK on success, ALREADY_ON if it is already on,
+   * @return - returnvalue::OK on success, ALREADY_ON if it is already on,
   *           SYSTEM_CALL_ERROR on system error
   */
  ReturnValue_t switchOnSdCard(sd::SdCard sdCard, bool doMountSdCard = true,
@ -117,7 +111,7 @@ class SdCardManager : public SystemObject, public HasReturnvaluesIF, public SdCa
   * @param doUnmountSdCard   Unmount the SD card before switching the card off, which makes
   *                          the operation safer
   * @param statusPair        If the status pair is already available, it can be passed here
-   * @return - RETURN_OK on success, ALREADY_ON if it is already on,
+   * @return - returnvalue::OK on success, ALREADY_ON if it is already on,
   *           SYSTEM_CALL_ERROR on system error
   */
  ReturnValue_t switchOffSdCard(sd::SdCard sdCard, bool doUnmountSdCard = true,
@ -127,9 +121,9 @@ class SdCardManager : public SystemObject, public HasReturnvaluesIF, public SdCa
   * Update the state file or creates one if it does not exist. You need to call this
   * function before calling #sdCardActive
   * @return
-   *  - RETURN_OK if the state file was updated successfully
+   *  - returnvalue::OK if the state file was updated successfully
   *  - CommandExecutor::COMMAND_PENDING: Non-blocking command is pending
-   *  - RETURN_FAILED: blocking command failed
+   *  - returnvalue::FAILED: blocking command failed
   */
  ReturnValue_t updateSdCardStateFile();

@ -139,7 +133,7 @@ class SdCardManager : public SystemObject, public HasReturnvaluesIF, public SdCa
   * the status of the SD cards and set the field of the provided boolean pair.
   * @param active Pair of booleans, where the first entry is the state of the first SD card
   * and the second one the state of the second SD card
-   * @return - RETURN_OK if the state was read successfully
+   * @return - returnvalue::OK if the state was read successfully
   *         - STATUS_FILE_FORMAT_INVALID if there was an issue with the state file. The user
   *           should call #updateSdCardStateFile again in that case
   *         - STATUS_FILE_NEXISTS if the status file does not exist
@ -164,7 +158,7 @@ class SdCardManager : public SystemObject, public HasReturnvaluesIF, public SdCa
   * mounted
   * @return
   */
-  sd::SdCard getActiveSdCard() const override;
+  std::optional<sd::SdCard> getActiveSdCard() const override;

  /**
   * Unmount the specified SD card. This is recommended before switching it off. The SD card
@ -193,7 +187,7 @@ class SdCardManager : public SystemObject, public HasReturnvaluesIF, public SdCa
   * @param prefSdCardPtr
   * @return
   */
-  std::string getCurrentMountPrefix() const override;
+  const std::string& getCurrentMountPrefix() const override;

  OpStatus checkCurrentOp(Operations& currentOp);

@ -212,7 +206,7 @@ class SdCardManager : public SystemObject, public HasReturnvaluesIF, public SdCa
   *
   * @return  true if mounted, otherwise false
   */
-  bool isSdCardMounted(sd::SdCard sdCard) override;
+  bool isSdCardUsable(std::optional<sd::SdCard> sdCard) override;

  ReturnValue_t isSdCardMountedReadOnly(sd::SdCard sdcard, bool& readOnly);

@ -220,11 +214,15 @@ class SdCardManager : public SystemObject, public HasReturnvaluesIF, public SdCa

  ReturnValue_t performFsck(sd::SdCard sdcard, bool printOutput, int& linuxError);

+  void markUnusable();
+
 private:
  CommandExecutor cmdExecutor;
  Operations currentOp = Operations::IDLE;
  bool blocking = false;
+  bool sdCardActive = true;
  bool printCmdOutput = true;
+  bool markedUnusable = false;
  MutexIF* mutex = nullptr;

  SdCardManager();
--- a/bsp_q7s/fs/helpers.cpp
+++ b/bsp_q7s/fs/helpers.cpp
@ -0,0 +1,8 @@
+#include "helpers.h"
+
+std::filesystem::path fshelpers::getPrefixedPath(SdCardManager &man,
+                                                 std::filesystem::path pathWihtoutPrefix) {
+  auto prefix = man.getCurrentMountPrefix();
+  auto resPath = prefix / pathWihtoutPrefix;
+  return resPath;
+}
--- a/bsp_q7s/fs/helpers.h
+++ b/bsp_q7s/fs/helpers.h
@ -0,0 +1,14 @@
+#ifndef BSP_Q7S_MEMORY_HELPERS_H_
+#define BSP_Q7S_MEMORY_HELPERS_H_
+
+#include <filesystem>
+
+#include "SdCardManager.h"
+
+namespace fshelpers {
+
+std::filesystem::path getPrefixedPath(SdCardManager& man, std::filesystem::path pathWihtoutPrefix);
+
+}
+
+#endif /* BSP_Q7S_MEMORY_HELPERS_H_ */
--- a/bsp_q7s/memory/CMakeLists.txt
+++ b/bsp_q7s/memory/CMakeLists.txt
@ -1,2 +1 @@
-target_sources(${OBSW_NAME} PRIVATE FileSystemHandler.cpp SdCardManager.cpp
-                                    scratchApi.cpp FilesystemHelper.cpp)
+target_sources(${OBSW_NAME} PRIVATE scratchApi.cpp)
--- a/bsp_q7s/memory/FileSystemHandler.cpp
+++ b/bsp_q7s/memory/FileSystemHandler.cpp
@ -1,238 +0,0 @@
-#include "FileSystemHandler.h"
-
-#include <cstring>
-#include <filesystem>
-#include <fstream>
-
-#include "bsp_q7s/core/CoreController.h"
-#include "fsfw/ipc/QueueFactory.h"
-#include "fsfw/memory/GenericFileSystemMessage.h"
-#include "fsfw/tasks/TaskFactory.h"
-
-FileSystemHandler::FileSystemHandler(object_id_t fileSystemHandler)
-    : SystemObject(fileSystemHandler) {
-  auto mqArgs = MqArgs(this->getObjectId());
-  mq = QueueFactory::instance()->createMessageQueue(FS_MAX_QUEUE_SIZE,
-                                                    MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
-}
-
-FileSystemHandler::~FileSystemHandler() { QueueFactory::instance()->deleteMessageQueue(mq); }
-
-ReturnValue_t FileSystemHandler::performOperation(uint8_t unsignedChar) {
-  while (true) {
-    try {
-      fileSystemHandlerLoop();
-    } catch (std::bad_alloc& e) {
-      // Restart OBSW, hints at a memory leak
-      sif::error << "Allocation error in FileSystemHandler::performOperation" << e.what()
-                 << std::endl;
-      // Set up an error file or a special flag in the scratch buffer for these cases
-      triggerEvent(CoreController::ALLOC_FAILURE, 0, 0);
-      CoreController::incrementAllocationFailureCount();
-    }
-  }
-}
-
-void FileSystemHandler::fileSystemHandlerLoop() {
-  CommandMessage filemsg;
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-  while (true) {
-    if (opCounter % 5 == 0) {
-      if (coreCtrl->sdInitFinished()) {
-        fileSystemCheckup();
-      }
-    }
-    result = mq->receiveMessage(&filemsg);
-    if (result == MessageQueueIF::EMPTY) {
-      break;
-    } else if (result != HasReturnvaluesIF::RETURN_FAILED) {
-      sif::warning << "FileSystemHandler::performOperation: Message reception failed!" << std::endl;
-      break;
-    }
-    Command_t command = filemsg.getCommand();
-    switch (command) {
-      case (GenericFileSystemMessage::CMD_CREATE_DIRECTORY): {
-        break;
-      }
-      case (GenericFileSystemMessage::CMD_CREATE_FILE): {
-        break;
-      }
-    }
-    opCounter++;
-  }
-
-  // This task will have a low priority and will run permanently in the background
-  // so we will just run in a permanent loop here and check file system
-  // messages permanently
-  opCounter++;
-  TaskFactory::instance()->delayTask(1000);
-}
-
-void FileSystemHandler::fileSystemCheckup() {
-  SdCardManager::SdStatePair statusPair;
-  sdcMan->getSdCardsStatus(statusPair);
-  sd::SdCard preferredSdCard = sdcMan->getPreferredSdCard();
-  if ((preferredSdCard == sd::SdCard::SLOT_0) and (statusPair.first == sd::SdState::MOUNTED)) {
-    currentMountPrefix = SdCardManager::SD_0_MOUNT_POINT;
-  } else if ((preferredSdCard == sd::SdCard::SLOT_1) and
-             (statusPair.second == sd::SdState::MOUNTED)) {
-    currentMountPrefix = SdCardManager::SD_1_MOUNT_POINT;
-  } else {
-    std::string sdString;
-    if (preferredSdCard == sd::SdCard::SLOT_0) {
-      sdString = "0";
-    } else {
-      sdString = "1";
-    }
-    sif::warning << "FileSystemHandler::performOperation: "
-                    "Inconsistent state detected"
-                 << std::endl;
-    sif::warning << "Preferred SD card is " << sdString
-                 << " but does not appear to be mounted. Attempting fix.." << std::endl;
-    // This function will appear to fix the inconsistent state
-    ReturnValue_t result = sdcMan->sanitizeState(&statusPair, preferredSdCard);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-      // Oh no.
-      triggerEvent(SdCardManager::SANITIZATION_FAILED, 0, 0);
-      sif::error << "FileSystemHandler::fileSystemCheckup: Sanitization failed" << std::endl;
-    }
-  }
-}
-
-MessageQueueId_t FileSystemHandler::getCommandQueue() const { return mq->getId(); }
-
-ReturnValue_t FileSystemHandler::initialize() {
-  coreCtrl = ObjectManager::instance()->get<CoreController>(objects::CORE_CONTROLLER);
-  if (coreCtrl == nullptr) {
-    sif::error << "FileSystemHandler::initialize: Could not retrieve core controller handle"
-               << std::endl;
-  }
-  sdcMan = SdCardManager::instance();
-  sd::SdCard preferredSdCard = sdcMan->getPreferredSdCard();
-  if (preferredSdCard == sd::SdCard::SLOT_0) {
-    currentMountPrefix = SdCardManager::SD_0_MOUNT_POINT;
-  } else if (preferredSdCard == sd::SdCard::SLOT_1) {
-    currentMountPrefix = SdCardManager::SD_1_MOUNT_POINT;
-  }
-  return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t FileSystemHandler::appendToFile(const char* repositoryPath, const char* filename,
-                                              const uint8_t* data, size_t size,
-                                              uint16_t packetNumber, FileSystemArgsIF* args) {
-  auto path = getInitPath(args) / repositoryPath / filename;
-  if (not std::filesystem::exists(path)) {
-    return FILE_DOES_NOT_EXIST;
-  }
-  std::ofstream file(path, std::ios_base::app | std::ios_base::out);
-  file.write(reinterpret_cast<const char*>(data), size);
-  if (not file.good()) {
-    return GENERIC_FILE_ERROR;
-  }
-  return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t FileSystemHandler::createFile(const char* repositoryPath, const char* filename,
-                                            const uint8_t* data, size_t size,
-                                            FileSystemArgsIF* args) {
-  auto path = getInitPath(args) / filename;
-  if (std::filesystem::exists(path)) {
-    return FILE_ALREADY_EXISTS;
-  }
-  std::ofstream file(path);
-  file.write(reinterpret_cast<const char*>(data), size);
-  if (not file.good()) {
-    return GENERIC_FILE_ERROR;
-  }
-  return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t FileSystemHandler::removeFile(const char* repositoryPath, const char* filename,
-                                            FileSystemArgsIF* args) {
-  auto path = getInitPath(args) / repositoryPath / filename;
-  if (not std::filesystem::exists(path)) {
-    return FILE_DOES_NOT_EXIST;
-  }
-  int result = std::remove(path.c_str());
-  if (result != 0) {
-    sif::warning << "FileSystemHandler::deleteFile: Failed with code " << result << std::endl;
-    return GENERIC_FILE_ERROR;
-  }
-  return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t FileSystemHandler::createDirectory(const char* repositoryPath, const char* dirname,
-                                                 bool createParentDirs, FileSystemArgsIF* args) {
-  auto path = getInitPath(args) / repositoryPath / dirname;
-  if (std::filesystem::exists(path)) {
-    return DIRECTORY_ALREADY_EXISTS;
-  }
-  if (std::filesystem::create_directory(path)) {
-    return HasReturnvaluesIF::RETURN_OK;
-  }
-  sif::warning << "Creating directory " << path << " failed" << std::endl;
-  return GENERIC_FILE_ERROR;
-}
-
-ReturnValue_t FileSystemHandler::removeDirectory(const char* repositoryPath, const char* dirname,
-                                                 bool deleteRecurively, FileSystemArgsIF* args) {
-  auto path = getInitPath(args) / repositoryPath / dirname;
-  if (not std::filesystem::exists(path)) {
-    return DIRECTORY_DOES_NOT_EXIST;
-  }
-  std::error_code err;
-  if (not deleteRecurively) {
-    if (std::filesystem::remove(path, err)) {
-      return HasReturnvaluesIF::RETURN_OK;
-    } else {
-      // Check error code. Most probably denied permissions because folder is not empty
-      sif::warning << "FileSystemHandler::removeDirectory: Deleting directory failed with "
-                      "code "
-                   << err.value() << ": " << strerror(err.value()) << std::endl;
-      if (err.value() == ENOTEMPTY) {
-        return DIRECTORY_NOT_EMPTY;
-      } else {
-        return GENERIC_FILE_ERROR;
-      }
-    }
-  } else {
-    if (std::filesystem::remove_all(path, err)) {
-      return HasReturnvaluesIF::RETURN_OK;
-    } else {
-      sif::warning << "FileSystemHandler::removeDirectory: Deleting directory failed with "
-                      "code "
-                   << err.value() << ": " << strerror(err.value()) << std::endl;
-      // Check error code
-      if (err.value() == ENOTEMPTY) {
-        return DIRECTORY_NOT_EMPTY;
-      } else {
-        return GENERIC_FILE_ERROR;
-      }
-    }
-  }
-
-  return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t FileSystemHandler::renameFile(const char* repositoryPath, const char* oldFilename,
-                                            const char* newFilename, FileSystemArgsIF* args) {
-  auto basepath = getInitPath(args) / repositoryPath;
-  std::filesystem::rename(basepath / oldFilename, basepath / newFilename);
-  return HasReturnvaluesIF::RETURN_OK;
-}
-
-void FileSystemHandler::parseCfg(FsCommandCfg* cfg, bool& useMountPrefix) {
-  if (cfg != nullptr) {
-    useMountPrefix = cfg->useMountPrefix;
-  }
-}
-
-std::filesystem::path FileSystemHandler::getInitPath(FileSystemArgsIF* args) {
-  bool useMountPrefix = true;
-  parseCfg(reinterpret_cast<FsCommandCfg*>(args), useMountPrefix);
-  std::string path;
-  if (useMountPrefix) {
-    path = currentMountPrefix;
-  }
-  return std::filesystem::path(path);
-}
--- a/bsp_q7s/memory/FileSystemHandler.h
+++ b/bsp_q7s/memory/FileSystemHandler.h
@ -1,68 +0,0 @@
-#ifndef BSP_Q7S_MEMORY_FILESYSTEMHANDLER_H_
-#define BSP_Q7S_MEMORY_FILESYSTEMHANDLER_H_
-
-#include <filesystem>
-#include <string>
-
-#include "OBSWConfig.h"
-#include "SdCardManager.h"
-#include "eive/definitions.h"
-#include "fsfw/ipc/MessageQueueIF.h"
-#include "fsfw/memory/HasFileSystemIF.h"
-#include "fsfw/objectmanager/SystemObject.h"
-#include "fsfw/tasks/ExecutableObjectIF.h"
-
-class CoreController;
-
-class FileSystemHandler : public SystemObject, public ExecutableObjectIF, public HasFileSystemIF {
- public:
-  struct FsCommandCfg : public FileSystemArgsIF {
-    // Can be used to automatically use mount prefix of active SD card.
-    // Otherwise, the operator has to specify the full path to the mounted SD card as well.
-    bool useMountPrefix = false;
-  };
-
-  FileSystemHandler(object_id_t fileSystemHandler);
-  virtual ~FileSystemHandler();
-
-  ReturnValue_t performOperation(uint8_t) override;
-
-  ReturnValue_t initialize() override;
-
-  /**
-   * Function to get the MessageQueueId_t of the implementing object
-   * @return MessageQueueId_t of the object
-   */
-  MessageQueueId_t getCommandQueue() const override;
-  ReturnValue_t appendToFile(const char* repositoryPath, const char* filename, const uint8_t* data,
-                             size_t size, uint16_t packetNumber,
-                             FileSystemArgsIF* args = nullptr) override;
-  ReturnValue_t createFile(const char* repositoryPath, const char* filename,
-                           const uint8_t* data = nullptr, size_t size = 0,
-                           FileSystemArgsIF* args = nullptr) override;
-  ReturnValue_t removeFile(const char* repositoryPath, const char* filename,
-                           FileSystemArgsIF* args = nullptr) override;
-  ReturnValue_t createDirectory(const char* repositoryPath, const char* dirname,
-                                bool createParentDirs, FileSystemArgsIF* args = nullptr) override;
-  ReturnValue_t removeDirectory(const char* repositoryPath, const char* dirname,
-                                bool deleteRecurively = false,
-                                FileSystemArgsIF* args = nullptr) override;
-  ReturnValue_t renameFile(const char* repositoryPath, const char* oldFilename,
-                           const char* newFilename, FileSystemArgsIF* args = nullptr) override;
-
- private:
-  CoreController* coreCtrl = nullptr;
-  MessageQueueIF* mq = nullptr;
-  std::string currentMountPrefix = SdCardManager::SD_0_MOUNT_POINT;
-  static constexpr uint32_t FS_MAX_QUEUE_SIZE = config::OBSW_FILESYSTEM_HANDLER_QUEUE_SIZE;
-
-  SdCardManager* sdcMan = nullptr;
-  uint8_t opCounter = 0;
-
-  void fileSystemHandlerLoop();
-  void fileSystemCheckup();
-  std::filesystem::path getInitPath(FileSystemArgsIF* args);
-  void parseCfg(FsCommandCfg* cfg, bool& useMountPrefix);
-};
-
-#endif /* BSP_Q7S_MEMORY_FILESYSTEMMANAGER_H_ */
--- a/bsp_q7s/memory/scratchApi.cpp
+++ b/bsp_q7s/memory/scratchApi.cpp
@ -1,28 +1,28 @@
 #include "scratchApi.h"

 ReturnValue_t scratch::writeString(std::string name, std::string string) {
-  std::ostringstream oss;
-  oss << "xsc_scratch write " << name << " \"" << string << "\"";
+  std::ostringstream oss("xsc_scratch write ", std::ostringstream::ate);
+  oss << name << " \"" << string << "\"";
  int result = std::system(oss.str().c_str());
  if (result != 0) {
    utility::handleSystemError(result, "scratch::writeString");
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
  }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t scratch::readString(std::string key, std::string &string) {
  std::ifstream file;
  std::string filename;
  ReturnValue_t result = readToFile(key, file, filename);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }

  std::string line;
  if (not std::getline(file, line)) {
    std::remove(filename.c_str());
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
  }

  size_t pos = line.find("=");
@ -35,16 +35,16 @@ ReturnValue_t scratch::readString(std::string key, std::string &string) {
    return KEY_NOT_FOUND;
  }
  string = line.substr(pos + 1);
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t scratch::clearValue(std::string key) {
-  std::ostringstream oss;
-  oss << "xsc_scratch clear " << key;
+  std::ostringstream oss("xsc_scratch clear ", std::ostringstream::ate);
+  oss << key;
  int result = std::system(oss.str().c_str());
  if (result != 0) {
    utility::handleSystemError(result, "scratch::clearValue");
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
  }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
--- a/bsp_q7s/memory/scratchApi.h
+++ b/bsp_q7s/memory/scratchApi.h
@ -7,7 +7,7 @@
 #include <sstream>
 #include <type_traits>

-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 #include "linux/utility/utility.h"
 #include "returnvalues/classIds.h"
@ -21,7 +21,7 @@ static constexpr char PREFERED_SDC_KEY[] = "PREFSD";
 static constexpr char ALLOC_FAILURE_COUNT[] = "ALLOCERR";

 static constexpr uint8_t INTERFACE_ID = CLASS_ID::SCRATCH_BUFFER;
-static constexpr ReturnValue_t KEY_NOT_FOUND = HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 0);
+static constexpr ReturnValue_t KEY_NOT_FOUND = returnvalue::makeCode(INTERFACE_ID, 0);

 ReturnValue_t clearValue(std::string key);

@ -83,25 +83,25 @@ ReturnValue_t readToFile(std::string name, std::ifstream& file, std::string& fil
    } else {
      utility::handleSystemError(result, "scratch::readToFile");
      std::remove(filename.c_str());
-      return HasReturnvaluesIF::RETURN_FAILED;
+      return returnvalue::FAILED;
    }
  }
  file.open(filename);
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

 }  // End of anonymous namespace

 template <typename T, class = typename std::enable_if<std::is_integral<T>::value>::type>
 inline ReturnValue_t writeNumber(std::string key, T num) noexcept {
-  std::ostringstream oss;
-  oss << "xsc_scratch write " << key << " " << std::to_string(num);
+  std::ostringstream oss("xsc_scratch write ", std::ostringstream::ate);
+  oss << key << " " << std::to_string(num);
  int result = std::system(oss.str().c_str());
  if (result != 0) {
    utility::handleSystemError(result, "scratch::writeNumber");
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
  }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

 template <typename T, class = typename std::enable_if<std::is_integral<T>::value>::type>
@ -110,7 +110,7 @@ inline ReturnValue_t readNumber(std::string key, T& num) noexcept {
  ifstream file;
  std::string filename;
  ReturnValue_t result = readToFile(key, file, filename);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    std::remove(filename.c_str());
    return result;
  }
@ -118,7 +118,7 @@ inline ReturnValue_t readNumber(std::string key, T& num) noexcept {
  string line;
  if (not std::getline(file, line)) {
    std::remove(filename.c_str());
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
  }

  size_t pos = line.find("=");
@ -138,7 +138,7 @@ inline ReturnValue_t readNumber(std::string key, T& num) noexcept {
  }

  std::remove(filename.c_str());
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

 }  // namespace scratch
--- a/bsp_q7s/xadc/Xadc.cpp
+++ b/bsp_q7s/xadc/Xadc.cpp
@ -12,20 +12,20 @@ Xadc::Xadc() {}
 Xadc::~Xadc() {}

 ReturnValue_t Xadc::getTemperature(float& temperature) {
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
  int raw = 0;
  int offset = 0;
  float scale = 0;
  result = readValFromFile<int>(xadc::file::tempRaw.c_str(), raw);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  result = readValFromFile<int>(xadc::file::tempOffset.c_str(), offset);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  result = readValFromFile<float>(xadc::file::tempScale.c_str(), scale);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  temperature = (raw + offset) * scale / 1000;
@ -35,84 +35,84 @@ ReturnValue_t Xadc::getTemperature(float& temperature) {
 ReturnValue_t Xadc::getVccPint(float& vccPint) {
  ReturnValue_t result =
      readVoltageFromSysfs(xadc::file::vccpintRaw, xadc::file::vccpintScale, vccPint);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t Xadc::getVccPaux(float& vccPaux) {
  ReturnValue_t result =
      readVoltageFromSysfs(xadc::file::vccpauxRaw, xadc::file::vccpauxScale, vccPaux);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t Xadc::getVccInt(float& vccInt) {
  ReturnValue_t result =
      readVoltageFromSysfs(xadc::file::vccintRaw, xadc::file::vccintScale, vccInt);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t Xadc::getVccAux(float& vccAux) {
  ReturnValue_t result =
      readVoltageFromSysfs(xadc::file::vccauxRaw, xadc::file::vccauxScale, vccAux);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t Xadc::getVccBram(float& vccBram) {
  ReturnValue_t result =
      readVoltageFromSysfs(xadc::file::vccbramRaw, xadc::file::vccbramScale, vccBram);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t Xadc::getVccOddr(float& vccOddr) {
  ReturnValue_t result =
      readVoltageFromSysfs(xadc::file::vccoddrRaw, xadc::file::vccoddrScale, vccOddr);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t Xadc::getVrefp(float& vrefp) {
  ReturnValue_t result = readVoltageFromSysfs(xadc::file::vrefpRaw, xadc::file::vrefpScale, vrefp);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t Xadc::getVrefn(float& vrefn) {
  ReturnValue_t result = readVoltageFromSysfs(xadc::file::vrefnRaw, xadc::file::vrefnScale, vrefn);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t Xadc::readVoltageFromSysfs(std::string rawFile, std::string scaleFile,
                                         float& voltage) {
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
  float raw = 0;
  float scale = 0;
  result = readValFromFile(rawFile.c_str(), raw);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  result = readValFromFile(scaleFile.c_str(), scale);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  voltage = calculateVoltage(raw, scale);
@ -127,7 +127,7 @@ ReturnValue_t Xadc::readValFromFile(const char* filename, T& val) {
  fp = fopen(filename, "r");
  if (fp == nullptr) {
    sif::warning << "Xadc::readValFromFile: Failed to open file " << filename << std::endl;
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
  }
  char valstring[MAX_STR_LENGTH] = "";
  char* returnVal = fgets(valstring, MAX_STR_LENGTH, fp);
@ -135,10 +135,10 @@ ReturnValue_t Xadc::readValFromFile(const char* filename, T& val) {
    sif::warning << "Xadc::readValFromFile: Failed to read string from file " << filename
                 << std::endl;
    fclose(fp);
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
  }
  std::istringstream valSstream(valstring);
  valSstream >> val;
  fclose(fp);
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
--- a/bsp_q7s/xadc/Xadc.h
+++ b/bsp_q7s/xadc/Xadc.h
@ -3,7 +3,7 @@

 #include <string>

-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/returnvalues/returnvalue.h"

 namespace xadc {
 using namespace std;
--- a/bsp_te0720_1cfa/InitMission.cpp
+++ b/bsp_te0720_1cfa/InitMission.cpp
@ -2,7 +2,7 @@

 #include <fsfw/objectmanager/ObjectManager.h>
 #include <fsfw/objectmanager/ObjectManagerIF.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/returnvalues/returnvalue.h>
 #include <fsfw/serviceinterface/ServiceInterface.h>
 #include <fsfw/tasks/FixedTimeslotTaskIF.h>
 #include <fsfw/tasks/PeriodicTaskIF.h>
@ -36,7 +36,7 @@ void initmission::initMission() {

 void initmission::initTasks() {
  TaskFactory* factory = TaskFactory::instance();
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
  if (factory == nullptr) {
    /* Should never happen ! */
    return;
@ -51,28 +51,28 @@ void initmission::initTasks() {
  PeriodicTaskIF* tmtcDistributor = factory->createPeriodicTask(
      "DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
  result = tmtcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "Object add component failed" << std::endl;
  }
  result = tmtcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "Object add component failed" << std::endl;
  }
  result = tmtcDistributor->addComponent(objects::TM_FUNNEL);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "Object add component failed" << std::endl;
  }

  PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask(
      "TMTC_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
  result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "Add component TMTC Bridge failed" << std::endl;
  }
  PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask(
      "TMTC_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
  result = tmtcPollingTask->addComponent(objects::TMTC_POLLING_TASK);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "Add component TMTC Polling failed" << std::endl;
  }

@ -84,7 +84,7 @@ void initmission::initTasks() {
  FixedTimeslotTaskIF* pst = factory->createFixedTimeslotTask(
      "UART_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 1.0, missedDeadlineFunc);
  result = pst::pstUart(pst);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
  }
  pstTasks.push_back(pst);
@ -93,7 +93,7 @@ void initmission::initTasks() {
  PeriodicTaskIF* mpsocHelperTask = factory->createPeriodicTask(
      "PLOC_MPSOC_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
  result = mpsocHelperTask->addComponent(objects::PLOC_MPSOC_HELPER);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PLOC_MPSOC_HELPER", objects::PLOC_MPSOC_HELPER);
  }
 #endif /* OBSW_ADD_PLOC_MPSOC == 1*/
@ -102,16 +102,16 @@ void initmission::initTasks() {
  PeriodicTaskIF* supvHelperTask = factory->createPeriodicTask(
      "PLOC_SUPV_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
  result = supvHelperTask->addComponent(objects::PLOC_SUPERVISOR_HELPER);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PLOC_SUPV_HELPER", objects::PLOC_SUPERVISOR_HELPER);
  }
 #endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */

-#if OBSW_USE_CCSDS_IP_CORE == 1
+#if OBSW_ADD_CCSDS_IP_CORES == 1
  PeriodicTaskIF* ccsdsHandlerTask = factory->createPeriodicTask(
      "CCSDS_HANDLER", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
  result = ccsdsHandlerTask->addComponent(objects::CCSDS_HANDLER);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("CCSDS Handler", objects::CCSDS_HANDLER);
  }

@ -121,10 +121,10 @@ void initmission::initTasks() {
  PeriodicTaskIF* pdecHandlerTask = factory->createPeriodicTask(
      "PDEC_HANDLER", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
  result = pdecHandlerTask->addComponent(objects::PDEC_HANDLER);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PDEC Handler", objects::PDEC_HANDLER);
  }
-#endif /* OBSW_USE_CCSDS_IP_CORE == 1 */
+#endif /* OBSW_ADD_CCSDS_IP_CORES == 1 */

  auto taskStarter = [](std::vector<PeriodicTaskIF*>& taskVector, std::string name) {
    for (const auto& task : taskVector) {
@ -140,10 +140,10 @@ void initmission::initTasks() {
  tmtcDistributor->startTask();
  tmtcBridgeTask->startTask();
  tmtcPollingTask->startTask();
-#if OBSW_USE_CCSDS_IP_CORE == 1
+#if OBSW_ADD_CCSDS_IP_CORE == 1
  pdecHandlerTask->startTask();
  ccsdsHandlerTask->startTask();
-#endif /* #if OBSW_USE_CCSDS_IP_CORE == 1 */
+#endif /* #if OBSW_ADD_CCSDS_IP_CORE == 1 */
 #if OBSW_ADD_PLOC_SUPERVISOR == 1
  supvHelperTask->startTask();
 #endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
@ -160,11 +160,11 @@ void initmission::initTasks() {
 void initmission::createPusTasks(TaskFactory& factory,
                                 TaskDeadlineMissedFunction missedDeadlineFunc,
                                 std::vector<PeriodicTaskIF*>& taskVec) {
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
  PeriodicTaskIF* pusVerification = factory.createPeriodicTask(
      "PUS_VERIF", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
  result = pusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::error << "Object add component failed" << std::endl;
  }
  taskVec.push_back(pusVerification);
@ -172,11 +172,11 @@ void initmission::createPusTasks(TaskFactory& factory,
  PeriodicTaskIF* pusEvents = factory.createPeriodicTask(
      "PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
  result = pusEvents->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS_EVENTS", objects::PUS_SERVICE_5_EVENT_REPORTING);
  }
  result = pusEvents->addComponent(objects::EVENT_MANAGER);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS_MGMT", objects::EVENT_MANAGER);
  }
  taskVec.push_back(pusEvents);
@ -184,11 +184,11 @@ void initmission::createPusTasks(TaskFactory& factory,
  PeriodicTaskIF* pusHighPrio = factory.createPeriodicTask(
      "PUS_HIGH_PRIO", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
  result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
  }
  result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT);
  }
  taskVec.push_back(pusHighPrio);
@ -196,19 +196,19 @@ void initmission::createPusTasks(TaskFactory& factory,
  PeriodicTaskIF* pusMedPrio = factory.createPeriodicTask(
      "PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
  result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
  }
  result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS200", objects::PUS_SERVICE_200_MODE_MGMT);
  }
  result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS20", objects::PUS_SERVICE_20_PARAMETERS);
  }
  result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS3", objects::PUS_SERVICE_3_HOUSEKEEPING);
  }
  taskVec.push_back(pusMedPrio);
@ -216,11 +216,11 @@ void initmission::createPusTasks(TaskFactory& factory,
  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 != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("PUS17", objects::PUS_SERVICE_17_TEST);
  }
  result = pusLowPrio->addComponent(objects::INTERNAL_ERROR_REPORTER);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    initmission::printAddObjectError("INT_ERR_RPRT", objects::INTERNAL_ERROR_REPORTER);
  }
  taskVec.push_back(pusLowPrio);
--- a/bsp_te0720_1cfa/OBSWConfig.h.in
+++ b/bsp_te0720_1cfa/OBSWConfig.h.in
@ -13,7 +13,7 @@
 /** All of the following flags should be enabled for mission code  */
 /*******************************************************************/

-#define OBSW_USE_CCSDS_IP_CORE                      0
+#define OBSW_ADD_CCSDS_IP_CORE                      0
 // Set to 1 if all telemetry should be sent to the PTME IP Core
 #define OBSW_TM_TO_PTME                             0
 // Set to 1 if telecommands are received via the PDEC IP Core
--- a/bsp_te0720_1cfa/ObjectFactory.cpp
+++ b/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,
--- a/common/config/commonConfig.cpp
+++ b/common/config/commonConfig.cpp
@ -1,8 +1,11 @@
 #include "commonConfig.h"

-#include "fsfw/tmtcpacket/SpacePacket.h"
-#include "tmtc/apid.h"
+#include "eive/definitions.h"
+#include "fsfw/tmtcpacket/ccsds/defs.h"

 const fsfw::Version common::OBSW_VERSION{OBSW_VERSION_MAJOR, OBSW_VERSION_MINOR,
                                         OBSW_VERSION_REVISION, OBSW_VERSION_CST_GIT_SHA1};
-const uint16_t common::PUS_PACKET_ID = spacepacket::getTcSpacePacketIdFromApid(apid::EIVE_OBSW);
+const uint16_t common::PUS_PACKET_ID =
+    ccsds::getTcSpacePacketIdFromApid(config::EIVE_PUS_APID, true);
+const uint16_t common::CFDP_PACKET_ID =
+    ccsds::getTcSpacePacketIdFromApid(config::EIVE_CFDP_APID, false);
--- a/common/config/commonConfig.h.in
+++ b/common/config/commonConfig.h.in
@ -25,6 +25,8 @@ debugging. */
 // CCSDS IP Cores. 
 #define OBSW_USE_TMTC_TCP_BRIDGE            1

+#define OBSW_ADD_CFDP_COMPONENTS            1
+
 namespace common {

 static constexpr uint8_t OBSW_VERSION_MAJOR = @OBSW_VERSION_MAJOR@;
@ -39,6 +41,7 @@ static constexpr uint32_t OBSW_MAX_SCHEDULED_TCS = @OBSW_MAX_SCHEDULED_TCS@;
 extern const fsfw::Version OBSW_VERSION;

 extern const uint16_t PUS_PACKET_ID;
+extern const uint16_t CFDP_PACKET_ID;

 static constexpr uint32_t CCSDS_HANDLER_QUEUE_SIZE = 50;
 static constexpr uint8_t NUMBER_OF_VIRTUAL_CHANNELS = 4;
--- a/common/config/devConf.h
+++ b/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
@ -55,6 +55,7 @@ namespace uart {

 static constexpr size_t HYPERION_GPS_REPLY_MAX_BUFFER = 1024;
 static constexpr UartBaudRate SYRLINKS_BAUD = UartBaudRate::RATE_38400;
+static constexpr UartBaudRate SCEX_BAUD = UartBaudRate::RATE_38400;
 static constexpr UartBaudRate GNSS_BAUD = UartBaudRate::RATE_9600;
 static constexpr UartBaudRate PLOC_MPSOC_BAUD = UartBaudRate::RATE_115200;
 static constexpr UartBaudRate PLOC_SUPV_BAUD = UartBaudRate::RATE_115200;
--- a/common/config/eive/definitions.h
+++ b/common/config/eive/definitions.h
@ -5,6 +5,21 @@

 namespace config {

+static constexpr char SD_0_MOUNT_POINT[] = "/mnt/sd0";
+static constexpr char SD_1_MOUNT_POINT[] = "/mnt/sd1";
+
+static constexpr char OBSW_UPDATE_ARCHIVE_FILE_NAME[] = "eive-sw-update.tar.xz";
+static constexpr char STRIPPED_OBSW_BINARY_FILE_NAME[] = "eive-obsw-stripped";
+static constexpr char OBSW_VERSION_FILE_NAME[] = "obsw_version.txt";
+
+static constexpr char OBSW_PATH[] = "/usr/bin/eive-obsw";
+static constexpr char OBSW_VERSION_FILE_PATH[] = "/usr/share/eive-obsw/obsw_version.txt";
+
+static constexpr uint16_t EIVE_PUS_APID = 0x65;
+static constexpr uint16_t EIVE_CFDP_APID = 0x66;
+static constexpr uint16_t EIVE_LOCAL_CFDP_ENTITY_ID = EIVE_CFDP_APID;
+static constexpr uint16_t EIVE_GROUND_CFDP_ENTITY_ID = 1;
+
 static constexpr uint32_t PL_PCDU_TRANSITION_TIMEOUT_MS = 20 * 60 * 1000;
 static constexpr uint32_t LONGEST_MODE_TIMEOUT_SECONDS = PL_PCDU_TRANSITION_TIMEOUT_MS / 1000;

@ -19,6 +34,15 @@ static constexpr uint8_t LIVE_TM = 0;
 static constexpr uint32_t MAX_PATH_SIZE = 100;
 static constexpr uint32_t MAX_FILENAME_SIZE = 50;

+static constexpr uint32_t SA_DEPL_INIT_BUFFER_SECS = 120;
+// Burn time for autonomous deployment
+static constexpr uint32_t SA_DEPL_BURN_TIME_SECS = 180;
+static constexpr uint32_t SA_DEPL_WAIT_TIME_SECS = 45 * 60;
+// HW constraints (current limit) mean that the GPIO channels need to be switched on in alternation
+static constexpr uint32_t SA_DEPL_CHANNEL_ALTERNATION_INTERVAL_SECS = 5;
+// Maximum allowed burn time allowed by the software.
+static constexpr uint32_t SA_DEPL_MAX_BURN_TIME = 180;
+
 }  // namespace config

 #endif /* COMMON_CONFIG_DEFINITIONS_H_ */
--- a/common/config/eive/eventSubsystemIds.h
+++ b/common/config/eive/eventSubsystemIds.h
@ -4,6 +4,7 @@
 #include <fsfw/events/fwSubsystemIdRanges.h>

 namespace SUBSYSTEM_ID {
+
 enum : uint8_t {
  COMMON_SUBSYSTEM_ID_START = FW_SUBSYSTEM_ID_RANGE,
  ACS_SUBSYSTEM = 112,
@ -32,7 +33,10 @@ enum : uint8_t {
  ACU_HANDLER = 135,
  PLOC_SUPV_HELPER = 136,
  SYRLINKS = 137,
+  SCEX_HANDLER = 138,
+  CONFIGHANDLER = 139,
  COMMON_SUBSYSTEM_ID_END
+
 };
 }

--- a/common/config/commonObjects.h
+++ b/common/config/commonObjects.h
@ -18,8 +18,9 @@ enum commonObjects : uint32_t {

  /* 0x43 ('C') for Controllers */
  THERMAL_CONTROLLER = 0x43400001,
-  ACS_CONTROLLER = 0x43100002,
+  ACS_CONTROLLER = 0x43000002,
  CORE_CONTROLLER = 0x43000003,
+  GLOBAL_JSON_CFG = 0x43000006,

  /* 0x44 ('D') for device handlers */
  MGM_0_LIS3_HANDLER = 0x44120006,
@ -38,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,
@ -57,6 +62,7 @@ enum commonObjects : uint32_t {
  PLOC_MPSOC_HANDLER = 0x44330015,
  PLOC_SUPERVISOR_HANDLER = 0x44330016,
  PLOC_SUPERVISOR_HELPER = 0x44330017,
+  SCEX = 0x44330032,
  SOLAR_ARRAY_DEPL_HANDLER = 0x444100A2,
  HEATER_HANDLER = 0x444100A4,

@ -107,6 +113,9 @@ enum commonObjects : uint32_t {

  SYRLINKS_HK_HANDLER = 0x445300A3,

+  /* 0x49 ('I') for Communication Interfaces */
+  SPI_RTD_COM_IF = 0x49020006,
+
  // 0x60 for other stuff
  HEATER_0_PLOC_PROC_BRD = 0x60000000,
  HEATER_1_PCDU_BRD = 0x60000001,
@ -121,7 +130,16 @@ enum commonObjects : uint32_t {
  ACS_BOARD_ASS = 0x73000001,
  SUS_BOARD_ASS = 0x73000002,
  TCS_BOARD_ASS = 0x73000003,
-  RW_ASS = 0x73000004
+  RW_ASS = 0x73000004,
+  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,
 };
 }

--- a/common/config/eive/resultClassIds.h
+++ b/common/config/eive/resultClassIds.h
--- a/common/config/tmtc/apid.h
+++ b/common/config/tmtc/apid.h
@ -1,18 +0,0 @@
-#ifndef FSFWCONFIG_TMTC_APID_H_
-#define FSFWCONFIG_TMTC_APID_H_
-
-#include <cstdint>
-
-/**
- * Application Process Definition: entity, uniquely identified by an
- * application process ID (APID), capable of generating telemetry source
- * packets and receiving telecommand packets
- *
- * EIVE APID: 0x65 / 101 / e
- * APID is a 11 bit number
- */
-namespace apid {
-static const uint16_t EIVE_OBSW = 0x65;
-}
-
-#endif /* FSFWCONFIG_TMTC_APID_H_ */
--- a/dummies/AcuDummy.cpp
+++ b/dummies/AcuDummy.cpp
@ -19,16 +19,16 @@ ReturnValue_t AcuDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {

 ReturnValue_t AcuDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
                                                const uint8_t *commandData, size_t commandDataLen) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t AcuDummy::scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
                                     size_t *foundLen) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t AcuDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 void AcuDummy::fillCommandAndReplyMap() {}
@ -37,6 +37,6 @@ uint32_t AcuDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return

 ReturnValue_t AcuDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(P60System::pool::ACU_TEMPERATURES, new PoolEntry<float>(3));
-  return HasReturnvaluesIF::RETURN_OK;
+  localDataPoolMap.emplace(ACU::pool::ACU_TEMPERATURES, new PoolEntry<float>(3));
+  return returnvalue::OK;
 }
--- a/dummies/BpxDummy.cpp
+++ b/dummies/BpxDummy.cpp
@ -19,16 +19,16 @@ ReturnValue_t BpxDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {

 ReturnValue_t BpxDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
                                                const uint8_t *commandData, size_t commandDataLen) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t BpxDummy::scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
                                     size_t *foundLen) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t BpxDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 void BpxDummy::fillCommandAndReplyMap() {}
@ -51,5 +51,5 @@ ReturnValue_t BpxDummy::initializeLocalDataPool(localpool::DataPool &localDataPo
  localDataPoolMap.emplace(BpxBattery::BATTERY_HEATER_MODE, &battheatMode);
  localDataPoolMap.emplace(BpxBattery::BATTHEAT_LOW_LIMIT, &battheatLow);
  localDataPoolMap.emplace(BpxBattery::BATTHEAT_HIGH_LIMIT, &battheatHigh);
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
--- a/dummies/CMakeLists.txt
+++ b/dummies/CMakeLists.txt
@ -12,8 +12,11 @@ target_sources(
         AcuDummy.cpp
         PduDummy.cpp
         P60DockDummy.cpp
+         SaDeploymentDummy.cpp
         GyroAdisDummy.cpp
         GyroL3GD20Dummy.cpp
         MgmLIS3MDLDummy.cpp
         PlPcduDummy.cpp
-         CoreControllerDummy.cpp)
+         CoreControllerDummy.cpp
+         helpers.cpp
+         MgmRm3100Dummy.cpp)
--- a/dummies/ComIFDummy.cpp
+++ b/dummies/ComIFDummy.cpp
@ -4,18 +4,18 @@ ComIFDummy::ComIFDummy(object_id_t objectId) : SystemObject(objectId) {}

 ComIFDummy::~ComIFDummy() {}

-ReturnValue_t ComIFDummy::initializeInterface(CookieIF *cookie) { return RETURN_OK; }
+ReturnValue_t ComIFDummy::initializeInterface(CookieIF *cookie) { return returnvalue::OK; }

 ReturnValue_t ComIFDummy::sendMessage(CookieIF *cookie, const uint8_t *sendData, size_t sendLen) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

-ReturnValue_t ComIFDummy::getSendSuccess(CookieIF *cookie) { return RETURN_OK; }
+ReturnValue_t ComIFDummy::getSendSuccess(CookieIF *cookie) { return returnvalue::OK; }

 ReturnValue_t ComIFDummy::requestReceiveMessage(CookieIF *cookie, size_t requestLen) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t ComIFDummy::readReceivedMessage(CookieIF *cookie, uint8_t **buffer, size_t *size) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }
--- a/dummies/CoreControllerDummy.cpp
+++ b/dummies/CoreControllerDummy.cpp
@ -6,24 +6,23 @@
 #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;
  if (not done) {
    done = true;
    ReturnValue_t result = ExtendedControllerBase::initialize();
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
      return result;
    }
  }

-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t CoreControllerDummy::handleCommandMessage(CommandMessage* message) {
-  return RETURN_FAILED;
+  return returnvalue::FAILED;
 }

 void CoreControllerDummy::performControlOperation() { return; }
@ -33,7 +32,7 @@ ReturnValue_t CoreControllerDummy::initializeLocalDataPool(localpool::DataPool&
  localDataPoolMap.emplace(core::TEMPERATURE, new PoolEntry<float>({0}));
  localDataPoolMap.emplace(core::PS_VOLTAGE, new PoolEntry<float>({0}));
  localDataPoolMap.emplace(core::PL_VOLTAGE, new PoolEntry<float>({0}));
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

 LocalPoolDataSetBase* CoreControllerDummy::getDataSetHandle(sid_t sid) {
@ -51,5 +50,5 @@ ReturnValue_t CoreControllerDummy::checkModeCommand(Mode_t mode, Submode_t submo
  if ((mode != MODE_OFF) && (mode != MODE_ON) && (mode != MODE_NORMAL)) {
    return INVALID_MODE;
  }
-  return RETURN_OK;
+  return returnvalue::OK;
 }
--- a/dummies/GyroAdisDummy.cpp
+++ b/dummies/GyroAdisDummy.cpp
@ -3,7 +3,7 @@
 #include "mission/devices/devicedefinitions/GyroADIS1650XDefinitions.h"

 GyroAdisDummy::GyroAdisDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
-    : DeviceHandlerBase(objectId, comif, comCookie) {}
+    : DeviceHandlerBase(objectId, comif, comCookie), dataset(this) {}

 GyroAdisDummy::~GyroAdisDummy() {}

@ -22,16 +22,16 @@ ReturnValue_t GyroAdisDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id)
 ReturnValue_t GyroAdisDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
                                                     const uint8_t *commandData,
                                                     size_t commandDataLen) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t GyroAdisDummy::scanForReply(const uint8_t *start, size_t len,
                                          DeviceCommandId_t *foundId, size_t *foundLen) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t GyroAdisDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 void GyroAdisDummy::fillCommandAndReplyMap() {}
@ -41,5 +41,5 @@ uint32_t GyroAdisDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { r
 ReturnValue_t GyroAdisDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                     LocalDataPoolManager &poolManager) {
  localDataPoolMap.emplace(ADIS1650X::TEMPERATURE, new PoolEntry<float>({0.0}));
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
--- a/dummies/GyroAdisDummy.h
+++ b/dummies/GyroAdisDummy.h
@ -3,6 +3,8 @@

 #include <fsfw/devicehandlers/DeviceHandlerBase.h>

+#include "mission/devices/devicedefinitions/GyroADIS1650XDefinitions.h"
+
 class GyroAdisDummy : public DeviceHandlerBase {
 public:
  static const DeviceCommandId_t SIMPLE_COMMAND = 1;
@ -15,6 +17,7 @@ class GyroAdisDummy : public DeviceHandlerBase {
  virtual ~GyroAdisDummy();

 protected:
+  AdisGyroPrimaryDataset dataset;
  void doStartUp() override;
  void doShutDown() override;
  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
--- a/dummies/GyroL3GD20Dummy.cpp
+++ b/dummies/GyroL3GD20Dummy.cpp
@ -22,16 +22,16 @@ ReturnValue_t GyroL3GD20Dummy::buildTransitionDeviceCommand(DeviceCommandId_t *i
 ReturnValue_t GyroL3GD20Dummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
                                                       const uint8_t *commandData,
                                                       size_t commandDataLen) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t GyroL3GD20Dummy::scanForReply(const uint8_t *start, size_t len,
                                            DeviceCommandId_t *foundId, size_t *foundLen) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t GyroL3GD20Dummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 void GyroL3GD20Dummy::fillCommandAndReplyMap() {}
@ -44,5 +44,5 @@ ReturnValue_t GyroL3GD20Dummy::initializeLocalDataPool(localpool::DataPool &loca
  localDataPoolMap.emplace(L3GD20H::ANG_VELOC_Y, new PoolEntry<float>({0.0}));
  localDataPoolMap.emplace(L3GD20H::ANG_VELOC_Z, new PoolEntry<float>({0.0}));
  localDataPoolMap.emplace(L3GD20H::TEMPERATURE, new PoolEntry<float>({0.0}));
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
--- a/dummies/ImtqDummy.cpp
+++ b/dummies/ImtqDummy.cpp
@ -1,6 +1,6 @@
 #include "ImtqDummy.h"

-#include <mission/devices/devicedefinitions/IMTQHandlerDefinitions.h>
+#include <mission/devices/devicedefinitions/imtqHandlerDefinitions.h>

 ImtqDummy::ImtqDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
    : DeviceHandlerBase(objectId, comif, comCookie) {}
@ -20,16 +20,16 @@ ReturnValue_t ImtqDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
 ReturnValue_t ImtqDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
                                                 const uint8_t *commandData,
                                                 size_t commandDataLen) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t ImtqDummy::scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
                                      size_t *foundLen) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t ImtqDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 void ImtqDummy::fillCommandAndReplyMap() {}
@ -39,5 +39,5 @@ uint32_t ImtqDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { retur
 ReturnValue_t ImtqDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                 LocalDataPoolManager &poolManager) {
  localDataPoolMap.emplace(IMTQ::MCU_TEMPERATURE, new PoolEntry<int16_t>({0}));
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
--- a/dummies/MgmLIS3MDLDummy.cpp
+++ b/dummies/MgmLIS3MDLDummy.cpp
@ -3,7 +3,7 @@
 #include "fsfw_hal/devicehandlers/devicedefinitions/MgmLIS3HandlerDefs.h"

 MgmLIS3MDLDummy::MgmLIS3MDLDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
-    : DeviceHandlerBase(objectId, comif, comCookie) {}
+    : DeviceHandlerBase(objectId, comif, comCookie), dataset(this) {}

 MgmLIS3MDLDummy::~MgmLIS3MDLDummy() {}

@ -22,16 +22,16 @@ ReturnValue_t MgmLIS3MDLDummy::buildTransitionDeviceCommand(DeviceCommandId_t *i
 ReturnValue_t MgmLIS3MDLDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
                                                       const uint8_t *commandData,
                                                       size_t commandDataLen) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t MgmLIS3MDLDummy::scanForReply(const uint8_t *start, size_t len,
                                            DeviceCommandId_t *foundId, size_t *foundLen) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t MgmLIS3MDLDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 void MgmLIS3MDLDummy::fillCommandAndReplyMap() {}
@ -41,5 +41,5 @@ uint32_t MgmLIS3MDLDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) {
 ReturnValue_t MgmLIS3MDLDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                       LocalDataPoolManager &poolManager) {
  localDataPoolMap.emplace(MGMLIS3MDL::TEMPERATURE_CELCIUS, new PoolEntry<float>({0.0}));
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
--- a/dummies/MgmLIS3MDLDummy.h
+++ b/dummies/MgmLIS3MDLDummy.h
@ -3,6 +3,8 @@

 #include <fsfw/devicehandlers/DeviceHandlerBase.h>

+#include "fsfw_hal/devicehandlers/devicedefinitions/MgmLIS3HandlerDefs.h"
+
 class MgmLIS3MDLDummy : public DeviceHandlerBase {
 public:
  static const DeviceCommandId_t SIMPLE_COMMAND = 1;
@ -15,6 +17,7 @@ class MgmLIS3MDLDummy : public DeviceHandlerBase {
  virtual ~MgmLIS3MDLDummy();

 protected:
+  MGMLIS3MDL::MgmPrimaryDataset dataset;
  void doStartUp() override;
  void doShutDown() override;
  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
--- a/dummies/MgmRm3100Dummy.cpp
+++ b/dummies/MgmRm3100Dummy.cpp
@ -0,0 +1,40 @@
+#include "MgmRm3100Dummy.h"
+
+using namespace returnvalue;
+
+MgmRm3100Dummy::MgmRm3100Dummy(object_id_t objectId, object_id_t comif, CookieIF* comCookie)
+    : DeviceHandlerBase(objectId, comif, comCookie), dataset(this) {}
+
+MgmRm3100Dummy::~MgmRm3100Dummy() = default;
+
+void MgmRm3100Dummy::doStartUp() {}
+
+void MgmRm3100Dummy::doShutDown() {}
+
+ReturnValue_t MgmRm3100Dummy::buildNormalDeviceCommand(DeviceCommandId_t* id) { return OK; }
+
+ReturnValue_t MgmRm3100Dummy::buildTransitionDeviceCommand(DeviceCommandId_t* id) { return OK; }
+
+ReturnValue_t MgmRm3100Dummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                      const uint8_t* commandData,
+                                                      size_t commandDataLen) {
+  return OK;
+}
+
+ReturnValue_t MgmRm3100Dummy::scanForReply(const uint8_t* start, size_t len,
+                                           DeviceCommandId_t* foundId, size_t* foundLen) {
+  return OK;
+}
+
+ReturnValue_t MgmRm3100Dummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) {
+  return OK;
+}
+
+void MgmRm3100Dummy::fillCommandAndReplyMap() {}
+
+uint32_t MgmRm3100Dummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 0; }
+
+ReturnValue_t MgmRm3100Dummy::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+                                                      LocalDataPoolManager& poolManager) {
+  return OK;
+}
--- a/dummies/MgmRm3100Dummy.h
+++ b/dummies/MgmRm3100Dummy.h
@ -0,0 +1,29 @@
+#ifndef DUMMIES_MGMRM3100DUMMY_H_
+#define DUMMIES_MGMRM3100DUMMY_H_
+
+#include "fsfw/devicehandlers/DeviceHandlerBase.h"
+#include "fsfw_hal/devicehandlers/devicedefinitions/MgmRM3100HandlerDefs.h"
+
+class MgmRm3100Dummy : public DeviceHandlerBase {
+ public:
+  MgmRm3100Dummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  virtual ~MgmRm3100Dummy();
+
+ protected:
+  RM3100::Rm3100PrimaryDataset dataset;
+  void doStartUp() override;
+  void doShutDown() override;
+  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
+                                        size_t commandDataLen) override;
+  ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+                             size_t *foundLen) override;
+  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
+  void fillCommandAndReplyMap() override;
+  uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                        LocalDataPoolManager &poolManager) override;
+};
+
+#endif /* DUMMIES_MGMRM3100DUMMY_H_ */
--- a/dummies/P60DockDummy.cpp
+++ b/dummies/P60DockDummy.cpp
@ -22,16 +22,16 @@ ReturnValue_t P60DockDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id)
 ReturnValue_t P60DockDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
                                                    const uint8_t *commandData,
                                                    size_t commandDataLen) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t P60DockDummy::scanForReply(const uint8_t *start, size_t len,
                                         DeviceCommandId_t *foundId, size_t *foundLen) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t P60DockDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 void P60DockDummy::fillCommandAndReplyMap() {}
@ -40,7 +40,7 @@ uint32_t P60DockDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { re

 ReturnValue_t P60DockDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                    LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(P60System::pool::P60DOCK_TEMPERATURE_1, new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(P60System::pool::P60DOCK_TEMPERATURE_2, new PoolEntry<float>({0}));
-  return HasReturnvaluesIF::RETURN_OK;
+  localDataPoolMap.emplace(P60Dock::pool::P60DOCK_TEMPERATURE_1, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(P60Dock::pool::P60DOCK_TEMPERATURE_2, new PoolEntry<float>({0}));
+  return returnvalue::OK;
 }
--- a/dummies/PduDummy.cpp
+++ b/dummies/PduDummy.cpp
@ -19,16 +19,16 @@ ReturnValue_t PduDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {

 ReturnValue_t PduDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
                                                const uint8_t *commandData, size_t commandDataLen) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t PduDummy::scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
                                     size_t *foundLen) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t PduDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 void PduDummy::fillCommandAndReplyMap() {}
@ -37,6 +37,6 @@ uint32_t PduDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return

 ReturnValue_t PduDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(P60System::pool::PDU_TEMPERATURE, new PoolEntry<float>({0}));
-  return HasReturnvaluesIF::RETURN_OK;
+  localDataPoolMap.emplace(PDU::pool::PDU_TEMPERATURE, new PoolEntry<float>({0}));
+  return returnvalue::OK;
 }
--- a/dummies/PlPcduDummy.cpp
+++ b/dummies/PlPcduDummy.cpp
@ -22,16 +22,16 @@ ReturnValue_t PlPcduDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
 ReturnValue_t PlPcduDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
                                                   const uint8_t *commandData,
                                                   size_t commandDataLen) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t PlPcduDummy::scanForReply(const uint8_t *start, size_t len,
                                        DeviceCommandId_t *foundId, size_t *foundLen) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t PlPcduDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 void PlPcduDummy::fillCommandAndReplyMap() {}
@ -41,5 +41,5 @@ uint32_t PlPcduDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { ret
 ReturnValue_t PlPcduDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                   LocalDataPoolManager &poolManager) {
  localDataPoolMap.emplace(plpcdu::PlPcduPoolIds::TEMP, new PoolEntry<float>({0.0}));
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
--- a/dummies/RwDummy.cpp
+++ b/dummies/RwDummy.cpp
@ -19,16 +19,16 @@ ReturnValue_t RwDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {

 ReturnValue_t RwDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
                                               const uint8_t *commandData, size_t commandDataLen) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t RwDummy::scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
                                    size_t *foundLen) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t RwDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 void RwDummy::fillCommandAndReplyMap() {}
@ -71,5 +71,5 @@ ReturnValue_t RwDummy::initializeLocalDataPool(localpool::DataPool &localDataPoo
  localDataPoolMap.emplace(RwDefinitions::SPI_BYTES_READ, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(RwDefinitions::SPI_REG_OVERRUN_ERRORS, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(RwDefinitions::SPI_TOTAL_ERRORS, new PoolEntry<uint32_t>({0}));
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
--- a/dummies/SaDeploymentDummy.cpp
+++ b/dummies/SaDeploymentDummy.cpp
@ -0,0 +1,7 @@
+#include "SaDeploymentDummy.h"
+
+SaDeplDummy::SaDeplDummy(object_id_t objectId) : SystemObject(objectId) {}
+
+SaDeplDummy::~SaDeplDummy() = default;
+
+ReturnValue_t SaDeplDummy::performOperation(uint8_t opCode) { return returnvalue::OK; }
--- a/dummies/SaDeploymentDummy.h
+++ b/dummies/SaDeploymentDummy.h
@ -0,0 +1,19 @@
+
+#ifndef DUMMIES_SADEPLOYMENT_H_
+#define DUMMIES_SADEPLOYMENT_H_
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+
+#include "SaDeploymentDummy.h"
+
+class SaDeplDummy : public SystemObject, public ExecutableObjectIF {
+ public:
+  SaDeplDummy(object_id_t objectId);
+  virtual ~SaDeplDummy();
+
+  ReturnValue_t performOperation(uint8_t opCode) override;
+
+ protected:
+};
+
+#endif /* DUMMIES_SADEPLOYMENT_H_ */
--- a/dummies/StarTrackerDummy.cpp
+++ b/dummies/StarTrackerDummy.cpp
@ -22,16 +22,16 @@ ReturnValue_t StarTrackerDummy::buildTransitionDeviceCommand(DeviceCommandId_t *
 ReturnValue_t StarTrackerDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
                                                        const uint8_t *commandData,
                                                        size_t commandDataLen) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t StarTrackerDummy::scanForReply(const uint8_t *start, size_t len,
                                             DeviceCommandId_t *foundId, size_t *foundLen) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t StarTrackerDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 void StarTrackerDummy::fillCommandAndReplyMap() {}
@ -41,5 +41,5 @@ uint32_t StarTrackerDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo)
 ReturnValue_t StarTrackerDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                        LocalDataPoolManager &poolManager) {
  localDataPoolMap.emplace(startracker::MCU_TEMPERATURE, new PoolEntry<float>({0}));
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
--- a/dummies/SusDummy.cpp
+++ b/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);
@ -25,15 +24,17 @@ ReturnValue_t SusDummy::initialize() {
  if (not done) {
    done = true;
    ReturnValue_t result = ExtendedControllerBase::initialize();
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
      return result;
    }
  }

-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

-ReturnValue_t SusDummy::handleCommandMessage(CommandMessage* message) { return RETURN_FAILED; }
+ReturnValue_t SusDummy::handleCommandMessage(CommandMessage* message) {
+  return returnvalue::FAILED;
+}

 void SusDummy::performControlOperation() {
  iteration++;
@ -54,7 +55,7 @@ ReturnValue_t SusDummy::initializeLocalDataPool(localpool::DataPool& localDataPo
  localDataPoolMap.emplace(SUS::SusPoolIds::TEMPERATURE_C, new PoolEntry<float>({0}, 1, true));
  localDataPoolMap.emplace(SUS::SusPoolIds::CHANNEL_VEC, new PoolEntry<uint16_t>({0}));

-  return RETURN_OK;
+  return returnvalue::OK;
 }

 LocalPoolDataSetBase* SusDummy::getDataSetHandle(sid_t sid) {
@ -74,5 +75,5 @@ ReturnValue_t SusDummy::checkModeCommand(Mode_t mode, Submode_t submode,
  if ((mode != MODE_OFF) && (mode != MODE_ON) && (mode != MODE_NORMAL)) {
    return INVALID_MODE;
  }
-  return RETURN_OK;
+  return returnvalue::OK;
 }
--- a/dummies/SyrlinksDummy.cpp
+++ b/dummies/SyrlinksDummy.cpp
@ -22,16 +22,16 @@ ReturnValue_t SyrlinksDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id)
 ReturnValue_t SyrlinksDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
                                                     const uint8_t *commandData,
                                                     size_t commandDataLen) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t SyrlinksDummy::scanForReply(const uint8_t *start, size_t len,
                                          DeviceCommandId_t *foundId, size_t *foundLen) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t SyrlinksDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
-  return RETURN_OK;
+  return returnvalue::OK;
 }

 void SyrlinksDummy::fillCommandAndReplyMap() {}
@ -42,5 +42,5 @@ ReturnValue_t SyrlinksDummy::initializeLocalDataPool(localpool::DataPool &localD
                                                     LocalDataPoolManager &poolManager) {
  localDataPoolMap.emplace(syrlinks::TEMP_BASEBAND_BOARD, new PoolEntry<float>({0}));
  localDataPoolMap.emplace(syrlinks::TEMP_POWER_AMPLIFIER, new PoolEntry<float>({0}));
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
--- a/dummies/TemperatureSensorsDummy.cpp
+++ b/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() {
@ -32,16 +32,16 @@ ReturnValue_t TemperatureSensorsDummy::initialize() {
  if (not done) {
    done = true;
    ReturnValue_t result = ExtendedControllerBase::initialize();
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
      return result;
    }
  }

-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

 ReturnValue_t TemperatureSensorsDummy::handleCommandMessage(CommandMessage* message) {
-  return RETURN_FAILED;
+  return returnvalue::FAILED;
 }

 void TemperatureSensorsDummy::performControlOperation() {
@ -49,7 +49,7 @@ void TemperatureSensorsDummy::performControlOperation() {
  value = sin(iteration / 80. * M_PI) * 10;

  ReturnValue_t result = max31865Set.read();
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
    sif::warning << "Failed to read temperature from MAX31865 dataset" << std::endl;
  }
  max31865Set.rtdValue = value - 5;
@ -73,7 +73,7 @@ ReturnValue_t TemperatureSensorsDummy::initializeLocalDataPool(
  localDataPoolMap.emplace(static_cast<lp_id_t>(MAX31865::PoolIds::FAULT_BYTE),
                           new PoolEntry<uint8_t>({0}));

-  return RETURN_OK;
+  return returnvalue::OK;
 }

 LocalPoolDataSetBase* TemperatureSensorsDummy::getDataSetHandle(sid_t sid) {
@ -94,5 +94,5 @@ ReturnValue_t TemperatureSensorsDummy::checkModeCommand(Mode_t mode, Submode_t s
  if ((mode != MODE_OFF) && (mode != MODE_ON) && (mode != MODE_NORMAL)) {
    return INVALID_MODE;
  }
-  return RETURN_OK;
+  return returnvalue::OK;
 }
--- a/dummies/helpers.cpp
+++ b/dummies/helpers.cpp
@ -0,0 +1,71 @@
+#include "helpers.h"
+
+#include <dummies/AcuDummy.h>
+#include <dummies/BpxDummy.h>
+#include <dummies/ComCookieDummy.h>
+#include <dummies/ComIFDummy.h>
+#include <dummies/CoreControllerDummy.h>
+#include <dummies/GyroAdisDummy.h>
+#include <dummies/GyroL3GD20Dummy.h>
+#include <dummies/ImtqDummy.h>
+#include <dummies/MgmLIS3MDLDummy.h>
+#include <dummies/MgmRm3100Dummy.h>
+#include <dummies/P60DockDummy.h>
+#include <dummies/PduDummy.h>
+#include <dummies/PlPcduDummy.h>
+#include <dummies/RwDummy.h>
+#include <dummies/SaDeploymentDummy.h>
+#include <dummies/StarTrackerDummy.h>
+#include <dummies/SusDummy.h>
+#include <dummies/SyrlinksDummy.h>
+#include <dummies/TemperatureSensorsDummy.h>
+
+using namespace dummy;
+
+void dummy::createDummies(DummyCfg cfg) {
+  new ComIFDummy(objects::DUMMY_COM_IF);
+  ComCookieDummy* comCookieDummy = new ComCookieDummy();
+  new BpxDummy(objects::BPX_BATT_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  if (cfg.addCoreCtrlCfg) {
+    new CoreControllerDummy(objects::CORE_CONTROLLER);
+  }
+  if (cfg.addRtdComIFDummy) {
+    new ComIFDummy(objects::SPI_RTD_COM_IF);
+  }
+  new RwDummy(objects::RW1, objects::DUMMY_COM_IF, comCookieDummy);
+  new RwDummy(objects::RW2, objects::DUMMY_COM_IF, comCookieDummy);
+  new RwDummy(objects::RW3, objects::DUMMY_COM_IF, comCookieDummy);
+  new RwDummy(objects::RW4, objects::DUMMY_COM_IF, comCookieDummy);
+  new SaDeplDummy(objects::SOLAR_ARRAY_DEPL_HANDLER);
+  new StarTrackerDummy(objects::STAR_TRACKER, 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);
+    new PduDummy(objects::PDU1_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+    new PduDummy(objects::PDU2_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+    new P60DockDummy(objects::P60DOCK_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  }
+
+  if (cfg.addAcsBoardDummies) {
+    new GyroAdisDummy(objects::GYRO_0_ADIS_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+    new GyroL3GD20Dummy(objects::GYRO_1_L3G_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+    new GyroAdisDummy(objects::GYRO_2_ADIS_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+    new GyroL3GD20Dummy(objects::GYRO_3_L3G_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+    new MgmLIS3MDLDummy(objects::MGM_0_LIS3_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+    new MgmLIS3MDLDummy(objects::MGM_2_LIS3_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+    new MgmRm3100Dummy(objects::MGM_1_RM3100_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+    new MgmRm3100Dummy(objects::MGM_3_RM3100_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  }
+
+  if (cfg.addSusDummies) {
+    new SusDummy();
+  }
+
+  if (cfg.addTempSensorDummies) {
+    new TemperatureSensorsDummy();
+  }
+  new PlPcduDummy(objects::PLPCDU_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+}
--- a/dummies/helpers.h
+++ b/dummies/helpers.h
@ -0,0 +1,17 @@
+#pragma once
+
+namespace dummy {
+
+struct DummyCfg {
+  bool addCoreCtrlCfg = true;
+  bool addPowerDummies = true;
+  bool addSyrlinksDummies = true;
+  bool addAcsBoardDummies = true;
+  bool addSusDummies = true;
+  bool addTempSensorDummies = true;
+  bool addRtdComIFDummy = true;
+};
+
+void createDummies(DummyCfg cfg);
+
+}  // namespace dummy
--- a/2
+++ b/2
--- a/generators/bsp_q7s_events.csv
+++ b/generators/bsp_q7s_events.csv
@ -69,6 +69,7 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 7510;0x1d56;TRYING_RECOVERY;MEDIUM;;fsfw/src/fsfw/health/HasHealthIF.h
 7511;0x1d57;RECOVERY_STEP;MEDIUM;;fsfw/src/fsfw/health/HasHealthIF.h
 7512;0x1d58;RECOVERY_DONE;MEDIUM;;fsfw/src/fsfw/health/HasHealthIF.h
+7600;0x1db0;HANDLE_PACKET_FAILED;LOW;;fsfw/src/fsfw/tcdistribution/definitions.h
 7900;0x1edc;RF_AVAILABLE;INFO;A RF available signal was detected. P1: raw RFA state, P2: 0;fsfw/src/fsfw/datalinklayer/DataLinkLayer.h
 7901;0x1edd;RF_LOST;INFO;A previously found RF available signal was lost. P1: raw RFA state, P2: 0;fsfw/src/fsfw/datalinklayer/DataLinkLayer.h
 7902;0x1ede;BIT_LOCK;INFO;A Bit Lock signal. Was detected. P1: raw BLO state, P2: 0;fsfw/src/fsfw/datalinklayer/DataLinkLayer.h
@ -78,7 +79,10 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 8901;0x22c5;CLOCK_SET_FAILURE;LOW;;fsfw/src/fsfw/pus/Service9TimeManagement.h
 9100;0x238c;TC_DELETION_FAILED;MEDIUM;Deletion of a TC from the map failed. P1: First 32 bit of request ID, P2. Last 32 bit of Request ID;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
 9700;0x25e4;TEST;INFO;;fsfw/src/fsfw/pus/Service17Test.h
-10600;0x2968;CHANGE_OF_SETUP_PARAMETER;LOW;;fsfw/hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h
+10600;0x2968;CHANGE_OF_SETUP_PARAMETER;LOW;;fsfw/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h
+10800;0x2a30;STORE_ERROR;LOW;;fsfw/src/fsfw/cfdp/handler/defs.h
+10801;0x2a31;MSG_QUEUE_ERROR;LOW;;fsfw/src/fsfw/cfdp/handler/defs.h
+10802;0x2a32;SERIALIZATION_ERROR;LOW;;fsfw/src/fsfw/cfdp/handler/defs.h
 11300;0x2c24;SWITCH_CMD_SENT;INFO;Indicates that a FSFW object requested setting a switch P1: 1 if on was requested, 0 for off | P2: Switch Index;mission/devices/devicedefinitions/powerDefinitions.h
 11301;0x2c25;SWITCH_HAS_CHANGED;INFO;Indicated that a switch state has changed P1: New switch state, 1 for on, 0 for off | P2: Switch Index;mission/devices/devicedefinitions/powerDefinitions.h
 11302;0x2c26;SWITCHING_Q7S_DENIED;MEDIUM;;mission/devices/devicedefinitions/powerDefinitions.h
@ -91,25 +95,29 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 11405;0x2c8d;SWITCH_ALREADY_OFF;LOW;;mission/devices/HeaterHandler.h
 11406;0x2c8e;MAIN_SWITCH_TIMEOUT;MEDIUM;;mission/devices/HeaterHandler.h
 11407;0x2c8f;FAULTY_HEATER_WAS_ON;LOW;;mission/devices/HeaterHandler.h
-11500;0x2cec;MAIN_SWITCH_ON_TIMEOUT;LOW;;mission/devices/SolarArrayDeploymentHandler.h
-11501;0x2ced;MAIN_SWITCH_OFF_TIMEOUT;LOW;;mission/devices/SolarArrayDeploymentHandler.h
-11502;0x2cee;DEPLOYMENT_FAILED;HIGH;;mission/devices/SolarArrayDeploymentHandler.h
-11503;0x2cef;DEPL_SA1_GPIO_SWTICH_ON_FAILED;HIGH;;mission/devices/SolarArrayDeploymentHandler.h
-11504;0x2cf0;DEPL_SA2_GPIO_SWTICH_ON_FAILED;HIGH;;mission/devices/SolarArrayDeploymentHandler.h
+11500;0x2cec;BURN_PHASE_START;INFO;P1: Burn duration in milliseconds, P2: Dry run flag;mission/devices/SolarArrayDeploymentHandler.h
+11501;0x2ced;BURN_PHASE_DONE;INFO;P1: Burn duration in milliseconds, P2: Dry run flag;mission/devices/SolarArrayDeploymentHandler.h
+11502;0x2cee;MAIN_SWITCH_ON_TIMEOUT;LOW;;mission/devices/SolarArrayDeploymentHandler.h
+11503;0x2cef;MAIN_SWITCH_OFF_TIMEOUT;LOW;;mission/devices/SolarArrayDeploymentHandler.h
+11504;0x2cf0;DEPL_SA1_GPIO_SWTICH_ON_FAILED;HIGH;;mission/devices/SolarArrayDeploymentHandler.h
+11505;0x2cf1;DEPL_SA2_GPIO_SWTICH_ON_FAILED;HIGH;;mission/devices/SolarArrayDeploymentHandler.h
+11506;0x2cf2;DEPL_SA1_GPIO_SWTICH_OFF_FAILED;HIGH;;mission/devices/SolarArrayDeploymentHandler.h
+11507;0x2cf3;DEPL_SA2_GPIO_SWTICH_OFF_FAILED;HIGH;;mission/devices/SolarArrayDeploymentHandler.h
+11508;0x2cf4;AUTONOMOUS_DEPLOYMENT_COMPLETED;INFO;;mission/devices/SolarArrayDeploymentHandler.h
 11601;0x2d51;MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC crc failure in telemetry packet;linux/devices/ploc/PlocMPSoCHandler.h
 11602;0x2d52;ACK_FAILURE;LOW;PLOC receive acknowledgment failure report P1: Command Id which leads the acknowledgment failure report P2: The status field inserted by the MPSoC into the data field;linux/devices/ploc/PlocMPSoCHandler.h
 11603;0x2d53;EXE_FAILURE;LOW;PLOC receive execution failure report P1: Command Id which leads the execution failure report P2: The status field inserted by the MPSoC into the data field;linux/devices/ploc/PlocMPSoCHandler.h
 11604;0x2d54;MPSOC_HANDLER_CRC_FAILURE;LOW;PLOC reply has invalid crc;linux/devices/ploc/PlocMPSoCHandler.h
 11605;0x2d55;MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH;LOW;Packet sequence count in received space packet does not match expected count P1: Expected sequence count P2: Received sequence count;linux/devices/ploc/PlocMPSoCHandler.h
 11606;0x2d56;MPSOC_SHUTDOWN_FAILED;HIGH;Supervisor fails to shutdown MPSoC. Requires to power off the PLOC and thus also to shutdown the supervisor.;linux/devices/ploc/PlocMPSoCHandler.h
-11701;0x2db5;SELF_TEST_I2C_FAILURE;LOW;Get self test result returns I2C failure P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/devices/IMTQHandler.h
-11702;0x2db6;SELF_TEST_SPI_FAILURE;LOW;Get self test result returns SPI failure. This concerns the MTM connectivity. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/devices/IMTQHandler.h
-11703;0x2db7;SELF_TEST_ADC_FAILURE;LOW;Get self test result returns failure in measurement of current and temperature. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/devices/IMTQHandler.h
-11704;0x2db8;SELF_TEST_PWM_FAILURE;LOW;Get self test result returns PWM failure which concerns the coil actuation. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/devices/IMTQHandler.h
-11705;0x2db9;SELF_TEST_TC_FAILURE;LOW;Get self test result returns TC failure (system failure) P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/devices/IMTQHandler.h
-11706;0x2dba;SELF_TEST_MTM_RANGE_FAILURE;LOW;Get self test result returns failure that MTM values were outside of the expected range. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/devices/IMTQHandler.h
-11707;0x2dbb;SELF_TEST_COIL_CURRENT_FAILURE;LOW;Get self test result returns failure indicating that the coil current was outside of the expected range P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/devices/IMTQHandler.h
-11708;0x2dbc;INVALID_ERROR_BYTE;LOW;Received invalid error byte. This indicates an error of the communication link between IMTQ and OBC.;mission/devices/IMTQHandler.h
+11701;0x2db5;SELF_TEST_I2C_FAILURE;LOW;Get self test result returns I2C failure P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/devices/ImtqHandler.h
+11702;0x2db6;SELF_TEST_SPI_FAILURE;LOW;Get self test result returns SPI failure. This concerns the MTM connectivity. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/devices/ImtqHandler.h
+11703;0x2db7;SELF_TEST_ADC_FAILURE;LOW;Get self test result returns failure in measurement of current and temperature. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/devices/ImtqHandler.h
+11704;0x2db8;SELF_TEST_PWM_FAILURE;LOW;Get self test result returns PWM failure which concerns the coil actuation. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/devices/ImtqHandler.h
+11705;0x2db9;SELF_TEST_TC_FAILURE;LOW;Get self test result returns TC failure (system failure) P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/devices/ImtqHandler.h
+11706;0x2dba;SELF_TEST_MTM_RANGE_FAILURE;LOW;Get self test result returns failure that MTM values were outside of the expected range. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/devices/ImtqHandler.h
+11707;0x2dbb;SELF_TEST_COIL_CURRENT_FAILURE;LOW;Get self test result returns failure indicating that the coil current was outside of the expected range P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/devices/ImtqHandler.h
+11708;0x2dbc;INVALID_ERROR_BYTE;LOW;Received invalid error byte. This indicates an error of the communication link between IMTQ and OBC.;mission/devices/ImtqHandler.h
 11801;0x2e19;ERROR_STATE;HIGH;Reaction wheel signals an error state;mission/devices/devicedefinitions/RwDefinitions.h
 11802;0x2e1a;RESET_OCCURED;LOW;;mission/devices/devicedefinitions/RwDefinitions.h
 11901;0x2e7d;BOOTING_FIRMWARE_FAILED;LOW;Failed to boot firmware;linux/devices/startracker/StarTrackerHandler.h
@ -119,17 +127,18 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 12003;0x2ee3;SUPV_EXE_FAILURE;LOW;PLOC received execution failure report P1: ID of command for which the execution failed P2: Status code sent by the supervisor handler;linux/devices/ploc/PlocSupervisorHandler.h
 12004;0x2ee4;SUPV_CRC_FAILURE_EVENT;LOW;PLOC supervisor reply has invalid crc;linux/devices/ploc/PlocSupervisorHandler.h
 12005;0x2ee5;SUPV_MPSOC_SHUWDOWN_BUILD_FAILED;LOW;Failed to build the command to shutdown the MPSoC;linux/devices/ploc/PlocSupervisorHandler.h
-12100;0x2f44;SANITIZATION_FAILED;LOW;;bsp_q7s/memory/SdCardManager.h
-12101;0x2f45;MOUNTED_SD_CARD;INFO;;bsp_q7s/memory/SdCardManager.h
+12100;0x2f44;SANITIZATION_FAILED;LOW;;bsp_q7s/fs/SdCardManager.h
+12101;0x2f45;MOUNTED_SD_CARD;INFO;;bsp_q7s/fs/SdCardManager.h
 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
@ -159,6 +168,8 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 12609;0x3141;MPSOC_ACK_INVALID_APID;LOW;Expected acknowledgment report but received space packet with other apid P1: Apid of received space packet P2: Internal state of MPSoC;linux/devices/ploc/PlocMPSoCHelper.h
 12610;0x3142;MPSOC_EXE_INVALID_APID;LOW;Expected execution report but received space packet with other apid P1: Apid of received space packet P2: Internal state of MPSoC;linux/devices/ploc/PlocMPSoCHelper.h
 12611;0x3143;MPSOC_HELPER_SEQ_CNT_MISMATCH;LOW;Received sequence count does not match expected sequence count P1: Expected sequence count P2: Received sequence count;linux/devices/ploc/PlocMPSoCHelper.h
+12612;0x3144;MPSOC_TM_SIZE_ERROR;LOW;;linux/devices/ploc/PlocMPSoCHelper.h
+12613;0x3145;MPSOC_TM_CRC_MISSMATCH;LOW;;linux/devices/ploc/PlocMPSoCHelper.h
 12700;0x319c;TRANSITION_BACK_TO_OFF;MEDIUM;Could not transition properly and went back to ALL OFF;mission/devices/PayloadPcduHandler.h
 12701;0x319d;NEG_V_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h
 12702;0x319e;U_DRO_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h
@ -171,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
@ -192,19 +203,33 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 13605;0x3525;SUPV_EVENT_BUFFER_REQUEST_SUCCESSFUL;LOW;Requesting event buffer was successful;linux/devices/ploc/PlocSupvHelper.h
 13606;0x3526;SUPV_EVENT_BUFFER_REQUEST_FAILED;LOW;Requesting event buffer failed;linux/devices/ploc/PlocSupvHelper.h
 13607;0x3527;SUPV_EVENT_BUFFER_REQUEST_TERMINATED;LOW;Terminated event buffer request by command P1: Number of packets read before process was terminated;linux/devices/ploc/PlocSupvHelper.h
-13608;0x3528;SUPV_SENDING_COMMAND_FAILED;LOW;;linux/devices/ploc/PlocSupvHelper.h
-13609;0x3529;SUPV_HELPER_REQUESTING_REPLY_FAILED;LOW;Request receive message of communication interface failed P1: Return value returned by the communication interface requestReceiveMessage function P2: Internal state of supervisor helper;linux/devices/ploc/PlocSupvHelper.h
-13610;0x352a;SUPV_HELPER_READING_REPLY_FAILED;LOW;Reading receive message of communication interface failed P1: Return value returned by the communication interface readingReceivedMessage function P2: Internal state of supervisor helper;linux/devices/ploc/PlocSupvHelper.h
-13611;0x352b;SUPV_MISSING_ACK;LOW;Did not receive acknowledgement report P1: Number of bytes missing P2: Internal state of MPSoC helper;linux/devices/ploc/PlocSupvHelper.h
-13612;0x352c;SUPV_MISSING_EXE;LOW;Supervisor did not receive execution report P1: Number of bytes missing P2: Internal state of supervisor helper;linux/devices/ploc/PlocSupvHelper.h
-13613;0x352d;SUPV_ACK_FAILURE_REPORT;LOW;Supervisor received acknowledgment failure report P1: Internal state of supervisor helper;linux/devices/ploc/PlocSupvHelper.h
-13614;0x352e;SUPV_EXE_FAILURE_REPORT;LOW;Execution report failure P1:;linux/devices/ploc/PlocSupvHelper.h
-13615;0x352f;SUPV_ACK_INVALID_APID;LOW;Supervisor expected acknowledgment report but received space packet with other apid P1: Apid of received space packet P2: Internal state of supervisor helper;linux/devices/ploc/PlocSupvHelper.h
-13616;0x3530;SUPV_EXE_INVALID_APID;LOW;Supervisor helper expected execution report but received space packet with other apid P1: Apid of received space packet P2: Internal state of supervisor helper;linux/devices/ploc/PlocSupvHelper.h
-13617;0x3531;ACK_RECEPTION_FAILURE;LOW;Failed to receive acknowledgment report P1: Return value P2: Apid of command for which the reception of the acknowledgment report failed;linux/devices/ploc/PlocSupvHelper.h
-13618;0x3532;EXE_RECEPTION_FAILURE;LOW;Failed to receive execution report P1: Return value P2: Apid of command for which the reception of the execution report failed;linux/devices/ploc/PlocSupvHelper.h
-13619;0x3533;WRITE_MEMORY_FAILED;LOW;Update procedure failed when sending packet with number P1 P1: Packet number for which the memory write command fails;linux/devices/ploc/PlocSupvHelper.h
+13608;0x3528;SUPV_MEM_CHECK_OK;INFO;;linux/devices/ploc/PlocSupvHelper.h
+13609;0x3529;SUPV_MEM_CHECK_FAIL;INFO;;linux/devices/ploc/PlocSupvHelper.h
+13616;0x3530;SUPV_SENDING_COMMAND_FAILED;LOW;;linux/devices/ploc/PlocSupvHelper.h
+13617;0x3531;SUPV_HELPER_REQUESTING_REPLY_FAILED;LOW;Request receive message of communication interface failed P1: Return value returned by the communication interface requestReceiveMessage function P2: Internal state of supervisor helper;linux/devices/ploc/PlocSupvHelper.h
+13618;0x3532;SUPV_HELPER_READING_REPLY_FAILED;LOW;Reading receive message of communication interface failed P1: Return value returned by the communication interface readingReceivedMessage function P2: Internal state of supervisor helper;linux/devices/ploc/PlocSupvHelper.h
+13619;0x3533;SUPV_MISSING_ACK;LOW;Did not receive acknowledgement report P1: Number of bytes missing P2: Internal state of MPSoC helper;linux/devices/ploc/PlocSupvHelper.h
+13620;0x3534;SUPV_MISSING_EXE;LOW;Supervisor did not receive execution report P1: Number of bytes missing P2: Internal state of supervisor helper;linux/devices/ploc/PlocSupvHelper.h
+13621;0x3535;SUPV_ACK_FAILURE_REPORT;LOW;Supervisor received acknowledgment failure report P1: Internal state of supervisor helper;linux/devices/ploc/PlocSupvHelper.h
+13622;0x3536;SUPV_EXE_FAILURE_REPORT;LOW;Execution report failure P1:;linux/devices/ploc/PlocSupvHelper.h
+13623;0x3537;SUPV_ACK_INVALID_APID;LOW;Supervisor expected acknowledgment report but received space packet with other apid P1: Apid of received space packet P2: Internal state of supervisor helper;linux/devices/ploc/PlocSupvHelper.h
+13624;0x3538;SUPV_EXE_INVALID_APID;LOW;Supervisor helper expected execution report but received space packet with other apid P1: Apid of received space packet P2: Internal state of supervisor helper;linux/devices/ploc/PlocSupvHelper.h
+13625;0x3539;ACK_RECEPTION_FAILURE;LOW;Failed to receive acknowledgment report P1: Return value P2: Apid of command for which the reception of the acknowledgment report failed;linux/devices/ploc/PlocSupvHelper.h
+13626;0x353a;EXE_RECEPTION_FAILURE;LOW;Failed to receive execution report P1: Return value P2: Apid of command for which the reception of the execution report failed;linux/devices/ploc/PlocSupvHelper.h
+13627;0x353b;WRITE_MEMORY_FAILED;LOW;Update procedure failed when sending packet. P1: First byte percent, third and fourth byte Sequence Count, P2: Bytes written;linux/devices/ploc/PlocSupvHelper.h
+13628;0x353c;SUPV_REPLY_SIZE_MISSMATCH;LOW;;linux/devices/ploc/PlocSupvHelper.h
+13629;0x353d;SUPV_REPLY_CRC_MISSMATCH;LOW;;linux/devices/ploc/PlocSupvHelper.h
+13630;0x353e;SUPV_UPDATE_PROGRESS;INFO;Will be triggered every 5 percent of the update progress. P1: First byte percent, third and fourth byte Sequence Count, P2: Bytes written;linux/devices/ploc/PlocSupvHelper.h
 13700;0x3584;ALLOC_FAILURE;MEDIUM;;bsp_q7s/core/CoreController.h
 13701;0x3585;REBOOT_SW;MEDIUM; Software reboot occurred. Can also be a systemd reboot. P1: Current Chip, P2: Current Copy;bsp_q7s/core/CoreController.h
 13702;0x3586;REBOOT_MECHANISM_TRIGGERED;MEDIUM;The reboot mechanism was triggered. P1: First 16 bits: Last Chip, Last 16 bits: Last Copy, P2: Each byte is the respective reboot count for the slots;bsp_q7s/core/CoreController.h
 13703;0x3587;REBOOT_HW;MEDIUM;;bsp_q7s/core/CoreController.h
+13704;0x3588;NO_SD_CARD_ACTIVE;HIGH;No SD card was active. Core controller will attempt to re-initialize a SD card.;bsp_q7s/core/CoreController.h
+13800;0x35e8;MISSING_PACKET;LOW;;mission/devices/devicedefinitions/ScexDefinitions.h
+13801;0x35e9;EXPERIMENT_TIMEDOUT;LOW;;mission/devices/devicedefinitions/ScexDefinitions.h
+13802;0x35ea;MULTI_PACKET_COMMAND_DONE;INFO;;mission/devices/devicedefinitions/ScexDefinitions.h
+13901;0x364d;SET_CONFIGFILEVALUE_FAILED;MEDIUM;;mission/utility/GlobalConfigHandler.h
+13902;0x364e;GET_CONFIGFILEVALUE_FAILED;MEDIUM;;mission/utility/GlobalConfigHandler.h
+13903;0x364f;INSERT_CONFIGFILEVALUE_FAILED;MEDIUM;;mission/utility/GlobalConfigHandler.h
+13904;0x3650;WRITE_CONFIGFILE_FAILED;MEDIUM;;mission/utility/GlobalConfigHandler.h
+13905;0x3651;READ_CONFIGFILE_FAILED;MEDIUM;;mission/utility/GlobalConfigHandler.h
--- a/generators/bsp_q7s_objects.csv
+++ b/generators/bsp_q7s_objects.csv
@ -1,6 +1,7 @@
 0x00005060;P60DOCK_TEST_TASK
+0x43000002;ACS_CONTROLLER
 0x43000003;CORE_CONTROLLER
-0x43100002;ACS_CONTROLLER
+0x43000006;GLOBAL_JSON_CFG
 0x43400001;THERMAL_CONTROLLER
 0x44120006;MGM_0_LIS3_HANDLER
 0x44120010;GYRO_0_ADIS_HANDLER
@ -46,10 +47,15 @@
 0x44330015;PLOC_MPSOC_HANDLER
 0x44330016;PLOC_SUPERVISOR_HANDLER
 0x44330017;PLOC_SUPERVISOR_HELPER
+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
@ -69,6 +75,7 @@
 0x445300A3;SYRLINKS_HK_HANDLER
 0x49000000;ARDUINO_COM_IF
 0x49010005;GPIO_IF
+0x49010006;SCEX_UART_READER
 0x49020004;SPI_MAIN_COM_IF
 0x49020005;SPI_RW_COM_IF
 0x49020006;SPI_RTD_COM_IF
@ -106,6 +113,7 @@
 0x534f0200;TM_STORE
 0x534f0300;IPC_STORE
 0x53500010;TIME_STAMPER
+0x53500020;VERIFICATION_REPORTER
 0x53ffffff;FSFW_OBJECTS_END
 0x54000010;SPI_TEST
 0x54000020;UART_TEST
@ -127,6 +135,14 @@
 0x73000002;SUS_BOARD_ASS
 0x73000003;TCS_BOARD_ASS
 0x73000004;RW_ASS
+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
--- a/generators/bsp_q7s_returnvalues.csv
+++ b/generators/bsp_q7s_returnvalues.csv
@ -1,236 +1,80 @@
 Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
-0x0000;OK;System-wide code for ok.;0;HasReturnvaluesIF;fsfw/returnvalues/HasReturnvaluesIF.h
-0x0001;Failed;Unspecified system-wide code for failed.;1;HasReturnvaluesIF;fsfw/returnvalues/HasReturnvaluesIF.h
-0x6100;GOMS_PacketTooLong;;0;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
-0x6101;GOMS_InvalidTableId;;1;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
-0x6102;GOMS_InvalidAddress;;2;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
-0x6103;GOMS_InvalidParamSize;;3;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
-0x6104;GOMS_InvalidPayloadSize;;4;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
-0x6105;GOMS_UnknownReplyId;;5;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
-0x53a1;HEATER_CommandNotSupported;;161;HEATER_HANDLER;mission/devices/HeaterHandler.h
-0x53a2;HEATER_InitFailed;;162;HEATER_HANDLER;mission/devices/HeaterHandler.h
-0x53a3;HEATER_InvalidSwitchNr;;163;HEATER_HANDLER;mission/devices/HeaterHandler.h
-0x53a4;HEATER_MainSwitchSetTimeout;;164;HEATER_HANDLER;mission/devices/HeaterHandler.h
-0x53a5;HEATER_CommandAlreadyWaiting;;165;HEATER_HANDLER;mission/devices/HeaterHandler.h
-0x55a0;IMTQ_InvalidCommandCode;;160;IMTQ_HANDLER;mission/devices/IMTQHandler.h
-0x55a1;IMTQ_ParameterMissing;;161;IMTQ_HANDLER;mission/devices/IMTQHandler.h
-0x55a2;IMTQ_ParameterInvalid;;162;IMTQ_HANDLER;mission/devices/IMTQHandler.h
-0x55a3;IMTQ_CcUnavailable;;163;IMTQ_HANDLER;mission/devices/IMTQHandler.h
-0x55a4;IMTQ_InternalProcessingError;;164;IMTQ_HANDLER;mission/devices/IMTQHandler.h
-0x55a5;IMTQ_RejectedWithoutReason;;165;IMTQ_HANDLER;mission/devices/IMTQHandler.h
-0x55a6;IMTQ_CmdErrUnknown;;166;IMTQ_HANDLER;mission/devices/IMTQHandler.h
-0x55a7;IMTQ_UnexpectedSelfTestReply;The status reply to a self test command was received but no self test command has been sent. This should normally never happen.;167;IMTQ_HANDLER;mission/devices/IMTQHandler.h
-0x56b0;RWHA_SpiWriteFailure;;176;RW_HANDLER;mission/devices/RwHandler.h
-0x56b1;RWHA_SpiReadFailure;Used by the spi send function to tell a failing read call;177;RW_HANDLER;mission/devices/RwHandler.h
-0x56b2;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
-0x56b3;RWHA_InvalidSubstitute;Can be used by the HDLC decoding mechanism to inform about an invalid substitution combination;179;RW_HANDLER;mission/devices/RwHandler.h
-0x56b4;RWHA_MissingEndSign;HDLC decoding mechanism never receives the end sign 0x7E;180;RW_HANDLER;mission/devices/RwHandler.h
-0x56b5;RWHA_NoReply;Reaction wheel only responds with empty frames.;181;RW_HANDLER;mission/devices/RwHandler.h
-0x56b6;RWHA_NoStartMarker;Expected a start marker as first byte;182;RW_HANDLER;mission/devices/RwHandler.h
-0x56a0;RWHA_InvalidSpeed;Action Message with invalid speed was received. Valid speeds must be in the range of [-65000, 1000] or [1000, 65000];160;RW_HANDLER;mission/devices/RwHandler.h
-0x56a1;RWHA_InvalidRampTime;Action Message with invalid ramp time was received.;161;RW_HANDLER;mission/devices/RwHandler.h
-0x56a2;RWHA_SetSpeedCommandInvalidLength;Received set speed command has invalid length. Should be 6.;162;RW_HANDLER;mission/devices/RwHandler.h
-0x56a3;RWHA_ExecutionFailed;Command execution failed;163;RW_HANDLER;mission/devices/RwHandler.h
-0x56a4;RWHA_CrcError;Reaction wheel reply has invalid crc;164;RW_HANDLER;mission/devices/RwHandler.h
-0x6aa0;SADPL_CommandNotSupported;;160;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x6aa1;SADPL_DeploymentAlreadyExecuting;;161;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x6aa2;SADPL_MainSwitchTimeoutFailure;;162;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x6aa3;SADPL_SwitchingDeplSa1Failed;;163;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x6aa4;SADPL_SwitchingDeplSa2Failed;;164;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x5ca0;SUSS_ErrorUnlockMutex;;160;SUS_HANDLER;mission/devices/SusHandler.h
-0x5ca1;SUSS_ErrorLockMutex;;161;SUS_HANDLER;mission/devices/SusHandler.h
-0x54a0;SYRLINKS_CrcFailure;;160;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x54a1;SYRLINKS_UartFraminOrParityErrorAck;;161;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x54a2;SYRLINKS_BadCharacterAck;;162;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x54a3;SYRLINKS_BadParameterValueAck;;163;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x54a4;SYRLINKS_BadEndOfFrameAck;;164;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x54a5;SYRLINKS_UnknownCommandIdAck;;165;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x54a6;SYRLINKS_BadCrcAck;;166;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x54a7;SYRLINKS_ReplyWrongSize;;167;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x54a8;SYRLINKS_MissingStartFrameCharacter;;168;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x67a0;NVMB_KeyNotExists;Specified key does not exist in json file;160;NVM_PARAM_BASE;mission/memory/NVMParameterBase.h
-0x64a0;CCSDS_CommandNotImplemented;Received action message with unknown action id;160;CCSDS_HANDLER;mission/tmtc/CCSDSHandler.h
-0x4701;HGIO_UnknownGpioId;;1;HAL_GPIO;fsfw/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4702;HGIO_DriveGpioFailure;;2;HAL_GPIO;fsfw/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4703;HGIO_GpioTypeFailure;;3;HAL_GPIO;fsfw/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4704;HGIO_GpioInvalidInstance;;4;HAL_GPIO;fsfw/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4705;HGIO_GpioDuplicateDetected;;5;HAL_GPIO;fsfw/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4706;HGIO_GpioInitFailed;;6;HAL_GPIO;fsfw/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4707;HGIO_GpioGetValueFailed;;7;HAL_GPIO;fsfw/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4400;HSPI_HalTimeoutRetval;;0;HAL_SPI;fsfw/hal/src/fsfw_hal/stm32h7/spi/spiDefinitions.h
-0x4401;HSPI_HalBusyRetval;;1;HAL_SPI;fsfw/hal/src/fsfw_hal/stm32h7/spi/spiDefinitions.h
-0x4402;HSPI_HalErrorRetval;;2;HAL_SPI;fsfw/hal/src/fsfw_hal/stm32h7/spi/spiDefinitions.h
-0x4501;HURT_UartReadFailure;;1;HAL_UART;fsfw/hal/src/fsfw_hal/linux/uart/UartComIF.h
-0x4502;HURT_UartReadSizeMissmatch;;2;HAL_UART;fsfw/hal/src/fsfw_hal/linux/uart/UartComIF.h
-0x4503;HURT_UartRxBufferTooSmall;;3;HAL_UART;fsfw/hal/src/fsfw_hal/linux/uart/UartComIF.h
-0x4300;UXOS_ExecutionFinished;Execution of the current command has finished;0;LINUX_OSAL;fsfw/hal/src/fsfw_hal/linux/CommandExecutor.h
-0x4301;UXOS_CommandPending;Command is pending. This will also be returned if the user tries to load another command but a command is still pending;1;LINUX_OSAL;fsfw/hal/src/fsfw_hal/linux/CommandExecutor.h
-0x4302;UXOS_BytesRead;Some bytes have been read from the executing process;2;LINUX_OSAL;fsfw/hal/src/fsfw_hal/linux/CommandExecutor.h
-0x4303;UXOS_CommandError;Command execution failed;3;LINUX_OSAL;fsfw/hal/src/fsfw_hal/linux/CommandExecutor.h
-0x4304;UXOS_NoCommandLoadedOrPending;;4;LINUX_OSAL;fsfw/hal/src/fsfw_hal/linux/CommandExecutor.h
-0x4306;UXOS_PcloseCallError;;6;LINUX_OSAL;fsfw/hal/src/fsfw_hal/linux/CommandExecutor.h
-0x3101;CF_ObjectHasNoFunctions;;1;COMMANDS_ACTIONS_IF;fsfw/src/fsfw/action/CommandsActionsIF.h
-0x3102;CF_AlreadyCommanding;;2;COMMANDS_ACTIONS_IF;fsfw/src/fsfw/action/CommandsActionsIF.h
-0x3201;HF_IsBusy;;1;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
-0x3202;HF_InvalidParameters;;2;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
-0x3203;HF_ExecutionFinished;;3;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
-0x3204;HF_InvalidActionId;;4;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
-0x3501;CFDP_InvalidTlvType;;1;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3502;CFDP_InvalidDirectiveFields;;2;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3503;CFDP_InvalidPduDatafieldLen;;3;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3504;CFDP_InvalidAckDirectiveFields;;4;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3505;CFDP_MetadataCantParseOptions;;5;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3506;CFDP_FinishedCantParseFsResponses;;6;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3508;CFDP_FilestoreRequiresSecondFile;;8;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3509;CFDP_FilestoreResponseCantParseFsMessage;;9;CFDP;fsfw/src/fsfw/cfdp/definitions.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
-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
-0x1601;FMM_MapFull;;1;FIXED_MULTIMAP;fsfw/src/fsfw/container/FixedOrderedMultimap.h
-0x1602;FMM_KeyDoesNotExist;;2;FIXED_MULTIMAP;fsfw/src/fsfw/container/FixedOrderedMultimap.h
-0x37a1;SGP4_InvalidEccentricity;;161;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x37a2;SGP4_InvalidMeanMotion;;162;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x37a3;SGP4_InvalidPerturbationElements;;163;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x37a4;SGP4_InvalidSemiLatusRectum;;164;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x37a5;SGP4_InvalidEpochElements;;165;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x37a6;SGP4_SatelliteHasDecayed;;166;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x37b1;SGP4_TleTooOld;;177;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x37b2;SGP4_TleNotInitialized;;178;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x2b01;CCS_BcIsSetVrCommand;;1;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2b02;CCS_BcIsUnlockCommand;;2;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2bb0;CCS_BcIllegalCommand;;176;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2bb1;CCS_BoardReadingNotFinished;;177;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2bf0;CCS_NsPositiveW;;240;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2bf1;CCS_NsNegativeW;;241;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2bf2;CCS_NsLockout;;242;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2bf3;CCS_FarmInLockout;;243;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2bf4;CCS_FarmInWait;;244;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2be0;CCS_WrongSymbol;;224;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2be1;CCS_DoubleStart;;225;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2be2;CCS_StartSymbolMissed;;226;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2be3;CCS_EndWithoutStart;;227;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2be4;CCS_TooLarge;;228;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2be5;CCS_TooShort;;229;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2be6;CCS_WrongTfVersion;;230;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2be7;CCS_WrongSpacecraftId;;231;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2be8;CCS_NoValidFrameType;;232;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2be9;CCS_CrcFailed;;233;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2bea;CCS_VcNotFound;;234;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2beb;CCS_ForwardingFailed;;235;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2bec;CCS_ContentTooLarge;;236;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2bed;CCS_ResidualData;;237;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2bee;CCS_DataCorrupted;;238;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2bef;CCS_IllegalSegmentationFlag;;239;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2bd0;CCS_IllegalFlagCombination;;208;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2bd1;CCS_ShorterThanHeader;;209;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2bd2;CCS_TooShortBlockedPacket;;210;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2bd3;CCS_TooShortMapExtraction;;211;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x0801;DPS_InvalidParameterDefinition;;1;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
-0x0802;DPS_SetWasAlreadyRead;;2;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
-0x0803;DPS_CommitingWithoutReading;;3;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
-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
-0x3ca0;PVA_InvalidReadWriteMode;;160;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
-0x3ca1;PVA_InvalidPoolEntry;;161;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
-0x3d00;HKM_QueueOrDestinationInvalid;;0;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3d01;HKM_WrongHkPacketType;;1;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3d02;HKM_ReportingStatusUnchanged;;2;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3d03;HKM_PeriodicHelperInvalid;;3;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3d04;HKM_PoolobjectNotFound;;4;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3d05;HKM_DatasetNotFound;;5;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3b00;LPIF_PoolEntryNotFound;;0;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
-0x3b01;LPIF_PoolEntryTypeConflict;;1;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.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
-0x3301;DC_NoReplyReceived;;1;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x3302;DC_ProtocolError;;2;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x3303;DC_Nullpointer;;3;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x3304;DC_InvalidCookieType;;4;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x3305;DC_NotActive;;5;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x3306;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
-0x03b2;DHB_IgnoreFullPacket;;178;DEVICE_HANDLER_BASE;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h
-0x03c0;DHB_NothingToSend;;192;DEVICE_HANDLER_BASE;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h
-0x03c2;DHB_CommandMapError;;194;DEVICE_HANDLER_BASE;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h
-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
-0x26a0;DHI_NoCommandData;;160;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26a1;DHI_CommandNotSupported;;161;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26a2;DHI_CommandAlreadySent;;162;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26a3;DHI_CommandWasNotSent;;163;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26a4;DHI_CantSwitchAddress;;164;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26a5;DHI_WrongModeForCommand;;165;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26a6;DHI_Timeout;;166;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26a7;DHI_Busy;;167;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26a8;DHI_NoReplyExpected;;168;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26a9;DHI_NonOpTemperature;;169;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26aa;DHI_CommandNotImplemented;;170;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26b0;DHI_ChecksumError;;176;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26b1;DHI_LengthMissmatch;;177;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26b2;DHI_InvalidData;;178;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26b3;DHI_ProtocolError;;179;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26c0;DHI_DeviceDidNotExecute;;192;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26c1;DHI_DeviceReportedError;;193;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26c2;DHI_UnknownDeviceReply;;194;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26c3;DHI_DeviceReplyInvalid;;195;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26d0;DHI_InvalidCommandParameter;;208;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26d1;DHI_InvalidNumberOrLengthOfParameters;;209;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x2401;EV_ListenerNotFound;;1;EVENT_MANAGER_IF;fsfw/src/fsfw/events/EventManagerIF.h
-0x2500;FDI_YourFault;;0;HANDLES_FAILURES_IF;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h
-0x2501;FDI_MyFault;;1;HANDLES_FAILURES_IF;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h
-0x2502;FDI_ConfirmLater;;2;HANDLES_FAILURES_IF;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h
-0x2301;MT_TooDetailedRequest;;1;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
-0x2302;MT_TooGeneralRequest;;2;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
-0x2303;MT_NoMatch;;3;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
-0x2304;MT_Full;;4;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
-0x2305;MT_NewNodeCreated;;5;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
-0x2e01;ASC_TooLongForTargetType;;1;ASCII_CONVERTER;fsfw/src/fsfw/globalfunctions/AsciiConverter.h
-0x2e02;ASC_InvalidCharacters;;2;ASCII_CONVERTER;fsfw/src/fsfw/globalfunctions/AsciiConverter.h
-0x2e03;ASC_BufferTooSmall;;3;ASCII_CONVERTER;fsfw/src/fsfw/globalfunctions/AsciiConverter.h
-0x3e01;DLEE_StreamTooShort;;1;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
-0x3e02;DLEE_DecodingError;;2;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.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
-0x0f01;CM_UnknownCommand;;1;COMMAND_MESSAGE;fsfw/src/fsfw/ipc/CommandMessageIF.h
-0x3901;MQI_Empty;;1;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3902;MQI_Full;No space left for more messages;2;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3903;MQI_NoReplyPartner;Returned if a reply method was called without partner;3;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3904;MQI_DestinationInvalid;Returned if the target destination is invalid.;4;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3801;MUX_NotEnoughResources;;1;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3802;MUX_InsufficientMemory;;2;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3803;MUX_NoPrivilege;;3;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3804;MUX_WrongAttributeSetting;;4;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3805;MUX_MutexAlreadyLocked;;5;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3806;MUX_MutexNotFound;;6;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3807;MUX_MutexMaxLocks;;7;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3808;MUX_CurrThreadAlreadyOwnsMutex;;8;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3809;MUX_CurrThreadDoesNotOwnMutex;;9;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x380a;MUX_MutexTimeout;;10;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x380b;MUX_MutexInvalidId;;11;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x380c;MUX_MutexDestroyedWhileWaiting;;12;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x4200;FILS_GenericFileError;;0;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
-0x4201;FILS_IsBusy;;1;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
-0x4202;FILS_InvalidParameters;;2;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
-0x4205;FILS_FileDoesNotExist;;5;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
-0x4206;FILS_FileAlreadyExists;;6;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
-0x4207;FILS_FileLocked;;7;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
-0x420a;FILS_DirectoryDoesNotExist;;10;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
-0x420b;FILS_DirectoryAlreadyExists;;11;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
-0x420c;FILS_DirectoryNotEmpty;;12;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
-0x420f;FILS_SequencePacketMissingWrite;;15;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
-0x4210;FILS_SequencePacketMissingRead;;16;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
+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
+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
+0x52b3;RWHA_InvalidSubstitute;Can be used by the HDLC decoding mechanism to inform about an invalid substitution combination;179;RW_HANDLER;mission/devices/RwHandler.h
+0x52b4;RWHA_MissingEndSign;HDLC decoding mechanism never receives the end sign 0x7E;180;RW_HANDLER;mission/devices/RwHandler.h
+0x52b5;RWHA_NoReply;Reaction wheel only responds with empty frames.;181;RW_HANDLER;mission/devices/RwHandler.h
+0x52b6;RWHA_NoStartMarker;Expected a start marker as first byte;182;RW_HANDLER;mission/devices/RwHandler.h
+0x52a0;RWHA_InvalidSpeed;Action Message with invalid speed was received. Valid speeds must be in the range of [-65000, 1000] or [1000, 65000];160;RW_HANDLER;mission/devices/RwHandler.h
+0x52a1;RWHA_InvalidRampTime;Action Message with invalid ramp time was received.;161;RW_HANDLER;mission/devices/RwHandler.h
+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
+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
+0x50a3;SYRLINKS_BadParameterValueAck;;163;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
+0x50a4;SYRLINKS_BadEndOfFrameAck;;164;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
+0x50a5;SYRLINKS_UnknownCommandIdAck;;165;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
+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
+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
@ -249,76 +93,62 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 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
-0x3001;LIM_Unchecked;;1;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x3002;LIM_Invalid;;2;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x3003;LIM_Unselected;;3;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x3004;LIM_BelowLowLimit;;4;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x3005;LIM_AboveHighLimit;;5;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x3006;LIM_UnexpectedValue;;6;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x3007;LIM_OutOfRange;;7;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x30a0;LIM_FirstSample;;160;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x30e0;LIM_InvalidSize;;224;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x30e1;LIM_WrongType;;225;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x30e2;LIM_WrongPid;;226;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x30e3;LIM_WrongLimitId;;227;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x30ee;LIM_MonitorNotFound;;238;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.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
-0x1a04;TRC_BothValuesOol;;4;TRIPLE_REDUNDACY_CHECK;fsfw/src/fsfw/monitoring/TriplexMonitor.h
-0x1a05;TRC_DuplexOol;;5;TRIPLE_REDUNDACY_CHECK;fsfw/src/fsfw/monitoring/TriplexMonitor.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
-0x0200;OM_ConnBroken;;0;OBJECT_MANAGER_IF;fsfw/src/fsfw/osal/common/TcpTmTcServer.h
-0x2901;IEC_NoConfigurationTable;;1;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2902;IEC_NoCpuTable;;2;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2903;IEC_InvalidWorkspaceAddress;;3;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2904;IEC_TooLittleWorkspace;;4;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2905;IEC_WorkspaceAllocation;;5;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2906;IEC_InterruptStackTooSmall;;6;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2907;IEC_ThreadExitted;;7;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2908;IEC_InconsistentMpInformation;;8;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2909;IEC_InvalidNode;;9;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x290a;IEC_NoMpci;;10;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x290b;IEC_BadPacket;;11;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x290c;IEC_OutOfPackets;;12;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x290d;IEC_OutOfGlobalObjects;;13;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x290e;IEC_OutOfProxies;;14;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x290f;IEC_InvalidGlobalId;;15;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2910;IEC_BadStackHook;;16;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2911;IEC_BadAttributes;;17;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2912;IEC_ImplementationKeyCreateInconsistency;;18;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2913;IEC_ImplementationBlockingOperationCancel;;19;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2914;IEC_MutexObtainFromBadState;;20;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2915;IEC_UnlimitedAndMaximumIs0;;21;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2d01;HPA_InvalidIdentifierId;;1;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
-0x2d02;HPA_InvalidDomainId;;2;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
-0x2d03;HPA_InvalidValue;;3;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
-0x2d05;HPA_ReadOnly;;5;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
-0x2c01;PAW_UnknownDatatype;;1;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2c02;PAW_DatatypeMissmatch;;2;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2c03;PAW_Readonly;;3;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2c04;PAW_TooBig;;4;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2c05;PAW_SourceNotSet;;5;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2c06;PAW_OutOfBounds;;6;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2c07;PAW_NotSet;;7;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2c08;PAW_ColumnOrRowsZero;;8;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2f01;POS_InPowerTransition;;1;POWER_SWITCHER;fsfw/src/fsfw/power/PowerSwitcher.h
-0x2f02;POS_SwitchStateMismatch;;2;POWER_SWITCHER;fsfw/src/fsfw/power/PowerSwitcher.h
-0x0501;PS_SwitchOn;;1;POWER_SWITCH_IF;fsfw/src/fsfw/power/PowerSwitchIF.h
-0x0500;PS_SwitchOff;;0;POWER_SWITCH_IF;fsfw/src/fsfw/power/PowerSwitchIF.h
-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
-0x4101;PUS11_InvalidTypeTimeWindow;;1;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x4102;PUS11_TimeshiftingNotPossible;;2;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x4103;PUS11_InvalidRelativeTime;;3;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.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
@ -362,105 +192,286 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 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
-0x2701;SM_DataTooLarge;;1;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
-0x2702;SM_DataStorageFull;;2;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
-0x2703;SM_IllegalStorageId;;3;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
-0x2704;SM_DataDoesNotExist;;4;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
-0x2705;SM_IllegalAddress;;5;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
-0x2706;SM_PoolTooLarge;;6;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.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
-0x3a01;SPH_SemaphoreTimeout;;1;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
-0x3a02;SPH_SemaphoreNotOwned;;2;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
-0x3a03;SPH_SemaphoreInvalid;;3;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
-0x1c01;TCD_PacketLost;;1;PACKET_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/TcDistributor.h
-0x1c02;TCD_DestinationNotFound;;2;PACKET_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/TcDistributor.h
-0x1c03;TCD_ServiceIdAlreadyExists;;3;PACKET_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/TcDistributor.h
-0x1b00;TCC_IllegalApid;;0;TC_PACKET_CHECK;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h
-0x1b01;TCC_IncompletePacket;;1;TC_PACKET_CHECK;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h
-0x1b02;TCC_IncorrectChecksum;;2;TC_PACKET_CHECK;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h
-0x1b03;TCC_IllegalPacketType;;3;TC_PACKET_CHECK;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h
-0x1b04;TCC_IllegalPacketSubtype;;4;TC_PACKET_CHECK;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h
-0x1b05;TCC_IncorrectPrimaryHeader;;5;TC_PACKET_CHECK;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h
-0x1b06;TCC_IncorrectSecondaryHeader;;6;TC_PACKET_CHECK;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h
-0x2801;TC_InvalidTargetState;;1;THERMAL_COMPONENT_IF;fsfw/src/fsfw/thermal/ThermalComponentIF.h
-0x28f1;TC_AboveOperationalLimit;;241;THERMAL_COMPONENT_IF;fsfw/src/fsfw/thermal/ThermalComponentIF.h
-0x28f2;TC_BelowOperationalLimit;;242;THERMAL_COMPONENT_IF;fsfw/src/fsfw/thermal/ThermalComponentIF.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
+0x0802;DPS_SetWasAlreadyRead;;2;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
+0x0803;DPS_CommitingWithoutReading;;3;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
+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
+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
+0x0500;PS_SwitchOff;;0;POWER_SWITCH_IF;fsfw/src/fsfw/power/PowerSwitchIF.h
+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
+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
+0x1a04;TRC_BothValuesOol;;4;TRIPLE_REDUNDACY_CHECK;fsfw/src/fsfw/monitoring/TriplexMonitor.h
+0x1a05;TRC_DuplexOol;;5;TRIPLE_REDUNDACY_CHECK;fsfw/src/fsfw/monitoring/TriplexMonitor.h
+0x3101;LIM_Unchecked;;1;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x3102;LIM_Invalid;;2;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x3103;LIM_Unselected;;3;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x3104;LIM_BelowLowLimit;;4;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x3105;LIM_AboveHighLimit;;5;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x3106;LIM_UnexpectedValue;;6;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x3107;LIM_OutOfRange;;7;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x31a0;LIM_FirstSample;;160;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x31e0;LIM_InvalidSize;;224;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x31e1;LIM_WrongType;;225;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+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
+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
+0x03b2;DHB_IgnoreFullPacket;;178;DEVICE_HANDLER_BASE;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h
+0x03c0;DHB_NothingToSend;;192;DEVICE_HANDLER_BASE;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h
+0x03c2;DHB_CommandMapError;;194;DEVICE_HANDLER_BASE;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h
+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
+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
+0x27a3;DHI_CommandWasNotSent;;163;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x27a4;DHI_CantSwitchAddress;;164;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x27a5;DHI_WrongModeForCommand;;165;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x27a6;DHI_Timeout;;166;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x27a7;DHI_Busy;;167;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x27a8;DHI_NoReplyExpected;;168;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x27a9;DHI_NonOpTemperature;;169;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x27aa;DHI_CommandNotImplemented;;170;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x27b0;DHI_ChecksumError;;176;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x27b1;DHI_LengthMissmatch;;177;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x27b2;DHI_InvalidData;;178;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x27b3;DHI_ProtocolError;;179;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x27c0;DHI_DeviceDidNotExecute;;192;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x27c1;DHI_DeviceReportedError;;193;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x27c2;DHI_UnknownDeviceReply;;194;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+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
+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
-0x3601;TSI_BadTimestamp;;1;TIME_STAMPER_IF;fsfw/src/fsfw/timemanager/TimeStamperIF.h
-0x2001;TMB_Busy;;1;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2002;TMB_Full;;2;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2003;TMB_Empty;;3;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2004;TMB_NullRequested;;4;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2005;TMB_TooLarge;;5;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2006;TMB_NotReady;;6;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2007;TMB_DumpError;;7;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2008;TMB_CrcError;;8;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2009;TMB_Timeout;;9;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x200a;TMB_IdlePacketFound;;10;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x200b;TMB_TelecommandFound;;11;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x200c;TMB_NoPusATm;;12;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x200d;TMB_TooSmall;;13;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x200e;TMB_BlockNotFound;;14;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x200f;TMB_InvalidRequest;;15;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2101;TMF_Busy;;1;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2102;TMF_LastPacketFound;;2;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2103;TMF_StopFetch;;3;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2104;TMF_Timeout;;4;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2105;TMF_TmChannelFull;;5;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2106;TMF_NotStored;;6;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2107;TMF_AllDeleted;;7;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2108;TMF_InvalidData;;8;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2109;TMF_NotReady;;9;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x1d01;PUS_ActivityStarted;;1;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
-0x1d02;PUS_InvalidSubservice;;2;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
-0x1d03;PUS_IllegalApplicationData;;3;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
-0x1d04;PUS_SendTmFailed;;4;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
-0x1d05;PUS_Timeout;;5;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
-0x1f01;CSB_ExecutionComplete;;1;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x1f02;CSB_NoStepMessage;;2;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x1f03;CSB_ObjectBusy;;3;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x1f04;CSB_Busy;;4;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x1f05;CSB_InvalidTc;;5;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x1f06;CSB_InvalidObject;;6;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x1f07;CSB_InvalidReply;;7;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x4b00;SPPA_NoPacketFound;;0;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
-0x4b01;SPPA_SplitPacket;;1;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
-0x68a0;FSHLP_SdNotMounted;SD card specified with path string not mounted;160;FILE_SYSTEM_HELPER;bsp_q7s/memory/FilesystemHelper.h
-0x68a1;FSHLP_FileNotExists;Specified file does not exist on filesystem;161;FILE_SYSTEM_HELPER;bsp_q7s/memory/FilesystemHelper.h
-0x7400;SCBU_KeyNotFound;;0;SCRATCH_BUFFER;bsp_q7s/memory/scratchApi.h
-0x7300;SDMA_OpOngoing;;0;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
-0x7301;SDMA_AlreadyOn;;1;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
-0x7302;SDMA_AlreadyMounted;;2;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
-0x7303;SDMA_AlreadyOff;;3;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
-0x730a;SDMA_StatusFileNexists;;10;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
-0x730b;SDMA_StatusFileFormatInvalid;;11;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
-0x730c;SDMA_MountError;;12;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
-0x730d;SDMA_UnmountError;;13;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
-0x730e;SDMA_SystemCallError;;14;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
-0x730f;SDMA_PopenCallError;;15;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.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
+0x6a01;SDMA_AlreadyOn;;1;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6a02;SDMA_AlreadyMounted;;2;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6a03;SDMA_AlreadyOff;;3;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6a0a;SDMA_StatusFileNexists;;10;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6a0b;SDMA_StatusFileFormatInvalid;;11;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6a0c;SDMA_MountError;;12;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+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
--- a/generators/deps/fsfwgen
+++ b/generators/deps/fsfwgen
--- a/generators/events/event_parser.py
+++ b/generators/events/event_parser.py
@ -60,7 +60,7 @@ FILE_SEPARATOR = ";"
 SUBSYSTEM_DEFINITION_DESTINATIONS = [
    f"{FSFW_CONFIG_ROOT}/events/subsystemIdRanges.h",
    f"{OBSW_ROOT_DIR}/fsfw/src/fsfw/events/fwSubsystemIdRanges.h",
-    f"{OBSW_ROOT_DIR}/common/config/commonSubsystemIds.h",
+    f"{OBSW_ROOT_DIR}/common/config/eive/eventSubsystemIds.h",
 ]
 SUBSYSTEM_DEFS_DEST_AS_PATH = [Path(x) for x in SUBSYSTEM_DEFINITION_DESTINATIONS]

--- a/generators/events/translateEvents.cpp
+++ b/generators/events/translateEvents.cpp
@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 209 translations.
+ * @brief    Auto-generated event translation file. Contains 234 translations.
 * @details
- * Generated on: 2022-06-27 09:14:37
+ * Generated on: 2022-11-14 17:10:10
 */
 #include "translateEvents.h"

@ -75,6 +75,7 @@ const char *OVERWRITING_HEALTH_STRING = "OVERWRITING_HEALTH";
 const char *TRYING_RECOVERY_STRING = "TRYING_RECOVERY";
 const char *RECOVERY_STEP_STRING = "RECOVERY_STEP";
 const char *RECOVERY_DONE_STRING = "RECOVERY_DONE";
+const char *HANDLE_PACKET_FAILED_STRING = "HANDLE_PACKET_FAILED";
 const char *RF_AVAILABLE_STRING = "RF_AVAILABLE";
 const char *RF_LOST_STRING = "RF_LOST";
 const char *BIT_LOCK_STRING = "BIT_LOCK";
@ -85,6 +86,9 @@ const char *CLOCK_SET_FAILURE_STRING = "CLOCK_SET_FAILURE";
 const char *TC_DELETION_FAILED_STRING = "TC_DELETION_FAILED";
 const char *TEST_STRING = "TEST";
 const char *CHANGE_OF_SETUP_PARAMETER_STRING = "CHANGE_OF_SETUP_PARAMETER";
+const char *STORE_ERROR_STRING = "STORE_ERROR";
+const char *MSG_QUEUE_ERROR_STRING = "MSG_QUEUE_ERROR";
+const char *SERIALIZATION_ERROR_STRING = "SERIALIZATION_ERROR";
 const char *SWITCH_CMD_SENT_STRING = "SWITCH_CMD_SENT";
 const char *SWITCH_HAS_CHANGED_STRING = "SWITCH_HAS_CHANGED";
 const char *SWITCHING_Q7S_DENIED_STRING = "SWITCHING_Q7S_DENIED";
@ -97,11 +101,15 @@ const char *SWITCH_ALREADY_ON_STRING = "SWITCH_ALREADY_ON";
 const char *SWITCH_ALREADY_OFF_STRING = "SWITCH_ALREADY_OFF";
 const char *MAIN_SWITCH_TIMEOUT_STRING = "MAIN_SWITCH_TIMEOUT";
 const char *FAULTY_HEATER_WAS_ON_STRING = "FAULTY_HEATER_WAS_ON";
+const char *BURN_PHASE_START_STRING = "BURN_PHASE_START";
+const char *BURN_PHASE_DONE_STRING = "BURN_PHASE_DONE";
 const char *MAIN_SWITCH_ON_TIMEOUT_STRING = "MAIN_SWITCH_ON_TIMEOUT";
 const char *MAIN_SWITCH_OFF_TIMEOUT_STRING = "MAIN_SWITCH_OFF_TIMEOUT";
-const char *DEPLOYMENT_FAILED_STRING = "DEPLOYMENT_FAILED";
 const char *DEPL_SA1_GPIO_SWTICH_ON_FAILED_STRING = "DEPL_SA1_GPIO_SWTICH_ON_FAILED";
 const char *DEPL_SA2_GPIO_SWTICH_ON_FAILED_STRING = "DEPL_SA2_GPIO_SWTICH_ON_FAILED";
+const char *DEPL_SA1_GPIO_SWTICH_OFF_FAILED_STRING = "DEPL_SA1_GPIO_SWTICH_OFF_FAILED";
+const char *DEPL_SA2_GPIO_SWTICH_OFF_FAILED_STRING = "DEPL_SA2_GPIO_SWTICH_OFF_FAILED";
+const char *AUTONOMOUS_DEPLOYMENT_COMPLETED_STRING = "AUTONOMOUS_DEPLOYMENT_COMPLETED";
 const char *MEMORY_READ_RPT_CRC_FAILURE_STRING = "MEMORY_READ_RPT_CRC_FAILURE";
 const char *ACK_FAILURE_STRING = "ACK_FAILURE";
 const char *EXE_FAILURE_STRING = "EXE_FAILURE";
@ -136,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";
@ -165,6 +174,8 @@ const char *MPSOC_EXE_FAILURE_REPORT_STRING = "MPSOC_EXE_FAILURE_REPORT";
 const char *MPSOC_ACK_INVALID_APID_STRING = "MPSOC_ACK_INVALID_APID";
 const char *MPSOC_EXE_INVALID_APID_STRING = "MPSOC_EXE_INVALID_APID";
 const char *MPSOC_HELPER_SEQ_CNT_MISMATCH_STRING = "MPSOC_HELPER_SEQ_CNT_MISMATCH";
+const char *MPSOC_TM_SIZE_ERROR_STRING = "MPSOC_TM_SIZE_ERROR";
+const char *MPSOC_TM_CRC_MISSMATCH_STRING = "MPSOC_TM_CRC_MISSMATCH";
 const char *TRANSITION_BACK_TO_OFF_STRING = "TRANSITION_BACK_TO_OFF";
 const char *NEG_V_OUT_OF_BOUNDS_STRING = "NEG_V_OUT_OF_BOUNDS";
 const char *U_DRO_OUT_OF_BOUNDS_STRING = "U_DRO_OUT_OF_BOUNDS";
@ -194,6 +205,8 @@ const char *TERMINATED_UPDATE_PROCEDURE_STRING = "TERMINATED_UPDATE_PROCEDURE";
 const char *SUPV_EVENT_BUFFER_REQUEST_SUCCESSFUL_STRING = "SUPV_EVENT_BUFFER_REQUEST_SUCCESSFUL";
 const char *SUPV_EVENT_BUFFER_REQUEST_FAILED_STRING = "SUPV_EVENT_BUFFER_REQUEST_FAILED";
 const char *SUPV_EVENT_BUFFER_REQUEST_TERMINATED_STRING = "SUPV_EVENT_BUFFER_REQUEST_TERMINATED";
+const char *SUPV_MEM_CHECK_OK_STRING = "SUPV_MEM_CHECK_OK";
+const char *SUPV_MEM_CHECK_FAIL_STRING = "SUPV_MEM_CHECK_FAIL";
 const char *SUPV_SENDING_COMMAND_FAILED_STRING = "SUPV_SENDING_COMMAND_FAILED";
 const char *SUPV_HELPER_REQUESTING_REPLY_FAILED_STRING = "SUPV_HELPER_REQUESTING_REPLY_FAILED";
 const char *SUPV_HELPER_READING_REPLY_FAILED_STRING = "SUPV_HELPER_READING_REPLY_FAILED";
@ -206,10 +219,22 @@ const char *SUPV_EXE_INVALID_APID_STRING = "SUPV_EXE_INVALID_APID";
 const char *ACK_RECEPTION_FAILURE_STRING = "ACK_RECEPTION_FAILURE";
 const char *EXE_RECEPTION_FAILURE_STRING = "EXE_RECEPTION_FAILURE";
 const char *WRITE_MEMORY_FAILED_STRING = "WRITE_MEMORY_FAILED";
+const char *SUPV_REPLY_SIZE_MISSMATCH_STRING = "SUPV_REPLY_SIZE_MISSMATCH";
+const char *SUPV_REPLY_CRC_MISSMATCH_STRING = "SUPV_REPLY_CRC_MISSMATCH";
+const char *SUPV_UPDATE_PROGRESS_STRING = "SUPV_UPDATE_PROGRESS";
 const char *ALLOC_FAILURE_STRING = "ALLOC_FAILURE";
 const char *REBOOT_SW_STRING = "REBOOT_SW";
 const char *REBOOT_MECHANISM_TRIGGERED_STRING = "REBOOT_MECHANISM_TRIGGERED";
 const char *REBOOT_HW_STRING = "REBOOT_HW";
+const char *NO_SD_CARD_ACTIVE_STRING = "NO_SD_CARD_ACTIVE";
+const char *MISSING_PACKET_STRING = "MISSING_PACKET";
+const char *EXPERIMENT_TIMEDOUT_STRING = "EXPERIMENT_TIMEDOUT";
+const char *MULTI_PACKET_COMMAND_DONE_STRING = "MULTI_PACKET_COMMAND_DONE";
+const char *SET_CONFIGFILEVALUE_FAILED_STRING = "SET_CONFIGFILEVALUE_FAILED";
+const char *GET_CONFIGFILEVALUE_FAILED_STRING = "GET_CONFIGFILEVALUE_FAILED";
+const char *INSERT_CONFIGFILEVALUE_FAILED_STRING = "INSERT_CONFIGFILEVALUE_FAILED";
+const char *WRITE_CONFIGFILE_FAILED_STRING = "WRITE_CONFIGFILE_FAILED";
+const char *READ_CONFIGFILE_FAILED_STRING = "READ_CONFIGFILE_FAILED";

 const char *translateEvents(Event event) {
  switch ((event & 0xFFFF)) {
@ -353,6 +378,8 @@ const char *translateEvents(Event event) {
      return RECOVERY_STEP_STRING;
    case (7512):
      return RECOVERY_DONE_STRING;
+    case (7600):
+      return HANDLE_PACKET_FAILED_STRING;
    case (7900):
      return RF_AVAILABLE_STRING;
    case (7901):
@ -373,6 +400,12 @@ const char *translateEvents(Event event) {
      return TEST_STRING;
    case (10600):
      return CHANGE_OF_SETUP_PARAMETER_STRING;
+    case (10800):
+      return STORE_ERROR_STRING;
+    case (10801):
+      return MSG_QUEUE_ERROR_STRING;
+    case (10802):
+      return SERIALIZATION_ERROR_STRING;
    case (11300):
      return SWITCH_CMD_SENT_STRING;
    case (11301):
@ -398,15 +431,23 @@ const char *translateEvents(Event event) {
    case (11407):
      return FAULTY_HEATER_WAS_ON_STRING;
    case (11500):
-      return MAIN_SWITCH_ON_TIMEOUT_STRING;
+      return BURN_PHASE_START_STRING;
    case (11501):
-      return MAIN_SWITCH_OFF_TIMEOUT_STRING;
+      return BURN_PHASE_DONE_STRING;
    case (11502):
-      return DEPLOYMENT_FAILED_STRING;
+      return MAIN_SWITCH_ON_TIMEOUT_STRING;
    case (11503):
-      return DEPL_SA1_GPIO_SWTICH_ON_FAILED_STRING;
+      return MAIN_SWITCH_OFF_TIMEOUT_STRING;
    case (11504):
+      return DEPL_SA1_GPIO_SWTICH_ON_FAILED_STRING;
+    case (11505):
      return DEPL_SA2_GPIO_SWTICH_ON_FAILED_STRING;
+    case (11506):
+      return DEPL_SA1_GPIO_SWTICH_OFF_FAILED_STRING;
+    case (11507):
+      return DEPL_SA2_GPIO_SWTICH_OFF_FAILED_STRING;
+    case (11508):
+      return AUTONOMOUS_DEPLOYMENT_COMPLETED_STRING;
    case (11601):
      return MEMORY_READ_RPT_CRC_FAILURE_STRING;
    case (11602):
@ -475,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):
@ -533,6 +576,10 @@ const char *translateEvents(Event event) {
      return MPSOC_EXE_INVALID_APID_STRING;
    case (12611):
      return MPSOC_HELPER_SEQ_CNT_MISMATCH_STRING;
+    case (12612):
+      return MPSOC_TM_SIZE_ERROR_STRING;
+    case (12613):
+      return MPSOC_TM_CRC_MISSMATCH_STRING;
    case (12700):
      return TRANSITION_BACK_TO_OFF_STRING;
    case (12701):
@ -592,29 +639,39 @@ const char *translateEvents(Event event) {
    case (13607):
      return SUPV_EVENT_BUFFER_REQUEST_TERMINATED_STRING;
    case (13608):
-      return SUPV_SENDING_COMMAND_FAILED_STRING;
+      return SUPV_MEM_CHECK_OK_STRING;
    case (13609):
-      return SUPV_HELPER_REQUESTING_REPLY_FAILED_STRING;
-    case (13610):
-      return SUPV_HELPER_READING_REPLY_FAILED_STRING;
-    case (13611):
-      return SUPV_MISSING_ACK_STRING;
-    case (13612):
-      return SUPV_MISSING_EXE_STRING;
-    case (13613):
-      return SUPV_ACK_FAILURE_REPORT_STRING;
-    case (13614):
-      return SUPV_EXE_FAILURE_REPORT_STRING;
-    case (13615):
-      return SUPV_ACK_INVALID_APID_STRING;
+      return SUPV_MEM_CHECK_FAIL_STRING;
    case (13616):
-      return SUPV_EXE_INVALID_APID_STRING;
+      return SUPV_SENDING_COMMAND_FAILED_STRING;
    case (13617):
-      return ACK_RECEPTION_FAILURE_STRING;
+      return SUPV_HELPER_REQUESTING_REPLY_FAILED_STRING;
    case (13618):
-      return EXE_RECEPTION_FAILURE_STRING;
+      return SUPV_HELPER_READING_REPLY_FAILED_STRING;
    case (13619):
+      return SUPV_MISSING_ACK_STRING;
+    case (13620):
+      return SUPV_MISSING_EXE_STRING;
+    case (13621):
+      return SUPV_ACK_FAILURE_REPORT_STRING;
+    case (13622):
+      return SUPV_EXE_FAILURE_REPORT_STRING;
+    case (13623):
+      return SUPV_ACK_INVALID_APID_STRING;
+    case (13624):
+      return SUPV_EXE_INVALID_APID_STRING;
+    case (13625):
+      return ACK_RECEPTION_FAILURE_STRING;
+    case (13626):
+      return EXE_RECEPTION_FAILURE_STRING;
+    case (13627):
      return WRITE_MEMORY_FAILED_STRING;
+    case (13628):
+      return SUPV_REPLY_SIZE_MISSMATCH_STRING;
+    case (13629):
+      return SUPV_REPLY_CRC_MISSMATCH_STRING;
+    case (13630):
+      return SUPV_UPDATE_PROGRESS_STRING;
    case (13700):
      return ALLOC_FAILURE_STRING;
    case (13701):
@ -623,6 +680,24 @@ const char *translateEvents(Event event) {
      return REBOOT_MECHANISM_TRIGGERED_STRING;
    case (13703):
      return REBOOT_HW_STRING;
+    case (13704):
+      return NO_SD_CARD_ACTIVE_STRING;
+    case (13800):
+      return MISSING_PACKET_STRING;
+    case (13801):
+      return EXPERIMENT_TIMEDOUT_STRING;
+    case (13802):
+      return MULTI_PACKET_COMMAND_DONE_STRING;
+    case (13901):
+      return SET_CONFIGFILEVALUE_FAILED_STRING;
+    case (13902):
+      return GET_CONFIGFILEVALUE_FAILED_STRING;
+    case (13903):
+      return INSERT_CONFIGFILEVALUE_FAILED_STRING;
+    case (13904):
+      return WRITE_CONFIGFILE_FAILED_STRING;
+    case (13905):
+      return READ_CONFIGFILE_FAILED_STRING;
    default:
      return "UNKNOWN_EVENT";
  }
--- a/Show More
+++ b/Show More