missing call added

spi mutex handling refactoring
Merge pull request 'preproc guards' (#612 ) from eive/fsfw:mueller/missing-preproc-defs into development
2022-05-14 16:57:59 +02:00 · 2022-05-14 11:32:51 +02:00 · 2022-05-13 13:22:38 +02:00 · 2022-05-13 12:01:40 +02:00 · 2022-05-13 11:57:22 +02:00 · 2022-05-13 11:56:37 +02:00
40 changed files with 1274 additions and 807 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -25,18 +25,41 @@ 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
 - 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
- Clock: 
+
-  - `timeval` to `TimeOfDay_t`
+### HAL
-  - 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
+- HAL Linux SPI: Set the Clock Default State when setting new SPI speed
-  - Better check for leap seconds
+  and mode
-  - Added Unittests for Clock (only getter)
+  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
 ## Removed
@ -46,12 +69,30 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 ## 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 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
 ## Fixed
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -4,10 +4,10 @@ set(LIB_FSFW_NAME fsfw)
 project(${LIB_FSFW_NAME})
 if(NOT CMAKE_CXX_STANDARD)
-    set(CMAKE_CXX_STANDARD 17)
+  set(CMAKE_CXX_STANDARD 17)
-    set(CMAKE_CXX_STANDARD_REQUIRED True)
+  set(CMAKE_CXX_STANDARD_REQUIRED True)
 elseif(${CMAKE_CXX_STANDARD} LESS 17)
-    message(FATAL_ERROR "Compiling the FSFW requires a minimum of C++17 support")
+  message(FATAL_ERROR "Compiling the FSFW requires a minimum of C++17 support")
 endif()
 set(FSFW_VERSION 4)
@ -17,34 +17,48 @@ set(FSFW_REVISION 0)
 # Add the cmake folder so the FindSphinx module is found
 set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
-set(FSFW_ETL_LIB_MAJOR_VERSION 20 CACHE STRING
+set(FSFW_ETL_LIB_NAME etl)
-    "ETL library major version requirement"
+set(FSFW_ETL_LIB_MAJOR_VERSION
-)
+    20
-set(FSFW_ETL_LIB_VERSION ${FSFW_ETL_LIB_MAJOR_VERSION}.27.3 CACHE STRING
+    CACHE STRING "ETL library major version requirement")
-    "ETL library exact 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
+set(FSFW_CATCH2_LIB_MAJOR_VERSION
-    "Catch2 library major version requirement"
+    3
-)
+    CACHE STRING "Catch2 library major version requirement")
-set(FSFW_CATCH2_LIB_VERSION v${FSFW_CATCH2_LIB_MAJOR_VERSION}.0.0-preview5 CACHE STRING
+set(FSFW_CATCH2_LIB_VERSION
-    "Catch2 library exact version requirement"
+    v${FSFW_CATCH2_LIB_MAJOR_VERSION}.0.0-preview5
-)
+    CACHE STRING "Catch2 library exact version requirement")
-set(FSFW_ETL_LIB_NAME etl)
+# Keep this off by default for now. See PR:
-
+# https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/616 for information which
-option(FSFW_GENERATE_SECTIONS
+# keeping this on by default is problematic
-    "Generate function and data sections. Required to remove unused code" ON
+option(
-)
+  FSFW_ENABLE_IPO
-if(FSFW_GENERATE_SECTIONS)
+  "Enable interprocedural optimization or link-time optimization if available"
-    option(FSFW_REMOVE_UNUSED_CODE "Remove unused code" ON)
+  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()
-option(FSFW_BUILD_UNITTESTS "Build unittest binary in addition to static library" OFF)
+option(FSFW_GENERATE_SECTIONS
       "Generate function and data sections. Required to remove unused code" ON)
 if(FSFW_GENERATE_SECTIONS)
  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_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)
@ -65,52 +79,61 @@ 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 "Building the FSFW unittests in addition to the static library")
+  message(
-    # Check whether the user has already installed Catch2 first
+    STATUS "Building the FSFW unittests in addition to the static library")
-    find_package(Catch2 ${FSFW_CATCH2_LIB_MAJOR_VERSION})
+  # Check whether the user has already installed Catch2 first
-    # Not installed, so use FetchContent to download and provide Catch2
+  find_package(Catch2 ${FSFW_CATCH2_LIB_MAJOR_VERSION})
-    if(NOT Catch2_FOUND)
+  # Not installed, so use FetchContent to download and provide Catch2
-        message(STATUS "Catch2 installation not found. Downloading Catch2 library with FetchContent")
+  if(NOT Catch2_FOUND)
-        include(FetchContent)
+    message(
      STATUS
        "Catch2 installation not found. Downloading Catch2 library with FetchContent"
    )
    include(FetchContent)
-        FetchContent_Declare(
+    FetchContent_Declare(
-            Catch2
+      Catch2
-            GIT_REPOSITORY https://github.com/catchorg/Catch2.git
+      GIT_REPOSITORY https://github.com/catchorg/Catch2.git
-            GIT_TAG        ${FSFW_CATCH2_LIB_VERSION}
+      GIT_TAG ${FSFW_CATCH2_LIB_VERSION})
        )
-        list(APPEND FSFW_FETCH_CONTENT_TARGETS Catch2)
+    list(APPEND FSFW_FETCH_CONTENT_TARGETS Catch2)
-    endif()
+  endif()
-    set(FSFW_CONFIG_PATH tests/src/fsfw_tests/unit/testcfg)
+  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/FSFWConfig.h.in FSFWConfig.h)
-    configure_file(tests/src/fsfw_tests/unit/testcfg/TestsConfig.h.in tests/TestsConfig.h)
+  configure_file(tests/src/fsfw_tests/unit/testcfg/TestsConfig.h.in
                 tests/TestsConfig.h)
-    project(${FSFW_TEST_TGT} CXX C)
+  project(${FSFW_TEST_TGT} CXX C)
-    add_executable(${FSFW_TEST_TGT})
+  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)
+  if(FSFW_TESTS_GEN_COV)
-        message(STATUS "Generating coverage data for the library")
+    message(STATUS "Generating coverage data for the library")
-        message(STATUS "Targets linking against ${LIB_FSFW_NAME} "
+    message(STATUS "Targets linking against ${LIB_FSFW_NAME} "
-            "will be compiled with coverage data as well"
+                   "will be compiled with coverage data as well")
-        )
+    include(FetchContent)
-        include(FetchContent)
+    FetchContent_Declare(
-        FetchContent_Declare(
+      cmake-modules GIT_REPOSITORY https://github.com/bilke/cmake-modules.git)
-            cmake-modules
+    FetchContent_MakeAvailable(cmake-modules)
-            GIT_REPOSITORY https://github.com/bilke/cmake-modules.git
+    set(CMAKE_BUILD_TYPE "Debug")
-        )
+    list(APPEND CMAKE_MODULE_PATH ${cmake-modules_SOURCE_DIR})
-        FetchContent_MakeAvailable(cmake-modules)
+    include(CodeCoverage)
-        set(CMAKE_BUILD_TYPE "Debug")
+  endif()
        list(APPEND CMAKE_MODULE_PATH ${cmake-modules_SOURCE_DIR})
        include(CodeCoverage)
    endif()
 endif()
 message(STATUS "Finding and/or providing ETL library")
@ -119,34 +142,33 @@ message(STATUS "Finding and/or providing ETL library")
 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
+  message(
-        "No ETL installation was found with find_package. Installing and providing "
+    STATUS
-        "etl with FindPackage"
+      "No ETL installation was found with find_package. Installing and providing "
-    )
+      "etl with FindPackage")
-    include(FetchContent)
+  include(FetchContent)
-    FetchContent_Declare(
+  FetchContent_Declare(
-        ${FSFW_ETL_LIB_NAME}
+    ${FSFW_ETL_LIB_NAME}
-        GIT_REPOSITORY https://github.com/ETLCPP/etl
+    GIT_REPOSITORY https://github.com/ETLCPP/etl
-        GIT_TAG        ${FSFW_ETL_LIB_VERSION}
+    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})
+  FetchContent_MakeAvailable(${FSFW_FETCH_CONTENT_TARGETS})
-    if(TARGET ${FSFW_ETL_LIB_NAME})
+  if(TARGET ${FSFW_ETL_LIB_NAME})
-        add_library(${FSFW_ETL_LINK_TARGET} ALIAS ${FSFW_ETL_LIB_NAME})
+    add_library(${FSFW_ETL_LINK_TARGET} ALIAS ${FSFW_ETL_LIB_NAME})
-    endif()
+  endif()
-    if(TARGET Catch2)
+  if(TARGET Catch2)
-        # Fixes regression -preview4, to be confirmed in later releases
+    # Fixes regression -preview4, to be confirmed in later releases Related
-        # Related GitHub issue: https://github.com/catchorg/Catch2/issues/2417
+    # GitHub issue: https://github.com/catchorg/Catch2/issues/2417
-        set_target_properties(Catch2 PROPERTIES DEBUG_POSTFIX "")
+    set_target_properties(Catch2 PROPERTIES DEBUG_POSTFIX "")
-    endif()
+  endif()
 endif()
 set(FSFW_CORE_INC_PATH "inc")
@ -154,59 +176,51 @@ 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
+target_include_directories(${LIB_FSFW_NAME} PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
-    ${CMAKE_CURRENT_BINARY_DIR}
+target_include_directories(${LIB_FSFW_NAME}
-)
+                           INTERFACE ${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 "Please pass the FSFW OSAL as FSFW_OSAL instead of OS_FSFW")
+  message(WARNING "Please pass the FSFW OSAL as FSFW_OSAL instead of OS_FSFW")
-    set(FSFW_OSAL 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")
+  message(STATUS "No OS for FSFW via FSFW_OSAL set. Assuming host OS")
-	# Assume host OS and autodetermine from OS_FSFW
+  # Assume host OS and autodetermine from OS_FSFW
-	if(UNIX)
+  if(UNIX)
-		set(FSFW_OSAL  "linux" 
+    set(FSFW_OSAL
-			CACHE STRING 
+        "linux"
-			"OS abstraction layer used in the FSFW"
+        CACHE STRING "OS abstraction layer used in the FSFW")
-		)
+  elseif(WIN32)
-	elseif(WIN32)
+    set(FSFW_OSAL
-		set(FSFW_OSAL  "host" 
+        "host"
-			CACHE STRING "OS abstraction layer used in the FSFW"
+        CACHE STRING "OS abstraction layer used in the FSFW")
-		)
+  endif()
 	endif()
 endif()
 set(FSFW_OSAL_DEFINITION FSFW_OSAL_HOST)
 if(FSFW_OSAL MATCHES host)
-    set(FSFW_OS_NAME "Host")
+  set(FSFW_OS_NAME "Host")
-    set(FSFW_OSAL_HOST ON)
+  set(FSFW_OSAL_HOST ON)
 elseif(FSFW_OSAL MATCHES linux)
-    set(FSFW_OS_NAME "Linux")
+  set(FSFW_OS_NAME "Linux")
-    set(FSFW_OSAL_LINUX ON)
+  set(FSFW_OSAL_LINUX ON)
 elseif(FSFW_OSAL MATCHES freertos)
-    set(FSFW_OS_NAME "FreeRTOS")
+  set(FSFW_OS_NAME "FreeRTOS")
-    set(FSFW_OSAL_FREERTOS ON)
+  set(FSFW_OSAL_FREERTOS ON)
-    target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+  target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${LIB_OS_NAME})
        ${LIB_OS_NAME}
    )
 elseif(FSFW_OSAL STREQUAL rtems)
