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

.gitignore

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

.idea/codeStyles/Project.xml

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

.idea/codeStyles/codeStyleConfig.xml

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

CHANGELOG.md

@@ -8,51 +8,28 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 # [unreleased]
 
-# [v6.0.0]
+# [v5.0.0]
-
-## Added
-
-- DHB TM handler `handleDeviceTM` renamed to `handleDeviceTm` and now takes
-  `util::DataWrapper` as the data input argument. This allows more flexibility in the possible
-  types of telemetry.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/669
-- Add `util::DataWrapper` class inside the `util` module. This is a tagged union which allows
-  to specify raw data either as a classic C-style raw pointer and size or as a `SerializeIF`
-  pointer.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/668
-- Add new `UnsignedByteField` class
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/660
 
 ## Changes
 
-- Removed `HasReturnvaluesIF` class in favor of `returnvalue` namespace with `OK` and `FAILED`
-  constants.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/659
-- Overhaul of the TMTC stack, including various changes and improvements
-  for other modules
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/655
-  which also includes a migration guide
-
-# [v5.0.0] 25.07.2022
-
-## Changes
-
-- Renamed auto-formatting script to `auto-formatter.sh` and made it more robust.
-  If `cmake-format` is installed, it will also auto-format the `CMakeLists.txt` files now.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/625
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/626
 - Bump C++ required version to C++17. Every project which uses the FSFW and every modern
   compiler supports it
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/622
+- HAL Linux SPI: Set the Clock Default State when setting new SPI speed
+  and mode
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/573
+- 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
 - New CMake option `FSFW_HAL_LINUX_ADD_LIBGPIOD` to specifically exclude `gpiod` code.
   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
-- `SimpleRingBuffer::writeData` now checks if the amount is larger than the total size of the 
+- HAL Linux Uart: Baudrate and bits per word are enums now, avoiding misconfigurations
-  Buffer and rejects such writeData calls with `returnvalue::FAILED`
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/585
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/586
 - 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
@@ -68,74 +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
-- Internal API change: Moved the `fsfw_hal` to the `src` folder and integration and internal
+- Clock: 
-  tests part of `fsfw_tests` to `src`. Unittests are now in a dedicated folder called `unittests`
+  - `timeval` to `TimeOfDay_t`
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/653
+  - 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
-### Task Module Refactoring
+  - Better check for leap seconds
-
+  - Added Unittests for Clock (only getter)
-PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/636
-
-**Refactoring general task code**
-
-- There was a lot of duplicate/boilerplate code inside the individual task IF OSAL implementations.
-  Remove it by introducing base classes `PeriodicTaskBase` and `FixedTimeslotTaskBase`.
-
-**Refactor PeriodicTaskIF**
-
-- Convert `virtual ReturnValue_t addComponent(object_id_t object)` to
-  `virtual ReturnValue_t addComponent(object_id_t object, uint8_t opCode = 0)`, allowing to pass
-  the operation code passed to `performOperation`. Updated API taking
-  an `ExecutableObjectIF` accordingly
-
-**Refactor FixedTimeslotTaskIF**
-
-- Add additional `addSlot` function which takes an `ExecutableObjectIF` pointer and its Object ID
-
-**Refactor FixedSequenceSlot**
-
-- Introduce typedef `CustomCheckFunc` for `ReturnValue_t (*customCheckFunction)(const SlotList&)`.
-- Convert `ReturnValue_t (*customCheckFunction)(const SlotList&)` to
-  `ReturnValue_t (*customCheckFunction)(const SlotList&, void*)`, allowing arbitrary user arguments
-  for the custom checker
-
-**Linux Task Module**
-
-- Use composition instead of inheritance for the `PeriodicPosixTask` and make the `PosixTask` a
-  member of the class
-
-### HAL
-
-- HAL Linux Uart: Baudrate and bits per word are enums now, avoiding misconfigurations
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/585
-- HAL Linux SPI: Set the Clock Default State when setting new SPI speed
-  and mode
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/573
-- GPIO HAL: `Direction`, `GpioOperation` and `Levels` are enum classes now, which prevents
-  name clashes with Windows defines.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/572
-- HAL Linux Uart: Baudrate and bits per word are enums now, avoiding misconfigurations
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/585
-
-### Time
-
-PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/584 and
-https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593
-
-- `timeval` to `TimeOfDay_t`
-- Added Mutex for gmtime calls: (compare http://www.opengate.at/blog/2020/01/timeless/)
-- Moved the statics used by Clock in ClockCommon.cpp to this file
-- Better check for leap seconds
-- Added Unittests for Clock (only getter)
-
-### Power 
-
-- `PowerSwitchIF`: Remove `const` specifier from `sendSwitchCommand` and `sendFuseOnCommand` and
-  also specify a `ReturnValue_t` return type
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
-- Extend `PowerSwitcher` module to optionally check current state when calling `turnOn` or
-  `turnOff`. Tis can be helpful to avoid commanding switches which do not need commanding
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
 
 ## Removed
 
@@ -145,39 +60,11 @@ https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593
 
 ## Additions
 
-- New constructor for PoolEntry which allows to simply specify the length of the pool entry.
-  This is also the new default constructor for scalar value with 0 as an initial value
-- Added options for CI/CD builds: `FSFW_CICD_BUILD`. This allows the source code to know
-  whether it is running in CI/CD
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/623
-- Basic `clion` support: Update `.gitignore` and add some basic run configurations
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/625
-- LTO support: Allow using LTO/IPO by setting `FSFW_ENABLE_LTO=1`. CMake is able to detect whether
-  the user compiler supports IPO/LPO. LTO is on by default now. Most modern compilers support it,
-  can make good use of it and it usually makes the code faster and/or smaller.
-  After some more research:
-  Enabling LTO will actually cause the compiler to only produce thin LTO by adding 
-  `-flto -fno-fat-lto-objects` to the compiler options. I am not sure this is an ideal choice
-  because if an application linking against the FSFW does not use LTO, there can be compile
-  issues (e.g. observed when compiling the FSFW tests without LTO). This is a known issue as
-  can be seen in the multiple CMake issues for it: 
-    - https://gitlab.kitware.com/cmake/cmake/-/issues/22913, 
-    - https://gitlab.kitware.com/cmake/cmake/-/issues/16808, 
-    - https://gitlab.kitware.com/cmake/cmake/-/issues/21696
-  Easiest solution for now: Keep this option OFF by default.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/616
 - 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,115 +1,51 @@
 cmake_minimum_required(VERSION 3.13)
+set(LIB_FSFW_NAME fsfw)
+project(${LIB_FSFW_NAME})
 
-set(MSG_PREFIX "fsfw |")
+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()
 
-# Add the cmake folder so the FindSphinx module is found
+set(FSFW_VERSION_IF_GIT_FAILS 4)
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
-list(APPEND CMAKE_MODULE_PATH
-     "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake-modules/bilke")
-list(APPEND CMAKE_MODULE_PATH
-     "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake-modules/rpavlik")
-
-# ##############################################################################
-# Version file handling  #
-# ##############################################################################
-
-set(FSFW_VERSION_IF_GIT_FAILS 5)
 set(FSFW_SUBVERSION_IF_GIT_FAILS 0)
 set(FSFW_REVISION_IF_GIT_FAILS 0)
 
-set(FSFW_GIT_VER_HANDLING_OK FALSE)
+# Add the cmake folder so the FindSphinx module is found
-# Version handling
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" )
-if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake-modules")
-  message(STATUS "${MSG_PREFIX} Determining version information with git")
+set(MSG_PREFIX "fsfw |")
-  include(FsfwHelpers)
-  determine_version_with_git("--exclude" "docker_*")
-  if(GIT_INFO)
-    set(FSFW_GIT_INFO
-        ${GIT_INFO}
-        CACHE STRING "Version information retrieved with git describe")
-    list(GET FSFW_GIT_INFO 1 FSFW_VERSION)
-    list(GET FSFW_GIT_INFO 2 FSFW_SUBVERSION)
-    list(GET FSFW_GIT_INFO 3 FSFW_REVISION)
-    list(GET FSFW_GIT_INFO 4 FSFW_VCS_INFO)
-    if(NOT FSFW_VERSION)
-      set(FSFW_VERSION ${FSFW_VERSION_IF_GIT_FAILS})
-    endif()
-    if(NOT FSFW_SUBVERSION)
-      set(FSFW_SUBVERSION ${FSFW_SUBVERSION_IF_GIT_FAILS})
-    endif()
-    if(NOT FSFW_REVISION)
-      set(FSFW_REVISION ${FSFW_REVISION_IF_GIT_FAILS})
-    endif()
-    set(FSFW_GIT_VER_HANDLING_OK TRUE)
-  else()
-    set(FSFW_GIT_VER_HANDLING_OK FALSE)
-  endif()
-endif()
-if(NOT FSFW_GIT_VER_HANDLING_OK)
-  set(FSFW_VERSION ${FSFW_VERSION_IF_GIT_FAILS})
-  set(FSFW_SUBVERSION ${FSFW_SUBVERSION_IF_GIT_FAILS})
-  set(FSFW_REVISION ${FSFW_REVISION_IF_GIT_FAILS})
-endif()
 
-set(LIB_FSFW_NAME fsfw)
+set(FSFW_ETL_LIB_MAJOR_VERSION 20 CACHE STRING
-project(${LIB_FSFW_NAME}
+    "ETL library major version requirement"
-        VERSION ${FSFW_VERSION}.${FSFW_SUBVERSION}.${FSFW_REVISION})
+)
+set(FSFW_ETL_LIB_VERSION ${FSFW_ETL_LIB_MAJOR_VERSION}.27.3 CACHE STRING
+    "ETL library exact version requirement"
+)
+set(FSFW_ETL_LINK_TARGET etl::etl)
 
-if(NOT CMAKE_CXX_STANDARD)
+set(FSFW_CATCH2_LIB_MAJOR_VERSION 3 CACHE STRING
-  set(CMAKE_CXX_STANDARD 17)
+    "Catch2 library major version requirement"
-  set(CMAKE_CXX_STANDARD_REQUIRED True)
+)
-elseif(${CMAKE_CXX_STANDARD} LESS 17)
+set(FSFW_CATCH2_LIB_VERSION v${FSFW_CATCH2_LIB_MAJOR_VERSION}.0.0-preview5 CACHE STRING
-  message(
+    "Catch2 library exact version requirement"
-    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_LINK_TARGET etl::etl)
-set(FSFW_ETL_LIB_MAJOR_VERSION
-    20
-    CACHE STRING "ETL library major version requirement")
-set(FSFW_ETL_LIB_VERSION
-    ${FSFW_ETL_LIB_MAJOR_VERSION}.28.0
-    CACHE STRING "ETL library exact version requirement")
-set(FSFW_ETL_LINK_TARGET etl::etl)
-
-set(FSFW_CATCH2_LIB_MAJOR_VERSION
-    3
-    CACHE STRING "Catch2 library major version requirement")
-set(FSFW_CATCH2_LIB_VERSION
-    v${FSFW_CATCH2_LIB_MAJOR_VERSION}.0.0-preview5
-    CACHE STRING "Catch2 library exact version requirement")
-
-# Keep this off by default for now. See PR:
-# https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/616 for information which
-# keeping this on by default is problematic
-option(
-  FSFW_ENABLE_IPO
-  "Enable interprocedural optimization or link-time optimization if available"
-  OFF)
-if(FSFW_ENABLE_IPO)
-  include(CheckIPOSupported)
-  check_ipo_supported(RESULT IPO_SUPPORTED OUTPUT IPO_ERROR)
-  if(NOT IPO_SUPPORTED)
-    message(STATUS "FSFW | IPO/LTO not supported: ${IPO_ERROR}")
-  endif()
-endif()
 
 option(FSFW_GENERATE_SECTIONS
-       "Generate function and data sections. Required to remove unused code" ON)
+    "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_TESTS "Build unittest binary in addition to static library"
+option(FSFW_BUILD_UNITTESTS "Build unittest binary in addition to static library" OFF)
-       OFF)
-option(FSFW_CICD_BUILD "Build for CI/CD. This can disable problematic test" OFF)
 option(FSFW_BUILD_DOCS "Build documentation with Sphinx and Doxygen" OFF)
-if(FSFW_BUILD_TESTS)
+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)
@@ -118,12 +54,6 @@ option(FSFW_ADD_INTERNAL_TESTS "Add internal unit tests" ON)
 option(FSFW_ADD_UNITTESTS "Add regular unittests. Requires Catch2" OFF)
 option(FSFW_ADD_HAL "Add Hardware Abstraction Layer" ON)
 
-if(UNIX)
-  option(FSFW_HAL_LINUX_ADD_PERIPHERAL_DRIVERS "Add Linux peripheral drivers"
-         OFF)
-  option(FSFW_HAL_LINUX_ADD_LIBGPIOD "Attempt to add Linux GPIOD drivers" OFF)
-endif()
-
 # Optional sources
 option(FSFW_ADD_PUS "Compile with PUS sources" ON)
 option(FSFW_ADD_MONITORING "Compile with monitoring components" ON)
@@ -136,95 +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(FSFW_GIT_VER_HANDLING_OK FALSE)
-  set_property(TARGET ${LIB_FSFW_NAME} PROPERTY INTERPROCEDURAL_OPTIMIZATION
+# Version handling
-                                                TRUE)
+if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
+    message(STATUS "${MSG_PREFIX} Determining version information with git")
+    include(FsfwHelpers)
+    determine_version_with_git("--exclude" "docker_*")
+    if(GIT_INFO)
+        set(FSFW_GIT_INFO ${GIT_INFO} CACHE STRING "Version information retrieved with git describe")
+        list(GET FSFW_GIT_INFO 1 FSFW_VERSION)
+        list(GET FSFW_GIT_INFO 2 FSFW_SUBVERSION)
+        list(GET FSFW_GIT_INFO 3 FSFW_REVISION)
+        list(GET FSFW_GIT_INFO 4 FSFW_VERSION_CST_GIT_SHA1)
+        if(NOT FSFW_VERSION)
+            set(FSFW_VERSION ${FSFW_VERSION_IF_GIT_FAILS})
+        endif()
+        if(NOT FSFW_SUBVERSION)
+            set(FSFW_SUBVERSION ${FSFW_SUBVERSION_IF_GIT_FAILS})
+        endif()
+        if(NOT FSFW_REVISION)
+            set(FSFW_REVISION ${FSFW_REVISION_IF_GIT_FAILS})
+        endif()
+        set(FSFW_GIT_VER_HANDLING_OK TRUE)
+   else()
+        set(FSFW_GIT_VER_HANDLING_OK FALSE)
+   endif()
+endif()
+if(NOT FSFW_GIT_VER_HANDLING_OK)
+    set(FSFW_VERSION ${FSFW_VERSION_IF_GIT_FAILS})
+    set(FSFW_SUBVERSION ${FSFW_SUBVERSION_IF_GIT_FAILS})
+    set(FSFW_REVISION ${FSFW_REVISION_IF_GIT_FAILS})
 endif()
 
-if(FSFW_BUILD_TESTS)
+if(FSFW_BUILD_UNITTESTS)
-  message(
+    message(STATUS "${MSG_PREFIX} Building the FSFW unittests in addition to the static library")
-    STATUS
+    # Check whether the user has already installed Catch2 first
-      "${MSG_PREFIX} Building the FSFW unittests in addition to the static library"
+    find_package(Catch2 ${FSFW_CATCH2_LIB_MAJOR_VERSION} CONFIG QUIET)
-  )
+    # Not installed, so use FetchContent to download and provide Catch2
-  # Check whether the user has already installed Catch2 first
+    if(NOT Catch2_FOUND)
-  find_package(Catch2 ${FSFW_CATCH2_LIB_MAJOR_VERSION})
+        message(STATUS "${MSG_PREFIX} Catch2 installation not found. Downloading Catch2 library with FetchContent")
-  # Not installed, so use FetchContent to download and provide Catch2
+        include(FetchContent)
-  if(NOT Catch2_FOUND)
-    message(
-      STATUS
-        "${MSG_PREFIX} Catch2 installation not found. Downloading Catch2 library with FetchContent"
-    )
-    include(FetchContent)
 
-    FetchContent_Declare(
+        FetchContent_Declare(
-      Catch2
+            Catch2
-      GIT_REPOSITORY https://github.com/catchorg/Catch2.git
+            GIT_REPOSITORY https://github.com/catchorg/Catch2.git
-      GIT_TAG ${FSFW_CATCH2_LIB_VERSION})
+            GIT_TAG        ${FSFW_CATCH2_LIB_VERSION}
+        )
 
-    list(APPEND FSFW_FETCH_CONTENT_TARGETS Catch2)
+        list(APPEND FSFW_FETCH_CONTENT_TARGETS Catch2)
-  endif()
+    endif()
 
-  set(FSFW_CONFIG_PATH unittests/testcfg)
+    set(FSFW_CONFIG_PATH tests/src/fsfw_tests/unit/testcfg)
-  configure_file(unittests/testcfg/FSFWConfig.h.in FSFWConfig.h)
+    configure_file(tests/src/fsfw_tests/unit/testcfg/FSFWConfig.h.in FSFWConfig.h)
-  configure_file(unittests/testcfg/TestsConfig.h.in tests/TestsConfig.h)
+    configure_file(tests/src/fsfw_tests/unit/testcfg/TestsConfig.h.in tests/TestsConfig.h)
 
-  project(${FSFW_TEST_TGT} CXX C)
+    project(${FSFW_TEST_TGT} CXX C)
-  add_executable(${FSFW_TEST_TGT})
+    add_executable(${FSFW_TEST_TGT})
-  if(IPO_SUPPORTED AND FSFW_ENABLE_IPO)
-    set_property(TARGET ${FSFW_TEST_TGT} PROPERTY INTERPROCEDURAL_OPTIMIZATION
-                                                  TRUE)
-  endif()
 
-  if(FSFW_TESTS_GEN_COV)
+    if(FSFW_TESTS_GEN_COV)
-    message(STATUS "${MSG_PREFIX} Generating coverage data for the library")
+        message(STATUS "${MSG_PREFIX} Generating coverage data for the library")
-    message(STATUS "${MSG_PREFIX} Targets linking against ${LIB_FSFW_NAME} "
+        message(STATUS "${MSG_PREFIX} Targets linking against ${LIB_FSFW_NAME} "
-                   "will be compiled with coverage data as well")
+            "will be compiled with coverage data as well"
-    set(CMAKE_BUILD_TYPE "Debug")
+        )
-    include(CodeCoverage)
+        set(CMAKE_BUILD_TYPE "Debug")
-  endif()
+        include(CodeCoverage)
+    endif()
 endif()
 
-message(
+message(STATUS "Finding and/or providing etl library with version ${FSFW_ETL_LIB_MAJOR_VERSION}")
-  STATUS
-    "${MSG_PREFIX} Finding and/or providing etl library with version ${FSFW_ETL_LIB_MAJOR_VERSION}"
-)
 
 # Check whether the user has already installed ETL first
 find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} CONFIG QUIET)
 # Not installed, so use FetchContent to download and provide etl
 if(NOT ${FSFW_ETL_LIB_NAME}_FOUND)
