possiible leak fixes

Reviewed-on: fsfw/fsfw#715

CHANGELOG.md

@@ -12,6 +12,23 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Fixes
 
+- `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.
+- `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
+- DHB `setNormalDatapoolEntriesInvalid`: The default implementation did not set the validity
+  to false correctly because the `read` and `write` calls were missing.
+- PUS TMTC creator module: Sequence flags were set to continuation segment (0b00) instead
+  of the correct unsegmented flags (0b11) as specified in the standard.
+- TC Scheduler Service 11: Add size and CRC check for contained TC.
+- Only delete health table entry in `HealthHelper` destructor if
+  health table was set.
+  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
@@ -24,19 +41,31 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Added
 
-- DHB TM handler `handleDeviceTM` renamed to `handleDeviceTm` and now takes
+- `CServiceHealthCommanding`: Add announce all health info implementation
-  `util::DataWrapper` as the data input argument. This allows more flexibility in the possible
+  PR: https://egit.irs.uni-stuttgart.de/eive/fsfw/pulls/122
-  types of telemetry.
+- `Service9TimeManagement`: Add `DUMP_TIME` (129) subservice.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/669
+- `TcpTmTcServer`: Allow setting the `SO_REUSEADDR` and `SO_REUSEPORT`
-- Add `util::DataWrapper` class inside the `util` module. This is a tagged union which allows
+  option on the TCP server. CTOR prototype has changed and expects an explicit
-  to specify raw data either as a classic C-style raw pointer and size or as a `SerializeIF`
+  TCP configuration struct to be passed.
-  pointer.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/722
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/668
+- `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
 
 ## Changes
 
+- `CService201HealthCommanding` renamed to `CServiceHealthCommanding`,
+  service ID customizable now. `CServiceHealthCommanding` expects configuration struct
+  `HealthServiceCfg` now
+  PR: https://egit.irs.uni-stuttgart.de/eive/fsfw/pulls/122
+- `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
+  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
   `uint16_t getTmSpacePacketIdFromApid(uint16_t apid, bool secondaryHeaderFlag)`
@@ -65,6 +94,10 @@ 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
@@ -92,6 +125,16 @@ 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
 
+## HAL
+
+- SPI: Cache the SPI device in the communication interface. Architecturally, this makes a
+  lot more sense because each ComIF should be responsible for one SPI bus.
+- SPI: Move the empty transfer to update the line polarity to separate function. This means
+  it is not automatically called when calling the setter function for SPI speed and mode.
+  The user should call this function after locking the CS mutex if multiple SPI devices with
+  differing speeds and modes are attached to one bus.
+- SPI: Getter functions for SPI speed and mode.
+
 # [v5.0.0] 25.07.2022
 
 ## Changes
@@ -225,6 +268,7 @@ https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593
     - https://gitlab.kitware.com/cmake/cmake/-/issues/21696
   Easiest solution for now: Keep this option OFF by default.
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/616
+- Linux HAL: Add wiretapping option for I2C. Enabled with `FSFW_HAL_I2C_WIRETAPPING` defined to 1
 - Dedicated Version class and constant `fsfw::FSFW_VERSION` containing version information
   inside `fsfw/version.h`
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/559
@@ -239,17 +283,6 @@ https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
 - `Subsystem`: New API to add table and sequence entries
 
-## HAL
-
-- SPI: Cache the SPI device in the communication interface. Architecturally, this makes a
-  lot more sense because each ComIF should be responsible for one SPI bus.
-- SPI: Move the empty transfer to update the line polarity to separate function. This means
-  it is not automatically called when calling the setter function for SPI speed and mode.
-  The user should call this function after locking the CS mutex if multiple SPI devices with
-  differing speeds and modes are attached to one bus.
-- SPI: Getter functions for SPI speed and mode.
-- I2C: Add wiretapping option for I2C. Enabled with `FSFW_HAL_I2C_WIRETAPPING` defined to 1.
-
 ## Fixed
 
 - TCP TMTC Server: `MutexGuard` was not created properly in

CMakeLists.txt

@@ -122,6 +122,7 @@ if(UNIX)
   option(FSFW_HAL_LINUX_ADD_PERIPHERAL_DRIVERS "Add Linux peripheral drivers"
          OFF)
   option(FSFW_HAL_LINUX_ADD_LIBGPIOD "Attempt to add Linux GPIOD drivers" OFF)
+  option(FSFW_HAL_LINUX_ADD_SERIAL_DRIVERS "Add serial drivers" ON)
 endif()
 
 # Optional sources

automation/Jenkinsfile

