some more fixes

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

 ## Removed

@ -69,30 +64,12 @@ https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593

 ## Additions

- LTO support: Allow using LTO/IPO by setting `FSFW_ENABLE_LTO=1`. CMake is able to detect whether
-  the user compiler supports IPO/LPO. LTO is on by default now. Most modern compilers support it,
-  can make good use of it and it usually makes the code faster and/or smaller.
-  After some more research:
-  Enabling LTO will actually cause the compiler to only produce thin LTO by adding 
-  `-flto -fno-fat-lto-objects` to the compiler options. I am not sure this is an ideal choice
-  because if an application linking against the FSFW does not use LTO, there can be compile
-  issues (e.g. observed when compiling the FSFW tests without LTO). This is a known issue as
-  can be seen in the multiple CMake issues for it: 
-    - https://gitlab.kitware.com/cmake/cmake/-/issues/22913, 
-    - https://gitlab.kitware.com/cmake/cmake/-/issues/16808, 
-    - https://gitlab.kitware.com/cmake/cmake/-/issues/21696
-  Easiest solution for now: Keep this option OFF by default.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/616
 - Linux HAL: Add wiretapping option for I2C. Enabled with `FSFW_HAL_I2C_WIRETAPPING` defined to 1
 - Dedicated Version class and constant `fsfw::FSFW_VERSION` containing version information
  inside `fsfw/version.h`
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/559
 - Added 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
@ -1,64 +1,97 @@
 cmake_minimum_required(VERSION 3.13)

-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)
-elseif(${CMAKE_CXX_STANDARD} LESS 17)
-  message(FATAL_ERROR "Compiling the FSFW requires a minimum of C++17 support")
-endif()
-
-set(FSFW_VERSION 4)
-set(FSFW_SUBVERSION 0)
-set(FSFW_REVISION 0)
+set(MSG_PREFIX "fsfw |")

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

-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")
+##########################
+# Version file handling  #
+##########################
+
+set(FSFW_VERSION_MAJOR_IF_GIT_FAILS 4)
+set(FSFW_VERSION_MINOR_IF_GIT_FAILS 0)
+set(FSFW_VERSION_REVISION_IF_GIT_FAILS 0)
+
+set(FSFW_GIT_VER_HANDLING_OK FALSE)
+# Check whether we got any revision (which isn't
+# always the case, e.g. when someone downloaded a zip
+# file from Github instead of a checkout)
+message(STATUS "${MSG_PREFIX} Determining version information with git")
+include(FsfwHelpers)
+determine_version_with_git("--exclude" "docker_*")
+if(GIT_INFO)
+    set(FSFW_GIT_INFO ${GIT_INFO} CACHE STRING "Version information retrieved with git describe" FORCE)
+    list(GET FSFW_GIT_INFO 1 FSFW_VERSION_MAJOR)
+    list(GET FSFW_GIT_INFO 2 FSFW_VERSION_MINOR)
+    list(GET FSFW_GIT_INFO 3 FSFW_VERSION_REVISION)
+    list(GET FSFW_GIT_INFO 4 FSFW_VERSION_VCS_INFO)
+    if(NOT FSFW_VERSION_MAJOR)
+        set(FSFW_VERSION_MAJOR ${FSFW_VERSION_MAJOR_IF_GIT_FAILS})
+    endif()
+    if(NOT FSFW_VERSION_MINOR)
+        set(FSFW_VERSION_MINOR ${FSFW_VERSION_MINOR_IF_GIT_FAILS})
+    endif()
+    if(NOT FSFW_VERSION_REVISION)
+        set(FSFW_VERSION_REVISION ${FSFW_VERSION_REVISION_IF_GIT_FAILS})
+    endif()
+    set(FSFW_GIT_VER_HANDLING_OK TRUE)
+else()
+    set(FSFW_GIT_VER_HANDLING_OK FALSE)
+endif()
+
+if(NOT FSFW_GIT_VER_HANDLING_OK)
+    set(FSFW_VERSION_MAJOR ${FSFW_VERSION_MAJOR_IF_GIT_FAILS})
+    set(FSFW_VERSION_MINOR ${FSFW_VERSION_MINOR_IF_GIT_FAILS})
+    set(FSFW_VERSION_REVISION ${FSFW_VERSION_REVISION_IF_GIT_FAILS})
+    set(GIT_REV "N/A")
+    set(GIT_DIFF "")
+    set(GIT_BRANCH "N/A")
+endif()
+
+
+set(LIB_FSFW_NAME fsfw)
+project(${LIB_FSFW_NAME} VERSION ${FSFW_VERSION_MAJOR}.${FSFW_VERSION_MINOR}.${FSFW_VERSION_REVISION})
+
+if(NOT CMAKE_CXX_STANDARD)
+    set(CMAKE_CXX_STANDARD 17)
+    set(CMAKE_CXX_STANDARD_REQUIRED True)
+elseif(${CMAKE_CXX_STANDARD} LESS 17)
+    message(FATAL_ERROR "${MSG_PREFIX} Compiling the FSFW requires a minimum of C++17 support")
+endif()
+
+set(FSFW_SOURCES_DIR "${CMAKE_SOURCE_DIR}/src/fsfw")
+
+set(FSFW_ETL_LIB_MAJOR_VERSION 20 CACHE STRING
+    "ETL library major version requirement"
+)
+set(FSFW_ETL_LIB_VERSION ${FSFW_ETL_LIB_MAJOR_VERSION}.27.3 CACHE STRING
+    "ETL library exact version requirement"
+)
 set(FSFW_ETL_LINK_TARGET etl::etl)

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

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

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

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

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

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

 add_library(${LIB_FSFW_NAME})

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

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

-    FetchContent_Declare(
-      Catch2
-      GIT_REPOSITORY https://github.com/catchorg/Catch2.git
-      GIT_TAG ${FSFW_CATCH2_LIB_VERSION})
+        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})
-  if(IPO_SUPPORTED AND FSFW_ENABLE_IPO)
-    set_property(TARGET ${FSFW_TEST_TGT} PROPERTY INTERPROCEDURAL_OPTIMIZATION
-                                                  TRUE)
-  endif()
+    project(${FSFW_TEST_TGT} CXX C)
+    add_executable(${FSFW_TEST_TGT})

-  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 "${MSG_PREFIX} Generating coverage data for the library")
+        message(STATUS "${MSG_PREFIX} Targets linking against ${LIB_FSFW_NAME} "
+            "will be compiled with coverage data as well"
+        )
+        set(CMAKE_BUILD_TYPE "Debug")
+        include(CodeCoverage)
+    endif()
 endif()

-message(STATUS "Finding and/or providing ETL library")
+message(STATUS "${MSG_PREFIX} Finding and/or providing ETL library")

 # Check whether the user has already installed ETL first
 find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} QUIET)
 # Not installed, so use FetchContent to download and provide etl
 if(NOT ${FSFW_ETL_LIB_NAME}_FOUND)
