that should do the job

Reviewed-on: fsfw/fsfw#694

.gitignore

@@ -10,8 +10,5 @@
 .settings
 .metadata
 
-# VSCode
-.vscode
-
 /build*
 /cmake-build*

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

@@ -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()

automation/Dockerfile

@@ -5,7 +5,7 @@ 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 python3 pip doxygen graphviz
+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
 
@@ -23,3 +23,7 @@ RUN git clone https://github.com/ETLCPP/etl.git && \
 
 #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

@@ -5,7 +5,7 @@ pipeline {
     }
     agent {
         docker { 
-            image 'fsfw-ci:d5'
+            image 'fsfw-ci:d6'
             args '--network host'
         }
     }
@@ -52,14 +52,12 @@ pipeline {
                     sh 'cmake -DFSFW_BUILD_DOCS=ON -DFSFW_OSAL=host ..'
                     sh 'make Sphinx'
                     sshagent(credentials: ['documentation-buildfix']) {
-                        sh 'ssh -o StrictHostKeyChecking=no buildfix@documentation.intra.irs.uni-stuttgart.de rm -rf /mnt/data/www/html/fsfw/development/*'
-                        sh 'scp -o StrictHostKeyChecking=no -r docs/sphinx/* buildfix@documentation.intra.irs.uni-stuttgart.de:/mnt/data/www/html/fsfw/development'
+                        sh 'rsync -r --delete docs/sphinx/* buildfix@documentation.irs.uni-stuttgart.de:/fsfw/development'
                     }
                 }
                 dir(BUILDDIR) {
                     sshagent(credentials: ['documentation-buildfix']) {
-                        sh 'ssh -o StrictHostKeyChecking=no buildfix@documentation.intra.irs.uni-stuttgart.de rm -rf /mnt/data/www/html/fsfw/coverage/development/*'
-                        sh 'scp -o StrictHostKeyChecking=no -r fsfw-tests_coverage/* buildfix@documentation.intra.irs.uni-stuttgart.de:/mnt/data/www/html/fsfw/coverage/development'
+                        sh 'rsync -r --delete fsfw-tests_coverage/* buildfix@documentation.irs.uni-stuttgart.de:/fsfw/coverage/development'
                     }
                 }
             }
@@ -73,14 +71,12 @@ pipeline {
                     sh 'cmake -DFSFW_BUILD_DOCS=ON -DFSFW_OSAL=host ..'
                     sh 'make Sphinx'
                     sshagent(credentials: ['documentation-buildfix']) {
-                        sh 'ssh -o StrictHostKeyChecking=no buildfix@documentation.intra.irs.uni-stuttgart.de rm -rf /mnt/data/www/html/fsfw/master/*'
-                        sh 'scp -o StrictHostKeyChecking=no -r docs/sphinx/* buildfix@documentation.intra.irs.uni-stuttgart.de:/mnt/data/www/html/fsfw/master'
+                        sh 'rsync -r --delete docs/sphinx/* buildfix@documentation.irs.uni-stuttgart.de:/fsfw/master'
                     }
                 }
                 dir(BUILDDIR) {
                     sshagent(credentials: ['documentation-buildfix']) {
-                        sh 'ssh -o StrictHostKeyChecking=no buildfix@documentation.intra.irs.uni-stuttgart.de rm -rf /mnt/data/www/html/fsfw/coverage/master/*'
-                        sh 'scp -o StrictHostKeyChecking=no -r fsfw-tests_coverage/* buildfix@documentation.intra.irs.uni-stuttgart.de:/mnt/data/www/html/fsfw/coverage/master'
+                        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
 -----------------

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

@@ -15,7 +15,6 @@ add_subdirectory(globalfunctions)
 add_subdirectory(health)
 add_subdirectory(housekeeping)
 add_subdirectory(internalerror)
-add_subdirectory(introspection)
 add_subdirectory(ipc)
 add_subdirectory(memory)
 add_subdirectory(modes)

src/fsfw/action/Action.cpp

@@ -1,62 +0,0 @@
-#include "Action.h"
-
-#include <fsfw/serialize/SerializeAdapter.h>
-
-#undef Action
-
-#ifdef FSFW_INTROSPECTION
-
-Action::Action() {}
-
-void Action::setEnum(EnumIF *theEnum) {
-  id = theEnum->getValue();
-  name = theEnum->getDescription();
-}
-
-const char *Action::getName() { return name; }
-#else
-Action::Action(ActionId_t id) : id(id) {}
-#endif
-ActionId_t Action::getId() { return id; }
-
-void Action::registerParameter(ParameterIF *parameter) { parameterList.push_back(parameter); }
-
-std::vector<ParameterIF *> const *Action::getParameters() const { return &parameterList; }
-
-size_t Action::getSerializedSize() const {
-  size_t size = SerializeAdapter::getSerializedSize(&id);
-  for (auto parameter : *getParameters()) {
-    size += parameter->getSerializedSize();
-  }
-  return size;
-}
-
-ReturnValue_t Action::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-                                Endianness streamEndianness) const {
-  ReturnValue_t result = SerializeAdapter::serialize(&id, buffer, size, maxSize, streamEndianness);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  for (auto parameter : *getParameters()) {
-    result = parameter->serialize(buffer, size, maxSize, streamEndianness);
-    if (result != returnvalue::OK) {
-      return result;
-    }
-  }
-  return result;
-}
-
-ReturnValue_t Action::deSerialize(const uint8_t **buffer, size_t *size,
-                                  Endianness streamEndianness) {
-  ReturnValue_t result = returnvalue::OK;/* TODO not needed as must have been read before to find this action = SerializeAdapter::deSerialize(&id, buffer, size, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
-    return result;
-  }*/
-  for (auto parameter : *getParameters()) {
-    result = parameter->deSerialize(buffer, size, streamEndianness);
-    if (result != returnvalue::OK) {
-      return result;
-    }
-  }
-  return result;
-}

src/fsfw/action/Action.h

@@ -1,50 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-
-#include <vector>
-
-#include <fsfw/serialize/SerializeIF.h>
-#include "ActionMessage.h"
-#include "ParameterIF.h"
-
-
-#ifdef FSFW_INTROSPECTION
-#include "../introspection/Enum.h"
-#endif
-
-class Action: public SerializeIF {
- public:
-#ifdef FSFW_INTROSPECTION
-  Action();
-  void setEnum(EnumIF* id);
-  const char *getName();
-#else
-  Action(ActionId_t id);
-#endif
-  ActionId_t getId();
-
-  MessageQueueId_t commandedBy;
-
-  [[nodiscard]] virtual ReturnValue_t handle() = 0;
-
-  void registerParameter(ParameterIF *parameter);
-
-  std::vector<ParameterIF *> const *getParameters() const;
-
-  ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-                                  Endianness streamEndianness) const override;
-
-  size_t getSerializedSize() const override;
-
-  ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-                                    Endianness streamEndianness) override;
-
- private:
-  ActionId_t id;
-  
-#ifdef FSFW_INTROSPECTION
-  const char *name;
-#endif
-  std::vector<ParameterIF *> parameterList;
-};

src/fsfw/action/ActionHelper.cpp

