possiible leak fixes

Reviewed-on: fsfw/fsfw#715

CHANGELOG.md

@@ -12,6 +12,20 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Fixes
 
+- `CService200ModeManagement`: Various bugfixes which lead to now execution complete being generated
+  on mode announcements, duplicate mode reply generated on announce commands, and the mode read
+  subservice not working properly.
+- `Service9TimeManagement`: Fix the time dump at the `SET_TIME` subservice: Include clock timeval
+  seconds instead of uptime.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/726
+- HAL MGM3100 Handler: Use axis specific gain/scaling factors. Previously,
+  only the X scaling factor was used.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/724
+- DHB `setNormalDatapoolEntriesInvalid`: The default implementation did not set the validity
+  to false correctly because the `read` and `write` calls were missing.
+- PUS TMTC creator module: Sequence flags were set to continuation segment (0b00) instead
+  of the correct unsegmented flags (0b11) as specified in the standard.
+- TC Scheduler Service 11: Add size and CRC check for contained TC.
 - Only delete health table entry in `HealthHelper` destructor if
   health table was set.
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/710/files
@@ -27,6 +41,15 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Added
 
+- `CServiceHealthCommanding`: Add announce all health info implementation
+  PR: https://egit.irs.uni-stuttgart.de/eive/fsfw/pulls/122
+- `Service9TimeManagement`: Add `DUMP_TIME` (129) subservice.
+- `TcpTmTcServer`: Allow setting the `SO_REUSEADDR` and `SO_REUSEPORT`
+  option on the TCP server. CTOR prototype has changed and expects an explicit
+  TCP configuration struct to be passed.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/722
+- `DleParser` helper class to parse DLE encoded packets from a byte stream.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/711
 - `UioMapper` is able to resolve symlinks now.
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/709
 - Add new `UnsignedByteField` class
@@ -34,6 +57,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Changes
 
+- `CService201HealthCommanding` renamed to `CServiceHealthCommanding`,
+  service ID customizable now. `CServiceHealthCommanding` expects configuration struct
+  `HealthServiceCfg` now
+  PR: https://egit.irs.uni-stuttgart.de/eive/fsfw/pulls/122
 - `AcceptsTelemetryIF`: `getReportReceptionQueue` is const now
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/712
 - Moved some container returnvalues to dedicated header and namespace
@@ -98,6 +125,16 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
      implementation without an extra component
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/682
 
+## HAL
+
+- SPI: Cache the SPI device in the communication interface. Architecturally, this makes a
+  lot more sense because each ComIF should be responsible for one SPI bus.
+- SPI: Move the empty transfer to update the line polarity to separate function. This means
+  it is not automatically called when calling the setter function for SPI speed and mode.
+  The user should call this function after locking the CS mutex if multiple SPI devices with
+  differing speeds and modes are attached to one bus.
+- SPI: Getter functions for SPI speed and mode.
+
 # [v5.0.0] 25.07.2022
 
 ## Changes
@@ -231,6 +268,7 @@ https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593
     - https://gitlab.kitware.com/cmake/cmake/-/issues/21696
   Easiest solution for now: Keep this option OFF by default.
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/616
+- Linux HAL: Add wiretapping option for I2C. Enabled with `FSFW_HAL_I2C_WIRETAPPING` defined to 1
 - Dedicated Version class and constant `fsfw::FSFW_VERSION` containing version information
   inside `fsfw/version.h`
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/559
@@ -245,17 +283,6 @@ https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
 - `Subsystem`: New API to add table and sequence entries
 
-## HAL
-
-- SPI: Cache the SPI device in the communication interface. Architecturally, this makes a
-  lot more sense because each ComIF should be responsible for one SPI bus.
-- SPI: Move the empty transfer to update the line polarity to separate function. This means
-  it is not automatically called when calling the setter function for SPI speed and mode.
-  The user should call this function after locking the CS mutex if multiple SPI devices with
-  differing speeds and modes are attached to one bus.
-- SPI: Getter functions for SPI speed and mode.
-- I2C: Add wiretapping option for I2C. Enabled with `FSFW_HAL_I2C_WIRETAPPING` defined to 1.
-
 ## Fixed
 
 - TCP TMTC Server: `MutexGuard` was not created properly in

