Merge pull request 'Added new functions to add sequences and tables' (#606) from eive/fsfw:mueller/new-ss-adder-functions into development

Reviewed-on: fsfw/fsfw#606

CHANGELOG

@@ -1,175 +0,0 @@
-# Changed from ASTP 1.1.0 to 1.2.0
-
-## API Changes
-
-### FSFW Architecture
-
-- New src folder which contains all source files except the HAL, contributed code and test code
-- External and internal API mostly stayed the same
-- Folder names are now all smaller case: internalError was renamed to internalerror and
-  FreeRTOS was renamed to freertos
-- Warning if optional headers are used but the modules was not added to the source files to compile
-
-### HAL
-
-- HAL added back into FSFW. It is tightly bound to the FSFW, and compiling it as a static library
-  made using it more complicated than necessary
-
-## Bugfixes
-
-### FreeRTOS QueueMapManager
-
-- Fixed a bug which causes the first generated Queue ID to be invalid
-
-## Enhancements
-
-### FSFW Architecture
-
-- See API changes chapter. This change will keep the internal API consistent in the future
-
-# Changes from ASTP 1.0.0 to 1.1.0
-
-## API Changes
-
-### PUS
-
-- Added PUS C support
-- SUBSYSTEM_IDs added for PUS Services
-- Added new Parameter which must be defined in config: fsfwconfig::FSFW_MAX_TM_PACKET_SIZE
-
-### ObjectManager
-
- - ObjectManager is now a singelton
-
-
-### Configuration
-
-- Additional configuration option fsfwconfig::FSFW_MAX_TM_PACKET_SIZE which 
-  need to be specified in FSFWConfig.h
-
-### CMake
-
-- Changed Cmake FSFW_ADDITIONAL_INC_PATH to FSFW_ADDITIONAL_INC_PATHS
-
-## Bugfixes 
-
-- timemanager/TimeStamperIF.h: Timestamp config was not used correctly, leading to different timestamp sizes than configured in fsfwconfig::FSFW_MISSION_TIMESTAMP_SIZE
-- TCP server fixes
-
-## Enhancements
-
-### FreeRTOS Queue Handles
-
-- Fixed an internal issue how FreeRTOS MessageQueues were handled
-
-### Linux OSAL
-
-- Better printf error messages
-
-### CMake
-
-- Check for C++11 as mininimum required Version
-
-### Debug Output
-
-- Changed Warning color to magenta, which is well readable on both dark and light mode IDEs
-
-
-# Changes from ASTP 0.0.1 to 1.0.0
-
-### Host OSAL
-
-- Bugfix in MessageQueue, which caused the sender not to be set properly
-
-### FreeRTOS OSAL
-
-- vRequestContextSwitchFromISR is declared extern "C" so it can be defined in
-a C file without issues
-
-### PUS Services
-
-- It is now possible to change the message queue depth for the telecommand verification service (PUS1)
-- The same is possible for the event reporting service (PUS5)
-- PUS Health Service added, which allows to command and retrieve health via PUS packets
-
-
-### EnhancedControllerBase
-
-- New base class for a controller which also implements HasActionsIF and HasLocalDataPoolIF
-
-### Local Pool
-
-- Interface of LocalPools has changed. LocalPool is not a template anymore. Instead the size and
-bucket number of the pools per page and the number of pages are passed to the ctor instead of
-two ctor arguments and a template parameter
-
-### Parameter Service
-
-- The API of the parameter service has been changed to prevent inconsistencies
-between documentation and actual code and to clarify usage.
-- The parameter ID now consists of:
-	1. Domain ID (1 byte)
-	2. Unique Identifier (1 byte)
-	3. Linear Index (2 bytes)
-The linear index can be used for arrays as well as matrices.
-The parameter load command now explicitely expects the ECSS PTC and PFC
-information as well as  the rows and column number. Rows and column will
-default to one, which is equivalent to one scalar parameter (the most
-important use-case)
-   
-### File System Interface
-
-- A new interfaces specifies the functions for a software object which exposes the file system of
-a given hardware to use message based file handling (e.g. PUS commanding)
-
-### Internal Error Reporter
-
-- The new internal error reporter uses the local data pools. The pool IDs for
-the exisiting three error values and the new error set will be hardcoded for
-now, the the constructor for the internal error reporter just takes an object
-ID for now.
-
-### Device Handler Base
-
-- There is an additional `PERFORM_OPERATION` step for the device handler base. It is important
-that DHB users adapt their polling sequence tables to perform this step. This steps allows for 
-a clear distinction between operation and communication steps
-- setNormalDatapoolEntriesInvalid is not an abstract method and a default implementation was provided
-- getTransitionDelayMs is now an abstract method
-
-### DeviceHandlerIF
-
-- Typo for UNKNOWN_DEVICE_REPLY 
-
-### Events
-
-- makeEvent function: Now takes three input parameters instead of two and
-allows setting a unique ID. Event.cpp source file removed, functions now
-defined in header directly. Namespaces renamed. Functions declared `constexpr`
-now
-
-### Commanding Service Base
-
-- CSB uses the new fsfwconfig::FSFW_CSB_FIFO_DEPTH variable to determine  the FIFO depth for each 
-CSB instance. This variable has to be set in the FSFWConfig.h file
-
-### Service Interface
-
-- Proper printf support contained in ServiceInterfacePrinter.h
-- CPP ostream support now optional (can reduce executable size by 150 - 250 kB)
-- Amalagated header which determines automatically which service interface to use depending on FSFWConfig.h configuration. 
-  Users can just use #include <fsfw/serviceinterface/ServiceInterface.h>
-- If CPP streams are excluded, sif:: calls won't work anymore and need to be replaced by their printf counterparts. 
-  For the fsfw, this can be done by checking the processor define FSFW_CPP_OSTREAM_ENABLED from FSFWConfig.h. 
-  For mission code, developers need to replace sif:: calls by the printf counterparts, but only if the CPP stream are excluded. 
-  If this is not the case, everything should work as usual.
-
-### ActionHelper and ActionMessage
-
-- ActionHelper finish function and ActionMessage::setCompletionReply now expects explicit 
-information whether to report a success or failure message instead of deriving it implicitely 
-from returnvalue
-
-### PUS Parameter Service 20
-
-Added PUS parameter service 20 (only custom subservices available).

CHANGELOG.md

@@ -0,0 +1,447 @@
+Change Log
+=======
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/)
+and this project adheres to [Semantic Versioning](http://semver.org/).
+
+# [unreleased]
+
+# [v5.0.0]
+
+## Changes
+
+- Bump C++ required version to C++17. Every project which uses the FSFW and every modern
+  compiler supports it
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/622
+- HAL Linux SPI: Set the Clock Default State when setting new SPI speed
+  and mode
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/573
+- 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
+- HAL Linux Uart: Baudrate and bits per word are enums now, avoiding misconfigurations
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/585
+- 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
+- Clock: 
+  - `timeval` to `TimeOfDay_t`
+  - Added Mutex for gmtime calls: (compare http://www.opengate.at/blog/2020/01/timeless/)
+  - Moved the statics used by Clock in ClockCommon.cpp to this file
+  - Better check for leap seconds
+  - Added Unittests for Clock (only getter)
+
+## Removed
+
+- Removed the `HkSwitchHelper`. This module should not be needed anymore, now that the local
+  datapools have been implemented.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/557
+
+## Additions
+
+- 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 ETL dependency and improved library dependency management
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/592
+- `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]
+
+## Additions
+
+- CFDP Packet Stack and related tests added. It also refactors the existing TMTC infastructure to
+  allow sending of CFDP packets to the CCSDS handlers.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/528
+- added virtual function to print datasets
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/544
+- doSendRead Hook
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/545
+- Dockumentation for DHB
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/551
+  
+### HAL additions
+
+- Linux Command Executor, which can execute shell commands in blocking and non-blocking mode
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/536
+- uio Mapper
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/543
+
+## Changes
+
+- Applied the `clang-format` auto-formatter to all source code
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/534
+- Updated Catch2 to v3.0.0-preview4
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/538
+- Changed CI to use prebuilt docker image
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/549
+
+## Bugfix
+
+- CMake fixes in PR https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/533 , was problematic
+  if the uppermost user `CMakeLists.txt` did not have the include paths set up properly, which
+  could lead to compile errors that `#include "fsfw/FSFW.h"` was not found.
+- Fix for build regression in Catch2 v3.0.0-preview4
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/548
+- Fix in unittest which failed on CI
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/552
+- Fix in helper script
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/553
+
+## API Changes
+
+- Aforementioned changes to existing TMTC stack
+
+## Known bugs
+
+- 
+
+# [v3.0.1]
+
+## API Changes
+
+* 
+
+## Bugfixes
+
+* Version number was not updated for v3.0.0 #542
+
+## Enhancement
+
+* 
+
+## Known bugs
+
+* 
+
+# [v3.0.0]
+
+## API Changes
+
+#### TCP Socket Changes
+
+* Keep Open TCP Implementation #496
+    * The socket will now kept open after disconnect. This allows reconnecting. 
+    * Only one connection is allowed
+    * No internal influence but clients need to change their Code.
+
+### GPIO IF
+
+* Add feature to open GPIO by line name #506
+
+### Bitutil
+
+* Unittests for Op Divider and Bitutility #510
+
+### Filesystem IF changed
+
+*  Filesystem Base Interface: Use IF instead of void pointer #511 
+
+### STM32
+
+* STM32 SPI Updates #518
+
+## Bugfixes
+
+* Small bugfix for LIS3 handler #504
+* Spelling fixed for function names #509
+* CMakeLists fixes #517
+* Out of bound reads and writes in unittests #519
+* Bug in TmPacketStoredPusC (#478)
+* Windows ifdef fixed #529
+
+## Enhancement
+
+* FSFW.h.in more default values #491
+* Minor updates for PUS services #498
+* HasReturnvaluesIF naming for parameter #499
+* Tests can now be built as part of FSFW and versioning moved to CMake #500
+*  Added integration test code #508 
+* More printouts for rejected TC packets #505
+* Arrayprinter format improvements #514
+* Adding code for CI with docker and jenkins #520
+* Added new function in SerializeAdapter  #513
+    *  Enables simple deSerialize if you keep track of the buffer position yourself
+    *  `` static ReturnValue_t deSerialize(T *object, const uint8_t* buffer,
+            size_t* deserSize, SerializeIF::Endianness streamEndianness) ``
+* Unittest helper scripts has a new Parameter to open the coverage html in the webrowser  #525
+    * ``'-o', '--open', Open coverage data in webbrowser`` 
+* Documentation updated. Sphinx Documentation can now be build with python script #526
+
+## Known bugs
+
+* Version number was not updated for v3.0.0 #542
+
+
+All Pull Requests:
+
+Milestone: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/milestone/19
+
+# [v2.0.0]
+
+## API Changes
+
+
+### File Structure changed to fit more common structure
+
+* See pull request (#445)
+  * HAL is now part of the main project
+    * **See Instructions below:**
+
+#### Instruction how to update existing / user code
+
+* Changes in `#include`:
+  * Rename `internalError` in includes to `internalerror`
+  * Rename `fsfw/hal` to `fsfw_hal`
+  * Rename `fsfw/tests` to `fsfw_tests`
+  * Rename `osal/FreeRTOS` to `osal/freertos`
+
+* Changes in `CMakeLists.txt`: 
+  * Rename `OS_FSFW` to `FSFW_OSAL`
+
+* Changes in `DleEncoder.cpp`
+    * Create an instance of the `DleEncoder` first before calling the `encode` and `decode` functions
+
+### Removed osal/linux/Timer (#486)
+
+* Was redundant to timemanager/Countdown
+
+#### Instruction how to update existing / user code
+
+* Use timemanager/Countdown instead
+
+## Bugfixes
+
+### TM Stack
+
+* Increased TM stack robustness by introducing `nullptr` checks and more printouts (#483)
+
+#### Host OSAL / FreeRTOS 
+
+* QueueMapManager Bugfix (NO_QUEUE was used as MessageQueueId) (#444)
+
+#### Events
+
+* Event output is now consistent (#447)
+
+#### DLE Encoder
+
+* Fixed possible out of bounds access in DLE Encoder (#492)
+
+## Enhancment
+
+* HAL as major new feature, also includes three MEMS devicehandlers as part of #481
+* Linux HAL updates (#456)
+* FreeRTOS Header cleaning update and Cmake tweaks (#442)
+* Printer updates (#453)
+* New returnvalue for for empty PST (#485)
+* TMTC Bridge: Increase limit of packets stored (#484)
+
+## Known bugs
+
+* Bug in TmPacketStoredPusC (#478)
+
+
+All Pull Requests:
+
+Milestone: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/milestone/5
+
+# [v1.2.0]
+
+## API Changes
+
+### FSFW Architecture
+
+- New src folder which contains all source files except the HAL, contributed code and test code
+- External and internal API mostly stayed the same
+- Folder names are now all smaller case: internalError was renamed to internalerror and
+  FreeRTOS was renamed to freertos
+- Warning if optional headers are used but the modules was not added to the source files to compile
+
+### HAL
+
+- HAL added back into FSFW. It is tightly bound to the FSFW, and compiling it as a static library
+  made using it more complicated than necessary
+
+## Bugfixes
+
+### FreeRTOS QueueMapManager
+
+- Fixed a bug which causes the first generated Queue ID to be invalid
+
+## Enhancements
+
+### FSFW Architecture
+
+- See API changes chapter. This change will keep the internal API consistent in the future
+
+# [v1.1.0]
+
+## API Changes
+
+### PUS
+
+- Added PUS C support
+- SUBSYSTEM_IDs added for PUS Services
+- Added new Parameter which must be defined in config: fsfwconfig::FSFW_MAX_TM_PACKET_SIZE
+
+### ObjectManager
+
+ - ObjectManager is now a singelton
+
+
+### Configuration
+
+- Additional configuration option fsfwconfig::FSFW_MAX_TM_PACKET_SIZE which 
+  need to be specified in FSFWConfig.h
+
+### CMake
+
+- Changed Cmake FSFW_ADDITIONAL_INC_PATH to FSFW_ADDITIONAL_INC_PATHS
+
+## Bugfixes 
+
+- timemanager/TimeStamperIF.h: Timestamp config was not used correctly, leading to different timestamp sizes than configured in fsfwconfig::FSFW_MISSION_TIMESTAMP_SIZE
+- TCP server fixes
+
+## Enhancements
+
+### FreeRTOS Queue Handles
+
+- Fixed an internal issue how FreeRTOS MessageQueues were handled
+
+### Linux OSAL
+
+- Better printf error messages
+
+### CMake
+
+- Check for C++11 as mininimum required Version
+
+### Debug Output
+
+- Changed Warning color to magenta, which is well readable on both dark and light mode IDEs
+
+
+# Changes from ASTP 0.0.1 to 1.0.0
+
+### Host OSAL
+
+- Bugfix in MessageQueue, which caused the sender not to be set properly
+
+### FreeRTOS OSAL
+
+- vRequestContextSwitchFromISR is declared extern "C" so it can be defined in
+a C file without issues
+
+### PUS Services
+
+- It is now possible to change the message queue depth for the telecommand verification service (PUS1)
+- The same is possible for the event reporting service (PUS5)
+- PUS Health Service added, which allows to command and retrieve health via PUS packets
+
+
+### EnhancedControllerBase
+
+- New base class for a controller which also implements HasActionsIF and HasLocalDataPoolIF
+
+### Local Pool
+
+- Interface of LocalPools has changed. LocalPool is not a template anymore. Instead the size and
+bucket number of the pools per page and the number of pages are passed to the ctor instead of
+two ctor arguments and a template parameter
+
+### Parameter Service
+
+- The API of the parameter service has been changed to prevent inconsistencies
+between documentation and actual code and to clarify usage.
+- The parameter ID now consists of:
+	1. Domain ID (1 byte)
+	2. Unique Identifier (1 byte)
+	3. Linear Index (2 bytes)
+The linear index can be used for arrays as well as matrices.
+The parameter load command now explicitely expects the ECSS PTC and PFC
+information as well as  the rows and column number. Rows and column will
+default to one, which is equivalent to one scalar parameter (the most
+important use-case)
+   
+### File System Interface
+
+- A new interfaces specifies the functions for a software object which exposes the file system of
+a given hardware to use message based file handling (e.g. PUS commanding)
+
+### Internal Error Reporter
+
+- The new internal error reporter uses the local data pools. The pool IDs for
+the exisiting three error values and the new error set will be hardcoded for
+now, the the constructor for the internal error reporter just takes an object
+ID for now.
+
+### Device Handler Base
+
+- There is an additional `PERFORM_OPERATION` step for the device handler base. It is important
+that DHB users adapt their polling sequence tables to perform this step. This steps allows for 
+a clear distinction between operation and communication steps
+- setNormalDatapoolEntriesInvalid is not an abstract method and a default implementation was provided
+- getTransitionDelayMs is now an abstract method
+
+### DeviceHandlerIF
+
+- Typo for UNKNOWN_DEVICE_REPLY 
+
+### Events
+
+- makeEvent function: Now takes three input parameters instead of two and
+allows setting a unique ID. Event.cpp source file removed, functions now
+defined in header directly. Namespaces renamed. Functions declared `constexpr`
+now
+
+### Commanding Service Base
+
+- CSB uses the new fsfwconfig::FSFW_CSB_FIFO_DEPTH variable to determine  the FIFO depth for each 
+CSB instance. This variable has to be set in the FSFWConfig.h file
+
+### Service Interface
+
+- Proper printf support contained in ServiceInterfacePrinter.h
+- CPP ostream support now optional (can reduce executable size by 150 - 250 kB)
+- Amalagated header which determines automatically which service interface to use depending on FSFWConfig.h configuration. 
+  Users can just use #include <fsfw/serviceinterface/ServiceInterface.h>
+- If CPP streams are excluded, sif:: calls won't work anymore and need to be replaced by their printf counterparts. 
+  For the fsfw, this can be done by checking the processor define FSFW_CPP_OSTREAM_ENABLED from FSFWConfig.h. 
+  For mission code, developers need to replace sif:: calls by the printf counterparts, but only if the CPP stream are excluded. 
+  If this is not the case, everything should work as usual.
+
+### ActionHelper and ActionMessage
+
+- ActionHelper finish function and ActionMessage::setCompletionReply now expects explicit 
+information whether to report a success or failure message instead of deriving it implicitely 
+from returnvalue
+
+### PUS Parameter Service 20
+
+Added PUS parameter service 20 (only custom subservices available).

CMakeLists.txt

@@ -1,12 +1,39 @@
 cmake_minimum_required(VERSION 3.13)
 
-set(FSFW_VERSION 2)
+set(LIB_FSFW_NAME fsfw)
+project(${LIB_FSFW_NAME})
+
+if(NOT CMAKE_CXX_STANDARD)
+    set(CMAKE_CXX_STANDARD 17)
+    set(CMAKE_CXX_STANDARD_REQUIRED True)
+elseif(${CMAKE_CXX_STANDARD} LESS 17)
+    message(FATAL_ERROR "Compiling the FSFW requires a minimum of C++17 support")
+endif()
+
+set(FSFW_VERSION 4)
 set(FSFW_SUBVERSION 0)
 set(FSFW_REVISION 0)
 
 # Add the cmake folder so the FindSphinx module is found
 set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
 
+set(FSFW_ETL_LIB_MAJOR_VERSION 20 CACHE STRING
+    "ETL library major version requirement"
+)
+set(FSFW_ETL_LIB_VERSION ${FSFW_ETL_LIB_MAJOR_VERSION}.27.3 CACHE STRING
+    "ETL library exact version requirement"
+)
+set(FSFW_ETL_LINK_TARGET etl::etl)
+
+set(FSFW_CATCH2_LIB_MAJOR_VERSION 3 CACHE STRING
+    "Catch2 library major version requirement"
+)
+set(FSFW_CATCH2_LIB_VERSION v${FSFW_CATCH2_LIB_MAJOR_VERSION}.0.0-preview5 CACHE STRING
+    "Catch2 library exact version requirement"
+)
+
+set(FSFW_ETL_LIB_NAME etl)
+
 option(FSFW_GENERATE_SECTIONS
     "Generate function and data sections. Required to remove unused code" ON
 )
@@ -38,28 +65,28 @@ 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})
 
 if(FSFW_BUILD_UNITTESTS)
     message(STATUS "Building the FSFW unittests in addition to the static library")
     # Check whether the user has already installed Catch2 first
-    find_package(Catch2 3)
+    find_package(Catch2 ${FSFW_CATCH2_LIB_MAJOR_VERSION})
     # Not installed, so use FetchContent to download and provide Catch2
     if(NOT Catch2_FOUND)
+        message(STATUS "Catch2 installation not found. Downloading Catch2 library with FetchContent")
         include(FetchContent)
 
         FetchContent_Declare(
             Catch2
             GIT_REPOSITORY https://github.com/catchorg/Catch2.git
-            GIT_TAG        v3.0.0-preview4
+            GIT_TAG        ${FSFW_CATCH2_LIB_VERSION}
         )
 
-        FetchContent_MakeAvailable(Catch2)
+        list(APPEND FSFW_FETCH_CONTENT_TARGETS Catch2)
     endif()
 
     set(FSFW_CONFIG_PATH tests/src/fsfw_tests/unit/testcfg)
@@ -86,6 +113,42 @@ if(FSFW_BUILD_UNITTESTS)
     endif()
 endif()
 
+message(STATUS "Finding and/or providing ETL library")
+
+# 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
+        "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)
@@ -98,12 +161,6 @@ 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 "Compiling the FSFW requires a minimum of C++11 support")
-endif()
 
 # Backwards comptability
 if(OS_FSFW AND NOT FSFW_OSAL)
@@ -279,6 +336,24 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 		  -Wimplicit-fallthrough=1
 		  -Wno-unused-parameter
 		  -Wno-psabi
+          -Wduplicated-cond # check for duplicate conditions
+          -Wduplicated-branches # check for duplicate branches
+          -Wlogical-op # Search for bitwise operations instead of logical 
+          -Wnull-dereference # Search for NULL dereference
+          -Wundef # Warn if undefind marcos are used
+          -Wformat=2 # Format string problem detection
+          -Wformat-overflow=2 # Formatting issues in printf
+          -Wformat-truncation=2 # Formatting issues in printf
+          -Wformat-security # Search for dangerous printf operations
+          -Wstrict-overflow=3 # Warn if integer overflows might happen
+          -Warray-bounds=2 # Some array bounds violations will be found
+          -Wshift-overflow=2 # Search for bit left shift overflows (<c++14)
+          -Wcast-qual # Warn if the constness is cast away
+          -Wstringop-overflow=4
+          # -Wstack-protector # Emits a few false positives for low level access
+          # -Wconversion # Creates many false positives
+          # -Warith-conversion # Use with Wconversion to find more implicit conversions
+          # -fanalyzer # Should be used to look through problems
         )
     endif()
 
@@ -329,6 +404,7 @@ target_compile_options(${LIB_FSFW_NAME} PRIVATE
 )
 
 target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+    ${FSFW_ETL_LINK_TARGET}
     ${FSFW_ADDITIONAL_LINK_LIBS}
 )
 

README.md

@@ -11,9 +11,15 @@ 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:
 
@@ -45,6 +51,28 @@ 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
@@ -71,9 +99,9 @@ add and link against the FSFW library in general.
 
 4. Link against the FSFW library
 
-	```cmake
-	target_link_libraries(<YourProjectName> PRIVATE fsfw)
-	```
+   ```cmake
+   target_link_libraries(${YourProjectName} PRIVATE fsfw)
+   ```
 
 5. It should now be possible use the FSFW as a static library from the user code.
 
@@ -83,6 +111,19 @@ 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`.
@@ -107,6 +148,42 @@ cmake --build . -- fsfw-tests_coverage -j
 
 The `coverage.py` script located in the `script` folder can also be used to do this conveniently.
 
+## Building the documentations
+
+The FSFW documentation is built using the tools Sphinx, doxygen and breathe based on the
+instructions provided in  [this blogpost](https://devblogs.microsoft.com/cppblog/clear-functional-c-documentation-with-sphinx-breathe-doxygen-cmake/). If you
+want to do this locally, set up the prerequisites first. This requires a ``python3``
+installation as well. Example here is for Ubuntu.
+
+```sh
+sudo apt-get install doxygen graphviz
+```
+
+And the following Python packages
+
+```sh
+python3 -m pip install sphinx breathe
+```
+
+You can set up a documentation build system using the following commands
+
+```sh
+mkdir build-docs && cd build-docs
+cmake -DFSFW_BUILD_DOCS=ON -DFSFW_OSAL=host ..
+```
+
+Then you can generate the documentation using
+
+```sh
+cmake --build . -j
+```
+
+You can find the generated documentation inside the `docs/sphinx` folder inside the build
+folder. Simply open the `index.html` in the webbrowser of your choice.
+
+The `helper.py` script located in the script` folder can also be used to create, build
+and open the documentation conveniently. Try `helper.py -h for more information.
+
 ## Formatting the sources
 
 The formatting is done by the `clang-format` tool. The configuration is contained within the

automation/Dockerfile

@@ -9,6 +9,6 @@ RUN apt-get --yes install gcc g++ cmake make lcov git valgrind nano iputils-ping
 
 RUN git clone https://github.com/catchorg/Catch2.git && \
 	cd Catch2 && \
-	git checkout v3.0.0-preview4 && \
+	git checkout v3.0.0-preview5 && \
 	cmake -Bbuild -H. -DBUILD_TESTING=OFF && \
 	cmake --build build/ --target install

automation/Jenkinsfile

@@ -3,13 +3,7 @@ pipeline {
         BUILDDIR = 'build-tests'
     }
     agent {
-        dockerfile {
-            dir 'automation'
-            //force docker to redownload base image and rebuild all steps instead of caching them
-            //this way, we always get an up to date docker image one each build
-            additionalBuildArgs  '--no-cache --pull'
-            reuseNode true
-        }
+        docker { image 'fsfw-ci:d2'}
     }
     stages {
         stage('Clean') {
@@ -27,14 +21,14 @@ pipeline {
         stage('Build') {
             steps {
                 dir(BUILDDIR) {
-                    sh 'cmake --build . -j'
+                    sh 'cmake --build . -j4'
                 }
             }
         }
         stage('Unittests') {
             steps {
                 dir(BUILDDIR) {
-                    sh 'cmake --build . -- fsfw-tests_coverage -j'
+                    sh 'cmake --build . -- fsfw-tests_coverage -j4'
                 }
             }
         }

docs/devicehandlers.rst

@@ -1,3 +1,110 @@
+.. _dhb-prim-doc:
+
 Device Handlers
 ==================
 
+Device handler components represent, control and monitor equipment, for example sensors or actuators
+of a spacecraft or the payload.
+
+Most device handlers have the same common functionality or
+requirements, which are fulfilled by implementing certain interfaces:
+
+- The handler/device needs to be commandable: :cpp:class:`HasActionsIF`
+- The handler needs to communicate with the physical device via a dedicated
+  communication bus, for example SpaceWire, UART or SPI: :cpp:class:`DeviceCommunicationIF`
+- The handler has housekeeping data which has to be exposed to the operator and/or other software
+  components: :cpp:class:`HasLocalDataPoolIF`
+- The handler has configurable parameters: :cpp:class:`ReceivesParameterMessagesIF` which
+  also implements :cpp:class:`HasParametersIF`
+- The handler has health states, for example to indicate a broken device:
+  :cpp:class:`HasHealthIF`
+- The handler has modes. For example there are the core modes `MODE_ON`, `MODE_OFF`
+  and `MODE_NORMAL` provided by the FSFW. `MODE_ON` means that a device is physically powered
+  but that it is not periodically polling data from the
+  physical device, `MODE_NORMAL` means that it is able to do that: :cpp:class:`HasModesIF`
+
+The device handler base therefore provides abstractions for a lot of common
+functionality, which can potentially avoid high amounts or logic and code duplication.
+
+Template Device Handler Base File
+----------------------------------
+
+This is an example template device handler header file with all necessary
+functions implemented:
+
+.. code-block:: cpp
+
+	#ifndef __TESTDEVICEHANDLER_H_
+	#define __TESTDEVICEHANDLER_H_
+
+	#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+
+	class TestDeviceHandler: DeviceHandlerBase {
+	public:
+	  TestDeviceHandler(object_id_t objectId, object_id_t comIF, CookieIF* cookie);
+	private:
+	  void doStartUp() override;
+	  void doShutDown() override;
+	  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t* id) override;
+	  ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t* id) override;
+	  void fillCommandAndReplyMap() override;
+	  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t* commandData,
+	                                        size_t commandDataLen) override;
+	  ReturnValue_t scanForReply(const uint8_t* start, size_t remainingSize, DeviceCommandId_t* foundId,
+	                             size_t* foundLen) override;
+	  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) override;
+	  uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
+	  ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+	                                        LocalDataPoolManager& poolManager) override;
+
+	};
+
+	#endif /* __TESTDEVICEHANDLER_H_ */
+
+and the respective source file with sensible default return values:
+
+.. code-block:: cpp
+
+	#include "TestDeviceHandler.h"
+
+	TestDeviceHandler::TestDeviceHandler(object_id_t objectId, object_id_t comIF, CookieIF* cookie)
+	    : DeviceHandlerBase(objectId, comIF, cookie) {}
+
+	void TestDeviceHandler::doStartUp() {}
+
+	void TestDeviceHandler::doShutDown() {}
+
+	ReturnValue_t TestDeviceHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
+	  return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	ReturnValue_t TestDeviceHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
+	  return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	void TestDeviceHandler::fillCommandAndReplyMap() {}
+
+	ReturnValue_t TestDeviceHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+	                                                         const uint8_t* commandData,
+	                                                         size_t commandDataLen) {
+	  return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	ReturnValue_t TestDeviceHandler::scanForReply(const uint8_t* start, size_t remainingSize,
+	                                              DeviceCommandId_t* foundId, size_t* foundLen) {
+	  return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	ReturnValue_t TestDeviceHandler::interpretDeviceReply(DeviceCommandId_t id,
+	                                                      const uint8_t* packet) {
+	  return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	uint32_t TestDeviceHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) {
+	  return 10000;
+	}
+
+	ReturnValue_t TestDeviceHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+	                                                         LocalDataPoolManager& poolManager) {
+	  return HasReturnvaluesIF::RETURN_OK;
+	}

docs/getting_started.rst

@@ -19,6 +19,29 @@ 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
 -------------------
 
@@ -60,6 +83,20 @@ 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`.
@@ -90,8 +127,21 @@ Building the documentation
 ----------------------------
 
 The FSFW documentation is built using the tools Sphinx, doxygen and breathe based on the
-instructions provided in `this blogpost <https://devblogs.microsoft.com/cppblog/clear-functional-c-documentation-with-sphinx-breathe-doxygen-cmake/>`_. You can set up a
-documentation build system using the following commands
+instructions provided in `this blogpost <https://devblogs.microsoft.com/cppblog/clear-functional-c-documentation-with-sphinx-breathe-doxygen-cmake/>`_. If you
+want to do this locally, set up the prerequisites first. This requires a ``python3``
+installation as well. Example here is for Ubuntu.
+
+.. code-block:: console
+
+   sudo apt-get install doxygen graphviz
+
+And the following Python packages
+
+.. code-block:: console
+
+   python3 -m pip install sphinx breathe
+
+You can set up a documentation build system using the following commands
 
 .. code-block:: bash
 
@@ -110,6 +160,14 @@ folder. Simply open the ``index.html`` in the webbrowser of your choice.
 The ``helper.py`` script located in the ``script`` folder can also be used to create, build
 and open the documentation conveniently. Try ``helper.py -h`` for more information.
 
+Formatting the source
+-----------------------
+
+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 ``apply-clang-format.sh`` helper script to format all source files consistently.
+
+
 .. _`Hosted FSFW example`: https://egit.irs.uni-stuttgart.de/fsfw/fsfw-example-hosted
 .. _`Catch2 library`: https://github.com/catchorg/Catch2
 .. _`Code coverage`: https://github.com/bilke/cmake-modules/tree/master

docs/highlevel.rst

@@ -118,7 +118,7 @@ The DH has mechanisms to monitor the communication with the physical device whic
 for FDIR reaction.  Device Handlers can be created by implementing ``DeviceHandlerBase``.
 A standard FDIR component for the DH will be created automatically but can
 be overwritten by the user. More information on DeviceHandlers can be found in the
-related [documentation section](doc/README-devicehandlers.md#top).
+related :ref:`documentation section <dhb-prim-doc>`.
 
 Modes and Health
 --------------------

hal/CMakeLists.txt

@@ -9,6 +9,7 @@ option(FSFW_HAL_ADD_LINUX "Add the Linux HAL to the sources. Requires gpiod libr
 # 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)

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

@@ -9,18 +9,18 @@ using gpioId_t = uint16_t;
 
 namespace gpio {
 
-enum Levels : uint8_t { LOW = 0, HIGH = 1, NONE = 99 };
+enum class Levels : int { LOW = 0, HIGH = 1, NONE = 99 };
 
-enum Direction : uint8_t { DIR_IN = 0, DIR_OUT = 1 };
+enum class Direction : int { IN = 0, OUT = 1 };
 
-enum GpioOperation { READ, WRITE };
+enum class GpioOperation { READ, WRITE };
 
 enum class GpioTypes {
   NONE,
   GPIO_REGULAR_BY_CHIP,
   GPIO_REGULAR_BY_LABEL,
   GPIO_REGULAR_BY_LINE_NAME,
-  TYPE_CALLBACK
+  CALLBACK
 };
 
 static constexpr gpioId_t NO_GPIO = -1;
@@ -57,7 +57,7 @@ class GpioBase {
   // Can be used to cast GpioBase to a concrete child implementation
   gpio::GpioTypes gpioType = gpio::GpioTypes::NONE;
   std::string consumer;
-  gpio::Direction direction = gpio::Direction::DIR_IN;
+  gpio::Direction direction = gpio::Direction::IN;
   gpio::Levels initValue = gpio::Levels::NONE;
 };
 
@@ -79,8 +79,8 @@ class GpiodRegularBase : public GpioBase {
 class GpiodRegularByChip : public GpiodRegularBase {
  public:
   GpiodRegularByChip()
-      : GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_CHIP, std::string(),
-                         gpio::Direction::DIR_IN, gpio::LOW, 0) {}
+      : GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_CHIP, std::string(), gpio::Direction::IN,
+                         gpio::Levels::LOW, 0) {}
 
   GpiodRegularByChip(std::string chipname_, int lineNum_, std::string consumer_,
                      gpio::Direction direction_, gpio::Levels initValue_)
@@ -89,8 +89,8 @@ class GpiodRegularByChip : public GpiodRegularBase {
         chipname(chipname_) {}
 
   GpiodRegularByChip(std::string chipname_, int lineNum_, std::string consumer_)
-      : GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_CHIP, consumer_, gpio::Direction::DIR_IN,
-                         gpio::LOW, lineNum_),
+      : GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_CHIP, consumer_, gpio::Direction::IN,
+                         gpio::Levels::LOW, lineNum_),
         chipname(chipname_) {}
 
   std::string chipname;
@@ -105,8 +105,8 @@ class GpiodRegularByLabel : public GpiodRegularBase {
         label(label_) {}
 
   GpiodRegularByLabel(std::string label_, int lineNum_, std::string consumer_)
-      : GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_LABEL, consumer_, gpio::Direction::DIR_IN,
-                         gpio::LOW, lineNum_),
+      : GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_LABEL, consumer_, gpio::Direction::IN,
+                         gpio::Levels::LOW, lineNum_),
         label(label_) {}
 
   std::string label;
@@ -126,8 +126,8 @@ class GpiodRegularByLineName : public GpiodRegularBase {
         lineName(lineName_) {}
 
   GpiodRegularByLineName(std::string lineName_, std::string consumer_)
-      : GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_LINE_NAME, consumer_,
-                         gpio::Direction::DIR_IN, gpio::LOW),
+      : GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_LINE_NAME, consumer_, gpio::Direction::IN,
+                         gpio::Levels::LOW),
         lineName(lineName_) {}
 
   std::string lineName;
@@ -137,7 +137,7 @@ class GpioCallback : public GpioBase {
  public:
   GpioCallback(std::string consumer, gpio::Direction direction_, gpio::Levels initValue_,
                gpio::gpio_cb_t callback, void* callbackArgs)
-      : GpioBase(gpio::GpioTypes::TYPE_CALLBACK, consumer, direction_, initValue_),
+      : GpioBase(gpio::GpioTypes::CALLBACK, consumer, direction_, initValue_),
         callback(callback),
         callbackArgs(callbackArgs) {}
 

hal/src/fsfw_hal/devicehandlers/GyroL3GD20Handler.cpp

@@ -8,11 +8,7 @@ GyroHandlerL3GD20H::GyroHandlerL3GD20H(object_id_t objectId, object_id_t deviceC
                                        CookieIF *comCookie, uint32_t transitionDelayMs)
     : DeviceHandlerBase(objectId, deviceCommunication, comCookie),
       transitionDelayMs(transitionDelayMs),
-      dataset(this) {
-#if FSFW_HAL_L3GD20_GYRO_DEBUG == 1
-  debugDivider = new PeriodicOperationDivider(10);
-#endif
-}
+      dataset(this) {}
 
 GyroHandlerL3GD20H::~GyroHandlerL3GD20H() {}
 
@@ -193,22 +189,22 @@ ReturnValue_t GyroHandlerL3GD20H::interpretDeviceReply(DeviceCommandId_t id,
 
       int8_t temperaturOffset = (-1) * packet[L3GD20H::TEMPERATURE_IDX];
       float temperature = 25.0 + temperaturOffset;
-#if FSFW_HAL_L3GD20_GYRO_DEBUG == 1
-      if (debugDivider->checkAndIncrement()) {
-        /* Set terminal to utf-8 if there is an issue with micro printout. */
+      if (periodicPrintout) {
+        if (debugDivider.checkAndIncrement()) {
+          /* Set terminal to utf-8 if there is an issue with micro printout. */
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::info << "GyroHandlerL3GD20H: Angular velocities (deg/s):" << std::endl;
-        sif::info << "X: " << angVelocX << std::endl;
-        sif::info << "Y: " << angVelocY << std::endl;
-        sif::info << "Z: " << angVelocZ << std::endl;
+          sif::info << "GyroHandlerL3GD20H: Angular velocities (deg/s):" << std::endl;
+          sif::info << "X: " << angVelocX << std::endl;
+          sif::info << "Y: " << angVelocY << std::endl;
+          sif::info << "Z: " << angVelocZ << std::endl;
 #else
-        sif::printInfo("GyroHandlerL3GD20H: Angular velocities (deg/s):\n");
-        sif::printInfo("X: %f\n", angVelocX);
-        sif::printInfo("Y: %f\n", angVelocY);
-        sif::printInfo("Z: %f\n", angVelocZ);
+          sif::printInfo("GyroHandlerL3GD20H: Angular velocities (deg/s):\n");
+          sif::printInfo("X: %f\n", angVelocX);
+          sif::printInfo("Y: %f\n", angVelocY);
+          sif::printInfo("Z: %f\n", angVelocZ);
 #endif
+        }
       }
-#endif
 
       PoolReadGuard readSet(&dataset);
       if (readSet.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
@@ -272,3 +268,8 @@ void GyroHandlerL3GD20H::setAbsoluteLimits(float limitX, float limitY, float lim
   this->absLimitY = limitY;
   this->absLimitZ = limitZ;
 }
+
+void GyroHandlerL3GD20H::enablePeriodicPrintouts(bool enable, uint8_t divider) {
+  periodicPrintout = enable;
+  debugDivider.setDivider(divider);
+}

hal/src/fsfw_hal/devicehandlers/GyroL3GD20Handler.h

@@ -5,7 +5,6 @@
 #include <fsfw/globalfunctions/PeriodicOperationDivider.h>
 
 #include "devicedefinitions/GyroL3GD20Definitions.h"
-#include "fsfw/FSFW.h"
 
 /**
  * @brief 	Device Handler for the L3GD20H gyroscope sensor
@@ -22,6 +21,8 @@ class GyroHandlerL3GD20H : public DeviceHandlerBase {
                      uint32_t transitionDelayMs);
   virtual ~GyroHandlerL3GD20H();
 
+  void enablePeriodicPrintouts(bool enable, uint8_t divider);
+
   /**
    * Set the absolute limit for the values on the axis in degrees per second.
    * The dataset values will be marked as invalid if that limit is exceeded
@@ -80,9 +81,8 @@ class GyroHandlerL3GD20H : public DeviceHandlerBase {
   // Set default value
   float sensitivity = L3GD20H::SENSITIVITY_00;
 
-#if FSFW_HAL_L3GD20_GYRO_DEBUG == 1
-  PeriodicOperationDivider *debugDivider = nullptr;
-#endif
+  bool periodicPrintout = false;
+  PeriodicOperationDivider debugDivider = PeriodicOperationDivider(3);
 };
 
 #endif /* MISSION_DEVICES_GYROL3GD20HANDLER_H_ */

hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp

@@ -1,20 +1,14 @@
 #include "MgmLIS3MDLHandler.h"
 
-#include "fsfw/datapool/PoolReadGuard.h"
-#if FSFW_HAL_LIS3MDL_MGM_DEBUG == 1
-#include "fsfw/globalfunctions/PeriodicOperationDivider.h"
-#endif
-
 #include <cmath>
 
+#include "fsfw/datapool/PoolReadGuard.h"
+
 MgmLIS3MDLHandler::MgmLIS3MDLHandler(object_id_t objectId, object_id_t deviceCommunication,
                                      CookieIF *comCookie, uint32_t transitionDelay)
     : DeviceHandlerBase(objectId, deviceCommunication, comCookie),
       dataset(this),
       transitionDelay(transitionDelay) {
-#if FSFW_HAL_LIS3MDL_MGM_DEBUG == 1
-  debugDivider = new PeriodicOperationDivider(10);
-#endif
   // Set to default values right away
   registers[0] = MGMLIS3MDL::CTRL_REG1_DEFAULT;
   registers[1] = MGMLIS3MDL::CTRL_REG2_DEFAULT;
@@ -272,23 +266,24 @@ ReturnValue_t MgmLIS3MDLHandler::interpretDeviceReply(DeviceCommandId_t id, cons
       float mgmZ = static_cast<float>(mgmMeasurementRawZ) * sensitivityFactor *
                    MGMLIS3MDL::GAUSS_TO_MICROTESLA_FACTOR;
 
-#if FSFW_HAL_LIS3MDL_MGM_DEBUG == 1
-      if (debugDivider->checkAndIncrement()) {
+      if (periodicPrintout) {
+        if (debugDivider.checkAndIncrement()) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::info << "MGMHandlerLIS3: Magnetic field strength in"
-                     " microtesla:"
-                  << std::endl;
-        sif::info << "X: " << mgmX << " uT" << std::endl;
-        sif::info << "Y: " << mgmY << " uT" << std::endl;
-        sif::info << "Z: " << mgmZ << " uT" << std::endl;
+          sif::info << "MGMHandlerLIS3: Magnetic field strength in"
+                       " microtesla:"
+                    << std::endl;
+          sif::info << "X: " << mgmX << " uT" << std::endl;
+          sif::info << "Y: " << mgmY << " uT" << std::endl;
+          sif::info << "Z: " << mgmZ << " uT" << std::endl;
 #else
-        sif::printInfo("MGMHandlerLIS3: Magnetic field strength in microtesla:\n");
-        sif::printInfo("X: %f uT\n", mgmX);
-        sif::printInfo("Y: %f uT\n", mgmY);
-        sif::printInfo("Z: %f uT\n", mgmZ);
+          sif::printInfo("MGMHandlerLIS3: Magnetic field strength in microtesla:\n");
+          sif::printInfo("X: %f uT\n", mgmX);
+          sif::printInfo("Y: %f uT\n", mgmY);
+          sif::printInfo("Z: %f uT\n", mgmZ);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 0 */
+        }
       }
-#endif /* OBSW_VERBOSE_LEVEL >= 1 */
+
       PoolReadGuard readHelper(&dataset);
       if (readHelper.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
         if (std::abs(mgmX) < absLimitX) {
@@ -318,15 +313,16 @@ ReturnValue_t MgmLIS3MDLHandler::interpretDeviceReply(DeviceCommandId_t id, cons
     case MGMLIS3MDL::READ_TEMPERATURE: {
       int16_t tempValueRaw = packet[2] << 8 | packet[1];
       float tempValue = 25.0 + ((static_cast<float>(tempValueRaw)) / 8.0);
-#if FSFW_HAL_LIS3MDL_MGM_DEBUG == 1
-      if (debugDivider->check()) {
+      if (periodicPrintout) {
+        if (debugDivider.check()) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::info << "MGMHandlerLIS3: Temperature: " << tempValue << " C" << std::endl;
+          sif::info << "MGMHandlerLIS3: Temperature: " << tempValue << " C" << std::endl;
 #else
-        sif::printInfo("MGMHandlerLIS3: Temperature: %f C\n");
+          sif::printInfo("MGMHandlerLIS3: Temperature: %f C\n");
 #endif
+        }
       }
-#endif
+
       ReturnValue_t result = dataset.read();
       if (result == HasReturnvaluesIF::RETURN_OK) {
         dataset.temperature = tempValue;
@@ -484,3 +480,8 @@ void MgmLIS3MDLHandler::setAbsoluteLimits(float xLimit, float yLimit, float zLim
   this->absLimitY = yLimit;
   this->absLimitZ = zLimit;
 }
+
+void MgmLIS3MDLHandler::enablePeriodicPrintouts(bool enable, uint8_t divider) {
+  periodicPrintout = enable;
+  debugDivider.setDivider(divider);
+}

hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h

@@ -3,8 +3,8 @@
 
 #include "devicedefinitions/MgmLIS3HandlerDefs.h"
 #include "events/subsystemIdRanges.h"
-#include "fsfw/FSFW.h"
 #include "fsfw/devicehandlers/DeviceHandlerBase.h"
+#include "fsfw/globalfunctions/PeriodicOperationDivider.h"
 
 class PeriodicOperationDivider;
 
@@ -30,6 +30,7 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase {
                     uint32_t transitionDelay);
   virtual ~MgmLIS3MDLHandler();
 
+  void enablePeriodicPrintouts(bool enable, uint8_t divider);
   /**
    * Set the absolute limit for the values on the axis in microtesla. The dataset values will
    * be marked as invalid if that limit is exceeded
@@ -167,9 +168,8 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase {
    */
   ReturnValue_t prepareCtrlRegisterWrite();
 
-#if FSFW_HAL_LIS3MDL_MGM_DEBUG == 1
-  PeriodicOperationDivider *debugDivider;
-#endif
+  bool periodicPrintout = false;
+  PeriodicOperationDivider debugDivider = PeriodicOperationDivider(3);
 };
 
 #endif /* MISSION_DEVICES_MGMLIS3MDLHANDLER_H_ */

hal/src/fsfw_hal/devicehandlers/MgmRM3100Handler.cpp

@@ -10,11 +10,7 @@ MgmRM3100Handler::MgmRM3100Handler(object_id_t objectId, object_id_t deviceCommu
                                    CookieIF *comCookie, uint32_t transitionDelay)
     : DeviceHandlerBase(objectId, deviceCommunication, comCookie),
       primaryDataset(this),
-      transitionDelay(transitionDelay) {
-#if FSFW_HAL_RM3100_MGM_DEBUG == 1
-  debugDivider = new PeriodicOperationDivider(10);
-#endif
-}
+      transitionDelay(transitionDelay) {}
 
 MgmRM3100Handler::~MgmRM3100Handler() {}
 
@@ -337,23 +333,23 @@ ReturnValue_t MgmRM3100Handler::handleDataReadout(const uint8_t *packet) {
   float fieldStrengthY = fieldStrengthRawY * scaleFactorX;
   float fieldStrengthZ = fieldStrengthRawZ * scaleFactorX;
 
-#if FSFW_HAL_RM3100_MGM_DEBUG == 1
-  if (debugDivider->checkAndIncrement()) {
+  if (periodicPrintout) {
+    if (debugDivider.checkAndIncrement()) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::info << "MgmRM3100Handler: Magnetic field strength in"
-                 " microtesla:"
-              << std::endl;
-    sif::info << "X: " << fieldStrengthX << " uT" << std::endl;
-    sif::info << "Y: " << fieldStrengthY << " uT" << std::endl;
-    sif::info << "Z: " << fieldStrengthZ << " uT" << std::endl;
+      sif::info << "MgmRM3100Handler: Magnetic field strength in"
+                   " microtesla:"
+                << std::endl;
+      sif::info << "X: " << fieldStrengthX << " uT" << std::endl;
+      sif::info << "Y: " << fieldStrengthY << " uT" << std::endl;
+      sif::info << "Z: " << fieldStrengthZ << " uT" << std::endl;
 #else
-    sif::printInfo("MgmRM3100Handler: Magnetic field strength in microtesla:\n");
-    sif::printInfo("X: %f uT\n", fieldStrengthX);
-    sif::printInfo("Y: %f uT\n", fieldStrengthY);
-    sif::printInfo("Z: %f uT\n", fieldStrengthZ);
+      sif::printInfo("MgmRM3100Handler: Magnetic field strength in microtesla:\n");
+      sif::printInfo("X: %f uT\n", fieldStrengthX);
+      sif::printInfo("Y: %f uT\n", fieldStrengthY);
+      sif::printInfo("Z: %f uT\n", fieldStrengthZ);
 #endif
+    }
   }
-#endif
 
   // TODO: Sanity check on values?
   PoolReadGuard readGuard(&primaryDataset);
@@ -365,3 +361,8 @@ ReturnValue_t MgmRM3100Handler::handleDataReadout(const uint8_t *packet) {
   }
   return RETURN_OK;
 }
+
+void MgmRM3100Handler::enablePeriodicPrintouts(bool enable, uint8_t divider) {
+  periodicPrintout = enable;
+  debugDivider.setDivider(divider);
+}

hal/src/fsfw_hal/devicehandlers/MgmRM3100Handler.h

@@ -2,12 +2,8 @@
 #define MISSION_DEVICES_MGMRM3100HANDLER_H_
 
 #include "devicedefinitions/MgmRM3100HandlerDefs.h"
-#include "fsfw/FSFW.h"
 #include "fsfw/devicehandlers/DeviceHandlerBase.h"
-
-#if FSFW_HAL_RM3100_MGM_DEBUG == 1
 #include "fsfw/globalfunctions/PeriodicOperationDivider.h"
-#endif
 
 /**
  * @brief 	Device Handler for the RM3100 geomagnetic magnetometer sensor
@@ -33,6 +29,7 @@ class MgmRM3100Handler : public DeviceHandlerBase {
                    uint32_t transitionDelay);
   virtual ~MgmRM3100Handler();
 
+  void enablePeriodicPrintouts(bool enable, uint8_t divider);
   /**
    * Configure device handler to go to normal mode after startup immediately
    * @param enable
@@ -98,9 +95,9 @@ class MgmRM3100Handler : public DeviceHandlerBase {
                                         size_t commandDataLen);
 
   ReturnValue_t handleDataReadout(const uint8_t *packet);
-#if FSFW_HAL_RM3100_MGM_DEBUG == 1
-  PeriodicOperationDivider *debugDivider;
-#endif
+
+  bool periodicPrintout = false;
+  PeriodicOperationDivider debugDivider = PeriodicOperationDivider(3);
 };
 
 #endif /* MISSION_DEVICEHANDLING_MGMRM3100HANDLER_H_ */

hal/src/fsfw_hal/linux/CMakeLists.txt

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

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

@@ -44,6 +44,7 @@ ReturnValue_t LinuxLibgpioIF::addGpios(GpioCookie* gpioCookie) {
 }
 
 ReturnValue_t LinuxLibgpioIF::configureGpios(GpioMap& mapToAdd) {
+  ReturnValue_t result = RETURN_OK;
   for (auto& gpioConfig : mapToAdd) {
     auto& gpioType = gpioConfig.second->gpioType;
     switch (gpioType) {
@@ -55,7 +56,7 @@ ReturnValue_t LinuxLibgpioIF::configureGpios(GpioMap& mapToAdd) {
         if (regularGpio == nullptr) {
           return GPIO_INVALID_INSTANCE;
         }
-        configureGpioByChip(gpioConfig.first, *regularGpio);
+        result = configureGpioByChip(gpioConfig.first, *regularGpio);
         break;
       }
       case (gpio::GpioTypes::GPIO_REGULAR_BY_LABEL): {
@@ -63,7 +64,7 @@ ReturnValue_t LinuxLibgpioIF::configureGpios(GpioMap& mapToAdd) {
         if (regularGpio == nullptr) {
           return GPIO_INVALID_INSTANCE;
         }
-        configureGpioByLabel(gpioConfig.first, *regularGpio);
+        result = configureGpioByLabel(gpioConfig.first, *regularGpio);
         break;
       }
       case (gpio::GpioTypes::GPIO_REGULAR_BY_LINE_NAME): {
@@ -71,10 +72,10 @@ ReturnValue_t LinuxLibgpioIF::configureGpios(GpioMap& mapToAdd) {
         if (regularGpio == nullptr) {
           return GPIO_INVALID_INSTANCE;
         }
-        configureGpioByLineName(gpioConfig.first, *regularGpio);
+        result = configureGpioByLineName(gpioConfig.first, *regularGpio);
         break;
       }
-      case (gpio::GpioTypes::TYPE_CALLBACK): {
+      case (gpio::GpioTypes::CALLBACK): {
         auto gpioCallback = dynamic_cast<GpioCallback*>(gpioConfig.second);
         if (gpioCallback->callback == nullptr) {
           return GPIO_INVALID_INSTANCE;
@@ -83,8 +84,11 @@ ReturnValue_t LinuxLibgpioIF::configureGpios(GpioMap& mapToAdd) {
                                gpioCallback->initValue, gpioCallback->callbackArgs);
       }
     }
+    if (result != RETURN_OK) {
+      return GPIO_INIT_FAILED;
+    }
   }
-  return RETURN_OK;
+  return result;
 }
 
 ReturnValue_t LinuxLibgpioIF::configureGpioByLabel(gpioId_t gpioId,
@@ -161,11 +165,12 @@ ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, struct gpiod
   consumer = regularGpio.consumer;
   /* Configure direction and add a description to the GPIO */
   switch (direction) {
-    case (gpio::DIR_OUT): {
-      result = gpiod_line_request_output(lineHandle, consumer.c_str(), regularGpio.initValue);
+    case (gpio::Direction::OUT): {
+      result = gpiod_line_request_output(lineHandle, consumer.c_str(),
+                                         static_cast<int>(regularGpio.initValue));
       break;
     }
-    case (gpio::DIR_IN): {
+    case (gpio::Direction::IN): {
       result = gpiod_line_request_input(lineHandle, consumer.c_str());
       break;
     }
@@ -211,7 +216,7 @@ ReturnValue_t LinuxLibgpioIF::pullHigh(gpioId_t gpioId) {
     if (regularGpio == nullptr) {
       return GPIO_TYPE_FAILURE;
     }
-    return driveGpio(gpioId, *regularGpio, gpio::HIGH);
+    return driveGpio(gpioId, *regularGpio, gpio::Levels::HIGH);
   } else {
     auto gpioCallback = dynamic_cast<GpioCallback*>(gpioMapIter->second);
     if (gpioCallback->callback == nullptr) {
@@ -243,7 +248,7 @@ ReturnValue_t LinuxLibgpioIF::pullLow(gpioId_t gpioId) {
     if (regularGpio == nullptr) {
       return GPIO_TYPE_FAILURE;
     }
-    return driveGpio(gpioId, *regularGpio, gpio::LOW);
+    return driveGpio(gpioId, *regularGpio, gpio::Levels::LOW);
   } else {
     auto gpioCallback = dynamic_cast<GpioCallback*>(gpioMapIter->second);
     if (gpioCallback->callback == nullptr) {
@@ -258,11 +263,11 @@ ReturnValue_t LinuxLibgpioIF::pullLow(gpioId_t gpioId) {
 
 ReturnValue_t LinuxLibgpioIF::driveGpio(gpioId_t gpioId, GpiodRegularBase& regularGpio,
                                         gpio::Levels logicLevel) {
-  int result = gpiod_line_set_value(regularGpio.lineHandle, logicLevel);
+  int result = gpiod_line_set_value(regularGpio.lineHandle, static_cast<int>(logicLevel));
   if (result < 0) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "LinuxLibgpioIF::driveGpio: Failed to pull GPIO with ID " << gpioId
-                 << " to logic level " << logicLevel << std::endl;
+                 << " to logic level " << static_cast<int>(logicLevel) << std::endl;
 #else
     sif::printWarning(
         "LinuxLibgpioIF::driveGpio: Failed to pull GPIO with ID %d to "
@@ -326,7 +331,7 @@ ReturnValue_t LinuxLibgpioIF::checkForConflicts(GpioMap& mapToAdd) {
         }
         break;
       }
-      case (gpio::GpioTypes::TYPE_CALLBACK): {
+      case (gpio::GpioTypes::CALLBACK): {
         auto callbackGpio = dynamic_cast<GpioCallback*>(gpioConfig.second);
         if (callbackGpio == nullptr) {
           return GPIO_TYPE_FAILURE;
@@ -366,13 +371,13 @@ ReturnValue_t LinuxLibgpioIF::checkForConflictsById(gpioId_t gpioIdToCheck,
       case (gpio::GpioTypes::GPIO_REGULAR_BY_CHIP):
       case (gpio::GpioTypes::GPIO_REGULAR_BY_LABEL):
       case (gpio::GpioTypes::GPIO_REGULAR_BY_LINE_NAME): {
-        if (gpioType == gpio::GpioTypes::NONE or gpioType == gpio::GpioTypes::TYPE_CALLBACK) {
+        if (gpioType == gpio::GpioTypes::NONE or gpioType == gpio::GpioTypes::CALLBACK) {
           eraseDuplicateDifferentType = true;
         }
         break;
       }
-      case (gpio::GpioTypes::TYPE_CALLBACK): {
-        if (gpioType != gpio::GpioTypes::TYPE_CALLBACK) {
+      case (gpio::GpioTypes::CALLBACK): {
+        if (gpioType != gpio::GpioTypes::CALLBACK) {
           eraseDuplicateDifferentType = true;
         }
       }

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

@@ -29,6 +29,8 @@ class LinuxLibgpioIF : public GpioIF, public SystemObject {
       HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 4);
   static constexpr ReturnValue_t GPIO_DUPLICATE_DETECTED =
       HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 5);
+  static constexpr ReturnValue_t GPIO_INIT_FAILED =
+      HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 6);
 
   LinuxLibgpioIF(object_id_t objectId);
   virtual ~LinuxLibgpioIF();

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

@@ -1,9 +1,14 @@
 #include "I2cComIF.h"
+
 #include "fsfw/FSFW.h"
 #include "fsfw/serviceinterface.h"
 #include "fsfw_hal/linux/UnixFileGuard.h"
 #include "fsfw_hal/linux/utility.h"
 
+#if FSFW_HAL_I2C_WIRETAPPING == 1
+#include "fsfw/globalfunctions/arrayprinter.h"
+#endif
+
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/i2c-dev.h>
@@ -12,7 +17,6 @@
 
 #include <cstring>
 
-
 I2cComIF::I2cComIF(object_id_t objectId) : SystemObject(objectId) {}
 
 I2cComIF::~I2cComIF() {}
@@ -112,6 +116,11 @@ ReturnValue_t I2cComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData, s
 #endif
     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 HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -176,6 +185,11 @@ ReturnValue_t I2cComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLe
     return HasReturnvaluesIF::RETURN_FAILED;
   }
 
+#if FSFW_HAL_I2C_WIRETAPPING == 1
+  sif::info << "I2C read bytes from bus " << deviceFile << ":" << std::endl;
+  arrayprinter::print(replyBuffer, requestLen);
+#endif
+
   i2cDeviceMapIter->second.replyLen = requestLen;
   return HasReturnvaluesIF::RETURN_OK;
 }

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

@@ -401,4 +401,12 @@ void SpiComIF::setSpiSpeedAndMode(int spiFd, spi::SpiModes mode, uint32_t speed)
   if (retval != 0) {
     utility::handleIoctlError("SpiComIF::setSpiSpeedAndMode: Setting SPI speed failed");
   }
+  // This updates the SPI clock default polarity. Only setting the mode does not update
+  // the line state, which can be an issue on mode switches because the clock line will
+  // switch the state after the chip select is pulled low
+  clockUpdateTransfer.len = 0;
+  retval = ioctl(spiFd, SPI_IOC_MESSAGE(1), &clockUpdateTransfer);
+  if (retval != 0) {
+    utility::handleIoctlError("SpiComIF::setSpiSpeedAndMode: Updating SPI default clock failed");
+  }
 }

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

@@ -74,6 +74,7 @@ class SpiComIF : public DeviceCommunicationIF, public SystemObject {
   MutexIF* spiMutex = nullptr;
   MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
   uint32_t timeoutMs = 20;
+  spi_ioc_transfer clockUpdateTransfer = {};
 
   using SpiDeviceMap = std::unordered_map<address_t, SpiInstance>;
   using SpiDeviceMapIter = SpiDeviceMap::iterator;

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

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

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

@@ -1,7 +1,4 @@
 #include "UartComIF.h"
-#include "fsfw/FSFW.h"
-#include "fsfw/serviceinterface.h"
-#include "fsfw_hal/linux/utility.h"
 
 #include <errno.h>
 #include <fcntl.h>
@@ -10,6 +7,10 @@
 
 #include <cstring>
 
+#include "fsfw/FSFW.h"
+#include "fsfw/serviceinterface.h"
+#include "fsfw_hal/linux/utility.h"
+
 UartComIF::UartComIF(object_id_t objectId) : SystemObject(objectId) {}
 
 UartComIF::~UartComIF() {}
@@ -147,16 +148,16 @@ void UartComIF::setDatasizeOptions(struct termios* options, UartCookie* uartCook
   /* Clear size bits */
   options->c_cflag &= ~CSIZE;
   switch (uartCookie->getBitsPerWord()) {
-    case 5:
+    case BitsPerWord::BITS_5:
       options->c_cflag |= CS5;
       break;
-    case 6:
+    case BitsPerWord::BITS_6:
       options->c_cflag |= CS6;
       break;
-    case 7:
+    case BitsPerWord::BITS_7:
       options->c_cflag |= CS7;
       break;
-    case 8:
+    case BitsPerWord::BITS_8:
       options->c_cflag |= CS8;
       break;
     default:
@@ -192,82 +193,128 @@ void UartComIF::setFixedOptions(struct termios* options) {
 
 void UartComIF::configureBaudrate(struct termios* options, UartCookie* uartCookie) {
   switch (uartCookie->getBaudrate()) {
-    case 50:
+    case UartBaudRate::RATE_50:
       cfsetispeed(options, B50);
       cfsetospeed(options, B50);
       break;
-    case 75:
+    case UartBaudRate::RATE_75:
       cfsetispeed(options, B75);
       cfsetospeed(options, B75);
       break;
-    case 110:
+    case UartBaudRate::RATE_110:
       cfsetispeed(options, B110);
       cfsetospeed(options, B110);
       break;
-    case 134:
+    case UartBaudRate::RATE_134:
       cfsetispeed(options, B134);
       cfsetospeed(options, B134);
       break;
-    case 150:
+    case UartBaudRate::RATE_150:
       cfsetispeed(options, B150);
       cfsetospeed(options, B150);
       break;
-    case 200:
+    case UartBaudRate::RATE_200:
       cfsetispeed(options, B200);
       cfsetospeed(options, B200);
       break;
-    case 300:
+    case UartBaudRate::RATE_300:
       cfsetispeed(options, B300);
       cfsetospeed(options, B300);
       break;
-    case 600:
+    case UartBaudRate::RATE_600:
       cfsetispeed(options, B600);
       cfsetospeed(options, B600);
       break;
-    case 1200:
+    case UartBaudRate::RATE_1200:
       cfsetispeed(options, B1200);
       cfsetospeed(options, B1200);
       break;
-    case 1800:
+    case UartBaudRate::RATE_1800:
       cfsetispeed(options, B1800);
       cfsetospeed(options, B1800);
       break;
-    case 2400:
+    case UartBaudRate::RATE_2400:
       cfsetispeed(options, B2400);
       cfsetospeed(options, B2400);
       break;
-    case 4800:
+    case UartBaudRate::RATE_4800:
       cfsetispeed(options, B4800);
       cfsetospeed(options, B4800);
       break;
-    case 9600:
+    case UartBaudRate::RATE_9600:
       cfsetispeed(options, B9600);
       cfsetospeed(options, B9600);
       break;
-    case 19200:
+    case UartBaudRate::RATE_19200:
       cfsetispeed(options, B19200);
       cfsetospeed(options, B19200);
       break;
-    case 38400:
+    case UartBaudRate::RATE_38400:
       cfsetispeed(options, B38400);
       cfsetospeed(options, B38400);
       break;
-    case 57600:
+    case UartBaudRate::RATE_57600:
       cfsetispeed(options, B57600);
       cfsetospeed(options, B57600);
       break;
-    case 115200:
+    case UartBaudRate::RATE_115200:
       cfsetispeed(options, B115200);
       cfsetospeed(options, B115200);
       break;
-    case 230400:
+    case UartBaudRate::RATE_230400:
       cfsetispeed(options, B230400);
       cfsetospeed(options, B230400);
       break;
-    case 460800:
+#ifndef __APPLE__
+    case UartBaudRate::RATE_460800:
       cfsetispeed(options, B460800);
       cfsetospeed(options, B460800);
       break;
+    case UartBaudRate::RATE_500000:
+      cfsetispeed(options, B500000);
+      cfsetospeed(options, B500000);
+      break;
+    case UartBaudRate::RATE_576000:
+      cfsetispeed(options, B576000);
+      cfsetospeed(options, B576000);
+      break;
+    case UartBaudRate::RATE_921600:
+      cfsetispeed(options, B921600);
+      cfsetospeed(options, B921600);
+      break;
+    case UartBaudRate::RATE_1000000:
+      cfsetispeed(options, B1000000);
+      cfsetospeed(options, B1000000);
+      break;
+    case UartBaudRate::RATE_1152000:
+      cfsetispeed(options, B1152000);
+      cfsetospeed(options, B1152000);
+      break;
+    case UartBaudRate::RATE_1500000:
+      cfsetispeed(options, B1500000);
+      cfsetospeed(options, B1500000);
+      break;
+    case UartBaudRate::RATE_2000000:
+      cfsetispeed(options, B2000000);
+      cfsetospeed(options, B2000000);
+      break;
+    case UartBaudRate::RATE_2500000:
+      cfsetispeed(options, B2500000);
+      cfsetospeed(options, B2500000);
+      break;
+    case UartBaudRate::RATE_3000000:
+      cfsetispeed(options, B3000000);
+      cfsetospeed(options, B3000000);
+      break;
+    case UartBaudRate::RATE_3500000:
+      cfsetispeed(options, B3500000);
+      cfsetospeed(options, B3500000);
+      break;
+    case UartBaudRate::RATE_4000000:
+      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;
@@ -426,7 +473,7 @@ ReturnValue_t UartComIF::handleNoncanonicalRead(UartCookie& uartCookie, UartDevi
   auto bufferPtr = iter->second.replyBuffer.data();
   // Size check to prevent buffer overflow
   if (requestLen > uartCookie.getMaxReplyLen()) {
-#if OBSW_VERBOSE_LEVEL >= 1
+#if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "UartComIF::requestReceiveMessage: Next read would cause overflow!"
                  << std::endl;

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

@@ -3,7 +3,7 @@
 #include <fsfw/serviceinterface.h>
 
 UartCookie::UartCookie(object_id_t handlerId, std::string deviceFile, UartModes uartMode,
-                       uint32_t baudrate, size_t maxReplyLen)
+                       UartBaudRate baudrate, size_t maxReplyLen)
     : handlerId(handlerId),
       deviceFile(deviceFile),
       uartMode(uartMode),
@@ -12,7 +12,7 @@ UartCookie::UartCookie(object_id_t handlerId, std::string deviceFile, UartModes
 
 UartCookie::~UartCookie() {}
 
-uint32_t UartCookie::getBaudrate() const { return baudrate; }
+UartBaudRate UartCookie::getBaudrate() const { return baudrate; }
 
 size_t UartCookie::getMaxReplyLen() const { return maxReplyLen; }
 
@@ -24,23 +24,9 @@ void UartCookie::setParityEven() { parity = Parity::EVEN; }
 
 Parity UartCookie::getParity() const { return parity; }
 
-void UartCookie::setBitsPerWord(uint8_t bitsPerWord_) {
-  switch (bitsPerWord_) {
-    case 5:
-    case 6:
-    case 7:
-    case 8:
-      break;
-    default:
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::debug << "UartCookie::setBitsPerWord: Invalid bits per word specified" << std::endl;
-#endif
-      return;
-  }
-  bitsPerWord = bitsPerWord_;
-}
+void UartCookie::setBitsPerWord(BitsPerWord bitsPerWord_) { bitsPerWord = bitsPerWord_; }
 
-uint8_t UartCookie::getBitsPerWord() const { return bitsPerWord; }
+BitsPerWord UartCookie::getBitsPerWord() const { return bitsPerWord; }
 
 StopBits UartCookie::getStopBits() const { return stopBits; }
 

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

@@ -12,6 +12,41 @@ enum class StopBits { ONE_STOP_BIT, TWO_STOP_BITS };
 
 enum class UartModes { CANONICAL, NON_CANONICAL };
 
+enum class BitsPerWord { BITS_5, BITS_6, BITS_7, BITS_8 };
+
+enum class UartBaudRate {
+  RATE_50,
+  RATE_75,
+  RATE_110,
+  RATE_134,
+  RATE_150,
+  RATE_200,
+  RATE_300,
+  RATE_600,
+  RATE_1200,
+  RATE_1800,
+  RATE_2400,
+  RATE_4800,
+  RATE_9600,
+  RATE_19200,
+  RATE_38400,
+  RATE_57600,
+  RATE_115200,
+  RATE_230400,
+  RATE_460800,
+  RATE_500000,
+  RATE_576000,
+  RATE_921600,
+  RATE_1000000,
+  RATE_1152000,
+  RATE_1500000,
+  RATE_2000000,
+  RATE_2500000,
+  RATE_3000000,
+  RATE_3500000,
+  RATE_4000000
+};
+
 /**
  * @brief   Cookie for the UartComIF. There are many options available to configure the UART driver.
  *          The constructor only requests for common options like the baudrate. Other options can
@@ -27,25 +62,23 @@ class UartCookie : public CookieIF {
    * @param uartMode      Specify the UART mode. The canonical mode should be used if the
    *                      messages are separated by a delimited character like '\n'. See the
    *                      termios documentation for more information
-   * @param baudrate      The baudrate to use for input and output. Possible Baudrates are: 50,
-   *                      75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800, 9600, B19200,
-   *                      38400, 57600, 115200, 230400, 460800
+   * @param baudrate      The baudrate to use for input and output.
    * @param maxReplyLen   The maximum size an object using this cookie expects
    * @details
    * Default configuration: No parity
    *                        8 databits (number of bits transfered with one uart frame)
    *                        One stop bit
    */
-  UartCookie(object_id_t handlerId, std::string deviceFile, UartModes uartMode, uint32_t baudrate,
-             size_t maxReplyLen);
+  UartCookie(object_id_t handlerId, std::string deviceFile, UartModes uartMode,
+             UartBaudRate baudrate, size_t maxReplyLen);
 
   virtual ~UartCookie();
 
-  uint32_t getBaudrate() const;
+  UartBaudRate getBaudrate() const;
   size_t getMaxReplyLen() const;
   std::string getDeviceFile() const;
   Parity getParity() const;
-  uint8_t getBitsPerWord() const;
+  BitsPerWord getBitsPerWord() const;
   StopBits getStopBits() const;
   UartModes getUartMode() const;
   object_id_t getHandlerId() const;
@@ -76,7 +109,7 @@ class UartCookie : public CookieIF {
   /**
    * Function two set number of bits per UART frame.
    */
-  void setBitsPerWord(uint8_t bitsPerWord_);
+  void setBitsPerWord(BitsPerWord bitsPerWord_);
 
   /**
    * Function to specify the number of stopbits.
@@ -97,10 +130,10 @@ class UartCookie : public CookieIF {
   std::string deviceFile;
   const UartModes uartMode;
   bool flushInput = false;
-  uint32_t baudrate;
+  UartBaudRate baudrate;
   size_t maxReplyLen = 0;
   Parity parity = Parity::NONE;
-  uint8_t bitsPerWord = 8;
+  BitsPerWord bitsPerWord = BitsPerWord::BITS_8;
   uint8_t readCycles = 1;
   StopBits stopBits = StopBits::ONE_STOP_BIT;
   bool replySizeFixed = true;

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

@@ -7,7 +7,11 @@
 #include <fstream>
 #include <sstream>
 
-#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw/serviceinterface.h"
+
+const char UioMapper::UIO_PATH_PREFIX[] = "/sys/class/uio/";
+const char UioMapper::MAP_SUBSTR[] = "/maps/map";
+const char UioMapper::SIZE_FILE_PATH[] = "/size";
 
 UioMapper::UioMapper(std::string uioFile, int mapNum) : uioFile(uioFile), mapNum(mapNum) {}
 
@@ -17,7 +21,9 @@ ReturnValue_t UioMapper::getMappedAdress(uint32_t** address, Permissions permiss
   ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
   int fd = open(uioFile.c_str(), O_RDWR);
   if (fd < 1) {
-    sif::warning << "PtmeAxiConfig::initialize: Invalid UIO device file" << std::endl;
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "PtmeAxiConfig::initialize: Invalid UIO device file" << std::endl;
+#endif
     return HasReturnvaluesIF::RETURN_FAILED;
   }
   size_t size = 0;
@@ -29,8 +35,10 @@ ReturnValue_t UioMapper::getMappedAdress(uint32_t** address, Permissions permiss
       mmap(NULL, size, static_cast<int>(permissions), MAP_SHARED, fd, mapNum * getpagesize()));
 
   if (*address == MAP_FAILED) {
-    sif::warning << "UioMapper::getMappedAdress: Failed to map physical address of uio device "
-                 << uioFile.c_str() << " and map" << static_cast<int>(mapNum) << std::endl;
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    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 HasReturnvaluesIF::RETURN_FAILED;
   }
   return HasReturnvaluesIF::RETURN_OK;
@@ -43,22 +51,34 @@ ReturnValue_t UioMapper::getMapSize(size_t* size) {
   FILE* fp;
   fp = fopen(namestream.str().c_str(), "r");
   if (fp == nullptr) {
-    sif::warning << "UioMapper::getMapSize: Failed to open file " << namestream.str() << std::endl;
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "UioMapper::getMapSize: Failed to open file " << namestream.str() << std::endl;
+#endif
     return HasReturnvaluesIF::RETURN_FAILED;
   }
   char hexstring[SIZE_HEX_STRING] = "";
   int items = fscanf(fp, "%s", hexstring);
   if (items != 1) {
-    sif::warning << "UioMapper::getMapSize: Failed with error code " << errno
-                 << " to read size "
-                    "string from file "
-                 << namestream.str() << std::endl;
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "UioMapper::getMapSize: Failed with error code " << errno
+               << " to read size "
+                  "string from file "
+               << namestream.str() << std::endl;
+#endif
+    fclose(fp);
     return HasReturnvaluesIF::RETURN_FAILED;
   }
-  items = sscanf(hexstring, "%x", size);
+  uint32_t sizeTmp = 0;
+  items = sscanf(hexstring, "%x", &sizeTmp);
+  if (size != nullptr) {
+    *size = sizeTmp;
+  }
   if (items != 1) {
-    sif::warning << "UioMapper::getMapSize: Failed with error code " << errno << "to convert "
-                 << "size of map" << mapNum << " to integer" << std::endl;
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "UioMapper::getMapSize: Failed with error code " << errno << "to convert "
+               << "size of map" << mapNum << " to integer" << std::endl;
+#endif
+    fclose(fp);
     return HasReturnvaluesIF::RETURN_FAILED;
   }
   fclose(fp);

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

@@ -39,9 +39,9 @@ class UioMapper {
   ReturnValue_t getMappedAdress(uint32_t** address, Permissions permissions);
 
  private:
-  static constexpr char UIO_PATH_PREFIX[] = "/sys/class/uio/";
-  static constexpr char MAP_SUBSTR[] = "/maps/map";
-  static constexpr char SIZE_FILE_PATH[] = "/size";
+  static const char UIO_PATH_PREFIX[];
+  static const char MAP_SUBSTR[];
+  static const char SIZE_FILE_PATH[];
   static constexpr int SIZE_HEX_STRING = 10;
 
   std::string uioFile;

hal/src/fsfw_hal/stm32h7/spi/mspInit.h

@@ -21,7 +21,7 @@ using mspCb = void (*)(void);
 namespace spi {
 
 struct MspCfgBase {
-  MspCfgBase();
+  MspCfgBase() {}
   MspCfgBase(stm32h7::GpioCfg sck, stm32h7::GpioCfg mosi, stm32h7::GpioCfg miso,
              mspCb cleanupCb = nullptr, mspCb setupCb = nullptr)
       : sck(sck), mosi(mosi), miso(miso), cleanupCb(cleanupCb), setupCb(setupCb) {}

scripts/helper.py

@@ -97,11 +97,11 @@ def handle_docs_type(args, build_dir_list: list):
         build_directory = determine_build_dir(build_dir_list)
     os.chdir(build_directory)
     if args.build:
-        os.system("cmake --build . -j")
+        cmd_runner("cmake --build . -j")
     if args.open:
         if not os.path.isfile("docs/sphinx/index.html"):
             # try again..
-            os.system("cmake --build . -j")
+            cmd_runner("cmake --build . -j")
             if not os.path.isfile("docs/sphinx/index.html"):
                 print(
                     "No Sphinx documentation file detected. "
@@ -143,22 +143,21 @@ def handle_tests_type(args, build_dir_list: list):
         if which("valgrind") is None:
             print("Please install valgrind first")
             sys.exit(1)
-        os.chdir(UNITTEST_FOLDER_NAME)
-        os.system("valgrind --leak-check=full ./fsfw-tests")
+        cmd_runner("valgrind --leak-check=full ./fsfw-tests")
         os.chdir("..")
 
 
 def create_tests_build_cfg():
     os.mkdir(UNITTEST_FOLDER_NAME)
     os.chdir(UNITTEST_FOLDER_NAME)
-    os.system("cmake -DFSFW_OSAL=host -DFSFW_BUILD_UNITTESTS=ON ..")
+    cmd_runner("cmake -DFSFW_OSAL=host -DFSFW_BUILD_UNITTESTS=ON ..")
     os.chdir("..")
 
 
 def create_docs_build_cfg():
     os.mkdir(DOCS_FOLDER_NAME)
     os.chdir(DOCS_FOLDER_NAME)
-    os.system("cmake -DFSFW_OSAL=host -DFSFW_BUILD_DOCS=ON ..")
+    cmd_runner("cmake -DFSFW_OSAL=host -DFSFW_BUILD_DOCS=ON ..")
     os.chdir("..")
 
 
@@ -181,7 +180,7 @@ def check_for_cmake_build_dir(build_dir_list: list) -> list:
 def perform_lcov_operation(directory: str, chdir: bool):
     if chdir:
         os.chdir(directory)
-    os.system("cmake --build . -- fsfw-tests_coverage -j")
+    cmd_runner("cmake --build . -- fsfw-tests_coverage -j")
 
 
 def determine_build_dir(build_dir_list: List[str]):
@@ -203,5 +202,10 @@ def determine_build_dir(build_dir_list: List[str]):
     return build_directory
 
 
+def cmd_runner(cmd: str):
+    print(f"Executing command: {cmd}")
+    os.system(cmd)
+
+
 if __name__ == "__main__":
     main()

src/fsfw/CMakeLists.txt

@@ -1,3 +1,7 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE
+    version.cpp
+)
+
 # Core
 
 add_subdirectory(action)

src/fsfw/FSFW.h.in

@@ -30,6 +30,10 @@
 #define FSFW_VERBOSE_LEVEL                  1
 #endif /* FSFW_VERBOSE_LEVEL */
 
+#ifndef FSFW_DISABLE_PRINTOUT
+#define FSFW_DISABLE_PRINTOUT               0
+#endif
+
 #ifndef FSFW_USE_REALTIME_FOR_LINUX
 #define FSFW_USE_REALTIME_FOR_LINUX         0
 #endif /* FSFW_USE_REALTIME_FOR_LINUX */
@@ -57,16 +61,9 @@
 #define FSFW_HAL_SPI_WIRETAPPING            0
 #endif
 
-#ifndef FSFW_HAL_L3GD20_GYRO_DEBUG
-#define FSFW_HAL_L3GD20_GYRO_DEBUG          0
-#endif /* FSFW_HAL_L3GD20_GYRO_DEBUG */
-
-#ifndef FSFW_HAL_RM3100_MGM_DEBUG
-#define FSFW_HAL_RM3100_MGM_DEBUG           0
-#endif /* FSFW_HAL_RM3100_MGM_DEBUG */
-
-#ifndef FSFW_HAL_LIS3MDL_MGM_DEBUG
-#define FSFW_HAL_LIS3MDL_MGM_DEBUG          0
-#endif /* FSFW_HAL_LIS3MDL_MGM_DEBUG */
+// Can be used for low-level debugging of the I2C bus
+#ifndef FSFW_HAL_I2C_WIRETAPPING
+#define FSFW_HAL_I2C_WIRETAPPING            0
+#endif
 
 #endif /* FSFW_FSFW_H_ */

src/fsfw/FSFWVersion.h.in

@@ -2,8 +2,8 @@
 #define FSFW_VERSION_H_
 
 // Versioning is kept in project CMakeLists.txt file
-#define FSFW_VERSION @FSFW_VERSION@
-#define FSFW_SUBVERSION @FSFW_SUBVERSION@
-#define FSFW_REVISION @FSFW_REVISION@
+#define FSFW_VERSION_MAJOR @FSFW_VERSION@
+#define FSFW_VERSION_MINOR @FSFW_SUBVERSION@
+#define FSFW_VERSION_REVISION @FSFW_REVISION@
 
 #endif /* FSFW_VERSION_H_ */

src/fsfw/cfdp/pdu/HeaderSerializer.h

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

src/fsfw/cfdp/tlv/FilestoreTlvBase.h

@@ -6,10 +6,13 @@
 #include <fsfw/cfdp/tlv/Tlv.h>
 #include <fsfw/cfdp/tlv/TlvIF.h>
 #include <fsfw/serialize/SerializeIF.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
 
 #include <cstddef>
 #include <cstdint>
 
+#include "fsfw/FSFW.h"
+
 namespace cfdp {
 
 enum FilestoreActionCode {

src/fsfw/container/FixedArrayList.h

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

src/fsfw/container/HybridIterator.h

@@ -10,16 +10,23 @@ class HybridIterator : public LinkedElement<T>::Iterator, public ArrayList<T, co
   HybridIterator() {}
 
   HybridIterator(typename LinkedElement<T>::Iterator *iter)
-      : LinkedElement<T>::Iterator(*iter), value(iter->value), linked(true) {}
+      : LinkedElement<T>::Iterator(*iter), linked(true) {
+    if (iter != nullptr) {
+      value = iter->value;
+    }
+  }
 
-  HybridIterator(LinkedElement<T> *start)
-      : LinkedElement<T>::Iterator(start), value(start->value), linked(true) {}
+  HybridIterator(LinkedElement<T> *start) : LinkedElement<T>::Iterator(start), linked(true) {
+    if (start != nullptr) {
+      value = start->value;
+    }
+  }
 
   HybridIterator(typename ArrayList<T, count_t>::Iterator start,
                  typename ArrayList<T, count_t>::Iterator end)
       : ArrayList<T, count_t>::Iterator(start), value(start.value), linked(false), end(end.value) {
     if (value == this->end) {
-      value = NULL;
+      value = nullptr;
     }
   }
 

src/fsfw/controller/ControllerBase.h

@@ -1,7 +1,6 @@
 #ifndef FSFW_CONTROLLER_CONTROLLERBASE_H_
 #define FSFW_CONTROLLER_CONTROLLERBASE_H_
 
-#include "fsfw/datapool/HkSwitchHelper.h"
 #include "fsfw/health/HasHealthIF.h"
 #include "fsfw/health/HealthHelper.h"
 #include "fsfw/modes/HasModesIF.h"
@@ -56,7 +55,7 @@ class ControllerBase : public HasModesIF,
   virtual void performControlOperation() = 0;
 
   virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-                                         uint32_t *msToReachTheMode) = 0;
+                                         uint32_t *msToReachTheMode) override = 0;
 
   const object_id_t parentId;
 
@@ -81,9 +80,9 @@ class ControllerBase : public HasModesIF,
 
   /** Mode helpers */
   virtual void modeChanged(Mode_t mode, Submode_t submode);
-  virtual void startTransition(Mode_t mode, Submode_t submode);
-  virtual void getMode(Mode_t *mode, Submode_t *submode);
-  virtual void setToExternalControl();
+  virtual void startTransition(Mode_t mode, Submode_t submode) override;
+  virtual void getMode(Mode_t *mode, Submode_t *submode) override;
+  virtual void setToExternalControl() override;
   virtual void announceMode(bool recursive);
   /** HK helpers */
   virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);

src/fsfw/datapool/CMakeLists.txt

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

src/fsfw/datapool/HkSwitchHelper.cpp

@@ -1,67 +0,0 @@
-#include "fsfw/datapool/HkSwitchHelper.h"
-
-#include "fsfw/ipc/QueueFactory.h"
-
-HkSwitchHelper::HkSwitchHelper(EventReportingProxyIF* eventProxy)
-    : commandActionHelper(this), eventProxy(eventProxy) {
-  actionQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-HkSwitchHelper::~HkSwitchHelper() { QueueFactory::instance()->deleteMessageQueue(actionQueue); }
-
-ReturnValue_t HkSwitchHelper::initialize() {
-  ReturnValue_t result = commandActionHelper.initialize();
-
-  if (result != HasReturnvaluesIF::RETURN_OK) {
-    return result;
-  }
-
-  return result;
-}
-
-ReturnValue_t HkSwitchHelper::performOperation(uint8_t operationCode) {
-  CommandMessage command;
-  while (actionQueue->receiveMessage(&command) == HasReturnvaluesIF::RETURN_OK) {
-    ReturnValue_t result = commandActionHelper.handleReply(&command);
-    if (result == HasReturnvaluesIF::RETURN_OK) {
-      continue;
-    }
-    command.setToUnknownCommand();
-    actionQueue->reply(&command);
-  }
-
-  return HasReturnvaluesIF::RETURN_OK;
-}
-
-void HkSwitchHelper::stepSuccessfulReceived(ActionId_t actionId, uint8_t step) {}
-
-void HkSwitchHelper::stepFailedReceived(ActionId_t actionId, uint8_t step,
-                                        ReturnValue_t returnCode) {
-  eventProxy->forwardEvent(SWITCHING_TM_FAILED, returnCode, actionId);
-}
-
-void HkSwitchHelper::dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) {}
-
-void HkSwitchHelper::completionSuccessfulReceived(ActionId_t actionId) {}
-
-void HkSwitchHelper::completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode) {
-  eventProxy->forwardEvent(SWITCHING_TM_FAILED, returnCode, actionId);
-}
-
-ReturnValue_t HkSwitchHelper::switchHK(SerializeIF* sids, bool enable) {
-  //	ActionId_t action = HKService::DISABLE_HK;
-  //	if (enable) {
-  //		action = HKService::ENABLE_HK;
-  //	}
-  //
-  //	ReturnValue_t result = commandActionHelper.commandAction(
-  //			objects::PUS_HK_SERVICE, action, sids);
-  //
-  //	if (result != HasReturnvaluesIF::RETURN_OK) {
-  //		eventProxy->forwardEvent(SWITCHING_TM_FAILED, result);
-  //	}
-  //	return result;
-  return HasReturnvaluesIF::RETURN_OK;
-}
-
-MessageQueueIF* HkSwitchHelper::getCommandQueuePtr() { return actionQueue; }

src/fsfw/datapool/HkSwitchHelper.h

@@ -1,44 +0,0 @@
-#ifndef FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_
-#define FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_
-
-#include "fsfw/action/CommandsActionsIF.h"
-#include "fsfw/events/EventReportingProxyIF.h"
-#include "fsfw/tasks/ExecutableObjectIF.h"
-
-// TODO this class violations separation between mission and framework
-// but it is only a transitional solution until the Datapool is
-// implemented decentrally
-
-class HkSwitchHelper : public ExecutableObjectIF, public CommandsActionsIF {
- public:
-  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::HK;
-  static const Event SWITCHING_TM_FAILED =
-      MAKE_EVENT(1, severity::LOW);  //!< Commanding the HK Service failed, p1: error code, p2
-                                     //!< action: 0 disable / 1 enable
-
-  HkSwitchHelper(EventReportingProxyIF* eventProxy);
-  virtual ~HkSwitchHelper();
-
-  ReturnValue_t initialize();
-
-  virtual ReturnValue_t performOperation(uint8_t operationCode = 0);
-
-  ReturnValue_t switchHK(SerializeIF* sids, bool enable);
-
-  virtual void setTaskIF(PeriodicTaskIF* task_){};
-
- protected:
-  virtual void stepSuccessfulReceived(ActionId_t actionId, uint8_t step);
-  virtual void stepFailedReceived(ActionId_t actionId, uint8_t step, ReturnValue_t returnCode);
-  virtual void dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size);
-  virtual void completionSuccessfulReceived(ActionId_t actionId);
-  virtual void completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode);
-  virtual MessageQueueIF* getCommandQueuePtr();
-
- private:
-  CommandActionHelper commandActionHelper;
-  MessageQueueIF* actionQueue;
-  EventReportingProxyIF* eventProxy;
-};
-
-#endif /* FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_ */

src/fsfw/datapool/PoolDataSetBase.h

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

src/fsfw/datapoollocal/LocalDataPoolManager.cpp

@@ -84,8 +84,8 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
     return result;
   }
 
-  printWarningOrError(sif::OutputTypes::OUT_WARNING, "initialize", HasReturnvaluesIF::RETURN_FAILED,
-                      "The map should only be initialized once");
+  printWarningOrError(sif::OutputTypes::OUT_WARNING, "initializeHousekeepingPoolEntriesOnce",
+                      HasReturnvaluesIF::RETURN_FAILED, "The map should only be initialized once");
   return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -787,6 +787,10 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid, bool i
   // Serialize set packet into store.
   size_t size = 0;
   result = setPacket.serialize(&storePtr, &size, expectedSize, SerializeIF::Endianness::BIG);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    ipcStore->deleteData(storeId);
+    return result;
+  }
   if (expectedSize != size) {
     printWarningOrError(sif::OutputTypes::OUT_WARNING, "generateSetStructurePacket",
                         HasReturnvaluesIF::RETURN_FAILED,
@@ -801,7 +805,10 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid, bool i
     HousekeepingMessage::setHkStuctureReportReply(&reply, sid, storeId);
   }
 
-  hkQueue->reply(&reply);
+  result = hkQueue->reply(&reply);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    ipcStore->deleteData(storeId);
+  }
   return result;
 }
 

src/fsfw/datapoollocal/LocalPoolDataSetBase.cpp

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

src/fsfw/datapoollocal/LocalPoolObjectBase.h

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

src/fsfw/datapoollocal/StaticLocalDataSet.h

@@ -46,7 +46,7 @@ class StaticLocalDataSet : public LocalPoolDataSetBase {
   }
 
  private:
-  std::array<PoolVariableIF*, NUM_VARIABLES> poolVarList;
+  std::array<PoolVariableIF*, NUM_VARIABLES> poolVarList = {};
 };
 
 #endif /* FSFW_DATAPOOLLOCAL_STATICLOCALDATASET_H_ */

src/fsfw/devicehandlers/DeviceHandlerBase.cpp

@@ -410,7 +410,7 @@ ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(
     DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles, LocalPoolDataSetBase* replyDataSet,
     size_t replyLen, bool periodic, bool hasDifferentReplyId, DeviceCommandId_t replyId) {
   // No need to check, as we may try to insert multiple times.
-  insertInCommandMap(deviceCommand);
+  insertInCommandMap(deviceCommand, hasDifferentReplyId, replyId);
   if (hasDifferentReplyId) {
     return insertInReplyMap(replyId, maxDelayCycles, replyDataSet, replyLen, periodic);
   } else {
@@ -437,11 +437,15 @@ ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
   }
 }
 
-ReturnValue_t DeviceHandlerBase::insertInCommandMap(DeviceCommandId_t deviceCommand) {
+ReturnValue_t DeviceHandlerBase::insertInCommandMap(DeviceCommandId_t deviceCommand,
+                                                    bool useAlternativeReply,
+                                                    DeviceCommandId_t alternativeReplyId) {
   DeviceCommandInfo info;
   info.expectedReplies = 0;
   info.isExecuting = false;
   info.sendReplyTo = NO_COMMANDER;
+  info.useAlternativeReplyId = alternativeReplyId;
+  info.alternativeReplyId = alternativeReplyId;
   auto resultPair = deviceCommandMap.emplace(deviceCommand, info);
   if (resultPair.second) {
     return RETURN_OK;
@@ -451,12 +455,20 @@ ReturnValue_t DeviceHandlerBase::insertInCommandMap(DeviceCommandId_t deviceComm
 }
 
 size_t DeviceHandlerBase::getNextReplyLength(DeviceCommandId_t commandId) {
-  DeviceReplyIter iter = deviceReplyMap.find(commandId);
-  if (iter != deviceReplyMap.end()) {
-    return iter->second.replyLen;
+  DeviceCommandId_t replyId = NO_COMMAND_ID;
+  DeviceCommandMap::iterator command = cookieInfo.pendingCommand;
+  if (command->second.useAlternativeReplyId) {
+    replyId = command->second.alternativeReplyId;
   } else {
-    return 0;
+    replyId = commandId;
   }
+  DeviceReplyIter iter = deviceReplyMap.find(replyId);
+  if (iter != deviceReplyMap.end()) {
+    if (iter->second.delayCycles != 0) {
+      return iter->second.replyLen;
+    }
+  }
+  return 0;
 }
 
 ReturnValue_t DeviceHandlerBase::updateReplyMapEntry(DeviceCommandId_t deviceReply,
@@ -651,7 +663,9 @@ void DeviceHandlerBase::doGetWrite() {
 
     // We need to distinguish here, because a raw command never expects a reply.
     //(Could be done in eRIRM, but then child implementations need to be careful.
-    result = enableReplyInReplyMap(cookieInfo.pendingCommand);
+    DeviceCommandMap::iterator command = cookieInfo.pendingCommand;
+    result = enableReplyInReplyMap(command, 1, command->second.useAlternativeReplyId,
+                                   command->second.alternativeReplyId);
   } else {
     // always generate a failure event, so that FDIR knows what's up
     triggerEvent(DEVICE_SENDING_COMMAND_FAILED, result, cookieInfo.pendingCommand->first);
@@ -824,7 +838,7 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData, DeviceCommandId
 }
 
 ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress, uint8_t** data,
-                                                uint32_t* len) {
+                                                size_t* len) {
   size_t lenTmp;
 
   if (IPCStore == nullptr) {

src/fsfw/devicehandlers/DeviceHandlerBase.h

@@ -163,7 +163,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * @param counter Specifies which Action to perform
    * @return RETURN_OK for successful execution
    */
-  virtual ReturnValue_t performOperation(uint8_t counter);
+  virtual ReturnValue_t performOperation(uint8_t counter) override;
 
   /**
    * @brief  Initializes the device handler
@@ -173,7 +173,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * Calls fillCommandAndReplyMap().
    * @return
    */
-  virtual ReturnValue_t initialize();
+  virtual ReturnValue_t initialize() override;
 
   /**
    * @brief   Intialization steps performed after all tasks have been created.
@@ -478,7 +478,9 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * @return - @c RETURN_OK when the command was successfully inserted,
    *         - @c RETURN_FAILED else.
    */
-  ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand);
+  ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand,
+                                   bool useAlternativeReply = false,
+                                   DeviceCommandId_t alternativeReplyId = 0);
 
   /**
    * Enables a periodic reply for a given command. It sets to delay cycles to the specified
@@ -673,7 +675,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   //! Pointer to the raw packet that will be sent.
   uint8_t *rawPacket = nullptr;
   //! Size of the #rawPacket.
-  uint32_t rawPacketLen = 0;
+  size_t rawPacketLen = 0;
 
   /**
    * The mode the device handler is currently in.
@@ -751,6 +753,8 @@ class DeviceHandlerBase : public DeviceHandlerIF,
     //! if this is != NO_COMMANDER, DHB was commanded externally and shall
     //! report everything to commander.
     MessageQueueId_t sendReplyTo;
+    bool useAlternativeReplyId;
+    DeviceCommandId_t alternativeReplyId;
   };
   using DeviceCommandMap = std::map<DeviceCommandId_t, DeviceCommandInfo>;
   /**
@@ -1054,11 +1058,11 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * @param parameter1	Optional parameter 1
    * @param parameter2	Optional parameter 2
    */
-  void triggerEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0);
+  void triggerEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) override;
   /**
    * Same as triggerEvent, but for forwarding if object is used as proxy.
    */
-  virtual void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const;
+  virtual void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const override;
 
   /**
    * Checks if current mode is transitional mode.
@@ -1250,7 +1254,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    *   - @c RETURN_FAILED IPCStore is nullptr
    *   - the return value from the IPCStore if it was not @c RETURN_OK
    */
-  ReturnValue_t getStorageData(store_address_t storageAddress, uint8_t **data, uint32_t *len);
+  ReturnValue_t getStorageData(store_address_t storageAddress, uint8_t **data, size_t *len);
 
   /**
    * @param modeTo either @c MODE_ON, MODE_NORMAL or MODE_RAW, nothing else!

src/fsfw/devicehandlers/DeviceHandlerFailureIsolation.cpp

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

src/fsfw/devicehandlers/DeviceHandlerIF.h

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

src/fsfw/events/Event.h

@@ -7,8 +7,14 @@
 // could be moved to more suitable location
 #include <events/subsystemIdRanges.h>
 
-typedef uint16_t EventId_t;
-typedef uint8_t EventSeverity_t;
+using EventId_t = uint16_t;
+using EventSeverity_t = uint8_t;
+using UniqueEventId_t = uint8_t;
+
+namespace severity {
+enum Severity : EventSeverity_t { INFO = 1, LOW = 2, MEDIUM = 3, HIGH = 4 };
+
+}  // namespace severity
 
 #define MAKE_EVENT(id, severity) (((severity) << 16) + (SUBSYSTEM_ID * 100) + (id))
 
@@ -20,18 +26,11 @@ constexpr EventId_t getEventId(Event event) { return (event & 0xFFFF); }
 
 constexpr EventSeverity_t getSeverity(Event event) { return ((event >> 16) & 0xFF); }
 
-constexpr Event makeEvent(uint8_t subsystemId, uint8_t uniqueEventId,
+constexpr Event makeEvent(uint8_t subsystemId, UniqueEventId_t uniqueEventId,
                           EventSeverity_t eventSeverity) {
   return (eventSeverity << 16) + (subsystemId * 100) + uniqueEventId;
 }
 
 }  // namespace event
 
-namespace severity {
-static constexpr EventSeverity_t INFO = 1;
-static constexpr EventSeverity_t LOW = 2;
-static constexpr EventSeverity_t MEDIUM = 3;
-static constexpr EventSeverity_t HIGH = 4;
-}  // namespace severity
-
 #endif /* EVENTOBJECT_EVENT_H_ */

src/fsfw/globalfunctions/CRC.cpp

@@ -28,7 +28,7 @@ const uint16_t CRC::crc16ccitt_table[256] = {
 
 // CRC implementation
 uint16_t CRC::crc16ccitt(uint8_t const input[], uint32_t length, uint16_t startingCrc) {
-  uint8_t *data = (uint8_t *)input;
+  const uint8_t *data = static_cast<const uint8_t *>(input);
   unsigned int tbl_idx;
 
   while (length--) {
@@ -39,88 +39,4 @@ uint16_t CRC::crc16ccitt(uint8_t const input[], uint32_t length, uint16_t starti
   }
   return startingCrc & 0xffff;
 
-  // The part below is not used!
-  //	bool temr[16];
-  //	bool xor_out[16];
-  //	bool r[16];
-  //	bool d[8];
-  //	uint16_t crc_value = 0;
-  //
-  //
-  //	for (int i=0; i<16 ;i++) {
-  //		temr[i] = false;
-  //		xor_out[i] = false;
-  //	}
-  //
-  //
-  //	for (int i=0; i<16 ;i++)
-  //			r[i] = true;    // initialize with 0xFFFF
-  //
-  //
-  //
-  //	for (int j=0; j<length ;j++)
-  //	{
-  //
-  //	for (int i=0; i<8 ;i++)
-  //		if ((input[j] & 1<<i) == 1<<i)
-  //			d[7-i]=true;			// reverse   input data
-  //		else
-  //			d[7-i]=false;			// reverse input data
-  //
-  //
-  //
-  //		  temr[0] = d[4] ^ d[0];
-  //		  temr[1] = d[5] ^ d[1];
-  //		  temr[2] = d[6] ^ d[2];
-  //		  temr[3] = d[7] ^ d[3];
-  //		  temr[4] = r[12] ^ r[8];
-  //		  temr[5] = r[13] ^ r[9];
-  //		  temr[6] = r[14] ^ r[10];
-  //		  temr[7] = r[15] ^ r[11];
-  //		  temr[8] = d[4] ^ r[12];
-  //		  temr[9] = d[5] ^ r[13];
-  //		  temr[10] = d[6] ^ r[14];
-  //		  temr[11] = d[7] ^ r[15];
-  //		  temr[12] = temr[0] ^ temr[4];
-  //		  temr[13] = temr[1] ^ temr[5];
-  //		  temr[14] = temr[2] ^ temr[6];
-  //		  temr[15] = temr[3] ^ temr[7];
-  //
-  //
-  //		  xor_out[0] = temr[12];
-  //		  xor_out[1] = temr[13];
-  //		  xor_out[2] = temr[14];
-  //		  xor_out[3] = temr[15];
-  //		  xor_out[4] = temr[8];
-  //		  xor_out[5] = temr[9] ^ temr[12];
-  //		  xor_out[6] = temr[10] ^ temr[13];
-  //		  xor_out[7] = temr[11] ^ temr[14];
-  //		  xor_out[8] = temr[15] ^ r[0];
-  //		  xor_out[9] = temr[8] ^ r[1];
-  //		  xor_out[10] = temr[9] ^ r[2];
-  //		  xor_out[11] = temr[10] ^ r[3];
-  //		  xor_out[12] = temr[11] ^ temr[12] ^ r[4];
-  //		  xor_out[13] = temr[13] ^ r[5];
-  //		  xor_out[14] = temr[14] ^ r[6];
-  //		  xor_out[15] = temr[15] ^ r[7];
-  //
-  //	 for (int i=0; i<16 ;i++)
-  //	 {
-  //		  r[i]= xor_out[i] ;
-  //	 }
-  //
-  //	}
-  //
-  //
-  //
-  //	for (int i=0; i<16 ;i++)
-  //	{
-  //		 if  (xor_out[i] == true)
-  //			 crc_value = crc_value + pow(2,(15 -i));   // reverse CrC result before
-  //Final XOR
-  //	}
-  //
-  //	crc_value = 0;// for debug mode
-  //	return (crc_value);
-
 } /* Calculate_CRC() */

src/fsfw/globalfunctions/arrayprinter.cpp

@@ -1,6 +1,7 @@
 #include "fsfw/globalfunctions/arrayprinter.h"
 
 #include <bitset>
+#include <cmath>
 
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
@@ -68,7 +69,7 @@ void arrayprinter::printHex(const uint8_t *data, size_t size, size_t maxCharPerL
     currentPos += snprintf(printBuffer + currentPos, 6, "%02x", data[i]);
     if (i < size - 1) {
       currentPos += sprintf(printBuffer + currentPos, ",");
-      if (i > 0 and (i + 1) % maxCharPerLine == 0) {
+      if ((i + 1) % maxCharPerLine == 0) {
         currentPos += sprintf(printBuffer + currentPos, "\n");
       }
     }
@@ -97,20 +98,21 @@ void arrayprinter::printDec(const uint8_t *data, size_t size, size_t maxCharPerL
   }
   std::cout << "]" << std::endl;
 #else
-  // General format: 32, 243, -12 so it is number of chars times 5
+  // General format: 32,243,-12 so it is number of chars times 4
   // plus line break plus small safety margin.
-  char printBuffer[(size + 1) * 5 + 1] = {};
+  uint16_t expectedLines = ceil((double)size / maxCharPerLine);
+  char printBuffer[size * 4 + 1 + expectedLines] = {};
   size_t currentPos = 0;
   for (size_t i = 0; i < size; i++) {
     // To avoid buffer overflows.
-    if (sizeof(printBuffer) - currentPos <= 5) {
+    if (sizeof(printBuffer) - currentPos <= 4) {
       break;
     }
 
-    currentPos += snprintf(printBuffer + currentPos, 3, "%d", data[i]);
+    currentPos += snprintf(printBuffer + currentPos, 4, "%d", data[i]);
     if (i < size - 1) {
       currentPos += sprintf(printBuffer + currentPos, ",");
-      if (i > 0 and (i + 1) % maxCharPerLine == 0) {
+      if ((i + 1) % maxCharPerLine == 0) {
         currentPos += sprintf(printBuffer + currentPos, "\n");
       }
     }

src/fsfw/globalfunctions/matching/MatchTree.h

@@ -25,7 +25,7 @@ class MatchTree : public SerializeableMatcherIF<T>, public BinaryTree<Serializea
       : BinaryTree<SerializeableMatcherIF<T>>(root.element), maxDepth(maxDepth) {}
   MatchTree() : BinaryTree<SerializeableMatcherIF<T>>(), maxDepth(-1) {}
   virtual ~MatchTree() {}
-  virtual bool match(T number) { return matchesTree(number); }
+  virtual bool match(T number) override { return matchesTree(number); }
   bool matchesTree(T number) {
     iterator iter = this->begin();
     if (iter == this->end()) {
@@ -179,6 +179,9 @@ class MatchTree : public SerializeableMatcherIF<T>, public BinaryTree<Serializea
   virtual ReturnValue_t cleanUpElement(iterator position) { return HasReturnvaluesIF::RETURN_OK; }
 
   bool matchSubtree(iterator iter, T number) {
+    if (iter == nullptr) {
+      return false;
+    }
     bool isMatch = iter->match(number);
     if (isMatch) {
       if (iter.left() == this->end()) {

src/fsfw/globalfunctions/matching/RangeMatcher.h

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

src/fsfw/internalerror/InternalErrorReporter.cpp

@@ -57,6 +57,9 @@ ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
       internalErrorDataset.storeHits.value += newStoreHits;
       internalErrorDataset.tmHits.value += newTmHits;
       internalErrorDataset.setValidity(true, true);
+      if ((newQueueHits != 0) or (newStoreHits != 0) or (newTmHits != 0)) {
+        internalErrorDataset.setChanged(true);
+      }
     }
   }
 
@@ -77,14 +80,6 @@ uint32_t InternalErrorReporter::getAndResetQueueHits() {
   return value;
 }
 
-uint32_t InternalErrorReporter::getQueueHits() {
-  uint32_t value;
-  mutex->lockMutex(timeoutType, timeoutMs);
-  value = queueHits;
-  mutex->unlockMutex();
-  return value;
-}
-
 void InternalErrorReporter::incrementQueueHits() {
   mutex->lockMutex(timeoutType, timeoutMs);
   queueHits++;
@@ -100,14 +95,6 @@ uint32_t InternalErrorReporter::getAndResetTmHits() {
   return value;
 }
 
-uint32_t InternalErrorReporter::getTmHits() {
-  uint32_t value;
-  mutex->lockMutex(timeoutType, timeoutMs);
-  value = tmHits;
-  mutex->unlockMutex();
-  return value;
-}
-
 void InternalErrorReporter::incrementTmHits() {
   mutex->lockMutex(timeoutType, timeoutMs);
   tmHits++;
@@ -125,14 +112,6 @@ uint32_t InternalErrorReporter::getAndResetStoreHits() {
   return value;
 }
 
-uint32_t InternalErrorReporter::getStoreHits() {
-  uint32_t value;
-  mutex->lockMutex(timeoutType, timeoutMs);
-  value = storeHits;
-  mutex->unlockMutex();
-  return value;
-}
-
 void InternalErrorReporter::incrementStoreHits() {
   mutex->lockMutex(timeoutType, timeoutMs);
   storeHits++;

src/fsfw/internalerror/InternalErrorReporter.h

@@ -46,11 +46,11 @@ class InternalErrorReporter : public SystemObject,
   virtual ReturnValue_t initializeAfterTaskCreation() override;
   virtual ReturnValue_t performOperation(uint8_t opCode) override;
 
-  virtual void queueMessageNotSent();
+  virtual void queueMessageNotSent() override;
 
-  virtual void lostTm();
+  virtual void lostTm() override;
 
-  virtual void storeFull();
+  virtual void storeFull() override;
 
   virtual void setTaskIF(PeriodicTaskIF* task) override;
 
@@ -74,15 +74,12 @@ class InternalErrorReporter : public SystemObject,
   uint32_t storeHits = 0;
 
   uint32_t getAndResetQueueHits();
-  uint32_t getQueueHits();
   void incrementQueueHits();
 
   uint32_t getAndResetTmHits();
-  uint32_t getTmHits();
   void incrementTmHits();
 
   uint32_t getAndResetStoreHits();
-  uint32_t getStoreHits();
   void incrementStoreHits();
 };
 

src/fsfw/internalerror/InternalErrorReporterIF.h

@@ -1,22 +1,34 @@
 #ifndef INTERNALERRORREPORTERIF_H_
 #define INTERNALERRORREPORTERIF_H_
 
+/**
+ * @brief   Interface which is used to report internal errors like full message queues or stores.
+ * @details
+ * This interface smust be used for the InteralErrorReporter object.
+ * It should be used to indicate that there was a Problem with Queues or Stores.
+ *
+ * It can be used to report missing Telemetry which could not be sent due to a internal problem.
+ *
+ */
 class InternalErrorReporterIF {
  public:
   virtual ~InternalErrorReporterIF() {}
-
   /**
-   * Thread safe
+   * @brief Function to be called if a message queue could not be sent.
+   * @details OSAL Implementations should call this function to indicate that
+   * a message was lost.
+   *
+   *  Implementations are required to be Thread safe
    */
   virtual void queueMessageNotSent() = 0;
-
   /**
-   * Thread safe
+   * @brief Function to be called if Telemetry could not be sent
+   * @details Implementations must be Thread safe
    */
   virtual void lostTm() = 0;
-
   /**
-   * Thread safe
+   * @brief Function to be called if a onboard storage is full
+   * @details Implementations must be Thread safe
    */
   virtual void storeFull() = 0;
 };

src/fsfw/ipc/CMakeLists.txt

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

src/fsfw/ipc/MessageQueueBase.cpp

@@ -0,0 +1,54 @@
+#include "MessageQueueBase.h"
+
+MessageQueueBase::MessageQueueBase(MessageQueueId_t id, MessageQueueId_t defaultDest, MqArgs* args)
+    : id(id) {
+  this->defaultDest = defaultDest;
+  if (args != nullptr) {
+    this->args = *args;
+  }
+}
+
+MessageQueueBase::~MessageQueueBase() {}
+
+ReturnValue_t MessageQueueBase::sendToDefault(MessageQueueMessageIF* message) {
+  return sendToDefaultFrom(message, this->getId(), false);
+}
+
+ReturnValue_t MessageQueueBase::reply(MessageQueueMessageIF* message) {
+  if (this->last != MessageQueueIF::NO_QUEUE) {
+    return sendMessageFrom(this->last, message, this->getId());
+  } else {
+    return NO_REPLY_PARTNER;
+  }
+}
+
+ReturnValue_t MessageQueueBase::receiveMessage(MessageQueueMessageIF* message,
+                                               MessageQueueId_t* receivedFrom) {
+  ReturnValue_t status = this->receiveMessage(message);
+  *receivedFrom = this->last;
+  return status;
+}
+
+MessageQueueId_t MessageQueueBase::getLastPartner() const { return last; }
+
+MessageQueueId_t MessageQueueBase::getId() const { return id; }
+
+MqArgs& MessageQueueBase::getMqArgs() { return args; }
+
+void MessageQueueBase::setDefaultDestination(MessageQueueId_t defaultDestination) {
+  this->defaultDest = defaultDestination;
+}
+
+MessageQueueId_t MessageQueueBase::getDefaultDestination() const { return defaultDest; }
+
+bool MessageQueueBase::isDefaultDestinationSet() const { return (defaultDest != NO_QUEUE); }
+
+ReturnValue_t MessageQueueBase::sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
+                                            bool ignoreFault) {
+  return sendMessageFrom(sendTo, message, this->getId(), false);
+}
+
+ReturnValue_t MessageQueueBase::sendToDefaultFrom(MessageQueueMessageIF* message,
+                                                  MessageQueueId_t sentFrom, bool ignoreFault) {
+  return sendMessageFrom(defaultDest, message, sentFrom, ignoreFault);
+}

src/fsfw/ipc/MessageQueueBase.h

@@ -0,0 +1,40 @@
+#ifndef FSFW_SRC_FSFW_IPC_MESSAGEQUEUEBASE_H_
+#define FSFW_SRC_FSFW_IPC_MESSAGEQUEUEBASE_H_
+
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/ipc/definitions.h>
+
+class MessageQueueBase : public MessageQueueIF {
+ public:
+  MessageQueueBase(MessageQueueId_t id, MessageQueueId_t defaultDest, MqArgs* mqArgs);
+  virtual ~MessageQueueBase();
+
+  // Default implementations for MessageQueueIF where possible
+  virtual MessageQueueId_t getLastPartner() const override;
+  virtual MessageQueueId_t getId() const override;
+  virtual MqArgs& getMqArgs() override;
+  virtual void setDefaultDestination(MessageQueueId_t defaultDestination) override;
+  virtual MessageQueueId_t getDefaultDestination() const override;
+  virtual bool isDefaultDestinationSet() const override;
+  virtual ReturnValue_t sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
+                                    bool ignoreFault) override;
+  virtual ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
+  virtual ReturnValue_t reply(MessageQueueMessageIF* message) override;
+  virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
+                                       MessageQueueId_t* receivedFrom) override;
+  virtual ReturnValue_t sendToDefaultFrom(MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+                                          bool ignoreFault = false) override;
+
+  // OSAL specific, forward the abstract function
+  virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) = 0;
+  virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
+                                        MessageQueueId_t sentFrom, bool ignoreFault = false) = 0;
+
+ protected:
+  MessageQueueId_t id = MessageQueueIF::NO_QUEUE;
+  MessageQueueId_t last = MessageQueueIF::NO_QUEUE;
+  MessageQueueId_t defaultDest = MessageQueueIF::NO_QUEUE;
+  MqArgs args = {};
+};
+
+#endif /* FSFW_SRC_FSFW_IPC_MESSAGEQUEUEBASE_H_ */

src/fsfw/ipc/MessageQueueIF.h

@@ -1,6 +1,8 @@
 #ifndef FSFW_IPC_MESSAGEQUEUEIF_H_
 #define FSFW_IPC_MESSAGEQUEUEIF_H_
 
+#include <fsfw/ipc/definitions.h>
+
 #include <cstdint>
 
 #include "../returnvalues/HasReturnvaluesIF.h"
@@ -44,8 +46,8 @@ class MessageQueueIF {
   virtual ReturnValue_t reply(MessageQueueMessageIF* message) = 0;
 
   /**
-   * @brief	This function reads available messages from the message queue
-   *          and returns the sender.
+   * @brief	This function reads available messages from the message queue and returns the
+   * sender.
    * @details
    * It works identically to the other receiveMessage call, but in addition
    * returns the sender's queue id.
@@ -78,19 +80,16 @@ class MessageQueueIF {
    */
   virtual ReturnValue_t flush(uint32_t* count) = 0;
   /**
-   * @brief	This method returns the message queue
-   *          id of the last communication partner.
+   * @brief	This method returns the message queue ID of the last communication partner.
    */
   virtual MessageQueueId_t getLastPartner() const = 0;
   /**
-   * @brief	This method returns the message queue
-   *          id of this class's message queue.
+   * @brief	This method returns the message queue ID  of this class's message queue.
    */
   virtual MessageQueueId_t getId() const = 0;
 
   /**
-   * @brief	With the sendMessage call, a queue message
-   *          is sent to a receiving queue.
+   * @brief	With the sendMessage call, a queue message is sent to a receiving queue.
    * @details
    * This method takes the message provided, adds the sentFrom information
    * and passes it on to the destination provided with an operating system
@@ -129,8 +128,7 @@ class MessageQueueIF {
                                     bool ignoreFault = false) = 0;
 
   /**
-   * @brief	The sendToDefaultFrom method sends a queue message
-   *          to the default destination.
+   * @brief	The sendToDefaultFrom method sends a queue message to the default destination.
    * @details
    * In all other aspects, it works identical to the sendMessage method.
    * @param message
@@ -164,6 +162,8 @@ class MessageQueueIF {
   virtual MessageQueueId_t getDefaultDestination() const = 0;
 
   virtual bool isDefaultDestinationSet() const = 0;
+
+  virtual MqArgs& getMqArgs() = 0;
 };
 
 #endif /* FSFW_IPC_MESSAGEQUEUEIF_H_ */

src/fsfw/ipc/QueueFactory.h

@@ -5,6 +5,7 @@
 
 #include "MessageQueueIF.h"
 #include "MessageQueueMessage.h"
+#include "definitions.h"
 
 /**
  * Creates message queues.
@@ -22,7 +23,8 @@ class QueueFactory {
   static QueueFactory* instance();
 
   MessageQueueIF* createMessageQueue(uint32_t messageDepth = 3,
-                                     size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);
+                                     size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE,
+                                     MqArgs* args = nullptr);
 
   void deleteMessageQueue(MessageQueueIF* queue);
 

src/fsfw/ipc/definitions.h

@@ -0,0 +1,14 @@
+#ifndef FSFW_SRC_FSFW_IPC_DEFINITIONS_H_
+#define FSFW_SRC_FSFW_IPC_DEFINITIONS_H_
+
+#include <fsfw/objectmanager/SystemObjectIF.h>
+#include <fsfw/objectmanager/frameworkObjects.h>
+
+struct MqArgs {
+  MqArgs(){};
+  MqArgs(object_id_t objectId, void* args = nullptr) : objectId(objectId), args(args) {}
+  object_id_t objectId = objects::NO_OBJECT;
+  void* args = nullptr;
+};
+
+#endif /* FSFW_SRC_FSFW_IPC_DEFINITIONS_H_ */

src/fsfw/monitoring/MonitoringMessageContent.h

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

src/fsfw/objectmanager/SystemObject.h

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

src/fsfw/osal/common/TcpTmTcServer.cpp

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

src/fsfw/osal/common/TcpTmTcServer.h

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

src/fsfw/osal/common/UdpTcPollingTask.cpp

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

src/fsfw/osal/common/UdpTcPollingTask.h

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

src/fsfw/osal/common/UdpTmTcBridge.cpp

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

src/fsfw/osal/common/UdpTmTcBridge.h

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

src/fsfw/osal/freertos/Clock.cpp

@@ -11,9 +11,6 @@
 // TODO sanitize input?
 // TODO much of this code can be reused for tick-only systems
 
-uint16_t Clock::leapSeconds = 0;
-MutexIF* Clock::timeMutex = nullptr;
-
 uint32_t Clock::getTicksPerSecond(void) { return 1000; }
 
 ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {

src/fsfw/osal/freertos/MessageQueue.cpp

@@ -4,8 +4,9 @@
 #include "fsfw/osal/freertos/QueueMapManager.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
-MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize)
-    : maxMessageSize(maxMessageSize) {
+MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize, MqArgs* args)
+    : MessageQueueBase(MessageQueueIF::NO_QUEUE, MessageQueueIF::NO_QUEUE, args),
+      maxMessageSize(maxMessageSize) {
   handle = xQueueCreate(messageDepth, maxMessageSize);
   if (handle == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -15,10 +16,10 @@ MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize)
 #else
     sif::printError("MessageQueue::MessageQueue: Creation failed\n");
     sif::printError("Specified Message Depth: %d\n", messageDepth);
-    sif::printError("Specified MAximum Message Size: %d\n", maxMessageSize);
+    sif::printError("Specified Maximum Message Size: %d\n", maxMessageSize);
 #endif
   }
-  QueueMapManager::instance()->addMessageQueue(handle, &queueId);
+  QueueMapManager::instance()->addMessageQueue(handle, &id);
 }
 
 MessageQueue::~MessageQueue() {
@@ -29,28 +30,6 @@ MessageQueue::~MessageQueue() {
 
 void MessageQueue::switchSystemContext(CallContext callContext) { this->callContext = callContext; }
 
-ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
-                                        bool ignoreFault) {
-  return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
-}
-
-ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
-  return sendToDefaultFrom(message, this->getId());
-}
-
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
-                                              MessageQueueId_t sentFrom, bool ignoreFault) {
-  return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
-}
-
-ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
-  if (this->lastPartner != MessageQueueIF::NO_QUEUE) {
-    return sendMessageFrom(this->lastPartner, message, this->getId());
-  } else {
-    return NO_REPLY_PARTNER;
-  }
-}
-
 ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
                                             MessageQueueId_t sentFrom, bool ignoreFault) {
   return sendMessageFromMessageQueue(sendTo, message, sentFrom, ignoreFault, callContext);
@@ -72,27 +51,16 @@ ReturnValue_t MessageQueue::handleSendResult(BaseType_t result, bool ignoreFault
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
-                                           MessageQueueId_t* receivedFrom) {
-  ReturnValue_t status = this->receiveMessage(message);
-  if (status == HasReturnvaluesIF::RETURN_OK) {
-    *receivedFrom = this->lastPartner;
-  }
-  return status;
-}
-
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
   BaseType_t result = xQueueReceive(handle, reinterpret_cast<void*>(message->getBuffer()), 0);
   if (result == pdPASS) {
-    this->lastPartner = message->getSender();
+    this->last = message->getSender();
     return HasReturnvaluesIF::RETURN_OK;
   } else {
     return MessageQueueIF::EMPTY;
   }
 }
 
-MessageQueueId_t MessageQueue::getLastPartner() const { return lastPartner; }
-
 ReturnValue_t MessageQueue::flush(uint32_t* count) {
   // TODO FreeRTOS does not support flushing partially
   // Is always successful
@@ -100,17 +68,6 @@ ReturnValue_t MessageQueue::flush(uint32_t* count) {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-MessageQueueId_t MessageQueue::getId() const { return queueId; }
-
-void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
-  defaultDestinationSet = true;
-  this->defaultDestination = defaultDestination;
-}
-
-MessageQueueId_t MessageQueue::getDefaultDestination() const { return defaultDestination; }
-
-bool MessageQueue::isDefaultDestinationSet() const { return defaultDestinationSet; }
-
 // static core function to send messages.
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
                                                         MessageQueueMessageIF* message,

src/fsfw/osal/freertos/MessageQueue.h

@@ -1,12 +1,15 @@
 #ifndef FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_
 #define FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_
 
+#include <fsfw/ipc/MessageQueueBase.h>
+
 #include "FreeRTOS.h"
 #include "TaskManagement.h"
 #include "fsfw/internalerror/InternalErrorReporterIF.h"
 #include "fsfw/ipc/MessageQueueIF.h"
 #include "fsfw/ipc/MessageQueueMessage.h"
 #include "fsfw/ipc/MessageQueueMessageIF.h"
+#include "fsfw/ipc/definitions.h"
 #include "queue.h"
 
 /**
@@ -32,7 +35,7 @@
  * @ingroup osal
  * @ingroup message_queue
  */
-class MessageQueue : public MessageQueueIF {
+class MessageQueue : public MessageQueueBase {
   friend class MessageQueueSenderIF;
 
  public:
@@ -53,7 +56,8 @@ class MessageQueue : public MessageQueueIF {
    * This should be left default.
    */
   MessageQueue(size_t messageDepth = 3,
-               size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);
+               size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE,
+               MqArgs* args = nullptr);
 
   /** Copying message queues forbidden */
   MessageQueue(const MessageQueue&) = delete;
@@ -73,40 +77,15 @@ class MessageQueue : public MessageQueueIF {
    */
   void switchSystemContext(CallContext callContext);
 
-  /** MessageQueueIF implementation */
-  ReturnValue_t sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
-                            bool ignoreFault = false) override;
+  QueueHandle_t getNativeQueueHandle();
 
-  ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
-
-  ReturnValue_t reply(MessageQueueMessageIF* message) override;
+  // Implement non-generic MessageQueueIF functions not handled by MessageQueueBase
   virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
                                         MessageQueueId_t sentFrom = NO_QUEUE,
                                         bool ignoreFault = false) override;
-
-  virtual ReturnValue_t sendToDefaultFrom(MessageQueueMessageIF* message,
-                                          MessageQueueId_t sentFrom = NO_QUEUE,
-                                          bool ignoreFault = false) override;
-
-  ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
-                               MessageQueueId_t* receivedFrom) override;
-
   ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
-
   ReturnValue_t flush(uint32_t* count) override;
 
-  MessageQueueId_t getLastPartner() const override;
-
-  MessageQueueId_t getId() const override;
-
-  void setDefaultDestination(MessageQueueId_t defaultDestination) override;
-
-  MessageQueueId_t getDefaultDestination() const override;
-
-  bool isDefaultDestinationSet() const override;
-
-  QueueHandle_t getNativeQueueHandle();
-
  protected:
   /**
    * @brief 	Implementation to be called from any send Call within
@@ -136,12 +115,8 @@ class MessageQueue : public MessageQueueIF {
   static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
 
  private:
-  bool defaultDestinationSet = false;
   QueueHandle_t handle;
-  MessageQueueId_t queueId = MessageQueueIF::NO_QUEUE;
 
-  MessageQueueId_t defaultDestination = MessageQueueIF::NO_QUEUE;
-  MessageQueueId_t lastPartner = MessageQueueIF::NO_QUEUE;
   const size_t maxMessageSize;
   //! Stores the current system context
   CallContext callContext = CallContext::TASK;

src/fsfw/osal/freertos/PeriodicTask.cpp

@@ -97,7 +97,11 @@ void PeriodicTask::taskFunctionality() {
 
 ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
   ExecutableObjectIF* newObject = ObjectManager::instance()->get<ExecutableObjectIF>(object);
-  if (newObject == nullptr) {
+  return addComponent(newObject);
+}
+
+ReturnValue_t PeriodicTask::addComponent(ExecutableObjectIF* object) {
+  if (object == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
                   "it implement ExecutableObjectIF"
@@ -105,8 +109,8 @@ ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
 #endif
     return HasReturnvaluesIF::RETURN_FAILED;
   }
-  objectList.push_back(newObject);
-  newObject->setTaskIF(this);
+  objectList.push_back(object);
+  object->setTaskIF(this);
 
   return HasReturnvaluesIF::RETURN_OK;
 }

src/fsfw/osal/freertos/PeriodicTask.h

@@ -63,6 +63,16 @@ class PeriodicTask : public PeriodicTaskIF, public FreeRTOSTaskIF {
    */
   ReturnValue_t addComponent(object_id_t object) override;
 
+  /**
+   * Adds an object to the list of objects to be executed.
+   * The objects are executed in the order added.
+   * @param object Id of the object to add.
+   * @return
+   * -@c RETURN_OK on success
+   * -@c RETURN_FAILED if the object could not be added.
+   */
+  ReturnValue_t addComponent(ExecutableObjectIF* object) override;
+
   uint32_t getPeriodMs() const override;
 
   ReturnValue_t sleepFor(uint32_t ms) override;

src/fsfw/osal/freertos/QueueFactory.cpp

@@ -22,8 +22,9 @@ QueueFactory::QueueFactory() {}
 
 QueueFactory::~QueueFactory() {}
 
-MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth, size_t maxMessageSize) {
-  return new MessageQueue(messageDepth, maxMessageSize);
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth, size_t maxMessageSize,
+                                                 MqArgs* args) {
+  return new MessageQueue(messageDepth, maxMessageSize, args);
 }
 
 void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) { delete queue; }

src/fsfw/osal/host/CMakeLists.txt

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

src/fsfw/osal/host/Clock.cpp

@@ -2,6 +2,7 @@
 
 #include <chrono>
 
+#include "fsfw/ipc/MutexGuard.h"
 #include "fsfw/platform.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
@@ -11,9 +12,6 @@
 #include <fstream>
 #endif
 
-uint16_t Clock::leapSeconds = 0;
-MutexIF* Clock::timeMutex = NULL;
-
 using SystemClock = std::chrono::system_clock;
 
 uint32_t Clock::getTicksPerSecond(void) {
@@ -127,6 +125,13 @@ ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
   auto seconds = std::chrono::time_point_cast<std::chrono::seconds>(now);
   auto fraction = now - seconds;
   time_t tt = SystemClock::to_time_t(now);
+  ReturnValue_t result = checkOrCreateClockMutex();
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  MutexGuard helper(timeMutex);
+  // gmtime writes its output in a global buffer which is not Thread Safe
+  // Therefore we have to use a Mutex here
   struct tm* timeInfo;
   timeInfo = gmtime(&tt);
   time->year = timeInfo->tm_year + 1900;
@@ -150,17 +155,14 @@ ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from, timeval*
   time_tm.tm_hour = from->hour;
   time_tm.tm_min = from->minute;
   time_tm.tm_sec = from->second;
+  time_tm.tm_isdst = 0;
 
-  time_t seconds = mktime(&time_tm);
+  time_t seconds = timegm(&time_tm);
 
   to->tv_sec = seconds;
   to->tv_usec = from->usecond;
   // Fails in 2038..
   return HasReturnvaluesIF::RETURN_OK;
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::warning << "Clock::convertTimeBla: not implemented yet" << std::endl;
-#endif
-  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {

src/fsfw/osal/host/MessageQueue.cpp

@@ -8,10 +8,12 @@
 #include "fsfw/osal/host/QueueMapManager.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
-MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize)
-    : messageSize(maxMessageSize), messageDepth(messageDepth) {
+MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize, MqArgs* args)
+    : MessageQueueBase(MessageQueueIF::NO_QUEUE, MessageQueueIF::NO_QUEUE, args),
+      messageSize(maxMessageSize),
+      messageDepth(messageDepth) {
   queueLock = MutexFactory::instance()->createMutex();
-  auto result = QueueMapManager::instance()->addMessageQueue(this, &mqId);
+  auto result = QueueMapManager::instance()->addMessageQueue(this, &id);
   if (result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "MessageQueue::MessageQueue: Could not be created" << std::endl;
@@ -23,42 +25,11 @@ MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize)
 
 MessageQueue::~MessageQueue() { MutexFactory::instance()->deleteMutex(queueLock); }
 
-ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
-                                        bool ignoreFault) {
-  return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
-}
-
-ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
-  return sendToDefaultFrom(message, this->getId());
-}
-
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
-                                              MessageQueueId_t sentFrom, bool ignoreFault) {
-  return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
-}
-
-ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
-  if (this->lastPartner != MessageQueueIF::NO_QUEUE) {
-    return sendMessageFrom(this->lastPartner, message, this->getId());
-  } else {
-    return MessageQueueIF::NO_REPLY_PARTNER;
-  }
-}
-
 ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
                                             MessageQueueId_t sentFrom, bool ignoreFault) {
   return sendMessageFromMessageQueue(sendTo, message, sentFrom, ignoreFault);
 }
 
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
-                                           MessageQueueId_t* receivedFrom) {
-  ReturnValue_t status = this->receiveMessage(message);
-  if (status == HasReturnvaluesIF::RETURN_OK) {
-    *receivedFrom = this->lastPartner;
-  }
-  return status;
-}
-
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
   if (messageQueue.empty()) {
     return MessageQueueIF::EMPTY;
@@ -68,12 +39,10 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
             message->getBuffer());
   messageQueue.pop();
   // The last partner is the first uint32_t field in the message
-  this->lastPartner = message->getSender();
+  this->last = message->getSender();
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-MessageQueueId_t MessageQueue::getLastPartner() const { return lastPartner; }
-
 ReturnValue_t MessageQueue::flush(uint32_t* count) {
   *count = messageQueue.size();
   // Clears the queue.
@@ -81,17 +50,6 @@ ReturnValue_t MessageQueue::flush(uint32_t* count) {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-MessageQueueId_t MessageQueue::getId() const { return mqId; }
-
-void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
-  defaultDestinationSet = true;
-  this->defaultDestination = defaultDestination;
-}
-
-MessageQueueId_t MessageQueue::getDefaultDestination() const { return defaultDestination; }
-
-bool MessageQueue::isDefaultDestinationSet() const { return defaultDestinationSet; }
-
 // static core function to send messages.
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
                                                         MessageQueueMessageIF* message,
@@ -125,6 +83,13 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
     memcpy(targetQueue->messageQueue.back().data(), message->getBuffer(),
            message->getMaximumMessageSize());
   } else {
+    if (not ignoreFault) {
+      InternalErrorReporterIF* internalErrorReporter =
+          ObjectManager::instance()->get<InternalErrorReporterIF>(objects::INTERNAL_ERROR_REPORTER);
+      if (internalErrorReporter != nullptr) {
+        internalErrorReporter->queueMessageNotSent();
+      }
+    }
     return MessageQueueIF::FULL;
   }
   return HasReturnvaluesIF::RETURN_OK;

src/fsfw/osal/host/MessageQueue.h

@@ -5,9 +5,11 @@
 #include <queue>
 
 #include "fsfw/internalerror/InternalErrorReporterIF.h"
+#include "fsfw/ipc/MessageQueueBase.h"
 #include "fsfw/ipc/MessageQueueIF.h"
 #include "fsfw/ipc/MessageQueueMessage.h"
 #include "fsfw/ipc/MutexIF.h"
+#include "fsfw/ipc/definitions.h"
 #include "fsfw/timemanager/Clock.h"
 
 /**
@@ -33,7 +35,7 @@
  * @ingroup osal
  * @ingroup message_queue
  */
-class MessageQueue : public MessageQueueIF {
+class MessageQueue : public MessageQueueBase {
   friend class MessageQueueSenderIF;
 
  public:
@@ -54,7 +56,8 @@ class MessageQueue : public MessageQueueIF {
    * This should be left default.
    */
   MessageQueue(size_t messageDepth = 3,
-               size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);
+               size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE,
+               MqArgs* args = nullptr);
 
   /** Copying message queues forbidden */
   MessageQueue(const MessageQueue&) = delete;
@@ -67,121 +70,12 @@ class MessageQueue : public MessageQueueIF {
    */
   virtual ~MessageQueue();
 
-  /**
-   * @brief	This operation sends a message to the given destination.
-   * @details	It directly uses the sendMessage call of the MessageQueueSender
-   * parent, but passes its queue id as "sentFrom" parameter.
-   * @param sendTo	This parameter specifies the message queue id of the
-   *  destination message queue.
-   * @param message	A pointer to a previously created message, which is sent.
-   * @param ignoreFault If set to true, the internal software fault counter
-   * is not incremented if queue is full.
-   */
-  ReturnValue_t sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
-                            bool ignoreFault = false) override;
-  /**
-   * @brief	This operation sends a message to the default destination.
-   * @details	As in the sendMessage method, this function uses the
-   * sendToDefault call of the MessageQueueSender parent class and adds its
-   * queue id as "sentFrom" information.
-   * @param message	A pointer to a previously created message, which is sent.
-   */
-  ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
-  /**
-   * @brief	This operation sends a message to the last communication partner.
-   * @details	This operation simplifies answering an incoming message by using
-   * the stored lastPartner information as destination. If there was no
-   * message received yet (i.e. lastPartner is zero), an error code is returned.
-   * @param message	A pointer to a previously created message, which is sent.
-   */
-  ReturnValue_t reply(MessageQueueMessageIF* message) override;
-
-  /**
-   * @brief	With the sendMessage call, a queue message is sent to a
-   * 			receiving queue.
-   * @details
-   * This method takes the message provided, adds the sentFrom information and
-   * passes it on to the destination provided with an operating system call.
-   *  The OS's return value is returned.
-   * @param sendTo	This parameter specifies the message queue id to send
-   * the message to.
-   * @param message	This is a pointer to a previously created message,
-   * which is sent.
-   * @param sentFrom	The sentFrom information can be set to inject the
-   * sender's queue id into the message. This variable is set to zero by
-   * default.
-   * @param ignoreFault If set to true, the internal software fault counter
-   * is not incremented if queue is full.
-   */
+  // Implement non-generic MessageQueueIF functions not handled by MessageQueueBase
   virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
                                         MessageQueueId_t sentFrom = NO_QUEUE,
                                         bool ignoreFault = false) override;
-
-  /**
-   * @brief	The sendToDefault method sends a queue message to the default
-   * 			destination.
-   * @details
-   * In all other aspects, it works identical to the sendMessage method.
-   * @param message	This is a pointer to a previously created message,
-   * which is sent.
-   * @param sentFrom	The sentFrom information can be set to inject the
-   * sender's queue id into the message. This variable is set to zero by
-   * default.
-   */
-  virtual ReturnValue_t sendToDefaultFrom(MessageQueueMessageIF* message,
-                                          MessageQueueId_t sentFrom = NO_QUEUE,
-                                          bool ignoreFault = false) override;
-
-  /**
-   * @brief	This function reads available messages from the message queue
-   * 			and returns the sender.
-   * @details
-   * It works identically to the other receiveMessage call, but in  addition
-   * returns the sender's queue id.
-   * @param message	A pointer to a message in which the received data is stored.
-   * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
-   */
-  ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
-                               MessageQueueId_t* receivedFrom) override;
-
-  /**
-   * @brief	This function reads available messages from the message queue.
-   * @details
-   * If data is available it is stored in the passed message pointer.
-   * The message's original content is overwritten and the sendFrom
-   * information is stored in the lastPartner attribute. Else, the lastPartner
-   * information remains untouched, the message's content is cleared and the
-   * function returns immediately.
-   * @param message	A pointer to a message in which the received data is stored.
-   */
   ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
-  /**
-   * Deletes all pending messages in the queue.
-   * @param count The number of flushed messages.
-   * @return RETURN_OK on success.
-   */
   ReturnValue_t flush(uint32_t* count) override;
-  /**
-   * @brief	This method returns the message queue id of the last
-   * 			communication partner.
-   */
-  MessageQueueId_t getLastPartner() const override;
-  /**
-   * @brief	This method returns the message queue id of this class's
-   * 			message queue.
-   */
-  MessageQueueId_t getId() const override;
-
-  /**
-   * @brief	This method is a simple setter for the default destination.
-   */
-  void setDefaultDestination(MessageQueueId_t defaultDestination) override;
-  /**
-   * @brief	This method is a simple getter for the default destination.
-   */
-  MessageQueueId_t getDefaultDestination() const override;
-
-  bool isDefaultDestinationSet() const override;
 
   ReturnValue_t lockQueue(MutexIF::TimeoutType timeoutType, dur_millis_t lockTimeout);
   ReturnValue_t unlockQueue();
@@ -211,23 +105,14 @@ class MessageQueue : public MessageQueueIF {
                                                    MessageQueueId_t sentFrom = NO_QUEUE,
                                                    bool ignoreFault = false);
 
-  // static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
-
  private:
   std::queue<std::vector<uint8_t>> messageQueue;
-  /**
-   * @brief	The class stores the queue id it got assigned.
-   * 			If initialization fails, the queue id is set to zero.
-   */
-  MessageQueueId_t mqId = MessageQueueIF::NO_QUEUE;
   size_t messageSize = 0;
   size_t messageDepth = 0;
 
   MutexIF* queueLock;
 
-  bool defaultDestinationSet = false;
   MessageQueueId_t defaultDestination = MessageQueueIF::NO_QUEUE;
-  MessageQueueId_t lastPartner = MessageQueueIF::NO_QUEUE;
 };
 
 #endif /* FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_ */

src/fsfw/osal/host/PeriodicTask.cpp

@@ -102,11 +102,15 @@ void PeriodicTask::taskFunctionality() {
 
 ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
   ExecutableObjectIF* newObject = ObjectManager::instance()->get<ExecutableObjectIF>(object);
-  if (newObject == nullptr) {
+  return addComponent(newObject);
+}
+
+ReturnValue_t PeriodicTask::addComponent(ExecutableObjectIF* object) {
+  if (object == nullptr) {
     return HasReturnvaluesIF::RETURN_FAILED;
   }
-  newObject->setTaskIF(this);
-  objectList.push_back(newObject);
+  object->setTaskIF(this);
+  objectList.push_back(object);
   return HasReturnvaluesIF::RETURN_OK;
 }
 

src/fsfw/osal/host/PeriodicTask.h

@@ -59,6 +59,16 @@ class PeriodicTask : public PeriodicTaskIF {
    */
   ReturnValue_t addComponent(object_id_t object);
 
+  /**
+   * Adds an object to the list of objects to be executed.
+   * The objects are executed in the order added.
+   * @param object pointer to the object to add.
+   * @return
+   *  -@c RETURN_OK on success
+   *  -@c RETURN_FAILED if the object could not be added.
+   */
+  ReturnValue_t addComponent(ExecutableObjectIF* object);
+
   uint32_t getPeriodMs() const;
 
   ReturnValue_t sleepFor(uint32_t ms);

src/fsfw/osal/host/QueueFactory.cpp

@@ -27,12 +27,13 @@ QueueFactory::QueueFactory() {}
 
 QueueFactory::~QueueFactory() {}
 
-MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth, size_t maxMessageSize) {
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth, size_t maxMessageSize,
+                                                 MqArgs* args) {
   // A thread-safe queue can be implemented  by using a combination
   // of std::queue and std::mutex. This uses dynamic memory allocation
   // which could be alleviated by using a custom allocator, external library
   // (etl::queue) or simply using std::queue, we're on a host machine anyway.
-  return new MessageQueue(messageDepth, maxMessageSize);
+  return new MessageQueue(messageDepth, maxMessageSize, args);
 }
 
 void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) { delete queue; }

src/fsfw/osal/linux/BinarySemaphore.cpp

@@ -1,6 +1,7 @@
 #include "fsfw/osal/linux/BinarySemaphore.h"
 
 #include <errno.h>
+#include <stdio.h>
 #include <time.h>
 
 #include <cstring>

src/fsfw/osal/linux/CMakeLists.txt

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

src/fsfw/osal/linux/Clock.cpp

@@ -8,11 +8,9 @@
 
 #include <fstream>
 
+#include "fsfw/ipc/MutexGuard.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
-uint16_t Clock::leapSeconds = 0;
-MutexIF* Clock::timeMutex = NULL;
-
 uint32_t Clock::getTicksPerSecond(void) {
   uint32_t ticks = sysconf(_SC_CLK_TCK);
   return ticks;
@@ -117,7 +115,13 @@ ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
     // TODO errno
     return HasReturnvaluesIF::RETURN_FAILED;
   }
-
+  ReturnValue_t result = checkOrCreateClockMutex();
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  MutexGuard helper(timeMutex);
+  // gmtime writes its output in a global buffer which is not Thread Safe
+  // Therefore we have to use a Mutex here
   struct tm* timeInfo;
   timeInfo = gmtime(&timeUnix.tv_sec);
   time->year = timeInfo->tm_year + 1900;
@@ -140,8 +144,9 @@ ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from, timeval*
   fromTm.tm_hour = from->hour;
   fromTm.tm_min = from->minute;
   fromTm.tm_sec = from->second;
+  fromTm.tm_isdst = 0;
 
-  to->tv_sec = mktime(&fromTm);
+  to->tv_sec = timegm(&fromTm);
   to->tv_usec = from->usecond;
   return HasReturnvaluesIF::RETURN_OK;
 }

src/fsfw/osal/linux/MessageQueue.cpp

@@ -11,13 +11,10 @@
 #include "fsfw/osal/linux/unixUtility.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
-MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize)
-    : id(MessageQueueIF::NO_QUEUE),
-      lastPartner(MessageQueueIF::NO_QUEUE),
-      defaultDestination(MessageQueueIF::NO_QUEUE),
+MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize, MqArgs* args)
+    : MessageQueueBase(MessageQueueIF::NO_QUEUE, MessageQueueIF::NO_QUEUE, args),
       maxMessageSize(maxMessageSize) {
   mq_attr attributes;
-  this->id = 0;
   // Set attributes
   attributes.mq_curmsgs = 0;
   attributes.mq_maxmsg = messageDepth;
@@ -50,30 +47,6 @@ MessageQueue::~MessageQueue() {
   }
 }
 
-ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
-                                        bool ignoreFault) {
-  return sendMessageFrom(sendTo, message, this->getId(), false);
-}
-
-ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
-  return sendToDefaultFrom(message, this->getId());
-}
-
-ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
-  if (this->lastPartner != 0) {
-    return sendMessageFrom(this->lastPartner, message, this->getId());
-  } else {
-    return NO_REPLY_PARTNER;
-  }
-}
-
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
-                                           MessageQueueId_t* receivedFrom) {
-  ReturnValue_t status = this->receiveMessage(message);
-  *receivedFrom = this->lastPartner;
-  return status;
-}
-
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
   if (message == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -96,7 +69,7 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
   int status = mq_receive(id, reinterpret_cast<char*>(message->getBuffer()),
                           message->getMaximumMessageSize(), &messagePriority);
   if (status > 0) {
-    this->lastPartner = message->getSender();
+    this->last = message->getSender();
     // Check size of incoming message.
     if (message->getMessageSize() < message->getMinimumMessageSize()) {
       return HasReturnvaluesIF::RETURN_FAILED;
@@ -164,8 +137,6 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
   }
 }
 
-MessageQueueId_t MessageQueue::getLastPartner() const { return this->lastPartner; }
-
 ReturnValue_t MessageQueue::flush(uint32_t* count) {
   mq_attr attrib;
   int status = mq_getattr(id, &attrib);
@@ -212,26 +183,11 @@ ReturnValue_t MessageQueue::flush(uint32_t* count) {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-MessageQueueId_t MessageQueue::getId() const { return this->id; }
-
-void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
-  this->defaultDestination = defaultDestination;
-}
-
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
-                                              MessageQueueId_t sentFrom, bool ignoreFault) {
-  return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
-}
-
 ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
                                             MessageQueueId_t sentFrom, bool ignoreFault) {
   return sendMessageFromMessageQueue(sendTo, message, sentFrom, ignoreFault);
 }
 
-MessageQueueId_t MessageQueue::getDefaultDestination() const { return this->defaultDestination; }
-
-bool MessageQueue::isDefaultDestinationSet() const { return (defaultDestination != NO_QUEUE); }
-
 uint16_t MessageQueue::queueCounter = 0;
 
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
@@ -240,9 +196,9 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
                                                         bool ignoreFault) {
   if (message == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "MessageQueue::sendMessageFromMessageQueue: Message is nullptr!" << std::endl;
+    sif::error << "MessageQueue::sendMessageFromMessageQueue: Message is nullptr" << std::endl;
 #else
-    sif::printError("MessageQueue::sendMessageFromMessageQueue: Message is nullptr!\n");
+    sif::printError("MessageQueue::sendMessageFromMessageQueue: Message is nullptr\n");
 #endif
     return HasReturnvaluesIF::RETURN_FAILED;
   }
@@ -256,7 +212,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
     if (!ignoreFault) {
       InternalErrorReporterIF* internalErrorReporter =
           ObjectManager::instance()->get<InternalErrorReporterIF>(objects::INTERNAL_ERROR_REPORTER);
-      if (internalErrorReporter != NULL) {
+      if (internalErrorReporter != nullptr) {
         internalErrorReporter->queueMessageNotSent();
       }
     }

src/fsfw/osal/linux/MessageQueue.h

@@ -1,11 +1,13 @@
 #ifndef FSFW_OSAL_LINUX_MESSAGEQUEUE_H_
 #define FSFW_OSAL_LINUX_MESSAGEQUEUE_H_
 
+#include <fsfw/ipc/MessageQueueBase.h>
 #include <mqueue.h>
 
 #include "fsfw/internalerror/InternalErrorReporterIF.h"
 #include "fsfw/ipc/MessageQueueIF.h"
 #include "fsfw/ipc/MessageQueueMessage.h"
+#include "fsfw/ipc/definitions.h"
 /**
  * @brief		This class manages sending and receiving of message queue messages.
  *
@@ -25,7 +27,7 @@
  * makes use of the operating system calls provided.
  *	@ingroup message_queue
  */
-class MessageQueue : public MessageQueueIF {
+class MessageQueue : public MessageQueueBase {
   friend class MessageQueueSenderIF;
 
  public:
@@ -42,104 +44,24 @@ class MessageQueue : public MessageQueueIF {
    * 							This should be left default.
    */
   MessageQueue(uint32_t messageDepth = 3,
-               size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);
+               size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE,
+               MqArgs* args = nullptr);
+
+  /** Copying message queues forbidden */
+  MessageQueue(const MessageQueue&) = delete;
+  MessageQueue& operator=(const MessageQueue&) = delete;
+
   /**
    * @brief	The destructor deletes the formerly created message queue.
    * @details	This is accomplished by using the delete call provided by the operating system.
    */
   virtual ~MessageQueue();
-  /**
-   * @brief	This operation sends a message to the given destination.
-   * @details	It directly uses the sendMessage call of the MessageQueueSender parent, but passes
-   * its queue id as "sentFrom" parameter.
-   * @param sendTo	This parameter specifies the message queue id of the destination message
-   * queue.
-   * @param message	A pointer to a previously created message, which is sent.
-   * @param ignoreFault If set to true, the internal software fault counter is not incremented if
-   * queue is full.
-   */
-  virtual ReturnValue_t sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
-                                    bool ignoreFault = false);
-  /**
-   * @brief	This operation sends a message to the default destination.
-   * @details	As in the sendMessage method, this function uses the sendToDefault call of the
-   * 			MessageQueueSender parent class and adds its queue id as "sentFrom"
-   * information.
-   * @param message	A pointer to a previously created message, which is sent.
-   */
-  virtual ReturnValue_t sendToDefault(MessageQueueMessageIF* message);
-  /**
-   * @brief	This operation sends a message to the last communication partner.
-   * @details	This operation simplifies answering an incoming message by using the stored
-   * 			lastParnter information as destination. If there was no message received yet
-   * 			(i.e. lastPartner is zero), an error code is returned.
-   * @param message	A pointer to a previously created message, which is sent.
-   */
-  ReturnValue_t reply(MessageQueueMessageIF* message);
 
-  /**
-   * @brief	This function reads available messages from the message queue and returns the
-   * sender.
-   * @details	It works identically to the other receiveMessage call, but in addition returns the
-   * 			sender's queue id.
-   * @param message	A pointer to a message in which the received data is stored.
-   * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
-   */
-  ReturnValue_t receiveMessage(MessageQueueMessageIF* message, MessageQueueId_t* receivedFrom);
-
-  /**
-   * @brief	This function reads available messages from the message queue.
-   * @details	If data is available it is stored in the passed message pointer. The message's
-   * 			original content is overwritten and the sendFrom information is stored in
-   * the lastPartner attribute. Else, the lastPartner information remains untouched, the message's
-   * content is cleared and the function returns immediately.
-   * @param message	A pointer to a message in which the received data is stored.
-   */
-  ReturnValue_t receiveMessage(MessageQueueMessageIF* message);
-  /**
-   * Deletes all pending messages in the queue.
-   * @param count The number of flushed messages.
-   * @return RETURN_OK on success.
-   */
-  ReturnValue_t flush(uint32_t* count);
-  /**
-   * @brief	This method returns the message queue id of the last communication partner.
-   */
-  MessageQueueId_t getLastPartner() const;
-  /**
-   * @brief	This method returns the message queue id of this class's message queue.
-   */
-  MessageQueueId_t getId() const;
-  /**
-   * \brief	With the sendMessage call, a queue message is sent to a receiving queue.
-   * \param sendTo	This parameter specifies the message queue id to send the message to.
-   * \param message	This is a pointer to a previously created message, which is sent.
-   * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the
-   * message. This variable is set to zero by default. \param ignoreFault If set to true, the
-   * internal software fault counter is not incremented if queue is full.
-   */
-  virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
-                                        MessageQueueId_t sentFrom, bool ignoreFault = false);
-  /**
-   * \brief	The sendToDefault method sends a queue message to the default destination.
-   * \details	In all other aspects, it works identical to the sendMessage method.
-   * \param message	This is a pointer to a previously created message, which is sent.
-   * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the
-   * message. This variable is set to zero by default.
-   */
-  virtual ReturnValue_t sendToDefaultFrom(MessageQueueMessageIF* message,
-                                          MessageQueueId_t sentFrom = NO_QUEUE,
-                                          bool ignoreFault = false);
-  /**
-   * \brief	This method is a simple setter for the default destination.
-   */
-  void setDefaultDestination(MessageQueueId_t defaultDestination);
-  /**
-   * \brief	This method is a simple getter for the default destination.
-   */
-  MessageQueueId_t getDefaultDestination() const;
-
-  bool isDefaultDestinationSet() const;
+  // Implement non-generic MessageQueueIF functions not handled by MessageQueueBase
+  ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
+  ReturnValue_t flush(uint32_t* count) override;
+  ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
+                                MessageQueueId_t sentFrom, bool ignoreFault = false) override;
 
  protected:
   /**
@@ -158,31 +80,10 @@ class MessageQueue : public MessageQueueIF {
                                                    bool ignoreFault = false);
 
  private:
-  /**
-   * @brief	The class stores the queue id it got assigned from the operating system in this
-   * attribute. If initialization fails, the queue id is set to zero.
-   */
-  MessageQueueId_t id;
-  /**
-   * @brief	In this attribute, the queue id of the last communication partner is stored
-   * 			to allow for replying.
-   */
-  MessageQueueId_t lastPartner;
-  /**
-   * @brief	The message queue's name -a user specific information for the operating system-  is
-   * 			generated automatically with the help of this static counter.
-   */
-  /**
-   * \brief	This attribute stores a default destination to send messages to.
-   * \details	It is stored to simplify sending to always-the-same receiver. The attribute may
-   * 			be set in the constructor or by a setter call to setDefaultDestination.
-   */
-  MessageQueueId_t defaultDestination;
-
   /**
    * The name of the message queue, stored for unlinking
    */
-  char name[16];
+  char name[16] = {};
 
   static uint16_t queueCounter;
   const size_t maxMessageSize;

src/fsfw/osal/linux/PeriodicPosixTask.cpp

@@ -28,7 +28,11 @@ void* PeriodicPosixTask::taskEntryPoint(void* arg) {
 
 ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object) {
   ExecutableObjectIF* newObject = ObjectManager::instance()->get<ExecutableObjectIF>(object);
-  if (newObject == nullptr) {
+  return addComponent(newObject);
+}
+
+ReturnValue_t PeriodicPosixTask::addComponent(ExecutableObjectIF* object) {
+  if (object == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
                << " it implements ExecutableObjectIF!" << std::endl;
@@ -39,8 +43,8 @@ ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object) {
 #endif
     return HasReturnvaluesIF::RETURN_FAILED;
   }
-  objectList.push_back(newObject);
-  newObject->setTaskIF(this);
+  objectList.push_back(object);
+  object->setTaskIF(this);
 
   return HasReturnvaluesIF::RETURN_OK;
 }

src/fsfw/osal/linux/PeriodicPosixTask.h

@@ -42,6 +42,14 @@ class PeriodicPosixTask : public PosixThread, public PeriodicTaskIF {
    */
   ReturnValue_t addComponent(object_id_t object) override;
 
+  /**
+   * Adds an object to the list of objects to be executed.
+   * The objects are executed in the order added.
+   * @param object pointer to the object to add.
+   * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
+   */
+  ReturnValue_t addComponent(ExecutableObjectIF* object) override;
+
   uint32_t getPeriodMs() const override;
 
   ReturnValue_t sleepFor(uint32_t ms) override;
@@ -65,9 +73,10 @@ class PeriodicPosixTask : public PosixThread, public PeriodicTaskIF {
   /**
    * @brief	The function containing the actual functionality of the task.
    * @details	The method sets and starts
-   * 			the task's period, then enters a loop that is repeated indefinitely. Within the
-   * loop, all performOperation methods of the added objects are called. Afterwards the task will be
-   * blocked until the next period. On missing the deadline, the deadlineMissedFunction is executed.
+   * 			the task's period, then enters a loop that is repeated indefinitely. Within
+   * the loop, all performOperation methods of the added objects are called. Afterwards the task
+   * will be blocked until the next period. On missing the deadline, the deadlineMissedFunction is
+   * executed.
    */
   virtual void taskFunctionality(void);
   /**

src/fsfw/osal/linux/QueueFactory.cpp

@@ -28,8 +28,9 @@ QueueFactory::QueueFactory() {}
 
 QueueFactory::~QueueFactory() {}
 
-MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth, size_t maxMessageSize) {
-  return new MessageQueue(messageDepth, maxMessageSize);
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth, size_t maxMessageSize,
+                                                 MqArgs* args) {
+  return new MessageQueue(messageDepth, maxMessageSize, args);
 }
 
 void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) { delete queue; }

src/fsfw/osal/rtems/Clock.cpp

@@ -6,9 +6,6 @@
 #include "fsfw/ipc/MutexGuard.h"
 #include "fsfw/osal/rtems/RtemsBasic.h"
 
-uint16_t Clock::leapSeconds = 0;
-MutexIF* Clock::timeMutex = nullptr;
-
 uint32_t Clock::getTicksPerSecond(void) {
   rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
   return static_cast<uint32_t>(ticks_per_second);

src/fsfw/osal/rtems/MessageQueue.cpp

@@ -6,8 +6,9 @@
 #include "fsfw/osal/rtems/RtemsBasic.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
-MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size)
-    : id(0), lastPartner(0), defaultDestination(NO_QUEUE), internalErrorReporter(nullptr) {
+MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size, MqArgs* args)
+    : MessageQueueBase(MessageQueueIF::NO_QUEUE, MessageQueueIF::NO_QUEUE, args),
+      internalErrorReporter(nullptr) {
   rtems_name name = ('Q' << 24) + (queueCounter++ << 8);
   rtems_status_code status =
       rtems_message_queue_create(name, message_depth, max_message_size, 0, &(this->id));
@@ -16,43 +17,19 @@ MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size)
     sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex << name << std::dec
                << " failed with status:" << (uint32_t)status << std::endl;
 #endif
-    this->id = 0;
+    this->id = MessageQueueIF::NO_QUEUE;
   }
 }
 
 MessageQueue::~MessageQueue() { rtems_message_queue_delete(id); }
 
-ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
-                                        bool ignoreFault) {
-  return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
-}
-
-ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
-  return sendToDefaultFrom(message, this->getId());
-}
-
-ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
-  if (this->lastPartner != 0) {
-    return sendMessage(this->lastPartner, message, this->getId());
-  } else {
-    return NO_REPLY_PARTNER;
-  }
-}
-
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
-                                           MessageQueueId_t* receivedFrom) {
-  ReturnValue_t status = this->receiveMessage(message);
-  *receivedFrom = this->lastPartner;
-  return status;
-}
-
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
   size_t size = 0;
   rtems_status_code status =
       rtems_message_queue_receive(id, message->getBuffer(), &size, RTEMS_NO_WAIT, 1);
   if (status == RTEMS_SUCCESSFUL) {
     message->setMessageSize(size);
-    this->lastPartner = message->getSender();
+    this->last = message->getSender();
     // Check size of incoming message.
     if (message->getMessageSize() < message->getMinimumMessageSize()) {
       return HasReturnvaluesIF::RETURN_FAILED;
@@ -65,19 +42,11 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
   return convertReturnCode(status);
 }
 
-MessageQueueId_t MessageQueue::getLastPartner() const { return this->lastPartner; }
-
 ReturnValue_t MessageQueue::flush(uint32_t* count) {
   rtems_status_code status = rtems_message_queue_flush(id, count);
   return convertReturnCode(status);
 }
 
-MessageQueueId_t MessageQueue::getId() const { return this->id; }
-
-void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
-  this->defaultDestination = defaultDestination;
-}
-
 ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
                                             MessageQueueId_t sentFrom, bool ignoreFault) {
   message->setSender(sentFrom);
@@ -103,15 +72,6 @@ ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo, MessageQueu
   return returnCode;
 }
 
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
-                                              MessageQueueId_t sentFrom, bool ignoreFault) {
-  return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
-}
-
-MessageQueueId_t MessageQueue::getDefaultDestination() const { return this->defaultDestination; }
-
-bool MessageQueue::isDefaultDestinationSet() const { return (defaultDestination != NO_QUEUE); }
-
 ReturnValue_t MessageQueue::convertReturnCode(rtems_status_code inValue) {
   switch (inValue) {
     case RTEMS_SUCCESSFUL:

src/fsfw/osal/rtems/MessageQueue.h

@@ -1,10 +1,13 @@
 #ifndef FSFW_OSAL_RTEMS_MESSAGEQUEUE_H_
 #define FSFW_OSAL_RTEMS_MESSAGEQUEUE_H_
 
+#include <fsfw/ipc/MessageQueueBase.h>
+
 #include "RtemsBasic.h"
 #include "fsfw/internalerror/InternalErrorReporterIF.h"
 #include "fsfw/ipc/MessageQueueIF.h"
 #include "fsfw/ipc/MessageQueueMessage.h"
+#include "fsfw/ipc/definitions.h"
 
 /**
  *	@brief		This class manages sending and receiving of message queue messages.
@@ -19,7 +22,7 @@
  *as well as sending and receiving messages, the class makes use of the operating system calls
  *provided. \ingroup message_queue
  */
-class MessageQueue : public MessageQueueIF {
+class MessageQueue : public MessageQueueBase {
  public:
   /**
    * @brief	The constructor initializes and configures the message queue.
@@ -34,131 +37,26 @@ class MessageQueue : public MessageQueueIF {
    * 							This should be left default.
    */
   MessageQueue(size_t message_depth = 3,
-               size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE);
+               size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE,
+               MqArgs* args = nullptr);
+
+  /** Copying message queues forbidden */
+  MessageQueue(const MessageQueue&) = delete;
+  MessageQueue& operator=(const MessageQueue&) = delete;
+
   /**
    * @brief	The destructor deletes the formerly created message queue.
    * @details	This is accomplished by using the delete call provided by the operating system.
    */
   virtual ~MessageQueue();
-  /**
-   * @brief	This operation sends a message to the given destination.
-   * @details	It directly uses the sendMessage call of the MessageQueueSender parent, but passes
-   * its queue id as "sentFrom" parameter.
-   * @param sendTo	This parameter specifies the message queue id of the destination message
-   * queue.
-   * @param message	A pointer to a previously created message, which is sent.
-   * @param ignoreFault If set to true, the internal software fault counter is not incremented if
-   * queue is full.
-   */
-  ReturnValue_t sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
-                            bool ignoreFault = false);
-  /**
-   * @brief	This operation sends a message to the default destination.
-   * @details	As in the sendMessage method, this function uses the sendToDefault call of the
-   * 			MessageQueueSender parent class and adds its queue id as "sentFrom"
-   * information.
-   * @param message	A pointer to a previously created message, which is sent.
-   */
-  ReturnValue_t sendToDefault(MessageQueueMessageIF* message);
-  /**
-   * @brief	This operation sends a message to the last communication partner.
-   * @details	This operation simplifies answering an incoming message by using the stored
-   * 			lastParnter information as destination. If there was no message received yet
-   * 			(i.e. lastPartner is zero), an error code is returned.
-   * @param message	A pointer to a previously created message, which is sent.
-   */
-  ReturnValue_t reply(MessageQueueMessageIF* message);
 
-  /**
-   * @brief	This function reads available messages from the message queue and returns the
-   * sender.
-   * @details	It works identically to the other receiveMessage call, but in addition returns the
-   * 			sender's queue id.
-   * @param message	A pointer to a message in which the received data is stored.
-   * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
-   */
-  ReturnValue_t receiveMessage(MessageQueueMessageIF* message, MessageQueueId_t* receivedFrom);
-
-  /**
-   * @brief	This function reads available messages from the message queue.
-   * @details	If data is available it is stored in the passed message pointer. The message's
-   * 			original content is overwritten and the sendFrom information is stored in
-   * the lastPartner attribute. Else, the lastPartner information remains untouched, the message's
-   * content is cleared and the function returns immediately.
-   * @param message	A pointer to a message in which the received data is stored.
-   */
-  ReturnValue_t receiveMessage(MessageQueueMessageIF* message);
-  /**
-   * Deletes all pending messages in the queue.
-   * @param count The number of flushed messages.
-   * @return RETURN_OK on success.
-   */
-  ReturnValue_t flush(uint32_t* count);
-  /**
-   * @brief	This method returns the message queue id of the last communication partner.
-   */
-  MessageQueueId_t getLastPartner() const;
-  /**
-   * @brief	This method returns the message queue id of this class's message queue.
-   */
-  MessageQueueId_t getId() const;
-  /**
-   * \brief	With the sendMessage call, a queue message is sent to a receiving queue.
-   * \details	This method takes the message provided, adds the sentFrom information and passes
-   * 			it on to the destination provided with an operating system call. The OS's
-   * return value is returned.
-   * \param sendTo	This parameter specifies the message queue id to send the message to.
-   * \param message	This is a pointer to a previously created message, which is sent.
-   * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the
-   * message. This variable is set to zero by default. \param ignoreFault If set to true, the
-   * internal software fault counter is not incremented if queue is full.
-   */
-  virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
-                                        MessageQueueId_t sentFrom = NO_QUEUE,
-                                        bool ignoreFault = false);
-  /**
-   * \brief	The sendToDefault method sends a queue message to the default destination.
-   * \details	In all other aspects, it works identical to the sendMessage method.
-   * \param message	This is a pointer to a previously created message, which is sent.
-   * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the
-   * message. This variable is set to zero by default.
-   */
-  virtual ReturnValue_t sendToDefaultFrom(MessageQueueMessageIF* message,
-                                          MessageQueueId_t sentFrom = NO_QUEUE,
-                                          bool ignoreFault = false);
-  /**
-   * \brief	This method is a simple setter for the default destination.
-   */
-  void setDefaultDestination(MessageQueueId_t defaultDestination);
-  /**
-   * \brief	This method is a simple getter for the default destination.
-   */
-  MessageQueueId_t getDefaultDestination() const;
-
-  bool isDefaultDestinationSet() const;
+  // Implement non-generic MessageQueueIF functions not handled by MessageQueueBase
+  ReturnValue_t flush(uint32_t* count) override;
+  ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
+                                MessageQueueId_t sentFrom = NO_QUEUE,
+                                bool ignoreFault = false) override;
 
  private:
-  /**
-   * @brief	The class stores the queue id it got assigned from the operating system in this
-   * attribute. If initialization fails, the queue id is set to zero.
-   */
-  MessageQueueId_t id;
-  /**
-   * @brief	In this attribute, the queue id of the last communication partner is stored
-   * 			to allow for replying.
-   */
-  MessageQueueId_t lastPartner;
-  /**
-   * @brief	The message queue's name -a user specific information for the operating system-  is
-   * 			generated automatically with the help of this static counter.
-   */
-  /**
-   * \brief	This attribute stores a default destination to send messages to.
-   * \details	It is stored to simplify sending to always-the-same receiver. The attribute may
-   * 			be set in the constructor or by a setter call to setDefaultDestination.
-   */
-  MessageQueueId_t defaultDestination;
-
   /**
    * \brief	This attribute stores a reference to the internal error reporter for reporting full
    * queues. \details	In the event of a full destination queue, the reporter will be notified. The

src/fsfw/osal/rtems/PeriodicTask.cpp

@@ -68,11 +68,15 @@ void PeriodicTask::taskFunctionality() {
 
 ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
   ExecutableObjectIF* newObject = ObjectManager::instance()->get<ExecutableObjectIF>(object);
-  if (newObject == nullptr) {
+  return addComponent(newObject);
+}
+
+ReturnValue_t PeriodicTask::addComponent(ExecutableObjectIF* object) {
+  if (object == nullptr) {
     return HasReturnvaluesIF::RETURN_FAILED;
   }
-  objectList.push_back(newObject);
-  newObject->setTaskIF(this);
+  objectList.push_back(object);
+  object->setTaskIF(this);
 
   return HasReturnvaluesIF::RETURN_OK;
 }

src/fsfw/osal/rtems/PeriodicTask.h

@@ -13,8 +13,8 @@ class ExecutableObjectIF;
  * @brief This class represents a specialized task for periodic activities of multiple objects.
  *
  * @details MultiObjectTask is an extension to ObjectTask in the way that it is able to execute
- * 			multiple objects that implement the ExecutableObjectIF interface. The objects
- * must be added prior to starting the task.
+ * 			multiple objects that implement the ExecutableObjectIF interface. The
+ * objects must be added prior to starting the task.
  * @author  baetz
  * @ingroup task_handling
  */
@@ -59,6 +59,14 @@ class PeriodicTask : public RTEMSTaskBase, public PeriodicTaskIF {
    */
   ReturnValue_t addComponent(object_id_t object) override;
 
+  /**
+   * Adds an object to the list of objects to be executed.
+   * The objects are executed in the order added.
+   * @param object pointer to the object to add.
+   * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
+   */
+  ReturnValue_t addComponent(ExecutableObjectIF *object) override;
+
   uint32_t getPeriodMs() const override;
 
   ReturnValue_t sleepFor(uint32_t ms) override;

src/fsfw/osal/rtems/QueueFactory.cpp

@@ -49,8 +49,9 @@ QueueFactory::QueueFactory() {}
 
 QueueFactory::~QueueFactory() {}
 
-MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth, size_t maxMessageSize) {
-  return new MessageQueue(messageDepth, maxMessageSize);
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth, size_t maxMessageSize,
+                                                 MqArgs* args) {
+  return new MessageQueue(messageDepth, maxMessageSize, args);
 }
 
 void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) { delete queue; }