add fsfw specific cmake message prefix

apply afmt
extend version handling with git describe
2022-04-22 14:08:26 +02:00 · 2022-04-22 14:04:30 +02:00 · 2022-04-22 14:04:18 +02:00 · 2022-04-22 11:58:44 +02:00
79 changed files with 1332 additions and 1124 deletions
@@ -12,9 +12,6 @@ and this project adheres to [Semantic Versioning](http://semver.org/).

 ## Changes

- Bump C++ required version to C++17. Every project which uses the FSFW and every modern
-  compiler supports it
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/622
 - HAL Linux SPI: Set the Clock Default State when setting new SPI speed
  and mode
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/573
@@ -27,16 +24,6 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - `oneShotAction` flag in the `TestTask` class is not static anymore
 - HAL Linux Uart: Baudrate and bits per word are enums now, avoiding misconfigurations
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/585
- IPC Message Queue Handling: Allow passing an optional `MqArgs` argument into the MessageQueue
-  creation call. It allows passing context information and an arbitrary user argument into
-  the message queue. Also streamlined and simplified `MessageQueue` implementation for all OSALs
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/583
- Clock: 
-  - `timeval` to `TimeOfDay_t`
-  - Added Mutex for gmtime calls: (compare http://www.opengate.at/blog/2020/01/timeless/)
-  - Moved the statics used by Clock in ClockCommon.cpp to this file
-  - Better check for leap seconds
-  - Added Unittests for Clock (only getter)

 ## Removed

@@ -50,25 +37,11 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Dedicated Version class and constant `fsfw::FSFW_VERSION` containing version information
  inside `fsfw/version.h`
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/559
- Added ETL dependency and improved library dependency management
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/592
- `Subsystem`: New API to add table and sequence entries

 ## Fixed

- TCP TMTC Server: `MutexGuard` was not created properly in
-  `TcpTmTcServer::handleTmSending(socket_t connSocket, bool& tmSent)` call.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/618
- Fix infinite recursion in `prepareHealthSetReply` of PUS Health Service 201.
-  Is not currently used right now but might be used in the future
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/617
- Move some CMake directives further up top so they are not ignored
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/621
 - Small bugfix in STM32 HAL for SPI
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/599
- HAL GPIO: Improved error checking in `LinuxLibgpioIF::configureGpios(...)`. If a GPIO
-  configuration fails, the function will exit prematurely with a dedicated error code
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/602

 # [v4.0.0]

@@ -1,38 +1,9 @@
 cmake_minimum_required(VERSION 3.13)

-set(LIB_FSFW_NAME fsfw)
-project(${LIB_FSFW_NAME})
-
-if(NOT CMAKE_CXX_STANDARD)
-    set(CMAKE_CXX_STANDARD 17)
-    set(CMAKE_CXX_STANDARD_REQUIRED True)
-elseif(${CMAKE_CXX_STANDARD} LESS 17)
-    message(FATAL_ERROR "Compiling the FSFW requires a minimum of C++17 support")
-endif()
-
-set(FSFW_VERSION 4)
-set(FSFW_SUBVERSION 0)
-set(FSFW_REVISION 0)
-
 # Add the cmake folder so the FindSphinx module is found
 set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})

-set(FSFW_ETL_LIB_MAJOR_VERSION 20 CACHE STRING
-    "ETL library major version requirement"
-)
-set(FSFW_ETL_LIB_VERSION ${FSFW_ETL_LIB_MAJOR_VERSION}.27.3 CACHE STRING
-    "ETL library exact version requirement"
-)
-set(FSFW_ETL_LINK_TARGET etl::etl)
-
-set(FSFW_CATCH2_LIB_MAJOR_VERSION 3 CACHE STRING
-    "Catch2 library major version requirement"
-)
-set(FSFW_CATCH2_LIB_VERSION v${FSFW_CATCH2_LIB_MAJOR_VERSION}.0.0-preview5 CACHE STRING
-    "Catch2 library exact version requirement"
-)
-
-set(FSFW_ETL_LIB_NAME etl)
+set(MSG_PREFIX "fsfw |")

 option(FSFW_GENERATE_SECTIONS
    "Generate function and data sections. Required to remove unused code" ON
@@ -65,28 +36,49 @@ option(FSFW_ADD_TMSTORAGE "Compile with tm storage components" OFF)
 # Contrib sources
 option(FSFW_ADD_SGP4_PROPAGATOR "Add SGP4 propagator code" OFF)

-
+set(LIB_FSFW_NAME fsfw)
 set(FSFW_TEST_TGT fsfw-tests)
 set(FSFW_DUMMY_TGT fsfw-dummy)

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

+# Version handling
+include("GetGitRevisionDescription")
+determine_version_with_git("--exclude" "docker_*")
+set(GIT_INFO ${GIT_INFO} CACHE STRING "Version information retrieved with git describe")
+list(GET GIT_INFO 1 FSFW_VERSION)
+list(GET GIT_INFO 2 FSFW_SUBVERSION)
+list(GET GIT_INFO 3 FSFW_REVISION)
+list(GET GIT_INFO 4 FSFW_VERSION_CST_GIT_SHA1)
+if(NOT FSFW_VERSION)
+    set(FSFW_VERSION -1)
+endif()
+if(NOT FSFW_SUBVERSION)
+    set(FSFW_SUBVERSION -1)
+endif()
+if(NOT FSFW_REVISION)
+    set(FSFW_REVISION -1)
+endif()
+
 if(FSFW_BUILD_UNITTESTS)
-    message(STATUS "Building the FSFW unittests in addition to the static library")
+    message(STATUS "${MSG_PREFIX} Building the FSFW unittests in addition to the static library")
    # Check whether the user has already installed Catch2 first
-    find_package(Catch2 ${FSFW_CATCH2_LIB_MAJOR_VERSION})
+    find_package(Catch2 3 QUIET)
    # Not installed, so use FetchContent to download and provide Catch2
    if(NOT Catch2_FOUND)
-        message(STATUS "Catch2 installation not found. Downloading Catch2 library with FetchContent")
+        message(STATUS "${MSG_PREFIX} Catch2 installation not found. Downloading Catch2 library with FetchContent")
        include(FetchContent)

        FetchContent_Declare(
            Catch2
            GIT_REPOSITORY https://github.com/catchorg/Catch2.git
-            GIT_TAG        ${FSFW_CATCH2_LIB_VERSION}
+            GIT_TAG        v3.0.0-preview4
        )

-        list(APPEND FSFW_FETCH_CONTENT_TARGETS Catch2)
+        FetchContent_MakeAvailable(Catch2)
+        #fixes regression -preview4, to be confirmed in later releases
+        set_target_properties(Catch2 PROPERTIES DEBUG_POSTFIX "")
    endif()

    set(FSFW_CONFIG_PATH tests/src/fsfw_tests/unit/testcfg)
@@ -97,8 +89,8 @@ if(FSFW_BUILD_UNITTESTS)
    add_executable(${FSFW_TEST_TGT})

    if(FSFW_TESTS_GEN_COV)
-        message(STATUS "Generating coverage data for the library")
-        message(STATUS "Targets linking against ${LIB_FSFW_NAME} "
+        message(STATUS "${MSG_PREFIX} Generating coverage data for the library")
+        message(STATUS "${MSG_PREFIX} Targets linking against ${LIB_FSFW_NAME} "
            "will be compiled with coverage data as well"
        )
        include(FetchContent)
@@ -113,42 +105,6 @@ if(FSFW_BUILD_UNITTESTS)
    endif()
 endif()

-message(STATUS "Finding and/or providing ETL library")
-
-# Check whether the user has already installed ETL first
-find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} QUIET)
-# Not installed, so use FetchContent to download and provide etl
-if(NOT ${FSFW_ETL_LIB_NAME}_FOUND)
-    message(STATUS
-        "No ETL installation was found with find_package. Installing and providing "
-        "etl with FindPackage"
-    )
-    include(FetchContent)
-
-    FetchContent_Declare(
-        ${FSFW_ETL_LIB_NAME}
-        GIT_REPOSITORY https://github.com/ETLCPP/etl
-        GIT_TAG        ${FSFW_ETL_LIB_VERSION}
-    )
-
-    list(APPEND FSFW_FETCH_CONTENT_TARGETS ${FSFW_ETL_LIB_NAME})
-endif()
-
-# The documentation for FetchContent recommends declaring all the dependencies
-# before making them available. We make all declared dependency available here
-# after their declaration
-if(FSFW_FETCH_CONTENT_TARGETS)
-    FetchContent_MakeAvailable(${FSFW_FETCH_CONTENT_TARGETS})
-    if(TARGET ${FSFW_ETL_LIB_NAME})
-        add_library(${FSFW_ETL_LINK_TARGET} ALIAS ${FSFW_ETL_LIB_NAME})
-    endif()
-    if(TARGET Catch2)
-        # Fixes regression -preview4, to be confirmed in later releases
-        # Related GitHub issue: https://github.com/catchorg/Catch2/issues/2417
-        set_target_properties(Catch2 PROPERTIES DEBUG_POSTFIX "")
-    endif()
-endif()
-
 set(FSFW_CORE_INC_PATH "inc")

 set_property(CACHE FSFW_OSAL PROPERTY STRINGS host linux rtems freertos)
@@ -161,15 +117,21 @@ target_include_directories(${LIB_FSFW_NAME} INTERFACE
    ${CMAKE_CURRENT_BINARY_DIR}
 )

+if(NOT CMAKE_CXX_STANDARD)
+    set(CMAKE_CXX_STANDARD 11)
+    set(CMAKE_CXX_STANDARD_REQUIRED True)
+elseif(${CMAKE_CXX_STANDARD} LESS 11)
+    message(FATAL_ERROR "${MSG_PREFIX} Compiling the FSFW requires a minimum of C++11 support")
+endif()

 # Backwards comptability
 if(OS_FSFW AND NOT FSFW_OSAL)
-    message(WARNING "Please pass the FSFW OSAL as FSFW_OSAL instead of OS_FSFW")
+    message(WARNING "${MSG_PREFIX} Please pass the FSFW OSAL as FSFW_OSAL instead of OS_FSFW")
    set(FSFW_OSAL OS_FSFW)
 endif()

 if(NOT FSFW_OSAL)
