bump version

bump changelog
expose base set of periodic HK for str
2023-01-24 12:26:20 +01:00 · 2023-01-24 12:25:16 +01:00 · 2023-01-24 12:24:29 +01:00 · 2023-01-23 19:06:51 +01:00 · 2023-01-23 16:18:52 +01:00 · 2023-01-23 16:18:06 +01:00
878 changed files with 77354 additions and 42906 deletions
--- a/.clang-format
+++ b/.clang-format
@ -0,0 +1,8 @@
+---
+BasedOnStyle: Google
+IndentWidth: 2
+---
+Language: Cpp
+ColumnLimit: 100
+ReflowComments: true
+---
--- a/.gitignore
+++ b/.gitignore
@ -1,19 +1,19 @@
 /build*
+/cmake-build*

-Debug
-Debug*
-Release
-Release*
-
+# Eclipse
 .settings
 .metadata
 .project
 .cproject 
-__pycache__
-
-.idea
-
 !misc/eclipse/**/.cproject
 !misc/eclipse/**/.project

+#vscode
+/.vscode
+
+# Python
+__pycache__
+.idea
+
 generators/*.db
--- a/.gitmodules
+++ b/.gitmodules
@ -1,6 +1,3 @@
-[submodule "etl"]
-	path = thirdparty/etl
-	url = https://github.com/ETLCPP/etl.git
 [submodule "arduino"]
 	path = arduino
 	url = https://egit.irs.uni-stuttgart.de/eive/eive_arduino_interface.git
@ -14,11 +11,17 @@
 	path = thirdparty/lwgps
 	url = https://github.com/rmspacefish/lwgps.git
 [submodule "generators/fsfwgen"]
-	path = generators/fsfwgen
-	url = https://egit.irs.uni-stuttgart.de/fsfw/fsfw-generators.git
+	path = generators/deps/fsfwgen
+	url = https://egit.irs.uni-stuttgart.de/fsfw/fsfw-gen.git
 [submodule "thirdparty/arcsec_star_tracker"]
 	path = thirdparty/arcsec_star_tracker
 	url = https://egit.irs.uni-stuttgart.de/eive/arcsec_star_tracker.git
 [submodule "thirdparty/json"]
 	path = thirdparty/json
 	url = https://github.com/nlohmann/json.git
+[submodule "thirdparty/rapidcsv"]
+	path = thirdparty/rapidcsv
+	url = https://github.com/d99kris/rapidcsv.git
+[submodule "thirdparty/gomspace-sw"]
+	path = thirdparty/gomspace-sw
+	url = https://egit.irs.uni-stuttgart.de/eive/gomspace-sw.git
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -0,0 +1,280 @@
+Change Log
+=======
+
+All notable changes to this project will be documented in this file.
+
+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.
+
+# [unreleased]
+
+## 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
+  procedure specified in detail in the README and some high level
+  commands to make this easier for operators.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/302
+- Update for FSFW: `HasReturnvaluesIF` class replaced by namespace `returnvalue`
+- Add some GomSpace clients as a submodule dependency. Use this dependency to deserialize the
+  GomSpace TM tables
+- Add API to retrieve GomSpace device parameter tables
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/287
+- Add API to save and load GomSpace config tables
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/293
+- Increase number of allowed consescutive action commands from 3 to 16
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/294
+- Fix for EM SW: Always create ACS Task
+- Added Scex device handler and Scex uart reader
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/303
+- ACS Subsystem. PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/228
+
+# [v1.13.0] 24.08.2022
+
+- Added first version of ACS Controller with gathers MGM data in a set
+- Some tweaks for IMTQ handler
+
+# [v1.12.1] 05.07.2022
+
+- Disable periodic TCS controller HK generation by default
+
+# [v1.12.0] 04.07.2022
+
+## Added
+
+- Dummy components to run OBSW without relying on external hardware
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/266
+- Basic Thermal Controller
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/266
+- PUS11 TC scheduler
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/259
+- Regular reboot command
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/242
+- Commands for individual RTD devices
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-tmtc/pulls/84
+- `RwAssembly` added to system components. Assembly works in principle,
+  issues making 4 consecutives RWs communicate at once..
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/224
+- Adds a yocto helper script which is able to install the release build binaries
+  (OBSW and Watchdog) into the `q7s-yocto` repository as long as the `q7s-package`
+  or `q7s-yocto` repo was cloned in the same directory the EIVE OBSW repo.
+  This makes updating the root filesystem a lot easier. It also creates and installs a
+  version file.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/248
+- Create the generic image by default for the Q7S build. The unique binary with the
+  username appended at the end is created as a side-product now
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/248
+
+## Fixed
+
+- `q7s-cp.py` bugfix
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/256
+- Generator scripts output now produce platform-independent artifacts
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/267
+
+### Heater
+
+- Adds `HealthIF` to heaters. Heaters are own system object with queues now which allows to set them faulty.
+- SW will attempt to shut down heaters which are on but marked faulty
+- Some simplifications for `HeaterHandler`, use `std::vector` instead of `std::unordered_map` for primary container. Using the heater indexes 0 to 7 allows to use natural array indexing
+- Some additional input sanity checks in `executeAction`
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/236
+
+## Changed
+
+- CCSDS handler improvements
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/268
+- Build unittest as default side product of hosted builds
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/244
+- Let CI/CD build host build and run unittest side product in same step
+- Catch2 pre-installed in CI/CD docker container, Xiphos SDK installed in CI/CD docker
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/247
+- Sun Sensors have names denoting their location and poiting in the satellite now
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/245
+- Better RTD names denoting their purpose (and location consequently)
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/246
+
+# [v1.11.0]
+
+## Fixed
+
+- Host build working again
+
+## Added
+
+- Custom Syrlinks FDIR which disabled most of the default FDIR functionality
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/232
+- Custom Gomspace FDIR which disabled most of the default FDIR functionality
+- Custom Syrlinks FDIR which disabled most of the default FDIR functionality
+
+## Changed
+
+- PCDU handler only called once in PST, but can handle multiple messages now
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/221
+  Bugfix: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/235
+- Update rootfs base of Linux, all related OBSW changes
+- Add `/usr/local/bin` to PATH. All shell scripts are there now
+- Add Syrlinks and TMP devices to Software by default
+- Update GPS Linux Hyperion Handler to use socket interface. Still allows switching
+  back to SHM interface, but the SHM interface is a possible cause of SW crashes
+- Updated code for changed FSFW HAL GPIO API: `readGpio` prototype has changed
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/240 and
+  https://egit.irs.uni-stuttgart.de/eive/fsfw/pulls/76
+
+### GPS
+
+PRs: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/239
+
+- Rename GPS device to `/dev/gps0`
+- Use gpsd version 3.17 now. Includes API changes
+
+### EM and FM splitup & Build Workflow improvements
+
+PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/238
+
+- Split up `bsp_q7s` in separate EM and FM build with module loading set to different
+  default values. The EM object factory is unique which allows building a parallel setup
+  with dummy components
+- All major BSPs have an own `OBSWConfig.h.in` file which simplifies the file significantly
+- Renamed Q7S primary build folders:
+  - `cmake-build-debug-q7s` for primary development build
+  - `cmake-build-release-q7s` for primary release build
+  - `cmake-build-debug-q7s-em` for primary development build of the EM software
+  - `cmake-build-release-q7s-em` for primary release build of the EM software
+- Refactored Q7S helper script handling. It is now intended and preferred to copy the environment
+  script to the same folder level as the `eive-obsw` and source it. This will also
+  add the path containing the shell helper scripts to `PATH`
+- The actual helper shell scripts were renamed as well to `q7s-<buildSystem>-<buildType>.sh`
+
+# [v1.10.1]
+
+Version bump
+
+# [v1.10.0]
+
+For all releases equal or prior to v1.10.0,
+see [milestones](https://egit.irs.uni-stuttgart.de/eive/eive-obsw/milestones)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,273 +1,564 @@
-################################################################################
+# ##############################################################################
 # CMake support for the EIVE OBSW
-# 
+#
 # Author: R. Mueller
-################################################################################
+# ##############################################################################

-################################################################################
+# ##############################################################################
 # Pre-Project preparation
-################################################################################
+# ##############################################################################
 cmake_minimum_required(VERSION 3.13)

+set(OBSW_VERSION_MAJOR_IF_GIT_FAILS 1)
+set(OBSW_VERSION_MINOR_IF_GIT_FAILS 20)
+set(OBSW_VERSION_REVISION_IF_GIT_FAILS 0)
+
 # set(CMAKE_VERBOSE TRUE)

-set(CMAKE_SCRIPT_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
-
-if(TGT_BSP MATCHES "arm/q7s")
-    option(Q7S_SIMPLE_MODE OFF "Simple mode with a minimal main function")
-endif()
-
-option(ADD_ETL_LIB "Add ETL library" ON)
-option(ADD_JSON_LIB "Add JSON librara" ON)
+option(
+  EIVE_HARDCODED_TOOLCHAIN_FILE
+  "\
+For Linux Board Target BSPs, a default toolchain file will be set. Should be set to OFF \
+if a different toolchain file is set externally"
+  ON)

 if(NOT FSFW_OSAL)
-	set(FSFW_OSAL host CACHE STRING "OS for the FSFW.")
+  set(FSFW_OSAL
+      linux
+      CACHE STRING "OS for the FSFW.")
 endif()

-if(TGT_BSP MATCHES "arm/raspberrypi" OR TGT_BSP MATCHES "arm/beagleboneblack")
+if(TGT_BSP)
+  if(TGT_BSP MATCHES "arm/q7s"
+     OR TGT_BSP MATCHES "arm/raspberrypi"
+     OR TGT_BSP MATCHES "arm/beagleboneblack")
    option(LINUX_CROSS_COMPILE ON)
+  endif()
+  if(TGT_BSP MATCHES "arm/raspberrypi" OR TGT_BSP MATCHES "arm/beagleboneblack")
+    option(EIVE_BUILD_GPSD_GPS_HANDLER "Build GPSD dependent GPS Handler" OFF)
+  elseif(TGT_BSP MATCHES "arm/q7s")
+    option(EIVE_Q7S_EM "Build configuration for the EM" OFF)
+    option(EIVE_BUILD_GPSD_GPS_HANDLER "Build GPSD dependent GPS Handler" ON)
+  endif()
+  option(EIVE_CREATE_UNIQUE_OBSW_BIN "Append username to generated binary name"
+         ON)
+else()
+  option(EIVE_CREATE_UNIQUE_OBSW_BIN "Append username to generated binary name"
+         OFF)
 endif()

+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 # Perform steps like loading toolchain files where applicable.
-include(${CMAKE_SCRIPT_PATH}/PreProjectConfig.cmake)
+include(PreProjectConfig)
 pre_project_config()

 # Project Name
-project(eive_obsw ASM C CXX)
-
-################################################################################
-# Pre-Sources preparation
-################################################################################
+project(eive-obsw)

 # Specify the C++ standard
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED True)

+include(EiveHelpers)
+
+option(EIVE_ADD_ETL_LIB "Add ETL library" ON)
+option(EIVE_ADD_JSON_LIB "Add JSON library" ON)
+
+set(OBSW_MAX_SCHEDULED_TCS 500)
+
+if(EIVE_Q7S_EM)
+  set(OBSW_Q7S_EM
+      1
+      CACHE STRING "Q7S EM configuration")
+  set(INIT_VAL 0)
+else()
+  set(OBSW_Q7S_EM
+      0
+      CACHE STRING "Q7S EM configuration")
+  set(INIT_VAL 1)
+endif()
+set(OBSW_ADD_MGT
+    ${INIT_VAL}
+    CACHE STRING "Add MGT module")
+set(OBSW_ADD_BPX_BATTERY_HANDLER
+    ${INIT_VAL}
+    CACHE STRING "Add MGT module")
+set(OBSW_ADD_STAR_TRACKER
+    ${INIT_VAL}
+    CACHE STRING "Add Startracker module")
+set(OBSW_ADD_SUN_SENSORS
+    ${INIT_VAL}
+    CACHE STRING "Add sun sensor module")
+set(OBSW_ADD_SUS_BOARD_ASS
+    ${INIT_VAL}
+    CACHE STRING "Add sun sensor board assembly")
+set(OBSW_ADD_ACS_BOARD
+    ${INIT_VAL}
+    CACHE STRING "Add ACS board module")
+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
+    ${INIT_VAL}
+    CACHE STRING "Add RTD devices")
+set(OBSW_ADD_RAD_SENSORS
+    ${INIT_VAL}
+    CACHE STRING "Add Rad Sensor module")
+set(OBSW_ADD_PL_PCDU
+    ${INIT_VAL}
+    CACHE STRING "Add Payload PCDU modukle")
+set(OBSW_ADD_SYRLINKS
+    1
+    CACHE STRING "Add Syrlinks module")
+set(OBSW_ADD_TMP_DEVICES
+    ${INIT_VAL}
+    CACHE STRING "Add TMP devices")
+set(OBSW_ADD_GOMSPACE_PCDU
+    ${INIT_VAL}
+    CACHE STRING "Add GomSpace PCDU modules")
+set(OBSW_ADD_RW
+    ${INIT_VAL}
+    CACHE STRING "Add RW modules")
+set(OBSW_ADD_SCEX_DEVICE
+    ${INIT_VAL}
+    CACHE STRING "Add Solar Cell Experiment module")
+set(OBSW_SYRLINKS_SIMULATED
+    ${OBSW_Q7S_EM}
+    CACHE STRING "Syrlinks is simulated")
+
+# ##############################################################################
+# Pre-Sources preparation
+# ##############################################################################
+
+# Version handling
+set(GIT_VER_HANDLING_OK FALSE)
+if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
+  determine_version_with_git("--exclude" "docker_*")
+  set(GIT_INFO
+      ${GIT_INFO}
+      CACHE STRING "Version information retrieved with git describe")
+  if(GIT_INFO)
+    set(GIT_INFO
+        ${GIT_INFO}
+        CACHE STRING "Version information retrieved with git describe")
+    list(GET GIT_INFO 1 OBSW_VERSION_MAJOR)
+    list(GET GIT_INFO 2 OBSW_VERSION_MINOR)
+    list(GET GIT_INFO 3 OBSW_VERSION_REVISION)
+    list(GET GIT_INFO 4 OBSW_VERSION_CST_GIT_SHA1)
+    if(NOT OBSW_VERSION_MAJOR)
+      set(OBSW_VERSION_MAJOR ${OBSW_VERSION_MAJOR_IF_GIT_FAILS})
+    endif()
+    if(NOT OBSW_VERSION_MINOR)
+      set(FSFW_SUBVERSION ${OBSW_VERSION_MINOR_IF_GIT_FAILS})
+    endif()
+    if(NOT OBSW_VERSION_REVISION)
+      set(FSFW_REVISION ${OBSW_VERSION_REVISION_IF_GIT_FAILS})
+    endif()
+    set(GIT_VER_HANDLING_OK TRUE)
+  else()
+    set(GIT_VER_HANDLING_OK FALSE)
+  endif()
+endif()
+if(NOT GIT_VER_HANDLING_OK)
+  set(OBSW_VERSION_MAJOR ${OBSW_VERSION_MAJOR_IF_GIT_FAILS})
+  set(OBSW_VERSION_MINOR ${OBSW_VERSION_MINOR_IF_GIT_FAILS})
+  set(OBSW_VERSION_REVISION ${OBSW_VERSION_REVISION_IF_GIT_FAILS})
+endif()
+
 # Set names and variables
-set(TARGET_NAME ${CMAKE_PROJECT_NAME}) 
+set(OBSW_NAME ${CMAKE_PROJECT_NAME})
+set(WATCHDOG_NAME eive-watchdog)
+set(SIMPLE_OBSW_NAME eive-simple)
+set(UNITTEST_NAME eive-unittest)
 set(LIB_FSFW_NAME fsfw)
-set(LIB_ETL_NAME etl)
+set(LIB_EIVE_MISSION eive-mission)
+set(LIB_ETL_TARGET etl::etl)
 set(LIB_CSP_NAME libcsp)
 set(LIB_LWGPS_NAME lwgps)
 set(LIB_ARCSEC wire)
+set(LIB_GOMSPACE_CLIENTS gs_clients)
+set(LIB_GOMSPACE_CSP gs_csp)
+
 set(THIRD_PARTY_FOLDER thirdparty)
 set(LIB_CXX_FS -lstdc++fs)
+set(LIB_CATCH2 Catch2)
+set(LIB_GPS gps)
 set(LIB_JSON_NAME nlohmann_json::nlohmann_json)
+set(LIB_DUMMIES dummies)

 # Set path names
 set(FSFW_PATH fsfw)
-set(MISSION_PATH mission)
-set(TEST_PATH test/testtasks)
+set(TEST_PATH test)
+set(UNITTEST_PATH unittest)
 set(LINUX_PATH linux)
+set(LIB_GOMSPACE_PATH ${THIRD_PARTY_FOLDER}/gomspace-sw)
 set(COMMON_PATH common)
+set(DUMMY_PATH dummies)
+set(WATCHDOG_PATH watchdog)
 set(COMMON_CONFIG_PATH ${COMMON_PATH}/config)
+set(UNITTEST_CFG_PATH ${UNITTEST_PATH}/testcfg)

-set(FSFW_HAL_LIB_PATH fsfw_hal)
-set(CSP_LIB_PATH ${THIRD_PARTY_FOLDER}/libcsp)
-set(ETL_LIB_PATH ${THIRD_PARTY_FOLDER}/etl)
-set(LWGPS_LIB_PATH ${THIRD_PARTY_FOLDER}/lwgps)
-set(ARCSEC_LIB_PATH ${THIRD_PARTY_FOLDER}/arcsec_star_tracker)
+set(LIB_EIVE_MISSION_PATH mission)
+set(LIB_ETL_PATH ${THIRD_PARTY_FOLDER}/etl)
+set(LIB_CATCH2_PATH ${THIRD_PARTY_FOLDER}/Catch2)
+set(LIB_LWGPS_PATH ${THIRD_PARTY_FOLDER}/lwgps)
+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(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.
-include (${CMAKE_SCRIPT_PATH}/HardwareOsPreConfig.cmake)
 pre_source_hw_os_config()

 if(TGT_BSP)
-    if(TGT_BSP MATCHES "arm/q7s" OR TGT_BSP MATCHES "arm/raspberrypi"
-        OR TGT_BSP MATCHES "arm/beagleboneblack"
-    )
-        set(FSFW_CONFIG_PATH "linux/fsfwconfig")
-        if(NOT Q7S_SIMPLE_MODE)
-            set(ADD_LINUX_FILES TRUE)
-            set(ADD_CSP_LIB TRUE)
-            set(FSFW_HAL_ADD_LINUX ON)
-        endif()
-    endif()
-   
-    if(${TGT_BSP} MATCHES "arm/raspberrypi") 
-        add_definitions(-DRASPBERRY_PI)
-        set(FSFW_HAL_ADD_RASPBERRY_PI ON)
-    endif()
-    
-    if(${TGT_BSP} MATCHES "arm/beagleboneblack") 
-        add_definitions(-DBEAGLEBONEBLACK)
-    endif()
-    
-    if(${TGT_BSP} MATCHES "arm/q7s")
-        add_definitions(-DXIPHOS_Q7S)
+  set(LIBGPS_VERSION_MAJOR 3)
+  # I assume a newer version than 3.17 will be installed on other Linux board
+  # than the Q7S
+  set(LIBGPS_VERSION_MINOR 20)
+  if(TGT_BSP MATCHES "arm/q7s"
+     OR TGT_BSP MATCHES "arm/raspberrypi"
+     OR TGT_BSP MATCHES "arm/beagleboneblack"
+     OR TGT_BSP MATCHES "arm/egse"
+     OR TGT_BSP MATCHES "arm/te0720-1cfa")
+    find_library(${LIB_GPS} gps)
+    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")
+    # Used by configure file
+    set(RASPBERRY_PI ON)
+    set(FSFW_HAL_ADD_RASPBERRY_PI ON)
+  endif()
+
+  if(TGT_BSP MATCHES "arm/egse")
+    # Used by configure file
+    set(EGSE ON)
+    set(FSFW_HAL_LINUX_ADD_LIBGPIOD OFF)
+    set(OBSW_ADD_STAR_TRACKER 1)
+    set(OBSW_DEBUG_STARTRACKER 1)
+  endif()
+
+  if(TGT_BSP MATCHES "arm/beagleboneblack")
+    # Used by configure file
+    set(BEAGLEBONEBLACK ON)
+  endif()
+
+  if(TGT_BSP MATCHES "arm/q7s")
+    # Used by configure file
+    set(XIPHOS_Q7S ON)
+    set(LIBGPS_VERSION_MAJOR 3)
+    set(LIBGPS_VERSION_MINOR 17)
+  endif()
+
+  if(TGT_BSP MATCHES "arm/te0720-1cfa")
+    set(TE0720_1CFA ON)
+  endif()
 else()
-    # Required by FSFW library
-    set(FSFW_CONFIG_PATH "${BSP_PATH}/fsfwconfig")
+  # Required by FSFW library
+  set(FSFW_CONFIG_PATH "${BSP_PATH}/fsfwconfig")
+  if(UNIX)
+    set(EIVE_ADD_LINUX_FILES ON)
+  endif()
 endif()

 # Configuration files
 configure_file(${COMMON_CONFIG_PATH}/commonConfig.h.in commonConfig.h)
 configure_file(${FSFW_CONFIG_PATH}/FSFWConfig.h.in FSFWConfig.h)
-configure_file(${FSFW_CONFIG_PATH}/OBSWConfig.h.in OBSWConfig.h)
-if(${TGT_BSP} MATCHES "arm/q7s")
-    configure_file(${BSP_PATH}/boardconfig/q7sConfig.h.in q7sConfig.h)
-elseif(${TGT_BSP} MATCHES "arm/raspberrypi")
-    configure_file(${BSP_PATH}/boardconfig/rpiConfig.h.in rpiConfig.h)
+configure_file(${BSP_PATH}/OBSWConfig.h.in OBSWConfig.h)
+if(TGT_BSP MATCHES "arm/q7s")
+  configure_file(${BSP_PATH}/boardconfig/q7sConfig.h.in q7sConfig.h)
+elseif(TGT_BSP MATCHES "arm/raspberrypi" OR TGT_BSP MATCHES "arm/egse")
+  configure_file(${BSP_PATH}/boardconfig/rpiConfig.h.in rpiConfig.h)
 endif()

+configure_file(${WATCHDOG_PATH}/watchdogConf.h.in watchdogConf.h)
+
 # Set common config path for FSFW
-set(FSFW_ADDITIONAL_INC_PATHS 
-    "${COMMON_PATH}/config"
-    ${CMAKE_CURRENT_BINARY_DIR}
-)
-# Set for lwgps library
-set(LWGPS_CONFIG_PATH "${COMMON_PATH}/config")
+set(FSFW_ADDITIONAL_INC_PATHS "${COMMON_PATH}/config"
+                              ${CMAKE_CURRENT_BINARY_DIR})

-################################################################################
+# ##############################################################################
 # Executable and Sources
-################################################################################
+# ##############################################################################

-# Add executable
-add_executable(${TARGET_NAME})
+# global compiler options need to be set before adding executables
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+  # Remove unused sections.
+  add_compile_options("-ffunction-sections" "-fdata-sections")

-if(ADD_CSP_LIB)
-    add_subdirectory(${CSP_LIB_PATH})
+  # Removed unused sections.
+  add_link_options("-Wl,--gc-sections")
+
+elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+  set(COMPILER_FLAGS "/permissive-")
 endif()

-if(ADD_ETL_LIB)
-    add_subdirectory(${ETL_LIB_PATH})
-endif()
-
-if(ADD_LINUX_FILES)
-    add_subdirectory(${LINUX_PATH})
-endif()
-
-if(ADD_JSON_LIB)
-    add_subdirectory(${LIB_JSON_PATH})
-endif()
-
-add_subdirectory(${BSP_PATH})
-add_subdirectory(${COMMON_PATH})
-
-if(NOT Q7S_SIMPLE_MODE)
-    add_subdirectory(${LWGPS_LIB_PATH})
-    add_subdirectory(${FSFW_PATH})
-    add_subdirectory(${MISSION_PATH})
-    add_subdirectory(${TEST_PATH})
-    add_subdirectory(${ARCSEC_LIB_PATH})
-endif()
-
-
-################################################################################
-# Post-Sources preparation
-################################################################################
-
-set_property(CACHE FSFW_OSAL PROPERTY STRINGS host linux)
-
-if(NOT Q7S_SIMPLE_MODE)
-    # Add libraries for all sources.
-    target_link_libraries(${TARGET_NAME} PRIVATE
-        ${LIB_FSFW_NAME}
-        ${LIB_OS_NAME}
-        ${LIB_LWGPS_NAME}
-        ${LIB_ARCSEC}
-        ${LIB_CXX_FS}
-    )
-endif()
-
-if(ADD_ETL_LIB)
-    target_link_libraries(${TARGET_NAME} PRIVATE
-        ${LIB_ETL_NAME}
-    )
-endif()
-
-if(ADD_CSP_LIB)
-	target_link_libraries(${TARGET_NAME} PRIVATE
-		${LIB_CSP_NAME}
-	)
-endif()
-
-if(ADD_JSON_LIB)
-    target_link_libraries(${TARGET_NAME} PRIVATE
-        ${LIB_JSON_NAME}
-    )
-endif()
-
-# Add include paths for all sources.
-target_include_directories(${TARGET_NAME} PRIVATE
-	${CMAKE_CURRENT_SOURCE_DIR}
-	${FSFW_CONFIG_PATH}
-	${CMAKE_CURRENT_BINARY_DIR}
-	${ARCSEC_LIB_PATH}
-)	
+add_library(${LIB_EIVE_MISSION})
+add_library(${LIB_DUMMIES})

+# Add main executable
+add_executable(${OBSW_NAME})
+set(OBSW_BIN_NAME ${CMAKE_PROJECT_NAME})

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

-	# Removed unused sections.
-	target_link_options(${TARGET_NAME} PRIVATE
-		"-Wl,--gc-sections"
-	)
-	
-elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-	set(COMPILER_FLAGS "/permissive-")
+set_target_properties(${OBSW_NAME} PROPERTIES OUTPUT_NAME ${OBSW_BIN_NAME})
+
+# Watchdog
+if(TGT_BSP MATCHES "arm/q7s")
+  add_executable(${WATCHDOG_NAME})
+else()
+  add_executable(${WATCHDOG_NAME} EXCLUDE_FROM_ALL)
+endif()
+
+add_subdirectory(${WATCHDOG_PATH})
+target_link_libraries(${WATCHDOG_NAME} PUBLIC ${LIB_CXX_FS})
+target_include_directories(${WATCHDOG_NAME} PUBLIC ${CMAKE_BINARY_DIR})
+
+# unittests
+if(NOT TGT_BSP)
+  add_executable(${UNITTEST_NAME})
+else()
+  add_executable(${UNITTEST_NAME} EXCLUDE_FROM_ALL)
+endif()
+
+if(EIVE_ADD_ETL_LIB)
+
+endif()
+
+if(EIVE_ADD_JSON_LIB)
+  add_subdirectory(${LIB_JSON_PATH})
+endif()
+
+add_subdirectory(thirdparty)
+
+if(EIVE_ADD_LINUX_FILES)
+  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})
+
+add_subdirectory(${COMMON_PATH})
+add_subdirectory(${DUMMY_PATH})
+
+add_subdirectory(${LIB_LWGPS_PATH})
+add_subdirectory(${FSFW_PATH})
+add_subdirectory(${LIB_EIVE_MISSION_PATH})
+add_subdirectory(${TEST_PATH})
+
+add_subdirectory(${UNITTEST_PATH})
+
+# This should have already been downloaded by the FSFW Still include it to be
+# safe find_package(etl ${FSFW_ETL_LIB_MAJOR_VERSION} CONFIG QUIET) Not
+# installed, so use FetchContent to download and provide etl if(NOT etl_FOUND)
+message(
+  STATUS
+    "No ETL installation was found with find_package. Installing and providing "
+    "etl with FindPackage")
+include(FetchContent)
+FetchContent_Declare(
+  etl
+  GIT_REPOSITORY https://github.com/ETLCPP/etl
+  GIT_TAG ${FSFW_ETL_LIB_VERSION})
+list(APPEND FSFW_FETCH_CONTENT_TARGETS etl)
+# endif()
+
+# Use same Catch2 version as framework
+if(NOT (TGT_BSP MATCHES "arm/te0720-1cfa")
+   AND NOT (TGT_BSP MATCHES "arm/q7s")
+   AND NOT (TGT_BSP MATCHES "arm/raspberrypi"))
+  # Check whether the user has already installed Catch2 first
+  find_package(Catch2 ${FSFW_CATCH2_LIB_MAJOR_VERSION} CONFIG QUIET)
+  # Not installed, so use FetchContent to download and provide Catch2
+  if(NOT Catch2_FOUND)
+    message(
+      STATUS
+        "${MSG_PREFIX} Catch2 installation not found. Downloading Catch2 library with FetchContent"
+    )
+    include(FetchContent)
+
+    FetchContent_Declare(
+      Catch2
+      GIT_REPOSITORY https://github.com/catchorg/Catch2.git
+      GIT_TAG ${FSFW_CATCH2_LIB_VERSION})
+
+    list(APPEND FSFW_FETCH_CONTENT_TARGETS Catch2)
+  endif()
+endif()
+
+# The documentation for FetchContent recommends declaring all the dependencies
+# before making them available. We make all declared dependency available here
+# after their declaration
+if(FSFW_FETCH_CONTENT_TARGETS)
+  FetchContent_MakeAvailable(${FSFW_FETCH_CONTENT_TARGETS})
+  if(TARGET etl)
+    add_library(${LIB_ETL_TARGET} ALIAS etl)
+  endif()
+  if(TARGET Catch2)
+    # Fixes regression -preview4, to be confirmed in later releases Related
+    # GitHub issue: https://github.com/catchorg/Catch2/issues/2417
+    set_target_properties(Catch2 PROPERTIES DEBUG_POSTFIX "")
+    set_target_properties(Catch2 PROPERTIES EXCLUDE_FROM_ALL "true")
+    set_target_properties(Catch2WithMain PROPERTIES EXCLUDE_FROM_ALL "true")
+  endif()
+endif()
+
+# ##############################################################################
+# Post-Sources preparation
+# ##############################################################################
+
+# Add libraries
+target_link_libraries(${LIB_EIVE_MISSION}
+                      PUBLIC ${LIB_FSFW_NAME} ${LIB_LWGPS_NAME} ${LIB_OS_NAME})
+
+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}
+                                                   ${LIB_GOMSPACE_CLIENTS})
+endif()
+
+target_link_libraries(${UNITTEST_NAME} PRIVATE Catch2 ${LIB_EIVE_MISSION}
+                                               rapidcsv ${LIB_DUMMIES})
+
+if(TGT_BSP MATCHES "arm/egse")
+  target_link_libraries(${OBSW_NAME} PRIVATE ${LIB_ARCSEC})
+endif()
+
+if(EIVE_ADD_ETL_LIB)
+  target_link_libraries(${LIB_EIVE_MISSION} PUBLIC ${LIB_ETL_TARGET})
+endif()
+
+if(EIVE_ADD_JSON_LIB)
+  target_link_libraries(${LIB_EIVE_MISSION} PUBLIC ${LIB_JSON_NAME})
+endif()
+
+target_link_libraries(${LIB_EIVE_MISSION} PUBLIC ${LIB_CXX_FS})
+
+# Add include paths for all sources.
+target_include_directories(
+  ${LIB_EIVE_MISSION} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ${FSFW_CONFIG_PATH}
+                             ${CMAKE_CURRENT_BINARY_DIR} ${LIB_ARCSEC_PATH})
+
+target_include_directories(
+  ${LIB_DUMMIES} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ${FSFW_CONFIG_PATH}
+                        ${CMAKE_CURRENT_BINARY_DIR})
+
+if(TGT_BSP MATCHES "arm/q7s" OR TGT_BSP MATCHES "arm/egse")
+  target_include_directories(${LIB_EIVE_MISSION} PUBLIC ${ARCSEC_LIB_PATH})
 endif()

 if(CMAKE_VERBOSE)
-	message(STATUS "Warning flags: ${WARNING_FLAGS}")
+  message(STATUS "Warning flags: ${WARNING_FLAGS}")
 endif()
-		 

-# Compile options for all sources.
-target_compile_options(${TARGET_NAME} PRIVATE
-	${WARNING_FLAGS}
-)
-
-if(${CMAKE_CROSSCOMPILING})
-	include (${CMAKE_SCRIPT_PATH}/HardwareOsPostConfig.cmake)
-	post_source_hw_os_config()
+if(CMAKE_CROSSCOMPILING)
+  include(HardwareOsPostConfig)
+  post_source_hw_os_config()
 endif()

 if(NOT CMAKE_SIZE)
-	set(CMAKE_SIZE size)
-	if(WIN32)
-		set(FILE_SUFFIX ".exe")
-	endif()
+  set(CMAKE_SIZE size)
+  if(WIN32)
+    set(FILE_SUFFIX ".exe")
+  endif()
 endif()

-if(TGT_BSP)
-	set(TARGET_STRING "Target BSP: ${TGT_BSP}")
+if(EIVE_BUILD_WATCHDOG)
+  set(TARGET_STRING "OBSW Watchdog")
 else()
-	set(TARGET_STRING "Target BSP: Hosted")
+  if(TGT_BSP)
+    set(TARGET_STRING "Target BSP: ${TGT_BSP}")
+  else()
+    set(TARGET_STRING "Target BSP: Hosted")
+  endif()
 endif()

-string(CONCAT POST_BUILD_COMMENT
-    "Build directory: ${CMAKE_BINARY_DIR}\n"
-    "Target OSAL: ${FSFW_OSAL}\n"
-    "Target Build Type: ${CMAKE_BUILD_TYPE}\n"
-    "${TARGET_STRING}"
-)
+install(TARGETS ${OBSW_NAME} RUNTIME DESTINATION bin)
+
+string(CONCAT POST_BUILD_COMMENT "Build directory: ${CMAKE_BINARY_DIR}\n"
+              "Target OSAL: ${FSFW_OSAL}\n"
+              "Target Build Type: ${CMAKE_BUILD_TYPE}\n" "${TARGET_STRING}")

 add_custom_command(
-   TARGET ${TARGET_NAME}
-   POST_BUILD
-   COMMAND ${CMAKE_SIZE} ${TARGET_NAME}${FILE_SUFFIX}
-   COMMENT ${POST_BUILD_COMMENT}
-)
+  TARGET ${OBSW_NAME}
+  POST_BUILD
+  COMMAND ${CMAKE_SIZE} ${OBSW_BIN_NAME}${FILE_SUFFIX}
+  COMMENT ${POST_BUILD_COMMENT})

-include (${CMAKE_SCRIPT_PATH}/BuildType.cmake)
+include(BuildType)
 set_build_type()
--- a/12
+++ b/12
@ -0,0 +1,12 @@
+python_script := './cmake/scripts/cmake-build-cfg.py'
+
+default: q7s-debug-make
+
+q7s-debug-make:
+	{{python_script}} -o linux -g make -b debug -t "arm/q7s" -l build-Debug-Q7S
+
+q7s-release-make:
+	{{python_script}} -o linux -g make -b release -t "arm/q7s" -l build-Release-Q7S
+
+q7s-debug-ninja:
+	{{python_script}} -o linux -g ninja -b debug -t "arm/q7s" -l build-Debug-Q7S
--- a/202
+++ b/202
@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
--- a/13
+++ b/13
@ -0,0 +1,13 @@
+Copyright 2021 Institute of Space Systems (IRS), University of Stuttgart
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
--- a/README.md
+++ b/README.md
--- a/linux/archive/gpio/CMakeLists.txt
+++ b/linux/archive/gpio/CMakeLists.txt
--- a/archive/gpio/GpioCookie.cpp
+++ b/archive/gpio/GpioCookie.cpp
@ -0,0 +1,32 @@
+#include "GpioCookie.h"
+
+#include <fsfw/serviceinterface/ServiceInterface.h>
+
+GpioCookie::GpioCookie() {}
+
+ReturnValue_t GpioCookie::addGpio(gpioId_t gpioId, GpioBase* gpioConfig) {
+  if (gpioConfig == nullptr) {
+    sif::debug << "GpioCookie::addGpio: gpioConfig is nullpointer" << std::endl;
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  auto gpioMapIter = gpioMap.find(gpioId);
+  if (gpioMapIter == gpioMap.end()) {
+    auto statusPair = gpioMap.emplace(gpioId, gpioConfig);
+    if (statusPair.second == false) {
+#if FSFW_VERBOSE_LEVEL >= 1
+      sif::error << "GpioCookie::addGpio: Failed to add GPIO " << gpioId << " to GPIO map"
+                 << std::endl;
+#endif
+      return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+#if FSFW_VERBOSE_LEVEL >= 1
+  sif::error << "GpioCookie::addGpio: GPIO already exists in GPIO map " << std::endl;
+#endif
+  return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+GpioMap GpioCookie::getGpioMap() const { return gpioMap; }
+
+GpioCookie::~GpioCookie() {}
--- a/linux/archive/gpio/GpioCookie.h
+++ b/linux/archive/gpio/GpioCookie.h
@ -1,11 +1,12 @@
 #ifndef LINUX_GPIO_GPIOCOOKIE_H_
 #define LINUX_GPIO_GPIOCOOKIE_H_

-#include "GpioIF.h"
-#include "gpioDefinitions.h"
 #include <fsfw/devicehandlers/CookieIF.h>
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>

+#include "GpioIF.h"
+#include "gpioDefinitions.h"
+
 /**
 * @brief   Cookie for the GpioIF. Allows the GpioIF to determine which
 * 			GPIOs to initialize and whether they should be configured as in- or
@ -16,24 +17,23 @@
 *
 * @author 	J. Meier
 */
