some more fixes

update changelog
possible fix for cicd
2022-05-10 16:58:34 +02:00 · 2022-05-10 16:55:22 +02:00 · 2022-05-10 16:53:33 +02:00 · 2022-05-10 16:53:15 +02:00 · 2022-05-10 16:48:23 +02:00 · 2022-05-10 16:47:51 +02:00
117 changed files with 1280 additions and 3385 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -25,11 +25,16 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/572
 - HAL Devicehandlers: Periodic printout is run-time configurable now
 - `oneShotAction` flag in the `TestTask` class is not static anymore
+- HAL Linux Uart: Baudrate and bits per word are enums now, avoiding misconfigurations
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/585
 - Major update for version handling, using `git describe` to fetch version information with git.
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/601
  - Add helper functions provided by [`cmake-modules`](https://github.com/bilke/cmake-modules)
    manually now. Those should not change too often and only a small subset is needed
  - Separate folder for easier update and for distinction
+  - Add helper functions provided by [`cmake-modules`](https://github.com/rpavlik/cmake-modules)
+    manually now. Those should not change too often and only a small subset is needed
+  - Separate folder for easier update and for distinction
  - LICENSE file included
  - use `int` for version numbers to allow unset or uninitialized version
  - Initialize Version object with numbers set to -1
@@ -38,43 +43,18 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
    versions since the last tag
  - Additional information is set to the last part of the git describe output for `FSFW_VERSION` now.
  - Version still need to be hand-updated if the FSFW is not included as a submodule for now.
+  - CMake will auto-generate a file named `versionAutogen.cpp` on each rebuild which contains
+    the version retrieved with git
 - IPC Message Queue Handling: Allow passing an optional `MqArgs` argument into the MessageQueue
  creation call. It allows passing context information and an arbitrary user argument into
  the message queue. Also streamlined and simplified `MessageQueue` implementation for all OSALs
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/583
-
-### HAL
-
- HAL Linux Uart: Baudrate and bits per word are enums now, avoiding misconfigurations
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/585
- HAL Linux SPI: Set the Clock Default State when setting new SPI speed
-  and mode
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/573
- GPIO HAL: `Direction`, `GpioOperation` and `Levels` are enum classes now, which prevents
-  name clashes with Windows defines.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/572
- HAL Linux Uart: Baudrate and bits per word are enums now, avoiding misconfigurations
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/585
-
-### Time
-
-PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/584 and
-https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593
-
- `timeval` to `TimeOfDay_t`
- Added Mutex for gmtime calls: (compare http://www.opengate.at/blog/2020/01/timeless/)
- Moved the statics used by Clock in ClockCommon.cpp to this file
- Better check for leap seconds
- Added Unittests for Clock (only getter)
-
-### Power 
-
- `PowerSwitchIF`: Remove `const` specifier from `sendSwitchCommand` and `sendFuseOnCommand` and
-  also specify a `ReturnValue_t` return type
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
- Extend `PowerSwitcher` module to optionally check current state when calling `turnOn` or
-  `turnOff`. Tis can be helpful to avoid commanding switches which do not need commanding
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
+- Clock: 
+  - `timeval` to `TimeOfDay_t`
+  - Added Mutex for gmtime calls: (compare http://www.opengate.at/blog/2020/01/timeless/)
+  - Moved the statics used by Clock in ClockCommon.cpp to this file
+  - Better check for leap seconds
+  - Added Unittests for Clock (only getter)

 ## Removed

@@ -84,45 +64,14 @@ https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593

 ## Additions

- LTO support: Allow using LTO/IPO by setting `FSFW_ENABLE_LTO=1`. CMake is able to detect whether
-  the user compiler supports IPO/LPO. LTO is on by default now. Most modern compilers support it,
-  can make good use of it and it usually makes the code faster and/or smaller.
-  After some more research:
-  Enabling LTO will actually cause the compiler to only produce thin LTO by adding 
-  `-flto -fno-fat-lto-objects` to the compiler options. I am not sure this is an ideal choice
-  because if an application linking against the FSFW does not use LTO, there can be compile
-  issues (e.g. observed when compiling the FSFW tests without LTO). This is a known issue as
-  can be seen in the multiple CMake issues for it: 
-    - https://gitlab.kitware.com/cmake/cmake/-/issues/22913, 
-    - https://gitlab.kitware.com/cmake/cmake/-/issues/16808, 
-    - https://gitlab.kitware.com/cmake/cmake/-/issues/21696
-  Easiest solution for now: Keep this option OFF by default.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/616
+- Linux HAL: Add wiretapping option for I2C. Enabled with `FSFW_HAL_I2C_WIRETAPPING` defined to 1
 - Dedicated Version class and constant `fsfw::FSFW_VERSION` containing version information
  inside `fsfw/version.h`
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/559
- Added generic PUS TC Scheduler Service 11. It depends on the new added Emebeded Template Library
-  (ETL) dependency.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/594
 - Added ETL dependency and improved library dependency management
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/592
- Add a `DummyPowerSwitcher` module which can be useful for test setups when no PCDU is available
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
- New typedef for switcher type
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
 - `Subsystem`: New API to add table and sequence entries

-## HAL
-
- SPI: Cache the SPI device in the communication interface. Architecturally, this makes a
-  lot more sense because each ComIF should be responsible for one SPI bus.
- SPI: Move the empty transfer to update the line polarity to separate function. This means
-  it is not automatically called when calling the setter function for SPI speed and mode.
-  The user should call this function after locking the CS mutex if multiple SPI devices with
-  differing speeds and modes are attached to one bus.
- SPI: Getter functions for SPI speed and mode.
- I2C: Add wiretapping option for I2C. Enabled with `FSFW_HAL_I2C_WIRETAPPING` defined to 1.
-
 ## Fixed

 - TCP TMTC Server: `MutexGuard` was not created properly in
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -4,110 +4,94 @@ set(MSG_PREFIX "fsfw |")

 # Add the cmake folder so the FindSphinx module is found
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
-list(APPEND CMAKE_MODULE_PATH
-     "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake-modules/bilke")
-list(APPEND CMAKE_MODULE_PATH
-     "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake-modules/rpavlik")
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake-modules/bilke")
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake-modules/rpavlik")

-# ##############################################################################
+##########################
 # Version file handling  #
-# ##############################################################################
+##########################

-set(FSFW_VERSION_IF_GIT_FAILS 4)
-set(FSFW_SUBVERSION_IF_GIT_FAILS 0)
-set(FSFW_REVISION_IF_GIT_FAILS 0)
+set(FSFW_VERSION_MAJOR_IF_GIT_FAILS 4)
+set(FSFW_VERSION_MINOR_IF_GIT_FAILS 0)
+set(FSFW_VERSION_REVISION_IF_GIT_FAILS 0)

 set(FSFW_GIT_VER_HANDLING_OK FALSE)
-# Version handling
-if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
-  message(STATUS "${MSG_PREFIX} Determining version information with git")
-  include(FsfwHelpers)
-  determine_version_with_git("--exclude" "docker_*")
-  if(GIT_INFO)
-    set(FSFW_GIT_INFO
-        ${GIT_INFO}
-        CACHE STRING "Version information retrieved with git describe")
-    list(GET FSFW_GIT_INFO 1 FSFW_VERSION)
-    list(GET FSFW_GIT_INFO 2 FSFW_SUBVERSION)
-    list(GET FSFW_GIT_INFO 3 FSFW_REVISION)
-    list(GET FSFW_GIT_INFO 4 FSFW_VCS_INFO)
-    if(NOT FSFW_VERSION)
-      set(FSFW_VERSION ${FSFW_VERSION_IF_GIT_FAILS})
+# Check whether we got any revision (which isn't
+# always the case, e.g. when someone downloaded a zip
+# file from Github instead of a checkout)
+message(STATUS "${MSG_PREFIX} Determining version information with git")
+include(FsfwHelpers)
+determine_version_with_git("--exclude" "docker_*")
+if(GIT_INFO)
+    set(FSFW_GIT_INFO ${GIT_INFO} CACHE STRING "Version information retrieved with git describe" FORCE)
+    list(GET FSFW_GIT_INFO 1 FSFW_VERSION_MAJOR)
+    list(GET FSFW_GIT_INFO 2 FSFW_VERSION_MINOR)
+    list(GET FSFW_GIT_INFO 3 FSFW_VERSION_REVISION)
+    list(GET FSFW_GIT_INFO 4 FSFW_VERSION_VCS_INFO)
+    if(NOT FSFW_VERSION_MAJOR)
+        set(FSFW_VERSION_MAJOR ${FSFW_VERSION_MAJOR_IF_GIT_FAILS})
    endif()
-    if(NOT FSFW_SUBVERSION)
-      set(FSFW_SUBVERSION ${FSFW_SUBVERSION_IF_GIT_FAILS})
+    if(NOT FSFW_VERSION_MINOR)
+        set(FSFW_VERSION_MINOR ${FSFW_VERSION_MINOR_IF_GIT_FAILS})
    endif()
-    if(NOT FSFW_REVISION)
-      set(FSFW_REVISION ${FSFW_REVISION_IF_GIT_FAILS})
+    if(NOT FSFW_VERSION_REVISION)
+        set(FSFW_VERSION_REVISION ${FSFW_VERSION_REVISION_IF_GIT_FAILS})
    endif()
    set(FSFW_GIT_VER_HANDLING_OK TRUE)
-  else()
+else()
    set(FSFW_GIT_VER_HANDLING_OK FALSE)
-  endif()
 endif()
+
 if(NOT FSFW_GIT_VER_HANDLING_OK)
-  set(FSFW_VERSION ${FSFW_VERSION_IF_GIT_FAILS})
-  set(FSFW_SUBVERSION ${FSFW_SUBVERSION_IF_GIT_FAILS})
-  set(FSFW_REVISION ${FSFW_REVISION_IF_GIT_FAILS})
+    set(FSFW_VERSION_MAJOR ${FSFW_VERSION_MAJOR_IF_GIT_FAILS})
+    set(FSFW_VERSION_MINOR ${FSFW_VERSION_MINOR_IF_GIT_FAILS})
+    set(FSFW_VERSION_REVISION ${FSFW_VERSION_REVISION_IF_GIT_FAILS})
+    set(GIT_REV "N/A")
+    set(GIT_DIFF "")
+    set(GIT_BRANCH "N/A")
 endif()

+
 set(LIB_FSFW_NAME fsfw)
-project(${LIB_FSFW_NAME}
-        VERSION ${FSFW_VERSION}.${FSFW_SUBVERSION}.${FSFW_REVISION})
+project(${LIB_FSFW_NAME} VERSION ${FSFW_VERSION_MAJOR}.${FSFW_VERSION_MINOR}.${FSFW_VERSION_REVISION})

 if(NOT CMAKE_CXX_STANDARD)
-  set(CMAKE_CXX_STANDARD 17)
-  set(CMAKE_CXX_STANDARD_REQUIRED True)
+    set(CMAKE_CXX_STANDARD 17)
+    set(CMAKE_CXX_STANDARD_REQUIRED True)
 elseif(${CMAKE_CXX_STANDARD} LESS 17)
-  message(
-    FATAL_ERROR
-      "${MSG_PREFIX} Compiling the FSFW requires a minimum of C++17 support")
+    message(FATAL_ERROR "${MSG_PREFIX} Compiling the FSFW requires a minimum of C++17 support")
 endif()

 set(FSFW_SOURCES_DIR "${CMAKE_SOURCE_DIR}/src/fsfw")

-set(FSFW_ETL_LIB_NAME etl)
-set(FSFW_ETL_LIB_MAJOR_VERSION
-    20
-    CACHE STRING "ETL library major version requirement")
-set(FSFW_ETL_LIB_VERSION
-    ${FSFW_ETL_LIB_MAJOR_VERSION}.27.3
-    CACHE STRING "ETL library exact version requirement")
+set(FSFW_ETL_LIB_MAJOR_VERSION 20 CACHE STRING
+    "ETL library major version requirement"
+)
+set(FSFW_ETL_LIB_VERSION ${FSFW_ETL_LIB_MAJOR_VERSION}.27.3 CACHE STRING
+    "ETL library exact version requirement"
+)
 set(FSFW_ETL_LINK_TARGET etl::etl)

-set(FSFW_CATCH2_LIB_MAJOR_VERSION
-    3
-    CACHE STRING "Catch2 library major version requirement")
-set(FSFW_CATCH2_LIB_VERSION
-    v${FSFW_CATCH2_LIB_MAJOR_VERSION}.0.0-preview5
-    CACHE STRING "Catch2 library exact version requirement")
+set(FSFW_CATCH2_LIB_MAJOR_VERSION 3 CACHE STRING
+    "Catch2 library major version requirement"
+)
+set(FSFW_CATCH2_LIB_VERSION v${FSFW_CATCH2_LIB_MAJOR_VERSION}.0.0-preview5 CACHE STRING
+    "Catch2 library exact version requirement"
+)

-# Keep this off by default for now. See PR:
-# https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/616 for information which
-# keeping this on by default is problematic
-option(
-  FSFW_ENABLE_IPO
-  "Enable interprocedural optimization or link-time optimization if available"
-  OFF)
-if(FSFW_ENABLE_IPO)
-  include(CheckIPOSupported)
-  check_ipo_supported(RESULT IPO_SUPPORTED OUTPUT IPO_ERROR)
-  if(NOT IPO_SUPPORTED)
-    message(STATUS "FSFW | IPO/LTO not supported: ${IPO_ERROR}")
-  endif()
-endif()
+set(FSFW_ETL_LIB_NAME etl)

 option(FSFW_GENERATE_SECTIONS
-       "Generate function and data sections. Required to remove unused code" ON)
+    "Generate function and data sections. Required to remove unused code" ON
+)
 if(FSFW_GENERATE_SECTIONS)
-  option(FSFW_REMOVE_UNUSED_CODE "Remove unused code" ON)
+    option(FSFW_REMOVE_UNUSED_CODE "Remove unused code" ON)
 endif()

-option(FSFW_BUILD_UNITTESTS
-       "Build unittest binary in addition to static library" OFF)
+option(FSFW_BUILD_UNITTESTS "Build unittest binary in addition to static library" OFF)
 option(FSFW_BUILD_DOCS "Build documentation with Sphinx and Doxygen" OFF)
 if(FSFW_BUILD_UNITTESTS)
-  option(FSFW_TESTS_GEN_COV "Generate coverage data for unittests" ON)
+    option(FSFW_TESTS_GEN_COV "Generate coverage data for unittests" ON)
 endif()

 option(FSFW_WARNING_SHADOW_LOCAL_GCC "Enable -Wshadow=local warning in GCC" ON)
@@ -128,93 +112,82 @@ option(FSFW_ADD_TMSTORAGE "Compile with tm storage components" OFF)
 # Contrib sources
 option(FSFW_ADD_SGP4_PROPAGATOR "Add SGP4 propagator code" OFF)

+
 set(FSFW_TEST_TGT fsfw-tests)
 set(FSFW_DUMMY_TGT fsfw-dummy)

 add_library(${LIB_FSFW_NAME})

-if(IPO_SUPPORTED AND FSFW_ENABLE_IPO)
-  set_property(TARGET ${LIB_FSFW_NAME} PROPERTY INTERPROCEDURAL_OPTIMIZATION
-                                                TRUE)
-endif()

 if(FSFW_BUILD_UNITTESTS)
-  message(
-    STATUS
-      "${MSG_PREFIX} Building the FSFW unittests in addition to the static library"
-  )
-  # Check whether the user has already installed Catch2 first
-  find_package(Catch2 ${FSFW_CATCH2_LIB_MAJOR_VERSION})
-  # 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"
+    message(STATUS "${MSG_PREFIX} Building the FSFW unittests in addition to the static library")
+    # Check whether the user has already installed Catch2 first
+    find_package(Catch2 ${FSFW_CATCH2_LIB_MAJOR_VERSION})
+    # 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()
+
+    set(FSFW_CONFIG_PATH tests/src/fsfw_tests/unit/testcfg)
+    configure_file(tests/src/fsfw_tests/unit/testcfg/FSFWConfig.h.in FSFWConfig.h)
+    configure_file(tests/src/fsfw_tests/unit/testcfg/TestsConfig.h.in tests/TestsConfig.h)
+
+    project(${FSFW_TEST_TGT} CXX C)
+    add_executable(${FSFW_TEST_TGT})
+
+    if(FSFW_TESTS_GEN_COV)
+        message(STATUS "${MSG_PREFIX} Generating coverage data for the library")
+        message(STATUS "${MSG_PREFIX} Targets linking against ${LIB_FSFW_NAME} "
+            "will be compiled with coverage data as well"
+        )
+        set(CMAKE_BUILD_TYPE "Debug")
+        include(CodeCoverage)
+    endif()
+endif()
+
+message(STATUS "${MSG_PREFIX} Finding and/or providing ETL library")
+
+# Check whether the user has already installed ETL first
+find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} QUIET)
+# Not installed, so use FetchContent to download and provide etl
+if(NOT ${FSFW_ETL_LIB_NAME}_FOUND)
+    message(STATUS
+        "No ETL installation was found with find_package. Installing and providing "
+        "etl with FindPackage"
    )
    include(FetchContent)

    FetchContent_Declare(
-      Catch2
-      GIT_REPOSITORY https://github.com/catchorg/Catch2.git
-      GIT_TAG ${FSFW_CATCH2_LIB_VERSION})
+        ${FSFW_ETL_LIB_NAME}
+        GIT_REPOSITORY https://github.com/ETLCPP/etl
+        GIT_TAG        ${FSFW_ETL_LIB_VERSION}
+    )

-    list(APPEND FSFW_FETCH_CONTENT_TARGETS Catch2)
-  endif()
-
-  set(FSFW_CONFIG_PATH tests/src/fsfw_tests/unit/testcfg)
-  configure_file(tests/src/fsfw_tests/unit/testcfg/FSFWConfig.h.in FSFWConfig.h)
-  configure_file(tests/src/fsfw_tests/unit/testcfg/TestsConfig.h.in
-                 tests/TestsConfig.h)
-
-  project(${FSFW_TEST_TGT} CXX C)
-  add_executable(${FSFW_TEST_TGT})
-  if(IPO_SUPPORTED AND FSFW_ENABLE_IPO)
-    set_property(TARGET ${FSFW_TEST_TGT} PROPERTY INTERPROCEDURAL_OPTIMIZATION
-                                                  TRUE)
-  endif()
-
-  if(FSFW_TESTS_GEN_COV)
-    message(STATUS "${MSG_PREFIX} Generating coverage data for the library")
-    message(STATUS "${MSG_PREFIX} Targets linking against ${LIB_FSFW_NAME} "
-                   "will be compiled with coverage data as well")
-    set(CMAKE_BUILD_TYPE "Debug")
-    include(CodeCoverage)
-  endif()
-endif()
-
-message(STATUS "${MSG_PREFIX} Finding and/or providing etl library with version ${FSFW_ETL_LIB_MAJOR_VERSION}")
-
-# Check whether the user has already installed ETL first
-find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} CONFIG QUIET)
-# Not installed, so use FetchContent to download and provide etl
-if(NOT ${FSFW_ETL_LIB_NAME}_FOUND)
-  message(
-    STATUS
-      "${MSG_PREFIX} No ETL installation was found with find_package. Installing and providing "
-      "etl with FindPackage")
-  include(FetchContent)
-
-  FetchContent_Declare(
-    ${FSFW_ETL_LIB_NAME}
-    GIT_REPOSITORY https://github.com/ETLCPP/etl
-    GIT_TAG ${FSFW_ETL_LIB_VERSION})
-
-  list(APPEND FSFW_FETCH_CONTENT_TARGETS ${FSFW_ETL_LIB_NAME})
+    list(APPEND FSFW_FETCH_CONTENT_TARGETS ${FSFW_ETL_LIB_NAME})
 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 ${FSFW_ETL_LIB_NAME})
-    add_library(${FSFW_ETL_LINK_TARGET} ALIAS ${FSFW_ETL_LIB_NAME})
-  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 "")
-  endif()
+    FetchContent_MakeAvailable(${FSFW_FETCH_CONTENT_TARGETS})
+    if(TARGET ${FSFW_ETL_LIB_NAME})
+        add_library(${FSFW_ETL_LINK_TARGET} ALIAS ${FSFW_ETL_LIB_NAME})
+    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 "")
+    endif()
 endif()

 set(FSFW_CORE_INC_PATH "inc")
@@ -222,242 +195,283 @@ set(FSFW_CORE_INC_PATH "inc")
 set_property(CACHE FSFW_OSAL PROPERTY STRINGS host linux rtems freertos)

 # For configure files
-target_include_directories(${LIB_FSFW_NAME} PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
-target_include_directories(${LIB_FSFW_NAME}
-                           INTERFACE ${CMAKE_CURRENT_BINARY_DIR})
+target_include_directories(${LIB_FSFW_NAME} PRIVATE
+    ${CMAKE_CURRENT_BINARY_DIR}
+)
+target_include_directories(${LIB_FSFW_NAME} INTERFACE
+    ${CMAKE_CURRENT_BINARY_DIR}
+)

 # Backwards comptability
 if(OS_FSFW AND NOT FSFW_OSAL)
-  message(
-    WARNING
-      "${MSG_PREFIX} Please pass the FSFW OSAL as FSFW_OSAL instead of OS_FSFW")
-  set(FSFW_OSAL OS_FSFW)
+    message(WARNING "${MSG_PREFIX} Please pass the FSFW OSAL as FSFW_OSAL instead of OS_FSFW")
+    set(FSFW_OSAL OS_FSFW)
 endif()

 if(NOT FSFW_OSAL)
-  message(STATUS "No OS for FSFW via FSFW_OSAL set. Assuming host OS")
-  # Assume host OS and autodetermine from OS_FSFW
-  if(UNIX)
-    set(FSFW_OSAL
-        "linux"
-        CACHE STRING "OS abstraction layer used in the FSFW")
-  elseif(WIN32)
-    set(FSFW_OSAL
-        "host"
-        CACHE STRING "OS abstraction layer used in the FSFW")
-  endif()
+	message(STATUS "${MSG_PREFIX} No OS for FSFW via FSFW_OSAL set. Assuming host OS")
+	# Assume host OS and autodetermine from OS_FSFW
+	if(UNIX)
+		set(FSFW_OSAL  "linux" 
+			CACHE STRING 
+			"OS abstraction layer used in the FSFW"
+		)
+	elseif(WIN32)
+		set(FSFW_OSAL  "host" 
+			CACHE STRING "OS abstraction layer used in the FSFW"
+		)
+	endif()
+
 endif()

 set(FSFW_OSAL_DEFINITION FSFW_OSAL_HOST)

 if(FSFW_OSAL MATCHES host)
-  set(FSFW_OS_NAME "Host")
-  set(FSFW_OSAL_HOST ON)
+    set(FSFW_OS_NAME "Host")
+    set(FSFW_OSAL_HOST ON)
 elseif(FSFW_OSAL MATCHES linux)
-  set(FSFW_OS_NAME "Linux")
-  set(FSFW_OSAL_LINUX ON)
+    set(FSFW_OS_NAME "Linux")
+    set(FSFW_OSAL_LINUX ON)
 elseif(FSFW_OSAL MATCHES freertos)
-  set(FSFW_OS_NAME "FreeRTOS")
-  set(FSFW_OSAL_FREERTOS ON)
-  target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${LIB_OS_NAME})
+    set(FSFW_OS_NAME "FreeRTOS")
+    set(FSFW_OSAL_FREERTOS ON)
+    target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+        ${LIB_OS_NAME}
+    )
 elseif(FSFW_OSAL STREQUAL rtems)
-  set(FSFW_OS_NAME "RTEMS")
-  set(FSFW_OSAL_RTEMS ON)
+    set(FSFW_OS_NAME "RTEMS")
+    set(FSFW_OSAL_RTEMS ON)
 else()
-  message(
-    WARNING
-      "${MSG_PREFIX} Invalid operating system for FSFW specified! Setting to host.."
-  )
-  set(FSFW_OS_NAME "Host")
-  set(OS_FSFW "host")
+    message(WARNING
+        "${MSG_PREFIX} Invalid operating system for FSFW specified! Setting to host.."
+    )
+    set(FSFW_OS_NAME "Host")
+    set(OS_FSFW "host")
 endif()

 configure_file(src/fsfw/FSFW.h.in fsfw/FSFW.h)
-configure_file(src/fsfw/FSFWVersion.h.in fsfw/FSFWVersion.h)
+# configure_file(src/fsfw/FSFWVersion.h.in fsfw/FSFWVersion.h)

-message(
-  STATUS "${MSG_PREFIX} Compiling FSFW for the ${FSFW_OS_NAME} operating system"
-)
+message(STATUS "${MSG_PREFIX} Compiling FSFW for the ${FSFW_OS_NAME} operating system")

 add_subdirectory(src)
 add_subdirectory(tests)
 if(FSFW_ADD_HAL)
-  add_subdirectory(hal)
+    add_subdirectory(hal)
 endif()
 add_subdirectory(contrib)
 if(FSFW_BUILD_DOCS)
-  add_subdirectory(docs)
+    add_subdirectory(docs)
 endif()

 if(FSFW_BUILD_UNITTESTS)
-  if(FSFW_TESTS_GEN_COV)
-    if(CMAKE_COMPILER_IS_GNUCXX)
-      include(CodeCoverage)
+    if(FSFW_TESTS_GEN_COV)
+        if(CMAKE_COMPILER_IS_GNUCXX)
+            include(CodeCoverage)

-      # Remove quotes.
-      separate_arguments(COVERAGE_COMPILER_FLAGS NATIVE_COMMAND
-                         "${COVERAGE_COMPILER_FLAGS}")
+            # Remove quotes.
+            separate_arguments(COVERAGE_COMPILER_FLAGS
+                NATIVE_COMMAND "${COVERAGE_COMPILER_FLAGS}"
+            )

-      # Add compile options manually, we don't want coverage for Catch2
-      target_compile_options(${FSFW_TEST_TGT}
-                             PRIVATE "${COVERAGE_COMPILER_FLAGS}")
-      target_compile_options(${LIB_FSFW_NAME}
-                             PRIVATE "${COVERAGE_COMPILER_FLAGS}")
+            # Add compile options manually, we don't want coverage for Catch2
+            target_compile_options(${FSFW_TEST_TGT} PRIVATE
+                "${COVERAGE_COMPILER_FLAGS}"
+            )
+            target_compile_options(${LIB_FSFW_NAME} PRIVATE
+                "${COVERAGE_COMPILER_FLAGS}"
+            )

-      # Exclude directories here
-      if(WIN32)
-        set(GCOVR_ADDITIONAL_ARGS "--exclude-throw-branches"
-                                  "--exclude-unreachable-branches")
-        set(COVERAGE_EXCLUDES "/c/msys64/mingw64/*" "*/fsfw_hal/*")
-      elseif(UNIX)
-        set(COVERAGE_EXCLUDES
-            "/usr/include/*"
-            "/usr/bin/*"
-            "Catch2/*"
-            "/usr/local/include/*"
-            "*/fsfw_tests/*"
-            "*/catch2-src/*"
-            "*/fsfw_hal/*")
-      endif()
+            # Exclude directories here
+            if(WIN32)
+                set(GCOVR_ADDITIONAL_ARGS
+                    "--exclude-throw-branches"
+                    "--exclude-unreachable-branches"
+                )
+                set(COVERAGE_EXCLUDES
+                    "/c/msys64/mingw64/*" "*/fsfw_hal/*"
+                )
+            elseif(UNIX)
+                set(COVERAGE_EXCLUDES
+                    "/usr/include/*" "/usr/bin/*" "Catch2/*"
+                    "/usr/local/include/*" "*/fsfw_tests/*"
+                    "*/catch2-src/*" "*/fsfw_hal/*"
+                )
+            endif()

-      target_link_options(${FSFW_TEST_TGT} PRIVATE -fprofile-arcs
-                          -ftest-coverage)
-      target_link_options(${LIB_FSFW_NAME} PRIVATE -fprofile-arcs
-                          -ftest-coverage)
-      # Need to specify this as an interface, otherwise there will the compile
-      # issues
-      target_link_options(${LIB_FSFW_NAME} INTERFACE -fprofile-arcs
-                          -ftest-coverage)
+            target_link_options(${FSFW_TEST_TGT} PRIVATE
+                -fprofile-arcs
+                -ftest-coverage
+            )
+            target_link_options(${LIB_FSFW_NAME} PRIVATE
+                -fprofile-arcs
+                -ftest-coverage
+            )
+            # Need to specify this as an interface, otherwise there will the compile issues
+            target_link_options(${LIB_FSFW_NAME} INTERFACE
+                -fprofile-arcs
+                -ftest-coverage
+            )

-      if(WIN32)
-        setup_target_for_coverage_gcovr_html(
-          NAME ${FSFW_TEST_TGT}_coverage EXECUTABLE ${FSFW_TEST_TGT}
-          DEPENDENCIES ${FSFW_TEST_TGT})
-      else()
-        setup_target_for_coverage_lcov(
-          NAME ${FSFW_TEST_TGT}_coverage EXECUTABLE ${FSFW_TEST_TGT}
-          DEPENDENCIES ${FSFW_TEST_TGT})
-      endif()
+            if(WIN32)
+                setup_target_for_coverage_gcovr_html(
+                    NAME ${FSFW_TEST_TGT}_coverage
+                    EXECUTABLE ${FSFW_TEST_TGT}
+                    DEPENDENCIES ${FSFW_TEST_TGT}
+                )
+            else()
+                setup_target_for_coverage_lcov(
+                    NAME ${FSFW_TEST_TGT}_coverage
+                    EXECUTABLE ${FSFW_TEST_TGT}
+                    DEPENDENCIES ${FSFW_TEST_TGT}
+                )
+            endif()
+        endif()
    endif()
-  endif()
-  target_link_libraries(${FSFW_TEST_TGT} PRIVATE Catch2::Catch2
-                                                 ${LIB_FSFW_NAME})
+    target_link_libraries(${FSFW_TEST_TGT} PRIVATE Catch2::Catch2 ${LIB_FSFW_NAME})
 endif()

-# The project CMakeLists file has to set the FSFW_CONFIG_PATH and add it. If
-# this is not given, we include the default configuration and emit a warning.
+# The project CMakeLists file has to set the FSFW_CONFIG_PATH and add it.
+# If this is not given, we include the default configuration and emit a warning.
 if(NOT FSFW_CONFIG_PATH)
-  set(DEF_CONF_PATH misc/defaultcfg/fsfwconfig)
-  if(NOT FSFW_BUILD_DOCS)
-    message(
-      WARNING
-        "${MSG_PREFIX} Flight Software Framework configuration path not set")
-    message(
-      WARNING
-        "${MSG_PREFIX} Setting default configuration from ${DEF_CONF_PATH} ..")
-  endif()
-  add_subdirectory(${DEF_CONF_PATH})
-  set(FSFW_CONFIG_PATH ${DEF_CONF_PATH})
+    set(DEF_CONF_PATH misc/defaultcfg/fsfwconfig)
+    if(NOT FSFW_BUILD_DOCS)
+        message(WARNING "${MSG_PREFIX} Flight Software Framework configuration path not set")
+        message(WARNING "${MSG_PREFIX} Setting default configuration from ${DEF_CONF_PATH} ..")
+    endif()
+    add_subdirectory(${DEF_CONF_PATH})
+    set(FSFW_CONFIG_PATH ${DEF_CONF_PATH})
 endif()

-# FSFW might be part of a possibly complicated folder structure, so we extract
-# the absolute path of the fsfwconfig folder.
+# FSFW might be part of a possibly complicated folder structure, so we 
+# extract the absolute path of the fsfwconfig folder.
 if(IS_ABSOLUTE ${FSFW_CONFIG_PATH})
-  set(FSFW_CONFIG_PATH_ABSOLUTE ${FSFW_CONFIG_PATH})
+	set(FSFW_CONFIG_PATH_ABSOLUTE ${FSFW_CONFIG_PATH})
 else()
-  get_filename_component(FSFW_CONFIG_PATH_ABSOLUTE ${FSFW_CONFIG_PATH} REALPATH
-                         BASE_DIR ${CMAKE_SOURCE_DIR})
+	get_filename_component(FSFW_CONFIG_PATH_ABSOLUTE
+		${FSFW_CONFIG_PATH} REALPATH BASE_DIR ${CMAKE_SOURCE_DIR}
+	)
 endif()

 foreach(INCLUDE_PATH ${FSFW_ADDITIONAL_INC_PATHS})