@@ -57,10 +57,6 @@ void ActionHelper::finish(bool success, MessageQueueId_t reportTo, ActionId_t co
 
 void ActionHelper::setQueueToUse(MessageQueueIF* queue) { queueToUse = queue; }
 
-MessageQueueIF const * ActionHelper::getQueue() const {
-  return queueToUse;
-}
-
 void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
                                     store_address_t dataAddress) {
   const uint8_t* dataPtr = nullptr;
@@ -70,29 +66,9 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t act
     CommandMessage reply;
     ActionMessage::setStepReply(&reply, actionId, 0, result);
     queueToUse->sendMessage(commandedBy, &reply);
-    ipcStore->deleteData(dataAddress);
     return;
   }
-  auto actionIter = actionMap.find(actionId);
-  if (actionIter == actionMap.end()){
-    CommandMessage reply;
-    ActionMessage::setStepReply(&reply, actionId, 0, HasActionsIF::INVALID_ACTION_ID);
-    queueToUse->sendMessage(commandedBy, &reply);
-    ipcStore->deleteData(dataAddress);
-    return;
-  }
-  Action* action = actionIter->second;
-  result = action->deSerialize(&dataPtr, &size, SerializeIF::Endianness::NETWORK);
-  if ((result != returnvalue::OK) or (size != 0)){
-    CommandMessage reply;
-    ActionMessage::setStepReply(&reply, actionId, 0, HasActionsIF::INVALID_PARAMETERS);
-    queueToUse->sendMessage(commandedBy, &reply);
-    ipcStore->deleteData(dataAddress);
-    return;
-  }
-  //TODO call action->check()
-  action->commandedBy = commandedBy;
-  result = owner->executeAction(action);
+  result = owner->executeAction(actionId, commandedBy, dataPtr, size);
   ipcStore->deleteData(dataAddress);
   if (result == HasActionsIF::EXECUTION_FINISHED) {
     CommandMessage reply;
@@ -187,11 +163,3 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo, ActionId_t rep
   }
   return result;
 }
-
-void ActionHelper::registerAction(Action* action) {
-  //TODO error handling
-  ActionId_t id = action->getId();
-  actionMap.emplace(id, action);
-}
-
-std::map<ActionId_t, Action*> const* ActionHelper::getActionMap() { return &actionMap; }

src/fsfw/action/ActionHelper.h

@@ -1,13 +1,9 @@
 #ifndef FSFW_ACTION_ACTIONHELPER_H_
 #define FSFW_ACTION_ACTIONHELPER_H_
 
-#include <map>
-
-#include "Action.h"
 #include "ActionMessage.h"
 #include "fsfw/ipc/MessageQueueIF.h"
 #include "fsfw/serialize/SerializeIF.h"
-
 /**
  * @brief Action Helper is a helper class which handles action messages
  *
@@ -102,16 +98,6 @@ class ActionHelper {
    */
   void setQueueToUse(MessageQueueIF* queue);
 
-  /**
-   * Needed so templateAction can check if actionHelper was
-   * contructed already to aid in debuggig a nasty coding error.
-   */
-  MessageQueueIF const * getQueue() const;
-
-  void registerAction(Action* action);
-
-  std::map<ActionId_t, Action*> const* getActionMap();
-
  protected:
   //! Increase of value of this per step
   static const uint8_t STEP_OFFSET = 1;
@@ -122,8 +108,6 @@ class ActionHelper {
   MessageQueueIF* queueToUse;
   //! Pointer to an IPC Store, initialized during construction or
   StorageManagerIF* ipcStore = nullptr;
-  //! Map of all implemented Actions
-  std::map<ActionId_t, Action*> actionMap;
 
   /**
    * Internal function called by handleActionMessage

src/fsfw/action/CMakeLists.txt

@@ -1,3 +1,3 @@
 target_sources(
-  ${LIB_FSFW_NAME} PRIVATE Action.cpp ActionHelper.cpp ActionMessage.cpp
+  ${LIB_FSFW_NAME} PRIVATE ActionHelper.cpp ActionMessage.cpp
                            CommandActionHelper.cpp SimpleActionHelper.cpp)

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/action/HasActionsIF.h

@@ -44,12 +44,8 @@ class HasActionsIF {
   /**
    * Function to get the MessageQueueId_t of the implementing object
    * @return MessageQueueId_t of the object
-   *
    */
   [[nodiscard]] virtual MessageQueueId_t getCommandQueue() const = 0;
-
-  [[nodiscard]] virtual ActionHelper* getActionHelper() = 0;
-
   /**
    * Execute or initialize the execution of a certain function.
    * The ActionHelpers will execute this function and behave differently
@@ -59,7 +55,8 @@ class HasActionsIF {
    * -@c EXECUTION_FINISHED Finish reply will be generated
    * -@c Not returnvalue::OK Step failure reply will be generated
    */
-  virtual ReturnValue_t executeAction(Action* action) = 0;
+  virtual ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+                                      const uint8_t* data, size_t size) = 0;
 };
 
 #endif /* FSFW_ACTION_HASACTIONSIF_H_ */

src/fsfw/action/MinMaxParameter.h

@@ -1,40 +0,0 @@
-#pragma once
-
-#include "Parameter.h"
-
-template <typename T>
-class MinMaxParameter : public Parameter<T> {
-#ifdef FSFW_INTROSPECTION
- private:
-  MinMaxParameter(Action *owner, const char *name, T min, T max)
-      : Parameter<T>(owner, name), min(min), max(max) {}
-
- public:
-  static MinMaxParameter createMinMaxParameter(Action *owner, const char *name, T min, T max) {
-    return MinMaxParameter(owner, name, min, max);
-  }
-  virtual double getMinFloating() override { return static_cast<double>(min); }
-  virtual int64_t getMinSigned() override { return static_cast<int64_t>(min); }
-
-  virtual double getMaxFloating() override { return static_cast<double>(max); }
-  virtual int64_t getMaxSigned() override { return static_cast<int64_t>(max); }
-
-#else
- private:
-  MinMaxParameter(Action *owner, T min, T max) : Parameter<T>(owner), min(min), max(max) {}
-
- public:
-  static MinMaxParameter createMinMaxParameter(Action *owner, T min, T max) {
-    return MinMaxParameter(owner, min, max);
-  }
-#endif
- private:
-  T min;
-  T max;
-};
-
-#ifdef FSFW_INTROSPECTION
-#define createMinMaxParameter(p1, p2, p3, p4) createMinMaxParameter(p1, p2, p3, p4)
-#else
-#define createMinMaxParameter(p1, p2, p3, p4) createMinMaxParameter(p1, p3, p4)
-#endif

src/fsfw/action/Parameter.h