-class GpioCookie: public CookieIF {
-public:
+class GpioCookie : public CookieIF {
+ public:
+  GpioCookie();

-    GpioCookie();
+  virtual ~GpioCookie();

-    virtual ~GpioCookie();
+  ReturnValue_t addGpio(gpioId_t gpioId, GpioBase* gpioConfig);
+  /**
+   * @brief	Get map with registered GPIOs.
+   */
+  GpioMap getGpioMap() const;

-    ReturnValue_t addGpio(gpioId_t gpioId, GpioBase* gpioConfig);
-    /**
-     * @brief	Get map with registered GPIOs.
-     */
-    GpioMap getGpioMap() const;
-
-private:
-    /**
-     * Returns a copy of the internal GPIO map.
-     */
-    GpioMap gpioMap;
+ private:
+  /**
+   * Returns a copy of the internal GPIO map.
+   */
+  GpioMap gpioMap;
 };

 #endif /* LINUX_GPIO_GPIOCOOKIE_H_ */
--- a/archive/gpio/GpioIF.h
+++ b/archive/gpio/GpioIF.h
@ -0,0 +1,54 @@
+#ifndef LINUX_GPIO_GPIOIF_H_
+#define LINUX_GPIO_GPIOIF_H_
+
+#include <fsfw/devicehandlers/CookieIF.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+#include "gpioDefinitions.h"
+
+class GpioCookie;
+
+/**
+ * @brief	This class defines the interface for objects requiring the control
+ * 			over GPIOs.
+ * @author	J. Meier
+ */
+class GpioIF : public HasReturnvaluesIF {
+ public:
+  virtual ~GpioIF(){};
+
+  /**
+   * @brief   Called by the GPIO using object.
+   * @param cookie	Cookie specifying informations of the GPIOs required
+   * 					by a object.
+   */
+  virtual ReturnValue_t addGpios(GpioCookie* cookie) = 0;
+
+  /**
+   * @brief	By implementing this function a child must provide the
+   * 			functionality to pull a certain GPIO to high logic level.
+   *
+   * @param gpioId	A unique number which specifies the GPIO to drive.
+   * @return  Returns RETURN_OK for success. This should never return RETURN_FAILED.
+   */
+  virtual ReturnValue_t pullHigh(gpioId_t gpioId) = 0;
+
+  /**
+   * @brief	By implementing this function a child must provide the
+   * 			functionality to pull a certain GPIO to low logic level.
+   *
+   * @param gpioId	A unique number which specifies the GPIO to drive.
+   */
+  virtual ReturnValue_t pullLow(gpioId_t gpioId) = 0;
+
+  /**
+   * @brief   This function requires a child to implement the functionality to read the state of
+   *          an ouput or input gpio.
+   *
+   * @param gpioId    A unique number which specifies the GPIO to read.
+   * @param gpioState State of GPIO will be written to this pointer.
+   */
+  virtual ReturnValue_t readGpio(gpioId_t gpioId, int* gpioState) = 0;
+};
+
+#endif /* LINUX_GPIO_GPIOIF_H_ */
--- a/archive/gpio/LinuxLibgpioIF.cpp
+++ b/archive/gpio/LinuxLibgpioIF.cpp
@ -0,0 +1,295 @@
+#include "LinuxLibgpioIF.h"
+
+#include <fsfw/serviceinterface/ServiceInterface.h>
+#include <gpiod.h>
+#include <linux/gpio/gpioDefinitions.h>
+#include <unistd.h>
+
+#include <utility>
+
+#include "GpioCookie.h"
+
+LinuxLibgpioIF::LinuxLibgpioIF(object_id_t objectId) : SystemObject(objectId) {
+  struct gpiod_chip* chip = gpiod_chip_open_by_label("/amba_pl/gpio@42030000");
+
+  sif::debug << chip->name << std::endl;
+}
+
+LinuxLibgpioIF::~LinuxLibgpioIF() {}
+
+ReturnValue_t LinuxLibgpioIF::addGpios(GpioCookie* gpioCookie) {
+  ReturnValue_t result;
+  if (gpioCookie == nullptr) {
+    sif::error << "LinuxLibgpioIF::initialize: Invalid cookie" << std::endl;
+    return RETURN_FAILED;
+  }
+
+  GpioMap mapToAdd = gpioCookie->getGpioMap();
+
+  /* Check whether this ID already exists in the map and remove duplicates */
+  result = checkForConflicts(mapToAdd);
+  if (result != RETURN_OK) {
+    return result;
+  }
+
+  result = configureGpios(mapToAdd);
+  if (result != RETURN_OK) {
+    return RETURN_FAILED;
+  }
+
+  /* Register new GPIOs in gpioMap */
+  gpioMap.insert(mapToAdd.begin(), mapToAdd.end());
+
+  return RETURN_OK;
+}
+
+ReturnValue_t LinuxLibgpioIF::configureGpios(GpioMap& mapToAdd) {
+  for (auto& gpioConfig : mapToAdd) {
+    switch (gpioConfig.second->gpioType) {
+      case (gpio::GpioTypes::NONE): {
+        return GPIO_INVALID_INSTANCE;
+      }
+      case (gpio::GpioTypes::GPIOD_REGULAR): {
+        GpiodRegular* regularGpio = dynamic_cast<GpiodRegular*>(gpioConfig.second);
+        if (regularGpio == nullptr) {
+          return GPIO_INVALID_INSTANCE;
+        }
+        configureRegularGpio(gpioConfig.first, regularGpio);
+        break;
+      }
+      case (gpio::GpioTypes::CALLBACK): {
+        auto gpioCallback = dynamic_cast<GpioCallback*>(gpioConfig.second);
+        if (gpioCallback->callback == nullptr) {
+          return GPIO_INVALID_INSTANCE;
+        }
+        gpioCallback->callback(gpioConfig.first, gpio::GpioOperation::WRITE,
+                               gpioCallback->initValue, gpioCallback->callbackArgs);
+      }
+    }
+  }
+  return RETURN_OK;
+}
+
+ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, GpiodRegular* regularGpio) {
+  std::string chipname;
+  unsigned int lineNum;
+  struct gpiod_chip* chip;
+  gpio::Direction direction;
+  std::string consumer;
+  struct gpiod_line* lineHandle;
+  int result = 0;
+
+  chipname = regularGpio->chipname;
+  chip = gpiod_chip_open_by_name(chipname.c_str());
+  if (!chip) {
+    sif::error << "LinuxLibgpioIF::configureGpios: Failed to open chip " << chipname
+               << ". Gpio ID: " << gpioId << std::endl;
+    return RETURN_FAILED;
+  }
+
+  lineNum = regularGpio->lineNum;
+  lineHandle = gpiod_chip_get_line(chip, lineNum);
+  if (!lineHandle) {
+    sif::error << "LinuxLibgpioIF::configureGpios: Failed to open line for GPIO with id " << gpioId
+               << std::endl;
+    gpiod_chip_close(chip);
+    return RETURN_FAILED;
+  }
+
+  direction = regularGpio->direction;
+  consumer = regularGpio->consumer;
+  /* Configure direction and add a description to the GPIO */
+  switch (direction) {
+    case (gpio::OUT): {
+      result = gpiod_line_request_output(lineHandle, consumer.c_str(), regularGpio->initValue);
+      if (result < 0) {
+        sif::error << "LinuxLibgpioIF::configureGpios: Failed to request line " << lineNum
+                   << " from GPIO instance with ID: " << gpioId << std::endl;
+        gpiod_line_release(lineHandle);
+        return RETURN_FAILED;
+      }
+      break;
+    }
+    case (gpio::IN): {
+      result = gpiod_line_request_input(lineHandle, consumer.c_str());
+      if (result < 0) {
+        sif::error << "LinuxLibgpioIF::configureGpios: Failed to request line " << lineNum
+                   << " from GPIO instance with ID: " << gpioId << std::endl;
+        gpiod_line_release(lineHandle);
+        return RETURN_FAILED;
+      }
+      break;
+    }
+    default: {
+      sif::error << "LinuxLibgpioIF::configureGpios: Invalid direction specified" << std::endl;
+      return GPIO_INVALID_INSTANCE;
+    }
+  }
+  /**
+   * Write line handle to GPIO configuration instance so it can later be used to set or
+   * read states of GPIOs.
+   */
+  regularGpio->lineHandle = lineHandle;
+  return RETURN_OK;
+}
+
+ReturnValue_t LinuxLibgpioIF::pullHigh(gpioId_t gpioId) {
+  gpioMapIter = gpioMap.find(gpioId);
+  if (gpioMapIter == gpioMap.end()) {
+    sif::warning << "LinuxLibgpioIF::driveGpio: Unknown GPIOD ID " << gpioId << std::endl;
+    return UNKNOWN_GPIO_ID;
+  }
+
+  if (gpioMapIter->second->gpioType == gpio::GpioTypes::GPIOD_REGULAR) {
+    return driveGpio(gpioId, dynamic_cast<GpiodRegular*>(gpioMapIter->second), 1);
+  } else {
+    auto gpioCallback = dynamic_cast<GpioCallback*>(gpioMapIter->second);
+    if (gpioCallback->callback == nullptr) {
+      return GPIO_INVALID_INSTANCE;
+    }
+    gpioCallback->callback(gpioMapIter->first, gpio::GpioOperation::WRITE, 1,
+                           gpioCallback->callbackArgs);
+  }
+  return GPIO_TYPE_FAILURE;
+}
+
+ReturnValue_t LinuxLibgpioIF::pullLow(gpioId_t gpioId) {
+  gpioMapIter = gpioMap.find(gpioId);
+  if (gpioMapIter == gpioMap.end()) {
+    sif::warning << "LinuxLibgpioIF::driveGpio: Unknown GPIOD ID " << gpioId << std::endl;
+    return UNKNOWN_GPIO_ID;
+  }
+
+  if (gpioMapIter->second->gpioType == gpio::GpioTypes::GPIOD_REGULAR) {
+    return driveGpio(gpioId, dynamic_cast<GpiodRegular*>(gpioMapIter->second), 0);
+  } else {
+    auto gpioCallback = dynamic_cast<GpioCallback*>(gpioMapIter->second);
+    if (gpioCallback->callback == nullptr) {
+      return GPIO_INVALID_INSTANCE;
+    }
+    gpioCallback->callback(gpioMapIter->first, gpio::GpioOperation::WRITE, 0,
+                           gpioCallback->callbackArgs);
+  }
+  return GPIO_TYPE_FAILURE;
+}
+
+ReturnValue_t LinuxLibgpioIF::driveGpio(gpioId_t gpioId, GpiodRegular* regularGpio,
+                                        unsigned int logicLevel) {
+  if (regularGpio == nullptr) {
+    return GPIO_TYPE_FAILURE;
+  }
+
+  int result = gpiod_line_set_value(regularGpio->lineHandle, logicLevel);
+  if (result < 0) {
+    sif::warning << "LinuxLibgpioIF::driveGpio: Failed to pull GPIO with ID " << gpioId
+                 << " to logic level " << logicLevel << std::endl;
+    return DRIVE_GPIO_FAILURE;
+  }
+
+  return RETURN_OK;
+}
+
+ReturnValue_t LinuxLibgpioIF::readGpio(gpioId_t gpioId, int* gpioState) {
+  gpioMapIter = gpioMap.find(gpioId);
+  if (gpioMapIter == gpioMap.end()) {
+    sif::warning << "LinuxLibgpioIF::readGpio: Unknown GPIOD ID " << gpioId << std::endl;
+    return UNKNOWN_GPIO_ID;
+  }
+
+  if (gpioMapIter->second->gpioType == gpio::GpioTypes::GPIOD_REGULAR) {
+    GpiodRegular* regularGpio = dynamic_cast<GpiodRegular*>(gpioMapIter->second);
+    if (regularGpio == nullptr) {
+      return GPIO_TYPE_FAILURE;
+    }
+    *gpioState = gpiod_line_get_value(regularGpio->lineHandle);
+  } else {
+  }
+
+  return RETURN_OK;
+}
+
+ReturnValue_t LinuxLibgpioIF::checkForConflicts(GpioMap& mapToAdd) {
+  ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  for (auto& gpioConfig : mapToAdd) {
+    switch (gpioConfig.second->gpioType) {
+      case (gpio::GpioTypes::GPIOD_REGULAR): {
+        auto regularGpio = dynamic_cast<GpiodRegular*>(gpioConfig.second);
+        if (regularGpio == nullptr) {
+          return GPIO_TYPE_FAILURE;
+        }
+        /* Check for conflicts and remove duplicates if necessary */
+        result = checkForConflictsRegularGpio(gpioConfig.first, regularGpio, mapToAdd);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+          status = result;
+        }
+        break;
+      }
+      case (gpio::GpioTypes::CALLBACK): {
+        auto callbackGpio = dynamic_cast<GpioCallback*>(gpioConfig.second);
+        if (callbackGpio == nullptr) {
+          return GPIO_TYPE_FAILURE;
+        }
+        /* Check for conflicts and remove duplicates if necessary */
+        result = checkForConflictsCallbackGpio(gpioConfig.first, callbackGpio, mapToAdd);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+          status = result;
+        }
+        break;
+      }
+      default: {
+      }
+    }
+  }
+  return status;
+}
+
+ReturnValue_t LinuxLibgpioIF::checkForConflictsRegularGpio(gpioId_t gpioIdToCheck,
+                                                           GpiodRegular* gpioToCheck,
+                                                           GpioMap& mapToAdd) {
+  /* Cross check with private map */
+  gpioMapIter = gpioMap.find(gpioIdToCheck);
+  if (gpioMapIter != gpioMap.end()) {
+    if (gpioMapIter->second->gpioType != gpio::GpioTypes::GPIOD_REGULAR) {
+      sif::warning << "LinuxLibgpioIF::checkForConflicts: ID already exists for different "
+                      "GPIO type"
+                   << gpioIdToCheck << ". Removing duplicate." << std::endl;
+      mapToAdd.erase(gpioIdToCheck);
+      return HasReturnvaluesIF::RETURN_OK;
+    }
+    auto ownRegularGpio = dynamic_cast<GpiodRegular*>(gpioMapIter->second);
+    if (ownRegularGpio == nullptr) {
+      return GPIO_TYPE_FAILURE;
+    }
+
+    /* Remove element from map to add because a entry for this GPIO
+    already exists */
+    sif::warning << "LinuxLibgpioIF::checkForConflictsRegularGpio: Duplicate GPIO definition"
+                 << " detected. Duplicate will be removed from map to add." << std::endl;
+    mapToAdd.erase(gpioIdToCheck);
+  }
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LinuxLibgpioIF::checkForConflictsCallbackGpio(gpioId_t gpioIdToCheck,
+                                                            GpioCallback* callbackGpio,
+                                                            GpioMap& mapToAdd) {
+  /* Cross check with private map */
+  gpioMapIter = gpioMap.find(gpioIdToCheck);
+  if (gpioMapIter != gpioMap.end()) {
+    if (gpioMapIter->second->gpioType != gpio::GpioTypes::CALLBACK) {
+      sif::warning << "LinuxLibgpioIF::checkForConflicts: ID already exists for different "
+                      "GPIO type"
+                   << gpioIdToCheck << ". Removing duplicate." << std::endl;
+      mapToAdd.erase(gpioIdToCheck);
+      return HasReturnvaluesIF::RETURN_OK;
+    }
+
+    /* Remove element from map to add because a entry for this GPIO
+    already exists */
+    sif::warning << "LinuxLibgpioIF::checkForConflictsRegularGpio: Duplicate GPIO definition"
+                 << " detected. Duplicate will be removed from map to add." << std::endl;
+    mapToAdd.erase(gpioIdToCheck);
+  }
+  return HasReturnvaluesIF::RETURN_OK;
+}
--- a/archive/gpio/LinuxLibgpioIF.h
+++ b/archive/gpio/LinuxLibgpioIF.h
@ -0,0 +1,75 @@
+#ifndef LINUX_GPIO_LINUXLIBGPIOIF_H_
+#define LINUX_GPIO_LINUXLIBGPIOIF_H_
+
+#include <fsfw/objectmanager/SystemObject.h>
+#include <fsfwconfig/returnvalues/classIds.h>
+#include <linux/gpio/GpioIF.h>
+
+class GpioCookie;
+
+/**
+ * @brief	This class implements the GpioIF for a linux based system. The
+ * 			implementation is based on the libgpiod lib which requires linux 4.8
+ * 			or higher.
+ * @note	The Petalinux SDK from Xilinx supports libgpiod since Petalinux
+ * 			2019.1.
+ */
+class LinuxLibgpioIF : public GpioIF, public SystemObject {
+ public:
+  static const uint8_t gpioRetvalId = CLASS_ID::LINUX_LIBGPIO_IF;
+
+  static constexpr ReturnValue_t UNKNOWN_GPIO_ID =
+      HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 1);
+  static constexpr ReturnValue_t DRIVE_GPIO_FAILURE =
+      HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 2);
+  static constexpr ReturnValue_t GPIO_TYPE_FAILURE =
+      HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 3);
+  static constexpr ReturnValue_t GPIO_INVALID_INSTANCE =
+      HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 4);
+
+  LinuxLibgpioIF(object_id_t objectId);
+  virtual ~LinuxLibgpioIF();
+
+  ReturnValue_t addGpios(GpioCookie* gpioCookie) override;
+  ReturnValue_t pullHigh(gpioId_t gpioId) override;
+  ReturnValue_t pullLow(gpioId_t gpioId) override;
+  ReturnValue_t readGpio(gpioId_t gpioId, int* gpioState) override;
+
+ private:
+  /* Holds the information and configuration of all used GPIOs */
+  GpioMap gpioMap;
+  GpioMapIter gpioMapIter;
+
+  /**
+   * @brief	This functions drives line of a GPIO specified by the GPIO ID.
+   *
+   * @param gpioId	The GPIO ID of the GPIO to drive.
+   * @param logiclevel	The logic level to set. O or 1.
+   */
+  ReturnValue_t driveGpio(gpioId_t gpioId, GpiodRegularBase& regularGpio, unsigned int logiclevel);
+
+  ReturnValue_t configureRegularGpio(gpioId_t gpioId, GpiodRegularBase& regularGpio);
+
+  /**
+   * @brief	This function checks if GPIOs are already registered and whether
+   * 			there exists a conflict in the GPIO configuration. E.g. the
+   * 			direction.
+   *
+   * @param mapToAdd	The GPIOs which shall be added to the gpioMap.
+   *
+   * @return	RETURN_OK if successful, otherwise RETURN_FAILED
+   */
+  ReturnValue_t checkForConflicts(GpioMap& mapToAdd);
+
+  ReturnValue_t checkForConflictsRegularGpio(gpioId_t gpiodId, GpiodRegular* regularGpio,
+                                             GpioMap& mapToAdd);
+  ReturnValue_t checkForConflictsCallbackGpio(gpioId_t gpiodId, GpioCallback* regularGpio,
+                                              GpioMap& mapToAdd);
+
+  /**
+   * @brief   Performs the initial configuration of all GPIOs specified in the GpioMap mapToAdd.
+   */
+  ReturnValue_t configureGpios(GpioMap& mapToAdd);
+};
+
+#endif /* LINUX_GPIO_LINUXLIBGPIOIF_H_ */
--- a/archive/gpio/gpioDefinitions.h
+++ b/archive/gpio/gpioDefinitions.h
@ -0,0 +1,83 @@
+#ifndef LINUX_GPIO_GPIODEFINITIONS_H_
+#define LINUX_GPIO_GPIODEFINITIONS_H_
+
+#include <string>
+#include <unordered_map>
+
+using gpioId_t = uint16_t;
+
+namespace gpio {
+
+enum class Levels : uint8_t { LOW = 0, HIGH = 1 };
+
+enum class Direction : uint8_t { IN = 0, OUT = 1 };
+
+enum class GpioOperation { READ, WRITE };
+
+enum class GpioTypes { NONE, GPIOD_REGULAR, CALLBACK };
+
+static constexpr gpioId_t NO_GPIO = -1;
+}  // namespace gpio
+
+/**
+ * @brief   Struct containing information about the GPIO to use. This is
+ *          required by the libgpiod to access and drive a GPIO.
+ * @param chipname      String of the chipname specifying the group which contains the GPIO to
+ *                      access. E.g. gpiochip0. To detect names of GPIO groups run gpiodetect on
+ *                      the linux command line.
+ * @param lineNum       The offset of the GPIO within the GPIO group.
+ * @param consumer      Name of the consumer. Simply a description of the GPIO configuration.
+ * @param direction     Specifies whether the GPIO should be used as in- or output.
+ * @param initValue     Defines the initial state of the GPIO when configured as output.
+ *                      Only required for output GPIOs.
+ * @param lineHandle    The handle returned by gpiod_chip_get_line will be later written to this
+ *                      pointer.
+ */
+class GpioBase {
+ public:
+  GpioBase() = default;
+
+  GpioBase(gpio::GpioTypes gpioType, std::string consumer, gpio::Direction direction, int initValue)
+      : gpioType(gpioType), consumer(consumer), direction(direction), initValue(initValue) {}
+
+  virtual ~GpioBase(){};
+
+  /* Can be used to cast GpioBase to a concrete child implementation */
+  gpio::GpioTypes gpioType = gpio::GpioTypes::NONE;
+  std::string consumer;
+  gpio::Direction direction = gpio::Direction::IN;
+  int initValue = 0;
+};
+
+class GpiodRegular : public GpioBase {
+ public:
+  GpiodRegular()
+      : GpioBase(gpio::GpioTypes::GPIOD_REGULAR, std::string(), gpio::Direction::IN, 0){};
+
+  GpiodRegular(std::string chipname_, int lineNum_, std::string consumer_,
+               gpio::Direction direction_, int initValue_)
+      : GpioBase(gpio::GpioTypes::GPIOD_REGULAR, consumer_, direction_, initValue_),
+        chipname(chipname_),
+        lineNum(lineNum_) {}
+  std::string chipname;
+  int lineNum = 0;
+  struct gpiod_line* lineHandle = nullptr;
+};
+
+class GpioCallback : public GpioBase {
+ public:
+  GpioCallback(std::string consumer, gpio::Direction direction_, int initValue_,
+               void (*callback)(gpioId_t gpioId, gpio::GpioOperation gpioOp, int value, void* args),
+               void* callbackArgs)
+      : GpioBase(gpio::GpioTypes::CALLBACK, consumer, direction_, initValue_),
+        callback(callback),
+        callbackArgs(callbackArgs) {}
+
+  void (*callback)(gpioId_t gpioId, gpio::GpioOperation gpioOp, int value, void* args) = nullptr;
+  void* callbackArgs = nullptr;
+};
+
+using GpioMap = std::unordered_map<gpioId_t, GpioBase*>;
+using GpioMapIter = GpioMap::iterator;
+
+#endif /* LINUX_GPIO_GPIODEFINITIONS_H_ */
--- a/archive/tmtc/CCSDSIPCoreBridge.cpp
+++ b/archive/tmtc/CCSDSIPCoreBridge.cpp
@ -0,0 +1,128 @@
+#include <fcntl.h>
+#include <linux/obc/Ptme.h>
+#include <sys/mman.h>
+
+CCSDSIPCoreBridge::CCSDSIPCoreBridge(object_id_t objectId, object_id_t tcDestination,
+                                     object_id_t tmStoreId, object_id_t tcStoreId,
+                                     LinuxLibgpioIF* gpioComIF, std::string uioPtme,
+                                     gpioId_t papbBusyId, gpioId_t papbEmptyId)
+    : TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId),
+      gpioComIF(gpioComIF),
+      uioPtme(uioPtme),
+      papbBusyId(papbBusyId),
+      papbEmptyId(papbEmptyId) {}
+
+CCSDSIPCoreBridge::~CCSDSIPCoreBridge() {}
+
+ReturnValue_t CCSDSIPCoreBridge::initialize() {
+  ReturnValue_t result = TmTcBridge::initialize();
+
+  fd = open("/dev/uio0", O_RDWR);
+  if (fd < 1) {
+    sif::debug << "CCSDSIPCoreBridge::initialize: Invalid UIO device file" << std::endl;
+    return RETURN_FAILED;
+  }
+
+  /**
+   * Map uio device in virtual address space
+   * PROT_WRITE: Map uio device in writable only mode
+   */
+  ptmeBaseAddress =
+      static_cast<uint32_t*>(mmap(NULL, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
+
+  if (ptmeBaseAddress == MAP_FAILED) {
+    sif::error << "CCSDSIPCoreBridge::initialize: Failed to map uio address" << std::endl;
+    return RETURN_FAILED;
+  }
+
+  return result;
+}
+
+ReturnValue_t CCSDSIPCoreBridge::handleTm() {
+#if OBSW_TEST_CCSDS_PTME == 1
+  return sendTestFrame();
+#else
+  return TmTcBridge::handleTm();
+#endif
+}
+
+ReturnValue_t CCSDSIPCoreBridge::sendTm(const uint8_t* data, size_t dataLen) {
+  if (pollPapbBusySignal() == RETURN_OK) {
+    startPacketTransfer();
+  }
+
+  for (size_t idx = 0; idx < dataLen; idx++) {
+    if (pollPapbBusySignal() == RETURN_OK) {
+      *(ptmeBaseAddress + PTME_DATA_REG_OFFSET) = static_cast<uint32_t>(*(data + idx));
+    } else {
+      sif::debug << "CCSDSIPCoreBridge::sendTm: Only written " << idx - 1 << " of " << dataLen
+                 << " data" << std::endl;
+      return RETURN_FAILED;
+    }
+  }
+
+  if (pollPapbBusySignal() == RETURN_OK) {
+    endPacketTransfer();
+  }
+  return RETURN_OK;
+}
+
+void CCSDSIPCoreBridge::startPacketTransfer() { *ptmeBaseAddress = PTME_CONFIG_START; }
+
+void CCSDSIPCoreBridge::endPacketTransfer() { *ptmeBaseAddress = PTME_CONFIG_END; }
+
+ReturnValue_t CCSDSIPCoreBridge::pollPapbBusySignal() {
+  int papbBusyState = 0;
+  ReturnValue_t result = RETURN_OK;
+
+  /** Check if PAPB interface is ready to receive data */
+  result = gpioComIF->readGpio(papbBusyId, &papbBusyState);
+  if (result != RETURN_OK) {
+    sif::debug << "CCSDSIPCoreBridge::pollPapbBusySignal: Failed to read papb busy signal"
+               << std::endl;
+    return RETURN_FAILED;
+  }
+  if (!papbBusyState) {
+    sif::debug << "CCSDSIPCoreBridge::pollPapbBusySignal: PAPB busy" << std::endl;
+    return PAPB_BUSY;
+  }
+
+  return RETURN_OK;
+}
+
+void CCSDSIPCoreBridge::isPtmeBufferEmpty() {
+  ReturnValue_t result = RETURN_OK;
+  int papbEmptyState = 1;
+
+  result = gpioComIF->readGpio(papbEmptyId, &papbEmptyState);
+
+  if (result != RETURN_OK) {
+    sif::debug << "CCSDSIPCoreBridge::isPtmeBufferEmpty: Failed to read papb empty signal"
+               << std::endl;
+    return;
+  }
+
+  if (papbEmptyState == 1) {
+    sif::debug << "CCSDSIPCoreBridge::isPtmeBufferEmpty: Buffer is empty" << std::endl;
+  } else {
+    sif::debug << "CCSDSIPCoreBridge::isPtmeBufferEmpty: Buffer is not empty" << std::endl;
+  }
+  return;
+}
+
+ReturnValue_t CCSDSIPCoreBridge::sendTestFrame() {
+  /** Size of one complete transfer frame data field amounts to 1105 bytes */
+  uint8_t testPacket[1105];
+
+  /** Fill one test packet */
+  for (int idx = 0; idx < 1105; idx++) {
+    testPacket[idx] = static_cast<uint8_t>(idx & 0xFF);
+  }
+
+  ReturnValue_t result = sendTm(testPacket, 1105);
+  if (result != RETURN_OK) {
+    return result;
+  }
+
+  return RETURN_OK;
+}
--- a/archive/tmtc/CCSDSIPCoreBridge.h
+++ b/archive/tmtc/CCSDSIPCoreBridge.h
@ -0,0 +1,129 @@
+#ifndef MISSION_OBC_CCSDSIPCOREBRIDGE_H_
+#define MISSION_OBC_CCSDSIPCOREBRIDGE_H_
+
+#include <fsfw/tmtcservices/TmTcBridge.h>
+#include <fsfw_hal/common/gpio/gpioDefinitions.h>
+#include <fsfw_hal/linux/gpio/LinuxLibgpioIF.h>
+
+#include <cstring>
+
+#include "OBSWConfig.h"
+
+/**
+ * @brief   This class handles the interfacing to the telemetry (PTME) and telecommand (PDEC) IP
+ *          cores responsible for the CCSDS encoding and decoding. The IP cores are implemented
+ *          on the programmable logic and are accessible through the linux UIO driver.
+ */
+class CCSDSIPCoreBridge : public TmTcBridge {
+ public:
+  /**
+   * @brief   Constructor
+   *
+   * @param objectId
+   * @param tcDestination
+   * @param tmStoreId
+   * @param tcStoreId
+   * @param uioPtme   Name of the uio device file which provides access to the PTME IP Core.
+   * @param papbBusyId    The ID of the GPIO which is connected to the PAPBBusy_N signal of the
+   *                      PTME IP Core. A low logic level indicates the PTME is not ready to
+   *                      receive more data.
+   * @param papbEmptyId   The ID of the GPIO which is connected to the PAPBEmpty signal of the
+   *                      PTME IP Core. The signal is high when there are no packets in the
+   *                      external buffer memory (BRAM).
+   */
+  CCSDSIPCoreBridge(object_id_t objectId, object_id_t tcDestination, object_id_t tmStoreId,
+                    object_id_t tcStoreId, LinuxLibgpioIF* gpioComIF, std::string uioPtme,
+                    gpioId_t papbBusyId, gpioId_t papbEmptyId);
+  virtual ~CCSDSIPCoreBridge();
+
+  ReturnValue_t initialize() override;
+
+ protected:
+  /**
+   * Overwriting this function to provide the capability of testing the PTME IP Core
+   * implementation.
+   */
+  virtual ReturnValue_t handleTm() override;
+
+  virtual ReturnValue_t sendTm(const uint8_t* data, size_t dataLen) override;
+
+ private:
+  static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_IP_CORE_BRIDGE;
+
+  static const ReturnValue_t PAPB_BUSY = MAKE_RETURN_CODE(0xA0);
+
+  /** Size of mapped address space. 4k (minimal size of pl device) */
+  //    static const int MAP_SIZE = 0xFA0;
+  static const int MAP_SIZE = 0x1000;
+
+  /**
+   * Configuration bits:
+   * bit[1:0]: Size of data (1,2,3 or 4 bytes). 1 Byte <=> b00
+   * bit[2]: Set this bit to 1 to abort a transfered packet
+   * bit[3]: Signals to PTME the start of a new telemetry packet
+   */
+  static const uint32_t PTME_CONFIG_START = 0x8;
+
+  /**
+   * Writing this word to the ptme base address signals to the PTME that a complete tm packet has
+   * been transferred.
+   */
+  static const uint32_t PTME_CONFIG_END = 0x0;
+
+  /**
+   * Writing to this offset within the PTME memory space will insert data for encoding to the
+   * PTME IP core.
+   * The address offset is 0x400 (= 4 * 256)
+   */
+  static const int PTME_DATA_REG_OFFSET = 256;
+
+  LinuxLibgpioIF* gpioComIF = nullptr;
+
+  /** The uio device file related to the PTME IP Core */
+  std::string uioPtme;
+
+  /** Pulled to low when PTME not ready to receive data */
+  gpioId_t papbBusyId = gpio::NO_GPIO;
+
+  /** High when externally buffer memory of PTME is empty */
+  gpioId_t papbEmptyId = gpio::NO_GPIO;
+
+  /** The file descriptor of the UIO driver */
+  int fd;
+
+  uint32_t* ptmeBaseAddress = nullptr;
+
+  /**
+   * @brief   This function sends the config byte to the PTME IP Core to initiate a packet
+   *          transfer.
+   */
+  void startPacketTransfer();
+
+  /**
+   * @brief   This function sends the config byte to the PTME IP Core to signal the end of a
+   *          packet transfer.
+   */
+  void endPacketTransfer();
+
+  /**
+   * @brief   This function reads the papb busy signal indicating whether the PAPB interface is
+   *          ready to receive more data or not. PAPB is ready when PAPB_Busy_N == '1'.
+   *
+   * @return  RETURN_OK when ready to receive data else PAPB_BUSY.
+   */
+  ReturnValue_t pollPapbBusySignal();
+
+  /**
+   * @brief   This function can be used for debugging to check wheter there are packets in
+   *          the packet buffer of the PTME or not.
+   */
+  void isPtmeBufferEmpty();
+
+  /**
+   * @brief   This function sends a complete telemetry transfer frame data field (1105 bytes)
+   *          to the input of the PTME IP Core. Can be used to test the implementation.
+   */
+  ReturnValue_t sendTestFrame();
+};
+
+#endif /* MISSION_OBC_CCSDSIPCOREBRIDGE_H_ */
--- a/automation/Dockerfile
+++ b/automation/Dockerfile
@ -0,0 +1,27 @@
+FROM ubuntu:focal
+
+RUN apt-get update
+RUN apt-get --yes upgrade
+#tzdata is a dependency, won't install otherwise
+ARG DEBIAN_FRONTEND=noninteractive
+RUN apt-get --yes install cmake libgpiod-dev xz-utils nano curl git gcc g++ lcov valgrind libgps-dev python3
+
+ARG XIPHOS_SDK_NAME=sdk-xiphos-eive-v0.2.0
+# Install Xiphos ARK SDK, which also installs Q7S root filesystem, required for cross-compilation.
+RUN curl https://buggy.irs.uni-stuttgart.de/eive/tools/${XIPHOS_SDK_NAME}.tar | tar -x && \
+    cd ${XIPHOS_SDK_NAME} && \
+    ./ark-glibc-x86_64-eive-image-cortexa9hf-neon-toolchain-nodistro.0.sh -y
+
+# Cross compiler
+RUN mkdir -p /usr/tools; \
+curl https://buggy.irs.uni-stuttgart.de/eive/tools/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf.tar.gz \
+    | tar -xz -C /usr/tools
+
+RUN git clone https://github.com/catchorg/Catch2.git && \
+    cd Catch2 && \
+    git checkout v3.0.0-preview5 && \
+    cmake -Bbuild -H. -DBUILD_TESTING=OFF && \
+    cmake --build build/ --target install
+
+ENV ZYNQ_7020_SYSROOT="/opt/xiphos/sdk/ark/sysroots/cortexa9hf-neon-xiphos-linux-gnueabi"
+ENV PATH=$PATH:"/usr/tools/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin"
--- a/automation/Jenkinsfile
+++ b/automation/Jenkinsfile
@ -0,0 +1,37 @@
+pipeline {
+    environment {
+        BUILDDIR_Q7 = 'build_q7'
+        BUILDDIR_LINUX = 'build_linux'
+    }
+    agent {
+        docker {
+            image 'eive-obsw-ci:d5'
+            args '--sysctl fs.mqueue.msg_max=100'
+        }
+    }
+    stages {
+        stage('Clean') {
+            steps {
+                sh 'rm -rf $BUILDDIR_Q7'
+                sh 'rm -rf $BUILDDIR_LINUX'
+            }
+        }
+        stage('Build Q7S') {
+            steps {
+                dir(BUILDDIR_Q7) {
+                    sh 'cmake -DTGT_BSP="arm/q7s" -DCMAKE_BUILD_TYPE=Debug ..'
+                    sh 'cmake --build . -j4'
+                }
+            }
+        }
+        stage('Build Host and Tests') {
+            steps {
+                dir(BUILDDIR_LINUX) {
+                    sh 'cmake ..'
+                    sh 'cmake --build . -j4'
+                    sh './eive-unittest'
+                }
+            }
+        }
+    }
+}
--- a/bsp_egse/CMakeLists.txt
+++ b/bsp_egse/CMakeLists.txt
@ -0,0 +1,3 @@
+target_sources(${OBSW_NAME} PUBLIC InitMission.cpp main.cpp ObjectFactory.cpp)
+
+add_subdirectory(boardconfig)
--- a/bsp_egse/InitMission.cpp
+++ b/bsp_egse/InitMission.cpp
@ -0,0 +1,192 @@
+#include "InitMission.h"
+
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/objectmanager/ObjectManagerIF.h>
+#include <fsfw/returnvalues/returnvalue.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
+#include <fsfw/tasks/FixedTimeslotTaskIF.h>
+#include <fsfw/tasks/PeriodicTaskIF.h>
+#include <fsfw/tasks/TaskFactory.h>
+#include <mission/utility/InitMission.h>
+
+#include <iostream>
+
+#include "OBSWConfig.h"
+#include "ObjectFactory.h"
+#include "objects/systemObjectList.h"
+#include "pollingsequence/pollingSequenceFactory.h"
+
+ServiceInterfaceStream sif::debug("DEBUG");
+ServiceInterfaceStream sif::info("INFO");
+ServiceInterfaceStream sif::warning("WARNING");
+ServiceInterfaceStream sif::error("ERROR");
+
+ObjectManagerIF* objectManager = nullptr;
+
+void initmission::initMission() {
+  sif::info << "Make sure the systemd service ser2net on the egse has been stopped "
+            << "(alias stop-ser2net)" << std::endl;
+  sif::info << "Make sure the power lines of the star tracker have been enabled "
+            << "(alias enable-startracker)" << std::endl;
+  sif::info << "Building global objects.." << std::endl;
+  /* Instantiate global object manager and also create all objects */
+  ObjectManager::instance()->setObjectFactoryFunction(ObjectFactory::produce, nullptr);
+  sif::info << "Initializing all objects.." << std::endl;
+  ObjectManager::instance()->initialize();
+
+  /* This function creates and starts all tasks */
+  initTasks();
+}
+
+void initmission::initTasks() {
+  TaskFactory* factory = TaskFactory::instance();
+  ReturnValue_t result = returnvalue::OK;
+  if (factory == nullptr) {
+    /* Should never happen ! */
+    return;
+  }
+#if OBSW_PRINT_MISSED_DEADLINES == 1
+  void (*missedDeadlineFunc)(void) = TaskFactory::printMissedDeadline;
+#else
+  void (*missedDeadlineFunc)(void) = nullptr;
+#endif
+
+  /* TMTC Distribution */
+  PeriodicTaskIF* tmtcDistributor = factory->createPeriodicTask(
+      "DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+  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);
+  if (result != returnvalue::OK) {
+    sif::error << "Object add component failed" << std::endl;
+  }
+  result = tmtcDistributor->addComponent(objects::TM_FUNNEL);
+  if (result != returnvalue::OK) {
+    sif::error << "Object add component failed" << std::endl;
+  }
+
+  PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask(
+      "TMTC_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+  result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
+  if (result != returnvalue::OK) {
+    sif::error << "Add component TMTC Bridge failed" << std::endl;
+  }
+  PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask(
+      "TMTC_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+  result = tmtcPollingTask->addComponent(objects::TMTC_POLLING_TASK);
+  if (result != returnvalue::OK) {
+    sif::error << "Add component TMTC Polling failed" << std::endl;
+  }
+
+  /* PUS Services */
+  std::vector<PeriodicTaskIF*> pusTasks;
+  createPusTasks(*factory, missedDeadlineFunc, pusTasks);
+
+  std::vector<PeriodicTaskIF*> pstTasks;
+  FixedTimeslotTaskIF* pst = factory->createFixedTimeslotTask(
+      "STAR_TRACKER_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.5, missedDeadlineFunc);
+  result = pst::pstUart(pst);
+  if (result != returnvalue::OK) {
+    sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
+  }
+  pstTasks.push_back(pst);
+
+  PeriodicTaskIF* strHelperTask = factory->createPeriodicTask(
+      "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);
+  }
+  pstTasks.push_back(strHelperTask);
+
+  auto taskStarter = [](std::vector<PeriodicTaskIF*>& taskVector, std::string name) {
+    for (const auto& task : taskVector) {
+      if (task != nullptr) {
+        task->startTask();
+      } else {
+        sif::error << "Task in vector " << name << " is invalid!" << std::endl;
+      }
+    }
+  };
+
+  sif::info << "Starting tasks.." << std::endl;
+  tmtcDistributor->startTask();
+  tmtcBridgeTask->startTask();
+  tmtcPollingTask->startTask();
+
+  taskStarter(pstTasks, "PST Tasks");
+  taskStarter(pusTasks, "PUS Tasks");
+
+  sif::info << "Tasks started.." << std::endl;
+}
+
+void initmission::createPusTasks(TaskFactory& factory,
+                                 TaskDeadlineMissedFunction missedDeadlineFunc,
+                                 std::vector<PeriodicTaskIF*>& taskVec) {
+  ReturnValue_t result = returnvalue::OK;
+  PeriodicTaskIF* pusVerification = factory.createPeriodicTask(
+      "PUS_VERIF", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+  result = pusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
+  if (result != returnvalue::OK) {
+    sif::error << "Object add component failed" << std::endl;
+  }
+  taskVec.push_back(pusVerification);
+
+  PeriodicTaskIF* pusEvents = factory.createPeriodicTask(
+      "PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+  result = pusEvents->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
+  if (result != returnvalue::OK) {
+    initmission::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);
+  }
+  taskVec.push_back(pusEvents);
+
+  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);
+  }
+  result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT);
+  }
+  taskVec.push_back(pusHighPrio);
+
+  PeriodicTaskIF* pusMedPrio = factory.createPeriodicTask(
+      "PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
+  if (result != returnvalue::OK) {
+    initmission::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);
+  }
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("PUS20", objects::PUS_SERVICE_20_PARAMETERS);
+  }
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("PUS3", objects::PUS_SERVICE_3_HOUSEKEEPING);
+  }
+  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("PUS17", objects::PUS_SERVICE_17_TEST);
+  }
+  result = pusLowPrio->addComponent(objects::INTERNAL_ERROR_REPORTER);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("INT_ERR_RPRT", objects::INTERNAL_ERROR_REPORTER);
+  }
+  taskVec.push_back(pusLowPrio);
+}
--- a/bsp_egse/InitMission.h
+++ b/bsp_egse/InitMission.h
@ -0,0 +1,21 @@
+#ifndef BSP_LINUX_INITMISSION_H_
+#define BSP_LINUX_INITMISSION_H_
+
+#include <vector>
+
+#include "fsfw/tasks/Typedef.h"
+
+class PeriodicTaskIF;
+class TaskFactory;
+
+namespace initmission {
+void initMission();
+void initTasks();
+
+void createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
+                    std::vector<PeriodicTaskIF*>& taskVec);
+void createPusTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
+                    std::vector<PeriodicTaskIF*>& taskVec);
+};  // namespace initmission
+
+#endif /* BSP_LINUX_INITMISSION_H_ */
--- a/bsp_egse/ObjectFactory.cpp
+++ b/bsp_egse/ObjectFactory.cpp
@ -0,0 +1,48 @@
+#include "ObjectFactory.h"
+
+#include <devConf.h>
+#include <fsfw_hal/linux/serial/SerialComIF.h>
+#include <fsfw_hal/linux/serial/SerialCookie.h>
+
+#include "OBSWConfig.h"
+#include "busConf.h"
+#include "fsfw/datapoollocal/LocalDataPoolManager.h"
+#include "fsfw/tmtcpacket/pus/tm.h"
+#include "fsfw/tmtcservices/CommandingServiceBase.h"
+#include "fsfw/tmtcservices/PusServiceBase.h"
+#include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
+#include "linux/devices/startracker/StarTrackerHandler.h"
+#include "mission/core/GenericFactory.h"
+#include "mission/utility/TmFunnel.h"
+#include "objects/systemObjectList.h"
+#include "tmtc/apid.h"
+#include "tmtc/pusIds.h"
+
+void Factory::setStaticFrameworkObjectIds() {
+  PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
+  PusServiceBase::packetDestination = objects::TM_FUNNEL;
+
+  CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
+  CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
+
+  TmFunnel::downlinkDestination = objects::TMTC_BRIDGE;
+  TmFunnel::storageDestination = objects::NO_OBJECT;
+
+  VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
+  TmPacketBase::timeStamperId = objects::TIME_STAMPER;
+}
+
+void ObjectFactory::produce(void* args) {
+  Factory::setStaticFrameworkObjectIds();
+  ObjectFactory::produceGenericObjects();
+
+  UartCookie* starTrackerCookie =
+      new UartCookie(objects::STAR_TRACKER, egse::STAR_TRACKER_UART, UartModes::NON_CANONICAL,
+                     uart::STAR_TRACKER_BAUD, startracker::MAX_FRAME_SIZE * 2 + 2);
+  newSerialComIF(objects::UART_COM_IF);
+  starTrackerCookie->setNoFixedSizeReply();
+  StrHelper* strHelper = new StrHelper(objects::STR_HELPER);
+  StarTrackerHandler* starTrackerHandler = new StarTrackerHandler(
+      objects::STAR_TRACKER, objects::UART_COM_IF, starTrackerCookie, strHelper);
+  starTrackerHandler->setStartUpImmediately();
+}
--- a/bsp_egse/ObjectFactory.h
+++ b/bsp_egse/ObjectFactory.h
@ -0,0 +1,8 @@
+#ifndef BSP_LINUX_OBJECTFACTORY_H_
+#define BSP_LINUX_OBJECTFACTORY_H_
+
+namespace ObjectFactory {
+void produce(void* args);
+};  // namespace ObjectFactory
+
+#endif /* BSP_LINUX_OBJECTFACTORY_H_ */
--- a/bsp_egse/boardconfig/CMakeLists.txt
+++ b/bsp_egse/boardconfig/CMakeLists.txt
@ -0,0 +1,3 @@
+target_sources(${OBSW_NAME} PRIVATE print.c)
+
+target_include_directories(${OBSW_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
--- a/bsp_egse/boardconfig/busConf.h
+++ b/bsp_egse/boardconfig/busConf.h
@ -0,0 +1,8 @@
+#ifndef BSP_EGSE_BOARDCONFIG_BUSCONF_H_
+#define BSP_EGSE_BOARDCONFIG_BUSCONF_H_
+
+namespace egse {
+static constexpr char STAR_TRACKER_UART[] = "/dev/serial0";
+}
+
+#endif /* BSP_EGSE_BOARDCONFIG_BUSCONF_H_ */
--- a/bsp_egse/boardconfig/etl_profile.h
+++ b/bsp_egse/boardconfig/etl_profile.h
@ -0,0 +1,38 @@
+///\file
+
+/******************************************************************************
+The MIT License(MIT)
+
+Embedded Template Library.
+https://github.com/ETLCPP/etl
+https://www.etlcpp.com
+
+Copyright(c) 2019 jwellbelove
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files(the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions :
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+#ifndef __ETL_PROFILE_H__
+#define __ETL_PROFILE_H__
+
+#define ETL_CHECK_PUSH_POP
+
+#define ETL_CPP11_SUPPORTED 1
+#define ETL_NO_NULLPTR_SUPPORT 0
+
+#endif
--- a/bsp_egse/boardconfig/gcov.h
+++ b/bsp_egse/boardconfig/gcov.h
@ -0,0 +1,15 @@
+#ifndef LINUX_GCOV_H_
+#define LINUX_GCOV_H_
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+
+#ifdef GCOV
+extern "C" void __gcov_flush();
+#else
+void __gcov_flush() {
+  sif::info << "GCC GCOV: Please supply GCOV=1 in Makefile if "
+               "coverage information is desired.\n"
+            << std::flush;
+}
+#endif
+
+#endif /* LINUX_GCOV_H_ */
--- a/bsp_egse/boardconfig/print.c
+++ b/bsp_egse/boardconfig/print.c
@ -0,0 +1,10 @@
+#include <bsp_egse/boardconfig/print.h>
+#include <stdio.h>
+
+void printChar(const char* character, bool errStream) {
+  if (errStream) {
+    putc(*character, stderr);
+    return;
+  }
+  putc(*character, stdout);
+}
--- a/bsp_egse/boardconfig/print.h
+++ b/bsp_egse/boardconfig/print.h
@ -0,0 +1,8 @@
+#ifndef HOSTED_BOARDCONFIG_PRINT_H_
+#define HOSTED_BOARDCONFIG_PRINT_H_
+
+#include <stdbool.h>
+
+void printChar(const char* character, bool errStream);
+
+#endif /* HOSTED_BOARDCONFIG_PRINT_H_ */
--- a/bsp_egse/boardconfig/rpiConfig.h.in
+++ b/bsp_egse/boardconfig/rpiConfig.h.in
@ -0,0 +1,6 @@
+#ifndef BSP_RPI_BOARDCONFIG_RPI_CONFIG_H_
+#define BSP_RPI_BOARDCONFIG_RPI_CONFIG_H_
+
+#include <cstdint>
+
+#endif /* BSP_RPI_BOARDCONFIG_RPI_CONFIG_H_ */
--- a/bsp_egse/main.cpp
+++ b/bsp_egse/main.cpp
@ -0,0 +1,28 @@
+#include <iostream>
+
+#include "InitMission.h"
+#include "OBSWConfig.h"
+#include "OBSWVersion.h"
+#include "fsfw/tasks/TaskFactory.h"
+#include "fsfw/version.h"
+
+/**
+ * @brief 	    This is the main program entry point for the egse (raspberry pi 4)
+ * @return
+ */
+int main(void) {
+  std::cout << "-- EIVE OBSW --" << std::endl;
+  std::cout << "-- Compiled for EGSE from Arcsec"
+            << " --" << std::endl;
+  std::cout << "-- OBSW " << SW_NAME << " v" << SW_VERSION << "." << SW_SUBVERSION << "."
+            << SW_REVISION << ", FSFW v" << FSFW_VERSION << "." << FSFW_SUBVERSION << FSFW_REVISION
+            << "--" << std::endl;
+  std::cout << "-- " << __DATE__ << " " << __TIME__ << " --" << std::endl;
+
+  initmission::initMission();
+
+  for (;;) {
+    /* Suspend main thread by sleeping it. */
+    TaskFactory::delayTask(5000);
+  }
+}
--- a/bsp_hosted/CMakeLists.txt
+++ b/bsp_hosted/CMakeLists.txt
@ -1,10 +1,4 @@
-target_sources(${TARGET_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.cpp
+++ b/bsp_hosted/InitMission.cpp
@ -1,159 +0,0 @@
-#include "InitMission.h"
-#include "ObjectFactory.h"
-
-#include <OBSWConfig.h>
-
-#include <fsfw/objectmanager/ObjectManagerIF.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
-#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
-#include <fsfw/objectmanager/ObjectManager.h>
-#include <fsfw/tasks/FixedTimeslotTaskIF.h>
-#include <fsfw/tasks/PeriodicTaskIF.h>
-#include <fsfw/tasks/TaskFactory.h>
-
-#include <mission/utility/InitMission.h>
-
-#include <iostream>
-
-#ifdef LINUX
-ServiceInterfaceStream sif::debug("DEBUG");
-ServiceInterfaceStream sif::info("INFO");
-ServiceInterfaceStream sif::warning("WARNING");
-ServiceInterfaceStream sif::error("ERROR", false, false, true);
-#else
-ServiceInterfaceStream sif::debug("DEBUG", true);
-ServiceInterfaceStream sif::info("INFO", true);
-ServiceInterfaceStream sif::warning("WARNING", true);
-ServiceInterfaceStream sif::error("ERROR", true, false, true);
-#endif
-
-ObjectManagerIF *objectManager = nullptr;
-
-void initmission::initMission() {
-    sif::info << "Building global objects.." << std::endl;
-    /* Instantiate global object manager and also create all objects */
-    ObjectManager::instance()->setObjectFactoryFunction(ObjectFactory::produce, nullptr);
-    sif::info << "Initializing all objects.." << std::endl;
-    ObjectManager::instance()->initialize();
-
-    /* This function creates and starts all tasks */
-    initTasks();
-}
-
-void initmission::initTasks() {
-    TaskFactory* factory = TaskFactory::instance();
-    if(factory == nullptr) {
-        /* Should never happen ! */
-        return;
-    }
-#if OBSW_PRINT_MISSED_DEADLINES == 1
-    void (*missedDeadlineFunc) (void) = TaskFactory::printMissedDeadline;
-#else
-    void (*missedDeadlineFunc) (void) = nullptr;
-#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);
-    if(result != HasReturnvaluesIF::RETURN_OK){
-        sif::error << "Object add component failed" << std::endl;
-    }
-    result = tmTcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
-    if(result != HasReturnvaluesIF::RETURN_OK){
-        sif::error << "Object add component failed" << std::endl;
-    }
-    result = tmTcDistributor->addComponent(objects::TM_FUNNEL);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        sif::error << "Object add component failed" << std::endl;
-    }
-
-    /* UDP bridge */
-    PeriodicTaskIF* udpBridgeTask = factory->createPeriodicTask(
-            "UDP_UNIX_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
-    result = udpBridgeTask->addComponent(objects::UDP_BRIDGE);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        sif::error << "Add component UDP Unix Bridge failed" << std::endl;
-    }
-    PeriodicTaskIF* udpPollingTask = factory->createPeriodicTask(
-            "UDP_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
-    result = udpPollingTask->addComponent(objects::UDP_POLLING_TASK);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        sif::error << "Add component UDP Polling failed" << std::endl;
-    }
-
-    /* PUS Services */
-    PeriodicTaskIF* pusVerification = factory->createPeriodicTask(
-            "PUS_VERIF", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
-    result = pusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
-    if(result != HasReturnvaluesIF::RETURN_OK){
-        sif::error << "Object add component failed" << std::endl;
-    }
-
-    PeriodicTaskIF* pusEvents = factory->createPeriodicTask(
-            "PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
-    result = pusVerification->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
-    if(result != HasReturnvaluesIF::RETURN_OK){
-        initmission::printAddObjectError("PUS5", objects::PUS_SERVICE_5_EVENT_REPORTING);
-    }
-
-    PeriodicTaskIF* pusHighPrio = factory->createPeriodicTask(
-            "PUS_HIGH_PRIO", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
-    result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        initmission::printAddObjectError("PUS2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
-    }
-    result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        initmission::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT);
-    }
-
-    PeriodicTaskIF* pusMedPrio = factory->createPeriodicTask(
-            "PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
-    result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        initmission::printAddObjectError("PUS8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
-    }
-    result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        initmission::printAddObjectError("PUS200", objects::PUS_SERVICE_200_MODE_MGMT);
-    }
-    result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        initmission::printAddObjectError("PUS20", objects::PUS_SERVICE_20_PARAMETERS);
-    }
-
-    PeriodicTaskIF* pusLowPrio = factory->createPeriodicTask(
-            "PUS_LOW_PRIO", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.6, missedDeadlineFunc);
-    result = pusLowPrio->addComponent(objects::PUS_SERVICE_17_TEST);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        initmission::printAddObjectError("PUS17", objects::PUS_SERVICE_17_TEST);
-    }
-
-    PeriodicTaskIF* testTask = factory->createPeriodicTask(
-            "TEST_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
-#if OBSW_ADD_TEST_CODE == 1
-    result = testTask->addComponent(objects::TEST_TASK);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        initmission::printAddObjectError("TEST_TASK", objects::TEST_TASK);
-    }
-#endif /* OBSW_ADD_TEST_CODE == 1 */
-
-    sif::info << "Starting tasks.." << std::endl;
-    tmTcDistributor->startTask();
-    udpBridgeTask->startTask();
-    udpPollingTask->startTask();
-
-    pusVerification->startTask();
-    pusEvents->startTask();
-    pusHighPrio->startTask();
-    pusMedPrio->startTask();
-    pusLowPrio->startTask();
-
-#if OBSW_ADD_TEST_CODE == 1
-    testTask->startTask();
-#endif /* OBSW_ADD_TEST_CODE == 1 */
-
-    sif::info << "Tasks started.." << std::endl;
-}
--- 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();
-};
-
-#endif /* BSP_LINUX_INITMISSION_H_ */
--- a/bsp_hosted/OBSWConfig.h.in
+++ b/bsp_hosted/OBSWConfig.h.in
@ -0,0 +1,127 @@
+/**
+ * @brief   This file can be used to add preprocessor define for conditional
+ *          code inclusion exclusion or various other project constants and
+ *          properties in one place.
+ */
+#ifndef FSFWCONFIG_OBSWCONFIG_H_
+#define FSFWCONFIG_OBSWCONFIG_H_
+
+#include "commonConfig.h"
+#include "OBSWVersion.h"
+    
+/*******************************************************************/
+/** All of the following flags should be enabled for mission code  */
+/*******************************************************************/
+
+#define OBSW_ENABLE_TIMERS                          1
+#define OBSW_ADD_STAR_TRACKER                       0
+#define OBSW_ADD_PLOC_SUPERVISOR                    0
+#define OBSW_ADD_PLOC_MPSOC                         0
+#define OBSW_ADD_SUN_SENSORS                        0
+#define OBSW_ADD_MGT                                0
+#define OBSW_ADD_ACS_BOARD                          0
+#define OBSW_ADD_ACS_HANDLERS                       0
+#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
+#define OBSW_ADD_TMP_DEVICES                        0
+#define OBSW_ADD_RAD_SENSORS                        0
+#define OBSW_ADD_SYRLINKS                           0
+#define OBSW_STAR_TRACKER_GROUND_CONFIG             1
+
+// This is a really tricky switch.. It initializes the PCDU switches to their default states
+// at powerup. I think it would be better
+// to leave it off for now. It makes testing a lot more difficult and it might mess with
+// something the operators might want to do by giving the software too much intelligence
+// at the wrong place. The system component might command all the Switches accordingly anyway
+#define OBSW_INITIALIZE_SWITCHES                    0
+#define OBSW_ENABLE_PERIODIC_HK                     0
+
+/*******************************************************************/
+/** All of the following flags should be disabled for mission code */
+/*******************************************************************/
+
+// Can be used to switch device to NORMAL mode immediately
+#define OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP    1
+#define OBSW_PRINT_MISSED_DEADLINES                 1
+
+#define OBSW_SYRLINKS_SIMULATED                     1
+#define OBSW_ADD_TEST_CODE                          0
+#define OBSW_ADD_TEST_TASK                          0
+#define OBSW_ADD_TEST_PST                           0
+// If this is enabled, all other SPI code should be disabled
+#define OBSW_ADD_SPI_TEST_CODE                      0
+// If this is enabled, all other I2C code should be disabled
+#define OBSW_ADD_I2C_TEST_CODE                      0
+#define OBSW_ADD_UART_TEST_CODE                     0
+
+#define OBSW_TEST_ACS                               0
+#define OBSW_DEBUG_ACS                              0
+#define OBSW_TEST_SUS                               0
+#define OBSW_DEBUG_SUS                              0
+#define OBSW_TEST_RTD                               0
+#define OBSW_DEBUG_RTD                              0
+#define OBSW_TEST_RAD_SENSOR                        0
+#define OBSW_DEBUG_RAD_SENSOR                       0
+#define OBSW_TEST_PL_PCDU                           0
+#define OBSW_DEBUG_PL_PCDU                          0
+#define OBSW_TEST_BPX_BATT                          0
+#define OBSW_DEBUG_BPX_BATT                         0
+#define OBSW_TEST_IMTQ                              0
+#define OBSW_DEBUG_IMTQ                             0
+#define OBSW_TEST_RW                                0
+#define OBSW_DEBUG_RW                               0
+
+#define OBSW_TEST_LIBGPIOD                          0
+#define OBSW_TEST_PLOC_HANDLER                      0
+#define OBSW_TEST_CCSDS_BRIDGE                      0
+#define OBSW_TEST_CCSDS_PTME                        0
+#define OBSW_TEST_TE7020_HEATER                     0
+#define OBSW_TEST_GPIO_OPEN_BY_LABEL                0
+#define OBSW_TEST_GPIO_OPEN_BY_LINE_NAME            0
+#define OBSW_DEBUG_P60DOCK                          0
+
+#define OBSW_PRINT_CORE_HK                          0
+#define OBSW_DEBUG_PDU1                             0
+#define OBSW_DEBUG_PDU2                             0
+#define OBSW_DEBUG_GPS                              0
+#define OBSW_DEBUG_ACU                              0
+#define OBSW_DEBUG_SYRLINKS                         0
+
+#define OBSW_DEBUG_PDEC_HANDLER                     0
+#define OBSW_DEBUG_PLOC_SUPERVISOR                  0
+#define OBSW_DEBUG_PLOC_MPSOC                       0
+#define OBSW_DEBUG_STARTRACKER                      0
+#define OBSW_TCP_SERVER_WIRETAPPING                 0
+
+/*******************************************************************/
+/** 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@
+#cmakedefine LIBGPS_VERSION_MINOR @LIBGPS_VERSION_MINOR@
+
+#ifdef RASPBERRY_PI
+#include "rpiConfig.h"
+#elif defined(XIPHOS_Q7S)
+#include "q7sConfig.h"
+#endif
+
+#ifdef __cplusplus
+
+#include "objects/systemObjectList.h"
+#include "events/subsystemIdRanges.h"
+#include "returnvalues/classIds.h"
+
+#endif
+
+#endif /* FSFWCONFIG_OBSWCONFIG_H_ */
--- a/bsp_hosted/ObjectFactory.cpp
+++ b/bsp_hosted/ObjectFactory.cpp
@ -1,46 +1,115 @@
 #include "ObjectFactory.h"

-#include <OBSWConfig.h>
-#include <objects/systemObjectList.h>
-#include <tmtc/apid.h>
-#include <tmtc/pusIds.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/utility/TmFunnel.h>
+#include <mission/tmtc/TmFunnelHandler.h>
+#include <objects/systemObjectList.h>

-#include <fsfw/osal/common/UdpTcPollingTask.h>
-#include <fsfw/osal/common/UdpTmTcBridge.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_ADD_TMTC_UDP_SERVER == 1
+#include "fsfw/osal/common/UdpTcPollingTask.h"
+#include "fsfw/osal/common/UdpTmTcBridge.h"
+#endif
+#if OBSW_ADD_TMTC_TCP_SERVER == 1
+#include "fsfw/osal/common/TcpTmTcBridge.h"
+#include "fsfw/osal/common/TcpTmTcServer.h"
+#endif

 #include <fsfw/tmtcpacket/pus/tm.h>

-
 #if OBSW_ADD_TEST_CODE == 1
 #include <test/testtasks/TestTask.h>
 #endif

-void Factory::setStaticFrameworkObjectIds(){
-	PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
-	PusServiceBase::packetDestination = objects::TM_FUNNEL;
+#include <dummies/AcuDummy.h>
+#include <dummies/BpxDummy.h>
+#include <dummies/ComCookieDummy.h>
+#include <dummies/ComIFDummy.h>
+#include <dummies/CoreControllerDummy.h>
+#include <dummies/GyroAdisDummy.h>
+#include <dummies/GyroL3GD20Dummy.h>
+#include <dummies/ImtqDummy.h>
+#include <dummies/MgmLIS3MDLDummy.h>
+#include <dummies/P60DockDummy.h>
+#include <dummies/PduDummy.h>
+#include <dummies/PlPcduDummy.h>
+#include <dummies/RwDummy.h>
+#include <dummies/StarTrackerDummy.h>
+#include <dummies/SusDummy.h>
+#include <dummies/SyrlinksDummy.h>
+#include <dummies/TemperatureSensorsDummy.h>

-	CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
-	CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
+#include "dummies/helpers.h"
+#include "mission/utility/GlobalConfigHandler.h"

-	TmFunnel::downlinkDestination = objects::UDP_BRIDGE;
-	// No storage object for now.
-	TmFunnel::storageDestination = objects::NO_OBJECT;
+#ifdef PLATFORM_UNIX
+#include <fsfw_hal/linux/serial/SerialComIF.h>
+#include <fsfw_hal/linux/serial/SerialCookie.h>

-	VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
-	TmPacketBase::timeStamperId = objects::TIME_STAMPER;
+#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::PUS_TM_FUNNEL;
+
+  CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
+  CommandingServiceBase::defaultPacketDestination = objects::PUS_TM_FUNNEL;
+
+  VerificationReporter::DEFAULT_RECEIVER = objects::PUS_SERVICE_1_VERIFICATION;
 }

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

-    new UdpTmTcBridge(objects::UDP_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR);
-    new UdpTcPollingTask(objects::UDP_POLLING_TASK, objects::UDP_BRIDGE);
+  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, *dummySwitcher);
+  new ThermalController(objects::THERMAL_CONTROLLER);
+  new TestTask(objects::TEST_TASK);
 }
