Merge branch 'meier/sequenceCount' into meier/develop

sequence count init value
Merge branch 'eive/develop' into meier/develop
2022-05-11 16:54:06 +02:00 · 2022-05-11 14:31:49 +02:00 · 2022-05-05 12:28:34 +02:00 · 2022-05-05 09:15:23 +02:00 · 2022-05-04 14:03:28 +02:00 · 2022-05-04 10:36:32 +02:00
58 changed files with 825 additions and 224 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -38,6 +38,16 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
    versions since the last tag
  - Additional information is set to the last part of the git describe output for `FSFW_VERSION` now.
  - Version still need to be hand-updated if the FSFW is not included as a submodule for now.
+- IPC Message Queue Handling: Allow passing an optional `MqArgs` argument into the MessageQueue
+  creation call. It allows passing context information and an arbitrary user argument into
+  the message queue. Also streamlined and simplified `MessageQueue` implementation for all OSALs
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/583
+- 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

@ -51,11 +61,16 @@ 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

 ## Fixed

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

--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,4 +1,5 @@
 cmake_minimum_required(VERSION 3.13)
+project(${LIB_FSFW_NAME})

 set(FSFW_VERSION_IF_GIT_FAILS 4)
 set(FSFW_SUBVERSION_IF_GIT_FAILS 0)
@ -9,6 +10,23 @@ list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" )
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake-modules")
 set(MSG_PREFIX "fsfw |")

+set(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
 )
@ -44,7 +62,6 @@ set(LIB_FSFW_NAME fsfw)
 set(FSFW_TEST_TGT fsfw-tests)
 set(FSFW_DUMMY_TGT fsfw-dummy)

-project(${LIB_FSFW_NAME})
 add_library(${LIB_FSFW_NAME})

 set(FSFW_GIT_VER_HANDLING_OK FALSE)
@ -82,7 +99,7 @@ endif()
 if(FSFW_BUILD_UNITTESTS)
    message(STATUS "${MSG_PREFIX} Building the FSFW unittests in addition to the static library")
    # Check whether the user has already installed Catch2 first
-    find_package(Catch2 3 QUIET)
+    find_package(Catch2 ${FSFW_CATCH2_LIB_MAJOR_VERSION} CONFIG QUIET)
    # Not installed, so use FetchContent to download and provide Catch2
    if(NOT Catch2_FOUND)
        message(STATUS "${MSG_PREFIX} Catch2 installation not found. Downloading Catch2 library with FetchContent")
@ -91,12 +108,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)
-        #fixes regression -preview4, to be confirmed in later releases
-        set_target_properties(Catch2 PROPERTIES DEBUG_POSTFIX "")
+        list(APPEND FSFW_FETCH_CONTENT_TARGETS Catch2)
    endif()

    set(FSFW_CONFIG_PATH tests/src/fsfw_tests/unit/testcfg)
@ -116,6 +131,40 @@ if(FSFW_BUILD_UNITTESTS)
    endif()
 endif()

+message(STATUS "Finding and/or providing etl library with version ${FSFW_ETL_LIB_MAJOR_VERSION}")
+
+# Check whether the user has already installed ETL first
+find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} CONFIG QUIET)
+# Not installed, so use FetchContent to download and provide etl
+if(NOT ${FSFW_ETL_LIB_NAME}_FOUND)
+    message(STATUS
+        "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)
@ -377,6 +426,7 @@ target_compile_options(${LIB_FSFW_NAME} PRIVATE
 )

 target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+    ${FSFW_ETL_LINK_TARGET}
    ${FSFW_ADDITIONAL_LINK_LIBS}
 )

--- a/README.md
+++ b/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`.
--- a/automation/Dockerfile
+++ b/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
--- a/automation/Jenkinsfile
+++ b/automation/Jenkinsfile
@ -3,7 +3,7 @@ pipeline {
        BUILDDIR = 'build-tests'
    }
    agent {
-        docker { image 'fsfw-ci:d1'}
+        docker { image 'fsfw-ci:d2'}
    }
    stages {
        stage('Clean') {
--- a/docs/getting_started.rst
+++ b/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`.
--- a/hal/src/fsfw_hal/common/gpio/GpioIF.h
+++ b/hal/src/fsfw_hal/common/gpio/GpioIF.h
@ -46,9 +46,9 @@ class GpioIF : public HasReturnvaluesIF {
   *          an ouput or input gpio.
   *
   * @param gpioId    A unique number which specifies the GPIO to read.
-   * @param gpioState State of GPIO will be written to this pointer.
+   * @param gpioState State of GPIO will be written to this reference
   */
-  virtual ReturnValue_t readGpio(gpioId_t gpioId, int* gpioState) = 0;
+  virtual ReturnValue_t readGpio(gpioId_t gpioId, gpio::Levels& gpioState) = 0;
 };

 #endif /* COMMON_GPIO_GPIOIF_H_ */