-  message(
+    message(STATUS
-    STATUS
+        "No ETL installation was found with find_package. Installing and providing "
-      "${MSG_PREFIX} No ETL installation was found with find_package. Installing and providing "
+        "etl with FindPackage"
-      "etl with FindPackage")
+    )
-  include(FetchContent)
+    include(FetchContent)
-
+    FetchContent_Declare(
-  FetchContent_Declare(
+        ${FSFW_ETL_LIB_NAME}
-    ${FSFW_ETL_LIB_NAME}
+        GIT_REPOSITORY https://github.com/ETLCPP/etl
-    GIT_REPOSITORY https://github.com/ETLCPP/etl
+        GIT_TAG        ${FSFW_ETL_LIB_VERSION}
-    GIT_TAG ${FSFW_ETL_LIB_VERSION})
+    )
-
+    list(APPEND FSFW_FETCH_CONTENT_TARGETS ${FSFW_ETL_LIB_NAME})
-  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})
+    FetchContent_MakeAvailable(${FSFW_FETCH_CONTENT_TARGETS})
-  if(TARGET ${FSFW_ETL_LIB_NAME})
+    if(TARGET ${FSFW_ETL_LIB_NAME})
-    add_library(${FSFW_ETL_LINK_TARGET} ALIAS ${FSFW_ETL_LIB_NAME})
+        add_library(${FSFW_ETL_LINK_TARGET} ALIAS ${FSFW_ETL_LIB_NAME})
-  endif()
+    endif()
-  if(TARGET Catch2)
+    if(TARGET Catch2)
-    # Fixes regression -preview4, to be confirmed in later releases Related
+        # Fixes regression -preview4, to be confirmed in later releases
-    # GitHub issue: https://github.com/catchorg/Catch2/issues/2417
+        # Related GitHub issue: https://github.com/catchorg/Catch2/issues/2417
-    set_target_properties(Catch2 PROPERTIES DEBUG_POSTFIX "")
+        set_target_properties(Catch2 PROPERTIES DEBUG_POSTFIX "")
-  endif()
+    endif()
 endif()
 
 set(FSFW_CORE_INC_PATH "inc")
@@ -232,241 +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} PRIVATE
-target_include_directories(${LIB_FSFW_NAME}
+    ${CMAKE_CURRENT_BINARY_DIR}
-                           INTERFACE ${CMAKE_CURRENT_BINARY_DIR})
+)
+target_include_directories(${LIB_FSFW_NAME} INTERFACE
+    ${CMAKE_CURRENT_BINARY_DIR}
+)
 
 # Backwards comptability
 if(OS_FSFW AND NOT FSFW_OSAL)
-  message(
+    message(WARNING "${MSG_PREFIX} Please pass the FSFW OSAL as FSFW_OSAL instead of OS_FSFW")
-    WARNING
+    set(FSFW_OSAL OS_FSFW)
-      "${MSG_PREFIX} Please pass the FSFW OSAL as FSFW_OSAL instead of OS_FSFW")
-  set(FSFW_OSAL OS_FSFW)
 endif()
 
 if(NOT FSFW_OSAL)
-  message(STATUS "No OS for FSFW via FSFW_OSAL set. Assuming host OS")
+	message(STATUS "${MSG_PREFIX} No OS for FSFW via FSFW_OSAL set. Assuming host OS")
-  # Assume host OS and autodetermine from OS_FSFW
+	# Assume host OS and autodetermine from OS_FSFW
-  if(UNIX)
+	if(UNIX)
-    set(FSFW_OSAL
+		set(FSFW_OSAL  "linux" 
-        "linux"
+			CACHE STRING 
-        CACHE STRING "OS abstraction layer used in the FSFW")
+			"OS abstraction layer used in the FSFW"
-  elseif(WIN32)
+		)
-    set(FSFW_OSAL
+	elseif(WIN32)
-        "host"
+		set(FSFW_OSAL  "host" 
-        CACHE STRING "OS abstraction layer used in the FSFW")
+			CACHE STRING "OS abstraction layer used in the FSFW"
-  endif()
+		)
+	endif()
+
 endif()
 
 set(FSFW_OSAL_DEFINITION FSFW_OSAL_HOST)
 
 if(FSFW_OSAL MATCHES host)
-  set(FSFW_OS_NAME "Host")
+    set(FSFW_OS_NAME "Host")
-  set(FSFW_OSAL_HOST ON)
+    set(FSFW_OSAL_HOST ON)
 elseif(FSFW_OSAL MATCHES linux)
-  set(FSFW_OS_NAME "Linux")
+    set(FSFW_OS_NAME "Linux")
-  set(FSFW_OSAL_LINUX ON)
+    set(FSFW_OSAL_LINUX ON)
 elseif(FSFW_OSAL MATCHES freertos)
-  set(FSFW_OS_NAME "FreeRTOS")
+    set(FSFW_OS_NAME "FreeRTOS")
-  set(FSFW_OSAL_FREERTOS ON)
+    set(FSFW_OSAL_FREERTOS ON)
-  target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${LIB_OS_NAME})
+    target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+        ${LIB_OS_NAME}
+    )
 elseif(FSFW_OSAL STREQUAL rtems)
-  set(FSFW_OS_NAME "RTEMS")
+    set(FSFW_OS_NAME "RTEMS")
-  set(FSFW_OSAL_RTEMS ON)
+    set(FSFW_OSAL_RTEMS ON)
 else()
-  message(
+    message(WARNING
-    WARNING
+        "${MSG_PREFIX} Invalid operating system for FSFW specified! Setting to host.."
-      "${MSG_PREFIX} Invalid operating system for FSFW specified! Setting to host.."
+    )
-  )
+    set(FSFW_OS_NAME "Host")
-  set(FSFW_OS_NAME "Host")
+    set(OS_FSFW "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(
+message(STATUS "${MSG_PREFIX} Compiling FSFW for the ${FSFW_OS_NAME} operating system")
-  STATUS "${MSG_PREFIX} Compiling FSFW for the ${FSFW_OS_NAME} operating system"
-)
 
 add_subdirectory(src)
+add_subdirectory(tests)
+if(FSFW_ADD_HAL)
+    add_subdirectory(hal)
+endif()
 add_subdirectory(contrib)
-if(FSFW_BUILD_TESTS)
-  add_subdirectory(unittests)
-endif()
 if(FSFW_BUILD_DOCS)
-  add_subdirectory(docs)
+    add_subdirectory(docs)
 endif()
 
-if(FSFW_BUILD_TESTS)
+if(FSFW_BUILD_UNITTESTS)
-  if(FSFW_TESTS_GEN_COV)
+    if(FSFW_TESTS_GEN_COV)
-    if(CMAKE_COMPILER_IS_GNUCXX)
+        if(CMAKE_COMPILER_IS_GNUCXX)
-      include(CodeCoverage)
+            include(CodeCoverage)
 
-      # Remove quotes.
+            # Remove quotes.
-      separate_arguments(COVERAGE_COMPILER_FLAGS NATIVE_COMMAND
+            separate_arguments(COVERAGE_COMPILER_FLAGS
-                         "${COVERAGE_COMPILER_FLAGS}")
+                NATIVE_COMMAND "${COVERAGE_COMPILER_FLAGS}"
+            )
 
-      # Add compile options manually, we don't want coverage for Catch2
+            # Add compile options manually, we don't want coverage for Catch2
-      target_compile_options(${FSFW_TEST_TGT}
+            target_compile_options(${FSFW_TEST_TGT} PRIVATE
-                             PRIVATE "${COVERAGE_COMPILER_FLAGS}")
+                "${COVERAGE_COMPILER_FLAGS}"
-      target_compile_options(${LIB_FSFW_NAME}
+            )
-                             PRIVATE "${COVERAGE_COMPILER_FLAGS}")
+            target_compile_options(${LIB_FSFW_NAME} PRIVATE
+                "${COVERAGE_COMPILER_FLAGS}"
+            )
 
-      # Exclude directories here
+            # Exclude directories here
-      if(WIN32)
+            if(WIN32)
-        set(GCOVR_ADDITIONAL_ARGS "--exclude-throw-branches"
+                set(GCOVR_ADDITIONAL_ARGS
-                                  "--exclude-unreachable-branches")
+                    "--exclude-throw-branches"
-        set(COVERAGE_EXCLUDES "/c/msys64/mingw64/*" "*/fsfw_hal/*")
+                    "--exclude-unreachable-branches"
-      elseif(UNIX)
+                )
-        set(COVERAGE_EXCLUDES
+                set(COVERAGE_EXCLUDES
-            "/usr/include/*"
+                    "/c/msys64/mingw64/*" "*/fsfw_hal/*"
-            "/usr/bin/*"
+                )
-            "Catch2/*"
+            elseif(UNIX)
-            "/usr/local/include/*"
+                set(COVERAGE_EXCLUDES
-            "*/fsfw_tests/*"
+                    "/usr/include/*" "/usr/bin/*" "Catch2/*"
-            "*/catch2-src/*"
+                    "/usr/local/include/*" "*/fsfw_tests/*"
-            "*/fsfw_hal/*")
+                    "*/catch2-src/*" "*/fsfw_hal/*"
-      endif()
+                )
+            endif()
 
-      target_link_options(${FSFW_TEST_TGT} PRIVATE -fprofile-arcs
+            target_link_options(${FSFW_TEST_TGT} PRIVATE
-                          -ftest-coverage)
+                -fprofile-arcs
-      target_link_options(${LIB_FSFW_NAME} PRIVATE -fprofile-arcs
+                -ftest-coverage
-                          -ftest-coverage)
+            )
-      # Need to specify this as an interface, otherwise there will the compile
+            target_link_options(${LIB_FSFW_NAME} PRIVATE
-      # issues
+                -fprofile-arcs
-      target_link_options(${LIB_FSFW_NAME} INTERFACE -fprofile-arcs
+                -ftest-coverage
-                          -ftest-coverage)
+            )
+            # Need to specify this as an interface, otherwise there will the compile issues
+            target_link_options(${LIB_FSFW_NAME} INTERFACE
+                -fprofile-arcs
+                -ftest-coverage
+            )
 
-      if(WIN32)
+            if(WIN32)
-        setup_target_for_coverage_gcovr_html(
+                setup_target_for_coverage_gcovr_html(
-          NAME ${FSFW_TEST_TGT}_coverage EXECUTABLE ${FSFW_TEST_TGT}
+                    NAME ${FSFW_TEST_TGT}_coverage
-          DEPENDENCIES ${FSFW_TEST_TGT})
+                    EXECUTABLE ${FSFW_TEST_TGT}
-      else()
+                    DEPENDENCIES ${FSFW_TEST_TGT}
-        setup_target_for_coverage_lcov(
+                )
-          NAME ${FSFW_TEST_TGT}_coverage EXECUTABLE ${FSFW_TEST_TGT}
+            else()
-          DEPENDENCIES ${FSFW_TEST_TGT})
+                setup_target_for_coverage_lcov(
-      endif()
+                    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
+# The project CMakeLists file has to set the FSFW_CONFIG_PATH and add it.
-# this is not given, we include the default configuration and emit a warning.
+# If this is not given, we include the default configuration and emit a warning.
 if(NOT FSFW_CONFIG_PATH)
-  set(DEF_CONF_PATH misc/defaultcfg/fsfwconfig)
+    set(DEF_CONF_PATH misc/defaultcfg/fsfwconfig)
-  if(NOT FSFW_BUILD_DOCS)
+    if(NOT FSFW_BUILD_DOCS)
-    message(
+        message(WARNING "${MSG_PREFIX} Flight Software Framework configuration path not set")
-      WARNING
+        message(WARNING "${MSG_PREFIX} Setting default configuration from ${DEF_CONF_PATH} ..")
-        "${MSG_PREFIX} Flight Software Framework configuration path not set")
+    endif()
-    message(
+    add_subdirectory(${DEF_CONF_PATH})
-      WARNING
+    set(FSFW_CONFIG_PATH ${DEF_CONF_PATH})
-        "${MSG_PREFIX} Setting default configuration from ${DEF_CONF_PATH} ..")
-  endif()
-  add_subdirectory(${DEF_CONF_PATH})
-  set(FSFW_CONFIG_PATH ${DEF_CONF_PATH})
 endif()
 
-# FSFW might be part of a possibly complicated folder structure, so we extract
+# FSFW might be part of a possibly complicated folder structure, so we 
-# the absolute path of the fsfwconfig folder.
+# extract the absolute path of the fsfwconfig folder.
 if(IS_ABSOLUTE ${FSFW_CONFIG_PATH})
-  set(FSFW_CONFIG_PATH_ABSOLUTE ${FSFW_CONFIG_PATH})
+	set(FSFW_CONFIG_PATH_ABSOLUTE ${FSFW_CONFIG_PATH})
 else()
-  get_filename_component(FSFW_CONFIG_PATH_ABSOLUTE ${FSFW_CONFIG_PATH} REALPATH
+	get_filename_component(FSFW_CONFIG_PATH_ABSOLUTE
-                         BASE_DIR ${CMAKE_SOURCE_DIR})
+		${FSFW_CONFIG_PATH} REALPATH BASE_DIR ${CMAKE_SOURCE_DIR}
+	)
 endif()
 
 foreach(INCLUDE_PATH ${FSFW_ADDITIONAL_INC_PATHS})
-  if(IS_ABSOLUTE ${INCLUDE_PATH})
+    if(IS_ABSOLUTE ${INCLUDE_PATH})
-    set(CURR_ABS_INC_PATH "${INCLUDE_PATH}")
+        set(CURR_ABS_INC_PATH "${INCLUDE_PATH}")
-  else()
+    else()
-    get_filename_component(CURR_ABS_INC_PATH ${INCLUDE_PATH} REALPATH BASE_DIR
+        get_filename_component(CURR_ABS_INC_PATH
-                           ${CMAKE_SOURCE_DIR})
+            ${INCLUDE_PATH} REALPATH BASE_DIR ${CMAKE_SOURCE_DIR})
-  endif()
+    endif()
 
-  if(CMAKE_VERBOSE)
+    if(CMAKE_VERBOSE)
-    message(STATUS "FSFW include path: ${CURR_ABS_INC_PATH}")
+        message(STATUS "FSFW include path: ${CURR_ABS_INC_PATH}")
-  endif()
+    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)
+    if(NOT DEFINED FSFW_WARNING_FLAGS)
-    set(FSFW_WARNING_FLAGS
+	   set(FSFW_WARNING_FLAGS
-        -Wall
+		  -Wall
-        -Wextra
+		  -Wextra
-        -Wimplicit-fallthrough=1
+		  -Wimplicit-fallthrough=1
-        -Wno-unused-parameter
+		  -Wno-unused-parameter
-        -Wno-psabi
+		  -Wno-psabi
-        -Wduplicated-cond # check for duplicate conditions
+          -Wduplicated-cond # check for duplicate conditions
-        -Wduplicated-branches # check for duplicate branches
+          -Wduplicated-branches # check for duplicate branches
-        -Wlogical-op # Search for bitwise operations instead of logical
+          -Wlogical-op # Search for bitwise operations instead of logical 
-        -Wnull-dereference # Search for NULL dereference
+          -Wnull-dereference # Search for NULL dereference
-        -Wundef # Warn if undefind marcos are used
+          -Wundef # Warn if undefind marcos are used
-        -Wformat=2 # Format string problem detection
+          -Wformat=2 # Format string problem detection
-        -Wformat-overflow=2 # Formatting issues in printf
+          -Wformat-overflow=2 # Formatting issues in printf
-        -Wformat-truncation=2 # Formatting issues in printf
+          -Wformat-truncation=2 # Formatting issues in printf
-        -Wformat-security # Search for dangerous printf operations
+          -Wformat-security # Search for dangerous printf operations
-        -Wstrict-overflow=3 # Warn if integer overflows might happen
+          -Wstrict-overflow=3 # Warn if integer overflows might happen
-        -Warray-bounds=2 # Some array bounds violations will be found
+          -Warray-bounds=2 # Some array bounds violations will be found
-        -Wshift-overflow=2 # Search for bit left shift overflows (<c++14)
+          -Wshift-overflow=2 # Search for bit left shift overflows (<c++14)
-        -Wcast-qual # Warn if the constness is cast away
+          -Wcast-qual # Warn if the constness is cast away
-        -Wstringop-overflow=4
+          -Wstringop-overflow=4
-        # -Wstack-protector # Emits a few false positives for low level access
+          # -Wstack-protector # Emits a few false positives for low level access
-        # -Wconversion # Creates many false positives -Warith-conversion # Use
+          # -Wconversion # Creates many false positives
-        # with Wconversion to find more implicit conversions -fanalyzer # Should
+          # -Warith-conversion # Use with Wconversion to find more implicit conversions
-        # be used to look through problems
+          # -fanalyzer # Should be used to look through problems
-    )
+        )
-  endif()
+    endif()
 
-  if(FSFW_GENERATE_SECTIONS)
+    if(FSFW_GENERATE_SECTIONS)
-    target_compile_options(${LIB_FSFW_NAME} PRIVATE "-ffunction-sections"
+        target_compile_options(${LIB_FSFW_NAME} PRIVATE
-                                                    "-fdata-sections")
+            "-ffunction-sections"
-  endif()
+            "-fdata-sections"
-
+        )
-  if(FSFW_REMOVE_UNUSED_CODE)
+    endif()
-    target_link_options(${LIB_FSFW_NAME} PRIVATE "Wl,--gc-sections")
-  endif()
-
-  if(FSFW_WARNING_SHADOW_LOCAL_GCC)
-    list(APPEND WARNING_FLAGS "-Wshadow=local")
-  endif()
 
+    if(FSFW_REMOVE_UNUSED_CODE)
+        target_link_options(${LIB_FSFW_NAME} PRIVATE
+            "Wl,--gc-sections"
+        )
+    endif()
+  
+    if(FSFW_WARNING_SHADOW_LOCAL_GCC)
+        list(APPEND WARNING_FLAGS "-Wshadow=local")
+    endif()
+	
 endif()
 
 if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-  set(COMPILER_FLAGS "/permissive-")
+	set(COMPILER_FLAGS "/permissive-")
 endif()
 
 # Required include paths to compile the FSFW
-target_include_directories(
+target_include_directories(${LIB_FSFW_NAME} INTERFACE 
-  ${LIB_FSFW_NAME} INTERFACE ${CMAKE_SOURCE_DIR} ${FSFW_CONFIG_PATH_ABSOLUTE}
+	${CMAKE_SOURCE_DIR}
-                             ${FSFW_CORE_INC_PATH} ${FSFW_ADD_INC_PATHS_ABS})
+	${FSFW_CONFIG_PATH_ABSOLUTE}
+	${FSFW_CORE_INC_PATH}
+	${FSFW_ADD_INC_PATHS_ABS}
+)
 
-# Includes path required to compile FSFW itself as well We assume that the
+# Includes path required to compile FSFW itself as well
-# fsfwconfig folder uses include relative to the project root here!
+# We assume that the fsfwconfig folder uses include relative to the project
-target_include_directories(
+# root here!
-  ${LIB_FSFW_NAME} PRIVATE ${CMAKE_SOURCE_DIR} ${FSFW_CONFIG_PATH_ABSOLUTE}
+target_include_directories(${LIB_FSFW_NAME} PRIVATE 
-                           ${FSFW_CORE_INC_PATH} ${FSFW_ADD_INC_PATHS_ABS})
+	${CMAKE_SOURCE_DIR}
+	${FSFW_CONFIG_PATH_ABSOLUTE}
+	${FSFW_CORE_INC_PATH}
+	${FSFW_ADD_INC_PATHS_ABS}
+)
 
