Merge branch 'service_11_bugfixes' into mueller/new-cfdp-update-with-handlers

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "automation/msvc-wine"]
-	path = automation/msvc-wine
-	url = https://github.com/mstorsjo/msvc-wine

CHANGELOG.md

@@ -8,71 +8,14 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 # [unreleased]
 
-## Fixes
+# [v6.0.0]
-
-- PUS Health Service: Size check for set health command.
-  Perform operation completion for announce health command.
-  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/746
-- Linux OSAL `getUptime` fix: Check validity of `/proc/uptime` file before reading uptime.
-  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/745
-- Small tweak for version getter
-  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/744
-
-## Added
-
-- add CFDP subsystem ID
-  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/742
-
-## Changed
-- Bump ETL version to 20.35.14
-  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/748
-- Renamed `PCDU_2` subsystem ID to `POWER_SWITCH_IF`.
-  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/743
-- Add new `PowerSwitchIF::SWITCH_UNKNOWN` returnvalue.
-  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/743
-- Assert that `FixedArrayList` is larger than 0 at compile time.
-  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/740
-
-## Added
-
-- `EventManager`: Add function to print all listeners.
-
-## Changed
-
-- `EventManager`: Queue depth is configurable now
-
-# [v6.0.0] 2023-02-10
 
 ## Fixes
 
-- Mode Service: Add allowed subservice
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/739
-- `CService200ModeManagement`: Various bugfixes which lead to now execution complete being generated
-  on mode announcements, duplicate mode reply generated on announce commands, and the mode read
-  subservice not working properly.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/736
-- Memory leak fixes for the TCP/IP TMTC bridge.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/737
-- `Service9TimeManagement`: Fix the time dump at the `SET_TIME` subservice: Include clock timeval
-  seconds instead of uptime.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/726
-- HAL MGM3100 Handler: Use axis specific gain/scaling factors. Previously,
-  only the X scaling factor was used.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/724
-- HAL MGM3100 Handler: Z value was previously calculated with bytes of the X value.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/733
-- DHB `setNormalDatapoolEntriesInvalid`: The default implementation did not set the validity
-  to false correctly because the `read` and `write` calls were missing.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/728
-- PUS TMTC creator module: Sequence flags were set to continuation segment (0b00) instead
-  of the correct unsegmented flags (0b11) as specified in the standard.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/727
 - TC Scheduler Service 11: Add size and CRC check for contained TC.
-  Bug: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/issues/719
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/720
 - Only delete health table entry in `HealthHelper` destructor if
   health table was set.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/710
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/710/files
 - I2C Bugfixes: Do not keep iterator as member and fix some incorrect handling with the iterator.
   Also properly reset the reply size for successfull transfers and erroneous transfers.
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/700
@@ -82,82 +25,22 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - `TcpTmTcServer.cpp`: The server was actually not able to handle
   CCSDS packets which were clumped together. This has been fixed now.
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/673
-- `CServiceHealthCommanding`: Add announce all health info implementation
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/725
-- various fixes related to linux Unittests and memory leaks
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/715
-- small fix to allow teardown handling
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/713
-- fix compiler warning for fixed array list copy ctor
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/704
-- missing include
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/703
-- defaultconfig did not build anymore
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/702
-- hotfix
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/699
-- small fix for helper
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/698
-- missing retval conv
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/697
-- DHB Countdown Bug
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/693
-- doc corrections
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/687
-- better error printout
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/686
-- include correction
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/683
-- better warning for missing include paths
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/676
-- Service 11 regression
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/670
 
 ## Added
 
-- Empty constructor for `CdsShortTimeStamper` which does not do an object manager registration.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/730
-- `Service9TimeManagement`: Add `DUMP_TIME` (129) subservice.
-- `TcpTmTcServer`: Allow setting the `SO_REUSEADDR` and `SO_REUSEPORT`
-  option on the TCP server. CTOR prototype has changed and expects an explicit
-  TCP configuration struct to be passed.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/722
 - `DleParser` helper class to parse DLE encoded packets from a byte stream.
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/711
 - `UioMapper` is able to resolve symlinks now.
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/709
 - Add new `UnsignedByteField` class
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/660
-- publish documentation for development and master branch
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/681
-- Add Linux HAL options
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/663
-- Expand SerializeIF
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/656
-- PUS Service 11: Additional Safety Check
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/666
-- improvements for auto-formatter script
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/665
-- provide a weak print char impl
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/674
-
-## Removed
-
-- now that doc server is up, remove markdown files
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/688
-- remove bsp specific code
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/679
 
 ## Changes
 
-- `CService201HealthCommanding` renamed to `CServiceHealthCommanding`,
-  service ID customizable now. `CServiceHealthCommanding` expects configuration struct
-  `HealthServiceCfg` now
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/725
 - `AcceptsTelemetryIF`: `getReportReceptionQueue` is const now
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/712
 - Moved some container returnvalues to dedicated header and namespace
-  so they can be used without template specification.
+  to they can be used without template specification.
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/707
 - Remove default secondary header argument for
   `uint16_t getTcSpacePacketIdFromApid(uint16_t apid, bool secondaryHeaderFlag)` and
@@ -187,41 +70,18 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - `DeviceHandlerBase`: New signature of `handleDeviceTm` which expects
   a `const SerializeIF&` and additional helper variant which expects `const uint8_t*`
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/671
+- Move some generic `StorageManagerIF` implementations from `LocalPool` to
+  interface itself so it can be re-used more easily. Also add new
+  abstract function `bool hasDataAtId(store_address_t storeId) const`.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/685
 - Improvements for `AcceptsTelemetryIF` and `AcceptsTelecommandsIF`:
   - Make functions `const` where it makes sense
   - Add `const char* getName const` abstract function
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/684
-- Generic TMTC Bridge Update
+- Move some generic `StorageManagerIF` implementations from `LocalPool` to
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/734
+  interface itself so it can be re-used more easily. Also add new
-- comment tweak to event parser can read everything
+  abstract function `bool hasDataAtId(store_address_t storeId) const`.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/732
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/685
-- CMakeLists file updates
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/731
-- improve srv20 error messages
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/723
-- I2C Linux: remove duplicate printout
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/718
-- printout handling improvements
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/717
-- vec getter, reset for content
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/716
-- updates for source sequence counter
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/714
-- SP reader getPacketData is const now
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/708
-- refactoring of serial drivers for linux
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/705
-- Local Pool Update Remove Add Data Ignore Fault Argument
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/701
-- Switch to new documentation server
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/694
-- Windows Tweaks
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/691
-- Refactor Local Pool API
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/667
-- group MGM data in local pool vectors
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/664
-
 
 ## CFDP
 
@@ -241,7 +101,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
      implementation without an extra component
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/682
 
-# [v5.0.0] 2022-07-25
+# [v5.0.0] 25.07.2022
 
 ## Changes
 

CMakeLists.txt

@@ -13,7 +13,7 @@ list(APPEND CMAKE_MODULE_PATH
 # Version file handling  #
 # ##############################################################################
 
-set(FSFW_VERSION_IF_GIT_FAILS 6)
+set(FSFW_VERSION_IF_GIT_FAILS 5)
 set(FSFW_SUBVERSION_IF_GIT_FAILS 0)
 set(FSFW_REVISION_IF_GIT_FAILS 0)
 
@@ -64,13 +64,6 @@ elseif(${CMAKE_CXX_STANDARD} LESS 17)
       "${MSG_PREFIX} Compiling the FSFW requires a minimum of C++17 support")
 endif()
 
-if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-  # Manually tweak MSVC to emit (about) the same warnings as clang and gcc on linux
-  # needs to be done here using add_compile_definitions() (as opposed to target_compile_definitions()) to be available for all binaries and libraries
-  add_compile_options("/permissive-" /wd4267 /wd4244 /wd4244 /wd4305 /wd4805 /wd4267 /wd4646 /wd4065 /wd4996 /Dand=&& /Dor=|| /Dnot=!)
-  add_compile_definitions(NOMINMAX)
-endif()
-
 set(FSFW_SOURCES_DIR "${CMAKE_SOURCE_DIR}/src/fsfw")
 
 set(FSFW_ETL_LIB_NAME etl)
@@ -79,7 +72,7 @@ set(FSFW_ETL_LIB_MAJOR_VERSION
     20
     CACHE STRING "ETL library major version requirement")
 set(FSFW_ETL_LIB_VERSION
-    ${FSFW_ETL_LIB_MAJOR_VERSION}.35.14
+    ${FSFW_ETL_LIB_MAJOR_VERSION}.28.0
     CACHE STRING "ETL library exact version requirement")
 set(FSFW_ETL_LINK_TARGET etl::etl)
 
@@ -160,12 +153,12 @@ if(FSFW_BUILD_TESTS)
       "${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} QUIET)
+  find_package(Catch2 ${FSFW_CATCH2_LIB_MAJOR_VERSION})
   # Not installed, so use FetchContent to download and provide Catch2
   if(NOT Catch2_FOUND)
     message(
       STATUS
-        "${MSG_PREFIX} Catch2 installation not found. Downloading Catch2 library with FetchContent."
+        "${MSG_PREFIX} Catch2 installation not found. Downloading Catch2 library with FetchContent"
     )
     include(FetchContent)
 
@@ -181,27 +174,6 @@ if(FSFW_BUILD_TESTS)
   configure_file(unittests/testcfg/FSFWConfig.h.in FSFWConfig.h)
   configure_file(unittests/testcfg/TestsConfig.h.in tests/TestsConfig.h)
 
-  if(FSFW_OSAL MATCHES "freertos")
-    message(STATUS "${MSG_PREFIX} Downloading FreeRTOS with FetchContent")
-    include(FetchContent)
-
-    set(FreeRTOS_PORT posix)
-
-    FetchContent_Declare(
-      FreeRTOS
-      GIT_REPOSITORY https://egit.irs.uni-stuttgart.de/fsfw/FreeRTOS-LTS
-      GIT_TAG develop
-      GIT_SUBMODULES FreeRTOS/FreeRTOS-Kernel)
-
-    FetchContent_MakeAvailable(FreeRTOS)
-
-    set(LIB_OS_NAME FreeRTOS)
-    target_include_directories(FreeRTOS PUBLIC unittests/testcfg/freertos)
-    set(THREADS_PREFER_PTHREAD_FLAG ON)
-    find_package(Threads REQUIRED)
-    target_link_libraries(FreeRTOS PRIVATE ${CMAKE_THREAD_LIBS_INIT})
-  endif()
-
   project(${FSFW_TEST_TGT} CXX C)
   add_executable(${FSFW_TEST_TGT})
   if(IPO_SUPPORTED AND FSFW_ENABLE_IPO)
