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.md

@@ -12,6 +12,9 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## 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
@@ -24,6 +27,16 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - `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
 
@@ -37,6 +50,25 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - 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]
 

CMakeLists.txt

@@ -1,5 +1,15 @@
 cmake_minimum_required(VERSION 3.13)
 
+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)
@@ -7,6 +17,23 @@ 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,17 +65,16 @@ 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 QUIET)
+    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")
@@ -57,12 +83,10 @@ if(FSFW_BUILD_UNITTESTS)
         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)
-        #fixes regression -preview4, to be confirmed in later releases
-        set_target_properties(Catch2 PROPERTIES DEBUG_POSTFIX "")
     endif()
 
     set(FSFW_CONFIG_PATH tests/src/fsfw_tests/unit/testcfg)
@@ -89,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)
@@ -101,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)
@@ -350,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
@@ -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`.

automation/Dockerfile

@@ -6,3 +6,9 @@ RUN apt-get --yes upgrade
 #tzdata is a dependency, won't install otherwise
 ARG DEBIAN_FRONTEND=noninteractive
 RUN apt-get --yes install gcc g++ cmake make lcov git valgrind nano iputils-ping
+
+RUN git clone https://github.com/catchorg/Catch2.git && \
+	cd Catch2 && \
+	git checkout v3.0.0-preview5 && \
+	cmake -Bbuild -H. -DBUILD_TESTING=OFF && \
+	cmake --build build/ --target install

automation/Jenkinsfile