-    set(FSFW_OS_NAME "RTEMS")
+  set(FSFW_OS_NAME "RTEMS")
-    set(FSFW_OSAL_RTEMS ON)
+  set(FSFW_OSAL_RTEMS ON)
 else()
-    message(WARNING
+  message(
-        "Invalid operating system for FSFW specified! Setting to host.."
+    WARNING "Invalid operating system for FSFW specified! Setting to host..")
-    )
+  set(FSFW_OS_NAME "Host")
-    set(FSFW_OS_NAME "Host")
+  set(OS_FSFW "host")
    set(OS_FSFW "host")
 endif()
 configure_file(src/fsfw/FSFW.h.in fsfw/FSFW.h)
@ -217,206 +231,178 @@ message(STATUS "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(FSFW_TESTS_GEN_COV)
-        if(CMAKE_COMPILER_IS_GNUCXX)
+    if(CMAKE_COMPILER_IS_GNUCXX)
-            include(CodeCoverage)
+      include(CodeCoverage)
-            # Remove quotes.
+      # Remove quotes.
-            separate_arguments(COVERAGE_COMPILER_FLAGS
+      separate_arguments(COVERAGE_COMPILER_FLAGS NATIVE_COMMAND
-                NATIVE_COMMAND "${COVERAGE_COMPILER_FLAGS}"
+                         "${COVERAGE_COMPILER_FLAGS}")
            )
-            # Add compile options manually, we don't want coverage for Catch2
+      # Add compile options manually, we don't want coverage for Catch2
-            target_compile_options(${FSFW_TEST_TGT} PRIVATE
+      target_compile_options(${FSFW_TEST_TGT}
-                "${COVERAGE_COMPILER_FLAGS}"
+                             PRIVATE "${COVERAGE_COMPILER_FLAGS}")
-            )
+      target_compile_options(${LIB_FSFW_NAME}
-            target_compile_options(${LIB_FSFW_NAME} PRIVATE
+                             PRIVATE "${COVERAGE_COMPILER_FLAGS}")
                "${COVERAGE_COMPILER_FLAGS}"
            )
-            # Exclude directories here
+      # Exclude directories here
-            if(WIN32)
+      if(WIN32)
-                set(GCOVR_ADDITIONAL_ARGS
+        set(GCOVR_ADDITIONAL_ARGS "--exclude-throw-branches"
-                    "--exclude-throw-branches"
+                                  "--exclude-unreachable-branches")
-                    "--exclude-unreachable-branches"
+        set(COVERAGE_EXCLUDES "/c/msys64/mingw64/*" "*/fsfw_hal/*")
-                )
+      elseif(UNIX)
-                set(COVERAGE_EXCLUDES
+        set(COVERAGE_EXCLUDES
-                    "/c/msys64/mingw64/*" "*/fsfw_hal/*"
+            "/usr/include/*"
-                )
+            "/usr/bin/*"
-            elseif(UNIX)
+            "Catch2/*"
-                set(COVERAGE_EXCLUDES
+            "/usr/local/include/*"
-                    "/usr/include/*" "/usr/bin/*" "Catch2/*"
+            "*/fsfw_tests/*"
-                    "/usr/local/include/*" "*/fsfw_tests/*"
+            "*/catch2-src/*"
-                    "*/catch2-src/*" "*/fsfw_hal/*"
+            "*/fsfw_hal/*")
-                )
+      endif()
            endif()
-            target_link_options(${FSFW_TEST_TGT} PRIVATE
+      target_link_options(${FSFW_TEST_TGT} PRIVATE -fprofile-arcs
-                -fprofile-arcs
+                          -ftest-coverage)
-                -ftest-coverage
+      target_link_options(${LIB_FSFW_NAME} PRIVATE -fprofile-arcs
-            )
+                          -ftest-coverage)
-            target_link_options(${LIB_FSFW_NAME} PRIVATE
+      # Need to specify this as an interface, otherwise there will the compile
-                -fprofile-arcs
+      # issues
-                -ftest-coverage
+      target_link_options(${LIB_FSFW_NAME} INTERFACE -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)
+      if(WIN32)
-                setup_target_for_coverage_gcovr_html(
+        setup_target_for_coverage_gcovr_html(
-                    NAME ${FSFW_TEST_TGT}_coverage
+          NAME ${FSFW_TEST_TGT}_coverage EXECUTABLE ${FSFW_TEST_TGT}
-                    EXECUTABLE ${FSFW_TEST_TGT}
+          DEPENDENCIES ${FSFW_TEST_TGT})
-                    DEPENDENCIES ${FSFW_TEST_TGT}
+      else()
-                )
+        setup_target_for_coverage_lcov(
-            else()
+          NAME ${FSFW_TEST_TGT}_coverage EXECUTABLE ${FSFW_TEST_TGT}
-                setup_target_for_coverage_lcov(
+          DEPENDENCIES ${FSFW_TEST_TGT})
-                    NAME ${FSFW_TEST_TGT}_coverage
+      endif()
                    EXECUTABLE ${FSFW_TEST_TGT}
                    DEPENDENCIES ${FSFW_TEST_TGT}
                )
            endif()
        endif()
    endif()
-    target_link_libraries(${FSFW_TEST_TGT} PRIVATE Catch2::Catch2 ${LIB_FSFW_NAME})
+  endif()
  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.
+# The project CMakeLists file has to set the FSFW_CONFIG_PATH and add it. If
-# If this is not given, we include the default configuration and emit a warning.
+# 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)
+  set(DEF_CONF_PATH misc/defaultcfg/fsfwconfig)
-    if(NOT FSFW_BUILD_DOCS)
+  if(NOT FSFW_BUILD_DOCS)
-        message(WARNING "Flight Software Framework configuration path not set!")
+    message(WARNING "Flight Software Framework configuration path not set!")
-        message(WARNING "Setting default configuration from ${DEF_CONF_PATH} ..")
+    message(WARNING "Setting default configuration from ${DEF_CONF_PATH} ..")
-    endif()
+  endif()
-    add_subdirectory(${DEF_CONF_PATH})
+  add_subdirectory(${DEF_CONF_PATH})
-    set(FSFW_CONFIG_PATH ${DEF_CONF_PATH})
+  set(FSFW_CONFIG_PATH ${DEF_CONF_PATH})
 endif()
-# FSFW might be part of a possibly complicated folder structure, so we 
+# FSFW might be part of a possibly complicated folder structure, so we extract
-# extract the absolute path of the fsfwconfig folder.
+# 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
+  get_filename_component(FSFW_CONFIG_PATH_ABSOLUTE ${FSFW_CONFIG_PATH} REALPATH
-		${FSFW_CONFIG_PATH} REALPATH BASE_DIR ${CMAKE_SOURCE_DIR}
+                         BASE_DIR ${CMAKE_SOURCE_DIR})
 	)
 endif()
 foreach(INCLUDE_PATH ${FSFW_ADDITIONAL_INC_PATHS})
-    if(IS_ABSOLUTE ${INCLUDE_PATH})
+  if(IS_ABSOLUTE ${INCLUDE_PATH})
-        set(CURR_ABS_INC_PATH "${INCLUDE_PATH}")
+    set(CURR_ABS_INC_PATH "${INCLUDE_PATH}")
-    else()
+  else()
-        get_filename_component(CURR_ABS_INC_PATH
+    get_filename_component(CURR_ABS_INC_PATH ${INCLUDE_PATH} REALPATH BASE_DIR
-            ${INCLUDE_PATH} REALPATH BASE_DIR ${CMAKE_SOURCE_DIR})
+                           ${CMAKE_SOURCE_DIR})
-    endif()
+  endif()
-    if(CMAKE_VERBOSE)
+  if(CMAKE_VERBOSE)
-        message(STATUS "FSFW include path: ${CURR_ABS_INC_PATH}")
+    message(STATUS "FSFW include path: ${CURR_ABS_INC_PATH}")
-    endif()
+  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)
+  if(NOT DEFINED FSFW_WARNING_FLAGS)
-	   set(FSFW_WARNING_FLAGS
+    set(FSFW_WARNING_FLAGS
-		  -Wall
+        -Wall
-		  -Wextra
+        -Wextra
-		  -Wimplicit-fallthrough=1
+        -Wimplicit-fallthrough=1
-		  -Wno-unused-parameter
+        -Wno-unused-parameter
-		  -Wno-psabi
+        -Wno-psabi
-          -Wduplicated-cond # check for duplicate conditions
+        -Wduplicated-cond # check for duplicate conditions
-          -Wduplicated-branches # check for duplicate branches
+        -Wduplicated-branches # check for duplicate branches
-          -Wlogical-op # Search for bitwise operations instead of logical 
+        -Wlogical-op # Search for bitwise operations instead of logical
-          -Wnull-dereference # Search for NULL dereference
+        -Wnull-dereference # Search for NULL dereference
-          -Wundef # Warn if undefind marcos are used
+        -Wundef # Warn if undefind marcos are used
-          -Wformat=2 # Format string problem detection
+        -Wformat=2 # Format string problem detection
-          -Wformat-overflow=2 # Formatting issues in printf
+        -Wformat-overflow=2 # Formatting issues in printf
-          -Wformat-truncation=2 # Formatting issues in printf
+        -Wformat-truncation=2 # Formatting issues in printf
-          -Wformat-security # Search for dangerous printf operations
+        -Wformat-security # Search for dangerous printf operations
-          -Wstrict-overflow=3 # Warn if integer overflows might happen
+        -Wstrict-overflow=3 # Warn if integer overflows might happen
-          -Warray-bounds=2 # Some array bounds violations will be found
+        -Warray-bounds=2 # Some array bounds violations will be found
-          -Wshift-overflow=2 # Search for bit left shift overflows (<c++14)
+        -Wshift-overflow=2 # Search for bit left shift overflows (<c++14)
-          -Wcast-qual # Warn if the constness is cast away
+        -Wcast-qual # Warn if the constness is cast away
-          -Wstringop-overflow=4
+        -Wstringop-overflow=4
-          # -Wstack-protector # Emits a few false positives for low level access
+        # -Wstack-protector # Emits a few false positives for low level access
-          # -Wconversion # Creates many false positives
+        # -Wconversion # Creates many false positives -Warith-conversion # Use
-          # -Warith-conversion # Use with Wconversion to find more implicit conversions
+        # with Wconversion to find more implicit conversions -fanalyzer # Should
-          # -fanalyzer # Should be used to look through problems
+        # be used to look through problems
-        )
+    )
-    endif()
+  endif()
-    if(FSFW_GENERATE_SECTIONS)
+  if(FSFW_GENERATE_SECTIONS)
-        target_compile_options(${LIB_FSFW_NAME} PRIVATE
+    target_compile_options(${LIB_FSFW_NAME} PRIVATE "-ffunction-sections"
-            "-ffunction-sections"
+                                                    "-fdata-sections")
-            "-fdata-sections"
+  endif()
-        )
+
-    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_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 
+target_include_directories(
-	${CMAKE_SOURCE_DIR}
+  ${LIB_FSFW_NAME} INTERFACE ${CMAKE_SOURCE_DIR} ${FSFW_CONFIG_PATH_ABSOLUTE}
-	${FSFW_CONFIG_PATH_ABSOLUTE}
+                             ${FSFW_CORE_INC_PATH} ${FSFW_ADD_INC_PATHS_ABS})
 	${FSFW_CORE_INC_PATH}
 	${FSFW_ADD_INC_PATHS_ABS}
 )
