make function public

Reviewed-on: fsfw/fsfw#712

CHANGELOG.md

@@ -12,6 +12,9 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Fixes
 
+- 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 +27,18 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Added
 
-- DHB TM handler `handleDeviceTM` renamed to `handleDeviceTm` and now takes
-  `util::DataWrapper` as the data input argument. This allows more flexibility in the possible
-  types of telemetry.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/669
-- Add `util::DataWrapper` class inside the `util` module. This is a tagged union which allows
-  to specify raw data either as a classic C-style raw pointer and size or as a `SerializeIF`
-  pointer.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/668
+- `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
 
+- `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 +67,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

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

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,
-                               size_t commandQueueDepth)
+ControllerBase::ControllerBase(object_id_t setObjectId, 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;
   }
-
-  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);
+  result = healthHelper.initialize();
   if (result != returnvalue::OK) {
     return result;
   }
-
-  result = modeHelper.initialize(parentQueue);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-
-  return returnvalue::OK;
+  return SystemObject::initialize();
 }
 
 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,
-                                               size_t commandQueueDepth)
-    : ControllerBase(objectId, parentId, commandQueueDepth),
+ExtendedControllerBase::ExtendedControllerBase(object_id_t objectId, size_t commandQueueDepth)
+    : ControllerBase(objectId, 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)
-    : SubsystemBase(objectId, parentId, MODE_OFF, commandQueueDepth),
+AssemblyBase::AssemblyBase(object_id_t objectId, uint16_t 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,
-                                   uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
-                                   object_id_t parent, FailureIsolationBase* customFdir,
-                                   size_t cmdQueueSize)
+                                   CookieIF* cookie, HasModeTreeChildrenIF& parent,
+                                   FailureIsolationBase* customFdir, size_t cmdQueueSize)
     : DeviceHandlerBase(setObjectId, deviceCommunication, cookie,
                         (customFdir == nullptr ? &childHandlerFdir : customFdir), cmdQueueSize),
-      parentId(parent),
-      childHandlerFdir(setObjectId) {
-  this->setHkDestination(hkDestination);
-  this->setThermalStateRequestPoolIds(thermalStatePoolId, thermalRequestPoolId);
-}
+      parent(parent),
+      childHandlerFdir(setObjectId) {}
 
 ChildHandlerBase::~ChildHandlerBase() {}
 
@@ -23,21 +18,5 @@ ReturnValue_t ChildHandlerBase::initialize() {
     return result;
   }
 
-  MessageQueueId_t parentQueue = 0;
-
-  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;
+  return DeviceHandlerBase::connectModeTreeParent(parent);
 }

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,
-                   uint32_t thermalRequestPoolId, object_id_t parent = objects::NO_OBJECT,
-                   FailureIsolationBase* customFdir = nullptr, size_t cmdQueueSize = 20);
+                   HasModeTreeChildrenIF& parent, 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,4 +1,4 @@
-#include "fsfw/devicehandlers/DeviceHandlerBase.h"
+#include "DeviceHandlerBase.h"
 
 #include "fsfw/datapoollocal/LocalPoolVariable.h"
 #include "fsfw/devicehandlers/AcceptsDeviceResponsesIF.h"
@@ -12,6 +12,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 +133,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 +361,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 +568,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
    */
@@ -1587,19 +1581,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() {
-  return mode;
-}
+Mode_t DeviceHandlerBase::getMode() { return mode; }
 
-Submode_t DeviceHandlerBase::getSubmode() {
-  return submode;
-}
+Submode_t DeviceHandlerBase::getSubmode() { return submode; }
 
 void DeviceHandlerBase::disableCommandsAndReplies() {
   for (auto& command : deviceCommandMap) {
@@ -1619,6 +1607,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/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;
-  sum += rhs.tv_sec * 1000000. + rhs.tv_usec;
+  int64_t sum = static_cast<int64_t>(lhs.tv_sec) * 1000000. + lhs.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/modes/ModeMessage.cpp

@@ -24,3 +24,13 @@ 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);
+}

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 =
-      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(
-      0xF1);  //!> 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 =
-      MAKE_COMMAND_ID(0x02);  //!> Reply to a CMD_MODE_COMMAND or CMD_MODE_READ
-  static const Command_t REPLY_MODE_INFO =
-      MAKE_COMMAND_ID(0x03);  //!> 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(
-      0x04);  //!> Reply in case a mode command can't be executed. Par1: returnCode, Par2: 0
-  static const Command_t REPLY_WRONG_MODE_REPLY =
-      MAKE_COMMAND_ID(0x05);  //!> 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(
-      0x06);  //!> Command to read the current mode and reply with a REPLY_MODE_REPLY
-  static const Command_t CMD_MODE_ANNOUNCE = MAKE_COMMAND_ID(
-      0x07);  //!> Command to trigger an ModeInfo Event. This command does NOT have a reply.
-  static const Command_t CMD_MODE_ANNOUNCE_RECURSIVELY =
-      MAKE_COMMAND_ID(0x08);  //!> Command to trigger an ModeInfo Event and to send this command to
-                              //! every child. This command does NOT have a reply.
+  //!> 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 = MAKE_COMMAND_ID(0x01);
+  //!> 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 CMD_MODE_COMMAND_FORCED = MAKE_COMMAND_ID(0xF1);
+  //!> Reply to a CMD_MODE_COMMAND or CMD_MODE_READ
+  static const Command_t REPLY_MODE_REPLY = MAKE_COMMAND_ID(0x02);
+  //!> Unrequested info about the current mode (used for composites to
+  //! inform their container of a changed mode)
+  static const Command_t REPLY_MODE_INFO = MAKE_COMMAND_ID(0x03);
+  //!> Reply in case a mode command can't be executed. Par1: returnCode, Par2: 0
+  static const Command_t REPLY_CANT_REACH_MODE = MAKE_COMMAND_ID(0x04);
+  //!> 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 REPLY_WRONG_MODE_REPLY = MAKE_COMMAND_ID(0x05);
+  //!> Command to read the current mode and reply with a REPLY_MODE_REPLY
+  static const Command_t CMD_MODE_READ = MAKE_COMMAND_ID(0x06);
+  //!> Command to trigger an ModeInfo Event. This command does NOT have a reply.
+  static const Command_t CMD_MODE_ANNOUNCE = MAKE_COMMAND_ID(0x07);
+  //!> 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,7 @@ class ModeMessage {
 
   static void setModeMessage(CommandMessage* message, Command_t command, Mode_t mode,
                              Submode_t submode);