-  if(IS_ABSOLUTE ${INCLUDE_PATH})
-    set(CURR_ABS_INC_PATH "${INCLUDE_PATH}")
-  else()
-    get_filename_component(CURR_ABS_INC_PATH ${INCLUDE_PATH} REALPATH BASE_DIR
-                           ${CMAKE_SOURCE_DIR})
-  endif()
+    if(IS_ABSOLUTE ${INCLUDE_PATH})
+        set(CURR_ABS_INC_PATH "${INCLUDE_PATH}")
+    else()
+        get_filename_component(CURR_ABS_INC_PATH
+            ${INCLUDE_PATH} REALPATH BASE_DIR ${CMAKE_SOURCE_DIR})
+    endif()

-  if(CMAKE_VERBOSE)
-    message(STATUS "FSFW include path: ${CURR_ABS_INC_PATH}")
-  endif()
+    if(CMAKE_VERBOSE)
+        message(STATUS "FSFW include path: ${CURR_ABS_INC_PATH}")
+    endif()

-  list(APPEND FSFW_ADD_INC_PATHS_ABS ${CURR_ABS_INC_PATH})
+    list(APPEND FSFW_ADD_INC_PATHS_ABS ${CURR_ABS_INC_PATH})
 endforeach()

 if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-  if(NOT DEFINED FSFW_WARNING_FLAGS)
-    set(FSFW_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
-    )
-  endif()
+    if(NOT DEFINED FSFW_WARNING_FLAGS)
+	   set(FSFW_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
+        )
+    endif()

-  if(FSFW_GENERATE_SECTIONS)
-    target_compile_options(${LIB_FSFW_NAME} PRIVATE "-ffunction-sections"
-                                                    "-fdata-sections")
-  endif()
-
-  if(FSFW_REMOVE_UNUSED_CODE)
-    target_link_options(${LIB_FSFW_NAME} PRIVATE "Wl,--gc-sections")
-  endif()
-
-  if(FSFW_WARNING_SHADOW_LOCAL_GCC)
-    list(APPEND WARNING_FLAGS "-Wshadow=local")
-  endif()
+    if(FSFW_GENERATE_SECTIONS)
+        target_compile_options(${LIB_FSFW_NAME} PRIVATE
+            "-ffunction-sections"
+            "-fdata-sections"
+        )
+    endif()

+    if(FSFW_REMOVE_UNUSED_CODE)
+        target_link_options(${LIB_FSFW_NAME} PRIVATE
+            "Wl,--gc-sections"
+        )
+    endif()
+  
+    if(FSFW_WARNING_SHADOW_LOCAL_GCC)
+        list(APPEND WARNING_FLAGS "-Wshadow=local")
+    endif()
+	
 endif()

 if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-  set(COMPILER_FLAGS "/permissive-")
+	set(COMPILER_FLAGS "/permissive-")
 endif()

 # Required include paths to compile the FSFW
-target_include_directories(
-  ${LIB_FSFW_NAME} INTERFACE ${CMAKE_SOURCE_DIR} ${FSFW_CONFIG_PATH_ABSOLUTE}
-                             ${FSFW_CORE_INC_PATH} ${FSFW_ADD_INC_PATHS_ABS})
+target_include_directories(${LIB_FSFW_NAME} INTERFACE 
+	${CMAKE_SOURCE_DIR}
+	${FSFW_CONFIG_PATH_ABSOLUTE}
+	${FSFW_CORE_INC_PATH}
+	${FSFW_ADD_INC_PATHS_ABS}
+)

-# Includes path required to compile FSFW itself as well We assume that the
-# fsfwconfig folder uses include relative to the project root here!
-target_include_directories(
-  ${LIB_FSFW_NAME} PRIVATE ${CMAKE_SOURCE_DIR} ${FSFW_CONFIG_PATH_ABSOLUTE}
-                           ${FSFW_CORE_INC_PATH} ${FSFW_ADD_INC_PATHS_ABS})
+# Includes path required to compile FSFW itself as well
+# We assume that the fsfwconfig folder uses include relative to the project
+# root here!
+target_include_directories(${LIB_FSFW_NAME} PRIVATE 
+	${CMAKE_SOURCE_DIR}
+	${FSFW_CONFIG_PATH_ABSOLUTE}
+	${FSFW_CORE_INC_PATH}
+	${FSFW_ADD_INC_PATHS_ABS}
+)

-target_compile_options(${LIB_FSFW_NAME} PRIVATE ${FSFW_WARNING_FLAGS}
-                                                ${COMPILER_FLAGS})
+target_compile_options(${LIB_FSFW_NAME} PRIVATE 
+	${FSFW_WARNING_FLAGS}
+	${COMPILER_FLAGS}
+)

-target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${FSFW_ETL_LINK_TARGET}
-                                               ${FSFW_ADDITIONAL_LINK_LIBS})
+target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+    ${FSFW_ETL_LINK_TARGET}
+    ${FSFW_ADDITIONAL_LINK_LIBS}
+)

-string(
-  CONCAT
-    POST_BUILD_COMMENT
+string(CONCAT POST_BUILD_COMMENT
    "######################################################################\n"
    "Built FSFW v${FSFW_VERSION}.${FSFW_SUBVERSION}.${FSFW_REVISION}, "
    "Target OSAL: ${FSFW_OS_NAME}\n"
-    "######################################################################\n")
+    "######################################################################\n"
+)

 add_custom_command(
-  TARGET ${LIB_FSFW_NAME}
-  POST_BUILD
-  COMMENT ${POST_BUILD_COMMENT})
+   TARGET ${LIB_FSFW_NAME}
+   POST_BUILD
+   COMMENT ${POST_BUILD_COMMENT}
+)
+
+# Add a custom command that produces version.cpp, plus
+# a dummy output that's not actually produced, in order
+# to force version.cmake to always be re-run before the build
+add_custom_command(
+    TARGET ${LIB_FSFW_NAME}
+    COMMAND ${CMAKE_COMMAND} -DVERSION_DIR=${FSFW_SOURCES_DIR}
+            -DVERSION_MAJOR=${FSFW_VERSION_MAJOR}
+            -DVERSION_MINOR=${FSFW_VERSION_MINOR}
+            -DVERSION_REVISION=${FSFW_VERSION_REVISION}
+            -DVERSION_VCS_INFO=${FSFW_VERSION_VCS_INFO}
+            -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/version.cmake
+    BYPRODUCTS ${FSFW_SOURCES_DIR}/versionAutogen.cpp
+    COMMENT ""
+)
--- a/FSFWVersion.h.in
+++ b/FSFWVersion.h.in
--- a/cmake/FsfwHelpers.cmake
+++ b/cmake/FsfwHelpers.cmake
@@ -8,6 +8,7 @@
 function(determine_version_with_git)
    include(GetGitRevisionDescription)
    git_describe(VERSION ${ARGN})
+    get_git_head_revision(GIT_BRANCH HASH_VAR)
    string(FIND ${VERSION} "." VALID_VERSION)
    if(VALID_VERSION EQUAL -1)
        message(WARNING "Version string ${VERSION} retrieved with git describe is invalid")
@@ -18,11 +19,14 @@ function(determine_version_with_git)
    string(REGEX REPLACE "^v[0-9]+\\.([0-9]+).*" "\\1" _VERSION_MINOR "${VERSION}")
    string(REGEX REPLACE "^v[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" _VERSION_PATCH "${VERSION}")
    string(REGEX REPLACE "^v[0-9]+\\.[0-9]+\\.[0-9]+-(.*)" "\\1" VERSION_SHA1 "${VERSION}")
+    string(STRIP "${GIT_BRANCH}" GIT_BRANCH)
    set(GIT_INFO ${VERSION})
    list(APPEND GIT_INFO ${_VERSION_MAJOR})
    list(APPEND GIT_INFO ${_VERSION_MINOR})
    list(APPEND GIT_INFO ${_VERSION_PATCH})
    list(APPEND GIT_INFO ${VERSION_SHA1})
    set(GIT_INFO ${GIT_INFO} PARENT_SCOPE)
+    set(GIT_BRANCH ${GIT_BRANCH} PARENT_SCOPE)
+    message(STATUS "${MSG_PREFIX} git branch ${GIT_BRANCH}")
    message(STATUS "${MSG_PREFIX} Set git version info into GIT_INFO from the git tag ${VERSION}")
 endfunction()
