prepare release

prepare next version
update generated files
2023-02-01 20:21:04 +01:00 · 2023-02-01 20:20:08 +01:00 · 2023-02-01 19:43:38 +01:00 · 2023-02-01 18:44:00 +01:00 · 2023-02-01 17:44:45 +01:00 · 2023-02-01 13:44:31 +01:00
293 changed files with 19023 additions and 5696 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -8,9 +8,216 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 The [milestone](https://egit.irs.uni-stuttgart.de/eive/eive-obsw/milestones)
 list yields a list of all related PRs for each release.

+Starting at v2.0.0, the following changes will consitute of a breaking
+change warranting a new major release:
+
+- The TMTC interface changes in any shape of form.
+- The behavour of the OBSW changes in a major shape or form relevant
+  for operations
+
 # [unreleased]

-# [v1.14.0]
+# [v1.23.0] 2023-02-01
+
+TMTC version: v2.9.0
+
+## Changed
+
+- Bumped FSFW to include improvements and bugfix for Health Service. The health service now
+  supports the announce all health info command.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/725
+
+## Fixed
+
+- Bumped FSFW to include fixes in the time service.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/726
+- The CCSDS handler starts the transmitter timer each time it is commanded to MODE_ON and times
+  out the timer when the handler is commanded to MODE_OFF
+- If the timer is timed out the CCSDS handler will disable the TX clock which will cause the
+  syrlinks to got to standby mode
+- PDEC handler now parses the FAR register also in interrupt mode
+
+
+# [v1.22.1] 2023-01-30
+
+## Changed
+
+- Updated FSFW to include addition where the `SO_REUSEADDR` option is set
+  on the TCP server, which should improve its ergonomics.
+
+# [v1.22.0] 2023-01-28
+
+TMTC version: v2.6.1
+
+## Added
+
+- First COM subsystem implementation. It mirrors the Syrlinks mode/submodes but also takes
+  care of commanding the CCSDS handler. It expects the Syrlinks submodes as mode commands.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/358
+- The CCSDS handler has has a new submode (3) to configure the default datarate.
+- Default datarate parameter commanding moved to COM subsystem.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/358
+
+# [v1.21.0] 2023-01-26
+
+TMTC version: v2.5.0
+Syrlinks PR: PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/353
+
+## Fixed
+
+- The `OBSW_SYRLINKS_SIMULATED` flag is set to 0 for for both EM and FM.
+- MGM4 handling in ACS sensor processing: Bugfix in `mulScalar` operation
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/354
+- Subsystem ID clash: CORE subsystem ID was the same as Syrlinks subsystem ID.
+
+## Changed
+
+- Startracker temperature set and PCDU switcher set are diagnostic now
+- `SyrlinksHkHandler` renamed to `SyrlinksHandler` to better reflect that it does more than
+  just HK and is also responsible for setting the TX mode of the device.
+- `SyrlinksHandler`: Go to startup immediately because the Syrlinks device should always be on
+  by default.
+- `SyrlinksHandler`: Go to normal mode at startup.
+
+## Added
+
+- The Syrlinks handler has submodes for the TX mode now: RX Only (0), RX and TX default
+  datarate (1), RX and TX Low Rate (2), RX and TX High Rate (3) and TX Carrier Wave (4).
+  The submodes apply for both ON and NORMAL mode. The default datarate can be updated using
+  a parameter command (domain ID 0 and unique ID 0) with value 0 for low rate and 1 for high rate.
+- The Syrlinks handler always sets TX to standby when switching off
+- The Syrlinks handler triggers a new TX_ON event when the transmitter was switched on successfully
+  and a TX_OFF event when it was switched off successfully.
+- Startracker temperature set and PCDU switcher set are diagnostic now
+- The CCSDS handler can accept mode commands now. It accepts ON and OFF commands. Furthermore
+  it has a submode for low datarate (1) and high datarate (2) for the ON command.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/352
+
+# [v1.20.0] 2023-01-24
+
+## Added
+
+- The Q7S SW now checks for a file named `boot_delay_secs.txt` in the home directory.
+  If it exists and the file is empty, it will delay for 6 seconds before continuing
+  with the regular boot. It can also try to read delay seconds from the file.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/340.
+- Basic TCS Subsystem component.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/319
+- Expose base set of STR periodic housekeeping packets
+
+## Changed
+
+- Moved some PDEC/PTME configuration to `common/config/eive/definitions.h`
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/319
+- The ACS Controller Gyro Sets (raw and processed) and the MEKF dataset are diagnostics now.
+- Bumped FSFW for Service 11 improvement which includes size and CRC check for contained TC
+- Syrlinks module now always included for both EM and FM
+- SA Deployment: Allow specifying the switch interval and the initial channel. This allows testing
+  the new deployment procedure where each channel is burned for half of the whole burn duration.
+  It also allows burning only one channel for the whole burn duration. The autonomous mechanism
+  was adapted to burn each channel for half of the burn time by default.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/347
+  TMTC PR: https://egit.irs.uni-stuttgart.de/eive/eive-tmtc/pulls/127
+- `Max31865RtdLowlevelHandler.cpp`: For each RTD device, the config is now re-written before
+  every read. This seems to fix some issue with invalid temperature sensor readings.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/345
+
+## Fixed
+
+- `GyroADIS1650XHandler`: Updated handler to determine correct dynamic range from `RANG_MDL`
+  register readout. This is because ADIS16505-3BMLZ devices are used on the ACS board and the
+  previous range setting was wrong. Also fixed a small error properly set internal state
+  on shut-down.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/342
+- Syrlinks Handler: Read RX frequency shift as 24 bit signed number now. Also include
+  validity handling for datasets.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/350
+- `GyroADIS1650XHandler`: Changed calculation of angular rate to be sensitivity based instead of 
+  max. range based, as previous fix still left an margin of error between ADIS16505 sensors 
+  and L3GD20 sensors.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/346
+
+# [v1.19.0] 2023-01-10
+
+## Changed
+
+- 5V stack is now off by default
+
+## Fixed
+
+- PLOC SUPV: Minor adaptions and important bugfix for UART manager
+- Allow cloning and building the hosted OBSW version without proprietary libraries,
+  which also avoids the need to have a Gitea account.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/337
+
+## Added
+
+- First version of ACS controller
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/329
+- Allow commanding the 5V stack internally in software
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/334
+- Add automatic 5V stack commanding for all connected devices
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/335
+
+# [v1.18.0] 2022-12-01
+
+## Changed
+
+- PLOC Supervisor: Changes baudrate to 921600
+- Renamed `/dev/ul-plsv` to `/dev/ploc_supv`, is not a UART lite anymore
+- Renamed `/dev/i2c_eive` to `/dev/i2c_pl` and `/dev/i2c-2` to `/dev/i2c_ps`.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/328
+
+# [v1.17.0] 2022-11-28
+
+## Added
+
+- PLOC Supervisor Update: Update SW to use newest PLOC SUPV version by TAS
+  PR 1: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/316
+  PR 2: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/324
+  PR 3: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/326
+
+# [v1.16.0] 2022-11-18
+
+- 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] 2022-10-27
+
+- 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
@ -29,6 +236,7 @@ list yields a list of all related PRs for each release.
 - Fix for EM SW: Always create ACS Task
 - Added Scex device handler and Scex uart reader
  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/303
+- ACS Subsystem. PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/228

 # [v1.13.0] 24.08.2022

--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -10,7 +10,7 @@
 cmake_minimum_required(VERSION 3.13)

 set(OBSW_VERSION_MAJOR_IF_GIT_FAILS 1)
-set(OBSW_VERSION_MINOR_IF_GIT_FAILS 14)
+set(OBSW_VERSION_MINOR_IF_GIT_FAILS 23)
 set(OBSW_VERSION_REVISION_IF_GIT_FAILS 0)

 # set(CMAKE_VERBOSE TRUE)