+  static void setModeAnnounceMessage(CommandMessage& message, bool recursive);
   static void setCantReachMode(CommandMessage* message, ReturnValue_t reason);
   static void clear(CommandMessage* message);
 };

src/fsfw/osal/common/TcpTmTcServer.cpp

@@ -274,6 +274,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/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/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,15 +54,26 @@ 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) {
-  ModePacket modeCommandPacket;
-  ReturnValue_t result =
-      modeCommandPacket.deSerialize(&tcData, &tcDataLen, SerializeIF::Endianness::BIG);
-  if (result != returnvalue::OK) {
-    return result;
+  ReturnValue_t result = returnvalue::OK;
+  if (subservice == Subservice::COMMAND_MODE_ANNCOUNCE or
+      subservice == Subservice::COMMAND_MODE_ANNOUNCE_RECURSIVELY) {
+    bool recursive = true;
+    if (subservice == Subservice::COMMAND_MODE_ANNCOUNCE) {
+      recursive = false;
+    }
+    ModeMessage::setModeAnnounceMessage(*message, recursive);
+  } else {
+    ModePacket modeCommandPacket;
+    ReturnValue_t result =
+        modeCommandPacket.deSerialize(&tcData, &tcDataLen, SerializeIF::Endianness::BIG);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+
+    ModeMessage::setModeMessage(message, ModeMessage::CMD_MODE_COMMAND, modeCommandPacket.getMode(),
+                                modeCommandPacket.getSubmode());
   }
 
-  ModeMessage::setModeMessage(message, ModeMessage::CMD_MODE_COMMAND, modeCommandPacket.getMode(),
-                              modeCommandPacket.getSubmode());
   return result;
 }
 

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/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/servicepackets/Service200Packets.h

@@ -1,9 +1,9 @@
 #ifndef FSFW_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
 #define FSFW_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
 
-#include "../../modes/ModeMessage.h"
-#include "../../serialize/SerialLinkedListAdapter.h"
-#include "../../serialize/SerializeIF.h"
+#include "fsfw/modes/ModeMessage.h"
+#include "fsfw/serialize/SerialLinkedListAdapter.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,
-                                 bool ignoreFault) {
-  ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
+ReturnValue_t LocalPool::addData(store_address_t* storageId, const uint8_t* data, size_t size) {
+  ReturnValue_t status = reserveSpace(size, storageId);
   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) {
-  ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
+                                        uint8_t** pData) {
+  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,
-                                        bool ignoreFault) {
+ReturnValue_t PoolManager::reserveSpace(const size_t size, store_address_t* address) {
   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,
-                                bool ignoreFault) = 0;
-
-  virtual ReturnValue_t addData(store_address_t* storageId, const uint8_t* data, size_t size) {
-    return addData(storageId, data, size, false);
-  }
+  virtual ReturnValue_t addData(store_address_t* storageId, const uint8_t* data, size_t size) = 0;
 
   /**
    * @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,
-                                       bool ignoreFault) = 0;
-
-  virtual ReturnValue_t getFreeElement(store_address_t* storageId, size_t size, uint8_t** dataPtr) {
-    return getFreeElement(storageId, size, dataPtr, false);
-  }
+  virtual ReturnValue_t getFreeElement(store_address_t* storageId, size_t size,
+                                       uint8_t** dataPtr) = 0;
 
   [[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,
-            uint32_t maxNumberOfTables);
+  Subsystem(object_id_t setObjectId, uint32_t maxNumberOfSequences, 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),
-      parentId(parent) {
+      modeHelper(this) {
   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 = SystemObject::initialize();
-
+  ReturnValue_t result = modeHelper.initialize();
   if (result != returnvalue::OK) {
     return result;
   }
-
-  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);
-
+  result = healthHelper.initialize();
   if (result != returnvalue::OK) {
     return result;
   }
-
-  result = modeHelper.initialize(parentQueue);
-
-  if (result != returnvalue::OK) {
-    return result;
-  }
-
-  return returnvalue::OK;
+  return SystemObject::initialize();
 }
 
 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 "../health/HasHealthIF.h"
-#include "../health/HealthHelper.h"
-#include "../ipc/MessageQueueIF.h"
-#include "../modes/HasModesIF.h"
-#include "../objectmanager/SystemObject.h"
-#include "../returnvalues/returnvalue.h"
-#include "../tasks/ExecutableObjectIF.h"
+#include "fsfw/container/HybridIterator.h"
+#include "fsfw/health/HasHealthIF.h"
+#include "fsfw/health/HealthHelper.h"
+#include "fsfw/ipc/MessageQueueIF.h"
+#include "fsfw/modes/HasModesIF.h"
+#include "fsfw/objectmanager/SystemObject.h"
+#include "fsfw/returnvalues/returnvalue.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,32 +41,34 @@ 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,
-                uint16_t commandQueueDepth = 8);
+  SubsystemBase(object_id_t setObjectId, Mode_t initialMode = 0, 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
    *
-   * 	Also adds them to the internal childrenMap.
+   *    Also adds them to the internal childrenMap.
    *
    * @param objectId
    * @return returnvalue::OK if successful
-   * 		   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
+   *           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,13 @@
+#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;
+  }
+  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/CCSDSTime.cpp

@@ -246,6 +246,20 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
   return UNSUPPORTED_TIME_FORMAT;
 }
 
+ReturnValue_t CCSDSTime::convertToAsciiWithSecs(int8_t* to, const Clock::TimeOfDay_t* from,
+                                                uint8_t length) {
+  if (from == nullptr or to == nullptr) {
+    return returnvalue::FAILED;
+  }
+  int count = snprintf(reinterpret_cast<char*>(to), length,
+                       "%4" SCNu32 "-%2" SCNu32 "-%2" SCNu32 "T%2" SCNu32 ":%2" SCNu32 ":%2" SCNu32,
+                       from->year, from->month, from->day, from->hour, from->minute, from->second);
+  if (count >= length) {
+    return returnvalue::FAILED;
+  }
+  return returnvalue::OK;
+}
+
 ReturnValue_t CCSDSTime::checkCcs(const uint8_t* time, uint8_t length) {
   const Ccs_mseconds* time_struct = reinterpret_cast<const Ccs_mseconds*>(time);
 

src/fsfw/timemanager/CCSDSTime.h

@@ -207,7 +207,8 @@ class CCSDSTime {
 
   static ReturnValue_t convertFromASCII(Clock::TimeOfDay_t *to, uint8_t const *from,
                                         uint8_t length);
-
+  static ReturnValue_t convertToAsciiWithSecs(int8_t *to, const Clock::TimeOfDay_t *from,
+                                              uint8_t length);
   static uint32_t subsecondsToMicroseconds(uint16_t subseconds);
 
  private:

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/tmstorage/TmStoreFrontendIF.h

@@ -6,47 +6,12 @@
 #include "fsfw/returnvalues/returnvalue.h"
 #include "tmStorageConf.h"
 
-class TmPacketMinimal;
-class SpacePacketBase;
+class PusTmReader;
+class SpacePacketReader;
 class TmStoreBackendIF;
 
 class TmStoreFrontendIF {
  public:
-  virtual TmStoreBackendIF* getBackend() const = 0;
-
-  /**
-   * What do I need to implement here?
-   * This is propably used by PUS Service 15 so we should propably check for messages..
-   * Provide base implementation?
-   * @param opCode
-   * @return
-   */
-  virtual ReturnValue_t performOperation(uint8_t opCode) = 0;
-  /**
-   * Callback from the back-end to indicate a certain packet was received.
-   * front-end takes care of discarding/downloading the packet.
-   * @param packet	Pointer to the newly received Space Packet.
-   * @param address	Start address of the packet found
-   * @param isLastPacket	Indicates if no more packets can be fetched.
-   * @return	If more packets shall be fetched, returnvalue::OK must be returned.
-   * 			Any other code stops fetching packets.
-   */
-  virtual ReturnValue_t packetRetrieved(TmPacketMinimal* packet, uint32_t address) = 0;
-  virtual void noMorePacketsInStore() = 0;
-  virtual void handleRetrievalFailed(ReturnValue_t errorCode, uint32_t parameter1 = 0,
-                                     uint32_t parameter2 = 0) = 0;
-  /**
-   * To get the queue where commands shall be sent.
-   * @return	Id of command queue.
-   */
-  virtual MessageQueueId_t getCommandQueue() const = 0;
-  virtual ReturnValue_t fetchPackets(ApidSsc start, ApidSsc end) = 0;
-  virtual ReturnValue_t deletePackets(ApidSsc upTo) = 0;
-  virtual ReturnValue_t checkPacket(SpacePacketBase* tmPacket) = 0;
-  virtual bool isEnabled() const = 0;
-  virtual void setEnabled(bool enabled) = 0;
-  virtual void resetDownlinkedPacketCount() = 0;
-  virtual ReturnValue_t setDumpTarget(object_id_t dumpTarget) = 0;
   static const uint8_t INTERFACE_ID = CLASS_ID::TM_STORE_FRONTEND_IF;
   static const ReturnValue_t BUSY = MAKE_RETURN_CODE(1);
   static const ReturnValue_t LAST_PACKET_FOUND = MAKE_RETURN_CODE(2);
@@ -57,7 +22,38 @@ class TmStoreFrontendIF {
   static const ReturnValue_t ALL_DELETED = MAKE_RETURN_CODE(7);
   static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(8);
   static const ReturnValue_t NOT_READY = MAKE_RETURN_CODE(9);
-  virtual ~TmStoreFrontendIF() {}
+
+  virtual ~TmStoreFrontendIF() = default;
+
+  /**
+   * To get the queue where commands shall be sent.
+   * @return  Id of command queue.
+   */
+  virtual MessageQueueId_t getCommandQueue() const = 0;
+
+  virtual TmStoreBackendIF* getBackend() const = 0;
+
+  /**
+   * Callback from the back-end to indicate a certain packet was received.
+   * front-end takes care of discarding/downloading the packet.
+   * @param packet	Pointer to the newly received Space Packet.
+   * @param address	Start address of the packet found
+   * @param isLastPacket	Indicates if no more packets can be fetched.
+   * @return	If more packets shall be fetched, returnvalue::OK must be returned.
+   * 			Any other code stops fetching packets.
+   */
+  virtual ReturnValue_t packetRetrieved(PusTmReader* packet, uint32_t address) = 0;
+  virtual void noMorePacketsInStore() = 0;
+  virtual void handleRetrievalFailed(ReturnValue_t errorCode, uint32_t parameter1 = 0,
+                                     uint32_t parameter2 = 0) = 0;
+
+  virtual ReturnValue_t fetchPackets(ApidSsc start, ApidSsc end) = 0;
+  virtual ReturnValue_t deletePackets(ApidSsc upTo) = 0;
+  virtual ReturnValue_t checkPacket(SpacePacketReader* tmPacket) = 0;
+  virtual bool isEnabled() const = 0;
+  virtual void setEnabled(bool enabled) = 0;
+  virtual void resetDownlinkedPacketCount() = 0;
+  virtual ReturnValue_t setDumpTarget(object_id_t dumpTarget) = 0;
 };
 
 #endif /* FSFW_TMTCSERVICES_TMSTOREFRONTENDIF_H_ */

src/fsfw/tmstorage/TmStoreFrontendSimpleIF.h

@@ -0,0 +1,14 @@
+#ifndef FSFW_SRC_FSFW_TMSTORAGE_TMSTOREBACKENDSIMPLEIF_H_
+#define FSFW_SRC_FSFW_TMSTORAGE_TMSTOREBACKENDSIMPLEIF_H_
+
+#include <fsfw/ipc/messageQueueDefinitions.h>
+
+class TmStoreFrontendSimpleIF {
+ public:
+  virtual ~TmStoreFrontendSimpleIF() = default;
+
+  virtual MessageQueueId_t getCommandQueue() const = 0;
+ private:
+};
+
+#endif /* FSFW_SRC_FSFW_TMSTORAGE_TMSTOREBACKENDSIMPLEIF_H_ */

src/fsfw/tmstorage/TmStorePackets.h

@@ -1,6 +1,10 @@
 #ifndef FSFW_TMSTORAGE_TMSTOREPACKETS_H_
 #define FSFW_TMSTORAGE_TMSTOREPACKETS_H_
 
+#include <fsfw/tmtcpacket/pus/tm/PusTmReader.h>
+
+#include <vector>
+
 #include "fsfw/globalfunctions/timevalOperations.h"
 #include "fsfw/serialize/SerialBufferAdapter.h"
 #include "fsfw/serialize/SerialFixedArrayListAdapter.h"
@@ -24,7 +28,7 @@ class ServiceSubservice : public SerialLinkedListAdapter<SerializeIF> {
 
 class ApidSsc : public SerializeIF {
  public:
-  ApidSsc() : apid(SpacePacketBase::LIMIT_APID), ssc(0) {}
+  ApidSsc() : apid(ccsds::LIMIT_APID), ssc(0) {}
   ApidSsc(uint16_t apid, uint16_t ssc) : apid(apid), ssc(ssc) {}
   uint16_t apid;
   uint16_t ssc;
@@ -62,51 +66,59 @@ class ChangeSelectionDefinition : public SerialLinkedListAdapter<SerializeIF> {
 
 class TmPacketInformation : public SerializeIF {
  public:
-  TmPacketInformation(TmPacketMinimal* packet) { setContent(packet); }
-  TmPacketInformation()
-      : apid(SpacePacketBase::LIMIT_APID),
+  TmPacketInformation(PusTmReader* packet, size_t timestampLen) : rawTimestamp(timestampLen) {
+    setContent(packet);
+  }
+  TmPacketInformation(size_t timestampLen)
+      : apid(ccsds::LIMIT_APID),
         sourceSequenceCount(0),
         serviceType(0),
         serviceSubtype(0),
-        subCounter(0) {}
+        subCounter(0),
+        rawTimestamp(timestampLen) {}
   void reset() {
-    apid = SpacePacketBase::LIMIT_APID;
+    apid = ccsds::LIMIT_APID;
     sourceSequenceCount = 0;
     serviceType = 0;
     serviceSubtype = 0;
     subCounter = 0;
-    memset(rawTimestamp, 0, sizeof(rawTimestamp));
+    memset(rawTimestamp.data(), 0, rawTimestamp.size());
   }
-  void setContent(TmPacketMinimal* packet) {
-    apid = packet->getAPID();
-    sourceSequenceCount = packet->getPacketSequenceCount();
+  void setContent(PusTmReader* packet) {
+    apid = packet->getApid();
+    sourceSequenceCount = packet->getSequenceCount();
     serviceType = packet->getService();
     serviceSubtype = packet->getSubService();
-    subCounter = packet->getPacketSubcounter();
-    memset(rawTimestamp, 0, sizeof(rawTimestamp));
-    const uint8_t* pField = NULL;
-    uint32_t size = 0;
-    ReturnValue_t result = packet->getPacketTimeRaw(&pField, &size);
-    if (result != returnvalue::OK) {
-      return;
-    }
-    if (*pField == CCSDSTime::P_FIELD_CDS_SHORT && size <= TimeStamperIF::MISSION_TIMESTAMP_SIZE) {
-      // Shortcut to avoid converting CDS back and forth.
-      memcpy(rawTimestamp, pField, size);
-      return;
-    }
-    timeval time = {0, 0};
-    result = packet->getPacketTime(&time);
-    if (result != returnvalue::OK) {
-      return;
-    }
-
-    CCSDSTime::CDS_short cdsFormat;
-    result = CCSDSTime::convertToCcsds(&cdsFormat, &time);
-    if (result != returnvalue::OK) {
-      return;
-    }
-    memcpy(rawTimestamp, &cdsFormat, sizeof(cdsFormat));
+    subCounter = packet->getMessageTypeCounter();
+    memset(rawTimestamp.data(), 0, rawTimestamp.size());
+    // TODO: Fix all of this
+    // const uint8_t* pField = NULL;
+    // uint32_t size = 0;
+    // auto* timeReader = packet->getTimeReader();
+    // ReturnValue_t result = packet->getPacketTimeRaw(&pField, &size);
+    // if (result != returnvalue::OK) {
+    // return;
+    //}
+    // if (*pField == CCSDSTime::P_FIELD_CDS_SHORT && size <= TimeStamperIF::MISSION_TIMESTAMP_SIZE)
+    // {
+    // Shortcut to avoid converting CDS back and forth.
+    // TODO: Fix
+    // memcpy(rawTimestamp, pField, size);
+    //      return;
+    //    }
+    //    timeval time = {0, 0};
+    //    result = packet->getPacketTime(&time);
+    //    if (result != returnvalue::OK) {
+    //      return;
+    //    }
+    //
+    //    CCSDSTime::CDS_short cdsFormat;
+    //    result = CCSDSTime::convertToCcsds(&cdsFormat, &time);
+    //    if (result != returnvalue::OK) {
+    //      return;
+    //    }
+    // TODO: Fix
+    // memcpy(rawTimestamp, &cdsFormat, sizeof(cdsFormat));
   }
   void setContent(TmPacketInformation* content) {
     apid = content->apid;
@@ -114,9 +126,10 @@ class TmPacketInformation : public SerializeIF {
     serviceType = content->serviceType;
     serviceSubtype = content->serviceSubtype;
     subCounter = content->subCounter;
-    memcpy(rawTimestamp, content->rawTimestamp, sizeof(rawTimestamp));
+    // TODO: Fix
+    // memcpy(rawTimestamp, content->rawTimestamp, sizeof(rawTimestamp));
   }
-  bool isValid() const { return (apid < SpacePacketBase::LIMIT_APID) ? true : false; }
+  bool isValid() const { return (apid < ccsds::LIMIT_APID) ? true : false; }
   static void reset(TmPacketInformation* packet) { packet->reset(); }
 
   static bool isOlderThan(const TmPacketInformation* packet, const timeval* cmpTime) {
@@ -216,7 +229,7 @@ class TmPacketInformation : public SerializeIF {
     if (result != returnvalue::OK) {
       return result;
     }
-    SerialBufferAdapter<uint8_t> adapter(rawTimestamp, sizeof(rawTimestamp));
+    SerialBufferAdapter<uint8_t> adapter(rawTimestamp.data(), rawTimestamp.size());
     return adapter.serialize(buffer, size, maxSize, streamEndianness);
   }
 
@@ -227,7 +240,7 @@ class TmPacketInformation : public SerializeIF {
     size += SerializeAdapter::getSerializedSize(&serviceType);
     size += SerializeAdapter::getSerializedSize(&serviceSubtype);
     size += SerializeAdapter::getSerializedSize(&subCounter);
-    SerialBufferAdapter<uint8_t> adapter(rawTimestamp, sizeof(rawTimestamp));
+    SerialBufferAdapter<uint8_t> adapter(rawTimestamp.data(), rawTimestamp.size());
     size += adapter.getSerializedSize();
     return size;
   };
@@ -253,7 +266,7 @@ class TmPacketInformation : public SerializeIF {
     if (result != returnvalue::OK) {
       return result;
     }
-    SerialBufferAdapter<uint8_t> adapter(rawTimestamp, sizeof(rawTimestamp));
+    SerialBufferAdapter<uint8_t> adapter(rawTimestamp.data(), rawTimestamp.size());
     return adapter.deSerialize(buffer, size, streamEndianness);
   }
 
@@ -263,6 +276,6 @@ class TmPacketInformation : public SerializeIF {
   uint8_t serviceType;
   uint8_t serviceSubtype;
   uint8_t subCounter;
-  uint8_t rawTimestamp[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
+  std::vector<uint8_t> rawTimestamp;
 };
 #endif /* FSFW_TMSTORAGE_TMSTOREPACKETS_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/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 "
-               << static_cast<uint16_t>(result) << std::endl;
+    sif::error << "PusService " << static_cast<int>(psbParams.serviceId)
+               << ": performService returned with " << static_cast<uint16_t>(result) << std::endl;
 #endif
     return returnvalue::FAILED;
   }

src/fsfw/tmtcservices/TmTcBridge.cpp

@@ -183,7 +183,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 +226,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/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_LIBGPIOD)
+  add_subdirectory(gpio)
+endif()
+if(FSFW_HAL_LINUX_ADD_SERIAL_DRIVERS)
+  add_subdirectory(serial)
+endif()
+
 if(FSFW_HAL_LINUX_ADD_PERIPHERAL_DRIVERS)
-  if(FSFW_HAL_LINUX_ADD_LIBGPIOD)
-    add_subdirectory(gpio)
-  endif()
-  add_subdirectory(uart)
   # Adding those does not really make sense on Apple systems which are generally
   # host systems. It won't even compile as the headers are missing
   if(NOT APPLE)

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

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,4 +1,4 @@
-#include "UartComIF.h"
+#include "SerialComIF.h"
 
 #include <errno.h>
 #include <fcntl.h>
@@ -11,18 +11,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 +59,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 +88,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 +114,7 @@ int UartComIF::configureUartPort(UartCookie* uartCookie) {
   return fd;
 }
 
-void UartComIF::setParityOptions(struct termios* options, UartCookie* 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) {
+void SerialComIF::setStopBitOptions(struct termios* options, SerialCookie* uartCookie) {
   /* Clear stop field. Sets stop bit to one bit */
   options->c_cflag &= ~CSTOPB;
   switch (uartCookie->getStopBits()) {
@@ -143,7 +126,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 +150,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 +173,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 +188,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 +219,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 +257,8 @@ ReturnValue_t UartComIF::requestReceiveMessage(CookieIF* cookie, size_t requestL
   }
 }
 
-ReturnValue_t UartComIF::handleCanonicalRead(UartCookie& uartCookie, UartDeviceMap::iterator& iter,
-                                             size_t requestLen) {
+ReturnValue_t SerialComIF::handleCanonicalRead(SerialCookie& uartCookie,
+                                               UartDeviceMap::iterator& iter, size_t requestLen) {
   ReturnValue_t result = returnvalue::OK;
   uint8_t maxReadCycles = uartCookie.getReadCycles();
   uint8_t currentReadCycles = 0;
@@ -332,8 +315,9 @@ ReturnValue_t UartComIF::handleCanonicalRead(UartCookie& uartCookie, UartDeviceM
   return result;
 }
 
-ReturnValue_t UartComIF::handleNoncanonicalRead(UartCookie& uartCookie,
-                                                UartDeviceMap::iterator& iter, size_t requestLen) {
+ReturnValue_t SerialComIF::handleNoncanonicalRead(SerialCookie& uartCookie,
+                                                  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 +350,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 +380,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 +399,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 +418,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);
 
-  /**
-   * @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);
+  void setStopBitOptions(struct termios* options, SerialCookie* 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,
-             size_t maxReplyLen, UartModes uartMode = UartModes::NON_CANONICAL);
+  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,10 +21,12 @@ UioMapper::UioMapper(std::string uioFile, int mapNum) : mapNum(mapNum) {
     char* res = realpath(uioFile.c_str(), nullptr);
     if (res) {
       this->uioFile = res;
+      free(res);
     } else {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::error << "Could not resolve real path of UIO file " << uioFile << std::endl;
+#endif
     }
-    free(res);
   } 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,
-                           object_id_t testDevice1)
-    : AssemblyBase(objectId, parentId),
-      deviceHandler0Id(testDevice0),
-      deviceHandler1Id(testDevice1) {
+TestAssembly::TestAssembly(object_id_t objectId, object_id_t parentId, ModeTreeChildIF& testDevice0,
+                           ModeTreeChildIF& testDevice1)
+    : AssemblyBase(objectId, parentId), deviceHandler0(testDevice0), deviceHandler1(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 (childrenMap[deviceHandler0Id].mode == MODE_ON) {
+      if (isDeviceAvailable(deviceHandler0.getObjectId())) {
+        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);
-  handler1 = ObjectManager::instance()->get<TestDevice>(deviceHandler1Id);
+  auto* handler0 = ObjectManager::instance()->get<TestDevice>(deviceHandler0.getObjectId());
+  auto* handler1 = ObjectManager::instance()->get<TestDevice>(deviceHandler1.getObjectId());
   if ((handler0 == nullptr) or (handler1 == nullptr)) {
     return returnvalue::FAILED;
   }
 
-  handler0->setParentQueue(this->getCommandQueue());
-  handler1->setParentQueue(this->getCommandQueue());
-
-  result = registerChild(deviceHandler0Id);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  result = registerChild(deviceHandler1Id);
-  if (result != returnvalue::OK) {
-    return result;
-  }
+  handler0->connectModeTreeParent(*this);
+  handler1->connectModeTreeParent(*this);
   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,
-               object_id_t testDevice1);
+  TestAssembly(object_id_t objectId, object_id_t parentId, ModeTreeChildIF& testDevice0,
+               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;
-  object_id_t deviceHandler1Id = 0;
-  TestDevice* handler0 = nullptr;
-  TestDevice* handler1 = nullptr;
+  ModeTreeChildIF& deviceHandler0;
+  ModeTreeChildIF& deviceHandler1;
 
   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)
-    : ExtendedControllerBase(objectId, parentId, commandQueueDepth) {}
+TestController::TestController(object_id_t objectId, size_t 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/container/TestArrayList.cpp

@@ -43,7 +43,7 @@ TEST_CASE("Array List", "[containers]") {
     for (auto i = 0; i < 20; i++) {
       REQUIRE(list.insert(i) == static_cast<int>(returnvalue::OK));
     }
-    REQUIRE(list.insert(20) == static_cast<int>(ArrayList<uint16_t>::FULL));
+    REQUIRE(list.insert(20) == static_cast<int>(containers::LIST_FULL));
     ArrayList<uint16_t>::Iterator it = list.begin();
     REQUIRE((*it) == 0);
     it++;

unittests/container/TestFixedArrayList.cpp

@@ -31,7 +31,7 @@ TEST_CASE("FixedArrayList Tests", "[containers]") {
     for (auto i = 1; i < 260; i++) {
       REQUIRE(list.insert(i) == static_cast<int>(returnvalue::OK));
     }
-    REQUIRE(list.insert(260) == static_cast<int>(ArrayList<uint32_t, uint16_t>::FULL));
+    REQUIRE(list.insert(260) == static_cast<int>(containers::LIST_FULL));
     list.clear();
     REQUIRE(list.size == 0);
   }

unittests/container/TestFixedMap.cpp

@@ -7,6 +7,8 @@
 
 template class FixedMap<unsigned int, unsigned short>;
 
+using namespace returnvalue;
+
 TEST_CASE("FixedMap Tests", "[containers]") {
   INFO("FixedMap Tests");
 
@@ -24,9 +26,9 @@ TEST_CASE("FixedMap Tests", "[containers]") {
       REQUIRE(map.find(i)->second == i + 1);
       REQUIRE(not map.empty());
     }
-    REQUIRE(map.insert(0, 0) == static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_ALREADY_EXISTS));
-    REQUIRE(map.insert(31, 0) == static_cast<int>(FixedMap<uint32_t, uint16_t>::MAP_FULL));
-    REQUIRE(map.exists(31) == static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+    REQUIRE(map.insert(0, 0) == static_cast<int>(containers::KEY_ALREADY_EXISTS));
+    REQUIRE(map.insert(31, 0) == static_cast<int>(containers::MAP_FULL));
+    REQUIRE(map.exists(31) == static_cast<int>(containers::KEY_DOES_NOT_EXIST));
     REQUIRE(map.size() == 30);
     REQUIRE(map.full());
     {
@@ -34,15 +36,14 @@ TEST_CASE("FixedMap Tests", "[containers]") {
       REQUIRE(map.find(5, &ptr) == static_cast<int>(returnvalue::OK));
       REQUIRE(*ptr == 6);
       REQUIRE(*(map.findValue(6)) == 7);
-      REQUIRE(map.find(31, &ptr) ==
-              static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+      REQUIRE(map.find(31, &ptr) == static_cast<int>(containers::KEY_DOES_NOT_EXIST));
     }
 
     REQUIRE(map.getSerializedSize() ==
             (sizeof(uint32_t) + 30 * (sizeof(uint32_t) + sizeof(uint16_t))));
     REQUIRE(map.erase(2) == static_cast<int>(returnvalue::OK));
-    REQUIRE(map.erase(31) == static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
-    REQUIRE(map.exists(2) == static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+    REQUIRE(map.erase(31) == static_cast<int>(containers::KEY_DOES_NOT_EXIST));
+    REQUIRE(map.exists(2) == static_cast<int>(containers::KEY_DOES_NOT_EXIST));
     REQUIRE(map.size() == 29);
 
     for (auto element : map) {
@@ -79,8 +80,7 @@ TEST_CASE("FixedMap Tests", "[containers]") {
     REQUIRE(map.insert(37, 38, nullptr) == static_cast<int>(returnvalue::OK));
     REQUIRE(map.find(37)->second == 38);
     REQUIRE(map.size() == 2);
-    REQUIRE(map.insert(37, 24, nullptr) ==
-            static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_ALREADY_EXISTS));
+    REQUIRE(map.insert(37, 24, nullptr) == static_cast<int>(containers::KEY_ALREADY_EXISTS));
     REQUIRE(map.find(37)->second != 24);
     REQUIRE(map.size() == 2);
   };
@@ -137,7 +137,7 @@ TEST_CASE("FixedMap Tests", "[containers]") {
     FixedMap<uint32_t, uint16_t>::Iterator it;
     std::pair<uint32_t, uint16_t> pair = std::make_pair(44, 43);
     it = FixedMap<uint32_t, uint16_t>::Iterator(&pair);
-    REQUIRE(map.erase(&it) == static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+    REQUIRE(map.erase(&it) == static_cast<int>(containers::KEY_DOES_NOT_EXIST));
     REQUIRE(map.find(45) == map.end());
     size_t toLargeMap = 100;
     const uint8_t* ptr = reinterpret_cast<uint8_t*>(&toLargeMap);

unittests/globalfunctions/testTimevalOperations.cpp

@@ -56,61 +56,65 @@ TEST_CASE("TimevalTest", "[timevalOperations]") {
   }
   SECTION("Operators") {
     timeval t1;
-    t1.tv_sec = 1648227422;
-    t1.tv_usec = 123456;
-    timeval t2;
-    t2.tv_sec = 1648227422;
-    t2.tv_usec = 123456;
-    timeval t3 = t1 - t2;
-    REQUIRE(t3.tv_sec == 0);
-    REQUIRE(t3.tv_usec == 0);
-    timeval t4 = t1 - t3;
-    REQUIRE(t4.tv_sec == 1648227422);
-    REQUIRE(t4.tv_usec == 123456);
-    timeval t5 = t3 - t1;
-    REQUIRE(t5.tv_sec == -1648227422);
-    REQUIRE(t5.tv_usec == -123456);
+    if (sizeof(t1.tv_sec) == 8) {
+      t1.tv_sec = 1648227422;
+      t1.tv_usec = 123456;
+      timeval t2;
+      t2.tv_sec = 1648227422;
+      t2.tv_usec = 123456;
+      timeval t3 = t1 - t2;
+      REQUIRE(t3.tv_sec == 0);
+      REQUIRE(t3.tv_usec == 0);
+      timeval t4 = t1 - t3;
+      REQUIRE(t4.tv_sec == 1648227422);
+      REQUIRE(t4.tv_usec == 123456);
+      timeval t5 = t3 - t1;
+      REQUIRE(t5.tv_sec == -1648227422);
+      REQUIRE(t5.tv_usec == -123456);
 
-    timeval t6;
-    t6.tv_sec = 1648227400;
-    t6.tv_usec = 999999;
+      timeval t6;
+      t6.tv_sec = 1648227400;
+      t6.tv_usec = 999999;
 
-    timeval t7 = t6 + t1;
-    REQUIRE(t7.tv_sec == (1648227422ull + 1648227400ull + 1ull));
-    REQUIRE(t7.tv_usec == 123455);
+      timeval t7 = t6 + t1;
+      // Overflow test
+      REQUIRE(t7.tv_sec == (1648227422ull + 1648227400ull + 1ull));
 
-    timeval t8 = t1 - t6;
-    REQUIRE(t8.tv_sec == 1648227422 - 1648227400 - 1);
-    REQUIRE(t8.tv_usec == 123457);
+      REQUIRE(t7.tv_usec == 123455);
 
-    double scalar = 2;
-    timeval t9 = t1 * scalar;
-    REQUIRE(t9.tv_sec == 3296454844);
-    REQUIRE(t9.tv_usec == 246912);
-    timeval t10 = scalar * t1;
-    REQUIRE(t10.tv_sec == 3296454844);
-    REQUIRE(t10.tv_usec == 246912);
-    timeval t11 = t6 * scalar;
-    REQUIRE(t11.tv_sec == (3296454800 + 1));
-    REQUIRE(t11.tv_usec == 999998);
+      timeval t8 = t1 - t6;
+      REQUIRE(t8.tv_sec == 1648227422 - 1648227400 - 1);
+      REQUIRE(t8.tv_usec == 123457);
 
-    timeval t12 = t1 / scalar;
-    REQUIRE(t12.tv_sec == 824113711);
-    REQUIRE(t12.tv_usec == 61728);
+      double scalar = 2;
+      timeval t9 = t1 * scalar;
+      REQUIRE(t9.tv_sec == 3296454844);
+      REQUIRE(t9.tv_usec == 246912);
+      timeval t10 = scalar * t1;
+      REQUIRE(t10.tv_sec == 3296454844);
+      REQUIRE(t10.tv_usec == 246912);
+      timeval t11 = t6 * scalar;
+      REQUIRE(t11.tv_sec == (3296454800 + 1));
+      REQUIRE(t11.tv_usec == 999998);
 
-    timeval t13 = t6 / scalar;
-    REQUIRE(t13.tv_sec == 824113700);
-    // Rounding issue
-    REQUIRE(t13.tv_usec == 499999);
+      timeval t12 = t1 / scalar;
+      REQUIRE(t12.tv_sec == 824113711);
+      REQUIRE(t12.tv_usec == 61728);
 
-    double scalar2 = t9 / t1;
-    REQUIRE(scalar2 == Catch::Approx(2.0));
-    double scalar3 = t1 / t6;
-    REQUIRE(scalar3 == Catch::Approx(1.000000013));
-    double scalar4 = t3 / t1;
-    REQUIRE(scalar4 == Catch::Approx(0));
-    double scalar5 = t12 / t1;
-    REQUIRE(scalar5 == Catch::Approx(0.5));
+      timeval t13 = t6 / scalar;
+      REQUIRE(t13.tv_sec == 824113700);
+      // Rounding issue
+      REQUIRE(t13.tv_usec == 499999);
+
+      double scalar2 = t9 / t1;
+      REQUIRE(scalar2 == Catch::Approx(2.0));
+      double scalar3 = t1 / t6;
+      REQUIRE(scalar3 == Catch::Approx(1.000000013));
+      double scalar4 = t3 / t1;
+      REQUIRE(scalar4 == Catch::Approx(0));
+      double scalar5 = t12 / t1;
+      REQUIRE(scalar5 == Catch::Approx(0.5));
+    }
   }
 
   SECTION("timevalOperations::toTimeval") {

unittests/hal/CMakeLists.txt

@@ -1,2 +1,5 @@
-target_sources(${FSFW_TEST_TGT} PRIVATE testCommandExecutor.cpp
-                                        testHostFilesystem.cpp testFsMock.cpp)
+target_sources(${FSFW_TEST_TGT} PRIVATE testHostFilesystem.cpp testFsMock.cpp)
+
+if(UNIX)
+  target_sources(${FSFW_TEST_TGT} PRIVATE testCommandExecutor.cpp)
+endif()

unittests/mocks/AcceptsTmMock.cpp

@@ -6,7 +6,7 @@ AcceptsTmMock::AcceptsTmMock(object_id_t registeredId, MessageQueueId_t queueToR
 AcceptsTmMock::AcceptsTmMock(MessageQueueId_t queueToReturn)
     : SystemObject(objects::NO_OBJECT, false), returnedQueue(queueToReturn) {}
 
-MessageQueueId_t AcceptsTmMock::getReportReceptionQueue(uint8_t virtualChannel) {
+MessageQueueId_t AcceptsTmMock::getReportReceptionQueue(uint8_t virtualChannel) const {
   return returnedQueue;
 }
 

unittests/mocks/AcceptsTmMock.h

@@ -9,7 +9,7 @@ class AcceptsTmMock : public SystemObject, public AcceptsTelemetryIF {
   AcceptsTmMock(object_id_t registeredId, MessageQueueId_t queueToReturn);
   explicit AcceptsTmMock(MessageQueueId_t queueToReturn);
 
-  MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel) override;
+  MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel) const override;
   const char* getName() const override;
 
   MessageQueueId_t returnedQueue;

unittests/mocks/StorageManagerMock.cpp

@@ -1,11 +1,11 @@
 #include "StorageManagerMock.h"
 
 ReturnValue_t StorageManagerMock::addData(store_address_t *storageId, const uint8_t *data,
-                                          size_t size, bool ignoreFault) {
+                                          size_t size) {
   if (nextAddDataCallFails.first) {
     return nextAddDataCallFails.second;
   }
-  return LocalPool::addData(storageId, data, size, ignoreFault);
+  return LocalPool::addData(storageId, data, size);
 }
 ReturnValue_t StorageManagerMock::deleteData(store_address_t packet_id) {
   if (nextDeleteDataCallFails.first) {
@@ -36,11 +36,11 @@ ReturnValue_t StorageManagerMock::modifyData(store_address_t packet_id, uint8_t
 }
 
 ReturnValue_t StorageManagerMock::getFreeElement(store_address_t *storageId, size_t size,
-                                                 uint8_t **p_data, bool ignoreFault) {
+                                                 uint8_t **p_data) {
   if (nextFreeElementCallFails.first) {
     return nextFreeElementCallFails.second;
   }
-  return LocalPool::getFreeElement(storageId, size, p_data, ignoreFault);
+  return LocalPool::getFreeElement(storageId, size, p_data);
 }
 
 bool StorageManagerMock::hasDataAtId(store_address_t storeId) const {

unittests/mocks/StorageManagerMock.h

@@ -8,15 +8,13 @@ class StorageManagerMock : public LocalPool {
  public:
   StorageManagerMock(object_id_t setObjectId, const LocalPoolConfig &poolConfig);
 
-  ReturnValue_t addData(store_address_t *storageId, const uint8_t *data, size_t size,
-                        bool ignoreFault) override;
+  ReturnValue_t addData(store_address_t *storageId, const uint8_t *data, size_t size) override;
   ReturnValue_t deleteData(store_address_t packet_id) override;
   ReturnValue_t deleteData(uint8_t *buffer, size_t size, store_address_t *storeId) override;
   ReturnValue_t getData(store_address_t packet_id, const uint8_t **packet_ptr,
                         size_t *size) override;
   ReturnValue_t modifyData(store_address_t packet_id, uint8_t **packet_ptr, size_t *size) override;
-  ReturnValue_t getFreeElement(store_address_t *storageId, size_t size, uint8_t **p_data,
-                               bool ignoreFault) override;
+  ReturnValue_t getFreeElement(store_address_t *storageId, size_t size, uint8_t **p_data) override;
   [[nodiscard]] bool hasDataAtId(store_address_t storeId) const override;
   void clearStore() override;
   void clearSubPool(uint8_t poolIndex) override;

unittests/util/testDataWrapper.cpp

@@ -1,55 +0,0 @@
-#include <array>
-#include <catch2/catch_test_macros.hpp>
-
-#include "fsfw/util/dataWrapper.h"
-#include "mocks/SimpleSerializable.h"
-
-TEST_CASE("Data Wrapper", "[util]") {
-  util::DataWrapper wrapper;
-  SECTION("State") {
-    REQUIRE(wrapper.isNull());
-    REQUIRE(wrapper.type == util::DataTypes::NONE);
-  }
-
-  SECTION("Set Raw Data") {
-    util::DataWrapper* instance = &wrapper;
-    bool deleteInst = false;
-    REQUIRE(wrapper.isNull());
-    std::array<uint8_t, 4> data = {1, 2, 3, 4};
-    SECTION("Setter") { wrapper.setRawData({data.data(), data.size()}); }
-    SECTION("Direct Construction Pair") {
-      instance = new util::DataWrapper(util::BufPair(data.data(), data.size()));
-      deleteInst = true;
-    }
-    SECTION("Direct Construction Single Args") {
-      instance = new util::DataWrapper(data.data(), data.size());
-      deleteInst = true;
-    }
-    REQUIRE(not instance->isNull());
-    REQUIRE(instance->type == util::DataTypes::RAW);
-    REQUIRE(instance->dataUnion.raw.data == data.data());
-    REQUIRE(instance->dataUnion.raw.len == data.size());
-    if (deleteInst) {
-      delete instance;
-    }
-  }
-
-  SECTION("Simple Serializable") {
-    util::DataWrapper* instance = &wrapper;
-    bool deleteInst = false;
-    REQUIRE(instance->isNull());
-    SimpleSerializable serializable;
-    SECTION("Setter") { wrapper.setSerializable(serializable); }
-    SECTION("Direct Construction") {
-      instance = new util::DataWrapper(serializable);
-      deleteInst = true;
-    }
-
-    REQUIRE(not instance->isNull());
-    REQUIRE(instance->type == util::DataTypes::SERIALIZABLE);
-    REQUIRE(instance->dataUnion.serializable == &serializable);
-    if (deleteInst) {
-      delete instance;
-    }
-  }
-}