--- a/cmake/version.cmake
+++ b/cmake/version.cmake
@@ -0,0 +1,38 @@
+if(NOT DEFINED VERSION_MAJOR)
+    message(WARNING "version.cmake | No VERSION_MAJOR variable passed. Setting to 0")
+    set(VERSION_MAJOR 0)
+endif()
+if(NOT DEFINED VERSION_MINOR)
+    message(WARNING "version.cmake | No VERSION_MINOR variable passed. Setting to 0")
+    set(VERSION_MINOR 0)
+endif()
+if(NOT DEFINED VERSION_REVISION)
+    message(WARNING "version.cmake | No VERSION_REVISION variable passed. Setting to 0")
+    set(VERSION_REVISION 0)
+endif()
+if(NOT DEFINED VERSION_VCS_INFO)
+    set(VERSION_VCS_INFO "")
+endif()
+
+set(VERSION_TO_SET "#include \"version.h\"
+
+namespace fsfw {
+
+const int FSFW_VERSION_MAJOR = ${VERSION_MAJOR};
+const int FSFW_VERSION_MINOR = ${VERSION_MINOR};
+const int FSFW_VERSION_REVISION = ${VERSION_MINOR};
+const char FSFW_VCS_INFO[] = \"${VERSION_VCS_INFO}\";
+
+};
+")
+
+if(EXISTS ${VERSION_DIR}/versionAutogen.cpp)
+    file(READ ${VERSION_DIR}/versionAutogen.cpp OLD_VERSION)
+else()
+    set(OLD_VERSION "")
+endif()
+
+if (NOT "${VERSION_TO_SET}" STREQUAL "${OLD_VERSION}")
+    message(STATUS "Updating versionAutogen.cpp file")
+    file(WRITE ${VERSION_DIR}/versionAutogen.cpp "${VERSION_TO_SET}")
+endif()
--- a/hal/src/fsfw_hal/common/gpio/GpioIF.h
+++ b/hal/src/fsfw_hal/common/gpio/GpioIF.h
@@ -46,9 +46,9 @@ class GpioIF : public HasReturnvaluesIF {
   *          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 reference
+   * @param gpioState State of GPIO will be written to this pointer.
   */
-  virtual ReturnValue_t readGpio(gpioId_t gpioId, gpio::Levels& gpioState) = 0;
+  virtual ReturnValue_t readGpio(gpioId_t gpioId, int* gpioState) = 0;
 };

 #endif /* COMMON_GPIO_GPIOIF_H_ */
--- a/hal/src/fsfw_hal/common/gpio/gpioDefinitions.h
+++ b/hal/src/fsfw_hal/common/gpio/gpioDefinitions.h
@@ -9,7 +9,7 @@ using gpioId_t = uint16_t;

 namespace gpio {

-enum class Levels : int { LOW = 0, HIGH = 1, FAILED = -1, NONE = 99 };
+enum class Levels : int { LOW = 0, HIGH = 1, NONE = 99 };

 enum class Direction : int { IN = 0, OUT = 1 };

--- a/hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp
+++ b/hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp
@@ -375,16 +375,13 @@ float MgmLIS3MDLHandler::getSensitivityFactor(MGMLIS3MDL::Sensitivies sens) {

 ReturnValue_t MgmLIS3MDLHandler::enableTemperatureSensor(const uint8_t *commandData,
                                                         size_t commandDataLen) {
-  if (commandData == nullptr) {
-    return INVALID_COMMAND_PARAMETER;
-  }
  triggerEvent(CHANGE_OF_SETUP_PARAMETER);
  uint32_t size = 2;
  commandBuffer[0] = writeCommand(MGMLIS3MDL::CTRL_REG1);
  if (commandDataLen > 1) {
    return INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS;
  }
-  switch (commandData[0]) {
+  switch (*commandData) {
    case (MGMLIS3MDL::ON): {
      commandBuffer[1] = registers[0] | (1 << 7);
      break;
--- a/hal/src/fsfw_hal/linux/CommandExecutor.cpp
+++ b/hal/src/fsfw_hal/linux/CommandExecutor.cpp
@@ -32,8 +32,6 @@ ReturnValue_t CommandExecutor::execute() {
  } else if (state == States::PENDING) {
    return COMMAND_PENDING;
  }
-  // Reset data in read vector
-  std::memset(readVec.data(), 0, readVec.size());
  currentCmdFile = popen(currentCmd.c_str(), "r");
  if (currentCmdFile == nullptr) {
    lastError = errno;
@@ -207,5 +205,3 @@ ReturnValue_t CommandExecutor::executeBlocking() {
  }
  return HasReturnvaluesIF::RETURN_OK;
 }
-
-const std::vector<char>& CommandExecutor::getReadVector() const { return readVec; }
--- a/hal/src/fsfw_hal/linux/CommandExecutor.h
+++ b/hal/src/fsfw_hal/linux/CommandExecutor.h
@@ -109,8 +109,6 @@ class CommandExecutor {
   */
  void reset();

-  const std::vector<char>& getReadVector() const;
-
 private:
  std::string currentCmd;
  bool blocking = true;
--- a/hal/src/fsfw_hal/linux/UnixFileGuard.cpp
+++ b/hal/src/fsfw_hal/linux/UnixFileGuard.cpp
@@ -6,7 +6,7 @@
 #include "fsfw/FSFW.h"
 #include "fsfw/serviceinterface.h"

-UnixFileGuard::UnixFileGuard(const std::string& device, int* fileDescriptor, int flags,
+UnixFileGuard::UnixFileGuard(std::string device, int* fileDescriptor, int flags,
                             std::string diagnosticPrefix)
    : fileDescriptor(fileDescriptor) {
  if (fileDescriptor == nullptr) {
--- a/hal/src/fsfw_hal/linux/UnixFileGuard.h
+++ b/hal/src/fsfw_hal/linux/UnixFileGuard.h
@@ -15,7 +15,7 @@ class UnixFileGuard {

  static constexpr ReturnValue_t OPEN_FILE_FAILED = 1;

-  UnixFileGuard(const std::string& device, int* fileDescriptor, int flags,
+  UnixFileGuard(std::string device, int* fileDescriptor, int flags,
                std::string diagnosticPrefix = "");

  virtual ~UnixFileGuard();
--- a/hal/src/fsfw_hal/linux/gpio/Gpio.h
+++ b/hal/src/fsfw_hal/linux/gpio/Gpio.h
@@ -1,27 +0,0 @@
-#ifndef FSFW_HAL_SRC_FSFW_HAL_LINUX_GPIO_GPIO_H_
-#define FSFW_HAL_SRC_FSFW_HAL_LINUX_GPIO_GPIO_H_
-
-#include "fsfw_hal/common/gpio/GpioIF.h"
-#include "fsfw_hal/common/gpio/gpioDefinitions.h"
-
-/**
- * @brief   Additional abstraction layer for handling GPIOs.
- *
- * @author  J. Meier
- */
-class Gpio {
- public:
-  Gpio(gpioId_t gpioId, GpioIF* gpioIF) : gpioId(gpioId), gpioIF(gpioIF) {
-    if (gpioIF == nullptr) {
-      sif::error << "Gpio::Gpio: Invalid GpioIF" << std::endl;
-    }
-  }
-  ReturnValue_t pullHigh() { return gpioIF->pullHigh(gpioId); }
-  ReturnValue_t pullLow() { return gpioIF->pullLow(gpioId); }
-
- private:
-  gpioId_t gpioId = gpio::NO_GPIO;
-  GpioIF* gpioIF = nullptr;
-};
-
-#endif /* FSFW_HAL_SRC_FSFW_HAL_LINUX_GPIO_GPIO_H_ */
--- a/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.cpp
+++ b/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.cpp
@@ -20,9 +20,7 @@ LinuxLibgpioIF::~LinuxLibgpioIF() {
 ReturnValue_t LinuxLibgpioIF::addGpios(GpioCookie* gpioCookie) {
  ReturnValue_t result;
  if (gpioCookie == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::error << "LinuxLibgpioIF::addGpios: Invalid cookie" << std::endl;
-#endif
    return RETURN_FAILED;
  }

@@ -98,10 +96,8 @@ ReturnValue_t LinuxLibgpioIF::configureGpioByLabel(gpioId_t gpioId,
  std::string& label = gpioByLabel.label;
  struct gpiod_chip* chip = gpiod_chip_open_by_label(label.c_str());
  if (chip == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::warning << "LinuxLibgpioIF::configureGpioByLabel: Failed to open gpio from gpio "
                 << "group with label " << label << ". Gpio ID: " << gpioId << std::endl;
-#endif
    return RETURN_FAILED;
  }
  std::string failOutput = "label: " + label;
@@ -112,10 +108,8 @@ ReturnValue_t LinuxLibgpioIF::configureGpioByChip(gpioId_t gpioId, GpiodRegularB
  std::string& chipname = gpioByChip.chipname;
  struct gpiod_chip* chip = gpiod_chip_open_by_name(chipname.c_str());
  if (chip == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::warning << "LinuxLibgpioIF::configureGpioByChip: Failed to open chip " << chipname
                 << ". Gpio ID: " << gpioId << std::endl;
-#endif
    return RETURN_FAILED;
  }
  std::string failOutput = "chipname: " + chipname;
@@ -139,10 +133,8 @@ ReturnValue_t LinuxLibgpioIF::configureGpioByLineName(gpioId_t gpioId,

  struct gpiod_chip* chip = gpiod_chip_open_by_name(chipname);
  if (chip == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::warning << "LinuxLibgpioIF::configureGpioByLineName: Failed to open chip " << chipname
                 << ". <Gpio ID: " << gpioId << std::endl;
-#endif
    return RETURN_FAILED;
  }
  std::string failOutput = "line name: " + lineName;
@@ -161,12 +153,10 @@ ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, struct gpiod
  lineNum = regularGpio.lineNum;
  lineHandle = gpiod_chip_get_line(chip, lineNum);
  if (!lineHandle) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::warning << "LinuxLibgpioIF::configureRegularGpio: Failed to open line " << std::endl;
    sif::warning << "GPIO ID: " << gpioId << ", line number: " << lineNum << ", " << failOutput
                 << std::endl;
    sif::warning << "Check if Linux GPIO configuration has changed. " << std::endl;
-#endif
    gpiod_chip_close(chip);
    return RETURN_FAILED;
  }
@@ -185,9 +175,7 @@ ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, struct gpiod
      break;
    }
    default: {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
      sif::error << "LinuxLibgpioIF::configureGpios: Invalid direction specified" << std::endl;
-#endif
      return GPIO_INVALID_INSTANCE;
    }

@@ -216,9 +204,7 @@ ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, struct gpiod
 ReturnValue_t LinuxLibgpioIF::pullHigh(gpioId_t gpioId) {
  gpioMapIter = gpioMap.find(gpioId);
  if (gpioMapIter == gpioMap.end()) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::warning << "LinuxLibgpioIF::pullHigh: Unknown GPIO ID " << gpioId << std::endl;
-#endif
    return UNKNOWN_GPIO_ID;
  }

@@ -294,7 +280,7 @@ ReturnValue_t LinuxLibgpioIF::driveGpio(gpioId_t gpioId, GpiodRegularBase& regul
  return RETURN_OK;
 }

-ReturnValue_t LinuxLibgpioIF::readGpio(gpioId_t gpioId, gpio::Levels& gpioState) {
+ReturnValue_t LinuxLibgpioIF::readGpio(gpioId_t gpioId, int* gpioState) {
  gpioMapIter = gpioMap.find(gpioId);
  if (gpioMapIter == gpioMap.end()) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -313,10 +299,7 @@ ReturnValue_t LinuxLibgpioIF::readGpio(gpioId_t gpioId, gpio::Levels& gpioState)
    if (regularGpio == nullptr) {
      return GPIO_TYPE_FAILURE;
    }
-    gpioState = static_cast<gpio::Levels>(gpiod_line_get_value(regularGpio->lineHandle));
-    if (gpioState == gpio::Levels::FAILED) {
-      return GPIO_GET_VALUE_FAILED;
-    }
+    *gpioState = gpiod_line_get_value(regularGpio->lineHandle);
  } else {
    auto gpioCallback = dynamic_cast<GpioCallback*>(gpioMapIter->second);
    if (gpioCallback->callback == nullptr) {
--- a/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+++ b/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
@@ -31,16 +31,14 @@ class LinuxLibgpioIF : public GpioIF, public SystemObject {
      HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 5);
  static constexpr ReturnValue_t GPIO_INIT_FAILED =
      HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 6);
-  // Will be returned if getting the line value failed. Error type will be set to errno in this case
-  static constexpr ReturnValue_t GPIO_GET_VALUE_FAILED =
-      HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 7);
+
  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, gpio::Levels& gpioState) override;
+  ReturnValue_t readGpio(gpioId_t gpioId, int* gpioState) override;

 private:
  static const size_t MAX_CHIPNAME_LENGTH = 11;
--- a/hal/src/fsfw_hal/linux/i2c/I2cComIF.cpp
+++ b/hal/src/fsfw_hal/linux/i2c/I2cComIF.cpp
@@ -170,20 +170,18 @@ ReturnValue_t I2cComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLe

  int readLen = read(fd, replyBuffer, requestLen);
  if (readLen != static_cast<int>(requestLen)) {
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    if (readLen < 0) {
-      sif::warning << "I2cComIF::requestReceiveMessage: Reading from I2C "
-                   << "device failed with error code " << errno << " | " << strerror(errno)
-                   << std::endl;
-    } else {
-      sif::warning << "I2cComIF::requestReceiveMessage: Read only " << readLen << " from "
-                   << requestLen << " bytes" << std::endl;
-    }
-#else
-#endif
+#if FSFW_VERBOSE_LEVEL >= 1 and FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "I2cComIF::requestReceiveMessage: Reading from I2C "
+               << "device failed with error code " << errno << ". Description"
+               << " of error: " << strerror(errno) << std::endl;
+    sif::error << "I2cComIF::requestReceiveMessage: Read only " << readLen << " from " << requestLen
+               << " bytes" << std::endl;
 #endif
    i2cDeviceMapIter->second.replyLen = 0;
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::debug << "I2cComIF::requestReceiveMessage: Read " << readLen << " of " << requestLen
+               << " bytes" << std::endl;
+#endif
    return HasReturnvaluesIF::RETURN_FAILED;
  }

--- a/hal/src/fsfw_hal/linux/spi/ManualCsLockGuard.h
+++ b/hal/src/fsfw_hal/linux/spi/ManualCsLockGuard.h
@@ -1,43 +0,0 @@
-#pragma once
-
-#include "fsfw/ipc/MutexIF.h"
-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
-#include "fsfw_hal/common/gpio/GpioIF.h"
-
-class ManualCsLockWrapper : public HasReturnvaluesIF {
- public:
-  ManualCsLockWrapper(MutexIF* lock, GpioIF* gpioIF, SpiCookie* cookie,
-                      MutexIF::TimeoutType type = MutexIF::TimeoutType::BLOCKING,
-                      uint32_t timeoutMs = 0)
-      : lock(lock), gpioIF(gpioIF), cookie(cookie), type(type), timeoutMs(timeoutMs) {
-    if (cookie == nullptr) {
-      // TODO: Error? Or maybe throw exception..
-      return;
-    }
-    cookie->setCsLockManual(true);
-    lockResult = lock->lockMutex(type, timeoutMs);
-    if (lockResult != RETURN_OK) {
-      return;
-    }
-    gpioResult = gpioIF->pullLow(cookie->getChipSelectPin());
-  }
-
-  ~ManualCsLockWrapper() {
-    if (gpioResult == RETURN_OK) {
-      gpioIF->pullHigh(cookie->getChipSelectPin());
-    }
-    cookie->setCsLockManual(false);
-    if (lockResult == RETURN_OK) {
-      lock->unlockMutex();
-    }
-  }
-  ReturnValue_t lockResult;
-  ReturnValue_t gpioResult;
-
- private:
-  MutexIF* lock;
-  GpioIF* gpioIF;
-  SpiCookie* cookie;
-  MutexIF::TimeoutType type;
-  uint32_t timeoutMs = 0;
-};
--- a/hal/src/fsfw_hal/linux/spi/SpiComIF.cpp
+++ b/hal/src/fsfw_hal/linux/spi/SpiComIF.cpp
@@ -15,8 +15,8 @@
 #include "fsfw_hal/linux/spi/SpiCookie.h"
 #include "fsfw_hal/linux/utility.h"

-SpiComIF::SpiComIF(object_id_t objectId, std::string devname, GpioIF* gpioComIF)
-    : SystemObject(objectId), gpioComIF(gpioComIF), dev(std::move(devname)) {
+SpiComIF::SpiComIF(object_id_t objectId, GpioIF* gpioComIF)
+    : SystemObject(objectId), gpioComIF(gpioComIF) {
  if (gpioComIF == nullptr) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -27,7 +27,7 @@ SpiComIF::SpiComIF(object_id_t objectId, std::string devname, GpioIF* gpioComIF)
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
  }

-  csMutex = MutexFactory::instance()->createMutex();
+  spiMutex = MutexFactory::instance()->createMutex();
 }

 ReturnValue_t SpiComIF::initializeInterface(CookieIF* cookie) {
@@ -85,7 +85,8 @@ ReturnValue_t SpiComIF::initializeInterface(CookieIF* cookie) {
  spiCookie->getSpiParameters(spiMode, spiSpeed, &params);

  int fileDescriptor = 0;
-  UnixFileGuard fileHelper(dev, &fileDescriptor, O_RDWR, "SpiComIF::initializeInterface");
+  UnixFileGuard fileHelper(spiCookie->getSpiDevice(), &fileDescriptor, O_RDWR,
+                           "SpiComIF::initializeInterface");
  if (fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
    return fileHelper.getOpenResult();
  }
@@ -181,7 +182,8 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
  int retval = 0;
  /* Prepare transfer */
  int fileDescriptor = 0;
-  UnixFileGuard fileHelper(dev, &fileDescriptor, O_RDWR, "SpiComIF::sendMessage");
+  std::string device = spiCookie->getSpiDevice();
+  UnixFileGuard fileHelper(device, &fileDescriptor, O_RDWR, "SpiComIF::sendMessage");
  if (fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
    return OPENING_FILE_FAILED;
  }
@@ -194,27 +196,20 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const

  bool fullDuplex = spiCookie->isFullDuplex();
  gpioId_t gpioId = spiCookie->getChipSelectPin();
-  bool csLockManual = spiCookie->getCsLockManual();

-  MutexIF::TimeoutType csType;
-  dur_millis_t csTimeout = 0;
-  // Pull SPI CS low. For now, no support for active high given
-  if (gpioId != gpio::NO_GPIO and not csLockManual) {
-    spiCookie->getMutexParams(csType, csTimeout);
-    result = csMutex->lockMutex(csType, csTimeout);
+  /* Pull SPI CS low. For now, no support for active high given  */
+  if (gpioId != gpio::NO_GPIO) {
+    result = spiMutex->lockMutex(timeoutType, timeoutMs);
    if (result != RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::error << "SpiComIF::sendMessage: Failed to lock mutex with code "
-                 << "0x" << std::hex << std::setfill('0') << std::setw(4) << result << std::dec
-                 << std::endl;
+      sif::error << "SpiComIF::sendMessage: Failed to lock mutex" << std::endl;
 #else
-      sif::printError("SpiComIF::sendMessage: Failed to lock mutex with code %d\n", result);
+      sif::printError("SpiComIF::sendMessage: Failed to lock mutex\n");
 #endif
 #endif
      return result;
    }
-    updateLinePolarity(fileDescriptor);
    ReturnValue_t result = gpioComIF->pullLow(gpioId);
    if (result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
@@ -226,8 +221,6 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
 #endif
      return result;
    }
-  } else {
-    updateLinePolarity(fileDescriptor);
  }

  /* Execute transfer */
@@ -255,9 +248,9 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
    }
  }

-  if (gpioId != gpio::NO_GPIO and not csLockManual) {
+  if (gpioId != gpio::NO_GPIO) {
    gpioComIF->pullHigh(gpioId);
-    result = csMutex->unlockMutex();
+    result = spiMutex->unlockMutex();
    if (result != RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
      sif::error << "SpiComIF::sendMessage: Failed to unlock mutex" << std::endl;
@@ -285,8 +278,9 @@ ReturnValue_t SpiComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLe

 ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  std::string device = spiCookie->getSpiDevice();
  int fileDescriptor = 0;
-  UnixFileGuard fileHelper(dev, &fileDescriptor, O_RDWR, "SpiComIF::requestReceiveMessage");
+  UnixFileGuard fileHelper(device, &fileDescriptor, O_RDWR, "SpiComIF::requestReceiveMessage");
  if (fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
    return OPENING_FILE_FAILED;
  }
@@ -298,22 +292,12 @@ ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
    return result;
  }

-  bool csLockManual = spiCookie->getCsLockManual();
  gpioId_t gpioId = spiCookie->getChipSelectPin();
-  MutexIF::TimeoutType csType;
-  dur_millis_t csTimeout = 0;
-  if (gpioId != gpio::NO_GPIO and not csLockManual) {
-    spiCookie->getMutexParams(csType, csTimeout);
-    result = csMutex->lockMutex(csType, csTimeout);
+  if (gpioId != gpio::NO_GPIO) {
+    result = spiMutex->lockMutex(timeoutType, timeoutMs);
    if (result != RETURN_OK) {
-#if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::error << "SpiComIF::sendMessage: Failed to lock mutex with code "
-                 << "0x" << std::hex << std::setfill('0') << std::setw(4) << result << std::dec
-                 << std::endl;
-#else
-      sif::printError("SpiComIF::sendMessage: Failed to lock mutex with code %d\n", result);
-#endif
+      sif::error << "SpiComIF::getSendSuccess: Failed to lock mutex" << std::endl;
 #endif
      return result;
    }
@@ -331,9 +315,9 @@ ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
    result = HALF_DUPLEX_TRANSFER_FAILED;
  }

-  if (gpioId != gpio::NO_GPIO and not csLockManual) {
+  if (gpioId != gpio::NO_GPIO) {
    gpioComIF->pullHigh(gpioId);
-    result = csMutex->unlockMutex();
+    result = spiMutex->unlockMutex();
    if (result != RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
      sif::error << "SpiComIF::getSendSuccess: Failed to unlock mutex" << std::endl;
@@ -362,7 +346,15 @@ ReturnValue_t SpiComIF::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
  return HasReturnvaluesIF::RETURN_OK;
 }

-MutexIF* SpiComIF::getCsMutex() { return csMutex; }
+MutexIF* SpiComIF::getMutex(MutexIF::TimeoutType* timeoutType, uint32_t* timeoutMs) {
+  if (timeoutType != nullptr) {
+    *timeoutType = this->timeoutType;
+  }
+  if (timeoutMs != nullptr) {
+    *timeoutMs = this->timeoutMs;
+  }
+  return spiMutex;
+}

 void SpiComIF::performSpiWiretapping(SpiCookie* spiCookie) {
  if (spiCookie == nullptr) {
@@ -409,27 +401,11 @@ void SpiComIF::setSpiSpeedAndMode(int spiFd, spi::SpiModes mode, uint32_t speed)
  if (retval != 0) {
    utility::handleIoctlError("SpiComIF::setSpiSpeedAndMode: Setting SPI speed failed");
  }
-}
-
-void SpiComIF::getSpiSpeedAndMode(int spiFd, spi::SpiModes& mode, uint32_t& speed) const {
-  uint8_t tmpMode = 0;
-  int retval = ioctl(spiFd, SPI_IOC_RD_MODE, &tmpMode);
-  if (retval != 0) {
-    utility::handleIoctlError("SpiComIF::getSpiSpeedAndMode: Reading SPI mode failed");
-  }
-  mode = static_cast<spi::SpiModes>(tmpMode);
-
-  retval = ioctl(spiFd, SPI_IOC_RD_MAX_SPEED_HZ, &speed);
-  if (retval != 0) {
-    utility::handleIoctlError("SpiComIF::getSpiSpeedAndMode: Getting SPI speed failed");
-  }
-}
-
-const std::string& SpiComIF::getSpiDev() const { return dev; }
-
-void SpiComIF::updateLinePolarity(int spiFd) {
+  // This updates the SPI clock default polarity. Only setting the mode does not update
+  // the line state, which can be an issue on mode switches because the clock line will
+  // switch the state after the chip select is pulled low
  clockUpdateTransfer.len = 0;
-  int retval = ioctl(spiFd, SPI_IOC_MESSAGE(1), &clockUpdateTransfer);
+  retval = ioctl(spiFd, SPI_IOC_MESSAGE(1), &clockUpdateTransfer);
  if (retval != 0) {
    utility::handleIoctlError("SpiComIF::setSpiSpeedAndMode: Updating SPI default clock failed");
  }
--- a/hal/src/fsfw_hal/linux/spi/SpiComIF.h
+++ b/hal/src/fsfw_hal/linux/spi/SpiComIF.h
@@ -22,17 +22,17 @@ class SpiCookie;
 */
 class SpiComIF : public DeviceCommunicationIF, public SystemObject {
 public:
-  static constexpr uint8_t CLASS_ID = CLASS_ID::HAL_SPI;
+  static constexpr uint8_t spiRetvalId = CLASS_ID::HAL_SPI;
  static constexpr ReturnValue_t OPENING_FILE_FAILED =
-      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 0);
+      HasReturnvaluesIF::makeReturnCode(spiRetvalId, 0);
  /* Full duplex (ioctl) transfer failure */
  static constexpr ReturnValue_t FULL_DUPLEX_TRANSFER_FAILED =
-      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 1);
+      HasReturnvaluesIF::makeReturnCode(spiRetvalId, 1);
  /* Half duplex (read/write) transfer failure */
  static constexpr ReturnValue_t HALF_DUPLEX_TRANSFER_FAILED =
-      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 2);
+      HasReturnvaluesIF::makeReturnCode(spiRetvalId, 2);

-  SpiComIF(object_id_t objectId, std::string devname, GpioIF* gpioComIF);
+  SpiComIF(object_id_t objectId, GpioIF* gpioComIF);

  ReturnValue_t initializeInterface(CookieIF* cookie) override;
  ReturnValue_t sendMessage(CookieIF* cookie, const uint8_t* sendData, size_t sendLen) override;
@@ -44,8 +44,7 @@ class SpiComIF : public DeviceCommunicationIF, public SystemObject {
   * @brief   This function returns the mutex which can be used to protect the spi bus when
   *          the chip select must be driven from outside of the com if.
   */
-  MutexIF* getCsMutex();
-  void setMutexParams(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs);
+  MutexIF* getMutex(MutexIF::TimeoutType* timeoutType = nullptr, uint32_t* timeoutMs = nullptr);

  /**
   * Perform a regular send operation using Linux iotcl. This is public so it can be used
@@ -60,20 +59,6 @@ class SpiComIF : public DeviceCommunicationIF, public SystemObject {

  GpioIF* getGpioInterface();
  void setSpiSpeedAndMode(int spiFd, spi::SpiModes mode, uint32_t speed);
-  void getSpiSpeedAndMode(int spiFd, spi::SpiModes& mode, uint32_t& speed) const;
-
-  /**
-   * This updates the SPI clock default polarity. Only setting the mode does not update
-   * the line state, which can be an issue on mode switches because the clock line will
-   * switch the state after the chip select is pulled low.
-   *
-   * It is recommended to call this function after #setSpiSpeedAndMode and after locking the
-   * CS mutex if the SPI bus has multiple SPI devices with different speed and SPI modes attached.
-   * @param spiFd
-   */
-  void updateLinePolarity(int spiFd);
-
-  const std::string& getSpiDev() const;
  void performSpiWiretapping(SpiCookie* spiCookie);

  ReturnValue_t getReadBuffer(address_t spiAddress, uint8_t** buffer);
@@ -85,14 +70,10 @@ class SpiComIF : public DeviceCommunicationIF, public SystemObject {
  };

  GpioIF* gpioComIF = nullptr;
-  std::string dev = "";
-  /**
-   * Protects the chip select operations. Lock when GPIO is pulled low, unlock after it was
-   * pulled high
-   */
-  MutexIF* csMutex = nullptr;
-  // MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
-  // uint32_t timeoutMs = DEFAULT_MUTEX_TIMEOUT;
+
+  MutexIF* spiMutex = nullptr;
+  MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+  uint32_t timeoutMs = 20;
  spi_ioc_transfer clockUpdateTransfer = {};

  using SpiDeviceMap = std::unordered_map<address_t, SpiInstance>;
--- a/hal/src/fsfw_hal/linux/spi/SpiCookie.cpp
+++ b/hal/src/fsfw_hal/linux/spi/SpiCookie.cpp
@@ -1,25 +1,26 @@
 #include "SpiCookie.h"

-SpiCookie::SpiCookie(address_t spiAddress, gpioId_t chipSelect, const size_t maxSize,
+SpiCookie::SpiCookie(address_t spiAddress, gpioId_t chipSelect, std::string spiDev,
+                     const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed)
+    : SpiCookie(spi::SpiComIfModes::REGULAR, spiAddress, chipSelect, spiDev, maxSize, spiMode,
+                spiSpeed, nullptr, nullptr) {}
+
+SpiCookie::SpiCookie(address_t spiAddress, std::string spiDev, const size_t maxSize,
                     spi::SpiModes spiMode, uint32_t spiSpeed)
-    : SpiCookie(spi::SpiComIfModes::REGULAR, spiAddress, chipSelect, maxSize, spiMode, spiSpeed,
-                nullptr, nullptr) {}
+    : SpiCookie(spiAddress, gpio::NO_GPIO, spiDev, maxSize, spiMode, spiSpeed) {}

-SpiCookie::SpiCookie(address_t spiAddress, const size_t maxSize, spi::SpiModes spiMode,
-                     uint32_t spiSpeed)
-    : SpiCookie(spiAddress, gpio::NO_GPIO, maxSize, spiMode, spiSpeed) {}
-
-SpiCookie::SpiCookie(address_t spiAddress, gpioId_t chipSelect, const size_t maxSize,
-                     spi::SpiModes spiMode, uint32_t spiSpeed,
-                     spi::send_callback_function_t callback, void* args)
-    : SpiCookie(spi::SpiComIfModes::CALLBACK, spiAddress, chipSelect, maxSize, spiMode, spiSpeed,
-                callback, args) {}
-
-SpiCookie::SpiCookie(spi::SpiComIfModes comIfMode, address_t spiAddress, gpioId_t chipSelect,
+SpiCookie::SpiCookie(address_t spiAddress, gpioId_t chipSelect, std::string spiDev,
                     const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed,
                     spi::send_callback_function_t callback, void* args)
+    : SpiCookie(spi::SpiComIfModes::CALLBACK, spiAddress, chipSelect, spiDev, maxSize, spiMode,
+                spiSpeed, callback, args) {}
+
+SpiCookie::SpiCookie(spi::SpiComIfModes comIfMode, address_t spiAddress, gpioId_t chipSelect,
+                     std::string spiDev, const size_t maxSize, spi::SpiModes spiMode,
+                     uint32_t spiSpeed, spi::send_callback_function_t callback, void* args)
    : spiAddress(spiAddress),
      chipSelectPin(chipSelect),
+      spiDevice(spiDev),
      comIfMode(comIfMode),
      maxSize(maxSize),
      spiMode(spiMode),
@@ -49,6 +50,8 @@ size_t SpiCookie::getMaxBufferSize() const { return maxSize; }

 address_t SpiCookie::getSpiAddress() const { return spiAddress; }

+std::string SpiCookie::getSpiDevice() const { return spiDevice; }
+
 void SpiCookie::setThreeWireSpi(bool enable) { uncommonParameters.threeWireSpi = enable; }

 void SpiCookie::setLsbFirst(bool enable) { uncommonParameters.lsbFirst = enable; }
@@ -104,17 +107,3 @@ void SpiCookie::getCallback(spi::send_callback_function_t* callback, void** args
  *callback = this->sendCallback;
  *args = this->callbackArgs;
 }
-
-void SpiCookie::setCsLockManual(bool enable) { manualCsLock = enable; }
-
-bool SpiCookie::getCsLockManual() const { return manualCsLock; }
-
-void SpiCookie::getMutexParams(MutexIF::TimeoutType& csTimeoutType, dur_millis_t& csTimeout) const {
-  csTimeoutType = this->csTimeoutType;
-  csTimeout = this->csTimeout;
-}
-
-void SpiCookie::setMutexParams(MutexIF::TimeoutType csTimeoutType, dur_millis_t csTimeout) {
-  this->csTimeoutType = csTimeoutType;
-  this->csTimeout = csTimeout;
-}
--- a/hal/src/fsfw_hal/linux/spi/SpiCookie.h
+++ b/hal/src/fsfw_hal/linux/spi/SpiCookie.h
@@ -2,8 +2,6 @@
 #define LINUX_SPI_SPICOOKIE_H_

 #include <fsfw/devicehandlers/CookieIF.h>
-#include <fsfw/ipc/MutexIF.h>
-#include <fsfw/timemanager/clockDefinitions.h>
 #include <linux/spi/spidev.h>

 #include "../../common/gpio/gpioDefinitions.h"
@@ -22,8 +20,6 @@
 */
 class SpiCookie : public CookieIF {
 public:
-  static constexpr dur_millis_t DEFAULT_MUTEX_TIMEOUT = 20;
-
  /**
   * Each SPI device will have a corresponding cookie. The cookie is used by the communication
   * interface and contains device specific information like the largest expected size to be
@@ -33,22 +29,23 @@ class SpiCookie : public CookieIF {
   * @param spiDev
   * @param maxSize
   */
-  SpiCookie(address_t spiAddress, gpioId_t chipSelect, const size_t maxSize, spi::SpiModes spiMode,
-            uint32_t spiSpeed);
+  SpiCookie(address_t spiAddress, gpioId_t chipSelect, std::string spiDev, const size_t maxSize,
+            spi::SpiModes spiMode, uint32_t spiSpeed);

  /**
   * Like constructor above, but without a dedicated GPIO CS. Can be used for hardware
   * slave select or if CS logic is performed with decoders.
   */
-  SpiCookie(address_t spiAddress, const size_t maxReplySize, spi::SpiModes spiMode,
-            uint32_t spiSpeed);
+  SpiCookie(address_t spiAddress, std::string spiDev, const size_t maxReplySize,
+            spi::SpiModes spiMode, uint32_t spiSpeed);

  /**
   * Use the callback mode of the SPI communication interface. The user can pass the callback
   * function here or by using the setter function #setCallbackMode
   */
-  SpiCookie(address_t spiAddress, gpioId_t chipSelect, const size_t maxSize, spi::SpiModes spiMode,
-            uint32_t spiSpeed, spi::send_callback_function_t callback, void* args);
+  SpiCookie(address_t spiAddress, gpioId_t chipSelect, std::string spiDev, const size_t maxSize,
+            spi::SpiModes spiMode, uint32_t spiSpeed, spi::send_callback_function_t callback,
+            void* args);

  /**
   * Get the callback function
@@ -58,6 +55,7 @@ class SpiCookie : public CookieIF {
  void getCallback(spi::send_callback_function_t* callback, void** args);

  address_t getSpiAddress() const;
+  std::string getSpiDevice() const;
  gpioId_t getChipSelectPin() const;
  size_t getMaxBufferSize() const;

@@ -141,42 +139,9 @@ class SpiCookie : public CookieIF {
   */
  void activateCsDeselect(bool deselectCs, uint16_t delayUsecs);

-  void getMutexParams(MutexIF::TimeoutType& csTimeoutType, dur_millis_t& csTimeout) const;
-  void setMutexParams(MutexIF::TimeoutType csTimeoutType, dur_millis_t csTimeout);
-
-  void setCsLockManual(bool enable);
-  bool getCsLockManual() const;
-
  spi_ioc_transfer* getTransferStructHandle();

 private:
-  address_t spiAddress;
-  gpioId_t chipSelectPin;
-
-  spi::SpiComIfModes comIfMode;
-
-  // Required for regular mode
-  const size_t maxSize;
-  spi::SpiModes spiMode;
-  /**
-   * If this is set to true, the SPI ComIF will not perform any mutex locking for the
-   * CS mechanism. The user is responsible to locking and unlocking the mutex for the
-   * whole duration of the transfers.
-   */
-  bool manualCsLock = false;
-  uint32_t spiSpeed;
-  bool halfDuplex = false;
-
-  MutexIF::TimeoutType csTimeoutType = MutexIF::TimeoutType::WAITING;
-  dur_millis_t csTimeout = DEFAULT_MUTEX_TIMEOUT;
-
-  // Required for callback mode
-  spi::send_callback_function_t sendCallback = nullptr;
-  void* callbackArgs = nullptr;
-
-  struct spi_ioc_transfer spiTransferStruct = {};
-  UncommonParameters uncommonParameters;
-
  /**
   * Internal constructor which initializes every field
   * @param spiAddress
@@ -189,8 +154,27 @@ class SpiCookie : public CookieIF {
   * @param args
   */
  SpiCookie(spi::SpiComIfModes comIfMode, address_t spiAddress, gpioId_t chipSelect,
-            const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed,
+            std::string spiDev, const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed,
            spi::send_callback_function_t callback, void* args);
+
+  address_t spiAddress;
+  gpioId_t chipSelectPin;
+  std::string spiDevice;
+
+  spi::SpiComIfModes comIfMode;
+
+  // Required for regular mode
+  const size_t maxSize;
+  spi::SpiModes spiMode;
+  uint32_t spiSpeed;
+  bool halfDuplex = false;
+
+  // Required for callback mode
+  spi::send_callback_function_t sendCallback = nullptr;
+  void* callbackArgs = nullptr;
+
+  struct spi_ioc_transfer spiTransferStruct = {};
+  UncommonParameters uncommonParameters;
 };

 #endif /* LINUX_SPI_SPICOOKIE_H_ */
--- a/hal/src/fsfw_hal/linux/uart/UartCookie.cpp
+++ b/hal/src/fsfw_hal/linux/uart/UartCookie.cpp
@@ -2,8 +2,8 @@

 #include <fsfw/serviceinterface.h>

-UartCookie::UartCookie(object_id_t handlerId, std::string deviceFile, UartBaudRate baudrate,
-                       size_t maxReplyLen, UartModes uartMode)
+UartCookie::UartCookie(object_id_t handlerId, std::string deviceFile, UartModes uartMode,
+                       UartBaudRate baudrate, size_t maxReplyLen)
    : handlerId(handlerId),
      deviceFile(deviceFile),
      uartMode(uartMode),
--- a/hal/src/fsfw_hal/linux/uart/UartCookie.h
+++ b/hal/src/fsfw_hal/linux/uart/UartCookie.h
@@ -69,8 +69,8 @@ class UartCookie : public CookieIF {
   *                        8 databits (number of bits transfered with one uart frame)
   *                        One stop bit
   */
-  UartCookie(object_id_t handlerId, std::string deviceFile, UartBaudRate baudrate,
-             size_t maxReplyLen, UartModes uartMode = UartModes::NON_CANONICAL);
+  UartCookie(object_id_t handlerId, std::string deviceFile, UartModes uartMode,
+             UartBaudRate baudrate, size_t maxReplyLen);

  virtual ~UartCookie();

--- a/scripts/apply-clang-format.sh
+++ b/scripts/apply-clang-format.sh
@@ -0,0 +1,8 @@
+#!/bin/bash
+if [[ ! -f README.md ]]; then
+	cd ..
+fi
+
+find ./src -iname *.h -o -iname *.cpp -o -iname *.c | xargs clang-format --style=file -i
+find ./hal -iname *.h -o -iname *.cpp -o -iname *.c | xargs clang-format --style=file -i
+find ./tests -iname *.h -o -iname *.cpp -o -iname *.c | xargs clang-format --style=file -i
--- a/scripts/auto-formatter.sh
+++ b/scripts/auto-formatter.sh
@@ -1,29 +0,0 @@
-#!/bin/bash
-if [[ ! -f README.md ]]; then
-  cd ..
-fi
-
-folder_list=(
-  "./src"
-  "./hal"
-  "./tests"
-)
-
-cmake_fmt="cmake-format"
-if command -v ${cmake_fmt} &> /dev/null; then
-  cmake_fmt_cmd="${cmake_fmt} -i CMakeLists.txt"
-  eval ${cmake_fmt_cmd}
-else
-  echo "No ${cmake_fmt} tool found, not formatting CMake files"
-fi
-
-cpp_format="clang-format"
-file_selectors="-iname *.h -o -iname *.cpp -o -iname *.c -o -iname *.tpp"
-if command -v ${cpp_format} &> /dev/null; then
-  for dir in ${folder_list[@]}; do
-    echo "Auto-formatting ${dir} recursively"
-    find ${dir} ${file_selectors} | xargs clang-format --style=file -i
-  done
-else
-  echo "No ${cpp_format} tool found, not formatting C++/C files"
-fi
--- a/src/fsfw/CMakeLists.txt
+++ b/src/fsfw/CMakeLists.txt
@@ -1,5 +1,6 @@
 target_sources(${LIB_FSFW_NAME} PRIVATE
    version.cpp
+    versionAutogen.cpp
 )

 # Core
--- a/src/fsfw/FSFWVersion.h.in
+++ b/src/fsfw/FSFWVersion.h.in
@@ -1,11 +0,0 @@
-#ifndef FSFW_VERSION_H_
-#define FSFW_VERSION_H_
-
-// Versioning is managed in project CMakeLists.txt file
-static constexpr int FSFW_VERSION_MAJOR = @FSFW_VERSION@;
-static constexpr int FSFW_VERSION_MINOR = @FSFW_SUBVERSION@;
-static constexpr int FSFW_VERSION_REVISION = @FSFW_REVISION@;
-// Also contains CST (Commits since tag) information
-static const char FSFW_VCS_INFO[] = "@FSFW_VCS_INFO@";
-
-#endif /* FSFW_VERSION_H_ */
--- a/src/fsfw/action/CommandActionHelper.h
+++ b/src/fsfw/action/CommandActionHelper.h
@@ -16,8 +16,8 @@ class CommandActionHelper {
 public:
  CommandActionHelper(CommandsActionsIF* owner);
  virtual ~CommandActionHelper();
-  ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId,
-                              const uint8_t* data = nullptr, uint32_t size = 0);
+  ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId, const uint8_t* data,
+                              uint32_t size);
  ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId, SerializeIF* data);
  ReturnValue_t initialize();
  ReturnValue_t handleReply(CommandMessage* reply);
--- a/src/fsfw/cfdp/CFDPHandler.cpp
+++ b/src/fsfw/cfdp/CFDPHandler.cpp
@@ -12,9 +12,7 @@ object_id_t CFDPHandler::packetDestination = 0;

 CFDPHandler::CFDPHandler(object_id_t setObjectId, CFDPDistributor* dist)
    : SystemObject(setObjectId) {
-  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
-  requestQueue = QueueFactory::instance()->createMessageQueue(
-      CFDP_HANDLER_MAX_RECEPTION, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  requestQueue = QueueFactory::instance()->createMessageQueue(CFDP_HANDLER_MAX_RECEPTION);
  distributor = dist;
 }

--- a/src/fsfw/container/FIFOBase.tpp
+++ b/src/fsfw/container/FIFOBase.tpp
@@ -5,88 +5,89 @@
 #error Include FIFOBase.h before FIFOBase.tpp!
 #endif

-template <typename T>
-inline FIFOBase<T>::FIFOBase(T* values, const size_t maxCapacity)
-    : maxCapacity(maxCapacity), values(values){};
+template<typename T>
+inline FIFOBase<T>::FIFOBase(T* values, const size_t maxCapacity):
+        maxCapacity(maxCapacity), values(values){};

-template <typename T>
+template<typename T>
 inline ReturnValue_t FIFOBase<T>::insert(T value) {
-  if (full()) {
-    return FULL;
-  } else {
-    values[writeIndex] = value;
-    writeIndex = next(writeIndex);
-    ++currentSize;
-    return HasReturnvaluesIF::RETURN_OK;
-  }
+    if (full()) {
+        return FULL;
+    } else {
+        values[writeIndex] = value;
+        writeIndex = next(writeIndex);
+        ++currentSize;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 };

-template <typename T>
+template<typename T>
 inline ReturnValue_t FIFOBase<T>::retrieve(T* value) {
-  if (empty()) {
-    return EMPTY;
-  } else {
-    if (value == nullptr) {
-      return HasReturnvaluesIF::RETURN_FAILED;
+    if (empty()) {
+        return EMPTY;
+    } else {
+        if (value == nullptr){
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        *value = values[readIndex];
+        readIndex = next(readIndex);
+        --currentSize;
+        return HasReturnvaluesIF::RETURN_OK;
    }
-    *value = values[readIndex];
-    readIndex = next(readIndex);
-    --currentSize;
-    return HasReturnvaluesIF::RETURN_OK;
-  }
 };

-template <typename T>
+template<typename T>
 inline ReturnValue_t FIFOBase<T>::peek(T* value) {
-  if (empty()) {
-    return EMPTY;
-  } else {
-    if (value == nullptr) {
-      return HasReturnvaluesIF::RETURN_FAILED;
+    if(empty()) {
+        return EMPTY;
+    } else {
+        if (value == nullptr){
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        *value = values[readIndex];
+        return HasReturnvaluesIF::RETURN_OK;
    }
-    *value = values[readIndex];
-    return HasReturnvaluesIF::RETURN_OK;
-  }
 };

-template <typename T>
+template<typename T>
 inline ReturnValue_t FIFOBase<T>::pop() {
-  T value;
-  return this->retrieve(&value);
+    T value;
+    return this->retrieve(&value);
 };

-template <typename T>
+template<typename T>
 inline bool FIFOBase<T>::empty() {
-  return (currentSize == 0);
+    return (currentSize == 0);
 };

-template <typename T>
+template<typename T>
 inline bool FIFOBase<T>::full() {
-  return (currentSize == maxCapacity);
+    return (currentSize == maxCapacity);
 }

-template <typename T>
+template<typename T>
 inline size_t FIFOBase<T>::size() {
-  return currentSize;
+    return currentSize;
 }

-template <typename T>
+template<typename T>
 inline size_t FIFOBase<T>::next(size_t current) {
-  ++current;
-  if (current == maxCapacity) {
-    current = 0;
-  }
-  return current;
+    ++current;
+    if (current == maxCapacity) {
+        current = 0;
+    }
+    return current;
 }

-template <typename T>
+template<typename T>
 inline size_t FIFOBase<T>::getMaxCapacity() const {
-  return maxCapacity;
+    return maxCapacity;
 }

-template <typename T>
-inline void FIFOBase<T>::setContainer(T* data) {
-  this->values = data;
+
+template<typename T>
+inline void FIFOBase<T>::setContainer(T *data) {
+    this->values = data;
 }

 #endif
--- a/src/fsfw/container/FixedArrayList.h
+++ b/src/fsfw/container/FixedArrayList.h
@@ -12,7 +12,6 @@ template <typename T, size_t MAX_SIZE, typename count_t = uint8_t>
 class FixedArrayList : public ArrayList<T, count_t> {
  static_assert(MAX_SIZE <= std::numeric_limits<count_t>::max(),
                "count_t is not large enough to hold MAX_SIZE");
-
 private:
  T data[MAX_SIZE];

--- a/src/fsfw/container/FixedOrderedMultimap.tpp
+++ b/src/fsfw/container/FixedOrderedMultimap.tpp
@@ -1,109 +1,109 @@
 #ifndef FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_
 #define FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_

-template <typename key_t, typename T, typename KEY_COMPARE>
-inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(key_t key, T value,
-                                                                         Iterator *storedValue) {
-  if (_size == theMap.maxSize()) {
-    return MAP_FULL;
-  }
-  size_t position = findNicePlace(key);
-  memmove(static_cast<void *>(&theMap[position + 1]), static_cast<void *>(&theMap[position]),
-          (_size - position) * sizeof(std::pair<key_t, T>));
-  theMap[position].first = key;
-  theMap[position].second = value;
-  ++_size;
-  if (storedValue != nullptr) {
-    *storedValue = Iterator(&theMap[position]);
-  }
-  return HasReturnvaluesIF::RETURN_OK;
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(key_t key, T value, Iterator *storedValue) {
+    if (_size == theMap.maxSize()) {
+        return MAP_FULL;
+    }
+    size_t position = findNicePlace(key);
+    memmove(static_cast<void*>(&theMap[position + 1]),static_cast<void*>(&theMap[position]),
+            (_size - position) * sizeof(std::pair<key_t,T>));
+    theMap[position].first = key;
+    theMap[position].second = value;
+    ++_size;
+    if (storedValue != nullptr) {
+        *storedValue = Iterator(&theMap[position]);
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
-template <typename key_t, typename T, typename KEY_COMPARE>
+template<typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(std::pair<key_t, T> pair) {
-  return insert(pair.first, pair.second);
+    return insert(pair.first, pair.second);
 }

-template <typename key_t, typename T, typename KEY_COMPARE>
+template<typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::exists(key_t key) const {
-  ReturnValue_t result = KEY_DOES_NOT_EXIST;
-  if (findFirstIndex(key) < _size) {
-    result = HasReturnvaluesIF::RETURN_OK;
-  }
-  return result;
-}
-
-template <typename key_t, typename T, typename KEY_COMPARE>
-inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(Iterator *iter) {
-  size_t i;
-  if ((i = findFirstIndex((*iter).value->first)) >= _size) {
-    return KEY_DOES_NOT_EXIST;
-  }
-  removeFromPosition(i);
-  if (*iter != begin()) {
-    (*iter)--;
-  } else {
-    *iter = begin();
-  }
-  return HasReturnvaluesIF::RETURN_OK;
-}
-
-template <typename key_t, typename T, typename KEY_COMPARE>
-inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(key_t key) {
-  size_t i;
-  if ((i = findFirstIndex(key)) >= _size) {
-    return KEY_DOES_NOT_EXIST;
-  }
-  do {
-    removeFromPosition(i);
-    i = findFirstIndex(key, i);
-  } while (i < _size);
-  return HasReturnvaluesIF::RETURN_OK;
-}
-
-template <typename key_t, typename T, typename KEY_COMPARE>
-inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(key_t key, T **value) const {
-  ReturnValue_t result = exists(key);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+    ReturnValue_t result = KEY_DOES_NOT_EXIST;
+    if (findFirstIndex(key) < _size) {
+        result = HasReturnvaluesIF::RETURN_OK;
+    }
    return result;
-  }
-  *value = &theMap[findFirstIndex(key)].second;
-  return HasReturnvaluesIF::RETURN_OK;
 }

-template <typename key_t, typename T, typename KEY_COMPARE>
-inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findFirstIndex(key_t key,
-                                                                          size_t startAt) const {
-  if (startAt >= _size) {
-    return startAt + 1;
-  }
-  size_t i = startAt;
-  for (i = startAt; i < _size; ++i) {
-    if (theMap[i].first == key) {
-      return i;
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(Iterator *iter) {
+    size_t i;
+    if ((i = findFirstIndex((*iter).value->first)) >= _size) {
+        return KEY_DOES_NOT_EXIST;
    }
-  }
-  return i;
+    removeFromPosition(i);
+    if (*iter != begin()) {
+        (*iter)--;
+    } else {
+        *iter = begin();
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }

-template <typename key_t, typename T, typename KEY_COMPARE>
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(key_t key) {
+    size_t i;
+    if ((i = findFirstIndex(key)) >= _size) {
+        return KEY_DOES_NOT_EXIST;
+    }
+    do {
+        removeFromPosition(i);
+        i = findFirstIndex(key, i);
+    } while (i < _size);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(key_t key, T **value) const {
+    ReturnValue_t result = exists(key);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    *value = &theMap[findFirstIndex(key)].second;
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findFirstIndex(key_t key, size_t startAt) const {
+    if (startAt >= _size) {
+        return startAt + 1;
+    }
+    size_t i = startAt;
+    for (i = startAt; i < _size; ++i) {
+        if (theMap[i].first == key) {
+            return i;
+        }
+    }
+    return i;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
 inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findNicePlace(key_t key) const {
-  size_t i = 0;
-  for (i = 0; i < _size; ++i) {
-    if (myComp(key, theMap[i].first)) {
-      return i;
+    size_t i = 0;
+    for (i = 0; i < _size; ++i) {
+        if (myComp(key, theMap[i].first)) {
+            return i;
+        }
    }
-  }
-  return i;
+    return i;
 }

-template <typename key_t, typename T, typename KEY_COMPARE>
+template<typename key_t, typename T, typename KEY_COMPARE>
 inline void FixedOrderedMultimap<key_t, T, KEY_COMPARE>::removeFromPosition(size_t position) {
-  if (_size <= position) {
-    return;
-  }
-  memmove(static_cast<void *>(&theMap[position]), static_cast<void *>(&theMap[position + 1]),
-          (_size - position - 1) * sizeof(std::pair<key_t, T>));
-  --_size;
+    if (_size <= position) {
+        return;
+    }
+    memmove(static_cast<void*>(&theMap[position]), static_cast<void*>(&theMap[position + 1]),
+            (_size - position - 1) * sizeof(std::pair<key_t,T>));
+    --_size;
 }

+
 #endif /* FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_ */
--- a/src/fsfw/controller/ControllerBase.cpp
+++ b/src/fsfw/controller/ControllerBase.cpp
@@ -13,9 +13,7 @@ ControllerBase::ControllerBase(object_id_t setObjectId, object_id_t parentId,
      submode(SUBMODE_NONE),
      modeHelper(this),
      healthHelper(this, setObjectId) {
-  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
-  commandQueue = QueueFactory::instance()->createMessageQueue(
-      commandQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth);
 }

 ControllerBase::~ControllerBase() { QueueFactory::instance()->deleteMessageQueue(commandQueue); }
--- a/src/fsfw/datapool/CMakeLists.txt
+++ b/src/fsfw/datapool/CMakeLists.txt
@@ -1,4 +1,4 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE 
-    PoolDataSetBase.cpp
-    PoolEntry.cpp
+target_sources(${LIB_FSFW_NAME} PRIVATE
+	PoolDataSetBase.cpp
+	PoolEntry.cpp
 )
--- a/src/fsfw/datapool/PoolEntry.cpp
+++ b/src/fsfw/datapool/PoolEntry.cpp
@@ -7,26 +7,24 @@
 #include "fsfw/serviceinterface/ServiceInterface.h"

 template <typename T>
-PoolEntry<T>::PoolEntry(uint8_t len, bool setValid) : length(len), valid(setValid) {
-  this->address = new T[this->length]();
-  std::memset(this->address, 0, this->getByteSize());
-}
-
-template <typename T>
-PoolEntry<T>::PoolEntry(std::initializer_list<T> initValues, bool setValid)
-    : length(static_cast<uint8_t>(initValues.size())), valid(setValid) {
-  this->address = new T[this->length]();
-  if (initValues.size() > 0) {
-    std::copy(initValues.begin(), initValues.end(), this->address);
+PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, bool setValid)
+    : length(static_cast<uint8_t>(initValue.size())), valid(setValid) {
+  this->address = new T[this->length];
+  if (initValue.size() == 0) {
+    std::memset(this->address, 0, this->getByteSize());
+  } else {
+    std::copy(initValue.begin(), initValue.end(), this->address);
  }
 }

 template <typename T>
-PoolEntry<T>::PoolEntry(const T* initValue, uint8_t setLength, bool setValid)
+PoolEntry<T>::PoolEntry(T* initValue, uint8_t setLength, bool setValid)
    : length(setLength), valid(setValid) {
-  this->address = new T[this->length]();
+  this->address = new T[this->length];
  if (initValue != nullptr) {
    std::memcpy(this->address, initValue, this->getByteSize());
+  } else {
+    std::memset(this->address, 0, this->getByteSize());
  }
 }

--- a/src/fsfw/datapool/PoolEntry.h
+++ b/src/fsfw/datapool/PoolEntry.h
@@ -33,9 +33,6 @@ class PoolEntry : public PoolEntryIF {
                "instead! The ECSS standard defines a boolean as a one bit "
                "field. Therefore it is preferred to store a boolean as an "
                "uint8_t");
-
-  PoolEntry(uint8_t len = 1, bool setValid = false);
-
  /**
   * @brief	In the classe's constructor, space is allocated on the heap and
   * 			potential initialization values are copied to that space.
@@ -52,7 +49,7 @@ class PoolEntry : public PoolEntryIF {
   * @param setValid
   * Sets the initialization flag. It is invalid by default.
   */
-  PoolEntry(std::initializer_list<T> initValue, bool setValid = false);
+  PoolEntry(std::initializer_list<T> initValue = {0}, bool setValid = false);

  /**
   * @brief	In the classe's constructor, space is allocated on the heap and
@@ -65,7 +62,7 @@ class PoolEntry : public PoolEntryIF {
   * @param setValid
   * Sets the initialization flag. It is invalid by default.
   */
-  PoolEntry(const T* initValue, uint8_t setLength = 1, bool setValid = false);
+  PoolEntry(T* initValue, uint8_t setLength = 1, bool setValid = false);

  //! Explicitely deleted copy ctor, copying is not allowed.
  PoolEntry(const PoolEntry&) = delete;
--- a/src/fsfw/datapoollocal/LocalPoolDataSetBase.h
+++ b/src/fsfw/datapoollocal/LocalPoolDataSetBase.h
@@ -162,7 +162,6 @@ class LocalPoolDataSetBase : public PoolDataSetBase, public MarkChangedIF {
  object_id_t getCreatorObjectId();

  bool getReportingEnabled() const;
-  void setReportingEnabled(bool enabled);

  /**
   * Returns the current periodic HK generation interval this set
@@ -190,6 +189,7 @@ class LocalPoolDataSetBase : public PoolDataSetBase, public MarkChangedIF {
   * Used for periodic generation.
   */
  bool reportingEnabled = false;
+  void setReportingEnabled(bool enabled);

  void initializePeriodicHelper(float collectionInterval, dur_millis_t minimumPeriodicInterval,
                                uint8_t nonDiagIntervalFactor = 5);
--- a/src/fsfw/datapoollocal/LocalPoolVariable.tpp
+++ b/src/fsfw/datapoollocal/LocalPoolVariable.tpp
@@ -5,189 +5,205 @@
 #error Include LocalPoolVariable.h before LocalPoolVariable.tpp!
 #endif

-template <typename T>
-inline LocalPoolVariable<T>::LocalPoolVariable(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
-                                               DataSetIF* dataSet, pool_rwm_t setReadWriteMode)
-    : LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
+template<typename T>
+inline LocalPoolVariable<T>::LocalPoolVariable(HasLocalDataPoolIF* hkOwner,
+        lp_id_t poolId, DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
+        LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}

-template <typename T>
-inline LocalPoolVariable<T>::LocalPoolVariable(object_id_t poolOwner, lp_id_t poolId,
-                                               DataSetIF* dataSet, pool_rwm_t setReadWriteMode)
-    : LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
+template<typename T>
+inline LocalPoolVariable<T>::LocalPoolVariable(object_id_t poolOwner,
+        lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+        LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}

-template <typename T>
-inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId, DataSetIF* dataSet,
-                                               pool_rwm_t setReadWriteMode)
-    : LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId, dataSet,
-                          setReadWriteMode) {}

-template <typename T>
-inline ReturnValue_t LocalPoolVariable<T>::read(MutexIF::TimeoutType timeoutType,
-                                                uint32_t timeoutMs) {
-  if (hkManager == nullptr) {
-    return readWithoutLock();
-  }
-  MutexIF* mutex = LocalDpManagerAttorney::getMutexHandle(*hkManager);
-  ReturnValue_t result = mutex->lockMutex(timeoutType, timeoutMs);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+template<typename T>
+inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId,
+        DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+        LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
+                dataSet, setReadWriteMode){}
+
+
+template<typename T>
+inline ReturnValue_t LocalPoolVariable<T>::read(
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+    if(hkManager == nullptr) {
+        return readWithoutLock();
+    }
+    MutexIF* mutex = LocalDpManagerAttorney::getMutexHandle(*hkManager);
+    ReturnValue_t result = mutex->lockMutex(timeoutType, timeoutMs);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    result = readWithoutLock();
+    mutex->unlockMutex();
    return result;
-  }
-  result = readWithoutLock();
-  mutex->unlockMutex();
-  return result;
 }

-template <typename T>
+template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
-  if (readWriteMode == pool_rwm_t::VAR_WRITE) {
-    object_id_t targetObjectId = hkManager->getCreatorObjectId();
-    reportReadCommitError("LocalPoolVector", PoolVariableIF::INVALID_READ_WRITE_MODE, true,
-                          targetObjectId, localPoolId);
-    return PoolVariableIF::INVALID_READ_WRITE_MODE;
-  }
+    if(readWriteMode == pool_rwm_t::VAR_WRITE) {
+        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVector",
+                PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
+                localPoolId);
+        return PoolVariableIF::INVALID_READ_WRITE_MODE;
+    }

-  PoolEntry<T>* poolEntry = nullptr;
-  ReturnValue_t result =
-      LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
-  if (result != RETURN_OK) {
-    object_id_t ownerObjectId = hkManager->getCreatorObjectId();
-    reportReadCommitError("LocalPoolVariable", result, false, ownerObjectId, localPoolId);
+    PoolEntry<T>* poolEntry = nullptr;
+    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+            &poolEntry);
+    if(result != RETURN_OK) {
+        object_id_t ownerObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVariable", result,
+                false, ownerObjectId, localPoolId);
+        return result;
+    }
+
+    this->value = *(poolEntry->getDataPtr());
+    this->valid = poolEntry->getValid();
+    return RETURN_OK;
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVariable<T>::commit(bool setValid,
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+    this->setValid(setValid);
+    return commit(timeoutType, timeoutMs);
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVariable<T>::commit(
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+    if(hkManager == nullptr) {
+        return commitWithoutLock();
+    }
+    MutexIF* mutex = LocalDpManagerAttorney::getMutexHandle(*hkManager);
+    ReturnValue_t result = mutex->lockMutex(timeoutType, timeoutMs);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    result = commitWithoutLock();
+    mutex->unlockMutex();
    return result;
-  }
-
-  this->value = *(poolEntry->getDataPtr());
-  this->valid = poolEntry->getValid();
-  return RETURN_OK;
 }

-template <typename T>
-inline ReturnValue_t LocalPoolVariable<T>::commit(bool setValid, MutexIF::TimeoutType timeoutType,
-                                                  uint32_t timeoutMs) {
-  this->setValid(setValid);
-  return commit(timeoutType, timeoutMs);
-}
-
-template <typename T>
-inline ReturnValue_t LocalPoolVariable<T>::commit(MutexIF::TimeoutType timeoutType,
-                                                  uint32_t timeoutMs) {
-  if (hkManager == nullptr) {
-    return commitWithoutLock();
-  }
-  MutexIF* mutex = LocalDpManagerAttorney::getMutexHandle(*hkManager);
-  ReturnValue_t result = mutex->lockMutex(timeoutType, timeoutMs);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
-    return result;
-  }
-  result = commitWithoutLock();
-  mutex->unlockMutex();
-  return result;
-}
-
-template <typename T>
+template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
-  if (readWriteMode == pool_rwm_t::VAR_READ) {
-    object_id_t targetObjectId = hkManager->getCreatorObjectId();
-    reportReadCommitError("LocalPoolVector", PoolVariableIF::INVALID_READ_WRITE_MODE, false,
-                          targetObjectId, localPoolId);
-    return PoolVariableIF::INVALID_READ_WRITE_MODE;
-  }
+    if(readWriteMode == pool_rwm_t::VAR_READ) {
+        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVector",
+                PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
+                localPoolId);
+        return PoolVariableIF::INVALID_READ_WRITE_MODE;
+    }

-  PoolEntry<T>* poolEntry = nullptr;
-  ReturnValue_t result =
-      LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
-  if (result != RETURN_OK) {
-    object_id_t ownerObjectId = hkManager->getCreatorObjectId();
-    reportReadCommitError("LocalPoolVariable", result, false, ownerObjectId, localPoolId);
-    return result;
-  }
+    PoolEntry<T>* poolEntry = nullptr;
+    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+            &poolEntry);
+    if(result != RETURN_OK) {
+        object_id_t ownerObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVariable", result,
+                false, ownerObjectId, localPoolId);
+        return result;
+    }

-  *(poolEntry->getDataPtr()) = this->value;
-  poolEntry->setValid(this->valid);
-  return RETURN_OK;
+    *(poolEntry->getDataPtr()) = this->value;
+    poolEntry->setValid(this->valid);
+    return RETURN_OK;
 }

-template <typename T>
-inline ReturnValue_t LocalPoolVariable<T>::serialize(
-    uint8_t** buffer, size_t* size, const size_t max_size,
-    SerializeIF::Endianness streamEndianness) const {
-  return SerializeAdapter::serialize(&value, buffer, size, max_size, streamEndianness);
+template<typename T>
+inline ReturnValue_t LocalPoolVariable<T>::serialize(uint8_t** buffer,
+        size_t* size, const size_t max_size,
+        SerializeIF::Endianness streamEndianness) const {
+    return SerializeAdapter::serialize(&value,
+            buffer, size ,max_size, streamEndianness);
 }

-template <typename T>
+template<typename T>
 inline size_t LocalPoolVariable<T>::getSerializedSize() const {
-  return SerializeAdapter::getSerializedSize(&value);
+    return SerializeAdapter::getSerializedSize(&value);
 }

-template <typename T>
-inline ReturnValue_t LocalPoolVariable<T>::deSerialize(const uint8_t** buffer, size_t* size,
-                                                       SerializeIF::Endianness streamEndianness) {
-  return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
+template<typename T>
+inline ReturnValue_t LocalPoolVariable<T>::deSerialize(const uint8_t** buffer,
+        size_t* size, SerializeIF::Endianness streamEndianness) {
+    return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
 }

 #if FSFW_CPP_OSTREAM_ENABLED == 1
-template <typename T>
-inline std::ostream& operator<<(std::ostream& out, const LocalPoolVariable<T>& var) {
-  out << var.value;
-  return out;
+template<typename T>
+inline std::ostream& operator<< (std::ostream &out,
+        const LocalPoolVariable<T> &var) {
+    out << var.value;
+    return out;
 }
 #endif

-template <typename T>
+template<typename T>
 inline LocalPoolVariable<T>::operator T() const {
-  return value;
+    return value;
 }

-template <typename T>
-inline LocalPoolVariable<T>& LocalPoolVariable<T>::operator=(const T& newValue) {
-  value = newValue;
-  return *this;
+template<typename T>
+inline LocalPoolVariable<T> & LocalPoolVariable<T>::operator=(
+        const T& newValue) {
+    value = newValue;
+    return *this;
 }

-template <typename T>
-inline LocalPoolVariable<T>& LocalPoolVariable<T>::operator=(
-    const LocalPoolVariable<T>& newPoolVariable) {
-  value = newPoolVariable.value;
-  return *this;
+template<typename T>
+inline LocalPoolVariable<T>& LocalPoolVariable<T>::operator =(
+        const LocalPoolVariable<T>& newPoolVariable) {
+    value = newPoolVariable.value;
+    return *this;
 }

-template <typename T>
-inline bool LocalPoolVariable<T>::operator==(const LocalPoolVariable<T>& other) const {
-  return this->value == other.value;
+template<typename T>
+inline bool LocalPoolVariable<T>::operator ==(
+        const LocalPoolVariable<T> &other) const {
+    return this->value == other.value;
 }

-template <typename T>
-inline bool LocalPoolVariable<T>::operator==(const T& other) const {
-  return this->value == other;
+template<typename T>
+inline bool LocalPoolVariable<T>::operator ==(const T &other) const {
+    return this->value == other;
 }

-template <typename T>
-inline bool LocalPoolVariable<T>::operator!=(const LocalPoolVariable<T>& other) const {
-  return not(*this == other);
+
+template<typename T>
+inline bool LocalPoolVariable<T>::operator !=(
+        const LocalPoolVariable<T> &other) const {
+    return not (*this == other);
 }

-template <typename T>
-inline bool LocalPoolVariable<T>::operator!=(const T& other) const {
-  return not(*this == other);
+template<typename T>
+inline bool LocalPoolVariable<T>::operator !=(const T &other) const {
+    return not (*this == other);
 }

-template <typename T>
-inline bool LocalPoolVariable<T>::operator<(const LocalPoolVariable<T>& other) const {
-  return this->value < other.value;
+
+template<typename T>
+inline bool LocalPoolVariable<T>::operator <(
+        const LocalPoolVariable<T> &other) const {
+    return this->value < other.value;
 }

-template <typename T>
-inline bool LocalPoolVariable<T>::operator<(const T& other) const {
-  return this->value < other;
+template<typename T>
+inline bool LocalPoolVariable<T>::operator <(const T &other) const {
+    return this->value < other;
 }

-template <typename T>
-inline bool LocalPoolVariable<T>::operator>(const LocalPoolVariable<T>& other) const {
-  return not(*this < other);
+
+template<typename T>
+inline bool LocalPoolVariable<T>::operator >(
+        const LocalPoolVariable<T> &other) const {
+    return not (*this < other);
 }

-template <typename T>
-inline bool LocalPoolVariable<T>::operator>(const T& other) const {
-  return not(*this < other);
+template<typename T>
+inline bool LocalPoolVariable<T>::operator >(const T &other) const {
+    return not (*this < other);
 }

 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_ */
--- a/src/fsfw/datapoollocal/LocalPoolVector.tpp
+++ b/src/fsfw/datapoollocal/LocalPoolVector.tpp
@@ -5,172 +5,174 @@
 #error Include LocalPoolVector.h before LocalPoolVector.tpp!
 #endif

-template <typename T, uint16_t vectorSize>
-inline LocalPoolVector<T, vectorSize>::LocalPoolVector(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
-                                                       DataSetIF* dataSet,
-                                                       pool_rwm_t setReadWriteMode)
-    : LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
+template<typename T, uint16_t vectorSize>
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(
+        HasLocalDataPoolIF* hkOwner, lp_id_t poolId, DataSetIF* dataSet,
+        pool_rwm_t setReadWriteMode):
+        LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}

-template <typename T, uint16_t vectorSize>
-inline LocalPoolVector<T, vectorSize>::LocalPoolVector(object_id_t poolOwner, lp_id_t poolId,
-                                                       DataSetIF* dataSet,
-                                                       pool_rwm_t setReadWriteMode)
-    : LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
+template<typename T, uint16_t vectorSize>
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(object_id_t poolOwner,
+        lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+        LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}

-template <typename T, uint16_t vectorSize>
-inline LocalPoolVector<T, vectorSize>::LocalPoolVector(gp_id_t globalPoolId, DataSetIF* dataSet,
-                                                       pool_rwm_t setReadWriteMode)
-    : LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId, dataSet,
-                          setReadWriteMode) {}
+template<typename T, uint16_t vectorSize>
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(gp_id_t globalPoolId,
+        DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+        LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
+                dataSet, setReadWriteMode) {}

-template <typename T, uint16_t vectorSize>
-inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(MutexIF::TimeoutType timeoutType,
-                                                          uint32_t timeoutMs) {
-  MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
-  return readWithoutLock();
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+    MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
+    return readWithoutLock();
 }
-template <typename T, uint16_t vectorSize>
+template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
-  if (readWriteMode == pool_rwm_t::VAR_WRITE) {
-    object_id_t targetObjectId = hkManager->getCreatorObjectId();
-    reportReadCommitError("LocalPoolVector", PoolVariableIF::INVALID_READ_WRITE_MODE, true,
-                          targetObjectId, localPoolId);
-    return PoolVariableIF::INVALID_READ_WRITE_MODE;
-  }
+    if(readWriteMode == pool_rwm_t::VAR_WRITE) {
+        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVector",
+                PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
+                localPoolId);
+        return PoolVariableIF::INVALID_READ_WRITE_MODE;
+    }

-  PoolEntry<T>* poolEntry = nullptr;
-  ReturnValue_t result =
-      LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
-  memset(this->value, 0, vectorSize * sizeof(T));
+    PoolEntry<T>* poolEntry = nullptr;
+    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+            &poolEntry);
+    memset(this->value, 0, vectorSize * sizeof(T));

-  if (result != RETURN_OK) {
-    object_id_t targetObjectId = hkManager->getCreatorObjectId();
-    reportReadCommitError("LocalPoolVector", result, true, targetObjectId, localPoolId);
-    return result;
-  }
-  std::memcpy(this->value, poolEntry->getDataPtr(), poolEntry->getByteSize());
-  this->valid = poolEntry->getValid();
-  return RETURN_OK;
+    if(result != RETURN_OK) {
+        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVector", result, true, targetObjectId,
+                localPoolId);
+        return result;
+    }
+    std::memcpy(this->value, poolEntry->getDataPtr(), poolEntry->getByteSize());
+    this->valid = poolEntry->getValid();
+    return RETURN_OK;
 }

-template <typename T, uint16_t vectorSize>
+template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(bool valid,
-                                                            MutexIF::TimeoutType timeoutType,
-                                                            uint32_t timeoutMs) {
-  this->setValid(valid);
-  return commit(timeoutType, timeoutMs);
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+    this->setValid(valid);
+    return commit(timeoutType, timeoutMs);
 }

-template <typename T, uint16_t vectorSize>
-inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(MutexIF::TimeoutType timeoutType,
-                                                            uint32_t timeoutMs) {
-  MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
-  return commitWithoutLock();
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+    MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
+    return commitWithoutLock();
 }

-template <typename T, uint16_t vectorSize>
+template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
-  if (readWriteMode == pool_rwm_t::VAR_READ) {
-    object_id_t targetObjectId = hkManager->getCreatorObjectId();
-    reportReadCommitError("LocalPoolVector", PoolVariableIF::INVALID_READ_WRITE_MODE, false,
-                          targetObjectId, localPoolId);
-    return PoolVariableIF::INVALID_READ_WRITE_MODE;
-  }
-  PoolEntry<T>* poolEntry = nullptr;
-  ReturnValue_t result =
-      LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
-  if (result != RETURN_OK) {
-    object_id_t targetObjectId = hkManager->getCreatorObjectId();
-    reportReadCommitError("LocalPoolVector", result, false, targetObjectId, localPoolId);
+    if(readWriteMode == pool_rwm_t::VAR_READ) {
+        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVector",
+                PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
+                localPoolId);
+        return PoolVariableIF::INVALID_READ_WRITE_MODE;
+    }
+    PoolEntry<T>* poolEntry = nullptr;
+    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+            &poolEntry);
+    if(result != RETURN_OK) {
+        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVector", result, false, targetObjectId,
+                localPoolId);
+        return result;
+    }
+    std::memcpy(poolEntry->getDataPtr(), this->value, poolEntry->getByteSize());
+    poolEntry->setValid(this->valid);
+    return RETURN_OK;
+}
+
+template<typename T, uint16_t vectorSize>
+inline T& LocalPoolVector<T, vectorSize>::operator [](size_t i) {
+    if(i < vectorSize) {
+        return value[i];
+    }
+    // If this happens, I have to set some value. I consider this
+    // a configuration error, but I wont exit here.
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
+            " last value!" << std::endl;
+#else
+    sif::printWarning("LocalPoolVector: Invalid index. Setting or returning"
+            " last value!\n");
+#endif
+    return value[vectorSize - 1];
+}
+
+template<typename T, uint16_t vectorSize>
+inline const T& LocalPoolVector<T, vectorSize>::operator [](size_t i) const {
+    if(i < vectorSize) {
+        return value[i];
+    }
+    // If this happens, I have to set some value. I consider this
+    // a configuration error, but I wont exit here.
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
+            " last value!" << std::endl;
+#else
+    sif::printWarning("LocalPoolVector: Invalid index. Setting or returning"
+            " last value!\n");
+#endif
+    return value[vectorSize - 1];
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
+        size_t* size, size_t maxSize,
+        SerializeIF::Endianness streamEndianness) const {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    for (uint16_t i = 0; i < vectorSize; i++) {
+        result = SerializeAdapter::serialize(&(value[i]), buffer, size,
+                maxSize, streamEndianness);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            break;
+        }
+    }
    return result;
-  }
-  std::memcpy(poolEntry->getDataPtr(), this->value, poolEntry->getByteSize());
-  poolEntry->setValid(this->valid);
-  return RETURN_OK;
 }

-template <typename T, uint16_t vectorSize>
-inline T& LocalPoolVector<T, vectorSize>::operator[](size_t i) {
-  if (i < vectorSize) {
-    return value[i];
-  }
-  // If this happens, I have to set some value. I consider this
-  // a configuration error, but I wont exit here.
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
-                  " last value!"
-               << std::endl;
-#else
-  sif::printWarning(
-      "LocalPoolVector: Invalid index. Setting or returning"
-      " last value!\n");
-#endif
-  return value[vectorSize - 1];
-}
-
-template <typename T, uint16_t vectorSize>
-inline const T& LocalPoolVector<T, vectorSize>::operator[](size_t i) const {
-  if (i < vectorSize) {
-    return value[i];
-  }
-  // If this happens, I have to set some value. I consider this
-  // a configuration error, but I wont exit here.
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
-                  " last value!"
-               << std::endl;
-#else
-  sif::printWarning(
-      "LocalPoolVector: Invalid index. Setting or returning"
-      " last value!\n");
-#endif
-  return value[vectorSize - 1];
-}
-
-template <typename T, uint16_t vectorSize>
-inline ReturnValue_t LocalPoolVector<T, vectorSize>::serialize(
-    uint8_t** buffer, size_t* size, size_t maxSize,
-    SerializeIF::Endianness streamEndianness) const {
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-  for (uint16_t i = 0; i < vectorSize; i++) {
-    result = SerializeAdapter::serialize(&(value[i]), buffer, size, maxSize, streamEndianness);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-      break;
-    }
-  }
-  return result;
-}
-
-template <typename T, uint16_t vectorSize>
+template<typename T, uint16_t vectorSize>
 inline size_t LocalPoolVector<T, vectorSize>::getSerializedSize() const {
-  return vectorSize * SerializeAdapter::getSerializedSize(value);
+    return vectorSize * SerializeAdapter::getSerializedSize(value);
 }

-template <typename T, uint16_t vectorSize>
+template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::deSerialize(
-    const uint8_t** buffer, size_t* size, SerializeIF::Endianness streamEndianness) {
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-  for (uint16_t i = 0; i < vectorSize; i++) {
-    result = SerializeAdapter::deSerialize(&(value[i]), buffer, size, streamEndianness);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-      break;
+        const uint8_t** buffer, size_t* size,
+        SerializeIF::Endianness streamEndianness) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    for (uint16_t i = 0; i < vectorSize; i++) {
+        result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
+                streamEndianness);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            break;
+        }
    }
-  }
-  return result;
+    return result;
 }

 #if FSFW_CPP_OSTREAM_ENABLED == 1
-template <typename T, uint16_t vectorSize>
-inline std::ostream& operator<<(std::ostream& out, const LocalPoolVector<T, vectorSize>& var) {
-  out << "Vector: [";
-  for (int i = 0; i < vectorSize; i++) {
-    out << var.value[i];
-    if (i < vectorSize - 1) {
-      out << ", ";
+template<typename T, uint16_t vectorSize>
+inline std::ostream& operator<< (std::ostream &out,
+        const LocalPoolVector<T, vectorSize> &var) {
+    out << "Vector: [";
+    for(int i = 0;i < vectorSize; i++) {
+        out << var.value[i];
+        if(i < vectorSize - 1) {
+            out << ", ";
+        }
    }
-  }
-  out << "]";
-  return out;
+    out << "]";
+    return out;
 }
 #endif

--- a/src/fsfw/devicehandlers/AssemblyBase.cpp
+++ b/src/fsfw/devicehandlers/AssemblyBase.cpp
@@ -26,7 +26,11 @@ void AssemblyBase::performChildOperation() {

 void AssemblyBase::startTransition(Mode_t mode, Submode_t submode) {
  doStartTransition(mode, submode);
-  triggerModeHelperEvents(mode, submode);
+  if (modeHelper.isForced()) {
+    triggerEvent(FORCING_MODE, mode, submode);
+  } else {
+    triggerEvent(CHANGING_MODE, mode, submode);
+  }
 }

 void AssemblyBase::doStartTransition(Mode_t mode, Submode_t submode) {
@@ -73,10 +77,9 @@ bool AssemblyBase::handleChildrenChangedHealth() {
  }
  HealthState healthState = healthHelper.healthTable->getHealth(iter->first);
  if (healthState == HasHealthIF::NEEDS_RECOVERY) {
-    triggerEvent(TRYING_RECOVERY, iter->first, 0);
+    triggerEvent(TRYING_RECOVERY);
    recoveryState = RECOVERY_STARTED;
    recoveringDevice = iter;
-    // The user needs to take care of commanding the children off in commandChildren
    doStartTransition(targetMode, targetSubmode);
  } else {
    triggerEvent(CHILD_CHANGED_HEALTH);
@@ -225,9 +228,6 @@ ReturnValue_t AssemblyBase::handleHealthReply(CommandMessage* message) {
 bool AssemblyBase::checkAndHandleRecovery() {
  switch (recoveryState) {
    case RECOVERY_STARTED:
-      // The recovery was already start in #handleChildrenChangedHealth and we just need
-      // to wait for an off time period.
-      // TODO: make time period configurable
      recoveryState = RECOVERY_WAIT;
      recoveryOffTimer.resetTimer();
      return true;
@@ -266,11 +266,3 @@ void AssemblyBase::overwriteDeviceHealth(object_id_t objectId, HasHealthIF::Heal
  modeHelper.setForced(true);
  sendHealthCommand(childrenMap[objectId].commandQueue, EXTERNAL_CONTROL);
 }
-
-void AssemblyBase::triggerModeHelperEvents(Mode_t mode, Submode_t submode) {
-  if (modeHelper.isForced()) {
-    triggerEvent(FORCING_MODE, mode, submode);
-  } else {
-    triggerEvent(CHANGING_MODE, mode, submode);
-  }
-}
--- a/src/fsfw/devicehandlers/AssemblyBase.h
+++ b/src/fsfw/devicehandlers/AssemblyBase.h
@@ -12,8 +12,7 @@
 * Documentation: Dissertation Baetz p.156, 157.
 *
 * This class reduces the complexity of controller components which would
- * otherwise be needed for the handling of redundant devices. However, it can also be used to
- * manage the mode keeping and recovery of non-redundant devices
+ * otherwise be needed for the handling of redundant devices.
 *
 * The template class monitors mode and health state of its children
 * and checks availability of devices on every detected change.
@@ -27,9 +26,11 @@
 *
 * Important:
 *
- * The implementation must call #registerChild for all commanded children during initialization.
+ * The implementation must call registerChild(object_id_t child)
+ * for all commanded children during initialization.
 * The implementation must call the initialization function of the base class.
 * (This will call the function in SubsystemBase)
+ *
 */
 class AssemblyBase : public SubsystemBase {
 public:
@@ -46,14 +47,13 @@ class AssemblyBase : public SubsystemBase {

 protected:
  /**
-   * Command children to reach [mode,submode] combination. Can be done by setting
-   * #commandsOutstanding correctly, or using #executeTable. In case of an FDIR recovery,
-   * the user needs to ensure that the target devices are healthy. If a device is not healthy,
-   * a recovery might be on-going and the device needs to be commanded to off first.
+   * Command children to reach [mode,submode] combination
+   * Can be done by setting #commandsOutstanding correctly,
+   * or using executeTable()
   * @param mode
   * @param submode
   * @return
-   *    - @c RETURN_OK if OK
+   *    - @c RETURN_OK if ok
   *    - @c NEED_SECOND_STEP if children need to be commanded again
   */
  virtual ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) = 0;
@@ -120,19 +120,8 @@ class AssemblyBase : public SubsystemBase {

  virtual ReturnValue_t handleHealthReply(CommandMessage *message);

-  /**
-   * @brief Default periodic handler
-   * @details
-   * This is the default periodic handler which will be called by the SubsystemBase
-   * performOperation. It performs the child transitions or reacts to changed health/mode states
-   * of children objects
-   */
-  virtual void performChildOperation() override;
+  virtual void performChildOperation();

-  /**
-   * This function handles changed mode or health states of children
-   * @return
-   */
  bool handleChildrenChanged();

  /**
@@ -145,37 +134,12 @@ class AssemblyBase : public SubsystemBase {

  bool handleChildrenChangedHealth();

-  /**
-   * Core transition handler. The default implementation will only do something if
-   * #commandsOutstanding is smaller or equal to zero, which means that all mode commands
-   * from the #doPerformTransition call were executed successfully.
-   *
-   * Unless a second step was requested, the function will then use #checkChildrenState to
-   * determine whether the target mode was reached.
-   *
-   * There is some special handling for certain (internal) modes:
-   *  - A second step is necessary. #commandChildren will be performed again
-   *  - The device health was overwritten. #commandChildren will be called
-   *  - A recovery is ongoing. #checkAndHandleRecovery will be called.
-   */
  virtual void handleChildrenTransition();

  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode, uint32_t *msToReachTheMode);

-  /**
-   * Calls #doStartTransition and triggers an informative event as well that the mode will
-   * change
-   * @param mode
-   * @param submode
-   */
  virtual void startTransition(Mode_t mode, Submode_t submode);

-  /**
-   * This function starts the transition by setting the internal #targetSubmode and #targetMode
-   * variables and then calling the #commandChildren function.
-   * @param mode
-   * @param submode
-   */
  virtual void doStartTransition(Mode_t mode, Submode_t submode);

  virtual bool isInTransition();
@@ -196,7 +160,7 @@ class AssemblyBase : public SubsystemBase {
   * Manages recovery of a device
   * @return true if recovery is still ongoing, false else.
   */
-  virtual bool checkAndHandleRecovery();
+  bool checkAndHandleRecovery();

  /**
   * Helper method to overwrite health state of one of the children.
@@ -204,8 +168,6 @@ class AssemblyBase : public SubsystemBase {
   * @param objectId Must be a registered child.
   */
  void overwriteDeviceHealth(object_id_t objectId, HasHealthIF::HealthState oldHealth);
-
-  void triggerModeHelperEvents(Mode_t mode, Submode_t submode);
 };

 #endif /* FSFW_DEVICEHANDLERS_ASSEMBLYBASE_H_ */
--- a/src/fsfw/devicehandlers/DeviceHandlerBase.cpp
+++ b/src/fsfw/devicehandlers/DeviceHandlerBase.cpp
@@ -39,9 +39,8 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, object_id_t device
      childTransitionDelay(5000),
      transitionSourceMode(_MODE_POWER_DOWN),
      transitionSourceSubMode(SUBMODE_NONE) {
-  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
  commandQueue = QueueFactory::instance()->createMessageQueue(
-      cmdQueueSize, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+      cmdQueueSize, MessageQueueMessage::MAX_MESSAGE_SIZE);
  insertInCommandMap(RAW_COMMAND_ID);
  cookieInfo.state = COOKIE_UNUSED;
  cookieInfo.pendingCommand = deviceCommandMap.end();
@@ -49,6 +48,9 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, object_id_t device
    printWarningOrError(sif::OutputTypes::OUT_ERROR, "DeviceHandlerBase",
                        HasReturnvaluesIF::RETURN_FAILED, "Invalid cookie");
  }
+  if (this->fdirInstance == nullptr) {
+    this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId, defaultFdirParentId);
+  }
 }

 void DeviceHandlerBase::setHkDestination(object_id_t hkDestination) {
@@ -124,18 +126,6 @@ ReturnValue_t DeviceHandlerBase::initialize() {
  if (result != RETURN_OK) {
    return result;
  }
-  if (this->fdirInstance == nullptr) {
-    this->fdirInstance =
-        new DeviceHandlerFailureIsolation(this->getObjectId(), defaultFdirParentId);
-  }
-
-  if (this->parent != objects::NO_OBJECT) {
-    HasModesIF* modeIF = ObjectManager::instance()->get<HasModesIF>(this->parent);
-    HasHealthIF* healthIF = ObjectManager::instance()->get<HasHealthIF>(this->parent);
-    if (modeIF != nullptr and healthIF != nullptr) {
-      setParentQueue(modeIF->getCommandQueue());
-    }
-  }

  communicationInterface =
      ObjectManager::instance()->get<DeviceCommunicationIF>(deviceCommunicationId);
@@ -243,28 +233,17 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 }

 void DeviceHandlerBase::decrementDeviceReplyMap() {
-  bool timedOut = false;
  for (std::pair<const DeviceCommandId_t, DeviceReplyInfo>& replyPair : deviceReplyMap) {
-    if (replyPair.second.countdown != nullptr && replyPair.second.active) {
-      if (replyPair.second.countdown->hasTimedOut()) {
-        timedOut = true;
-      }
-    }
-    if (replyPair.second.delayCycles != 0 && replyPair.second.countdown == nullptr) {
+    if (replyPair.second.delayCycles != 0) {
      replyPair.second.delayCycles--;
      if (replyPair.second.delayCycles == 0) {
        if (replyPair.second.periodic) {
          replyPair.second.delayCycles = replyPair.second.maxDelayCycles;
        }
-        timedOut = true;
+        replyToReply(replyPair.first, replyPair.second, TIMEOUT);
+        missedReply(replyPair.first);
      }
    }
-    if (timedOut) {
-      replyToReply(replyPair.first, replyPair.second, TIMEOUT);
-      missedReply(replyPair.first);
-      timedOut = false;
-      replyPair.second.active = false;
-    }
  }
 }

@@ -373,12 +352,14 @@ void DeviceHandlerBase::doStateMachine() {
      }
    } break;
    case _MODE_WAIT_OFF: {
+      uint32_t currentUptime;
+      Clock::getUptime(&currentUptime);
+
      if (powerSwitcher == nullptr) {
        setMode(MODE_OFF);
        break;
      }
-      uint32_t currentUptime;
-      Clock::getUptime(&currentUptime);
+
      if (currentUptime - timeoutStart >= powerSwitcher->getSwitchDelayMs()) {
        triggerEvent(MODE_TRANSITION_FAILED, PowerSwitchIF::SWITCH_TIMEOUT, 0);
        setMode(MODE_ERROR_ON);
@@ -427,22 +408,20 @@ ReturnValue_t DeviceHandlerBase::isModeCombinationValid(Mode_t mode, Submode_t s

 ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(
    DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles, LocalPoolDataSetBase* replyDataSet,
-    size_t replyLen, bool periodic, bool hasDifferentReplyId, DeviceCommandId_t replyId,
-    Countdown* countdown) {
+    size_t replyLen, bool periodic, bool hasDifferentReplyId, DeviceCommandId_t replyId) {
  // No need to check, as we may try to insert multiple times.
  insertInCommandMap(deviceCommand, hasDifferentReplyId, replyId);
  if (hasDifferentReplyId) {
-    return insertInReplyMap(replyId, maxDelayCycles, replyDataSet, replyLen, periodic, countdown);
+    return insertInReplyMap(replyId, maxDelayCycles, replyDataSet, replyLen, periodic);
  } else {
-    return insertInReplyMap(deviceCommand, maxDelayCycles, replyDataSet, replyLen, periodic,
-                            countdown);
+    return insertInReplyMap(deviceCommand, maxDelayCycles, replyDataSet, replyLen, periodic);
  }
 }

 ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
                                                  uint16_t maxDelayCycles,
                                                  LocalPoolDataSetBase* dataSet, size_t replyLen,
-                                                  bool periodic, Countdown* countdown) {
+                                                  bool periodic) {
  DeviceReplyInfo info;
  info.maxDelayCycles = maxDelayCycles;
  info.periodic = periodic;
@@ -450,10 +429,6 @@ ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
  info.replyLen = replyLen;
  info.dataSet = dataSet;
  info.command = deviceCommandMap.end();
-  info.countdown = countdown;
-  if (info.periodic) {
-    info.active = true;
-  }
  auto resultPair = deviceReplyMap.emplace(replyId, info);
  if (resultPair.second) {
    return RETURN_OK;
@@ -489,8 +464,7 @@ size_t DeviceHandlerBase::getNextReplyLength(DeviceCommandId_t commandId) {
  }
  DeviceReplyIter iter = deviceReplyMap.find(replyId);
  if (iter != deviceReplyMap.end()) {
-    if ((iter->second.delayCycles != 0 && iter->second.countdown == nullptr) ||
-        (iter->second.active && iter->second.countdown != nullptr)) {
+    if (iter->second.delayCycles != 0) {
      return iter->second.replyLen;
    }
  }
@@ -834,18 +808,17 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData, DeviceCommandId

  DeviceReplyInfo* info = &(iter->second);

-  if ((info->delayCycles != 0 && info->countdown == nullptr) ||
-      (info->active && info->countdown != nullptr)) {
+  if (info->delayCycles != 0) {
    result = interpretDeviceReply(foundId, receivedData);

    if (result == IGNORE_REPLY_DATA) {
      return;
    }

-    if (info->active && info->countdown != nullptr) {
-      disableTimeoutControlledReply(info);
-    } else if (info->delayCycles != 0) {
-      disableDelayCyclesControlledReply(info);
+    if (info->periodic) {
+      info->delayCycles = info->maxDelayCycles;
+    } else {
+      info->delayCycles = 0;
    }

    if (result != RETURN_OK) {
@@ -864,24 +837,6 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData, DeviceCommandId
  }
 }

-void DeviceHandlerBase::disableTimeoutControlledReply(DeviceReplyInfo* info) {
-  if (info->periodic) {
-    info->countdown->resetTimer();
-  } else {
-    info->active = false;
-    info->countdown->timeOut();
-  }
-}
-
-void DeviceHandlerBase::disableDelayCyclesControlledReply(DeviceReplyInfo* info) {
-  if (info->periodic) {
-    info->delayCycles = info->maxDelayCycles;
-  } else {
-    info->delayCycles = 0;
-    info->active = false;
-  }
-}
-
 ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress, uint8_t** data,
                                                size_t* len) {
  size_t lenTmp;
@@ -1007,10 +962,6 @@ ReturnValue_t DeviceHandlerBase::enableReplyInReplyMap(DeviceCommandMap::iterato
    info->delayCycles = info->maxDelayCycles;
    info->command = command;
    command->second.expectedReplies = expectedReplies;
-    if (info->countdown != nullptr) {
-      info->countdown->resetTimer();
-    }
-    info->active = true;
    return RETURN_OK;
  } else {
    return NO_REPLY_EXPECTED;
@@ -1245,8 +1196,7 @@ void DeviceHandlerBase::setParentQueue(MessageQueueId_t parentQueueId) {
 bool DeviceHandlerBase::isAwaitingReply() {
  std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter;
  for (iter = deviceReplyMap.begin(); iter != deviceReplyMap.end(); ++iter) {
-    if ((iter->second.delayCycles != 0 && iter->second.countdown == nullptr) ||
-        (iter->second.active && iter->second.countdown != nullptr)) {
+    if (iter->second.delayCycles != 0) {
      return true;
    }
  }
@@ -1401,8 +1351,6 @@ uint8_t DeviceHandlerBase::getReplyDelayCycles(DeviceCommandId_t deviceCommand)
  DeviceReplyMap::iterator iter = deviceReplyMap.find(deviceCommand);
  if (iter == deviceReplyMap.end()) {
    return 0;
-  } else if (iter->second.countdown != nullptr) {
-    return 0;
  }
  return iter->second.delayCycles;
 }
@@ -1451,8 +1399,6 @@ void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task) { executingTask = task;
 void DeviceHandlerBase::debugInterface(uint8_t positionTracker, object_id_t objectId,
                                       uint32_t parameter) {}

-Submode_t DeviceHandlerBase::getInitialSubmode() { return SUBMODE_NONE; }
-
 void DeviceHandlerBase::performOperationHook() {}

 ReturnValue_t DeviceHandlerBase::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
@@ -1475,7 +1421,7 @@ ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
  this->poolManager.initializeAfterTaskCreation();

  if (setStartupImmediately) {
-    startTransition(MODE_ON, getInitialSubmode());
+    startTransition(MODE_ON, SUBMODE_NONE);
  }
  return HasReturnvaluesIF::RETURN_OK;
 }
@@ -1559,11 +1505,3 @@ MessageQueueId_t DeviceHandlerBase::getCommanderQueueId(DeviceCommandId_t replyI
  }
  return commandIter->second.sendReplyTo;
 }
-
-void DeviceHandlerBase::setCustomFdir(FailureIsolationBase* fdir) { this->fdirInstance = fdir; }
-
-void DeviceHandlerBase::setParent(object_id_t parent) { this->parent = parent; }
-
-void DeviceHandlerBase::setPowerSwitcher(PowerSwitchIF* switcher) {
-  this->powerSwitcher = switcher;
-}
--- a/src/fsfw/devicehandlers/DeviceHandlerBase.h
+++ b/src/fsfw/devicehandlers/DeviceHandlerBase.h
@@ -103,9 +103,6 @@ class DeviceHandlerBase : public DeviceHandlerIF,
  DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication, CookieIF *comCookie,
                    FailureIsolationBase *fdirInstance = nullptr, size_t cmdQueueSize = 20);

-  void setCustomFdir(FailureIsolationBase *fdir);
-  void setParent(object_id_t parent);
-  void setPowerSwitcher(PowerSwitchIF *switcher);
  void setHkDestination(object_id_t hkDestination);

  /**
@@ -451,9 +448,6 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   * by the device repeatedly without request) or not. Default is aperiodic (0).
   * Please note that periodic replies are disabled by default. You can enable them with
   * #updatePeriodicReply
-   * @param countdown Instead of using maxDelayCycles to timeout a device reply it is also possible
-   *                  to provide a pointer to a Countdown object which will signal the timeout
-   *                  when expired
   * @return	- @c RETURN_OK when the command was successfully inserted,
   *          - @c RETURN_FAILED else.
   */
@@ -461,26 +455,22 @@ class DeviceHandlerBase : public DeviceHandlerIF,
                                           LocalPoolDataSetBase *replyDataSet = nullptr,
                                           size_t replyLen = 0, bool periodic = false,
                                           bool hasDifferentReplyId = false,
-                                           DeviceCommandId_t replyId = 0,
-                                           Countdown *countdown = nullptr);
+                                           DeviceCommandId_t replyId = 0);
  /**
   * @brief 	This is a helper method to insert replies in the reply map.
   * @param deviceCommand	Identifier of the reply to add.
   * @param maxDelayCycles The maximum number of delay cycles the reply waits
-   *    until it times out.
+   * until it times out.
   * @param periodic	Indicates if the command is periodic (i.e. it is sent
-   *    by the device repeatedly without request) or not. Default is aperiodic (0).
-   *    Please note that periodic replies are disabled by default. You can enable them with
-   *    #updatePeriodicReply
-   * @param countdown Instead of using maxDelayCycles to timeout a device reply it is also possible
-   *    to provide a pointer to a Countdown object which will signal the timeout
-   *    when expired
+   * by the device repeatedly without request) or not. Default is aperiodic (0).
+   * Please note that periodic replies are disabled by default. You can enable them with
+   * #updatePeriodicReply
   * @return	- @c RETURN_OK when the command was successfully inserted,
   *          - @c RETURN_FAILED else.
   */
  ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles,
                                 LocalPoolDataSetBase *dataSet = nullptr, size_t replyLen = 0,
-                                 bool periodic = false, Countdown *countdown = nullptr);
+                                 bool periodic = false);

  /**
   * @brief   A simple command to add a command to the commandList.
@@ -659,12 +649,6 @@ class DeviceHandlerBase : public DeviceHandlerIF,
  virtual void debugInterface(uint8_t positionTracker = 0, object_id_t objectId = 0,
                              uint32_t parameter = 0);

-  /**
-   * @brief Can be overwritten by a child to specify the initial submode when device has been set
-   *        to startup immediately.
-   */
-  virtual Submode_t getInitialSubmode();
-
 protected:
  static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;

@@ -783,18 +767,11 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   * This is used to keep track of pending replies.
   */
  struct DeviceReplyInfo {
-    //! For Command-Reply combinations:
    //! The maximum number of cycles the handler should wait for a reply
    //! to this command.
-    //!
-    //! Reply Only:
-    //! For periodic replies, this variable will be the number of delay cycles between the replies.
-    //! For the non-periodic variant, this variable is not used as there is no meaningful
-    //! definition for delay
    uint16_t maxDelayCycles;
-    //! This variable will be set to #maxDelayCycles if a reply is expected.
-    //! For non-periodic replies without a command, this variable is unused.
-    //! A runtime value of 0 means there is no reply is currently expected.
+    //! The currently remaining cycles the handler should wait for a reply,
+    //! 0 means there is no reply expected
    uint16_t delayCycles;
    size_t replyLen = 0;  //!< Expected size of the reply.
    //! if this is !=0, the delayCycles will not be reset to 0 but to
@@ -806,11 +783,6 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    LocalPoolDataSetBase *dataSet = nullptr;
    //! The command that expects this reply.
    DeviceCommandMap::iterator command;
-    //! Instead of using delayCycles to specify the maximum time to wait for the device reply, it
-    //! is also possible specify a countdown
-    Countdown *countdown = nullptr;
-    //! will be set to true when reply is enabled
-    bool active = false;
  };

  using DeviceReplyMap = std::map<DeviceCommandId_t, DeviceReplyInfo>;
@@ -850,7 +822,6 @@ class DeviceHandlerBase : public DeviceHandlerIF,
  /** Pointer to the used FDIR instance. If not provided by child,
   * default class is instantiated. */
  FailureIsolationBase *fdirInstance;
-  object_id_t parent = objects::NO_OBJECT;

  //! To correctly delete the default instance.
  bool defaultFDIRUsed;
@@ -1273,17 +1244,6 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   */
  void doGetRead(void);

-  /**
-   * @brief Handles disabling of replies which use a timeout to detect missed replies.
-   */
-  void disableTimeoutControlledReply(DeviceReplyInfo *info);
-
-  /**
-   * @brief Handles disabling of replies which use a number of maximum delay cycles to detect
-   *        missed replies.
-   */
-  void disableDelayCyclesControlledReply(DeviceReplyInfo *info);
-
  /**
   * Retrive data from the #IPCStore.
   *
--- a/src/fsfw/devicehandlers/DeviceHandlerFailureIsolation.cpp
+++ b/src/fsfw/devicehandlers/DeviceHandlerFailureIsolation.cpp
@@ -29,7 +29,6 @@ ReturnValue_t DeviceHandlerFailureIsolation::eventReceived(EventMessage* event)
  switch (event->getEvent()) {
    case HasModesIF::MODE_TRANSITION_FAILED:
    case HasModesIF::OBJECT_IN_INVALID_MODE:
-    case DeviceHandlerIF::DEVICE_WANTS_HARD_REBOOT:
      // We'll try a recovery as long as defined in MAX_REBOOT.
      // Might cause some AssemblyBase cycles, so keep number low.
      handleRecovery(event->getEvent());
--- a/src/fsfw/devicehandlers/DeviceHandlerIF.h
+++ b/src/fsfw/devicehandlers/DeviceHandlerIF.h
@@ -109,7 +109,6 @@ class DeviceHandlerIF {
  static const Event INVALID_DEVICE_COMMAND = MAKE_EVENT(8, severity::LOW);
  static const Event MONITORING_LIMIT_EXCEEDED = MAKE_EVENT(9, severity::LOW);
  static const Event MONITORING_AMBIGUOUS = MAKE_EVENT(10, severity::HIGH);
-  static const Event DEVICE_WANTS_HARD_REBOOT = MAKE_EVENT(11, severity::HIGH);

  static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;

--- a/src/fsfw/devicehandlers/HealthDevice.cpp
+++ b/src/fsfw/devicehandlers/HealthDevice.cpp
@@ -8,9 +8,7 @@ HealthDevice::HealthDevice(object_id_t setObjectId, MessageQueueId_t parentQueue
      parentQueue(parentQueue),
      commandQueue(),
      healthHelper(this, setObjectId) {
-  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
-  commandQueue = QueueFactory::instance()->createMessageQueue(
-      3, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  commandQueue = QueueFactory::instance()->createMessageQueue(3);
 }

 HealthDevice::~HealthDevice() { QueueFactory::instance()->deleteMessageQueue(commandQueue); }
--- a/src/fsfw/events/EventManager.cpp
+++ b/src/fsfw/events/EventManager.cpp
@@ -18,9 +18,8 @@ const LocalPool::LocalPoolConfig EventManager::poolConfig = {
 EventManager::EventManager(object_id_t setObjectId)
    : SystemObject(setObjectId), factoryBackend(0, poolConfig, false, true) {
  mutex = MutexFactory::instance()->createMutex();
-  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
-  eventReportQueue = QueueFactory::instance()->createMessageQueue(
-      MAX_EVENTS_PER_CYCLE, EventMessage::EVENT_MESSAGE_SIZE, &mqArgs);
+  eventReportQueue = QueueFactory::instance()->createMessageQueue(MAX_EVENTS_PER_CYCLE,
+                                                                  EventMessage::EVENT_MESSAGE_SIZE);
 }

 EventManager::~EventManager() {
@@ -47,20 +46,9 @@ ReturnValue_t EventManager::performOperation(uint8_t opCode) {

 void EventManager::notifyListeners(EventMessage* message) {
  lockMutex();
-  for (auto& listener : listenerList) {
-    if (listener.second.match(message)) {
-      ReturnValue_t result =
-          MessageQueueSenderIF::sendMessage(listener.first, message, message->getSender());
-      if (result != HasReturnvaluesIF::RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << std::hex << "EventManager::notifyListeners: MSG to 0x" << std::setfill('0')
-                   << std::setw(8) << listener.first << " failed with result 0x" << std::setw(4)
-                   << result << std::setfill(' ') << std::endl;
-#else
-        sif::printError("Sending message to listener 0x%08x failed with result %04x\n",
-                        listener.first, result);
-#endif
-      }
+  for (auto iter = listenerList.begin(); iter != listenerList.end(); ++iter) {
+    if (iter->second.match(message)) {
+      MessageQueueSenderIF::sendMessage(iter->first, message, message->getSender());
    }
  }
  unlockMutex();
@@ -201,19 +189,4 @@ void EventManager::printUtility(sif::OutputTypes printType, EventMessage* messag
  }
 }

-void EventManager::printListeners() {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::info << "Event manager listener MQ IDs:" << std::setfill('0') << std::hex << std::endl;
-  for (auto& listener : listenerList) {
-    sif::info << "0x" << std::setw(8) << listener.first << std::endl;
-  }
-  sif::info << std::dec << std::setfill(' ');
-#else
-  sif::printInfo("Event manager listener MQ IDs:\n");
-  for (auto& listener : listenerList) {
-    sif::printInfo("0x%08x\n", listener.first);
-  }
-#endif
-}
-
 #endif /* FSFW_OBJ_EVENT_TRANSLATION == 1 */
--- a/src/fsfw/events/EventManager.h
+++ b/src/fsfw/events/EventManager.h
@@ -42,7 +42,6 @@ class EventManager : public EventManagerIF, public ExecutableObjectIF, public Sy
                                          object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
                                          bool reporterInverted = false);
  ReturnValue_t performOperation(uint8_t opCode);
-  void printListeners();

 protected:
  MessageQueueIF* eventReportQueue = nullptr;
--- a/src/fsfw/fdir/FailureIsolationBase.cpp
+++ b/src/fsfw/fdir/FailureIsolationBase.cpp
@@ -9,9 +9,8 @@
 FailureIsolationBase::FailureIsolationBase(object_id_t owner, object_id_t parent,
                                           uint8_t messageDepth, uint8_t parameterDomainBase)
    : ownerId(owner), faultTreeParent(parent), parameterDomainBase(parameterDomainBase) {
-  auto mqArgs = MqArgs(owner, static_cast<void*>(this));
-  eventQueue = QueueFactory::instance()->createMessageQueue(
-      messageDepth, EventMessage::EVENT_MESSAGE_SIZE, &mqArgs);
+  eventQueue =
+      QueueFactory::instance()->createMessageQueue(messageDepth, EventMessage::EVENT_MESSAGE_SIZE);
 }

 FailureIsolationBase::~FailureIsolationBase() {
@@ -52,12 +51,11 @@ ReturnValue_t FailureIsolationBase::initialize() {
        ObjectManager::instance()->get<ConfirmsFailuresIF>(faultTreeParent);
    if (parentIF == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::error << "FailureIsolationBase::intialize: Parent object "
-                 << "invalid" << std::endl;
-      sif::error << "Make sure it implements ConfirmsFailuresIF" << std::endl;
-#else
-      sif::printError("FailureIsolationBase::intialize: Parent object invalid\n");
-      sif::printError("Make sure it implements ConfirmsFailuresIF\n");
+      sif::error << "FailureIsolationBase::intialize: Parent object"
+                 << "invalid." << std::endl;
+#endif
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::error << "Make sure it implements ConfirmsFailuresIF." << std::endl;
 #endif
      return ObjectManagerIF::CHILD_INIT_FAILED;
      return RETURN_FAILED;
--- a/src/fsfw/fdir/FailureIsolationBase.h
+++ b/src/fsfw/fdir/FailureIsolationBase.h
@@ -14,12 +14,13 @@ class FailureIsolationBase : public HasReturnvaluesIF,
                             public HasParametersIF {
 public:
  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FDIR_1;
-  //! FDIR has an internal state, which changed from par2 (oldState) to par1 (newState).
-  static const Event FDIR_CHANGED_STATE = MAKE_EVENT(1, severity::INFO);
-  //! FDIR tries to restart device. Par1: event that caused recovery.
-  static const Event FDIR_STARTS_RECOVERY = MAKE_EVENT(2, severity::MEDIUM);
-  //! FDIR turns off device. Par1: event that caused recovery.
-  static const Event FDIR_TURNS_OFF_DEVICE = MAKE_EVENT(3, severity::MEDIUM);
+  static const Event FDIR_CHANGED_STATE =
+      MAKE_EVENT(1, severity::INFO);  //!< FDIR has an internal state, which changed from par2
+                                      //!< (oldState) to par1 (newState).
+  static const Event FDIR_STARTS_RECOVERY = MAKE_EVENT(
+      2, severity::MEDIUM);  //!< FDIR tries to restart device. Par1: event that caused recovery.
+  static const Event FDIR_TURNS_OFF_DEVICE = MAKE_EVENT(
+      3, severity::MEDIUM);  //!< FDIR turns off device. Par1: event that caused recovery.

  FailureIsolationBase(object_id_t owner, object_id_t parent = objects::NO_OBJECT,
                       uint8_t messageDepth = 10, uint8_t parameterDomainBase = 0xF0);
--- a/src/fsfw/globalfunctions/CMakeLists.txt
+++ b/src/fsfw/globalfunctions/CMakeLists.txt
@@ -1,13 +1,13 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
-    arrayprinter.cpp
-    AsciiConverter.cpp
-    CRC.cpp
-    DleEncoder.cpp
-    DleParser.cpp
-    PeriodicOperationDivider.cpp
-    timevalOperations.cpp
-    Type.cpp
-    bitutility.cpp
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		arrayprinter.cpp
+		AsciiConverter.cpp
+		CRC.cpp
+		DleEncoder.cpp
+		PeriodicOperationDivider.cpp
+		timevalOperations.cpp
+		Type.cpp
+		bitutility.cpp
 )

 add_subdirectory(math)
--- a/src/fsfw/globalfunctions/DleParser.cpp
+++ b/src/fsfw/globalfunctions/DleParser.cpp
@@ -1,231 +0,0 @@
-#include "DleParser.h"
-
-#include <fsfw/globalfunctions/DleEncoder.h>
-#include <fsfw/serviceinterface/ServiceInterface.h>
-
-#include <cstdio>
-
-DleParser::DleParser(SimpleRingBuffer& decodeRingBuf, DleEncoder& decoder, BufPair encodedBuf,
-                     BufPair decodedBuf, UserHandler handler, void* args)
-    : decodeRingBuf(decodeRingBuf),
-      decoder(decoder),
-      encodedBuf(encodedBuf),
-      decodedBuf(decodedBuf),
-      handler(handler),
-      ctx(args) {
-  if (handler == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "DleParser::DleParser: Invalid user handler" << std::endl;
-#else
-    sif::printError("DleParser::DleParser: Invalid user handler\n");
-#endif
-  }
-}
-
-ReturnValue_t DleParser::passData(uint8_t* data, size_t len) {
-  if (data == nullptr or len == 0 or handler == nullptr) {
-    return RETURN_FAILED;
-  }
-  size_t copyIntoRingBufFromHere = 0;
-  size_t copyAmount = len;
-  size_t startIdx = 0;
-  ReturnValue_t result = RETURN_OK;
-  bool startFoundInThisPacket = false;
-  for (size_t idx = 0; idx < len; idx++) {
-    if (data[idx] == DleEncoder::STX_CHAR) {
-      if (not startFound and not startFoundInThisPacket) {
-        startIdx = idx;
-        copyIntoRingBufFromHere = idx;
-        copyAmount = len - idx;
-      } else {
-        // Maybe print warning, should not happen
-        decodeRingBuf.clear();
-        ErrorInfo info;
-        info.len = idx;
-        prepareErrorContext(ErrorTypes::CONSECUTIVE_STX_CHARS, info);
-        handler(ctx);
-        copyIntoRingBufFromHere = idx;
-        copyAmount = len - idx;
-      }
-      startFound = true;
-      startFoundInThisPacket = true;
-    } else if (data[idx] == DleEncoder::ETX_CHAR) {
-      if (startFoundInThisPacket) {
-        size_t readLen = 0;
-        size_t decodedLen = 0;
-        result = decoder.decode(data + startIdx, idx + 1 - startIdx, &readLen, decodedBuf.first,
-                                decodedBuf.second, &decodedLen);
-        if (result == HasReturnvaluesIF::RETURN_OK) {
-          ctx.setType(ContextType::PACKET_FOUND);
-          ctx.decodedPacket.first = decodedBuf.first;
-          ctx.decodedPacket.second = decodedLen;
-          this->handler(ctx);
-        } else if (result == DleEncoder::STREAM_TOO_SHORT) {
-          ErrorInfo info;
-          info.res = result;
-          prepareErrorContext(ErrorTypes::DECODING_BUF_TOO_SMALL, info);
-          handler(ctx);
-        } else {
-          ErrorInfo info;
-          info.res = result;
-          prepareErrorContext(ErrorTypes::DECODING_BUF_TOO_SMALL, info);
-          handler(ctx);
-        }
-        decodeRingBuf.clear();
-        if ((idx + 1) < len) {
-          copyIntoRingBufFromHere = idx + 1;
-          copyAmount = len - idx - 1;
-        } else {
-          copyAmount = 0;
-        }
-      } else if (startFound) {
-        // ETX found but STX was found in another mini packet. Reconstruct the full packet
-        // to decode it
-        result = decodeRingBuf.writeData(data, idx + 1);
-        if (result != HasReturnvaluesIF::RETURN_OK) {
-          ErrorInfo info;
-          info.res = result;
-          prepareErrorContext(ErrorTypes::RING_BUF_ERROR, info);
-          handler(ctx);
-        }
-        size_t fullEncodedLen = decodeRingBuf.getAvailableReadData();
-        if (fullEncodedLen > encodedBuf.second) {
-          ErrorInfo info;
-          info.len = fullEncodedLen;
-          prepareErrorContext(ErrorTypes::ENCODED_BUF_TOO_SMALL, info);
-          handler(ctx);
-          decodeRingBuf.clear();
-        } else {
-          size_t decodedLen = 0;
-          size_t readLen = 0;
-          decodeRingBuf.readData(encodedBuf.first, fullEncodedLen, true);
-          result = decoder.decode(encodedBuf.first, fullEncodedLen, &readLen, decodedBuf.first,
-                                  decodedBuf.second, &decodedLen);
-          if (result == HasReturnvaluesIF::RETURN_OK) {
-            if (this->handler != nullptr) {
-              ctx.setType(ContextType::PACKET_FOUND);
-              ctx.decodedPacket.first = decodedBuf.first;
-              ctx.decodedPacket.second = decodedLen;
-              this->handler(ctx);
-            }
-          } else if (result == DleEncoder::STREAM_TOO_SHORT) {
-            ErrorInfo info;
-            info.res = result;
-            prepareErrorContext(ErrorTypes::DECODING_BUF_TOO_SMALL, info);
-            handler(ctx);
-          } else {
-            ErrorInfo info;
-            info.res = result;
-            prepareErrorContext(ErrorTypes::DECODE_ERROR, info);
-            handler(ctx);
-          }
-          decodeRingBuf.clear();
-          startFound = false;
-          startFoundInThisPacket = false;
-          if ((idx + 1) < len) {
-            copyIntoRingBufFromHere = idx + 1;
-            copyAmount = len - idx - 1;
-          } else {
-            copyAmount = 0;
-          }
-        }
-      } else {
-        // End data without preceeding STX
-        ErrorInfo info;
-        info.len = idx + 1;
-        prepareErrorContext(ErrorTypes::CONSECUTIVE_ETX_CHARS, info);
-        handler(ctx);
-        decodeRingBuf.clear();
-        if ((idx + 1) < len) {
-          copyIntoRingBufFromHere = idx + 1;
-          copyAmount = len - idx - 1;
-        } else {
-          copyAmount = 0;
-        }
-      }
-      startFoundInThisPacket = false;
-      startFound = false;
-    }
-  }
-  if (copyAmount > 0) {
-    result = decodeRingBuf.writeData(data + copyIntoRingBufFromHere, copyAmount);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-      ErrorInfo info;
-      info.res = result;
-      prepareErrorContext(ErrorTypes::RING_BUF_ERROR, info);
-      handler(ctx);
-    }
-  }
-  return RETURN_OK;
-}
-
-void DleParser::defaultFoundPacketHandler(uint8_t* packet, size_t len, void* args) {
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::info << "DleParserBase::handleFoundPacket: Detected DLE packet with " << len << " bytes"
-            << std::endl;
-#else
-  sif::printInfo("DleParserBase::handleFoundPacket: Detected DLE packet with %d bytes\n", len);
-#endif
-#endif
-}
-
-void DleParser::defaultErrorHandler(ErrorTypes err, ErrorInfo ctx) {
-  switch (err) {
-    case (ErrorTypes::NONE): {
-      errorPrinter("No error");
-      break;
-    }
-    case (ErrorTypes::DECODE_ERROR): {
-      errorPrinter("Decode Error");
-      break;
-    }
-    case (ErrorTypes::RING_BUF_ERROR): {
-      errorPrinter("Ring Buffer Error");
-      break;
-    }
-    case (ErrorTypes::ENCODED_BUF_TOO_SMALL):
-    case (ErrorTypes::DECODING_BUF_TOO_SMALL): {
-      char opt[64];
-      snprintf(opt, sizeof(opt), ": Too small for packet with length %zu", ctx.len);
-      if (err == ErrorTypes::ENCODED_BUF_TOO_SMALL) {
-        errorPrinter("Encoded buf too small", opt);
-      } else {
-        errorPrinter("Decoding buf too small", opt);
-      }
-      break;
-    }
-    case (ErrorTypes::CONSECUTIVE_STX_CHARS): {
-      errorPrinter("Consecutive STX chars detected");
-      break;
-    }
-    case (ErrorTypes::CONSECUTIVE_ETX_CHARS): {
-      errorPrinter("Consecutive ETX chars detected");
-      break;
-    }
-  }
-}
-
-void DleParser::errorPrinter(const char* str, const char* opt) {
-  if (opt == nullptr) {
-    opt = "";
-  }
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::info << "DleParserBase::handleParseError: " << str << opt << std::endl;
-#else
-  sif::printInfo("DleParserBase::handleParseError: %s%s\n", str, opt);
-#endif
-#endif
-}
-
-void DleParser::prepareErrorContext(ErrorTypes err, ErrorInfo info) {
-  ctx.setType(ContextType::ERROR);
-  ctx.error.first = err;
-  ctx.error.second = info;
-}
-
-void DleParser::reset() {
-  startFound = false;
-  decodeRingBuf.clear();
-}
--- a/src/fsfw/globalfunctions/DleParser.h
+++ b/src/fsfw/globalfunctions/DleParser.h
@@ -1,127 +0,0 @@
-#ifndef MISSION_DEVICES_DLEPARSER_H_
-#define MISSION_DEVICES_DLEPARSER_H_
-
-#include <fsfw/container/SimpleRingBuffer.h>
-#include <fsfw/globalfunctions/DleEncoder.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
-
-#include <cstddef>
-#include <utility>
-
-/**
- * @brief This base helper class can be used to extract DLE encoded packets from a data stream
- * @details
- * The core API of the parser takes received packets which can contains DLE packets. The parser
- * can deal with DLE packets split across multiple packets. It does so by using a dedicated
- * decoding ring buffer. The user can process received packets and detect errors by
- * overriding two provided virtual methods. This also allows detecting multiple DLE packets
- * inside one passed packet.
- */
-class DleParser : public HasReturnvaluesIF {
- public:
-  using BufPair = std::pair<uint8_t*, size_t>;
-
-  enum class ContextType { PACKET_FOUND, ERROR };
-
-  enum class ErrorTypes {
-    NONE,
-    ENCODED_BUF_TOO_SMALL,
-    DECODING_BUF_TOO_SMALL,
-    DECODE_ERROR,
-    RING_BUF_ERROR,
-    CONSECUTIVE_STX_CHARS,
-    CONSECUTIVE_ETX_CHARS
-  };
-
-  union ErrorInfo {
-    size_t len;
-    ReturnValue_t res;
-  };
-
-  using ErrorPair = std::pair<ErrorTypes, ErrorInfo>;
-
-  struct Context {
-   public:
-    Context(void* args) : userArgs(args) { setType(ContextType::PACKET_FOUND); }
-
-    void setType(ContextType type) {
-      if (type == ContextType::PACKET_FOUND) {
-        error.first = ErrorTypes::NONE;
-        error.second.len = 0;
-      } else {
-        decodedPacket.first = nullptr;
-        decodedPacket.second = 0;
-      }
-    }
-
-    ContextType getType() const { return type; }
-
-    BufPair decodedPacket = {};
-    ErrorPair error;
-    void* userArgs;
-
-   private:
-    ContextType type;
-  };
-
-  using UserHandler = void (*)(const Context& ctx);
-
-  /**
-   * Base class constructor
-   * @param decodeRingBuf Ring buffer used to store multiple packets to allow detecting DLE packets
-   * split across multiple packets
-   * @param decoder Decoder instance
-   * @param encodedBuf Buffer used to store encoded packets. It has to be large enough to hold
-   * the largest expected encoded DLE packet size
-   * @param decodedBuf Buffer used to store decoded packets. It has to be large enough to hold the
-   * largest expected decoded DLE packet size
-   * @param handler Function which will be called on a found packet
-   * @param args Arbitrary user argument
-   */
-  DleParser(SimpleRingBuffer& decodeRingBuf, DleEncoder& decoder, BufPair encodedBuf,
-            BufPair decodedBuf, UserHandler handler, void* args);
-
-  /**
-   * This function allows to pass new data into the parser. It then scans for DLE packets
-   * automatically and inserts (part of) the packet into a ring buffer if necessary.
-   * @param data
-   * @param len
-   * @return
-   */
-  ReturnValue_t passData(uint8_t* data, size_t len);
-
-  /**
-   * Example found packet handler
-   * function call
-   * @param packet Decoded packet
-   * @param len Length of detected packet
-   */
-  void defaultFoundPacketHandler(uint8_t* packet, size_t len, void* args);
-  /**
-   * Will be called if an error occured in the #passData call
-   * @param err
-   * @param ctx Context information depending on the error type
-   *  - For buffer length errors, will be set to the detected packet length which is too large
-   *  - For decode or ring buffer errors, will be set to the result returned from the failed call
-   */
-  static void defaultErrorHandler(ErrorTypes err, ErrorInfo ctx);
-
-  static void errorPrinter(const char* str, const char* opt = nullptr);
-
-  void prepareErrorContext(ErrorTypes err, ErrorInfo ctx);
-  /**
-   * Resets the parser by resetting the internal states and clearing the decoding ring buffer
-   */
-  void reset();
-
- private:
-  SimpleRingBuffer& decodeRingBuf;
-  DleEncoder& decoder;
-  BufPair encodedBuf;
-  BufPair decodedBuf;
-  UserHandler handler = nullptr;
-  Context ctx;
-  bool startFound = false;
-};
-
-#endif /* MISSION_DEVICES_DLEPARSER_H_ */
--- a/src/fsfw/health/HasHealthIF.h
+++ b/src/fsfw/health/HasHealthIF.h
@@ -16,27 +16,26 @@ class HasHealthIF {
  };

  static const uint8_t INTERFACE_ID = CLASS_ID::HAS_HEALTH_IF;
-  static constexpr ReturnValue_t OBJECT_NOT_HEALTHY =
-      HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 1);
-  static constexpr ReturnValue_t INVALID_HEALTH_STATE =
-      HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 2);
-  static constexpr ReturnValue_t IS_EXTERNALLY_CONTROLLED =
-      HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 3);
+  static const ReturnValue_t OBJECT_NOT_HEALTHY = MAKE_RETURN_CODE(1);
+  static const ReturnValue_t INVALID_HEALTH_STATE = MAKE_RETURN_CODE(2);

  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER_1;
-  //! P1: New Health, P2: Old Health
  static const Event HEALTH_INFO = MAKE_EVENT(6, severity::INFO);
  static const Event CHILD_CHANGED_HEALTH = MAKE_EVENT(7, severity::INFO);
  static const Event CHILD_PROBLEMS = MAKE_EVENT(8, severity::LOW);
-  //! Assembly overwrites health information of children to keep satellite alive.
-  static const Event OVERWRITING_HEALTH = MAKE_EVENT(9, severity::LOW);
-  //! Someone starts a recovery of a component (typically power-cycle). No parameters.
-  static const Event TRYING_RECOVERY = MAKE_EVENT(10, severity::MEDIUM);
-  //! Recovery is ongoing. Comes twice during recovery.
-  //! P1: 0 for the first, 1 for the second event. P2: 0
-  static const Event RECOVERY_STEP = MAKE_EVENT(11, severity::MEDIUM);
-  //! Recovery was completed. Not necessarily successful. No parameters.
-  static const Event RECOVERY_DONE = MAKE_EVENT(12, severity::MEDIUM);
+  static const Event OVERWRITING_HEALTH =
+      MAKE_EVENT(9, severity::LOW);  //!< Assembly overwrites health information of children to keep
+                                     //!< satellite alive.
+  static const Event TRYING_RECOVERY =
+      MAKE_EVENT(10, severity::MEDIUM);  //!< Someone starts a recovery of a component (typically
+                                         //!< power-cycle). No parameters.
+  static const Event RECOVERY_STEP =
+      MAKE_EVENT(11, severity::MEDIUM);  //!< Recovery is ongoing. Comes twice during recovery. P1:
+                                         //!< 0 for the first, 1 for the second event. P2: 0
+  static const Event RECOVERY_DONE = MAKE_EVENT(
+      12,
+      severity::MEDIUM);  //!< Recovery was completed. Not necessarily successful. No parameters.
+
  virtual ~HasHealthIF() {}

  virtual MessageQueueId_t getCommandQueue() const = 0;
--- a/src/fsfw/internalerror/InternalErrorReporter.cpp
+++ b/src/fsfw/internalerror/InternalErrorReporter.cpp
@@ -7,13 +7,11 @@

 InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId, uint32_t messageQueueDepth)
    : SystemObject(setObjectId),
+      commandQueue(QueueFactory::instance()->createMessageQueue(messageQueueDepth)),
      poolManager(this, commandQueue),
      internalErrorSid(setObjectId, InternalErrorDataset::ERROR_SET_ID),
      internalErrorDataset(this) {
  mutex = MutexFactory::instance()->createMutex();
-  auto mqArgs = MqArgs(setObjectId, static_cast<void *>(this));
-  commandQueue = QueueFactory::instance()->createMessageQueue(
-      messageQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }

 InternalErrorReporter::~InternalErrorReporter() { MutexFactory::instance()->deleteMutex(mutex); }
@@ -38,14 +36,15 @@ ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
    if ((newQueueHits > 0) or (newTmHits > 0) or (newStoreHits > 0)) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
      sif::debug << "InternalErrorReporter::performOperation: Errors "
-                 << "occured: Queue | TM | Store : " << newQueueHits << " | " << newTmHits << " | "
-                 << newStoreHits << std::endl;
+                 << "occured!" << std::endl;
+      sif::debug << "Queue errors: " << newQueueHits << std::endl;
+      sif::debug << "TM errors: " << newTmHits << std::endl;
+      sif::debug << "Store errors: " << newStoreHits << std::endl;
 #else
-      sif::printDebug(
-          "InternalErrorReporter::performOperation: Errors occured: Queue | TM | Store: %lu | %lu "
-          "| %lu\n",
-          static_cast<unsigned int>(newQueueHits), static_cast<unsigned int>(newTmHits),
-          static_cast<unsigned int>(newStoreHits));
+      sif::printDebug("InternalErrorReporter::performOperation: Errors occured!\n");
+      sif::printDebug("Queue errors: %lu\n", static_cast<unsigned int>(newQueueHits));
+      sif::printDebug("TM errors: %lu\n", static_cast<unsigned int>(newTmHits));
+      sif::printDebug("Store errors: %lu\n", static_cast<unsigned int>(newStoreHits));
 #endif
    }
  }
--- a/src/fsfw/modes/HasModesIF.h
+++ b/src/fsfw/modes/HasModesIF.h
@@ -19,33 +19,32 @@ class HasModesIF {
  static const ReturnValue_t INVALID_SUBMODE = MAKE_RETURN_CODE(0x04);

  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER;
-  //! An object announces changing the mode. p1: target mode. p2: target submode
-  static const Event CHANGING_MODE = MAKE_EVENT(0, severity::INFO);
-  //! An Object announces its mode; parameter1 is mode, parameter2 is submode
-  static const Event MODE_INFO = MAKE_EVENT(1, severity::INFO);
+  static const Event CHANGING_MODE =
+      MAKE_EVENT(0, severity::INFO);  //!< An object announces changing the mode. p1: target mode.
+                                      //!< p2: target submode
+  static const Event MODE_INFO = MAKE_EVENT(
+      1,
+      severity::INFO);  //!< An Object announces its mode; parameter1 is mode, parameter2 is submode
  static const Event FALLBACK_FAILED = MAKE_EVENT(2, severity::HIGH);
  static const Event MODE_TRANSITION_FAILED = MAKE_EVENT(3, severity::LOW);
  static const Event CANT_KEEP_MODE = MAKE_EVENT(4, severity::HIGH);
-  //! Indicates a bug or configuration failure: Object is in a mode it should never be in.
-  static const Event OBJECT_IN_INVALID_MODE = MAKE_EVENT(5, severity::LOW);
-  //! The mode is changed, but for some reason, the change is forced, i.e. EXTERNAL_CONTROL ignored.
-  //! p1: target mode. p2: target submode
-  static const Event FORCING_MODE = MAKE_EVENT(6, severity::MEDIUM);
-  //! A mode command was rejected by the called object. Par1: called object id, Par2: return code.
-  static const Event MODE_CMD_REJECTED = MAKE_EVENT(7, severity::LOW);
+  static const Event OBJECT_IN_INVALID_MODE =
+      MAKE_EVENT(5, severity::LOW);  //!< Indicates a bug or configuration failure: Object is in a
+                                     //!< mode it should never be in.
+  static const Event FORCING_MODE = MAKE_EVENT(
+      6, severity::MEDIUM);  //!< The mode is changed, but for some reason, the change is forced,
+                             //!< i.e. EXTERNAL_CONTROL ignored. p1: target mode. p2: target submode
+  static const Event MODE_CMD_REJECTED =
+      MAKE_EVENT(7, severity::LOW);  //!< A mode command was rejected by the called object. Par1:
+                                     //!< called object id, Par2: return code.

-  //! The device is powered and ready to perform operations. In this mode, no commands are
-  //! sent by the device handler itself, but direct commands van be commanded and will be
-  //! interpreted
-  static constexpr Mode_t MODE_ON = 1;
-  //! The device is powered off. The only command accepted in this mode is a mode change to on.
-  static constexpr Mode_t MODE_OFF = 0;
-
-  static constexpr Mode_t MODE_INVALID = -1;
-  static constexpr Mode_t MODE_UNDEFINED = -2;
-
-  //! To avoid checks against magic number "0".
-  static const Submode_t SUBMODE_NONE = 0;
+  static const Mode_t MODE_ON =
+      1;  //!< The device is powered and ready to perform operations. In this mode, no commands are
+          //!< sent by the device handler itself, but direct commands van be commanded and will be
+          //!< interpreted
+  static const Mode_t MODE_OFF = 0;  //!< The device is powered off. The only command accepted in
+                                     //!< this mode is a mode change to on.
+  static const Submode_t SUBMODE_NONE = 0;  //!< To avoid checks against magic number "0".

  virtual ~HasModesIF() {}
  virtual MessageQueueId_t getCommandQueue() const = 0;
--- a/src/fsfw/objectmanager/ObjectManager.cpp
+++ b/src/fsfw/objectmanager/ObjectManager.cpp
@@ -95,16 +95,13 @@ void ObjectManager::initialize() {
  for (auto const& it : objectList) {
    result = it.second->initialize();
    if (result != RETURN_OK) {
-#if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
+      object_id_t var = it.first;
      sif::error << "ObjectManager::initialize: Object 0x" << std::hex << std::setw(8)
-                 << std::setfill('0') << it.first << " failed to initialize with code 0x" << result
-                 << std::dec << std::setfill(' ') << std::endl;
-#else
-      sif::printError(
-          "ObjectManager::initialize: Object 0x%08x failed to initialize with code 0x%04x\n", var,
-          it.first);
-#endif
+                 << std::setfill('0') << var
+                 << " failed to "
+                    "initialize with code 0x"
+                 << result << std::dec << std::setfill(' ') << std::endl;
 #endif
      errorCount++;
    }
--- a/src/fsfw/osal/common/TcpTmTcServer.cpp
+++ b/src/fsfw/osal/common/TcpTmTcServer.cpp
@@ -109,8 +109,8 @@ TcpTmTcServer::~TcpTmTcServer() { closeSocket(listenerTcpSocket); }
  using namespace tcpip;
  // If a connection is accepted, the corresponding socket will be assigned to the new socket
  socket_t connSocket = 0;
-  sockaddr clientSockAddr = {};
-  socklen_t connectorSockAddrLen = 0;
+  // sockaddr clientSockAddr = {};
+  // socklen_t connectorSockAddrLen = 0;
  int retval = 0;

  // Listen for connection requests permanently for lifetime of program
@@ -121,8 +121,8 @@ TcpTmTcServer::~TcpTmTcServer() { closeSocket(listenerTcpSocket); }
      continue;
    }

-    connSocket = accept(listenerTcpSocket, &clientSockAddr, &connectorSockAddrLen);
-    // connSocket = accept(listenerTcpSocket, nullptr, nullptr);
+    // connSocket = accept(listenerTcpSocket, &clientSockAddr, &connectorSockAddrLen);
+    connSocket = accept(listenerTcpSocket, nullptr, nullptr);

    if (connSocket == INVALID_SOCKET) {
      handleError(Protocol::TCP, ErrorSources::ACCEPT_CALL, 500);
@@ -137,7 +137,6 @@ TcpTmTcServer::~TcpTmTcServer() { closeSocket(listenerTcpSocket); }
    if (retval != 0) {
      handleError(Protocol::TCP, ErrorSources::SHUTDOWN_CALL);
    }
-
    closeSocket(connSocket);
    connSocket = 0;
  }
@@ -162,7 +161,7 @@ void TcpTmTcServer::handleServerOperation(socket_t& connSocket) {

  while (true) {
    ssize_t retval = recv(connSocket, reinterpret_cast<char*>(receptionBuffer.data()),
-                          receptionBuffer.capacity(), tcpConfig.tcpFlags);
+                      receptionBuffer.capacity(), tcpConfig.tcpFlags);
    if (retval == 0) {
      size_t availableReadData = ringBuffer.getAvailableReadData();
      if (availableReadData > lastRingBufferSize) {
@@ -286,7 +285,7 @@ ReturnValue_t TcpTmTcServer::handleTmSending(socket_t connSocket, bool& tmSent)
      arrayprinter::print(storeAccessor.data(), storeAccessor.size());
    }
    ssize_t retval = send(connSocket, reinterpret_cast<const char*>(storeAccessor.data()),
-                          storeAccessor.size(), tcpConfig.tcpTmFlags);
+                      storeAccessor.size(), tcpConfig.tcpTmFlags);
    if (retval == static_cast<int>(storeAccessor.size())) {
      // Packet sent, clear FIFO entry
      tmtcBridge->tmFifo->pop();
@@ -341,7 +340,7 @@ ReturnValue_t TcpTmTcServer::handleTcRingBufferData(size_t availableReadData) {
  size_t foundSize = 0;
  size_t readLen = 0;
  while (readLen < readAmount) {
-    if (spacePacketParser == nullptr) {
+    if(spacePacketParser == nullptr) {
      return HasReturnvaluesIF::RETURN_FAILED;
    }
    result =
--- a/src/fsfw/osal/freertos/FixedTimeslotTask.cpp
+++ b/src/fsfw/osal/freertos/FixedTimeslotTask.cpp
@@ -46,8 +46,8 @@ void FixedTimeslotTask::missedDeadlineCounter() {
  FixedTimeslotTask::deadlineMissedCount++;
  if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "PST missed " << FixedTimeslotTask::deadlineMissedCount << " deadlines"
-                 << std::endl;
+    sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount << " deadlines."
+               << std::endl;
 #endif
  }
 }
--- a/src/fsfw/osal/linux/FixedTimeslotTask.cpp
+++ b/src/fsfw/osal/linux/FixedTimeslotTask.cpp
@@ -14,8 +14,6 @@ FixedTimeslotTask::FixedTimeslotTask(const char* name_, int priority_, size_t st

 FixedTimeslotTask::~FixedTimeslotTask() {}

-bool FixedTimeslotTask::isEmpty() const { return pst.isEmpty(); }
-
 void* FixedTimeslotTask::taskEntryPoint(void* arg) {
  // The argument is re-interpreted as PollingTask.
  FixedTimeslotTask* originalTask(reinterpret_cast<FixedTimeslotTask*>(arg));
@@ -52,7 +50,7 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId, uint32_t slotT
  return HasReturnvaluesIF::RETURN_FAILED;
 }

-ReturnValue_t FixedTimeslotTask::checkSequence() { return pst.checkSequence(); }
+ReturnValue_t FixedTimeslotTask::checkSequence() const { return pst.checkSequence(); }

 void FixedTimeslotTask::taskFunctionality() {
  // Like FreeRTOS pthreads are running as soon as they are created
@@ -89,8 +87,8 @@ void FixedTimeslotTask::missedDeadlineCounter() {
  FixedTimeslotTask::deadlineMissedCount++;
  if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "PST missed " << FixedTimeslotTask::deadlineMissedCount << " deadlines"
-                 << std::endl;
+    sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount << " deadlines."
+               << std::endl;
 #endif
  }
 }
--- a/src/fsfw/osal/linux/FixedTimeslotTask.h
+++ b/src/fsfw/osal/linux/FixedTimeslotTask.h
@@ -24,18 +24,15 @@ class FixedTimeslotTask : public FixedTimeslotTaskIF, public PosixThread {
  FixedTimeslotTask(const char* name_, int priority_, size_t stackSize_, uint32_t periodMs_);
  virtual ~FixedTimeslotTask();

-  ReturnValue_t startTask() override;
+  virtual ReturnValue_t startTask();

-  ReturnValue_t sleepFor(uint32_t ms) override;
+  virtual ReturnValue_t sleepFor(uint32_t ms);

-  uint32_t getPeriodMs() const override;
+  virtual uint32_t getPeriodMs() const;

-  ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
-                        int8_t executionStep) override;
+  virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep);

-  ReturnValue_t checkSequence() override;
-
-  bool isEmpty() const override;
+  virtual ReturnValue_t checkSequence() const;

  /**
   * This static function can be used as #deadlineMissedFunc.
--- a/src/fsfw/osal/linux/PeriodicPosixTask.cpp
+++ b/src/fsfw/osal/linux/PeriodicPosixTask.cpp
@@ -1,7 +1,6 @@
 #include "fsfw/osal/linux/PeriodicPosixTask.h"

-#include <set>
-#include <cerrno>
+#include <errno.h>

 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
@@ -24,15 +23,15 @@ void* PeriodicPosixTask::taskEntryPoint(void* arg) {
  PeriodicPosixTask* originalTask(reinterpret_cast<PeriodicPosixTask*>(arg));
  // The task's functionality is called.
  originalTask->taskFunctionality();
-  return nullptr;
+  return NULL;
 }

-ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object, uint8_t opCode) {
+ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object) {
  ExecutableObjectIF* newObject = ObjectManager::instance()->get<ExecutableObjectIF>(object);
-  return addComponent(newObject, opCode);
+  return addComponent(newObject);
 }

-ReturnValue_t PeriodicPosixTask::addComponent(ExecutableObjectIF* object, uint8_t opCode) {
+ReturnValue_t PeriodicPosixTask::addComponent(ExecutableObjectIF* object) {
  if (object == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
@@ -44,7 +43,7 @@ ReturnValue_t PeriodicPosixTask::addComponent(ExecutableObjectIF* object, uint8_
 #endif
    return HasReturnvaluesIF::RETURN_FAILED;
  }
-  objectList.push_back({object, opCode});
+  objectList.push_back(object);
  object->setTaskIF(this);

  return HasReturnvaluesIF::RETURN_OK;
@@ -55,9 +54,6 @@ ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
 }

 ReturnValue_t PeriodicPosixTask::startTask(void) {
-  if (isEmpty()) {
-    return HasReturnvaluesIF::RETURN_FAILED;
-  }
  started = true;
  PosixThread::createTask(&taskEntryPoint, this);
  return HasReturnvaluesIF::RETURN_OK;
@@ -68,13 +64,15 @@ void PeriodicPosixTask::taskFunctionality(void) {
    suspend();
  }

-  initObjsAfterTaskCreation();
+  for (auto const& object : objectList) {
+    object->initializeAfterTaskCreation();
+  }

  uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
  // The task's "infinite" inner loop is entered.
  while (1) {
-    for (auto const& objOpCodePair : objectList) {
-      objOpCodePair.first->performOperation(objOpCodePair.second);
+    for (auto const& object : objectList) {
+      object->performOperation();
    }

    if (not PosixThread::delayUntil(&lastWakeTime, periodMs)) {
@@ -86,25 +84,3 @@ void PeriodicPosixTask::taskFunctionality(void) {
 }

 uint32_t PeriodicPosixTask::getPeriodMs() const { return periodMs; }
-
-bool PeriodicPosixTask::isEmpty() const { return objectList.empty(); }
-
-ReturnValue_t PeriodicPosixTask::initObjsAfterTaskCreation() {
-  std::multiset<ExecutableObjectIF*> uniqueObjects;
-  ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
-  uint32_t count = 0;
-  for (const auto& obj : objectList) {
-    // Ensure that each unique object is initialized once.
-    if (uniqueObjects.find(obj.first) == uniqueObjects.end()) {
-      ReturnValue_t result = obj.first->initializeAfterTaskCreation();
-      if (result != HasReturnvaluesIF::RETURN_OK) {
-        count++;
-        status = result;
-      }
-      uniqueObjects.emplace(obj.first);
-    }
-  }
-  if (count > 0) {
-  }
-  return status;
-}
--- a/src/fsfw/osal/linux/PeriodicPosixTask.h
+++ b/src/fsfw/osal/linux/PeriodicPosixTask.h
@@ -40,7 +40,7 @@ class PeriodicPosixTask : public PosixThread, public PeriodicTaskIF {
   * @param object Id of the object to add.
   * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
   */
-  ReturnValue_t addComponent(object_id_t object, uint8_t opCode) override;
+  ReturnValue_t addComponent(object_id_t object) override;

  /**
   * Adds an object to the list of objects to be executed.
@@ -48,20 +48,14 @@ class PeriodicPosixTask : public PosixThread, public PeriodicTaskIF {
   * @param object pointer to the object to add.
   * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
   */
-  ReturnValue_t addComponent(ExecutableObjectIF* object, uint8_t opCode) override;
+  ReturnValue_t addComponent(ExecutableObjectIF* object) override;

  uint32_t getPeriodMs() const override;

  ReturnValue_t sleepFor(uint32_t ms) override;

-  ReturnValue_t initObjsAfterTaskCreation();
-
-  bool isEmpty() const override;
-
 private:
-  //! Typedef for the List of objects. Will contain the objects to execute and their respective
-  //! op codes
-  using ObjectList = std::vector<std::pair<ExecutableObjectIF*, uint8_t>>;
+  typedef std::vector<ExecutableObjectIF*> ObjectList;  //!< Typedef for the List of objects.
  /**
   * @brief	This attribute holds a list of objects to be executed.
   */
--- a/src/fsfw/osal/rtems/FixedTimeslotTask.cpp
+++ b/src/fsfw/osal/rtems/FixedTimeslotTask.cpp
@@ -50,8 +50,8 @@ void FixedTimeslotTask::missedDeadlineCounter() {
  FixedTimeslotTask::deadlineMissedCount++;
  if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "PST missed " << FixedTimeslotTask::deadlineMissedCount << " deadlines"
-                 << std::endl;
+    sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount << " deadlines."
+               << std::endl;
 #endif
  }
 }
--- a/src/fsfw/parameters/HasParametersIF.h
+++ b/src/fsfw/parameters/HasParametersIF.h
@@ -66,7 +66,7 @@ class HasParametersIF {
   * @param newValues
   * @param startAtIndex Linear index, runs left to right, top to bottom for
   * matrix indexes.
-   * @return RETURN_OK if parameter is valid and a set function of the parameter wrapper was called.
+   * @return
   */
  virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueIdentifier,
                                     ParameterWrapper *parameterWrapper,
--- a/src/fsfw/parameters/ParameterWrapper.cpp
+++ b/src/fsfw/parameters/ParameterWrapper.cpp
@@ -211,13 +211,9 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
  if (data == nullptr) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "ParameterWrapper::copyFrom: Called on read-only variable or "
-                    "data pointer not set"
-                 << std::endl;
+    sif::warning << "ParameterWrapper::copyFrom: Called on read-only variable!" << std::endl;
 #else
-    sif::printWarning(
-        "ParameterWrapper::copyFrom: Called on read-only variable "
-        "or data pointer not set\n");
+    sif::printWarning("ParameterWrapper::copyFrom: Called on read-only variable!\n");
 #endif
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
    return READONLY;
@@ -226,9 +222,9 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
  if (from->readonlyData == nullptr) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "ParameterWrapper::copyFrom: Source not set" << std::endl;
+    sif::warning << "ParameterWrapper::copyFrom: Source not set!" << std::endl;
 #else
-    sif::printWarning("ParameterWrapper::copyFrom: Source not set\n");
+    sif::printWarning("ParameterWrapper::copyFrom: Source not set!\n");
 #endif
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
    return SOURCE_NOT_SET;
@@ -237,9 +233,9 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
  if (type != from->type) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "ParameterWrapper::copyFrom: Datatype missmatch" << std::endl;
+    sif::warning << "ParameterWrapper::copyFrom: Datatype missmatch!" << std::endl;
 #else
-    sif::printWarning("ParameterWrapper::copyFrom: Datatype missmatch\n");
+    sif::printWarning("ParameterWrapper::copyFrom: Datatype missmatch!\n");
 #endif
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
    return DATATYPE_MISSMATCH;
@@ -249,9 +245,9 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
  if (rows == 0 or columns == 0) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "ParameterWrapper::copyFrom: Columns or rows zero" << std::endl;
+    sif::warning << "ParameterWrapper::copyFrom: Columns or rows zero!" << std::endl;
 #else
-    sif::printWarning("ParameterWrapper::copyFrom: Columns or rows zero\n");
+    sif::printWarning("ParameterWrapper::copyFrom: Columns or rows zero!\n");
 #endif
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
    return COLUMN_OR_ROWS_ZERO;
--- a/src/fsfw/power/CMakeLists.txt
+++ b/src/fsfw/power/CMakeLists.txt
@@ -1,8 +1,7 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
-    Fuse.cpp
-    PowerComponent.cpp
-    PowerSensor.cpp
-    PowerSwitcher.cpp
-    DummyPowerSwitcher.cpp
-    PowerSwitcherComponent.cpp
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Fuse.cpp
+		PowerComponent.cpp
+		PowerSensor.cpp
+		PowerSwitcher.cpp
 )
--- a/src/fsfw/power/DummyPowerSwitcher.cpp
+++ b/src/fsfw/power/DummyPowerSwitcher.cpp
@@ -1,47 +0,0 @@
-#include "DummyPowerSwitcher.h"
-
-DummyPowerSwitcher::DummyPowerSwitcher(object_id_t objectId, size_t numberOfSwitches,
-                                       size_t numberOfFuses, bool registerGlobally,
-                                       uint32_t switchDelayMs)
-    : SystemObject(objectId, registerGlobally),
-      switcherList(numberOfSwitches),
-      fuseList(numberOfFuses),
-      switchDelayMs(switchDelayMs) {}
-
-void DummyPowerSwitcher::setInitialSwitcherList(std::vector<ReturnValue_t> switcherList) {
-  this->switcherList = switcherList;
-}
-
-void DummyPowerSwitcher::setInitialFusesList(std::vector<ReturnValue_t> fuseList) {
-  this->fuseList = fuseList;
-}
-
-ReturnValue_t DummyPowerSwitcher::sendSwitchCommand(power::Switch_t switchNr, ReturnValue_t onOff) {
-  if (switchNr < switcherList.size()) {
-    switcherList[switchNr] = onOff;
-  }
-  return RETURN_FAILED;
-}
-
-ReturnValue_t DummyPowerSwitcher::sendFuseOnCommand(uint8_t fuseNr) {
-  if (fuseNr < fuseList.size()) {
-    fuseList[fuseNr] = FUSE_ON;
-  }
-  return RETURN_FAILED;
-}
-
-ReturnValue_t DummyPowerSwitcher::getSwitchState(power::Switch_t switchNr) const {
-  if (switchNr < switcherList.size()) {
-    return switcherList[switchNr];
-  }
-  return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-ReturnValue_t DummyPowerSwitcher::getFuseState(uint8_t fuseNr) const {
-  if (fuseNr < fuseList.size()) {
-    return fuseList[fuseNr];
-  }
-  return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-uint32_t DummyPowerSwitcher::getSwitchDelayMs(void) const { return switchDelayMs; }
--- a/src/fsfw/power/DummyPowerSwitcher.h
+++ b/src/fsfw/power/DummyPowerSwitcher.h
@@ -1,38 +0,0 @@
-#ifndef FSFW_SRC_FSFW_POWER_DUMMYPOWERSWITCHER_H_
-#define FSFW_SRC_FSFW_POWER_DUMMYPOWERSWITCHER_H_
-
-#include <cstddef>
-#include <vector>
-
-#include "PowerSwitchIF.h"
-#include "definitions.h"
-#include "fsfw/objectmanager/SystemObject.h"
-
-/**
- * @brief   This component can be used to simulate a power switcher like a
- *          Power Control Distribution Unit (PCDU)
- * @details
- * The dummy switcher will simply cache the commanded fuse and switch states and return them
- * in the according switch getter functions. In that sense, it simulates an ideal PCDU.
- */
-class DummyPowerSwitcher : public SystemObject, public PowerSwitchIF {
- public:
-  DummyPowerSwitcher(object_id_t objectId, size_t numberOfSwitches, size_t numberOfFuses,
-                     bool registerGlobally = true, uint32_t switchDelayMs = 5000);
-
-  void setInitialSwitcherList(std::vector<ReturnValue_t> switcherList);
-  void setInitialFusesList(std::vector<ReturnValue_t> switcherList);
-
-  virtual ReturnValue_t sendSwitchCommand(power::Switch_t switchNr, ReturnValue_t onOff) override;
-  virtual ReturnValue_t sendFuseOnCommand(uint8_t fuseNr) override;
-  virtual ReturnValue_t getSwitchState(power::Switch_t switchNr) const override;
-  virtual ReturnValue_t getFuseState(uint8_t fuseNr) const override;
-  virtual uint32_t getSwitchDelayMs(void) const override;
-
- private:
-  std::vector<ReturnValue_t> switcherList;
-  std::vector<ReturnValue_t> fuseList;
-  uint32_t switchDelayMs = 5000;
-};
-
-#endif /* FSFW_SRC_FSFW_POWER_DUMMYPOWERSWITCHER_H_ */
--- a/src/fsfw/power/Fuse.h
+++ b/src/fsfw/power/Fuse.h
@@ -34,14 +34,14 @@ class Fuse : public SystemObject,
  };

  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_1;
-  //! PSS detected that current on a fuse is totally out of bounds.
-  static const Event FUSE_CURRENT_HIGH = MAKE_EVENT(1, severity::LOW);
-  //! PSS detected a fuse that went off.
-  static const Event FUSE_WENT_OFF = MAKE_EVENT(2, severity::LOW);
-  //! PSS detected a fuse that violates its limits.
-  static const Event POWER_ABOVE_HIGH_LIMIT = MAKE_EVENT(4, severity::LOW);
-  //! PSS detected a fuse that violates its limits.
-  static const Event POWER_BELOW_LOW_LIMIT = MAKE_EVENT(5, severity::LOW);
+  static const Event FUSE_CURRENT_HIGH = MAKE_EVENT(
+      1, severity::LOW);  //!< PSS detected that current on a fuse is totally out of bounds.
+  static const Event FUSE_WENT_OFF =
+      MAKE_EVENT(2, severity::LOW);  //!< PSS detected a fuse that went off.
+  static const Event POWER_ABOVE_HIGH_LIMIT =
+      MAKE_EVENT(4, severity::LOW);  //!< PSS detected a fuse that violates its limits.
+  static const Event POWER_BELOW_LOW_LIMIT =
+      MAKE_EVENT(5, severity::LOW);  //!< PSS detected a fuse that violates its limits.

  typedef std::list<PowerComponentIF *> DeviceList;
  Fuse(object_id_t fuseObjectId, uint8_t fuseId, sid_t variableSet, VariableIds ids,
--- a/src/fsfw/power/PowerSwitchIF.h
+++ b/src/fsfw/power/PowerSwitchIF.h
@@ -3,7 +3,6 @@

 #include "../events/Event.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include "definitions.h"
 /**
 *
 * @brief   This interface defines a connection to a device that is capable of
@@ -38,11 +37,11 @@ class PowerSwitchIF : public HasReturnvaluesIF {
   * @param switchNr
   * @param onOff on == @c SWITCH_ON; off != @c SWITCH_ON
   */
-  virtual ReturnValue_t sendSwitchCommand(power::Switch_t switchNr, ReturnValue_t onOff) = 0;
+  virtual void sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) const = 0;
  /**
   * Sends a command to the Power Unit to enable a certain fuse.
   */
-  virtual ReturnValue_t sendFuseOnCommand(uint8_t fuseNr) = 0;
+  virtual void sendFuseOnCommand(uint8_t fuseNr) const = 0;

  /**
   * get the state of the Switches.
@@ -52,7 +51,7 @@ class PowerSwitchIF : public HasReturnvaluesIF {
   *     - @c SWITCH_OFF if the specified switch is off.
   *     - @c RETURN_FAILED if an error occured
   */
-  virtual ReturnValue_t getSwitchState(power::Switch_t switchNr) const = 0;
+  virtual ReturnValue_t getSwitchState(uint8_t switchNr) const = 0;
  /**
   * get state of a fuse.
   * @param fuseNr
--- a/src/fsfw/power/PowerSwitcher.cpp
+++ b/src/fsfw/power/PowerSwitcher.cpp
@@ -1,12 +1,19 @@
 #include "fsfw/power/PowerSwitcher.h"

-#include "definitions.h"
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"

-PowerSwitcher::PowerSwitcher(PowerSwitchIF* switcher, power::Switch_t setSwitch1,
-                             power::Switch_t setSwitch2, PowerSwitcher::State_t setStartState)
-    : power(switcher), state(setStartState), firstSwitch(setSwitch1), secondSwitch(setSwitch2) {}
+PowerSwitcher::PowerSwitcher(uint8_t setSwitch1, uint8_t setSwitch2,
+                             PowerSwitcher::State_t setStartState)
+    : state(setStartState), firstSwitch(setSwitch1), secondSwitch(setSwitch2) {}
+
+ReturnValue_t PowerSwitcher::initialize(object_id_t powerSwitchId) {
+  power = ObjectManager::instance()->get<PowerSwitchIF>(powerSwitchId);
+  if (power == nullptr) {
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  return HasReturnvaluesIF::RETURN_OK;
+}

 ReturnValue_t PowerSwitcher::getStateOfSwitches() {
  SwitchReturn_t result = howManySwitches();
@@ -45,37 +52,18 @@ void PowerSwitcher::commandSwitches(ReturnValue_t onOff) {
  return;
 }

-void PowerSwitcher::turnOn(bool checkCurrentState) {
-  if (checkCurrentState) {
-    if (getStateOfSwitches() == PowerSwitchIF::SWITCH_ON) {
-      state = SWITCH_IS_ON;
-      return;
-    }
-  }
+void PowerSwitcher::turnOn() {
  commandSwitches(PowerSwitchIF::SWITCH_ON);
  state = WAIT_ON;
 }

-void PowerSwitcher::turnOff(bool checkCurrentState) {
-  if (checkCurrentState) {
-    if (getStateOfSwitches() == PowerSwitchIF::SWITCH_OFF) {
-      state = SWITCH_IS_OFF;
-      return;
-    }
-  }
+void PowerSwitcher::turnOff() {
  commandSwitches(PowerSwitchIF::SWITCH_OFF);
  state = WAIT_OFF;
 }

-bool PowerSwitcher::active() {
-  if (state == WAIT_OFF or state == WAIT_ON) {
-    return true;
-  }
-  return false;
-}
-
 PowerSwitcher::SwitchReturn_t PowerSwitcher::howManySwitches() {
-  if (secondSwitch == power::NO_SWITCH) {
+  if (secondSwitch == NO_SWITCH) {
    return ONE_SWITCH;
  } else {
    return TWO_SWITCHES;
--- a/src/fsfw/power/PowerSwitcher.h
+++ b/src/fsfw/power/PowerSwitcher.h
@@ -14,29 +14,28 @@ class PowerSwitcher : public HasReturnvaluesIF {
    SWITCH_IS_OFF,
    SWITCH_IS_ON,
  };
-
+  State_t state;
  static const uint8_t INTERFACE_ID = CLASS_ID::POWER_SWITCHER;
  static const ReturnValue_t IN_POWER_TRANSITION = MAKE_RETURN_CODE(1);
  static const ReturnValue_t SWITCH_STATE_MISMATCH = MAKE_RETURN_CODE(2);
-  PowerSwitcher(PowerSwitchIF* switcher, power::Switch_t setSwitch1,
-                power::Switch_t setSwitch2 = power::NO_SWITCH,
+  PowerSwitcher(uint8_t setSwitch1, uint8_t setSwitch2 = NO_SWITCH,
                State_t setStartState = SWITCH_IS_OFF);
-  void turnOn(bool checkCurrentState = true);
-  void turnOff(bool checkCurrentState = true);
-  bool active();
+  ReturnValue_t initialize(object_id_t powerSwitchId);
+  void turnOn();
+  void turnOff();
  void doStateMachine();
  State_t getState();
  ReturnValue_t checkSwitchState();
  uint32_t getSwitchDelay();
-  power::Switch_t getFirstSwitch() const;
-  power::Switch_t getSecondSwitch() const;
+  uint8_t getFirstSwitch() const;
+  uint8_t getSecondSwitch() const;

 private:
+  uint8_t firstSwitch;
+  uint8_t secondSwitch;
  PowerSwitchIF* power = nullptr;
-  State_t state;
-  power::Switch_t firstSwitch = power::NO_SWITCH;
-  power::Switch_t secondSwitch = power::NO_SWITCH;

+  static const uint8_t NO_SWITCH = 0xFF;
  enum SwitchReturn_t { ONE_SWITCH = 1, TWO_SWITCHES = 2 };
  ReturnValue_t getStateOfSwitches();
  void commandSwitches(ReturnValue_t onOff);
--- a/src/fsfw/power/PowerSwitcherComponent.cpp
+++ b/src/fsfw/power/PowerSwitcherComponent.cpp
@@ -1,107 +0,0 @@
-#include "PowerSwitcherComponent.h"
-
-#include <fsfw/ipc/QueueFactory.h>
-#include <fsfw/power/PowerSwitchIF.h>
-
-PowerSwitcherComponent::PowerSwitcherComponent(object_id_t objectId, PowerSwitchIF *pwrSwitcher,
-                                               power::Switch_t pwrSwitch)
-    : SystemObject(objectId),
-      switcher(pwrSwitcher, pwrSwitch),
-      modeHelper(this),
-      healthHelper(this, objectId) {
-  queue = QueueFactory::instance()->createMessageQueue();
-}
-
-ReturnValue_t PowerSwitcherComponent::performOperation(uint8_t opCode) {
-  ReturnValue_t result;
-  CommandMessage command;
-
-  for (result = queue->receiveMessage(&command); result == RETURN_OK;
-       result = queue->receiveMessage(&command)) {
-    result = healthHelper.handleHealthCommand(&command);
-    if (result == RETURN_OK) {
-      continue;
-    }
-
-    result = modeHelper.handleModeCommand(&command);
-    if (result == RETURN_OK) {
-      continue;
-    }
-  }
-  if (switcher.active()) {
-    switcher.doStateMachine();
-    auto currState = switcher.getState();
-    if (currState == PowerSwitcher::SWITCH_IS_OFF) {
-      setMode(MODE_OFF, 0);
-    } else if (currState == PowerSwitcher::SWITCH_IS_ON) {
-      setMode(MODE_ON, 0);
-    }
-  }
-  return RETURN_OK;
-}
-
-ReturnValue_t PowerSwitcherComponent::initialize() {
-  ReturnValue_t result = modeHelper.initialize();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
-    return result;
-  }
-  result = healthHelper.initialize();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
-    return result;
-  }
-  return SystemObject::initialize();
-}
-
-MessageQueueId_t PowerSwitcherComponent::getCommandQueue() const { return queue->getId(); }
-
-void PowerSwitcherComponent::getMode(Mode_t *mode, Submode_t *submode) {
-  *mode = this->mode;
-  *submode = this->submode;
-}
-
-ReturnValue_t PowerSwitcherComponent::setHealth(HealthState health) {
-  healthHelper.setHealth(health);
-  return RETURN_OK;
-}
-
-ReturnValue_t PowerSwitcherComponent::checkModeCommand(Mode_t mode, Submode_t submode,
-                                                       uint32_t *msToReachTheMode) {
-  *msToReachTheMode = 5000;
-  if (mode != MODE_ON and mode != MODE_OFF) {
-    return TRANS_NOT_ALLOWED;
-  }
-  return RETURN_OK;
-}
-
-void PowerSwitcherComponent::startTransition(Mode_t mode, Submode_t submode) {
-  if (mode == MODE_OFF) {
-    switcher.turnOff(true);
-    switcher.doStateMachine();
-    if (switcher.getState() == PowerSwitcher::SWITCH_IS_OFF) {
-      setMode(MODE_OFF, 0);
-    }
-  } else if (mode == MODE_ON) {
-    switcher.turnOn(true);
-    switcher.doStateMachine();
-    if (switcher.getState() == PowerSwitcher::SWITCH_IS_ON) {
-      setMode(MODE_ON, 0);
-    }
-  }
-}
-
-void PowerSwitcherComponent::setToExternalControl() {
-  healthHelper.setHealth(HasHealthIF::EXTERNAL_CONTROL);
-}
-
-void PowerSwitcherComponent::announceMode(bool recursive) {
-  triggerEvent(MODE_INFO, mode, submode);
-}
-
-void PowerSwitcherComponent::setMode(Mode_t newMode, Submode_t newSubmode) {
-  this->mode = newMode;
-  this->submode = newSubmode;
-  modeHelper.modeChanged(mode, submode);
-  announceMode(false);
-}
-
-HasHealthIF::HealthState PowerSwitcherComponent::getHealth() { return healthHelper.getHealth(); }
--- a/src/fsfw/power/PowerSwitcherComponent.h
+++ b/src/fsfw/power/PowerSwitcherComponent.h
@@ -1,62 +0,0 @@
-#ifndef _FSFW_POWER_POWERSWITCHERCOMPONENT_H_
-#define _FSFW_POWER_POWERSWITCHERCOMPONENT_H_
-
-#include <fsfw/health/HasHealthIF.h>
-#include <fsfw/health/HealthHelper.h>
-#include <fsfw/modes/HasModesIF.h>
-#include <fsfw/modes/ModeHelper.h>
-#include <fsfw/objectmanager/SystemObject.h>
-#include <fsfw/power/PowerSwitcher.h>
-#include <fsfw/power/definitions.h>
-#include <fsfw/tasks/ExecutableObjectIF.h>
-
-class PowerSwitchIF;
-
-/**
- * @brief Allows to create an power switch object with its own mode and health
- * @details
- * This basic component allows to create an object which is solely responsible for managing a
- * switch. It also has a mode and a health by implementing the respective interface components
- * which allows integrating this component into a system mode tree.
- *
- * Commanding this component to MODE_OFF will cause the switcher to turn the switch off while
- * commanding in to MODE_ON will cause the switcher to turn the switch on.
- */
-class PowerSwitcherComponent : public SystemObject,
-                               public HasReturnvaluesIF,
-                               public ExecutableObjectIF,
-                               public HasModesIF,
-                               public HasHealthIF {
- public:
-  PowerSwitcherComponent(object_id_t objectId, PowerSwitchIF *pwrSwitcher,
-                         power::Switch_t pwrSwitch);
-
- private:
-  MessageQueueIF *queue = nullptr;
-  PowerSwitcher switcher;
-
-  Mode_t mode = MODE_OFF;
-  Submode_t submode = 0;
-
-  ModeHelper modeHelper;
-  HealthHelper healthHelper;
-
-  void setMode(Mode_t newMode, Submode_t newSubmode);
-
-  virtual ReturnValue_t performOperation(uint8_t opCode) override;
-
-  ReturnValue_t initialize() override;
-
-  MessageQueueId_t getCommandQueue() const override;
-  void getMode(Mode_t *mode, Submode_t *submode) override;
-  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-                                 uint32_t *msToReachTheMode) override;
-  void startTransition(Mode_t mode, Submode_t submode) override;
-  void setToExternalControl() override;
-  void announceMode(bool recursive) override;
-
-  ReturnValue_t setHealth(HealthState health) override;
-  HasHealthIF::HealthState getHealth() override;
-};
-
-#endif /* _FSFW_POWER_POWERSWITCHERCOMPONENT_H_ */
--- a/src/fsfw/power/definitions.h
+++ b/src/fsfw/power/definitions.h
@@ -1,13 +0,0 @@
-#ifndef FSFW_SRC_FSFW_POWER_DEFINITIONS_H_
-#define FSFW_SRC_FSFW_POWER_DEFINITIONS_H_
-
-#include <cstdint>
-
-namespace power {
-
-using Switch_t = uint8_t;
-static constexpr Switch_t NO_SWITCH = 0xFF;
-
-}  // namespace power
-
-#endif /* FSFW_SRC_FSFW_POWER_DEFINITIONS_H_ */
--- a/src/fsfw/pus/CService201HealthCommanding.cpp
+++ b/src/fsfw/pus/CService201HealthCommanding.cpp
@@ -97,8 +97,7 @@ ReturnValue_t CService201HealthCommanding::handleReply(const CommandMessage *rep
 }

 // Not used for now, health state already reported by event
-[[maybe_unused]] ReturnValue_t CService201HealthCommanding::prepareHealthSetReply(
-    const CommandMessage *reply) {
+[[maybe_unused]] ReturnValue_t CService201HealthCommanding::prepareHealthSetReply(const CommandMessage *reply) {
  auto health = static_cast<uint8_t>(HealthMessage::getHealth(reply));
  auto oldHealth = static_cast<uint8_t>(HealthMessage::getOldHealth(reply));
  HealthSetReply healthSetReply(health, oldHealth);
--- a/src/fsfw/pus/CService201HealthCommanding.h
+++ b/src/fsfw/pus/CService201HealthCommanding.h
@@ -39,7 +39,7 @@ class CService201HealthCommanding : public CommandingServiceBase {

 private:
  static ReturnValue_t checkInterfaceAndAcquireMessageQueue(MessageQueueId_t *MessageQueueToSet,
-                                                            const object_id_t *objectId);
+                                                     const object_id_t *objectId);

  [[maybe_unused]] ReturnValue_t prepareHealthSetReply(const CommandMessage *reply);

--- a/src/fsfw/pus/Service11TelecommandScheduling.h
+++ b/src/fsfw/pus/Service11TelecommandScheduling.h
@@ -1,202 +0,0 @@
-#ifndef MISSION_PUS_SERVICE11TELECOMMANDSCHEDULING_H_
-#define MISSION_PUS_SERVICE11TELECOMMANDSCHEDULING_H_
-
-#include <etl/multimap.h>
-#include <fsfw/tmtcservices/PusServiceBase.h>
-#include <fsfw/tmtcservices/TmTcMessage.h>
-
-#include "fsfw/FSFW.h"
-#include "fsfw/returnvalues/FwClassIds.h"
-
-/**
- * @brief: PUS-Service 11 - Telecommand scheduling.
- * @details:
- * PUS-Service 11 - Telecommand scheduling.
- * Full documentation: ECSS-E-ST-70-41C, p. 168:
- * ST[11] time-based scheduling
- *
- * This service provides the capability to command pre-loaded
- * application processes (telecommands) by releasing them at their
- * due-time.
- * References to telecommands are stored together with their due-timepoints
- * and are released at their corresponding due-time.
- *
- * Necessary subservice functionalities are implemented.
- * Those are:
- * TC[11,4] activity insertion
- * TC[11,5] activity deletion
- * TC[11,6] filter-based activity deletion
- * TC[11,7] activity time-shift
- * TC[11,8] filter-based activity time-shift
- *
- * Groups are not supported.
- * This service remains always enabled. Sending a disable-request has no effect.
- */
-template <size_t MAX_NUM_TCS>
-class Service11TelecommandScheduling final : public PusServiceBase {
- public:
-  static constexpr uint8_t CLASS_ID = CLASS_ID::PUS_SERVICE_11;
-
-  static constexpr ReturnValue_t INVALID_TYPE_TIME_WINDOW =
-      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 1);
-  static constexpr ReturnValue_t TIMESHIFTING_NOT_POSSIBLE =
-      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 2);
-  static constexpr ReturnValue_t INVALID_RELATIVE_TIME =
-      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 3);
-
-  // The types of PUS-11 subservices
-  enum Subservice : uint8_t {
-    ENABLE_SCHEDULING = 1,
-    DISABLE_SCHEDULING = 2,
-    RESET_SCHEDULING = 3,
-    INSERT_ACTIVITY = 4,
-    DELETE_ACTIVITY = 5,
-    FILTER_DELETE_ACTIVITY = 6,
-    TIMESHIFT_ACTIVITY = 7,
-    FILTER_TIMESHIFT_ACTIVITY = 8,
-    DETAIL_REPORT = 9,
-    TIMEBASE_SCHEDULE_DETAIL_REPORT = 10,
-    TIMESHIFT_ALL_SCHEDULE_ACTIVITIES = 15
-  };
-
-  // The types of time windows for TC[11,6] and TC[11,8], as defined in ECSS-E-ST-70-41C,
-  // requirement 8.11.3c (p. 507)
-  enum TypeOfTimeWindow : uint32_t {
-    SELECT_ALL = 0,
-    FROM_TIMETAG_TO_TIMETAG = 1,
-    FROM_TIMETAG = 2,
-    TO_TIMETAG = 3
-  };
-
-  Service11TelecommandScheduling(object_id_t objectId, uint16_t apid, uint8_t serviceId,
-                                 AcceptsTelecommandsIF* tcRecipient,
-                                 uint16_t releaseTimeMarginSeconds = DEFAULT_RELEASE_TIME_MARGIN,
-                                 bool debugMode = false);
-
-  ~Service11TelecommandScheduling();
-
-  /** PusServiceBase overrides */
-  ReturnValue_t handleRequest(uint8_t subservice) override;
-  ReturnValue_t performService() override;
-  ReturnValue_t initialize() override;
-
- private:
-  struct TelecommandStruct {
-    uint64_t requestId;
-    uint32_t seconds;
-    store_address_t storeAddr;  // uint16
-  };
-
-  static constexpr uint16_t DEFAULT_RELEASE_TIME_MARGIN = 5;
-
-  // minimum release time offset to insert into schedule
-  const uint16_t RELEASE_TIME_MARGIN_SECONDS = 5;
-
-  // the maximum amount of stored TCs is defined here
-  static constexpr uint16_t MAX_STORED_TELECOMMANDS = 500;
-
-  bool debugMode = false;
-  StorageManagerIF* tcStore = nullptr;
-  AcceptsTelecommandsIF* tcRecipient = nullptr;
-  MessageQueueId_t recipientMsgQueueId = 0;
-
-  /**
-   * The telecommand map uses the exectution time as a Unix time stamp as
-   * the key. This is mapped to a generic telecommand struct.
-   */
-  using TelecommandMap = etl::multimap<uint32_t, TelecommandStruct, MAX_NUM_TCS>;
-  using TcMapIter = typename TelecommandMap::iterator;
-
-  TelecommandMap telecommandMap;
-
-  /**
-   * @brief Logic to be performed on an incoming TC[11,4].
-   * @return RETURN_OK if successful
-   */
-  ReturnValue_t doInsertActivity(const uint8_t* data, size_t size);
-
-  /**
-   * @brief Logic to be performed on an incoming TC[11,5].
-   * @return RETURN_OK if successful
-   */
-  ReturnValue_t doDeleteActivity(const uint8_t* data, size_t size);
-
-  /**
-   * @brief Logic to be performed on an incoming TC[11,6].
-   * @return RETURN_OK if successful
-   */
-  ReturnValue_t doFilterDeleteActivity(const uint8_t* data, size_t size);
-
-  /**
-   * @brief Logic to be performed on an incoming TC[11,7].
-   * @return RETURN_OK if successful
-   */
-  ReturnValue_t doTimeshiftActivity(const uint8_t* data, size_t size);
-
-  /**
-   * @brief Logic to be performed on an incoming TC[11,8].
-   * @return RETURN_OK if successful
-   */
-  ReturnValue_t doFilterTimeshiftActivity(const uint8_t* data, size_t size);
-
-  /**
-   * @brief Deserializes a generic type from a payload buffer by using the FSFW
-   * SerializeAdapter Interface.
-   * @param output Output to be deserialized
-   * @param buf Payload buffer (application data)
-   * @param bufsize Remaining size of payload buffer (application data size)
-   * @return RETURN_OK if successful
-   */
-  template <typename T>
-  ReturnValue_t deserializeViaFsfwInterface(T& output, const uint8_t* buf, size_t bufsize);
-
-  /**
-   * @brief Extracts the Request ID from the Application Data of a TC by utilizing a ctor of the
-   * class TcPacketPus.
-   * NOTE: This only works if the payload data is a TC (e.g. not for TC[11,5] which does not
-   * send a TC as payload)!
-   * @param data The Application data of the TC (get via getApplicationData()).
-   * @return requestId
-   */
-  uint64_t getRequestIdFromDataTC(const uint8_t* data) const;
-
-  /**
-   * @brief Extracts the Request ID from the Application Data directly, assuming it is packed
-   * as follows (acc. to ECSS): | source ID (uint32) | apid (uint32) | ssc (uint32) |.
-   * @param data Pointer to first byte described data
-   * @param dataSize Remaining size of data NOTE: non-const, this is modified by the function
-   * @param [out] requestId Request ID
-   * @return RETURN_OK if successful
-   */
-  ReturnValue_t getRequestIdFromData(const uint8_t*& data, size_t& dataSize, uint64_t& requestId);
-
-  /**
-   * @brief Builds the Request ID from its three elements.
-   * @param sourceId Source ID
-   * @param apid Application Process ID (APID)
-   * @param ssc Source Sequence Count
-   * @return Request ID
-   */
-  uint64_t buildRequestId(uint32_t sourceId, uint16_t apid, uint16_t ssc) const;
-
-  /**
-   * @brief Gets the filter range for filter TCs from a data packet
-   * @param data TC data
-   * @param dataSize TC data size
-   * @param [out] itBegin Begin of filter range
-   * @param [out] itEnd End of filter range
-   * @return RETURN_OK if successful
-   */
-  ReturnValue_t getMapFilterFromData(const uint8_t*& data, size_t& size, TcMapIter& itBegin,
-                                     TcMapIter& itEnd);
-
-  ReturnValue_t handleInvalidData(const char* ctx);
-  /**
-   * @brief Prints content of multimap. Use for simple debugging only.
-   */
-  void debugPrintMultimapContent(void) const;
-};
-
-#include "Service11TelecommandScheduling.tpp"
-
-#endif /* MISSION_PUS_SERVICE11TELECOMMANDSCHEDULING_H_ */
--- a/src/fsfw/pus/Service11TelecommandScheduling.tpp
+++ b/src/fsfw/pus/Service11TelecommandScheduling.tpp
@@ -1,598 +0,0 @@
-#pragma once
-
-#include <fsfw/objectmanager/ObjectManager.h>
-#include <fsfw/serialize/SerializeAdapter.h>
-#include <fsfw/tmtcservices/AcceptsTelecommandsIF.h>
-
-#include <cstddef>
-
-static constexpr auto DEF_END = SerializeIF::Endianness::BIG;
-
-template <size_t MAX_NUM_TCS>
-inline Service11TelecommandScheduling<MAX_NUM_TCS>::Service11TelecommandScheduling(
-    object_id_t objectId, uint16_t apid, uint8_t serviceId, AcceptsTelecommandsIF *tcRecipient,
-    uint16_t releaseTimeMarginSeconds, bool debugMode)
-    : PusServiceBase(objectId, apid, serviceId),
-      RELEASE_TIME_MARGIN_SECONDS(releaseTimeMarginSeconds),
-      debugMode(debugMode),
-      tcRecipient(tcRecipient) {}
-
-template <size_t MAX_NUM_TCS>
-inline Service11TelecommandScheduling<MAX_NUM_TCS>::~Service11TelecommandScheduling() {}
-
-template <size_t MAX_NUM_TCS>
-inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::handleRequest(
-    uint8_t subservice) {
-  if (debugMode) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::info << "PUS11::handleRequest: Handling request " << static_cast<int>(subservice);
-#else
-    sif::printInfo("PUS11::handleRequest: Handling request %d\n", subservice);
-#endif
-  }
-  // Get de-serialized Timestamp
-  const uint8_t *data = currentPacket.getApplicationData();
-  size_t size = currentPacket.getApplicationDataSize();
-  if (data == nullptr) {
-    return handleInvalidData("handleRequest");
-  }
-  switch (subservice) {
-    case Subservice::INSERT_ACTIVITY:
-      return doInsertActivity(data, size);
-    case Subservice::DELETE_ACTIVITY:
-      return doDeleteActivity(data, size);
-    case Subservice::FILTER_DELETE_ACTIVITY:
-      return doFilterDeleteActivity(data, size);
-    case Subservice::TIMESHIFT_ACTIVITY:
-      return doTimeshiftActivity(data, size);
-    case Subservice::FILTER_TIMESHIFT_ACTIVITY:
-      return doFilterTimeshiftActivity(data, size);
-    default:
-      break;
-  }
-
-  return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-template <size_t MAX_NUM_TCS>
-inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::performService() {
-  // DEBUG
-  // DebugPrintMultimapContent();
-
-  // get current time as UNIX timestamp
-  timeval tNow = {};
-  Clock::getClock_timeval(&tNow);
-
-  // NOTE: The iterator is increased in the loop here. Increasing the iterator as for-loop arg
-  // does not work in this case as we are deleting the current element here.
-  for (auto it = telecommandMap.begin(); it != telecommandMap.end();) {
-    if (it->first <= tNow.tv_sec) {
-      // release tc
-      TmTcMessage releaseMsg(it->second.storeAddr);
-      auto sendRet = this->requestQueue->sendMessage(recipientMsgQueueId, &releaseMsg, false);
-
-      if (sendRet != HasReturnvaluesIF::RETURN_OK) {
-        return sendRet;
-      }
-
-      telecommandMap.erase(it++);
-
-      if (debugMode) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::info << "Released TC & erased it from TC map" << std::endl;
-#else
-        sif::printInfo("Released TC & erased it from TC map\n");
-#endif
-      }
-      continue;
-    }
-    it++;
-  }
-
-  return HasReturnvaluesIF::RETURN_OK;
-}
-
-template <size_t MAX_NUM_TCS>
-inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::initialize() {
-  ReturnValue_t res = PusServiceBase::initialize();
-  if (res != HasReturnvaluesIF::RETURN_OK) {
-    return res;
-  }
-
-  tcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::TC_STORE);
-  if (!tcStore) {
-    return ObjectManagerIF::CHILD_INIT_FAILED;
-  }
-
-  if (tcRecipient == nullptr) {
-    return ObjectManagerIF::CHILD_INIT_FAILED;
-  }
-  recipientMsgQueueId = tcRecipient->getRequestQueue();
-
-  return res;
-}
-
-template <size_t MAX_NUM_TCS>
-inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::doInsertActivity(
-    const uint8_t *data, size_t size) {
-  uint32_t timestamp = 0;
-  const uint8_t *initData = data;
-  size_t initSz = size;
-  ReturnValue_t result = SerializeAdapter::deSerialize(&timestamp, &data, &size, DEF_END);
-  if (result != RETURN_OK) {
-    return result;
-  }
-
-  // Insert possible if sched. time is above margin
-  // (See requirement for Time margin)
-  timeval tNow = {};
-  Clock::getClock_timeval(&tNow);
-  if (timestamp - tNow.tv_sec <= RELEASE_TIME_MARGIN_SECONDS) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "Service11TelecommandScheduling::doInsertActivity: Release time too close to "
-                    "current time"
-                 << std::endl;
-#else
-    sif::printWarning(
-        "Service11TelecommandScheduling::doInsertActivity: Release time too close to current "
-        "time\n");
-#endif
-    return RETURN_FAILED;
-  }
-
-  // store currentPacket and receive the store address
-  store_address_t addr{};
-  if (tcStore->addData(&addr, initData, initSz) != RETURN_OK ||
-      addr.raw == storeId::INVALID_STORE_ADDRESS) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "Service11TelecommandScheduling::doInsertActivity: Adding data to TC Store failed"
-               << std::endl;
-#else
-    sif::printError(
-        "Service11TelecommandScheduling::doInsertActivity: Adding data to TC Store failed\n");
-#endif
-    return RETURN_FAILED;
-  }
-
-  // insert into multimap with new store address
-  TelecommandStruct tc;
-  tc.seconds = timestamp;
-  tc.storeAddr = addr;
-  tc.requestId =
-      getRequestIdFromDataTC(data);  // TODO: Missing sanity check of the returned request id
-
-  auto it = telecommandMap.insert(std::pair<uint32_t, TelecommandStruct>(timestamp, tc));
-  if (it == telecommandMap.end()) {
-    return RETURN_FAILED;
-  }
-
-  if (debugMode) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::info << "PUS11::doInsertActivity: Inserted into Multimap:" << std::endl;
-#else
-    sif::printInfo("PUS11::doInsertActivity: Inserted into Multimap:\n");
-#endif
-    debugPrintMultimapContent();
-  }
-  return HasReturnvaluesIF::RETURN_OK;
-}
-
-template <size_t MAX_NUM_TCS>
-inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::doDeleteActivity(
-    const uint8_t *data, size_t size) {
-  // Get request ID
-  uint64_t requestId;
-  ReturnValue_t result = getRequestIdFromData(data, size, requestId);
-  if (result != RETURN_OK) {
-    return result;
-  }
-
-  // DEBUG
-  if (debugMode) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::info << "PUS11::doDeleteActivity: requestId: " << requestId << std::endl;
-#else
-    sif::printInfo("PUS11::doDeleteActivity: requestId: %d\n", requestId);
-#endif
-  }
-
-  TcMapIter tcToDelete;     // handle to the TC to be deleted, can be used if counter is valid
-  int tcToDeleteCount = 0;  // counter of all found TCs. Should be 1.
-
-  for (auto it = telecommandMap.begin(); it != telecommandMap.end(); it++) {
-    if (it->second.requestId == requestId) {
-      tcToDelete = it;
-      tcToDeleteCount++;
-    }
-  }
-
-  // check if 1 explicit TC is found via request ID
-  if (tcToDeleteCount == 0 || tcToDeleteCount > 1) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "Service11TelecommandScheduling::doDeleteActivity: No or more than 1 TC found. "
-                    "Cannot explicitly delete TC"
-                 << std::endl;
-#else
-    sif::printWarning(
-        "Service11TelecommandScheduling::doDeleteActivity: No or more than 1 TC found. "
-        "Cannot explicitly delete TC");
-#endif
-    return RETURN_FAILED;
-  }
-
-  // delete packet from store
-  if (tcStore->deleteData(tcToDelete->second.storeAddr) != RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "Service11TelecommandScheduling::doDeleteActivity: Could not delete TC from Store"
-               << std::endl;
-#else
-    sif::printError(
-        "Service11TelecommandScheduling::doDeleteActivity: Could not delete TC from Store\n");
-#endif
-    return RETURN_FAILED;
-  }
-
-  telecommandMap.erase(tcToDelete);
-  if (debugMode) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::info << "PUS11::doDeleteActivity: Deleted TC from map" << std::endl;
-#else
-    sif::printInfo("PUS11::doDeleteActivity: Deleted TC from map\n");
-#endif
-  }
-
-  return RETURN_OK;
-}
-
-template <size_t MAX_NUM_TCS>
-inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::doFilterDeleteActivity(
-    const uint8_t *data, size_t size) {
-  TcMapIter itBegin;
-  TcMapIter itEnd;
-
-  ReturnValue_t result = getMapFilterFromData(data, size, itBegin, itEnd);
-  // get the filter window as map range via dedicated method
-  if (result != RETURN_OK) {
-    return result;
-  }
-
-  int deletedTCs = 0;
-  for (TcMapIter it = itBegin; it != itEnd; it++) {
-    // delete packet from store
-    if (tcStore->deleteData(it->second.storeAddr) != RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::error << "Service11TelecommandScheduling::doFilterDeleteActivity: Could not delete TC "
-                    "from Store"
-                 << std::endl;
-#else
-      sif::printError(
-          "Service11TelecommandScheduling::doFilterDeleteActivity: Could not delete TC from "
-          "Store\n");
-#endif
-      continue;
-    }
-    deletedTCs++;
-  }
-
-  // NOTE: Spec says this function erases all elements including itBegin but not itEnd,
-  // see here: https://www.cplusplus.com/reference/map/multimap/erase/
-  // Therefore we need to increase itEnd by 1. (Note that end() returns the "past-the-end" iterator)
-  if (itEnd != telecommandMap.end()) {
-    itEnd++;
-  }
-
-  telecommandMap.erase(itBegin, itEnd);
-
-  if (debugMode) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::info << "PUS11::doFilterDeleteActivity: Deleted " << deletedTCs << " TCs" << std::endl;
-#else
-    sif::printInfo("PUS11::doFilterDeleteActivity: Deleted %d TCs\n", deletedTCs);
-#endif
-  }
-  return RETURN_OK;
-}
-
-template <size_t MAX_NUM_TCS>
-inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::doTimeshiftActivity(
-    const uint8_t *data, size_t size) {
-  // Get relative time
-  uint32_t relativeTime = 0;
-  ReturnValue_t result = SerializeAdapter::deSerialize(&relativeTime, &data, &size, DEF_END);
-  if (result != RETURN_OK) {
-    return result;
-  }
-  if (relativeTime == 0) {
-    return INVALID_RELATIVE_TIME;
-  }
-  // TODO further check sanity of the relative time?
-
-  // Get request ID
-  uint64_t requestId;
-  result = getRequestIdFromData(data, size, requestId);
-  if (result != RETURN_OK) {
-    return result;
-  }
-
-  if (debugMode) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::info << "PUS11::doTimeshiftActivity: requestId: " << requestId << std::endl;
-#else
-    sif::printInfo("PUS11::doTimeshiftActivity: requestId: %d\n", requestId);
-#endif
-  }
-
-  // NOTE: Despite having C++17 ETL multimap has no member function extract :(
-
-  TcMapIter tcToTimeshiftIt;
-  int tcToTimeshiftCount = 0;
-
-  for (auto it = telecommandMap.begin(); it != telecommandMap.end(); it++) {
-    if (it->second.requestId == requestId) {
-      tcToTimeshiftIt = it;
-      tcToTimeshiftCount++;
-    }
-  }
-
-  if (tcToTimeshiftCount == 0 || tcToTimeshiftCount > 1) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "Service11TelecommandScheduling::doTimeshiftActivity: Either 0 or more than 1 "
-                    "TCs found. No explicit timeshifting "
-                    "possible"
-                 << std::endl;
-
-#else
-    sif::printWarning(
-        "Service11TelecommandScheduling::doTimeshiftActivity: Either 0 or more than 1 TCs found. "
-        "No explicit timeshifting possible\n");
-#endif
-    return TIMESHIFTING_NOT_POSSIBLE;
-  }
-
-  // temporarily hold the item
-  TelecommandStruct tempTc(tcToTimeshiftIt->second);
-  uint32_t tempKey = tcToTimeshiftIt->first + relativeTime;
-
-  // delete old entry from the mm
-  telecommandMap.erase(tcToTimeshiftIt);
-
-  // and then insert it again as new entry
-  telecommandMap.insert(std::make_pair(tempKey, tempTc));
-
-  if (debugMode) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::info << "PUS11::doTimeshiftActivity: Shifted TC" << std::endl;
-#else
-    sif::printDebug("PUS11::doTimeshiftActivity: Shifted TC\n");
-#endif
-    debugPrintMultimapContent();
-  }
-
-  return RETURN_OK;
-}
-
-template <size_t MAX_NUM_TCS>
-inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::doFilterTimeshiftActivity(
-    const uint8_t *data, size_t size) {
-  // Get relative time
-  uint32_t relativeTime = 0;
-  ReturnValue_t result = SerializeAdapter::deSerialize(&relativeTime, &data, &size, DEF_END);
-  if (result != RETURN_OK) {
-    return result;
-  }
-  if (relativeTime == 0) {
-    return INVALID_RELATIVE_TIME;
-  }
-
-  // Do time window
-  TcMapIter itBegin;
-  TcMapIter itEnd;
-  result = getMapFilterFromData(data, size, itBegin, itEnd);
-  if (result != RETURN_OK) {
-    return result;
-  }
-
-  int shiftedItemsCount = 0;
-  for (auto it = itBegin; it != itEnd;) {
-    // temporarily hold the item
-    TelecommandStruct tempTc(it->second);
-    uint32_t tempKey = it->first + relativeTime;
-
-    // delete the old entry from the mm
-    telecommandMap.erase(it++);
-
-    // and then insert it again as new entry
-    telecommandMap.insert(std::make_pair(tempKey, tempTc));
-    shiftedItemsCount++;
-    continue;
-  }
-
-  if (debugMode) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::info << "PUS11::doFilterTimeshiftActivity: shiftedItemsCount: " << shiftedItemsCount
-              << std::endl;
-#else
-    sif::printInfo("PUS11::doFilterTimeshiftActivity: shiftedItemsCount: %d\n", shiftedItemsCount);
-#endif
-    debugPrintMultimapContent();
-  }
-
-  if (shiftedItemsCount > 0) {
-    return RETURN_OK;
-  }
-  return RETURN_FAILED;
-}
-
-template <size_t MAX_NUM_TCS>
-inline uint64_t Service11TelecommandScheduling<MAX_NUM_TCS>::getRequestIdFromDataTC(
-    const uint8_t *data) const {
-  TcPacketPus mask(data);
-
-  uint32_t sourceId = mask.getSourceId();
-  uint16_t apid = mask.getAPID();
-  uint16_t sequenceCount = mask.getPacketSequenceCount();
-
-  return buildRequestId(sourceId, apid, sequenceCount);
-}
-
-template <size_t MAX_NUM_TCS>
-inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::getRequestIdFromData(
-    const uint8_t *&data, size_t &dataSize, uint64_t &requestId) {
-  uint32_t srcId = 0;
-  uint16_t apid = 0;
-  uint16_t ssc = 0;
-
-  ReturnValue_t result = SerializeAdapter::deSerialize(&srcId, &data, &dataSize, DEF_END);
-  if (result != RETURN_OK) {
-    return result;
-  }
-  result = SerializeAdapter::deSerialize(&apid, &data, &dataSize, DEF_END);
-  if (result != RETURN_OK) {
-    return result;
-  }
-  result = SerializeAdapter::deSerialize(&ssc, &data, &dataSize, DEF_END);
-  if (result != RETURN_OK) {
-    return result;
-  }
-  requestId = buildRequestId(srcId, apid, ssc);
-
-  return RETURN_OK;
-}
-
-template <size_t MAX_NUM_TCS>
-inline uint64_t Service11TelecommandScheduling<MAX_NUM_TCS>::buildRequestId(uint32_t sourceId,
-                                                                            uint16_t apid,
-                                                                            uint16_t ssc) const {
-  uint64_t sourceId64 = static_cast<uint64_t>(sourceId);
-  uint64_t apid64 = static_cast<uint64_t>(apid);
-  uint64_t ssc64 = static_cast<uint64_t>(ssc);
-
-  return (sourceId64 << 32) | (apid64 << 16) | ssc64;
-}
-
-template <size_t MAX_NUM_TCS>
-inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::getMapFilterFromData(
-    const uint8_t *&data, size_t &dataSize, TcMapIter &itBegin, TcMapIter &itEnd) {
-  // get filter type first
-  uint32_t typeRaw = 0;
-  ReturnValue_t result = SerializeAdapter::deSerialize(&typeRaw, &data, &dataSize, DEF_END);
-  if (result != RETURN_OK) {
-    return result;
-  }
-
-  if (typeRaw > 3) {
-    return INVALID_TYPE_TIME_WINDOW;
-  }
-  TypeOfTimeWindow type = static_cast<TypeOfTimeWindow>(typeRaw);
-
-  // we now have the type of delete activity - so now we set the range to delete,
-  // according to the type of time window.
-  // NOTE: Blocks are used in this switch-case statement so that timestamps can be
-  // cleanly redefined for each case.
-  switch (type) {
-    case TypeOfTimeWindow::SELECT_ALL: {
-      itBegin = telecommandMap.begin();
-      itEnd = telecommandMap.end();
-      break;
-    }
-
-    case TypeOfTimeWindow::FROM_TIMETAG: {
-      uint32_t fromTimestamp = 0;
-      result = SerializeAdapter::deSerialize(&fromTimestamp, &data, &dataSize, DEF_END);
-      if (result != RETURN_OK) {
-        return result;
-      }
-
-      itBegin = telecommandMap.begin();
-      while (itBegin->first < fromTimestamp && itBegin != telecommandMap.end()) {
-        itBegin++;
-      }
-
-      itEnd = telecommandMap.end();
-      break;
-    }
-
-    case TypeOfTimeWindow::TO_TIMETAG: {
-      uint32_t toTimestamp;
-      result = SerializeAdapter::deSerialize(&toTimestamp, &data, &dataSize, DEF_END);
-      if (result != RETURN_OK) {
-        return result;
-      }
-      itBegin = telecommandMap.begin();
-      itEnd = telecommandMap.begin();
-      while (itEnd->first <= toTimestamp && itEnd != telecommandMap.end()) {
-        itEnd++;
-      }
-      break;
-    }
-
-    case TypeOfTimeWindow::FROM_TIMETAG_TO_TIMETAG: {
-      uint32_t fromTimestamp;
-      uint32_t toTimestamp;
-
-      result = SerializeAdapter::deSerialize(&fromTimestamp, &data, &dataSize,
-                                             SerializeIF::Endianness::BIG);
-      if (result != RETURN_OK) {
-        return result;
-      }
-      result = SerializeAdapter::deSerialize(&toTimestamp, &data, &dataSize,
-                                             SerializeIF::Endianness::BIG);
-      if (result != RETURN_OK) {
-        return result;
-      }
-      itBegin = telecommandMap.begin();
-      itEnd = telecommandMap.begin();
-
-      while (itBegin->first < fromTimestamp && itBegin != telecommandMap.end()) {
-        itBegin++;
-      }
-      while (itEnd->first <= toTimestamp && itEnd != telecommandMap.end()) {
-        itEnd++;
-      }
-      break;
-    }
-
-    default:
-      return RETURN_FAILED;
-  }
-
-  // additional security check, this should never be true
-  if (itBegin->first > itEnd->first) {
-    sif::printError("11::GetMapFilterFromData: itBegin > itEnd\n");
-    return RETURN_FAILED;
-  }
-
-  // the map range should now be set according to the sent filter.
-  return RETURN_OK;
-}
-
-template <size_t MAX_NUM_TCS>
-inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::handleInvalidData(
-    const char *ctx) {
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::warning << "Service11TelecommandScheduling:: " << ctx << ": Invalid buffer" << std::endl;
-#else
-  sif::printWarning("Service11TelecommandScheduling::%s: Invalid buffer\n", ctx);
-#endif
-#endif
-  return RETURN_FAILED;
-}
-
-template <size_t MAX_NUM_TCS>
-inline void Service11TelecommandScheduling<MAX_NUM_TCS>::debugPrintMultimapContent(void) const {
-#if FSFW_DISABLE_PRINTOUT == 0
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::debug << "Service11TelecommandScheduling::debugPrintMultimapContent: Multimap Content"
-             << std::endl;
-  sif::debug << "[" << dit->first << "]: Request ID: " << dit->second.requestId << " | "
-             << "Store Address: " << dit->second.storeAddr << std::endl;
-#else
-  sif::printDebug("Service11TelecommandScheduling::debugPrintMultimapContent: Multimap Content\n");
-  for (auto dit = telecommandMap.begin(); dit != telecommandMap.end(); ++dit) {
-    sif::printDebug("[%d]: Request ID: %d  | Store Address: %d\n", dit->first,
-                    dit->second.requestId, dit->second.storeAddr);
-  }
-#endif
-#endif
-}
--- a/src/fsfw/pus/Service1TelecommandVerification.cpp
+++ b/src/fsfw/pus/Service1TelecommandVerification.cpp
@@ -16,9 +16,7 @@ Service1TelecommandVerification::Service1TelecommandVerification(object_id_t obj
      apid(apid),
      serviceId(serviceId),
      targetDestination(targetDestination) {
-  auto mqArgs = MqArgs(objectId, static_cast<void*>(this));
-  tmQueue = QueueFactory::instance()->createMessageQueue(
-      messageQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  tmQueue = QueueFactory::instance()->createMessageQueue(messageQueueDepth);
 }

 Service1TelecommandVerification::~Service1TelecommandVerification() {
--- a/src/fsfw/pus/Service3Housekeeping.cpp
+++ b/src/fsfw/pus/Service3Housekeeping.cpp
@@ -214,11 +214,11 @@ ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
    default:
 #if FSFW_CPP_OSTREAM_ENABLED == 1
      sif::warning << "Service3Housekeeping::handleReply: Invalid reply with "
-                   << "reply command " << command << std::endl;
+                   << "reply command " << command << "!" << std::endl;
 #else
      sif::printWarning(
          "Service3Housekeeping::handleReply: Invalid reply with "
-          "reply command %hu\n",
+          "reply command %hu!\n",
          command);
 #endif
      return CommandingServiceBase::INVALID_REPLY;
--- a/src/fsfw/pus/Service5EventReporting.cpp
+++ b/src/fsfw/pus/Service5EventReporting.cpp
@@ -12,9 +12,7 @@ Service5EventReporting::Service5EventReporting(object_id_t objectId, uint16_t ap
                                               uint32_t messageQueueDepth)
    : PusServiceBase(objectId, apid, serviceId),
      maxNumberReportsPerCycle(maxNumberReportsPerCycle) {
-  auto mqArgs = MqArgs(objectId, static_cast<void*>(this));
-  eventQueue = QueueFactory::instance()->createMessageQueue(
-      messageQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  eventQueue = QueueFactory::instance()->createMessageQueue(messageQueueDepth);
 }

 Service5EventReporting::~Service5EventReporting() {
@@ -38,6 +36,9 @@ ReturnValue_t Service5EventReporting::performService() {
      }
    }
  }
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::warning << "Service5EventReporting::generateEventReport: Too many events" << std::endl;
+#endif
  return HasReturnvaluesIF::RETURN_OK;
 }

@@ -86,7 +87,7 @@ ReturnValue_t Service5EventReporting::handleRequest(uint8_t subservice) {
 // to be registered to the event manager to listen for events.
 ReturnValue_t Service5EventReporting::initialize() {
  EventManagerIF* manager = ObjectManager::instance()->get<EventManagerIF>(objects::EVENT_MANAGER);
-  if (manager == nullptr) {
+  if (manager == NULL) {
    return RETURN_FAILED;
  }
  // register Service 5 as listener for events
--- a/src/fsfw/pus/Service5EventReporting.h
+++ b/src/fsfw/pus/Service5EventReporting.h
@@ -41,7 +41,7 @@
 class Service5EventReporting : public PusServiceBase {
 public:
  Service5EventReporting(object_id_t objectId, uint16_t apid, uint8_t serviceId,
-                         size_t maxNumberReportsPerCycle, uint32_t messageQueueDepth);
+                         size_t maxNumberReportsPerCycle = 10, uint32_t messageQueueDepth = 10);
  virtual ~Service5EventReporting();

  /***
--- a/src/fsfw/pus/Service9TimeManagement.h
+++ b/src/fsfw/pus/Service9TimeManagement.h
@@ -6,10 +6,10 @@
 class Service9TimeManagement : public PusServiceBase {
 public:
  static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_9;
-  //!< Clock has been set. P1: New Uptime. P2: Old Uptime
-  static constexpr Event CLOCK_SET = MAKE_EVENT(0, severity::INFO);
-  //!< Clock could not be set. P1: Returncode.
-  static constexpr Event CLOCK_SET_FAILURE = MAKE_EVENT(1, severity::LOW);
+  static constexpr Event CLOCK_SET =
+      MAKE_EVENT(0, severity::INFO);  //!< Clock has been set. P1: New Uptime. P2: Old Uptime
+  static constexpr Event CLOCK_SET_FAILURE =
+      MAKE_EVENT(1, severity::LOW);  //!< Clock could not be set. P1: Returncode.

  static constexpr uint8_t CLASS_ID = CLASS_ID::PUS_SERVICE_9;

--- a/src/fsfw/returnvalues/FwClassIds.h
+++ b/src/fsfw/returnvalues/FwClassIds.h
@@ -72,7 +72,6 @@ enum : uint8_t {
  DLE_ENCODER,                    // DLEE
  PUS_SERVICE_3,                  // PUS3
  PUS_SERVICE_9,                  // PUS9
-  PUS_SERVICE_11,                 // PUS11
  FILE_SYSTEM,                    // FILS
  LINUX_OSAL,                     // UXOS
  HAL_SPI,                        // HSPI
--- a/src/fsfw/subsystem/Subsystem.h
+++ b/src/fsfw/subsystem/Subsystem.h
@@ -33,12 +33,8 @@ struct SequenceEntry : public TableSequenceBase {
 };

 /**
- * @brief   This class extends the SubsystemBase to perform the management of mode tables
- *          and mode sequences
+ * @brief   TODO: documentation missing
 * @details
- * This class is able to use mode tables and sequences to command all its children into the
- * right mode. Fallback sequences can be used to handle failed transitions or have a fallback
- * in case a component can't keep its current mode.
 */
 class Subsystem : public SubsystemBase, public HasModeSequenceIF {
 public:
--- a/src/fsfw/subsystem/SubsystemBase.cpp
+++ b/src/fsfw/subsystem/SubsystemBase.cpp
@@ -8,13 +8,11 @@ SubsystemBase::SubsystemBase(object_id_t setObjectId, object_id_t parent, Mode_t
                             uint16_t commandQueueDepth)
    : SystemObject(setObjectId),
      mode(initialMode),
+      commandQueue(QueueFactory::instance()->createMessageQueue(commandQueueDepth,
+                                                                CommandMessage::MAX_MESSAGE_SIZE)),
      healthHelper(this, setObjectId),
      modeHelper(this),
-      parentId(parent) {
-  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
-  commandQueue = QueueFactory::instance()->createMessageQueue(
-      commandQueueDepth, CommandMessage::MAX_MESSAGE_SIZE, &mqArgs);
-}
+      parentId(parent) {}

 SubsystemBase::~SubsystemBase() { QueueFactory::instance()->deleteMessageQueue(commandQueue); }

@@ -33,9 +31,8 @@ ReturnValue_t SubsystemBase::registerChild(object_id_t objectId) {
      info.mode = MODE_OFF;
    }
  } else {
-    // intentional to force an initial command during system startup
    info.commandQueue = child->getCommandQueue();
-    info.mode = HasModesIF::MODE_UNDEFINED;
+    info.mode = -1;  // intentional to force an initial command during system startup
  }

  info.submode = SUBMODE_NONE;
--- a/src/fsfw/subsystem/SubsystemBase.h
+++ b/src/fsfw/subsystem/SubsystemBase.h
@@ -15,14 +15,7 @@

 /**
 * @defgroup subsystems Subsystem Objects
- * All Subsystem and Assemblies can derive from this class. It contains helper classes to
- * perform mode and health handling, which allows OBSW developers to build a mode tree for
- * the whole satellite.
- *
- * Aside from setting up a mode tree and being able to executing mode tables, this class does not
- * provide an implementation on what to do with the features. To build a mode tree, helper classes
- * like the #AssemblyBase or the #Subsystem class extend and use the functionality of the base
- * class.
+ * Contains all Subsystem and Assemblies
 */
 class SubsystemBase : public SystemObject,
                      public HasModesIF,
@@ -103,7 +96,6 @@ class SubsystemBase : public SystemObject,
                                       Submode_t targetSubmode);

  /**
-   * This function takes care of sending all according mode commands specified inside a mode table.
   * We need to know the target Submode, as children are able to inherit the submode
   * Still, we have a default for all child implementations which do not use submode inheritance
   */
--- a/src/fsfw/tasks/FixedSlotSequence.cpp
+++ b/src/fsfw/tasks/FixedSlotSequence.cpp
@@ -164,5 +164,3 @@ ReturnValue_t FixedSlotSequence::intializeSequenceAfterTaskCreation() const {
 void FixedSlotSequence::addCustomCheck(ReturnValue_t (*customCheckFunction)(const SlotList&)) {
  this->customCheckFunction = customCheckFunction;
 }
-
-bool FixedSlotSequence::isEmpty() const { return slotList.empty(); }
--- a/src/fsfw/tasks/FixedSlotSequence.h
+++ b/src/fsfw/tasks/FixedSlotSequence.h
@@ -159,8 +159,6 @@ class FixedSlotSequence {
   */
  ReturnValue_t intializeSequenceAfterTaskCreation() const;

-  bool isEmpty() const;
-
 protected:
  /**
   * @brief	This list contains all PollingSlot objects, defining order and
--- a/src/fsfw/tasks/FixedTimeslotTaskIF.h
+++ b/src/fsfw/tasks/FixedTimeslotTaskIF.h
@@ -30,7 +30,7 @@ class FixedTimeslotTaskIF : public PeriodicTaskIF {
   * Check whether the sequence is valid and perform all other required
   * initialization steps which are needed after task creation
   */
-  virtual ReturnValue_t checkSequence() = 0;
+  virtual ReturnValue_t checkSequence() const = 0;
 };

 #endif /* FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_ */
--- a/src/fsfw/tasks/PeriodicTaskIF.h
+++ b/src/fsfw/tasks/PeriodicTaskIF.h
@@ -31,7 +31,7 @@ class PeriodicTaskIF {
   * Add an object to the task. The object needs to implement ExecutableObjectIF
   * @return
   */
-  virtual ReturnValue_t addComponent(object_id_t object, uint8_t opCode = 0) {
+  virtual ReturnValue_t addComponent(object_id_t object) {
    return HasReturnvaluesIF::RETURN_FAILED;
  };

@@ -41,15 +41,13 @@ class PeriodicTaskIF {
   * Add an object to the task.
   * @return
   */
-  virtual ReturnValue_t addComponent(ExecutableObjectIF* object, uint8_t opCode = 0) {
+  virtual ReturnValue_t addComponent(ExecutableObjectIF* object) {
    return HasReturnvaluesIF::RETURN_FAILED;
  };

  virtual ReturnValue_t sleepFor(uint32_t ms) = 0;

  virtual uint32_t getPeriodMs() const = 0;
-
-  virtual bool isEmpty() const = 0;
 };

 #endif /* PERIODICTASKIF_H_ */
--- a/src/fsfw/tcdistribution/TcDistributor.cpp
+++ b/src/fsfw/tcdistribution/TcDistributor.cpp
@@ -5,9 +5,7 @@
 #include "fsfw/tmtcservices/TmTcMessage.h"

 TcDistributor::TcDistributor(object_id_t objectId) : SystemObject(objectId) {
-  auto mqArgs = MqArgs(objectId);
-  tcQueue = QueueFactory::instance()->createMessageQueue(
-      DISTRIBUTER_MAX_PACKETS, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  tcQueue = QueueFactory::instance()->createMessageQueue(DISTRIBUTER_MAX_PACKETS);
 }

 TcDistributor::~TcDistributor() { QueueFactory::instance()->deleteMessageQueue(tcQueue); }
--- a/src/fsfw/thermal/AbstractTemperatureSensor.cpp
+++ b/src/fsfw/thermal/AbstractTemperatureSensor.cpp
@@ -4,13 +4,14 @@

 AbstractTemperatureSensor::AbstractTemperatureSensor(object_id_t setObjectid,
                                                     ThermalModuleIF *thermalModule)
-    : SystemObject(setObjectid), healthHelper(this, setObjectid), parameterHelper(this) {
-  if (thermalModule != nullptr) {
+    : SystemObject(setObjectid),
+      commandQueue(NULL),
+      healthHelper(this, setObjectid),
+      parameterHelper(this) {
+  if (thermalModule != NULL) {
    thermalModule->registerSensor(this);
  }
-  auto mqArgs = MqArgs(setObjectid, static_cast<void *>(this));
-  commandQueue = QueueFactory::instance()->createMessageQueue(
-      3, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  commandQueue = QueueFactory::instance()->createMessageQueue();
 }

 AbstractTemperatureSensor::~AbstractTemperatureSensor() {
--- a/src/fsfw/thermal/AbstractTemperatureSensor.h
+++ b/src/fsfw/thermal/AbstractTemperatureSensor.h
@@ -51,7 +51,7 @@ class AbstractTemperatureSensor : public HasHealthIF,
  HasHealthIF::HealthState getHealth();

 protected:
-  MessageQueueIF* commandQueue = nullptr;
+  MessageQueueIF* commandQueue;
  HealthHelper healthHelper;
  ParameterHelper parameterHelper;

--- a/src/fsfw/thermal/Heater.cpp
+++ b/src/fsfw/thermal/Heater.cpp
@@ -12,9 +12,7 @@ Heater::Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1)
      switch1(switch1),
      heaterOnCountdown(10800000) /*about two orbits*/,
      parameterHelper(this) {
-  auto mqArgs = MqArgs(objectId, static_cast<void*>(this));
-  eventQueue = QueueFactory::instance()->createMessageQueue(
-      3, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  eventQueue = QueueFactory::instance()->createMessageQueue();
 }

 Heater::~Heater() { QueueFactory::instance()->deleteMessageQueue(eventQueue); }
--- a/src/fsfw/timemanager/Countdown.cpp
+++ b/src/fsfw/timemanager/Countdown.cpp
@@ -1,11 +1,7 @@
 #include "fsfw/timemanager/Countdown.h"

-Countdown::Countdown(uint32_t initialTimeout, bool startImmediately) : timeout(initialTimeout) {
-  if (startImmediately) {
-    setTimeout(initialTimeout);
-  } else {
-    timeout = initialTimeout;
-  }
+Countdown::Countdown(uint32_t initialTimeout) : timeout(initialTimeout) {
+  setTimeout(initialTimeout);
 }

 Countdown::~Countdown() {}
--- a/src/fsfw/timemanager/Countdown.h
+++ b/src/fsfw/timemanager/Countdown.h
@@ -26,9 +26,8 @@ class Countdown {
   * Otherwise a call to hasTimedOut might return True.
   *
   * @param initialTimeout Countdown duration in milliseconds
-   * @param startImmediately  Set to false if countdown should not be started immediately
   */
-  Countdown(uint32_t initialTimeout = 0, bool startImmediately = true);
+  Countdown(uint32_t initialTimeout = 0);
  ~Countdown();
  /**
   * Call to set a new countdown duration.
--- a/src/fsfw/tmstorage/TmStoreBackendIF.h
+++ b/src/fsfw/tmstorage/TmStoreBackendIF.h
@@ -33,47 +33,50 @@ class TmStoreBackendIF : public HasParametersIF {
  static const ReturnValue_t INVALID_REQUEST = MAKE_RETURN_CODE(15);

  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::MEMORY;
-  //! Initiating sending data to store failed. Low, par1:
-  //! returnCode, par2: integer (debug info)
-  static const Event STORE_SEND_WRITE_FAILED = MAKE_EVENT(0, severity::LOW);
-  //! Data was sent, but writing failed. Low, par1: returnCode, par2: 0
-  static const Event STORE_WRITE_FAILED = MAKE_EVENT(1, severity::LOW);
-  //! Initiating reading data from store failed. Low, par1: returnCode, par2: 0
-  static const Event STORE_SEND_READ_FAILED = MAKE_EVENT(2, severity::LOW);
-  //! Data was requested, but access failed. Low, par1: returnCode, par2: 0
-  static const Event STORE_READ_FAILED = MAKE_EVENT(3, severity::LOW);
-  //! An unexpected TM packet or data message occurred. Low, par1: 0, par2: integer (debug info)
-  static const Event UNEXPECTED_MSG = MAKE_EVENT(4, severity::LOW);
-  //! Storing data failed. May simply be a full store. Low, par1: returnCode,
-  //! par2: integer (sequence count of failed packet).
-  static const Event STORING_FAILED = MAKE_EVENT(5, severity::LOW);
-  //! Dumping retrieved data failed. Low, par1: returnCode,
-  //! par2: integer (sequence count of failed packet).
-  static const Event TM_DUMP_FAILED = MAKE_EVENT(6, severity::LOW);
-  //! Corrupted init data or read error. Low, par1: returnCode, par2: integer (debug info)
-  //! Store was not initialized. Starts empty. Info, parameters both zero.
-  static const Event STORE_INIT_FAILED = MAKE_EVENT(7, severity::LOW);
-  //! Data was read out, but it is inconsistent. Low par1:
-  //! Memory address of corruption, par2: integer (debug info)
-  static const Event STORE_INIT_EMPTY = MAKE_EVENT(8, severity::INFO);
-
-  static const Event STORE_CONTENT_CORRUPTED = MAKE_EVENT(9, severity::LOW);
-  //! Info event indicating the store will be initialized, either at boot or after IOB switch.
-  //! Info. pars: 0
-  static const Event STORE_INITIALIZE = MAKE_EVENT(10, severity::INFO);
-  //! Info event indicating the store was successfully initialized, either at boot or after
-  //! IOB switch. Info. pars: 0
-  static const Event INIT_DONE = MAKE_EVENT(11, severity::INFO);
-  //! Info event indicating that dumping finished successfully.
-  //! par1: Number of dumped packets. par2: APID/SSC (16bits each)
-  static const Event DUMP_FINISHED = MAKE_EVENT(12, severity::INFO);
-  //! Info event indicating that deletion finished successfully.
-  //! par1:Number of deleted packets. par2: APID/SSC (16bits each)
-  static const Event DELETION_FINISHED = MAKE_EVENT(13, severity::INFO);
-  //! Info event indicating that something went wrong during deletion. pars: 0
-  static const Event DELETION_FAILED = MAKE_EVENT(14, severity::LOW);
-  //! Info that the a auto catalog report failed
-  static const Event AUTO_CATALOGS_SENDING_FAILED = MAKE_EVENT(15, severity::INFO);
+  static const Event STORE_SEND_WRITE_FAILED =
+      MAKE_EVENT(0, severity::LOW);  //!< Initiating sending data to store failed. Low, par1:
+                                     //!< returnCode, par2: integer (debug info)
+  static const Event STORE_WRITE_FAILED = MAKE_EVENT(
+      1, severity::LOW);  //!< Data was sent, but writing failed. Low, par1: returnCode, par2: 0
+  static const Event STORE_SEND_READ_FAILED =
+      MAKE_EVENT(2, severity::LOW);  //!< Initiating reading data from store failed. Low, par1:
+                                     //!< returnCode, par2: 0
+  static const Event STORE_READ_FAILED = MAKE_EVENT(
+      3, severity::LOW);  //!< Data was requested, but access failed. Low, par1: returnCode, par2: 0
+  static const Event UNEXPECTED_MSG =
+      MAKE_EVENT(4, severity::LOW);  //!< An unexpected TM packet or data message occurred. Low,
+                                     //!< par1: 0, par2: integer (debug info)
+  static const Event STORING_FAILED = MAKE_EVENT(
+      5, severity::LOW);  //!< Storing data failed. May simply be a full store. Low, par1:
+                          //!< returnCode, par2: integer (sequence count of failed packet).
+  static const Event TM_DUMP_FAILED =
+      MAKE_EVENT(6, severity::LOW);  //!< Dumping retrieved data failed. Low, par1: returnCode,
+                                     //!< par2: integer (sequence count of failed packet).
+  static const Event STORE_INIT_FAILED =
+      MAKE_EVENT(7, severity::LOW);  //!< Corrupted init data or read error. Low, par1: returnCode,
+                                     //!< par2: integer (debug info)
+  static const Event STORE_INIT_EMPTY = MAKE_EVENT(
+      8, severity::INFO);  //!< Store was not initialized. Starts empty. Info, parameters both zero.
+  static const Event STORE_CONTENT_CORRUPTED =
+      MAKE_EVENT(9, severity::LOW);  //!< Data was read out, but it is inconsistent. Low par1:
+                                     //!< Memory address of corruption, par2: integer (debug info)
+  static const Event STORE_INITIALIZE =
+      MAKE_EVENT(10, severity::INFO);  //!< Info event indicating the store will be initialized,
+                                       //!< either at boot or after IOB switch. Info. pars: 0
+  static const Event INIT_DONE = MAKE_EVENT(
+      11, severity::INFO);  //!< Info event indicating the store was successfully initialized,
+                            //!< either at boot or after IOB switch. Info. pars: 0
+  static const Event DUMP_FINISHED = MAKE_EVENT(
+      12, severity::INFO);  //!< Info event indicating that dumping finished successfully. par1:
+                            //!< Number of dumped packets. par2: APID/SSC (16bits each)
+  static const Event DELETION_FINISHED = MAKE_EVENT(
+      13, severity::INFO);  //!< Info event indicating that deletion finished successfully. par1:
+                            //!< Number of deleted packets. par2: APID/SSC (16bits each)
+  static const Event DELETION_FAILED = MAKE_EVENT(
+      14,
+      severity::LOW);  //!< Info event indicating that something went wrong during deletion. pars: 0
+  static const Event AUTO_CATALOGS_SENDING_FAILED =
+      MAKE_EVENT(15, severity::INFO);  //!< Info that the a auto catalog report failed

  virtual ~TmStoreBackendIF() {}

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Robin Mueller	7b767b238a	some more fixes	2022-05-10 16:58:34 +02:00
Robin Mueller	42ac1af4b2	update changelog	2022-05-10 16:55:22 +02:00
Robin Mueller	1e5ba0212e	possible fix for cicd	2022-05-10 16:53:33 +02:00
Robin Mueller	ac95e8f250	cmakelists update	2022-05-10 16:53:15 +02:00
Robin Mueller	1e569128c6	update auto-gen file	2022-05-10 16:48:23 +02:00
Robin Mueller	f35c4049c0	removed faulty include	2022-05-10 16:47:51 +02:00
Robin Mueller	5d946f5640	commit seems to change	2022-05-10 16:46:03 +02:00
Robin Mueller	f57bd290d9	this compiles	2022-05-10 16:43:16 +02:00
Robin Mueller	aa4e2d7209	remove custom command which reset .h.in file	2022-05-10 16:13:32 +02:00
Robin Mueller	58cb96ece0	update changelog	2022-05-10 12:28:40 +02:00
Robin Mueller	88cc8c46a1	this appears to do the trick	2022-05-10 12:26:21 +02:00