automation/Jenkinsfile

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

src/fsfw/controller/ControllerBase.cpp

@@ -109,5 +109,5 @@ 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);
+  return modetree::connectModeTreeParent(parent, *this, &healthHelper, modeHelper);
 }

src/fsfw/devicehandlers/DeviceHandlerBase.cpp

@@ -1,5 +1,6 @@
 #include "DeviceHandlerBase.h"
 
+#include "fsfw/datapool/PoolReadGuard.h"
 #include "fsfw/datapoollocal/LocalPoolVariable.h"
 #include "fsfw/devicehandlers/AcceptsDeviceResponsesIF.h"
 #include "fsfw/devicehandlers/DeviceTmReportingWrapper.h"
@@ -1524,7 +1525,10 @@ DeviceCommandId_t DeviceHandlerBase::getPendingCommand() const {
 void DeviceHandlerBase::setNormalDatapoolEntriesInvalid() {
   for (const auto& reply : deviceReplyMap) {
     if (reply.second.dataSet != nullptr) {
-      reply.second.dataSet->setValidity(false, true);
+      PoolReadGuard pg(reply.second.dataSet);
+      if (pg.getReadResult() == returnvalue::OK) {
+        reply.second.dataSet->setValidity(false, true);
+      }
     }
   }
 }
@@ -1608,7 +1612,7 @@ void DeviceHandlerBase::disableCommandsAndReplies() {
 }
 
 ReturnValue_t DeviceHandlerBase::connectModeTreeParent(HasModeTreeChildrenIF& parent) {
-  return modetree::connectModeTreeParent(parent, *this, healthHelper, modeHelper);
+  return modetree::connectModeTreeParent(parent, *this, &healthHelper, modeHelper);
 }
 
 const HasHealthIF* DeviceHandlerBase::getOptHealthIF() const { return this; }

src/fsfw/events/EventManager.cpp

@@ -24,6 +24,7 @@ EventManager::EventManager(object_id_t setObjectId)
 }
 
 EventManager::~EventManager() {
+  listenerList.clear();
   QueueFactory::instance()->deleteMessageQueue(eventReportQueue);
   MutexFactory::instance()->deleteMutex(mutex);
 }
@@ -73,9 +74,14 @@ ReturnValue_t EventManager::registerListener(MessageQueueId_t listener,
   if (!result.second) {
     return returnvalue::FAILED;
   }
+
   return returnvalue::OK;
 }
 
+ReturnValue_t EventManager::unregisterListener(MessageQueueId_t listener) {
+  return listenerList.erase(listener) == 1 ? returnvalue::OK : returnvalue::FAILED;
+}
+
 ReturnValue_t EventManager::subscribeToEvent(MessageQueueId_t listener, EventId_t event) {
   return subscribeToEventRange(listener, event);
 }

src/fsfw/events/EventManager.h

@@ -31,6 +31,7 @@ class EventManager : public EventManagerIF, public ExecutableObjectIF, public Sy
   MessageQueueId_t getEventReportQueue();
 
   ReturnValue_t registerListener(MessageQueueId_t listener, bool forwardAllButSelected = false);
+  ReturnValue_t unregisterListener(MessageQueueId_t listener) override;
   ReturnValue_t subscribeToEvent(MessageQueueId_t listener, EventId_t event);
   ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener, object_id_t object);
   ReturnValue_t subscribeToEventRange(MessageQueueId_t listener, EventId_t idFrom = 0,

src/fsfw/events/EventManagerIF.h

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

src/fsfw/fdir/FailureIsolationBase.cpp

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

src/fsfw/globalfunctions/matching/MatchTree.h

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

src/fsfw/health/HealthTable.cpp

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

src/fsfw/health/HealthTable.h

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

src/fsfw/internalerror/InternalErrorReporter.cpp

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

src/fsfw/modes/ModeMessage.cpp

@@ -34,3 +34,9 @@ void ModeMessage::setModeAnnounceMessage(CommandMessage& message, bool recursive
   }
   message.setCommand(cmd);
 }