@@ -229,8 +201,8 @@ find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} QUIET)
 if(NOT ${FSFW_ETL_LIB_NAME}_FOUND)
   message(
     STATUS
-      "${MSG_PREFIX} ETL installation not found. Downloading ETL with FetchContent."
+      "${MSG_PREFIX} No ETL installation was found with find_package. Installing and providing "
-  )
+      "etl with FindPackage")
   include(FetchContent)
 
   FetchContent_Declare(
@@ -254,7 +226,6 @@ if(FSFW_FETCH_CONTENT_TARGETS)
     # GitHub issue: https://github.com/catchorg/Catch2/issues/2417
     set_target_properties(Catch2 PROPERTIES DEBUG_POSTFIX "")
   endif()
-
 endif()
 
 set(FSFW_CORE_INC_PATH "inc")
@@ -389,9 +360,6 @@ if(FSFW_BUILD_TESTS)
   endif()
   target_link_libraries(${FSFW_TEST_TGT} PRIVATE Catch2::Catch2
                                                  ${LIB_FSFW_NAME})
-  if(FSFW_OSAL MATCHES "freertos")
-    target_link_libraries(${FSFW_TEST_TGT} PRIVATE FreeRTOS)
-  endif()
 endif()
 
 # The project CMakeLists file has to set the FSFW_CONFIG_PATH and add it. If
@@ -479,8 +447,8 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 
 endif()
 
-if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-  set(FSFW_WARNING_FLAGS -Wall -Wno-gnu-anonymous-struct)
+  set(COMPILER_FLAGS "/permissive-")
 endif()
 
 # Required include paths to compile the FSFW

automation/Dockerfile

@@ -5,7 +5,7 @@ RUN apt-get --yes upgrade
 
 #tzdata is a dependency, won't install otherwise
 ARG DEBIAN_FRONTEND=noninteractive
-RUN apt-get --yes install ca-certificates clang cmake doxygen g++ gcc git graphviz iputils-ping lcov make msitools nano ninja-build pip python3 python3-simplejson python3-six qemu-system-arm rsync valgrind wget winbind
+RUN apt-get --yes install gcc g++ cmake make lcov git valgrind nano iputils-ping python3 pip doxygen graphviz rsync
 
 RUN python3 -m pip install sphinx breathe
 
@@ -21,36 +21,8 @@ RUN git clone https://github.com/ETLCPP/etl.git && \
         cmake -B build . && \
         cmake --install build/
 
-        
-# install our own rtems build
-RUN wget -qO- https://buggy.irs.uni-stuttgart.de/rtems_releases/rtems6-12.2.1.tar.bz2 | tar -xj -C /opt/
-ENV PATH="$PATH:/opt/rtems/6/bin"
-
-# install modern wine for MSVC, removing a conflicting file
-RUN dpkg --add-architecture i386 && \
-    mkdir -pm755 /etc/apt/keyrings && \
-    wget -O /etc/apt/keyrings/winehq-archive.key https://dl.winehq.org/wine-builds/winehq.key && \
-    wget -NP /etc/apt/sources.list.d/ https://dl.winehq.org/wine-builds/ubuntu/dists/focal/winehq-focal.sources && \
-    apt-get update && \
-    apt-get --yes install winehq-stable
-# silence wine
-ENV WINEDEBUG=-all 
-
-
-# install MSVC using https://github.com/mstorsjo/msvc-wine
-# see msvc-wine/LICENSE.txt
-COPY msvc-wine/lowercase msvc-wine/fixinclude msvc-wine/install.sh msvc-wine/vsdownload.py ./
-COPY msvc-wine/wrappers/* ./wrappers/
-RUN PYTHONUNBUFFERED=1 ./vsdownload.py --accept-license --dest /opt/msvc && \
-    ./install.sh /opt/msvc && \
-    rm lowercase fixinclude install.sh vsdownload.py && \
-    rm -rf wrappers
-RUN wine64 wineboot --init && \
-    while pgrep wineserver > /dev/null; do sleep 1; done
-
-
 #ssh needs a valid user to work
-RUN addgroup -q --gid 117 jenkins && adduser -q --uid 114 --gid 117 jenkins
+RUN adduser --uid 114 jenkins
 
 #add documentation server to known hosts
 RUN echo "|1|/LzCV4BuTmTb2wKnD146l9fTKgQ=|NJJtVjvWbtRt8OYqFgcYRnMQyVw= ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBNL8ssTonYtgiR/6RRlSIK9WU1ywOcJmxFTLcEblAwH7oifZzmYq3XRfwXrgfMpylEfMFYfCU8JRqtmi19xc21A=" >> /etc/ssh/ssh_known_hosts

automation/Jenkinsfile

@@ -1,76 +1,48 @@
 pipeline {
     environment {
-        BUILDDIR_HOST = 'cmake-build-tests-host'
+        BUILDDIR = 'cmake-build-tests'
-        BUILDDIR_LINUX = 'cmake-build-tests-linux'
-        BUILDDIR_FREERTOS = 'cmake-build-tests-freertos'
-        BUILDDIR_RTEMS = 'cmake-build-tests-rtems'
-        BUILDDIR_WIN = 'cmake-build-tests-windows'
         DOCDDIR = 'cmake-build-documentation'
     }
     agent {
         docker { 
-            image 'fsfw-ci:d9'
+            image 'fsfw-ci:d6'
-            args '--network host --sysctl fs.mqueue.msg_max=100'
+            args '--network host'
         }
     }
     stages {
-        stage('x64-linux-clang-host') {
+        stage('Clean') {
             steps {
-                sh 'rm -rf $BUILDDIR_HOST'
+                sh 'rm -rf $BUILDDIR'
-
-                dir(BUILDDIR_HOST) {
-                    sh 'CC=clang CXX=clang++ cmake -DFSFW_OSAL=host -DFSFW_BUILD_TESTS=ON -DFSFW_CICD_BUILD=ON ..'
-                    sh 'cmake --build . -j4'
-                    sh 'valgrind --leak-check=full --error-exitcode=1 ./fsfw-tests'
             }
         }
-        }
+        stage('Configure') {
-        stage('x64-linux-gcc') {
             steps {
-                sh 'rm -rf $BUILDDIR_LINUX'
+                dir(BUILDDIR) {
-
+                    sh 'cmake -DFSFW_OSAL=host -DFSFW_BUILD_TESTS=ON -DFSFW_CICD_BUILD=ON ..'
-                dir(BUILDDIR_LINUX) {
+                }
-                    sh 'cmake -DFSFW_OSAL=linux -DFSFW_BUILD_TESTS=ON -DFSFW_CICD_BUILD=ON ..'
+            }
+        }
+        stage('Build') {
+            steps {
+                dir(BUILDDIR) {
                     sh 'cmake --build . -j4'
+                }
+            }
+        }
+        stage('Unittests') {
+            steps {
+                dir(BUILDDIR) {
                     sh 'cmake --build . -- fsfw-tests_coverage -j4'
+                }
+            }
+        }
+        stage('Valgrind') {
+            steps {
+                dir(BUILDDIR) {
                     sh 'valgrind --leak-check=full --error-exitcode=1 ./fsfw-tests'
                 }
             }
         }
-        stage('x64-FreeRTOS-gcc') {
-            steps {
-                sh 'rm -rf $BUILDDIR_FREERTOS'
-
-                dir(BUILDDIR_FREERTOS) {
-                    sh 'cmake -DFSFW_OSAL=freertos -DFSFW_BUILD_TESTS=ON -DFSFW_CICD_BUILD=ON ..'
-                    sh 'cmake --build . -j4'
-                    sh './fsfw-tests'
-                    //sh 'valgrind --leak-check=full --error-exitcode=1 ./fsfw-tests'
-                }
-            }
-        }
-        stage('aarch64-rtems6-gcc') {
-            steps {
-                sh 'rm -rf $BUILDDIR_RTEMS'
-
-                dir(BUILDDIR_RTEMS) {
-                    sh 'cmake -DFSFW_OSAL=rtems -DFSFW_BUILD_TESTS=ON -DFSFW_TESTS_GEN_COV=OFF -DFSFW_CICD_BUILD=ON -DCMAKE_TOOLCHAIN_FILE=../cmake/aarch64-rtems6-gcc.cmake ..'
-                    sh 'cmake --build . -j4'
-                    sh 'qemu-system-aarch64 -no-reboot -nographic -serial mon:stdio -semihosting -machine virt,gic-version=3 -cpu cortex-a72 -m 4000  -kernel fsfw-tests'
-                }
-            }
-        }
-        stage('x64-windows-msvc-host') {
-            steps {
-                sh 'rm -rf $BUILDDIR_WIN'
-
-                dir(BUILDDIR_WIN) {
-                    sh 'cmake -DFSFW_OSAL=host -DFSFW_BUILD_TESTS=ON -DFSFW_TESTS_GEN_COV=OFF -DFSFW_CICD_BUILD=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_TOOLCHAIN_FILE=../cmake/x64-windows-msvc.cmake -GNinja ..'
-                    sh 'cmake --build . -j4'
-                    sh 'wine64 fsfw-tests.exe'
-                }
-            }
-        }
         stage('Documentation') {
             when {
                 branch 'development'
@@ -83,7 +55,7 @@ pipeline {
                         sh 'rsync -r --delete docs/sphinx/* buildfix@documentation.irs.uni-stuttgart.de:/fsfw/development'
                     }
                 }
-                dir(BUILDDIR_LINUX) {
+                dir(BUILDDIR) {
                     sshagent(credentials: ['documentation-buildfix']) {
                         sh 'rsync -r --delete fsfw-tests_coverage/* buildfix@documentation.irs.uni-stuttgart.de:/fsfw/coverage/development'
                     }
@@ -102,7 +74,7 @@ pipeline {
                         sh 'rsync -r --delete docs/sphinx/* buildfix@documentation.irs.uni-stuttgart.de:/fsfw/master'
                     }
                 }
-                dir(BUILDDIR_LINUX) {
+                dir(BUILDDIR) {
                     sshagent(credentials: ['documentation-buildfix']) {
                         sh 'rsync -r --delete fsfw-tests_coverage/* buildfix@documentation.irs.uni-stuttgart.de:/fsfw/coverage/master'
                     }

cmake/Platform/a72_lp64_qemu.cmake

@@ -1,3 +0,0 @@
-add_compile_options("-mcpu=cortex-a72" "-I/opt/rtems/6/aarch64-rtems6/a72_lp64_qemu/lib/include")
-
-add_link_options("-B/opt/rtems/6/aarch64-rtems6/a72_lp64_qemu/lib" "-qrtems")

cmake/aarch64-rtems6-gcc.cmake

@@ -1,33 +0,0 @@
-## the name of the target operating system
-set(CMAKE_SYSTEM_NAME a72_lp64_qemu)
-
-set(CMAKE_SYSTEM_PROCESSOR a72)
-
-# which compilers to use for C and C++
-set(CMAKE_C_COMPILER   aarch64-rtems6-gcc)
-set(CMAKE_CXX_COMPILER aarch64-rtems6-g++)
-
-# built in tests fail
-set(CMAKE_C_COMPILER_WORKS 1)
-set(CMAKE_CXX_COMPILER_WORKS 1)
-
-# adjust the default behavior of the FIND_XXX() commands:
-# search programs in the host environment
-set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY)
-
-# search headers and libraries in the target environment
-set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
-
-# ignore host installed libraries
-# makes find_package() ignore the <package>Config.cmake files
-set(CMAKE_IGNORE_PATH /usr/local)
-
-
-# supress errors
-add_compile_definitions("__STDC_VERSION__")
-
-# make newlib behave like glib with an intercepted cmath
-add_compile_options("-I${CMAKE_SOURCE_DIR}/unittests/testcfg/rtems/include")
-

cmake/x64-windows-msvc.cmake

@@ -1,27 +0,0 @@
-set(CMAKE_SYSTEM_NAME Windows)
-
-# which compilers to use for C and C++
-set(CMAKE_C_COMPILER   /opt/msvc/bin/x64/cl)
-set(CMAKE_CXX_COMPILER /opt/msvc/bin/x64/cl)
-
-# built in tests fail
-set(CMAKE_C_COMPILER_WORKS ON)
-set(CMAKE_CXX_COMPILER_WORKS ON)
-
-# fails somewhere caused by wine
-# overriding internal variable DO NOT TRY THIS AT HOME!
-set(CMAKE_C_ABI_COMPILED ON)
-set(CMAKE_CXX_ABI_COMPILED ON)
-
-# adjust the default behavior of the FIND_XXX() commands:
-# search programs in the host environment
-set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY)
-
-# search headers and libraries in the target environment
-set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
-
-# ignore host installed libraries
-# makes find_package() ignore the <package>Config.cmake files
-set(CMAKE_IGNORE_PATH /usr/local)

scripts/check_release.py

@@ -1,110 +0,0 @@
-#! /bin/python
-
-
-import argparse
-import json
-import urllib.request
-import re
-from pathlib import Path
-
-def main() -> None:
-    parser = argparse.ArgumentParser(
-        description="List undocumented PRs"
-    )
-    parser.add_argument("-v", "--version", type=str, required=True)
-    args = parser.parse_args()
-    
-    match = re.search("([0-9]+\.[0-9]+\.[0-9]+)", args.version)
-    
-    if not match:
-        print("invalid version")
-        exit(1)
-    
-    version = "v" + match.group(1)
-    
-    print("looking for milestone for " + version + " ...")
-    
-    
-    with urllib.request.urlopen("https://egit.irs.uni-stuttgart.de/api/v1/repos/fsfw/fsfw/milestones?name=" + version) as milestone_json:
-        milestones = json.load(milestone_json)
-        if (len(milestones) == 0):
-            print("did not find any milestone")
-            exit(1)
-        if (len(milestones) > 1):
-            print("found multiple milestons")
-        milestone_title = milestones[0]['title']
-        milestone = str(milestones[0]['id'])
-        print("Using Milestone \""+ milestone_title + "\" with id " + milestone)
-    
-    milestone_prs = []
-    
-    page = 1
-    last_count = 1;
-    while last_count != 0:
-        with urllib.request.urlopen("https://egit.irs.uni-stuttgart.de/api/v1/repos/fsfw/fsfw/pulls?state=closed&milestone=" + str(milestone) + "&limit=100&page=" + str(page)) as pull_requests_json:
-            pull_requests = json.load(pull_requests_json)
-            for pr in pull_requests:
-                milestone_prs.append({'number': str(pr['number']), 'title' : pr['title']})
-            page += 1
-            last_count = len(pull_requests)
-    
-    print("Found " + str(len(milestone_prs)) + " closed PRs in Milestone")
-    
-    print("looking for CHANGELOG.md ...")
-    
-    path = Path(".")
-    
-    files = list(path.glob("CHANGELOG.md"))
-    
-    if (len(files) != 1):
-        files = list(path.glob("../CHANGELOG.md"))
-        
-    if (len(files) != 1):
-        print("did not find CHANGELOG.md. Run script in either root directory or scripts subfolder.")
-        exit(1)
-        
-    print("Scanning CHANGELOG.md ...")
-    
-    changelog_prs = []
-    
-    with open(files[0]) as changelog:
-        line = changelog.readline()
-        while (line):
-            #print("line: " + line)
-            match = re.search("\#.+(v[0-9]+\.[0-9]+\.[0-9]+)", line)
-            if (match):
-                if match.group(1) == version:
-                    #print("found version")
-                    line = changelog.readline()
-                    continue
-                else:
-                    #print("done with " + match.group(1))
-                    break
-            
-            match = re.search("PR: https://egit\.irs\.uni-stuttgart\.de/fsfw/fsfw/pulls/([0-9]+)", line)
-            if match:
-                changelog_prs.append(match.group(1))
-                
-            line = changelog.readline()
-    
-    print("Found " + str(len(changelog_prs)) + " PRs in CHANGELOG.md")
-    
-    print("")
-    
-    copy_array = changelog_prs.copy()
-    print("PRs in CHANGELOG.md that are not in Milestone:")
-    for pr in milestone_prs:
-        if pr['number'] in copy_array:
-            copy_array.remove(pr['number'])
-    for pr in copy_array:
-        print("https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/" + pr)
-
-    print("")
-
-    print("PRs in milestone that are not in CHANGELOG.md:")
-    
-    for pr in milestone_prs:
-        if pr['number'] not in changelog_prs:
-            print("- " + pr['title'] + "\n  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/" + pr['number'])
-
-main()

src/fsfw/cfdp.h

@@ -2,7 +2,10 @@
 #define FSFW_CFDP_H
 
 #include "cfdp/definitions.h"
+#include "cfdp/handler/CfdpHandler.h"
+#include "cfdp/handler/DestHandler.h"
 #include "cfdp/handler/FaultHandlerBase.h"
+#include "cfdp/helpers.h"
 #include "cfdp/tlv/Lv.h"
 #include "cfdp/tlv/StringLv.h"
 #include "cfdp/tlv/Tlv.h"

src/fsfw/cfdp/FileSize.h

@@ -21,7 +21,7 @@ struct FileSize : public SerializeIF {
     this->largeFile = isLarge;
     return serialize(buffer, size, maxSize, streamEndianness);
   }
-  using SerializeIF::serialize;
+
   ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
                           Endianness streamEndianness) const override {
     if (not largeFile) {

src/fsfw/cfdp/VarLenFields.cpp

@@ -3,7 +3,7 @@
 #include "fsfw/serialize/SerializeAdapter.h"
 #include "fsfw/serviceinterface.h"
 
-cfdp::VarLenField::VarLenField(cfdp::WidthInBytes width, uint64_t value) : VarLenField() {
+cfdp::VarLenField::VarLenField(cfdp::WidthInBytes width, size_t value) : VarLenField() {
   ReturnValue_t result = this->setValue(width, value);
   if (result != returnvalue::OK) {
 #if FSFW_DISABLE_PRINTOUT == 0
@@ -20,7 +20,7 @@ cfdp::VarLenField::VarLenField() : width(cfdp::WidthInBytes::ONE_BYTE) { value.o
 
 cfdp::WidthInBytes cfdp::VarLenField::getWidth() const { return width; }
 
-ReturnValue_t cfdp::VarLenField::setValue(cfdp::WidthInBytes widthInBytes, uint64_t value_) {
+ReturnValue_t cfdp::VarLenField::setValue(cfdp::WidthInBytes widthInBytes, size_t value_) {
   switch (widthInBytes) {
     case (cfdp::WidthInBytes::ONE_BYTE): {
       if (value_ > UINT8_MAX) {
@@ -51,7 +51,7 @@ ReturnValue_t cfdp::VarLenField::setValue(cfdp::WidthInBytes widthInBytes, uint6
   return returnvalue::OK;
 }
 
-uint64_t cfdp::VarLenField::getValue() const {
+size_t cfdp::VarLenField::getValue() const {
   switch (width) {
     case (cfdp::WidthInBytes::ONE_BYTE): {
       return value.oneByte;

src/fsfw/cfdp/VarLenFields.h

@@ -25,13 +25,13 @@ class VarLenField : public SerializeIF {
   template <typename T>
   explicit VarLenField(UnsignedByteField<T> byteField);
 
-  VarLenField(cfdp::WidthInBytes width, uint64_t value);
+  VarLenField(cfdp::WidthInBytes width, size_t value);
 
   bool operator==(const VarLenField &other) const;
   bool operator!=(const VarLenField &other) const;
   bool operator<(const VarLenField &other) const;
 
-  ReturnValue_t setValue(cfdp::WidthInBytes, uint64_t value);
+  ReturnValue_t setValue(cfdp::WidthInBytes, size_t value);
 
   ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
                           Endianness streamEndianness) const override;
@@ -42,7 +42,7 @@ class VarLenField : public SerializeIF {
                             Endianness streamEndianness);
 
   [[nodiscard]] cfdp::WidthInBytes getWidth() const;
-  [[nodiscard]] uint64_t getValue() const;
+  [[nodiscard]] size_t getValue() const;
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
   friend std::ostream &operator<<(std::ostream &os, const VarLenField &id) {
@@ -53,7 +53,6 @@ class VarLenField : public SerializeIF {
 #endif
 
  private:
-  using SerializeIF::deSerialize;
   ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
                             Endianness streamEndianness) override;
 

src/fsfw/cfdp/definitions.h

@@ -9,11 +9,6 @@
 #include "fsfw/returnvalues/FwClassIds.h"
 #include "fsfw/returnvalues/returnvalue.h"
 
-// Thanks, windows
-#ifdef NO_ERROR
-#undef NO_ERROR
-#endif
-
 namespace cfdp {
 
 static constexpr char CFDP_VERSION_2_NAME[] = "CCSDS 727.0-B-5";

src/fsfw/cfdp/handler/CMakeLists.txt

@@ -1 +1,3 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE FaultHandlerBase.cpp UserBase.cpp)
+target_sources(
+  ${LIB_FSFW_NAME} PRIVATE SourceHandler.cpp DestHandler.cpp
+                           FaultHandlerBase.cpp UserBase.cpp CfdpHandler.cpp)

src/fsfw/cfdp/handler/CfdpHandler.cpp

@@ -0,0 +1,134 @@
+#include "CfdpHandler.h"
+
+#include "fsfw/cfdp/pdu/AckPduReader.h"
+#include "fsfw/cfdp/pdu/PduHeaderReader.h"
+#include "fsfw/globalfunctions/arrayprinter.h"
+#include "fsfw/ipc/QueueFactory.h"
+#include "fsfw/tmtcservices/TmTcMessage.h"
+
+using namespace returnvalue;
+using namespace cfdp;
+
+CfdpHandler::CfdpHandler(const FsfwHandlerParams& fsfwParams, const CfdpHandlerCfg& cfdpCfg)
+    : SystemObject(fsfwParams.objectId),
+      msgQueue(fsfwParams.msgQueue),
+      destHandler(
+          DestHandlerParams(LocalEntityCfg(cfdpCfg.id, cfdpCfg.indicCfg, cfdpCfg.faultHandler),
+                            cfdpCfg.userHandler, cfdpCfg.remoteCfgProvider, cfdpCfg.packetInfoList,
+                            cfdpCfg.lostSegmentsList),
+          FsfwParams(fsfwParams.packetDest, nullptr, this, fsfwParams.tcStore,
+                     fsfwParams.tmStore)) {
+  destHandler.setMsgQueue(msgQueue);
+}
+
+[[nodiscard]] const char* CfdpHandler::getName() const { return "CFDP Handler"; }
+
+[[nodiscard]] uint32_t CfdpHandler::getIdentifier() const {
+  return destHandler.getDestHandlerParams().cfg.localId.getValue();
+}
+
+[[nodiscard]] MessageQueueId_t CfdpHandler::getRequestQueue() const { return msgQueue.getId(); }
+
+ReturnValue_t CfdpHandler::initialize() {
+  ReturnValue_t result = destHandler.initialize();
+  if (result != OK) {
+    return result;
+  }
+  tcStore = destHandler.getTcStore();
+  tmStore = destHandler.getTmStore();
+
+  return SystemObject::initialize();
+}
+
+ReturnValue_t CfdpHandler::performOperation(uint8_t operationCode) {
+  // TODO: Receive TC packets and route them to source and dest handler, depending on which is
+  //       correct or more appropriate
+  ReturnValue_t status;
+  ReturnValue_t result = OK;
+  TmTcMessage tmtcMsg;
+  for (status = msgQueue.receiveMessage(&tmtcMsg); status == returnvalue::OK;
+       status = msgQueue.receiveMessage(&tmtcMsg)) {
+    result = handleCfdpPacket(tmtcMsg);
+    if (result != OK) {
+      status = result;
+    }
+  }
+  auto& fsmRes = destHandler.performStateMachine();
+  // TODO: Error handling?
+  while (fsmRes.callStatus == CallStatus::CALL_AGAIN) {
+    destHandler.performStateMachine();
+    // TODO: Error handling?
+  }
+  return status;
+}
+
+ReturnValue_t CfdpHandler::handleCfdpPacket(TmTcMessage& msg) {
+  auto accessorPair = tcStore->getData(msg.getStorageId());
+  if (accessorPair.first != OK) {
+    return accessorPair.first;
+  }
+  PduHeaderReader reader(accessorPair.second.data(), accessorPair.second.size());
+  ReturnValue_t result = reader.parseData();
+  if (result != returnvalue::OK) {
+    return INVALID_PDU_FORMAT;
+  }
+  // The CFDP distributor should have taken care of ensuring the destination ID is correct
+  PduType type = reader.getPduType();
+  // Only the destination handler can process these PDUs
+  if (type == PduType::FILE_DATA) {
+    // Disable auto-deletion of packet
+    accessorPair.second.release();
+    PacketInfo info(type, msg.getStorageId());
+    result = destHandler.passPacket(info);
+  } else {
+    // Route depending on PDU type and directive type if applicable. It retrieves directive type
+    // from the raw stream for better performance (with sanity and directive code check).
+    // The routing is based on section 4.5 of the CFDP standard which specifies the PDU forwarding
+    // procedure.
+
+    // PDU header only. Invalid supplied data. A directive packet should have a valid data field
+    // with at least one byte being the directive code
+    const uint8_t* pduDataField = reader.getPduDataField();
+    if (pduDataField == nullptr) {
+      return INVALID_PDU_FORMAT;
+    }
+    if (not FileDirectiveReader::checkFileDirective(pduDataField[0])) {
+      return INVALID_DIRECTIVE_FIELD;
+    }
+    auto directive = static_cast<FileDirective>(pduDataField[0]);
+
+    auto passToDestHandler = [&]() {
+      accessorPair.second.release();
+      PacketInfo info(type, msg.getStorageId(), directive);
+      result = destHandler.passPacket(info);
+    };
+    auto passToSourceHandler = [&]() {
+
+    };
+    if (directive == FileDirective::METADATA or directive == FileDirective::EOF_DIRECTIVE or
+        directive == FileDirective::PROMPT) {
+      // Section b) of 4.5.3: These PDUs should always be targeted towards the file receiver a.k.a.
+      // the destination handler
+      passToDestHandler();
+    } else if (directive == FileDirective::FINISH or directive == FileDirective::NAK or
+               directive == FileDirective::KEEP_ALIVE) {
+      // Section c) of 4.5.3: These PDUs should always be targeted towards the file sender a.k.a.
+      // the source handler
+      passToSourceHandler();
+    } else if (directive == FileDirective::ACK) {
+      // Section a): Recipient depends of the type of PDU that is being acknowledged. We can simply
+      // extract the PDU type from the raw stream. If it is an EOF PDU, this packet is passed to
+      // the source handler, for a Finished PDU, it is passed to the destination handler.
+      FileDirective ackedDirective;
+      if (not AckPduReader::checkAckedDirectiveField(pduDataField[1], ackedDirective)) {
+        return INVALID_ACK_DIRECTIVE_FIELDS;
+      }
+      if (ackedDirective == FileDirective::EOF_DIRECTIVE) {
+        passToSourceHandler();
+      } else if (ackedDirective == FileDirective::FINISH) {
+        passToDestHandler();
+      }
+    }
+  }
+  return result;
+}

src/fsfw/cfdp/handler/CfdpHandler.h

@@ -0,0 +1,71 @@
+#ifndef FSFW_EXAMPLE_HOSTED_CFDPHANDLER_H
+#define FSFW_EXAMPLE_HOSTED_CFDPHANDLER_H
+
+#include <utility>
+
+#include "fsfw/cfdp/handler/DestHandler.h"
+#include "fsfw/objectmanager/SystemObject.h"
+#include "fsfw/tasks/ExecutableObjectIF.h"
+#include "fsfw/tmtcservices/AcceptsTelecommandsIF.h"
+#include "fsfw/tmtcservices/TmTcMessage.h"
+
+struct FsfwHandlerParams {
+  FsfwHandlerParams(object_id_t objectId, HasFileSystemIF& vfs, AcceptsTelemetryIF& packetDest,
+                    StorageManagerIF& tcStore, StorageManagerIF& tmStore, MessageQueueIF& msgQueue)
+      : objectId(objectId),
+        vfs(vfs),
+        packetDest(packetDest),
+        tcStore(tcStore),
+        tmStore(tmStore),
+        msgQueue(msgQueue) {}
+  object_id_t objectId{};
+  HasFileSystemIF& vfs;
+  AcceptsTelemetryIF& packetDest;
+  StorageManagerIF& tcStore;
+  StorageManagerIF& tmStore;
+  MessageQueueIF& msgQueue;
+};
+
+struct CfdpHandlerCfg {
+  CfdpHandlerCfg(cfdp::EntityId localId, cfdp::IndicationCfg indicationCfg,
+                 cfdp::UserBase& userHandler, cfdp::FaultHandlerBase& userFaultHandler,
+                 cfdp::PacketInfoListBase& packetInfo, cfdp::LostSegmentsListBase& lostSegmentsList,
+                 cfdp::RemoteConfigTableIF& remoteCfgProvider)
+      : id(std::move(localId)),
+        indicCfg(indicationCfg),
+        packetInfoList(packetInfo),
+        lostSegmentsList(lostSegmentsList),
+        remoteCfgProvider(remoteCfgProvider),
+        userHandler(userHandler),
+        faultHandler(userFaultHandler) {}
+
+  cfdp::EntityId id;
+  cfdp::IndicationCfg indicCfg;
+  cfdp::PacketInfoListBase& packetInfoList;
+  cfdp::LostSegmentsListBase& lostSegmentsList;
+  cfdp::RemoteConfigTableIF& remoteCfgProvider;
+  cfdp::UserBase& userHandler;
+  cfdp::FaultHandlerBase& faultHandler;
+};
+
+class CfdpHandler : public SystemObject, public ExecutableObjectIF, public AcceptsTelecommandsIF {
+ public:
+  explicit CfdpHandler(const FsfwHandlerParams& fsfwParams, const CfdpHandlerCfg& cfdpCfg);
+
+  [[nodiscard]] const char* getName() const override;
+  [[nodiscard]] uint32_t getIdentifier() const override;
+  [[nodiscard]] MessageQueueId_t getRequestQueue() const override;
+
+  ReturnValue_t initialize() override;
+  ReturnValue_t performOperation(uint8_t operationCode) override;
+
+ private:
+  MessageQueueIF& msgQueue;
+  cfdp::DestHandler destHandler;
+  StorageManagerIF* tcStore = nullptr;
+  StorageManagerIF* tmStore = nullptr;
+
+  ReturnValue_t handleCfdpPacket(TmTcMessage& msg);
+};
+
+#endif  // FSFW_EXAMPLE_HOSTED_CFDPHANDLER_H

src/fsfw/cfdp/handler/DestHandler.cpp

@@ -0,0 +1,490 @@
+#include "DestHandler.h"
+
+#include <etl/crc32.h>
+
+#include <utility>
+
+#include "fsfw/FSFW.h"
+#include "fsfw/cfdp/pdu/EofPduReader.h"
+#include "fsfw/cfdp/pdu/FileDataReader.h"
+#include "fsfw/cfdp/pdu/FinishedPduCreator.h"
+#include "fsfw/cfdp/pdu/PduHeaderReader.h"
+#include "fsfw/objectmanager.h"
+#include "fsfw/tmtcservices/TmTcMessage.h"
+
+using namespace returnvalue;
+
+cfdp::DestHandler::DestHandler(DestHandlerParams params, FsfwParams fsfwParams)
+    : tlvVec(params.maxTlvsInOnePdu),
+      userTlvVec(params.maxTlvsInOnePdu),
+      dp(std::move(params)),
+      fp(fsfwParams),
+      tp(params.maxFilenameLen) {
+  tp.pduConf.direction = cfdp::Direction::TOWARDS_SENDER;
+}
+
+const cfdp::DestHandler::FsmResult& cfdp::DestHandler::performStateMachine() {
+  ReturnValue_t result;
+  uint8_t errorIdx = 0;
+  fsmRes.resetOfIteration();
+  if (fsmRes.step == TransactionStep::IDLE) {
+    for (auto infoIter = dp.packetListRef.begin(); infoIter != dp.packetListRef.end();) {
+      if (infoIter->pduType == PduType::FILE_DIRECTIVE and
+          infoIter->directiveType == FileDirective::METADATA) {
+        result = handleMetadataPdu(*infoIter);
+        checkAndHandleError(result, errorIdx);
+        // Store data was deleted in PDU handler because a store guard is used
+        dp.packetListRef.erase(infoIter++);
+      } else {
+        infoIter++;
+      }
+    }
+    if (fsmRes.step == TransactionStep::IDLE) {
+      // To decrease the already high complexity of the software, all packets arriving before
+      // a metadata PDU are deleted.
+      for (auto infoIter = dp.packetListRef.begin(); infoIter != dp.packetListRef.end();) {
+        fp.tcStore->deleteData(infoIter->storeId);
+        infoIter++;
+      }
+      dp.packetListRef.clear();
+    }
+
+    if (fsmRes.step != TransactionStep::IDLE) {
+      fsmRes.callStatus = CallStatus::CALL_AGAIN;
+    }
+    return updateFsmRes(errorIdx);
+  }
+  if (fsmRes.state == CfdpStates::BUSY_CLASS_1_NACKED) {
+    if (fsmRes.step == TransactionStep::RECEIVING_FILE_DATA_PDUS) {
+      for (auto infoIter = dp.packetListRef.begin(); infoIter != dp.packetListRef.end();) {
+        if (infoIter->pduType == PduType::FILE_DATA) {
+          result = handleFileDataPdu(*infoIter);
+          checkAndHandleError(result, errorIdx);
+          // Store data was deleted in PDU handler because a store guard is used
+          dp.packetListRef.erase(infoIter++);
+        } else if (infoIter->pduType == PduType::FILE_DIRECTIVE and
+                   infoIter->directiveType == FileDirective::EOF_DIRECTIVE) {
+          // TODO: Support for check timer missing
+          result = handleEofPdu(*infoIter);
+          checkAndHandleError(result, errorIdx);
+          // Store data was deleted in PDU handler because a store guard is used
+          dp.packetListRef.erase(infoIter++);
+        } else {
+          infoIter++;
+        }
+      }
+    }
+    if (fsmRes.step == TransactionStep::TRANSFER_COMPLETION) {
+      result = handleTransferCompletion();
+      checkAndHandleError(result, errorIdx);
+    }
+    if (fsmRes.step == TransactionStep::SENDING_FINISHED_PDU) {
+      result = sendFinishedPdu();
+      checkAndHandleError(result, errorIdx);
+      finish();
+    }
+    return updateFsmRes(errorIdx);
+  }
+  if (fsmRes.state == CfdpStates::BUSY_CLASS_2_ACKED) {
+    // TODO: Will be implemented at a later stage
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "CFDP state machine for acknowledged mode not implemented yet" << std::endl;
+#endif
+  }
+  return updateFsmRes(errorIdx);
+}
+
+ReturnValue_t cfdp::DestHandler::passPacket(PacketInfo packet) {
+  if (dp.packetListRef.full()) {
+    return FAILED;
+  }
+  dp.packetListRef.push_back(packet);
+  return OK;
+}
+
+ReturnValue_t cfdp::DestHandler::initialize() {
+  if (fp.tmStore == nullptr) {
+    fp.tmStore = ObjectManager::instance()->get<StorageManagerIF>(objects::TM_STORE);
+    if (fp.tmStore == nullptr) {
+      return FAILED;
+    }
+  }
+
+  if (fp.tcStore == nullptr) {
+    fp.tcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::TC_STORE);
+    if (fp.tcStore == nullptr) {
+      return FAILED;
+    }
+  }
+
+  if (fp.msgQueue == nullptr) {
+    return FAILED;
+  }
+  return OK;
+}
+
+ReturnValue_t cfdp::DestHandler::handleMetadataPdu(const PacketInfo& info) {
+  // Process metadata PDU
+  auto constAccessorPair = fp.tcStore->getData(info.storeId);
+  if (constAccessorPair.first != OK) {
+    // TODO: This is not a CFDP error. Event and/or warning?
+    return constAccessorPair.first;
+  }
+  cfdp::StringLv sourceFileName;
+  cfdp::StringLv destFileName;
+  MetadataInfo metadataInfo(tp.fileSize, sourceFileName, destFileName);
+  cfdp::Tlv* tlvArrayAsPtr = tlvVec.data();
+  metadataInfo.setOptionsArray(&tlvArrayAsPtr, std::nullopt, tlvVec.size());
+  MetadataPduReader reader(constAccessorPair.second.data(), constAccessorPair.second.size(),
+                           metadataInfo);
+  ReturnValue_t result = reader.parseData();
+  // TODO: The standard does not really specify what happens if this kind of error happens
+  //       I think it might be a good idea to cache some sort of error code, which
+  //       is translated into a warning and/or event by an upper layer
+  if (result != OK) {
+    return handleMetadataParseError(result, constAccessorPair.second.data(),
+                                    constAccessorPair.second.size());
+  }
+  return startTransaction(reader, metadataInfo);
+}
+
+ReturnValue_t cfdp::DestHandler::handleFileDataPdu(const cfdp::PacketInfo& info) {
+  // Process file data PDU
+  auto constAccessorPair = fp.tcStore->getData(info.storeId);
+  if (constAccessorPair.first != OK) {
+    // TODO: This is not a CFDP error. Event and/or warning?
+    return constAccessorPair.first;
+  }
+  cfdp::FileSize offset;
+  FileDataInfo fdInfo(offset);
+  FileDataReader reader(constAccessorPair.second.data(), constAccessorPair.second.size(), fdInfo);
+  ReturnValue_t result = reader.parseData();
+  if (result != OK) {
+    return result;
+  }
+  size_t fileSegmentLen = 0;
+  const uint8_t* fileData = fdInfo.getFileData(&fileSegmentLen);
+  FileOpParams fileOpParams(tp.destName.data(), fileSegmentLen);
+  fileOpParams.offset = offset.value();
+  if (dp.cfg.indicCfg.fileSegmentRecvIndicRequired) {
+    FileSegmentRecvdParams segParams;
+    segParams.offset = offset.value();
+    segParams.id = tp.transactionId;
+    segParams.length = fileSegmentLen;
+    segParams.recContState = fdInfo.getRecordContinuationState();
+    size_t segmentMetadatLen = 0;
+    auto* segMetadata = fdInfo.getSegmentMetadata(&segmentMetadatLen);
+    segParams.segmentMetadata = {segMetadata, segmentMetadatLen};
+    dp.user.fileSegmentRecvdIndication(segParams);
+  }
+  result = dp.user.vfs.writeToFile(fileOpParams, fileData);
+  if (offset.value() + fileSegmentLen > tp.progress) {
+    tp.progress = offset.value() + fileSegmentLen;
+  }
+  if (result != returnvalue::OK) {
+    // TODO: Proper Error handling
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "File write error" << std::endl;
+#endif
+  } else {
+    tp.deliveryStatus = FileDeliveryStatus::RETAINED_IN_FILESTORE;
+  }
+  return result;
+}
+
+ReturnValue_t cfdp::DestHandler::handleEofPdu(const cfdp::PacketInfo& info) {
+  // Process EOF PDU
+  auto constAccessorPair = fp.tcStore->getData(info.storeId);
+  if (constAccessorPair.first != OK) {
+    // TODO: This is not a CFDP error. Event and/or warning?
+    return constAccessorPair.first;
+  }
+  EofInfo eofInfo(nullptr);
+  EofPduReader reader(constAccessorPair.second.data(), constAccessorPair.second.size(), eofInfo);
+  ReturnValue_t result = reader.parseData();
+  if (result != OK) {
+    return result;
+  }
+  // TODO: Error handling
+  if (eofInfo.getConditionCode() == ConditionCode::NO_ERROR) {
+    tp.crc = eofInfo.getChecksum();
+    uint64_t fileSizeFromEof = eofInfo.getFileSize().value();
+    // CFDP 4.6.1.2.9: Declare file size error if progress exceeds file size
+    if (fileSizeFromEof > tp.progress) {
+      // TODO: File size error
+    }
+    tp.fileSize.setFileSize(fileSizeFromEof, std::nullopt);
+  }
+  if (dp.cfg.indicCfg.eofRecvIndicRequired) {
+    dp.user.eofRecvIndication(getTransactionId());
+  }
+  if (fsmRes.step == TransactionStep::RECEIVING_FILE_DATA_PDUS) {
+    if (fsmRes.state == CfdpStates::BUSY_CLASS_1_NACKED) {
+      fsmRes.step = TransactionStep::TRANSFER_COMPLETION;
+    } else if (fsmRes.state == CfdpStates::BUSY_CLASS_2_ACKED) {
+      fsmRes.step = TransactionStep::SENDING_ACK_PDU;
+    }
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t cfdp::DestHandler::handleMetadataParseError(ReturnValue_t result,
+                                                          const uint8_t* rawData, size_t maxSize) {
+  // TODO: try to extract destination ID for error
+  // TODO: Invalid metadata PDU.
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::warning << "Parsing Metadata PDU failed with code " << result << std::endl;
+#else
+#endif
+  PduHeaderReader headerReader(rawData, maxSize);
+  result = headerReader.parseData();
+  if (result != OK) {
+    // TODO: Now this really should not happen. Warning or error,
+    //       yield or cache appropriate returnvalue
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "Parsing Header failed" << std::endl;
+#else
+#endif
+    // TODO: Trigger appropriate event
+    return result;
+  }
+  cfdp::EntityId destId;
+  headerReader.getDestId(destId);
+  RemoteEntityCfg* remoteCfg;
+  if (not dp.remoteCfgTable.getRemoteCfg(destId, &remoteCfg)) {
+// TODO: No remote config for dest ID. I consider this a configuration error, which is not
+//       covered by the standard.
+//       Warning or error, yield or cache appropriate returnvalue
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "No remote config exists for destination ID" << std::endl;
+#else
+#endif
+    // TODO: Trigger appropriate event
+  }
+  // TODO: Appropriate returnvalue?
+  return returnvalue::FAILED;
+}
+
+ReturnValue_t cfdp::DestHandler::startTransaction(MetadataPduReader& reader, MetadataInfo& info) {
+  if (fsmRes.state != CfdpStates::IDLE) {
+    // According to standard, discard metadata PDU if we are busy
+    return OK;
+  }
+  ReturnValue_t result = OK;
+  fsmRes.step = TransactionStep::TRANSACTION_START;
+  if (reader.getTransmissionMode() == TransmissionMode::UNACKNOWLEDGED) {
+    fsmRes.state = CfdpStates::BUSY_CLASS_1_NACKED;
+  } else if (reader.getTransmissionMode() == TransmissionMode::ACKNOWLEDGED) {
+    fsmRes.state = CfdpStates::BUSY_CLASS_2_ACKED;
+  }
+  tp.checksumType = info.getChecksumType();
+  tp.closureRequested = info.isClosureRequested();
+  size_t sourceNameSize = 0;
+  const uint8_t* sourceNamePtr = info.getSourceFileName().getValue(&sourceNameSize);
+  if (sourceNameSize > tp.sourceName.size()) {
+    // TODO: Warning, event etc.
+    return FAILED;
+  }
+  std::memcpy(tp.sourceName.data(), sourceNamePtr, sourceNameSize);
+  tp.sourceName[sourceNameSize] = '\0';
+  size_t destNameSize = 0;
+  const uint8_t* destNamePtr = info.getDestFileName().getValue(&destNameSize);
+  if (destNameSize > tp.destName.size()) {
+    // TODO: Warning, event etc.
+    return FAILED;
+  }
+  std::memcpy(tp.destName.data(), destNamePtr, destNameSize);
+  tp.destName[destNameSize] = '\0';
+  reader.fillConfig(tp.pduConf);
+  tp.pduConf.direction = Direction::TOWARDS_SENDER;
+  tp.transactionId.entityId = tp.pduConf.sourceId;
+  tp.transactionId.seqNum = tp.pduConf.seqNum;
+  if (not dp.remoteCfgTable.getRemoteCfg(tp.pduConf.sourceId, &tp.remoteCfg)) {
+    // TODO: Warning, event etc.
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "cfdp::DestHandler" << __func__
+                 << ": No remote configuration found for destination ID "
+                 << tp.pduConf.sourceId.getValue() << std::endl;
+#endif
+    return FAILED;
+  }
+  // If both dest name size and source name size are 0, we are dealing with a metadata only PDU,
+  // so there is no need to create a file or truncate an existing file
+  if (destNameSize > 0 and sourceNameSize > 0) {
+    FilesystemParams fparams(tp.destName.data());
+    // TODO: Filesystem errors?
+    if (dp.user.vfs.fileExists(fparams)) {
+      dp.user.vfs.truncateFile(fparams);
+    } else {
+      result = dp.user.vfs.createFile(fparams);
+      if (result != OK) {
+        // TODO: Handle FS error. This is probably a case for the filestore rejection mechanism of
+        // CFDP.
+        //       In any case, it does not really make sense to continue here
+      }
+    }
+  }
+  fsmRes.step = TransactionStep::RECEIVING_FILE_DATA_PDUS;
+  MetadataRecvdParams params(tp.transactionId, tp.pduConf.sourceId);
+  params.fileSize = tp.fileSize.getSize();
+  params.destFileName = tp.destName.data();
+  params.sourceFileName = tp.sourceName.data();
+  params.msgsToUserArray = dynamic_cast<MessageToUserTlv*>(userTlvVec.data());
+  params.msgsToUserLen = info.getOptionsLen();
+  dp.user.metadataRecvdIndication(params);
+  return result;
+}
+
+cfdp::CfdpStates cfdp::DestHandler::getCfdpState() const { return fsmRes.state; }
+
+ReturnValue_t cfdp::DestHandler::handleTransferCompletion() {
+  ReturnValue_t result;
+  if (tp.checksumType != ChecksumType::NULL_CHECKSUM) {
+    result = checksumVerification();
+    if (result != OK) {
+      // TODO: Warning / error handling?
+    }
+  } else {
+    tp.conditionCode = ConditionCode::NO_ERROR;
+  }
+  result = noticeOfCompletion();
+  if (result != OK) {
+  }
+  if (fsmRes.state == CfdpStates::BUSY_CLASS_1_NACKED) {
+    if (tp.closureRequested) {
+      fsmRes.step = TransactionStep::SENDING_FINISHED_PDU;
+    } else {
+      finish();
+    }
+  } else if (fsmRes.state == CfdpStates::BUSY_CLASS_2_ACKED) {
+    fsmRes.step = TransactionStep::SENDING_FINISHED_PDU;
+  }
+  return OK;
+}
+
+void cfdp::DestHandler::finish() {
+  tp.reset();
+  dp.packetListRef.clear();
+  fsmRes.state = CfdpStates::IDLE;
+  fsmRes.step = TransactionStep::IDLE;
+}
+
+ReturnValue_t cfdp::DestHandler::checksumVerification() {
+  std::array<uint8_t, 1024> buf{};
+  // TODO: Checksum verification and notice of completion
+  etl::crc32 crcCalc;
+  uint64_t currentOffset = 0;
+  FileOpParams params(tp.destName.data(), tp.fileSize.value());
+  while (currentOffset < tp.fileSize.value()) {
+    uint64_t readLen;
+    if (currentOffset + buf.size() > tp.fileSize.value()) {
+      readLen = tp.fileSize.value() - currentOffset;
+    } else {
+      readLen = buf.size();
+    }
+    if (readLen > 0) {
+      params.offset = currentOffset;
+      params.size = readLen;
+      auto result = dp.user.vfs.readFromFile(params, buf.data(), buf.size());
+      if (result != OK) {
+        // TODO: I think this is a case for a filestore rejection, but it might sense to print
+        //       a warning or trigger an event because this should generally not happen
+        return FAILED;
+      }
+      crcCalc.add(buf.begin(), buf.begin() + readLen);
+    }
+    currentOffset += readLen;
+  }
+
+  uint32_t value = crcCalc.value();
+  if (value == tp.crc) {
+    tp.conditionCode = ConditionCode::NO_ERROR;
+    tp.deliveryCode = FileDeliveryCode::DATA_COMPLETE;
+  } else {
+    // TODO: Proper error handling
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "CRC check for file " << tp.destName.data() << " failed" << std::endl;
+#endif
+    tp.conditionCode = ConditionCode::FILE_CHECKSUM_FAILURE;
+  }
+  return OK;
+}
+
+ReturnValue_t cfdp::DestHandler::noticeOfCompletion() {
+  if (dp.cfg.indicCfg.transactionFinishedIndicRequired) {
+    TransactionFinishedParams params(tp.transactionId, tp.conditionCode, tp.deliveryCode,
+                                     tp.deliveryStatus);
+    dp.user.transactionFinishedIndication(params);
+  }
+  return OK;
+}
+
+ReturnValue_t cfdp::DestHandler::sendFinishedPdu() {
+  FinishedInfo info(tp.conditionCode, tp.deliveryCode, tp.deliveryStatus);
+  FinishPduCreator finishedPdu(tp.pduConf, info);
+  store_address_t storeId;
+  uint8_t* dataPtr = nullptr;
+  ReturnValue_t result =
+      fp.tmStore->getFreeElement(&storeId, finishedPdu.getSerializedSize(), &dataPtr);
+  if (result != OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "cfdp::DestHandler:sendFinishedPdu: Getting store slot failed" << std::endl;
+#endif
+    fp.eventReporter->forwardEvent(events::STORE_ERROR, result, 0);
+    return result;
+  }
+  size_t serLen = 0;
+  result = finishedPdu.serialize(dataPtr, serLen, finishedPdu.getSerializedSize());
+  if (result != OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "cfdp::DestHandler::sendFinishedPdu: Serializing Finished PDU failed"
+                 << std::endl;
+#endif
+    fp.eventReporter->forwardEvent(events::SERIALIZATION_ERROR, result, 0);
+    return result;
+  }
+  TmTcMessage msg(storeId);
+  result = fp.msgQueue->sendMessage(fp.packetDest.getReportReceptionQueue(), &msg);
+  if (result != OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "cfdp::DestHandler::sendFinishedPdu: Sending PDU failed" << std::endl;
+#endif
+    fp.eventReporter->forwardEvent(events::MSG_QUEUE_ERROR, result, 0);
+    return result;
+  }
+  fsmRes.packetsSent++;
+  return OK;
+}
+
+cfdp::DestHandler::TransactionStep cfdp::DestHandler::getTransactionStep() const {
+  return fsmRes.step;
+}
+
+const cfdp::DestHandler::FsmResult& cfdp::DestHandler::updateFsmRes(uint8_t errors) {
+  fsmRes.errors = errors;
+  fsmRes.result = OK;
+  if (fsmRes.errors > 0) {
+    fsmRes.result = FAILED;
+  }
+  return fsmRes;
+}
+
+const cfdp::TransactionId& cfdp::DestHandler::getTransactionId() const { return tp.transactionId; }
+
+void cfdp::DestHandler::checkAndHandleError(ReturnValue_t result, uint8_t& errorIdx) {
+  if (result != OK and errorIdx < 3) {
+    fsmRes.errorCodes[errorIdx] = result;
+    errorIdx++;
+  }
+}
+
+void cfdp::DestHandler::setMsgQueue(MessageQueueIF& queue) { fp.msgQueue = &queue; }
+
+void cfdp::DestHandler::setEventReporter(EventReportingProxyIF& reporter) {
+  fp.eventReporter = &reporter;
+}
+
+const cfdp::DestHandlerParams& cfdp::DestHandler::getDestHandlerParams() const { return dp; }
+
+StorageManagerIF* cfdp::DestHandler::getTmStore() const { return fp.tmStore; }
+StorageManagerIF* cfdp::DestHandler::getTcStore() const { return fp.tcStore; }

src/fsfw/cfdp/handler/DestHandler.h

@@ -0,0 +1,202 @@
+#ifndef FSFW_CFDP_CFDPDESTHANDLER_H
+#define FSFW_CFDP_CFDPDESTHANDLER_H
+
+#include <etl/list.h>
+#include <etl/set.h>
+
+#include <optional>
+#include <utility>
+
+#include "RemoteConfigTableIF.h"
+#include "UserBase.h"
+#include "defs.h"
+#include "fsfw/cfdp/handler/mib.h"
+#include "fsfw/cfdp/pdu/MetadataPduReader.h"
+#include "fsfw/cfdp/pdu/PduConfig.h"
+#include "fsfw/container/DynamicFIFO.h"
+#include "fsfw/storagemanager/StorageManagerIF.h"
+#include "fsfw/storagemanager/storeAddress.h"
+#include "fsfw/tmtcservices/AcceptsTelemetryIF.h"
+
+namespace cfdp {
+
+struct PacketInfo {
+  PacketInfo(PduType type, store_address_t storeId,
+             std::optional<FileDirective> directive = std::nullopt)
+      : pduType(type), directiveType(directive), storeId(storeId) {}
+
+  PduType pduType = PduType::FILE_DATA;
+  std::optional<FileDirective> directiveType = FileDirective::INVALID_DIRECTIVE;
+  store_address_t storeId = store_address_t::invalid();
+  PacketInfo() = default;
+};
+
+template <size_t SIZE>
+using LostSegmentsList = etl::set<etl::pair<uint64_t, uint64_t>, SIZE>;
+template <size_t SIZE>
+using PacketInfoList = etl::list<PacketInfo, SIZE>;
+using LostSegmentsListBase = etl::iset<etl::pair<uint64_t, uint64_t>>;
+using PacketInfoListBase = etl::ilist<PacketInfo>;
+
+struct DestHandlerParams {
+  DestHandlerParams(LocalEntityCfg cfg, UserBase& user, RemoteConfigTableIF& remoteCfgTable,
+                    PacketInfoListBase& packetList,
+                    // TODO: This container can potentially take tons of space. For a better
+                    //       memory efficient implementation, an additional abstraction could be
+                    //       be used so users can use uint32_t as the pair type
+                    LostSegmentsListBase& lostSegmentsContainer)
+      : cfg(std::move(cfg)),
+        user(user),
+        remoteCfgTable(remoteCfgTable),
+        packetListRef(packetList),
+        lostSegmentsContainer(lostSegmentsContainer) {}
+
+  LocalEntityCfg cfg;
+  UserBase& user;
+  RemoteConfigTableIF& remoteCfgTable;
+
+  PacketInfoListBase& packetListRef;
+  LostSegmentsListBase& lostSegmentsContainer;
+  uint8_t maxTlvsInOnePdu = 10;
+  size_t maxFilenameLen = 255;
+};
+
+struct FsfwParams {
+  FsfwParams(AcceptsTelemetryIF& packetDest, MessageQueueIF* msgQueue,
+             EventReportingProxyIF* eventReporter, StorageManagerIF& tcStore,
+             StorageManagerIF& tmStore)
+      : FsfwParams(packetDest, msgQueue, eventReporter) {
+    this->tcStore = &tcStore;
+    this->tmStore = &tmStore;
+  }
+
+  FsfwParams(AcceptsTelemetryIF& packetDest, MessageQueueIF* msgQueue,
+             EventReportingProxyIF* eventReporter)
+      : packetDest(packetDest), msgQueue(msgQueue), eventReporter(eventReporter) {}
+  AcceptsTelemetryIF& packetDest;
+  MessageQueueIF* msgQueue;
+  EventReportingProxyIF* eventReporter = nullptr;
+  StorageManagerIF* tcStore = nullptr;
+  StorageManagerIF* tmStore = nullptr;
+};
+
+enum class CallStatus { DONE, CALL_AFTER_DELAY, CALL_AGAIN };
+
+class DestHandler {
+ public:
+  enum class TransactionStep {
+    IDLE = 0,
+    TRANSACTION_START = 1,
+    RECEIVING_FILE_DATA_PDUS = 2,
+    SENDING_ACK_PDU = 3,
+    TRANSFER_COMPLETION = 4,
+    SENDING_FINISHED_PDU = 5
+  };
+
+  struct FsmResult {
+   public:
+    ReturnValue_t result = returnvalue::OK;
+    CallStatus callStatus = CallStatus::CALL_AFTER_DELAY;
+    TransactionStep step = TransactionStep::IDLE;
+    CfdpStates state = CfdpStates::IDLE;
+    uint32_t packetsSent = 0;
+    uint8_t errors = 0;
+    std::array<ReturnValue_t, 3> errorCodes = {};
+    void resetOfIteration() {
+      result = returnvalue::OK;
+      callStatus = CallStatus::CALL_AFTER_DELAY;
+      packetsSent = 0;
+      errors = 0;
+      errorCodes.fill(returnvalue::OK);
+    }
+  };
+  /**
+   * Will be returned if it is advisable to call the state machine operation call again
+   */
+  ReturnValue_t PARTIAL_SUCCESS = returnvalue::makeCode(0, 2);
+  ReturnValue_t FAILURE = returnvalue::makeCode(0, 3);
+  explicit DestHandler(DestHandlerParams handlerParams, FsfwParams fsfwParams);
+
+  /**
+   *
+   * @return
+   *  - @c returnvalue::OK  State machine OK for this execution cycle
+   *  - @c CALL_FSM_AGAIN   State machine should be called again.
+   */
+  const FsmResult& performStateMachine();
+  void setMsgQueue(MessageQueueIF& queue);
+  void setEventReporter(EventReportingProxyIF& reporter);
+
+  ReturnValue_t passPacket(PacketInfo packet);
+
+  ReturnValue_t initialize();
+
+  [[nodiscard]] CfdpStates getCfdpState() const;
+  [[nodiscard]] TransactionStep getTransactionStep() const;
+  [[nodiscard]] const TransactionId& getTransactionId() const;
+  [[nodiscard]] const DestHandlerParams& getDestHandlerParams() const;
+  [[nodiscard]] StorageManagerIF* getTcStore() const;
+  [[nodiscard]] StorageManagerIF* getTmStore() const;
+
+ private:
+  struct TransactionParams {
+    // Initialize char vectors with length + 1 for 0 termination
+    explicit TransactionParams(size_t maxFileNameLen)
+        : sourceName(maxFileNameLen + 1), destName(maxFileNameLen + 1) {}
+
+    void reset() {
+      pduConf = PduConfig();
+      transactionId = TransactionId();
+      std::fill(sourceName.begin(), sourceName.end(), '\0');
+      std::fill(destName.begin(), destName.end(), '\0');
+      fileSize.setFileSize(0, false);
+      conditionCode = ConditionCode::NO_ERROR;
+      deliveryCode = FileDeliveryCode::DATA_INCOMPLETE;
+      deliveryStatus = FileDeliveryStatus::DISCARDED_DELIBERATELY;
+      crc = 0;
+      progress = 0;
+      remoteCfg = nullptr;
+      closureRequested = false;
+      checksumType = ChecksumType::NULL_CHECKSUM;
+    }
+
+    ChecksumType checksumType = ChecksumType::NULL_CHECKSUM;
+    bool closureRequested = false;
+    std::vector<char> sourceName;
+    std::vector<char> destName;
+    cfdp::FileSize fileSize;
+    TransactionId transactionId;
+    PduConfig pduConf;
+    ConditionCode conditionCode = ConditionCode::NO_ERROR;
+    FileDeliveryCode deliveryCode = FileDeliveryCode::DATA_INCOMPLETE;
+    FileDeliveryStatus deliveryStatus = FileDeliveryStatus::DISCARDED_DELIBERATELY;
+    uint32_t crc = 0;
+    uint64_t progress = 0;
+    RemoteEntityCfg* remoteCfg = nullptr;
+  };
+
+  std::vector<cfdp::Tlv> tlvVec;
+  std::vector<cfdp::Tlv> userTlvVec;
+  DestHandlerParams dp;
+  FsfwParams fp;
+  TransactionParams tp;
+  FsmResult fsmRes;
+
+  ReturnValue_t startTransaction(MetadataPduReader& reader, MetadataInfo& info);
+  ReturnValue_t handleMetadataPdu(const PacketInfo& info);
+  ReturnValue_t handleFileDataPdu(const PacketInfo& info);
+  ReturnValue_t handleEofPdu(const PacketInfo& info);
+  ReturnValue_t handleMetadataParseError(ReturnValue_t result, const uint8_t* rawData,
+                                         size_t maxSize);
+  ReturnValue_t handleTransferCompletion();
+  ReturnValue_t sendFinishedPdu();
+  ReturnValue_t noticeOfCompletion();
+  ReturnValue_t checksumVerification();
+  const FsmResult& updateFsmRes(uint8_t errors);
+  void checkAndHandleError(ReturnValue_t result, uint8_t& errorIdx);
+  void finish();
+};
+
+}  // namespace cfdp
+
+#endif  // FSFW_CFDP_CFDPDESTHANDLER_H

