Merge branch 'eive/develop' into mueller/extend-version-class-fork

Reviewed-on: eive/fsfw#66

.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,69 +8,25 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 # [unreleased]
 
-# [v6.0.0]
-
-## Fixes
-
-- Bugfix for Serial Buffer Stream: Setting `doActive` to false now
-  actually fully disables printing.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/680
-- `TcpTmTcServer.cpp`: The server was actually not able to handle
-  CCSDS packets which were clumped together. This has been fixed now.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/673
-
-## Added
-
-- Add new `UnsignedByteField` class
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/660
+# [v5.0.0]
 
 ## 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
-- Bump Catch2 dependency to regular version `v3.1.0`
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/678
-- `SerialBufferAdapter`: Rename `setBuffer` to `setConstBuffer` and update
-  API to expect `const uint8_t*` accordingly.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/677
-- Remove the following user includes from `fsfw/events/Event.h` and
-  `fsfw/returnvalues/returnvalue.h`:
-  - `#include "events/subsystemIdRanges.h"`
-  - `#include "returnvalues/classIds.h"`
-  The user has to include those themselves now
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/675
-- `DeviceHandlerBase`: Set command sender before calling `buildCommandFromCommand`.
-  This allows finishing action commands immediately inside the function.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/672
-- `DeviceHandlerBase`: New signature of `handleDeviceTm` which expects
-  a `const SerializeIF&` and additional helper variant which expects `const uint8_t*`
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/671
-
-# [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 
-  Buffer and rejects such writeData calls with `returnvalue::FAILED`
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/586
+- HAL Linux Uart: Baudrate and bits per word are enums now, avoiding misconfigurations
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/585
 - Major update for version handling, using `git describe` to fetch version information with git.
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/601
+  - Place `Version` class outside of `fsfw` namespace. It is generic
   - Add helper functions provided by [`cmake-modules`](https://github.com/bilke/cmake-modules)
     manually now. Those should not change too often and only a small subset is needed
   - Separate folder for easier update and for distinction
@@ -82,78 +38,6 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
     versions since the last tag
   - Additional information is set to the last part of the git describe output for `FSFW_VERSION` now.
   - Version still need to be hand-updated if the FSFW is not included as a submodule for now.
-- IPC Message Queue Handling: Allow passing an optional `MqArgs` argument into the MessageQueue
-  creation call. It allows passing context information and an arbitrary user argument into
-  the message queue. Also streamlined and simplified `MessageQueue` implementation for all OSALs
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/583
-- Internal API change: Moved the `fsfw_hal` to the `src` folder and integration and internal
-  tests part of `fsfw_tests` to `src`. Unittests are now in a dedicated folder called `unittests`
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/653
-
-### Task Module Refactoring
-
-PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/636
-
-**Refactoring general task code**
-
-- There was a lot of duplicate/boilerplate code inside the individual task IF OSAL implementations.
-  Remove it by introducing base classes `PeriodicTaskBase` and `FixedTimeslotTaskBase`.
-
-**Refactor PeriodicTaskIF**
-
-- Convert `virtual ReturnValue_t addComponent(object_id_t object)` to
-  `virtual ReturnValue_t addComponent(object_id_t object, uint8_t opCode = 0)`, allowing to pass
-  the operation code passed to `performOperation`. Updated API taking
-  an `ExecutableObjectIF` accordingly
-
-**Refactor FixedTimeslotTaskIF**
-
-- Add additional `addSlot` function which takes an `ExecutableObjectIF` pointer and its Object ID
-
-**Refactor FixedSequenceSlot**
-
-- Introduce typedef `CustomCheckFunc` for `ReturnValue_t (*customCheckFunction)(const SlotList&)`.
-- Convert `ReturnValue_t (*customCheckFunction)(const SlotList&)` to
-  `ReturnValue_t (*customCheckFunction)(const SlotList&, void*)`, allowing arbitrary user arguments
-  for the custom checker
-
-**Linux Task Module**
-
-- Use composition instead of inheritance for the `PeriodicPosixTask` and make the `PosixTask` a
-  member of the class
-
-### HAL
-
-- HAL Linux Uart: Baudrate and bits per word are enums now, avoiding misconfigurations
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/585
-- HAL Linux SPI: Set the Clock Default State when setting new SPI speed
-  and mode
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/573
-- GPIO HAL: `Direction`, `GpioOperation` and `Levels` are enum classes now, which prevents
-  name clashes with Windows defines.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/572
-- HAL Linux Uart: Baudrate and bits per word are enums now, avoiding misconfigurations
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/585
-
-### Time
-
-PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/584 and
-https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593
-
-- `timeval` to `TimeOfDay_t`
-- Added Mutex for gmtime calls: (compare http://www.opengate.at/blog/2020/01/timeless/)
-- Moved the statics used by Clock in ClockCommon.cpp to this file
-- Better check for leap seconds
-- Added Unittests for Clock (only getter)
-
-### Power 
-
-- `PowerSwitchIF`: Remove `const` specifier from `sendSwitchCommand` and `sendFuseOnCommand` and
-  also specify a `ReturnValue_t` return type
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
-- Extend `PowerSwitcher` module to optionally check current state when calling `turnOn` or
-  `turnOff`. Tis can be helpful to avoid commanding switches which do not need commanding
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
 
 ## Removed
 
@@ -163,57 +47,15 @@ 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
 - Linux HAL: Add wiretapping option for I2C. Enabled with `FSFW_HAL_I2C_WIRETAPPING` defined to 1
 - Dedicated Version class and constant `fsfw::FSFW_VERSION` containing version information
   inside `fsfw/version.h`
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/559
-- Added generic PUS TC Scheduler Service 11. It depends on the new added Emebeded Template Library
-  (ETL) dependency.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/594
-- Added ETL dependency and improved library dependency management
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/592
-- Add a `DummyPowerSwitcher` module which can be useful for test setups when no PCDU is available
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
-- New typedef for switcher type
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
-- `Subsystem`: New API to add table and sequence entries
 
 ## Fixed
 
-- TCP TMTC Server: `MutexGuard` was not created properly in
-  `TcpTmTcServer::handleTmSending(socket_t connSocket, bool& tmSent)` call.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/618
-- Fix infinite recursion in `prepareHealthSetReply` of PUS Health Service 201.
-  Is not currently used right now but might be used in the future
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/617
-- Move some CMake directives further up top so they are not ignored
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/621
 - Small bugfix in STM32 HAL for SPI
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/599
-- HAL GPIO: Improved error checking in `LinuxLibgpioIF::configureGpios(...)`. If a GPIO
-  configuration fails, the function will exit prematurely with a dedicated error code
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/602
 
 # [v4.0.0]
 

CMakeLists.txt

@@ -1,21 +1,51 @@
 cmake_minimum_required(VERSION 3.13)
 
-set(MSG_PREFIX "fsfw |")
+set(FSFW_VERSION_IF_GIT_FAILS 4)
+set(FSFW_SUBVERSION_IF_GIT_FAILS 0)
+set(FSFW_REVISION_IF_GIT_FAILS 0)
 
 # Add the cmake folder so the FindSphinx module is found
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" )
-list(APPEND CMAKE_MODULE_PATH
-     "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake-modules/bilke")
-list(APPEND CMAKE_MODULE_PATH
-     "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake-modules/rpavlik")
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake-modules")
+set(MSG_PREFIX "fsfw |")
 
-# ##############################################################################
-# Version file handling  #
-# ##############################################################################
+option(FSFW_GENERATE_SECTIONS
+    "Generate function and data sections. Required to remove unused code" ON
+)
+if(FSFW_GENERATE_SECTIONS)
+    option(FSFW_REMOVE_UNUSED_CODE "Remove unused code" ON)
+endif()
 
-set(FSFW_VERSION_IF_GIT_FAILS 5)
-set(FSFW_SUBVERSION_IF_GIT_FAILS 0)
-set(FSFW_REVISION_IF_GIT_FAILS 0)
+option(FSFW_BUILD_UNITTESTS "Build unittest binary in addition to static library" OFF)
+option(FSFW_BUILD_DOCS "Build documentation with Sphinx and Doxygen" OFF)
+if(FSFW_BUILD_UNITTESTS)
+    option(FSFW_TESTS_GEN_COV "Generate coverage data for unittests" ON)
+endif()
+
+option(FSFW_WARNING_SHADOW_LOCAL_GCC "Enable -Wshadow=local warning in GCC" ON)
+# Options to exclude parts of the FSFW from compilation.
+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)
+
+# Optional sources
+option(FSFW_ADD_PUS "Compile with PUS sources" ON)
+option(FSFW_ADD_MONITORING "Compile with monitoring components" ON)
+
+option(FSFW_ADD_RMAP "Compile with RMAP" OFF)
+option(FSFW_ADD_DATALINKLAYER "Compile with Data Link Layer" OFF)
+option(FSFW_ADD_COORDINATES "Compile with coordinate components" OFF)
+option(FSFW_ADD_TMSTORAGE "Compile with tm storage components" OFF)
+
+# Contrib sources
+option(FSFW_ADD_SGP4_PROPAGATOR "Add SGP4 propagator code" OFF)
+
+set(LIB_FSFW_NAME fsfw)
+set(FSFW_TEST_TGT fsfw-tests)
+set(FSFW_DUMMY_TGT fsfw-dummy)
+
+project(${LIB_FSFW_NAME})
+add_library(${LIB_FSFW_NAME})
 
 set(FSFW_GIT_VER_HANDLING_OK FALSE)
 # Version handling
@@ -24,13 +54,11 @@ if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.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")
+        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)
+        list(GET FSFW_GIT_INFO 4 FSFW_VERSION_CST_GIT_SHA1)
         if(NOT FSFW_VERSION)
             set(FSFW_VERSION ${FSFW_VERSION_IF_GIT_FAILS})
         endif()