@@ -1,120 +0,0 @@
-#pragma once
-
-#include <stdio.h>
-
-#include "Action.h"
-#include <fsfw/introspection/Types.h>
-#include <fsfw/introspection/TypesHelper.h>
-#include "ParameterIF.h"
-// TODO: ifdef introspection stuff
-
-
-
-template <typename T>
-class Parameter : public ParameterIF {
- protected:
-#ifdef FSFW_INTROSPECTION
-  Parameter(Action *owner, const char *name)
-      : name(name)
-#else
-  Parameter(Action *owner)
-#endif
-  {
-    owner->registerParameter(this);
-  }
-
- public:
-#ifdef FSFW_INTROSPECTION
-  static Parameter createParameter(Action *owner, const char *name) {
-    return Parameter(owner, name);
-  }
-#else
-  static Parameter createParameter(Action *owner) { return Parameter(owner); }
-#endif
-
-  bool isValid() override {
-    return enumHelper<std::is_base_of<EnumIF, T>::value>::isValid(&value);
-  }
-
-  operator T(){
-    return value;
-  }
-
-  Parameter& operator =(const T& newValue){
-    value = newValue;
-    return *this;
-  }
-
-#ifdef FSFW_INTROSPECTION
-  Types::ParameterType getType() override {
-    return enumHelper<std::is_base_of<EnumIF, T>::value>::template getType<T>();
-  }
-#endif
-
-  T value;
-
-  ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-                          Endianness streamEndianness) const override {
-    return SerializeAdapter::serialize(&value, buffer, size, maxSize, streamEndianness);
-  }
-
-  size_t getSerializedSize() const override { return SerializeAdapter::getSerializedSize(&value); }
-
-  ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-                            Endianness streamEndianness) override {
-    return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
-  }
-
-#ifdef FSFW_INTROSPECTION
-  double getFloating() override { return (double)value; }
-  int64_t getSigned() override { return (int64_t)value; }
-
-  bool setFloating(double value) override {
-    if (getType() != Types::FLOATING) {
-      return false;
-    }
-    this->value = T(value);
-    return true;
-  }
-
-  bool setSigned(int64_t value) override {
-    if ((getType() != Types::SIGNED) && (getType() != Types::ENUM)) {
-      return false;
-    }
-    this->value = T(value);
-    return true;
-  }
-
-  double getMinFloating() override {
-    return enumHelper<std::is_base_of<EnumIF, T>::value>::template getMin<T>();
-  }
-  int64_t getMinSigned() override {
-    return enumHelper<std::is_base_of<EnumIF, T>::value>::template getMin<T>();
-  }
-
-  double getMaxFloating() override {
-    return enumHelper<std::is_base_of<EnumIF, T>::value>::template getMax<T>();
-  }
-  int64_t getMaxSigned() override {
-    return enumHelper<std::is_base_of<EnumIF, T>::value>::template getMax<T>();
-  }
-
-  std::vector<int64_t> getEnumValues() override {
-    return enumHelper<std::is_base_of<EnumIF, T>::value>::getEnumValues(&value);
-  }
-  const char *const *getEnumDescriptions() override {
-    return enumHelper<std::is_base_of<EnumIF, T>::value>::getEnumDescriptions(&value);
-  }
-
-  const char *getName() override { return name; }
-
- private:
-  const char *name;
-#endif
-};
-
-#ifdef FSFW_INTROSPECTION
-#define createParameter(p1, p2) createParameter(p1, p2)
-#else
-#define createParameter(p1, p2) createParameter(p1)
-#endif

src/fsfw/action/ParameterIF.h

@@ -1,45 +0,0 @@
-#pragma once
-
-#include <fsfw/serialize/SerializeIF.h>
-#include <fsfw/introspection/Types.h>
-
-#ifdef FSFW_INTROSPECTION
-#include <vector>
-#endif
-
-class ParameterIF : public SerializeIF {
- public:
-  virtual bool isValid() = 0;
-#ifdef FSFW_INTROSPECTION
-
-  
-
-  virtual const char *getName() = 0;
-
-  virtual Types::ParameterType getType() = 0;
-
-  virtual double getFloating() = 0;
-  virtual int64_t getSigned() = 0;
-
-  virtual bool setFloating(double value) = 0;
-  virtual bool setSigned(int64_t value) = 0;
-
-  virtual double getMinFloating() = 0;
-  virtual int64_t getMinSigned() = 0;
-
-  virtual double getMaxFloating() = 0;
-  virtual int64_t getMaxSigned() = 0;
-
-  virtual std::vector<int64_t> getEnumValues() = 0;
-  virtual const char *const * getEnumDescriptions() = 0;
-
-  // ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-  //                                 Endianness streamEndianness) const override = 0;
-
-  // size_t getSerializedSize() const override = 0;
-
-  // ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-  //                                   Endianness streamEndianness) override = 0;
-
-#endif
-};

src/fsfw/action/SimpleActionHelper.cpp

@@ -44,27 +44,11 @@ void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId
   if (result != returnvalue::OK) {
     ActionMessage::setStepReply(&reply, actionId, 0, result);
     queueToUse->sendMessage(commandedBy, &reply);
-    ipcStore->deleteData(dataAddress);
     return;
   }