+
+void ModeMessage::setCmdModeMessage(CommandMessage& message, Mode_t mode, Submode_t submode) {
+  setModeMessage(&message, CMD_MODE_COMMAND, mode, submode);
+}
+
+void ModeMessage::setModeReadMessage(CommandMessage& message) { message.setCommand(CMD_MODE_READ); }

src/fsfw/modes/ModeMessage.h

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

src/fsfw/objectmanager/ObjectManager.cpp

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

src/fsfw/objectmanager/ObjectManager.h

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

src/fsfw/osal/CMakeLists.txt

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

src/fsfw/osal/common/TcpTmTcServer.cpp

@@ -26,12 +26,12 @@
 const std::string TcpTmTcServer::DEFAULT_SERVER_PORT = tcpip::DEFAULT_SERVER_PORT;
 
 TcpTmTcServer::TcpTmTcServer(object_id_t objectId, object_id_t tmtcTcpBridge,
-                             size_t receptionBufferSize, size_t ringBufferSize,
-                             std::string customTcpServerPort, ReceptionModes receptionMode)
+                             TcpTmTcServer::TcpConfig cfg, size_t receptionBufferSize,
+                             size_t ringBufferSize, ReceptionModes receptionMode)
     : SystemObject(objectId),
       tmtcBridgeId(tmtcTcpBridge),
       receptionMode(receptionMode),
-      tcpConfig(std::move(customTcpServerPort)),
+      tcpConfig(cfg),
       receptionBuffer(receptionBufferSize),
       ringBuffer(ringBufferSize, true) {}
 
@@ -91,6 +91,15 @@ ReturnValue_t TcpTmTcServer::initialize() {
     return returnvalue::FAILED;
   }
 
+  if (tcpConfig.reuseAddr) {
+    unsigned int enable = 1;
+    setsockopt(listenerTcpSocket, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable));
+  }
+  if (tcpConfig.reusePort) {
+    unsigned int enable = 1;
+    setsockopt(listenerTcpSocket, SOL_SOCKET, SO_REUSEPORT, &enable, sizeof(enable));
+  }
+
   // Bind to the address found by getaddrinfo
   retval = bind(listenerTcpSocket, addrResult->ai_addr, static_cast<int>(addrResult->ai_addrlen));
   if (retval == SOCKET_ERROR) {

src/fsfw/osal/common/TcpTmTcServer.h

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

src/fsfw/osal/linux/MessageQueue.cpp

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

src/fsfw/osal/osal.h.in

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

src/fsfw/pus/CMakeLists.txt

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

src/fsfw/pus/CService200ModeCommanding.cpp

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

src/fsfw/pus/CService201HealthCommanding.cpp

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

src/fsfw/pus/CServiceHealthCommanding.cpp

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

src/fsfw/pus/CServiceHealthCommanding.h

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

src/fsfw/pus/Service11TelecommandScheduling.h

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

src/fsfw/pus/Service11TelecommandScheduling.tpp

@@ -2,9 +2,11 @@
 
 #include <cstddef>
 
+#include "fsfw/globalfunctions/CRC.h"
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/serialize/SerializeAdapter.h"
 #include "fsfw/serviceinterface.h"
+#include "fsfw/tmtcpacket/pus/tc/PusTcIF.h"
 #include "fsfw/tmtcservices/AcceptsTelecommandsIF.h"
 
 static constexpr auto DEF_END = SerializeIF::Endianness::BIG;
@@ -171,6 +173,14 @@ inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::doInsertActivi
     return returnvalue::FAILED;
   }
 