--- a/hal/src/fsfw_hal/common/gpio/gpioDefinitions.h
+++ b/hal/src/fsfw_hal/common/gpio/gpioDefinitions.h
@ -9,7 +9,7 @@ using gpioId_t = uint16_t;

 namespace gpio {

-enum class Levels : int { LOW = 0, HIGH = 1, NONE = 99 };
+enum class Levels : int { LOW = 0, HIGH = 1, FAILED = -1, NONE = 99 };

 enum class Direction : int { IN = 0, OUT = 1 };

--- a/hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp
+++ b/hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp
@ -375,7 +375,7 @@ float MgmLIS3MDLHandler::getSensitivityFactor(MGMLIS3MDL::Sensitivies sens) {

 ReturnValue_t MgmLIS3MDLHandler::enableTemperatureSensor(const uint8_t *commandData,
                                                         size_t commandDataLen) {
-  if(commandData == nullptr) {
+  if (commandData == nullptr) {
    return INVALID_COMMAND_PARAMETER;
  }
  triggerEvent(CHANGE_OF_SETUP_PARAMETER);
--- a/hal/src/fsfw_hal/linux/CMakeLists.txt
+++ b/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)
--- a/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.cpp
+++ b/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,
@ -276,7 +280,7 @@ ReturnValue_t LinuxLibgpioIF::driveGpio(gpioId_t gpioId, GpiodRegularBase& regul
  return RETURN_OK;
 }

-ReturnValue_t LinuxLibgpioIF::readGpio(gpioId_t gpioId, int* gpioState) {
+ReturnValue_t LinuxLibgpioIF::readGpio(gpioId_t gpioId, gpio::Levels& gpioState) {
  gpioMapIter = gpioMap.find(gpioId);
  if (gpioMapIter == gpioMap.end()) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@ -295,7 +299,10 @@ ReturnValue_t LinuxLibgpioIF::readGpio(gpioId_t gpioId, int* gpioState) {
    if (regularGpio == nullptr) {
      return GPIO_TYPE_FAILURE;
    }
-    *gpioState = gpiod_line_get_value(regularGpio->lineHandle);
+    gpioState = static_cast<gpio::Levels>(gpiod_line_get_value(regularGpio->lineHandle));
+    if (gpioState == gpio::Levels::FAILED) {
+      return GPIO_GET_VALUE_FAILED;
+    }
  } else {
    auto gpioCallback = dynamic_cast<GpioCallback*>(gpioMapIter->second);
    if (gpioCallback->callback == nullptr) {
--- a/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+++ b/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
@ -29,14 +29,18 @@ 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);
+  // Will be returned if getting the line value failed. Error type will be set to errno in this case
+  static constexpr ReturnValue_t GPIO_GET_VALUE_FAILED =
+      HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 7);
  LinuxLibgpioIF(object_id_t objectId);
  virtual ~LinuxLibgpioIF();

  ReturnValue_t addGpios(GpioCookie* gpioCookie) override;
  ReturnValue_t pullHigh(gpioId_t gpioId) override;
  ReturnValue_t pullLow(gpioId_t gpioId) override;
-  ReturnValue_t readGpio(gpioId_t gpioId, int* gpioState) override;
+  ReturnValue_t readGpio(gpioId_t gpioId, gpio::Levels& gpioState) override;

 private:
  static const size_t MAX_CHIPNAME_LENGTH = 11;
--- a/hal/src/fsfw_hal/linux/i2c/I2cComIF.cpp
+++ b/hal/src/fsfw_hal/linux/i2c/I2cComIF.cpp
@ -170,18 +170,20 @@ ReturnValue_t I2cComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLe

  int readLen = read(fd, replyBuffer, requestLen);
  if (readLen != static_cast<int>(requestLen)) {
-#if FSFW_VERBOSE_LEVEL >= 1 and FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "I2cComIF::requestReceiveMessage: Reading from I2C "
-               << "device failed with error code " << errno << ". Description"
-               << " of error: " << strerror(errno) << std::endl;
-    sif::error << "I2cComIF::requestReceiveMessage: Read only " << readLen << " from " << requestLen
-               << " bytes" << std::endl;
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    if (readLen < 0) {
+      sif::warning << "I2cComIF::requestReceiveMessage: Reading from I2C "
+                   << "device failed with error code " << errno << " | " << strerror(errno)
+                   << std::endl;
+    } else {
+      sif::warning << "I2cComIF::requestReceiveMessage: Read only " << readLen << " from "
+                   << requestLen << " bytes" << std::endl;
+    }
+#else
+#endif
 #endif
    i2cDeviceMapIter->second.replyLen = 0;
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::debug << "I2cComIF::requestReceiveMessage: Read " << readLen << " of " << requestLen
-               << " bytes" << std::endl;
-#endif
    return HasReturnvaluesIF::RETURN_FAILED;
  }

--- a/hal/src/fsfw_hal/linux/spi/SpiCookie.cpp
+++ b/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)
--- a/hal/src/fsfw_hal/linux/uart/UartComIF.cpp
+++ b/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;
--- a/src/fsfw/cfdp/pdu/HeaderSerializer.h
+++ b/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;
--- a/src/fsfw/container/FixedArrayList.h
+++ b/src/fsfw/container/FixedArrayList.h
@ -9,7 +9,7 @@
 */
 template <typename T, size_t MAX_SIZE, typename count_t = uint8_t>
 class FixedArrayList : public ArrayList<T, count_t> {
-#if !defined(_MSC_VER)
+#if !defined(_MSC_VER) && !defined(__clang__)
  static_assert(MAX_SIZE <= (std::pow(2, sizeof(count_t) * 8) - 1),
                "count_t is not large enough to hold MAX_SIZE");
 #endif
--- a/src/fsfw/container/HybridIterator.h
+++ b/src/fsfw/container/HybridIterator.h
@ -10,7 +10,7 @@ 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;
    }
--- a/src/fsfw/controller/ControllerBase.h
+++ b/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 getMode(Mode_t *mode, Submode_t *submode);
-  virtual void setToExternalControl();
+  virtual void startTransition(Mode_t mode, Submode_t submode) override;
+  virtual void getMode(Mode_t *mode, Submode_t *submode) override;
+  virtual void setToExternalControl() override;
  virtual void announceMode(bool recursive);
  /** HK helpers */
  virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
--- a/src/fsfw/datapool/PoolDataSetBase.h
+++ b/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,
--- a/src/fsfw/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/src/fsfw/datapoollocal/LocalPoolDataSetBase.cpp
@ -94,13 +94,14 @@ ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(
  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
  const uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount) / 8.0);
  uint8_t *validityPtr = nullptr;
-#ifdef _MSC_VER
-  /* Use a std::vector here because MSVC will (rightly) not create a fixed size array
-  with a non constant size specifier */
-  std::vector<uint8_t> validityMask(validityMaskSize);
+#if defined(_MSC_VER) || defined(__clang__)
+  // Use a std::vector here because MSVC will (rightly) not create a fixed size array
+  // with a non constant size specifier. The Apple compiler (LLVM) will not accept
+  // the  initialization of a variable sized array
+  std::vector<uint8_t> validityMask(validityMaskSize, 0);
  validityPtr = validityMask.data();
 #else
-  uint8_t validityMask[validityMaskSize] = {0};
+  uint8_t validityMask[validityMaskSize] = {};
  validityPtr = validityMask;
 #endif
  uint8_t validBufferIndex = 0;
--- a/src/fsfw/datapoollocal/LocalPoolObjectBase.h
+++ b/src/fsfw/datapoollocal/LocalPoolObjectBase.h
@ -23,8 +23,8 @@ class LocalPoolObjectBase : public PoolVariableIF, public HasReturnvaluesIF, pub
  LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId, DataSetIF* dataSet = nullptr,
                      pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);

-  void setReadWriteMode(pool_rwm_t newReadWriteMode);
-  pool_rwm_t getReadWriteMode() const;
+  void setReadWriteMode(pool_rwm_t newReadWriteMode) override;
+  pool_rwm_t getReadWriteMode() const override;

  bool isValid() const override;
  void setValid(bool valid) override;
--- a/src/fsfw/devicehandlers/DeviceHandlerBase.cpp
+++ b/src/fsfw/devicehandlers/DeviceHandlerBase.cpp
@ -243,16 +243,27 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 }

 void DeviceHandlerBase::decrementDeviceReplyMap() {
+  bool timedOut = false;
  for (std::pair<const DeviceCommandId_t, DeviceReplyInfo>& replyPair : deviceReplyMap) {
-    if (replyPair.second.delayCycles != 0) {
+    if (replyPair.second.countdown != nullptr && replyPair.second.active) {
+      if (replyPair.second.countdown->hasTimedOut()) {
+        timedOut = true;
+      }
+    }
+    if (replyPair.second.delayCycles != 0 && replyPair.second.countdown == nullptr) {
      replyPair.second.delayCycles--;
      if (replyPair.second.delayCycles == 0) {
        if (replyPair.second.periodic) {
          replyPair.second.delayCycles = replyPair.second.maxDelayCycles;
        }
+        timedOut = true;
+      }
+    }
+    if (timedOut) {
      replyToReply(replyPair.first, replyPair.second, TIMEOUT);
      missedReply(replyPair.first);
-      }
+      timedOut = false;
+      replyPair.second.active = false;
    }
  }
 }
@ -416,20 +427,22 @@ ReturnValue_t DeviceHandlerBase::isModeCombinationValid(Mode_t mode, Submode_t s

 ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(
    DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles, LocalPoolDataSetBase* replyDataSet,
-    size_t replyLen, bool periodic, bool hasDifferentReplyId, DeviceCommandId_t replyId) {
+    size_t replyLen, bool periodic, bool hasDifferentReplyId, DeviceCommandId_t replyId,
+    Countdown* countdown) {
  // No need to check, as we may try to insert multiple times.
  insertInCommandMap(deviceCommand, hasDifferentReplyId, replyId);
  if (hasDifferentReplyId) {
-    return insertInReplyMap(replyId, maxDelayCycles, replyDataSet, replyLen, periodic);
+    return insertInReplyMap(replyId, maxDelayCycles, replyDataSet, replyLen, periodic, countdown);
  } else {
-    return insertInReplyMap(deviceCommand, maxDelayCycles, replyDataSet, replyLen, periodic);
+    return insertInReplyMap(deviceCommand, maxDelayCycles, replyDataSet, replyLen, periodic,
+                            countdown);
  }
 }

 ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
                                                  uint16_t maxDelayCycles,
                                                  LocalPoolDataSetBase* dataSet, size_t replyLen,
-                                                  bool periodic) {
+                                                  bool periodic, Countdown* countdown) {
  DeviceReplyInfo info;
  info.maxDelayCycles = maxDelayCycles;
  info.periodic = periodic;
@ -437,6 +450,10 @@ ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
  info.replyLen = replyLen;
  info.dataSet = dataSet;
  info.command = deviceCommandMap.end();
+  info.countdown = countdown;
+  if (info.periodic) {
+    info.active = true;
+  }
  auto resultPair = deviceReplyMap.emplace(replyId, info);
  if (resultPair.second) {
    return RETURN_OK;
@ -472,7 +489,8 @@ size_t DeviceHandlerBase::getNextReplyLength(DeviceCommandId_t commandId) {
  }
  DeviceReplyIter iter = deviceReplyMap.find(replyId);
  if (iter != deviceReplyMap.end()) {
-    if (iter->second.delayCycles != 0) {
+    if ((iter->second.delayCycles != 0 && iter->second.countdown == nullptr) ||
+        (iter->second.active && iter->second.countdown != nullptr)) {
      return iter->second.replyLen;
    }
  }
@ -816,17 +834,18 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData, DeviceCommandId

  DeviceReplyInfo* info = &(iter->second);

-  if (info->delayCycles != 0) {
+  if ((info->delayCycles != 0 && info->countdown == nullptr) ||
+      (info->active && info->countdown != nullptr)) {
    result = interpretDeviceReply(foundId, receivedData);

    if (result == IGNORE_REPLY_DATA) {
      return;
    }

-    if (info->periodic) {
-      info->delayCycles = info->maxDelayCycles;
-    } else {
-      info->delayCycles = 0;
+    if (info->active && info->countdown != nullptr) {
+      disableTimeoutControlledReply(info);
+    } else if (info->delayCycles != 0) {
+      disableDelayCyclesControlledReply(info);
    }

    if (result != RETURN_OK) {
@ -845,6 +864,24 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData, DeviceCommandId
  }
 }

+void DeviceHandlerBase::disableTimeoutControlledReply(DeviceReplyInfo* info) {
+  if (info->periodic) {
+    info->countdown->resetTimer();
+  } else {
+    info->active = false;
+    info->countdown->timeOut();
+  }
+}
+
+void DeviceHandlerBase::disableDelayCyclesControlledReply(DeviceReplyInfo* info) {
+  if (info->periodic) {
+    info->delayCycles = info->maxDelayCycles;
+  } else {
+    info->delayCycles = 0;
+    info->active = false;
+  }
+}
+
 ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress, uint8_t** data,
                                                size_t* len) {
  size_t lenTmp;
@ -970,6 +1007,10 @@ ReturnValue_t DeviceHandlerBase::enableReplyInReplyMap(DeviceCommandMap::iterato
    info->delayCycles = info->maxDelayCycles;
    info->command = command;
    command->second.expectedReplies = expectedReplies;
+    if (info->countdown != nullptr) {
+      info->countdown->resetTimer();
+    }
+    info->active = true;
    return RETURN_OK;
  } else {
    return NO_REPLY_EXPECTED;
@ -1204,7 +1245,8 @@ void DeviceHandlerBase::setParentQueue(MessageQueueId_t parentQueueId) {
 bool DeviceHandlerBase::isAwaitingReply() {
  std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter;
  for (iter = deviceReplyMap.begin(); iter != deviceReplyMap.end(); ++iter) {
-    if (iter->second.delayCycles != 0) {
+    if ((iter->second.delayCycles != 0 && iter->second.countdown == nullptr) ||
+        (iter->second.active && iter->second.countdown != nullptr)) {
      return true;
    }
  }
@ -1360,6 +1402,9 @@ uint8_t DeviceHandlerBase::getReplyDelayCycles(DeviceCommandId_t deviceCommand)
  if (iter == deviceReplyMap.end()) {
    return 0;
  }
+  else if (iter->second.countdown != nullptr) {
+    return 0;
+  }
  return iter->second.delayCycles;
 }

--- a/src/fsfw/devicehandlers/DeviceHandlerBase.h
+++ b/src/fsfw/devicehandlers/DeviceHandlerBase.h
@ -166,7 +166,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
@ -176,7 +176,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.
@ -451,6 +451,9 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   * by the device repeatedly without request) or not. Default is aperiodic (0).
   * Please note that periodic replies are disabled by default. You can enable them with
   * #updatePeriodicReply
+   * @param countdown Instead of using maxDelayCycles to timeout a device reply it is also possible
+   *                  to provide a pointer to a Countdown object which will signal the timeout
+   *                  when expired
   * @return	- @c RETURN_OK when the command was successfully inserted,
   *          - @c RETURN_FAILED else.
   */
@ -458,7 +461,8 @@ class DeviceHandlerBase : public DeviceHandlerIF,
                                           LocalPoolDataSetBase *replyDataSet = nullptr,
                                           size_t replyLen = 0, bool periodic = false,
                                           bool hasDifferentReplyId = false,
-                                           DeviceCommandId_t replyId = 0);
+                                           DeviceCommandId_t replyId = 0,
+                                           Countdown *countdown = nullptr);
  /**
   * @brief 	This is a helper method to insert replies in the reply map.
   * @param deviceCommand	Identifier of the reply to add.
@ -468,12 +472,15 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   * by the device repeatedly without request) or not. Default is aperiodic (0).
   * Please note that periodic replies are disabled by default. You can enable them with
   * #updatePeriodicReply
+   * @param countdown Instead of using maxDelayCycles to timeout a device reply it is also possible
+   *                  to provide a pointer to a Countdown object which will signal the timeout
+   *                  when expired
   * @return	- @c RETURN_OK when the command was successfully inserted,
   *          - @c RETURN_FAILED else.
   */
  ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles,
                                 LocalPoolDataSetBase *dataSet = nullptr, size_t replyLen = 0,
-                                 bool periodic = false);
+                                 bool periodic = false, Countdown *countdown = nullptr);

  /**
   * @brief   A simple command to add a command to the commandList.
@ -792,6 +799,11 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    LocalPoolDataSetBase *dataSet = nullptr;
    //! The command that expects this reply.
    DeviceCommandMap::iterator command;
+    //! Instead of using delayCycles to specify the maximum time to wait for the device reply, it
+    //! is also possible specify a countdown
+    Countdown* countdown = nullptr;
+    //! will be set to true when reply is enabled
+    bool active = false;
  };

  using DeviceReplyMap = std::map<DeviceCommandId_t, DeviceReplyInfo>;
@ -1068,11 +1080,12 @@ 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.
@ -1253,6 +1266,17 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   */
  void doGetRead(void);

+  /**
+   * @brief Handles disabling of replies which use a timeout to detect missed replies.
+   */
+  void disableTimeoutControlledReply(DeviceReplyInfo* info);
+
+  /**
+   * @brief Handles disabling of replies which use a number of maximum delay cycles to detect
+   *        missed replies.
+   */
+  void disableDelayCyclesControlledReply(DeviceReplyInfo* info);
+
  /**
   * Retrive data from the #IPCStore.
   *
--- a/src/fsfw/globalfunctions/DleParser.cpp
+++ b/src/fsfw/globalfunctions/DleParser.cpp
@ -187,7 +187,7 @@ void DleParser::defaultErrorHandler(ErrorTypes err, ErrorInfo ctx) {
    case (ErrorTypes::ENCODED_BUF_TOO_SMALL):
    case (ErrorTypes::DECODING_BUF_TOO_SMALL): {
      char opt[64];
-      snprintf(opt, sizeof(opt), ": Too small for packet with length %d", ctx.len);
+      snprintf(opt, sizeof(opt), ": Too small for packet with length %zu", ctx.len);
      if (err == ErrorTypes::ENCODED_BUF_TOO_SMALL) {
        errorPrinter("Encoded buf too small", opt);
      } else {
--- a/src/fsfw/globalfunctions/matching/MatchTree.h
+++ b/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()) {
--- a/src/fsfw/globalfunctions/matching/RangeMatcher.h
+++ b/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 {
--- a/src/fsfw/monitoring/MonitoringMessageContent.h
+++ b/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();
--- a/src/fsfw/objectmanager/SystemObject.h
+++ b/src/fsfw/objectmanager/SystemObject.h
@ -48,9 +48,10 @@ 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_ */
--- a/src/fsfw/osal/common/UdpTcPollingTask.cpp
+++ b/src/fsfw/osal/common/UdpTcPollingTask.cpp
@ -16,11 +16,13 @@
 //! Debugging preprocessor define.
 #define FSFW_UDP_RECV_WIRETAPPING_ENABLED 0

+const timeval UdpTcPollingTask::DEFAULT_TIMEOUT = {0, 500000};
+
 UdpTcPollingTask::UdpTcPollingTask(object_id_t objectId, object_id_t tmtcUdpBridge,
                                   size_t maxRecvSize, double timeoutSeconds)
    : SystemObject(objectId), tmtcBridgeId(tmtcUdpBridge) {
-  if (frameSize > 0) {
-    this->frameSize = frameSize;
+  if (maxRecvSize > 0) {
+    this->frameSize = maxRecvSize;
  } else {
    this->frameSize = DEFAULT_MAX_RECV_SIZE;
  }
@ -31,22 +33,20 @@ UdpTcPollingTask::UdpTcPollingTask(object_id_t objectId, object_id_t tmtcUdpBrid
  receptionBuffer.resize(this->frameSize);

  if (timeoutSeconds == -1) {
-    receptionTimeout = DEFAULT_TIMEOUT;
+    receptionTimeout = UdpTcPollingTask::DEFAULT_TIMEOUT;
  } else {
    receptionTimeout = timevalOperations::toTimeval(timeoutSeconds);
  }
 }

-UdpTcPollingTask::~UdpTcPollingTask() {}
-
-ReturnValue_t UdpTcPollingTask::performOperation(uint8_t opCode) {
+[[noreturn]] ReturnValue_t UdpTcPollingTask::performOperation(uint8_t opCode) {
  /* Sender Address is cached here. */
-  struct sockaddr senderAddress;
+  struct sockaddr senderAddress {};
  socklen_t senderAddressSize = sizeof(senderAddress);

  /* Poll for new UDP datagrams in permanent loop. */
  while (true) {
-    int bytesReceived =
+    ssize_t bytesReceived =
        recvfrom(this->serverSocket, reinterpret_cast<char*>(receptionBuffer.data()), frameSize,
                 receptionFlags, &senderAddress, &senderAddressSize);
    if (bytesReceived == SOCKET_ERROR) {
@ -70,7 +70,6 @@ ReturnValue_t UdpTcPollingTask::performOperation(uint8_t opCode) {
    }
    tmtcBridge->checkAndSetClientAddress(senderAddress);
  }
-  return HasReturnvaluesIF::RETURN_OK;
 }

 ReturnValue_t UdpTcPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
@ -155,7 +154,7 @@ void UdpTcPollingTask::setTimeout(double timeoutSeconds) {
 #endif
  }
 #elif defined(PLATFORM_UNIX)
-  timeval tval;
+  timeval tval{};
  tval = timevalOperations::toTimeval(timeoutSeconds);
  int result = setsockopt(serverSocket, SOL_SOCKET, SO_RCVTIMEO, &tval, sizeof(receptionTimeout));
  if (result == -1) {
--- a/src/fsfw/osal/common/UdpTcPollingTask.h
+++ b/src/fsfw/osal/common/UdpTcPollingTask.h
@ -21,11 +21,11 @@ class UdpTcPollingTask : public TcpIpBase, public SystemObject, public Executabl
 public:
  static constexpr size_t DEFAULT_MAX_RECV_SIZE = 1500;
  //! 0.5  default milliseconds timeout for now.
-  static constexpr timeval DEFAULT_TIMEOUT = {0, 500};
+  static const timeval DEFAULT_TIMEOUT;

  UdpTcPollingTask(object_id_t objectId, object_id_t tmtcUdpBridge, size_t maxRecvSize = 0,
                   double timeoutSeconds = -1);
-  virtual ~UdpTcPollingTask();
+  ~UdpTcPollingTask() override = default;

  /**
   * Turn on optional timeout for UDP polling. In the default mode,
@ -34,9 +34,9 @@ class UdpTcPollingTask : public TcpIpBase, public SystemObject, public Executabl
   */
  void setTimeout(double timeoutSeconds);

-  virtual ReturnValue_t performOperation(uint8_t opCode) override;
-  virtual ReturnValue_t initialize() override;
-  virtual ReturnValue_t initializeAfterTaskCreation() override;
+  [[noreturn]] ReturnValue_t performOperation(uint8_t opCode) override;
+  ReturnValue_t initialize() override;
+  ReturnValue_t initializeAfterTaskCreation() override;

 protected:
  StorageManagerIF* tcStore = nullptr;
@ -51,7 +51,7 @@ class UdpTcPollingTask : public TcpIpBase, public SystemObject, public Executabl
  std::vector<uint8_t> receptionBuffer;

  size_t frameSize = 0;
-  timeval receptionTimeout;
+  timeval receptionTimeout{};

  ReturnValue_t handleSuccessfullTcRead(size_t bytesRead);
 };
--- a/src/fsfw/osal/common/UdpTmTcBridge.cpp
+++ b/src/fsfw/osal/common/UdpTmTcBridge.cpp
@ -20,13 +20,13 @@
 const std::string UdpTmTcBridge::DEFAULT_SERVER_PORT = tcpip::DEFAULT_SERVER_PORT;

 UdpTmTcBridge::UdpTmTcBridge(object_id_t objectId, object_id_t tcDestination,
-                             std::string udpServerPort, object_id_t tmStoreId,
+                             const std::string &udpServerPort_, object_id_t tmStoreId,
                             object_id_t tcStoreId)
    : TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
-  if (udpServerPort == "") {
-    this->udpServerPort = DEFAULT_SERVER_PORT;
+  if (udpServerPort_.empty()) {
+    udpServerPort = DEFAULT_SERVER_PORT;
  } else {
-    this->udpServerPort = udpServerPort;
+    udpServerPort = udpServerPort_;
  }

  mutex = MutexFactory::instance()->createMutex();
@ -117,7 +117,7 @@ ReturnValue_t UdpTmTcBridge::sendTm(const uint8_t *data, size_t dataLen) {
  tcpip::printAddress(&clientAddress);
 #endif

-  int bytesSent = sendto(serverSocket, reinterpret_cast<const char *>(data), dataLen, flags,
+  ssize_t bytesSent = sendto(serverSocket, reinterpret_cast<const char *>(data), dataLen, flags,
                             &clientAddress, clientAddressLen);
  if (bytesSent == SOCKET_ERROR) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@ -150,7 +150,7 @@ void UdpTmTcBridge::checkAndSetClientAddress(sockaddr &newAddress) {
  clientAddressLen = sizeof(clientAddress);
 }

-void UdpTmTcBridge::setMutexProperties(MutexIF::TimeoutType timeoutType, dur_millis_t timeoutMs) {
-  this->timeoutType = timeoutType;
-  this->mutexTimeoutMs = timeoutMs;
+void UdpTmTcBridge::setMutexProperties(MutexIF::TimeoutType timeoutType_, dur_millis_t timeoutMs) {
+  timeoutType = timeoutType_;
+  mutexTimeoutMs = timeoutMs;
 }
--- a/src/fsfw/osal/common/UdpTmTcBridge.h
+++ b/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 = "",
-                object_id_t tmStoreId = objects::TM_STORE,
+  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.
--- a/src/fsfw/osal/freertos/Clock.cpp
+++ b/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) {
--- a/src/fsfw/osal/host/CMakeLists.txt
+++ b/src/fsfw/osal/host/CMakeLists.txt
@ -1,5 +1,4 @@
-target_sources(${LIB_FSFW_NAME} 
-	PRIVATE 
+target_sources(${LIB_FSFW_NAME} PRIVATE
  Clock.cpp
  FixedTimeslotTask.cpp
  MessageQueue.cpp
@ -16,9 +15,13 @@ target_sources(${LIB_FSFW_NAME}
 if(UNIX)
  find_package(Threads REQUIRED)

-	target_link_libraries(${LIB_FSFW_NAME} 
-	PRIVATE
-		rt
+  target_link_libraries(${LIB_FSFW_NAME} PRIVATE
    ${CMAKE_THREAD_LIBS_INIT}
  )
+  if(NOT APPLE)
+    target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+      rt
+      )
+  endif()
+
 endif()
--- a/src/fsfw/osal/host/Clock.cpp
+++ b/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;
--- a/src/fsfw/osal/linux/CMakeLists.txt
+++ b/src/fsfw/osal/linux/CMakeLists.txt
@ -14,16 +14,16 @@ target_sources(${LIB_FSFW_NAME} PRIVATE
  TaskFactory.cpp
  tcpipHelpers.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}
+  )
+
+if(NOT APPLE)
+  target_link_libraries(${LIB_FSFW_NAME} PUBLIC
    rt
-)
-
-target_link_libraries(${LIB_FSFW_NAME} INTERFACE
-    ${CMAKE_THREAD_LIBS_INIT}
-)
-
+  )
+endif()
--- a/src/fsfw/osal/linux/Clock.cpp
+++ b/src/fsfw/osal/linux/Clock.cpp
@ -6,16 +6,11 @@
 #include <time.h>
 #include <unistd.h>

-#include <cstring>
 #include <fstream>

+#include "fsfw/ipc/MutexGuard.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"

-uint16_t Clock::leapSeconds = 0;
-MutexIF* Clock::timeMutex = NULL;
-
-void handleClockError(const char* func);
-
 uint32_t Clock::getTicksPerSecond(void) {
  uint32_t ticks = sysconf(_SC_CLK_TCK);
  return ticks;
@ -30,7 +25,7 @@ ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {

  int status = clock_settime(CLOCK_REALTIME, &timeUnix);
  if (status != 0) {
-    handleClockError("setClock");
+    // TODO errno
    return HasReturnvaluesIF::RETURN_FAILED;
  }
  return HasReturnvaluesIF::RETURN_OK;
@ -42,7 +37,7 @@ ReturnValue_t Clock::setClock(const timeval* time) {
  timeUnix.tv_nsec = (__syscall_slong_t)time->tv_usec * 1000;
  int status = clock_settime(CLOCK_REALTIME, &timeUnix);
  if (status != 0) {
-    handleClockError("setClock");
+    // TODO errno
    return HasReturnvaluesIF::RETURN_FAILED;
  }
  return HasReturnvaluesIF::RETURN_OK;
@ -52,7 +47,6 @@ ReturnValue_t Clock::getClock_timeval(timeval* time) {
  timespec timeUnix;
  int status = clock_gettime(CLOCK_REALTIME, &timeUnix);
  if (status != 0) {
-    handleClockError("getClock_timeval");
    return HasReturnvaluesIF::RETURN_FAILED;
  }
  time->tv_sec = timeUnix.tv_sec;
@ -121,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;
@ -155,14 +155,3 @@ ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
  *JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24. / 3600.;
  return HasReturnvaluesIF::RETURN_OK;
 }
-
-void handleClockError(const char* func) {
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::warning << "Clock::" << func << ": Failed with code " << errno << ": " << strerror(errno)
-               << std::endl;
-#else
-  sif::printWarning("Clock::%s: Failed with code %d: %s\n", func, errno, strerror(errno));
-#endif
-#endif
-}
--- a/src/fsfw/osal/rtems/Clock.cpp
+++ b/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);
--- a/src/fsfw/power/Fuse.h
+++ b/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;
--- a/src/fsfw/pus/Service3Housekeeping.h
+++ b/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 {
--- a/src/fsfw/subsystem/Subsystem.cpp
+++ b/src/fsfw/subsystem/Subsystem.cpp
@ -307,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;
@ -350,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;
@ -458,6 +467,7 @@ ReturnValue_t Subsystem::initialize() {
  }

  mode = initialMode;
+  submode = initSubmode;

  return RETURN_OK;
 }
@ -595,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;
--- a/src/fsfw/subsystem/Subsystem.h
+++ b/src/fsfw/subsystem/Subsystem.h
@ -10,6 +10,28 @@
 #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   This class extends the SubsystemBase to perform the management of mode tables
 *          and mode sequences
@ -48,13 +70,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;

@ -93,6 +117,7 @@ class Subsystem : public SubsystemBase, public HasModeSequenceIF {
  Submode_t targetSubmode;

  Mode_t initialMode = 0;
+  Submode_t initSubmode = SUBMODE_NONE;

  HybridIterator<ModeListEntry> currentSequenceIterator;

@ -130,18 +155,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);

--- a/src/fsfw/subsystem/SubsystemBase.h
+++ b/src/fsfw/subsystem/SubsystemBase.h
@ -137,9 +137,9 @@ class SubsystemBase : public SystemObject,

  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();
 };
--- a/src/fsfw/timemanager/CCSDSTime.cpp
+++ b/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++) {
-    secs += *from << ((nCoarse * 8 - 8) * (1 + count));
+  for (int count = nCoarse; count > 0; count--) {
+    secs += *from << (count * 8 - 8);
    from++;
  }
-  for (int count = 0; count < nFine; count++) {
-    subSeconds += *from << ((nFine * 8 - 8) * (1 + count));
+  for (int count = nFine; count > 0; count--) {
+    subSeconds += *from << (count * 8 - 8);
    from++;
  }
  // Move to POSIX epoch.
--- a/src/fsfw/timemanager/CCSDSTime.h
+++ b/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();
-  virtual ~CCSDSTime();
+  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_ */
--- a/src/fsfw/timemanager/Clock.h
+++ b/src/fsfw/timemanager/Clock.h
@ -173,6 +173,7 @@ class Clock {

  static MutexIF *timeMutex;
  static uint16_t leapSeconds;
+  static bool leapSecondsSet;
 };

 #endif /* FSFW_TIMEMANAGER_CLOCK_H_ */
--- a/src/fsfw/timemanager/ClockCommon.cpp
+++ b/src/fsfw/timemanager/ClockCommon.cpp
@ -3,6 +3,10 @@
 #include "fsfw/ipc/MutexGuard.h"
 #include "fsfw/timemanager/Clock.h"

+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);
@ -29,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_) {
-  if (timeMutex == nullptr) {
+  if (not leapSecondsSet) {
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  if (checkOrCreateClockMutex() != HasReturnvaluesIF::RETURN_OK) {
    return HasReturnvaluesIF::RETURN_FAILED;
  }
  MutexGuard helper(timeMutex);
@ -46,6 +54,16 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {

 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;
--- a/src/fsfw/timemanager/Countdown.cpp
+++ b/src/fsfw/timemanager/Countdown.cpp
@ -1,7 +1,12 @@
 #include "fsfw/timemanager/Countdown.h"

-Countdown::Countdown(uint32_t initialTimeout) : timeout(initialTimeout) {
+Countdown::Countdown(uint32_t initialTimeout, bool startImmediately) : timeout(initialTimeout) {
+  if (startImmediately) {
    setTimeout(initialTimeout);
+  }
+  else {
+    timeout = initialTimeout;
+  }
 }

 Countdown::~Countdown() {}
--- a/src/fsfw/timemanager/Countdown.h
+++ b/src/fsfw/timemanager/Countdown.h
@ -26,8 +26,9 @@ class Countdown {
   * Otherwise a call to hasTimedOut might return True.
   *
   * @param initialTimeout Countdown duration in milliseconds
+   * @param startImmediately  Set to false if countdown should not be started immediately
   */
-  Countdown(uint32_t initialTimeout = 0);
+  Countdown(uint32_t initialTimeout = 0, bool startImmediately = true);
  ~Countdown();
  /**
   * Call to set a new countdown duration.
--- a/src/fsfw/tmtcpacket/SpacePacket.cpp
+++ b/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)) {
-    memcpy(&this->localData.byteStream, p_Data, packet_size);
+  if (packet_size <= sizeof(this->localData)) {
+    memcpy(this->localData.byteStream, p_Data, packet_size);
    return true;
  } else {
    return false;
--- a/src/fsfw/tmtcservices/CommandingServiceBase.h
+++ b/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
--- a/src/fsfw/tmtcservices/SourceSequenceCounter.h
+++ b/src/fsfw/tmtcservices/SourceSequenceCounter.h
@ -8,7 +8,7 @@ class SourceSequenceCounter {
  uint16_t sequenceCount;

 public:
-  SourceSequenceCounter() : sequenceCount(0) {}
+  SourceSequenceCounter(uint16_t initialSequenceCount = 0) : sequenceCount(initialSequenceCount) {}
  void increment() {
    sequenceCount = (sequenceCount + 1) % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
  }
@ -31,6 +31,7 @@ class SourceSequenceCounter {
    sequenceCount = newCount;
    return *this;
  }
+
  operator uint16_t() { return this->get(); }
 };

--- a/tests/src/fsfw_tests/unit/globalfunctions/CMakeLists.txt
+++ b/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
 )
--- a/tests/src/fsfw_tests/unit/globalfunctions/testTimevalOperations.cpp
+++ b/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);
+  }
+}
--- a/tests/src/fsfw_tests/unit/osal/CMakeLists.txt
+++ b/tests/src/fsfw_tests/unit/osal/CMakeLists.txt
@ -1,4 +1,5 @@
 target_sources(${FSFW_TEST_TGT} PRIVATE
 	TestMessageQueue.cpp
 	TestSemaphore.cpp
+	TestClock.cpp
 )
--- a/tests/src/fsfw_tests/unit/osal/TestClock.cpp
+++ b/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));
+  }
+}
--- a/tests/src/fsfw_tests/unit/timemanager/TestCCSDSTime.cpp
+++ b/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);
  }
 }
Author	SHA1	Message	Date
Jakob Meier	b0b75b85a9	Merge branch 'meier/sequenceCount' into meier/develop	2022-05-11 16:54:06 +02:00
Jakob Meier	bc994595da	sequence count init value	2022-05-11 14:31:49 +02:00
Robin Müller	de2d4da161	Merge branch 'eive/develop' into meier/develop	2022-05-05 12:28:34 +02:00
Jakob Meier	19bd26d998	Merge branch 'meier/develop' of https://egit.irs.uni-stuttgart.de/eive/fsfw into meier/develop	2022-05-05 09:15:23 +02:00
Jakob.Meier	80cb0e682f	Merge pull request 'Update GPIO API' (#76 ) from mueller/update-gpio-api into eive/develop Reviewed-on: #76	2022-05-04 14:03:28 +02:00
Cleanroom Laptop L15	8ee26f81f9	dedicated returnvalue for line get failure	2022-05-04 10:36:32 +02:00
Cleanroom Laptop L15	3556eca8e8	error check on line getter	2022-05-04 10:33:55 +02:00
Cleanroom Laptop L15	a9041b84a3	update read gpio API	2022-05-04 10:27:20 +02:00
Jakob.Meier	83d9dbc052	Merge pull request 'improved i2c error printout' (#75 ) from mueller/i2c-error-handling-improvement into eive/develop Reviewed-on: #75	2022-05-03 16:50:48 +02:00
Robin Mueller	2220120d54	improved i2c error printout	2022-05-03 16:43:15 +02:00
Robin Mueller	15eb22f9ee	Merge remote-tracking branch 'origin/eive/develop' into meier/develop	2022-05-03 13:03:44 +02:00
Robin Mueller	7f6c8b8b12	Merge remote-tracking branch 'upstream/development' into eive/develop	2022-05-02 16:15:27 +02:00
Robin Müller	1a07864a5f	Merge pull request 'CCSDS Time CUC Tests' (#593 ) from gaisser/fsfw:gaisser_cuc_tests into development Reviewed-on: fsfw/fsfw#593	2022-05-02 15:29:48 +02:00
Steffen Gaisser	3e9d6bdbb9	Merge branch 'development' into gaisser_cuc_tests	2022-05-02 15:24:32 +02:00
Steffen Gaisser	c295539c79	Merge pull request 'Fixes to allow compilation on MacOS' (#611 ) from mueller/mac-os into development Reviewed-on: fsfw/fsfw#611	2022-05-02 15:22:19 +02:00
Robin Müller	cddf16f941	Merge branch 'development' into mueller/mac-os	2022-05-02 15:15:53 +02:00
Robin Müller	a3dee05fe3	Merge pull request 'space packet bug fix' (#607 ) from meier/spacePacketBugFix into development Reviewed-on: fsfw/fsfw#607	2022-05-02 15:15:28 +02:00
Steffen Gaisser	8edf4c3c8d	Merge branch 'development' into meier/spacePacketBugFix	2022-05-02 15:10:32 +02:00
Steffen Gaisser	8cc94a55ab	Merge pull request 'Bump Catch2 dependency & Catch2 pre-installed for CI/CD' (#605 ) from mueller/bump-catch2 into development Reviewed-on: fsfw/fsfw#605	2022-05-02 15:03:08 +02:00
Robin Müller	daffb6b666	Merge branch 'development' into gaisser_cuc_tests	2022-05-02 14:45:33 +02:00
Jakob Meier	789668ae50	Merge branch 'eive/develop' into meier/develop	2022-05-02 14:45:23 +02:00
Robin Müller	7cfb1e6076	Merge branch 'development' into mueller/bump-catch2	2022-05-02 14:36:44 +02:00
Steffen Gaisser	cc36baff78	Merge pull request 'Hotfix CMake & ETL' (#604 ) from mueller/hotfix-etl into development Reviewed-on: fsfw/fsfw#604	2022-05-02 14:36:29 +02:00
Robin Müller	4c65109ac0	Merge branch 'development' into meier/spacePacketBugFix	2022-05-02 14:36:24 +02:00
Robin Müller	861bd15eda	Merge branch 'development' into mueller/hotfix-etl	2022-05-02 14:20:40 +02:00
Steffen Gaisser	7b979eadff	Merge pull request 'fix compiler warnings and auto-formatting' (#598 ) from eive/fsfw:mueller/compiler-warning-fixes-upstream-2 into development Reviewed-on: fsfw/fsfw#598	2022-05-02 14:17:00 +02:00
Steffen Gaisser	16714ceb40	Merge branch 'development' into gaisser_cuc_tests	2022-05-02 13:58:17 +02:00
Robin Mueller	fea301bcc9	Merge remote-tracking branch 'origin/mueller/hotfix-etl' into mueller/mac-os	2022-05-02 09:35:28 +02:00
Robin Mueller	77450eb4b7	removed flag which does not exist	2022-05-02 09:09:41 +02:00
Robin	28015c4735	it compiles and runs	2022-05-01 17:48:49 +02:00
Robin	7d61e67d20	more macos changes	2022-04-30 19:02:41 +02:00
Robin	afcbc8be0a	changes for MacOS	2022-04-30 18:40:22 +02:00
Jakob.Meier	7760b3063e	Merge pull request 'New Subsystem adder functions' (#73 ) from mueller/new-ss-adder-functions-eive into eive/develop Reviewed-on: #73	2022-04-30 17:00:34 +02:00
Jakob Meier	d04f88bee0	Merge branch 'eive/develop' into mueller/new-ss-adder-functions-eive	2022-04-30 16:59:48 +02:00
Jakob.Meier	e867d09111	Merge pull request 'Update from upstream' (#72 ) from mueller/update-from-upstream into eive/develop Reviewed-on: #72	2022-04-30 16:55:35 +02:00
Robin Müller	7a2269262b	Merge branch 'development' into meier/spacePacketBugFix	2022-04-29 08:45:10 +02:00
Jakob Meier	9731dc1e61	space packet bug fix	2022-04-29 07:47:23 +02:00
Jakob Meier	43aad11859	space packet bugfix	2022-04-29 07:43:52 +02:00
Robin Mueller	3225a8e350	added option to change initial submode	2022-04-28 16:48:14 +02:00
Robin Mueller	1c4ea6dd0d	Merge branch 'eive/develop' into mueller/new-ss-adder-functions-eive	2022-04-28 14:34:20 +02:00
Robin Mueller	e2eb4bfea4	Merge remote-tracking branch 'upstream/development' into mueller/update-from-upstream	2022-04-28 14:30:08 +02:00
Robin Mueller	29b0a352fc	added new functions to add sequences and tables	2022-04-28 14:26:00 +02:00
Jakob Meier	41682aab3f	Merge branch 'eive/develop' into meier/develop	2022-04-28 11:45:27 +02:00
Robin Mueller	8642b13fd1	Merge branch 'mueller/hotfix-etl' into mueller/bump-catch2	2022-04-27 21:55:45 +02:00
Robin Mueller	6aa72892ed	clean usage of FetchContent_MakeAvailable	2022-04-27 21:53:57 +02:00
Robin Mueller	70f0a72f1b	added explicit checkout of v3.0.0-preview5	2022-04-27 13:54:15 +02:00
Robin Mueller	b5d890eedd	install Catch2 for docker_d2 and update Jenkinsfile	2022-04-27 13:43:49 +02:00
Robin Mueller	50b1b48678	link Catch2 issue	2022-04-27 13:36:26 +02:00
Robin Mueller	0e0dbc74aa	Merge branch 'mueller/hotfix-etl' into mueller/bump-catch2	2022-04-27 09:45:42 +02:00
Robin Mueller	8c34051d8b	bump Catch2 revision	2022-04-27 09:45:20 +02:00
Robin Mueller	b00d83cb1a	bump ETL revision	2022-04-27 09:41:16 +02:00
Robin Mueller	17e609c3a5	some more var replacements	2022-04-27 09:37:11 +02:00
Robin Mueller	64f0166b64	hotfix for new ETL dependency	2022-04-27 09:16:52 +02:00
Robin Mueller	c80f06fbcb	hotfix for ETL lib dep	2022-04-27 09:08:17 +02:00
Robin Mueller	70eb8325a0	Merge remote-tracking branch 'upstream/development' into mueller/compiler-warning-fixes-upstream-2	2022-04-27 08:47:45 +02:00
Robin Müller	e796f82203	Merge pull request 'gpio bug fix' (#602 ) from KSat/fsfw:hoffmann/gpioBugfix into development Reviewed-on: fsfw/fsfw#602	2022-04-27 08:41:54 +02:00
Robin Mueller	5b7ca8c13c	update CHANGELOG.md, apply afmt	2022-04-27 08:39:21 +02:00
Jakob.Meier	d61fe7db93	Merge pull request 'Update FSFW' (#70 ) from mueller/update-fsfw into eive/develop Reviewed-on: #70	2022-04-27 07:48:56 +02:00
Robin Mueller	c1be1fe232	update CMakeLists.txt etl handling	2022-04-26 20:06:26 +02:00
Robin Mueller	ec2e274f22	find_package call for Catch2 quiet	2022-04-26 16:31:45 +02:00
Robin Mueller	c5a7b98a7d	name correction	2022-04-26 16:24:14 +02:00
Robin Mueller	6a8da303fb	exporting etl target	2022-04-26 14:06:30 +02:00
Robin Mueller	3d047f9629	trying to export ETL lib	2022-04-26 11:15:24 +02:00
Robin Mueller	1739edd9b0	warning fix for modern compilers	2022-04-26 10:32:37 +02:00
Robin Mueller	466a3639a5	Merge remote-tracking branch 'upstream/development' into mueller/update-fsfw	2022-04-26 10:02:43 +02:00
Jakob Meier	900ef5b912	option to use coutdwon object to time out replies	2022-04-26 09:07:03 +02:00
Robin Müller	031739ef51	Merge branch 'development' into hoffmann/gpioBugfix	2022-04-25 15:45:21 +02:00
Robin Mueller	80be937d9d	Merge remote-tracking branch 'upstream/development' into mueller/compiler-warning-fixes-upstream-2	2022-04-25 15:24:17 +02:00
Steffen Gaisser	b8516b15cb	Merge pull request 'Added an additional conversion function' (#584 ) from eive/fsfw:mueller/clock-addition into development Reviewed-on: fsfw/fsfw#584	2022-04-25 15:22:07 +02:00
Steffen Gaisser	ac5a54b5da	Merge branch 'development' into mueller/clock-addition	2022-04-25 15:12:24 +02:00
Robin Mueller	29015b340b	update changelog	2022-04-25 15:10:50 +02:00
Ulrich Mohr	64274acbeb	Merge pull request 'Add ETL dependency' (#592 ) from KSat/fsfw:mueller/add-etl-dependency into development Reviewed-on: fsfw/fsfw#592	2022-04-25 15:08:05 +02:00
Robin Müller	ff98c42514	Merge branch 'development' into mueller/clock-addition	2022-04-25 14:54:22 +02:00
Ulrich Mohr	126ac52975	Merge pull request 'Allow passing a MqArgs struct to the MQ creation' (#583 ) from eive/fsfw:mueller/ipc-pass-arbitrary-args-to-mq into development Reviewed-on: fsfw/fsfw#583	2022-04-25 14:43:52 +02:00
Philipp	70d3197212	gpio init bug fix Return values from configureGpios were not checked	2022-04-25 14:32:05 +02:00
Philipp	dd90980520	push test	2022-04-25 14:19:03 +02:00
Jakob.Meier	280b641cbc	Merge pull request 'mueller/extend-version-class-fork' (#69 ) from mueller/extend-version-class-fork into eive/develop Reviewed-on: #69	2022-04-22 20:06:49 +02:00
Robin Mueller	352ab43c1f	Merge remote-tracking branch 'upstream/development' into mueller/add-etl-dependency	2022-04-12 17:11:41 +02:00
Robin Müller	07f5dbb9ac	Merge branch 'development' into mueller/compiler-warning-fixes-upstream-2	2022-04-12 17:08:56 +02:00
Robin Müller	97e98eae24	Merge branch 'development' into mueller/ipc-pass-arbitrary-args-to-mq	2022-04-12 17:06:30 +02:00
Robin Müller	afce942bf8	Merge branch 'development' into mueller/compiler-warning-fixes-upstream-2	2022-04-11 17:33:04 +02:00
Robin Mueller	a1d7a56dfa	small fix	2022-04-11 17:14:43 +02:00
Robin Mueller	cb78fefbb3	afmt	2022-04-11 17:14:04 +02:00
Robin Mueller	c55925959b	Merge branch 'mueller/add-etl-dependency' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller/add-etl-dependency	2022-04-11 16:44:30 +02:00
Robin Mueller	4f0669c574	doc update	2022-04-11 16:44:20 +02:00
Robin Müller	f0d996ffd2	Merge branch 'development' into mueller/add-etl-dependency	2022-04-11 16:17:46 +02:00
Robin Mueller	f4d05c2c9c	Merge branch 'mueller/ipc-pass-arbitrary-args-to-mq' of https://egit.irs.uni-stuttgart.de/eive/fsfw into mueller/ipc-pass-arbitrary-args-to-mq	2022-04-11 16:13:55 +02:00
Robin Mueller	d1151ca707	changelog update	2022-04-11 16:13:47 +02:00
Robin Müller	82f46992f6	Merge branch 'development' into mueller/ipc-pass-arbitrary-args-to-mq	2022-04-11 16:11:57 +02:00
Robin Mueller	9947a648df	fix compiler warnings	2022-04-11 16:06:13 +02:00
Robin Mueller	b2252bdc0b	Merge remote-tracking branch 'upstream/development' into mueller/add-etl-dependency	2022-04-04 14:18:30 +02:00
Steffen Gaisser	a3930dafc5	Moved unused constructors	2022-03-28 21:37:25 +02:00
Steffen Gaisser	4f9797af3b	Updated CCSDS CuC Functions	2022-03-28 21:24:33 +02:00
Robin Mueller	1a530633ca	small fix	2022-03-28 21:10:51 +02:00
Robin Mueller	8037e8074b	more docs	2022-03-28 21:03:18 +02:00
Robin Mueller	d07e0e5576	trying something	2022-03-28 21:01:26 +02:00
Robin Mueller	5525466b52	update changelog	2022-03-28 20:57:30 +02:00
Robin Mueller	c2a89bf709	bugfix	2022-03-28 20:57:13 +02:00
Robin Mueller	8dd0b2608d	cache version variables	2022-03-28 20:55:34 +02:00
Robin Mueller	05495077ec	doc update	2022-03-28 20:53:39 +02:00
Robin Mueller	8ff9eadf30	update changelog, add basic instructions for etl	2022-03-28 20:43:36 +02:00
Robin Mueller	082c86ea18	link ETL lib as well	2022-03-28 20:18:49 +02:00
Robin Mueller	2800d6f28c	add ETL dependency	2022-03-28 20:16:11 +02:00
Steffen Gaisser	b4effe7a46	Clang format	2022-03-28 18:33:24 +02:00
Steffen Gaisser	e6e71436c2	Added more tests	2022-03-28 18:32:51 +02:00
Steffen Gaisser	a887f852c8	Merge branch 'development' into mueller/clock-addition	2022-03-28 15:45:58 +02:00
Steffen Gaisser	0b3255e463	Fixed tests	2022-03-28 15:17:59 +02:00
Steffen Gaisser	631a531212	Merge branch 'development' into mueller/clock-addition	2022-03-28 14:51:23 +02:00
Steffen Gaisser	665d8cd479	Applied clang format	2022-03-25 18:48:53 +01:00
Steffen Gaisser	10398855a9	Added more unittest coverage Added Mutex for gmtime functions Moved Statics used in ClockCommon to ClockCommon	2022-03-25 18:47:31 +01:00
Robin Mueller	d0fec93dc3	argument order inversion	2022-03-25 13:42:49 +01:00
Robin Mueller	59ab54b2fb	call corrections	2022-03-25 13:41:37 +01:00
Robin Mueller	7095999bd2	remove CCSDSTime function	2022-03-25 13:34:35 +01:00
Robin Mueller	7ffb4107d2	added missing docs	2022-03-25 13:34:08 +01:00
Robin Mueller	9ce59d3c75	added an additional conversion function - timeval to TimeOfDay_t	2022-03-22 17:54:09 +01:00