@@ -51,211 +79,82 @@ if(NOT FSFW_GIT_VER_HANDLING_OK)
     set(FSFW_REVISION ${FSFW_REVISION_IF_GIT_FAILS})
 endif()
 
-set(LIB_FSFW_NAME fsfw)
-project(${LIB_FSFW_NAME}
-        VERSION ${FSFW_VERSION}.${FSFW_SUBVERSION}.${FSFW_REVISION})
-
-if(NOT CMAKE_CXX_STANDARD)
-  set(CMAKE_CXX_STANDARD 17)
-  set(CMAKE_CXX_STANDARD_REQUIRED True)
-elseif(${CMAKE_CXX_STANDARD} LESS 17)
-  message(
-    FATAL_ERROR
-      "${MSG_PREFIX} Compiling the FSFW requires a minimum of C++17 support")
-endif()
-
-set(FSFW_SOURCES_DIR "${CMAKE_SOURCE_DIR}/src/fsfw")
-
-set(FSFW_ETL_LIB_NAME etl)
-set(FSFW_ETL_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}.1.0
-    CACHE STRING "Catch2 library exact version requirement")
-
-# Keep this off by default for now. See PR:
-# https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/616 for information which
-# keeping this on by default is problematic
-option(
-  FSFW_ENABLE_IPO
-  "Enable interprocedural optimization or link-time optimization if available"
-  OFF)
-if(FSFW_ENABLE_IPO)
-  include(CheckIPOSupported)
-  check_ipo_supported(RESULT IPO_SUPPORTED OUTPUT IPO_ERROR)
-  if(NOT IPO_SUPPORTED)
-    message(STATUS "FSFW | IPO/LTO not supported: ${IPO_ERROR}")
-  endif()
-endif()
-
-option(FSFW_GENERATE_SECTIONS
-       "Generate function and data sections. Required to remove unused code" ON)
-if(FSFW_GENERATE_SECTIONS)
-  option(FSFW_REMOVE_UNUSED_CODE "Remove unused code" ON)
-endif()
-
-option(FSFW_BUILD_TESTS "Build unittest binary in addition to static library"
-       OFF)
-option(FSFW_CICD_BUILD "Build for CI/CD. This can disable problematic test" OFF)
-option(FSFW_BUILD_DOCS "Build documentation with Sphinx and Doxygen" OFF)
-if(FSFW_BUILD_TESTS)
-  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)
-# Options to exclude parts of the FSFW from compilation.
-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)
-
-option(FSFW_ADD_RMAP "Compile with RMAP" OFF)
-option(FSFW_ADD_DATALINKLAYER "Compile with Data Link Layer" OFF)
-option(FSFW_ADD_COORDINATES "Compile with coordinate components" OFF)
-option(FSFW_ADD_TMSTORAGE "Compile with tm storage components" OFF)
-
-# Contrib sources
-option(FSFW_ADD_SGP4_PROPAGATOR "Add SGP4 propagator code" OFF)
-
-set(FSFW_TEST_TGT fsfw-tests)
-set(FSFW_DUMMY_TGT fsfw-dummy)
-
-add_library(${LIB_FSFW_NAME})
-
-if(IPO_SUPPORTED AND FSFW_ENABLE_IPO)
-  set_property(TARGET ${LIB_FSFW_NAME} PROPERTY INTERPROCEDURAL_OPTIMIZATION
-                                                TRUE)
-endif()
-
-if(FSFW_BUILD_TESTS)
-  message(
-    STATUS
-      "${MSG_PREFIX} Building the FSFW unittests in addition to the static library"
-  )
+if(FSFW_BUILD_UNITTESTS)
+    message(STATUS "${MSG_PREFIX} Building the FSFW unittests in addition to the static library")
     # Check whether the user has already installed Catch2 first
-  find_package(Catch2 ${FSFW_CATCH2_LIB_MAJOR_VERSION})
+    find_package(Catch2 3 QUIET)
     # Not installed, so use FetchContent to download and provide Catch2
     if(NOT Catch2_FOUND)
-    message(
-      STATUS
-        "${MSG_PREFIX} Catch2 installation not found. Downloading Catch2 library with FetchContent"
-    )
+        message(STATUS "${MSG_PREFIX} Catch2 installation not found. Downloading Catch2 library with FetchContent")
         include(FetchContent)
 
         FetchContent_Declare(
             Catch2
             GIT_REPOSITORY https://github.com/catchorg/Catch2.git
-      GIT_TAG ${FSFW_CATCH2_LIB_VERSION})
+            GIT_TAG        v3.0.0-preview4
+        )
 
-    list(APPEND FSFW_FETCH_CONTENT_TARGETS Catch2)
+        FetchContent_MakeAvailable(Catch2)
+        #fixes regression -preview4, to be confirmed in later releases
+        set_target_properties(Catch2 PROPERTIES DEBUG_POSTFIX "")
     endif()
 
-  set(FSFW_CONFIG_PATH unittests/testcfg)
-  configure_file(unittests/testcfg/FSFWConfig.h.in FSFWConfig.h)
-  configure_file(unittests/testcfg/TestsConfig.h.in tests/TestsConfig.h)
+    set(FSFW_CONFIG_PATH tests/src/fsfw_tests/unit/testcfg)
+    configure_file(tests/src/fsfw_tests/unit/testcfg/FSFWConfig.h.in FSFWConfig.h)
+    configure_file(tests/src/fsfw_tests/unit/testcfg/TestsConfig.h.in tests/TestsConfig.h)
 
     project(${FSFW_TEST_TGT} CXX C)
     add_executable(${FSFW_TEST_TGT})