src/fsfw/cfdp/handler/SourceHandler.cpp

@@ -0,0 +1 @@
+#include "SourceHandler.h"

src/fsfw/cfdp/handler/SourceHandler.h

@@ -0,0 +1,6 @@
+#ifndef FSFW_CFDP_CFDPSOURCEHANDLER_H
+#define FSFW_CFDP_CFDPSOURCEHANDLER_H
+
+class SourceHandler {};
+
+#endif  // FSFW_CFDP_CFDPSOURCEHANDLER_H

src/fsfw/cfdp/handler/defs.h

@@ -5,5 +5,15 @@ namespace cfdp {
 
 enum class CfdpStates { IDLE, BUSY_CLASS_1_NACKED, BUSY_CLASS_2_ACKED, SUSPENDED };
 
-}
+static constexpr uint8_t SSID = SUBSYSTEM_ID::CFDP;
+
+namespace events {
+
+static constexpr Event STORE_ERROR = event::makeEvent(SSID, 0, severity::LOW);
+static constexpr Event MSG_QUEUE_ERROR = event::makeEvent(SSID, 1, severity::LOW);
+static constexpr Event SERIALIZATION_ERROR = event::makeEvent(SSID, 2, severity::LOW);
+
+}  // namespace events
+
+}  // namespace cfdp
 #endif  // FSFW_CFDP_HANDLER_DEFS_H