--- a/bsp_hosted/ObjectFactory.h
+++ b/bsp_hosted/ObjectFactory.h
@ -1,10 +1,9 @@
 #ifndef BSP_LINUX_OBJECTFACTORY_H_
 #define BSP_LINUX_OBJECTFACTORY_H_

-
 namespace ObjectFactory {
-	void setStatics();
-	void produce(void* args);
-};
+void setStatics();
+void produce(void* args);
+};  // namespace ObjectFactory

 #endif /* BSP_LINUX_OBJECTFACTORY_H_ */
--- a/bsp_hosted/boardconfig/CMakeLists.txt
+++ b/bsp_hosted/boardconfig/CMakeLists.txt
@ -1,10 +1,3 @@
-target_sources(${TARGET_NAME} PRIVATE
-	print.c
-)
-
-target_include_directories(${TARGET_NAME} PUBLIC
-	${CMAKE_CURRENT_SOURCE_DIR}
-)
-
-
+target_sources(${OBSW_NAME} PRIVATE print.c)

+target_include_directories(${OBSW_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
--- a/bsp_hosted/boardconfig/etl_profile.h
+++ b/bsp_hosted/boardconfig/etl_profile.h
@ -32,7 +32,7 @@ SOFTWARE.

 #define ETL_CHECK_PUSH_POP

-#define ETL_CPP11_SUPPORTED  1
-#define ETL_NO_NULLPTR_SUPPORT  0
+#define ETL_CPP11_SUPPORTED 1
+#define ETL_NO_NULLPTR_SUPPORT 0

 #endif
--- a/bsp_hosted/boardconfig/gcov.h
+++ b/bsp_hosted/boardconfig/gcov.h
@ -6,8 +6,9 @@
 extern "C" void __gcov_flush();
 #else
 void __gcov_flush() {
-	sif::info << "GCC GCOV: Please supply GCOV=1 in Makefile if "
-			"coverage information is desired.\n" << std::flush;
+  sif::info << "GCC GCOV: Please supply GCOV=1 in Makefile if "
+               "coverage information is desired.\n"
+            << std::flush;
 }
 #endif

--- a/bsp_hosted/boardconfig/print.c
+++ b/bsp_hosted/boardconfig/print.c
@ -3,13 +3,9 @@
 #include <stdio.h>

 void printChar(const char* character, bool errStream) {
-	if(errStream) {
-		putc(*character, stderr);
-		return;
-	}
-	putc(*character, stdout);
+  if (errStream) {
+    putc(*character, stderr);
+    return;
+  }
+  putc(*character, stdout);
 }
-
-
-
-
--- a/bsp_hosted/bsp_hosted.mk
+++ b/bsp_hosted/bsp_hosted.mk
@ -1,11 +0,0 @@
-# add main and others
-CXXSRC += $(wildcard $(CURRENTPATH)/*.cpp)
-CSRC += $(wildcard $(CURRENTPATH)/*.c)
-
-CSRC += $(wildcard $(CURRENTPATH)/boardconfig/*.c)
-
-CXXSRC += $(wildcard $(CURRENTPATH)/comIF/*.cpp)
-CSRC += $(wildcard $(CURRENTPATH)/comIF/*.c)
-
-INCLUDES += $(CURRENTPATH)/boardconfig
-INCLUDES += $(CURRENTPATH)/fsfwconfig
--- a/bsp_hosted/comIF/ArduinoComIF.cpp
+++ b/bsp_hosted/comIF/ArduinoComIF.cpp
@ -1,376 +1,349 @@
 #include "ArduinoComIF.h"
-#include "ArduinoCookie.h"

-#include <fsfw/globalfunctions/DleEncoder.h>
 #include <fsfw/globalfunctions/CRC.h>
+#include <fsfw/globalfunctions/DleEncoder.h>
 #include <fsfw/serviceinterface/ServiceInterfaceStream.h>

+#include "ArduinoCookie.h"
+
 // This only works on Linux
 #ifdef LINUX
-#include <termios.h>
 #include <fcntl.h>
+#include <termios.h>
 #include <unistd.h>
 #elif WIN32
-#include <windows.h>
 #include <strsafe.h>
+#include <windows.h>
 #endif

 #include <cstring>

-ArduinoComIF::ArduinoComIF(object_id_t setObjectId, bool promptComIF,
-        const char *serialDevice):
-		rxBuffer(MAX_PACKET_SIZE * MAX_NUMBER_OF_SPI_DEVICES*10, true),
-		SystemObject(setObjectId) {
+ArduinoComIF::ArduinoComIF(object_id_t setObjectId, bool promptComIF, const char *serialDevice)
+    : rxBuffer(MAX_PACKET_SIZE * MAX_NUMBER_OF_SPI_DEVICES * 10, true), SystemObject(setObjectId) {
 #ifdef LINUX
-	initialized = false;
-	serialPort = ::open("/dev/ttyUSB0", O_RDWR);
+  initialized = false;
+  serialPort = ::open("/dev/ttyUSB0", O_RDWR);

-	if (serialPort < 0) {
-		//configuration error
-		printf("Error %i from open: %s\n", errno, strerror(errno));
-		return;
-	}
+  if (serialPort < 0) {
+    // configuration error
+    printf("Error %i from open: %s\n", errno, strerror(errno));
+    return;
+  }

-	struct termios tty;
-	memset(&tty, 0, sizeof tty);
+  struct termios tty;
+  memset(&tty, 0, sizeof tty);

-	// Read in existing settings, and handle any error
-	if (tcgetattr(serialPort, &tty) != 0) {
-		printf("Error %i from tcgetattr: %s\n", errno, strerror(errno));
-		return;
-	}
+  // Read in existing settings, and handle any error
+  if (tcgetattr(serialPort, &tty) != 0) {
+    printf("Error %i from tcgetattr: %s\n", errno, strerror(errno));
+    return;
+  }

-	tty.c_cflag &= ~PARENB; // Clear parity bit, disabling parity
-	tty.c_cflag &= ~CSTOPB; // Clear stop field, only one stop bit used in communication
-	tty.c_cflag |= CS8; // 8 bits per byte
-	tty.c_cflag &= ~CRTSCTS; // Disable RTS/CTS hardware flow control
-	tty.c_lflag &= ~ICANON; //Disable Canonical Mode
-	tty.c_oflag &= ~OPOST; // Prevent special interpretation of output bytes (e.g. newline chars)
-	tty.c_oflag &= ~ONLCR; // Prevent conversion of newline to carriage return/line feed
-	tty.c_cc[VTIME] = 0;    // Non Blocking
-	tty.c_cc[VMIN] = 0;
+  tty.c_cflag &= ~PARENB;   // Clear parity bit, disabling parity
+  tty.c_cflag &= ~CSTOPB;   // Clear stop field, only one stop bit used in communication
+  tty.c_cflag |= CS8;       // 8 bits per byte
+  tty.c_cflag &= ~CRTSCTS;  // Disable RTS/CTS hardware flow control
+  tty.c_lflag &= ~ICANON;   // Disable Canonical Mode
+  tty.c_oflag &= ~OPOST;    // Prevent special interpretation of output bytes (e.g. newline chars)
+  tty.c_oflag &= ~ONLCR;    // Prevent conversion of newline to carriage return/line feed
+  tty.c_cc[VTIME] = 0;      // Non Blocking
+  tty.c_cc[VMIN] = 0;

-	cfsetispeed(&tty, B9600); //Baudrate
+  cfsetispeed(&tty, B9600);  // Baudrate

-	if (tcsetattr(serialPort, TCSANOW, &tty) != 0) {
-		//printf("Error %i from tcsetattr: %s\n", errno, strerror(errno));
-		return;
-	}
+  if (tcsetattr(serialPort, TCSANOW, &tty) != 0) {
+    // printf("Error %i from tcsetattr: %s\n", errno, strerror(errno));
+    return;
+  }

-	initialized = true;
+  initialized = true;
 #elif WIN32
-	DCB serialParams = { 0 };
+  DCB serialParams = {0};

-	// we need to ask the COM port from the user.
-	if(promptComIF) {
-	    sif::info << "Please enter the COM port (c to cancel): " << std::flush;
-	    std::string comPort;
-	    while(hCom == INVALID_HANDLE_VALUE) {
+  // we need to ask the COM port from the user.
+  if (promptComIF) {
+    sif::info << "Please enter the COM port (c to cancel): " << std::flush;
+    std::string comPort;
+    while (hCom == INVALID_HANDLE_VALUE) {
+      std::getline(std::cin, comPort);
+      if (comPort[0] == 'c') {
+        break;
+      }
+      const TCHAR *pcCommPort = comPort.c_str();
+      hCom = CreateFileA(pcCommPort,                    // port name
+                         GENERIC_READ | GENERIC_WRITE,  // Read/Write
+                         0,                             // No Sharing
+                         NULL,                          // No Security
+                         OPEN_EXISTING,                 // Open existing port only
+                         0,                             // Non Overlapped I/O
+                         NULL);                         // Null for Comm Devices

-	        std::getline(std::cin, comPort);
-	        if(comPort[0] == 'c') {
-	            break;
-	        }
-	        const TCHAR *pcCommPort = comPort.c_str();
-	        hCom = CreateFileA(pcCommPort,        //port name
-	                GENERIC_READ | GENERIC_WRITE, //Read/Write
-	                0,                            // No Sharing
-	                NULL,                         // No Security
-	                OPEN_EXISTING,// Open existing port only
-	                0,            // Non Overlapped I/O
-	                NULL);        // Null for Comm Devices
+      if (hCom == INVALID_HANDLE_VALUE) {
+        if (GetLastError() == 2) {
+          sif::error << "COM Port does not found!" << std::endl;
+        } else {
+          TCHAR err[128];
+          FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(),
+                        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), err, sizeof(err), NULL);
+          //  Handle the error.
+          sif::info << "CreateFileA Error code: " << GetLastError() << std::endl;
+          sif::error << err << std::flush;
+        }
+        sif::info << "Please enter a valid COM port: " << std::flush;
+      }
+    }
+  }

-	        if (hCom == INVALID_HANDLE_VALUE)
-	        {
-	            if(GetLastError() == 2) {
-	                sif::error << "COM Port does not found!" << std::endl;
-	            }
-	            else {
-	                TCHAR err[128];
-	                FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL,
-	                        GetLastError(),
-	                        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-	                        err, sizeof(err), NULL);
-	                //  Handle the error.
-	                sif::info << "CreateFileA Error code: " << GetLastError()
-	                         << std::endl;
-	                sif::error << err << std::flush;
-	            }
-	            sif::info << "Please enter a valid COM port: " << std::flush;
-	        }
-	    }
+  serialParams.DCBlength = sizeof(serialParams);
+  if (baudRate == 9600) {
+    serialParams.BaudRate = CBR_9600;
+  }
+  if (baudRate == 115200) {
+    serialParams.BaudRate = CBR_115200;
+  } else {
+    serialParams.BaudRate = baudRate;
+  }

-	}
+  serialParams.ByteSize = 8;
+  serialParams.Parity = NOPARITY;
+  serialParams.StopBits = ONESTOPBIT;
+  SetCommState(hCom, &serialParams);

-
-	serialParams.DCBlength = sizeof(serialParams);
-	if(baudRate == 9600) {
-	    serialParams.BaudRate = CBR_9600;
-	}
-	if(baudRate == 115200) {
-	    serialParams.BaudRate = CBR_115200;
-	}
-	else {
-	    serialParams.BaudRate = baudRate;
-	}
-
-	serialParams.ByteSize = 8;
-	serialParams.Parity = NOPARITY;
-	serialParams.StopBits = ONESTOPBIT;
-	SetCommState(hCom, &serialParams);
-
-	COMMTIMEOUTS timeout = { 0 };
-	// This will set the read operation to be blocking until data is received
-	// and then read continuously until there is a gap of one millisecond.
-	timeout.ReadIntervalTimeout = 1;
-	timeout.ReadTotalTimeoutConstant = 0;
-	timeout.ReadTotalTimeoutMultiplier = 0;
-	timeout.WriteTotalTimeoutConstant = 0;
-	timeout.WriteTotalTimeoutMultiplier = 0;
-	SetCommTimeouts(hCom, &timeout);
-	// Serial port should now be read for operations.
+  COMMTIMEOUTS timeout = {0};
+  // This will set the read operation to be blocking until data is received
+  // and then read continuously until there is a gap of one millisecond.
+  timeout.ReadIntervalTimeout = 1;
+  timeout.ReadTotalTimeoutConstant = 0;
+  timeout.ReadTotalTimeoutMultiplier = 0;
+  timeout.WriteTotalTimeoutConstant = 0;
+  timeout.WriteTotalTimeoutMultiplier = 0;
+  SetCommTimeouts(hCom, &timeout);
+  // Serial port should now be read for operations.
 #endif
 }

 ArduinoComIF::~ArduinoComIF() {
 #ifdef LINUX
-	::close(serialPort);
+  ::close(serialPort);
 #elif WIN32
-	CloseHandle(hCom);
+  CloseHandle(hCom);
 #endif
 }
-ReturnValue_t ArduinoComIF::initializeInterface(CookieIF * cookie) {
-    return HasReturnvaluesIF::RETURN_OK;
+ReturnValue_t ArduinoComIF::initializeInterface(CookieIF *cookie) { return returnvalue::OK; }
+
+ReturnValue_t ArduinoComIF::sendMessage(CookieIF *cookie, const uint8_t *data, size_t len) {
+  ArduinoCookie *arduinoCookie = dynamic_cast<ArduinoCookie *>(cookie);
+  if (arduinoCookie == nullptr) {
+    return INVALID_COOKIE_TYPE;
+  }
+
+  return sendMessage(arduinoCookie->command, arduinoCookie->address, data, len);
 }

-ReturnValue_t ArduinoComIF::sendMessage(CookieIF *cookie, const uint8_t *data,
-		size_t len) {
-	ArduinoCookie *arduinoCookie = dynamic_cast<ArduinoCookie*>(cookie);
-	if (arduinoCookie == nullptr) {
-		return INVALID_COOKIE_TYPE;
-	}
+ReturnValue_t ArduinoComIF::getSendSuccess(CookieIF *cookie) { return returnvalue::OK; }

-	return sendMessage(arduinoCookie->command, arduinoCookie->address, data,
-			len);
+ReturnValue_t ArduinoComIF::requestReceiveMessage(CookieIF *cookie, size_t requestLen) {
+  return returnvalue::OK;
 }

-ReturnValue_t ArduinoComIF::getSendSuccess(CookieIF *cookie) {
-	return RETURN_OK;
+ReturnValue_t ArduinoComIF::readReceivedMessage(CookieIF *cookie, uint8_t **buffer, size_t *size) {
+  handleSerialPortRx();
+
+  ArduinoCookie *arduinoCookie = dynamic_cast<ArduinoCookie *>(cookie);
+  if (arduinoCookie == nullptr) {
+    return INVALID_COOKIE_TYPE;
+  }
+
+  *buffer = arduinoCookie->replyBuffer.data();
+  *size = arduinoCookie->receivedDataLen;
+  return returnvalue::OK;
 }

-ReturnValue_t ArduinoComIF::requestReceiveMessage(CookieIF *cookie,
-        size_t requestLen) {
-	return RETURN_OK;
-}
+ReturnValue_t ArduinoComIF::sendMessage(uint8_t command, uint8_t address, const uint8_t *data,
+                                        size_t dataLen) {
+  if (dataLen > UINT16_MAX) {
+    return TOO_MUCH_DATA;
+  }

-ReturnValue_t ArduinoComIF::readReceivedMessage(CookieIF *cookie,
-		uint8_t **buffer, size_t *size) {
+  // being conservative here
+  uint8_t sendBuffer[(dataLen + 6) * 2 + 2];

-	handleSerialPortRx();
+  sendBuffer[0] = DleEncoder::STX_CHAR;

-	ArduinoCookie *arduinoCookie = dynamic_cast<ArduinoCookie*>(cookie);
-	if (arduinoCookie == nullptr) {
-		return INVALID_COOKIE_TYPE;
-	}
+  uint8_t *currentPosition = sendBuffer + 1;
+  size_t remainingLen = sizeof(sendBuffer) - 1;
+  size_t encodedLen = 0;

-	*buffer = arduinoCookie->replyBuffer.data();
-	*size = arduinoCookie->receivedDataLen;
-	return HasReturnvaluesIF::RETURN_OK;
-}
+  ReturnValue_t result =
+      DleEncoder::encode(&command, 1, currentPosition, remainingLen, &encodedLen, false);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  currentPosition += encodedLen;
+  remainingLen -= encodedLen;  // DleEncoder will never return encodedLen > remainingLen

-ReturnValue_t ArduinoComIF::sendMessage(uint8_t command,
-		uint8_t address, const uint8_t *data, size_t dataLen) {
-	if (dataLen > UINT16_MAX) {
-		return TOO_MUCH_DATA;
-	}
+  result = DleEncoder::encode(&address, 1, currentPosition, remainingLen, &encodedLen, false);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  currentPosition += encodedLen;
+  remainingLen -= encodedLen;  // DleEncoder will never return encodedLen > remainingLen

-	//being conservative here
-	uint8_t sendBuffer[(dataLen + 6) * 2 + 2];
+  uint8_t temporaryBuffer[2];

-	sendBuffer[0] = DleEncoder::STX_CHAR;
+  // note to Lukas: yes we _could_ use Serialize here, but for 16 bit it is a bit too much...
+  temporaryBuffer[0] = dataLen >> 8;  // we checked dataLen above
+  temporaryBuffer[1] = dataLen;

-	uint8_t *currentPosition = sendBuffer + 1;
-	size_t remainingLen = sizeof(sendBuffer) - 1;
-	size_t encodedLen = 0;
+  result =
+      DleEncoder::encode(temporaryBuffer, 2, currentPosition, remainingLen, &encodedLen, false);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  currentPosition += encodedLen;
+  remainingLen -= encodedLen;  // DleEncoder will never return encodedLen > remainingLen

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

-	result = DleEncoder::encode(&address, 1, currentPosition, remainingLen,
-			&encodedLen, false);
-	if (result != RETURN_OK) {
-		return result;
-	}
-	currentPosition += encodedLen;
-	remainingLen -= encodedLen; //DleEncoder will never return encodedLen > remainingLen
+  uint16_t crc = CRC::crc16ccitt(&command, 1);
+  crc = CRC::crc16ccitt(&address, 1, crc);
+  // fortunately the length is still there
+  crc = CRC::crc16ccitt(temporaryBuffer, 2, crc);
+  crc = CRC::crc16ccitt(data, dataLen, crc);

-	uint8_t temporaryBuffer[2];
+  temporaryBuffer[0] = crc >> 8;
+  temporaryBuffer[1] = crc;

-	//note to Lukas: yes we _could_ use Serialize here, but for 16 bit it is a bit too much...
-	temporaryBuffer[0] = dataLen >> 8; //we checked dataLen above
-	temporaryBuffer[1] = dataLen;
+  result =
+      DleEncoder::encode(temporaryBuffer, 2, currentPosition, remainingLen, &encodedLen, false);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  currentPosition += encodedLen;
+  remainingLen -= encodedLen;  // DleEncoder will never return encodedLen > remainingLen

-	result = DleEncoder::encode(temporaryBuffer, 2, currentPosition,
-			remainingLen, &encodedLen, false);
-	if (result != RETURN_OK) {
-		return result;
-	}
-	currentPosition += encodedLen;
-	remainingLen -= encodedLen; //DleEncoder will never return encodedLen > remainingLen
+  if (remainingLen > 0) {
+    *currentPosition = DleEncoder::ETX_CHAR;
+  }
+  remainingLen -= 1;

-	//encoding the actual data
-	result = DleEncoder::encode(data, dataLen, currentPosition, remainingLen,
-			&encodedLen, false);
-	if (result != RETURN_OK) {
-		return result;
-	}
-	currentPosition += encodedLen;
-	remainingLen -= encodedLen; //DleEncoder will never return encodedLen > remainingLen
-
-	uint16_t crc = CRC::crc16ccitt(&command, 1);
-	crc = CRC::crc16ccitt(&address, 1, crc);
-	//fortunately the length is still there
-	crc = CRC::crc16ccitt(temporaryBuffer, 2, crc);
-	crc = CRC::crc16ccitt(data, dataLen, crc);
-
-	temporaryBuffer[0] = crc >> 8;
-	temporaryBuffer[1] = crc;
-
-	result = DleEncoder::encode(temporaryBuffer, 2, currentPosition,
-			remainingLen, &encodedLen, false);
-	if (result != RETURN_OK) {
-		return result;
-	}
-	currentPosition += encodedLen;
-	remainingLen -= encodedLen; //DleEncoder will never return encodedLen > remainingLen
-
-	if (remainingLen > 0) {
-		*currentPosition = DleEncoder::ETX_CHAR;
-	}
-	remainingLen -= 1;
-
-	encodedLen = sizeof(sendBuffer) - remainingLen;
+  encodedLen = sizeof(sendBuffer) - remainingLen;

 #ifdef LINUX
-	ssize_t writtenlen = ::write(serialPort, sendBuffer, encodedLen);
-	if (writtenlen < 0) {
-		//we could try to find out what happened...
-		return RETURN_FAILED;
-	}
-	if (writtenlen != encodedLen) {
-		//the OS failed us, we do not try to block until everything is written, as
-		//we can not block the whole system here
-		return RETURN_FAILED;
-	}
-	return RETURN_OK;
+  ssize_t writtenlen = ::write(serialPort, sendBuffer, encodedLen);
+  if (writtenlen < 0) {
+    // we could try to find out what happened...
+    return returnvalue::FAILED;
+  }
+  if (writtenlen != encodedLen) {
+    // the OS failed us, we do not try to block until everything is written, as
+    // we can not block the whole system here
+    return returnvalue::FAILED;
+  }
+  return returnvalue::OK;
 #elif WIN32
-	return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 #endif
 }

 void ArduinoComIF::handleSerialPortRx() {
 #ifdef LINUX
-	uint32_t availableSpace = rxBuffer.availableWriteSpace();
+  uint32_t availableSpace = rxBuffer.availableWriteSpace();

-	uint8_t dataFromSerial[availableSpace];
+  uint8_t dataFromSerial[availableSpace];

-	ssize_t bytesRead = read(serialPort, dataFromSerial,
-			sizeof(dataFromSerial));
+  ssize_t bytesRead = read(serialPort, dataFromSerial, sizeof(dataFromSerial));

-	if (bytesRead < 0) {
-		return;
-	}
+  if (bytesRead < 0) {
+    return;
+  }

-	rxBuffer.writeData(dataFromSerial, bytesRead);
+  rxBuffer.writeData(dataFromSerial, bytesRead);

-	uint8_t dataReceivedSoFar[rxBuffer.getMaxSize()];
+  uint8_t dataReceivedSoFar[rxBuffer.getMaxSize()];

-	uint32_t dataLenReceivedSoFar = 0;
+  uint32_t dataLenReceivedSoFar = 0;

-	rxBuffer.readData(dataReceivedSoFar, sizeof(dataReceivedSoFar), true,
-			&dataLenReceivedSoFar);
+  rxBuffer.readData(dataReceivedSoFar, sizeof(dataReceivedSoFar), true, &dataLenReceivedSoFar);

-	//look for STX
-	size_t firstSTXinRawData = 0;
-	while ((firstSTXinRawData < dataLenReceivedSoFar)
-			&& (dataReceivedSoFar[firstSTXinRawData] != DleEncoder::STX_CHAR)) {
-		firstSTXinRawData++;
-	}
+  // look for STX
+  size_t firstSTXinRawData = 0;
+  while ((firstSTXinRawData < dataLenReceivedSoFar) &&
+         (dataReceivedSoFar[firstSTXinRawData] != DleEncoder::STX_CHAR)) {
+    firstSTXinRawData++;
+  }

-	if (dataReceivedSoFar[firstSTXinRawData] != DleEncoder::STX_CHAR) {
-		//there is no STX in our data, throw it away...
-		rxBuffer.deleteData(dataLenReceivedSoFar);
-		return;
-	}
+  if (dataReceivedSoFar[firstSTXinRawData] != DleEncoder::STX_CHAR) {
+    // there is no STX in our data, throw it away...
+    rxBuffer.deleteData(dataLenReceivedSoFar);
+    return;
+  }

-	uint8_t packet[MAX_PACKET_SIZE];
-	size_t packetLen = 0;
+  uint8_t packet[MAX_PACKET_SIZE];
+  size_t packetLen = 0;

-	size_t readSize = 0;
+  size_t readSize = 0;

-	ReturnValue_t result = DleEncoder::decode(
-			dataReceivedSoFar + firstSTXinRawData,
-			dataLenReceivedSoFar - firstSTXinRawData, &readSize, packet,
-			sizeof(packet), &packetLen);
+  ReturnValue_t result = DleEncoder::decode(dataReceivedSoFar + firstSTXinRawData,
+                                            dataLenReceivedSoFar - firstSTXinRawData, &readSize,
+                                            packet, sizeof(packet), &packetLen);

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

-		// after handling the packet, we can delete it from the raw stream,
-		// it has been copied to packet
-		toDelete += readSize;
-	}
+    // after handling the packet, we can delete it from the raw stream,
+    // it has been copied to packet
+    toDelete += readSize;
+  }

-	//remove Data which was processed
-	rxBuffer.deleteData(toDelete);
+  // remove Data which was processed
+  rxBuffer.deleteData(toDelete);
 #elif WIN32
 #endif
 }

-void ArduinoComIF::setBaudrate(uint32_t baudRate) {
-    this->baudRate = baudRate;
-}
+void ArduinoComIF::setBaudrate(uint32_t baudRate) { this->baudRate = baudRate; }

 void ArduinoComIF::handlePacket(uint8_t *packet, size_t packetLen) {
-	uint16_t crc = CRC::crc16ccitt(packet, packetLen);
-	if (crc != 0) {
-		//CRC error
-		return;
-	}
+  uint16_t crc = CRC::crc16ccitt(packet, packetLen);
+  if (crc != 0) {
+    // CRC error
+    return;
+  }

-	uint8_t command = packet[0];
-	uint8_t address = packet[1];
+  uint8_t command = packet[0];
+  uint8_t address = packet[1];

-	uint16_t size = (packet[2] << 8) + packet[3];
+  uint16_t size = (packet[2] << 8) + packet[3];

-	if (size != packetLen - 6) {
-		//Invalid Length
-		return;
-	}
+  if (size != packetLen - 6) {
+    // Invalid Length
+    return;
+  }

-	switch (command) {
-	case ArduinoCookie::SPI: {
-		//ArduinoCookie **itsComplicated;
-		auto findIter = spiMap.find(address);
-		if (findIter == spiMap.end()) {
-			//we do no know this address
-			return;
-		}
-		ArduinoCookie& cookie = findIter->second;
-		if (packetLen > cookie.maxReplySize + 6) {
-			packetLen = cookie.maxReplySize + 6;
-		}
-		std::memcpy(cookie.replyBuffer.data(), packet + 4, packetLen - 6);
-		cookie.receivedDataLen = packetLen - 6;
-	}
-		break;
-	default:
-		return;
-	}
+  switch (command) {
+    case ArduinoCookie::SPI: {
+      // ArduinoCookie **itsComplicated;
+      auto findIter = spiMap.find(address);
+      if (findIter == spiMap.end()) {
+        // we do no know this address
+        return;
+      }
+      ArduinoCookie &cookie = findIter->second;
+      if (packetLen > cookie.maxReplySize + 6) {
+        packetLen = cookie.maxReplySize + 6;
+      }
+      std::memcpy(cookie.replyBuffer.data(), packet + 4, packetLen - 6);
+      cookie.receivedDataLen = packetLen - 6;
+    } break;
+    default:
+      return;
+  }
 }
--- a/bsp_hosted/comIF/ArduinoComIF.h
+++ b/bsp_hosted/comIF/ArduinoComIF.h
@ -4,8 +4,8 @@
 #include <fsfw/container/FixedMap.h>
 #include <fsfw/container/SimpleRingBuffer.h>
 #include <fsfw/devicehandlers/DeviceCommunicationIF.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
 #include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw/returnvalues/returnvalue.h>

 #include <cstdint>
 #include <map>
@ -14,56 +14,53 @@
 #include <windows.h>
 #endif

-//Forward declaration, so users don't peek
+// Forward declaration, so users don't peek
 class ArduinoCookie;

-class ArduinoComIF: public SystemObject,
-		public DeviceCommunicationIF {
-public:
-	static const uint8_t MAX_NUMBER_OF_SPI_DEVICES = 8;
-	static const uint8_t MAX_PACKET_SIZE = 64;
+class ArduinoComIF : public SystemObject, public DeviceCommunicationIF {
+ public:
+  static const uint8_t MAX_NUMBER_OF_SPI_DEVICES = 8;
+  static const uint8_t MAX_PACKET_SIZE = 64;

-	static const uint8_t COMMAND_INVALID = -1;
-	static const uint8_t COMMAND_SPI = 1;
+  static const uint8_t COMMAND_INVALID = -1;
+  static const uint8_t COMMAND_SPI = 1;

-	ArduinoComIF(object_id_t setObjectId, bool promptComIF = false,
-	        const char *serialDevice = nullptr);
-	void setBaudrate(uint32_t baudRate);
+  ArduinoComIF(object_id_t setObjectId, bool promptComIF = false,
+               const char *serialDevice = nullptr);
+  void setBaudrate(uint32_t baudRate);

-	virtual ~ArduinoComIF();
+  virtual ~ArduinoComIF();

-	/** DeviceCommunicationIF overrides */
-    virtual ReturnValue_t initializeInterface(CookieIF * cookie) override;
-    virtual ReturnValue_t sendMessage(CookieIF *cookie,
-            const uint8_t * sendData, size_t sendLen) override;
-    virtual ReturnValue_t getSendSuccess(CookieIF *cookie) override;
-    virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie,
-            size_t requestLen) override;
-    virtual ReturnValue_t readReceivedMessage(CookieIF *cookie,
-            uint8_t **buffer, size_t *size) override;
+  /** DeviceCommunicationIF overrides */
+  virtual ReturnValue_t initializeInterface(CookieIF *cookie) override;
+  virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t *sendData,
+                                    size_t sendLen) override;
+  virtual ReturnValue_t getSendSuccess(CookieIF *cookie) override;
+  virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen) override;
+  virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
+                                            size_t *size) override;

