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

2023-01-13 11:15:50 +01:00 · 2023-01-13 10:59:48 +01:00 · 2023-01-13 10:56:24 +01:00 · 2023-01-13 10:56:16 +01:00 · 2022-10-17 17:29:10 +02:00 · 2022-10-17 17:24:46 +02:00
60 changed files with 1471 additions and 843 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -8,38 +8,14 @@ and this project adheres to [Semantic Versioning](http://semver.org/).

 # [unreleased]

-# [v6.0.0] 2023-02-10
+# [v6.0.0]

 ## 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
@ -49,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
@ -154,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
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/734
- comment tweak to event parser can read everything
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/732
- 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
-
+- 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

 ## CFDP

@ -208,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

--- a/CMakeLists.txt
+++ b/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)

@ -153,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)

@ -201,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(
--- a/automation/Jenkinsfile
+++ b/automation/Jenkinsfile
@ -1,87 +1,45 @@
 pipeline {
    environment {
-        BUILDDIR_HOST = 'cmake-build-tests-host'
-        BUILDDIR_LINUX = 'cmake-build-tests-linux'
+        BUILDDIR = 'cmake-build-tests'
        DOCDDIR = 'cmake-build-documentation'
    }
    agent {
        docker { 
            image 'fsfw-ci:d6'
-            args '--network host --sysctl fs.mqueue.msg_max=100'
+            args '--network host'
        }
    }
    stages {
-        stage('Host') {
-            stages{
-                stage('Clean') {
-                    steps {
-                        sh 'rm -rf $BUILDDIR_HOST'
-                    }
-                }
-                stage('Configure') {
-                    steps {
-                        dir(BUILDDIR_HOST) {
-                            sh 'cmake -DFSFW_OSAL=host -DFSFW_BUILD_TESTS=ON -DFSFW_CICD_BUILD=ON ..'
-                        }
-                    }
-                }
-                stage('Build') {
-                    steps {
-                        dir(BUILDDIR_HOST) {
-                            sh 'cmake --build . -j4'
-                        }
-                    }
-                }
-                stage('Unittests') {
-                    steps {
-                        dir(BUILDDIR_HOST) {
-                            sh 'cmake --build . -- fsfw-tests_coverage -j4'
-                        }
-                    }
-                }
-                stage('Valgrind') {
-                    steps {
-                        dir(BUILDDIR_HOST) {
-                            sh 'valgrind --leak-check=full --error-exitcode=1 ./fsfw-tests'
-                        }
-                    }
+        stage('Clean') {
+            steps {
+                sh 'rm -rf $BUILDDIR'
+            }
+        }
+        stage('Configure') {
+            steps {
+                dir(BUILDDIR) {
+                    sh 'cmake -DFSFW_OSAL=host -DFSFW_BUILD_TESTS=ON -DFSFW_CICD_BUILD=ON ..'
                }
            }
        }
-        stage('Linux') {
-            stages{
-                stage('Clean') {
-                    steps {
-                        sh 'rm -rf $BUILDDIR_LINUX'
-                    }
+        stage('Build') {
+            steps {
+                dir(BUILDDIR) {
+                    sh 'cmake --build . -j4'
                }
-                stage('Configure') {
-                    steps {
-                        dir(BUILDDIR_LINUX) {
-                            sh 'cmake -DFSFW_OSAL=linux -DFSFW_BUILD_TESTS=ON -DFSFW_CICD_BUILD=ON ..'
-                        }
-                    }
+            }
+        }
+        stage('Unittests') {
+            steps {
+                dir(BUILDDIR) {
+                    sh 'cmake --build . -- fsfw-tests_coverage -j4'
                }
-                stage('Build') {
-                    steps {
-                        dir(BUILDDIR_LINUX) {
-                            sh 'cmake --build . -j4'
-                        }
-                    }
-                }
-                stage('Unittests') {
-                    steps {
-                        dir(BUILDDIR_LINUX) {
-                            sh 'cmake --build . -- fsfw-tests_coverage -j4'
-                        }
-                    }
-                }
-                stage('Valgrind') {
-                    steps {
-                        dir(BUILDDIR_LINUX) {
-                            sh 'valgrind --leak-check=full --error-exitcode=1 ./fsfw-tests'
-                        }
-                    }
+            }
+        }
+        stage('Valgrind') {
+            steps {
+                dir(BUILDDIR) {
+                    sh 'valgrind --leak-check=full --error-exitcode=1 ./fsfw-tests'
                }
            }
        }
--- a/scripts/check_release.py
+++ b/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()
--- a/src/fsfw/cfdp.h
+++ b/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"
--- a/src/fsfw/cfdp/handler/CMakeLists.txt
+++ b/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)
--- a/src/fsfw/cfdp/handler/CfdpHandler.cpp
+++ b/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;
+}
--- a/src/fsfw/cfdp/handler/CfdpHandler.h
+++ b/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
--- a/src/fsfw/cfdp/handler/DestHandler.cpp
+++ b/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; }
--- a/src/fsfw/cfdp/handler/DestHandler.h
+++ b/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
--- a/src/fsfw/cfdp/handler/SourceHandler.cpp
+++ b/src/fsfw/cfdp/handler/SourceHandler.cpp
@ -0,0 +1 @@
+#include "SourceHandler.h"
--- a/src/fsfw/cfdp/handler/SourceHandler.h
+++ b/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
--- a/src/fsfw/cfdp/handler/defs.h
+++ b/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
--- a/src/fsfw/devicehandlers/DeviceHandlerBase.cpp
+++ b/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"
@ -1509,10 +1508,7 @@ 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);
-      }
+      reply.second.dataSet->setValidity(false, true);
    }
  }
 }
--- a/src/fsfw/events/EventManager.cpp
+++ b/src/fsfw/events/EventManager.cpp
@ -23,7 +23,6 @@ EventManager::EventManager(object_id_t setObjectId)
 }

 EventManager::~EventManager() {
-  listenerList.clear();
  QueueFactory::instance()->deleteMessageQueue(eventReportQueue);
  MutexFactory::instance()->deleteMutex(mutex);
 }
@ -62,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);
 }
--- a/src/fsfw/events/EventManager.h
+++ b/src/fsfw/events/EventManager.h
@ -31,7 +31,6 @@ class EventManager : public EventManagerIF, public ExecutableObjectIF, public Sy
  MessageQueueId_t getEventReportQueue();

  ReturnValue_t registerListener(MessageQueueId_t listener, bool forwardAllButSelected = false);
-  ReturnValue_t unregisterListener(MessageQueueId_t listener) override;
  ReturnValue_t subscribeToEvent(MessageQueueId_t listener, EventId_t event);
  ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener, object_id_t object);
  ReturnValue_t subscribeToEventRange(MessageQueueId_t listener, EventId_t idFrom = 0,
--- a/src/fsfw/events/EventManagerIF.h
+++ b/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;
--- a/src/fsfw/events/fwSubsystemIdRanges.h
+++ b/src/fsfw/events/fwSubsystemIdRanges.h
@ -33,6 +33,7 @@ enum : uint8_t {
  PUS_SERVICE_23 = 103,
  MGM_LIS3MDL = 106,
  MGM_RM3100 = 107,
+  CFDP = 108,

  FW_SUBSYSTEM_ID_RANGE
 };
--- a/src/fsfw/fdir/FailureIsolationBase.cpp
+++ b/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);
 }