-# Includes path required to compile FSFW itself as well
+# Includes path required to compile FSFW itself as well We assume that the
-# We assume that the fsfwconfig folder uses include relative to the project
+# fsfwconfig folder uses include relative to the project root here!
-# root here!
+target_include_directories(
-target_include_directories(${LIB_FSFW_NAME} PRIVATE 
+  ${LIB_FSFW_NAME} PRIVATE ${CMAKE_SOURCE_DIR} ${FSFW_CONFIG_PATH_ABSOLUTE}
-	${CMAKE_SOURCE_DIR}
+                           ${FSFW_CORE_INC_PATH} ${FSFW_ADD_INC_PATHS_ABS})
 	${FSFW_CONFIG_PATH_ABSOLUTE}
 	${FSFW_CORE_INC_PATH}
 	${FSFW_ADD_INC_PATHS_ABS}
 )
-target_compile_options(${LIB_FSFW_NAME} PRIVATE 
+target_compile_options(${LIB_FSFW_NAME} PRIVATE ${FSFW_WARNING_FLAGS}
-	${FSFW_WARNING_FLAGS}
+                                                ${COMPILER_FLAGS})
 	${COMPILER_FLAGS}
 )
-target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${FSFW_ETL_LINK_TARGET}
-    ${FSFW_ETL_LINK_TARGET}
+                                               ${FSFW_ADDITIONAL_LINK_LIBS})
    ${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}
+  TARGET ${LIB_FSFW_NAME}
-   POST_BUILD
+  POST_BUILD
-   COMMENT ${POST_BUILD_COMMENT}
+  COMMENT ${POST_BUILD_COMMENT})
 )
--- a/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.cpp
+++ b/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.cpp
@ -20,7 +20,9 @@ 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;
  }
@ -96,8 +98,10 @@ 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;
@ -108,8 +112,10 @@ 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;
@ -133,8 +139,10 @@ 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;
@ -153,10 +161,12 @@ 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;
  }
@ -175,7 +185,9 @@ 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;
    }
@ -204,7 +216,9 @@ 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;
  }
--- a/hal/src/fsfw_hal/linux/spi/ManualCsLockGuard.h
+++ b/hal/src/fsfw_hal/linux/spi/ManualCsLockGuard.h
@ -0,0 +1,43 @@
 #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
@ -196,16 +196,22 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
  bool fullDuplex = spiCookie->isFullDuplex();
  gpioId_t gpioId = spiCookie->getChipSelectPin();
  bool csLockManual = spiCookie->getCsLockManual();
-  /* Pull SPI CS low. For now, no support for active high given  */
+  MutexIF::TimeoutType csType;
-  if (gpioId != gpio::NO_GPIO) {
+  dur_millis_t csTimeout = 0;
-    result = spiMutex->lockMutex(timeoutType, timeoutMs);
+  // 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);
    if (result != RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::error << "SpiComIF::sendMessage: Failed to lock mutex" << std::endl;
+      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\n");
+      sif::printError("SpiComIF::sendMessage: Failed to lock mutex with code %d\n", result);
 #endif
 #endif
      return result;
@ -248,7 +254,7 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
    }
  }