-	message(STATUS "No OS for FSFW via FSFW_OSAL set. Assuming host OS")
+	message(STATUS "${MSG_PREFIX} No OS for FSFW via FSFW_OSAL set. Assuming host OS")
 	# Assume host OS and autodetermine from OS_FSFW
 	if(UNIX)
 		set(FSFW_OSAL  "linux" 
@@ -203,7 +165,7 @@ elseif(FSFW_OSAL STREQUAL rtems)
    set(FSFW_OSAL_RTEMS ON)
 else()
    message(WARNING
-        "Invalid operating system for FSFW specified! Setting to host.."
+        "${MSG_PREFIX} Invalid operating system for FSFW specified! Setting to host.."
    )
    set(FSFW_OS_NAME "Host")
    set(OS_FSFW "host")
@@ -212,7 +174,7 @@ endif()
 configure_file(src/fsfw/FSFW.h.in fsfw/FSFW.h)
 configure_file(src/fsfw/FSFWVersion.h.in fsfw/FSFWVersion.h)

-message(STATUS "Compiling FSFW for the ${FSFW_OS_NAME} operating system.")
+message(STATUS "${MSG_PREFIX} Compiling FSFW for the ${FSFW_OS_NAME} operating system")

 add_subdirectory(src)
 add_subdirectory(tests)
@@ -296,8 +258,8 @@ endif()
 if(NOT FSFW_CONFIG_PATH)
    set(DEF_CONF_PATH misc/defaultcfg/fsfwconfig)
    if(NOT FSFW_BUILD_DOCS)
-        message(WARNING "Flight Software Framework configuration path not set!")
-        message(WARNING "Setting default configuration from ${DEF_CONF_PATH} ..")
+        message(WARNING "${MSG_PREFIX} Flight Software Framework configuration path not set")
+        message(WARNING "${MSG_PREFIX} Setting default configuration from ${DEF_CONF_PATH} ..")
    endif()
    add_subdirectory(${DEF_CONF_PATH})
    set(FSFW_CONFIG_PATH ${DEF_CONF_PATH})
@@ -404,7 +366,6 @@ target_compile_options(${LIB_FSFW_NAME} PRIVATE
 )

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

@@ -11,15 +11,9 @@ with Airbus Defence and Space GmbH.

 ## Quick facts

-The framework is designed for systems, which communicate with external devices, perform control loops, 
-receive telecommands and send telemetry, and need to maintain a high level of availability. Therefore,
-a mode and health system provides control over the states of the software and the controlled devices.
-In addition, a simple mechanism of event based fault detection, isolation and recovery is implemented as well. 
+The framework is designed for systems, which communicate with external devices, perform control loops, receive telecommands and send telemetry, and need to maintain a high level of availability. Therefore, a mode and health system provides control over the states of the software and the controlled devices. In addition, a simple mechanism of event based fault detection, isolation and recovery is implemented as well. 

-The FSFW provides abstraction layers for operating systems to provide a uniform operating system
-abstraction layer (OSAL). Some components of this OSAL are required internally by the FSFW but is
-also very useful for developers to implement the same application logic on different operating
-systems with a uniform interface.
+The FSFW provides abstraction layers for operating systems to provide a uniform operating system abstraction layer (OSAL). Some components of this OSAL are required internally by the FSFW but is also very useful for developers to implement the same application logic on different operating systems with a uniform interface.

 Currently, the FSFW provides the following OSALs:

@@ -51,28 +45,6 @@ A template configuration folder was provided and can be copied into the project
 a starting point. The [configuration section](docs/README-config.md#top) provides more specific 
 information about the possible options.

-## Prerequisites
-
-The Embedded Template Library (etl) is a dependency of the FSFW which is automatically
-installed and provided by the build system unless the correction version was installed.
-The current recommended version can be found inside the fsfw `CMakeLists.txt` file or by using
-`ccmake` and looking up the `FSFW_ETL_LIB_MAJOR_VERSION` variable.
-
-You can install the ETL library like this. On Linux, it might be necessary to add `sudo` before
-the install call:
-
-```cpp
-git clone https://github.com/ETLCPP/etl
-cd etl
-git checkout <currentRecommendedVersion>
-mkdir build && cd build
-cmake ..
-cmake --install .
-```
-
-It is recommended to install `20.27.2` or newer for the package version handling of
-ETL to work.
-
 ## Adding the library

 The following steps show how to add and use FSFW components. It is still recommended to
@@ -111,19 +83,6 @@ The FSFW also has unittests which use the [Catch2 library](https://github.com/ca
 These are built by setting the CMake option `FSFW_BUILD_UNITTESTS` to `ON` or `TRUE`
 from your project `CMakeLists.txt` file or from the command line.

-You can install the Catch2 library, which prevents the build system to avoid re-downloading
-the dependency if the unit tests are completely rebuilt. The current recommended version
-can be found inside the fsfw `CMakeLists.txt` file or by using `ccmake` and looking up
-the `FSFW_CATCH2_LIB_VERSION` variable.
-
-```sh
-git clone https://github.com/catchorg/Catch2.git
-cd Catch2
-git checkout <currentRecommendedVersion>
-cmake -Bbuild -H. -DBUILD_TESTING=OFF
-sudo cmake --build build/ --target install
-```
-
 The fsfw-tests binary will be built as part of the static library and dropped alongside it.
 If the unittests are built, the library and the tests will be built with coverage information by
 default. This can be disabled by setting the `FSFW_TESTS_COV_GEN` option to `OFF` or `FALSE`.
@@ -6,9 +6,3 @@ 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
@@ -3,7 +3,7 @@ pipeline {
        BUILDDIR = 'build-tests'
    }
    agent {
-        docker { image 'fsfw-ci:d2'}
+        docker { image 'fsfw-ci:d1'}
    }
    stages {
        stage('Clean') {
@@ -0,0 +1,284 @@
+# - Returns a version string from Git
+#
+# These functions force a re-configure on each git commit so that you can
+# trust the values of the variables in your build system.
+#
+#  get_git_head_revision(<refspecvar> <hashvar> [ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR])
+#
+# Returns the refspec and sha hash of the current head revision
+#
+#  git_describe(<var> [<additional arguments to git describe> ...])
+#
+# Returns the results of git describe on the source tree, and adjusting
+# the output so that it tests false if an error occurs.
+#
+#  git_describe_working_tree(<var> [<additional arguments to git describe> ...])
+#
+# Returns the results of git describe on the working tree (--dirty option),
+# and adjusting the output so that it tests false if an error occurs.
+#
+#  git_get_exact_tag(<var> [<additional arguments to git describe> ...])
+#
+# Returns the results of git describe --exact-match on the source tree,
+# and adjusting the output so that it tests false if there was no exact
+# matching tag.
+#
+#  git_local_changes(<var>)
+#
+# Returns either "CLEAN" or "DIRTY" with respect to uncommitted changes.
+# Uses the return code of "git diff-index --quiet HEAD --".
+# Does not regard untracked files.
+#
+# Requires CMake 2.6 or newer (uses the 'function' command)
+#
+# Original Author:
+# 2009-2020 Ryan Pavlik <ryan.pavlik@gmail.com> <abiryan@ryand.net>
+# http://academic.cleardefinition.com
+#
+# Copyright 2009-2013, Iowa State University.
+# Copyright 2013-2020, Ryan Pavlik
+# Copyright 2013-2020, Contributors
+# SPDX-License-Identifier: BSL-1.0
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+if(__get_git_revision_description)
+    return()
+endif()
+set(__get_git_revision_description YES)
+
+# We must run the following at "include" time, not at function call time,
+# to find the path to this module rather than the path to a calling list file
+get_filename_component(_gitdescmoddir ${CMAKE_CURRENT_LIST_FILE} PATH)
+
+# Function _git_find_closest_git_dir finds the next closest .git directory
+# that is part of any directory in the path defined by _start_dir.
+# The result is returned in the parent scope variable whose name is passed
+# as variable _git_dir_var. If no .git directory can be found, the
+# function returns an empty string via _git_dir_var.
+#
+# Example: Given a path C:/bla/foo/bar and assuming C:/bla/.git exists and
+# neither foo nor bar contain a file/directory .git. This wil return
+# C:/bla/.git
+#
+function(_git_find_closest_git_dir _start_dir _git_dir_var)
+    set(cur_dir "${_start_dir}")
+    set(git_dir "${_start_dir}/.git")
+    while(NOT EXISTS "${git_dir}")
+        # .git dir not found, search parent directories
+        set(git_previous_parent "${cur_dir}")
+        get_filename_component(cur_dir "${cur_dir}" DIRECTORY)
+        if(cur_dir STREQUAL git_previous_parent)
+            # We have reached the root directory, we are not in git
+            set(${_git_dir_var}
+                ""
+                PARENT_SCOPE)
+            return()
+        endif()
+        set(git_dir "${cur_dir}/.git")
+    endwhile()
+    set(${_git_dir_var}
+        "${git_dir}"
+        PARENT_SCOPE)
+endfunction()
+
+function(get_git_head_revision _refspecvar _hashvar)
+    _git_find_closest_git_dir("${CMAKE_CURRENT_SOURCE_DIR}" GIT_DIR)
+
+    if("${ARGN}" STREQUAL "ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR")
+        set(ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR TRUE)
+    else()
+        set(ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR FALSE)
+    endif()
+    if(NOT "${GIT_DIR}" STREQUAL "")
+        file(RELATIVE_PATH _relative_to_source_dir "${CMAKE_SOURCE_DIR}"
+             "${GIT_DIR}")
+        if("${_relative_to_source_dir}" MATCHES "[.][.]" AND NOT ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR)
+            # We've gone above the CMake root dir.
+            set(GIT_DIR "")
+        endif()
+    endif()
+    if("${GIT_DIR}" STREQUAL "")
+        set(${_refspecvar}
+            "GITDIR-NOTFOUND"
+            PARENT_SCOPE)
+        set(${_hashvar}
+            "GITDIR-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+
+    # Check if the current source dir is a git submodule or a worktree.
+    # In both cases .git is a file instead of a directory.
+    #
+    if(NOT IS_DIRECTORY ${GIT_DIR})
+        # The following git command will return a non empty string that
+        # points to the super project working tree if the current
+        # source dir is inside a git submodule.
+        # Otherwise the command will return an empty string.
+        #
+        execute_process(
+            COMMAND "${GIT_EXECUTABLE}" rev-parse
+                    --show-superproject-working-tree
+            WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+            OUTPUT_VARIABLE out
+            ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+        if(NOT "${out}" STREQUAL "")
+            # If out is empty, GIT_DIR/CMAKE_CURRENT_SOURCE_DIR is in a submodule
+            file(READ ${GIT_DIR} submodule)
+            string(REGEX REPLACE "gitdir: (.*)$" "\\1" GIT_DIR_RELATIVE
+                                 ${submodule})
+            string(STRIP ${GIT_DIR_RELATIVE} GIT_DIR_RELATIVE)
+            get_filename_component(SUBMODULE_DIR ${GIT_DIR} PATH)
+            get_filename_component(GIT_DIR ${SUBMODULE_DIR}/${GIT_DIR_RELATIVE}
+                                   ABSOLUTE)
+            set(HEAD_SOURCE_FILE "${GIT_DIR}/HEAD")
+        else()
+            # GIT_DIR/CMAKE_CURRENT_SOURCE_DIR is in a worktree
+            file(READ ${GIT_DIR} worktree_ref)
+            # The .git directory contains a path to the worktree information directory
+            # inside the parent git repo of the worktree.
+            #
+            string(REGEX REPLACE "gitdir: (.*)$" "\\1" git_worktree_dir
+                                 ${worktree_ref})
+            string(STRIP ${git_worktree_dir} git_worktree_dir)
+            _git_find_closest_git_dir("${git_worktree_dir}" GIT_DIR)
+            set(HEAD_SOURCE_FILE "${git_worktree_dir}/HEAD")
+        endif()
+    else()
+        set(HEAD_SOURCE_FILE "${GIT_DIR}/HEAD")
+    endif()
+    set(GIT_DATA "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/git-data")
+    if(NOT EXISTS "${GIT_DATA}")
+        file(MAKE_DIRECTORY "${GIT_DATA}")
+    endif()
+
+    if(NOT EXISTS "${HEAD_SOURCE_FILE}")
+        return()
+    endif()
+    set(HEAD_FILE "${GIT_DATA}/HEAD")
+    configure_file("${HEAD_SOURCE_FILE}" "${HEAD_FILE}" COPYONLY)
+
+    configure_file("${_gitdescmoddir}/GetGitRevisionDescription.cmake.in"
+                   "${GIT_DATA}/grabRef.cmake" @ONLY)
+    include("${GIT_DATA}/grabRef.cmake")
+
+    set(${_refspecvar}
+        "${HEAD_REF}"
+        PARENT_SCOPE)
+    set(${_hashvar}
+        "${HEAD_HASH}"
+        PARENT_SCOPE)
+endfunction()
+
+function(git_describe _var)
+    if(NOT GIT_FOUND)
+        find_package(Git QUIET)
+    endif()
+    get_git_head_revision(refspec hash)
+    if(NOT GIT_FOUND)
+        set(${_var}
+            "GIT-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+    if(NOT hash)
+        set(${_var}
+            "HEAD-HASH-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+
+    # TODO sanitize
+    #if((${ARGN}" MATCHES "&&") OR
+    #   (ARGN MATCHES "||") OR
+    #   (ARGN MATCHES "\\;"))
+    #   message("Please report the following error to the project!")
+    #   message(FATAL_ERROR "Looks like someone's doing something nefarious with git_describe! Passed arguments ${ARGN}")
+    #endif()
+
+    #message(STATUS "Arguments to execute_process: ${ARGN}")
+
+    execute_process(
+        COMMAND "${GIT_EXECUTABLE}" describe --tags --always ${hash} ${ARGN}
+        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+        RESULT_VARIABLE res
+        OUTPUT_VARIABLE out
+        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if(NOT res EQUAL 0)
+        set(out "${out}-${res}-NOTFOUND")
+    endif()
+
+    set(${_var}
+        "${out}"
+        PARENT_SCOPE)
+endfunction()
+
+function(git_describe_working_tree _var)
+    if(NOT GIT_FOUND)
+        find_package(Git QUIET)
+    endif()
+    if(NOT GIT_FOUND)
+        set(${_var}
+            "GIT-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+
+    execute_process(
+        COMMAND "${GIT_EXECUTABLE}" describe --dirty ${ARGN}
+        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+        RESULT_VARIABLE res
+        OUTPUT_VARIABLE out
+        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if(NOT res EQUAL 0)
+        set(out "${out}-${res}-NOTFOUND")
+    endif()
+
+    set(${_var}
+        "${out}"
+        PARENT_SCOPE)
+endfunction()
+
+function(git_get_exact_tag _var)
+    git_describe(out --exact-match ${ARGN})
+    set(${_var}
+        "${out}"
+        PARENT_SCOPE)
+endfunction()
+
+function(git_local_changes _var)
+    if(NOT GIT_FOUND)
+        find_package(Git QUIET)
+    endif()
+    get_git_head_revision(refspec hash)
+    if(NOT GIT_FOUND)
+        set(${_var}
+            "GIT-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+    if(NOT hash)
+        set(${_var}
+            "HEAD-HASH-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+
+    execute_process(
+        COMMAND "${GIT_EXECUTABLE}" diff-index --quiet HEAD --
+        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+        RESULT_VARIABLE res
+        OUTPUT_VARIABLE out
+        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if(res EQUAL 0)
+        set(${_var}
+            "CLEAN"
+            PARENT_SCOPE)
+    else()
+        set(${_var}
+            "DIRTY"
+            PARENT_SCOPE)
+    endif()
+endfunction()
@@ -0,0 +1,43 @@
+#
+# Internal file for GetGitRevisionDescription.cmake
+#
+# Requires CMake 2.6 or newer (uses the 'function' command)
+#
+# Original Author:
+# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
+# http://academic.cleardefinition.com
+# Iowa State University HCI Graduate Program/VRAC
+#
+# Copyright 2009-2012, Iowa State University
+# Copyright 2011-2015, Contributors
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+# SPDX-License-Identifier: BSL-1.0
+
+set(HEAD_HASH)
+
+file(READ "@HEAD_FILE@" HEAD_CONTENTS LIMIT 1024)
+
+string(STRIP "${HEAD_CONTENTS}" HEAD_CONTENTS)
+if(HEAD_CONTENTS MATCHES "ref")
+    # named branch
+    string(REPLACE "ref: " "" HEAD_REF "${HEAD_CONTENTS}")
+    if(EXISTS "@GIT_DIR@/${HEAD_REF}")
+        configure_file("@GIT_DIR@/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY)
+    else()
+        configure_file("@GIT_DIR@/packed-refs" "@GIT_DATA@/packed-refs" COPYONLY)
+        file(READ "@GIT_DATA@/packed-refs" PACKED_REFS)
+        if(${PACKED_REFS} MATCHES "([0-9a-z]*) ${HEAD_REF}")
+            set(HEAD_HASH "${CMAKE_MATCH_1}")
+        endif()
+    endif()
+else()
+    # detached HEAD
+    configure_file("@GIT_DIR@/HEAD" "@GIT_DATA@/head-ref" COPYONLY)
+endif()
+
+if(NOT HEAD_HASH)
+    file(READ "@GIT_DATA@/head-ref" HEAD_HASH LIMIT 1024)
+    string(STRIP "${HEAD_HASH}" HEAD_HASH)
+endif()
@@ -0,0 +1,28 @@
+# Determines the git version with git describe and returns it by setting
+# the GIT_INFO list in the parent scope. The list has the following entries
+# 1. Full version string
+# 2. Major version
+# 3. Minor version
+# 4. Revision
+# 5. git SHA hash and commits since tag
+function(determine_version_with_git)
+    include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/GetGitRevisionDescription.cmake)
+    git_describe(VERSION ${ARGN})
+    string(FIND ${VERSION} "." VALID_VERSION)
+    if(VALID_VERSION EQUAL -1)
+        message(WARNING "Version string ${VERSION} retrieved with git describe is invalid")
+        return()
+    endif()
+    # Parse the version information into pieces.
+    string(REGEX REPLACE "^v([0-9]+)\\..*" "\\1" _VERSION_MAJOR "${VERSION}")
+    string(REGEX REPLACE "^v[0-9]+\\.([0-9]+).*" "\\1" _VERSION_MINOR "${VERSION}")
+    string(REGEX REPLACE "^v[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" _VERSION_PATCH "${VERSION}")
+    string(REGEX REPLACE "^v[0-9]+\\.[0-9]+\\.[0-9]+-(.*)" "\\1" VERSION_SHA1 "${VERSION}")
+    set(GIT_INFO ${VERSION})
+    list(APPEND GIT_INFO ${_VERSION_MAJOR})
+    list(APPEND GIT_INFO ${_VERSION_MINOR})
+    list(APPEND GIT_INFO ${_VERSION_PATCH})
+    list(APPEND GIT_INFO ${VERSION_SHA1})
+    set(GIT_INFO ${GIT_INFO} PARENT_SCOPE)
+    message(STATUS "${MSG_PREFIX} Set git version info into GIT_INFO from the git tag ${VERSION}")
+endfunction()
@@ -19,29 +19,6 @@ A template configuration folder was provided and can be copied into the project
 a starting point. The [configuration section](docs/README-config.md#top) provides more specific 
 information about the possible options.

-Prerequisites
-------------------
-
-The Embedded Template Library (etl) is a dependency of the FSFW which is automatically
-installed and provided by the build system unless the correction version was installed.
-The current recommended version can be found inside the fsfw ``CMakeLists.txt`` file or by using
-``ccmake`` and looking up the ``FSFW_ETL_LIB_MAJOR_VERSION`` variable.
-
-You can install the ETL library like this. On Linux, it might be necessary to add ``sudo`` before
-the install call:
-
-.. code-block:: console
-
-   git clone https://github.com/ETLCPP/etl
-   cd etl
-   git checkout <currentRecommendedVersion>
-   mkdir build && cd build
-   cmake ..
-   cmake --install .
-
-It is recommended to install ``20.27.2`` or newer for the package version handling of
-ETL to work.
-
 Adding the library
 -------------------

@@ -83,20 +60,6 @@ The FSFW also has unittests which use the `Catch2 library`_.
 These are built by setting the CMake option ``FSFW_BUILD_UNITTESTS`` to ``ON`` or `TRUE`
 from your project `CMakeLists.txt` file or from the command line.

-You can install the Catch2 library, which prevents the build system to avoid re-downloading
-the dependency if the unit tests are completely rebuilt. The current recommended version
-can be found inside the fsfw ``CMakeLists.txt`` file or by using ``ccmake`` and looking up
-the ``FSFW_CATCH2_LIB_VERSION`` variable.
-
-.. code-block:: console
-
-   git clone https://github.com/catchorg/Catch2.git
-   cd Catch2
-   git checkout <currentRecommendedVersion>
-   cmake -Bbuild -H. -DBUILD_TESTING=OFF
-   sudo cmake --build build/ --target install
-
-
 The fsfw-tests binary will be built as part of the static library and dropped alongside it.
 If the unittests are built, the library and the tests will be built with coverage information by
 default. This can be disabled by setting the `FSFW_TESTS_COV_GEN` option to `OFF` or `FALSE`.
@@ -12,14 +12,9 @@ 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)
@@ -44,7 +44,6 @@ 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) {
@@ -56,7 +55,7 @@ ReturnValue_t LinuxLibgpioIF::configureGpios(GpioMap& mapToAdd) {
        if (regularGpio == nullptr) {
          return GPIO_INVALID_INSTANCE;
        }
-        result = configureGpioByChip(gpioConfig.first, *regularGpio);
+        configureGpioByChip(gpioConfig.first, *regularGpio);
        break;
      }
      case (gpio::GpioTypes::GPIO_REGULAR_BY_LABEL): {
@@ -64,7 +63,7 @@ ReturnValue_t LinuxLibgpioIF::configureGpios(GpioMap& mapToAdd) {
        if (regularGpio == nullptr) {
          return GPIO_INVALID_INSTANCE;
        }
-        result = configureGpioByLabel(gpioConfig.first, *regularGpio);
+        configureGpioByLabel(gpioConfig.first, *regularGpio);
        break;
      }
      case (gpio::GpioTypes::GPIO_REGULAR_BY_LINE_NAME): {
@@ -72,7 +71,7 @@ ReturnValue_t LinuxLibgpioIF::configureGpios(GpioMap& mapToAdd) {
        if (regularGpio == nullptr) {
          return GPIO_INVALID_INSTANCE;
        }
-        result = configureGpioByLineName(gpioConfig.first, *regularGpio);
+        configureGpioByLineName(gpioConfig.first, *regularGpio);
        break;
      }
      case (gpio::GpioTypes::CALLBACK): {
@@ -84,11 +83,8 @@ ReturnValue_t LinuxLibgpioIF::configureGpios(GpioMap& mapToAdd) {
                               gpioCallback->initValue, gpioCallback->callbackArgs);
      }
    }
-    if (result != RETURN_OK) {
-      return GPIO_INIT_FAILED;
-    }
  }
-  return result;
+  return RETURN_OK;
 }

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

  LinuxLibgpioIF(object_id_t objectId);
  virtual ~LinuxLibgpioIF();
@@ -1,4 +1,4 @@
-#include "SpiCookie.h"
+#include "fsfw_hal/linux/spi/SpiCookie.h"

 SpiCookie::SpiCookie(address_t spiAddress, gpioId_t chipSelect, std::string spiDev,
                     const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed)
@@ -265,7 +265,6 @@ void UartComIF::configureBaudrate(struct termios* options, UartCookie* uartCooki
      cfsetispeed(options, B230400);
      cfsetospeed(options, B230400);
      break;
-#ifndef __APPLE__
    case UartBaudRate::RATE_460800:
      cfsetispeed(options, B460800);
      cfsetospeed(options, B460800);
@@ -314,7 +313,6 @@ void UartComIF::configureBaudrate(struct termios* options, UartCookie* uartCooki
      cfsetispeed(options, B4000000);
      cfsetospeed(options, B4000000);
      break;
-#endif // ! __APPLE__
    default:
 #if FSFW_CPP_OSTREAM_ENABLED == 1
      sif::warning << "UartComIF::configureBaudrate: Baudrate not supported" << std::endl;
@@ -2,8 +2,9 @@
 #define FSFW_VERSION_H_

 // Versioning is kept in project CMakeLists.txt file
-#define FSFW_VERSION_MAJOR @FSFW_VERSION@
-#define FSFW_VERSION_MINOR @FSFW_SUBVERSION@
-#define FSFW_VERSION_REVISION @FSFW_REVISION@
+static constexpr int FSFW_VERSION_MAJOR = @FSFW_VERSION@;
+static constexpr int FSFW_VERSION_MINOR = @FSFW_SUBVERSION@;
+static constexpr int FSFW_VERSION_REVISION = @FSFW_REVISION@;
+static const char FSFW_VERSION_CST_GIT_SHA1[] = "@FSFW_VERSION_CST_GIT_SHA1@";

 #endif /* FSFW_VERSION_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 override;
+  bool hasSegmentMetadataFlag() const;
  void setSegmentationControl(cfdp::SegmentationControl);

  void getSourceId(cfdp::EntityId& sourceId) const override;
@@ -2,7 +2,6 @@
 #define FIXEDARRAYLIST_H_

 #include <cmath>
-#include <limits>

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

@@ -10,23 +10,16 @@ class HybridIterator : public LinkedElement<T>::Iterator, public ArrayList<T, co
  HybridIterator() {}

  HybridIterator(typename LinkedElement<T>::Iterator *iter)
-      : LinkedElement<T>::Iterator(*iter), linked(true) {
-    if (iter != nullptr) {
-      value = iter->value;
-    }
-  }
+      : LinkedElement<T>::Iterator(*iter), value(iter->value), linked(true) {}

-  HybridIterator(LinkedElement<T> *start) : LinkedElement<T>::Iterator(start), linked(true) {
-    if (start != nullptr) {
-      value = start->value;
-    }
-  }
+  HybridIterator(LinkedElement<T> *start)
+      : LinkedElement<T>::Iterator(start), value(start->value), linked(true) {}

  HybridIterator(typename ArrayList<T, count_t>::Iterator start,
                 typename ArrayList<T, count_t>::Iterator end)
      : ArrayList<T, count_t>::Iterator(start), value(start.value), linked(false), end(end.value) {
    if (value == this->end) {
-      value = nullptr;
+      value = NULL;
    }
  }

@@ -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) override = 0;
+                                         uint32_t *msToReachTheMode) = 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) override;
-  virtual void getMode(Mode_t *mode, Submode_t *submode) override;
-  virtual void setToExternalControl() override;
+  virtual void startTransition(Mode_t mode, Submode_t submode);
+  virtual void getMode(Mode_t *mode, Submode_t *submode);
+  virtual void setToExternalControl();
  virtual void announceMode(bool recursive);
  /** HK helpers */
  virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
@@ -109,7 +109,7 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF, public HasRetu
   */
  virtual ReturnValue_t unlockDataPool() override;

-  virtual uint16_t getFillCount() const override;
+  virtual uint16_t getFillCount() const;

  /* SerializeIF implementations */
  virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, const size_t maxSize,
@@ -94,14 +94,13 @@ 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;
-#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);
+#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);
  validityPtr = validityMask.data();
 #else
-  uint8_t validityMask[validityMaskSize] = {};
+  uint8_t validityMask[validityMaskSize] = {0};
  validityPtr = validityMask;
 #endif
  uint8_t validBufferIndex = 0;
@@ -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) override;
-  pool_rwm_t getReadWriteMode() const override;
+  void setReadWriteMode(pool_rwm_t newReadWriteMode);
+  pool_rwm_t getReadWriteMode() const;

  bool isValid() const override;
  void setValid(bool valid) override;
@@ -163,7 +163,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   * @param counter Specifies which Action to perform
   * @return RETURN_OK for successful execution
   */
-  virtual ReturnValue_t performOperation(uint8_t counter) override;
+  virtual ReturnValue_t performOperation(uint8_t counter);

  /**
   * @brief  Initializes the device handler
@@ -173,7 +173,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   * Calls fillCommandAndReplyMap().
   * @return
   */
-  virtual ReturnValue_t initialize() override;
+  virtual ReturnValue_t initialize();

  /**
   * @brief   Intialization steps performed after all tasks have been created.
@@ -1058,11 +1058,11 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   * @param parameter1	Optional parameter 1
   * @param parameter2	Optional parameter 2
   */
-  void triggerEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) override;
+  void triggerEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0);
  /**
   * 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 override;
+  virtual void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const;

  /**
   * Checks if current mode is transitional mode.
@@ -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) override { return matchesTree(number); }
+  virtual bool match(T number) { return matchesTree(number); }
  bool matchesTree(T number) {
    iterator iter = this->begin();
    if (iter == this->end()) {
@@ -179,9 +179,6 @@ class MatchTree : public SerializeableMatcherIF<T>, public BinaryTree<Serializea
  virtual ReturnValue_t cleanUpElement(iterator position) { return HasReturnvaluesIF::RETURN_OK; }

  bool matchSubtree(iterator iter, T number) {
-    if (iter == nullptr) {
-      return false;
-    }
    bool isMatch = iter->match(number);
    if (isMatch) {
      if (iter.left() == this->end()) {
@@ -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) override {
+  bool match(T input) {
    if (inverted) {
      return !doMatch(input);
    } else {
@@ -1,6 +1,6 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
-    CommandMessage.cpp
-    CommandMessageCleaner.cpp
-    MessageQueueMessage.cpp
-    MessageQueueBase.cpp
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		CommandMessage.cpp
+		CommandMessageCleaner.cpp
+		MessageQueueMessage.cpp
 )
@@ -1,54 +0,0 @@
-#include "MessageQueueBase.h"
-
-MessageQueueBase::MessageQueueBase(MessageQueueId_t id, MessageQueueId_t defaultDest, MqArgs* args)
-    : id(id) {
-  this->defaultDest = defaultDest;
-  if (args != nullptr) {
-    this->args = *args;
-  }
-}
-
-MessageQueueBase::~MessageQueueBase() {}
-
-ReturnValue_t MessageQueueBase::sendToDefault(MessageQueueMessageIF* message) {
-  return sendToDefaultFrom(message, this->getId(), false);
-}
-
-ReturnValue_t MessageQueueBase::reply(MessageQueueMessageIF* message) {
-  if (this->last != MessageQueueIF::NO_QUEUE) {
-    return sendMessageFrom(this->last, message, this->getId());
-  } else {
-    return NO_REPLY_PARTNER;
-  }
-}
-
-ReturnValue_t MessageQueueBase::receiveMessage(MessageQueueMessageIF* message,
-                                               MessageQueueId_t* receivedFrom) {
-  ReturnValue_t status = this->receiveMessage(message);
-  *receivedFrom = this->last;
-  return status;
-}
-
-MessageQueueId_t MessageQueueBase::getLastPartner() const { return last; }
-
-MessageQueueId_t MessageQueueBase::getId() const { return id; }
-
-MqArgs& MessageQueueBase::getMqArgs() { return args; }
-
-void MessageQueueBase::setDefaultDestination(MessageQueueId_t defaultDestination) {
-  this->defaultDest = defaultDestination;
-}
-
-MessageQueueId_t MessageQueueBase::getDefaultDestination() const { return defaultDest; }
-
-bool MessageQueueBase::isDefaultDestinationSet() const { return (defaultDest != NO_QUEUE); }
-
-ReturnValue_t MessageQueueBase::sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
-                                            bool ignoreFault) {
-  return sendMessageFrom(sendTo, message, this->getId(), false);
-}
-
-ReturnValue_t MessageQueueBase::sendToDefaultFrom(MessageQueueMessageIF* message,
-                                                  MessageQueueId_t sentFrom, bool ignoreFault) {
-  return sendMessageFrom(defaultDest, message, sentFrom, ignoreFault);
-}
@@ -1,40 +0,0 @@
-#ifndef FSFW_SRC_FSFW_IPC_MESSAGEQUEUEBASE_H_
-#define FSFW_SRC_FSFW_IPC_MESSAGEQUEUEBASE_H_
-
-#include <fsfw/ipc/MessageQueueIF.h>
-#include <fsfw/ipc/definitions.h>
-
-class MessageQueueBase : public MessageQueueIF {
- public:
-  MessageQueueBase(MessageQueueId_t id, MessageQueueId_t defaultDest, MqArgs* mqArgs);
-  virtual ~MessageQueueBase();
-
-  // Default implementations for MessageQueueIF where possible
-  virtual MessageQueueId_t getLastPartner() const override;
-  virtual MessageQueueId_t getId() const override;
-  virtual MqArgs& getMqArgs() override;
-  virtual void setDefaultDestination(MessageQueueId_t defaultDestination) override;
-  virtual MessageQueueId_t getDefaultDestination() const override;
-  virtual bool isDefaultDestinationSet() const override;
-  virtual ReturnValue_t sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
-                                    bool ignoreFault) override;
-  virtual ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
-  virtual ReturnValue_t reply(MessageQueueMessageIF* message) override;
-  virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
-                                       MessageQueueId_t* receivedFrom) override;
-  virtual ReturnValue_t sendToDefaultFrom(MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-                                          bool ignoreFault = false) override;
-
-  // OSAL specific, forward the abstract function
-  virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) = 0;
-  virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
-                                        MessageQueueId_t sentFrom, bool ignoreFault = false) = 0;
-
- protected:
-  MessageQueueId_t id = MessageQueueIF::NO_QUEUE;
-  MessageQueueId_t last = MessageQueueIF::NO_QUEUE;
-  MessageQueueId_t defaultDest = MessageQueueIF::NO_QUEUE;
-  MqArgs args = {};
-};
-
-#endif /* FSFW_SRC_FSFW_IPC_MESSAGEQUEUEBASE_H_ */
@@ -1,8 +1,6 @@
 #ifndef FSFW_IPC_MESSAGEQUEUEIF_H_
 #define FSFW_IPC_MESSAGEQUEUEIF_H_

-#include <fsfw/ipc/definitions.h>
-
 #include <cstdint>

 #include "../returnvalues/HasReturnvaluesIF.h"
@@ -46,8 +44,8 @@ class MessageQueueIF {
  virtual ReturnValue_t reply(MessageQueueMessageIF* message) = 0;

  /**
-   * @brief	This function reads available messages from the message queue and returns the
-   * sender.
+   * @brief	This function reads available messages from the message queue
+   *          and returns the sender.
   * @details
   * It works identically to the other receiveMessage call, but in addition
   * returns the sender's queue id.
@@ -80,16 +78,19 @@ class MessageQueueIF {
   */
  virtual ReturnValue_t flush(uint32_t* count) = 0;
  /**
-   * @brief	This method returns the message queue ID of the last communication partner.
+   * @brief	This method returns the message queue
+   *          id of the last communication partner.
   */
  virtual MessageQueueId_t getLastPartner() const = 0;
  /**
-   * @brief	This method returns the message queue ID  of this class's message queue.
+   * @brief	This method returns the message queue
+   *          id of this class's message queue.
   */
  virtual MessageQueueId_t getId() const = 0;

  /**
-   * @brief	With the sendMessage call, a queue message is sent to a receiving queue.
+   * @brief	With the sendMessage call, a queue message
+   *          is sent to a receiving queue.
   * @details
   * This method takes the message provided, adds the sentFrom information
   * and passes it on to the destination provided with an operating system
@@ -128,7 +129,8 @@ class MessageQueueIF {
                                    bool ignoreFault = false) = 0;

  /**
-   * @brief	The sendToDefaultFrom method sends a queue message to the default destination.
+   * @brief	The sendToDefaultFrom method sends a queue message
+   *          to the default destination.
   * @details
   * In all other aspects, it works identical to the sendMessage method.
   * @param message
@@ -162,8 +164,6 @@ class MessageQueueIF {
  virtual MessageQueueId_t getDefaultDestination() const = 0;

  virtual bool isDefaultDestinationSet() const = 0;
-
-  virtual MqArgs& getMqArgs() = 0;
 };

 #endif /* FSFW_IPC_MESSAGEQUEUEIF_H_ */
@@ -5,7 +5,6 @@

 #include "MessageQueueIF.h"
 #include "MessageQueueMessage.h"
-#include "definitions.h"

 /**
 * Creates message queues.
@@ -23,8 +22,7 @@ class QueueFactory {
  static QueueFactory* instance();

  MessageQueueIF* createMessageQueue(uint32_t messageDepth = 3,
-                                     size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE,
-                                     MqArgs* args = nullptr);
+                                     size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);

  void deleteMessageQueue(MessageQueueIF* queue);

@@ -1,14 +0,0 @@
-#ifndef FSFW_SRC_FSFW_IPC_DEFINITIONS_H_
-#define FSFW_SRC_FSFW_IPC_DEFINITIONS_H_
-
-#include <fsfw/objectmanager/SystemObjectIF.h>
-#include <fsfw/objectmanager/frameworkObjects.h>
-
-struct MqArgs {
-  MqArgs(){};
-  MqArgs(object_id_t objectId, void* args = nullptr) : objectId(objectId), args(args) {}
-  object_id_t objectId = objects::NO_OBJECT;
-  void* args = nullptr;
-};
-
-#endif /* FSFW_SRC_FSFW_IPC_DEFINITIONS_H_ */
@@ -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,6 +46,7 @@ class MonitoringReportContent : public SerialLinkedListAdapter<SerializeIF> {
        limitValue(0),
        oldState(0),
        newState(0),
+        rawTimestamp({0}),
        timestampSerializer(rawTimestamp, sizeof(rawTimestamp)),
        timeStamper(NULL) {
    setAllNext();
@@ -48,9 +48,9 @@ class SystemObject : public SystemObjectIF {
  virtual ~SystemObject();
  object_id_t getObjectId() const override;
  virtual ReturnValue_t initialize() override;
-  virtual ReturnValue_t checkObjectConnections() override;
+  virtual ReturnValue_t checkObjectConnections();

-  virtual void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const override;
+  virtual void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const;
 };

 #endif /* FSFW_OBJECTMANAGER_SYSTEMOBJECT_H_ */
@@ -19,8 +19,6 @@
 #include <ws2tcpip.h>
 #elif defined(PLATFORM_UNIX)
 #include <netdb.h>
-
-#include <utility>
 #endif

 const std::string TcpTmTcServer::DEFAULT_SERVER_PORT = tcpip::DEFAULT_SERVER_PORT;
@@ -31,7 +29,7 @@ TcpTmTcServer::TcpTmTcServer(object_id_t objectId, object_id_t tmtcTcpBridge,
    : SystemObject(objectId),
      tmtcBridgeId(tmtcTcpBridge),
      receptionMode(receptionMode),
-      tcpConfig(std::move(customTcpServerPort)),
+      tcpConfig(customTcpServerPort),
      receptionBuffer(receptionBufferSize),
      ringBuffer(ringBufferSize, true) {}

@@ -105,7 +103,7 @@ ReturnValue_t TcpTmTcServer::initialize() {

 TcpTmTcServer::~TcpTmTcServer() { closeSocket(listenerTcpSocket); }

-[[noreturn]] ReturnValue_t TcpTmTcServer::performOperation(uint8_t opCode) {
+ReturnValue_t TcpTmTcServer::performOperation(uint8_t opCode) {
  using namespace tcpip;
  // If a connection is accepted, the corresponding socket will be assigned to the new socket
  socket_t connSocket = 0;
@@ -140,6 +138,7 @@ TcpTmTcServer::~TcpTmTcServer() { closeSocket(listenerTcpSocket); }
    closeSocket(connSocket);
    connSocket = 0;
  }
+  return HasReturnvaluesIF::RETURN_OK;
 }

 ReturnValue_t TcpTmTcServer::initializeAfterTaskCreation() {
@@ -160,7 +159,7 @@ void TcpTmTcServer::handleServerOperation(socket_t& connSocket) {
 #endif

  while (true) {
-    ssize_t retval = recv(connSocket, reinterpret_cast<char*>(receptionBuffer.data()),
+    int retval = recv(connSocket, reinterpret_cast<char*>(receptionBuffer.data()),
                      receptionBuffer.capacity(), tcpConfig.tcpFlags);
    if (retval == 0) {
      size_t availableReadData = ringBuffer.getAvailableReadData();
@@ -253,17 +252,17 @@ ReturnValue_t TcpTmTcServer::handleTcReception(uint8_t* spacePacket, size_t pack
  return result;
 }

-const std::string& TcpTmTcServer::getTcpPort() const { return tcpConfig.tcpPort; }
+std::string TcpTmTcServer::getTcpPort() const { return tcpConfig.tcpPort; }

-void TcpTmTcServer::setSpacePacketParsingOptions(std::vector<uint16_t> validPacketIds_) {
-  this->validPacketIds = std::move(validPacketIds_);
+void TcpTmTcServer::setSpacePacketParsingOptions(std::vector<uint16_t> validPacketIds) {
+  this->validPacketIds = validPacketIds;
 }

 TcpTmTcServer::TcpConfig& TcpTmTcServer::getTcpConfigStruct() { return tcpConfig; }

 ReturnValue_t TcpTmTcServer::handleTmSending(socket_t connSocket, bool& tmSent) {
  // Access to the FIFO is mutex protected because it is filled by the bridge
-  MutexGuard mg(tmtcBridge->mutex, tmtcBridge->timeoutType, tmtcBridge->mutexTimeoutMs);
+  MutexGuard(tmtcBridge->mutex, tmtcBridge->timeoutType, tmtcBridge->mutexTimeoutMs);
  store_address_t storeId;
  while ((not tmtcBridge->tmFifo->empty()) and
         (tmtcBridge->packetSentCounter < tmtcBridge->sentPacketsPerCycle)) {
@@ -284,7 +283,7 @@ ReturnValue_t TcpTmTcServer::handleTmSending(socket_t connSocket, bool& tmSent)
 #endif
      arrayprinter::print(storeAccessor.data(), storeAccessor.size());
    }
-    ssize_t retval = send(connSocket, reinterpret_cast<const char*>(storeAccessor.data()),
+    int retval = send(connSocket, reinterpret_cast<const char*>(storeAccessor.data()),
                      storeAccessor.size(), tcpConfig.tcpTmFlags);
    if (retval == static_cast<int>(storeAccessor.size())) {
      // Packet sent, clear FIFO entry
@@ -340,9 +339,6 @@ ReturnValue_t TcpTmTcServer::handleTcRingBufferData(size_t availableReadData) {
  size_t foundSize = 0;
  size_t readLen = 0;
  while (readLen < readAmount) {
-    if(spacePacketParser == nullptr) {
-      return HasReturnvaluesIF::RETURN_FAILED;
-    }
    result =
        spacePacketParser->parseSpacePackets(bufPtrPtr, readAmount, startIdx, foundSize, readLen);
    switch (result) {
@@ -17,7 +17,6 @@
 #endif

 #include <string>
-#include <utility>
 #include <vector>

 class TcpTmTcBridge;
@@ -45,7 +44,7 @@ class TcpTmTcServer : public SystemObject, public TcpIpBase, public ExecutableOb

  struct TcpConfig {
   public:
-    explicit TcpConfig(std::string tcpPort) : tcpPort(std::move(tcpPort)) {}
+    TcpConfig(std::string tcpPort) : tcpPort(tcpPort) {}

    /**
     * Passed to the recv call
@@ -85,7 +84,7 @@ class TcpTmTcServer : public SystemObject, public TcpIpBase, public ExecutableOb
                size_t ringBufferSize = RING_BUFFER_SIZE,
                std::string customTcpServerPort = DEFAULT_SERVER_PORT,
                ReceptionModes receptionMode = ReceptionModes::SPACE_PACKETS);
-  ~TcpTmTcServer() override;
+  virtual ~TcpTmTcServer();

  void enableWiretapping(bool enable);

@@ -98,10 +97,10 @@ class TcpTmTcServer : public SystemObject, public TcpIpBase, public ExecutableOb
  void setSpacePacketParsingOptions(std::vector<uint16_t> validPacketIds);

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

-  [[nodiscard]] const std::string& getTcpPort() const;
+  std::string getTcpPort() const;

 protected:
  StorageManagerIF* tcStore = nullptr;
@@ -116,7 +115,7 @@ class TcpTmTcServer : public SystemObject, public TcpIpBase, public ExecutableOb

  ReceptionModes receptionMode;
  TcpConfig tcpConfig;
-  struct sockaddr tcpAddress = {};
+  struct sockaddr tcpAddress;
  socket_t listenerTcpSocket = 0;

  MessageQueueId_t targetTcDestination = MessageQueueIF::NO_QUEUE;
@@ -16,13 +16,11 @@
 //! 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 (maxRecvSize > 0) {
-    this->frameSize = maxRecvSize;
+  if (frameSize > 0) {
+    this->frameSize = frameSize;
  } else {
    this->frameSize = DEFAULT_MAX_RECV_SIZE;
  }
@@ -33,20 +31,22 @@ UdpTcPollingTask::UdpTcPollingTask(object_id_t objectId, object_id_t tmtcUdpBrid
  receptionBuffer.resize(this->frameSize);

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

-[[noreturn]] ReturnValue_t UdpTcPollingTask::performOperation(uint8_t opCode) {
+UdpTcPollingTask::~UdpTcPollingTask() {}
+
+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) {
-    ssize_t bytesReceived =
+    int bytesReceived =
        recvfrom(this->serverSocket, reinterpret_cast<char*>(receptionBuffer.data()), frameSize,
                 receptionFlags, &senderAddress, &senderAddressSize);
    if (bytesReceived == SOCKET_ERROR) {
@@ -70,6 +70,7 @@ UdpTcPollingTask::UdpTcPollingTask(object_id_t objectId, object_id_t tmtcUdpBrid
    }
    tmtcBridge->checkAndSetClientAddress(senderAddress);
  }
+  return HasReturnvaluesIF::RETURN_OK;
 }

 ReturnValue_t UdpTcPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
@@ -154,7 +155,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) {
@@ -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 const timeval DEFAULT_TIMEOUT;
+  static constexpr timeval DEFAULT_TIMEOUT = {0, 500};

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

  /**
   * 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);

-  [[noreturn]] ReturnValue_t performOperation(uint8_t opCode) override;
-  ReturnValue_t initialize() override;
-  ReturnValue_t initializeAfterTaskCreation() override;
+  virtual ReturnValue_t performOperation(uint8_t opCode) override;
+  virtual ReturnValue_t initialize() override;
+  virtual 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);
 };
@@ -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,
-                             const std::string& udpServerPort_, object_id_t tmStoreId,
+                             std::string udpServerPort, object_id_t tmStoreId,
                             object_id_t tcStoreId)
    : TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
-  if (udpServerPort_.empty()) {
-    udpServerPort = DEFAULT_SERVER_PORT;
+  if (udpServerPort == "") {
+    this->udpServerPort = DEFAULT_SERVER_PORT;
  } else {
-    udpServerPort = udpServerPort_;
+    this->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

-  ssize_t bytesSent = sendto(serverSocket, reinterpret_cast<const char *>(data), dataLen, flags,
+  int 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) {
-  timeoutType = timeoutType_;
-  mutexTimeoutMs = timeoutMs;
+void UdpTmTcBridge::setMutexProperties(MutexIF::TimeoutType timeoutType, dur_millis_t timeoutMs) {
+  this->timeoutType = timeoutType;
+  this->mutexTimeoutMs = timeoutMs;
 }
@@ -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, const std::string& udpServerPort = "",
+  UdpTmTcBridge(object_id_t objectId, object_id_t tcDestination, std::string udpServerPort = "",
                object_id_t tmStoreId = objects::TM_STORE,
                object_id_t tcStoreId = objects::TC_STORE);
-  ~UdpTmTcBridge() override;
+  virtual ~UdpTmTcBridge();

  /**
   * Set properties of internal mutex.
@@ -46,12 +46,12 @@ class UdpTmTcBridge : public TmTcBridge, public TcpIpBase {
  std::string getUdpPort() const;

 protected:
-  ReturnValue_t sendTm(const uint8_t* data, size_t dataLen) override;
+  virtual 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.
@@ -11,6 +11,9 @@
 // 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) {
@@ -4,9 +4,8 @@
 #include "fsfw/osal/freertos/QueueMapManager.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"

-MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize, MqArgs* args)
-    : MessageQueueBase(MessageQueueIF::NO_QUEUE, MessageQueueIF::NO_QUEUE, args),
-      maxMessageSize(maxMessageSize) {
+MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize)
+    : maxMessageSize(maxMessageSize) {
  handle = xQueueCreate(messageDepth, maxMessageSize);
  if (handle == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -16,10 +15,10 @@ MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize, MqArgs* a
 #else
    sif::printError("MessageQueue::MessageQueue: Creation failed\n");
    sif::printError("Specified Message Depth: %d\n", messageDepth);
-    sif::printError("Specified Maximum Message Size: %d\n", maxMessageSize);
+    sif::printError("Specified MAximum Message Size: %d\n", maxMessageSize);
 #endif
  }
-  QueueMapManager::instance()->addMessageQueue(handle, &id);
+  QueueMapManager::instance()->addMessageQueue(handle, &queueId);
 }

 MessageQueue::~MessageQueue() {
@@ -30,6 +29,28 @@ MessageQueue::~MessageQueue() {

 void MessageQueue::switchSystemContext(CallContext callContext) { this->callContext = callContext; }

+ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
+                                        bool ignoreFault) {
+  return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
+}
+
+ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
+  return sendToDefaultFrom(message, this->getId());
+}
+
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
+                                              MessageQueueId_t sentFrom, bool ignoreFault) {
+  return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
+}
+
+ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
+  if (this->lastPartner != MessageQueueIF::NO_QUEUE) {
+    return sendMessageFrom(this->lastPartner, message, this->getId());
+  } else {
+    return NO_REPLY_PARTNER;
+  }
+}
+
 ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
                                            MessageQueueId_t sentFrom, bool ignoreFault) {
  return sendMessageFromMessageQueue(sendTo, message, sentFrom, ignoreFault, callContext);
@@ -51,16 +72,27 @@ ReturnValue_t MessageQueue::handleSendResult(BaseType_t result, bool ignoreFault
  return HasReturnvaluesIF::RETURN_OK;
 }

+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
+                                           MessageQueueId_t* receivedFrom) {
+  ReturnValue_t status = this->receiveMessage(message);
+  if (status == HasReturnvaluesIF::RETURN_OK) {
+    *receivedFrom = this->lastPartner;
+  }
+  return status;
+}
+
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
  BaseType_t result = xQueueReceive(handle, reinterpret_cast<void*>(message->getBuffer()), 0);
  if (result == pdPASS) {
-    this->last = message->getSender();
+    this->lastPartner = message->getSender();
    return HasReturnvaluesIF::RETURN_OK;
  } else {
    return MessageQueueIF::EMPTY;
  }
 }

+MessageQueueId_t MessageQueue::getLastPartner() const { return lastPartner; }
+
 ReturnValue_t MessageQueue::flush(uint32_t* count) {
  // TODO FreeRTOS does not support flushing partially
  // Is always successful
@@ -68,6 +100,17 @@ ReturnValue_t MessageQueue::flush(uint32_t* count) {
  return HasReturnvaluesIF::RETURN_OK;
 }

+MessageQueueId_t MessageQueue::getId() const { return queueId; }
+
+void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
+  defaultDestinationSet = true;
+  this->defaultDestination = defaultDestination;
+}
+
+MessageQueueId_t MessageQueue::getDefaultDestination() const { return defaultDestination; }
+
+bool MessageQueue::isDefaultDestinationSet() const { return defaultDestinationSet; }
+
 // static core function to send messages.
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
                                                        MessageQueueMessageIF* message,
@@ -1,15 +1,12 @@
 #ifndef FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_
 #define FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_

-#include <fsfw/ipc/MessageQueueBase.h>
-
 #include "FreeRTOS.h"
 #include "TaskManagement.h"
 #include "fsfw/internalerror/InternalErrorReporterIF.h"
 #include "fsfw/ipc/MessageQueueIF.h"
 #include "fsfw/ipc/MessageQueueMessage.h"
 #include "fsfw/ipc/MessageQueueMessageIF.h"
-#include "fsfw/ipc/definitions.h"
 #include "queue.h"

 /**
@@ -35,7 +32,7 @@
 * @ingroup osal
 * @ingroup message_queue
 */
-class MessageQueue : public MessageQueueBase {
+class MessageQueue : public MessageQueueIF {
  friend class MessageQueueSenderIF;

 public:
@@ -56,8 +53,7 @@ class MessageQueue : public MessageQueueBase {
   * This should be left default.
   */
  MessageQueue(size_t messageDepth = 3,
-               size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE,
-               MqArgs* args = nullptr);
+               size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);

  /** Copying message queues forbidden */
  MessageQueue(const MessageQueue&) = delete;
@@ -77,15 +73,40 @@ class MessageQueue : public MessageQueueBase {
   */
  void switchSystemContext(CallContext callContext);

-  QueueHandle_t getNativeQueueHandle();
+  /** MessageQueueIF implementation */
+  ReturnValue_t sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
+                            bool ignoreFault = false) override;

-  // Implement non-generic MessageQueueIF functions not handled by MessageQueueBase
+  ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
+
+  ReturnValue_t reply(MessageQueueMessageIF* message) override;
  virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
                                        MessageQueueId_t sentFrom = NO_QUEUE,
                                        bool ignoreFault = false) override;
+
+  virtual ReturnValue_t sendToDefaultFrom(MessageQueueMessageIF* message,
+                                          MessageQueueId_t sentFrom = NO_QUEUE,
+                                          bool ignoreFault = false) override;
+
+  ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
+                               MessageQueueId_t* receivedFrom) override;
+
  ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
+
  ReturnValue_t flush(uint32_t* count) override;

+  MessageQueueId_t getLastPartner() const override;
+
+  MessageQueueId_t getId() const override;
+
+  void setDefaultDestination(MessageQueueId_t defaultDestination) override;
+
+  MessageQueueId_t getDefaultDestination() const override;
+
+  bool isDefaultDestinationSet() const override;
+
+  QueueHandle_t getNativeQueueHandle();
+
 protected:
  /**
   * @brief 	Implementation to be called from any send Call within
@@ -115,8 +136,12 @@ class MessageQueue : public MessageQueueBase {
  static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);

 private:
+  bool defaultDestinationSet = false;
  QueueHandle_t handle;
+  MessageQueueId_t queueId = MessageQueueIF::NO_QUEUE;

+  MessageQueueId_t defaultDestination = MessageQueueIF::NO_QUEUE;
+  MessageQueueId_t lastPartner = MessageQueueIF::NO_QUEUE;
  const size_t maxMessageSize;
  //! Stores the current system context
  CallContext callContext = CallContext::TASK;
@@ -22,9 +22,8 @@ QueueFactory::QueueFactory() {}

 QueueFactory::~QueueFactory() {}

-MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth, size_t maxMessageSize,
-                                                 MqArgs* args) {
-  return new MessageQueue(messageDepth, maxMessageSize, args);
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth, size_t maxMessageSize) {
+  return new MessageQueue(messageDepth, maxMessageSize);
 }

 void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) { delete queue; }
@@ -1,27 +1,24 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
-  Clock.cpp
-  FixedTimeslotTask.cpp
-  MessageQueue.cpp
-  Mutex.cpp
-  MutexFactory.cpp
-  PeriodicTask.cpp
-  QueueFactory.cpp
-  QueueMapManager.cpp
-  SemaphoreFactory.cpp
-  TaskFactory.cpp
-  taskHelpers.cpp
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Clock.cpp
+		FixedTimeslotTask.cpp
+		MessageQueue.cpp
+		Mutex.cpp
+		MutexFactory.cpp
+		PeriodicTask.cpp
+		QueueFactory.cpp
+		QueueMapManager.cpp
+		SemaphoreFactory.cpp
+		TaskFactory.cpp
+		taskHelpers.cpp
 )

 if(UNIX)
-  find_package(Threads REQUIRED)
-
-  target_link_libraries(${LIB_FSFW_NAME} PRIVATE
-    ${CMAKE_THREAD_LIBS_INIT}
-  )
-  if(NOT APPLE)
-    target_link_libraries(${LIB_FSFW_NAME} PRIVATE
-      rt
-      )
-  endif()
-
+	find_package(Threads REQUIRED)
+	
+	target_link_libraries(${LIB_FSFW_NAME} 
+	PRIVATE
+		rt
+		${CMAKE_THREAD_LIBS_INIT}
+	)
 endif()
@@ -2,7 +2,6 @@

 #include <chrono>

-#include "fsfw/ipc/MutexGuard.h"
 #include "fsfw/platform.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"

@@ -12,6 +11,9 @@
 #include <fstream>
 #endif

+uint16_t Clock::leapSeconds = 0;
+MutexIF* Clock::timeMutex = NULL;
+
 using SystemClock = std::chrono::system_clock;

 uint32_t Clock::getTicksPerSecond(void) {
@@ -125,13 +127,6 @@ 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;
@@ -8,12 +8,10 @@
 #include "fsfw/osal/host/QueueMapManager.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"

-MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize, MqArgs* args)
-    : MessageQueueBase(MessageQueueIF::NO_QUEUE, MessageQueueIF::NO_QUEUE, args),
-      messageSize(maxMessageSize),
-      messageDepth(messageDepth) {
+MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize)
+    : messageSize(maxMessageSize), messageDepth(messageDepth) {
  queueLock = MutexFactory::instance()->createMutex();
-  auto result = QueueMapManager::instance()->addMessageQueue(this, &id);
+  auto result = QueueMapManager::instance()->addMessageQueue(this, &mqId);
  if (result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::error << "MessageQueue::MessageQueue: Could not be created" << std::endl;
@@ -25,11 +23,42 @@ MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize, MqArgs* a

 MessageQueue::~MessageQueue() { MutexFactory::instance()->deleteMutex(queueLock); }

+ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
+                                        bool ignoreFault) {
+  return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
+}
+
+ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
+  return sendToDefaultFrom(message, this->getId());
+}
+
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
+                                              MessageQueueId_t sentFrom, bool ignoreFault) {
+  return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
+}
+
+ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
+  if (this->lastPartner != MessageQueueIF::NO_QUEUE) {
+    return sendMessageFrom(this->lastPartner, message, this->getId());
+  } else {
+    return MessageQueueIF::NO_REPLY_PARTNER;
+  }
+}
+
 ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
                                            MessageQueueId_t sentFrom, bool ignoreFault) {
  return sendMessageFromMessageQueue(sendTo, message, sentFrom, ignoreFault);
 }

+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
+                                           MessageQueueId_t* receivedFrom) {
+  ReturnValue_t status = this->receiveMessage(message);
+  if (status == HasReturnvaluesIF::RETURN_OK) {
+    *receivedFrom = this->lastPartner;
+  }
+  return status;
+}
+
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
  if (messageQueue.empty()) {
    return MessageQueueIF::EMPTY;
@@ -39,10 +68,12 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
            message->getBuffer());
  messageQueue.pop();
  // The last partner is the first uint32_t field in the message
-  this->last = message->getSender();
+  this->lastPartner = message->getSender();
  return HasReturnvaluesIF::RETURN_OK;
 }

+MessageQueueId_t MessageQueue::getLastPartner() const { return lastPartner; }
+
 ReturnValue_t MessageQueue::flush(uint32_t* count) {
  *count = messageQueue.size();
  // Clears the queue.
@@ -50,6 +81,17 @@ ReturnValue_t MessageQueue::flush(uint32_t* count) {
  return HasReturnvaluesIF::RETURN_OK;
 }

+MessageQueueId_t MessageQueue::getId() const { return mqId; }
+
+void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
+  defaultDestinationSet = true;
+  this->defaultDestination = defaultDestination;
+}
+
+MessageQueueId_t MessageQueue::getDefaultDestination() const { return defaultDestination; }
+
+bool MessageQueue::isDefaultDestinationSet() const { return defaultDestinationSet; }
+
 // static core function to send messages.
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
                                                        MessageQueueMessageIF* message,
@@ -5,11 +5,9 @@
 #include <queue>

 #include "fsfw/internalerror/InternalErrorReporterIF.h"
-#include "fsfw/ipc/MessageQueueBase.h"
 #include "fsfw/ipc/MessageQueueIF.h"
 #include "fsfw/ipc/MessageQueueMessage.h"
 #include "fsfw/ipc/MutexIF.h"
-#include "fsfw/ipc/definitions.h"
 #include "fsfw/timemanager/Clock.h"

 /**
@@ -35,7 +33,7 @@
 * @ingroup osal
 * @ingroup message_queue
 */
-class MessageQueue : public MessageQueueBase {
+class MessageQueue : public MessageQueueIF {
  friend class MessageQueueSenderIF;

 public:
@@ -56,8 +54,7 @@ class MessageQueue : public MessageQueueBase {
   * This should be left default.
   */
  MessageQueue(size_t messageDepth = 3,
-               size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE,
-               MqArgs* args = nullptr);
+               size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);

  /** Copying message queues forbidden */
  MessageQueue(const MessageQueue&) = delete;
@@ -70,12 +67,121 @@ class MessageQueue : public MessageQueueBase {
   */
  virtual ~MessageQueue();

-  // Implement non-generic MessageQueueIF functions not handled by MessageQueueBase
+  /**
+   * @brief	This operation sends a message to the given destination.
+   * @details	It directly uses the sendMessage call of the MessageQueueSender
+   * parent, but passes its queue id as "sentFrom" parameter.
+   * @param sendTo	This parameter specifies the message queue id of the
+   *  destination message queue.
+   * @param message	A pointer to a previously created message, which is sent.
+   * @param ignoreFault If set to true, the internal software fault counter
+   * is not incremented if queue is full.
+   */
+  ReturnValue_t sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
+                            bool ignoreFault = false) override;
+  /**
+   * @brief	This operation sends a message to the default destination.
+   * @details	As in the sendMessage method, this function uses the
+   * sendToDefault call of the MessageQueueSender parent class and adds its
+   * queue id as "sentFrom" information.
+   * @param message	A pointer to a previously created message, which is sent.
+   */
+  ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
+  /**
+   * @brief	This operation sends a message to the last communication partner.
+   * @details	This operation simplifies answering an incoming message by using
+   * the stored lastPartner information as destination. If there was no
+   * message received yet (i.e. lastPartner is zero), an error code is returned.
+   * @param message	A pointer to a previously created message, which is sent.
+   */
+  ReturnValue_t reply(MessageQueueMessageIF* message) override;
+
+  /**
+   * @brief	With the sendMessage call, a queue message is sent to a
+   * 			receiving queue.
+   * @details
+   * This method takes the message provided, adds the sentFrom information and
+   * passes it on to the destination provided with an operating system call.
+   *  The OS's return value is returned.
+   * @param sendTo	This parameter specifies the message queue id to send
+   * the message to.
+   * @param message	This is a pointer to a previously created message,
+   * which is sent.
+   * @param sentFrom	The sentFrom information can be set to inject the
+   * sender's queue id into the message. This variable is set to zero by
+   * default.
+   * @param ignoreFault If set to true, the internal software fault counter
+   * is not incremented if queue is full.
+   */
  virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
                                        MessageQueueId_t sentFrom = NO_QUEUE,
                                        bool ignoreFault = false) override;
+
+  /**
+   * @brief	The sendToDefault method sends a queue message to the default
+   * 			destination.
+   * @details
+   * In all other aspects, it works identical to the sendMessage method.
+   * @param message	This is a pointer to a previously created message,
+   * which is sent.
+   * @param sentFrom	The sentFrom information can be set to inject the
+   * sender's queue id into the message. This variable is set to zero by
+   * default.
+   */
+  virtual ReturnValue_t sendToDefaultFrom(MessageQueueMessageIF* message,
+                                          MessageQueueId_t sentFrom = NO_QUEUE,
+                                          bool ignoreFault = false) override;
+
+  /**
+   * @brief	This function reads available messages from the message queue
+   * 			and returns the sender.
+   * @details
+   * It works identically to the other receiveMessage call, but in  addition
+   * returns the sender's queue id.
+   * @param message	A pointer to a message in which the received data is stored.
+   * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
+   */
+  ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
+                               MessageQueueId_t* receivedFrom) override;
+
+  /**
+   * @brief	This function reads available messages from the message queue.
+   * @details
+   * If data is available it is stored in the passed message pointer.
+   * The message's original content is overwritten and the sendFrom
+   * information is stored in the lastPartner attribute. Else, the lastPartner
+   * information remains untouched, the message's content is cleared and the
+   * function returns immediately.
+   * @param message	A pointer to a message in which the received data is stored.
+   */
  ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
+  /**
+   * Deletes all pending messages in the queue.
+   * @param count The number of flushed messages.
+   * @return RETURN_OK on success.
+   */
  ReturnValue_t flush(uint32_t* count) override;
+  /**
+   * @brief	This method returns the message queue id of the last
+   * 			communication partner.
+   */
+  MessageQueueId_t getLastPartner() const override;
+  /**
+   * @brief	This method returns the message queue id of this class's
+   * 			message queue.
+   */
+  MessageQueueId_t getId() const override;
+
+  /**
+   * @brief	This method is a simple setter for the default destination.
+   */
+  void setDefaultDestination(MessageQueueId_t defaultDestination) override;
+  /**
+   * @brief	This method is a simple getter for the default destination.
+   */
+  MessageQueueId_t getDefaultDestination() const override;
+
+  bool isDefaultDestinationSet() const override;

  ReturnValue_t lockQueue(MutexIF::TimeoutType timeoutType, dur_millis_t lockTimeout);
  ReturnValue_t unlockQueue();
@@ -105,14 +211,23 @@ class MessageQueue : public MessageQueueBase {
                                                   MessageQueueId_t sentFrom = NO_QUEUE,
                                                   bool ignoreFault = false);

+  // static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
+
 private:
  std::queue<std::vector<uint8_t>> messageQueue;
+  /**
+   * @brief	The class stores the queue id it got assigned.
+   * 			If initialization fails, the queue id is set to zero.
+   */
+  MessageQueueId_t mqId = MessageQueueIF::NO_QUEUE;
  size_t messageSize = 0;
  size_t messageDepth = 0;

  MutexIF* queueLock;

+  bool defaultDestinationSet = false;
  MessageQueueId_t defaultDestination = MessageQueueIF::NO_QUEUE;
+  MessageQueueId_t lastPartner = MessageQueueIF::NO_QUEUE;
 };

 #endif /* FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_ */
@@ -27,13 +27,12 @@ QueueFactory::QueueFactory() {}

 QueueFactory::~QueueFactory() {}

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

 void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) { delete queue; }
@@ -1,29 +1,29 @@
 target_sources(${LIB_FSFW_NAME} PRIVATE
-  Clock.cpp
-  BinarySemaphore.cpp
-  CountingSemaphore.cpp
-  FixedTimeslotTask.cpp
-  InternalErrorCodes.cpp
-  MessageQueue.cpp
-  Mutex.cpp
-  MutexFactory.cpp
-  PeriodicPosixTask.cpp
-  PosixThread.cpp
-  QueueFactory.cpp
-  SemaphoreFactory.cpp
-  TaskFactory.cpp
-  tcpipHelpers.cpp
-  unixUtility.cpp
-  )
+    Clock.cpp
+	BinarySemaphore.cpp
+	CountingSemaphore.cpp
+	FixedTimeslotTask.cpp
+	InternalErrorCodes.cpp
+	MessageQueue.cpp
+	Mutex.cpp
+	MutexFactory.cpp
+	PeriodicPosixTask.cpp
+	PosixThread.cpp
+	QueueFactory.cpp
+	SemaphoreFactory.cpp
+	TaskFactory.cpp
+	tcpipHelpers.cpp
+	unixUtility.cpp
+)

 find_package(Threads REQUIRED)

-target_link_libraries(${LIB_FSFW_NAME} PUBLIC
-  ${CMAKE_THREAD_LIBS_INIT}
-  )
+target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+	${CMAKE_THREAD_LIBS_INIT}
+	rt
+)
+
+target_link_libraries(${LIB_FSFW_NAME} INTERFACE
+	${CMAKE_THREAD_LIBS_INIT}
+)

-if(NOT APPLE)
-  target_link_libraries(${LIB_FSFW_NAME} PUBLIC
-    rt
-  )
-endif()
@@ -8,9 +8,11 @@

 #include <fstream>

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

+uint16_t Clock::leapSeconds = 0;
+MutexIF* Clock::timeMutex = NULL;
+
 uint32_t Clock::getTicksPerSecond(void) {
  uint32_t ticks = sysconf(_SC_CLK_TCK);
  return ticks;
@@ -115,13 +117,7 @@ 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;
@@ -11,10 +11,13 @@
 #include "fsfw/osal/linux/unixUtility.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"

-MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize, MqArgs* args)
-    : MessageQueueBase(MessageQueueIF::NO_QUEUE, MessageQueueIF::NO_QUEUE, args),
+MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize)
+    : id(MessageQueueIF::NO_QUEUE),
+      lastPartner(MessageQueueIF::NO_QUEUE),
+      defaultDestination(MessageQueueIF::NO_QUEUE),
      maxMessageSize(maxMessageSize) {
  mq_attr attributes;
+  this->id = 0;
  // Set attributes
  attributes.mq_curmsgs = 0;
  attributes.mq_maxmsg = messageDepth;
@@ -47,6 +50,30 @@ MessageQueue::~MessageQueue() {
  }
 }

+ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
+                                        bool ignoreFault) {
+  return sendMessageFrom(sendTo, message, this->getId(), false);
+}
+
+ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
+  return sendToDefaultFrom(message, this->getId());
+}
+
+ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
+  if (this->lastPartner != 0) {
+    return sendMessageFrom(this->lastPartner, message, this->getId());
+  } else {
+    return NO_REPLY_PARTNER;
+  }
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
+                                           MessageQueueId_t* receivedFrom) {
+  ReturnValue_t status = this->receiveMessage(message);
+  *receivedFrom = this->lastPartner;
+  return status;
+}
+
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
  if (message == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -69,7 +96,7 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
  int status = mq_receive(id, reinterpret_cast<char*>(message->getBuffer()),
                          message->getMaximumMessageSize(), &messagePriority);
  if (status > 0) {
-    this->last = message->getSender();
+    this->lastPartner = message->getSender();
    // Check size of incoming message.
    if (message->getMessageSize() < message->getMinimumMessageSize()) {
      return HasReturnvaluesIF::RETURN_FAILED;
@@ -137,6 +164,8 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
  }
 }

+MessageQueueId_t MessageQueue::getLastPartner() const { return this->lastPartner; }
+
 ReturnValue_t MessageQueue::flush(uint32_t* count) {
  mq_attr attrib;
  int status = mq_getattr(id, &attrib);
@@ -183,11 +212,26 @@ ReturnValue_t MessageQueue::flush(uint32_t* count) {
  return HasReturnvaluesIF::RETURN_OK;
 }

+MessageQueueId_t MessageQueue::getId() const { return this->id; }
+
+void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
+  this->defaultDestination = defaultDestination;
+}
+
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
+                                              MessageQueueId_t sentFrom, bool ignoreFault) {
+  return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
+}
+
 ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
                                            MessageQueueId_t sentFrom, bool ignoreFault) {
  return sendMessageFromMessageQueue(sendTo, message, sentFrom, ignoreFault);
 }

+MessageQueueId_t MessageQueue::getDefaultDestination() const { return this->defaultDestination; }
+
+bool MessageQueue::isDefaultDestinationSet() const { return (defaultDestination != NO_QUEUE); }
+
 uint16_t MessageQueue::queueCounter = 0;

 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
@@ -196,9 +240,9 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
                                                        bool ignoreFault) {
  if (message == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "MessageQueue::sendMessageFromMessageQueue: Message is nullptr" << std::endl;
+    sif::error << "MessageQueue::sendMessageFromMessageQueue: Message is nullptr!" << std::endl;
 #else
-    sif::printError("MessageQueue::sendMessageFromMessageQueue: Message is nullptr\n");
+    sif::printError("MessageQueue::sendMessageFromMessageQueue: Message is nullptr!\n");
 #endif
    return HasReturnvaluesIF::RETURN_FAILED;
  }
@@ -212,7 +256,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
    if (!ignoreFault) {
      InternalErrorReporterIF* internalErrorReporter =
          ObjectManager::instance()->get<InternalErrorReporterIF>(objects::INTERNAL_ERROR_REPORTER);
-      if (internalErrorReporter != nullptr) {
+      if (internalErrorReporter != NULL) {
        internalErrorReporter->queueMessageNotSent();
      }
    }
@@ -1,13 +1,11 @@
 #ifndef FSFW_OSAL_LINUX_MESSAGEQUEUE_H_
 #define FSFW_OSAL_LINUX_MESSAGEQUEUE_H_

-#include <fsfw/ipc/MessageQueueBase.h>
 #include <mqueue.h>

 #include "fsfw/internalerror/InternalErrorReporterIF.h"
 #include "fsfw/ipc/MessageQueueIF.h"
 #include "fsfw/ipc/MessageQueueMessage.h"
-#include "fsfw/ipc/definitions.h"
 /**
 * @brief		This class manages sending and receiving of message queue messages.
 *
@@ -27,7 +25,7 @@
 * makes use of the operating system calls provided.
 *	@ingroup message_queue
 */
-class MessageQueue : public MessageQueueBase {
+class MessageQueue : public MessageQueueIF {
  friend class MessageQueueSenderIF;

 public:
@@ -44,24 +42,104 @@ class MessageQueue : public MessageQueueBase {
   * 							This should be left default.
   */
  MessageQueue(uint32_t messageDepth = 3,
-               size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE,
-               MqArgs* args = nullptr);
-
-  /** Copying message queues forbidden */
-  MessageQueue(const MessageQueue&) = delete;
-  MessageQueue& operator=(const MessageQueue&) = delete;
-
+               size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);
  /**
   * @brief	The destructor deletes the formerly created message queue.
   * @details	This is accomplished by using the delete call provided by the operating system.
   */
  virtual ~MessageQueue();
+  /**
+   * @brief	This operation sends a message to the given destination.
+   * @details	It directly uses the sendMessage call of the MessageQueueSender parent, but passes
+   * its queue id as "sentFrom" parameter.
+   * @param sendTo	This parameter specifies the message queue id of the destination message
+   * queue.
+   * @param message	A pointer to a previously created message, which is sent.
+   * @param ignoreFault If set to true, the internal software fault counter is not incremented if
+   * queue is full.
+   */
+  virtual ReturnValue_t sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
+                                    bool ignoreFault = false);
+  /**
+   * @brief	This operation sends a message to the default destination.
+   * @details	As in the sendMessage method, this function uses the sendToDefault call of the
+   * 			MessageQueueSender parent class and adds its queue id as "sentFrom"
+   * information.
+   * @param message	A pointer to a previously created message, which is sent.
+   */
+  virtual ReturnValue_t sendToDefault(MessageQueueMessageIF* message);
+  /**
+   * @brief	This operation sends a message to the last communication partner.
+   * @details	This operation simplifies answering an incoming message by using the stored
+   * 			lastParnter information as destination. If there was no message received yet
+   * 			(i.e. lastPartner is zero), an error code is returned.
+   * @param message	A pointer to a previously created message, which is sent.
+   */
+  ReturnValue_t reply(MessageQueueMessageIF* message);

-  // Implement non-generic MessageQueueIF functions not handled by MessageQueueBase
-  ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
-  ReturnValue_t flush(uint32_t* count) override;
-  ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
-                                MessageQueueId_t sentFrom, bool ignoreFault = false) override;
+  /**
+   * @brief	This function reads available messages from the message queue and returns the
+   * sender.
+   * @details	It works identically to the other receiveMessage call, but in addition returns the
+   * 			sender's queue id.
+   * @param message	A pointer to a message in which the received data is stored.
+   * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
+   */
+  ReturnValue_t receiveMessage(MessageQueueMessageIF* message, MessageQueueId_t* receivedFrom);
+
+  /**
+   * @brief	This function reads available messages from the message queue.
+   * @details	If data is available it is stored in the passed message pointer. The message's
+   * 			original content is overwritten and the sendFrom information is stored in
+   * the lastPartner attribute. Else, the lastPartner information remains untouched, the message's
+   * content is cleared and the function returns immediately.
+   * @param message	A pointer to a message in which the received data is stored.
+   */
+  ReturnValue_t receiveMessage(MessageQueueMessageIF* message);
+  /**
+   * Deletes all pending messages in the queue.
+   * @param count The number of flushed messages.
+   * @return RETURN_OK on success.
+   */
+  ReturnValue_t flush(uint32_t* count);
+  /**
+   * @brief	This method returns the message queue id of the last communication partner.
+   */
+  MessageQueueId_t getLastPartner() const;
+  /**
+   * @brief	This method returns the message queue id of this class's message queue.
+   */
+  MessageQueueId_t getId() const;
+  /**
+   * \brief	With the sendMessage call, a queue message is sent to a receiving queue.
+   * \param sendTo	This parameter specifies the message queue id to send the message to.
+   * \param message	This is a pointer to a previously created message, which is sent.
+   * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the
+   * message. This variable is set to zero by default. \param ignoreFault If set to true, the
+   * internal software fault counter is not incremented if queue is full.
+   */
+  virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
+                                        MessageQueueId_t sentFrom, bool ignoreFault = false);
+  /**
+   * \brief	The sendToDefault method sends a queue message to the default destination.
+   * \details	In all other aspects, it works identical to the sendMessage method.
+   * \param message	This is a pointer to a previously created message, which is sent.
+   * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the
+   * message. This variable is set to zero by default.
+   */
+  virtual ReturnValue_t sendToDefaultFrom(MessageQueueMessageIF* message,
+                                          MessageQueueId_t sentFrom = NO_QUEUE,
+                                          bool ignoreFault = false);
+  /**
+   * \brief	This method is a simple setter for the default destination.
+   */
+  void setDefaultDestination(MessageQueueId_t defaultDestination);
+  /**
+   * \brief	This method is a simple getter for the default destination.
+   */
+  MessageQueueId_t getDefaultDestination() const;
+
+  bool isDefaultDestinationSet() const;

 protected:
  /**
@@ -80,10 +158,31 @@ class MessageQueue : public MessageQueueBase {
                                                   bool ignoreFault = false);

 private:
+  /**
+   * @brief	The class stores the queue id it got assigned from the operating system in this
+   * attribute. If initialization fails, the queue id is set to zero.
+   */
+  MessageQueueId_t id;
+  /**
+   * @brief	In this attribute, the queue id of the last communication partner is stored
+   * 			to allow for replying.
+   */
+  MessageQueueId_t lastPartner;
+  /**
+   * @brief	The message queue's name -a user specific information for the operating system-  is
+   * 			generated automatically with the help of this static counter.
+   */
+  /**
+   * \brief	This attribute stores a default destination to send messages to.
+   * \details	It is stored to simplify sending to always-the-same receiver. The attribute may
+   * 			be set in the constructor or by a setter call to setDefaultDestination.
+   */
+  MessageQueueId_t defaultDestination;
+
  /**
   * The name of the message queue, stored for unlinking
   */
-  char name[16] = {};
+  char name[16];

  static uint16_t queueCounter;
  const size_t maxMessageSize;
@@ -28,9 +28,8 @@ QueueFactory::QueueFactory() {}

 QueueFactory::~QueueFactory() {}

-MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth, size_t maxMessageSize,
-                                                 MqArgs* args) {
-  return new MessageQueue(messageDepth, maxMessageSize, args);
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth, size_t maxMessageSize) {
+  return new MessageQueue(messageDepth, maxMessageSize);
 }

 void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) { delete queue; }
@@ -6,6 +6,9 @@
 #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);
@@ -6,9 +6,8 @@
 #include "fsfw/osal/rtems/RtemsBasic.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"

-MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size, MqArgs* args)
-    : MessageQueueBase(MessageQueueIF::NO_QUEUE, MessageQueueIF::NO_QUEUE, args),
-      internalErrorReporter(nullptr) {
+MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size)
+    : id(0), lastPartner(0), defaultDestination(NO_QUEUE), internalErrorReporter(nullptr) {
  rtems_name name = ('Q' << 24) + (queueCounter++ << 8);
  rtems_status_code status =
      rtems_message_queue_create(name, message_depth, max_message_size, 0, &(this->id));
@@ -17,19 +16,43 @@ MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size, MqArgs
    sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex << name << std::dec
               << " failed with status:" << (uint32_t)status << std::endl;
 #endif
-    this->id = MessageQueueIF::NO_QUEUE;
+    this->id = 0;
  }
 }

 MessageQueue::~MessageQueue() { rtems_message_queue_delete(id); }

+ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
+                                        bool ignoreFault) {
+  return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
+}
+
+ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
+  return sendToDefaultFrom(message, this->getId());
+}
+
+ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
+  if (this->lastPartner != 0) {
+    return sendMessage(this->lastPartner, message, this->getId());
+  } else {
+    return NO_REPLY_PARTNER;
+  }
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
+                                           MessageQueueId_t* receivedFrom) {
+  ReturnValue_t status = this->receiveMessage(message);
+  *receivedFrom = this->lastPartner;
+  return status;
+}
+
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
  size_t size = 0;
  rtems_status_code status =
      rtems_message_queue_receive(id, message->getBuffer(), &size, RTEMS_NO_WAIT, 1);
  if (status == RTEMS_SUCCESSFUL) {
    message->setMessageSize(size);
-    this->last = message->getSender();
+    this->lastPartner = message->getSender();
    // Check size of incoming message.
    if (message->getMessageSize() < message->getMinimumMessageSize()) {
      return HasReturnvaluesIF::RETURN_FAILED;
@@ -42,11 +65,19 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
  return convertReturnCode(status);
 }

+MessageQueueId_t MessageQueue::getLastPartner() const { return this->lastPartner; }
+
 ReturnValue_t MessageQueue::flush(uint32_t* count) {
  rtems_status_code status = rtems_message_queue_flush(id, count);
  return convertReturnCode(status);
 }

+MessageQueueId_t MessageQueue::getId() const { return this->id; }
+
+void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
+  this->defaultDestination = defaultDestination;
+}
+
 ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
                                            MessageQueueId_t sentFrom, bool ignoreFault) {
  message->setSender(sentFrom);
@@ -72,6 +103,15 @@ ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo, MessageQueu
  return returnCode;
 }

+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
+                                              MessageQueueId_t sentFrom, bool ignoreFault) {
+  return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
+}
+
+MessageQueueId_t MessageQueue::getDefaultDestination() const { return this->defaultDestination; }
+
+bool MessageQueue::isDefaultDestinationSet() const { return (defaultDestination != NO_QUEUE); }
+
 ReturnValue_t MessageQueue::convertReturnCode(rtems_status_code inValue) {
  switch (inValue) {
    case RTEMS_SUCCESSFUL:
@@ -1,13 +1,10 @@
 #ifndef FSFW_OSAL_RTEMS_MESSAGEQUEUE_H_
 #define FSFW_OSAL_RTEMS_MESSAGEQUEUE_H_

-#include <fsfw/ipc/MessageQueueBase.h>
-
 #include "RtemsBasic.h"
 #include "fsfw/internalerror/InternalErrorReporterIF.h"
 #include "fsfw/ipc/MessageQueueIF.h"
 #include "fsfw/ipc/MessageQueueMessage.h"
-#include "fsfw/ipc/definitions.h"

 /**
 *	@brief		This class manages sending and receiving of message queue messages.
@@ -22,7 +19,7 @@
 *as well as sending and receiving messages, the class makes use of the operating system calls
 *provided. \ingroup message_queue
 */
-class MessageQueue : public MessageQueueBase {
+class MessageQueue : public MessageQueueIF {
 public:
  /**
   * @brief	The constructor initializes and configures the message queue.
@@ -37,26 +34,131 @@ class MessageQueue : public MessageQueueBase {
   * 							This should be left default.
   */
  MessageQueue(size_t message_depth = 3,
-               size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE,
-               MqArgs* args = nullptr);
-
-  /** Copying message queues forbidden */
-  MessageQueue(const MessageQueue&) = delete;
-  MessageQueue& operator=(const MessageQueue&) = delete;
-
+               size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE);
  /**
   * @brief	The destructor deletes the formerly created message queue.
   * @details	This is accomplished by using the delete call provided by the operating system.
   */
  virtual ~MessageQueue();
+  /**
+   * @brief	This operation sends a message to the given destination.
+   * @details	It directly uses the sendMessage call of the MessageQueueSender parent, but passes
+   * its queue id as "sentFrom" parameter.
+   * @param sendTo	This parameter specifies the message queue id of the destination message
+   * queue.
+   * @param message	A pointer to a previously created message, which is sent.
+   * @param ignoreFault If set to true, the internal software fault counter is not incremented if
+   * queue is full.
+   */
+  ReturnValue_t sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
+                            bool ignoreFault = false);
+  /**
+   * @brief	This operation sends a message to the default destination.
+   * @details	As in the sendMessage method, this function uses the sendToDefault call of the
+   * 			MessageQueueSender parent class and adds its queue id as "sentFrom"
+   * information.
+   * @param message	A pointer to a previously created message, which is sent.
+   */
+  ReturnValue_t sendToDefault(MessageQueueMessageIF* message);
+  /**
+   * @brief	This operation sends a message to the last communication partner.
+   * @details	This operation simplifies answering an incoming message by using the stored
+   * 			lastParnter information as destination. If there was no message received yet
+   * 			(i.e. lastPartner is zero), an error code is returned.
+   * @param message	A pointer to a previously created message, which is sent.
+   */
+  ReturnValue_t reply(MessageQueueMessageIF* message);

-  // Implement non-generic MessageQueueIF functions not handled by MessageQueueBase
-  ReturnValue_t flush(uint32_t* count) override;
-  ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
-                                MessageQueueId_t sentFrom = NO_QUEUE,
-                                bool ignoreFault = false) override;
+  /**
+   * @brief	This function reads available messages from the message queue and returns the
+   * sender.
+   * @details	It works identically to the other receiveMessage call, but in addition returns the
+   * 			sender's queue id.
+   * @param message	A pointer to a message in which the received data is stored.
+   * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
+   */
+  ReturnValue_t receiveMessage(MessageQueueMessageIF* message, MessageQueueId_t* receivedFrom);
+
+  /**
+   * @brief	This function reads available messages from the message queue.
+   * @details	If data is available it is stored in the passed message pointer. The message's
+   * 			original content is overwritten and the sendFrom information is stored in
+   * the lastPartner attribute. Else, the lastPartner information remains untouched, the message's
+   * content is cleared and the function returns immediately.
+   * @param message	A pointer to a message in which the received data is stored.
+   */
+  ReturnValue_t receiveMessage(MessageQueueMessageIF* message);
+  /**
+   * Deletes all pending messages in the queue.
+   * @param count The number of flushed messages.
+   * @return RETURN_OK on success.
+   */
+  ReturnValue_t flush(uint32_t* count);
+  /**
+   * @brief	This method returns the message queue id of the last communication partner.
+   */
+  MessageQueueId_t getLastPartner() const;
+  /**
+   * @brief	This method returns the message queue id of this class's message queue.
+   */
+  MessageQueueId_t getId() const;
+  /**
+   * \brief	With the sendMessage call, a queue message is sent to a receiving queue.
+   * \details	This method takes the message provided, adds the sentFrom information and passes
+   * 			it on to the destination provided with an operating system call. The OS's
+   * return value is returned.
+   * \param sendTo	This parameter specifies the message queue id to send the message to.
+   * \param message	This is a pointer to a previously created message, which is sent.
+   * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the
+   * message. This variable is set to zero by default. \param ignoreFault If set to true, the
+   * internal software fault counter is not incremented if queue is full.
+   */
+  virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
+                                        MessageQueueId_t sentFrom = NO_QUEUE,
+                                        bool ignoreFault = false);
+  /**
+   * \brief	The sendToDefault method sends a queue message to the default destination.
+   * \details	In all other aspects, it works identical to the sendMessage method.
+   * \param message	This is a pointer to a previously created message, which is sent.
+   * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the
+   * message. This variable is set to zero by default.
+   */
+  virtual ReturnValue_t sendToDefaultFrom(MessageQueueMessageIF* message,
+                                          MessageQueueId_t sentFrom = NO_QUEUE,
+                                          bool ignoreFault = false);
+  /**
+   * \brief	This method is a simple setter for the default destination.
+   */
+  void setDefaultDestination(MessageQueueId_t defaultDestination);
+  /**
+   * \brief	This method is a simple getter for the default destination.
+   */
+  MessageQueueId_t getDefaultDestination() const;
+
+  bool isDefaultDestinationSet() const;

 private:
+  /**
+   * @brief	The class stores the queue id it got assigned from the operating system in this
+   * attribute. If initialization fails, the queue id is set to zero.
+   */
+  MessageQueueId_t id;
+  /**
+   * @brief	In this attribute, the queue id of the last communication partner is stored
+   * 			to allow for replying.
+   */
+  MessageQueueId_t lastPartner;
+  /**
+   * @brief	The message queue's name -a user specific information for the operating system-  is
+   * 			generated automatically with the help of this static counter.
+   */
+  /**
+   * \brief	This attribute stores a default destination to send messages to.
+   * \details	It is stored to simplify sending to always-the-same receiver. The attribute may
+   * 			be set in the constructor or by a setter call to setDefaultDestination.
+   */
+  MessageQueueId_t defaultDestination;
+
  /**
   * \brief	This attribute stores a reference to the internal error reporter for reporting full
   * queues. \details	In the event of a full destination queue, the reporter will be notified. The
@@ -49,9 +49,8 @@ QueueFactory::QueueFactory() {}

 QueueFactory::~QueueFactory() {}

-MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth, size_t maxMessageSize,
-                                                 MqArgs* args) {
-  return new MessageQueue(messageDepth, maxMessageSize, args);
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth, size_t maxMessageSize) {
+  return new MessageQueue(messageDepth, maxMessageSize);
 }

 void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) { delete queue; }
@@ -54,7 +54,7 @@ class Fuse : public SystemObject,

  ReturnValue_t check();
  uint8_t getFuseId() const;
-  ReturnValue_t initialize() override;
+  ReturnValue_t initialize();
  DeviceList devices;
  ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
                          SerializeIF::Endianness streamEndianness) const override;
@@ -13,6 +13,8 @@ CService201HealthCommanding::CService201HealthCommanding(object_id_t objectId, u
    : CommandingServiceBase(objectId, apid, serviceId, numParallelCommands, commandTimeoutSeconds) {
 }

+CService201HealthCommanding::~CService201HealthCommanding() {}
+
 ReturnValue_t CService201HealthCommanding::isValidSubservice(uint8_t subservice) {
  switch (subservice) {
    case (Subservice::COMMAND_SET_HEALTH):
@@ -41,8 +43,8 @@ ReturnValue_t CService201HealthCommanding::getMessageQueueAndObject(uint8_t subs
 }

 ReturnValue_t CService201HealthCommanding::checkInterfaceAndAcquireMessageQueue(
-    MessageQueueId_t *messageQueueToSet, const object_id_t *objectId) {
-  auto *destination = ObjectManager::instance()->get<HasHealthIF>(*objectId);
+    MessageQueueId_t *messageQueueToSet, object_id_t *objectId) {
+  HasHealthIF *destination = ObjectManager::instance()->get<HasHealthIF>(*objectId);
  if (destination == nullptr) {
    return CommandingServiceBase::INVALID_OBJECT;
  }
@@ -75,10 +77,6 @@ ReturnValue_t CService201HealthCommanding::prepareCommand(CommandMessage *messag
      HealthMessage::setHealthMessage(message, HealthMessage::HEALTH_ANNOUNCE_ALL);
      break;
    }
-    default: {
-      // Should never happen, subservice was already checked
-      result = RETURN_FAILED;
-    }
  }
  return result;
 }
@@ -97,9 +95,10 @@ ReturnValue_t CService201HealthCommanding::handleReply(const CommandMessage *rep
 }

 // Not used for now, health state already reported by event
-[[maybe_unused]] ReturnValue_t CService201HealthCommanding::prepareHealthSetReply(const CommandMessage *reply) {
-  auto health = static_cast<uint8_t>(HealthMessage::getHealth(reply));
-  auto oldHealth = static_cast<uint8_t>(HealthMessage::getOldHealth(reply));
+ReturnValue_t CService201HealthCommanding::prepareHealthSetReply(const CommandMessage *reply) {
+  prepareHealthSetReply(reply);
+  uint8_t health = static_cast<uint8_t>(HealthMessage::getHealth(reply));
+  uint8_t oldHealth = static_cast<uint8_t>(HealthMessage::getOldHealth(reply));
  HealthSetReply healthSetReply(health, oldHealth);
  return sendTmPacket(Subservice::REPLY_HEALTH_SET, &healthSetReply);
 }
@@ -1,7 +1,7 @@
 #ifndef FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_
 #define FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_

-#include "fsfw/tmtcservices/CommandingServiceBase.h"
+#include "../tmtcservices/CommandingServiceBase.h"

 /**
 * @brief   Custom PUS service to set health of all objects
@@ -21,7 +21,7 @@ class CService201HealthCommanding : public CommandingServiceBase {
 public:
  CService201HealthCommanding(object_id_t objectId, uint16_t apid, uint8_t serviceId,
                              uint8_t numParallelCommands = 4, uint16_t commandTimeoutSeconds = 60);
-  ~CService201HealthCommanding() override = default;
+  virtual ~CService201HealthCommanding();

 protected:
  /* CSB abstract function implementations */
@@ -38,10 +38,12 @@ class CService201HealthCommanding : public CommandingServiceBase {
                            bool *isStep) override;

 private:
-  static ReturnValue_t checkInterfaceAndAcquireMessageQueue(MessageQueueId_t *MessageQueueToSet,
-                                                     const object_id_t *objectId);
+  ReturnValue_t checkAndAcquireTargetID(object_id_t *objectIdToSet, const uint8_t *tcData,
+                                        size_t tcDataLen);
+  ReturnValue_t checkInterfaceAndAcquireMessageQueue(MessageQueueId_t *MessageQueueToSet,
+                                                     object_id_t *objectId);

-  [[maybe_unused]] ReturnValue_t prepareHealthSetReply(const CommandMessage *reply);
+  ReturnValue_t prepareHealthSetReply(const CommandMessage *reply);

  enum Subservice {
    //! [EXPORT] : [TC] Set health of target object
@@ -43,7 +43,7 @@ class Service3Housekeeping : public CommandingServiceBase, public AcceptsHkPacke
                            CommandMessage* optionalNextCommand, object_id_t objectId,
                            bool* isStep) override;

-  virtual MessageQueueId_t getHkQueue() const override;
+  virtual MessageQueueId_t getHkQueue() const;

 private:
  enum class Subservice {
@@ -30,11 +30,11 @@ ReturnValue_t Subsystem::checkSequence(HybridIterator<ModeListEntry> iter,
    return FALLBACK_SEQUENCE_DOES_NOT_EXIST;
  }

-  if (iter.value == nullptr) {
+  if (iter.value == NULL) {
    return NO_TARGET_TABLE;
  }

-  for (; iter.value != nullptr; ++iter) {
+  for (; iter.value != NULL; ++iter) {
    if (!existsModeTable(iter->getTableId())) {
      return TABLE_DOES_NOT_EXIST;
    } else {
@@ -66,18 +66,13 @@ HybridIterator<ModeListEntry> Subsystem::getCurrentTable() {
 void Subsystem::performChildOperation() {
  if (isInTransition) {
    if (commandsOutstanding <= 0) {  // all children of the current table were commanded and replied
-      if (currentSequenceIterator.value == nullptr) {  // we're through with this sequence
+      if (currentSequenceIterator.value == NULL) {  // we're through with this sequence
        if (checkStateAgainstTable(currentTargetTable, targetSubmode) == RETURN_OK) {
          setMode(targetMode, targetSubmode);
          isInTransition = false;
          return;
        } else {
-          Mode_t tableId = 0;
-          auto seq = getSequence(targetMode);
-          if (seq.value != nullptr) {
-            tableId = seq->getTableId();
-          }
-          transitionFailed(TARGET_TABLE_NOT_REACHED, tableId);
+          transitionFailed(TARGET_TABLE_NOT_REACHED, getSequence(targetMode)->getTableId());
          return;
        }
      }
@@ -253,13 +248,10 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage *message) {
    case ModeSequenceMessage::READ_TABLE: {
      ReturnValue_t result;
      Mode_t table = ModeSequenceMessage::getSequenceId(message);
-      EntryPointer *entry = nullptr;
+      EntryPointer *entry = NULL;
      result = modeTables.find(table, &entry);
-      if (result != RETURN_OK or entry == nullptr) {
+      if (result != RETURN_OK) {
        replyToCommand(result, 0);
-        if (entry == nullptr) {
-          return result;
-        }
      }

      SerializeIF *elements[2];
@@ -307,11 +299,6 @@ 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;
@@ -355,10 +342,6 @@ 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;
@@ -467,7 +450,6 @@ ReturnValue_t Subsystem::initialize() {
  }

  mode = initialMode;
-  submode = initSubmode;

  return RETURN_OK;
 }
@@ -605,10 +587,7 @@ ReturnValue_t Subsystem::checkObjectConnections() {
  return RETURN_OK;
 }

-void Subsystem::setInitialMode(Mode_t mode, Submode_t submode) {
-  this->initialMode = mode;
-  this->initSubmode = submode;
-}
+void Subsystem::setInitialMode(Mode_t mode) { initialMode = mode; }

 void Subsystem::cantKeepMode() {
  ReturnValue_t result;
@@ -1,37 +1,16 @@
 #ifndef FSFW_SUBSYSTEM_SUBSYSTEM_H_
 #define FSFW_SUBSYSTEM_SUBSYSTEM_H_

+#include <FSFWConfig.h>
+
 #include "../container/FixedArrayList.h"
 #include "../container/FixedMap.h"
 #include "../container/HybridIterator.h"
 #include "../container/SinglyLinkedList.h"
 #include "../serialize/SerialArrayListAdapter.h"
 #include "SubsystemBase.h"
-#include "fsfw/FSFW.h"
 #include "modes/ModeDefinitions.h"

-struct TableSequenceBase {
- public:
-  TableSequenceBase(Mode_t mode, ArrayList<ModeListEntry> *table) : mode(mode), table(table){};
-  Mode_t mode;
-  ArrayList<ModeListEntry> *table;
-  bool inStore = false;
-  bool preInit = true;
-};
-
-struct TableEntry : public TableSequenceBase {
- public:
-  TableEntry(Mode_t mode, ArrayList<ModeListEntry> *table) : TableSequenceBase(mode, table){};
-};
-
-struct SequenceEntry : public TableSequenceBase {
- public:
-  SequenceEntry(Mode_t mode, ArrayList<ModeListEntry> *table, Mode_t fallbackMode)
-      : TableSequenceBase(mode, table), fallbackMode(fallbackMode) {}
-
-  Mode_t fallbackMode;
-};
-
 /**
 * @brief   TODO: documentation missing
 * @details
@@ -66,15 +45,13 @@ 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, Submode_t submode = SUBMODE_NONE);
+  void setInitialMode(Mode_t mode);

  virtual ReturnValue_t initialize() override;

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

  Mode_t initialMode = 0;
-  Submode_t initSubmode = SUBMODE_NONE;

  HybridIterator<ModeListEntry> currentSequenceIterator;

@@ -151,18 +127,18 @@ class Subsystem : public SubsystemBase, public HasModeSequenceIF {

  ReturnValue_t deleteTable(Mode_t id);

-  virtual void performChildOperation() override;
+  virtual void performChildOperation();

-  virtual ReturnValue_t handleCommandMessage(CommandMessage *message) override;
+  virtual ReturnValue_t handleCommandMessage(CommandMessage *message);

  bool isFallbackSequence(Mode_t SequenceId);

  bool isTableUsed(Mode_t tableId);

  virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-                                         uint32_t *msToReachTheMode) override;
+                                         uint32_t *msToReachTheMode);

-  virtual void startTransition(Mode_t mode, Submode_t submode) override;
+  virtual void startTransition(Mode_t mode, Submode_t submode);

  void sendSerializablesAsCommandMessage(Command_t command, SerializeIF **elements, uint8_t count);

@@ -123,15 +123,15 @@ class SubsystemBase : public SystemObject,
  virtual void performChildOperation() = 0;

  virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-                                         uint32_t *msToReachTheMode) override = 0;
+                                         uint32_t *msToReachTheMode) = 0;

-  virtual void startTransition(Mode_t mode, Submode_t submode) override = 0;
+  virtual void startTransition(Mode_t mode, Submode_t submode) = 0;

-  virtual void getMode(Mode_t *mode, Submode_t *submode) override;
+  virtual void getMode(Mode_t *mode, Submode_t *submode);

-  virtual void setToExternalControl() override;
+  virtual void setToExternalControl();

-  virtual void announceMode(bool recursive) override;
+  virtual void announceMode(bool recursive);

  virtual void modeChanged();
 };
@@ -6,6 +6,10 @@

 #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) {
@@ -87,7 +91,7 @@ ReturnValue_t CCSDSTime::convertFromCDS(Clock::TimeOfDay_t* to, const uint8_t* f
  if (result != HasReturnvaluesIF::RETURN_OK) {
    return result;
  }
-  return Clock::convertTimevalToTimeOfDay(&time, to);
+  return convertTimevalToTimeOfDay(to, &time);
 }

 ReturnValue_t CCSDSTime::convertFromCCS(Clock::TimeOfDay_t* to, const uint8_t* from,
@@ -424,7 +428,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 != nullptr) {
+    if (foundLength != NULL) {
      *foundLength += 1;
    }
  }
@@ -485,6 +489,11 @@ 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;
@@ -574,7 +583,7 @@ ReturnValue_t CCSDSTime::convertFromCDS(Clock::TimeOfDay_t* to, const CCSDSTime:
  if (result != HasReturnvaluesIF::RETURN_OK) {
    return result;
  }
-  return Clock::convertTimevalToTimeOfDay(&tempTimeval, to);
+  return CCSDSTime::convertTimevalToTimeOfDay(to, &tempTimeval);
 }

 ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, uint8_t pField, const uint8_t* from,
@@ -584,18 +593,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 != nullptr) {
+  if (foundLength != NULL) {
    *foundLength = totalLength;
  }
  if (totalLength > maxLength) {
    return LENGTH_MISMATCH;
  }
-  for (int count = nCoarse; count > 0; count--) {
-    secs += *from << (count * 8 - 8);
+  for (int count = 0; count < nCoarse; count++) {
+    secs += *from << ((nCoarse * 8 - 8) * (1 + count));
    from++;
  }
-  for (int count = nFine; count > 0; count--) {
-    subSeconds += *from << (count * 8 - 8);
+  for (int count = 0; count < nFine; count++) {
+    subSeconds += *from << ((nFine * 8 - 8) * (1 + count));
    from++;
  }
  // Move to POSIX epoch.
@@ -161,37 +161,18 @@ 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);

@@ -211,8 +192,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
   *
@@ -242,6 +223,7 @@ 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_ */
@@ -99,13 +99,6 @@ class Clock {
   */
  static ReturnValue_t getDateAndTime(TimeOfDay_t *time);

-  /**
-   * Convert to time of day struct given the POSIX timeval struct
-   * @param from
-   * @param to
-   * @return
-   */
-  static ReturnValue_t convertTimevalToTimeOfDay(const timeval *from, TimeOfDay_t *to);
  /**
   * Converts a time of day struct to POSIX seconds.
   * @param time The time of day as input
@@ -173,7 +166,6 @@ class Clock {

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

 #endif /* FSFW_TIMEMANAGER_CLOCK_H_ */
@@ -1,13 +1,7 @@
-#include <ctime>
-
 #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) {
+ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval *tt) {
  uint16_t leapSeconds;
  ReturnValue_t result = getLeapSeconds(&leapSeconds);
  if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -33,16 +27,12 @@ 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 (not leapSecondsSet) {
-    return HasReturnvaluesIF::RETURN_FAILED;
-  }
-  if (checkOrCreateClockMutex() != HasReturnvaluesIF::RETURN_OK) {
+ReturnValue_t Clock::getLeapSeconds(uint16_t *leapSeconds_) {
+  if (timeMutex == nullptr) {
    return HasReturnvaluesIF::RETURN_FAILED;
  }
  MutexGuard helper(timeMutex);
@@ -52,32 +42,9 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
  return HasReturnvaluesIF::RETURN_OK;
 }

-ReturnValue_t Clock::convertTimevalToTimeOfDay(const timeval* from, TimeOfDay_t* to) {
-  struct tm* timeInfo;
-  // According to https://en.cppreference.com/w/c/chrono/gmtime, the implementation of gmtime_s
-  // in the Windows CRT is incompatible with the C standard but this should not be an issue for
-  // this implementation
-  ReturnValue_t result = checkOrCreateClockMutex();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
-    return result;
-  }
-  MutexGuard helper(timeMutex);
-  // gmtime writes its output in a global buffer which is not Thread Safe
-  // Therefore we have to use a Mutex here
-  timeInfo = gmtime(&from->tv_sec);
-  to->year = timeInfo->tm_year + 1900;
-  to->month = timeInfo->tm_mon + 1;
-  to->day = timeInfo->tm_mday;
-  to->hour = timeInfo->tm_hour;
-  to->minute = timeInfo->tm_min;
-  to->second = timeInfo->tm_sec;
-  to->usecond = from->tv_usec;
-  return HasReturnvaluesIF::RETURN_OK;
-}
-
 ReturnValue_t Clock::checkOrCreateClockMutex() {
  if (timeMutex == nullptr) {
-    MutexFactory* mutexFactory = MutexFactory::instance();
+    MutexFactory *mutexFactory = MutexFactory::instance();
    if (mutexFactory == nullptr) {
      return HasReturnvaluesIF::RETURN_FAILED;
    }
@@ -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->localData)) {
-    memcpy(this->localData.byteStream, p_Data, packet_size);
+  if (packet_size <= sizeof(this->data)) {
+    memcpy(&this->localData.byteStream, p_Data, packet_size);
    return true;
  } else {
    return false;
@@ -95,7 +95,7 @@ class CommandingServiceBase : public SystemObject,
   */
  virtual ReturnValue_t performOperation(uint8_t opCode) override;

-  virtual uint16_t getIdentifier() override;
+  virtual uint16_t getIdentifier();

  /**
   * Returns the requestQueue MessageQueueId_t
@@ -104,7 +104,7 @@ class CommandingServiceBase : public SystemObject,
   *
   * @return requestQueue messageQueueId_t
   */
-  virtual MessageQueueId_t getRequestQueue() override;
+  virtual MessageQueueId_t getRequestQueue();

  /**
   * Returns the commandQueue MessageQueueId_t
@@ -166,7 +166,7 @@ class CommandingServiceBase : public SystemObject,
   * @param objectId Target object ID
   * @return
   * - @c RETURN_OK to generate a verification start message
-   * - @c EXECUTION_COMPLETE Fire-and-forget command. Generate a completion
+   * - @c EXECUTION_COMPELTE Fire-and-forget command. Generate a completion
   *      verification message.
   * - @c Anything else rejects the packets and generates a start failure
   *      verification.
@@ -12,12 +12,24 @@
 #undef minor
 #endif

-const fsfw::Version fsfw::FSFW_VERSION = {FSFW_VERSION_MAJOR, FSFW_VERSION_MINOR,
-                                          FSFW_VERSION_REVISION};
+const Version fsfw::FSFW_VERSION = {FSFW_VERSION_MAJOR, FSFW_VERSION_MINOR, FSFW_VERSION_REVISION};

-fsfw::Version::Version(uint32_t major, uint32_t minor, uint32_t revision)
-    : major(major), minor(minor), revision(revision) {}
+Version::Version(int major, int minor, int revision, const char* addInfo)
+    : major(major), minor(minor), revision(revision), addInfo(addInfo) {}

-void fsfw::Version::getVersion(char* str, size_t maxLen) const {
-  snprintf(str, maxLen, "%d.%d.%d", major, minor, revision);
+void Version::getVersion(char* str, size_t maxLen) const {
+  size_t len = snprintf(str, maxLen, "%d.%d.%d", major, minor, revision);
+  if (addInfo != nullptr) {
+    snprintf(str + len, maxLen - len, "-%s", addInfo);
+  }
 }
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+std::ostream& operator<<(std::ostream& os, const Version& v) {
+  os << v.major << "." << v.minor << "." << v.revision;
+  if (v.addInfo != nullptr) {
+    os << "-" << v.addInfo;
+  }
+  return os;
+}
+#endif
@@ -8,14 +8,15 @@
 #endif
 #include <cstdint>

-namespace fsfw {
-
 class Version {
 public:
-  Version(uint32_t major, uint32_t minor, uint32_t revision);
-  uint32_t major = 0;
-  uint32_t minor = 0;
-  uint32_t revision = 0;
+  Version(int major, int minor, int revision, const char* addInfo = nullptr);
+  int major = -1;
+  int minor = -1;
+  int revision = -1;
+
+  // Additional information, e.g. a git SHA hash
+  const char* addInfo = nullptr;

  friend bool operator==(const Version& v1, const Version& v2) {
    return (v1.major == v2.major and v1.minor == v2.minor and v1.revision == v2.revision);
@@ -43,10 +44,7 @@ class Version {
   * @param v
   * @return
   */
-  friend std::ostream& operator<<(std::ostream& os, const Version& v) {
-    os << v.major << "." << v.minor << "." << v.revision;
-    return os;
-  }
+  friend std::ostream& operator<<(std::ostream& os, const Version& v);
 #endif

  /**
@@ -57,7 +55,9 @@ class Version {
  void getVersion(char* str, size_t maxLen) const;
 };

-extern const fsfw::Version FSFW_VERSION;
+namespace fsfw {
+
+extern const Version FSFW_VERSION;

 }  // namespace fsfw

@@ -21,10 +21,8 @@ TEST_CASE("LocalPoolManagerTest", "[LocManTest]") {
  REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
  REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation() == retval::CATCH_OK);

-  MessageQueueMockBase* poolOwnerMock = poolOwner->getMockQueueHandle();
-  REQUIRE(poolOwnerMock != nullptr);
-
-  // MessageQueueIF* hkCommander = QueueFactory::instance()->createMessageQueue();
+  MessageQueueMockBase* mqMock = poolOwner->getMockQueueHandle();
+  REQUIRE(mqMock != nullptr);
  CommandMessage messageSent;
  uint8_t messagesSent = 0;

@@ -43,9 +41,9 @@ TEST_CASE("LocalPoolManagerTest", "[LocManTest]") {
    poolOwner->dataset.setChanged(true);
    /* Now the update message should be generated. */
    REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
-    REQUIRE(poolOwnerMock->wasMessageSent() == true);
+    REQUIRE(mqMock->wasMessageSent() == true);

-    REQUIRE(poolOwnerMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+    REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
    CHECK(messageSent.getCommand() ==
          static_cast<int>(HousekeepingMessage::UPDATE_NOTIFICATION_SET));

@@ -55,9 +53,9 @@ TEST_CASE("LocalPoolManagerTest", "[LocManTest]") {
    poolOwner->dataset.setChanged(true);
    REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);

-    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
    CHECK(messagesSent == 1);
-    REQUIRE(poolOwnerMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+    REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
    CHECK(messageSent.getCommand() ==
          static_cast<int>(HousekeepingMessage::UPDATE_NOTIFICATION_SET));

@@ -65,15 +63,15 @@ TEST_CASE("LocalPoolManagerTest", "[LocManTest]") {
    REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK);
    poolOwner->dataset.setChanged(true);
    REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
-    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
    CHECK(messagesSent == 2);
    /* first message sent should be the update notification, considering
    the internal list is a vector checked in insertion order. */
-    REQUIRE(poolOwnerMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+    REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
    CHECK(messageSent.getCommand() ==
          static_cast<int>(HousekeepingMessage::UPDATE_NOTIFICATION_SET));

-    REQUIRE(poolOwnerMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+    REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
    CHECK(messageSent.getCommand() == static_cast<int>(HousekeepingMessage::HK_REPORT));
    /* Clear message to avoid memory leak, our mock won't do it for us (yet) */
    CommandMessageCleaner::clearCommandMessage(&messageSent);
@@ -101,9 +99,9 @@ TEST_CASE("LocalPoolManagerTest", "[LocManTest]") {

    /* Trigger generation of snapshot */
    REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
-    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
    CHECK(messagesSent == 1);
-    REQUIRE(poolOwnerMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+    REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
    /* Check that snapshot was generated */
    CHECK(messageSent.getCommand() == static_cast<int>(HousekeepingMessage::UPDATE_SNAPSHOT_SET));
    /* Now we deserialize the snapshot into a new dataset instance */
@@ -164,12 +162,12 @@ TEST_CASE("LocalPoolManagerTest", "[LocManTest]") {
    REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);

    /* Check update snapshot was sent. */
-    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
    CHECK(messagesSent == 1);

    /* Should have been reset. */
    CHECK(poolVar->hasChanged() == false);
-    REQUIRE(poolOwnerMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+    REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
    CHECK(messageSent.getCommand() ==
          static_cast<int>(HousekeepingMessage::UPDATE_SNAPSHOT_VARIABLE));
    /* Now we deserialize the snapshot into a new dataset instance */
@@ -211,11 +209,11 @@ TEST_CASE("LocalPoolManagerTest", "[LocManTest]") {
    REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);

    /* Check update notification was sent. */
-    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
    CHECK(messagesSent == 1);
    /* Should have been reset. */
    CHECK(poolVar->hasChanged() == false);
-    REQUIRE(poolOwnerMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+    REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
    CHECK(messageSent.getCommand() ==
          static_cast<int>(HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE));
    /* Now subscribe for the dataset update (HK and update) again with subscription interface */
@@ -227,26 +225,26 @@ TEST_CASE("LocalPoolManagerTest", "[LocManTest]") {
    poolOwner->dataset.setChanged(true);
    REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
    /* Now two messages should be sent. */
-    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
    CHECK(messagesSent == 2);
-    poolOwnerMock->clearMessages(true);
+    mqMock->clearMessages(true);

    poolOwner->dataset.setChanged(true);
    poolVar->setChanged(true);
    REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
    /* Now three messages should be sent. */
-    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
    CHECK(messagesSent == 3);
-    REQUIRE(poolOwnerMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+    REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
    CHECK(messageSent.getCommand() ==
          static_cast<int>(HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE));
-    REQUIRE(poolOwnerMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+    REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
    CHECK(messageSent.getCommand() ==
          static_cast<int>(HousekeepingMessage::UPDATE_NOTIFICATION_SET));
-    REQUIRE(poolOwnerMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+    REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
    CHECK(messageSent.getCommand() == static_cast<int>(HousekeepingMessage::HK_REPORT));
    CommandMessageCleaner::clearCommandMessage(&messageSent);
-    REQUIRE(poolOwnerMock->receiveMessage(&messageSent) == static_cast<int>(MessageQueueIF::EMPTY));
+    REQUIRE(mqMock->receiveMessage(&messageSent) == static_cast<int>(MessageQueueIF::EMPTY));
  }

  SECTION("PeriodicHKAndMessaging") {
@@ -257,38 +255,38 @@ TEST_CASE("LocalPoolManagerTest", "[LocManTest]") {
    REQUIRE(poolOwner->subscribePeriodicHk(true) == retval::CATCH_OK);
    REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
    /* Now HK packet should be sent as message immediately. */
-    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
    CHECK(messagesSent == 1);
-    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+    CHECK(mqMock->popMessage() == retval::CATCH_OK);

    LocalPoolDataSetBase* setHandle = poolOwner->getDataSetHandle(lpool::testSid);
    REQUIRE(setHandle != nullptr);
    CHECK(poolOwner->poolManager.generateHousekeepingPacket(lpool::testSid, setHandle, false) ==
          retval::CATCH_OK);
-    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
    CHECK(messagesSent == 1);
-    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+    CHECK(mqMock->popMessage() == retval::CATCH_OK);

    CHECK(setHandle->getReportingEnabled() == true);
    CommandMessage hkCmd;
    HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, false, false);
    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
    CHECK(setHandle->getReportingEnabled() == false);
-    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
    CHECK(messagesSent == 1);
-    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+    CHECK(mqMock->popMessage() == retval::CATCH_OK);

    HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, true, false);
    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
    CHECK(setHandle->getReportingEnabled() == true);
-    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
-    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+    REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+    CHECK(mqMock->popMessage() == retval::CATCH_OK);

    HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, false, false);
    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
    CHECK(setHandle->getReportingEnabled() == false);
-    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
-    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+    REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+    CHECK(mqMock->popMessage() == retval::CATCH_OK);

    HousekeepingMessage::setCollectionIntervalModificationCommand(&hkCmd, lpool::testSid, 0.4,
                                                                  false);
@@ -296,23 +294,23 @@ TEST_CASE("LocalPoolManagerTest", "[LocManTest]") {
    /* For non-diagnostics and a specified minimum frequency of 0.2 seconds, the
    resulting collection interval should be 1.0 second */
    CHECK(poolOwner->dataset.getCollectionInterval() == 1.0);
-    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
    CHECK(messagesSent == 1);
-    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+    CHECK(mqMock->popMessage() == retval::CATCH_OK);

    HousekeepingMessage::setStructureReportingCommand(&hkCmd, lpool::testSid, false);
    REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
    /* Now HK packet should be sent as message. */
-    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
    CHECK(messagesSent == 1);
-    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+    CHECK(mqMock->popMessage() == retval::CATCH_OK);

    HousekeepingMessage::setOneShotReportCommand(&hkCmd, lpool::testSid, false);
    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
-    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
    CHECK(messagesSent == 1);
-    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+    CHECK(mqMock->popMessage() == retval::CATCH_OK);

    HousekeepingMessage::setUpdateNotificationSetCommand(&hkCmd, lpool::testSid);
    sid_t sidToCheck;
@@ -328,62 +326,62 @@ TEST_CASE("LocalPoolManagerTest", "[LocManTest]") {
    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) ==
          static_cast<int>(LocalDataPoolManager::WRONG_HK_PACKET_TYPE));
    /* We still expect a failure message being sent */
-    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
    CHECK(messagesSent == 1);
-    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+    CHECK(mqMock->popMessage() == retval::CATCH_OK);

    HousekeepingMessage::setCollectionIntervalModificationCommand(&hkCmd, lpool::testSid, 0.4,
                                                                  false);
    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) ==
          static_cast<int>(LocalDataPoolManager::WRONG_HK_PACKET_TYPE));
-    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
    CHECK(messagesSent == 1);
-    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+    CHECK(mqMock->popMessage() == retval::CATCH_OK);

    HousekeepingMessage::setStructureReportingCommand(&hkCmd, lpool::testSid, false);
    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) ==
          static_cast<int>(LocalDataPoolManager::WRONG_HK_PACKET_TYPE));
-    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
    CHECK(messagesSent == 1);
-    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+    CHECK(mqMock->popMessage() == retval::CATCH_OK);

    HousekeepingMessage::setStructureReportingCommand(&hkCmd, lpool::testSid, true);
    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
-    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
    CHECK(messagesSent == 1);
-    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+    CHECK(mqMock->popMessage() == retval::CATCH_OK);

    HousekeepingMessage::setCollectionIntervalModificationCommand(&hkCmd, lpool::testSid, 0.4,
                                                                  true);
    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
-    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
    CHECK(messagesSent == 1);
-    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+    CHECK(mqMock->popMessage() == retval::CATCH_OK);

    HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, true, true);
    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
-    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
    CHECK(messagesSent == 1);
-    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+    CHECK(mqMock->popMessage() == retval::CATCH_OK);

    HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, false, true);
    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
-    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
    CHECK(messagesSent == 1);
-    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+    CHECK(mqMock->popMessage() == retval::CATCH_OK);

    HousekeepingMessage::setOneShotReportCommand(&hkCmd, lpool::testSid, false);
    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) ==
          static_cast<int>(LocalDataPoolManager::WRONG_HK_PACKET_TYPE));
-    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
    CHECK(messagesSent == 1);
-    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+    CHECK(mqMock->popMessage() == retval::CATCH_OK);

    HousekeepingMessage::setOneShotReportCommand(&hkCmd, lpool::testSid, true);
    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
-    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
    CHECK(messagesSent == 1);
-    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+    CHECK(mqMock->popMessage() == retval::CATCH_OK);

    HousekeepingMessage::setUpdateNotificationVariableCommand(&hkCmd, lpool::uint8VarGpid);
    gp_id_t gpidToCheck;
@@ -409,5 +407,5 @@ TEST_CASE("LocalPoolManagerTest", "[LocManTest]") {
  /* we need to reset the subscription list because the pool owner
  is a global object. */
  CHECK(poolOwner->reset() == retval::CATCH_OK);
-  poolOwnerMock->clearMessages(true);
+  mqMock->clearMessages(true);
 }
@@ -3,5 +3,4 @@ target_sources(${FSFW_TEST_TGT} PRIVATE
    testOpDivider.cpp
    testBitutil.cpp
    testCRC.cpp
-    testTimevalOperations.cpp
 )
@@ -1,124 +0,0 @@
-#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);
-  }
-}
@@ -5,17 +5,15 @@
 #include <queue>

 #include "fsfw/ipc/CommandMessage.h"
-#include "fsfw/ipc/MessageQueueBase.h"
 #include "fsfw/ipc/MessageQueueIF.h"
 #include "fsfw/ipc/MessageQueueMessage.h"
 #include "fsfw_tests/unit/CatchDefinitions.h"

-class MessageQueueMockBase : public MessageQueueBase {
+class MessageQueueMockBase : public MessageQueueIF {
 public:
-  MessageQueueMockBase()
-      : MessageQueueBase(MessageQueueIF::NO_QUEUE, MessageQueueIF::NO_QUEUE, nullptr) {}
-
+  MessageQueueId_t myQueueId = tconst::testQueueId;
  uint8_t messageSentCounter = 0;
+  bool defaultDestSet = false;
  bool messageSent = false;

  bool wasMessageSent(uint8_t* messageSentCounter = nullptr, bool resetCounter = true) {
@@ -40,31 +38,54 @@ class MessageQueueMockBase : public MessageQueueBase {
    return receiveMessage(&message);
  }

-  virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override {
+  virtual ReturnValue_t reply(MessageQueueMessageIF* message) {
+    return sendMessage(myQueueId, message);
+  };
+  virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
+                                       MessageQueueId_t* receivedFrom) {
+    return receiveMessage(message);
+  }
+
+  virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) {
    if (messagesSentQueue.empty()) {
      return MessageQueueIF::EMPTY;
    }
-    this->last = message->getSender();
+
    std::memcpy(message->getBuffer(), messagesSentQueue.front().getBuffer(),
                message->getMessageSize());
    messagesSentQueue.pop();
    return HasReturnvaluesIF::RETURN_OK;
  }
  virtual ReturnValue_t flush(uint32_t* count) { return HasReturnvaluesIF::RETURN_OK; }
+  virtual MessageQueueId_t getLastPartner() const { return myQueueId; }
+  virtual MessageQueueId_t getId() const { return myQueueId; }
  virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
-                                        MessageQueueId_t sentFrom,
-                                        bool ignoreFault = false) override {
+                                        MessageQueueId_t sentFrom, bool ignoreFault = false) {
+    return sendMessage(sendTo, message);
+  }
+  virtual ReturnValue_t sendToDefaultFrom(MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+                                          bool ignoreFault = false) {
+    return sendMessage(myQueueId, message);
+  }
+  virtual ReturnValue_t sendToDefault(MessageQueueMessageIF* message) {
+    return sendMessage(myQueueId, message);
+  }
+  virtual ReturnValue_t sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
+                                    bool ignoreFault = false) override {
    messageSent = true;
    messageSentCounter++;
    MessageQueueMessage& messageRef = *(dynamic_cast<MessageQueueMessage*>(message));
    messagesSentQueue.push(messageRef);
    return HasReturnvaluesIF::RETURN_OK;
  }
-
-  virtual ReturnValue_t reply(MessageQueueMessageIF* message) override {
-    return sendMessageFrom(MessageQueueIF::NO_QUEUE, message, this->getId(), false);
+  virtual void setDefaultDestination(MessageQueueId_t defaultDestination) {
+    myQueueId = defaultDestination;
+    defaultDestSet = true;
  }

+  virtual MessageQueueId_t getDefaultDestination() const { return myQueueId; }
+  virtual bool isDefaultDestinationSet() const { return defaultDestSet; }
+
  void clearMessages(bool clearCommandMessages = true) {
    while (not messagesSentQueue.empty()) {
      if (clearCommandMessages) {
@@ -1,5 +1,4 @@
 target_sources(${FSFW_TEST_TGT} PRIVATE
 	TestMessageQueue.cpp
 	TestSemaphore.cpp
-	TestClock.cpp
 )
@@ -1,86 +0,0 @@
-#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));
-  }
-}
@@ -81,8 +81,7 @@ 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());
-    auto result = CCSDSTime::convertFromASCII(&timeTo, timeChar, timeAscii.length());
-    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    CCSDSTime::convertFromASCII(&timeTo, timeChar, timeAscii.length());
    REQUIRE(timeTo.year == 2022);
    REQUIRE(timeTo.month == 12);
    REQUIRE(timeTo.day == 31);
@@ -90,19 +89,6 @@ 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") {
@@ -133,7 +119,6 @@ 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;
@@ -143,77 +128,5 @@ 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
muellerr	b951cb736a	add fsfw specific cmake message prefix	2022-04-22 14:08:26 +02:00
muellerr	7e1aed6ad9	apply afmt	2022-04-22 14:04:30 +02:00
muellerr	07155e2546	extend version handling with git describe	2022-04-22 14:04:18 +02:00
muellerr	8c6c8ad3c0	exntend version class to allow add info	2022-04-22 11:58:44 +02:00