src/fsfw/cfdp/pdu/EofInfo.cpp

@@ -42,6 +42,6 @@ size_t EofInfo::getSerializedSize(bool fssLarge) {
   return size;
 }
 
-ReturnValue_t EofInfo::setFileSize(uint64_t fileSize, bool isLarge) {
+ReturnValue_t EofInfo::setFileSize(size_t fileSize, bool isLarge) {
   return this->fileSize.setFileSize(fileSize, isLarge);
 }

src/fsfw/cfdp/pdu/EofInfo.h

@@ -21,7 +21,7 @@ struct EofInfo {
   void setChecksum(uint32_t checksum);
   void setConditionCode(cfdp::ConditionCode conditionCode);
   void setFaultLoc(EntityIdTlv* faultLoc);
-  ReturnValue_t setFileSize(uint64_t size, bool isLarge);
+  ReturnValue_t setFileSize(size_t size, bool isLarge);
 
  private:
   cfdp::ConditionCode conditionCode;

src/fsfw/cfdp/pdu/FinishedPduReader.cpp

@@ -1,10 +1,5 @@
 #include "FinishedPduReader.h"
 
-// Thanks, windows
-#ifdef NO_ERROR
-#undef NO_ERROR
-#endif
-
 FinishPduReader::FinishPduReader(const uint8_t* pduBuf, size_t maxSize, FinishedInfo& info)
     : FileDirectiveReader(pduBuf, maxSize), finishedInfo(info) {}
 

src/fsfw/cfdp/tlv/EntityIdTlv.h

@@ -23,7 +23,6 @@ class EntityIdTlv : public TlvIF {
    */
   ReturnValue_t deSerialize(cfdp::Tlv& tlv, Endianness endianness);
 
-  using SerializeIF::deSerialize;
   ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
                             Endianness streamEndianness) override;
 

src/fsfw/cfdp/tlv/FilestoreRequestTlv.h

@@ -26,7 +26,6 @@ class FilestoreRequestTlv : public cfdp::FilestoreTlvBase {
    */
   ReturnValue_t deSerialize(cfdp::Tlv &tlv, Endianness endianness);
 
-  using SerializeIF::deSerialize;
   ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
                             Endianness streamEndianness) override;
 

src/fsfw/cfdp/tlv/FilestoreResponseTlv.h

@@ -29,7 +29,6 @@ class FilestoreResponseTlv : public cfdp::FilestoreTlvBase {
    */
   ReturnValue_t deSerialize(const cfdp::Tlv& tlv, Endianness endianness);
 
-  using SerializeIF::deSerialize;
   ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
                             Endianness streamEndianness) override;
 

src/fsfw/container/FixedArrayList.h

@@ -12,7 +12,6 @@ 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(),
                 "count_t is not large enough to hold MAX_SIZE");
-  static_assert(MAX_SIZE > 0, "MAX_SIZE is 0");
 
  private:
   T data[MAX_SIZE];

src/fsfw/datapoollocal/LocalDataPoolManager.h

@@ -364,10 +364,6 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
   void printWarningOrError(sif::OutputTypes outputType, const char* functionName,
                            ReturnValue_t errorCode = returnvalue::FAILED,
                            const char* errorPrint = nullptr);
-
- private:
-  using ProvidesDataPoolSubscriptionIF::subscribeForPeriodicPacket;
-  using ProvidesDataPoolSubscriptionIF::subscribeForUpdatePacket;
 };
 
 template <class T>

src/fsfw/devicehandlers/DeviceHandlerBase.cpp

@@ -1,6 +1,5 @@
 #include "fsfw/devicehandlers/DeviceHandlerBase.h"
 
-#include "fsfw/datapool/PoolReadGuard.h"
 #include "fsfw/datapoollocal/LocalPoolVariable.h"
 #include "fsfw/devicehandlers/AcceptsDeviceResponsesIF.h"
 #include "fsfw/devicehandlers/DeviceTmReportingWrapper.h"