-private:
+ private:
 #ifdef LINUX
 #elif WIN32
-    HANDLE hCom = INVALID_HANDLE_VALUE;
+  HANDLE hCom = INVALID_HANDLE_VALUE;
 #endif
-	// remembering if the initialization in the ctor worked
-	// if not, all calls are disabled
-	bool initialized = false;
-	int serialPort = 0;
-	// Default baud rate is 9600 for now.
-	uint32_t baudRate = 9600;
+  // remembering if the initialization in the ctor worked
+  // if not, all calls are disabled
+  bool initialized = false;
+  int serialPort = 0;
+  // Default baud rate is 9600 for now.
+  uint32_t baudRate = 9600;

-	//used to know where to put the data if a reply is received
-	std::map<uint8_t, ArduinoCookie> spiMap;
+  // used to know where to put the data if a reply is received
+  std::map<uint8_t, ArduinoCookie> spiMap;

-	SimpleRingBuffer rxBuffer;
+  SimpleRingBuffer rxBuffer;

-	ReturnValue_t sendMessage(uint8_t command, uint8_t address,
-			const uint8_t *data, size_t dataLen);
-	void handleSerialPortRx();
+  ReturnValue_t sendMessage(uint8_t command, uint8_t address, const uint8_t *data, size_t dataLen);
+  void handleSerialPortRx();