@@ -3,7 +3,7 @@ pipeline {
         BUILDDIR = 'build-tests'
     }
     agent {
-        docker { image 'fsfw-ci:d1'}
+        docker { image 'fsfw-ci:d2'}
     }
     stages {
         stage('Clean') {

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`.

hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp

@@ -1,9 +1,9 @@
 #include "MgmLIS3MDLHandler.h"
 
-#include "fsfw/datapool/PoolReadGuard.h"
-
 #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),

hal/src/fsfw_hal/linux/CMakeLists.txt

@@ -12,9 +12,14 @@ if(FSFW_HAL_LINUX_ADD_PERIPHERAL_DRIVERS)
 if(FSFW_HAL_LINUX_ADD_LIBGPIOD)
 	add_subdirectory(gpio)
 endif()
-	add_subdirectory(spi)
-	add_subdirectory(i2c)
 	add_subdirectory(uart)
+	# 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,7 +72,7 @@ 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::CALLBACK): {
@@ -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,

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/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

@@ -265,6 +265,7 @@ void UartComIF::configureBaudrate(struct termios* options, UartCookie* uartCooki
       cfsetispeed(options, B230400);
       cfsetospeed(options, B230400);
       break;
+#ifndef __APPLE__
     case UartBaudRate::RATE_460800:
       cfsetispeed(options, B460800);
       cfsetospeed(options, B460800);
@@ -313,6 +314,7 @@ void UartComIF::configureBaudrate(struct termios* options, UartCookie* uartCooki
       cfsetispeed(options, B4000000);
       cfsetospeed(options, B4000000);
       break;
+#endif // ! __APPLE__
     default:
 #if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::warning << "UartComIF::configureBaudrate: Baudrate not supported" << std::endl;

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

@@ -24,9 +24,7 @@ void UartCookie::setParityEven() { parity = Parity::EVEN; }
 
 Parity UartCookie::getParity() const { return parity; }
 
-void UartCookie::setBitsPerWord(BitsPerWord bitsPerWord_) {
+void UartCookie::setBitsPerWord(BitsPerWord bitsPerWord_) { bitsPerWord = bitsPerWord_; }
-  bitsPerWord = bitsPerWord_;
-}
 
 BitsPerWord UartCookie::getBitsPerWord() const { return bitsPerWord; }
 

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) {}

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/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::numeric_limits<count_t>::max(),
-  static_assert(MAX_SIZE <= (std::pow(2, sizeof(count_t) * 8) - 1),
                 "count_t is not large enough to hold MAX_SIZE");
-#endif
  private:
   T data[MAX_SIZE];
 

src/fsfw/container/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)
+  HybridIterator(LinkedElement<T> *start) : LinkedElement<T>::Iterator(start), linked(true) {
-      : LinkedElement<T>::Iterator(start), value(start->value), 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

@@ -55,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;
 
@@ -80,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 startTransition(Mode_t mode, Submode_t submode) override;
-  virtual void getMode(Mode_t *mode, Submode_t *submode);
+  virtual void getMode(Mode_t *mode, Submode_t *submode) override;
-  virtual void setToExternalControl();
+  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/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

@@ -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
+#if defined(_MSC_VER) || defined(__clang__)
-  /* Use a std::vector here because MSVC will (rightly) not create a fixed size array
+  // Use a std::vector here because MSVC will (rightly) not create a fixed size array
-  with a non constant size specifier */
+  // with a non constant size specifier. The Apple compiler (LLVM) will not accept
-  std::vector<uint8_t> validityMask(validityMaskSize);
+  // 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);
+  void setReadWriteMode(pool_rwm_t newReadWriteMode) override;
-  pool_rwm_t getReadWriteMode() const;
+  pool_rwm_t getReadWriteMode() const override;
 
   bool isValid() const override;
   void setValid(bool valid) override;

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);
+  DeviceCommandId_t replyId = NO_COMMAND_ID;
-  if (iter != deviceReplyMap.end()) {
+  DeviceCommandMap::iterator command = cookieInfo.pendingCommand;
-    return iter->second.replyLen;
+  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);

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
@@ -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.

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/ipc/MessageQueueBase.cpp

@@ -1,9 +1,9 @@
 #include "MessageQueueBase.h"
 
-MessageQueueBase::MessageQueueBase(MessageQueueId_t id, MessageQueueId_t defaultDest,
+MessageQueueBase::MessageQueueBase(MessageQueueId_t id, MessageQueueId_t defaultDest, MqArgs* args)
-    MqArgs* args): id(id) {
+    : id(id) {
   this->defaultDest = defaultDest;
-  if(args != nullptr) {
+  if (args != nullptr) {
     this->args = *args;
   }
 }
@@ -23,35 +23,25 @@ ReturnValue_t MessageQueueBase::reply(MessageQueueMessageIF* message) {
 }
 
 ReturnValue_t MessageQueueBase::receiveMessage(MessageQueueMessageIF* message,
-                                           MessageQueueId_t* receivedFrom) {
+                                               MessageQueueId_t* receivedFrom) {
   ReturnValue_t status = this->receiveMessage(message);
   *receivedFrom = this->last;
   return status;
 }
 
-MessageQueueId_t MessageQueueBase::getLastPartner() const {
+MessageQueueId_t MessageQueueBase::getLastPartner() const { return last; }
-  return last;
-}
 
-MessageQueueId_t MessageQueueBase::getId() const {
+MessageQueueId_t MessageQueueBase::getId() const { return id; }
-  return id;
-}
 
-MqArgs& MessageQueueBase::getMqArgs() {
+MqArgs& MessageQueueBase::getMqArgs() { return args; }
-  return args;
-}
 
 void MessageQueueBase::setDefaultDestination(MessageQueueId_t defaultDestination) {
   this->defaultDest = defaultDestination;
 }
 
-MessageQueueId_t MessageQueueBase::getDefaultDestination() const {
+MessageQueueId_t MessageQueueBase::getDefaultDestination() const { return defaultDest; }
-  return defaultDest;
-}
 
-bool MessageQueueBase::isDefaultDestinationSet() const {
+bool MessageQueueBase::isDefaultDestinationSet() const { return (defaultDest != NO_QUEUE); }
-  return (defaultDest != NO_QUEUE);
-}
 
 ReturnValue_t MessageQueueBase::sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
                                             bool ignoreFault) {

src/fsfw/ipc/MessageQueueBase.h

@@ -1,11 +1,11 @@
 #ifndef FSFW_SRC_FSFW_IPC_MESSAGEQUEUEBASE_H_
 #define FSFW_SRC_FSFW_IPC_MESSAGEQUEUEBASE_H_
 
-#include <fsfw/ipc/definitions.h>
 #include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/ipc/definitions.h>
 
-class MessageQueueBase: public MessageQueueIF {
+class MessageQueueBase : public MessageQueueIF {
-public:
+ public:
   MessageQueueBase(MessageQueueId_t id, MessageQueueId_t defaultDest, MqArgs* mqArgs);
   virtual ~MessageQueueBase();
 
@@ -17,25 +17,24 @@ public:
   virtual MessageQueueId_t getDefaultDestination() const override;
   virtual bool isDefaultDestinationSet() const override;
   virtual ReturnValue_t sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
-      bool ignoreFault) override;
+                                    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;
+                                       MessageQueueId_t* receivedFrom) override;
-  virtual ReturnValue_t sendToDefaultFrom(MessageQueueMessageIF* message,
+  virtual ReturnValue_t sendToDefaultFrom(MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-      MessageQueueId_t sentFrom, bool ignoreFault = false) override;
+                                          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:
+
+ 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

@@ -2,6 +2,7 @@
 #define FSFW_IPC_MESSAGEQUEUEIF_H_
 
 #include <fsfw/ipc/definitions.h>
+
 #include <cstdint>
 
 #include "../returnvalues/HasReturnvaluesIF.h"
@@ -45,7 +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.

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) {
+void TcpTmTcServer::setSpacePacketParsingOptions(std::vector<uint16_t> validPacketIds_) {
-  this->validPacketIds = 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) {
+  if (maxRecvSize > 0) {
-    this->frameSize = frameSize;
+    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() {}
+[[noreturn]] ReturnValue_t UdpTcPollingTask::performOperation(uint8_t opCode) {
-
-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;
+  [[noreturn]] ReturnValue_t performOperation(uint8_t opCode) override;
-  virtual ReturnValue_t initialize() override;
+  ReturnValue_t initialize() override;
-  virtual ReturnValue_t initializeAfterTaskCreation() 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 == "") {
+  if (udpServerPort_.empty()) {
-    this->udpServerPort = DEFAULT_SERVER_PORT;
+    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) {
+void UdpTmTcBridge::setMutexProperties(MutexIF::TimeoutType timeoutType_, dur_millis_t timeoutMs) {
-  this->timeoutType = timeoutType;
+  timeoutType = timeoutType_;
-  this->mutexTimeoutMs = timeoutMs;
+  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.h

@@ -2,6 +2,7 @@
 #define FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_
 
 #include <fsfw/ipc/MessageQueueBase.h>
+
 #include "FreeRTOS.h"
 #include "TaskManagement.h"
 #include "fsfw/internalerror/InternalErrorReporterIF.h"

src/fsfw/osal/host/CMakeLists.txt

@@ -1,24 +1,27 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(${LIB_FSFW_NAME} PRIVATE
-	PRIVATE 
+  Clock.cpp
-		Clock.cpp
+  FixedTimeslotTask.cpp
-		FixedTimeslotTask.cpp
+  MessageQueue.cpp
-		MessageQueue.cpp
+  Mutex.cpp
-		Mutex.cpp
+  MutexFactory.cpp
-		MutexFactory.cpp
+  PeriodicTask.cpp
-		PeriodicTask.cpp
+  QueueFactory.cpp
-		QueueFactory.cpp
+  QueueMapManager.cpp
-		QueueMapManager.cpp
+  SemaphoreFactory.cpp
-		SemaphoreFactory.cpp
+  TaskFactory.cpp
-		TaskFactory.cpp
+  taskHelpers.cpp
-		taskHelpers.cpp
 )
 
 if(UNIX)
-	find_package(Threads REQUIRED)
+  find_package(Threads REQUIRED)
-	
+
-	target_link_libraries(${LIB_FSFW_NAME} 
+  target_link_libraries(${LIB_FSFW_NAME} PRIVATE
-	PRIVATE
+    ${CMAKE_THREAD_LIBS_INIT}
-		rt
+  )
-		${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;

src/fsfw/osal/host/MessageQueue.h

@@ -1,17 +1,17 @@
 #ifndef FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_
 #define FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_
 
-#include "fsfw/ipc/MessageQueueBase.h"
+#include <memory>
+#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"
 
-#include <memory>
-#include <queue>
-
 /**
  * @brief		This class manages sending and receiving of
  * 				message queue messages.

src/fsfw/osal/linux/CMakeLists.txt

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

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;

src/fsfw/osal/linux/MessageQueue.h

@@ -61,8 +61,7 @@ class MessageQueue : public 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,
+                                MessageQueueId_t sentFrom, bool ignoreFault = false) override;
-                                        bool ignoreFault = false) override;
 
  protected:
   /**

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

@@ -2,6 +2,7 @@
 #define FSFW_OSAL_RTEMS_MESSAGEQUEUE_H_
 
 #include <fsfw/ipc/MessageQueueBase.h>
+
 #include "RtemsBasic.h"
 #include "fsfw/internalerror/InternalErrorReporterIF.h"
 #include "fsfw/ipc/MessageQueueIF.h"
@@ -52,8 +53,8 @@ class MessageQueue : public MessageQueueBase {
   // 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,
+                                MessageQueueId_t sentFrom = NO_QUEUE,
-                                        bool ignoreFault = false) override;
+                                bool ignoreFault = false) override;
 
  private:
   /**

src/fsfw/osal/rtems/PeriodicTask.h

@@ -59,14 +59,13 @@ 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;
+  ReturnValue_t addComponent(ExecutableObjectIF *object) override;
-
 
   uint32_t getPeriodMs() const override;
 

src/fsfw/power/Fuse.h

@@ -54,7 +54,7 @@ class Fuse : public SystemObject,
 
   ReturnValue_t check();
   uint8_t getFuseId() const;
-  ReturnValue_t initialize();
+  ReturnValue_t initialize() override;
   DeviceList devices;
   ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
                           SerializeIF::Endianness streamEndianness) const override;

src/fsfw/pus/CService201HealthCommanding.cpp

@@ -13,8 +13,6 @@ CService201HealthCommanding::CService201HealthCommanding(object_id_t objectId, u
     : CommandingServiceBase(objectId, apid, serviceId, numParallelCommands, commandTimeoutSeconds) {
 }
 
-CService201HealthCommanding::~CService201HealthCommanding() {}
-
 ReturnValue_t CService201HealthCommanding::isValidSubservice(uint8_t subservice) {
   switch (subservice) {
     case (Subservice::COMMAND_SET_HEALTH):
@@ -43,8 +41,8 @@ ReturnValue_t CService201HealthCommanding::getMessageQueueAndObject(uint8_t subs
 }
 
 ReturnValue_t CService201HealthCommanding::checkInterfaceAndAcquireMessageQueue(
-    MessageQueueId_t *messageQueueToSet, object_id_t *objectId) {
+    MessageQueueId_t *messageQueueToSet, const object_id_t *objectId) {
-  HasHealthIF *destination = ObjectManager::instance()->get<HasHealthIF>(*objectId);
+  auto *destination = ObjectManager::instance()->get<HasHealthIF>(*objectId);
   if (destination == nullptr) {
     return CommandingServiceBase::INVALID_OBJECT;
   }
@@ -77,6 +75,10 @@ ReturnValue_t CService201HealthCommanding::prepareCommand(CommandMessage *messag
       HealthMessage::setHealthMessage(message, HealthMessage::HEALTH_ANNOUNCE_ALL);
       break;
     }
+    default: {
+      // Should never happen, subservice was already checked
+      result = RETURN_FAILED;
+    }
   }
   return result;
 }
@@ -95,10 +97,9 @@ ReturnValue_t CService201HealthCommanding::handleReply(const CommandMessage *rep
 }
 
 // Not used for now, health state already reported by event
-ReturnValue_t CService201HealthCommanding::prepareHealthSetReply(const CommandMessage *reply) {
+[[maybe_unused]] ReturnValue_t CService201HealthCommanding::prepareHealthSetReply(const CommandMessage *reply) {
-  prepareHealthSetReply(reply);
+  auto health = static_cast<uint8_t>(HealthMessage::getHealth(reply));
-  uint8_t health = static_cast<uint8_t>(HealthMessage::getHealth(reply));
+  auto oldHealth = static_cast<uint8_t>(HealthMessage::getOldHealth(reply));
-  uint8_t oldHealth = static_cast<uint8_t>(HealthMessage::getOldHealth(reply));
   HealthSetReply healthSetReply(health, oldHealth);
   return sendTmPacket(Subservice::REPLY_HEALTH_SET, &healthSetReply);
 }

src/fsfw/pus/CService201HealthCommanding.h

@@ -1,7 +1,7 @@
 #ifndef FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_
 #define FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_
 
-#include "../tmtcservices/CommandingServiceBase.h"
+#include "fsfw/tmtcservices/CommandingServiceBase.h"
 
 /**
  * @brief   Custom PUS service to set health of all objects
@@ -21,7 +21,7 @@ class CService201HealthCommanding : public CommandingServiceBase {
  public:
   CService201HealthCommanding(object_id_t objectId, uint16_t apid, uint8_t serviceId,
                               uint8_t numParallelCommands = 4, uint16_t commandTimeoutSeconds = 60);
-  virtual ~CService201HealthCommanding();
+  ~CService201HealthCommanding() override = default;
 
  protected:
   /* CSB abstract function implementations */
@@ -38,12 +38,10 @@ class CService201HealthCommanding : public CommandingServiceBase {
                             bool *isStep) override;
 
  private:
-  ReturnValue_t checkAndAcquireTargetID(object_id_t *objectIdToSet, const uint8_t *tcData,
+  static ReturnValue_t checkInterfaceAndAcquireMessageQueue(MessageQueueId_t *MessageQueueToSet,
-                                        size_t tcDataLen);
+                                                     const object_id_t *objectId);
-  ReturnValue_t checkInterfaceAndAcquireMessageQueue(MessageQueueId_t *MessageQueueToSet,
-                                                     object_id_t *objectId);
 
-  ReturnValue_t prepareHealthSetReply(const CommandMessage *reply);
+  [[maybe_unused]] ReturnValue_t prepareHealthSetReply(const CommandMessage *reply);
 
   enum Subservice {
     //! [EXPORT] : [TC] Set health of target object

src/fsfw/pus/Service3Housekeeping.h

@@ -43,7 +43,7 @@ class Service3Housekeeping : public CommandingServiceBase, public AcceptsHkPacke
                             CommandMessage* optionalNextCommand, object_id_t objectId,
                             bool* isStep) override;
 
-  virtual MessageQueueId_t getHkQueue() const;
+  virtual MessageQueueId_t getHkQueue() const override;
 
  private:
   enum class Subservice {

src/fsfw/subsystem/Subsystem.cpp

@@ -30,11 +30,11 @@ ReturnValue_t Subsystem::checkSequence(HybridIterator<ModeListEntry> iter,
     return FALLBACK_SEQUENCE_DOES_NOT_EXIST;
   }
 
-  if (iter.value == NULL) {
+  if (iter.value == nullptr) {
     return NO_TARGET_TABLE;
   }
 
-  for (; iter.value != NULL; ++iter) {
+  for (; iter.value != nullptr; ++iter) {
     if (!existsModeTable(iter->getTableId())) {
       return TABLE_DOES_NOT_EXIST;
     } else {
@@ -66,13 +66,18 @@ HybridIterator<ModeListEntry> Subsystem::getCurrentTable() {
 void Subsystem::performChildOperation() {
   if (isInTransition) {
     if (commandsOutstanding <= 0) {  // all children of the current table were commanded and replied
-      if (currentSequenceIterator.value == NULL) {  // we're through with this sequence
+      if (currentSequenceIterator.value == nullptr) {  // we're through with this sequence
         if (checkStateAgainstTable(currentTargetTable, targetSubmode) == RETURN_OK) {
           setMode(targetMode, targetSubmode);
           isInTransition = false;
           return;
         } else {
-          transitionFailed(TARGET_TABLE_NOT_REACHED, getSequence(targetMode)->getTableId());
+          Mode_t tableId = 0;
+          auto seq = getSequence(targetMode);
+          if (seq.value != nullptr) {
+            tableId = seq->getTableId();
+          }
+          transitionFailed(TARGET_TABLE_NOT_REACHED, tableId);
           return;
         }
       }
@@ -248,10 +253,13 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage *message) {
     case ModeSequenceMessage::READ_TABLE: {
       ReturnValue_t result;
       Mode_t table = ModeSequenceMessage::getSequenceId(message);
-      EntryPointer *entry = NULL;
+      EntryPointer *entry = nullptr;
       result = modeTables.find(table, &entry);
-      if (result != RETURN_OK) {
+      if (result != RETURN_OK or entry == nullptr) {
         replyToCommand(result, 0);
+        if (entry == nullptr) {
+          return result;
+        }
       }
 
       SerializeIF *elements[2];
@@ -299,6 +307,11 @@ void Subsystem::replyToCommand(ReturnValue_t status, uint32_t parameter) {
   }
 }
 
+ReturnValue_t Subsystem::addSequence(SequenceEntry sequence) {
+  return addSequence(sequence.table, sequence.mode, sequence.fallbackMode, sequence.inStore,
+                     sequence.preInit);
+}
+
 ReturnValue_t Subsystem::addSequence(ArrayList<ModeListEntry> *sequence, Mode_t id,
                                      Mode_t fallbackSequence, bool inStore, bool preInit) {
   ReturnValue_t result;
@@ -342,6 +355,10 @@ ReturnValue_t Subsystem::addSequence(ArrayList<ModeListEntry> *sequence, Mode_t
   return result;
 }
 
+ReturnValue_t Subsystem::addTable(TableEntry table) {
+  return addTable(table.table, table.mode, table.inStore, table.preInit);
+}
+
 ReturnValue_t Subsystem::addTable(ArrayList<ModeListEntry> *table, Mode_t id, bool inStore,
                                   bool preInit) {
   ReturnValue_t result;
@@ -450,6 +467,7 @@ ReturnValue_t Subsystem::initialize() {
   }
 
   mode = initialMode;
+  submode = initSubmode;
 
   return RETURN_OK;
 }
@@ -587,7 +605,10 @@ ReturnValue_t Subsystem::checkObjectConnections() {
   return RETURN_OK;
 }
 
-void Subsystem::setInitialMode(Mode_t mode) { initialMode = mode; }
+void Subsystem::setInitialMode(Mode_t mode, Submode_t submode) {
+  this->initialMode = mode;
+  this->initSubmode = submode;
+}
 
 void Subsystem::cantKeepMode() {
   ReturnValue_t result;

src/fsfw/subsystem/Subsystem.h

@@ -1,16 +1,37 @@
 #ifndef FSFW_SUBSYSTEM_SUBSYSTEM_H_
 #define FSFW_SUBSYSTEM_SUBSYSTEM_H_
 
-#include <FSFWConfig.h>
-
 #include "../container/FixedArrayList.h"
 #include "../container/FixedMap.h"
 #include "../container/HybridIterator.h"
 #include "../container/SinglyLinkedList.h"
 #include "../serialize/SerialArrayListAdapter.h"
 #include "SubsystemBase.h"
+#include "fsfw/FSFW.h"
 #include "modes/ModeDefinitions.h"
 
+struct TableSequenceBase {
+ public:
+  TableSequenceBase(Mode_t mode, ArrayList<ModeListEntry> *table) : mode(mode), table(table){};
+  Mode_t mode;
+  ArrayList<ModeListEntry> *table;
+  bool inStore = false;
+  bool preInit = true;
+};
+
+struct TableEntry : public TableSequenceBase {
+ public:
+  TableEntry(Mode_t mode, ArrayList<ModeListEntry> *table) : TableSequenceBase(mode, table){};
+};
+
+struct SequenceEntry : public TableSequenceBase {
+ public:
+  SequenceEntry(Mode_t mode, ArrayList<ModeListEntry> *table, Mode_t fallbackMode)
+      : TableSequenceBase(mode, table), fallbackMode(fallbackMode) {}
+
+  Mode_t fallbackMode;
+};
+
 /**
  * @brief   TODO: documentation missing
  * @details
@@ -45,13 +66,15 @@ class Subsystem : public SubsystemBase, public HasModeSequenceIF {
             uint32_t maxNumberOfTables);
   virtual ~Subsystem();
 
+  ReturnValue_t addSequence(SequenceEntry sequence);
   ReturnValue_t addSequence(ArrayList<ModeListEntry> *sequence, Mode_t id, Mode_t fallbackSequence,
                             bool inStore = true, bool preInit = true);
 
+  ReturnValue_t addTable(TableEntry table);
   ReturnValue_t addTable(ArrayList<ModeListEntry> *table, Mode_t id, bool inStore = true,
                          bool preInit = true);
 
-  void setInitialMode(Mode_t mode);
+  void setInitialMode(Mode_t mode, Submode_t submode = SUBMODE_NONE);
 
   virtual ReturnValue_t initialize() override;
 
@@ -90,6 +113,7 @@ class Subsystem : public SubsystemBase, public HasModeSequenceIF {
   Submode_t targetSubmode;
 
   Mode_t initialMode = 0;
+  Submode_t initSubmode = SUBMODE_NONE;
 
   HybridIterator<ModeListEntry> currentSequenceIterator;
 
@@ -127,18 +151,18 @@ class Subsystem : public SubsystemBase, public HasModeSequenceIF {
 
   ReturnValue_t deleteTable(Mode_t id);
 
-  virtual void performChildOperation();
+  virtual void performChildOperation() override;
 
-  virtual ReturnValue_t handleCommandMessage(CommandMessage *message);
+  virtual ReturnValue_t handleCommandMessage(CommandMessage *message) override;
 
   bool isFallbackSequence(Mode_t SequenceId);
 
   bool isTableUsed(Mode_t tableId);
 
   virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-                                         uint32_t *msToReachTheMode);
+                                         uint32_t *msToReachTheMode) override;
 
-  virtual void startTransition(Mode_t mode, Submode_t submode);
+  virtual void startTransition(Mode_t mode, Submode_t submode) override;
 
   void sendSerializablesAsCommandMessage(Command_t command, SerializeIF **elements, uint8_t count);
 

src/fsfw/subsystem/SubsystemBase.h

@@ -123,15 +123,15 @@ class SubsystemBase : public SystemObject,
   virtual void performChildOperation() = 0;
 
   virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-                                         uint32_t *msToReachTheMode) = 0;
+                                         uint32_t *msToReachTheMode) override = 0;
 
-  virtual void startTransition(Mode_t mode, Submode_t submode) = 0;
+  virtual void startTransition(Mode_t mode, Submode_t submode) override = 0;
 
-  virtual void getMode(Mode_t *mode, Submode_t *submode);
+  virtual void getMode(Mode_t *mode, Submode_t *submode) override;
 
-  virtual void setToExternalControl();
+  virtual void setToExternalControl() override;
 
-  virtual void announceMode(bool recursive);
+  virtual void announceMode(bool recursive) override;
 
   virtual void modeChanged();
 };

src/fsfw/timemanager/CCSDSTime.cpp

@@ -6,10 +6,6 @@
 
 #include "fsfw/FSFW.h"
 
-CCSDSTime::CCSDSTime() {}
-
-CCSDSTime::~CCSDSTime() {}
-
 ReturnValue_t CCSDSTime::convertToCcsds(Ccs_seconds* to, const Clock::TimeOfDay_t* from) {
   ReturnValue_t result = checkTimeOfDay(from);
   if (result != RETURN_OK) {
@@ -91,7 +87,7 @@ ReturnValue_t CCSDSTime::convertFromCDS(Clock::TimeOfDay_t* to, const uint8_t* f
   if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
-  return convertTimevalToTimeOfDay(to, &time);
+  return Clock::convertTimevalToTimeOfDay(&time, to);
 }
 
 ReturnValue_t CCSDSTime::convertFromCCS(Clock::TimeOfDay_t* to, const uint8_t* from,
@@ -428,7 +424,7 @@ ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, const uint8_t* from, size_t
   from++;
   ReturnValue_t result = convertFromCUC(to, pField, from, foundLength, maxLength - 1);
   if (result == HasReturnvaluesIF::RETURN_OK) {
-    if (foundLength != NULL) {
+    if (foundLength != nullptr) {
       *foundLength += 1;
     }
   }
@@ -489,11 +485,6 @@ ReturnValue_t CCSDSTime::checkTimeOfDay(const Clock::TimeOfDay_t* time) {
   return RETURN_OK;
 }
 
-ReturnValue_t CCSDSTime::convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to, timeval* from) {
-  // This is rather tricky. Implement only if needed. Also, if so, move to OSAL.
-  return UNSUPPORTED_TIME_FORMAT;
-}
-
 ReturnValue_t CCSDSTime::convertFromCDS(timeval* to, const uint8_t* from, size_t* foundLength,
                                         size_t maxLength) {
   uint8_t pField = *from;
@@ -583,7 +574,7 @@ ReturnValue_t CCSDSTime::convertFromCDS(Clock::TimeOfDay_t* to, const CCSDSTime:
   if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
-  return CCSDSTime::convertTimevalToTimeOfDay(to, &tempTimeval);
+  return Clock::convertTimevalToTimeOfDay(&tempTimeval, to);
 }
 
 ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, uint8_t pField, const uint8_t* from,
@@ -593,18 +584,18 @@ ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, uint8_t pField, const uint8
   uint8_t nCoarse = ((pField & 0b1100) >> 2) + 1;
   uint8_t nFine = (pField & 0b11);
   size_t totalLength = nCoarse + nFine;
-  if (foundLength != NULL) {
+  if (foundLength != nullptr) {
     *foundLength = totalLength;
   }
   if (totalLength > maxLength) {
     return LENGTH_MISMATCH;
   }
-  for (int count = 0; count < nCoarse; count++) {
+  for (int count = nCoarse; count > 0; count--) {
-    secs += *from << ((nCoarse * 8 - 8) * (1 + count));
+    secs += *from << (count * 8 - 8);
     from++;
   }
-  for (int count = 0; count < nFine; count++) {
+  for (int count = nFine; count > 0; count--) {
-    subSeconds += *from << ((nFine * 8 - 8) * (1 + count));
+    subSeconds += *from << (count * 8 - 8);
     from++;
   }
   // Move to POSIX epoch.

src/fsfw/timemanager/CCSDSTime.h

@@ -161,18 +161,37 @@ class CCSDSTime : public HasReturnvaluesIF {
    */
   static ReturnValue_t convertFromCcsds(timeval *to, uint8_t const *from, size_t *foundLength,
                                         size_t maxLength);
-
+  /**
+   * @brief Currently unsupported conversion due to leapseconds
+   *
+   * @param to Time Of Day (UTC)
+   * @param from Buffer to take the CUC from
+   * @param length Length of buffer
+   * @return ReturnValue_t UNSUPPORTED_TIME_FORMAT in any case ATM
+   */
   static ReturnValue_t convertFromCUC(Clock::TimeOfDay_t *to, uint8_t const *from, uint8_t length);
-
+  /**
+   * @brief Converts from CCSDS CUC to timeval
+   *
+   * If input is CCSDS Epoch this is TAI! -> No leapsecond support.
+   *
+   * Currently, it only supports seconds + 2 Byte Subseconds (1/65536 seconds)
+   *
+   *
+   * @param to Timeval to write the result to
+   * @param from Buffer to read from
+   * @param foundLength Length found by this function (can be nullptr if unused)
+   * @param maxLength Max length of the buffer to be read
+   * @return ReturnValue_t - RETURN_OK if successful
+   *                       - LENGTH_MISMATCH if expected length is larger than maxLength
+   */
   static ReturnValue_t convertFromCUC(timeval *to, uint8_t const *from, size_t *foundLength,
                                       size_t maxLength);
-
   static ReturnValue_t convertFromCUC(timeval *to, uint8_t pField, uint8_t const *from,
                                       size_t *foundLength, size_t maxLength);
 
   static ReturnValue_t convertFromCCS(timeval *to, uint8_t const *from, size_t *foundLength,
                                       size_t maxLength);
-
   static ReturnValue_t convertFromCCS(timeval *to, uint8_t pField, uint8_t const *from,
                                       size_t *foundLength, size_t maxLength);
 
@@ -192,8 +211,8 @@ class CCSDSTime : public HasReturnvaluesIF {
   static uint32_t subsecondsToMicroseconds(uint16_t subseconds);
 
  private:
-  CCSDSTime();
+  CCSDSTime(){};
-  virtual ~CCSDSTime();
+  virtual ~CCSDSTime(){};
   /**
    * checks a ccs time stream for validity
    *
@@ -223,7 +242,6 @@ class CCSDSTime : public HasReturnvaluesIF {
                                          uint8_t *day);
 
   static bool isLeapYear(uint32_t year);
-  static ReturnValue_t convertTimevalToTimeOfDay(Clock::TimeOfDay_t *to, timeval *from);
 };
 
 #endif /* FSFW_TIMEMANAGER_CCSDSTIME_H_ */

src/fsfw/timemanager/Clock.h

@@ -99,6 +99,13 @@ class Clock {
    */
   static ReturnValue_t getDateAndTime(TimeOfDay_t *time);
 
+  /**
+   * Convert to time of day struct given the POSIX timeval struct
+   * @param from
+   * @param to
+   * @return
+   */
+  static ReturnValue_t convertTimevalToTimeOfDay(const timeval *from, TimeOfDay_t *to);
   /**
    * Converts a time of day struct to POSIX seconds.
    * @param time The time of day as input
@@ -166,6 +173,7 @@ class Clock {
 
   static MutexIF *timeMutex;
   static uint16_t leapSeconds;
+  static bool leapSecondsSet;
 };
 
 #endif /* FSFW_TIMEMANAGER_CLOCK_H_ */

src/fsfw/timemanager/ClockCommon.cpp

@@ -1,7 +1,13 @@
+#include <ctime>
+
 #include "fsfw/ipc/MutexGuard.h"
 #include "fsfw/timemanager/Clock.h"
 
-ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval *tt) {
+uint16_t Clock::leapSeconds = 0;
+MutexIF* Clock::timeMutex = nullptr;
+bool Clock::leapSecondsSet = false;
+
+ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval* tt) {
   uint16_t leapSeconds;
   ReturnValue_t result = getLeapSeconds(&leapSeconds);
   if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -27,12 +33,16 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
   MutexGuard helper(timeMutex);
 
   leapSeconds = leapSeconds_;
+  leapSecondsSet = true;
 
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t Clock::getLeapSeconds(uint16_t *leapSeconds_) {
+ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
-  if (timeMutex == nullptr) {
+  if (not leapSecondsSet) {
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  if (checkOrCreateClockMutex() != HasReturnvaluesIF::RETURN_OK) {
     return HasReturnvaluesIF::RETURN_FAILED;
   }
   MutexGuard helper(timeMutex);
@@ -42,9 +52,32 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t *leapSeconds_) {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
+ReturnValue_t Clock::convertTimevalToTimeOfDay(const timeval* from, TimeOfDay_t* to) {
+  struct tm* timeInfo;
+  // According to https://en.cppreference.com/w/c/chrono/gmtime, the implementation of gmtime_s
+  // in the Windows CRT is incompatible with the C standard but this should not be an issue for
+  // this implementation
+  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
+  timeInfo = gmtime(&from->tv_sec);
+  to->year = timeInfo->tm_year + 1900;
+  to->month = timeInfo->tm_mon + 1;
+  to->day = timeInfo->tm_mday;
+  to->hour = timeInfo->tm_hour;
+  to->minute = timeInfo->tm_min;
+  to->second = timeInfo->tm_sec;
+  to->usecond = from->tv_usec;
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
 ReturnValue_t Clock::checkOrCreateClockMutex() {
   if (timeMutex == nullptr) {
-    MutexFactory *mutexFactory = MutexFactory::instance();
+    MutexFactory* mutexFactory = MutexFactory::instance();
     if (mutexFactory == nullptr) {
       return HasReturnvaluesIF::RETURN_FAILED;
     }

src/fsfw/tmtcpacket/SpacePacket.cpp

@@ -19,8 +19,8 @@ SpacePacket::SpacePacket(uint16_t packetDataLength, bool isTelecommand, uint16_t
 SpacePacket::~SpacePacket(void) {}
 
 bool SpacePacket::addWholeData(const uint8_t* p_Data, uint32_t packet_size) {
-  if (packet_size <= sizeof(this->data)) {
+  if (packet_size <= sizeof(this->localData)) {
-    memcpy(&this->localData.byteStream, p_Data, packet_size);
+    memcpy(this->localData.byteStream, p_Data, packet_size);
     return true;
   } else {
     return false;

src/fsfw/tmtcservices/CommandingServiceBase.h

@@ -95,7 +95,7 @@ class CommandingServiceBase : public SystemObject,
    */
   virtual ReturnValue_t performOperation(uint8_t opCode) override;
 
-  virtual uint16_t getIdentifier();
+  virtual uint16_t getIdentifier() override;
 
   /**
    * Returns the requestQueue MessageQueueId_t
@@ -104,7 +104,7 @@ class CommandingServiceBase : public SystemObject,
    *
    * @return requestQueue messageQueueId_t
    */
-  virtual MessageQueueId_t getRequestQueue();
+  virtual MessageQueueId_t getRequestQueue() override;
 
   /**
    * Returns the commandQueue MessageQueueId_t
@@ -166,7 +166,7 @@ class CommandingServiceBase : public SystemObject,
    * @param objectId Target object ID
    * @return
    * - @c RETURN_OK to generate a verification start message
-   * - @c EXECUTION_COMPELTE Fire-and-forget command. Generate a completion
+   * - @c EXECUTION_COMPLETE Fire-and-forget command. Generate a completion
    *      verification message.
    * - @c Anything else rejects the packets and generates a start failure
    *      verification.

src/fsfw/version.cpp

@@ -1,8 +1,9 @@
 #include "version.h"
-#include "fsfw/FSFWVersion.h"
 
 #include <cstdio>
 
+#include "fsfw/FSFWVersion.h"
+
 #ifdef major
 #undef major
 #endif

src/fsfw/version.h

@@ -29,7 +29,7 @@ class Version {
   }
 
   friend bool operator>(const Version& v1, const Version& v2) {
-    return not (v1 < v2) and not (v1 == v2);
+    return not(v1 < v2) and not(v1 == v2);
   }
 
   friend bool operator<=(const Version& v1, const Version& v2) { return ((v1 == v2) or (v1 < v2)); }

tests/src/fsfw_tests/unit/globalfunctions/CMakeLists.txt

@@ -3,4 +3,5 @@ target_sources(${FSFW_TEST_TGT} PRIVATE
     testOpDivider.cpp
     testBitutil.cpp
     testCRC.cpp
+    testTimevalOperations.cpp
 )

tests/src/fsfw_tests/unit/globalfunctions/testTimevalOperations.cpp

@@ -0,0 +1,124 @@
+#include <fsfw/globalfunctions/timevalOperations.h>
+
+#include <catch2/catch_approx.hpp>
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw_tests/unit/CatchDefinitions.h"
+
+TEST_CASE("TimevalTest", "[timevalOperations]") {
+  SECTION("Comparison") {
+    timeval t1;
+    t1.tv_sec = 1648227422;
+    t1.tv_usec = 123456;
+    timeval t2;
+    t2.tv_sec = 1648227422;
+    t2.tv_usec = 123456;
+    REQUIRE(t1 == t2);
+    REQUIRE(t2 == t1);
+    REQUIRE_FALSE(t1 != t2);
+    REQUIRE_FALSE(t2 != t1);
+    REQUIRE(t1 <= t2);
+    REQUIRE(t2 <= t1);
+    REQUIRE(t1 >= t2);
+    REQUIRE(t2 >= t1);
+    REQUIRE_FALSE(t1 < t2);
+    REQUIRE_FALSE(t2 < t1);
+    REQUIRE_FALSE(t1 > t2);
+    REQUIRE_FALSE(t2 > t1);
+
+    timeval t3;
+    t3.tv_sec = 1648227422;
+    t3.tv_usec = 123457;
+    REQUIRE_FALSE(t1 == t3);
+    REQUIRE(t1 != t3);
+    REQUIRE(t1 <= t3);
+    REQUIRE_FALSE(t3 <= t1);
+    REQUIRE_FALSE(t1 >= t3);
+    REQUIRE(t3 >= t1);
+    REQUIRE(t1 < t3);
+    REQUIRE_FALSE(t3 < t1);
+    REQUIRE_FALSE(t1 > t3);
+    REQUIRE(t3 > t1);
+
+    timeval t4;
+    t4.tv_sec = 1648227423;
+    t4.tv_usec = 123456;
+    REQUIRE_FALSE(t1 == t4);
+    REQUIRE(t1 != t4);
+    REQUIRE(t1 <= t4);
+    REQUIRE_FALSE(t4 <= t1);
+    REQUIRE_FALSE(t1 >= t4);
+    REQUIRE(t4 >= t1);
+    REQUIRE(t1 < t4);
+    REQUIRE_FALSE(t4 < t1);
+    REQUIRE_FALSE(t1 > t4);
+    REQUIRE(t4 > t1);
+  }
+  SECTION("Operators") {
+    timeval t1;
+    t1.tv_sec = 1648227422;
+    t1.tv_usec = 123456;
+    timeval t2;
+    t2.tv_sec = 1648227422;
+    t2.tv_usec = 123456;
+    timeval t3 = t1 - t2;
+    REQUIRE(t3.tv_sec == 0);
+    REQUIRE(t3.tv_usec == 0);
+    timeval t4 = t1 - t3;
+    REQUIRE(t4.tv_sec == 1648227422);
+    REQUIRE(t4.tv_usec == 123456);
+    timeval t5 = t3 - t1;
+    REQUIRE(t5.tv_sec == -1648227422);
+    REQUIRE(t5.tv_usec == -123456);
+
+    timeval t6;
+    t6.tv_sec = 1648227400;
+    t6.tv_usec = 999999;
+
+    timeval t7 = t6 + t1;
+    REQUIRE(t7.tv_sec == (1648227422ull + 1648227400ull + 1ull));
+    REQUIRE(t7.tv_usec == 123455);
+
+    timeval t8 = t1 - t6;
+    REQUIRE(t8.tv_sec == 1648227422 - 1648227400 - 1);
+    REQUIRE(t8.tv_usec == 123457);
+
+    double scalar = 2;
+    timeval t9 = t1 * scalar;
+    REQUIRE(t9.tv_sec == 3296454844);
+    REQUIRE(t9.tv_usec == 246912);
+    timeval t10 = scalar * t1;
+    REQUIRE(t10.tv_sec == 3296454844);
+    REQUIRE(t10.tv_usec == 246912);
+    timeval t11 = t6 * scalar;
+    REQUIRE(t11.tv_sec == (3296454800 + 1));
+    REQUIRE(t11.tv_usec == 999998);
+
+    timeval t12 = t1 / scalar;
+    REQUIRE(t12.tv_sec == 824113711);
+    REQUIRE(t12.tv_usec == 61728);
+
+    timeval t13 = t6 / scalar;
+    REQUIRE(t13.tv_sec == 824113700);
+    // Rounding issue
+    REQUIRE(t13.tv_usec == 499999);
+
+    double scalar2 = t9 / t1;
+    REQUIRE(scalar2 == Catch::Approx(2.0));
+    double scalar3 = t1 / t6;
+    REQUIRE(scalar3 == Catch::Approx(1.000000013));
+    double scalar4 = t3 / t1;
+    REQUIRE(scalar4 == Catch::Approx(0));
+    double scalar5 = t12 / t1;
+    REQUIRE(scalar5 == Catch::Approx(0.5));
+  }
+
+  SECTION("timevalOperations::toTimeval") {
+    double seconds = 1648227422.123456;
+    timeval t1 = timevalOperations::toTimeval(seconds);
+    REQUIRE(t1.tv_sec == 1648227422);
+    // Allow 1 usec rounding tolerance
+    REQUIRE(t1.tv_usec >= 123455);
+    REQUIRE(t1.tv_usec <= 123457);
+  }
+}

tests/src/fsfw_tests/unit/mocks/MessageQueueMockBase.h

@@ -4,8 +4,8 @@
 #include <cstring>
 #include <queue>
 
-#include "fsfw/ipc/MessageQueueBase.h"
 #include "fsfw/ipc/CommandMessage.h"
+#include "fsfw/ipc/MessageQueueBase.h"
 #include "fsfw/ipc/MessageQueueIF.h"
 #include "fsfw/ipc/MessageQueueMessage.h"
 #include "fsfw_tests/unit/CatchDefinitions.h"
@@ -13,7 +13,7 @@
 class MessageQueueMockBase : public MessageQueueBase {
  public:
   MessageQueueMockBase()
-   : MessageQueueBase(MessageQueueIF::NO_QUEUE, MessageQueueIF::NO_QUEUE, nullptr) {}
+      : MessageQueueBase(MessageQueueIF::NO_QUEUE, MessageQueueIF::NO_QUEUE, nullptr) {}
 
   uint8_t messageSentCounter = 0;
   bool messageSent = false;

tests/src/fsfw_tests/unit/osal/CMakeLists.txt

@@ -1,4 +1,5 @@
 target_sources(${FSFW_TEST_TGT} PRIVATE
 	TestMessageQueue.cpp
 	TestSemaphore.cpp
+	TestClock.cpp
 )

tests/src/fsfw_tests/unit/osal/TestClock.cpp

@@ -0,0 +1,86 @@
+#include <fsfw/globalfunctions/timevalOperations.h>
+#include <fsfw/timemanager/Clock.h>
+
+#include <array>
+#include <catch2/catch_approx.hpp>
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw_tests/unit/CatchDefinitions.h"
+
+TEST_CASE("OSAL::Clock Test", "[OSAL::Clock Test]") {
+  SECTION("Test getClock") {
+    timeval time;
+    ReturnValue_t result = Clock::getClock_timeval(&time);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    Clock::TimeOfDay_t timeOfDay;
+    result = Clock::getDateAndTime(&timeOfDay);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    timeval timeOfDayAsTimeval;
+    result = Clock::convertTimeOfDayToTimeval(&timeOfDay, &timeOfDayAsTimeval);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    // We require timeOfDayAsTimeval to be larger than time as it
+    // was request a few ns later
+    double difference = timevalOperations::toDouble(timeOfDayAsTimeval - time);
+    CHECK(difference >= 0.0);
+    CHECK(difference <= 0.005);
+
+    // Conversion in the other direction
+    Clock::TimeOfDay_t timevalAsTimeOfDay;
+    result = Clock::convertTimevalToTimeOfDay(&time, &timevalAsTimeOfDay);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    CHECK(timevalAsTimeOfDay.year <= timeOfDay.year);
+    // TODO We should write TimeOfDay operators!
+  }
+  SECTION("Leap seconds") {
+    uint16_t leapSeconds = 0;
+    ReturnValue_t result = Clock::getLeapSeconds(&leapSeconds);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_FAILED);
+    REQUIRE(leapSeconds == 0);
+    result = Clock::setLeapSeconds(18);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    result = Clock::getLeapSeconds(&leapSeconds);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(leapSeconds == 18);
+  }
+  SECTION("usec Test") {
+    timeval timeAsTimeval;
+    ReturnValue_t result = Clock::getClock_timeval(&timeAsTimeval);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    uint64_t timeAsUsec = 0;
+    result = Clock::getClock_usecs(&timeAsUsec);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    double timeAsUsecDouble = static_cast<double>(timeAsUsec) / 1000000.0;
+    timeval timeAsUsecTimeval = timevalOperations::toTimeval(timeAsUsecDouble);
+    double difference = timevalOperations::toDouble(timeAsUsecTimeval - timeAsTimeval);
+    // We accept 5 ms difference
+    CHECK(difference >= 0.0);
+    CHECK(difference <= 0.005);
+    uint64_t timevalAsUint64 = static_cast<uint64_t>(timeAsTimeval.tv_sec) * 1000000ull +
+                               static_cast<uint64_t>(timeAsTimeval.tv_usec);
+    CHECK((timeAsUsec - timevalAsUint64) >= 0);
+    CHECK((timeAsUsec - timevalAsUint64) <= (5 * 1000));
+  }
+  SECTION("Test j2000") {
+    double j2000;
+    timeval time;
+    time.tv_sec = 1648208539;
+    time.tv_usec = 0;
+    ReturnValue_t result = Clock::convertTimevalToJD2000(time, &j2000);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    double correctJ2000 = 2459663.98772 - 2451545.0;
+    CHECK(j2000 == Catch::Approx(correctJ2000).margin(1.2 * 1e-8));
+  }
+  SECTION("Convert to TT") {
+    timeval utcTime;
+    utcTime.tv_sec = 1648208539;
+    utcTime.tv_usec = 999000;
+    timeval tt;
+    ReturnValue_t result = Clock::setLeapSeconds(27);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    result = Clock::convertUTCToTT(utcTime, &tt);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    CHECK(tt.tv_usec == 183000);
+    // The plus 1 is a own forced overflow of usecs
+    CHECK(tt.tv_sec == (1648208539 + 27 + 10 + 32 + 1));
+  }
+}

tests/src/fsfw_tests/unit/timemanager/TestCCSDSTime.cpp

@@ -81,7 +81,8 @@ TEST_CASE("CCSDSTime Tests", "[TestCCSDSTime]") {
     std::string timeAscii = "2022-12-31T23:59:59.123Z";
     Clock::TimeOfDay_t timeTo;
     const uint8_t* timeChar = reinterpret_cast<const uint8_t*>(timeAscii.c_str());
-    CCSDSTime::convertFromASCII(&timeTo, timeChar, timeAscii.length());
+    auto result = CCSDSTime::convertFromASCII(&timeTo, timeChar, timeAscii.length());
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
     REQUIRE(timeTo.year == 2022);
     REQUIRE(timeTo.month == 12);
     REQUIRE(timeTo.day == 31);
@@ -89,6 +90,19 @@ TEST_CASE("CCSDSTime Tests", "[TestCCSDSTime]") {
     REQUIRE(timeTo.minute == 59);
     REQUIRE(timeTo.second == 59);
     REQUIRE(timeTo.usecond == Catch::Approx(123000));
+
+    std::string timeAscii2 = "2022-365T23:59:59.123Z";
+    const uint8_t* timeChar2 = reinterpret_cast<const uint8_t*>(timeAscii2.c_str());
+    Clock::TimeOfDay_t timeTo2;
+    result = CCSDSTime::convertFromCcsds(&timeTo2, timeChar2, timeAscii2.length());
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(timeTo2.year == 2022);
+    REQUIRE(timeTo2.month == 12);
+    REQUIRE(timeTo2.day == 31);
+    REQUIRE(timeTo2.hour == 23);
+    REQUIRE(timeTo2.minute == 59);
+    REQUIRE(timeTo2.second == 59);
+    REQUIRE(timeTo2.usecond == Catch::Approx(123000));
   }
 
   SECTION("CDS Conversions") {
@@ -119,6 +133,7 @@ TEST_CASE("CCSDSTime Tests", "[TestCCSDSTime]") {
     CHECK(cdsTime.msDay_h == 0xE0);
     CHECK(cdsTime.msDay_l == 0xC5);
     CHECK(cdsTime.msDay_ll == 0xC3);
+    CHECK(cdsTime.pField == CCSDSTime::P_FIELD_CDS_SHORT);
 
     // Conversion back to timeval
     timeval timeReturnAsTimeval;
@@ -128,5 +143,77 @@ TEST_CASE("CCSDSTime Tests", "[TestCCSDSTime]") {
     timeval difference = timeAsTimeval - timeReturnAsTimeval;
     CHECK(difference.tv_usec == 456);
     CHECK(difference.tv_sec == 0);
+
+    Clock::TimeOfDay_t timeReturnAsTimeOfDay;
+    result = CCSDSTime::convertFromCDS(&timeReturnAsTimeOfDay, &cdsTime);
+    CHECK(result == HasReturnvaluesIF::RETURN_OK);
+    CHECK(timeReturnAsTimeOfDay.year == 2020);
+    CHECK(timeReturnAsTimeOfDay.month == 2);
+    CHECK(timeReturnAsTimeOfDay.day == 29);
+    CHECK(timeReturnAsTimeOfDay.hour == 13);
+    CHECK(timeReturnAsTimeOfDay.minute == 24);
+    CHECK(timeReturnAsTimeOfDay.second == 45);
+    // micro seconds precision is lost
+    CHECK(timeReturnAsTimeOfDay.usecond == 123000);
+
+    Clock::TimeOfDay_t timeReturnAsTodFromBuffer;
+    const uint8_t* buffer = reinterpret_cast<const uint8_t*>(&cdsTime);
+    result = CCSDSTime::convertFromCDS(&timeReturnAsTodFromBuffer, buffer, sizeof(cdsTime));
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    CHECK(timeReturnAsTodFromBuffer.year == time.year);
+    CHECK(timeReturnAsTodFromBuffer.month == time.month);
+    CHECK(timeReturnAsTodFromBuffer.day == time.day);
+    CHECK(timeReturnAsTodFromBuffer.hour == time.hour);
+    CHECK(timeReturnAsTodFromBuffer.minute == time.minute);
+    CHECK(timeReturnAsTodFromBuffer.second == time.second);
+    CHECK(timeReturnAsTodFromBuffer.usecond == 123000);
+
+    Clock::TimeOfDay_t todFromCCSDS;
+    result = CCSDSTime::convertFromCcsds(&todFromCCSDS, buffer, sizeof(cdsTime));
+    CHECK(result == HasReturnvaluesIF::RETURN_OK);
+    CHECK(todFromCCSDS.year == time.year);
+    CHECK(todFromCCSDS.month == time.month);
+    CHECK(todFromCCSDS.day == time.day);
+    CHECK(todFromCCSDS.hour == time.hour);
+    CHECK(todFromCCSDS.minute == time.minute);
+    CHECK(todFromCCSDS.second == time.second);
+    CHECK(todFromCCSDS.usecond == 123000);
+  }
+  SECTION("CUC") {
+    timeval to;
+    // seconds = 0x771E960F, microseconds = 0x237
+    // microseconds = 567000
+    // This gives 37158.912 1/65536 seconds -> rounded to 37159 -> 0x9127
+    // This results in -> 567001 us
+    std::array<uint8_t, 7> cucBuffer = {
+        CCSDSTime::P_FIELD_CUC_6B_CCSDS, 0x77, 0x1E, 0x96, 0x0F, 0x91, 0x27};
+    size_t foundLength = 0;
+    auto result = CCSDSTime::convertFromCUC(&to, cucBuffer.data(), &foundLength, cucBuffer.size());
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(foundLength == 7);
+    REQUIRE(to.tv_sec == 1619801999);  // TAI (no leap seconds)
+    REQUIRE(to.tv_usec == 567001);
+
+    Clock::TimeOfDay_t tod;
+    result = CCSDSTime::convertFromCUC(&tod, cucBuffer.data(), cucBuffer.size());
+    // This test must be changed if this is ever going to be implemented
+    REQUIRE(result == CCSDSTime::UNSUPPORTED_TIME_FORMAT);
+  }
+
+  SECTION("CCSDS Failures") {
+    Clock::TimeOfDay_t time;
+    time.year = 2020;
+    time.month = 12;
+    time.day = 32;
+    time.hour = 13;
+    time.minute = 24;
+    time.second = 45;
+    time.usecond = 123456;
+    CCSDSTime::Ccs_mseconds to;
+    auto result = CCSDSTime::convertToCcsds(&to, &time);
+    REQUIRE(result == CCSDSTime::INVALID_TIME_FORMAT);
+    CCSDSTime::Ccs_seconds to2;
+    result = CCSDSTime::convertToCcsds(&to2, &time);
+    REQUIRE(result == CCSDSTime::INVALID_TIME_FORMAT);
   }
 }

tests/src/fsfw_tests/unit/version.cpp

@@ -17,15 +17,15 @@ TEST_CASE("Version API Tests", "[TestVersionAPI]") {
   fsfw::Version v1 = fsfw::Version(1, 1, 1);
   fsfw::Version v2 = fsfw::Version(1, 1, 1);
   REQUIRE(v1 == v2);
-  REQUIRE(not (v1 < v2));
+  REQUIRE(not(v1 < v2));
-  REQUIRE(not (v1 > v2));
+  REQUIRE(not(v1 > v2));
   REQUIRE(v1 <= v2);
   REQUIRE(v1 >= v2);
   v1.revision -= 1;
   REQUIRE(v1 != v2);
-  REQUIRE(not (v1 == v2));
+  REQUIRE(not(v1 == v2));
-  REQUIRE(not (v1 > v2));
+  REQUIRE(not(v1 > v2));
-  REQUIRE(not (v1 >= v2));
+  REQUIRE(not(v1 >= v2));
   REQUIRE(v1 < v2);
   REQUIRE(v1 <= v2);
   v1.revision += 1;
@@ -33,60 +33,60 @@ TEST_CASE("Version API Tests", "[TestVersionAPI]") {
   REQUIRE(v1 != v2);
   REQUIRE(v1 < v2);
   REQUIRE(v1 <= v2);
-  REQUIRE(not (v1 == v2));
+  REQUIRE(not(v1 == v2));
-  REQUIRE(not (v1 > v2));
+  REQUIRE(not(v1 > v2));
-  REQUIRE(not (v1 >= v2));
+  REQUIRE(not(v1 >= v2));
   v1.minor += 1;
   v1.major -= 1;
   REQUIRE(v1 != v2);
   REQUIRE(v1 < v2);
   REQUIRE(v1 <= v2);
-  REQUIRE(not (v1 == v2));
+  REQUIRE(not(v1 == v2));
-  REQUIRE(not (v1 > v2));
+  REQUIRE(not(v1 > v2));
-  REQUIRE(not (v1 >= v2));
+  REQUIRE(not(v1 >= v2));
   v1.major += 1;
   REQUIRE(v1 == v2);
   REQUIRE(v1 <= v2);
   REQUIRE(v1 >= v2);
-  REQUIRE(not (v1 != v2));
+  REQUIRE(not(v1 != v2));
-  REQUIRE(not (v1 > v2));
+  REQUIRE(not(v1 > v2));
-  REQUIRE(not (v1 < v2));
+  REQUIRE(not(v1 < v2));
   v1.major += 1;
   v1.minor -= 1;
   REQUIRE(v1 != v2);
   REQUIRE(v1 > v2);
   REQUIRE(v1 >= v2);
-  REQUIRE(not (v1 == v2));
+  REQUIRE(not(v1 == v2));
-  REQUIRE(not (v1 < v2));
+  REQUIRE(not(v1 < v2));
-  REQUIRE(not (v1 <= v2));
+  REQUIRE(not(v1 <= v2));
   v1.major -= 1;
   v1.minor += 2;
   v1.revision -= 1;
   REQUIRE(v1 != v2);
   REQUIRE(v1 > v2);
   REQUIRE(v1 >= v2);
-  REQUIRE(not (v1 == v2));
+  REQUIRE(not(v1 == v2));
-  REQUIRE(not (v1 < v2));
+  REQUIRE(not(v1 < v2));
-  REQUIRE(not (v1 <= v2));
+  REQUIRE(not(v1 <= v2));
   v1.minor -= 1;
   v1.revision += 2;
   REQUIRE(v1 != v2);
   REQUIRE(v1 > v2);
   REQUIRE(v1 >= v2);
-  REQUIRE(not (v1 == v2));
+  REQUIRE(not(v1 == v2));
-  REQUIRE(not (v1 < v2));
+  REQUIRE(not(v1 < v2));
-  REQUIRE(not (v1 <= v2));
+  REQUIRE(not(v1 <= v2));
   v1.revision -= 1;
   REQUIRE(v1 == v2);
   REQUIRE(v1 <= v2);
   REQUIRE(v1 >= v2);
-  REQUIRE(not (v1 != v2));
+  REQUIRE(not(v1 != v2));
 #if FSFW_CPP_OSTREAM_ENABLED == 1
   sif::info << "v" << fsfw::FSFW_VERSION << std::endl;
 #endif
   char verString[10] = {};
   fsfw::FSFW_VERSION.getVersion(verString, sizeof(verString));
 #if FSFW_DISABLE_PRINTOUT == 0
-  printf("v%s\n",verString);
+  printf("v%s\n", verString);
 #endif
 }