-target_compile_options(${LIB_FSFW_NAME} PRIVATE ${FSFW_WARNING_FLAGS}
+target_compile_options(${LIB_FSFW_NAME} PRIVATE 
-                                                ${COMPILER_FLAGS})
+	${FSFW_WARNING_FLAGS}
+	${COMPILER_FLAGS}
+)
 
-target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${FSFW_ADDITIONAL_LINK_LIBS})
+target_link_libraries(${LIB_FSFW_NAME} PRIVATE
-target_link_libraries(${LIB_FSFW_NAME} PUBLIC ${FSFW_ETL_LINK_TARGET})
+    ${FSFW_ETL_LINK_TARGET}
+    ${FSFW_ADDITIONAL_LINK_LIBS}
+)
 
-string(
+string(CONCAT POST_BUILD_COMMENT
-  CONCAT
-    POST_BUILD_COMMENT
     "######################################################################\n"
     "Built FSFW v${FSFW_VERSION}.${FSFW_SUBVERSION}.${FSFW_REVISION}, "
     "Target OSAL: ${FSFW_OS_NAME}\n"
-    "######################################################################\n")
+    "######################################################################\n"
+)
 
 add_custom_command(
-  TARGET ${LIB_FSFW_NAME}
+   TARGET ${LIB_FSFW_NAME}
-  POST_BUILD
+   POST_BUILD
-  COMMENT ${POST_BUILD_COMMENT})
+   COMMENT ${POST_BUILD_COMMENT}
+)

README.md

@@ -99,7 +99,7 @@ add and link against the FSFW library in general.
 
 4. Link against the FSFW library
 