-  message(
-    STATUS
-      "No ETL installation was found with find_package. Installing and providing "
-      "etl with FindPackage")
-  include(FetchContent)
+    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")
@ -176,233 +195,283 @@ set(FSFW_CORE_INC_PATH "inc")
 set_property(CACHE FSFW_OSAL PROPERTY STRINGS host linux rtems freertos)

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

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

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

 endif()

 set(FSFW_OSAL_DEFINITION FSFW_OSAL_HOST)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 add_custom_command(
-  TARGET ${LIB_FSFW_NAME}
-  POST_BUILD
-  COMMENT ${POST_BUILD_COMMENT})
+   TARGET ${LIB_FSFW_NAME}
+   POST_BUILD
+   COMMENT ${POST_BUILD_COMMENT}
+)
+
+# Add a custom command that produces version.cpp, plus
+# a dummy output that's not actually produced, in order
+# to force version.cmake to always be re-run before the build
+add_custom_command(
+    TARGET ${LIB_FSFW_NAME}
+    COMMAND ${CMAKE_COMMAND} -DVERSION_DIR=${FSFW_SOURCES_DIR}
+            -DVERSION_MAJOR=${FSFW_VERSION_MAJOR}
+            -DVERSION_MINOR=${FSFW_VERSION_MINOR}
+            -DVERSION_REVISION=${FSFW_VERSION_REVISION}
+            -DVERSION_VCS_INFO=${FSFW_VERSION_VCS_INFO}
+            -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/version.cmake
+    BYPRODUCTS ${FSFW_SOURCES_DIR}/versionAutogen.cpp
+    COMMENT ""
+)
--- a/cmake/FsfwHelpers.cmake
+++ b/cmake/FsfwHelpers.cmake
@ -0,0 +1,32 @@
+# Determines the git version with git describe and returns it by setting
+# the GIT_INFO list in the parent scope. The list has the following entries
+# 1. Full version string
+# 2. Major version
+# 3. Minor version
+# 4. Revision
+# 5. git SHA hash and commits since tag
+function(determine_version_with_git)
+    include(GetGitRevisionDescription)
+    git_describe(VERSION ${ARGN})
+    get_git_head_revision(GIT_BRANCH HASH_VAR)
+    string(FIND ${VERSION} "." VALID_VERSION)
+    if(VALID_VERSION EQUAL -1)
+        message(WARNING "Version string ${VERSION} retrieved with git describe is invalid")
+        return()
+    endif()
+    # Parse the version information into pieces.
+    string(REGEX REPLACE "^v([0-9]+)\\..*" "\\1" _VERSION_MAJOR "${VERSION}")
+    string(REGEX REPLACE "^v[0-9]+\\.([0-9]+).*" "\\1" _VERSION_MINOR "${VERSION}")
+    string(REGEX REPLACE "^v[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" _VERSION_PATCH "${VERSION}")
+    string(REGEX REPLACE "^v[0-9]+\\.[0-9]+\\.[0-9]+-(.*)" "\\1" VERSION_SHA1 "${VERSION}")
+    string(STRIP "${GIT_BRANCH}" GIT_BRANCH)
+    set(GIT_INFO ${VERSION})
+    list(APPEND GIT_INFO ${_VERSION_MAJOR})
+    list(APPEND GIT_INFO ${_VERSION_MINOR})
+    list(APPEND GIT_INFO ${_VERSION_PATCH})
+    list(APPEND GIT_INFO ${VERSION_SHA1})
+    set(GIT_INFO ${GIT_INFO} PARENT_SCOPE)
+    set(GIT_BRANCH ${GIT_BRANCH} PARENT_SCOPE)
+    message(STATUS "${MSG_PREFIX} git branch ${GIT_BRANCH}")
+    message(STATUS "${MSG_PREFIX} Set git version info into GIT_INFO from the git tag ${VERSION}")
+endfunction()
--- a/cmake/cmake-modules/README.md
+++ b/cmake/cmake-modules/README.md
@ -0,0 +1,7 @@
+The files in the `bilke` folder were manually copy and pasted from the
+[cmake-modules repository](https://github.com/bilke/cmake-modules). It was decided to do
+this because only a small subset of its provided functions are needed.
+
+The files in the `rpavlik` folder were manually copy and pasted from the
+[cmake-modules repository](https://github.com/rpavlik/cmake-modules). It was decided to do
+this because only a small subset of its provided functions are needed.
--- a/cmake/cmake-modules/bilke/CodeCoverage.cmake
+++ b/cmake/cmake-modules/bilke/CodeCoverage.cmake
@ -0,0 +1,719 @@
+# Copyright (c) 2012 - 2017, Lars Bilke
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+#    may be used to endorse or promote products derived from this software without
+#    specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# CHANGES:
+#
+# 2012-01-31, Lars Bilke
+# - Enable Code Coverage
+#
+# 2013-09-17, Joakim Söderberg
+# - Added support for Clang.
+# - Some additional usage instructions.
+#
+# 2016-02-03, Lars Bilke
+# - Refactored functions to use named parameters
+#
+# 2017-06-02, Lars Bilke
+# - Merged with modified version from github.com/ufz/ogs
+#
+# 2019-05-06, Anatolii Kurotych
+# - Remove unnecessary --coverage flag
+#
+# 2019-12-13, FeRD (Frank Dana)
+# - Deprecate COVERAGE_LCOVR_EXCLUDES and COVERAGE_GCOVR_EXCLUDES lists in favor
+#   of tool-agnostic COVERAGE_EXCLUDES variable, or EXCLUDE setup arguments.
+# - CMake 3.4+: All excludes can be specified relative to BASE_DIRECTORY
+# - All setup functions: accept BASE_DIRECTORY, EXCLUDE list
+# - Set lcov basedir with -b argument
+# - Add automatic --demangle-cpp in lcovr, if 'c++filt' is available (can be
+#   overridden with NO_DEMANGLE option in setup_target_for_coverage_lcovr().)
+# - Delete output dir, .info file on 'make clean'
+# - Remove Python detection, since version mismatches will break gcovr
+# - Minor cleanup (lowercase function names, update examples...)
+#
+# 2019-12-19, FeRD (Frank Dana)
+# - Rename Lcov outputs, make filtered file canonical, fix cleanup for targets
+#
+# 2020-01-19, Bob Apthorpe
+# - Added gfortran support
+#
+# 2020-02-17, FeRD (Frank Dana)
+# - Make all add_custom_target()s VERBATIM to auto-escape wildcard characters
+#   in EXCLUDEs, and remove manual escaping from gcovr targets
+#
+# 2021-01-19, Robin Mueller
+# - Add CODE_COVERAGE_VERBOSE option which will allow to print out commands which are run
+# - Added the option for users to set the GCOVR_ADDITIONAL_ARGS variable to supply additional
+#   flags to the gcovr command
+#
+# 2020-05-04, Mihchael Davis
+#     - Add -fprofile-abs-path to make gcno files contain absolute paths
+#     - Fix BASE_DIRECTORY not working when defined
+#     - Change BYPRODUCT from folder to index.html to stop ninja from complaining about double defines
+#
+# 2021-05-10, Martin Stump
+#     - Check if the generator is multi-config before warning about non-Debug builds
+#
+# 2022-02-22, Marko Wehle
+#     - Change gcovr output from -o <filename> for --xml <filename> and --html <filename> output respectively.
+#       This will allow for Multiple Output Formats at the same time by making use of GCOVR_ADDITIONAL_ARGS, e.g. GCOVR_ADDITIONAL_ARGS "--txt".
+#
+# USAGE:
+#
+# 1. Copy this file into your cmake modules path.
+#
+# 2. Add the following line to your CMakeLists.txt (best inside an if-condition
+#    using a CMake option() to enable it just optionally):
+#      include(CodeCoverage)
+#
+# 3. Append necessary compiler flags for all supported source files:
+#      append_coverage_compiler_flags()
+#    Or for specific target:
+#      append_coverage_compiler_flags_to_target(YOUR_TARGET_NAME)
+#
+# 3.a (OPTIONAL) Set appropriate optimization flags, e.g. -O0, -O1 or -Og
+#
+# 4. If you need to exclude additional directories from the report, specify them
+#    using full paths in the COVERAGE_EXCLUDES variable before calling
+#    setup_target_for_coverage_*().
+#    Example:
+#      set(COVERAGE_EXCLUDES
+#          '${PROJECT_SOURCE_DIR}/src/dir1/*'
+#          '/path/to/my/src/dir2/*')
+#    Or, use the EXCLUDE argument to setup_target_for_coverage_*().
+#    Example:
+#      setup_target_for_coverage_lcov(
+#          NAME coverage
+#          EXECUTABLE testrunner
+#          EXCLUDE "${PROJECT_SOURCE_DIR}/src/dir1/*" "/path/to/my/src/dir2/*")
+#
+# 4.a NOTE: With CMake 3.4+, COVERAGE_EXCLUDES or EXCLUDE can also be set
+#     relative to the BASE_DIRECTORY (default: PROJECT_SOURCE_DIR)
+#     Example:
+#       set(COVERAGE_EXCLUDES "dir1/*")
+#       setup_target_for_coverage_gcovr_html(
+#           NAME coverage
+#           EXECUTABLE testrunner
+#           BASE_DIRECTORY "${PROJECT_SOURCE_DIR}/src"
+#           EXCLUDE "dir2/*")
+#
+# 5. Use the functions described below to create a custom make target which
+#    runs your test executable and produces a code coverage report.
+#
+# 6. Build a Debug build:
+#      cmake -DCMAKE_BUILD_TYPE=Debug ..
+#      make
+#      make my_coverage_target
+#
+
+include(CMakeParseArguments)
+
+option(CODE_COVERAGE_VERBOSE "Verbose information" FALSE)
+
+# Check prereqs
+find_program( GCOV_PATH gcov )
+find_program( LCOV_PATH  NAMES lcov lcov.bat lcov.exe lcov.perl)
+find_program( FASTCOV_PATH NAMES fastcov fastcov.py )
+find_program( GENHTML_PATH NAMES genhtml genhtml.perl genhtml.bat )
+find_program( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/scripts/test)
+find_program( CPPFILT_PATH NAMES c++filt )
+
+if(NOT GCOV_PATH)
+    message(FATAL_ERROR "gcov not found! Aborting...")
+endif() # NOT GCOV_PATH
+
+get_property(LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES)
+list(GET LANGUAGES 0 LANG)
+
+if("${CMAKE_${LANG}_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
+    if("${CMAKE_${LANG}_COMPILER_VERSION}" VERSION_LESS 3)
+        message(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...")
+    endif()
+elseif(NOT CMAKE_COMPILER_IS_GNUCXX)
+    if("${CMAKE_Fortran_COMPILER_ID}" MATCHES "[Ff]lang")
+        # Do nothing; exit conditional without error if true
+    elseif("${CMAKE_Fortran_COMPILER_ID}" MATCHES "GNU")
+        # Do nothing; exit conditional without error if true
+    else()
+        message(FATAL_ERROR "Compiler is not GNU gcc! Aborting...")
+    endif()
+endif()
+
+set(COVERAGE_COMPILER_FLAGS "-g -fprofile-arcs -ftest-coverage"
+    CACHE INTERNAL "")
+if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
+    include(CheckCXXCompilerFlag)
+    check_cxx_compiler_flag(-fprofile-abs-path HAVE_fprofile_abs_path)
+    if(HAVE_fprofile_abs_path)
+        set(COVERAGE_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS} -fprofile-abs-path")
+    endif()
+endif()
+
+set(CMAKE_Fortran_FLAGS_COVERAGE
+    ${COVERAGE_COMPILER_FLAGS}
+    CACHE STRING "Flags used by the Fortran compiler during coverage builds."
+    FORCE )
+set(CMAKE_CXX_FLAGS_COVERAGE
+    ${COVERAGE_COMPILER_FLAGS}
+    CACHE STRING "Flags used by the C++ compiler during coverage builds."
+    FORCE )
+set(CMAKE_C_FLAGS_COVERAGE
+    ${COVERAGE_COMPILER_FLAGS}
+    CACHE STRING "Flags used by the C compiler during coverage builds."
+    FORCE )
+set(CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    ""
+    CACHE STRING "Flags used for linking binaries during coverage builds."
+    FORCE )
+set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE
+    ""
+    CACHE STRING "Flags used by the shared libraries linker during coverage builds."
+    FORCE )
+mark_as_advanced(
+    CMAKE_Fortran_FLAGS_COVERAGE
+    CMAKE_CXX_FLAGS_COVERAGE
+    CMAKE_C_FLAGS_COVERAGE
+    CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    CMAKE_SHARED_LINKER_FLAGS_COVERAGE )
+
+get_property(GENERATOR_IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+if(NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG))
+    message(WARNING "Code coverage results with an optimised (non-Debug) build may be misleading")
+endif() # NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG)
+
+if(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_Fortran_COMPILER_ID STREQUAL "GNU")
+    link_libraries(gcov)
+endif()
+
+# Defines a target for running and collection code coverage information
+# Builds dependencies, runs the given executable and outputs reports.
+# NOTE! The executable should always have a ZERO as exit code otherwise
+# the coverage generation will not complete.
+#
+# setup_target_for_coverage_lcov(
+#     NAME testrunner_coverage                    # New target name
+#     EXECUTABLE testrunner -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
+#     DEPENDENCIES testrunner                     # Dependencies to build first
+#     BASE_DIRECTORY "../"                        # Base directory for report
+#                                                 #  (defaults to PROJECT_SOURCE_DIR)
+#     EXCLUDE "src/dir1/*" "src/dir2/*"           # Patterns to exclude (can be relative
+#                                                 #  to BASE_DIRECTORY, with CMake 3.4+)
+#     NO_DEMANGLE                                 # Don't demangle C++ symbols
+#                                                 #  even if c++filt is found
+# )
+function(setup_target_for_coverage_lcov)
+
+    set(options NO_DEMANGLE)
+    set(oneValueArgs BASE_DIRECTORY NAME)
+    set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES LCOV_ARGS GENHTML_ARGS)
+    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if(NOT LCOV_PATH)
+        message(FATAL_ERROR "lcov not found! Aborting...")
+    endif() # NOT LCOV_PATH
+
+    if(NOT GENHTML_PATH)
+        message(FATAL_ERROR "genhtml not found! Aborting...")
+    endif() # NOT GENHTML_PATH
+
+    # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR
+    if(DEFINED Coverage_BASE_DIRECTORY)
+        get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE)
+    else()
+        set(BASEDIR ${PROJECT_SOURCE_DIR})
+    endif()
+
+    # Collect excludes (CMake 3.4+: Also compute absolute paths)
+    set(LCOV_EXCLUDES "")
+    foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_LCOV_EXCLUDES})
+        if(CMAKE_VERSION VERSION_GREATER 3.4)
+            get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR})
+        endif()
+        list(APPEND LCOV_EXCLUDES "${EXCLUDE}")
+    endforeach()
+    list(REMOVE_DUPLICATES LCOV_EXCLUDES)
+
+    # Conditional arguments
+    if(CPPFILT_PATH AND NOT ${Coverage_NO_DEMANGLE})
+      set(GENHTML_EXTRA_ARGS "--demangle-cpp")
+    endif()
+     
+    # Setting up commands which will be run to generate coverage data.
+    # Cleanup lcov
+    set(LCOV_CLEAN_CMD 
+        ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} -directory . 
+        -b ${BASEDIR} --zerocounters
+    )
+    # Create baseline to make sure untouched files show up in the report
+    set(LCOV_BASELINE_CMD 
+        ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} -c -i -d . -b 
+        ${BASEDIR} -o ${Coverage_NAME}.base
+    )
+    # Run tests
+    set(LCOV_EXEC_TESTS_CMD 
+        ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS}
+    )    
+    # Capturing lcov counters and generating report
+    set(LCOV_CAPTURE_CMD 
+        ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} --directory . -b 
+        ${BASEDIR} --capture --output-file ${Coverage_NAME}.capture
+    )
+    # add baseline counters
+    set(LCOV_BASELINE_COUNT_CMD
+        ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} -a ${Coverage_NAME}.base 
+        -a ${Coverage_NAME}.capture --output-file ${Coverage_NAME}.total
+    ) 
+    # filter collected data to final coverage report
+    set(LCOV_FILTER_CMD 
+        ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} --remove 
+        ${Coverage_NAME}.total ${LCOV_EXCLUDES} --output-file ${Coverage_NAME}.info
+    )    
+    # Generate HTML output
+    set(LCOV_GEN_HTML_CMD
+        ${GENHTML_PATH} ${GENHTML_EXTRA_ARGS} ${Coverage_GENHTML_ARGS} -o 
+        ${Coverage_NAME} ${Coverage_NAME}.info
+    )
+    
+
+    if(CODE_COVERAGE_VERBOSE)
+        message(STATUS "Executed command report")
+        message(STATUS "Command to clean up lcov: ")
+        string(REPLACE ";" " " LCOV_CLEAN_CMD_SPACED "${LCOV_CLEAN_CMD}")
+        message(STATUS "${LCOV_CLEAN_CMD_SPACED}")
+
+        message(STATUS "Command to create baseline: ")
+        string(REPLACE ";" " " LCOV_BASELINE_CMD_SPACED "${LCOV_BASELINE_CMD}")
+        message(STATUS "${LCOV_BASELINE_CMD_SPACED}")
+
+        message(STATUS "Command to run the tests: ")
+        string(REPLACE ";" " " LCOV_EXEC_TESTS_CMD_SPACED "${LCOV_EXEC_TESTS_CMD}")
+        message(STATUS "${LCOV_EXEC_TESTS_CMD_SPACED}")
+
+        message(STATUS "Command to capture counters and generate report: ")
+        string(REPLACE ";" " " LCOV_CAPTURE_CMD_SPACED "${LCOV_CAPTURE_CMD}")
+        message(STATUS "${LCOV_CAPTURE_CMD_SPACED}")
+
+        message(STATUS "Command to add baseline counters: ")
+        string(REPLACE ";" " " LCOV_BASELINE_COUNT_CMD_SPACED "${LCOV_BASELINE_COUNT_CMD}")
+        message(STATUS "${LCOV_BASELINE_COUNT_CMD_SPACED}")
+
+        message(STATUS "Command to filter collected data: ")
+        string(REPLACE ";" " " LCOV_FILTER_CMD_SPACED "${LCOV_FILTER_CMD}")
+        message(STATUS "${LCOV_FILTER_CMD_SPACED}")
+
+        message(STATUS "Command to generate lcov HTML output: ")
+        string(REPLACE ";" " " LCOV_GEN_HTML_CMD_SPACED "${LCOV_GEN_HTML_CMD}")
+        message(STATUS "${LCOV_GEN_HTML_CMD_SPACED}")
+    endif()
+
+    # Setup target
+    add_custom_target(${Coverage_NAME}
+        COMMAND ${LCOV_CLEAN_CMD}
+        COMMAND ${LCOV_BASELINE_CMD} 
+        COMMAND ${LCOV_EXEC_TESTS_CMD}
+        COMMAND ${LCOV_CAPTURE_CMD}
+        COMMAND ${LCOV_BASELINE_COUNT_CMD}
+        COMMAND ${LCOV_FILTER_CMD} 
+        COMMAND ${LCOV_GEN_HTML_CMD}
+
+        # Set output files as GENERATED (will be removed on 'make clean')
+        BYPRODUCTS
+            ${Coverage_NAME}.base
+            ${Coverage_NAME}.capture
+            ${Coverage_NAME}.total
+            ${Coverage_NAME}.info
+            ${Coverage_NAME}/index.html
+        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+        DEPENDS ${Coverage_DEPENDENCIES}
+        VERBATIM # Protect arguments to commands
+        COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report."
+    )
+
+    # Show where to find the lcov info report
+    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
+        COMMAND ;
+        COMMENT "Lcov code coverage info report saved in ${Coverage_NAME}.info."
+    )
+
+    # Show info where to find the report
+    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
+        COMMAND ;
+        COMMENT "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report."
+    )
+
+endfunction() # setup_target_for_coverage_lcov
+
+# Defines a target for running and collection code coverage information
+# Builds dependencies, runs the given executable and outputs reports.
+# NOTE! The executable should always have a ZERO as exit code otherwise
+# the coverage generation will not complete.
+#
+# setup_target_for_coverage_gcovr_xml(
+#     NAME ctest_coverage                    # New target name
+#     EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
+#     DEPENDENCIES executable_target         # Dependencies to build first
+#     BASE_DIRECTORY "../"                   # Base directory for report
+#                                            #  (defaults to PROJECT_SOURCE_DIR)
+#     EXCLUDE "src/dir1/*" "src/dir2/*"      # Patterns to exclude (can be relative
+#                                            #  to BASE_DIRECTORY, with CMake 3.4+)
+# )
+# The user can set the variable GCOVR_ADDITIONAL_ARGS to supply additional flags to the
+# GCVOR command.
+function(setup_target_for_coverage_gcovr_xml)
+
+    set(options NONE)
+    set(oneValueArgs BASE_DIRECTORY NAME)
+    set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
+    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if(NOT GCOVR_PATH)
+        message(FATAL_ERROR "gcovr not found! Aborting...")
+    endif() # NOT GCOVR_PATH
+
+    # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR
+    if(DEFINED Coverage_BASE_DIRECTORY)
+        get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE)
+    else()
+        set(BASEDIR ${PROJECT_SOURCE_DIR})
+    endif()
+
+    # Collect excludes (CMake 3.4+: Also compute absolute paths)
+    set(GCOVR_EXCLUDES "")
+    foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_GCOVR_EXCLUDES})
+        if(CMAKE_VERSION VERSION_GREATER 3.4)
+            get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR})
+        endif()
+        list(APPEND GCOVR_EXCLUDES "${EXCLUDE}")
+    endforeach()
+    list(REMOVE_DUPLICATES GCOVR_EXCLUDES)
+
+    # Combine excludes to several -e arguments
+    set(GCOVR_EXCLUDE_ARGS "")
+    foreach(EXCLUDE ${GCOVR_EXCLUDES})
+        list(APPEND GCOVR_EXCLUDE_ARGS "-e")
+        list(APPEND GCOVR_EXCLUDE_ARGS "${EXCLUDE}")
+    endforeach()
+    
+    # Set up commands which will be run to generate coverage data
+    # Run tests
+    set(GCOVR_XML_EXEC_TESTS_CMD
+        ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS}
+    )
+    # Running gcovr
+    set(GCOVR_XML_CMD
+        ${GCOVR_PATH} --xml ${Coverage_NAME}.xml -r ${BASEDIR} ${GCOVR_ADDITIONAL_ARGS}
+        ${GCOVR_EXCLUDE_ARGS} --object-directory=${PROJECT_BINARY_DIR}
+    )
+    
+    if(CODE_COVERAGE_VERBOSE)
+        message(STATUS "Executed command report")
+
+        message(STATUS "Command to run tests: ")
+        string(REPLACE ";" " " GCOVR_XML_EXEC_TESTS_CMD_SPACED "${GCOVR_XML_EXEC_TESTS_CMD}")
+        message(STATUS "${GCOVR_XML_EXEC_TESTS_CMD_SPACED}")
+
+        message(STATUS "Command to generate gcovr XML coverage data: ")
+        string(REPLACE ";" " " GCOVR_XML_CMD_SPACED "${GCOVR_XML_CMD}")
+        message(STATUS "${GCOVR_XML_CMD_SPACED}")
+    endif()
+
+    add_custom_target(${Coverage_NAME}
+        COMMAND ${GCOVR_XML_EXEC_TESTS_CMD}
+        COMMAND ${GCOVR_XML_CMD}
+        
+        BYPRODUCTS ${Coverage_NAME}.xml
+        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+        DEPENDS ${Coverage_DEPENDENCIES}
+        VERBATIM # Protect arguments to commands
+        COMMENT "Running gcovr to produce Cobertura code coverage report."
+    )
+
+    # Show info where to find the report
+    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
+        COMMAND ;
+        COMMENT "Cobertura code coverage report saved in ${Coverage_NAME}.xml."
+    )
+endfunction() # setup_target_for_coverage_gcovr_xml
+
+# Defines a target for running and collection code coverage information
+# Builds dependencies, runs the given executable and outputs reports.
+# NOTE! The executable should always have a ZERO as exit code otherwise
+# the coverage generation will not complete.
+#
+# setup_target_for_coverage_gcovr_html(
+#     NAME ctest_coverage                    # New target name
+#     EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
+#     DEPENDENCIES executable_target         # Dependencies to build first
+#     BASE_DIRECTORY "../"                   # Base directory for report
+#                                            #  (defaults to PROJECT_SOURCE_DIR)
+#     EXCLUDE "src/dir1/*" "src/dir2/*"      # Patterns to exclude (can be relative
+#                                            #  to BASE_DIRECTORY, with CMake 3.4+)
+# )
+# The user can set the variable GCOVR_ADDITIONAL_ARGS to supply additional flags to the
+# GCVOR command.
+function(setup_target_for_coverage_gcovr_html)
+
+    set(options NONE)
+    set(oneValueArgs BASE_DIRECTORY NAME)
+    set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
+    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if(NOT GCOVR_PATH)
+        message(FATAL_ERROR "gcovr not found! Aborting...")
+    endif() # NOT GCOVR_PATH
+
+    # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR
+    if(DEFINED Coverage_BASE_DIRECTORY)
+        get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE)
+    else()
+        set(BASEDIR ${PROJECT_SOURCE_DIR})
+    endif()
+
+    # Collect excludes (CMake 3.4+: Also compute absolute paths)
+    set(GCOVR_EXCLUDES "")
+    foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_GCOVR_EXCLUDES})
+        if(CMAKE_VERSION VERSION_GREATER 3.4)
+            get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR})
+        endif()
+        list(APPEND GCOVR_EXCLUDES "${EXCLUDE}")
+    endforeach()
+    list(REMOVE_DUPLICATES GCOVR_EXCLUDES)
+
+    # Combine excludes to several -e arguments
+    set(GCOVR_EXCLUDE_ARGS "")
+    foreach(EXCLUDE ${GCOVR_EXCLUDES})
+        list(APPEND GCOVR_EXCLUDE_ARGS "-e")
+        list(APPEND GCOVR_EXCLUDE_ARGS "${EXCLUDE}")
+    endforeach()
+
+    # Set up commands which will be run to generate coverage data
+    # Run tests
+    set(GCOVR_HTML_EXEC_TESTS_CMD
+        ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS}
+    )
+    # Create folder
+    set(GCOVR_HTML_FOLDER_CMD
+        ${CMAKE_COMMAND} -E make_directory ${PROJECT_BINARY_DIR}/${Coverage_NAME}
+    )
+    # Running gcovr
+    set(GCOVR_HTML_CMD
+        ${GCOVR_PATH} --html ${Coverage_NAME}/index.html --html-details -r ${BASEDIR} ${GCOVR_ADDITIONAL_ARGS}
+        ${GCOVR_EXCLUDE_ARGS} --object-directory=${PROJECT_BINARY_DIR}
+    )
+
+    if(CODE_COVERAGE_VERBOSE)
+        message(STATUS "Executed command report")
+
+        message(STATUS "Command to run tests: ")
+        string(REPLACE ";" " " GCOVR_HTML_EXEC_TESTS_CMD_SPACED "${GCOVR_HTML_EXEC_TESTS_CMD}")
+        message(STATUS "${GCOVR_HTML_EXEC_TESTS_CMD_SPACED}")
+
+        message(STATUS "Command to create a folder: ")
+        string(REPLACE ";" " " GCOVR_HTML_FOLDER_CMD_SPACED "${GCOVR_HTML_FOLDER_CMD}")
+        message(STATUS "${GCOVR_HTML_FOLDER_CMD_SPACED}")
+
+        message(STATUS "Command to generate gcovr HTML coverage data: ")
+        string(REPLACE ";" " " GCOVR_HTML_CMD_SPACED "${GCOVR_HTML_CMD}")
+        message(STATUS "${GCOVR_HTML_CMD_SPACED}")
+    endif()
+
+    add_custom_target(${Coverage_NAME}
+        COMMAND ${GCOVR_HTML_EXEC_TESTS_CMD}
+        COMMAND ${GCOVR_HTML_FOLDER_CMD}
+        COMMAND ${GCOVR_HTML_CMD}
+
+        BYPRODUCTS ${PROJECT_BINARY_DIR}/${Coverage_NAME}/index.html  # report directory
+        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+        DEPENDS ${Coverage_DEPENDENCIES}
+        VERBATIM # Protect arguments to commands
+        COMMENT "Running gcovr to produce HTML code coverage report."
+    )
+
+    # Show info where to find the report
+    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
+        COMMAND ;
+        COMMENT "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report."
+    )
+
+endfunction() # setup_target_for_coverage_gcovr_html
+
+# Defines a target for running and collection code coverage information
+# Builds dependencies, runs the given executable and outputs reports.
+# NOTE! The executable should always have a ZERO as exit code otherwise
+# the coverage generation will not complete.
+#
+# setup_target_for_coverage_fastcov(
+#     NAME testrunner_coverage                    # New target name
+#     EXECUTABLE testrunner -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
+#     DEPENDENCIES testrunner                     # Dependencies to build first
+#     BASE_DIRECTORY "../"                        # Base directory for report
+#                                                 #  (defaults to PROJECT_SOURCE_DIR)
+#     EXCLUDE "src/dir1/" "src/dir2/"             # Patterns to exclude.
+#     NO_DEMANGLE                                 # Don't demangle C++ symbols
+#                                                 #  even if c++filt is found
+#     SKIP_HTML                                   # Don't create html report
+#     POST_CMD perl -i -pe s!${PROJECT_SOURCE_DIR}/!!g ctest_coverage.json  # E.g. for stripping source dir from file paths
+# )
+function(setup_target_for_coverage_fastcov)
+
+    set(options NO_DEMANGLE SKIP_HTML)
+    set(oneValueArgs BASE_DIRECTORY NAME)
+    set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES FASTCOV_ARGS GENHTML_ARGS POST_CMD)
+    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if(NOT FASTCOV_PATH)
+        message(FATAL_ERROR "fastcov not found! Aborting...")
+    endif()
+
+    if(NOT Coverage_SKIP_HTML AND NOT GENHTML_PATH)
+        message(FATAL_ERROR "genhtml not found! Aborting...")
+    endif()
+
+    # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR
+    if(Coverage_BASE_DIRECTORY)
+        get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE)
+    else()
+        set(BASEDIR ${PROJECT_SOURCE_DIR})
+    endif()
+
+    # Collect excludes (Patterns, not paths, for fastcov)
+    set(FASTCOV_EXCLUDES "")
+    foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_FASTCOV_EXCLUDES})
+        list(APPEND FASTCOV_EXCLUDES "${EXCLUDE}")
+    endforeach()
+    list(REMOVE_DUPLICATES FASTCOV_EXCLUDES)
+
+    # Conditional arguments
+    if(CPPFILT_PATH AND NOT ${Coverage_NO_DEMANGLE})
+        set(GENHTML_EXTRA_ARGS "--demangle-cpp")
+    endif()
+
+    # Set up commands which will be run to generate coverage data
+    set(FASTCOV_EXEC_TESTS_CMD ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS})
+
+    set(FASTCOV_CAPTURE_CMD ${FASTCOV_PATH} ${Coverage_FASTCOV_ARGS} --gcov ${GCOV_PATH}
+        --search-directory ${BASEDIR}
+        --process-gcno
+        --output ${Coverage_NAME}.json
+        --exclude ${FASTCOV_EXCLUDES}
+        --exclude ${FASTCOV_EXCLUDES}
+    )
+    
+    set(FASTCOV_CONVERT_CMD ${FASTCOV_PATH}
+        -C ${Coverage_NAME}.json --lcov --output ${Coverage_NAME}.info
+    )
+
+    if(Coverage_SKIP_HTML)
+        set(FASTCOV_HTML_CMD ";")
+    else()
+        set(FASTCOV_HTML_CMD ${GENHTML_PATH} ${GENHTML_EXTRA_ARGS} ${Coverage_GENHTML_ARGS}
+            -o ${Coverage_NAME} ${Coverage_NAME}.info
+        )
+    endif()
+
+    set(FASTCOV_POST_CMD ";")
+    if(Coverage_POST_CMD)
+        set(FASTCOV_POST_CMD ${Coverage_POST_CMD})
+    endif()
+
+    if(CODE_COVERAGE_VERBOSE)
+        message(STATUS "Code coverage commands for target ${Coverage_NAME} (fastcov):")
+
+        message("   Running tests:")
+        string(REPLACE ";" " " FASTCOV_EXEC_TESTS_CMD_SPACED "${FASTCOV_EXEC_TESTS_CMD}")
+        message("     ${FASTCOV_EXEC_TESTS_CMD_SPACED}")
+
+        message("   Capturing fastcov counters and generating report:")
+        string(REPLACE ";" " " FASTCOV_CAPTURE_CMD_SPACED "${FASTCOV_CAPTURE_CMD}")
+        message("     ${FASTCOV_CAPTURE_CMD_SPACED}")
+
+        message("   Converting fastcov .json to lcov .info:")
+        string(REPLACE ";" " " FASTCOV_CONVERT_CMD_SPACED "${FASTCOV_CONVERT_CMD}")
+        message("     ${FASTCOV_CONVERT_CMD_SPACED}")
+
+        if(NOT Coverage_SKIP_HTML)
+            message("   Generating HTML report: ")
+            string(REPLACE ";" " " FASTCOV_HTML_CMD_SPACED "${FASTCOV_HTML_CMD}")
+            message("     ${FASTCOV_HTML_CMD_SPACED}")
+        endif()
+        if(Coverage_POST_CMD)
+            message("   Running post command: ")
+            string(REPLACE ";" " " FASTCOV_POST_CMD_SPACED "${FASTCOV_POST_CMD}")
+            message("     ${FASTCOV_POST_CMD_SPACED}")
+        endif()
+    endif()
+
+    # Setup target
+    add_custom_target(${Coverage_NAME}
+
+        # Cleanup fastcov
+        COMMAND ${FASTCOV_PATH} ${Coverage_FASTCOV_ARGS} --gcov ${GCOV_PATH}
+            --search-directory ${BASEDIR}
+            --zerocounters
+
+        COMMAND ${FASTCOV_EXEC_TESTS_CMD}
+        COMMAND ${FASTCOV_CAPTURE_CMD}
+        COMMAND ${FASTCOV_CONVERT_CMD}
+        COMMAND ${FASTCOV_HTML_CMD}
+        COMMAND ${FASTCOV_POST_CMD}
+
+        # Set output files as GENERATED (will be removed on 'make clean')
+        BYPRODUCTS
+             ${Coverage_NAME}.info
+             ${Coverage_NAME}.json
+             ${Coverage_NAME}/index.html  # report directory
+
+        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+        DEPENDS ${Coverage_DEPENDENCIES}
+        VERBATIM # Protect arguments to commands
+        COMMENT "Resetting code coverage counters to zero. Processing code coverage counters and generating report."
+    )
+
+    set(INFO_MSG "fastcov code coverage info report saved in ${Coverage_NAME}.info and ${Coverage_NAME}.json.")
+    if(NOT Coverage_SKIP_HTML)
+        string(APPEND INFO_MSG " Open ${PROJECT_BINARY_DIR}/${Coverage_NAME}/index.html in your browser to view the coverage report.")
+    endif()
+    # Show where to find the fastcov info report
+    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E echo ${INFO_MSG}
+    )
+
+endfunction() # setup_target_for_coverage_fastcov
+
+function(append_coverage_compiler_flags)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
+    set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
+    message(STATUS "Appending code coverage compiler flags: ${COVERAGE_COMPILER_FLAGS}")
+endfunction() # append_coverage_compiler_flags
+
+# Setup coverage for specific library
+function(append_coverage_compiler_flags_to_target name)
+    target_compile_options(${name}
+        PRIVATE ${COVERAGE_COMPILER_FLAGS})
+endfunction()
--- a/cmake/cmake-modules/bilke/LICENSE_1_0.txt
+++ b/cmake/cmake-modules/bilke/LICENSE_1_0.txt
@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
--- a/cmake/cmake-modules/rpavlik/GetGitRevisionDescription.cmake
+++ b/cmake/cmake-modules/rpavlik/GetGitRevisionDescription.cmake
@ -0,0 +1,284 @@
+# - Returns a version string from Git
+#
+# These functions force a re-configure on each git commit so that you can
+# trust the values of the variables in your build system.
+#
+#  get_git_head_revision(<refspecvar> <hashvar> [ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR])
+#
+# Returns the refspec and sha hash of the current head revision
+#
+#  git_describe(<var> [<additional arguments to git describe> ...])
+#
+# Returns the results of git describe on the source tree, and adjusting
+# the output so that it tests false if an error occurs.
+#
+#  git_describe_working_tree(<var> [<additional arguments to git describe> ...])
+#
+# Returns the results of git describe on the working tree (--dirty option),
+# and adjusting the output so that it tests false if an error occurs.
+#
+#  git_get_exact_tag(<var> [<additional arguments to git describe> ...])
+#
+# Returns the results of git describe --exact-match on the source tree,
+# and adjusting the output so that it tests false if there was no exact
+# matching tag.
+#
+#  git_local_changes(<var>)
+#
+# Returns either "CLEAN" or "DIRTY" with respect to uncommitted changes.
+# Uses the return code of "git diff-index --quiet HEAD --".
+# Does not regard untracked files.
+#
+# Requires CMake 2.6 or newer (uses the 'function' command)
+#
+# Original Author:
+# 2009-2020 Ryan Pavlik <ryan.pavlik@gmail.com> <abiryan@ryand.net>
+# http://academic.cleardefinition.com
+#
+# Copyright 2009-2013, Iowa State University.
+# Copyright 2013-2020, Ryan Pavlik
+# Copyright 2013-2020, Contributors
+# SPDX-License-Identifier: BSL-1.0
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+if(__get_git_revision_description)
+    return()
+endif()
+set(__get_git_revision_description YES)
+
+# We must run the following at "include" time, not at function call time,
+# to find the path to this module rather than the path to a calling list file
+get_filename_component(_gitdescmoddir ${CMAKE_CURRENT_LIST_FILE} PATH)
+
+# Function _git_find_closest_git_dir finds the next closest .git directory
+# that is part of any directory in the path defined by _start_dir.
+# The result is returned in the parent scope variable whose name is passed
+# as variable _git_dir_var. If no .git directory can be found, the
+# function returns an empty string via _git_dir_var.
+#
+# Example: Given a path C:/bla/foo/bar and assuming C:/bla/.git exists and
+# neither foo nor bar contain a file/directory .git. This wil return
+# C:/bla/.git
+#
+function(_git_find_closest_git_dir _start_dir _git_dir_var)
+    set(cur_dir "${_start_dir}")
+    set(git_dir "${_start_dir}/.git")
+    while(NOT EXISTS "${git_dir}")
+        # .git dir not found, search parent directories
+        set(git_previous_parent "${cur_dir}")
+        get_filename_component(cur_dir "${cur_dir}" DIRECTORY)
+        if(cur_dir STREQUAL git_previous_parent)
+            # We have reached the root directory, we are not in git
+            set(${_git_dir_var}
+                ""
+                PARENT_SCOPE)
+            return()
+        endif()
+        set(git_dir "${cur_dir}/.git")
+    endwhile()
+    set(${_git_dir_var}
+        "${git_dir}"
+        PARENT_SCOPE)
+endfunction()
+
+function(get_git_head_revision _refspecvar _hashvar)
+    _git_find_closest_git_dir("${CMAKE_CURRENT_SOURCE_DIR}" GIT_DIR)
+
+    if("${ARGN}" STREQUAL "ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR")
+        set(ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR TRUE)
+    else()
+        set(ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR FALSE)
+    endif()
+    if(NOT "${GIT_DIR}" STREQUAL "")
+        file(RELATIVE_PATH _relative_to_source_dir "${CMAKE_SOURCE_DIR}"
+             "${GIT_DIR}")
+        if("${_relative_to_source_dir}" MATCHES "[.][.]" AND NOT ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR)
+            # We've gone above the CMake root dir.
+            set(GIT_DIR "")
+        endif()
+    endif()
+    if("${GIT_DIR}" STREQUAL "")
+        set(${_refspecvar}
+            "GITDIR-NOTFOUND"
+            PARENT_SCOPE)
+        set(${_hashvar}
+            "GITDIR-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+
+    # Check if the current source dir is a git submodule or a worktree.
+    # In both cases .git is a file instead of a directory.
+    #
+    if(NOT IS_DIRECTORY ${GIT_DIR})
+        # The following git command will return a non empty string that
+        # points to the super project working tree if the current
+        # source dir is inside a git submodule.
+        # Otherwise the command will return an empty string.
+        #
+        execute_process(
+            COMMAND "${GIT_EXECUTABLE}" rev-parse
+                    --show-superproject-working-tree
+            WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+            OUTPUT_VARIABLE out
+            ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+        if(NOT "${out}" STREQUAL "")
+            # If out is empty, GIT_DIR/CMAKE_CURRENT_SOURCE_DIR is in a submodule
+            file(READ ${GIT_DIR} submodule)
+            string(REGEX REPLACE "gitdir: (.*)$" "\\1" GIT_DIR_RELATIVE
+                                 ${submodule})
+            string(STRIP ${GIT_DIR_RELATIVE} GIT_DIR_RELATIVE)
+            get_filename_component(SUBMODULE_DIR ${GIT_DIR} PATH)
+            get_filename_component(GIT_DIR ${SUBMODULE_DIR}/${GIT_DIR_RELATIVE}
+                                   ABSOLUTE)
+            set(HEAD_SOURCE_FILE "${GIT_DIR}/HEAD")
+        else()
+            # GIT_DIR/CMAKE_CURRENT_SOURCE_DIR is in a worktree
+            file(READ ${GIT_DIR} worktree_ref)
+            # The .git directory contains a path to the worktree information directory
+            # inside the parent git repo of the worktree.
+            #
+            string(REGEX REPLACE "gitdir: (.*)$" "\\1" git_worktree_dir
+                                 ${worktree_ref})
+            string(STRIP ${git_worktree_dir} git_worktree_dir)
+            _git_find_closest_git_dir("${git_worktree_dir}" GIT_DIR)
+            set(HEAD_SOURCE_FILE "${git_worktree_dir}/HEAD")
+        endif()
+    else()
+        set(HEAD_SOURCE_FILE "${GIT_DIR}/HEAD")
+    endif()
+    set(GIT_DATA "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/git-data")
+    if(NOT EXISTS "${GIT_DATA}")
+        file(MAKE_DIRECTORY "${GIT_DATA}")
+    endif()
+
+    if(NOT EXISTS "${HEAD_SOURCE_FILE}")
+        return()
+    endif()
+    set(HEAD_FILE "${GIT_DATA}/HEAD")
+    configure_file("${HEAD_SOURCE_FILE}" "${HEAD_FILE}" COPYONLY)
+
+    configure_file("${_gitdescmoddir}/GetGitRevisionDescription.cmake.in"
+                   "${GIT_DATA}/grabRef.cmake" @ONLY)
+    include("${GIT_DATA}/grabRef.cmake")
+
+    set(${_refspecvar}
+        "${HEAD_REF}"
+        PARENT_SCOPE)
+    set(${_hashvar}
+        "${HEAD_HASH}"
+        PARENT_SCOPE)
+endfunction()
+
+function(git_describe _var)
+    if(NOT GIT_FOUND)
+        find_package(Git QUIET)
+    endif()
+    get_git_head_revision(refspec hash)
+    if(NOT GIT_FOUND)
+        set(${_var}
+            "GIT-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+    if(NOT hash)
+        set(${_var}
+            "HEAD-HASH-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+
+    # TODO sanitize
+    #if((${ARGN}" MATCHES "&&") OR
+    #   (ARGN MATCHES "||") OR
+    #   (ARGN MATCHES "\\;"))
+    #   message("Please report the following error to the project!")
+    #   message(FATAL_ERROR "Looks like someone's doing something nefarious with git_describe! Passed arguments ${ARGN}")
+    #endif()
+
+    #message(STATUS "Arguments to execute_process: ${ARGN}")
+
+    execute_process(
+        COMMAND "${GIT_EXECUTABLE}" describe --tags --always ${hash} ${ARGN}
+        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+        RESULT_VARIABLE res
+        OUTPUT_VARIABLE out
+        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if(NOT res EQUAL 0)
+        set(out "${out}-${res}-NOTFOUND")
+    endif()
+
+    set(${_var}
+        "${out}"
+        PARENT_SCOPE)
+endfunction()
+
+function(git_describe_working_tree _var)
+    if(NOT GIT_FOUND)
+        find_package(Git QUIET)
+    endif()
+    if(NOT GIT_FOUND)
+        set(${_var}
+            "GIT-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+
+    execute_process(
+        COMMAND "${GIT_EXECUTABLE}" describe --dirty ${ARGN}
+        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+        RESULT_VARIABLE res
+        OUTPUT_VARIABLE out
+        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if(NOT res EQUAL 0)
+        set(out "${out}-${res}-NOTFOUND")
+    endif()
+
+    set(${_var}
+        "${out}"
+        PARENT_SCOPE)
+endfunction()
+
+function(git_get_exact_tag _var)
+    git_describe(out --exact-match ${ARGN})
+    set(${_var}
+        "${out}"
+        PARENT_SCOPE)
+endfunction()
+
+function(git_local_changes _var)
+    if(NOT GIT_FOUND)
+        find_package(Git QUIET)
+    endif()
+    get_git_head_revision(refspec hash)
+    if(NOT GIT_FOUND)
+        set(${_var}
+            "GIT-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+    if(NOT hash)
+        set(${_var}
+            "HEAD-HASH-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+
+    execute_process(
+        COMMAND "${GIT_EXECUTABLE}" diff-index --quiet HEAD --
+        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+        RESULT_VARIABLE res
+        OUTPUT_VARIABLE out
+        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if(res EQUAL 0)
+        set(${_var}
+            "CLEAN"
+            PARENT_SCOPE)
+    else()
+        set(${_var}
+            "DIRTY"
+            PARENT_SCOPE)
+    endif()
+endfunction()
--- a/cmake/cmake-modules/rpavlik/GetGitRevisionDescription.cmake.in
+++ b/cmake/cmake-modules/rpavlik/GetGitRevisionDescription.cmake.in
@ -0,0 +1,43 @@
+#
+# Internal file for GetGitRevisionDescription.cmake
+#
+# Requires CMake 2.6 or newer (uses the 'function' command)
+#
+# Original Author:
+# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
+# http://academic.cleardefinition.com
+# Iowa State University HCI Graduate Program/VRAC
+#
+# Copyright 2009-2012, Iowa State University
+# Copyright 2011-2015, Contributors
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+# SPDX-License-Identifier: BSL-1.0
+
+set(HEAD_HASH)
+
+file(READ "@HEAD_FILE@" HEAD_CONTENTS LIMIT 1024)
+
+string(STRIP "${HEAD_CONTENTS}" HEAD_CONTENTS)
+if(HEAD_CONTENTS MATCHES "ref")
+    # named branch
+    string(REPLACE "ref: " "" HEAD_REF "${HEAD_CONTENTS}")
+    if(EXISTS "@GIT_DIR@/${HEAD_REF}")
+        configure_file("@GIT_DIR@/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY)
+    else()
+        configure_file("@GIT_DIR@/packed-refs" "@GIT_DATA@/packed-refs" COPYONLY)
+        file(READ "@GIT_DATA@/packed-refs" PACKED_REFS)
+        if(${PACKED_REFS} MATCHES "([0-9a-z]*) ${HEAD_REF}")
+            set(HEAD_HASH "${CMAKE_MATCH_1}")
+        endif()
+    endif()
+else()
+    # detached HEAD
+    configure_file("@GIT_DIR@/HEAD" "@GIT_DATA@/head-ref" COPYONLY)
+endif()
+
+if(NOT HEAD_HASH)
+    file(READ "@GIT_DATA@/head-ref" HEAD_HASH LIMIT 1024)
+    string(STRIP "${HEAD_HASH}" HEAD_HASH)
+endif()
--- a/cmake/cmake-modules/rpavlik/LICENSES/BSD-3-Clause.txt
+++ b/cmake/cmake-modules/rpavlik/LICENSES/BSD-3-Clause.txt
@ -0,0 +1,26 @@
+Copyright (c) <year> <owner>. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+may be used to endorse or promote products derived from this software without
+specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--- a/cmake/cmake-modules/rpavlik/LICENSES/BSL-1.0.txt
+++ b/cmake/cmake-modules/rpavlik/LICENSES/BSL-1.0.txt
@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute, execute,
+and transmit the Software, and to prepare derivative works of the Software,
+and to permit third-parties to whom the Software is furnished to do so, all
+subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer, must
+be included in all copies of the Software, in whole or in part, and all derivative
+works of the Software, unless such copies or derivative works are solely in
+the form of machine-executable object code generated by a source language
+processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES
+OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
--- a/cmake/cmake-modules/rpavlik/LICENSE_1_0.txt
+++ b/cmake/cmake-modules/rpavlik/LICENSE_1_0.txt
@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
--- a/cmake/version.cmake
+++ b/cmake/version.cmake
@ -0,0 +1,38 @@
+if(NOT DEFINED VERSION_MAJOR)
+    message(WARNING "version.cmake | No VERSION_MAJOR variable passed. Setting to 0")
+    set(VERSION_MAJOR 0)
+endif()
+if(NOT DEFINED VERSION_MINOR)
+    message(WARNING "version.cmake | No VERSION_MINOR variable passed. Setting to 0")
+    set(VERSION_MINOR 0)
+endif()
+if(NOT DEFINED VERSION_REVISION)
+    message(WARNING "version.cmake | No VERSION_REVISION variable passed. Setting to 0")
+    set(VERSION_REVISION 0)
+endif()
+if(NOT DEFINED VERSION_VCS_INFO)
+    set(VERSION_VCS_INFO "")
+endif()
+
+set(VERSION_TO_SET "#include \"version.h\"
+
+namespace fsfw {
+
+const int FSFW_VERSION_MAJOR = ${VERSION_MAJOR};
+const int FSFW_VERSION_MINOR = ${VERSION_MINOR};
+const int FSFW_VERSION_REVISION = ${VERSION_MINOR};
+const char FSFW_VCS_INFO[] = \"${VERSION_VCS_INFO}\";
+
+};
+")
+
+if(EXISTS ${VERSION_DIR}/versionAutogen.cpp)
+    file(READ ${VERSION_DIR}/versionAutogen.cpp OLD_VERSION)
+else()
+    set(OLD_VERSION "")
+endif()
+
+if (NOT "${VERSION_TO_SET}" STREQUAL "${OLD_VERSION}")
+    message(STATUS "Updating versionAutogen.cpp file")
+    file(WRITE ${VERSION_DIR}/versionAutogen.cpp "${VERSION_TO_SET}")
+endif()
--- a/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.cpp
+++ b/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.cpp
@ -20,9 +20,7 @@ LinuxLibgpioIF::~LinuxLibgpioIF() {
 ReturnValue_t LinuxLibgpioIF::addGpios(GpioCookie* gpioCookie) {
  ReturnValue_t result;
  if (gpioCookie == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::error << "LinuxLibgpioIF::addGpios: Invalid cookie" << std::endl;
-#endif
    return RETURN_FAILED;
  }

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

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

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

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

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

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

-  if (gpioId != gpio::NO_GPIO and not csLockManual) {
+  if (gpioId != gpio::NO_GPIO) {
    gpioComIF->pullHigh(gpioId);
    result = spiMutex->unlockMutex();
    if (result != RETURN_OK) {
@ -298,27 +292,12 @@ 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::sendMessage: Failed to lock mutex with code "
-                 << "0x" << std::hex << std::setfill('0') << std::setw(4) << result << std::dec
-                 << std::endl;
-#else
-      sif::printError("SpiComIF::sendMessage: Failed to lock mutex with code %d\n", result);
-#endif
+      sif::error << "SpiComIF::getSendSuccess: Failed to lock mutex" << std::endl;
 #endif
      return result;
    }
@ -336,7 +315,7 @@ ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
    result = HALF_DUPLEX_TRANSFER_FAILED;
  }

-  if (gpioId != gpio::NO_GPIO and not csLockManual) {
+  if (gpioId != gpio::NO_GPIO) {
    gpioComIF->pullHigh(gpioId);
    result = spiMutex->unlockMutex();
    if (result != RETURN_OK) {
@ -367,7 +346,6 @@ 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;
@ -377,9 +355,6 @@ 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 CLASS_ID = CLASS_ID::HAL_SPI;
+  static constexpr uint8_t spiRetvalId = CLASS_ID::HAL_SPI;
  static constexpr ReturnValue_t OPENING_FILE_FAILED =
-      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 0);
+      HasReturnvaluesIF::makeReturnCode(spiRetvalId, 0);
  /* Full duplex (ioctl) transfer failure */
  static constexpr ReturnValue_t FULL_DUPLEX_TRANSFER_FAILED =
-      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 1);
+      HasReturnvaluesIF::makeReturnCode(spiRetvalId, 1);
  /* Half duplex (read/write) transfer failure */
  static constexpr ReturnValue_t HALF_DUPLEX_TRANSFER_FAILED =
-      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 2);
+      HasReturnvaluesIF::makeReturnCode(spiRetvalId, 2);

  SpiComIF(object_id_t objectId, 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* getCsMutex();
+  MutexIF* getMutex(MutexIF::TimeoutType* timeoutType = nullptr, uint32_t* timeoutMs = nullptr);

  /**
   * Perform a regular send operation using Linux iotcl. This is public so it can be used
@ -70,13 +70,10 @@ class SpiComIF : public DeviceCommunicationIF, public SystemObject {
  };

  GpioIF* gpioComIF = nullptr;
-  std::string dev = "";
-  /**
-   * Protects the chip select operations. Lock when GPIO is pulled low, unlock after it was
-   * pulled high
-   */
-  MutexIF* csMutex = nullptr;

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

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

 #include "../../common/gpio/gpioDefinitions.h"
@ -22,8 +20,6 @@
 */
 class SpiCookie : public CookieIF {
 public:
-  static constexpr dur_millis_t DEFAULT_MUTEX_TIMEOUT = 20;
-
  /**
   * Each SPI device will have a corresponding cookie. The cookie is used by the communication
   * interface and contains device specific information like the largest expected size to be
@ -143,43 +139,9 @@ class SpiCookie : public CookieIF {
   */
  void activateCsDeselect(bool deselectCs, uint16_t delayUsecs);

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

 private:
-  address_t spiAddress;
-  gpioId_t chipSelectPin;
-  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
@ -192,8 +154,27 @@ class SpiCookie : public CookieIF {
   * @param args
   */
  SpiCookie(spi::SpiComIfModes comIfMode, address_t spiAddress, gpioId_t chipSelect,
-            const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed,
+            std::string spiDev, const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed,
            spi::send_callback_function_t callback, void* args);
+
+  address_t spiAddress;
+  gpioId_t chipSelectPin;
+  std::string spiDevice;
+
+  spi::SpiComIfModes comIfMode;
+
+  // Required for regular mode
+  const size_t maxSize;
+  spi::SpiModes spiMode;
+  uint32_t spiSpeed;
+  bool halfDuplex = false;
+
+  // Required for callback mode
+  spi::send_callback_function_t sendCallback = nullptr;
+  void* callbackArgs = nullptr;
+
+  struct spi_ioc_transfer spiTransferStruct = {};
+  UncommonParameters uncommonParameters;
 };

 #endif /* LINUX_SPI_SPICOOKIE_H_ */
--- a/scripts/apply-clang-format.sh
+++ b/scripts/apply-clang-format.sh
@ -0,0 +1,8 @@
+#!/bin/bash
+if [[ ! -f README.md ]]; then
+	cd ..
+fi
+
+find ./src -iname *.h -o -iname *.cpp -o -iname *.c | xargs clang-format --style=file -i
+find ./hal -iname *.h -o -iname *.cpp -o -iname *.c | xargs clang-format --style=file -i
+find ./tests -iname *.h -o -iname *.cpp -o -iname *.c | xargs clang-format --style=file -i
--- a/scripts/auto-formatter.sh
+++ b/scripts/auto-formatter.sh
@ -1,22 +0,0 @@
-#!/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/CMakeLists.txt
+++ b/src/fsfw/CMakeLists.txt
@ -1,5 +1,6 @@
 target_sources(${LIB_FSFW_NAME} PRIVATE
    version.cpp
+    versionAutogen.cpp
 )

 # Core
--- a/src/fsfw/FSFWVersion.h.in
+++ b/src/fsfw/FSFWVersion.h.in
@ -1,9 +0,0 @@
-#ifndef FSFW_VERSION_H_
-#define FSFW_VERSION_H_
-
-// Versioning is kept in project CMakeLists.txt file
-#define FSFW_VERSION_MAJOR @FSFW_VERSION@
-#define FSFW_VERSION_MINOR @FSFW_SUBVERSION@
-#define FSFW_VERSION_REVISION @FSFW_REVISION@
-
-#endif /* FSFW_VERSION_H_ */
--- a/src/fsfw/container/FIFOBase.tpp
+++ b/src/fsfw/container/FIFOBase.tpp
@ -5,88 +5,89 @@
 #error Include FIFOBase.h before FIFOBase.tpp!
 #endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

--- a/src/fsfw/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/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
-    DummyPowerSwitcher.cpp
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Fuse.cpp
+		PowerComponent.cpp
+		PowerSensor.cpp
+		PowerSwitcher.cpp
 )
--- a/src/fsfw/power/DummyPowerSwitcher.cpp
+++ b/src/fsfw/power/DummyPowerSwitcher.cpp
@ -1,47 +0,0 @@
-#include "DummyPowerSwitcher.h"
-
-DummyPowerSwitcher::DummyPowerSwitcher(object_id_t objectId, size_t numberOfSwitches,
-                                       size_t numberOfFuses, bool registerGlobally,
-                                       uint32_t switchDelayMs)
-    : SystemObject(objectId, registerGlobally),
-      switcherList(numberOfSwitches),
-      fuseList(numberOfFuses),
-      switchDelayMs(switchDelayMs) {}
-
-void DummyPowerSwitcher::setInitialSwitcherList(std::vector<ReturnValue_t> switcherList) {
-  this->switcherList = switcherList;
-}
-
-void DummyPowerSwitcher::setInitialFusesList(std::vector<ReturnValue_t> fuseList) {
-  this->fuseList = fuseList;
-}
-
-ReturnValue_t DummyPowerSwitcher::sendSwitchCommand(power::Switch_t switchNr, ReturnValue_t onOff) {
-  if (switchNr < switcherList.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
@ -1,38 +0,0 @@
-#ifndef FSFW_SRC_FSFW_POWER_DUMMYPOWERSWITCHER_H_
-#define FSFW_SRC_FSFW_POWER_DUMMYPOWERSWITCHER_H_
-
-#include <cstddef>
-#include <vector>
-
-#include "PowerSwitchIF.h"
-#include "definitions.h"
-#include "fsfw/objectmanager/SystemObject.h"
-
-/**
- * @brief   This component can be used to simulate a power switcher like a
- *          Power Control Distribution Unit (PCDU)
- * @details
- * The dummy switcher will simply cache the commanded fuse and switch states and return them
- * in the according switch getter functions. In that sense, it simulates an ideal PCDU.
- */
-class DummyPowerSwitcher : public SystemObject, public PowerSwitchIF {
- public:
-  DummyPowerSwitcher(object_id_t objectId, size_t numberOfSwitches, size_t numberOfFuses,
-                     bool registerGlobally = true, uint32_t switchDelayMs = 5000);
-
-  void setInitialSwitcherList(std::vector<ReturnValue_t> switcherList);
-  void setInitialFusesList(std::vector<ReturnValue_t> switcherList);
-
-  virtual ReturnValue_t sendSwitchCommand(power::Switch_t switchNr, ReturnValue_t onOff) override;
-  virtual ReturnValue_t sendFuseOnCommand(uint8_t fuseNr) override;
-  virtual ReturnValue_t getSwitchState(power::Switch_t switchNr) const override;
-  virtual ReturnValue_t getFuseState(uint8_t fuseNr) const override;
-  virtual uint32_t getSwitchDelayMs(void) const override;
-
- private:
-  std::vector<ReturnValue_t> switcherList;
-  std::vector<ReturnValue_t> fuseList;
-  uint32_t switchDelayMs = 5000;
-};
-
-#endif /* FSFW_SRC_FSFW_POWER_DUMMYPOWERSWITCHER_H_ */
--- a/src/fsfw/power/Fuse.h
+++ b/src/fsfw/power/Fuse.h
@ -34,14 +34,14 @@ class Fuse : public SystemObject,
  };

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

  typedef std::list<PowerComponentIF *> DeviceList;
  Fuse(object_id_t fuseObjectId, uint8_t fuseId, sid_t variableSet, VariableIds ids,
--- a/src/fsfw/power/PowerSensor.cpp
+++ b/src/fsfw/power/PowerSensor.cpp
@ -15,8 +15,7 @@ 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(3, MessageQueueMessage::MAX_MESSAGE_SIZE);
+  commandQueue = QueueFactory::instance()->createMessageQueue();
 }

 PowerSensor::~PowerSensor() { QueueFactory::instance()->deleteMessageQueue(commandQueue); }
--- a/src/fsfw/power/PowerSwitchIF.h
+++ b/src/fsfw/power/PowerSwitchIF.h
@ -3,7 +3,6 @@

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

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

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

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

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

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

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

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

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

+  static const uint8_t NO_SWITCH = 0xFF;
  enum SwitchReturn_t { ONE_SWITCH = 1, TWO_SWITCHES = 2 };
  ReturnValue_t getStateOfSwitches();
  void commandSwitches(ReturnValue_t onOff);
--- a/src/fsfw/power/definitions.h
+++ b/src/fsfw/power/definitions.h
@ -1,13 +0,0 @@
-#ifndef FSFW_SRC_FSFW_POWER_DEFINITIONS_H_
-#define FSFW_SRC_FSFW_POWER_DEFINITIONS_H_
-
-#include <cstdint>
-
-namespace power {
-
-using Switch_t = uint8_t;
-static constexpr Switch_t NO_SWITCH = 0xFF;
-
-}  // namespace power
-
-#endif /* FSFW_SRC_FSFW_POWER_DEFINITIONS_H_ */
--- a/src/fsfw/pus/CService201HealthCommanding.cpp
+++ b/src/fsfw/pus/CService201HealthCommanding.cpp
@ -97,8 +97,7 @@ ReturnValue_t CService201HealthCommanding::handleReply(const CommandMessage *rep
 }

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

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

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

--- a/src/fsfw/version.cpp
+++ b/src/fsfw/version.cpp
@ -2,8 +2,6 @@

 #include <cstdio>

-#include "fsfw/FSFWVersion.h"
-
 #ifdef major
 #undef major
 #endif
@ -13,11 +11,28 @@
 #endif

 const fsfw::Version fsfw::FSFW_VERSION = {FSFW_VERSION_MAJOR, FSFW_VERSION_MINOR,
-                                          FSFW_VERSION_REVISION};
+                                          FSFW_VERSION_REVISION, FSFW_VCS_INFO};

-fsfw::Version::Version(uint32_t major, uint32_t minor, uint32_t revision)
-    : major(major), minor(minor), revision(revision) {}
+fsfw::Version::Version(int major, int minor, int revision, const char* addInfo)
+    : major(major), minor(minor), revision(revision), addInfo(addInfo) {}

 void fsfw::Version::getVersion(char* str, size_t maxLen) const {
-  snprintf(str, maxLen, "%d.%d.%d", major, minor, revision);
+  size_t len = snprintf(str, maxLen, "%d.%d.%d", major, minor, revision);
+  if (addInfo != nullptr) {
+    snprintf(str + len, maxLen - len, "-%s", addInfo);
+  }
 }
+
+namespace fsfw {
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+std::ostream& operator<<(std::ostream& os, const Version& v) {
+  os << v.major << "." << v.minor << "." << v.revision;
+  if (v.addInfo != nullptr) {
+    os << "-" << v.addInfo;
+  }
+  return os;
+}
+#endif
+
+}  // namespace fsfw
--- a/src/fsfw/version.h
+++ b/src/fsfw/version.h
@ -12,10 +12,13 @@ namespace fsfw {

 class Version {
 public:
-  Version(uint32_t major, uint32_t minor, uint32_t revision);
-  uint32_t major = 0;
-  uint32_t minor = 0;
-  uint32_t revision = 0;
+  Version(int major, int minor, int revision, const char* addInfo = nullptr);
+  int major = -1;
+  int minor = -1;
+  int revision = -1;
+
+  // Additional information, e.g. a git SHA hash
+  const char* addInfo = nullptr;

  friend bool operator==(const Version& v1, const Version& v2) {
    return (v1.major == v2.major and v1.minor == v2.minor and v1.revision == v2.revision);
@ -43,10 +46,7 @@ class Version {
   * @param v
   * @return
   */
-  friend std::ostream& operator<<(std::ostream& os, const Version& v) {
-    os << v.major << "." << v.minor << "." << v.revision;
-    return os;
-  }
+  friend std::ostream& operator<<(std::ostream& os, const Version& v);
 #endif

  /**
@ -57,6 +57,11 @@ class Version {
  void getVersion(char* str, size_t maxLen) const;
 };

+extern const int FSFW_VERSION_MAJOR;
+extern const int FSFW_VERSION_MINOR;
+extern const int FSFW_VERSION_REVISION;
+extern const char FSFW_VCS_INFO[];
+
 extern const fsfw::Version FSFW_VERSION;

 }  // namespace fsfw
--- a/src/fsfw/versionAutogen.cpp
+++ b/src/fsfw/versionAutogen.cpp
@ -0,0 +1,10 @@
+#include "version.h"
+
+namespace fsfw {
+
+const int FSFW_VERSION_MAJOR = 4;
+const int FSFW_VERSION_MINOR = 0;
+const int FSFW_VERSION_REVISION = 0;
+const char FSFW_VCS_INFO[] = "292-g42ac1af4";
+
+};
--- a/tests/src/fsfw_tests/unit/CMakeLists.txt
+++ b/tests/src/fsfw_tests/unit/CMakeLists.txt
@ -11,10 +11,7 @@ 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
@ -1,3 +0,0 @@
-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
@ -1,77 +0,0 @@
-#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
@ -1,52 +0,0 @@
-#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
@ -1,3 +0,0 @@
-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
@ -1,71 +0,0 @@
-#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,9 +21,8 @@ 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
 };
 }

--- a/tests/src/fsfw_tests/unit/version.cpp
+++ b/tests/src/fsfw_tests/unit/version.cpp
@ -14,8 +14,8 @@ TEST_CASE("Version API Tests", "[TestVersionAPI]") {
  REQUIRE(fsfw::Version(255, 0, 0) >= fsfw::FSFW_VERSION);
  REQUIRE(fsfw::Version(0, 0, 0) < fsfw::FSFW_VERSION);
  REQUIRE(fsfw::Version(0, 0, 0) <= fsfw::FSFW_VERSION);
-  fsfw::Version v1 = fsfw::Version(1, 1, 1);
-  fsfw::Version v2 = fsfw::Version(1, 1, 1);
+  auto v1 = fsfw::Version(1, 1, 1);
+  auto v2 = fsfw::Version(1, 1, 1);
  REQUIRE(v1 == v2);
  REQUIRE(not(v1 < v2));
  REQUIRE(not(v1 > v2));
Author	SHA1	Message	Date
Robin Mueller	7b767b238a	some more fixes	2022-05-10 16:58:34 +02:00
Robin Mueller	42ac1af4b2	update changelog	2022-05-10 16:55:22 +02:00
Robin Mueller	1e5ba0212e	possible fix for cicd	2022-05-10 16:53:33 +02:00
Robin Mueller	ac95e8f250	cmakelists update	2022-05-10 16:53:15 +02:00
Robin Mueller	1e569128c6	update auto-gen file	2022-05-10 16:48:23 +02:00
Robin Mueller	f35c4049c0	removed faulty include	2022-05-10 16:47:51 +02:00
Robin Mueller	5d946f5640	commit seems to change	2022-05-10 16:46:03 +02:00
Robin Mueller	f57bd290d9	this compiles	2022-05-10 16:43:16 +02:00
Robin Mueller	aa4e2d7209	remove custom command which reset .h.in file	2022-05-10 16:13:32 +02:00
Robin Mueller	58cb96ece0	update changelog	2022-05-10 12:28:40 +02:00
Robin Mueller	88cc8c46a1	this appears to do the trick	2022-05-10 12:26:21 +02:00
Robin Mueller	377c3325d2	update cmake-modules file	2022-05-10 12:16:38 +02:00
Robin Mueller	efb3d982f3	added missing prefix	2022-05-10 11:52:40 +02:00
Robin Mueller	dd986fefd3	experimenting with PRE_BUILD command	2022-05-10 11:51:25 +02:00
Robin Müller	b38329aa0e	Merge branch 'development' into mueller/extend-version-class	2022-05-10 11:19:48 +02:00
Robin Müller	be6a492022	Merge branch 'development' into mueller/extend-version-class	2022-05-09 22:34:09 +02:00
Robin Mueller	736f8d0238	order fix	2022-05-09 15:50:49 +02:00
Robin Mueller	f1acf8e18b	Merge remote-tracking branch 'upstream/development' into mueller/extend-version-class	2022-05-09 15:48:04 +02:00
Robin Mueller	398d04dc50	fixed tests	2022-05-09 11:15:18 +02:00
Robin Mueller	80a5ed3c5b	added back fsfw namespace	2022-05-09 11:06:45 +02:00
Robin Mueller	5d5a355110	Merge remote-tracking branch 'upstream/development' into mueller/extend-version-class	2022-05-09 11:04:15 +02:00
Robin Müller	b62c19a364	Merge branch 'development' into mueller/extend-version-class	2022-05-02 14:48:23 +02:00
Robin Mueller	8e4ad10627	Merge remote-tracking branch 'upstream/development' into mueller/extend-version-class	2022-04-27 08:46:18 +02:00
Robin Mueller	d62ee6a611	Merge remote-tracking branch 'upstream/development' into mueller/extend-version-class	2022-04-25 15:23:46 +02:00
Robin Mueller	4032228005	Merge remote-tracking branch 'upstream/development' into mueller/extend-version-class	2022-04-25 15:15:54 +02:00
Robin Mueller	18f9958332	add git CST and sha info to version ctor	2022-04-22 15:39:44 +02:00
Robin Mueller	68231db9a1	changelog typo	2022-04-22 15:37:14 +02:00
Robin Mueller	85e849ca00	small remaining fix	2022-04-22 15:10:08 +02:00
Robin Mueller	617d41c7d5	maybe this fixed CI/CD issues	2022-04-22 15:08:16 +02:00
Robin Mueller	cccdced74d	unique helper file name	2022-04-22 15:00:04 +02:00
Robin Mueller	750369b0a6	small addition and possible fix	2022-04-22 14:55:17 +02:00
Robin Mueller	539e01deee	minor form change	2022-04-22 14:53:12 +02:00
Robin Mueller	4079edc80e	update changelog	2022-04-22 14:52:55 +02:00
Robin Mueller	a569990ca2	fix tests	2022-04-22 14:50:50 +02:00
Robin Mueller	9c7eba4431	git version handler more robust now	2022-04-22 14:47:28 +02:00
Robin Mueller	513ae9dc10	prefixed git info variable	2022-04-22 14:38:32 +02:00
Robin Mueller	effecd4662	include cmake-modules manually instead - Instead of using FetchContent - Separate folder for easier update and for distintion - LICENSE file included	2022-04-22 14:33:34 +02:00
Robin Mueller	b951cb736a	add fsfw specific cmake message prefix	2022-04-22 14:08:26 +02:00
Robin Mueller	7e1aed6ad9	apply afmt	2022-04-22 14:04:30 +02:00
Robin Mueller	07155e2546	extend version handling with git describe	2022-04-22 14:04:18 +02:00
Robin Mueller	8c6c8ad3c0	exntend version class to allow add info	2022-04-22 11:58:44 +02:00