Merge branch 'development' into meier/upstream-pus-distributor-bugfix

Merge pull request 'Move HAL and Tests folder' (#653 ) from mueller/move-hal-tests-folder into development
Reviewed-on: fsfw/fsfw#653
2022-07-18 15:12:30 +02:00 · 2022-07-18 15:05:25 +02:00 · 2022-07-18 15:00:40 +02:00 · 2022-07-18 14:59:25 +02:00 · 2022-07-18 14:36:40 +02:00 · 2022-07-18 11:58:55 +02:00
319 changed files with 1148 additions and 1415 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -40,6 +40,9 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
  creation call. It allows passing context information and an arbitrary user argument into
  the message queue. Also streamlined and simplified `MessageQueue` implementation for all OSALs
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/583
+- Internal API change: Moved the `fsfw_hal` to the `src` folder and integration and internal
+  tests part of `fsfw_tests` to `src`. Unittests are now in a dedicated folder called `unittests`
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/653

 ### Task Module Refactoring

@ -85,7 +88,6 @@ PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/636
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/572
 - HAL Linux Uart: Baudrate and bits per word are enums now, avoiding misconfigurations
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/585
- Linux HAL: Add wiretapping option for I2C. Enabled with `FSFW_HAL_I2C_WIRETAPPING` defined to 1

 ### Time

@ -115,6 +117,8 @@ https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593

 ## Additions

+- New constructor for PoolEntry which allows to simply specify the length of the pool entry.
+  This is also the new default constructor for scalar value with 0 as an initial value
 - Added options for CI/CD builds: `FSFW_CICD_BUILD`. This allows the source code to know
  whether it is running in CI/CD
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/623
@ -134,6 +138,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
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -67,6 +67,7 @@ endif()
 set(FSFW_SOURCES_DIR "${CMAKE_SOURCE_DIR}/src/fsfw")

 set(FSFW_ETL_LIB_NAME etl)
+set(FSFW_ETL_LINK_TARGET etl::etl)
 set(FSFW_ETL_LIB_MAJOR_VERSION
    20
    CACHE STRING "ETL library major version requirement")
@ -103,11 +104,11 @@ if(FSFW_GENERATE_SECTIONS)
  option(FSFW_REMOVE_UNUSED_CODE "Remove unused code" ON)
 endif()

-option(FSFW_BUILD_UNITTESTS
+option(FSFW_BUILD_TESTS
       "Build unittest binary in addition to static library" OFF)
 option(FSFW_CICD_BUILD "Build for CI/CD. This can disable problematic test" OFF)
 option(FSFW_BUILD_DOCS "Build documentation with Sphinx and Doxygen" OFF)
-if(FSFW_BUILD_UNITTESTS)
+if(FSFW_BUILD_TESTS)
  option(FSFW_TESTS_GEN_COV "Generate coverage data for unittests" ON)
 endif()

@ -139,7 +140,7 @@ if(IPO_SUPPORTED AND FSFW_ENABLE_IPO)
                                                TRUE)
 endif()

-if(FSFW_BUILD_UNITTESTS)
+if(FSFW_BUILD_TESTS)
  message(
    STATUS
      "${MSG_PREFIX} Building the FSFW unittests in addition to the static library"
@ -162,10 +163,9 @@ if(FSFW_BUILD_UNITTESTS)
    list(APPEND FSFW_FETCH_CONTENT_TARGETS Catch2)
  endif()

-  set(FSFW_CONFIG_PATH tests/src/fsfw_tests/unit/testcfg)
-  configure_file(tests/src/fsfw_tests/unit/testcfg/FSFWConfig.h.in FSFWConfig.h)
-  configure_file(tests/src/fsfw_tests/unit/testcfg/TestsConfig.h.in
-                 tests/TestsConfig.h)
+  set(FSFW_CONFIG_PATH unittests/testcfg)
+  configure_file(unittests/testcfg/FSFWConfig.h.in FSFWConfig.h)
+  configure_file(unittests/testcfg/TestsConfig.h.in tests/TestsConfig.h)

  project(${FSFW_TEST_TGT} CXX C)
  add_executable(${FSFW_TEST_TGT})
@ -183,10 +183,7 @@ if(FSFW_BUILD_UNITTESTS)
  endif()
 endif()

-message(
-  STATUS
-    "${MSG_PREFIX} Finding and/or providing etl library with version ${FSFW_ETL_LIB_MAJOR_VERSION}"
-)
+message(STATUS "${MSG_PREFIX} Finding and/or providing ETL library")

 # Check whether the user has already installed ETL first
 find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} QUIET)
@ -194,7 +191,7 @@ find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} QUIET)
 if(NOT ${FSFW_ETL_LIB_NAME}_FOUND)
  message(
    STATUS
-      "${MSG_PREFIX} No ETL installation was found with find_package. Installing and providing "
+      "No ETL installation was found with find_package. Installing and providing "
      "etl with FindPackage")
  include(FetchContent)

@ -284,16 +281,15 @@ message(
 )

 add_subdirectory(src)
-add_subdirectory(tests)
-if(FSFW_ADD_HAL)
-  add_subdirectory(hal)
-endif()
 add_subdirectory(contrib)
+if(FSFW_BUILD_TESTS)
+  add_subdirectory(unittests)
+endif()
 if(FSFW_BUILD_DOCS)
  add_subdirectory(docs)
 endif()

-if(FSFW_BUILD_UNITTESTS)
+if(FSFW_BUILD_TESTS)
  if(FSFW_TESTS_GEN_COV)
    if(CMAKE_COMPILER_IS_GNUCXX)
      include(CodeCoverage)