@ -98,14 +98,35 @@ set(OBSW_ADD_ACS_BOARD
 set(OBSW_ADD_GPS_CTRL
    ${INIT_VAL}
    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
-    1
+    ${INIT_VAL}
    CACHE STRING "Add RTD devices")
 set(OBSW_ADD_RAD_SENSORS
    ${INIT_VAL}
@ -114,7 +135,7 @@ set(OBSW_ADD_PL_PCDU
    ${INIT_VAL}
    CACHE STRING "Add Payload PCDU modukle")
 set(OBSW_ADD_SYRLINKS
-    ${INIT_VAL}
+    1
    CACHE STRING "Add Syrlinks module")
 set(OBSW_ADD_TMP_DEVICES
    ${INIT_VAL}
@ -128,6 +149,9 @@ set(OBSW_ADD_RW
 set(OBSW_ADD_SCEX_DEVICE
    ${INIT_VAL}
    CACHE STRING "Add Solar Cell Experiment module")
+set(OBSW_SYRLINKS_SIMULATED
+    0
+    CACHE STRING "Syrlinks is simulated")

 # ##############################################################################
 # Pre-Sources preparation
@ -209,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.
@ -229,12 +253,15 @@ if(TGT_BSP)
    set(FSFW_CONFIG_PATH "linux/fsfwconfig")
    if(NOT BUILD_Q7S_SIMPLE_MODE)
      set(EIVE_ADD_LINUX_FILES TRUE)
+      set(EIVE_ADD_LINUX_FSFWCONFIG TRUE)
      set(ADD_GOMSPACE_CSP TRUE)
      set(ADD_GOMSPACE_CLIENTS TRUE)
      set(FSFW_HAL_ADD_LINUX ON)
      set(FSFW_HAL_LINUX_ADD_LIBGPIOD ON)
      set(FSFW_HAL_LINUX_ADD_PERIPHERAL_DRIVERS ON)
    endif()
+  elseif(UNIX)
+    set(EIVE_ADD_LINUX_FILES ON)
  endif()

  if(TGT_BSP MATCHES "arm/raspberrypi")
@ -269,6 +296,9 @@ if(TGT_BSP)
 else()
  # Required by FSFW library
  set(FSFW_CONFIG_PATH "${BSP_PATH}/fsfwconfig")
+  if(UNIX)
+    set(EIVE_ADD_LINUX_FILES ON)
+  endif()
 endif()

 # Configuration files
@ -369,18 +399,17 @@ 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})
+  if(TGT_BSP MATCHES "arm/q7s")
+    add_subdirectory(${LIB_GOMSPACE_PATH})
+    add_subdirectory(${LIB_ARCSEC_PATH})
+  endif()
  add_subdirectory(${LINUX_PATH})
 endif()
 add_subdirectory(${BSP_PATH})

-if(UNIX)
-  add_subdirectory(${LIB_GOMSPACE_PATH})
-endif()
-
 add_subdirectory(${COMMON_PATH})
 add_subdirectory(${DUMMY_PATH})

@ -459,7 +488,8 @@ target_link_libraries(${LIB_DUMMIES} PUBLIC ${LIB_FSFW_NAME} ${LIB_JSON_NAME})
 target_link_libraries(${OBSW_NAME} PRIVATE ${LIB_EIVE_MISSION} ${LIB_DUMMIES})

 if(TGT_BSP MATCHES "arm/q7s")
-  target_link_libraries(${LIB_EIVE_MISSION} PUBLIC ${LIB_GPS} ${LIB_ARCSEC})
+  target_link_libraries(${LIB_EIVE_MISSION} PUBLIC ${LIB_GPS} ${LIB_ARCSEC}
+                                                   ${LIB_GOMSPACE_CLIENTS})
 endif()

 target_link_libraries(${UNITTEST_NAME} PRIVATE Catch2 ${LIB_EIVE_MISSION}
@ -469,10 +499,6 @@ if(TGT_BSP MATCHES "arm/egse")
  target_link_libraries(${OBSW_NAME} PRIVATE ${LIB_ARCSEC})
 endif()

-if(UNIX)
-  target_link_libraries(${OBSW_NAME} PRIVATE ${LIB_GOMSPACE_CLIENTS})
-endif()
-
 if(EIVE_ADD_ETL_LIB)
  target_link_libraries(${LIB_EIVE_MISSION} PUBLIC ${LIB_ETL_TARGET})
 endif()
--- a/README.md
+++ b/README.md
@ -95,9 +95,7 @@ When using Windows, run theses steps in MSYS2.
 2. Update all the submodules

   ```sh
-   git submodule init
-   git submodule sync
-   git submodule update
+   git submodule update --init
   ```

 3. Ensure that the cross-compiler is working with `arm-linux-gnueabihf-gcc --version` and that
@ -290,7 +288,7 @@ helper scripts as well.
 4. Run build command by double clicking the created target or by right clicking
   the project folder and selecting Build Project.

-# <a id="host-commands"></a> Useful and Common Commands (Host)
+# <a id="host-commands"></a> Useful and Common Commands

 ## Build generation

@ -319,14 +317,11 @@ cmake -DTGT_BSP=arm/q7s -DCMAKE_BUILD_TYPE=Release ..
 cmake --build . -j
 ```

-### Q7S Watchdog
-
-The watchdog will be built along side the primary OBSW binary.
-
-### Hosted
+### Hosted OBSW

 You can also use the FSFW OSAL `host` to build on Windows or for generic OSes.
-Note: Currently this is not supported.
+You can use the `clone-submodules-no-privlibs.sh` script to only clone the required (non-private)
+submodules required to build the hosted OBSW.

 ```sh
 mkdir cmake-build-debug && cd cmake-build-debug
@ -334,6 +329,21 @@ cmake -DFSFW_OSAL=host -DCMAKE_BUILD_TYPE=Debug ..
 cmake --build . -j
 ```

+You can also use the `linux` OSAL:
+
+```sh
+mkdir cmake-build-debug && cd cmake-build-debug
+cmake -DFSFW_OSAL=linux -DCMAKE_BUILD_TYPE=Debug ..
+cmake --build . -j
+```
+
+Please note that some additional Linux setup might be necessary.
+You can find more information in the [Linux section of the FSFW example](https://egit.irs.uni-stuttgart.de/fsfw/fsfw-example-linux-mcu/src/branch/mueller/master/doc/README-linux.md#raising-message-queue-size-limit)
+
+### Q7S Watchdog
+
+The watchdog will be built along side the primary OBSW binary.
+
 ### Unittests

 To build the unittests, the corresponding target must be specified in the build command.
@ -1055,6 +1065,29 @@ Get fill count:
 xsc_scratch read | wc -c
 ```

+## Custom device names in Linux with the `udev` module
+
+You can assign custom device names using the Linux `udev` system.
+This works by specifying a rules file inside the `/etc/udev/rules.d` folder
+which creates a SYMLINK if certain device properties are true.
+
+Each rule is a new line inside a rules file.
+For example, the rule
+
+```txt
+SUBSYSTEM=="tty", ATTRS{interface}=="Dual RS232-HS", ATTRS{bInterfaceNumber}=="01", SYMLINK+="ploc_supv
+```
+
+Will create a symlink `/dev/ploc_supv` if a connected USB device has the
+same `interface` and `bInterfaceNumber` properties as shown above.
+
+You can list the properties for a given connected device using `udevadm`.
+For example, you can do this for a connected example device `/dev/ttyUSB0`
+by using
+
+```txt
+udevadm info -a /dev/ttyUSB0
+```

 ## Using `system` when debugging

@ -1108,11 +1141,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/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/CMakeLists.txt
+++ b/bsp_hosted/CMakeLists.txt
@ -1,4 +1,4 @@
-target_sources(${OBSW_NAME} PUBLIC InitMission.cpp main.cpp ObjectFactory.cpp)
+target_sources(${OBSW_NAME} PUBLIC scheduling.cpp main.cpp ObjectFactory.cpp)

 add_subdirectory(fsfwconfig)
 add_subdirectory(boardconfig)
--- a/bsp_hosted/Dockerfile
+++ b/bsp_hosted/Dockerfile
@ -14,7 +14,7 @@ RUN set -ex; \
    rm -rf build-hosted; \
    mkdir build-hosted; \
    cd build-hosted; \
-    cmake -DCMAKE_BUILD_TYPE=Release -DOS_FSFW=linux ..;
+    cmake -DCMAKE_BUILD_TYPE=Release -DOSAL_FSFW=host ..;

 ENTRYPOINT ["cmake", "--build", "build-hosted"]
 CMD ["-j"]
--- a/bsp_hosted/InitMission.h
+++ b/bsp_hosted/InitMission.h
@ -1,9 +0,0 @@
-#ifndef BSP_LINUX_INITMISSION_H_
-#define BSP_LINUX_INITMISSION_H_
-
-namespace initmission {
-void initMission();
-void initTasks();
-};  // namespace initmission
-
-#endif /* BSP_LINUX_INITMISSION_H_ */
--- a/bsp_hosted/OBSWConfig.h.in
+++ b/bsp_hosted/OBSWConfig.h.in
@ -24,6 +24,7 @@
 #define OBSW_ADD_GPS_0                              0
 #define OBSW_ADD_GPS_1                              0
 #define OBSW_ADD_RW                                 0
+#define OBSW_DEBUG_TMP1075                          0
 #define OBSW_ADD_BPX_BATTERY_HANDLER                0
 #define OBSW_ADD_RTD_DEVICES                        0
 #define OBSW_ADD_PL_PCDU                            0
@ -100,6 +101,10 @@
 /*******************************************************************/
 /** CMake Defines                                                  */
 /*******************************************************************/
+
+#define OBSW_ADD_TMTC_UDP_SERVER            1
+#define OBSW_ADD_TMTC_TCP_SERVER            1
+
 #cmakedefine EIVE_BUILD_GPSD_GPS_HANDLER

 #cmakedefine LIBGPS_VERSION_MAJOR @LIBGPS_VERSION_MAJOR@
--- a/bsp_hosted/ObjectFactory.cpp
+++ b/bsp_hosted/ObjectFactory.cpp
@ -1,21 +1,25 @@
 #include "ObjectFactory.h"

+#include <fsfw/power/DummyPowerSwitcher.h>
 #include <fsfw/tmtcservices/CommandingServiceBase.h>
 #include <fsfw/tmtcservices/PusServiceBase.h>
 #include <mission/controller/ThermalController.h>
 #include <mission/core/GenericFactory.h>
-#include <mission/tmtc/TmFunnel.h>
+#include <mission/tmtc/TmFunnelHandler.h>
 #include <objects/systemObjectList.h>
-#include <tmtc/pusIds.h>

 #include "OBSWConfig.h"
+#include "devConf.h"
 #include "eive/definitions.h"
+#include "fsfw/platform.h"
 #include "fsfw_tests/integration/task/TestTask.h"
+#include "tmtc/pusIds.h"

-#if OBSW_USE_TMTC_TCP_BRIDGE == 0
+#if OBSW_ADD_TMTC_UDP_SERVER == 1
 #include "fsfw/osal/common/UdpTcPollingTask.h"
 #include "fsfw/osal/common/UdpTmTcBridge.h"
-#else
+#endif
+#if OBSW_ADD_TMTC_TCP_SERVER == 1
 #include "fsfw/osal/common/TcpTmTcBridge.h"
 #include "fsfw/osal/common/TcpTmTcServer.h"
 #endif
@ -47,28 +51,65 @@
 #include "dummies/helpers.h"
 #include "mission/utility/GlobalConfigHandler.h"

+#ifdef PLATFORM_UNIX
+#include <fsfw_hal/linux/serial/SerialComIF.h>
+#include <fsfw_hal/linux/serial/SerialCookie.h>
+
+#include "devices/gpioIds.h"
+#include "fsfw_hal/linux/gpio/Gpio.h"
+#include "linux/devices/ploc/PlocMPSoCHandler.h"
+#include "linux/devices/ploc/PlocMPSoCHelper.h"
+#include "linux/devices/ploc/PlocSupervisorHandler.h"
+#include "linux/devices/ploc/PlocSupvUartMan.h"
+#include "test/gpio/DummyGpioIF.h"
+#endif
+
 void Factory::setStaticFrameworkObjectIds() {
  PusServiceBase::PUS_DISTRIBUTOR = objects::PUS_PACKET_DISTRIBUTOR;
-  PusServiceBase::PACKET_DESTINATION = objects::TM_FUNNEL;
+  PusServiceBase::PACKET_DESTINATION = objects::PUS_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;
+  CommandingServiceBase::defaultPacketDestination = objects::PUS_TM_FUNNEL;

  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);
+
+  DummyGpioIF* dummyGpioIF = new DummyGpioIF();
+  auto* dummySwitcher = new DummyPowerSwitcher(objects::PCDU_HANDLER, 18, 0);
+  static_cast<void>(dummyGpioIF);
+#ifdef PLATFORM_UNIX
+  new SerialComIF(objects::UART_COM_IF);
+#if OBSW_ADD_PLOC_MPSOC == 1
+  std::string mpscoDev = "";
+  auto mpsocCookie = new UartCookie(objects::PLOC_MPSOC_HANDLER, mpscoDev, 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, dummyGpioIF),
+                       objects::PLOC_SUPERVISOR_HANDLER);
+#endif /* OBSW_ADD_PLOC_MPSOC == 1 */
+#if OBSW_ADD_PLOC_SUPERVISOR == 1
+  std::string plocSupvString = "/dev/ploc_supv";
+  auto supervisorCookie =
+      new SerialCookie(objects::PLOC_SUPERVISOR_HANDLER, plocSupvString, uart::PLOC_SUPV_BAUD,
+                       supv::MAX_PACKET_SIZE * 20, UartModes::NON_CANONICAL);
+  supervisorCookie->setNoFixedSizeReply();
+  auto supvHelper = new PlocSupvUartManager(objects::PLOC_SUPERVISOR_HELPER);
+  new PlocSupervisorHandler(objects::PLOC_SUPERVISOR_HANDLER, supervisorCookie,
+                            Gpio(gpioIds::ENABLE_SUPV_UART, dummyGpioIF), pcdu::PDU1_CH6_PLOC_12V,
+                            *supvHelper);
+#endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
+#endif

  dummy::DummyCfg cfg;
-  dummy::createDummies(cfg);
-  new TemperatureSensorsDummy();
-  new SusDummy();
-  new ThermalController(objects::THERMAL_CONTROLLER, objects::NO_OBJECT);
+  dummy::createDummies(cfg, *dummySwitcher);
+  new ThermalController(objects::THERMAL_CONTROLLER);
  new TestTask(objects::TEST_TASK);
 }
--- 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/translateEvents.cpp
+++ b/bsp_hosted/fsfwconfig/events/translateEvents.cpp
@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 83 translations.
+ * @brief    Auto-generated event translation file. Contains 239 translations.
 * @details
- * Generated on: 2021-05-17 19:49:55
+ * Generated on: 2022-11-16 15:25:08
 */
 #include "translateEvents.h"

@ -34,6 +34,7 @@ const char *DEVICE_UNREQUESTED_REPLY_STRING = "DEVICE_UNREQUESTED_REPLY";
 const char *INVALID_DEVICE_COMMAND_STRING = "INVALID_DEVICE_COMMAND";
 const char *MONITORING_LIMIT_EXCEEDED_STRING = "MONITORING_LIMIT_EXCEEDED";
 const char *MONITORING_AMBIGUOUS_STRING = "MONITORING_AMBIGUOUS";
+const char *DEVICE_WANTS_HARD_REBOOT_STRING = "DEVICE_WANTS_HARD_REBOOT";
 const char *FUSE_CURRENT_HIGH_STRING = "FUSE_CURRENT_HIGH";
 const char *FUSE_WENT_OFF_STRING = "FUSE_WENT_OFF";
 const char *POWER_ABOVE_HIGH_LIMIT_STRING = "POWER_ABOVE_HIGH_LIMIT";
@ -59,7 +60,6 @@ const char *MONITOR_CHANGED_STATE_STRING = "MONITOR_CHANGED_STATE";
 const char *VALUE_BELOW_LOW_LIMIT_STRING = "VALUE_BELOW_LOW_LIMIT";
 const char *VALUE_ABOVE_HIGH_LIMIT_STRING = "VALUE_ABOVE_HIGH_LIMIT";
 const char *VALUE_OUT_OF_RANGE_STRING = "VALUE_OUT_OF_RANGE";
-const char *SWITCHING_TM_FAILED_STRING = "SWITCHING_TM_FAILED";
 const char *CHANGING_MODE_STRING = "CHANGING_MODE";
 const char *MODE_INFO_STRING = "MODE_INFO";
 const char *FALLBACK_FAILED_STRING = "FALLBACK_FAILED";
@ -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";
@ -82,15 +83,166 @@ const char *BIT_LOCK_LOST_STRING = "BIT_LOCK_LOST";
 const char *FRAME_PROCESSING_FAILED_STRING = "FRAME_PROCESSING_FAILED";
 const char *CLOCK_SET_STRING = "CLOCK_SET";
 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";
+const char *FDIR_REACTION_IGNORED_STRING = "FDIR_REACTION_IGNORED";
+const char *GPIO_PULL_HIGH_FAILED_STRING = "GPIO_PULL_HIGH_FAILED";
+const char *GPIO_PULL_LOW_FAILED_STRING = "GPIO_PULL_LOW_FAILED";
+const char *HEATER_WENT_ON_STRING = "HEATER_WENT_ON";
+const char *HEATER_WENT_OFF_STRING = "HEATER_WENT_OFF";
+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 *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";
-const char *CRC_FAILURE_EVENT_STRING = "CRC_FAILURE_EVENT";
+const char *MPSOC_HANDLER_CRC_FAILURE_STRING = "MPSOC_HANDLER_CRC_FAILURE";
+const char *MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH_STRING = "MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH";
+const char *MPSOC_SHUTDOWN_FAILED_STRING = "MPSOC_SHUTDOWN_FAILED";
+const char *SELF_TEST_I2C_FAILURE_STRING = "SELF_TEST_I2C_FAILURE";
+const char *SELF_TEST_SPI_FAILURE_STRING = "SELF_TEST_SPI_FAILURE";
+const char *SELF_TEST_ADC_FAILURE_STRING = "SELF_TEST_ADC_FAILURE";
+const char *SELF_TEST_PWM_FAILURE_STRING = "SELF_TEST_PWM_FAILURE";
+const char *SELF_TEST_TC_FAILURE_STRING = "SELF_TEST_TC_FAILURE";
+const char *SELF_TEST_MTM_RANGE_FAILURE_STRING = "SELF_TEST_MTM_RANGE_FAILURE";
+const char *SELF_TEST_COIL_CURRENT_FAILURE_STRING = "SELF_TEST_COIL_CURRENT_FAILURE";
+const char *INVALID_ERROR_BYTE_STRING = "INVALID_ERROR_BYTE";
+const char *ERROR_STATE_STRING = "ERROR_STATE";
+const char *RESET_OCCURED_STRING = "RESET_OCCURED";
+const char *BOOTING_FIRMWARE_FAILED_STRING = "BOOTING_FIRMWARE_FAILED";
+const char *BOOTING_BOOTLOADER_FAILED_STRING = "BOOTING_BOOTLOADER_FAILED";
+const char *SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING = "SUPV_MEMORY_READ_RPT_CRC_FAILURE";
+const char *SUPV_UNKNOWN_TM_STRING = "SUPV_UNKNOWN_TM";
+const char *SUPV_UNINIMPLEMENTED_TM_STRING = "SUPV_UNINIMPLEMENTED_TM";
+const char *SUPV_ACK_FAILURE_STRING = "SUPV_ACK_FAILURE";
+const char *SUPV_EXE_FAILURE_STRING = "SUPV_EXE_FAILURE";
+const char *SUPV_CRC_FAILURE_EVENT_STRING = "SUPV_CRC_FAILURE_EVENT";
+const char *SUPV_HELPER_EXECUTING_STRING = "SUPV_HELPER_EXECUTING";
+const char *SUPV_MPSOC_SHUWDOWN_BUILD_FAILED_STRING = "SUPV_MPSOC_SHUWDOWN_BUILD_FAILED";
+const char *SANITIZATION_FAILED_STRING = "SANITIZATION_FAILED";
+const char *MOUNTED_SD_CARD_STRING = "MOUNTED_SD_CARD";
+const char *SEND_MRAM_DUMP_FAILED_STRING = "SEND_MRAM_DUMP_FAILED";
+const char *MRAM_DUMP_FAILED_STRING = "MRAM_DUMP_FAILED";
+const char *MRAM_DUMP_FINISHED_STRING = "MRAM_DUMP_FINISHED";
+const char *INVALID_TC_FRAME_STRING = "INVALID_TC_FRAME";
+const char *INVALID_FAR_STRING = "INVALID_FAR";
+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";
+const char *IMAGE_DOWNLOAD_SUCCESSFUL_STRING = "IMAGE_DOWNLOAD_SUCCESSFUL";
+const char *FLASH_WRITE_SUCCESSFUL_STRING = "FLASH_WRITE_SUCCESSFUL";
+const char *FLASH_READ_SUCCESSFUL_STRING = "FLASH_READ_SUCCESSFUL";
+const char *FLASH_READ_FAILED_STRING = "FLASH_READ_FAILED";
+const char *FIRMWARE_UPDATE_SUCCESSFUL_STRING = "FIRMWARE_UPDATE_SUCCESSFUL";
+const char *FIRMWARE_UPDATE_FAILED_STRING = "FIRMWARE_UPDATE_FAILED";
+const char *STR_HELPER_READING_REPLY_FAILED_STRING = "STR_HELPER_READING_REPLY_FAILED";
+const char *STR_HELPER_COM_ERROR_STRING = "STR_HELPER_COM_ERROR";
+const char *STR_HELPER_NO_REPLY_STRING = "STR_HELPER_NO_REPLY";
+const char *STR_HELPER_DEC_ERROR_STRING = "STR_HELPER_DEC_ERROR";
+const char *POSITION_MISMATCH_STRING = "POSITION_MISMATCH";
+const char *STR_HELPER_FILE_NOT_EXISTS_STRING = "STR_HELPER_FILE_NOT_EXISTS";
+const char *STR_HELPER_SENDING_PACKET_FAILED_STRING = "STR_HELPER_SENDING_PACKET_FAILED";
+const char *STR_HELPER_REQUESTING_MSG_FAILED_STRING = "STR_HELPER_REQUESTING_MSG_FAILED";
+const char *MPSOC_FLASH_WRITE_FAILED_STRING = "MPSOC_FLASH_WRITE_FAILED";
+const char *MPSOC_FLASH_WRITE_SUCCESSFUL_STRING = "MPSOC_FLASH_WRITE_SUCCESSFUL";
+const char *MPSOC_SENDING_COMMAND_FAILED_STRING = "MPSOC_SENDING_COMMAND_FAILED";
+const char *MPSOC_HELPER_REQUESTING_REPLY_FAILED_STRING = "MPSOC_HELPER_REQUESTING_REPLY_FAILED";
+const char *MPSOC_HELPER_READING_REPLY_FAILED_STRING = "MPSOC_HELPER_READING_REPLY_FAILED";
+const char *MPSOC_MISSING_ACK_STRING = "MPSOC_MISSING_ACK";
+const char *MPSOC_MISSING_EXE_STRING = "MPSOC_MISSING_EXE";
+const char *MPSOC_ACK_FAILURE_REPORT_STRING = "MPSOC_ACK_FAILURE_REPORT";
+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";
+const char *I_DRO_OUT_OF_BOUNDS_STRING = "I_DRO_OUT_OF_BOUNDS";
+const char *U_X8_OUT_OF_BOUNDS_STRING = "U_X8_OUT_OF_BOUNDS";
+const char *I_X8_OUT_OF_BOUNDS_STRING = "I_X8_OUT_OF_BOUNDS";
+const char *U_TX_OUT_OF_BOUNDS_STRING = "U_TX_OUT_OF_BOUNDS";
+const char *I_TX_OUT_OF_BOUNDS_STRING = "I_TX_OUT_OF_BOUNDS";
+const char *U_MPA_OUT_OF_BOUNDS_STRING = "U_MPA_OUT_OF_BOUNDS";
+const char *I_MPA_OUT_OF_BOUNDS_STRING = "I_MPA_OUT_OF_BOUNDS";
+const char *U_HPA_OUT_OF_BOUNDS_STRING = "U_HPA_OUT_OF_BOUNDS";
+const char *I_HPA_OUT_OF_BOUNDS_STRING = "I_HPA_OUT_OF_BOUNDS";
+const char *TRANSITION_OTHER_SIDE_FAILED_STRING = "TRANSITION_OTHER_SIDE_FAILED";
+const char *NOT_ENOUGH_DEVICES_DUAL_MODE_STRING = "NOT_ENOUGH_DEVICES_DUAL_MODE";
+const char *POWER_STATE_MACHINE_TIMEOUT_STRING = "POWER_STATE_MACHINE_TIMEOUT";
+const char *SIDE_SWITCH_TRANSITION_NOT_ALLOWED_STRING = "SIDE_SWITCH_TRANSITION_NOT_ALLOWED";
+const char *CHILDREN_LOST_MODE_STRING = "CHILDREN_LOST_MODE";
+const char *GPS_FIX_CHANGE_STRING = "GPS_FIX_CHANGE";
+const char *P60_BOOT_COUNT_STRING = "P60_BOOT_COUNT";
+const char *BATT_MODE_STRING = "BATT_MODE";
+const char *BATT_MODE_CHANGED_STRING = "BATT_MODE_CHANGED";
+const char *SUPV_UPDATE_FAILED_STRING = "SUPV_UPDATE_FAILED";
+const char *SUPV_UPDATE_SUCCESSFUL_STRING = "SUPV_UPDATE_SUCCESSFUL";
+const char *SUPV_CONTINUE_UPDATE_FAILED_STRING = "SUPV_CONTINUE_UPDATE_FAILED";
+const char *SUPV_CONTINUE_UPDATE_SUCCESSFUL_STRING = "SUPV_CONTINUE_UPDATE_SUCCESSFUL";
+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";
+const char *SUPV_MISSING_ACK_STRING = "SUPV_MISSING_ACK";
+const char *SUPV_MISSING_EXE_STRING = "SUPV_MISSING_EXE";
+const char *SUPV_ACK_FAILURE_REPORT_STRING = "SUPV_ACK_FAILURE_REPORT";
+const char *SUPV_EXE_FAILURE_REPORT_STRING = "SUPV_EXE_FAILURE_REPORT";
+const char *SUPV_ACK_INVALID_APID_STRING = "SUPV_ACK_INVALID_APID";
+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 *HDLC_FRAME_REMOVAL_ERROR_STRING = "HDLC_FRAME_REMOVAL_ERROR";
+const char *HDLC_CRC_ERROR_STRING = "HDLC_CRC_ERROR";
+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)) {
+  switch ((event & 0xFFFF)) {
    case (2200):
      return STORE_SEND_WRITE_FAILED_STRING;
    case (2201):
@ -149,6 +301,8 @@ const char *translateEvents(Event event) {
      return MONITORING_LIMIT_EXCEEDED_STRING;
    case (2810):
      return MONITORING_AMBIGUOUS_STRING;
+    case (2811):
+      return DEVICE_WANTS_HARD_REBOOT_STRING;
    case (4201):
      return FUSE_CURRENT_HIGH_STRING;
    case (4202):
@ -199,8 +353,6 @@ const char *translateEvents(Event event) {
      return VALUE_ABOVE_HIGH_LIMIT_STRING;
    case (7204):
      return VALUE_OUT_OF_RANGE_STRING;
-    case (7301):
-      return SWITCHING_TM_FAILED_STRING;
    case (7400):
      return CHANGING_MODE_STRING;
    case (7401):
@ -231,6 +383,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):
@ -245,18 +399,320 @@ const char *translateEvents(Event event) {
      return CLOCK_SET_STRING;
    case (8901):
      return CLOCK_SET_FAILURE_STRING;
+    case (9100):
+      return TC_DELETION_FAILED_STRING;
    case (9700):
      return TEST_STRING;
    case (10600):
      return CHANGE_OF_SETUP_PARAMETER_STRING;
-    case (11101):
+    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):
+      return SWITCH_HAS_CHANGED_STRING;
+    case (11302):
+      return SWITCHING_Q7S_DENIED_STRING;
+    case (11303):
+      return FDIR_REACTION_IGNORED_STRING;
+    case (11400):
+      return GPIO_PULL_HIGH_FAILED_STRING;
+    case (11401):
+      return GPIO_PULL_LOW_FAILED_STRING;
+    case (11402):
+      return HEATER_WENT_ON_STRING;
+    case (11403):
+      return HEATER_WENT_OFF_STRING;
+    case (11404):
+      return SWITCH_ALREADY_ON_STRING;
+    case (11405):
+      return SWITCH_ALREADY_OFF_STRING;
+    case (11406):
+      return MAIN_SWITCH_TIMEOUT_STRING;
+    case (11407):
+      return FAULTY_HEATER_WAS_ON_STRING;
+    case (11500):
+      return BURN_PHASE_START_STRING;
+    case (11501):
+      return BURN_PHASE_DONE_STRING;
+    case (11502):
+      return MAIN_SWITCH_ON_TIMEOUT_STRING;
+    case (11503):
+      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 (11102):
+    case (11602):
      return ACK_FAILURE_STRING;
-    case (11103):
+    case (11603):
      return EXE_FAILURE_STRING;
-    case (11104):
-      return CRC_FAILURE_EVENT_STRING;
+    case (11604):
+      return MPSOC_HANDLER_CRC_FAILURE_STRING;
+    case (11605):
+      return MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH_STRING;
+    case (11606):
+      return MPSOC_SHUTDOWN_FAILED_STRING;
+    case (11701):
+      return SELF_TEST_I2C_FAILURE_STRING;
+    case (11702):
+      return SELF_TEST_SPI_FAILURE_STRING;
+    case (11703):
+      return SELF_TEST_ADC_FAILURE_STRING;
+    case (11704):
+      return SELF_TEST_PWM_FAILURE_STRING;
+    case (11705):
+      return SELF_TEST_TC_FAILURE_STRING;
+    case (11706):
+      return SELF_TEST_MTM_RANGE_FAILURE_STRING;
+    case (11707):
+      return SELF_TEST_COIL_CURRENT_FAILURE_STRING;
+    case (11708):
+      return INVALID_ERROR_BYTE_STRING;
+    case (11801):
+      return ERROR_STATE_STRING;
+    case (11802):
+      return RESET_OCCURED_STRING;
+    case (11901):
+      return BOOTING_FIRMWARE_FAILED_STRING;
+    case (11902):
+      return BOOTING_BOOTLOADER_FAILED_STRING;
+    case (12001):
+      return SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING;
+    case (12002):
+      return SUPV_UNKNOWN_TM_STRING;
+    case (12003):
+      return SUPV_UNINIMPLEMENTED_TM_STRING;
+    case (12004):
+      return SUPV_ACK_FAILURE_STRING;
+    case (12005):
+      return SUPV_EXE_FAILURE_STRING;
+    case (12006):
+      return SUPV_CRC_FAILURE_EVENT_STRING;
+    case (12007):
+      return SUPV_HELPER_EXECUTING_STRING;
+    case (12008):
+      return SUPV_MPSOC_SHUWDOWN_BUILD_FAILED_STRING;
+    case (12100):
+      return SANITIZATION_FAILED_STRING;
+    case (12101):
+      return MOUNTED_SD_CARD_STRING;
+    case (12300):
+      return SEND_MRAM_DUMP_FAILED_STRING;
+    case (12301):
+      return MRAM_DUMP_FAILED_STRING;
+    case (12302):
+      return MRAM_DUMP_FINISHED_STRING;
+    case (12401):
+      return INVALID_TC_FRAME_STRING;
+    case (12402):
+      return INVALID_FAR_STRING;
+    case (12403):
+      return CARRIER_LOCK_STRING;
+    case (12404):
+      return BIT_LOCK_PDEC_STRING;
+    case (12405):
+      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):
+      return IMAGE_DOWNLOAD_FAILED_STRING;
+    case (12502):
+      return IMAGE_UPLOAD_SUCCESSFUL_STRING;
+    case (12503):
+      return IMAGE_DOWNLOAD_SUCCESSFUL_STRING;
+    case (12504):
+      return FLASH_WRITE_SUCCESSFUL_STRING;
+    case (12505):
+      return FLASH_READ_SUCCESSFUL_STRING;
+    case (12506):
+      return FLASH_READ_FAILED_STRING;
+    case (12507):
+      return FIRMWARE_UPDATE_SUCCESSFUL_STRING;
+    case (12508):
+      return FIRMWARE_UPDATE_FAILED_STRING;
+    case (12509):
+      return STR_HELPER_READING_REPLY_FAILED_STRING;
+    case (12510):
+      return STR_HELPER_COM_ERROR_STRING;
+    case (12511):
+      return STR_HELPER_NO_REPLY_STRING;
+    case (12512):
+      return STR_HELPER_DEC_ERROR_STRING;
+    case (12513):
+      return POSITION_MISMATCH_STRING;
+    case (12514):
+      return STR_HELPER_FILE_NOT_EXISTS_STRING;
+    case (12515):
+      return STR_HELPER_SENDING_PACKET_FAILED_STRING;
+    case (12516):
+      return STR_HELPER_REQUESTING_MSG_FAILED_STRING;
+    case (12600):
+      return MPSOC_FLASH_WRITE_FAILED_STRING;
+    case (12601):
+      return MPSOC_FLASH_WRITE_SUCCESSFUL_STRING;
+    case (12602):
+      return MPSOC_SENDING_COMMAND_FAILED_STRING;
+    case (12603):
+      return MPSOC_HELPER_REQUESTING_REPLY_FAILED_STRING;
+    case (12604):
+      return MPSOC_HELPER_READING_REPLY_FAILED_STRING;
+    case (12605):
+      return MPSOC_MISSING_ACK_STRING;
+    case (12606):
+      return MPSOC_MISSING_EXE_STRING;
+    case (12607):
+      return MPSOC_ACK_FAILURE_REPORT_STRING;
+    case (12608):
+      return MPSOC_EXE_FAILURE_REPORT_STRING;
+    case (12609):
+      return MPSOC_ACK_INVALID_APID_STRING;
+    case (12610):
+      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):
+      return NEG_V_OUT_OF_BOUNDS_STRING;
+    case (12702):
+      return U_DRO_OUT_OF_BOUNDS_STRING;
+    case (12703):
+      return I_DRO_OUT_OF_BOUNDS_STRING;
+    case (12704):
+      return U_X8_OUT_OF_BOUNDS_STRING;
+    case (12705):
+      return I_X8_OUT_OF_BOUNDS_STRING;
+    case (12706):
+      return U_TX_OUT_OF_BOUNDS_STRING;
+    case (12707):
+      return I_TX_OUT_OF_BOUNDS_STRING;
+    case (12708):
+      return U_MPA_OUT_OF_BOUNDS_STRING;
+    case (12709):
+      return I_MPA_OUT_OF_BOUNDS_STRING;
+    case (12710):
+      return U_HPA_OUT_OF_BOUNDS_STRING;
+    case (12711):
+      return I_HPA_OUT_OF_BOUNDS_STRING;
+    case (12800):
+      return TRANSITION_OTHER_SIDE_FAILED_STRING;
+    case (12801):
+      return NOT_ENOUGH_DEVICES_DUAL_MODE_STRING;
+    case (12802):
+      return POWER_STATE_MACHINE_TIMEOUT_STRING;
+    case (12803):
+      return SIDE_SWITCH_TRANSITION_NOT_ALLOWED_STRING;
+    case (13000):
+      return CHILDREN_LOST_MODE_STRING;
+    case (13100):
+      return GPS_FIX_CHANGE_STRING;
+    case (13200):
+      return P60_BOOT_COUNT_STRING;
+    case (13201):
+      return BATT_MODE_STRING;
+    case (13202):
+      return BATT_MODE_CHANGED_STRING;
+    case (13600):
+      return SUPV_UPDATE_FAILED_STRING;
+    case (13601):
+      return SUPV_UPDATE_SUCCESSFUL_STRING;
+    case (13602):
+      return SUPV_CONTINUE_UPDATE_FAILED_STRING;
+    case (13603):
+      return SUPV_CONTINUE_UPDATE_SUCCESSFUL_STRING;
+    case (13604):
+      return TERMINATED_UPDATE_PROCEDURE_STRING;
+    case (13605):
+      return SUPV_EVENT_BUFFER_REQUEST_SUCCESSFUL_STRING;
+    case (13606):
+      return SUPV_EVENT_BUFFER_REQUEST_FAILED_STRING;
+    case (13607):
+      return SUPV_EVENT_BUFFER_REQUEST_TERMINATED_STRING;
+    case (13608):
+      return SUPV_MEM_CHECK_OK_STRING;
+    case (13609):
+      return SUPV_MEM_CHECK_FAIL_STRING;
+    case (13616):
+      return SUPV_SENDING_COMMAND_FAILED_STRING;
+    case (13617):
+      return SUPV_HELPER_REQUESTING_REPLY_FAILED_STRING;
+    case (13618):
+      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 (13631):
+      return HDLC_FRAME_REMOVAL_ERROR_STRING;
+    case (13632):
+      return HDLC_CRC_ERROR_STRING;
+    case (13700):
+      return ALLOC_FAILURE_STRING;
+    case (13701):
+      return REBOOT_SW_STRING;
+    case (13702):
+      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/bsp_hosted/fsfwconfig/events/translateEvents.h
+++ b/bsp_hosted/fsfwconfig/events/translateEvents.h
@ -1,8 +1,8 @@
 #ifndef FSFWCONFIG_EVENTS_TRANSLATEEVENTS_H_
 #define FSFWCONFIG_EVENTS_TRANSLATEEVENTS_H_

-#include <fsfw/events/Event.h>
+#include "fsfw/events/Event.h"

-const char* translateEvents(Event event);
+const char *translateEvents(Event event);

 #endif /* FSFWCONFIG_EVENTS_TRANSLATEEVENTS_H_ */
--- a/bsp_hosted/fsfwconfig/objects/systemObjectList.h
+++ b/bsp_hosted/fsfwconfig/objects/systemObjectList.h
@ -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/objects/translateObjects.cpp
+++ b/bsp_hosted/fsfwconfig/objects/translateObjects.cpp
@ -1,23 +1,105 @@
 /**
- * @brief	Auto-generated object translation file.
+ * @brief  Auto-generated object translation file.
 * @details
- * Contains 31 translations.
- * Generated on: 2021-05-17 19:12:49
+ * Contains 148 translations.
+ * Generated on: 2022-11-15 17:44:20
 */
 #include "translateObjects.h"

-#include "systemObjectList.h"
-
-const char *TEST_TASK_STRING = "TEST_TASK";
-const char *DUMMY_HANDLER_STRING = "DUMMY_HANDLER";
+const char *P60DOCK_TEST_TASK_STRING = "P60DOCK_TEST_TASK";
+const char *ACS_CONTROLLER_STRING = "ACS_CONTROLLER";
+const char *CORE_CONTROLLER_STRING = "CORE_CONTROLLER";
+const char *GLOBAL_JSON_CFG_STRING = "GLOBAL_JSON_CFG";
+const char *THERMAL_CONTROLLER_STRING = "THERMAL_CONTROLLER";
+const char *MGM_0_LIS3_HANDLER_STRING = "MGM_0_LIS3_HANDLER";
+const char *GYRO_0_ADIS_HANDLER_STRING = "GYRO_0_ADIS_HANDLER";
+const char *SUS_0_N_LOC_XFYFZM_PT_XF_STRING = "SUS_0_N_LOC_XFYFZM_PT_XF";
+const char *SUS_1_N_LOC_XBYFZM_PT_XB_STRING = "SUS_1_N_LOC_XBYFZM_PT_XB";
+const char *SUS_2_N_LOC_XFYBZB_PT_YB_STRING = "SUS_2_N_LOC_XFYBZB_PT_YB";
+const char *SUS_3_N_LOC_XFYBZF_PT_YF_STRING = "SUS_3_N_LOC_XFYBZF_PT_YF";
+const char *SUS_4_N_LOC_XMYFZF_PT_ZF_STRING = "SUS_4_N_LOC_XMYFZF_PT_ZF";
+const char *SUS_5_N_LOC_XFYMZB_PT_ZB_STRING = "SUS_5_N_LOC_XFYMZB_PT_ZB";
+const char *SUS_6_R_LOC_XFYBZM_PT_XF_STRING = "SUS_6_R_LOC_XFYBZM_PT_XF";
+const char *SUS_7_R_LOC_XBYBZM_PT_XB_STRING = "SUS_7_R_LOC_XBYBZM_PT_XB";
+const char *SUS_8_R_LOC_XBYBZB_PT_YB_STRING = "SUS_8_R_LOC_XBYBZB_PT_YB";
+const char *SUS_9_R_LOC_XBYBZB_PT_YF_STRING = "SUS_9_R_LOC_XBYBZB_PT_YF";
+const char *SUS_10_N_LOC_XMYBZF_PT_ZF_STRING = "SUS_10_N_LOC_XMYBZF_PT_ZF";
+const char *SUS_11_R_LOC_XBYMZB_PT_ZB_STRING = "SUS_11_R_LOC_XBYMZB_PT_ZB";
+const char *RW1_STRING = "RW1";
+const char *MGM_1_RM3100_HANDLER_STRING = "MGM_1_RM3100_HANDLER";
+const char *GYRO_1_L3G_HANDLER_STRING = "GYRO_1_L3G_HANDLER";
+const char *RW2_STRING = "RW2";
+const char *MGM_2_LIS3_HANDLER_STRING = "MGM_2_LIS3_HANDLER";
+const char *GYRO_2_ADIS_HANDLER_STRING = "GYRO_2_ADIS_HANDLER";
+const char *RW3_STRING = "RW3";
+const char *MGM_3_RM3100_HANDLER_STRING = "MGM_3_RM3100_HANDLER";
+const char *GYRO_3_L3G_HANDLER_STRING = "GYRO_3_L3G_HANDLER";
+const char *RW4_STRING = "RW4";
+const char *STAR_TRACKER_STRING = "STAR_TRACKER";
+const char *GPS_CONTROLLER_STRING = "GPS_CONTROLLER";
+const char *IMTQ_HANDLER_STRING = "IMTQ_HANDLER";
+const char *PCDU_HANDLER_STRING = "PCDU_HANDLER";
+const char *P60DOCK_HANDLER_STRING = "P60DOCK_HANDLER";
+const char *PDU1_HANDLER_STRING = "PDU1_HANDLER";
+const char *PDU2_HANDLER_STRING = "PDU2_HANDLER";
+const char *ACU_HANDLER_STRING = "ACU_HANDLER";
+const char *BPX_BATT_HANDLER_STRING = "BPX_BATT_HANDLER";
+const char *PLPCDU_HANDLER_STRING = "PLPCDU_HANDLER";
+const char *RAD_SENSOR_STRING = "RAD_SENSOR";
+const char *PLOC_UPDATER_STRING = "PLOC_UPDATER";
+const char *PLOC_MEMORY_DUMPER_STRING = "PLOC_MEMORY_DUMPER";
+const char *STR_HELPER_STRING = "STR_HELPER";
+const char *PLOC_MPSOC_HELPER_STRING = "PLOC_MPSOC_HELPER";
+const char *AXI_PTME_CONFIG_STRING = "AXI_PTME_CONFIG";
+const char *PTME_CONFIG_STRING = "PTME_CONFIG";
+const char *PLOC_MPSOC_HANDLER_STRING = "PLOC_MPSOC_HANDLER";
+const char *PLOC_SUPERVISOR_HANDLER_STRING = "PLOC_SUPERVISOR_HANDLER";
+const char *PLOC_SUPERVISOR_HELPER_STRING = "PLOC_SUPERVISOR_HELPER";
+const char *SCEX_STRING = "SCEX";
+const char *SOLAR_ARRAY_DEPL_HANDLER_STRING = "SOLAR_ARRAY_DEPL_HANDLER";
+const char *HEATER_HANDLER_STRING = "HEATER_HANDLER";
+const char *TMP1075_HANDLER_TCS_0_STRING = "TMP1075_HANDLER_TCS_0";
+const char *TMP1075_HANDLER_TCS_1_STRING = "TMP1075_HANDLER_TCS_1";
+const char *TMP1075_HANDLER_PLPCDU_0_STRING = "TMP1075_HANDLER_PLPCDU_0";
+const char *TMP1075_HANDLER_PLPCDU_1_STRING = "TMP1075_HANDLER_PLPCDU_1";
+const char *TMP1075_HANDLER_IF_BOARD_STRING = "TMP1075_HANDLER_IF_BOARD";
+const char *TMP1075_HANDLER_OBC_IF_BOARD_STRING = "TMP1075_HANDLER_OBC_IF_BOARD";
+const char *RTD_0_IC3_PLOC_HEATSPREADER_STRING = "RTD_0_IC3_PLOC_HEATSPREADER";
+const char *RTD_1_IC4_PLOC_MISSIONBOARD_STRING = "RTD_1_IC4_PLOC_MISSIONBOARD";
+const char *RTD_2_IC5_4K_CAMERA_STRING = "RTD_2_IC5_4K_CAMERA";
+const char *RTD_3_IC6_DAC_HEATSPREADER_STRING = "RTD_3_IC6_DAC_HEATSPREADER";
+const char *RTD_4_IC7_STARTRACKER_STRING = "RTD_4_IC7_STARTRACKER";
+const char *RTD_5_IC8_RW1_MX_MY_STRING = "RTD_5_IC8_RW1_MX_MY";
+const char *RTD_6_IC9_DRO_STRING = "RTD_6_IC9_DRO";
+const char *RTD_7_IC10_SCEX_STRING = "RTD_7_IC10_SCEX";
+const char *RTD_8_IC11_X8_STRING = "RTD_8_IC11_X8";
+const char *RTD_9_IC12_HPA_STRING = "RTD_9_IC12_HPA";
+const char *RTD_10_IC13_PL_TX_STRING = "RTD_10_IC13_PL_TX";
+const char *RTD_11_IC14_MPA_STRING = "RTD_11_IC14_MPA";
+const char *RTD_12_IC15_ACU_STRING = "RTD_12_IC15_ACU";
+const char *RTD_13_IC16_PLPCDU_HEATSPREADER_STRING = "RTD_13_IC16_PLPCDU_HEATSPREADER";
+const char *RTD_14_IC17_TCS_BOARD_STRING = "RTD_14_IC17_TCS_BOARD";
+const char *RTD_15_IC18_IMTQ_STRING = "RTD_15_IC18_IMTQ";
+const char *SYRLINKS_HK_HANDLER_STRING = "SYRLINKS_HK_HANDLER";
 const char *ARDUINO_COM_IF_STRING = "ARDUINO_COM_IF";
-const char *PUS_SERVICE_3_STRING = "PUS_SERVICE_3";
-const char *PUS_SERVICE_5_STRING = "PUS_SERVICE_5";
+const char *GPIO_IF_STRING = "GPIO_IF";
+const char *SCEX_UART_READER_STRING = "SCEX_UART_READER";
+const char *SPI_MAIN_COM_IF_STRING = "SPI_MAIN_COM_IF";
+const char *SPI_RW_COM_IF_STRING = "SPI_RW_COM_IF";
+const char *SPI_RTD_COM_IF_STRING = "SPI_RTD_COM_IF";
+const char *UART_COM_IF_STRING = "UART_COM_IF";
+const char *I2C_COM_IF_STRING = "I2C_COM_IF";
+const char *CSP_COM_IF_STRING = "CSP_COM_IF";
+const char *CCSDS_PACKET_DISTRIBUTOR_STRING = "CCSDS_PACKET_DISTRIBUTOR";
+const char *PUS_PACKET_DISTRIBUTOR_STRING = "PUS_PACKET_DISTRIBUTOR";
+const char *TMTC_BRIDGE_STRING = "TMTC_BRIDGE";
+const char *TMTC_POLLING_TASK_STRING = "TMTC_POLLING_TASK";
+const char *FILE_SYSTEM_HANDLER_STRING = "FILE_SYSTEM_HANDLER";
+const char *SDC_MANAGER_STRING = "SDC_MANAGER";
+const char *PTME_STRING = "PTME";
+const char *PDEC_HANDLER_STRING = "PDEC_HANDLER";
+const char *CCSDS_HANDLER_STRING = "CCSDS_HANDLER";
 const char *PUS_SERVICE_6_STRING = "PUS_SERVICE_6";
-const char *PUS_SERVICE_8_STRING = "PUS_SERVICE_8";
-const char *PUS_SERVICE_23_STRING = "PUS_SERVICE_23";
-const char *PUS_SERVICE_201_STRING = "PUS_SERVICE_201";
-const char *TM_FUNNEL_STRING = "TM_FUNNEL";
 const char *FSFW_OBJECTS_START_STRING = "FSFW_OBJECTS_START";
 const char *PUS_SERVICE_1_VERIFICATION_STRING = "PUS_SERVICE_1_VERIFICATION";
 const char *PUS_SERVICE_2_DEVICE_ACCESS_STRING = "PUS_SERVICE_2_DEVICE_ACCESS";
@ -25,9 +107,12 @@ const char *PUS_SERVICE_3_HOUSEKEEPING_STRING = "PUS_SERVICE_3_HOUSEKEEPING";
 const char *PUS_SERVICE_5_EVENT_REPORTING_STRING = "PUS_SERVICE_5_EVENT_REPORTING";
 const char *PUS_SERVICE_8_FUNCTION_MGMT_STRING = "PUS_SERVICE_8_FUNCTION_MGMT";
 const char *PUS_SERVICE_9_TIME_MGMT_STRING = "PUS_SERVICE_9_TIME_MGMT";
+const char *PUS_SERVICE_11_TC_SCHEDULER_STRING = "PUS_SERVICE_11_TC_SCHEDULER";
 const char *PUS_SERVICE_17_TEST_STRING = "PUS_SERVICE_17_TEST";
 const char *PUS_SERVICE_20_PARAMETERS_STRING = "PUS_SERVICE_20_PARAMETERS";
 const char *PUS_SERVICE_200_MODE_MGMT_STRING = "PUS_SERVICE_200_MODE_MGMT";
+const char *PUS_SERVICE_201_HEALTH_STRING = "PUS_SERVICE_201_HEALTH";
+const char *CFDP_PACKET_DISTRIBUTOR_STRING = "CFDP_PACKET_DISTRIBUTOR";
 const char *HEALTH_TABLE_STRING = "HEALTH_TABLE";
 const char *MODE_STORE_STRING = "MODE_STORE";
 const char *EVENT_MANAGER_STRING = "EVENT_MANAGER";
@ -36,33 +121,230 @@ const char *TC_STORE_STRING = "TC_STORE";
 const char *TM_STORE_STRING = "TM_STORE";
 const char *IPC_STORE_STRING = "IPC_STORE";
 const char *TIME_STAMPER_STRING = "TIME_STAMPER";
+const char *VERIFICATION_REPORTER_STRING = "VERIFICATION_REPORTER";
 const char *FSFW_OBJECTS_END_STRING = "FSFW_OBJECTS_END";
+const char *SPI_TEST_STRING = "SPI_TEST";
+const char *UART_TEST_STRING = "UART_TEST";
+const char *I2C_TEST_STRING = "I2C_TEST";
+const char *DUMMY_COM_IF_STRING = "DUMMY_COM_IF";
+const char *DUMMY_HANDLER_STRING = "DUMMY_HANDLER";
 const char *DUMMY_INTERFACE_STRING = "DUMMY_INTERFACE";
-const char *THERMAL_CONTROLLER_STRING = "THERMAL_CONTROLLER";
+const char *LIBGPIOD_TEST_STRING = "LIBGPIOD_TEST";
+const char *TEST_TASK_STRING = "TEST_TASK";
+const char *HEATER_0_PLOC_PROC_BRD_STRING = "HEATER_0_PLOC_PROC_BRD";
+const char *HEATER_1_PCDU_BRD_STRING = "HEATER_1_PCDU_BRD";
+const char *HEATER_2_ACS_BRD_STRING = "HEATER_2_ACS_BRD";
+const char *HEATER_3_OBC_BRD_STRING = "HEATER_3_OBC_BRD";
+const char *HEATER_4_CAMERA_STRING = "HEATER_4_CAMERA";
+const char *HEATER_5_STR_STRING = "HEATER_5_STR";
+const char *HEATER_6_DRO_STRING = "HEATER_6_DRO";
+const char *HEATER_7_HPA_STRING = "HEATER_7_HPA";
+const char *ACS_BOARD_ASS_STRING = "ACS_BOARD_ASS";
+const char *SUS_BOARD_ASS_STRING = "SUS_BOARD_ASS";
+const char *TCS_BOARD_ASS_STRING = "TCS_BOARD_ASS";
+const char *RW_ASS_STRING = "RW_ASS";
+const char *CAM_SWITCHER_STRING = "CAM_SWITCHER";
+const char *TM_FUNNEL_STRING = "TM_FUNNEL";
+const char *PUS_TM_FUNNEL_STRING = "PUS_TM_FUNNEL";
+const char *CFDP_TM_FUNNEL_STRING = "CFDP_TM_FUNNEL";
+const char *CFDP_HANDLER_STRING = "CFDP_HANDLER";
+const char *CFDP_DISTRIBUTOR_STRING = "CFDP_DISTRIBUTOR";
+const char *EIVE_SYSTEM_STRING = "EIVE_SYSTEM";
+const char *ACS_SUBSYSTEM_STRING = "ACS_SUBSYSTEM";
+const char *PL_SUBSYSTEM_STRING = "PL_SUBSYSTEM";
+const char *CCSDS_IP_CORE_BRIDGE_STRING = "CCSDS_IP_CORE_BRIDGE";
 const char *NO_OBJECT_STRING = "NO_OBJECT";

 const char *translateObject(object_id_t object) {
  switch ((object & 0xFFFFFFFF)) {
-    case 0x42694269:
-      return TEST_TASK_STRING;
-    case 0x4400AFFE:
-      return DUMMY_HANDLER_STRING;
-    case 0x49000001:
+    case 0x00005060:
+      return P60DOCK_TEST_TASK_STRING;
+    case 0x43000002:
+      return ACS_CONTROLLER_STRING;
+    case 0x43000003:
+      return CORE_CONTROLLER_STRING;
+    case 0x43000006:
+      return GLOBAL_JSON_CFG_STRING;
+    case 0x43400001:
+      return THERMAL_CONTROLLER_STRING;
+    case 0x44120006:
+      return MGM_0_LIS3_HANDLER_STRING;
+    case 0x44120010:
+      return GYRO_0_ADIS_HANDLER_STRING;
+    case 0x44120032:
+      return SUS_0_N_LOC_XFYFZM_PT_XF_STRING;
+    case 0x44120033:
+      return SUS_1_N_LOC_XBYFZM_PT_XB_STRING;
+    case 0x44120034:
+      return SUS_2_N_LOC_XFYBZB_PT_YB_STRING;
+    case 0x44120035:
+      return SUS_3_N_LOC_XFYBZF_PT_YF_STRING;
+    case 0x44120036:
+      return SUS_4_N_LOC_XMYFZF_PT_ZF_STRING;
+    case 0x44120037:
+      return SUS_5_N_LOC_XFYMZB_PT_ZB_STRING;
+    case 0x44120038:
+      return SUS_6_R_LOC_XFYBZM_PT_XF_STRING;
+    case 0x44120039:
+      return SUS_7_R_LOC_XBYBZM_PT_XB_STRING;
+    case 0x44120040:
+      return SUS_8_R_LOC_XBYBZB_PT_YB_STRING;
+    case 0x44120041:
+      return SUS_9_R_LOC_XBYBZB_PT_YF_STRING;
+    case 0x44120042:
+      return SUS_10_N_LOC_XMYBZF_PT_ZF_STRING;
+    case 0x44120043:
+      return SUS_11_R_LOC_XBYMZB_PT_ZB_STRING;
+    case 0x44120047:
+      return RW1_STRING;
+    case 0x44120107:
+      return MGM_1_RM3100_HANDLER_STRING;
+    case 0x44120111:
+      return GYRO_1_L3G_HANDLER_STRING;
+    case 0x44120148:
+      return RW2_STRING;
+    case 0x44120208:
+      return MGM_2_LIS3_HANDLER_STRING;
+    case 0x44120212:
+      return GYRO_2_ADIS_HANDLER_STRING;
+    case 0x44120249:
+      return RW3_STRING;
+    case 0x44120309:
+      return MGM_3_RM3100_HANDLER_STRING;
+    case 0x44120313:
+      return GYRO_3_L3G_HANDLER_STRING;
+    case 0x44120350:
+      return RW4_STRING;
+    case 0x44130001:
+      return STAR_TRACKER_STRING;
+    case 0x44130045:
+      return GPS_CONTROLLER_STRING;
+    case 0x44140014:
+      return IMTQ_HANDLER_STRING;
+    case 0x442000A1:
+      return PCDU_HANDLER_STRING;
+    case 0x44250000:
+      return P60DOCK_HANDLER_STRING;
+    case 0x44250001:
+      return PDU1_HANDLER_STRING;
+    case 0x44250002:
+      return PDU2_HANDLER_STRING;
+    case 0x44250003:
+      return ACU_HANDLER_STRING;
+    case 0x44260000:
+      return BPX_BATT_HANDLER_STRING;
+    case 0x44300000:
+      return PLPCDU_HANDLER_STRING;
+    case 0x443200A5:
+      return RAD_SENSOR_STRING;
+    case 0x44330000:
+      return PLOC_UPDATER_STRING;
+    case 0x44330001:
+      return PLOC_MEMORY_DUMPER_STRING;
+    case 0x44330002:
+      return STR_HELPER_STRING;
+    case 0x44330003:
+      return PLOC_MPSOC_HELPER_STRING;
+    case 0x44330004:
+      return AXI_PTME_CONFIG_STRING;
+    case 0x44330005:
+      return PTME_CONFIG_STRING;
+    case 0x44330015:
+      return PLOC_MPSOC_HANDLER_STRING;
+    case 0x44330016:
+      return PLOC_SUPERVISOR_HANDLER_STRING;
+    case 0x44330017:
+      return PLOC_SUPERVISOR_HELPER_STRING;
+    case 0x44330032:
+      return SCEX_STRING;
+    case 0x444100A2:
+      return SOLAR_ARRAY_DEPL_HANDLER_STRING;
+    case 0x444100A4:
+      return HEATER_HANDLER_STRING;
+    case 0x44420004:
+      return TMP1075_HANDLER_TCS_0_STRING;
+    case 0x44420005:
+      return TMP1075_HANDLER_TCS_1_STRING;
+    case 0x44420006:
+      return TMP1075_HANDLER_PLPCDU_0_STRING;
+    case 0x44420007:
+      return TMP1075_HANDLER_PLPCDU_1_STRING;
+    case 0x44420008:
+      return TMP1075_HANDLER_IF_BOARD_STRING;
+    case 0x44420009:
+      return TMP1075_HANDLER_OBC_IF_BOARD_STRING;
+    case 0x44420016:
+      return RTD_0_IC3_PLOC_HEATSPREADER_STRING;
+    case 0x44420017:
+      return RTD_1_IC4_PLOC_MISSIONBOARD_STRING;
+    case 0x44420018:
+      return RTD_2_IC5_4K_CAMERA_STRING;
+    case 0x44420019:
+      return RTD_3_IC6_DAC_HEATSPREADER_STRING;
+    case 0x44420020:
+      return RTD_4_IC7_STARTRACKER_STRING;
+    case 0x44420021:
+      return RTD_5_IC8_RW1_MX_MY_STRING;
+    case 0x44420022:
+      return RTD_6_IC9_DRO_STRING;
+    case 0x44420023:
+      return RTD_7_IC10_SCEX_STRING;
+    case 0x44420024:
+      return RTD_8_IC11_X8_STRING;
+    case 0x44420025:
+      return RTD_9_IC12_HPA_STRING;
+    case 0x44420026:
+      return RTD_10_IC13_PL_TX_STRING;
+    case 0x44420027:
+      return RTD_11_IC14_MPA_STRING;
+    case 0x44420028:
+      return RTD_12_IC15_ACU_STRING;
+    case 0x44420029:
+      return RTD_13_IC16_PLPCDU_HEATSPREADER_STRING;
+    case 0x44420030:
+      return RTD_14_IC17_TCS_BOARD_STRING;
+    case 0x44420031:
+      return RTD_15_IC18_IMTQ_STRING;
+    case 0x445300A3:
+      return SYRLINKS_HK_HANDLER_STRING;
+    case 0x49000000:
      return ARDUINO_COM_IF_STRING;
-    case 0x51000300:
-      return PUS_SERVICE_3_STRING;
-    case 0x51000400:
-      return PUS_SERVICE_5_STRING;
+    case 0x49010005:
+      return GPIO_IF_STRING;
+    case 0x49010006:
+      return SCEX_UART_READER_STRING;
+    case 0x49020004:
+      return SPI_MAIN_COM_IF_STRING;
+    case 0x49020005:
+      return SPI_RW_COM_IF_STRING;
+    case 0x49020006:
+      return SPI_RTD_COM_IF_STRING;
+    case 0x49030003:
+      return UART_COM_IF_STRING;
+    case 0x49040002:
+      return I2C_COM_IF_STRING;
+    case 0x49050001:
+      return CSP_COM_IF_STRING;
+    case 0x50000100:
+      return CCSDS_PACKET_DISTRIBUTOR_STRING;
+    case 0x50000200:
+      return PUS_PACKET_DISTRIBUTOR_STRING;
+    case 0x50000300:
+      return TMTC_BRIDGE_STRING;
+    case 0x50000400:
+      return TMTC_POLLING_TASK_STRING;
+    case 0x50000500:
+      return FILE_SYSTEM_HANDLER_STRING;
+    case 0x50000550:
+      return SDC_MANAGER_STRING;
+    case 0x50000600:
+      return PTME_STRING;
+    case 0x50000700:
+      return PDEC_HANDLER_STRING;
+    case 0x50000800:
+      return CCSDS_HANDLER_STRING;
    case 0x51000500:
      return PUS_SERVICE_6_STRING;
-    case 0x51000800:
-      return PUS_SERVICE_8_STRING;
-    case 0x51002300:
-      return PUS_SERVICE_23_STRING;
-    case 0x51020100:
-      return PUS_SERVICE_201_STRING;
-    case 0x52000002:
-      return TM_FUNNEL_STRING;
    case 0x53000000:
      return FSFW_OBJECTS_START_STRING;
    case 0x53000001:
@ -77,12 +359,18 @@ const char *translateObject(object_id_t object) {
      return PUS_SERVICE_8_FUNCTION_MGMT_STRING;
    case 0x53000009:
      return PUS_SERVICE_9_TIME_MGMT_STRING;
+    case 0x53000011:
+      return PUS_SERVICE_11_TC_SCHEDULER_STRING;
    case 0x53000017:
      return PUS_SERVICE_17_TEST_STRING;
    case 0x53000020:
      return PUS_SERVICE_20_PARAMETERS_STRING;
    case 0x53000200:
      return PUS_SERVICE_200_MODE_MGMT_STRING;
+    case 0x53000201:
+      return PUS_SERVICE_201_HEALTH_STRING;
+    case 0x53001000:
+      return CFDP_PACKET_DISTRIBUTOR_STRING;
    case 0x53010000:
      return HEALTH_TABLE_STRING;
    case 0x53010100:
@ -99,12 +387,70 @@ const char *translateObject(object_id_t object) {
      return IPC_STORE_STRING;
    case 0x53500010:
      return TIME_STAMPER_STRING;
+    case 0x53500020:
+      return VERIFICATION_REPORTER_STRING;
    case 0x53ffffff:
      return FSFW_OBJECTS_END_STRING;
-    case 0xCAFECAFE:
+    case 0x54000010:
+      return SPI_TEST_STRING;
+    case 0x54000020:
+      return UART_TEST_STRING;
+    case 0x54000030:
+      return I2C_TEST_STRING;
+    case 0x54000040:
+      return DUMMY_COM_IF_STRING;
+    case 0x5400AFFE:
+      return DUMMY_HANDLER_STRING;
+    case 0x5400CAFE:
      return DUMMY_INTERFACE_STRING;
-    case objects::THERMAL_CONTROLLER:
-      return THERMAL_CONTROLLER_STRING;
+    case 0x54123456:
+      return LIBGPIOD_TEST_STRING;
+    case 0x54694269:
+      return TEST_TASK_STRING;
+    case 0x60000000:
+      return HEATER_0_PLOC_PROC_BRD_STRING;
+    case 0x60000001:
+      return HEATER_1_PCDU_BRD_STRING;
+    case 0x60000002:
+      return HEATER_2_ACS_BRD_STRING;
+    case 0x60000003:
+      return HEATER_3_OBC_BRD_STRING;
+    case 0x60000004:
+      return HEATER_4_CAMERA_STRING;
+    case 0x60000005:
+      return HEATER_5_STR_STRING;
+    case 0x60000006:
+      return HEATER_6_DRO_STRING;
+    case 0x60000007:
+      return HEATER_7_HPA_STRING;
+    case 0x73000001:
+      return ACS_BOARD_ASS_STRING;
+    case 0x73000002:
+      return SUS_BOARD_ASS_STRING;
+    case 0x73000003:
+      return TCS_BOARD_ASS_STRING;
+    case 0x73000004:
+      return RW_ASS_STRING;
+    case 0x73000006:
+      return CAM_SWITCHER_STRING;
+    case 0x73000100:
+      return TM_FUNNEL_STRING;
+    case 0x73000101:
+      return PUS_TM_FUNNEL_STRING;
+    case 0x73000102:
+      return CFDP_TM_FUNNEL_STRING;
+    case 0x73000205:
+      return CFDP_HANDLER_STRING;
+    case 0x73000206:
+      return CFDP_DISTRIBUTOR_STRING;
+    case 0x73010000:
+      return EIVE_SYSTEM_STRING;
+    case 0x73010001:
+      return ACS_SUBSYSTEM_STRING;
+    case 0x73010002:
+      return PL_SUBSYSTEM_STRING;
+    case 0x73500000:
+      return CCSDS_IP_CORE_BRIDGE_STRING;
    case 0xFFFFFFFF:
      return NO_OBJECT_STRING;
    default:
--- a/bsp_hosted/fsfwconfig/objects/translateObjects.h
+++ b/bsp_hosted/fsfwconfig/objects/translateObjects.h
@ -3,6 +3,6 @@

 #include <fsfw/objectmanager/SystemObjectIF.h>

-const char* translateObject(object_id_t object);
+const char *translateObject(object_id_t object);

 #endif /* FSFWCONFIG_OBJECTS_TRANSLATEOBJECTS_H_ */
--- a/bsp_hosted/fsfwconfig/pollingsequence/DummyPst.cpp
+++ b/bsp_hosted/fsfwconfig/pollingsequence/DummyPst.cpp
@ -44,12 +44,11 @@ ReturnValue_t dummy_pst::pst(FixedTimeslotTaskIF *thisSequence) {
  thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::SEND_READ);
  thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::GET_READ);

-  thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0,
-                        DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0, DeviceHandlerIF::GET_READ);

  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
--- a/bsp_hosted/main.cpp
+++ b/bsp_hosted/main.cpp
@ -2,7 +2,6 @@

 #include <iostream>

-#include "InitMission.h"
 #include "commonConfig.h"
 #include "fsfw/FSFWVersion.h"
 #include "fsfw/controller/ControllerBase.h"
@ -11,6 +10,7 @@
 #include "fsfw/modes/ModeMessage.h"
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/tasks/TaskFactory.h"
+#include "scheduling.h"

 #ifdef WIN32
 static const char* COMPILE_PRINTOUT = "Windows";
@ -35,7 +35,7 @@ int main(void) {
            << " BSP HOSTED"
            << " --" << std::endl;

-  initmission::initMission();
+  scheduling::initMission();

  for (;;) {
    // suspend main thread by sleeping it.
--- a/bsp_hosted/InitMission.cpp
+++ b/bsp_hosted/InitMission.cpp
@ -1,6 +1,5 @@
-#include "InitMission.h"
+#include "linux/scheduling.h"

-#include <OBSWConfig.h>
 #include <bsp_hosted/fsfwconfig/pollingsequence/DummyPst.h>
 #include <fsfw/objectmanager/ObjectManager.h>
 #include <fsfw/objectmanager/ObjectManagerIF.h>
@ -13,7 +12,9 @@

 #include <iostream>

+#include "OBSWConfig.h"
 #include "ObjectFactory.h"
+#include "scheduling.h"

 #ifdef LINUX
 ServiceInterfaceStream sif::debug("DEBUG");
@ -29,7 +30,7 @@ ServiceInterfaceStream sif::error("ERROR", true, false, true);

 ObjectManagerIF* objectManager = nullptr;

-void initmission::initMission() {
+void scheduling::initMission() {
  sif::info << "Building global objects.." << std::endl;
  /* Instantiate global object manager and also create all objects */
  ObjectManager::instance()->setObjectFactoryFunction(ObjectFactory::produce, nullptr);
@ -40,7 +41,7 @@ void initmission::initMission() {
  initTasks();
 }

-void initmission::initTasks() {
+void scheduling::initTasks() {
  TaskFactory* factory = TaskFactory::instance();
  if (factory == nullptr) {
    /* Should never happen ! */
@ -53,31 +54,38 @@ void initmission::initTasks() {
 #endif

  /* TMTC Distribution */
-  PeriodicTaskIF* tmTcDistributor = factory->createPeriodicTask(
-      "DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
-  ReturnValue_t result = tmTcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
+  PeriodicTaskIF* tmtcDistributor = factory->createPeriodicTask(
+      "DIST", 45, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+  ReturnValue_t result = tmtcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
  if (result != returnvalue::OK) {
    sif::error << "Object add component failed" << std::endl;
  }
-  result = tmTcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
+  result = tmtcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
  if (result != returnvalue::OK) {
    sif::error << "Object add component failed" << std::endl;
  }
-  result = tmTcDistributor->addComponent(objects::TM_FUNNEL);
+  result = tmtcDistributor->addComponent(objects::TM_FUNNEL);
  if (result != returnvalue::OK) {
    sif::error << "Object add component failed" << std::endl;
  }
-
-  /* UDP bridge */
-  PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask(
-      "TMTC_UNIX_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
-  result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
+  result = tmtcDistributor->addComponent(objects::UDP_TMTC_SERVER);
  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);
+  result = tmtcDistributor->addComponent(objects::TCP_TMTC_SERVER);
+  if (result != returnvalue::OK) {
+    sif::error << "Add component UDP Unix Bridge failed" << std::endl;
+  }
+
+  PeriodicTaskIF* udpPollingTask = factory->createPeriodicTask(
+      "UDP_POLLING", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+  result = udpPollingTask->addComponent(objects::UDP_TMTC_POLLING_TASK);
+  if (result != returnvalue::OK) {
+    sif::error << "Add component UDP Polling failed" << std::endl;
+  }
+  PeriodicTaskIF* tcpPollingTask = factory->createPeriodicTask(
+      "TCP_POLLING", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+  result = tcpPollingTask->addComponent(objects::TCP_TMTC_POLLING_TASK);
  if (result != returnvalue::OK) {
    sif::error << "Add component UDP Polling failed" << std::endl;
  }
@ -94,69 +102,60 @@ void initmission::initTasks() {
      "EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
  result = eventHandling->addComponent(objects::EVENT_MANAGER);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("EVENT_MNGR", objects::EVENT_MANAGER);
+    scheduling::printAddObjectError("EVENT_MNGR", objects::EVENT_MANAGER);
  }
  result = eventHandling->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("PUS5", objects::PUS_SERVICE_5_EVENT_REPORTING);
+    scheduling::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 != returnvalue::OK) {
-    initmission::printAddObjectError("PUS2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
+    scheduling::printAddObjectError("PUS2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
  }
  result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT);
+    scheduling::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT);
  }
  result = pusHighPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("PUS3", objects::PUS_SERVICE_3_HOUSEKEEPING);
+    scheduling::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 != returnvalue::OK) {
-    initmission::printAddObjectError("PUS8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
+    scheduling::printAddObjectError("PUS8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
  }
  result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("PUS200", objects::PUS_SERVICE_200_MODE_MGMT);
+    scheduling::printAddObjectError("PUS200", objects::PUS_SERVICE_200_MODE_MGMT);
  }
  result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("PUS20", objects::PUS_SERVICE_20_PARAMETERS);
+    scheduling::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 != returnvalue::OK) {
-    initmission::printAddObjectError("PUS17", objects::PUS_SERVICE_17_TEST);
+    scheduling::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 != 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 != returnvalue::OK) {
-    initmission::printAddObjectError("SUS_0_dummy", objects::SUS_0_N_LOC_XFYFZM_PT_XF);
-  }
-
  result = thermalTask->addComponent(objects::CORE_CONTROLLER);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("Core controller dummy", objects::CORE_CONTROLLER);
+    scheduling::printAddObjectError("Core controller dummy", objects::CORE_CONTROLLER);
  }

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

  FixedTimeslotTaskIF* pstTask = factory->createFixedTimeslotTask(
@ -166,17 +165,60 @@ void initmission::initTasks() {
    sif::error << "Failed to add dummy pst to fixed timeslot task" << std::endl;
  }

+#if OBSW_ADD_PLOC_SUPERVISOR == 1
+  PeriodicTaskIF* supvHelperTask = factory->createPeriodicTask(
+      "PLOC_SUPV_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
+  result = supvHelperTask->addComponent(objects::PLOC_SUPERVISOR_HELPER);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("PLOC_SUPV_HELPER", objects::PLOC_SUPERVISOR_HELPER);
+  }
+#endif /* OBSW_ADD_PLOC_SUPERVISOR */
+
+  PeriodicTaskIF* plTask = factory->createPeriodicTask(
+      "PL_TASK", 25, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
+  scheduling::addMpsocSupvHandlers(plTask);
 #if OBSW_ADD_TEST_CODE == 1
  result = testTask->addComponent(objects::TEST_TASK);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("TEST_TASK", objects::TEST_TASK);
+    scheduling::printAddObjectError("TEST_TASK", objects::TEST_TASK);
  }
 #endif /* OBSW_ADD_TEST_CODE == 1 */

+  PeriodicTaskIF* dummyTask = factory->createPeriodicTask(
+      "DUMMY_TASK", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
+  dummyTask->addComponent(objects::SUS_0_N_LOC_XFYFZM_PT_XF);
+  dummyTask->addComponent(objects::SUS_1_N_LOC_XBYFZM_PT_XB);
+  dummyTask->addComponent(objects::SUS_2_N_LOC_XFYBZB_PT_YB);
+  dummyTask->addComponent(objects::SUS_3_N_LOC_XFYBZF_PT_YF);
+  dummyTask->addComponent(objects::SUS_4_N_LOC_XMYFZF_PT_ZF);
+  dummyTask->addComponent(objects::SUS_5_N_LOC_XFYMZB_PT_ZB);
+  dummyTask->addComponent(objects::SUS_6_R_LOC_XFYBZM_PT_XF);
+  dummyTask->addComponent(objects::SUS_7_R_LOC_XBYBZM_PT_XB);
+  dummyTask->addComponent(objects::SUS_8_R_LOC_XBYBZB_PT_YB);
+  dummyTask->addComponent(objects::SUS_9_R_LOC_XBYBZB_PT_YF);
+  dummyTask->addComponent(objects::SUS_10_N_LOC_XMYBZF_PT_ZF);
+  dummyTask->addComponent(objects::SUS_11_R_LOC_XBYMZB_PT_ZB);
+  dummyTask->addComponent(objects::RTD_0_IC3_PLOC_HEATSPREADER);
+  dummyTask->addComponent(objects::RTD_1_IC4_PLOC_MISSIONBOARD);
+  dummyTask->addComponent(objects::RTD_2_IC5_4K_CAMERA);
+  dummyTask->addComponent(objects::RTD_3_IC6_DAC_HEATSPREADER);
+  dummyTask->addComponent(objects::RTD_4_IC7_STARTRACKER);
+  dummyTask->addComponent(objects::RTD_5_IC8_RW1_MX_MY);
+  dummyTask->addComponent(objects::RTD_6_IC9_DRO);
+  dummyTask->addComponent(objects::RTD_7_IC10_SCEX);
+  dummyTask->addComponent(objects::RTD_8_IC11_X8);
+  dummyTask->addComponent(objects::RTD_9_IC12_HPA);
+  dummyTask->addComponent(objects::RTD_10_IC13_PL_TX);
+  dummyTask->addComponent(objects::RTD_11_IC14_MPA);
+  dummyTask->addComponent(objects::RTD_12_IC15_ACU);
+  dummyTask->addComponent(objects::RTD_13_IC16_PLPCDU_HEATSPREADER);
+  dummyTask->addComponent(objects::RTD_14_IC17_TCS_BOARD);
+  dummyTask->addComponent(objects::RTD_15_IC18_IMTQ);
+
  sif::info << "Starting tasks.." << std::endl;
-  tmTcDistributor->startTask();
-  tmtcBridgeTask->startTask();
-  tmtcPollingTask->startTask();
+  tmtcDistributor->startTask();
+  udpPollingTask->startTask();
+  tcpPollingTask->startTask();

  pusVerification->startTask();
  eventHandling->startTask();
@ -186,6 +228,13 @@ void initmission::initTasks() {

  pstTask->startTask();
  thermalTask->startTask();
+  dummyTask->startTask();
+#if OBSW_ADD_PLOC_SUPERVISOR == 1
+  supvHelperTask->startTask();
+#endif
+#if OBSW_ADD_PLOC_SUPERVISOR == 1 || OBSW_ADD_PLOC_MPSOC == 1
+  plTask->startTask();
+#endif

 #if OBSW_ADD_TEST_CODE == 1
  testTask->startTask();
--- a/bsp_hosted/scheduling.h
+++ b/bsp_hosted/scheduling.h
@ -0,0 +1,6 @@
+#pragma once
+
+namespace scheduling {
+void initMission();
+void initTasks();
+};  // namespace scheduling
--- a/bsp_linux_board/CMakeLists.txt
+++ b/bsp_linux_board/CMakeLists.txt
@ -3,3 +3,4 @@ target_sources(${OBSW_NAME} PUBLIC InitMission.cpp main.cpp gpioInit.cpp

 add_subdirectory(boardconfig)
 add_subdirectory(boardtest)
+add_subdirectory(fsfwconfig)
--- a/bsp_linux_board/OBSWConfig.h.in
+++ b/bsp_linux_board/OBSWConfig.h.in
@ -103,7 +103,7 @@
 /*******************************************************************/
 #cmakedefine EIVE_BUILD_GPSD_GPS_HANDLER

-#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_linux_board/ObjectFactory.cpp
+++ b/bsp_linux_board/ObjectFactory.cpp
@ -34,8 +34,8 @@
 #include "fsfw/osal/common/UdpTmTcBridge.h"
 #endif

-#include <fsfw_hal/linux/uart/UartComIF.h>
-#include <fsfw_hal/linux/uart/UartCookie.h>
+#include <fsfw_hal/linux/serial/SerialComIF.h>
+#include <fsfw_hal/linux/serial/SerialCookie.h>

 #include "fsfw_hal/common/gpio/GpioCookie.h"
 #include "fsfw_hal/devicehandlers/GyroL3GD20Handler.h"
@ -202,7 +202,7 @@ void ObjectFactory::createTestTasks() {
 #if OBSW_ADD_UART_TEST_CODE == 1
  new UartTestClass(objects::UART_TEST);
 #else
-  new UartComIF(objects::UART_COM_IF);
+  newSerialComIF(objects::UART_COM_IF);
 #endif

 #if RPI_LOOPBACK_TEST_GPIO == 1
--- a/bsp_q7s/OBSWConfig.h.in
+++ b/bsp_q7s/OBSWConfig.h.in
@ -14,34 +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_CTRL                           @OBSW_ADD_ACS_CTRL@
+#define OBSW_ADD_ACS_CTRL                           1
 #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
@ -56,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
@ -99,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
@ -113,6 +119,14 @@
 /*******************************************************************/
 /** CMake Defines                                                  */
 /*******************************************************************/
+
+// Use TCP instead of UDP for the TMTC bridge. This allows using the TMTC client locally
+// because UDP packets are not allowed in the VPN
+// This will cause the OBSW to initialize the TMTC bridge responsible for exchanging data with the
+// CCSDS IP Cores. 
+#define OBSW_ADD_TMTC_TCP_SERVER            1
+#define OBSW_ADD_TMTC_UDP_SERVER            1
+
 #cmakedefine EIVE_BUILD_GPSD_GPS_HANDLER

 #cmakedefine LIBGPS_VERSION_MAJOR @LIBGPS_VERSION_MAJOR@
--- a/bsp_q7s/boardconfig/busConf.h
+++ b/bsp_q7s/boardconfig/busConf.h
@ -3,24 +3,28 @@

 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";
+//! I2C bus using an I2C IP core in the programmable logic (PL)
+static constexpr char I2C_PL_EIVE[] = "/dev/i2c_pl";
+//! I2C bus using the I2C peripheral of the ARM processing system (PS)
+static constexpr char I2C_PS_EIVE[] = "/dev/i2c_ps";

 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_SCEX_DEV[] = "/dev/ttyS-SCEX";
+static constexpr char UART_PLOC_MPSOC_DEV[] = "/dev/ul_plmpsoc";
+static constexpr char UART_PLOC_SUPERVSIOR_DEV[] = "/dev/ploc_supv";
+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/boardtest/Q7STestTask.cpp
+++ b/bsp_q7s/boardtest/Q7STestTask.cpp
@ -75,8 +75,10 @@ ReturnValue_t Q7STestTask::performOneShotAction() {
  if (doTestProtHandler) {
    testProtHandler();
  }
-  FsOpCodes opCode = FsOpCodes::CREATE_EMPTY_FILE_IN_TMP;
-  testFileSystemHandlerDirect(opCode);
+  if (DO_TEST_FS_HANDLER) {
+    FsOpCodes opCode = FsOpCodes::CREATE_EMPTY_FILE_IN_TMP;
+    testFileSystemHandlerDirect(opCode);
+  }
  return TestTask::performOneShotAction();
 }

--- a/bsp_q7s/boardtest/Q7STestTask.h
+++ b/bsp_q7s/boardtest/Q7STestTask.h
@ -18,6 +18,7 @@ class Q7STestTask : public TestTask {
  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/rwSpiCallback.cpp
+++ b/bsp_q7s/callbacks/rwSpiCallback.cpp
@ -41,19 +41,19 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
  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 returnvalue::FAILED;
  }

  int fileDescriptor = 0;
  const std::string& dev = comIf->getSpiDev();
-  result = openSpi(dev, O_RDWR, gpioIF, gpioId, mutex, timeoutType, timeoutMs, fileDescriptor);
+  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 != returnvalue::OK) {
-    closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+    closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
    return result;
  }

@ -127,9 +127,9 @@ 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);
+  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;
      }
@ -233,7 +233,7 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen

  cookie->setTransferSize(decodedFrameLen);

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

  return result;
 }
--- a/bsp_q7s/core/CMakeLists.txt
+++ b/bsp_q7s/core/CMakeLists.txt
@ -1,4 +1,4 @@
-target_sources(${OBSW_NAME} PRIVATE CoreController.cpp InitMission.cpp
+target_sources(${OBSW_NAME} PRIVATE CoreController.cpp scheduling.cpp
                                    ObjectFactory.cpp)

-target_sources(${SIMPLE_OBSW_NAME} PRIVATE InitMission.cpp)
+target_sources(${SIMPLE_OBSW_NAME} PRIVATE scheduling.cpp)
--- a/bsp_q7s/core/CoreController.cpp
+++ b/bsp_q7s/core/CoreController.cpp
@ -3,16 +3,17 @@
 #include <fsfw/events/EventManager.h>
 #include <fsfw/filesystem/HasFileSystemIF.h>
 #include <fsfw/ipc/QueueFactory.h>
+#include <fsfw/tasks/TaskFactory.h>

-#include "OBSWConfig.h"
 #include "OBSWVersion.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 #include "fsfw/timemanager/Stopwatch.h"
 #include "fsfw/version.h"
 #include "watchdog/definitions.h"
-#if OBSW_USE_TMTC_TCP_BRIDGE == 0
+#if OBSW_ADD_TMTC_UDP_SERVER == 1
 #include "fsfw/osal/common/UdpTmTcBridge.h"
-#else
+#endif
+#if OBSW_ADD_TMTC_TCP_SERVER == 1
 #include "fsfw/osal/common/TcpTmTcServer.h"
 #endif
 #include <fcntl.h>
@ -31,10 +32,7 @@ xsc::Chip CoreController::CURRENT_CHIP = xsc::Chip::NO_CHIP;
 xsc::Copy CoreController::CURRENT_COPY = xsc::Copy::NO_COPY;

 CoreController::CoreController(object_id_t objectId)
-    : ExtendedControllerBase(objectId, objects::NO_OBJECT, 5),
-      opDivider5(5),
-      opDivider10(10),
-      hkSet(this) {
+    : ExtendedControllerBase(objectId, 5), opDivider5(5), opDivider10(10), hkSet(this) {
  ReturnValue_t result = returnvalue::OK;
  try {
    result = initWatchdogFifo();
@ -50,10 +48,7 @@ CoreController::CoreController(object_id_t objectId)
      sdcMan->setBlocking(false);
    }

-    result = initBootCopy();
-    if (result != returnvalue::OK) {
-      sif::warning << "CoreController::CoreController: Boot copy init" << std::endl;
-    }
+    getCurrentBootCopy(CURRENT_CHIP, CURRENT_COPY);
  } catch (const std::filesystem::filesystem_error &e) {
    sif::error << "CoreController::CoreController: Failed with exception " << e.what() << std::endl;
  }
@ -82,6 +77,12 @@ void CoreController::performControlOperation() {
  sdStateMachine();
  performMountedSdCardOperations();
  if (sdCardCheckCd.hasTimedOut()) {
+    if (shortSdCardCdCounter < 2) {
+      shortSdCardCdCounter++;
+    }
+    if (shortSdCardCdCounter == 2) {
+      sdCardCheckCd.setTimeout(DEFAULT_SD_CARD_CHECK_TIMEOUT);
+    }
    performSdCardCheck();
    sdCardCheckCd.resetTimer();
  }
@ -92,9 +93,9 @@ void CoreController::performControlOperation() {

 ReturnValue_t CoreController::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                      LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(core::TEMPERATURE, new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(core::PS_VOLTAGE, new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(core::PL_VOLTAGE, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(core::TEMPERATURE, &tempPoolEntry);
+  localDataPoolMap.emplace(core::PS_VOLTAGE, &psVoltageEntry);
+  localDataPoolMap.emplace(core::PL_VOLTAGE, &plVoltageEntry);
  poolManager.subscribeForRegularPeriodicPacket({hkSet.getSid(), false, 10.0});
  return returnvalue::OK;
 }
@ -172,8 +173,7 @@ ReturnValue_t CoreController::initializeAfterTaskCreation() {
  setenv("PATH", updatedEnvPath.c_str(), true);
  updateProtInfo();
  initPrint();
-  ExtendedControllerBase::initializeAfterTaskCreation();
-  return result;
+  return ExtendedControllerBase::initializeAfterTaskCreation();
 }

 ReturnValue_t CoreController::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
@ -794,7 +794,7 @@ ReturnValue_t CoreController::actionListDirectoryIntoFile(ActionId_t actionId,
  return returnvalue::OK;
 }

-ReturnValue_t CoreController::initBootCopy() {
+ReturnValue_t CoreController::initBootCopyFile() {
  if (not std::filesystem::exists(CURR_COPY_FILE)) {
    // This file is created by the systemd service eive-early-config so this should
    // not happen normally
@ -804,8 +804,6 @@ ReturnValue_t CoreController::initBootCopy() {
      utility::handleSystemError(result, "CoreController::initBootCopy");
    }
  }
-
-  getCurrentBootCopy(CURRENT_CHIP, CURRENT_COPY);
  return returnvalue::OK;
 }

@ -933,6 +931,9 @@ ReturnValue_t CoreController::actionReboot(const uint8_t *data, size_t size) {
 ReturnValue_t CoreController::gracefulShutdownTasks(xsc::Chip chip, xsc::Copy copy,
                                                    bool &protOpPerformed) {
  sdcMan->setBlocking(true);
+  sdcMan->markUnusable();
+  // Wait two seconds to ensure no one uses the SD cards
+  TaskFactory::delayTask(2000);
  // Attempt graceful shutdown by unmounting and switching off SD cards
  sdcMan->switchOffSdCard(sd::SdCard::SLOT_0);
  sdcMan->switchOffSdCard(sd::SdCard::SLOT_1);
@ -1230,31 +1231,35 @@ void CoreController::performWatchdogControlOperation() {
 }

 void CoreController::performMountedSdCardOperations() {
-  auto mountedSdCardOp = [&](bool &mntSwitch, sd::SdCard sdCard, std::string mntPoint) {
-    if (mntSwitch) {
-      bool sdCardMounted = sdcMan->isSdCardUsable(sdCard);
-      if (sdCardMounted and not performOneShotSdCardOpsSwitch) {
-        std::ostringstream path;
-        path << mntPoint << "/" << CONF_FOLDER;
-        if (not std::filesystem::exists(path.str())) {
-          std::filesystem::create_directory(path.str());
-        }
-        initVersionFile();
-        initClockFromTimeFile();
-        performRebootFileHandling(false);
-        performOneShotSdCardOpsSwitch = true;
+  auto mountedSdCardOp = [&](sd::SdCard sdCard, std::string mntPoint) {
+    if (not performOneShotSdCardOpsSwitch) {
+      std::ostringstream path;
+      path << mntPoint << "/" << CONF_FOLDER;
+      if (not std::filesystem::exists(path.str())) {
+        std::filesystem::create_directory(path.str());
      }
-      mntSwitch = false;
+      initVersionFile();
+      ReturnValue_t result = initBootCopyFile();
+      if (result != returnvalue::OK) {
+        sif::warning << "CoreController::CoreController: Boot copy init" << std::endl;
+      }
+      initClockFromTimeFile();
+      performRebootFileHandling(false);
    }
+    timeFileHandler();
  };
-  if (sdInfo.active == sd::SdCard::SLOT_1) {
-    mountedSdCardOp(sdInfo.mountSwitch.second, sd::SdCard::SLOT_1, config::SD_1_MOUNT_POINT);
-    mountedSdCardOp(sdInfo.mountSwitch.first, sd::SdCard::SLOT_0, config::SD_0_MOUNT_POINT);
-  } else {
-    mountedSdCardOp(sdInfo.mountSwitch.first, sd::SdCard::SLOT_0, config::SD_0_MOUNT_POINT);
-    mountedSdCardOp(sdInfo.mountSwitch.second, sd::SdCard::SLOT_1, config::SD_1_MOUNT_POINT);
+  bool someSdCardActive = false;
+  if (sdInfo.active == sd::SdCard::SLOT_0 and sdcMan->isSdCardUsable(sd::SdCard::SLOT_0)) {
+    mountedSdCardOp(sd::SdCard::SLOT_0, config::SD_0_MOUNT_POINT);
+    someSdCardActive = true;
+  }
+  if (sdInfo.active == sd::SdCard::SLOT_1 and sdcMan->isSdCardUsable(sd::SdCard::SLOT_1)) {
+    mountedSdCardOp(sd::SdCard::SLOT_1, config::SD_1_MOUNT_POINT);
+    someSdCardActive = true;
+  }
+  if (someSdCardActive) {
+    performOneShotSdCardOpsSwitch = true;
  }
-  timeFileHandler();
 }

 ReturnValue_t CoreController::performSdCardCheck() {
@ -1295,7 +1300,19 @@ ReturnValue_t CoreController::performSdCardCheck() {
  if (active.second == sd::SdState::MOUNTED) {
    sdCardCheck(sd::SdCard::SLOT_1);
  }
-
+#if OBSW_SD_CARD_MUST_BE_ON == 1
+  // This is FDIR. The core controller will attempt once to get some SD card working
+  bool someSdCardActive = false;
+  if ((sdInfo.active == sd::SdCard::SLOT_0 and sdcMan->isSdCardUsable(sd::SdCard::SLOT_0)) or
+      (sdInfo.active == sd::SdCard::SLOT_1 and sdcMan->isSdCardUsable(sd::SdCard::SLOT_1))) {
+    someSdCardActive = true;
+  }
+  if (not someSdCardActive and remountAttemptFlag) {
+    triggerEvent(NO_SD_CARD_ACTIVE);
+    initSdCardBlocking();
+    remountAttemptFlag = false;
+  }
+#endif
  return returnvalue::OK;
 }

@ -1306,7 +1323,7 @@ void CoreController::performRebootFileHandling(bool recreateFile) {
 #if OBSW_VERBOSE_LEVEL >= 1
    sif::info << "CoreController::performRebootFileHandling: Recreating reboot file" << std::endl;
 #endif
-    rebootFile.enabled = true;
+    rebootFile.enabled = false;
    rebootFile.img00Cnt = 0;
    rebootFile.img01Cnt = 0;
    rebootFile.img10Cnt = 0;
--- a/bsp_q7s/core/CoreController.h
+++ b/bsp_q7s/core/CoreController.h
@ -7,6 +7,7 @@
 #include <cstddef>

 #include "CoreDefinitions.h"
+#include "OBSWConfig.h"
 #include "bsp_q7s/fs/SdCardManager.h"
 #include "events/subsystemIdRanges.h"
 #include "fsfw/controller/ExtendedControllerBase.h"
@ -69,6 +70,9 @@ class CoreController : public ExtendedControllerBase {
  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;
@ -102,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();
@ -205,7 +212,9 @@ class CoreController : public ExtendedControllerBase {

  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
@ -217,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();
@ -230,7 +247,7 @@ class CoreController : public ExtendedControllerBase {
  ReturnValue_t initClockFromTimeFile();
  ReturnValue_t performSdCardCheck();
  ReturnValue_t timeFileHandler();
-  ReturnValue_t initBootCopy();
+  ReturnValue_t initBootCopyFile();
  ReturnValue_t initWatchdogFifo();
  ReturnValue_t initSdCardBlocking();
  bool startSdStateMachine(sd::SdCard targetActiveSd, SdCfgMode mode, MessageQueueId_t commander,
--- a/bsp_q7s/core/ObjectFactory.cpp
+++ b/bsp_q7s/core/ObjectFactory.cpp
@ -1,6 +1,7 @@
 #include "ObjectFactory.h"

-#include <linux/devices/ScexUartReader.h>
+#include <fsfw/subsystem/Subsystem.h>
+#include <mission/system/objects/CamSwitcher.h>

 #include "OBSWConfig.h"
 #include "bsp_q7s/boardtest/Q7STestTask.h"
@ -23,6 +24,7 @@
 #include "linux/callbacks/gpioCallbacks.h"
 #include "linux/csp/CspComIF.h"
 #include "linux/devices/GPSHyperionLinuxController.h"
+#include "linux/devices/ScexUartReader.h"
 #include "linux/devices/devicedefinitions/PlocMPSoCDefinitions.h"
 #include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
 #include "linux/devices/ploc/PlocMPSoCHandler.h"
@ -31,22 +33,32 @@
 #include "linux/devices/ploc/PlocSupervisorHandler.h"
 #include "linux/devices/startracker/StarTrackerHandler.h"
 #include "linux/devices/startracker/StrHelper.h"
-#include "linux/obc/AxiPtmeConfig.h"
-#include "linux/obc/PapbVcInterface.h"
-#include "linux/obc/PdecHandler.h"
-#include "linux/obc/Ptme.h"
-#include "linux/obc/PtmeConfig.h"
+#include "linux/ipcore/AxiPtmeConfig.h"
+#include "linux/ipcore/PapbVcInterface.h"
+#include "linux/ipcore/PdecHandler.h"
+#include "linux/ipcore/Ptme.h"
+#include "linux/ipcore/PtmeConfig.h"
 #include "mission/csp/CspCookie.h"
-#include "mission/system/RwAssembly.h"
 #include "mission/system/fdir/AcsBoardFdir.h"
 #include "mission/system/fdir/GomspacePowerFdir.h"
 #include "mission/system/fdir/RtdFdir.h"
 #include "mission/system/fdir/SusFdir.h"
 #include "mission/system/fdir/SyrlinksFdir.h"
+#include "mission/system/objects/AcsSubsystem.h"
+#include "mission/system/objects/RwAssembly.h"
+#include "mission/system/objects/TcsBoardAssembly.h"
+#include "mission/system/tree/acsModeTree.h"
+#include "mission/system/tree/comModeTree.h"
+#include "mission/system/tree/payloadModeTree.h"
+#include "mission/system/tree/tcsModeTree.h"
 #include "tmtc/pusIds.h"
 #if OBSW_TEST_LIBGPIOD == 1
 #include "linux/boardtest/LibgpiodTest.h"
 #endif
+#include <mission/devices/ImtqHandler.h>
+#include <mission/devices/PcduHandler.h>
+#include <mission/devices/SyrlinksHandler.h>
+
 #include <sstream>

 #include "fsfw/datapoollocal/LocalDataPoolManager.h"
@ -61,26 +73,23 @@
 #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"
 #include "mission/devices/PDU1Handler.h"
 #include "mission/devices/PDU2Handler.h"
 #include "mission/devices/PayloadPcduHandler.h"
 #include "mission/devices/RadiationSensorHandler.h"
 #include "mission/devices/RwHandler.h"
 #include "mission/devices/SolarArrayDeploymentHandler.h"
-#include "mission/devices/SyrlinksHkHandler.h"
 #include "mission/devices/Tmp1075Handler.h"
 #include "mission/devices/devicedefinitions/GomspaceDefinitions.h"
 #include "mission/devices/devicedefinitions/Max31865Definitions.h"
@ -88,19 +97,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::PUS_DISTRIBUTOR = objects::PUS_PACKET_DISTRIBUTOR;
-  PusServiceBase::PACKET_DESTINATION = objects::TM_FUNNEL;
+  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;
@ -108,14 +117,6 @@ 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::DEFAULT_RECEIVER = objects::PUS_SERVICE_1_VERIFICATION;
@ -124,23 +125,32 @@ void Factory::setStaticFrameworkObjectIds() {
 void ObjectFactory::setStatics() { Factory::setStaticFrameworkObjectIds(); }

 void ObjectFactory::createTmpComponents() {
-  I2cCookie* i2cCookieTmp1075tcs1 =
-      new I2cCookie(addresses::TMP1075_TCS_1, TMP1075::MAX_REPLY_LENGTH, q7s::I2C_DEFAULT_DEV);
-  I2cCookie* i2cCookieTmp1075tcs2 =
-      new I2cCookie(addresses::TMP1075_TCS_2, TMP1075::MAX_REPLY_LENGTH, q7s::I2C_DEFAULT_DEV);
+  std::vector<std::pair<object_id_t, address_t>> tmpDevIds = {{
+      {objects::TMP1075_HANDLER_TCS_0, addresses::TMP1075_TCS_0},
+      {objects::TMP1075_HANDLER_TCS_1, addresses::TMP1075_TCS_1},
+      {objects::TMP1075_HANDLER_PLPCDU_0, addresses::TMP1075_PLPCDU_0},
+      // damaged
+      // {objects::TMP1075_HANDLER_PLPCDU_1, addresses::TMP1075_PLPCDU_1},
+      {objects::TMP1075_HANDLER_IF_BOARD, addresses::TMP1075_IF_BOARD},
+  }};
+  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]);
+    tmpDevHandler->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
+    // TODO: Remove this after TCS subsystem was added
+    // These devices are connected to the 3V3 stack and should be powered permanently. Therefore,
+    // we set them to normal mode immediately here.
+    tmpDevHandler->setModeNormal();
+  }
 }

-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,11 +161,9 @@ 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) {
@ -200,8 +208,12 @@ void ObjectFactory::createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchI
 #endif
 }

-void ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF) {
+ReturnValue_t ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF,
+                                                      Stack5VHandler& stackHandler) {
  using namespace gpio;
+  if (gpioComIF == nullptr) {
+    return returnvalue::FAILED;
+  }
  GpioCookie* gpioCookieRadSensor = new GpioCookie;
  std::stringstream consumer;
  consumer << "0x" << std::hex << objects::RAD_SENSOR;
@ -218,21 +230,19 @@ void ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF) {
                    spi::DEFAULT_MAX_1227_MODE, spi::DEFAULT_MAX_1227_SPEED);
  spiCookieRadSensor->setMutexParams(MutexIF::TimeoutType::WAITING, spi::RAD_SENSOR_CS_TIMEOUT);
  auto radSensor = new RadiationSensorHandler(objects::RAD_SENSOR, objects::SPI_MAIN_COM_IF,
-                                              spiCookieRadSensor, gpioComIF);
+                                              spiCookieRadSensor, gpioComIF, stackHandler);
  static_cast<void>(radSensor);
-  // The radiation sensor ADC is powered by the 5V stack connector which should always be on
-  radSensor->setStartUpImmediately();
-  // It's a simple sensor, so just to to normal mode immediately
-  radSensor->setToGoToNormalModeImmediately();
 #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;
@ -337,11 +347,11 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
  SpiCookie* spiCookie =
      new SpiCookie(addresses::MGM_0_LIS3, gpioIds::MGM_0_LIS3_CS, MGMLIS3MDL::MAX_BUFFER_SIZE,
                    spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED);
-  auto mgmLis3Handler = new MgmLIS3MDLHandler(objects::MGM_0_LIS3_HANDLER, objects::SPI_MAIN_COM_IF,
-                                              spiCookie, spi::LIS3_TRANSITION_DELAY);
+  auto mgmLis3Handler0 = new MgmLIS3MDLHandler(
+      objects::MGM_0_LIS3_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, spi::LIS3_TRANSITION_DELAY);
  fdir = new AcsBoardFdir(objects::MGM_0_LIS3_HANDLER);
-  mgmLis3Handler->setCustomFdir(fdir);
-  static_cast<void>(mgmLis3Handler);
+  mgmLis3Handler0->setCustomFdir(fdir);
+  assemblyChildren.push_back(*mgmLis3Handler0);
 #if OBSW_TEST_ACS == 1
  mgmLis3Handler->setStartUpImmediately();
  mgmLis3Handler->setToGoToNormalMode(true);
@ -352,13 +362,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 +378,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 +393,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 +416,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 +427,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 +447,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 +455,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,9 +481,18 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
      objects::MGM_0_LIS3_HANDLER, objects::MGM_1_RM3100_HANDLER, objects::MGM_2_LIS3_HANDLER,
      objects::MGM_3_RM3100_HANDLER, objects::GYRO_0_ADIS_HANDLER, objects::GYRO_1_L3G_HANDLER,
      objects::GYRO_2_ADIS_HANDLER, objects::GYRO_3_L3G_HANDLER, objects::GPS_CONTROLLER);
-  auto acsAss = new AcsBoardAssembly(objects::ACS_BOARD_ASS, objects::NO_OBJECT, pwrSwitcher,
-                                     acsBoardHelper, gpioComIF);
+  auto acsAss =
+      new AcsBoardAssembly(objects::ACS_BOARD_ASS, pwrSwitcher, acsBoardHelper, gpioComIF);
  static_cast<void>(acsAss);
+  for (auto& assChild : assemblyChildren) {
+    ReturnValue_t result = assChild.get().connectModeTreeParent(*acsAss);
+    if (result != returnvalue::OK) {
+      sif::error << "Connecting assembly for ACS board component " << assChild.get().getObjectId()
+                 << " failed" << std::endl;
+    }
+  }
+  gpsCtrl->connectModeTreeParent(*acsAss);
+  acsAss->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
 #endif /* OBSW_ADD_ACS_HANDLERS == 1 */
 }

@ -539,7 +555,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;
@ -552,33 +569,40 @@ 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_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);
+  auto syrlinksFdir = new SyrlinksFdir(objects::SYRLINKS_HANDLER);
  auto syrlinksHandler =
-      new SyrlinksHkHandler(objects::SYRLINKS_HK_HANDLER, objects::UART_COM_IF, syrlinksUartCookie,
-                            pcdu::PDU1_CH1_SYRLINKS_12V, syrlinksFdir);
+      new SyrlinksHandler(objects::SYRLINKS_HANDLER, objects::UART_COM_IF, syrlinksUartCookie,
+                          pcdu::PDU1_CH1_SYRLINKS_12V, syrlinksFdir);
  syrlinksHandler->setPowerSwitcher(pwrSwitcher);
+  syrlinksHandler->setStartUpImmediately();
+  syrlinksHandler->connectModeTreeParent(satsystem::com::SUBSYSTEM);
 #if OBSW_DEBUG_SYRLINKS == 1
  syrlinksHandler->setDebugMode(true);
 #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);
 #if OBSW_ADD_PLOC_MPSOC == 1
  consumer << "0x" << std::hex << objects::PLOC_MPSOC_HANDLER;
  auto gpioConfigMPSoC = new GpiodRegularByLineName(q7s::gpioNames::ENABLE_MPSOC_UART,
@ -587,13 +611,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;
@ -603,13 +628,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 supvHelper = new PlocSupvUartManager(objects::PLOC_SUPERVISOR_HELPER);
+  auto* supvHandler = new PlocSupervisorHandler(objects::PLOC_SUPERVISOR_HANDLER, 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);
 }
@ -686,13 +712,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;
@ -755,18 +789,26 @@ 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);
-  vc = new VirtualChannel(ccsds::VC1, common::VC1_QUEUE_SIZE, objects::CCSDS_HANDLER);
-  ccsdsHandler->addVirtualChannel(ccsds::VC1, vc);
-  vc = new VirtualChannel(ccsds::VC2, common::VC2_QUEUE_SIZE, objects::CCSDS_HANDLER);
-  ccsdsHandler->addVirtualChannel(ccsds::VC2, vc);
-  vc = new VirtualChannel(ccsds::VC3, common::VC3_QUEUE_SIZE, objects::CCSDS_HANDLER);
-  ccsdsHandler->addVirtualChannel(ccsds::VC3, vc);
+  vc = new VirtualChannel(ccsds::VC0, config::VC0_QUEUE_SIZE, objects::CCSDS_HANDLER);
+  (*ipCoreHandler)->addVirtualChannel(ccsds::VC0, vc);
+  vc = new VirtualChannel(ccsds::VC1, config::VC1_QUEUE_SIZE, objects::CCSDS_HANDLER);
+  (*ipCoreHandler)->addVirtualChannel(ccsds::VC1, vc);
+  vc = new VirtualChannel(ccsds::VC2, config::VC2_QUEUE_SIZE, objects::CCSDS_HANDLER);
+  (*ipCoreHandler)->addVirtualChannel(ccsds::VC2, vc);
+  vc = new VirtualChannel(ccsds::VC3, config::VC3_QUEUE_SIZE, objects::CCSDS_HANDLER);
+  (*ipCoreHandler)->addVirtualChannel(ccsds::VC3, vc);
+
+  ReturnValue_t result = (*ipCoreHandler)->connectModeTreeParent(satsystem::com::SUBSYSTEM);
+  if (result != returnvalue::OK) {
+    sif::error
+        << "ObjectFactory::createCcsdsComponents: Connecting COM subsystem to CCSDS handler failed"
+        << std::endl;
+  }
+
  GpioCookie* gpioCookiePdec = new GpioCookie;
  consumer.str("");
  consumer << "0x" << std::hex << objects::PDEC_HANDLER;
@ -775,8 +817,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);
@ -792,10 +839,12 @@ 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,
-                                           PowerSwitchIF* pwrSwitcher) {
+                                           PowerSwitchIF* pwrSwitcher,
+                                           Stack5VHandler& stackHandler) {
  using namespace gpio;
  // Create all GPIO components first
  GpioCookie* plPcduGpios = new GpioCookie;
@ -841,10 +890,9 @@ void ObjectFactory::createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF*
      new SpiCookie(addresses::PLPCDU_ADC, gpioIds::PLPCDU_ADC_CS, plpcdu::MAX_ADC_REPLY_SIZE,
                    spi::DEFAULT_MAX_1227_MODE, spi::PL_PCDU_MAX_1227_SPEED);
  // Create device handler components
-  auto plPcduHandler = new PayloadPcduHandler(
-      objects::PLPCDU_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, gpioComIF,
-      SdCardManager::instance(), pwrSwitcher, pcdu::Switches::PDU2_CH1_PL_PCDU_BATT_0_14V8,
-      pcdu::Switches::PDU2_CH6_PL_PCDU_BATT_1_14V8, false);
+  auto plPcduHandler =
+      new PayloadPcduHandler(objects::PLPCDU_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie,
+                             gpioComIF, SdCardManager::instance(), stackHandler, false);
  spiCookie->setCallbackMode(PayloadPcduHandler::extConvAsTwoCallback, plPcduHandler);
 //  plPcduHandler->enablePeriodicPrintout(true, 5);
 //  static_cast<void>(plPcduHandler);
@ -855,6 +903,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) {
@ -863,7 +912,7 @@ void ObjectFactory::createTestComponents(LinuxLibgpioIF* gpioComIF) {
  new SpiTestClass(objects::SPI_TEST, gpioComIF);
 #endif
 #if OBSW_ADD_I2C_TEST_CODE == 1
-  new I2cTestClass(objects::I2C_TEST, q7s::I2C_DEFAULT_DEV);
+  new I2cTestClass(objects::I2C_TEST, q7s::I2C_PL_EIVE);
 #endif
 #if OBSW_ADD_UART_TEST_CODE == 1
  // auto* reader= new ScexUartReader(objects::SCEX_UART_READER);
@ -872,23 +921,24 @@ void ObjectFactory::createTestComponents(LinuxLibgpioIF* gpioComIF) {
 }

 void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) {
-  UartCookie* starTrackerCookie =
-      new UartCookie(objects::STAR_TRACKER, q7s::UART_STAR_TRACKER_DEV, uart::STAR_TRACKER_BAUD,
-                     startracker::MAX_FRAME_SIZE * 2 + 2, UartModes::NON_CANONICAL);
+  auto* starTrackerCookie =
+      new SerialCookie(objects::STAR_TRACKER, q7s::UART_STAR_TRACKER_DEV, uart::STAR_TRACKER_BAUD,
+                       startracker::MAX_FRAME_SIZE * 2 + 2, UartModes::NON_CANONICAL);
  starTrackerCookie->setNoFixedSizeReply();
  StrHelper* strHelper = new StrHelper(objects::STR_HELPER);
  auto starTracker =
      new StarTrackerHandler(objects::STAR_TRACKER, objects::UART_COM_IF, starTrackerCookie,
                             strHelper, pcdu::PDU1_CH2_STAR_TRACKER_5V);
  starTracker->setPowerSwitcher(pwrSwitcher);
+  starTracker->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
 }

 void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher) {
-  I2cCookie* imtqI2cCookie =
-      new I2cCookie(addresses::IMTQ, IMTQ::MAX_REPLY_SIZE, q7s::I2C_DEFAULT_DEV);
-  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();
@ -900,7 +950,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();
--- a/bsp_q7s/core/ObjectFactory.h
+++ b/bsp_q7s/core/ObjectFactory.h
@ -2,11 +2,15 @@
 #define BSP_Q7S_OBJECTFACTORY_H_

 #include <fsfw/returnvalues/returnvalue.h>
+#include <mission/system/objects/Stack5VHandler.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 +23,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);
+                            PowerSwitchIF* pwrSwitcher, Stack5VHandler& stackHandler);
 void createTmpComponents();
-void createRadSensorComponent(LinuxLibgpioIF* gpioComIF);
-void createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComIF* uartComIF,
+ReturnValue_t createRadSensorComponent(LinuxLibgpioIF* gpioComIF, Stack5VHandler& handler);
+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/core/InitMission.cpp
+++ b/bsp_q7s/core/InitMission.cpp
@ -1,7 +1,8 @@
-#include "bsp_q7s/core/InitMission.h"
+#include "scheduling.h"

 #include <fsfw/devicehandlers/DeviceCommunicationIF.h>
-#include <linux/InitMission.h>
+#include <fsfw/subsystem/Subsystem.h>
+#include <linux/scheduling.h>

 #include <iostream>
 #include <vector>
@ -35,13 +36,13 @@ ServiceInterfaceStream sif::error("ERROR", true, false, true);

 ObjectManagerIF* objectManager = nullptr;

-void initmission::initMission() {
+void scheduling::initMission() {
  sif::info << "Building global objects.." << std::endl;
  try {
    /* Instantiate global object manager and also create all objects */
    ObjectManager::instance()->setObjectFactoryFunction(ObjectFactory::produce, nullptr);
  } catch (const std::invalid_argument& e) {
-    sif::error << "initmission::initMission: Object Construction failed with an "
+    sif::error << "scheduling::initMission: Object Construction failed with an "
                  "invalid argument: "
               << e.what();
    std::exit(1);
@ -54,7 +55,7 @@ void initmission::initMission() {
  initTasks();
 }

-void initmission::initTasks() {
+void scheduling::initTasks() {
  TaskFactory* factory = TaskFactory::instance();
  ReturnValue_t result = returnvalue::OK;
  if (factory == nullptr) {
@ -67,122 +68,190 @@ void initmission::initTasks() {
  void (*missedDeadlineFunc)(void) = nullptr;
 #endif

-  PeriodicTaskIF* coreController = factory->createPeriodicTask(
-      "CORE_CTRL", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc);
-  result = coreController->addComponent(objects::CORE_CONTROLLER);
+#if OBSW_ADD_SA_DEPL == 1
+  // Could add this to the core controller but the core controller does so many thing that I would
+  // prefer to have the solar array deployment in a seprate task.
+  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("CORE_CTRL", objects::CORE_CONTROLLER);
+    scheduling::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 = sysTask->addComponent(objects::CORE_CONTROLLER);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("CORE_CTRL", objects::CORE_CONTROLLER);
+  }
+  result = sysTask->addComponent(objects::PL_SUBSYSTEM);
+  if (result != returnvalue::OK) {
+    scheduling::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_SERVERS == 1
+#if OBSW_ADD_TMTC_UDP_SERVER == 1
+  result = tmTcDistributor->addComponent(objects::UDP_TMTC_SERVER);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("UDP_TMTC_SERVER", objects::UDP_TMTC_SERVER);
+  }
+#endif
+#if OBSW_ADD_TMTC_TCP_SERVER == 1
+  result = tmTcDistributor->addComponent(objects::TCP_TMTC_SERVER);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("TCP_TMTC_SERVER", objects::TCP_TMTC_SERVER);
+  }
+#endif
+#endif
  result = tmTcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("CCSDS_DISTRIB", objects::CCSDS_PACKET_DISTRIBUTOR);
+    scheduling::printAddObjectError("CCSDS_DISTRIB", objects::CCSDS_PACKET_DISTRIBUTOR);
  }
  result = tmTcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("PUS_PACKET_DISTRIB", objects::PUS_PACKET_DISTRIBUTOR);
+    scheduling::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);
+    scheduling::printAddObjectError("CFDP_DISTRIBUTOR", objects::CFDP_DISTRIBUTOR);
  }
  result = tmTcDistributor->addComponent(objects::TM_FUNNEL);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("TM_FUNNEL", objects::TM_FUNNEL);
+    scheduling::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 OBSW_ADD_TCPIP_SERVERS == 1
+#if OBSW_ADD_TMTC_UDP_SERVER == 1
+  PeriodicTaskIF* udpPollingTask = factory->createPeriodicTask(
+      "UDP_TMTC_POLLING", 65, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+  result = udpPollingTask->addComponent(objects::UDP_TMTC_POLLING_TASK);
  if (result != returnvalue::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 != returnvalue::OK) {
-    initmission::printAddObjectError("UDP_POLLING", objects::TMTC_POLLING_TASK);
+    scheduling::printAddObjectError("UDP_POLLING", objects::UDP_TMTC_POLLING_TASK);
  }
 #endif
-
-#if OBSW_USE_CCSDS_IP_CORE == 1
-  PeriodicTaskIF* ccsdsHandlerTask = factory->createPeriodicTask(
-      "CCSDS_HANDLER", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
-  result = ccsdsHandlerTask->addComponent(objects::CCSDS_HANDLER);
+#if OBSW_ADD_TMTC_TCP_SERVER == 1
+  PeriodicTaskIF* tcpPollingTask = factory->createPeriodicTask(
+      "TCP_TMTC_POLLING", 65, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+  result = tcpPollingTask->addComponent(objects::TCP_TMTC_POLLING_TASK);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("CCSDS Handler", objects::CCSDS_HANDLER);
+    scheduling::printAddObjectError("UDP_POLLING", objects::TCP_TMTC_POLLING_TASK);
+  }
+#endif
+#endif
+
+  PeriodicTaskIF* comTask = factory->createPeriodicTask(
+      "CCSDS_HANDLER", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+  result = comTask->addComponent(objects::COM_SUBSYSTEM);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("COM subsystem", objects::COM_SUBSYSTEM);
+  }
+#if OBSW_ADD_CCSDS_IP_CORES == 1
+  result = comTask->addComponent(objects::CCSDS_HANDLER);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("CCSDS Handler", objects::CCSDS_HANDLER);
  }

-  // Minimal distance between two received TCs amounts to 0.6 seconds
-  // If a command has not been read before the next one arrives, the old command will be
-  // overwritten by the PDEC.
+  // Runs in IRQ mode, frequency does not really matter
  PeriodicTaskIF* pdecHandlerTask = factory->createPeriodicTask(
-      "PDEC_HANDLER", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
+      "PDEC_HANDLER", 75, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
  result = pdecHandlerTask->addComponent(objects::PDEC_HANDLER);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("PDEC Handler", objects::PDEC_HANDLER);
+    scheduling::printAddObjectError("PDEC Handler", objects::PDEC_HANDLER);
  }
-#endif /* OBSW_USE_CCSDS_IP_CORE == 1 */
+#endif /* OBSW_ADD_CCSDS_IP_CORE == 1 */

 #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);
+    scheduling::printAddObjectError("CFDP Handler", objects::CFDP_HANDLER);
  }
 #endif

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

 #if OBSW_ADD_ACS_CTRL == 1
-  acsTask->addComponent(objects::ACS_CONTROLLER);
+  acsCtrlTask->addComponent(objects::ACS_CONTROLLER);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("ACS_CTRL", objects::ACS_CONTROLLER);
+    scheduling::printAddObjectError("ACS_CTRL", objects::ACS_CONTROLLER);
  }
 #endif
+#if OBSW_Q7S_EM == 1
+  acsCtrlTask->addComponent(objects::MGM_0_LIS3_HANDLER);
+  acsCtrlTask->addComponent(objects::MGM_1_RM3100_HANDLER);
+  acsCtrlTask->addComponent(objects::MGM_2_LIS3_HANDLER);
+  acsCtrlTask->addComponent(objects::MGM_3_RM3100_HANDLER);
+  acsCtrlTask->addComponent(objects::IMTQ_HANDLER);
+  acsCtrlTask->addComponent(objects::SUS_0_N_LOC_XFYFZM_PT_XF);
+  acsCtrlTask->addComponent(objects::SUS_6_R_LOC_XFYBZM_PT_XF);
+  acsCtrlTask->addComponent(objects::SUS_1_N_LOC_XBYFZM_PT_XB);
+  acsCtrlTask->addComponent(objects::SUS_7_R_LOC_XBYBZM_PT_XB);
+  acsCtrlTask->addComponent(objects::SUS_2_N_LOC_XFYBZB_PT_YB);
+  acsCtrlTask->addComponent(objects::SUS_8_R_LOC_XBYBZB_PT_YB);
+  acsCtrlTask->addComponent(objects::SUS_3_N_LOC_XFYBZF_PT_YF);
+  acsCtrlTask->addComponent(objects::SUS_9_R_LOC_XBYBZB_PT_YF);
+  acsCtrlTask->addComponent(objects::SUS_4_N_LOC_XMYFZF_PT_ZF);
+  acsCtrlTask->addComponent(objects::SUS_10_N_LOC_XMYBZF_PT_ZF);
+  acsCtrlTask->addComponent(objects::SUS_5_N_LOC_XFYMZB_PT_ZB);
+  acsCtrlTask->addComponent(objects::SUS_11_R_LOC_XBYMZB_PT_ZB);
+  acsCtrlTask->addComponent(objects::GYRO_0_ADIS_HANDLER);
+  acsCtrlTask->addComponent(objects::GYRO_1_L3G_HANDLER);
+  acsCtrlTask->addComponent(objects::GYRO_2_ADIS_HANDLER);
+  acsCtrlTask->addComponent(objects::GYRO_3_L3G_HANDLER);
+  acsCtrlTask->addComponent(objects::GPS_CONTROLLER);
+  acsCtrlTask->addComponent(objects::STAR_TRACKER);
+  acsCtrlTask->addComponent(objects::RW1);
+  acsCtrlTask->addComponent(objects::RW2);
+  acsCtrlTask->addComponent(objects::RW3);
+  acsCtrlTask->addComponent(objects::RW4);
+#endif

-  PeriodicTaskIF* sysTask = factory->createPeriodicTask(
+  PeriodicTaskIF* acsSysTask = factory->createPeriodicTask(
      "SYS_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
-  static_cast<void>(sysTask);
+  static_cast<void>(acsSysTask);
 #if OBSW_ADD_ACS_BOARD == 1
-  result = sysTask->addComponent(objects::ACS_BOARD_ASS);
+  result = acsSysTask->addComponent(objects::ACS_BOARD_ASS);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("ACS_BOARD_ASS", objects::ACS_BOARD_ASS);
+    scheduling::printAddObjectError("ACS_BOARD_ASS", objects::ACS_BOARD_ASS);
  }
 #endif /* OBSW_ADD_ACS_HANDLERS */
 #if OBSW_ADD_RW == 1
-  result = sysTask->addComponent(objects::RW_ASS);
+  result = acsSysTask->addComponent(objects::RW_ASS);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("RW_ASS", objects::RW_ASS);
+    scheduling::printAddObjectError("RW_ASS", objects::RW_ASS);
  }
 #endif
 #if OBSW_ADD_SUS_BOARD_ASS == 1
-  result = sysTask->addComponent(objects::SUS_BOARD_ASS);
+  result = acsSysTask->addComponent(objects::SUS_BOARD_ASS);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("SUS_BOARD_ASS", objects::SUS_BOARD_ASS);
+    scheduling::printAddObjectError("SUS_BOARD_ASS", objects::SUS_BOARD_ASS);
  }
 #endif
+  result = acsSysTask->addComponent(objects::ACS_SUBSYSTEM);
+  if (result != returnvalue::OK) {
+    scheduling::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 != returnvalue::OK) {
-    initmission::printAddObjectError("SPI_RTD_POLLING", objects::SPI_RTD_COM_IF);
+    scheduling::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 = {
@ -211,11 +280,31 @@ void initmission::initTasks() {
    tcsTask->addComponent(rtd, DeviceHandlerIF::SEND_READ);
    tcsTask->addComponent(rtd, DeviceHandlerIF::GET_READ);
  }
-  tcsTask->addComponent(objects::TCS_BOARD_ASS);
-#endif /* OBSW_ADD_RTD_DEVICES */
+#endif

+  PeriodicTaskIF* tcsSystemTask = factory->createPeriodicTask(
+      "TCS_TASK", 45, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.5, missedDeadlineFunc);
+  result = tcsSystemTask->addComponent(objects::TCS_SUBSYSTEM);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("TCS_SUBSYSTEM", objects::TCS_SUBSYSTEM);
+  }
+#if OBSW_ADD_RTD_DEVICES == 1
+  result = tcsSystemTask->addComponent(objects::TCS_BOARD_ASS);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("TCS_BOARD_ASS", objects::TCS_BOARD_ASS);
+  }
+#endif /* OBSW_ADD_RTD_DEVICES */
 #if OBSW_ADD_TCS_CTRL == 1
-  tcsTask->addComponent(objects::THERMAL_CONTROLLER);
+  result = tcsSystemTask->addComponent(objects::THERMAL_CONTROLLER);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("THERMAL_CONTROLLER", objects::THERMAL_CONTROLLER);
+  }
+#endif
+#if OBSW_ADD_HEATERS == 1
+  result = tcsSystemTask->addComponent(objects::HEATER_HANDLER);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("HEATER_HANDLER", objects::HEATER_HANDLER);
+  }
 #endif

 #if OBSW_ADD_STAR_TRACKER == 1
@ -223,7 +312,7 @@ void initmission::initTasks() {
      "STR_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
  result = strHelperTask->addComponent(objects::STR_HELPER);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("STR_HELPER", objects::STR_HELPER);
+    scheduling::printAddObjectError("STR_HELPER", objects::STR_HELPER);
  }
 #endif /* OBSW_ADD_STAR_TRACKER == 1 */

@ -232,7 +321,7 @@ void initmission::initTasks() {
      "PLOC_MPSOC_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
  result = mpsocHelperTask->addComponent(objects::PLOC_MPSOC_HELPER);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("PLOC_MPSOC_HELPER", objects::PLOC_MPSOC_HELPER);
+    scheduling::printAddObjectError("PLOC_MPSOC_HELPER", objects::PLOC_MPSOC_HELPER);
  }
 #endif /* OBSW_ADD_PLOC_MPSOC */

@ -241,18 +330,15 @@ void initmission::initTasks() {
      "PLOC_SUPV_HELPER", 10, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
  result = supvHelperTask->addComponent(objects::PLOC_SUPERVISOR_HELPER);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("PLOC_SUPV_HELPER", objects::PLOC_SUPERVISOR_HELPER);
+    scheduling::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 != returnvalue::OK) {
-    initmission::printAddObjectError("PTME_TEST", objects::CCSDS_IP_CORE_BRIDGE);
-  }
-#endif
+  PeriodicTaskIF* plTask = factory->createPeriodicTask(
+      "PL_TASK", 25, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
+  scheduling::addMpsocSupvHandlers(plTask);
+  plTask->addComponent(objects::CAM_SWITCHER);
+
 #if OBSW_ADD_SCEX_DEVICE == 1
  PeriodicTaskIF* scexDevHandler;
  PeriodicTaskIF* scexReaderTask;
@ -265,6 +351,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) {
+    scheduling::printAddObjectError("PTME_TEST", objects::CCSDS_IP_CORE_BRIDGE);
+  }
+#endif
  std::vector<PeriodicTaskIF*> testTasks;
  createTestTasks(*factory, missedDeadlineFunc, testTasks);
 #endif
@ -282,17 +376,24 @@ void initmission::initTasks() {
  sif::info << "Starting tasks.." << std::endl;
  tmTcDistributor->startTask();

-#if OBSW_ADD_TCPIP_BRIDGE == 1
-  tmtcBridgeTask->startTask();
-  tmtcPollingTask->startTask();
+#if OBSW_ADD_TCPIP_SERVERS == 1
+#if OBSW_ADD_TMTC_UDP_SERVER == 1
+  udpPollingTask->startTask();
+#endif
+#if OBSW_ADD_TMTC_TCP_SERVER == 1
+  tcpPollingTask->startTask();
+#endif
 #endif

-#if OBSW_USE_CCSDS_IP_CORE == 1
-  ccsdsHandlerTask->startTask();
+  comTask->startTask();
+#if OBSW_ADD_CCSDS_IP_CORES == 1
  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");
@ -313,15 +414,19 @@ void initmission::initTasks() {
  strHelperTask->startTask();
 #endif /* OBSW_ADD_STAR_TRACKER == 1 */

-  acsTask->startTask();
-  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 */
+  plTask->startTask();

 #if OBSW_ADD_TEST_CODE == 1
  taskStarter(testTasks, "Test task vector");
@ -330,9 +435,8 @@ void initmission::initTasks() {
  sif::info << "Tasks started.." << std::endl;
 }

-void initmission::createPstTasks(TaskFactory& factory,
-                                 TaskDeadlineMissedFunction missedDeadlineFunc,
-                                 std::vector<PeriodicTaskIF*>& taskVec) {
+void scheduling::createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
+                                std::vector<PeriodicTaskIF*>& taskVec) {
  ReturnValue_t result = returnvalue::OK;
  /* Polling Sequence Table Default */
 #if OBSW_ADD_SPI_TEST_CODE == 0
@ -341,9 +445,9 @@ void initmission::createPstTasks(TaskFactory& factory,
  result = pst::pstSpi(spiPst);
  if (result != returnvalue::OK) {
    if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
-      sif::warning << "InitMission::initTasks: SPI PST is empty" << std::endl;
+      sif::warning << "scheduling::initTasks: SPI PST is empty" << std::endl;
    } else {
-      sif::error << "InitMission::initTasks: Creating SPI PST failed!" << std::endl;
+      sif::error << "scheduling::initTasks: Creating SPI PST failed!" << std::endl;
    }
  } else {
    taskVec.push_back(spiPst);
@ -356,9 +460,9 @@ void initmission::createPstTasks(TaskFactory& factory,
  result = pst::pstSpiRw(rwPstTask);
  if (result != returnvalue::OK) {
    if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
-      sif::warning << "InitMission::initTasks: SPI PST is empty" << std::endl;
+      sif::warning << "scheduling::initTasks: SPI PST is empty" << std::endl;
    } else {
-      sif::error << "InitMission::initTasks: Creating SPI PST failed!" << std::endl;
+      sif::error << "scheduling::initTasks: Creating SPI PST failed!" << std::endl;
    }
  } else {
    taskVec.push_back(rwPstTask);
@ -370,35 +474,23 @@ void initmission::createPstTasks(TaskFactory& factory,
  result = pst::pstUart(uartPst);
  if (result != returnvalue::OK) {
    if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
-      sif::warning << "InitMission::initTasks: UART PST is empty" << std::endl;
+      sif::warning << "scheduling::initTasks: UART PST is empty" << std::endl;
    } else {
-      sif::error << "InitMission::initTasks: Creating UART PST failed!" << std::endl;
+      sif::error << "scheduling::initTasks: Creating UART PST failed!" << std::endl;
    }
  } else {
    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 != returnvalue::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 != returnvalue::OK) {
    if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
-      sif::warning << "InitMission::initTasks: I2C PST is empty" << std::endl;
+      sif::warning << "scheduling::initTasks: I2C PST is empty" << std::endl;
    } else {
-      sif::error << "InitMission::initTasks: Creating I2C PST failed!" << std::endl;
+      sif::error << "scheduling::initTasks: Creating I2C PST failed!" << std::endl;
    }
  } else {
    taskVec.push_back(i2cPst);
@ -411,23 +503,22 @@ void initmission::createPstTasks(TaskFactory& factory,
  result = pst::pstGompaceCan(gomSpacePstTask);
  if (result != returnvalue::OK) {
    if (result != FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
-      sif::error << "InitMission::initTasks: GomSpace PST initialization failed!" << std::endl;
+      sif::error << "scheduling::initTasks: GomSpace PST initialization failed!" << std::endl;
    }
  }
  taskVec.push_back(gomSpacePstTask);
 #endif
 }

-void initmission::createPusTasks(TaskFactory& factory,
-                                 TaskDeadlineMissedFunction missedDeadlineFunc,
-                                 std::vector<PeriodicTaskIF*>& taskVec) {
+void scheduling::createPusTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
+                                std::vector<PeriodicTaskIF*>& taskVec) {
  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 != returnvalue::OK) {
-    initmission::printAddObjectError("PUS_VERIF", objects::PUS_SERVICE_1_VERIFICATION);
+    scheduling::printAddObjectError("PUS_VERIF", objects::PUS_SERVICE_1_VERIFICATION);
  }
  taskVec.push_back(pusVerification);

@ -435,24 +526,25 @@ void initmission::createPusTasks(TaskFactory& factory,
      "PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
  result = pusEvents->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("PUS_EVENTS", objects::PUS_SERVICE_5_EVENT_REPORTING);
+    scheduling::printAddObjectError("PUS_EVENTS", objects::PUS_SERVICE_5_EVENT_REPORTING);
  }
  result = pusEvents->addComponent(objects::EVENT_MANAGER);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("PUS_MGMT", objects::EVENT_MANAGER);
+    scheduling::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 != returnvalue::OK) {
-    initmission::printAddObjectError("PUS_2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
+    scheduling::printAddObjectError("PUS_2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
  }
  result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("PUS_9", objects::PUS_SERVICE_9_TIME_MGMT);
+    scheduling::printAddObjectError("PUS_9", objects::PUS_SERVICE_9_TIME_MGMT);
  }
+
  taskVec.push_back(pusHighPrio);

  PeriodicTaskIF* pusMedPrio = factory.createPeriodicTask(
@ -460,46 +552,47 @@ void initmission::createPusTasks(TaskFactory& factory,

  result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("PUS_3", objects::PUS_SERVICE_3_HOUSEKEEPING);
+    scheduling::printAddObjectError("PUS_3", objects::PUS_SERVICE_3_HOUSEKEEPING);
  }
  result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("PUS_8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
+    scheduling::printAddObjectError("PUS_8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
  }
  result = pusMedPrio->addComponent(objects::PUS_SERVICE_11_TC_SCHEDULER);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("PUS_11", objects::PUS_SERVICE_11_TC_SCHEDULER);
+    scheduling::printAddObjectError("PUS_11", objects::PUS_SERVICE_11_TC_SCHEDULER);
  }
  result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("PUS_20", objects::PUS_SERVICE_20_PARAMETERS);
+    scheduling::printAddObjectError("PUS_20", objects::PUS_SERVICE_20_PARAMETERS);
  }
  result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("PUS_200", objects::PUS_SERVICE_200_MODE_MGMT);
+    scheduling::printAddObjectError("PUS_200", objects::PUS_SERVICE_200_MODE_MGMT);
  }
  result = pusMedPrio->addComponent(objects::PUS_SERVICE_201_HEALTH);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("PUS_201", objects::PUS_SERVICE_201_HEALTH);
+    scheduling::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) {
+    scheduling::printAddObjectError("PUS_17", objects::PUS_SERVICE_17_TEST);
  }
  taskVec.push_back(pusMedPrio);

  PeriodicTaskIF* pusLowPrio = factory.createPeriodicTask(
      "PUS_LOW_PRIO", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.6, missedDeadlineFunc);
-  result = pusLowPrio->addComponent(objects::PUS_SERVICE_17_TEST);
-  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("PUS_17", objects::PUS_SERVICE_17_TEST);
-  }
  result = pusLowPrio->addComponent(objects::INTERNAL_ERROR_REPORTER);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("ERROR_REPORTER", objects::INTERNAL_ERROR_REPORTER);
+    scheduling::printAddObjectError("ERROR_REPORTER", objects::INTERNAL_ERROR_REPORTER);
  }
  taskVec.push_back(pusLowPrio);
 }

-void initmission::createTestTasks(TaskFactory& factory,
-                                  TaskDeadlineMissedFunction missedDeadlineFunc,
-                                  std::vector<PeriodicTaskIF*>& taskVec) {
+void scheduling::createTestTasks(TaskFactory& factory,
+                                 TaskDeadlineMissedFunction missedDeadlineFunc,
+                                 std::vector<PeriodicTaskIF*>& taskVec) {
 #if OBSW_ADD_TEST_TASK == 1 && OBSW_ADD_TEST_CODE == 1
  ReturnValue_t result = returnvalue::OK;
  static_cast<void>(result);  // supress warning in case it is not used
@ -509,25 +602,25 @@ void initmission::createTestTasks(TaskFactory& factory,

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

 #if OBSW_ADD_SPI_TEST_CODE == 1
  result = testTask->addComponent(objects::SPI_TEST);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("SPI_TEST", objects::SPI_TEST);
+    scheduling::printAddObjectError("SPI_TEST", objects::SPI_TEST);
  }
 #endif
 #if OBSW_ADD_I2C_TEST_CODE == 1
  result = testTask->addComponent(objects::I2C_TEST);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("I2C_TEST", objects::I2C_TEST);
+    scheduling::printAddObjectError("I2C_TEST", objects::I2C_TEST);
  }
 #endif
 #if OBSW_ADD_UART_TEST_CODE == 1
  result = testTask->addComponent(objects::UART_TEST);
  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("UART_TEST", objects::UART_TEST);
+    scheduling::printAddObjectError("UART_TEST", objects::UART_TEST);
  }
 #endif

--- a/bsp_q7s/core/InitMission.h
+++ b/bsp_q7s/core/InitMission.h
@ -8,7 +8,7 @@
 class PeriodicTaskIF;
 class TaskFactory;

-namespace initmission {
+namespace scheduling {
 void initMission();
 void initTasks();

@ -18,6 +18,6 @@ void createPusTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadl
                    std::vector<PeriodicTaskIF*>& taskVec);
 void createTestTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
                     std::vector<PeriodicTaskIF*>& taskVec);
-};  // namespace initmission
+};  // namespace scheduling

 #endif /* BSP_Q7S_INITMISSION_H_ */
--- a/bsp_q7s/em/emObjectFactory.cpp
+++ b/bsp_q7s/em/emObjectFactory.cpp
@ -1,5 +1,7 @@
+#include <bsp_q7s/callbacks/q7sGpioCallbacks.h>
 #include <fsfw/health/HealthTableIF.h>
 #include <fsfw/power/DummyPowerSwitcher.h>
+#include <mission/devices/devicedefinitions/GomspaceDefinitions.h>

 #include "OBSWConfig.h"
 #include "bsp_q7s/core/CoreController.h"
@ -12,30 +14,47 @@
 #include "linux/ObjectFactory.h"
 #include "linux/callbacks/gpioCallbacks.h"
 #include "mission/core/GenericFactory.h"
+#include "mission/system/tree/comModeTree.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;
  SpiComIF* spiRwComIF = nullptr;
  createCommunicationInterfaces(&gpioComIF, &uartComIF, &spiMainComIF, &i2cComIF, &spiRwComIF);
+  /* 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;
-  dummy::createDummies(dummyCfg);
+#if OBSW_ADD_SYRLINKS == 1
+  dummyCfg.addSyrlinksDummies = false;
+#endif
+#if OBSW_ADD_GOMSPACE_PCDU == 1
+  dummyCfg.addPowerDummies = false;
+#endif
+
+  PowerSwitchIF* pwrSwitcher = nullptr;
+#if OBSW_ADD_GOMSPACE_PCDU == 0
+  pwrSwitcher = new DummyPowerSwitcher(objects::PCDU_HANDLER, 18, 0);
+#else
+  createPcduComponents(gpioComIF, &pwrSwitcher);
+#endif
+
+  dummy::createDummies(dummyCfg, *pwrSwitcher);

  new CoreController(objects::CORE_CONTROLLER);

-  gpioCallbacks::disableAllDecoder(gpioComIF);
-  PowerSwitchIF* pwrSwitcher = new DummyPowerSwitcher(objects::PCDU_HANDLER, 18, 0);
-
  // Regular FM code, does not work for EM if the hardware is not connected
  // createPcduComponents(gpioComIF, &pwrSwitcher);
  // createPlPcduComponents(gpioComIF, spiMainComIF, pwrSwitcher);
@ -43,19 +62,29 @@ void ObjectFactory::produce(void* args) {
  // createSunSensorComponents(gpioComIF, spiMainComIF, pwrSwitcher, q7s::SPI_DEFAULT_DEV);
  // createRtdComponents(q7s::SPI_DEFAULT_DEV, gpioComIF, pwrSwitcher, spiMainComIF);
  // createTmpComponents();
-  createRadSensorComponent(gpioComIF);
+  // 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();
-  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();
@ -64,14 +93,21 @@ 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();
-  createAcsController();
+#if OBSW_ADD_SCEX_DEVICE == 1
+  createScexComponents(q7s::UART_SCEX_DEV, pwrSwitcher, *SdCardManager::instance(), false,
+                       pcdu::Switches::PDU1_CH5_SOLAR_CELL_EXP_5V);
+#endif
+  createAcsController(true);
+  satsystem::com::init();
 }
--- a/bsp_q7s/fmObjectFactory.cpp
+++ b/bsp_q7s/fmObjectFactory.cpp
@ -1,3 +1,4 @@
+#include <bsp_q7s/callbacks/q7sGpioCallbacks.h>
 #include <mission/devices/devicedefinitions/GomspaceDefinitions.h>

 #include "OBSWConfig.h"
@ -10,38 +11,51 @@
 #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);
+  auto* stackHandler = new Stack5VHandler(*pwrSwitcher);
+
+#if OBSW_ADD_RAD_SENSORS == 1
+  createRadSensorComponent(gpioComIF, *stackHandler);
+#endif
+#if OBSW_ADD_SUN_SENSORS == 1
+  createSunSensorComponents(gpioComIF, spiMainComIF, pwrSwitcher, q7s::SPI_DEFAULT_DEV, true);
+#endif

 #if OBSW_ADD_ACS_BOARD == 1
  createAcsBoardComponents(gpioComIF, uartComIF, pwrSwitcher);
 #endif
  createHeaterComponents(gpioComIF, pwrSwitcher, healthTable);
-  createSolarArrayDeploymentComponents();
-  createPlPcduComponents(gpioComIF, spiMainComIF, pwrSwitcher);
+#if OBSW_ADD_TMP_DEVICES == 1
+  createTmpComponents();
+#endif
+  createSolarArrayDeploymentComponents(*pwrSwitcher, *gpioComIF);
+  createPlPcduComponents(gpioComIF, spiMainComIF, pwrSwitcher, *stackHandler);
 #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);
@ -55,9 +69,13 @@ 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,
@ -70,5 +88,6 @@ void ObjectFactory::produce(void* args) {

  createMiscComponents();
  createThermalController();
-  createAcsController();
+  createAcsController(true);
+  satsystem::init();
 }
--- a/bsp_q7s/fs/SdCardManager.cpp
+++ b/bsp_q7s/fs/SdCardManager.cpp
@ -27,8 +27,7 @@ SdCardManager::SdCardManager() : SystemObject(objects::SDC_MANAGER), cmdExecutor
  }
  uint8_t prefSdRaw = 0;
  result = scratch::readNumber(scratch::PREFERED_SDC_KEY, prefSdRaw);
-  result = mutex->unlockMutex();
-  if (result != returnvalue::OK) {
+  if (mutex->unlockMutex() != returnvalue::OK) {
    sif::error << "SdCardManager::SdCardManager: Mutex unlock failed" << std::endl;
  }

@ -460,7 +459,14 @@ void SdCardManager::setBlocking(bool blocking) { this->blocking = blocking; }

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

-bool SdCardManager::isSdCardUsable(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);

@ -468,20 +474,30 @@ bool SdCardManager::isSdCardUsable(sd::SdCard sdCard) {
    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;
 }
@ -561,5 +577,13 @@ void SdCardManager::setActiveSdCard(sd::SdCard sdCard) {

 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/fs/SdCardManager.h
+++ b/bsp_q7s/fs/SdCardManager.h
@ -206,7 +206,7 @@ class SdCardManager : public SystemObject, public SdCardMountedIF {
   *
   * @return  true if mounted, otherwise false
   */
-  bool isSdCardUsable(sd::SdCard sdCard) override;
+  bool isSdCardUsable(std::optional<sd::SdCard> sdCard) override;

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

@ -214,12 +214,15 @@ class SdCardManager : public SystemObject, public SdCardMountedIF {

  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/obsw.cpp
+++ b/bsp_q7s/obsw.cpp
@ -1,11 +1,16 @@
 #include "obsw.h"

+#include <pwd.h>
+#include <sys/types.h>
+#include <unistd.h>
+
 #include <filesystem>
+#include <fstream>
 #include <iostream>

 #include "OBSWConfig.h"
 #include "commonConfig.h"
-#include "core/InitMission.h"
+#include "core/scheduling.h"
 #include "fsfw/tasks/TaskFactory.h"
 #include "fsfw/version.h"
 #include "q7sConfig.h"
@ -36,7 +41,36 @@ int obsw::obsw() {
    return OBSW_ALREADY_RUNNING;
  }
 #endif
-  initmission::initMission();
+
+  const char* homedir = nullptr;
+  homedir = getenv("HOME");
+  if (homedir == nullptr) {
+    homedir = getpwuid(getuid())->pw_dir;
+  }
+  std::filesystem::path bootDelayFile = std::filesystem::path(homedir) / "boot_delay_secs.txt";
+  // Init delay handling.
+  if (std::filesystem::exists(bootDelayFile)) {
+    std::ifstream ifile(bootDelayFile);
+    std::string lineStr;
+    unsigned int bootDelaySecs = 0;
+    unsigned int line = 0;
+    // Try to reas delay seconds from file.
+    while (std::getline(ifile, lineStr)) {
+      std::istringstream iss(lineStr);
+      if (!(iss >> bootDelaySecs)) {
+        break;
+      }
+      line++;
+    }
+    if (line == 0) {
+      // If the file is empty, assume default of 6 seconds
+      bootDelaySecs = 6;
+    }
+    std::cout << "Delaying OBSW start for " << bootDelaySecs << " seconds" << std::endl;
+    TaskFactory::delayTask(bootDelaySecs * 1000);
+  }
+
+  scheduling::initMission();

  for (;;) {
    /* Suspend main thread by sleeping it. */
--- a/bsp_te0720_1cfa/InitMission.cpp
+++ b/bsp_te0720_1cfa/InitMission.cpp
@ -107,7 +107,7 @@ void initmission::initTasks() {
  }
 #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);
@ -124,7 +124,7 @@ void initmission::initTasks() {
  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 */
--- 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/clone-submodules-no-privlibs.sh
+++ b/clone-submodules-no-privlibs.sh
@ -0,0 +1,3 @@
+#!/bin/bash
+
+git submodule update --init fsfw thirdparty/rapidcsv thirdparty/lwgps thirdparty/json
--- a/cmake/scripts/cmake-build-cfg.py
+++ b/cmake/scripts/cmake-build-cfg.py
@ -22,24 +22,38 @@ def main():
    parser = argparse.ArgumentParser(
        description="Processing arguments for CMake build configuration."
    )
-    parser.add_argument("-o", "--osal", type=str, choices=["freertos", "linux", "rtems", "host"],
-                        help="FSFW OSAL. Valid arguments: host, linux, rtems, freertos")
    parser.add_argument(
-        "-b", "--buildtype", type=str, choices=["debug", "release", "size", "reldeb"],
+        "-o",
+        "--osal",
+        type=str,
+        choices=["freertos", "linux", "rtems", "host"],
+        help="FSFW OSAL. Valid arguments: host, linux, rtems, freertos",
+    )
+    parser.add_argument(
+        "-b",
+        "--buildtype",
+        type=str,
+        choices=["debug", "release", "size", "reldeb"],
        help="CMake build type. Valid arguments: debug, release, size, reldeb (Release with Debug "
-             "Information)", default="debug"
+        "Information)",
+        default="debug",
    )
    parser.add_argument("-l", "--builddir", type=str, help="Specify build directory.")
    parser.add_argument(
-        "-g", "--generator", type=str, help="CMake Generator", choices=['make', 'ninja']
+        "-g", "--generator", type=str, help="CMake Generator", choices=["make", "ninja"]
    )
    parser.add_argument(
-        "-d", "--defines",
+        "-d",
+        "--defines",
        help="Additional custom defines passed to CMake (supply without -D prefix!)",
-        nargs="*", type=str
+        nargs="*",
+        type=str,
    )
    parser.add_argument(
-        "-t", "--target-bsp", type=str, help="Target BSP, combination of architecture and machine"
+        "-t",
+        "--target-bsp",
+        type=str,
+        help="Target BSP, combination of architecture and machine",
    )

    args = parser.parse_args()
@ -59,13 +73,13 @@ def main():
    if args.generator is None:
        generator_cmake_arg = ""
    else:
-        if args.generator == 'make':
-            if os.name == 'nt':
+        if args.generator == "make":
+            if os.name == "nt":
                generator_cmake_arg = '-G "MinGW Makefiles"'
            else:
                generator_cmake_arg = '-G "Unix Makefiles"'
-        elif args.generator == 'ninja':
-            generator_cmake_arg = '-G Ninja'
+        elif args.generator == "ninja":
+            generator_cmake_arg = "-G Ninja"
        else:
            generator_cmake_arg = args.generator

@ -79,7 +93,7 @@ def main():
        cmake_build_type = "RelWithDebInfo"

    if args.target_bsp is not None:
-        cmake_target_cfg_cmd = f"-DTGT_BSP=\"{args.target_bsp}\""
+        cmake_target_cfg_cmd = f'-DTGT_BSP="{args.target_bsp}"'
    else:
        cmake_target_cfg_cmd = ""

@ -92,10 +106,12 @@ def main():
    build_folder = cmake_build_type
    if args.builddir is not None:
        build_folder = args.builddir
-    
+
    build_path = source_location + os.path.sep + build_folder
    if os.path.isdir(build_path):
-        remove_old_dir = input(f"{build_folder} folder already exists. Remove old directory? [y/n]: ")
+        remove_old_dir = input(
+            f"{build_folder} folder already exists. Remove old directory? [y/n]: "
+        )
        if str(remove_old_dir).lower() in ["yes", "y", 1]:
            remove_old_dir = True
        else:
@ -109,17 +125,19 @@ def main():
    print(f"Navigating into build directory: {build_path}")
    os.chdir(build_folder)

-    cmake_command = f"cmake {generator_cmake_arg} -DFSFW_OSAL=\"{osal}\" " \
-                    f"-DCMAKE_BUILD_TYPE=\"{cmake_build_type}\" {cmake_target_cfg_cmd} " \
-                    f"{define_string} {source_location}"
+    cmake_command = (
+        f'cmake {generator_cmake_arg} -DFSFW_OSAL="{osal}" '
+        f'-DCMAKE_BUILD_TYPE="{cmake_build_type}" {cmake_target_cfg_cmd} '
+        f"{define_string} {source_location}"
+    )
    # Remove redundant spaces
-    cmake_command = ' '.join(cmake_command.split())
+    cmake_command = " ".join(cmake_command.split())
    print("Running CMake command: ")
-    print(f"\" {cmake_command} \"")
+    print(f'" {cmake_command} "')
    os.system(cmake_command)
    print("-- CMake configuration done. --")
-    
-    
+
+
 def rm_build_dir(path: str):
    # On windows the permissions of the build directory may have been set to read-only. If this
    # is the case the permissions are changed before trying to delete the directory.
@ -134,7 +152,9 @@ def determine_source_location() -> str:
        index += 1
        os.chdir("..")
        if index >= 5:
-            print("Error: Could not find source directory (determined by looking for fsfw folder!)")
+            print(
+                "Error: Could not find source directory (determined by looking for fsfw folder!)"
+            )
            sys.exit(1)
    return os.getcwd()

--- a/cmake/scripts/host/host-make-debug.sh
+++ b/cmake/scripts/host/host-make-debug.sh
@ -1,12 +1,14 @@
 #!/bin/bash
 cfg_script_name="cmake-build-cfg.py"
 init_dir=$(pwd)
+root_dir=""
 if [ -z "${EIVE_OBSW_ROOT}" ]; then
    counter=0
    while [ ${counter} -lt 5 ]
    do
        cd ..
        if [ -f ${cfg_script_name} ];then
+            root_dir=$(realpath "../..")
            break
        fi
        counter=$((counter=counter + 1))
@ -18,6 +20,7 @@ if [ -z "${EIVE_OBSW_ROOT}" ]; then
    fi
 else
    cfg_script_name="${EIVE_OBSW_ROOT}/cmake/scripts/${cfg_script_name}"
+    root_dir=${EIVE_OBSW_ROOT}
 fi

 build_generator="make"
@ -34,4 +37,5 @@ echo "Running command (without the leading +):"
 set -x # Print command 
 ${python} ${cfg_script_name} -o "${os_fsfw}" -g "${build_generator}" -b "debug" -l "${builddir}"
 # Use this if commands are added which should not be printed
-# set +x
+set +x
+cd ${root_dir}/${builddir}
--- a/cmake/scripts/host/host-make-release.sh
+++ b/cmake/scripts/host/host-make-release.sh
@ -7,6 +7,7 @@ if [ -z "${EIVE_OBSW_ROOT}" ]; then
    do
        cd ..
        if [ -f ${cfg_script_name} ];then
+            root_dir=$(realpath "../..")
            break
        fi
        counter=$((counter=counter + 1))
@ -20,7 +21,7 @@ else
    cfg_script_name="${EIVE_OBSW_ROOT}/cmake/scripts/${cfg_script_name}"
 fi

-build_generator="Unix Makefiles"
+build_generator="make"
 os_fsfw="host"
 builddir="cmake-build-release"
 if [ "${OS}" = "Windows_NT" ]; then
@ -34,4 +35,5 @@ echo "Running command (without the leading +):"
 set -x # Print command 
 ${python} ${cfg_script_name} -o "${os_fsfw}" -g "${build_generator}" -b "release" -l "${builddir}"
 # Use this if commands are added which should not be printed
-# set +x
+set +x
+cd ${root_dir}/${builddir}
--- a/common/config/commonConfig.h.in
+++ b/common/config/commonConfig.h.in
@ -17,13 +17,7 @@ debugging. */
 #define OBSW_ADD_LWGPS_TEST                 0   

 // Disable this for mission code. It allows exchanging TMTC packets via the Ethernet port
-#define OBSW_ADD_TCPIP_BRIDGE               1
-
-// Use TCP instead of UDP for the TMTC bridge. This allows using the TMTC client locally
-// because UDP packets are not allowed in the VPN
-// This will cause the OBSW to initialize the TMTC bridge responsible for exchanging data with the
-// CCSDS IP Cores. 
-#define OBSW_USE_TMTC_TCP_BRIDGE            1
+#define OBSW_ADD_TCPIP_SERVERS              1

 #define OBSW_ADD_CFDP_COMPONENTS            1

@ -42,14 +36,6 @@ 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;
-static constexpr uint8_t VC0_QUEUE_SIZE = 50;
-static constexpr uint8_t VC1_QUEUE_SIZE = 50;
-static constexpr uint8_t VC2_QUEUE_SIZE = 50;
-static constexpr uint8_t VC3_QUEUE_SIZE = 50;
-
 }

 #endif /* COMMON_CONFIG_COMMONCONFIG_H_ */
--- a/common/config/devConf.h
+++ b/common/config/devConf.h
@ -1,11 +1,13 @@
 #ifndef COMMON_CONFIG_DEVCONF_H_
 #define COMMON_CONFIG_DEVCONF_H_

+#include <fsfw_hal/linux/serial/SerialCookie.h>
+
 #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,10 +57,10 @@ 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_57600;
+static constexpr UartBaudRate SCEX_BAUD = UartBaudRate::RATE_115200;
 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;
+static constexpr UartBaudRate PLOC_SUPV_BAUD = UartBaudRate::RATE_921600;
 static constexpr UartBaudRate STAR_TRACKER_BAUD = UartBaudRate::RATE_921600;

 }  // namespace uart
--- a/linux/fsfwconfig/devices/addresses.h
+++ b/linux/fsfwconfig/devices/addresses.h
@ -43,11 +43,14 @@ enum logicalAddresses : address_t {
  DUMMY_GPS1 = 131,
 };

-enum i2cAddresses : address_t {
+enum I2cAddress : address_t {
  BPX_BATTERY = 0x07,
  IMTQ = 0x10,
-  TMP1075_TCS_1 = 0x48,
-  TMP1075_TCS_2 = 0x49,
+  TMP1075_TCS_0 = 0x48,
+  TMP1075_TCS_1 = 0x49,
+  TMP1075_PLPCDU_0 = 0x4A,
+  TMP1075_PLPCDU_1 = 0x4B,
+  TMP1075_IF_BOARD = 0x4C,
 };

 enum spiAddresses : address_t {
--- a/common/config/eive/definitions.h
+++ b/common/config/eive/definitions.h
@ -34,6 +34,27 @@ 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 LEGACY_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;
+
+static constexpr uint32_t CCSDS_HANDLER_QUEUE_SIZE = 50;
+static constexpr uint8_t NUMBER_OF_VIRTUAL_CHANNELS = 4;
+static constexpr uint8_t VC0_QUEUE_SIZE = 80;
+static constexpr uint8_t VC1_QUEUE_SIZE = 80;
+static constexpr uint8_t VC2_QUEUE_SIZE = 50;
+static constexpr uint8_t VC3_QUEUE_SIZE = 50;
+
+static constexpr uint32_t MAX_PUS_FUNNEL_QUEUE_DEPTH = 100;
+
+static constexpr uint32_t MAX_STORED_CMDS_UDP = 120;
+static constexpr uint32_t MAX_STORED_CMDS_TCP = 120;
+
 }  // namespace config

 #endif /* COMMON_CONFIG_DEFINITIONS_H_ */
--- a/common/config/eive/eventSubsystemIds.h
+++ b/common/config/eive/eventSubsystemIds.h
@ -35,6 +35,7 @@ enum : uint8_t {
  SYRLINKS = 137,
  SCEX_HANDLER = 138,
  CONFIGHANDLER = 139,
+  CORE = 140,
  COMMON_SUBSYSTEM_ID_END

 };
--- a/common/config/eive/objects.h
+++ b/common/config/eive/objects.h
@ -8,14 +8,20 @@ enum commonObjects : uint32_t {
  /* First Byte 0x50-0x52 reserved for PUS Services **/
  CCSDS_PACKET_DISTRIBUTOR = 0x50000100,
  PUS_PACKET_DISTRIBUTOR = 0x50000200,
-  TMTC_BRIDGE = 0x50000300,
-  TMTC_POLLING_TASK = 0x50000400,
+  TCP_TMTC_SERVER = 0x50000300,
+  UDP_TMTC_SERVER = 0x50000301,
+  TCP_TMTC_POLLING_TASK = 0x50000400,
+  UDP_TMTC_POLLING_TASK = 0x50000401,
  FILE_SYSTEM_HANDLER = 0x50000500,
  SDC_MANAGER = 0x50000550,
  PTME = 0x50000600,
  PDEC_HANDLER = 0x50000700,
  CCSDS_HANDLER = 0x50000800,

+  /* 0x49 ('I') for Communication Interfaces **/
+  UART_COM_IF = 0x49030003,
+  SCEX_UART_READER = 0x49010006,
+
  /* 0x43 ('C') for Controllers */
  THERMAL_CONTROLLER = 0x43400001,
  ACS_CONTROLLER = 0x43000002,
@ -39,8 +45,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,
@ -107,7 +117,9 @@ enum commonObjects : uint32_t {
  SUS_5_N_LOC_XFYMZB_PT_ZB = 0x44120037,
  SUS_11_R_LOC_XBYMZB_PT_ZB = 0x44120043,

-  SYRLINKS_HK_HANDLER = 0x445300A3,
+  SYRLINKS_HANDLER = 0x445300A3,
+  // might be obsolete, was not used in Q7S FM SW
+  // CCSDS_IP_CORE_BRIDGE = 0x73500000,

  /* 0x49 ('I') for Communication Interfaces */
  SPI_RTD_COM_IF = 0x49020006,
@ -127,8 +139,18 @@ enum commonObjects : uint32_t {
  SUS_BOARD_ASS = 0x73000002,
  TCS_BOARD_ASS = 0x73000003,
  RW_ASS = 0x73000004,
-  CFDP_HANDLER = 0x73000005,
-  CFDP_DISTRIBUTOR = 0x73000006
+  CAM_SWITCHER = 0x73000006,
+  EIVE_SYSTEM = 0x73010000,
+  ACS_SUBSYSTEM = 0x73010001,
+  PL_SUBSYSTEM = 0x73010002,
+  TCS_SUBSYSTEM = 0x73010003,
+  COM_SUBSYSTEM = 0x73010004,
+
+  TM_FUNNEL = 0x73000100,
+  PUS_TM_FUNNEL = 0x73000101,
+  CFDP_TM_FUNNEL = 0x73000102,
+  CFDP_HANDLER = 0x73000205,
+  CFDP_DISTRIBUTOR = 0x73000206,
 };
 }

--- a/dummies/CMakeLists.txt
+++ b/dummies/CMakeLists.txt
@ -12,6 +12,8 @@ target_sources(
         AcuDummy.cpp
         PduDummy.cpp
         P60DockDummy.cpp
+         SaDeploymentDummy.cpp
+         GpsDummy.cpp
         GyroAdisDummy.cpp
         GyroL3GD20Dummy.cpp
         MgmLIS3MDLDummy.cpp
--- a/dummies/CoreControllerDummy.cpp
+++ b/dummies/CoreControllerDummy.cpp
@ -6,8 +6,7 @@
 #include <cmath>
 #include <cstdlib>

-CoreControllerDummy::CoreControllerDummy(object_id_t objectId)
-    : ExtendedControllerBase(objectId, objects::NO_OBJECT) {}
+CoreControllerDummy::CoreControllerDummy(object_id_t objectId) : ExtendedControllerBase(objectId) {}

 ReturnValue_t CoreControllerDummy::initialize() {
  static bool done = false;
--- a/dummies/GpsDummy.cpp
+++ b/dummies/GpsDummy.cpp
@ -0,0 +1,56 @@
+#include "GpsDummy.h"
+
+#include <mission/devices/devicedefinitions/GPSDefinitions.h>
+
+GpsDummy::GpsDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
+    : DeviceHandlerBase(objectId, comif, comCookie) {}
+
+GpsDummy::~GpsDummy() {}
+
+void GpsDummy::doStartUp() {}
+
+void GpsDummy::doShutDown() {}
+
+ReturnValue_t GpsDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) { return NOTHING_TO_SEND; }
+
+ReturnValue_t GpsDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t GpsDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                const uint8_t *commandData, size_t commandDataLen) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t GpsDummy::scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+                                     size_t *foundLen) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t GpsDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
+  return returnvalue::OK;
+}
+
+void GpsDummy::fillCommandAndReplyMap() {}
+
+uint32_t GpsDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
+
+ReturnValue_t GpsDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                                LocalDataPoolManager &poolManager) {
+  localDataPoolMap.emplace(GpsHyperion::LATITUDE, new PoolEntry<double>({0.0}, 1));
+  localDataPoolMap.emplace(GpsHyperion::LONGITUDE, new PoolEntry<double>({0.0}, 1));
+  localDataPoolMap.emplace(GpsHyperion::ALTITUDE, new PoolEntry<double>({0.0}));
+  localDataPoolMap.emplace(GpsHyperion::SPEED, new PoolEntry<double>({7684.2}));
+  localDataPoolMap.emplace(GpsHyperion::FIX_MODE, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(GpsHyperion::SATS_IN_USE, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(GpsHyperion::SATS_IN_VIEW, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(GpsHyperion::YEAR, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(GpsHyperion::MONTH, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(GpsHyperion::DAY, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(GpsHyperion::HOURS, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(GpsHyperion::MINUTES, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(GpsHyperion::SECONDS, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(GpsHyperion::UNIX_SECONDS, new PoolEntry<uint32_t>({0}));
+
+  return returnvalue::OK;
+}
--- a/dummies/GpsDummy.h
+++ b/dummies/GpsDummy.h
@ -0,0 +1,33 @@
+#ifndef DUMMIES_GPSDUMMY_H_
+#define DUMMIES_GPSDUMMY_H_
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+
+class GpsDummy : public DeviceHandlerBase {
+ public:
+  static const DeviceCommandId_t SIMPLE_COMMAND = 1;
+  static const DeviceCommandId_t PERIODIC_REPLY = 2;
+
+  static const uint8_t SIMPLE_COMMAND_DATA = 1;
+  static const uint8_t PERIODIC_REPLY_DATA = 2;
+
+  GpsDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  virtual ~GpsDummy();
+
+ protected:
+  void doStartUp() override;
+  void doShutDown() override;
+  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
+                                        size_t commandDataLen) override;
+  ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+                             size_t *foundLen) override;
+  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
+  void fillCommandAndReplyMap() override;
+  uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                        LocalDataPoolManager &poolManager) override;
+};
+
+#endif /* DUMMIES_GPSDUMMY_H_ */
--- a/dummies/GyroAdisDummy.cpp
+++ b/dummies/GyroAdisDummy.cpp
@ -40,6 +40,13 @@ uint32_t GyroAdisDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { r

 ReturnValue_t GyroAdisDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                     LocalDataPoolManager &poolManager) {
+  localDataPoolMap.emplace(ADIS1650X::ANG_VELOC_X, new PoolEntry<double>({-0.5}, true));
+  localDataPoolMap.emplace(ADIS1650X::ANG_VELOC_Y, new PoolEntry<double>({0.2}, true));
+  localDataPoolMap.emplace(ADIS1650X::ANG_VELOC_Z, new PoolEntry<double>({-1.2}, true));
+  localDataPoolMap.emplace(ADIS1650X::ACCELERATION_X, new PoolEntry<double>({0.0}));
+  localDataPoolMap.emplace(ADIS1650X::ACCELERATION_Y, new PoolEntry<double>({0.0}));
+  localDataPoolMap.emplace(ADIS1650X::ACCELERATION_Z, new PoolEntry<double>({0.0}));
  localDataPoolMap.emplace(ADIS1650X::TEMPERATURE, new PoolEntry<float>({0.0}));
+
  return returnvalue::OK;
 }
--- a/dummies/GyroL3GD20Dummy.cpp
+++ b/dummies/GyroL3GD20Dummy.cpp
@ -40,9 +40,9 @@ uint32_t GyroL3GD20Dummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) {

 ReturnValue_t GyroL3GD20Dummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                       LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(L3GD20H::ANG_VELOC_X, new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(L3GD20H::ANG_VELOC_Y, new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(L3GD20H::ANG_VELOC_Z, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(L3GD20H::ANG_VELOC_X, new PoolEntry<float>({1.2}, true));
+  localDataPoolMap.emplace(L3GD20H::ANG_VELOC_Y, new PoolEntry<float>({-0.1}, true));
+  localDataPoolMap.emplace(L3GD20H::ANG_VELOC_Z, new PoolEntry<float>({0.7}, true));
  localDataPoolMap.emplace(L3GD20H::TEMPERATURE, new PoolEntry<float>({0.0}));
  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) {}
@ -39,5 +39,9 @@ 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}));
+  localDataPoolMap.emplace(IMTQ::MGM_CAL_NT, new PoolEntry<float>({0.0, 0.0, 0.0}));
+  localDataPoolMap.emplace(IMTQ::ACTUATION_CAL_STATUS, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(IMTQ::MTM_RAW, new PoolEntry<float>({0.12, 0.76, -0.45}, true));
+  localDataPoolMap.emplace(IMTQ::ACTUATION_RAW_STATUS, new PoolEntry<uint8_t>({0}));
  return returnvalue::OK;
 }
--- a/dummies/MgmLIS3MDLDummy.cpp
+++ b/dummies/MgmLIS3MDLDummy.cpp
@ -41,5 +41,7 @@ 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}));
+  localDataPoolMap.emplace(MGMLIS3MDL::FIELD_STRENGTHS,
+                           new PoolEntry<float>({1.02, 0.56, -0.78}, true));
  return returnvalue::OK;
 }
--- a/dummies/MgmRm3100Dummy.cpp
+++ b/dummies/MgmRm3100Dummy.cpp
@ -36,5 +36,7 @@ uint32_t MgmRm3100Dummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) {

 ReturnValue_t MgmRm3100Dummy::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                                      LocalDataPoolManager& poolManager) {
-  return OK;
+  localDataPoolMap.emplace(RM3100::FIELD_STRENGTHS,
+                           new PoolEntry<float>({0.87, -0.95, 0.11}, true));
+  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
@ -41,5 +41,29 @@ 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}));
+
+  localDataPoolMap.emplace(startracker::TICKS_SOLUTION_SET, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(startracker::TIME_SOLUTION_SET, new PoolEntry<uint64_t>({0}));
+  localDataPoolMap.emplace(startracker::CALI_QW, new PoolEntry<float>({1.0}, true));
+  localDataPoolMap.emplace(startracker::CALI_QX, new PoolEntry<float>({0.0}, true));
+  localDataPoolMap.emplace(startracker::CALI_QY, new PoolEntry<float>({0.0}, true));
+  localDataPoolMap.emplace(startracker::CALI_QZ, new PoolEntry<float>({0.0}, true));
+  localDataPoolMap.emplace(startracker::TRACK_CONFIDENCE, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(startracker::TRACK_QW, new PoolEntry<float>({1.0}));
+  localDataPoolMap.emplace(startracker::TRACK_QX, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(startracker::TRACK_QY, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(startracker::TRACK_QZ, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(startracker::TRACK_REMOVED, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(startracker::STARS_CENTROIDED, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(startracker::STARS_MATCHED_DATABASE, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(startracker::LISA_QW, new PoolEntry<float>({1.0}));
+  localDataPoolMap.emplace(startracker::LISA_QX, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(startracker::LISA_QY, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(startracker::LISA_QZ, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(startracker::LISA_PERC_CLOSE, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(startracker::LISA_NR_CLOSE, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(startracker::TRUST_WORTHY, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(startracker::STABLE_COUNT, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(startracker::SOLUTION_STRATEGY, new PoolEntry<uint8_t>({0}));
  return returnvalue::OK;
 }
--- a/dummies/SusDummy.cpp
+++ b/dummies/SusDummy.cpp
@ -1,80 +1,43 @@
 #include "SusDummy.h"

-#include <objects/systemObjectList.h>
+SusDummy::SusDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
+    : DeviceHandlerBase(objectId, comif, comCookie), susSet(this) {}

-#include <cmath>
-#include <cstdlib>
+SusDummy::~SusDummy() {}

-SusDummy::SusDummy()
-    : ExtendedControllerBase(objects::SUS_0_N_LOC_XFYFZM_PT_XF, objects::NO_OBJECT), susSet(this) {
-  ObjectManager::instance()->insert(objects::SUS_6_R_LOC_XFYBZM_PT_XF, this);
-  ObjectManager::instance()->insert(objects::SUS_1_N_LOC_XBYFZM_PT_XB, this);
-  ObjectManager::instance()->insert(objects::SUS_7_R_LOC_XBYBZM_PT_XB, this);
-  ObjectManager::instance()->insert(objects::SUS_2_N_LOC_XFYBZB_PT_YB, this);
-  ObjectManager::instance()->insert(objects::SUS_8_R_LOC_XBYBZB_PT_YB, this);
-  ObjectManager::instance()->insert(objects::SUS_3_N_LOC_XFYBZF_PT_YF, this);
-  ObjectManager::instance()->insert(objects::SUS_9_R_LOC_XBYBZB_PT_YF, this);
-  ObjectManager::instance()->insert(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, this);
-  ObjectManager::instance()->insert(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, this);
-  ObjectManager::instance()->insert(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, this);
-  ObjectManager::instance()->insert(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, this);
+void SusDummy::doStartUp() {}
+
+void SusDummy::doShutDown() {}
+
+ReturnValue_t SusDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) { return NOTHING_TO_SEND; }
+
+ReturnValue_t SusDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
 }

-ReturnValue_t SusDummy::initialize() {
-  static bool done = false;
-  if (not done) {
-    done = true;
-    ReturnValue_t result = ExtendedControllerBase::initialize();
-    if (result != returnvalue::OK) {
-      return result;
-    }
-  }
-
+ReturnValue_t SusDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                const uint8_t *commandData, size_t commandDataLen) {
  return returnvalue::OK;
 }

-ReturnValue_t SusDummy::handleCommandMessage(CommandMessage* message) {
-  return returnvalue::FAILED;
+ReturnValue_t SusDummy::scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+                                     size_t *foundLen) {
+  return returnvalue::OK;
 }

-void SusDummy::performControlOperation() {
-  iteration++;
-  value = sin(iteration / 80. * M_PI + 10) * 10 - 10;
-
-  susSet.read();
-  susSet.temperatureCelcius = value;
-  if ((iteration % 100) < 20) {
-    susSet.setValidity(false, true);
-  } else {
-    susSet.setValidity(true, true);
-  }
-  susSet.commit();
+ReturnValue_t SusDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
+  return returnvalue::OK;
 }

-ReturnValue_t SusDummy::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
-                                                LocalDataPoolManager& poolManager) {
+void SusDummy::fillCommandAndReplyMap() {}
+
+uint32_t SusDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
+
+ReturnValue_t SusDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                                LocalDataPoolManager &poolManager) {
  localDataPoolMap.emplace(SUS::SusPoolIds::TEMPERATURE_C, new PoolEntry<float>({0}, 1, true));
-  localDataPoolMap.emplace(SUS::SusPoolIds::CHANNEL_VEC, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(SUS::SusPoolIds::CHANNEL_VEC,
+                           new PoolEntry<uint16_t>({0, 0, 0, 0, 0, 0}, true));

  return returnvalue::OK;
 }
-
-LocalPoolDataSetBase* SusDummy::getDataSetHandle(sid_t sid) {
-  switch (sid.ownerSetId) {
-    case SUS::SUS_DATA_SET_ID:
-      return &susSet;
-    default:
-      return nullptr;
-  }
-}
-
-ReturnValue_t SusDummy::checkModeCommand(Mode_t mode, Submode_t submode,
-                                         uint32_t* msToReachTheMode) {
-  if (submode != SUBMODE_NONE) {
-    return INVALID_SUBMODE;
-  }
-  if ((mode != MODE_OFF) && (mode != MODE_ON) && (mode != MODE_NORMAL)) {
-    return INVALID_MODE;
-  }
-  return returnvalue::OK;
-}
--- a/dummies/SusDummy.h
+++ b/dummies/SusDummy.h
@ -1,27 +1,36 @@
-#pragma once
+#ifndef DUMMIES_SUSDUMMY_H_
+#define DUMMIES_SUSDUMMY_H_

-#include <fsfw/controller/ExtendedControllerBase.h>
-#include <mission/devices/devicedefinitions/SusDefinitions.h>
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>

-class SusDummy : public ExtendedControllerBase {
+#include "mission/devices/devicedefinitions/SusDefinitions.h"
+
+class SusDummy : public DeviceHandlerBase {
 public:
-  SusDummy();
+  static const DeviceCommandId_t SIMPLE_COMMAND = 1;
+  static const DeviceCommandId_t PERIODIC_REPLY = 2;

-  ReturnValue_t initialize() override;
+  static const uint8_t SIMPLE_COMMAND_DATA = 1;
+  static const uint8_t PERIODIC_REPLY_DATA = 2;
+
+  SusDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  virtual ~SusDummy();

 protected:
-  virtual ReturnValue_t handleCommandMessage(CommandMessage* message) override;
-  virtual void performControlOperation() override;
-  virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
-                                                LocalDataPoolManager& poolManager) override;
-  virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
-
-  // Mode abstract functions
-  virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-                                         uint32_t* msToReachTheMode) override;
-
- private:
-  int iteration = 0;
-  float value = 0;
  SUS::SusDataset susSet;
-};
+  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_SUSDUMMY_H_ */
--- 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,12 @@ 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);
+
+  ObjectManager::instance()->insert(objects::TMP1075_HANDLER_PLPCDU_0, this);
+  ObjectManager::instance()->insert(objects::TMP1075_HANDLER_PLPCDU_1, this);
+  ObjectManager::instance()->insert(objects::TMP1075_HANDLER_IF_BOARD, this);
 }

 ReturnValue_t TemperatureSensorsDummy::initialize() {
--- a/dummies/helpers.cpp
+++ b/dummies/helpers.cpp
@ -5,6 +5,7 @@
 #include <dummies/ComCookieDummy.h>
 #include <dummies/ComIFDummy.h>
 #include <dummies/CoreControllerDummy.h>
+#include <dummies/GpsDummy.h>
 #include <dummies/GyroAdisDummy.h>
 #include <dummies/GyroL3GD20Dummy.h>
 #include <dummies/ImtqDummy.h>
@ -14,14 +15,16 @@
 #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>
+#include <mission/system/objects/CamSwitcher.h>

 using namespace dummy;

-void dummy::createDummies(DummyCfg cfg) {
+void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitch) {
  new ComIFDummy(objects::DUMMY_COM_IF);
  ComCookieDummy* comCookieDummy = new ComCookieDummy();
  new BpxDummy(objects::BPX_BATT_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
@ -35,8 +38,11 @@ void dummy::createDummies(DummyCfg cfg) {
  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);
-  new SyrlinksDummy(objects::SYRLINKS_HK_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  if (cfg.addSyrlinksDummies) {
+    new SyrlinksDummy(objects::SYRLINKS_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);
@ -54,14 +60,27 @@ void dummy::createDummies(DummyCfg cfg) {
    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);
+    new GpsDummy(objects::GPS_CONTROLLER, objects::DUMMY_COM_IF, comCookieDummy);
  }

  if (cfg.addSusDummies) {
-    new SusDummy();
+    new SusDummy(objects::SUS_0_N_LOC_XFYFZM_PT_XF, objects::DUMMY_COM_IF, comCookieDummy);
+    new SusDummy(objects::SUS_1_N_LOC_XBYFZM_PT_XB, objects::DUMMY_COM_IF, comCookieDummy);
+    new SusDummy(objects::SUS_2_N_LOC_XFYBZB_PT_YB, objects::DUMMY_COM_IF, comCookieDummy);
+    new SusDummy(objects::SUS_3_N_LOC_XFYBZF_PT_YF, objects::DUMMY_COM_IF, comCookieDummy);
+    new SusDummy(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, objects::DUMMY_COM_IF, comCookieDummy);
+    new SusDummy(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, objects::DUMMY_COM_IF, comCookieDummy);
+    new SusDummy(objects::SUS_6_R_LOC_XFYBZM_PT_XF, objects::DUMMY_COM_IF, comCookieDummy);
+    new SusDummy(objects::SUS_7_R_LOC_XBYBZM_PT_XB, objects::DUMMY_COM_IF, comCookieDummy);
+    new SusDummy(objects::SUS_8_R_LOC_XBYBZB_PT_YB, objects::DUMMY_COM_IF, comCookieDummy);
+    new SusDummy(objects::SUS_9_R_LOC_XBYBZB_PT_YF, objects::DUMMY_COM_IF, comCookieDummy);
+    new SusDummy(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, objects::DUMMY_COM_IF, comCookieDummy);
+    new SusDummy(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, objects::DUMMY_COM_IF, comCookieDummy);
  }

  if (cfg.addTempSensorDummies) {
    new TemperatureSensorsDummy();
  }
+  new CamSwitcher(objects::CAM_SWITCHER, pwrSwitch, power::NO_SWITCH);
  new PlPcduDummy(objects::PLPCDU_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
 }
--- a/dummies/helpers.h
+++ b/dummies/helpers.h
@ -1,16 +1,19 @@
 #pragma once

+#include <fsfw/power/PowerSwitchIF.h>
+
 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);
+void createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitch);

 }  // namespace dummy
--- a/2
+++ b/2
--- a/generators/bsp_q7s_events.csv
+++ b/generators/bsp_q7s_events.csv
@ -76,10 +76,15 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 7903;0x1edf;BIT_LOCK_LOST;INFO;A previously found Bit Lock signal was lost. P1: raw BLO state, P2: 0;fsfw/src/fsfw/datalinklayer/DataLinkLayer.h
 7905;0x1ee1;FRAME_PROCESSING_FAILED;LOW;The CCSDS Board could not interpret a TC;fsfw/src/fsfw/datalinklayer/DataLinkLayer.h
 8900;0x22c4;CLOCK_SET;INFO;;fsfw/src/fsfw/pus/Service9TimeManagement.h
-8901;0x22c5;CLOCK_SET_FAILURE;LOW;;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8901;0x22c5;CLOCK_DUMP;INFO;;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8902;0x22c6;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/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
+11200;0x2bc0;SAFE_RATE_VIOLATION;MEDIUM;;mission/controller/AcsController.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
@ -92,45 +97,53 @@ 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
 11902;0x2e7e;BOOTING_BOOTLOADER_FAILED;LOW;Failed to boot star tracker into bootloader mode;linux/devices/startracker/StarTrackerHandler.h
 12001;0x2ee1;SUPV_MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC supervisor crc failure in telemetry packet;linux/devices/ploc/PlocSupervisorHandler.h
-12002;0x2ee2;SUPV_ACK_FAILURE;LOW;PLOC supervisor received acknowledgment failure report;linux/devices/ploc/PlocSupervisorHandler.h
-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
+12002;0x2ee2;SUPV_UNKNOWN_TM;LOW;Unhandled event. P1: APID, P2: Service ID;linux/devices/ploc/PlocSupervisorHandler.h
+12003;0x2ee3;SUPV_UNINIMPLEMENTED_TM;LOW;;linux/devices/ploc/PlocSupervisorHandler.h
+12004;0x2ee4;SUPV_ACK_FAILURE;LOW;PLOC supervisor received acknowledgment failure report;linux/devices/ploc/PlocSupervisorHandler.h
+12005;0x2ee5;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
+12006;0x2ee6;SUPV_CRC_FAILURE_EVENT;LOW;PLOC supervisor reply has invalid crc;linux/devices/ploc/PlocSupervisorHandler.h
+12007;0x2ee7;SUPV_HELPER_EXECUTING;LOW;Supervisor helper currently executing a command;linux/devices/ploc/PlocSupervisorHandler.h
+12008;0x2ee8;SUPV_MPSOC_SHUTDOWN_BUILD_FAILED;LOW;Failed to build the command to shutdown the MPSoC;linux/devices/ploc/PlocSupervisorHandler.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
@ -174,48 +187,49 @@ 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
 13202;0x3392;BATT_MODE_CHANGED;MEDIUM;Battery mode has changed. P1: Old mode. P2: New mode;mission/devices/P60DockHandler.h
-13600;0x3520;SUPV_UPDATE_FAILED;LOW;update failed;linux/devices/ploc/PlocSupvHelper.h
-13601;0x3521;SUPV_UPDATE_SUCCESSFUL;LOW;update successful;linux/devices/ploc/PlocSupvHelper.h
-13602;0x3522;SUPV_CONTINUE_UPDATE_FAILED;LOW;Continue update command failed;linux/devices/ploc/PlocSupvHelper.h
-13603;0x3523;SUPV_CONTINUE_UPDATE_SUCCESSFUL;LOW;Continue update command successful;linux/devices/ploc/PlocSupvHelper.h
-13604;0x3524;TERMINATED_UPDATE_PROCEDURE;LOW;Terminated update procedure by command;linux/devices/ploc/PlocSupvHelper.h
-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_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
+13600;0x3520;SUPV_UPDATE_FAILED;LOW;update failed;linux/devices/ploc/PlocSupvUartMan.h
+13601;0x3521;SUPV_UPDATE_SUCCESSFUL;LOW;update successful;linux/devices/ploc/PlocSupvUartMan.h
+13602;0x3522;SUPV_CONTINUE_UPDATE_FAILED;LOW;Continue update command failed;linux/devices/ploc/PlocSupvUartMan.h
+13603;0x3523;SUPV_CONTINUE_UPDATE_SUCCESSFUL;LOW;Continue update command successful;linux/devices/ploc/PlocSupvUartMan.h
+13604;0x3524;TERMINATED_UPDATE_PROCEDURE;LOW;Terminated update procedure by command;linux/devices/ploc/PlocSupvUartMan.h
+13605;0x3525;SUPV_EVENT_BUFFER_REQUEST_SUCCESSFUL;LOW;Requesting event buffer was successful;linux/devices/ploc/PlocSupvUartMan.h
+13606;0x3526;SUPV_EVENT_BUFFER_REQUEST_FAILED;LOW;Requesting event buffer failed;linux/devices/ploc/PlocSupvUartMan.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/PlocSupvUartMan.h
+13608;0x3528;SUPV_MEM_CHECK_OK;INFO;;linux/devices/ploc/PlocSupvUartMan.h
+13609;0x3529;SUPV_MEM_CHECK_FAIL;INFO;;linux/devices/ploc/PlocSupvUartMan.h
+13616;0x3530;SUPV_SENDING_COMMAND_FAILED;LOW;;linux/devices/ploc/PlocSupvUartMan.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/PlocSupvUartMan.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/PlocSupvUartMan.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/PlocSupvUartMan.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/PlocSupvUartMan.h
+13621;0x3535;SUPV_ACK_FAILURE_REPORT;LOW;Supervisor received acknowledgment failure report P1: Internal state of supervisor helper;linux/devices/ploc/PlocSupvUartMan.h
+13622;0x3536;SUPV_EXE_FAILURE_REPORT;LOW;Execution report failure P1:;linux/devices/ploc/PlocSupvUartMan.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/PlocSupvUartMan.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/PlocSupvUartMan.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/PlocSupvUartMan.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/PlocSupvUartMan.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/PlocSupvUartMan.h
+13628;0x353c;SUPV_REPLY_SIZE_MISSMATCH;LOW;;linux/devices/ploc/PlocSupvUartMan.h
+13629;0x353d;SUPV_REPLY_CRC_MISSMATCH;LOW;;linux/devices/ploc/PlocSupvUartMan.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/PlocSupvUartMan.h
+13631;0x353f;HDLC_FRAME_REMOVAL_ERROR;INFO;;linux/devices/ploc/PlocSupvUartMan.h
+13632;0x3540;HDLC_CRC_ERROR;INFO;;linux/devices/ploc/PlocSupvUartMan.h
+13700;0x3584;FDIR_REACTION_IGNORED;MEDIUM;;mission/devices/devicedefinitions/SyrlinksDefinitions.h
+13701;0x3585;TX_ON;INFO;Transmitter is on now. P1: Submode, P2: Current default datarate.;mission/devices/devicedefinitions/SyrlinksDefinitions.h
+13702;0x3586;TX_OFF;INFO;Transmitter is off now.;mission/devices/devicedefinitions/SyrlinksDefinitions.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
@ -224,3 +238,8 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 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
+14000;0x36b0;ALLOC_FAILURE;MEDIUM;;bsp_q7s/core/CoreController.h
+14001;0x36b1;REBOOT_SW;MEDIUM; Software reboot occurred. Can also be a systemd reboot. P1: Current Chip, P2: Current Copy;bsp_q7s/core/CoreController.h
+14002;0x36b2;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
+14003;0x36b3;REBOOT_HW;MEDIUM;;bsp_q7s/core/CoreController.h
+14004;0x36b4;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
--- a/generators/bsp_q7s_objects.csv
+++ b/generators/bsp_q7s_objects.csv
@ -50,8 +50,12 @@
 0x44330032;SCEX
 0x444100A2;SOLAR_ARRAY_DEPL_HANDLER
 0x444100A4;HEATER_HANDLER
-0x44420004;TMP1075_HANDLER_1
-0x44420005;TMP1075_HANDLER_2
+0x44420004;TMP1075_HANDLER_TCS_0
+0x44420005;TMP1075_HANDLER_TCS_1
+0x44420006;TMP1075_HANDLER_PLPCDU_0
+0x44420007;TMP1075_HANDLER_PLPCDU_1
+0x44420008;TMP1075_HANDLER_IF_BOARD
+0x44420009;TMP1075_HANDLER_OBC_IF_BOARD
 0x44420016;RTD_0_IC3_PLOC_HEATSPREADER
 0x44420017;RTD_1_IC4_PLOC_MISSIONBOARD
 0x44420018;RTD_2_IC5_4K_CAMERA
@ -68,7 +72,7 @@
 0x44420029;RTD_13_IC16_PLPCDU_HEATSPREADER
 0x44420030;RTD_14_IC17_TCS_BOARD
 0x44420031;RTD_15_IC18_IMTQ
-0x445300A3;SYRLINKS_HK_HANDLER
+0x445300A3;SYRLINKS_HANDLER
 0x49000000;ARDUINO_COM_IF
 0x49010005;GPIO_IF
 0x49010006;SCEX_UART_READER
@ -80,8 +84,10 @@
 0x49050001;CSP_COM_IF
 0x50000100;CCSDS_PACKET_DISTRIBUTOR
 0x50000200;PUS_PACKET_DISTRIBUTOR
-0x50000300;TMTC_BRIDGE
-0x50000400;TMTC_POLLING_TASK
+0x50000300;TCP_TMTC_SERVER
+0x50000301;UDP_TMTC_SERVER
+0x50000400;TCP_TMTC_POLLING_TASK
+0x50000401;UDP_TMTC_POLLING_TASK
 0x50000500;FILE_SYSTEM_HANDLER
 0x50000550;SDC_MANAGER
 0x50000600;PTME
@ -131,8 +137,16 @@
 0x73000002;SUS_BOARD_ASS
 0x73000003;TCS_BOARD_ASS
 0x73000004;RW_ASS
-0x73000005;CFDP_HANDLER
-0x73000006;CFDP_DISTRIBUTOR
+0x73000006;CAM_SWITCHER
 0x73000100;TM_FUNNEL
+0x73000101;PUS_TM_FUNNEL
+0x73000102;CFDP_TM_FUNNEL
+0x73000205;CFDP_HANDLER
+0x73000206;CFDP_DISTRIBUTOR
+0x73010000;EIVE_SYSTEM
+0x73010001;ACS_SUBSYSTEM
+0x73010002;PL_SUBSYSTEM
+0x73010003;TCS_SUBSYSTEM
+0x73010004;COM_SUBSYSTEM
 0x73500000;CCSDS_IP_CORE_BRIDGE
 0xFFFFFFFF;NO_OBJECT
--- a/generators/bsp_q7s_returnvalues.csv
+++ b/generators/bsp_q7s_returnvalues.csv
@ -2,6 +2,7 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x0000;OK;System-wide code for ok.;0;HasReturnvaluesIF;fsfw/returnvalues/returnvalue.h
 0x0001;Failed;Unspecified system-wide code for failed.;1;HasReturnvaluesIF;fsfw/returnvalues/returnvalue.h
 0x63a0;NVMB_KeyNotExists;Specified key does not exist in json file;160;NVM_PARAM_BASE;mission/memory/NVMParameterBase.h
+0x6300;NVMB_Busy;;0;NVM_PARAM_BASE;mission/system/objects/Stack5VHandler.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
@ -9,6 +10,14 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 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
@ -21,35 +30,30 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x52a2;RWHA_SetSpeedCommandInvalidLength;Received set speed command has invalid length. Should be 6.;162;RW_HANDLER;mission/devices/RwHandler.h
 0x52a3;RWHA_ExecutionFailed;Command execution failed;163;RW_HANDLER;mission/devices/RwHandler.h
 0x52a4;RWHA_CrcError;Reaction wheel reply has invalid crc;164;RW_HANDLER;mission/devices/RwHandler.h
+0x50a0;SYRLINKS_CrcFailure;;160;SYRLINKS_HANDLER;mission/devices/SyrlinksHandler.h
+0x50a1;SYRLINKS_UartFraminOrParityErrorAck;;161;SYRLINKS_HANDLER;mission/devices/SyrlinksHandler.h
+0x50a2;SYRLINKS_BadCharacterAck;;162;SYRLINKS_HANDLER;mission/devices/SyrlinksHandler.h
+0x50a3;SYRLINKS_BadParameterValueAck;;163;SYRLINKS_HANDLER;mission/devices/SyrlinksHandler.h
+0x50a4;SYRLINKS_BadEndOfFrameAck;;164;SYRLINKS_HANDLER;mission/devices/SyrlinksHandler.h
+0x50a5;SYRLINKS_UnknownCommandIdAck;;165;SYRLINKS_HANDLER;mission/devices/SyrlinksHandler.h
+0x50a6;SYRLINKS_BadCrcAck;;166;SYRLINKS_HANDLER;mission/devices/SyrlinksHandler.h
+0x50a7;SYRLINKS_ReplyWrongSize;;167;SYRLINKS_HANDLER;mission/devices/SyrlinksHandler.h
+0x50a8;SYRLINKS_MissingStartFrameCharacter;;168;SYRLINKS_HANDLER;mission/devices/SyrlinksHandler.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
-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
-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/CCSDSHandler.h
+0x60a0;CCSDS_CommandNotImplemented;Received action message with unknown action id;160;CCSDS_HANDLER;mission/tmtc/CcsdsIpCoreHandler.h
+0x6001;CCSDS_KalmanNoGyrMeas;;1;CCSDS_HANDLER;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6002;CCSDS_KalmanNoModel;;2;CCSDS_HANDLER;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6003;CCSDS_KalmanInversionFailed;;3;CCSDS_HANDLER;mission/controller/acs/MultiplicativeKalmanFilter.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
@ -60,9 +64,9 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 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/uart/UartComIF.h
-0x4602;HURT_UartReadSizeMissmatch;;2;HAL_UART;fsfw/src/fsfw_hal/linux/uart/UartComIF.h
-0x4603;HURT_UartRxBufferTooSmall;;3;HAL_UART;fsfw/src/fsfw_hal/linux/uart/UartComIF.h
+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
@ -101,10 +105,6 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 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
-0x1101;AL_Full;;1;ARRAY_LIST;fsfw/src/fsfw/container/ArrayList.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
 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
@ -325,6 +325,7 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 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
@ -372,6 +373,8 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 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
+0x4205;PUS11_ContainedTcTooSmall;;5;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4206;PUS11_ContainedTcCrcMissmatch;;6;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
--- a/generators/events/event_parser.py
+++ b/generators/events/event_parser.py
@ -46,7 +46,7 @@ BSP_DIR_NAME = BSP_SELECT.value

 # Store this file in the root of the generators folder
 CSV_FILENAME = Path(f"{ROOT_DIR}/{BSP_SELECT.value}_events.csv")
-CSV_COPY_DEST = Path(f"{OBSW_ROOT_DIR}/tmtc/config/events.csv")
+CSV_COPY_DEST = Path(f"{OBSW_ROOT_DIR}/tmtc/eive_tmtc/config/events.csv")

 if BSP_SELECT == BspType.BSP_Q7S or BSP_SELECT == BspType.BSP_LINUX_BOARD:
    FSFW_CONFIG_ROOT = Path(f"{OBSW_ROOT_DIR}/linux/fsfwconfig")
--- a/generators/events/translateEvents.cpp
+++ b/generators/events/translateEvents.cpp
@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 225 translations.
+ * @brief    Auto-generated event translation file. Contains 244 translations.
 * @details
- * Generated on: 2022-10-10 11:15:49
+ * Generated on: 2023-02-01 19:42:11
 */
 #include "translateEvents.h"

@ -82,10 +82,15 @@ const char *BIT_LOCK_STRING = "BIT_LOCK";
 const char *BIT_LOCK_LOST_STRING = "BIT_LOCK_LOST";
 const char *FRAME_PROCESSING_FAILED_STRING = "FRAME_PROCESSING_FAILED";
 const char *CLOCK_SET_STRING = "CLOCK_SET";
+const char *CLOCK_DUMP_STRING = "CLOCK_DUMP";
 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 *SAFE_RATE_VIOLATION_STRING = "SAFE_RATE_VIOLATION";
 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";
@ -98,11 +103,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";
@ -122,10 +131,13 @@ const char *RESET_OCCURED_STRING = "RESET_OCCURED";
 const char *BOOTING_FIRMWARE_FAILED_STRING = "BOOTING_FIRMWARE_FAILED";
 const char *BOOTING_BOOTLOADER_FAILED_STRING = "BOOTING_BOOTLOADER_FAILED";
 const char *SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING = "SUPV_MEMORY_READ_RPT_CRC_FAILURE";
+const char *SUPV_UNKNOWN_TM_STRING = "SUPV_UNKNOWN_TM";
+const char *SUPV_UNINIMPLEMENTED_TM_STRING = "SUPV_UNINIMPLEMENTED_TM";
 const char *SUPV_ACK_FAILURE_STRING = "SUPV_ACK_FAILURE";
 const char *SUPV_EXE_FAILURE_STRING = "SUPV_EXE_FAILURE";
 const char *SUPV_CRC_FAILURE_EVENT_STRING = "SUPV_CRC_FAILURE_EVENT";
-const char *SUPV_MPSOC_SHUWDOWN_BUILD_FAILED_STRING = "SUPV_MPSOC_SHUWDOWN_BUILD_FAILED";
+const char *SUPV_HELPER_EXECUTING_STRING = "SUPV_HELPER_EXECUTING";
+const char *SUPV_MPSOC_SHUTDOWN_BUILD_FAILED_STRING = "SUPV_MPSOC_SHUTDOWN_BUILD_FAILED";
 const char *SANITIZATION_FAILED_STRING = "SANITIZATION_FAILED";
 const char *MOUNTED_SD_CARD_STRING = "MOUNTED_SD_CARD";
 const char *SEND_MRAM_DUMP_FAILED_STRING = "SEND_MRAM_DUMP_FAILED";
@ -137,6 +149,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";
@ -214,10 +227,10 @@ 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 *HDLC_FRAME_REMOVAL_ERROR_STRING = "HDLC_FRAME_REMOVAL_ERROR";
+const char *HDLC_CRC_ERROR_STRING = "HDLC_CRC_ERROR";
+const char *TX_ON_STRING = "TX_ON";
+const char *TX_OFF_STRING = "TX_OFF";
 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";
@ -226,6 +239,11 @@ 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 *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 *translateEvents(Event event) {
  switch ((event & 0xFFFF)) {
@ -384,6 +402,8 @@ const char *translateEvents(Event event) {
    case (8900):
      return CLOCK_SET_STRING;
    case (8901):
+      return CLOCK_DUMP_STRING;
+    case (8902):
      return CLOCK_SET_FAILURE_STRING;
    case (9100):
      return TC_DELETION_FAILED_STRING;
@ -391,6 +411,14 @@ 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 (11200):
+      return SAFE_RATE_VIOLATION_STRING;
    case (11300):
      return SWITCH_CMD_SENT_STRING;
    case (11301):
@ -416,15 +444,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):
@ -464,13 +500,19 @@ const char *translateEvents(Event event) {
    case (12001):
      return SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING;
    case (12002):
-      return SUPV_ACK_FAILURE_STRING;
+      return SUPV_UNKNOWN_TM_STRING;
    case (12003):
-      return SUPV_EXE_FAILURE_STRING;
+      return SUPV_UNINIMPLEMENTED_TM_STRING;
    case (12004):
-      return SUPV_CRC_FAILURE_EVENT_STRING;
+      return SUPV_ACK_FAILURE_STRING;
    case (12005):
-      return SUPV_MPSOC_SHUWDOWN_BUILD_FAILED_STRING;
+      return SUPV_EXE_FAILURE_STRING;
+    case (12006):
+      return SUPV_CRC_FAILURE_EVENT_STRING;
+    case (12007):
+      return SUPV_HELPER_EXECUTING_STRING;
+    case (12008):
+      return SUPV_MPSOC_SHUTDOWN_BUILD_FAILED_STRING;
    case (12100):
      return SANITIZATION_FAILED_STRING;
    case (12101):
@ -493,6 +535,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):
@ -647,14 +691,14 @@ const char *translateEvents(Event event) {
      return SUPV_REPLY_CRC_MISSMATCH_STRING;
    case (13630):
      return SUPV_UPDATE_PROGRESS_STRING;
-    case (13700):
-      return ALLOC_FAILURE_STRING;
+    case (13631):
+      return HDLC_FRAME_REMOVAL_ERROR_STRING;
+    case (13632):
+      return HDLC_CRC_ERROR_STRING;
    case (13701):
-      return REBOOT_SW_STRING;
+      return TX_ON_STRING;
    case (13702):
-      return REBOOT_MECHANISM_TRIGGERED_STRING;
-    case (13703):
-      return REBOOT_HW_STRING;
+      return TX_OFF_STRING;
    case (13800):
      return MISSING_PACKET_STRING;
    case (13801):
@ -671,6 +715,16 @@ const char *translateEvents(Event event) {
      return WRITE_CONFIGFILE_FAILED_STRING;
    case (13905):
      return READ_CONFIGFILE_FAILED_STRING;
+    case (14000):
+      return ALLOC_FAILURE_STRING;
+    case (14001):
+      return REBOOT_SW_STRING;
+    case (14002):
+      return REBOOT_MECHANISM_TRIGGERED_STRING;
+    case (14003):
+      return REBOOT_HW_STRING;
+    case (14004):
+      return NO_SD_CARD_ACTIVE_STRING;
    default:
      return "UNKNOWN_EVENT";
  }
--- a/generators/objects/objects.py
+++ b/generators/objects/objects.py
@ -43,7 +43,7 @@ CPP_COPY_DESTINATION = f"{FSFW_CONFIG_ROOT}/objects/"
 CPP_FILENAME = f"{os.path.dirname(os.path.realpath(__file__))}//translateObjects.cpp"
 CPP_H_FILENAME = f"{os.path.dirname(os.path.realpath(__file__))}//translateObjects.h"
 CSV_OBJECT_FILENAME = f"{ROOT_DIR}/{BSP_SELECT.value}_objects.csv"
-CSV_COPY_DEST = f"{OBSW_ROOT_DIR}/tmtc/config/objects.csv"
+CSV_COPY_DEST = f"{OBSW_ROOT_DIR}/tmtc/eive_tmtc/config/objects.csv"
 FILE_SEPARATOR = ";"


--- a/generators/objects/translateObjects.cpp
+++ b/generators/objects/translateObjects.cpp
@ -1,8 +1,8 @@
 /**
 * @brief  Auto-generated object translation file.
 * @details
- * Contains 138 translations.
- * Generated on: 2022-10-10 11:15:49
+ * Contains 152 translations.
+ * Generated on: 2023-02-01 19:42:11
 */
 #include "translateObjects.h"

@ -58,8 +58,12 @@ const char *PLOC_SUPERVISOR_HELPER_STRING = "PLOC_SUPERVISOR_HELPER";
 const char *SCEX_STRING = "SCEX";
 const char *SOLAR_ARRAY_DEPL_HANDLER_STRING = "SOLAR_ARRAY_DEPL_HANDLER";
 const char *HEATER_HANDLER_STRING = "HEATER_HANDLER";
-const char *TMP1075_HANDLER_1_STRING = "TMP1075_HANDLER_1";
-const char *TMP1075_HANDLER_2_STRING = "TMP1075_HANDLER_2";
+const char *TMP1075_HANDLER_TCS_0_STRING = "TMP1075_HANDLER_TCS_0";
+const char *TMP1075_HANDLER_TCS_1_STRING = "TMP1075_HANDLER_TCS_1";
+const char *TMP1075_HANDLER_PLPCDU_0_STRING = "TMP1075_HANDLER_PLPCDU_0";
+const char *TMP1075_HANDLER_PLPCDU_1_STRING = "TMP1075_HANDLER_PLPCDU_1";
+const char *TMP1075_HANDLER_IF_BOARD_STRING = "TMP1075_HANDLER_IF_BOARD";
+const char *TMP1075_HANDLER_OBC_IF_BOARD_STRING = "TMP1075_HANDLER_OBC_IF_BOARD";
 const char *RTD_0_IC3_PLOC_HEATSPREADER_STRING = "RTD_0_IC3_PLOC_HEATSPREADER";
 const char *RTD_1_IC4_PLOC_MISSIONBOARD_STRING = "RTD_1_IC4_PLOC_MISSIONBOARD";
 const char *RTD_2_IC5_4K_CAMERA_STRING = "RTD_2_IC5_4K_CAMERA";
@ -76,7 +80,7 @@ const char *RTD_12_IC15_ACU_STRING = "RTD_12_IC15_ACU";
 const char *RTD_13_IC16_PLPCDU_HEATSPREADER_STRING = "RTD_13_IC16_PLPCDU_HEATSPREADER";
 const char *RTD_14_IC17_TCS_BOARD_STRING = "RTD_14_IC17_TCS_BOARD";
 const char *RTD_15_IC18_IMTQ_STRING = "RTD_15_IC18_IMTQ";
-const char *SYRLINKS_HK_HANDLER_STRING = "SYRLINKS_HK_HANDLER";
+const char *SYRLINKS_HANDLER_STRING = "SYRLINKS_HANDLER";
 const char *ARDUINO_COM_IF_STRING = "ARDUINO_COM_IF";
 const char *GPIO_IF_STRING = "GPIO_IF";
 const char *SCEX_UART_READER_STRING = "SCEX_UART_READER";
@ -88,8 +92,10 @@ const char *I2C_COM_IF_STRING = "I2C_COM_IF";
 const char *CSP_COM_IF_STRING = "CSP_COM_IF";
 const char *CCSDS_PACKET_DISTRIBUTOR_STRING = "CCSDS_PACKET_DISTRIBUTOR";
 const char *PUS_PACKET_DISTRIBUTOR_STRING = "PUS_PACKET_DISTRIBUTOR";
-const char *TMTC_BRIDGE_STRING = "TMTC_BRIDGE";
-const char *TMTC_POLLING_TASK_STRING = "TMTC_POLLING_TASK";
+const char *TCP_TMTC_SERVER_STRING = "TCP_TMTC_SERVER";
+const char *UDP_TMTC_SERVER_STRING = "UDP_TMTC_SERVER";
+const char *TCP_TMTC_POLLING_TASK_STRING = "TCP_TMTC_POLLING_TASK";
+const char *UDP_TMTC_POLLING_TASK_STRING = "UDP_TMTC_POLLING_TASK";
 const char *FILE_SYSTEM_HANDLER_STRING = "FILE_SYSTEM_HANDLER";
 const char *SDC_MANAGER_STRING = "SDC_MANAGER";
 const char *PTME_STRING = "PTME";
@ -139,9 +145,17 @@ const char *ACS_BOARD_ASS_STRING = "ACS_BOARD_ASS";
 const char *SUS_BOARD_ASS_STRING = "SUS_BOARD_ASS";
 const char *TCS_BOARD_ASS_STRING = "TCS_BOARD_ASS";
 const char *RW_ASS_STRING = "RW_ASS";
+const char *CAM_SWITCHER_STRING = "CAM_SWITCHER";
+const char *TM_FUNNEL_STRING = "TM_FUNNEL";
+const char *PUS_TM_FUNNEL_STRING = "PUS_TM_FUNNEL";
+const char *CFDP_TM_FUNNEL_STRING = "CFDP_TM_FUNNEL";
 const char *CFDP_HANDLER_STRING = "CFDP_HANDLER";
 const char *CFDP_DISTRIBUTOR_STRING = "CFDP_DISTRIBUTOR";
-const char *TM_FUNNEL_STRING = "TM_FUNNEL";
+const char *EIVE_SYSTEM_STRING = "EIVE_SYSTEM";
+const char *ACS_SUBSYSTEM_STRING = "ACS_SUBSYSTEM";
+const char *PL_SUBSYSTEM_STRING = "PL_SUBSYSTEM";
+const char *TCS_SUBSYSTEM_STRING = "TCS_SUBSYSTEM";
+const char *COM_SUBSYSTEM_STRING = "COM_SUBSYSTEM";
 const char *CCSDS_IP_CORE_BRIDGE_STRING = "CCSDS_IP_CORE_BRIDGE";
 const char *NO_OBJECT_STRING = "NO_OBJECT";

@ -252,9 +266,17 @@ const char *translateObject(object_id_t object) {
    case 0x444100A4:
      return HEATER_HANDLER_STRING;
    case 0x44420004:
-      return TMP1075_HANDLER_1_STRING;
+      return TMP1075_HANDLER_TCS_0_STRING;
    case 0x44420005:
-      return TMP1075_HANDLER_2_STRING;
+      return TMP1075_HANDLER_TCS_1_STRING;
+    case 0x44420006:
+      return TMP1075_HANDLER_PLPCDU_0_STRING;
+    case 0x44420007:
+      return TMP1075_HANDLER_PLPCDU_1_STRING;
+    case 0x44420008:
+      return TMP1075_HANDLER_IF_BOARD_STRING;
+    case 0x44420009:
+      return TMP1075_HANDLER_OBC_IF_BOARD_STRING;
    case 0x44420016:
      return RTD_0_IC3_PLOC_HEATSPREADER_STRING;
    case 0x44420017:
@ -288,7 +310,7 @@ const char *translateObject(object_id_t object) {
    case 0x44420031:
      return RTD_15_IC18_IMTQ_STRING;
    case 0x445300A3:
-      return SYRLINKS_HK_HANDLER_STRING;
+      return SYRLINKS_HANDLER_STRING;
    case 0x49000000:
      return ARDUINO_COM_IF_STRING;
    case 0x49010005:
@ -312,9 +334,13 @@ const char *translateObject(object_id_t object) {
    case 0x50000200:
      return PUS_PACKET_DISTRIBUTOR_STRING;
    case 0x50000300:
-      return TMTC_BRIDGE_STRING;
+      return TCP_TMTC_SERVER_STRING;
+    case 0x50000301:
+      return UDP_TMTC_SERVER_STRING;
    case 0x50000400:
-      return TMTC_POLLING_TASK_STRING;
+      return TCP_TMTC_POLLING_TASK_STRING;
+    case 0x50000401:
+      return UDP_TMTC_POLLING_TASK_STRING;
    case 0x50000500:
      return FILE_SYSTEM_HANDLER_STRING;
    case 0x50000550:
@ -413,12 +439,28 @@ const char *translateObject(object_id_t object) {
      return TCS_BOARD_ASS_STRING;
    case 0x73000004:
      return RW_ASS_STRING;
-    case 0x73000005:
-      return CFDP_HANDLER_STRING;
    case 0x73000006:
-      return CFDP_DISTRIBUTOR_STRING;
+      return CAM_SWITCHER_STRING;
    case 0x73000100:
      return TM_FUNNEL_STRING;
+    case 0x73000101:
+      return PUS_TM_FUNNEL_STRING;
+    case 0x73000102:
+      return CFDP_TM_FUNNEL_STRING;
+    case 0x73000205:
+      return CFDP_HANDLER_STRING;
+    case 0x73000206:
+      return CFDP_DISTRIBUTOR_STRING;
+    case 0x73010000:
+      return EIVE_SYSTEM_STRING;
+    case 0x73010001:
+      return ACS_SUBSYSTEM_STRING;
+    case 0x73010002:
+      return PL_SUBSYSTEM_STRING;
+    case 0x73010003:
+      return TCS_SUBSYSTEM_STRING;
+    case 0x73010004:
+      return COM_SUBSYSTEM_STRING;
    case 0x73500000:
      return CCSDS_IP_CORE_BRIDGE_STRING;
    case 0xFFFFFFFF:
--- a/generators/returnvalues/returnvalues_parser.py
+++ b/generators/returnvalues/returnvalues_parser.py
@ -31,7 +31,7 @@ MAX_STRING_LENGTH = 32
 BSP_SELECT = BspType.BSP_Q7S
 BSP_DIR_NAME = BSP_SELECT.value
 CSV_RETVAL_FILENAME = Path(f"{ROOT_DIR}/{BSP_SELECT.value}_returnvalues.csv")
-CSV_COPY_DEST = Path(f"{OBSW_ROOT_DIR}/tmtc/config/returnvalues.csv")
+CSV_COPY_DEST = Path(f"{OBSW_ROOT_DIR}/tmtc/eive_tmtc/config/returnvalues.csv")
 ADD_LINUX_FOLDER = False

 if BSP_SELECT == BspType.BSP_Q7S or BSP_SELECT == BspType.BSP_LINUX_BOARD:
--- a/linux/CMakeLists.txt
+++ b/linux/CMakeLists.txt
@ -1,9 +1,16 @@
-add_subdirectory(csp)
 add_subdirectory(utility)
 add_subdirectory(callbacks)
 add_subdirectory(boardtest)
 add_subdirectory(devices)
-add_subdirectory(fsfwconfig)
-add_subdirectory(obc)
+add_subdirectory(ipcore)

-target_sources(${OBSW_NAME} PUBLIC ObjectFactory.cpp InitMission.cpp)
+if(EIVE_ADD_LINUX_FSFWCONFIG)
+  add_subdirectory(fsfwconfig)
+endif()
+
+# Dependency on proprietary library
+if(TGT_BSP MATCHES "arm/q7s")
+  add_subdirectory(csp)
+endif()
+
+target_sources(${OBSW_NAME} PUBLIC ObjectFactory.cpp scheduling.cpp)
--- a/linux/InitMission.cpp
+++ b/linux/InitMission.cpp
@ -1,47 +0,0 @@
-#include "InitMission.h"
-
-#include <fsfw/devicehandlers/DeviceHandlerIF.h>
-#include <fsfw/tasks/PeriodicTaskIF.h>
-#include <mission/utility/InitMission.h>
-
-#include "OBSWConfig.h"
-#include "ObjectFactory.h"
-
-void scheduling::schedulingScex(TaskFactory& factory, PeriodicTaskIF*& scexDevHandler,
-                                PeriodicTaskIF*& scexReaderTask) {
-  using namespace initmission;
-  ReturnValue_t result = returnvalue::OK;
-#if OBSW_PRINT_MISSED_DEADLINES == 1
-  void (*missedDeadlineFunc)(void) = TaskFactory::printMissedDeadline;
-#else
-  void (*missedDeadlineFunc)(void) = nullptr;
-#endif
-  scexDevHandler = factory.createPeriodicTask(
-      "SCEX_DEV", 35, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.5, missedDeadlineFunc);
-
-  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::PERFORM_OPERATION);
-  if (result != returnvalue::OK) {
-    printAddObjectError("SCEX_DEV", objects::SCEX);
-  }
-  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::SEND_WRITE);
-  if (result != returnvalue::OK) {
-    printAddObjectError("SCEX_DEV", objects::SCEX);
-  }
-  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::GET_WRITE);
-  if (result != returnvalue::OK) {
-    printAddObjectError("SCEX_DEV", objects::SCEX);
-  }
-  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::SEND_READ);
-  if (result != returnvalue::OK) {
-    printAddObjectError("SCEX_DEV", objects::SCEX);
-  }
-  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::GET_READ);
-
-  result = returnvalue::OK;
-  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) {
-    printAddObjectError("SCEX_UART_READER", objects::SCEX_UART_READER);
-  }
-}
--- a/linux/ObjectFactory.cpp
+++ b/linux/ObjectFactory.cpp
@ -1,12 +1,13 @@
 #include "ObjectFactory.h"

 #include <fsfw/power/PowerSwitchIF.h>
+#include <fsfw/subsystem/Subsystem.h>
 #include <fsfw_hal/common/gpio/GpioCookie.h>
 #include <fsfw_hal/common/gpio/GpioIF.h>
 #include <fsfw_hal/common/gpio/gpioDefinitions.h>
+#include <fsfw_hal/linux/serial/SerialCookie.h>
 #include <fsfw_hal/linux/spi/SpiComIF.h>
 #include <fsfw_hal/linux/spi/SpiCookie.h>
-#include <fsfw_hal/linux/uart/UartCookie.h>
 #include <linux/callbacks/gpioCallbacks.h>
 #include <linux/devices/Max31865RtdLowlevelHandler.h>
 #include <mission/controller/AcsController.h>
@ -15,8 +16,6 @@
 #include <mission/devices/Max31865PT1000Handler.h>
 #include <mission/devices/ScexDeviceHandler.h>
 #include <mission/devices/SusHandler.h>
-#include <mission/system/SusAssembly.h>
-#include <mission/system/TcsBoardAssembly.h>
 #include <mission/system/fdir/RtdFdir.h>
 #include <mission/system/fdir/SusFdir.h>

@ -24,9 +23,16 @@
 #include "devConf.h"
 #include "devices/addresses.h"
 #include "devices/gpioIds.h"
+#include "eive/definitions.h"
+#include "mission/system/objects/SusAssembly.h"
+#include "mission/system/objects/TcsBoardAssembly.h"
+#include "mission/system/tree/acsModeTree.h"
+#include "mission/system/tree/payloadModeTree.h"
+#include "mission/system/tree/tcsModeTree.h"

 void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiComIF,
-                                              PowerSwitchIF* pwrSwitcher, std::string spiDev) {
+                                              PowerSwitchIF* pwrSwitcher, std::string spiDev,
+                                              bool swap0And6) {
  using namespace gpio;
  GpioCookie* gpioCookieSus = new GpioCookie();
  GpioCallback* susgpio = nullptr;
@ -73,12 +79,15 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
 #if OBSW_ADD_SUN_SENSORS == 1
  SusFdir* fdir = nullptr;
  std::array<SusHandler*, 12> susHandlers = {};
-  SpiCookie* spiCookie = new SpiCookie(addresses::SUS_0, gpioIds::CS_SUS_0, SUS::MAX_CMD_SIZE,
+  gpioId_t gpioId = gpioIds::CS_SUS_0;
+  if (swap0And6) {
+    gpioId = gpioIds::CS_SUS_6;
+  }
+  SpiCookie* spiCookie = new SpiCookie(addresses::SUS_0, gpioId, SUS::MAX_CMD_SIZE,
                                       spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
  susHandlers[0] =
      new SusHandler(objects::SUS_0_N_LOC_XFYFZM_PT_XF, 0, objects::SPI_MAIN_COM_IF, spiCookie);
  fdir = new SusFdir(objects::SUS_0_N_LOC_XFYFZM_PT_XF);
-  susHandlers[0]->setParent(objects::SUS_BOARD_ASS);
  susHandlers[0]->setCustomFdir(fdir);

  spiCookie = new SpiCookie(addresses::SUS_1, gpioIds::CS_SUS_1, SUS::MAX_CMD_SIZE,
@ -86,7 +95,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
  susHandlers[1] =
      new SusHandler(objects::SUS_1_N_LOC_XBYFZM_PT_XB, 1, objects::SPI_MAIN_COM_IF, spiCookie);
  fdir = new SusFdir(objects::SUS_1_N_LOC_XBYFZM_PT_XB);
-  susHandlers[1]->setParent(objects::SUS_BOARD_ASS);
  susHandlers[1]->setCustomFdir(fdir);

  spiCookie = new SpiCookie(addresses::SUS_2, gpioIds::CS_SUS_2, SUS::MAX_CMD_SIZE,
@ -94,7 +102,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
  susHandlers[2] =
      new SusHandler(objects::SUS_2_N_LOC_XFYBZB_PT_YB, 2, objects::SPI_MAIN_COM_IF, spiCookie);
  fdir = new SusFdir(objects::SUS_2_N_LOC_XFYBZB_PT_YB);
-  susHandlers[2]->setParent(objects::SUS_BOARD_ASS);
  susHandlers[2]->setCustomFdir(fdir);

  spiCookie = new SpiCookie(addresses::SUS_3, gpioIds::CS_SUS_3, SUS::MAX_CMD_SIZE,
@ -102,7 +109,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
  susHandlers[3] =
      new SusHandler(objects::SUS_3_N_LOC_XFYBZF_PT_YF, 3, objects::SPI_MAIN_COM_IF, spiCookie);
  fdir = new SusFdir(objects::SUS_3_N_LOC_XFYBZF_PT_YF);
-  susHandlers[3]->setParent(objects::SUS_BOARD_ASS);
  susHandlers[3]->setCustomFdir(fdir);

  spiCookie = new SpiCookie(addresses::SUS_4, gpioIds::CS_SUS_4, SUS::MAX_CMD_SIZE,
@ -110,7 +116,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
  susHandlers[4] =
      new SusHandler(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, 4, objects::SPI_MAIN_COM_IF, spiCookie);
  fdir = new SusFdir(objects::SUS_4_N_LOC_XMYFZF_PT_ZF);
-  susHandlers[4]->setParent(objects::SUS_BOARD_ASS);
  susHandlers[4]->setCustomFdir(fdir);

  spiCookie = new SpiCookie(addresses::SUS_5, gpioIds::CS_SUS_5, SUS::MAX_CMD_SIZE,
@ -118,15 +123,17 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
  susHandlers[5] =
      new SusHandler(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, 5, objects::SPI_MAIN_COM_IF, spiCookie);
  fdir = new SusFdir(objects::SUS_5_N_LOC_XFYMZB_PT_ZB);
-  susHandlers[5]->setParent(objects::SUS_BOARD_ASS);
  susHandlers[5]->setCustomFdir(fdir);

-  spiCookie = new SpiCookie(addresses::SUS_6, gpioIds::CS_SUS_6, SUS::MAX_CMD_SIZE,
-                            spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
+  gpioId = gpioIds::CS_SUS_6;
+  if (swap0And6) {
+    gpioId = gpioIds::CS_SUS_0;
+  }
+  spiCookie = new SpiCookie(addresses::SUS_6, gpioId, SUS::MAX_CMD_SIZE, spi::SUS_MAX_1227_MODE,
+                            spi::SUS_MAX1227_SPI_FREQ);
  susHandlers[6] =
      new SusHandler(objects::SUS_6_R_LOC_XFYBZM_PT_XF, 6, objects::SPI_MAIN_COM_IF, spiCookie);
  fdir = new SusFdir(objects::SUS_6_R_LOC_XFYBZM_PT_XF);
-  susHandlers[6]->setParent(objects::SUS_BOARD_ASS);
  susHandlers[6]->setCustomFdir(fdir);

  spiCookie = new SpiCookie(addresses::SUS_7, gpioIds::CS_SUS_7, SUS::MAX_CMD_SIZE,
@ -134,7 +141,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
  susHandlers[7] =
      new SusHandler(objects::SUS_7_R_LOC_XBYBZM_PT_XB, 7, objects::SPI_MAIN_COM_IF, spiCookie);
  fdir = new SusFdir(objects::SUS_7_R_LOC_XBYBZM_PT_XB);
-  susHandlers[7]->setParent(objects::SUS_BOARD_ASS);
  susHandlers[7]->setCustomFdir(fdir);

  spiCookie = new SpiCookie(addresses::SUS_8, gpioIds::CS_SUS_8, SUS::MAX_CMD_SIZE,
@ -142,7 +148,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
  susHandlers[8] =
      new SusHandler(objects::SUS_8_R_LOC_XBYBZB_PT_YB, 8, objects::SPI_MAIN_COM_IF, spiCookie);
  fdir = new SusFdir(objects::SUS_8_R_LOC_XBYBZB_PT_YB);
-  susHandlers[8]->setParent(objects::SUS_BOARD_ASS);
  susHandlers[8]->setCustomFdir(fdir);

  spiCookie = new SpiCookie(addresses::SUS_9, gpioIds::CS_SUS_9, SUS::MAX_CMD_SIZE,
@ -150,7 +155,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
  susHandlers[9] =
      new SusHandler(objects::SUS_9_R_LOC_XBYBZB_PT_YF, 9, objects::SPI_MAIN_COM_IF, spiCookie);
  fdir = new SusFdir(objects::SUS_9_R_LOC_XBYBZB_PT_YF);
-  susHandlers[9]->setParent(objects::SUS_BOARD_ASS);
  susHandlers[9]->setCustomFdir(fdir);

  spiCookie = new SpiCookie(addresses::SUS_10, gpioIds::CS_SUS_10, SUS::MAX_CMD_SIZE,
@ -158,7 +162,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
  susHandlers[10] =
      new SusHandler(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, 10, objects::SPI_MAIN_COM_IF, spiCookie);
  fdir = new SusFdir(objects::SUS_10_N_LOC_XMYBZF_PT_ZF);
-  susHandlers[10]->setParent(objects::SUS_BOARD_ASS);
  susHandlers[10]->setCustomFdir(fdir);

  spiCookie = new SpiCookie(addresses::SUS_11, gpioIds::CS_SUS_11, SUS::MAX_CMD_SIZE,
@ -166,11 +169,24 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
  susHandlers[11] =
      new SusHandler(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, 11, objects::SPI_MAIN_COM_IF, spiCookie);
  fdir = new SusFdir(objects::SUS_11_R_LOC_XBYMZB_PT_ZB);
-  susHandlers[11]->setParent(objects::SUS_BOARD_ASS);
  susHandlers[11]->setCustomFdir(fdir);

+  std::array<object_id_t, 12> susIds = {
+      objects::SUS_0_N_LOC_XFYFZM_PT_XF,  objects::SUS_1_N_LOC_XBYFZM_PT_XB,
+      objects::SUS_2_N_LOC_XFYBZB_PT_YB,  objects::SUS_3_N_LOC_XFYBZF_PT_YF,
+      objects::SUS_4_N_LOC_XMYFZF_PT_ZF,  objects::SUS_5_N_LOC_XFYMZB_PT_ZB,
+      objects::SUS_6_R_LOC_XFYBZM_PT_XF,  objects::SUS_7_R_LOC_XBYBZM_PT_XB,
+      objects::SUS_8_R_LOC_XBYBZB_PT_YB,  objects::SUS_9_R_LOC_XBYBZB_PT_YF,
+      objects::SUS_10_N_LOC_XMYBZF_PT_ZF, objects::SUS_11_R_LOC_XBYMZB_PT_ZB};
+  SusAssHelper susAssHelper = SusAssHelper(susIds);
+  auto susAss = new SusAssembly(objects::SUS_BOARD_ASS, pwrSwitcher, susAssHelper);
  for (auto& sus : susHandlers) {
    if (sus != nullptr) {
+      ReturnValue_t result = sus->connectModeTreeParent(*susAss);
+      if (result != returnvalue::OK) {
+        sif::error << "Connecting SUS " << sus->getObjectId() << " to SUS assembly failed"
+                   << std::endl;
+      }
 #if OBSW_TEST_SUS == 1
      sus->setStartUpImmediately();
      sus->setToGoToNormalMode(true);
@ -180,17 +196,7 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
 #endif
    }
  }
-  std::array<object_id_t, 12> susIds = {
-      objects::SUS_0_N_LOC_XFYFZM_PT_XF,  objects::SUS_1_N_LOC_XBYFZM_PT_XB,
-      objects::SUS_2_N_LOC_XFYBZB_PT_YB,  objects::SUS_3_N_LOC_XFYBZF_PT_YF,
-      objects::SUS_4_N_LOC_XMYFZF_PT_ZF,  objects::SUS_5_N_LOC_XFYMZB_PT_ZB,
-      objects::SUS_6_R_LOC_XFYBZM_PT_XF,  objects::SUS_7_R_LOC_XBYBZM_PT_XB,
-      objects::SUS_8_R_LOC_XBYBZB_PT_YB,  objects::SUS_9_R_LOC_XBYBZB_PT_YF,
-      objects::SUS_10_N_LOC_XMYBZF_PT_ZF, objects::SUS_11_R_LOC_XBYMZB_PT_ZB};
-  SusAssHelper susAssHelper = SusAssHelper(susIds);
-  auto susAss =
-      new SusAssembly(objects::SUS_BOARD_ASS, objects::NO_OBJECT, pwrSwitcher, susAssHelper);
-  static_cast<void>(susAss);
+  susAss->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
 #endif /* OBSW_ADD_SUN_SENSORS == 1 */
 }

@ -292,6 +298,11 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
  std::array<SpiCookie*, NUM_RTDS> rtdCookies = {};
  std::array<Max31865EiveHandler*, NUM_RTDS> rtds = {};
  RtdFdir* rtdFdir = nullptr;
+
+  TcsBoardHelper helper(rtdInfos);
+  TcsBoardAssembly* tcsBoardAss = new TcsBoardAssembly(
+      objects::TCS_BOARD_ASS, pwrSwitcher, pcdu::Switches::PDU1_CH0_TCS_BOARD_3V3, helper);
+  tcsBoardAss->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
  // Create special low level reader communication interface
  new Max31865RtdReader(objects::SPI_RTD_COM_IF, comIF, gpioComIF);
  for (uint8_t idx = 0; idx < NUM_RTDS; idx++) {
@ -303,7 +314,11 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
    rtds[idx] =
        new Max31865EiveHandler(rtdInfos[idx].first, objects::SPI_RTD_COM_IF, rtdLowLevelCookie);
    rtds[idx]->setDeviceInfo(idx, rtdInfos[idx].second);
-    rtds[idx]->setParent(objects::TCS_BOARD_ASS);
+    ReturnValue_t result = rtds[idx]->connectModeTreeParent(*tcsBoardAss);
+    if (result != returnvalue::OK) {
+      sif::error << "Connecting RTD " << static_cast<int>(idx) << " to RTD Assembly failed"
+                 << std::endl;
+    }
    rtdFdir = new RtdFdir(rtdInfos[idx].first);
    rtds[idx]->setCustomFdir(rtdFdir);
 #if OBSW_DEBUG_RTD == 1
@ -315,18 +330,13 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
 #endif
  }

-  TcsBoardHelper helper(rtdInfos);
-  TcsBoardAssembly* tcsBoardAss =
-      new TcsBoardAssembly(objects::TCS_BOARD_ASS, objects::NO_OBJECT, pwrSwitcher,
-                           pcdu::Switches::PDU1_CH0_TCS_BOARD_3V3, helper);
-  static_cast<void>(tcsBoardAss);
 #endif  // OBSW_ADD_RTD_DEVICES == 1
 }

 void ObjectFactory::createScexComponents(std::string uartDev, PowerSwitchIF* pwrSwitcher,
                                         SdCardMountedIF& mountedIF, bool onImmediately,
                                         std::optional<power::Switch_t> switchId) {
-  auto* cookie = new UartCookie(objects::SCEX, uartDev, uart::SCEX_BAUD, 4096);
+  auto* cookie = new SerialCookie(objects::SCEX, uartDev, uart::SCEX_BAUD, 4096);
  cookie->setTwoStopBits();
  // cookie->setParityEven();
  auto scexUartReader = new ScexUartReader(objects::SCEX_UART_READER);
@ -337,16 +347,30 @@ void ObjectFactory::createScexComponents(std::string uartDev, PowerSwitchIF* pwr
  if (switchId) {
    scexHandler->setPowerSwitcher(*pwrSwitcher, switchId.value());
  }
+  scexHandler->connectModeTreeParent(satsystem::pl::SUBSYSTEM);
 }

 void ObjectFactory::createThermalController() {
-  new ThermalController(objects::THERMAL_CONTROLLER, objects::NO_OBJECT);
+  auto* tcsCtrl = new ThermalController(objects::THERMAL_CONTROLLER);
+  tcsCtrl->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
 }

-void ObjectFactory::createAcsController() { new AcsController(objects::ACS_CONTROLLER); }
+AcsController* ObjectFactory::createAcsController(bool connectSubsystem) {
+  auto acsCtrl = new AcsController(objects::ACS_CONTROLLER);
+  if (connectSubsystem) {
+    acsCtrl->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
+  }
+  return acsCtrl;
+}

 void ObjectFactory::gpioChecker(ReturnValue_t result, std::string output) {
  if (result != returnvalue::OK) {
    sif::error << "ObjectFactory: Adding GPIOs failed for " << output << std::endl;
  }
 }
+
+void ObjectFactory::addTmtcIpCoresToFunnels(CcsdsIpCoreHandler& ipCoreHandler,
+                                            PusTmFunnel& pusFunnel, CfdpTmFunnel& cfdpFunnel) {
+  cfdpFunnel.addDestination(ipCoreHandler, config::LIVE_TM);
+  pusFunnel.addDestination(ipCoreHandler, config::LIVE_TM);
+}
--- a/linux/ObjectFactory.h
+++ b/linux/ObjectFactory.h
@ -4,6 +4,9 @@
 #include <fsfw/returnvalues/returnvalue.h>
 #include <fsfw_hal/linux/gpio/LinuxLibgpioIF.h>
 #include <mission/memory/SdCardMountedIF.h>
+#include <mission/tmtc/CcsdsIpCoreHandler.h>
+#include <mission/tmtc/CfdpTmFunnel.h>
+#include <mission/tmtc/PusTmFunnel.h>

 #include <optional>
 #include <string>
@ -11,11 +14,12 @@
 class GpioIF;
 class SpiComIF;
 class PowerSwitchIF;
+class AcsController;

 namespace ObjectFactory {

 void createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiComIF, PowerSwitchIF* pwrSwitcher,
-                               std::string spiDev);
+                               std::string spiDev, bool swap0And6);
 void createRtdComponents(std::string spiDev, GpioIF* gpioComIF, PowerSwitchIF* pwrSwitcher,
                         SpiComIF* comIF);

@ -26,6 +30,9 @@ void createScexComponents(std::string uartDev, PowerSwitchIF* pwrSwitcher,
 void gpioChecker(ReturnValue_t result, std::string output);

 void createThermalController();
-void createAcsController();
+AcsController* createAcsController(bool connectSubsystem);
+
+void addTmtcIpCoresToFunnels(CcsdsIpCoreHandler& ipCoreHandler, PusTmFunnel& pusFunnel,
+                             CfdpTmFunnel& cfdpFunnel);

 }  // namespace ObjectFactory
--- a/linux/boardtest/SpiTestClass.cpp
+++ b/linux/boardtest/SpiTestClass.cpp
@ -333,14 +333,12 @@ void SpiTestClass::performPeriodicMax1227Test() {
 }

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

-    max1227::prepareExternallyClockedRead0ToN(sendBuffer.data(), 5, spiTransferStruct[0].len);
+    size_t tmpSz = spiTransferStruct[0].len;
+    max1227::prepareExternallyClockedRead0ToN(sendBuffer.data(), 5, tmpSz);
    transfer(fd, cfg.gpioId);
    uint16_t adcRaw[6] = {};
    adcRaw[0] = (recvBuffer[1] << 8) | recvBuffer[2];
@ -552,7 +553,9 @@ void SpiTestClass::max1227PlPcduTest(int fd) {
    spiTransferStruct[0].len = 1;
    transfer(fd, gpioIds::PLPCDU_ADC_CS);
    uint8_t n = 11;
-    max1227::prepareExternallyClockedRead0ToN(sendBuffer.data(), n, spiTransferStruct[0].len);
+    size_t tmpSz = spiTransferStruct[0].len;
+    max1227::prepareExternallyClockedRead0ToN(sendBuffer.data(), n, tmpSz);
+    spiTransferStruct[0].len = tmpSz;
    size_t dummy = 0;
    max1227::prepareExternallyClockedTemperatureRead(sendBuffer.data() + spiTransferStruct[0].len,
                                                     dummy);
@ -585,9 +588,11 @@ void SpiTestClass::max1227PlPcduTest(int fd) {
    spiTransferStruct[0].len = 1;
    transfer(fd, gpioIds::PLPCDU_ADC_CS);
    uint8_t n = 11;
-    max1227::prepareExternallyClockedRead0ToN(sendBuffer.data(), n, spiTransferStruct[0].len);
+    size_t tmpLen = spiTransferStruct[0].len;
+    max1227::prepareExternallyClockedRead0ToN(sendBuffer.data(), n, tmpLen);
    max1227::prepareExternallyClockedTemperatureRead(sendBuffer.data() + spiTransferStruct[0].len,
-                                                     spiTransferStruct[0].len);
+                                                     tmpLen);
+    spiTransferStruct[0].len = tmpLen;
    transfer(fd, gpioIds::PLPCDU_ADC_CS);
    uint16_t adcRaw[n + 1] = {};
    for (uint8_t idx = 0; idx < n + 1; idx++) {
--- a/linux/boardtest/UartTestClass.cpp
+++ b/linux/boardtest/UartTestClass.cpp
@ -3,7 +3,7 @@
 #include <errno.h>  // Error integer and strerror() function
 #include <fcntl.h>  // Contains file controls like O_RDWR
 #include <fsfw/tasks/TaskFactory.h>
-#include <fsfw_hal/linux/uart/UartCookie.h>
+#include <fsfw_hal/linux/serial/SerialCookie.h>
 #include <linux/devices/ScexDleParser.h>
 #include <linux/devices/ScexHelper.h>
 #include <linux/devices/ScexUartReader.h>
@ -13,6 +13,7 @@
 #include <string>

 #include "OBSWConfig.h"
+#include "eive/objects.h"
 #include "fsfw/globalfunctions/CRC.h"
 #include "fsfw/globalfunctions/DleEncoder.h"
 #include "fsfw/globalfunctions/arrayprinter.h"
@ -164,7 +165,7 @@ void UartTestClass::scexInit() {
 #else
    std::string devname = "/dev/ul-scex";
 #endif
-    uartCookie = new UartCookie(this->getObjectId(), devname, UartBaudRate::RATE_57600, 4096);
+    uartCookie = new SerialCookie(this->getObjectId(), devname, UartBaudRate::RATE_57600, 4096);
    reader->setDebugMode(false);
    ReturnValue_t result = reader->initializeInterface(uartCookie);
    if (result != OK) {
--- a/linux/boardtest/UartTestClass.h
+++ b/linux/boardtest/UartTestClass.h
@ -5,7 +5,7 @@
 #include <fsfw/globalfunctions/DleEncoder.h>
 #include <fsfw/globalfunctions/DleParser.h>
 #include <fsfw/timemanager/Countdown.h>
-#include <fsfw_hal/linux/uart/UartCookie.h>
+#include <fsfw_hal/linux/serial/SerialCookie.h>
 #include <termios.h>  // Contains POSIX terminal control definitions

 #include <array>
@ -57,7 +57,7 @@ class UartTestClass : public TestTask {
  scex::Cmds currCmd = scex::Cmds::PING;
  TestModes mode = TestModes::GPS;
  DleEncoder dleEncoder = DleEncoder();
-  UartCookie* uartCookie = nullptr;
+  SerialCookie* uartCookie = nullptr;
  size_t encodedLen = 0;
  lwgps_t gpsData = {};
  struct termios tty = {};
--- a/linux/devices/CMakeLists.txt
+++ b/linux/devices/CMakeLists.txt
@ -7,4 +7,8 @@ target_sources(
                       ScexDleParser.cpp ScexHelper.cpp)

 add_subdirectory(ploc)
-add_subdirectory(startracker)
+
+# Dependency on proprietary library
+if(TGT_BSP MATCHES "arm/q7s")
+  add_subdirectory(startracker)
+endif()
--- a/linux/devices/GPSHyperionLinuxController.cpp
+++ b/linux/devices/GPSHyperionLinuxController.cpp
@ -18,9 +18,7 @@

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

--- a/linux/devices/Max31865RtdLowlevelHandler.cpp
+++ b/linux/devices/Max31865RtdLowlevelHandler.cpp
@ -50,7 +50,7 @@ ReturnValue_t Max31865RtdReader::performOperation(uint8_t operationCode) {
 }

 bool Max31865RtdReader::rtdIsActive(uint8_t idx) {
-  if (rtds[idx]->on and rtds[idx]->active and rtds[idx]->configured) {
+  if (rtds[idx]->on and rtds[idx]->db.active and rtds[idx]->db.configured) {
    return true;
  }
  return false;
@ -69,7 +69,7 @@ bool Max31865RtdReader::periodicInitHandling() {
    if (rtd == nullptr) {
      continue;
    }
-    if ((rtd->on or rtd->active) and not rtd->configured and rtd->cd.hasTimedOut()) {
+    if ((rtd->on or rtd->db.active) and not rtd->db.configured and rtd->cd.hasTimedOut()) {
      ManualCsLockWrapper mg(csLock, gpioIF, rtd->spiCookie, csTimeoutType, csTimeoutMs);
      if (mg.lockResult != returnvalue::OK or mg.gpioResult != returnvalue::OK) {
        sif::error << "Max31865RtdReader::periodicInitHandling: Manual CS lock failed" << std::endl;
@ -95,13 +95,7 @@ bool Max31865RtdReader::periodicInitHandling() {
      if (result != returnvalue::OK) {
        handleSpiError(rtd, result, "clearFaultStatus");
      }
-      rtd->configured = true;
      rtd->db.configured = true;
-      if (rtd->active) {
-        rtd->db.active = true;
-      }
-    }
-    if (rtd->active and rtd->configured and not rtd->db.active) {
      rtd->db.active = true;
    }
  }
@ -149,7 +143,7 @@ ReturnValue_t Max31865RtdReader::periodicReadHandling() {
  auto result = returnvalue::OK;
  MutexGuard mg(readerMutex);
  if (mg.getLockResult() != returnvalue::OK) {
-    sif::warning << "Max31865RtdReader::periodicReadReqHandling: Mutex lock failed" << std::endl;
+    sif::warning << "Max31865RtdReader::periodicReadHandling: Mutex lock failed" << std::endl;
    return returnvalue::FAILED;
  }
  // Now read the RTD values
@ -160,6 +154,10 @@ ReturnValue_t Max31865RtdReader::periodicReadHandling() {
    if (rtdIsActive(rtd->idx)) {
      uint16_t rtdVal = 0;
      bool faultBitSet = false;
+      result = writeCfgReg(rtd->spiCookie, BASE_CFG);
+      if (result != returnvalue::OK) {
+        handleSpiError(rtd, result, "writeCfgReg");
+      }
      result = readRtdVal(rtd->spiCookie, rtdVal, faultBitSet);
      if (result != returnvalue::OK) {
        handleSpiError(rtd, result, "readRtdVal");
@ -241,8 +239,8 @@ ReturnValue_t Max31865RtdReader::sendMessage(CookieIF* cookie, const uint8_t* se
        rtdCookie->cd.setTimeout(MAX31865::WARMUP_MS);
        rtdCookie->cd.resetTimer();
        rtdCookie->on = true;
-        rtdCookie->active = false;
-        rtdCookie->configured = false;
+        rtdCookie->db.active = false;
+        rtdCookie->db.configured = false;
        if (sendLen == 5) {
          thresholdHandler(rtdCookie, sendData);
        }
@ -254,10 +252,10 @@ ReturnValue_t Max31865RtdReader::sendMessage(CookieIF* cookie, const uint8_t* se
        rtdCookie->cd.setTimeout(MAX31865::WARMUP_MS);
        rtdCookie->cd.resetTimer();
        rtdCookie->on = true;
-        rtdCookie->active = true;
-        rtdCookie->configured = false;
+        rtdCookie->db.active = true;
+        rtdCookie->db.configured = false;
      } else {
-        rtdCookie->active = true;
+        rtdCookie->db.active = true;
      }
      if (sendLen == 5) {
        thresholdHandler(rtdCookie, sendData);
@ -266,8 +264,8 @@ ReturnValue_t Max31865RtdReader::sendMessage(CookieIF* cookie, const uint8_t* se
    }
    case (EiveMax31855::RtdCommands::OFF): {
      rtdCookie->on = false;
-      rtdCookie->active = false;
-      rtdCookie->configured = false;
+      rtdCookie->db.active = false;
+      rtdCookie->db.configured = false;
      break;
    }
    case (EiveMax31855::RtdCommands::HIGH_TRESHOLD): {
@ -288,7 +286,13 @@ ReturnValue_t Max31865RtdReader::sendMessage(CookieIF* cookie, const uint8_t* se
      }
      break;
    }
-    case (EiveMax31855::RtdCommands::CFG):
+    case (EiveMax31855::RtdCommands::CFG): {
+      ReturnValue_t result = writeCfgReg(rtdCookie->spiCookie, BASE_CFG);
+      if (result != returnvalue::OK) {
+        handleSpiError(rtdCookie, result, "writeCfgReg");
+      }
+      break;
+    }
    default: {
      // TODO: Only implement if needed
      break;
--- a/linux/devices/Max31865RtdLowlevelHandler.h
+++ b/linux/devices/Max31865RtdLowlevelHandler.h
@ -23,8 +23,6 @@ struct Max31865ReaderCookie : public CookieIF {
  Countdown cd = Countdown(MAX31865::WARMUP_MS);

  bool on = false;
-  bool configured = false;
-  bool active = false;
  bool writeLowThreshold = false;
  bool writeHighThreshold = false;
  uint16_t lowThreshold = 0;
--- a/linux/devices/ScexUartReader.cpp
+++ b/linux/devices/ScexUartReader.cpp
@ -6,7 +6,7 @@
 #include <fsfw/ipc/MutexGuard.h>
 #include <fsfw/tasks/SemaphoreFactory.h>
 #include <fsfw/tasks/TaskFactory.h>
-#include <fsfw_hal/linux/uart/UartCookie.h>
+#include <fsfw_hal/linux/serial/SerialCookie.h>
 #include <unistd.h>  // write(), read(), close()

 #include <cerrno>  // Error integer and strerror() function
@ -58,7 +58,7 @@ ReturnValue_t ScexUartReader::performOperation(uint8_t operationCode) {
          result = tryDleParsing();
        }

-        TaskFactory::delayTask(400);
+        TaskFactory::delayTask(150);
      } else if (bytesRead < 0) {
        sif::warning << "ScexUartReader::performOperation: read call failed with error [" << errno
                     << ", " << strerror(errno) << "]" << std::endl;
@ -84,7 +84,7 @@ ReturnValue_t ScexUartReader::performOperation(uint8_t operationCode) {
 }

 ReturnValue_t ScexUartReader::initializeInterface(CookieIF *cookie) {
-  UartCookie *uartCookie = dynamic_cast<UartCookie *>(cookie);
+  SerialCookie *uartCookie = dynamic_cast<SerialCookie *>(cookie);
  if (uartCookie == nullptr) {
    return FAILED;
  }
@ -98,18 +98,11 @@ ReturnValue_t ScexUartReader::initializeInterface(CookieIF *cookie) {
  }
  // Setting up UART parameters
  tty.c_cflag &= ~PARENB;  // Clear parity bit
-  if (uartCookie->getStopBits() == StopBits::TWO_STOP_BITS) {
-    // Use two stop bits
-    tty.c_cflag |= CSTOPB;
-  } else {
-    // Clear stop field, only one stop bit used in communication
-    tty.c_cflag &= ~CSTOPB;
-  }
-
-  tty.c_cflag &= ~CSIZE;          // Clear all the size bits
-  tty.c_cflag |= CS8;             // 8 bits per byte
-  tty.c_cflag &= ~CRTSCTS;        // Disable RTS/CTS hardware flow control
-  tty.c_cflag |= CREAD | CLOCAL;  // Turn on READ & ignore ctrl lines (CLOCAL = 1)
+  uart::setStopbits(tty, uartCookie->getStopBits());
+  uart::setBitsPerWord(tty, BitsPerWord::BITS_8);
+  tty.c_cflag &= ~CRTSCTS;  // Disable RTS/CTS hardware flow control
+  uart::enableRead(tty);
+  uart::ignoreCtrlLines(tty);

  // Use non-canonical mode and clear echo flag
  tty.c_lflag &= ~(ICANON | ECHO);
@ -118,10 +111,7 @@ ReturnValue_t ScexUartReader::initializeInterface(CookieIF *cookie) {
  tty.c_cc[VTIME] = 0;
  tty.c_cc[VMIN] = 0;

-  // The SCEX experiment has a fixed baud rate.
-  if (cfsetispeed(&tty, B38400) != 0) {
-    sif::warning << "ScexUartReader::initializeInterface: Setting baud rate failed" << std::endl;
-  }
+  uart::setBaudrate(tty, uartCookie->getBaudrate());
  if (tcsetattr(serialPort, TCSANOW, &tty) != 0) {
    sif::warning << "ScexUartReader::initializeInterface: tcsetattr call failed with error ["
                 << errno << ", " << strerror(errno) << std::endl;
@ -216,6 +206,10 @@ ReturnValue_t ScexUartReader::tryDleParsing() {
 void ScexUartReader::reset() {
  lock->lockMutex();
  state = States::FINISH;
+  ipcRingBuf.clear();
+  while (not ipcQueue.empty()) {
+    ipcQueue.pop();
+  }
  lock->unlockMutex();
 }

--- a/linux/devices/devicedefinitions/MPSoCReturnValuesIF.h
+++ b/linux/devices/devicedefinitions/MPSoCReturnValuesIF.h
@ -1,6 +1,7 @@
 #ifndef MPSOC_RETURN_VALUES_IF_H_
 #define MPSOC_RETURN_VALUES_IF_H_

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

 class MPSoCReturnValuesIF {
--- a/linux/devices/devicedefinitions/PlocMPSoCDefinitions.h
+++ b/linux/devices/devicedefinitions/PlocMPSoCDefinitions.h
@ -152,8 +152,8 @@ class TcBase : public ploc::SpTcBase, public MPSoCReturnValuesIF {
   *        sent and received packets.
   */
  TcBase(ploc::SpTcParams params, uint16_t apid, uint16_t sequenceCount)
-      : ploc::SpTcBase(params, apid, sequenceCount) {
-    spParams.setDataFieldLen(INIT_LENGTH);
+      : ploc::SpTcBase(params, apid, 0, sequenceCount) {
+    spParams.setFullPayloadLen(INIT_LENGTH);
  }

  ReturnValue_t buildPacket() { return buildPacket(nullptr, 0); }
@ -181,7 +181,7 @@ class TcBase : public ploc::SpTcBase, public MPSoCReturnValuesIF {
    if (res != returnvalue::OK) {
      return res;
    }
-    return calcCrc();
+    return calcAndSetCrc();
  }

 protected:
@ -206,7 +206,7 @@ class TcMemRead : public TcBase {
   */
  TcMemRead(ploc::SpTcParams params, uint16_t sequenceCount)
      : TcBase(params, apid::TC_MEM_READ, sequenceCount) {
-    spParams.setPayloadLen(COMMAND_LENGTH);
+    spParams.setFullPayloadLen(COMMAND_LENGTH + CRC_SIZE);
  }

  uint16_t getMemLen() const { return memLen; }
@ -267,7 +267,7 @@ class TcMemWrite : public TcBase {
    }
    uint16_t memLen =
        *(commandData + MEM_ADDRESS_SIZE) << 8 | *(commandData + MEM_ADDRESS_SIZE + 1);
-    spParams.setPayloadLen(MIN_FIXED_PAYLOAD_LENGTH + memLen * 4);
+    spParams.setFullPayloadLen(MIN_FIXED_PAYLOAD_LENGTH + memLen * 4 + CRC_SIZE);
    result = checkPayloadLen();
    if (result != returnvalue::OK) {
      return result;
@ -313,7 +313,7 @@ class FlashFopen : public ploc::SpTcBase {
  ReturnValue_t createPacket(std::string filename, char accessMode_) {
    accessMode = accessMode_;
    size_t nameSize = filename.size();
-    spParams.setPayloadLen(nameSize + sizeof(NULL_TERMINATOR) + sizeof(accessMode));
+    spParams.setFullPayloadLen(nameSize + sizeof(NULL_TERMINATOR) + sizeof(accessMode) + CRC_SIZE);
    ReturnValue_t result = checkPayloadLen();
    if (result != returnvalue::OK) {
      return result;
@ -322,7 +322,7 @@ class FlashFopen : public ploc::SpTcBase {
    *(spParams.buf + nameSize) = NULL_TERMINATOR;
    std::memcpy(payloadStart + nameSize + sizeof(NULL_TERMINATOR), &accessMode, sizeof(accessMode));
    updateSpFields();
-    return calcCrc();
+    return calcAndSetCrc();
  }

 private:
@ -339,14 +339,14 @@ class FlashFclose : public ploc::SpTcBase {

  ReturnValue_t createPacket(std::string filename) {
    size_t nameSize = filename.size();
-    spParams.setPayloadLen(nameSize + sizeof(NULL_TERMINATOR));
+    spParams.setFullPayloadLen(nameSize + sizeof(NULL_TERMINATOR) + CRC_SIZE);
    ReturnValue_t result = checkPayloadLen();
    if (result != returnvalue::OK) {
      return result;
    }
    std::memcpy(payloadStart, filename.c_str(), nameSize);
    *(payloadStart + nameSize) = NULL_TERMINATOR;
-    return calcCrc();
+    return calcAndSetCrc();
  }
 };

@ -365,7 +365,7 @@ class TcFlashWrite : public ploc::SpTcBase {
      sif::debug << "FlashWrite::createPacket: Command data too big" << std::endl;
      return returnvalue::FAILED;
    }
-    spParams.setPayloadLen(static_cast<uint16_t>(writeLen) + 4);
+    spParams.setFullPayloadLen(static_cast<uint16_t>(writeLen) + 4 + CRC_SIZE);
    result = checkPayloadLen();
    if (result != returnvalue::OK) {
      return result;
@ -382,7 +382,7 @@ class TcFlashWrite : public ploc::SpTcBase {
    if (res != returnvalue::OK) {
      return res;
    }
-    return calcCrc();
+    return calcAndSetCrc();
  }

 private:
@ -399,7 +399,7 @@ class TcFlashDelete : public ploc::SpTcBase {

  ReturnValue_t buildPacket(std::string filename) {
    size_t nameSize = filename.size();
-    spParams.setPayloadLen(nameSize + sizeof(NULL_TERMINATOR));
+    spParams.setFullPayloadLen(nameSize + sizeof(NULL_TERMINATOR) + CRC_SIZE);
    auto res = checkPayloadLen();
    if (res != returnvalue::OK) {
      return res;
@ -412,7 +412,7 @@ class TcFlashDelete : public ploc::SpTcBase {
    if (res != returnvalue::OK) {
      return res;
    }
-    return calcCrc();
+    return calcAndSetCrc();
  }
 };

@ -439,7 +439,7 @@ class TcReplayStart : public TcBase {
 protected:
  ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) override {
    ReturnValue_t result = returnvalue::OK;
-    spParams.setPayloadLen(commandDataLen);
+    spParams.setFullPayloadLen(commandDataLen + CRC_SIZE);
    result = lengthCheck(commandDataLen);
    if (result != returnvalue::OK) {
      return result;
@ -500,7 +500,7 @@ class TcDownlinkPwrOn : public TcBase {
    if (result != returnvalue::OK) {
      return result;
    }
-    spParams.setPayloadLen(commandDataLen + sizeof(MAX_AMPLITUDE));
+    spParams.setFullPayloadLen(commandDataLen + sizeof(MAX_AMPLITUDE) + CRC_SIZE);
    result = checkPayloadLen();
    if (result != returnvalue::OK) {
      return result;
@ -571,7 +571,7 @@ class TcReplayWriteSeq : public TcBase {
 protected:
  ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) override {
    ReturnValue_t result = returnvalue::OK;
-    spParams.setPayloadLen(commandDataLen + sizeof(NULL_TERMINATOR));
+    spParams.setFullPayloadLen(commandDataLen + sizeof(NULL_TERMINATOR) + CRC_SIZE);
    result = lengthCheck(commandDataLen);
    if (result != returnvalue::OK) {
      return result;
@ -657,7 +657,8 @@ class TcCamcmdSend : public TcBase {
      return INVALID_LENGTH;
    }
    uint16_t dataLen = static_cast<uint16_t>(commandDataLen + sizeof(CARRIAGE_RETURN));
-    spParams.setPayloadLen(sizeof(dataLen) + commandDataLen + sizeof(CARRIAGE_RETURN));
+    spParams.setFullPayloadLen(sizeof(dataLen) + commandDataLen + sizeof(CARRIAGE_RETURN) +
+                               CRC_SIZE);
    auto res = checkPayloadLen();
    if (res != returnvalue::OK) {
      return res;
--- a/linux/devices/devicedefinitions/PlocSupervisorDefinitions.h
+++ b/linux/devices/devicedefinitions/PlocSupervisorDefinitions.h
--- a/linux/devices/devicedefinitions/SupvReturnValuesIF.h
+++ b/linux/devices/devicedefinitions/SupvReturnValuesIF.h
@ -1,61 +0,0 @@
-#ifndef SUPV_RETURN_VALUES_IF_H_
-#define SUPV_RETURN_VALUES_IF_H_
-
-#include "fsfw/returnvalues/returnvalue.h"
-
-class SupvReturnValuesIF {
- public:
-  static const uint8_t INTERFACE_ID = CLASS_ID::SUPV_RETURN_VALUES_IF;
-
-  //! [EXPORT] : [COMMENT] Space Packet received from PLOC supervisor has invalid CRC
-  static const ReturnValue_t CRC_FAILURE = MAKE_RETURN_CODE(0xA0);
-  //! [EXPORT] : [COMMENT] Received ACK failure reply from PLOC supervisor
-  static const ReturnValue_t RECEIVED_ACK_FAILURE = MAKE_RETURN_CODE(0xA1);
-  //! [EXPORT] : [COMMENT] Received execution failure reply from PLOC supervisor
-  static const ReturnValue_t RECEIVED_EXE_FAILURE = MAKE_RETURN_CODE(0xA2);
-  //! [EXPORT] : [COMMENT] Received space packet with invalid APID from PLOC supervisor
-  static const ReturnValue_t INVALID_APID = MAKE_RETURN_CODE(0xA3);
-  //! [EXPORT] : [COMMENT] Failed to read current system time
-  static const ReturnValue_t GET_TIME_FAILURE = MAKE_RETURN_CODE(0xA4);
-  //! [EXPORT] : [COMMENT] Received command with invalid watchdog parameter. Valid watchdogs are 0
-  //! for PS, 1 for PL and 2 for INT
-  static const ReturnValue_t INVALID_WATCHDOG = MAKE_RETURN_CODE(0xA5);
-  //! [EXPORT] : [COMMENT] Received watchdog timeout config command with invalid timeout. Valid
-  //! timeouts must be in the range between 1000 and 360000 ms.
-  static const ReturnValue_t INVALID_WATCHDOG_TIMEOUT = MAKE_RETURN_CODE(0xA6);
-  //! [EXPORT] : [COMMENT] Received latchup config command with invalid latchup ID
-  static const ReturnValue_t INVALID_LATCHUP_ID = MAKE_RETURN_CODE(0xA7);
-  //! [EXPORT] : [COMMENT] Received set adc sweep period command with invalid sweep period. Must be
-  //! larger than 21.
-  static const ReturnValue_t SWEEP_PERIOD_TOO_SMALL = MAKE_RETURN_CODE(0xA8);
-  //! [EXPORT] : [COMMENT] Receive auto EM test command with invalid test param. Valid params are 1
-  //! and 2.
-  static const ReturnValue_t INVALID_TEST_PARAM = MAKE_RETURN_CODE(0xA9);
-  //! [EXPORT] : [COMMENT] Returned when scanning for MRAM dump packets failed.
-  static const ReturnValue_t MRAM_PACKET_PARSING_FAILURE = MAKE_RETURN_CODE(0xAA);
-  //! [EXPORT] : [COMMENT] Returned when the start and stop addresses of the MRAM dump or MRAM  wipe
-  //! commands are invalid (e.g. start address bigger than stop address)
-  static const ReturnValue_t INVALID_MRAM_ADDRESSES = MAKE_RETURN_CODE(0xAB);
-  //! [EXPORT] : [COMMENT] Expect reception of an MRAM dump packet but received space packet with
-  //! other apid.
-  static const ReturnValue_t NO_MRAM_PACKET = MAKE_RETURN_CODE(0xAC);
-  //! [EXPORT] : [COMMENT] Path to PLOC directory on SD card does not exist
-  static const ReturnValue_t PATH_DOES_NOT_EXIST = MAKE_RETURN_CODE(0xAD);
-  //! [EXPORT] : [COMMENT] MRAM dump file does not exists. The file should actually already have
-  //! been created with the reception of the first dump packet.
-  static const ReturnValue_t MRAM_FILE_NOT_EXISTS = MAKE_RETURN_CODE(0xAE);
-  //! [EXPORT] : [COMMENT] Received action command has invalid length
-  static const ReturnValue_t INVALID_LENGTH = MAKE_RETURN_CODE(0xAF);
-  //! [EXPORT] : [COMMENT] Filename too long
-  static const ReturnValue_t FILENAME_TOO_LONG = MAKE_RETURN_CODE(0xB0);
-  //! [EXPORT] : [COMMENT] Received update status report with invalid packet length field
-  static const ReturnValue_t UPDATE_STATUS_REPORT_INVALID_LENGTH = MAKE_RETURN_CODE(0xB1);
-  //! [EXPORT] : [COMMENT] Update status report does not contain expected CRC. There might be a bit
-  //! flip in the update memory region.
-  static const ReturnValue_t UPDATE_CRC_FAILURE = MAKE_RETURN_CODE(0xB2);
-  //! [EXPORT] : [COMMENT] Supervisor helper task ist currently executing a command (wait until
-  //! helper tas has finished or interrupt by sending the terminate command)
-  static const ReturnValue_t SUPV_HELPER_EXECUTING = MAKE_RETURN_CODE(0xB3);
-};
-
-#endif /* SUPV_RETURN_VALUES_IF_H_ */
--- a/linux/devices/ploc/CMakeLists.txt
+++ b/linux/devices/ploc/CMakeLists.txt
@ -1,4 +1,4 @@
 target_sources(
  ${OBSW_NAME}
  PRIVATE PlocSupervisorHandler.cpp PlocMemoryDumper.cpp PlocMPSoCHandler.cpp
-          PlocMPSoCHelper.cpp PlocSupvHelper.cpp)
+          PlocMPSoCHelper.cpp PlocSupvUartMan.cpp)
--- a/linux/devices/ploc/PlocMPSoCHandler.cpp
+++ b/linux/devices/ploc/PlocMPSoCHandler.cpp
@ -31,7 +31,7 @@ ReturnValue_t PlocMPSoCHandler::initialize() {
  if (result != returnvalue::OK) {
    return result;
  }
-  uartComIf = dynamic_cast<UartComIF*>(communicationInterface);
+  uartComIf = dynamic_cast<SerialComIF*>(communicationInterface);
  if (uartComIf == nullptr) {
    sif::warning << "PlocMPSoCHandler::initialize: Invalid uart com if" << std::endl;
    return ObjectManagerIF::CHILD_INIT_FAILED;
@ -184,12 +184,14 @@ void PlocMPSoCHandler::doShutDown() {
      powerState = PowerState::SHUTDOWN;
      break;
    case PowerState::OFF:
+      sequenceCount = 0;
      setMode(_MODE_POWER_DOWN);
      break;
    default:
      break;
  }
 #else
+  sequenceCount = 0;
  uartIsolatorSwitch.pullLow();
  setMode(_MODE_POWER_DOWN);
  powerState = PowerState::OFF;
@ -340,12 +342,13 @@ ReturnValue_t PlocMPSoCHandler::scanForReply(const uint8_t* start, size_t remain
    }
  }

-  sequenceCount++;
  uint16_t recvSeqCnt = (*(start + 2) << 8 | *(start + 3)) & PACKET_SEQUENCE_COUNT_MASK;
  if (recvSeqCnt != sequenceCount) {
    triggerEvent(MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH, sequenceCount, recvSeqCnt);
    sequenceCount = recvSeqCnt;
  }
+  // This sequence count ping pong does not make any sense but it is how the MPSoC expects it.
+  sequenceCount++;
  return result;
 }

@ -403,11 +406,9 @@ void PlocMPSoCHandler::handleEvent(EventMessage* eventMessage) {
 ReturnValue_t PlocMPSoCHandler::prepareTcMemWrite(const uint8_t* commandData,
                                                  size_t commandDataLen) {
  ReturnValue_t result = returnvalue::OK;
-  sequenceCount++;
  mpsoc::TcMemWrite tcMemWrite(spParams, sequenceCount);
  result = tcMemWrite.buildPacket(commandData, commandDataLen);
  if (result != returnvalue::OK) {
-    sequenceCount--;
    return result;
  }
  finishTcPrep(tcMemWrite.getFullPacketLen());
@ -417,11 +418,9 @@ ReturnValue_t PlocMPSoCHandler::prepareTcMemWrite(const uint8_t* commandData,
 ReturnValue_t PlocMPSoCHandler::prepareTcMemRead(const uint8_t* commandData,
                                                 size_t commandDataLen) {
  ReturnValue_t result = returnvalue::OK;
-  sequenceCount++;
  mpsoc::TcMemRead tcMemRead(spParams, sequenceCount);
  result = tcMemRead.buildPacket(commandData, commandDataLen);
  if (result != returnvalue::OK) {
-    sequenceCount--;
    return result;
  }
  finishTcPrep(tcMemRead.getFullPacketLen());
@ -435,12 +434,10 @@ ReturnValue_t PlocMPSoCHandler::prepareTcFlashDelete(const uint8_t* commandData,
    return MPSoCReturnValuesIF::NAME_TOO_LONG;
  }
  ReturnValue_t result = returnvalue::OK;
-  sequenceCount++;
  mpsoc::TcFlashDelete tcFlashDelete(spParams, sequenceCount);
  result = tcFlashDelete.buildPacket(
      std::string(reinterpret_cast<const char*>(commandData), commandDataLen));
  if (result != returnvalue::OK) {
-    sequenceCount--;
    return result;
  }
  finishTcPrep(tcFlashDelete.getFullPacketLen());
@ -450,11 +447,9 @@ ReturnValue_t PlocMPSoCHandler::prepareTcFlashDelete(const uint8_t* commandData,
 ReturnValue_t PlocMPSoCHandler::prepareTcReplayStart(const uint8_t* commandData,
                                                     size_t commandDataLen) {
  ReturnValue_t result = returnvalue::OK;
-  sequenceCount++;
  mpsoc::TcReplayStart tcReplayStart(spParams, sequenceCount);
  result = tcReplayStart.buildPacket(commandData, commandDataLen);
  if (result != returnvalue::OK) {
-    sequenceCount--;
    return result;
  }
  finishTcPrep(tcReplayStart.getFullPacketLen());
@ -463,11 +458,9 @@ ReturnValue_t PlocMPSoCHandler::prepareTcReplayStart(const uint8_t* commandData,

 ReturnValue_t PlocMPSoCHandler::prepareTcReplayStop() {
  ReturnValue_t result = returnvalue::OK;
-  sequenceCount++;
  mpsoc::TcReplayStop tcReplayStop(spParams, sequenceCount);
  result = tcReplayStop.buildPacket();
  if (result != returnvalue::OK) {
-    sequenceCount--;
    return result;
  }
  finishTcPrep(tcReplayStop.getFullPacketLen());
@ -477,11 +470,9 @@ ReturnValue_t PlocMPSoCHandler::prepareTcReplayStop() {
 ReturnValue_t PlocMPSoCHandler::prepareTcDownlinkPwrOn(const uint8_t* commandData,
                                                       size_t commandDataLen) {
  ReturnValue_t result = returnvalue::OK;
-  sequenceCount++;
  mpsoc::TcDownlinkPwrOn tcDownlinkPwrOn(spParams, sequenceCount);
  result = tcDownlinkPwrOn.buildPacket(commandData, commandDataLen);
  if (result != returnvalue::OK) {
-    sequenceCount--;
    return result;
  }
  finishTcPrep(tcDownlinkPwrOn.getFullPacketLen());
@ -490,11 +481,9 @@ ReturnValue_t PlocMPSoCHandler::prepareTcDownlinkPwrOn(const uint8_t* commandDat

 ReturnValue_t PlocMPSoCHandler::prepareTcDownlinkPwrOff() {
  ReturnValue_t result = returnvalue::OK;
-  sequenceCount++;
  mpsoc::TcDownlinkPwrOff tcDownlinkPwrOff(spParams, sequenceCount);
  result = tcDownlinkPwrOff.buildPacket();
  if (result != returnvalue::OK) {
-    sequenceCount--;
    return result;
  }
  finishTcPrep(tcDownlinkPwrOff.getFullPacketLen());
@ -504,11 +493,9 @@ ReturnValue_t PlocMPSoCHandler::prepareTcDownlinkPwrOff() {
 ReturnValue_t PlocMPSoCHandler::prepareTcReplayWriteSequence(const uint8_t* commandData,
                                                             size_t commandDataLen) {
  ReturnValue_t result = returnvalue::OK;
-  sequenceCount++;
  mpsoc::TcReplayWriteSeq tcReplayWriteSeq(spParams, sequenceCount);
  result = tcReplayWriteSeq.buildPacket(commandData, commandDataLen);
  if (result != returnvalue::OK) {
-    sequenceCount--;
    return result;
  }
  finishTcPrep(tcReplayWriteSeq.getFullPacketLen());
@ -517,11 +504,9 @@ ReturnValue_t PlocMPSoCHandler::prepareTcReplayWriteSequence(const uint8_t* comm

 ReturnValue_t PlocMPSoCHandler::prepareTcModeReplay() {
  ReturnValue_t result = returnvalue::OK;
-  sequenceCount++;
  mpsoc::TcModeReplay tcModeReplay(spParams, sequenceCount);
  result = tcModeReplay.buildPacket();
  if (result != returnvalue::OK) {
-    sequenceCount--;
    return result;
  }
  finishTcPrep(tcModeReplay.getFullPacketLen());
@ -530,11 +515,9 @@ ReturnValue_t PlocMPSoCHandler::prepareTcModeReplay() {

 ReturnValue_t PlocMPSoCHandler::prepareTcModeIdle() {
  ReturnValue_t result = returnvalue::OK;
-  sequenceCount++;
  mpsoc::TcModeIdle tcModeIdle(spParams, sequenceCount);
  result = tcModeIdle.buildPacket();
  if (result != returnvalue::OK) {
-    sequenceCount--;
    return result;
  }
  finishTcPrep(tcModeIdle.getFullPacketLen());
@ -544,11 +527,9 @@ ReturnValue_t PlocMPSoCHandler::prepareTcModeIdle() {
 ReturnValue_t PlocMPSoCHandler::prepareTcCamCmdSend(const uint8_t* commandData,
                                                    size_t commandDataLen) {
  ReturnValue_t result = returnvalue::OK;
-  sequenceCount++;
  mpsoc::TcCamcmdSend tcCamCmdSend(spParams, sequenceCount);
  result = tcCamCmdSend.buildPacket(commandData, commandDataLen);
  if (result != returnvalue::OK) {
-    sequenceCount--;
    return result;
  }
  finishTcPrep(tcCamCmdSend.getFullPacketLen());
@ -560,6 +541,7 @@ void PlocMPSoCHandler::finishTcPrep(size_t packetLen) {
  nextReplyId = mpsoc::ACK_REPORT;
  rawPacket = commandBuffer;
  rawPacketLen = packetLen;
+  sequenceCount++;
 }

 ReturnValue_t PlocMPSoCHandler::verifyPacket(const uint8_t* start, size_t foundLen) {
--- a/linux/devices/ploc/PlocMPSoCHandler.h
+++ b/linux/devices/ploc/PlocMPSoCHandler.h
@ -10,7 +10,7 @@
 #include "fsfw/ipc/QueueFactory.h"
 #include "fsfw/tmtcservices/SourceSequenceCounter.h"
 #include "fsfw_hal/linux/gpio/Gpio.h"
-#include "fsfw_hal/linux/uart/UartComIF.h"
+#include "fsfw_hal/linux/serial/SerialComIF.h"
 #include "linux/devices/devicedefinitions/MPSoCReturnValuesIF.h"
 #include "linux/devices/devicedefinitions/PlocMPSoCDefinitions.h"
 #include "linux/devices/devicedefinitions/PlocSupervisorDefinitions.h"
@ -107,10 +107,7 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
  MessageQueueIF* eventQueue = nullptr;
  MessageQueueIF* commandActionHelperQueue = nullptr;

-  // Initiate the sequence count with the maximum value. It is incremented before
-  // a packet is sent, so the first value will be 0 accordingly using
-  // the wrap around of the counter.
-  SourceSequenceCounter sequenceCount = SourceSequenceCounter(ccsds::LIMIT_SEQUENCE_COUNT - 1);
+  SourceSequenceCounter sequenceCount = SourceSequenceCounter(0);

  uint8_t commandBuffer[mpsoc::MAX_COMMAND_SIZE];
  SpacePacketCreator creator;
@ -123,7 +120,7 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
   */
  DeviceCommandId_t nextReplyId = mpsoc::NONE;

-  UartComIF* uartComIf = nullptr;
+  SerialComIF* uartComIf = nullptr;

  PlocMPSoCHelper* plocMPSoCHelper = nullptr;
  Gpio uartIsolatorSwitch;
--- a/linux/devices/ploc/PlocMPSoCHelper.cpp
+++ b/linux/devices/ploc/PlocMPSoCHelper.cpp
@ -57,7 +57,7 @@ ReturnValue_t PlocMPSoCHelper::performOperation(uint8_t operationCode) {
 }

 ReturnValue_t PlocMPSoCHelper::setComIF(DeviceCommunicationIF* communicationInterface_) {
-  uartComIF = dynamic_cast<UartComIF*>(communicationInterface_);
+  uartComIF = dynamic_cast<SerialComIF*>(communicationInterface_);
  if (uartComIF == nullptr) {
    sif::warning << "PlocMPSoCHelper::initialize: Invalid uart com if" << std::endl;
    return returnvalue::FAILED;
--- a/linux/devices/ploc/PlocMPSoCHelper.h
+++ b/linux/devices/ploc/PlocMPSoCHelper.h
@ -9,7 +9,7 @@
 #include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
 #include "fsfw/tmtcservices/SourceSequenceCounter.h"
-#include "fsfw_hal/linux/uart/UartComIF.h"
+#include "fsfw_hal/linux/serial/SerialComIF.h"
 #include "linux/devices/devicedefinitions/PlocMPSoCDefinitions.h"
 #ifdef XIPHOS_Q7S
 #include "bsp_q7s/fs/SdCardManager.h"
@ -136,7 +136,7 @@ class PlocMPSoCHelper : public SystemObject, public ExecutableObjectIF {
   * Communication interface of MPSoC responsible for low level access. Must be set by the
   * MPSoC Handler.
   */
-  UartComIF* uartComIF = nullptr;
+  SerialComIF* uartComIF = nullptr;
  // Communication cookie. Must be set by the MPSoC Handler
  CookieIF* comCookie = nullptr;
  // Sequence count, must be set by Ploc MPSoC Handler
--- a/linux/devices/ploc/PlocMemoryDumper.h
+++ b/linux/devices/ploc/PlocMemoryDumper.h
@ -5,7 +5,12 @@
 #include <linux/devices/devicedefinitions/PlocSupervisorDefinitions.h>

 #include "OBSWConfig.h"
+
+#ifdef XIPHOS_Q7S
 #include "bsp_q7s/fs/SdCardManager.h"
+#endif
+
+#include "eive/eventSubsystemIds.h"
 #include "fsfw/action/ActionHelper.h"
 #include "fsfw/action/CommandActionHelper.h"
 #include "fsfw/action/CommandsActionsIF.h"
@ -13,7 +18,7 @@
 #include "fsfw/objectmanager/SystemObject.h"
 #include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
-#include "linux/fsfwconfig/objects/systemObjectList.h"
+#include "objects/systemObjectList.h"

 /**
 * @brief   Because the buffer of the linux tty driver is limited to 2 x 65535 bytes, this class is
--- a/Show More
+++ b/Show More