@@ -1,48 +1,90 @@
 pipeline {
     environment {
-        BUILDDIR = 'cmake-build-tests'
+        BUILDDIR_HOST = 'cmake-build-tests-host'
+        BUILDDIR_LINUX = 'cmake-build-tests-linux'
         DOCDDIR = 'cmake-build-documentation'
     }
     agent {
         docker { 
             image 'fsfw-ci:d6'
-            args '--network host'
+            args '--network host --sysctl fs.mqueue.msg_max=100'
         }
     }
     stages {
+        stage('Host') {
+            stages{
                 stage('Clean') {
                     steps {
-                sh 'rm -rf $BUILDDIR'
+                        sh 'rm -rf $BUILDDIR_HOST'
                     }
                 }
                 stage('Configure') {
                     steps {
-                dir(BUILDDIR) {
+                        dir(BUILDDIR_HOST) {
                             sh 'cmake -DFSFW_OSAL=host -DFSFW_BUILD_TESTS=ON -DFSFW_CICD_BUILD=ON ..'
                         }
                     }
                 }
                 stage('Build') {
                     steps {
-                dir(BUILDDIR) {
+                        dir(BUILDDIR_HOST) {
                             sh 'cmake --build . -j4'
                         }
                     }
                 }
                 stage('Unittests') {
                     steps {
-                dir(BUILDDIR) {
+                        dir(BUILDDIR_HOST) {
                             sh 'cmake --build . -- fsfw-tests_coverage -j4'
                         }
                     }
                 }
                 stage('Valgrind') {
                     steps {
-                dir(BUILDDIR) {
+                        dir(BUILDDIR_HOST) {
                             sh 'valgrind --leak-check=full --error-exitcode=1 ./fsfw-tests'
                         }
                     }
                 }
+            }
+        }
+        stage('Linux') {
+            stages{
+                stage('Clean') {
+                    steps {
+                        sh 'rm -rf $BUILDDIR_LINUX'
+                    }
+                }
+                stage('Configure') {
+                    steps {
+                        dir(BUILDDIR_LINUX) {
+                            sh 'cmake -DFSFW_OSAL=linux -DFSFW_BUILD_TESTS=ON -DFSFW_CICD_BUILD=ON ..'
+                        }
+                    }
+                }
+                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('Documentation') {
             when {
                 branch 'development'

cmake/cmake-modules/bilke/CodeCoverage.cmake

@@ -140,7 +140,7 @@ find_program( GCOV_PATH gcov )
 find_program( LCOV_PATH  NAMES lcov lcov.bat lcov.exe lcov.perl)
 find_program( FASTCOV_PATH NAMES fastcov fastcov.py )
 find_program( GENHTML_PATH NAMES genhtml genhtml.perl genhtml.bat )
-find_program( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/scripts/test)
+find_program( GCOVR_PATH gcovr )
 find_program( CPPFILT_PATH NAMES c++filt )
 
 if(NOT GCOV_PATH)

docs/conf.py

@@ -51,7 +51,10 @@ exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
 html_theme = "alabaster"
 
 html_theme_options = {
-    "extra_nav_links": {"Impressum" : "https://www.uni-stuttgart.de/impressum", "Datenschutz": "https://info.irs.uni-stuttgart.de/datenschutz/datenschutzWebmit.html"}
+    "extra_nav_links": {
+        "Impressum": "https://www.uni-stuttgart.de/impressum",
+        "Datenschutz": "https://info.irs.uni-stuttgart.de/datenschutz/datenschutzWebmit.html",
+    }
 }
 
 

src/fsfw/container/ArrayList.h

@@ -4,6 +4,7 @@
 #include "../returnvalues/returnvalue.h"
 #include "../serialize/SerializeAdapter.h"
 #include "../serialize/SerializeIF.h"
+#include "definitions.h"
 
 /**
  * @brief     A List that stores its values in an array.
@@ -19,9 +20,6 @@ class ArrayList {
   friend class SerialArrayListAdapter;
 
  public:
-  static const uint8_t INTERFACE_ID = CLASS_ID::ARRAY_LIST;
-  static const ReturnValue_t FULL = MAKE_RETURN_CODE(0x01);
-
   /**
    * This is the allocating constructor.
    * It allocates an array of the specified size.
@@ -187,7 +185,7 @@ class ArrayList {
    */
   ReturnValue_t insert(T entry) {
     if (size >= maxSize_) {
-      return FULL;
+      return containers::LIST_FULL;
     }
     entries[size] = entry;
     ++size;

src/fsfw/container/FixedArrayList.h

@@ -12,6 +12,7 @@ template <typename T, size_t MAX_SIZE, typename count_t = uint8_t>
 class FixedArrayList : public ArrayList<T, count_t> {
   static_assert(MAX_SIZE <= std::numeric_limits<count_t>::max(),
                 "count_t is not large enough to hold MAX_SIZE");
+  static_assert(MAX_SIZE > 0, "MAX_SIZE is 0");
 
  private:
   T data[MAX_SIZE];
@@ -20,15 +21,19 @@ class FixedArrayList : public ArrayList<T, count_t> {
   FixedArrayList() : ArrayList<T, count_t>(data, MAX_SIZE) {}
 
   FixedArrayList(const FixedArrayList& other) : ArrayList<T, count_t>(data, MAX_SIZE) {
-    memcpy(this->data, other.data, sizeof(this->data));
     this->entries = data;
     this->size = other.size;
+    for (size_t idx = 0; idx < this->size; idx++) {
+      data[idx] = other.data[idx];
+    }
   }
 
   FixedArrayList& operator=(FixedArrayList other) {
-    memcpy(this->data, other.data, sizeof(this->data));
     this->entries = data;
     this->size = other.size;
+    for (size_t idx = 0; idx < this->size; idx++) {
+      data[idx] = other.data[idx];
+    }
     return *this;
   }
 

src/fsfw/container/FixedMap.h

@@ -4,8 +4,8 @@
 #include <type_traits>
 #include <utility>
 
-#include "../returnvalues/returnvalue.h"
 #include "ArrayList.h"
+#include "definitions.h"
 
 /**
  * @brief    Map implementation for maps with a pre-defined size.
@@ -24,11 +24,6 @@ class FixedMap : public SerializeIF {
                 "derived class from SerializeIF to be serialize-able");
 
  public:
-  static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MAP;
-  static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
-  static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
-  static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
-
  private:
   static const key_t EMPTY_SLOT = -1;
   ArrayList<std::pair<key_t, T>, uint32_t> theMap;
@@ -76,10 +71,10 @@ class FixedMap : public SerializeIF {
 
   ReturnValue_t insert(key_t key, T value, Iterator* storedValue = nullptr) {
     if (exists(key) == returnvalue::OK) {
-      return KEY_ALREADY_EXISTS;
+      return containers::KEY_ALREADY_EXISTS;
     }
     if (_size == theMap.maxSize()) {
-      return MAP_FULL;
+      return containers::MAP_FULL;
     }
     theMap[_size].first = key;
     theMap[_size].second = value;
@@ -93,7 +88,7 @@ class FixedMap : public SerializeIF {
   ReturnValue_t insert(std::pair<key_t, T> pair) { return insert(pair.first, pair.second); }
 
   ReturnValue_t exists(key_t key) const {
-    ReturnValue_t result = KEY_DOES_NOT_EXIST;
+    ReturnValue_t result = containers::KEY_DOES_NOT_EXIST;
     if (findIndex(key) < _size) {
       result = returnvalue::OK;
     }
@@ -103,7 +98,7 @@ class FixedMap : public SerializeIF {
   ReturnValue_t erase(Iterator* iter) {
     uint32_t i;
     if ((i = findIndex((*iter).value->first)) >= _size) {
-      return KEY_DOES_NOT_EXIST;
+      return containers::KEY_DOES_NOT_EXIST;
     }
     theMap[i] = theMap[_size - 1];
     --_size;
@@ -114,7 +109,7 @@ class FixedMap : public SerializeIF {
   ReturnValue_t erase(key_t key) {
     uint32_t i;
     if ((i = findIndex(key)) >= _size) {
-      return KEY_DOES_NOT_EXIST;
+      return containers::KEY_DOES_NOT_EXIST;
     }
     theMap[i] = theMap[_size - 1];
     --_size;

src/fsfw/container/definitions.h

@@ -0,0 +1,14 @@
+#ifndef FSFW_CONTAINER_DEFINITIONS_H_
+#define FSFW_CONTAINER_DEFINITIONS_H_
+
+#include "fsfw/retval.h"
+
+namespace containers {
+static const ReturnValue_t KEY_ALREADY_EXISTS = returnvalue::makeCode(CLASS_ID::FIXED_MAP, 0x01);
+static const ReturnValue_t MAP_FULL = returnvalue::makeCode(CLASS_ID::FIXED_MAP, 0x02);
+static const ReturnValue_t KEY_DOES_NOT_EXIST = returnvalue::makeCode(CLASS_ID::FIXED_MAP, 0x03);
+
+static const ReturnValue_t LIST_FULL = returnvalue::makeCode(CLASS_ID::ARRAY_LIST, 0x01);
+}  // namespace containers
+
+#endif /* FSFW_CONTAINER_DEFINITIONS_H_ */

src/fsfw/controller/ControllerBase.cpp

@@ -4,11 +4,10 @@
 #include "fsfw/ipc/QueueFactory.h"
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/subsystem/SubsystemBase.h"
+#include "fsfw/subsystem/helper.h"
 
-ControllerBase::ControllerBase(object_id_t setObjectId, object_id_t parentId,
+ControllerBase::ControllerBase(object_id_t setObjectId, size_t commandQueueDepth)
-                               size_t commandQueueDepth)
     : SystemObject(setObjectId),
-      parentId(parentId),
       mode(MODE_OFF),
       submode(SUBMODE_NONE),
       modeHelper(this),
@@ -21,33 +20,15 @@ ControllerBase::ControllerBase(object_id_t setObjectId, object_id_t parentId,
 ControllerBase::~ControllerBase() { QueueFactory::instance()->deleteMessageQueue(commandQueue); }
 
 ReturnValue_t ControllerBase::initialize() {
-  ReturnValue_t result = SystemObject::initialize();
+  ReturnValue_t result = modeHelper.initialize();
   if (result != returnvalue::OK) {
     return result;
   }
-
+  result = healthHelper.initialize();
-  MessageQueueId_t parentQueue = 0;
-  if (parentId != objects::NO_OBJECT) {
-    auto* parent = ObjectManager::instance()->get<SubsystemBase>(parentId);
-    if (parent == nullptr) {
-      return returnvalue::FAILED;
-    }
-    parentQueue = parent->getCommandQueue();
-
-    parent->registerChild(getObjectId());
-  }
-
-  result = healthHelper.initialize(parentQueue);
   if (result != returnvalue::OK) {
     return result;
   }
-
+  return SystemObject::initialize();
-  result = modeHelper.initialize(parentQueue);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-
-  return returnvalue::OK;
 }
 
 MessageQueueId_t ControllerBase::getCommandQueue() const { return commandQueue->getId(); }
@@ -120,3 +101,13 @@ void ControllerBase::setTaskIF(PeriodicTaskIF* task_) { executingTask = task_; }
 void ControllerBase::changeHK(Mode_t mode_, Submode_t submode_, bool enable) {}
 
 ReturnValue_t ControllerBase::initializeAfterTaskCreation() { return returnvalue::OK; }
+
+const HasHealthIF* ControllerBase::getOptHealthIF() const { return this; }
+
+const HasModesIF& ControllerBase::getModeIF() const { return *this; }
+
+ModeTreeChildIF& ControllerBase::getModeTreeChildIF() { return *this; }
+
+ReturnValue_t ControllerBase::connectModeTreeParent(HasModeTreeChildrenIF& parent) {
+  return modetree::connectModeTreeParent(parent, *this, &healthHelper, modeHelper);
+}

src/fsfw/controller/ControllerBase.h

@@ -6,6 +6,9 @@
 #include "fsfw/modes/HasModesIF.h"
 #include "fsfw/modes/ModeHelper.h"
 #include "fsfw/objectmanager/SystemObject.h"
+#include "fsfw/subsystem/HasModeTreeChildrenIF.h"
+#include "fsfw/subsystem/ModeTreeChildIF.h"
+#include "fsfw/subsystem/ModeTreeConnectionIF.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
 #include "fsfw/tasks/PeriodicTaskIF.h"
 
@@ -18,13 +21,18 @@
 class ControllerBase : public HasModesIF,
                        public HasHealthIF,
                        public ExecutableObjectIF,
+                       public ModeTreeChildIF,
+                       public ModeTreeConnectionIF,
                        public SystemObject {
  public:
   static const Mode_t MODE_NORMAL = 2;
 
-  ControllerBase(object_id_t setObjectId, object_id_t parentId, size_t commandQueueDepth = 3);
+  ControllerBase(object_id_t setObjectId, size_t commandQueueDepth = 3);
   ~ControllerBase() override;
 
+  ReturnValue_t connectModeTreeParent(HasModeTreeChildrenIF &parent) override;
+  ModeTreeChildIF &getModeTreeChildIF() override;
+
   /** SystemObject override */
   ReturnValue_t initialize() override;
 
@@ -38,6 +46,8 @@ class ControllerBase : public HasModesIF,
   ReturnValue_t performOperation(uint8_t opCode) override;
   void setTaskIF(PeriodicTaskIF *task) override;
   ReturnValue_t initializeAfterTaskCreation() override;
+  const HasHealthIF *getOptHealthIF() const override;
+  const HasModesIF &getModeIF() const override;
 
  protected:
   /**
@@ -56,8 +66,6 @@ class ControllerBase : public HasModesIF,
   ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
                                  uint32_t *msToReachTheMode) override = 0;
 
-  const object_id_t parentId;
-
   Mode_t mode;
 
   Submode_t submode;

src/fsfw/controller/ExtendedControllerBase.cpp

@@ -1,8 +1,7 @@
 #include "fsfw/controller/ExtendedControllerBase.h"
 
-ExtendedControllerBase::ExtendedControllerBase(object_id_t objectId, object_id_t parentId,
+ExtendedControllerBase::ExtendedControllerBase(object_id_t objectId, size_t commandQueueDepth)
-                                               size_t commandQueueDepth)
+    : ControllerBase(objectId, commandQueueDepth),
-    : ControllerBase(objectId, parentId, commandQueueDepth),
       poolManager(this, commandQueue),
       actionHelper(this, commandQueue) {}
 

src/fsfw/controller/ExtendedControllerBase.h

@@ -17,7 +17,7 @@ class ExtendedControllerBase : public ControllerBase,
                                public HasActionsIF,
                                public HasLocalDataPoolIF {
  public:
-  ExtendedControllerBase(object_id_t objectId, object_id_t parentId, size_t commandQueueDepth = 3);
+  ExtendedControllerBase(object_id_t objectId, size_t commandQueueDepth = 3);
   ~ExtendedControllerBase() override;
 
   /* SystemObjectIF overrides */

src/fsfw/devicehandlers/AssemblyBase.cpp

@@ -1,7 +1,7 @@
 #include "fsfw/devicehandlers/AssemblyBase.h"
 
-AssemblyBase::AssemblyBase(object_id_t objectId, object_id_t parentId, uint16_t commandQueueDepth)
+AssemblyBase::AssemblyBase(object_id_t objectId, uint16_t commandQueueDepth)
-    : SubsystemBase(objectId, parentId, MODE_OFF, commandQueueDepth),
+    : SubsystemBase(objectId, MODE_OFF, commandQueueDepth),
       internalState(STATE_NONE),
       recoveryState(RECOVERY_IDLE),
       recoveringDevice(childrenMap.end()),

src/fsfw/devicehandlers/AssemblyBase.h

@@ -41,7 +41,7 @@ class AssemblyBase : public SubsystemBase {
   static const ReturnValue_t NEED_TO_CHANGE_HEALTH = MAKE_RETURN_CODE(0x05);
   static const ReturnValue_t NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE = MAKE_RETURN_CODE(0xa1);
 
-  AssemblyBase(object_id_t objectId, object_id_t parentId, uint16_t commandQueueDepth = 8);
+  AssemblyBase(object_id_t objectId, uint16_t commandQueueDepth = 8);
   virtual ~AssemblyBase();
 
  protected:

src/fsfw/devicehandlers/ChildHandlerBase.cpp

@@ -3,17 +3,12 @@
 #include "fsfw/subsystem/SubsystemBase.h"
 
 ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
-                                   CookieIF* cookie, object_id_t hkDestination,
+                                   CookieIF* cookie, HasModeTreeChildrenIF& parent,
-                                   uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
+                                   FailureIsolationBase* customFdir, size_t cmdQueueSize)
-                                   object_id_t parent, FailureIsolationBase* customFdir,
-                                   size_t cmdQueueSize)
     : DeviceHandlerBase(setObjectId, deviceCommunication, cookie,
                         (customFdir == nullptr ? &childHandlerFdir : customFdir), cmdQueueSize),
-      parentId(parent),
+      parent(parent),
-      childHandlerFdir(setObjectId) {
+      childHandlerFdir(setObjectId) {}
-  this->setHkDestination(hkDestination);
-  this->setThermalStateRequestPoolIds(thermalStatePoolId, thermalRequestPoolId);
-}
 
 ChildHandlerBase::~ChildHandlerBase() {}
 
@@ -23,21 +18,5 @@ ReturnValue_t ChildHandlerBase::initialize() {
     return result;
   }
 
-  MessageQueueId_t parentQueue = 0;
+  return DeviceHandlerBase::connectModeTreeParent(parent);
-
-  if (parentId != objects::NO_OBJECT) {
-    SubsystemBase* parent = ObjectManager::instance()->get<SubsystemBase>(parentId);
-    if (parent == NULL) {
-      return returnvalue::FAILED;
-    }
-    parentQueue = parent->getCommandQueue();
-
-    parent->registerChild(getObjectId());
-  }
-
-  healthHelper.setParentQueue(parentQueue);
-
-  modeHelper.setParentQueue(parentQueue);
-
-  return returnvalue::OK;
 }

src/fsfw/devicehandlers/ChildHandlerBase.h

@@ -1,22 +1,23 @@
 #ifndef FSFW_DEVICEHANDLER_CHILDHANDLERBASE_H_
 #define FSFW_DEVICEHANDLER_CHILDHANDLERBASE_H_
 
+#include <fsfw/subsystem/HasModeTreeChildrenIF.h>
+
 #include "ChildHandlerFDIR.h"
 #include "DeviceHandlerBase.h"
 
 class ChildHandlerBase : public DeviceHandlerBase {
  public:
   ChildHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication, CookieIF* cookie,
-                   object_id_t hkDestination, uint32_t thermalStatePoolId,
+                   HasModeTreeChildrenIF& parent, FailureIsolationBase* customFdir = nullptr,
-                   uint32_t thermalRequestPoolId, object_id_t parent = objects::NO_OBJECT,
+                   size_t cmdQueueSize = 20);
-                   FailureIsolationBase* customFdir = nullptr, size_t cmdQueueSize = 20);
 
   virtual ~ChildHandlerBase();
 
   virtual ReturnValue_t initialize();
 
  protected:
-  const uint32_t parentId;
+  HasModeTreeChildrenIF& parent;
   ChildHandlerFDIR childHandlerFdir;
 };
 

src/fsfw/devicehandlers/DeviceHandlerBase.cpp

@@ -1,5 +1,6 @@
-#include "fsfw/devicehandlers/DeviceHandlerBase.h"
+#include "DeviceHandlerBase.h"
 
+#include "fsfw/datapool/PoolReadGuard.h"
 #include "fsfw/datapoollocal/LocalPoolVariable.h"
 #include "fsfw/devicehandlers/AcceptsDeviceResponsesIF.h"
 #include "fsfw/devicehandlers/DeviceTmReportingWrapper.h"
@@ -12,6 +13,7 @@
 #include "fsfw/serviceinterface/ServiceInterface.h"
 #include "fsfw/storagemanager/StorageManagerIF.h"
 #include "fsfw/subsystem/SubsystemBase.h"
+#include "fsfw/subsystem/helper.h"
 #include "fsfw/thermal/ThermalComponentIF.h"
 
 object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
@@ -132,14 +134,6 @@ ReturnValue_t DeviceHandlerBase::initialize() {
         new DeviceHandlerFailureIsolation(this->getObjectId(), defaultFdirParentId);
   }
 
-  if (this->parent != objects::NO_OBJECT) {
-    HasModesIF* modeIF = ObjectManager::instance()->get<HasModesIF>(this->parent);
-    HasHealthIF* healthIF = ObjectManager::instance()->get<HasHealthIF>(this->parent);
-    if (modeIF != nullptr and healthIF != nullptr) {
-      setParentQueue(modeIF->getCommandQueue());
-    }
-  }
-
   communicationInterface =
       ObjectManager::instance()->get<DeviceCommunicationIF>(deviceCommunicationId);
   if (communicationInterface == nullptr) {
@@ -368,6 +362,8 @@ void DeviceHandlerBase::doStateMachine() {
       if ((switchState == PowerSwitchIF::SWITCH_ON) || (switchState == NO_SWITCH)) {
         // NOTE: TransitionSourceMode and -SubMode are set by handleCommandedModeTransition
         childTransitionFailure = CHILD_TIMEOUT;
+        transitionSourceMode = _MODE_SHUT_DOWN;
+        transitionSourceSubMode = SUBMODE_NONE;
         setMode(_MODE_START_UP);
         callChildStatemachine();
       }
@@ -573,7 +569,6 @@ void DeviceHandlerBase::setTransition(Mode_t modeTo, Submode_t submodeTo) {
 }
 
 void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
-
   /**
    * handle transition from OFF to NORMAL by continuing towards normal when ON is reached
    */
@@ -1530,9 +1525,12 @@ DeviceCommandId_t DeviceHandlerBase::getPendingCommand() const {
 void DeviceHandlerBase::setNormalDatapoolEntriesInvalid() {
   for (const auto& reply : deviceReplyMap) {
     if (reply.second.dataSet != nullptr) {
+      PoolReadGuard pg(reply.second.dataSet);
+      if (pg.getReadResult() == returnvalue::OK) {
         reply.second.dataSet->setValidity(false, true);
       }
     }
+  }
 }
 
 void DeviceHandlerBase::printWarningOrError(sif::OutputTypes errorType, const char* functionName,
@@ -1587,19 +1585,13 @@ MessageQueueId_t DeviceHandlerBase::getCommanderQueueId(DeviceCommandId_t replyI
 
 void DeviceHandlerBase::setCustomFdir(FailureIsolationBase* fdir) { this->fdirInstance = fdir; }
 
-void DeviceHandlerBase::setParent(object_id_t parent) { this->parent = parent; }
-
 void DeviceHandlerBase::setPowerSwitcher(PowerSwitchIF* switcher) {
   this->powerSwitcher = switcher;
 }
 
-Mode_t DeviceHandlerBase::getMode() {
+Mode_t DeviceHandlerBase::getMode() { return mode; }
-  return mode;
-}
 
-Submode_t DeviceHandlerBase::getSubmode() {
+Submode_t DeviceHandlerBase::getSubmode() { return submode; }
-  return submode;
-}
 
 void DeviceHandlerBase::disableCommandsAndReplies() {
   for (auto& command : deviceCommandMap) {
@@ -1619,6 +1611,16 @@ void DeviceHandlerBase::disableCommandsAndReplies() {
   }
 }
 
+ReturnValue_t DeviceHandlerBase::connectModeTreeParent(HasModeTreeChildrenIF& parent) {
+  return modetree::connectModeTreeParent(parent, *this, &healthHelper, modeHelper);
+}
+
+const HasHealthIF* DeviceHandlerBase::getOptHealthIF() const { return this; }
+
+const HasModesIF& DeviceHandlerBase::getModeIF() const { return *this; }
+
+ModeTreeChildIF& DeviceHandlerBase::getModeTreeChildIF() { return *this; }
+
 ReturnValue_t DeviceHandlerBase::finishAction(bool success, DeviceCommandId_t action,
                                               ReturnValue_t result) {
   auto commandIter = deviceCommandMap.find(action);

src/fsfw/devicehandlers/DeviceHandlerBase.h

@@ -21,9 +21,9 @@
 #include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 #include "fsfw/serviceinterface/serviceInterfaceDefintions.h"
+#include "fsfw/subsystem/ModeTreeConnectionIF.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
 #include "fsfw/tasks/PeriodicTaskIF.h"
-#include "fsfw/util/dataWrapper.h"
 
 namespace Factory {
 void setStaticFrameworkObjectIds();
@@ -84,6 +84,8 @@ class DeviceHandlerBase : public DeviceHandlerIF,
                           public HasModesIF,
                           public HasHealthIF,
                           public HasActionsIF,
+                          public ModeTreeChildIF,
+                          public ModeTreeConnectionIF,
                           public ReceivesParameterMessagesIF,
                           public HasLocalDataPoolIF {
   friend void(Factory::setStaticFrameworkObjectIds)();
@@ -104,7 +106,6 @@ class DeviceHandlerBase : public DeviceHandlerIF,
                     FailureIsolationBase *fdirInstance = nullptr, size_t cmdQueueSize = 20);
 
   void setCustomFdir(FailureIsolationBase *fdir);
-  void setParent(object_id_t parent);
   void setPowerSwitcher(PowerSwitchIF *switcher);
 
   /**
@@ -169,6 +170,10 @@ class DeviceHandlerBase : public DeviceHandlerIF,
       lp_id_t thermalStatePoolId = DeviceHandlerIF::DEFAULT_THERMAL_STATE_POOL_ID,
       lp_id_t thermalRequestPoolId = DeviceHandlerIF::DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID,
       uint32_t thermalSetId = DeviceHandlerIF::DEFAULT_THERMAL_SET_ID);
+
+  ReturnValue_t connectModeTreeParent(HasModeTreeChildrenIF &parent) override;
+  ModeTreeChildIF &getModeTreeChildIF() override;
+
   /**
    * @brief   Helper function to ease device handler development.
    * This will instruct the transition to MODE_ON immediately
@@ -214,7 +219,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * @param counter Specifies which Action to perform
    * @return returnvalue::OK for successful execution
    */
-  virtual ReturnValue_t performOperation(uint8_t counter) override;
+  ReturnValue_t performOperation(uint8_t counter) override;
 
   /**
    * @brief  Initializes the device handler
@@ -224,14 +229,14 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * Calls fillCommandAndReplyMap().
    * @return
    */
-  virtual ReturnValue_t initialize() override;
+  ReturnValue_t initialize() override;
 
   /**
    * @brief   Intialization steps performed after all tasks have been created.
    *          This function will be called by the executing task.
    * @return
    */
-  virtual ReturnValue_t initializeAfterTaskCreation() override;
+  ReturnValue_t initializeAfterTaskCreation() override;
 
   /** Destructor. */
   virtual ~DeviceHandlerBase();
@@ -248,6 +253,8 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   virtual object_id_t getObjectId() const override;
 
   /**
+   * This is a helper method for classes which are parent nodes in the mode tree.
+   * It registers the passed queue as the destination for mode and health messages.
    * @param parentQueueId
    */
   virtual void setParentQueue(MessageQueueId_t parentQueueId);
@@ -1012,6 +1019,9 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    */
   LocalDataPoolManager *getHkManagerHandle() override;
 
+  const HasHealthIF *getOptHealthIF() const override;
+  const HasModesIF &getModeIF() const override;
+
   /**
    * Returns the delay cycle count of a reply.
    * A count != 0 indicates that the command is already executed.

src/fsfw/devicehandlers/DeviceTmReportingWrapper.h

@@ -4,7 +4,6 @@
 #include "fsfw/action/HasActionsIF.h"
 #include "fsfw/objectmanager/SystemObjectIF.h"
 #include "fsfw/serialize/SerializeIF.h"
-#include "fsfw/util/dataWrapper.h"
 
 class DeviceTmReportingWrapper : public SerializeIF {
  public:

src/fsfw/events/EventManager.cpp

@@ -24,6 +24,7 @@ EventManager::EventManager(object_id_t setObjectId)
 }
 
 EventManager::~EventManager() {
+  listenerList.clear();
   QueueFactory::instance()->deleteMessageQueue(eventReportQueue);
   MutexFactory::instance()->deleteMutex(mutex);
 }
@@ -73,9 +74,14 @@ 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);
 }

src/fsfw/events/EventManager.h

@@ -31,6 +31,7 @@ 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,

src/fsfw/events/EventManagerIF.h

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

src/fsfw/fdir/FailureIsolationBase.cpp

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

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

src/fsfw/globalfunctions/timevalOperations.cpp

@@ -1,8 +1,8 @@
 #include "fsfw/globalfunctions/timevalOperations.h"
 
 timeval& operator+=(timeval& lhs, const timeval& rhs) {
-  int64_t sum = lhs.tv_sec * 1000000. + lhs.tv_usec;
+  int64_t sum = static_cast<int64_t>(lhs.tv_sec) * 1000000. + lhs.tv_usec;
-  sum += rhs.tv_sec * 1000000. + rhs.tv_usec;
+  sum += static_cast<int64_t>(rhs.tv_sec) * 1000000. + rhs.tv_usec;
   lhs.tv_sec = sum / 1000000;
   lhs.tv_usec = sum - lhs.tv_sec * 1000000;
   return lhs;

src/fsfw/health/HealthHelper.cpp

@@ -5,7 +5,11 @@
 HealthHelper::HealthHelper(HasHealthIF* owner, object_id_t objectId)
     : objectId(objectId), owner(owner) {}
 
-HealthHelper::~HealthHelper() { healthTable->removeObject(objectId); }
+HealthHelper::~HealthHelper() {
+  if (healthTable != nullptr) {
+    healthTable->removeObject(objectId);
+  }
+}
 
 ReturnValue_t HealthHelper::handleHealthCommand(CommandMessage* message) {
   switch (message->getCommand()) {

src/fsfw/health/HealthTable.cpp

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

src/fsfw/health/HealthTable.h

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

src/fsfw/internalerror/InternalErrorReporter.cpp

@@ -10,13 +10,17 @@ InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId, uint32_t m
       poolManager(this, commandQueue),
       internalErrorSid(setObjectId, InternalErrorDataset::ERROR_SET_ID),
       internalErrorDataset(this) {
+  commandQueue = QueueFactory::instance()->createMessageQueue(messageQueueDepth);
   mutex = MutexFactory::instance()->createMutex();
   auto mqArgs = MqArgs(setObjectId, static_cast<void *>(this));
   commandQueue = QueueFactory::instance()->createMessageQueue(
       messageQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
 
-InternalErrorReporter::~InternalErrorReporter() { MutexFactory::instance()->deleteMutex(mutex); }
+InternalErrorReporter::~InternalErrorReporter() {
+  MutexFactory::instance()->deleteMutex(mutex);
+  QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
 
 void InternalErrorReporter::setDiagnosticPrintout(bool enable) {
   this->diagnosticPrintout = enable;

src/fsfw/modes/ModeMessage.cpp

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

src/fsfw/modes/ModeMessage.h

@@ -1,43 +1,42 @@
 #ifndef FSFW_MODES_MODEMESSAGE_H_
 #define FSFW_MODES_MODEMESSAGE_H_
 
-#include "../ipc/CommandMessage.h"
+#include "fsfw/ipc/CommandMessage.h"
 
 typedef uint32_t Mode_t;
 typedef uint8_t Submode_t;
 
 class ModeMessage {
- private:
-  ModeMessage();
-
  public:
   static const uint8_t MESSAGE_ID = messagetypes::MODE_COMMAND;
-  static const Command_t CMD_MODE_COMMAND =
+  //!> Command to set the specified Mode, replies are: REPLY_MODE_REPLY,
-      MAKE_COMMAND_ID(0x01);  //!> Command to set the specified Mode, replies are: REPLY_MODE_REPLY,
   //! REPLY_WRONG_MODE_REPLY, and REPLY_REJECTED; don't add any replies,
   //! as this will break the subsystem mode machine!!
-  static const Command_t CMD_MODE_COMMAND_FORCED = MAKE_COMMAND_ID(
+  static const Command_t CMD_MODE_COMMAND = MAKE_COMMAND_ID(0x01);
-      0xF1);  //!> Command to set the specified Mode, regardless of external control flag, replies
+  //!> Command to set the specified Mode, regardless of external control flag, replies
   //! are: REPLY_MODE_REPLY, REPLY_WRONG_MODE_REPLY, and REPLY_REJECTED; don't add any
   //! replies, as this will break the subsystem mode machine!!
-  static const Command_t REPLY_MODE_REPLY =
+  static const Command_t CMD_MODE_COMMAND_FORCED = MAKE_COMMAND_ID(0xF1);
-      MAKE_COMMAND_ID(0x02);  //!> Reply to a CMD_MODE_COMMAND or CMD_MODE_READ
+  //!> Reply to a CMD_MODE_COMMAND or CMD_MODE_READ
-  static const Command_t REPLY_MODE_INFO =
+  static const Command_t REPLY_MODE_REPLY = MAKE_COMMAND_ID(0x02);
-      MAKE_COMMAND_ID(0x03);  //!> Unrequested info about the current mode (used for composites to
+  //!> Unrequested info about the current mode (used for composites to
   //! inform their container of a changed mode)
-  static const Command_t REPLY_CANT_REACH_MODE = MAKE_COMMAND_ID(
+  static const Command_t REPLY_MODE_INFO = MAKE_COMMAND_ID(0x03);
-      0x04);  //!> Reply in case a mode command can't be executed. Par1: returnCode, Par2: 0
+  //!> Reply in case a mode command can't be executed. Par1: returnCode, Par2: 0
-  static const Command_t REPLY_WRONG_MODE_REPLY =
+  static const Command_t REPLY_CANT_REACH_MODE = MAKE_COMMAND_ID(0x04);
-      MAKE_COMMAND_ID(0x05);  //!> Reply to a CMD_MODE_COMMAND, indicating that a mode was commanded
+  //!> Reply to a CMD_MODE_COMMAND, indicating that a mode was commanded
   //! and a transition started but was aborted; the parameters contain
   //! the mode that was reached
-  static const Command_t CMD_MODE_READ = MAKE_COMMAND_ID(
+  static const Command_t REPLY_WRONG_MODE_REPLY = MAKE_COMMAND_ID(0x05);
-      0x06);  //!> Command to read the current mode and reply with a REPLY_MODE_REPLY
+  //!> Command to read the current mode and reply with a REPLY_MODE_REPLY
-  static const Command_t CMD_MODE_ANNOUNCE = MAKE_COMMAND_ID(
+  static const Command_t CMD_MODE_READ = MAKE_COMMAND_ID(0x06);
-      0x07);  //!> Command to trigger an ModeInfo Event. This command does NOT have a reply.
+  //!> Command to trigger an ModeInfo Event. This command does NOT have a reply.
-  static const Command_t CMD_MODE_ANNOUNCE_RECURSIVELY =
+  static const Command_t CMD_MODE_ANNOUNCE = MAKE_COMMAND_ID(0x07);
-      MAKE_COMMAND_ID(0x08);  //!> Command to trigger an ModeInfo Event and to send this command to
+  //!> Command to trigger an ModeInfo Event and to send this command to
   //! every child. This command does NOT have a reply.
+  static const Command_t CMD_MODE_ANNOUNCE_RECURSIVELY = MAKE_COMMAND_ID(0x08);
+
+  ModeMessage() = delete;
 
   static Mode_t getMode(const CommandMessage* message);
   static Submode_t getSubmode(const CommandMessage* message);
@@ -45,6 +44,9 @@ class ModeMessage {
 
   static void setModeMessage(CommandMessage* message, Command_t command, Mode_t mode,
                              Submode_t submode);
+  static void setCmdModeMessage(CommandMessage& message, Mode_t mode, Submode_t submode);
+  static void setModeAnnounceMessage(CommandMessage& message, bool recursive);
+  static void setModeReadMessage(CommandMessage& message);
   static void setCantReachMode(CommandMessage* message, ReturnValue_t reason);
   static void clear(CommandMessage* message);
 };

src/fsfw/objectmanager/ObjectManager.cpp

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

src/fsfw/objectmanager/ObjectManager.h

@@ -24,12 +24,17 @@ class ObjectManager : public ObjectManagerIF {
   using produce_function_t = void (*)(void* args);
 
   /**
-   * Returns the single instance of TaskFactory.
+   * Returns the single instance of ObjectManager.
    * 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>
@@ -66,6 +71,9 @@ class ObjectManager : public ObjectManagerIF {
    */
   std::map<object_id_t, SystemObjectIF*> objectList;
   static ObjectManager* objManagerInstance;
+  // used when the OM itself is deleted to modify behaviour of remove()
+  // to avoid iterator invalidation and double free
+  bool teardown = false;
 };
 
 // Documentation can be found in the class method declaration above

src/fsfw/osal/CMakeLists.txt

@@ -1,10 +1,13 @@
 # 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)
@@ -13,18 +16,20 @@ 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..")
+
   # 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.")
@@ -33,3 +38,5 @@ else()
 endif()
 
 add_subdirectory(common)
+
+configure_file(osal.h.in ${CMAKE_BINARY_DIR}/fsfw/osal/osal.h)

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,
-                             size_t receptionBufferSize, size_t ringBufferSize,
+                             TcpTmTcServer::TcpConfig cfg, size_t receptionBufferSize,
-                             std::string customTcpServerPort, ReceptionModes receptionMode)
+                             size_t ringBufferSize, ReceptionModes receptionMode)
     : SystemObject(objectId),
       tmtcBridgeId(tmtcTcpBridge),
       receptionMode(receptionMode),
-      tcpConfig(std::move(customTcpServerPort)),
+      tcpConfig(cfg),
       receptionBuffer(receptionBufferSize),
       ringBuffer(ringBufferSize, true) {}
 
@@ -91,6 +91,15 @@ 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) {
@@ -274,6 +283,8 @@ ReturnValue_t TcpTmTcServer::handleTmSending(socket_t connSocket, bool& tmSent)
     ConstStorageAccessor storeAccessor(storeId);
     ReturnValue_t result = tmStore->getData(storeId, storeAccessor);
     if (result != returnvalue::OK) {
+      // Invalid entry, pop FIFO
+      tmtcBridge->tmFifo->pop();
       return result;
     }
     if (wiretappingEnabled) {

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:
-    explicit TcpConfig(std::string tcpPort) : tcpPort(std::move(tcpPort)) {}
+    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) {}
 
     /**
      * Passed to the recv call
@@ -63,9 +63,25 @@ class TcpTmTcServer : public SystemObject, public TcpIpBase, public ExecutableOb
      */
     int tcpTmFlags = 0;
 
-    const std::string tcpPort;
+    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;
   };
 
+  enum class ReceptionModes { SPACE_PACKETS };
+
   static const std::string DEFAULT_SERVER_PORT;
 
   static constexpr size_t ETHERNET_MTU_SIZE = 1500;
@@ -80,10 +96,9 @@ 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(object_id_t objectId, object_id_t tmtcTcpBridge, TcpTmTcServer::TcpConfig cfg,
                 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;
 

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\n", queueCounter++);
+  sprintf(name, "/FSFW_MQ%u", queueCounter++);
 
   // Create a nonblocking queue if the name is available (the queue is read
   // and writable for the owner as well as the group)

src/fsfw/osal/osal.h.in

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

src/fsfw/power/PowerSwitcherComponent.cpp

@@ -3,7 +3,7 @@
 #include <fsfw/ipc/QueueFactory.h>
 #include <fsfw/power/PowerSwitchIF.h>
 
-PowerSwitcherComponent::PowerSwitcherComponent(object_id_t objectId, PowerSwitchIF *pwrSwitcher,
+PowerSwitcherComponent::PowerSwitcherComponent(object_id_t objectId, PowerSwitchIF* pwrSwitcher,
                                                power::Switch_t pwrSwitch)
     : SystemObject(objectId),
       switcher(pwrSwitcher, pwrSwitch),
@@ -54,7 +54,7 @@ ReturnValue_t PowerSwitcherComponent::initialize() {
 
 MessageQueueId_t PowerSwitcherComponent::getCommandQueue() const { return queue->getId(); }
 
-void PowerSwitcherComponent::getMode(Mode_t *mode, Submode_t *submode) {
+void PowerSwitcherComponent::getMode(Mode_t* mode, Submode_t* submode) {
   *mode = this->mode;
   *submode = this->submode;
 }
@@ -65,7 +65,7 @@ ReturnValue_t PowerSwitcherComponent::setHealth(HealthState health) {
 }
 
 ReturnValue_t PowerSwitcherComponent::checkModeCommand(Mode_t mode, Submode_t submode,
-                                                       uint32_t *msToReachTheMode) {
+                                                       uint32_t* msToReachTheMode) {
   *msToReachTheMode = 5000;
   if (mode != MODE_ON and mode != MODE_OFF) {
     return TRANS_NOT_ALLOWED;
@@ -105,3 +105,15 @@ void PowerSwitcherComponent::setMode(Mode_t newMode, Submode_t newSubmode) {
 }
 
 HasHealthIF::HealthState PowerSwitcherComponent::getHealth() { return healthHelper.getHealth(); }
+
+const HasHealthIF* PowerSwitcherComponent::getOptHealthIF() const { return this; }
+
+const HasModesIF& PowerSwitcherComponent::getModeIF() const { return *this; }
+
+ReturnValue_t PowerSwitcherComponent::connectModeTreeParent(HasModeTreeChildrenIF& parent) {
+  return parent.registerChild(*this);
+}
+
+object_id_t PowerSwitcherComponent::getObjectId() const { return SystemObject::getObjectId(); }
+
+ModeTreeChildIF& PowerSwitcherComponent::getModeTreeChildIF() { return *this; }

src/fsfw/power/PowerSwitcherComponent.h

@@ -8,6 +8,8 @@
 #include <fsfw/objectmanager/SystemObject.h>
 #include <fsfw/power/PowerSwitcher.h>
 #include <fsfw/power/definitions.h>
+#include <fsfw/subsystem/ModeTreeChildIF.h>
+#include <fsfw/subsystem/ModeTreeConnectionIF.h>
 #include <fsfw/tasks/ExecutableObjectIF.h>
 
 class PowerSwitchIF;
@@ -24,12 +26,17 @@ class PowerSwitchIF;
  */
 class PowerSwitcherComponent : public SystemObject,
                                public ExecutableObjectIF,
+                               public ModeTreeChildIF,
+                               public ModeTreeConnectionIF,
                                public HasModesIF,
                                public HasHealthIF {
  public:
   PowerSwitcherComponent(object_id_t objectId, PowerSwitchIF *pwrSwitcher,
                          power::Switch_t pwrSwitch);
 
+  ReturnValue_t connectModeTreeParent(HasModeTreeChildrenIF &parent) override;
+  ModeTreeChildIF &getModeTreeChildIF() override;
+
  private:
   MessageQueueIF *queue = nullptr;
   PowerSwitcher switcher;
@@ -56,6 +63,10 @@ class PowerSwitcherComponent : public SystemObject,
 
   ReturnValue_t setHealth(HealthState health) override;
   HasHealthIF::HealthState getHealth() override;
+
+  object_id_t getObjectId() const override;
+  const HasHealthIF *getOptHealthIF() const override;
+  const HasModesIF &getModeIF() const override;
 };
 
 #endif /* _FSFW_POWER_POWERSWITCHERCOMPONENT_H_ */

src/fsfw/pus/CMakeLists.txt

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

src/fsfw/pus/CService200ModeCommanding.cpp

@@ -20,6 +20,7 @@ ReturnValue_t CService200ModeCommanding::isValidSubservice(uint8_t subservice) {
     case (Subservice::COMMAND_MODE_COMMAND):
     case (Subservice::COMMAND_MODE_READ):
     case (Subservice::COMMAND_MODE_ANNCOUNCE):
+    case (Subservice::COMMAND_MODE_ANNOUNCE_RECURSIVELY):
       return returnvalue::OK;
     default:
       return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
@@ -53,6 +54,8 @@ 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) {
+  switch (subservice) {
+    case (Subservice::COMMAND_MODE_COMMAND): {
       ModePacket modeCommandPacket;
       ReturnValue_t result =
           modeCommandPacket.deSerialize(&tcData, &tcDataLen, SerializeIF::Endianness::BIG);
@@ -60,9 +63,27 @@ ReturnValue_t CService200ModeCommanding::prepareCommand(CommandMessage *message,
         return result;
       }
 
-  ModeMessage::setModeMessage(message, ModeMessage::CMD_MODE_COMMAND, modeCommandPacket.getMode(),
+      ModeMessage::setModeMessage(message, ModeMessage::CMD_MODE_COMMAND,
-                              modeCommandPacket.getSubmode());
+                                  modeCommandPacket.getMode(), modeCommandPacket.getSubmode());
-  return result;
+      return returnvalue::OK;
+    }
+    case (Subservice::COMMAND_MODE_ANNCOUNCE):
+    case (Subservice::COMMAND_MODE_ANNOUNCE_RECURSIVELY): {
+      bool recursive = true;
+      if (subservice == Subservice::COMMAND_MODE_ANNCOUNCE) {
+        recursive = false;
+      }
+      ModeMessage::setModeAnnounceMessage(*message, recursive);
+      return EXECUTION_COMPLETE;
+    }
+    case (Subservice::COMMAND_MODE_READ): {
+      ModeMessage::setModeReadMessage(*message);
+      return returnvalue::OK;
+    }
+    default: {
+      return CommandingServiceBase::INVALID_SUBSERVICE;
+    }
+  }
 }
 
 ReturnValue_t CService200ModeCommanding::handleReply(const CommandMessage *reply,
@@ -73,8 +94,10 @@ ReturnValue_t CService200ModeCommanding::handleReply(const CommandMessage *reply
   ReturnValue_t result = returnvalue::FAILED;
   switch (replyId) {
     case (ModeMessage::REPLY_MODE_REPLY): {
-      result = prepareModeReply(reply, objectId);
+      if (previousCommand != ModeMessage::CMD_MODE_COMMAND) {
-      break;
+        return prepareModeReply(reply, objectId);
+      }
+      return returnvalue::OK;
     }
     case (ModeMessage::REPLY_WRONG_MODE_REPLY): {
       result = prepareWrongModeReply(reply, objectId);

src/fsfw/pus/CService201HealthCommanding.cpp

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

src/fsfw/pus/CServiceHealthCommanding.cpp

@@ -0,0 +1,152 @@
+#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),
+      healthTable(args.table),
+      maxNumHealthInfoPerCycle(args.maxNumHealthInfoPerCycle) {}
+
+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;
+      while (true) {
+        ReturnValue_t result = iterateHealthTable(false);
+        if (result != returnvalue::OK) {
+          break;
+        }
+      }
+
+      return returnvalue::OK;
+    }
+    default: {
+      // Should never happen, subservice was already checked
+      result = returnvalue::FAILED;
+    }
+  }
+  return result;
+}
+
+ReturnValue_t CServiceHealthCommanding::handleReply(const CommandMessage *reply,
+                                                    Command_t previousCommand, uint32_t *state,
+                                                    CommandMessage *optionalNextCommand,
+                                                    object_id_t objectId, bool *isStep) {
+  Command_t replyId = reply->getCommand();
+  if (replyId == HealthMessage::REPLY_HEALTH_SET) {
+    return EXECUTION_COMPLETE;
+  } else if (replyId == CommandMessageIF::REPLY_REJECTED) {
+    return reply->getReplyRejectedReason();
+  }
+  return CommandingServiceBase::INVALID_REPLY;
+}
+
+void CServiceHealthCommanding::doPeriodicOperation() {
+  if (reportAllHealth) {
+    for (uint8_t i = 0; i < maxNumHealthInfoPerCycle; i++) {
+      ReturnValue_t result = iterateHealthTable(false);
+      if (result != returnvalue::OK) {
+        reportAllHealth = false;
+        break;
+      }
+    }
+  }
+}
+
+// Not used for now, health state already reported by event
+[[maybe_unused]] ReturnValue_t CServiceHealthCommanding::prepareHealthSetReply(
+    const CommandMessage *reply) {
+  auto health = static_cast<uint8_t>(HealthMessage::getHealth(reply));
+  auto oldHealth = static_cast<uint8_t>(HealthMessage::getOldHealth(reply));
+  HealthSetReply healthSetReply(health, oldHealth);
+  return sendTmPacket(Subservice::REPLY_HEALTH_SET, healthSetReply);
+}
+
+ReturnValue_t CServiceHealthCommanding::iterateHealthTable(bool reset) {
+  std::pair<object_id_t, HasHealthIF::HealthState> pair;
+
+  ReturnValue_t result = healthTable.iterate(&pair, reset);
+  if (result != returnvalue::OK) {
+    return result;
+  } else {
+    EventManagerIF::triggerEvent(pair.first, HasHealthIF::HEALTH_INFO, pair.second, pair.second);
+    return returnvalue::OK;
+  }
+}

src/fsfw/pus/CServiceHealthCommanding.h

@@ -1,8 +1,26 @@
 #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, HealthTable &healthTable,
+                   uint16_t maxNumHealthInfoPerCycle)
+      : objectId(objectId),
+        apid(apid),
+        table(healthTable),
+        maxNumHealthInfoPerCycle(maxNumHealthInfoPerCycle) {}
+  object_id_t objectId;
+  uint16_t apid;
+  HealthTable &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.
@@ -17,11 +35,10 @@
  * child class like this service
  *
  */
-class CService201HealthCommanding : public CommandingServiceBase {
+class CServiceHealthCommanding : public CommandingServiceBase {
  public:
-  CService201HealthCommanding(object_id_t objectId, uint16_t apid, uint8_t serviceId,
+  CServiceHealthCommanding(HealthServiceCfg args);
-                              uint8_t numParallelCommands = 4, uint16_t commandTimeoutSeconds = 60);
+  ~CServiceHealthCommanding() override = default;
-  ~CService201HealthCommanding() override = default;
 
  protected:
   /* CSB abstract function implementations */
@@ -37,7 +54,13 @@ class CService201HealthCommanding : public CommandingServiceBase {
                             CommandMessage *optionalNextCommand, object_id_t objectId,
                             bool *isStep) override;
 
+  void doPeriodicOperation() override;
+
  private:
+  HealthTable &healthTable;
+  uint16_t maxNumHealthInfoPerCycle = 0;
+  bool reportAllHealth = false;
+  ReturnValue_t iterateHealthTable(bool reset);
   static ReturnValue_t checkInterfaceAndAcquireMessageQueue(MessageQueueId_t *MessageQueueToSet,
                                                             const object_id_t *objectId);
 

src/fsfw/pus/Service11TelecommandScheduling.h

@@ -41,6 +41,8 @@ class Service11TelecommandScheduling final : public PusServiceBase {
   static constexpr ReturnValue_t INVALID_TIME_WINDOW = returnvalue::makeCode(CLASS_ID, 2);
   static constexpr ReturnValue_t TIMESHIFTING_NOT_POSSIBLE = returnvalue::makeCode(CLASS_ID, 3);
   static constexpr ReturnValue_t INVALID_RELATIVE_TIME = returnvalue::makeCode(CLASS_ID, 4);
+  static constexpr ReturnValue_t CONTAINED_TC_TOO_SMALL = returnvalue::makeCode(CLASS_ID, 5);
+  static constexpr ReturnValue_t CONTAINED_TC_CRC_MISSMATCH = returnvalue::makeCode(CLASS_ID, 6);
 
   static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_11;
 

src/fsfw/pus/Service11TelecommandScheduling.tpp

@@ -2,9 +2,11 @@
 
 #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"
 
 static constexpr auto DEF_END = SerializeIF::Endianness::BIG;
@@ -171,6 +173,14 @@ inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::doInsertActivi
     return returnvalue::FAILED;
   }
 
+  if (size < PusTcIF::MIN_SIZE) {
+    return CONTAINED_TC_TOO_SMALL;
+  }
+
+  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 ||

src/fsfw/pus/Service17Test.cpp

@@ -1,5 +1,7 @@
 #include "fsfw/pus/Service17Test.h"
 
+#include <fsfw/serialize/SerializeElement.h>
+
 #include "fsfw/FSFW.h"
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/objectmanager/SystemObject.h"
@@ -31,6 +33,15 @@ ReturnValue_t Service17Test::handleRequest(uint8_t subservice) {
       }
       return tmHelper.storeAndSendTmPacket();
     }
+    case Subservice::PING_WITH_DATA: {
+      SerializeElement<uint32_t> receivedDataLen = currentPacket.getUserDataLen();
+      ReturnValue_t result =
+          tmHelper.prepareTmPacket(Subservice::PING_WITH_DATA_REPORT_WITH_SIZE, receivedDataLen);
+      if (result != returnvalue::OK) {
+        return result;
+      }
+      return tmHelper.storeAndSendTmPacket();
+    }
     default:
       return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
   }

src/fsfw/pus/Service17Test.h

@@ -32,6 +32,9 @@ class Service17Test : public PusServiceBase {
     CONNECTION_TEST_REPORT = 2,
     //!  [EXPORT] : [COMMAND] Trigger test reply and test event
     EVENT_TRIGGER_TEST = 128,
+    PING_WITH_DATA = 129,
+    //! [EXPORT] : [COMMAND] Report which reports the sent user data size
+    PING_WITH_DATA_REPORT_WITH_SIZE = 130
   };
 
   explicit Service17Test(PsbParams params);

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: " << std::hex << objectId << std::dec << 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 << "Make sure it implements ReceivesParameterMessagesIF" << std::endl;
 #else
     sif::printError(
         "Service20ParameterManagement::checkInterfaceAndAcquire"
         "MessageQueue: Can't access object\n");
     sif::printError("Object ID: 0x%08x\n", *objectId);
-    sif::printError("Make sure it implements ReceivesParameterMessagesIF!\n");
+    sif::printError("Make sure it implements ReceivesParameterMessagesIF\n");
 #endif
 
     return CommandingServiceBase::INVALID_OBJECT;

src/fsfw/pus/Service5EventReporting.h

@@ -42,7 +42,7 @@
 class Service5EventReporting : public PusServiceBase {
  public:
   Service5EventReporting(PsbParams params, size_t maxNumberReportsPerCycle = 10,
-                         uint32_t messageQueueDepth = 10);
+                         uint32_t messageQueueDepth = 20);
   ~Service5EventReporting() override;
 
   /***

src/fsfw/pus/Service9TimeManagement.cpp

@@ -1,5 +1,7 @@
 #include "fsfw/pus/Service9TimeManagement.h"
 
+#include <cmath>
+
 #include "fsfw/events/EventManagerIF.h"
 #include "fsfw/pus/servicepackets/Service9Packets.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
@@ -15,9 +17,17 @@ 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;
   }
@@ -33,14 +43,14 @@ ReturnValue_t Service9TimeManagement::setTime() {
     return result;
   }
 
-  uint32_t formerUptime;
+  timeval time;
-  Clock::getUptime(&formerUptime);
+  Clock::getClock_timeval(&time);
   result = Clock::setClock(&timeToSet);
 
   if (result == returnvalue::OK) {
-    uint32_t newUptime;
+    timeval newTime;
-    Clock::getUptime(&newUptime);
+    Clock::getClock_timeval(&newTime);
-    triggerEvent(CLOCK_SET, newUptime, formerUptime);
+    triggerEvent(CLOCK_SET, time.tv_sec, newTime.tv_sec);
     return returnvalue::OK;
   } else {
     triggerEvent(CLOCK_SET_FAILURE, result, 0);

src/fsfw/pus/Service9TimeManagement.h

@@ -6,10 +6,13 @@
 class Service9TimeManagement : public PusServiceBase {
  public:
   static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_9;
-  //!< Clock has been set. P1: New Uptime. P2: Old Uptime
+
+  //!< 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(1, severity::LOW);
+  static constexpr Event CLOCK_SET_FAILURE = MAKE_EVENT(2, severity::LOW);
 
   static constexpr uint8_t CLASS_ID = CLASS_ID::PUS_SERVICE_9;
 
@@ -30,8 +33,9 @@ class Service9TimeManagement : public PusServiceBase {
   virtual ReturnValue_t setTime();
 
  private:
-  enum SUBSERVICE {
+  enum Subservice {
-    SET_TIME = 128  //!< [EXPORT] : [COMMAND] Time command in ASCII, CUC or CDS format
+    SET_TIME = 128,  //!< [EXPORT] : [COMMAND] Time command in ASCII, CUC or CDS format
+    DUMP_TIME = 129,
   };
 };
 

src/fsfw/pus/servicepackets/Service200Packets.h

@@ -1,9 +1,9 @@
 #ifndef FSFW_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
 #define FSFW_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
 
-#include "../../modes/ModeMessage.h"
+#include "fsfw/modes/ModeMessage.h"
-#include "../../serialize/SerialLinkedListAdapter.h"
+#include "fsfw/serialize/SerialLinkedListAdapter.h"
-#include "../../serialize/SerializeIF.h"
+#include "fsfw/serialize/SerializeIF.h"
 
 /**
  * @brief Subservice 1, 2, 3, 4, 5

src/fsfw/storagemanager/LocalPool.cpp

@@ -31,9 +31,8 @@ LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig& poolConfig,
 
 LocalPool::~LocalPool() = default;
 
-ReturnValue_t LocalPool::addData(store_address_t* storageId, const uint8_t* data, size_t size,
+ReturnValue_t LocalPool::addData(store_address_t* storageId, const uint8_t* data, size_t size) {
-                                 bool ignoreFault) {
+  ReturnValue_t status = reserveSpace(size, storageId);
-  ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
   if (status == returnvalue::OK) {
     write(*storageId, data, size);
   }
@@ -49,8 +48,8 @@ ReturnValue_t LocalPool::getData(store_address_t packetId, const uint8_t** packe
 }
 
 ReturnValue_t LocalPool::getFreeElement(store_address_t* storageId, const size_t size,
-                                        uint8_t** pData, bool ignoreFault) {
+                                        uint8_t** pData) {
-  ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
+  ReturnValue_t status = reserveSpace(size, storageId);
   if (status == returnvalue::OK) {
     *pData = &store[storageId->poolIndex][getRawPosition(*storageId)];
   } else {
@@ -167,7 +166,7 @@ void LocalPool::clearStore() {
   }
 }
 
-ReturnValue_t LocalPool::reserveSpace(size_t size, store_address_t* storeId, bool ignoreFault) {
+ReturnValue_t LocalPool::reserveSpace(size_t size, store_address_t* storeId) {
   ReturnValue_t status = getSubPoolIndex(size, &storeId->poolIndex);
   if (status != returnvalue::OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -318,27 +317,3 @@ bool LocalPool::hasDataAtId(store_address_t storeId) const {
   }
   return false;
 }
-
-ReturnValue_t LocalPool::getFreeElement(store_address_t* storeId, size_t size, uint8_t** pData) {
-  return StorageManagerIF::getFreeElement(storeId, size, pData);
-}
-
-ConstAccessorPair LocalPool::getData(store_address_t storeId) {
-  return StorageManagerIF::getData(storeId);
-}
-
-ReturnValue_t LocalPool::addData(store_address_t* storeId, const uint8_t* data, size_t size) {
-  return StorageManagerIF::addData(storeId, data, size);
-}
-
-ReturnValue_t LocalPool::getData(store_address_t storeId, ConstStorageAccessor& accessor) {
-  return StorageManagerIF::getData(storeId, accessor);
-}
-
-ReturnValue_t LocalPool::modifyData(store_address_t storeId, StorageAccessor& accessor) {
-  return StorageManagerIF::modifyData(storeId, accessor);
-}
-
-AccessorPair LocalPool::modifyData(store_address_t storeId) {
-  return StorageManagerIF::modifyData(storeId);
-}

src/fsfw/storagemanager/LocalPool.h

@@ -86,21 +86,13 @@ class LocalPool : public SystemObject, public StorageManagerIF {
   /**
    * Documentation: See StorageManagerIF.h
    */
-  ReturnValue_t addData(store_address_t* storeId, const uint8_t* data, size_t size,
-                        bool ignoreFault) override;
   ReturnValue_t addData(store_address_t* storeId, const uint8_t* data, size_t size) override;
 
   ReturnValue_t getFreeElement(store_address_t* storeId, size_t size, uint8_t** pData) override;
-  ReturnValue_t getFreeElement(store_address_t* storeId, size_t size, uint8_t** pData,
-                               bool ignoreFault) override;
 
-  ConstAccessorPair getData(store_address_t storeId) override;
-  ReturnValue_t getData(store_address_t storeId, ConstStorageAccessor& accessor) override;
   ReturnValue_t getData(store_address_t storeId, const uint8_t** packet_ptr, size_t* size) override;
 
-  AccessorPair modifyData(store_address_t storeId) override;
   ReturnValue_t modifyData(store_address_t storeId, uint8_t** packet_ptr, size_t* size) override;
-  ReturnValue_t modifyData(store_address_t storeId, StorageAccessor& accessor) override;
 
   ReturnValue_t deleteData(store_address_t storeId) override;
   ReturnValue_t deleteData(uint8_t* ptr, size_t size, store_address_t* storeId) override;
@@ -136,6 +128,12 @@ class LocalPool : public SystemObject, public StorageManagerIF {
   [[nodiscard]] max_subpools_t getNumberOfSubPools() const override;
   [[nodiscard]] bool hasDataAtId(store_address_t storeId) const override;
 
+  // Using functions provided by StorageManagerIF requires either a fully qualified path
+  // like for example localPool.StorageManagerIF::getFreeElement(...) or re-exporting
+  // the fully qualified path with the using directive.
+  using StorageManagerIF::getData;
+  using StorageManagerIF::modifyData;
+
  protected:
   /**
    * With this helper method, a free element of @c size is reserved.
@@ -144,7 +142,7 @@ class LocalPool : public SystemObject, public StorageManagerIF {
    * @return	- returnvalue::OK on success,
    * 			- the return codes of #getPoolIndex or #findEmpty otherwise.
    */
-  virtual ReturnValue_t reserveSpace(size_t size, store_address_t* address, bool ignoreFault);
+  virtual ReturnValue_t reserveSpace(size_t size, store_address_t* address);
 
  private:
   /**
@@ -188,6 +186,8 @@ class LocalPool : public SystemObject, public StorageManagerIF {
   std::vector<std::vector<size_type>> sizeLists =
       std::vector<std::vector<size_type>>(NUMBER_OF_SUBPOOLS);
 
+  bool ignoreFault = false;
+
   //! A variable to determine whether higher n pools are used if
   //! the store is full.
   bool spillsToHigherPools = false;

src/fsfw/storagemanager/PoolManager.cpp

@@ -9,10 +9,9 @@ PoolManager::PoolManager(object_id_t setObjectId, const LocalPoolConfig& localPo
 
 PoolManager::~PoolManager() { MutexFactory::instance()->deleteMutex(mutex); }
 
-ReturnValue_t PoolManager::reserveSpace(const size_t size, store_address_t* address,
+ReturnValue_t PoolManager::reserveSpace(const size_t size, store_address_t* address) {
-                                        bool ignoreFault) {
   MutexGuard mutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeoutMs);
-  ReturnValue_t status = LocalPool::reserveSpace(size, address, ignoreFault);
+  ReturnValue_t status = LocalPool::reserveSpace(size, address);
   return status;
 }
 

src/fsfw/storagemanager/PoolManager.h

@@ -57,7 +57,7 @@ class PoolManager : public LocalPool {
   //! Default mutex timeout value to prevent permanent blocking.
   uint32_t mutexTimeoutMs = 20;
 
-  ReturnValue_t reserveSpace(size_t size, store_address_t* address, bool ignoreFault) override;
+  ReturnValue_t reserveSpace(size_t size, store_address_t* address) override;
 
   /**
    * @brief	The mutex is created in the constructor and makes

src/fsfw/storagemanager/StorageManagerIF.h

@@ -55,7 +55,7 @@ class StorageManagerIF {
   /**
    * @brief This is the empty virtual destructor as required for C++ interfaces.
    */
-  ~StorageManagerIF() = default;
+  virtual ~StorageManagerIF() = default;
   /**
    * @brief	With addData, a free storage position is allocated and data
    * 			stored there.
@@ -66,12 +66,7 @@ class StorageManagerIF {
    * @return	Returns @returnvalue::OK if data was added.
    * 		@returnvalue::FAILED if data could not be added, storageId is unchanged then.
    */
-  virtual ReturnValue_t addData(store_address_t* storageId, const uint8_t* data, size_t size,
+  virtual ReturnValue_t addData(store_address_t* storageId, const uint8_t* data, size_t size) = 0;
-                                bool ignoreFault) = 0;
-
-  virtual ReturnValue_t addData(store_address_t* storageId, const uint8_t* data, size_t size) {
-    return addData(storageId, data, size, false);
-  }
 
   /**
    * @brief	With deleteData, the storageManager frees the memory region
@@ -186,12 +181,8 @@ class StorageManagerIF {
    * @return	Returns @returnvalue::OK if data was added.
    * 		@returnvalue::FAILED if data could not be added, storageId is unchanged then.
    */
-  virtual ReturnValue_t getFreeElement(store_address_t* storageId, size_t size, uint8_t** dataPtr,
+  virtual ReturnValue_t getFreeElement(store_address_t* storageId, size_t size,
-                                       bool ignoreFault) = 0;
+                                       uint8_t** dataPtr) = 0;
-
-  virtual ReturnValue_t getFreeElement(store_address_t* storageId, size_t size, uint8_t** dataPtr) {
-    return getFreeElement(storageId, size, dataPtr, false);
-  }
 
   [[nodiscard]] virtual bool hasDataAtId(store_address_t storeId) const = 0;
 

src/fsfw/subsystem/CMakeLists.txt

@@ -1,3 +1,4 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE Subsystem.cpp SubsystemBase.cpp)
+target_sources(${LIB_FSFW_NAME} PRIVATE Subsystem.cpp SubsystemBase.cpp
+                                        helper.cpp)
 
 add_subdirectory(modes)

src/fsfw/subsystem/HasModeTreeChildrenIF.h

@@ -0,0 +1,13 @@
+#ifndef FSFW_SUBSYSTEM_HASMODETREECHILDRENIF_H_
+#define FSFW_SUBSYSTEM_HASMODETREECHILDRENIF_H_
+
+#include "ModeTreeChildIF.h"
+
+class HasModeTreeChildrenIF {
+ public:
+  virtual ~HasModeTreeChildrenIF() = default;
+  virtual ReturnValue_t registerChild(const ModeTreeChildIF& child) = 0;
+  virtual MessageQueueId_t getCommandQueue() const = 0;
+};
+
+#endif  // FSFW_SUBSYSTEM_HASMODETREECHILDRENIF_H_

src/fsfw/subsystem/ModeTreeChildIF.h

@@ -0,0 +1,15 @@
+#ifndef FSFW_SUBSYSTEM_MODETREECHILDIF_H_
+#define FSFW_SUBSYSTEM_MODETREECHILDIF_H_
+
+#include <fsfw/health/HasHealthIF.h>
+#include <fsfw/modes/HasModesIF.h>
+
+class ModeTreeChildIF {
+ public:
+  virtual ~ModeTreeChildIF() = default;
+  virtual object_id_t getObjectId() const = 0;
+  virtual const HasHealthIF* getOptHealthIF() const = 0;
+  virtual const HasModesIF& getModeIF() const = 0;
+};
+
+#endif /* FSFW_SUBSYSTEM_MODETREECHILDIF_H_ */

src/fsfw/subsystem/ModeTreeConnectionIF.h

@@ -0,0 +1,13 @@
+#ifndef FSFW_SUBSYSTEM_MODES_MODETREECONNECTIONIF_H_
+#define FSFW_SUBSYSTEM_MODES_MODETREECONNECTIONIF_H_
+
+#include "fsfw/subsystem/HasModeTreeChildrenIF.h"
+
+class ModeTreeConnectionIF {
+ public:
+  virtual ~ModeTreeConnectionIF() = default;
+  virtual ReturnValue_t connectModeTreeParent(HasModeTreeChildrenIF& parent) = 0;
+  virtual ModeTreeChildIF& getModeTreeChildIF() = 0;
+};
+
+#endif /* FSFW_SRC_FSFW_SUBSYSTEM_MODES_MODETREECONNECTIONIF_H_ */

src/fsfw/subsystem/Subsystem.cpp

@@ -9,9 +9,9 @@
 #include "fsfw/serialize/SerialLinkedListAdapter.h"
 #include "fsfw/serialize/SerializeElement.h"
 
-Subsystem::Subsystem(object_id_t setObjectId, object_id_t parent, uint32_t maxNumberOfSequences,
+Subsystem::Subsystem(object_id_t setObjectId, uint32_t maxNumberOfSequences,
                      uint32_t maxNumberOfTables)
-    : SubsystemBase(setObjectId, parent, 0),
+    : SubsystemBase(setObjectId, 0),
       isInTransition(false),
       childrenChangedHealth(false),
       currentTargetTable(),
@@ -36,6 +36,13 @@ ReturnValue_t Subsystem::checkSequence(HybridIterator<ModeListEntry> iter,
 
   for (; iter.value != nullptr; ++iter) {
     if (!existsModeTable(iter->getTableId())) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      using namespace std;
+      sif::warning << "Subsystem::checkSequence: "
+                   << "Object " << setfill('0') << hex << "0x" << setw(8) << getObjectId()
+                   << setw(0) << ": Mode table for mode ID "
+                   << "0x" << setw(8) << iter->getTableId() << " does not exist" << dec << endl;
+#endif
       return TABLE_DOES_NOT_EXIST;
     } else {
       ReturnValue_t result = checkTable(getTable(iter->getTableId()));

src/fsfw/subsystem/Subsystem.h

@@ -66,8 +66,7 @@ class Subsystem : public SubsystemBase, public HasModeSequenceIF {
    * @param maxNumberOfSequences
    * @param maxNumberOfTables
    */
-  Subsystem(object_id_t setObjectId, object_id_t parent, uint32_t maxNumberOfSequences,
+  Subsystem(object_id_t setObjectId, uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables);
-            uint32_t maxNumberOfTables);
   virtual ~Subsystem();
 
   ReturnValue_t addSequence(SequenceEntry sequence);

src/fsfw/subsystem/SubsystemBase.cpp

@@ -1,16 +1,17 @@
 #include "fsfw/subsystem/SubsystemBase.h"
 
+#include "fsfw/FSFW.h"
 #include "fsfw/ipc/QueueFactory.h"
 #include "fsfw/objectmanager/ObjectManager.h"
-#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw/serviceinterface.h"
+#include "fsfw/subsystem/helper.h"
 
-SubsystemBase::SubsystemBase(object_id_t setObjectId, object_id_t parent, Mode_t initialMode,
+SubsystemBase::SubsystemBase(object_id_t setObjectId, Mode_t initialMode,
                              uint16_t commandQueueDepth)
     : SystemObject(setObjectId),
       mode(initialMode),
       healthHelper(this, setObjectId),
-      modeHelper(this),
+      modeHelper(this) {
-      parentId(parent) {
   auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
   commandQueue = QueueFactory::instance()->createMessageQueue(
       commandQueueDepth, CommandMessage::MAX_MESSAGE_SIZE, &mqArgs);
@@ -18,36 +19,6 @@ SubsystemBase::SubsystemBase(object_id_t setObjectId, object_id_t parent, Mode_t
 
 SubsystemBase::~SubsystemBase() { QueueFactory::instance()->deleteMessageQueue(commandQueue); }
 
-ReturnValue_t SubsystemBase::registerChild(object_id_t objectId) {
-  ChildInfo info;
-
-  HasModesIF* child = ObjectManager::instance()->get<HasModesIF>(objectId);
-  // This is a rather ugly hack to have the changedHealth info for all
-  // children available.
-  HasHealthIF* healthChild = ObjectManager::instance()->get<HasHealthIF>(objectId);
-  if (child == nullptr) {
-    if (healthChild == nullptr) {
-      return CHILD_DOESNT_HAVE_MODES;
-    } else {
-      info.commandQueue = healthChild->getCommandQueue();
-      info.mode = MODE_OFF;
-    }
-  } else {
-    // intentional to force an initial command during system startup
-    info.commandQueue = child->getCommandQueue();
-    info.mode = HasModesIF::MODE_UNDEFINED;
-  }
-
-  info.submode = SUBMODE_NONE;
-  info.healthChanged = false;
-
-  auto resultPair = childrenMap.emplace(objectId, info);
-  if (not resultPair.second) {
-    return COULD_NOT_INSERT_CHILD;
-  }
-  return returnvalue::OK;
-}
-
 ReturnValue_t SubsystemBase::checkStateAgainstTable(HybridIterator<ModeListEntry> tableIter,
                                                     Submode_t targetSubmode) {
   std::map<object_id_t, ChildInfo>::iterator childIter;
@@ -87,7 +58,8 @@ void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter, Submod
     if ((iter = childrenMap.find(object)) == childrenMap.end()) {
       // illegal table entry, should only happen due to misconfigured mode table
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::debug << std::hex << getObjectId() << ": invalid mode table entry" << std::endl;
+      sif::debug << std::hex << SystemObject::getObjectId() << ": invalid mode table entry"
+                 << std::endl;
 #endif
       continue;
     }
@@ -158,36 +130,15 @@ ReturnValue_t SubsystemBase::updateChildChangedHealth(MessageQueueId_t queue, bo
 MessageQueueId_t SubsystemBase::getCommandQueue() const { return commandQueue->getId(); }
 
 ReturnValue_t SubsystemBase::initialize() {
-  MessageQueueId_t parentQueue = MessageQueueIF::NO_QUEUE;
+  ReturnValue_t result = modeHelper.initialize();
-  ReturnValue_t result = SystemObject::initialize();
-
   if (result != returnvalue::OK) {
     return result;
   }
-
+  result = healthHelper.initialize();
-  if (parentId != objects::NO_OBJECT) {
-    SubsystemBase* parent = ObjectManager::instance()->get<SubsystemBase>(parentId);
-    if (parent == nullptr) {
-      return returnvalue::FAILED;
-    }
-    parentQueue = parent->getCommandQueue();
-
-    parent->registerChild(getObjectId());
-  }
-
-  result = healthHelper.initialize(parentQueue);
-
   if (result != returnvalue::OK) {
     return result;
   }
-
+  return SystemObject::initialize();
-  result = modeHelper.initialize(parentQueue);
-
-  if (result != returnvalue::OK) {
-    return result;
-  }
-
-  return returnvalue::OK;
 }
 
 ReturnValue_t SubsystemBase::performOperation(uint8_t opCode) {
@@ -240,8 +191,14 @@ ReturnValue_t SubsystemBase::handleModeReply(CommandMessage* message) {
 }
 
 ReturnValue_t SubsystemBase::checkTable(HybridIterator<ModeListEntry> tableIter) {
-  for (; tableIter.value != NULL; ++tableIter) {
+  for (; tableIter.value != nullptr; ++tableIter) {
     if (childrenMap.find(tableIter.value->getObject()) == childrenMap.end()) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      using namespace std;
+      sif::warning << "SubsystemBase::checkTable: Could not find object " << setfill('0') << hex
+                   << "0x" << setw(8) << tableIter.value->getObject() << " in object " << setw(8)
+                   << setw(0) << "0x" << setw(8) << SystemObject::getObjectId() << dec << std::endl;
+#endif
       return TABLE_CONTAINS_INVALID_OBJECT_ID;
     }
   }
@@ -326,4 +283,33 @@ ReturnValue_t SubsystemBase::setHealth(HealthState health) {
 
 HasHealthIF::HealthState SubsystemBase::getHealth() { return healthHelper.getHealth(); }
 
+ReturnValue_t SubsystemBase::connectModeTreeParent(HasModeTreeChildrenIF& parent) {
+  return modetree::connectModeTreeParent(parent, *this, &healthHelper, modeHelper);
+}
+
+object_id_t SubsystemBase::getObjectId() const { return SystemObject::getObjectId(); }
+
 void SubsystemBase::modeChanged() {}
+
+ReturnValue_t SubsystemBase::registerChild(const ModeTreeChildIF& child) {
+  ChildInfo info;
+
+  const HasModesIF& modeChild = child.getModeIF();
+  // intentional to force an initial command during system startup
+  info.commandQueue = modeChild.getCommandQueue();
+  info.mode = HasModesIF::MODE_UNDEFINED;
+  info.submode = SUBMODE_NONE;
+  info.healthChanged = false;
+
+  auto resultPair = childrenMap.emplace(child.getObjectId(), info);
+  if (not resultPair.second) {
+    return COULD_NOT_INSERT_CHILD;
+  }
+  return returnvalue::OK;
+}
+
+const HasHealthIF* SubsystemBase::getOptHealthIF() const { return this; }
+
+const HasModesIF& SubsystemBase::getModeIF() const { return *this; }
+
+ModeTreeChildIF& SubsystemBase::getModeTreeChildIF() { return *this; }

src/fsfw/subsystem/SubsystemBase.h

@@ -3,14 +3,16 @@
 
 #include <map>
 
-#include "../container/HybridIterator.h"
+#include "fsfw/container/HybridIterator.h"
-#include "../health/HasHealthIF.h"
+#include "fsfw/health/HasHealthIF.h"
-#include "../health/HealthHelper.h"
+#include "fsfw/health/HealthHelper.h"
-#include "../ipc/MessageQueueIF.h"
+#include "fsfw/ipc/MessageQueueIF.h"
-#include "../modes/HasModesIF.h"
+#include "fsfw/modes/HasModesIF.h"
-#include "../objectmanager/SystemObject.h"
+#include "fsfw/objectmanager/SystemObject.h"
-#include "../returnvalues/returnvalue.h"
+#include "fsfw/returnvalues/returnvalue.h"
-#include "../tasks/ExecutableObjectIF.h"
+#include "fsfw/subsystem/HasModeTreeChildrenIF.h"
+#include "fsfw/subsystem/ModeTreeConnectionIF.h"
+#include "fsfw/tasks/ExecutableObjectIF.h"
 #include "modes/HasModeSequenceIF.h"
 
 /**
@@ -27,6 +29,9 @@
 class SubsystemBase : public SystemObject,
                       public HasModesIF,
                       public HasHealthIF,
+                      public HasModeTreeChildrenIF,
+                      public ModeTreeConnectionIF,
+                      public ModeTreeChildIF,
                       public ExecutableObjectIF {
  public:
   static const uint8_t INTERFACE_ID = CLASS_ID::SUBSYSTEM_BASE;
@@ -36,12 +41,14 @@ class SubsystemBase : public SystemObject,
   static const ReturnValue_t COULD_NOT_INSERT_CHILD = MAKE_RETURN_CODE(0x04);
   static const ReturnValue_t TABLE_CONTAINS_INVALID_OBJECT_ID = MAKE_RETURN_CODE(0x05);
 
-  SubsystemBase(object_id_t setObjectId, object_id_t parent, Mode_t initialMode = 0,
+  SubsystemBase(object_id_t setObjectId, Mode_t initialMode = 0, uint16_t commandQueueDepth = 8);
-                uint16_t commandQueueDepth = 8);
   virtual ~SubsystemBase();
 
   virtual MessageQueueId_t getCommandQueue() const override;
 
+  ReturnValue_t connectModeTreeParent(HasModeTreeChildrenIF &parent) override;
+  ModeTreeChildIF &getModeTreeChildIF() override;
+
   /**
    * Function to register the child objects.
    * Performs a checks if the child does implement HasHealthIF and/or HasModesIF
@@ -53,15 +60,15 @@ class SubsystemBase : public SystemObject,
    *           CHILD_DOESNT_HAVE_MODES if Child is no HasHealthIF and no HasModesIF
    *           COULD_NOT_INSERT_CHILD If the Child could not be added to the ChildrenMap
    */
-  ReturnValue_t registerChild(object_id_t objectId);
+  ReturnValue_t registerChild(const ModeTreeChildIF &child) override;
 
-  virtual ReturnValue_t initialize() override;
+  ReturnValue_t initialize() override;
 
-  virtual ReturnValue_t performOperation(uint8_t opCode) override;
+  ReturnValue_t performOperation(uint8_t opCode) override;
 
-  virtual ReturnValue_t setHealth(HealthState health) override;
+  ReturnValue_t setHealth(HealthState health) override;
 
-  virtual HasHealthIF::HealthState getHealth() override;
+  HasHealthIF::HealthState getHealth() override;
 
  protected:
   struct ChildInfo {
@@ -88,8 +95,6 @@ class SubsystemBase : public SystemObject,
 
   ModeHelper modeHelper;
 
-  const object_id_t parentId;
-
   typedef std::map<object_id_t, ChildInfo> ChildrenMap;
   ChildrenMap childrenMap;
 
@@ -136,6 +141,10 @@ class SubsystemBase : public SystemObject,
 
   virtual void getMode(Mode_t *mode, Submode_t *submode) override;
 
+  object_id_t getObjectId() const override;
+  const HasHealthIF *getOptHealthIF() const override;
+  const HasModesIF &getModeIF() const override;
+
   virtual void setToExternalControl() override;
 
   virtual void announceMode(bool recursive) override;

src/fsfw/subsystem/helper.cpp

@@ -0,0 +1,15 @@
+#include "helper.h"
+
+ReturnValue_t modetree::connectModeTreeParent(HasModeTreeChildrenIF& parent,
+                                              const ModeTreeChildIF& child,
+                                              HealthHelper* healthHelper, ModeHelper& modeHelper) {
+  ReturnValue_t result = parent.registerChild(child);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  if (healthHelper != nullptr) {
+    healthHelper->setParentQueue(parent.getCommandQueue());
+  }
+  modeHelper.setParentQueue(parent.getCommandQueue());
+  return returnvalue::OK;
+}

src/fsfw/subsystem/helper.h

@@ -0,0 +1,14 @@
+#ifndef FSFW_SUBSYSTEM_HELPER_H_
+#define FSFW_SUBSYSTEM_HELPER_H_
+
+#include "HasModeTreeChildrenIF.h"
+#include "fsfw/health/HealthHelper.h"
+
+namespace modetree {
+
+ReturnValue_t connectModeTreeParent(HasModeTreeChildrenIF& parent, const ModeTreeChildIF& child,
+                                    HealthHelper* healthHelper, ModeHelper& modeHelper);
+
+}
+
+#endif /* FSFW_SRC_FSFW_SUBSYSTEM_HELPER_H_ */

src/fsfw/timemanager/TimeReaderIF.h

@@ -1,6 +1,7 @@
 #ifndef FSFW_TIMEMANAGER_TIMEREADERIF_H
 #define FSFW_TIMEMANAGER_TIMEREADERIF_H
 
+#include <cstdio>
 #include <cstdlib>
 
 #include "fsfw/platform.h"

src/fsfw/tmtcpacket/ccsds/SpacePacketReader.cpp

@@ -21,7 +21,7 @@ SpacePacketReader::~SpacePacketReader() = default;
 
 inline uint16_t SpacePacketReader::getPacketIdRaw() const { return ccsds::getPacketId(*spHeader); }
 
-const uint8_t* SpacePacketReader::getPacketData() { return packetDataField; }
+const uint8_t* SpacePacketReader::getPacketData() const { return packetDataField; }
 
 ReturnValue_t SpacePacketReader::setData(uint8_t* data, size_t maxSize_, void* args) {
   return setInternalFields(data, maxSize_);

src/fsfw/tmtcpacket/ccsds/SpacePacketReader.h

@@ -71,7 +71,7 @@ class SpacePacketReader : public SpacePacketIF,
   // Helper methods:
   [[nodiscard]] ReturnValue_t checkSize() const;
 
-  const uint8_t* getPacketData();
+  const uint8_t* getPacketData() const;
 
   ReturnValue_t setReadOnlyData(const uint8_t* data, size_t maxSize);
 

src/fsfw/tmtcpacket/pus/tc/PusTcCreator.cpp

@@ -100,5 +100,6 @@ ReturnValue_t PusTcCreator::setSerializableUserData(const SerializeIF &serializa
 void PusTcCreator::setup() {
   spCreator.setPacketType(ccsds::PacketType::TC);
   spCreator.setSecHeaderFlag();
+  spCreator.setSeqFlags(ccsds::SequenceFlags::UNSEGMENTED);
   updateSpLengthField();
 }

src/fsfw/tmtcpacket/pus/tm/PusTmCreator.cpp

@@ -119,6 +119,7 @@ void PusTmCreator::setup() {
   updateSpLengthField();
   spCreator.setPacketType(ccsds::PacketType::TM);
   spCreator.setSecHeaderFlag();
+  spCreator.setSeqFlags(ccsds::SequenceFlags::UNSEGMENTED);
 }
 
 void PusTmCreator::setMessageTypeCounter(uint16_t messageTypeCounter) {

src/fsfw/tmtcservices/PusServiceBase.cpp

@@ -27,8 +27,8 @@ ReturnValue_t PusServiceBase::performOperation(uint8_t opCode) {
   ReturnValue_t result = performService();
   if (result != returnvalue::OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "PusService " << psbParams.serviceId << ": performService returned with "
+    sif::error << "PusService " << static_cast<int>(psbParams.serviceId)
-               << static_cast<uint16_t>(result) << std::endl;
+               << ": performService returned with " << static_cast<uint16_t>(result) << std::endl;
 #endif
     return returnvalue::FAILED;
   }

src/fsfw/tmtcservices/SourceSequenceCounter.h

@@ -11,7 +11,7 @@ class SourceSequenceCounter {
   SourceSequenceCounter(uint16_t initialSequenceCount = 0) : sequenceCount(initialSequenceCount) {}
   void increment() { sequenceCount = (sequenceCount + 1) % (ccsds::LIMIT_SEQUENCE_COUNT); }
   void decrement() { sequenceCount = (sequenceCount - 1) % (ccsds::LIMIT_SEQUENCE_COUNT); }
-  uint16_t get() { return this->sequenceCount; }
+  uint16_t get() const { return this->sequenceCount; }
   void reset(uint16_t toValue = 0) { sequenceCount = toValue % (ccsds::LIMIT_SEQUENCE_COUNT); }
   SourceSequenceCounter& operator++(int) {
     this->increment();

src/fsfw/tmtcservices/TmTcBridge.cpp

@@ -145,13 +145,17 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 #endif /* FSFW_VERBOSE_LEVEL >= 3 */
 
     if (communicationLinkUp == false or packetSentCounter >= sentPacketsPerCycle) {
-      storeDownlinkData(&message);
+      ReturnValue_t result = storeDownlinkData(&message);
+      if (result != returnvalue::OK) {
+        tmStore->deleteData(message.getStorageId());
+      }
       continue;
     }
 
     result = tmStore->getData(message.getStorageId(), &data, &size);
     if (result != returnvalue::OK) {
       status = result;
+      tmStore->deleteData(message.getStorageId());
       continue;
     }
 
@@ -159,9 +163,9 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
     if (result != returnvalue::OK) {
       status = result;
     } else {
-      tmStore->deleteData(message.getStorageId());
       packetSentCounter++;
     }
+    tmStore->deleteData(message.getStorageId());
   }
   return status;
 }
@@ -183,7 +187,7 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage* message) {
           "TmTcBridge::storeDownlinkData: TM downlink max. number "
           "of stored packet IDs reached!\n");
 #endif
-      warningSwitch = true;
+      warningSwitch = false;
     }
     if (overwriteOld) {
       tmFifo->retrieve(&storeId);
@@ -226,6 +230,7 @@ ReturnValue_t TmTcBridge::handleStoredTm() {
     packetSentCounter++;
 
     if (tmFifo->empty()) {
+      warningSwitch = true;
       tmStored = false;
     }
     tmStore->deleteData(storeId);

src/fsfw/tmtcservices/TmTcBridge.h

@@ -65,15 +65,13 @@ class TmTcBridge : public AcceptsTelemetryIF,
   ReturnValue_t performOperation(uint8_t operationCode = 0) override;
 
   /** AcceptsTelemetryIF override */
-  MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel = 0) const override;
+  MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel) const override;
 
   /** AcceptsTelecommandsIF override */
   uint32_t getIdentifier() const override;
   MessageQueueId_t getRequestQueue() const override;
   const char* getName() const override;
 
-  bool warningSwitch = true;
-
  protected:
   const char* name = "";
 
@@ -93,6 +91,7 @@ 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;
 

src/fsfw/util/dataWrapper.h

@@ -1,72 +0,0 @@
-#ifndef FSFW_UTIL_DATAWRAPPER_H
-#define FSFW_UTIL_DATAWRAPPER_H
-
-#include <cstddef>
-#include <cstdint>
-#include <utility>
-
-#include "fsfw/serialize.h"
-
-namespace util {
-
-using BufPair = std::pair<const uint8_t*, size_t>;
-
-struct RawData {
-  RawData() = default;
-  const uint8_t* data = nullptr;
-  size_t len = 0;
-};
-
-enum DataTypes { NONE, RAW, SERIALIZABLE };
-
-union DataUnion {
-  RawData raw{};
-  SerializeIF* serializable;
-};
-
-struct DataWrapper {
-  DataWrapper() = default;
-
-  DataWrapper(const uint8_t* data, size_t size) : type(DataTypes::RAW) { setRawData({data, size}); }
-
-  explicit DataWrapper(BufPair raw) : type(DataTypes::RAW) { setRawData(raw); }
-
-  explicit DataWrapper(SerializeIF& serializable) : type(DataTypes::SERIALIZABLE) {
-    setSerializable(serializable);
-  }
-
-  DataTypes type = DataTypes::NONE;
-  DataUnion dataUnion;
-
-  [[nodiscard]] size_t getLength() const {
-    if (type == DataTypes::RAW) {
-      return dataUnion.raw.len;
-    } else if (type == DataTypes::SERIALIZABLE and dataUnion.serializable != nullptr) {
-      return dataUnion.serializable->getSerializedSize();
-    }
-    return 0;
-  }
-
-  [[nodiscard]] bool isNull() const {
-    if ((type == DataTypes::NONE) or (type == DataTypes::RAW and dataUnion.raw.data == nullptr) or
-        (type == DataTypes::SERIALIZABLE and dataUnion.serializable == nullptr)) {
-      return true;
-    }
-    return false;
-  }
-
-  void setRawData(BufPair bufPair) {
-    type = DataTypes::RAW;
-    dataUnion.raw.data = bufPair.first;
-    dataUnion.raw.len = bufPair.second;
-  }
-
-  void setSerializable(SerializeIF& serializable) {
-    type = DataTypes::SERIALIZABLE;
-    dataUnion.serializable = &serializable;
-  }
-};
-
-}  // namespace util
-
-#endif  // FSFW_UTIL_DATAWRAPPER_H

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[3] << 8)) >> 8;
+  int32_t fieldStrengthRawZ = ((packet[7] << 24) | (packet[8] << 16) | (packet[9] << 8)) >> 8;
 
   // Now scale to physical value in microtesla
   float fieldStrengthX = fieldStrengthRawX * scaleFactorX;
-  float fieldStrengthY = fieldStrengthRawY * scaleFactorX;
+  float fieldStrengthY = fieldStrengthRawY * scaleFactorY;
-  float fieldStrengthZ = fieldStrengthRawZ * scaleFactorX;
+  float fieldStrengthZ = fieldStrengthRawZ * scaleFactorZ;
 
   if (periodicPrintout) {
     if (debugDivider.checkAndIncrement()) {

src/fsfw_hal/linux/CMakeLists.txt

@@ -5,11 +5,14 @@ endif()
 target_sources(${LIB_FSFW_NAME} PRIVATE UnixFileGuard.cpp CommandExecutor.cpp
                                         utility.cpp)
 
-if(FSFW_HAL_LINUX_ADD_PERIPHERAL_DRIVERS)
+if(FSFW_HAL_LINUX_ADD_LIBGPIOD)
-  if(FSFW_HAL_LINUX_ADD_LIBGPIOD)
   add_subdirectory(gpio)
-  endif()
+endif()
-  add_subdirectory(uart)
+if(FSFW_HAL_LINUX_ADD_SERIAL_DRIVERS)
+  add_subdirectory(serial)
+endif()
+
+if(FSFW_HAL_LINUX_ADD_PERIPHERAL_DRIVERS)
   # Adding those does not really make sense on Apple systems which are generally
   # host systems. It won't even compile as the headers are missing
   if(NOT APPLE)

src/fsfw_hal/linux/i2c/I2cComIF.cpp

@@ -109,14 +109,17 @@ ReturnValue_t I2cComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData, s
   }
 
   if (write(fd, sendData, sendLen) != static_cast<int>(sendLen)) {
+    i2cCookie->errorCounter++;
+    if (i2cCookie->errorCounter < 3) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::error << "I2cComIF::sendMessage: Failed to send data to I2C "
                     "device with error code "
                  << errno << ". Error description: " << strerror(errno) << std::endl;
 #endif
+    }
     return returnvalue::FAILED;
   }
-
+  i2cCookie->errorCounter = 0;
 #if FSFW_HAL_I2C_WIRETAPPING == 1
   sif::info << "Sent I2C data to bus " << deviceFile << ":" << std::endl;
   arrayprinter::print(sendData, sendLen);
@@ -180,10 +183,6 @@ 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;
   }

src/fsfw_hal/linux/i2c/I2cCookie.h

@@ -27,6 +27,8 @@ class I2cCookie : public CookieIF {
   size_t getMaxReplyLen() const;
   std::string getDeviceFile() const;
 
+  uint8_t errorCounter = 0;
+
  private:
   address_t i2cAddress = 0;
   size_t maxReplyLen = 0;

src/fsfw_hal/linux/serial/CMakeLists.txt

@@ -0,0 +1,2 @@
+target_sources(${LIB_FSFW_NAME} PUBLIC SerialComIF.cpp SerialCookie.cpp
+                                       helper.cpp)

src/fsfw_hal/linux/serial/SerialComIF.cpp

@@ -1,7 +1,8 @@
-#include "UartComIF.h"
+#include "SerialComIF.h"
 
 #include <errno.h>
 #include <fcntl.h>
+#include <fsfw_hal/linux/serial/SerialComIF.h>
 #include <termios.h>
 #include <unistd.h>
 
@@ -11,18 +12,18 @@
 #include "fsfw/serviceinterface.h"
 #include "fsfw_hal/linux/utility.h"
 
-UartComIF::UartComIF(object_id_t objectId) : SystemObject(objectId) {}
+SerialComIF::SerialComIF(object_id_t objectId) : SystemObject(objectId) {}
 
-UartComIF::~UartComIF() {}
+SerialComIF::~SerialComIF() {}
 
-ReturnValue_t UartComIF::initializeInterface(CookieIF* cookie) {
+ReturnValue_t SerialComIF::initializeInterface(CookieIF* cookie) {
   std::string deviceFile;
 
   if (cookie == nullptr) {
     return NULLPOINTER;
   }
 
-  UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
+  SerialCookie* uartCookie = dynamic_cast<SerialCookie*>(cookie);
   if (uartCookie == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "UartComIF::initializeInterface: Invalid UART Cookie!" << std::endl;
@@ -59,7 +60,7 @@ ReturnValue_t UartComIF::initializeInterface(CookieIF* cookie) {
   return returnvalue::OK;
 }
 
-int UartComIF::configureUartPort(UartCookie* uartCookie) {
+int SerialComIF::configureUartPort(SerialCookie* uartCookie) {
   struct termios options = {};
 
   std::string deviceFile = uartCookie->getDeviceFile();
@@ -88,7 +89,7 @@ int UartComIF::configureUartPort(UartCookie* uartCookie) {
     return fd;
   }
 
-  setParityOptions(&options, uartCookie);
+  uart::setParity(options, uartCookie->getParity());
   setStopBitOptions(&options, uartCookie);
   setDatasizeOptions(&options, uartCookie);
   setFixedOptions(&options);
@@ -114,24 +115,7 @@ int UartComIF::configureUartPort(UartCookie* uartCookie) {
   return fd;
 }
 
-void UartComIF::setParityOptions(struct termios* options, UartCookie* uartCookie) {
+void SerialComIF::setStopBitOptions(struct termios* options, SerialCookie* uartCookie) {
-  /* Clear parity bit */
-  options->c_cflag &= ~PARENB;
-  switch (uartCookie->getParity()) {
-    case Parity::EVEN:
-      options->c_cflag |= PARENB;
-      options->c_cflag &= ~PARODD;
-      break;
-    case Parity::ODD:
-      options->c_cflag |= PARENB;
-      options->c_cflag |= PARODD;
-      break;
-    default:
-      break;
-  }
-}
-
-void UartComIF::setStopBitOptions(struct termios* options, UartCookie* uartCookie) {
   /* Clear stop field. Sets stop bit to one bit */
   options->c_cflag &= ~CSTOPB;
   switch (uartCookie->getStopBits()) {
@@ -143,7 +127,7 @@ void UartComIF::setStopBitOptions(struct termios* options, UartCookie* uartCooki
   }
 }
 
-void UartComIF::setDatasizeOptions(struct termios* options, UartCookie* uartCookie) {
+void SerialComIF::setDatasizeOptions(struct termios* options, SerialCookie* uartCookie) {
   /* Clear size bits */
   options->c_cflag &= ~CSIZE;
   switch (uartCookie->getBitsPerWord()) {
@@ -167,7 +151,7 @@ void UartComIF::setDatasizeOptions(struct termios* options, UartCookie* uartCook
   }
 }
 
-void UartComIF::setFixedOptions(struct termios* options) {
+void SerialComIF::setFixedOptions(struct termios* options) {
   /* Disable RTS/CTS hardware flow control */
   options->c_cflag &= ~CRTSCTS;
   /* Turn on READ & ignore ctrl lines (CLOCAL = 1) */
@@ -190,7 +174,7 @@ void UartComIF::setFixedOptions(struct termios* options) {
   options->c_oflag &= ~ONLCR;
 }
 
-ReturnValue_t UartComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData, size_t sendLen) {
+ReturnValue_t SerialComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData, size_t sendLen) {
   int fd = 0;
   std::string deviceFile;
 
@@ -205,7 +189,7 @@ ReturnValue_t UartComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData,
     return returnvalue::FAILED;
   }
 
-  UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
+  SerialCookie* uartCookie = dynamic_cast<SerialCookie*>(cookie);
   if (uartCookie == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "UartComIF::sendMessasge: Invalid UART Cookie!" << std::endl;
@@ -236,12 +220,12 @@ ReturnValue_t UartComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData,
   return returnvalue::OK;
 }
 
-ReturnValue_t UartComIF::getSendSuccess(CookieIF* cookie) { return returnvalue::OK; }
+ReturnValue_t SerialComIF::getSendSuccess(CookieIF* cookie) { return returnvalue::OK; }
 
-ReturnValue_t UartComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLen) {
+ReturnValue_t SerialComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLen) {
   std::string deviceFile;
 
-  UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
+  SerialCookie* uartCookie = dynamic_cast<SerialCookie*>(cookie);
   if (uartCookie == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::debug << "UartComIF::requestReceiveMessage: Invalid Uart Cookie!" << std::endl;
@@ -274,8 +258,8 @@ ReturnValue_t UartComIF::requestReceiveMessage(CookieIF* cookie, size_t requestL
   }
 }
 
-ReturnValue_t UartComIF::handleCanonicalRead(UartCookie& uartCookie, UartDeviceMap::iterator& iter,
+ReturnValue_t SerialComIF::handleCanonicalRead(SerialCookie& uartCookie,
-                                             size_t requestLen) {
+                                               UartDeviceMap::iterator& iter, size_t requestLen) {
   ReturnValue_t result = returnvalue::OK;
   uint8_t maxReadCycles = uartCookie.getReadCycles();
   uint8_t currentReadCycles = 0;
@@ -332,8 +316,9 @@ ReturnValue_t UartComIF::handleCanonicalRead(UartCookie& uartCookie, UartDeviceM
   return result;
 }
 
-ReturnValue_t UartComIF::handleNoncanonicalRead(UartCookie& uartCookie,
+ReturnValue_t SerialComIF::handleNoncanonicalRead(SerialCookie& uartCookie,
-                                                UartDeviceMap::iterator& iter, size_t requestLen) {
+                                                  UartDeviceMap::iterator& iter,
+                                                  size_t requestLen) {
   int fd = iter->second.fileDescriptor;
   auto bufferPtr = iter->second.replyBuffer.data();
   // Size check to prevent buffer overflow
@@ -366,10 +351,10 @@ ReturnValue_t UartComIF::handleNoncanonicalRead(UartCookie& uartCookie,
   return returnvalue::OK;
 }
 
-ReturnValue_t UartComIF::readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) {
+ReturnValue_t SerialComIF::readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) {
   std::string deviceFile;
 
-  UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
+  SerialCookie* uartCookie = dynamic_cast<SerialCookie*>(cookie);
   if (uartCookie == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::debug << "UartComIF::readReceivedMessage: Invalid uart cookie!" << std::endl;
@@ -396,9 +381,9 @@ ReturnValue_t UartComIF::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
   return returnvalue::OK;
 }
 
-ReturnValue_t UartComIF::flushUartRxBuffer(CookieIF* cookie) {
+ReturnValue_t SerialComIF::flushUartRxBuffer(CookieIF* cookie) {
   std::string deviceFile;
-  UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
+  SerialCookie* uartCookie = dynamic_cast<SerialCookie*>(cookie);
   if (uartCookie == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "UartComIF::flushUartRxBuffer: Invalid uart cookie!" << std::endl;
@@ -415,9 +400,9 @@ ReturnValue_t UartComIF::flushUartRxBuffer(CookieIF* cookie) {
   return returnvalue::FAILED;
 }
 
-ReturnValue_t UartComIF::flushUartTxBuffer(CookieIF* cookie) {
+ReturnValue_t SerialComIF::flushUartTxBuffer(CookieIF* cookie) {
   std::string deviceFile;
-  UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
+  SerialCookie* uartCookie = dynamic_cast<SerialCookie*>(cookie);
   if (uartCookie == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "UartComIF::flushUartTxBuffer: Invalid uart cookie!" << std::endl;
@@ -434,9 +419,9 @@ ReturnValue_t UartComIF::flushUartTxBuffer(CookieIF* cookie) {
   return returnvalue::FAILED;
 }
 
-ReturnValue_t UartComIF::flushUartTxAndRxBuf(CookieIF* cookie) {
+ReturnValue_t SerialComIF::flushUartTxAndRxBuf(CookieIF* cookie) {
   std::string deviceFile;
-  UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
+  SerialCookie* uartCookie = dynamic_cast<SerialCookie*>(cookie);
   if (uartCookie == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "UartComIF::flushUartTxAndRxBuf: Invalid uart cookie!" << std::endl;

src/fsfw_hal/linux/serial/SerialComIF.h

@@ -3,13 +3,12 @@
 
 #include <fsfw/devicehandlers/DeviceCommunicationIF.h>
 #include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw_hal/linux/serial/SerialCookie.h>
+#include <fsfw_hal/linux/serial/helper.h>
 
 #include <unordered_map>
 #include <vector>
 
-#include "UartCookie.h"
-#include "helper.h"
-
 /**
  * @brief 	This is the communication interface to access serial ports on linux based operating
  *          systems.
@@ -19,7 +18,7 @@
  *
  * @author 	J. Meier
  */
-class UartComIF : public DeviceCommunicationIF, public SystemObject {
+class SerialComIF : public DeviceCommunicationIF, public SystemObject {
  public:
   static constexpr uint8_t uartRetvalId = CLASS_ID::HAL_UART;
 
@@ -27,9 +26,9 @@ class UartComIF : public DeviceCommunicationIF, public SystemObject {
   static constexpr ReturnValue_t UART_READ_SIZE_MISSMATCH = returnvalue::makeCode(uartRetvalId, 2);
   static constexpr ReturnValue_t UART_RX_BUFFER_TOO_SMALL = returnvalue::makeCode(uartRetvalId, 3);
 
-  UartComIF(object_id_t objectId);
+  SerialComIF(object_id_t objectId);
 
-  virtual ~UartComIF();
+  virtual ~SerialComIF();
 
   ReturnValue_t initializeInterface(CookieIF* cookie) override;
   ReturnValue_t sendMessage(CookieIF* cookie, const uint8_t* sendData, size_t sendLen) override;
@@ -76,20 +75,9 @@ class UartComIF : public DeviceCommunicationIF, public SystemObject {
    *                      uart device file, baudrate, parity, stopbits etc.
    * @return  The file descriptor of the configured uart.
    */
-  int configureUartPort(UartCookie* uartCookie);
+  int configureUartPort(SerialCookie* uartCookie);
 
-  /**
+  void setStopBitOptions(struct termios* options, SerialCookie* uartCookie);
-   * @brief   This function adds the parity settings to the termios options struct.
-   *
-   * @param options   Pointer to termios options struct which will be modified to enable or disable
-   *                  parity checking.
-   * @param uartCookie    Pointer to uart cookie containing the information about the desired
-   *                      parity settings.
-   *
-   */
-  void setParityOptions(struct termios* options, UartCookie* uartCookie);
-
-  void setStopBitOptions(struct termios* options, UartCookie* uartCookie);
 
   /**
    * @brief   This function sets options which are not configurable by the uartCookie.
@@ -99,11 +87,11 @@ class UartComIF : public DeviceCommunicationIF, public SystemObject {
   /**
    * @brief   With this function the datasize settings are added to the termios options struct.
    */
-  void setDatasizeOptions(struct termios* options, UartCookie* uartCookie);
+  void setDatasizeOptions(struct termios* options, SerialCookie* uartCookie);
 
-  ReturnValue_t handleCanonicalRead(UartCookie& uartCookie, UartDeviceMap::iterator& iter,
+  ReturnValue_t handleCanonicalRead(SerialCookie& uartCookie, UartDeviceMap::iterator& iter,
                                     size_t requestLen);
-  ReturnValue_t handleNoncanonicalRead(UartCookie& uartCookie, UartDeviceMap::iterator& iter,
+  ReturnValue_t handleNoncanonicalRead(SerialCookie& uartCookie, UartDeviceMap::iterator& iter,
                                        size_t requestLen);
 };
 

src/fsfw_hal/linux/serial/SerialCookie.cpp

@@ -0,0 +1,51 @@
+#include "SerialCookie.h"
+
+#include <fsfw/serviceinterface.h>
+
+SerialCookie::SerialCookie(object_id_t handlerId, std::string deviceFile, UartBaudRate baudrate,
+                           size_t maxReplyLen, UartModes uartMode)
+    : handlerId(handlerId),
+      deviceFile(deviceFile),
+      uartMode(uartMode),
+      baudrate(baudrate),
+      maxReplyLen(maxReplyLen) {}
+
+SerialCookie::~SerialCookie() {}
+
+UartBaudRate SerialCookie::getBaudrate() const { return baudrate; }
+
+size_t SerialCookie::getMaxReplyLen() const { return maxReplyLen; }
+
+std::string SerialCookie::getDeviceFile() const { return deviceFile; }
+
+void SerialCookie::setParityOdd() { parity = Parity::ODD; }
+
+void SerialCookie::setParityEven() { parity = Parity::EVEN; }
+
+Parity SerialCookie::getParity() const { return parity; }
+
+void SerialCookie::setBitsPerWord(BitsPerWord bitsPerWord_) { bitsPerWord = bitsPerWord_; }
+
+BitsPerWord SerialCookie::getBitsPerWord() const { return bitsPerWord; }
+
+StopBits SerialCookie::getStopBits() const { return stopBits; }
+
+void SerialCookie::setTwoStopBits() { stopBits = StopBits::TWO_STOP_BITS; }
+
+void SerialCookie::setOneStopBit() { stopBits = StopBits::ONE_STOP_BIT; }
+
+UartModes SerialCookie::getUartMode() const { return uartMode; }
+
+void SerialCookie::setReadCycles(uint8_t readCycles) { this->readCycles = readCycles; }
+
+void SerialCookie::setToFlushInput(bool enable) { this->flushInput = enable; }
+
+uint8_t SerialCookie::getReadCycles() const { return readCycles; }
+
+bool SerialCookie::getInputShouldBeFlushed() { return this->flushInput; }
+
+object_id_t SerialCookie::getHandlerId() const { return this->handlerId; }
+
+void SerialCookie::setNoFixedSizeReply() { replySizeFixed = false; }
+
+bool SerialCookie::isReplySizeFixed() { return replySizeFixed; }

src/fsfw_hal/linux/serial/SerialCookie.h

@@ -3,11 +3,10 @@
 
 #include <fsfw/devicehandlers/CookieIF.h>
 #include <fsfw/objectmanager/SystemObjectIF.h>
+#include <fsfw_hal/linux/serial/helper.h>
 
 #include <string>
 
-#include "helper.h"
-
 /**
  * @brief   Cookie for the UartComIF. There are many options available to configure the UART driver.
  *          The constructor only requests for common options like the baudrate. Other options can
@@ -15,7 +14,7 @@
  *
  * @author 	J. Meier
  */
-class UartCookie : public CookieIF {
+class SerialCookie : public CookieIF {
  public:
   /**
    * @brief	Constructor for the uart cookie.
@@ -30,10 +29,10 @@ class UartCookie : public CookieIF {
    *                        8 databits (number of bits transfered with one uart frame)
    *                        One stop bit
    */
-  UartCookie(object_id_t handlerId, std::string deviceFile, UartBaudRate baudrate,
+  SerialCookie(object_id_t handlerId, std::string deviceFile, UartBaudRate baudrate,
                size_t maxReplyLen, UartModes uartMode = UartModes::NON_CANONICAL);
 
-  virtual ~UartCookie();
+  virtual ~SerialCookie();
 
   UartBaudRate getBaudrate() const;
   size_t getMaxReplyLen() const;

src/fsfw_hal/linux/serial/helper.cpp

@@ -0,0 +1,163 @@
+#include <fsfw_hal/linux/serial/helper.h>
+#include <sys/ioctl.h>
+
+#include "fsfw/serviceinterface.h"
+
+void uart::setMode(struct termios& options, UartModes mode) {
+  if (mode == UartModes::NON_CANONICAL) {
+    /* Disable canonical mode */
+    options.c_lflag &= ~ICANON;
+  } else if (mode == UartModes::CANONICAL) {
+    options.c_lflag |= ICANON;
+  }
+}
+
+void uart::setBaudrate(struct termios& options, UartBaudRate baud) {
+  switch (baud) {
+    case UartBaudRate::RATE_50:
+      cfsetspeed(&options, B50);
+      break;
+    case UartBaudRate::RATE_75:
+      cfsetspeed(&options, B75);
+      break;
+    case UartBaudRate::RATE_110:
+      cfsetspeed(&options, B110);
+      break;
+    case UartBaudRate::RATE_134:
+      cfsetspeed(&options, B134);
+      break;
+    case UartBaudRate::RATE_150:
+      cfsetspeed(&options, B150);
+      break;
+    case UartBaudRate::RATE_200:
+      cfsetspeed(&options, B200);
+      break;
+    case UartBaudRate::RATE_300:
+      cfsetspeed(&options, B300);
+      break;
+    case UartBaudRate::RATE_600:
+      cfsetspeed(&options, B600);
+      break;
+    case UartBaudRate::RATE_1200:
+      cfsetspeed(&options, B1200);
+      break;
+    case UartBaudRate::RATE_1800:
+      cfsetspeed(&options, B1800);
+      break;
+    case UartBaudRate::RATE_2400:
+      cfsetspeed(&options, B2400);
+      break;
+    case UartBaudRate::RATE_4800:
+      cfsetspeed(&options, B4800);
+      break;
+    case UartBaudRate::RATE_9600:
+      cfsetspeed(&options, B9600);
+      break;
+    case UartBaudRate::RATE_19200:
+      cfsetspeed(&options, B19200);
+      break;
+    case UartBaudRate::RATE_38400:
+      cfsetspeed(&options, B38400);
+      break;
+    case UartBaudRate::RATE_57600:
+      cfsetspeed(&options, B57600);
+      break;
+    case UartBaudRate::RATE_115200:
+      cfsetspeed(&options, B115200);
+      break;
+    case UartBaudRate::RATE_230400:
+      cfsetspeed(&options, B230400);
+      break;
+#ifndef __APPLE__
+    case UartBaudRate::RATE_460800:
+      cfsetspeed(&options, B460800);
+      break;
+    case UartBaudRate::RATE_500000:
+      cfsetspeed(&options, B500000);
+      break;
+    case UartBaudRate::RATE_576000:
+      cfsetspeed(&options, B576000);
+      break;
+    case UartBaudRate::RATE_921600:
+      cfsetspeed(&options, B921600);
+      break;
+    case UartBaudRate::RATE_1000000:
+      cfsetspeed(&options, B1000000);
+      break;
+    case UartBaudRate::RATE_1152000:
+      cfsetspeed(&options, B1152000);
+      break;
+    case UartBaudRate::RATE_1500000:
+      cfsetspeed(&options, B1500000);
+      break;
+    case UartBaudRate::RATE_2000000:
+      cfsetspeed(&options, B2000000);
+      break;
+    case UartBaudRate::RATE_2500000:
+      cfsetspeed(&options, B2500000);
+      break;
+    case UartBaudRate::RATE_3000000:
+      cfsetspeed(&options, B3000000);
+      break;
+    case UartBaudRate::RATE_3500000:
+      cfsetspeed(&options, B3500000);
+      break;
+    case UartBaudRate::RATE_4000000:
+      cfsetspeed(&options, B4000000);
+      break;
+#endif  // ! __APPLE__
+    default:
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::warning << "UartComIF::configureBaudrate: Baudrate not supported" << std::endl;
+#endif
+      break;
+  }
+}
+
+void uart::setBitsPerWord(struct termios& options, BitsPerWord bits) {
+  options.c_cflag &= ~CSIZE;  // Clear all the size bits
+  if (bits == BitsPerWord::BITS_5) {
+    options.c_cflag |= CS5;
+  } else if (bits == BitsPerWord::BITS_6) {
+    options.c_cflag |= CS6;
+  } else if (bits == BitsPerWord::BITS_7) {
+    options.c_cflag |= CS7;
+  } else if (bits == BitsPerWord::BITS_8) {
+    options.c_cflag |= CS8;
+  }
+}
+
+void uart::enableRead(struct termios& options) { options.c_cflag |= CREAD; }
+
+void uart::ignoreCtrlLines(struct termios& options) { options.c_cflag |= CLOCAL; }
+
+void uart::setParity(struct termios& options, Parity parity) {
+  /* Clear parity bit */
+  options.c_cflag &= ~PARENB;
+  switch (parity) {
+    case Parity::EVEN:
+      options.c_cflag |= PARENB;
+      options.c_cflag &= ~PARODD;
+      break;
+    case Parity::ODD:
+      options.c_cflag |= PARENB;
+      options.c_cflag |= PARODD;
+      break;
+    default:
+      break;
+  }
+}
+
+int uart::readCountersAndErrors(int serialPort, serial_icounter_struct& icounter) {
+  return ioctl(serialPort, TIOCGICOUNT, &icounter);
+}
+
+void uart::setStopbits(struct termios& options, StopBits bits) {
+  if (bits == StopBits::TWO_STOP_BITS) {
+    // Use two stop bits
+    options.c_cflag |= CSTOPB;
+  } else {
+    // Clear stop field, only one stop bit used in communication
+    options.c_cflag &= ~CSTOPB;
+  }
+}

src/fsfw_hal/linux/serial/helper.h

@@ -54,6 +54,16 @@ void setMode(struct termios& options, UartModes mode);
  */
 void setBaudrate(struct termios& options, UartBaudRate baud);
 
+void setStopbits(struct termios& options, StopBits bits);
+
+void setBitsPerWord(struct termios& options, BitsPerWord bits);
+
+void enableRead(struct termios& options);
+
+void setParity(struct termios& options, Parity parity);
+
+void ignoreCtrlLines(struct termios& options);
+
 int readCountersAndErrors(int serialPort, serial_icounter_struct& icounter);
 
 }  // namespace uart

src/fsfw_hal/linux/uart/CMakeLists.txt

@@ -1 +0,0 @@
-target_sources(${LIB_FSFW_NAME} PUBLIC UartComIF.cpp UartCookie.cpp helper.cpp)

src/fsfw_hal/linux/uart/UartCookie.cpp

@@ -1,51 +0,0 @@
-#include "UartCookie.h"
-
-#include <fsfw/serviceinterface.h>
-
-UartCookie::UartCookie(object_id_t handlerId, std::string deviceFile, UartBaudRate baudrate,
-                       size_t maxReplyLen, UartModes uartMode)
-    : handlerId(handlerId),
-      deviceFile(deviceFile),
-      uartMode(uartMode),
-      baudrate(baudrate),
-      maxReplyLen(maxReplyLen) {}
-
-UartCookie::~UartCookie() {}
-
-UartBaudRate UartCookie::getBaudrate() const { return baudrate; }
-
-size_t UartCookie::getMaxReplyLen() const { return maxReplyLen; }
-
-std::string UartCookie::getDeviceFile() const { return deviceFile; }
-
-void UartCookie::setParityOdd() { parity = Parity::ODD; }
-
-void UartCookie::setParityEven() { parity = Parity::EVEN; }
-
-Parity UartCookie::getParity() const { return parity; }
-
-void UartCookie::setBitsPerWord(BitsPerWord bitsPerWord_) { bitsPerWord = bitsPerWord_; }
-
-BitsPerWord UartCookie::getBitsPerWord() const { return bitsPerWord; }
-
-StopBits UartCookie::getStopBits() const { return stopBits; }
-
-void UartCookie::setTwoStopBits() { stopBits = StopBits::TWO_STOP_BITS; }
-
-void UartCookie::setOneStopBit() { stopBits = StopBits::ONE_STOP_BIT; }
-
-UartModes UartCookie::getUartMode() const { return uartMode; }
-
-void UartCookie::setReadCycles(uint8_t readCycles) { this->readCycles = readCycles; }
-
-void UartCookie::setToFlushInput(bool enable) { this->flushInput = enable; }
-
-uint8_t UartCookie::getReadCycles() const { return readCycles; }
-
-bool UartCookie::getInputShouldBeFlushed() { return this->flushInput; }
-
-object_id_t UartCookie::getHandlerId() const { return this->handlerId; }
-
-void UartCookie::setNoFixedSizeReply() { replySizeFixed = false; }
-
-bool UartCookie::isReplySizeFixed() { return replySizeFixed; }

src/fsfw_hal/linux/uart/helper.cpp

@@ -1,148 +0,0 @@
-#include "helper.h"
-
-#include <sys/ioctl.h>
-
-#include "fsfw/serviceinterface.h"
-
-void uart::setMode(struct termios& options, UartModes mode) {
-  if (mode == UartModes::NON_CANONICAL) {
-    /* Disable canonical mode */
-    options.c_lflag &= ~ICANON;
-  } else if (mode == UartModes::CANONICAL) {
-    options.c_lflag |= ICANON;
-  }
-}
-
-void uart::setBaudrate(struct termios& options, UartBaudRate baud) {
-  switch (baud) {
-    case UartBaudRate::RATE_50:
-      cfsetispeed(&options, B50);
-      cfsetospeed(&options, B50);
-      break;
-    case UartBaudRate::RATE_75:
-      cfsetispeed(&options, B75);
-      cfsetospeed(&options, B75);
-      break;
-    case UartBaudRate::RATE_110:
-      cfsetispeed(&options, B110);
-      cfsetospeed(&options, B110);
-      break;
-    case UartBaudRate::RATE_134:
-      cfsetispeed(&options, B134);
-      cfsetospeed(&options, B134);
-      break;
-    case UartBaudRate::RATE_150:
-      cfsetispeed(&options, B150);
-      cfsetospeed(&options, B150);
-      break;
-    case UartBaudRate::RATE_200:
-      cfsetispeed(&options, B200);
-      cfsetospeed(&options, B200);
-      break;
-    case UartBaudRate::RATE_300:
-      cfsetispeed(&options, B300);
-      cfsetospeed(&options, B300);
-      break;
-    case UartBaudRate::RATE_600:
-      cfsetispeed(&options, B600);
-      cfsetospeed(&options, B600);
-      break;
-    case UartBaudRate::RATE_1200:
-      cfsetispeed(&options, B1200);
-      cfsetospeed(&options, B1200);
-      break;
-    case UartBaudRate::RATE_1800:
-      cfsetispeed(&options, B1800);
-      cfsetospeed(&options, B1800);
-      break;
-    case UartBaudRate::RATE_2400:
-      cfsetispeed(&options, B2400);
-      cfsetospeed(&options, B2400);
-      break;
-    case UartBaudRate::RATE_4800:
-      cfsetispeed(&options, B4800);
-      cfsetospeed(&options, B4800);
-      break;
-    case UartBaudRate::RATE_9600:
-      cfsetispeed(&options, B9600);
-      cfsetospeed(&options, B9600);
-      break;
-    case UartBaudRate::RATE_19200:
-      cfsetispeed(&options, B19200);
-      cfsetospeed(&options, B19200);
-      break;
-    case UartBaudRate::RATE_38400:
-      cfsetspeed(&options, B38400);
-      break;
-    case UartBaudRate::RATE_57600:
-      cfsetispeed(&options, B57600);
-      cfsetospeed(&options, B57600);
-      break;
-    case UartBaudRate::RATE_115200:
-      cfsetspeed(&options, B115200);
-      break;
-    case UartBaudRate::RATE_230400:
-      cfsetispeed(&options, B230400);
-      cfsetospeed(&options, B230400);
-      break;
-#ifndef __APPLE__
-    case UartBaudRate::RATE_460800:
-      cfsetispeed(&options, B460800);
-      cfsetospeed(&options, B460800);
-      break;
-    case UartBaudRate::RATE_500000:
-      cfsetispeed(&options, B500000);
-      cfsetospeed(&options, B500000);
-      break;
-    case UartBaudRate::RATE_576000:
-      cfsetispeed(&options, B576000);
-      cfsetospeed(&options, B576000);
-      break;
-    case UartBaudRate::RATE_921600:
-      cfsetispeed(&options, B921600);
-      cfsetospeed(&options, B921600);
-      break;
-    case UartBaudRate::RATE_1000000:
-      cfsetispeed(&options, B1000000);
-      cfsetospeed(&options, B1000000);
-      break;
-    case UartBaudRate::RATE_1152000:
-      cfsetispeed(&options, B1152000);
-      cfsetospeed(&options, B1152000);
-      break;
-    case UartBaudRate::RATE_1500000:
-      cfsetispeed(&options, B1500000);
-      cfsetospeed(&options, B1500000);
-      break;
-    case UartBaudRate::RATE_2000000:
-      cfsetispeed(&options, B2000000);
-      cfsetospeed(&options, B2000000);
-      break;
-    case UartBaudRate::RATE_2500000:
-      cfsetispeed(&options, B2500000);
-      cfsetospeed(&options, B2500000);
-      break;
-    case UartBaudRate::RATE_3000000:
-      cfsetispeed(&options, B3000000);
-      cfsetospeed(&options, B3000000);
-      break;
-    case UartBaudRate::RATE_3500000:
-      cfsetispeed(&options, B3500000);
-      cfsetospeed(&options, B3500000);
-      break;
-    case UartBaudRate::RATE_4000000:
-      cfsetispeed(&options, B4000000);
-      cfsetospeed(&options, B4000000);
-      break;
-#endif  // ! __APPLE__
-    default:
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::warning << "UartComIF::configureBaudrate: Baudrate not supported" << std::endl;
-#endif
-      break;
-  }
-}
-
-int uart::readCountersAndErrors(int serialPort, serial_icounter_struct& icounter) {
-  return ioctl(serialPort, TIOCGICOUNT, &icounter);
-}

src/fsfw_hal/linux/uio/UioMapper.cpp

@@ -21,11 +21,13 @@ UioMapper::UioMapper(std::string uioFile, int mapNum) : mapNum(mapNum) {
     char* res = realpath(uioFile.c_str(), nullptr);
     if (res) {
       this->uioFile = res;
-    } else {
-      sif::error << "Could not resolve real path of UIO file " << uioFile << std::endl;
-    }
       free(res);
     } else {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::error << "Could not resolve real path of UIO file " << uioFile << std::endl;
+#endif
+    }
+  } else {
     this->uioFile = std::move(uioFile);
   }
 }

src/fsfw_tests/integration/assemblies/TestAssembly.cpp

@@ -2,19 +2,17 @@
 
 #include <fsfw/objectmanager/ObjectManager.h>
 
-TestAssembly::TestAssembly(object_id_t objectId, object_id_t parentId, object_id_t testDevice0,
+TestAssembly::TestAssembly(object_id_t objectId, object_id_t parentId, ModeTreeChildIF& testDevice0,
-                           object_id_t testDevice1)
+                           ModeTreeChildIF& testDevice1)
-    : AssemblyBase(objectId, parentId),
+    : AssemblyBase(objectId, parentId), deviceHandler0(testDevice0), deviceHandler1(testDevice1) {
-      deviceHandler0Id(testDevice0),
-      deviceHandler1Id(testDevice1) {
   ModeListEntry newModeListEntry;
-  newModeListEntry.setObject(testDevice0);
+  newModeListEntry.setObject(testDevice0.getObjectId());
   newModeListEntry.setMode(MODE_OFF);
   newModeListEntry.setSubmode(SUBMODE_NONE);
 
   commandTable.insert(newModeListEntry);
 
-  newModeListEntry.setObject(testDevice1);
+  newModeListEntry.setObject(testDevice1.getObjectId());
   newModeListEntry.setMode(MODE_OFF);
   newModeListEntry.setSubmode(SUBMODE_NONE);
 
@@ -43,8 +41,8 @@ ReturnValue_t TestAssembly::commandChildren(Mode_t mode, Submode_t submode) {
       commandTable[1].setMode(MODE_OFF);
       commandTable[1].setSubmode(SUBMODE_NONE);
       // We try to prefer 0 here but we try to switch to 1 even if it might fail
-      if (isDeviceAvailable(deviceHandler0Id)) {
+      if (isDeviceAvailable(deviceHandler0.getObjectId())) {
-        if (childrenMap[deviceHandler0Id].mode == MODE_ON) {
+        if (childrenMap[deviceHandler0.getObjectId()].mode == MODE_ON) {
           commandTable[0].setMode(mode);
           commandTable[0].setSubmode(SUBMODE_NONE);
         } else {
@@ -53,7 +51,7 @@ ReturnValue_t TestAssembly::commandChildren(Mode_t mode, Submode_t submode) {
           result = NEED_SECOND_STEP;
         }
       } else {
-        if (childrenMap[deviceHandler1Id].mode == MODE_ON) {
+        if (childrenMap[deviceHandler1.getObjectId()].mode == MODE_ON) {
           commandTable[1].setMode(mode);
           commandTable[1].setSubmode(SUBMODE_NONE);
         } else {
@@ -64,7 +62,7 @@ ReturnValue_t TestAssembly::commandChildren(Mode_t mode, Submode_t submode) {
       }
     } else {
       // Dual Mode Normal
-      if (childrenMap[deviceHandler0Id].mode == MODE_ON) {
+      if (childrenMap[deviceHandler0.getObjectId()].mode == MODE_ON) {
         commandTable[0].setMode(mode);
         commandTable[0].setSubmode(SUBMODE_NONE);
       } else {
@@ -72,7 +70,7 @@ ReturnValue_t TestAssembly::commandChildren(Mode_t mode, Submode_t submode) {
         commandTable[0].setSubmode(SUBMODE_NONE);
         result = NEED_SECOND_STEP;
       }
-      if (childrenMap[deviceHandler1Id].mode == MODE_ON) {
+      if (childrenMap[deviceHandler1.getObjectId()].mode == MODE_ON) {
         commandTable[1].setMode(mode);
         commandTable[1].setSubmode(SUBMODE_NONE);
       } else {
@@ -89,7 +87,7 @@ ReturnValue_t TestAssembly::commandChildren(Mode_t mode, Submode_t submode) {
       commandTable[1].setMode(MODE_OFF);
       commandTable[1].setSubmode(SUBMODE_NONE);
       // We try to prefer 0 here but we try to switch to 1 even if it might fail
-      if (isDeviceAvailable(deviceHandler0Id)) {
+      if (isDeviceAvailable(deviceHandler0.getObjectId())) {
         commandTable[0].setMode(MODE_ON);
         commandTable[0].setSubmode(SUBMODE_NONE);
       } else {
@@ -133,23 +131,14 @@ ReturnValue_t TestAssembly::initialize() {
   if (result != returnvalue::OK) {
     return result;
   }
-  handler0 = ObjectManager::instance()->get<TestDevice>(deviceHandler0Id);
+  auto* handler0 = ObjectManager::instance()->get<TestDevice>(deviceHandler0.getObjectId());
-  handler1 = ObjectManager::instance()->get<TestDevice>(deviceHandler1Id);
+  auto* handler1 = ObjectManager::instance()->get<TestDevice>(deviceHandler1.getObjectId());
   if ((handler0 == nullptr) or (handler1 == nullptr)) {
     return returnvalue::FAILED;
   }
 
-  handler0->setParentQueue(this->getCommandQueue());
+  handler0->connectModeTreeParent(*this);
-  handler1->setParentQueue(this->getCommandQueue());
+  handler1->connectModeTreeParent(*this);
-
-  result = registerChild(deviceHandler0Id);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  result = registerChild(deviceHandler1Id);
-  if (result != returnvalue::OK) {
-    return result;
-  }
   return result;
 }
 

src/fsfw_tests/integration/assemblies/TestAssembly.h

@@ -7,8 +7,8 @@
 
 class TestAssembly : public AssemblyBase {
  public:
-  TestAssembly(object_id_t objectId, object_id_t parentId, object_id_t testDevice0,
+  TestAssembly(object_id_t objectId, object_id_t parentId, ModeTreeChildIF& testDevice0,
-               object_id_t testDevice1);
+               ModeTreeChildIF& testDevice1);
   virtual ~TestAssembly();
   ReturnValue_t initialize() override;
 
@@ -41,10 +41,8 @@ class TestAssembly : public AssemblyBase {
 
  private:
   FixedArrayList<ModeListEntry, 2> commandTable;
-  object_id_t deviceHandler0Id = 0;
+  ModeTreeChildIF& deviceHandler0;
-  object_id_t deviceHandler1Id = 0;
+  ModeTreeChildIF& deviceHandler1;
-  TestDevice* handler0 = nullptr;
-  TestDevice* handler1 = nullptr;
 
   bool isDeviceAvailable(object_id_t object);
 };

src/fsfw_tests/integration/controller/TestController.cpp

@@ -4,8 +4,8 @@
 #include <fsfw/objectmanager/ObjectManager.h>
 #include <fsfw/serviceinterface/ServiceInterface.h>
 
-TestController::TestController(object_id_t objectId, object_id_t parentId, size_t commandQueueDepth)
+TestController::TestController(object_id_t objectId, size_t commandQueueDepth)
-    : ExtendedControllerBase(objectId, parentId, commandQueueDepth) {}
+    : ExtendedControllerBase(objectId, commandQueueDepth) {}
 
 TestController::~TestController() {}
 

src/fsfw_tests/integration/controller/TestController.h

@@ -7,7 +7,7 @@
 
 class TestController : public ExtendedControllerBase {
  public:
-  TestController(object_id_t objectId, object_id_t parentId, size_t commandQueueDepth = 10);
+  TestController(object_id_t objectId, size_t commandQueueDepth = 10);
   virtual ~TestController();
 
  protected:

unittests/CatchSetup.cpp

@@ -31,4 +31,7 @@ int customSetup() {
   return 0;
 }
 
-int customTeardown() { return 0; }
+int customTeardown() {
+  ObjectManager::clear();
+  return 0;
+}