-   ```sh
+   ```cmake
    target_link_libraries(${YourProjectName} PRIVATE fsfw)
    ```
 
@@ -131,15 +131,15 @@ default. This can be disabled by setting the `FSFW_TESTS_COV_GEN` option to `OFF
 You can use the following commands inside the `fsfw` folder to set up the build system
 
 ```sh
-mkdir build-tests && cd build-tests
+mkdir build-Unittest && cd build-Unittest
-cmake -DFSFW_BUILD_TESTS=ON -DFSFW_OSAL=host -DCMAKE_BUILD_TYPE=Debug ..
+cmake -DFSFW_BUILD_UNITTESTS=ON -DFSFW_OSAL=host -DCMAKE_BUILD_TYPE=Debug ..
 ```
 
 You can also use `-DFSFW_OSAL=linux` on Linux systems.
 
 Coverage data in HTML format can be generated using the `CodeCoverage`
 [CMake module](https://github.com/bilke/cmake-modules/tree/master).
-To build the unittests, run them and then generate the coverage data in this format,
+To build the unittests, run them and then generare the coverage data in this format,
 the following command can be used inside the build directory after the build system was set up
 
 ```sh
@@ -188,10 +188,7 @@ and open the documentation conveniently. Try `helper.py -h for more information.
 
 The formatting is done by the `clang-format` tool. The configuration is contained within the
 `.clang-format` file in the repository root. As long as `clang-format` is installed, you
-can run the `auto-format.sh` helper script to format all source files consistently. Furthermore cmake-format is required to format CMake files which can be installed with:
+can run the `apply-clang-format.sh` helper script to format all source files consistently.
-````sh
-sudo pip install cmakelang
-````
 
 ## Index
 

automation/Dockerfile

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

automation/Jenkinsfile

@@ -1,9 +1,9 @@
 pipeline {
     environment {
-        BUILDDIR = 'cmake-build-tests'
+        BUILDDIR = 'build-tests'
     }
     agent {
-        docker { image 'fsfw-ci:d3'}
+        docker { image 'fsfw-ci:d2'}
     }
     stages {
         stage('Clean') {
@@ -14,7 +14,7 @@ pipeline {
         stage('Configure') {
             steps {
                 dir(BUILDDIR) {
-                    sh 'cmake -DFSFW_OSAL=host -DFSFW_BUILD_TESTS=ON -DFSFW_CICD_BUILD=ON ..'
+                    sh 'cmake -DFSFW_OSAL=host -DFSFW_BUILD_UNITTESTS=ON ..'
                 }
             }
         }

cmake/cmake-modules/GetGitRevisionDescription.cmake

@@ -0,0 +1,141 @@
+# - Returns a version string from Git
+#
+# These functions force a re-configure on each git commit so that you can
+# trust the values of the variables in your build system.
+#
+#  get_git_head_revision(<refspecvar> <hashvar> [<additional arguments to git describe> ...])
+#
+# Returns the refspec and sha hash of the current head revision
+#
+#  git_describe(<var> [<additional arguments to git describe> ...])
+#
+# Returns the results of git describe on the source tree, and adjusting
+# the output so that it tests false if an error occurs.
+#
+#  git_get_exact_tag(<var> [<additional arguments to git describe> ...])
+#
+# Returns the results of git describe --exact-match on the source tree,
+# and adjusting the output so that it tests false if there was no exact
+# matching tag.
+#
+# Requires CMake 2.6 or newer (uses the 'function' command)
+#
+# Original Author:
+# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
+# http://academic.cleardefinition.com
+# Iowa State University HCI Graduate Program/VRAC
+#
+# Copyright Iowa State University 2009-2010.
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+if(__get_git_revision_description)
+    return()
+endif()
+set(__get_git_revision_description YES)
+
+# We must run the following at "include" time, not at function call time,
+# to find the path to this module rather than the path to a calling list file
+get_filename_component(_gitdescmoddir ${CMAKE_CURRENT_LIST_FILE} PATH)
+
+function(get_git_head_revision _refspecvar _hashvar)
+    set(GIT_PARENT_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
+    set(GIT_DIR "${GIT_PARENT_DIR}/.git")
+    while(NOT EXISTS "${GIT_DIR}")    # .git dir not found, search parent directories
+        set(GIT_PREVIOUS_PARENT "${GIT_PARENT_DIR}")
+        get_filename_component(GIT_PARENT_DIR ${GIT_PARENT_DIR} PATH)
+        if(GIT_PARENT_DIR STREQUAL GIT_PREVIOUS_PARENT)
+            # We have reached the root directory, we are not in git
+            set(${_refspecvar} "GITDIR-NOTFOUND" PARENT_SCOPE)
+            set(${_hashvar} "GITDIR-NOTFOUND" PARENT_SCOPE)
+            return()
+        endif()
+        set(GIT_DIR "${GIT_PARENT_DIR}/.git")
+    endwhile()
+    # check if this is a submodule
+    if(NOT IS_DIRECTORY ${GIT_DIR})
+        file(READ ${GIT_DIR} submodule)
+        string(REGEX REPLACE "gitdir: (.*)\n$" "\\1" GIT_DIR_RELATIVE ${submodule})
+        get_filename_component(SUBMODULE_DIR ${GIT_DIR} PATH)
+
+        if (IS_ABSOLUTE ${GIT_DIR_RELATIVE})
+            set(GIT_DIR ${GIT_DIR_RELATIVE})
+        else()
+            get_filename_component(GIT_DIR ${SUBMODULE_DIR}/${GIT_DIR_RELATIVE} ABSOLUTE)
+        endif()
+
+    endif()
+    set(GIT_DATA "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/git-data")
+    if(NOT EXISTS "${GIT_DATA}")
+        file(MAKE_DIRECTORY "${GIT_DATA}")
+    endif()
+
+    if(NOT EXISTS "${GIT_DIR}/HEAD")
+        return()
+    endif()
+    set(HEAD_FILE "${GIT_DATA}/HEAD")
+    configure_file("${GIT_DIR}/HEAD" "${HEAD_FILE}" COPYONLY)
+
+    configure_file("${_gitdescmoddir}/GetGitRevisionDescription.cmake.in"
+        "${GIT_DATA}/grabRef.cmake"
+        @ONLY)
+    include("${GIT_DATA}/grabRef.cmake")
+
+    set(${_refspecvar} "${HEAD_REF}" PARENT_SCOPE)
+    set(${_hashvar} "${HEAD_HASH}" PARENT_SCOPE)
+endfunction()
+
+function(git_describe _var)
+    if(NOT GIT_FOUND)
+        find_package(Git QUIET)
+    endif()
+    get_git_head_revision(refspec hash)
+    if(NOT GIT_FOUND)
+        set(${_var} "GIT-NOTFOUND" PARENT_SCOPE)
+        return()
+    endif()
+    if(NOT hash)
+        set(${_var} "HEAD-HASH-NOTFOUND" PARENT_SCOPE)
+        return()
+    endif()
+
+    # TODO sanitize
+    #if((${ARGN}" MATCHES "&&") OR
+    #    (ARGN MATCHES "||") OR
+    #    (ARGN MATCHES "\\;"))
+    #    message("Please report the following error to the project!")
+    #    message(FATAL_ERROR "Looks like someone's doing something nefarious with git_describe! Passed arguments ${ARGN}")
+    #endif()
+
+    #message(STATUS "Arguments to execute_process: ${ARGN}")
+
+    execute_process(COMMAND
+        ${GIT_EXECUTABLE}
+        describe
+        ${hash}
+        ${ARGN}
+        WORKING_DIRECTORY
+        "${CMAKE_SOURCE_DIR}"
+        RESULT_VARIABLE
+        res
+        OUTPUT_VARIABLE
+        out
+        ERROR_QUIET
+        OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if(NOT res EQUAL 0)
+        set(out "${out}-${res}-NOTFOUND")
+    endif()
+
+    set(${_var} "${out}" PARENT_SCOPE)
+endfunction()
+
+function(git_get_exact_tag _var)
+    git_describe(out --exact-match ${ARGN})
+    set(${_var} "${out}" PARENT_SCOPE)
+endfunction()
+
+function(git_get_tag _var)
+    git_describe(out --tags ${ARGN})
+    set(${_var} "${out}" PARENT_SCOPE)
+endfunction()

cmake/cmake-modules/GetGitRevisionDescription.cmake.in

@@ -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 Iowa State University 2009-2010.
-# Copyright 2011-2015, Contributors
 # Distributed under the Boost Software License, Version 1.0.
 # (See accompanying file LICENSE_1_0.txt or copy at
 # http://www.boost.org/LICENSE_1_0.txt)
-# SPDX-License-Identifier: BSL-1.0
 
 set(HEAD_HASH)
 
@@ -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)
+    configure_file("@GIT_DIR@/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY)
-    else()
+    elseif(EXISTS "@GIT_DIR@/logs/${HEAD_REF}")
-        configure_file("@GIT_DIR@/packed-refs" "@GIT_DATA@/packed-refs" COPYONLY)
+        configure_file("@GIT_DIR@/logs/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY)
-        file(READ "@GIT_DATA@/packed-refs" PACKED_REFS)
+        set(HEAD_HASH "${HEAD_REF}")
-        if(${PACKED_REFS} MATCHES "([0-9a-z]*) ${HEAD_REF}")
-            set(HEAD_HASH "${CMAKE_MATCH_1}")
-        endif()
     endif()
 else()
     # detached HEAD
@@ -38,6 +33,6 @@ else()
 endif()
 
 if(NOT HEAD_HASH)
-    file(READ "@GIT_DATA@/head-ref" HEAD_HASH LIMIT 1024)
+file(READ "@GIT_DATA@/head-ref" HEAD_HASH LIMIT 1024)
-    string(STRIP "${HEAD_HASH}" HEAD_HASH)
+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
+The license file in included here as well.
-[cmake-modules repository](https://github.com/rpavlik/cmake-modules). It was decided to do
-this because only a small subset of its provided functions are needed.

cmake/cmake-modules/rpavlik/GetGitRevisionDescription.cmake

@@ -1,284 +0,0 @@
-# - Returns a version string from Git
-#
-# These functions force a re-configure on each git commit so that you can
-# trust the values of the variables in your build system.
-#
-#  get_git_head_revision(<refspecvar> <hashvar> [ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR])
-#
-# Returns the refspec and sha hash of the current head revision
-#
-#  git_describe(<var> [<additional arguments to git describe> ...])
-#
-# Returns the results of git describe on the source tree, and adjusting
-# the output so that it tests false if an error occurs.
-#
-#  git_describe_working_tree(<var> [<additional arguments to git describe> ...])
-#
-# Returns the results of git describe on the working tree (--dirty option),
-# and adjusting the output so that it tests false if an error occurs.
-#
-#  git_get_exact_tag(<var> [<additional arguments to git describe> ...])
-#
-# Returns the results of git describe --exact-match on the source tree,
-# and adjusting the output so that it tests false if there was no exact
-# matching tag.
-#
-#  git_local_changes(<var>)
-#
-# Returns either "CLEAN" or "DIRTY" with respect to uncommitted changes.
-# Uses the return code of "git diff-index --quiet HEAD --".
-# Does not regard untracked files.
-#
-# Requires CMake 2.6 or newer (uses the 'function' command)
-#
-# Original Author:
-# 2009-2020 Ryan Pavlik <ryan.pavlik@gmail.com> <abiryan@ryand.net>
-# http://academic.cleardefinition.com
-#
-# Copyright 2009-2013, Iowa State University.
-# Copyright 2013-2020, Ryan Pavlik
-# Copyright 2013-2020, Contributors
-# SPDX-License-Identifier: BSL-1.0
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
-# http://www.boost.org/LICENSE_1_0.txt)
-
-if(__get_git_revision_description)
-    return()
-endif()
-set(__get_git_revision_description YES)
-
-# We must run the following at "include" time, not at function call time,
-# to find the path to this module rather than the path to a calling list file
-get_filename_component(_gitdescmoddir ${CMAKE_CURRENT_LIST_FILE} PATH)
-
-# Function _git_find_closest_git_dir finds the next closest .git directory
-# that is part of any directory in the path defined by _start_dir.
-# The result is returned in the parent scope variable whose name is passed
-# as variable _git_dir_var. If no .git directory can be found, the
-# function returns an empty string via _git_dir_var.
-#
-# Example: Given a path C:/bla/foo/bar and assuming C:/bla/.git exists and
-# neither foo nor bar contain a file/directory .git. This wil return
-# C:/bla/.git
-#
-function(_git_find_closest_git_dir _start_dir _git_dir_var)
-    set(cur_dir "${_start_dir}")
-    set(git_dir "${_start_dir}/.git")
-    while(NOT EXISTS "${git_dir}")
-        # .git dir not found, search parent directories
-        set(git_previous_parent "${cur_dir}")
-        get_filename_component(cur_dir "${cur_dir}" DIRECTORY)
-        if(cur_dir STREQUAL git_previous_parent)
-            # We have reached the root directory, we are not in git
-            set(${_git_dir_var}
-                ""
-                PARENT_SCOPE)
-            return()
-        endif()
-        set(git_dir "${cur_dir}/.git")
-    endwhile()
-    set(${_git_dir_var}
-        "${git_dir}"
-        PARENT_SCOPE)
-endfunction()
-
-function(get_git_head_revision _refspecvar _hashvar)
-    _git_find_closest_git_dir("${CMAKE_CURRENT_SOURCE_DIR}" GIT_DIR)
-
-    if("${ARGN}" STREQUAL "ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR")
-        set(ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR TRUE)
-    else()
-        set(ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR FALSE)
-    endif()
-    if(NOT "${GIT_DIR}" STREQUAL "")
-        file(RELATIVE_PATH _relative_to_source_dir "${CMAKE_SOURCE_DIR}"
-             "${GIT_DIR}")
-        if("${_relative_to_source_dir}" MATCHES "[.][.]" AND NOT ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR)
-            # We've gone above the CMake root dir.
-            set(GIT_DIR "")
-        endif()
-    endif()
-    if("${GIT_DIR}" STREQUAL "")
-        set(${_refspecvar}
-            "GITDIR-NOTFOUND"
-            PARENT_SCOPE)
-        set(${_hashvar}
-            "GITDIR-NOTFOUND"
-            PARENT_SCOPE)
-        return()
-    endif()
-
-    # Check if the current source dir is a git submodule or a worktree.
-    # In both cases .git is a file instead of a directory.
-    #
-    if(NOT IS_DIRECTORY ${GIT_DIR})
-        # The following git command will return a non empty string that
-        # points to the super project working tree if the current
-        # source dir is inside a git submodule.
-        # Otherwise the command will return an empty string.
-        #
-        execute_process(
-            COMMAND "${GIT_EXECUTABLE}" rev-parse
-                    --show-superproject-working-tree
-            WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
-            OUTPUT_VARIABLE out
-            ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
-        if(NOT "${out}" STREQUAL "")
-            # If out is empty, GIT_DIR/CMAKE_CURRENT_SOURCE_DIR is in a submodule
-            file(READ ${GIT_DIR} submodule)
-            string(REGEX REPLACE "gitdir: (.*)$" "\\1" GIT_DIR_RELATIVE
-                                 ${submodule})
-            string(STRIP ${GIT_DIR_RELATIVE} GIT_DIR_RELATIVE)
-            get_filename_component(SUBMODULE_DIR ${GIT_DIR} PATH)
-            get_filename_component(GIT_DIR ${SUBMODULE_DIR}/${GIT_DIR_RELATIVE}
-                                   ABSOLUTE)
-            set(HEAD_SOURCE_FILE "${GIT_DIR}/HEAD")
-        else()
-            # GIT_DIR/CMAKE_CURRENT_SOURCE_DIR is in a worktree
-            file(READ ${GIT_DIR} worktree_ref)
-            # The .git directory contains a path to the worktree information directory
-            # inside the parent git repo of the worktree.
-            #
-            string(REGEX REPLACE "gitdir: (.*)$" "\\1" git_worktree_dir
-                                 ${worktree_ref})
-            string(STRIP ${git_worktree_dir} git_worktree_dir)
-            _git_find_closest_git_dir("${git_worktree_dir}" GIT_DIR)
-            set(HEAD_SOURCE_FILE "${git_worktree_dir}/HEAD")
-        endif()
-    else()
-        set(HEAD_SOURCE_FILE "${GIT_DIR}/HEAD")
-    endif()
-    set(GIT_DATA "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/git-data")
-    if(NOT EXISTS "${GIT_DATA}")
-        file(MAKE_DIRECTORY "${GIT_DATA}")
-    endif()
-
-    if(NOT EXISTS "${HEAD_SOURCE_FILE}")
-        return()
-    endif()
-    set(HEAD_FILE "${GIT_DATA}/HEAD")
-    configure_file("${HEAD_SOURCE_FILE}" "${HEAD_FILE}" COPYONLY)
-
-    configure_file("${_gitdescmoddir}/GetGitRevisionDescription.cmake.in"
-                   "${GIT_DATA}/grabRef.cmake" @ONLY)
-    include("${GIT_DATA}/grabRef.cmake")
-
-    set(${_refspecvar}
-        "${HEAD_REF}"
-        PARENT_SCOPE)
-    set(${_hashvar}
-        "${HEAD_HASH}"
-        PARENT_SCOPE)
-endfunction()
-
-function(git_describe _var)
-    if(NOT GIT_FOUND)
-        find_package(Git QUIET)
-    endif()
-    get_git_head_revision(refspec hash)
-    if(NOT GIT_FOUND)
-        set(${_var}
-            "GIT-NOTFOUND"
-            PARENT_SCOPE)
-        return()
-    endif()
-    if(NOT hash)
-        set(${_var}
-            "HEAD-HASH-NOTFOUND"
-            PARENT_SCOPE)
-        return()
-    endif()
-
-    # TODO sanitize
-    #if((${ARGN}" MATCHES "&&") OR
-    #   (ARGN MATCHES "||") OR
-    #   (ARGN MATCHES "\\;"))
-    #   message("Please report the following error to the project!")
-    #   message(FATAL_ERROR "Looks like someone's doing something nefarious with git_describe! Passed arguments ${ARGN}")
-    #endif()
-
-    #message(STATUS "Arguments to execute_process: ${ARGN}")
-
-    execute_process(
-        COMMAND "${GIT_EXECUTABLE}" describe --tags --always ${hash} ${ARGN}
-        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
-        RESULT_VARIABLE res
-        OUTPUT_VARIABLE out
-        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
-    if(NOT res EQUAL 0)
-        set(out "${out}-${res}-NOTFOUND")
-    endif()
-
-    set(${_var}
-        "${out}"
-        PARENT_SCOPE)
-endfunction()
-
-function(git_describe_working_tree _var)
-    if(NOT GIT_FOUND)
-        find_package(Git QUIET)
-    endif()
-    if(NOT GIT_FOUND)
-        set(${_var}
-            "GIT-NOTFOUND"
-            PARENT_SCOPE)
-        return()
-    endif()
-
-    execute_process(
-        COMMAND "${GIT_EXECUTABLE}" describe --dirty ${ARGN}
-        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
-        RESULT_VARIABLE res
-        OUTPUT_VARIABLE out
-        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
-    if(NOT res EQUAL 0)
-        set(out "${out}-${res}-NOTFOUND")
-    endif()
-
-    set(${_var}
-        "${out}"
-        PARENT_SCOPE)
-endfunction()
-
-function(git_get_exact_tag _var)
-    git_describe(out --exact-match ${ARGN})
-    set(${_var}
-        "${out}"
-        PARENT_SCOPE)
-endfunction()
-
-function(git_local_changes _var)
-    if(NOT GIT_FOUND)
-        find_package(Git QUIET)
-    endif()
-    get_git_head_revision(refspec hash)
-    if(NOT GIT_FOUND)
-        set(${_var}
-            "GIT-NOTFOUND"
-            PARENT_SCOPE)
-        return()
-    endif()
-    if(NOT hash)
-        set(${_var}
-            "HEAD-HASH-NOTFOUND"
-            PARENT_SCOPE)
-        return()
-    endif()
-
-    execute_process(
-        COMMAND "${GIT_EXECUTABLE}" diff-index --quiet HEAD --
-        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
-        RESULT_VARIABLE res
-        OUTPUT_VARIABLE out
-        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
-    if(res EQUAL 0)
-        set(${_var}
-            "CLEAN"
-            PARENT_SCOPE)
-    else()
-        set(${_var}
-            "DIRTY"
-            PARENT_SCOPE)
-    endif()
-endfunction()

cmake/cmake-modules/rpavlik/LICENSES/BSD-3-Clause.txt

@@ -1,26 +0,0 @@
-Copyright (c) <year> <owner>. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice,
-this list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
-this list of conditions and the following disclaimer in the documentation
-and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its contributors
-may be used to endorse or promote products derived from this software without
-specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

cmake/cmake-modules/rpavlik/LICENSES/BSL-1.0.txt

@@ -1,23 +0,0 @@
-Boost Software License - Version 1.0 - August 17th, 2003
-
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute, execute,
-and transmit the Software, and to prepare derivative works of the Software,
-and to permit third-parties to whom the Software is furnished to do so, all
-subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer, must
-be included in all copies of the Software, in whole or in part, and all derivative
-works of the Software, unless such copies or derivative works are solely in
-the form of machine-executable object code generated by a source language
-processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
-COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES
-OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

cmake/cmake-modules/rpavlik/LICENSE_1_0.txt

@@ -1,23 +0,0 @@
-Boost Software License - Version 1.0 - August 17th, 2003
-
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.

docs/README-highlevel.md

@@ -14,7 +14,7 @@ FSFW to achieve that. The fsfw uses run-time type information but exceptions are
 # Failure Handling
 
 Functions should return a defined `ReturnValue_t` to signal to the caller that something has
-gone wrong. Returnvalues must be unique. For this the function `returnvalue::makeCode`
+gone wrong. Returnvalues must be unique. For this the function `HasReturnvaluesIF::makeReturnCode`
 or the macro `MAKE_RETURN` can be used. The `CLASS_ID` is a unique id for that type of object.
 See `returnvalues/FwClassIds` folder. The user can add custom `CLASS_ID`s via the
 `fsfwconfig` folder.

docs/README-localpools.md

@@ -144,7 +144,7 @@ ReturnValue_t GyroHandler::initializeLocalDataPool(localpool::DataPool &localDat
 			new PoolEntry<uint8_t>({0}));
 
 	poolManager.subscribeForPeriodicPacket(gyroData.getSid(), false, 4.0, false);
-	return returnvalue::OK;
+	return HasReturnvaluesIF::RETURN_OK;
 }
 ```
 
@@ -154,7 +154,7 @@ in any case:
 
 ```cpp
 PoolReadGuard readHelper(&gyroData);
-if(readHelper.getReadResult() == returnvalue::OK) {
+if(readHelper.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
 	if(not gyroData.isValid()) {
 		gyroData.setValidity(true, true);
 	}

docs/api/returnvalue.rst

@@ -3,7 +3,7 @@
 Returnvalue API
 ==================
 
-.. doxygenfile:: returnvalue.h
+.. doxygenfile:: HasReturnvaluesIF.h
 
 .. _fwclassids:
 

docs/devicehandlers.rst

@@ -75,11 +75,11 @@ and the respective source file with sensible default return values:
 	void TestDeviceHandler::doShutDown() {}
 
 	ReturnValue_t TestDeviceHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
-	  return returnvalue::OK;
+	  return HasReturnvaluesIF::RETURN_OK;
 	}
 
 	ReturnValue_t TestDeviceHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
-	  return returnvalue::OK;
+	  return HasReturnvaluesIF::RETURN_OK;
 	}
 
 	void TestDeviceHandler::fillCommandAndReplyMap() {}
@@ -87,17 +87,17 @@ and the respective source file with sensible default return values:
 	ReturnValue_t TestDeviceHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
 	                                                         const uint8_t* commandData,
 	                                                         size_t commandDataLen) {
-	  return returnvalue::OK;
+	  return HasReturnvaluesIF::RETURN_OK;
 	}
 
 	ReturnValue_t TestDeviceHandler::scanForReply(const uint8_t* start, size_t remainingSize,
 	                                              DeviceCommandId_t* foundId, size_t* foundLen) {
-	  return returnvalue::OK;
+	  return HasReturnvaluesIF::RETURN_OK;
 	}
 
 	ReturnValue_t TestDeviceHandler::interpretDeviceReply(DeviceCommandId_t id,
 	                                                      const uint8_t* packet) {
-	  return returnvalue::OK;
+	  return HasReturnvaluesIF::RETURN_OK;
 	}
 
 	uint32_t TestDeviceHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) {
@@ -106,5 +106,5 @@ and the respective source file with sensible default return values:
 
 	ReturnValue_t TestDeviceHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
 	                                                         LocalDataPoolManager& poolManager) {
-	  return returnvalue::OK;
+	  return HasReturnvaluesIF::RETURN_OK;
 	}

docs/getting_started.rst

@@ -106,7 +106,7 @@ You can use the following commands inside the ``fsfw`` folder to set up the buil
 .. code-block:: console
 
    mkdir build-tests && cd build-tests
-   cmake -DFSFW_BUILD_TESTS=ON -DFSFW_OSAL=host ..
+   cmake -DFSFW_BUILD_UNITTESTS=ON -DFSFW_OSAL=host ..
 
 
 You can also use ``-DFSFW_OSAL=linux`` on Linux systems.

docs/highlevel.rst

@@ -18,7 +18,7 @@ Failure Handling
 -----------------
 
 Functions should return a defined :cpp:type:`ReturnValue_t` to signal to the caller that something has
-gone wrong. Returnvalues must be unique. For this the function :cpp:func:`returnvalue::makeCode`
+gone wrong. Returnvalues must be unique. For this the function :cpp:func:`HasReturnvaluesIF::makeReturnCode`
 or the :ref:`macro MAKE_RETURN_CODE <retvalapi>` can be used. The ``CLASS_ID`` is a unique ID for that type of object.
 See the :ref:`FSFW Class IDs file <fwclassids>`. The user can add custom ``CLASS_ID``\s via the
 ``fsfwconfig`` folder.

docs/localpools.rst

@@ -150,7 +150,7 @@ with a housekeeping service command.
 				new PoolEntry<uint8_t>({0}));
 
 		poolManager.subscribeForPeriodicPacket(gyroData.getSid(), false, 4.0, false);
-		return returnvalue::OK;
+		return HasReturnvaluesIF::RETURN_OK;
 	}
 
 Now, if we receive some sensor data and converted them into the right format,
@@ -160,7 +160,7 @@ in any case:
 .. code-block:: cpp
 
 	PoolReadGuard readHelper(&gyroData);
-	if(readHelper.getReadResult() == returnvalue::OK) {
+	if(readHelper.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
 		if(not gyroData.isValid()) {
 			gyroData.setValidity(true, true);
 		}

hal/CMakeLists.txt

@@ -0,0 +1,48 @@
+cmake_minimum_required(VERSION 3.13)
+
+# Can also be changed by upper CMakeLists.txt file
+find_library(LIB_FSFW_NAME fsfw REQUIRED)
+
+option(FSFW_HAL_ADD_LINUX "Add the Linux HAL to the sources. Requires gpiod library" OFF)
+# On by default for now because I did not have an issue including and compiling those files
+# and libraries on a Desktop Linux system and the primary target of the FSFW is still embedded
+# Linux. The only exception from this is the gpiod library which requires a dedicated installation,
+# but CMake is able to determine whether this library is installed with find_library.
+option(FSFW_HAL_LINUX_ADD_PERIPHERAL_DRIVERS "Add peripheral drivers for embedded Linux" ON)
+option(FSFW_HAL_LINUX_ADD_LIBGPIOD "Target implements libgpiod" ON)
+
+option(FSFW_HAL_ADD_RASPBERRY_PI "Add Raspberry Pi specific code to the sources" OFF)
+option(FSFW_HAL_ADD_STM32H7 "Add the STM32H7 HAL to the sources" OFF)
+option(FSFW_HAL_WARNING_SHADOW_LOCAL_GCC "Enable -Wshadow=local warning in GCC" ON)
+
+set(LINUX_HAL_PATH_NAME linux)
+set(STM32H7_PATH_NAME stm32h7)
+
+add_subdirectory(src)
+
+foreach(INCLUDE_PATH ${FSFW_HAL_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(CMAKE_VERBOSE)
+        message(STATUS "FSFW include path: ${CURR_ABS_INC_PATH}")
+    endif()
+
+    list(APPEND FSFW_HAL_ADD_INC_PATHS_ABS ${CURR_ABS_INC_PATH})
+endforeach()
+
+target_include_directories(${LIB_FSFW_NAME} PRIVATE
+    ${FSFW_HAL_ADD_INC_PATHS_ABS}
+)
+
+target_compile_definitions(${LIB_FSFW_NAME} PRIVATE
+    ${FSFW_HAL_DEFINES}
+)
+
+target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+    ${FSFW_HAL_LINK_LIBS}
+)

hal/src/CMakeLists.txt

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

hal/src/fsfw_hal/CMakeLists.txt

@@ -2,9 +2,9 @@ add_subdirectory(devicehandlers)
 add_subdirectory(common)
 
 if(UNIX)
-  add_subdirectory(linux)
+    add_subdirectory(linux)
 endif()
 
 if(FSFW_HAL_ADD_STM32H7)
-  add_subdirectory(stm32h7)
+    add_subdirectory(stm32h7)
 endif()

hal/src/fsfw_hal/common/gpio/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE
+    GpioCookie.cpp
+)

hal/src/fsfw_hal/common/gpio/GpioCookie.cpp

@@ -11,7 +11,7 @@ ReturnValue_t GpioCookie::addGpio(gpioId_t gpioId, GpioBase* gpioConfig) {
 #else
     sif::printWarning("GpioCookie::addGpio: gpioConfig is nullpointer\n");
 #endif
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
   auto gpioMapIter = gpioMap.find(gpioId);
   if (gpioMapIter == gpioMap.end()) {
@@ -25,9 +25,9 @@ ReturnValue_t GpioCookie::addGpio(gpioId_t gpioId, GpioBase* gpioConfig) {
       sif::printWarning("GpioCookie::addGpio: Failed to add GPIO %d to GPIO map\n", gpioId);
 #endif
 #endif
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
-    return returnvalue::OK;
+    return HasReturnvaluesIF::RETURN_OK;
   }
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -36,7 +36,7 @@ ReturnValue_t GpioCookie::addGpio(gpioId_t gpioId, GpioBase* gpioConfig) {
   sif::printWarning("GpioCookie::addGpio: GPIO already exists in GPIO map\n");
 #endif
 #endif
-  return returnvalue::FAILED;
+  return HasReturnvaluesIF::RETURN_FAILED;
 }
 
 GpioMap GpioCookie::getGpioMap() const { return gpioMap; }

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

@@ -2,7 +2,7 @@
 #define COMMON_GPIO_GPIOCOOKIE_H_
 
 #include <fsfw/devicehandlers/CookieIF.h>
-#include <fsfw/returnvalues/returnvalue.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
 #include "GpioIF.h"
 #include "gpioDefinitions.h"

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

@@ -2,7 +2,7 @@
 #define COMMON_GPIO_GPIOIF_H_
 
 #include <fsfw/devicehandlers/CookieIF.h>
-#include <fsfw/returnvalues/returnvalue.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
 #include "gpioDefinitions.h"
 
@@ -13,7 +13,7 @@ class GpioCookie;
  * 			over GPIOs.
  * @author	J. Meier
  */
-class GpioIF {
+class GpioIF : public HasReturnvaluesIF {
  public:
   virtual ~GpioIF(){};
 
@@ -29,7 +29,7 @@ class GpioIF {
    * 			functionality to pull a certain GPIO to high logic level.
    *
    * @param gpioId	A unique number which specifies the GPIO to drive.
-   * @return  Returns returnvalue::OK for success. This should never return returnvalue::FAILED.
+   * @return  Returns RETURN_OK for success. This should never return RETURN_FAILED.
    */
   virtual ReturnValue_t pullHigh(gpioId_t gpioId) = 0;
 

hal/src/fsfw_hal/devicehandlers/CMakeLists.txt

@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE
+    GyroL3GD20Handler.cpp
+    MgmRM3100Handler.cpp
+    MgmLIS3MDLHandler.cpp
+)

hal/src/fsfw_hal/devicehandlers/GyroL3GD20Handler.cpp

@@ -70,9 +70,9 @@ ReturnValue_t GyroHandlerL3GD20H::buildTransitionDeviceCommand(DeviceCommandId_t
           "GyroL3GD20Handler::buildTransitionDeviceCommand: "
           "Unknown internal state!\n");
 #endif
-      return returnvalue::OK;
+      return HasReturnvaluesIF::RETURN_OK;
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t GyroHandlerL3GD20H::buildNormalDeviceCommand(DeviceCommandId_t *id) {
@@ -135,7 +135,7 @@ ReturnValue_t GyroHandlerL3GD20H::buildCommandFromCommand(DeviceCommandId_t devi
     default:
       return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t GyroHandlerL3GD20H::scanForReply(const uint8_t *start, size_t len,
@@ -144,12 +144,12 @@ ReturnValue_t GyroHandlerL3GD20H::scanForReply(const uint8_t *start, size_t len,
   *foundId = this->getPendingCommand();
   *foundLen = this->rawPacketLen;
 
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t GyroHandlerL3GD20H::interpretDeviceReply(DeviceCommandId_t id,
                                                        const uint8_t *packet) {
-  ReturnValue_t result = returnvalue::OK;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
   switch (id) {
     case (L3GD20H::CONFIGURE_CTRL_REGS): {
       commandExecuted = true;
@@ -207,7 +207,7 @@ ReturnValue_t GyroHandlerL3GD20H::interpretDeviceReply(DeviceCommandId_t id,
       }
 
       PoolReadGuard readSet(&dataset);
-      if (readSet.getReadResult() == returnvalue::OK) {
+      if (readSet.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
         if (std::abs(angVelocX) < this->absLimitX) {
           dataset.angVelocX = angVelocX;
           dataset.angVelocX.setValid(true);
@@ -252,9 +252,7 @@ ReturnValue_t GyroHandlerL3GD20H::initializeLocalDataPool(localpool::DataPool &l
   localDataPoolMap.emplace(L3GD20H::ANG_VELOC_Y, new PoolEntry<float>({0.0}));
   localDataPoolMap.emplace(L3GD20H::ANG_VELOC_Z, new PoolEntry<float>({0.0}));
   localDataPoolMap.emplace(L3GD20H::TEMPERATURE, new PoolEntry<float>({0.0}));
-  poolManager.subscribeForRegularPeriodicPacket(
+  return HasReturnvaluesIF::RETURN_OK;
-      subdp::RegularHkPeriodicParams(dataset.getSid(), false, 10.0));
-  return returnvalue::OK;
 }
 
 void GyroHandlerL3GD20H::fillCommandAndReplyMap() {

hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp

@@ -82,7 +82,7 @@ ReturnValue_t MgmLIS3MDLHandler::buildTransitionDeviceCommand(DeviceCommandId_t
 #else
       sif::printWarning("GyroHandler::buildTransitionDeviceCommand: Unknown internal state!\n");
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-      return returnvalue::OK;
+      return HasReturnvaluesIF::RETURN_OK;
     }
   }
   return buildCommandFromCommand(*id, NULL, 0);
@@ -137,7 +137,7 @@ ReturnValue_t MgmLIS3MDLHandler::buildCommandFromCommand(DeviceCommandId_t devic
 
       rawPacket = commandBuffer;
       rawPacketLen = MGMLIS3MDL::NR_OF_DATA_AND_CFG_REGISTERS + 1;
-      return returnvalue::OK;
+      return RETURN_OK;
     }
     case (MGMLIS3MDL::READ_TEMPERATURE): {
       std::memset(commandBuffer, 0, 3);
@@ -145,7 +145,7 @@ ReturnValue_t MgmLIS3MDLHandler::buildCommandFromCommand(DeviceCommandId_t devic
 
       rawPacket = commandBuffer;
       rawPacketLen = 3;
-      return returnvalue::OK;
+      return RETURN_OK;
     }
     case (MGMLIS3MDL::IDENTIFY_DEVICE): {
       return identifyDevice();
@@ -155,7 +155,7 @@ ReturnValue_t MgmLIS3MDLHandler::buildCommandFromCommand(DeviceCommandId_t devic
     }
     case (MGMLIS3MDL::SETUP_MGM): {
       setupMgm();
-      return returnvalue::OK;
+      return HasReturnvaluesIF::RETURN_OK;
     }
     case (MGMLIS3MDL::ACCURACY_OP_MODE_SET): {
       return setOperatingMode(commandData, commandDataLen);
@@ -163,7 +163,7 @@ ReturnValue_t MgmLIS3MDLHandler::buildCommandFromCommand(DeviceCommandId_t devic
     default:
       return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
   }
-  return returnvalue::FAILED;
+  return HasReturnvaluesIF::RETURN_FAILED;
 }
 
 ReturnValue_t MgmLIS3MDLHandler::identifyDevice() {
@@ -174,7 +174,7 @@ ReturnValue_t MgmLIS3MDLHandler::identifyDevice() {
   rawPacket = commandBuffer;
   rawPacketLen = size;
 
-  return returnvalue::OK;
+  return RETURN_OK;
 }
 
 ReturnValue_t MgmLIS3MDLHandler::scanForReply(const uint8_t *start, size_t len,
@@ -234,7 +234,7 @@ ReturnValue_t MgmLIS3MDLHandler::scanForReply(const uint8_t *start, size_t len,
 
   /* Data with SPI Interface always has this answer */
   if (start[0] == 0b11111111) {
-    return returnvalue::OK;
+    return RETURN_OK;
   } else {
     return DeviceHandlerIF::INVALID_DATA;
   }
@@ -285,23 +285,27 @@ ReturnValue_t MgmLIS3MDLHandler::interpretDeviceReply(DeviceCommandId_t id, cons
       }
 
       PoolReadGuard readHelper(&dataset);
-      if (readHelper.getReadResult() == returnvalue::OK) {
+      if (readHelper.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
-        if (std::abs(mgmX) > absLimitX or std::abs(mgmY) > absLimitY or
-            std::abs(mgmZ) > absLimitZ) {
-          dataset.fieldStrengths.setValid(false);
-        }
         if (std::abs(mgmX) < absLimitX) {
-          dataset.fieldStrengths[0] = mgmX;
+          dataset.fieldStrengthX = mgmX;
+          dataset.fieldStrengthX.setValid(true);
+        } else {
+          dataset.fieldStrengthX.setValid(false);
         }
 
         if (std::abs(mgmY) < absLimitY) {
-          dataset.fieldStrengths[1] = mgmY;
+          dataset.fieldStrengthY = mgmY;
+          dataset.fieldStrengthY.setValid(true);
+        } else {
+          dataset.fieldStrengthY.setValid(false);
         }
 
         if (std::abs(mgmZ) < absLimitZ) {
-          dataset.fieldStrengths[2] = mgmZ;
+          dataset.fieldStrengthZ = mgmZ;
+          dataset.fieldStrengthZ.setValid(true);
+        } else {
+          dataset.fieldStrengthZ.setValid(false);
         }
-        dataset.fieldStrengths.setValid(true);
       }
       break;
     }
@@ -320,7 +324,7 @@ ReturnValue_t MgmLIS3MDLHandler::interpretDeviceReply(DeviceCommandId_t id, cons
       }
 
       ReturnValue_t result = dataset.read();
-      if (result == returnvalue::OK) {
+      if (result == HasReturnvaluesIF::RETURN_OK) {
         dataset.temperature = tempValue;
         dataset.commit();
       }
@@ -331,7 +335,7 @@ ReturnValue_t MgmLIS3MDLHandler::interpretDeviceReply(DeviceCommandId_t id, cons
       return DeviceHandlerIF::UNKNOWN_DEVICE_REPLY;
     }
   }
-  return returnvalue::OK;
+  return RETURN_OK;
 }
 
 MGMLIS3MDL::Sensitivies MgmLIS3MDLHandler::getSensitivity(uint8_t ctrlRegister2) {
@@ -397,7 +401,7 @@ ReturnValue_t MgmLIS3MDLHandler::enableTemperatureSensor(const uint8_t *commandD
   rawPacket = commandBuffer;
   rawPacketLen = size;
 
-  return returnvalue::OK;
+  return RETURN_OK;
 }
 
 ReturnValue_t MgmLIS3MDLHandler::setOperatingMode(const uint8_t *commandData,
@@ -454,7 +458,7 @@ ReturnValue_t MgmLIS3MDLHandler::prepareCtrlRegisterWrite() {
   rawPacketLen = MGMLIS3MDL::NR_OF_CTRL_REGISTERS + 1;
 
   // We dont have to check if this is working because we just did i
-  return returnvalue::OK;
+  return RETURN_OK;
 }
 
 void MgmLIS3MDLHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
@@ -467,10 +471,11 @@ void MgmLIS3MDLHandler::modeChanged(void) { internalState = InternalState::STATE
 
 ReturnValue_t MgmLIS3MDLHandler::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                          LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(MGMLIS3MDL::FIELD_STRENGTHS, &mgmXYZ);
+  localDataPoolMap.emplace(MGMLIS3MDL::FIELD_STRENGTH_X, new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(MGMLIS3MDL::TEMPERATURE_CELCIUS, &temperature);
+  localDataPoolMap.emplace(MGMLIS3MDL::FIELD_STRENGTH_Y, new PoolEntry<float>({0.0}));
-  poolManager.subscribeForRegularPeriodicPacket({dataset.getSid(), false, 10.0});
+  localDataPoolMap.emplace(MGMLIS3MDL::FIELD_STRENGTH_Z, new PoolEntry<float>({0.0}));
-  return returnvalue::OK;
+  localDataPoolMap.emplace(MGMLIS3MDL::TEMPERATURE_CELCIUS, new PoolEntry<float>({0.0}));
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 void MgmLIS3MDLHandler::setAbsoluteLimits(float xLimit, float yLimit, float zLimit) {

hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h

@@ -103,8 +103,6 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase {
   CommunicationStep communicationStep = CommunicationStep::DATA;
   bool commandExecuted = false;
 
-  PoolEntry<float> mgmXYZ = PoolEntry<float>(3);
-  PoolEntry<float> temperature = PoolEntry<float>();
   /*------------------------------------------------------------------------*/
   /* Device specific commands and variables */
   /*------------------------------------------------------------------------*/

hal/src/fsfw_hal/devicehandlers/MgmRM3100Handler.cpp

@@ -4,7 +4,7 @@
 #include "fsfw/devicehandlers/DeviceHandlerMessage.h"
 #include "fsfw/globalfunctions/bitutility.h"
 #include "fsfw/objectmanager/SystemObjectIF.h"
-#include "fsfw/returnvalues/returnvalue.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
 
 MgmRM3100Handler::MgmRM3100Handler(object_id_t objectId, object_id_t deviceCommunication,
                                    CookieIF *comCookie, uint32_t transitionDelay)
@@ -93,7 +93,7 @@ ReturnValue_t MgmRM3100Handler::buildTransitionDeviceCommand(DeviceCommandId_t *
           "Unknown internal state\n");
 #endif
 #endif
-      return returnvalue::OK;
+      return HasReturnvaluesIF::RETURN_OK;
   }
 
   return buildCommandFromCommand(*id, commandBuffer, commandLen);
@@ -146,7 +146,7 @@ ReturnValue_t MgmRM3100Handler::buildCommandFromCommand(DeviceCommandId_t device
     default:
       return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
   }
-  return returnvalue::OK;
+  return RETURN_OK;
 }
 
 ReturnValue_t MgmRM3100Handler::buildNormalDeviceCommand(DeviceCommandId_t *id) {
@@ -159,11 +159,11 @@ ReturnValue_t MgmRM3100Handler::scanForReply(const uint8_t *start, size_t len,
   // For SPI, ID will always be the one of the last sent command
   *foundId = this->getPendingCommand();
   *foundLen = len;
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t MgmRM3100Handler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
-  ReturnValue_t result = returnvalue::OK;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
   switch (id) {
     case (RM3100::CONFIGURE_CMM):
     case (RM3100::CONFIGURE_CYCLE_COUNT):
@@ -250,7 +250,7 @@ ReturnValue_t MgmRM3100Handler::handleCycleCountConfigCommand(DeviceCommandId_t
   std::memcpy(commandBuffer + 5, &cycleCountRegValueZ, 2);
   rawPacketLen = 7;
   rawPacket = commandBuffer;
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t MgmRM3100Handler::handleCycleCommand(bool oneCycleValue, const uint8_t *commandData,
@@ -258,7 +258,7 @@ ReturnValue_t MgmRM3100Handler::handleCycleCommand(bool oneCycleValue, const uin
   RM3100::CycleCountCommand command(oneCycleValue);
   ReturnValue_t result =
       command.deSerialize(&commandData, &commandDataLen, SerializeIF::Endianness::BIG);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
 
@@ -274,7 +274,7 @@ ReturnValue_t MgmRM3100Handler::handleCycleCommand(bool oneCycleValue, const uin
   cycleCountRegValueX = command.cycleCountX;
   cycleCountRegValueY = command.cycleCountY;
   cycleCountRegValueZ = command.cycleCountZ;
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t MgmRM3100Handler::handleTmrcConfigCommand(DeviceCommandId_t deviceCommand,
@@ -289,7 +289,7 @@ ReturnValue_t MgmRM3100Handler::handleTmrcConfigCommand(DeviceCommandId_t device
   tmrcRegValue = commandData[0];
   rawPacketLen = 2;
   rawPacket = commandBuffer;
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 void MgmRM3100Handler::fillCommandAndReplyMap() {
@@ -305,13 +305,14 @@ void MgmRM3100Handler::fillCommandAndReplyMap() {
   insertInCommandAndReplyMap(RM3100::READ_DATA, 3, &primaryDataset);
 }
 
-void MgmRM3100Handler::modeChanged() { internalState = InternalState::NONE; }
+void MgmRM3100Handler::modeChanged(void) { internalState = InternalState::NONE; }
 
 ReturnValue_t MgmRM3100Handler::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                         LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(RM3100::FIELD_STRENGTHS, &mgmXYZ);
+  localDataPoolMap.emplace(RM3100::FIELD_STRENGTH_X, new PoolEntry<float>({0.0}));
-  poolManager.subscribeForRegularPeriodicPacket({primaryDataset.getSid(), false, 10.0});
+  localDataPoolMap.emplace(RM3100::FIELD_STRENGTH_Y, new PoolEntry<float>({0.0}));
-  return returnvalue::OK;
+  localDataPoolMap.emplace(RM3100::FIELD_STRENGTH_Z, new PoolEntry<float>({0.0}));
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 uint32_t MgmRM3100Handler::getTransitionDelayMs(Mode_t from, Mode_t to) {
@@ -352,13 +353,13 @@ ReturnValue_t MgmRM3100Handler::handleDataReadout(const uint8_t *packet) {
 
   // TODO: Sanity check on values?
   PoolReadGuard readGuard(&primaryDataset);
-  if (readGuard.getReadResult() == returnvalue::OK) {
+  if (readGuard.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
-    primaryDataset.fieldStrengths[0] = fieldStrengthX;
+    primaryDataset.fieldStrengthX = fieldStrengthX;
-    primaryDataset.fieldStrengths[1] = fieldStrengthY;
+    primaryDataset.fieldStrengthY = fieldStrengthY;
-    primaryDataset.fieldStrengths[2] = fieldStrengthZ;
+    primaryDataset.fieldStrengthZ = fieldStrengthZ;
     primaryDataset.setValidity(true, true);
   }
-  return returnvalue::OK;
+  return RETURN_OK;
 }
 
 void MgmRM3100Handler::enablePeriodicPrintouts(bool enable, uint8_t divider) {

hal/src/fsfw_hal/devicehandlers/MgmRM3100Handler.h

@@ -85,7 +85,6 @@ class MgmRM3100Handler : public DeviceHandlerBase {
 
   bool goToNormalModeAtStartup = false;
   uint32_t transitionDelay;
-  PoolEntry<float> mgmXYZ = PoolEntry<float>(3);
 
   ReturnValue_t handleCycleCountConfigCommand(DeviceCommandId_t deviceCommand,
                                               const uint8_t *commandData, size_t commandDataLen);

hal/src/fsfw_hal/devicehandlers/devicedefinitions/MgmLIS3HandlerDefs.h

@@ -139,7 +139,12 @@ static const uint8_t CTRL_REG5_DEFAULT = 0;
 
 static const uint32_t MGM_DATA_SET_ID = READ_CONFIG_AND_DATA;
 
-enum MgmPoolIds : lp_id_t { FIELD_STRENGTHS, TEMPERATURE_CELCIUS };
+enum MgmPoolIds : lp_id_t {
+  FIELD_STRENGTH_X,
+  FIELD_STRENGTH_Y,
+  FIELD_STRENGTH_Z,
+  TEMPERATURE_CELCIUS
+};
 
 class MgmPrimaryDataset : public StaticLocalDataSet<4> {
  public:
@@ -147,10 +152,9 @@ class MgmPrimaryDataset : public StaticLocalDataSet<4> {
 
   MgmPrimaryDataset(object_id_t mgmId) : StaticLocalDataSet(sid_t(mgmId, MGM_DATA_SET_ID)) {}
 
-  /**
+  lp_var_t<float> fieldStrengthX = lp_var_t<float>(sid.objectId, FIELD_STRENGTH_X, this);
-   * Field strenghts in uT
+  lp_var_t<float> fieldStrengthY = lp_var_t<float>(sid.objectId, FIELD_STRENGTH_Y, this);
-   */
+  lp_var_t<float> fieldStrengthZ = lp_var_t<float>(sid.objectId, FIELD_STRENGTH_Z, this);
-  lp_vec_t<float, 3> fieldStrengths = lp_vec_t<float, 3>(sid.objectId, FIELD_STRENGTHS, this);
   lp_var_t<float> temperature = lp_var_t<float>(sid.objectId, TEMPERATURE_CELCIUS, this);
 };
 

hal/src/fsfw_hal/devicehandlers/devicedefinitions/MgmRM3100HandlerDefs.h

@@ -101,7 +101,11 @@ class CycleCountCommand : public SerialLinkedListAdapter<SerializeIF> {
 
 static constexpr uint32_t MGM_DATASET_ID = READ_DATA;
 
-enum MgmPoolIds : lp_id_t { FIELD_STRENGTHS };
+enum MgmPoolIds : lp_id_t {
+  FIELD_STRENGTH_X,
+  FIELD_STRENGTH_Y,
+  FIELD_STRENGTH_Z,
+};
 
 class Rm3100PrimaryDataset : public StaticLocalDataSet<3> {
  public:
@@ -109,10 +113,10 @@ class Rm3100PrimaryDataset : public StaticLocalDataSet<3> {
 
   Rm3100PrimaryDataset(object_id_t mgmId) : StaticLocalDataSet(sid_t(mgmId, MGM_DATASET_ID)) {}
 
-  /**
+  // Field strengths in micro Tesla.
-   * Field strenghts in uT
+  lp_var_t<float> fieldStrengthX = lp_var_t<float>(sid.objectId, FIELD_STRENGTH_X, this);
-   */
+  lp_var_t<float> fieldStrengthY = lp_var_t<float>(sid.objectId, FIELD_STRENGTH_Y, this);
-  lp_vec_t<float, 3> fieldStrengths = lp_vec_t<float, 3>(sid.objectId, FIELD_STRENGTHS, this);
+  lp_var_t<float> fieldStrengthZ = lp_var_t<float>(sid.objectId, FIELD_STRENGTH_Z, this);
 };
 
 }  // namespace RM3100

hal/src/fsfw_hal/linux/CMakeLists.txt

@@ -0,0 +1,25 @@
+if(FSFW_HAL_ADD_RASPBERRY_PI)
+    add_subdirectory(rpi)
+endif()
+
+target_sources(${LIB_FSFW_NAME} PRIVATE
+	UnixFileGuard.cpp
+	CommandExecutor.cpp
+	utility.cpp
+)
+
+if(FSFW_HAL_LINUX_ADD_PERIPHERAL_DRIVERS)
+if(FSFW_HAL_LINUX_ADD_LIBGPIOD)
+	add_subdirectory(gpio)
+endif()
+	add_subdirectory(uart)
+	# Adding those does not really make sense on Apple systems which
+	# are generally host systems. It won't even compile as the headers
+	# are missing
+	if(NOT APPLE)
+		add_subdirectory(i2c)
+		add_subdirectory(spi)
+	endif()
+endif()
+
+add_subdirectory(uio)

hal/src/fsfw_hal/linux/CommandExecutor.cpp

@@ -23,7 +23,7 @@ ReturnValue_t CommandExecutor::load(std::string command, bool blocking, bool pri
   if (state == States::IDLE) {
     state = States::COMMAND_LOADED;
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t CommandExecutor::execute() {
@@ -32,12 +32,10 @@ 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;
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
   if (blocking) {
     ReturnValue_t result = executeBlocking();
@@ -48,7 +46,7 @@ ReturnValue_t CommandExecutor::execute() {
     waiter.fd = currentFd;
   }
   state = States::PENDING;
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t CommandExecutor::close() {
@@ -58,7 +56,7 @@ ReturnValue_t CommandExecutor::close() {
       pclose(currentCmdFile);
     }
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 void CommandExecutor::printLastError(std::string funcName) const {
@@ -81,7 +79,7 @@ void CommandExecutor::setRingBuffer(SimpleRingBuffer* ringBuffer,
 
 ReturnValue_t CommandExecutor::check(bool& replyReceived) {
   if (blocking) {
-    return returnvalue::OK;
+    return HasReturnvaluesIF::RETURN_OK;
   }
   switch (state) {
     case (States::IDLE):
@@ -96,7 +94,7 @@ ReturnValue_t CommandExecutor::check(bool& replyReceived) {
   int result = poll(&waiter, 1, 0);
   switch (result) {
     case (0): {
-      return returnvalue::OK;
+      return HasReturnvaluesIF::RETURN_OK;
       break;
     }
     case (1): {
@@ -153,7 +151,7 @@ ReturnValue_t CommandExecutor::check(bool& replyReceived) {
         ReturnValue_t retval = EXECUTION_FINISHED;
         if (result != 0) {
           lastError = result;
-          retval = returnvalue::FAILED;
+          retval = HasReturnvaluesIF::RETURN_FAILED;
         }
         state = States::IDLE;
         currentCmdFile = nullptr;
@@ -163,7 +161,7 @@ ReturnValue_t CommandExecutor::check(bool& replyReceived) {
       break;
     }
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 void CommandExecutor::reset() {
@@ -203,9 +201,7 @@ ReturnValue_t CommandExecutor::executeBlocking() {
   int result = pclose(currentCmdFile);
   if (result != 0) {
     lastError = result;
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
-
-const std::vector<char>& CommandExecutor::getReadVector() const { return readVec; }

hal/src/fsfw_hal/linux/CommandExecutor.h

@@ -7,7 +7,7 @@
 #include <vector>
 
 #include "fsfw/returnvalues/FwClassIds.h"
-#include "fsfw/returnvalues/returnvalue.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
 
 class SimpleRingBuffer;
 template <typename T>
@@ -31,25 +31,27 @@ class CommandExecutor {
   static constexpr uint8_t CLASS_ID = CLASS_ID::LINUX_OSAL;
 
   //! [EXPORT] : [COMMENT] Execution of the current command has finished
-  static constexpr ReturnValue_t EXECUTION_FINISHED = returnvalue::makeCode(CLASS_ID, 0);
+  static constexpr ReturnValue_t EXECUTION_FINISHED =
+      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 0);
 
   //! [EXPORT] : [COMMENT] Command is pending. This will also be returned if the user tries
   //! to load another command but a command is still pending
-  static constexpr ReturnValue_t COMMAND_PENDING = returnvalue::makeCode(CLASS_ID, 1);
+  static constexpr ReturnValue_t COMMAND_PENDING = HasReturnvaluesIF::makeReturnCode(CLASS_ID, 1);
   //! [EXPORT] : [COMMENT] Some bytes have been read from the executing process
-  static constexpr ReturnValue_t BYTES_READ = returnvalue::makeCode(CLASS_ID, 2);
+  static constexpr ReturnValue_t BYTES_READ = HasReturnvaluesIF::makeReturnCode(CLASS_ID, 2);
   //! [EXPORT] : [COMMENT] Command execution failed
-  static constexpr ReturnValue_t COMMAND_ERROR = returnvalue::makeCode(CLASS_ID, 3);
+  static constexpr ReturnValue_t COMMAND_ERROR = HasReturnvaluesIF::makeReturnCode(CLASS_ID, 3);
   //! [EXPORT] : [COMMENT]
-  static constexpr ReturnValue_t NO_COMMAND_LOADED_OR_PENDING = returnvalue::makeCode(CLASS_ID, 4);
+  static constexpr ReturnValue_t NO_COMMAND_LOADED_OR_PENDING =
-  static constexpr ReturnValue_t PCLOSE_CALL_ERROR = returnvalue::makeCode(CLASS_ID, 6);
+      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 4);
+  static constexpr ReturnValue_t PCLOSE_CALL_ERROR = HasReturnvaluesIF::makeReturnCode(CLASS_ID, 6);
 
   /**
    * Constructor. Is initialized with maximum size of internal buffer to read data from the
    * executed process.
    * @param maxSize
    */
-  explicit CommandExecutor(size_t maxSize);
+  CommandExecutor(const size_t maxSize);
 
   /**
    * Load a new command which should be executed
@@ -62,11 +64,11 @@ class CommandExecutor {
   /**
    * Execute the loaded command.
    * @return
-   *  - In blocking mode, it will return returnvalue::FAILED if
+   *  - In blocking mode, it will return RETURN_FAILED if
    *    the result of the system call was not 0. The error value can be accessed using
    *    getLastError
    *  - In non-blocking mode, this call will start
-   *    the execution and then return returnvalue::OK
+   *    the execution and then return RETURN_OK
    */
   ReturnValue_t execute();
   /**
@@ -75,8 +77,8 @@ class CommandExecutor {
    * @return
    *  - BYTES_READ if bytes have been read from the executing process. It is recommended to call
    *    check again after this
-   *  - returnvalue::OK execution is pending, but no bytes have been read from the executing process
+   *  - RETURN_OK execution is pending, but no bytes have been read from the executing process
-   *  - returnvalue::FAILED if execution has failed, error value can be accessed using getLastError
+   *  - RETURN_FAILED if execution has failed, error value can be accessed using getLastError
    *  - EXECUTION_FINISHED if the process was executed successfully
    *  - NO_COMMAND_LOADED_OR_PENDING self-explanatory
    *  - COMMAND_ERROR internal poll error
@@ -85,7 +87,7 @@ class CommandExecutor {
   /**
    * Abort the current command. Should normally not be necessary, check can be used to find
    * out whether command execution was successful
-   * @return returnvalue::OK
+   * @return RETURN_OK
    */
   ReturnValue_t close();
 
@@ -107,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/UnixFileGuard.h

@@ -2,7 +2,7 @@
 #define LINUX_UTILITY_UNIXFILEGUARD_H_
 
 #include <fcntl.h>
-#include <fsfw/returnvalues/returnvalue.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
 #include <unistd.h>
 
 #include <string>
@@ -24,7 +24,7 @@ class UnixFileGuard {
 
  private:
   int* fileDescriptor = nullptr;
-  ReturnValue_t openStatus = returnvalue::OK;
+  ReturnValue_t openStatus = HasReturnvaluesIF::RETURN_OK;
 };
 
 #endif /* LINUX_UTILITY_UNIXFILEGUARD_H_ */

hal/src/fsfw_hal/linux/gpio/CMakeLists.txt

@@ -0,0 +1,16 @@
+# This abstraction layer requires the gpiod library. You can install this library
+# with "sudo apt-get install -y libgpiod-dev". If you are cross-compiling, you need
+# to install the package before syncing the sysroot to your host computer.
+find_library(LIB_GPIO gpiod)
+
+if(${LIB_GPIO} MATCHES LIB_GPIO-NOTFOUND)
+    message(STATUS "gpiod library not found, not linking against it")
+else()
+    target_sources(${LIB_FSFW_NAME} PRIVATE
+        LinuxLibgpioIF.cpp
+    )
+    target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+        ${LIB_GPIO}
+    )
+endif()
+

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

@@ -20,33 +20,31 @@ 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;
-    return returnvalue::FAILED;
   }
 
   GpioMap mapToAdd = gpioCookie->getGpioMap();
 
   /* Check whether this ID already exists in the map and remove duplicates */
   result = checkForConflicts(mapToAdd);
-  if (result != returnvalue::OK) {
+  if (result != RETURN_OK) {
     return result;
   }
 
   result = configureGpios(mapToAdd);
-  if (result != returnvalue::OK) {
+  if (result != RETURN_OK) {
-    return returnvalue::FAILED;
+    return RETURN_FAILED;
   }
 
   /* Register new GPIOs in gpioMap */
   gpioMap.insert(mapToAdd.begin(), mapToAdd.end());
 
-  return returnvalue::OK;
+  return RETURN_OK;
 }
 
 ReturnValue_t LinuxLibgpioIF::configureGpios(GpioMap& mapToAdd) {
-  ReturnValue_t result = returnvalue::OK;
+  ReturnValue_t result = RETURN_OK;
   for (auto& gpioConfig : mapToAdd) {
     auto& gpioType = gpioConfig.second->gpioType;
     switch (gpioType) {
@@ -86,7 +84,7 @@ ReturnValue_t LinuxLibgpioIF::configureGpios(GpioMap& mapToAdd) {
                                gpioCallback->initValue, gpioCallback->callbackArgs);
       }
     }
-    if (result != returnvalue::OK) {
+    if (result != RETURN_OK) {
       return GPIO_INIT_FAILED;
     }
   }
@@ -98,11 +96,9 @@ 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;
-    return returnvalue::FAILED;
   }
   std::string failOutput = "label: " + label;
   return configureRegularGpio(gpioId, chip, gpioByLabel, failOutput);
@@ -112,11 +108,9 @@ 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;
-    return returnvalue::FAILED;
   }
   std::string failOutput = "chipname: " + chipname;
   return configureRegularGpio(gpioId, chip, gpioByChip, failOutput);
@@ -132,18 +126,16 @@ ReturnValue_t LinuxLibgpioIF::configureGpioByLineName(gpioId_t gpioId,
       gpiod_ctxless_find_line(lineName.c_str(), chipname, MAX_CHIPNAME_LENGTH, &lineOffset);
   if (result != LINE_FOUND) {
     parseFindeLineResult(result, lineName);
-    return returnvalue::FAILED;
+    return RETURN_FAILED;
   }
 
   gpioByLineName.lineNum = static_cast<int>(lineOffset);
 
   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;
-    return returnvalue::FAILED;
   }
   std::string failOutput = "line name: " + lineName;
   return configureRegularGpio(gpioId, chip, gpioByLineName, failOutput);
@@ -161,14 +153,12 @@ ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, struct gpiod
   lineNum = regularGpio.lineNum;
   lineHandle = gpiod_chip_get_line(chip, lineNum);
   if (!lineHandle) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "LinuxLibgpioIF::configureRegularGpio: Failed to open line " << std::endl;
     sif::warning << "GPIO ID: " << gpioId << ", line number: " << lineNum << ", " << failOutput
                  << std::endl;
     sif::warning << "Check if Linux GPIO configuration has changed. " << std::endl;
-#endif
     gpiod_chip_close(chip);
-    return returnvalue::FAILED;
+    return RETURN_FAILED;
   }
 
   direction = regularGpio.direction;
@@ -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;
     }
 
@@ -202,7 +190,7 @@ ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, struct gpiod
             lineNum, gpioId);
 #endif
         gpiod_line_release(lineHandle);
-        return returnvalue::FAILED;
+        return RETURN_FAILED;
       }
   }
   /**
@@ -210,15 +198,13 @@ ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, struct gpiod
    * read states of GPIOs.
    */
   regularGpio.lineHandle = lineHandle;
-  return returnvalue::OK;
+  return RETURN_OK;
 }
 
 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;
   }
 
@@ -238,7 +224,7 @@ ReturnValue_t LinuxLibgpioIF::pullHigh(gpioId_t gpioId) {
     }
     gpioCallback->callback(gpioMapIter->first, gpio::GpioOperation::WRITE, gpio::Levels::HIGH,
                            gpioCallback->callbackArgs);
-    return returnvalue::OK;
+    return RETURN_OK;
   }
   return GPIO_TYPE_FAILURE;
 }
@@ -270,7 +256,7 @@ ReturnValue_t LinuxLibgpioIF::pullLow(gpioId_t gpioId) {
     }
     gpioCallback->callback(gpioMapIter->first, gpio::GpioOperation::WRITE, gpio::Levels::LOW,
                            gpioCallback->callbackArgs);
-    return returnvalue::OK;
+    return RETURN_OK;
   }
   return GPIO_TYPE_FAILURE;
 }
@@ -291,7 +277,7 @@ ReturnValue_t LinuxLibgpioIF::driveGpio(gpioId_t gpioId, GpiodRegularBase& regul
     return DRIVE_GPIO_FAILURE;
   }
 
-  return returnvalue::OK;
+  return RETURN_OK;
 }
 
 ReturnValue_t LinuxLibgpioIF::readGpio(gpioId_t gpioId, gpio::Levels& gpioState) {
@@ -324,14 +310,14 @@ ReturnValue_t LinuxLibgpioIF::readGpio(gpioId_t gpioId, gpio::Levels& gpioState)
     }
     gpioCallback->callback(gpioMapIter->first, gpio::GpioOperation::READ, gpio::Levels::NONE,
                            gpioCallback->callbackArgs);
-    return returnvalue::OK;
+    return RETURN_OK;
   }
-  return returnvalue::OK;
+  return RETURN_OK;
 }
 
 ReturnValue_t LinuxLibgpioIF::checkForConflicts(GpioMap& mapToAdd) {
-  ReturnValue_t status = returnvalue::OK;
+  ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
-  ReturnValue_t result = returnvalue::OK;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
   for (auto& gpioConfig : mapToAdd) {
     switch (gpioConfig.second->gpioType) {
       case (gpio::GpioTypes::GPIO_REGULAR_BY_CHIP):
@@ -343,7 +329,7 @@ ReturnValue_t LinuxLibgpioIF::checkForConflicts(GpioMap& mapToAdd) {
         }
         // Check for conflicts and remove duplicates if necessary
         result = checkForConflictsById(gpioConfig.first, gpioConfig.second->gpioType, mapToAdd);
-        if (result != returnvalue::OK) {
+        if (result != HasReturnvaluesIF::RETURN_OK) {
           status = result;
         }
         break;
@@ -355,7 +341,7 @@ ReturnValue_t LinuxLibgpioIF::checkForConflicts(GpioMap& mapToAdd) {
         }
         // Check for conflicts and remove duplicates if necessary
         result = checkForConflictsById(gpioConfig.first, gpioConfig.second->gpioType, mapToAdd);
-        if (result != returnvalue::OK) {
+        if (result != HasReturnvaluesIF::RETURN_OK) {
           status = result;
         }
         break;
@@ -429,7 +415,7 @@ ReturnValue_t LinuxLibgpioIF::checkForConflictsById(gpioId_t gpioIdToCheck,
     mapToAdd.erase(gpioIdToCheck);
     return GPIO_DUPLICATE_DETECTED;
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 void LinuxLibgpioIF::parseFindeLineResult(int result, std::string& lineName) {

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

@@ -19,15 +19,21 @@ class LinuxLibgpioIF : public GpioIF, public SystemObject {
  public:
   static const uint8_t gpioRetvalId = CLASS_ID::HAL_GPIO;
 
-  static constexpr ReturnValue_t UNKNOWN_GPIO_ID = returnvalue::makeCode(gpioRetvalId, 1);
+  static constexpr ReturnValue_t UNKNOWN_GPIO_ID =
-  static constexpr ReturnValue_t DRIVE_GPIO_FAILURE = returnvalue::makeCode(gpioRetvalId, 2);
+      HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 1);
-  static constexpr ReturnValue_t GPIO_TYPE_FAILURE = returnvalue::makeCode(gpioRetvalId, 3);
+  static constexpr ReturnValue_t DRIVE_GPIO_FAILURE =
-  static constexpr ReturnValue_t GPIO_INVALID_INSTANCE = returnvalue::makeCode(gpioRetvalId, 4);
+      HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 2);
-  static constexpr ReturnValue_t GPIO_DUPLICATE_DETECTED = returnvalue::makeCode(gpioRetvalId, 5);
+  static constexpr ReturnValue_t GPIO_TYPE_FAILURE =
-  static constexpr ReturnValue_t GPIO_INIT_FAILED = returnvalue::makeCode(gpioRetvalId, 6);
+      HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 3);
+  static constexpr ReturnValue_t GPIO_INVALID_INSTANCE =
+      HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 4);
+  static constexpr ReturnValue_t GPIO_DUPLICATE_DETECTED =
+      HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 5);
+  static constexpr ReturnValue_t GPIO_INIT_FAILED =
+      HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 6);
   // Will be returned if getting the line value failed. Error type will be set to errno in this case
-  static constexpr ReturnValue_t GPIO_GET_VALUE_FAILED = returnvalue::makeCode(gpioRetvalId, 7);
+  static constexpr ReturnValue_t GPIO_GET_VALUE_FAILED =
-
+      HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 7);
   LinuxLibgpioIF(object_id_t objectId);
   virtual ~LinuxLibgpioIF();
 
@@ -67,7 +73,7 @@ class LinuxLibgpioIF : public GpioIF, public SystemObject {
    *
    * @param mapToAdd	The GPIOs which shall be added to the gpioMap.
    *
-   * @return	returnvalue::OK if successful, otherwise returnvalue::FAILED
+   * @return	RETURN_OK if successful, otherwise RETURN_FAILED
    */
   ReturnValue_t checkForConflicts(GpioMap& mapToAdd);
 

hal/src/fsfw_hal/linux/i2c/CMakeLists.txt

@@ -0,0 +1,8 @@
+target_sources(${LIB_FSFW_NAME} PUBLIC
+    I2cComIF.cpp
+    I2cCookie.cpp
+)
+
+
+
+

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

@@ -52,16 +52,16 @@ ReturnValue_t I2cComIF::initializeInterface(CookieIF* cookie) {
                  << i2cAddress << "to I2C device "
                  << "map" << std::endl;
 #endif
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
-    return returnvalue::OK;
+    return HasReturnvaluesIF::RETURN_OK;
   }
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
   sif::error << "I2cComIF::initializeInterface: Device with address " << i2cAddress
              << "already in use" << std::endl;
 #endif
-  return returnvalue::FAILED;
+  return HasReturnvaluesIF::RETURN_FAILED;
 }
 
 ReturnValue_t I2cComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData, size_t sendLen) {
@@ -73,11 +73,11 @@ ReturnValue_t I2cComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData, s
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "I2cComIF::sendMessage: Send Data is nullptr" << std::endl;
 #endif
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
 
   if (sendLen == 0) {
-    return returnvalue::OK;
+    return HasReturnvaluesIF::RETURN_OK;
   }
 
   I2cCookie* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
@@ -95,16 +95,16 @@ ReturnValue_t I2cComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData, s
     sif::error << "I2cComIF::sendMessage: i2cAddress of Cookie not "
                << "registered in i2cDeviceMap" << std::endl;
 #endif
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
 
   deviceFile = i2cCookie->getDeviceFile();
   UnixFileGuard fileHelper(deviceFile, &fd, O_RDWR, "I2cComIF::sendMessage");
-  if (fileHelper.getOpenResult() != returnvalue::OK) {
+  if (fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
     return fileHelper.getOpenResult();
   }
   result = openDevice(deviceFile, i2cAddress, &fd);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
 
@@ -114,17 +114,17 @@ ReturnValue_t I2cComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData, s
                   "device with error code "
                << errno << ". Error description: " << strerror(errno) << std::endl;
 #endif
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
 
 #if FSFW_HAL_I2C_WIRETAPPING == 1
   sif::info << "Sent I2C data to bus " << deviceFile << ":" << std::endl;
   arrayprinter::print(sendData, sendLen);
 #endif
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t I2cComIF::getSendSuccess(CookieIF* cookie) { return returnvalue::OK; }
+ReturnValue_t I2cComIF::getSendSuccess(CookieIF* cookie) { return HasReturnvaluesIF::RETURN_OK; }
 
 ReturnValue_t I2cComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLen) {
   ReturnValue_t result;
@@ -132,7 +132,7 @@ ReturnValue_t I2cComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLe
   std::string deviceFile;
 
   if (requestLen == 0) {
-    return returnvalue::OK;
+    return HasReturnvaluesIF::RETURN_OK;
   }
 
   I2cCookie* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
@@ -152,16 +152,16 @@ ReturnValue_t I2cComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLe
                << "registered in i2cDeviceMap" << std::endl;
 #endif
     i2cDeviceMapIter->second.replyLen = 0;
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
 
   deviceFile = i2cCookie->getDeviceFile();
   UnixFileGuard fileHelper(deviceFile, &fd, O_RDWR, "I2cComIF::requestReceiveMessage");
-  if (fileHelper.getOpenResult() != returnvalue::OK) {
+  if (fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
     return fileHelper.getOpenResult();
   }
   result = openDevice(deviceFile, i2cAddress, &fd);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     i2cDeviceMapIter->second.replyLen = 0;
     return result;
   }
@@ -184,7 +184,7 @@ ReturnValue_t I2cComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLe
 #endif
 #endif
     i2cDeviceMapIter->second.replyLen = 0;
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
 
 #if FSFW_HAL_I2C_WIRETAPPING == 1
@@ -193,7 +193,7 @@ ReturnValue_t I2cComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLe
 #endif
 
   i2cDeviceMapIter->second.replyLen = requestLen;
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t I2cComIF::readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) {
@@ -212,12 +212,12 @@ ReturnValue_t I2cComIF::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
     sif::error << "I2cComIF::readReceivedMessage: i2cAddress of Cookie not "
                << "found in i2cDeviceMap" << std::endl;
 #endif
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
   *buffer = i2cDeviceMapIter->second.replyBuffer.data();
   *size = i2cDeviceMapIter->second.replyLen;
 
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t I2cComIF::openDevice(std::string deviceFile, address_t i2cAddress,
@@ -233,7 +233,7 @@ ReturnValue_t I2cComIF::openDevice(std::string deviceFile, address_t i2cAddress,
     sif::printWarning("Error description: %s\n", strerror(errno));
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }

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

@@ -49,7 +49,7 @@ class I2cComIF : public DeviceCommunicationIF, public SystemObject {
    * @param deviceFile	The name of the device file. E.g. i2c-0
    * @param i2cAddress	The address of the i2c slave device.
    * @param fileDescriptor	Pointer to device descriptor.
-   * @return	returnvalue::OK if successful, otherwise returnvalue::FAILED.
+   * @return	RETURN_OK if successful, otherwise RETURN_FAILED.
    */
   ReturnValue_t openDevice(std::string deviceFile, address_t i2cAddress, int *fileDescriptor);
 };

hal/src/fsfw_hal/linux/rpi/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE
+    GpioRPi.cpp
+)

hal/src/fsfw_hal/linux/rpi/GpioRPi.cpp

@@ -9,7 +9,7 @@ ReturnValue_t gpio::createRpiGpioConfig(GpioCookie* cookie, gpioId_t gpioId, int
                                         std::string consumer, gpio::Direction direction,
                                         gpio::Levels initValue) {
   if (cookie == nullptr) {
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
 
   auto config = new GpiodRegularByChip();
@@ -30,9 +30,9 @@ ReturnValue_t gpio::createRpiGpioConfig(GpioCookie* cookie, gpioId_t gpioId, int
     sif::printError("createRpiGpioConfig: BCM pin %d invalid!\n", bcmPin);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
   config->lineNum = bcmPin;
   cookie->addGpio(gpioId, config);
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }

hal/src/fsfw_hal/linux/rpi/GpioRPi.h

@@ -1,7 +1,7 @@
 #ifndef BSP_RPI_GPIO_GPIORPI_H_
 #define BSP_RPI_GPIO_GPIORPI_H_
 
-#include <fsfw/returnvalues/returnvalue.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
 #include "../../common/gpio/gpioDefinitions.h"
 

hal/src/fsfw_hal/linux/spi/CMakeLists.txt

@@ -0,0 +1,8 @@
+target_sources(${LIB_FSFW_NAME} PUBLIC
+    SpiComIF.cpp
+    SpiCookie.cpp
+)
+
+
+
+

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

@@ -56,7 +56,7 @@ ReturnValue_t SpiComIF::initializeInterface(CookieIF* cookie) {
           static_cast<unsigned long>(spiAddress));
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
     /* Now we emplaced the read buffer in the map, we still need to assign that location
     to the SPI driver transfer struct */
@@ -69,7 +69,7 @@ ReturnValue_t SpiComIF::initializeInterface(CookieIF* cookie) {
     sif::printError("SpiComIF::initializeInterface: SPI address already exists!\n");
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
 
   /* Pull CS high in any case to be sure that device is inactive */
@@ -86,7 +86,7 @@ ReturnValue_t SpiComIF::initializeInterface(CookieIF* cookie) {
 
   int fileDescriptor = 0;
   UnixFileGuard fileHelper(dev, &fileDescriptor, O_RDWR, "SpiComIF::initializeInterface");
-  if (fileHelper.getOpenResult() != returnvalue::OK) {
+  if (fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
     return fileHelper.getOpenResult();
   }
 
@@ -128,12 +128,12 @@ ReturnValue_t SpiComIF::initializeInterface(CookieIF* cookie) {
           "Could not write bits per word!");
     }
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t SpiComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData, size_t sendLen) {
   SpiCookie* spiCookie = dynamic_cast<SpiCookie*>(cookie);
-  ReturnValue_t result = returnvalue::OK;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 
   if (spiCookie == nullptr) {
     return NULLPOINTER;
@@ -177,12 +177,12 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
     spiCookie->assignReadBuffer(iter->second.replyBuffer.data());
   }
 
-  ReturnValue_t result = returnvalue::OK;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
   int retval = 0;
   /* Prepare transfer */
   int fileDescriptor = 0;
   UnixFileGuard fileHelper(dev, &fileDescriptor, O_RDWR, "SpiComIF::sendMessage");
-  if (fileHelper.getOpenResult() != returnvalue::OK) {
+  if (fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
     return OPENING_FILE_FAILED;
   }
   spi::SpiModes spiMode = spi::SpiModes::MODE_0;
@@ -194,29 +194,23 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
 
   bool fullDuplex = spiCookie->isFullDuplex();
   gpioId_t gpioId = spiCookie->getChipSelectPin();
-  bool csLockManual = spiCookie->getCsLockManual();
 
-  MutexIF::TimeoutType csType;
+  /* Pull SPI CS low. For now, no support for active high given  */
-  dur_millis_t csTimeout = 0;
+  if (gpioId != gpio::NO_GPIO) {
-  // Pull SPI CS low. For now, no support for active high given
+    result = csMutex->lockMutex(timeoutType, timeoutMs);
-  if (gpioId != gpio::NO_GPIO and not csLockManual) {
+    if (result != RETURN_OK) {
-    spiCookie->getMutexParams(csType, csTimeout);
-    result = csMutex->lockMutex(csType, csTimeout);
-    if (result != returnvalue::OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::error << "SpiComIF::sendMessage: Failed to lock mutex with code "
+      sif::error << "SpiComIF::sendMessage: Failed to lock mutex" << std::endl;
-                 << "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);
+      sif::printError("SpiComIF::sendMessage: Failed to lock mutex\n");
 #endif
 #endif
       return result;
     }
     updateLinePolarity(fileDescriptor);
-    result = gpioComIF->pullLow(gpioId);
+    ReturnValue_t result = gpioComIF->pullLow(gpioId);
-    if (result != returnvalue::OK) {
+    if (result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::warning << "SpiComIF::sendMessage: Pulling low CS pin failed" << std::endl;
@@ -255,10 +249,10 @@ 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 != returnvalue::OK) {
+    if (result != RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::error << "SpiComIF::sendMessage: Failed to unlock mutex" << std::endl;
 #endif
@@ -268,7 +262,7 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
   return result;
 }
 
-ReturnValue_t SpiComIF::getSendSuccess(CookieIF* cookie) { return returnvalue::OK; }
+ReturnValue_t SpiComIF::getSendSuccess(CookieIF* cookie) { return HasReturnvaluesIF::RETURN_OK; }
 
 ReturnValue_t SpiComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLen) {
   SpiCookie* spiCookie = dynamic_cast<SpiCookie*>(cookie);
@@ -277,43 +271,33 @@ ReturnValue_t SpiComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLe
   }
 
   if (spiCookie->isFullDuplex()) {
-    return returnvalue::OK;
+    return HasReturnvaluesIF::RETURN_OK;
   }
 
   return performHalfDuplexReception(spiCookie);
 }
 
 ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
-  ReturnValue_t result = returnvalue::OK;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
   int fileDescriptor = 0;
   UnixFileGuard fileHelper(dev, &fileDescriptor, O_RDWR, "SpiComIF::requestReceiveMessage");
-  if (fileHelper.getOpenResult() != returnvalue::OK) {
+  if (fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
     return OPENING_FILE_FAILED;
   }
 
   uint8_t* rxBuf = nullptr;
   size_t readSize = spiCookie->getCurrentTransferSize();
   result = getReadBuffer(spiCookie->getSpiAddress(), &rxBuf);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
 
-  bool csLockManual = spiCookie->getCsLockManual();
   gpioId_t gpioId = spiCookie->getChipSelectPin();
-  MutexIF::TimeoutType csType;
+  if (gpioId != gpio::NO_GPIO) {
-  dur_millis_t csTimeout = 0;
+    result = csMutex->lockMutex(timeoutType, timeoutMs);
-  if (gpioId != gpio::NO_GPIO and not csLockManual) {
+    if (result != RETURN_OK) {
-    spiCookie->getMutexParams(csType, csTimeout);
-    result = csMutex->lockMutex(csType, csTimeout);
-    if (result != returnvalue::OK) {
-#if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::error << "SpiComIF::sendMessage: Failed to lock mutex with code "
+      sif::error << "SpiComIF::getSendSuccess: Failed to lock mutex" << std::endl;
-                 << "0x" << std::hex << std::setfill('0') << std::setw(4) << result << std::dec
-                 << std::endl;
-#else
-      sif::printError("SpiComIF::sendMessage: Failed to lock mutex with code %d\n", result);
-#endif
 #endif
       return result;
     }
@@ -331,10 +315,10 @@ 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 != returnvalue::OK) {
+    if (result != RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::error << "SpiComIF::getSendSuccess: Failed to unlock mutex" << std::endl;
 #endif
@@ -348,21 +332,29 @@ ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
 ReturnValue_t SpiComIF::readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) {
   SpiCookie* spiCookie = dynamic_cast<SpiCookie*>(cookie);
   if (spiCookie == nullptr) {
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
   uint8_t* rxBuf = nullptr;
   ReturnValue_t result = getReadBuffer(spiCookie->getSpiAddress(), &rxBuf);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
 
   *buffer = rxBuf;
   *size = spiCookie->getCurrentTransferSize();
   spiCookie->setTransferSize(0);
-  return returnvalue::OK;
+  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) {
@@ -385,16 +377,16 @@ void SpiComIF::performSpiWiretapping(SpiCookie* spiCookie) {
 
 ReturnValue_t SpiComIF::getReadBuffer(address_t spiAddress, uint8_t** buffer) {
   if (buffer == nullptr) {
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
 
   auto iter = spiDeviceMap.find(spiAddress);
   if (iter == spiDeviceMap.end()) {
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
 
   *buffer = iter->second.replyBuffer.data();
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 GpioIF* SpiComIF::getGpioInterface() { return gpioComIF; }
@@ -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

@@ -23,13 +23,14 @@ class SpiCookie;
 class SpiComIF : public DeviceCommunicationIF, public SystemObject {
  public:
   static constexpr uint8_t spiRetvalId = CLASS_ID::HAL_SPI;
-  static constexpr ReturnValue_t OPENING_FILE_FAILED = returnvalue::makeCode(spiRetvalId, 0);
+  static constexpr ReturnValue_t OPENING_FILE_FAILED =
+      HasReturnvaluesIF::makeReturnCode(spiRetvalId, 0);
   /* Full duplex (ioctl) transfer failure */
   static constexpr ReturnValue_t FULL_DUPLEX_TRANSFER_FAILED =
-      returnvalue::makeCode(spiRetvalId, 1);
+      HasReturnvaluesIF::makeReturnCode(spiRetvalId, 1);
   /* Half duplex (read/write) transfer failure */
   static constexpr ReturnValue_t HALF_DUPLEX_TRANSFER_FAILED =
-      returnvalue::makeCode(spiRetvalId, 2);
+      HasReturnvaluesIF::makeReturnCode(spiRetvalId, 2);
 
   SpiComIF(object_id_t objectId, std::string devname, GpioIF* gpioComIF);
 
@@ -43,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();
+  MutexIF* getMutex(MutexIF::TimeoutType* timeoutType = nullptr, uint32_t* timeoutMs = nullptr);
-  void setMutexParams(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs);
 
   /**
    * Perform a regular send operation using Linux iotcl. This is public so it can be used
@@ -59,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
@@ -71,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);
@@ -90,8 +90,8 @@ class SpiComIF : public DeviceCommunicationIF, public SystemObject {
    * pulled high
    */
   MutexIF* csMutex = nullptr;
-  // MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+  MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
-  // uint32_t timeoutMs = DEFAULT_MUTEX_TIMEOUT;
+  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_ */

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

@@ -7,7 +7,7 @@
 
 #include "../../common/gpio/gpioDefinitions.h"
 #include "../../common/spi/spiCommon.h"
-#include "fsfw/returnvalues/returnvalue.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
 
 class SpiCookie;
 class SpiComIF;

hal/src/fsfw_hal/linux/uart/CMakeLists.txt

@@ -0,0 +1,4 @@
+target_sources(${LIB_FSFW_NAME} PUBLIC
+	UartComIF.cpp
+	UartCookie.cpp
+)

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

@@ -37,7 +37,7 @@ ReturnValue_t UartComIF::initializeInterface(CookieIF* cookie) {
   if (uartDeviceMapIter == uartDeviceMap.end()) {
     int fileDescriptor = configureUartPort(uartCookie);
     if (fileDescriptor < 0) {
-      return returnvalue::FAILED;
+      return RETURN_FAILED;
     }
     size_t maxReplyLen = uartCookie->getMaxReplyLen();
     UartElements uartElements = {fileDescriptor, std::vector<uint8_t>(maxReplyLen), 0};
@@ -47,17 +47,17 @@ ReturnValue_t UartComIF::initializeInterface(CookieIF* cookie) {
       sif::warning << "UartComIF::initializeInterface: Failed to insert device " << deviceFile
                    << "to UART device map" << std::endl;
 #endif
-      return returnvalue::FAILED;
+      return RETURN_FAILED;
     }
   } else {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "UartComIF::initializeInterface: UART device " << deviceFile
                  << " already in use" << std::endl;
 #endif
-    return returnvalue::FAILED;
+    return RETURN_FAILED;
   }
 
-  return returnvalue::OK;
+  return RETURN_OK;
 }
 
 int UartComIF::configureUartPort(UartCookie* uartCookie) {
@@ -329,14 +329,14 @@ ReturnValue_t UartComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData,
   UartDeviceMapIter uartDeviceMapIter;
 
   if (sendLen == 0) {
-    return returnvalue::OK;
+    return RETURN_OK;
   }
 
   if (sendData == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "UartComIF::sendMessage: Send data is nullptr" << std::endl;
 #endif
-    return returnvalue::FAILED;
+    return RETURN_FAILED;
   }
 
   UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
@@ -354,7 +354,7 @@ ReturnValue_t UartComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData,
     sif::debug << "UartComIF::sendMessage: Device file " << deviceFile << "not in UART map"
                << std::endl;
 #endif
-    return returnvalue::FAILED;
+    return RETURN_FAILED;
   }
 
   fd = uartDeviceMapIter->second.fileDescriptor;
@@ -364,13 +364,13 @@ ReturnValue_t UartComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData,
     sif::error << "UartComIF::sendMessage: Failed to send data with error code " << errno
                << ": Error description: " << strerror(errno) << std::endl;
 #endif
-    return returnvalue::FAILED;
+    return RETURN_FAILED;
   }
 
-  return returnvalue::OK;
+  return RETURN_OK;
 }
 
-ReturnValue_t UartComIF::getSendSuccess(CookieIF* cookie) { return returnvalue::OK; }
+ReturnValue_t UartComIF::getSendSuccess(CookieIF* cookie) { return RETURN_OK; }
 
 ReturnValue_t UartComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLen) {
   std::string deviceFile;
@@ -389,7 +389,7 @@ ReturnValue_t UartComIF::requestReceiveMessage(CookieIF* cookie, size_t requestL
   uartDeviceMapIter = uartDeviceMap.find(deviceFile);
 
   if (uartMode == UartModes::NON_CANONICAL and requestLen == 0) {
-    return returnvalue::OK;
+    return RETURN_OK;
   }
 
   if (uartDeviceMapIter == uartDeviceMap.end()) {
@@ -397,7 +397,7 @@ ReturnValue_t UartComIF::requestReceiveMessage(CookieIF* cookie, size_t requestL
     sif::debug << "UartComIF::requestReceiveMessage: Device file " << deviceFile
                << " not in uart map" << std::endl;
 #endif
-    return returnvalue::FAILED;
+    return RETURN_FAILED;
   }
 
   if (uartMode == UartModes::CANONICAL) {
@@ -405,13 +405,13 @@ ReturnValue_t UartComIF::requestReceiveMessage(CookieIF* cookie, size_t requestL
   } else if (uartMode == UartModes::NON_CANONICAL) {
     return handleNoncanonicalRead(*uartCookie, uartDeviceMapIter, requestLen);
   } else {
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
 }
 
 ReturnValue_t UartComIF::handleCanonicalRead(UartCookie& uartCookie, UartDeviceMapIter& iter,
                                              size_t requestLen) {
-  ReturnValue_t result = returnvalue::OK;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
   uint8_t maxReadCycles = uartCookie.getReadCycles();
   uint8_t currentReadCycles = 0;
   int bytesRead = 0;
@@ -454,7 +454,7 @@ ReturnValue_t UartComIF::handleCanonicalRead(UartCookie& uartCookie, UartDeviceM
                           strerror(errno));
 #endif
 #endif
-        return returnvalue::FAILED;
+        return RETURN_FAILED;
       }
 
     } else if (bytesRead > 0) {
@@ -487,18 +487,18 @@ ReturnValue_t UartComIF::handleNoncanonicalRead(UartCookie& uartCookie, UartDevi
   }
   int bytesRead = read(fd, bufferPtr, requestLen);
   if (bytesRead < 0) {
-    return returnvalue::FAILED;
+    return RETURN_FAILED;
   } else if (bytesRead != static_cast<int>(requestLen)) {
     if (uartCookie.isReplySizeFixed()) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::warning << "UartComIF::requestReceiveMessage: Only read " << bytesRead << " of "
                    << requestLen << " bytes" << std::endl;
 #endif
-      return returnvalue::FAILED;
+      return RETURN_FAILED;
     }
   }
   iter->second.replyLen = bytesRead;
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t UartComIF::readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) {
@@ -520,7 +520,7 @@ ReturnValue_t UartComIF::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
     sif::debug << "UartComIF::readReceivedMessage: Device file " << deviceFile << " not in uart map"
                << std::endl;
 #endif
-    return returnvalue::FAILED;
+    return RETURN_FAILED;
   }
 
   *buffer = uartDeviceMapIter->second.replyBuffer.data();
@@ -529,7 +529,7 @@ ReturnValue_t UartComIF::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
   /* Length is reset to 0 to prevent reading the same data twice */
   uartDeviceMapIter->second.replyLen = 0;
 
-  return returnvalue::OK;
+  return RETURN_OK;
 }
 
 ReturnValue_t UartComIF::flushUartRxBuffer(CookieIF* cookie) {
@@ -547,9 +547,9 @@ ReturnValue_t UartComIF::flushUartRxBuffer(CookieIF* cookie) {
   if (uartDeviceMapIter != uartDeviceMap.end()) {
     int fd = uartDeviceMapIter->second.fileDescriptor;
     tcflush(fd, TCIFLUSH);
-    return returnvalue::OK;
+    return RETURN_OK;
   }
-  return returnvalue::FAILED;
+  return RETURN_FAILED;
 }
 
 ReturnValue_t UartComIF::flushUartTxBuffer(CookieIF* cookie) {
@@ -567,9 +567,9 @@ ReturnValue_t UartComIF::flushUartTxBuffer(CookieIF* cookie) {
   if (uartDeviceMapIter != uartDeviceMap.end()) {
     int fd = uartDeviceMapIter->second.fileDescriptor;
     tcflush(fd, TCOFLUSH);
-    return returnvalue::OK;
+    return RETURN_OK;
   }
-  return returnvalue::FAILED;
+  return RETURN_FAILED;
 }
 
 ReturnValue_t UartComIF::flushUartTxAndRxBuf(CookieIF* cookie) {
@@ -587,9 +587,9 @@ ReturnValue_t UartComIF::flushUartTxAndRxBuf(CookieIF* cookie) {
   if (uartDeviceMapIter != uartDeviceMap.end()) {
     int fd = uartDeviceMapIter->second.fileDescriptor;
     tcflush(fd, TCIOFLUSH);
-    return returnvalue::OK;
+    return RETURN_OK;
   }
-  return returnvalue::FAILED;
+  return RETURN_FAILED;
 }
 
 void UartComIF::setUartMode(struct termios* options, UartCookie& uartCookie) {

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

@@ -22,9 +22,12 @@ class UartComIF : public DeviceCommunicationIF, public SystemObject {
  public:
   static constexpr uint8_t uartRetvalId = CLASS_ID::HAL_UART;
 
-  static constexpr ReturnValue_t UART_READ_FAILURE = returnvalue::makeCode(uartRetvalId, 1);
+  static constexpr ReturnValue_t UART_READ_FAILURE =
-  static constexpr ReturnValue_t UART_READ_SIZE_MISSMATCH = returnvalue::makeCode(uartRetvalId, 2);
+      HasReturnvaluesIF::makeReturnCode(uartRetvalId, 1);
-  static constexpr ReturnValue_t UART_RX_BUFFER_TOO_SMALL = returnvalue::makeCode(uartRetvalId, 3);
+  static constexpr ReturnValue_t UART_READ_SIZE_MISSMATCH =
+      HasReturnvaluesIF::makeReturnCode(uartRetvalId, 2);
+  static constexpr ReturnValue_t UART_RX_BUFFER_TOO_SMALL =
+      HasReturnvaluesIF::makeReturnCode(uartRetvalId, 3);
 
   UartComIF(object_id_t objectId);
 

hal/src/fsfw_hal/linux/uio/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(${LIB_FSFW_NAME} PUBLIC
+	UioMapper.cpp
+)

hal/src/fsfw_hal/linux/uio/UioMapper.cpp

@@ -18,17 +18,17 @@ UioMapper::UioMapper(std::string uioFile, int mapNum) : uioFile(uioFile), mapNum
 UioMapper::~UioMapper() {}
 
 ReturnValue_t UioMapper::getMappedAdress(uint32_t** address, Permissions permissions) {
-  ReturnValue_t result = returnvalue::OK;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
   int fd = open(uioFile.c_str(), O_RDWR);
   if (fd < 1) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "PtmeAxiConfig::initialize: Invalid UIO device file" << std::endl;
 #endif
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
   size_t size = 0;
   result = getMapSize(&size);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
   *address = static_cast<uint32_t*>(
@@ -39,9 +39,9 @@ ReturnValue_t UioMapper::getMappedAdress(uint32_t** address, Permissions permiss
     sif::error << "UioMapper::getMappedAdress: Failed to map physical address of uio device "
                << uioFile.c_str() << " and map" << static_cast<int>(mapNum) << std::endl;
 #endif
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t UioMapper::getMapSize(size_t* size) {
@@ -54,7 +54,7 @@ ReturnValue_t UioMapper::getMapSize(size_t* size) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "UioMapper::getMapSize: Failed to open file " << namestream.str() << std::endl;
 #endif
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
   char hexstring[SIZE_HEX_STRING] = "";
   int items = fscanf(fp, "%s", hexstring);
@@ -66,7 +66,7 @@ ReturnValue_t UioMapper::getMapSize(size_t* size) {
                << namestream.str() << std::endl;
 #endif
     fclose(fp);
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
   uint32_t sizeTmp = 0;
   items = sscanf(hexstring, "%x", &sizeTmp);
@@ -79,8 +79,8 @@ ReturnValue_t UioMapper::getMapSize(size_t* size) {
                << "size of map" << mapNum << " to integer" << std::endl;
 #endif
     fclose(fp);
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
   fclose(fp);
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }

hal/src/fsfw_hal/linux/uio/UioMapper.h

@@ -5,7 +5,7 @@
 
 #include <string>
 
-#include "fsfw/returnvalues/returnvalue.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
 
 /**
  * @brief   Class to help opening uio device files and mapping the physical addresses into the user

hal/src/fsfw_hal/stm32h7/CMakeLists.txt

@@ -2,4 +2,6 @@ add_subdirectory(spi)
 add_subdirectory(gpio)
 add_subdirectory(devicetest)
 
-target_sources(${LIB_FSFW_NAME} PRIVATE dma.cpp)
+target_sources(${LIB_FSFW_NAME} PRIVATE
+    dma.cpp
+)

hal/src/fsfw_hal/stm32h7/devicetest/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE
+    GyroL3GD20H.cpp
+)

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

@@ -84,7 +84,7 @@ ReturnValue_t GyroL3GD20H::initialize() {
   spiHandle->Init.Mode = SPI_MODE_MASTER;
   if (HAL_SPI_Init(spiHandle) != HAL_OK) {
     sif::printWarning("Error initializing SPI\n");
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
 
   delete mspCfg;
@@ -106,11 +106,11 @@ ReturnValue_t GyroL3GD20H::initialize() {
       return handlePollingTransferInit();
     }
     default: {
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
   }
 
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t GyroL3GD20H::performOperation() {
@@ -125,10 +125,10 @@ ReturnValue_t GyroL3GD20H::performOperation() {
       return handleInterruptSensorRead();
     }
     default: {
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t GyroL3GD20H::handleDmaTransferInit() {
@@ -162,10 +162,10 @@ ReturnValue_t GyroL3GD20H::handleDmaTransferInit() {
     case (TransferStates::FAILURE): {
       sif::printWarning("Transfer failure\n");
       transferState = TransferStates::FAILURE;
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
     default: {
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
   }
 
@@ -194,10 +194,10 @@ ReturnValue_t GyroL3GD20H::handleDmaTransferInit() {
     case (TransferStates::FAILURE): {
       sif::printWarning("GyroL3GD20H::initialize: Configuration transfer failure\n");
       transferState = TransferStates::FAILURE;
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
     default: {
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
   }
 
@@ -228,13 +228,13 @@ ReturnValue_t GyroL3GD20H::handleDmaTransferInit() {
     case (TransferStates::FAILURE): {
       sif::printWarning("GyroL3GD20H::initialize: Configuration transfer failure\n");
       transferState = TransferStates::FAILURE;
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
     default: {
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t GyroL3GD20H::handleDmaSensorRead() {
@@ -259,13 +259,13 @@ ReturnValue_t GyroL3GD20H::handleDmaSensorRead() {
     case (TransferStates::FAILURE): {
       sif::printWarning("GyroL3GD20H::handleDmaSensorRead: Sensor read failure\n");
       transferState = TransferStates::FAILURE;
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
     default: {
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 HAL_StatusTypeDef GyroL3GD20H::performDmaTransfer(size_t sendSize) {
@@ -298,14 +298,14 @@ ReturnValue_t GyroL3GD20H::handlePollingTransferInit() {
     }
     case (HAL_TIMEOUT): {
       sif::printDebug("GyroL3GD20H::initialize: Polling transfer timeout\n");
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
     case (HAL_ERROR): {
       sif::printDebug("GyroL3GD20H::initialize: Polling transfer failure\n");
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
     default: {
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
   }
 
@@ -323,14 +323,14 @@ ReturnValue_t GyroL3GD20H::handlePollingTransferInit() {
     }
     case (HAL_TIMEOUT): {
       sif::printDebug("GyroL3GD20H::initialize: Polling transfer timeout\n");
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
     case (HAL_ERROR): {
       sif::printDebug("GyroL3GD20H::initialize: Polling transfer failure\n");
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
     default: {
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
   }
 
@@ -353,17 +353,17 @@ ReturnValue_t GyroL3GD20H::handlePollingTransferInit() {
     }
     case (HAL_TIMEOUT): {
       sif::printDebug("GyroL3GD20H::initialize: Polling transfer timeout\n");
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
     case (HAL_ERROR): {
       sif::printDebug("GyroL3GD20H::initialize: Polling transfer failure\n");
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
     default: {
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t GyroL3GD20H::handlePollingSensorRead() {
@@ -380,17 +380,17 @@ ReturnValue_t GyroL3GD20H::handlePollingSensorRead() {
     }
     case (HAL_TIMEOUT): {
       sif::printDebug("GyroL3GD20H::initialize: Polling transfer timeout\n");
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
     case (HAL_ERROR): {
       sif::printDebug("GyroL3GD20H::initialize: Polling transfer failure\n");
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
     default: {
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t GyroL3GD20H::handleInterruptTransferInit() {
@@ -416,7 +416,7 @@ ReturnValue_t GyroL3GD20H::handleInterruptTransferInit() {
     case (HAL_ERROR):
     case (HAL_TIMEOUT): {
       sif::printDebug("GyroL3GD20H::initialize: Initialization failure using interrupts\n");
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
   }
 
@@ -438,7 +438,7 @@ ReturnValue_t GyroL3GD20H::handleInterruptTransferInit() {
     case (HAL_ERROR):
     case (HAL_TIMEOUT): {
       sif::printDebug("GyroL3GD20H::initialize: Initialization failure using interrupts\n");
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
   }
 
@@ -465,10 +465,10 @@ ReturnValue_t GyroL3GD20H::handleInterruptTransferInit() {
     case (HAL_ERROR):
     case (HAL_TIMEOUT): {
       sif::printDebug("GyroL3GD20H::initialize: Initialization failure using interrupts\n");
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t GyroL3GD20H::handleInterruptSensorRead() {
@@ -489,10 +489,10 @@ ReturnValue_t GyroL3GD20H::handleInterruptSensorRead() {
     case (HAL_ERROR):
     case (HAL_TIMEOUT): {
       sif::printDebug("GyroL3GD20H::initialize: Sensor read failure using interrupts\n");
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 void GyroL3GD20H::prepareConfigRegs(uint8_t *configRegs) {

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

@@ -6,14 +6,10 @@
 
 #include "../spi/mspInit.h"
 #include "../spi/spiDefinitions.h"
-#include "fsfw/returnvalues/returnvalue.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
 #include "stm32h7xx_hal.h"
 #include "stm32h7xx_hal_spi.h"
 
-#ifndef STM_USE_PERIPHERAL_TX_BUFFER_MPU_PROTECTION
-#define STM_USE_PERIPHERAL_TX_BUFFER_MPU_PROTECTION 1
-#endif
-
 enum class TransferStates { IDLE, WAIT, SUCCESS, FAILURE };
 
 class GyroL3GD20H {

hal/src/fsfw_hal/stm32h7/gpio/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE
+    gpio.cpp
+)

hal/src/fsfw_hal/stm32h7/i2c/CMakeLists.txt

@@ -0,0 +1,2 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE
+)

hal/src/fsfw_hal/stm32h7/spi/CMakeLists.txt

@@ -0,0 +1,9 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE
+    spiCore.cpp
+    spiDefinitions.cpp
+    spiInterrupts.cpp
+    mspInit.cpp
+    SpiCookie.cpp
+    SpiComIF.cpp
+    stm32h743zi.cpp
+)

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

@@ -35,7 +35,7 @@ void SpiComIF::addDmaHandles(DMA_HandleTypeDef *txHandle, DMA_HandleTypeDef *rxH
   spi::setDmaHandles(txHandle, rxHandle);
 }
 
-ReturnValue_t SpiComIF::initialize() { return returnvalue::OK; }
+ReturnValue_t SpiComIF::initialize() { return HasReturnvaluesIF::RETURN_OK; }
 
 ReturnValue_t SpiComIF::initializeInterface(CookieIF *cookie) {
   SpiCookie *spiCookie = dynamic_cast<SpiCookie *>(cookie);
@@ -55,7 +55,7 @@ ReturnValue_t SpiComIF::initializeInterface(CookieIF *cookie) {
     spi::getDmaHandles(&txHandle, &rxHandle);
     if (txHandle == nullptr or rxHandle == nullptr) {
       sif::printError("SpiComIF::initialize: DMA handles not set!\n");
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
   }
   // This semaphore ensures thread-safety for a given bus
@@ -79,7 +79,7 @@ ReturnValue_t SpiComIF::initializeInterface(CookieIF *cookie) {
           static_cast<unsigned long>(spiAddress));
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
   }
   auto gpioPin = spiCookie->getChipSelectGpioPin();
@@ -98,7 +98,7 @@ ReturnValue_t SpiComIF::initializeInterface(CookieIF *cookie) {
 #endif
   } else {
     printCfgError("SPI Bus Index");
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
 
   auto mspCfg = spiCookie->getMspCfg();
@@ -107,21 +107,21 @@ ReturnValue_t SpiComIF::initializeInterface(CookieIF *cookie) {
     auto typedCfg = dynamic_cast<spi::MspPollingConfigStruct *>(mspCfg);
     if (typedCfg == nullptr) {
       printCfgError("Polling MSP");
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
     spi::setSpiPollingMspFunctions(typedCfg);
   } else if (transferMode == spi::TransferModes::INTERRUPT) {
     auto typedCfg = dynamic_cast<spi::MspIrqConfigStruct *>(mspCfg);
     if (typedCfg == nullptr) {
       printCfgError("IRQ MSP");
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
     spi::setSpiIrqMspFunctions(typedCfg);
   } else if (transferMode == spi::TransferModes::DMA) {
     auto typedCfg = dynamic_cast<spi::MspDmaConfigStruct *>(mspCfg);
     if (typedCfg == nullptr) {
       printCfgError("DMA MSP");
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
     // Check DMA handles
     DMA_HandleTypeDef *txHandle = nullptr;
@@ -129,7 +129,7 @@ ReturnValue_t SpiComIF::initializeInterface(CookieIF *cookie) {
     spi::getDmaHandles(&txHandle, &rxHandle);
     if (txHandle == nullptr or rxHandle == nullptr) {
       printCfgError("DMA Handle");
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
     spi::setSpiDmaMspFunctions(typedCfg);
   }
@@ -145,12 +145,12 @@ ReturnValue_t SpiComIF::initializeInterface(CookieIF *cookie) {
 
   if (HAL_SPI_Init(&spiHandle) != HAL_OK) {
     sif::printWarning("SpiComIF::initialize: Error initializing SPI\n");
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
   // The MSP configuration struct is not required anymore
   spiCookie->deleteMspCfg();
 
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t SpiComIF::sendMessage(CookieIF *cookie, const uint8_t *sendData, size_t sendLen) {
@@ -163,7 +163,7 @@ ReturnValue_t SpiComIF::sendMessage(CookieIF *cookie, const uint8_t *sendData, s
 
   auto iter = spiDeviceMap.find(spiCookie->getDeviceAddress());
   if (iter == spiDeviceMap.end()) {
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
   iter->second.currentTransferLen = sendLen;
 
@@ -176,7 +176,7 @@ ReturnValue_t SpiComIF::sendMessage(CookieIF *cookie, const uint8_t *sendData, s
     case (spi::TransferStates::FAILURE):
     case (spi::TransferStates::SUCCESS):
     default: {
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
   }
 
@@ -194,13 +194,13 @@ ReturnValue_t SpiComIF::sendMessage(CookieIF *cookie, const uint8_t *sendData, s
                                     sendData, sendLen);
     }
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t SpiComIF::getSendSuccess(CookieIF *cookie) { return returnvalue::OK; }
+ReturnValue_t SpiComIF::getSendSuccess(CookieIF *cookie) { return HasReturnvaluesIF::RETURN_OK; }
 
 ReturnValue_t SpiComIF::requestReceiveMessage(CookieIF *cookie, size_t requestLen) {
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t SpiComIF::readReceivedMessage(CookieIF *cookie, uint8_t **buffer, size_t *size) {
@@ -212,7 +212,7 @@ ReturnValue_t SpiComIF::readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
     case (spi::TransferStates::SUCCESS): {
       auto iter = spiDeviceMap.find(spiCookie->getDeviceAddress());
       if (iter == spiDeviceMap.end()) {
-        return returnvalue::FAILED;
+        return HasReturnvaluesIF::RETURN_FAILED;
       }
       *buffer = iter->second.replyBuffer.data();
       *size = iter->second.currentTransferLen;
@@ -228,18 +228,18 @@ ReturnValue_t SpiComIF::readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
 #endif
 #endif
       spiCookie->setTransferState(spi::TransferStates::IDLE);
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
     case (spi::TransferStates::WAIT):
     case (spi::TransferStates::IDLE): {
       break;
     }
     default: {
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
   }
 
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 void SpiComIF::setDefaultPollingTimeout(dur_millis_t timeout) {
@@ -252,7 +252,7 @@ ReturnValue_t SpiComIF::handlePollingSendOperation(uint8_t *recvPtr, SPI_HandleT
   auto gpioPort = spiCookie.getChipSelectGpioPort();
   auto gpioPin = spiCookie.getChipSelectGpioPin();
   auto returnval = spiSemaphore->acquire(timeoutType, timeoutMs);
-  if (returnval != returnvalue::OK) {
+  if (returnval != HasReturnvaluesIF::RETURN_OK) {
     return returnval;
   }
   spiCookie.setTransferState(spi::TransferStates::WAIT);
@@ -299,7 +299,7 @@ ReturnValue_t SpiComIF::handlePollingSendOperation(uint8_t *recvPtr, SPI_HandleT
       return spi::HAL_ERROR_RETVAL;
     }
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t SpiComIF::handleInterruptSendOperation(uint8_t *recvPtr, SPI_HandleTypeDef &spiHandle,
@@ -318,7 +318,7 @@ ReturnValue_t SpiComIF::handleIrqSendOperation(uint8_t *recvPtr, SPI_HandleTypeD
                                                SpiCookie &spiCookie, const uint8_t *sendData,
                                                size_t sendLen) {
   ReturnValue_t result = genericIrqSendSetup(recvPtr, spiHandle, spiCookie, sendData, sendLen);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
   // yet another HAL driver which is not const-correct..
@@ -366,7 +366,7 @@ ReturnValue_t SpiComIF::halErrorHandler(HAL_StatusTypeDef status, spi::TransferM
       return spi::HAL_TIMEOUT_RETVAL;
     }
     default: {
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
   }
 }
@@ -379,7 +379,7 @@ ReturnValue_t SpiComIF::genericIrqSendSetup(uint8_t *recvPtr, SPI_HandleTypeDef
 
   // Take the semaphore which will be released by a callback when the transfer is complete
   ReturnValue_t result = spiSemaphore->acquire(SemaphoreIF::TimeoutType::WAITING, timeoutMs);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     // Configuration error
     sif::printWarning(
         "SpiComIF::handleInterruptSendOperation: Semaphore "
@@ -399,7 +399,7 @@ ReturnValue_t SpiComIF::genericIrqSendSetup(uint8_t *recvPtr, SPI_HandleTypeDef
     HAL_GPIO_WritePin(spiCookie.getChipSelectGpioPort(), spiCookie.getChipSelectGpioPin(),
                       GPIO_PIN_RESET);
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 void SpiComIF::spiTransferTxCompleteCallback(SPI_HandleTypeDef *hspi, void *args) {
@@ -445,7 +445,7 @@ void SpiComIF::genericIrqHandler(void *irqArgsVoid, spi::TransferStates targetSt
 #elif defined FSFW_OSAL_RTEMS
   ReturnValue_t result = comIF->spiSemaphore->release();
 #endif
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     // Configuration error
     printf("SpiComIF::genericIrqHandler: Failure releasing Semaphore!\n");
   }