-	void handlePacket(uint8_t *packet, size_t packetLen);
+  void handlePacket(uint8_t *packet, size_t packetLen);
 };

 #endif /* MISSION_ARDUINOCOMMINTERFACE_H_ */
--- a/bsp_hosted/comIF/ArduinoCookie.cpp
+++ b/bsp_hosted/comIF/ArduinoCookie.cpp
@ -1,8 +1,8 @@
 #include <bsp_hosted/comIF/ArduinoCookie.h>

-ArduinoCookie::ArduinoCookie(Protocol_t protocol, uint8_t address,
-		const size_t maxReplySize) :
-		protocol(protocol), command(protocol), address(address),
-		maxReplySize(maxReplySize), replyBuffer(maxReplySize) {
-}
-
+ArduinoCookie::ArduinoCookie(Protocol_t protocol, uint8_t address, const size_t maxReplySize)
+    : protocol(protocol),
+      command(protocol),
+      address(address),
+      maxReplySize(maxReplySize),
+      replyBuffer(maxReplySize) {}
--- a/bsp_hosted/comIF/ArduinoCookie.h
+++ b/bsp_hosted/comIF/ArduinoCookie.h
@ -2,26 +2,21 @@
 #define MISSION_ARDUINO_ARDUINOCOOKIE_H_

 #include <fsfw/devicehandlers/CookieIF.h>
+
 #include <vector>

-class ArduinoCookie: public CookieIF {
-public:
-	enum Protocol_t: uint8_t {
-		INVALID,
-		SPI,
-		I2C
-	};
+class ArduinoCookie : public CookieIF {
+ public:
+  enum Protocol_t : uint8_t { INVALID, SPI, I2C };

-	ArduinoCookie(Protocol_t protocol, uint8_t address,
-	        const size_t maxReplySize);
-
-	Protocol_t protocol;
-	uint8_t command;
-	uint8_t address;
-	std::vector<uint8_t> replyBuffer;
-	size_t receivedDataLen = 0;
-	size_t maxReplySize;
+  ArduinoCookie(Protocol_t protocol, uint8_t address, const size_t maxReplySize);

+  Protocol_t protocol;
+  uint8_t command;
+  uint8_t address;
+  std::vector<uint8_t> replyBuffer;
+  size_t receivedDataLen = 0;
+  size_t maxReplySize;
 };

 #endif /* MISSION_ARDUINO_ARDUINOCOOKIE_H_ */
--- a/bsp_hosted/comIF/CMakeLists.txt
+++ b/bsp_hosted/comIF/CMakeLists.txt
@ -1,8 +1 @@
-target_sources(${TARGET_NAME} PUBLIC
-	ArduinoComIF.cpp
-	ArduinoCookie.cpp
-)
-
-
-
-
+target_sources(${OBSW_NAME} PUBLIC ArduinoComIF.cpp ArduinoCookie.cpp)
--- a/bsp_hosted/fsfwconfig/CMakeLists.txt
+++ b/bsp_hosted/fsfwconfig/CMakeLists.txt
@ -1,21 +1,17 @@
-target_sources(${TARGET_NAME} PRIVATE
-	ipc/MissionMessageTypes.cpp
-)
+target_sources(${OBSW_NAME} PRIVATE ipc/MissionMessageTypes.cpp)

-target_include_directories(${TARGET_NAME} PUBLIC
-	${CMAKE_CURRENT_SOURCE_DIR}
-)
+target_include_directories(${OBSW_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})

 # If a special translation file for object IDs exists, compile it.
 if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/objects/translateObjects.cpp")
-    target_sources(${TARGET_NAME} PRIVATE
-        objects/translateObjects.cpp
-    )
+  target_sources(${OBSW_NAME} PRIVATE objects/translateObjects.cpp)
+  target_sources(${UNITTEST_NAME} PRIVATE objects/translateObjects.cpp)
 endif()

 # If a special translation file for events exists, compile it.
 if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/objects/translateObjects.cpp")
-    target_sources(${TARGET_NAME} PRIVATE
-        events/translateEvents.cpp
-    )
+  target_sources(${OBSW_NAME} PRIVATE events/translateEvents.cpp)
+  target_sources(${UNITTEST_NAME} PRIVATE events/translateEvents.cpp)
 endif()
+
+add_subdirectory(pollingsequence)
--- a/bsp_hosted/fsfwconfig/FSFWConfig.h.in
+++ b/bsp_hosted/fsfwconfig/FSFWConfig.h.in
@ -7,41 +7,41 @@
 //! Used to determine whether C++ ostreams are used which can increase
 //! the binary size significantly. If this is disabled,
 //! the C stdio functions can be used alternatively
-#define FSFW_CPP_OSTREAM_ENABLED 	1
+#define FSFW_CPP_OSTREAM_ENABLED 1

 //! More FSFW related printouts depending on level. Useful for development.
-#define FSFW_VERBOSE_LEVEL			1
+#define FSFW_VERBOSE_LEVEL 1

 //! Can be used to completely disable printouts, even the C stdio ones.
 #if FSFW_CPP_OSTREAM_ENABLED == 0 && FSFW_VERBOSE_LEVEL == 0
-	#define FSFW_DISABLE_PRINTOUT 	0
+#define FSFW_DISABLE_PRINTOUT 0
 #endif

-#define FSFW_USE_PUS_C_TELEMETRY    1
+#define FSFW_USE_PUS_C_TELEMETRY 1
 #define FSFW_USE_PUS_C_TELECOMMANDS 1

 //! Can be used to disable the ANSI color sequences for C stdio.
-#define FSFW_COLORED_OUTPUT 		1
+#define FSFW_COLORED_OUTPUT 1

 //! If FSFW_OBJ_EVENT_TRANSLATION is set to one,
 //! additional output which requires the translation files translateObjects
 //! and translateEvents (and their compiled source files)
-#define FSFW_OBJ_EVENT_TRANSLATION	1
+#define FSFW_OBJ_EVENT_TRANSLATION 1

 #if FSFW_OBJ_EVENT_TRANSLATION == 1
 //! Specify whether info events are printed too.
-#define FSFW_DEBUG_INFO				1
-#include "objects/translateObjects.h"
+#define FSFW_DEBUG_INFO 1
 #include "events/translateEvents.h"
+#include "objects/translateObjects.h"
 #else
 #endif

 //! When using the newlib nano library, C99 support for stdio facilities
 //! will not be provided. This define should be set to 1 if this is the case.
-#define FSFW_NO_C99_IO 	            1
+#define FSFW_NO_C99_IO 1

 //! Specify whether a special mode store is used for Subsystem components.
-#define FSFW_USE_MODESTORE          0
+#define FSFW_USE_MODESTORE 0

 //! Defines if the real time scheduler for linux should be used.
 //! If set to 0, this will also disable priority settings for linux
@ -58,7 +58,7 @@ static constexpr uint8_t FSFW_MISSION_TIMESTAMP_SIZE = 7;
 //! Configure the allocated pool sizes for the event manager.
 static constexpr size_t FSFW_EVENTMGMR_MATCHTREE_NODES = 240;
 static constexpr size_t FSFW_EVENTMGMT_EVENTIDMATCHERS = 120;
-static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
+static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS = 120;

 //! Defines the FIFO depth of each commanding service base which
 //! also determines how many commands a CSB service can handle in one cycle
@ -70,6 +70,6 @@ static constexpr size_t FSFW_PRINT_BUFFER_SIZE = 124;

 static constexpr size_t FSFW_MAX_TM_PACKET_SIZE = 2048;

-}
+}  // namespace fsfwconfig

 #endif /* CONFIG_FSFWCONFIG_H_ */
--- a/bsp_hosted/fsfwconfig/OBSWConfig.h.in
+++ b/bsp_hosted/fsfwconfig/OBSWConfig.h.in
@ -8,11 +8,25 @@

 #include "commonConfig.h"

-#define OBSW_ADD_TEST_CODE      1
+#define OBSW_PRINT_MISSED_DEADLINES                 1
+
+#define OBSW_ADD_TEST_CODE                          1

 /* These defines should be disabled for mission code but are useful for
 debugging. */
-#define OBSW_VEBOSE_LEVEL       1
+#define OBSW_VEBOSE_LEVEL                           1
+
+#define OBSW_ADD_CCSDS_IP_CORES                     0
+// Set to 1 if all telemetry should be sent to the PTME IP Core
+#define OBSW_TM_TO_PTME                             0
+// Set to 1 if telecommands are received via the PDEC IP Core
+#define OBSW_TC_FROM_PDEC                           0
+
+#define OBSW_SYRLINKS_SIMULATED                     0
+
+#define OBSW_INITIALIZE_SWITCHES                    0
+
+#define OBSW_TCP_SERVER_WIRETAPPING                 0

 #ifdef __cplusplus

--- a/bsp_hosted/fsfwconfig/devices/gpioIds.h
+++ b/bsp_hosted/fsfwconfig/devices/gpioIds.h
@ -1,59 +0,0 @@
-#ifndef FSFWCONFIG_DEVICES_GPIOIDS_H_
-#define FSFWCONFIG_DEVICES_GPIOIDS_H_
-
-#include <linux/gpio/GpioIF.h>
-
-namespace gpioIds {
-	enum gpioId_t {
-		HEATER_0,
-		HEATER_1,
-		HEATER_2,
-		HEATER_3,
-		HEATER_4,
-		HEATER_5,
-		HEATER_6,
-		HEATER_7,
-		DEPLSA1,
-		DEPLSA2,
-
-		MGM_0_LIS3_CS,
-		MGM_1_RM3100_CS,
-		GYRO_0_ADIS_CS,
-		GYRO_1_L3G_CS,
-		GYRO_2_L3G_CS,
-		MGM_2_LIS3_CS,
-		MGM_3_RM3100_CS,
-
-		TEST_ID_0,
-		TEST_ID_1,
-
-		RTD_IC3,
-        RTD_IC4,
-        RTD_IC5,
-        RTD_IC6,
-        RTD_IC7,
-        RTD_IC8,
-        RTD_IC9,
-        RTD_IC10,
-        RTD_IC11,
-        RTD_IC12,
-        RTD_IC13,
-        RTD_IC14,
-        RTD_IC15,
-        RTD_IC16,
-        RTD_IC17,
-        RTD_IC18,
-
-        SPI_MUX_BIT_1,
-        SPI_MUX_BIT_2,
-        SPI_MUX_BIT_3,
-        SPI_MUX_BIT_4,
-        SPI_MUX_BIT_5,
-        SPI_MUX_BIT_6
-	};
-}
-
-
-
-
-#endif /* FSFWCONFIG_DEVICES_GPIOIDS_H_ */
--- a/bsp_hosted/fsfwconfig/devices/powerSwitcherList.h
+++ b/bsp_hosted/fsfwconfig/devices/powerSwitcherList.h
@ -1,58 +0,0 @@
-#ifndef FSFWCONFIG_DEVICES_POWERSWITCHERLIST_H_
-#define FSFWCONFIG_DEVICES_POWERSWITCHERLIST_H_
-
-#include <OBSWConfig.h>
-
-namespace pcduSwitches {
-	/* Switches are uint8_t datatype and go from 0 to 255 */
-	enum switcherList {
-	    Q7S,
-        PAYLOAD_PCDU_CH1,
-        RW,
-        TCS_BOARD_8V_HEATER_IN,
-        SUS_REDUNDANT,
-        DEPLOYMENT_MECHANISM,
-        PAYLOAD_PCDU_CH6,
-        ACS_BOARD_SIDE_B,
-        PAYLOAD_CAMERA,
-        TCS_BOARD_3V3,
-        SYRLINKS,
-        STAR_TRACKER,
-        MGT,
-        SUS_NOMINAL,
-        SOLAR_CELL_EXP,
-        PLOC,
-        ACS_BORAD_SIDE_A,
-        NUMBER_OF_SWITCHES
-	};
-
-	static const uint8_t ON = 1;
-	static const uint8_t OFF = 0;
-
-	/* Output states after reboot of the PDUs */
-	static const uint8_t INIT_STATE_Q7S = ON;
-	static const uint8_t INIT_STATE_PAYLOAD_PCDU_CH1 = OFF;
-	static const uint8_t INIT_STATE_RW = OFF;
-#if BOARD_TE0720 == 1
-	/* Because the TE0720 is not connected to the PCDU, this switch is always on */
-	static const uint8_t INIT_STATE_TCS_BOARD_8V_HEATER_IN = ON;
-#else
-	static const uint8_t INIT_STATE_TCS_BOARD_8V_HEATER_IN = OFF;
-#endif
-	static const uint8_t INIT_STATE_SUS_REDUNDANT = OFF;
-	static const uint8_t INIT_STATE_DEPLOYMENT_MECHANISM = OFF;
-	static const uint8_t INIT_STATE_PAYLOAD_PCDU_CH6 = OFF;
-	static const uint8_t INIT_STATE_ACS_BOARD_SIDE_B = OFF;
-	static const uint8_t INIT_STATE_PAYLOAD_CAMERA = OFF;
-	static const uint8_t INIT_STATE_TCS_BOARD_3V3 = OFF;
-	static const uint8_t INIT_STATE_SYRLINKS = OFF;
-	static const uint8_t INIT_STATE_STAR_TRACKER = OFF;
-	static const uint8_t INIT_STATE_MGT = OFF;
-	static const uint8_t INIT_STATE_SUS_NOMINAL = OFF;
-	static const uint8_t INIT_STATE_SOLAR_CELL_EXP = OFF;
-	static const uint8_t INIT_STATE_PLOC = OFF;
-	static const uint8_t INIT_STATE_ACS_BOARD_SIDE_A = OFF;
-}
-
-
-#endif /* FSFWCONFIG_DEVICES_POWERSWITCHERLIST_H_ */
--- a/bsp_hosted/fsfwconfig/events/subsystemIdRanges.h
+++ b/bsp_hosted/fsfwconfig/events/subsystemIdRanges.h
@ -1,17 +1,16 @@
 #ifndef CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_
 #define CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_

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

+#include "eive/eventSubsystemIds.h"
+
 /**
 * These IDs are part of the ID for an event thrown by a subsystem.
 * Numbers 0-80 are reserved for FSFW Subsystem IDs (framework/events/)
 */
 namespace SUBSYSTEM_ID {
-enum: uint8_t {
-	SUBSYSTEM_ID_START = COMMON_SUBSYSTEM_ID_END
-};
+enum : uint8_t { SUBSYSTEM_ID_START = COMMON_SUBSYSTEM_ID_END };
 }

 #endif /* CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_ */
--- 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,183 +83,638 @@ 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) ) {
-	case(2200):
-		return STORE_SEND_WRITE_FAILED_STRING;
-	case(2201):
-		return STORE_WRITE_FAILED_STRING;
-	case(2202):
-		return STORE_SEND_READ_FAILED_STRING;
-	case(2203):
-		return STORE_READ_FAILED_STRING;
-	case(2204):
-		return UNEXPECTED_MSG_STRING;
-	case(2205):
-		return STORING_FAILED_STRING;
-	case(2206):
-		return TM_DUMP_FAILED_STRING;
-	case(2207):
-		return STORE_INIT_FAILED_STRING;
-	case(2208):
-		return STORE_INIT_EMPTY_STRING;
-	case(2209):
-		return STORE_CONTENT_CORRUPTED_STRING;
-	case(2210):
-		return STORE_INITIALIZE_STRING;
-	case(2211):
-		return INIT_DONE_STRING;
-	case(2212):
-		return DUMP_FINISHED_STRING;
-	case(2213):
-		return DELETION_FINISHED_STRING;
-	case(2214):
-		return DELETION_FAILED_STRING;
-	case(2215):
-		return AUTO_CATALOGS_SENDING_FAILED_STRING;
-	case(2600):
-		return GET_DATA_FAILED_STRING;
-	case(2601):
-		return STORE_DATA_FAILED_STRING;
-	case(2800):
-		return DEVICE_BUILDING_COMMAND_FAILED_STRING;
-	case(2801):
-		return DEVICE_SENDING_COMMAND_FAILED_STRING;
-	case(2802):
-		return DEVICE_REQUESTING_REPLY_FAILED_STRING;
-	case(2803):
-		return DEVICE_READING_REPLY_FAILED_STRING;
-	case(2804):
-		return DEVICE_INTERPRETING_REPLY_FAILED_STRING;
-	case(2805):
-		return DEVICE_MISSED_REPLY_STRING;
-	case(2806):
-		return DEVICE_UNKNOWN_REPLY_STRING;
-	case(2807):
-		return DEVICE_UNREQUESTED_REPLY_STRING;
-	case(2808):
-		return INVALID_DEVICE_COMMAND_STRING;
-	case(2809):
-		return MONITORING_LIMIT_EXCEEDED_STRING;
-	case(2810):
-		return MONITORING_AMBIGUOUS_STRING;
-	case(4201):
-		return FUSE_CURRENT_HIGH_STRING;
-	case(4202):
-		return FUSE_WENT_OFF_STRING;
-	case(4204):
-		return POWER_ABOVE_HIGH_LIMIT_STRING;
-	case(4205):
-		return POWER_BELOW_LOW_LIMIT_STRING;
-	case(4300):
-		return SWITCH_WENT_OFF_STRING;
-	case(5000):
-		return HEATER_ON_STRING;
-	case(5001):
-		return HEATER_OFF_STRING;
-	case(5002):
-		return HEATER_TIMEOUT_STRING;
-	case(5003):
-		return HEATER_STAYED_ON_STRING;
-	case(5004):
-		return HEATER_STAYED_OFF_STRING;
-	case(5200):
-		return TEMP_SENSOR_HIGH_STRING;
-	case(5201):
-		return TEMP_SENSOR_LOW_STRING;
-	case(5202):
-		return TEMP_SENSOR_GRADIENT_STRING;
-	case(5901):
-		return COMPONENT_TEMP_LOW_STRING;
-	case(5902):
-		return COMPONENT_TEMP_HIGH_STRING;
-	case(5903):
-		return COMPONENT_TEMP_OOL_LOW_STRING;
-	case(5904):
-		return COMPONENT_TEMP_OOL_HIGH_STRING;
-	case(5905):
-		return TEMP_NOT_IN_OP_RANGE_STRING;
-	case(7101):
-		return FDIR_CHANGED_STATE_STRING;
-	case(7102):
-		return FDIR_STARTS_RECOVERY_STRING;
-	case(7103):
-		return FDIR_TURNS_OFF_DEVICE_STRING;
-	case(7201):
-		return MONITOR_CHANGED_STATE_STRING;
-	case(7202):
-		return VALUE_BELOW_LOW_LIMIT_STRING;
-	case(7203):
-		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):
-		return MODE_INFO_STRING;
-	case(7402):
-		return FALLBACK_FAILED_STRING;
-	case(7403):
-		return MODE_TRANSITION_FAILED_STRING;
-	case(7404):
-		return CANT_KEEP_MODE_STRING;
-	case(7405):
-		return OBJECT_IN_INVALID_MODE_STRING;
-	case(7406):
-		return FORCING_MODE_STRING;
-	case(7407):
-		return MODE_CMD_REJECTED_STRING;
-	case(7506):
-		return HEALTH_INFO_STRING;
-	case(7507):
-		return CHILD_CHANGED_HEALTH_STRING;
-	case(7508):
-		return CHILD_PROBLEMS_STRING;
-	case(7509):
-		return OVERWRITING_HEALTH_STRING;
-	case(7510):
-		return TRYING_RECOVERY_STRING;
-	case(7511):
-		return RECOVERY_STEP_STRING;
-	case(7512):
-		return RECOVERY_DONE_STRING;
-	case(7900):
-		return RF_AVAILABLE_STRING;
-	case(7901):
-		return RF_LOST_STRING;
-	case(7902):
-		return BIT_LOCK_STRING;
-	case(7903):
-		return BIT_LOCK_LOST_STRING;
-	case(7905):
-		return FRAME_PROCESSING_FAILED_STRING;
-	case(8900):
-		return CLOCK_SET_STRING;
-	case(8901):
-		return CLOCK_SET_FAILURE_STRING;
-	case(9700):
-		return TEST_STRING;
-	case(10600):
-		return CHANGE_OF_SETUP_PARAMETER_STRING;
-	case(11101):
-		return MEMORY_READ_RPT_CRC_FAILURE_STRING;
-	case(11102):
-		return ACK_FAILURE_STRING;
-	case(11103):
-		return EXE_FAILURE_STRING;
-	case(11104):
-		return CRC_FAILURE_EVENT_STRING;
-	default:
-		return "UNKNOWN_EVENT";
-	}
-	return 0;
+const char *translateEvents(Event event) {
+  switch ((event & 0xFFFF)) {
+    case (2200):
+      return STORE_SEND_WRITE_FAILED_STRING;
+    case (2201):
+      return STORE_WRITE_FAILED_STRING;
+    case (2202):
+      return STORE_SEND_READ_FAILED_STRING;
+    case (2203):
+      return STORE_READ_FAILED_STRING;
+    case (2204):
+      return UNEXPECTED_MSG_STRING;
+    case (2205):
+      return STORING_FAILED_STRING;
+    case (2206):
+      return TM_DUMP_FAILED_STRING;
+    case (2207):
+      return STORE_INIT_FAILED_STRING;
+    case (2208):
+      return STORE_INIT_EMPTY_STRING;
+    case (2209):
+      return STORE_CONTENT_CORRUPTED_STRING;
+    case (2210):
+      return STORE_INITIALIZE_STRING;
+    case (2211):
+      return INIT_DONE_STRING;
+    case (2212):
+      return DUMP_FINISHED_STRING;
+    case (2213):
+      return DELETION_FINISHED_STRING;
+    case (2214):
+      return DELETION_FAILED_STRING;
+    case (2215):
+      return AUTO_CATALOGS_SENDING_FAILED_STRING;
+    case (2600):
+      return GET_DATA_FAILED_STRING;
+    case (2601):
+      return STORE_DATA_FAILED_STRING;
+    case (2800):
+      return DEVICE_BUILDING_COMMAND_FAILED_STRING;
+    case (2801):
+      return DEVICE_SENDING_COMMAND_FAILED_STRING;
+    case (2802):
+      return DEVICE_REQUESTING_REPLY_FAILED_STRING;
+    case (2803):
+      return DEVICE_READING_REPLY_FAILED_STRING;
+    case (2804):
+      return DEVICE_INTERPRETING_REPLY_FAILED_STRING;
+    case (2805):
+      return DEVICE_MISSED_REPLY_STRING;
+    case (2806):
+      return DEVICE_UNKNOWN_REPLY_STRING;
+    case (2807):
+      return DEVICE_UNREQUESTED_REPLY_STRING;
+    case (2808):
+      return INVALID_DEVICE_COMMAND_STRING;
+    case (2809):
+      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):
+      return FUSE_WENT_OFF_STRING;
+    case (4204):
+      return POWER_ABOVE_HIGH_LIMIT_STRING;
+    case (4205):
+      return POWER_BELOW_LOW_LIMIT_STRING;
+    case (4300):
+      return SWITCH_WENT_OFF_STRING;
+    case (5000):
+      return HEATER_ON_STRING;
+    case (5001):
+      return HEATER_OFF_STRING;
+    case (5002):
+      return HEATER_TIMEOUT_STRING;
+    case (5003):
+      return HEATER_STAYED_ON_STRING;
+    case (5004):
+      return HEATER_STAYED_OFF_STRING;
+    case (5200):
+      return TEMP_SENSOR_HIGH_STRING;
+    case (5201):
+      return TEMP_SENSOR_LOW_STRING;
+    case (5202):
+      return TEMP_SENSOR_GRADIENT_STRING;
+    case (5901):
+      return COMPONENT_TEMP_LOW_STRING;
+    case (5902):
+      return COMPONENT_TEMP_HIGH_STRING;
+    case (5903):
+      return COMPONENT_TEMP_OOL_LOW_STRING;
+    case (5904):
+      return COMPONENT_TEMP_OOL_HIGH_STRING;
+    case (5905):
+      return TEMP_NOT_IN_OP_RANGE_STRING;
+    case (7101):
+      return FDIR_CHANGED_STATE_STRING;
+    case (7102):
+      return FDIR_STARTS_RECOVERY_STRING;
+    case (7103):
+      return FDIR_TURNS_OFF_DEVICE_STRING;
+    case (7201):
+      return MONITOR_CHANGED_STATE_STRING;
+    case (7202):
+      return VALUE_BELOW_LOW_LIMIT_STRING;
+    case (7203):
+      return VALUE_ABOVE_HIGH_LIMIT_STRING;
+    case (7204):
+      return VALUE_OUT_OF_RANGE_STRING;
+    case (7400):
+      return CHANGING_MODE_STRING;
+    case (7401):
+      return MODE_INFO_STRING;
+    case (7402):
+      return FALLBACK_FAILED_STRING;
+    case (7403):
+      return MODE_TRANSITION_FAILED_STRING;
+    case (7404):
+      return CANT_KEEP_MODE_STRING;
+    case (7405):
+      return OBJECT_IN_INVALID_MODE_STRING;
+    case (7406):
+      return FORCING_MODE_STRING;
+    case (7407):
+      return MODE_CMD_REJECTED_STRING;
+    case (7506):
+      return HEALTH_INFO_STRING;
+    case (7507):
+      return CHILD_CHANGED_HEALTH_STRING;
+    case (7508):
+      return CHILD_PROBLEMS_STRING;
+    case (7509):
+      return OVERWRITING_HEALTH_STRING;
+    case (7510):
+      return TRYING_RECOVERY_STRING;
+    case (7511):
+      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):
+      return RF_LOST_STRING;
+    case (7902):
+      return BIT_LOCK_STRING;
+    case (7903):
+      return BIT_LOCK_LOST_STRING;
+    case (7905):
+      return FRAME_PROCESSING_FAILED_STRING;
+    case (8900):
+      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 (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 (11602):
+      return ACK_FAILURE_STRING;
+    case (11603):
+      return EXE_FAILURE_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";
+  }
+  return 0;
 }