-  if(IPO_SUPPORTED AND FSFW_ENABLE_IPO)
-    set_property(TARGET ${FSFW_TEST_TGT} PROPERTY INTERPROCEDURAL_OPTIMIZATION
-                                                  TRUE)
-  endif()
 
     if(FSFW_TESTS_GEN_COV)
         message(STATUS "${MSG_PREFIX} Generating coverage data for the library")
         message(STATUS "${MSG_PREFIX} Targets linking against ${LIB_FSFW_NAME} "
-                   "will be compiled with coverage data as well")
+            "will be compiled with coverage data as well"
+        )
         set(CMAKE_BUILD_TYPE "Debug")
         include(CodeCoverage)
     endif()
 endif()
 
-message(
-  STATUS
-    "${MSG_PREFIX} Finding and/or providing etl library with version ${FSFW_ETL_LIB_MAJOR_VERSION}"
-)
-
-# Check whether the user has already installed ETL first
-find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} QUIET)
-# Not installed, so use FetchContent to download and provide etl
-if(NOT ${FSFW_ETL_LIB_NAME}_FOUND)
-  message(
-    STATUS
-      "${MSG_PREFIX} No ETL installation was found with find_package. Installing and providing "
-      "etl with FindPackage")
-  include(FetchContent)
-
-  FetchContent_Declare(
-    ${FSFW_ETL_LIB_NAME}
-    GIT_REPOSITORY https://github.com/ETLCPP/etl
-    GIT_TAG ${FSFW_ETL_LIB_VERSION})
-
-  list(APPEND FSFW_FETCH_CONTENT_TARGETS ${FSFW_ETL_LIB_NAME})
-endif()
-
-# The documentation for FetchContent recommends declaring all the dependencies
-# before making them available. We make all declared dependency available here
-# after their declaration
-if(FSFW_FETCH_CONTENT_TARGETS)
-  FetchContent_MakeAvailable(${FSFW_FETCH_CONTENT_TARGETS})
-  if(TARGET ${FSFW_ETL_LIB_NAME})
-    add_library(${FSFW_ETL_LINK_TARGET} ALIAS ${FSFW_ETL_LIB_NAME})
-  endif()
-  if(TARGET Catch2)
-    # Fixes regression -preview4, to be confirmed in later releases Related
-    # GitHub issue: https://github.com/catchorg/Catch2/issues/2417
-    set_target_properties(Catch2 PROPERTIES DEBUG_POSTFIX "")
-  endif()
-endif()
-
 set(FSFW_CORE_INC_PATH "inc")
 
 set_property(CACHE FSFW_OSAL PROPERTY STRINGS host linux rtems freertos)
 
 # For configure files
-target_include_directories(${LIB_FSFW_NAME} PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
-target_include_directories(${LIB_FSFW_NAME}
-                           INTERFACE ${CMAKE_CURRENT_BINARY_DIR})
+target_include_directories(${LIB_FSFW_NAME} PRIVATE
+    ${CMAKE_CURRENT_BINARY_DIR}
+)
+target_include_directories(${LIB_FSFW_NAME} INTERFACE
+    ${CMAKE_CURRENT_BINARY_DIR}
+)
+
+if(NOT CMAKE_CXX_STANDARD)
+    set(CMAKE_CXX_STANDARD 11)
+    set(CMAKE_CXX_STANDARD_REQUIRED True)
+elseif(${CMAKE_CXX_STANDARD} LESS 11)
+    message(FATAL_ERROR "${MSG_PREFIX} Compiling the FSFW requires a minimum of C++11 support")
+endif()
 
 # Backwards comptability
 if(OS_FSFW AND NOT FSFW_OSAL)
-  message(
-    WARNING
-      "${MSG_PREFIX} Please pass the FSFW OSAL as FSFW_OSAL instead of OS_FSFW")
+    message(WARNING "${MSG_PREFIX} Please pass the FSFW OSAL as FSFW_OSAL instead of OS_FSFW")
     set(FSFW_OSAL OS_FSFW)
 endif()
 
 if(NOT FSFW_OSAL)
-  message(STATUS "No OS for FSFW via FSFW_OSAL set. Assuming host OS")
+	message(STATUS "${MSG_PREFIX} No OS for FSFW via FSFW_OSAL set. Assuming host OS")
 	# Assume host OS and autodetermine from OS_FSFW
 	if(UNIX)
-    set(FSFW_OSAL
-        "linux"
-        CACHE STRING "OS abstraction layer used in the FSFW")
+		set(FSFW_OSAL  "linux" 
+			CACHE STRING 
+			"OS abstraction layer used in the FSFW"
+		)
 	elseif(WIN32)
-    set(FSFW_OSAL
-        "host"
-        CACHE STRING "OS abstraction layer used in the FSFW")
+		set(FSFW_OSAL  "host" 
+			CACHE STRING "OS abstraction layer used in the FSFW"
+		)
 	endif()
+
 endif()
 
 set(FSFW_OSAL_DEFINITION FSFW_OSAL_HOST)
@@ -269,13 +168,14 @@ elseif(FSFW_OSAL MATCHES linux)
 elseif(FSFW_OSAL MATCHES freertos)
     set(FSFW_OS_NAME "FreeRTOS")
     set(FSFW_OSAL_FREERTOS ON)
-  target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${LIB_OS_NAME})
+    target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+        ${LIB_OS_NAME}
+    )
 elseif(FSFW_OSAL STREQUAL rtems)
     set(FSFW_OS_NAME "RTEMS")
     set(FSFW_OSAL_RTEMS ON)
 else()
-  message(
-    WARNING
+    message(WARNING
         "${MSG_PREFIX} Invalid operating system for FSFW specified! Setting to host.."
     )
     set(FSFW_OS_NAME "Host")
@@ -285,106 +185,113 @@ endif()
 configure_file(src/fsfw/FSFW.h.in fsfw/FSFW.h)
 configure_file(src/fsfw/FSFWVersion.h.in fsfw/FSFWVersion.h)
 
-message(
-  STATUS "${MSG_PREFIX} Compiling FSFW for the ${FSFW_OS_NAME} operating system"
-)
+message(STATUS "${MSG_PREFIX} Compiling FSFW for the ${FSFW_OS_NAME} operating system")
 
 add_subdirectory(src)
-add_subdirectory(contrib)
-if(FSFW_BUILD_TESTS)
-  add_subdirectory(unittests)
+add_subdirectory(tests)
+if(FSFW_ADD_HAL)
+    add_subdirectory(hal)
 endif()
+add_subdirectory(contrib)
 if(FSFW_BUILD_DOCS)
     add_subdirectory(docs)
 endif()
 
-if(FSFW_BUILD_TESTS)
+if(FSFW_BUILD_UNITTESTS)
     if(FSFW_TESTS_GEN_COV)
         if(CMAKE_COMPILER_IS_GNUCXX)
             include(CodeCoverage)
 
             # Remove quotes.
-      separate_arguments(COVERAGE_COMPILER_FLAGS NATIVE_COMMAND
-                         "${COVERAGE_COMPILER_FLAGS}")
+            separate_arguments(COVERAGE_COMPILER_FLAGS
+                NATIVE_COMMAND "${COVERAGE_COMPILER_FLAGS}"
+            )
 
             # Add compile options manually, we don't want coverage for Catch2
-      target_compile_options(${FSFW_TEST_TGT}
-                             PRIVATE "${COVERAGE_COMPILER_FLAGS}")
-      target_compile_options(${LIB_FSFW_NAME}
-                             PRIVATE "${COVERAGE_COMPILER_FLAGS}")
+            target_compile_options(${FSFW_TEST_TGT} PRIVATE
+                "${COVERAGE_COMPILER_FLAGS}"
+            )
+            target_compile_options(${LIB_FSFW_NAME} PRIVATE
+                "${COVERAGE_COMPILER_FLAGS}"
+            )
 
             # Exclude directories here
             if(WIN32)
-        set(GCOVR_ADDITIONAL_ARGS "--exclude-throw-branches"
-                                  "--exclude-unreachable-branches")
-        set(COVERAGE_EXCLUDES "/c/msys64/mingw64/*" "*/fsfw_hal/*")
+                set(GCOVR_ADDITIONAL_ARGS
+                    "--exclude-throw-branches"
+                    "--exclude-unreachable-branches"
+                )
+                set(COVERAGE_EXCLUDES
+                    "/c/msys64/mingw64/*" "*/fsfw_hal/*"
+                )
             elseif(UNIX)
                 set(COVERAGE_EXCLUDES
-            "/usr/include/*"
-            "/usr/bin/*"
-            "Catch2/*"
-            "/usr/local/include/*"
-            "*/fsfw_tests/*"
-            "*/catch2-src/*"
-            "*/fsfw_hal/*")
+                    "/usr/include/*" "/usr/bin/*" "Catch2/*"
+                    "/usr/local/include/*" "*/fsfw_tests/*"
+                    "*/catch2-src/*" "*/fsfw_hal/*"
+                )
             endif()
 