-  if (gpioId != gpio::NO_GPIO) {
+  if (gpioId != gpio::NO_GPIO and not csLockManual) {
    gpioComIF->pullHigh(gpioId);
    result = spiMutex->unlockMutex();
    if (result != RETURN_OK) {
@ -292,12 +298,27 @@ ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
    return result;
  }
  bool csLockManual = spiCookie->getCsLockManual();
  gpioId_t gpioId = spiCookie->getChipSelectPin();
 <<<<<<< Updated upstream
  if (gpioId != gpio::NO_GPIO) {
    result = spiMutex->lockMutex(timeoutType, timeoutMs);
 =======
  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);
 >>>>>>> Stashed changes
    if (result != RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::error << "SpiComIF::getSendSuccess: Failed to lock mutex" << std::endl;
+      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
 #endif
      return result;
    }
@ -315,7 +336,7 @@ ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
    result = HALF_DUPLEX_TRANSFER_FAILED;
  }
-  if (gpioId != gpio::NO_GPIO) {
+  if (gpioId != gpio::NO_GPIO and not csLockManual) {
    gpioComIF->pullHigh(gpioId);
    result = spiMutex->unlockMutex();
    if (result != RETURN_OK) {
@ -346,6 +367,7 @@ ReturnValue_t SpiComIF::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
  return HasReturnvaluesIF::RETURN_OK;
 }
 <<<<<<< Updated upstream
 MutexIF* SpiComIF::getMutex(MutexIF::TimeoutType* timeoutType, uint32_t* timeoutMs) {
  if (timeoutType != nullptr) {
    *timeoutType = this->timeoutType;
@ -355,6 +377,9 @@ MutexIF* SpiComIF::getMutex(MutexIF::TimeoutType* timeoutType, uint32_t* timeout
  }
  return spiMutex;
 }
 =======
 MutexIF* SpiComIF::getCsMutex() { return csMutex; }
 >>>>>>> Stashed changes
 void SpiComIF::performSpiWiretapping(SpiCookie* spiCookie) {
  if (spiCookie == nullptr) {
--- a/hal/src/fsfw_hal/linux/spi/SpiComIF.h
+++ b/hal/src/fsfw_hal/linux/spi/SpiComIF.h
@ -22,15 +22,15 @@ class SpiCookie;
 */
 class SpiComIF : public DeviceCommunicationIF, public SystemObject {
 public:
-  static constexpr uint8_t spiRetvalId = CLASS_ID::HAL_SPI;
+  static constexpr uint8_t CLASS_ID = CLASS_ID::HAL_SPI;
  static constexpr ReturnValue_t OPENING_FILE_FAILED =
-      HasReturnvaluesIF::makeReturnCode(spiRetvalId, 0);
+      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 0);
  /* Full duplex (ioctl) transfer failure */
  static constexpr ReturnValue_t FULL_DUPLEX_TRANSFER_FAILED =
-      HasReturnvaluesIF::makeReturnCode(spiRetvalId, 1);
+      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 1);
  /* Half duplex (read/write) transfer failure */
  static constexpr ReturnValue_t HALF_DUPLEX_TRANSFER_FAILED =
-      HasReturnvaluesIF::makeReturnCode(spiRetvalId, 2);
+      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 2);
  SpiComIF(object_id_t objectId, GpioIF* gpioComIF);
@ -44,7 +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* getMutex(MutexIF::TimeoutType* timeoutType = nullptr, uint32_t* timeoutMs = nullptr);
+  MutexIF* getCsMutex();
  /**
   * Perform a regular send operation using Linux iotcl. This is public so it can be used
@ -70,10 +70,13 @@ 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* 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
@ -107,3 +107,17 @@ 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,6 +2,8 @@
 #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"
@ -20,6 +22,8 @@
 */
 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
@ -139,9 +143,43 @@ 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;
  std::string spiDevice;
  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
@ -154,27 +192,8 @@ class SpiCookie : public CookieIF {
   * @param args
   */
  SpiCookie(spi::SpiComIfModes comIfMode, address_t spiAddress, gpioId_t chipSelect,
-            std::string spiDev, const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed,
+            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/UartComIF.cpp
+++ b/hal/src/fsfw_hal/linux/uart/UartComIF.cpp
@ -314,7 +314,7 @@ void UartComIF::configureBaudrate(struct termios* options, UartCookie* uartCooki
      cfsetispeed(options, B4000000);
      cfsetospeed(options, B4000000);
      break;
-#endif // ! __APPLE__
+#endif  // ! __APPLE__
    default:
 #if FSFW_CPP_OSTREAM_ENABLED == 1
      sif::warning << "UartComIF::configureBaudrate: Baudrate not supported" << std::endl;
--- a/scripts/apply-clang-format.sh
+++ b/scripts/apply-clang-format.sh
@ -1,8 +0,0 @@
 #!/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
@ -0,0 +1,22 @@
 #!/bin/bash
 if [[ ! -f README.md ]]; then
  cd ..
 fi
 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
  find ./src ${file_selectors} | xargs clang-format --style=file -i
  find ./hal ${file_selectors} | xargs clang-format --style=file -i
  find ./tests ${file_selectors} | xargs clang-format --style=file -i
 else
  echo "No ${cpp_format} tool found, not formatting C++/C files"
 fi
--- a/src/fsfw/container/FIFOBase.tpp
+++ b/src/fsfw/container/FIFOBase.tpp
@ -5,89 +5,88 @@
 #error Include FIFOBase.h before FIFOBase.tpp!
 #endif
-template<typename T>
+template <typename T>
-inline FIFOBase<T>::FIFOBase(T* values, const size_t maxCapacity):
+inline FIFOBase<T>::FIFOBase(T* values, const size_t maxCapacity)
-        maxCapacity(maxCapacity), values(values){};
+    : maxCapacity(maxCapacity), values(values){};
-template<typename T>
+template <typename T>
 inline ReturnValue_t FIFOBase<T>::insert(T value) {
-    if (full()) {
+  if (full()) {
-        return FULL;
+    return FULL;
-    } else {
+  } else {
-        values[writeIndex] = value;
+    values[writeIndex] = value;
-        writeIndex = next(writeIndex);
+    writeIndex = next(writeIndex);
-        ++currentSize;
+    ++currentSize;
-        return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
-    }
+  }
 };
-template<typename T>
+template <typename T>
 inline ReturnValue_t FIFOBase<T>::retrieve(T* value) {
-    if (empty()) {
+  if (empty()) {
-        return EMPTY;
+    return EMPTY;
-    } else {
+  } else {
-        if (value == nullptr){
+    if (value == nullptr) {
-            return HasReturnvaluesIF::RETURN_FAILED;
+      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()) {
+  if (empty()) {
-        return EMPTY;
+    return EMPTY;
-    } else {
+  } else {
-        if (value == nullptr){
+    if (value == nullptr) {
-            return HasReturnvaluesIF::RETURN_FAILED;
+      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;
+  T value;
-    return this->retrieve(&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;
+  ++current;
-    if (current == maxCapacity) {
+  if (current == maxCapacity) {
-        current = 0;
+    current = 0;
-    }
+  }
-    return current;
+  return current;
 }
-template<typename T>
+template <typename T>
 inline size_t FIFOBase<T>::getMaxCapacity() const {
-    return maxCapacity;
+  return maxCapacity;
 }
-
+template <typename T>
-template<typename T>
+inline void FIFOBase<T>::setContainer(T* data) {
-inline void FIFOBase<T>::setContainer(T *data) {
+  this->values = data;
    this->values = data;
 }
 #endif
--- a/src/fsfw/container/FixedArrayList.h
+++ b/src/fsfw/container/FixedArrayList.h
@ -12,6 +12,7 @@ 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>
-template<typename key_t, typename T, typename KEY_COMPARE>
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(key_t key, T value,
-inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(key_t key, T value, Iterator *storedValue) {
+                                                                         Iterator *storedValue) {
-    if (_size == theMap.maxSize()) {
+  if (_size == theMap.maxSize()) {
-        return MAP_FULL;
+    return MAP_FULL;
-    }
+  }
-    size_t position = findNicePlace(key);
+  size_t position = findNicePlace(key);
-    memmove(static_cast<void*>(&theMap[position + 1]),static_cast<void*>(&theMap[position]),
+  memmove(static_cast<void *>(&theMap[position + 1]), static_cast<void *>(&theMap[position]),
-            (_size - position) * sizeof(std::pair<key_t,T>));
+          (_size - position) * sizeof(std::pair<key_t, T>));
-    theMap[position].first = key;
+  theMap[position].first = key;
-    theMap[position].second = value;
+  theMap[position].second = value;
-    ++_size;
+  ++_size;
-    if (storedValue != nullptr) {
+  if (storedValue != nullptr) {
-        *storedValue = Iterator(&theMap[position]);
+    *storedValue = Iterator(&theMap[position]);
-    }
+  }
-    return HasReturnvaluesIF::RETURN_OK;
+  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;
+  ReturnValue_t result = KEY_DOES_NOT_EXIST;
-    if (findFirstIndex(key) < _size) {
+  if (findFirstIndex(key) < _size) {
-        result = HasReturnvaluesIF::RETURN_OK;
+    result = HasReturnvaluesIF::RETURN_OK;
-    }
+  }
-    return result;
+  return result;
 }
-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(Iterator *iter) {
-    size_t i;
+  size_t i;
-    if ((i = findFirstIndex((*iter).value->first)) >= _size) {
+  if ((i = findFirstIndex((*iter).value->first)) >= _size) {
-        return KEY_DOES_NOT_EXIST;
+    return KEY_DOES_NOT_EXIST;
-    }
+  }
-    removeFromPosition(i);
+  removeFromPosition(i);
-    if (*iter != begin()) {
+  if (*iter != begin()) {
-        (*iter)--;
+    (*iter)--;
-    } else {
+  } else {
-        *iter = begin();
+    *iter = begin();
-    }
+  }
-    return HasReturnvaluesIF::RETURN_OK;
+  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;
+  size_t i;
-    if ((i = findFirstIndex(key)) >= _size) {
+  if ((i = findFirstIndex(key)) >= _size) {
-        return KEY_DOES_NOT_EXIST;
+    return KEY_DOES_NOT_EXIST;
-    }
+  }
-    do {
+  do {
-        removeFromPosition(i);
+    removeFromPosition(i);
-        i = findFirstIndex(key, i);
+    i = findFirstIndex(key, i);
-    } while (i < _size);
+  } while (i < _size);
-    return HasReturnvaluesIF::RETURN_OK;
+  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>::find(key_t key, T **value) const {
-    ReturnValue_t result = exists(key);
+  ReturnValue_t result = exists(key);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
+    return result;
-    }
+  }
-    *value = &theMap[findFirstIndex(key)].second;
+  *value = &theMap[findFirstIndex(key)].second;
-    return HasReturnvaluesIF::RETURN_OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
-template<typename key_t, typename T, typename KEY_COMPARE>
+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 {
+inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findFirstIndex(key_t key,
-    if (startAt >= _size) {
+                                                                          size_t startAt) const {
-        return startAt + 1;
+  if (startAt >= _size) {
    return startAt + 1;
  }
  size_t i = startAt;
  for (i = startAt; i < _size; ++i) {
    if (theMap[i].first == key) {
      return i;
    }
-    size_t i = startAt;
+  }
-    for (i = startAt; i < _size; ++i) {
+  return i;
        if (theMap[i].first == key) {
            return i;
        }
    }
    return i;
 }
-template<typename key_t, typename T, typename KEY_COMPARE>
+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;
+  size_t i = 0;
-    for (i = 0; i < _size; ++i) {
+  for (i = 0; i < _size; ++i) {
-        if (myComp(key, theMap[i].first)) {
+    if (myComp(key, theMap[i].first)) {
-            return i;
+      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) {
+  if (_size <= position) {
-        return;
+    return;
-    }
+  }
-    memmove(static_cast<void*>(&theMap[position]), static_cast<void*>(&theMap[position + 1]),
+  memmove(static_cast<void *>(&theMap[position]), static_cast<void *>(&theMap[position + 1]),
-            (_size - position - 1) * sizeof(std::pair<key_t,T>));
+          (_size - position - 1) * sizeof(std::pair<key_t, T>));
-    --_size;
+  --_size;
 }
 #endif /* FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_ */
--- a/src/fsfw/datapoollocal/LocalPoolVariable.tpp
+++ b/src/fsfw/datapoollocal/LocalPoolVariable.tpp
@ -5,205 +5,189 @@
 #error Include LocalPoolVariable.h before LocalPoolVariable.tpp!
 #endif
-template<typename T>
+template <typename T>
-inline LocalPoolVariable<T>::LocalPoolVariable(HasLocalDataPoolIF* hkOwner,
+inline LocalPoolVariable<T>::LocalPoolVariable(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
-        lp_id_t poolId, DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
+                                               DataSetIF* dataSet, pool_rwm_t setReadWriteMode)
-        LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
+    : LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
-template<typename T>
+template <typename T>
-inline LocalPoolVariable<T>::LocalPoolVariable(object_id_t poolOwner,
+inline LocalPoolVariable<T>::LocalPoolVariable(object_id_t poolOwner, lp_id_t poolId,
-        lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+                                               DataSetIF* dataSet, pool_rwm_t setReadWriteMode)
-        LocalPoolObjectBase(poolOwner, poolId, dataSet, 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>
+template <typename T>
-inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId,
+inline ReturnValue_t LocalPoolVariable<T>::read(MutexIF::TimeoutType timeoutType,
-        DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+                                                uint32_t timeoutMs) {
-        LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
+  if (hkManager == nullptr) {
-                dataSet, setReadWriteMode){}
+    return readWithoutLock();
-
+  }
-
+  MutexIF* mutex = LocalDpManagerAttorney::getMutexHandle(*hkManager);
-template<typename T>
+  ReturnValue_t result = mutex->lockMutex(timeoutType, timeoutMs);
-inline ReturnValue_t LocalPoolVariable<T>::read(
+  if (result != HasReturnvaluesIF::RETURN_OK) {
        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) {
+  if (readWriteMode == pool_rwm_t::VAR_WRITE) {
-        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+    object_id_t targetObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVector",
+    reportReadCommitError("LocalPoolVector", PoolVariableIF::INVALID_READ_WRITE_MODE, true,
-                PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
+                          targetObjectId, localPoolId);
-                localPoolId);
+    return PoolVariableIF::INVALID_READ_WRITE_MODE;
-        return PoolVariableIF::INVALID_READ_WRITE_MODE;
+  }
    }
-    PoolEntry<T>* poolEntry = nullptr;
+  PoolEntry<T>* poolEntry = nullptr;
-    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+  ReturnValue_t result =
-            &poolEntry);
+      LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
-    if(result != RETURN_OK) {
+  if (result != RETURN_OK) {
-        object_id_t ownerObjectId = hkManager->getCreatorObjectId();
+    object_id_t ownerObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVariable", result,
+    reportReadCommitError("LocalPoolVariable", result, false, ownerObjectId, localPoolId);
                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>
+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>
 inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
-    if(readWriteMode == pool_rwm_t::VAR_READ) {
+  if (readWriteMode == pool_rwm_t::VAR_READ) {
-        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+    object_id_t targetObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVector",
+    reportReadCommitError("LocalPoolVector", PoolVariableIF::INVALID_READ_WRITE_MODE, false,
-                PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
+                          targetObjectId, localPoolId);
-                localPoolId);
+    return PoolVariableIF::INVALID_READ_WRITE_MODE;
-        return PoolVariableIF::INVALID_READ_WRITE_MODE;
+  }
    }
-    PoolEntry<T>* poolEntry = nullptr;
+  PoolEntry<T>* poolEntry = nullptr;
-    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+  ReturnValue_t result =
-            &poolEntry);
+      LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
-    if(result != RETURN_OK) {
+  if (result != RETURN_OK) {
-        object_id_t ownerObjectId = hkManager->getCreatorObjectId();
+    object_id_t ownerObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVariable", result,
+    reportReadCommitError("LocalPoolVariable", result, false, ownerObjectId, localPoolId);
-                false, ownerObjectId, localPoolId);
+    return result;
-        return result;
+  }
    }
-    *(poolEntry->getDataPtr()) = this->value;
+  *(poolEntry->getDataPtr()) = this->value;
-    poolEntry->setValid(this->valid);
+  poolEntry->setValid(this->valid);
-    return RETURN_OK;
+  return RETURN_OK;
 }
-template<typename T>
+template <typename T>
-inline ReturnValue_t LocalPoolVariable<T>::serialize(uint8_t** buffer,
+inline ReturnValue_t LocalPoolVariable<T>::serialize(
-        size_t* size, const size_t max_size,
+    uint8_t** buffer, size_t* size, const size_t max_size,
-        SerializeIF::Endianness streamEndianness) const {
+    SerializeIF::Endianness streamEndianness) const {
-    return SerializeAdapter::serialize(&value,
+  return SerializeAdapter::serialize(&value, buffer, size, max_size, streamEndianness);
            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>
+template <typename T>
-inline ReturnValue_t LocalPoolVariable<T>::deSerialize(const uint8_t** buffer,
+inline ReturnValue_t LocalPoolVariable<T>::deSerialize(const uint8_t** buffer, size_t* size,
-        size_t* size, SerializeIF::Endianness streamEndianness) {
+                                                       SerializeIF::Endianness streamEndianness) {
-    return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
+  return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
 }
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-template<typename T>
+template <typename T>
-inline std::ostream& operator<< (std::ostream &out,
+inline std::ostream& operator<<(std::ostream& out, const LocalPoolVariable<T>& var) {
-        const LocalPoolVariable<T> &var) {
+  out << var.value;
-    out << var.value;
+  return out;
    return out;
 }
 #endif
-template<typename T>
+template <typename T>
 inline LocalPoolVariable<T>::operator T() const {
-    return value;
+  return value;
 }
-template<typename T>
+template <typename T>
-inline LocalPoolVariable<T> & LocalPoolVariable<T>::operator=(
+inline LocalPoolVariable<T>& LocalPoolVariable<T>::operator=(const T& newValue) {
-        const T& newValue) {
+  value = newValue;
-    value = newValue;
+  return *this;
    return *this;
 }
-template<typename T>
+template <typename T>
-inline LocalPoolVariable<T>& LocalPoolVariable<T>::operator =(
+inline LocalPoolVariable<T>& LocalPoolVariable<T>::operator=(
-        const LocalPoolVariable<T>& newPoolVariable) {
+    const LocalPoolVariable<T>& newPoolVariable) {
-    value = newPoolVariable.value;
+  value = newPoolVariable.value;
-    return *this;
+  return *this;
 }
-template<typename T>
+template <typename T>
-inline bool LocalPoolVariable<T>::operator ==(
+inline bool LocalPoolVariable<T>::operator==(const LocalPoolVariable<T>& other) const {
-        const LocalPoolVariable<T> &other) const {
+  return this->value == other.value;
    return this->value == other.value;
 }
-template<typename T>
+template <typename T>
-inline bool LocalPoolVariable<T>::operator ==(const T &other) const {
+inline bool LocalPoolVariable<T>::operator==(const T& other) const {
-    return this->value == other;
+  return this->value == other;
 }
-
+template <typename T>
-template<typename T>
+inline bool LocalPoolVariable<T>::operator!=(const LocalPoolVariable<T>& other) const {
-inline bool LocalPoolVariable<T>::operator !=(
+  return not(*this == other);
        const LocalPoolVariable<T> &other) const {
    return not (*this == other);
 }
-template<typename T>
+template <typename T>
-inline bool LocalPoolVariable<T>::operator !=(const T &other) const {
+inline bool LocalPoolVariable<T>::operator!=(const T& other) const {
-    return not (*this == other);
+  return not(*this == other);
 }
-
+template <typename T>
-template<typename T>
+inline bool LocalPoolVariable<T>::operator<(const LocalPoolVariable<T>& other) const {
-inline bool LocalPoolVariable<T>::operator <(
+  return this->value < other.value;
        const LocalPoolVariable<T> &other) const {
    return this->value < other.value;
 }
-template<typename T>
+template <typename T>
-inline bool LocalPoolVariable<T>::operator <(const T &other) const {
+inline bool LocalPoolVariable<T>::operator<(const T& other) const {
-    return this->value < other;
+  return this->value < other;
 }
-
+template <typename T>
-template<typename T>
+inline bool LocalPoolVariable<T>::operator>(const LocalPoolVariable<T>& other) const {
-inline bool LocalPoolVariable<T>::operator >(
+  return not(*this < other);
        const LocalPoolVariable<T> &other) const {
    return not (*this < other);
 }
-template<typename T>
+template <typename T>
-inline bool LocalPoolVariable<T>::operator >(const T &other) const {
+inline bool LocalPoolVariable<T>::operator>(const T& other) const {
-    return not (*this < other);
+  return not(*this < other);
 }
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_ */
--- a/src/fsfw/datapoollocal/LocalPoolVector.tpp
+++ b/src/fsfw/datapoollocal/LocalPoolVector.tpp
@ -5,174 +5,172 @@
 #error Include LocalPoolVector.h before LocalPoolVector.tpp!
 #endif
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
-inline LocalPoolVector<T, vectorSize>::LocalPoolVector(
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
-        HasLocalDataPoolIF* hkOwner, lp_id_t poolId, DataSetIF* dataSet,
+                                                       DataSetIF* dataSet,
-        pool_rwm_t setReadWriteMode):
+                                                       pool_rwm_t setReadWriteMode)
-        LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
+    : LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
-inline LocalPoolVector<T, vectorSize>::LocalPoolVector(object_id_t poolOwner,
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(object_id_t poolOwner, lp_id_t poolId,
-        lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+                                                       DataSetIF* dataSet,
-        LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
+                                                       pool_rwm_t setReadWriteMode)
    : LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
-inline LocalPoolVector<T, vectorSize>::LocalPoolVector(gp_id_t globalPoolId,
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(gp_id_t globalPoolId, DataSetIF* dataSet,
-        DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+                                                       pool_rwm_t setReadWriteMode)
-        LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
+    : LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId, dataSet,
-                dataSet, setReadWriteMode) {}
+                          setReadWriteMode) {}
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
-inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(MutexIF::TimeoutType timeoutType,
-        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+                                                          uint32_t timeoutMs) {
-    MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
+  MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
-    return readWithoutLock();
+  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) {
+  if (readWriteMode == pool_rwm_t::VAR_WRITE) {
-        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+    object_id_t targetObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVector",
+    reportReadCommitError("LocalPoolVector", PoolVariableIF::INVALID_READ_WRITE_MODE, true,
-                PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
+                          targetObjectId, localPoolId);
-                localPoolId);
+    return PoolVariableIF::INVALID_READ_WRITE_MODE;
-        return PoolVariableIF::INVALID_READ_WRITE_MODE;
+  }
    }
-    PoolEntry<T>* poolEntry = nullptr;
+  PoolEntry<T>* poolEntry = nullptr;
-    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+  ReturnValue_t result =
-            &poolEntry);
+      LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
-    memset(this->value, 0, vectorSize * sizeof(T));
+  memset(this->value, 0, vectorSize * sizeof(T));
-    if(result != RETURN_OK) {
+  if (result != RETURN_OK) {
-        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+    object_id_t targetObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVector", result, true, targetObjectId,
+    reportReadCommitError("LocalPoolVector", result, true, targetObjectId, localPoolId);
-                localPoolId);
+    return result;
-        return result;
+  }
-    }
+  std::memcpy(this->value, poolEntry->getDataPtr(), poolEntry->getByteSize());
-    std::memcpy(this->value, poolEntry->getDataPtr(), poolEntry->getByteSize());
+  this->valid = poolEntry->getValid();
-    this->valid = poolEntry->getValid();
+  return RETURN_OK;
    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) {
+                                                            MutexIF::TimeoutType timeoutType,
-    this->setValid(valid);
+                                                            uint32_t timeoutMs) {
-    return commit(timeoutType, timeoutMs);
+  this->setValid(valid);
  return commit(timeoutType, timeoutMs);
 }
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
-inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(MutexIF::TimeoutType timeoutType,
-        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+                                                            uint32_t timeoutMs) {
-    MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
+  MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
-    return commitWithoutLock();
+  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) {
+  if (readWriteMode == pool_rwm_t::VAR_READ) {
-        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+    object_id_t targetObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVector",
+    reportReadCommitError("LocalPoolVector", PoolVariableIF::INVALID_READ_WRITE_MODE, false,
-                PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
+                          targetObjectId, localPoolId);
-                localPoolId);
+    return PoolVariableIF::INVALID_READ_WRITE_MODE;
-        return PoolVariableIF::INVALID_READ_WRITE_MODE;
+  }
-    }
+  PoolEntry<T>* poolEntry = nullptr;
-    PoolEntry<T>* poolEntry = nullptr;
+  ReturnValue_t result =
-    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+      LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
-            &poolEntry);
+  if (result != RETURN_OK) {
-    if(result != RETURN_OK) {
+    object_id_t targetObjectId = hkManager->getCreatorObjectId();
-        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+    reportReadCommitError("LocalPoolVector", result, false, targetObjectId, localPoolId);
        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>
+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>
 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,
+    const uint8_t** buffer, size_t* size, SerializeIF::Endianness streamEndianness) {
-        SerializeIF::Endianness streamEndianness) {
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+  for (uint16_t i = 0; i < vectorSize; i++) {
-    for (uint16_t i = 0; i < vectorSize; i++) {
+    result = SerializeAdapter::deSerialize(&(value[i]), buffer, size, streamEndianness);
-        result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
+    if (result != HasReturnvaluesIF::RETURN_OK) {
-                streamEndianness);
+      break;
        if (result != HasReturnvaluesIF::RETURN_OK) {
            break;
        }
    }
-    return result;
+  }
  return result;
 }
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
-inline std::ostream& operator<< (std::ostream &out,
+inline std::ostream& operator<<(std::ostream& out, const LocalPoolVector<T, vectorSize>& var) {
-        const LocalPoolVector<T, vectorSize> &var) {
+  out << "Vector: [";
-    out << "Vector: [";
+  for (int i = 0; i < vectorSize; i++) {
-    for(int i = 0;i < vectorSize; i++) {
+    out << var.value[i];
-        out << var.value[i];
+    if (i < vectorSize - 1) {
-        if(i < vectorSize - 1) {
+      out << ", ";
            out << ", ";
        }
    }
-    out << "]";
+  }
-    return out;
+  out << "]";
  return out;
 }
 #endif
--- a/src/fsfw/devicehandlers/DeviceHandlerBase.h
+++ b/src/fsfw/devicehandlers/DeviceHandlerBase.h
@ -1062,7 +1062,8 @@ class DeviceHandlerBase : public DeviceHandlerIF,
  /**
   * Same as triggerEvent, but for forwarding if object is used as proxy.
   */
-  virtual void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const override;
+  virtual void forwardEvent(Event event, uint32_t parameter1 = 0,
                            uint32_t parameter2 = 0) const override;
  /**
   * Checks if current mode is transitional mode.
--- a/src/fsfw/objectmanager/SystemObject.h
+++ b/src/fsfw/objectmanager/SystemObject.h
@ -50,7 +50,8 @@ class SystemObject : public SystemObjectIF {
  virtual ReturnValue_t initialize() override;
  virtual ReturnValue_t checkObjectConnections() override;
-  virtual void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const override;
+  virtual void forwardEvent(Event event, uint32_t parameter1 = 0,
                            uint32_t parameter2 = 0) const override;
 };
 #endif /* FSFW_OBJECTMANAGER_SYSTEMOBJECT_H_ */
--- a/src/fsfw/osal/common/TcpTmTcServer.cpp
+++ b/src/fsfw/osal/common/TcpTmTcServer.cpp
@ -161,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) {
@ -285,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();
@ -340,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/common/UdpTcPollingTask.cpp
+++ b/src/fsfw/osal/common/UdpTcPollingTask.cpp
@ -154,7 +154,7 @@ void UdpTcPollingTask::setTimeout(double timeoutSeconds) {
 #endif
  }
 #elif defined(PLATFORM_UNIX)
-  timeval tval {};
+  timeval tval{};
  tval = timevalOperations::toTimeval(timeoutSeconds);
  int result = setsockopt(serverSocket, SOL_SOCKET, SO_RCVTIMEO, &tval, sizeof(receptionTimeout));
  if (result == -1) {
--- a/src/fsfw/osal/common/UdpTmTcBridge.cpp
+++ b/src/fsfw/osal/common/UdpTmTcBridge.cpp
@ -20,7 +20,7 @@
 const std::string UdpTmTcBridge::DEFAULT_SERVER_PORT = tcpip::DEFAULT_SERVER_PORT;
 UdpTmTcBridge::UdpTmTcBridge(object_id_t objectId, object_id_t tcDestination,
-                             const std::string& udpServerPort_, object_id_t tmStoreId,
+                             const std::string &udpServerPort_, object_id_t tmStoreId,
                             object_id_t tcStoreId)
    : TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
  if (udpServerPort_.empty()) {
@ -118,7 +118,7 @@ ReturnValue_t UdpTmTcBridge::sendTm(const uint8_t *data, size_t dataLen) {
 #endif
  ssize_t bytesSent = sendto(serverSocket, reinterpret_cast<const char *>(data), dataLen, flags,
-                         &clientAddress, clientAddressLen);
+                             &clientAddress, clientAddressLen);
  if (bytesSent == SOCKET_ERROR) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::warning << "TmTcUdpBridge::sendTm: Send operation failed." << std::endl;
--- a/src/fsfw/osal/common/UdpTmTcBridge.h
+++ b/src/fsfw/osal/common/UdpTmTcBridge.h
@ -29,8 +29,8 @@ class UdpTmTcBridge : public TmTcBridge, public TcpIpBase {
  /* The ports chosen here should not be used by any other process. */
  static const std::string DEFAULT_SERVER_PORT;
-  UdpTmTcBridge(object_id_t objectId, object_id_t tcDestination, const std::string& udpServerPort = "",
+  UdpTmTcBridge(object_id_t objectId, object_id_t tcDestination,
-                object_id_t tmStoreId = objects::TM_STORE,
+                const std::string& udpServerPort = "", object_id_t tmStoreId = objects::TM_STORE,
                object_id_t tcStoreId = objects::TC_STORE);
  ~UdpTmTcBridge() override;
--- a/src/fsfw/power/CMakeLists.txt
+++ b/src/fsfw/power/CMakeLists.txt
@ -1,7 +1,7 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(${LIB_FSFW_NAME} PRIVATE
-	PRIVATE 
+    Fuse.cpp
-		Fuse.cpp
+    PowerComponent.cpp
-		PowerComponent.cpp
+    PowerSensor.cpp
-		PowerSensor.cpp
+    PowerSwitcher.cpp
-		PowerSwitcher.cpp
+    DummyPowerSwitcher.cpp
 )
--- a/src/fsfw/power/DummyPowerSwitcher.cpp
+++ b/src/fsfw/power/DummyPowerSwitcher.cpp
@ -0,0 +1,47 @@
 #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.capacity()) {
    switcherList[switchNr] = onOff;
  }
  return RETURN_FAILED;
 }
 ReturnValue_t DummyPowerSwitcher::sendFuseOnCommand(uint8_t fuseNr) {
  if (fuseNr < fuseList.capacity()) {
    fuseList[fuseNr] = FUSE_ON;
  }
  return RETURN_FAILED;
 }
 ReturnValue_t DummyPowerSwitcher::getSwitchState(power::Switch_t switchNr) const {
  if (switchNr < switcherList.capacity()) {
    return switcherList[switchNr];
  }
  return HasReturnvaluesIF::RETURN_FAILED;
 }
 ReturnValue_t DummyPowerSwitcher::getFuseState(uint8_t fuseNr) const {
  if (fuseNr < fuseList.capacity()) {
    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
@ -0,0 +1,38 @@
 #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;
-  static const Event FUSE_CURRENT_HIGH = MAKE_EVENT(
+  //! PSS detected that current on a fuse is totally out of bounds.
-      1, severity::LOW);  //!< PSS detected that current on a fuse is totally out of bounds.
+  static const Event FUSE_CURRENT_HIGH = MAKE_EVENT(1, severity::LOW);
-  static const Event FUSE_WENT_OFF =
+  //! PSS detected a fuse that went off.
-      MAKE_EVENT(2, severity::LOW);  //!< PSS detected a fuse that went off.
+  static const Event FUSE_WENT_OFF = MAKE_EVENT(2, severity::LOW);
-  static const Event POWER_ABOVE_HIGH_LIMIT =
+  //! PSS detected a fuse that violates its limits.
-      MAKE_EVENT(4, severity::LOW);  //!< PSS detected a fuse that violates its limits.
+  static const Event POWER_ABOVE_HIGH_LIMIT = MAKE_EVENT(4, severity::LOW);
-  static const Event POWER_BELOW_LOW_LIMIT =
+  //! PSS detected a fuse that violates its limits.
-      MAKE_EVENT(5, severity::LOW);  //!< PSS detected a fuse that violates its limits.
+  static const Event POWER_BELOW_LOW_LIMIT = MAKE_EVENT(5, severity::LOW);
  typedef std::list<PowerComponentIF *> DeviceList;
  Fuse(object_id_t fuseObjectId, uint8_t fuseId, sid_t variableSet, VariableIds ids,
--- a/src/fsfw/power/PowerSensor.cpp
+++ b/src/fsfw/power/PowerSensor.cpp
@ -15,7 +15,8 @@ PowerSensor::PowerSensor(object_id_t objectId, sid_t setId, VariableIds ids, Def
                   limits.currentMin, limits.currentMax, events.currentLow, events.currentHigh),
      voltageLimit(objectId, MODULE_ID_VOLTAGE, ids.pidVoltage, confirmationCount,
                   limits.voltageMin, limits.voltageMax, events.voltageLow, events.voltageHigh) {
-  commandQueue = QueueFactory::instance()->createMessageQueue();
+  commandQueue =
      QueueFactory::instance()->createMessageQueue(3, MessageQueueMessage::MAX_MESSAGE_SIZE);
 }
 PowerSensor::~PowerSensor() { QueueFactory::instance()->deleteMessageQueue(commandQueue); }
--- a/src/fsfw/power/PowerSwitchIF.h
+++ b/src/fsfw/power/PowerSwitchIF.h
@ -3,6 +3,7 @@
 #include "../events/Event.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "definitions.h"
 /**
 *
 * @brief   This interface defines a connection to a device that is capable of
@ -37,11 +38,11 @@ class PowerSwitchIF : public HasReturnvaluesIF {
   * @param switchNr
   * @param onOff on == @c SWITCH_ON; off != @c SWITCH_ON
   */
-  virtual void sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) const = 0;
+  virtual ReturnValue_t sendSwitchCommand(power::Switch_t switchNr, ReturnValue_t onOff) = 0;
  /**
   * Sends a command to the Power Unit to enable a certain fuse.
   */
-  virtual void sendFuseOnCommand(uint8_t fuseNr) const = 0;
+  virtual ReturnValue_t sendFuseOnCommand(uint8_t fuseNr) = 0;
  /**
   * get the state of the Switches.
@ -51,7 +52,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(uint8_t switchNr) const = 0;
+  virtual ReturnValue_t getSwitchState(power::Switch_t switchNr) const = 0;
  /**
   * get state of a fuse.
   * @param fuseNr
--- a/src/fsfw/power/PowerSwitcher.cpp
+++ b/src/fsfw/power/PowerSwitcher.cpp
@ -1,19 +1,12 @@
 #include "fsfw/power/PowerSwitcher.h"
 #include "definitions.h"
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
-PowerSwitcher::PowerSwitcher(uint8_t setSwitch1, uint8_t setSwitch2,
+PowerSwitcher::PowerSwitcher(PowerSwitchIF* switcher, power::Switch_t setSwitch1,
-                             PowerSwitcher::State_t setStartState)
+                             power::Switch_t setSwitch2, PowerSwitcher::State_t setStartState)
-    : state(setStartState), firstSwitch(setSwitch1), secondSwitch(setSwitch2) {}
+    : power(switcher), 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();
@ -52,18 +45,37 @@ void PowerSwitcher::commandSwitches(ReturnValue_t onOff) {
  return;
 }
-void PowerSwitcher::turnOn() {
+void PowerSwitcher::turnOn(bool checkCurrentState) {
  if (checkCurrentState) {
    if (getStateOfSwitches() == PowerSwitchIF::SWITCH_ON) {
      state = SWITCH_IS_ON;
      return;
    }
  }
  commandSwitches(PowerSwitchIF::SWITCH_ON);
  state = WAIT_ON;
 }
-void PowerSwitcher::turnOff() {
+void PowerSwitcher::turnOff(bool checkCurrentState) {
  if (checkCurrentState) {
    if (getStateOfSwitches() == PowerSwitchIF::SWITCH_OFF) {
      state = SWITCH_IS_OFF;
      return;
    }
  }
  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 == NO_SWITCH) {
+  if (secondSwitch == power::NO_SWITCH) {
    return ONE_SWITCH;
  } else {
    return TWO_SWITCHES;
--- a/src/fsfw/power/PowerSwitcher.h
+++ b/src/fsfw/power/PowerSwitcher.h
@ -14,28 +14,29 @@ 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(uint8_t setSwitch1, uint8_t setSwitch2 = NO_SWITCH,
+  PowerSwitcher(PowerSwitchIF* switcher, power::Switch_t setSwitch1,
                power::Switch_t setSwitch2 = power::NO_SWITCH,
                State_t setStartState = SWITCH_IS_OFF);
-  ReturnValue_t initialize(object_id_t powerSwitchId);
+  void turnOn(bool checkCurrentState = true);
-  void turnOn();
+  void turnOff(bool checkCurrentState = true);
-  void turnOff();
+  bool active();
  void doStateMachine();
  State_t getState();
  ReturnValue_t checkSwitchState();
  uint32_t getSwitchDelay();
-  uint8_t getFirstSwitch() const;
+  power::Switch_t getFirstSwitch() const;
-  uint8_t getSecondSwitch() const;
+  power::Switch_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/definitions.h
+++ b/src/fsfw/power/definitions.h
@ -0,0 +1,13 @@
 #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,7 +97,8 @@ 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/tests/src/fsfw_tests/unit/CMakeLists.txt
+++ b/tests/src/fsfw_tests/unit/CMakeLists.txt
@ -11,7 +11,10 @@ target_sources(${FSFW_TEST_TGT} PRIVATE
 )
 add_subdirectory(testcfg)
 add_subdirectory(mocks)
 add_subdirectory(action)
 add_subdirectory(power)
 add_subdirectory(container)
 add_subdirectory(osal)
 add_subdirectory(serialize)
--- a/tests/src/fsfw_tests/unit/mocks/CMakeLists.txt
+++ b/tests/src/fsfw_tests/unit/mocks/CMakeLists.txt
@ -0,0 +1,3 @@
 target_sources(${FSFW_TEST_TGT} PRIVATE
 	PowerSwitcherMock.cpp
 )
--- a/tests/src/fsfw_tests/unit/mocks/PowerSwitcherMock.cpp
+++ b/tests/src/fsfw_tests/unit/mocks/PowerSwitcherMock.cpp
@ -0,0 +1,77 @@
 #include "PowerSwitcherMock.h"
 static uint32_t SWITCH_REQUEST_UPDATE_VALUE = 0;
 PowerSwitcherMock::PowerSwitcherMock() {}
 ReturnValue_t PowerSwitcherMock::sendSwitchCommand(power::Switch_t switchNr, ReturnValue_t onOff) {
  if (switchMap.count(switchNr) == 0) {
    switchMap.emplace(switchNr, SwitchInfo(switchNr, onOff));
  } else {
    SwitchInfo& info = switchMap.at(switchNr);
    info.currentState = onOff;
    if (onOff == PowerSwitchIF::SWITCH_ON) {
      info.timesCalledOn++;
    } else {
      info.timesCalledOff++;
    }
  }
  return RETURN_OK;
 }
 ReturnValue_t PowerSwitcherMock::sendFuseOnCommand(uint8_t fuseNr) {
  if (fuseMap.count(fuseNr) == 0) {
    fuseMap.emplace(fuseNr, FuseInfo(fuseNr));
  } else {
    FuseInfo& info = fuseMap.at(fuseNr);
    info.timesCalled++;
  }
  return RETURN_OK;
 }
 ReturnValue_t PowerSwitcherMock::getSwitchState(power::Switch_t switchNr) const {
  if (switchMap.count(switchNr) == 1) {
    auto& info = switchMap.at(switchNr);
    SWITCH_REQUEST_UPDATE_VALUE++;
    return info.currentState;
  }
  return RETURN_FAILED;
 }
 ReturnValue_t PowerSwitcherMock::getFuseState(uint8_t fuseNr) const {
  if (fuseMap.count(fuseNr) == 1) {
    return FUSE_ON;
  } else {
    return FUSE_OFF;
  }
  return RETURN_FAILED;
 }
 uint32_t PowerSwitcherMock::getSwitchDelayMs(void) const { return 5000; }
 SwitchInfo::SwitchInfo() : switcher(0) {}
 SwitchInfo::SwitchInfo(power::Switch_t switcher, ReturnValue_t initState)
    : switcher(switcher), currentState(initState) {}
 FuseInfo::FuseInfo(uint8_t fuse) : fuse(fuse) {}
 void PowerSwitcherMock::getSwitchInfo(power::Switch_t switcher, SwitchInfo& info) {
  if (switchMap.count(switcher) == 1) {
    info = switchMap.at(switcher);
  }
 }
 void PowerSwitcherMock::getFuseInfo(uint8_t fuse, FuseInfo& info) {
  if (fuseMap.count(fuse) == 1) {
    info = fuseMap.at(fuse);
  }
 }
 uint32_t PowerSwitcherMock::getAmountSwitchStatWasRequested() {
  return SWITCH_REQUEST_UPDATE_VALUE;
 }
 void PowerSwitcherMock::initSwitch(power::Switch_t switchNr) {
  switchMap.emplace(switchNr, SwitchInfo(switchNr, PowerSwitchIF::SWITCH_OFF));
 }
--- a/tests/src/fsfw_tests/unit/mocks/PowerSwitcherMock.h
+++ b/tests/src/fsfw_tests/unit/mocks/PowerSwitcherMock.h
@ -0,0 +1,52 @@
 #ifndef FSFW_TESTS_SRC_FSFW_TESTS_UNIT_MOCKS_POWERSWITCHERMOCK_H_
 #define FSFW_TESTS_SRC_FSFW_TESTS_UNIT_MOCKS_POWERSWITCHERMOCK_H_
 #include <fsfw/power/PowerSwitchIF.h>
 #include <map>
 #include <utility>
 struct SwitchInfo {
 public:
  SwitchInfo();
  SwitchInfo(power::Switch_t switcher, ReturnValue_t initState);
  power::Switch_t switcher;
  ReturnValue_t currentState = PowerSwitchIF::SWITCH_OFF;
  uint32_t timesCalledOn = 0;
  uint32_t timesCalledOff = 0;
  uint32_t timesStatusRequested = 0;
 };
 struct FuseInfo {
 public:
  FuseInfo(uint8_t fuse);
  uint8_t fuse;
  uint32_t timesCalled = 0;
 };
 class PowerSwitcherMock : public PowerSwitchIF {
 public:
  PowerSwitcherMock();
  ReturnValue_t sendSwitchCommand(power::Switch_t switchNr, ReturnValue_t onOff) override;
  ReturnValue_t sendFuseOnCommand(uint8_t fuseNr) override;
  ReturnValue_t getSwitchState(power::Switch_t switchNr) const override;
  ReturnValue_t getFuseState(uint8_t fuseNr) const override;
  uint32_t getSwitchDelayMs(void) const override;
  void getSwitchInfo(power::Switch_t switcher, SwitchInfo& info);
  void getFuseInfo(uint8_t fuse, FuseInfo& info);
  uint32_t getAmountSwitchStatWasRequested();
  void initSwitch(power::Switch_t switchNr);
 private:
  using SwitchOnOffPair = std::pair<power::Switch_t, ReturnValue_t>;
  using FuseOnOffPair = std::pair<uint8_t, ReturnValue_t>;
  std::map<power::Switch_t, SwitchInfo> switchMap;
  std::map<uint8_t, FuseInfo> fuseMap;
 };
 #endif /* FSFW_TESTS_SRC_FSFW_TESTS_UNIT_MOCKS_POWERSWITCHERMOCK_H_ */
--- a/tests/src/fsfw_tests/unit/power/CMakeLists.txt
+++ b/tests/src/fsfw_tests/unit/power/CMakeLists.txt
@ -0,0 +1,3 @@
 target_sources(${FSFW_TEST_TGT} PRIVATE
    testPowerSwitcher.cpp
 )
--- a/tests/src/fsfw_tests/unit/power/testPowerSwitcher.cpp
+++ b/tests/src/fsfw_tests/unit/power/testPowerSwitcher.cpp
@ -0,0 +1,71 @@
 #include <fsfw/power/DummyPowerSwitcher.h>
 #include <fsfw/power/PowerSwitcher.h>
 #include <fsfw_tests/unit/mocks/PowerSwitcherMock.h>
 #include <catch2/catch_test_macros.hpp>
 #include "objects/systemObjectList.h"
 TEST_CASE("Power Switcher", "[power-switcher]") {
  PowerSwitcherMock mock;
  PowerSwitcher switcher(&mock, 1);
  DummyPowerSwitcher dummySwitcher(objects::DUMMY_POWER_SWITCHER, 5, 5, false);
  PowerSwitcher switcherUsingDummy(&dummySwitcher, 1);
  SwitchInfo switchInfo;
  mock.initSwitch(1);
  SECTION("Basic Tests") {
    REQUIRE(switcher.getFirstSwitch() == 1);
    REQUIRE(switcher.getSecondSwitch() == power::NO_SWITCH);
    // Default start state
    REQUIRE(switcher.getState() == PowerSwitcher::SWITCH_IS_OFF);
    switcher.turnOn(true);
    REQUIRE(mock.getAmountSwitchStatWasRequested() == 1);
    REQUIRE(switcher.getState() == PowerSwitcher::WAIT_ON);
    REQUIRE(switcher.checkSwitchState() == PowerSwitcher::IN_POWER_TRANSITION);
    REQUIRE(switcher.active());
    switcher.doStateMachine();
    REQUIRE(switcher.getState() == PowerSwitcher::SWITCH_IS_ON);
    mock.getSwitchInfo(1, switchInfo);
    REQUIRE(switchInfo.timesCalledOn == 1);
    REQUIRE(not switcher.active());
    REQUIRE(mock.getAmountSwitchStatWasRequested() == 2);
    REQUIRE(switcher.checkSwitchState() == HasReturnvaluesIF::RETURN_OK);
    REQUIRE(mock.getAmountSwitchStatWasRequested() == 3);
    switcher.turnOff(false);
    REQUIRE(mock.getAmountSwitchStatWasRequested() == 3);
    REQUIRE(switcher.getState() == PowerSwitcher::WAIT_OFF);
    REQUIRE(switcher.active());
    REQUIRE(switcher.getState() == PowerSwitcher::WAIT_OFF);
    switcher.doStateMachine();
    mock.getSwitchInfo(1, switchInfo);
    REQUIRE(switcher.getState() == PowerSwitcher::SWITCH_IS_OFF);
    REQUIRE(switchInfo.timesCalledOn == 1);
    REQUIRE(switchInfo.timesCalledOff == 1);
    REQUIRE(not switcher.active());
    REQUIRE(mock.getAmountSwitchStatWasRequested() == 4);
  }
  SECTION("Dummy Test") {
    // Same tests, but we can't really check the dummy
    REQUIRE(switcherUsingDummy.getFirstSwitch() == 1);
    REQUIRE(switcherUsingDummy.getSecondSwitch() == power::NO_SWITCH);
    REQUIRE(switcherUsingDummy.getState() == PowerSwitcher::SWITCH_IS_OFF);
    switcherUsingDummy.turnOn(true);
    REQUIRE(switcherUsingDummy.getState() == PowerSwitcher::WAIT_ON);
    REQUIRE(switcherUsingDummy.active());
    switcherUsingDummy.doStateMachine();
    REQUIRE(switcherUsingDummy.getState() == PowerSwitcher::SWITCH_IS_ON);
    REQUIRE(not switcherUsingDummy.active());
    switcherUsingDummy.turnOff(false);
    REQUIRE(switcherUsingDummy.getState() == PowerSwitcher::WAIT_OFF);
    REQUIRE(switcherUsingDummy.active());
    REQUIRE(switcherUsingDummy.getState() == PowerSwitcher::WAIT_OFF);
    switcherUsingDummy.doStateMachine();
    REQUIRE(switcherUsingDummy.getState() == PowerSwitcher::SWITCH_IS_OFF);
    REQUIRE(not switcherUsingDummy.active());
  }
  SECTION("More Dummy Tests") {}
 }
--- a/tests/src/fsfw_tests/unit/testcfg/objects/systemObjectList.h
+++ b/tests/src/fsfw_tests/unit/testcfg/objects/systemObjectList.h
@ -21,8 +21,9 @@ enum sourceObjects : uint32_t {
  HK_RECEIVER_MOCK = 22,
  TEST_LOCAL_POOL_OWNER_BASE = 25,
-  SHARED_SET_ID = 26
+  SHARED_SET_ID = 26,
  DUMMY_POWER_SWITCHER = 27
 };
 }
Author	SHA1	Message	Date
Robin Mueller	06111ec3ed	missing call added	2022-05-14 16:57:59 +02:00
Robin Mueller	51087518b0	spi mutex handling refactoring	2022-05-14 11:32:51 +02:00
Robin Müller	e3d1308205	Merge pull request 'preproc guards' (#612 ) from eive/fsfw:mueller/missing-preproc-defs into development Reviewed-on: fsfw/fsfw#612	2022-05-13 13:22:38 +02:00
Steffen Gaisser	99c72fd00b	Merge pull request 'Auto-Formatter Script Improvements' (#626 ) from mueller/amft-cmakelists into development Reviewed-on: fsfw/fsfw#626	2022-05-13 12:01:40 +02:00
Robin Mueller	811287aac8	delete old scripts	2022-05-13 11:57:22 +02:00
Robin Mueller	23fb06578b	this is better	2022-05-13 11:56:37 +02:00
Robin Mueller	c86e99e6dc	rename auto-formatter	2022-05-13 11:56:20 +02:00
Robin Mueller	4092de911c	use variable for repeated section	2022-05-13 11:55:19 +02:00
Robin Müller	00952e15b0	Merge branch 'development' into mueller/missing-preproc-defs	2022-05-13 11:50:24 +02:00
Robin Mueller	01ebf0f4d3	tab size	2022-05-13 11:49:01 +02:00
Robin Mueller	99fe6487c8	another small improvement	2022-05-13 11:48:18 +02:00
Robin Mueller	d4a6f987bc	small fix	2022-05-13 11:46:59 +02:00
Robin Mueller	57bac4f262	Merge remote-tracking branch 'origin/development' into mueller/amft-cmakelists	2022-05-13 11:46:17 +02:00
Robin Mueller	cfa6843c8f	check whether clang-format is installed	2022-05-13 11:46:04 +02:00
Steffen Gaisser	b6b3221b22	Merge pull request 'run auto-formatter over cmakelists.txt' (#619 ) from mueller/amft-cmakelists into development Reviewed-on: fsfw/fsfw#619	2022-05-13 11:44:48 +02:00
Robin Mueller	deee4c43c0	finally this works	2022-05-13 11:37:58 +02:00
Robin Mueller	ad0b6f1ed1	another small fix	2022-05-13 11:35:59 +02:00
Robin Mueller	ec03a674bd	Merge branch 'mueller/amft-cmakelists' of https://egit.irs.uni-stuttgart.de/fsfw/fsfw into mueller/amft-cmakelists	2022-05-13 11:35:28 +02:00
Robin Mueller	9e3d5b6a0c	small fix	2022-05-13 11:35:18 +02:00
Robin Mueller	994c7299b9	add cmake-format command to shell script	2022-05-13 11:34:44 +02:00
Robin Müller	57a830cb46	Merge branch 'development' into mueller/amft-cmakelists	2022-05-13 11:30:52 +02:00
Robin Mueller	c215508a12	another missing preproc guard	2022-05-13 00:25:52 +02:00
Robin Müller	ccadbb5942	Merge branch 'development' into mueller/missing-preproc-defs	2022-05-13 00:24:04 +02:00
Steffen Gaisser	a83b86ccd2	Merge pull request 'refactor power module' (#590 ) from eive/fsfw:mueller/refactor-power-switch-if-etc into development Reviewed-on: fsfw/fsfw#590	2022-05-12 18:37:45 +02:00
Robin Mueller	3046822e88	run cmake-format	2022-05-12 17:27:39 +02:00
Robin Mueller	6442dd0c38	Merge branch 'mueller/amft-cmakelists' of https://egit.irs.uni-stuttgart.de/fsfw/fsfw into mueller/amft-cmakelists	2022-05-12 17:16:15 +02:00
Robin Mueller	9b6fa646ed	Merge remote-tracking branch 'origin/development' into mueller/amft-cmakelists	2022-05-12 17:16:10 +02:00
Robin Müller	2d9d83a1c5	Merge branch 'development' into mueller/missing-preproc-defs	2022-05-12 17:10:54 +02:00
Robin Müller	c561271070	Merge branch 'development' into mueller/refactor-power-switch-if-etc	2022-05-12 17:09:27 +02:00
Steffen Gaisser	b99160e850	Merge pull request 'Add LTO support' (#616 ) from mueller/add-lto-support into development Reviewed-on: fsfw/fsfw#616	2022-05-12 16:56:54 +02:00
Robin Mueller	d11f898f70	update dummy power switcher docs	2022-05-12 15:02:06 +02:00
Robin Müller	34e124f2db	Merge branch 'development' into mueller/amft-cmakelists	2022-05-11 11:30:40 +02:00
Robin Mueller	e05c72b062	minor formatting fix	2022-05-10 13:08:14 +02:00
Robin Mueller	2ca8523215	Merge branch 'mueller/add-lto-support' of https://egit.irs.uni-stuttgart.de/fsfw/fsfw into mueller/add-lto-support	2022-05-10 11:57:01 +02:00
Robin Mueller	25775614de	only check IPO support if enabled	2022-05-10 11:56:51 +02:00
Steffen Gaisser	0410ecd9e3	Merge branch 'development' into mueller/add-lto-support	2022-05-10 11:51:39 +02:00
Robin Mueller	0fe1b70bae	keep LTO option off by default	2022-05-10 11:19:29 +02:00
Robin Mueller	c5b4499d98	Merge remote-tracking branch 'upstream/development' into mueller/refactor-power-switch-if-etc	2022-05-10 09:58:21 +02:00
Robin Müller	458aa5c265	Merge branch 'development' into mueller/missing-preproc-defs	2022-05-10 09:56:29 +02:00
Robin Müller	eb0223bc51	Merge branch 'development' into mueller/add-lto-support	2022-05-09 22:34:28 +02:00
Robin Müller	d8bd08dd8c	Merge branch 'development' into mueller/amft-cmakelists	2022-05-09 17:22:40 +02:00
Robin Müller	18c2847b08	Merge branch 'development' into mueller/missing-preproc-defs	2022-05-09 17:21:48 +02:00
Steffen Gaisser	d983305ea5	Merge branch 'development' into mueller/amft-cmakelists	2022-05-09 16:34:22 +02:00
Robin Müller	dd9e28fca1	Merge branch 'development' into mueller/add-lto-support	2022-05-09 16:09:31 +02:00
Robin Mueller	7b7f5d7e0a	Merge branch 'mueller/add-lto-support' of https://egit.irs.uni-stuttgart.de/fsfw/fsfw into mueller/add-lto-support	2022-05-09 16:07:19 +02:00
Robin Mueller	fd112ed597	enable lto for test target	2022-05-09 16:07:05 +02:00
Robin Mueller	5989c88c88	indentation	2022-05-09 15:54:29 +02:00
Robin Mueller	da8a108cb7	Merge remote-tracking branch 'origin/development' into mueller/amft-cmakelists	2022-05-09 15:54:10 +02:00
Robin Müller	75132c1e39	Merge branch 'development' into mueller/add-lto-support	2022-05-09 15:52:28 +02:00
Robin Mueller	15352b539d	Merge remote-tracking branch 'upstream/development' into mueller/refactor-power-switch-if-etc	2022-05-09 15:37:32 +02:00
Robin Müller	4015e85506	Merge branch 'development' into mueller/missing-preproc-defs	2022-05-09 15:35:49 +02:00
Robin Mueller	8a40878eb5	Merge remote-tracking branch 'origin/development' into mueller/add-lto-support	2022-05-09 15:17:16 +02:00
Robin Mueller	220469a2dd	Merge remote-tracking branch 'origin/development' into mueller/amft-cmakelists	2022-05-09 15:16:12 +02:00
Robin Mueller	6308427d03	run auto-formatter over cmakelists.txt	2022-05-09 11:18:56 +02:00
Robin Müller	c78b7c432b	Merge branch 'development' into mueller/refactor-power-switch-if-etc	2022-05-09 11:02:45 +02:00
Robin Mueller	637512ad77	changelog update	2022-05-09 10:34:14 +02:00
Robin Mueller	a4bd5a2aaa	update changelog	2022-05-09 10:31:03 +02:00
Robin Mueller	a943e4eebb	enable LTO where applicable	2022-05-09 02:23:20 +02:00
Robin Mueller	cb0c80d8dc	add option and cmake module for lto support	2022-05-09 02:22:16 +02:00
Robin Müller	2fbf847367	Merge branch 'development' into mueller/missing-preproc-defs	2022-05-02 16:16:33 +02:00
Robin Müller	57e6c46e72	Merge branch 'development' into mueller/missing-preproc-defs	2022-05-02 15:16:37 +02:00
Robin Mueller	a3617cad11	preproc guards	2022-05-02 15:12:38 +02:00
Robin Mueller	2c8531ea48	Merge remote-tracking branch 'upstream/development' into mueller/refactor-power-switch-if-etc	2022-04-27 08:45:04 +02:00
Robin Mueller	b94685e045	added missing PR cross-ref	2022-04-25 15:44:46 +02:00
Robin Mueller	572d602b72	improve changelog, add entry	2022-04-25 15:42:44 +02:00
Robin Mueller	88051c9302	Merge remote-tracking branch 'upstream/development' into mueller/refactor-power-switch-if-etc	2022-04-25 15:37:03 +02:00
Robin Müller	4ed9cc933f	Merge branch 'development' into mueller/refactor-power-switch-if-etc	2022-04-11 16:11:27 +02:00
Robin Mueller	b764194ed0	added more unit tests	2022-04-01 18:43:46 +02:00
Robin Mueller	2d0e4ba951	applied afmt	2022-04-01 18:38:54 +02:00
Robin Mueller	0d549b687d	Merge branch 'mueller/refactor-power-switch-if-etc' of https://egit.irs.uni-stuttgart.de/eive/fsfw into mueller/refactor-power-switch-if-etc	2022-04-01 18:38:34 +02:00
Robin Mueller	738f572043	added unit tests, minor API change	2022-04-01 18:38:25 +02:00
Robin Müller	cab508fd64	Merge branch 'development' into mueller/refactor-power-switch-if-etc	2022-04-01 17:28:14 +02:00
Robin Mueller	c20be13733	change switch type in header as well	2022-04-01 16:40:13 +02:00
Robin Mueller	b42987059a	make dummy power switcher a system object	2022-03-30 17:41:38 +02:00
Robin Mueller	23af170229	small tweaks	2022-03-28 12:59:03 +02:00
Robin Mueller	b32d1da421	this should compile	2022-03-28 12:57:11 +02:00
Robin Mueller	6f0362b956	refactor power module	2022-03-28 12:48:15 +02:00