that should do the job

Reviewed-on: fsfw/fsfw#694

CHANGELOG.md

@@ -10,16 +10,17 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 # [v6.0.0]
 
+## Fixes
+
+- Bugfix for Serial Buffer Stream: Setting `doActive` to false now
+  actually fully disables printing.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/680
+- `TcpTmTcServer.cpp`: The server was actually not able to handle
+  CCSDS packets which were clumped together. This has been fixed now.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/673
+
 ## 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
 - Add new `UnsignedByteField` class
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/660
 
@@ -32,6 +33,23 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
   for other modules
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/655
   which also includes a migration guide
+- Bump Catch2 dependency to regular version `v3.1.0`
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/678
+- `SerialBufferAdapter`: Rename `setBuffer` to `setConstBuffer` and update
+  API to expect `const uint8_t*` accordingly.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/677
+- Remove the following user includes from `fsfw/events/Event.h` and
+  `fsfw/returnvalues/returnvalue.h`:
+  - `#include "events/subsystemIdRanges.h"`
+  - `#include "returnvalues/classIds.h"`
+  The user has to include those themselves now
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/675
+- `DeviceHandlerBase`: Set command sender before calling `buildCommandFromCommand`.
+  This allows finishing action commands immediately inside the function.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/672
+- `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
 
 # [v5.0.0] 25.07.2022
 
@@ -166,6 +184,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
@@ -180,17 +199,6 @@ https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
 - `Subsystem`: New API to add table and sequence entries
 
-## HAL
-
-- SPI: Cache the SPI device in the communication interface. Architecturally, this makes a
-  lot more sense because each ComIF should be responsible for one SPI bus.
-- SPI: Move the empty transfer to update the line polarity to separate function. This means
-  it is not automatically called when calling the setter function for SPI speed and mode.
-  The user should call this function after locking the CS mutex if multiple SPI devices with
-  differing speeds and modes are attached to one bus.
-- SPI: Getter functions for SPI speed and mode.
-- I2C: Add wiretapping option for I2C. Enabled with `FSFW_HAL_I2C_WIRETAPPING` defined to 1.
-
 ## Fixed
 
 - TCP TMTC Server: `MutexGuard` was not created properly in

CMakeLists.txt

@@ -80,7 +80,7 @@ set(FSFW_CATCH2_LIB_MAJOR_VERSION
     3
     CACHE STRING "Catch2 library major version requirement")
 set(FSFW_CATCH2_LIB_VERSION
-    v${FSFW_CATCH2_LIB_MAJOR_VERSION}.0.0-preview5
+    v${FSFW_CATCH2_LIB_MAJOR_VERSION}.1.0
     CACHE STRING "Catch2 library exact version requirement")
 
 # Keep this off by default for now. See PR:
@@ -195,7 +195,7 @@ message(
 )
 
 # Check whether the user has already installed ETL first
-find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} CONFIG QUIET)
+find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} QUIET)
 # Not installed, so use FetchContent to download and provide etl
 if(NOT ${FSFW_ETL_LIB_NAME}_FOUND)
   message(
@@ -326,7 +326,8 @@ if(FSFW_BUILD_TESTS)
             "/usr/local/include/*"
             "*/fsfw_tests/*"
             "*/catch2-src/*"
-            "*/fsfw_hal/*")
+            "*/fsfw_hal/*"
+            "unittests/*")
       endif()
 
       target_link_options(${FSFW_TEST_TGT} PRIVATE -fprofile-arcs
@@ -345,7 +346,8 @@ if(FSFW_BUILD_TESTS)
       else()
         setup_target_for_coverage_lcov(
           NAME ${FSFW_TEST_TGT}_coverage EXECUTABLE ${FSFW_TEST_TGT}
-          DEPENDENCIES ${FSFW_TEST_TGT})
+          DEPENDENCIES ${FSFW_TEST_TGT}
+          GENHTML_ARGS --html-epilog ${CMAKE_SOURCE_DIR}/unittests/lcov_epilog.html)
       endif()
     endif()
   endif()
@@ -360,7 +362,8 @@ if(NOT FSFW_CONFIG_PATH)
   if(NOT FSFW_BUILD_DOCS)
     message(
       WARNING
-        "${MSG_PREFIX} Flight Software Framework configuration path not set")
+        "${MSG_PREFIX} Flight Software Framework configuration path FSFW_CONFIG_PATH not set"
+    )
     message(
       WARNING
         "${MSG_PREFIX} Setting default configuration from ${DEF_CONF_PATH} ..")

README.md

@@ -175,7 +175,7 @@ cmake -DFSFW_BUILD_DOCS=ON -DFSFW_OSAL=host ..
 Then you can generate the documentation using
 
 ```sh
-cmake --build . -j
+cmake --build . -- Sphinx -j
 ```
 
 You can find the generated documentation inside the `docs/sphinx` folder inside the build

automation/Dockerfile

@@ -5,16 +5,25 @@ RUN apt-get --yes upgrade
 
 #tzdata is a dependency, won't install otherwise
 ARG DEBIAN_FRONTEND=noninteractive
-RUN apt-get --yes install gcc g++ cmake make lcov git valgrind nano iputils-ping
+RUN apt-get --yes install gcc g++ cmake make lcov git valgrind nano iputils-ping python3 pip doxygen graphviz rsync
+
+RUN python3 -m pip install sphinx breathe
 
 RUN git clone https://github.com/catchorg/Catch2.git && \
-	cd Catch2 && \
-	git checkout v3.0.0-preview5 && \
-	cmake -Bbuild -H. -DBUILD_TESTING=OFF && \
-	cmake --build build/ --target install
+        cd Catch2 && \
+        git checkout v3.1.0 && \
+        cmake -Bbuild -H. -DBUILD_TESTING=OFF && \
+        cmake --build build/ --target install
 
 RUN git clone https://github.com/ETLCPP/etl.git && \
-	cd etl && \
-	git checkout 20.28.0 && \
-	cmake -B build . && \
-	cmake --install build/
+        cd etl && \
+        git checkout 20.28.0 && \
+        cmake -B build . && \
+        cmake --install build/
+
+#ssh needs a valid user to work
+RUN adduser --uid 114 jenkins
+
+#add documentation server to known hosts
+RUN echo "|1|/LzCV4BuTmTb2wKnD146l9fTKgQ=|NJJtVjvWbtRt8OYqFgcYRnMQyVw= ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBNL8ssTonYtgiR/6RRlSIK9WU1ywOcJmxFTLcEblAwH7oifZzmYq3XRfwXrgfMpylEfMFYfCU8JRqtmi19xc21A=" >> /etc/ssh/ssh_known_hosts
+RUN echo "|1|CcBvBc3EG03G+XM5rqRHs6gK/Gg=|oGeJQ+1I8NGI2THIkJsW92DpTzs= ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBNL8ssTonYtgiR/6RRlSIK9WU1ywOcJmxFTLcEblAwH7oifZzmYq3XRfwXrgfMpylEfMFYfCU8JRqtmi19xc21A=" >> /etc/ssh/ssh_known_hosts

automation/Jenkinsfile

@@ -1,9 +1,13 @@
 pipeline {
     environment {
         BUILDDIR = 'cmake-build-tests'
+        DOCDDIR = 'cmake-build-documentation'
     }
     agent {
-        docker { image 'fsfw-ci:d3'}
+        docker { 
+            image 'fsfw-ci:d6'
+            args '--network host'
+        }
     }
     stages {
         stage('Clean') {
@@ -39,5 +43,43 @@ pipeline {
                 }
             }
         }
+        stage('Documentation') {
+            when {
+                branch 'development'
+            }
+            steps {
+                dir(DOCDDIR) {
+                    sh 'cmake -DFSFW_BUILD_DOCS=ON -DFSFW_OSAL=host ..'
+                    sh 'make Sphinx'
+                    sshagent(credentials: ['documentation-buildfix']) {
+                        sh 'rsync -r --delete docs/sphinx/* buildfix@documentation.irs.uni-stuttgart.de:/fsfw/development'
+                    }
+                }
+                dir(BUILDDIR) {
+                    sshagent(credentials: ['documentation-buildfix']) {
+                        sh 'rsync -r --delete fsfw-tests_coverage/* buildfix@documentation.irs.uni-stuttgart.de:/fsfw/coverage/development'
+                    }
+                }
+            }
+        }
+        stage('Master Documentation') {
+            when {
+                branch 'master'
+            }
+            steps {
+                dir(DOCDDIR) {
+                    sh 'cmake -DFSFW_BUILD_DOCS=ON -DFSFW_OSAL=host ..'
+                    sh 'make Sphinx'
+                    sshagent(credentials: ['documentation-buildfix']) {
+                        sh 'rsync -r --delete docs/sphinx/* buildfix@documentation.irs.uni-stuttgart.de:/fsfw/master'
+                    }
+                }
+                dir(BUILDDIR) {
+                    sshagent(credentials: ['documentation-buildfix']) {
+                        sh 'rsync -r --delete fsfw-tests_coverage/* buildfix@documentation.irs.uni-stuttgart.de:/fsfw/coverage/master'
+                    }
+                }
+            }
+        }
     }
 }

docs/conf.py

@@ -50,6 +50,11 @@ 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"}
+}
+
+
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".

docs/highlevel.rst

@@ -6,13 +6,14 @@ High-level overview
 Structure
 ----------
 
-The general structure is driven by the usage of interfaces provided by objects.
-The FSFW uses C++11 as baseline. The intention behind this is that this C++ Standard should be
-widely available, even with older compilers.
-The FSFW uses dynamic allocation during the initialization but provides static containers during runtime.
-This simplifies the instantiation of objects and allows the usage of some standard containers.
-Dynamic Allocation after initialization is discouraged and different solutions are provided in the
-FSFW to achieve that. The fsfw uses run-time type information but exceptions are not allowed.
+The general structure is driven by the usage of interfaces provided by objects. 
+The FSFW uses C++17 as baseline. Most modern compilers like GCC should have support for this
+standard, even for micocontrollers.
+
+The FSFW might use dynamic allocation during program initialization but not during runtime.
+It offers pool objects, static containers and it also exposes the
+`Embedded Template Library <https://www.etlcpp.com/>`_ to allow writing code which does not perform
+allocation during runtime. The fsfw uses run-time type information but will not throw exceptions.
 
 Failure Handling
 -----------------

misc/defaultcfg/fsfwconfig/FSFWConfig.h

@@ -4,6 +4,10 @@
 #include <cstddef>
 #include <cstdint>
 
+// It is assumed the user has a subsystem and class ID list in some user header files.
+// #include "events/subsystemIdRanges.h"
+// #include "returnvalues/classIds.h"
+
 //! Used to determine whether C++ ostreams are used which can increase
 //! the binary size significantly. If this is disabled,
 //! the C stdio functions can be used alternatively

scripts/helper.py

@@ -199,7 +199,7 @@ def check_for_cmake_build_dir(build_dir_list: list) -> list:
 def perform_lcov_operation(directory: str, chdir: bool):
     if chdir:
         os.chdir(directory)
-    cmd_runner("cmake --build . -- fsfw-tests_coverage -j")
+    cmd_runner("cmake --build -j . -- fsfw-tests_coverage")
 
 
 def determine_build_dir(build_dir_list: List[str]):

src/fsfw/action/CommandActionHelper.h

@@ -16,8 +16,8 @@ class CommandActionHelper {
  public:
   explicit CommandActionHelper(CommandsActionsIF* owner);
   virtual ~CommandActionHelper();
-  ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId,
-                              const uint8_t* data = nullptr, uint32_t size = 0);
+  ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId, const uint8_t* data,
+                              uint32_t size);
   ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId, SerializeIF* data);
   ReturnValue_t initialize();
   ReturnValue_t handleReply(CommandMessage* reply);

src/fsfw/cfdp/CfdpHandler.cpp