-      target_link_options(${FSFW_TEST_TGT} PRIVATE -fprofile-arcs
-                          -ftest-coverage)
-      target_link_options(${LIB_FSFW_NAME} PRIVATE -fprofile-arcs
-                          -ftest-coverage)
-      # Need to specify this as an interface, otherwise there will the compile
-      # issues
-      target_link_options(${LIB_FSFW_NAME} INTERFACE -fprofile-arcs
-                          -ftest-coverage)
+            target_link_options(${FSFW_TEST_TGT} PRIVATE
+                -fprofile-arcs
+                -ftest-coverage
+            )
+            target_link_options(${LIB_FSFW_NAME} PRIVATE
+                -fprofile-arcs
+                -ftest-coverage
+            )
+            # Need to specify this as an interface, otherwise there will the compile issues
+            target_link_options(${LIB_FSFW_NAME} INTERFACE
+                -fprofile-arcs
+                -ftest-coverage
+            )
 
             if(WIN32)
                 setup_target_for_coverage_gcovr_html(
-          NAME ${FSFW_TEST_TGT}_coverage EXECUTABLE ${FSFW_TEST_TGT}
-          DEPENDENCIES ${FSFW_TEST_TGT})
+                    NAME ${FSFW_TEST_TGT}_coverage
+                    EXECUTABLE ${FSFW_TEST_TGT}
+                    DEPENDENCIES ${FSFW_TEST_TGT}
+                )
             else()
                 setup_target_for_coverage_lcov(
-          NAME ${FSFW_TEST_TGT}_coverage EXECUTABLE ${FSFW_TEST_TGT}
-          DEPENDENCIES ${FSFW_TEST_TGT})
+                    NAME ${FSFW_TEST_TGT}_coverage
+                    EXECUTABLE ${FSFW_TEST_TGT}
+                    DEPENDENCIES ${FSFW_TEST_TGT}
+                )
             endif()
         endif()
     endif()
-  target_link_libraries(${FSFW_TEST_TGT} PRIVATE Catch2::Catch2
-                                                 ${LIB_FSFW_NAME})
+    target_link_libraries(${FSFW_TEST_TGT} PRIVATE Catch2::Catch2 ${LIB_FSFW_NAME})
 endif()
 
-# The project CMakeLists file has to set the FSFW_CONFIG_PATH and add it. If
-# this is not given, we include the default configuration and emit a warning.
+# The project CMakeLists file has to set the FSFW_CONFIG_PATH and add it.
+# If this is not given, we include the default configuration and emit a warning.
 if(NOT FSFW_CONFIG_PATH)
     set(DEF_CONF_PATH misc/defaultcfg/fsfwconfig)
     if(NOT FSFW_BUILD_DOCS)
-    message(
-      WARNING
-        "${MSG_PREFIX} Flight Software Framework configuration path FSFW_CONFIG_PATH not set"
-    )
-    message(
-      WARNING
-        "${MSG_PREFIX} Setting default configuration from ${DEF_CONF_PATH} ..")
+        message(WARNING "${MSG_PREFIX} Flight Software Framework configuration path not set")
+        message(WARNING "${MSG_PREFIX} Setting default configuration from ${DEF_CONF_PATH} ..")
     endif()
     add_subdirectory(${DEF_CONF_PATH})
     set(FSFW_CONFIG_PATH ${DEF_CONF_PATH})
 endif()
 
-# FSFW might be part of a possibly complicated folder structure, so we extract
-# the absolute path of the fsfwconfig folder.
+# FSFW might be part of a possibly complicated folder structure, so we 
+# extract the absolute path of the fsfwconfig folder.
 if(IS_ABSOLUTE ${FSFW_CONFIG_PATH})
 	set(FSFW_CONFIG_PATH_ABSOLUTE ${FSFW_CONFIG_PATH})
 else()
-  get_filename_component(FSFW_CONFIG_PATH_ABSOLUTE ${FSFW_CONFIG_PATH} REALPATH
-                         BASE_DIR ${CMAKE_SOURCE_DIR})
+	get_filename_component(FSFW_CONFIG_PATH_ABSOLUTE
+		${FSFW_CONFIG_PATH} REALPATH BASE_DIR ${CMAKE_SOURCE_DIR}
+	)
 endif()
 
 foreach(INCLUDE_PATH ${FSFW_ADDITIONAL_INC_PATHS})
     if(IS_ABSOLUTE ${INCLUDE_PATH})
         set(CURR_ABS_INC_PATH "${INCLUDE_PATH}")
     else()
-    get_filename_component(CURR_ABS_INC_PATH ${INCLUDE_PATH} REALPATH BASE_DIR
-                           ${CMAKE_SOURCE_DIR})
+        get_filename_component(CURR_ABS_INC_PATH
+            ${INCLUDE_PATH} REALPATH BASE_DIR ${CMAKE_SOURCE_DIR})
     endif()
 
     if(CMAKE_VERBOSE)
@@ -417,19 +324,23 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
           -Wcast-qual # Warn if the constness is cast away
           -Wstringop-overflow=4
           # -Wstack-protector # Emits a few false positives for low level access
-        # -Wconversion # Creates many false positives -Warith-conversion # Use
-        # with Wconversion to find more implicit conversions -fanalyzer # Should
-        # be used to look through problems
+          # -Wconversion # Creates many false positives
+          # -Warith-conversion # Use with Wconversion to find more implicit conversions
+          # -fanalyzer # Should be used to look through problems
         )
     endif()
 
     if(FSFW_GENERATE_SECTIONS)
-    target_compile_options(${LIB_FSFW_NAME} PRIVATE "-ffunction-sections"
-                                                    "-fdata-sections")
+        target_compile_options(${LIB_FSFW_NAME} PRIVATE
+            "-ffunction-sections"
+            "-fdata-sections"
+        )
     endif()
 
     if(FSFW_REMOVE_UNUSED_CODE)
-    target_link_options(${LIB_FSFW_NAME} PRIVATE "Wl,--gc-sections")
+        target_link_options(${LIB_FSFW_NAME} PRIVATE
+            "Wl,--gc-sections"
+        )
     endif()
   
     if(FSFW_WARNING_SHADOW_LOCAL_GCC)
@@ -443,31 +354,41 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
 endif()
 
 # Required include paths to compile the FSFW
-target_include_directories(
-  ${LIB_FSFW_NAME} INTERFACE ${CMAKE_SOURCE_DIR} ${FSFW_CONFIG_PATH_ABSOLUTE}
-                             ${FSFW_CORE_INC_PATH} ${FSFW_ADD_INC_PATHS_ABS})
+target_include_directories(${LIB_FSFW_NAME} INTERFACE 
+	${CMAKE_SOURCE_DIR}
+	${FSFW_CONFIG_PATH_ABSOLUTE}
+	${FSFW_CORE_INC_PATH}
+	${FSFW_ADD_INC_PATHS_ABS}
+)
 