--- a/src/fsfw/globalfunctions/matching/MatchTree.h
+++ b/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) {
--- a/src/fsfw/health/HasHealthIF.h
+++ b/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 constexpr ReturnValue_t INVALID_HEALTH_STATE = returnvalue::makeCode(INTERFACE_ID, 2);
-  static constexpr ReturnValue_t IS_EXTERNALLY_CONTROLLED = returnvalue::makeCode(INTERFACE_ID, 3);
+  static const ReturnValue_t OBJECT_NOT_HEALTHY = MAKE_RETURN_CODE(1);
+  static const ReturnValue_t INVALID_HEALTH_STATE = MAKE_RETURN_CODE(2);

  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 = MAKE_EVENT(9, severity::LOW);
-  //! Someone starts a recovery of a component (typically power-cycle). No parameters.
-  static const Event TRYING_RECOVERY = MAKE_EVENT(10, severity::MEDIUM);
-  //! Recovery is ongoing. Comes twice during recovery.
-  //! P1: 0 for the first, 1 for the second event. P2: 0
-  static const Event RECOVERY_STEP = MAKE_EVENT(11, severity::MEDIUM);
-  //! Recovery was completed. Not necessarily successful. No parameters.
-  static const Event RECOVERY_DONE = MAKE_EVENT(12, severity::MEDIUM);
+  static const Event OVERWRITING_HEALTH =
+      MAKE_EVENT(9, severity::LOW);  //!< Assembly overwrites health information of children to keep
+                                     //!< satellite alive.
+  static const Event TRYING_RECOVERY =
+      MAKE_EVENT(10, severity::MEDIUM);  //!< Someone starts a recovery of a component (typically
+                                         //!< power-cycle). No parameters.
+  static const Event RECOVERY_STEP =
+      MAKE_EVENT(11, severity::MEDIUM);  //!< Recovery is ongoing. Comes twice during recovery. P1:
+                                         //!< 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;
--- a/src/fsfw/health/HealthTable.cpp
+++ b/src/fsfw/health/HealthTable.cpp
@ -6,6 +6,8 @@

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

--- a/src/fsfw/health/HealthTable.h
+++ b/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;
--- a/src/fsfw/internalerror/InternalErrorReporter.cpp
+++ b/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() {
-  MutexFactory::instance()->deleteMutex(mutex);
-  QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
+InternalErrorReporter::~InternalErrorReporter() { MutexFactory::instance()->deleteMutex(mutex); }

 void InternalErrorReporter::setDiagnosticPrintout(bool enable) {
  this->diagnosticPrintout = enable;
--- a/src/fsfw/modes/ModeMessage.cpp
+++ b/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); }
--- a/src/fsfw/modes/ModeMessage.h
+++ b/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);
 };
--- a/src/fsfw/objectmanager/ObjectManager.cpp
+++ b/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 iter = objectList.begin(); iter != objectList.end(); iter = objectList.erase(iter)) {
-    delete iter->second;
+  for (auto const& iter : objectList) {
+    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
--- a/src/fsfw/objectmanager/ObjectManager.h
+++ b/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
--- a/src/fsfw/osal/CMakeLists.txt
+++ b/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)
--- a/src/fsfw/osal/common/TcpTmTcServer.cpp
+++ b/src/fsfw/osal/common/TcpTmTcServer.cpp
@ -26,12 +26,12 @@
 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 ringBufferSize, ReceptionModes receptionMode)
+                             size_t receptionBufferSize, size_t ringBufferSize,
+                             std::string customTcpServerPort, ReceptionModes receptionMode)
    : SystemObject(objectId),
      tmtcBridgeId(tmtcTcpBridge),
      receptionMode(receptionMode),
-      tcpConfig(cfg),
+      tcpConfig(std::move(customTcpServerPort)),
      receptionBuffer(receptionBufferSize),
      ringBuffer(ringBufferSize, true) {}

@ -91,15 +91,6 @@ ReturnValue_t TcpTmTcServer::initialize() {
    return returnvalue::FAILED;
  }