--- 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/fsfwconfig.mk
+++ b/bsp_hosted/fsfwconfig/fsfwconfig.mk
@ -1,7 +0,0 @@
-CXXSRC += $(wildcard $(CURRENTPATH)/cdatapool/*.cpp)
-CXXSRC += $(wildcard $(CURRENTPATH)/ipc/*.cpp)
-CXXSRC += $(wildcard $(CURRENTPATH)/objects/*.cpp)
-CXXSRC += $(wildcard $(CURRENTPATH)/pollingsequence/*.cpp)
-CXXSRC += $(wildcard $(CURRENTPATH)/events/*.cpp)
-
-INCLUDES += $(CURRENTPATH)
--- a/bsp_hosted/fsfwconfig/ipc/MissionMessageTypes.cpp
+++ b/bsp_hosted/fsfwconfig/ipc/MissionMessageTypes.cpp
@ -1,11 +1,10 @@
 #include "MissionMessageTypes.h"
+
 #include <fsfw/ipc/CommandMessage.h>

 void messagetypes::clearMissionMessage(CommandMessage* message) {
-	switch(message->getMessageType()) {
-	default:
-		break;
-	}
+  switch (message->getMessageType()) {
+    default:
+      break;
+  }
 }
-
-
--- a/bsp_hosted/fsfwconfig/ipc/MissionMessageTypes.h
+++ b/bsp_hosted/fsfwconfig/ipc/MissionMessageTypes.h
@ -13,10 +13,10 @@ class CommandMessage;
 */
 namespace messagetypes {
 enum MESSAGE_TYPE {
-	MISSION_MESSAGE_TYPE_START = FW_MESSAGES_COUNT,
+  MISSION_MESSAGE_TYPE_START = FW_MESSAGES_COUNT,
 };

 void clearMissionMessage(CommandMessage* message);
-}
+}  // namespace messagetypes

 #endif /* CONFIG_IPC_MISSIONMESSAGETYPES_H_ */
--- a/bsp_hosted/fsfwconfig/objects/systemObjectList.h
+++ b/bsp_hosted/fsfwconfig/objects/systemObjectList.h
@ -2,30 +2,30 @@
 #define HOSTED_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_

 #include <cstdint>
-#include <commonObjects.h>
+
+#include "eive/objects.h"

 // The objects will be instantiated in the ID order
 namespace objects {
-	enum sourceObjects: uint32_t {
+enum sourceObjects : uint32_t {

-		PUS_SERVICE_3 = 0x51000300,
-		PUS_SERVICE_5 = 0x51000400,
-		PUS_SERVICE_6 = 0x51000500,
-		PUS_SERVICE_8 = 0x51000800,
-		PUS_SERVICE_23 = 0x51002300,
-		PUS_SERVICE_201 = 0x51020100,
+  PUS_SERVICE_3 = 0x51000300,
+  PUS_SERVICE_5 = 0x51000400,
+  PUS_SERVICE_6 = 0x51000500,
+  PUS_SERVICE_8 = 0x51000800,
+  PUS_SERVICE_23 = 0x51002300,
+  PUS_SERVICE_201 = 0x51020100,

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

-		/* Test Task */
+  TEST_TASK = 0x42694269,
+  DUMMY_INTERFACE = 0xCAFECAFE,
+  DUMMY_HANDLER = 0x44000001,
+  /* 0x49 ('I') for Communication Interfaces **/
+  ARDUINO_COM_IF = 0x49000001,

-		TEST_TASK = 0x42694269,
-		DUMMY_INTERFACE = 0xCAFECAFE,
-		DUMMY_HANDLER = 0x4400AFFE,
-
-		/* 0x49 ('I') for Communication Interfaces **/
-		ARDUINO_COM_IF = 0x49000001
-	};
+  DUMMY_COM_IF = 0x49000002
+};
 }

 #endif /* BSP_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_ */
--- a/bsp_hosted/fsfwconfig/objects/translateObjects.cpp
+++ b/bsp_hosted/fsfwconfig/objects/translateObjects.cpp
@ -1,21 +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"

-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";
@ -23,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";
@ -34,76 +121,340 @@ 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 *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:
-		return ARDUINO_COM_IF_STRING;
-	case 0x51000300:
-		return PUS_SERVICE_3_STRING;
-	case 0x51000400:
-		return PUS_SERVICE_5_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:
-		return PUS_SERVICE_1_VERIFICATION_STRING;
-	case 0x53000002:
-		return PUS_SERVICE_2_DEVICE_ACCESS_STRING;
-	case 0x53000003:
-		return PUS_SERVICE_3_HOUSEKEEPING_STRING;
-	case 0x53000005:
-		return PUS_SERVICE_5_EVENT_REPORTING_STRING;
-	case 0x53000008:
-		return PUS_SERVICE_8_FUNCTION_MGMT_STRING;
-	case 0x53000009:
-		return PUS_SERVICE_9_TIME_MGMT_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 0x53010000:
-		return HEALTH_TABLE_STRING;
-	case 0x53010100:
-		return MODE_STORE_STRING;
-	case 0x53030000:
-		return EVENT_MANAGER_STRING;
-	case 0x53040000:
-		return INTERNAL_ERROR_REPORTER_STRING;
-	case 0x534f0100:
-		return TC_STORE_STRING;
-	case 0x534f0200:
-		return TM_STORE_STRING;
-	case 0x534f0300:
-		return IPC_STORE_STRING;
-	case 0x53500010:
-		return TIME_STAMPER_STRING;
-	case 0x53ffffff:
-		return FSFW_OBJECTS_END_STRING;
-	case 0xCAFECAFE:
-		return DUMMY_INTERFACE_STRING;
-	case 0xFFFFFFFF:
-		return NO_OBJECT_STRING;
-	default:
-		return "UNKNOWN_OBJECT";
-	}
-	return 0;
+const char *translateObject(object_id_t object) {
+  switch ((object & 0xFFFFFFFF)) {
+    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 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 0x53000000:
+      return FSFW_OBJECTS_START_STRING;
+    case 0x53000001:
+      return PUS_SERVICE_1_VERIFICATION_STRING;
+    case 0x53000002:
+      return PUS_SERVICE_2_DEVICE_ACCESS_STRING;
+    case 0x53000003:
+      return PUS_SERVICE_3_HOUSEKEEPING_STRING;
+    case 0x53000005:
+      return PUS_SERVICE_5_EVENT_REPORTING_STRING;
+    case 0x53000008:
+      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:
+      return MODE_STORE_STRING;
+    case 0x53030000:
+      return EVENT_MANAGER_STRING;
+    case 0x53040000:
+      return INTERNAL_ERROR_REPORTER_STRING;
+    case 0x534f0100:
+      return TC_STORE_STRING;
+    case 0x534f0200:
+      return TM_STORE_STRING;
+    case 0x534f0300:
+      return IPC_STORE_STRING;
+    case 0x53500010:
+      return TIME_STAMPER_STRING;
+    case 0x53500020:
+      return VERIFICATION_REPORTER_STRING;
+    case 0x53ffffff:
+      return FSFW_OBJECTS_END_STRING;
+    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 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:
+      return "UNKNOWN_OBJECT";
+  }
+  return 0;
 }
--- 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/CMakeLists.txt
+++ b/bsp_hosted/fsfwconfig/pollingsequence/CMakeLists.txt
@ -0,0 +1 @@
+target_sources(${OBSW_NAME} PRIVATE DummyPst.cpp)
--- a/bsp_hosted/fsfwconfig/pollingsequence/DummyPst.cpp
+++ b/bsp_hosted/fsfwconfig/pollingsequence/DummyPst.cpp
@ -0,0 +1,140 @@
+#include "DummyPst.h"
+
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+#include <fsfw/tasks/FixedTimeslotTaskIF.h>
+#include <objects/systemObjectList.h>
+
+ReturnValue_t dummy_pst::pst(FixedTimeslotTaskIF *thisSequence) {
+  uint32_t length = thisSequence->getPeriodMs();
+
+  thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::RW1, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::RW1, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::RW1, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::RW1, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::RW1, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::RW2, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::RW2, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::RW2, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::RW2, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::RW2, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::RW3, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::RW3, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::RW3, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::RW3, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::RW3, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::RW4, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::RW4, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::RW4, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::RW4, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::RW4, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::ACU_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::ACU_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::ACU_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::ACU_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::ACU_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+  if (thisSequence->checkSequence() == returnvalue::OK) {
+    return returnvalue::OK;
+  } else {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "pst::pollingSequenceInitDefault: Sequence invalid!" << std::endl;
+#endif
+    return returnvalue::FAILED;
+  }
+}
--- a/bsp_hosted/fsfwconfig/pollingsequence/DummyPst.h
+++ b/bsp_hosted/fsfwconfig/pollingsequence/DummyPst.h
@ -0,0 +1,14 @@
+#ifndef POLLINGSEQUENCEFACTORY_H_
+#define POLLINGSEQUENCEFACTORY_H_
+
+#include <fsfw/returnvalues/returnvalue.h>
+
+class FixedTimeslotTaskIF;
+
+namespace dummy_pst {
+
+ReturnValue_t pst(FixedTimeslotTaskIF *thisSequence);
+
+}
+
+#endif /* POLLINGSEQUENCEINIT_H_ */
--- a/bsp_hosted/fsfwconfig/returnvalues/classIds.h
+++ b/bsp_hosted/fsfwconfig/returnvalues/classIds.h
@ -1,9 +1,10 @@
 #ifndef CONFIG_RETURNVALUES_CLASSIDS_H_
 #define CONFIG_RETURNVALUES_CLASSIDS_H_

-#include "commonClassIds.h"
 #include <fsfw/returnvalues/FwClassIds.h>

+#include "eive/resultClassIds.h"
+
 /**
 * Source IDs starts at 73 for now
 * Framework IDs for ReturnValues run from 0 to 56
@ -11,9 +12,8 @@
 */
 namespace CLASS_ID {
 enum {
-	CLASS_ID_START = COMMON_CLASS_ID_END,
+  CLASS_ID_START = COMMON_CLASS_ID_END,
 };
 }

-
 #endif /* CONFIG_RETURNVALUES_CLASSIDS_H_ */
--- a/bsp_hosted/fsfwconfig/tmtc/apid.h
+++ b/bsp_hosted/fsfwconfig/tmtc/apid.h
@ -1,19 +0,0 @@
-#ifndef FSFWCONFIG_TMTC_APID_H_
-#define FSFWCONFIG_TMTC_APID_H_
-
-#include <stdint.h>
-
-/**
- * Application Process Definition: entity, uniquely identified by an
- * application process ID (APID), capable of generating telemetry source
- * packets and receiving telecommand packets
- *
- * SOURCE APID: 0x73 / 115 / s
- * APID is a 11 bit number
- */
-namespace apid {
-	static const uint16_t EIVE_OBSW = 0x65;
-}
-
-
-#endif /* FSFWCONFIG_TMTC_APID_H_ */
--- a/bsp_hosted/fsfwconfig/tmtc/pusIds.h
+++ b/bsp_hosted/fsfwconfig/tmtc/pusIds.h
@ -1,23 +0,0 @@
-#ifndef CONFIG_TMTC_PUSIDS_HPP_
-#define CONFIG_TMTC_PUSIDS_HPP_
-
-namespace pus {
-enum Ids{
-	PUS_SERVICE_1 = 1,
-	PUS_SERVICE_2 = 2,
-	PUS_SERVICE_3 = 3,
-	PUS_SERVICE_3_PSB = 3,
-	PUS_SERVICE_5 = 5,
-	PUS_SERVICE_6 = 6,
-	PUS_SERVICE_8 = 8,
-	PUS_SERVICE_9 = 9,
-	PUS_SERVICE_17 = 17,
-	PUS_SERVICE_19 = 19,
-	PUS_SERVICE_20 = 20,
-	PUS_SERVICE_23 = 23,
-	PUS_SERVICE_200 = 200,
-	PUS_SERVICE_201 = 201,
-};
-};
-
-#endif /* CONFIG_TMTC_PUSIDS_HPP_ */
--- a/bsp_hosted/main.cpp
+++ b/bsp_hosted/main.cpp
@ -1,9 +1,17 @@
-#include "InitMission.h"
+#include <objects/systemObjectList.h>

-#include <OBSWVersion.h>
-#include <fsfw/tasks/TaskFactory.h>
 #include <iostream>

+#include "commonConfig.h"
+#include "fsfw/FSFWVersion.h"
+#include "fsfw/controller/ControllerBase.h"
+#include "fsfw/ipc/QueueFactory.h"
+#include "fsfw/modes/HasModesIF.h"
+#include "fsfw/modes/ModeMessage.h"
+#include "fsfw/objectmanager/ObjectManager.h"
+#include "fsfw/tasks/TaskFactory.h"
+#include "scheduling.h"
+
 #ifdef WIN32
 static const char* COMPILE_PRINTOUT = "Windows";
 #elif LINUX
@ -16,20 +24,21 @@ static const char* COMPILE_PRINTOUT = "unknown OS";
 * 			Linux and Windows.
 * @return
 */
-int main(void)
-{
-    std::cout << "-- EIVE OBSW --" << std::endl;
-    std::cout << "-- Compiled for " << COMPILE_PRINTOUT <<  " --" << std::endl;
-    std::cout << "-- Software version " << SW_NAME << " v" << SW_VERSION << "."
-            << SW_SUBVERSION << "." << SW_REVISION << " -- " << std::endl;
-    std::cout << "-- " <<  __DATE__ << " " << __TIME__ << " --" << std::endl;
+int main(void) {
+  std::cout << "-- EIVE OBSW --" << std::endl;
+  std::cout << "-- Compiled for " << COMPILE_PRINTOUT << " --" << std::endl;
+  std::cout << "-- OBSW "
+            << "v" << common::OBSW_VERSION << " | FSFW v" << fsfw::FSFW_VERSION << " --"
+            << std::endl;
+  std::cout << "-- " << __DATE__ << " " << __TIME__ << " --" << std::endl;
+  std::cout << "-- "
+            << " BSP HOSTED"
+            << " --" << std::endl;

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

-	for(;;) {
-		// suspend main thread by sleeping it.
-		TaskFactory::delayTask(5000);
-	}
+  for (;;) {
+    // suspend main thread by sleeping it.
+    TaskFactory::delayTask(5000);
+  }
 }
-
-
--- a/bsp_hosted/scheduling.cpp
+++ b/bsp_hosted/scheduling.cpp
@ -0,0 +1,244 @@
+#include "linux/scheduling.h"
+
+#include <bsp_hosted/fsfwconfig/pollingsequence/DummyPst.h>
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/objectmanager/ObjectManagerIF.h>
+#include <fsfw/returnvalues/returnvalue.h>
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+#include <fsfw/tasks/FixedTimeslotTaskIF.h>
+#include <fsfw/tasks/PeriodicTaskIF.h>
+#include <fsfw/tasks/TaskFactory.h>
+#include <mission/utility/InitMission.h>
+
+#include <iostream>
+
+#include "OBSWConfig.h"
+#include "ObjectFactory.h"
+#include "scheduling.h"
+
+#ifdef LINUX
+ServiceInterfaceStream sif::debug("DEBUG");
+ServiceInterfaceStream sif::info("INFO");
+ServiceInterfaceStream sif::warning("WARNING");
+ServiceInterfaceStream sif::error("ERROR", false, false, true);
+#else
+ServiceInterfaceStream sif::debug("DEBUG", true);
+ServiceInterfaceStream sif::info("INFO", true);
+ServiceInterfaceStream sif::warning("WARNING", true);
+ServiceInterfaceStream sif::error("ERROR", true, false, true);
+#endif
+
+ObjectManagerIF* objectManager = nullptr;
+
+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);
+  sif::info << "Initializing all objects.." << std::endl;
+  ObjectManager::instance()->initialize();
+
+  /* This function creates and starts all tasks */
+  initTasks();
+}
+
+void scheduling::initTasks() {
+  TaskFactory* factory = TaskFactory::instance();
+  if (factory == nullptr) {
+    /* Should never happen ! */
+    return;
+  }
+#if OBSW_PRINT_MISSED_DEADLINES == 1
+  void (*missedDeadlineFunc)(void) = TaskFactory::printMissedDeadline;
+#else
+  void (*missedDeadlineFunc)(void) = nullptr;
+#endif
+
+  /* TMTC Distribution */
+  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);
+  if (result != returnvalue::OK) {
+    sif::error << "Object add component failed" << std::endl;
+  }
+  result = tmtcDistributor->addComponent(objects::TM_FUNNEL);
+  if (result != returnvalue::OK) {
+    sif::error << "Object add component failed" << std::endl;
+  }
+  result = tmtcDistributor->addComponent(objects::UDP_TMTC_SERVER);
+  if (result != returnvalue::OK) {
+    sif::error << "Add component UDP Unix Bridge failed" << std::endl;
+  }
+  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;
+  }
+
+  /* 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) {
+    sif::error << "Object add component failed" << std::endl;
+  }
+
+  PeriodicTaskIF* eventHandling = factory->createPeriodicTask(
+      "EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+  result = eventHandling->addComponent(objects::EVENT_MANAGER);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("EVENT_MNGR", objects::EVENT_MANAGER);
+  }
+  result = eventHandling->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
+  if (result != returnvalue::OK) {
+    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) {
+    scheduling::printAddObjectError("PUS2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
+  }
+  result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT);
+  }
+  result = pusHighPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
+  if (result != returnvalue::OK) {
+    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) {
+    scheduling::printAddObjectError("PUS8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
+  }
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("PUS200", objects::PUS_SERVICE_200_MODE_MGMT);
+  }
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
+  if (result != returnvalue::OK) {
+    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) {
+    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::CORE_CONTROLLER);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("Core controller dummy", objects::CORE_CONTROLLER);
+  }
+
+  result = thermalTask->addComponent(objects::THERMAL_CONTROLLER);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("THERMAL_CONTROLLER", objects::THERMAL_CONTROLLER);
+  }
+
+  FixedTimeslotTaskIF* pstTask = factory->createFixedTimeslotTask(
+      "DUMMY_PST", 75, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.5, missedDeadlineFunc);
+  result = dummy_pst::pst(pstTask);
+  if (result != returnvalue::OK) {
+    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) {
+    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();
+  udpPollingTask->startTask();
+  tcpPollingTask->startTask();
+
+  pusVerification->startTask();
+  eventHandling->startTask();
+  pusHighPrio->startTask();
+  pusMedPrio->startTask();
+  pusLowPrio->startTask();
+
+  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();
+#endif /* OBSW_ADD_TEST_CODE == 1 */
+
+  sif::info << "Tasks started.." << std::endl;
+}
--- 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
@ -1,8 +1,6 @@
-target_sources(${TARGET_NAME} PUBLIC
-	InitMission.cpp
-	main.cpp
-	ObjectFactory.cpp
-)
+target_sources(${OBSW_NAME} PUBLIC InitMission.cpp main.cpp gpioInit.cpp
+                                   ObjectFactory.cpp RPiSdCardManager.cpp)

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

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

 #include <iostream>

+#include "OBSWConfig.h"
+#include "ObjectFactory.h"
+#include "objects/systemObjectList.h"
+#include "pollingsequence/pollingSequenceFactory.h"
+
 ServiceInterfaceStream sif::debug("DEBUG");
 ServiceInterfaceStream sif::info("INFO");
 ServiceInterfaceStream sif::warning("WARNING");
 ServiceInterfaceStream sif::error("ERROR");

-ObjectManagerIF *objectManager = nullptr;
+ObjectManagerIF* objectManager = nullptr;

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

-    /* This function creates and starts all tasks */
-    initTasks();
+  /* This function creates and starts all tasks */
+  initTasks();
 }

 void initmission::initTasks() {
-    TaskFactory* factory = TaskFactory::instance();
-    if(factory == nullptr) {
-        /* Should never happen ! */
-        return;
-    }
+  TaskFactory* factory = TaskFactory::instance();
+  ReturnValue_t result = returnvalue::OK;
+  if (factory == nullptr) {
+    /* Should never happen ! */
+    return;
+  }
 #if OBSW_PRINT_MISSED_DEADLINES == 1
-    void (*missedDeadlineFunc) (void) = TaskFactory::printMissedDeadline;
+  void (*missedDeadlineFunc)(void) = TaskFactory::printMissedDeadline;
 #else
-    void (*missedDeadlineFunc) (void) = nullptr;
+  void (*missedDeadlineFunc)(void) = nullptr;
 #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);
-    if(result != HasReturnvaluesIF::RETURN_OK){
-        sif::error << "Object add component failed" << std::endl;
-    }
-    result = tmTcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
-    if(result != HasReturnvaluesIF::RETURN_OK){
-        sif::error << "Object add component failed" << std::endl;
-    }
-    result = tmTcDistributor->addComponent(objects::TM_FUNNEL);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        sif::error << "Object add component failed" << std::endl;
-    }
+  /* TMTC Distribution */
+  PeriodicTaskIF* tmTcDistributor = factory->createPeriodicTask(
+      "DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+  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);
+  if (result != returnvalue::OK) {
+    sif::error << "Object add component failed" << std::endl;
+  }
+  result = tmTcDistributor->addComponent(objects::TM_FUNNEL);
+  if (result != returnvalue::OK) {
+    sif::error << "Object add component failed" << std::endl;
+  }

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

-    /* PUS Services */
-    PeriodicTaskIF* pusVerification = factory->createPeriodicTask(
-            "PUS_VERIF", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
-    result = pusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
-    if(result != HasReturnvaluesIF::RETURN_OK){
-        sif::error << "Object add component failed" << std::endl;
-    }
+#if OBSW_ADD_SCEX_DEVICE == 1
+  PeriodicTaskIF* scexDevHandler;
+  PeriodicTaskIF* scexReaderTask;
+  scheduling::schedulingScex(*factory, scexDevHandler, scexReaderTask);
+#endif

-    PeriodicTaskIF* pusEvents = factory->createPeriodicTask(
-            "PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
-    result = pusVerification->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
-    if(result != HasReturnvaluesIF::RETURN_OK){
-        initmission::printAddObjectError("PUS5", objects::PUS_SERVICE_5_EVENT_REPORTING);
-    }
+  /* PUS Services */
+  std::vector<PeriodicTaskIF*> pusTasks;
+  createPusTasks(*factory, missedDeadlineFunc, pusTasks);

-    PeriodicTaskIF* pusHighPrio = factory->createPeriodicTask(
-            "PUS_HIGH_PRIO", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
-    result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        initmission::printAddObjectError("PUS2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
-    }
-    result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        initmission::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT);
-    }
-
-    PeriodicTaskIF* pusMedPrio = factory->createPeriodicTask(
-            "PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
-    result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        initmission::printAddObjectError("PUS8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
-    }
-    result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        initmission::printAddObjectError("PUS200", objects::PUS_SERVICE_200_MODE_MGMT);
-    }
-    result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        initmission::printAddObjectError("PUS20", objects::PUS_SERVICE_20_PARAMETERS);
-    }
-    result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        initmission::printAddObjectError("PUS3", objects::PUS_SERVICE_3_HOUSEKEEPING);
-    }
-
-    PeriodicTaskIF* pusLowPrio = factory->createPeriodicTask(
-            "PUS_LOW_PRIO", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.6, missedDeadlineFunc);
-    result = pusLowPrio->addComponent(objects::PUS_SERVICE_17_TEST);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        initmission::printAddObjectError("PUS17", objects::PUS_SERVICE_17_TEST);
-    }
-    result = pusLowPrio->addComponent(objects::INTERNAL_ERROR_REPORTER);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        initmission::printAddObjectError("INT_ERR_RPRT",
-                objects::INTERNAL_ERROR_REPORTER);
-    }
-
-#if OBSW_ADD_TEST_PST == 1
-    FixedTimeslotTaskIF* pstTestTask = factory->createFixedTimeslotTask("ACS_PST", 50,
-            PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 2.0, missedDeadlineFunc);
-    result = pst::pstTest(pstTestTask);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        sif::warning << "initmission::initTasks: ACS PST initialization failed!" << std::endl;
-    }
-#endif /* RPI_TEST_ACS_BOARD == 1 */
-
-    PeriodicTaskIF* testTask = factory->createPeriodicTask(
-            "TEST_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+  std::vector<PeriodicTaskIF*> pstTasks;
+  createPstTasks(*factory, missedDeadlineFunc, pstTasks);
 #if OBSW_ADD_TEST_CODE == 1
-    result = testTask->addComponent(objects::TEST_TASK);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        initmission::printAddObjectError("TEST_TASK", objects::TEST_TASK);
-    }
+  std::vector<PeriodicTaskIF*> testTasks;
+  createTestTasks(*factory, missedDeadlineFunc, pstTasks);
 #endif /* OBSW_ADD_TEST_CODE == 1 */