@@ -11,9 +11,7 @@ object_id_t CfdpHandler::packetDestination = 0;
 
 CfdpHandler::CfdpHandler(object_id_t setObjectId, CFDPDistributor* dist)
     : SystemObject(setObjectId) {
-  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
-  requestQueue = QueueFactory::instance()->createMessageQueue(
-      CFDP_HANDLER_MAX_RECEPTION, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  requestQueue = QueueFactory::instance()->createMessageQueue(CFDP_HANDLER_MAX_RECEPTION);
   distributor = dist;
 }
 

src/fsfw/cfdp/tlv/Lv.cpp

@@ -21,7 +21,7 @@ cfdp::Lv& cfdp::Lv::operator=(const Lv& other) {
   if (value == nullptr or otherSize == 0) {
     this->zeroLen = true;
   }
-  this->value.setBuffer(value, otherSize);
+  this->value.setConstBuffer(value, otherSize);
   return *this;
 }
 
@@ -70,7 +70,7 @@ ReturnValue_t cfdp::Lv::deSerialize(const uint8_t** buffer, size_t* size,
   }
   zeroLen = false;
   // Zero-copy implementation
-  value.setBuffer(const_cast<uint8_t*>(*buffer + 1), lengthField);
+  value.setConstBuffer(*buffer + 1, lengthField);
   *buffer += 1 + lengthField;
   *size -= 1 + lengthField;
   return returnvalue::OK;

src/fsfw/cfdp/tlv/Tlv.cpp

@@ -75,7 +75,7 @@ ReturnValue_t cfdp::Tlv::deSerialize(const uint8_t **buffer, size_t *size,
   }
   zeroLen = false;
   // Zero-copy implementation
-  value.setBuffer(const_cast<uint8_t *>(*buffer + 1), lengthField);
+  value.setConstBuffer(*buffer + 1, lengthField);
   *buffer += 1 + lengthField;
   *size -= 1 + lengthField;
   return returnvalue::OK;
@@ -96,7 +96,7 @@ void cfdp::Tlv::setValue(uint8_t *value, size_t len) {
   if (len > 0) {
     zeroLen = false;
   }
-  this->value.setBuffer(value, len);
+  this->value.setConstBuffer(value, len);
 }
 
 uint8_t cfdp::Tlv::getLengthField() const { return this->value.getSerializedSize() - 1; }

src/fsfw/controller/ControllerBase.cpp

@@ -13,9 +13,7 @@ ControllerBase::ControllerBase(object_id_t setObjectId, object_id_t parentId,
       submode(SUBMODE_NONE),
       modeHelper(this),
       healthHelper(this, setObjectId) {
-  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
-  commandQueue = QueueFactory::instance()->createMessageQueue(
-      commandQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth);
 }
 
 ControllerBase::~ControllerBase() { QueueFactory::instance()->deleteMessageQueue(commandQueue); }

src/fsfw/datapoollocal/LocalDataPoolManager.cpp

@@ -570,10 +570,6 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(CommandMessage* me
 
   CommandMessage reply;
   if (result != returnvalue::OK) {
-    if (result == WRONG_HK_PACKET_TYPE) {
-      printWarningOrError(sif::OutputTypes::OUT_WARNING, "handleHousekeepingMessage",
-                          WRONG_HK_PACKET_TYPE);
-    }
     HousekeepingMessage::setHkRequestFailureReply(&reply, sid, result);
   } else {
     HousekeepingMessage::setHkRequestSuccessReply(&reply, sid);
@@ -829,8 +825,6 @@ void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
       errorPrint = "Dataset not found";
     } else if (error == POOLOBJECT_NOT_FOUND) {
       errorPrint = "Pool Object not found";
-    } else if (error == WRONG_HK_PACKET_TYPE) {
-      errorPrint = "Wrong Packet Type";
     } else if (error == returnvalue::FAILED) {
       if (outputType == sif::OutputTypes::OUT_WARNING) {
         errorPrint = "Generic Warning";

src/fsfw/datapoollocal/LocalPoolDataSetBase.h

@@ -162,7 +162,6 @@ class LocalPoolDataSetBase : public PoolDataSetBase, public MarkChangedIF {
   object_id_t getCreatorObjectId();
 
   bool getReportingEnabled() const;
-  void setReportingEnabled(bool enabled);
 
   /**
    * Returns the current periodic HK generation interval this set
@@ -190,6 +189,7 @@ class LocalPoolDataSetBase : public PoolDataSetBase, public MarkChangedIF {
    * Used for periodic generation.
    */
   bool reportingEnabled = false;
+  void setReportingEnabled(bool enabled);
 
   void initializePeriodicHelper(float collectionInterval, dur_millis_t minimumPeriodicInterval,
                                 uint8_t nonDiagIntervalFactor = 5);

src/fsfw/devicehandlers/AssemblyBase.cpp

@@ -26,7 +26,11 @@ void AssemblyBase::performChildOperation() {
 
 void AssemblyBase::startTransition(Mode_t mode, Submode_t submode) {
   doStartTransition(mode, submode);
-  triggerModeHelperEvents(mode, submode);
+  if (modeHelper.isForced()) {
+    triggerEvent(FORCING_MODE, mode, submode);
+  } else {
+    triggerEvent(CHANGING_MODE, mode, submode);
+  }
 }
 
 void AssemblyBase::doStartTransition(Mode_t mode, Submode_t submode) {
@@ -73,10 +77,9 @@ bool AssemblyBase::handleChildrenChangedHealth() {
   }
   HealthState healthState = healthHelper.healthTable->getHealth(iter->first);
   if (healthState == HasHealthIF::NEEDS_RECOVERY) {
-    triggerEvent(TRYING_RECOVERY, iter->first, 0);
+    triggerEvent(TRYING_RECOVERY);
     recoveryState = RECOVERY_STARTED;
     recoveringDevice = iter;
-    // The user needs to take care of commanding the children off in commandChildren
     doStartTransition(targetMode, targetSubmode);
   } else {
     triggerEvent(CHILD_CHANGED_HEALTH);
@@ -225,9 +228,6 @@ ReturnValue_t AssemblyBase::handleHealthReply(CommandMessage* message) {
 bool AssemblyBase::checkAndHandleRecovery() {
   switch (recoveryState) {
     case RECOVERY_STARTED:
-      // The recovery was already start in #handleChildrenChangedHealth and we just need
-      // to wait for an off time period.
-      // TODO: make time period configurable
       recoveryState = RECOVERY_WAIT;
       recoveryOffTimer.resetTimer();
       return true;
@@ -266,11 +266,3 @@ void AssemblyBase::overwriteDeviceHealth(object_id_t objectId, HasHealthIF::Heal
   modeHelper.setForced(true);
   sendHealthCommand(childrenMap[objectId].commandQueue, EXTERNAL_CONTROL);
 }
-
-void AssemblyBase::triggerModeHelperEvents(Mode_t mode, Submode_t submode) {
-  if (modeHelper.isForced()) {
-    triggerEvent(FORCING_MODE, mode, submode);
-  } else {
-    triggerEvent(CHANGING_MODE, mode, submode);
-  }
-}

src/fsfw/devicehandlers/AssemblyBase.h

@@ -12,8 +12,7 @@
  * Documentation: Dissertation Baetz p.156, 157.
  *
  * This class reduces the complexity of controller components which would
- * otherwise be needed for the handling of redundant devices. However, it can also be used to
- * manage the mode keeping and recovery of non-redundant devices
+ * otherwise be needed for the handling of redundant devices.
  *
  * The template class monitors mode and health state of its children
  * and checks availability of devices on every detected change.
@@ -27,9 +26,11 @@
  *
  * Important:
  *
- * The implementation must call #registerChild for all commanded children during initialization.
+ * The implementation must call registerChild(object_id_t child)
+ * for all commanded children during initialization.
  * The implementation must call the initialization function of the base class.
  * (This will call the function in SubsystemBase)
+ *
  */
 class AssemblyBase : public SubsystemBase {
  public:
@@ -46,10 +47,9 @@ class AssemblyBase : public SubsystemBase {
 
  protected:
   /**
-   * Command children to reach [mode,submode] combination. Can be done by setting
-   * #commandsOutstanding correctly, or using #executeTable. In case of an FDIR recovery,
-   * the user needs to ensure that the target devices are healthy. If a device is not healthy,
-   * a recovery might be on-going and the device needs to be commanded to off first.
+   * Command children to reach [mode,submode] combination
+   * Can be done by setting #commandsOutstanding correctly,
+   * or using executeTable()
    * @param mode
    * @param submode
    * @return
@@ -120,19 +120,8 @@ class AssemblyBase : public SubsystemBase {
 
   virtual ReturnValue_t handleHealthReply(CommandMessage *message);
 
-  /**
-   * @brief Default periodic handler
-   * @details
-   * This is the default periodic handler which will be called by the SubsystemBase
-   * performOperation. It performs the child transitions or reacts to changed health/mode states
-   * of children objects
-   */
-  virtual void performChildOperation() override;
+  virtual void performChildOperation();
 
-  /**
-   * This function handles changed mode or health states of children
-   * @return
-   */
   bool handleChildrenChanged();
 
   /**
@@ -145,37 +134,12 @@ class AssemblyBase : public SubsystemBase {
 
   bool handleChildrenChangedHealth();
 
-  /**
-   * Core transition handler. The default implementation will only do something if
-   * #commandsOutstanding is smaller or equal to zero, which means that all mode commands
-   * from the #doPerformTransition call were executed successfully.
-   *
-   * Unless a second step was requested, the function will then use #checkChildrenState to
-   * determine whether the target mode was reached.
-   *
-   * There is some special handling for certain (internal) modes:
-   *  - A second step is necessary. #commandChildren will be performed again
-   *  - The device health was overwritten. #commandChildren will be called
-   *  - A recovery is ongoing. #checkAndHandleRecovery will be called.
-   */
   virtual void handleChildrenTransition();
 
   ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode, uint32_t *msToReachTheMode);
 
-  /**
-   * Calls #doStartTransition and triggers an informative event as well that the mode will
-   * change
-   * @param mode
-   * @param submode
-   */
   virtual void startTransition(Mode_t mode, Submode_t submode);
 
-  /**
-   * This function starts the transition by setting the internal #targetSubmode and #targetMode
-   * variables and then calling the #commandChildren function.
-   * @param mode
-   * @param submode
-   */
   virtual void doStartTransition(Mode_t mode, Submode_t submode);
 
   virtual bool isInTransition();
@@ -196,7 +160,7 @@ class AssemblyBase : public SubsystemBase {
    * Manages recovery of a device
    * @return true if recovery is still ongoing, false else.
    */
-  virtual bool checkAndHandleRecovery();
+  bool checkAndHandleRecovery();
 
   /**
    * Helper method to overwrite health state of one of the children.
@@ -204,8 +168,6 @@ class AssemblyBase : public SubsystemBase {
    * @param objectId Must be a registered child.
    */
   void overwriteDeviceHealth(object_id_t objectId, HasHealthIF::HealthState oldHealth);
-
-  void triggerModeHelperEvents(Mode_t mode, Submode_t submode);
 };
 
 #endif /* FSFW_DEVICEHANDLERS_ASSEMBLYBASE_H_ */

src/fsfw/devicehandlers/DeviceHandlerBase.cpp

@@ -40,9 +40,8 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, object_id_t device
       childTransitionDelay(5000),
       transitionSourceMode(_MODE_POWER_DOWN),
       transitionSourceSubMode(SUBMODE_NONE) {
-  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
   commandQueue = QueueFactory::instance()->createMessageQueue(
-      cmdQueueSize, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+      cmdQueueSize, MessageQueueMessage::MAX_MESSAGE_SIZE);
   insertInCommandMap(RAW_COMMAND_ID);
   cookieInfo.state = COOKIE_UNUSED;
   cookieInfo.pendingCommand = deviceCommandMap.end();
@@ -50,6 +49,9 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, object_id_t device
     printWarningOrError(sif::OutputTypes::OUT_ERROR, "DeviceHandlerBase", returnvalue::FAILED,
                         "Invalid cookie");
   }
+  if (this->fdirInstance == nullptr) {
+    this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId, defaultFdirParentId);
+  }
 }
 
 void DeviceHandlerBase::setHkDestination(object_id_t hkDestination) {
@@ -127,18 +129,6 @@ ReturnValue_t DeviceHandlerBase::initialize() {
   if (result != returnvalue::OK) {
     return result;
   }
-  if (this->fdirInstance == nullptr) {
-    this->fdirInstance =
-        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);
@@ -374,12 +364,13 @@ void DeviceHandlerBase::doStateMachine() {
       }
     } break;
     case _MODE_WAIT_OFF: {
+      uint32_t currentUptime;
+      Clock::getUptime(&currentUptime);
+
       if (powerSwitcher == nullptr) {
         setMode(MODE_OFF);
         break;
       }
-      uint32_t currentUptime;
-      Clock::getUptime(&currentUptime);
       if (currentUptime - timeoutStart >= powerSwitcher->getSwitchDelayMs()) {
         triggerEvent(MODE_TRANSITION_FAILED, PowerSwitchIF::SWITCH_TIMEOUT, 0);
         setMode(MODE_ERROR_ON);
@@ -580,9 +571,6 @@ void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
   mode = newMode;
   modeChanged();
   setNormalDatapoolEntriesInvalid();
-  if (newMode == MODE_OFF) {
-    disableCommandsAndReplies();
-  }
   if (!isTransitionalMode()) {
     modeHelper.modeChanged(newMode, newSubmode);
     announceMode(false);
@@ -1288,7 +1276,6 @@ void DeviceHandlerBase::handleDeviceTm(const SerializeIF& dataSet, DeviceCommand
   if (iter->second.command != deviceCommandMap.end()) {
     MessageQueueId_t queueId = iter->second.command->second.sendReplyTo;
 
-    // This may fail, but we'll ignore the fault.
     if (queueId != NO_COMMANDER) {
       // This may fail, but we'll ignore the fault.
       actionHelper.reportData(queueId, replyId, const_cast<SerializeIF*>(&dataSet));
@@ -1331,13 +1318,11 @@ ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId, MessageQueue
     return result;
   }
   DeviceCommandMap::iterator iter = deviceCommandMap.find(actionId);
-  MessageQueueId_t prevRecipient = MessageQueueIF::NO_QUEUE;
   if (iter == deviceCommandMap.end()) {
     result = COMMAND_NOT_SUPPORTED;
   } else if (iter->second.isExecuting) {
     result = COMMAND_ALREADY_SENT;
   } else {
-    prevRecipient = iter->second.sendReplyTo;
     iter->second.sendReplyTo = commandedBy;
     result = buildCommandFromCommand(actionId, data, size);
   }
@@ -1345,8 +1330,6 @@ ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId, MessageQueue
     iter->second.isExecuting = true;
     cookieInfo.pendingCommand = iter;
     cookieInfo.state = COOKIE_WRITE_READY;
-  } else {
-    iter->second.sendReplyTo = prevRecipient;
   }
   return result;
 }
@@ -1471,8 +1454,6 @@ void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task) { executingTask = task;
 void DeviceHandlerBase::debugInterface(uint8_t positionTracker, object_id_t objectId,
                                        uint32_t parameter) {}
 
-Submode_t DeviceHandlerBase::getInitialSubmode() { return SUBMODE_NONE; }
-
 void DeviceHandlerBase::performOperationHook() {}
 
 ReturnValue_t DeviceHandlerBase::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
@@ -1495,7 +1476,7 @@ ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
   this->poolManager.initializeAfterTaskCreation();
 
   if (setStartupImmediately) {
-    startTransition(MODE_ON, getInitialSubmode());
+    startTransition(MODE_ON, SUBMODE_NONE);
   }
   return returnvalue::OK;
 }
@@ -1579,29 +1560,3 @@ MessageQueueId_t DeviceHandlerBase::getCommanderQueueId(DeviceCommandId_t replyI
   }
   return commandIter->second.sendReplyTo;
 }
-
-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;
-}
-
-void DeviceHandlerBase::disableCommandsAndReplies() {
-  for (auto& command : deviceCommandMap) {
-    if (command.second.isExecuting) {
-      command.second.isExecuting = false;
-    }
-  }
-  for (auto& reply : deviceReplyMap) {
-    if (!reply.second.periodic) {
-      if (reply.second.countdown != nullptr) {
-        reply.second.countdown->timeOut();
-      } else {
-        reply.second.delayCycles = 0;
-      }
-      reply.second.active = false;
-    }
-  }
-}

src/fsfw/devicehandlers/DeviceHandlerBase.h

@@ -23,7 +23,6 @@
 #include "fsfw/serviceinterface/serviceInterfaceDefintions.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
 #include "fsfw/tasks/PeriodicTaskIF.h"
-#include "fsfw/util/dataWrapper.h"
 
 namespace Factory {
 void setStaticFrameworkObjectIds();
@@ -103,9 +102,6 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication, CookieIF *comCookie,
                     FailureIsolationBase *fdirInstance = nullptr, size_t cmdQueueSize = 20);
 
-  void setCustomFdir(FailureIsolationBase *fdir);
-  void setParent(object_id_t parent);
-  void setPowerSwitcher(PowerSwitchIF *switcher);
   void setHkDestination(object_id_t hkDestination);
 
   /**
@@ -467,14 +463,14 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * @brief 	This is a helper method to insert replies in the reply map.
    * @param deviceCommand	Identifier of the reply to add.
    * @param maxDelayCycles The maximum number of delay cycles the reply waits
-   *    until it times out.
+   * until it times out.
    * @param periodic	Indicates if the command is periodic (i.e. it is sent
-   *    by the device repeatedly without request) or not. Default is aperiodic (0).
-   *    Please note that periodic replies are disabled by default. You can enable them with
-   *    #updatePeriodicReply
+   * by the device repeatedly without request) or not. Default is aperiodic (0).
+   * Please note that periodic replies are disabled by default. You can enable them with
+   * #updatePeriodicReply
    * @param countdown Instead of using maxDelayCycles to timeout a device reply it is also possible
-   *    to provide a pointer to a Countdown object which will signal the timeout
-   *    when expired
+   *                  to provide a pointer to a Countdown object which will signal the timeout
+   *                  when expired
    * @return	- @c returnvalue::OK when the command was successfully inserted,
    *          - @c returnvalue::FAILED else.
    */
@@ -659,12 +655,6 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   virtual void debugInterface(uint8_t positionTracker = 0, object_id_t objectId = 0,
                               uint32_t parameter = 0);
 
-  /**
-   * @brief Can be overwritten by a child to specify the initial submode when device has been set
-   *        to startup immediately.
-   */
-  virtual Submode_t getInitialSubmode();
-
  protected:
   static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;
 
@@ -783,18 +773,11 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * This is used to keep track of pending replies.
    */
   struct DeviceReplyInfo {
-    //! For Command-Reply combinations:
     //! The maximum number of cycles the handler should wait for a reply
     //! to this command.
-    //!
-    //! Reply Only:
-    //! For periodic replies, this variable will be the number of delay cycles between the replies.
-    //! For the non-periodic variant, this variable is not used as there is no meaningful
-    //! definition for delay
     uint16_t maxDelayCycles;
-    //! This variable will be set to #maxDelayCycles if a reply is expected.
-    //! For non-periodic replies without a command, this variable is unused.
-    //! A runtime value of 0 means there is no reply is currently expected.
+    //! The currently remaining cycles the handler should wait for a reply,
+    //! 0 means there is no reply expected
     uint16_t delayCycles;
     size_t replyLen = 0;  //!< Expected size of the reply.
     //! if this is !=0, the delayCycles will not be reset to 0 but to
@@ -850,7 +833,6 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   /** Pointer to the used FDIR instance. If not provided by child,
    * default class is instantiated. */
   FailureIsolationBase *fdirInstance;
-  object_id_t parent = objects::NO_OBJECT;
 
   //! To correctly delete the default instance.
   bool defaultFDIRUsed;
@@ -1070,8 +1052,23 @@ class DeviceHandlerBase : public DeviceHandlerIF,
 
   bool isAwaitingReply();
 
+  /**
+   * Wrapper function for @handleDeviceTm which wraps the raw buffer with @SerialBufferAdapter.
+   * For interpreted data, prefer the other function.
+   * @param rawData
+   * @param rawDataLen
+   * @param replyId
+   * @param forceDirectTm
+   */
   void handleDeviceTm(const uint8_t *rawData, size_t rawDataLen, DeviceCommandId_t replyId,
                       bool forceDirectTm = false);
+  /**
+   * Can be used to handle Service 8 data replies. This will also generate the TM wiretapping
+   * packets accordingly.
+   * @param dataSet
+   * @param replyId
+   * @param forceDirectTm
+   */
   void handleDeviceTm(const SerializeIF &dataSet, DeviceCommandId_t replyId,
                       bool forceDirectTm = false);
 
@@ -1326,11 +1323,6 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   void printWarningOrError(sif::OutputTypes errorType, const char *functionName,
                            ReturnValue_t errorCode = returnvalue::FAILED,
                            const char *errorPrint = nullptr);
-
-  /**
-   * @brief Disables all commands and replies when device is set to MODE_OFF
-   */
-  void disableCommandsAndReplies();
 };
 
 #endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */

src/fsfw/devicehandlers/DeviceHandlerFailureIsolation.cpp

@@ -29,7 +29,6 @@ ReturnValue_t DeviceHandlerFailureIsolation::eventReceived(EventMessage* event)
   switch (event->getEvent()) {
     case HasModesIF::MODE_TRANSITION_FAILED:
     case HasModesIF::OBJECT_IN_INVALID_MODE:
-    case DeviceHandlerIF::DEVICE_WANTS_HARD_REBOOT:
       // We'll try a recovery as long as defined in MAX_REBOOT.
       // Might cause some AssemblyBase cycles, so keep number low.
       handleRecovery(event->getEvent());

src/fsfw/devicehandlers/DeviceHandlerIF.h

@@ -109,7 +109,6 @@ class DeviceHandlerIF {
   static const Event INVALID_DEVICE_COMMAND = MAKE_EVENT(8, severity::LOW);
   static const Event MONITORING_LIMIT_EXCEEDED = MAKE_EVENT(9, severity::LOW);
   static const Event MONITORING_AMBIGUOUS = MAKE_EVENT(10, severity::HIGH);
-  static const Event DEVICE_WANTS_HARD_REBOOT = MAKE_EVENT(11, severity::HIGH);
 
   static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
 

src/fsfw/devicehandlers/DeviceTmReportingWrapper.h

@@ -1,10 +1,9 @@
 #ifndef FSFW_DEVICEHANDLERS_DEVICETMREPORTINGWRAPPER_H_
 #define FSFW_DEVICEHANDLERS_DEVICETMREPORTINGWRAPPER_H_
 
-#include "fsfw/action/HasActionsIF.h"
-#include "fsfw/objectmanager/SystemObjectIF.h"
-#include "fsfw/serialize/SerializeIF.h"
-#include "fsfw/util/dataWrapper.h"
+#include "../action/HasActionsIF.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../serialize/SerializeIF.h"
 
 class DeviceTmReportingWrapper : public SerializeIF {
  public:

src/fsfw/devicehandlers/HealthDevice.cpp

@@ -8,9 +8,7 @@ HealthDevice::HealthDevice(object_id_t setObjectId, MessageQueueId_t parentQueue
       parentQueue(parentQueue),
       commandQueue(),
       healthHelper(this, setObjectId) {
-  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
-  commandQueue = QueueFactory::instance()->createMessageQueue(
-      3, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  commandQueue = QueueFactory::instance()->createMessageQueue(3);
 }
 
 HealthDevice::~HealthDevice() { QueueFactory::instance()->deleteMessageQueue(commandQueue); }

src/fsfw/events/Event.h

@@ -4,8 +4,6 @@
 #include <stdint.h>
 
 #include "fwSubsystemIdRanges.h"
-// could be moved to more suitable location
-#include <events/subsystemIdRanges.h>
 
 using EventId_t = uint16_t;
 using EventSeverity_t = uint8_t;

src/fsfw/events/EventManager.cpp

@@ -18,9 +18,8 @@ const LocalPool::LocalPoolConfig EventManager::poolConfig = {
 EventManager::EventManager(object_id_t setObjectId)
     : SystemObject(setObjectId), factoryBackend(0, poolConfig, false, true) {
   mutex = MutexFactory::instance()->createMutex();
-  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
-  eventReportQueue = QueueFactory::instance()->createMessageQueue(
-      MAX_EVENTS_PER_CYCLE, EventMessage::EVENT_MESSAGE_SIZE, &mqArgs);
+  eventReportQueue = QueueFactory::instance()->createMessageQueue(MAX_EVENTS_PER_CYCLE,
+                                                                  EventMessage::EVENT_MESSAGE_SIZE);
 }
 
 EventManager::~EventManager() {
@@ -47,20 +46,9 @@ ReturnValue_t EventManager::performOperation(uint8_t opCode) {
 
 void EventManager::notifyListeners(EventMessage* message) {
   lockMutex();
-  for (auto& listener : listenerList) {
-    if (listener.second.match(message)) {
-      ReturnValue_t result =
-          MessageQueueSenderIF::sendMessage(listener.first, message, message->getSender());
-      if (result != returnvalue::OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << std::hex << "EventManager::notifyListeners: MSG to 0x" << std::setfill('0')
-                   << std::setw(8) << listener.first << " failed with result 0x" << std::setw(4)
-                   << result << std::setfill(' ') << std::endl;
-#else
-        sif::printError("Sending message to listener 0x%08x failed with result %04x\n",
-                        listener.first, result);
-#endif
-      }
+  for (auto iter = listenerList.begin(); iter != listenerList.end(); ++iter) {
+    if (iter->second.match(message)) {
+      MessageQueueSenderIF::sendMessage(iter->first, message, message->getSender());
     }
   }
   unlockMutex();
@@ -206,19 +194,4 @@ void EventManager::printUtility(sif::OutputTypes printType, EventMessage* messag
   }
 }
 
-void EventManager::printListeners() {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::info << "Event manager listener MQ IDs:" << std::setfill('0') << std::hex << std::endl;
-  for (auto& listener : listenerList) {
-    sif::info << "0x" << std::setw(8) << listener.first << std::endl;
-  }
-  sif::info << std::dec << std::setfill(' ');
-#else
-  sif::printInfo("Event manager listener MQ IDs:\n");
-  for (auto& listener : listenerList) {
-    sif::printInfo("0x%08x\n", listener.first);
-  }
-#endif
-}
-
 #endif /* FSFW_OBJ_EVENT_TRANSLATION == 1 */

src/fsfw/events/EventManager.h

@@ -43,7 +43,6 @@ class EventManager : public EventManagerIF, public ExecutableObjectIF, public Sy
                                           object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
                                           bool reporterInverted = false);
   ReturnValue_t performOperation(uint8_t opCode);
-  void printListeners();
 
  protected:
   MessageQueueIF* eventReportQueue = nullptr;

src/fsfw/fdir/FailureIsolationBase.cpp

@@ -9,9 +9,8 @@
 FailureIsolationBase::FailureIsolationBase(object_id_t owner, object_id_t parent,
                                            uint8_t messageDepth, uint8_t parameterDomainBase)
     : ownerId(owner), faultTreeParent(parent), parameterDomainBase(parameterDomainBase) {
-  auto mqArgs = MqArgs(owner, static_cast<void*>(this));
-  eventQueue = QueueFactory::instance()->createMessageQueue(
-      messageDepth, EventMessage::EVENT_MESSAGE_SIZE, &mqArgs);
+  eventQueue =
+      QueueFactory::instance()->createMessageQueue(messageDepth, EventMessage::EVENT_MESSAGE_SIZE);
 }
 
 FailureIsolationBase::~FailureIsolationBase() {
@@ -62,12 +61,11 @@ ReturnValue_t FailureIsolationBase::initialize() {
         ObjectManager::instance()->get<ConfirmsFailuresIF>(faultTreeParent);
     if (parentIF == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::error << "FailureIsolationBase::intialize: Parent object "
-                 << "invalid" << std::endl;
-      sif::error << "Make sure it implements ConfirmsFailuresIF" << std::endl;
-#else
-      sif::printError("FailureIsolationBase::intialize: Parent object invalid\n");
-      sif::printError("Make sure it implements ConfirmsFailuresIF\n");
+      sif::error << "FailureIsolationBase::intialize: Parent object"
+                 << "invalid." << std::endl;
+#endif
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::error << "Make sure it implements ConfirmsFailuresIF." << std::endl;
 #endif
       return ObjectManagerIF::CHILD_INIT_FAILED;
       return returnvalue::FAILED;

src/fsfw/fdir/FailureIsolationBase.h

@@ -12,12 +12,13 @@
 class FailureIsolationBase : public ConfirmsFailuresIF, public HasParametersIF {
  public:
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FDIR_1;
-  //! FDIR has an internal state, which changed from par2 (oldState) to par1 (newState).
-  static const Event FDIR_CHANGED_STATE = MAKE_EVENT(1, severity::INFO);
-  //! FDIR tries to restart device. Par1: event that caused recovery.
-  static const Event FDIR_STARTS_RECOVERY = MAKE_EVENT(2, severity::MEDIUM);
-  //! FDIR turns off device. Par1: event that caused recovery.
-  static const Event FDIR_TURNS_OFF_DEVICE = MAKE_EVENT(3, severity::MEDIUM);
+  static const Event FDIR_CHANGED_STATE =
+      MAKE_EVENT(1, severity::INFO);  //!< FDIR has an internal state, which changed from par2
+                                      //!< (oldState) to par1 (newState).
+  static const Event FDIR_STARTS_RECOVERY = MAKE_EVENT(
+      2, severity::MEDIUM);  //!< FDIR tries to restart device. Par1: event that caused recovery.
+  static const Event FDIR_TURNS_OFF_DEVICE = MAKE_EVENT(
+      3, severity::MEDIUM);  //!< FDIR turns off device. Par1: event that caused recovery.
 
   FailureIsolationBase(object_id_t owner, object_id_t parent = objects::NO_OBJECT,
                        uint8_t messageDepth = 10, uint8_t parameterDomainBase = 0xF0);

src/fsfw/globalfunctions/CMakeLists.txt

@@ -4,7 +4,6 @@ target_sources(
           AsciiConverter.cpp
           CRC.cpp
           DleEncoder.cpp
-          DleParser.cpp
           PeriodicOperationDivider.cpp
           timevalOperations.cpp
           Type.cpp

src/fsfw/globalfunctions/DleParser.cpp

@@ -1,230 +0,0 @@
-#include "DleParser.h"
-
-#include <fsfw/serviceinterface/ServiceInterface.h>
-
-#include <cstdio>
-
-DleParser::DleParser(SimpleRingBuffer& decodeRingBuf, DleEncoder& decoder, BufPair encodedBuf,
-                     BufPair decodedBuf, UserHandler handler, void* args)
-    : decodeRingBuf(decodeRingBuf),
-      decoder(decoder),
-      encodedBuf(encodedBuf),
-      decodedBuf(decodedBuf),
-      handler(handler),
-      ctx(args) {
-  if (handler == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "DleParser::DleParser: Invalid user handler" << std::endl;
-#else
-    sif::printError("DleParser::DleParser: Invalid user handler\n");
-#endif
-  }
-}
-
-ReturnValue_t DleParser::passData(uint8_t* data, size_t len) {
-  if (data == nullptr or len == 0 or handler == nullptr) {
-    return returnvalue::FAILED;
-  }
-  size_t copyIntoRingBufFromHere = 0;
-  size_t copyAmount = len;
-  size_t startIdx = 0;
-  ReturnValue_t result = returnvalue::OK;
-  bool startFoundInThisPacket = false;
-  for (size_t idx = 0; idx < len; idx++) {
-    if (data[idx] == DleEncoder::STX_CHAR) {
-      if (not startFound and not startFoundInThisPacket) {
-        startIdx = idx;
-        copyIntoRingBufFromHere = idx;
-        copyAmount = len - idx;
-      } else {
-        // Maybe print warning, should not happen
-        decodeRingBuf.clear();
-        ErrorInfo info;
-        info.len = idx;
-        prepareErrorContext(ErrorTypes::CONSECUTIVE_STX_CHARS, info);
-        handler(ctx);
-        copyIntoRingBufFromHere = idx;
-        copyAmount = len - idx;
-      }
-      startFound = true;
-      startFoundInThisPacket = true;
-    } else if (data[idx] == DleEncoder::ETX_CHAR) {
-      if (startFoundInThisPacket) {
-        size_t readLen = 0;
-        size_t decodedLen = 0;
-        result = decoder.decode(data + startIdx, idx + 1 - startIdx, &readLen, decodedBuf.first,
-                                decodedBuf.second, &decodedLen);
-        if (result == returnvalue::OK) {
-          ctx.setType(ContextType::PACKET_FOUND);
-          ctx.decodedPacket.first = decodedBuf.first;
-          ctx.decodedPacket.second = decodedLen;
-          this->handler(ctx);
-        } else if (result == DleEncoder::STREAM_TOO_SHORT) {
-          ErrorInfo info;
-          info.res = result;
-          prepareErrorContext(ErrorTypes::DECODING_BUF_TOO_SMALL, info);
-          handler(ctx);
-        } else {
-          ErrorInfo info;
-          info.res = result;
-          prepareErrorContext(ErrorTypes::DECODING_BUF_TOO_SMALL, info);
-          handler(ctx);
-        }
-        decodeRingBuf.clear();
-        if ((idx + 1) < len) {
-          copyIntoRingBufFromHere = idx + 1;
-          copyAmount = len - idx - 1;
-        } else {
-          copyAmount = 0;
-        }
-      } else if (startFound) {
-        // ETX found but STX was found in another mini packet. Reconstruct the full packet
-        // to decode it
-        result = decodeRingBuf.writeData(data, idx + 1);
-        if (result != returnvalue::OK) {
-          ErrorInfo info;
-          info.res = result;
-          prepareErrorContext(ErrorTypes::RING_BUF_ERROR, info);
-          handler(ctx);
-        }
-        size_t fullEncodedLen = decodeRingBuf.getAvailableReadData();
-        if (fullEncodedLen > encodedBuf.second) {
-          ErrorInfo info;
-          info.len = fullEncodedLen;
-          prepareErrorContext(ErrorTypes::ENCODED_BUF_TOO_SMALL, info);
-          handler(ctx);
-          decodeRingBuf.clear();
-        } else {
-          size_t decodedLen = 0;
-          size_t readLen = 0;
-          decodeRingBuf.readData(encodedBuf.first, fullEncodedLen, true);
-          result = decoder.decode(encodedBuf.first, fullEncodedLen, &readLen, decodedBuf.first,
-                                  decodedBuf.second, &decodedLen);
-          if (result == returnvalue::OK) {
-            if (this->handler != nullptr) {
-              ctx.setType(ContextType::PACKET_FOUND);
-              ctx.decodedPacket.first = decodedBuf.first;
-              ctx.decodedPacket.second = decodedLen;
-              this->handler(ctx);
-            }
-          } else if (result == DleEncoder::STREAM_TOO_SHORT) {
-            ErrorInfo info;
-            info.res = result;
-            prepareErrorContext(ErrorTypes::DECODING_BUF_TOO_SMALL, info);
-            handler(ctx);
-          } else {
-            ErrorInfo info;
-            info.res = result;
-            prepareErrorContext(ErrorTypes::DECODE_ERROR, info);
-            handler(ctx);
-          }
-          decodeRingBuf.clear();
-          startFound = false;
-          startFoundInThisPacket = false;
-          if ((idx + 1) < len) {
-            copyIntoRingBufFromHere = idx + 1;
-            copyAmount = len - idx - 1;
-          } else {
-            copyAmount = 0;
-          }
-        }
-      } else {
-        // End data without preceeding STX
-        ErrorInfo info;
-        info.len = idx + 1;
-        prepareErrorContext(ErrorTypes::CONSECUTIVE_ETX_CHARS, info);
-        handler(ctx);
-        decodeRingBuf.clear();
-        if ((idx + 1) < len) {
-          copyIntoRingBufFromHere = idx + 1;
-          copyAmount = len - idx - 1;
-        } else {
-          copyAmount = 0;
-        }
-      }
-      startFoundInThisPacket = false;
-      startFound = false;
-    }
-  }
-  if (copyAmount > 0) {
-    result = decodeRingBuf.writeData(data + copyIntoRingBufFromHere, copyAmount);
-    if (result != returnvalue::OK) {
-      ErrorInfo info;
-      info.res = result;
-      prepareErrorContext(ErrorTypes::RING_BUF_ERROR, info);
-      handler(ctx);
-    }
-  }
-  return returnvalue::OK;
-}
-
-void DleParser::defaultFoundPacketHandler(uint8_t* packet, size_t len, void* args) {
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::info << "DleParserBase::handleFoundPacket: Detected DLE packet with " << len << " bytes"
-            << std::endl;
-#else
-  sif::printInfo("DleParserBase::handleFoundPacket: Detected DLE packet with %d bytes\n", len);
-#endif
-#endif
-}
-
-void DleParser::defaultErrorHandler(ErrorTypes err, ErrorInfo ctx) {
-  switch (err) {
-    case (ErrorTypes::NONE): {
-      errorPrinter("No error");
-      break;
-    }
-    case (ErrorTypes::DECODE_ERROR): {
-      errorPrinter("Decode Error");
-      break;
-    }
-    case (ErrorTypes::RING_BUF_ERROR): {
-      errorPrinter("Ring Buffer Error");
-      break;
-    }
-    case (ErrorTypes::ENCODED_BUF_TOO_SMALL):
-    case (ErrorTypes::DECODING_BUF_TOO_SMALL): {
-      char opt[64];
-      snprintf(opt, sizeof(opt), ": Too small for packet with length %zu", ctx.len);
-      if (err == ErrorTypes::ENCODED_BUF_TOO_SMALL) {
-        errorPrinter("Encoded buf too small", opt);
-      } else {
-        errorPrinter("Decoding buf too small", opt);
-      }
-      break;
-    }
-    case (ErrorTypes::CONSECUTIVE_STX_CHARS): {
-      errorPrinter("Consecutive STX chars detected");
-      break;
-    }
-    case (ErrorTypes::CONSECUTIVE_ETX_CHARS): {
-      errorPrinter("Consecutive ETX chars detected");
-      break;
-    }
-  }
-}
-
-void DleParser::errorPrinter(const char* str, const char* opt) {
-  if (opt == nullptr) {
-    opt = "";
-  }
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::info << "DleParserBase::handleParseError: " << str << opt << std::endl;
-#else
-  sif::printInfo("DleParserBase::handleParseError: %s%s\n", str, opt);
-#endif
-#endif
-}
-
-void DleParser::prepareErrorContext(ErrorTypes err, ErrorInfo info) {
-  ctx.setType(ContextType::ERROR);
-  ctx.error.first = err;
-  ctx.error.second = info;
-}
-
-void DleParser::reset() {
-  startFound = false;
-  decodeRingBuf.clear();
-}

src/fsfw/globalfunctions/DleParser.h

@@ -1,125 +0,0 @@
-#pragma once
-
-#include <fsfw/container/SimpleRingBuffer.h>
-#include <fsfw/globalfunctions/DleEncoder.h>
-#include <fsfw/returnvalues/returnvalue.h>
-
-#include <cstddef>
-#include <utility>
-
-/**
- * @brief This base helper class can be used to extract DLE encoded packets from a data stream
- * @details
- * The core API of the parser takes received packets which can contains DLE packets. The parser
- * can deal with DLE packets split across multiple packets. It does so by using a dedicated
- * decoding ring buffer. The user can process received packets and detect errors by
- * overriding two provided virtual methods. This also allows detecting multiple DLE packets
- * inside one passed packet.
- */
-class DleParser {
- public:
-  using BufPair = std::pair<uint8_t*, size_t>;
-
-  enum class ContextType { PACKET_FOUND, ERROR };
-
-  enum class ErrorTypes {
-    NONE,
-    ENCODED_BUF_TOO_SMALL,
-    DECODING_BUF_TOO_SMALL,
-    DECODE_ERROR,
-    RING_BUF_ERROR,
-    CONSECUTIVE_STX_CHARS,
-    CONSECUTIVE_ETX_CHARS
-  };
-
-  union ErrorInfo {
-    size_t len;
-    ReturnValue_t res;
-  };
-
-  using ErrorPair = std::pair<ErrorTypes, ErrorInfo>;
-
-  struct Context {
-   public:
-    Context(void* args) : userArgs(args) { setType(ContextType::PACKET_FOUND); }
-
-    void setType(ContextType type) {
-      this->type = type;
-      if (type == ContextType::PACKET_FOUND) {
-        error.first = ErrorTypes::NONE;
-        error.second.len = 0;
-      } else {
-        decodedPacket.first = nullptr;
-        decodedPacket.second = 0;
-      }
-    }
-
-    ContextType getType() const { return type; }
-
-    BufPair decodedPacket = {};
-    ErrorPair error;
-    void* userArgs;
-
-   private:
-    ContextType type;
-  };
-
-  using UserHandler = void (*)(const Context& ctx);
-
-  /**
-   * Base class constructor
-   * @param decodeRingBuf Ring buffer used to store multiple packets to allow detecting DLE packets
-   * split across multiple packets
-   * @param decoder Decoder instance
-   * @param encodedBuf Buffer used to store encoded packets. It has to be large enough to hold
-   * the largest expected encoded DLE packet size
-   * @param decodedBuf Buffer used to store decoded packets. It has to be large enough to hold the
-   * largest expected decoded DLE packet size
-   * @param handler Function which will be called on a found packet
-   * @param args Arbitrary user argument
-   */
-  DleParser(SimpleRingBuffer& decodeRingBuf, DleEncoder& decoder, BufPair encodedBuf,
-            BufPair decodedBuf, UserHandler handler, void* args);
-
-  /**
-   * This function allows to pass new data into the parser. It then scans for DLE packets
-   * automatically and inserts (part of) the packet into a ring buffer if necessary.
-   * @param data
-   * @param len
-   * @return
-   */
-  ReturnValue_t passData(uint8_t* data, size_t len);
-
-  /**
-   * Example found packet handler
-   * function call
-   * @param packet Decoded packet
-   * @param len Length of detected packet
-   */
-  void defaultFoundPacketHandler(uint8_t* packet, size_t len, void* args);
-  /**
-   * Will be called if an error occured in the #passData call
-   * @param err
-   * @param ctx Context information depending on the error type
-   *  - For buffer length errors, will be set to the detected packet length which is too large
-   *  - For decode or ring buffer errors, will be set to the result returned from the failed call
-   */
-  static void defaultErrorHandler(ErrorTypes err, ErrorInfo ctx);
-
-  static void errorPrinter(const char* str, const char* opt = nullptr);
-
-  void prepareErrorContext(ErrorTypes err, ErrorInfo ctx);
-  /**
-   * Resets the parser by resetting the internal states and clearing the decoding ring buffer
-   */
-  void reset();
-
- private:
-  SimpleRingBuffer& decodeRingBuf;
-  DleEncoder& decoder;
-  BufPair encodedBuf;
-  BufPair decodedBuf;
-  UserHandler handler = nullptr;
-  Context ctx;
-  bool startFound = false;
-};

src/fsfw/health/HasHealthIF.h

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

src/fsfw/internalerror/InternalErrorReporter.cpp

@@ -7,13 +7,11 @@
 
 InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId, uint32_t messageQueueDepth)
     : SystemObject(setObjectId),
+      commandQueue(QueueFactory::instance()->createMessageQueue(messageQueueDepth)),
       poolManager(this, commandQueue),
       internalErrorSid(setObjectId, InternalErrorDataset::ERROR_SET_ID),
       internalErrorDataset(this) {
   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); }
@@ -38,14 +36,15 @@ ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
     if ((newQueueHits > 0) or (newTmHits > 0) or (newStoreHits > 0)) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::debug << "InternalErrorReporter::performOperation: Errors "
-                 << "occured: Queue | TM | Store : " << newQueueHits << " | " << newTmHits << " | "
-                 << newStoreHits << std::endl;
+                 << "occured!" << std::endl;
+      sif::debug << "Queue errors: " << newQueueHits << std::endl;
+      sif::debug << "TM errors: " << newTmHits << std::endl;
+      sif::debug << "Store errors: " << newStoreHits << std::endl;
 #else
-      sif::printDebug(
-          "InternalErrorReporter::performOperation: Errors occured: Queue | TM | Store: %lu | %lu "
-          "| %lu\n",
-          static_cast<unsigned int>(newQueueHits), static_cast<unsigned int>(newTmHits),
-          static_cast<unsigned int>(newStoreHits));
+      sif::printDebug("InternalErrorReporter::performOperation: Errors occured!\n");
+      sif::printDebug("Queue errors: %lu\n", static_cast<unsigned int>(newQueueHits));
+      sif::printDebug("TM errors: %lu\n", static_cast<unsigned int>(newTmHits));
+      sif::printDebug("Store errors: %lu\n", static_cast<unsigned int>(newStoreHits));
 #endif
     }
   }

src/fsfw/ipc/CommandMessageIF.h

@@ -34,7 +34,7 @@ class CommandMessageIF {
   static const Command_t CMD_NONE = MAKE_COMMAND_ID(0);
   static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID(1);
   //! Reply indicating that the current command was rejected,
-  //! Parameter 1 should contain the error code
+  //! par1 should contain the error code
   static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID(2);
 
   virtual ~CommandMessageIF(){};

src/fsfw/modes/HasModesIF.h

@@ -19,33 +19,32 @@ class HasModesIF {
   static const ReturnValue_t INVALID_SUBMODE = MAKE_RETURN_CODE(0x04);
 
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER;
-  //! An object announces changing the mode. p1: target mode. p2: target submode
-  static const Event CHANGING_MODE = MAKE_EVENT(0, severity::INFO);
-  //! An Object announces its mode; parameter1 is mode, parameter2 is submode
-  static const Event MODE_INFO = MAKE_EVENT(1, severity::INFO);
+  static const Event CHANGING_MODE =
+      MAKE_EVENT(0, severity::INFO);  //!< An object announces changing the mode. p1: target mode.
+                                      //!< p2: target submode
+  static const Event MODE_INFO = MAKE_EVENT(
+      1,
+      severity::INFO);  //!< An Object announces its mode; parameter1 is mode, parameter2 is submode
   static const Event FALLBACK_FAILED = MAKE_EVENT(2, severity::HIGH);
   static const Event MODE_TRANSITION_FAILED = MAKE_EVENT(3, severity::LOW);
   static const Event CANT_KEEP_MODE = MAKE_EVENT(4, severity::HIGH);
-  //! Indicates a bug or configuration failure: Object is in a mode it should never be in.
-  static const Event OBJECT_IN_INVALID_MODE = MAKE_EVENT(5, severity::LOW);
-  //! The mode is changed, but for some reason, the change is forced, i.e. EXTERNAL_CONTROL ignored.
-  //! p1: target mode. p2: target submode
-  static const Event FORCING_MODE = MAKE_EVENT(6, severity::MEDIUM);
-  //! A mode command was rejected by the called object. Par1: called object id, Par2: return code.
-  static const Event MODE_CMD_REJECTED = MAKE_EVENT(7, severity::LOW);
+  static const Event OBJECT_IN_INVALID_MODE =
+      MAKE_EVENT(5, severity::LOW);  //!< Indicates a bug or configuration failure: Object is in a
+                                     //!< mode it should never be in.
+  static const Event FORCING_MODE = MAKE_EVENT(
+      6, severity::MEDIUM);  //!< The mode is changed, but for some reason, the change is forced,
+                             //!< i.e. EXTERNAL_CONTROL ignored. p1: target mode. p2: target submode
+  static const Event MODE_CMD_REJECTED =
+      MAKE_EVENT(7, severity::LOW);  //!< A mode command was rejected by the called object. Par1:
+                                     //!< called object id, Par2: return code.
 
-  //! The device is powered and ready to perform operations. In this mode, no commands are
-  //! sent by the device handler itself, but direct commands van be commanded and will be
-  //! interpreted
-  static constexpr Mode_t MODE_ON = 1;
-  //! The device is powered off. The only command accepted in this mode is a mode change to on.
-  static constexpr Mode_t MODE_OFF = 0;
-
-  static constexpr Mode_t MODE_INVALID = -1;
-  static constexpr Mode_t MODE_UNDEFINED = -2;
-
-  //! To avoid checks against magic number "0".
-  static const Submode_t SUBMODE_NONE = 0;
+  static const Mode_t MODE_ON =
+      1;  //!< The device is powered and ready to perform operations. In this mode, no commands are
+          //!< sent by the device handler itself, but direct commands van be commanded and will be
+          //!< interpreted
+  static const Mode_t MODE_OFF = 0;  //!< The device is powered off. The only command accepted in
+                                     //!< this mode is a mode change to on.
+  static const Submode_t SUBMODE_NONE = 0;  //!< To avoid checks against magic number "0".
 
   virtual ~HasModesIF() {}
   virtual MessageQueueId_t getCommandQueue() const = 0;

src/fsfw/monitoring/MonitoringMessageContent.h

@@ -8,7 +8,7 @@
 #include "../serialize/SerialLinkedListAdapter.h"
 #include "../serialize/SerializeElement.h"
 #include "../serviceinterface/ServiceInterface.h"
-#include "../timemanager/TimeStamperIF.h"
+#include "../timemanager/TimeWriterIF.h"
 #include "HasMonitorsIF.h"
 #include "MonitoringIF.h"
 #include "monitoringConf.h"
@@ -34,9 +34,9 @@ class MonitoringReportContent : public SerialLinkedListAdapter<SerializeIF> {
   SerializeElement<T> limitValue;
   SerializeElement<ReturnValue_t> oldState;
   SerializeElement<ReturnValue_t> newState;
-  uint8_t rawTimestamp[TimeStamperIF::MAXIMUM_TIMESTAMP_LEN] = {};
+  uint8_t rawTimestamp[TimeWriterIF::MAXIMUM_TIMESTAMP_LEN] = {};
   SerializeElement<SerialBufferAdapter<uint8_t>> timestampSerializer;
-  TimeStamperIF* timeStamper;
+  TimeWriterIF* timeStamper;
   MonitoringReportContent()
       : SerialLinkedListAdapter<SerializeIF>(&parameterObjectId),
         monitorId(0),
@@ -79,7 +79,7 @@ class MonitoringReportContent : public SerialLinkedListAdapter<SerializeIF> {
   }
   bool checkAndSetStamper() {
     if (timeStamper == nullptr) {
-      timeStamper = ObjectManager::instance()->get<TimeStamperIF>(timeStamperId);
+      timeStamper = ObjectManager::instance()->get<TimeWriterIF>(timeStamperId);
       if (timeStamper == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "MonitoringReportContent::checkAndSetStamper: "

src/fsfw/objectmanager/ObjectManager.cpp

@@ -16,11 +16,6 @@ ObjectManager* ObjectManager::instance() {
   return objManagerInstance;
 }
 
-void ObjectManager::setObjectFactoryFunction(produce_function_t objFactoryFunc, void* factoryArgs) {
-  this->objectFactoryFunction = objFactoryFunc;
-  this->factoryArgs = factoryArgs;
-}
-
 ObjectManager::ObjectManager() = default;
 
 ObjectManager::~ObjectManager() {
@@ -79,32 +74,18 @@ SystemObjectIF* ObjectManager::getSystemObject(object_id_t id) {
 }
 
 void ObjectManager::initialize() {
-  if (objectFactoryFunction == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "ObjectManager::initialize: Passed produceObjects "
-                  "functions is nullptr!"
-               << std::endl;
-#else
-    sif::printError("ObjectManager::initialize: Passed produceObjects functions is nullptr!\n");
-#endif
-    return;
-  }
-  objectFactoryFunction(factoryArgs);
   ReturnValue_t result = returnvalue::FAILED;
   uint32_t errorCount = 0;
   for (auto const& it : objectList) {
     result = it.second->initialize();
     if (result != returnvalue::OK) {
-#if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
+      object_id_t var = it.first;
       sif::error << "ObjectManager::initialize: Object 0x" << std::hex << std::setw(8)
-                 << std::setfill('0') << it.first << " failed to initialize with code 0x" << result
-                 << std::dec << std::setfill(' ') << std::endl;
-#else
-      sif::printError(
-          "ObjectManager::initialize: Object 0x%08x failed to initialize with code 0x%04x\n", var,
-          it.first);
-#endif
+                 << std::setfill('0') << var
+                 << " failed to "
+                    "initialize with code 0x"
+                 << result << std::dec << std::setfill(' ') << std::endl;
 #endif
       errorCount++;
     }

src/fsfw/objectmanager/ObjectManager.h

@@ -21,7 +21,6 @@
  */
 class ObjectManager : public ObjectManagerIF {
  public:
-  using produce_function_t = void (*)(void* args);
 
   /**
    * Returns the single instance of TaskFactory.
@@ -30,8 +29,6 @@ class ObjectManager : public ObjectManagerIF {
    */
   static ObjectManager* instance();
 
-  void setObjectFactoryFunction(produce_function_t prodFunc, void* args);
-
   template <typename T>
   T* get(object_id_t id);
 
@@ -54,8 +51,6 @@ class ObjectManager : public ObjectManagerIF {
    * @param   The id of the object to be created.
    * @return  Returns a pointer to the newly created object or NULL.
    */
-  produce_function_t objectFactoryFunction = nullptr;
-  void* factoryArgs = nullptr;
 
  private:
   ObjectManager();

src/fsfw/osal/CMakeLists.txt

@@ -16,9 +16,7 @@ elseif(FSFW_OSAL MATCHES "host")
 
 else()
 
-  message(
-    WARNING
-      "${MSG_PREFIX} The FSFW_OSAL variable was not set. Assuming host OS..")
+  message(WARNING "The OS_FSFW variable was not set. Assuming host OS..")
   # Not set. Assumuing this is a host build, try to determine host OS
   if(WIN32)
     add_subdirectory(host)

src/fsfw/parameters/HasParametersIF.h

@@ -66,8 +66,7 @@ class HasParametersIF {
    * @param newValues
    * @param startAtIndex Linear index, runs left to right, top to bottom for
    * matrix indexes.
-   * @return returnvalue::OK if parameter is valid and a set function of the parameter wrapper was
-   * called.
+   * @return
    */
   virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueIdentifier,
                                      ParameterWrapper *parameterWrapper,

src/fsfw/parameters/ParameterWrapper.cpp

@@ -211,13 +211,9 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
   if (data == nullptr) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "ParameterWrapper::copyFrom: Called on read-only variable or "
-                    "data pointer not set"
-                 << std::endl;
+    sif::warning << "ParameterWrapper::copyFrom: Called on read-only variable!" << std::endl;
 #else
-    sif::printWarning(
-        "ParameterWrapper::copyFrom: Called on read-only variable "
-        "or data pointer not set\n");
+    sif::printWarning("ParameterWrapper::copyFrom: Called on read-only variable!\n");
 #endif
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
     return READONLY;
@@ -226,9 +222,9 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
   if (from->readonlyData == nullptr) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "ParameterWrapper::copyFrom: Source not set" << std::endl;
+    sif::warning << "ParameterWrapper::copyFrom: Source not set!" << std::endl;
 #else
-    sif::printWarning("ParameterWrapper::copyFrom: Source not set\n");
+    sif::printWarning("ParameterWrapper::copyFrom: Source not set!\n");
 #endif
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
     return SOURCE_NOT_SET;
@@ -237,9 +233,9 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
   if (type != from->type) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "ParameterWrapper::copyFrom: Datatype missmatch" << std::endl;
+    sif::warning << "ParameterWrapper::copyFrom: Datatype missmatch!" << std::endl;
 #else
-    sif::printWarning("ParameterWrapper::copyFrom: Datatype missmatch\n");
+    sif::printWarning("ParameterWrapper::copyFrom: Datatype missmatch!\n");
 #endif
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
     return DATATYPE_MISSMATCH;
@@ -249,9 +245,9 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
   if (rows == 0 or columns == 0) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "ParameterWrapper::copyFrom: Columns or rows zero" << std::endl;
+    sif::warning << "ParameterWrapper::copyFrom: Columns or rows zero!" << std::endl;
 #else
-    sif::printWarning("ParameterWrapper::copyFrom: Columns or rows zero\n");
+    sif::printWarning("ParameterWrapper::copyFrom: Columns or rows zero!\n");
 #endif
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
     return COLUMN_OR_ROWS_ZERO;

src/fsfw/power/PowerSwitchIF.h

@@ -29,9 +29,9 @@ class PowerSwitchIF {
   static const ReturnValue_t FUSE_ON = MAKE_RETURN_CODE(3);
   static const ReturnValue_t FUSE_OFF = MAKE_RETURN_CODE(4);
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_2;
-  //!< Someone detected that a switch went off which shouldn't. Severity:
-  //!< Low, Parameter1: switchId1, Parameter2: switchId2
-  static const Event SWITCH_WENT_OFF = MAKE_EVENT(0, severity::LOW);
+  static const Event SWITCH_WENT_OFF = MAKE_EVENT(
+      0, severity::LOW);  //!< Someone detected that a switch went off which shouldn't. Severity:
+                          //!< Low, Parameter1: switchId1, Parameter2: switchId2
   /**
    * send a direct command to the Power Unit to enable/disable the specified switch.
    *

src/fsfw/pus/Service11TelecommandScheduling.tpp

@@ -75,7 +75,7 @@ inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::performService
   // NOTE: The iterator is increased in the loop here. Increasing the iterator as for-loop arg
   // does not work in this case as we are deleting the current element here.
   for (auto it = telecommandMap.begin(); it != telecommandMap.end();) {
-    if (it->first <= static_cast<uint32_t>(tNow.tv_sec)) {
+    if (it->first <= tNow.tv_sec) {
       if (schedulingEnabled) {
         // release tc
         TmTcMessage releaseMsg(it->second.storeAddr);
@@ -568,11 +568,13 @@ inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::getMapFilterFr
         return INVALID_TIME_WINDOW;
       }
       itBegin = telecommandMap.begin();
-      itEnd = telecommandMap.begin();
 
       while (itBegin->first < fromTimestamp && itBegin != telecommandMap.end()) {
         itBegin++;
       }
+
+      // start looking for end beginning at begin
+      itEnd = itBegin;
       while (itEnd->first <= toTimestamp && itEnd != telecommandMap.end()) {
         itEnd++;
       }

src/fsfw/pus/Service1TelecommandVerification.cpp

@@ -11,7 +11,7 @@ Service1TelecommandVerification::Service1TelecommandVerification(object_id_t obj
                                                                  uint16_t apid, uint8_t serviceId,
                                                                  object_id_t targetDestination,
                                                                  uint16_t messageQueueDepth,
-                                                                 TimeStamperIF* timeStamper)
+                                                                 TimeWriterIF* timeStamper)
     : SystemObject(objectId),
       apid(apid),
       serviceId(serviceId),
@@ -134,7 +134,7 @@ ReturnValue_t Service1TelecommandVerification::initialize() {
     storeHelper.setTmStore(*tmStore);
   }
   if (timeStamper == nullptr) {
-    timeStamper = ObjectManager::instance()->get<TimeStamperIF>(objects::TIME_STAMPER);
+    timeStamper = ObjectManager::instance()->get<TimeWriterIF>(objects::TIME_STAMPER);
     if (timeStamper == nullptr) {
       return ObjectManagerIF::CHILD_INIT_FAILED;
     }

src/fsfw/pus/Service1TelecommandVerification.h

@@ -47,7 +47,7 @@ class Service1TelecommandVerification : public AcceptsVerifyMessageIF,
 
   Service1TelecommandVerification(object_id_t objectId, uint16_t apid, uint8_t serviceId,
                                   object_id_t targetDestination, uint16_t messageQueueDepth,
-                                  TimeStamperIF* timeStamper = nullptr);
+                                  TimeWriterIF* timeStamper = nullptr);
   ~Service1TelecommandVerification() override;
 
   /**
@@ -87,7 +87,7 @@ class Service1TelecommandVerification : public AcceptsVerifyMessageIF,
   TmStoreHelper storeHelper;
   TmStoreAndSendWrapper tmHelper;
   InternalErrorReporterIF* errReporter = nullptr;
-  TimeStamperIF* timeStamper = nullptr;
+  TimeWriterIF* timeStamper = nullptr;
   StorageManagerIF* tmStore = nullptr;
   MessageQueueIF* tmQueue = nullptr;
 

src/fsfw/pus/Service3Housekeeping.cpp

@@ -208,17 +208,17 @@ ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
       ReturnValue_t error = returnvalue::FAILED;
       HousekeepingMessage::getHkRequestFailureReply(reply, &error);
       failureParameter2 = error;
-      return returnvalue::FAILED;
+      return CommandingServiceBase::EXECUTION_COMPLETE;
     }
 
     default:
 #if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::warning << "Service3Housekeeping::handleReply: Invalid reply with "
-                   << "reply command " << command << std::endl;
+                   << "reply command " << command << "!" << std::endl;
 #else
       sif::printWarning(
           "Service3Housekeeping::handleReply: Invalid reply with "
-          "reply command %hu\n",
+          "reply command %hu!\n",
           command);
 #endif
       return CommandingServiceBase::INVALID_REPLY;
@@ -248,28 +248,19 @@ void Service3Housekeeping::handleUnrequestedReply(CommandMessage* reply) {
     case (HousekeepingMessage::HK_REQUEST_FAILURE): {
       break;
     }
-    case (CommandMessage::REPLY_REJECTED): {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::warning << "Service3Housekeeping::handleUnrequestedReply: Unexpected reply "
-                      "rejected with error code"
-                   << reply->getParameter() << std::endl;
-#else
-#endif
-      break;
-    }
 
     default: {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::warning << "Service3Housekeeping::handleUnrequestedReply: Invalid reply with reply "
                       "command "
-                   << command << "" << std::endl;
+                   << command << "!" << std::endl;
 #else
       sif::printWarning(
           "Service3Housekeeping::handleUnrequestedReply: Invalid reply with "
-          "reply command %hu\n",
+          "reply command %hu!\n",
           command);
 #endif
-      break;
+      return;
     }
   }
 
@@ -284,7 +275,6 @@ void Service3Housekeeping::handleUnrequestedReply(CommandMessage* reply) {
         "Could not generate reply!\n");
 #endif
   }
-  CommandingServiceBase::handleUnrequestedReply(reply);
 }
 
 MessageQueueId_t Service3Housekeeping::getHkQueue() const { return commandQueue->getId(); }

src/fsfw/pus/Service5EventReporting.cpp

@@ -13,9 +13,7 @@ Service5EventReporting::Service5EventReporting(PsbParams params, size_t maxNumbe
       storeHelper(params.apid),
       tmHelper(params.serviceId, storeHelper, sendHelper),
       maxNumberReportsPerCycle(maxNumberReportsPerCycle) {
-  auto mqArgs = MqArgs(getObjectId(), static_cast<void*>(this));
-  eventQueue = QueueFactory::instance()->createMessageQueue(
-      messageQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  eventQueue = QueueFactory::instance()->createMessageQueue(messageQueueDepth);
 }
 
 Service5EventReporting::~Service5EventReporting() {
@@ -39,6 +37,9 @@ ReturnValue_t Service5EventReporting::performService() {
       }
     }
   }
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::warning << "Service5EventReporting::generateEventReport: Too many events" << std::endl;
+#endif
   return returnvalue::OK;
 }
 

src/fsfw/pus/Service9TimeManagement.h

@@ -6,10 +6,10 @@
 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
-  static constexpr Event CLOCK_SET = MAKE_EVENT(0, 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 =
+      MAKE_EVENT(0, severity::INFO);  //!< Clock has been set. P1: New Uptime. P2: Old Uptime
+  static constexpr Event CLOCK_SET_FAILURE =
+      MAKE_EVENT(1, severity::LOW);  //!< Clock could not be set. P1: Returncode.
 
   static constexpr uint8_t CLASS_ID = CLASS_ID::PUS_SERVICE_9;
 

src/fsfw/returnvalues/returnvalue.h

@@ -1,8 +1,6 @@
 #ifndef FSFW_RETURNVALUES_RETURNVALUE_H_
 #define FSFW_RETURNVALUES_RETURNVALUE_H_
 
-#include <returnvalues/classIds.h>
-
 #include <cstdint>
 
 #include "FwClassIds.h"

src/fsfw/serialize/SerialBufferAdapter.cpp

@@ -21,7 +21,7 @@ SerialBufferAdapter<count_t>::SerialBufferAdapter(uint8_t* buffer, count_t buffe
       bufferLength(bufferLength) {}
 
 template <typename count_t>
-SerialBufferAdapter<count_t>::~SerialBufferAdapter() {}
+SerialBufferAdapter<count_t>::~SerialBufferAdapter() = default;
 
 template <typename count_t>
 ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer, size_t* size,
@@ -119,10 +119,10 @@ const uint8_t* SerialBufferAdapter<count_t>::getConstBuffer() const {
 }
 
 template <typename count_t>
-void SerialBufferAdapter<count_t>::setBuffer(uint8_t* buffer, count_t bufferLength) {
-  this->buffer = buffer;
-  this->constBuffer = buffer;
-  this->bufferLength = bufferLength;
+void SerialBufferAdapter<count_t>::setConstBuffer(const uint8_t* buf, count_t bufLen) {
+  this->buffer = nullptr;
+  this->bufferLength = bufLen;
+  this->constBuffer = buf;
 }
 
 // forward Template declaration for linker

src/fsfw/serialize/SerialBufferAdapter.h

@@ -21,6 +21,7 @@
 template <typename count_t>
 class SerialBufferAdapter : public SerializeIF {
  public:
+  SerialBufferAdapter() = default;
   /**
    * Constructor for constant uint8_t buffer. Length field can be serialized optionally.
    * Type of length can be supplied as template type.
@@ -40,12 +41,12 @@ class SerialBufferAdapter : public SerializeIF {
    */
   SerialBufferAdapter(uint8_t* buffer, count_t bufferLength, bool serializeLength = false);
 
-  virtual ~SerialBufferAdapter();
+  ~SerialBufferAdapter() override;
 
-  virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                                  Endianness streamEndianness) const override;
+  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                          Endianness streamEndianness) const override;
 
-  virtual size_t getSerializedSize() const override;
+  [[nodiscard]] size_t getSerializedSize() const override;
 
   /**
    * @brief This function deserializes a buffer into the member buffer.
@@ -59,12 +60,12 @@ class SerialBufferAdapter : public SerializeIF {
    * @param bigEndian
    * @return
    */
-  virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                                    Endianness streamEndianness) override;
+  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                            Endianness streamEndianness) override;
 
   uint8_t* getBuffer();
-  const uint8_t* getConstBuffer() const;
-  void setBuffer(uint8_t* buffer, count_t bufferLength);
+  [[nodiscard]] const uint8_t* getConstBuffer() const;
+  void setConstBuffer(const uint8_t* buf, count_t bufLen);
 
  private:
   bool serializeLength = false;

src/fsfw/serviceinterface/ServiceInterfaceBuffer.cpp

@@ -1,8 +1,8 @@
-#include "fsfw/serviceinterface/ServiceInterfaceBuffer.h"
+#include "ServiceInterfaceBuffer.h"
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 
-#include <inttypes.h>
+#include <cinttypes>
 
 #include <cstring>
 
@@ -16,8 +16,6 @@
 // to be implemented by bsp
 extern "C" void printChar(const char*, bool errStream);
 
-#ifndef UT699
-
 ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage, bool addCrToPreamble,
                                                bool buffered, bool errStream, uint16_t port)
     : isActive(true),
@@ -58,6 +56,9 @@ ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage, bool addC
 }
 
 void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
+  if (not isActive) {
+    return;
+  }
   char array[BUF_SIZE];
   uint32_t length = end - begin;
   if (length > sizeof(array)) {
@@ -74,8 +75,6 @@ void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
   }
 }
 
-#endif
-
 int ServiceInterfaceBuffer::overflow(int c) {
   if (not buffered and this->isActive) {
     if (c != Traits::eof()) {
@@ -169,89 +168,4 @@ void ServiceInterfaceBuffer::setAsciiColorPrefix(std::string colorPrefix) {
 }
 #endif
 
-#ifdef UT699
-#include "../osal/rtems/Interrupt.h"
-
-ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message, uint16_t port) {
-  this->log_message = set_message;
-  this->isActive = true;
-  setp(buf, buf + BUF_SIZE);
-}
-
-void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
-  char array[BUF_SIZE];
-  uint32_t length = end - begin;
-  if (length > sizeof(array)) {
-    length = sizeof(array);
-  }
-  memcpy(array, begin, length);
-
-  if (!Interrupt::isInterruptInProgress()) {
-    std::cout << array;
-  } else {
-    // Uncomment the following line if you need ISR debug output.
-    //		printk(array);
-  }
-}
-#endif  // UT699
-
-#ifdef ML505
-#include <bsp_flp/network/networkconfig.h>
-ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message, uint16_t port)
-    : isActive(true),
-      log_message(set_message),
-      udpSocket(0),
-      remoteAddressLength(sizeof(remoteAddress)) {
-  setp(buf, buf + BUF_SIZE);
-  memset((uint8_t*)&remoteAddress, 0, sizeof(remoteAddress));
-  remoteAddress.sin_family = AF_INET;
-  remoteAddress.sin_port = htons(port);
-  remoteAddress.sin_addr.s_addr = htonl(inet_addr("192.168.250.100"));
-}
-
-void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
-  char array[BUF_SIZE];
-  uint32_t length = end - begin;
-  if (length > sizeof(array)) {
-    length = sizeof(array);
-  }
-  memcpy(array, begin, length);
-
-  if (udpSocket <= 0) {
-    initSocket();
-  }
-
-  if (udpSocket > 0) {
-    sendto(udpSocket, array, length, 0, (sockaddr*)&remoteAddress, sizeof(remoteAddress));
-  }
-}
-
-void ServiceInterfaceBuffer::initSocket() {
-  sockaddr_in address;
-  memset((uint8_t*)&address, 0, sizeof(address));
-  address.sin_family = AF_INET;
-  address.sin_port = htons(0);
-  address.sin_addr.s_addr = htonl(INADDR_ANY);
-
-  udpSocket = socket(PF_INET, SOCK_DGRAM, 0);
-  if (socket < 0) {
-    printf("Error opening socket!\n");
-    return;
-  }
-  timeval timeout = {0, 20};
-  if (setsockopt(udpSocket, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) < 0) {
-    printf("Error setting SO_RCVTIMEO socket options!\n");
-    return;
-  }
-  if (setsockopt(udpSocket, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout)) < 0) {
-    printf("Error setting SO_SNDTIMEO socket options!\n");
-    return;
-  }
-  if (bind(udpSocket, (sockaddr*)&address, sizeof(address)) < 0) {
-    printf("Error binding socket!\n");
-  }
-}
-
-#endif  // ML505
-
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif

src/fsfw/serviceinterface/ServiceInterfaceBuffer.h

@@ -1,9 +1,8 @@
 #ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
 #define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
 
-#include <FSFWConfig.h>
-
-#include "../returnvalues/returnvalue.h"
+#include "fsfw/FSFW.h"
+#include "fsfw/returnvalues/returnvalue.h"
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 
@@ -11,8 +10,6 @@
 #include <iostream>
 #include <sstream>
 
-#ifndef UT699
-
 /**
  * @brief 	This is the underlying stream buffer which implements the
  * 			streambuf class and overloads the overflow() and sync() methods
@@ -77,85 +74,6 @@ class ServiceInterfaceBuffer : public std::streambuf {
   bool crAdditionEnabled() const;
 };
 
-#endif
-
-#ifdef UT699
-class ServiceInterfaceBuffer : public std::basic_streambuf<char, std::char_traits<char> > {
-  friend class ServiceInterfaceStream;
-
- public:
-  ServiceInterfaceBuffer(std::string set_message, uint16_t port);
-
- protected:
-  bool isActive;
-  // This is called when buffer becomes full. If
-  // buffer is not used, then this is called every
-  // time when characters are put to stream.
-  virtual int overflow(int c = Traits::eof());
-
-  // This function is called when stream is flushed,
-  // for example when std::endl is put to stream.
-  virtual int sync(void);
-
- private:
-  // For additional message information
-  std::string log_message;
-  // For EOF detection
-  typedef std::char_traits<char> Traits;
-
-  // Work in buffer mode. It is also possible to work without buffer.
-  static size_t const BUF_SIZE = 128;
-  char buf[BUF_SIZE];
-
-  // In this function, the characters are parsed.
-  void putChars(char const* begin, char const* end);
-};
-#endif  // UT699
-
-#ifdef ML505
-#include <arpa/inet.h>
-#include <netinet/in.h>
-#include <netinet/udp.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-
-class ServiceInterfaceBuffer : public std::basic_streambuf<char, std::char_traits<char> > {
-  friend class ServiceInterfaceStream;
-
- public:
-  ServiceInterfaceBuffer(std::string set_message, uint16_t port);
-
- protected:
-  bool isActive;
-  // This is called when buffer becomes full. If
-  // buffer is not used, then this is called every
-  // time when characters are put to stream.
-  virtual int overflow(int c = Traits::eof());
-
-  // This function is called when stream is flushed,
-  // for example when std::endl is put to stream.
-  virtual int sync(void);
-
- private:
-  // For additional message information
-  std::string log_message;
-  // For EOF detection
-  typedef std::char_traits<char> Traits;
-
-  // Work in buffer mode. It is also possible to work without buffer.
-  static size_t const BUF_SIZE = 128;
-  char buf[BUF_SIZE];
-
-  // In this function, the characters are parsed.
-  void putChars(char const* begin, char const* end);
-
-  int udpSocket;
-  sockaddr_in remoteAddress;
-  socklen_t remoteAddressLength;
-  void initSocket();
-};
-#endif  // ML505
-
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 
 #endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_ */

src/fsfw/serviceinterface/ServiceInterfaceStream.h

@@ -1,9 +1,8 @@
 #ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
 #define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
 
-#include <FSFWConfig.h>
-
 #include "ServiceInterfaceBuffer.h"
+#include "fsfw/FSFW.h"
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 

src/fsfw/subsystem/Subsystem.h

@@ -33,12 +33,8 @@ struct SequenceEntry : public TableSequenceBase {
 };
 
 /**
- * @brief   This class extends the SubsystemBase to perform the management of mode tables
- *          and mode sequences
+ * @brief   TODO: documentation missing
  * @details
- * This class is able to use mode tables and sequences to command all its children into the
- * right mode. Fallback sequences can be used to handle failed transitions or have a fallback
- * in case a component can't keep its current mode.
  */
 class Subsystem : public SubsystemBase, public HasModeSequenceIF {
  public:

src/fsfw/subsystem/SubsystemBase.cpp

@@ -8,13 +8,11 @@ SubsystemBase::SubsystemBase(object_id_t setObjectId, object_id_t parent, Mode_t
                              uint16_t commandQueueDepth)
     : SystemObject(setObjectId),
       mode(initialMode),
+      commandQueue(QueueFactory::instance()->createMessageQueue(commandQueueDepth,
+                                                                CommandMessage::MAX_MESSAGE_SIZE)),
       healthHelper(this, setObjectId),
       modeHelper(this),
-      parentId(parent) {
-  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
-  commandQueue = QueueFactory::instance()->createMessageQueue(
-      commandQueueDepth, CommandMessage::MAX_MESSAGE_SIZE, &mqArgs);
-}
+      parentId(parent) {}
 
 SubsystemBase::~SubsystemBase() { QueueFactory::instance()->deleteMessageQueue(commandQueue); }
 
@@ -33,9 +31,8 @@ ReturnValue_t SubsystemBase::registerChild(object_id_t objectId) {
       info.mode = MODE_OFF;
     }
   } else {
-    // intentional to force an initial command during system startup
     info.commandQueue = child->getCommandQueue();
-    info.mode = HasModesIF::MODE_UNDEFINED;
+    info.mode = -1;  // intentional to force an initial command during system startup
   }
 
   info.submode = SUBMODE_NONE;

src/fsfw/subsystem/SubsystemBase.h

@@ -15,14 +15,7 @@
 
 /**
  * @defgroup subsystems Subsystem Objects
- * All Subsystem and Assemblies can derive from this class. It contains helper classes to
- * perform mode and health handling, which allows OBSW developers to build a mode tree for
- * the whole satellite.
- *
- * Aside from setting up a mode tree and being able to executing mode tables, this class does not
- * provide an implementation on what to do with the features. To build a mode tree, helper classes
- * like the #AssemblyBase or the #Subsystem class extend and use the functionality of the base
- * class.
+ * Contains all Subsystem and Assemblies
  */
 class SubsystemBase : public SystemObject,
                       public HasModesIF,
@@ -102,7 +95,6 @@ class SubsystemBase : public SystemObject,
                                        Submode_t targetSubmode);
 
   /**
-   * This function takes care of sending all according mode commands specified inside a mode table.
    * We need to know the target Submode, as children are able to inherit the submode
    * Still, we have a default for all child implementations which do not use submode inheritance
    */

src/fsfw/tcdistribution/PusDistributor.cpp

@@ -146,7 +146,7 @@ ReturnValue_t PusDistributor::initialize() {
 
 void PusDistributor::checkerFailurePrinter() const {
 #if FSFW_VERBOSE_LEVEL >= 1
-  const char* keyword = "unnamed";
+  const char* keyword = "unnamed error";
   if (tcStatus == tcdistrib::INCORRECT_CHECKSUM) {
     keyword = "checksum";
   } else if (tcStatus == tcdistrib::INCORRECT_PRIMARY_HEADER) {
@@ -157,8 +157,6 @@ void PusDistributor::checkerFailurePrinter() const {
     keyword = "incorrect secondary header";
   } else if (tcStatus == tcdistrib::INCOMPLETE_PACKET) {
     keyword = "incomplete packet";
-  } else if (tcStatus == tcdistrib::INVALID_SEC_HEADER_FIELD) {
-    keyword = "invalid secondary header field";
   }
 #if FSFW_CPP_OSTREAM_ENABLED == 1
   sif::warning << "PUSDistributor::handlePacket: Packet format invalid, " << keyword << " error"

src/fsfw/tcdistribution/TcDistributor.cpp

@@ -5,9 +5,7 @@
 #include "fsfw/tmtcservices/TmTcMessage.h"
 
 TcDistributor::TcDistributor(object_id_t objectId) : SystemObject(objectId) {
-  auto mqArgs = MqArgs(objectId);
-  tcQueue = QueueFactory::instance()->createMessageQueue(
-      DISTRIBUTER_MAX_PACKETS, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  tcQueue = QueueFactory::instance()->createMessageQueue(DISTRIBUTER_MAX_PACKETS);
 }
 
 TcDistributor::~TcDistributor() { QueueFactory::instance()->deleteMessageQueue(tcQueue); }

src/fsfw/thermal/AbstractTemperatureSensor.cpp

@@ -4,13 +4,14 @@
 
 AbstractTemperatureSensor::AbstractTemperatureSensor(object_id_t setObjectid,
                                                      ThermalModuleIF *thermalModule)
-    : SystemObject(setObjectid), healthHelper(this, setObjectid), parameterHelper(this) {
-  if (thermalModule != nullptr) {
+    : SystemObject(setObjectid),
+      commandQueue(NULL),
+      healthHelper(this, setObjectid),
+      parameterHelper(this) {
+  if (thermalModule != NULL) {
     thermalModule->registerSensor(this);
   }
-  auto mqArgs = MqArgs(setObjectid, static_cast<void *>(this));
-  commandQueue = QueueFactory::instance()->createMessageQueue(
-      3, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  commandQueue = QueueFactory::instance()->createMessageQueue();
 }
 
 AbstractTemperatureSensor::~AbstractTemperatureSensor() {

src/fsfw/thermal/AbstractTemperatureSensor.h

@@ -51,7 +51,7 @@ class AbstractTemperatureSensor : public HasHealthIF,
   HasHealthIF::HealthState getHealth();
 
  protected:
-  MessageQueueIF* commandQueue = nullptr;
+  MessageQueueIF* commandQueue;
   HealthHelper healthHelper;
   ParameterHelper parameterHelper;
 

src/fsfw/thermal/Heater.cpp

@@ -12,9 +12,7 @@ Heater::Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1)
       switch1(switch1),
       heaterOnCountdown(10800000) /*about two orbits*/,
       parameterHelper(this) {
-  auto mqArgs = MqArgs(objectId, static_cast<void*>(this));
-  eventQueue = QueueFactory::instance()->createMessageQueue(
-      3, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  eventQueue = QueueFactory::instance()->createMessageQueue();
 }
 
 Heater::~Heater() { QueueFactory::instance()->deleteMessageQueue(eventQueue); }

src/fsfw/thermal/ThermalComponentIF.h

@@ -13,9 +13,9 @@ class ThermalComponentIF : public HasParametersIF {
   static const Event COMPONENT_TEMP_HIGH = MAKE_EVENT(2, severity::LOW);
   static const Event COMPONENT_TEMP_OOL_LOW = MAKE_EVENT(3, severity::LOW);
   static const Event COMPONENT_TEMP_OOL_HIGH = MAKE_EVENT(4, severity::LOW);
-  //!< Is thrown when a device should start-up, but the temperature is out
-  //!< of OP range. P1: thermalState of the component, P2: 0
-  static const Event TEMP_NOT_IN_OP_RANGE = MAKE_EVENT(5, severity::LOW);
+  static const Event TEMP_NOT_IN_OP_RANGE = MAKE_EVENT(
+      5, severity::LOW);  //!< Is thrown when a device should start-up, but the temperature is out
+                          //!< of OP range. P1: thermalState of the component, P2: 0
 
   static const uint8_t INTERFACE_ID = CLASS_ID::THERMAL_COMPONENT_IF;
   static const ReturnValue_t INVALID_TARGET_STATE = MAKE_RETURN_CODE(1);

src/fsfw/timemanager/CdsShortTimeStamper.cpp

@@ -6,11 +6,6 @@
 
 CdsShortTimeStamper::CdsShortTimeStamper(object_id_t objectId) : SystemObject(objectId) {}
 
-ReturnValue_t CdsShortTimeStamper::addTimeStamp(uint8_t *buffer, const uint8_t maxSize) {
-  size_t serLen = 0;
-  return serialize(&buffer, &serLen, maxSize, SerializeIF::Endianness::NETWORK);
-}
-
 ReturnValue_t CdsShortTimeStamper::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
                                              SerializeIF::Endianness streamEndianness) const {
   if (*size + getSerializedSize() > maxSize) {
@@ -33,15 +28,22 @@ size_t CdsShortTimeStamper::getSerializedSize() const { return getTimestampSize(
 
 ReturnValue_t CdsShortTimeStamper::deSerialize(const uint8_t **buffer, size_t *size,
                                                SerializeIF::Endianness streamEndianness) {
-  return returnvalue::FAILED;
-}
-
-ReturnValue_t CdsShortTimeStamper::readTimeStamp(const uint8_t *buffer, size_t maxSize) {
-  if (maxSize < getTimestampSize()) {
+  if (size == nullptr or buffer == nullptr) {
+    return returnvalue::FAILED;
+  }
+  if (*size < getTimestampSize()) {
     return SerializeIF::STREAM_TOO_SHORT;
   }
   size_t foundLen = 0;
-  return CCSDSTime::convertFromCcsds(&readTime, buffer, &foundLen, maxSize);
+  if (((**buffer >> 4) & 0b111) != CCSDSTime::TimeCodeIdentification::CDS) {
+    return BAD_TIMESTAMP;
+  }
+  auto res = CCSDSTime::convertFromCcsds(&readTime, *buffer, &foundLen, *size);
+  if (res == returnvalue::OK) {
+    *size -= getSerializedSize();
+    *buffer += getSerializedSize();
+  }
+  return res;
 }
 
 timeval &CdsShortTimeStamper::getTime() { return readTime; }

src/fsfw/timemanager/CdsShortTimeStamper.h

@@ -3,7 +3,7 @@
 
 #include "CCSDSTime.h"
 #include "TimeReaderIF.h"
-#include "TimeStamperIF.h"
+#include "TimeWriterIF.h"
 #include "fsfw/objectmanager/SystemObject.h"
 
 /**
@@ -15,7 +15,7 @@
  * overriding the #addTimeStamp function.
  * @ingroup utility
  */
-class CdsShortTimeStamper : public TimeStamperIF, public TimeReaderIF, public SystemObject {
+class CdsShortTimeStamper : public TimeWriterIF, public TimeReaderIF, public SystemObject {
  public:
   static constexpr size_t TIMESTAMP_LEN = 7;
   /**
@@ -25,20 +25,11 @@ class CdsShortTimeStamper : public TimeStamperIF, public TimeReaderIF, public Sy
    */
   explicit CdsShortTimeStamper(object_id_t objectId);
 
-  /**
-   * Adds a CCSDS CDC short 8 byte timestamp to the given buffer.
-   * This function can be overriden to use a custom timestamp.
-   * @param buffer
-   * @param maxSize
-   * @return
-   */
-  ReturnValue_t addTimeStamp(uint8_t *buffer, uint8_t maxSize) override;
   ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
                           Endianness streamEndianness) const override;
   [[nodiscard]] size_t getSerializedSize() const override;
   ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
                             Endianness streamEndianness) override;
-  ReturnValue_t readTimeStamp(const uint8_t *buffer, size_t maxSize) override;
   timeval &getTime() override;
   [[nodiscard]] size_t getTimestampSize() const override;
 

src/fsfw/timemanager/Countdown.cpp

@@ -1,11 +1,7 @@
 #include "fsfw/timemanager/Countdown.h"
 
-Countdown::Countdown(uint32_t initialTimeout, bool startImmediately) : timeout(initialTimeout) {
-  if (startImmediately) {
-    setTimeout(initialTimeout);
-  } else {
-    timeout = initialTimeout;
-  }
+Countdown::Countdown(uint32_t initialTimeout) : timeout(initialTimeout) {
+  setTimeout(initialTimeout);
 }
 
 Countdown::~Countdown() {}

src/fsfw/timemanager/Countdown.h

@@ -26,9 +26,8 @@ class Countdown {
    * Otherwise a call to hasTimedOut might return True.
    *
    * @param initialTimeout Countdown duration in milliseconds
-   * @param startImmediately  Set to false if countdown should not be started immediately
    */
-  Countdown(uint32_t initialTimeout = 0, bool startImmediately = true);
+  Countdown(uint32_t initialTimeout = 0);
   ~Countdown();
   /**
    * Call to set a new countdown duration.

src/fsfw/timemanager/TimeReaderIF.h

@@ -5,12 +5,28 @@
 
 #include "TimeStampIF.h"
 #include "fsfw/returnvalues/returnvalue.h"
+#include "fsfw/serialize/SerializeIF.h"
 
-class TimeReaderIF : public TimeStampIF {
+class TimeReaderIF : public SerializeIF, public TimeStampIF {
  public:
   ~TimeReaderIF() override = default;
-  virtual ReturnValue_t readTimeStamp(const uint8_t* buffer, size_t maxSize) = 0;
   virtual timeval& getTime() = 0;
+
+  [[nodiscard]] size_t getSerializedSize() const override { return getTimestampSize(); }
+
+  ReturnValue_t readTimeStamp(const uint8_t* buf, size_t maxSize) {
+    size_t dummy = 0;
+    return deSerialize(buf, dummy, maxSize, SerializeIF::Endianness::NETWORK);
+  }
+
+ private:
+  /**
+   *   Forbidden, use dedicated IF @TimeWriterIF
+   */
+  [[nodiscard]] ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                                        Endianness streamEndianness) const override {
+    return returnvalue::FAILED;
+  }
 };
 
 #endif  // FSFW_TIMEMANAGER_TIMEREADERIF_H

src/fsfw/timemanager/TimeStamperIF.h

@@ -1,23 +0,0 @@
-#ifndef FSFW_TIMEMANAGER_TIMESTAMPERIF_H_
-#define FSFW_TIMEMANAGER_TIMESTAMPERIF_H_
-
-#include "TimeStampIF.h"
-#include "fsfw/returnvalues/returnvalue.h"
-#include "fsfw/serialize/SerializeIF.h"
-
-/**
- * A class implementing this IF provides facilities to add a time stamp to the
- * buffer provided.
- * Implementors need to ensure that calling the method is thread-safe, i.e.
- * addTimeStamp may be called in parallel from a different context.
- */
-class TimeStamperIF : public SerializeIF, public TimeStampIF {
- public:
-  virtual ReturnValue_t addTimeStamp(uint8_t* buffer, uint8_t maxSize) = 0;
-  ~TimeStamperIF() override = default;
-  size_t getTimestampSize() const override { return getSerializedSize(); }
-
- protected:
-};
-
-#endif /* FSFW_TIMEMANAGER_TIMESTAMPERIF_H_ */

src/fsfw/timemanager/TimeWriterIF.h

@@ -0,0 +1,34 @@
+#ifndef FSFW_TIMEMANAGER_TIMESTAMPERIF_H_
+#define FSFW_TIMEMANAGER_TIMESTAMPERIF_H_
+
+#include "TimeStampIF.h"
+#include "fsfw/returnvalues/returnvalue.h"
+#include "fsfw/serialize/SerializeIF.h"
+
+/**
+ * A class implementing this IF provides facilities to add a time stamp to the
+ * buffer provided.
+ * Implementors need to ensure that calling the method is thread-safe, i.e.
+ * addTimeStamp may be called in parallel from a different context.
+ */
+class TimeWriterIF : public SerializeIF, public TimeStampIF {
+ public:
+  ~TimeWriterIF() override = default;
+  [[nodiscard]] size_t getTimestampSize() const override { return getSerializedSize(); }
+
+  ReturnValue_t addTimeStamp(uint8_t *buf, size_t maxSize) {
+    size_t dummy = 0;
+    return serialize(buf, dummy, maxSize, SerializeIF::Endianness::NETWORK);
+  }
+
+ private:
+  /**
+   *   Forbidden, use dedicated IF @TimeReaderIF
+   */
+  ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+                            Endianness streamEndianness) override {
+    return returnvalue::FAILED;
+  }
+};
+
+#endif /* FSFW_TIMEMANAGER_TIMESTAMPERIF_H_ */

src/fsfw/tmstorage/TmStoreBackendIF.h

@@ -33,47 +33,50 @@ class TmStoreBackendIF : public HasParametersIF {
   static const ReturnValue_t INVALID_REQUEST = MAKE_RETURN_CODE(15);
 
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::MEMORY;
-  //! Initiating sending data to store failed. Low, par1:
-  //! returnCode, par2: integer (debug info)
-  static const Event STORE_SEND_WRITE_FAILED = MAKE_EVENT(0, severity::LOW);
-  //! Data was sent, but writing failed. Low, par1: returnCode, par2: 0
-  static const Event STORE_WRITE_FAILED = MAKE_EVENT(1, severity::LOW);
-  //! Initiating reading data from store failed. Low, par1: returnCode, par2: 0
-  static const Event STORE_SEND_READ_FAILED = MAKE_EVENT(2, severity::LOW);
-  //! Data was requested, but access failed. Low, par1: returnCode, par2: 0
-  static const Event STORE_READ_FAILED = MAKE_EVENT(3, severity::LOW);
-  //! An unexpected TM packet or data message occurred. Low, par1: 0, par2: integer (debug info)
-  static const Event UNEXPECTED_MSG = MAKE_EVENT(4, severity::LOW);
-  //! Storing data failed. May simply be a full store. Low, par1: returnCode,
-  //! par2: integer (sequence count of failed packet).
-  static const Event STORING_FAILED = MAKE_EVENT(5, severity::LOW);
-  //! Dumping retrieved data failed. Low, par1: returnCode,
-  //! par2: integer (sequence count of failed packet).
-  static const Event TM_DUMP_FAILED = MAKE_EVENT(6, severity::LOW);
-  //! Corrupted init data or read error. Low, par1: returnCode, par2: integer (debug info)
-  //! Store was not initialized. Starts empty. Info, parameters both zero.
-  static const Event STORE_INIT_FAILED = MAKE_EVENT(7, severity::LOW);
-  //! Data was read out, but it is inconsistent. Low par1:
-  //! Memory address of corruption, par2: integer (debug info)
-  static const Event STORE_INIT_EMPTY = MAKE_EVENT(8, severity::INFO);
-
-  static const Event STORE_CONTENT_CORRUPTED = MAKE_EVENT(9, severity::LOW);
-  //! Info event indicating the store will be initialized, either at boot or after IOB switch.
-  //! Info. pars: 0
-  static const Event STORE_INITIALIZE = MAKE_EVENT(10, severity::INFO);
-  //! Info event indicating the store was successfully initialized, either at boot or after
-  //! IOB switch. Info. pars: 0
-  static const Event INIT_DONE = MAKE_EVENT(11, severity::INFO);
-  //! Info event indicating that dumping finished successfully.
-  //! par1: Number of dumped packets. par2: APID/SSC (16bits each)
-  static const Event DUMP_FINISHED = MAKE_EVENT(12, severity::INFO);
-  //! Info event indicating that deletion finished successfully.
-  //! par1:Number of deleted packets. par2: APID/SSC (16bits each)
-  static const Event DELETION_FINISHED = MAKE_EVENT(13, severity::INFO);
-  //! Info event indicating that something went wrong during deletion. pars: 0
-  static const Event DELETION_FAILED = MAKE_EVENT(14, severity::LOW);
-  //! Info that the a auto catalog report failed
-  static const Event AUTO_CATALOGS_SENDING_FAILED = MAKE_EVENT(15, severity::INFO);
+  static const Event STORE_SEND_WRITE_FAILED =
+      MAKE_EVENT(0, severity::LOW);  //!< Initiating sending data to store failed. Low, par1:
+                                     //!< returnCode, par2: integer (debug info)
+  static const Event STORE_WRITE_FAILED = MAKE_EVENT(
+      1, severity::LOW);  //!< Data was sent, but writing failed. Low, par1: returnCode, par2: 0
+  static const Event STORE_SEND_READ_FAILED =
+      MAKE_EVENT(2, severity::LOW);  //!< Initiating reading data from store failed. Low, par1:
+                                     //!< returnCode, par2: 0
+  static const Event STORE_READ_FAILED = MAKE_EVENT(
+      3, severity::LOW);  //!< Data was requested, but access failed. Low, par1: returnCode, par2: 0
+  static const Event UNEXPECTED_MSG =
+      MAKE_EVENT(4, severity::LOW);  //!< An unexpected TM packet or data message occurred. Low,
+                                     //!< par1: 0, par2: integer (debug info)
+  static const Event STORING_FAILED = MAKE_EVENT(
+      5, severity::LOW);  //!< Storing data failed. May simply be a full store. Low, par1:
+                          //!< returnCode, par2: integer (sequence count of failed packet).
+  static const Event TM_DUMP_FAILED =
+      MAKE_EVENT(6, severity::LOW);  //!< Dumping retrieved data failed. Low, par1: returnCode,
+                                     //!< par2: integer (sequence count of failed packet).
+  static const Event STORE_INIT_FAILED =
+      MAKE_EVENT(7, severity::LOW);  //!< Corrupted init data or read error. Low, par1: returnCode,
+                                     //!< par2: integer (debug info)
+  static const Event STORE_INIT_EMPTY = MAKE_EVENT(
+      8, severity::INFO);  //!< Store was not initialized. Starts empty. Info, parameters both zero.
+  static const Event STORE_CONTENT_CORRUPTED =
+      MAKE_EVENT(9, severity::LOW);  //!< Data was read out, but it is inconsistent. Low par1:
+                                     //!< Memory address of corruption, par2: integer (debug info)
+  static const Event STORE_INITIALIZE =
+      MAKE_EVENT(10, severity::INFO);  //!< Info event indicating the store will be initialized,
+                                       //!< either at boot or after IOB switch. Info. pars: 0
+  static const Event INIT_DONE = MAKE_EVENT(
+      11, severity::INFO);  //!< Info event indicating the store was successfully initialized,
+                            //!< either at boot or after IOB switch. Info. pars: 0
+  static const Event DUMP_FINISHED = MAKE_EVENT(
+      12, severity::INFO);  //!< Info event indicating that dumping finished successfully. par1:
+                            //!< Number of dumped packets. par2: APID/SSC (16bits each)
+  static const Event DELETION_FINISHED = MAKE_EVENT(
+      13, severity::INFO);  //!< Info event indicating that deletion finished successfully. par1:
+                            //!< Number of deleted packets. par2: APID/SSC (16bits each)
+  static const Event DELETION_FAILED = MAKE_EVENT(
+      14,
+      severity::LOW);  //!< Info event indicating that something went wrong during deletion. pars: 0
+  static const Event AUTO_CATALOGS_SENDING_FAILED =
+      MAKE_EVENT(15, severity::INFO);  //!< Info that the a auto catalog report failed
 
   virtual ~TmStoreBackendIF() {}
 

src/fsfw/tmstorage/TmStorePackets.h

@@ -7,7 +7,7 @@
 #include "fsfw/serialize/SerialLinkedListAdapter.h"
 #include "fsfw/serialize/SerializeElement.h"
 #include "fsfw/timemanager/CCSDSTime.h"
-#include "fsfw/timemanager/TimeStamperIF.h"
+#include "fsfw/timemanager/TimeWriterIF.h"
 #include "fsfw/tmtcpacket/pus/tm/PusTmMinimal.h"
 #include "tmStorageConf.h"
 

src/fsfw/tmtcpacket/pus/CustomUserDataIF.h

@@ -7,6 +7,6 @@ class CustomUserDataIF {
  public:
   virtual ~CustomUserDataIF() = default;
   virtual ReturnValue_t setRawUserData(const uint8_t* data, size_t len) = 0;
-  virtual ReturnValue_t setSerializableUserData(SerializeIF& serializable) = 0;
+  virtual ReturnValue_t setSerializableUserData(const SerializeIF& serializable) = 0;
 };
 #endif  // FSFW_TMTCPACKET_CREATORDATAIF_H

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

@@ -14,7 +14,6 @@ PusTcCreator::PusTcCreator(SpacePacketParams spParams, PusTcParams pusParams)
 ReturnValue_t PusTcCreator::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
                                       SerializeIF::Endianness streamEndianness) const {
   const uint8_t *start = *buffer;
-  size_t userDataLen = pusParams.dataWrapper.getLength();
   if (*size + getSerializedSize() > maxSize) {
     return SerializeIF::BUFFER_TOO_SHORT;
   }
@@ -37,17 +36,8 @@ ReturnValue_t PusTcCreator::serialize(uint8_t **buffer, size_t *size, size_t max
   if (result != returnvalue::OK) {
     return result;
   }
-  if (pusParams.dataWrapper.type == util::DataTypes::RAW) {
-    const uint8_t *data = pusParams.dataWrapper.dataUnion.raw.data;
-    if (data != nullptr and userDataLen > 0) {
-      std::memcpy(*buffer, data, userDataLen);
-      *buffer += userDataLen;
-      *size += userDataLen;
-    }
-  } else if (pusParams.dataWrapper.type == util::DataTypes::SERIALIZABLE and
-             pusParams.dataWrapper.dataUnion.serializable != nullptr) {
-    result = pusParams.dataWrapper.dataUnion.serializable->serialize(buffer, size, maxSize,
-                                                                     streamEndianness);
+  if (pusParams.appData != nullptr) {
+    result = pusParams.appData->serialize(buffer, size, maxSize, streamEndianness);
     if (result != returnvalue::OK) {
       return result;
     }
@@ -58,8 +48,11 @@ ReturnValue_t PusTcCreator::serialize(uint8_t **buffer, size_t *size, size_t max
 }
 
 void PusTcCreator::updateSpLengthField() {
-  spCreator.setDataLen(ecss::PusTcDataFieldHeader::MIN_SIZE + pusParams.dataWrapper.getLength() +
-                       1);
+  size_t len = ecss::PusTcDataFieldHeader::MIN_SIZE + 1;
+  if (pusParams.appData != nullptr) {
+    len += pusParams.appData->getSerializedSize();
+  }
+  spCreator.setDataLen(len);
 }
 
 size_t PusTcCreator::getSerializedSize() const { return spCreator.getFullPacketLen(); }
@@ -91,14 +84,15 @@ SpacePacketParams &PusTcCreator::getSpParams() { return spCreator.getParams(); }
 
 ReturnValue_t PusTcCreator::setRawUserData(const uint8_t *data, size_t len) {
   // TODO: Check length field?
-  pusParams.dataWrapper.setRawData({data, len});
+  pusParams.bufAdapter.setConstBuffer(data, len);
+  pusParams.appData = &pusParams.bufAdapter;
   updateSpLengthField();
   return returnvalue::OK;
 }
 
-ReturnValue_t PusTcCreator::setSerializableUserData(SerializeIF &serializable) {
+ReturnValue_t PusTcCreator::setSerializableUserData(const SerializeIF &serializable) {
   // TODO: Check length field?
-  pusParams.dataWrapper.setSerializable(serializable);
+  pusParams.appData = &serializable;
   updateSpLengthField();
   return returnvalue::OK;
 }

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

@@ -1,22 +1,30 @@
 #ifndef FSFW_TMTCPACKET_TCPACKETDESERIALIZER_H
 #define FSFW_TMTCPACKET_TCPACKETDESERIALIZER_H
 
+#include "fsfw/serialize/SerialBufferAdapter.h"
 #include "fsfw/tmtcpacket/RedirectableDataPointerIF.h"
 #include "fsfw/tmtcpacket/ccsds/SpacePacketCreator.h"
 #include "fsfw/tmtcpacket/ccsds/SpacePacketIF.h"
 #include "fsfw/tmtcpacket/pus/CustomUserDataIF.h"
 #include "fsfw/tmtcpacket/pus/defs.h"
 #include "fsfw/tmtcpacket/pus/tc/PusTcIF.h"
-#include "fsfw/util/dataWrapper.h"
 
 struct PusTcParams {
   PusTcParams(uint8_t service_, uint8_t subservice_) : service(service_), subservice(subservice_) {}
 
+  void setRawAppData(const uint8_t *data, size_t len) {
+    bufAdapter.setConstBuffer(data, len);
+    appData = &bufAdapter;
+  }
+
+  void setSerializableAppData(const SerializeIF &serializable) { appData = &serializable; }
+
   uint8_t service;
   uint8_t subservice;
   uint8_t ackFlags = ecss::ACK_ALL;
   uint16_t sourceId = 0;
-  util::DataWrapper dataWrapper{};
+  SerialBufferAdapter<uint8_t> bufAdapter;
+  const SerializeIF *appData = nullptr;
   uint8_t pusVersion = ecss::PusVersion::PUS_C;
 };
 
@@ -52,7 +60,7 @@ class PusTcCreator : public PusTcIF, public SerializeIF, public CustomUserDataIF
   [[nodiscard]] uint8_t getSubService() const override;
   [[nodiscard]] uint16_t getSourceId() const override;
   ReturnValue_t setRawUserData(const uint8_t *data, size_t len) override;
-  ReturnValue_t setSerializableUserData(SerializeIF &serializable) override;
+  ReturnValue_t setSerializableUserData(const SerializeIF &serializable) override;
 
   // Load all big endian helpers into the class namespace
   using SerializeIF::serializeBe;

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

@@ -3,7 +3,7 @@
 #include <utility>
 
 #include "fsfw/globalfunctions/CRC.h"
-#include "fsfw/timemanager/TimeStamperIF.h"
+#include "fsfw/timemanager/TimeWriterIF.h"
 
 PusTmCreator::PusTmCreator(SpacePacketParams initSpParams, PusTmParams initPusParams)
     : pusParams(initPusParams), spCreator(std::move(initSpParams)) {
@@ -30,7 +30,7 @@ uint8_t PusTmCreator::getSubService() const { return pusParams.secHeader.subserv
 
 PusTmParams& PusTmCreator::getParams() { return pusParams; }
 
-void PusTmCreator::setTimeStamper(TimeStamperIF& timeStamper_) {
+void PusTmCreator::setTimeStamper(TimeWriterIF& timeStamper_) {
   pusParams.secHeader.timeStamper = &timeStamper_;
   updateSpLengthField();
 }
@@ -51,7 +51,6 @@ ReturnValue_t PusTmCreator::serialize(uint8_t** buffer, size_t* size, size_t max
   if (result != returnvalue::OK) {
     return result;
   }
-  size_t userDataLen = pusParams.dataWrapper.getLength();
   **buffer =
       ((pusParams.secHeader.pusVersion << 4) & 0xF0) | (pusParams.secHeader.scTimeRefStatus & 0x0F);
   *buffer += 1;
@@ -77,15 +76,8 @@ ReturnValue_t PusTmCreator::serialize(uint8_t** buffer, size_t* size, size_t max
     }
   }
 
-  if (pusParams.dataWrapper.type == util::DataTypes::RAW and
-      pusParams.dataWrapper.dataUnion.raw.data != nullptr) {
-    std::memcpy(*buffer, pusParams.dataWrapper.dataUnion.raw.data, userDataLen);
-    *buffer += userDataLen;
-    *size += userDataLen;
-  } else if (pusParams.dataWrapper.type == util::DataTypes::SERIALIZABLE and
-             pusParams.dataWrapper.dataUnion.serializable != nullptr) {
-    result = pusParams.dataWrapper.dataUnion.serializable->serialize(buffer, size, maxSize,
-                                                                     streamEndianness);
+  if (pusParams.sourceData != nullptr) {
+    result = pusParams.sourceData->serialize(buffer, size, maxSize, streamEndianness);
     if (result != returnvalue::OK) {
       return result;
     }
@@ -106,13 +98,15 @@ ReturnValue_t PusTmCreator::deSerialize(const uint8_t** buffer, size_t* size,
   return returnvalue::FAILED;
 }
 
-TimeStamperIF* PusTmCreator::getTimestamper() const { return pusParams.secHeader.timeStamper; }
+TimeWriterIF* PusTmCreator::getTimestamper() const { return pusParams.secHeader.timeStamper; }
 
 SpacePacketParams& PusTmCreator::getSpParams() { return spCreator.getParams(); }
 
 void PusTmCreator::updateSpLengthField() {
-  size_t headerLen = PusTmIF::MIN_SEC_HEADER_LEN + pusParams.dataWrapper.getLength() +
-                     sizeof(ecss::PusChecksumT) - 1;
+  size_t headerLen = PusTmIF::MIN_SEC_HEADER_LEN + sizeof(ecss::PusChecksumT) - 1;
+  if (pusParams.sourceData != nullptr) {
+    headerLen += pusParams.sourceData->getSerializedSize();
+  }
   if (pusParams.secHeader.timeStamper != nullptr) {
     headerLen += pusParams.secHeader.timeStamper->getSerializedSize();
   }
@@ -134,12 +128,17 @@ void PusTmCreator::setMessageTypeCounter(uint16_t messageTypeCounter) {
 void PusTmCreator::setDestId(uint16_t destId) { pusParams.secHeader.destId = destId; }
 
 ReturnValue_t PusTmCreator::setRawUserData(const uint8_t* data, size_t len) {
-  pusParams.dataWrapper.setRawData({data, len});
+  if (data == nullptr or len == 0) {
+    pusParams.sourceData = nullptr;
+  } else {
+    pusParams.adapter.setConstBuffer(data, len);
+    pusParams.sourceData = &pusParams.adapter;
+  }
   updateSpLengthField();
   return returnvalue::OK;
 }
-ReturnValue_t PusTmCreator::setSerializableUserData(SerializeIF& serializable) {
-  pusParams.dataWrapper.setSerializable(serializable);
+ReturnValue_t PusTmCreator::setSerializableUserData(const SerializeIF& serializable) {
+  pusParams.sourceData = &serializable;
   updateSpLengthField();
   return returnvalue::OK;
 }

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

@@ -2,18 +2,18 @@
 #define FSFW_TMTCPACKET_TMPACKETCREATOR_H
 
 #include "PusTmIF.h"
+#include "fsfw/serialize/SerialBufferAdapter.h"
 #include "fsfw/tmtcpacket/ccsds/SpacePacketCreator.h"
 #include "fsfw/tmtcpacket/pus/CustomUserDataIF.h"
-#include "fsfw/util/dataWrapper.h"
 
 struct PusTmSecHeader {
   PusTmSecHeader() = default;
-  PusTmSecHeader(uint8_t service, uint8_t subservice, TimeStamperIF* timeStamper)
+  PusTmSecHeader(uint8_t service, uint8_t subservice, TimeWriterIF* timeStamper)
       : service(service), subservice(subservice), timeStamper(timeStamper) {}
 
   uint8_t service = 0;
   uint8_t subservice = 0;
-  TimeStamperIF* timeStamper = nullptr;
+  TimeWriterIF* timeStamper = nullptr;
   uint8_t pusVersion = ecss::PusVersion::PUS_C;
   uint8_t scTimeRefStatus = 0;
   uint16_t messageTypeCounter = 0;
@@ -23,22 +23,28 @@ struct PusTmSecHeader {
 struct PusTmParams {
   PusTmParams() = default;
   explicit PusTmParams(PusTmSecHeader secHeader) : secHeader(secHeader){};
-  PusTmParams(PusTmSecHeader secHeader, util::DataWrapper dataWrapper)
-      : secHeader(secHeader), dataWrapper(dataWrapper) {}
-
-  PusTmParams(uint8_t service, uint8_t subservice, TimeStamperIF* timeStamper)
+  PusTmParams(PusTmSecHeader secHeader, const SerializeIF& data)
+      : secHeader(secHeader), sourceData(&data) {}
+  PusTmParams(PusTmSecHeader secHeader, const uint8_t* data, size_t dataLen)
+      : secHeader(secHeader), adapter(data, dataLen), sourceData(&adapter) {}
+  PusTmParams(uint8_t service, uint8_t subservice, TimeWriterIF* timeStamper)
       : secHeader(service, subservice, timeStamper) {}
 
-  PusTmParams(uint8_t service, uint8_t subservice, TimeStamperIF* timeStamper,
-              util::DataWrapper dataWrapper_)
+  PusTmParams(uint8_t service, uint8_t subservice, TimeWriterIF* timeStamper,
+              const SerializeIF& data_)
       : PusTmParams(service, subservice, timeStamper) {
-    dataWrapper = dataWrapper_;
+    sourceData = &data_;
   }
+
+  PusTmParams(uint8_t service, uint8_t subservice, TimeWriterIF* timeStamper, const uint8_t* data,
+              size_t dataLen)
+      : secHeader(service, subservice, timeStamper), adapter(data, dataLen), sourceData(&adapter) {}
   PusTmSecHeader secHeader;
-  util::DataWrapper dataWrapper{};
+  SerialBufferAdapter<uint8_t> adapter;
+  const SerializeIF* sourceData = nullptr;
 };
 
-class TimeStamperIF;
+class TimeWriterIF;
 
 /**
  * This class provides a high-level interface to create PUS TM packets and then @serialize
@@ -56,7 +62,7 @@ class PusTmCreator : public SerializeIF, public PusTmIF, public CustomUserDataIF
   PusTmCreator(SpacePacketParams initSpParams, PusTmParams initPusParams);
   ~PusTmCreator() override = default;
 
-  void setTimeStamper(TimeStamperIF& timeStamper);
+  void setTimeStamper(TimeWriterIF& timeStamper);
   /**
    * This function disables the CRC16 calculation on serialization. This is useful to avoid
    * duplicate calculation if some lower level component needs to update fields like the sequence
@@ -86,9 +92,9 @@ class PusTmCreator : public SerializeIF, public PusTmIF, public CustomUserDataIF
   ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
                           Endianness streamEndianness) const override;
   [[nodiscard]] size_t getSerializedSize() const override;
-  [[nodiscard]] TimeStamperIF* getTimestamper() const;
+  [[nodiscard]] TimeWriterIF* getTimestamper() const;
   ReturnValue_t setRawUserData(const uint8_t* data, size_t len) override;
-  ReturnValue_t setSerializableUserData(SerializeIF& serializable) override;
+  ReturnValue_t setSerializableUserData(const SerializeIF& serializable) override;
 
   // Load all big endian (network endian) helpers into scope
   using SerializeIF::serializeBe;

src/fsfw/tmtcpacket/pus/tm/PusTmIF.h

@@ -4,7 +4,7 @@
 #include <cstddef>
 #include <cstdint>
 
-#include "fsfw/timemanager/TimeStamperIF.h"
+#include "fsfw/timemanager/TimeWriterIF.h"
 #include "fsfw/tmtcpacket/pus/PusIF.h"
 #include "fsfw/tmtcpacket/pus/defs.h"
 

src/fsfw/tmtcservices/CommandingServiceBase.cpp

@@ -25,10 +25,8 @@ CommandingServiceBase::CommandingServiceBase(object_id_t setObjectId, uint16_t a
       tmHelper(service, tmStoreHelper, tmSendHelper),
       verificationReporter(verificationReporter),
       commandMap(numberOfParallelCommands) {
-  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
-  size_t mqSz = MessageQueueMessage::MAX_MESSAGE_SIZE;
-  commandQueue = QueueFactory::instance()->createMessageQueue(queueDepth, mqSz, &mqArgs);
-  requestQueue = QueueFactory::instance()->createMessageQueue(queueDepth, mqSz, &mqArgs);
+  commandQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
+  requestQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
 }
 
 void CommandingServiceBase::setPacketSource(object_id_t packetSource_) {
@@ -106,7 +104,7 @@ ReturnValue_t CommandingServiceBase::initialize() {
   // This avoids duplicate calculation of the CRC16
   tmStoreHelper.disableCrcCalculation();
   if (tmTimeStamper == nullptr) {
-    tmTimeStamper = ObjectManager::instance()->get<TimeStamperIF>(objects::TIME_STAMPER);
+    tmTimeStamper = ObjectManager::instance()->get<TimeWriterIF>(objects::TIME_STAMPER);
     if (tmTimeStamper == nullptr) {
       return ObjectManagerIF::CHILD_INIT_FAILED;
     }
@@ -223,7 +221,7 @@ void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result, Comma
 
   // In case a new command is to be sent immediately, this is performed here.
   // If no new command is sent, only analyse reply result by initializing
-  // sendResult as returnvalue::OK
+  // sendResult as RETURN_OK
   ReturnValue_t sendResult = returnvalue::OK;
   if (nextCommand->getCommand() != CommandMessage::CMD_NONE) {
     sendResult = commandQueue->sendMessage(reply->getSender(), nextCommand);

src/fsfw/tmtcservices/CommandingServiceBase.h

@@ -272,7 +272,7 @@ class CommandingServiceBase : public SystemObject,
   MessageQueueIF* commandQueue = nullptr;
   MessageQueueIF* requestQueue = nullptr;
 
-  TimeStamperIF* tmTimeStamper = nullptr;
+  TimeWriterIF* tmTimeStamper = nullptr;
   VerificationReporterIF* verificationReporter;
 
   InternalErrorReporterIF* errReporter = nullptr;

src/fsfw/tmtcservices/PusServiceBase.cpp

@@ -178,7 +178,7 @@ ReturnValue_t PusServiceBase::initializeTmStoreHelper(TmStoreHelper& tmStoreHelp
   }
 
   if (psbParams.timeStamper == nullptr) {
-    auto timerStamper = ObjectManager::instance()->get<TimeStamperIF>(objects::TIME_STAMPER);
+    auto timerStamper = ObjectManager::instance()->get<TimeWriterIF>(objects::TIME_STAMPER);
     if (timerStamper != nullptr) {
       tmStoreHelper.setTimeStamper(*timerStamper);
     }

src/fsfw/tmtcservices/PusServiceBase.h

@@ -65,7 +65,7 @@ struct PsbParams {
    * register itself at that object.
    */
   PUSDistributorIF* pusDistributor = nullptr;
-  TimeStamperIF* timeStamper = nullptr;
+  TimeWriterIF* timeStamper = nullptr;
 };
 
 namespace Factory {

src/fsfw/tmtcservices/SourceSequenceCounter.h

@@ -5,28 +5,20 @@
 
 class SourceSequenceCounter {
  private:
-  uint16_t sequenceCount = 0;
+  uint16_t sequenceCount;
 
  public:
-  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); }
+  SourceSequenceCounter() : sequenceCount(0) {}
+  void increment() {
+    sequenceCount = (sequenceCount + 1) % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
+  }
+  void decrement() {
+    sequenceCount = (sequenceCount - 1) % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
+  }
   uint16_t get() { return this->sequenceCount; }
-  void reset(uint16_t toValue = 0) { sequenceCount = toValue % (ccsds::LIMIT_SEQUENCE_COUNT); }
-  SourceSequenceCounter& operator++(int) {
-    this->increment();
-    return *this;
+  void reset(uint16_t toValue = 0) {
+    sequenceCount = toValue % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
   }
-  SourceSequenceCounter& operator--(int) {
-    this->decrement();
-    return *this;
-  }
-  SourceSequenceCounter& operator=(const uint16_t& newCount) {
-    sequenceCount = newCount;
-    return *this;
-  }
-
-  operator uint16_t() { return this->get(); }
 };
 
 #endif /* FSFW_TMTCSERVICES_SOURCESEQUENCECOUNTER_H_ */

src/fsfw/tmtcservices/SpacePacketParser.h

@@ -17,7 +17,6 @@
  */
 class SpacePacketParser {
  public:
-
   struct FoundPacketInfo {
     size_t startIdx = 0;
     size_t sizeFound = 0;
@@ -51,9 +50,7 @@ class SpacePacketParser {
   ReturnValue_t parseSpacePackets(const uint8_t** buffer, const size_t maxSize,
                                   FoundPacketInfo& packetInfo);
 
-  size_t getAmountRead() {
-    return amountRead;
-  }
+  size_t getAmountRead() { return amountRead; }
 
   void reset() {
     nextStartIdx = 0;

src/fsfw/tmtcservices/TmStoreHelper.cpp

@@ -11,7 +11,7 @@ TmStoreHelper::TmStoreHelper(uint16_t defaultApid, StorageManagerIF& tmStore) :
 }
 
 TmStoreHelper::TmStoreHelper(uint16_t defaultApid, StorageManagerIF& tmStore,
-                             TimeStamperIF& timeStamper)
+                             TimeWriterIF& timeStamper)
     : tmStore(&tmStore) {
   creator.setApid(defaultApid);
   creator.setTimeStamper(timeStamper);
@@ -59,7 +59,7 @@ ReturnValue_t TmStoreHelper::addPacketToStore() {
                            SerializeIF::Endianness::NETWORK);
 }
 
-void TmStoreHelper::setTimeStamper(TimeStamperIF& timeStamper_) {
+void TmStoreHelper::setTimeStamper(TimeWriterIF& timeStamper_) {
   creator.setTimeStamper(timeStamper_);
 }
 
@@ -67,7 +67,7 @@ void TmStoreHelper::setApid(uint16_t apid) { creator.setApid(apid); }
 
 PusTmCreator& TmStoreHelper::getCreatorRef() { return creator; }
 
-TimeStamperIF* TmStoreHelper::getTimeStamper() const { return creator.getTimestamper(); }
+TimeWriterIF* TmStoreHelper::getTimeStamper() const { return creator.getTimestamper(); }
 
 uint16_t TmStoreHelper::getApid() const { return creator.getApid(); }
 

src/fsfw/tmtcservices/TmStoreHelper.h

@@ -4,14 +4,14 @@
 #include "fsfw/internalerror/InternalErrorReporterIF.h"
 #include "fsfw/ipc/MessageQueueMessageIF.h"
 #include "fsfw/storagemanager/StorageManagerIF.h"
-#include "fsfw/timemanager/TimeStamperIF.h"
+#include "fsfw/timemanager/TimeWriterIF.h"
 #include "fsfw/tmtcpacket/pus/tm/PusTmCreator.h"
 
 class TmStoreHelper {
  public:
   explicit TmStoreHelper(uint16_t defaultApid);
   TmStoreHelper(uint16_t defaultApid, StorageManagerIF& tmStore);
-  TmStoreHelper(uint16_t defaultApid, StorageManagerIF& tmStore, TimeStamperIF& timeStamper);
+  TmStoreHelper(uint16_t defaultApid, StorageManagerIF& tmStore, TimeWriterIF& timeStamper);
 
   void disableCrcCalculation();
   [[nodiscard]] bool crcCalculationEnabled() const;
@@ -20,8 +20,8 @@ class TmStoreHelper {
 
   PusTmCreator& getCreatorRef();
 
-  void setTimeStamper(TimeStamperIF& timeStamper);
-  [[nodiscard]] TimeStamperIF* getTimeStamper() const;
+  void setTimeStamper(TimeWriterIF& timeStamper);
+  [[nodiscard]] TimeWriterIF* getTimeStamper() const;
 
   [[nodiscard]] StorageManagerIF* getTmStore() const;
   void setTmStore(StorageManagerIF& store);

src/fsfw/tmtcservices/TmTcBridge.cpp

@@ -15,9 +15,7 @@ TmTcBridge::TmTcBridge(object_id_t objectId, object_id_t tcDestination, object_i
       tcDestination(tcDestination)
 
 {
-  auto mqArgs = MqArgs(objectId, static_cast<void*>(this));
-  tmTcReceptionQueue = QueueFactory::instance()->createMessageQueue(
-      TMTC_RECEPTION_QUEUE_DEPTH, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  tmTcReceptionQueue = QueueFactory::instance()->createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
 }
 
 TmTcBridge::~TmTcBridge() { QueueFactory::instance()->deleteMessageQueue(tmTcReceptionQueue); }
@@ -36,7 +34,7 @@ ReturnValue_t TmTcBridge::setNumberOfSentPacketsPerCycle(uint8_t sentPacketsPerC
   }
 }
 
-ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(unsigned int maxNumberOfPacketsStored) {
+ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(uint8_t maxNumberOfPacketsStored) {
   if (maxNumberOfPacketsStored <= LIMIT_DOWNLINK_PACKETS_STORED) {
     this->maxNumberOfPacketsStored = maxNumberOfPacketsStored;
     return returnvalue::OK;
@@ -173,18 +171,15 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage* message) {
   }
 
   if (tmFifo->full()) {
-    if (warningSwitch) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::warning << "TmTcBridge::storeDownlinkData: TM downlink max. number "
-                      "of stored packet IDs reached!"
-                   << std::endl;
+    sif::warning << "TmTcBridge::storeDownlinkData: TM downlink max. number "
+                    "of stored packet IDs reached!"
+                 << std::endl;
 #else
-      sif::printWarning(
-          "TmTcBridge::storeDownlinkData: TM downlink max. number "
-          "of stored packet IDs reached!\n");
+    sif::printWarning(
+        "TmTcBridge::storeDownlinkData: TM downlink max. number "
+        "of stored packet IDs reached!\n");
 #endif
-      warningSwitch = true;
-    }
     if (overwriteOld) {
       tmFifo->retrieve(&storeId);
       tmStore->deleteData(storeId);

src/fsfw/tmtcservices/TmTcBridge.h

@@ -17,7 +17,7 @@ class TmTcBridge : public AcceptsTelemetryIF,
  public:
   static constexpr uint8_t TMTC_RECEPTION_QUEUE_DEPTH = 20;
   static constexpr uint8_t LIMIT_STORED_DATA_SENT_PER_CYCLE = 15;
-  static constexpr unsigned int LIMIT_DOWNLINK_PACKETS_STORED = 1000;
+  static constexpr uint8_t LIMIT_DOWNLINK_PACKETS_STORED = 200;
 
   static constexpr uint8_t DEFAULT_STORED_DATA_SENT_PER_CYCLE = 5;
   static constexpr uint8_t DEFAULT_DOWNLINK_PACKETS_STORED = 10;
@@ -42,7 +42,7 @@ class TmTcBridge : public AcceptsTelemetryIF,
    * @return -@c returnvalue::OK if value was set successfully
    *         -@c returnvalue::FAILED otherwise, stored value stays the same
    */
-  ReturnValue_t setMaxNumberOfPacketsStored(unsigned int maxNumberOfPacketsStored);
+  ReturnValue_t setMaxNumberOfPacketsStored(uint8_t maxNumberOfPacketsStored);
 
   /**
    * This will set up the bridge to overwrite old data in the FIFO.
@@ -71,8 +71,6 @@ class TmTcBridge : public AcceptsTelemetryIF,
   virtual uint16_t getIdentifier() override;
   virtual MessageQueueId_t getRequestQueue() override;
 
-  bool warningSwitch = true;
-
  protected:
   //! Cached for initialize function.
   object_id_t tmStoreId = objects::NO_OBJECT;
@@ -151,7 +149,7 @@ class TmTcBridge : public AcceptsTelemetryIF,
    */
   DynamicFIFO<store_address_t>* tmFifo = nullptr;
   uint8_t sentPacketsPerCycle = DEFAULT_STORED_DATA_SENT_PER_CYCLE;
-  unsigned int maxNumberOfPacketsStored = DEFAULT_DOWNLINK_PACKETS_STORED;
+  uint8_t maxNumberOfPacketsStored = DEFAULT_DOWNLINK_PACKETS_STORED;
 };
 
 #endif /* FSFW_TMTCSERVICES_TMTCBRIDGE_H_ */

src/fsfw/tmtcservices/tmHelpers.h

@@ -10,48 +10,33 @@ namespace telemetry {
 class DataWithObjectIdPrefix : public SerializeIF {
  public:
   DataWithObjectIdPrefix(object_id_t objectId, const uint8_t* srcData, size_t srcDataLen)
-      : objectId(objectId) {
-    dataWrapper.type = util::DataTypes::RAW;
-    dataWrapper.dataUnion.raw.data = srcData;
-    dataWrapper.dataUnion.raw.len = srcDataLen;
-  }
+      : objectId(objectId), bufAdapter(srcData, srcDataLen), userData(&bufAdapter) {}
 
-  DataWithObjectIdPrefix(object_id_t objectId, SerializeIF& serializable) : objectId(objectId) {
-    dataWrapper.type = util::DataTypes::SERIALIZABLE;
-    dataWrapper.dataUnion.serializable = &serializable;
-  }
+  DataWithObjectIdPrefix(object_id_t objectId, const SerializeIF& serializable)
+      : objectId(objectId), userData(&serializable) {}
 
   ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
                           Endianness streamEndianness) const override {
     if (*size + getSerializedSize() > maxSize) {
       return SerializeIF::BUFFER_TOO_SHORT;
     }
-    if (dataWrapper.type != util::DataTypes::RAW) {
-      if ((dataWrapper.dataUnion.raw.data == nullptr) and (dataWrapper.dataUnion.raw.len > 0)) {
-        return returnvalue::FAILED;
-      }
-    } else if (dataWrapper.type == util::DataTypes::SERIALIZABLE) {
-      if (dataWrapper.dataUnion.serializable == nullptr) {
-        return returnvalue::FAILED;
-      }
-    }
     ReturnValue_t result =
         SerializeAdapter::serialize(&objectId, buffer, size, maxSize, streamEndianness);
     if (result != returnvalue::OK) {
       return result;
     }
-    if (dataWrapper.type != util::DataTypes::RAW) {
-      std::memcpy(*buffer, dataWrapper.dataUnion.raw.data, dataWrapper.dataUnion.raw.len);
-      *buffer += dataWrapper.dataUnion.raw.len;
-      *size += dataWrapper.dataUnion.raw.len;
-    } else {
-      return dataWrapper.dataUnion.serializable->serialize(buffer, size, maxSize, streamEndianness);
+    if (userData != nullptr) {
+      return userData->serialize(buffer, size, maxSize, streamEndianness);
     }
     return returnvalue::OK;
   }
 
   [[nodiscard]] size_t getSerializedSize() const override {
-    return sizeof(objectId) + dataWrapper.getLength();
+    size_t len = 0;
+    if (userData != nullptr) {
+      len += userData->getSerializedSize();
+    }
+    return len;
   }
 
   ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
@@ -63,7 +48,8 @@ class DataWithObjectIdPrefix : public SerializeIF {
 
  private:
   object_id_t objectId;
-  util::DataWrapper dataWrapper{};
+  SerialBufferAdapter<uint8_t> bufAdapter;
+  const SerializeIF* userData = nullptr;
 };
 
 }  // namespace telemetry

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/common/CMakeLists.txt

@@ -1 +1,3 @@
 add_subdirectory(gpio)
+
+target_sources(${LIB_FSFW_NAME} PRIVATE printChar.c)

src/fsfw_hal/common/gpio/GpioIF.h

@@ -46,9 +46,9 @@ class GpioIF {
    *          an ouput or input gpio.
    *
    * @param gpioId    A unique number which specifies the GPIO to read.
-   * @param gpioState State of GPIO will be written to this reference
+   * @param gpioState State of GPIO will be written to this pointer.
    */
-  virtual ReturnValue_t readGpio(gpioId_t gpioId, gpio::Levels& gpioState) = 0;
+  virtual ReturnValue_t readGpio(gpioId_t gpioId, int* gpioState) = 0;
 };
 
 #endif /* COMMON_GPIO_GPIOIF_H_ */

src/fsfw_hal/common/gpio/gpioDefinitions.h

@@ -9,7 +9,7 @@ using gpioId_t = uint16_t;
 
 namespace gpio {
 
-enum class Levels : int { LOW = 0, HIGH = 1, FAILED = -1, NONE = 99 };
+enum class Levels : int { LOW = 0, HIGH = 1, NONE = 99 };
 
 enum class Direction : int { IN = 0, OUT = 1 };
 

src/fsfw_hal/common/printChar.c

@@ -0,0 +1,10 @@
+#include <stdio.h>
+#include <stdbool.h>
+
+void __attribute__((weak)) printChar(const char* character, bool errStream) {
+  if (errStream) {
+    fprintf(stderr, "%c", *character);
+  } else {
+    printf("%c", *character);
+  }
+}

src/fsfw_hal/devicehandlers/GyroL3GD20Handler.cpp

@@ -252,8 +252,6 @@ ReturnValue_t GyroHandlerL3GD20H::initializeLocalDataPool(localpool::DataPool &l
   localDataPoolMap.emplace(L3GD20H::ANG_VELOC_Y, new PoolEntry<float>({0.0}));
   localDataPoolMap.emplace(L3GD20H::ANG_VELOC_Z, new PoolEntry<float>({0.0}));
   localDataPoolMap.emplace(L3GD20H::TEMPERATURE, new PoolEntry<float>({0.0}));
-  poolManager.subscribeForRegularPeriodicPacket(
-      subdp::RegularHkPeriodicParams(dataset.getSid(), false, 10.0));
   return returnvalue::OK;
 }
 

src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp

@@ -371,16 +371,13 @@ float MgmLIS3MDLHandler::getSensitivityFactor(MGMLIS3MDL::Sensitivies sens) {
 
 ReturnValue_t MgmLIS3MDLHandler::enableTemperatureSensor(const uint8_t *commandData,
                                                          size_t commandDataLen) {
-  if (commandData == nullptr) {
-    return INVALID_COMMAND_PARAMETER;
-  }
   triggerEvent(CHANGE_OF_SETUP_PARAMETER);
   uint32_t size = 2;
   commandBuffer[0] = writeCommand(MGMLIS3MDL::CTRL_REG1);
   if (commandDataLen > 1) {
     return INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS;
   }
-  switch (commandData[0]) {
+  switch (*commandData) {
     case (MGMLIS3MDL::ON): {
       commandBuffer[1] = registers[0] | (1 << 7);
       break;

src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h

@@ -2,7 +2,6 @@
 #define MISSION_DEVICES_MGMLIS3MDLHANDLER_H_
 
 #include "devicedefinitions/MgmLIS3HandlerDefs.h"
-#include "events/subsystemIdRanges.h"
 #include "fsfw/devicehandlers/DeviceHandlerBase.h"
 #include "fsfw/globalfunctions/PeriodicOperationDivider.h"
 

src/fsfw_hal/linux/CommandExecutor.cpp

@@ -32,8 +32,6 @@ ReturnValue_t CommandExecutor::execute() {
   } else if (state == States::PENDING) {
     return COMMAND_PENDING;
   }
-  // Reset data in read vector
-  std::memset(readVec.data(), 0, readVec.size());
   currentCmdFile = popen(currentCmd.c_str(), "r");
   if (currentCmdFile == nullptr) {
     lastError = errno;
@@ -207,5 +205,3 @@ ReturnValue_t CommandExecutor::executeBlocking() {
   }
   return returnvalue::OK;
 }
-
-const std::vector<char>& CommandExecutor::getReadVector() const { return readVec; }

src/fsfw_hal/linux/CommandExecutor.h

@@ -107,8 +107,6 @@ class CommandExecutor {
    */
   void reset();
 
-  const std::vector<char>& getReadVector() const;
-
  private:
   std::string currentCmd;
   bool blocking = true;