-  if (tcpConfig.reuseAddr) {
-    unsigned int enable = 1;
-    setsockopt(listenerTcpSocket, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable));
-  }
-  if (tcpConfig.reusePort) {
-    unsigned int enable = 1;
-    setsockopt(listenerTcpSocket, SOL_SOCKET, SO_REUSEPORT, &enable, sizeof(enable));
-  }
-
  // Bind to the address found by getaddrinfo
  retval = bind(listenerTcpSocket, addrResult->ai_addr, static_cast<int>(addrResult->ai_addrlen));
  if (retval == SOCKET_ERROR) {
--- a/src/fsfw/osal/common/TcpTmTcServer.h
+++ b/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) {}
-    TcpConfig(std::string tcpPort, bool reuseAddr, bool reusePort)
-        : tcpPort(std::move(tcpPort)), reuseAddr(reuseAddr), reusePort(reusePort) {}
+    explicit TcpConfig(std::string tcpPort) : tcpPort(std::move(tcpPort)) {}

    /**
     * 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;
-
-    /**
-     * 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;
+    const std::string tcpPort;
  };
-  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;

--- a/src/fsfw/osal/linux/MessageQueue.cpp
+++ b/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)
--- a/src/fsfw/osal/osal.h.in
+++ b/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
-    }
-};
--- a/src/fsfw/osal/rtems/SemaphoreFactory.cpp
+++ b/src/fsfw/osal/rtems/SemaphoreFactory.cpp
@ -1,5 +1,5 @@
 #include "fsfw/osal/rtems/BinarySemaphore.h"
-// #include "fsfw/osal/rtems/CountingSemaphore.h"
+//#include "fsfw/osal/rtems/CountingSemaphore.h"

 #include "fsfw/serviceinterface/ServiceInterface.h"
 #include "fsfw/tasks/SemaphoreFactory.h"
--- a/src/fsfw/pus/CMakeLists.txt
+++ b/src/fsfw/pus/CMakeLists.txt
@ -9,4 +9,4 @@ target_sources(
          Service17Test.cpp
          Service20ParameterManagement.cpp
          CService200ModeCommanding.cpp
-          CServiceHealthCommanding.cpp)
+          CService201HealthCommanding.cpp)
--- a/src/fsfw/pus/CService200ModeCommanding.cpp
+++ b/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_ANNOUNCE_RECURSIVELY):
+    case (Subservice::COMMAND_MODE_ANNCOUNCE):
      return returnvalue::OK;
    default:
      return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
@ -54,32 +53,16 @@ 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);
-      if (result != returnvalue::OK) {
-        return result;
-      }
-
-      ModeMessage::setModeMessage(message, ModeMessage::CMD_MODE_COMMAND,
-                                  modeCommandPacket.getMode(), modeCommandPacket.getSubmode());
-      return returnvalue::OK;
-    }
-    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;
+  ModePacket modeCommandPacket;
+  ReturnValue_t result =
+      modeCommandPacket.deSerialize(&tcData, &tcDataLen, SerializeIF::Endianness::BIG);
+  if (result != returnvalue::OK) {
+    return result;
  }
+
+  ModeMessage::setModeMessage(message, ModeMessage::CMD_MODE_COMMAND, modeCommandPacket.getMode(),
+                              modeCommandPacket.getSubmode());
+  return result;
 }

 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) {
-        return prepareModeReply(reply, objectId);
-      }
-      return returnvalue::OK;
+      result = prepareModeReply(reply, objectId);
+      break;
    }
    case (ModeMessage::REPLY_WRONG_MODE_REPLY): {
      result = prepareWrongModeReply(reply, objectId);
--- a/src/fsfw/pus/CService200ModeCommanding.h
+++ b/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,
--- a/src/fsfw/pus/CService201HealthCommanding.cpp
+++ b/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);
+}
--- a/src/fsfw/pus/CService201HealthCommanding.h
+++ b/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);
-  ~CServiceHealthCommanding() override = default;
-
-  ReturnValue_t initialize() override;
+  CService201HealthCommanding(object_id_t objectId, uint16_t apid, uint8_t serviceId,
+                              uint8_t numParallelCommands = 4, uint16_t commandTimeoutSeconds = 60);
+  ~CService201HealthCommanding() override = default;

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

--- a/src/fsfw/pus/CServiceHealthCommanding.cpp
+++ b/src/fsfw/pus/CServiceHealthCommanding.cpp
@ -1,158 +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): {
-      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): {
-      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;
-  }
-}
--- a/src/fsfw/pus/Service11TelecommandScheduling.tpp
+++ b/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;

@ -180,7 +180,7 @@ inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::doInsertActivi
  if (CRC::crc16ccitt(data, size) != 0) {
    return CONTAINED_TC_CRC_MISSMATCH;
  }
-
+  
  // store currentPacket and receive the store address
  store_address_t addr{};
  if (tcStore->addData(&addr, data, size) != returnvalue::OK ||
--- a/src/fsfw/pus/Service20ParameterManagement.cpp
+++ b/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 << "Make sure it implements ReceivesParameterMessagesIF" << std::endl;
+    sif::error << "Object ID: " << std::hex << objectId << std::dec << 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;
--- a/src/fsfw/pus/Service9TimeManagement.cpp
+++ b/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;
-  Clock::getClock_timeval(&time);
+  uint32_t formerUptime;
+  Clock::getUptime(&formerUptime);
  result = Clock::setClock(&timeToSet);

  if (result == returnvalue::OK) {
-    timeval newTime;
-    Clock::getClock_timeval(&newTime);
-    triggerEvent(CLOCK_SET, time.tv_sec, newTime.tv_sec);
+    uint32_t newUptime;
+    Clock::getUptime(&newUptime);
+    triggerEvent(CLOCK_SET, newUptime, formerUptime);
    return returnvalue::OK;
  } else {
    triggerEvent(CLOCK_SET_FAILURE, result, 0);
--- a/src/fsfw/pus/Service9TimeManagement.h
+++ b/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;
-
-  //!< Clock has been set. P1: old timeval seconds. P2: new timeval seconds.
-  static constexpr Event CLOCK_SET = MAKE_EVENT(0, severity::INFO);
-  //!< Clock dump event. P1: timeval seconds P2: timeval milliseconds.
-  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 Event CLOCK_SET =
+      MAKE_EVENT(0, severity::INFO);  //!< Clock has been set. P1: New Uptime. P2: Old Uptime
+  static constexpr Event CLOCK_SET_FAILURE =
+      MAKE_EVENT(1, severity::LOW);  //!< Clock could not be set. P1: Returncode.

  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 {
-    SET_TIME = 128,  //!< [EXPORT] : [COMMAND] Time command in ASCII, CUC or CDS format
-    DUMP_TIME = 129,
+  enum SUBSERVICE {
+    SET_TIME = 128  //!< [EXPORT] : [COMMAND] Time command in ASCII, CUC or CDS format
  };
 };

--- a/src/fsfw/rmap/rmapStructs.h
+++ b/src/fsfw/rmap/rmapStructs.h
@ -10,11 +10,11 @@

 //////////////////////////////////////////////////////////////////////////////////
 // RMAP command bits
-// #define RMAP_COMMAND_BIT_INCREMENT	2
-// #define RMAP_COMMAND_BIT_REPLY		3
-// #define RMAP_COMMAND_BIT_WRITE		5
-// #define RMAP_COMMAND_BIT_VERIFY		4
-// #define RMAP_COMMAND_BIT			6
+//#define RMAP_COMMAND_BIT_INCREMENT	2
+//#define RMAP_COMMAND_BIT_REPLY		3
+//#define RMAP_COMMAND_BIT_WRITE		5
+//#define RMAP_COMMAND_BIT_VERIFY		4
+//#define RMAP_COMMAND_BIT			6

 namespace RMAPIds {

@ -32,14 +32,14 @@ static const uint8_t RMAP_COMMAND_READ = ((1 << RMAP_COMMAND_BIT) | (1 << RMAP_C
 static const uint8_t RMAP_REPLY_WRITE =
    ((1 << RMAP_COMMAND_BIT_WRITE) | (1 << RMAP_COMMAND_BIT_REPLY));
 static const uint8_t RMAP_REPLY_READ = ((1 << RMAP_COMMAND_BIT_REPLY));
-// #define RMAP_COMMAND_WRITE			((1<<RMAP_COMMAND_BIT) | (1<<RMAP_COMMAND_BIT_WRITE)
+//#define RMAP_COMMAND_WRITE			((1<<RMAP_COMMAND_BIT) | (1<<RMAP_COMMAND_BIT_WRITE)
 //| (1<<RMAP_COMMAND_BIT_REPLY)) #define RMAP_COMMAND_WRITE_VERIFY	((1<<RMAP_COMMAND_BIT) |
 //(1<<RMAP_COMMAND_BIT_WRITE) | (1<<RMAP_COMMAND_BIT_REPLY) | (1<<RMAP_COMMAND_BIT_VERIFY)) #define
-//  RMAP_COMMAND_READ			((1<<RMAP_COMMAND_BIT) | (1<<RMAP_COMMAND_BIT_REPLY))
+// RMAP_COMMAND_READ			((1<<RMAP_COMMAND_BIT) | (1<<RMAP_COMMAND_BIT_REPLY))

-// #define RMAP_REPLY_WRITE			((1<<RMAP_COMMAND_BIT_WRITE) |
+//#define RMAP_REPLY_WRITE			((1<<RMAP_COMMAND_BIT_WRITE) |
 //(1<<RMAP_COMMAND_BIT_REPLY))
-// #define RMAP_REPLY_WRITE_VERIFY		((1<<RMAP_COMMAND_BIT_WRITE) |
+//#define RMAP_REPLY_WRITE_VERIFY		((1<<RMAP_COMMAND_BIT_WRITE) |
 //(1<<RMAP_COMMAND_BIT_REPLY) | (1<<RMAP_COMMAND_BIT_VERIFY)) #define RMAP_REPLY_READ
 //((1<<RMAP_COMMAND_BIT_REPLY))

@ -49,9 +49,9 @@ static const uint8_t RMAP_COMMAND_HEADER_LEN = 16;
 static const uint8_t RMAP_WRITE_REPLY_HEADER_LEN = 8;
 static const uint8_t RMAP_READ_REPLY_HEADER_LEN = 12;
 static const uint8_t RMAP_DATA_FOOTER_SIZE = 1;  // SIZE OF CRC
-// #define RMAP_COMMAND_HEADER_LEN		16
-// #define RMAP_WRITE_REPLY_HEADER_LEN	8
-// #define RMAP_READ_REPLY_HEADER_LEN	12
+//#define RMAP_COMMAND_HEADER_LEN		16
+//#define RMAP_WRITE_REPLY_HEADER_LEN	8
+//#define RMAP_READ_REPLY_HEADER_LEN	12

 }  // namespace RMAPIds

--- a/src/fsfw/timemanager/CdsShortTimeStamper.cpp
+++ b/src/fsfw/timemanager/CdsShortTimeStamper.cpp
@ -4,8 +4,6 @@

 #include "fsfw/timemanager/Clock.h"

-CdsShortTimeStamper::CdsShortTimeStamper() : SystemObject(0, false) {}
-
 CdsShortTimeStamper::CdsShortTimeStamper(object_id_t objectId) : SystemObject(objectId) {}

 ReturnValue_t CdsShortTimeStamper::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
--- a/src/fsfw/timemanager/CdsShortTimeStamper.h
+++ b/src/fsfw/timemanager/CdsShortTimeStamper.h
@ -18,7 +18,6 @@
 class CdsShortTimeStamper : public TimeWriterIF, public TimeReaderIF, public SystemObject {
 public:
  static constexpr size_t TIMESTAMP_LEN = 7;
-  CdsShortTimeStamper();
  /**
   * @brief   Default constructor which also registers the time stamper as a
   *          system object so it can be found with the #objectManager.
--- a/src/fsfw/tmtcpacket/pus/tc/PusTcCreator.cpp
+++ b/src/fsfw/tmtcpacket/pus/tc/PusTcCreator.cpp
@ -100,6 +100,5 @@ ReturnValue_t PusTcCreator::setSerializableUserData(const SerializeIF &serializa
 void PusTcCreator::setup() {
  spCreator.setPacketType(ccsds::PacketType::TC);
  spCreator.setSecHeaderFlag();
-  spCreator.setSeqFlags(ccsds::SequenceFlags::UNSEGMENTED);
  updateSpLengthField();
 }
--- a/src/fsfw/tmtcpacket/pus/tm/PusTmCreator.cpp
+++ b/src/fsfw/tmtcpacket/pus/tm/PusTmCreator.cpp
@ -119,7 +119,6 @@ void PusTmCreator::setup() {
  updateSpLengthField();
  spCreator.setPacketType(ccsds::PacketType::TM);
  spCreator.setSecHeaderFlag();
-  spCreator.setSeqFlags(ccsds::SequenceFlags::UNSEGMENTED);
 }

 void PusTmCreator::setMessageTypeCounter(uint16_t messageTypeCounter) {
--- a/src/fsfw/tmtcservices/TmTcBridge.cpp
+++ b/src/fsfw/tmtcservices/TmTcBridge.cpp
@ -16,9 +16,7 @@ TmTcBridge::TmTcBridge(const char* name, object_id_t objectId, object_id_t tcDes
      tcDestination(tcDestination)

 {
-  auto mqArgs = MqArgs(objectId, static_cast<void*>(this));
-  tmTcReceptionQueue = QueueFactory::instance()->createMessageQueue(
-      TMTC_RECEPTION_QUEUE_DEPTH, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  tmTcReceptionQueue = QueueFactory::instance()->createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
 }

 TmTcBridge::~TmTcBridge() { QueueFactory::instance()->deleteMessageQueue(tmTcReceptionQueue); }
@ -37,7 +35,7 @@ ReturnValue_t TmTcBridge::setNumberOfSentPacketsPerCycle(uint8_t sentPacketsPerC
  }
 }

-ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(unsigned int maxNumberOfPacketsStored) {
+ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(uint8_t maxNumberOfPacketsStored) {
  if (maxNumberOfPacketsStored <= LIMIT_DOWNLINK_PACKETS_STORED) {
    this->maxNumberOfPacketsStored = maxNumberOfPacketsStored;
    return returnvalue::OK;
@ -145,17 +143,13 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 #endif /* FSFW_VERBOSE_LEVEL >= 3 */

    if (communicationLinkUp == false or packetSentCounter >= sentPacketsPerCycle) {
-      ReturnValue_t result = storeDownlinkData(&message);
-      if (result != returnvalue::OK) {
-        tmStore->deleteData(message.getStorageId());
-      }
+      storeDownlinkData(&message);
      continue;
    }

    result = tmStore->getData(message.getStorageId(), &data, &size);
    if (result != returnvalue::OK) {
      status = result;
-      tmStore->deleteData(message.getStorageId());
      continue;
    }