-#if RPI_ADD_SPI_TEST == 1
-    result = testTask->addComponent(objects::SPI_TEST);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        initmission::printAddObjectError("SPI_TEST", objects::SPI_TEST);
+
+  auto taskStarter = [](std::vector<PeriodicTaskIF*>& taskVector, std::string name) {
+    for (const auto& task : taskVector) {
+      if (task != nullptr) {
+        task->startTask();
+      } else {
+        sif::error << "Task in vector " << name << " is invalid!" << std::endl;
+      }
    }
+  };
+
+  sif::info << "Starting tasks.." << std::endl;
+  tmTcDistributor->startTask();
+  tmtcBridgeTask->startTask();
+  tmtcPollingTask->startTask();
+
+  taskStarter(pusTasks, "PUS Tasks");
+#if OBSW_ADD_TEST_CODE == 1
+  taskStarter(testTasks, "Test Tasks");
+#endif /* OBSW_ADD_TEST_CODE == 1 */
+  taskStarter(pstTasks, "PST Tasks");
+
+#if OBSW_ADD_SCEX_DEVICE == 1
+  scexDevHandler->startTask();
+  scexReaderTask->startTask();
+#endif
+#if OBSW_ADD_TEST_PST == 1
+  if (startTestPst) {
+    pstTestTask->startTask();
+  }
+#endif /* RPI_TEST_ACS_BOARD == 1 */
+  sif::info << "Tasks started.." << std::endl;
+}
+
+void initmission::createPusTasks(TaskFactory& factory,
+                                 TaskDeadlineMissedFunction missedDeadlineFunc,
+                                 std::vector<PeriodicTaskIF*>& taskVec) {
+  ReturnValue_t result = returnvalue::OK;
+  PeriodicTaskIF* pusVerification = factory.createPeriodicTask(
+      "PUS_VERIF", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+  result = pusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
+  if (result != returnvalue::OK) {
+    sif::error << "Object add component failed" << std::endl;
+  }
+  taskVec.push_back(pusVerification);
+
+  PeriodicTaskIF* pusEvents = factory.createPeriodicTask(
+      "PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+  result = pusEvents->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
+  if (result != returnvalue::OK) {
+    initmission::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);
+  }
+  taskVec.push_back(pusEvents);
+
+  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);
+  }
+  result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT);
+  }
+  taskVec.push_back(pusHighPrio);
+
+  PeriodicTaskIF* pusMedPrio = factory.createPeriodicTask(
+      "PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
+  if (result != returnvalue::OK) {
+    initmission::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);
+  }
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("PUS20", objects::PUS_SERVICE_20_PARAMETERS);
+  }
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("PUS3", objects::PUS_SERVICE_3_HOUSEKEEPING);
+  }
+  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("PUS17", objects::PUS_SERVICE_17_TEST);
+  }
+  result = pusLowPrio->addComponent(objects::INTERNAL_ERROR_REPORTER);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("INT_ERR_RPRT", objects::INTERNAL_ERROR_REPORTER);
+  }
+  taskVec.push_back(pusLowPrio);
+}
+
+void initmission::createPstTasks(TaskFactory& factory,
+                                 TaskDeadlineMissedFunction missedDeadlineFunc,
+                                 std::vector<PeriodicTaskIF*>& taskVec) {
+  ReturnValue_t result = returnvalue::OK;
+#if OBSW_ADD_SPI_TEST_CODE == 0
+  FixedTimeslotTaskIF* spiPst = factory.createFixedTimeslotTask(
+      "SPI_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 1.0, missedDeadlineFunc);
+  result = pst::pstSpi(spiPst);
+  if (result != returnvalue::OK) {
+    if (result != FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
+      sif::error << "InitMission::createPstTasks: Creating PST failed!" << std::endl;
+    }
+  } else {
+    taskVec.push_back(spiPst);
+  }
+#endif
+}
+
+void initmission::createTestTasks(TaskFactory& factory,
+                                  TaskDeadlineMissedFunction missedDeadlineFunc,
+                                  std::vector<PeriodicTaskIF*>& taskVec) {
+  ReturnValue_t result = returnvalue::OK;
+  PeriodicTaskIF* testTask = factory.createPeriodicTask(
+      "TEST_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+  result = testTask->addComponent(objects::TEST_TASK);
+  if (result != returnvalue::OK) {
+    initmission::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);
+  }
 #endif /* RPI_ADD_SPI_TEST == 1 */
 #if RPI_ADD_GPIO_TEST == 1
-    result = testTask->addComponent(objects::LIBGPIOD_TEST);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        initmission::printAddObjectError("GPIOD_TEST", objects::LIBGPIOD_TEST);
-    }
+  result = testTask->addComponent(objects::LIBGPIOD_TEST);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("GPIOD_TEST", objects::LIBGPIOD_TEST);
+  }
 #endif /* RPI_ADD_GPIO_TEST == 1 */
-#if RPI_ADD_UART_TEST == 1
-    result = testTask->addComponent(objects::UART_TEST);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        initmission::printAddObjectError("UART_TEST", objects::UART_TEST);
-    }
+#if OBSW_ADD_UART_TEST_CODE == 1
+  result = testTask->addComponent(objects::UART_TEST);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("UART_TEST", objects::UART_TEST);
+  }
+  PeriodicTaskIF* scexReaderTask = factory.createPeriodicTask(
+      "SCEX_UART_READER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+  result = scexReaderTask->addComponent(objects::SCEX_UART_READER);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("SCEX_UART_READER", objects::SCEX_UART_READER);
+  }
+  taskVec.push_back(scexReaderTask);
 #endif /* RPI_ADD_GPIO_TEST == 1 */
+  taskVec.push_back(testTask);

-    sif::info << "Starting tasks.." << std::endl;
-    tmTcDistributor->startTask();
-    udpBridgeTask->startTask();
-    udpPollingTask->startTask();
-
-    pusVerification->startTask();
-    pusEvents->startTask();
-    pusHighPrio->startTask();
-    pusMedPrio->startTask();
-    pusLowPrio->startTask();
-
-#if OBSW_ADD_TEST_CODE == 1
-    testTask->startTask();
-#endif /* OBSW_ADD_TEST_CODE == 1 */
-
+  bool startTestPst = true;
+  static_cast<void>(startTestPst);
 #if OBSW_ADD_TEST_PST == 1
-    pstTestTask->startTask();
+  FixedTimeslotTaskIF* pstTestTask = factory->createFixedTimeslotTask(
+      "TEST_PST", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 2.0, missedDeadlineFunc);
+  result = pst::pstTest(pstTestTask);
+  if (result != returnvalue::OK) {
+    sif::info << "initmission::initTasks: ACS PST empty or invalid" << std::endl;
+    startTestPst = false;
+  }
 #endif /* RPI_TEST_ACS_BOARD == 1 */
-    sif::info << "Tasks started.." << std::endl;
 }
--- a/bsp_linux_board/InitMission.h
+++ b/bsp_linux_board/InitMission.h
@ -1,9 +1,23 @@
 #ifndef BSP_LINUX_INITMISSION_H_
 #define BSP_LINUX_INITMISSION_H_

+#include <vector>
+
+#include "fsfw/tasks/definitions.h"
+
+class PeriodicTaskIF;
+class TaskFactory;
+
 namespace initmission {
 void initMission();
 void initTasks();
-};
+
+void createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
+                    std::vector<PeriodicTaskIF*>& taskVec);
+void createTestTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
+                     std::vector<PeriodicTaskIF*>& taskVec);
+void createPusTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
+                    std::vector<PeriodicTaskIF*>& taskVec);
+};  // namespace initmission

 #endif /* BSP_LINUX_INITMISSION_H_ */
--- a/bsp_linux_board/OBSWConfig.h.in
+++ b/bsp_linux_board/OBSWConfig.h.in
@ -0,0 +1,129 @@
+/**
+ * @brief   This file can be used to add preprocessor define for conditional
+ *          code inclusion exclusion or various other project constants and
+ *          properties in one place.
+ */
+#ifndef FSFWCONFIG_OBSWCONFIG_H_
+#define FSFWCONFIG_OBSWCONFIG_H_
+
+#include "commonConfig.h"
+#include "OBSWVersion.h"
+     
+/*******************************************************************/
+/** All of the following flags should be enabled for mission code  */
+/*******************************************************************/
+
+#define OBSW_ENABLE_TIMERS                          1
+#define OBSW_ADD_STAR_TRACKER                       0
+#define OBSW_ADD_PLOC_SUPERVISOR                    0
+#define OBSW_ADD_PLOC_MPSOC                         0
+#define OBSW_ADD_SUN_SENSORS                        0
+#define OBSW_ADD_MGT                                0
+#define OBSW_ADD_ACS_BOARD                          0
+#define OBSW_ADD_ACS_HANDLERS                       0
+#define OBSW_ADD_GPS_0                              0
+#define OBSW_ADD_GPS_1                              0
+#define OBSW_ADD_RW                                 0
+#define OBSW_ADD_BPX_BATTERY_HANDLER                0
+#define OBSW_ADD_RTD_DEVICES                        0
+#define OBSW_ADD_PL_PCDU                            0
+#define OBSW_ADD_TMP_DEVICES                        0
+#define OBSW_ADD_SCEX_DEVICE                        1
+#define OBSW_ADD_RAD_SENSORS                        0
+#define OBSW_ADD_SYRLINKS                           0
+#define OBSW_STAR_TRACKER_GROUND_CONFIG             1
+
+// This is a really tricky switch.. It initializes the PCDU switches to their default states
+// at powerup. I think it would be better
+// to leave it off for now. It makes testing a lot more difficult and it might mess with
+// something the operators might want to do by giving the software too much intelligence
+// at the wrong place. The system component might command all the Switches accordingly anyway
+#define OBSW_INITIALIZE_SWITCHES                    0
+#define OBSW_ENABLE_PERIODIC_HK                     0
+
+/*******************************************************************/
+/** All of the following flags should be disabled for mission code */
+/*******************************************************************/
+
+// Can be used to switch device to NORMAL mode immediately
+#define OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP    1
+#define OBSW_PRINT_MISSED_DEADLINES                 1
+
+#define OBSW_SYRLINKS_SIMULATED                     1
+#define OBSW_ADD_TEST_CODE                          0
+#define OBSW_ADD_TEST_TASK                          0
+#define OBSW_ADD_TEST_PST                           0
+// If this is enabled, all other SPI code should be disabled
+#define OBSW_ADD_SPI_TEST_CODE                      0
+// If this is enabled, all other I2C code should be disabled
+#define OBSW_ADD_I2C_TEST_CODE                      0
+#define OBSW_ADD_UART_TEST_CODE                     0
+
+#define OBSW_TEST_ACS                               0
+#define OBSW_DEBUG_ACS                              0
+#define OBSW_TEST_SUS                               0
+#define OBSW_DEBUG_SUS                              0
+#define OBSW_TEST_RTD                               0
+#define OBSW_DEBUG_RTD                              0
+#define OBSW_TEST_RAD_SENSOR                        0
+#define OBSW_DEBUG_RAD_SENSOR                       0
+#define OBSW_TEST_PL_PCDU                           0
+#define OBSW_DEBUG_PL_PCDU                          0
+#define OBSW_TEST_BPX_BATT                          0
+#define OBSW_DEBUG_BPX_BATT                         0
+#define OBSW_TEST_IMTQ                              0
+#define OBSW_DEBUG_IMTQ                             0
+#define OBSW_TEST_RW                                0
+#define OBSW_DEBUG_RW                               0
+
+#define OBSW_TEST_LIBGPIOD                          0
+#define OBSW_TEST_PLOC_HANDLER                      0
+#define OBSW_TEST_CCSDS_BRIDGE                      0
+#define OBSW_TEST_CCSDS_PTME                        0
+#define OBSW_TEST_TE7020_HEATER                     0
+#define OBSW_TEST_GPIO_OPEN_BY_LABEL                0
+#define OBSW_TEST_GPIO_OPEN_BY_LINE_NAME            0
+#define OBSW_DEBUG_P60DOCK                          0
+
+#define OBSW_PRINT_CORE_HK                          0
+#define OBSW_DEBUG_PDU1                             0
+#define OBSW_DEBUG_PDU2                             0
+#define OBSW_DEBUG_GPS                              0
+#define OBSW_DEBUG_ACU                              0
+#define OBSW_DEBUG_SYRLINKS                         0
+
+#define OBSW_DEBUG_PDEC_HANDLER                     0
+#define OBSW_DEBUG_PLOC_SUPERVISOR                  0
+#define OBSW_DEBUG_PLOC_MPSOC                       0
+#define OBSW_DEBUG_STARTRACKER                      0
+#define OBSW_TCP_SERVER_WIRETAPPING                 0
+
+/*******************************************************************/
+/** CMake Defines                                                  */
+/*******************************************************************/
+#cmakedefine EIVE_BUILD_GPSD_GPS_HANDLER
+
+#define OBSW_ADD_CCSDS_IP_CORES                     0
+// Set to 1 if all telemetry should be sent to the PTME IP Core
+#define OBSW_TM_TO_PTME                             0
+// Set to 1 if telecommands are received via the PDEC IP Core
+#define OBSW_TC_FROM_PDEC                           0
+
+#cmakedefine LIBGPS_VERSION_MAJOR @LIBGPS_VERSION_MAJOR@
+#cmakedefine LIBGPS_VERSION_MINOR @LIBGPS_VERSION_MINOR@
+
+#ifdef RASPBERRY_PI
+#include "rpiConfig.h"
+#elif defined(XIPHOS_Q7S)
+#include "q7sConfig.h"
+#endif
+
+#ifdef __cplusplus
+
+#include "objects/systemObjectList.h"
+#include "events/subsystemIdRanges.h"
+#include "returnvalues/classIds.h"
+
+#endif
+
+#endif /* FSFWCONFIG_OBSWCONFIG_H_ */
--- a/bsp_linux_board/ObjectFactory.cpp
+++ b/bsp_linux_board/ObjectFactory.cpp
@ -1,165 +1,248 @@
-#include <fsfw/hal/linux/uart/UartComIF.h>
-#include <fsfw/hal/linux/uart/UartCookie.h>
-#include <mission/devices/GPSHyperionHandler.h>
 #include "ObjectFactory.h"

-#include "objects/systemObjectList.h"
+#include <bsp_linux_board/RPiSdCardManager.h>
+#include <linux/devices/ScexUartReader.h>
+
+#include "OBSWConfig.h"
+#include "devConf.h"
 #include "devices/addresses.h"
 #include "devices/gpioIds.h"
-#include "OBSWConfig.h"
-#include "tmtc/apid.h"
-#include "tmtc/pusIds.h"
-#include "spiConf.h"
-
+#include "fsfw/datapoollocal/LocalDataPoolManager.h"
+#include "fsfw/power/DummyPowerSwitcher.h"
+#include "fsfw/tasks/TaskFactory.h"
+#include "fsfw/tmtcpacket/pus/tm.h"
+#include "fsfw/tmtcservices/CommandingServiceBase.h"
+#include "fsfw/tmtcservices/PusServiceBase.h"
+#include "gpioInit.h"
+#include "linux/ObjectFactory.h"
 #include "linux/boardtest/LibgpiodTest.h"
 #include "linux/boardtest/SpiTestClass.h"
 #include "linux/boardtest/UartTestClass.h"
-
 #include "mission/core/GenericFactory.h"
-#include "mission/utility/TmFunnel.h"
-#include "mission/devices/MGMHandlerLIS3MDL.h"
-#include "mission/devices/MGMHandlerRM3100.h"
-#include "mission/devices/GyroADIS16507Handler.h"
-
-#include "fsfw/datapoollocal/LocalDataPoolManager.h"
-#include "fsfw/tmtcservices/CommandingServiceBase.h"
-#include "fsfw/tmtcservices/PusServiceBase.h"
-#include "fsfw/tmtcpacket/pus/tm.h"
-#include "fsfw/tasks/TaskFactory.h"
+#include "mission/devices/GPSHyperionHandler.h"
+#include "mission/devices/GyroADIS1650XHandler.h"
+#include "mission/tmtc/TmFunnel.h"
+#include "objects/systemObjectList.h"
+#include "tmtc/pusIds.h"

 /* UDP server includes */
-#include "fsfw/osal/common/UdpTmTcBridge.h"
+#if OBSW_USE_TMTC_TCP_BRIDGE == 1
+#include <fsfw/src/fsfw/osal/common/TcpTmTcBridge.h>
+#include <fsfw/src/fsfw/osal/common/TcpTmTcServer.h>
+#else
 #include "fsfw/osal/common/UdpTcPollingTask.h"
-
-#include "fsfw/hal/devicehandlers/GyroL3GD20Handler.h"
-#include "fsfw/hal/linux/gpio/LinuxLibgpioIF.h"
-#include "fsfw/hal/linux/rpi/GpioRPi.h"
-#include "fsfw/hal/common/gpio/GpioCookie.h"
-#include "fsfw/hal/linux/spi/SpiCookie.h"
-#include "fsfw/hal/linux/spi/SpiComIF.h"
-
-void Factory::setStaticFrameworkObjectIds() {
-    PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
-    PusServiceBase::packetDestination = objects::TM_FUNNEL;
-
-    CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
-    CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
-
-    TmFunnel::downlinkDestination = objects::UDP_BRIDGE;
-    // No storage object for now.
-    TmFunnel::storageDestination = objects::NO_OBJECT;
-
-    VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
-    TmPacketBase::timeStamperId = objects::TIME_STAMPER;
-}
-
-
-
-void ObjectFactory::produce(void* args){
-    Factory::setStaticFrameworkObjectIds();
-    ObjectFactory::produceGenericObjects();
-
-    new UdpTmTcBridge(objects::UDP_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR);
-    new UdpTcPollingTask(objects::UDP_POLLING_TASK, objects::UDP_BRIDGE);
-
-    GpioIF* gpioIF = new LinuxLibgpioIF(objects::GPIO_IF);
-    GpioCookie* gpioCookie = nullptr;
-    static_cast<void>(gpioCookie);
-#if RPI_ADD_SPI_TEST == 1
-    new SpiTestClass(objects::SPI_TEST, gpioIF);
+#include "fsfw/osal/common/UdpTmTcBridge.h"
 #endif

-#if RPI_ADD_UART_TEST == 1
-    new UartTestClass(objects::UART_TEST);
+#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"
+#include "fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h"
+#include "fsfw_hal/devicehandlers/MgmRM3100Handler.h"
+#include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
+#include "fsfw_hal/linux/rpi/GpioRPi.h"
+#include "fsfw_hal/linux/spi/SpiComIF.h"
+#include "fsfw_hal/linux/spi/SpiCookie.h"
+
+void Factory::setStaticFrameworkObjectIds() {
+  PusServiceBase::PUS_DISTRIBUTOR = objects::PUS_PACKET_DISTRIBUTOR;
+  PusServiceBase::PACKET_DESTINATION = objects::TM_FUNNEL;
+
+  CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
+  CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
+
+  TmFunnel::downlinkDestination = objects::TMTC_BRIDGE;
+  // No storage object for now.
+  TmFunnel::storageDestination = objects::NO_OBJECT;
+}
+
+void ObjectFactory::produce(void* args) {
+  Factory::setStaticFrameworkObjectIds();
+  ObjectFactory::produceGenericObjects();
+
+  GpioIF* gpioIF = new LinuxLibgpioIF(objects::GPIO_IF);
+  GpioCookie* gpioCookie = nullptr;
+  static_cast<void>(gpioCookie);
+
+  SpiComIF* spiComIF = new SpiComIF(objects::SPI_MAIN_COM_IF, spi::DEV, gpioIF);
+  static_cast<void>(spiComIF);
+  auto pwrSwitcher = new DummyPowerSwitcher(objects::PCDU_HANDLER, 18, 0);
+  static_cast<void>(pwrSwitcher);
+
+#if OBSW_ADD_ACS_BOARD == 1 && defined(RASPBERRY_PI)
+  createRpiAcsBoard(gpioIF, spiDev);
+#endif
+
+#if OBSW_ADD_SUN_SENSORS == 1 || OBSW_ADD_RTD_DEVICES == 1
+#ifdef RASPBERRY_PI
+  rpi::gpio::initSpiCsDecoder(gpioIF);
+#endif
+#endif
+
+#if OBSW_ADD_SCEX_DEVICE == 1
+  auto* sdcMan = new RPiSdCardManager("/tmp");
+  createScexComponents(uart::DEV, pwrSwitcher, *sdcMan, true, std::nullopt);
+#endif
+
+#if OBSW_ADD_SUN_SENSORS == 1
+  createSunSensorComponents(gpioIF, spiComIF, pwrSwitcher, spi::DEV);
+#endif
+
+#if OBSW_ADD_RTD_DEVICES == 1
+  createRtdComponents(spi::DEV, gpioIF, pwrSwitcher);
+#endif
+
+#if OBSW_ADD_TEST_CODE == 1
+  createTestTasks();
+#endif /* OBSW_ADD_TEST_CODE == 1 */
+}
+
+void ObjectFactory::createRpiAcsBoard(GpioIF* gpioIF, std::string spiDev) {
+  GpioCookie* gpioCookie = new GpioCookie();
+  // TODO: Missing pin for Gyro 2
+  gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_0_LIS3_CS, gpio::MGM_0_BCM_PIN, "MGM_0_LIS3",
+                            gpio::Direction::OUT, gpio::Levels::HIGH);
+  gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_1_RM3100_CS, gpio::MGM_1_BCM_PIN,
+                            "MGM_1_RM3100", gpio::Direction::OUT, gpio::Levels::HIGH);
+  gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_2_LIS3_CS, gpio::MGM_2_BCM_PIN, "MGM_2_LIS3",
+                            gpio::Direction::OUT, gpio::Levels::HIGH);
+  gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_3_RM3100_CS, gpio::MGM_3_BCM_PIN,
+                            "MGM_3_RM3100", gpio::Direction::OUT, gpio::Levels::HIGH);
+  gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_0_ADIS_CS, gpio::GYRO_0_BCM_PIN,
+                            "GYRO_0_ADIS", gpio::Direction::OUT, gpio::Levels::HIGH);
+  gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_1_L3G_CS, gpio::GYRO_1_BCM_PIN, "GYRO_1_L3G",
+                            gpio::Direction::OUT, gpio::Levels::HIGH);
+  gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_2_ADIS_CS, gpio::GYRO_2_BCM_PIN,
+                            "GYRO_2_ADIS", gpio::Direction::OUT, gpio::Levels::HIGH);
+  gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_3_L3G_CS, gpio::GYRO_3_BCM_PIN, "GYRO_3_L3G",
+                            gpio::Direction::OUT, gpio::Levels::HIGH);
+  gpioIF->addGpios(gpioCookie);
+  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, 0);
+  mgmLis3Handler->setStartUpImmediately();
+#if OBSW_TEST_ACS == 1
+  mgmLis3Handler->setToGoToNormalMode(true);
+#endif
+
+  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 =
+      new MgmRM3100Handler(objects::MGM_1_RM3100_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, 0);
+  mgmRm3100Handler->setStartUpImmediately();
+#if OBSW_TEST_ACS == 1
+  mgmRm3100Handler->setToGoToNormalMode(true);
+#endif
+
+  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, 0);
+  mgmLis3Handler->setStartUpImmediately();
+#if OBSW_TEST_ACS == 1
+  mgmLis3Handler->setToGoToNormalMode(true);
+#endif
+
+  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, 0);
+  mgmRm3100Handler->setStartUpImmediately();
+#if OBSW_TEST_ACS == 1
+  mgmRm3100Handler->setToGoToNormalMode(true);
+#endif
+
+  spiCookie =
+      new SpiCookie(addresses::GYRO_0_ADIS, gpioIds::GYRO_0_ADIS_CS, ADIS1650X::MAXIMUM_REPLY_SIZE,
+                    spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
+  auto adisHandler =
+      new GyroADIS1650XHandler(objects::GYRO_0_ADIS_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie,
+                               ADIS1650X::Type::ADIS16505);
+  adisHandler->setStartUpImmediately();
+  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(objects::GYRO_1_L3G_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, 0);
+  gyroL3gHandler->setStartUpImmediately();
+#if OBSW_TEST_ACS == 1
+  gyroL3gHandler->setToGoToNormalMode(true);
+#endif
+
+  spiCookie =
+      new SpiCookie(addresses::GYRO_2_ADIS, gpioIds::GYRO_2_ADIS_CS, ADIS1650X::MAXIMUM_REPLY_SIZE,
+                    spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
+  adisHandler = new GyroADIS1650XHandler(objects::GYRO_2_ADIS_HANDLER, objects::SPI_MAIN_COM_IF,
+                                         spiCookie, ADIS1650X::Type::ADIS16505);
+  adisHandler->setStartUpImmediately();
+
+  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, 0);
+  gyroL3gHandler->setStartUpImmediately();
+#if OBSW_TEST_ACS == 1
+  gyroL3gHandler->setToGoToNormalMode(true);
+#endif
+}
+
+void ObjectFactory::createTestTasks() {
+  new TestTask(objects::TEST_TASK);
+
+#if OBSW_ADD_SPI_TEST_CODE == 1
+  new SpiTestClass(objects::SPI_TEST, gpioIF);
+#endif
+
+#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
-    GpioCookie* gpioCookieLoopback = new GpioCookie();
-    /* Loopback pins. Adapt according to setup */
-    gpioId_t gpioIdSender = gpioIds::TEST_ID_0;
-    int bcmPinSender = 26;
-    gpioId_t gpioIdReader = gpioIds::TEST_ID_1;
-    int bcmPinReader = 16;
-    gpio::createRpiGpioConfig(gpioCookieLoopback, gpioIdSender, bcmPinSender, "GPIO_LB_SENDER",
-            gpio::Direction::OUT, 0);
-    gpio::createRpiGpioConfig(gpioCookieLoopback, gpioIdReader, bcmPinReader, "GPIO_LB_READER",
-            gpio::Direction::IN, 0);
-    new LibgpiodTest(objects::LIBGPIOD_TEST, objects::GPIO_IF, gpioCookieLoopback);
+  GpioCookie* gpioCookieLoopback = new GpioCookie();
+  /* Loopback pins. Adapt according to setup */
+  gpioId_t gpioIdSender = gpioIds::TEST_ID_0;
+  int bcmPinSender = 26;
+  gpioId_t gpioIdReader = gpioIds::TEST_ID_1;
+  int bcmPinReader = 16;
+  gpio::createRpiGpioConfig(gpioCookieLoopback, gpioIdSender, bcmPinSender, "GPIO_LB_SENDER",
+                            gpio::Direction::OUT, 0);
+  gpio::createRpiGpioConfig(gpioCookieLoopback, gpioIdReader, bcmPinReader, "GPIO_LB_READER",
+                            gpio::Direction::IN, 0);
+  new LibgpiodTest(objects::LIBGPIOD_TEST, objects::GPIO_IF, gpioCookieLoopback);
 #endif /* RPI_LOOPBACK_TEST_GPIO == 1 */

-    new SpiComIF(objects::SPI_COM_IF, gpioIF);
-
-    std::string spiDev;
-    SpiCookie* spiCookie = nullptr;
-    static_cast<void>(spiCookie);
-
-#if RPI_TEST_ACS_BOARD == 1
-    if(gpioCookie == nullptr) {
-        gpioCookie = new GpioCookie();
-    }
-    gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_0_LIS3_CS, gpio::MGM_0_BCM_PIN,
-            "MGM_0_LIS3", gpio::Direction::OUT, 1);
-    gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_1_RM3100_CS, gpio::MGM_1_BCM_PIN,
-            "MGM_1_RM3100", gpio::Direction::OUT, 1);
-    gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_2_LIS3_CS, gpio::MGM_2_BCM_PIN,
-            "MGM_2_LIS3", gpio::Direction::OUT, 1);
-    gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_3_RM3100_CS, gpio::MGM_3_BCM_PIN,
-            "MGM_3_RM3100", gpio::Direction::OUT, 1);
-    gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_0_ADIS_CS, gpio::GYRO_0_BCM_PIN,
-            "GYRO_0_ADIS", gpio::Direction::OUT, 1);
-    gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_1_L3G_CS, gpio::GYRO_1_BCM_PIN,
-            "GYRO_1_L3G", gpio::Direction::OUT, 1);
-    gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_2_L3G_CS, gpio::GYRO_2_BCM_PIN,
-            "GYRO_2_L3G", gpio::Direction::OUT, 1);
-    gpioIF->addGpios(gpioCookie);
-
-    spiDev = "/dev/spidev0.0";
-    spiCookie = new SpiCookie(addresses::MGM_0_LIS3, gpioIds::MGM_0_LIS3_CS, spiDev,
-            MGMLIS3MDL::MAX_BUFFER_SIZE, spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED);
-    auto mgmLis3Handler = new MGMHandlerLIS3MDL(objects::MGM_0_LIS3_HANDLER,
-            objects::SPI_COM_IF, spiCookie);
-    mgmLis3Handler->setStartUpImmediately();
-
-    spiCookie = new SpiCookie(addresses::MGM_1_RM3100, gpioIds::MGM_1_RM3100_CS, spiDev,
-            RM3100::MAX_BUFFER_SIZE, spi::DEFAULT_RM3100_MODE, spi::DEFAULT_RM3100_SPEED);
-    auto mgmRm3100Handler = new MGMHandlerRM3100(objects::MGM_1_RM3100_HANDLER,
-            objects::SPI_COM_IF, spiCookie);
-    mgmRm3100Handler->setStartUpImmediately();
-
-    spiCookie = new SpiCookie(addresses::GYRO_1_L3G, gpioIds::GYRO_1_L3G_CS, spiDev,
-            L3GD20H::MAX_BUFFER_SIZE, spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
-    auto gyroL3gHandler = new GyroHandlerL3GD20H(objects::GYRO_1_L3G_HANDLER, objects::SPI_COM_IF,
-            spiCookie);
-    gyroL3gHandler->setStartUpImmediately();
-
-#endif /* RPI_TEST_ACS_BOARD == 1 */
-
 #if RPI_TEST_ADIS16507 == 1
-    if(gpioCookie == nullptr) {
-        gpioCookie = new GpioCookie();
-    }
-    gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_0_ADIS_CS, gpio::GYRO_0_BCM_PIN,
-            "GYRO_0_ADIS", gpio::Direction::OUT, 1);
-    gpioIF->addGpios(gpioCookie);
+  if (gpioCookie == nullptr) {
+    gpioCookie = new GpioCookie();
+  }
+  gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_0_ADIS_CS, gpio::GYRO_0_BCM_PIN,
+                            "GYRO_0_ADIS", gpio::Direction::OUT, 1);
+  gpioIF->addGpios(gpioCookie);

-    spiDev = "/dev/spidev0.0";
-    spiCookie = new SpiCookie(addresses::GYRO_0_ADIS, gpioIds::GYRO_0_ADIS_CS, spiDev,
-            ADIS16507::MAXIMUM_REPLY_SIZE, spi::DEFAULT_ADIS16507_MODE, spi::DEFAULT_ADIS16507_SPEED,
-            nullptr, nullptr);
-    auto adisGyroHandler = new GyroADIS16507Handler(objects::GYRO_0_ADIS_HANDLER, objects::SPI_COM_IF, spiCookie);
-    adisGyroHandler->setStartUpImmediately();
+  spiDev = "/dev/spidev0.1";
+  spiCookie = new SpiCookie(addresses::GYRO_0_ADIS, gpioIds::GYRO_0_ADIS_CS, spiDev,
+                            ADIS16507::MAXIMUM_REPLY_SIZE, spi::DEFAULT_ADIS16507_MODE,
+                            spi::DEFAULT_ADIS16507_SPEED, nullptr, nullptr);
+  auto adisGyroHandler =
+      new GyroADIS16507Handler(objects::GYRO_0_ADIS_HANDLER, objects::SPI_COM_IF, spiCookie);
+  adisGyroHandler->setStartUpImmediately();
 #endif /* RPI_TEST_ADIS16507 == 1 */

 #if RPI_TEST_GPS_HANDLER == 1
-    UartCookie* uartCookie = new UartCookie(objects::GPS0_HANDLER, "/dev/serial0",
-            UartModes::CANONICAL, 9600, 1024);
-    uartCookie->setToFlushInput(true);
-    uartCookie->setReadCycles(6);
-    GPSHyperionHandler* gpsHandler = new GPSHyperionHandler(objects::GPS0_HANDLER,
-            objects::UART_COM_IF, uartCookie);
-    gpsHandler->setStartUpImmediately();
+  UartCookie* uartCookie =
+      new UartCookie(objects::GPS0_HANDLER, "/dev/serial0", UartModes::CANONICAL, 9600, 1024);
+  uartCookie->setToFlushInput(true);
+  uartCookie->setReadCycles(6);
+  GPSHyperionHandler* gpsHandler =
+      new GPSHyperionHandler(objects::GPS0_HANDLER, objects::UART_COM_IF, uartCookie, false);
+  gpsHandler->setStartUpImmediately();
 #endif
-
 }
--- a/bsp_linux_board/ObjectFactory.h
+++ b/bsp_linux_board/ObjectFactory.h
@ -1,10 +1,16 @@
 #ifndef BSP_LINUX_OBJECTFACTORY_H_
 #define BSP_LINUX_OBJECTFACTORY_H_

+#include <string>
+
+class GpioIF;

 namespace ObjectFactory {
-	void setStatics();
-	void produce(void* args);
-};
+void setStatics();
+void produce(void* args);
+
+void createRpiAcsBoard(GpioIF* gpioIF, std::string spiDev);
+void createTestTasks();
+};  // namespace ObjectFactory

 #endif /* BSP_LINUX_OBJECTFACTORY_H_ */