-# Includes path required to compile FSFW itself as well We assume that the
-# fsfwconfig folder uses include relative to the project root here!
-target_include_directories(
-  ${LIB_FSFW_NAME} PRIVATE ${CMAKE_SOURCE_DIR} ${FSFW_CONFIG_PATH_ABSOLUTE}
-                           ${FSFW_CORE_INC_PATH} ${FSFW_ADD_INC_PATHS_ABS})
+# Includes path required to compile FSFW itself as well
+# We assume that the fsfwconfig folder uses include relative to the project
+# root here!
+target_include_directories(${LIB_FSFW_NAME} PRIVATE 
+	${CMAKE_SOURCE_DIR}
+	${FSFW_CONFIG_PATH_ABSOLUTE}
+	${FSFW_CORE_INC_PATH}
+	${FSFW_ADD_INC_PATHS_ABS}
+)
 
-target_compile_options(${LIB_FSFW_NAME} PRIVATE ${FSFW_WARNING_FLAGS}
-                                                ${COMPILER_FLAGS})
+target_compile_options(${LIB_FSFW_NAME} PRIVATE 
+	${FSFW_WARNING_FLAGS}
+	${COMPILER_FLAGS}
+)
 
-target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${FSFW_ADDITIONAL_LINK_LIBS})
-target_link_libraries(${LIB_FSFW_NAME} PUBLIC ${FSFW_ETL_LINK_TARGET})
+target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+    ${FSFW_ADDITIONAL_LINK_LIBS}
+)
 
-string(
-  CONCAT
-    POST_BUILD_COMMENT
+string(CONCAT POST_BUILD_COMMENT
     "######################################################################\n"
     "Built FSFW v${FSFW_VERSION}.${FSFW_SUBVERSION}.${FSFW_REVISION}, "
     "Target OSAL: ${FSFW_OS_NAME}\n"
-    "######################################################################\n")
+    "######################################################################\n"
+)
 
 add_custom_command(
    TARGET ${LIB_FSFW_NAME}
    POST_BUILD
-  COMMENT ${POST_BUILD_COMMENT})
+   COMMENT ${POST_BUILD_COMMENT}
+)

README.md

@@ -11,15 +11,9 @@ with Airbus Defence and Space GmbH.
 
 ## Quick facts
 
-The framework is designed for systems, which communicate with external devices, perform control loops, 
-receive telecommands and send telemetry, and need to maintain a high level of availability. Therefore,
-a mode and health system provides control over the states of the software and the controlled devices.
-In addition, a simple mechanism of event based fault detection, isolation and recovery is implemented as well. 
+The framework is designed for systems, which communicate with external devices, perform control loops, receive telecommands and send telemetry, and need to maintain a high level of availability. Therefore, a mode and health system provides control over the states of the software and the controlled devices. In addition, a simple mechanism of event based fault detection, isolation and recovery is implemented as well. 
 
-The FSFW provides abstraction layers for operating systems to provide a uniform operating system
-abstraction layer (OSAL). Some components of this OSAL are required internally by the FSFW but is
-also very useful for developers to implement the same application logic on different operating
-systems with a uniform interface.
+The FSFW provides abstraction layers for operating systems to provide a uniform operating system abstraction layer (OSAL). Some components of this OSAL are required internally by the FSFW but is also very useful for developers to implement the same application logic on different operating systems with a uniform interface.
 
 Currently, the FSFW provides the following OSALs:
 