-  auto actionIter = actionMap.find(actionId);
-  if (actionIter == actionMap.end()){
-    CommandMessage reply;
-    ActionMessage::setStepReply(&reply, actionId, 0, HasActionsIF::INVALID_ACTION_ID);
-    queueToUse->sendMessage(commandedBy, &reply);
-    ipcStore->deleteData(dataAddress);
-    return;
-  }
-  Action* action = actionIter->second;
-  result = action->deSerialize(&dataPtr, &size, SerializeIF::Endianness::NETWORK);
-  if ((result != returnvalue::OK) or (size != 0)) {
-    CommandMessage reply;
-    ActionMessage::setStepReply(&reply, actionId, 0, HasActionsIF::INVALID_PARAMETERS);
-    queueToUse->sendMessage(commandedBy, &reply);
-    ipcStore->deleteData(dataAddress);
-    return;
-  }
-  result = action->handle();
+  lastCommander = commandedBy;
+  lastAction = actionId;
+  result = owner->executeAction(actionId, commandedBy, dataPtr, size);
   ipcStore->deleteData(dataAddress);
   switch (result) {
     case returnvalue::OK:

src/fsfw/action/TemplateAction.h

@@ -1,29 +0,0 @@
-#pragma once
-
-#include "Action.h"
-#include "fsfw/serviceinterface/ServiceInterface.h"
-
-template <class owner, class action, class ActionEnum>
-class TemplateAction : public Action {
- public:
-#ifdef FSFW_INTROSPECTION
-  TemplateAction(owner *myOwner, ActionEnum id) : Action(), myOwner(myOwner) {
-    Action::setEnum(&id);
-    if (myOwner->getActionHelper() == nullptr) {
-      sif::error
-          << "TemplateAction::TemplateAction: Action instances need to be created (ie located) after the actionHelper instance."
-          << "Program will segfault now..." << std::endl;
-    }
-    myOwner->getActionHelper()->registerAction(this);
-  }
-#else
-  TemplateAction(owner *myOwner, ActionEnum id) : Action((uint32_t)id), myOwner(myOwner) {
-    myOwner->getActionHelper()->registerAction(this);
-  }
-#endif
-
-  ReturnValue_t handle() override { return myOwner->handleAction(dynamic_cast<action *>(this)); }
-
- private:
-  owner *myOwner;
-};

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/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); }
@@ -103,10 +101,6 @@ ReturnValue_t ControllerBase::performOperation(uint8_t opCode) {
 
 void ControllerBase::modeChanged(Mode_t mode_, Submode_t submode_) {}
 
-const ModeHelper * ControllerBase::getModeHelper() const {
-  return &modeHelper;
-}
-
 ReturnValue_t ControllerBase::setHealth(HealthState health) {
   switch (health) {
     case HEALTHY:

src/fsfw/controller/ControllerBase.h

@@ -3,7 +3,6 @@
 
 #include "fsfw/health/HasHealthIF.h"
 #include "fsfw/health/HealthHelper.h"
-#include "fsfw/introspection/ClasslessEnum.h"
 #include "fsfw/modes/HasModesIF.h"
 #include "fsfw/modes/ModeHelper.h"
 #include "fsfw/objectmanager/SystemObject.h"
@@ -21,9 +20,7 @@ class ControllerBase : public HasModesIF,
                        public ExecutableObjectIF,
                        public SystemObject {
  public:
-  FSFW_CLASSLESS_ENUM(ControllerModes, Mode_t,
-                      ((CONTROLLER_MODE_ON, MODE_ON, "On"))((CONTROLLER_MODE_OFF, MODE_OFF,
-                                                             "Off"))((MODE_NORMAL, 2, "Normal")))
+  static const Mode_t MODE_NORMAL = 2;
 
   ControllerBase(object_id_t setObjectId, object_id_t parentId, size_t commandQueueDepth = 3);
   ~ControllerBase() override;
@@ -42,9 +39,6 @@ class ControllerBase : public HasModesIF,
   void setTaskIF(PeriodicTaskIF *task) override;
   ReturnValue_t initializeAfterTaskCreation() override;
 
-  /** HasModeIF override */
-  const ModeHelper *getModeHelper() const override;
-
  protected:
   /**
    * Implemented by child class. Handle command messages which are not

src/fsfw/controller/ExtendedControllerBase.cpp

@@ -8,12 +8,11 @@ ExtendedControllerBase::ExtendedControllerBase(object_id_t objectId, object_id_t
 
 ExtendedControllerBase::~ExtendedControllerBase() = default;
 
-ActionHelper *ExtendedControllerBase::getActionHelper() {
-  return &actionHelper;
-}
-
-ReturnValue_t ExtendedControllerBase::executeAction(Action *action) {
-  return action->handle();
+ReturnValue_t ExtendedControllerBase::executeAction(ActionId_t actionId,
+                                                    MessageQueueId_t commandedBy,
+                                                    const uint8_t *data, size_t size) {
+  /* Needs to be overriden and implemented by child class. */
+  return returnvalue::OK;
 }
 
 object_id_t ExtendedControllerBase::getObjectId() const { return SystemObject::getObjectId(); }

src/fsfw/controller/ExtendedControllerBase.h

@@ -29,10 +29,6 @@ class ExtendedControllerBase : public ControllerBase,
   ReturnValue_t performOperation(uint8_t opCode) override;
   ReturnValue_t initializeAfterTaskCreation() override;
 
-  /* HasActionsIF overrides */
-  ActionHelper* getActionHelper() override;
-  ReturnValue_t executeAction(Action* actionId) override;
-
  protected:
   LocalDataPoolManager poolManager;
   ActionHelper actionHelper;
@@ -53,6 +49,10 @@ class ExtendedControllerBase : public ControllerBase,
   /* Handle the four messages mentioned above */
   void handleQueue() override;
 
+  /* HasActionsIF overrides */
+  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+                              const uint8_t* data, size_t size) override;
+
   /* HasLocalDatapoolIF overrides */
   LocalDataPoolManager* getHkManagerHandle() override;
   [[nodiscard]] object_id_t getObjectId() const override;

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/datapoollocal/LocalPoolObjectBase.cpp

@@ -48,12 +48,12 @@ LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
   if (hkOwner == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "LocalPoolVariable: The supplied pool owner 0x" << std::hex << poolOwner
-               << std::dec << " did not implement the correct interface "
+               << std::dec << "  does not exist or does not implement the correct interface "
                << "HasLocalDataPoolIF" << std::endl;
 #else
     sif::printError(
-        "LocalPoolVariable: The supplied pool owner 0x%08x did not implement the correct "
-        "interface HasLocalDataPoolIF\n",
+        "LocalPoolVariable: The supplied pool owner 0x%08x does not exist or does not implement "
+        "the correct interface HasLocalDataPoolIF\n",
         poolOwner);
 #endif
     return;

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));
@@ -1324,21 +1311,20 @@ void DeviceHandlerBase::handleDeviceTm(const SerializeIF& dataSet, DeviceCommand
   }
 }
 
-ActionHelper* DeviceHandlerBase::getActionHelper() { return &actionHelper; }
-
-ReturnValue_t DeviceHandlerBase::executeAction(Action* action) {
+ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+                                               const uint8_t* data, size_t size) {
   ReturnValue_t result = acceptExternalDeviceCommands();
   if (result != returnvalue::OK) {
     return result;
   }
-  DeviceCommandMap::iterator iter = deviceCommandMap.find(action->getId());
+  DeviceCommandMap::iterator iter = deviceCommandMap.find(actionId);
   if (iter == deviceCommandMap.end()) {
     result = COMMAND_NOT_SUPPORTED;
   } else if (iter->second.isExecuting) {
     result = COMMAND_ALREADY_SENT;
   } else {
-    iter->second.sendReplyTo = action->commandedBy;
-    result = action->handle();
+    iter->second.sendReplyTo = commandedBy;
+    result = buildCommandFromCommand(actionId, data, size);
   }
   if (result == returnvalue::OK) {
     iter->second.isExecuting = true;
@@ -1468,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,
@@ -1492,7 +1476,7 @@ ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
   this->poolManager.initializeAfterTaskCreation();
 
   if (setStartupImmediately) {
-    startTransition(MODE_ON, getInitialSubmode());
+    startTransition(MODE_ON, SUBMODE_NONE);
   }
   return returnvalue::OK;
 }
@@ -1576,36 +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;
-    }
-  }
-}
-
-ModeHelper const* DeviceHandlerBase::getModeHelper() const { return &modeHelper; }
-
-ModeDefinitionHelper DeviceHandlerBase::getModeDefinitionHelper() {
-  return ModeDefinitionHelper::create<DeviceHandlerMode, DefaultSubmode>();
-}
-

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);
 
   /**
@@ -204,15 +200,13 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    */
   virtual void setParentQueue(MessageQueueId_t parentQueueId);
 
-  /** @brief  Implementations required for HasActionIF */
-  ActionHelper* getActionHelper() override;
-  ReturnValue_t executeAction(Action *action) override;
+  /** @brief  Implementation required for HasActionIF */
+  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+                              const uint8_t *data, size_t size) override;
 
   Mode_t getTransitionSourceMode() const;
   Submode_t getTransitionSourceSubMode() const;
-  void getMode(Mode_t *mode, Submode_t *submode) override;
-  ModeHelper const * getModeHelper() const override;
-  ModeDefinitionHelper getModeDefinitionHelper() override;
+  virtual void getMode(Mode_t *mode, Submode_t *submode);
   HealthState getHealth();
   ReturnValue_t setHealth(HealthState health);
   virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
@@ -316,8 +310,6 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    *    - Anything else triggers an even with the returnvalue as a parameter
    */
   virtual ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) = 0;
-  
-  //TODO Remove and update documentation
   /**
    * @brief 	Build a device command packet from data supplied by a direct
    *          command (PUS Service 8)
@@ -344,7 +336,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    */
   virtual ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
                                                 const uint8_t *commandData,