@@ -322,7 +321,8 @@ void DeviceHandlerBase::doStateMachine() {
       if (mode != currentMode) {
         break;
       }
-      uint32_t currentUptime = Clock::getUptime_ms();
+      uint32_t currentUptime;
+      Clock::getUptime(&currentUptime);
       if (currentUptime - timeoutStart >= childTransitionDelay) {
 #if FSFW_VERBOSE_LEVEL >= 1 && FSFW_OBJ_EVENT_TRANSLATION == 0
         char printout[60];
@@ -346,7 +346,8 @@ void DeviceHandlerBase::doStateMachine() {
       setMode(_MODE_WAIT_ON);
       break;
     case _MODE_WAIT_ON: {
-      uint32_t currentUptime = Clock::getUptime_ms();
+      uint32_t currentUptime;
+      Clock::getUptime(&currentUptime);
       if (powerSwitcher != nullptr and
           currentUptime - timeoutStart >= powerSwitcher->getSwitchDelayMs()) {
         triggerEvent(MODE_TRANSITION_FAILED, PowerSwitchIF::SWITCH_TIMEOUT, 0);
@@ -365,7 +366,8 @@ void DeviceHandlerBase::doStateMachine() {
       }
     } break;
     case _MODE_WAIT_OFF: {
-      uint32_t currentUptime = Clock::getUptime_ms();
+      uint32_t currentUptime;
+      Clock::getUptime(&currentUptime);
 
       if (powerSwitcher == nullptr) {
         setMode(MODE_OFF);
@@ -575,7 +577,7 @@ void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
     modeHelper.modeChanged(newMode, newSubmode);
     announceMode(false);
   }
-  timeoutStart = Clock::getUptime_ms();
+  Clock::getUptime(&timeoutStart);
 
   if (mode == MODE_OFF and thermalSet != nullptr) {
     ReturnValue_t result = thermalSet->read();
@@ -1506,13 +1508,10 @@ DeviceCommandId_t DeviceHandlerBase::getPendingCommand() const {
 void DeviceHandlerBase::setNormalDatapoolEntriesInvalid() {
   for (const auto& reply : deviceReplyMap) {
     if (reply.second.dataSet != nullptr) {
-      PoolReadGuard pg(reply.second.dataSet);
-      if (pg.getReadResult() == returnvalue::OK) {
       reply.second.dataSet->setValidity(false, true);
     }
   }
 }
-}
 
 void DeviceHandlerBase::printWarningOrError(sif::OutputTypes errorType, const char* functionName,
                                             ReturnValue_t errorCode, const char* errorPrint) {

src/fsfw/devicehandlers/DeviceHandlerBase.h

@@ -206,9 +206,9 @@ class DeviceHandlerBase : public DeviceHandlerIF,
 
   Mode_t getTransitionSourceMode() const;
   Submode_t getTransitionSourceSubMode() const;
-  virtual void getMode(Mode_t *mode, Submode_t *submode) override;
+  virtual void getMode(Mode_t *mode, Submode_t *submode);
-  HealthState getHealth() override;
+  HealthState getHealth();
-  ReturnValue_t setHealth(HealthState health) override;
+  ReturnValue_t setHealth(HealthState health);
   virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
                                      ParameterWrapper *parameterWrapper,
                                      const ParameterWrapper *newValues,
@@ -1073,7 +1073,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
                       bool forceDirectTm = false);
 
   virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-                                         uint32_t *msToReachTheMode) override;
+                                         uint32_t *msToReachTheMode);
 
   virtual ReturnValue_t letChildHandleMessage(CommandMessage *message);
 

src/fsfw/events/EventManager.cpp

@@ -15,16 +15,14 @@ const LocalPool::LocalPoolConfig EventManager::poolConfig = {
     {fsfwconfig::FSFW_EVENTMGMT_EVENTIDMATCHERS, sizeof(EventIdRangeMatcher)},
     {fsfwconfig::FSFW_EVENTMGMR_RANGEMATCHERS, sizeof(ReporterRangeMatcher)}};
 
-EventManager::EventManager(object_id_t setObjectId, uint32_t eventQueueDepth)
+EventManager::EventManager(object_id_t setObjectId)
     : SystemObject(setObjectId), factoryBackend(0, poolConfig, false, true) {
   mutex = MutexFactory::instance()->createMutex();
-  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
+  eventReportQueue = QueueFactory::instance()->createMessageQueue(MAX_EVENTS_PER_CYCLE,
-  eventReportQueue = QueueFactory::instance()->createMessageQueue(
+                                                                  EventMessage::EVENT_MESSAGE_SIZE);
-      eventQueueDepth, EventMessage::EVENT_MESSAGE_SIZE, &mqArgs);
 }
 
 EventManager::~EventManager() {
-  listenerList.clear();
   QueueFactory::instance()->deleteMessageQueue(eventReportQueue);
   MutexFactory::instance()->deleteMutex(mutex);
 }
@@ -48,20 +46,9 @@ ReturnValue_t EventManager::performOperation(uint8_t opCode) {
 
 void EventManager::notifyListeners(EventMessage* message) {
   lockMutex();
-  for (auto& listener : listenerList) {
+  for (auto iter = listenerList.begin(); iter != listenerList.end(); ++iter) {
-    if (listener.second.match(message)) {
+    if (iter->second.match(message)) {
-      ReturnValue_t result =
+      MessageQueueSenderIF::sendMessage(iter->first, message, message->getSender());
-          MessageQueueSenderIF::sendMessage(listener.first, message, message->getSender());
-      if (result != returnvalue::OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << std::hex << "EventManager::notifyListeners: MSG to 0x" << std::setfill('0')
-                   << std::setw(8) << listener.first << " failed with result 0x" << std::setw(4)
-                   << result << std::setfill(' ') << std::endl;
-#else
-        sif::printError("Sending message to listener 0x%08x failed with result %04x\n",
-                        listener.first, result);
-#endif
-      }
     }
   }
   unlockMutex();
@@ -74,14 +61,9 @@ ReturnValue_t EventManager::registerListener(MessageQueueId_t listener,
   if (!result.second) {
     return returnvalue::FAILED;
   }
-
   return returnvalue::OK;
 }
 
-ReturnValue_t EventManager::unregisterListener(MessageQueueId_t listener) {
-  return listenerList.erase(listener) == 1 ? returnvalue::OK : returnvalue::FAILED;
-}
-
 ReturnValue_t EventManager::subscribeToEvent(MessageQueueId_t listener, EventId_t event) {
   return subscribeToEventRange(listener, event);
 }
@@ -212,19 +194,4 @@ void EventManager::printUtility(sif::OutputTypes printType, EventMessage* messag
   }
 }
 
-void EventManager::printListeners() {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::info << "Event manager listener MQ IDs:" << std::setfill('0') << std::hex << std::endl;
-  for (auto& listener : listenerList) {
-    sif::info << "0x" << std::setw(8) << listener.first << std::endl;
-  }
-  sif::info << std::dec << std::setfill(' ');
-#else
-  sif::printInfo("Event manager listener MQ IDs:\n");
-  for (auto& listener : listenerList) {
-    sif::printInfo("0x%08x\n", listener.first);
-  }
-#endif
-}
-
 #endif /* FSFW_OBJ_EVENT_TRANSLATION == 1 */

src/fsfw/events/EventManager.h

@@ -21,32 +21,28 @@ extern const char* translateEvents(Event event);
 
 class EventManager : public EventManagerIF, public ExecutableObjectIF, public SystemObject {
  public:
+  static const uint16_t MAX_EVENTS_PER_CYCLE = 80;
 
-  EventManager(object_id_t setObjectId, uint32_t eventQueueDepth);
+  EventManager(object_id_t setObjectId);
   virtual ~EventManager();
 
   void setMutexTimeout(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs);
 
-  MessageQueueId_t getEventReportQueue() override;
+  MessageQueueId_t getEventReportQueue();
 
-  ReturnValue_t registerListener(MessageQueueId_t listener,
+  ReturnValue_t registerListener(MessageQueueId_t listener, bool forwardAllButSelected = false);
-                                 bool forwardAllButSelected = false) override;
+  ReturnValue_t subscribeToEvent(MessageQueueId_t listener, EventId_t event);
-  ReturnValue_t unregisterListener(MessageQueueId_t listener) override;
+  ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener, object_id_t object);
-  ReturnValue_t subscribeToEvent(MessageQueueId_t listener, EventId_t event) override;
-  ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener, object_id_t object) override;
   ReturnValue_t subscribeToEventRange(MessageQueueId_t listener, EventId_t idFrom = 0,
                                       EventId_t idTo = 0, bool idInverted = false,
                                       object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
-                                      bool reporterInverted = false) override;
+                                      bool reporterInverted = false);
-  ReturnValue_t unsubscribeFromAllEvents(MessageQueueId_t listener, object_id_t object) override;
+  ReturnValue_t unsubscribeFromAllEvents(MessageQueueId_t listener, object_id_t object);
   ReturnValue_t unsubscribeFromEventRange(MessageQueueId_t listener, EventId_t idFrom = 0,
                                           EventId_t idTo = 0, bool idInverted = false,
                                           object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
-                                          bool reporterInverted = false) override;
+                                          bool reporterInverted = false);
-  ReturnValue_t performOperation(uint8_t opCode) override;
+  ReturnValue_t performOperation(uint8_t opCode);
-
-  void printListeners();
-
 
  protected:
   MessageQueueIF* eventReportQueue = nullptr;

src/fsfw/events/EventManagerIF.h

@@ -18,7 +18,6 @@ class EventManagerIF {
 
   virtual ReturnValue_t registerListener(MessageQueueId_t listener,
                                          bool forwardAllButSelected = false) = 0;
-  virtual ReturnValue_t unregisterListener(MessageQueueId_t listener) = 0;
   virtual ReturnValue_t subscribeToEvent(MessageQueueId_t listener, EventId_t event) = 0;
   virtual ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener, object_id_t object) = 0;
   virtual ReturnValue_t unsubscribeFromAllEvents(MessageQueueId_t listener, object_id_t object) = 0;

src/fsfw/events/fwSubsystemIdRanges.h

@@ -10,7 +10,7 @@ enum : uint8_t {
   CDH = 28,
   TCS_1 = 59,
   PCDU_1 = 42,
-  POWER_SWITCH_IF = 43,
+  PCDU_2 = 43,
   HEATER = 50,
   T_SENSORS = 52,
   FDIR = 70,

src/fsfw/fdir/FailureIsolationBase.cpp

@@ -23,7 +23,7 @@ FailureIsolationBase::~FailureIsolationBase() {
 #endif
     return;
   }
-  manager->unregisterListener(eventQueue->getId());
+  manager->unsubscribeFromAllEvents(eventQueue->getId(), ownerId);
   QueueFactory::instance()->deleteMessageQueue(eventQueue);
 }
 

src/fsfw/globalfunctions/DleParser.cpp

@@ -52,7 +52,6 @@ ReturnValue_t DleParser::parseRingBuf(size_t& readSize) {
         // without skipping the STX
         readSize = vectorIdx;
         ErrorInfo info;
-        info.len = vectorIdx;
         setErrorContext(ErrorTypes::CONSECUTIVE_STX_CHARS, info);
         return POSSIBLE_PACKET_LOSS;
       }

src/fsfw/globalfunctions/Type.h

@@ -58,7 +58,7 @@ class Type : public SerializeIF {
 
 template <typename T>
 struct PodTypeConversion {
-  static_assert(!std::is_same<T, bool>::value,
+  static_assert(not std::is_same<T, bool>::value,
                 "Do not use boolean for the PoolEntry type, use uint8_t "
                 "instead! The ECSS standard defines a boolean as a one bit "
                 "field. Therefore it is preferred to store a boolean as an "

src/fsfw/globalfunctions/arrayprinter.cpp

@@ -37,16 +37,16 @@ void arrayprinter::print(const uint8_t *data, size_t size, OutputType type, bool
   }
 }
 
-void arrayprinter::printHex(const uint8_t *data, size_t datasize, size_t maxCharPerLine) {
+void arrayprinter::printHex(const uint8_t *data, size_t size, size_t maxCharPerLine) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
   if (sif::info.crAdditionEnabled()) {
     std::cout << "\r" << std::endl;
   }
 
   std::cout << "hex [" << std::setfill('0') << std::hex;
-  for (size_t i = 0; i < datasize; i++) {
+  for (size_t i = 0; i < size; i++) {
     std::cout << std::setw(2) << static_cast<int>(data[i]);
-    if (i < datasize - 1) {
+    if (i < size - 1) {
       std::cout << ",";
       if (i > 0 and (i + 1) % maxCharPerLine == 0) {
         std::cout << std::endl;
@@ -56,11 +56,27 @@ void arrayprinter::printHex(const uint8_t *data, size_t datasize, size_t maxChar
   std::cout << std::dec << std::setfill(' ');
   std::cout << "]" << std::endl;
 #else
-  printf("hex [");
+  // General format: 0x01, 0x02, 0x03 so it is number of chars times 6
-  for (size_t i = 0; i < datasize; i++) {
+  // plus line break plus small safety margin.
-    printf("0x%02x ", data[i]);
+  char printBuffer[(size + 1) * 7 + 1] = {};
+  size_t currentPos = 0;
+  for (size_t i = 0; i < size; i++) {
+    // To avoid buffer overflows.
+    if (sizeof(printBuffer) - currentPos <= 7) {
+      break;
     }
-  printf("]\n");
+
+    currentPos += snprintf(printBuffer + currentPos, 6, "%02x", data[i]);
+    if (i < size - 1) {
+      currentPos += sprintf(printBuffer + currentPos, ",");
+      if ((i + 1) % maxCharPerLine == 0) {
+        currentPos += sprintf(printBuffer + currentPos, "\n");
+      }
+    }
+  }
+#if FSFW_DISABLE_PRINTOUT == 0
+  printf("hex [%s]\n", printBuffer);
+#endif /* FSFW_DISABLE_PRINTOUT == 0 */
 #endif
 }
 
@@ -84,10 +100,26 @@ void arrayprinter::printDec(const uint8_t *data, size_t size, size_t maxCharPerL
 #else
   // General format: 32,243,-12 so it is number of chars times 4
   // plus line break plus small safety margin.
-
+  uint16_t expectedLines = ceil((double)size / maxCharPerLine);
+  char printBuffer[size * 4 + 1 + expectedLines] = {};
+  size_t currentPos = 0;
   for (size_t i = 0; i < size; i++) {
-    // TODO
+    // To avoid buffer overflows.
+    if (sizeof(printBuffer) - currentPos <= 4) {
+      break;
     }
+
+    currentPos += snprintf(printBuffer + currentPos, 4, "%d", data[i]);
+    if (i < size - 1) {
+      currentPos += sprintf(printBuffer + currentPos, ",");
+      if ((i + 1) % maxCharPerLine == 0) {
+        currentPos += sprintf(printBuffer + currentPos, "\n");
+      }
+    }
+  }
+#if FSFW_DISABLE_PRINTOUT == 0
+  printf("dec [%s]\n", printBuffer);
+#endif /* FSFW_DISABLE_PRINTOUT == 0 */
 #endif
 }
 

src/fsfw/globalfunctions/matching/MatchTree.h

@@ -24,7 +24,7 @@ class MatchTree : public SerializeableMatcherIF<T>, public BinaryTree<Serializea
   MatchTree(iterator root, uint8_t maxDepth = -1)
       : BinaryTree<SerializeableMatcherIF<T>>(root.element), maxDepth(maxDepth) {}
   MatchTree() : BinaryTree<SerializeableMatcherIF<T>>(), maxDepth(-1) {}
-  virtual ~MatchTree() { clear(); }
+  virtual ~MatchTree() {}
   virtual bool match(T number) override { return matchesTree(number); }
   bool matchesTree(T number) {
     iterator iter = this->begin();
@@ -176,45 +176,6 @@ class MatchTree : public SerializeableMatcherIF<T>, public BinaryTree<Serializea
     return cleanUpElement(position);
   }
 
-  void clear() {
-    Node* localRoot = BinaryTree<SerializeableMatcherIF<T>>::rootNode;
-
-    if (localRoot == nullptr) {
-      return;
-    }
-
-    Node* node = localRoot->left;
-
-    while (true) {
-      if (node->left != nullptr) {
-        node = node->left;
-        continue;
-      }
-      if (node->right != nullptr) {
-        node = node->right;
-        continue;
-      }
-      if (node->parent == nullptr) {
-        // this is the root node with no children
-        if (node->value != nullptr) {
-          cleanUpElement(iterator(node));
-        }
-        return;
-      }
-      // leaf
-      {
-        Node* parent = node->parent;
-        if (parent->left == node) {
-          parent->left = nullptr;
-        } else {
-          parent->right = nullptr;
-        }
-        cleanUpElement(iterator(node));
-        node = parent;
-      }
-    }
-  }
-
   virtual ReturnValue_t cleanUpElement(iterator position) { return returnvalue::OK; }
 
   bool matchSubtree(iterator iter, T number) {

src/fsfw/health/HasHealthIF.h

@@ -16,24 +16,26 @@ class HasHealthIF {
   };
 
   static const uint8_t INTERFACE_ID = CLASS_ID::HAS_HEALTH_IF;
-  static constexpr ReturnValue_t OBJECT_NOT_HEALTHY = returnvalue::makeCode(INTERFACE_ID, 1);
+  static const ReturnValue_t OBJECT_NOT_HEALTHY = MAKE_RETURN_CODE(1);
-  static constexpr ReturnValue_t INVALID_HEALTH_STATE = returnvalue::makeCode(INTERFACE_ID, 2);
+  static const ReturnValue_t INVALID_HEALTH_STATE = MAKE_RETURN_CODE(2);
-  static constexpr ReturnValue_t IS_EXTERNALLY_CONTROLLED = returnvalue::makeCode(INTERFACE_ID, 3);
 
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER_1;
-  //! P1: New Health, P2: Old Health
   static const Event HEALTH_INFO = MAKE_EVENT(6, severity::INFO);
   static const Event CHILD_CHANGED_HEALTH = MAKE_EVENT(7, severity::INFO);
   static const Event CHILD_PROBLEMS = MAKE_EVENT(8, severity::LOW);
-  //! Assembly overwrites health information of children to keep satellite alive.
+  static const Event OVERWRITING_HEALTH =
-  static const Event OVERWRITING_HEALTH = MAKE_EVENT(9, severity::LOW);
+      MAKE_EVENT(9, severity::LOW);  //!< Assembly overwrites health information of children to keep
-  //! Someone starts a recovery of a component (typically power-cycle). No parameters.
+                                     //!< satellite alive.
-  static const Event TRYING_RECOVERY = MAKE_EVENT(10, severity::MEDIUM);
+  static const Event TRYING_RECOVERY =
-  //! Recovery is ongoing. Comes twice during recovery.
+      MAKE_EVENT(10, severity::MEDIUM);  //!< Someone starts a recovery of a component (typically
-  //! P1: 0 for the first, 1 for the second event. P2: 0
+                                         //!< power-cycle). No parameters.
-  static const Event RECOVERY_STEP = MAKE_EVENT(11, severity::MEDIUM);
+  static const Event RECOVERY_STEP =
-  //! Recovery was completed. Not necessarily successful. No parameters.
+      MAKE_EVENT(11, severity::MEDIUM);  //!< Recovery is ongoing. Comes twice during recovery. P1:
-  static const Event RECOVERY_DONE = MAKE_EVENT(12, severity::MEDIUM);
+                                         //!< 0 for the first, 1 for the second event. P2: 0
+  static const Event RECOVERY_DONE = MAKE_EVENT(
+      12,
+      severity::MEDIUM);  //!< Recovery was completed. Not necessarily successful. No parameters.
+
   virtual ~HasHealthIF() {}
 
   virtual MessageQueueId_t getCommandQueue() const = 0;

src/fsfw/health/HealthTable.cpp

@@ -6,6 +6,8 @@
 
 HealthTable::HealthTable(object_id_t objectid) : SystemObject(objectid) {
   mutex = MutexFactory::instance()->createMutex();
+  ;
+
   mapIterator = healthMap.begin();
 }
 

src/fsfw/health/HealthTable.h

@@ -8,8 +8,6 @@
 #include "HealthTableIF.h"
 
 class HealthTable : public HealthTableIF, public SystemObject {
-  friend class CServiceHealthCommanding;
-
  public:
   explicit HealthTable(object_id_t objectid);
   ~HealthTable() override;

src/fsfw/housekeeping/HousekeepingSnapshot.h

@@ -55,7 +55,7 @@ class HousekeepingSnapshot : public SerializeIF {
       : timeStamp(timeStamp), timeStampSize(timeStampSize), updateData(dataSetPtr){};
 
   virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                                  Endianness streamEndianness) const override {
+                                  Endianness streamEndianness) const {
     if (timeStamp != nullptr) {
       /* Endianness will always be MACHINE, so we can simply use memcpy
       here. */
@@ -70,7 +70,7 @@ class HousekeepingSnapshot : public SerializeIF {
     return updateData->serialize(buffer, size, maxSize, streamEndianness);
   }
 
-  virtual size_t getSerializedSize() const override {
+  virtual size_t getSerializedSize() const {
     if (updateData == nullptr) {
       return 0;
     }

src/fsfw/internalerror/InternalErrorReporter.cpp

@@ -7,17 +7,14 @@
 
 InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId, uint32_t messageQueueDepth)
     : SystemObject(setObjectId),
+      commandQueue(QueueFactory::instance()->createMessageQueue(messageQueueDepth)),
       poolManager(this, commandQueue),
       internalErrorSid(setObjectId, InternalErrorDataset::ERROR_SET_ID),
       internalErrorDataset(this) {
-  commandQueue = QueueFactory::instance()->createMessageQueue(messageQueueDepth);
   mutex = MutexFactory::instance()->createMutex();
 }
 
-InternalErrorReporter::~InternalErrorReporter() {
+InternalErrorReporter::~InternalErrorReporter() { MutexFactory::instance()->deleteMutex(mutex); }
-  MutexFactory::instance()->deleteMutex(mutex);
-  QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
 
 void InternalErrorReporter::setDiagnosticPrintout(bool enable) {
   this->diagnosticPrintout = enable;

src/fsfw/modes/ModeMessage.cpp

@@ -24,19 +24,3 @@ void ModeMessage::setCantReachMode(CommandMessage* message, ReturnValue_t reason
   message->setParameter(reason);
   message->setParameter2(0);
 }
-
-void ModeMessage::setModeAnnounceMessage(CommandMessage& message, bool recursive) {
-  Command_t cmd;
-  if (recursive) {
-    cmd = CMD_MODE_ANNOUNCE_RECURSIVELY;
-  } else {
-    cmd = CMD_MODE_ANNOUNCE;
-  }
-  message.setCommand(cmd);
-}
-
-void ModeMessage::setCmdModeMessage(CommandMessage& message, Mode_t mode, Submode_t submode) {
-  setModeMessage(&message, CMD_MODE_COMMAND, mode, submode);
-}
-
-void ModeMessage::setModeReadMessage(CommandMessage& message) { message.setCommand(CMD_MODE_READ); }

src/fsfw/modes/ModeMessage.h

@@ -45,9 +45,6 @@ class ModeMessage {
 
   static void setModeMessage(CommandMessage* message, Command_t command, Mode_t mode,
                              Submode_t submode);
-  static void setCmdModeMessage(CommandMessage& message, Mode_t mode, Submode_t submode);
-  static void setModeAnnounceMessage(CommandMessage& message, bool recursive);
-  static void setModeReadMessage(CommandMessage& message);
   static void setCantReachMode(CommandMessage* message, ReturnValue_t reason);
   static void clear(CommandMessage* message);
 };

src/fsfw/monitoring/AbsLimitMonitor.h

@@ -18,7 +18,7 @@ class AbsLimitMonitor : public MonitorBase<T> {
         violationEvent(violationEvent),
         aboveIsViolation(aboveIsViolation) {}
   virtual ~AbsLimitMonitor() {}
-  ReturnValue_t checkSample(T sample, T *crossedLimit) override {
+  virtual ReturnValue_t checkSample(T sample, T *crossedLimit) {
     *crossedLimit = limit;
     if (aboveIsViolation) {
       if ((std::abs(sample) > limit)) {
@@ -32,9 +32,9 @@ class AbsLimitMonitor : public MonitorBase<T> {
     return returnvalue::OK;  // We're not out of range.
   }
 
-  ReturnValue_t getParameter(uint8_t domainId, uint8_t parameterId,
+  virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-                             ParameterWrapper *parameterWrapper, const ParameterWrapper *newValues,
+                                     ParameterWrapper *parameterWrapper,
-                             uint16_t startAtIndex) override {
+                                     const ParameterWrapper *newValues, uint16_t startAtIndex) {
     ReturnValue_t result = this->MonitorBase<T>::getParameter(
         domainId, parameterId, parameterWrapper, newValues, startAtIndex);
     // We'll reuse the DOMAIN_ID of MonitorReporter,
@@ -61,7 +61,7 @@ class AbsLimitMonitor : public MonitorBase<T> {
   void setLimit(T value) { limit = value; }
 
  protected:
-  void sendTransitionEvent(T currentValue, ReturnValue_t state) override {
+  void sendTransitionEvent(T currentValue, ReturnValue_t state) {
     switch (state) {
       case MonitoringIF::OUT_OF_RANGE:
         EventManagerIF::triggerEvent(this->reportingId, violationEvent, this->globalPoolId.objectId,

src/fsfw/objectmanager/ObjectManager.cpp

@@ -23,17 +23,9 @@ void ObjectManager::setObjectFactoryFunction(produce_function_t objFactoryFunc,
 
 ObjectManager::ObjectManager() = default;
 
-void ObjectManager::clear() {
-  if (objManagerInstance != nullptr) {
-    delete objManagerInstance;
-    objManagerInstance = nullptr;
-  }
-}
-
 ObjectManager::~ObjectManager() {
-  teardown = true;
+  for (auto const& iter : objectList) {
-  for (auto iter = objectList.begin(); iter != objectList.end(); iter = objectList.erase(iter)) {
+    delete iter.second;
-    delete iter->second;
   }
 }
 
@@ -61,12 +53,6 @@ ReturnValue_t ObjectManager::insert(object_id_t id, SystemObjectIF* object) {
 }
 
 ReturnValue_t ObjectManager::remove(object_id_t id) {
-  // this function is called during destruction of System Objects
-  // disabeld for teardown to avoid iterator invalidation and
-  // double free
-  if (teardown) {
-    return returnvalue::OK;
-  }
   if (this->getSystemObject(id) != nullptr) {
     this->objectList.erase(id);
 #if FSFW_CPP_OSTREAM_ENABLED == 1

src/fsfw/objectmanager/ObjectManager.h

@@ -24,17 +24,12 @@ class ObjectManager : public ObjectManagerIF {
   using produce_function_t = void (*)(void* args);
 
   /**
-   * Returns the single instance of ObjectManager.
+   * Returns the single instance of TaskFactory.
    * The implementation of #instance is found in its subclasses.
    * Thus, we choose link-time variability of the  instance.
    */
   static ObjectManager* instance();
 
-  /**
-   * Deletes the single instance of ObjectManager
-   */
-  static void clear();
-
   void setObjectFactoryFunction(produce_function_t prodFunc, void* args);
 
   template <typename T>
@@ -71,9 +66,6 @@ class ObjectManager : public ObjectManagerIF {
    */
   std::map<object_id_t, SystemObjectIF*> objectList;
   static ObjectManager* objManagerInstance;
-  // used when the OM itself is deleted to modify behaviour of remove()
-  // to avoid iterator invalidation and double free
-  bool teardown = false;
 };
 
 // Documentation can be found in the class method declaration above

src/fsfw/osal/CMakeLists.txt

@@ -1,13 +1,10 @@
 # Check the OS_FSFW variable
 if(FSFW_OSAL MATCHES "freertos")
   add_subdirectory(freertos)
-  set(FSFW_OSAL_FREERTOS 1)
 elseif(FSFW_OSAL MATCHES "rtems")
   add_subdirectory(rtems)
-  set(FSFW_OSAL_RTEMS 1)
 elseif(FSFW_OSAL MATCHES "linux")
   add_subdirectory(linux)
-  set(FSFW_OSAL_LINUX 1)
 elseif(FSFW_OSAL MATCHES "host")
   add_subdirectory(host)
   if(WIN32)
@@ -16,20 +13,16 @@ elseif(FSFW_OSAL MATCHES "host")
     # We still need to pull in some Linux specific sources
     target_sources(${LIB_FSFW_NAME} PUBLIC linux/tcpipHelpers.cpp)
   endif()
-  set(FSFW_OSAL_HOST 1)
-else()
-  message(
-    WARNING
-      "${MSG_PREFIX} The FSFW_OSAL variable was not set. Assuming host OS..")
 
+else()
+
+  message(WARNING "The OS_FSFW variable was not set. Assuming host OS..")
   # Not set. Assumuing this is a host build, try to determine host OS
   if(WIN32)
     add_subdirectory(host)
     add_subdirectory(windows)
-    set(FSFW_OSAL_HOST 1)
   elseif(UNIX)
     add_subdirectory(linux)
-    set(FSFW_OSAL_LINUX 1)
   else()
     # MacOS or other OSes have not been tested yet / are not supported.
     message(FATAL_ERROR "The host OS could not be determined! Aborting.")
@@ -38,5 +31,3 @@ else()
 endif()
 
 add_subdirectory(common)
-
-configure_file(osal.h.in ${CMAKE_BINARY_DIR}/fsfw/osal/osal.h)

src/fsfw/osal/Endiness.h

@@ -24,11 +24,8 @@
 #else
 
 #ifdef WIN32
-// Thanks, windows
-// clang-format off
-#include <winsock2.h>
 #include <windows.h>
-// clang-format on
+#include <winsock2.h>
 #if REG_DWORD == REG_DWORD_LITTLE_ENDIAN
 #define BYTE_ORDER_SYSTEM LITTLE_ENDIAN
 #else

src/fsfw/osal/common/TcpIpBase.cpp

@@ -40,8 +40,6 @@ int TcpIpBase::closeSocket(socket_t socket) {
   return closesocket(socket);
 #elif defined(PLATFORM_UNIX)
   return close(socket);
-#else
-  return -1;
 #endif
 }
 
@@ -50,7 +48,5 @@ int TcpIpBase::getLastSocketError() {
   return WSAGetLastError();
 #elif defined(PLATFORM_UNIX)
   return errno;
-#else
-  return 0;
 #endif
 }

src/fsfw/osal/common/TcpTmTcBridge.cpp

@@ -16,9 +16,9 @@
 
 #endif
 
-TcpTmTcBridge::TcpTmTcBridge(object_id_t objectId, object_id_t tcDestination,
+TcpTmTcBridge::TcpTmTcBridge(object_id_t objectId, object_id_t tcDestination, object_id_t tmStoreId,
-                             uint32_t msgQueueDepth, object_id_t tmStoreId, object_id_t tcStoreId)
+                             object_id_t tcStoreId)
-    : TmTcBridge("TCP TMTC Bridge", objectId, tcDestination, msgQueueDepth, tmStoreId, tcStoreId) {
+    : TmTcBridge("TCP TMTC Bridge", objectId, tcDestination, tmStoreId, tcStoreId) {
   mutex = MutexFactory::instance()->createMutex();
   // Connection is always up, TM is requested by connecting to server and receiving packets
   registerCommConnect();

src/fsfw/osal/common/TcpTmTcBridge.h

@@ -38,7 +38,7 @@ class TcpTmTcBridge : public TmTcBridge {
    * @param tmStoreId TM store object ID. It is recommended to the default object ID
    * @param tcStoreId TC store object ID. It is recommended to the default object ID
    */
-  TcpTmTcBridge(object_id_t objectId, object_id_t tcDestination, uint32_t msgQueueDepth,
+  TcpTmTcBridge(object_id_t objectId, object_id_t tcDestination,
                 object_id_t tmStoreId = objects::TM_STORE,
                 object_id_t tcStoreId = objects::TC_STORE);
   virtual ~TcpTmTcBridge();

src/fsfw/osal/common/TcpTmTcServer.cpp

@@ -16,7 +16,7 @@
 
 #ifdef PLATFORM_WIN
 #include <winsock2.h>
-typedef SSIZE_T ssize_t;
+#include <ws2tcpip.h>
 #elif defined(PLATFORM_UNIX)
 #include <netdb.h>
 
@@ -26,12 +26,12 @@ typedef SSIZE_T ssize_t;
 const std::string TcpTmTcServer::DEFAULT_SERVER_PORT = tcpip::DEFAULT_SERVER_PORT;
 
 TcpTmTcServer::TcpTmTcServer(object_id_t objectId, object_id_t tmtcTcpBridge,
-                             TcpTmTcServer::TcpConfig cfg, size_t receptionBufferSize,
+                             size_t receptionBufferSize, size_t ringBufferSize,
-                             size_t ringBufferSize, ReceptionModes receptionMode)
+                             std::string customTcpServerPort, ReceptionModes receptionMode)
     : SystemObject(objectId),
       tmtcBridgeId(tmtcTcpBridge),
       receptionMode(receptionMode),
-      tcpConfig(cfg),
+      tcpConfig(std::move(customTcpServerPort)),
       receptionBuffer(receptionBufferSize),
       ringBuffer(ringBufferSize, true) {}
 
@@ -91,25 +91,6 @@ ReturnValue_t TcpTmTcServer::initialize() {
     return returnvalue::FAILED;
   }
 
-  if (tcpConfig.reuseAddr) {
-#ifdef PLATFORM_WIN
-    DWORD enable = 1;
-    setsockopt(listenerTcpSocket, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<char*>(&enable),
-               sizeof(enable));
-#elif defined(PLATFORM_UNIX)
-    unsigned int enable = 1;
-    setsockopt(listenerTcpSocket, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable));
-#endif
-  }
-
-  if (tcpConfig.reusePort) {
-// Not supported in windows
-#ifdef PLATFORM_UNIX
-    unsigned int enable = 1;
-    setsockopt(listenerTcpSocket, SOL_SOCKET, SO_REUSEPORT, &enable, sizeof(enable));
-#endif
-  }
-
   // Bind to the address found by getaddrinfo
   retval = bind(listenerTcpSocket, addrResult->ai_addr, static_cast<int>(addrResult->ai_addrlen));
   if (retval == SOCKET_ERROR) {

src/fsfw/osal/common/TcpTmTcServer.h

@@ -41,11 +41,11 @@ class SpacePacketParser;
  */
 class TcpTmTcServer : public SystemObject, public TcpIpBase, public ExecutableObjectIF {
  public:
+  enum class ReceptionModes { SPACE_PACKETS };
+
   struct TcpConfig {
    public:
-    TcpConfig(bool reuseAddr, bool reusePort) : reuseAddr(reuseAddr), reusePort(reusePort) {}
+    explicit TcpConfig(std::string tcpPort) : tcpPort(std::move(tcpPort)) {}
-    TcpConfig(std::string tcpPort, bool reuseAddr, bool reusePort)
-        : tcpPort(std::move(tcpPort)), reuseAddr(reuseAddr), reusePort(reusePort) {}
 
     /**
      * Passed to the recv call
@@ -63,23 +63,8 @@ class TcpTmTcServer : public SystemObject, public TcpIpBase, public ExecutableOb
      */
     int tcpTmFlags = 0;
 
-    std::string tcpPort = DEFAULT_SERVER_PORT;
+    const std::string tcpPort;
-
-    /**
-     * Sets the SO_REUSEADDR option on the socket. See
-     * https://man7.org/linux/man-pages/man7/socket.7.html for more details. This option is
-     * especially useful in a debugging and development environment where an OBSW image might be
-     * re-flashed oftentimes and where all incoming telecommands are received on a dedicated TCP
-     * port.
-     */
-    bool reuseAddr = false;
-    /**
-     * Sets the SO_REUSEPORT option on the socket. See
-     * https://man7.org/linux/man-pages/man7/socket.7.html for more details.
-     */
-    bool reusePort = false;
   };
-  enum class ReceptionModes { SPACE_PACKETS };
 
   static const std::string DEFAULT_SERVER_PORT;
 
@@ -95,9 +80,10 @@ class TcpTmTcServer : public SystemObject, public TcpIpBase, public ExecutableOb
    *                              size will be the Ethernet MTU size
    * @param customTcpServerPort   The user can specify another port than the default (7301) here.
    */
-  TcpTmTcServer(object_id_t objectId, object_id_t tmtcTcpBridge, TcpTmTcServer::TcpConfig cfg,
+  TcpTmTcServer(object_id_t objectId, object_id_t tmtcTcpBridge,
                 size_t receptionBufferSize = RING_BUFFER_SIZE,
                 size_t ringBufferSize = RING_BUFFER_SIZE,
+                std::string customTcpServerPort = DEFAULT_SERVER_PORT,
                 ReceptionModes receptionMode = ReceptionModes::SPACE_PACKETS);
   ~TcpTmTcServer() override;
 
@@ -130,7 +116,7 @@ class TcpTmTcServer : public SystemObject, public TcpIpBase, public ExecutableOb
 
   ReceptionModes receptionMode;
   TcpConfig tcpConfig;
-  // struct sockaddr tcpAddress = {};
+  struct sockaddr tcpAddress = {};
   socket_t listenerTcpSocket = 0;
 
   MessageQueueId_t targetTcDestination = MessageQueueIF::NO_QUEUE;

src/fsfw/osal/common/UdpTcPollingTask.cpp

@@ -8,7 +8,6 @@
 
 #ifdef PLATFORM_WIN
 #include <winsock2.h>
-typedef SSIZE_T ssize_t;
 #elif defined(PLATFORM_UNIX)
 #include <sys/socket.h>
 #include <sys/types.h>

src/fsfw/osal/common/UdpTmTcBridge.cpp

@@ -7,7 +7,6 @@
 
 #ifdef PLATFORM_WIN
 #include <ws2tcpip.h>
-typedef SSIZE_T ssize_t;
 #elif defined(PLATFORM_UNIX)
 #include <arpa/inet.h>
 #include <netdb.h>
@@ -21,9 +20,9 @@ typedef SSIZE_T ssize_t;
 const std::string UdpTmTcBridge::DEFAULT_SERVER_PORT = tcpip::DEFAULT_SERVER_PORT;
 
 UdpTmTcBridge::UdpTmTcBridge(object_id_t objectId, object_id_t tcDestination,
-                             uint32_t msgQueueDepth, const std::string &udpServerPort_,
+                             const std::string &udpServerPort_, object_id_t tmStoreId,
-                             object_id_t tmStoreId, object_id_t tcStoreId)
+                             object_id_t tcStoreId)
-    : TmTcBridge("UDP TMTC Bridge", objectId, tcDestination, msgQueueDepth, tmStoreId, tcStoreId) {
+    : TmTcBridge("UDP TMTC Bridge", objectId, tcDestination, tmStoreId, tcStoreId) {
   if (udpServerPort_.empty()) {
     udpServerPort = DEFAULT_SERVER_PORT;
   } else {
@@ -127,7 +126,10 @@ ReturnValue_t UdpTmTcBridge::sendTm(const uint8_t *data, size_t dataLen) {
     tcpip::handleError(tcpip::Protocol::UDP, tcpip::ErrorSources::SENDTO_CALL);
   }
 #if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
-  sif::debug << "TmTcUdpBridge::sendTm: " << bytesSent << " bytes were sent" << std::endl;
+  sif::debug << "TmTcUdpBridge::sendTm: " << bytesSent
+             << " bytes were"
+                " sent."
+             << std::endl;
 #endif
   return returnvalue::OK;
 }

src/fsfw/osal/common/UdpTmTcBridge.h

@@ -29,7 +29,7 @@ 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, uint32_t msgQueueDepth,
+  UdpTmTcBridge(object_id_t objectId, object_id_t tcDestination,
                 const std::string& udpServerPort = "", object_id_t tmStoreId = objects::TM_STORE,
                 object_id_t tcStoreId = objects::TC_STORE);
   ~UdpTmTcBridge() override;

src/fsfw/osal/freertos/BinSemaphUsingTask.h

@@ -40,7 +40,7 @@ class BinarySemaphoreUsingTask : public SemaphoreIF {
   void refreshTaskHandle();
 
   ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
-                        uint32_t timeoutMs = 0) override;
+                        uint32_t timeoutMs = portMAX_DELAY) override;
   ReturnValue_t release() override;
   uint8_t getSemaphoreCounter() const override;
   static uint8_t getSemaphoreCounter(TaskHandle_t taskHandle);

src/fsfw/osal/freertos/BinarySemaphore.h

@@ -51,7 +51,7 @@ class BinarySemaphore : public SemaphoreIF {
    *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
    */
   ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
-                        uint32_t timeoutMs = 0) override;
+                        uint32_t timeoutMs = portMAX_DELAY) override;
 
   /**
    * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.

src/fsfw/osal/freertos/Clock.cpp

@@ -11,6 +11,19 @@
 // TODO sanitize input?
 // TODO much of this code can be reused for tick-only systems
 
+uint32_t Clock::getTicksPerSecond(void) { return 1000; }
+
+ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
+  timeval time_timeval;
+
+  ReturnValue_t result = convertTimeOfDayToTimeval(time, &time_timeval);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+
+  return setClock(&time_timeval);
+}
+
 ReturnValue_t Clock::setClock(const timeval* time) {
   timeval uptime = getUptime();
 
@@ -31,12 +44,81 @@ ReturnValue_t Clock::getClock_timeval(timeval* time) {
   return returnvalue::OK;
 }
 
+ReturnValue_t Clock::getUptime(timeval* uptime) {
+  *uptime = getUptime();
+
+  return returnvalue::OK;
+}
+
 timeval Clock::getUptime() {
   TickType_t ticksSinceStart = xTaskGetTickCount();
   return Timekeeper::ticksToTimeval(ticksSinceStart);
 }
 
+ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
+  timeval uptime = getUptime();
+  *uptimeMs = uptime.tv_sec * 1000 + uptime.tv_usec / 1000;
+  return returnvalue::OK;
+}
+
 // uint32_t Clock::getUptimeSeconds() {
 //	timeval uptime = getUptime();
 //	return uptime.tv_sec;
 // }
+
+ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
+  timeval time_timeval;
+  ReturnValue_t result = getClock_timeval(&time_timeval);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  *time = time_timeval.tv_sec * 1000000 + time_timeval.tv_usec;
+  return returnvalue::OK;
+}
+
+ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
+  timeval time_timeval;
+  ReturnValue_t result = getClock_timeval(&time_timeval);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  struct tm time_tm;
+
+  gmtime_r(&time_timeval.tv_sec, &time_tm);
+
+  time->year = time_tm.tm_year + 1900;
+  time->month = time_tm.tm_mon + 1;
+  time->day = time_tm.tm_mday;
+
+  time->hour = time_tm.tm_hour;
+  time->minute = time_tm.tm_min;
+  time->second = time_tm.tm_sec;
+
+  time->usecond = time_timeval.tv_usec;
+
+  return returnvalue::OK;
+}
+
+ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from, timeval* to) {
+  struct tm time_tm = {};
+
+  time_tm.tm_year = from->year - 1900;
+  time_tm.tm_mon = from->month - 1;
+  time_tm.tm_mday = from->day;
+
+  time_tm.tm_hour = from->hour;
+  time_tm.tm_min = from->minute;
+  time_tm.tm_sec = from->second;
+
+  time_t seconds = mktime(&time_tm);
+
+  to->tv_sec = seconds;
+  to->tv_usec = from->usecond;
+  // Fails in 2038..
+  return returnvalue::OK;
+}
+
+ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
+  *JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24. / 3600.;
+  return returnvalue::OK;
+}

src/fsfw/osal/freertos/CountingSemaphUsingTask.h

@@ -34,7 +34,7 @@ class CountingSemaphoreUsingTask : public SemaphoreIF {
    *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
    */
   ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
-                        uint32_t timeoutMs = 0) override;
+                        uint32_t timeoutMs = portMAX_DELAY) override;
 
   /**
    * Release a semaphore, increasing the number of available counting

src/fsfw/osal/freertos/FixedTimeslotTask.cpp

@@ -56,9 +56,7 @@ ReturnValue_t FixedTimeslotTask::startTask() {
   // start time for the first entry.
   auto slotListIter = pollingSeqTable.current;
 
-  ReturnValue_t result = pollingSeqTable.intializeSequenceAfterTaskCreation();
+  pollingSeqTable.intializeSequenceAfterTaskCreation();
-  // Ignore returnvalue for now
-  static_cast<void>(result);
 
   // The start time for the first entry is read.
   uint32_t intervalMs = slotListIter->pollingTimeMs;

src/fsfw/osal/freertos/Mutex.cpp

@@ -22,7 +22,7 @@ ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
     return MutexIF::MUTEX_NOT_FOUND;
   }
   // If the timeout type is BLOCKING, this will be the correct value.
-  TickType_t timeout = portMAX_DELAY;
+  uint32_t timeout = portMAX_DELAY;
   if (timeoutType == TimeoutType::POLLING) {
     timeout = 0;
   } else if (timeoutType == TimeoutType::WAITING) {

src/fsfw/osal/freertos/TaskManagement.cpp

@@ -3,16 +3,16 @@
 void TaskManagement::vRequestContextSwitchFromTask() { vTaskDelay(0); }
 
 void TaskManagement::requestContextSwitch(CallContext callContext = CallContext::TASK) {
-  //   if (callContext == CallContext::ISR) {
+  if (callContext == CallContext::ISR) {
-  //     // This function depends on the partmacro.h definition for the specific device
+    // This function depends on the partmacro.h definition for the specific device
-  //     vRequestContextSwitchFromISR();
+    vRequestContextSwitchFromISR();
-  //   } else {
+  } else {
     vRequestContextSwitchFromTask();
-  //   }
+  }
 }
 
 TaskHandle_t TaskManagement::getCurrentTaskHandle() { return xTaskGetCurrentTaskHandle(); }
 
-// size_t TaskManagement::getTaskStackHighWatermark(TaskHandle_t task) {
+size_t TaskManagement::getTaskStackHighWatermark(TaskHandle_t task) {
-//   return uxTaskGetStackHighWaterMark(task) * sizeof(StackType_t);
+  return uxTaskGetStackHighWaterMark(task) * sizeof(StackType_t);
-// }
+}

src/fsfw/osal/freertos/TaskManagement.h

@@ -11,7 +11,7 @@
  * Architecture dependant portmacro.h function call.
  * Should be implemented in bsp.
  */
-// extern "C" void vRequestContextSwitchFromISR();
+extern "C" void vRequestContextSwitchFromISR();
 
 /*!
  * Used by functions to tell if they are being called from
@@ -53,7 +53,7 @@ TaskHandle_t getCurrentTaskHandle();
  * @return Smallest value of stack remaining since the task was started in
  * 		   words.
  */
-// size_t getTaskStackHighWatermark(TaskHandle_t task = nullptr);
+size_t getTaskStackHighWatermark(TaskHandle_t task = nullptr);
 
 };  // namespace TaskManagement
 

src/fsfw/osal/host/Clock.cpp

@@ -15,6 +15,27 @@
 
 using SystemClock = std::chrono::system_clock;
 
+uint32_t Clock::getTicksPerSecond(void) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::warning << "Clock::getTicksPerSecond: Not implemented for host OSAL" << std::endl;
+#else
+  sif::printWarning("Clock::getTicksPerSecond: Not implemented for host OSAL\n");
+#endif
+  /* To avoid division by zero */
+  return 1;
+}
+
+ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
+  /* I don't know why someone would need to set a clock which is probably perfectly fine on a
+  host system with internet access so this is not implemented for now. */
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::warning << "Clock::setClock: Not implemented for host OSAL" << std::endl;
+#else
+  sif::printWarning("Clock::setClock: Not implemented for host OSAL\n");
+#endif
+  return returnvalue::OK;
+}
+
 ReturnValue_t Clock::setClock(const timeval* time) {
   /* I don't know why someone would need to set a clock which is probably perfectly fine on a
   host system with internet access so this is not implemented for now. */
@@ -45,7 +66,6 @@ ReturnValue_t Clock::getClock_timeval(timeval* time) {
   time->tv_usec = timeUnix.tv_nsec / 1000.0;
   return returnvalue::OK;
 #else
-#warning Clock::getClock_timeval() not implemented for your platform
 #if FSFW_CPP_OSTREAM_ENABLED == 1
   sif::warning << "Clock::getUptime: Not implemented for found OS!" << std::endl;
 #else
@@ -55,6 +75,15 @@ ReturnValue_t Clock::getClock_timeval(timeval* time) {
 #endif
 }
 
+ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
+  if (time == nullptr) {
+    return returnvalue::FAILED;
+  }
+  using namespace std::chrono;
+  *time = duration_cast<microseconds>(system_clock::now().time_since_epoch()).count();
+  return returnvalue::OK;
+}
+
 timeval Clock::getUptime() {
   timeval timeval;
 #if defined(PLATFORM_WIN)
@@ -71,10 +100,73 @@ timeval Clock::getUptime() {
     timeval.tv_usec = uptimeSeconds * (double)1e6 - (timeval.tv_sec * 1e6);
   }
 #else
-#warning Clock::getUptime() not implemented for your platform
 #if FSFW_CPP_OSTREAM_ENABLED == 1
   sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
 #endif
 #endif
   return timeval;
 }
+
+ReturnValue_t Clock::getUptime(timeval* uptime) {
+  *uptime = getUptime();
+  return returnvalue::OK;
+}
+
+ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
+  timeval uptime = getUptime();
+  *uptimeMs = uptime.tv_sec * 1000 + uptime.tv_usec / 1000;
+  return returnvalue::OK;
+}
+
+ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
+  /* Do some magic with chrono (C++20!) */
+  /* Right now, the library doesn't have the new features to get the required values yet.
+  so we work around that for now. */
+  auto now = SystemClock::now();
+  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 != returnvalue::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;
+  time->month = timeInfo->tm_mon + 1;
+  time->day = timeInfo->tm_mday;
+  time->hour = timeInfo->tm_hour;
+  time->minute = timeInfo->tm_min;
+  time->second = timeInfo->tm_sec;
+  auto usecond = std::chrono::duration_cast<std::chrono::microseconds>(fraction);
+  time->usecond = usecond.count();
+  return returnvalue::OK;
+}
+
+ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from, timeval* to) {
+  struct tm time_tm {};
+
+  time_tm.tm_year = from->year - 1900;
+  time_tm.tm_mon = from->month - 1;
+  time_tm.tm_mday = from->day;
+
+  time_tm.tm_hour = from->hour;
+  time_tm.tm_min = from->minute;
+  time_tm.tm_sec = from->second;
+  time_tm.tm_isdst = 0;
+
+  time_t seconds = timegm(&time_tm);
+
+  to->tv_sec = seconds;
+  to->tv_usec = from->usecond;
+  // Fails in 2038..
+  return returnvalue::OK;
+}
+
+ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
+  *JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24. / 3600.;
+  return returnvalue::OK;
+}

src/fsfw/osal/host/PeriodicTask.cpp

@@ -9,6 +9,7 @@
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
 #if defined(PLATFORM_WIN)
+#include <processthreadsapi.h>
 
 #include "fsfw/osal/windows/winTaskHelpers.h"
 #elif defined(PLATFORM_UNIX)

src/fsfw/osal/host/TaskFactory.cpp

@@ -50,6 +50,6 @@ void TaskFactory::printMissedDeadline() {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
   sif::warning << "TaskFactory::printMissedDeadline: " << name << std::endl;
 #else
-  sif::printWarning("TaskFactory::printMissedDeadline: %s\n", name.c_str());
+  sif::printWarning("TaskFactory::printMissedDeadline: %s\n", name);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 }

src/fsfw/osal/host/taskHelpers.h

@@ -3,7 +3,6 @@
 
 #include <fsfw/returnvalues/returnvalue.h>
 
-#include <string>
 #include <thread>
 
 namespace tasks {

src/fsfw/osal/linux/Clock.cpp

@@ -10,6 +10,26 @@
 #include "fsfw/ipc/MutexGuard.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
+uint32_t Clock::getTicksPerSecond() {
+  uint32_t ticks = sysconf(_SC_CLK_TCK);
+  return ticks;
+}
+
+ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
+  timespec timeUnix{};
+  timeval timeTimeval{};
+  convertTimeOfDayToTimeval(time, &timeTimeval);
+  timeUnix.tv_sec = timeTimeval.tv_sec;
+  timeUnix.tv_nsec = (__syscall_slong_t)timeTimeval.tv_usec * 1000;
+
+  int status = clock_settime(CLOCK_REALTIME, &timeUnix);
+  if (status != 0) {
+    // TODO errno
+    return returnvalue::FAILED;
+  }
+  return returnvalue::OK;
+}
+
 ReturnValue_t Clock::setClock(const timeval* time) {
   timespec timeUnix{};
   timeUnix.tv_sec = time->tv_sec;
@@ -33,22 +53,104 @@ ReturnValue_t Clock::getClock_timeval(timeval* time) {
   return returnvalue::OK;
 }
 
+ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
+  timeval timeVal{};
+  ReturnValue_t result = getClock_timeval(&timeVal);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  *time = static_cast<uint64_t>(timeVal.tv_sec) * 1e6 + timeVal.tv_usec;
 
+  return returnvalue::OK;
+}
 
 timeval Clock::getUptime() {
   timeval uptime{};
-
+  auto result = getUptime(&uptime);
-  double uptimeSeconds;
+  if (result != returnvalue::OK) {
-  std::ifstream ifile("/proc/uptime");
-  if (ifile.bad()) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "Clock::getUptime: Error getting uptime" << std::endl;
 #endif
-    return uptime;
-  }
-  if (ifile >> uptimeSeconds) {
-    uptime.tv_sec = uptimeSeconds;
-    uptime.tv_usec = (uptimeSeconds - uptime.tv_sec) * (double)1e6;
   }
   return uptime;
 }
+
+ReturnValue_t Clock::getUptime(timeval* uptime) {
+  // TODO This is not posix compatible and delivers only seconds precision
+  //  Linux specific file read but more precise.
+  double uptimeSeconds;
+  if (std::ifstream("/proc/uptime", std::ios::in) >> uptimeSeconds) {
+    uptime->tv_sec = uptimeSeconds;
+    uptime->tv_usec = uptimeSeconds * (double)1e6 - (uptime->tv_sec * 1e6);
+  }
+  return returnvalue::OK;
+}
+
+// Wait for new FSFW Clock function delivering seconds uptime.
+// uint32_t Clock::getUptimeSeconds() {
+//	//TODO This is not posix compatible and delivers only seconds precision
+//	struct sysinfo sysInfo;
+//	int result = sysinfo(&sysInfo);
+//	if(result != 0){
+//		return returnvalue::FAILED;
+//	}
+//	return sysInfo.uptime;
+//}
+
+ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
+  timeval uptime{};
+  ReturnValue_t result = getUptime(&uptime);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  *uptimeMs = uptime.tv_sec * 1e3 + uptime.tv_usec / 1e3;
+  return returnvalue::OK;
+}
+
+ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
+  timespec timeUnix{};
+  int status = clock_gettime(CLOCK_REALTIME, &timeUnix);
+  if (status != 0) {
+    // TODO errno
+    return returnvalue::FAILED;
+  }
+  ReturnValue_t result = checkOrCreateClockMutex();
+  if (result != returnvalue::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 std::tm* timeInfo;
+  timeInfo = gmtime(&timeUnix.tv_sec);
+  time->year = timeInfo->tm_year + 1900;
+  time->month = timeInfo->tm_mon + 1;
+  time->day = timeInfo->tm_mday;
+  time->hour = timeInfo->tm_hour;
+  time->minute = timeInfo->tm_min;
+  time->second = timeInfo->tm_sec;
+  time->usecond = timeUnix.tv_nsec / 1000.0;
+
+  return returnvalue::OK;
+}
+
+ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from, timeval* to) {
+  std::tm fromTm{};
+  // Note: Fails for years before AD
+  fromTm.tm_year = from->year - 1900;
+  fromTm.tm_mon = from->month - 1;
+  fromTm.tm_mday = from->day;
+  fromTm.tm_hour = from->hour;
+  fromTm.tm_min = from->minute;
+  fromTm.tm_sec = from->second;
+  fromTm.tm_isdst = 0;
+
+  to->tv_sec = timegm(&fromTm);
+  to->tv_usec = from->usecond;
+  return returnvalue::OK;
+}
+
+ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
+  *JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24. / 3600.;
+  return returnvalue::OK;
+}

src/fsfw/osal/linux/MessageQueue.cpp

@@ -21,7 +21,7 @@ MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize, MqArgs*
   attributes.mq_msgsize = maxMessageSize;
   attributes.mq_flags = 0;  // Flags are ignored on Linux during mq_open
   // Set the name of the queue. The slash is mandatory!
-  sprintf(name, "/FSFW_MQ%u", queueCounter++);
+  sprintf(name, "/FSFW_MQ%u\n", queueCounter++);
 
   // Create a nonblocking queue if the name is available (the queue is read
   // and writable for the owner as well as the group)

src/fsfw/osal/osal.h.in

@@ -1,36 +0,0 @@
-#pragma once
-
-namespace osal {
-    enum osalTarget{
-        HOST,
-        LINUX,
-        WINDOWS,
-        FREERTOS,
-        RTEMS,
-    };
-
-#cmakedefine FSFW_OSAL_HOST
-#cmakedefine FSFW_OSAL_LINUX
-#cmakedefine FSFW_OSAL_WINDOWS
-#cmakedefine FSFW_OSAL_FREERTOS
-#cmakedefine FSFW_OSAL_RTEMS
-
-
-    constexpr osalTarget getTarget() {
-#ifdef FSFW_OSAL_HOST
-  return HOST;
-#endif
-#ifdef FSFW_OSAL_LINUX
-  return LINUX;
-#endif
-#ifdef FSFW_OSAL_WINDOWS
-  return WINDOWS;
-#endif
-#ifdef FSFW_OSAL_FREERTOS
-  return FREERTOS;
-#endif
-#ifdef FSFW_OSAL_RTEMS
-  return RTEMS;
-#endif
-    }
-};

src/fsfw/osal/rtems/BinarySemaphore.cpp

@@ -2,8 +2,6 @@
 
 #include <rtems/rtems/sem.h>
 
-// TODO
-
 BinarySemaphore::BinarySemaphore() {}
 
 BinarySemaphore::~BinarySemaphore() {}

src/fsfw/osal/rtems/Clock.cpp

@@ -6,21 +6,20 @@
 #include "fsfw/ipc/MutexGuard.h"
 #include "fsfw/osal/rtems/RtemsBasic.h"
 
-ReturnValue_t Clock::setClock(const timeval* time) {
+uint32_t Clock::getTicksPerSecond(void) {
-  TimeOfDay_t time_tod;
+  rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
-  ReturnValue_t result = convertTimevalToTimeOfDay(time, &time_tod);
+  return static_cast<uint32_t>(ticks_per_second);
-  if (result != returnvalue::OK) {
-    return result;
 }
+
+ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
   rtems_time_of_day timeRtems;
-  timeRtems.year = time_tod.year;
+  timeRtems.year = time->year;
-  timeRtems.month = time_tod.month;
+  timeRtems.month = time->month;
-  timeRtems.day = time_tod.day;
+  timeRtems.day = time->day;
-  timeRtems.hour = time_tod.hour;
+  timeRtems.hour = time->hour;
-  timeRtems.minute = time_tod.minute;
+  timeRtems.minute = time->minute;
-  timeRtems.second = time_tod.second;
+  timeRtems.second = time->second;
-  timeRtems.ticks =
+  timeRtems.ticks = time->usecond * getTicksPerSecond() / 1e6;
-      static_cast<uint64_t>(time_tod.usecond) * rtems_clock_get_ticks_per_second() / 1e6;
   rtems_status_code status = rtems_clock_set(&timeRtems);
   switch (status) {
     case RTEMS_SUCCESSFUL:
@@ -34,6 +33,27 @@ ReturnValue_t Clock::setClock(const timeval* time) {
   }
 }
 
+ReturnValue_t Clock::setClock(const timeval* time) {
+  timespec newTime;
+  newTime.tv_sec = time->tv_sec;
+  if (time->tv_usec < 0) {
+    // better returnvalue.
+    return returnvalue::FAILED;
+  }
+  newTime.tv_nsec = time->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
+
+  ISR_lock_Context context;
+  _TOD_Lock();
+  _TOD_Acquire(&context);
+  Status_Control status = _TOD_Set(&newTime, &context);
+  _TOD_Unlock();
+  if (status == STATUS_SUCCESSFUL) {
+    return returnvalue::OK;
+  }
+  // better returnvalue
+  return returnvalue::FAILED;
+}
+
 ReturnValue_t Clock::getClock_timeval(timeval* time) {
   // Callable from ISR
   rtems_status_code status = rtems_clock_get_tod_timeval(time);
@@ -47,13 +67,86 @@ ReturnValue_t Clock::getClock_timeval(timeval* time) {
   }
 }
 
-timeval Clock::getUptime() {
+ReturnValue_t Clock::getUptime(timeval* uptime) {
   // According to docs.rtems.org for rtems 5 this method is more accurate than
   // rtems_clock_get_ticks_since_boot
-  timeval time_timeval;
   timespec time;
   rtems_status_code status = rtems_clock_get_uptime(&time);
-  time_timeval.tv_sec = time.tv_sec;
+  uptime->tv_sec = time.tv_sec;
-  time_timeval.tv_usec = time.tv_nsec / 1000;
+  time.tv_nsec = time.tv_nsec / 1000;
-  return time_timeval;
+  uptime->tv_usec = time.tv_nsec;
+  switch (status) {
+    case RTEMS_SUCCESSFUL:
+      return returnvalue::OK;
+    default:
+      return returnvalue::FAILED;
+  }
+}
+
+ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
+  // This counter overflows after 50 days
+  *uptimeMs = rtems_clock_get_ticks_since_boot();
+  return returnvalue::OK;
+}
+
+ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
+  timeval temp_time;
+  rtems_status_code returnValue = rtems_clock_get_tod_timeval(&temp_time);
+  *time = ((uint64_t)temp_time.tv_sec * 1000000) + temp_time.tv_usec;
+  switch (returnValue) {
+    case RTEMS_SUCCESSFUL:
+      return returnvalue::OK;
+    default:
+      return returnvalue::FAILED;
+  }
+}
+
+ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
+  /* For all but the last field, the struct will be filled with the correct values */
+  rtems_time_of_day timeRtems;
+  rtems_status_code status = rtems_clock_get_tod(&timeRtems);
+  switch (status) {
+    case RTEMS_SUCCESSFUL: {
+      /* The last field now contains the RTEMS ticks of the seconds from 0
+      to rtems_clock_get_ticks_per_second() minus one.
+      We calculate the microseconds accordingly */
+      time->day = timeRtems.day;
+      time->hour = timeRtems.hour;
+      time->minute = timeRtems.minute;
+      time->month = timeRtems.month;
+      time->second = timeRtems.second;
+      time->usecond =
+          static_cast<float>(timeRtems.ticks) / rtems_clock_get_ticks_per_second() * 1e6;
+      time->year = timeRtems.year;
+      return returnvalue::OK;
+    }
+    case RTEMS_NOT_DEFINED:
+      /* System date and time is not set */
+      return returnvalue::FAILED;
+    case RTEMS_INVALID_ADDRESS:
+      /* time_buffer is NULL */
+      return returnvalue::FAILED;
+    default:
+      return returnvalue::FAILED;
+  }
+}
+
+ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from, timeval* to) {
+  // Fails in 2038..
+  rtems_time_of_day timeRtems;
+  timeRtems.year = from->year;
+  timeRtems.month = from->month;
+  timeRtems.day = from->day;
+  timeRtems.hour = from->hour;
+  timeRtems.minute = from->minute;
+  timeRtems.second = from->second;
+  timeRtems.ticks = from->usecond * getTicksPerSecond() / 1e6;
+  to->tv_sec = _TOD_To_seconds(&timeRtems);
+  to->tv_usec = from->usecond;
+  return returnvalue::OK;
+}
+
+ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
+  *JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24. / 3600.;
+  return returnvalue::OK;
 }

src/fsfw/osal/rtems/CpuUsage.cpp

@@ -93,8 +93,8 @@ ReturnValue_t CpuUsage::serialize(uint8_t** buffer, size_t* size, size_t maxSize
                                                        streamEndianness);
 }
 
-size_t CpuUsage::getSerializedSize() const {
+uint32_t CpuUsage::getSerializedSize() const {
-  size_t size = 0;
+  uint32_t size = 0;
 
   size += sizeof(timeSinceLastReset);
   size += SerialArrayListAdapter<ThreadData>::getSerializedSize(&threadData);
@@ -136,8 +136,8 @@ ReturnValue_t CpuUsage::ThreadData::serialize(uint8_t** buffer, size_t* size, si
   return returnvalue::OK;
 }
 
-size_t CpuUsage::ThreadData::getSerializedSize() const {
+uint32_t CpuUsage::ThreadData::getSerializedSize() const {
-  size_t size = 0;
+  uint32_t size = 0;
 
   size += sizeof(id);
   size += MAX_LENGTH_OF_THREAD_NAME;

src/fsfw/osal/rtems/InternalErrorCodes.cpp

@@ -35,9 +35,10 @@ ReturnValue_t InternalErrorCodes::translate(uint8_t code) {
       return OUT_OF_PROXIES;
     case INTERNAL_ERROR_INVALID_GLOBAL_ID:
       return INVALID_GLOBAL_ID;
-    // TODO this one is not there anymore in rtems-6 (5 as well?)
+#ifndef STM32H743ZI_NUCLEO
-    // case INTERNAL_ERROR_BAD_STACK_HOOK:
+    case INTERNAL_ERROR_BAD_STACK_HOOK:
-    //   return BAD_STACK_HOOK;
+      return BAD_STACK_HOOK;
+#endif
       //	case INTERNAL_ERROR_BAD_ATTRIBUTES:
       //		return BAD_ATTRIBUTES;
       //	case INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY:

src/fsfw/osal/rtems/SemaphoreFactory.cpp

@@ -18,9 +18,7 @@ SemaphoreFactory* SemaphoreFactory::instance() {
 }
 
 SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t argument) {
-  return nullptr;
+  return new BinarySemaphore();
-  // TODO
-  // return new BinarySemaphore();
 }
 
 SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t maxCount, uint8_t initCount,

src/fsfw/osal/windows/winTaskHelpers.h

@@ -5,11 +5,7 @@
 
 #ifdef _WIN32
 
-// Thanks, windows
+#include <minwindef.h>
-// clang-format off
-#include <windows.h>
-#include <processthreadsapi.h>
-// clang-format on
 
 namespace tasks {
 

src/fsfw/parameters/ParameterWrapper.h

@@ -45,7 +45,6 @@ class ParameterWrapper : public SerializeIF {
 
   virtual size_t getSerializedSize() const override;
 
-  using SerializeIF::deSerialize;
   virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
                                     Endianness streamEndianness) override;
 

src/fsfw/power/Fuse.h

@@ -32,7 +32,7 @@ class Fuse : public SystemObject,
     gp_id_t poolIdPower;
   };
 
-  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::POWER_SWITCH_IF;
+  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_1;
   //! PSS detected that current on a fuse is totally out of bounds.
   static const Event FUSE_CURRENT_HIGH = MAKE_EVENT(1, severity::LOW);
   //! PSS detected a fuse that went off.
@@ -62,13 +62,13 @@ class Fuse : public SystemObject,
                             SerializeIF::Endianness streamEndianness) override;
   void setAllMonitorsToUnchecked();
   ReturnValue_t performOperation(uint8_t opCode);
-  MessageQueueId_t getCommandQueue() const override;
+  MessageQueueId_t getCommandQueue() const;
   void setDataPoolEntriesInvalid();
-  ReturnValue_t setHealth(HealthState health) override;
+  ReturnValue_t setHealth(HealthState health);
-  HasHealthIF::HealthState getHealth() override;
+  HasHealthIF::HealthState getHealth();
 
   ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId, ParameterWrapper *parameterWrapper,
-                             const ParameterWrapper *newValues, uint16_t startAtIndex) override;
+                             const ParameterWrapper *newValues, uint16_t startAtIndex);
 
  private:
   uint8_t oldFuseState;

src/fsfw/power/PowerComponent.h

@@ -10,15 +10,15 @@ class PowerComponent : public PowerComponentIF {
   PowerComponent(object_id_t setId, uint8_t moduleId, float minPower, float maxPower,
                  uint8_t switchId1, bool twoSwitches = false, uint8_t switchId2 = 0xFF);
 
-  object_id_t getDeviceObjectId() override;
+  virtual object_id_t getDeviceObjectId();
 
-  uint8_t getSwitchId1() override;
+  virtual uint8_t getSwitchId1();
-  uint8_t getSwitchId2() override;
+  virtual uint8_t getSwitchId2();
 
-  bool hasTwoSwitches() override;
+  bool hasTwoSwitches();
 
-  float getMin() override;
+  float getMin();
-  float getMax() override;
+  float getMax();
 
   ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
                           Endianness streamEndianness) const override;
@@ -29,7 +29,7 @@ class PowerComponent : public PowerComponentIF {
                             Endianness streamEndianness) override;
 
   ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId, ParameterWrapper* parameterWrapper,
-                             const ParameterWrapper* newValues, uint16_t startAtIndex) override;
+                             const ParameterWrapper* newValues, uint16_t startAtIndex);
 
  private:
   const object_id_t deviceObjectId = objects::NO_OBJECT;

src/fsfw/power/PowerSwitchIF.h

@@ -28,12 +28,10 @@ class PowerSwitchIF {
   static const ReturnValue_t SWITCH_TIMEOUT = MAKE_RETURN_CODE(2);
   static const ReturnValue_t FUSE_ON = MAKE_RETURN_CODE(3);
   static const ReturnValue_t FUSE_OFF = MAKE_RETURN_CODE(4);
-  static const ReturnValue_t SWITCH_UNKNOWN = MAKE_RETURN_CODE(5);
+  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_2;
-
+  static const Event SWITCH_WENT_OFF = MAKE_EVENT(
-  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::POWER_SWITCH_IF;
+      0, severity::LOW);  //!< Someone detected that a switch went off which shouldn't. Severity:
-  //!< Someone detected that a switch went off which shouldn't. Severity:
                           //!< Low, Parameter1: switchId1, Parameter2: switchId2
-  static const Event SWITCH_WENT_OFF = MAKE_EVENT(0, severity::LOW);
   /**
    * send a direct command to the Power Unit to enable/disable the specified switch.
    *
@@ -52,7 +50,6 @@ class PowerSwitchIF {
    * @return
    *     - @c SWITCH_ON if the specified switch is on.
    *     - @c SWITCH_OFF if the specified switch is off.
-   *     - @c SWITCH_UNKNOWN if the state of the specified switch is unknown.
    *     - @c returnvalue::FAILED if an error occured
    */
   virtual ReturnValue_t getSwitchState(power::Switch_t switchNr) const = 0;

src/fsfw/pus/CMakeLists.txt

@@ -9,4 +9,4 @@ target_sources(
           Service17Test.cpp
           Service20ParameterManagement.cpp
           CService200ModeCommanding.cpp
-          CServiceHealthCommanding.cpp)
+          CService201HealthCommanding.cpp)

src/fsfw/pus/CService200ModeCommanding.cpp

@@ -19,8 +19,7 @@ ReturnValue_t CService200ModeCommanding::isValidSubservice(uint8_t subservice) {
   switch (subservice) {
     case (Subservice::COMMAND_MODE_COMMAND):
     case (Subservice::COMMAND_MODE_READ):
-    case (Subservice::COMMAND_MODE_ANNOUNCE):
+    case (Subservice::COMMAND_MODE_ANNCOUNCE):
-    case (Subservice::COMMAND_MODE_ANNOUNCE_RECURSIVELY):
       return returnvalue::OK;
     default:
       return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
@@ -54,9 +53,6 @@ ReturnValue_t CService200ModeCommanding::checkInterfaceAndAcquireMessageQueue(
 ReturnValue_t CService200ModeCommanding::prepareCommand(CommandMessage *message, uint8_t subservice,
                                                         const uint8_t *tcData, size_t tcDataLen,
                                                         uint32_t *state, object_id_t objectId) {
-  bool recursive = false;
-  switch (subservice) {
-    case (Subservice::COMMAND_MODE_COMMAND): {
   ModePacket modeCommandPacket;
   ReturnValue_t result =
       modeCommandPacket.deSerialize(&tcData, &tcDataLen, SerializeIF::Endianness::BIG);
@@ -64,22 +60,9 @@ ReturnValue_t CService200ModeCommanding::prepareCommand(CommandMessage *message,
     return result;
   }
 
-      ModeMessage::setModeMessage(message, ModeMessage::CMD_MODE_COMMAND,
+  ModeMessage::setModeMessage(message, ModeMessage::CMD_MODE_COMMAND, modeCommandPacket.getMode(),
-                                  modeCommandPacket.getMode(), modeCommandPacket.getSubmode());
+                              modeCommandPacket.getSubmode());
-      return returnvalue::OK;
+  return result;
-    }
-    case (Subservice::COMMAND_MODE_ANNOUNCE_RECURSIVELY):
-      recursive = true;
-      [[fallthrough]];
-    case (Subservice::COMMAND_MODE_ANNOUNCE):
-      ModeMessage::setModeAnnounceMessage(*message, recursive);
-      return EXECUTION_COMPLETE;
-    case (Subservice::COMMAND_MODE_READ):
-      ModeMessage::setModeReadMessage(*message);
-      return returnvalue::OK;
-    default:
-      return CommandingServiceBase::INVALID_SUBSERVICE;
-  }
 }
 
 ReturnValue_t CService200ModeCommanding::handleReply(const CommandMessage *reply,
@@ -90,10 +73,8 @@ ReturnValue_t CService200ModeCommanding::handleReply(const CommandMessage *reply
   ReturnValue_t result = returnvalue::FAILED;
   switch (replyId) {
     case (ModeMessage::REPLY_MODE_REPLY): {
-      if (previousCommand != ModeMessage::CMD_MODE_COMMAND) {
+      result = prepareModeReply(reply, objectId);
-        return prepareModeReply(reply, objectId);
+      break;
-      }
-      return returnvalue::OK;
     }
     case (ModeMessage::REPLY_WRONG_MODE_REPLY): {
       result = prepareWrongModeReply(reply, objectId);

src/fsfw/pus/CService200ModeCommanding.h

@@ -52,7 +52,7 @@ class CService200ModeCommanding : public CommandingServiceBase {
     COMMAND_MODE_READ = 3,
     //!< [EXPORT] : [COMMAND] Trigger an ModeInfo Event.
     //! This command does NOT have a reply
-    COMMAND_MODE_ANNOUNCE = 4,
+    COMMAND_MODE_ANNCOUNCE = 4,
     //!< [EXPORT] : [COMMAND] Trigger a ModeInfo Event and to send this
     //! command to every child. This command does NOT have a reply.
     COMMAND_MODE_ANNOUNCE_RECURSIVELY = 5,

src/fsfw/pus/CService201HealthCommanding.cpp

@@ -0,0 +1,106 @@
+#include "fsfw/pus/CService201HealthCommanding.h"
+
+#include "fsfw/health/HasHealthIF.h"
+#include "fsfw/health/HealthMessage.h"
+#include "fsfw/objectmanager/ObjectManager.h"
+#include "fsfw/pus/servicepackets/Service201Packets.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
+
+CService201HealthCommanding::CService201HealthCommanding(object_id_t objectId, uint16_t apid,
+                                                         uint8_t serviceId,
+                                                         uint8_t numParallelCommands,
+                                                         uint16_t commandTimeoutSeconds)
+    : CommandingServiceBase(objectId, apid, "PUS 201 Health MGMT", serviceId, numParallelCommands,
+                            commandTimeoutSeconds) {}
+
+ReturnValue_t CService201HealthCommanding::isValidSubservice(uint8_t subservice) {
+  switch (subservice) {
+    case (Subservice::COMMAND_SET_HEALTH):
+    case (Subservice::COMMAND_ANNOUNCE_HEALTH):
+    case (Subservice::COMMAND_ANNOUNCE_HEALTH_ALL):
+      return returnvalue::OK;
+    default:
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::error << "Invalid Subservice" << std::endl;
+#endif
+      return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+  }
+}
+
+ReturnValue_t CService201HealthCommanding::getMessageQueueAndObject(uint8_t subservice,
+                                                                    const uint8_t *tcData,
+                                                                    size_t tcDataLen,
+                                                                    MessageQueueId_t *id,
+                                                                    object_id_t *objectId) {
+  if (tcDataLen < sizeof(object_id_t)) {
+    return CommandingServiceBase::INVALID_TC;
+  }
+  SerializeAdapter::deSerialize(objectId, &tcData, &tcDataLen, SerializeIF::Endianness::BIG);
+
+  return checkInterfaceAndAcquireMessageQueue(id, objectId);
+}
+
+ReturnValue_t CService201HealthCommanding::checkInterfaceAndAcquireMessageQueue(
+    MessageQueueId_t *messageQueueToSet, const object_id_t *objectId) {
+  auto *destination = ObjectManager::instance()->get<HasHealthIF>(*objectId);
+  if (destination == nullptr) {
+    return CommandingServiceBase::INVALID_OBJECT;
+  }
+
+  *messageQueueToSet = destination->getCommandQueue();
+  return returnvalue::OK;
+}
+
+ReturnValue_t CService201HealthCommanding::prepareCommand(CommandMessage *message,
+                                                          uint8_t subservice, const uint8_t *tcData,
+                                                          size_t tcDataLen, uint32_t *state,
+                                                          object_id_t objectId) {
+  ReturnValue_t result = returnvalue::OK;
+  switch (subservice) {
+    case (Subservice::COMMAND_SET_HEALTH): {
+      HealthSetCommand healthCommand;
+      result = healthCommand.deSerialize(&tcData, &tcDataLen, SerializeIF::Endianness::BIG);
+      if (result != returnvalue::OK) {
+        break;
+      }
+      HealthMessage::setHealthMessage(message, HealthMessage::HEALTH_SET,
+                                      healthCommand.getHealth());
+      break;
+    }
+    case (Subservice::COMMAND_ANNOUNCE_HEALTH): {
+      HealthMessage::setHealthMessage(message, HealthMessage::HEALTH_ANNOUNCE);
+      break;
+    }
+    case (Subservice::COMMAND_ANNOUNCE_HEALTH_ALL): {
+      HealthMessage::setHealthMessage(message, HealthMessage::HEALTH_ANNOUNCE_ALL);
+      break;
+    }
+    default: {
+      // Should never happen, subservice was already checked
+      result = returnvalue::FAILED;
+    }
+  }
+  return result;
+}
+
+ReturnValue_t CService201HealthCommanding::handleReply(const CommandMessage *reply,
+                                                       Command_t previousCommand, uint32_t *state,
+                                                       CommandMessage *optionalNextCommand,
+                                                       object_id_t objectId, bool *isStep) {
+  Command_t replyId = reply->getCommand();
+  if (replyId == HealthMessage::REPLY_HEALTH_SET) {
+    return EXECUTION_COMPLETE;
+  } else if (replyId == CommandMessageIF::REPLY_REJECTED) {
+    return reply->getReplyRejectedReason();
+  }
+  return CommandingServiceBase::INVALID_REPLY;
+}
+
+// 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));
+  HealthSetReply healthSetReply(health, oldHealth);
+  return sendTmPacket(Subservice::REPLY_HEALTH_SET, healthSetReply);
+}

src/fsfw/pus/CService201HealthCommanding.h

@@ -1,26 +1,8 @@
 #ifndef FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_
 #define FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_
 
-#include <fsfw/health/HealthTable.h>
-
 #include "fsfw/tmtcservices/CommandingServiceBase.h"
 
-struct HealthServiceCfg {
-  HealthServiceCfg(object_id_t objectId, uint16_t apid, object_id_t healthTable,
-                   uint16_t maxNumHealthInfoPerCycle)
-      : objectId(objectId),
-        apid(apid),
-        table(healthTable),
-        maxNumHealthInfoPerCycle(maxNumHealthInfoPerCycle) {}
-  object_id_t objectId;
-  uint16_t apid;
-  object_id_t table;
-  uint16_t maxNumHealthInfoPerCycle;
-  uint8_t service = 201;
-  uint8_t numParallelCommands = 4;
-  uint16_t commandTimeoutSeconds = 60;
-};
-
 /**
  * @brief   Custom PUS service to set health of all objects
  *          implementing hasHealthIF.
@@ -35,12 +17,11 @@ struct HealthServiceCfg {
  * child class like this service
  *
  */
-class CServiceHealthCommanding : public CommandingServiceBase {
+class CService201HealthCommanding : public CommandingServiceBase {
  public:
-  CServiceHealthCommanding(HealthServiceCfg args);
+  CService201HealthCommanding(object_id_t objectId, uint16_t apid, uint8_t serviceId,
-  ~CServiceHealthCommanding() override = default;
+                              uint8_t numParallelCommands = 4, uint16_t commandTimeoutSeconds = 60);
-
+  ~CService201HealthCommanding() override = default;
-  ReturnValue_t initialize() override;
 
  protected:
   /* CSB abstract function implementations */
@@ -56,14 +37,7 @@ class CServiceHealthCommanding : public CommandingServiceBase {
                             CommandMessage *optionalNextCommand, object_id_t objectId,
                             bool *isStep) override;
 
-  void doPeriodicOperation() override;
-
  private:
-  const object_id_t healthTableId;
-  HealthTable *healthTable;
-  uint16_t maxNumHealthInfoPerCycle = 0;
-  bool reportAllHealth = false;
-  ReturnValue_t iterateHealthTable(bool reset);
   static ReturnValue_t checkInterfaceAndAcquireMessageQueue(MessageQueueId_t *MessageQueueToSet,
                                                             const object_id_t *objectId);
 

src/fsfw/pus/CServiceHealthCommanding.cpp

@@ -1,161 +0,0 @@
-#include <fsfw/events/EventManagerIF.h>
-#include <fsfw/pus/CServiceHealthCommanding.h>
-
-#include "fsfw/health/HasHealthIF.h"
-#include "fsfw/health/HealthMessage.h"
-#include "fsfw/objectmanager/ObjectManager.h"
-#include "fsfw/pus/servicepackets/Service201Packets.h"
-#include "fsfw/serviceinterface/ServiceInterface.h"
-
-CServiceHealthCommanding::CServiceHealthCommanding(HealthServiceCfg args)
-    : CommandingServiceBase(args.objectId, args.apid, "PUS 201 Health MGMT", args.service,
-                            args.numParallelCommands, args.commandTimeoutSeconds),
-      healthTableId(args.table),
-      maxNumHealthInfoPerCycle(args.maxNumHealthInfoPerCycle) {}
-
-ReturnValue_t CServiceHealthCommanding::initialize() {
-  ReturnValue_t result = CommandingServiceBase::initialize();
-  if (result != returnvalue::OK) {
-    return result;
-  }
-
-  healthTable = ObjectManager::instance()->get<HealthTable>(healthTableId);
-  if (healthTable == nullptr) {
-    return returnvalue::FAILED;
-  }
-
-  return returnvalue::OK;
-}
-
-ReturnValue_t CServiceHealthCommanding::isValidSubservice(uint8_t subservice) {
-  switch (subservice) {
-    case (Subservice::COMMAND_SET_HEALTH):
-    case (Subservice::COMMAND_ANNOUNCE_HEALTH):
-    case (Subservice::COMMAND_ANNOUNCE_HEALTH_ALL):
-      return returnvalue::OK;
-    default:
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::error << "Invalid Subservice" << std::endl;
-#endif
-      return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
-  }
-}
-
-ReturnValue_t CServiceHealthCommanding::getMessageQueueAndObject(uint8_t subservice,
-                                                                 const uint8_t *tcData,
-                                                                 size_t tcDataLen,
-                                                                 MessageQueueId_t *id,
-                                                                 object_id_t *objectId) {
-  switch (subservice) {
-    case (Subservice::COMMAND_SET_HEALTH):
-    case (Subservice::COMMAND_ANNOUNCE_HEALTH): {
-      if (tcDataLen < sizeof(object_id_t)) {
-        return CommandingServiceBase::INVALID_TC;
-      }
-      SerializeAdapter::deSerialize(objectId, &tcData, &tcDataLen, SerializeIF::Endianness::BIG);
-
-      return checkInterfaceAndAcquireMessageQueue(id, objectId);
-    }
-    case (Subservice::COMMAND_ANNOUNCE_HEALTH_ALL): {
-      return returnvalue::OK;
-    }
-    default: {
-      return returnvalue::FAILED;
-    }
-  }
-}
-
-ReturnValue_t CServiceHealthCommanding::checkInterfaceAndAcquireMessageQueue(
-    MessageQueueId_t *messageQueueToSet, const object_id_t *objectId) {
-  auto *destination = ObjectManager::instance()->get<HasHealthIF>(*objectId);
-  if (destination == nullptr) {
-    return CommandingServiceBase::INVALID_OBJECT;
-  }
-
-  *messageQueueToSet = destination->getCommandQueue();
-  return returnvalue::OK;
-}
-
-ReturnValue_t CServiceHealthCommanding::prepareCommand(CommandMessage *message, uint8_t subservice,
-                                                       const uint8_t *tcData, size_t tcDataLen,
-                                                       uint32_t *state, object_id_t objectId) {
-  ReturnValue_t result = returnvalue::OK;
-  switch (subservice) {
-    case (Subservice::COMMAND_SET_HEALTH): {
-      if (tcDataLen != sizeof(object_id_t) + sizeof(HasHealthIF::HealthState)) {
-        return CommandingServiceBase::INVALID_TC;
-      }
-      HealthSetCommand healthCommand;
-      result = healthCommand.deSerialize(&tcData, &tcDataLen, SerializeIF::Endianness::BIG);
-      if (result != returnvalue::OK) {
-        break;
-      }
-      HealthMessage::setHealthMessage(message, HealthMessage::HEALTH_SET,
-                                      healthCommand.getHealth());
-      break;
-    }
-    case (Subservice::COMMAND_ANNOUNCE_HEALTH): {
-      HealthMessage::setHealthMessage(message, HealthMessage::HEALTH_ANNOUNCE);
-      return CommandingServiceBase::EXECUTION_COMPLETE;
-    }
-    case (Subservice::COMMAND_ANNOUNCE_HEALTH_ALL): {
-      ReturnValue_t result = iterateHealthTable(true);
-      if (result == returnvalue::OK) {
-        reportAllHealth = true;
-        return EXECUTION_COMPLETE;
-      }
-      return result;
-    }
-    default: {
-      // Should never happen, subservice was already checked
-      result = returnvalue::FAILED;
-    }
-  }
-  return result;
-}
-
-ReturnValue_t CServiceHealthCommanding::handleReply(const CommandMessage *reply,
-                                                    Command_t previousCommand, uint32_t *state,
-                                                    CommandMessage *optionalNextCommand,
-                                                    object_id_t objectId, bool *isStep) {
-  Command_t replyId = reply->getCommand();
-  if (replyId == HealthMessage::REPLY_HEALTH_SET) {
-    return EXECUTION_COMPLETE;
-  } else if (replyId == CommandMessageIF::REPLY_REJECTED) {
-    return reply->getReplyRejectedReason();
-  }
-  return CommandingServiceBase::INVALID_REPLY;
-}
-
-void CServiceHealthCommanding::doPeriodicOperation() {
-  if (reportAllHealth) {
-    for (uint8_t i = 0; i < maxNumHealthInfoPerCycle; i++) {
-      ReturnValue_t result = iterateHealthTable(false);
-      if (result != returnvalue::OK) {
-        reportAllHealth = false;
-        break;
-      }
-    }
-  }
-}
-
-// Not used for now, health state already reported by event
-[[maybe_unused]] ReturnValue_t CServiceHealthCommanding::prepareHealthSetReply(
-    const CommandMessage *reply) {
-  auto health = static_cast<uint8_t>(HealthMessage::getHealth(reply));
-  auto oldHealth = static_cast<uint8_t>(HealthMessage::getOldHealth(reply));
-  HealthSetReply healthSetReply(health, oldHealth);
-  return sendTmPacket(Subservice::REPLY_HEALTH_SET, healthSetReply);
-}
-
-ReturnValue_t CServiceHealthCommanding::iterateHealthTable(bool reset) {
-  std::pair<object_id_t, HasHealthIF::HealthState> pair;
-
-  ReturnValue_t result = healthTable->iterate(&pair, reset);
-  if (result != returnvalue::OK) {
-    return result;
-  } else {
-    EventManagerIF::triggerEvent(pair.first, HasHealthIF::HEALTH_INFO, pair.second, pair.second);
-    return returnvalue::OK;
-  }
-}

src/fsfw/pus/Service11TelecommandScheduling.tpp

@@ -2,12 +2,12 @@
 
 #include <cstddef>
 
-#include "fsfw/globalfunctions/CRC.h"
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/serialize/SerializeAdapter.h"
 #include "fsfw/serviceinterface.h"
-#include "fsfw/tmtcpacket/pus/tc/PusTcIF.h"
 #include "fsfw/tmtcservices/AcceptsTelecommandsIF.h"
+#include "fsfw/tmtcpacket/pus/tc/PusTcIF.h"
+#include "fsfw/globalfunctions/CRC.h"
 
 static constexpr auto DEF_END = SerializeIF::Endianness::BIG;
 

src/fsfw/pus/Service1TelecommandVerification.cpp

@@ -13,7 +13,7 @@ Service1TelecommandVerification::Service1TelecommandVerification(object_id_t obj
                                                                  uint16_t messageQueueDepth,
                                                                  TimeWriterIF* timeStamper)
     : SystemObject(objectId),
-      //      apid(apid),
+      apid(apid),
       serviceId(serviceId),
       targetDestination(targetDestination),
       storeHelper(apid),

src/fsfw/pus/Service1TelecommandVerification.h

@@ -72,7 +72,7 @@ class Service1TelecommandVerification : public AcceptsVerifyMessageIF,
   ReturnValue_t initialize() override;
 
  private:
-  // uint16_t apid = 0;
+  uint16_t apid = 0;
   uint8_t serviceId = 0;
 
   object_id_t targetDestination = objects::NO_OBJECT;

src/fsfw/pus/Service20ParameterManagement.cpp

@@ -69,14 +69,14 @@ ReturnValue_t Service20ParameterManagement::checkInterfaceAndAcquireMessageQueue
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "Service20ParameterManagement::checkInterfaceAndAcquire"
                << "MessageQueue: Can't access object" << std::endl;
-    sif::error << "Object ID: 0x" << std::hex << *objectId << std::dec << std::endl;
+    sif::error << "Object ID: " << std::hex << objectId << std::dec << std::endl;
-    sif::error << "Make sure it implements ReceivesParameterMessagesIF" << std::endl;
+    sif::error << "Make sure it implements ReceivesParameterMessagesIF!" << std::endl;
 #else
     sif::printError(
         "Service20ParameterManagement::checkInterfaceAndAcquire"
         "MessageQueue: Can't access object\n");
     sif::printError("Object ID: 0x%08x\n", *objectId);
-    sif::printError("Make sure it implements ReceivesParameterMessagesIF\n");
+    sif::printError("Make sure it implements ReceivesParameterMessagesIF!\n");
 #endif
 
     return CommandingServiceBase::INVALID_OBJECT;

src/fsfw/pus/Service9TimeManagement.cpp

@@ -1,7 +1,5 @@
 #include "fsfw/pus/Service9TimeManagement.h"
 
-#include <cmath>
-
 #include "fsfw/events/EventManagerIF.h"
 #include "fsfw/pus/servicepackets/Service9Packets.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
@@ -17,17 +15,9 @@ ReturnValue_t Service9TimeManagement::performService() { return returnvalue::OK;
 
 ReturnValue_t Service9TimeManagement::handleRequest(uint8_t subservice) {
   switch (subservice) {
-    case Subservice::SET_TIME: {
+    case SUBSERVICE::SET_TIME: {
       return setTime();
     }
-    case Subservice::DUMP_TIME: {
-      timeval newTime;
-      Clock::getClock_timeval(&newTime);
-      uint32_t subsecondMs =
-          static_cast<uint32_t>(std::floor(static_cast<double>(newTime.tv_usec) / 1000.0));
-      triggerEvent(CLOCK_DUMP, newTime.tv_sec, subsecondMs);
-      return returnvalue::OK;
-    }
     default:
       return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
   }
@@ -43,14 +33,14 @@ ReturnValue_t Service9TimeManagement::setTime() {
     return result;
   }
 
-  timeval time;
+  uint32_t formerUptime;
-  Clock::getClock_timeval(&time);
+  Clock::getUptime(&formerUptime);
   result = Clock::setClock(&timeToSet);
 
   if (result == returnvalue::OK) {
-    timeval newTime;
+    uint32_t newUptime;
-    Clock::getClock_timeval(&newTime);
+    Clock::getUptime(&newUptime);
-    triggerEvent(CLOCK_SET, time.tv_sec, newTime.tv_sec);
+    triggerEvent(CLOCK_SET, newUptime, formerUptime);
     return returnvalue::OK;
   } else {
     triggerEvent(CLOCK_SET_FAILURE, result, 0);

src/fsfw/pus/Service9TimeManagement.h

@@ -6,13 +6,10 @@
 class Service9TimeManagement : public PusServiceBase {
  public:
   static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_9;
-
+  static constexpr Event CLOCK_SET =
-  //!< Clock has been set. P1: old timeval seconds. P2: new timeval seconds.
+      MAKE_EVENT(0, severity::INFO);  //!< Clock has been set. P1: New Uptime. P2: Old Uptime
-  static constexpr Event CLOCK_SET = MAKE_EVENT(0, severity::INFO);
+  static constexpr Event CLOCK_SET_FAILURE =
-  //!< Clock dump event. P1: timeval seconds P2: timeval milliseconds.
+      MAKE_EVENT(1, severity::LOW);  //!< Clock could not be set. P1: Returncode.
-  static constexpr Event CLOCK_DUMP = MAKE_EVENT(1, severity::INFO);
-  //!< Clock could not be set. P1: Returncode.
-  static constexpr Event CLOCK_SET_FAILURE = MAKE_EVENT(2, severity::LOW);
 
   static constexpr uint8_t CLASS_ID = CLASS_ID::PUS_SERVICE_9;
 
@@ -33,9 +30,8 @@ class Service9TimeManagement : public PusServiceBase {
   virtual ReturnValue_t setTime();
 
  private:
-  enum Subservice {
+  enum SUBSERVICE {
-    SET_TIME = 128,  //!< [EXPORT] : [COMMAND] Time command in ASCII, CUC or CDS format
+    SET_TIME = 128  //!< [EXPORT] : [COMMAND] Time command in ASCII, CUC or CDS format
-    DUMP_TIME = 129,
   };
 };
 

src/fsfw/pus/servicepackets/Service1Packets.h

@@ -69,7 +69,7 @@ class FailureReport : public SerializeIF {  //!< [EXPORT] : [SUBSERVICE] 2, 4, 6
     return result;
   }
 
-  virtual size_t getSerializedSize() const override {
+  virtual size_t getSerializedSize() const {
     size_t size = 0;
     size += SerializeAdapter::getSerializedSize(&packetId);
     size += sizeof(packetSequenceControl);