@@ -51,28 +45,6 @@ A template configuration folder was provided and can be copied into the project
 a starting point. The [configuration section](docs/README-config.md#top) provides more specific 
 information about the possible options.
 
-## Prerequisites
-
-The Embedded Template Library (etl) is a dependency of the FSFW which is automatically
-installed and provided by the build system unless the correction version was installed.
-The current recommended version can be found inside the fsfw `CMakeLists.txt` file or by using
-`ccmake` and looking up the `FSFW_ETL_LIB_MAJOR_VERSION` variable.
-
-You can install the ETL library like this. On Linux, it might be necessary to add `sudo` before
-the install call:
-
-```cpp
-git clone https://github.com/ETLCPP/etl
-cd etl
-git checkout <currentRecommendedVersion>
-mkdir build && cd build
-cmake ..
-cmake --install .
-```
-
-It is recommended to install `20.27.2` or newer for the package version handling of
-ETL to work.
-
 ## Adding the library
 
 The following steps show how to add and use FSFW components. It is still recommended to
@@ -99,7 +71,7 @@ add and link against the FSFW library in general.
 
 4. Link against the FSFW library
 
-   ```sh
+   ```cmake
    target_link_libraries(${YourProjectName} PRIVATE fsfw)
    ```
 
@@ -111,19 +83,6 @@ The FSFW also has unittests which use the [Catch2 library](https://github.com/ca
 These are built by setting the CMake option `FSFW_BUILD_UNITTESTS` to `ON` or `TRUE`
 from your project `CMakeLists.txt` file or from the command line.
 
-You can install the Catch2 library, which prevents the build system to avoid re-downloading
-the dependency if the unit tests are completely rebuilt. The current recommended version
-can be found inside the fsfw `CMakeLists.txt` file or by using `ccmake` and looking up
-the `FSFW_CATCH2_LIB_VERSION` variable.
-
-```sh
-git clone https://github.com/catchorg/Catch2.git
-cd Catch2
-git checkout <currentRecommendedVersion>
-cmake -Bbuild -H. -DBUILD_TESTING=OFF
-sudo cmake --build build/ --target install
-```
-
 The fsfw-tests binary will be built as part of the static library and dropped alongside it.
 If the unittests are built, the library and the tests will be built with coverage information by
 default. This can be disabled by setting the `FSFW_TESTS_COV_GEN` option to `OFF` or `FALSE`.
@@ -131,15 +90,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
-cmake -DFSFW_BUILD_TESTS=ON -DFSFW_OSAL=host -DCMAKE_BUILD_TYPE=Debug ..
+mkdir build-Unittest && cd build-Unittest
+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
@@ -175,7 +134,7 @@ cmake -DFSFW_BUILD_DOCS=ON -DFSFW_OSAL=host ..
 Then you can generate the documentation using
 
 ```sh
-cmake --build . -- Sphinx -j
+cmake --build . -j
 ```
 
 You can find the generated documentation inside the `docs/sphinx` folder inside the build
@@ -188,10 +147,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:
-````sh
-sudo pip install cmakelang
-````
+can run the `apply-clang-format.sh` helper script to format all source files consistently.
 
 ## Index
 

automation/Dockerfile

@@ -5,25 +5,4 @@ RUN apt-get --yes upgrade
 
 #tzdata is a dependency, won't install otherwise
 ARG DEBIAN_FRONTEND=noninteractive
-RUN apt-get --yes install gcc g++ cmake make lcov git valgrind nano iputils-ping python3 pip doxygen graphviz rsync
-
-RUN python3 -m pip install sphinx breathe
-
-RUN git clone https://github.com/catchorg/Catch2.git && \
-        cd Catch2 && \
-        git checkout v3.1.0 && \
-        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/
-
-#ssh needs a valid user to work
-RUN adduser --uid 114 jenkins
-
-#add documentation server to known hosts
-RUN echo "|1|/LzCV4BuTmTb2wKnD146l9fTKgQ=|NJJtVjvWbtRt8OYqFgcYRnMQyVw= ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBNL8ssTonYtgiR/6RRlSIK9WU1ywOcJmxFTLcEblAwH7oifZzmYq3XRfwXrgfMpylEfMFYfCU8JRqtmi19xc21A=" >> /etc/ssh/ssh_known_hosts
-RUN echo "|1|CcBvBc3EG03G+XM5rqRHs6gK/Gg=|oGeJQ+1I8NGI2THIkJsW92DpTzs= ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBNL8ssTonYtgiR/6RRlSIK9WU1ywOcJmxFTLcEblAwH7oifZzmYq3XRfwXrgfMpylEfMFYfCU8JRqtmi19xc21A=" >> /etc/ssh/ssh_known_hosts
+RUN apt-get --yes install gcc g++ cmake make lcov git valgrind nano iputils-ping

automation/Jenkinsfile

@@ -1,13 +1,9 @@
 pipeline {
     environment {
-        BUILDDIR = 'cmake-build-tests'
-        DOCDDIR = 'cmake-build-documentation'
+        BUILDDIR = 'build-tests'
     }
     agent {
-        docker { 
-            image 'fsfw-ci:d5'
-            args '--network host'
-        }
+        docker { image 'fsfw-ci:d1'}
     }
     stages {
         stage('Clean') {
@@ -18,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 ..'
                 }
             }
         }
@@ -43,47 +39,5 @@ pipeline {
                 }
             }
         }
-        stage('Documentation') {
-            when {
-                branch 'development'
-            }
-            steps {
-                dir(DOCDDIR) {
-                    sh 'cmake -DFSFW_BUILD_DOCS=ON -DFSFW_OSAL=host ..'
-                    sh 'make Sphinx'
-                    sshagent(credentials: ['documentation-buildfix']) {
-                        sh 'ssh -o StrictHostKeyChecking=no buildfix@documentation.intra.irs.uni-stuttgart.de rm -rf /mnt/data/www/html/fsfw/development/*'
-                        sh 'scp -o StrictHostKeyChecking=no -r docs/sphinx/* buildfix@documentation.intra.irs.uni-stuttgart.de:/mnt/data/www/html/fsfw/development'
-                    }
-                }
-                dir(BUILDDIR) {
-                    sshagent(credentials: ['documentation-buildfix']) {
-                        sh 'ssh -o StrictHostKeyChecking=no buildfix@documentation.intra.irs.uni-stuttgart.de rm -rf /mnt/data/www/html/fsfw/coverage/development/*'
-                        sh 'scp -o StrictHostKeyChecking=no -r fsfw-tests_coverage/* buildfix@documentation.intra.irs.uni-stuttgart.de:/mnt/data/www/html/fsfw/coverage/development'
-                    }
-                }
-            }
-        }
-        stage('Master Documentation') {
-            when {
-                branch 'master'
-            }
-            steps {
-                dir(DOCDDIR) {
-                    sh 'cmake -DFSFW_BUILD_DOCS=ON -DFSFW_OSAL=host ..'
-                    sh 'make Sphinx'
-                    sshagent(credentials: ['documentation-buildfix']) {
-                        sh 'ssh -o StrictHostKeyChecking=no buildfix@documentation.intra.irs.uni-stuttgart.de rm -rf /mnt/data/www/html/fsfw/master/*'
-                        sh 'scp -o StrictHostKeyChecking=no -r docs/sphinx/* buildfix@documentation.intra.irs.uni-stuttgart.de:/mnt/data/www/html/fsfw/master'
-                    }
-                }
-                dir(BUILDDIR) {
-                    sshagent(credentials: ['documentation-buildfix']) {
-                        sh 'ssh -o StrictHostKeyChecking=no buildfix@documentation.intra.irs.uni-stuttgart.de rm -rf /mnt/data/www/html/fsfw/coverage/master/*'
-                        sh 'scp -o StrictHostKeyChecking=no -r fsfw-tests_coverage/* buildfix@documentation.intra.irs.uni-stuttgart.de:/mnt/data/www/html/fsfw/coverage/master'
-                    }
-                }
-            }
-        }
     }
 }

cmake/cmake-modules/GetGitRevisionDescription.cmake

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

cmake/cmake-modules/GetGitRevisionDescription.cmake.in

@@ -8,12 +8,10 @@
 # http://academic.cleardefinition.com
 # Iowa State University HCI Graduate Program/VRAC
 #
-# Copyright 2009-2012, Iowa State University
-# Copyright 2011-2015, Contributors
+# Copyright Iowa State University 2009-2010.
 # Distributed under the Boost Software License, Version 1.0.
 # (See accompanying file LICENSE_1_0.txt or copy at
 # http://www.boost.org/LICENSE_1_0.txt)
-# SPDX-License-Identifier: BSL-1.0
 
 set(HEAD_HASH)
 
@@ -25,12 +23,9 @@ if(HEAD_CONTENTS MATCHES "ref")
     string(REPLACE "ref: " "" HEAD_REF "${HEAD_CONTENTS}")
     if(EXISTS "@GIT_DIR@/${HEAD_REF}")
     configure_file("@GIT_DIR@/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY)
-    else()
-        configure_file("@GIT_DIR@/packed-refs" "@GIT_DATA@/packed-refs" COPYONLY)
-        file(READ "@GIT_DATA@/packed-refs" PACKED_REFS)
-        if(${PACKED_REFS} MATCHES "([0-9a-z]*) ${HEAD_REF}")
-            set(HEAD_HASH "${CMAKE_MATCH_1}")
-        endif()
+    elseif(EXISTS "@GIT_DIR@/logs/${HEAD_REF}")
+        configure_file("@GIT_DIR@/logs/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY)
+        set(HEAD_HASH "${HEAD_REF}")
     endif()
 else()
     # detached HEAD

cmake/cmake-modules/README.md

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

cmake/cmake-modules/rpavlik/GetGitRevisionDescription.cmake

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

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

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

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

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

cmake/cmake-modules/rpavlik/LICENSE_1_0.txt

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

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/conf.py

@@ -50,11 +50,6 @@ exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
 #
 html_theme = 'alabaster'
 
-html_theme_options = {
-    "extra_nav_links": {"Impressum" : "https://www.uni-stuttgart.de/impressum", "Datenschutz": "https://info.irs.uni-stuttgart.de/datenschutz/datenschutzWebmit.html"}
-}
-
-
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".

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

@@ -19,29 +19,6 @@ A template configuration folder was provided and can be copied into the project
 a starting point. The [configuration section](docs/README-config.md#top) provides more specific 
 information about the possible options.
 
-Prerequisites
--------------------
-
-The Embedded Template Library (etl) is a dependency of the FSFW which is automatically
-installed and provided by the build system unless the correction version was installed.
-The current recommended version can be found inside the fsfw ``CMakeLists.txt`` file or by using
-``ccmake`` and looking up the ``FSFW_ETL_LIB_MAJOR_VERSION`` variable.
-
-You can install the ETL library like this. On Linux, it might be necessary to add ``sudo`` before
-the install call:
-
-.. code-block:: console
-
-   git clone https://github.com/ETLCPP/etl
-   cd etl
-   git checkout <currentRecommendedVersion>
-   mkdir build && cd build
-   cmake ..
-   cmake --install .
-
-It is recommended to install ``20.27.2`` or newer for the package version handling of
-ETL to work.
-
 Adding the library
 -------------------
 
@@ -83,20 +60,6 @@ The FSFW also has unittests which use the `Catch2 library`_.
 These are built by setting the CMake option ``FSFW_BUILD_UNITTESTS`` to ``ON`` or `TRUE`
 from your project `CMakeLists.txt` file or from the command line.
 
-You can install the Catch2 library, which prevents the build system to avoid re-downloading
-the dependency if the unit tests are completely rebuilt. The current recommended version
-can be found inside the fsfw ``CMakeLists.txt`` file or by using ``ccmake`` and looking up
-the ``FSFW_CATCH2_LIB_VERSION`` variable.
-
-.. code-block:: console
-
-   git clone https://github.com/catchorg/Catch2.git
-   cd Catch2
-   git checkout <currentRecommendedVersion>
-   cmake -Bbuild -H. -DBUILD_TESTING=OFF
-   sudo cmake --build build/ --target install
-
-
 The fsfw-tests binary will be built as part of the static library and dropped alongside it.
 If the unittests are built, the library and the tests will be built with coverage information by
 default. This can be disabled by setting the `FSFW_TESTS_COV_GEN` option to `OFF` or `FALSE`.
@@ -106,7 +69,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/common/CMakeLists.txt

@@ -0,0 +1 @@
+add_subdirectory(gpio)

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,7 +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}));
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_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 (std::abs(mgmX) > absLimitX or std::abs(mgmY) > absLimitY or
-            std::abs(mgmZ) > absLimitZ) {
-          dataset.fieldStrengths.setValid(false);
-        }
+      if (readHelper.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
         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) {
@@ -371,13 +375,16 @@ float MgmLIS3MDLHandler::getSensitivityFactor(MGMLIS3MDL::Sensitivies sens) {
 
 ReturnValue_t MgmLIS3MDLHandler::enableTemperatureSensor(const uint8_t *commandData,
                                                          size_t commandDataLen) {
+  if(commandData == nullptr) {
+    return INVALID_COMMAND_PARAMETER;
+  }
   triggerEvent(CHANGE_OF_SETUP_PARAMETER);
   uint32_t size = 2;
   commandBuffer[0] = writeCommand(MGMLIS3MDL::CTRL_REG1);
   if (commandDataLen > 1) {
     return INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS;
   }
-  switch (*commandData) {
+  switch (commandData[0]) {
     case (MGMLIS3MDL::ON): {
       commandBuffer[1] = registers[0] | (1 << 7);
       break;
@@ -394,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,
@@ -451,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) {
@@ -464,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::TEMPERATURE_CELCIUS, &temperature);
-  poolManager.subscribeForRegularPeriodicPacket({dataset.getSid(), false, 10.0});
-  return returnvalue::OK;
+  localDataPoolMap.emplace(MGMLIS3MDL::FIELD_STRENGTH_X, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(MGMLIS3MDL::FIELD_STRENGTH_Y, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(MGMLIS3MDL::FIELD_STRENGTH_Z, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(MGMLIS3MDL::TEMPERATURE_CELCIUS, new PoolEntry<float>({0.0}));
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 void MgmLIS3MDLHandler::setAbsoluteLimits(float xLimit, float yLimit, float zLimit) {

hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h

@@ -2,6 +2,7 @@
 #define MISSION_DEVICES_MGMLIS3MDLHANDLER_H_
 
 #include "devicedefinitions/MgmLIS3HandlerDefs.h"
+#include "events/subsystemIdRanges.h"
 #include "fsfw/devicehandlers/DeviceHandlerBase.h"
 #include "fsfw/globalfunctions/PeriodicOperationDivider.h"
 
@@ -102,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);
-  poolManager.subscribeForRegularPeriodicPacket({primaryDataset.getSid(), false, 10.0});
-  return returnvalue::OK;
+  localDataPoolMap.emplace(RM3100::FIELD_STRENGTH_X, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(RM3100::FIELD_STRENGTH_Y, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(RM3100::FIELD_STRENGTH_Z, new PoolEntry<float>({0.0}));
+  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) {
-    primaryDataset.fieldStrengths[0] = fieldStrengthX;
-    primaryDataset.fieldStrengths[1] = fieldStrengthY;
-    primaryDataset.fieldStrengths[2] = fieldStrengthZ;
+  if (readGuard.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+    primaryDataset.fieldStrengthX = fieldStrengthX;
+    primaryDataset.fieldStrengthY = fieldStrengthY;
+    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)) {}
 
-  /**
-   * Field strenghts in uT
-   */
-  lp_vec_t<float, 3> fieldStrengths = lp_vec_t<float, 3>(sid.objectId, FIELD_STRENGTHS, this);
+  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_var_t<float> fieldStrengthZ = lp_var_t<float>(sid.objectId, FIELD_STRENGTH_Z, 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 strenghts in uT
-   */
-  lp_vec_t<float, 3> fieldStrengths = lp_vec_t<float, 3>(sid.objectId, FIELD_STRENGTHS, this);
+  // Field strengths in micro Tesla.
+  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_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,20 @@
+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(spi)
+	add_subdirectory(i2c)
+	add_subdirectory(uart)
+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() {
@@ -35,7 +35,7 @@ ReturnValue_t CommandExecutor::execute() {
   currentCmdFile = popen(currentCmd.c_str(), "r");
   if (currentCmdFile == nullptr) {
     lastError = errno;
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
   if (blocking) {
     ReturnValue_t result = executeBlocking();
@@ -46,7 +46,7 @@ ReturnValue_t CommandExecutor::execute() {
     waiter.fd = currentFd;
   }
   state = States::PENDING;
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t CommandExecutor::close() {
@@ -56,7 +56,7 @@ ReturnValue_t CommandExecutor::close() {
       pclose(currentCmdFile);
     }
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 void CommandExecutor::printLastError(std::string funcName) const {
@@ -79,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):
@@ -94,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): {
@@ -151,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;
@@ -161,7 +161,7 @@ ReturnValue_t CommandExecutor::check(bool& replyReceived) {
       break;
     }
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 void CommandExecutor::reset() {
@@ -201,7 +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;
 }

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 PCLOSE_CALL_ERROR = returnvalue::makeCode(CLASS_ID, 6);
+  static constexpr ReturnValue_t NO_COMMAND_LOADED_OR_PENDING =
+      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
-   *  - returnvalue::FAILED if execution has failed, error value can be accessed using getLastError
+   *  - RETURN_OK execution is pending, but no bytes have been read from the executing process
+   *  - 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();
 

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/Gpio.h

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

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

@@ -20,33 +20,30 @@ 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 returnvalue::FAILED;
+    return RETURN_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) {
-    return returnvalue::FAILED;
+  if (result != RETURN_OK) {
+    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;
   for (auto& gpioConfig : mapToAdd) {
     auto& gpioType = gpioConfig.second->gpioType;
     switch (gpioType) {
@@ -58,7 +55,7 @@ ReturnValue_t LinuxLibgpioIF::configureGpios(GpioMap& mapToAdd) {
         if (regularGpio == nullptr) {
           return GPIO_INVALID_INSTANCE;
         }
-        result = configureGpioByChip(gpioConfig.first, *regularGpio);
+        configureGpioByChip(gpioConfig.first, *regularGpio);
         break;
       }
       case (gpio::GpioTypes::GPIO_REGULAR_BY_LABEL): {
@@ -66,7 +63,7 @@ ReturnValue_t LinuxLibgpioIF::configureGpios(GpioMap& mapToAdd) {
         if (regularGpio == nullptr) {
           return GPIO_INVALID_INSTANCE;
         }
-        result = configureGpioByLabel(gpioConfig.first, *regularGpio);
+        configureGpioByLabel(gpioConfig.first, *regularGpio);
         break;
       }
       case (gpio::GpioTypes::GPIO_REGULAR_BY_LINE_NAME): {
@@ -74,7 +71,7 @@ ReturnValue_t LinuxLibgpioIF::configureGpios(GpioMap& mapToAdd) {
         if (regularGpio == nullptr) {
           return GPIO_INVALID_INSTANCE;
         }
-        result = configureGpioByLineName(gpioConfig.first, *regularGpio);
+        configureGpioByLineName(gpioConfig.first, *regularGpio);
         break;
       }
       case (gpio::GpioTypes::CALLBACK): {
@@ -86,11 +83,8 @@ ReturnValue_t LinuxLibgpioIF::configureGpios(GpioMap& mapToAdd) {
                                gpioCallback->initValue, gpioCallback->callbackArgs);
       }
     }
-    if (result != returnvalue::OK) {
-      return GPIO_INIT_FAILED;
   }
-  }
-  return result;
+  return RETURN_OK;
 }
 
 ReturnValue_t LinuxLibgpioIF::configureGpioByLabel(gpioId_t gpioId,
@@ -98,11 +92,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 returnvalue::FAILED;
+    return RETURN_FAILED;
   }
   std::string failOutput = "label: " + label;
   return configureRegularGpio(gpioId, chip, gpioByLabel, failOutput);
@@ -112,11 +104,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 returnvalue::FAILED;
+    return RETURN_FAILED;
   }
   std::string failOutput = "chipname: " + chipname;
   return configureRegularGpio(gpioId, chip, gpioByChip, failOutput);
@@ -132,18 +122,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 returnvalue::FAILED;
+    return RETURN_FAILED;
   }
   std::string failOutput = "line name: " + lineName;
   return configureRegularGpio(gpioId, chip, gpioByLineName, failOutput);
@@ -161,14 +149,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 +171,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 +186,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 +194,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 +220,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 +252,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 +273,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, int* gpioState) {
@@ -321,14 +303,14 @@ ReturnValue_t LinuxLibgpioIF::readGpio(gpioId_t gpioId, int* 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 result = returnvalue::OK;
+  ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
   for (auto& gpioConfig : mapToAdd) {
     switch (gpioConfig.second->gpioType) {
       case (gpio::GpioTypes::GPIO_REGULAR_BY_CHIP):
@@ -340,7 +322,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;
@@ -352,7 +334,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;
@@ -426,7 +408,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,12 +19,16 @@ 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 DRIVE_GPIO_FAILURE = returnvalue::makeCode(gpioRetvalId, 2);
-  static constexpr ReturnValue_t GPIO_TYPE_FAILURE = returnvalue::makeCode(gpioRetvalId, 3);
-  static constexpr ReturnValue_t GPIO_INVALID_INSTANCE = returnvalue::makeCode(gpioRetvalId, 4);
-  static constexpr ReturnValue_t GPIO_DUPLICATE_DETECTED = returnvalue::makeCode(gpioRetvalId, 5);
-  static constexpr ReturnValue_t GPIO_INIT_FAILED = returnvalue::makeCode(gpioRetvalId, 6);
+  static constexpr ReturnValue_t UNKNOWN_GPIO_ID =
+      HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 1);
+  static constexpr ReturnValue_t DRIVE_GPIO_FAILURE =
+      HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 2);
+  static constexpr ReturnValue_t GPIO_TYPE_FAILURE =
+      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);
 
   LinuxLibgpioIF(object_id_t objectId);
   virtual ~LinuxLibgpioIF();
@@ -65,7 +69,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;
   }
@@ -182,7 +182,7 @@ ReturnValue_t I2cComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLe
     sif::debug << "I2cComIF::requestReceiveMessage: Read " << readLen << " of " << requestLen
                << " bytes" << std::endl;
 #endif
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
 
 #if FSFW_HAL_I2C_WIRETAPPING == 1
@@ -191,7 +191,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) {
@@ -210,12 +210,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,
@@ -231,7 +231,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 */
@@ -87,7 +87,7 @@ ReturnValue_t SpiComIF::initializeInterface(CookieIF* cookie) {
   int fileDescriptor = 0;
   UnixFileGuard fileHelper(spiCookie->getSpiDevice(), &fileDescriptor, O_RDWR,
                            "SpiComIF::initializeInterface");
-  if (fileHelper.getOpenResult() != returnvalue::OK) {
+  if (fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
     return fileHelper.getOpenResult();
   }
 
@@ -129,12 +129,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;
@@ -178,13 +178,13 @@ 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;
   std::string device = spiCookie->getSpiDevice();
   UnixFileGuard fileHelper(device, &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;
@@ -200,7 +200,7 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
   /* Pull SPI CS low. For now, no support for active high given  */
   if (gpioId != gpio::NO_GPIO) {
     result = spiMutex->lockMutex(timeoutType, timeoutMs);
-    if (result != returnvalue::OK) {
+    if (result != RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::error << "SpiComIF::sendMessage: Failed to lock mutex" << std::endl;
@@ -210,8 +210,8 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
 #endif
       return result;
     }
-    result = gpioComIF->pullLow(gpioId);
-    if (result != returnvalue::OK) {
+    ReturnValue_t result = gpioComIF->pullLow(gpioId);
+    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;
@@ -251,7 +251,7 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
   if (gpioId != gpio::NO_GPIO) {
     gpioComIF->pullHigh(gpioId);
     result = spiMutex->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
@@ -261,7 +261,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);
@@ -270,32 +270,32 @@ 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;
   std::string device = spiCookie->getSpiDevice();
   int fileDescriptor = 0;
   UnixFileGuard fileHelper(device, &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;
   }
 
   gpioId_t gpioId = spiCookie->getChipSelectPin();
   if (gpioId != gpio::NO_GPIO) {
     result = spiMutex->lockMutex(timeoutType, timeoutMs);
-    if (result != returnvalue::OK) {
+    if (result != RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::error << "SpiComIF::getSendSuccess: Failed to lock mutex" << std::endl;
 #endif
@@ -318,7 +318,7 @@ ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
   if (gpioId != gpio::NO_GPIO) {
     gpioComIF->pullHigh(gpioId);
     result = spiMutex->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
@@ -332,18 +332,18 @@ 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::getMutex(MutexIF::TimeoutType* timeoutType, uint32_t* timeoutMs) {
@@ -377,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; }

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, GpioIF* gpioComIF);
 

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

@@ -1,4 +1,4 @@
-#include "SpiCookie.h"
+#include "fsfw_hal/linux/spi/SpiCookie.h"
 
 SpiCookie::SpiCookie(address_t spiAddress, gpioId_t chipSelect, std::string spiDev,
                      const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed)

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) {
@@ -265,7 +265,6 @@ void UartComIF::configureBaudrate(struct termios* options, UartCookie* uartCooki
       cfsetispeed(options, B230400);
       cfsetospeed(options, B230400);
       break;
-#ifndef __APPLE__
     case UartBaudRate::RATE_460800:
       cfsetispeed(options, B460800);
       cfsetospeed(options, B460800);
@@ -314,7 +313,6 @@ void UartComIF::configureBaudrate(struct termios* options, UartCookie* uartCooki
       cfsetispeed(options, B4000000);
       cfsetospeed(options, B4000000);
       break;
-#endif  // ! __APPLE__
     default:
 #if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::warning << "UartComIF::configureBaudrate: Baudrate not supported" << std::endl;
@@ -329,14 +327,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 +352,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 +362,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 +387,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 +395,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 +403,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 +452,7 @@ ReturnValue_t UartComIF::handleCanonicalRead(UartCookie& uartCookie, UartDeviceM
                           strerror(errno));
 #endif
 #endif
-        return returnvalue::FAILED;
+        return RETURN_FAILED;
       }
 
     } else if (bytesRead > 0) {
@@ -487,18 +485,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 +518,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 +527,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 +545,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 +565,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 +585,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_SIZE_MISSMATCH = returnvalue::makeCode(uartRetvalId, 2);
-  static constexpr ReturnValue_t UART_RX_BUFFER_TOO_SMALL = returnvalue::makeCode(uartRetvalId, 3);
+  static constexpr ReturnValue_t UART_READ_FAILURE =
+      HasReturnvaluesIF::makeReturnCode(uartRetvalId, 1);
+  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/uart/UartCookie.cpp

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

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

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

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