compile DleParser

Reviewed-on: #99
Reviewed-by: Robin Müller <muellerr@irs.uni-stuttgart.de>

CHANGELOG.md

@@ -12,6 +12,9 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Changes
 
+- Bump C++ required version to C++17. Every project which uses the FSFW and every modern
+  compiler supports it
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/622
 - 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
@@ -22,11 +25,8 @@ 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
-  - Place `Version` class outside of `fsfw` namespace. It is generic
   - 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
@@ -42,12 +42,39 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
   creation call. It allows passing context information and an arbitrary user argument into
   the message queue. Also streamlined and simplified `MessageQueue` implementation for all OSALs
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/583
-- Clock: 
-  - `timeval` to `TimeOfDay_t`
-  - Added Mutex for gmtime calls: (compare http://www.opengate.at/blog/2020/01/timeless/)
-  - Moved the statics used by Clock in ClockCommon.cpp to this file
-  - Better check for leap seconds
-  - Added Unittests for Clock (only getter)
+
+### HAL
+
+- HAL Linux Uart: Baudrate and bits per word are enums now, avoiding misconfigurations
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/585
+- HAL Linux SPI: Set the Clock Default State when setting new SPI speed
+  and mode
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/573
+- GPIO HAL: `Direction`, `GpioOperation` and `Levels` are enum classes now, which prevents
+  name clashes with Windows defines.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/572
+- HAL Linux Uart: Baudrate and bits per word are enums now, avoiding misconfigurations
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/585
+
+### Time
+
+PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/584 and
+https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593
+
+- `timeval` to `TimeOfDay_t`
+- Added Mutex for gmtime calls: (compare http://www.opengate.at/blog/2020/01/timeless/)
+- Moved the statics used by Clock in ClockCommon.cpp to this file
+- Better check for leap seconds
+- Added Unittests for Clock (only getter)
+
+### Power 
+
+- `PowerSwitchIF`: Remove `const` specifier from `sendSwitchCommand` and `sendFuseOnCommand` and
+  also specify a `ReturnValue_t` return type
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
+- Extend `PowerSwitcher` module to optionally check current state when calling `turnOn` or
+  `turnOff`. Tis can be helpful to avoid commanding switches which do not need commanding
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
 
 ## Removed
 
@@ -57,15 +84,55 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Additions
 
-- Linux HAL: Add wiretapping option for I2C. Enabled with `FSFW_HAL_I2C_WIRETAPPING` defined to 1
+- 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
 - Dedicated Version class and constant `fsfw::FSFW_VERSION` containing version information
   inside `fsfw/version.h`
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/559
+- Added generic PUS TC Scheduler Service 11. It depends on the new added Emebeded Template Library
+  (ETL) dependency.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/594
 - Added ETL dependency and improved library dependency management
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/592
+- Add a `DummyPowerSwitcher` module which can be useful for test setups when no PCDU is available
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
+- New typedef for switcher type
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
+- `Subsystem`: New API to add table and sequence entries
+
+## HAL
+
+- SPI: Cache the SPI device in the communication interface. Architecturally, this makes a
+  lot more sense because each ComIF should be responsible for one SPI bus.
+- SPI: Move the empty transfer to update the line polarity to separate function. This means
+  it is not automatically called when calling the setter function for SPI speed and mode.
+  The user should call this function after locking the CS mutex if multiple SPI devices with
+  differing speeds and modes are attached to one bus.
+- SPI: Getter functions for SPI speed and mode.
+- I2C: Add wiretapping option for I2C. Enabled with `FSFW_HAL_I2C_WIRETAPPING` defined to 1.
 
 ## Fixed
 
+- TCP TMTC Server: `MutexGuard` was not created properly in
+  `TcpTmTcServer::handleTmSending(socket_t connSocket, bool& tmSent)` call.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/618
+- Fix infinite recursion in `prepareHealthSetReply` of PUS Health Service 201.
+  Is not currently used right now but might be used in the future
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/617
+- Move some CMake directives further up top so they are not ignored
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/621
 - Small bugfix in STM32 HAL for SPI
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/599
 - HAL GPIO: Improved error checking in `LinuxLibgpioIF::configureGpios(...)`. If a GPIO

CMakeLists.txt

@@ -1,42 +1,113 @@
 cmake_minimum_required(VERSION 3.13)
-project(${LIB_FSFW_NAME})
+
+set(MSG_PREFIX "fsfw |")
+
+# Add the cmake folder so the FindSphinx module is found
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+list(APPEND CMAKE_MODULE_PATH
+     "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake-modules/bilke")
+list(APPEND CMAKE_MODULE_PATH
+     "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake-modules/rpavlik")
+
+# ##############################################################################
+# Version file handling  #
+# ##############################################################################
 
 set(FSFW_VERSION_IF_GIT_FAILS 4)
 set(FSFW_SUBVERSION_IF_GIT_FAILS 0)
 set(FSFW_REVISION_IF_GIT_FAILS 0)
 
-# Add the cmake folder so the FindSphinx module is found
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" )
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake-modules")
-set(MSG_PREFIX "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_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-preview4 CACHE STRING
-    "Catch2 library exact version requirement"
-)
-
-set(FSFW_ETL_LIB_NAME etl)
-
-option(FSFW_GENERATE_SECTIONS
-    "Generate function and data sections. Required to remove unused code" ON
-)
-if(FSFW_GENERATE_SECTIONS)
-    option(FSFW_REMOVE_UNUSED_CODE "Remove unused code" ON)
+set(FSFW_GIT_VER_HANDLING_OK FALSE)
+# Version handling
+if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
+  message(STATUS "${MSG_PREFIX} Determining version information with git")
+  include(FsfwHelpers)
+  determine_version_with_git("--exclude" "docker_*")
+  if(GIT_INFO)
+    set(FSFW_GIT_INFO
+        ${GIT_INFO}
+        CACHE STRING "Version information retrieved with git describe")
+    list(GET FSFW_GIT_INFO 1 FSFW_VERSION)
+    list(GET FSFW_GIT_INFO 2 FSFW_SUBVERSION)
+    list(GET FSFW_GIT_INFO 3 FSFW_REVISION)
+    list(GET FSFW_GIT_INFO 4 FSFW_VCS_INFO)
+    if(NOT FSFW_VERSION)
+      set(FSFW_VERSION ${FSFW_VERSION_IF_GIT_FAILS})
+    endif()
+    if(NOT FSFW_SUBVERSION)
+      set(FSFW_SUBVERSION ${FSFW_SUBVERSION_IF_GIT_FAILS})
+    endif()
+    if(NOT FSFW_REVISION)
+      set(FSFW_REVISION ${FSFW_REVISION_IF_GIT_FAILS})
+    endif()
+    set(FSFW_GIT_VER_HANDLING_OK TRUE)
+  else()
+    set(FSFW_GIT_VER_HANDLING_OK FALSE)
+  endif()
+endif()
+if(NOT FSFW_GIT_VER_HANDLING_OK)
+  set(FSFW_VERSION ${FSFW_VERSION_IF_GIT_FAILS})
+  set(FSFW_SUBVERSION ${FSFW_SUBVERSION_IF_GIT_FAILS})
+  set(FSFW_REVISION ${FSFW_REVISION_IF_GIT_FAILS})
 endif()
 
-option(FSFW_BUILD_UNITTESTS "Build unittest binary in addition to static library" OFF)
+set(LIB_FSFW_NAME fsfw)
+project(${LIB_FSFW_NAME}
+        VERSION ${FSFW_VERSION}.${FSFW_SUBVERSION}.${FSFW_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_NAME etl)
+set(FSFW_ETL_LIB_MAJOR_VERSION
+    20
+    CACHE STRING "ETL library major version requirement")
+set(FSFW_ETL_LIB_VERSION
+    ${FSFW_ETL_LIB_MAJOR_VERSION}.27.3
+    CACHE STRING "ETL library exact version requirement")
+set(FSFW_ETL_LINK_TARGET etl::etl)
+
+set(FSFW_CATCH2_LIB_MAJOR_VERSION
+    3
+    CACHE STRING "Catch2 library major version requirement")
+set(FSFW_CATCH2_LIB_VERSION
+    v${FSFW_CATCH2_LIB_MAJOR_VERSION}.0.0-preview5
+    CACHE STRING "Catch2 library exact version requirement")
+
+# Keep this off by default for now. See PR:
+# https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/616 for information which
+# keeping this on by default is problematic
+option(
+  FSFW_ENABLE_IPO
+  "Enable interprocedural optimization or link-time optimization if available"
+  OFF)
+if(FSFW_ENABLE_IPO)
+  include(CheckIPOSupported)
+  check_ipo_supported(RESULT IPO_SUPPORTED OUTPUT IPO_ERROR)
+  if(NOT IPO_SUPPORTED)
+    message(STATUS "FSFW | IPO/LTO not supported: ${IPO_ERROR}")
+  endif()
+endif()
+
+option(FSFW_GENERATE_SECTIONS
+       "Generate function and data sections. Required to remove unused code" ON)
+if(FSFW_GENERATE_SECTIONS)
+  option(FSFW_REMOVE_UNUSED_CODE "Remove unused code" ON)
+endif()
+
+option(FSFW_BUILD_UNITTESTS
+       "Build unittest binary in addition to static library" OFF)
 option(FSFW_BUILD_DOCS "Build documentation with Sphinx and Doxygen" OFF)
 if(FSFW_BUILD_UNITTESTS)
-    option(FSFW_TESTS_GEN_COV "Generate coverage data for unittests" ON)
+  option(FSFW_TESTS_GEN_COV "Generate coverage data for unittests" ON)
 endif()
 
 option(FSFW_WARNING_SHADOW_LOCAL_GCC "Enable -Wshadow=local warning in GCC" ON)
@@ -57,376 +128,336 @@ option(FSFW_ADD_TMSTORAGE "Compile with tm storage components" OFF)
 # Contrib sources
 option(FSFW_ADD_SGP4_PROPAGATOR "Add SGP4 propagator code" OFF)
 
-set(LIB_FSFW_NAME fsfw)
 set(FSFW_TEST_TGT fsfw-tests)
 set(FSFW_DUMMY_TGT fsfw-dummy)
 
 add_library(${LIB_FSFW_NAME})
 
-set(FSFW_GIT_VER_HANDLING_OK FALSE)
-# Version handling
-if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
-    message(STATUS "${MSG_PREFIX} Determining version information with git")
-    include(FsfwHelpers)
-    determine_version_with_git("--exclude" "docker_*")
-    if(GIT_INFO)
-        set(FSFW_GIT_INFO ${GIT_INFO} CACHE STRING "Version information retrieved with git describe")
-        list(GET FSFW_GIT_INFO 1 FSFW_VERSION)
-        list(GET FSFW_GIT_INFO 2 FSFW_SUBVERSION)
-        list(GET FSFW_GIT_INFO 3 FSFW_REVISION)
-        list(GET FSFW_GIT_INFO 4 FSFW_VERSION_CST_GIT_SHA1)
-        if(NOT FSFW_VERSION)
-            set(FSFW_VERSION ${FSFW_VERSION_IF_GIT_FAILS})
-        endif()
-        if(NOT FSFW_SUBVERSION)
-            set(FSFW_SUBVERSION ${FSFW_SUBVERSION_IF_GIT_FAILS})
-        endif()
-        if(NOT FSFW_REVISION)
-            set(FSFW_REVISION ${FSFW_REVISION_IF_GIT_FAILS})
-        endif()
-        set(FSFW_GIT_VER_HANDLING_OK TRUE)
-   else()
-        set(FSFW_GIT_VER_HANDLING_OK FALSE)
-   endif()
-endif()
-if(NOT FSFW_GIT_VER_HANDLING_OK)
-    set(FSFW_VERSION ${FSFW_VERSION_IF_GIT_FAILS})
-    set(FSFW_SUBVERSION ${FSFW_SUBVERSION_IF_GIT_FAILS})
-    set(FSFW_REVISION ${FSFW_REVISION_IF_GIT_FAILS})
+if(IPO_SUPPORTED AND FSFW_ENABLE_IPO)
+  set_property(TARGET ${LIB_FSFW_NAME} PROPERTY INTERPROCEDURAL_OPTIMIZATION
+                                                TRUE)
 endif()
 
 if(FSFW_BUILD_UNITTESTS)
-    message(STATUS "${MSG_PREFIX} Building the FSFW unittests in addition to the static library")
-    # Check whether the user has already installed Catch2 first
-    find_package(Catch2 ${FSFW_CATCH2_LIB_MAJOR_VERSION} CONFIG QUIET)
-    # Not installed, so use FetchContent to download and provide Catch2
-    if(NOT Catch2_FOUND)
-        message(STATUS "${MSG_PREFIX} Catch2 installation not found. Downloading Catch2 library with FetchContent")
-        include(FetchContent)
+  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})
 
-        FetchContent_MakeAvailable(Catch2)
-        #fixes regression -preview4, to be confirmed in later releases
-        set_target_properties(Catch2 PROPERTIES DEBUG_POSTFIX "")
-    endif()
+    list(APPEND FSFW_FETCH_CONTENT_TARGETS Catch2)
+  endif()
 
-    set(FSFW_CONFIG_PATH tests/src/fsfw_tests/unit/testcfg)
-    configure_file(tests/src/fsfw_tests/unit/testcfg/FSFWConfig.h.in FSFWConfig.h)
-    configure_file(tests/src/fsfw_tests/unit/testcfg/TestsConfig.h.in tests/TestsConfig.h)
+  set(FSFW_CONFIG_PATH tests/src/fsfw_tests/unit/testcfg)
+  configure_file(tests/src/fsfw_tests/unit/testcfg/FSFWConfig.h.in FSFWConfig.h)
+  configure_file(tests/src/fsfw_tests/unit/testcfg/TestsConfig.h.in
+                 tests/TestsConfig.h)
 
-    project(${FSFW_TEST_TGT} CXX C)
-    add_executable(${FSFW_TEST_TGT})
+  project(${FSFW_TEST_TGT} CXX C)
+  add_executable(${FSFW_TEST_TGT})
+  if(IPO_SUPPORTED AND FSFW_ENABLE_IPO)
+    set_property(TARGET ${FSFW_TEST_TGT} PROPERTY INTERPROCEDURAL_OPTIMIZATION
+                                                  TRUE)
+  endif()
 
-    if(FSFW_TESTS_GEN_COV)
-        message(STATUS "${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()
+  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 with version ${FSFW_ETL_LIB_MAJOR_VERSION}")
+message(STATUS "${MSG_PREFIX} Finding and/or providing etl library with version ${FSFW_ETL_LIB_MAJOR_VERSION}")
 
 # Check whether the user has already installed ETL first
-# find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} CONFIG QUIET)
+find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} CONFIG QUIET)
 # Not installed, so use FetchContent to download and provide etl
-# if(NOT ${FSFW_ETL_LIB_NAME}_FOUND)
-message(STATUS
-    "No etl installation was found with find_package. Installing and providing "
-    "etl with FetchContent"
-)
-include(FetchContent)
+if(NOT ${FSFW_ETL_LIB_NAME}_FOUND)
+  message(
+    STATUS
+      "${MSG_PREFIX} No ETL installation was found with find_package. Installing and providing "
+      "etl with FindPackage")
+  include(FetchContent)
 
-FetchContent_Declare(
+  FetchContent_Declare(
     ${FSFW_ETL_LIB_NAME}
     GIT_REPOSITORY https://github.com/ETLCPP/etl
-    GIT_TAG        ${FSFW_ETL_LIB_VERSION}
-)
+    GIT_TAG ${FSFW_ETL_LIB_VERSION})
 
-FetchContent_MakeAvailable(${FSFW_ETL_LIB_NAME})
-# endif()
+  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()
+endif()
 
 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}