+  if (size < PusTcIF::MIN_SIZE) {
+    return CONTAINED_TC_TOO_SMALL;
+  }
+
+  if (CRC::crc16ccitt(data, size) != 0) {
+    return CONTAINED_TC_CRC_MISSMATCH;
+  }
+
   // store currentPacket and receive the store address
   store_address_t addr{};
   if (tcStore->addData(&addr, data, size) != returnvalue::OK ||

src/fsfw/pus/Service20ParameterManagement.cpp

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

src/fsfw/pus/Service9TimeManagement.cpp

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

src/fsfw/pus/Service9TimeManagement.h

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

src/fsfw/subsystem/SubsystemBase.cpp

@@ -195,7 +195,7 @@ ReturnValue_t SubsystemBase::checkTable(HybridIterator<ModeListEntry> 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
+      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
@@ -284,7 +284,7 @@ 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);
+  return modetree::connectModeTreeParent(parent, *this, &healthHelper, modeHelper);
 }
 
 object_id_t SubsystemBase::getObjectId() const { return SystemObject::getObjectId(); }

src/fsfw/subsystem/helper.cpp

@@ -2,12 +2,14 @@
 
 ReturnValue_t modetree::connectModeTreeParent(HasModeTreeChildrenIF& parent,
                                               const ModeTreeChildIF& child,
-                                              HealthHelper& healthHelper, ModeHelper& modeHelper) {
+                                              HealthHelper* healthHelper, ModeHelper& modeHelper) {
   ReturnValue_t result = parent.registerChild(child);
   if (result != returnvalue::OK) {
     return result;
   }
-  healthHelper.setParentQueue(parent.getCommandQueue());
+  if (healthHelper != nullptr) {
+    healthHelper->setParentQueue(parent.getCommandQueue());
+  }
   modeHelper.setParentQueue(parent.getCommandQueue());
   return returnvalue::OK;
 }

src/fsfw/subsystem/helper.h

@@ -7,7 +7,7 @@
 namespace modetree {
 
 ReturnValue_t connectModeTreeParent(HasModeTreeChildrenIF& parent, const ModeTreeChildIF& child,
-                                    HealthHelper& healthHelper, ModeHelper& modeHelper);
+                                    HealthHelper* healthHelper, ModeHelper& modeHelper);
 
 }
 

src/fsfw/timemanager/CCSDSTime.cpp

@@ -246,20 +246,6 @@ 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,8 +207,7 @@ 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/tmstorage/TmStoreFrontendIF.h

@@ -6,12 +6,47 @@
 #include "fsfw/returnvalues/returnvalue.h"
 #include "tmStorageConf.h"
 
-class PusTmReader;
-class SpacePacketReader;
+class TmPacketMinimal;
+class SpacePacketBase;
 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);
@@ -22,38 +57,7 @@ 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() = 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;
+  virtual ~TmStoreFrontendIF() {}
 };
 
 #endif /* FSFW_TMTCSERVICES_TMSTOREFRONTENDIF_H_ */

src/fsfw/tmstorage/TmStoreFrontendSimpleIF.h

@@ -1,14 +0,0 @@
-#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,10 +1,6 @@
 #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"
