dedicated returnvalue for line get failure

Reviewed-on: eive/fsfw#75

.gitignore

@@ -1,14 +1,6 @@
-# PyCharm and CLion
-/.idea/*
-!/.idea/runConfigurations
-!/.idea/cmake.xml
-!/.idea/codeStyles
-
-# Eclipse
 .cproject
 .project
 .settings
 .metadata
 
 /build*
-/cmake-build*

.idea/codeStyles/Project.xml

@@ -1,14 +0,0 @@
-<component name="ProjectCodeStyleConfiguration">
-  <code_scheme name="Project" version="173">
-    <clangFormatSettings>
-      <option name="ENABLED" value="true" />
-    </clangFormatSettings>
-    <codeStyleSettings language="CMake">
-      <indentOptions>
-        <option name="INDENT_SIZE" value="2" />
-        <option name="CONTINUATION_INDENT_SIZE" value="0" />
-        <option name="TAB_SIZE" value="2" />
-      </indentOptions>
-    </codeStyleSettings>
-  </code_scheme>
-</component>

.idea/codeStyles/codeStyleConfig.xml

@@ -1,5 +0,0 @@
-<component name="ProjectCodeStyleConfiguration">
-  <state>
-    <option name="USE_PER_PROJECT_SETTINGS" value="true" />
-  </state>
-</component>

.run/fsfw-tests_coverage.run.xml

@@ -1,7 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="fsfw-tests_coverage" type="CMakeRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" PASS_PARENT_ENVS_2="true" PROJECT_NAME="fsfw-tests" TARGET_NAME="fsfw-tests_coverage" CONFIG_NAME="Debug Unittest" RUN_TARGET_PROJECT_NAME="fsfw-tests" RUN_TARGET_NAME="fsfw-tests">
-    <method v="2">
-      <option name="com.jetbrains.cidr.execution.CidrBuildBeforeRunTaskProvider$BuildBeforeRunTask" enabled="true" />
-    </method>
-  </configuration>
-</component>

.run/fsfw.run.xml

@@ -1,7 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="fsfw" type="CMakeRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" PASS_PARENT_ENVS_2="true" PROJECT_NAME="fsfw-tests" TARGET_NAME="fsfw" CONFIG_NAME="Debug Unittest" RUN_TARGET_PROJECT_NAME="fsfw-tests" RUN_TARGET_NAME="fsfw-tests">
-    <method v="2">
-      <option name="com.jetbrains.cidr.execution.CidrBuildBeforeRunTaskProvider$BuildBeforeRunTask" enabled="true" />
-    </method>
-  </configuration>
-</component>

CHANGELOG.md

@@ -12,13 +12,6 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Changes
 
-- Renamed auto-formatting script to `auto-formatter.sh` and made it more robust.
-  If `cmake-format` is installed, it will also auto-format the `CMakeLists.txt` files now.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/625
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/626
-- 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
@@ -29,8 +22,11 @@ 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
@@ -46,72 +42,13 @@ 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: 
-### Task Module Refactoring
-
-PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/636
-
-**Refactoring general task code**
-
-- There was a lot of duplicate/boilerplate code inside the individual task IF OSAL implementations.
-  Remove it by introducing base classes `PeriodicTaskBase` and `FixedTimeslotTaskBase`.
-
-**Refactor PeriodicTaskIF**
-
-- Convert `virtual ReturnValue_t addComponent(object_id_t object)` to
-  `virtual ReturnValue_t addComponent(object_id_t object, uint8_t opCode = 0)`, allowing to pass
-  the operation code passed to `performOperation`. Updated API taking
-  an `ExecutableObjectIF` accordingly
-
-**Refactor FixedTimeslotTaskIF**
-
-- Add additional `addSlot` function which takes an `ExecutableObjectIF` pointer and its Object ID
-
-**Refactor FixedSequenceSlot**
-
-- Introduce typedef `CustomCheckFunc` for `ReturnValue_t (*customCheckFunction)(const SlotList&)`.
-- Convert `ReturnValue_t (*customCheckFunction)(const SlotList&)` to
-  `ReturnValue_t (*customCheckFunction)(const SlotList&, void*)`, allowing arbitrary user arguments
-  for the custom checker
-
-**Linux Task Module**
-
-- Use composition instead of inheritance for the `PeriodicPosixTask` and make the `PosixTask` a
-  member of the class
-
-### 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
 
 - Removed the `HkSwitchHelper`. This module should not be needed anymore, now that the local
@@ -120,50 +57,15 @@ https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593
 
 ## Additions
 
-- Added options for CI/CD builds: `FSFW_CICD_BUILD`. This allows the source code to know
-  whether it is running in CI/CD
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/623
-- Basic `clion` support: Update `.gitignore` and add some basic run configurations
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/625
-- LTO support: Allow using LTO/IPO by setting `FSFW_ENABLE_LTO=1`. CMake is able to detect whether
-  the user compiler supports IPO/LPO. LTO is on by default now. Most modern compilers support it,
-  can make good use of it and it usually makes the code faster and/or smaller.
-  After some more research:
-  Enabling LTO will actually cause the compiler to only produce thin LTO by adding 
-  `-flto -fno-fat-lto-objects` to the compiler options. I am not sure this is an ideal choice
-  because if an application linking against the FSFW does not use LTO, there can be compile
-  issues (e.g. observed when compiling the FSFW tests without LTO). This is a known issue as
-  can be seen in the multiple CMake issues for it: 
-    - https://gitlab.kitware.com/cmake/cmake/-/issues/22913, 
-    - https://gitlab.kitware.com/cmake/cmake/-/issues/16808, 
-    - https://gitlab.kitware.com/cmake/cmake/-/issues/21696
-  Easiest solution for now: Keep this option OFF by default.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/616
 - Linux HAL: Add wiretapping option for I2C. Enabled with `FSFW_HAL_I2C_WIRETAPPING` defined to 1
 - Dedicated Version class and constant `fsfw::FSFW_VERSION` containing version information
   inside `fsfw/version.h`
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/559
-- Added generic PUS TC Scheduler Service 11. It depends on the new added Emebeded Template Library
-  (ETL) dependency.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/594
 - Added ETL dependency and improved library dependency management
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/592
-- Add a `DummyPowerSwitcher` module which can be useful for test setups when no PCDU is available
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
-- New typedef for switcher type
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
-- `Subsystem`: New API to add table and sequence entries
 
 ## 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,111 +1,40 @@
 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)
 
-set(FSFW_GIT_VER_HANDLING_OK FALSE)
+# Add the cmake folder so the FindSphinx module is found
-# Version handling
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" )
-if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake-modules")
-  message(STATUS "${MSG_PREFIX} Determining version information with git")
+set(MSG_PREFIX "fsfw |")
-  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()
 
-set(LIB_FSFW_NAME fsfw)
+set(FSFW_ETL_LIB_MAJOR_VERSION 20 CACHE STRING
-project(${LIB_FSFW_NAME}
+    "ETL library major version requirement"
-        VERSION ${FSFW_VERSION}.${FSFW_SUBVERSION}.${FSFW_REVISION})
+)
-
+set(FSFW_ETL_LIB_VERSION ${FSFW_ETL_LIB_MAJOR_VERSION}.27.3 CACHE STRING
-if(NOT CMAKE_CXX_STANDARD)
+    "ETL library exact version requirement"
-  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}.28.0
-    CACHE STRING "ETL library exact version requirement")
 set(FSFW_ETL_LINK_TARGET etl::etl)
 
-set(FSFW_CATCH2_LIB_MAJOR_VERSION
+set(FSFW_CATCH2_LIB_MAJOR_VERSION 3 CACHE STRING
-    3
+    "Catch2 library major version requirement"
-    CACHE STRING "Catch2 library major version requirement")
+)
-set(FSFW_CATCH2_LIB_VERSION
+set(FSFW_CATCH2_LIB_VERSION v${FSFW_CATCH2_LIB_MAJOR_VERSION}.0.0-preview5 CACHE STRING
-    v${FSFW_CATCH2_LIB_MAJOR_VERSION}.0.0-preview5
+    "Catch2 library exact version requirement"
-    CACHE STRING "Catch2 library exact version requirement")
+)
 
-# Keep this off by default for now. See PR:
+set(FSFW_ETL_LIB_NAME etl)
-# 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)
+    "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
+option(FSFW_BUILD_UNITTESTS "Build unittest binary in addition to static library" OFF)
-       "Build unittest binary in addition to static library" OFF)
-option(FSFW_CICD_BUILD "Build for CI/CD. This can disable problematic test" 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)
@@ -129,77 +58,95 @@ 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})
 
-if(IPO_SUPPORTED AND FSFW_ENABLE_IPO)
+set(FSFW_GIT_VER_HANDLING_OK FALSE)
-  set_property(TARGET ${LIB_FSFW_NAME} PROPERTY INTERPROCEDURAL_OPTIMIZATION
+# Version handling
-                                                TRUE)
+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})
 endif()
 
 if(FSFW_BUILD_UNITTESTS)
-  message(
+    message(STATUS "${MSG_PREFIX} Building the FSFW unittests in addition to the static library")
-    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})
+    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(
+        message(STATUS "${MSG_PREFIX} Catch2 installation not found. Downloading Catch2 library with FetchContent")
-      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})
+            GIT_TAG        ${FSFW_CATCH2_LIB_VERSION}
+        )
 
         list(APPEND FSFW_FETCH_CONTENT_TARGETS Catch2)
     endif()
 
     set(FSFW_CONFIG_PATH tests/src/fsfw_tests/unit/testcfg)
     configure_file(tests/src/fsfw_tests/unit/testcfg/FSFWConfig.h.in FSFWConfig.h)
-  configure_file(tests/src/fsfw_tests/unit/testcfg/TestsConfig.h.in
+    configure_file(tests/src/fsfw_tests/unit/testcfg/TestsConfig.h.in tests/TestsConfig.h)
-                 tests/TestsConfig.h)
 
     project(${FSFW_TEST_TGT} CXX C)
     add_executable(${FSFW_TEST_TGT})
-  if(IPO_SUPPORTED AND FSFW_ENABLE_IPO)
-    set_property(TARGET ${FSFW_TEST_TGT} PROPERTY INTERPROCEDURAL_OPTIMIZATION
-                                                  TRUE)
-  endif()
 
     if(FSFW_TESTS_GEN_COV)
         message(STATUS "${MSG_PREFIX} Generating coverage data for the library")
         message(STATUS "${MSG_PREFIX} Targets linking against ${LIB_FSFW_NAME} "
-                   "will be compiled with coverage data as well")
+            "will be compiled with coverage data as well"
+        )
         set(CMAKE_BUILD_TYPE "Debug")
         include(CodeCoverage)
     endif()
 endif()
 
-message(STATUS "${MSG_PREFIX} Finding and/or providing ETL library")
+message(STATUS "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} 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(
+    message(STATUS
-    STATUS
         "No ETL installation was found with find_package. Installing and providing "
-      "etl with FindPackage")
+        "etl with FindPackage"
+    )
     include(FetchContent)
-
     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}
-
+    )
     list(APPEND FSFW_FETCH_CONTENT_TARGETS ${FSFW_ETL_LIB_NAME})
 endif()
 
@@ -212,8 +159,8 @@ if(FSFW_FETCH_CONTENT_TARGETS)
         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
+        # Fixes regression -preview4, to be confirmed in later releases
-    # GitHub issue: https://github.com/catchorg/Catch2/issues/2417
+        # Related GitHub issue: https://github.com/catchorg/Catch2/issues/2417
         set_target_properties(Catch2 PROPERTIES DEBUG_POSTFIX "")
     endif()
 endif()
@@ -223,30 +170,40 @@ 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} PRIVATE
-target_include_directories(${LIB_FSFW_NAME}
+    ${CMAKE_CURRENT_BINARY_DIR}
-                           INTERFACE ${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()
 
 # Backwards comptability
 if(OS_FSFW AND NOT FSFW_OSAL)
-  message(
+    message(WARNING "${MSG_PREFIX} Please pass the FSFW OSAL as FSFW_OSAL instead of OS_FSFW")
-    WARNING
-      "${MSG_PREFIX} Please pass the FSFW OSAL as FSFW_OSAL instead of OS_FSFW")
     set(FSFW_OSAL OS_FSFW)
 endif()
 
 if(NOT FSFW_OSAL)
-  message(STATUS "No OS for FSFW via FSFW_OSAL set. Assuming host OS")
+	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
+		set(FSFW_OSAL  "linux" 
-        "linux"
+			CACHE STRING 
-        CACHE STRING "OS abstraction layer used in the FSFW")
+			"OS abstraction layer used in the FSFW"
+		)
 	elseif(WIN32)
-    set(FSFW_OSAL
+		set(FSFW_OSAL  "host" 
-        "host"
+			CACHE STRING "OS abstraction layer used in the FSFW"
-        CACHE STRING "OS abstraction layer used in the FSFW")
+		)
 	endif()
+
 endif()
 
 set(FSFW_OSAL_DEFINITION FSFW_OSAL_HOST)
@@ -260,13 +217,14 @@ elseif(FSFW_OSAL MATCHES linux)
 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})
+    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)
 else()
-  message(
+    message(WARNING
-    WARNING
         "${MSG_PREFIX} Invalid operating system for FSFW specified! Setting to host.."
     )
     set(FSFW_OS_NAME "Host")
@@ -276,9 +234,7 @@ endif()
 configure_file(src/fsfw/FSFW.h.in fsfw/FSFW.h)
 configure_file(src/fsfw/FSFWVersion.h.in fsfw/FSFWVersion.h)
 
-message(
+message(STATUS "${MSG_PREFIX} Compiling FSFW for the ${FSFW_OS_NAME} operating system")
-  STATUS "${MSG_PREFIX} Compiling FSFW for the ${FSFW_OS_NAME} operating system"
-)
 
 add_subdirectory(src)
 add_subdirectory(tests)
@@ -296,86 +252,95 @@ if(FSFW_BUILD_UNITTESTS)
             include(CodeCoverage)
 
             # Remove quotes.
-      separate_arguments(COVERAGE_COMPILER_FLAGS NATIVE_COMMAND
+            separate_arguments(COVERAGE_COMPILER_FLAGS
-                         "${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}
+            target_compile_options(${FSFW_TEST_TGT} PRIVATE
-                             PRIVATE "${COVERAGE_COMPILER_FLAGS}")
+                "${COVERAGE_COMPILER_FLAGS}"
-      target_compile_options(${LIB_FSFW_NAME}
+            )
-                             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"
+                set(GCOVR_ADDITIONAL_ARGS
-                                  "--exclude-unreachable-branches")
+                    "--exclude-throw-branches"
-        set(COVERAGE_EXCLUDES "/c/msys64/mingw64/*" "*/fsfw_hal/*")
+                    "--exclude-unreachable-branches"
+                )
+                set(COVERAGE_EXCLUDES
+                    "/c/msys64/mingw64/*" "*/fsfw_hal/*"
+                )
             elseif(UNIX)
                 set(COVERAGE_EXCLUDES
-            "/usr/include/*"
+                    "/usr/include/*" "/usr/bin/*" "Catch2/*"
-            "/usr/bin/*"
+                    "/usr/local/include/*" "*/fsfw_tests/*"
-            "Catch2/*"
+                    "*/catch2-src/*" "*/fsfw_hal/*"
-            "/usr/local/include/*"
+                )
-            "*/fsfw_tests/*"
-            "*/catch2-src/*"
-            "*/fsfw_hal/*")
             endif()
 
-      target_link_options(${FSFW_TEST_TGT} PRIVATE -fprofile-arcs
+            target_link_options(${FSFW_TEST_TGT} PRIVATE
-                          -ftest-coverage)
+                -fprofile-arcs
-      target_link_options(${LIB_FSFW_NAME} PRIVATE -fprofile-arcs
+                -ftest-coverage
-                          -ftest-coverage)
+            )
-      # Need to specify this as an interface, otherwise there will the compile
+            target_link_options(${LIB_FSFW_NAME} PRIVATE
-      # issues
+                -fprofile-arcs
-      target_link_options(${LIB_FSFW_NAME} INTERFACE -fprofile-arcs
+                -ftest-coverage
-                          -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}
+                    NAME ${FSFW_TEST_TGT}_coverage
-          DEPENDENCIES ${FSFW_TEST_TGT})
+                    EXECUTABLE ${FSFW_TEST_TGT}
+                    DEPENDENCIES ${FSFW_TEST_TGT}
+                )
             else()
                 setup_target_for_coverage_lcov(
-          NAME ${FSFW_TEST_TGT}_coverage EXECUTABLE ${FSFW_TEST_TGT}
+                    NAME ${FSFW_TEST_TGT}_coverage
-          DEPENDENCIES ${FSFW_TEST_TGT})
+                    EXECUTABLE ${FSFW_TEST_TGT}
+                    DEPENDENCIES ${FSFW_TEST_TGT}
+                )
             endif()
         endif()
     endif()
-  target_link_libraries(${FSFW_TEST_TGT} PRIVATE Catch2::Catch2
+    target_link_libraries(${FSFW_TEST_TGT} PRIVATE Catch2::Catch2 ${LIB_FSFW_NAME})
-                                                 ${LIB_FSFW_NAME})
 endif()
 
-# The project CMakeLists file has to set the FSFW_CONFIG_PATH and add it. If
+# The project CMakeLists file has to set the FSFW_CONFIG_PATH and add it.
-# this is not given, we include the default configuration and emit a warning.
+# 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(
+        message(WARNING "${MSG_PREFIX} Flight Software Framework configuration path not set")
-      WARNING
+        message(WARNING "${MSG_PREFIX} Setting default configuration from ${DEF_CONF_PATH} ..")
-        "${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
+# FSFW might be part of a possibly complicated folder structure, so we 
-# the absolute path of the fsfwconfig folder.
+# extract the absolute path of the fsfwconfig folder.
 if(IS_ABSOLUTE ${FSFW_CONFIG_PATH})
 	set(FSFW_CONFIG_PATH_ABSOLUTE ${FSFW_CONFIG_PATH})
 else()
-  get_filename_component(FSFW_CONFIG_PATH_ABSOLUTE ${FSFW_CONFIG_PATH} REALPATH
+	get_filename_component(FSFW_CONFIG_PATH_ABSOLUTE
-                         BASE_DIR ${CMAKE_SOURCE_DIR})
+		${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
+        get_filename_component(CURR_ABS_INC_PATH
-                           ${CMAKE_SOURCE_DIR})
+            ${INCLUDE_PATH} REALPATH BASE_DIR ${CMAKE_SOURCE_DIR})
     endif()
 
     if(CMAKE_VERBOSE)
@@ -408,19 +373,23 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
           -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
+          # -Wconversion # Creates many false positives
-        # with Wconversion to find more implicit conversions -fanalyzer # Should
+          # -Warith-conversion # Use with Wconversion to find more implicit conversions
-        # be used to look through problems
+          # -fanalyzer # Should be used to look through problems
         )
     endif()
 
     if(FSFW_GENERATE_SECTIONS)
-    target_compile_options(${LIB_FSFW_NAME} PRIVATE "-ffunction-sections"
+        target_compile_options(${LIB_FSFW_NAME} PRIVATE
-                                                    "-fdata-sections")
+            "-ffunction-sections"
+            "-fdata-sections"
+        )
     endif()
 
     if(FSFW_REMOVE_UNUSED_CODE)
-    target_link_options(${LIB_FSFW_NAME} PRIVATE "Wl,--gc-sections")
+        target_link_options(${LIB_FSFW_NAME} PRIVATE
+            "Wl,--gc-sections"
+        )
     endif()
   
     if(FSFW_WARNING_SHADOW_LOCAL_GCC)
@@ -434,31 +403,42 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
 endif()
 
 # Required include paths to compile the FSFW
-target_include_directories(
+target_include_directories(${LIB_FSFW_NAME} INTERFACE 
-  ${LIB_FSFW_NAME} INTERFACE ${CMAKE_SOURCE_DIR} ${FSFW_CONFIG_PATH_ABSOLUTE}
+	${CMAKE_SOURCE_DIR}
-                             ${FSFW_CORE_INC_PATH} ${FSFW_ADD_INC_PATHS_ABS})
+	${FSFW_CONFIG_PATH_ABSOLUTE}
+	${FSFW_CORE_INC_PATH}
+	${FSFW_ADD_INC_PATHS_ABS}
+)
 
-# Includes path required to compile FSFW itself as well We assume that the
+# Includes path required to compile FSFW itself as well
-# fsfwconfig folder uses include relative to the project root here!
+# We assume that the fsfwconfig folder uses include relative to the project
-target_include_directories(
+# root here!
-  ${LIB_FSFW_NAME} PRIVATE ${CMAKE_SOURCE_DIR} ${FSFW_CONFIG_PATH_ABSOLUTE}
+target_include_directories(${LIB_FSFW_NAME} PRIVATE 
-                           ${FSFW_CORE_INC_PATH} ${FSFW_ADD_INC_PATHS_ABS})
+	${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}
+target_compile_options(${LIB_FSFW_NAME} PRIVATE 
-                                                ${COMPILER_FLAGS})
+	${FSFW_WARNING_FLAGS}
+	${COMPILER_FLAGS}
+)
 
-target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${FSFW_ETL_LINK_TARGET}
+target_link_libraries(${LIB_FSFW_NAME} PRIVATE
-                                               ${FSFW_ADDITIONAL_LINK_LIBS})
+    ${FSFW_ETL_LINK_TARGET}
+    ${FSFW_ADDITIONAL_LINK_LIBS}
+)
 
-string(
+string(CONCAT POST_BUILD_COMMENT
-  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})
+   COMMENT ${POST_BUILD_COMMENT}
+)

README.md

@@ -99,7 +99,7 @@ add and link against the FSFW library in general.
 
 4. Link against the FSFW library
 
-   ```sh
+   ```cmake
    target_link_libraries(${YourProjectName} PRIVATE fsfw)
    ```
 
@@ -131,7 +131,7 @@ default. This can be disabled by setting the `FSFW_TESTS_COV_GEN` option to `OFF
 You can use the following commands inside the `fsfw` folder to set up the build system
 
 ```sh
-mkdir build-tests && cd build-tests
+mkdir build-Unittest && cd build-Unittest
 cmake -DFSFW_BUILD_UNITTESTS=ON -DFSFW_OSAL=host -DCMAKE_BUILD_TYPE=Debug ..
 ```
 

automation/Dockerfile

@@ -12,9 +12,3 @@ RUN git clone https://github.com/catchorg/Catch2.git && \
 	git checkout v3.0.0-preview5 && \
 	cmake -Bbuild -H. -DBUILD_TESTING=OFF && \
 	cmake --build build/ --target install
-
-RUN git clone https://github.com/ETLCPP/etl.git && \
-	cd etl && \
-	git checkout 20.28.0 && \
-	cmake -B build . && \
-	cmake --install build/

automation/Jenkinsfile

@@ -14,7 +14,7 @@ pipeline {
         stage('Configure') {
             steps {
                 dir(BUILDDIR) {
-                    sh 'cmake -DFSFW_OSAL=host -DFSFW_BUILD_UNITTESTS=ON -DFSFW_CICD_BUILD=ON ..'
+                    sh 'cmake -DFSFW_OSAL=host -DFSFW_BUILD_UNITTESTS=ON ..'
                 }
             }
         }

cmake/cmake-modules/GetGitRevisionDescription.cmake

@@ -0,0 +1,141 @@
+# - 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/GetGitRevisionDescription.cmake.in

@@ -8,12 +8,10 @@
 # http://academic.cleardefinition.com
 # Iowa State University HCI Graduate Program/VRAC
 #
-# Copyright 2009-2012, Iowa State University
+# Copyright Iowa State University 2009-2010.
-# 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)
 
@@ -25,12 +23,9 @@ if(HEAD_CONTENTS MATCHES "ref")
     string(REPLACE "ref: " "" HEAD_REF "${HEAD_CONTENTS}")
     if(EXISTS "@GIT_DIR@/${HEAD_REF}")
     configure_file("@GIT_DIR@/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY)
-    else()
+    elseif(EXISTS "@GIT_DIR@/logs/${HEAD_REF}")
-        configure_file("@GIT_DIR@/packed-refs" "@GIT_DATA@/packed-refs" COPYONLY)
+        configure_file("@GIT_DIR@/logs/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY)
-        file(READ "@GIT_DATA@/packed-refs" PACKED_REFS)
+        set(HEAD_HASH "${HEAD_REF}")
-        if(${PACKED_REFS} MATCHES "([0-9a-z]*) ${HEAD_REF}")
-            set(HEAD_HASH "${CMAKE_MATCH_1}")
-        endif()
     endif()
 else()
     # detached HEAD

cmake/cmake-modules/README.md

@@ -1,7 +1,5 @@
-The files in the `bilke` folder were manually copy and pasted from the
+The files in these folder were manually copy and pasted from the
 [cmake-modules repository](https://github.com/bilke/cmake-modules). It was decided to do
 this because only a small subset of its provided functions are needed.
 
-The files in the `rpavlik` folder were manually copy and pasted from the
+The license file in included here as well.
-[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

@@ -1,284 +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> [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/LICENSES/BSD-3-Clause.txt

@@ -1,26 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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/MgmLIS3MDLHandler.cpp

@@ -375,13 +375,16 @@ float MgmLIS3MDLHandler::getSensitivityFactor(MGMLIS3MDL::Sensitivies sens) {
 
 ReturnValue_t MgmLIS3MDLHandler::enableTemperatureSensor(const uint8_t *commandData,
                                                          size_t commandDataLen) {
+  if (commandData == nullptr) {
+    return INVALID_COMMAND_PARAMETER;
+  }
   triggerEvent(CHANGE_OF_SETUP_PARAMETER);
   uint32_t size = 2;
   commandBuffer[0] = writeCommand(MGMLIS3MDL::CTRL_REG1);
   if (commandDataLen > 1) {
     return INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS;
   }
-  switch (*commandData) {
+  switch (commandData[0]) {
     case (MGMLIS3MDL::ON): {
       commandBuffer[1] = registers[0] | (1 << 7);
       break;

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

@@ -0,0 +1,27 @@
+#ifndef FSFW_HAL_SRC_FSFW_HAL_LINUX_GPIO_GPIO_H_
+#define FSFW_HAL_SRC_FSFW_HAL_LINUX_GPIO_GPIO_H_
+
+#include "fsfw_hal/common/gpio/GpioIF.h"
+#include "fsfw_hal/common/gpio/gpioDefinitions.h"
+
+/**
+ * @brief   Additional abstraction layer for handling GPIOs.
+ *
+ * @author  J. Meier
+ */
+class Gpio {
+ public:
+  Gpio(gpioId_t gpioId, GpioIF* gpioIF) : gpioId(gpioId), gpioIF(gpioIF) {
+    if (gpioIF == nullptr) {
+      sif::error << "Gpio::Gpio: Invalid GpioIF" << std::endl;
+    }
+  }
+  ReturnValue_t pullHigh() { return gpioIF->pullHigh(gpioId); }
+  ReturnValue_t pullLow() { return gpioIF->pullLow(gpioId); }
+
+ private:
+  gpioId_t gpioId = gpio::NO_GPIO;
+  GpioIF* gpioIF = nullptr;
+};
+
+#endif /* FSFW_HAL_SRC_FSFW_HAL_LINUX_GPIO_GPIO_H_ */

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