-)
-
-if(NOT CMAKE_CXX_STANDARD)
-    set(CMAKE_CXX_STANDARD 11)
-    set(CMAKE_CXX_STANDARD_REQUIRED True)
-elseif(${CMAKE_CXX_STANDARD} LESS 11)
-    message(FATAL_ERROR "${MSG_PREFIX} Compiling the FSFW requires a minimum of C++11 support")
-endif()
+target_include_directories(${LIB_FSFW_NAME} PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+target_include_directories(${LIB_FSFW_NAME}
+                           INTERFACE ${CMAKE_CURRENT_BINARY_DIR})
 
 # Backwards comptability
 if(OS_FSFW AND NOT FSFW_OSAL)
-    message(WARNING "${MSG_PREFIX} Please pass the FSFW OSAL as FSFW_OSAL instead of OS_FSFW")
-    set(FSFW_OSAL OS_FSFW)
+  message(
+    WARNING
+      "${MSG_PREFIX} Please pass the FSFW OSAL as FSFW_OSAL instead of OS_FSFW")
+  set(FSFW_OSAL OS_FSFW)
 endif()
 
 if(NOT FSFW_OSAL)
-	message(STATUS "${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()
-
+  message(STATUS "No OS for FSFW via FSFW_OSAL set. Assuming host OS")
+  # Assume host OS and autodetermine from OS_FSFW
+  if(UNIX)
+    set(FSFW_OSAL
+        "linux"
+        CACHE STRING "OS abstraction layer used in the FSFW")
+  elseif(WIN32)
+    set(FSFW_OSAL
+        "host"
+        CACHE STRING "OS abstraction layer used in the FSFW")
+  endif()
 endif()
 
 set(FSFW_OSAL_DEFINITION FSFW_OSAL_HOST)
 
 if(FSFW_OSAL MATCHES host)
-    set(FSFW_OS_NAME "Host")
-    set(FSFW_OSAL_HOST ON)
+  set(FSFW_OS_NAME "Host")
+  set(FSFW_OSAL_HOST ON)
 elseif(FSFW_OSAL MATCHES linux)
-    set(FSFW_OS_NAME "Linux")
-    set(FSFW_OSAL_LINUX ON)
+  set(FSFW_OS_NAME "Linux")
+  set(FSFW_OSAL_LINUX ON)
 elseif(FSFW_OSAL MATCHES freertos)
-    set(FSFW_OS_NAME "FreeRTOS")
-    set(FSFW_OSAL_FREERTOS ON)
-    target_link_libraries(${LIB_FSFW_NAME} PRIVATE
-        ${LIB_OS_NAME}
-    )
+  set(FSFW_OS_NAME "FreeRTOS")
+  set(FSFW_OSAL_FREERTOS ON)
+  target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${LIB_OS_NAME})
 elseif(FSFW_OSAL STREQUAL rtems)
-    set(FSFW_OS_NAME "RTEMS")
-    set(FSFW_OSAL_RTEMS ON)
+  set(FSFW_OS_NAME "RTEMS")
+  set(FSFW_OSAL_RTEMS ON)
 else()
-    message(WARNING
-        "${MSG_PREFIX} Invalid operating system for FSFW specified! Setting to host.."
-    )
-    set(FSFW_OS_NAME "Host")
-    set(OS_FSFW "host")
+  message(
+    WARNING
+      "${MSG_PREFIX} Invalid operating system for FSFW specified! Setting to host.."
+  )
+  set(FSFW_OS_NAME "Host")
+  set(OS_FSFW "host")
 endif()
 
 configure_file(src/fsfw/FSFW.h.in fsfw/FSFW.h)
 configure_file(src/fsfw/FSFWVersion.h.in fsfw/FSFWVersion.h)
 
-message(STATUS "${MSG_PREFIX} Compiling FSFW for the ${FSFW_OS_NAME} operating system")
+message(
+  STATUS "${MSG_PREFIX} Compiling FSFW for the ${FSFW_OS_NAME} operating system"
+)
 
 add_subdirectory(src)
 add_subdirectory(tests)
 if(FSFW_ADD_HAL)
-    add_subdirectory(hal)
+  add_subdirectory(hal)
 endif()
 add_subdirectory(contrib)
 if(FSFW_BUILD_DOCS)
-    add_subdirectory(docs)
+  add_subdirectory(docs)
 endif()
 
 if(FSFW_BUILD_UNITTESTS)
-    if(FSFW_TESTS_GEN_COV)
-        if(CMAKE_COMPILER_IS_GNUCXX)
-            include(CodeCoverage)
+  if(FSFW_TESTS_GEN_COV)
+    if(CMAKE_COMPILER_IS_GNUCXX)
+      include(CodeCoverage)
 
-            # Remove quotes.
-            separate_arguments(COVERAGE_COMPILER_FLAGS
-                NATIVE_COMMAND "${COVERAGE_COMPILER_FLAGS}"
-            )
+      # Remove quotes.
+      separate_arguments(COVERAGE_COMPILER_FLAGS NATIVE_COMMAND
+                         "${COVERAGE_COMPILER_FLAGS}")
 
-            # Add compile options manually, we don't want coverage for Catch2
-            target_compile_options(${FSFW_TEST_TGT} PRIVATE
-                "${COVERAGE_COMPILER_FLAGS}"
-            )
-            target_compile_options(${LIB_FSFW_NAME} PRIVATE
-                "${COVERAGE_COMPILER_FLAGS}"
-            )
+      # Add compile options manually, we don't want coverage for Catch2
+      target_compile_options(${FSFW_TEST_TGT}
+                             PRIVATE "${COVERAGE_COMPILER_FLAGS}")
+      target_compile_options(${LIB_FSFW_NAME}
+                             PRIVATE "${COVERAGE_COMPILER_FLAGS}")
 
-            # Exclude directories here
-            if(WIN32)
-                set(GCOVR_ADDITIONAL_ARGS
-                    "--exclude-throw-branches"
-                    "--exclude-unreachable-branches"
-                )
-                set(COVERAGE_EXCLUDES
-                    "/c/msys64/mingw64/*" "*/fsfw_hal/*"
-                )
-            elseif(UNIX)
-                set(COVERAGE_EXCLUDES
-                    "/usr/include/*" "/usr/bin/*" "Catch2/*"
-                    "/usr/local/include/*" "*/fsfw_tests/*"
-                    "*/catch2-src/*" "*/fsfw_hal/*"
-                )
-            endif()
+      # Exclude directories here
+      if(WIN32)
+        set(GCOVR_ADDITIONAL_ARGS "--exclude-throw-branches"
+                                  "--exclude-unreachable-branches")
+        set(COVERAGE_EXCLUDES "/c/msys64/mingw64/*" "*/fsfw_hal/*")
+      elseif(UNIX)
+        set(COVERAGE_EXCLUDES
+            "/usr/include/*"
+            "/usr/bin/*"
+            "Catch2/*"
+            "/usr/local/include/*"
+            "*/fsfw_tests/*"
+            "*/catch2-src/*"
+            "*/fsfw_hal/*")
+      endif()
 
-            target_link_options(${FSFW_TEST_TGT} PRIVATE
-                -fprofile-arcs
-                -ftest-coverage
-            )
-            target_link_options(${LIB_FSFW_NAME} PRIVATE
-                -fprofile-arcs
-                -ftest-coverage
-            )
-            # Need to specify this as an interface, otherwise there will the compile issues
-            target_link_options(${LIB_FSFW_NAME} INTERFACE
-                -fprofile-arcs
-                -ftest-coverage
-            )
+      target_link_options(${FSFW_TEST_TGT} PRIVATE -fprofile-arcs
+                          -ftest-coverage)
+      target_link_options(${LIB_FSFW_NAME} PRIVATE -fprofile-arcs
+                          -ftest-coverage)
+      # Need to specify this as an interface, otherwise there will the compile
+      # issues
+      target_link_options(${LIB_FSFW_NAME} INTERFACE -fprofile-arcs
+                          -ftest-coverage)
 
-            if(WIN32)
-                setup_target_for_coverage_gcovr_html(
-                    NAME ${FSFW_TEST_TGT}_coverage
-                    EXECUTABLE ${FSFW_TEST_TGT}
-                    DEPENDENCIES ${FSFW_TEST_TGT}
-                )
-            else()
-                setup_target_for_coverage_lcov(
-                    NAME ${FSFW_TEST_TGT}_coverage
-                    EXECUTABLE ${FSFW_TEST_TGT}
-                    DEPENDENCIES ${FSFW_TEST_TGT}
-                )
-            endif()
-        endif()
+      if(WIN32)
+        setup_target_for_coverage_gcovr_html(
+          NAME ${FSFW_TEST_TGT}_coverage EXECUTABLE ${FSFW_TEST_TGT}
+          DEPENDENCIES ${FSFW_TEST_TGT})
+      else()
+        setup_target_for_coverage_lcov(
+          NAME ${FSFW_TEST_TGT}_coverage EXECUTABLE ${FSFW_TEST_TGT}
+          DEPENDENCIES ${FSFW_TEST_TGT})
+      endif()
     endif()
-    target_link_libraries(${FSFW_TEST_TGT} PRIVATE Catch2::Catch2 ${LIB_FSFW_NAME})
+  endif()
+  target_link_libraries(${FSFW_TEST_TGT} PRIVATE Catch2::Catch2
+                                                 ${LIB_FSFW_NAME})
 endif()
 
-# The project CMakeLists file has to set the FSFW_CONFIG_PATH and add it.
-# If this is not given, we include the default configuration and emit a warning.
+# The project CMakeLists file has to set the FSFW_CONFIG_PATH and add it. If
+# this is not given, we include the default configuration and emit a warning.
 if(NOT FSFW_CONFIG_PATH)
-    set(DEF_CONF_PATH misc/defaultcfg/fsfwconfig)
-    if(NOT FSFW_BUILD_DOCS)
-        message(WARNING "${MSG_PREFIX} Flight Software Framework configuration path not set")
-        message(WARNING "${MSG_PREFIX} Setting default configuration from ${DEF_CONF_PATH} ..")
-    endif()
-    add_subdirectory(${DEF_CONF_PATH})
-    set(FSFW_CONFIG_PATH ${DEF_CONF_PATH})
+  set(DEF_CONF_PATH misc/defaultcfg/fsfwconfig)
+  if(NOT FSFW_BUILD_DOCS)
+    message(
+      WARNING
+        "${MSG_PREFIX} Flight Software Framework configuration path not set")
+    message(
+      WARNING
+        "${MSG_PREFIX} Setting default configuration from ${DEF_CONF_PATH} ..")
+  endif()
+  add_subdirectory(${DEF_CONF_PATH})
+  set(FSFW_CONFIG_PATH ${DEF_CONF_PATH})
 endif()
 
-# FSFW might be part of a possibly complicated folder structure, so we 
-# extract the absolute path of the fsfwconfig folder.
+# FSFW might be part of a possibly complicated folder structure, so we extract
+# the absolute path of the fsfwconfig folder.
 if(IS_ABSOLUTE ${FSFW_CONFIG_PATH})
-	set(FSFW_CONFIG_PATH_ABSOLUTE ${FSFW_CONFIG_PATH})
+  set(FSFW_CONFIG_PATH_ABSOLUTE ${FSFW_CONFIG_PATH})
 else()
-	get_filename_component(FSFW_CONFIG_PATH_ABSOLUTE
-		${FSFW_CONFIG_PATH} REALPATH BASE_DIR ${CMAKE_SOURCE_DIR}
-	)
+  get_filename_component(FSFW_CONFIG_PATH_ABSOLUTE ${FSFW_CONFIG_PATH} REALPATH
+                         BASE_DIR ${CMAKE_SOURCE_DIR})
 endif()
 
 foreach(INCLUDE_PATH ${FSFW_ADDITIONAL_INC_PATHS})
-    if(IS_ABSOLUTE ${INCLUDE_PATH})
-        set(CURR_ABS_INC_PATH "${INCLUDE_PATH}")
-    else()
-        get_filename_component(CURR_ABS_INC_PATH
-            ${INCLUDE_PATH} REALPATH BASE_DIR ${CMAKE_SOURCE_DIR})
-    endif()
+  if(IS_ABSOLUTE ${INCLUDE_PATH})
+    set(CURR_ABS_INC_PATH "${INCLUDE_PATH}")
+  else()
+    get_filename_component(CURR_ABS_INC_PATH ${INCLUDE_PATH} REALPATH BASE_DIR
+                           ${CMAKE_SOURCE_DIR})
+  endif()
 
-    if(CMAKE_VERBOSE)
-        message(STATUS "FSFW include path: ${CURR_ABS_INC_PATH}")
-    endif()
+  if(CMAKE_VERBOSE)
+    message(STATUS "FSFW include path: ${CURR_ABS_INC_PATH}")
+  endif()
 
-    list(APPEND FSFW_ADD_INC_PATHS_ABS ${CURR_ABS_INC_PATH})
+  list(APPEND FSFW_ADD_INC_PATHS_ABS ${CURR_ABS_INC_PATH})
 endforeach()
 
 if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-    if(NOT DEFINED FSFW_WARNING_FLAGS)
-	   set(FSFW_WARNING_FLAGS
-		  -Wall
-		  -Wextra
-		  -Wimplicit-fallthrough=1
-		  -Wno-unused-parameter
-		  -Wno-psabi
-          -Wduplicated-cond # check for duplicate conditions
-          -Wduplicated-branches # check for duplicate branches
-          -Wlogical-op # Search for bitwise operations instead of logical 
-          -Wnull-dereference # Search for NULL dereference
-          -Wundef # Warn if undefind marcos are used
-          -Wformat=2 # Format string problem detection
-          -Wformat-overflow=2 # Formatting issues in printf
-          -Wformat-truncation=2 # Formatting issues in printf
-          -Wformat-security # Search for dangerous printf operations
-          -Wstrict-overflow=3 # Warn if integer overflows might happen
-          -Warray-bounds=2 # Some array bounds violations will be found
-          -Wshift-overflow=2 # Search for bit left shift overflows (<c++14)
-          -Wcast-qual # Warn if the constness is cast away
-          -Wstringop-overflow=4
-          # -Wstack-protector # Emits a few false positives for low level access
-          # -Wconversion # Creates many false positives
-          # -Warith-conversion # Use with Wconversion to find more implicit conversions
-          # -fanalyzer # Should be used to look through problems
-        )
-    endif()
+  if(NOT DEFINED FSFW_WARNING_FLAGS)
+    set(FSFW_WARNING_FLAGS
+        -Wall
+        -Wextra
+        -Wimplicit-fallthrough=1
+        -Wno-unused-parameter
+        -Wno-psabi
+        -Wduplicated-cond # check for duplicate conditions
+        -Wduplicated-branches # check for duplicate branches
+        -Wlogical-op # Search for bitwise operations instead of logical
+        -Wnull-dereference # Search for NULL dereference
+        -Wundef # Warn if undefind marcos are used
+        -Wformat=2 # Format string problem detection
+        -Wformat-overflow=2 # Formatting issues in printf
+        -Wformat-truncation=2 # Formatting issues in printf
+        -Wformat-security # Search for dangerous printf operations
+        -Wstrict-overflow=3 # Warn if integer overflows might happen
+        -Warray-bounds=2 # Some array bounds violations will be found
+        -Wshift-overflow=2 # Search for bit left shift overflows (<c++14)
+        -Wcast-qual # Warn if the constness is cast away
+        -Wstringop-overflow=4
+        # -Wstack-protector # Emits a few false positives for low level access
+        # -Wconversion # Creates many false positives -Warith-conversion # Use
+        # with Wconversion to find more implicit conversions -fanalyzer # Should
+        # be used to look through problems
+    )
+  endif()
 
-    if(FSFW_GENERATE_SECTIONS)
-        target_compile_options(${LIB_FSFW_NAME} PRIVATE
-            "-ffunction-sections"
-            "-fdata-sections"
-        )
-    endif()
+  if(FSFW_GENERATE_SECTIONS)
+    target_compile_options(${LIB_FSFW_NAME} PRIVATE "-ffunction-sections"
+                                                    "-fdata-sections")
+  endif()
+
+  if(FSFW_REMOVE_UNUSED_CODE)
+    target_link_options(${LIB_FSFW_NAME} PRIVATE "Wl,--gc-sections")
+  endif()
+
+  if(FSFW_WARNING_SHADOW_LOCAL_GCC)
+    list(APPEND WARNING_FLAGS "-Wshadow=local")
+  endif()
 
-    if(FSFW_REMOVE_UNUSED_CODE)
-        target_link_options(${LIB_FSFW_NAME} PRIVATE
-            "Wl,--gc-sections"
-        )
-    endif()
-  
-    if(FSFW_WARNING_SHADOW_LOCAL_GCC)
-        list(APPEND WARNING_FLAGS "-Wshadow=local")
-    endif()
-	
 endif()
 
 if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-	set(COMPILER_FLAGS "/permissive-")
+  set(COMPILER_FLAGS "/permissive-")
 endif()
 
 # Required include paths to compile the FSFW
-target_include_directories(${LIB_FSFW_NAME} INTERFACE 
-	${CMAKE_SOURCE_DIR}
-	${FSFW_CONFIG_PATH_ABSOLUTE}
-	${FSFW_CORE_INC_PATH}
-	${FSFW_ADD_INC_PATHS_ABS}
-)
+target_include_directories(
+  ${LIB_FSFW_NAME} INTERFACE ${CMAKE_SOURCE_DIR} ${FSFW_CONFIG_PATH_ABSOLUTE}
+                             ${FSFW_CORE_INC_PATH} ${FSFW_ADD_INC_PATHS_ABS})
 
-# Includes path required to compile FSFW itself as well
-# We assume that the fsfwconfig folder uses include relative to the project
-# root here!
-target_include_directories(${LIB_FSFW_NAME} PRIVATE 
-	${CMAKE_SOURCE_DIR}
-	${FSFW_CONFIG_PATH_ABSOLUTE}
-	${FSFW_CORE_INC_PATH}
-	${FSFW_ADD_INC_PATHS_ABS}
-)
+# Includes path required to compile FSFW itself as well We assume that the
+# fsfwconfig folder uses include relative to the project root here!
+target_include_directories(
+  ${LIB_FSFW_NAME} PRIVATE ${CMAKE_SOURCE_DIR} ${FSFW_CONFIG_PATH_ABSOLUTE}
+                           ${FSFW_CORE_INC_PATH} ${FSFW_ADD_INC_PATHS_ABS})
 
-target_compile_options(${LIB_FSFW_NAME} PRIVATE 
-	${FSFW_WARNING_FLAGS}
-	${COMPILER_FLAGS}
-)
+target_compile_options(${LIB_FSFW_NAME} PRIVATE ${FSFW_WARNING_FLAGS}
+                                                ${COMPILER_FLAGS})
 
-target_link_libraries(${LIB_FSFW_NAME} PRIVATE
-    etl
-    ${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})

automation/Dockerfile

@@ -6,3 +6,9 @@ RUN apt-get --yes upgrade
 #tzdata is a dependency, won't install otherwise
 ARG DEBIAN_FRONTEND=noninteractive
 RUN apt-get --yes install gcc g++ cmake make lcov git valgrind nano iputils-ping
+
+RUN git clone https://github.com/catchorg/Catch2.git && \
+	cd Catch2 && \
+	git checkout v3.0.0-preview5 && \
+	cmake -Bbuild -H. -DBUILD_TESTING=OFF && \
+	cmake --build build/ --target install

automation/Jenkinsfile

@@ -3,7 +3,7 @@ pipeline {
         BUILDDIR = 'build-tests'
     }
     agent {
-        docker { image 'fsfw-ci:d1'}
+        docker { image 'fsfw-ci:d2'}
     }
     stages {
         stage('Clean') {

cmake/cmake-modules/GetGitRevisionDescription.cmake

@@ -1,141 +0,0 @@
-# - 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> [<additional arguments to git describe> ...])
-#
-# 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_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.
-#
-# 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 Iowa State University 2009-2010.
-# 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(get_git_head_revision _refspecvar _hashvar)
-    set(GIT_PARENT_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
-    set(GIT_DIR "${GIT_PARENT_DIR}/.git")
-    while(NOT EXISTS "${GIT_DIR}")    # .git dir not found, search parent directories
-        set(GIT_PREVIOUS_PARENT "${GIT_PARENT_DIR}")
-        get_filename_component(GIT_PARENT_DIR ${GIT_PARENT_DIR} PATH)
-        if(GIT_PARENT_DIR STREQUAL GIT_PREVIOUS_PARENT)
-            # We have reached the root directory, we are not in git
-            set(${_refspecvar} "GITDIR-NOTFOUND" PARENT_SCOPE)
-            set(${_hashvar} "GITDIR-NOTFOUND" PARENT_SCOPE)
-            return()
-        endif()
-        set(GIT_DIR "${GIT_PARENT_DIR}/.git")
-    endwhile()
-    # check if this is a submodule
-    if(NOT IS_DIRECTORY ${GIT_DIR})
-        file(READ ${GIT_DIR} submodule)
-        string(REGEX REPLACE "gitdir: (.*)\n$" "\\1" GIT_DIR_RELATIVE ${submodule})
-        get_filename_component(SUBMODULE_DIR ${GIT_DIR} PATH)
-
-        if (IS_ABSOLUTE ${GIT_DIR_RELATIVE})
-            set(GIT_DIR ${GIT_DIR_RELATIVE})
-        else()
-            get_filename_component(GIT_DIR ${SUBMODULE_DIR}/${GIT_DIR_RELATIVE} ABSOLUTE)
-        endif()
-
-    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 "${GIT_DIR}/HEAD")
-        return()
-    endif()
-    set(HEAD_FILE "${GIT_DATA}/HEAD")
-    configure_file("${GIT_DIR}/HEAD" "${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
-        ${hash}
-        ${ARGN}
-        WORKING_DIRECTORY
-        "${CMAKE_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_get_tag _var)
-    git_describe(out --tags ${ARGN})
-    set(${_var} "${out}" PARENT_SCOPE)
-endfunction()

cmake/cmake-modules/README.md

@@ -1,5 +1,7 @@
-The files in these folder were manually copy and pasted from the
+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 license file in included here as well.
+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.

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()

cmake/cmake-modules/rpavlik/GetGitRevisionDescription.cmake.in

@@ -1,4 +1,4 @@
-# 
+#
 # Internal file for GetGitRevisionDescription.cmake
 #
 # Requires CMake 2.6 or newer (uses the 'function' command)
@@ -8,10 +8,12 @@
 # http://academic.cleardefinition.com
 # Iowa State University HCI Graduate Program/VRAC
 #
-# Copyright Iowa State University 2009-2010.
+# 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)
 
@@ -22,10 +24,13 @@ 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)
-    elseif(EXISTS "@GIT_DIR@/logs/${HEAD_REF}")
-        configure_file("@GIT_DIR@/logs/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY)
-        set(HEAD_HASH "${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
@@ -33,6 +38,6 @@ else()
 endif()
 
 if(NOT HEAD_HASH)
-file(READ "@GIT_DATA@/head-ref" HEAD_HASH LIMIT 1024)
-string(STRIP "${HEAD_HASH}" HEAD_HASH)
+    file(READ "@GIT_DATA@/head-ref" HEAD_HASH LIMIT 1024)
+    string(STRIP "${HEAD_HASH}" HEAD_HASH)
 endif()

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.

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.

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.

hal/src/fsfw_hal/common/gpio/GpioIF.h

@@ -46,9 +46,9 @@ class GpioIF : public HasReturnvaluesIF {
    *          an ouput or input gpio.
    *
    * @param gpioId    A unique number which specifies the GPIO to read.
-   * @param gpioState State of GPIO will be written to this pointer.
+   * @param gpioState State of GPIO will be written to this reference
    */
-  virtual ReturnValue_t readGpio(gpioId_t gpioId, int* gpioState) = 0;
+  virtual ReturnValue_t readGpio(gpioId_t gpioId, gpio::Levels& gpioState) = 0;
 };
 
 #endif /* COMMON_GPIO_GPIOIF_H_ */

hal/src/fsfw_hal/common/gpio/gpioDefinitions.h

@@ -9,7 +9,7 @@ using gpioId_t = uint16_t;
 
 namespace gpio {
 
-enum class Levels : int { LOW = 0, HIGH = 1, NONE = 99 };
+enum class Levels : int { LOW = 0, HIGH = 1, FAILED = -1, NONE = 99 };
 
 enum class Direction : int { IN = 0, OUT = 1 };
 

hal/src/fsfw_hal/devicehandlers/GyroL3GD20Handler.cpp

@@ -252,6 +252,7 @@ ReturnValue_t GyroHandlerL3GD20H::initializeLocalDataPool(localpool::DataPool &l
   localDataPoolMap.emplace(L3GD20H::ANG_VELOC_Y, new PoolEntry<float>({0.0}));
   localDataPoolMap.emplace(L3GD20H::ANG_VELOC_Z, new PoolEntry<float>({0.0}));
   localDataPoolMap.emplace(L3GD20H::TEMPERATURE, new PoolEntry<float>({0.0}));
+  poolManager.subscribeForPeriodicPacket(dataset.getSid(), false, 10.0, false);
   return HasReturnvaluesIF::RETURN_OK;
 }
 

hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp

@@ -475,6 +475,7 @@ ReturnValue_t MgmLIS3MDLHandler::initializeLocalDataPool(localpool::DataPool &lo
   localDataPoolMap.emplace(MGMLIS3MDL::FIELD_STRENGTH_Y, new PoolEntry<float>({0.0}));
   localDataPoolMap.emplace(MGMLIS3MDL::FIELD_STRENGTH_Z, new PoolEntry<float>({0.0}));
   localDataPoolMap.emplace(MGMLIS3MDL::TEMPERATURE_CELCIUS, new PoolEntry<float>({0.0}));
+  poolManager.subscribeForPeriodicPacket(dataset.getSid(), false, 10.0, false);
   return HasReturnvaluesIF::RETURN_OK;
 }
 

hal/src/fsfw_hal/devicehandlers/MgmRM3100Handler.cpp

@@ -312,6 +312,7 @@ ReturnValue_t MgmRM3100Handler::initializeLocalDataPool(localpool::DataPool &loc
   localDataPoolMap.emplace(RM3100::FIELD_STRENGTH_X, new PoolEntry<float>({0.0}));
   localDataPoolMap.emplace(RM3100::FIELD_STRENGTH_Y, new PoolEntry<float>({0.0}));
   localDataPoolMap.emplace(RM3100::FIELD_STRENGTH_Z, new PoolEntry<float>({0.0}));
+  poolManager.subscribeForPeriodicPacket(primaryDataset.getSid(), false, 10.0, false);
   return HasReturnvaluesIF::RETURN_OK;
 }
 

hal/src/fsfw_hal/linux/CMakeLists.txt

@@ -12,9 +12,14 @@ if(FSFW_HAL_LINUX_ADD_PERIPHERAL_DRIVERS)
 if(FSFW_HAL_LINUX_ADD_LIBGPIOD)
 	add_subdirectory(gpio)
 endif()
-	add_subdirectory(spi)
-	add_subdirectory(i2c)
 	add_subdirectory(uart)
+	# Adding those does not really make sense on Apple systems which
+	# are generally host systems. It won't even compile as the headers
+	# are missing
+	if(NOT APPLE)
+		add_subdirectory(i2c)
+		add_subdirectory(spi)
+	endif()
 endif()
 
 add_subdirectory(uio)

hal/src/fsfw_hal/linux/CommandExecutor.cpp

@@ -32,6 +32,8 @@ ReturnValue_t CommandExecutor::execute() {
   } else if (state == States::PENDING) {
     return COMMAND_PENDING;
   }
+  // Reset data in read vector
+  std::memset(readVec.data(), 0, readVec.size());
   currentCmdFile = popen(currentCmd.c_str(), "r");
   if (currentCmdFile == nullptr) {
     lastError = errno;
@@ -205,3 +207,5 @@ ReturnValue_t CommandExecutor::executeBlocking() {
   }
   return HasReturnvaluesIF::RETURN_OK;
 }
+
+const std::vector<char>& CommandExecutor::getReadVector() const { return readVec; }

hal/src/fsfw_hal/linux/CommandExecutor.h

@@ -109,6 +109,8 @@ class CommandExecutor {
    */
   void reset();
 
+  const std::vector<char>& getReadVector() const;
+
  private:
   std::string currentCmd;
   bool blocking = true;

hal/src/fsfw_hal/linux/UnixFileGuard.cpp

@@ -6,7 +6,7 @@
 #include "fsfw/FSFW.h"
 #include "fsfw/serviceinterface.h"
 
-UnixFileGuard::UnixFileGuard(std::string device, int* fileDescriptor, int flags,
+UnixFileGuard::UnixFileGuard(const std::string& device, int* fileDescriptor, int flags,
                              std::string diagnosticPrefix)
     : fileDescriptor(fileDescriptor) {
   if (fileDescriptor == nullptr) {

hal/src/fsfw_hal/linux/UnixFileGuard.h

@@ -15,7 +15,7 @@ class UnixFileGuard {
 
   static constexpr ReturnValue_t OPEN_FILE_FAILED = 1;
 
-  UnixFileGuard(std::string device, int* fileDescriptor, int flags,
+  UnixFileGuard(const std::string& device, int* fileDescriptor, int flags,
                 std::string diagnosticPrefix = "");
 
   virtual ~UnixFileGuard();

hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.cpp

@@ -20,7 +20,9 @@ LinuxLibgpioIF::~LinuxLibgpioIF() {
 ReturnValue_t LinuxLibgpioIF::addGpios(GpioCookie* gpioCookie) {
   ReturnValue_t result;
   if (gpioCookie == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "LinuxLibgpioIF::addGpios: Invalid cookie" << std::endl;
+#endif
     return RETURN_FAILED;
   }
 
@@ -96,8 +98,10 @@ ReturnValue_t LinuxLibgpioIF::configureGpioByLabel(gpioId_t gpioId,
   std::string& label = gpioByLabel.label;
   struct gpiod_chip* chip = gpiod_chip_open_by_label(label.c_str());
   if (chip == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "LinuxLibgpioIF::configureGpioByLabel: Failed to open gpio from gpio "
                  << "group with label " << label << ". Gpio ID: " << gpioId << std::endl;
+#endif
     return RETURN_FAILED;
   }
   std::string failOutput = "label: " + label;
@@ -108,8 +112,10 @@ ReturnValue_t LinuxLibgpioIF::configureGpioByChip(gpioId_t gpioId, GpiodRegularB
   std::string& chipname = gpioByChip.chipname;
   struct gpiod_chip* chip = gpiod_chip_open_by_name(chipname.c_str());
   if (chip == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "LinuxLibgpioIF::configureGpioByChip: Failed to open chip " << chipname
                  << ". Gpio ID: " << gpioId << std::endl;
+#endif
     return RETURN_FAILED;
   }
   std::string failOutput = "chipname: " + chipname;
@@ -133,8 +139,10 @@ ReturnValue_t LinuxLibgpioIF::configureGpioByLineName(gpioId_t gpioId,
 
   struct gpiod_chip* chip = gpiod_chip_open_by_name(chipname);
   if (chip == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "LinuxLibgpioIF::configureGpioByLineName: Failed to open chip " << chipname
                  << ". <Gpio ID: " << gpioId << std::endl;
+#endif
     return RETURN_FAILED;
   }
   std::string failOutput = "line name: " + lineName;
@@ -153,10 +161,12 @@ ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, struct gpiod
   lineNum = regularGpio.lineNum;
   lineHandle = gpiod_chip_get_line(chip, lineNum);
   if (!lineHandle) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "LinuxLibgpioIF::configureRegularGpio: Failed to open line " << std::endl;
     sif::warning << "GPIO ID: " << gpioId << ", line number: " << lineNum << ", " << failOutput
                  << std::endl;
     sif::warning << "Check if Linux GPIO configuration has changed. " << std::endl;
+#endif
     gpiod_chip_close(chip);
     return RETURN_FAILED;
   }
@@ -175,7 +185,9 @@ ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, struct gpiod
       break;
     }
     default: {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::error << "LinuxLibgpioIF::configureGpios: Invalid direction specified" << std::endl;
+#endif
       return GPIO_INVALID_INSTANCE;
     }
 
@@ -204,7 +216,9 @@ ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, struct gpiod
 ReturnValue_t LinuxLibgpioIF::pullHigh(gpioId_t gpioId) {
   gpioMapIter = gpioMap.find(gpioId);
   if (gpioMapIter == gpioMap.end()) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "LinuxLibgpioIF::pullHigh: Unknown GPIO ID " << gpioId << std::endl;
+#endif
     return UNKNOWN_GPIO_ID;
   }
 
@@ -280,7 +294,7 @@ ReturnValue_t LinuxLibgpioIF::driveGpio(gpioId_t gpioId, GpiodRegularBase& regul
   return RETURN_OK;
 }
 
-ReturnValue_t LinuxLibgpioIF::readGpio(gpioId_t gpioId, int* gpioState) {
+ReturnValue_t LinuxLibgpioIF::readGpio(gpioId_t gpioId, gpio::Levels& gpioState) {
   gpioMapIter = gpioMap.find(gpioId);
   if (gpioMapIter == gpioMap.end()) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -299,7 +313,10 @@ ReturnValue_t LinuxLibgpioIF::readGpio(gpioId_t gpioId, int* gpioState) {
     if (regularGpio == nullptr) {
       return GPIO_TYPE_FAILURE;
     }
-    *gpioState = gpiod_line_get_value(regularGpio->lineHandle);
+    gpioState = static_cast<gpio::Levels>(gpiod_line_get_value(regularGpio->lineHandle));
+    if (gpioState == gpio::Levels::FAILED) {
+      return GPIO_GET_VALUE_FAILED;
+    }
   } else {
     auto gpioCallback = dynamic_cast<GpioCallback*>(gpioMapIter->second);
     if (gpioCallback->callback == nullptr) {

hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h

@@ -31,14 +31,16 @@ class LinuxLibgpioIF : public GpioIF, public SystemObject {
       HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 5);
   static constexpr ReturnValue_t GPIO_INIT_FAILED =
       HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 6);
-
+  // Will be returned if getting the line value failed. Error type will be set to errno in this case
+  static constexpr ReturnValue_t GPIO_GET_VALUE_FAILED =
+      HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 7);
   LinuxLibgpioIF(object_id_t objectId);
   virtual ~LinuxLibgpioIF();
 
   ReturnValue_t addGpios(GpioCookie* gpioCookie) override;
   ReturnValue_t pullHigh(gpioId_t gpioId) override;
   ReturnValue_t pullLow(gpioId_t gpioId) override;
-  ReturnValue_t readGpio(gpioId_t gpioId, int* gpioState) override;
+  ReturnValue_t readGpio(gpioId_t gpioId, gpio::Levels& gpioState) override;
 
  private:
   static const size_t MAX_CHIPNAME_LENGTH = 11;

hal/src/fsfw_hal/linux/i2c/I2cComIF.cpp

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

hal/src/fsfw_hal/linux/spi/ManualCsLockGuard.h

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

hal/src/fsfw_hal/linux/spi/SpiComIF.cpp

@@ -15,8 +15,8 @@
 #include "fsfw_hal/linux/spi/SpiCookie.h"
 #include "fsfw_hal/linux/utility.h"
 
-SpiComIF::SpiComIF(object_id_t objectId, GpioIF* gpioComIF)
-    : SystemObject(objectId), gpioComIF(gpioComIF) {
+SpiComIF::SpiComIF(object_id_t objectId, std::string devname, GpioIF* gpioComIF)
+    : SystemObject(objectId), gpioComIF(gpioComIF), dev(std::move(devname)) {
   if (gpioComIF == nullptr) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -27,7 +27,7 @@ SpiComIF::SpiComIF(object_id_t objectId, GpioIF* gpioComIF)
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
   }
 
-  spiMutex = MutexFactory::instance()->createMutex();
+  csMutex = MutexFactory::instance()->createMutex();
 }
 
 ReturnValue_t SpiComIF::initializeInterface(CookieIF* cookie) {
@@ -85,8 +85,7 @@ ReturnValue_t SpiComIF::initializeInterface(CookieIF* cookie) {
   spiCookie->getSpiParameters(spiMode, spiSpeed, &params);
 
   int fileDescriptor = 0;
-  UnixFileGuard fileHelper(spiCookie->getSpiDevice(), &fileDescriptor, O_RDWR,
-                           "SpiComIF::initializeInterface");
+  UnixFileGuard fileHelper(dev, &fileDescriptor, O_RDWR, "SpiComIF::initializeInterface");
   if (fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
     return fileHelper.getOpenResult();
   }
@@ -182,8 +181,7 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
   int retval = 0;
   /* Prepare transfer */
   int fileDescriptor = 0;
-  std::string device = spiCookie->getSpiDevice();
-  UnixFileGuard fileHelper(device, &fileDescriptor, O_RDWR, "SpiComIF::sendMessage");
+  UnixFileGuard fileHelper(dev, &fileDescriptor, O_RDWR, "SpiComIF::sendMessage");
   if (fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
     return OPENING_FILE_FAILED;
   }
@@ -196,20 +194,27 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
 
   bool fullDuplex = spiCookie->isFullDuplex();
   gpioId_t gpioId = spiCookie->getChipSelectPin();
+  bool csLockManual = spiCookie->getCsLockManual();
 
-  /* Pull SPI CS low. For now, no support for active high given  */
-  if (gpioId != gpio::NO_GPIO) {
-    result = spiMutex->lockMutex(timeoutType, timeoutMs);
+  MutexIF::TimeoutType csType;
+  dur_millis_t csTimeout = 0;
+  // Pull SPI CS low. For now, no support for active high given
+  if (gpioId != gpio::NO_GPIO and not csLockManual) {
+    spiCookie->getMutexParams(csType, csTimeout);
+    result = csMutex->lockMutex(csType, csTimeout);
     if (result != RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::error << "SpiComIF::sendMessage: Failed to lock mutex" << std::endl;
+      sif::error << "SpiComIF::sendMessage: Failed to lock mutex with code "
+                 << "0x" << std::hex << std::setfill('0') << std::setw(4) << result << std::dec
+                 << std::endl;
 #else
-      sif::printError("SpiComIF::sendMessage: Failed to lock mutex\n");
+      sif::printError("SpiComIF::sendMessage: Failed to lock mutex with code %d\n", result);
 #endif
 #endif
       return result;
     }
+    updateLinePolarity(fileDescriptor);
     ReturnValue_t result = gpioComIF->pullLow(gpioId);
     if (result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
@@ -221,6 +226,8 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
 #endif
       return result;
     }
+  } else {
+    updateLinePolarity(fileDescriptor);
   }
 
   /* Execute transfer */
@@ -248,9 +255,9 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
     }
   }
 
-  if (gpioId != gpio::NO_GPIO) {
+  if (gpioId != gpio::NO_GPIO and not csLockManual) {
     gpioComIF->pullHigh(gpioId);
-    result = spiMutex->unlockMutex();
+    result = csMutex->unlockMutex();
     if (result != RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::error << "SpiComIF::sendMessage: Failed to unlock mutex" << std::endl;
@@ -278,9 +285,8 @@ ReturnValue_t SpiComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLe
 
 ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
   ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-  std::string device = spiCookie->getSpiDevice();
   int fileDescriptor = 0;
-  UnixFileGuard fileHelper(device, &fileDescriptor, O_RDWR, "SpiComIF::requestReceiveMessage");
+  UnixFileGuard fileHelper(dev, &fileDescriptor, O_RDWR, "SpiComIF::requestReceiveMessage");
   if (fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
     return OPENING_FILE_FAILED;
   }
@@ -292,12 +298,22 @@ ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
     return result;
   }
 
+  bool csLockManual = spiCookie->getCsLockManual();
   gpioId_t gpioId = spiCookie->getChipSelectPin();
-  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);
     if (result != RETURN_OK) {
+#if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::error << "SpiComIF::getSendSuccess: Failed to lock mutex" << std::endl;
+      sif::error << "SpiComIF::sendMessage: Failed to lock mutex with code "
+                 << "0x" << std::hex << std::setfill('0') << std::setw(4) << result << std::dec
+                 << std::endl;
+#else
+      sif::printError("SpiComIF::sendMessage: Failed to lock mutex with code %d\n", result);
+#endif
 #endif
       return result;
     }
@@ -315,9 +331,9 @@ ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
     result = HALF_DUPLEX_TRANSFER_FAILED;
   }
 
-  if (gpioId != gpio::NO_GPIO) {
+  if (gpioId != gpio::NO_GPIO and not csLockManual) {
     gpioComIF->pullHigh(gpioId);
-    result = spiMutex->unlockMutex();
+    result = csMutex->unlockMutex();
     if (result != RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::error << "SpiComIF::getSendSuccess: Failed to unlock mutex" << std::endl;
@@ -346,15 +362,7 @@ ReturnValue_t SpiComIF::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-MutexIF* SpiComIF::getMutex(MutexIF::TimeoutType* timeoutType, uint32_t* timeoutMs) {
-  if (timeoutType != nullptr) {
-    *timeoutType = this->timeoutType;
-  }
-  if (timeoutMs != nullptr) {
-    *timeoutMs = this->timeoutMs;
-  }
-  return spiMutex;
-}
+MutexIF* SpiComIF::getCsMutex() { return csMutex; }
 
 void SpiComIF::performSpiWiretapping(SpiCookie* spiCookie) {
   if (spiCookie == nullptr) {
@@ -401,11 +409,27 @@ void SpiComIF::setSpiSpeedAndMode(int spiFd, spi::SpiModes mode, uint32_t speed)
   if (retval != 0) {
     utility::handleIoctlError("SpiComIF::setSpiSpeedAndMode: Setting SPI speed failed");
   }
-  // This updates the SPI clock default polarity. Only setting the mode does not update
-  // the line state, which can be an issue on mode switches because the clock line will
-  // switch the state after the chip select is pulled low
+}
+
+void SpiComIF::getSpiSpeedAndMode(int spiFd, spi::SpiModes& mode, uint32_t& speed) const {
+  uint8_t tmpMode = 0;
+  int retval = ioctl(spiFd, SPI_IOC_RD_MODE, &tmpMode);
+  if (retval != 0) {
+    utility::handleIoctlError("SpiComIF::getSpiSpeedAndMode: Reading SPI mode failed");
+  }
+  mode = static_cast<spi::SpiModes>(tmpMode);
+
+  retval = ioctl(spiFd, SPI_IOC_RD_MAX_SPEED_HZ, &speed);
+  if (retval != 0) {
+    utility::handleIoctlError("SpiComIF::getSpiSpeedAndMode: Getting SPI speed failed");
+  }
+}
+
+const std::string& SpiComIF::getSpiDev() const { return dev; }
+
+void SpiComIF::updateLinePolarity(int spiFd) {
   clockUpdateTransfer.len = 0;
-  retval = ioctl(spiFd, SPI_IOC_MESSAGE(1), &clockUpdateTransfer);
+  int retval = ioctl(spiFd, SPI_IOC_MESSAGE(1), &clockUpdateTransfer);
   if (retval != 0) {
     utility::handleIoctlError("SpiComIF::setSpiSpeedAndMode: Updating SPI default clock failed");
   }

hal/src/fsfw_hal/linux/spi/SpiComIF.h

@@ -22,17 +22,17 @@ class SpiCookie;
  */
 class SpiComIF : public DeviceCommunicationIF, public SystemObject {
  public:
-  static constexpr uint8_t spiRetvalId = CLASS_ID::HAL_SPI;
+  static constexpr uint8_t CLASS_ID = CLASS_ID::HAL_SPI;
   static constexpr ReturnValue_t OPENING_FILE_FAILED =
-      HasReturnvaluesIF::makeReturnCode(spiRetvalId, 0);
+      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 0);
   /* Full duplex (ioctl) transfer failure */
   static constexpr ReturnValue_t FULL_DUPLEX_TRANSFER_FAILED =
-      HasReturnvaluesIF::makeReturnCode(spiRetvalId, 1);
+      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 1);
   /* Half duplex (read/write) transfer failure */
   static constexpr ReturnValue_t HALF_DUPLEX_TRANSFER_FAILED =
-      HasReturnvaluesIF::makeReturnCode(spiRetvalId, 2);
+      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 2);
 
-  SpiComIF(object_id_t objectId, GpioIF* gpioComIF);
+  SpiComIF(object_id_t objectId, std::string devname, GpioIF* gpioComIF);
 
   ReturnValue_t initializeInterface(CookieIF* cookie) override;
   ReturnValue_t sendMessage(CookieIF* cookie, const uint8_t* sendData, size_t sendLen) override;
@@ -44,7 +44,8 @@ class SpiComIF : public DeviceCommunicationIF, public SystemObject {
    * @brief   This function returns the mutex which can be used to protect the spi bus when
    *          the chip select must be driven from outside of the com if.
    */
-  MutexIF* getMutex(MutexIF::TimeoutType* timeoutType = nullptr, uint32_t* timeoutMs = nullptr);
+  MutexIF* getCsMutex();
+  void setMutexParams(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs);
 
   /**
    * Perform a regular send operation using Linux iotcl. This is public so it can be used
@@ -59,6 +60,20 @@ class SpiComIF : public DeviceCommunicationIF, public SystemObject {
 
   GpioIF* getGpioInterface();
   void setSpiSpeedAndMode(int spiFd, spi::SpiModes mode, uint32_t speed);
+  void getSpiSpeedAndMode(int spiFd, spi::SpiModes& mode, uint32_t& speed) const;
+
+  /**
+   * This updates the SPI clock default polarity. Only setting the mode does not update
+   * the line state, which can be an issue on mode switches because the clock line will
+   * switch the state after the chip select is pulled low.
+   *
+   * It is recommended to call this function after #setSpiSpeedAndMode and after locking the
+   * CS mutex if the SPI bus has multiple SPI devices with different speed and SPI modes attached.
+   * @param spiFd
+   */
+  void updateLinePolarity(int spiFd);
+
+  const std::string& getSpiDev() const;
   void performSpiWiretapping(SpiCookie* spiCookie);
 
   ReturnValue_t getReadBuffer(address_t spiAddress, uint8_t** buffer);
@@ -70,10 +85,14 @@ class SpiComIF : public DeviceCommunicationIF, public SystemObject {
   };
 
   GpioIF* gpioComIF = nullptr;
-
-  MutexIF* spiMutex = nullptr;
-  MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
-  uint32_t timeoutMs = 20;
+  std::string dev = "";
+  /**
+   * Protects the chip select operations. Lock when GPIO is pulled low, unlock after it was
+   * pulled high
+   */
+  MutexIF* csMutex = nullptr;
+  // MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+  // uint32_t timeoutMs = DEFAULT_MUTEX_TIMEOUT;
   spi_ioc_transfer clockUpdateTransfer = {};
 
   using SpiDeviceMap = std::unordered_map<address_t, SpiInstance>;

hal/src/fsfw_hal/linux/spi/SpiCookie.cpp

@@ -1,26 +1,25 @@
-#include "fsfw_hal/linux/spi/SpiCookie.h"
+#include "SpiCookie.h"
 
-SpiCookie::SpiCookie(address_t spiAddress, gpioId_t chipSelect, std::string spiDev,
-                     const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed)
-    : SpiCookie(spi::SpiComIfModes::REGULAR, spiAddress, chipSelect, spiDev, maxSize, spiMode,
-                spiSpeed, nullptr, nullptr) {}
-
-SpiCookie::SpiCookie(address_t spiAddress, std::string spiDev, const size_t maxSize,
+SpiCookie::SpiCookie(address_t spiAddress, gpioId_t chipSelect, const size_t maxSize,
                      spi::SpiModes spiMode, uint32_t spiSpeed)
-    : SpiCookie(spiAddress, gpio::NO_GPIO, spiDev, maxSize, spiMode, spiSpeed) {}
+    : SpiCookie(spi::SpiComIfModes::REGULAR, spiAddress, chipSelect, maxSize, spiMode, spiSpeed,
+                nullptr, nullptr) {}
 
-SpiCookie::SpiCookie(address_t spiAddress, gpioId_t chipSelect, std::string spiDev,
-                     const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed,
+SpiCookie::SpiCookie(address_t spiAddress, const size_t maxSize, spi::SpiModes spiMode,
+                     uint32_t spiSpeed)
+    : SpiCookie(spiAddress, gpio::NO_GPIO, maxSize, spiMode, spiSpeed) {}
+
+SpiCookie::SpiCookie(address_t spiAddress, gpioId_t chipSelect, const size_t maxSize,
+                     spi::SpiModes spiMode, uint32_t spiSpeed,
                      spi::send_callback_function_t callback, void* args)
-    : SpiCookie(spi::SpiComIfModes::CALLBACK, spiAddress, chipSelect, spiDev, maxSize, spiMode,
-                spiSpeed, callback, args) {}
+    : SpiCookie(spi::SpiComIfModes::CALLBACK, spiAddress, chipSelect, maxSize, spiMode, spiSpeed,
+                callback, args) {}
 
 SpiCookie::SpiCookie(spi::SpiComIfModes comIfMode, address_t spiAddress, gpioId_t chipSelect,
-                     std::string spiDev, const size_t maxSize, spi::SpiModes spiMode,
-                     uint32_t spiSpeed, spi::send_callback_function_t callback, void* args)
+                     const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed,
+                     spi::send_callback_function_t callback, void* args)
     : spiAddress(spiAddress),
       chipSelectPin(chipSelect),
-      spiDevice(spiDev),
       comIfMode(comIfMode),
       maxSize(maxSize),
       spiMode(spiMode),
@@ -50,8 +49,6 @@ size_t SpiCookie::getMaxBufferSize() const { return maxSize; }
 
 address_t SpiCookie::getSpiAddress() const { return spiAddress; }
 
-std::string SpiCookie::getSpiDevice() const { return spiDevice; }
-
 void SpiCookie::setThreeWireSpi(bool enable) { uncommonParameters.threeWireSpi = enable; }
 
 void SpiCookie::setLsbFirst(bool enable) { uncommonParameters.lsbFirst = enable; }
@@ -107,3 +104,17 @@ void SpiCookie::getCallback(spi::send_callback_function_t* callback, void** args
   *callback = this->sendCallback;
   *args = this->callbackArgs;
 }
+
+void SpiCookie::setCsLockManual(bool enable) { manualCsLock = enable; }
+
+bool SpiCookie::getCsLockManual() const { return manualCsLock; }
+
+void SpiCookie::getMutexParams(MutexIF::TimeoutType& csTimeoutType, dur_millis_t& csTimeout) const {
+  csTimeoutType = this->csTimeoutType;
+  csTimeout = this->csTimeout;
+}
+
+void SpiCookie::setMutexParams(MutexIF::TimeoutType csTimeoutType, dur_millis_t csTimeout) {
+  this->csTimeoutType = csTimeoutType;
+  this->csTimeout = csTimeout;
+}

hal/src/fsfw_hal/linux/spi/SpiCookie.h

@@ -2,6 +2,8 @@
 #define LINUX_SPI_SPICOOKIE_H_
 
 #include <fsfw/devicehandlers/CookieIF.h>
+#include <fsfw/ipc/MutexIF.h>
+#include <fsfw/timemanager/clockDefinitions.h>
 #include <linux/spi/spidev.h>
 
 #include "../../common/gpio/gpioDefinitions.h"
@@ -20,6 +22,8 @@
  */
 class SpiCookie : public CookieIF {
  public:
+  static constexpr dur_millis_t DEFAULT_MUTEX_TIMEOUT = 20;
+
   /**
    * Each SPI device will have a corresponding cookie. The cookie is used by the communication
    * interface and contains device specific information like the largest expected size to be
@@ -29,23 +33,22 @@ class SpiCookie : public CookieIF {
    * @param spiDev
    * @param maxSize
    */
-  SpiCookie(address_t spiAddress, gpioId_t chipSelect, std::string spiDev, const size_t maxSize,
-            spi::SpiModes spiMode, uint32_t spiSpeed);
+  SpiCookie(address_t spiAddress, gpioId_t chipSelect, const size_t maxSize, spi::SpiModes spiMode,
+            uint32_t spiSpeed);
 
   /**
    * Like constructor above, but without a dedicated GPIO CS. Can be used for hardware
    * slave select or if CS logic is performed with decoders.
    */
-  SpiCookie(address_t spiAddress, std::string spiDev, const size_t maxReplySize,
-            spi::SpiModes spiMode, uint32_t spiSpeed);
+  SpiCookie(address_t spiAddress, const size_t maxReplySize, spi::SpiModes spiMode,
+            uint32_t spiSpeed);
 
   /**
    * Use the callback mode of the SPI communication interface. The user can pass the callback
    * function here or by using the setter function #setCallbackMode
    */
-  SpiCookie(address_t spiAddress, gpioId_t chipSelect, std::string spiDev, const size_t maxSize,
-            spi::SpiModes spiMode, uint32_t spiSpeed, spi::send_callback_function_t callback,
-            void* args);
+  SpiCookie(address_t spiAddress, gpioId_t chipSelect, const size_t maxSize, spi::SpiModes spiMode,
+            uint32_t spiSpeed, spi::send_callback_function_t callback, void* args);
 
   /**
    * Get the callback function
@@ -55,7 +58,6 @@ class SpiCookie : public CookieIF {
   void getCallback(spi::send_callback_function_t* callback, void** args);
 
   address_t getSpiAddress() const;
-  std::string getSpiDevice() const;
   gpioId_t getChipSelectPin() const;
   size_t getMaxBufferSize() const;
 
@@ -139,9 +141,42 @@ class SpiCookie : public CookieIF {
    */
   void activateCsDeselect(bool deselectCs, uint16_t delayUsecs);
 
+  void getMutexParams(MutexIF::TimeoutType& csTimeoutType, dur_millis_t& csTimeout) const;
+  void setMutexParams(MutexIF::TimeoutType csTimeoutType, dur_millis_t csTimeout);
+
+  void setCsLockManual(bool enable);
+  bool getCsLockManual() const;
+
   spi_ioc_transfer* getTransferStructHandle();
 
  private:
+  address_t spiAddress;
+  gpioId_t chipSelectPin;
+
+  spi::SpiComIfModes comIfMode;
+
+  // Required for regular mode
+  const size_t maxSize;
+  spi::SpiModes spiMode;
+  /**
+   * If this is set to true, the SPI ComIF will not perform any mutex locking for the
+   * CS mechanism. The user is responsible to locking and unlocking the mutex for the
+   * whole duration of the transfers.
+   */
+  bool manualCsLock = false;
+  uint32_t spiSpeed;
+  bool halfDuplex = false;
+
+  MutexIF::TimeoutType csTimeoutType = MutexIF::TimeoutType::WAITING;
+  dur_millis_t csTimeout = DEFAULT_MUTEX_TIMEOUT;
+
+  // Required for callback mode
+  spi::send_callback_function_t sendCallback = nullptr;
+  void* callbackArgs = nullptr;
+
+  struct spi_ioc_transfer spiTransferStruct = {};
+  UncommonParameters uncommonParameters;
+
   /**
    * Internal constructor which initializes every field
    * @param spiAddress
@@ -154,27 +189,8 @@ class SpiCookie : public CookieIF {
    * @param args
    */
   SpiCookie(spi::SpiComIfModes comIfMode, address_t spiAddress, gpioId_t chipSelect,
-            std::string spiDev, const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed,
+            const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed,
             spi::send_callback_function_t callback, void* args);
-
-  address_t spiAddress;
-  gpioId_t chipSelectPin;
-  std::string spiDevice;
-
-  spi::SpiComIfModes comIfMode;
-
-  // Required for regular mode
-  const size_t maxSize;
-  spi::SpiModes spiMode;
-  uint32_t spiSpeed;
-  bool halfDuplex = false;
-
-  // Required for callback mode
-  spi::send_callback_function_t sendCallback = nullptr;
-  void* callbackArgs = nullptr;
-
-  struct spi_ioc_transfer spiTransferStruct = {};
-  UncommonParameters uncommonParameters;
 };
 
 #endif /* LINUX_SPI_SPICOOKIE_H_ */

hal/src/fsfw_hal/linux/uart/UartComIF.cpp

@@ -265,6 +265,7 @@ void UartComIF::configureBaudrate(struct termios* options, UartCookie* uartCooki
       cfsetispeed(options, B230400);
       cfsetospeed(options, B230400);
       break;
+#ifndef __APPLE__
     case UartBaudRate::RATE_460800:
       cfsetispeed(options, B460800);
       cfsetospeed(options, B460800);
@@ -313,6 +314,7 @@ void UartComIF::configureBaudrate(struct termios* options, UartCookie* uartCooki
       cfsetispeed(options, B4000000);
       cfsetospeed(options, B4000000);
       break;
+#endif  // ! __APPLE__
     default:
 #if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::warning << "UartComIF::configureBaudrate: Baudrate not supported" << std::endl;

scripts/apply-clang-format.sh

@@ -1,8 +0,0 @@
-#!/bin/bash
-if [[ ! -f README.md ]]; then
-	cd ..
-fi
-
-find ./src -iname *.h -o -iname *.cpp -o -iname *.c | xargs clang-format --style=file -i
-find ./hal -iname *.h -o -iname *.cpp -o -iname *.c | xargs clang-format --style=file -i
-find ./tests -iname *.h -o -iname *.cpp -o -iname *.c | xargs clang-format --style=file -i

scripts/auto-formatter.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+if [[ ! -f README.md ]]; then
+  cd ..
+fi
+
+folder_list=(
+  "./src"
+  "./hal"
+  "./tests"
+)
+
+cmake_fmt="cmake-format"
+file_selectors="-iname CMakeLists.txt"
+if command -v ${cmake_fmt} &> /dev/null; then
+  ${cmake_fmt} -i CMakeLists.txt
+  find ./src ${file_selectors} | xargs ${cmake_fmt}  -i
+else
+  echo "No ${cmake_fmt} tool found, not formatting CMake files"
+fi
+
+cpp_format="clang-format"
+file_selectors="-iname *.h -o -iname *.cpp -o -iname *.c -o -iname *.tpp"
+if command -v ${cpp_format} &> /dev/null; then
+  for dir in ${folder_list[@]}; do
+    echo "Auto-formatting ${dir} recursively"
+    find ${dir} ${file_selectors} | xargs clang-format --style=file -i
+  done
+else
+  echo "No ${cpp_format} tool found, not formatting C++/C files"
+fi

src/CMakeLists.txt

@@ -1,9 +1,6 @@
-target_include_directories(${LIB_FSFW_NAME} PRIVATE
-    ${CMAKE_CURRENT_SOURCE_DIR}
-)
+target_include_directories(${LIB_FSFW_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
 
-target_include_directories(${LIB_FSFW_NAME} INTERFACE
-    ${CMAKE_CURRENT_SOURCE_DIR}
-)
+target_include_directories(${LIB_FSFW_NAME}
+                           INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})
 
 add_subdirectory(fsfw)

src/fsfw/CMakeLists.txt

@@ -1,6 +1,4 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
-    version.cpp
-)
+target_sources(${LIB_FSFW_NAME} PRIVATE version.cpp)
 
 # Core
 
@@ -37,22 +35,22 @@ add_subdirectory(tmtcservices)
 # Optional
 
 if(FSFW_ADD_MONITORING)
-add_subdirectory(monitoring)
+  add_subdirectory(monitoring)
 endif()
 if(FSFW_ADD_PUS)
-    add_subdirectory(pus)
+  add_subdirectory(pus)
 endif()
 if(FSFW_ADD_TMSTORAGE)
-    add_subdirectory(tmstorage)
+  add_subdirectory(tmstorage)
 endif()
 if(FSFW_ADD_COORDINATES)
-    add_subdirectory(coordinates)
+  add_subdirectory(coordinates)
 endif()
 if(FSFW_ADD_RMAP)
-    add_subdirectory(rmap)
+  add_subdirectory(rmap)
 endif()
 if(FSFW_ADD_DATALINKLAYER)
-    add_subdirectory(datalinklayer)
+  add_subdirectory(datalinklayer)
 endif()
 
 # OSAL

src/fsfw/FSFWVersion.h.in

@@ -6,6 +6,6 @@ static constexpr int FSFW_VERSION_MAJOR = @FSFW_VERSION@;
 static constexpr int FSFW_VERSION_MINOR = @FSFW_SUBVERSION@;
 static constexpr int FSFW_VERSION_REVISION = @FSFW_REVISION@;
 // Also contains CST (Commits since tag) information
-static const char FSFW_VERSION_CST_GIT_SHA1[] = "@FSFW_VERSION_CST_GIT_SHA1@";
+static const char FSFW_VCS_INFO[] = "@FSFW_VCS_INFO@";
 
 #endif /* FSFW_VERSION_H_ */

src/fsfw/action/CMakeLists.txt

@@ -1,7 +1,3 @@
-target_sources(${LIB_FSFW_NAME} 
-    PRIVATE 
-        ActionHelper.cpp
-        ActionMessage.cpp
-        CommandActionHelper.cpp
-        SimpleActionHelper.cpp
-)
+target_sources(
+  ${LIB_FSFW_NAME} PRIVATE ActionHelper.cpp ActionMessage.cpp
+                           CommandActionHelper.cpp SimpleActionHelper.cpp)

src/fsfw/cfdp/CMakeLists.txt

@@ -1,7 +1,4 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
-    CFDPHandler.cpp
-    CFDPMessage.cpp
-)
+target_sources(${LIB_FSFW_NAME} PRIVATE CFDPHandler.cpp CFDPMessage.cpp)
 
 add_subdirectory(pdu)
 add_subdirectory(tlv)

src/fsfw/cfdp/pdu/CMakeLists.txt

@@ -1,32 +1,30 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
-    PduConfig.cpp
-    VarLenField.cpp
-    HeaderSerializer.cpp
-    HeaderDeserializer.cpp
-    FileDirectiveDeserializer.cpp
-    FileDirectiveSerializer.cpp
- 
-    AckInfo.cpp
-    AckPduSerializer.cpp
-    AckPduDeserializer.cpp
-    EofInfo.cpp
-    EofPduSerializer.cpp
-    EofPduDeserializer.cpp
-    NakInfo.cpp
-    NakPduSerializer.cpp
-    NakPduDeserializer.cpp
-    FinishedInfo.cpp
-    FinishedPduSerializer.cpp
-    FinishedPduDeserializer.cpp
-    MetadataInfo.cpp
-    MetadataPduSerializer.cpp
-    MetadataPduDeserializer.cpp
-    KeepAlivePduSerializer.cpp
-    KeepAlivePduDeserializer.cpp
-    PromptPduSerializer.cpp
-    PromptPduDeserializer.cpp
-
-    FileDataSerializer.cpp
-    FileDataDeserializer.cpp
-    FileDataInfo.cpp
-)
+target_sources(
+  ${LIB_FSFW_NAME}
+  PRIVATE PduConfig.cpp
+          VarLenField.cpp
+          HeaderSerializer.cpp
+          HeaderDeserializer.cpp
+          FileDirectiveDeserializer.cpp
+          FileDirectiveSerializer.cpp
+          AckInfo.cpp
+          AckPduSerializer.cpp
+          AckPduDeserializer.cpp
+          EofInfo.cpp
+          EofPduSerializer.cpp
+          EofPduDeserializer.cpp
+          NakInfo.cpp
+          NakPduSerializer.cpp
+          NakPduDeserializer.cpp
+          FinishedInfo.cpp
+          FinishedPduSerializer.cpp
+          FinishedPduDeserializer.cpp
+          MetadataInfo.cpp
+          MetadataPduSerializer.cpp
+          MetadataPduDeserializer.cpp
+          KeepAlivePduSerializer.cpp
+          KeepAlivePduDeserializer.cpp
+          PromptPduSerializer.cpp
+          PromptPduDeserializer.cpp
+          FileDataSerializer.cpp
+          FileDataDeserializer.cpp
+          FileDataInfo.cpp)

src/fsfw/cfdp/pdu/HeaderSerializer.h

@@ -44,7 +44,7 @@ class HeaderSerializer : public SerializeIF, public PduHeaderIF {
   cfdp::WidthInBytes getLenEntityIds() const override;
   cfdp::WidthInBytes getLenSeqNum() const override;
   cfdp::SegmentMetadataFlag getSegmentMetadataFlag() const override;
-  bool hasSegmentMetadataFlag() const;
+  bool hasSegmentMetadataFlag() const override;
   void setSegmentationControl(cfdp::SegmentationControl);
 
   void getSourceId(cfdp::EntityId& sourceId) const override;

src/fsfw/cfdp/tlv/CMakeLists.txt

@@ -1,10 +1,10 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
-    EntityIdTlv.cpp
-    FilestoreRequestTlv.cpp
-    FilestoreResponseTlv.cpp
-    Lv.cpp
-    Tlv.cpp
-    FlowLabelTlv.cpp
-    MessageToUserTlv.cpp
-    FaultHandlerOverrideTlv.cpp
-)
+target_sources(
+  ${LIB_FSFW_NAME}
+  PRIVATE EntityIdTlv.cpp
+          FilestoreRequestTlv.cpp
+          FilestoreResponseTlv.cpp
+          Lv.cpp
+          Tlv.cpp
+          FlowLabelTlv.cpp
+          MessageToUserTlv.cpp
+          FaultHandlerOverrideTlv.cpp)

src/fsfw/container/CMakeLists.txt

@@ -1,5 +1,2 @@
-target_sources(${LIB_FSFW_NAME} 
-    PRIVATE 
-        SharedRingBuffer.cpp
-        SimpleRingBuffer.cpp
-)
+target_sources(${LIB_FSFW_NAME} PRIVATE SharedRingBuffer.cpp
+                                        SimpleRingBuffer.cpp)

src/fsfw/container/FIFOBase.tpp

@@ -5,89 +5,88 @@
 #error Include FIFOBase.h before FIFOBase.tpp!
 #endif
 
-template<typename T>
-inline FIFOBase<T>::FIFOBase(T* values, const size_t maxCapacity):
-        maxCapacity(maxCapacity), values(values){};
+template <typename T>
+inline FIFOBase<T>::FIFOBase(T* values, const size_t maxCapacity)
+    : maxCapacity(maxCapacity), values(values){};
 
-template<typename T>
+template <typename T>
 inline ReturnValue_t FIFOBase<T>::insert(T value) {
-    if (full()) {
-        return FULL;
-    } else {
-        values[writeIndex] = value;
-        writeIndex = next(writeIndex);
-        ++currentSize;
-        return HasReturnvaluesIF::RETURN_OK;
-    }
+  if (full()) {
+    return FULL;
+  } else {
+    values[writeIndex] = value;
+    writeIndex = next(writeIndex);
+    ++currentSize;
+    return HasReturnvaluesIF::RETURN_OK;
+  }
 };
 
-template<typename T>
+template <typename T>
 inline ReturnValue_t FIFOBase<T>::retrieve(T* value) {
-    if (empty()) {
-        return EMPTY;
-    } else {
-        if (value == nullptr){
-            return HasReturnvaluesIF::RETURN_FAILED;
-        }
-        *value = values[readIndex];
-        readIndex = next(readIndex);
-        --currentSize;
-        return HasReturnvaluesIF::RETURN_OK;
+  if (empty()) {
+    return EMPTY;
+  } else {
+    if (value == nullptr) {
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
+    *value = values[readIndex];
+    readIndex = next(readIndex);
+    --currentSize;
+    return HasReturnvaluesIF::RETURN_OK;
+  }
 };
 
-template<typename T>
+template <typename T>
 inline ReturnValue_t FIFOBase<T>::peek(T* value) {
-    if(empty()) {
-        return EMPTY;
-    } else {
-        if (value == nullptr){
-            return HasReturnvaluesIF::RETURN_FAILED;
-        }
-        *value = values[readIndex];
-        return HasReturnvaluesIF::RETURN_OK;
+  if (empty()) {
+    return EMPTY;
+  } else {
+    if (value == nullptr) {
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
+    *value = values[readIndex];
+    return HasReturnvaluesIF::RETURN_OK;
+  }
 };
 
-template<typename T>
+template <typename T>
 inline ReturnValue_t FIFOBase<T>::pop() {
-    T value;
-    return this->retrieve(&value);
+  T value;
+  return this->retrieve(&value);
 };
 
-template<typename T>
+template <typename T>
 inline bool FIFOBase<T>::empty() {
-    return (currentSize == 0);
+  return (currentSize == 0);
 };
 
-template<typename T>
+template <typename T>
 inline bool FIFOBase<T>::full() {
-    return (currentSize == maxCapacity);
+  return (currentSize == maxCapacity);
 }
 
-template<typename T>
+template <typename T>
 inline size_t FIFOBase<T>::size() {
-    return currentSize;
+  return currentSize;
 }
 
-template<typename T>
+template <typename T>
 inline size_t FIFOBase<T>::next(size_t current) {
-    ++current;
-    if (current == maxCapacity) {
-        current = 0;
-    }
-    return current;
+  ++current;
+  if (current == maxCapacity) {
+    current = 0;
+  }
+  return current;
 }
 
-template<typename T>
+template <typename T>
 inline size_t FIFOBase<T>::getMaxCapacity() const {
-    return maxCapacity;
+  return maxCapacity;
 }
 
-
-template<typename T>
-inline void FIFOBase<T>::setContainer(T *data) {
-    this->values = data;
+template <typename T>
+inline void FIFOBase<T>::setContainer(T* data) {
+  this->values = data;
 }
 
 #endif

src/fsfw/container/FixedArrayList.h

@@ -2,6 +2,7 @@
 #define FIXEDARRAYLIST_H_
 
 #include <cmath>
+#include <limits>
 
 #include "ArrayList.h"
 /**
@@ -9,10 +10,9 @@
  */
 template <typename T, size_t MAX_SIZE, typename count_t = uint8_t>
 class FixedArrayList : public ArrayList<T, count_t> {
-#if !defined(_MSC_VER)
-  static_assert(MAX_SIZE <= (std::pow(2, sizeof(count_t) * 8) - 1),
+  static_assert(MAX_SIZE <= std::numeric_limits<count_t>::max(),
                 "count_t is not large enough to hold MAX_SIZE");
-#endif
+
  private:
   T data[MAX_SIZE];
 

src/fsfw/container/FixedOrderedMultimap.tpp

@@ -1,109 +1,109 @@
 #ifndef FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_
 #define FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_
 
-
-template<typename key_t, typename T, typename KEY_COMPARE>
-inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(key_t key, T value, Iterator *storedValue) {
-    if (_size == theMap.maxSize()) {
-        return MAP_FULL;
-    }
-    size_t position = findNicePlace(key);
-    memmove(static_cast<void*>(&theMap[position + 1]),static_cast<void*>(&theMap[position]),
-            (_size - position) * sizeof(std::pair<key_t,T>));
-    theMap[position].first = key;
-    theMap[position].second = value;
-    ++_size;
-    if (storedValue != nullptr) {
-        *storedValue = Iterator(&theMap[position]);
-    }
-    return HasReturnvaluesIF::RETURN_OK;
+template <typename key_t, typename T, typename KEY_COMPARE>
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(key_t key, T value,
+                                                                         Iterator *storedValue) {
+  if (_size == theMap.maxSize()) {
+    return MAP_FULL;
+  }
+  size_t position = findNicePlace(key);
+  memmove(static_cast<void *>(&theMap[position + 1]), static_cast<void *>(&theMap[position]),
+          (_size - position) * sizeof(std::pair<key_t, T>));
+  theMap[position].first = key;
+  theMap[position].second = value;
+  ++_size;
+  if (storedValue != nullptr) {
+    *storedValue = Iterator(&theMap[position]);
+  }
+  return HasReturnvaluesIF::RETURN_OK;
 }
-template<typename key_t, typename T, typename KEY_COMPARE>
+template <typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(std::pair<key_t, T> pair) {
-    return insert(pair.first, pair.second);
+  return insert(pair.first, pair.second);
 }
 
-template<typename key_t, typename T, typename KEY_COMPARE>
+template <typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::exists(key_t key) const {
-    ReturnValue_t result = KEY_DOES_NOT_EXIST;
-    if (findFirstIndex(key) < _size) {
-        result = HasReturnvaluesIF::RETURN_OK;
-    }
-    return result;
+  ReturnValue_t result = KEY_DOES_NOT_EXIST;
+  if (findFirstIndex(key) < _size) {
+    result = HasReturnvaluesIF::RETURN_OK;
+  }
+  return result;
 }
 
-template<typename key_t, typename T, typename KEY_COMPARE>
+template <typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(Iterator *iter) {
-    size_t i;
-    if ((i = findFirstIndex((*iter).value->first)) >= _size) {
-        return KEY_DOES_NOT_EXIST;
-    }
-    removeFromPosition(i);
-    if (*iter != begin()) {
-        (*iter)--;
-    } else {
-        *iter = begin();
-    }
-    return HasReturnvaluesIF::RETURN_OK;
+  size_t i;
+  if ((i = findFirstIndex((*iter).value->first)) >= _size) {
+    return KEY_DOES_NOT_EXIST;
+  }
+  removeFromPosition(i);
+  if (*iter != begin()) {
+    (*iter)--;
+  } else {
+    *iter = begin();
+  }
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
-template<typename key_t, typename T, typename KEY_COMPARE>
+template <typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(key_t key) {
-    size_t i;
-    if ((i = findFirstIndex(key)) >= _size) {
-        return KEY_DOES_NOT_EXIST;
-    }
-    do {
-        removeFromPosition(i);
-        i = findFirstIndex(key, i);
-    } while (i < _size);
-    return HasReturnvaluesIF::RETURN_OK;
+  size_t i;
+  if ((i = findFirstIndex(key)) >= _size) {
+    return KEY_DOES_NOT_EXIST;
+  }
+  do {
+    removeFromPosition(i);
+    i = findFirstIndex(key, i);
+  } while (i < _size);
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
-template<typename key_t, typename T, typename KEY_COMPARE>
+template <typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(key_t key, T **value) const {
-    ReturnValue_t result = exists(key);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-    }
-    *value = &theMap[findFirstIndex(key)].second;
-    return HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result = exists(key);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  *value = &theMap[findFirstIndex(key)].second;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
-template<typename key_t, typename T, typename KEY_COMPARE>
-inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findFirstIndex(key_t key, size_t startAt) const {
-    if (startAt >= _size) {
-        return startAt + 1;
+template <typename key_t, typename T, typename KEY_COMPARE>
+inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findFirstIndex(key_t key,
+                                                                          size_t startAt) const {
+  if (startAt >= _size) {
+    return startAt + 1;
+  }
+  size_t i = startAt;
+  for (i = startAt; i < _size; ++i) {
+    if (theMap[i].first == key) {
+      return i;
     }
-    size_t i = startAt;
-    for (i = startAt; i < _size; ++i) {
-        if (theMap[i].first == key) {
-            return i;
-        }
-    }
-    return i;
+  }
+  return i;
 }
 
-template<typename key_t, typename T, typename KEY_COMPARE>
+template <typename key_t, typename T, typename KEY_COMPARE>
 inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findNicePlace(key_t key) const {
-    size_t i = 0;
-    for (i = 0; i < _size; ++i) {
-        if (myComp(key, theMap[i].first)) {
-            return i;
-        }
+  size_t i = 0;
+  for (i = 0; i < _size; ++i) {
+    if (myComp(key, theMap[i].first)) {
+      return i;
     }
-    return i;
+  }
+  return i;
 }
 
-template<typename key_t, typename T, typename KEY_COMPARE>
+template <typename key_t, typename T, typename KEY_COMPARE>
 inline void FixedOrderedMultimap<key_t, T, KEY_COMPARE>::removeFromPosition(size_t position) {
-    if (_size <= position) {
-        return;
-    }
-    memmove(static_cast<void*>(&theMap[position]), static_cast<void*>(&theMap[position + 1]),
-            (_size - position - 1) * sizeof(std::pair<key_t,T>));
-    --_size;
+  if (_size <= position) {
+    return;
+  }
+  memmove(static_cast<void *>(&theMap[position]), static_cast<void *>(&theMap[position + 1]),
+          (_size - position - 1) * sizeof(std::pair<key_t, T>));
+  --_size;
 }
 
-
 #endif /* FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_ */

src/fsfw/container/HybridIterator.h

@@ -10,7 +10,7 @@ class HybridIterator : public LinkedElement<T>::Iterator, public ArrayList<T, co
   HybridIterator() {}
 
   HybridIterator(typename LinkedElement<T>::Iterator *iter)
-      : LinkedElement<T>::Iterator(*iter), value(iter->value), linked(true) {
+      : LinkedElement<T>::Iterator(*iter), linked(true) {
     if (iter != nullptr) {
       value = iter->value;
     }

src/fsfw/controller/CMakeLists.txt

@@ -1,4 +1,2 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE 
-    ControllerBase.cpp
-    ExtendedControllerBase.cpp
-)
+target_sources(${LIB_FSFW_NAME} PRIVATE ControllerBase.cpp
+                                        ExtendedControllerBase.cpp)

src/fsfw/controller/ControllerBase.h

@@ -55,7 +55,7 @@ class ControllerBase : public HasModesIF,
   virtual void performControlOperation() = 0;
 
   virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-                                         uint32_t *msToReachTheMode) = 0;
+                                         uint32_t *msToReachTheMode) override = 0;
 
   const object_id_t parentId;
 
@@ -80,9 +80,9 @@ class ControllerBase : public HasModesIF,
 
   /** Mode helpers */
   virtual void modeChanged(Mode_t mode, Submode_t submode);
-  virtual void startTransition(Mode_t mode, Submode_t submode);
-  virtual void getMode(Mode_t *mode, Submode_t *submode);
-  virtual void setToExternalControl();
+  virtual void startTransition(Mode_t mode, Submode_t submode) override;
+  virtual void getMode(Mode_t *mode, Submode_t *submode) override;
+  virtual void setToExternalControl() override;
   virtual void announceMode(bool recursive);
   /** HK helpers */
   virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);

src/fsfw/coordinates/CMakeLists.txt

@@ -1,5 +1,2 @@
-target_sources(${LIB_FSFW_NAME} 
-	PRIVATE 
-		CoordinateTransformations.cpp
-		Sgp4Propagator.cpp
-)
+target_sources(${LIB_FSFW_NAME} PRIVATE CoordinateTransformations.cpp
+                                        Sgp4Propagator.cpp)

src/fsfw/datalinklayer/CMakeLists.txt

@@ -1,12 +1,11 @@
-target_sources(${LIB_FSFW_NAME} 
-	PRIVATE 
-		Clcw.cpp
-		DataLinkLayer.cpp
-		Farm1StateLockout.cpp
-		Farm1StateOpen.cpp
-		Farm1StateWait.cpp
-		MapPacketExtraction.cpp
-		TcTransferFrame.cpp
-		TcTransferFrameLocal.cpp
-		VirtualChannelReception.cpp
-)
+target_sources(
+  ${LIB_FSFW_NAME}
+  PRIVATE Clcw.cpp
+          DataLinkLayer.cpp
+          Farm1StateLockout.cpp
+          Farm1StateOpen.cpp
+          Farm1StateWait.cpp
+          MapPacketExtraction.cpp
+          TcTransferFrame.cpp
+          TcTransferFrameLocal.cpp
+          VirtualChannelReception.cpp)

src/fsfw/datapool/CMakeLists.txt

@@ -1,4 +1 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE 
-    PoolDataSetBase.cpp
-    PoolEntry.cpp
-)
+target_sources(${LIB_FSFW_NAME} PRIVATE PoolDataSetBase.cpp PoolEntry.cpp)

src/fsfw/datapool/PoolDataSetBase.h

@@ -109,7 +109,7 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF, public HasRetu
    */
   virtual ReturnValue_t unlockDataPool() override;
 
-  virtual uint16_t getFillCount() const;
+  virtual uint16_t getFillCount() const override;
 
   /* SerializeIF implementations */
   virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, const size_t maxSize,

src/fsfw/datapoollocal/CMakeLists.txt

@@ -1,10 +1,6 @@
-target_sources(${LIB_FSFW_NAME} 
-	PRIVATE 
-		LocalDataPoolManager.cpp
-		LocalDataSet.cpp
-		LocalPoolDataSetBase.cpp
-		LocalPoolObjectBase.cpp
-		SharedLocalDataSet.cpp
-)
+target_sources(
+  ${LIB_FSFW_NAME}
+  PRIVATE LocalDataPoolManager.cpp LocalDataSet.cpp LocalPoolDataSetBase.cpp
+          LocalPoolObjectBase.cpp SharedLocalDataSet.cpp)
 
-add_subdirectory(internal)
+add_subdirectory(internal)

src/fsfw/datapoollocal/LocalDataPoolManager.cpp

@@ -577,6 +577,9 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(CommandMessage* me
 
   CommandMessage reply;
   if (result != HasReturnvaluesIF::RETURN_OK) {
+    if(result == WRONG_HK_PACKET_TYPE) {
+      printWarningOrError(sif::OutputTypes::OUT_WARNING, "handleHousekeepingMessage", WRONG_HK_PACKET_TYPE);
+    }
     HousekeepingMessage::setHkRequestFailureReply(&reply, sid, result);
   } else {
     HousekeepingMessage::setHkRequestSuccessReply(&reply, sid);
@@ -696,9 +699,9 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
   if (result != HasReturnvaluesIF::RETURN_OK) {
     /* Configuration error */
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "LocalDataPoolManager::performHkOperation: HK generation failed." << std::endl;
+    sif::warning << "LocalDataPoolManager::performPeriodicHkOperation: HK generation failed." << std::endl;
 #else
-    sif::printWarning("LocalDataPoolManager::performHkOperation: HK generation failed.\n");
+    sif::printWarning("LocalDataPoolManager::performPeriodicHkOperation: HK generation failed.\n");
 #endif
   }
 }
@@ -834,6 +837,8 @@ void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
       errorPrint = "Dataset not found";
     } else if (error == POOLOBJECT_NOT_FOUND) {
       errorPrint = "Pool Object not found";
+    } else if (error == WRONG_HK_PACKET_TYPE) {
+      errorPrint = "Wrong Packet Type";
     } else if (error == HasReturnvaluesIF::RETURN_FAILED) {
       if (outputType == sif::OutputTypes::OUT_WARNING) {
         errorPrint = "Generic Warning";

src/fsfw/datapoollocal/LocalPoolDataSetBase.cpp

@@ -94,13 +94,14 @@ ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(
   ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
   const uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount) / 8.0);
   uint8_t *validityPtr = nullptr;
-#ifdef _MSC_VER
-  /* Use a std::vector here because MSVC will (rightly) not create a fixed size array
-  with a non constant size specifier */
-  std::vector<uint8_t> validityMask(validityMaskSize);
+#if defined(_MSC_VER) || defined(__clang__)
+  // Use a std::vector here because MSVC will (rightly) not create a fixed size array
+  // with a non constant size specifier. The Apple compiler (LLVM) will not accept
+  // the  initialization of a variable sized array
+  std::vector<uint8_t> validityMask(validityMaskSize, 0);
   validityPtr = validityMask.data();
 #else
-  uint8_t validityMask[validityMaskSize] = {0};
+  uint8_t validityMask[validityMaskSize] = {};
   validityPtr = validityMask;
 #endif
   uint8_t validBufferIndex = 0;

src/fsfw/datapoollocal/LocalPoolObjectBase.h

@@ -23,8 +23,8 @@ class LocalPoolObjectBase : public PoolVariableIF, public HasReturnvaluesIF, pub
   LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId, DataSetIF* dataSet = nullptr,
                       pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
-  void setReadWriteMode(pool_rwm_t newReadWriteMode);
-  pool_rwm_t getReadWriteMode() const;
+  void setReadWriteMode(pool_rwm_t newReadWriteMode) override;
+  pool_rwm_t getReadWriteMode() const override;
 
   bool isValid() const override;
   void setValid(bool valid) override;

src/fsfw/datapoollocal/LocalPoolVariable.tpp

@@ -5,205 +5,189 @@
 #error Include LocalPoolVariable.h before LocalPoolVariable.tpp!
 #endif
 
-template<typename T>
-inline LocalPoolVariable<T>::LocalPoolVariable(HasLocalDataPoolIF* hkOwner,
-        lp_id_t poolId, DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
-        LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
+template <typename T>
+inline LocalPoolVariable<T>::LocalPoolVariable(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
+                                               DataSetIF* dataSet, pool_rwm_t setReadWriteMode)
+    : LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
-template<typename T>
-inline LocalPoolVariable<T>::LocalPoolVariable(object_id_t poolOwner,
-        lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
-        LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
+template <typename T>
+inline LocalPoolVariable<T>::LocalPoolVariable(object_id_t poolOwner, lp_id_t poolId,
+                                               DataSetIF* dataSet, pool_rwm_t setReadWriteMode)
+    : LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
 
+template <typename T>
+inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId, DataSetIF* dataSet,
+                                               pool_rwm_t setReadWriteMode)
+    : LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId, dataSet,
+                          setReadWriteMode) {}
 
-template<typename T>
-inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId,
-        DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
-        LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
-                dataSet, setReadWriteMode){}
-
-
-template<typename T>
-inline ReturnValue_t LocalPoolVariable<T>::read(
-        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-    if(hkManager == nullptr) {
-        return readWithoutLock();
-    }
-    MutexIF* mutex = LocalDpManagerAttorney::getMutexHandle(*hkManager);
-    ReturnValue_t result = mutex->lockMutex(timeoutType, timeoutMs);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-    }
-    result = readWithoutLock();
-    mutex->unlockMutex();
+template <typename T>
+inline ReturnValue_t LocalPoolVariable<T>::read(MutexIF::TimeoutType timeoutType,
+                                                uint32_t timeoutMs) {
+  if (hkManager == nullptr) {
+    return readWithoutLock();
+  }
+  MutexIF* mutex = LocalDpManagerAttorney::getMutexHandle(*hkManager);
+  ReturnValue_t result = mutex->lockMutex(timeoutType, timeoutMs);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
+  }
+  result = readWithoutLock();
+  mutex->unlockMutex();
+  return result;
 }
 
-template<typename T>
+template <typename T>
 inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
-    if(readWriteMode == pool_rwm_t::VAR_WRITE) {
-        object_id_t targetObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVector",
-                PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
-                localPoolId);
-        return PoolVariableIF::INVALID_READ_WRITE_MODE;
-    }
+  if (readWriteMode == pool_rwm_t::VAR_WRITE) {
+    object_id_t targetObjectId = hkManager->getCreatorObjectId();
+    reportReadCommitError("LocalPoolVector", PoolVariableIF::INVALID_READ_WRITE_MODE, true,
+                          targetObjectId, localPoolId);
+    return PoolVariableIF::INVALID_READ_WRITE_MODE;
+  }
 
-    PoolEntry<T>* poolEntry = nullptr;
-    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
-            &poolEntry);
-    if(result != RETURN_OK) {
-        object_id_t ownerObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVariable", result,
-                false, ownerObjectId, localPoolId);
-        return result;
-    }
-
-    this->value = *(poolEntry->getDataPtr());
-    this->valid = poolEntry->getValid();
-    return RETURN_OK;
-}
-
-template<typename T>
-inline ReturnValue_t LocalPoolVariable<T>::commit(bool setValid,
-        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-    this->setValid(setValid);
-    return commit(timeoutType, timeoutMs);
-}
-
-template<typename T>
-inline ReturnValue_t LocalPoolVariable<T>::commit(
-        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-    if(hkManager == nullptr) {
-        return commitWithoutLock();
-    }
-    MutexIF* mutex = LocalDpManagerAttorney::getMutexHandle(*hkManager);
-    ReturnValue_t result = mutex->lockMutex(timeoutType, timeoutMs);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-    }
-    result = commitWithoutLock();
-    mutex->unlockMutex();
+  PoolEntry<T>* poolEntry = nullptr;
+  ReturnValue_t result =
+      LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
+  if (result != RETURN_OK) {
+    object_id_t ownerObjectId = hkManager->getCreatorObjectId();
+    reportReadCommitError("LocalPoolVariable", result, false, ownerObjectId, localPoolId);
     return result;
+  }
+
+  this->value = *(poolEntry->getDataPtr());
+  this->valid = poolEntry->getValid();
+  return RETURN_OK;
 }
 
-template<typename T>
+template <typename T>
+inline ReturnValue_t LocalPoolVariable<T>::commit(bool setValid, MutexIF::TimeoutType timeoutType,
+                                                  uint32_t timeoutMs) {
+  this->setValid(setValid);
+  return commit(timeoutType, timeoutMs);
+}
+
+template <typename T>
+inline ReturnValue_t LocalPoolVariable<T>::commit(MutexIF::TimeoutType timeoutType,
+                                                  uint32_t timeoutMs) {
+  if (hkManager == nullptr) {
+    return commitWithoutLock();
+  }
+  MutexIF* mutex = LocalDpManagerAttorney::getMutexHandle(*hkManager);
+  ReturnValue_t result = mutex->lockMutex(timeoutType, timeoutMs);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  result = commitWithoutLock();
+  mutex->unlockMutex();
+  return result;
+}
+
+template <typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
-    if(readWriteMode == pool_rwm_t::VAR_READ) {
-        object_id_t targetObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVector",
-                PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
-                localPoolId);
-        return PoolVariableIF::INVALID_READ_WRITE_MODE;
-    }
+  if (readWriteMode == pool_rwm_t::VAR_READ) {
+    object_id_t targetObjectId = hkManager->getCreatorObjectId();
+    reportReadCommitError("LocalPoolVector", PoolVariableIF::INVALID_READ_WRITE_MODE, false,
+                          targetObjectId, localPoolId);
+    return PoolVariableIF::INVALID_READ_WRITE_MODE;
+  }
 
-    PoolEntry<T>* poolEntry = nullptr;
-    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
-            &poolEntry);
-    if(result != RETURN_OK) {
-        object_id_t ownerObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVariable", result,
-                false, ownerObjectId, localPoolId);
-        return result;
-    }
+  PoolEntry<T>* poolEntry = nullptr;
+  ReturnValue_t result =
+      LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
+  if (result != RETURN_OK) {
+    object_id_t ownerObjectId = hkManager->getCreatorObjectId();
+    reportReadCommitError("LocalPoolVariable", result, false, ownerObjectId, localPoolId);
+    return result;
+  }
 
-    *(poolEntry->getDataPtr()) = this->value;
-    poolEntry->setValid(this->valid);
-    return RETURN_OK;
+  *(poolEntry->getDataPtr()) = this->value;
+  poolEntry->setValid(this->valid);
+  return RETURN_OK;
 }
 
-template<typename T>
-inline ReturnValue_t LocalPoolVariable<T>::serialize(uint8_t** buffer,
-        size_t* size, const size_t max_size,
-        SerializeIF::Endianness streamEndianness) const {
-    return SerializeAdapter::serialize(&value,
-            buffer, size ,max_size, streamEndianness);
+template <typename T>
+inline ReturnValue_t LocalPoolVariable<T>::serialize(
+    uint8_t** buffer, size_t* size, const size_t max_size,
+    SerializeIF::Endianness streamEndianness) const {
+  return SerializeAdapter::serialize(&value, buffer, size, max_size, streamEndianness);
 }
 
-template<typename T>
+template <typename T>
 inline size_t LocalPoolVariable<T>::getSerializedSize() const {
-    return SerializeAdapter::getSerializedSize(&value);
+  return SerializeAdapter::getSerializedSize(&value);
 }
 
-template<typename T>
-inline ReturnValue_t LocalPoolVariable<T>::deSerialize(const uint8_t** buffer,
-        size_t* size, SerializeIF::Endianness streamEndianness) {
-    return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
+template <typename T>
+inline ReturnValue_t LocalPoolVariable<T>::deSerialize(const uint8_t** buffer, size_t* size,
+                                                       SerializeIF::Endianness streamEndianness) {
+  return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
 }
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-template<typename T>
-inline std::ostream& operator<< (std::ostream &out,
-        const LocalPoolVariable<T> &var) {
-    out << var.value;
-    return out;
+template <typename T>
+inline std::ostream& operator<<(std::ostream& out, const LocalPoolVariable<T>& var) {
+  out << var.value;
+  return out;
 }
 #endif
 
-template<typename T>
+template <typename T>
 inline LocalPoolVariable<T>::operator T() const {
-    return value;
+  return value;
 }
 
-template<typename T>
-inline LocalPoolVariable<T> & LocalPoolVariable<T>::operator=(
-        const T& newValue) {
-    value = newValue;
-    return *this;
+template <typename T>
+inline LocalPoolVariable<T>& LocalPoolVariable<T>::operator=(const T& newValue) {
+  value = newValue;
+  return *this;
 }
 
-template<typename T>
-inline LocalPoolVariable<T>& LocalPoolVariable<T>::operator =(
-        const LocalPoolVariable<T>& newPoolVariable) {
-    value = newPoolVariable.value;
-    return *this;
+template <typename T>
+inline LocalPoolVariable<T>& LocalPoolVariable<T>::operator=(
+    const LocalPoolVariable<T>& newPoolVariable) {
+  value = newPoolVariable.value;
+  return *this;
 }
 
-template<typename T>
-inline bool LocalPoolVariable<T>::operator ==(
-        const LocalPoolVariable<T> &other) const {
-    return this->value == other.value;
+template <typename T>
+inline bool LocalPoolVariable<T>::operator==(const LocalPoolVariable<T>& other) const {
+  return this->value == other.value;
 }
 
-template<typename T>
-inline bool LocalPoolVariable<T>::operator ==(const T &other) const {
-    return this->value == other;
+template <typename T>
+inline bool LocalPoolVariable<T>::operator==(const T& other) const {
+  return this->value == other;
 }
 
-
-template<typename T>
-inline bool LocalPoolVariable<T>::operator !=(
-        const LocalPoolVariable<T> &other) const {
-    return not (*this == other);
+template <typename T>
+inline bool LocalPoolVariable<T>::operator!=(const LocalPoolVariable<T>& other) const {
+  return not(*this == other);
 }
 
-template<typename T>
-inline bool LocalPoolVariable<T>::operator !=(const T &other) const {
-    return not (*this == other);
+template <typename T>
+inline bool LocalPoolVariable<T>::operator!=(const T& other) const {
+  return not(*this == other);
 }
 
-
-template<typename T>
-inline bool LocalPoolVariable<T>::operator <(
-        const LocalPoolVariable<T> &other) const {
-    return this->value < other.value;
+template <typename T>
+inline bool LocalPoolVariable<T>::operator<(const LocalPoolVariable<T>& other) const {
+  return this->value < other.value;
 }
 
-template<typename T>
-inline bool LocalPoolVariable<T>::operator <(const T &other) const {
-    return this->value < other;
+template <typename T>
+inline bool LocalPoolVariable<T>::operator<(const T& other) const {
+  return this->value < other;
 }
 
-
-template<typename T>
-inline bool LocalPoolVariable<T>::operator >(
-        const LocalPoolVariable<T> &other) const {
-    return not (*this < other);
+template <typename T>
+inline bool LocalPoolVariable<T>::operator>(const LocalPoolVariable<T>& other) const {
+  return not(*this < other);
 }
 
-template<typename T>
-inline bool LocalPoolVariable<T>::operator >(const T &other) const {
-    return not (*this < other);
+template <typename T>
+inline bool LocalPoolVariable<T>::operator>(const T& other) const {
+  return not(*this < other);
 }
 
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_ */

src/fsfw/datapoollocal/LocalPoolVector.tpp

@@ -5,174 +5,172 @@
 #error Include LocalPoolVector.h before LocalPoolVector.tpp!
 #endif
 
-template<typename T, uint16_t vectorSize>
-inline LocalPoolVector<T, vectorSize>::LocalPoolVector(
-        HasLocalDataPoolIF* hkOwner, lp_id_t poolId, DataSetIF* dataSet,
-        pool_rwm_t setReadWriteMode):
-        LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
+template <typename T, uint16_t vectorSize>
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
+                                                       DataSetIF* dataSet,
+                                                       pool_rwm_t setReadWriteMode)
+    : LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
-template<typename T, uint16_t vectorSize>
-inline LocalPoolVector<T, vectorSize>::LocalPoolVector(object_id_t poolOwner,
-        lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
-        LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
+template <typename T, uint16_t vectorSize>
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(object_id_t poolOwner, lp_id_t poolId,
+                                                       DataSetIF* dataSet,
+                                                       pool_rwm_t setReadWriteMode)
+    : LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
 
-template<typename T, uint16_t vectorSize>
-inline LocalPoolVector<T, vectorSize>::LocalPoolVector(gp_id_t globalPoolId,
-        DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
-        LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
-                dataSet, setReadWriteMode) {}
+template <typename T, uint16_t vectorSize>
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(gp_id_t globalPoolId, DataSetIF* dataSet,
+                                                       pool_rwm_t setReadWriteMode)
+    : LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId, dataSet,
+                          setReadWriteMode) {}
 
-template<typename T, uint16_t vectorSize>
-inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(
-        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-    MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
-    return readWithoutLock();
+template <typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(MutexIF::TimeoutType timeoutType,
+                                                          uint32_t timeoutMs) {
+  MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
+  return readWithoutLock();
 }
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
-    if(readWriteMode == pool_rwm_t::VAR_WRITE) {
-        object_id_t targetObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVector",
-                PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
-                localPoolId);
-        return PoolVariableIF::INVALID_READ_WRITE_MODE;
-    }
+  if (readWriteMode == pool_rwm_t::VAR_WRITE) {
+    object_id_t targetObjectId = hkManager->getCreatorObjectId();
+    reportReadCommitError("LocalPoolVector", PoolVariableIF::INVALID_READ_WRITE_MODE, true,
+                          targetObjectId, localPoolId);
+    return PoolVariableIF::INVALID_READ_WRITE_MODE;
+  }
 
-    PoolEntry<T>* poolEntry = nullptr;
-    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
-            &poolEntry);
-    memset(this->value, 0, vectorSize * sizeof(T));
+  PoolEntry<T>* poolEntry = nullptr;
+  ReturnValue_t result =
+      LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
+  memset(this->value, 0, vectorSize * sizeof(T));
 
-    if(result != RETURN_OK) {
-        object_id_t targetObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVector", result, true, targetObjectId,
-                localPoolId);
-        return result;
-    }
-    std::memcpy(this->value, poolEntry->getDataPtr(), poolEntry->getByteSize());
-    this->valid = poolEntry->getValid();
-    return RETURN_OK;
+  if (result != RETURN_OK) {
+    object_id_t targetObjectId = hkManager->getCreatorObjectId();
+    reportReadCommitError("LocalPoolVector", result, true, targetObjectId, localPoolId);
+    return result;
+  }
+  std::memcpy(this->value, poolEntry->getDataPtr(), poolEntry->getByteSize());
+  this->valid = poolEntry->getValid();
+  return RETURN_OK;
 }
 
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(bool valid,
-        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-    this->setValid(valid);
-    return commit(timeoutType, timeoutMs);
+                                                            MutexIF::TimeoutType timeoutType,
+                                                            uint32_t timeoutMs) {
+  this->setValid(valid);
+  return commit(timeoutType, timeoutMs);
 }
 
-template<typename T, uint16_t vectorSize>
-inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
-        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-    MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
-    return commitWithoutLock();
+template <typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(MutexIF::TimeoutType timeoutType,
+                                                            uint32_t timeoutMs) {
+  MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
+  return commitWithoutLock();
 }
 
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
-    if(readWriteMode == pool_rwm_t::VAR_READ) {
-        object_id_t targetObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVector",
-                PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
-                localPoolId);
-        return PoolVariableIF::INVALID_READ_WRITE_MODE;
-    }
-    PoolEntry<T>* poolEntry = nullptr;
-    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
-            &poolEntry);
-    if(result != RETURN_OK) {
-        object_id_t targetObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVector", result, false, targetObjectId,
-                localPoolId);
-        return result;
-    }
-    std::memcpy(poolEntry->getDataPtr(), this->value, poolEntry->getByteSize());
-    poolEntry->setValid(this->valid);
-    return RETURN_OK;
-}
-
-template<typename T, uint16_t vectorSize>
-inline T& LocalPoolVector<T, vectorSize>::operator [](size_t i) {
-    if(i < vectorSize) {
-        return value[i];
-    }
-    // If this happens, I have to set some value. I consider this
-    // a configuration error, but I wont exit here.
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
-            " last value!" << std::endl;
-#else
-    sif::printWarning("LocalPoolVector: Invalid index. Setting or returning"
-            " last value!\n");
-#endif
-    return value[vectorSize - 1];
-}
-
-template<typename T, uint16_t vectorSize>
-inline const T& LocalPoolVector<T, vectorSize>::operator [](size_t i) const {
-    if(i < vectorSize) {
-        return value[i];
-    }
-    // If this happens, I have to set some value. I consider this
-    // a configuration error, but I wont exit here.
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
-            " last value!" << std::endl;
-#else
-    sif::printWarning("LocalPoolVector: Invalid index. Setting or returning"
-            " last value!\n");
-#endif
-    return value[vectorSize - 1];
-}
-
-template<typename T, uint16_t vectorSize>
-inline ReturnValue_t LocalPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
-        size_t* size, size_t maxSize,
-        SerializeIF::Endianness streamEndianness) const {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-    for (uint16_t i = 0; i < vectorSize; i++) {
-        result = SerializeAdapter::serialize(&(value[i]), buffer, size,
-                maxSize, streamEndianness);
-        if (result != HasReturnvaluesIF::RETURN_OK) {
-            break;
-        }
-    }
+  if (readWriteMode == pool_rwm_t::VAR_READ) {
+    object_id_t targetObjectId = hkManager->getCreatorObjectId();
+    reportReadCommitError("LocalPoolVector", PoolVariableIF::INVALID_READ_WRITE_MODE, false,
+                          targetObjectId, localPoolId);
+    return PoolVariableIF::INVALID_READ_WRITE_MODE;
+  }
+  PoolEntry<T>* poolEntry = nullptr;
+  ReturnValue_t result =
+      LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
+  if (result != RETURN_OK) {
+    object_id_t targetObjectId = hkManager->getCreatorObjectId();
+    reportReadCommitError("LocalPoolVector", result, false, targetObjectId, localPoolId);
     return result;
+  }
+  std::memcpy(poolEntry->getDataPtr(), this->value, poolEntry->getByteSize());
+  poolEntry->setValid(this->valid);
+  return RETURN_OK;
 }
 
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
+inline T& LocalPoolVector<T, vectorSize>::operator[](size_t i) {
+  if (i < vectorSize) {
+    return value[i];
+  }
+  // If this happens, I have to set some value. I consider this
+  // a configuration error, but I wont exit here.
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
+                  " last value!"
+               << std::endl;
+#else
+  sif::printWarning(
+      "LocalPoolVector: Invalid index. Setting or returning"
+      " last value!\n");
+#endif
+  return value[vectorSize - 1];
+}
+
+template <typename T, uint16_t vectorSize>
+inline const T& LocalPoolVector<T, vectorSize>::operator[](size_t i) const {
+  if (i < vectorSize) {
+    return value[i];
+  }
+  // If this happens, I have to set some value. I consider this
+  // a configuration error, but I wont exit here.
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
+                  " last value!"
+               << std::endl;
+#else
+  sif::printWarning(
+      "LocalPoolVector: Invalid index. Setting or returning"
+      " last value!\n");
+#endif
+  return value[vectorSize - 1];
+}
+
+template <typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::serialize(
+    uint8_t** buffer, size_t* size, size_t maxSize,
+    SerializeIF::Endianness streamEndianness) const {
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+  for (uint16_t i = 0; i < vectorSize; i++) {
+    result = SerializeAdapter::serialize(&(value[i]), buffer, size, maxSize, streamEndianness);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      break;
+    }
+  }
+  return result;
+}
+
+template <typename T, uint16_t vectorSize>
 inline size_t LocalPoolVector<T, vectorSize>::getSerializedSize() const {
-    return vectorSize * SerializeAdapter::getSerializedSize(value);
+  return vectorSize * SerializeAdapter::getSerializedSize(value);
 }
 
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::deSerialize(
-        const uint8_t** buffer, size_t* size,
-        SerializeIF::Endianness streamEndianness) {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-    for (uint16_t i = 0; i < vectorSize; i++) {
-        result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
-                streamEndianness);
-        if (result != HasReturnvaluesIF::RETURN_OK) {
-            break;
-        }
+    const uint8_t** buffer, size_t* size, SerializeIF::Endianness streamEndianness) {
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+  for (uint16_t i = 0; i < vectorSize; i++) {
+    result = SerializeAdapter::deSerialize(&(value[i]), buffer, size, streamEndianness);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      break;
     }
-    return result;
+  }
+  return result;
 }
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-template<typename T, uint16_t vectorSize>
-inline std::ostream& operator<< (std::ostream &out,
-        const LocalPoolVector<T, vectorSize> &var) {
-    out << "Vector: [";
-    for(int i = 0;i < vectorSize; i++) {
-        out << var.value[i];
-        if(i < vectorSize - 1) {
-            out << ", ";
-        }
+template <typename T, uint16_t vectorSize>
+inline std::ostream& operator<<(std::ostream& out, const LocalPoolVector<T, vectorSize>& var) {
+  out << "Vector: [";
+  for (int i = 0; i < vectorSize; i++) {
+    out << var.value[i];
+    if (i < vectorSize - 1) {
+      out << ", ";
     }
-    out << "]";
-    return out;
+  }
+  out << "]";
+  return out;
 }
 #endif
 

src/fsfw/datapoollocal/internal/CMakeLists.txt

@@ -1,5 +1,2 @@
-target_sources(${LIB_FSFW_NAME} 
-	PRIVATE 
-		HasLocalDpIFUserAttorney.cpp
-		HasLocalDpIFManagerAttorney.cpp
-)
+target_sources(${LIB_FSFW_NAME} PRIVATE HasLocalDpIFUserAttorney.cpp
+                                        HasLocalDpIFManagerAttorney.cpp)

src/fsfw/devicehandlers/CMakeLists.txt

@@ -1,11 +1,10 @@
-target_sources(${LIB_FSFW_NAME} 
-	PRIVATE 
-		AssemblyBase.cpp
-		ChildHandlerBase.cpp
-		ChildHandlerFDIR.cpp
-		DeviceHandlerBase.cpp
-		DeviceHandlerFailureIsolation.cpp
-		DeviceHandlerMessage.cpp
-		DeviceTmReportingWrapper.cpp
-		HealthDevice.cpp
-)
+target_sources(
+  ${LIB_FSFW_NAME}
+  PRIVATE AssemblyBase.cpp
+          ChildHandlerBase.cpp
+          ChildHandlerFDIR.cpp
+          DeviceHandlerBase.cpp
+          DeviceHandlerFailureIsolation.cpp
+          DeviceHandlerMessage.cpp
+          DeviceTmReportingWrapper.cpp
+          HealthDevice.cpp)

src/fsfw/devicehandlers/DeviceHandlerBase.cpp

@@ -243,17 +243,28 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 }
 
 void DeviceHandlerBase::decrementDeviceReplyMap() {
+  bool timedOut = false;
   for (std::pair<const DeviceCommandId_t, DeviceReplyInfo>& replyPair : deviceReplyMap) {
-    if (replyPair.second.delayCycles != 0) {
+    if (replyPair.second.countdown != nullptr && replyPair.second.active) {
+      if (replyPair.second.countdown->hasTimedOut()) {
+        timedOut = true;
+      }
+    }
+    if (replyPair.second.delayCycles != 0 && replyPair.second.countdown == nullptr) {
       replyPair.second.delayCycles--;
       if (replyPair.second.delayCycles == 0) {
         if (replyPair.second.periodic) {
           replyPair.second.delayCycles = replyPair.second.maxDelayCycles;
         }
-        replyToReply(replyPair.first, replyPair.second, TIMEOUT);
-        missedReply(replyPair.first);
+        timedOut = true;
       }
     }
+    if (timedOut) {
+      replyToReply(replyPair.first, replyPair.second, TIMEOUT);
+      missedReply(replyPair.first);
+      timedOut = false;
+      replyPair.second.active = false;
+    }
   }
 }
 
@@ -416,20 +427,22 @@ ReturnValue_t DeviceHandlerBase::isModeCombinationValid(Mode_t mode, Submode_t s
 
 ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(
     DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles, LocalPoolDataSetBase* replyDataSet,
-    size_t replyLen, bool periodic, bool hasDifferentReplyId, DeviceCommandId_t replyId) {
+    size_t replyLen, bool periodic, bool hasDifferentReplyId, DeviceCommandId_t replyId,
+    Countdown* countdown) {
   // No need to check, as we may try to insert multiple times.
   insertInCommandMap(deviceCommand, hasDifferentReplyId, replyId);
   if (hasDifferentReplyId) {
-    return insertInReplyMap(replyId, maxDelayCycles, replyDataSet, replyLen, periodic);
+    return insertInReplyMap(replyId, maxDelayCycles, replyDataSet, replyLen, periodic, countdown);
   } else {
-    return insertInReplyMap(deviceCommand, maxDelayCycles, replyDataSet, replyLen, periodic);
+    return insertInReplyMap(deviceCommand, maxDelayCycles, replyDataSet, replyLen, periodic,
+                            countdown);
   }
 }
 
 ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
                                                   uint16_t maxDelayCycles,
                                                   LocalPoolDataSetBase* dataSet, size_t replyLen,
-                                                  bool periodic) {
+                                                  bool periodic, Countdown* countdown) {
   DeviceReplyInfo info;
   info.maxDelayCycles = maxDelayCycles;
   info.periodic = periodic;
@@ -437,6 +450,10 @@ ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
   info.replyLen = replyLen;
   info.dataSet = dataSet;
   info.command = deviceCommandMap.end();
+  info.countdown = countdown;
+  if (info.periodic) {
+    info.active = true;
+  }
   auto resultPair = deviceReplyMap.emplace(replyId, info);
   if (resultPair.second) {
     return RETURN_OK;
@@ -472,7 +489,8 @@ size_t DeviceHandlerBase::getNextReplyLength(DeviceCommandId_t commandId) {
   }
   DeviceReplyIter iter = deviceReplyMap.find(replyId);
   if (iter != deviceReplyMap.end()) {
-    if (iter->second.delayCycles != 0) {
+    if ((iter->second.delayCycles != 0 && iter->second.countdown == nullptr) ||
+        (iter->second.active && iter->second.countdown != nullptr)) {
       return iter->second.replyLen;
     }
   }
@@ -554,6 +572,9 @@ void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
   mode = newMode;
   modeChanged();
   setNormalDatapoolEntriesInvalid();
+  if (newMode == MODE_OFF) {
+    disableCommandsAndReplies();
+  }
   if (!isTransitionalMode()) {
     modeHelper.modeChanged(newMode, newSubmode);
     announceMode(false);
@@ -816,17 +837,18 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData, DeviceCommandId
 
   DeviceReplyInfo* info = &(iter->second);
 
-  if (info->delayCycles != 0) {
+  if ((info->delayCycles != 0 && info->countdown == nullptr) ||
+      (info->active && info->countdown != nullptr)) {
     result = interpretDeviceReply(foundId, receivedData);
 
     if (result == IGNORE_REPLY_DATA) {
       return;
     }
 
-    if (info->periodic) {
-      info->delayCycles = info->maxDelayCycles;
-    } else {
-      info->delayCycles = 0;
+    if (info->active && info->countdown != nullptr) {
+      disableTimeoutControlledReply(info);
+    } else if (info->delayCycles != 0) {
+      disableDelayCyclesControlledReply(info);
     }
 
     if (result != RETURN_OK) {
@@ -845,6 +867,24 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData, DeviceCommandId
   }
 }
 
+void DeviceHandlerBase::disableTimeoutControlledReply(DeviceReplyInfo* info) {
+  if (info->periodic) {
+    info->countdown->resetTimer();
+  } else {
+    info->active = false;
+    info->countdown->timeOut();
+  }
+}
+
+void DeviceHandlerBase::disableDelayCyclesControlledReply(DeviceReplyInfo* info) {
+  if (info->periodic) {
+    info->delayCycles = info->maxDelayCycles;
+  } else {
+    info->delayCycles = 0;
+    info->active = false;
+  }
+}
+
 ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress, uint8_t** data,
                                                 size_t* len) {
   size_t lenTmp;
@@ -970,6 +1010,10 @@ ReturnValue_t DeviceHandlerBase::enableReplyInReplyMap(DeviceCommandMap::iterato
     info->delayCycles = info->maxDelayCycles;
     info->command = command;
     command->second.expectedReplies = expectedReplies;
+    if (info->countdown != nullptr) {
+      info->countdown->resetTimer();
+    }
+    info->active = true;
     return RETURN_OK;
   } else {
     return NO_REPLY_EXPECTED;
@@ -1204,7 +1248,8 @@ void DeviceHandlerBase::setParentQueue(MessageQueueId_t parentQueueId) {
 bool DeviceHandlerBase::isAwaitingReply() {
   std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter;
   for (iter = deviceReplyMap.begin(); iter != deviceReplyMap.end(); ++iter) {
-    if (iter->second.delayCycles != 0) {
+    if ((iter->second.delayCycles != 0 && iter->second.countdown == nullptr) ||
+        (iter->second.active && iter->second.countdown != nullptr)) {
       return true;
     }
   }
@@ -1359,6 +1404,8 @@ uint8_t DeviceHandlerBase::getReplyDelayCycles(DeviceCommandId_t deviceCommand)
   DeviceReplyMap::iterator iter = deviceReplyMap.find(deviceCommand);
   if (iter == deviceReplyMap.end()) {
     return 0;
+  } else if (iter->second.countdown != nullptr) {
+    return 0;
   }
   return iter->second.delayCycles;
 }
@@ -1523,3 +1570,22 @@ void DeviceHandlerBase::setParent(object_id_t parent) { this->parent = parent; }
 void DeviceHandlerBase::setPowerSwitcher(PowerSwitchIF* switcher) {
   this->powerSwitcher = switcher;
 }
+
+void DeviceHandlerBase::disableCommandsAndReplies() {
+  for (auto& command : deviceCommandMap) {
+    if (command.second.isExecuting) {
+      command.second.isExecuting = false;
+    }
+  }
+  for (auto& reply : deviceReplyMap) {
+    if (!reply.second.periodic) {
+      if (reply.second.countdown != nullptr) {
+        reply.second.countdown->timeOut();
+      }
+      else {
+        reply.second.delayCycles = 0;
+      }
+      reply.second.active = false;
+    }
+  }
+}

src/fsfw/devicehandlers/DeviceHandlerBase.h

@@ -166,7 +166,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * @param counter Specifies which Action to perform
    * @return RETURN_OK for successful execution
    */
-  virtual ReturnValue_t performOperation(uint8_t counter);
+  virtual ReturnValue_t performOperation(uint8_t counter) override;
 
   /**
    * @brief  Initializes the device handler
@@ -176,7 +176,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * Calls fillCommandAndReplyMap().
    * @return
    */
-  virtual ReturnValue_t initialize();
+  virtual ReturnValue_t initialize() override;
 
   /**
    * @brief   Intialization steps performed after all tasks have been created.
@@ -451,6 +451,9 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * by the device repeatedly without request) or not. Default is aperiodic (0).
    * Please note that periodic replies are disabled by default. You can enable them with
    * #updatePeriodicReply
+   * @param countdown Instead of using maxDelayCycles to timeout a device reply it is also possible
+   *                  to provide a pointer to a Countdown object which will signal the timeout
+   *                  when expired
    * @return	- @c RETURN_OK when the command was successfully inserted,
    *          - @c RETURN_FAILED else.
    */
@@ -458,22 +461,26 @@ class DeviceHandlerBase : public DeviceHandlerIF,
                                            LocalPoolDataSetBase *replyDataSet = nullptr,
                                            size_t replyLen = 0, bool periodic = false,
                                            bool hasDifferentReplyId = false,
-                                           DeviceCommandId_t replyId = 0);
+                                           DeviceCommandId_t replyId = 0,
+                                           Countdown *countdown = nullptr);
   /**
    * @brief 	This is a helper method to insert replies in the reply map.
    * @param deviceCommand	Identifier of the reply to add.
    * @param maxDelayCycles The maximum number of delay cycles the reply waits
-   * until it times out.
+   *    until it times out.
    * @param periodic	Indicates if the command is periodic (i.e. it is sent
-   * by the device repeatedly without request) or not. Default is aperiodic (0).
-   * Please note that periodic replies are disabled by default. You can enable them with
-   * #updatePeriodicReply
+   *    by the device repeatedly without request) or not. Default is aperiodic (0).
+   *    Please note that periodic replies are disabled by default. You can enable them with
+   *    #updatePeriodicReply
+   * @param countdown Instead of using maxDelayCycles to timeout a device reply it is also possible
+   *    to provide a pointer to a Countdown object which will signal the timeout
+   *    when expired
    * @return	- @c RETURN_OK when the command was successfully inserted,
    *          - @c RETURN_FAILED else.
    */
   ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles,
                                  LocalPoolDataSetBase *dataSet = nullptr, size_t replyLen = 0,
-                                 bool periodic = false);
+                                 bool periodic = false, Countdown *countdown = nullptr);
 
   /**
    * @brief   A simple command to add a command to the commandList.
@@ -776,11 +783,18 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * This is used to keep track of pending replies.
    */
   struct DeviceReplyInfo {
+    //! For Command-Reply combinations:
     //! The maximum number of cycles the handler should wait for a reply
     //! to this command.
+    //!
+    //! Reply Only:
+    //! For periodic replies, this variable will be the number of delay cycles between the replies.
+    //! For the non-periodic variant, this variable is not used as there is no meaningful
+    //! definition for delay
     uint16_t maxDelayCycles;
-    //! The currently remaining cycles the handler should wait for a reply,
-    //! 0 means there is no reply expected
+    //! This variable will be set to #maxDelayCycles if a reply is expected.
+    //! For non-periodic replies without a command, this variable is unused.
+    //! A runtime value of 0 means there is no reply is currently expected.
     uint16_t delayCycles;
     size_t replyLen = 0;  //!< Expected size of the reply.
     //! if this is !=0, the delayCycles will not be reset to 0 but to
@@ -792,6 +806,11 @@ class DeviceHandlerBase : public DeviceHandlerIF,
     LocalPoolDataSetBase *dataSet = nullptr;
     //! The command that expects this reply.
     DeviceCommandMap::iterator command;
+    //! Instead of using delayCycles to specify the maximum time to wait for the device reply, it
+    //! is also possible specify a countdown
+    Countdown *countdown = nullptr;
+    //! will be set to true when reply is enabled
+    bool active = false;
   };
 
   using DeviceReplyMap = std::map<DeviceCommandId_t, DeviceReplyInfo>;
@@ -1068,11 +1087,12 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * @param parameter1	Optional parameter 1
    * @param parameter2	Optional parameter 2
    */
-  void triggerEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0);
+  void triggerEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) override;
   /**
    * Same as triggerEvent, but for forwarding if object is used as proxy.
    */
-  virtual void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const;
+  virtual void forwardEvent(Event event, uint32_t parameter1 = 0,
+                            uint32_t parameter2 = 0) const override;
 
   /**
    * Checks if current mode is transitional mode.
@@ -1253,6 +1273,17 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    */
   void doGetRead(void);
 
+  /**
+   * @brief Handles disabling of replies which use a timeout to detect missed replies.
+   */
+  void disableTimeoutControlledReply(DeviceReplyInfo *info);
+
+  /**
+   * @brief Handles disabling of replies which use a number of maximum delay cycles to detect
+   *        missed replies.
+   */
+  void disableDelayCyclesControlledReply(DeviceReplyInfo *info);
+
   /**
    * Retrive data from the #IPCStore.
    *
@@ -1294,6 +1325,11 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   void printWarningOrError(sif::OutputTypes errorType, const char *functionName,
                            ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_FAILED,
                            const char *errorPrint = nullptr);
+
+  /**
+   * @brief Disables all commands and replies when device is set to MODE_OFF
+   */
+  void disableCommandsAndReplies();
 };
 
 #endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */

src/fsfw/events/CMakeLists.txt

@@ -1,6 +1,3 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE 
-    EventManager.cpp
-    EventMessage.cpp
-)
+target_sources(${LIB_FSFW_NAME} PRIVATE EventManager.cpp EventMessage.cpp)
 
 add_subdirectory(eventmatching)

src/fsfw/events/eventmatching/CMakeLists.txt

@@ -1,7 +1,3 @@
-target_sources(${LIB_FSFW_NAME} 
-	PRIVATE 
-		EventIdRangeMatcher.cpp
-		EventMatchTree.cpp
-		ReporterRangeMatcher.cpp
-		SeverityRangeMatcher.cpp
-)
+target_sources(
+  ${LIB_FSFW_NAME} PRIVATE EventIdRangeMatcher.cpp EventMatchTree.cpp
+                           ReporterRangeMatcher.cpp SeverityRangeMatcher.cpp)

src/fsfw/events/fwSubsystemIdRanges.h

@@ -27,6 +27,7 @@ enum : uint8_t {
   PUS_SERVICE_6 = 86,
   PUS_SERVICE_8 = 88,
   PUS_SERVICE_9 = 89,
+  PUS_SERVICE_11 = 91,
   PUS_SERVICE_17 = 97,
   PUS_SERVICE_23 = 103,
   MGM_LIS3MDL = 106,

src/fsfw/fdir/CMakeLists.txt

@@ -1,6 +1,3 @@
-target_sources(${LIB_FSFW_NAME} 
-	PRIVATE 
-		EventCorrelation.cpp
-		FailureIsolationBase.cpp
-		FaultCounter.cpp
-)
+target_sources(
+  ${LIB_FSFW_NAME} PRIVATE EventCorrelation.cpp FailureIsolationBase.cpp
+                           FaultCounter.cpp)

src/fsfw/globalfunctions/CMakeLists.txt

@@ -1,13 +1,13 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
-    arrayprinter.cpp
-    AsciiConverter.cpp
-    CRC.cpp
-    DleEncoder.cpp
-    DleParser.cpp
-    PeriodicOperationDivider.cpp
-    timevalOperations.cpp
-    Type.cpp
-    bitutility.cpp
-)
+target_sources(
+  ${LIB_FSFW_NAME}
+  PRIVATE arrayprinter.cpp
+          AsciiConverter.cpp
+          CRC.cpp
+          DleEncoder.cpp
+          DleParser.cpp
+          PeriodicOperationDivider.cpp
+          timevalOperations.cpp
+          Type.cpp
+          bitutility.cpp)
 
 add_subdirectory(math)

src/fsfw/globalfunctions/DleParser.cpp

@@ -1,6 +1,5 @@
 #include "DleParser.h"
 
-#include <fsfw/globalfunctions/DleEncoder.h>
 #include <fsfw/serviceinterface/ServiceInterface.h>
 
 #include <cstdio>

src/fsfw/globalfunctions/DleParser.h

@@ -1,5 +1,4 @@
-#ifndef MISSION_DEVICES_DLEPARSER_H_
-#define MISSION_DEVICES_DLEPARSER_H_
+#pragma once
 
 #include <fsfw/container/SimpleRingBuffer.h>
 #include <fsfw/globalfunctions/DleEncoder.h>
@@ -123,5 +122,3 @@ class DleParser : public HasReturnvaluesIF {
   Context ctx;
   bool startFound = false;
 };
-
-#endif /* MISSION_DEVICES_DLEPARSER_H_ */

src/fsfw/globalfunctions/matching/MatchTree.h

@@ -25,7 +25,7 @@ class MatchTree : public SerializeableMatcherIF<T>, public BinaryTree<Serializea
       : BinaryTree<SerializeableMatcherIF<T>>(root.element), maxDepth(maxDepth) {}
   MatchTree() : BinaryTree<SerializeableMatcherIF<T>>(), maxDepth(-1) {}
   virtual ~MatchTree() {}
-  virtual bool match(T number) { return matchesTree(number); }
+  virtual bool match(T number) override { return matchesTree(number); }
   bool matchesTree(T number) {
     iterator iter = this->begin();
     if (iter == this->end()) {

src/fsfw/globalfunctions/matching/RangeMatcher.h

@@ -15,7 +15,7 @@ class RangeMatcher : public SerializeableMatcherIF<T> {
   RangeMatcher(T lowerBound, T upperBound, bool inverted = false)
       : inverted(inverted), lowerBound(lowerBound), upperBound(upperBound) {}
 
-  bool match(T input) {
+  bool match(T input) override {
     if (inverted) {
       return !doMatch(input);
     } else {

src/fsfw/globalfunctions/math/CMakeLists.txt

@@ -1,4 +1 @@
-target_sources(${LIB_FSFW_NAME} 
-	PRIVATE 
-		QuaternionOperations.cpp
-)
+target_sources(${LIB_FSFW_NAME} PRIVATE QuaternionOperations.cpp)

src/fsfw/health/CMakeLists.txt

@@ -1,6 +1,2 @@
-target_sources(${LIB_FSFW_NAME} 
-	PRIVATE 
-		HealthHelper.cpp
-		HealthMessage.cpp
-		HealthTable.cpp	
-)
+target_sources(${LIB_FSFW_NAME} PRIVATE HealthHelper.cpp HealthMessage.cpp
+                                        HealthTable.cpp)

src/fsfw/health/HasHealthIF.h

@@ -16,10 +16,15 @@ class HasHealthIF {
   };
 
   static const uint8_t INTERFACE_ID = CLASS_ID::HAS_HEALTH_IF;
-  static const ReturnValue_t OBJECT_NOT_HEALTHY = MAKE_RETURN_CODE(1);
-  static const ReturnValue_t INVALID_HEALTH_STATE = MAKE_RETURN_CODE(2);
+  static constexpr ReturnValue_t OBJECT_NOT_HEALTHY =
+      HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 1);
+  static constexpr ReturnValue_t INVALID_HEALTH_STATE =
+      HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 2);
+  static constexpr ReturnValue_t IS_EXTERNALLY_CONTROLLED =
+      HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 3);
 
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER_1;
+  //! P1: New Health, P2: Old Health
   static const Event HEALTH_INFO = MAKE_EVENT(6, severity::INFO);
   static const Event CHILD_CHANGED_HEALTH = MAKE_EVENT(7, severity::INFO);
   static const Event CHILD_PROBLEMS = MAKE_EVENT(8, severity::LOW);

src/fsfw/housekeeping/CMakeLists.txt

@@ -1,5 +1,2 @@
-target_sources(${LIB_FSFW_NAME} 
-	PRIVATE 
-		HousekeepingMessage.cpp
-		PeriodicHousekeepingHelper.cpp
-)
+target_sources(${LIB_FSFW_NAME} PRIVATE HousekeepingMessage.cpp
+                                        PeriodicHousekeepingHelper.cpp)

src/fsfw/internalerror/CMakeLists.txt

@@ -1,4 +1 @@
-target_sources(${LIB_FSFW_NAME} 
-	PRIVATE 
-		InternalErrorReporter.cpp
-)
+target_sources(${LIB_FSFW_NAME} PRIVATE InternalErrorReporter.cpp)

src/fsfw/ipc/CMakeLists.txt

@@ -1,6 +1,3 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
-    CommandMessage.cpp
-    CommandMessageCleaner.cpp
-    MessageQueueMessage.cpp
-    MessageQueueBase.cpp
-)
+target_sources(
+  ${LIB_FSFW_NAME} PRIVATE CommandMessage.cpp CommandMessageCleaner.cpp
+                           MessageQueueMessage.cpp MessageQueueBase.cpp)

src/fsfw/ipc/CommandMessageIF.h

@@ -34,7 +34,7 @@ class CommandMessageIF {
   static const Command_t CMD_NONE = MAKE_COMMAND_ID(0);
   static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID(1);
   //! Reply indicating that the current command was rejected,
-  //! par1 should contain the error code
+  //! Parameter 1 should contain the error code
   static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID(2);
 
   virtual ~CommandMessageIF(){};

src/fsfw/memory/CMakeLists.txt

@@ -1,5 +1,2 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
-    MemoryHelper.cpp
-    MemoryMessage.cpp
-    GenericFileSystemMessage.cpp
-)
+target_sources(${LIB_FSFW_NAME} PRIVATE MemoryHelper.cpp MemoryMessage.cpp
+                                        GenericFileSystemMessage.cpp)

src/fsfw/modes/CMakeLists.txt

@@ -1,5 +1 @@
-target_sources(${LIB_FSFW_NAME} 
-	PRIVATE 
-		ModeHelper.cpp
-		ModeMessage.cpp
-)
+target_sources(${LIB_FSFW_NAME} PRIVATE ModeHelper.cpp ModeMessage.cpp)

src/fsfw/monitoring/CMakeLists.txt

@@ -1,5 +1,2 @@
-target_sources(${LIB_FSFW_NAME} 
-	PRIVATE 
-		LimitViolationReporter.cpp
-		MonitoringMessage.cpp
-)
+target_sources(${LIB_FSFW_NAME} PRIVATE LimitViolationReporter.cpp
+                                        MonitoringMessage.cpp)

src/fsfw/monitoring/MonitoringMessageContent.h

@@ -34,7 +34,7 @@ class MonitoringReportContent : public SerialLinkedListAdapter<SerializeIF> {
   SerializeElement<T> limitValue;
   SerializeElement<ReturnValue_t> oldState;
   SerializeElement<ReturnValue_t> newState;
-  uint8_t rawTimestamp[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
+  uint8_t rawTimestamp[TimeStamperIF::MISSION_TIMESTAMP_SIZE] = {};
   SerializeElement<SerialBufferAdapter<uint8_t>> timestampSerializer;
   TimeStamperIF* timeStamper;
   MonitoringReportContent()
@@ -46,7 +46,6 @@ class MonitoringReportContent : public SerialLinkedListAdapter<SerializeIF> {
         limitValue(0),
         oldState(0),
         newState(0),
-        rawTimestamp({0}),
         timestampSerializer(rawTimestamp, sizeof(rawTimestamp)),
         timeStamper(NULL) {
     setAllNext();

src/fsfw/objectmanager/CMakeLists.txt

@@ -1,5 +1 @@
-target_sources(${LIB_FSFW_NAME} 
-	PRIVATE 
-		ObjectManager.cpp
-		SystemObject.cpp
-)
+target_sources(${LIB_FSFW_NAME} PRIVATE ObjectManager.cpp SystemObject.cpp)

src/fsfw/objectmanager/SystemObject.h

@@ -48,9 +48,10 @@ class SystemObject : public SystemObjectIF {
   virtual ~SystemObject();
   object_id_t getObjectId() const override;
   virtual ReturnValue_t initialize() override;
-  virtual ReturnValue_t checkObjectConnections();
+  virtual ReturnValue_t checkObjectConnections() override;
 
-  virtual void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const;
+  virtual void forwardEvent(Event event, uint32_t parameter1 = 0,
+                            uint32_t parameter2 = 0) const override;
 };
 
 #endif /* FSFW_OBJECTMANAGER_SYSTEMOBJECT_H_ */

src/fsfw/objectmanager/frameworkObjects.h

@@ -14,6 +14,7 @@ enum framework_objects : object_id_t {
   PUS_SERVICE_5_EVENT_REPORTING = 0x53000005,
   PUS_SERVICE_8_FUNCTION_MGMT = 0x53000008,
   PUS_SERVICE_9_TIME_MGMT = 0x53000009,
+  PUS_SERVICE_11_TC_SCHEDULER = 0x53000011,
   PUS_SERVICE_17_TEST = 0x53000017,
   PUS_SERVICE_20_PARAMETERS = 0x53000020,
   PUS_SERVICE_200_MODE_MGMT = 0x53000200,

src/fsfw/osal/CMakeLists.txt

@@ -1,35 +1,33 @@
 # Check the OS_FSFW variable
 if(FSFW_OSAL MATCHES "freertos")
-    add_subdirectory(freertos)
+  add_subdirectory(freertos)
 elseif(FSFW_OSAL MATCHES "rtems")
-    add_subdirectory(rtems)
+  add_subdirectory(rtems)
 elseif(FSFW_OSAL MATCHES "linux")
-    add_subdirectory(linux)
+  add_subdirectory(linux)
 elseif(FSFW_OSAL MATCHES "host")
-    add_subdirectory(host)
-    if (WIN32)
-        add_subdirectory(windows)
-    elseif(UNIX)
-        # We still need to pull in some Linux specific sources
-        target_sources(${LIB_FSFW_NAME} PUBLIC
-            linux/tcpipHelpers.cpp
-        )
-    endif ()
+  add_subdirectory(host)
+  if(WIN32)
+    add_subdirectory(windows)
+  elseif(UNIX)
+    # We still need to pull in some Linux specific sources
+    target_sources(${LIB_FSFW_NAME} PUBLIC linux/tcpipHelpers.cpp)
+  endif()
 
 else()
 
-    message(WARNING "The OS_FSFW variable was not set. Assuming host OS..")
-    # Not set. Assumuing this is a host build, try to determine host OS
-    if (WIN32)
-        add_subdirectory(host)
-        add_subdirectory(windows)
-    elseif (UNIX)
-        add_subdirectory(linux)
-    else ()
-        # MacOS or other OSes have not been tested yet / are not supported.
-        message(FATAL_ERROR "The host OS could not be determined! Aborting.")
-    endif()
+  message(WARNING "${MSG_PREFIX} The FSFW_OSAL variable was not set. Assuming host OS..")
+  # Not set. Assumuing this is a host build, try to determine host OS
+  if(WIN32)
+    add_subdirectory(host)
+    add_subdirectory(windows)
+  elseif(UNIX)
+    add_subdirectory(linux)
+  else()
+    # MacOS or other OSes have not been tested yet / are not supported.
+    message(FATAL_ERROR "The host OS could not be determined! Aborting.")
+  endif()
 
 endif()
 
-add_subdirectory(common)
+add_subdirectory(common)

src/fsfw/osal/common/CMakeLists.txt

@@ -1,17 +1,10 @@
 if(DEFINED WIN32 OR DEFINED UNIX)
-    target_sources(${LIB_FSFW_NAME} PRIVATE 
-        tcpipCommon.cpp
-        TcpIpBase.cpp
-        UdpTcPollingTask.cpp
-        UdpTmTcBridge.cpp
-        TcpTmTcServer.cpp
-        TcpTmTcBridge.cpp
-    )
+  target_sources(
+    ${LIB_FSFW_NAME}
+    PRIVATE tcpipCommon.cpp TcpIpBase.cpp UdpTcPollingTask.cpp
+            UdpTmTcBridge.cpp TcpTmTcServer.cpp TcpTmTcBridge.cpp)
 endif()
 
 if(WIN32)
-    target_link_libraries(${LIB_FSFW_NAME} PRIVATE
-        wsock32 
-        ws2_32
-    )
-endif()
+  target_link_libraries(${LIB_FSFW_NAME} PRIVATE wsock32 ws2_32)
+endif()

src/fsfw/osal/common/TcpTmTcServer.cpp

@@ -19,6 +19,8 @@
 #include <ws2tcpip.h>
 #elif defined(PLATFORM_UNIX)
 #include <netdb.h>
+
+#include <utility>
 #endif
 
 const std::string TcpTmTcServer::DEFAULT_SERVER_PORT = tcpip::DEFAULT_SERVER_PORT;
@@ -29,7 +31,7 @@ TcpTmTcServer::TcpTmTcServer(object_id_t objectId, object_id_t tmtcTcpBridge,
     : SystemObject(objectId),
       tmtcBridgeId(tmtcTcpBridge),
       receptionMode(receptionMode),
-      tcpConfig(customTcpServerPort),
+      tcpConfig(std::move(customTcpServerPort)),
       receptionBuffer(receptionBufferSize),
       ringBuffer(ringBufferSize, true) {}
 
@@ -103,12 +105,12 @@ ReturnValue_t TcpTmTcServer::initialize() {
 
 TcpTmTcServer::~TcpTmTcServer() { closeSocket(listenerTcpSocket); }
 
-ReturnValue_t TcpTmTcServer::performOperation(uint8_t opCode) {
+[[noreturn]] ReturnValue_t TcpTmTcServer::performOperation(uint8_t opCode) {
   using namespace tcpip;
   // If a connection is accepted, the corresponding socket will be assigned to the new socket
   socket_t connSocket = 0;
-  // sockaddr clientSockAddr = {};
-  // socklen_t connectorSockAddrLen = 0;
+  sockaddr clientSockAddr = {};
+  socklen_t connectorSockAddrLen = 0;
   int retval = 0;
 
   // Listen for connection requests permanently for lifetime of program
@@ -119,8 +121,7 @@ ReturnValue_t TcpTmTcServer::performOperation(uint8_t opCode) {
       continue;
     }
 
-    // connSocket = accept(listenerTcpSocket, &clientSockAddr, &connectorSockAddrLen);
-    connSocket = accept(listenerTcpSocket, nullptr, nullptr);
+    connSocket = accept(listenerTcpSocket, &clientSockAddr, &connectorSockAddrLen);
 
     if (connSocket == INVALID_SOCKET) {
       handleError(Protocol::TCP, ErrorSources::ACCEPT_CALL, 500);
@@ -135,10 +136,10 @@ ReturnValue_t TcpTmTcServer::performOperation(uint8_t opCode) {
     if (retval != 0) {
       handleError(Protocol::TCP, ErrorSources::SHUTDOWN_CALL);
     }
+
     closeSocket(connSocket);
     connSocket = 0;
   }
-  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t TcpTmTcServer::initializeAfterTaskCreation() {
@@ -159,8 +160,8 @@ void TcpTmTcServer::handleServerOperation(socket_t& connSocket) {
 #endif
 
   while (true) {
-    int retval = recv(connSocket, reinterpret_cast<char*>(receptionBuffer.data()),
-                      receptionBuffer.capacity(), tcpConfig.tcpFlags);
+    ssize_t retval = recv(connSocket, reinterpret_cast<char*>(receptionBuffer.data()),
+                          receptionBuffer.capacity(), tcpConfig.tcpFlags);
     if (retval == 0) {
       size_t availableReadData = ringBuffer.getAvailableReadData();
       if (availableReadData > lastRingBufferSize) {
@@ -252,17 +253,17 @@ ReturnValue_t TcpTmTcServer::handleTcReception(uint8_t* spacePacket, size_t pack
   return result;
 }
 
-std::string TcpTmTcServer::getTcpPort() const { return tcpConfig.tcpPort; }
+const std::string& TcpTmTcServer::getTcpPort() const { return tcpConfig.tcpPort; }
 
-void TcpTmTcServer::setSpacePacketParsingOptions(std::vector<uint16_t> validPacketIds) {
-  this->validPacketIds = validPacketIds;
+void TcpTmTcServer::setSpacePacketParsingOptions(std::vector<uint16_t> validPacketIds_) {
+  this->validPacketIds = std::move(validPacketIds_);
 }
 
 TcpTmTcServer::TcpConfig& TcpTmTcServer::getTcpConfigStruct() { return tcpConfig; }
 
 ReturnValue_t TcpTmTcServer::handleTmSending(socket_t connSocket, bool& tmSent) {
   // Access to the FIFO is mutex protected because it is filled by the bridge
-  MutexGuard(tmtcBridge->mutex, tmtcBridge->timeoutType, tmtcBridge->mutexTimeoutMs);
+  MutexGuard mg(tmtcBridge->mutex, tmtcBridge->timeoutType, tmtcBridge->mutexTimeoutMs);
   store_address_t storeId;
   while ((not tmtcBridge->tmFifo->empty()) and
          (tmtcBridge->packetSentCounter < tmtcBridge->sentPacketsPerCycle)) {
@@ -283,8 +284,8 @@ ReturnValue_t TcpTmTcServer::handleTmSending(socket_t connSocket, bool& tmSent)
 #endif
       arrayprinter::print(storeAccessor.data(), storeAccessor.size());
     }
-    int retval = send(connSocket, reinterpret_cast<const char*>(storeAccessor.data()),
-                      storeAccessor.size(), tcpConfig.tcpTmFlags);
+    ssize_t retval = send(connSocket, reinterpret_cast<const char*>(storeAccessor.data()),
+                          storeAccessor.size(), tcpConfig.tcpTmFlags);
     if (retval == static_cast<int>(storeAccessor.size())) {
       // Packet sent, clear FIFO entry
       tmtcBridge->tmFifo->pop();
@@ -339,6 +340,9 @@ ReturnValue_t TcpTmTcServer::handleTcRingBufferData(size_t availableReadData) {
   size_t foundSize = 0;
   size_t readLen = 0;
   while (readLen < readAmount) {
+    if (spacePacketParser == nullptr) {
+      return HasReturnvaluesIF::RETURN_FAILED;
+    }
     result =
         spacePacketParser->parseSpacePackets(bufPtrPtr, readAmount, startIdx, foundSize, readLen);
     switch (result) {

src/fsfw/osal/common/TcpTmTcServer.h

@@ -17,6 +17,7 @@
 #endif
 
 #include <string>
+#include <utility>
 #include <vector>
 
 class TcpTmTcBridge;
@@ -44,7 +45,7 @@ class TcpTmTcServer : public SystemObject, public TcpIpBase, public ExecutableOb
 
   struct TcpConfig {
    public:
-    TcpConfig(std::string tcpPort) : tcpPort(tcpPort) {}
+    explicit TcpConfig(std::string tcpPort) : tcpPort(std::move(tcpPort)) {}
 
     /**
      * Passed to the recv call
@@ -84,7 +85,7 @@ class TcpTmTcServer : public SystemObject, public TcpIpBase, public ExecutableOb
                 size_t ringBufferSize = RING_BUFFER_SIZE,
                 std::string customTcpServerPort = DEFAULT_SERVER_PORT,
                 ReceptionModes receptionMode = ReceptionModes::SPACE_PACKETS);
-  virtual ~TcpTmTcServer();
+  ~TcpTmTcServer() override;
 
   void enableWiretapping(bool enable);
 
@@ -97,10 +98,10 @@ class TcpTmTcServer : public SystemObject, public TcpIpBase, public ExecutableOb
   void setSpacePacketParsingOptions(std::vector<uint16_t> validPacketIds);
 
   ReturnValue_t initialize() override;
-  ReturnValue_t performOperation(uint8_t opCode) override;
+  [[noreturn]] ReturnValue_t performOperation(uint8_t opCode) override;
   ReturnValue_t initializeAfterTaskCreation() override;
 
-  std::string getTcpPort() const;
+  [[nodiscard]] const std::string& getTcpPort() const;
 
  protected:
   StorageManagerIF* tcStore = nullptr;
@@ -115,7 +116,7 @@ class TcpTmTcServer : public SystemObject, public TcpIpBase, public ExecutableOb
 
   ReceptionModes receptionMode;
   TcpConfig tcpConfig;
-  struct sockaddr tcpAddress;
+  struct sockaddr tcpAddress = {};
   socket_t listenerTcpSocket = 0;
 
   MessageQueueId_t targetTcDestination = MessageQueueIF::NO_QUEUE;

src/fsfw/osal/common/UdpTcPollingTask.cpp

@@ -16,11 +16,13 @@
 //! Debugging preprocessor define.
 #define FSFW_UDP_RECV_WIRETAPPING_ENABLED 0
 
+const timeval UdpTcPollingTask::DEFAULT_TIMEOUT = {0, 500000};
+
 UdpTcPollingTask::UdpTcPollingTask(object_id_t objectId, object_id_t tmtcUdpBridge,
                                    size_t maxRecvSize, double timeoutSeconds)
     : SystemObject(objectId), tmtcBridgeId(tmtcUdpBridge) {
-  if (frameSize > 0) {
-    this->frameSize = frameSize;
+  if (maxRecvSize > 0) {
+    this->frameSize = maxRecvSize;
   } else {
     this->frameSize = DEFAULT_MAX_RECV_SIZE;
   }
@@ -31,22 +33,20 @@ UdpTcPollingTask::UdpTcPollingTask(object_id_t objectId, object_id_t tmtcUdpBrid
   receptionBuffer.resize(this->frameSize);
 
   if (timeoutSeconds == -1) {
-    receptionTimeout = DEFAULT_TIMEOUT;
+    receptionTimeout = UdpTcPollingTask::DEFAULT_TIMEOUT;
   } else {
     receptionTimeout = timevalOperations::toTimeval(timeoutSeconds);
   }
 }
 
-UdpTcPollingTask::~UdpTcPollingTask() {}
-
-ReturnValue_t UdpTcPollingTask::performOperation(uint8_t opCode) {
+[[noreturn]] ReturnValue_t UdpTcPollingTask::performOperation(uint8_t opCode) {
   /* Sender Address is cached here. */
-  struct sockaddr senderAddress;
+  struct sockaddr senderAddress {};
   socklen_t senderAddressSize = sizeof(senderAddress);
 
   /* Poll for new UDP datagrams in permanent loop. */
   while (true) {
-    int bytesReceived =
+    ssize_t bytesReceived =
         recvfrom(this->serverSocket, reinterpret_cast<char*>(receptionBuffer.data()), frameSize,
                  receptionFlags, &senderAddress, &senderAddressSize);
     if (bytesReceived == SOCKET_ERROR) {
@@ -70,7 +70,6 @@ ReturnValue_t UdpTcPollingTask::performOperation(uint8_t opCode) {
     }
     tmtcBridge->checkAndSetClientAddress(senderAddress);
   }
-  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t UdpTcPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
@@ -155,7 +154,7 @@ void UdpTcPollingTask::setTimeout(double timeoutSeconds) {
 #endif
   }
 #elif defined(PLATFORM_UNIX)
-  timeval tval;
+  timeval tval{};
   tval = timevalOperations::toTimeval(timeoutSeconds);
   int result = setsockopt(serverSocket, SOL_SOCKET, SO_RCVTIMEO, &tval, sizeof(receptionTimeout));
   if (result == -1) {

src/fsfw/osal/common/UdpTcPollingTask.h

@@ -21,11 +21,11 @@ class UdpTcPollingTask : public TcpIpBase, public SystemObject, public Executabl
  public:
   static constexpr size_t DEFAULT_MAX_RECV_SIZE = 1500;
   //! 0.5  default milliseconds timeout for now.
-  static constexpr timeval DEFAULT_TIMEOUT = {0, 500};
+  static const timeval DEFAULT_TIMEOUT;
 
   UdpTcPollingTask(object_id_t objectId, object_id_t tmtcUdpBridge, size_t maxRecvSize = 0,
                    double timeoutSeconds = -1);
-  virtual ~UdpTcPollingTask();
+  ~UdpTcPollingTask() override = default;
 
   /**
    * Turn on optional timeout for UDP polling. In the default mode,
@@ -34,9 +34,9 @@ class UdpTcPollingTask : public TcpIpBase, public SystemObject, public Executabl
    */
   void setTimeout(double timeoutSeconds);
 
-  virtual ReturnValue_t performOperation(uint8_t opCode) override;
-  virtual ReturnValue_t initialize() override;
-  virtual ReturnValue_t initializeAfterTaskCreation() override;
+  [[noreturn]] ReturnValue_t performOperation(uint8_t opCode) override;
+  ReturnValue_t initialize() override;
+  ReturnValue_t initializeAfterTaskCreation() override;
 
  protected:
   StorageManagerIF* tcStore = nullptr;
@@ -51,7 +51,7 @@ class UdpTcPollingTask : public TcpIpBase, public SystemObject, public Executabl
   std::vector<uint8_t> receptionBuffer;
 
   size_t frameSize = 0;
-  timeval receptionTimeout;
+  timeval receptionTimeout{};
 
   ReturnValue_t handleSuccessfullTcRead(size_t bytesRead);
 };

src/fsfw/osal/common/UdpTmTcBridge.cpp

@@ -20,13 +20,13 @@
 const std::string UdpTmTcBridge::DEFAULT_SERVER_PORT = tcpip::DEFAULT_SERVER_PORT;
 
 UdpTmTcBridge::UdpTmTcBridge(object_id_t objectId, object_id_t tcDestination,
-                             std::string udpServerPort, object_id_t tmStoreId,
+                             const std::string &udpServerPort_, object_id_t tmStoreId,
                              object_id_t tcStoreId)
     : TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
-  if (udpServerPort == "") {
-    this->udpServerPort = DEFAULT_SERVER_PORT;
+  if (udpServerPort_.empty()) {
+    udpServerPort = DEFAULT_SERVER_PORT;
   } else {
-    this->udpServerPort = udpServerPort;
+    udpServerPort = udpServerPort_;
   }
 
   mutex = MutexFactory::instance()->createMutex();
@@ -117,8 +117,8 @@ ReturnValue_t UdpTmTcBridge::sendTm(const uint8_t *data, size_t dataLen) {
   tcpip::printAddress(&clientAddress);
 #endif
 
-  int bytesSent = sendto(serverSocket, reinterpret_cast<const char *>(data), dataLen, flags,
-                         &clientAddress, clientAddressLen);
+  ssize_t bytesSent = sendto(serverSocket, reinterpret_cast<const char *>(data), dataLen, flags,
+                             &clientAddress, clientAddressLen);
   if (bytesSent == SOCKET_ERROR) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "TmTcUdpBridge::sendTm: Send operation failed." << std::endl;
@@ -150,7 +150,7 @@ void UdpTmTcBridge::checkAndSetClientAddress(sockaddr &newAddress) {
   clientAddressLen = sizeof(clientAddress);
 }
 
-void UdpTmTcBridge::setMutexProperties(MutexIF::TimeoutType timeoutType, dur_millis_t timeoutMs) {
-  this->timeoutType = timeoutType;
-  this->mutexTimeoutMs = timeoutMs;
+void UdpTmTcBridge::setMutexProperties(MutexIF::TimeoutType timeoutType_, dur_millis_t timeoutMs) {
+  timeoutType = timeoutType_;
+  mutexTimeoutMs = timeoutMs;
 }

src/fsfw/osal/common/UdpTmTcBridge.h

@@ -29,10 +29,10 @@ class UdpTmTcBridge : public TmTcBridge, public TcpIpBase {
   /* The ports chosen here should not be used by any other process. */
   static const std::string DEFAULT_SERVER_PORT;
 
-  UdpTmTcBridge(object_id_t objectId, object_id_t tcDestination, std::string udpServerPort = "",
-                object_id_t tmStoreId = objects::TM_STORE,
+  UdpTmTcBridge(object_id_t objectId, object_id_t tcDestination,
+                const std::string& udpServerPort = "", object_id_t tmStoreId = objects::TM_STORE,
                 object_id_t tcStoreId = objects::TC_STORE);
-  virtual ~UdpTmTcBridge();
+  ~UdpTmTcBridge() override;
 
   /**
    * Set properties of internal mutex.
@@ -46,12 +46,12 @@ class UdpTmTcBridge : public TmTcBridge, public TcpIpBase {
   std::string getUdpPort() const;
 
  protected:
-  virtual ReturnValue_t sendTm(const uint8_t* data, size_t dataLen) override;
+  ReturnValue_t sendTm(const uint8_t* data, size_t dataLen) override;
 
  private:
   std::string udpServerPort;
 
-  struct sockaddr clientAddress;
+  struct sockaddr clientAddress = {};
   socklen_t clientAddressLen = 0;
 
   //! Access to the client address is mutex protected as it is set by another task.

src/fsfw/osal/freertos/CMakeLists.txt

@@ -1,32 +1,30 @@
-target_sources(${LIB_FSFW_NAME} 
-	PRIVATE 
-		Clock.cpp
-		FixedTimeslotTask.cpp
-		BinarySemaphore.cpp
-		BinSemaphUsingTask.cpp
-		CountingSemaphore.cpp
-		CountingSemaphUsingTask.cpp
-		MessageQueue.cpp
-		Mutex.cpp
-		MutexFactory.cpp
-		PeriodicTask.cpp
-		QueueFactory.cpp
-		SemaphoreFactory.cpp
-		TaskFactory.cpp
-		Timekeeper.cpp
-		TaskManagement.cpp
-		QueueMapManager.cpp
-)
+target_sources(
+  ${LIB_FSFW_NAME}
+  PRIVATE Clock.cpp
+          FixedTimeslotTask.cpp
+          BinarySemaphore.cpp
+          BinSemaphUsingTask.cpp
+          CountingSemaphore.cpp
+          CountingSemaphUsingTask.cpp
+          MessageQueue.cpp
+          Mutex.cpp
+          MutexFactory.cpp
+          PeriodicTask.cpp
+          QueueFactory.cpp
+          SemaphoreFactory.cpp
+          TaskFactory.cpp
+          Timekeeper.cpp
+          TaskManagement.cpp
+          QueueMapManager.cpp)
 
-# FreeRTOS is required to link the FSFW now. It is recommended to compile 
-# FreeRTOS as a static library and set LIB_OS_NAME to the target name of the 
+# FreeRTOS is required to link the FSFW now. It is recommended to compile
+# FreeRTOS as a static library and set LIB_OS_NAME to the target name of the
 # library.
 if(NOT LIB_OS_NAME)
-	message(STATUS
-		"LIB_OS_NAME is empty. Make sure to include the FreeRTOS header path properly."
-	)
+  message(
+    STATUS
+      "LIB_OS_NAME is empty. Make sure to include the FreeRTOS header path properly."
+  )
 else()
-    target_link_libraries(${LIB_FSFW_NAME} PRIVATE
-        ${LIB_OS_NAME}
-    )
+  target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${LIB_OS_NAME})
 endif()

src/fsfw/osal/freertos/FixedTimeslotTask.cpp

@@ -46,8 +46,8 @@ void FixedTimeslotTask::missedDeadlineCounter() {
   FixedTimeslotTask::deadlineMissedCount++;
   if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount << " deadlines."
-               << std::endl;
+    sif::warning << "PST missed " << FixedTimeslotTask::deadlineMissedCount << " deadlines"
+                 << std::endl;
 #endif
   }
 }

src/fsfw/osal/host/CMakeLists.txt

@@ -1,24 +1,23 @@
-target_sources(${LIB_FSFW_NAME} 
-	PRIVATE 
-		Clock.cpp
-		FixedTimeslotTask.cpp
-		MessageQueue.cpp
-		Mutex.cpp
-		MutexFactory.cpp
-		PeriodicTask.cpp
-		QueueFactory.cpp
-		QueueMapManager.cpp
-		SemaphoreFactory.cpp
-		TaskFactory.cpp
-		taskHelpers.cpp
-)
+target_sources(
+  ${LIB_FSFW_NAME}
+  PRIVATE Clock.cpp
+          FixedTimeslotTask.cpp
+          MessageQueue.cpp
+          Mutex.cpp
+          MutexFactory.cpp
+          PeriodicTask.cpp
+          QueueFactory.cpp
+          QueueMapManager.cpp
+          SemaphoreFactory.cpp
+          TaskFactory.cpp
+          taskHelpers.cpp)
 
 if(UNIX)
-	find_package(Threads REQUIRED)
-	
-	target_link_libraries(${LIB_FSFW_NAME} 
-	PRIVATE
-		rt
-		${CMAKE_THREAD_LIBS_INIT}
-	)
-endif()
+  find_package(Threads REQUIRED)
+
+  target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${CMAKE_THREAD_LIBS_INIT})
+  if(NOT APPLE)
+    target_link_libraries(${LIB_FSFW_NAME} PRIVATE rt)
+  endif()
+
+endif()

src/fsfw/osal/host/FixedTimeslotTask.cpp

@@ -3,9 +3,7 @@
 #include <chrono>
 #include <thread>
 
-#include "fsfw/ipc/MutexFactory.h"
 #include "fsfw/objectmanager/ObjectManager.h"
-#include "fsfw/osal/host/FixedTimeslotTask.h"
 #include "fsfw/osal/host/Mutex.h"
 #include "fsfw/osal/host/taskHelpers.h"
 #include "fsfw/platform.h"
@@ -22,12 +20,8 @@
 
 FixedTimeslotTask::FixedTimeslotTask(const char* name, TaskPriority setPriority,
                                      TaskStackSize setStack, TaskPeriod setPeriod,
-                                     void (*setDeadlineMissedFunc)())
-    : started(false),
-      pollingSeqTable(setPeriod * 1000),
-      taskName(name),
-      period(setPeriod),
-      deadlineMissedFunc(setDeadlineMissedFunc) {
+                                     TaskDeadlineMissedFunction dlmFunc_)
+    : FixedTimeslotTaskBase(setPeriod, dlmFunc_), started(false), taskName(name) {
   // It is propably possible to set task priorities by using the native
   // task handles for Windows / Linux
   mainThread = std::thread(&FixedTimeslotTask::taskEntryPoint, this, this);
@@ -39,7 +33,7 @@ FixedTimeslotTask::FixedTimeslotTask(const char* name, TaskPriority setPriority,
   tasks::insertTaskName(mainThread.get_id(), taskName);
 }
 
-FixedTimeslotTask::~FixedTimeslotTask(void) {
+FixedTimeslotTask::~FixedTimeslotTask() {
   // Do not delete objects, we were responsible for ptrs only.
   terminateThread = true;
   if (mainThread.joinable()) {
@@ -48,7 +42,7 @@ FixedTimeslotTask::~FixedTimeslotTask(void) {
 }
 
 void FixedTimeslotTask::taskEntryPoint(void* argument) {
-  FixedTimeslotTask* originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
+  auto* originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
 
   if (not originalTask->started) {
     // we have to suspend/block here until the task is started.
@@ -80,7 +74,7 @@ ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-void FixedTimeslotTask::taskFunctionality() {
+[[noreturn]] void FixedTimeslotTask::taskFunctionality() {
   pollingSeqTable.intializeSequenceAfterTaskCreation();
 
   // A local iterator for the Polling Sequence Table is created to
@@ -106,16 +100,18 @@ void FixedTimeslotTask::taskFunctionality() {
       // we need to wait before executing the current slot
       // this gives us the time to wait:
       interval = chron_ms(this->pollingSeqTable.getIntervalToPreviousSlotMs());
-      delayForInterval(&currentStartTime, interval);
-      // TODO deadline missed check
+      if (not delayForInterval(&currentStartTime, interval)) {
+        if (dlmFunc != nullptr) {
+          dlmFunc();
+        }
+      }
     }
   }
 }
 
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId, uint32_t slotTimeMs,
                                          int8_t executionStep) {
-  ExecutableObjectIF* executableObject =
-      ObjectManager::instance()->get<ExecutableObjectIF>(componentId);
+  auto* executableObject = ObjectManager::instance()->get<ExecutableObjectIF>(componentId);
   if (executableObject != nullptr) {
     pollingSeqTable.addSlot(componentId, slotTimeMs, executionStep, executableObject, this);
     return HasReturnvaluesIF::RETURN_OK;
@@ -133,10 +129,6 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId, uint32_t slotT
   return HasReturnvaluesIF::RETURN_FAILED;
 }
 
-ReturnValue_t FixedTimeslotTask::checkSequence() const { return pollingSeqTable.checkSequence(); }
-
-uint32_t FixedTimeslotTask::getPeriodMs() const { return period * 1000; }
-
 bool FixedTimeslotTask::delayForInterval(chron_ms* previousWakeTimeMs, const chron_ms interval) {
   bool shouldDelay = false;
   // Get current wakeup time

src/fsfw/osal/host/FixedTimeslotTask.h

@@ -6,10 +6,10 @@
 #include <thread>
 #include <vector>
 
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../tasks/FixedSlotSequence.h"
-#include "../../tasks/FixedTimeslotTaskIF.h"
-#include "../../tasks/Typedef.h"
+#include "fsfw/objectmanager/ObjectManagerIF.h"
+#include "fsfw/tasks/FixedSlotSequence.h"
+#include "fsfw/tasks/FixedTimeslotTaskBase.h"
+#include "fsfw/tasks/definitions.h"
 
 class ExecutableObjectIF;
 
@@ -19,7 +19,7 @@ class ExecutableObjectIF;
  * @details
  * @ingroup task_handling
  */
-class FixedTimeslotTask : public FixedTimeslotTaskIF {
+class FixedTimeslotTask : public FixedTimeslotTaskBase {
  public:
   /**
    * @brief   Standard constructor of the class.
@@ -39,7 +39,7 @@ class FixedTimeslotTask : public FixedTimeslotTaskIF {
    * @brief   Currently, the executed object's lifetime is not coupled with
    *          the task object's lifetime, so the destructor is empty.
    */
-  virtual ~FixedTimeslotTask(void);
+  ~FixedTimeslotTask() override;
 
   /**
    * @brief   The method to start the task.
@@ -48,7 +48,7 @@ class FixedTimeslotTask : public FixedTimeslotTaskIF {
    *          The address of the task object is passed as an argument
    *          to the system call.
    */
-  ReturnValue_t startTask(void);
+  ReturnValue_t startTask() override;
 
   /**
    * Add timeslot to the polling sequence table.
@@ -57,47 +57,23 @@ class FixedTimeslotTask : public FixedTimeslotTaskIF {
    * @param executionStep
    * @return
    */
-  ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep);
+  ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
+                        int8_t executionStep) override;
 
-  ReturnValue_t checkSequence() const override;
-
-  uint32_t getPeriodMs() const;
-
-  ReturnValue_t sleepFor(uint32_t ms);
+  ReturnValue_t sleepFor(uint32_t ms) override;
 
  protected:
   using chron_ms = std::chrono::milliseconds;
 
   bool started;
-  //!< Typedef for the List of objects.
-  typedef std::vector<ExecutableObjectIF*> ObjectList;
+
   std::thread mainThread;
   std::atomic<bool> terminateThread{false};
 
-  //! Polling sequence table which contains the object to execute
-  //! and information like the timeslots and the passed execution step.
-  FixedSlotSequence pollingSeqTable;
-
   std::condition_variable initCondition;
   std::mutex initMutex;
   std::string taskName;
-  /**
-   * @brief   The period of the task.
-   * @details
-   * The period determines the frequency of the task's execution.
-   * It is expressed in clock ticks.
-   */
-  TaskPeriod period;
 
-  /**
-   * @brief   The pointer to the deadline-missed function.
-   * @details
-   * This pointer stores the function that is executed if the task's deadline
-   * is missed. So, each may react individually on a timing failure.
-   * The pointer may be NULL, then nothing happens on missing the deadline.
-   * The deadline is equal to the next execution of the periodic task.
-   */
-  void (*deadlineMissedFunc)(void);
   /**
    * @brief   This is the function executed in the new task's context.
    * @details
@@ -117,9 +93,9 @@ class FixedTimeslotTask : public FixedTimeslotTaskIF {
    * the checkAndRestartPeriod system call blocks the task until the next
    *  period. On missing the deadline, the deadlineMissedFunction is executed.
    */
-  void taskFunctionality(void);
+  [[noreturn]] void taskFunctionality();
 
-  bool delayForInterval(chron_ms* previousWakeTimeMs, const chron_ms interval);
+  static bool delayForInterval(chron_ms* previousWakeTimeMs, chron_ms interval);
 };
 
 #endif /* FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_ */