Merge branch 'develop' into mueller/spi-speed-mode-getter

CHANGELOG.md

@@ -25,8 +25,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
@@ -42,39 +45,12 @@ 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
-
-### 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
+- Clock: 
+  - `timeval` to `TimeOfDay_t`
+  - Added Mutex for gmtime calls: (compare http://www.opengate.at/blog/2020/01/timeless/)
+  - Moved the statics used by Clock in ClockCommon.cpp to this file
+  - Better check for leap seconds
+  - Added Unittests for Clock (only getter)
 
 ## Removed
 
@@ -84,32 +60,11 @@ https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593
 
 ## Additions
 
-- LTO support: Allow using LTO/IPO by setting `FSFW_ENABLE_LTO=1`. CMake is able to detect whether
-  the user compiler supports IPO/LPO. LTO is on by default now. Most modern compilers support it,
-  can make good use of it and it usually makes the code faster and/or smaller.
-  After some more research:
-  Enabling LTO will actually cause the compiler to only produce thin LTO by adding 
-  `-flto -fno-fat-lto-objects` to the compiler options. I am not sure this is an ideal choice
-  because if an application linking against the FSFW does not use LTO, there can be compile
-  issues (e.g. observed when compiling the FSFW tests without LTO). This is a known issue as
-  can be seen in the multiple CMake issues for it: 
-    - https://gitlab.kitware.com/cmake/cmake/-/issues/22913, 
-    - https://gitlab.kitware.com/cmake/cmake/-/issues/16808, 
-    - https://gitlab.kitware.com/cmake/cmake/-/issues/21696
-  Easiest solution for now: Keep this option OFF by default.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/616
 - Dedicated Version class and constant `fsfw::FSFW_VERSION` containing version information
   inside `fsfw/version.h`
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/559
-- Added generic PUS TC Scheduler Service 11. It depends on the new added Emebeded Template Library
-  (ETL) dependency.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/594
 - Added ETL dependency and improved library dependency management
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/592
-- Add a `DummyPowerSwitcher` module which can be useful for test setups when no PCDU is available
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
-- New typedef for switcher type
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
 - `Subsystem`: New API to add table and sequence entries
 
 ## HAL

CMakeLists.txt

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

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

@@ -1,4 +1,4 @@
-#
+# 
 # Internal file for GetGitRevisionDescription.cmake
 #
 # Requires CMake 2.6 or newer (uses the 'function' command)
@@ -8,12 +8,10 @@
 # http://academic.cleardefinition.com
 # Iowa State University HCI Graduate Program/VRAC
 #
-# Copyright 2009-2012, Iowa State University
-# Copyright 2011-2015, Contributors
+# 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)
-# SPDX-License-Identifier: BSL-1.0
 
 set(HEAD_HASH)
 
@@ -24,13 +22,10 @@ if(HEAD_CONTENTS MATCHES "ref")
     # named branch
     string(REPLACE "ref: " "" HEAD_REF "${HEAD_CONTENTS}")
     if(EXISTS "@GIT_DIR@/${HEAD_REF}")
-        configure_file("@GIT_DIR@/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY)
-    else()
-        configure_file("@GIT_DIR@/packed-refs" "@GIT_DATA@/packed-refs" COPYONLY)
-        file(READ "@GIT_DATA@/packed-refs" PACKED_REFS)
-        if(${PACKED_REFS} MATCHES "([0-9a-z]*) ${HEAD_REF}")
-            set(HEAD_HASH "${CMAKE_MATCH_1}")
-        endif()
+    configure_file("@GIT_DIR@/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY)
+    elseif(EXISTS "@GIT_DIR@/logs/${HEAD_REF}")
+        configure_file("@GIT_DIR@/logs/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY)
+        set(HEAD_HASH "${HEAD_REF}")
     endif()
 else()
     # detached HEAD
@@ -38,6 +33,6 @@ else()
 endif()
 
 if(NOT HEAD_HASH)
-    file(READ "@GIT_DATA@/head-ref" HEAD_HASH LIMIT 1024)
-    string(STRIP "${HEAD_HASH}" HEAD_HASH)
+file(READ "@GIT_DATA@/head-ref" HEAD_HASH LIMIT 1024)
+string(STRIP "${HEAD_HASH}" HEAD_HASH)
 endif()

cmake/cmake-modules/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
-[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.
+The license file in included here as well.

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/devicehandlers/GyroL3GD20Handler.cpp

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

hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp

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

hal/src/fsfw_hal/devicehandlers/MgmRM3100Handler.cpp

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

hal/src/fsfw_hal/linux/CommandExecutor.cpp

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

hal/src/fsfw_hal/linux/CommandExecutor.h

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

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;
   }
 

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

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

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

@@ -194,22 +194,16 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
 
   bool fullDuplex = spiCookie->isFullDuplex();
   gpioId_t gpioId = spiCookie->getChipSelectPin();
-  bool csLockManual = spiCookie->getCsLockManual();
 
-  MutexIF::TimeoutType csType;
-  dur_millis_t csTimeout = 0;
-  // Pull SPI CS low. For now, no support for active high given
-  if (gpioId != gpio::NO_GPIO and not csLockManual) {
-    spiCookie->getMutexParams(csType, csTimeout);
-    result = csMutex->lockMutex(csType, csTimeout);
+  /* Pull SPI CS low. For now, no support for active high given  */
+  if (gpioId != gpio::NO_GPIO) {
+    result = csMutex->lockMutex(timeoutType, timeoutMs);
     if (result != RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::error << "SpiComIF::sendMessage: Failed to lock mutex with code "
-                 << "0x" << std::hex << std::setfill('0') << std::setw(4) << result << std::dec
-                 << std::endl;
+      sif::error << "SpiComIF::sendMessage: Failed to lock mutex" << std::endl;
 #else
-      sif::printError("SpiComIF::sendMessage: Failed to lock mutex with code %d\n", result);
+      sif::printError("SpiComIF::sendMessage: Failed to lock mutex\n");
 #endif
 #endif
       return result;
@@ -255,7 +249,7 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
     }
   }
 
-  if (gpioId != gpio::NO_GPIO and not csLockManual) {
+  if (gpioId != gpio::NO_GPIO) {
     gpioComIF->pullHigh(gpioId);
     result = csMutex->unlockMutex();
     if (result != RETURN_OK) {
@@ -298,22 +292,12 @@ ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
     return result;
   }
 
-  bool csLockManual = spiCookie->getCsLockManual();
   gpioId_t gpioId = spiCookie->getChipSelectPin();
-  MutexIF::TimeoutType csType;
-  dur_millis_t csTimeout = 0;
-  if (gpioId != gpio::NO_GPIO and not csLockManual) {
-    spiCookie->getMutexParams(csType, csTimeout);
-    result = csMutex->lockMutex(csType, csTimeout);
+  if (gpioId != gpio::NO_GPIO) {
+    result = csMutex->lockMutex(timeoutType, timeoutMs);
     if (result != RETURN_OK) {
-#if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::error << "SpiComIF::sendMessage: Failed to lock mutex with code "
-                 << "0x" << std::hex << std::setfill('0') << std::setw(4) << result << std::dec
-                 << std::endl;
-#else
-      sif::printError("SpiComIF::sendMessage: Failed to lock mutex with code %d\n", result);
-#endif
+      sif::error << "SpiComIF::getSendSuccess: Failed to lock mutex" << std::endl;
 #endif
       return result;
     }
@@ -331,7 +315,7 @@ ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
     result = HALF_DUPLEX_TRANSFER_FAILED;
   }
 
-  if (gpioId != gpio::NO_GPIO and not csLockManual) {
+  if (gpioId != gpio::NO_GPIO) {
     gpioComIF->pullHigh(gpioId);
     result = csMutex->unlockMutex();
     if (result != RETURN_OK) {
@@ -362,7 +346,15 @@ ReturnValue_t SpiComIF::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-MutexIF* SpiComIF::getCsMutex() { return csMutex; }
+MutexIF* SpiComIF::getMutex(MutexIF::TimeoutType* timeoutType, uint32_t* timeoutMs) {
+  if (timeoutType != nullptr) {
+    *timeoutType = this->timeoutType;
+  }
+  if (timeoutMs != nullptr) {
+    *timeoutMs = this->timeoutMs;
+  }
+  return csMutex;
+}
 
 void SpiComIF::performSpiWiretapping(SpiCookie* spiCookie) {
   if (spiCookie == nullptr) {
@@ -425,7 +417,9 @@ void SpiComIF::getSpiSpeedAndMode(int spiFd, spi::SpiModes& mode, uint32_t& spee
   }
 }
 
-const std::string& SpiComIF::getSpiDev() const { return dev; }
+const std::string& SpiComIF::getSpiDev() const {
+  return dev;
+}
 
 void SpiComIF::updateLinePolarity(int spiFd) {
   clockUpdateTransfer.len = 0;

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

@@ -22,15 +22,15 @@ class SpiCookie;
  */
 class SpiComIF : public DeviceCommunicationIF, public SystemObject {
  public:
-  static constexpr uint8_t CLASS_ID = CLASS_ID::HAL_SPI;
+  static constexpr uint8_t spiRetvalId = CLASS_ID::HAL_SPI;
   static constexpr ReturnValue_t OPENING_FILE_FAILED =
-      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 0);
+      HasReturnvaluesIF::makeReturnCode(spiRetvalId, 0);
   /* Full duplex (ioctl) transfer failure */
   static constexpr ReturnValue_t FULL_DUPLEX_TRANSFER_FAILED =
-      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 1);
+      HasReturnvaluesIF::makeReturnCode(spiRetvalId, 1);
   /* Half duplex (read/write) transfer failure */
   static constexpr ReturnValue_t HALF_DUPLEX_TRANSFER_FAILED =
-      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 2);
+      HasReturnvaluesIF::makeReturnCode(spiRetvalId, 2);
 
   SpiComIF(object_id_t objectId, std::string devname, GpioIF* gpioComIF);
 
@@ -44,8 +44,7 @@ class SpiComIF : public DeviceCommunicationIF, public SystemObject {
    * @brief   This function returns the mutex which can be used to protect the spi bus when
    *          the chip select must be driven from outside of the com if.
    */
-  MutexIF* getCsMutex();
-  void setMutexParams(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs);
+  MutexIF* getMutex(MutexIF::TimeoutType* timeoutType = nullptr, uint32_t* timeoutMs = nullptr);
 
   /**
    * Perform a regular send operation using Linux iotcl. This is public so it can be used
@@ -60,7 +59,6 @@ class SpiComIF : public DeviceCommunicationIF, public SystemObject {
 
   GpioIF* getGpioInterface();
   void setSpiSpeedAndMode(int spiFd, spi::SpiModes mode, uint32_t speed);
-  void getSpiSpeedAndMode(int spiFd, spi::SpiModes& mode, uint32_t& speed) const;
 
   /**
    * This updates the SPI clock default polarity. Only setting the mode does not update
@@ -72,6 +70,7 @@ class SpiComIF : public DeviceCommunicationIF, public SystemObject {
    * @param spiFd
    */
   void updateLinePolarity(int spiFd);
+  void getSpiSpeedAndMode(int spiFd, spi::SpiModes& mode, uint32_t& speed) const;
 
   const std::string& getSpiDev() const;
   void performSpiWiretapping(SpiCookie* spiCookie);
@@ -91,8 +90,8 @@ class SpiComIF : public DeviceCommunicationIF, public SystemObject {
    * pulled high
    */
   MutexIF* csMutex = nullptr;
-  // MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
-  // uint32_t timeoutMs = DEFAULT_MUTEX_TIMEOUT;
+  MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+  uint32_t timeoutMs = 20;
   spi_ioc_transfer clockUpdateTransfer = {};
 
   using SpiDeviceMap = std::unordered_map<address_t, SpiInstance>;

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

@@ -104,17 +104,3 @@ void SpiCookie::getCallback(spi::send_callback_function_t* callback, void** args
   *callback = this->sendCallback;
   *args = this->callbackArgs;
 }
-
-void SpiCookie::setCsLockManual(bool enable) { manualCsLock = enable; }
-
-bool SpiCookie::getCsLockManual() const { return manualCsLock; }
-
-void SpiCookie::getMutexParams(MutexIF::TimeoutType& csTimeoutType, dur_millis_t& csTimeout) const {
-  csTimeoutType = this->csTimeoutType;
-  csTimeout = this->csTimeout;
-}
-
-void SpiCookie::setMutexParams(MutexIF::TimeoutType csTimeoutType, dur_millis_t csTimeout) {
-  this->csTimeoutType = csTimeoutType;
-  this->csTimeout = csTimeout;
-}

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

@@ -2,8 +2,6 @@
 #define LINUX_SPI_SPICOOKIE_H_
 
 #include <fsfw/devicehandlers/CookieIF.h>
-#include <fsfw/ipc/MutexIF.h>
-#include <fsfw/timemanager/clockDefinitions.h>
 #include <linux/spi/spidev.h>
 
 #include "../../common/gpio/gpioDefinitions.h"
@@ -22,8 +20,6 @@
  */
 class SpiCookie : public CookieIF {
  public:
-  static constexpr dur_millis_t DEFAULT_MUTEX_TIMEOUT = 20;
-
   /**
    * Each SPI device will have a corresponding cookie. The cookie is used by the communication
    * interface and contains device specific information like the largest expected size to be
@@ -141,42 +137,9 @@ class SpiCookie : public CookieIF {
    */
   void activateCsDeselect(bool deselectCs, uint16_t delayUsecs);
 
-  void getMutexParams(MutexIF::TimeoutType& csTimeoutType, dur_millis_t& csTimeout) const;
-  void setMutexParams(MutexIF::TimeoutType csTimeoutType, dur_millis_t csTimeout);
-
-  void setCsLockManual(bool enable);
-  bool getCsLockManual() const;
-
   spi_ioc_transfer* getTransferStructHandle();
 
  private:
-  address_t spiAddress;
-  gpioId_t chipSelectPin;
-
-  spi::SpiComIfModes comIfMode;
-
-  // Required for regular mode
-  const size_t maxSize;
-  spi::SpiModes spiMode;
-  /**
-   * If this is set to true, the SPI ComIF will not perform any mutex locking for the
-   * CS mechanism. The user is responsible to locking and unlocking the mutex for the
-   * whole duration of the transfers.
-   */
-  bool manualCsLock = false;
-  uint32_t spiSpeed;
-  bool halfDuplex = false;
-
-  MutexIF::TimeoutType csTimeoutType = MutexIF::TimeoutType::WAITING;
-  dur_millis_t csTimeout = DEFAULT_MUTEX_TIMEOUT;
-
-  // Required for callback mode
-  spi::send_callback_function_t sendCallback = nullptr;
-  void* callbackArgs = nullptr;
-
-  struct spi_ioc_transfer spiTransferStruct = {};
-  UncommonParameters uncommonParameters;
-
   /**
    * Internal constructor which initializes every field
    * @param spiAddress
@@ -191,6 +154,24 @@ class SpiCookie : public CookieIF {
   SpiCookie(spi::SpiComIfModes comIfMode, address_t spiAddress, gpioId_t chipSelect,
             const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed,
             spi::send_callback_function_t callback, void* args);
+
+  address_t spiAddress;
+  gpioId_t chipSelectPin;
+
+  spi::SpiComIfModes comIfMode;
+
+  // Required for regular mode
+  const size_t maxSize;
+  spi::SpiModes spiMode;
+  uint32_t spiSpeed;
+  bool halfDuplex = false;
+
+  // Required for callback mode
+  spi::send_callback_function_t sendCallback = nullptr;
+  void* callbackArgs = nullptr;
+
+  struct spi_ioc_transfer spiTransferStruct = {};
+  UncommonParameters uncommonParameters;
 };
 
 #endif /* LINUX_SPI_SPICOOKIE_H_ */

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

src/CMakeLists.txt

@@ -1,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}
-                           INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})
+target_include_directories(${LIB_FSFW_NAME} INTERFACE
+    ${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
 
@@ -35,22 +37,22 @@ add_subdirectory(tmtcservices)
 # Optional
 
 if(FSFW_ADD_MONITORING)
-  add_subdirectory(monitoring)
+add_subdirectory(monitoring)
 endif()
 if(FSFW_ADD_PUS)
-  add_subdirectory(pus)
+    add_subdirectory(pus)
 endif()
 if(FSFW_ADD_TMSTORAGE)
-  add_subdirectory(tmstorage)
+    add_subdirectory(tmstorage)
 endif()
 if(FSFW_ADD_COORDINATES)
-  add_subdirectory(coordinates)
+    add_subdirectory(coordinates)
 endif()
 if(FSFW_ADD_RMAP)
-  add_subdirectory(rmap)
+    add_subdirectory(rmap)
 endif()
 if(FSFW_ADD_DATALINKLAYER)
-  add_subdirectory(datalinklayer)
+    add_subdirectory(datalinklayer)
 endif()
 
 # OSAL

src/fsfw/FSFWVersion.h.in

@@ -6,6 +6,6 @@ static constexpr int FSFW_VERSION_MAJOR = @FSFW_VERSION@;
 static constexpr int FSFW_VERSION_MINOR = @FSFW_SUBVERSION@;
 static constexpr int FSFW_VERSION_REVISION = @FSFW_REVISION@;
 // Also contains CST (Commits since tag) information
-static const char FSFW_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(
-  ${LIB_FSFW_NAME} PRIVATE ActionHelper.cpp ActionMessage.cpp
-                           CommandActionHelper.cpp SimpleActionHelper.cpp)
+target_sources(${LIB_FSFW_NAME} 
+    PRIVATE 
+        ActionHelper.cpp
+        ActionMessage.cpp
+        CommandActionHelper.cpp
+        SimpleActionHelper.cpp
+)

src/fsfw/cfdp/CMakeLists.txt

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

src/fsfw/cfdp/tlv/CMakeLists.txt

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

src/fsfw/container/CMakeLists.txt

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

src/fsfw/container/FIFOBase.tpp

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

src/fsfw/container/FixedOrderedMultimap.tpp

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

src/fsfw/controller/CMakeLists.txt

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

src/fsfw/coordinates/CMakeLists.txt

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

src/fsfw/datalinklayer/CMakeLists.txt

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

src/fsfw/datapool/CMakeLists.txt

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

src/fsfw/datapoollocal/CMakeLists.txt

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

src/fsfw/datapoollocal/LocalDataPoolManager.cpp

@@ -577,9 +577,6 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(CommandMessage* me
 
   CommandMessage reply;
   if (result != HasReturnvaluesIF::RETURN_OK) {
-    if(result == WRONG_HK_PACKET_TYPE) {
-      printWarningOrError(sif::OutputTypes::OUT_WARNING, "handleHousekeepingMessage", WRONG_HK_PACKET_TYPE);
-    }
     HousekeepingMessage::setHkRequestFailureReply(&reply, sid, result);
   } else {
     HousekeepingMessage::setHkRequestSuccessReply(&reply, sid);
@@ -699,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
   }
 }
@@ -837,8 +834,6 @@ void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
       errorPrint = "Dataset not found";
     } else if (error == POOLOBJECT_NOT_FOUND) {
       errorPrint = "Pool Object not found";
-    } else if (error == WRONG_HK_PACKET_TYPE) {
-      errorPrint = "Wrong Packet Type";
     } else if (error == HasReturnvaluesIF::RETURN_FAILED) {
       if (outputType == sif::OutputTypes::OUT_WARNING) {
         errorPrint = "Generic Warning";

src/fsfw/datapoollocal/LocalPoolVariable.tpp

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

src/fsfw/datapoollocal/LocalPoolVector.tpp

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

src/fsfw/datapoollocal/internal/CMakeLists.txt

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

src/fsfw/devicehandlers/CMakeLists.txt

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

src/fsfw/devicehandlers/DeviceHandlerBase.cpp

@@ -572,9 +572,6 @@ void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
   mode = newMode;
   modeChanged();
   setNormalDatapoolEntriesInvalid();
-  if (newMode == MODE_OFF) {
-    disableCommandsAndReplies();
-  }
   if (!isTransitionalMode()) {
     modeHelper.modeChanged(newMode, newSubmode);
     announceMode(false);
@@ -1570,22 +1567,3 @@ void DeviceHandlerBase::setParent(object_id_t parent) { this->parent = parent; }
 void DeviceHandlerBase::setPowerSwitcher(PowerSwitchIF* switcher) {
   this->powerSwitcher = switcher;
 }
-
-void DeviceHandlerBase::disableCommandsAndReplies() {
-  for (auto& command : deviceCommandMap) {
-    if (command.second.isExecuting) {
-      command.second.isExecuting = false;
-    }
-  }
-  for (auto& reply : deviceReplyMap) {
-    if (!reply.second.periodic) {
-      if (reply.second.countdown != nullptr) {
-        reply.second.countdown->timeOut();
-      }
-      else {
-        reply.second.delayCycles = 0;
-      }
-      reply.second.active = false;
-    }
-  }
-}

src/fsfw/devicehandlers/DeviceHandlerBase.h

@@ -467,14 +467,14 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * @brief 	This is a helper method to insert replies in the reply map.
    * @param deviceCommand	Identifier of the reply to add.
    * @param maxDelayCycles The maximum number of delay cycles the reply waits
-   *    until it times out.
+   * until it times out.
    * @param periodic	Indicates if the command is periodic (i.e. it is sent
-   *    by the device repeatedly without request) or not. Default is aperiodic (0).
-   *    Please note that periodic replies are disabled by default. You can enable them with
-   *    #updatePeriodicReply
+   * by the device repeatedly without request) or not. Default is aperiodic (0).
+   * Please note that periodic replies are disabled by default. You can enable them with
+   * #updatePeriodicReply
    * @param countdown Instead of using maxDelayCycles to timeout a device reply it is also possible
-   *    to provide a pointer to a Countdown object which will signal the timeout
-   *    when expired
+   *                  to provide a pointer to a Countdown object which will signal the timeout
+   *                  when expired
    * @return	- @c RETURN_OK when the command was successfully inserted,
    *          - @c RETURN_FAILED else.
    */
@@ -783,18 +783,11 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * This is used to keep track of pending replies.
    */
   struct DeviceReplyInfo {
-    //! For Command-Reply combinations:
     //! The maximum number of cycles the handler should wait for a reply
     //! to this command.
-    //!
-    //! Reply Only:
-    //! For periodic replies, this variable will be the number of delay cycles between the replies.
-    //! For the non-periodic variant, this variable is not used as there is no meaningful
-    //! definition for delay
     uint16_t maxDelayCycles;
-    //! This variable will be set to #maxDelayCycles if a reply is expected.
-    //! For non-periodic replies without a command, this variable is unused.
-    //! A runtime value of 0 means there is no reply is currently expected.
+    //! The currently remaining cycles the handler should wait for a reply,
+    //! 0 means there is no reply expected
     uint16_t delayCycles;
     size_t replyLen = 0;  //!< Expected size of the reply.
     //! if this is !=0, the delayCycles will not be reset to 0 but to
@@ -1325,11 +1318,6 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   void printWarningOrError(sif::OutputTypes errorType, const char *functionName,
                            ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_FAILED,
                            const char *errorPrint = nullptr);
-
-  /**
-   * @brief Disables all commands and replies when device is set to MODE_OFF
-   */
-  void disableCommandsAndReplies();
 };
 
 #endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */

src/fsfw/events/CMakeLists.txt

@@ -1,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/eventmatching/CMakeLists.txt

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

src/fsfw/events/fwSubsystemIdRanges.h

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

src/fsfw/globalfunctions/CMakeLists.txt

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

src/fsfw/globalfunctions/DleParser.cpp

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

src/fsfw/globalfunctions/DleParser.h

@@ -1,4 +1,5 @@
-#pragma once
+#ifndef MISSION_DEVICES_DLEPARSER_H_
+#define MISSION_DEVICES_DLEPARSER_H_
 
 #include <fsfw/container/SimpleRingBuffer.h>
 #include <fsfw/globalfunctions/DleEncoder.h>
@@ -122,3 +123,5 @@ class DleParser : public HasReturnvaluesIF {
   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
-                                        HealthTable.cpp)
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		HealthHelper.cpp
+		HealthMessage.cpp
+		HealthTable.cpp	
+)

src/fsfw/health/HasHealthIF.h

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

src/fsfw/housekeeping/CMakeLists.txt

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

src/fsfw/internalerror/CMakeLists.txt

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

src/fsfw/ipc/CMakeLists.txt

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

src/fsfw/ipc/CommandMessageIF.h

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

src/fsfw/memory/CMakeLists.txt

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

src/fsfw/modes/CMakeLists.txt

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

src/fsfw/monitoring/CMakeLists.txt

@@ -1,2 +1,5 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE LimitViolationReporter.cpp
-                                        MonitoringMessage.cpp)
+target_sources(${LIB_FSFW_NAME} 
+	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/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

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

src/fsfw/osal/common/CMakeLists.txt

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

src/fsfw/osal/common/TcpTmTcServer.cpp

@@ -109,8 +109,8 @@ TcpTmTcServer::~TcpTmTcServer() { closeSocket(listenerTcpSocket); }
   using namespace tcpip;
   // If a connection is accepted, the corresponding socket will be assigned to the new socket
   socket_t connSocket = 0;
-  sockaddr clientSockAddr = {};
-  socklen_t connectorSockAddrLen = 0;
+  // sockaddr clientSockAddr = {};
+  // socklen_t connectorSockAddrLen = 0;
   int retval = 0;
 
   // Listen for connection requests permanently for lifetime of program
@@ -121,7 +121,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,7 +137,6 @@ TcpTmTcServer::~TcpTmTcServer() { closeSocket(listenerTcpSocket); }
     if (retval != 0) {
       handleError(Protocol::TCP, ErrorSources::SHUTDOWN_CALL);
     }
-
     closeSocket(connSocket);
     connSocket = 0;
   }

src/fsfw/osal/freertos/CMakeLists.txt

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

src/fsfw/osal/host/CMakeLists.txt

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

src/fsfw/osal/host/FixedTimeslotTask.cpp

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

src/fsfw/osal/host/FixedTimeslotTask.h

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

src/fsfw/osal/host/PeriodicTask.cpp

@@ -3,10 +3,13 @@
 #include <chrono>
 #include <thread>
 
+#include "fsfw/ipc/MutexFactory.h"
+#include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/osal/host/Mutex.h"
 #include "fsfw/osal/host/taskHelpers.h"
 #include "fsfw/platform.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw/tasks/ExecutableObjectIF.h"
 
 #if defined(PLATFORM_WIN)
 #include <processthreadsapi.h>
@@ -17,8 +20,8 @@
 #endif
 
 PeriodicTask::PeriodicTask(const char* name, TaskPriority setPriority, TaskStackSize setStack,
-                           TaskPeriod setPeriod, TaskDeadlineMissedFunction dlmFunc_)
-    : PeriodicTaskBase(setPeriod, dlmFunc_), started(false), taskName(name) {
+                           TaskPeriod setPeriod, void (*setDeadlineMissedFunc)())
+    : started(false), taskName(name), period(setPeriod), deadlineMissedFunc(setDeadlineMissedFunc) {
   // It is probably possible to set task priorities by using the native
   // task handles for Windows / Linux
   mainThread = std::thread(&PeriodicTask::taskEntryPoint, this, this);
@@ -30,7 +33,7 @@ PeriodicTask::PeriodicTask(const char* name, TaskPriority setPriority, TaskStack
   tasks::insertTaskName(mainThread.get_id(), taskName);
 }
 
-PeriodicTask::~PeriodicTask() {
+PeriodicTask::~PeriodicTask(void) {
   // Do not delete objects, we were responsible for ptrs only.
   terminateThread = true;
   if (mainThread.joinable()) {
@@ -39,7 +42,7 @@ PeriodicTask::~PeriodicTask() {
 }
 
 void PeriodicTask::taskEntryPoint(void* argument) {
-  auto* originalTask(reinterpret_cast<PeriodicTask*>(argument));
+  PeriodicTask* originalTask(reinterpret_cast<PeriodicTask*>(argument));
 
   if (not originalTask->started) {
     // we have to suspend/block here until the task is started.
@@ -72,27 +75,47 @@ ReturnValue_t PeriodicTask::sleepFor(uint32_t ms) {
 }
 
 void PeriodicTask::taskFunctionality() {
-  initObjsAfterTaskCreation();
+  for (const auto& object : objectList) {
+    object->initializeAfterTaskCreation();
+  }
 
   std::chrono::milliseconds periodChrono(static_cast<uint32_t>(period * 1000));
   auto currentStartTime{std::chrono::duration_cast<std::chrono::milliseconds>(
       std::chrono::system_clock::now().time_since_epoch())};
+  auto nextStartTime{currentStartTime};
+
   /* Enter the loop that defines the task behavior. */
   for (;;) {
     if (terminateThread.load()) {
       break;
     }
-    for (const auto& objectPair : objectList) {
-      objectPair.first->performOperation(objectPair.second);
+    for (const auto& object : objectList) {
+      object->performOperation();
     }
     if (not delayForInterval(&currentStartTime, periodChrono)) {
-      if (dlmFunc != nullptr) {
-        this->dlmFunc();
+      if (deadlineMissedFunc != nullptr) {
+        this->deadlineMissedFunc();
       }
     }
   }
 }
 
+ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
+  ExecutableObjectIF* newObject = ObjectManager::instance()->get<ExecutableObjectIF>(object);
+  return addComponent(newObject);
+}
+
+ReturnValue_t PeriodicTask::addComponent(ExecutableObjectIF* object) {
+  if (object == nullptr) {
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  object->setTaskIF(this);
+  objectList.push_back(object);
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint32_t PeriodicTask::getPeriodMs() const { return period * 1000; }
+
 bool PeriodicTask::delayForInterval(chron_ms* previousWakeTimeMs, const chron_ms interval) {
   bool shouldDelay = false;
   // Get current wakeup time
@@ -133,5 +156,3 @@ bool PeriodicTask::delayForInterval(chron_ms* previousWakeTimeMs, const chron_ms
   (*previousWakeTimeMs) = currentStartTime;
   return false;
 }
-
-bool PeriodicTask::isEmpty() const { return objectList.empty(); }

src/fsfw/osal/host/PeriodicTask.h

@@ -6,9 +6,9 @@
 #include <thread>
 #include <vector>
 
-#include "fsfw/objectmanager/ObjectManagerIF.h"
-#include "fsfw/tasks/PeriodicTaskBase.h"
-#include "fsfw/tasks/definitions.h"
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../tasks/PeriodicTaskIF.h"
+#include "../../tasks/Typedef.h"
 
 class ExecutableObjectIF;
 
@@ -19,7 +19,7 @@ class ExecutableObjectIF;
  *
  * @ingroup task_handling
  */
-class PeriodicTask : public PeriodicTaskBase {
+class PeriodicTask : public PeriodicTaskIF {
  public:
   /**
    * @brief	Standard constructor of the class.
@@ -34,12 +34,12 @@ class PeriodicTask : public PeriodicTaskBase {
    * assigned.
    */
   PeriodicTask(const char* name, TaskPriority setPriority, TaskStackSize setStack,
-               TaskPeriod setPeriod, TaskDeadlineMissedFunction dlmFunc);
+               TaskPeriod setPeriod, void (*setDeadlineMissedFunc)());
   /**
    * @brief	Currently, the executed object's lifetime is not coupled with
    * 			the task object's lifetime, so the destructor is empty.
    */
-  ~PeriodicTask() override;
+  virtual ~PeriodicTask(void);
 
   /**
    * @brief	The method to start the task.
@@ -48,21 +48,63 @@ class PeriodicTask : public PeriodicTaskBase {
    * 			The address of the task object is passed as an argument
    * 			to the system call.
    */
-  ReturnValue_t startTask() override;
+  ReturnValue_t startTask(void);
+  /**
+   * Adds an object to the list of objects to be executed.
+   * The objects are executed in the order added.
+   * @param object Id of the object to add.
+   * @return
+   *  -@c RETURN_OK on success
+   *  -@c RETURN_FAILED if the object could not be added.
+   */
+  ReturnValue_t addComponent(object_id_t object);
 
-  ReturnValue_t sleepFor(uint32_t ms) override;
+  /**
+   * Adds an object to the list of objects to be executed.
+   * The objects are executed in the order added.
+   * @param object pointer to the object to add.
+   * @return
+   *  -@c RETURN_OK on success
+   *  -@c RETURN_FAILED if the object could not be added.
+   */
+  ReturnValue_t addComponent(ExecutableObjectIF* object);
+
+  uint32_t getPeriodMs() const;
+
+  ReturnValue_t sleepFor(uint32_t ms);
 
-  bool isEmpty() const override;
  protected:
   using chron_ms = std::chrono::milliseconds;
   bool started;
+  //!< Typedef for the List of objects.
+  typedef std::vector<ExecutableObjectIF*> ObjectList;
   std::thread mainThread;
   std::atomic<bool> terminateThread{false};
 
+  /**
+   * @brief	This attribute holds a list of objects to be executed.
+   */
+  ObjectList objectList;
+
   std::condition_variable initCondition;
   std::mutex initMutex;
   std::string taskName;
-
+  /**
+   * @brief	The period of the task.
+   * @details
+   * The period determines the frequency of the task's execution.
+   * It is expressed in clock ticks.
+   */
+  TaskPeriod period;
+  /**
+   * @brief	The pointer to the deadline-missed function.
+   * @details
+   * This pointer stores the function that is executed if the task's deadline
+   * is missed. So, each may react individually on a timing failure.
+   * The pointer may be NULL, then nothing happens on missing the deadline.
+   * The deadline is equal to the next execution of the periodic task.
+   */
+  void (*deadlineMissedFunc)(void);
   /**
    * @brief	This is the function executed in the new task's context.
    * @details
@@ -82,9 +124,9 @@ class PeriodicTask : public PeriodicTaskBase {
    * the checkAndRestartPeriod system call blocks the task until the next
    *  period. On missing the deadline, the deadlineMissedFunction is executed.
    */
-  void taskFunctionality();
+  void taskFunctionality(void);
 
-  static bool delayForInterval(chron_ms* previousWakeTimeMs, chron_ms interval);
+  bool delayForInterval(chron_ms* previousWakeTimeMs, const chron_ms interval);
 };
 
-#endif /* FRAMEWORK_OSAL_HOST_PERIODICTASK_H_ */
+#endif /* PERIODICTASK_H_ */

src/fsfw/osal/host/TaskFactory.cpp

@@ -14,9 +14,9 @@ TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
 // Not used for the host implementation for now because C++ thread abstraction is used
 const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = 0;
 
-TaskFactory::TaskFactory() = default;
+TaskFactory::TaskFactory() {}
 
-TaskFactory::~TaskFactory() = default;
+TaskFactory::~TaskFactory() {}
 
 TaskFactory* TaskFactory::instance() { return TaskFactory::factoryInstance; }
 

src/fsfw/osal/host/taskHelpers.cpp

@@ -6,7 +6,7 @@
 std::mutex nameMapLock;
 std::map<std::thread::id, std::string> taskNameMap;
 
-ReturnValue_t tasks::insertTaskName(std::thread::id threadId, const std::string& taskName) {
+ReturnValue_t tasks::insertTaskName(std::thread::id threadId, std::string taskName) {
   std::lock_guard<std::mutex> lg(nameMapLock);
   auto returnPair = taskNameMap.emplace(threadId, taskName);
   if (not returnPair.second) {

src/fsfw/osal/host/taskHelpers.h

@@ -7,7 +7,7 @@
 
 namespace tasks {
 
-ReturnValue_t insertTaskName(std::thread::id threadId, const std::string& taskName);
+ReturnValue_t insertTaskName(std::thread::id threadId, std::string taskName);
 std::string getTaskName(std::thread::id threadId);
 
 }  // namespace tasks

src/fsfw/osal/linux/CMakeLists.txt

@@ -1,25 +1,29 @@
-target_sources(
-  ${LIB_FSFW_NAME}
-  PRIVATE Clock.cpp
-          BinarySemaphore.cpp
-          CountingSemaphore.cpp
-          FixedTimeslotTask.cpp
-          InternalErrorCodes.cpp
-          MessageQueue.cpp
-          Mutex.cpp
-          MutexFactory.cpp
-          PeriodicPosixTask.cpp
-          PosixThread.cpp
-          QueueFactory.cpp
-          SemaphoreFactory.cpp
-          TaskFactory.cpp
-          tcpipHelpers.cpp
-          unixUtility.cpp)
+target_sources(${LIB_FSFW_NAME} PRIVATE
+  Clock.cpp
+  BinarySemaphore.cpp
+  CountingSemaphore.cpp
+  FixedTimeslotTask.cpp
+  InternalErrorCodes.cpp
+  MessageQueue.cpp
+  Mutex.cpp
+  MutexFactory.cpp
+  PeriodicPosixTask.cpp
+  PosixThread.cpp
+  QueueFactory.cpp
+  SemaphoreFactory.cpp
+  TaskFactory.cpp
+  tcpipHelpers.cpp
+  unixUtility.cpp
+  )
 
 find_package(Threads REQUIRED)
 
-target_link_libraries(${LIB_FSFW_NAME} PUBLIC ${CMAKE_THREAD_LIBS_INIT})
+target_link_libraries(${LIB_FSFW_NAME} PUBLIC
+  ${CMAKE_THREAD_LIBS_INIT}
+  )
 
 if(NOT APPLE)
-  target_link_libraries(${LIB_FSFW_NAME} PUBLIC rt)
+  target_link_libraries(${LIB_FSFW_NAME} PUBLIC
+    rt
+  )
 endif()

src/fsfw/osal/linux/FixedTimeslotTask.cpp

@@ -1,21 +1,22 @@
 #include "fsfw/osal/linux/FixedTimeslotTask.h"
 
-#include <climits>
+#include <limits.h>
 
+#include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
 uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
 const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = PTHREAD_STACK_MIN;
 
-FixedTimeslotTask::FixedTimeslotTask(const char* name_, TaskPriority priority_, size_t stackSize_,
-                                     TaskPeriod periodSeconds_, TaskDeadlineMissedFunction dlmFunc_)
-    : FixedTimeslotTaskBase(periodSeconds_, dlmFunc_),
-      posixThread(name_, priority_, stackSize_),
-      started(false) {}
+FixedTimeslotTask::FixedTimeslotTask(const char* name_, int priority_, size_t stackSize_,
+                                     uint32_t periodMs_)
+    : PosixThread(name_, priority_, stackSize_), pst(periodMs_), started(false) {}
+
+FixedTimeslotTask::~FixedTimeslotTask() {}
 
 void* FixedTimeslotTask::taskEntryPoint(void* arg) {
   // The argument is re-interpreted as PollingTask.
-  auto* originalTask(reinterpret_cast<FixedTimeslotTask*>(arg));
+  FixedTimeslotTask* originalTask(reinterpret_cast<FixedTimeslotTask*>(arg));
   // The task's functionality is called.
   originalTask->taskFunctionality();
   return nullptr;
@@ -23,7 +24,7 @@ void* FixedTimeslotTask::taskEntryPoint(void* arg) {
 
 ReturnValue_t FixedTimeslotTask::startTask() {
   started = true;
-  posixThread.createTask(&taskEntryPoint, this);
+  createTask(&taskEntryPoint, this);
   return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -31,25 +32,45 @@ ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
   return PosixThread::sleep((uint64_t)ms * 1000000);
 }
 
-[[noreturn]] void FixedTimeslotTask::taskFunctionality() {
-  // Like FreeRTOS pthreads are running as soon as they are created
-  if (!started) {
-    posixThread.suspend();
+uint32_t FixedTimeslotTask::getPeriodMs() const { return pst.getLengthMs(); }
+
+ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId, uint32_t slotTimeMs,
+                                         int8_t executionStep) {
+  ExecutableObjectIF* executableObject =
+      ObjectManager::instance()->get<ExecutableObjectIF>(componentId);
+  if (executableObject != nullptr) {
+    pst.addSlot(componentId, slotTimeMs, executionStep, executableObject, this);
+    return HasReturnvaluesIF::RETURN_OK;
   }
 
-  pollingSeqTable.intializeSequenceAfterTaskCreation();
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::error << "Component " << std::hex << componentId << " not found, not adding it to pst"
+             << std::dec << std::endl;
+#endif
+  return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t FixedTimeslotTask::checkSequence() const { return pst.checkSequence(); }
+
+void FixedTimeslotTask::taskFunctionality() {
+  // Like FreeRTOS pthreads are running as soon as they are created
+  if (!started) {
+    suspend();
+  }
+
+  pst.intializeSequenceAfterTaskCreation();
 
   // The start time for the first entry is read.
-  uint64_t lastWakeTime = PosixThread::getCurrentMonotonicTimeMs();
-  uint32_t interval = 0;
+  uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
+  uint64_t interval = pst.getIntervalToNextSlotMs();
 
   // The task's "infinite" inner loop is entered.
-  while (true) {
-    if (pollingSeqTable.slotFollowsImmediately()) {
+  while (1) {
+    if (pst.slotFollowsImmediately()) {
       // Do nothing
     } else {
       // The interval for the next polling slot is selected.
-      interval = pollingSeqTable.getIntervalToPreviousSlotMs();
+      interval = this->pst.getIntervalToPreviousSlotMs();
       // The period is checked and restarted with the new interval.
       // If the deadline was missed, the deadlineMissedFunc is called.
       if (!PosixThread::delayUntil(&lastWakeTime, interval)) {
@@ -58,7 +79,7 @@ ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
       }
     }
     // The device handler for this slot is executed and the next one is chosen.
-    pollingSeqTable.executeAndAdvance();
+    this->pst.executeAndAdvance();
   }
 }
 
@@ -66,8 +87,8 @@ void FixedTimeslotTask::missedDeadlineCounter() {
   FixedTimeslotTask::deadlineMissedCount++;
   if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount << " deadlines."
-               << std::endl;
+    sif::warning << "PST missed " << FixedTimeslotTask::deadlineMissedCount << " deadlines"
+                 << std::endl;
 #endif
   }
 }

src/fsfw/osal/linux/FixedTimeslotTask.h

@@ -3,12 +3,11 @@
 
 #include <pthread.h>
 
+#include "../../tasks/FixedSlotSequence.h"
+#include "../../tasks/FixedTimeslotTaskIF.h"
 #include "PosixThread.h"
-#include "fsfw/tasks/FixedSlotSequence.h"
-#include "fsfw/tasks/FixedTimeslotTaskBase.h"
-#include "fsfw/tasks/definitions.h"
 
-class FixedTimeslotTask : public FixedTimeslotTaskBase {
+class FixedTimeslotTask : public FixedTimeslotTaskIF, public PosixThread {
  public:
   /**
    * Create a generic periodic task.
@@ -22,13 +21,18 @@ class FixedTimeslotTask : public FixedTimeslotTaskBase {
    * @param period_
    * @param deadlineMissedFunc_
    */
-  FixedTimeslotTask(const char* name_, TaskPriority priority_, size_t stackSize_,
-                    TaskPeriod periodSeconds_, TaskDeadlineMissedFunction dlmFunc_);
-  ~FixedTimeslotTask() override = default;
+  FixedTimeslotTask(const char* name_, int priority_, size_t stackSize_, uint32_t periodMs_);
+  virtual ~FixedTimeslotTask();
 
-  ReturnValue_t startTask() override;
+  virtual ReturnValue_t startTask();
 
-  ReturnValue_t sleepFor(uint32_t ms) override;
+  virtual ReturnValue_t sleepFor(uint32_t ms);
+
+  virtual uint32_t getPeriodMs() const;
+
+  virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep);
+
+  virtual ReturnValue_t checkSequence() const;
 
   /**
    * This static function can be used as #deadlineMissedFunc.
@@ -49,12 +53,9 @@ class FixedTimeslotTask : public FixedTimeslotTaskBase {
    * It links the functionalities provided by FixedSlotSequence with the
    * OS's System Calls to keep the timing of the periods.
    */
-  [[noreturn]] virtual void taskFunctionality();
+  virtual void taskFunctionality();
 
  private:
-  PosixThread posixThread;
-  bool started;
-
   /**
    * @brief	This is the entry point in a new thread.
    *
@@ -67,6 +68,9 @@ class FixedTimeslotTask : public FixedTimeslotTaskBase {
    * arbitrary data.
    */
   static void* taskEntryPoint(void* arg);
+  FixedSlotSequence pst;
+
+  bool started;
 };
 
 #endif /* FSFW_OSAL_LINUX_FIXEDTIMESLOTTASK_H_ */

src/fsfw/osal/linux/PeriodicPosixTask.cpp

@@ -1,54 +1,86 @@
-#include "PeriodicPosixTask.h"
+#include "fsfw/osal/linux/PeriodicPosixTask.h"
 
-#include "fsfw/serviceinterface.h"
+#include <errno.h>
+
+#include "fsfw/objectmanager/ObjectManager.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
 
 PeriodicPosixTask::PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_,
-                                     TaskPeriod period_, TaskDeadlineMissedFunction dlmFunc_)
-    : PeriodicTaskBase(period_, dlmFunc_),
-      posixThread(name_, priority_, stackSize_),
-      started(false) {}
+                                     uint32_t period_, void(deadlineMissedFunc_)())
+    : PosixThread(name_, priority_, stackSize_),
+      objectList(),
+      started(false),
+      periodMs(period_),
+      deadlineMissedFunc(deadlineMissedFunc_) {}
+
+PeriodicPosixTask::~PeriodicPosixTask() {
+  // Not Implemented
+}
 
 void* PeriodicPosixTask::taskEntryPoint(void* arg) {
   // The argument is re-interpreted as PollingTask.
-  auto* originalTask(reinterpret_cast<PeriodicPosixTask*>(arg));
+  PeriodicPosixTask* originalTask(reinterpret_cast<PeriodicPosixTask*>(arg));
   // The task's functionality is called.
   originalTask->taskFunctionality();
-  return nullptr;
+  return NULL;
 }
 
-ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
-  return PosixThread::sleep(static_cast<uint64_t>(ms) * 1000000);
+ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object) {
+  ExecutableObjectIF* newObject = ObjectManager::instance()->get<ExecutableObjectIF>(object);
+  return addComponent(newObject);
 }
 
-ReturnValue_t PeriodicPosixTask::startTask() {
-  if (isEmpty()) {
+ReturnValue_t PeriodicPosixTask::addComponent(ExecutableObjectIF* object) {
+  if (object == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
+               << " it implements ExecutableObjectIF!" << std::endl;
+#else
+    sif::printError(
+        "PeriodicTask::addComponent: Invalid object. Make sure it "
+        "implements ExecutableObjectIF!\n");
+#endif
     return HasReturnvaluesIF::RETURN_FAILED;
   }
-  started = true;
-  posixThread.createTask(&taskEntryPoint, this);
+  objectList.push_back(object);
+  object->setTaskIF(this);
+
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-[[noreturn]] void PeriodicPosixTask::taskFunctionality() {
+ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
+  return PosixThread::sleep((uint64_t)ms * 1000000);
+}
+
+ReturnValue_t PeriodicPosixTask::startTask(void) {
+  started = true;
+  PosixThread::createTask(&taskEntryPoint, this);
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+void PeriodicPosixTask::taskFunctionality(void) {
   if (not started) {
-    posixThread.suspend();
+    suspend();
   }
 
-  initObjsAfterTaskCreation();
+  for (auto const& object : objectList) {
+    object->initializeAfterTaskCreation();
+  }
 
-  uint64_t lastWakeTime = PosixThread::getCurrentMonotonicTimeMs();
-  uint64_t periodMs = getPeriodMs();
+  uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
   // The task's "infinite" inner loop is entered.
-  while (true) {
-    for (auto const& objOpCodePair : objectList) {
-      objOpCodePair.first->performOperation(objOpCodePair.second);
+  while (1) {
+    for (auto const& object : objectList) {
+      object->performOperation();
     }
 
     if (not PosixThread::delayUntil(&lastWakeTime, periodMs)) {
-      if (dlmFunc != nullptr) {
-        dlmFunc();
+      if (this->deadlineMissedFunc != nullptr) {
+        this->deadlineMissedFunc();
       }
     }
   }
 }
+
+uint32_t PeriodicPosixTask::getPeriodMs() const { return periodMs; }

src/fsfw/osal/linux/PeriodicPosixTask.h

@@ -3,13 +3,12 @@
 
 #include <vector>
 
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../tasks/ExecutableObjectIF.h"
+#include "../../tasks/PeriodicTaskIF.h"
 #include "PosixThread.h"
-#include "fsfw/objectmanager/ObjectManagerIF.h"
-#include "fsfw/tasks/ExecutableObjectIF.h"
-#include "fsfw/tasks/PeriodicTaskBase.h"
-#include "fsfw/tasks/PeriodicTaskIF.h"
 
-class PeriodicPosixTask : public PeriodicTaskBase {
+class PeriodicPosixTask : public PosixThread, public PeriodicTaskIF {
  public:
   /**
    * Create a generic periodic task.
@@ -23,9 +22,9 @@ class PeriodicPosixTask : public PeriodicTaskBase {
    * @param period_
    * @param deadlineMissedFunc_
    */
-  PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_, TaskPeriod period_,
-                    TaskDeadlineMissedFunction dlmFunc_);
-  ~PeriodicPosixTask() override = default;
+  PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_, uint32_t period_,
+                    void (*deadlineMissedFunc_)());
+  virtual ~PeriodicPosixTask();
 
   /**
    * @brief	The method to start the task.
@@ -35,17 +34,42 @@ class PeriodicPosixTask : public PeriodicTaskBase {
    * 			to the system call.
    */
   ReturnValue_t startTask() override;
+  /**
+   * Adds an object to the list of objects to be executed.
+   * The objects are executed in the order added.
+   * @param object Id of the object to add.
+   * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
+   */
+  ReturnValue_t addComponent(object_id_t object) override;
+
+  /**
+   * Adds an object to the list of objects to be executed.
+   * The objects are executed in the order added.
+   * @param object pointer to the object to add.
+   * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
+   */
+  ReturnValue_t addComponent(ExecutableObjectIF* object) override;
+
+  uint32_t getPeriodMs() const override;
 
   ReturnValue_t sleepFor(uint32_t ms) override;
 
  private:
-  PosixThread posixThread;
+  typedef std::vector<ExecutableObjectIF*> ObjectList;  //!< Typedef for the List of objects.
+  /**
+   * @brief	This attribute holds a list of objects to be executed.
+   */
+  ObjectList objectList;
 
   /**
    * @brief Flag to indicate that the task was started and is allowed to run
    */
   bool started;
 
+  /**
+   * @brief Period of the task in milliseconds
+   */
+  uint32_t periodMs;
   /**
    * @brief	The function containing the actual functionality of the task.
    * @details	The method sets and starts
@@ -54,7 +78,7 @@ class PeriodicPosixTask : public PeriodicTaskBase {
    * will be blocked until the next period. On missing the deadline, the deadlineMissedFunction is
    * executed.
    */
-  [[noreturn]] virtual void taskFunctionality();
+  virtual void taskFunctionality(void);
   /**
    * @brief	This is the entry point in a new thread.
    *
@@ -62,6 +86,14 @@ class PeriodicPosixTask : public PeriodicTaskBase {
    * of the child class. Needs a valid pointer to the derived class.
    */
   static void* taskEntryPoint(void* arg);
+  /**
+   * @brief	The pointer to the deadline-missed function.
+   * @details	This pointer stores the function that is executed if the task's deadline is missed.
+   * 			So, each may react individually on a timing failure. The pointer may be
+   * NULL, then nothing happens on missing the deadline. The deadline is equal to the next execution
+   * 			of the periodic task.
+   */
+  void (*deadlineMissedFunc)();
 };
 
 #endif /* FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_ */

src/fsfw/osal/linux/PosixThread.h

@@ -35,21 +35,6 @@ class PosixThread {
    */
   void resume();
 
-  /**
-   * @brief     Function that has to be called by derived class because the
-   *        derived class pointer has to be valid as argument.
-   * @details
-   * This function creates a pthread with the given parameters. As the
-   * function requires a pointer to the derived object it has to be called
-   * after the this pointer of the derived object is valid.
-   * Sets the taskEntryPoint as function to be called by new a thread.
-   * @param fnc_ Function which will be executed by the thread.
-   * @param arg_
-   * argument of the taskEntryPoint function, needs to be this pointer
-   * of derived class
-   */
-  void createTask(void* (*fnc_)(void*), void* arg_);
-
   /**
    * Delay function similar to FreeRtos delayUntil function
    *
@@ -70,6 +55,21 @@ class PosixThread {
  protected:
   pthread_t thread;
 
+  /**
+   * @brief 	Function that has to be called by derived class because the
+   *  		derived class pointer has to be valid as argument.
+   * @details
+   * This function creates a pthread with the given parameters. As the
+   * function requires a pointer to the derived object it has to be called
+   * after the this pointer of the derived object is valid.
+   * Sets the taskEntryPoint as function to be called by new a thread.
+   * @param fnc_ Function which will be executed by the thread.
+   * @param arg_
+   * argument of the taskEntryPoint function, needs to be this pointer
+   * of derived class
+   */
+  void createTask(void* (*fnc_)(void*), void* arg_);
+
  private:
   char name[PTHREAD_MAX_NAMELEN];
   int priority;

src/fsfw/osal/linux/TaskFactory.cpp

@@ -8,22 +8,21 @@
 // TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
 TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
 
-TaskFactory::~TaskFactory() = default;
+TaskFactory::~TaskFactory() {}
 
 TaskFactory* TaskFactory::instance() { return TaskFactory::factoryInstance; }
 
 PeriodicTaskIF* TaskFactory::createPeriodicTask(
     TaskName name_, TaskPriority taskPriority_, TaskStackSize stackSize_,
     TaskPeriod periodInSeconds_, TaskDeadlineMissedFunction deadLineMissedFunction_) {
-  return new PeriodicPosixTask(name_, taskPriority_, stackSize_, periodInSeconds_,
+  return new PeriodicPosixTask(name_, taskPriority_, stackSize_, periodInSeconds_ * 1000,
                                deadLineMissedFunction_);
 }
 
 FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(
     TaskName name_, TaskPriority taskPriority_, TaskStackSize stackSize_,
     TaskPeriod periodInSeconds_, TaskDeadlineMissedFunction deadLineMissedFunction_) {
-  return new FixedTimeslotTask(name_, taskPriority_, stackSize_, periodInSeconds_,
-                               deadLineMissedFunction_);
+  return new FixedTimeslotTask(name_, taskPriority_, stackSize_, periodInSeconds_ * 1000);
 }
 
 ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {

src/fsfw/osal/rtems/CMakeLists.txt

@@ -1,17 +1,20 @@
-target_sources(
-  ${LIB_FSFW_NAME}
-  PRIVATE Clock.cpp
-          CpuUsage.cpp
-          InitTask.cpp
-          InternalErrorCodes.cpp
-          MessageQueue.cpp
-          PeriodicTask.cpp
-          Mutex.cpp
-          MutexFactory.cpp
-          FixedTimeslotTask.cpp
-          QueueFactory.cpp
-          RtemsBasic.cpp
-          RTEMSTaskBase.cpp
-          TaskFactory.cpp
-          BinarySemaphore.cpp
-          SemaphoreFactory.cpp)
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Clock.cpp
+		CpuUsage.cpp
+		InitTask.cpp
+		InternalErrorCodes.cpp
+		MessageQueue.cpp
+		PeriodicTask.cpp
+		Mutex.cpp
+		MutexFactory.cpp
+		FixedTimeslotTask.cpp
+		QueueFactory.cpp
+		RtemsBasic.cpp
+		RTEMSTaskBase.cpp
+		TaskFactory.cpp
+		BinarySemaphore.cpp
+		SemaphoreFactory.cpp
+)
+
+

src/fsfw/osal/windows/CMakeLists.txt

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

src/fsfw/parameters/CMakeLists.txt

@@ -1,3 +1,6 @@
-target_sources(
-  ${LIB_FSFW_NAME} PRIVATE ParameterHelper.cpp ParameterMessage.cpp
-                           ParameterWrapper.cpp)
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ParameterHelper.cpp
+		ParameterMessage.cpp
+		ParameterWrapper.cpp
+)

src/fsfw/power/CMakeLists.txt

@@ -1,4 +1,8 @@
-target_sources(
-  ${LIB_FSFW_NAME}
-  PRIVATE Fuse.cpp PowerComponent.cpp PowerSensor.cpp PowerSwitcher.cpp
-          DummyPowerSwitcher.cpp PowerSwitcherComponent.cpp)
+target_sources(${LIB_FSFW_NAME} PRIVATE
+    Fuse.cpp
+    PowerComponent.cpp
+    PowerSensor.cpp
+    PowerSwitcher.cpp
+    DummyPowerSwitcher.cpp
+    PowerSwitcherComponent.cpp
+)

src/fsfw/power/DummyPowerSwitcher.cpp

@@ -1,9 +1,8 @@
 #include "DummyPowerSwitcher.h"
 
 DummyPowerSwitcher::DummyPowerSwitcher(object_id_t objectId, size_t numberOfSwitches,
-                                       size_t numberOfFuses, bool registerGlobally,
-                                       uint32_t switchDelayMs)
-    : SystemObject(objectId, registerGlobally),
+                                       size_t numberOfFuses, uint32_t switchDelayMs)
+    : SystemObject(objectId),
       switcherList(numberOfSwitches),
       fuseList(numberOfFuses),
       switchDelayMs(switchDelayMs) {}
@@ -17,28 +16,28 @@ void DummyPowerSwitcher::setInitialFusesList(std::vector<ReturnValue_t> fuseList
 }
 
 ReturnValue_t DummyPowerSwitcher::sendSwitchCommand(power::Switch_t switchNr, ReturnValue_t onOff) {
-  if (switchNr < switcherList.size()) {
+  if (switchNr < switcherList.capacity()) {
     switcherList[switchNr] = onOff;
   }
   return RETURN_FAILED;
 }
 
 ReturnValue_t DummyPowerSwitcher::sendFuseOnCommand(uint8_t fuseNr) {
-  if (fuseNr < fuseList.size()) {
+  if (fuseNr < fuseList.capacity()) {
     fuseList[fuseNr] = FUSE_ON;
   }
   return RETURN_FAILED;
 }
 
 ReturnValue_t DummyPowerSwitcher::getSwitchState(power::Switch_t switchNr) const {
-  if (switchNr < switcherList.size()) {
+  if (switchNr < switcherList.capacity()) {
     return switcherList[switchNr];
   }
   return HasReturnvaluesIF::RETURN_FAILED;
 }
 
 ReturnValue_t DummyPowerSwitcher::getFuseState(uint8_t fuseNr) const {
-  if (fuseNr < fuseList.size()) {
+  if (fuseNr < fuseList.capacity()) {
     return fuseList[fuseNr];
   }
   return HasReturnvaluesIF::RETURN_FAILED;

src/fsfw/power/DummyPowerSwitcher.h

@@ -8,17 +8,10 @@
 #include "definitions.h"
 #include "fsfw/objectmanager/SystemObject.h"
 
-/**
- * @brief   This component can be used to simulate a power switcher like a
- *          Power Control Distribution Unit (PCDU)
- * @details
- * The dummy switcher will simply cache the commanded fuse and switch states and return them
- * in the according switch getter functions. In that sense, it simulates an ideal PCDU.
- */
 class DummyPowerSwitcher : public SystemObject, public PowerSwitchIF {
  public:
   DummyPowerSwitcher(object_id_t objectId, size_t numberOfSwitches, size_t numberOfFuses,
-                     bool registerGlobally = true, uint32_t switchDelayMs = 5000);
+                     uint32_t switchDelayMs = 5000);
 
   void setInitialSwitcherList(std::vector<ReturnValue_t> switcherList);
   void setInitialFusesList(std::vector<ReturnValue_t> switcherList);

src/fsfw/power/PowerSensor.cpp

@@ -15,7 +15,9 @@ PowerSensor::PowerSensor(object_id_t objectId, sid_t setId, VariableIds ids, Def
                    limits.currentMin, limits.currentMax, events.currentLow, events.currentHigh),
       voltageLimit(objectId, MODULE_ID_VOLTAGE, ids.pidVoltage, confirmationCount,
                    limits.voltageMin, limits.voltageMax, events.voltageLow, events.voltageHigh) {
-  commandQueue = QueueFactory::instance()->createMessageQueue();
+  auto mqArgs = MqArgs(objectId, static_cast<void*>(this));
+  commandQueue = QueueFactory::instance()->createMessageQueue(
+      3, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
 
 PowerSensor::~PowerSensor() { QueueFactory::instance()->deleteMessageQueue(commandQueue); }

src/fsfw/power/PowerSwitcher.h

@@ -18,8 +18,7 @@ class PowerSwitcher : public HasReturnvaluesIF {
   static const uint8_t INTERFACE_ID = CLASS_ID::POWER_SWITCHER;
   static const ReturnValue_t IN_POWER_TRANSITION = MAKE_RETURN_CODE(1);
   static const ReturnValue_t SWITCH_STATE_MISMATCH = MAKE_RETURN_CODE(2);
-  PowerSwitcher(PowerSwitchIF* switcher, power::Switch_t setSwitch1,
-                power::Switch_t setSwitch2 = power::NO_SWITCH,
+  PowerSwitcher(PowerSwitchIF* switcher, uint8_t setSwitch1, uint8_t setSwitch2 = power::NO_SWITCH,
                 State_t setStartState = SWITCH_IS_OFF);
   void turnOn(bool checkCurrentState = true);
   void turnOff(bool checkCurrentState = true);

src/fsfw/pus/CMakeLists.txt

@@ -1,12 +1,12 @@
-target_sources(
-  ${LIB_FSFW_NAME}
-  PRIVATE Service1TelecommandVerification.cpp
-          Service2DeviceAccess.cpp
-          Service3Housekeeping.cpp
-          Service5EventReporting.cpp
-          Service8FunctionManagement.cpp
-          Service9TimeManagement.cpp
-          Service17Test.cpp
-          Service20ParameterManagement.cpp
-          CService200ModeCommanding.cpp
-          CService201HealthCommanding.cpp)
+target_sources(${LIB_FSFW_NAME} PRIVATE 
+    Service1TelecommandVerification.cpp
+    Service2DeviceAccess.cpp
+    Service3Housekeeping.cpp
+    Service5EventReporting.cpp
+    Service8FunctionManagement.cpp
+    Service9TimeManagement.cpp
+    Service17Test.cpp
+    Service20ParameterManagement.cpp
+    CService200ModeCommanding.cpp
+    CService201HealthCommanding.cpp
+)

src/fsfw/pus/Service11TelecommandScheduling.h

@@ -1,203 +0,0 @@
-#ifndef MISSION_PUS_SERVICE11TELECOMMANDSCHEDULING_H_
-#define MISSION_PUS_SERVICE11TELECOMMANDSCHEDULING_H_
-
-#include <etl/multimap.h>
-#include <fsfw/tmtcservices/PusServiceBase.h>
-#include <fsfw/tmtcservices/TmTcMessage.h>
-
-#include "fsfw/FSFW.h"
-#include "fsfw/returnvalues/FwClassIds.h"
-
-/**
- * @brief: PUS-Service 11 - Telecommand scheduling.
- * @details:
- * PUS-Service 11 - Telecommand scheduling.
- * Full documentation: ECSS-E-ST-70-41C, p. 168:
- * ST[11] time-based scheduling
- *
- * This service provides the capability to command pre-loaded
- * application processes (telecommands) by releasing them at their
- * due-time.
- * References to telecommands are stored together with their due-timepoints
- * and are released at their corresponding due-time.
- *
- * Necessary subservice functionalities are implemented.
- * Those are:
- * TC[11,4] activity insertion
- * TC[11,5] activity deletion
- * TC[11,6] filter-based activity deletion
- * TC[11,7] activity time-shift
- * TC[11,8] filter-based activity time-shift
- *
- * Groups are not supported.
- * This service remains always enabled. Sending a disable-request has no effect.
- */
-template <size_t MAX_NUM_TCS>
-class Service11TelecommandScheduling final : public PusServiceBase {
- public:
-  static constexpr uint8_t CLASS_ID = CLASS_ID::PUS_SERVICE_11;
-
-  static constexpr ReturnValue_t INVALID_TYPE_TIME_WINDOW =
-      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 1);
-  static constexpr ReturnValue_t TIMESHIFTING_NOT_POSSIBLE =
-      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 2);
-  static constexpr ReturnValue_t INVALID_RELATIVE_TIME =
-      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 3);
-
-  static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_11;
-
-  //! [EXPORT] : [COMMENT] Deletion of a TC from the map failed.
-  //! P1: First 32 bit of request ID, P2. Last 32 bit of Request ID
-  static constexpr Event TC_DELETION_FAILED = event::makeEvent(SUBSYSTEM_ID, 0, severity::MEDIUM);
-
-  // The types of PUS-11 subservices
-  enum Subservice : uint8_t {
-    ENABLE_SCHEDULING = 1,
-    DISABLE_SCHEDULING = 2,
-    RESET_SCHEDULING = 3,
-    INSERT_ACTIVITY = 4,
-    DELETE_ACTIVITY = 5,
-    FILTER_DELETE_ACTIVITY = 6,
-    TIMESHIFT_ACTIVITY = 7,
-    FILTER_TIMESHIFT_ACTIVITY = 8,
-    DETAIL_REPORT = 9,
-    TIMEBASE_SCHEDULE_DETAIL_REPORT = 10,
-    TIMESHIFT_ALL_SCHEDULE_ACTIVITIES = 15
-  };
-
-  // The types of time windows for TC[11,6] and TC[11,8], as defined in ECSS-E-ST-70-41C,
-  // requirement 8.11.3c (p. 507)
-  enum TypeOfTimeWindow : uint32_t {
-    SELECT_ALL = 0,
-    FROM_TIMETAG_TO_TIMETAG = 1,
-    FROM_TIMETAG = 2,
-    TO_TIMETAG = 3
-  };
-
-  Service11TelecommandScheduling(object_id_t objectId, uint16_t apid, uint8_t serviceId,
-                                 AcceptsTelecommandsIF* tcRecipient,
-                                 uint16_t releaseTimeMarginSeconds = DEFAULT_RELEASE_TIME_MARGIN,
-                                 bool debugMode = false);
-
-  ~Service11TelecommandScheduling() override;
-
-  void enableExpiredTcDeletion();
-  void disableExpiredTcDeletion();
-
-  /** PusServiceBase overrides */
-  ReturnValue_t handleRequest(uint8_t subservice) override;
-  ReturnValue_t performService() override;
-  ReturnValue_t initialize() override;
-
- private:
-  struct TelecommandStruct {
-    uint64_t requestId{};
-    uint32_t seconds{};
-    store_address_t storeAddr;  // uint16
-  };
-
-  static constexpr uint16_t DEFAULT_RELEASE_TIME_MARGIN = 5;
-
-  // minimum release time offset to insert into schedule
-  const uint16_t RELEASE_TIME_MARGIN_SECONDS = 5;
-
-  /**
-   * By default, the scheduling will be disabled. This is a standard requirement
-   */
-  bool schedulingEnabled = false;
-  bool deleteExpiredTcWhenDisabled = true;
-  bool debugMode = false;
-  StorageManagerIF* tcStore = nullptr;
-  AcceptsTelecommandsIF* tcRecipient = nullptr;
-  MessageQueueId_t recipientMsgQueueId = 0;
-
-  /**
-   * The telecommand map uses the exectution time as a Unix time stamp as
-   * the key. This is mapped to a generic telecommand struct.
-   */
-  using TelecommandMap = etl::multimap<uint32_t, TelecommandStruct, MAX_NUM_TCS>;
-  using TcMapIter = typename TelecommandMap::iterator;
-
-  TelecommandMap telecommandMap;
-
-  ReturnValue_t handleResetCommand();
-  /**
-   * @brief Logic to be performed on an incoming TC[11,4].
-   * @return RETURN_OK if successful
-   */
-  ReturnValue_t doInsertActivity(const uint8_t* data, size_t size);
-
-  /**
-   * @brief Logic to be performed on an incoming TC[11,5].
-   * @return RETURN_OK if successful
-   */
-  ReturnValue_t doDeleteActivity(const uint8_t* data, size_t size);
-
-  /**
-   * @brief Logic to be performed on an incoming TC[11,6].
-   * @return RETURN_OK if successful
-   */
-  ReturnValue_t doFilterDeleteActivity(const uint8_t* data, size_t size);
-
-  /**
-   * @brief Logic to be performed on an incoming TC[11,7].
-   * @return RETURN_OK if successful
-   */
-  ReturnValue_t doTimeshiftActivity(const uint8_t* data, size_t size);
-
-  /**
-   * @brief Logic to be performed on an incoming TC[11,8].
-   * @return RETURN_OK if successful
-   */
-  ReturnValue_t doFilterTimeshiftActivity(const uint8_t* data, size_t size);
-
-  /**
-   * @brief Extracts the Request ID from the Application Data of a TC by utilizing a ctor of the
-   * class TcPacketPus.
-   * NOTE: This only works if the payload data is a TC (e.g. not for TC[11,5] which does not
-   * send a TC as payload)!
-   * @param data The Application data of the TC (get via getApplicationData()).
-   * @return requestId
-   */
-  uint64_t getRequestIdFromDataTC(const uint8_t* data) const;
-
-  /**
-   * @brief Extracts the Request ID from the Application Data directly, assuming it is packed
-   * as follows (acc. to ECSS): | source ID (uint32) | apid (uint32) | ssc (uint32) |.
-   * @param data Pointer to first byte described data
-   * @param dataSize Remaining size of data NOTE: non-const, this is modified by the function
-   * @param [out] requestId Request ID
-   * @return RETURN_OK if successful
-   */
-  ReturnValue_t getRequestIdFromData(const uint8_t*& data, size_t& dataSize, uint64_t& requestId);
-
-  /**
-   * @brief Builds the Request ID from its three elements.
-   * @param sourceId Source ID
-   * @param apid Application Process ID (APID)
-   * @param ssc Source Sequence Count
-   * @return Request ID
-   */
-  [[nodiscard]] uint64_t buildRequestId(uint32_t sourceId, uint16_t apid, uint16_t ssc) const;
-
-  /**
-   * @brief Gets the filter range for filter TCs from a data packet
-   * @param data TC data
-   * @param dataSize TC data size
-   * @param [out] itBegin Begin of filter range
-   * @param [out] itEnd End of filter range
-   * @return RETURN_OK if successful
-   */
-  ReturnValue_t getMapFilterFromData(const uint8_t*& data, size_t& size, TcMapIter& itBegin,
-                                     TcMapIter& itEnd);
-
-  ReturnValue_t handleInvalidData(const char* ctx);
-  /**
-   * @brief Prints content of multimap. Use for simple debugging only.
-   */
-  void debugPrintMultimapContent() const;
-};
-
-#include "Service11TelecommandScheduling.tpp"
-
-#endif /* MISSION_PUS_SERVICE11TELECOMMANDSCHEDULING_H_ */

src/fsfw/pus/Service11TelecommandScheduling.tpp

@@ -1,645 +0,0 @@
-#pragma once
-
-#include <cstddef>
-
-#include "fsfw/objectmanager/ObjectManager.h"
-#include "fsfw/serialize/SerializeAdapter.h"
-#include "fsfw/serviceinterface.h"
-#include "fsfw/tmtcservices/AcceptsTelecommandsIF.h"
-
-static constexpr auto DEF_END = SerializeIF::Endianness::BIG;
-
-template <size_t MAX_NUM_TCS>
-inline Service11TelecommandScheduling<MAX_NUM_TCS>::Service11TelecommandScheduling(
-    object_id_t objectId, uint16_t apid, uint8_t serviceId, AcceptsTelecommandsIF *tcRecipient,
-    uint16_t releaseTimeMarginSeconds, bool debugMode)
-    : PusServiceBase(objectId, apid, serviceId),
-      RELEASE_TIME_MARGIN_SECONDS(releaseTimeMarginSeconds),
-      debugMode(debugMode),
-      tcRecipient(tcRecipient) {}
-
-template <size_t MAX_NUM_TCS>
-inline Service11TelecommandScheduling<MAX_NUM_TCS>::~Service11TelecommandScheduling() = default;
-
-template <size_t MAX_NUM_TCS>
-inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::handleRequest(
-    uint8_t subservice) {
-  if (debugMode) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::info << "PUS11::handleRequest: Handling request " << static_cast<int>(subservice);
-#else
-    sif::printInfo("PUS11::handleRequest: Handling request %d\n", subservice);
-#endif
-  }
-  // Get de-serialized Timestamp
-  const uint8_t *data = currentPacket.getApplicationData();
-  size_t size = currentPacket.getApplicationDataSize();
-  if (data == nullptr) {
-    return handleInvalidData("handleRequest");
-  }
-  switch (subservice) {
-    case Subservice::ENABLE_SCHEDULING: {
-      schedulingEnabled = true;
-      break;
-    }
-    case Subservice::DISABLE_SCHEDULING: {
-      schedulingEnabled = false;
-      break;
-    }
-    case Subservice::RESET_SCHEDULING: {
-      return handleResetCommand();
-    }
-    case Subservice::INSERT_ACTIVITY:
-      return doInsertActivity(data, size);
-    case Subservice::DELETE_ACTIVITY:
-      return doDeleteActivity(data, size);
-    case Subservice::FILTER_DELETE_ACTIVITY:
-      return doFilterDeleteActivity(data, size);
-    case Subservice::TIMESHIFT_ACTIVITY:
-      return doTimeshiftActivity(data, size);
-    case Subservice::FILTER_TIMESHIFT_ACTIVITY:
-      return doFilterTimeshiftActivity(data, size);
-    default:
-      return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
-  }
-  return RETURN_OK;
-}
-
-template <size_t MAX_NUM_TCS>
-inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::performService() {
-  if (not schedulingEnabled) {
-    return RETURN_OK;
-  }
-  // get current time as UNIX timestamp
-  timeval tNow = {};
-  Clock::getClock_timeval(&tNow);
-
-  // TODO: Optionally limit the max number of released TCs per cycle?
-  // NOTE: The iterator is increased in the loop here. Increasing the iterator as for-loop arg
-  // does not work in this case as we are deleting the current element here.
-  for (auto it = telecommandMap.begin(); it != telecommandMap.end();) {
-    if (it->first <= static_cast<uint32_t>(tNow.tv_sec)) {
-      if (schedulingEnabled) {
-        // release tc
-        TmTcMessage releaseMsg(it->second.storeAddr);
-        auto sendRet = this->requestQueue->sendMessage(recipientMsgQueueId, &releaseMsg, false);
-
-        if (sendRet != HasReturnvaluesIF::RETURN_OK) {
-          return sendRet;
-        }
-        if (debugMode) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-          sif::info << "Released TC & erased it from TC map" << std::endl;
-#else
-          sif::printInfo("Released TC & erased it from TC map\n");
-#endif
-        }
-        telecommandMap.erase(it++);
-      } else if (deleteExpiredTcWhenDisabled) {
-        telecommandMap.erase(it++);
-      }
-      continue;
-    }
-    it++;
-  }
-
-  return HasReturnvaluesIF::RETURN_OK;
-}
-
-template <size_t MAX_NUM_TCS>
-inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::initialize() {
-  ReturnValue_t res = PusServiceBase::initialize();
-  if (res != HasReturnvaluesIF::RETURN_OK) {
-    return res;
-  }
-
-  tcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::TC_STORE);
-  if (!tcStore) {
-    return ObjectManagerIF::CHILD_INIT_FAILED;
-  }
-
-  if (tcRecipient == nullptr) {
-    return ObjectManagerIF::CHILD_INIT_FAILED;
-  }
-  recipientMsgQueueId = tcRecipient->getRequestQueue();
-
-  return res;
-}
-
-template <size_t MAX_NUM_TCS>
-inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::handleResetCommand() {
-  for (auto it = telecommandMap.begin(); it != telecommandMap.end(); it++) {
-    ReturnValue_t result = tcStore->deleteData(it->second.storeAddr);
-    if (result != RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-      // This should not happen
-      sif::warning << "Service11TelecommandScheduling::handleRequestDeleting: Deletion failed"
-                   << std::endl;
-#else
-      sif::printWarning("Service11TelecommandScheduling::handleRequestDeleting: Deletion failed\n");
-#endif
-      triggerEvent(TC_DELETION_FAILED, (it->second.requestId >> 32) & 0xffffffff,
-                   it->second.requestId & 0xffffffff);
-    }
-  }
-  telecommandMap.clear();
-  return RETURN_OK;
-}
-
-template <size_t MAX_NUM_TCS>
-inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::doInsertActivity(
-    const uint8_t *data, size_t size) {
-  uint32_t timestamp = 0;
-  ReturnValue_t result = SerializeAdapter::deSerialize(&timestamp, &data, &size, DEF_END);
-  if (result != RETURN_OK) {
-    return result;
-  }
-
-  // Insert possible if sched. time is above margin
-  // (See requirement for Time margin)
-  timeval tNow = {};
-  Clock::getClock_timeval(&tNow);
-  if (timestamp - tNow.tv_sec <= RELEASE_TIME_MARGIN_SECONDS) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "Service11TelecommandScheduling::doInsertActivity: Release time too close to "
-                    "current time"
-                 << std::endl;
-#else
-    sif::printWarning(
-        "Service11TelecommandScheduling::doInsertActivity: Release time too close to current "
-        "time\n");
-#endif
-    return RETURN_FAILED;
-  }
-
-  // store currentPacket and receive the store address
-  store_address_t addr{};
-  if (tcStore->addData(&addr, data, size) != RETURN_OK ||
-      addr.raw == storeId::INVALID_STORE_ADDRESS) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "Service11TelecommandScheduling::doInsertActivity: Adding data to TC Store failed"
-               << std::endl;
-#else
-    sif::printError(
-        "Service11TelecommandScheduling::doInsertActivity: Adding data to TC Store failed\n");
-#endif
-    return RETURN_FAILED;
-  }
-
-  // insert into multimap with new store address
-  TelecommandStruct tc;
-  tc.seconds = timestamp;
-  tc.storeAddr = addr;
-  tc.requestId =
-      getRequestIdFromDataTC(data);  // TODO: Missing sanity check of the returned request id
-
-  auto it = telecommandMap.insert(std::pair<uint32_t, TelecommandStruct>(timestamp, tc));
-  if (it == telecommandMap.end()) {
-    return RETURN_FAILED;
-  }
-
-  if (debugMode) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::info << "PUS11::doInsertActivity: Inserted into Multimap:" << std::endl;
-#else
-    sif::printInfo("PUS11::doInsertActivity: Inserted into Multimap:\n");
-#endif
-    debugPrintMultimapContent();
-  }
-  return HasReturnvaluesIF::RETURN_OK;
-}
-
-template <size_t MAX_NUM_TCS>
-inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::doDeleteActivity(
-    const uint8_t *data, size_t size) {
-  // Get request ID
-  uint64_t requestId;
-  ReturnValue_t result = getRequestIdFromData(data, size, requestId);
-  if (result != RETURN_OK) {
-    return result;
-  }
-
-  // DEBUG
-  if (debugMode) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::info << "PUS11::doDeleteActivity: requestId: " << requestId << std::endl;
-#else
-    sif::printInfo("PUS11::doDeleteActivity: requestId: %d\n", requestId);
-#endif
-  }
-
-  TcMapIter tcToDelete;     // handle to the TC to be deleted, can be used if counter is valid
-  int tcToDeleteCount = 0;  // counter of all found TCs. Should be 1.
-
-  for (auto it = telecommandMap.begin(); it != telecommandMap.end(); it++) {
-    if (it->second.requestId == requestId) {
-      tcToDelete = it;
-      tcToDeleteCount++;
-    }
-  }
-
-  // check if 1 explicit TC is found via request ID
-  if (tcToDeleteCount == 0 || tcToDeleteCount > 1) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "Service11TelecommandScheduling::doDeleteActivity: No or more than 1 TC found. "
-                    "Cannot explicitly delete TC"
-                 << std::endl;
-#else
-    sif::printWarning(
-        "Service11TelecommandScheduling::doDeleteActivity: No or more than 1 TC found. "
-        "Cannot explicitly delete TC");
-#endif
-    return RETURN_FAILED;
-  }
-
-  // delete packet from store
-  if (tcStore->deleteData(tcToDelete->second.storeAddr) != RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "Service11TelecommandScheduling::doDeleteActivity: Could not delete TC from Store"
-               << std::endl;
-#else
-    sif::printError(
-        "Service11TelecommandScheduling::doDeleteActivity: Could not delete TC from Store\n");
-#endif
-    return RETURN_FAILED;
-  }
-
-  telecommandMap.erase(tcToDelete);
-  if (debugMode) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::info << "PUS11::doDeleteActivity: Deleted TC from map" << std::endl;
-#else
-    sif::printInfo("PUS11::doDeleteActivity: Deleted TC from map\n");
-#endif
-  }
-
-  return RETURN_OK;
-}
-
-template <size_t MAX_NUM_TCS>
-inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::doFilterDeleteActivity(
-    const uint8_t *data, size_t size) {
-  TcMapIter itBegin;
-  TcMapIter itEnd;
-
-  ReturnValue_t result = getMapFilterFromData(data, size, itBegin, itEnd);
-  // get the filter window as map range via dedicated method
-  if (result != RETURN_OK) {
-    return result;
-  }
-
-  int deletedTCs = 0;
-  for (TcMapIter it = itBegin; it != itEnd; it++) {
-    // delete packet from store
-    if (tcStore->deleteData(it->second.storeAddr) != RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::error << "Service11TelecommandScheduling::doFilterDeleteActivity: Could not delete TC "
-                    "from Store"
-                 << std::endl;
-#else
-      sif::printError(
-          "Service11TelecommandScheduling::doFilterDeleteActivity: Could not delete TC from "
-          "Store\n");
-#endif
-      continue;
-    }
-    deletedTCs++;
-  }
-
-  // NOTE: Spec says this function erases all elements including itBegin but not itEnd,
-  // see here: https://www.cplusplus.com/reference/map/multimap/erase/
-  // Therefore we need to increase itEnd by 1. (Note that end() returns the "past-the-end" iterator)
-  if (itEnd != telecommandMap.end()) {
-    itEnd++;
-  }
-
-  telecommandMap.erase(itBegin, itEnd);
-
-  if (debugMode) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::info << "PUS11::doFilterDeleteActivity: Deleted " << deletedTCs << " TCs" << std::endl;
-#else
-    sif::printInfo("PUS11::doFilterDeleteActivity: Deleted %d TCs\n", deletedTCs);
-#endif
-  }
-  return RETURN_OK;
-}
-
-template <size_t MAX_NUM_TCS>
-inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::doTimeshiftActivity(
-    const uint8_t *data, size_t size) {
-  // Get relative time
-  uint32_t relativeTime = 0;
-  ReturnValue_t result = SerializeAdapter::deSerialize(&relativeTime, &data, &size, DEF_END);
-  if (result != RETURN_OK) {
-    return result;
-  }
-  if (relativeTime == 0) {
-    return INVALID_RELATIVE_TIME;
-  }
-  // TODO further check sanity of the relative time?
-
-  // Get request ID
-  uint64_t requestId;
-  result = getRequestIdFromData(data, size, requestId);
-  if (result != RETURN_OK) {
-    return result;
-  }
-
-  if (debugMode) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::info << "PUS11::doTimeshiftActivity: requestId: " << requestId << std::endl;
-#else
-    sif::printInfo("PUS11::doTimeshiftActivity: requestId: %d\n", requestId);
-#endif
-  }
-
-  // NOTE: Despite having C++17 ETL multimap has no member function extract :(
-
-  TcMapIter tcToTimeshiftIt;
-  int tcToTimeshiftCount = 0;
-
-  for (auto it = telecommandMap.begin(); it != telecommandMap.end(); it++) {
-    if (it->second.requestId == requestId) {
-      tcToTimeshiftIt = it;
-      tcToTimeshiftCount++;
-    }
-  }
-
-  if (tcToTimeshiftCount == 0 || tcToTimeshiftCount > 1) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "Service11TelecommandScheduling::doTimeshiftActivity: Either 0 or more than 1 "
-                    "TCs found. No explicit timeshifting "
-                    "possible"
-                 << std::endl;
-
-#else
-    sif::printWarning(
-        "Service11TelecommandScheduling::doTimeshiftActivity: Either 0 or more than 1 TCs found. "
-        "No explicit timeshifting possible\n");
-#endif
-    return TIMESHIFTING_NOT_POSSIBLE;
-  }
-
-  // temporarily hold the item
-  TelecommandStruct tempTc(tcToTimeshiftIt->second);
-  uint32_t tempKey = tcToTimeshiftIt->first + relativeTime;
-
-  // delete old entry from the mm
-  telecommandMap.erase(tcToTimeshiftIt);
-
-  // and then insert it again as new entry
-  telecommandMap.insert(std::make_pair(tempKey, tempTc));
-
-  if (debugMode) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::info << "PUS11::doTimeshiftActivity: Shifted TC" << std::endl;
-#else
-    sif::printDebug("PUS11::doTimeshiftActivity: Shifted TC\n");
-#endif
-    debugPrintMultimapContent();
-  }
-
-  return RETURN_OK;
-}
-
-template <size_t MAX_NUM_TCS>
-inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::doFilterTimeshiftActivity(
-    const uint8_t *data, size_t size) {
-  // Get relative time
-  uint32_t relativeTime = 0;
-  ReturnValue_t result = SerializeAdapter::deSerialize(&relativeTime, &data, &size, DEF_END);
-  if (result != RETURN_OK) {
-    return result;
-  }
-  if (relativeTime == 0) {
-    return INVALID_RELATIVE_TIME;
-  }
-
-  // Do time window
-  TcMapIter itBegin;
-  TcMapIter itEnd;
-  result = getMapFilterFromData(data, size, itBegin, itEnd);
-  if (result != RETURN_OK) {
-    return result;
-  }
-
-  int shiftedItemsCount = 0;
-  for (auto it = itBegin; it != itEnd;) {
-    // temporarily hold the item
-    TelecommandStruct tempTc(it->second);
-    uint32_t tempKey = it->first + relativeTime;
-
-    // delete the old entry from the mm
-    telecommandMap.erase(it++);
-
-    // and then insert it again as new entry
-    telecommandMap.insert(std::make_pair(tempKey, tempTc));
-    shiftedItemsCount++;
-  }
-
-  if (debugMode) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::info << "PUS11::doFilterTimeshiftActivity: shiftedItemsCount: " << shiftedItemsCount
-              << std::endl;
-#else
-    sif::printInfo("PUS11::doFilterTimeshiftActivity: shiftedItemsCount: %d\n", shiftedItemsCount);
-#endif
-    debugPrintMultimapContent();
-  }
-
-  if (shiftedItemsCount > 0) {
-    return RETURN_OK;
-  }
-  return RETURN_FAILED;
-}
-
-template <size_t MAX_NUM_TCS>
-inline uint64_t Service11TelecommandScheduling<MAX_NUM_TCS>::getRequestIdFromDataTC(
-    const uint8_t *data) const {
-  TcPacketPus mask(data);
-
-  uint32_t sourceId = mask.getSourceId();
-  uint16_t apid = mask.getAPID();
-  uint16_t sequenceCount = mask.getPacketSequenceCount();
-
-  return buildRequestId(sourceId, apid, sequenceCount);
-}
-
-template <size_t MAX_NUM_TCS>
-inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::getRequestIdFromData(
-    const uint8_t *&data, size_t &dataSize, uint64_t &requestId) {
-  uint32_t srcId = 0;
-  uint16_t apid = 0;
-  uint16_t ssc = 0;
-
-  ReturnValue_t result = SerializeAdapter::deSerialize(&srcId, &data, &dataSize, DEF_END);
-  if (result != RETURN_OK) {
-    return result;
-  }
-  result = SerializeAdapter::deSerialize(&apid, &data, &dataSize, DEF_END);
-  if (result != RETURN_OK) {
-    return result;
-  }
-  result = SerializeAdapter::deSerialize(&ssc, &data, &dataSize, DEF_END);
-  if (result != RETURN_OK) {
-    return result;
-  }
-  requestId = buildRequestId(srcId, apid, ssc);
-
-  return RETURN_OK;
-}
-
-template <size_t MAX_NUM_TCS>
-inline uint64_t Service11TelecommandScheduling<MAX_NUM_TCS>::buildRequestId(uint32_t sourceId,
-                                                                            uint16_t apid,
-                                                                            uint16_t ssc) const {
-  auto sourceId64 = static_cast<uint64_t>(sourceId);
-  auto apid64 = static_cast<uint64_t>(apid);
-  auto ssc64 = static_cast<uint64_t>(ssc);
-
-  return (sourceId64 << 32) | (apid64 << 16) | ssc64;
-}
-
-template <size_t MAX_NUM_TCS>
-inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::getMapFilterFromData(
-    const uint8_t *&data, size_t &dataSize, TcMapIter &itBegin, TcMapIter &itEnd) {
-  // get filter type first
-  uint32_t typeRaw = 0;
-  ReturnValue_t result = SerializeAdapter::deSerialize(&typeRaw, &data, &dataSize, DEF_END);
-  if (result != RETURN_OK) {
-    return result;
-  }
-
-  if (typeRaw > 3) {
-    return INVALID_TYPE_TIME_WINDOW;
-  }
-  auto type = static_cast<TypeOfTimeWindow>(typeRaw);
-
-  // we now have the type of delete activity - so now we set the range to delete,
-  // according to the type of time window.
-  // NOTE: Blocks are used in this switch-case statement so that timestamps can be
-  // cleanly redefined for each case.
-  switch (type) {
-    case TypeOfTimeWindow::SELECT_ALL: {
-      itBegin = telecommandMap.begin();
-      itEnd = telecommandMap.end();
-      break;
-    }
-
-    case TypeOfTimeWindow::FROM_TIMETAG: {
-      uint32_t fromTimestamp = 0;
-      result = SerializeAdapter::deSerialize(&fromTimestamp, &data, &dataSize, DEF_END);
-      if (result != RETURN_OK) {
-        return result;
-      }
-
-      itBegin = telecommandMap.begin();
-      while (itBegin->first < fromTimestamp && itBegin != telecommandMap.end()) {
-        itBegin++;
-      }
-
-      itEnd = telecommandMap.end();
-      break;
-    }
-
-    case TypeOfTimeWindow::TO_TIMETAG: {
-      uint32_t toTimestamp;
-      result = SerializeAdapter::deSerialize(&toTimestamp, &data, &dataSize, DEF_END);
-      if (result != RETURN_OK) {
-        return result;
-      }
-      itBegin = telecommandMap.begin();
-      itEnd = telecommandMap.begin();
-      while (itEnd->first <= toTimestamp && itEnd != telecommandMap.end()) {
-        itEnd++;
-      }
-      break;
-    }
-
-    case TypeOfTimeWindow::FROM_TIMETAG_TO_TIMETAG: {
-      uint32_t fromTimestamp;
-      uint32_t toTimestamp;
-
-      result = SerializeAdapter::deSerialize(&fromTimestamp, &data, &dataSize,
-                                             SerializeIF::Endianness::BIG);
-      if (result != RETURN_OK) {
-        return result;
-      }
-      result = SerializeAdapter::deSerialize(&toTimestamp, &data, &dataSize,
-                                             SerializeIF::Endianness::BIG);
-      if (result != RETURN_OK) {
-        return result;
-      }
-      itBegin = telecommandMap.begin();
-      itEnd = telecommandMap.begin();
-
-      while (itBegin->first < fromTimestamp && itBegin != telecommandMap.end()) {
-        itBegin++;
-      }
-      while (itEnd->first <= toTimestamp && itEnd != telecommandMap.end()) {
-        itEnd++;
-      }
-      break;
-    }
-
-    default:
-      return RETURN_FAILED;
-  }
-
-  // additional security check, this should never be true
-  if (itBegin->first > itEnd->first) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-#else
-    sif::printError("11::GetMapFilterFromData: itBegin > itEnd\n");
-#endif
-    return RETURN_FAILED;
-  }
-
-  // the map range should now be set according to the sent filter.
-  return RETURN_OK;
-}
-
-template <size_t MAX_NUM_TCS>
-inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::handleInvalidData(
-    const char *ctx) {
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::warning << "Service11TelecommandScheduling:: " << ctx << ": Invalid buffer" << std::endl;
-#else
-  sif::printWarning("Service11TelecommandScheduling::%s: Invalid buffer\n", ctx);
-#endif
-#endif
-  return RETURN_FAILED;
-}
-
-template <size_t MAX_NUM_TCS>
-inline void Service11TelecommandScheduling<MAX_NUM_TCS>::debugPrintMultimapContent() const {
-  for ([[maybe_unused]] const auto &dit : telecommandMap) {
-#if FSFW_DISABLE_PRINTOUT == 0
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::debug << "Service11TelecommandScheduling::debugPrintMultimapContent: Multimap Content"
-               << std::endl;
-    sif::debug << "[" << dit.first << "]: Request ID: " << dit.second.requestId << " | "
-               << "Store Address: " << dit.second.storeAddr.raw << std::endl;
-#else
-    sif::printDebug(
-        "Service11TelecommandScheduling::debugPrintMultimapContent: Multimap Content\n");
-    for (auto dit = telecommandMap.begin(); dit != telecommandMap.end(); ++dit) {
-      sif::printDebug("[%d]: Request ID: %d  | Store Address: %d\n", dit->first,
-                      dit->second.requestId, dit->second.storeAddr);
-    }
-#endif
-#endif
-  }
-}
-
-template <size_t MAX_NUM_TCS>
-inline void Service11TelecommandScheduling<MAX_NUM_TCS>::enableExpiredTcDeletion() {
-  deleteExpiredTcWhenDisabled = true;
-}
-
-template <size_t MAX_NUM_TCS>
-inline void Service11TelecommandScheduling<MAX_NUM_TCS>::disableExpiredTcDeletion() {
-  deleteExpiredTcWhenDisabled = false;
-}

src/fsfw/pus/Service3Housekeeping.cpp

@@ -208,7 +208,7 @@ ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
       ReturnValue_t error = HasReturnvaluesIF::RETURN_FAILED;
       HousekeepingMessage::getHkRequestFailureReply(reply, &error);
       failureParameter2 = error;
-      return RETURN_FAILED;
+      return CommandingServiceBase::EXECUTION_COMPLETE;
     }
 
     default:
@@ -248,23 +248,19 @@ void Service3Housekeeping::handleUnrequestedReply(CommandMessage* reply) {
     case (HousekeepingMessage::HK_REQUEST_FAILURE): {
       break;
     }
-    case(CommandMessage::REPLY_REJECTED): {
-      sif::warning << "Service3Housekeeping::handleUnrequestedReply: Unexpected reply "
-          "rejected with error code" << reply->getParameter() << std::endl;
-      break;
-    }
 
     default: {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::warning << "Service3Housekeeping::handleUnrequestedReply: Invalid reply with reply "
-                      "command " << command << "" << std::endl;
+                      "command "
+                   << command << "!" << std::endl;
 #else
       sif::printWarning(
           "Service3Housekeeping::handleUnrequestedReply: Invalid reply with "
-          "reply command %hu\n",
+          "reply command %hu!\n",
           command);
 #endif
-      break;
+      return;
     }
   }
 
@@ -279,7 +275,6 @@ void Service3Housekeeping::handleUnrequestedReply(CommandMessage* reply) {
         "Could not generate reply!\n");
 #endif
   }
-  CommandingServiceBase::handleUnrequestedReply(reply);
 }
 
 MessageQueueId_t Service3Housekeeping::getHkQueue() const { return commandQueue->getId(); }

src/fsfw/pus/Service5EventReporting.cpp

@@ -85,7 +85,7 @@ ReturnValue_t Service5EventReporting::handleRequest(uint8_t subservice) {
 // In addition to the default PUSServiceBase initialization, this service needs
 // to be registered to the event manager to listen for events.
 ReturnValue_t Service5EventReporting::initialize() {
-  auto* manager = ObjectManager::instance()->get<EventManagerIF>(objects::EVENT_MANAGER);
+  EventManagerIF* manager = ObjectManager::instance()->get<EventManagerIF>(objects::EVENT_MANAGER);
   if (manager == nullptr) {
     return RETURN_FAILED;
   }

src/fsfw/returnvalues/FwClassIds.h

@@ -72,7 +72,6 @@ enum : uint8_t {
   DLE_ENCODER,                    // DLEE
   PUS_SERVICE_3,                  // PUS3
   PUS_SERVICE_9,                  // PUS9
-  PUS_SERVICE_11,                 // PUS11
   FILE_SYSTEM,                    // FILS
   LINUX_OSAL,                     // UXOS
   HAL_SPI,                        // HSPI

src/fsfw/rmap/CMakeLists.txt

@@ -1,2 +1,7 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE RMAP.cpp RMAPCookie.cpp
-                                        RmapDeviceCommunicationIF.cpp)
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		RMAP.cpp
+		RMAPCookie.cpp
+		RmapDeviceCommunicationIF.cpp
+)
+