-                                                size_t commandDataLen) {return returnvalue::FAILED;}
+                                                size_t commandDataLen) = 0;
 
   /* Reply handling */
   /**
@@ -471,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.
    */
@@ -663,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;
 
@@ -787,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
@@ -854,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;
@@ -1345,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

@@ -4,7 +4,6 @@
 #include "../action/HasActionsIF.h"
 #include "../datapoollocal/localPoolDefinitions.h"
 #include "../events/Event.h"
-#include "../introspection/ClasslessEnum.h"
 #include "../ipc/MessageQueueSenderIF.h"
 #include "../modes/HasModesIF.h"
 #include "DeviceHandlerMessage.h"
@@ -38,30 +37,23 @@ class DeviceHandlerIF {
    * The mode of the device itself is transparent to the user but related to the mode of the
    * handler. MODE_ON and MODE_OFF are included in hasModesIF.h
    */
-  FSFW_CLASSLESS_ENUM(
-      DeviceHandlerMode, Mode_t,
-      //! The device is powered and ready to perform operations. In this mode, no
-      //! commands are sent by the device handler itself, but direct commands can be
-      //! commanded and will be executed/forwarded to the device
-      //! This is an alias of MODE_ON to have the FSFW_ENUM complete for introspection
-      ((DEVICEHANDLER_MODE_ON, HasModesIF::MODE_ON, "On"))
-      //! The device is powered off. The only command accepted in this
-      //! mode is a mode change to on.
-      //! This is an alias of MODE_OFF to have the FSFW_ENUM complete for introspection
-      ((DEVICEHANDLER_MODE_OFF, HasModesIF::MODE_OFF, "Off"))
-      //! The device is powered on and the device handler periodically sends
-      //! commands. The commands to be sent are selected by the handler
-      //! according to the submode.
-      ((MODE_NORMAL, 2, "Normal"))
-      //! The device is powered on and ready to perform operations. In this mode,
-      //! raw commands can be sent. The device handler will send all replies
-      //! received from the command back to the commanding object as raw TM
-      ((MODE_RAW, 3, "Raw"))
-      //! The device is shut down but the switch could not be turned off, so the
-      //! device still is powered. In this mode, only a mode change to @c MODE_OFF
-      //! can be commanded, which tries to switch off the device again.
-      ((MODE_ERROR_ON, 4, "Error")))
 
+  // MODE_ON = 0, //!< 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 MODE_OFF = 1, //!< The device is powered off. The only command accepted in this
+  // mode is a mode change to on.
+  //! The device is powered on and the device handler periodically sends
+  //! commands. The commands to be sent are selected by the handler
+  //! according to the submode.
+  static const Mode_t MODE_NORMAL = 2;
+  //! The device is powered on and ready to perform operations. In this mode,
+  //! raw commands can be sent. The device handler will send all replies
+  //! received from the command back to the commanding object.
+  static const Mode_t MODE_RAW = 3;
+  //! The device is shut down but the switch could not be turned off, so the
+  //! device still is powered. In this mode, only a mode change to @c MODE_OFF
+  //! can be commanded, which tries to switch off the device again.
+  static const Mode_t MODE_ERROR_ON = 4;
   //! This is a transitional state which can not be commanded. The device
   //! handler performs all commands to get the device in a state ready to
   //! perform commands. When this is completed, the mode changes to @c MODE_ON.
@@ -117,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/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,124 +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) {
-      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/introspection/CMakeLists.txt

@@ -1 +0,0 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE ParameterTypeSelector.cpp) 

src/fsfw/introspection/ClasslessEnum.h

@@ -1,48 +0,0 @@
-#pragma once
-
-#include <fsfw/returnvalues/returnvalue.h>
-
-#include <boost/preprocessor.hpp>
-
-// TODO ifdef EnumIF, consistent naming of functions arrays and macros (probably enum values and
-// descriptions)
-
-#include "EnumIF.h"
-#include "EnumCommon.h"
-
-#ifdef FSFW_INTROSPECTION
-
-#define FSFW_CLASSLESS_ENUM(name, type, elements)                                            \
-  enum : type { BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_FOR_EACH(CLEAN_ENUM_ITEM, "", elements)) };   \
-                                                                                             \
-  class name : public EnumIF {                                                               \
-   public:                                                                                   \
-    enum : type { BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_FOR_EACH(CLEAN_ENUM_ITEM, "", elements)) }; \
-    name(type value) : value(value) {}                                                       \
-    name() : value(-1) {}                                                                    \
-    name(const name &other) : value(other.value) {}                                          \
-    int64_t getValue() const override { return value; }                                      \
-    operator type() { return value; }                                                        \
-    name &operator=(name other) {                                                            \
-      value = other.value;                                                                   \
-      return *this;                                                                          \
-    }                                                                                        \
-    name &operator=(type value) {                                                            \
-      this->value = value;                                                                   \
-      return *this;                                                                          \
-    }                                                                                        \
-    CREATE_KEY_ARRAY(elements, type)                                                         \
-    VALUE_CHECK(type)                                                                        \
-    GET_INDEX()                                                                              \
-    CREATE_DESCRIPTION_ARRAY(elements)                                                       \
-    GET_DESCRIPTION_FUNC()                                                                   \
-   private:                                                                                  \
-    type value;                                                                              \
-  };
-
-#else
-
-#define FSFW_CLASSLESS_ENUM(name, type, elements) \
-  enum name : type { BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_FOR_EACH(CLEAN_ENUM_ITEM, "", elements)) };
-
-#endif

src/fsfw/introspection/Enum.h

@@ -1,64 +0,0 @@
-#pragma once
-
-#include <fsfw/returnvalues/returnvalue.h>
-#include <fsfw/serialize/SerializeAdapter.h>
-
-#include <boost/preprocessor.hpp>
-
-// TODO ifdef EnumIF, consistent naming of functions arrays and macros (probably enum values and
-// descriptions)
-
-#include "EnumIF.h"
-#include "EnumCommon.h"
-
-
-#ifdef FSFW_INTROSPECTION
-
-#define FSFW_ENUM(name, type, elements)                                                      \
-  class name : public EnumIF, public SerializeIF {                                           \
-   public:                                                                                   \
-    enum : type { BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_FOR_EACH(CLEAN_ENUM_ITEM, "", elements)) }; \
-    name(type value) : value(value) {}                                                       \
-    name() : value(-1) {}                                                                    \
-    name(const name &other) : value(other.value) {}                                          \
-    int64_t getValue() const override { return value; }                                      \
-    operator type() { return value; }                                                        \
-    name &operator=(name other) {                                                            \
-      value = other.value;                                                                   \
-      return *this;                                                                          \
-    }                                                                                        \
-    name &operator=(type value) {                                                            \
-      this->value = value;                                                                   \
-      return *this;                                                                          \
-    }                                                                                        \
-    CREATE_KEY_ARRAY(elements, type)                                                         \
-    VALUE_CHECK(type)                                                                        \
-    GET_INDEX()                                                                              \
-    CREATE_DESCRIPTION_ARRAY(elements)                                                       \
-    GET_DESCRIPTION_FUNC()                                                                   \
-    virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,          \
-                                    Endianness streamEndianness) const override {            \
-      return SerializeAdapter::serialize<>(&value, buffer, size, maxSize, streamEndianness); \
-    }                                                                                        \
-    virtual size_t getSerializedSize() const override {                                      \
-      return SerializeAdapter::getSerializedSize<>(&value);                                  \
-    }                                                                                        \
-    virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,                  \
-                                      Endianness streamEndianness) override {                \
-      return SerializeAdapter::deSerialize<>(&value, buffer, size, streamEndianness);        \
-    }                                                                                        \
-                                                                                             \
-   private:                                                                                  \
-    type value;                                                                              \
-  };
-
-
-#else
-
-#define FSFW_ENUM(name, type, elements)                                     \
-  enum class name : type {                                                  \
-    BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_FOR_EACH(CLEAN_ENUM_ITEM, "", elements)) \
-  };
-
-
-#endif