@@ -28,7 +24,7 @@ class ServiceSubservice : public SerialLinkedListAdapter<SerializeIF> {
 
 class ApidSsc : public SerializeIF {
  public:
-  ApidSsc() : apid(ccsds::LIMIT_APID), ssc(0) {}
+  ApidSsc() : apid(SpacePacketBase::LIMIT_APID), ssc(0) {}
   ApidSsc(uint16_t apid, uint16_t ssc) : apid(apid), ssc(ssc) {}
   uint16_t apid;
   uint16_t ssc;
@@ -66,59 +62,51 @@ class ChangeSelectionDefinition : public SerialLinkedListAdapter<SerializeIF> {
 
 class TmPacketInformation : public SerializeIF {
  public:
-  TmPacketInformation(PusTmReader* packet, size_t timestampLen) : rawTimestamp(timestampLen) {
-    setContent(packet);
-  }
-  TmPacketInformation(size_t timestampLen)
-      : apid(ccsds::LIMIT_APID),
+  TmPacketInformation(TmPacketMinimal* packet) { setContent(packet); }
+  TmPacketInformation()
+      : apid(SpacePacketBase::LIMIT_APID),
         sourceSequenceCount(0),
         serviceType(0),
         serviceSubtype(0),
-        subCounter(0),
-        rawTimestamp(timestampLen) {}
+        subCounter(0) {}
   void reset() {
-    apid = ccsds::LIMIT_APID;
+    apid = SpacePacketBase::LIMIT_APID;
     sourceSequenceCount = 0;
     serviceType = 0;
     serviceSubtype = 0;
     subCounter = 0;
-    memset(rawTimestamp.data(), 0, rawTimestamp.size());
+    memset(rawTimestamp, 0, sizeof(rawTimestamp));
   }
-  void setContent(PusTmReader* packet) {
-    apid = packet->getApid();
-    sourceSequenceCount = packet->getSequenceCount();
+  void setContent(TmPacketMinimal* packet) {
+    apid = packet->getAPID();
+    sourceSequenceCount = packet->getPacketSequenceCount();
     serviceType = packet->getService();
     serviceSubtype = packet->getSubService();
-    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));
+    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));
   }
   void setContent(TmPacketInformation* content) {
     apid = content->apid;
@@ -126,10 +114,9 @@ class TmPacketInformation : public SerializeIF {
     serviceType = content->serviceType;
     serviceSubtype = content->serviceSubtype;
     subCounter = content->subCounter;
-    // TODO: Fix
-    // memcpy(rawTimestamp, content->rawTimestamp, sizeof(rawTimestamp));
+    memcpy(rawTimestamp, content->rawTimestamp, sizeof(rawTimestamp));
   }
-  bool isValid() const { return (apid < ccsds::LIMIT_APID) ? true : false; }
+  bool isValid() const { return (apid < SpacePacketBase::LIMIT_APID) ? true : false; }
   static void reset(TmPacketInformation* packet) { packet->reset(); }
 
   static bool isOlderThan(const TmPacketInformation* packet, const timeval* cmpTime) {
@@ -229,7 +216,7 @@ class TmPacketInformation : public SerializeIF {
     if (result != returnvalue::OK) {
       return result;
     }
-    SerialBufferAdapter<uint8_t> adapter(rawTimestamp.data(), rawTimestamp.size());
+    SerialBufferAdapter<uint8_t> adapter(rawTimestamp, sizeof(rawTimestamp));
     return adapter.serialize(buffer, size, maxSize, streamEndianness);
   }
 
@@ -240,7 +227,7 @@ class TmPacketInformation : public SerializeIF {
     size += SerializeAdapter::getSerializedSize(&serviceType);
     size += SerializeAdapter::getSerializedSize(&serviceSubtype);
     size += SerializeAdapter::getSerializedSize(&subCounter);
-    SerialBufferAdapter<uint8_t> adapter(rawTimestamp.data(), rawTimestamp.size());
+    SerialBufferAdapter<uint8_t> adapter(rawTimestamp, sizeof(rawTimestamp));
     size += adapter.getSerializedSize();
     return size;
   };
@@ -266,7 +253,7 @@ class TmPacketInformation : public SerializeIF {
     if (result != returnvalue::OK) {
       return result;
     }
-    SerialBufferAdapter<uint8_t> adapter(rawTimestamp.data(), rawTimestamp.size());
+    SerialBufferAdapter<uint8_t> adapter(rawTimestamp, sizeof(rawTimestamp));
     return adapter.deSerialize(buffer, size, streamEndianness);
   }
 
@@ -276,6 +263,6 @@ class TmPacketInformation : public SerializeIF {
   uint8_t serviceType;
   uint8_t serviceSubtype;
   uint8_t subCounter;
-  std::vector<uint8_t> rawTimestamp;
+  uint8_t rawTimestamp[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
 };
 #endif /* FSFW_TMSTORAGE_TMSTOREPACKETS_H_ */

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

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

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

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

src/fsfw/tmtcservices/SourceSequenceCounter.h

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

src/fsfw/tmtcservices/TmTcBridge.cpp

@@ -145,13 +145,17 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 #endif /* FSFW_VERBOSE_LEVEL >= 3 */
 
     if (communicationLinkUp == false or packetSentCounter >= sentPacketsPerCycle) {
-      storeDownlinkData(&message);
+      ReturnValue_t result = storeDownlinkData(&message);
+      if (result != returnvalue::OK) {
+        tmStore->deleteData(message.getStorageId());
+      }
       continue;
     }
 
     result = tmStore->getData(message.getStorageId(), &data, &size);
     if (result != returnvalue::OK) {
       status = result;
+      tmStore->deleteData(message.getStorageId());
       continue;
     }
 
@@ -159,9 +163,9 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
     if (result != returnvalue::OK) {
       status = result;
     } else {
-      tmStore->deleteData(message.getStorageId());
       packetSentCounter++;
     }
+    tmStore->deleteData(message.getStorageId());
   }
   return status;
 }

src/fsfw_hal/devicehandlers/MgmRM3100Handler.cpp

@@ -325,12 +325,12 @@ ReturnValue_t MgmRM3100Handler::handleDataReadout(const uint8_t *packet) {
   // trickery here to calculate the raw values first
   int32_t fieldStrengthRawX = ((packet[1] << 24) | (packet[2] << 16) | (packet[3] << 8)) >> 8;
   int32_t fieldStrengthRawY = ((packet[4] << 24) | (packet[5] << 16) | (packet[6] << 8)) >> 8;
-  int32_t fieldStrengthRawZ = ((packet[7] << 24) | (packet[8] << 16) | (packet[3] << 8)) >> 8;
+  int32_t fieldStrengthRawZ = ((packet[7] << 24) | (packet[8] << 16) | (packet[9] << 8)) >> 8;
 
   // Now scale to physical value in microtesla
   float fieldStrengthX = fieldStrengthRawX * scaleFactorX;
-  float fieldStrengthY = fieldStrengthRawY * scaleFactorX;
-  float fieldStrengthZ = fieldStrengthRawZ * scaleFactorX;
+  float fieldStrengthY = fieldStrengthRawY * scaleFactorY;
+  float fieldStrengthZ = fieldStrengthRawZ * scaleFactorZ;
 
   if (periodicPrintout) {
     if (debugDivider.checkAndIncrement()) {

src/fsfw_hal/linux/i2c/I2cComIF.cpp

@@ -183,10 +183,6 @@ ReturnValue_t I2cComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLe
     }
 #else
 #endif
-#endif
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::debug << "I2cComIF::requestReceiveMessage: Read " << readLen << " of " << requestLen
-               << " bytes" << std::endl;
 #endif
     return returnvalue::FAILED;
   }

src/fsfw_hal/linux/serial/SerialComIF.cpp

@@ -2,6 +2,7 @@
 
 #include <errno.h>
 #include <fcntl.h>
+#include <fsfw_hal/linux/serial/SerialComIF.h>
 #include <termios.h>
 #include <unistd.h>
 

unittests/CatchSetup.cpp

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

unittests/devicehandler/DeviceHandlerCommander.cpp

@@ -9,7 +9,9 @@ DeviceHandlerCommander::DeviceHandlerCommander(object_id_t objectId)
       QUEUE_SIZE, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
 
-DeviceHandlerCommander::~DeviceHandlerCommander() {}
+DeviceHandlerCommander::~DeviceHandlerCommander() {
+  QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
 
 ReturnValue_t DeviceHandlerCommander::performOperation(uint8_t operationCode) {
   readCommandQueue();

unittests/osal/TestSemaphore.cpp

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

unittests/testcfg/devices/logicalAddresses.h

@@ -7,7 +7,7 @@
 
 namespace addresses {
 /* Logical addresses have uint32_t datatype */
-enum logicalAddresses : address_t {};
+enum LogicAddress : address_t {};
 }  // namespace addresses
 
 #endif /* CONFIG_DEVICES_LOGICALADDRESSES_H_ */