@@ -20,9 +20,7 @@ LinuxLibgpioIF::~LinuxLibgpioIF() {
 ReturnValue_t LinuxLibgpioIF::addGpios(GpioCookie* gpioCookie) {
   ReturnValue_t result;
   if (gpioCookie == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "LinuxLibgpioIF::addGpios: Invalid cookie" << std::endl;
-#endif
     return RETURN_FAILED;
   }
 
@@ -98,10 +96,8 @@ ReturnValue_t LinuxLibgpioIF::configureGpioByLabel(gpioId_t gpioId,
   std::string& label = gpioByLabel.label;
   struct gpiod_chip* chip = gpiod_chip_open_by_label(label.c_str());
   if (chip == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "LinuxLibgpioIF::configureGpioByLabel: Failed to open gpio from gpio "
                  << "group with label " << label << ". Gpio ID: " << gpioId << std::endl;
-#endif
     return RETURN_FAILED;
   }
   std::string failOutput = "label: " + label;
@@ -112,10 +108,8 @@ ReturnValue_t LinuxLibgpioIF::configureGpioByChip(gpioId_t gpioId, GpiodRegularB
   std::string& chipname = gpioByChip.chipname;
   struct gpiod_chip* chip = gpiod_chip_open_by_name(chipname.c_str());
   if (chip == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "LinuxLibgpioIF::configureGpioByChip: Failed to open chip " << chipname
                  << ". Gpio ID: " << gpioId << std::endl;
-#endif
     return RETURN_FAILED;
   }
   std::string failOutput = "chipname: " + chipname;
@@ -139,10 +133,8 @@ ReturnValue_t LinuxLibgpioIF::configureGpioByLineName(gpioId_t gpioId,
 
   struct gpiod_chip* chip = gpiod_chip_open_by_name(chipname);
   if (chip == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "LinuxLibgpioIF::configureGpioByLineName: Failed to open chip " << chipname
                  << ". <Gpio ID: " << gpioId << std::endl;
-#endif
     return RETURN_FAILED;
   }
   std::string failOutput = "line name: " + lineName;
@@ -161,12 +153,10 @@ ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, struct gpiod
   lineNum = regularGpio.lineNum;
   lineHandle = gpiod_chip_get_line(chip, lineNum);
   if (!lineHandle) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "LinuxLibgpioIF::configureRegularGpio: Failed to open line " << std::endl;
     sif::warning << "GPIO ID: " << gpioId << ", line number: " << lineNum << ", " << failOutput
                  << std::endl;
     sif::warning << "Check if Linux GPIO configuration has changed. " << std::endl;
-#endif
     gpiod_chip_close(chip);
     return RETURN_FAILED;
   }
@@ -185,9 +175,7 @@ ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, struct gpiod
       break;
     }
     default: {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::error << "LinuxLibgpioIF::configureGpios: Invalid direction specified" << std::endl;
-#endif
       return GPIO_INVALID_INSTANCE;
     }
 
@@ -216,9 +204,7 @@ ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, struct gpiod
 ReturnValue_t LinuxLibgpioIF::pullHigh(gpioId_t gpioId) {
   gpioMapIter = gpioMap.find(gpioId);
   if (gpioMapIter == gpioMap.end()) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "LinuxLibgpioIF::pullHigh: Unknown GPIO ID " << gpioId << std::endl;
-#endif
     return UNKNOWN_GPIO_ID;
   }
 
@@ -294,7 +280,7 @@ ReturnValue_t LinuxLibgpioIF::driveGpio(gpioId_t gpioId, GpiodRegularBase& regul
   return RETURN_OK;
 }
 
-ReturnValue_t LinuxLibgpioIF::readGpio(gpioId_t gpioId, 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
@@ -313,7 +299,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
+#if FSFW_VERBOSE_LEVEL >= 1
-    sif::error << "I2cComIF::requestReceiveMessage: Reading from I2C "
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-               << "device failed with error code " << errno << ". Description"
+    if (readLen < 0) {
-               << " of error: " << strerror(errno) << std::endl;
+      sif::warning << "I2cComIF::requestReceiveMessage: Reading from I2C "
-    sif::error << "I2cComIF::requestReceiveMessage: Read only " << readLen << " from " << requestLen
+                   << "device failed with error code " << errno << " | " << strerror(errno)
-               << " bytes" << std::endl;
+                   << 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/SpiComIF.cpp

@@ -210,7 +210,7 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
 #endif
       return result;
     }
-    result = gpioComIF->pullLow(gpioId);
+    ReturnValue_t result = gpioComIF->pullLow(gpioId);
     if (result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1

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

@@ -2,8 +2,8 @@
 
 #include <fsfw/serviceinterface.h>
 
-UartCookie::UartCookie(object_id_t handlerId, std::string deviceFile, UartModes uartMode,
+UartCookie::UartCookie(object_id_t handlerId, std::string deviceFile, UartBaudRate baudrate,
-                       UartBaudRate baudrate, size_t maxReplyLen)
+                       size_t maxReplyLen, UartModes uartMode)
     : handlerId(handlerId),
       deviceFile(deviceFile),
       uartMode(uartMode),

hal/src/fsfw_hal/linux/uart/UartCookie.h

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

hal/src/fsfw_hal/stm32h7/devicetest/GyroL3GD20H.h

@@ -10,10 +10,6 @@
 #include "stm32h7xx_hal.h"
 #include "stm32h7xx_hal_spi.h"
 
-#ifndef STM_USE_PERIPHERAL_TX_BUFFER_MPU_PROTECTION
-#define STM_USE_PERIPHERAL_TX_BUFFER_MPU_PROTECTION 1
-#endif
-
 enum class TransferStates { IDLE, WAIT, SUCCESS, FAILURE };
 
 class GyroL3GD20H {

scripts/apply-clang-format.sh

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

scripts/auto-formatter.sh

@@ -1,23 +0,0 @@
-#!/bin/bash
-if [[ ! -f README.md ]]; then
-  cd ..
-fi
-
-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
-  find ./src ${file_selectors} | xargs ${cpp_format} --style=file -i
-  find ./hal ${file_selectors} | xargs ${cpp_format} --style=file -i
-  find ./tests ${file_selectors} | xargs ${cpp_format} --style=file -i
-else
-  echo "No ${cpp_format} tool found, not formatting C++/C files"
-fi

src/CMakeLists.txt

@@ -1,6 +1,9 @@
-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}
+target_include_directories(${LIB_FSFW_NAME} INTERFACE
-                           INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
 
 add_subdirectory(fsfw)

src/fsfw/CMakeLists.txt

@@ -1,4 +1,6 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE version.cpp)
+target_sources(${LIB_FSFW_NAME} PRIVATE
+    version.cpp
+)
 
 # Core
 

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_VCS_INFO[] = "@FSFW_VCS_INFO@";
+static const char FSFW_VERSION_CST_GIT_SHA1[] = "@FSFW_VERSION_CST_GIT_SHA1@";
 
 #endif /* FSFW_VERSION_H_ */

src/fsfw/action/CMakeLists.txt

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

src/fsfw/action/CommandActionHelper.h

@@ -16,8 +16,8 @@ class CommandActionHelper {
  public:
   CommandActionHelper(CommandsActionsIF* owner);
   virtual ~CommandActionHelper();
-  ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId, const uint8_t* data,
+  ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId,
-                              uint32_t size);
+                              const uint8_t* data = nullptr, uint32_t size = 0);
   ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId, SerializeIF* data);
   ReturnValue_t initialize();
   ReturnValue_t handleReply(CommandMessage* reply);

src/fsfw/cfdp/CFDPHandler.cpp

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

src/fsfw/cfdp/CMakeLists.txt

@@ -1,4 +1,7 @@
-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,11 +1,11 @@
-target_sources(
+target_sources(${LIB_FSFW_NAME} PRIVATE
-  ${LIB_FSFW_NAME}
+    PduConfig.cpp
-  PRIVATE PduConfig.cpp
     VarLenField.cpp
     HeaderSerializer.cpp
     HeaderDeserializer.cpp
     FileDirectiveDeserializer.cpp
     FileDirectiveSerializer.cpp
+ 
     AckInfo.cpp
     AckPduSerializer.cpp
     AckPduDeserializer.cpp
@@ -25,6 +25,8 @@ target_sources(
     KeepAlivePduDeserializer.cpp
     PromptPduSerializer.cpp
     PromptPduDeserializer.cpp
+
     FileDataSerializer.cpp
     FileDataDeserializer.cpp
-          FileDataInfo.cpp)
+    FileDataInfo.cpp
+)

src/fsfw/cfdp/tlv/CMakeLists.txt

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

src/fsfw/container/CMakeLists.txt

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

src/fsfw/container/FIFOBase.tpp

@@ -6,8 +6,8 @@
 #endif
 
 template<typename T>
-inline FIFOBase<T>::FIFOBase(T* values, const size_t maxCapacity)
+inline FIFOBase<T>::FIFOBase(T* values, const size_t maxCapacity):
-    : maxCapacity(maxCapacity), values(values){};
+        maxCapacity(maxCapacity), values(values){};
 
 template<typename T>
 inline ReturnValue_t FIFOBase<T>::insert(T value) {
@@ -84,6 +84,7 @@ inline size_t FIFOBase<T>::getMaxCapacity() const {
     return maxCapacity;
 }
 
+
 template<typename T>
 inline void FIFOBase<T>::setContainer(T *data) {
     this->values = data;

src/fsfw/container/FixedArrayList.h

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

src/fsfw/container/FixedOrderedMultimap.tpp

@@ -1,9 +1,9 @@
 #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,
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(key_t key, T value, Iterator *storedValue) {
-                                                                         Iterator *storedValue) {
     if (_size == theMap.maxSize()) {
         return MAP_FULL;
     }
@@ -71,8 +71,7 @@ inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(key_t key
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
-inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findFirstIndex(key_t key,
+inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findFirstIndex(key_t key, size_t startAt) const {
-                                                                          size_t startAt) const {
     if (startAt >= _size) {
         return startAt + 1;
     }
@@ -106,4 +105,5 @@ inline void FixedOrderedMultimap<key_t, T, KEY_COMPARE>::removeFromPosition(size
     --_size;
 }
 
+
 #endif /* FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_ */

src/fsfw/controller/CMakeLists.txt

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

src/fsfw/controller/ControllerBase.cpp

@@ -13,7 +13,9 @@ ControllerBase::ControllerBase(object_id_t setObjectId, object_id_t parentId,
       submode(SUBMODE_NONE),
       modeHelper(this),
       healthHelper(this, setObjectId) {
-  commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth);
+  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
+  commandQueue = QueueFactory::instance()->createMessageQueue(
+      commandQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
 
 ControllerBase::~ControllerBase() { QueueFactory::instance()->deleteMessageQueue(commandQueue); }

src/fsfw/coordinates/CMakeLists.txt

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

src/fsfw/datalinklayer/CMakeLists.txt

@@ -1,6 +1,6 @@
-target_sources(
+target_sources(${LIB_FSFW_NAME} 
-  ${LIB_FSFW_NAME}
+	PRIVATE 
-  PRIVATE Clcw.cpp
+		Clcw.cpp
 		DataLinkLayer.cpp
 		Farm1StateLockout.cpp
 		Farm1StateOpen.cpp
@@ -8,4 +8,5 @@ target_sources(
 		MapPacketExtraction.cpp
 		TcTransferFrame.cpp
 		TcTransferFrameLocal.cpp
-          VirtualChannelReception.cpp)
+		VirtualChannelReception.cpp
+)

src/fsfw/datapool/CMakeLists.txt

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

src/fsfw/datapool/PoolEntry.cpp

@@ -7,24 +7,26 @@
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
 template <typename T>
-PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, bool setValid)
+PoolEntry<T>::PoolEntry(uint8_t len, bool setValid) : length(len), valid(setValid) {
-    : length(static_cast<uint8_t>(initValue.size())), valid(setValid) {
+  this->address = new T[this->length]();
-  this->address = new T[this->length];
-  if (initValue.size() == 0) {
   std::memset(this->address, 0, this->getByteSize());
-  } else {
+}
-    std::copy(initValue.begin(), initValue.end(), this->address);
+
+template <typename T>
+PoolEntry<T>::PoolEntry(std::initializer_list<T> initValues, bool setValid)
+    : length(static_cast<uint8_t>(initValues.size())), valid(setValid) {
+  this->address = new T[this->length]();
+  if (initValues.size() > 0) {
+    std::copy(initValues.begin(), initValues.end(), this->address);
   }
 }
 
 template <typename T>
-PoolEntry<T>::PoolEntry(T* initValue, uint8_t setLength, bool setValid)
+PoolEntry<T>::PoolEntry(const T* initValue, uint8_t setLength, bool setValid)
     : length(setLength), valid(setValid) {
-  this->address = new T[this->length];
+  this->address = new T[this->length]();
   if (initValue != nullptr) {
     std::memcpy(this->address, initValue, this->getByteSize());
-  } else {
-    std::memset(this->address, 0, this->getByteSize());
   }
 }
 

src/fsfw/datapool/PoolEntry.h

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

src/fsfw/datapoollocal/CMakeLists.txt

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

src/fsfw/datapoollocal/LocalDataPoolManager.cpp

@@ -696,9 +696,9 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
   if (result != HasReturnvaluesIF::RETURN_OK) {
     /* Configuration error */
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "LocalDataPoolManager::performPeriodicHkOperation: HK generation failed." << std::endl;
+    sif::warning << "LocalDataPoolManager::performHkOperation: HK generation failed." << std::endl;
 #else
-    sif::printWarning("LocalDataPoolManager::performPeriodicHkOperation: HK generation failed.\n");
+    sif::printWarning("LocalDataPoolManager::performHkOperation: HK generation failed.\n");
 #endif
   }
 }

src/fsfw/datapoollocal/LocalPoolDataSetBase.h

@@ -162,6 +162,7 @@ class LocalPoolDataSetBase : public PoolDataSetBase, public MarkChangedIF {
   object_id_t getCreatorObjectId();
 
   bool getReportingEnabled() const;
+  void setReportingEnabled(bool enabled);
 
   /**
    * Returns the current periodic HK generation interval this set
@@ -189,7 +190,6 @@ class LocalPoolDataSetBase : public PoolDataSetBase, public MarkChangedIF {
    * Used for periodic generation.
    */
   bool reportingEnabled = false;
-  void setReportingEnabled(bool enabled);
 
   void initializePeriodicHelper(float collectionInterval, dur_millis_t minimumPeriodicInterval,
                                 uint8_t nonDiagIntervalFactor = 5);

src/fsfw/datapoollocal/LocalPoolVariable.tpp

@@ -6,24 +6,26 @@
 #endif
 
 template<typename T>
-inline LocalPoolVariable<T>::LocalPoolVariable(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
+inline LocalPoolVariable<T>::LocalPoolVariable(HasLocalDataPoolIF* hkOwner,
-                                               DataSetIF* dataSet, pool_rwm_t setReadWriteMode)
+        lp_id_t poolId, DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
-    : LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
+        LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
 template<typename T>
-inline LocalPoolVariable<T>::LocalPoolVariable(object_id_t poolOwner, lp_id_t poolId,
+inline LocalPoolVariable<T>::LocalPoolVariable(object_id_t poolOwner,
-                                               DataSetIF* dataSet, pool_rwm_t setReadWriteMode)
+        lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
-    : LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
+        LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
+
 
 template<typename T>
-inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId, DataSetIF* dataSet,
+inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId,
-                                               pool_rwm_t setReadWriteMode)
+        DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
-    : LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId, dataSet,
+        LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
-                          setReadWriteMode) {}
+                dataSet, setReadWriteMode){}
+
 
 template<typename T>
-inline ReturnValue_t LocalPoolVariable<T>::read(MutexIF::TimeoutType timeoutType,
+inline ReturnValue_t LocalPoolVariable<T>::read(
-                                                uint32_t timeoutMs) {
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
     if(hkManager == nullptr) {
         return readWithoutLock();
     }
@@ -41,17 +43,19 @@ 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,
+        reportReadCommitError("LocalPoolVector",
-                          targetObjectId, localPoolId);
+                PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
+                localPoolId);
         return PoolVariableIF::INVALID_READ_WRITE_MODE;
     }
 
     PoolEntry<T>* poolEntry = nullptr;
-  ReturnValue_t result =
+    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
-      LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
+            &poolEntry);
     if(result != RETURN_OK) {
         object_id_t ownerObjectId = hkManager->getCreatorObjectId();
-    reportReadCommitError("LocalPoolVariable", result, false, ownerObjectId, localPoolId);
+        reportReadCommitError("LocalPoolVariable", result,
+                false, ownerObjectId, localPoolId);
         return result;
     }
 
@@ -61,15 +65,15 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVariable<T>::commit(bool setValid, MutexIF::TimeoutType timeoutType,
+inline ReturnValue_t LocalPoolVariable<T>::commit(bool setValid,
-                                                  uint32_t timeoutMs) {
+        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,
+inline ReturnValue_t LocalPoolVariable<T>::commit(
-                                                  uint32_t timeoutMs) {
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
     if(hkManager == nullptr) {
         return commitWithoutLock();
     }
@@ -87,17 +91,19 @@ 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,
+        reportReadCommitError("LocalPoolVector",
-                          targetObjectId, localPoolId);
+                PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
+                localPoolId);
         return PoolVariableIF::INVALID_READ_WRITE_MODE;
     }
 
     PoolEntry<T>* poolEntry = nullptr;
-  ReturnValue_t result =
+    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
-      LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
+            &poolEntry);
     if(result != RETURN_OK) {
         object_id_t ownerObjectId = hkManager->getCreatorObjectId();
-    reportReadCommitError("LocalPoolVariable", result, false, ownerObjectId, localPoolId);
+        reportReadCommitError("LocalPoolVariable", result,
+                false, ownerObjectId, localPoolId);
         return result;
     }
 
@@ -107,10 +113,11 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVariable<T>::serialize(
+inline ReturnValue_t LocalPoolVariable<T>::serialize(uint8_t** buffer,
-    uint8_t** buffer, size_t* size, const size_t max_size,
+        size_t* size, const size_t max_size,
         SerializeIF::Endianness streamEndianness) const {
-  return SerializeAdapter::serialize(&value, buffer, size, max_size, streamEndianness);
+    return SerializeAdapter::serialize(&value,
+            buffer, size ,max_size, streamEndianness);
 }
 
 template<typename T>
@@ -119,14 +126,15 @@ inline size_t LocalPoolVariable<T>::getSerializedSize() const {
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVariable<T>::deSerialize(const uint8_t** buffer, size_t* size,
+inline ReturnValue_t LocalPoolVariable<T>::deSerialize(const uint8_t** buffer,
-                                                       SerializeIF::Endianness streamEndianness) {
+        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) {
+inline std::ostream& operator<< (std::ostream &out,
+        const LocalPoolVariable<T> &var) {
     out << var.value;
     return out;
 }
@@ -138,7 +146,8 @@ inline LocalPoolVariable<T>::operator T() const {
 }
 
 template<typename T>
-inline LocalPoolVariable<T>& LocalPoolVariable<T>::operator=(const T& newValue) {
+inline LocalPoolVariable<T> & LocalPoolVariable<T>::operator=(
+        const T& newValue) {
     value = newValue;
     return *this;
 }
@@ -151,7 +160,8 @@ inline LocalPoolVariable<T>& LocalPoolVariable<T>::operator=(
 }
 
 template<typename T>
-inline bool LocalPoolVariable<T>::operator==(const LocalPoolVariable<T>& other) const {
+inline bool LocalPoolVariable<T>::operator ==(
+        const LocalPoolVariable<T> &other) const {
     return this->value == other.value;
 }
 
@@ -160,8 +170,10 @@ 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 {
+inline bool LocalPoolVariable<T>::operator !=(
+        const LocalPoolVariable<T> &other) const {
     return not (*this == other);
 }
 
@@ -170,8 +182,10 @@ 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 {
+inline bool LocalPoolVariable<T>::operator <(
+        const LocalPoolVariable<T> &other) const {
     return this->value < other.value;
 }
 
@@ -180,8 +194,10 @@ 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 {
+inline bool LocalPoolVariable<T>::operator >(
+        const LocalPoolVariable<T> &other) const {
     return not (*this < other);
 }
 

src/fsfw/datapoollocal/LocalPoolVector.tpp

@@ -6,26 +6,25 @@
 #endif
 
 template<typename T, uint16_t vectorSize>
-inline LocalPoolVector<T, vectorSize>::LocalPoolVector(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(
-                                                       DataSetIF* dataSet,
+        HasLocalDataPoolIF* hkOwner, lp_id_t poolId, DataSetIF* dataSet,
-                                                       pool_rwm_t setReadWriteMode)
+        pool_rwm_t setReadWriteMode):
-    : LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
+        LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
 template<typename T, uint16_t vectorSize>
-inline LocalPoolVector<T, vectorSize>::LocalPoolVector(object_id_t poolOwner, lp_id_t poolId,
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(object_id_t poolOwner,
-                                                       DataSetIF* dataSet,
+        lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
-                                                       pool_rwm_t setReadWriteMode)
+        LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
-    : LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
 
 template<typename T, uint16_t vectorSize>
-inline LocalPoolVector<T, vectorSize>::LocalPoolVector(gp_id_t globalPoolId, DataSetIF* dataSet,
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(gp_id_t globalPoolId,
-                                                       pool_rwm_t setReadWriteMode)
+        DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
-    : LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId, dataSet,
+        LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
-                          setReadWriteMode) {}
+                dataSet, setReadWriteMode) {}
 
 template<typename T, uint16_t vectorSize>
-inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(MutexIF::TimeoutType timeoutType,
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(
-                                                          uint32_t timeoutMs) {
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
     MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
     return readWithoutLock();
 }
@@ -33,19 +32,21 @@ 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,
+        reportReadCommitError("LocalPoolVector",
-                          targetObjectId, localPoolId);
+                PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
+                localPoolId);
         return PoolVariableIF::INVALID_READ_WRITE_MODE;
     }
 
     PoolEntry<T>* poolEntry = nullptr;
-  ReturnValue_t result =
+    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
-      LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
+            &poolEntry);
     memset(this->value, 0, vectorSize * sizeof(T));
 
     if(result != RETURN_OK) {
         object_id_t targetObjectId = hkManager->getCreatorObjectId();
-    reportReadCommitError("LocalPoolVector", result, true, targetObjectId, localPoolId);
+        reportReadCommitError("LocalPoolVector", result, true, targetObjectId,
+                localPoolId);
         return result;
     }
     std::memcpy(this->value, poolEntry->getDataPtr(), poolEntry->getByteSize());
@@ -55,15 +56,14 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(bool valid,
-                                                            MutexIF::TimeoutType timeoutType,
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-                                                            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,
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
-                                                            uint32_t timeoutMs) {
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
     MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
     return commitWithoutLock();
 }
@@ -72,16 +72,18 @@ 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,
+        reportReadCommitError("LocalPoolVector",
-                          targetObjectId, localPoolId);
+                PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
+                localPoolId);
         return PoolVariableIF::INVALID_READ_WRITE_MODE;
     }
     PoolEntry<T>* poolEntry = nullptr;
-  ReturnValue_t result =
+    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
-      LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
+            &poolEntry);
     if(result != RETURN_OK) {
         object_id_t targetObjectId = hkManager->getCreatorObjectId();
-    reportReadCommitError("LocalPoolVector", result, false, targetObjectId, localPoolId);
+        reportReadCommitError("LocalPoolVector", result, false, targetObjectId,
+                localPoolId);
         return result;
     }
     std::memcpy(poolEntry->getDataPtr(), this->value, poolEntry->getByteSize());
@@ -98,11 +100,9 @@ inline T& LocalPoolVector<T, vectorSize>::operator[](size_t i) {
     // a configuration error, but I wont exit here.
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
-                  " last value!"
+            " last value!" << std::endl;
-               << std::endl;
 #else
-  sif::printWarning(
+    sif::printWarning("LocalPoolVector: Invalid index. Setting or returning"
-      "LocalPoolVector: Invalid index. Setting or returning"
             " last value!\n");
 #endif
     return value[vectorSize - 1];
@@ -117,23 +117,22 @@ inline const T& LocalPoolVector<T, vectorSize>::operator[](size_t i) const {
     // a configuration error, but I wont exit here.
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
-                  " last value!"
+            " last value!" << std::endl;
-               << std::endl;
 #else
-  sif::printWarning(
+    sif::printWarning("LocalPoolVector: Invalid index. Setting or returning"
-      "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(
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
-    uint8_t** buffer, size_t* size, size_t maxSize,
+        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);
+        result = SerializeAdapter::serialize(&(value[i]), buffer, size,
+                maxSize, streamEndianness);
         if (result != HasReturnvaluesIF::RETURN_OK) {
             break;
         }
@@ -148,10 +147,12 @@ inline size_t LocalPoolVector<T, vectorSize>::getSerializedSize() const {
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::deSerialize(
-    const uint8_t** buffer, size_t* size, SerializeIF::Endianness streamEndianness) {
+        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);
+        result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
+                streamEndianness);
         if (result != HasReturnvaluesIF::RETURN_OK) {
             break;
         }
@@ -161,7 +162,8 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::deSerialize(
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 template<typename T, uint16_t vectorSize>
-inline std::ostream& operator<<(std::ostream& out, const LocalPoolVector<T, vectorSize>& var) {
+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];

src/fsfw/datapoollocal/internal/CMakeLists.txt

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

src/fsfw/devicehandlers/AssemblyBase.cpp

@@ -26,11 +26,7 @@ void AssemblyBase::performChildOperation() {
 
 void AssemblyBase::startTransition(Mode_t mode, Submode_t submode) {
   doStartTransition(mode, submode);
-  if (modeHelper.isForced()) {
+  triggerModeHelperEvents(mode, submode);
-    triggerEvent(FORCING_MODE, mode, submode);
-  } else {
-    triggerEvent(CHANGING_MODE, mode, submode);
-  }
 }
 
 void AssemblyBase::doStartTransition(Mode_t mode, Submode_t submode) {
@@ -77,9 +73,10 @@ bool AssemblyBase::handleChildrenChangedHealth() {
   }
   HealthState healthState = healthHelper.healthTable->getHealth(iter->first);
   if (healthState == HasHealthIF::NEEDS_RECOVERY) {
-    triggerEvent(TRYING_RECOVERY);
+    triggerEvent(TRYING_RECOVERY, iter->first, 0);
     recoveryState = RECOVERY_STARTED;
     recoveringDevice = iter;
+    // The user needs to take care of commanding the children off in commandChildren
     doStartTransition(targetMode, targetSubmode);
   } else {
     triggerEvent(CHILD_CHANGED_HEALTH);
@@ -228,6 +225,9 @@ ReturnValue_t AssemblyBase::handleHealthReply(CommandMessage* message) {
 bool AssemblyBase::checkAndHandleRecovery() {
   switch (recoveryState) {
     case RECOVERY_STARTED:
+      // The recovery was already start in #handleChildrenChangedHealth and we just need
+      // to wait for an off time period.
+      // TODO: make time period configurable
       recoveryState = RECOVERY_WAIT;
       recoveryOffTimer.resetTimer();
       return true;
@@ -266,3 +266,11 @@ void AssemblyBase::overwriteDeviceHealth(object_id_t objectId, HasHealthIF::Heal
   modeHelper.setForced(true);
   sendHealthCommand(childrenMap[objectId].commandQueue, EXTERNAL_CONTROL);
 }
+
+void AssemblyBase::triggerModeHelperEvents(Mode_t mode, Submode_t submode) {
+  if (modeHelper.isForced()) {
+    triggerEvent(FORCING_MODE, mode, submode);
+  } else {
+    triggerEvent(CHANGING_MODE, mode, submode);
+  }
+}

src/fsfw/devicehandlers/AssemblyBase.h

@@ -12,7 +12,8 @@
  * Documentation: Dissertation Baetz p.156, 157.
  *
  * This class reduces the complexity of controller components which would
- * otherwise be needed for the handling of redundant devices.
+ * otherwise be needed for the handling of redundant devices. However, it can also be used to
+ * manage the mode keeping and recovery of non-redundant devices
  *
  * The template class monitors mode and health state of its children
  * and checks availability of devices on every detected change.
@@ -26,11 +27,9 @@
  *
  * Important:
  *
- * The implementation must call registerChild(object_id_t child)
+ * The implementation must call #registerChild for all commanded children during initialization.
- * for all commanded children during initialization.
  * The implementation must call the initialization function of the base class.
  * (This will call the function in SubsystemBase)
- *
  */
 class AssemblyBase : public SubsystemBase {
  public:
@@ -47,13 +46,14 @@ class AssemblyBase : public SubsystemBase {
 
  protected:
   /**
-   * Command children to reach [mode,submode] combination
+   * Command children to reach [mode,submode] combination. Can be done by setting
-   * Can be done by setting #commandsOutstanding correctly,
+   * #commandsOutstanding correctly, or using #executeTable. In case of an FDIR recovery,
-   * or using executeTable()
+   * the user needs to ensure that the target devices are healthy. If a device is not healthy,
+   * a recovery might be on-going and the device needs to be commanded to off first.
    * @param mode
    * @param submode
    * @return
-   *    - @c RETURN_OK if ok
+   *    - @c RETURN_OK if OK
    *    - @c NEED_SECOND_STEP if children need to be commanded again
    */
   virtual ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) = 0;
@@ -120,8 +120,19 @@ class AssemblyBase : public SubsystemBase {
 
   virtual ReturnValue_t handleHealthReply(CommandMessage *message);
 
-  virtual void performChildOperation();
+  /**
+   * @brief Default periodic handler
+   * @details
+   * This is the default periodic handler which will be called by the SubsystemBase
+   * performOperation. It performs the child transitions or reacts to changed health/mode states
+   * of children objects
+   */
+  virtual void performChildOperation() override;
 
+  /**
+   * This function handles changed mode or health states of children
+   * @return
+   */
   bool handleChildrenChanged();
 
   /**
@@ -134,12 +145,37 @@ class AssemblyBase : public SubsystemBase {
 
   bool handleChildrenChangedHealth();
 
+  /**
+   * Core transition handler. The default implementation will only do something if
+   * #commandsOutstanding is smaller or equal to zero, which means that all mode commands
+   * from the #doPerformTransition call were executed successfully.
+   *
+   * Unless a second step was requested, the function will then use #checkChildrenState to
+   * determine whether the target mode was reached.
+   *
+   * There is some special handling for certain (internal) modes:
+   *  - A second step is necessary. #commandChildren will be performed again
+   *  - The device health was overwritten. #commandChildren will be called
+   *  - A recovery is ongoing. #checkAndHandleRecovery will be called.
+   */
   virtual void handleChildrenTransition();
 
   ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode, uint32_t *msToReachTheMode);
 
+  /**
+   * Calls #doStartTransition and triggers an informative event as well that the mode will
+   * change
+   * @param mode
+   * @param submode
+   */
   virtual void startTransition(Mode_t mode, Submode_t submode);
 
+  /**
+   * This function starts the transition by setting the internal #targetSubmode and #targetMode
+   * variables and then calling the #commandChildren function.
+   * @param mode
+   * @param submode
+   */
   virtual void doStartTransition(Mode_t mode, Submode_t submode);
 
   virtual bool isInTransition();
@@ -160,7 +196,7 @@ class AssemblyBase : public SubsystemBase {
    * Manages recovery of a device
    * @return true if recovery is still ongoing, false else.
    */
-  bool checkAndHandleRecovery();
+  virtual bool checkAndHandleRecovery();
 
   /**
    * Helper method to overwrite health state of one of the children.
@@ -168,6 +204,8 @@ class AssemblyBase : public SubsystemBase {
    * @param objectId Must be a registered child.
    */
   void overwriteDeviceHealth(object_id_t objectId, HasHealthIF::HealthState oldHealth);
+
+  void triggerModeHelperEvents(Mode_t mode, Submode_t submode);
 };
 
 #endif /* FSFW_DEVICEHANDLERS_ASSEMBLYBASE_H_ */

src/fsfw/devicehandlers/CMakeLists.txt

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

src/fsfw/devicehandlers/DeviceHandlerBase.cpp

@@ -39,8 +39,9 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, object_id_t device
       childTransitionDelay(5000),
       transitionSourceMode(_MODE_POWER_DOWN),
       transitionSourceSubMode(SUBMODE_NONE) {
+  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
   commandQueue = QueueFactory::instance()->createMessageQueue(
-      cmdQueueSize, MessageQueueMessage::MAX_MESSAGE_SIZE);
+      cmdQueueSize, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
   insertInCommandMap(RAW_COMMAND_ID);
   cookieInfo.state = COOKIE_UNUSED;
   cookieInfo.pendingCommand = deviceCommandMap.end();
@@ -48,9 +49,6 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, object_id_t device
     printWarningOrError(sif::OutputTypes::OUT_ERROR, "DeviceHandlerBase",
                         HasReturnvaluesIF::RETURN_FAILED, "Invalid cookie");
   }
-  if (this->fdirInstance == nullptr) {
-    this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId, defaultFdirParentId);
-  }
 }
 
 void DeviceHandlerBase::setHkDestination(object_id_t hkDestination) {
@@ -126,6 +124,18 @@ ReturnValue_t DeviceHandlerBase::initialize() {
   if (result != RETURN_OK) {
     return result;
   }
+  if (this->fdirInstance == nullptr) {
+    this->fdirInstance =
+        new DeviceHandlerFailureIsolation(this->getObjectId(), defaultFdirParentId);
+  }
+
+  if (this->parent != objects::NO_OBJECT) {
+    HasModesIF* modeIF = ObjectManager::instance()->get<HasModesIF>(this->parent);
+    HasHealthIF* healthIF = ObjectManager::instance()->get<HasHealthIF>(this->parent);
+    if (modeIF != nullptr and healthIF != nullptr) {
+      setParentQueue(modeIF->getCommandQueue());
+    }
+  }
 
   communicationInterface =
       ObjectManager::instance()->get<DeviceCommunicationIF>(deviceCommunicationId);
@@ -352,14 +362,12 @@ void DeviceHandlerBase::doStateMachine() {
       }
     } break;
     case _MODE_WAIT_OFF: {
-      uint32_t currentUptime;
-      Clock::getUptime(&currentUptime);
-
       if (powerSwitcher == nullptr) {
         setMode(MODE_OFF);
         break;
       }
-
+      uint32_t currentUptime;
+      Clock::getUptime(&currentUptime);
       if (currentUptime - timeoutStart >= powerSwitcher->getSwitchDelayMs()) {
         triggerEvent(MODE_TRANSITION_FAILED, PowerSwitchIF::SWITCH_TIMEOUT, 0);
         setMode(MODE_ERROR_ON);
@@ -1399,6 +1407,8 @@ void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task) { executingTask = task;
 void DeviceHandlerBase::debugInterface(uint8_t positionTracker, object_id_t objectId,
                                        uint32_t parameter) {}
 
+Submode_t DeviceHandlerBase::getInitialSubmode() { return SUBMODE_NONE; }
+
 void DeviceHandlerBase::performOperationHook() {}
 
 ReturnValue_t DeviceHandlerBase::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
@@ -1421,7 +1431,7 @@ ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
   this->poolManager.initializeAfterTaskCreation();
 
   if (setStartupImmediately) {
-    startTransition(MODE_ON, SUBMODE_NONE);
+    startTransition(MODE_ON, getInitialSubmode());
   }
   return HasReturnvaluesIF::RETURN_OK;
 }
@@ -1505,3 +1515,11 @@ MessageQueueId_t DeviceHandlerBase::getCommanderQueueId(DeviceCommandId_t replyI
   }
   return commandIter->second.sendReplyTo;
 }
+
+void DeviceHandlerBase::setCustomFdir(FailureIsolationBase* fdir) { this->fdirInstance = fdir; }
+
+void DeviceHandlerBase::setParent(object_id_t parent) { this->parent = parent; }
+
+void DeviceHandlerBase::setPowerSwitcher(PowerSwitchIF* switcher) {
+  this->powerSwitcher = switcher;
+}

src/fsfw/devicehandlers/DeviceHandlerBase.h

@@ -103,6 +103,9 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication, CookieIF *comCookie,
                     FailureIsolationBase *fdirInstance = nullptr, size_t cmdQueueSize = 20);
 
+  void setCustomFdir(FailureIsolationBase *fdir);
+  void setParent(object_id_t parent);
+  void setPowerSwitcher(PowerSwitchIF *switcher);
   void setHkDestination(object_id_t hkDestination);
 
   /**
@@ -649,6 +652,12 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   virtual void debugInterface(uint8_t positionTracker = 0, object_id_t objectId = 0,
                               uint32_t parameter = 0);
 
+  /**
+   * @brief Can be overwritten by a child to specify the initial submode when device has been set
+   *        to startup immediately.
+   */
+  virtual Submode_t getInitialSubmode();
+
  protected:
   static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;
 
@@ -822,6 +831,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   /** Pointer to the used FDIR instance. If not provided by child,
    * default class is instantiated. */
   FailureIsolationBase *fdirInstance;
+  object_id_t parent = objects::NO_OBJECT;
 
   //! To correctly delete the default instance.
   bool defaultFDIRUsed;

src/fsfw/devicehandlers/DeviceHandlerFailureIsolation.cpp

@@ -29,6 +29,7 @@ ReturnValue_t DeviceHandlerFailureIsolation::eventReceived(EventMessage* event)
   switch (event->getEvent()) {
     case HasModesIF::MODE_TRANSITION_FAILED:
     case HasModesIF::OBJECT_IN_INVALID_MODE:
+    case DeviceHandlerIF::DEVICE_WANTS_HARD_REBOOT:
       // We'll try a recovery as long as defined in MAX_REBOOT.
       // Might cause some AssemblyBase cycles, so keep number low.
       handleRecovery(event->getEvent());

src/fsfw/devicehandlers/DeviceHandlerIF.h

@@ -109,6 +109,7 @@ class DeviceHandlerIF {
   static const Event INVALID_DEVICE_COMMAND = MAKE_EVENT(8, severity::LOW);
   static const Event MONITORING_LIMIT_EXCEEDED = MAKE_EVENT(9, severity::LOW);
   static const Event MONITORING_AMBIGUOUS = MAKE_EVENT(10, severity::HIGH);
+  static const Event DEVICE_WANTS_HARD_REBOOT = MAKE_EVENT(11, severity::HIGH);
 
   static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
 

src/fsfw/devicehandlers/HealthDevice.cpp

@@ -8,7 +8,9 @@ HealthDevice::HealthDevice(object_id_t setObjectId, MessageQueueId_t parentQueue
       parentQueue(parentQueue),
       commandQueue(),
       healthHelper(this, setObjectId) {
-  commandQueue = QueueFactory::instance()->createMessageQueue(3);
+  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
+  commandQueue = QueueFactory::instance()->createMessageQueue(
+      3, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
 
 HealthDevice::~HealthDevice() { QueueFactory::instance()->deleteMessageQueue(commandQueue); }

src/fsfw/events/CMakeLists.txt

@@ -1,3 +1,6 @@
-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/EventManager.cpp

@@ -18,8 +18,9 @@ const LocalPool::LocalPoolConfig EventManager::poolConfig = {
 EventManager::EventManager(object_id_t setObjectId)
     : SystemObject(setObjectId), factoryBackend(0, poolConfig, false, true) {
   mutex = MutexFactory::instance()->createMutex();
-  eventReportQueue = QueueFactory::instance()->createMessageQueue(MAX_EVENTS_PER_CYCLE,
+  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
-                                                                  EventMessage::EVENT_MESSAGE_SIZE);
+  eventReportQueue = QueueFactory::instance()->createMessageQueue(
+      MAX_EVENTS_PER_CYCLE, EventMessage::EVENT_MESSAGE_SIZE, &mqArgs);
 }
 
 EventManager::~EventManager() {
@@ -46,9 +47,20 @@ ReturnValue_t EventManager::performOperation(uint8_t opCode) {
 
 void EventManager::notifyListeners(EventMessage* message) {
   lockMutex();
-  for (auto iter = listenerList.begin(); iter != listenerList.end(); ++iter) {
+  for (auto& listener : listenerList) {
-    if (iter->second.match(message)) {
+    if (listener.second.match(message)) {
-      MessageQueueSenderIF::sendMessage(iter->first, message, message->getSender());
+      ReturnValue_t result =
+          MessageQueueSenderIF::sendMessage(listener.first, message, message->getSender());
+      if (result != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << std::hex << "EventManager::notifyListeners: MSG to 0x" << std::setfill('0')
+                   << std::setw(8) << listener.first << " failed with result 0x" << std::setw(4)
+                   << result << std::setfill(' ') << std::endl;
+#else
+        sif::printError("Sending message to listener 0x%08x failed with result %04x\n",
+                        listener.first, result);
+#endif
+      }
     }
   }
   unlockMutex();
@@ -189,4 +201,19 @@ void EventManager::printUtility(sif::OutputTypes printType, EventMessage* messag
   }
 }
 
+void EventManager::printListeners() {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::info << "Event manager listener MQ IDs:" << std::setfill('0') << std::hex << std::endl;
+  for (auto& listener : listenerList) {
+    sif::info << "0x" << std::setw(8) << listener.first << std::endl;
+  }
+  sif::info << std::dec << std::setfill(' ');
+#else
+  sif::printInfo("Event manager listener MQ IDs:\n");
+  for (auto& listener : listenerList) {
+    sif::printInfo("0x%08x\n", listener.first);
+  }
+#endif
+}
+
 #endif /* FSFW_OBJ_EVENT_TRANSLATION == 1 */

src/fsfw/events/EventManager.h

@@ -42,6 +42,7 @@ class EventManager : public EventManagerIF, public ExecutableObjectIF, public Sy
                                           object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
                                           bool reporterInverted = false);
   ReturnValue_t performOperation(uint8_t opCode);
+  void printListeners();
 
  protected:
   MessageQueueIF* eventReportQueue = nullptr;

src/fsfw/events/eventmatching/CMakeLists.txt

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

src/fsfw/events/fwSubsystemIdRanges.h

@@ -27,7 +27,6 @@ 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,3 +1,6 @@
-target_sources(
+target_sources(${LIB_FSFW_NAME} 
-  ${LIB_FSFW_NAME} PRIVATE EventCorrelation.cpp FailureIsolationBase.cpp
+	PRIVATE 
-                           FaultCounter.cpp)
+		EventCorrelation.cpp
+		FailureIsolationBase.cpp
+		FaultCounter.cpp
+)

src/fsfw/fdir/FailureIsolationBase.cpp

@@ -9,8 +9,9 @@
 FailureIsolationBase::FailureIsolationBase(object_id_t owner, object_id_t parent,
                                            uint8_t messageDepth, uint8_t parameterDomainBase)
     : ownerId(owner), faultTreeParent(parent), parameterDomainBase(parameterDomainBase) {
-  eventQueue =
+  auto mqArgs = MqArgs(owner, static_cast<void*>(this));
-      QueueFactory::instance()->createMessageQueue(messageDepth, EventMessage::EVENT_MESSAGE_SIZE);
+  eventQueue = QueueFactory::instance()->createMessageQueue(
+      messageDepth, EventMessage::EVENT_MESSAGE_SIZE, &mqArgs);
 }
 
 FailureIsolationBase::~FailureIsolationBase() {
@@ -52,10 +53,11 @@ ReturnValue_t FailureIsolationBase::initialize() {
     if (parentIF == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::error << "FailureIsolationBase::intialize: Parent object "
-                 << "invalid." << std::endl;
+                 << "invalid" << std::endl;
-#endif
+      sif::error << "Make sure it implements ConfirmsFailuresIF" << std::endl;
-#if FSFW_CPP_OSTREAM_ENABLED == 1
+#else
-      sif::error << "Make sure it implements ConfirmsFailuresIF." << std::endl;
+      sif::printError("FailureIsolationBase::intialize: Parent object invalid\n");
+      sif::printError("Make sure it implements ConfirmsFailuresIF\n");
 #endif
       return ObjectManagerIF::CHILD_INIT_FAILED;
       return RETURN_FAILED;

src/fsfw/fdir/FailureIsolationBase.h

@@ -14,13 +14,12 @@ class FailureIsolationBase : public HasReturnvaluesIF,
                              public HasParametersIF {
  public:
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FDIR_1;
-  static const Event FDIR_CHANGED_STATE =
+  //! FDIR has an internal state, which changed from par2 (oldState) to par1 (newState).
-      MAKE_EVENT(1, severity::INFO);  //!< FDIR has an internal state, which changed from par2
+  static const Event FDIR_CHANGED_STATE = MAKE_EVENT(1, severity::INFO);
-                                      //!< (oldState) to par1 (newState).
+  //! FDIR tries to restart device. Par1: event that caused recovery.
-  static const Event FDIR_STARTS_RECOVERY = MAKE_EVENT(
+  static const Event FDIR_STARTS_RECOVERY = MAKE_EVENT(2, severity::MEDIUM);
-      2, severity::MEDIUM);  //!< FDIR tries to restart device. Par1: event that caused recovery.
+  //! FDIR turns off device. Par1: event that caused recovery.
-  static const Event FDIR_TURNS_OFF_DEVICE = MAKE_EVENT(
+  static const Event FDIR_TURNS_OFF_DEVICE = MAKE_EVENT(3, severity::MEDIUM);
-      3, severity::MEDIUM);  //!< FDIR turns off device. Par1: event that caused recovery.
 
   FailureIsolationBase(object_id_t owner, object_id_t parent = objects::NO_OBJECT,
                        uint8_t messageDepth = 10, uint8_t parameterDomainBase = 0xF0);

src/fsfw/globalfunctions/CMakeLists.txt

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

src/fsfw/globalfunctions/DleParser.cpp

@@ -0,0 +1,231 @@
+#include "DleParser.h"
+
+#include <fsfw/globalfunctions/DleEncoder.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
+
+#include <cstdio>
+
+DleParser::DleParser(SimpleRingBuffer& decodeRingBuf, DleEncoder& decoder, BufPair encodedBuf,
+                     BufPair decodedBuf, UserHandler handler, void* args)
+    : decodeRingBuf(decodeRingBuf),
+      decoder(decoder),
+      encodedBuf(encodedBuf),
+      decodedBuf(decodedBuf),
+      handler(handler),
+      ctx(args) {
+  if (handler == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "DleParser::DleParser: Invalid user handler" << std::endl;
+#else
+    sif::printError("DleParser::DleParser: Invalid user handler\n");
+#endif
+  }
+}
+
+ReturnValue_t DleParser::passData(uint8_t* data, size_t len) {
+  if (data == nullptr or len == 0 or handler == nullptr) {
+    return RETURN_FAILED;
+  }
+  size_t copyIntoRingBufFromHere = 0;
+  size_t copyAmount = len;
+  size_t startIdx = 0;
+  ReturnValue_t result = RETURN_OK;
+  bool startFoundInThisPacket = false;
+  for (size_t idx = 0; idx < len; idx++) {
+    if (data[idx] == DleEncoder::STX_CHAR) {
+      if (not startFound and not startFoundInThisPacket) {
+        startIdx = idx;
+        copyIntoRingBufFromHere = idx;
+        copyAmount = len - idx;
+      } else {
+        // Maybe print warning, should not happen
+        decodeRingBuf.clear();
+        ErrorInfo info;
+        info.len = idx;
+        prepareErrorContext(ErrorTypes::CONSECUTIVE_STX_CHARS, info);
+        handler(ctx);
+        copyIntoRingBufFromHere = idx;
+        copyAmount = len - idx;
+      }
+      startFound = true;
+      startFoundInThisPacket = true;
+    } else if (data[idx] == DleEncoder::ETX_CHAR) {
+      if (startFoundInThisPacket) {
+        size_t readLen = 0;
+        size_t decodedLen = 0;
+        result = decoder.decode(data + startIdx, idx + 1 - startIdx, &readLen, decodedBuf.first,
+                                decodedBuf.second, &decodedLen);
+        if (result == HasReturnvaluesIF::RETURN_OK) {
+          ctx.setType(ContextType::PACKET_FOUND);
+          ctx.decodedPacket.first = decodedBuf.first;
+          ctx.decodedPacket.second = decodedLen;
+          this->handler(ctx);
+        } else if (result == DleEncoder::STREAM_TOO_SHORT) {
+          ErrorInfo info;
+          info.res = result;
+          prepareErrorContext(ErrorTypes::DECODING_BUF_TOO_SMALL, info);
+          handler(ctx);
+        } else {
+          ErrorInfo info;
+          info.res = result;
+          prepareErrorContext(ErrorTypes::DECODING_BUF_TOO_SMALL, info);
+          handler(ctx);
+        }
+        decodeRingBuf.clear();
+        if ((idx + 1) < len) {
+          copyIntoRingBufFromHere = idx + 1;
+          copyAmount = len - idx - 1;
+        } else {
+          copyAmount = 0;
+        }
+      } else if (startFound) {
+        // ETX found but STX was found in another mini packet. Reconstruct the full packet
+        // to decode it
+        result = decodeRingBuf.writeData(data, idx + 1);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+          ErrorInfo info;
+          info.res = result;
+          prepareErrorContext(ErrorTypes::RING_BUF_ERROR, info);
+          handler(ctx);
+        }
+        size_t fullEncodedLen = decodeRingBuf.getAvailableReadData();
+        if (fullEncodedLen > encodedBuf.second) {
+          ErrorInfo info;
+          info.len = fullEncodedLen;
+          prepareErrorContext(ErrorTypes::ENCODED_BUF_TOO_SMALL, info);
+          handler(ctx);
+          decodeRingBuf.clear();
+        } else {
+          size_t decodedLen = 0;
+          size_t readLen = 0;
+          decodeRingBuf.readData(encodedBuf.first, fullEncodedLen, true);
+          result = decoder.decode(encodedBuf.first, fullEncodedLen, &readLen, decodedBuf.first,
+                                  decodedBuf.second, &decodedLen);
+          if (result == HasReturnvaluesIF::RETURN_OK) {
+            if (this->handler != nullptr) {
+              ctx.setType(ContextType::PACKET_FOUND);
+              ctx.decodedPacket.first = decodedBuf.first;
+              ctx.decodedPacket.second = decodedLen;
+              this->handler(ctx);
+            }
+          } else if (result == DleEncoder::STREAM_TOO_SHORT) {
+            ErrorInfo info;
+            info.res = result;
+            prepareErrorContext(ErrorTypes::DECODING_BUF_TOO_SMALL, info);
+            handler(ctx);
+          } else {
+            ErrorInfo info;
+            info.res = result;
+            prepareErrorContext(ErrorTypes::DECODE_ERROR, info);
+            handler(ctx);
+          }
+          decodeRingBuf.clear();
+          startFound = false;
+          startFoundInThisPacket = false;
+          if ((idx + 1) < len) {
+            copyIntoRingBufFromHere = idx + 1;
+            copyAmount = len - idx - 1;
+          } else {
+            copyAmount = 0;
+          }
+        }
+      } else {
+        // End data without preceeding STX
+        ErrorInfo info;
+        info.len = idx + 1;
+        prepareErrorContext(ErrorTypes::CONSECUTIVE_ETX_CHARS, info);
+        handler(ctx);
+        decodeRingBuf.clear();
+        if ((idx + 1) < len) {
+          copyIntoRingBufFromHere = idx + 1;
+          copyAmount = len - idx - 1;
+        } else {
+          copyAmount = 0;
+        }
+      }
+      startFoundInThisPacket = false;
+      startFound = false;
+    }
+  }
+  if (copyAmount > 0) {
+    result = decodeRingBuf.writeData(data + copyIntoRingBufFromHere, copyAmount);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      ErrorInfo info;
+      info.res = result;
+      prepareErrorContext(ErrorTypes::RING_BUF_ERROR, info);
+      handler(ctx);
+    }
+  }
+  return RETURN_OK;
+}
+
+void DleParser::defaultFoundPacketHandler(uint8_t* packet, size_t len, void* args) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::info << "DleParserBase::handleFoundPacket: Detected DLE packet with " << len << " bytes"
+            << std::endl;
+#else
+  sif::printInfo("DleParserBase::handleFoundPacket: Detected DLE packet with %d bytes\n", len);
+#endif
+#endif
+}
+
+void DleParser::defaultErrorHandler(ErrorTypes err, ErrorInfo ctx) {
+  switch (err) {
+    case (ErrorTypes::NONE): {
+      errorPrinter("No error");
+      break;
+    }
+    case (ErrorTypes::DECODE_ERROR): {
+      errorPrinter("Decode Error");
+      break;
+    }
+    case (ErrorTypes::RING_BUF_ERROR): {
+      errorPrinter("Ring Buffer Error");
+      break;
+    }
+    case (ErrorTypes::ENCODED_BUF_TOO_SMALL):
+    case (ErrorTypes::DECODING_BUF_TOO_SMALL): {
+      char opt[64];
+      snprintf(opt, sizeof(opt), ": Too small for packet with length %zu", ctx.len);
+      if (err == ErrorTypes::ENCODED_BUF_TOO_SMALL) {
+        errorPrinter("Encoded buf too small", opt);
+      } else {
+        errorPrinter("Decoding buf too small", opt);
+      }
+      break;
+    }
+    case (ErrorTypes::CONSECUTIVE_STX_CHARS): {
+      errorPrinter("Consecutive STX chars detected");
+      break;
+    }
+    case (ErrorTypes::CONSECUTIVE_ETX_CHARS): {
+      errorPrinter("Consecutive ETX chars detected");
+      break;
+    }
+  }
+}
+
+void DleParser::errorPrinter(const char* str, const char* opt) {
+  if (opt == nullptr) {
+    opt = "";
+  }
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::info << "DleParserBase::handleParseError: " << str << opt << std::endl;
+#else
+  sif::printInfo("DleParserBase::handleParseError: %s%s\n", str, opt);
+#endif
+#endif
+}
+
+void DleParser::prepareErrorContext(ErrorTypes err, ErrorInfo info) {
+  ctx.setType(ContextType::ERROR);
+  ctx.error.first = err;
+  ctx.error.second = info;
+}
+
+void DleParser::reset() {
+  startFound = false;
+  decodeRingBuf.clear();
+}

src/fsfw/globalfunctions/DleParser.h

@@ -0,0 +1,127 @@
+#ifndef MISSION_DEVICES_DLEPARSER_H_
+#define MISSION_DEVICES_DLEPARSER_H_
+
+#include <fsfw/container/SimpleRingBuffer.h>
+#include <fsfw/globalfunctions/DleEncoder.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+#include <cstddef>
+#include <utility>
+
+/**
+ * @brief This base helper class can be used to extract DLE encoded packets from a data stream
+ * @details
+ * The core API of the parser takes received packets which can contains DLE packets. The parser
+ * can deal with DLE packets split across multiple packets. It does so by using a dedicated
+ * decoding ring buffer. The user can process received packets and detect errors by
+ * overriding two provided virtual methods. This also allows detecting multiple DLE packets
+ * inside one passed packet.
+ */
+class DleParser : public HasReturnvaluesIF {
+ public:
+  using BufPair = std::pair<uint8_t*, size_t>;
+
+  enum class ContextType { PACKET_FOUND, ERROR };
+
+  enum class ErrorTypes {
+    NONE,
+    ENCODED_BUF_TOO_SMALL,
+    DECODING_BUF_TOO_SMALL,
+    DECODE_ERROR,
+    RING_BUF_ERROR,
+    CONSECUTIVE_STX_CHARS,
+    CONSECUTIVE_ETX_CHARS
+  };
+
+  union ErrorInfo {
+    size_t len;
+    ReturnValue_t res;
+  };
+
+  using ErrorPair = std::pair<ErrorTypes, ErrorInfo>;
+
+  struct Context {
+   public:
+    Context(void* args) : userArgs(args) { setType(ContextType::PACKET_FOUND); }
+
+    void setType(ContextType type) {
+      if (type == ContextType::PACKET_FOUND) {
+        error.first = ErrorTypes::NONE;
+        error.second.len = 0;
+      } else {
+        decodedPacket.first = nullptr;
+        decodedPacket.second = 0;
+      }
+    }
+
+    ContextType getType() const { return type; }
+
+    BufPair decodedPacket = {};
+    ErrorPair error;
+    void* userArgs;
+
+   private:
+    ContextType type;
+  };
+
+  using UserHandler = void (*)(const Context& ctx);
+
+  /**
+   * Base class constructor
+   * @param decodeRingBuf Ring buffer used to store multiple packets to allow detecting DLE packets
+   * split across multiple packets
+   * @param decoder Decoder instance
+   * @param encodedBuf Buffer used to store encoded packets. It has to be large enough to hold
+   * the largest expected encoded DLE packet size
+   * @param decodedBuf Buffer used to store decoded packets. It has to be large enough to hold the
+   * largest expected decoded DLE packet size
+   * @param handler Function which will be called on a found packet
+   * @param args Arbitrary user argument
+   */
+  DleParser(SimpleRingBuffer& decodeRingBuf, DleEncoder& decoder, BufPair encodedBuf,
+            BufPair decodedBuf, UserHandler handler, void* args);
+
+  /**
+   * This function allows to pass new data into the parser. It then scans for DLE packets
+   * automatically and inserts (part of) the packet into a ring buffer if necessary.
+   * @param data
+   * @param len
+   * @return
+   */
+  ReturnValue_t passData(uint8_t* data, size_t len);
+
+  /**
+   * Example found packet handler
+   * function call
+   * @param packet Decoded packet
+   * @param len Length of detected packet
+   */
+  void defaultFoundPacketHandler(uint8_t* packet, size_t len, void* args);
+  /**
+   * Will be called if an error occured in the #passData call
+   * @param err
+   * @param ctx Context information depending on the error type
+   *  - For buffer length errors, will be set to the detected packet length which is too large
+   *  - For decode or ring buffer errors, will be set to the result returned from the failed call
+   */
+  static void defaultErrorHandler(ErrorTypes err, ErrorInfo ctx);
+
+  static void errorPrinter(const char* str, const char* opt = nullptr);
+
+  void prepareErrorContext(ErrorTypes err, ErrorInfo ctx);
+  /**
+   * Resets the parser by resetting the internal states and clearing the decoding ring buffer
+   */
+  void reset();
+
+ private:
+  SimpleRingBuffer& decodeRingBuf;
+  DleEncoder& decoder;
+  BufPair encodedBuf;
+  BufPair decodedBuf;
+  UserHandler handler = nullptr;
+  Context ctx;
+  bool startFound = false;
+};
+
+#endif /* MISSION_DEVICES_DLEPARSER_H_ */

src/fsfw/globalfunctions/math/CMakeLists.txt

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

src/fsfw/health/CMakeLists.txt

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

src/fsfw/health/HasHealthIF.h

@@ -23,19 +23,15 @@ class HasHealthIF {
   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);
-  static const Event OVERWRITING_HEALTH =
+  //! Assembly overwrites health information of children to keep satellite alive.
-      MAKE_EVENT(9, severity::LOW);  //!< Assembly overwrites health information of children to keep
+  static const Event OVERWRITING_HEALTH = MAKE_EVENT(9, severity::LOW);
-                                     //!< satellite alive.
+  //! Someone starts a recovery of a component (typically power-cycle). No parameters.
-  static const Event TRYING_RECOVERY =
+  static const Event TRYING_RECOVERY = MAKE_EVENT(10, severity::MEDIUM);
-      MAKE_EVENT(10, severity::MEDIUM);  //!< Someone starts a recovery of a component (typically
+  //! Recovery is ongoing. Comes twice during recovery.
-                                         //!< power-cycle). No parameters.
+  //! P1: 0 for the first, 1 for the second event. P2: 0
-  static const Event RECOVERY_STEP =
+  static const Event RECOVERY_STEP = MAKE_EVENT(11, severity::MEDIUM);
-      MAKE_EVENT(11, severity::MEDIUM);  //!< Recovery is ongoing. Comes twice during recovery. P1:
+  //! Recovery was completed. Not necessarily successful. No parameters.
-                                         //!< 0 for the first, 1 for the second event. P2: 0
+  static const Event RECOVERY_DONE = MAKE_EVENT(12, severity::MEDIUM);
-  static const Event RECOVERY_DONE = MAKE_EVENT(
-      12,
-      severity::MEDIUM);  //!< Recovery was completed. Not necessarily successful. No parameters.
-
   virtual ~HasHealthIF() {}
 
   virtual MessageQueueId_t getCommandQueue() const = 0;

src/fsfw/housekeeping/CMakeLists.txt

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

src/fsfw/internalerror/CMakeLists.txt

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

src/fsfw/internalerror/InternalErrorReporter.cpp

@@ -7,11 +7,13 @@
 
 InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId, uint32_t messageQueueDepth)
     : SystemObject(setObjectId),
-      commandQueue(QueueFactory::instance()->createMessageQueue(messageQueueDepth)),
       poolManager(this, commandQueue),
       internalErrorSid(setObjectId, InternalErrorDataset::ERROR_SET_ID),
       internalErrorDataset(this) {
   mutex = MutexFactory::instance()->createMutex();
+  auto mqArgs = MqArgs(setObjectId, static_cast<void *>(this));
+  commandQueue = QueueFactory::instance()->createMessageQueue(
+      messageQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
 
 InternalErrorReporter::~InternalErrorReporter() { MutexFactory::instance()->deleteMutex(mutex); }
@@ -36,15 +38,14 @@ ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
     if ((newQueueHits > 0) or (newTmHits > 0) or (newStoreHits > 0)) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::debug << "InternalErrorReporter::performOperation: Errors "
-                 << "occured!" << std::endl;
+                 << "occured: Queue | TM | Store : " << newQueueHits << " | " << newTmHits << " | "
-      sif::debug << "Queue errors: " << newQueueHits << std::endl;
+                 << newStoreHits << std::endl;
-      sif::debug << "TM errors: " << newTmHits << std::endl;
-      sif::debug << "Store errors: " << newStoreHits << std::endl;
 #else
-      sif::printDebug("InternalErrorReporter::performOperation: Errors occured!\n");
+      sif::printDebug(
-      sif::printDebug("Queue errors: %lu\n", static_cast<unsigned int>(newQueueHits));
+          "InternalErrorReporter::performOperation: Errors occured: Queue | TM | Store: %lu | %lu "
-      sif::printDebug("TM errors: %lu\n", static_cast<unsigned int>(newTmHits));
+          "| %lu\n",
-      sif::printDebug("Store errors: %lu\n", static_cast<unsigned int>(newStoreHits));
+          static_cast<unsigned int>(newQueueHits), static_cast<unsigned int>(newTmHits),
+          static_cast<unsigned int>(newStoreHits));
 #endif
     }
   }

src/fsfw/ipc/CMakeLists.txt

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

src/fsfw/memory/CMakeLists.txt

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

src/fsfw/modes/CMakeLists.txt

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

src/fsfw/modes/HasModesIF.h

@@ -19,32 +19,33 @@ class HasModesIF {
   static const ReturnValue_t INVALID_SUBMODE = MAKE_RETURN_CODE(0x04);
 
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER;
-  static const Event CHANGING_MODE =
+  //! An object announces changing the mode. p1: target mode. p2: target submode
-      MAKE_EVENT(0, severity::INFO);  //!< An object announces changing the mode. p1: target mode.
+  static const Event CHANGING_MODE = MAKE_EVENT(0, severity::INFO);
-                                      //!< p2: target submode
+  //! An Object announces its mode; parameter1 is mode, parameter2 is submode
-  static const Event MODE_INFO = MAKE_EVENT(
+  static const Event MODE_INFO = MAKE_EVENT(1, severity::INFO);
-      1,
-      severity::INFO);  //!< An Object announces its mode; parameter1 is mode, parameter2 is submode
   static const Event FALLBACK_FAILED = MAKE_EVENT(2, severity::HIGH);
   static const Event MODE_TRANSITION_FAILED = MAKE_EVENT(3, severity::LOW);
   static const Event CANT_KEEP_MODE = MAKE_EVENT(4, severity::HIGH);
-  static const Event OBJECT_IN_INVALID_MODE =
+  //! Indicates a bug or configuration failure: Object is in a mode it should never be in.
-      MAKE_EVENT(5, severity::LOW);  //!< Indicates a bug or configuration failure: Object is in a
+  static const Event OBJECT_IN_INVALID_MODE = MAKE_EVENT(5, severity::LOW);
-                                     //!< mode it should never be in.
+  //! The mode is changed, but for some reason, the change is forced, i.e. EXTERNAL_CONTROL ignored.
-  static const Event FORCING_MODE = MAKE_EVENT(
+  //! p1: target mode. p2: target submode
-      6, severity::MEDIUM);  //!< The mode is changed, but for some reason, the change is forced,
+  static const Event FORCING_MODE = MAKE_EVENT(6, severity::MEDIUM);
-                             //!< i.e. EXTERNAL_CONTROL ignored. p1: target mode. p2: target submode
+  //! A mode command was rejected by the called object. Par1: called object id, Par2: return code.
-  static const Event MODE_CMD_REJECTED =
+  static const Event MODE_CMD_REJECTED = MAKE_EVENT(7, severity::LOW);
-      MAKE_EVENT(7, severity::LOW);  //!< A mode command was rejected by the called object. Par1:
-                                     //!< called object id, Par2: return code.
 
-  static const Mode_t MODE_ON =
+  //! The device is powered and ready to perform operations. In this mode, no commands are
-      1;  //!< The device is powered and ready to perform operations. In this mode, no commands are
+  //! sent by the device handler itself, but direct commands van be commanded and will be
-          //!< sent by the device handler itself, but direct commands van be commanded and will be
+  //! interpreted
-          //!< interpreted
+  static constexpr Mode_t MODE_ON = 1;
-  static const Mode_t MODE_OFF = 0;  //!< The device is powered off. The only command accepted in
+  //! The device is powered off. The only command accepted in this mode is a mode change to on.
-                                     //!< this mode is a mode change to on.
+  static constexpr Mode_t MODE_OFF = 0;
-  static const Submode_t SUBMODE_NONE = 0;  //!< To avoid checks against magic number "0".
+
+  static constexpr Mode_t MODE_INVALID = -1;
+  static constexpr Mode_t MODE_UNDEFINED = -2;
+
+  //! To avoid checks against magic number "0".
+  static const Submode_t SUBMODE_NONE = 0;
 
   virtual ~HasModesIF() {}
   virtual MessageQueueId_t getCommandQueue() const = 0;

src/fsfw/monitoring/CMakeLists.txt

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

src/fsfw/objectmanager/CMakeLists.txt

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

src/fsfw/objectmanager/ObjectManager.cpp

@@ -95,13 +95,16 @@ void ObjectManager::initialize() {
   for (auto const& it : objectList) {
     result = it.second->initialize();
     if (result != RETURN_OK) {
+#if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-      object_id_t var = it.first;
       sif::error << "ObjectManager::initialize: Object 0x" << std::hex << std::setw(8)
-                 << std::setfill('0') << var
+                 << std::setfill('0') << it.first << " failed to initialize with code 0x" << result
-                 << " failed to "
+                 << std::dec << std::setfill(' ') << std::endl;
-                    "initialize with code 0x"
+#else
-                 << result << std::dec << std::setfill(' ') << std::endl;
+      sif::printError(
+          "ObjectManager::initialize: Object 0x%08x failed to initialize with code 0x%04x\n", var,
+          it.first);
+#endif
 #endif
       errorCount++;
     }

src/fsfw/objectmanager/frameworkObjects.h

@@ -14,7 +14,6 @@ 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

@@ -11,7 +11,9 @@ elseif(FSFW_OSAL MATCHES "host")
         add_subdirectory(windows)
     elseif(UNIX)
         # We still need to pull in some Linux specific sources
-    target_sources(${LIB_FSFW_NAME} PUBLIC linux/tcpipHelpers.cpp)
+        target_sources(${LIB_FSFW_NAME} PUBLIC
+            linux/tcpipHelpers.cpp
+        )
     endif ()
 
 else()

src/fsfw/osal/common/CMakeLists.txt

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

src/fsfw/osal/common/TcpTmTcServer.cpp

@@ -19,8 +19,6 @@
 #include <ws2tcpip.h>
 #elif defined(PLATFORM_UNIX)
 #include <netdb.h>
-
-#include <utility>
 #endif
 
 const std::string TcpTmTcServer::DEFAULT_SERVER_PORT = tcpip::DEFAULT_SERVER_PORT;
@@ -31,7 +29,7 @@ TcpTmTcServer::TcpTmTcServer(object_id_t objectId, object_id_t tmtcTcpBridge,
     : SystemObject(objectId),
       tmtcBridgeId(tmtcTcpBridge),
       receptionMode(receptionMode),
-      tcpConfig(std::move(customTcpServerPort)),
+      tcpConfig(customTcpServerPort),
       receptionBuffer(receptionBufferSize),
       ringBuffer(ringBufferSize, true) {}
 
@@ -105,12 +103,12 @@ ReturnValue_t TcpTmTcServer::initialize() {
 
 TcpTmTcServer::~TcpTmTcServer() { closeSocket(listenerTcpSocket); }
 
-[[noreturn]] ReturnValue_t TcpTmTcServer::performOperation(uint8_t opCode) {
+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 = {};
+  // sockaddr clientSockAddr = {};
-  socklen_t connectorSockAddrLen = 0;
+  // socklen_t connectorSockAddrLen = 0;
   int retval = 0;
 
   // Listen for connection requests permanently for lifetime of program
@@ -121,7 +119,8 @@ TcpTmTcServer::~TcpTmTcServer() { closeSocket(listenerTcpSocket); }
       continue;
     }
 
-    connSocket = accept(listenerTcpSocket, &clientSockAddr, &connectorSockAddrLen);
+    // connSocket = accept(listenerTcpSocket, &clientSockAddr, &connectorSockAddrLen);
+    connSocket = accept(listenerTcpSocket, nullptr, nullptr);
 
     if (connSocket == INVALID_SOCKET) {
       handleError(Protocol::TCP, ErrorSources::ACCEPT_CALL, 500);
@@ -136,10 +135,10 @@ TcpTmTcServer::~TcpTmTcServer() { closeSocket(listenerTcpSocket); }
     if (retval != 0) {
       handleError(Protocol::TCP, ErrorSources::SHUTDOWN_CALL);
     }
-
     closeSocket(connSocket);
     connSocket = 0;
   }
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t TcpTmTcServer::initializeAfterTaskCreation() {
@@ -160,7 +159,7 @@ void TcpTmTcServer::handleServerOperation(socket_t& connSocket) {
 #endif
 
   while (true) {
-    ssize_t retval = recv(connSocket, reinterpret_cast<char*>(receptionBuffer.data()),
+    int retval = recv(connSocket, reinterpret_cast<char*>(receptionBuffer.data()),
                       receptionBuffer.capacity(), tcpConfig.tcpFlags);
     if (retval == 0) {
       size_t availableReadData = ringBuffer.getAvailableReadData();
@@ -253,17 +252,17 @@ ReturnValue_t TcpTmTcServer::handleTcReception(uint8_t* spacePacket, size_t pack
   return result;
 }
 
-const std::string& TcpTmTcServer::getTcpPort() const { return tcpConfig.tcpPort; }
+std::string TcpTmTcServer::getTcpPort() const { return tcpConfig.tcpPort; }
 
-void TcpTmTcServer::setSpacePacketParsingOptions(std::vector<uint16_t> validPacketIds_) {
+void TcpTmTcServer::setSpacePacketParsingOptions(std::vector<uint16_t> validPacketIds) {
-  this->validPacketIds = std::move(validPacketIds_);
+  this->validPacketIds = 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 mg(tmtcBridge->mutex, tmtcBridge->timeoutType, tmtcBridge->mutexTimeoutMs);
+  MutexGuard(tmtcBridge->mutex, tmtcBridge->timeoutType, tmtcBridge->mutexTimeoutMs);
   store_address_t storeId;
   while ((not tmtcBridge->tmFifo->empty()) and
          (tmtcBridge->packetSentCounter < tmtcBridge->sentPacketsPerCycle)) {
@@ -284,7 +283,7 @@ ReturnValue_t TcpTmTcServer::handleTmSending(socket_t connSocket, bool& tmSent)
 #endif
       arrayprinter::print(storeAccessor.data(), storeAccessor.size());
     }
-    ssize_t retval = send(connSocket, reinterpret_cast<const char*>(storeAccessor.data()),
+    int 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
@@ -340,9 +339,6 @@ 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,7 +17,6 @@
 #endif
 
 #include <string>
-#include <utility>
 #include <vector>
 
 class TcpTmTcBridge;
@@ -45,7 +44,7 @@ class TcpTmTcServer : public SystemObject, public TcpIpBase, public ExecutableOb
 
   struct TcpConfig {
    public:
-    explicit TcpConfig(std::string tcpPort) : tcpPort(std::move(tcpPort)) {}
+    TcpConfig(std::string tcpPort) : tcpPort(tcpPort) {}
 
     /**
      * Passed to the recv call
@@ -85,7 +84,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);
-  ~TcpTmTcServer() override;
+  virtual ~TcpTmTcServer();
 
   void enableWiretapping(bool enable);
 
@@ -98,10 +97,10 @@ class TcpTmTcServer : public SystemObject, public TcpIpBase, public ExecutableOb
   void setSpacePacketParsingOptions(std::vector<uint16_t> validPacketIds);
 
   ReturnValue_t initialize() override;
-  [[noreturn]] ReturnValue_t performOperation(uint8_t opCode) override;
+  ReturnValue_t performOperation(uint8_t opCode) override;
   ReturnValue_t initializeAfterTaskCreation() override;
 
-  [[nodiscard]] const std::string& getTcpPort() const;
+  std::string getTcpPort() const;
 
  protected:
   StorageManagerIF* tcStore = nullptr;
@@ -116,7 +115,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/freertos/CMakeLists.txt

@@ -1,6 +1,6 @@
-target_sources(
+target_sources(${LIB_FSFW_NAME} 
-  ${LIB_FSFW_NAME}
+	PRIVATE 
-  PRIVATE Clock.cpp
+		Clock.cpp
 		FixedTimeslotTask.cpp
 		BinarySemaphore.cpp
 		BinSemaphUsingTask.cpp
@@ -15,16 +15,18 @@ target_sources(
 		TaskFactory.cpp
 		Timekeeper.cpp
 		TaskManagement.cpp
-          QueueMapManager.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 
 # library.
 if(NOT LIB_OS_NAME)
-  message(
+	message(STATUS
-    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

@@ -1,23 +1,27 @@
 #include "fsfw/osal/freertos/FixedTimeslotTask.h"
 
-#include "fsfw/serviceinterface.h"
+#include "fsfw/objectmanager/ObjectManager.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 
+uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
 const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = configMINIMAL_STACK_SIZE;
 
 FixedTimeslotTask::FixedTimeslotTask(TaskName name, TaskPriority setPriority,
-                                     TaskStackSize setStack, TaskPeriod period,
+                                     TaskStackSize setStack, TaskPeriod overallPeriod,
-                                     TaskDeadlineMissedFunction dlmFunc_)
+                                     void (*setDeadlineMissedFunc)())
-    : FixedTimeslotTaskBase(period, dlmFunc_), started(false), handle(nullptr) {
+    : started(false), handle(nullptr), pst(overallPeriod * 1000) {
   configSTACK_DEPTH_TYPE stackSize = setStack / sizeof(configSTACK_DEPTH_TYPE);
   xTaskCreate(taskEntryPoint, name, stackSize, this, setPriority, &handle);
+  // All additional attributes are applied to the object.
+  this->deadlineMissedFunc = setDeadlineMissedFunc;
 }
 
-FixedTimeslotTask::~FixedTimeslotTask() = default;
+FixedTimeslotTask::~FixedTimeslotTask() {}
 
 void FixedTimeslotTask::taskEntryPoint(void* argument) {
   // The argument is re-interpreted as FixedTimeslotTask. The Task object is
   // global, so it is found from any place.
-  auto* originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
+  FixedTimeslotTask* originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
   /* Task should not start until explicitly requested,
    * but in FreeRTOS, tasks start as soon as they are created if the scheduler
    * is running but not if the scheduler is not running.
@@ -28,18 +32,26 @@ void FixedTimeslotTask::taskEntryPoint(void* argument) {
    * can continue */
 
   if (not originalTask->started) {
-    vTaskSuspend(nullptr);
+    vTaskSuspend(NULL);
   }
 
   originalTask->taskFunctionality();
 #if FSFW_CPP_OSTREAM_ENABLED == 1
   sif::debug << "Polling task " << originalTask->handle << " returned from taskFunctionality."
              << std::endl;
-#else
-  sif::printDebug("Polling task returned from taskFunctionality\n");
 #endif
 }
 
+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;
+#endif
+  }
+}
+
 ReturnValue_t FixedTimeslotTask::startTask() {
   started = true;
 
@@ -51,12 +63,31 @@ ReturnValue_t FixedTimeslotTask::startTask() {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-[[noreturn]] void FixedTimeslotTask::taskFunctionality() {
+ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId, uint32_t slotTimeMs,
+                                         int8_t executionStep) {
+  ExecutableObjectIF* handler = ObjectManager::instance()->get<ExecutableObjectIF>(componentId);
+  if (handler != nullptr) {
+    pst.addSlot(componentId, slotTimeMs, executionStep, handler, this);
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::error << "Component " << std::hex << componentId << " not found, not adding it to pst"
+             << std::endl;
+#endif
+  return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+uint32_t FixedTimeslotTask::getPeriodMs() const { return pst.getLengthMs(); }
+
+ReturnValue_t FixedTimeslotTask::checkSequence() const { return pst.checkSequence(); }
+
+void FixedTimeslotTask::taskFunctionality() {
   // A local iterator for the Polling Sequence Table is created to find the
   // start time for the first entry.
-  auto slotListIter = pollingSeqTable.current;
+  auto slotListIter = pst.current;
 
-  pollingSeqTable.intializeSequenceAfterTaskCreation();
+  pst.intializeSequenceAfterTaskCreation();
 
   // The start time for the first entry is read.
   uint32_t intervalMs = slotListIter->pollingTimeMs;
@@ -77,10 +108,10 @@ ReturnValue_t FixedTimeslotTask::startTask() {
   /* Enter the loop that defines the task behavior. */
   for (;;) {
     // The component for this slot is executed and the next one is chosen.
-    this->pollingSeqTable.executeAndAdvance();
+    this->pst.executeAndAdvance();
-    if (not pollingSeqTable.slotFollowsImmediately()) {
+    if (not pst.slotFollowsImmediately()) {
       // Get the interval till execution of the next slot.
-      intervalMs = this->pollingSeqTable.getIntervalToPreviousSlotMs();
+      intervalMs = this->pst.getIntervalToPreviousSlotMs();
       interval = pdMS_TO_TICKS(intervalMs);
 
 #if (tskKERNEL_VERSION_MAJOR == 10 && tskKERNEL_VERSION_MINOR >= 4) || tskKERNEL_VERSION_MAJOR > 10
@@ -101,8 +132,8 @@ ReturnValue_t FixedTimeslotTask::startTask() {
 }
 
 void FixedTimeslotTask::handleMissedDeadline() {
-  if (dlmFunc != nullptr) {
+  if (deadlineMissedFunc != nullptr) {
-    dlmFunc();
+    this->deadlineMissedFunc();
   }
 }
 

src/fsfw/osal/freertos/FixedTimeslotTask.h

@@ -4,11 +4,11 @@
 #include "FreeRTOS.h"
 #include "FreeRTOSTaskIF.h"
 #include "fsfw/tasks/FixedSlotSequence.h"
-#include "fsfw/tasks/FixedTimeslotTaskBase.h"
+#include "fsfw/tasks/FixedTimeslotTaskIF.h"
-#include "fsfw/tasks/definitions.h"
+#include "fsfw/tasks/Typedef.h"
 #include "task.h"
 
-class FixedTimeslotTask : public FixedTimeslotTaskBase, public FreeRTOSTaskIF {
+class FixedTimeslotTask : public FixedTimeslotTaskIF, public FreeRTOSTaskIF {
  public:
   /**
    * Keep in mind that you need to call before vTaskStartScheduler()!
@@ -23,7 +23,7 @@ class FixedTimeslotTask : public FixedTimeslotTaskBase, public FreeRTOSTaskIF {
    * @return Pointer to the newly created task.
    */
   FixedTimeslotTask(TaskName name, TaskPriority setPriority, TaskStackSize setStack,
-                    TaskPeriod overallPeriod, TaskDeadlineMissedFunction dlmFunc);
+                    TaskPeriod overallPeriod, void (*setDeadlineMissedFunc)());
 
   /**
    * @brief	The destructor of the class.
@@ -32,9 +32,26 @@ class FixedTimeslotTask : public FixedTimeslotTaskBase, public FreeRTOSTaskIF {
    * initialization for the PST and the device handlers. This is done by
    * calling the PST's destructor.
    */
-  ~FixedTimeslotTask() override;
+  virtual ~FixedTimeslotTask(void);
 
-  ReturnValue_t startTask() override;
+  ReturnValue_t startTask(void);
+  /**
+   * This static function can be used as #deadlineMissedFunc.
+   * It counts missedDeadlines and prints the number of missed deadlines
+   * every 10th time.
+   */
+  static void missedDeadlineCounter();
+  /**
+   * A helper variable to count missed deadlines.
+   */
+  static uint32_t deadlineMissedCount;
+
+  ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
+                        int8_t executionStep) override;
+
+  uint32_t getPeriodMs() const override;
+
+  ReturnValue_t checkSequence() const override;
 
   ReturnValue_t sleepFor(uint32_t ms) override;
 
@@ -44,6 +61,17 @@ class FixedTimeslotTask : public FixedTimeslotTaskBase, public FreeRTOSTaskIF {
   bool started;
   TaskHandle_t handle;
 
+  FixedSlotSequence pst;
+
+  /**
+   * @brief	This attribute holds a function pointer that is executed when
+   *          a deadline was missed.
+   * @details
+   * Another function may be announced to determine the actions to perform
+   * when a deadline was missed. Currently, only one function for missing
+   * any deadline is allowed. If not used, it shall be declared NULL.
+   */
+  void (*deadlineMissedFunc)(void);
   /**
    * @brief	This is the entry point for a new task.
    * @details
@@ -60,7 +88,7 @@ class FixedTimeslotTask : public FixedTimeslotTaskBase, public FreeRTOSTaskIF {
    * It links the functionalities provided by FixedSlotSequence with the
    * OS's System Calls to keep the timing of the periods.
    */
-  [[noreturn]] void taskFunctionality();
+  void taskFunctionality(void);
 
   void handleMissedDeadline();
 };

src/fsfw/osal/freertos/FreeRTOSTaskIF.h

@@ -6,11 +6,11 @@
 
 class FreeRTOSTaskIF {
  public:
-  virtual ~FreeRTOSTaskIF() = default;
+  virtual ~FreeRTOSTaskIF() {}
   virtual TaskHandle_t getTaskHandle() = 0;
 
  protected:
-  static bool checkMissedDeadline(const TickType_t xLastWakeTime, const TickType_t interval) {
+  bool checkMissedDeadline(const TickType_t xLastWakeTime, const TickType_t interval) {
     /* Check whether deadline was missed while also taking overflows
      * into account. Drawing this on paper with a timeline helps to understand
      * it. */