src/fsfw/introspection/EnumCommon.h

@@ -1,62 +0,0 @@
-#define CLEAN_ENUM_ITEM(r, data, element)                                          \
-  BOOST_PP_IF(BOOST_PP_SUB(BOOST_PP_TUPLE_SIZE(element), 2),                       \
-              (BOOST_PP_TUPLE_ELEM(0, element) = BOOST_PP_TUPLE_ELEM(1, element)), \
-              (BOOST_PP_TUPLE_ELEM(0, element)))
-
-#if defined FSFW_ENUM_VALUE_CHECKS || defined FSFW_INTROSPECTION
-
-
-#define GET_KEY(r, data, element) (BOOST_PP_TUPLE_ELEM(0, element))
-#define GET_DESCRIPTION(r, data, element)                                                       \
-  BOOST_PP_IF(BOOST_PP_SUB(BOOST_PP_TUPLE_SIZE(element), 2), (BOOST_PP_TUPLE_ELEM(2, element)), \
-              (BOOST_PP_TUPLE_ELEM(1, element)))
-
-#define CREATE_KEY_ARRAY(enum_elements, type)                                                \
-  /*was static constexpr, but clang won't compile that*/                                     \
-  int64_t elements[BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_FOR_EACH(GET_KEY, "", enum_elements))] = { \
-      BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_FOR_EACH(GET_KEY, "", enum_elements))};                 \
-  const int64_t *getElements() const override { return elements; }                           \
-  size_t getSize() const override {                                                          \
-    return BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_FOR_EACH(GET_KEY, "", enum_elements));             \
-  }
-#define VALUE_CHECK(type)                                                 \
-  bool isValid() const override {                                         \
-    for (size_t i = 0; i < sizeof(elements) / sizeof(elements[0]); i++) { \
-      if (value == elements[i]) {                                         \
-        return true;                                                      \
-      }                                                                   \
-    }                                                                     \
-    return false;                                                         \
-  }
-
-#ifdef FSFW_INTROSPECTION
-#define CREATE_DESCRIPTION_ARRAY(elements)                                                       \
-  /*was static constexpr, but clang won't compile that*/                                         \
-  const char                                                                                     \
-      *descriptions[BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_FOR_EACH(GET_DESCRIPTION, "", elements))] = { \
-          BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_FOR_EACH(GET_DESCRIPTION, "", elements))};              \
-  const char *const *getDescriptions() const override { return descriptions; }
-#define GET_INDEX()                                                       \
-  size_t getIndex(int64_t value) const override {                         \
-    for (size_t i = 0; i < sizeof(elements) / sizeof(elements[0]); i++) { \
-      if (value == elements[i]) {                                         \
-        return i;                                                         \
-      }                                                                   \
-    }                                                                     \
-    return -1;                                                            \
-  }
-#define GET_DESCRIPTION_FUNC()                        \
-  const char *getDescription() const override {       \
-    if (getIndex(value) == static_cast<size_t>(-1)) { \
-      return nullptr;                                      \
-    } else {                                          \
-      return descriptions[getIndex(value)];           \
-    }                                                 \
-  }
-#else
-#define GET_INDEX()
-#define CREATE_DESCRIPTION_ARRAY(elements)
-#define GET_DESCRIPTION_FUNC()
-#endif
-
-#endif

src/fsfw/introspection/EnumIF.h

@@ -1,16 +0,0 @@
-#pragma once
-
-#include <cstddef>
-#include <cstdint>
-
-class EnumIF {
- public:
-  virtual ~EnumIF() {}
-  virtual int64_t getValue() const = 0;
-  virtual bool isValid() const = 0;
-  virtual size_t getSize() const = 0;
-  virtual size_t getIndex(int64_t value) const = 0;
-  virtual const int64_t *getElements() const = 0;
-  virtual const char *const *getDescriptions() const = 0;
-  virtual const char *getDescription() const = 0;
-};

src/fsfw/introspection/ParameterTypeSelector.cpp

@@ -1,56 +0,0 @@
-#include "ParameterTypeSelector.h"
-
-#include <stdint.h>
-
-#include "Types.h"
-
-#ifdef FSFW_INTROSPECTION
-
-template <typename T>
-Types::ParameterType ParameterTypeSelector::getType() {
-    return Types::UNSUPPORTED;
-  }
-
-template <>
-Types::ParameterType ParameterTypeSelector::getType<uint8_t>() {
-  return Types::SIGNED;
-}
-template <>
-Types::ParameterType ParameterTypeSelector::getType<int8_t>() {
-  return Types::SIGNED;
-}
-
-template <>
-Types::ParameterType ParameterTypeSelector::getType<uint16_t>() {
-  return Types::SIGNED;
-}
-template <>
-Types::ParameterType ParameterTypeSelector::getType<int16_t>() {
-  return Types::SIGNED;
-}
-template <>
-Types::ParameterType ParameterTypeSelector::getType<uint32_t>() {
-  return Types::SIGNED;
-}
-template <>
-Types::ParameterType ParameterTypeSelector::getType<int32_t>() {
-  return Types::SIGNED;
-}
-// template <>
-// Types::ParameterType ParameterTypeSelector::getType<uint64_t>() {
-//   return Types::UNSIGNED;
-// }
-template <>
-Types::ParameterType ParameterTypeSelector::getType<int64_t>() {
-  return Types::SIGNED;
-}
-template <>
-Types::ParameterType ParameterTypeSelector::getType<float>() {
-  return Types::FLOATING;
-}
-template <>
-Types::ParameterType ParameterTypeSelector::getType<double>() {
-  return Types::FLOATING;
-}
-
-#endif

src/fsfw/introspection/ParameterTypeSelector.h

@@ -1,13 +0,0 @@
-#pragma once
-
-#include "Types.h"
-
-#ifdef FSFW_INTROSPECTION
-
-class ParameterTypeSelector {
- public:
-  template <typename T>
-  static Types::ParameterType getType();
-};
-
-#endif

src/fsfw/introspection/Types.h

@@ -1,8 +0,0 @@
-#pragma once
-
-//maybe call them MIB types as these are the ones exposed to the MIB?
-// Note: some DBs (Postgress, Mongo) only support signed 64bit integers. To have a common denominator, all integers are int64_t.
-// As such, ther is no unsigned Type, as there can not be a uint64_t and uint32_t completely fits into int64_t
-namespace Types {
-enum ParameterType { SIGNED, FLOATING, ENUM, STRING, BYTEARRAY, UNSUPPORTED };
-}  // namespace Types

src/fsfw/introspection/TypesHelper.h

