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`
-  - 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)
+
+### HAL
+
+- HAL Linux SPI: Set the Clock Default State when setting new SPI speed
+  and mode
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/573
+- GPIO HAL: `Direction`, `GpioOperation` and `Levels` are enum classes now, which prevents
+  name clashes with Windows defines.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/572
+- HAL Linux Uart: Baudrate and bits per word are enums now, avoiding misconfigurations
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/585
+
+### Time
+
+PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/584 and
+https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593
+
+- `timeval` to `TimeOfDay_t`
+- Added Mutex for gmtime calls: (compare http://www.opengate.at/blog/2020/01/timeless/)
+- Moved the statics used by Clock in ClockCommon.cpp to this file
+- Better check for leap seconds
+- Added Unittests for Clock (only getter)
+
+### Power 
+
+- `PowerSwitchIF`: Remove `const` specifier from `sendSwitchCommand` and `sendFuseOnCommand` and
+  also specify a `ReturnValue_t` return type
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
+- Extend `PowerSwitcher` module to optionally check current state when calling `turnOn` or
+  `turnOff`. Tis can be helpful to avoid commanding switches which do not need commanding
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590

 ## 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_REQUIRED True)
+  set(CMAKE_CXX_STANDARD 17)
+  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
-    "ETL library major version requirement"
-)
-set(FSFW_ETL_LIB_VERSION ${FSFW_ETL_LIB_MAJOR_VERSION}.27.3 CACHE STRING
-    "ETL library exact version requirement"
-)
+set(FSFW_ETL_LIB_NAME etl)
+set(FSFW_ETL_LIB_MAJOR_VERSION
+    20
+    CACHE STRING "ETL library major version requirement")
+set(FSFW_ETL_LIB_VERSION
+    ${FSFW_ETL_LIB_MAJOR_VERSION}.27.3
+    CACHE STRING "ETL library exact version requirement")
 set(FSFW_ETL_LINK_TARGET etl::etl)

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

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

-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")
-    # Check whether the user has already installed Catch2 first
-    find_package(Catch2 ${FSFW_CATCH2_LIB_MAJOR_VERSION})
-    # Not installed, so use FetchContent to download and provide Catch2
-    if(NOT Catch2_FOUND)
-        message(STATUS "Catch2 installation not found. Downloading Catch2 library with FetchContent")
-        include(FetchContent)
+  message(
+    STATUS "Building the FSFW unittests in addition to the static library")
+  # Check whether the user has already installed Catch2 first
+  find_package(Catch2 ${FSFW_CATCH2_LIB_MAJOR_VERSION})
+  # Not installed, so use FetchContent to download and provide Catch2
+  if(NOT Catch2_FOUND)
+    message(
+      STATUS
+        "Catch2 installation not found. Downloading Catch2 library with FetchContent"
+    )
+    include(FetchContent)

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

-        list(APPEND FSFW_FETCH_CONTENT_TARGETS Catch2)
-    endif()
+    list(APPEND FSFW_FETCH_CONTENT_TARGETS Catch2)
+  endif()

-    set(FSFW_CONFIG_PATH tests/src/fsfw_tests/unit/testcfg)
-    configure_file(tests/src/fsfw_tests/unit/testcfg/FSFWConfig.h.in FSFWConfig.h)
-    configure_file(tests/src/fsfw_tests/unit/testcfg/TestsConfig.h.in tests/TestsConfig.h)
+  set(FSFW_CONFIG_PATH tests/src/fsfw_tests/unit/testcfg)
+  configure_file(tests/src/fsfw_tests/unit/testcfg/FSFWConfig.h.in FSFWConfig.h)
+  configure_file(tests/src/fsfw_tests/unit/testcfg/TestsConfig.h.in
+                 tests/TestsConfig.h)

-    project(${FSFW_TEST_TGT} CXX C)
-    add_executable(${FSFW_TEST_TGT})
+  project(${FSFW_TEST_TGT} CXX C)
+  add_executable(${FSFW_TEST_TGT})
+  if(IPO_SUPPORTED AND FSFW_ENABLE_IPO)
+    set_property(TARGET ${FSFW_TEST_TGT} PROPERTY INTERPROCEDURAL_OPTIMIZATION
+                                                  TRUE)
+  endif()

-    if(FSFW_TESTS_GEN_COV)
-        message(STATUS "Generating coverage data for the library")
-        message(STATUS "Targets linking against ${LIB_FSFW_NAME} "
-            "will be compiled with coverage data as well"
-        )
-        include(FetchContent)
-        FetchContent_Declare(
-            cmake-modules
-            GIT_REPOSITORY https://github.com/bilke/cmake-modules.git
-        )
-        FetchContent_MakeAvailable(cmake-modules)
-        set(CMAKE_BUILD_TYPE "Debug")
-        list(APPEND CMAKE_MODULE_PATH ${cmake-modules_SOURCE_DIR})
-        include(CodeCoverage)
-    endif()
+  if(FSFW_TESTS_GEN_COV)
+    message(STATUS "Generating coverage data for the library")
+    message(STATUS "Targets linking against ${LIB_FSFW_NAME} "
+                   "will be compiled with coverage data as well")
+    include(FetchContent)
+    FetchContent_Declare(
+      cmake-modules GIT_REPOSITORY https://github.com/bilke/cmake-modules.git)
+    FetchContent_MakeAvailable(cmake-modules)
+    set(CMAKE_BUILD_TYPE "Debug")
+    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
-        "No ETL installation was found with find_package. Installing and providing "
-        "etl with FindPackage"
-    )
-    include(FetchContent)
+  message(
+    STATUS
+      "No ETL installation was found with find_package. Installing and providing "
+      "etl with FindPackage")
+  include(FetchContent)

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

-    list(APPEND FSFW_FETCH_CONTENT_TARGETS ${FSFW_ETL_LIB_NAME})
+  list(APPEND FSFW_FETCH_CONTENT_TARGETS ${FSFW_ETL_LIB_NAME})
 endif()

 # The documentation for FetchContent recommends declaring all the dependencies
 # before making them available. We make all declared dependency available here
 # after their declaration
 if(FSFW_FETCH_CONTENT_TARGETS)
-    FetchContent_MakeAvailable(${FSFW_FETCH_CONTENT_TARGETS})
-    if(TARGET ${FSFW_ETL_LIB_NAME})
-        add_library(${FSFW_ETL_LINK_TARGET} ALIAS ${FSFW_ETL_LIB_NAME})
-    endif()
-    if(TARGET Catch2)
-        # Fixes regression -preview4, to be confirmed in later releases
-        # Related GitHub issue: https://github.com/catchorg/Catch2/issues/2417
-        set_target_properties(Catch2 PROPERTIES DEBUG_POSTFIX "")
-    endif()
+  FetchContent_MakeAvailable(${FSFW_FETCH_CONTENT_TARGETS})
+  if(TARGET ${FSFW_ETL_LIB_NAME})
+    add_library(${FSFW_ETL_LINK_TARGET} ALIAS ${FSFW_ETL_LIB_NAME})
+  endif()
+  if(TARGET Catch2)
+    # Fixes regression -preview4, to be confirmed in later releases Related
+    # GitHub issue: https://github.com/catchorg/Catch2/issues/2417
+    set_target_properties(Catch2 PROPERTIES DEBUG_POSTFIX "")
+  endif()
 endif()

 set(FSFW_CORE_INC_PATH "inc")
@ -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
-    ${CMAKE_CURRENT_BINARY_DIR}
-)
-target_include_directories(${LIB_FSFW_NAME} INTERFACE
-    ${CMAKE_CURRENT_BINARY_DIR}
-)
-
+target_include_directories(${LIB_FSFW_NAME} PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+target_include_directories(${LIB_FSFW_NAME}
+                           INTERFACE ${CMAKE_CURRENT_BINARY_DIR})

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

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

 endif()

 set(FSFW_OSAL_DEFINITION FSFW_OSAL_HOST)

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

 configure_file(src/fsfw/FSFW.h.in fsfw/FSFW.h)
@ -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(CMAKE_COMPILER_IS_GNUCXX)
-            include(CodeCoverage)
+  if(FSFW_TESTS_GEN_COV)
+    if(CMAKE_COMPILER_IS_GNUCXX)
+      include(CodeCoverage)

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

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

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

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

-            if(WIN32)
-                setup_target_for_coverage_gcovr_html(
-                    NAME ${FSFW_TEST_TGT}_coverage
-                    EXECUTABLE ${FSFW_TEST_TGT}
-                    DEPENDENCIES ${FSFW_TEST_TGT}
-                )
-            else()
-                setup_target_for_coverage_lcov(
-                    NAME ${FSFW_TEST_TGT}_coverage
-                    EXECUTABLE ${FSFW_TEST_TGT}
-                    DEPENDENCIES ${FSFW_TEST_TGT}
-                )
-            endif()
-        endif()
+      if(WIN32)
+        setup_target_for_coverage_gcovr_html(
+          NAME ${FSFW_TEST_TGT}_coverage EXECUTABLE ${FSFW_TEST_TGT}
+          DEPENDENCIES ${FSFW_TEST_TGT})
+      else()
+        setup_target_for_coverage_lcov(
+          NAME ${FSFW_TEST_TGT}_coverage EXECUTABLE ${FSFW_TEST_TGT}
+          DEPENDENCIES ${FSFW_TEST_TGT})
+      endif()
    endif()
-    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.
-# If this is not given, we include the default configuration and emit a warning.
+# The project CMakeLists file has to set the FSFW_CONFIG_PATH and add it. If
+# this is not given, we include the default configuration and emit a warning.
 if(NOT FSFW_CONFIG_PATH)
-    set(DEF_CONF_PATH misc/defaultcfg/fsfwconfig)
-    if(NOT FSFW_BUILD_DOCS)
-        message(WARNING "Flight Software Framework configuration path not set!")
-        message(WARNING "Setting default configuration from ${DEF_CONF_PATH} ..")
-    endif()
-    add_subdirectory(${DEF_CONF_PATH})
-    set(FSFW_CONFIG_PATH ${DEF_CONF_PATH})
+  set(DEF_CONF_PATH misc/defaultcfg/fsfwconfig)
+  if(NOT FSFW_BUILD_DOCS)
+    message(WARNING "Flight Software Framework configuration path not set!")
+    message(WARNING "Setting default configuration from ${DEF_CONF_PATH} ..")
+  endif()
+  add_subdirectory(${DEF_CONF_PATH})
+  set(FSFW_CONFIG_PATH ${DEF_CONF_PATH})
 endif()

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

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

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

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

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

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

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

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

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

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

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

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

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

 add_custom_command(
-   TARGET ${LIB_FSFW_NAME}
-   POST_BUILD
-   COMMENT ${POST_BUILD_COMMENT}
-)
+  TARGET ${LIB_FSFW_NAME}
+  POST_BUILD
+  COMMENT ${POST_BUILD_COMMENT})
--- 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  */
-  if (gpioId != gpio::NO_GPIO) {
-    result = spiMutex->lockMutex(timeoutType, timeoutMs);
+  MutexIF::TimeoutType csType;
+  dur_millis_t csTimeout = 0;
+  // Pull SPI CS low. For now, no support for active high given
+  if (gpioId != gpio::NO_GPIO and not csLockManual) {
+    spiCookie->getMutexParams(csType, csTimeout);
+    result = csMutex->lockMutex(csType, csTimeout);
    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>
-inline FIFOBase<T>::FIFOBase(T* values, const size_t maxCapacity):
-        maxCapacity(maxCapacity), values(values){};
+template <typename T>
+inline FIFOBase<T>::FIFOBase(T* values, const size_t maxCapacity)
+    : maxCapacity(maxCapacity), values(values){};

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

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

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

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

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

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

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

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

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

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

 #endif
--- a/src/fsfw/container/FixedArrayList.h
+++ b/src/fsfw/container/FixedArrayList.h
@ -12,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>
-inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(key_t key, T value, Iterator *storedValue) {
-    if (_size == theMap.maxSize()) {
-        return MAP_FULL;
-    }
-    size_t position = findNicePlace(key);
-    memmove(static_cast<void*>(&theMap[position + 1]),static_cast<void*>(&theMap[position]),
-            (_size - position) * sizeof(std::pair<key_t,T>));
-    theMap[position].first = key;
-    theMap[position].second = value;
-    ++_size;
-    if (storedValue != nullptr) {
-        *storedValue = Iterator(&theMap[position]);
-    }
-    return HasReturnvaluesIF::RETURN_OK;
+template <typename key_t, typename T, typename KEY_COMPARE>
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(key_t key, T value,
+                                                                         Iterator *storedValue) {
+  if (_size == theMap.maxSize()) {
+    return MAP_FULL;
+  }
+  size_t position = findNicePlace(key);
+  memmove(static_cast<void *>(&theMap[position + 1]), static_cast<void *>(&theMap[position]),
+          (_size - position) * sizeof(std::pair<key_t, T>));
+  theMap[position].first = key;
+  theMap[position].second = value;
+  ++_size;
+  if (storedValue != nullptr) {
+    *storedValue = Iterator(&theMap[position]);
+  }
+  return HasReturnvaluesIF::RETURN_OK;
 }
-template<typename key_t, typename T, typename KEY_COMPARE>
+template <typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(std::pair<key_t, T> pair) {
-    return insert(pair.first, pair.second);
+  return insert(pair.first, pair.second);
 }

-template<typename key_t, typename T, typename KEY_COMPARE>
+template <typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::exists(key_t key) const {
-    ReturnValue_t result = KEY_DOES_NOT_EXIST;
-    if (findFirstIndex(key) < _size) {
-        result = HasReturnvaluesIF::RETURN_OK;
-    }
-    return result;
+  ReturnValue_t result = KEY_DOES_NOT_EXIST;
+  if (findFirstIndex(key) < _size) {
+    result = HasReturnvaluesIF::RETURN_OK;
+  }
+  return result;
 }

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

-template<typename key_t, typename T, typename KEY_COMPARE>
+template <typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(key_t key) {
-    size_t i;
-    if ((i = findFirstIndex(key)) >= _size) {
-        return KEY_DOES_NOT_EXIST;
-    }
-    do {
-        removeFromPosition(i);
-        i = findFirstIndex(key, i);
-    } while (i < _size);
-    return HasReturnvaluesIF::RETURN_OK;
+  size_t i;
+  if ((i = findFirstIndex(key)) >= _size) {
+    return KEY_DOES_NOT_EXIST;
+  }
+  do {
+    removeFromPosition(i);
+    i = findFirstIndex(key, i);
+  } while (i < _size);
+  return HasReturnvaluesIF::RETURN_OK;
 }

-template<typename key_t, typename T, typename KEY_COMPARE>
+template <typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(key_t key, T **value) const {
-    ReturnValue_t result = exists(key);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-    }
-    *value = &theMap[findFirstIndex(key)].second;
-    return HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result = exists(key);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  *value = &theMap[findFirstIndex(key)].second;
+  return HasReturnvaluesIF::RETURN_OK;
 }

-template<typename key_t, typename T, typename KEY_COMPARE>
-inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findFirstIndex(key_t key, size_t startAt) const {
-    if (startAt >= _size) {
-        return startAt + 1;
+template <typename key_t, typename T, typename KEY_COMPARE>
+inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findFirstIndex(key_t key,
+                                                                          size_t startAt) const {
+  if (startAt >= _size) {
+    return startAt + 1;
+  }
+  size_t i = startAt;
+  for (i = startAt; i < _size; ++i) {
+    if (theMap[i].first == key) {
+      return i;
    }
-    size_t i = startAt;
-    for (i = startAt; i < _size; ++i) {
-        if (theMap[i].first == key) {
-            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 size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findNicePlace(key_t key) const {
-    size_t i = 0;
-    for (i = 0; i < _size; ++i) {
-        if (myComp(key, theMap[i].first)) {
-            return i;
-        }
+  size_t i = 0;
+  for (i = 0; i < _size; ++i) {
+    if (myComp(key, theMap[i].first)) {
+      return i;
    }
-    return i;
+  }
+  return i;
 }

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

-
 #endif /* FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_ */
--- a/src/fsfw/datapoollocal/LocalPoolVariable.tpp
+++ b/src/fsfw/datapoollocal/LocalPoolVariable.tpp
@ -5,205 +5,189 @@
 #error Include LocalPoolVariable.h before LocalPoolVariable.tpp!
 #endif

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

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

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

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

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

-    PoolEntry<T>* poolEntry = nullptr;
-    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
-            &poolEntry);
-    if(result != RETURN_OK) {
-        object_id_t ownerObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVariable", result,
-                false, ownerObjectId, localPoolId);
-        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();
+  PoolEntry<T>* poolEntry = nullptr;
+  ReturnValue_t result =
+      LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
+  if (result != RETURN_OK) {
+    object_id_t ownerObjectId = hkManager->getCreatorObjectId();
+    reportReadCommitError("LocalPoolVariable", result, false, ownerObjectId, localPoolId);
    return result;
+  }
+
+  this->value = *(poolEntry->getDataPtr());
+  this->valid = poolEntry->getValid();
+  return RETURN_OK;
 }

-template<typename T>
+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) {
-        object_id_t targetObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVector",
-                PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
-                localPoolId);
-        return PoolVariableIF::INVALID_READ_WRITE_MODE;
-    }
+  if (readWriteMode == pool_rwm_t::VAR_READ) {
+    object_id_t targetObjectId = hkManager->getCreatorObjectId();
+    reportReadCommitError("LocalPoolVector", PoolVariableIF::INVALID_READ_WRITE_MODE, false,
+                          targetObjectId, localPoolId);
+    return PoolVariableIF::INVALID_READ_WRITE_MODE;
+  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
-    if(readWriteMode == pool_rwm_t::VAR_READ) {
-        object_id_t targetObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVector",
-                PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
-                localPoolId);
-        return PoolVariableIF::INVALID_READ_WRITE_MODE;
-    }
-    PoolEntry<T>* poolEntry = nullptr;
-    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
-            &poolEntry);
-    if(result != RETURN_OK) {
-        object_id_t targetObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVector", result, false, targetObjectId,
-                localPoolId);
-        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;
-        }
-    }
+  if (readWriteMode == pool_rwm_t::VAR_READ) {
+    object_id_t targetObjectId = hkManager->getCreatorObjectId();
+    reportReadCommitError("LocalPoolVector", PoolVariableIF::INVALID_READ_WRITE_MODE, false,
+                          targetObjectId, localPoolId);
+    return PoolVariableIF::INVALID_READ_WRITE_MODE;
+  }
+  PoolEntry<T>* poolEntry = nullptr;
+  ReturnValue_t result =
+      LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
+  if (result != RETURN_OK) {
+    object_id_t targetObjectId = hkManager->getCreatorObjectId();
+    reportReadCommitError("LocalPoolVector", result, false, targetObjectId, localPoolId);
    return result;
+  }
+  std::memcpy(poolEntry->getDataPtr(), this->value, poolEntry->getByteSize());
+  poolEntry->setValid(this->valid);
+  return RETURN_OK;
 }

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

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

--- a/src/fsfw/devicehandlers/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 = "",
-                object_id_t tmStoreId = objects::TM_STORE,
+  UdpTmTcBridge(object_id_t objectId, object_id_t tcDestination,
+                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} 
-	PRIVATE 
-		Fuse.cpp
-		PowerComponent.cpp
-		PowerSensor.cpp
-		PowerSwitcher.cpp
+target_sources(${LIB_FSFW_NAME} PRIVATE
+    Fuse.cpp
+    PowerComponent.cpp
+    PowerSensor.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(
-      1, severity::LOW);  //!< PSS detected that current on a fuse is totally out of bounds.
-  static const Event FUSE_WENT_OFF =
-      MAKE_EVENT(2, severity::LOW);  //!< PSS detected a fuse that went off.
-  static const Event POWER_ABOVE_HIGH_LIMIT =
-      MAKE_EVENT(4, severity::LOW);  //!< PSS detected a fuse that violates its limits.
-  static const Event POWER_BELOW_LOW_LIMIT =
-      MAKE_EVENT(5, severity::LOW);  //!< PSS detected a fuse that violates its limits.
+  //! PSS detected that current on a fuse is totally out of bounds.
+  static const Event FUSE_CURRENT_HIGH = MAKE_EVENT(1, severity::LOW);
+  //! PSS detected a fuse that went off.
+  static const Event FUSE_WENT_OFF = MAKE_EVENT(2, severity::LOW);
+  //! PSS detected a fuse that violates its limits.
+  static const Event POWER_ABOVE_HIGH_LIMIT = MAKE_EVENT(4, severity::LOW);
+  //! PSS detected a fuse that violates its limits.
+  static const Event POWER_BELOW_LOW_LIMIT = MAKE_EVENT(5, severity::LOW);

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

 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();
-  void turnOff();
+  void turnOn(bool checkCurrentState = true);
+  void turnOff(bool checkCurrentState = true);
+  bool active();
  void doStateMachine();
  State_t getState();
  ReturnValue_t checkSwitchState();
  uint32_t getSwitchDelay();
-  uint8_t getFirstSwitch() const;
-  uint8_t getSecondSwitch() const;
+  power::Switch_t getFirstSwitch() 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