@ -163,9 +157,9 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
    if (result != returnvalue::OK) {
      status = result;
    } else {
+      tmStore->deleteData(message.getStorageId());
      packetSentCounter++;
    }
-    tmStore->deleteData(message.getStorageId());
  }
  return status;
 }
@ -177,18 +171,15 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage* message) {
  }

  if (tmFifo->full()) {
-    if (warningSwitch) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::warning << "TmTcBridge::storeDownlinkData: TM downlink max. number "
-                      "of stored packet IDs reached!"
-                   << std::endl;
+    sif::warning << "TmTcBridge::storeDownlinkData: TM downlink max. number "
+                    "of stored packet IDs reached!"
+                 << std::endl;
 #else
-      sif::printWarning(
-          "TmTcBridge::storeDownlinkData: TM downlink max. number "
-          "of stored packet IDs reached!\n");
+    sif::printWarning(
+        "TmTcBridge::storeDownlinkData: TM downlink max. number "
+        "of stored packet IDs reached!\n");
 #endif
-      warningSwitch = false;
-    }
    if (overwriteOld) {
      tmFifo->retrieve(&storeId);
      tmStore->deleteData(storeId);
@ -230,7 +221,6 @@ ReturnValue_t TmTcBridge::handleStoredTm() {
    packetSentCounter++;

    if (tmFifo->empty()) {
-      warningSwitch = true;
      tmStored = false;
    }
    tmStore->deleteData(storeId);
--- a/src/fsfw/tmtcservices/TmTcBridge.h
+++ b/src/fsfw/tmtcservices/TmTcBridge.h
@ -17,7 +17,7 @@ class TmTcBridge : public AcceptsTelemetryIF,
 public:
  static constexpr uint8_t TMTC_RECEPTION_QUEUE_DEPTH = 20;
  static constexpr uint8_t LIMIT_STORED_DATA_SENT_PER_CYCLE = 15;
-  static constexpr unsigned int LIMIT_DOWNLINK_PACKETS_STORED = 500;
+  static constexpr uint8_t LIMIT_DOWNLINK_PACKETS_STORED = 200;

  static constexpr uint8_t DEFAULT_STORED_DATA_SENT_PER_CYCLE = 5;
  static constexpr uint8_t DEFAULT_DOWNLINK_PACKETS_STORED = 10;
@ -42,7 +42,7 @@ class TmTcBridge : public AcceptsTelemetryIF,
   * @return -@c returnvalue::OK if value was set successfully
   *         -@c returnvalue::FAILED otherwise, stored value stays the same
   */
-  ReturnValue_t setMaxNumberOfPacketsStored(unsigned int maxNumberOfPacketsStored);
+  ReturnValue_t setMaxNumberOfPacketsStored(uint8_t maxNumberOfPacketsStored);

  /**
   * This will set up the bridge to overwrite old data in the FIFO.
@ -91,7 +91,6 @@ class TmTcBridge : public AcceptsTelemetryIF,
  //! by default, so telemetry will be handled immediately.
  bool communicationLinkUp = true;
  bool tmStored = false;
-  bool warningSwitch = true;
  bool overwriteOld = true;
  uint8_t packetSentCounter = 0;

@ -153,7 +152,7 @@ class TmTcBridge : public AcceptsTelemetryIF,
   */
  DynamicFIFO<store_address_t>* tmFifo = nullptr;
  uint8_t sentPacketsPerCycle = DEFAULT_STORED_DATA_SENT_PER_CYCLE;
-  unsigned int maxNumberOfPacketsStored = DEFAULT_DOWNLINK_PACKETS_STORED;
+  uint8_t maxNumberOfPacketsStored = DEFAULT_DOWNLINK_PACKETS_STORED;
 };

 #endif /* FSFW_TMTCSERVICES_TMTCBRIDGE_H_ */
--- a/src/fsfw_hal/devicehandlers/MgmRM3100Handler.cpp
+++ b/src/fsfw_hal/devicehandlers/MgmRM3100Handler.cpp
@ -325,12 +325,12 @@ ReturnValue_t MgmRM3100Handler::handleDataReadout(const uint8_t *packet) {
  // trickery here to calculate the raw values first
  int32_t fieldStrengthRawX = ((packet[1] << 24) | (packet[2] << 16) | (packet[3] << 8)) >> 8;
  int32_t fieldStrengthRawY = ((packet[4] << 24) | (packet[5] << 16) | (packet[6] << 8)) >> 8;
-  int32_t fieldStrengthRawZ = ((packet[7] << 24) | (packet[8] << 16) | (packet[9] << 8)) >> 8;
+  int32_t fieldStrengthRawZ = ((packet[7] << 24) | (packet[8] << 16) | (packet[3] << 8)) >> 8;

  // Now scale to physical value in microtesla
  float fieldStrengthX = fieldStrengthRawX * scaleFactorX;
-  float fieldStrengthY = fieldStrengthRawY * scaleFactorY;
-  float fieldStrengthZ = fieldStrengthRawZ * scaleFactorZ;
+  float fieldStrengthY = fieldStrengthRawY * scaleFactorX;
+  float fieldStrengthZ = fieldStrengthRawZ * scaleFactorX;

  if (periodicPrintout) {
    if (debugDivider.checkAndIncrement()) {
--- a/src/fsfw_hal/linux/i2c/I2cComIF.cpp
+++ b/src/fsfw_hal/linux/i2c/I2cComIF.cpp
@ -180,6 +180,10 @@ ReturnValue_t I2cComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLe
    }
 #else
 #endif
+#endif
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::debug << "I2cComIF::requestReceiveMessage: Read " << readLen << " of " << requestLen
+               << " bytes" << std::endl;
 #endif
    return returnvalue::FAILED;
  }
--- a/unittests/CatchSetup.cpp
+++ b/unittests/CatchSetup.cpp
@ -31,7 +31,4 @@ int customSetup() {
  return 0;
 }

-int customTeardown() {
-  ObjectManager::clear();
-  return 0;
-}
+int customTeardown() { return 0; }
--- a/unittests/cfdp/handler/CMakeLists.txt
+++ b/unittests/cfdp/handler/CMakeLists.txt
@ -1,2 +1,3 @@
-target_sources(${FSFW_TEST_TGT} PRIVATE testDistributor.cpp
-                                        testFaultHandler.cpp)
+target_sources(
+  ${FSFW_TEST_TGT} PRIVATE testDistributor.cpp testDestHandler.cpp
+                           testSourceHandler.cpp testFaultHandler.cpp)
--- a/unittests/cfdp/handler/testDestHandler.cpp
+++ b/unittests/cfdp/handler/testDestHandler.cpp
@ -0,0 +1,244 @@
+#include <etl/crc32.h>
+
+#include <catch2/catch_test_macros.hpp>
+#include <random>
+#include <utility>
+
+#include "fsfw/cfdp.h"
+#include "fsfw/cfdp/pdu/EofPduCreator.h"
+#include "fsfw/cfdp/pdu/FileDataCreator.h"
+#include "fsfw/cfdp/pdu/MetadataPduCreator.h"
+#include "mocks/AcceptsTmMock.h"
+#include "mocks/EventReportingProxyMock.h"
+#include "mocks/FilesystemMock.h"
+#include "mocks/MessageQueueMock.h"
+#include "mocks/StorageManagerMock.h"
+#include "mocks/cfdp/FaultHandlerMock.h"
+#include "mocks/cfdp/RemoteConfigTableMock.h"
+#include "mocks/cfdp/UserMock.h"
+
+TEST_CASE("CFDP Dest Handler", "[cfdp]") {
+  using namespace cfdp;
+  using namespace returnvalue;
+  MessageQueueId_t destQueueId = 2;
+  AcceptsTmMock tmReceiver(destQueueId);
+  MessageQueueMock mqMock(destQueueId);
+  EntityId localId = EntityId(UnsignedByteField<uint16_t>(2));
+  EntityId remoteId = EntityId(UnsignedByteField<uint16_t>(3));
+  FaultHandlerMock fhMock;
+  LocalEntityCfg localEntityCfg(localId, IndicationCfg(), fhMock);
+  FilesystemMock fsMock;
+  UserMock userMock(fsMock);
+  RemoteConfigTableMock remoteCfgTableMock;
+  PacketInfoList<64> packetInfoList;
+  LostSegmentsList<128> lostSegmentsList;
+  DestHandlerParams dp(localEntityCfg, userMock, remoteCfgTableMock, packetInfoList,
+                       lostSegmentsList);
+  EventReportingProxyMock eventReporterMock;
+  LocalPool::LocalPoolConfig storeCfg = {{10, 32}, {10, 64}, {10, 128}, {10, 1024}};
+  StorageManagerMock tcStore(2, storeCfg);
+  StorageManagerMock tmStore(3, storeCfg);
+  FsfwParams fp(tmReceiver, &mqMock, &eventReporterMock);
+  RemoteEntityCfg cfg(remoteId);
+  remoteCfgTableMock.addRemoteConfig(cfg);
+  fp.tcStore = &tcStore;
+  fp.tmStore = &tmStore;
+  uint8_t* buf = nullptr;
+  size_t serLen = 0;
+  store_address_t storeId;
+  PduConfig conf;
+  auto destHandler = DestHandler(dp, fp);
+  CHECK(destHandler.initialize() == OK);
+
+  auto metadataPreparation = [&](FileSize cfdpFileSize, ChecksumType checksumType) {
+    std::string srcNameString = "hello.txt";
+    std::string destNameString = "hello-cpy.txt";
+    StringLv srcName(srcNameString);
+    StringLv destName(destNameString);
+    MetadataInfo info(false, checksumType, cfdpFileSize, srcName, destName);
+    TransactionSeqNum seqNum(UnsignedByteField<uint16_t>(1));
+    conf.sourceId = remoteId;
+    conf.destId = localId;
+    conf.mode = TransmissionMode::UNACKNOWLEDGED;
+    conf.seqNum = seqNum;
+    MetadataPduCreator metadataCreator(conf, info);
+    REQUIRE(tcStore.getFreeElement(&storeId, metadataCreator.getSerializedSize(), &buf) == OK);
+    REQUIRE(metadataCreator.serialize(buf, serLen, metadataCreator.getSerializedSize()) == OK);
+    PacketInfo packetInfo(metadataCreator.getPduType(), storeId,
+                          metadataCreator.getDirectiveCode());
+    packetInfoList.push_back(packetInfo);
+  };
+
+  auto metadataCheck = [&](const cfdp::DestHandler::FsmResult& res, const char* sourceName,
+                           const char* destName, size_t fileLen) {
+    REQUIRE(res.result == OK);
+    REQUIRE(res.callStatus == CallStatus::CALL_AGAIN);
+    REQUIRE(res.errors == 0);
+    // Assert that the packet was deleted after handling
+    REQUIRE(not tcStore.hasDataAtId(storeId));
+    REQUIRE(packetInfoList.empty());
+    REQUIRE(userMock.metadataRecvd.size() == 1);
+    auto& idMetadataPair = userMock.metadataRecvd.back();
+    REQUIRE(idMetadataPair.first == destHandler.getTransactionId());
+    REQUIRE(idMetadataPair.second.sourceId.getValue() == 3);
+    REQUIRE(idMetadataPair.second.fileSize == fileLen);
+    REQUIRE(strcmp(idMetadataPair.second.destFileName, destName) == 0);
+    REQUIRE(strcmp(idMetadataPair.second.sourceFileName, sourceName) == 0);
+    userMock.metadataRecvd.pop();
+    REQUIRE(fsMock.fileMap.find(destName) != fsMock.fileMap.end());
+    REQUIRE(res.result == OK);
+    REQUIRE(res.state == CfdpStates::BUSY_CLASS_1_NACKED);
+    REQUIRE(res.step == DestHandler::TransactionStep::RECEIVING_FILE_DATA_PDUS);
+  };
+
+  auto eofPreparation = [&](FileSize cfdpFileSize, uint32_t crc) {
+    EofInfo eofInfo(cfdp::ConditionCode::NO_ERROR, crc, std::move(cfdpFileSize));
+    EofPduCreator eofCreator(conf, eofInfo);
+    REQUIRE(tcStore.getFreeElement(&storeId, eofCreator.getSerializedSize(), &buf) == OK);
+    REQUIRE(eofCreator.serialize(buf, serLen, eofCreator.getSerializedSize()) == OK);
+    PacketInfo packetInfo(eofCreator.getPduType(), storeId, eofCreator.getDirectiveCode());
+    packetInfoList.push_back(packetInfo);
+  };
+
+  auto eofCheck = [&](const cfdp::DestHandler::FsmResult& res, const TransactionId& id) {
+    REQUIRE(res.result == OK);
+    REQUIRE(res.state == CfdpStates::IDLE);
+    REQUIRE(res.errors == 0);
+    REQUIRE(res.step == DestHandler::TransactionStep::IDLE);
+    // Assert that the packet was deleted after handling
+    REQUIRE(not tcStore.hasDataAtId(storeId));
+    REQUIRE(packetInfoList.empty());
+    REQUIRE(userMock.eofsRevd.size() == 1);
+    auto& eofId = userMock.eofsRevd.back();
+    CHECK(eofId == id);
+    REQUIRE(userMock.finishedRecvd.size() == 1);
+    auto& idParamPair = userMock.finishedRecvd.back();
+    CHECK(idParamPair.first == id);
+    CHECK(idParamPair.second.condCode == ConditionCode::NO_ERROR);
+  };
+
+  auto fileDataPduCheck = [&](const cfdp::DestHandler::FsmResult& res,
+                              const std::vector<store_address_t>& idsToCheck) {
+    REQUIRE(res.result == OK);
+    REQUIRE(res.state == CfdpStates::BUSY_CLASS_1_NACKED);
+    REQUIRE(res.step == DestHandler::TransactionStep::RECEIVING_FILE_DATA_PDUS);
+    for (const auto id : idsToCheck) {
+      REQUIRE(not tcStore.hasDataAtId(id));
+    }
+    REQUIRE(packetInfoList.empty());
+  };
+
+  SECTION("State") {
+    CHECK(destHandler.getCfdpState() == CfdpStates::IDLE);
+    CHECK(destHandler.getTransactionStep() == DestHandler::TransactionStep::IDLE);
+  }
+
+  SECTION("Idle State Machine Iteration") {
+    auto res = destHandler.performStateMachine();
+    CHECK(res.result == OK);
+    CHECK(res.callStatus == CallStatus::CALL_AFTER_DELAY);
+    CHECK(res.errors == 0);
+    CHECK(destHandler.getCfdpState() == CfdpStates::IDLE);
+    CHECK(destHandler.getTransactionStep() == DestHandler::TransactionStep::IDLE);
+  }
+
+  SECTION("Empty File Transfer") {
+    const DestHandler::FsmResult& res = destHandler.performStateMachine();
+    CHECK(res.result == OK);
+    FileSize cfdpFileSize(0);
+    metadataPreparation(cfdpFileSize, ChecksumType::NULL_CHECKSUM);
+    destHandler.performStateMachine();
+    metadataCheck(res, "hello.txt", "hello-cpy.txt", 0);
+    destHandler.performStateMachine();
+    REQUIRE(res.callStatus == CallStatus::CALL_AFTER_DELAY);
+    auto transactionId = destHandler.getTransactionId();
+    eofPreparation(cfdpFileSize, 0);
+    // After EOF, operation is done because no closure was requested
+    destHandler.performStateMachine();
+    eofCheck(res, transactionId);
+  }
+
+  SECTION("Small File Transfer") {
+    const DestHandler::FsmResult& res = destHandler.performStateMachine();
+    CHECK(res.result == OK);
+    std::string fileData = "hello test data";
+    etl::crc32 crcCalc;
+    crcCalc.add(fileData.begin(), fileData.end());
+    uint32_t crc32 = crcCalc.value();
+    FileSize cfdpFileSize(fileData.size());
+    metadataPreparation(cfdpFileSize, ChecksumType::CRC_32);
+    destHandler.performStateMachine();
+    metadataCheck(res, "hello.txt", "hello-cpy.txt", fileData.size());
+    destHandler.performStateMachine();
+    REQUIRE(res.callStatus == CallStatus::CALL_AFTER_DELAY);
+    auto transactionId = destHandler.getTransactionId();
+    FileSize offset(0);
+    FileDataInfo fdPduInfo(offset, reinterpret_cast<const uint8_t*>(fileData.data()),
+                           fileData.size());
+    FileDataCreator fdPduCreator(conf, fdPduInfo);
+    REQUIRE(tcStore.getFreeElement(&storeId, fdPduCreator.getSerializedSize(), &buf) == OK);
+    REQUIRE(fdPduCreator.serialize(buf, serLen, fdPduCreator.getSerializedSize()) == OK);
+    PacketInfo packetInfo(fdPduCreator.getPduType(), storeId, std::nullopt);
+    packetInfoList.push_back(packetInfo);
+    destHandler.performStateMachine();
+    fileDataPduCheck(res, {storeId});
+    eofPreparation(cfdpFileSize, crc32);
+    // After EOF, operation is done because no closure was requested
+    destHandler.performStateMachine();
+    eofCheck(res, transactionId);
+  }
+
+  SECTION("Segmented File Transfer") {
+    const DestHandler::FsmResult& res = destHandler.performStateMachine();
+    CHECK(res.result == OK);
+    std::random_device dev;
+    std::mt19937 rng(dev());
+    std::uniform_int_distribution<std::mt19937::result_type> distU8(0, 255);
+    std::array<uint8_t, 1024> largerFileData{};
+    for (auto& val : largerFileData) {
+      val = distU8(rng);
+    }
+    etl::crc32 crcCalc;
+    crcCalc.add(largerFileData.begin(), largerFileData.end());
+    uint32_t crc32 = crcCalc.value();
+    FileSize cfdpFileSize(largerFileData.size());
+    metadataPreparation(cfdpFileSize, ChecksumType::CRC_32);
+    destHandler.performStateMachine();
+    metadataCheck(res, "hello.txt", "hello-cpy.txt", largerFileData.size());
+    destHandler.performStateMachine();
+    REQUIRE(res.callStatus == CallStatus::CALL_AFTER_DELAY);
+    auto transactionId = destHandler.getTransactionId();
+
+    std::vector<store_address_t> idsToCheck;
+    {
+      FileSize offset(0);
+      FileDataInfo fdPduInfo(offset, reinterpret_cast<const uint8_t*>(largerFileData.data()),
+                             largerFileData.size() / 2);
+      FileDataCreator fdPduCreator(conf, fdPduInfo);
+      REQUIRE(tcStore.getFreeElement(&storeId, fdPduCreator.getSerializedSize(), &buf) == OK);
+      REQUIRE(fdPduCreator.serialize(buf, serLen, fdPduCreator.getSerializedSize()) == OK);
+      PacketInfo packetInfo(fdPduCreator.getPduType(), storeId, std::nullopt);
+      idsToCheck.push_back(storeId);
+      packetInfoList.push_back(packetInfo);
+    }
+
+    {
+      FileSize offset(512);
+      FileDataInfo fdPduInfo(offset, reinterpret_cast<const uint8_t*>(largerFileData.data() + 512),
+                             largerFileData.size() / 2);
+      FileDataCreator fdPduCreator(conf, fdPduInfo);
+      REQUIRE(tcStore.getFreeElement(&storeId, fdPduCreator.getSerializedSize(), &buf) == OK);
+      REQUIRE(fdPduCreator.serialize(buf, serLen, fdPduCreator.getSerializedSize()) == OK);
+      PacketInfo packetInfo(fdPduCreator.getPduType(), storeId, std::nullopt);
+      idsToCheck.push_back(storeId);
+      packetInfoList.push_back(packetInfo);
+    }
+
+    destHandler.performStateMachine();
+    fileDataPduCheck(res, idsToCheck);
+    eofPreparation(cfdpFileSize, crc32);
+    // After EOF, operation is done because no closure was requested
+    destHandler.performStateMachine();
+    eofCheck(res, transactionId);
+  }
+}
--- a/unittests/cfdp/handler/testSourceHandler.cpp
+++ b/unittests/cfdp/handler/testSourceHandler.cpp
@ -0,0 +1,3 @@
+#include <catch2/catch_test_macros.hpp>
+
+TEST_CASE("CFDP Source Handler", "[cfdp]") {}
--- a/unittests/devicehandler/DeviceHandlerCommander.cpp
+++ b/unittests/devicehandler/DeviceHandlerCommander.cpp
@ -9,9 +9,7 @@ DeviceHandlerCommander::DeviceHandlerCommander(object_id_t objectId)
      QUEUE_SIZE, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }

-DeviceHandlerCommander::~DeviceHandlerCommander() {
-  QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
+DeviceHandlerCommander::~DeviceHandlerCommander() {}

 ReturnValue_t DeviceHandlerCommander::performOperation(uint8_t operationCode) {
  readCommandQueue();
--- a/unittests/osal/TestSemaphore.cpp
+++ b/unittests/osal/TestSemaphore.cpp
@ -1,38 +1,46 @@
-#include <fsfw/osal/osal.h>
+
+#ifdef LINUX
+
+/*
 #include <fsfw/tasks/SemaphoreFactory.h>
 #include <fsfw/timemanager/Stopwatch.h>

-#include <catch2/catch_test_macros.hpp>
+#include "catch.hpp"
+#include "core/CatchDefinitions.h"

-// binary semaphores currently only supported on linux
-#ifdef FSFW_OSAL_LINUX
-
-TEST_CASE("Binary Semaphore Test", "[BinSemaphore]") {
-  // perform set-up here
-  SemaphoreIF* binSemaph = SemaphoreFactory::instance()->createBinarySemaphore();
-  REQUIRE(binSemaph != nullptr);
-  SECTION("Simple Test") {
-    // set-up is run for each section
-    REQUIRE(binSemaph->getSemaphoreCounter() == 1);
-    REQUIRE(binSemaph->release() == static_cast<int>(SemaphoreIF::SEMAPHORE_NOT_OWNED));
-    REQUIRE(binSemaph->acquire(SemaphoreIF::POLLING) == returnvalue::OK);
-    {
-      // not precise enough on linux.. should use clock instead..
-      // Stopwatch stopwatch(false);
-      // REQUIRE(binSemaph->acquire(SemaphoreIF::TimeoutType::WAITING, 5) ==
-      //		SemaphoreIF::SEMAPHORE_TIMEOUT);
-      // dur_millis_t time = stopwatch.stop();
-      // CHECK(time == 5);
-    }
-    REQUIRE(binSemaph->getSemaphoreCounter() == 0);
-    REQUIRE(binSemaph->release() == returnvalue::OK);
-  }
-  SemaphoreFactory::instance()->deleteSemaphore(binSemaph);
-  // perform tear-down here
+TEST_CASE("Binary Semaphore Test" , "[BinSemaphore]") {
+        //perform set-up here
+        SemaphoreIF* binSemaph = SemaphoreFactory::instance()->
+                        createBinarySemaphore();
+        REQUIRE(binSemaph != nullptr);
+        SECTION("Simple Test") {
+                // set-up is run for each section
+                REQUIRE(binSemaph->getSemaphoreCounter() == 1);
+                REQUIRE(binSemaph->release() ==
+                                static_cast<int>(SemaphoreIF::SEMAPHORE_NOT_OWNED));
+                REQUIRE(binSemaph->acquire(SemaphoreIF::POLLING) ==
+                                result::OK);
+                {
+                        // not precise enough on linux.. should use clock instead..
+                        //Stopwatch stopwatch(false);
+                        //REQUIRE(binSemaph->acquire(SemaphoreIF::TimeoutType::WAITING, 5) ==
+                        //		SemaphoreIF::SEMAPHORE_TIMEOUT);
+                        //dur_millis_t time = stopwatch.stop();
+                        //CHECK(time == 5);
+                }
+                REQUIRE(binSemaph->getSemaphoreCounter() == 0);
+                REQUIRE(binSemaph->release() == result::OK);
+        }
+        SemaphoreFactory::instance()->deleteSemaphore(binSemaph);
+        // perform tear-down here
 }

-TEST_CASE("Counting Semaphore Test", "[CountingSemaph]") {
-  SECTION("Simple Test") {}
-}

-#endif
+TEST_CASE("Counting Semaphore Test" , "[CountingSemaph]") {
+        SECTION("Simple Test") {
+
+        }
+}
+*/
+
+#endif
--- a/unittests/testcfg/devices/logicalAddresses.h
+++ b/unittests/testcfg/devices/logicalAddresses.h
@ -7,7 +7,7 @@

 namespace addresses {
 /* Logical addresses have uint32_t datatype */
-enum LogicAddress : address_t {};
+enum logicalAddresses : address_t {};
 }  // namespace addresses

 #endif /* CONFIG_DEVICES_LOGICALADDRESSES_H_ */
Author	SHA1	Message	Date
Robin Müller	39310c3fad	Merge branch 'service_11_bugfixes' into mueller/new-cfdp-update-with-handlers fsfw/fsfw/pipeline/head This commit looks good Details	2023-01-13 11:15:50 +01:00
Robin Müller	bf311757a2	Merge branch 'service_11_bugfixes' into mueller/new-cfdp-update-with-handlers fsfw/fsfw/pipeline/head This commit looks good Details	2023-01-13 10:59:48 +01:00
Robin Müller	cbe1b65a33	Merge branch 'service_11_bugfixes' into mueller/new-cfdp-update-with-handlers fsfw/fsfw/pipeline/head This commit looks good Details	2023-01-13 10:56:24 +01:00
Robin Müller	80f0060cd2	Merge remote-tracking branch 'origin/development' into mueller/new-cfdp-update-with-handlers fsfw/fsfw/pipeline/head Build queued... Details	2023-01-13 10:56:16 +01:00
Robin Müller	009700ce80	remove info printout fsfw/fsfw/pipeline/head There was a failure building this commit Details	2022-10-17 17:29:10 +02:00
Robin Müller	1e43296f2b	missing validity check fsfw/fsfw/pipeline/head There was a failure building this commit Details	2022-10-17 17:24:46 +02:00
Robin Müller	1aa062df7f	const specifier for AcceptsTelemetryIF fsfw/fsfw/pipeline/head There was a failure building this commit Details	2022-10-17 16:27:41 +02:00
Robin Müller	14a8924a83	size check bugfix fsfw/fsfw/pipeline/head There was a failure building this commit Details	2022-10-17 14:01:21 +02:00
Robin Müller	9f81926aec	some more basic error handling fsfw/fsfw/pipeline/head There was a failure building this commit Details	2022-10-17 12:22:01 +02:00
Robin Müller	79c38b45df	events for FSFW specific errors fsfw/fsfw/pipeline/head There was a failure building this commit Details	2022-10-17 12:20:26 +02:00
Robin Müller	e893e73f86	add first CFDP events fsfw/fsfw/pipeline/head There was a failure building this commit Details	2022-10-17 12:19:31 +02:00
Robin Müller	bdbe0cc9da	pass message queue externally fsfw/fsfw/pipeline/head This commit looks good Details	2022-09-16 16:28:41 +02:00
Robin Müller	c38088c64b	adaptions for enum renaming fsfw/fsfw/pipeline/head This commit looks good Details	2022-09-15 18:44:00 +02:00
Robin Müller	7eb63d6d79	Merge branch 'mueller/cfdp-update-without-handlers' into mueller/new-cfdp-update-with-handlers fsfw/fsfw/pipeline/head There was a failure building this commit Details	2022-09-15 18:41:29 +02:00
Robin Müller	ed68268c0c	generic cfdp handler wrapper fsfw/fsfw/pipeline/head There was a failure building this commit Details	2022-09-15 16:53:04 +02:00
Robin Müller	c549914efb	include helpers fsfw/fsfw/pipeline/head There was a failure building this commit Details	2022-09-15 16:50:06 +02:00
Robin Müller	753d5ff39e	adaptions for enum renaming fsfw/fsfw/pipeline/head There was a failure building this commit Details	2022-09-15 16:47:09 +02:00
Robin Müller	36ca35da77	Merge branch 'mueller/cfdp-update-without-handlers' into mueller/new-cfdp-update-with-handlers	2022-09-15 16:46:25 +02:00
Robin Müller	4fb7375492	Merge branch 'mueller/cfdp-update-without-handlers' into mueller/new-cfdp-update-with-handlers fsfw/fsfw/pipeline/head This commit looks good Details	2022-09-15 16:21:32 +02:00
Robin Müller	47df9e8b5b	Merge branch 'mueller/cfdp-update-without-handlers' into mueller/new-cfdp-update-with-handlers fsfw/fsfw/pipeline/head This commit looks good Details	2022-09-15 16:03:06 +02:00
Robin Müller	86aafe4422	Merge branch 'mueller/cfdp-update-without-handlers' into mueller/new-cfdp-update-with-handlers fsfw/fsfw/pipeline/head This commit looks good Details	2022-09-15 11:02:46 +02:00
Robin Müller	dbaeed83af	Merge branch 'mueller/cfdp-update-without-handlers' into mueller/new-cfdp-update-with-handlers fsfw/fsfw/pipeline/head This commit looks good Details	2022-09-14 19:48:25 +02:00
Robin Müller	385a0ffd73	add CFDP handlers manually fsfw/fsfw/pipeline/head This commit looks good Details	2022-09-14 19:29:43 +02:00