@@ -1,74 +0,0 @@
-#pragma once
-
-#include <limits>
-#include <vector>
-
-#include "Enum.h"
-#include "Types.h"
-#include "ParameterTypeSelector.h"
-
-template <bool>
-class enumHelper;
-
-template <>
-class enumHelper<true> {
- public:
-  static bool isValid(EnumIF *anEnum) { return anEnum->isValid(); }
-
-#ifdef FSFW_INTROSPECTION
-  template <typename T>
-  static Types::ParameterType getType() {
-    return Types::ENUM;
-  }
-
-  template <typename T>
-  static T getMin() {
-    return 0;
-  }
-
-  template <typename T>
-  static T getMax() {
-    return 0;
-  }
-
-  static std::vector<int64_t> getEnumValues() { return std::vector<int64_t>(); }
-
-  static std::vector<int64_t> getEnumValues(EnumIF *anEnum) {
-    std::vector<int64_t> vector;
-    for (size_t i = 0; i < anEnum->getSize(); i++) {
-      vector.push_back(anEnum->getElements()[i]);
-    }
-    return vector;
-  }
-
-  static const char *const *getEnumDescriptions(EnumIF *anEnum) {
-    return anEnum->getDescriptions();
-  }
-#endif
-};
-
-template <>
-class enumHelper<false> {
- public:
-  static bool isValid(void *) { return true; }
-
-#ifdef FSFW_INTROSPECTION
-  template <typename T>
-  static Types::ParameterType getType() {
-    return ParameterTypeSelector::getType<T>();
-  }
-
-  template <typename T>
-  static T getMin() {
-    return std::numeric_limits<T>::lowest();
-  }
-  template <typename T>
-  static T getMax() {
-    return std::numeric_limits<T>::max();
-  }
-
-  static std::vector<int64_t> getEnumValues(void *) { return std::vector<int64_t>(); }
-
-  static const char *const *getEnumDescriptions(void *) { return nullptr; }
-#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

@@ -4,9 +4,7 @@
 #include <cstdint>
 
 #include "../events/Event.h"
-#include "../introspection/ClasslessEnum.h"
 #include "../returnvalues/returnvalue.h"
-#include "ModeDefinitionHelper.h"
 #include "ModeHelper.h"
 #include "ModeMessage.h"
 
@@ -21,39 +19,35 @@ 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 can 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;
-
-  FSFW_CLASSLESS_ENUM(DefaultSubmode, Submode_t,
-                      ((SUBMODE_NONE, 0,
-                        "Default")))  //!< To avoid checks against magic number "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;
-  virtual const ModeHelper * getModeHelper() const = 0;
-  virtual ModeDefinitionHelper getModeDefinitionHelper() = 0;
   virtual void getMode(Mode_t *mode, Submode_t *submode) = 0;
 
  protected:

src/fsfw/modes/ModeDefinitionHelper.h

@@ -1,33 +0,0 @@
-#pragma once
-
-#include <fsfw/introspection/EnumIF.h>
-
-class ModeDefinitionHelper {
- public:
-#ifdef FSFW_INTROSPECTION
-  ModeDefinitionHelper(EnumIF *mode, EnumIF *submode) : mode(mode), submode(submode) {}
-#else
-  ModeDefinitionHelper(void *mode, void *submode) {};
-#endif
-  template <typename Mode, typename Submode>
-  static ModeDefinitionHelper create() {
-#ifdef FSFW_INTROSPECTION
-    EnumIF *mode = new Mode();
-    EnumIF *submode = new Submode();
-    return ModeDefinitionHelper(mode, submode);
-#else
-    return ModeDefinitionHelper(nullptr, nullptr);
-#endif
-  }
-
-  void free() {
-#ifdef FSFW_INTROSPECTION
-    delete mode;
-    delete submode;
-#endif
-  }
-#ifdef FSFW_INTROSPECTION
-  EnumIF *mode;
-  EnumIF *submode;
-#endif
-};

src/fsfw/modes/ModeHelper.cpp

@@ -4,7 +4,7 @@
 #include "fsfw/modes/HasModesIF.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
-ModeHelper::ModeHelper(HasModesIF *owner)
+ModeHelper::ModeHelper(HasModesIF* owner)
     : commandedMode(HasModesIF::MODE_OFF),
       commandedSubmode(HasModesIF::SUBMODE_NONE),
       owner(owner),
@@ -12,7 +12,7 @@ ModeHelper::ModeHelper(HasModesIF *owner)
 
 ModeHelper::~ModeHelper() {}
 
-ReturnValue_t ModeHelper::handleModeCommand(CommandMessage *command) {
+ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
   CommandMessage reply;
   Mode_t mode;
   Submode_t submode;
@@ -106,33 +106,3 @@ bool ModeHelper::isTimedOut() { return countdown.hasTimedOut(); }
 bool ModeHelper::isForced() { return forced; }
 
 void ModeHelper::setForced(bool forced) { this->forced = forced; }
-
-#ifdef FSFW_INTROSPECTION
-std::vector<std::pair<Mode_t, const char *>> ModeHelper::getModes() const {
-  std::vector<std::pair<Mode_t, const char *>> modeVector;
-  auto modeDefinitionHelper = owner->getModeDefinitionHelper();
-  EnumIF *mode = modeDefinitionHelper.mode;
-  for (size_t i = 0; i < mode->getSize(); i++) {
-    modeVector.push_back(
-        std::pair<Mode_t, const char *>(mode->getElements()[i], mode->getDescriptions()[i]));
-  }
-  modeDefinitionHelper.free();
-  return modeVector;
-}
-
-std::vector<std::pair<Submode_t, const char *>> ModeHelper::getSubmodes(Mode_t mode) const {
-  auto modeDefinitionHelper = owner->getModeDefinitionHelper();
-  EnumIF *submode = modeDefinitionHelper.submode;
-  std::vector<std::pair<Submode_t, const char *>> submodeVector;
-  for (size_t i = 0; i < submode->getSize(); i++) {
-    uint32_t ignored;
-    if (owner->checkModeCommand(mode, submode->getElements()[i], &ignored) ==
-        HasReturnvaluesIF::RETURN_OK) {
-      submodeVector.push_back(std::pair<Submode_t, const char *>(submode->getElements()[i],
-                                                                 submode->getDescriptions()[i]));
-    }
-  }
-  modeDefinitionHelper.free();
-  return submodeVector;
-}
-#endif

src/fsfw/modes/ModeHelper.h

@@ -1,8 +1,6 @@
 #ifndef FSFW_MODES_MODEHELPER_H_
 #define FSFW_MODES_MODEHELPER_H_
 
-#include <vector>
-
 #include "ModeMessage.h"
 #include "fsfw/ipc/MessageQueueIF.h"
 #include "fsfw/returnvalues/returnvalue.h"
@@ -41,12 +39,6 @@ class ModeHelper {
 
   void setForced(bool forced);
 
-#ifdef FSFW_INTROSPECTION
-  std::vector<std::pair<Mode_t, const char *>> getModes() const;
-
-  std::vector<std::pair<Submode_t, const char *>> getSubmodes(Mode_t mode) const;
-#endif
-
  protected:
   HasModesIF *owner;
   MessageQueueId_t parentQueueId = MessageQueueIF::NO_QUEUE;

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() {
@@ -78,37 +73,19 @@ SystemObjectIF* ObjectManager::getSystemObject(object_id_t id) {
   }
 }
 
-void ObjectManager::produce() {
-  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);
-}
-
 void ObjectManager::initialize() {
-  produce();
   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++;
     }
@@ -147,7 +124,3 @@ void ObjectManager::printList() {
   }
 #endif
 }
-
-const std::map<object_id_t, SystemObjectIF*> * ObjectManager::getObjectList(){
-  return &objectList;
-}

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);
 