--- a/bsp_linux_board/RPiSdCardManager.cpp
+++ b/bsp_linux_board/RPiSdCardManager.cpp
@ -0,0 +1,13 @@
+#include "RPiSdCardManager.h"
+
+RPiSdCardManager::RPiSdCardManager(std::string prefix) : prefix(std::move(prefix)) {}
+
+const std::string& RPiSdCardManager::getCurrentMountPrefix() const { return prefix; }
+
+bool RPiSdCardManager::isSdCardUsable(sd::SdCard sdCard) { return true; }
+
+std::optional<sd::SdCard> RPiSdCardManager::getPreferredSdCard() const { return std::nullopt; }
+
+void RPiSdCardManager::setActiveSdCard(sd::SdCard sdCard) {}
+
+std::optional<sd::SdCard> RPiSdCardManager::getActiveSdCard() const { return std::nullopt; }
--- a/bsp_linux_board/RPiSdCardManager.h
+++ b/bsp_linux_board/RPiSdCardManager.h
@ -0,0 +1,18 @@
+#ifndef BSP_LINUX_BOARD_RPISDCARDMANAGER_H_
+#define BSP_LINUX_BOARD_RPISDCARDMANAGER_H_
+#include <mission/memory/SdCardMountedIF.h>
+
+class RPiSdCardManager : public SdCardMountedIF {
+ public:
+  RPiSdCardManager(std::string prefix);
+  const std::string& getCurrentMountPrefix() const override;
+  bool isSdCardUsable(sd::SdCard sdCard) override;
+  std::optional<sd::SdCard> getPreferredSdCard() const override;
+  void setActiveSdCard(sd::SdCard sdCard) override;
+  std::optional<sd::SdCard> getActiveSdCard() const override;
+
+ private:
+  std::string prefix;
+};
+
+#endif /* BSP_LINUX_BOARD_RPISDCARDMANAGER_H_ */
--- a/bsp_linux_board/boardconfig/CMakeLists.txt
+++ b/bsp_linux_board/boardconfig/CMakeLists.txt
@ -1,7 +1,3 @@
-target_sources(${TARGET_NAME} PRIVATE
-	print.c
-)
+target_sources(${OBSW_NAME} PRIVATE print.c)

-target_include_directories(${TARGET_NAME} PUBLIC
-	${CMAKE_CURRENT_SOURCE_DIR}
-)
+target_include_directories(${OBSW_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
--- a/bsp_linux_board/boardconfig/etl_profile.h
+++ b/bsp_linux_board/boardconfig/etl_profile.h
@ -32,7 +32,7 @@ SOFTWARE.

 #define ETL_CHECK_PUSH_POP

-#define ETL_CPP11_SUPPORTED  1
-#define ETL_NO_NULLPTR_SUPPORT  0
+#define ETL_CPP11_SUPPORTED 1
+#define ETL_NO_NULLPTR_SUPPORT 0

 #endif
--- a/bsp_linux_board/boardconfig/gcov.h
+++ b/bsp_linux_board/boardconfig/gcov.h
@ -6,8 +6,9 @@
 extern "C" void __gcov_flush();
 #else
 void __gcov_flush() {
-	sif::info << "GCC GCOV: Please supply GCOV=1 in Makefile if "
-			"coverage information is desired.\n" << std::flush;
+  sif::info << "GCC GCOV: Please supply GCOV=1 in Makefile if "
+               "coverage information is desired.\n"
+            << std::flush;
 }
 #endif

--- a/bsp_linux_board/boardconfig/print.c
+++ b/bsp_linux_board/boardconfig/print.c
@ -1,14 +1,10 @@
-#include <bsp_q7s/boardconfig/print.h>
+#include <bsp_linux_board/boardconfig/print.h>
 #include <stdio.h>

 void printChar(const char* character, bool errStream) {
-	if(errStream) {
-		putc(*character, stderr);
-		return;
-	}
-	putc(*character, stdout);
+  if (errStream) {
+    putc(*character, stderr);
+    return;
+  }
+  putc(*character, stdout);
 }
-
-
-
-
--- a/bsp_linux_board/boardconfig/rpiConfig.h.in
+++ b/bsp_linux_board/boardconfig/rpiConfig.h.in
@ -15,20 +15,6 @@
 #define RPI_TEST_ACS_BOARD              0
 #endif

-#define RPI_ADD_UART_TEST               1
-#if RPI_ADD_UART_TEST == 1
-#define RPI_TEST_GPS_DEVICE             0
-#endif
-
-/* Adapt these values accordingly */
-namespace gpio {
-static constexpr uint8_t MGM_0_BCM_PIN = 0;
-static constexpr uint8_t MGM_1_BCM_PIN = 1;
-static constexpr uint8_t MGM_2_BCM_PIN = 17;
-static constexpr uint8_t MGM_3_BCM_PIN = 27;
-static constexpr uint8_t GYRO_0_BCM_PIN = 5;
-static constexpr uint8_t GYRO_1_BCM_PIN = 6;
-static constexpr uint8_t GYRO_2_BCM_PIN = 4;
-}
+#define RPI_ADD_UART_TEST               0

 #endif /* BSP_RPI_BOARDCONFIG_RPI_CONFIG_H_ */
--- a/bsp_linux_board/boardtest/CMakeLists.txt
+++ b/bsp_linux_board/boardtest/CMakeLists.txt
@ -1,6 +1 @@
-target_sources(${TARGET_NAME} PRIVATE
-)
-
-
-
-
+target_sources(${OBSW_NAME} PRIVATE)
--- a/bsp_linux_board/definitions.h
+++ b/bsp_linux_board/definitions.h
@ -0,0 +1,43 @@
+#ifndef BSP_LINUX_BOARD_DEFINITIONS_H_
+#define BSP_LINUX_BOARD_DEFINITIONS_H_
+
+#include <cstdint>
+
+#include "OBSWConfig.h"
+
+#ifdef RASPBERRY_PI
+
+namespace spi {
+
+static constexpr char DEV[] = "/dev/spidev0.1";
+
+}
+
+namespace uart {
+
+static constexpr char DEV[] = "/dev/serial0";
+
+}
+
+/* Adapt these values accordingly */
+namespace gpio {
+static constexpr uint8_t MGM_0_BCM_PIN = 17;
+static constexpr uint8_t MGM_1_BCM_PIN = 27;
+static constexpr uint8_t MGM_2_BCM_PIN = 22;
+static constexpr uint8_t MGM_3_BCM_PIN = 23;
+static constexpr uint8_t GYRO_0_BCM_PIN = 5;
+static constexpr uint8_t GYRO_1_BCM_PIN = 6;
+static constexpr uint8_t GYRO_2_BCM_PIN = 13;
+static constexpr uint8_t GYRO_3_BCM_PIN = 19;
+
+static constexpr uint8_t SPI_MUX_0_BCM = 17;
+static constexpr uint8_t SPI_MUX_1_BCM = 27;
+static constexpr uint8_t SPI_MUX_2_BCM = 22;
+static constexpr uint8_t SPI_MUX_3_BCM = 23;
+static constexpr uint8_t SPI_MUX_4_BCM = 5;
+static constexpr uint8_t SPI_MUX_5_BCM = 6;
+}  // namespace gpio
+
+#endif
+
+#endif /* BSP_LINUX_BOARD_DEFINITIONS_H_ */
--- a/bsp_linux_board/gpioInit.cpp
+++ b/bsp_linux_board/gpioInit.cpp
@ -0,0 +1,56 @@
+#include "gpioInit.h"
+
+#include <devices/gpioIds.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
+#include <fsfw_hal/common/gpio/GpioCookie.h>
+#include <fsfw_hal/common/gpio/GpioIF.h>
+
+#include "definitions.h"
+#include "fsfw_hal/linux/rpi/GpioRPi.h"
+
+#ifdef RASPBERRY_PI
+
+struct MuxInfo {
+  MuxInfo(gpioId_t gpioId, int bcmNum, std::string consumer)
+      : gpioId(gpioId), bcmNum(bcmNum), consumer(consumer) {}
+  gpioId_t gpioId;
+  int bcmNum;
+  std::string consumer;
+};
+
+void rpi::gpio::initSpiCsDecoder(GpioIF* gpioComIF) {
+  using namespace ::gpio;
+  ReturnValue_t result;
+
+  if (gpioComIF == nullptr) {
+    sif::debug << "initSpiCsDecoder: Invalid gpioComIF" << std::endl;
+    return;
+  }
+
+  std::array<::MuxInfo, 6> muxInfo{
+      MuxInfo(gpioIds::SPI_MUX_BIT_0, SPI_MUX_0_BCM, "SPI_MUX_0"),
+      MuxInfo(gpioIds::SPI_MUX_BIT_1, SPI_MUX_1_BCM, "SPI_MUX_1"),
+      MuxInfo(gpioIds::SPI_MUX_BIT_2, SPI_MUX_2_BCM, "SPI_MUX_2"),
+      MuxInfo(gpioIds::SPI_MUX_BIT_3, SPI_MUX_3_BCM, "SPI_MUX_3"),
+      MuxInfo(gpioIds::SPI_MUX_BIT_4, SPI_MUX_4_BCM, "SPI_MUX_4"),
+      MuxInfo(gpioIds::SPI_MUX_BIT_5, SPI_MUX_5_BCM, "SPI_MUX_5"),
+  };
+  GpioCookie* spiMuxGpios = new GpioCookie;
+
+  for (const auto& info : muxInfo) {
+    result = createRpiGpioConfig(spiMuxGpios, info.gpioId, info.bcmNum, info.consumer,
+                                 Direction::OUT, Levels::LOW);
+    if (result != returnvalue::OK) {
+      sif::error << "Creating Raspberry Pi SPI Mux GPIO failed with code " << result << std::endl;
+      return;
+    }
+  }
+
+  result = gpioComIF->addGpios(spiMuxGpios);
+  if (result != returnvalue::OK) {
+    sif::error << "initSpiCsDecoder: Failed to add mux bit gpios to gpioComIF" << std::endl;
+    return;
+  }
+}
+
+#endif
--- a/bsp_linux_board/gpioInit.h
+++ b/bsp_linux_board/gpioInit.h
@ -0,0 +1,20 @@
+#pragma once
+
+#include "OBSWConfig.h"
+
+class GpioIF;
+
+#ifdef RASPBERRY_PI
+namespace rpi {
+namespace gpio {
+
+/**
+ * @brief   This function initializes the GPIOs used to control the SN74LVC138APWR decoders on
+ *          the TCS Board and the interface board.
+ */
+void initSpiCsDecoder(GpioIF* gpioComIF);
+
+}  // namespace gpio
+}  // namespace rpi
+
+#endif
--- a/bsp_linux_board/main.cpp
+++ b/bsp_linux_board/main.cpp
@ -1,11 +1,11 @@
-#include "InitMission.h"
-#include "OBSWVersion.h"
-
-#include "fsfw/FSFWVersion.h"
-#include "fsfw/tasks/TaskFactory.h"
-
 #include <iostream>

+#include "InitMission.h"
+#include "OBSWConfig.h"
+#include "OBSWVersion.h"
+#include "fsfw/tasks/TaskFactory.h"
+#include "fsfw/version.h"
+
 #ifdef RASPBERRY_PI
 static const char* const BOARD_NAME = "Raspberry Pi";
 #elif defined(BEAGLEBONEBLACK)
@ -18,21 +18,17 @@ static const char* const BOARD_NAME = "Unknown Board";
 * @brief 	    This is the main program and entry point for the Raspberry Pi.
 * @return
 */
-int main(void)
-{
-    std::cout << "-- EIVE OBSW --" << std::endl;
-    std::cout << "-- Compiled for Linux board " << BOARD_NAME << " --" << std::endl;
-    std::cout << "-- OBSW " << SW_NAME << " v" << SW_VERSION << "." << SW_SUBVERSION <<
-            "." << SW_REVISION << ", FSFW v" << FSFW_VERSION << "." << FSFW_SUBVERSION <<
-            FSFW_REVISION << "--"  << std::endl;
-    std::cout << "-- " <<  __DATE__ << " " << __TIME__ << " --" << std::endl;
+int main(void) {
+  std::cout << "-- EIVE OBSW --" << std::endl;
+  std::cout << "-- Compiled for Linux board " << BOARD_NAME << " --" << std::endl;
+  std::cout << "-- OBSW " << SW_NAME << " v" << SW_VERSION << "." << SW_SUBVERSION << "."
+            << SW_REVISION << ", FSFW v" << fsfw::FSFW_VERSION << " --" << std::endl;
+  std::cout << "-- " << __DATE__ << " " << __TIME__ << " --" << std::endl;

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

-	for(;;) {
-		/* Suspend main thread by sleeping it. */
-		TaskFactory::delayTask(5000);
-	}
+  for (;;) {
+    /* Suspend main thread by sleeping it. */
+    TaskFactory::delayTask(5000);
+  }
 }
-
-
--- a/bsp_q7s/CMakeLists.txt
+++ b/bsp_q7s/CMakeLists.txt
@ -1,16 +1,27 @@
-target_sources(${TARGET_NAME} PUBLIC
-	main.cpp
-)
+# simple mode
+add_executable(${SIMPLE_OBSW_NAME} EXCLUDE_FROM_ALL)
+target_compile_definitions(${SIMPLE_OBSW_NAME} PRIVATE "Q7S_SIMPLE_MODE")
+target_sources(${SIMPLE_OBSW_NAME} PUBLIC main.cpp)
+# I think this is unintentional? (produces linker errors for stuff in /linux)
+target_link_libraries(${SIMPLE_OBSW_NAME} PUBLIC ${LIB_FSFW_NAME})
+target_compile_definitions(${SIMPLE_OBSW_NAME} PRIVATE "Q7S_SIMPLE_MODE")
+add_subdirectory(simple)
+
+target_sources(${OBSW_NAME} PUBLIC main.cpp obsw.cpp)

 add_subdirectory(boardtest)

-if(Q7S_SIMPLE_MODE)
-    add_subdirectory(simple)
+add_subdirectory(boardconfig)
+add_subdirectory(comIF)
+add_subdirectory(core)
+
+if(EIVE_Q7S_EM)
+  add_subdirectory(em)
 else()
-    add_subdirectory(boardconfig)
-    add_subdirectory(comIF)
-    add_subdirectory(gpio)
-    add_subdirectory(core)
-    add_subdirectory(memory)
-    add_subdirectory(spiCallbacks)
+  target_sources(${OBSW_NAME} PUBLIC fmObjectFactory.cpp)
 endif()
+
+add_subdirectory(memory)
+add_subdirectory(callbacks)
+add_subdirectory(xadc)
+add_subdirectory(fs)
--- a/bsp_q7s/Dockerfile
+++ b/bsp_q7s/Dockerfile
@ -1,35 +0,0 @@
-FROM ubuntu:latest
-# FROM alpine:latest
-
-ENV TZ=Europe/Berlin
-RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
-
-RUN apt-get update && apt-get install -y curl cmake g++
-
-# Q7S root filesystem, required for cross-compilation. Use IPv6 for curl
-RUN mkdir -p /usr/rootfs; \
-    curl -6 https://eive-cloud.irs.uni-stuttgart.de/index.php/s/dnfMy9kGpgynN6J/download/cortexa9hf-neon-xiphos-linux-gnueabi.tar.gz \
-    | tar xvz -C /usr/rootfs
-# Q7S C++ cross-compiler. Use IPv6 for curl
-RUN mkdir -p /usr/tools; \
-    curl -6 https://eive-cloud.irs.uni-stuttgart.de/index.php/s/RMsbHydJc6PSqcz/download/gcc-arm-linux-gnueabi.tar.gz \
-    | tar xvz -C /usr/tools
-
-# RUN apk add cmake make g++
-
-# Required for cmake build
-ENV Q7S_SYSROOT="/usr/rootfs/cortexa9hf-neon-xiphos-linux-gnueabi"
-ENV PATH=$PATH:"/usr/tools/gcc-arm-linux-gnueabi/bin"
-
-WORKDIR /usr/src/app
-COPY . .
-
-RUN set -ex; \
-    rm -rf build-q7s; \
-    mkdir build-q7s; \
-    cd build-q7s; \
-    cmake -DCMAKE_BUILD_TYPE=Release -DOS_FSFW=linux -DTGT_BSP="arm/q7s" ..;
-
-ENTRYPOINT ["cmake", "--build", "build-q7s"]
-CMD ["-j"]
-# CMD ["bash"]
--- a/bsp_q7s/OBSWConfig.h.in
+++ b/bsp_q7s/OBSWConfig.h.in
@ -0,0 +1,143 @@
+/**
+ * @brief   This file can be used to add preprocessor define for conditional
+ *          code inclusion exclusion or various other project constants and
+ *          properties in one place.
+ */
+#ifndef FSFWCONFIG_OBSWCONFIG_H_
+#define FSFWCONFIG_OBSWCONFIG_H_
+
+#include "commonConfig.h"
+#include "q7sConfig.h"
+#include "OBSWVersion.h"
+
+/*******************************************************************/
+/** All of the following flags should be enabled for mission code  */
+/*******************************************************************/
+
+#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                    @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                           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
+
+// 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
+// to leave it off for now. It makes testing a lot more difficult and it might mess with
+// something the operators might want to do by giving the software too much intelligence
+// at the wrong place. The system component might command all the Switches accordingly anyway
+#define OBSW_INITIALIZE_SWITCHES                    0
+#define OBSW_ENABLE_PERIODIC_HK                     0
+
+/*******************************************************************/
+/** All of the following flags should be disabled for mission code */
+/*******************************************************************/
+
+// Can be used to switch device to NORMAL mode immediately
+#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                     @OBSW_SYRLINKS_SIMULATED@
+#define OBSW_ADD_TEST_CODE                          0
+#define OBSW_ADD_TEST_TASK                          0
+#define OBSW_ADD_TEST_PST                           0
+// If this is enabled, all other SPI code should be disabled
+#define OBSW_ADD_SPI_TEST_CODE                      0
+// If this is enabled, all other I2C code should be disabled
+#define OBSW_ADD_I2C_TEST_CODE                      0
+#define OBSW_ADD_UART_TEST_CODE                     0
+
+#define OBSW_TEST_ACS                               0
+#define OBSW_DEBUG_ACS                              0
+#define OBSW_TEST_SUS                               0
+#define OBSW_DEBUG_SUS                              0
+#define OBSW_TEST_RTD                               0
+#define OBSW_DEBUG_RTD                              0
+#define OBSW_TEST_RAD_SENSOR                        0
+#define OBSW_DEBUG_RAD_SENSOR                       0
+#define OBSW_TEST_PL_PCDU                           0
+#define OBSW_DEBUG_PL_PCDU                          0
+#define OBSW_TEST_BPX_BATT                          0
+#define OBSW_DEBUG_BPX_BATT                         0
+#define OBSW_TEST_IMTQ                              0
+#define OBSW_DEBUG_IMTQ                             0
+#define OBSW_TEST_RW                                0
+#define OBSW_DEBUG_RW                               0
+
+#define OBSW_TEST_LIBGPIOD                          0
+#define OBSW_TEST_PLOC_HANDLER                      0
+#define OBSW_TEST_CCSDS_BRIDGE                      0
+#define OBSW_TEST_CCSDS_PTME                        0
+#define OBSW_TEST_TE7020_HEATER                     0
+#define OBSW_TEST_GPIO_OPEN_BY_LABEL                0
+#define OBSW_TEST_GPIO_OPEN_BY_LINE_NAME            0
+#define OBSW_DEBUG_P60DOCK                          0
+
+#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
+
+#define OBSW_DEBUG_PDEC_HANDLER                     0
+#define OBSW_DEBUG_PLOC_SUPERVISOR                  0
+#define OBSW_DEBUG_PLOC_MPSOC                       0
+#define OBSW_DEBUG_STARTRACKER                      0
+
+#define OBSW_TCP_SERVER_WIRETAPPING                 0
+
+/*******************************************************************/
+/** 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@
+#cmakedefine LIBGPS_VERSION_MINOR @LIBGPS_VERSION_MINOR@
+
+#ifdef __cplusplus
+
+#include "objects/systemObjectList.h"
+#include "events/subsystemIdRanges.h"
+#include "returnvalues/classIds.h"
+
+#endif
+
+#endif /* FSFWCONFIG_OBSWCONFIG_H_ */
--- a/bsp_q7s/boardconfig/CMakeLists.txt
+++ b/bsp_q7s/boardconfig/CMakeLists.txt
@ -1,7 +1,5 @@
-target_sources(${TARGET_NAME} PRIVATE
-	print.c
-)
+target_sources(${OBSW_NAME} PRIVATE print.c)

-target_include_directories(${TARGET_NAME} PUBLIC
-	${CMAKE_CURRENT_SOURCE_DIR}
-)
+target_sources(${SIMPLE_OBSW_NAME} PRIVATE print.c)
+
+target_include_directories(${OBSW_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
--- a/bsp_q7s/boardconfig/busConf.h
+++ b/bsp_q7s/boardconfig/busConf.h
@ -0,0 +1,111 @@
+#ifndef BSP_Q7S_BOARDCONFIG_BUSCONF_H_
+#define BSP_Q7S_BOARDCONFIG_BUSCONF_H_
+
+namespace q7s {
+
+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";
+
+//! 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/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/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 {
+static const int PTME_VC0 = 0;
+static const int PTME_VC1 = 1;
+static const int PTME_VC2 = 2;
+static const int PTME_VC3 = 3;
+static const int PTME_CONFIG = 4;
+}  // namespace uiomapids
+
+namespace gpioNames {
+
+static constexpr char GYRO_0_ADIS_CS[] = "gyro_0_adis_chip_select";
+static constexpr char GYRO_1_L3G_CS[] = "gyro_1_l3g_chip_select";
+static constexpr char GYRO_2_ADIS_CS[] = "gyro_2_adis_chip_select";
+static constexpr char GYRO_3_L3G_CS[] = "gyro_3_l3g_chip_select";
+static constexpr char MGM_0_CS[] = "mgm_0_lis3_chip_select";
+static constexpr char MGM_1_CS[] = "mgm_1_rm3100_chip_select";
+static constexpr char MGM_2_CS[] = "mgm_2_lis3_chip_select";
+static constexpr char MGM_3_CS[] = "mgm_3_rm3100_chip_select";
+static constexpr char RESET_GNSS_0[] = "reset_gnss_0";
+static constexpr char RESET_GNSS_1[] = "reset_gnss_1";
+static constexpr char GNSS_0_ENABLE[] = "enable_gnss_0";
+static constexpr char GNSS_1_ENABLE[] = "enable_gnss_1";
+static constexpr char GYRO_0_ENABLE[] = "enable_gyro_0";
+static constexpr char GYRO_2_ENABLE[] = "enable_gyro_2";
+static constexpr char GNSS_SELECT[] = "gnss_mux_select";
+static constexpr char GNSS_MUX_SELECT[] = "gnss_mux_select";
+
+static constexpr char HEATER_0[] = "heater0";
+static constexpr char HEATER_1[] = "heater1";
+static constexpr char HEATER_2[] = "heater2";
+static constexpr char HEATER_3[] = "heater3";
+static constexpr char HEATER_4[] = "heater4";
+static constexpr char HEATER_5[] = "heater5";
+static constexpr char HEATER_6[] = "heater6";
+static constexpr char HEATER_7[] = "heater7";
+static constexpr char SA_DPL_PIN_0[] = "sa_dpl_0";
+static constexpr char SA_DPL_PIN_1[] = "sa_dpl_1";
+static constexpr char SPI_MUX_BIT_0_PIN[] = "spi_mux_bit_0";
+static constexpr char SPI_MUX_BIT_1_PIN[] = "spi_mux_bit_1";
+static constexpr char SPI_MUX_BIT_2_PIN[] = "spi_mux_bit_2";
+static constexpr char SPI_MUX_BIT_3_PIN[] = "spi_mux_bit_3";
+static constexpr char SPI_MUX_BIT_4_PIN[] = "spi_mux_bit_4";
+static constexpr char SPI_MUX_BIT_5_PIN[] = "spi_mux_bit_5";
+static constexpr char EN_RW_CS[] = "en_rw_cs";
+static constexpr char EN_RW_1[] = "enable_rw_1";
+static constexpr char EN_RW_2[] = "enable_rw_2";
+static constexpr char EN_RW_3[] = "enable_rw_3";
+static constexpr char EN_RW_4[] = "enable_rw_4";
+
+static constexpr char RAD_SENSOR_CHIP_SELECT[] = "rad_sensor_chip_select";
+static constexpr char ENABLE_RADFET[] = "enable_radfet";
+static constexpr char PAPB_BUSY_SIGNAL_VC0[] = "papb_busy_signal_vc0";
+static constexpr char PAPB_EMPTY_SIGNAL_VC0[] = "papb_empty_signal_vc0";
+static constexpr char PAPB_BUSY_SIGNAL_VC1[] = "papb_busy_signal_vc1";
+static constexpr char PAPB_EMPTY_SIGNAL_VC1[] = "papb_empty_signal_vc1";
+static constexpr char PAPB_BUSY_SIGNAL_VC2[] = "papb_busy_signal_vc2";
+static constexpr char PAPB_EMPTY_SIGNAL_VC2[] = "papb_empty_signal_vc2";
+static constexpr char PAPB_BUSY_SIGNAL_VC3[] = "papb_busy_signal_vc3";
+static constexpr char PAPB_EMPTY_SIGNAL_VC3[] = "papb_empty_signal_vc3";
+static constexpr char RS485_EN_TX_CLOCK[] = "tx_clock_enable_ltc2872";
+static constexpr char RS485_EN_TX_DATA[] = "tx_data_enable_ltc2872";
+static constexpr char RS485_EN_RX_CLOCK[] = "rx_clock_enable_ltc2872";
+static constexpr char RS485_EN_RX_DATA[] = "rx_data_enable_ltc2872";
+static constexpr char PDEC_RESET[] = "pdec_reset";
+static constexpr char SYRLINKS_FAULT[] = "syrlinks_fault";
+
+static constexpr char PL_PCDU_ENABLE_VBAT0[] = "enable_plpcdu_vbat0";
+static constexpr char PL_PCDU_ENABLE_VBAT1[] = "enable_plpcdu_vbat1";
+static constexpr char PL_PCDU_ENABLE_DRO[] = "enable_plpcdu_dro";
+static constexpr char PL_PCDU_ENABLE_X8[] = "enable_plpcdu_x8";
+static constexpr char PL_PCDU_ENABLE_TX[] = "enable_plpcdu_tx";
+static constexpr char PL_PCDU_ENABLE_HPA[] = "enable_plpcdu_hpa";
+static constexpr char PL_PCDU_ENABLE_MPA[] = "enable_plpcdu_mpa";
+static constexpr char PL_PCDU_ADC_CS[] = "plpcdu_adc_chip_select";
+
+static constexpr char ENABLE_SUPV_UART[] = "enable_supv_uart";
+static constexpr char ENABLE_MPSOC_UART[] = "enable_mpsoc_uart";
+
+}  // namespace gpioNames
+}  // namespace q7s
+
+#endif /* BSP_Q7S_BOARDCONFIG_BUSCONF_H_ */
--- a/bsp_q7s/boardconfig/etl_profile.h
+++ b/bsp_q7s/boardconfig/etl_profile.h
@ -32,7 +32,8 @@ SOFTWARE.

 #define ETL_CHECK_PUSH_POP

-#define ETL_CPP11_SUPPORTED  1
-#define ETL_NO_NULLPTR_SUPPORT  0
+#define ETL_CPP11_SUPPORTED 1
+#define ETL_NO_NULLPTR_SUPPORT 0
+#define ETL_HAS_ERROR_ON_STRING_TRUNCATION 1

 #endif
--- a/bsp_q7s/boardconfig/gcov.h
+++ b/bsp_q7s/boardconfig/gcov.h
@ -6,8 +6,9 @@
 extern "C" void __gcov_flush();
 #else
 void __gcov_flush() {
-	sif::info << "GCC GCOV: Please supply GCOV=1 in Makefile if "
-			"coverage information is desired.\n" << std::flush;
+  sif::info << "GCC GCOV: Please supply GCOV=1 in Makefile if "
+               "coverage information is desired.\n"
+            << std::flush;
 }
 #endif

--- a/bsp_q7s/boardconfig/print.c
+++ b/bsp_q7s/boardconfig/print.c
@ -2,13 +2,9 @@
 #include <stdio.h>

 void printChar(const char* character, bool errStream) {
-	if(errStream) {
-		putc(*character, stderr);
-		return;
-	}
-	putc(*character, stdout);
+  if (errStream) {
+    putc(*character, stderr);
+    return;
+  }
+  putc(*character, stdout);
 }
-
-
-
-
--- a/bsp_q7s/boardconfig/q7sConfig.h.in
+++ b/bsp_q7s/boardconfig/q7sConfig.h.in
@ -3,31 +3,28 @@

 #include <cstdint>

-#cmakedefine01 Q7S_SIMPLE_MODE
+#define OBSW_Q7S_EM                                 @OBSW_Q7S_EM@

-#define Q7S_SD_NONE                     0
-#define Q7S_SD_COLD_REDUNDANT           1
-#define Q7S_SD_HOT_REDUNDANT            2
-// The OBSW will perform different actions to set up the SD cards depending on the flag set here
-// Set to Q7S_SD_NONE: Don't do anything
-// Set to Q7S_COLD_REDUNDANT: On startup, get the prefered SD card, turn it on and mount it, and 
-//     turn off the second SD card if it is on
-// Set to Q7S_HOT_REDUNDANT: On startup, turn on both SD cards and mount them  
-#define Q7S_SD_CARD_CONFIG              Q7S_SD_COLD_REDUNDANT
+/*******************************************************************/
+/** All of the following flags should be enabled for mission code  */
+/*******************************************************************/

-#define Q7S_ADD_RTD_DEVICES             0
+//! Timers can mess up the code when debugging
+//! All of this should be enabled for mission code!

-/* Only one of those 2 should be enabled! */
-/* Add code for ACS board */
-#define OBSW_ADD_ACS_BOARD              0
-#if OBSW_ADD_ACS_BOARD == 0
-#define Q7S_ADD_SPI_TEST                0
+/*******************************************************************/
+/** Other flags                                                    */
+/*******************************************************************/
+
+// Probably better if this is disabled for mission code. Convenient for development
+#define Q7S_CHECK_FOR_ALREADY_RUNNING_IMG           1
+
+#define Q7S_SIMPLE_ADD_FILE_SYSTEM_TEST             0
+
+#ifndef Q7S_SIMPLE_MODE
+#define Q7S_SIMPLE_MODE 0
 #endif

-#define Q7S_ADD_SYRLINKS_HANDLER        1
-
-#define Q7S_SIMPLE_ADD_FILE_SYSTEM_TEST 0
-
 namespace config {

 static const uint32_t SD_CARD_ACCESS_MUTEX_TIMEOUT = 50;
--- a/Show More
+++ b/Show More
				`@ -0,0 +1 @@`
				`target_sources(${OBSW_NAME} PRIVATE DummyPst.cpp)`