@ -450,8 +446,8 @@ target_include_directories(
 target_compile_options(${LIB_FSFW_NAME} PRIVATE ${FSFW_WARNING_FLAGS}
                                                ${COMPILER_FLAGS})

-target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${FSFW_ETL_LINK_TARGET}
-                                               ${FSFW_ADDITIONAL_LINK_LIBS})
+target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${FSFW_ADDITIONAL_LINK_LIBS})
+target_link_libraries(${LIB_FSFW_NAME} PUBLIC ${FSFW_ETL_LINK_TARGET})

 string(
  CONCAT
--- a/README.md
+++ b/README.md
@ -139,7 +139,7 @@ You can also use `-DFSFW_OSAL=linux` on Linux systems.

 Coverage data in HTML format can be generated using the `CodeCoverage`
 [CMake module](https://github.com/bilke/cmake-modules/tree/master).
-To build the unittests, run them and then generare the coverage data in this format,
+To build the unittests, run them and then generate the coverage data in this format,
 the following command can be used inside the build directory after the build system was set up

 ```sh
@ -188,7 +188,10 @@ and open the documentation conveniently. Try `helper.py -h for more information.

 The formatting is done by the `clang-format` tool. The configuration is contained within the
 `.clang-format` file in the repository root. As long as `clang-format` is installed, you
-can run the `apply-clang-format.sh` helper script to format all source files consistently.
+can run the `auto-format.sh` helper script to format all source files consistently. Furthermore cmake-format is required to format CMake files which can be installed with:
+````sh
+sudo pip install cmakelang
+````

 ## Index

--- a/automation/Dockerfile
+++ b/automation/Dockerfile
@ -12,3 +12,9 @@ RUN git clone https://github.com/catchorg/Catch2.git && \
 	git checkout v3.0.0-preview5 && \
 	cmake -Bbuild -H. -DBUILD_TESTING=OFF && \
 	cmake --build build/ --target install
+
+RUN git clone https://github.com/ETLCPP/etl.git && \
+	cd etl && \
+	git checkout 20.28.0 && \
+	cmake -B build . && \
+	cmake --install build/
--- a/automation/Jenkinsfile
+++ b/automation/Jenkinsfile
@ -3,7 +3,7 @@ pipeline {
        BUILDDIR = 'build-tests'
    }
    agent {
-        docker { image 'fsfw-ci:d2'}
+        docker { image 'fsfw-ci:d3'}
    }
    stages {
        stage('Clean') {
@ -14,7 +14,7 @@ pipeline {
        stage('Configure') {
            steps {
                dir(BUILDDIR) {
-                    sh 'cmake -DFSFW_OSAL=host -DFSFW_BUILD_UNITTESTS=ON -DFSFW_CICD_BUILD=ON ..'
+                    sh 'cmake -DFSFW_OSAL=host -DFSFW_BUILD_TESTS=ON -DFSFW_CICD_BUILD=ON ..'
                }
            }
        }
--- a/hal/CMakeLists.txt
+++ b/hal/CMakeLists.txt
@ -1,48 +0,0 @@
-cmake_minimum_required(VERSION 3.13)
-
-# Can also be changed by upper CMakeLists.txt file
-find_library(LIB_FSFW_NAME fsfw REQUIRED)
-
-option(FSFW_HAL_ADD_LINUX "Add the Linux HAL to the sources. Requires gpiod library" OFF)
-# On by default for now because I did not have an issue including and compiling those files
-# and libraries on a Desktop Linux system and the primary target of the FSFW is still embedded
-# Linux. The only exception from this is the gpiod library which requires a dedicated installation,
-# but CMake is able to determine whether this library is installed with find_library.
-option(FSFW_HAL_LINUX_ADD_PERIPHERAL_DRIVERS "Add peripheral drivers for embedded Linux" ON)
-option(FSFW_HAL_LINUX_ADD_LIBGPIOD "Target implements libgpiod" ON)
-
-option(FSFW_HAL_ADD_RASPBERRY_PI "Add Raspberry Pi specific code to the sources" OFF)
-option(FSFW_HAL_ADD_STM32H7 "Add the STM32H7 HAL to the sources" OFF)
-option(FSFW_HAL_WARNING_SHADOW_LOCAL_GCC "Enable -Wshadow=local warning in GCC" ON)
-
-set(LINUX_HAL_PATH_NAME linux)
-set(STM32H7_PATH_NAME stm32h7)
-
-add_subdirectory(src)
-
-foreach(INCLUDE_PATH ${FSFW_HAL_ADDITIONAL_INC_PATHS})
-    if(IS_ABSOLUTE ${INCLUDE_PATH})
-        set(CURR_ABS_INC_PATH "${INCLUDE_PATH}")
-    else()
-        get_filename_component(CURR_ABS_INC_PATH
-            ${INCLUDE_PATH} REALPATH BASE_DIR ${CMAKE_SOURCE_DIR})
-    endif()
-
-    if(CMAKE_VERBOSE)
-        message(STATUS "FSFW include path: ${CURR_ABS_INC_PATH}")
-    endif()
-
-    list(APPEND FSFW_HAL_ADD_INC_PATHS_ABS ${CURR_ABS_INC_PATH})
-endforeach()
-
-target_include_directories(${LIB_FSFW_NAME} PRIVATE
-    ${FSFW_HAL_ADD_INC_PATHS_ABS}
-)
-
-target_compile_definitions(${LIB_FSFW_NAME} PRIVATE
-    ${FSFW_HAL_DEFINES}
-)
-
-target_link_libraries(${LIB_FSFW_NAME} PRIVATE
-    ${FSFW_HAL_LINK_LIBS}
-)
--- a/hal/src/CMakeLists.txt
+++ b/hal/src/CMakeLists.txt
@ -1,9 +0,0 @@
-target_include_directories(${LIB_FSFW_NAME} PRIVATE
-    ${CMAKE_CURRENT_SOURCE_DIR}
-)
-
-target_include_directories(${LIB_FSFW_NAME} INTERFACE
-    ${CMAKE_CURRENT_SOURCE_DIR}
-)
-
-add_subdirectory(fsfw_hal)
--- a/hal/src/fsfw_hal/linux/gpio/Gpio.h
+++ b/hal/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_ */
--- a/hal/src/fsfw_hal/linux/spi/ManualCsLockGuard.h
+++ b/hal/src/fsfw_hal/linux/spi/ManualCsLockGuard.h
@ -1,43 +0,0 @@
-#pragma once
-
-#include "fsfw/ipc/MutexIF.h"
-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
-#include "fsfw_hal/common/gpio/GpioIF.h"
-
-class ManualCsLockWrapper : public HasReturnvaluesIF {
- public:
-  ManualCsLockWrapper(MutexIF* lock, GpioIF* gpioIF, SpiCookie* cookie,
-                      MutexIF::TimeoutType type = MutexIF::TimeoutType::BLOCKING,
-                      uint32_t timeoutMs = 0)
-      : lock(lock), gpioIF(gpioIF), cookie(cookie), type(type), timeoutMs(timeoutMs) {
-    if (cookie == nullptr) {
-      // TODO: Error? Or maybe throw exception..
-      return;
-    }
-    cookie->setCsLockManual(true);
-    lockResult = lock->lockMutex(type, timeoutMs);
-    if (lockResult != RETURN_OK) {
-      return;
-    }
-    gpioResult = gpioIF->pullLow(cookie->getChipSelectPin());
-  }
-
-  ~ManualCsLockWrapper() {
-    if (gpioResult == RETURN_OK) {
-      gpioIF->pullHigh(cookie->getChipSelectPin());
-    }
-    cookie->setCsLockManual(false);
-    if (lockResult == RETURN_OK) {
-      lock->unlockMutex();
-    }
-  }
-  ReturnValue_t lockResult;
-  ReturnValue_t gpioResult;
-
- private:
-  MutexIF* lock;
-  GpioIF* gpioIF;
-  SpiCookie* cookie;
-  MutexIF::TimeoutType type;
-  uint32_t timeoutMs = 0;
-};
--- a/scripts/auto-formatter.sh
+++ b/scripts/auto-formatter.sh
@ -3,12 +3,6 @@ if [[ ! -f README.md ]]; then
  cd ..
 fi

-folder_list=(
-  "./src"
-  "./hal"
-  "./tests"
-)
-
 cmake_fmt="cmake-format"
 file_selectors="-iname CMakeLists.txt"
 if command -v ${cmake_fmt} &> /dev/null; then
@ -21,10 +15,9 @@ fi
 cpp_format="clang-format"
 file_selectors="-iname *.h -o -iname *.cpp -o -iname *.c -o -iname *.tpp"
 if command -v ${cpp_format} &> /dev/null; then
-  for dir in ${folder_list[@]}; do
-    echo "Auto-formatting ${dir} recursively"
-    find ${dir} ${file_selectors} | xargs clang-format --style=file -i
-  done
+  find ./src ${file_selectors} | xargs ${cpp_format} --style=file -i
+  find ./hal ${file_selectors} | xargs ${cpp_format} --style=file -i
+  find ./tests ${file_selectors} | xargs ${cpp_format} --style=file -i
 else
  echo "No ${cpp_format} tool found, not formatting C++/C files"
 fi
--- a/scripts/helper.py
+++ b/scripts/helper.py
@ -48,6 +48,20 @@ def main():
        action="store_true",
        help="Run valgrind on generated test binary",
    )
+    parser.add_argument(
+        "-g",
+        "--generators",
+        default = "Ninja",
+        action="store",
+        help="CMake generators",
+    )
+    parser.add_argument(
+        "-w",
+        "--windows",
+        default=False,
+        action="store_true",
+        help="Run on windows",
+    )

    args = parser.parse_args()
    if args.all:
@ -115,14 +129,14 @@ def handle_tests_type(args, build_dir_list: list):
    if args.create:
        if os.path.exists(UNITTEST_FOLDER_NAME):
            shutil.rmtree(UNITTEST_FOLDER_NAME)
-        create_tests_build_cfg()
+        create_tests_build_cfg(args)
        build_directory = UNITTEST_FOLDER_NAME
    elif len(build_dir_list) == 0:
        print(
            "No valid CMake tests build directory found. "
            "Trying to set up test build system"
        )
-        create_tests_build_cfg()
+        create_tests_build_cfg(args)
        build_directory = UNITTEST_FOLDER_NAME
    elif len(build_dir_list) == 1:
        build_directory = build_dir_list[0]
@ -147,10 +161,15 @@ def handle_tests_type(args, build_dir_list: list):
        os.chdir("..")


-def create_tests_build_cfg():
+def create_tests_build_cfg(args):
    os.mkdir(UNITTEST_FOLDER_NAME)
    os.chdir(UNITTEST_FOLDER_NAME)
-    cmd_runner("cmake -DFSFW_OSAL=host -DFSFW_BUILD_UNITTESTS=ON ..")
+    if args.windows:
+        cmake_cmd = 'cmake -G "' + args.generators + '" -DFSFW_OSAL=host -DFSFW_BUILD_TESTS=ON \
+        -DGCOVR_PATH="py -m gcovr" ..'
+    else:
+        cmake_cmd = 'cmake -G "' + args.generators + '" -DFSFW_OSAL=host -DFSFW_BUILD_TESTS=ON ..'
+    cmd_runner(cmake_cmd)
    os.chdir("..")


--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@ -4,3 +4,8 @@ target_include_directories(${LIB_FSFW_NAME}
                           INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})

 add_subdirectory(fsfw)
+if(FSFW_ADD_HAL)
+  add_subdirectory(fsfw_hal)
+endif()
+
+add_subdirectory(fsfw_tests)
--- a/src/fsfw/action/ActionHelper.cpp
+++ b/src/fsfw/action/ActionHelper.cpp
@ -6,7 +6,7 @@
 ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue)
    : owner(setOwner), queueToUse(useThisQueue) {}

-ActionHelper::~ActionHelper() {}
+ActionHelper::~ActionHelper() = default;

 ReturnValue_t ActionHelper::handleActionMessage(CommandMessage* command) {
  if (command->getCommand() == ActionMessage::EXECUTE_ACTION) {
@ -59,7 +59,7 @@ void ActionHelper::setQueueToUse(MessageQueueIF* queue) { queueToUse = queue; }

 void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
                                    store_address_t dataAddress) {
-  const uint8_t* dataPtr = NULL;
+  const uint8_t* dataPtr = nullptr;
  size_t size = 0;
  ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
  if (result != HasReturnvaluesIF::RETURN_OK) {
--- a/src/fsfw/action/ActionHelper.h
+++ b/src/fsfw/action/ActionHelper.h
@ -1,9 +1,9 @@
 #ifndef FSFW_ACTION_ACTIONHELPER_H_
 #define FSFW_ACTION_ACTIONHELPER_H_

-#include "../ipc/MessageQueueIF.h"
-#include "../serialize/SerializeIF.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
 *
--- a/src/fsfw/action/ActionMessage.cpp
+++ b/src/fsfw/action/ActionMessage.cpp
@ -2,9 +2,9 @@
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/storagemanager/StorageManagerIF.h"

-ActionMessage::ActionMessage() {}
+ActionMessage::ActionMessage() = default;

-ActionMessage::~ActionMessage() {}
+ActionMessage::~ActionMessage() = default;

 void ActionMessage::setCommand(CommandMessage* message, ActionId_t fid,
                               store_address_t parameters) {
@ -64,9 +64,8 @@ void ActionMessage::clear(CommandMessage* message) {
  switch (message->getCommand()) {
    case EXECUTE_ACTION:
    case DATA_REPLY: {
-      StorageManagerIF* ipcStore =
-          ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
-      if (ipcStore != NULL) {
+      auto* ipcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
+      if (ipcStore != nullptr) {
        ipcStore->deleteData(getStoreId(message));
      }
      break;
--- a/src/fsfw/action/CommandActionHelper.cpp
+++ b/src/fsfw/action/CommandActionHelper.cpp
@ -2,14 +2,14 @@
 #include "fsfw/objectmanager/ObjectManager.h"

 CommandActionHelper::CommandActionHelper(CommandsActionsIF *setOwner)
-    : owner(setOwner), queueToUse(NULL), ipcStore(NULL), commandCount(0), lastTarget(0) {}
+    : owner(setOwner), queueToUse(nullptr), ipcStore(nullptr), commandCount(0), lastTarget(0) {}

-CommandActionHelper::~CommandActionHelper() {}
+CommandActionHelper::~CommandActionHelper() = default;

 ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo, ActionId_t actionId,
                                                 SerializeIF *data) {
-  HasActionsIF *receiver = ObjectManager::instance()->get<HasActionsIF>(commandTo);
-  if (receiver == NULL) {
+  auto *receiver = ObjectManager::instance()->get<HasActionsIF>(commandTo);
+  if (receiver == nullptr) {
    return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
  }
  store_address_t storeId;
@ -29,11 +29,8 @@ ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo, ActionId

 ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo, ActionId_t actionId,
                                                 const uint8_t *data, uint32_t size) {
-  //    if (commandCount != 0) {
-  //        return CommandsFunctionsIF::ALREADY_COMMANDING;
-  //    }
-  HasActionsIF *receiver = ObjectManager::instance()->get<HasActionsIF>(commandTo);
-  if (receiver == NULL) {
+  auto *receiver = ObjectManager::instance()->get<HasActionsIF>(commandTo);
+  if (receiver == nullptr) {
    return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
  }
  store_address_t storeId;
@ -59,12 +56,12 @@ ReturnValue_t CommandActionHelper::sendCommand(MessageQueueId_t queueId, ActionI

 ReturnValue_t CommandActionHelper::initialize() {
  ipcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
-  if (ipcStore == NULL) {
+  if (ipcStore == nullptr) {
    return HasReturnvaluesIF::RETURN_FAILED;
  }

  queueToUse = owner->getCommandQueuePtr();
-  if (queueToUse == NULL) {
+  if (queueToUse == nullptr) {
    return HasReturnvaluesIF::RETURN_FAILED;
  }
  return HasReturnvaluesIF::RETURN_OK;
@ -104,7 +101,7 @@ ReturnValue_t CommandActionHelper::handleReply(CommandMessage *reply) {
 uint8_t CommandActionHelper::getCommandCount() const { return commandCount; }

 void CommandActionHelper::extractDataForOwner(ActionId_t actionId, store_address_t storeId) {
-  const uint8_t *data = NULL;
+  const uint8_t *data = nullptr;
  size_t size = 0;
  ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
  if (result != HasReturnvaluesIF::RETURN_OK) {
--- a/src/fsfw/action/CommandActionHelper.h
+++ b/src/fsfw/action/CommandActionHelper.h
@ -14,14 +14,14 @@ class CommandActionHelper {
  friend class CommandsActionsIF;

 public:
-  CommandActionHelper(CommandsActionsIF* owner);
+  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);
-  uint8_t getCommandCount() const;
+  [[nodiscard]] uint8_t getCommandCount() const;

 private:
  CommandsActionsIF* owner;
--- a/src/fsfw/action/CommandsActionsIF.h
+++ b/src/fsfw/action/CommandsActionsIF.h
@ -1,9 +1,9 @@
 #ifndef FSFW_ACTION_COMMANDSACTIONSIF_H_
 #define FSFW_ACTION_COMMANDSACTIONSIF_H_

-#include "../ipc/MessageQueueIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
 #include "CommandActionHelper.h"
+#include "fsfw/ipc/MessageQueueIF.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"

 /**
 * Interface to separate commanding actions of other objects.
@ -21,7 +21,7 @@ class CommandsActionsIF {
  static const uint8_t INTERFACE_ID = CLASS_ID::COMMANDS_ACTIONS_IF;
  static const ReturnValue_t OBJECT_HAS_NO_FUNCTIONS = MAKE_RETURN_CODE(1);
  static const ReturnValue_t ALREADY_COMMANDING = MAKE_RETURN_CODE(2);
-  virtual ~CommandsActionsIF() {}
+  virtual ~CommandsActionsIF() = default;
  virtual MessageQueueIF* getCommandQueuePtr() = 0;

 protected:
--- a/src/fsfw/action/HasActionsIF.h
+++ b/src/fsfw/action/HasActionsIF.h
@ -1,11 +1,11 @@
 #ifndef FSFW_ACTION_HASACTIONSIF_H_
 #define FSFW_ACTION_HASACTIONSIF_H_

-#include "../ipc/MessageQueueIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
 #include "ActionHelper.h"
 #include "ActionMessage.h"
 #include "SimpleActionHelper.h"
+#include "fsfw/ipc/MessageQueueIF.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"

 /**
 * @brief
@ -40,12 +40,12 @@ class HasActionsIF {
  static const ReturnValue_t INVALID_PARAMETERS = MAKE_RETURN_CODE(2);
  static const ReturnValue_t EXECUTION_FINISHED = MAKE_RETURN_CODE(3);
  static const ReturnValue_t INVALID_ACTION_ID = MAKE_RETURN_CODE(4);
-  virtual ~HasActionsIF() {}
+  virtual ~HasActionsIF() = default;
  /**
   * Function to get the MessageQueueId_t of the implementing object
   * @return MessageQueueId_t of the object
   */
-  virtual MessageQueueId_t getCommandQueue() const = 0;
+  [[nodiscard]] virtual MessageQueueId_t getCommandQueue() const = 0;
  /**
   * Execute or initialize the execution of a certain function.
   * The ActionHelpers will execute this function and behave differently
--- a/src/fsfw/action/SimpleActionHelper.cpp
+++ b/src/fsfw/action/SimpleActionHelper.cpp
@ -3,7 +3,7 @@
 SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue)
    : ActionHelper(setOwner, useThisQueue), isExecuting(false) {}

-SimpleActionHelper::~SimpleActionHelper() {}
+SimpleActionHelper::~SimpleActionHelper() = default;

 void SimpleActionHelper::step(ReturnValue_t result) {
  // STEP_OFFESET is subtracted to compensate for adding offset in base
@ -38,7 +38,7 @@ void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId
    ActionMessage::setStepReply(&reply, actionId, 0, HasActionsIF::IS_BUSY);
    queueToUse->sendMessage(commandedBy, &reply);
  }
-  const uint8_t* dataPtr = NULL;
+  const uint8_t* dataPtr = nullptr;
  size_t size = 0;
  ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
  if (result != HasReturnvaluesIF::RETURN_OK) {
--- a/src/fsfw/action/SimpleActionHelper.h
+++ b/src/fsfw/action/SimpleActionHelper.h
@ -11,15 +11,15 @@
 class SimpleActionHelper : public ActionHelper {
 public:
  SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
-  virtual ~SimpleActionHelper();
+  ~SimpleActionHelper() override;
  void step(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
  void finish(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
  ReturnValue_t reportData(SerializeIF* data);

 protected:
  void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
-                        store_address_t dataAddress);
-  virtual void resetHelper();
+                        store_address_t dataAddress) override;
+  void resetHelper() override;

 private:
  bool isExecuting;
@ -28,4 +28,4 @@ class SimpleActionHelper : public ActionHelper {
  uint8_t stepCount = 0;
 };

-#endif /* SIMPLEACTIONHELPER_H_ */
+#endif /* FSFW_ACTION_SIMPLEACTIONHELPER_H_ */
--- a/src/fsfw/cfdp/CFDPHandler.cpp
+++ b/src/fsfw/cfdp/CFDPHandler.cpp
@ -12,9 +12,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;
 }

--- a/src/fsfw/controller/ControllerBase.cpp
+++ b/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); }
@ -28,7 +26,7 @@ ReturnValue_t ControllerBase::initialize() {

  MessageQueueId_t parentQueue = 0;
  if (parentId != objects::NO_OBJECT) {
-    SubsystemBase* parent = ObjectManager::instance()->get<SubsystemBase>(parentId);
+    auto* parent = ObjectManager::instance()->get<SubsystemBase>(parentId);
    if (parent == nullptr) {
      return RETURN_FAILED;
    }
@ -54,7 +52,7 @@ MessageQueueId_t ControllerBase::getCommandQueue() const { return commandQueue->

 void ControllerBase::handleQueue() {
  CommandMessage command;
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result;
  for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
       result = commandQueue->receiveMessage(&command)) {
    result = modeHelper.handleModeCommand(&command);
@ -75,20 +73,20 @@ void ControllerBase::handleQueue() {
  }
 }

-void ControllerBase::startTransition(Mode_t mode, Submode_t submode) {
+void ControllerBase::startTransition(Mode_t mode_, Submode_t submode_) {
  changeHK(this->mode, this->submode, false);
  triggerEvent(CHANGING_MODE, mode, submode);
-  this->mode = mode;
-  this->submode = submode;
+  mode = mode_;
+  submode = submode_;
  modeHelper.modeChanged(mode, submode);
  modeChanged(mode, submode);
  announceMode(false);
  changeHK(this->mode, this->submode, true);
 }

-void ControllerBase::getMode(Mode_t* mode, Submode_t* submode) {
-  *mode = this->mode;
-  *submode = this->submode;
+void ControllerBase::getMode(Mode_t* mode_, Submode_t* submode_) {
+  *mode_ = this->mode;
+  *submode_ = this->submode;
 }

 void ControllerBase::setToExternalControl() { healthHelper.setHealth(EXTERNAL_CONTROL); }
@ -101,7 +99,7 @@ ReturnValue_t ControllerBase::performOperation(uint8_t opCode) {
  return RETURN_OK;
 }

-void ControllerBase::modeChanged(Mode_t mode, Submode_t submode) { return; }
+void ControllerBase::modeChanged(Mode_t mode_, Submode_t submode_) {}

 ReturnValue_t ControllerBase::setHealth(HealthState health) {
  switch (health) {
@ -117,6 +115,6 @@ ReturnValue_t ControllerBase::setHealth(HealthState health) {
 HasHealthIF::HealthState ControllerBase::getHealth() { return healthHelper.getHealth(); }
 void ControllerBase::setTaskIF(PeriodicTaskIF* task_) { executingTask = task_; }

-void ControllerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {}
+void ControllerBase::changeHK(Mode_t mode_, Submode_t submode_, bool enable) {}

 ReturnValue_t ControllerBase::initializeAfterTaskCreation() { return HasReturnvaluesIF::RETURN_OK; }
--- a/src/fsfw/controller/ControllerBase.h
+++ b/src/fsfw/controller/ControllerBase.h
@ -24,21 +24,21 @@ class ControllerBase : public HasModesIF,
  static const Mode_t MODE_NORMAL = 2;

  ControllerBase(object_id_t setObjectId, object_id_t parentId, size_t commandQueueDepth = 3);
-  virtual ~ControllerBase();
+  ~ControllerBase() override;

  /** SystemObject override */
-  virtual ReturnValue_t initialize() override;
+  ReturnValue_t initialize() override;

-  virtual MessageQueueId_t getCommandQueue() const override;
+  [[nodiscard]] MessageQueueId_t getCommandQueue() const override;

  /** HasHealthIF overrides */
-  virtual ReturnValue_t setHealth(HealthState health) override;
-  virtual HasHealthIF::HealthState getHealth() override;
+  ReturnValue_t setHealth(HealthState health) override;
+  HasHealthIF::HealthState getHealth() override;

  /** ExecutableObjectIF overrides */
-  virtual ReturnValue_t performOperation(uint8_t opCode) override;
-  virtual void setTaskIF(PeriodicTaskIF *task) override;
-  virtual ReturnValue_t initializeAfterTaskCreation() override;
+  ReturnValue_t performOperation(uint8_t opCode) override;
+  void setTaskIF(PeriodicTaskIF *task) override;
+  ReturnValue_t initializeAfterTaskCreation() override;

 protected:
  /**
@ -54,8 +54,8 @@ class ControllerBase : public HasModesIF,
   */
  virtual void performControlOperation() = 0;

-  virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-                                         uint32_t *msToReachTheMode) override = 0;
+  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+                                 uint32_t *msToReachTheMode) override = 0;

  const object_id_t parentId;

@ -80,10 +80,10 @@ class ControllerBase : public HasModesIF,

  /** Mode helpers */
  virtual void modeChanged(Mode_t mode, Submode_t submode);
-  virtual void startTransition(Mode_t mode, Submode_t submode) override;
-  virtual void getMode(Mode_t *mode, Submode_t *submode) override;
-  virtual void setToExternalControl() override;
-  virtual void announceMode(bool recursive);
+  void startTransition(Mode_t mode, Submode_t submode) override;
+  void getMode(Mode_t *mode, Submode_t *submode) override;
+  void setToExternalControl() override;
+  void announceMode(bool recursive) override;
  /** HK helpers */
  virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
 };
--- a/src/fsfw/controller/ExtendedControllerBase.cpp
+++ b/src/fsfw/controller/ExtendedControllerBase.cpp
@ -6,7 +6,7 @@ ExtendedControllerBase::ExtendedControllerBase(object_id_t objectId, object_id_t
      poolManager(this, commandQueue),
      actionHelper(this, commandQueue) {}

-ExtendedControllerBase::~ExtendedControllerBase() {}
+ExtendedControllerBase::~ExtendedControllerBase() = default;

 ReturnValue_t ExtendedControllerBase::executeAction(ActionId_t actionId,
                                                    MessageQueueId_t commandedBy,
@ -31,7 +31,7 @@ ReturnValue_t ExtendedControllerBase::handleCommandMessage(CommandMessage *messa

 void ExtendedControllerBase::handleQueue() {
  CommandMessage command;
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result;
  for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
       result = commandQueue->receiveMessage(&command)) {
    result = actionHelper.handleActionMessage(&command);
--- a/src/fsfw/controller/ExtendedControllerBase.h
+++ b/src/fsfw/controller/ExtendedControllerBase.h
@ -18,16 +18,16 @@ class ExtendedControllerBase : public ControllerBase,
                               public HasLocalDataPoolIF {
 public:
  ExtendedControllerBase(object_id_t objectId, object_id_t parentId, size_t commandQueueDepth = 3);
-  virtual ~ExtendedControllerBase();
+  ~ExtendedControllerBase() override;

  /* SystemObjectIF overrides */
-  virtual ReturnValue_t initialize() override;
+  ReturnValue_t initialize() override;

-  virtual MessageQueueId_t getCommandQueue() const override;
+  [[nodiscard]] MessageQueueId_t getCommandQueue() const override;

  /* ExecutableObjectIF overrides */
-  virtual ReturnValue_t performOperation(uint8_t opCode) override;
-  virtual ReturnValue_t initializeAfterTaskCreation() override;
+  ReturnValue_t performOperation(uint8_t opCode) override;
+  ReturnValue_t initializeAfterTaskCreation() override;

 protected:
  LocalDataPoolManager poolManager;
@ -39,32 +39,32 @@ class ExtendedControllerBase : public ControllerBase,
   * @param message
   * @return
   */
-  virtual ReturnValue_t handleCommandMessage(CommandMessage* message) = 0;
+  ReturnValue_t handleCommandMessage(CommandMessage* message) override = 0;

  /**
   * Periodic helper from ControllerBase, implemented by child class.
   */
-  virtual void performControlOperation() = 0;
+  void performControlOperation() override = 0;

  /* Handle the four messages mentioned above */
  void handleQueue() override;

  /* HasActionsIF overrides */
-  virtual ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                                      const uint8_t* data, size_t size) override;
+  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+                              const uint8_t* data, size_t size) override;

  /* HasLocalDatapoolIF overrides */
-  virtual LocalDataPoolManager* getHkManagerHandle() override;
-  virtual object_id_t getObjectId() const override;
-  virtual uint32_t getPeriodicOperationFrequency() const override;
+  LocalDataPoolManager* getHkManagerHandle() override;
+  [[nodiscard]] object_id_t getObjectId() const override;
+  [[nodiscard]] uint32_t getPeriodicOperationFrequency() const override;

-  virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
-                                                LocalDataPoolManager& poolManager) override = 0;
-  virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override = 0;
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+                                        LocalDataPoolManager& poolManager) override = 0;
+  LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override = 0;

  // Mode abstract functions
-  virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-                                         uint32_t* msToReachTheMode) override = 0;
+  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+                                 uint32_t* msToReachTheMode) override = 0;
 };

 #endif /* FSFW_CONTROLLER_EXTENDEDCONTROLLERBASE_H_ */
--- a/src/fsfw/datapoollocal/LocalDataPoolManager.cpp
+++ b/src/fsfw/datapoollocal/LocalDataPoolManager.cpp
@ -577,10 +577,6 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(CommandMessage* me

  CommandMessage reply;
  if (result != HasReturnvaluesIF::RETURN_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);
@ -700,7 +696,8 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
  if (result != HasReturnvaluesIF::RETURN_OK) {
    /* Configuration error */
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "LocalDataPoolManager::performPeriodicHkOperation: HK generation failed." << std::endl;
+    sif::warning << "LocalDataPoolManager::performPeriodicHkOperation: HK generation failed."
+                 << std::endl;
 #else
    sif::printWarning("LocalDataPoolManager::performPeriodicHkOperation: HK generation failed.\n");
 #endif
@ -838,8 +835,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 == HasReturnvaluesIF::RETURN_FAILED) {
      if (outputType == sif::OutputTypes::OUT_WARNING) {
        errorPrint = "Generic Warning";
--- a/src/fsfw/datapoollocal/LocalPoolDataSetBase.h
+++ b/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);
--- a/src/fsfw/devicehandlers/AssemblyBase.cpp
+++ b/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);
-  }
-}
--- a/src/fsfw/devicehandlers/AssemblyBase.h
+++ b/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,14 +47,13 @@ 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
-   *    - @c RETURN_OK if OK
+   *    - @c RETURN_OK if ok
   *    - @c NEED_SECOND_STEP if children need to be commanded again
   */
  virtual ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) = 0;
@ -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_ */
--- a/src/fsfw/devicehandlers/DeviceHandlerBase.cpp
+++ b/src/fsfw/devicehandlers/DeviceHandlerBase.cpp
@ -39,9 +39,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();
@ -49,6 +48,9 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, object_id_t device
    printWarningOrError(sif::OutputTypes::OUT_ERROR, "DeviceHandlerBase",
                        HasReturnvaluesIF::RETURN_FAILED, "Invalid cookie");
  }
+  if (this->fdirInstance == nullptr) {
+    this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId, defaultFdirParentId);
+  }
 }

 void DeviceHandlerBase::setHkDestination(object_id_t hkDestination) {
@ -63,7 +65,9 @@ void DeviceHandlerBase::setThermalStateRequestPoolIds(lp_id_t thermalStatePoolId
 }

 DeviceHandlerBase::~DeviceHandlerBase() {
-  delete comCookie;
+  if (comCookie != nullptr) {
+    delete comCookie;
+  }
  if (defaultFDIRUsed) {
    delete fdirInstance;
  }
@ -124,18 +128,6 @@ ReturnValue_t DeviceHandlerBase::initialize() {
  if (result != RETURN_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);
@ -247,15 +239,14 @@ void DeviceHandlerBase::decrementDeviceReplyMap() {
  for (std::pair<const DeviceCommandId_t, DeviceReplyInfo>& replyPair : deviceReplyMap) {
    if (replyPair.second.countdown != nullptr && replyPair.second.active) {
      if (replyPair.second.countdown->hasTimedOut()) {
+        resetTimeoutControlledReply(&replyPair.second);
        timedOut = true;
      }
    }
    if (replyPair.second.delayCycles != 0 && replyPair.second.countdown == nullptr) {
      replyPair.second.delayCycles--;
      if (replyPair.second.delayCycles == 0) {
-        if (replyPair.second.periodic) {
-          replyPair.second.delayCycles = replyPair.second.maxDelayCycles;
-        }
+        resetDelayCyclesControlledReply(&replyPair.second);
        timedOut = true;
      }
    }
@ -263,7 +254,6 @@ void DeviceHandlerBase::decrementDeviceReplyMap() {
      replyToReply(replyPair.first, replyPair.second, TIMEOUT);
      missedReply(replyPair.first);
      timedOut = false;
-      replyPair.second.active = false;
    }
  }
 }
@ -373,12 +363,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);
@ -451,9 +442,6 @@ ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
  info.dataSet = dataSet;
  info.command = deviceCommandMap.end();
  info.countdown = countdown;
-  if (info.periodic) {
-    info.active = true;
-  }
  auto resultPair = deviceReplyMap.emplace(replyId, info);
  if (resultPair.second) {
    return RETURN_OK;
@ -526,9 +514,19 @@ ReturnValue_t DeviceHandlerBase::updatePeriodicReply(bool enable, DeviceCommandI
      return COMMAND_NOT_SUPPORTED;
    }
    if (enable) {
-      info->delayCycles = info->maxDelayCycles;
+      info->active = true;
+      if (info->countdown != nullptr) {
+        info->delayCycles = info->maxDelayCycles;
+      } else {
+        info->countdown->resetTimer();
+      }
    } else {
-      info->delayCycles = 0;
+      info->active = false;
+      if (info->countdown != nullptr) {
+        info->delayCycles = 0;
+      } else {
+        info->countdown->timeOut();
+      }
    }
  }
  return HasReturnvaluesIF::RETURN_OK;
@ -572,9 +570,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);
@ -846,9 +841,9 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData, DeviceCommandId
    }

    if (info->active && info->countdown != nullptr) {
-      disableTimeoutControlledReply(info);
+      resetTimeoutControlledReply(info);
    } else if (info->delayCycles != 0) {
-      disableDelayCyclesControlledReply(info);
+      resetDelayCyclesControlledReply(info);
    }

    if (result != RETURN_OK) {
@ -867,7 +862,7 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData, DeviceCommandId
  }
 }

-void DeviceHandlerBase::disableTimeoutControlledReply(DeviceReplyInfo* info) {
+void DeviceHandlerBase::resetTimeoutControlledReply(DeviceReplyInfo* info) {
  if (info->periodic) {
    info->countdown->resetTimer();
  } else {
@ -876,7 +871,7 @@ void DeviceHandlerBase::disableTimeoutControlledReply(DeviceReplyInfo* info) {
  }
 }

-void DeviceHandlerBase::disableDelayCyclesControlledReply(DeviceReplyInfo* info) {
+void DeviceHandlerBase::resetDelayCyclesControlledReply(DeviceReplyInfo* info) {
  if (info->periodic) {
    info->delayCycles = info->maxDelayCycles;
  } else {
@ -1007,6 +1002,8 @@ ReturnValue_t DeviceHandlerBase::enableReplyInReplyMap(DeviceCommandMap::iterato
  }
  if (iter != deviceReplyMap.end()) {
    DeviceReplyInfo* info = &(iter->second);
+    // If a countdown has been set, the delay cycles will be ignored and the reply times out
+    // as soon as the countdown has expired
    info->delayCycles = info->maxDelayCycles;
    info->command = command;
    command->second.expectedReplies = expectedReplies;
@ -1405,7 +1402,12 @@ uint8_t DeviceHandlerBase::getReplyDelayCycles(DeviceCommandId_t deviceCommand)
  if (iter == deviceReplyMap.end()) {
    return 0;
  } else if (iter->second.countdown != nullptr) {
-    return 0;
+    // fake a useful return value for legacy code
+    if (iter->second.active) {
+      return 1;
+    } else {
+      return 0;
+    }
  }
  return iter->second.delayCycles;
 }
@ -1454,8 +1456,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,
@ -1478,7 +1478,7 @@ ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
  this->poolManager.initializeAfterTaskCreation();

  if (setStartupImmediately) {
-    startTransition(MODE_ON, getInitialSubmode());
+    startTransition(MODE_ON, SUBMODE_NONE);
  }
  return HasReturnvaluesIF::RETURN_OK;
 }
@ -1562,29 +1562,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;
-    }
-  }
-}
--- a/src/fsfw/devicehandlers/DeviceHandlerBase.h
+++ b/src/fsfw/devicehandlers/DeviceHandlerBase.h
@ -7,7 +7,6 @@
 #include "DeviceHandlerFailureIsolation.h"
 #include "DeviceHandlerIF.h"
 #include "DeviceHandlerThermalSet.h"
-#include "DhbCfgHelpers.h"
 #include "fsfw/action/ActionHelper.h"
 #include "fsfw/action/HasActionsIF.h"
 #include "fsfw/datapool/PoolVariableIF.h"
@ -104,9 +103,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);

  /**
@ -468,14 +464,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 RETURN_OK when the command was successfully inserted,
   *          - @c RETURN_FAILED else.
   */
@ -489,9 +485,9 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   * @return - @c RETURN_OK when the command was successfully inserted,
   *         - @c RETURN_FAILED else.
   */
-  ReturnValue_t insertInCommandMap(
-      DeviceCommandId_t deviceCommand, bool useAlternativeReply = false,
-      DeviceCommandId_t alternativeReplyId = DeviceHandlerIF::NO_COMMAND_ID);
+  ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand,
+                                   bool useAlternativeReply = false,
+                                   DeviceCommandId_t alternativeReplyId = 0);

  /**
   * Enables a periodic reply for a given command. It sets to delay cycles to the specified
@ -660,12 +656,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;

@ -784,18 +774,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
@ -851,7 +834,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;
@ -1275,15 +1257,15 @@ class DeviceHandlerBase : public DeviceHandlerIF,
  void doGetRead(void);

  /**
-   * @brief Handles disabling of replies which use a timeout to detect missed replies.
+   * @brief Resets replies which use a timeout to detect missed replies.
   */
-  void disableTimeoutControlledReply(DeviceReplyInfo *info);
+  void resetTimeoutControlledReply(DeviceReplyInfo *info);

  /**
-   * @brief Handles disabling of replies which use a number of maximum delay cycles to detect
+   * @brief Resets replies which use a number of maximum delay cycles to detect
   *        missed replies.
   */
-  void disableDelayCyclesControlledReply(DeviceReplyInfo *info);
+  void resetDelayCyclesControlledReply(DeviceReplyInfo *info);

  /**
   * Retrive data from the #IPCStore.
@ -1326,11 +1308,6 @@ class DeviceHandlerBase : public DeviceHandlerIF,
  void printWarningOrError(sif::OutputTypes errorType, const char *functionName,
                           ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_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_ */
--- a/src/fsfw/devicehandlers/DeviceHandlerFailureIsolation.cpp
+++ b/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());
--- a/src/fsfw/devicehandlers/DeviceHandlerIF.h
+++ b/src/fsfw/devicehandlers/DeviceHandlerIF.h
@ -109,7 +109,6 @@ class DeviceHandlerIF {
  static const Event INVALID_DEVICE_COMMAND = MAKE_EVENT(8, severity::LOW);
  static const Event MONITORING_LIMIT_EXCEEDED = MAKE_EVENT(9, severity::LOW);
  static const Event MONITORING_AMBIGUOUS = MAKE_EVENT(10, severity::HIGH);
-  static const Event DEVICE_WANTS_HARD_REBOOT = MAKE_EVENT(11, severity::HIGH);

  static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;

--- a/src/fsfw/devicehandlers/DhbCfgHelpers.h
+++ b/src/fsfw/devicehandlers/DhbCfgHelpers.h
@ -1,72 +0,0 @@
-#ifndef FSFW_SRC_FSFW_DEVICEHANDLERS_DHBCFGHELPERS_H_
-#define FSFW_SRC_FSFW_DEVICEHANDLERS_DHBCFGHELPERS_H_
-
-/**
- * @brief   This is the base class for configuration related to both DHB commands, replies and their
- *          combination
- */
-struct CfgBase {
- public:
-  explicit CfgBase(DeviceCommandId_t cmdAndOrReplyId) : cmdAndOrReplyId(cmdAndOrReplyId){};
-  DeviceCommandId_t cmdAndOrReplyId;
-};
-
-/**
- * @brief   Configuration class for commands
- */
-struct CmdCfg {
- public:
-  explicit CmdCfg(DeviceCommandId_t cmdId) : baseCfg(cmdId){};
-
-  CfgBase baseCfg;
-  //! This can be used if a command can trigger multiple replies
-  std::pair<bool, DeviceCommandId_t> alternativeReply = {false, DeviceHandlerIF::NO_COMMAND_ID};
-};
-
-/**
- * @brief   Configuration class for replies
- */
-struct ReplyCfg {
- public:
-  ReplyCfg(DeviceCommandId_t replyId, uint16_t maxDelayCycles)
-      : baseCfg(replyId), maxDelayCycles(maxDelayCycles){};
-  ReplyCfg(DeviceCommandId_t replyId, uint16_t maxDelayCycles, LocalPoolDataSetBase* set)
-      : ReplyCfg(replyId, maxDelayCycles) {
-    dataSet = set;
-  };
-
-  CfgBase baseCfg;
-  //! A data set can be mapped to a reply ID. This allows to omit the #getDataSetHandle
-  //! override in a user device handler as this pointer will be passed as long as the device
-  //! command ID is equal to the set ID.
-  LocalPoolDataSetBase* dataSet = nullptr;
-  //! 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 = 0;
-  //! First parameter: Specify whether reply is arriving periodically
-  //! Second parameter: Specify whether periodic reply should be enabled immediately
-  std::pair<bool, bool> periodicCfg = {false, false};
-  //! If a reply needs to be requested with a specific length, the length can be specified here
-  size_t replyLen = 0;
-  //! It is also possible to use a time based instead of a cycle based mechanism to specify
-  //! how long a reply takes. For non-periodic replies without a command, this variable is not used.
-  Countdown* countdown = nullptr;
-};
-
-/**
- * @brief   Configuration class for commands and replies
- */
-struct CmdReplyCfg {
- public:
-  CmdReplyCfg(CmdCfg cmdCfg, ReplyCfg replyCfg) : cmdCfg(cmdCfg), replyCfg(replyCfg) {}
-  CmdCfg cmdCfg;
-  ReplyCfg replyCfg;
-};
-
-#endif /* FSFW_SRC_FSFW_DEVICEHANDLERS_DHBCFGHELPERS_H_ */
--- a/src/fsfw/devicehandlers/HealthDevice.cpp
+++ b/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); }
--- a/src/fsfw/events/EventManager.cpp
+++ b/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 != HasReturnvaluesIF::RETURN_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();
@ -100,6 +88,11 @@ ReturnValue_t EventManager::subscribeToEventRange(MessageQueueId_t listener, Eve
  return result;
 }

+ReturnValue_t EventManager::unsubscribeFromAllEvents(MessageQueueId_t listener,
+                                                     object_id_t object) {
+  return unsubscribeFromEventRange(listener, 0, 0, true, object);
+}
+
 ReturnValue_t EventManager::unsubscribeFromEventRange(MessageQueueId_t listener, EventId_t idFrom,
                                                      EventId_t idTo, bool idInverted,
                                                      object_id_t reporterFrom,
@ -201,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 */
--- a/src/fsfw/events/EventManager.h
+++ b/src/fsfw/events/EventManager.h
@ -37,12 +37,12 @@ class EventManager : public EventManagerIF, public ExecutableObjectIF, public Sy
                                      EventId_t idTo = 0, bool idInverted = false,
                                      object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
                                      bool reporterInverted = false);
+  ReturnValue_t unsubscribeFromAllEvents(MessageQueueId_t listener, object_id_t object);
  ReturnValue_t unsubscribeFromEventRange(MessageQueueId_t listener, EventId_t idFrom = 0,
                                          EventId_t idTo = 0, bool idInverted = false,
                                          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;
--- a/src/fsfw/events/EventManagerIF.h
+++ b/src/fsfw/events/EventManagerIF.h
@ -20,6 +20,7 @@ class EventManagerIF {
                                         bool forwardAllButSelected = false) = 0;
  virtual ReturnValue_t subscribeToEvent(MessageQueueId_t listener, EventId_t event) = 0;
  virtual ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener, object_id_t object) = 0;
+  virtual ReturnValue_t unsubscribeFromAllEvents(MessageQueueId_t listener, object_id_t object) = 0;
  virtual ReturnValue_t subscribeToEventRange(MessageQueueId_t listener, EventId_t idFrom = 0,
                                              EventId_t idTo = 0, bool idInverted = false,
                                              object_id_t reporterFrom = 0,
--- a/src/fsfw/fdir/FailureIsolationBase.cpp
+++ b/src/fsfw/fdir/FailureIsolationBase.cpp
@ -9,12 +9,21 @@
 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() {
+  EventManagerIF* manager = ObjectManager::instance()->get<EventManagerIF>(objects::EVENT_MANAGER);
+  if (manager == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "FailureIsolationBase::~FailureIsolationBase: Event Manager has not"
+                  " been initialized!"
+               << std::endl;
+#endif
+    return;
+  }
+  manager->unsubscribeFromAllEvents(eventQueue->getId(), ownerId);
  QueueFactory::instance()->deleteMessageQueue(eventQueue);
 }

@ -52,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 RETURN_FAILED;
--- a/src/fsfw/fdir/FailureIsolationBase.h
+++ b/src/fsfw/fdir/FailureIsolationBase.h
@ -14,12 +14,13 @@ class FailureIsolationBase : public HasReturnvaluesIF,
                             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);
--- a/src/fsfw/fdir/FaultCounter.cpp
+++ b/src/fsfw/fdir/FaultCounter.cpp
@ -60,14 +60,14 @@ ReturnValue_t FaultCounter::getParameter(uint8_t domainId, uint8_t uniqueId,
    return INVALID_DOMAIN_ID;
  }

-  switch (uniqueId) {
-    case 0:
+  switch (static_cast<ParameterIds>(uniqueId)) {
+    case ParameterIds::FAILURE_THRESHOLD:
      parameterWrapper->set(failureThreshold);
      break;
-    case 1:
+    case ParameterIds::FAULT_COUNT:
      parameterWrapper->set(faultCount);
      break;
-    case 2:
+    case ParameterIds::TIMEOUT:
      parameterWrapper->set(timer.timeout);
      break;
    default:
--- a/src/fsfw/fdir/FaultCounter.h
+++ b/src/fsfw/fdir/FaultCounter.h
@ -6,6 +6,8 @@

 class FaultCounter : public HasParametersIF {
 public:
+  enum class ParameterIds { FAILURE_THRESHOLD, FAULT_COUNT, TIMEOUT };
+
  FaultCounter();
  FaultCounter(uint32_t failureThreshold, uint32_t decrementAfterMs,
               uint8_t setParameterDomain = 0);
@ -25,7 +27,8 @@ class FaultCounter : public HasParametersIF {

  virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
                                     ParameterWrapper *parameterWrapper,
-                                     const ParameterWrapper *newValues, uint16_t startAtIndex);
+                                     const ParameterWrapper *newValues = nullptr,
+                                     uint16_t startAtIndex = 0);

  void setParameterDomain(uint8_t domain);

--- a/src/fsfw/globalfunctions/CMakeLists.txt
+++ b/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
--- a/src/fsfw/globalfunctions/DleParser.cpp
+++ b/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 RETURN_FAILED;
-  }
-  size_t copyIntoRingBufFromHere = 0;
-  size_t copyAmount = len;
-  size_t startIdx = 0;
-  ReturnValue_t result = RETURN_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 == HasReturnvaluesIF::RETURN_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 != HasReturnvaluesIF::RETURN_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 == HasReturnvaluesIF::RETURN_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 != HasReturnvaluesIF::RETURN_OK) {
-      ErrorInfo info;
-      info.res = result;
-      prepareErrorContext(ErrorTypes::RING_BUF_ERROR, info);
-      handler(ctx);
-    }
-  }
-  return RETURN_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();
-}
--- a/src/fsfw/globalfunctions/DleParser.h
+++ b/src/fsfw/globalfunctions/DleParser.h
@ -1,124 +0,0 @@
-#pragma once
-
-#include <fsfw/container/SimpleRingBuffer.h>
-#include <fsfw/globalfunctions/DleEncoder.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.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 HasReturnvaluesIF {
- 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;
-};
--- a/src/fsfw/health/HasHealthIF.h
+++ b/src/fsfw/health/HasHealthIF.h
@ -16,27 +16,26 @@ class HasHealthIF {
  };

  static const uint8_t INTERFACE_ID = CLASS_ID::HAS_HEALTH_IF;
-  static constexpr ReturnValue_t OBJECT_NOT_HEALTHY =
-      HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 1);
-  static constexpr ReturnValue_t INVALID_HEALTH_STATE =
-      HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 2);
-  static constexpr ReturnValue_t IS_EXTERNALLY_CONTROLLED =
-      HasReturnvaluesIF::makeReturnCode(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;
--- a/src/fsfw/health/HealthHelper.cpp
+++ b/src/fsfw/health/HealthHelper.cpp
@ -5,7 +5,7 @@
 HealthHelper::HealthHelper(HasHealthIF* owner, object_id_t objectId)
    : objectId(objectId), owner(owner) {}

-HealthHelper::~HealthHelper() {}
+HealthHelper::~HealthHelper() { healthTable->removeObject(objectId); }

 ReturnValue_t HealthHelper::handleHealthCommand(CommandMessage* message) {
  switch (message->getCommand()) {
--- a/src/fsfw/health/HealthTable.cpp
+++ b/src/fsfw/health/HealthTable.cpp
@ -27,6 +27,15 @@ ReturnValue_t HealthTable::registerObject(object_id_t object,
  return HasReturnvaluesIF::RETURN_OK;
 }

+ReturnValue_t HealthTable::removeObject(object_id_t object) {
+  mapIterator = healthMap.find(object);
+  if (mapIterator == healthMap.end()) {
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  healthMap.erase(mapIterator);
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
 void HealthTable::setHealth(object_id_t object, HasHealthIF::HealthState newState) {
  MutexGuard(mutex, timeoutType, mutexTimeoutMs);
  HealthMap::iterator iter = healthMap.find(object);
--- a/src/fsfw/health/HealthTable.h
+++ b/src/fsfw/health/HealthTable.h
@ -17,6 +17,7 @@ class HealthTable : public HealthTableIF, public SystemObject {
  /** HealthTableIF overrides */
  virtual ReturnValue_t registerObject(
      object_id_t object, HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY) override;
+  ReturnValue_t removeObject(object_id_t object) override;
  virtual size_t getPrintSize() override;
  virtual void printAll(uint8_t* pointer, size_t maxSize) override;

--- a/src/fsfw/health/HealthTableIF.h
+++ b/src/fsfw/health/HealthTableIF.h
@ -14,6 +14,8 @@ class HealthTableIF : public ManagesHealthIF {
  virtual ReturnValue_t registerObject(
      object_id_t object, HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY) = 0;

+  virtual ReturnValue_t removeObject(object_id_t objectId) = 0;
+
  virtual size_t getPrintSize() = 0;
  virtual void printAll(uint8_t *pointer, size_t maxSize) = 0;

--- a/src/fsfw/internalerror/InternalErrorReporter.cpp
+++ b/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
    }
  }
--- a/src/fsfw/ipc/CommandMessageIF.h
+++ b/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(){};
--- a/src/fsfw/modes/HasModesIF.h
+++ b/src/fsfw/modes/HasModesIF.h
@ -19,33 +19,32 @@ class HasModesIF {
  static const ReturnValue_t INVALID_SUBMODE = MAKE_RETURN_CODE(0x04);

  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER;
-  //! An object announces changing the mode. p1: target mode. p2: target submode
-  static const Event CHANGING_MODE = MAKE_EVENT(0, severity::INFO);
-  //! An Object announces its mode; parameter1 is mode, parameter2 is submode
-  static const Event MODE_INFO = MAKE_EVENT(1, severity::INFO);
+  static const Event CHANGING_MODE =
+      MAKE_EVENT(0, severity::INFO);  //!< An object announces changing the mode. p1: target mode.
+                                      //!< p2: target submode
+  static const Event MODE_INFO = MAKE_EVENT(
+      1,
+      severity::INFO);  //!< An Object announces its mode; parameter1 is mode, parameter2 is submode
  static const Event FALLBACK_FAILED = MAKE_EVENT(2, severity::HIGH);
  static const Event MODE_TRANSITION_FAILED = MAKE_EVENT(3, severity::LOW);
  static const Event CANT_KEEP_MODE = MAKE_EVENT(4, severity::HIGH);
-  //! Indicates a bug or configuration failure: Object is in a mode it should never be in.
-  static const Event OBJECT_IN_INVALID_MODE = MAKE_EVENT(5, severity::LOW);
-  //! The mode is changed, but for some reason, the change is forced, i.e. EXTERNAL_CONTROL ignored.
-  //! p1: target mode. p2: target submode
-  static const Event FORCING_MODE = MAKE_EVENT(6, severity::MEDIUM);
-  //! A mode command was rejected by the called object. Par1: called object id, Par2: return code.
-  static const Event MODE_CMD_REJECTED = MAKE_EVENT(7, severity::LOW);
+  static const Event OBJECT_IN_INVALID_MODE =
+      MAKE_EVENT(5, severity::LOW);  //!< Indicates a bug or configuration failure: Object is in a
+                                     //!< mode it should never be in.
+  static const Event FORCING_MODE = MAKE_EVENT(
+      6, severity::MEDIUM);  //!< The mode is changed, but for some reason, the change is forced,
+                             //!< i.e. EXTERNAL_CONTROL ignored. p1: target mode. p2: target submode
+  static const Event MODE_CMD_REJECTED =
+      MAKE_EVENT(7, severity::LOW);  //!< A mode command was rejected by the called object. Par1:
+                                     //!< called object id, Par2: return code.

-  //! The device is powered and ready to perform operations. In this mode, no commands are
-  //! sent by the device handler itself, but direct commands van be commanded and will be
-  //! interpreted
-  static constexpr Mode_t MODE_ON = 1;
-  //! The device is powered off. The only command accepted in this mode is a mode change to on.
-  static constexpr Mode_t MODE_OFF = 0;
-
-  static constexpr Mode_t MODE_INVALID = -1;
-  static constexpr Mode_t MODE_UNDEFINED = -2;
-
-  //! To avoid checks against magic number "0".
-  static const Submode_t SUBMODE_NONE = 0;
+  static const Mode_t MODE_ON =
+      1;  //!< The device is powered and ready to perform operations. In this mode, no commands are
+          //!< sent by the device handler itself, but direct commands van be commanded and will be
+          //!< interpreted
+  static const Mode_t MODE_OFF = 0;  //!< The device is powered off. The only command accepted in
+                                     //!< this mode is a mode change to on.
+  static const Submode_t SUBMODE_NONE = 0;  //!< To avoid checks against magic number "0".

  virtual ~HasModesIF() {}
  virtual MessageQueueId_t getCommandQueue() const = 0;
--- a/src/fsfw/objectmanager/ObjectManager.cpp
+++ b/src/fsfw/objectmanager/ObjectManager.cpp
@ -95,16 +95,13 @@ void ObjectManager::initialize() {
  for (auto const& it : objectList) {
    result = it.second->initialize();
    if (result != RETURN_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++;
    }
--- a/src/fsfw/osal/CMakeLists.txt
+++ b/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)
--- a/src/fsfw/osal/linux/FixedTimeslotTask.cpp
+++ b/src/fsfw/osal/linux/FixedTimeslotTask.cpp
@ -54,7 +54,7 @@ ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
      // If the deadline was missed, the deadlineMissedFunc is called.
      if (!PosixThread::delayUntil(&lastWakeTime, interval)) {
        // No time left on timer -> we missed the deadline
-        if(dlmFunc != nullptr){
+        if (dlmFunc != nullptr) {
          dlmFunc();
        }
      }
--- a/src/fsfw/osal/linux/MessageQueue.cpp
+++ b/src/fsfw/osal/linux/MessageQueue.cpp
@ -290,10 +290,9 @@ ReturnValue_t MessageQueue::handleOpenError(mq_attr* attributes, uint32_t messag
         */
 #if FSFW_CPP_OSTREAM_ENABLED == 1
        sif::error << "MessageQueue::MessageQueue: Default MQ size " << defaultMqMaxMsg
-                   << " is too small for requested size " << messageDepth << std::endl;
+                   << " is too small for requested message depth " << messageDepth << std::endl;
        sif::error << "This error can be fixed by setting the maximum "
-                      "allowed message size higher!"
-                   << std::endl;
+                      "allowed message depth higher" << std::endl;
 #else
        sif::printError(
            "MessageQueue::MessageQueue: Default MQ size %d is too small for"
--- a/src/fsfw/parameters/HasParametersIF.h
+++ b/src/fsfw/parameters/HasParametersIF.h
@ -66,7 +66,7 @@ class HasParametersIF {
   * @param newValues
   * @param startAtIndex Linear index, runs left to right, top to bottom for
   * matrix indexes.
-   * @return RETURN_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,
--- a/src/fsfw/parameters/ParameterWrapper.cpp
+++ b/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;
--- a/src/fsfw/power/PowerSwitchIF.h
+++ b/src/fsfw/power/PowerSwitchIF.h
@ -29,9 +29,9 @@ class PowerSwitchIF : public HasReturnvaluesIF {
  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.
   *
--- a/src/fsfw/pus/Service11TelecommandScheduling.tpp
+++ b/src/fsfw/pus/Service11TelecommandScheduling.tpp
@ -78,7 +78,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);
--- a/src/fsfw/pus/Service1TelecommandVerification.cpp
+++ b/src/fsfw/pus/Service1TelecommandVerification.cpp
@ -16,9 +16,7 @@ Service1TelecommandVerification::Service1TelecommandVerification(object_id_t obj
      apid(apid),
      serviceId(serviceId),
      targetDestination(targetDestination) {
-  auto mqArgs = MqArgs(objectId, static_cast<void*>(this));
-  tmQueue = QueueFactory::instance()->createMessageQueue(
-      messageQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  tmQueue = QueueFactory::instance()->createMessageQueue(messageQueueDepth);
 }

 Service1TelecommandVerification::~Service1TelecommandVerification() {
--- a/src/fsfw/pus/Service3Housekeeping.cpp
+++ b/src/fsfw/pus/Service3Housekeeping.cpp
@ -208,17 +208,17 @@ ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
      ReturnValue_t error = HasReturnvaluesIF::RETURN_FAILED;
      HousekeepingMessage::getHkRequestFailureReply(reply, &error);
      failureParameter2 = error;
-      return RETURN_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,25 +248,19 @@ void Service3Housekeeping::handleUnrequestedReply(CommandMessage* reply) {
    case (HousekeepingMessage::HK_REQUEST_FAILURE): {
      break;
    }
-    case (CommandMessage::REPLY_REJECTED): {
-      sif::warning << "Service3Housekeeping::handleUnrequestedReply: Unexpected reply "
-                      "rejected with error code"
-                   << reply->getParameter() << std::endl;
-      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;
    }
  }

@ -281,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(); }
--- a/src/fsfw/pus/Service5EventReporting.cpp
+++ b/src/fsfw/pus/Service5EventReporting.cpp
@ -12,9 +12,7 @@ Service5EventReporting::Service5EventReporting(object_id_t objectId, uint16_t ap
                                               uint32_t messageQueueDepth)
    : PusServiceBase(objectId, apid, serviceId),
      maxNumberReportsPerCycle(maxNumberReportsPerCycle) {
-  auto mqArgs = MqArgs(objectId, static_cast<void*>(this));
-  eventQueue = QueueFactory::instance()->createMessageQueue(
-      messageQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  eventQueue = QueueFactory::instance()->createMessageQueue(messageQueueDepth);
 }

 Service5EventReporting::~Service5EventReporting() {
@ -38,6 +36,9 @@ ReturnValue_t Service5EventReporting::performService() {
      }
    }
  }
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::warning << "Service5EventReporting::generateEventReport: Too many events" << std::endl;
+#endif
  return HasReturnvaluesIF::RETURN_OK;
 }

--- a/src/fsfw/pus/Service5EventReporting.h
+++ b/src/fsfw/pus/Service5EventReporting.h
@ -41,7 +41,7 @@
 class Service5EventReporting : public PusServiceBase {
 public:
  Service5EventReporting(object_id_t objectId, uint16_t apid, uint8_t serviceId,
-                         size_t maxNumberReportsPerCycle, uint32_t messageQueueDepth);
+                         size_t maxNumberReportsPerCycle = 10, uint32_t messageQueueDepth = 10);
  virtual ~Service5EventReporting();

  /***
--- a/src/fsfw/pus/Service9TimeManagement.h
+++ b/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;

--- a/src/fsfw/subsystem/Subsystem.h
+++ b/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:
--- a/src/fsfw/subsystem/SubsystemBase.cpp
+++ b/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;
--- a/src/fsfw/subsystem/SubsystemBase.h
+++ b/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,
@ -103,7 +96,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
   */
--- a/src/fsfw/tcdistribution/CFDPDistributor.cpp
+++ b/src/fsfw/tcdistribution/CFDPDistributor.cpp
@ -33,7 +33,11 @@ CFDPDistributor::TcMqMapIter CFDPDistributor::selectDestination() {
  if (this->currentPacket == nullptr) {
    return queueMapIt;
  }
-  this->currentPacket->setStoreAddress(this->currentMessage.getStorageId());
+  ReturnValue_t result = this->currentPacket->setStoreAddress(this->currentMessage.getStorageId());
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    tcStatus = PACKET_TOO_SHORT;
+    return this->queueMap.end();
+  }
  if (currentPacket->getWholeData() != nullptr) {
    tcStatus = checker.checkPacket(currentPacket);
    if (tcStatus != HasReturnvaluesIF::RETURN_OK) {
--- a/src/fsfw/tcdistribution/PUSDistributor.cpp
+++ b/src/fsfw/tcdistribution/PUSDistributor.cpp
@ -27,7 +27,12 @@ PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
    if (this->currentPacket == nullptr) {
      return queueMapIt;
    }
-    this->currentPacket->setStoreAddress(this->currentMessage.getStorageId(), currentPacket);
+    ReturnValue_t result =
+        this->currentPacket->setStoreAddress(this->currentMessage.getStorageId(), currentPacket);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      tcStatus = PACKET_TOO_SHORT;
+      return this->queueMap.end();
+    }
    if (currentPacket->getWholeData() != nullptr) {
      tcStatus = checker.checkPacket(currentPacket);
      if (tcStatus != HasReturnvaluesIF::RETURN_OK) {
@ -106,6 +111,14 @@ ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
 MessageQueueId_t PUSDistributor::getRequestQueue() { return tcQueue->getId(); }

 ReturnValue_t PUSDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
+  if (tcStatus == PACKET_LOST or tcStatus == PACKET_TOO_SHORT) {
+    // The ack flags, packet id and sequence control are unknown for a packet which is too short or
+    // has been lost
+    this->verifyChannel.sendFailureReport(tc_verification::ACCEPTANCE_FAILURE, UNKNOWN_ACK_FLAGS,
+                                          UNKNOWN_PACKET_ID, UNKNOWN_SEQUENCE_CONTROL, tcStatus);
+    currentPacket->deletePacket();
+    return RETURN_FAILED;
+  }
  if (queueStatus != RETURN_OK) {
    tcStatus = queueStatus;
  }
--- a/src/fsfw/tcdistribution/PUSDistributor.h
+++ b/src/fsfw/tcdistribution/PUSDistributor.h
@ -72,6 +72,11 @@ class PUSDistributor : public TcDistributor, public PUSDistributorIF, public Acc
   * success/failure messages.
   */
  ReturnValue_t callbackAfterSending(ReturnValue_t queueStatus) override;
+
+ private:
+  static const uint8_t UNKNOWN_ACK_FLAGS = 0;
+  static const uint8_t UNKNOWN_PACKET_ID = 0;
+  static const uint8_t UNKNOWN_SEQUENCE_CONTROL = 0;
 };

 #endif /* FSFW_TCDISTRIBUTION_PUSDISTRIBUTOR_H_ */
--- a/src/fsfw/tcdistribution/TcDistributor.cpp
+++ b/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); }
--- a/src/fsfw/tcdistribution/TcDistributor.h
+++ b/src/fsfw/tcdistribution/TcDistributor.h
@ -36,6 +36,7 @@ class TcDistributor : public SystemObject, public ExecutableObjectIF, public Has
  static constexpr ReturnValue_t PACKET_LOST = MAKE_RETURN_CODE(1);
  static constexpr ReturnValue_t DESTINATION_NOT_FOUND = MAKE_RETURN_CODE(2);
  static constexpr ReturnValue_t SERVICE_ID_ALREADY_EXISTS = MAKE_RETURN_CODE(3);
+  static constexpr ReturnValue_t PACKET_TOO_SHORT = MAKE_RETURN_CODE(4);
  /**
   * Within the default constructor, the SystemObject id is set and the
   * message queue is initialized.
--- a/src/fsfw/thermal/AbstractTemperatureSensor.cpp
+++ b/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() {
--- a/src/fsfw/thermal/AbstractTemperatureSensor.h
+++ b/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;

--- a/src/fsfw/thermal/Heater.cpp
+++ b/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); }
--- a/src/fsfw/thermal/ThermalComponentIF.h
+++ b/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);
--- a/src/fsfw/timemanager/Countdown.cpp
+++ b/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() {}
--- a/src/fsfw/timemanager/Countdown.h
+++ b/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.
--- a/src/fsfw/tmstorage/TmStoreBackendIF.h
+++ b/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() {}

--- a/src/fsfw/tmtcpacket/SpacePacket.h
+++ b/src/fsfw/tmtcpacket/SpacePacket.h
@ -25,7 +25,7 @@ class SpacePacket : public SpacePacketBase {
   * @param apid Sets the packet's APID field. The default value describes an idle packet.
   * @param sequenceCount ets the packet's Source Sequence Count field.
   */
-  SpacePacket(uint16_t packetDataLength = 0, bool isTelecommand = false,
+  SpacePacket(uint16_t packetDataLength, bool isTelecommand = false,
              uint16_t apid = APID_IDLE_PACKET, uint16_t sequenceCount = 0);
  /**
   * The class's default destructor.
--- a/src/fsfw/tmtcpacket/cfdp/CFDPPacketStored.cpp
+++ b/src/fsfw/tmtcpacket/cfdp/CFDPPacketStored.cpp
@ -37,7 +37,7 @@ ReturnValue_t CFDPPacketStored::deletePacket() {
 // CFDPPacket* CFDPPacketStored::getPacketBase() {
 //     return this;
 // }
-void CFDPPacketStored::setStoreAddress(store_address_t setAddress) {
+ReturnValue_t CFDPPacketStored::setStoreAddress(store_address_t setAddress) {
  this->storeAddress = setAddress;
  const uint8_t* tempData = nullptr;
  size_t tempSize;
@ -46,11 +46,11 @@ void CFDPPacketStored::setStoreAddress(store_address_t setAddress) {
    status = this->store->getData(this->storeAddress, &tempData, &tempSize);
  }
  if (status == StorageManagerIF::RETURN_OK) {
-    this->setData(const_cast<uint8_t*>(tempData), tempSize);
+    return this->setData(const_cast<uint8_t*>(tempData), tempSize);
  } else {
-    // To circumvent size checks
-    this->setData(nullptr, -1);
    this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+    // To circumvent size checks
+    return this->setData(nullptr, -1);
  }
 }

--- a/src/fsfw/tmtcpacket/cfdp/CFDPPacketStored.h
+++ b/src/fsfw/tmtcpacket/cfdp/CFDPPacketStored.h
@ -29,7 +29,7 @@ class CFDPPacketStored : public CFDPPacket, public TcPacketStoredBase {
   */
  ReturnValue_t getData(const uint8_t** dataPtr, size_t* dataSize);

-  void setStoreAddress(store_address_t setAddress);
+  ReturnValue_t setStoreAddress(store_address_t setAddress);

  store_address_t getStoreAddress();

--- a/src/fsfw/tmtcpacket/pus/tc/TcPacketStoredBase.cpp
+++ b/src/fsfw/tmtcpacket/pus/tc/TcPacketStoredBase.cpp
@ -42,7 +42,7 @@ bool TcPacketStoredBase::checkAndSetStore() {
  return true;
 }

-void TcPacketStoredBase::setStoreAddress(store_address_t setAddress,
+ReturnValue_t TcPacketStoredBase::setStoreAddress(store_address_t setAddress,
                                         RedirectableDataPointerIF* packet) {
  this->storeAddress = setAddress;
  const uint8_t* tempData = nullptr;
@ -53,10 +53,10 @@ void TcPacketStoredBase::setStoreAddress(store_address_t setAddress,
  }

  if (status == StorageManagerIF::RETURN_OK) {
-    packet->setData(const_cast<uint8_t*>(tempData), tempSize);
+    return packet->setData(const_cast<uint8_t*>(tempData), tempSize);
  } else {
-    packet->setData(nullptr, -1);
    this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+    return packet->setData(nullptr, -1);
  }
 }

--- a/src/fsfw/tmtcpacket/pus/tc/TcPacketStoredBase.h
+++ b/src/fsfw/tmtcpacket/pus/tc/TcPacketStoredBase.h
@ -38,7 +38,8 @@ class TcPacketStoredBase : public TcPacketStoredIF {
   */
  ReturnValue_t getData(const uint8_t** dataPtr, size_t* dataSize) override;

-  void setStoreAddress(store_address_t setAddress, RedirectableDataPointerIF* packet) override;
+  ReturnValue_t setStoreAddress(store_address_t setAddress,
+                                RedirectableDataPointerIF* packet) override;
  store_address_t getStoreAddress() override;

  /**
--- a/src/fsfw/tmtcpacket/pus/tc/TcPacketStoredIF.h
+++ b/src/fsfw/tmtcpacket/pus/tc/TcPacketStoredIF.h
@ -16,8 +16,11 @@ class TcPacketStoredIF {
   * With this call, the stored packet can be set to another packet in a store. This is useful
   * if the packet is a class member and used for more than one packet.
   * @param setAddress    The new packet id to link to.
+   *
+   * @return RETURN_OK if successful otherwise error return code.
   */
-  virtual void setStoreAddress(store_address_t setAddress, RedirectableDataPointerIF* packet) = 0;
+  virtual ReturnValue_t setStoreAddress(store_address_t setAddress,
+                                        RedirectableDataPointerIF* packet) = 0;

  virtual store_address_t getStoreAddress() = 0;

--- a/src/fsfw/tmtcservices/CommandingServiceBase.cpp
+++ b/src/fsfw/tmtcservices/CommandingServiceBase.cpp
@ -20,10 +20,8 @@ CommandingServiceBase::CommandingServiceBase(object_id_t setObjectId, uint16_t a
      service(service),
      timeoutSeconds(commandTimeoutSeconds),
      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) {
--- a/src/fsfw/tmtcservices/PusServiceBase.cpp
+++ b/src/fsfw/tmtcservices/PusServiceBase.cpp
@ -13,9 +13,7 @@ object_id_t PusServiceBase::packetDestination = 0;

 PusServiceBase::PusServiceBase(object_id_t setObjectId, uint16_t setApid, uint8_t setServiceId)
    : SystemObject(setObjectId), apid(setApid), serviceId(setServiceId) {
-  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
-  requestQueue = QueueFactory::instance()->createMessageQueue(
-      PUS_SERVICE_MAX_RECEPTION, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  requestQueue = QueueFactory::instance()->createMessageQueue(PUS_SERVICE_MAX_RECEPTION);
 }

 PusServiceBase::~PusServiceBase() { QueueFactory::instance()->deleteMessageQueue(requestQueue); }
--- a/src/fsfw/tmtcservices/SourceSequenceCounter.h
+++ b/src/fsfw/tmtcservices/SourceSequenceCounter.h
@ -5,10 +5,10 @@

 class SourceSequenceCounter {
 private:
-  uint16_t sequenceCount = 0;
+  uint16_t sequenceCount;

 public:
-  SourceSequenceCounter(uint16_t initialSequenceCount = 0) : sequenceCount(initialSequenceCount) {}
+  SourceSequenceCounter() : sequenceCount(0) {}
  void increment() {
    sequenceCount = (sequenceCount + 1) % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
  }
@ -19,20 +19,6 @@ class SourceSequenceCounter {
  void reset(uint16_t toValue = 0) {
    sequenceCount = toValue % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
  }
-  SourceSequenceCounter& operator++(int) {
-    this->increment();
-    return *this;
-  }
-  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_ */
--- a/src/fsfw/tmtcservices/TmTcBridge.cpp
+++ b/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 RETURN_OK;
@ -174,18 +172,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);
--- a/src/fsfw/tmtcservices/TmTcBridge.h
+++ b/src/fsfw/tmtcservices/TmTcBridge.h
@ -18,7 +18,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;
@ -43,7 +43,7 @@ class TmTcBridge : public AcceptsTelemetryIF,
   * @return -@c RETURN_OK if value was set successfully
   *         -@c RETURN_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.
@ -72,8 +72,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;
@ -152,7 +150,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_ */
--- a/hal/src/fsfw_hal/CMakeLists.txt
+++ b/hal/src/fsfw_hal/CMakeLists.txt
--- a/hal/src/fsfw_hal/common/CMakeLists.txt
+++ b/hal/src/fsfw_hal/common/CMakeLists.txt
--- a/hal/src/fsfw_hal/common/gpio/CMakeLists.txt
+++ b/hal/src/fsfw_hal/common/gpio/CMakeLists.txt
--- a/hal/src/fsfw_hal/common/gpio/GpioCookie.cpp
+++ b/hal/src/fsfw_hal/common/gpio/GpioCookie.cpp
--- a/hal/src/fsfw_hal/common/gpio/GpioCookie.h
+++ b/hal/src/fsfw_hal/common/gpio/GpioCookie.h
--- a/hal/src/fsfw_hal/common/gpio/GpioIF.h
+++ b/hal/src/fsfw_hal/common/gpio/GpioIF.h
@ -46,9 +46,9 @@ class GpioIF : public HasReturnvaluesIF {
   *          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_ */
--- a/hal/src/fsfw_hal/common/gpio/gpioDefinitions.h
+++ b/hal/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 };

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Robin Müller	b96f5a2552	Merge branch 'development' into meier/upstream-pus-distributor-bugfix	2022-07-18 15:12:30 +02:00
Robin Müller	9a2e68b37e	Merge pull request 'Move HAL and Tests folder' (#653 ) from mueller/move-hal-tests-folder into development Reviewed-on: fsfw/fsfw#653	2022-07-18 15:05:25 +02:00
Robin Mueller	91067cde98	typo	2022-07-18 15:00:40 +02:00
Robin Mueller	428018e4f1	update changelog	2022-07-18 14:59:25 +02:00
Robin Mueller	6e5239e9a0	update jenkinsfile	2022-07-18 14:36:40 +02:00
Robin Mueller	78b09ed0c9	fixes includes	2022-07-18 11:58:55 +02:00
Robin Mueller	fdf35232ee	some fixes	2022-07-18 11:47:00 +02:00
Robin Mueller	8465670374	separate unittest folder	2022-07-18 11:42:51 +02:00
Robin Mueller	3b23fb77b4	add obsolete add_subdirectory calls	2022-07-18 09:01:45 +02:00
Robin Mueller	6f7be281ef	move HAL and tests folder	2022-07-18 08:59:40 +02:00
Robin Müller	ec8e5cc123	Merge branch 'development' into meier/upstream-pus-distributor-bugfix	2022-07-15 10:16:35 +02:00
Jakob Meier	3686bbc486	Merge pull request 'DHB Reply Timeout' (#637 ) from meier/dhbReplyTimeout into development Reviewed-on: fsfw/fsfw#637	2022-07-14 09:17:18 +02:00
Jakob Meier	ecac08814e	better naming for functions which reset states of replies	2022-07-14 09:15:13 +02:00
Jakob Meier	e8b8fff0b5	Merge branch 'development' into meier/dhbReplyTimeout	2022-07-14 09:01:28 +02:00
Jakob Meier	4d34f93cfc	missing reset of timedOut value in loop of decrementDeviceReplyMap	2022-07-14 08:58:23 +02:00
Ulrich Mohr	adbf375f38	some small fixes to dhb countdown addition	2022-07-13 21:58:07 +02:00
Ulrich Mohr	2e42f53682	Merge pull request 'New PoolEntry constructor' (#651 ) from eive/fsfw:mueller/new-pool-entry-ctor into development Reviewed-on: fsfw/fsfw#651	2022-07-13 17:43:56 +02:00
Ulrich Mohr	c519b70302	Merge pull request 'printout tweak' (#652 ) from mueller/printout-tweak-mq-linux-osal into development Reviewed-on: fsfw/fsfw#652	2022-07-13 17:35:53 +02:00
Ulrich Mohr	45ee307bc4	Merge pull request 'remove duplicate CHANGELOG entries' (#649 ) from eive/fsfw:mueller/clean-changelog into development Reviewed-on: fsfw/fsfw#649	2022-07-13 16:50:50 +02:00
Ulrich Mohr	8a2068aca6	Merge pull request 'clang-tidy changes for controller module' (#648 ) from clang-tidy-controllers into development Reviewed-on: fsfw/fsfw#648	2022-07-13 16:49:15 +02:00
Ulrich Mohr	aa60484111	Merge pull request 'clang-tidy changes for actions module' (#647 ) from clang-tidy-actions into development Reviewed-on: fsfw/fsfw#647	2022-07-13 16:42:39 +02:00
Ulrich Mohr	e99c7f3824	Merge pull request 'Install ETL library in CI/CD' (#645 ) from mueller/install-etl-cicd into development Reviewed-on: fsfw/fsfw#645	2022-07-13 16:39:29 +02:00
Ulrich Mohr	2ee3ef1f1d	Merge branch 'development' into mueller/install-etl-cicd	2022-07-13 16:38:30 +02:00
Robin Müller	ce48827ee5	Merge branch 'development' into clang-tidy-actions	2022-07-13 16:00:50 +02:00
Robin Müller	0d80fad685	Merge branch 'development' into clang-tidy-controllers	2022-07-13 16:00:42 +02:00
Robin Müller	c6253bf0dd	Merge branch 'development' into mueller/new-pool-entry-ctor	2022-07-13 15:41:47 +02:00
Ulrich Mohr	93933dee02	Merge pull request 'delete run configs' (#646 ) from mueller/del-cmake-run-cfgs into development Reviewed-on: fsfw/fsfw#646	2022-07-13 15:37:55 +02:00
Robin Mueller	0e49640306	update CHANGELOG	2022-07-08 17:59:43 +02:00
Robin Mueller	32fea9838e	add new pool entry constructor - This constructor allows to simply specify the length. This is also the new default constructor for scalar values which are initially invalid	2022-07-08 17:56:44 +02:00
Robin Mueller	0519083894	remove duplicate entries	2022-07-08 17:48:06 +02:00
Robin Mueller	14bac9a418	clang-tidy changes for controller module	2022-07-04 11:48:36 +02:00
Robin Mueller	3bef73708f	clang-tidy changes for actions module	2022-07-04 11:44:26 +02:00
Robin Mueller	fef6ddceff	delete run configs	2022-07-04 11:16:13 +02:00
Robin Mueller	5a9db72814	test public linkage	2022-07-04 10:27:14 +02:00
Robin Mueller	5cccd5caba	bump used container	2022-07-04 10:21:47 +02:00
Robin Mueller	7de56f189b	install etl library in ci/cd	2022-07-04 10:13:48 +02:00
Jakob Meier	df97bbc691	run auto-formatter	2022-06-23 11:56:46 +02:00
Jakob Meier	2d2f65bf89	moved activation of periodic replies to updatePeriodicReply	2022-06-23 11:54:51 +02:00
Jakob Meier	298f764298	return value of setStoreSddress	2022-06-22 19:11:51 +02:00
Jakob Meier	2e76250209	faulty handling of size check in pus distributor	2022-06-22 18:19:06 +02:00
Robin Müller	3e9ae62b28	Merge branch 'development' into meier/dhbReplyTimeout	2022-06-21 10:49:06 +02:00
Jakob Meier	21eb386f3c	changed reply timeouts	2022-06-06 12:34:57 +02:00
Jakob Meier	ade36e65c6	missed reply check in simple command nominal test case	2022-06-06 12:30:27 +02:00
Jakob Meier	103661facc	deugging	2022-06-06 12:26:00 +02:00
Jakob Meier	ae2f7219fd	run auto-formatter	2022-06-06 11:55:42 +02:00
Jakob Meier	4fba2704aa	unit test for detection of missed reply when commanded externally	2022-06-06 10:53:08 +02:00
Jakob Meier	161dbde0d7	fixed merge conflicts	2022-06-06 10:30:17 +02:00
Jakob Meier	2fa4fd61d0	device fdir mock	2022-06-05 12:54:13 +02:00
Jakob Meier	bf673c56c6	unit test for dhb	2022-06-05 12:52:55 +02:00
Jakob Meier	1611a4e1f0	device handler unittest wip	2022-05-16 11:10:35 +02:00
Jakob Meier	7afe30ea88	fixed merge conflict	2022-05-09 12:56:22 +02:00
Jakob Meier	0aee86442e	typo in readme	2022-04-26 11:48:18 +02:00
Jakob Meier	951c077abc	option to use Countdown object to time out replies	2022-04-26 10:03:04 +02:00
Robin Mueller	adfefdd93f	printout tweak	2022-04-11 14:19:01 +02:00