@@ -42,9 +39,7 @@ class ObjectManager : public ObjectManagerIF {
   ReturnValue_t insert(object_id_t id, SystemObjectIF* object) override;
   ReturnValue_t remove(object_id_t id) override;
   void initialize() override;
-  void produce() override;
   void printList() override;
-  const std::map<object_id_t, SystemObjectIF*> * getObjectList() override;
 
  protected:
   SystemObjectIF* getSystemObject(object_id_t id) override;
@@ -56,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/objectmanager/ObjectManagerIF.h

@@ -1,8 +1,6 @@
 #ifndef FSFW_OBJECTMANAGER_OBJECTMANAGERIF_H_
 #define FSFW_OBJECTMANAGER_OBJECTMANAGERIF_H_
 
-#include <map>
-
 #include "../returnvalues/returnvalue.h"
 #include "../serviceinterface/ServiceInterface.h"
 #include "SystemObjectIF.h"
@@ -60,14 +58,12 @@ class ObjectManagerIF {
    * 			@li returnvalue::OK in case the object was successfully removed
    */
   virtual ReturnValue_t remove(object_id_t id) = 0;
-  virtual void produce() = 0;
   virtual void initialize() = 0;
   /**
    * @brief	This is a debug function, that prints the current content of the
    * 			object list.
    */
   virtual void printList() = 0;
-  virtual const std::map<object_id_t, SystemObjectIF*>* getObjectList() = 0;
 };
 
 #endif /* OBJECTMANAGERIF_H_ */

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

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/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;
@@ -327,7 +324,3 @@ ReturnValue_t SubsystemBase::setHealth(HealthState health) {
 HasHealthIF::HealthState SubsystemBase::getHealth() { return healthHelper.getHealth(); }
 
 void SubsystemBase::modeChanged() {}
-
-const ModeHelper * SubsystemBase::getModeHelper() const {
-  return &modeHelper;
-}

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,
@@ -40,9 +33,7 @@ class SubsystemBase : public SystemObject,
                 uint16_t commandQueueDepth = 8);
   virtual ~SubsystemBase();
 
-  MessageQueueId_t getCommandQueue() const override;
-
-  const ModeHelper * getModeHelper() const override;
+  virtual MessageQueueId_t getCommandQueue() const override;
 
   /**
    * Function to register the child objects.
@@ -57,13 +48,13 @@ class SubsystemBase : public SystemObject,
    */
   ReturnValue_t registerChild(object_id_t objectId);
 
-  ReturnValue_t initialize() override;
+  virtual ReturnValue_t initialize() override;
 
-  ReturnValue_t performOperation(uint8_t opCode) override;
+  virtual ReturnValue_t performOperation(uint8_t opCode) override;
 
-  ReturnValue_t setHealth(HealthState health) override;
+  virtual ReturnValue_t setHealth(HealthState health) override;
 
-  HasHealthIF::HealthState getHealth() override;
+  virtual HasHealthIF::HealthState getHealth() override;
 
  protected:
   struct ChildInfo {
@@ -104,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/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/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/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_) {
@@ -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/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/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/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/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/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/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;

src/fsfw_hal/linux/UnixFileGuard.cpp

@@ -6,7 +6,7 @@
 #include "fsfw/FSFW.h"
 #include "fsfw/serviceinterface.h"
 
-UnixFileGuard::UnixFileGuard(const std::string& device, int* fileDescriptor, int flags,
+UnixFileGuard::UnixFileGuard(std::string device, int* fileDescriptor, int flags,
                              std::string diagnosticPrefix)
     : fileDescriptor(fileDescriptor) {
   if (fileDescriptor == nullptr) {

src/fsfw_hal/linux/UnixFileGuard.h

@@ -15,7 +15,7 @@ class UnixFileGuard {
 
   static constexpr ReturnValue_t OPEN_FILE_FAILED = 1;
 
-  UnixFileGuard(const std::string& device, int* fileDescriptor, int flags,
+  UnixFileGuard(std::string device, int* fileDescriptor, int flags,
                 std::string diagnosticPrefix = "");
 
   virtual ~UnixFileGuard();

src/fsfw_hal/linux/gpio/Gpio.h

@@ -1,27 +0,0 @@
-#ifndef FSFW_HAL_SRC_FSFW_HAL_LINUX_GPIO_GPIO_H_
-#define FSFW_HAL_SRC_FSFW_HAL_LINUX_GPIO_GPIO_H_
-
-#include "fsfw_hal/common/gpio/GpioIF.h"
-#include "fsfw_hal/common/gpio/gpioDefinitions.h"
-
-/**
- * @brief   Additional abstraction layer for handling GPIOs.
- *
- * @author  J. Meier
- */
-class Gpio {
- public:
-  Gpio(gpioId_t gpioId, GpioIF* gpioIF) : gpioId(gpioId), gpioIF(gpioIF) {
-    if (gpioIF == nullptr) {
-      sif::error << "Gpio::Gpio: Invalid GpioIF" << std::endl;
-    }
-  }
-  ReturnValue_t pullHigh() { return gpioIF->pullHigh(gpioId); }
-  ReturnValue_t pullLow() { return gpioIF->pullLow(gpioId); }
-
- private:
-  gpioId_t gpioId = gpio::NO_GPIO;
-  GpioIF* gpioIF = nullptr;
-};
-
-#endif /* FSFW_HAL_SRC_FSFW_HAL_LINUX_GPIO_GPIO_H_ */

src/fsfw_hal/linux/gpio/LinuxLibgpioIF.cpp

@@ -294,7 +294,7 @@ ReturnValue_t LinuxLibgpioIF::driveGpio(gpioId_t gpioId, GpiodRegularBase& regul
   return returnvalue::OK;
 }
 
-ReturnValue_t LinuxLibgpioIF::readGpio(gpioId_t gpioId, gpio::Levels& gpioState) {
+ReturnValue_t LinuxLibgpioIF::readGpio(gpioId_t gpioId, int* gpioState) {
   gpioMapIter = gpioMap.find(gpioId);
   if (gpioMapIter == gpioMap.end()) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -313,10 +313,7 @@ ReturnValue_t LinuxLibgpioIF::readGpio(gpioId_t gpioId, gpio::Levels& gpioState)
     if (regularGpio == nullptr) {
       return GPIO_TYPE_FAILURE;
     }
-    gpioState = static_cast<gpio::Levels>(gpiod_line_get_value(regularGpio->lineHandle));
-    if (gpioState == gpio::Levels::FAILED) {
-      return GPIO_GET_VALUE_FAILED;
-    }
+    *gpioState = gpiod_line_get_value(regularGpio->lineHandle);
   } else {
     auto gpioCallback = dynamic_cast<GpioCallback*>(gpioMapIter->second);
     if (gpioCallback->callback == nullptr) {