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

Reviewed-on: fsfw/fsfw#653

.gitignore

@@ -1,6 +1,14 @@
+# PyCharm and CLion
+/.idea/*
+!/.idea/runConfigurations
+!/.idea/cmake.xml
+!/.idea/codeStyles
+
+# Eclipse
 .cproject
 .project
 .settings
 .metadata
 
 /build*
+/cmake-build*

.idea/codeStyles/Project.xml

@@ -0,0 +1,14 @@
+<component name="ProjectCodeStyleConfiguration">
+  <code_scheme name="Project" version="173">
+    <clangFormatSettings>
+      <option name="ENABLED" value="true" />
+    </clangFormatSettings>
+    <codeStyleSettings language="CMake">
+      <indentOptions>
+        <option name="INDENT_SIZE" value="2" />
+        <option name="CONTINUATION_INDENT_SIZE" value="0" />
+        <option name="TAB_SIZE" value="2" />
+      </indentOptions>
+    </codeStyleSettings>
+  </code_scheme>
+</component>

.idea/codeStyles/codeStyleConfig.xml

@@ -0,0 +1,5 @@
+<component name="ProjectCodeStyleConfiguration">
+  <state>
+    <option name="USE_PER_PROJECT_SETTINGS" value="true" />
+  </state>
+</component>

CHANGELOG.md

@@ -12,15 +12,13 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Changes
 
+- Renamed auto-formatting script to `auto-formatter.sh` and made it more robust.
+  If `cmake-format` is installed, it will also auto-format the `CMakeLists.txt` files now.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/625
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/626
 - Bump C++ required version to C++17. Every project which uses the FSFW and every modern
   compiler supports it
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/622
-- HAL Linux SPI: Set the Clock Default State when setting new SPI speed
-  and mode
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/573
-- GPIO HAL: `Direction`, `GpioOperation` and `Levels` are enum classes now, which prevents
-  name clashes with Windows defines.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/572
 - New CMake option `FSFW_HAL_LINUX_ADD_LIBGPIOD` to specifically exclude `gpiod` code.
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/572
 - HAL Devicehandlers: Periodic printout is run-time configurable now
@@ -42,6 +40,41 @@ 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
+
+PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/636
+
+**Refactoring general task code**
+
+- There was a lot of duplicate/boilerplate code inside the individual task IF OSAL implementations.
+  Remove it by introducing base classes `PeriodicTaskBase` and `FixedTimeslotTaskBase`.
+
+**Refactor PeriodicTaskIF**
+
+- Convert `virtual ReturnValue_t addComponent(object_id_t object)` to
+  `virtual ReturnValue_t addComponent(object_id_t object, uint8_t opCode = 0)`, allowing to pass
+  the operation code passed to `performOperation`. Updated API taking
+  an `ExecutableObjectIF` accordingly
+
+**Refactor FixedTimeslotTaskIF**
+
+- Add additional `addSlot` function which takes an `ExecutableObjectIF` pointer and its Object ID
+
+**Refactor FixedSequenceSlot**
+
+- Introduce typedef `CustomCheckFunc` for `ReturnValue_t (*customCheckFunction)(const SlotList&)`.
+- Convert `ReturnValue_t (*customCheckFunction)(const SlotList&)` to
+  `ReturnValue_t (*customCheckFunction)(const SlotList&, void*)`, allowing arbitrary user arguments
+  for the custom checker
+
+**Linux Task Module**
+
+- Use composition instead of inheritance for the `PeriodicPosixTask` and make the `PosixTask` a
+  member of the class
 
 ### HAL
 
@@ -84,6 +117,13 @@ 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
+- Basic `clion` support: Update `.gitignore` and add some basic run configurations
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/625
 - LTO support: Allow using LTO/IPO by setting `FSFW_ENABLE_LTO=1`. CMake is able to detect whether
   the user compiler supports IPO/LPO. LTO is on by default now. Most modern compilers support it,
   can make good use of it and it usually makes the code faster and/or smaller.
@@ -98,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
@@ -112,17 +153,6 @@ https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
 - `Subsystem`: New API to add table and sequence entries
 
-## HAL
-
-- SPI: Cache the SPI device in the communication interface. Architecturally, this makes a
-  lot more sense because each ComIF should be responsible for one SPI bus.
-- SPI: Move the empty transfer to update the line polarity to separate function. This means
-  it is not automatically called when calling the setter function for SPI speed and mode.
-  The user should call this function after locking the CS mutex if multiple SPI devices with
-  differing speeds and modes are attached to one bus.
-- SPI: Getter functions for SPI speed and mode.
-- I2C: Add wiretapping option for I2C. Enabled with `FSFW_HAL_I2C_WIRETAPPING` defined to 1.
-
 ## Fixed
 
 - TCP TMTC Server: `MutexGuard` was not created properly in

CMakeLists.txt

@@ -67,11 +67,12 @@ 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")
 set(FSFW_ETL_LIB_VERSION
-    ${FSFW_ETL_LIB_MAJOR_VERSION}.27.3
+    ${FSFW_ETL_LIB_MAJOR_VERSION}.28.0
     CACHE STRING "ETL library exact version requirement")
 set(FSFW_ETL_LINK_TARGET etl::etl)
 
@@ -103,10 +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()
 
@@ -138,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"
@@ -161,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)
+  set(FSFW_CONFIG_PATH unittests/testcfg)
-  configure_file(tests/src/fsfw_tests/unit/testcfg/FSFWConfig.h.in FSFWConfig.h)
+  configure_file(unittests/testcfg/FSFWConfig.h.in FSFWConfig.h)
-  configure_file(tests/src/fsfw_tests/unit/testcfg/TestsConfig.h.in
+  configure_file(unittests/testcfg/TestsConfig.h.in tests/TestsConfig.h)
-                 tests/TestsConfig.h)
 
   project(${FSFW_TEST_TGT} CXX C)
   add_executable(${FSFW_TEST_TGT})
@@ -182,15 +183,15 @@ 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} CONFIG QUIET)
+find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} QUIET)
 # Not installed, so use FetchContent to download and provide etl
 if(NOT ${FSFW_ETL_LIB_NAME}_FOUND)
   message(
     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)
 
@@ -280,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)
@@ -446,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}
+target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${FSFW_ADDITIONAL_LINK_LIBS})
-                                               ${FSFW_ADDITIONAL_LINK_LIBS})
+target_link_libraries(${LIB_FSFW_NAME} PUBLIC ${FSFW_ETL_LINK_TARGET})
 
 string(
   CONCAT

README.md

@@ -99,7 +99,7 @@ add and link against the FSFW library in general.
 
 4. Link against the FSFW library
 
-   ```cmake
+   ```sh
    target_link_libraries(${YourProjectName} PRIVATE fsfw)
    ```
 
@@ -131,7 +131,7 @@ default. This can be disabled by setting the `FSFW_TESTS_COV_GEN` option to `OFF
 You can use the following commands inside the `fsfw` folder to set up the build system
 
 ```sh
-mkdir build-Unittest && cd build-Unittest
+mkdir build-tests && cd build-tests
 cmake -DFSFW_BUILD_UNITTESTS=ON -DFSFW_OSAL=host -DCMAKE_BUILD_TYPE=Debug ..
 ```
 
@@ -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
 

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/

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 ..'
+                    sh 'cmake -DFSFW_OSAL=host -DFSFW_BUILD_TESTS=ON -DFSFW_CICD_BUILD=ON ..'
                 }
             }
         }

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

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)

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_ */

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

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
+  find ./src ${file_selectors} | xargs ${cpp_format} --style=file -i
-    echo "Auto-formatting ${dir} recursively"
+  find ./hal ${file_selectors} | xargs ${cpp_format} --style=file -i
-    find ${dir} ${file_selectors} | xargs clang-format --style=file -i
+  find ./tests ${file_selectors} | xargs ${cpp_format} --style=file -i
-  done
 else
   echo "No ${cpp_format} tool found, not formatting C++/C files"
 fi

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("..")
 
 

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)

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

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
  *

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 =
+      auto* ipcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
-          ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
+      if (ipcStore != nullptr) {
-      if (ipcStore != NULL) {
         ipcStore->deleteData(getStoreId(message));
       }
       break;

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);
+  auto *receiver = ObjectManager::instance()->get<HasActionsIF>(commandTo);
-  if (receiver == NULL) {
+  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) {
+  auto *receiver = ObjectManager::instance()->get<HasActionsIF>(commandTo);
-  //        return CommandsFunctionsIF::ALREADY_COMMANDING;
+  if (receiver == nullptr) {
-  //    }
-  HasActionsIF *receiver = ObjectManager::instance()->get<HasActionsIF>(commandTo);
-  if (receiver == NULL) {
     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) {

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,
+  ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId, const uint8_t* data,
-                              const uint8_t* data = nullptr, uint32_t size = 0);
+                              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;

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:

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

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

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);
+                        store_address_t dataAddress) override;
-  virtual void resetHelper();
+  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_ */

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);
-  requestQueue = QueueFactory::instance()->createMessageQueue(
-      CFDP_HANDLER_MAX_RECEPTION, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
   distributor = dist;
 }
 

src/fsfw/controller/ControllerBase.cpp

@@ -13,9 +13,7 @@ ControllerBase::ControllerBase(object_id_t setObjectId, object_id_t parentId,
       submode(SUBMODE_NONE),
       modeHelper(this),
       healthHelper(this, setObjectId) {
-  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
+  commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth);
-  commandQueue = QueueFactory::instance()->createMessageQueue(
-      commandQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
 
 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;
+  mode = mode_;
-  this->submode = submode;
+  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) {
+void ControllerBase::getMode(Mode_t* mode_, Submode_t* submode_) {
-  *mode = this->mode;
+  *mode_ = this->mode;
-  *submode = this->submode;
+  *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; }

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;
+  ReturnValue_t setHealth(HealthState health) override;
-  virtual HasHealthIF::HealthState getHealth() override;
+  HasHealthIF::HealthState getHealth() override;
 
   /** ExecutableObjectIF overrides */
-  virtual ReturnValue_t performOperation(uint8_t opCode) override;
+  ReturnValue_t performOperation(uint8_t opCode) override;
-  virtual void setTaskIF(PeriodicTaskIF *task) override;
+  void setTaskIF(PeriodicTaskIF *task) override;
-  virtual ReturnValue_t initializeAfterTaskCreation() 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,
+  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-                                         uint32_t *msToReachTheMode) override = 0;
+                                 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;
+  void startTransition(Mode_t mode, Submode_t submode) override;
-  virtual void getMode(Mode_t *mode, Submode_t *submode) override;
+  void getMode(Mode_t *mode, Submode_t *submode) override;
-  virtual void setToExternalControl() override;
+  void setToExternalControl() override;
-  virtual void announceMode(bool recursive);
+  void announceMode(bool recursive) override;
   /** HK helpers */
   virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
 };

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

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;
+  ReturnValue_t performOperation(uint8_t opCode) override;
-  virtual ReturnValue_t initializeAfterTaskCreation() 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,
+  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                                      const uint8_t* data, size_t size) override;
+                              const uint8_t* data, size_t size) override;
 
   /* HasLocalDatapoolIF overrides */
-  virtual LocalDataPoolManager* getHkManagerHandle() override;
+  LocalDataPoolManager* getHkManagerHandle() override;
-  virtual object_id_t getObjectId() const override;
+  [[nodiscard]] object_id_t getObjectId() const override;
-  virtual uint32_t getPeriodicOperationFrequency() const override;
+  [[nodiscard]] uint32_t getPeriodicOperationFrequency() const override;
 
-  virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
-                                                LocalDataPoolManager& poolManager) override = 0;
+                                        LocalDataPoolManager& poolManager) override = 0;
-  virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override = 0;
+  LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override = 0;
 
   // Mode abstract functions
-  virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-                                         uint32_t* msToReachTheMode) override = 0;
+                                 uint32_t* msToReachTheMode) override = 0;
 };
 
 #endif /* FSFW_CONTROLLER_EXTENDEDCONTROLLERBASE_H_ */

src/fsfw/datapoollocal/LocalDataPoolManager.cpp

@@ -577,9 +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);
@@ -699,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
@@ -837,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";

src/fsfw/datapoollocal/LocalPoolDataSetBase.h

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

src/fsfw/devicehandlers/AssemblyBase.cpp

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

src/fsfw/devicehandlers/AssemblyBase.h

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

src/fsfw/devicehandlers/DeviceHandlerBase.cpp

@@ -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) {
+        resetDelayCyclesControlledReply(&replyPair.second);
-          replyPair.second.delayCycles = replyPair.second.maxDelayCycles;
-        }
         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,30 +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;
-    }
-  }
-}

src/fsfw/devicehandlers/DeviceHandlerBase.h

@@ -103,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);
 
   /**
@@ -467,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).
+   * 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
+   * Please note that periodic replies are disabled by default. You can enable them with
-   *    #updatePeriodicReply
+   * #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
+   *                  to provide a pointer to a Countdown object which will signal the timeout
-   *    when expired
+   *                  when expired
    * @return	- @c RETURN_OK when the command was successfully inserted,
    *          - @c RETURN_FAILED else.
    */
@@ -659,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;
 
@@ -783,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.
+    //! The currently remaining cycles the handler should wait for a reply,
-    //! For non-periodic replies without a command, this variable is unused.
+    //! 0 means there is no reply expected
-    //! A runtime value of 0 means there is no reply is currently expected.
     uint16_t delayCycles;
     size_t replyLen = 0;  //!< Expected size of the reply.
     //! if this is !=0, the delayCycles will not be reset to 0 but to
@@ -850,7 +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;
@@ -1274,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.
@@ -1325,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_ */

src/fsfw/devicehandlers/DeviceHandlerFailureIsolation.cpp

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

src/fsfw/devicehandlers/DeviceHandlerIF.h

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

src/fsfw/devicehandlers/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);
-  commandQueue = QueueFactory::instance()->createMessageQueue(
-      3, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
 
 HealthDevice::~HealthDevice() { QueueFactory::instance()->deleteMessageQueue(commandQueue); }

src/fsfw/events/EventManager.cpp

@@ -18,9 +18,8 @@ const LocalPool::LocalPoolConfig EventManager::poolConfig = {
 EventManager::EventManager(object_id_t setObjectId)
     : SystemObject(setObjectId), factoryBackend(0, poolConfig, false, true) {
   mutex = MutexFactory::instance()->createMutex();
-  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
+  eventReportQueue = QueueFactory::instance()->createMessageQueue(MAX_EVENTS_PER_CYCLE,
-  eventReportQueue = QueueFactory::instance()->createMessageQueue(
+                                                                  EventMessage::EVENT_MESSAGE_SIZE);
-      MAX_EVENTS_PER_CYCLE, EventMessage::EVENT_MESSAGE_SIZE, &mqArgs);
 }
 
 EventManager::~EventManager() {
@@ -47,20 +46,9 @@ ReturnValue_t EventManager::performOperation(uint8_t opCode) {
 
 void EventManager::notifyListeners(EventMessage* message) {
   lockMutex();
-  for (auto& listener : listenerList) {
+  for (auto iter = listenerList.begin(); iter != listenerList.end(); ++iter) {
-    if (listener.second.match(message)) {
+    if (iter->second.match(message)) {
-      ReturnValue_t result =
+      MessageQueueSenderIF::sendMessage(iter->first, message, message->getSender());
-          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
-      }
     }
   }
   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 */

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;

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,

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 =
-  eventQueue = QueueFactory::instance()->createMessageQueue(
+      QueueFactory::instance()->createMessageQueue(messageDepth, EventMessage::EVENT_MESSAGE_SIZE);
-      messageDepth, EventMessage::EVENT_MESSAGE_SIZE, &mqArgs);
 }
 
 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 "
+      sif::error << "FailureIsolationBase::intialize: Parent object"
-                 << "invalid" << std::endl;
+                 << "invalid." << std::endl;
-      sif::error << "Make sure it implements ConfirmsFailuresIF" << std::endl;
+#endif
-#else
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::printError("FailureIsolationBase::intialize: Parent object invalid\n");
+      sif::error << "Make sure it implements ConfirmsFailuresIF." << std::endl;
-      sif::printError("Make sure it implements ConfirmsFailuresIF\n");
 #endif
       return ObjectManagerIF::CHILD_INIT_FAILED;
       return RETURN_FAILED;

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 =
-  static const Event FDIR_CHANGED_STATE = MAKE_EVENT(1, severity::INFO);
+      MAKE_EVENT(1, severity::INFO);  //!< FDIR has an internal state, which changed from par2
-  //! FDIR tries to restart device. Par1: event that caused recovery.
+                                      //!< (oldState) to par1 (newState).
-  static const Event FDIR_STARTS_RECOVERY = MAKE_EVENT(2, severity::MEDIUM);
+  static const Event FDIR_STARTS_RECOVERY = MAKE_EVENT(
-  //! FDIR turns off device. Par1: event that caused recovery.
+      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);
+  static const Event FDIR_TURNS_OFF_DEVICE = MAKE_EVENT(
+      3, severity::MEDIUM);  //!< FDIR turns off device. Par1: event that caused recovery.
 
   FailureIsolationBase(object_id_t owner, object_id_t parent = objects::NO_OBJECT,
                        uint8_t messageDepth = 10, uint8_t parameterDomainBase = 0xF0);

src/fsfw/fdir/FaultCounter.cpp

@@ -60,14 +60,14 @@ ReturnValue_t FaultCounter::getParameter(uint8_t domainId, uint8_t uniqueId,
     return INVALID_DOMAIN_ID;
   }
 
-  switch (uniqueId) {
+  switch (static_cast<ParameterIds>(uniqueId)) {
-    case 0:
+    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:

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

src/fsfw/globalfunctions/CMakeLists.txt

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

src/fsfw/globalfunctions/DleParser.cpp

@@ -1,230 +0,0 @@
-#include "DleParser.h"
-
-#include <fsfw/serviceinterface/ServiceInterface.h>
-
-#include <cstdio>
-
-DleParser::DleParser(SimpleRingBuffer& decodeRingBuf, DleEncoder& decoder, BufPair encodedBuf,
-                     BufPair decodedBuf, UserHandler handler, void* args)
-    : decodeRingBuf(decodeRingBuf),
-      decoder(decoder),
-      encodedBuf(encodedBuf),
-      decodedBuf(decodedBuf),
-      handler(handler),
-      ctx(args) {
-  if (handler == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "DleParser::DleParser: Invalid user handler" << std::endl;
-#else
-    sif::printError("DleParser::DleParser: Invalid user handler\n");
-#endif
-  }
-}
-
-ReturnValue_t DleParser::passData(uint8_t* data, size_t len) {
-  if (data == nullptr or len == 0 or handler == nullptr) {
-    return 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();
-}

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

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 =
+  static const ReturnValue_t OBJECT_NOT_HEALTHY = MAKE_RETURN_CODE(1);
-      HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 1);
+  static const ReturnValue_t INVALID_HEALTH_STATE = MAKE_RETURN_CODE(2);
-  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 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 =
-  static const Event OVERWRITING_HEALTH = MAKE_EVENT(9, severity::LOW);
+      MAKE_EVENT(9, severity::LOW);  //!< Assembly overwrites health information of children to keep
-  //! Someone starts a recovery of a component (typically power-cycle). No parameters.
+                                     //!< satellite alive.
-  static const Event TRYING_RECOVERY = MAKE_EVENT(10, severity::MEDIUM);
+  static const Event TRYING_RECOVERY =
-  //! Recovery is ongoing. Comes twice during recovery.
+      MAKE_EVENT(10, severity::MEDIUM);  //!< Someone starts a recovery of a component (typically
-  //! P1: 0 for the first, 1 for the second event. P2: 0
+                                         //!< power-cycle). No parameters.
-  static const Event RECOVERY_STEP = MAKE_EVENT(11, severity::MEDIUM);
+  static const Event RECOVERY_STEP =
-  //! Recovery was completed. Not necessarily successful. No parameters.
+      MAKE_EVENT(11, severity::MEDIUM);  //!< Recovery is ongoing. Comes twice during recovery. P1:
-  static const Event RECOVERY_DONE = MAKE_EVENT(12, severity::MEDIUM);
+                                         //!< 0 for the first, 1 for the second event. P2: 0
+  static const Event RECOVERY_DONE = MAKE_EVENT(
+      12,
+      severity::MEDIUM);  //!< Recovery was completed. Not necessarily successful. No parameters.
+
   virtual ~HasHealthIF() {}
 
   virtual MessageQueueId_t getCommandQueue() const = 0;

src/fsfw/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()) {

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

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;
 

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;
 

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 << " | "
+                 << "occured!" << std::endl;
-                 << newStoreHits << 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(
+      sif::printDebug("InternalErrorReporter::performOperation: Errors occured!\n");
-          "InternalErrorReporter::performOperation: Errors occured: Queue | TM | Store: %lu | %lu "
+      sif::printDebug("Queue errors: %lu\n", static_cast<unsigned int>(newQueueHits));
-          "| %lu\n",
+      sif::printDebug("TM errors: %lu\n", static_cast<unsigned int>(newTmHits));
-          static_cast<unsigned int>(newQueueHits), static_cast<unsigned int>(newTmHits),
+      sif::printDebug("Store errors: %lu\n", static_cast<unsigned int>(newStoreHits));
-          static_cast<unsigned int>(newStoreHits));
 #endif
     }
   }

src/fsfw/ipc/CommandMessageIF.h

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

src/fsfw/modes/HasModesIF.h

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

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::setfill('0') << var
-                 << std::dec << std::setfill(' ') << std::endl;
+                 << " failed to "
-#else
+                    "initialize with code 0x"
-      sif::printError(
+                 << result << std::dec << std::setfill(' ') << std::endl;
-          "ObjectManager::initialize: Object 0x%08x failed to initialize with code 0x%04x\n", var,
-          it.first);
-#endif
 #endif
       errorCount++;
     }

src/fsfw/osal/CMakeLists.txt

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

src/fsfw/osal/freertos/FixedTimeslotTask.cpp

@@ -1,27 +1,23 @@
 #include "fsfw/osal/freertos/FixedTimeslotTask.h"
 
-#include "fsfw/objectmanager/ObjectManager.h"
+#include "fsfw/serviceinterface.h"
-#include "fsfw/serviceinterface/ServiceInterface.h"
 
-uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
 const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = configMINIMAL_STACK_SIZE;
 
 FixedTimeslotTask::FixedTimeslotTask(TaskName name, TaskPriority setPriority,
-                                     TaskStackSize setStack, TaskPeriod overallPeriod,
+                                     TaskStackSize setStack, TaskPeriod period,
-                                     void (*setDeadlineMissedFunc)())
+                                     TaskDeadlineMissedFunction dlmFunc_)
-    : started(false), handle(nullptr), pst(overallPeriod * 1000) {
+    : FixedTimeslotTaskBase(period, dlmFunc_), started(false), handle(nullptr) {
   configSTACK_DEPTH_TYPE stackSize = setStack / sizeof(configSTACK_DEPTH_TYPE);
   xTaskCreate(taskEntryPoint, name, stackSize, this, setPriority, &handle);
-  // All additional attributes are applied to the object.
-  this->deadlineMissedFunc = setDeadlineMissedFunc;
 }
 
-FixedTimeslotTask::~FixedTimeslotTask() {}
+FixedTimeslotTask::~FixedTimeslotTask() = default;
 
 void FixedTimeslotTask::taskEntryPoint(void* argument) {
   // The argument is re-interpreted as FixedTimeslotTask. The Task object is
   // global, so it is found from any place.
-  FixedTimeslotTask* originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
+  auto* originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
   /* Task should not start until explicitly requested,
    * but in FreeRTOS, tasks start as soon as they are created if the scheduler
    * is running but not if the scheduler is not running.
@@ -32,26 +28,18 @@ void FixedTimeslotTask::taskEntryPoint(void* argument) {
    * can continue */
 
   if (not originalTask->started) {
-    vTaskSuspend(NULL);
+    vTaskSuspend(nullptr);
   }
 
   originalTask->taskFunctionality();
 #if FSFW_CPP_OSTREAM_ENABLED == 1
   sif::debug << "Polling task " << originalTask->handle << " returned from taskFunctionality."
              << std::endl;
+#else
+  sif::printDebug("Polling task returned from taskFunctionality\n");
 #endif
 }
 
-void FixedTimeslotTask::missedDeadlineCounter() {
-  FixedTimeslotTask::deadlineMissedCount++;
-  if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "PST missed " << FixedTimeslotTask::deadlineMissedCount << " deadlines"
-                 << std::endl;
-#endif
-  }
-}
-
 ReturnValue_t FixedTimeslotTask::startTask() {
   started = true;
 
@@ -63,31 +51,12 @@ ReturnValue_t FixedTimeslotTask::startTask() {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId, uint32_t slotTimeMs,
+[[noreturn]] void FixedTimeslotTask::taskFunctionality() {
-                                         int8_t executionStep) {
-  ExecutableObjectIF* handler = ObjectManager::instance()->get<ExecutableObjectIF>(componentId);
-  if (handler != nullptr) {
-    pst.addSlot(componentId, slotTimeMs, executionStep, handler, this);
-    return HasReturnvaluesIF::RETURN_OK;
-  }
-
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::error << "Component " << std::hex << componentId << " not found, not adding it to pst"
-             << std::endl;
-#endif
-  return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-uint32_t FixedTimeslotTask::getPeriodMs() const { return pst.getLengthMs(); }
-
-ReturnValue_t FixedTimeslotTask::checkSequence() const { return pst.checkSequence(); }
-
-void FixedTimeslotTask::taskFunctionality() {
   // A local iterator for the Polling Sequence Table is created to find the
   // start time for the first entry.
-  auto slotListIter = pst.current;
+  auto slotListIter = pollingSeqTable.current;
 
-  pst.intializeSequenceAfterTaskCreation();
+  pollingSeqTable.intializeSequenceAfterTaskCreation();
 
   // The start time for the first entry is read.
   uint32_t intervalMs = slotListIter->pollingTimeMs;
@@ -108,10 +77,10 @@ void FixedTimeslotTask::taskFunctionality() {
   /* Enter the loop that defines the task behavior. */
   for (;;) {
     // The component for this slot is executed and the next one is chosen.
-    this->pst.executeAndAdvance();
+    this->pollingSeqTable.executeAndAdvance();
-    if (not pst.slotFollowsImmediately()) {
+    if (not pollingSeqTable.slotFollowsImmediately()) {
       // Get the interval till execution of the next slot.
-      intervalMs = this->pst.getIntervalToPreviousSlotMs();
+      intervalMs = this->pollingSeqTable.getIntervalToPreviousSlotMs();
       interval = pdMS_TO_TICKS(intervalMs);
 
 #if (tskKERNEL_VERSION_MAJOR == 10 && tskKERNEL_VERSION_MINOR >= 4) || tskKERNEL_VERSION_MAJOR > 10
@@ -132,8 +101,8 @@ void FixedTimeslotTask::taskFunctionality() {
 }
 
 void FixedTimeslotTask::handleMissedDeadline() {
-  if (deadlineMissedFunc != nullptr) {
+  if (dlmFunc != nullptr) {
-    this->deadlineMissedFunc();
+    dlmFunc();
   }
 }
 

src/fsfw/osal/freertos/FixedTimeslotTask.h

@@ -4,11 +4,11 @@
 #include "FreeRTOS.h"
 #include "FreeRTOSTaskIF.h"
 #include "fsfw/tasks/FixedSlotSequence.h"
-#include "fsfw/tasks/FixedTimeslotTaskIF.h"
+#include "fsfw/tasks/FixedTimeslotTaskBase.h"
-#include "fsfw/tasks/Typedef.h"
+#include "fsfw/tasks/definitions.h"
 #include "task.h"
 
-class FixedTimeslotTask : public FixedTimeslotTaskIF, public FreeRTOSTaskIF {
+class FixedTimeslotTask : public FixedTimeslotTaskBase, public FreeRTOSTaskIF {
  public:
   /**
    * Keep in mind that you need to call before vTaskStartScheduler()!
@@ -23,7 +23,7 @@ class FixedTimeslotTask : public FixedTimeslotTaskIF, public FreeRTOSTaskIF {
    * @return Pointer to the newly created task.
    */
   FixedTimeslotTask(TaskName name, TaskPriority setPriority, TaskStackSize setStack,
-                    TaskPeriod overallPeriod, void (*setDeadlineMissedFunc)());
+                    TaskPeriod overallPeriod, TaskDeadlineMissedFunction dlmFunc);
 
   /**
    * @brief	The destructor of the class.
@@ -32,26 +32,9 @@ class FixedTimeslotTask : public FixedTimeslotTaskIF, public FreeRTOSTaskIF {
    * initialization for the PST and the device handlers. This is done by
    * calling the PST's destructor.
    */
-  virtual ~FixedTimeslotTask(void);
+  ~FixedTimeslotTask() override;
 
-  ReturnValue_t startTask(void);
+  ReturnValue_t startTask() override;
-  /**
-   * This static function can be used as #deadlineMissedFunc.
-   * It counts missedDeadlines and prints the number of missed deadlines
-   * every 10th time.
-   */
-  static void missedDeadlineCounter();
-  /**
-   * A helper variable to count missed deadlines.
-   */
-  static uint32_t deadlineMissedCount;
-
-  ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
-                        int8_t executionStep) override;
-
-  uint32_t getPeriodMs() const override;
-
-  ReturnValue_t checkSequence() const override;
 
   ReturnValue_t sleepFor(uint32_t ms) override;
 
@@ -61,17 +44,6 @@ class FixedTimeslotTask : public FixedTimeslotTaskIF, public FreeRTOSTaskIF {
   bool started;
   TaskHandle_t handle;
 
-  FixedSlotSequence pst;
-
-  /**
-   * @brief	This attribute holds a function pointer that is executed when
-   *          a deadline was missed.
-   * @details
-   * Another function may be announced to determine the actions to perform
-   * when a deadline was missed. Currently, only one function for missing
-   * any deadline is allowed. If not used, it shall be declared NULL.
-   */
-  void (*deadlineMissedFunc)(void);
   /**
    * @brief	This is the entry point for a new task.
    * @details
@@ -88,7 +60,7 @@ class FixedTimeslotTask : public FixedTimeslotTaskIF, public FreeRTOSTaskIF {
    * It links the functionalities provided by FixedSlotSequence with the
    * OS's System Calls to keep the timing of the periods.
    */
-  void taskFunctionality(void);
+  [[noreturn]] void taskFunctionality();
 
   void handleMissedDeadline();
 };

src/fsfw/osal/freertos/FreeRTOSTaskIF.h

@@ -6,11 +6,11 @@
 
 class FreeRTOSTaskIF {
  public:
-  virtual ~FreeRTOSTaskIF() {}
+  virtual ~FreeRTOSTaskIF() = default;
   virtual TaskHandle_t getTaskHandle() = 0;
 
  protected:
-  bool checkMissedDeadline(const TickType_t xLastWakeTime, const TickType_t interval) {
+  static bool checkMissedDeadline(const TickType_t xLastWakeTime, const TickType_t interval) {
     /* Check whether deadline was missed while also taking overflows
      * into account. Drawing this on paper with a timeline helps to understand
      * it. */

src/fsfw/osal/freertos/PeriodicTask.cpp

@@ -5,27 +5,28 @@
 #include "fsfw/tasks/ExecutableObjectIF.h"
 
 PeriodicTask::PeriodicTask(const char* name, TaskPriority setPriority, TaskStackSize setStack,
-                           TaskPeriod setPeriod, TaskDeadlineMissedFunction deadlineMissedFunc)
+                           TaskPeriod setPeriod, TaskDeadlineMissedFunction dlmFunc_)
-    : started(false), handle(NULL), period(setPeriod), deadlineMissedFunc(deadlineMissedFunc) {
+    : PeriodicTaskBase(setPeriod, dlmFunc_), started(false), handle(nullptr) {
   configSTACK_DEPTH_TYPE stackSize = setStack / sizeof(configSTACK_DEPTH_TYPE);
   BaseType_t status = xTaskCreate(taskEntryPoint, name, stackSize, this, setPriority, &handle);
   if (status != pdPASS) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::debug << "PeriodicTask Insufficient heap memory remaining. "
+    sif::debug << "PeriodicTask::PeriodicTask Insufficient heap memory remaining. Status: "
-                  "Status: "
                << status << std::endl;
+#else
+    sif::printDebug("PeriodicTask::PeriodicTask: Insufficient heap memory remaining. Status: %d\n",
+                    status);
 #endif
   }
 }
 
-PeriodicTask::~PeriodicTask(void) {
+// Do not delete objects, we were responsible for ptrs only.
-  // Do not delete objects, we were responsible for ptrs only.
+PeriodicTask::~PeriodicTask() = default;
-}
 
 void PeriodicTask::taskEntryPoint(void* argument) {
   // The argument is re-interpreted as PeriodicTask. The Task object is
   // global, so it is found from any place.
-  PeriodicTask* originalTask(reinterpret_cast<PeriodicTask*>(argument));
+  auto* originalTask(reinterpret_cast<PeriodicTask*>(argument));
   /* Task should not start until explicitly requested,
    * but in FreeRTOS, tasks start as soon as they are created if the scheduler
    * is running but not if the scheduler is not running.
@@ -36,7 +37,7 @@ void PeriodicTask::taskEntryPoint(void* argument) {
    * can continue */
 
   if (not originalTask->started) {
-    vTaskSuspend(NULL);
+    vTaskSuspend(nullptr);
   }
 
   originalTask->taskFunctionality();
@@ -62,13 +63,11 @@ ReturnValue_t PeriodicTask::sleepFor(uint32_t ms) {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-void PeriodicTask::taskFunctionality() {
+[[noreturn]] void PeriodicTask::taskFunctionality() {
   TickType_t xLastWakeTime;
   const TickType_t xPeriod = pdMS_TO_TICKS(this->period * 1000.);
 
-  for (auto const& object : objectList) {
+  initObjsAfterTaskCreation();
-    object->initializeAfterTaskCreation();
-  }
 
   /* The xLastWakeTime variable needs to be initialized with the current tick
    count. Note that this is the only time the variable is written to
@@ -77,8 +76,8 @@ void PeriodicTask::taskFunctionality() {
   xLastWakeTime = xTaskGetTickCount();
   /* Enter the loop that defines the task behavior. */
   for (;;) {
-    for (auto const& object : objectList) {
+    for (auto const& objectPair : objectList) {
-      object->performOperation();
+      objectPair.first->performOperation(objectPair.second);
     }
 
 #if (tskKERNEL_VERSION_MAJOR == 10 && tskKERNEL_VERSION_MINOR >= 4) || tskKERNEL_VERSION_MAJOR > 10
@@ -95,32 +94,10 @@ void PeriodicTask::taskFunctionality() {
   }
 }
 
-ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
-  ExecutableObjectIF* newObject = ObjectManager::instance()->get<ExecutableObjectIF>(object);
-  return addComponent(newObject);
-}
-
-ReturnValue_t PeriodicTask::addComponent(ExecutableObjectIF* object) {
-  if (object == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
-                  "it implement ExecutableObjectIF"
-               << std::endl;
-#endif
-    return HasReturnvaluesIF::RETURN_FAILED;
-  }
-  objectList.push_back(object);
-  object->setTaskIF(this);
-
-  return HasReturnvaluesIF::RETURN_OK;
-}
-
-uint32_t PeriodicTask::getPeriodMs() const { return period * 1000; }
-
 TaskHandle_t PeriodicTask::getTaskHandle() { return handle; }
 
 void PeriodicTask::handleMissedDeadline() {
-  if (deadlineMissedFunc != nullptr) {
+  if (dlmFunc != nullptr) {
-    this->deadlineMissedFunc();
+    dlmFunc();
   }
 }

src/fsfw/osal/freertos/PeriodicTask.h

@@ -6,8 +6,8 @@
 #include "FreeRTOS.h"
 #include "FreeRTOSTaskIF.h"
 #include "fsfw/objectmanager/ObjectManagerIF.h"
-#include "fsfw/tasks/PeriodicTaskIF.h"
+#include "fsfw/tasks/PeriodicTaskBase.h"
-#include "fsfw/tasks/Typedef.h"
+#include "fsfw/tasks/definitions.h"
 #include "task.h"
 
 class ExecutableObjectIF;
@@ -17,7 +17,7 @@ class ExecutableObjectIF;
  * 			periodic activities of multiple objects.
  * @ingroup task_handling
  */
-class PeriodicTask : public PeriodicTaskIF, public FreeRTOSTaskIF {
+class PeriodicTask : public PeriodicTaskBase, public FreeRTOSTaskIF {
  public:
   /**
    * Keep in Mind that you need to call before this vTaskStartScheduler()!
@@ -43,7 +43,7 @@ class PeriodicTask : public PeriodicTaskIF, public FreeRTOSTaskIF {
    * @brief	Currently, the executed object's lifetime is not coupled with
    * 			the task object's lifetime, so the destructor is empty.
    */
-  virtual ~PeriodicTask(void);
+  ~PeriodicTask() override;
 
   /**
    * @brief	The method to start the task.
@@ -53,27 +53,6 @@ class PeriodicTask : public PeriodicTaskIF, public FreeRTOSTaskIF {
    * 			to the system call.
    */
   ReturnValue_t startTask() override;
-  /**
-   * Adds an object to the list of objects to be executed.
-   * The objects are executed in the order added.
-   * @param object Id of the object to add.
-   * @return
-   * -@c RETURN_OK on success
-   * -@c RETURN_FAILED if the object could not be added.
-   */
-  ReturnValue_t addComponent(object_id_t object) override;
-
-  /**
-   * Adds an object to the list of objects to be executed.
-   * The objects are executed in the order added.
-   * @param object Id of the object to add.
-   * @return
-   * -@c RETURN_OK on success
-   * -@c RETURN_FAILED if the object could not be added.
-   */
-  ReturnValue_t addComponent(ExecutableObjectIF* object) override;
-
-  uint32_t getPeriodMs() const override;
 
   ReturnValue_t sleepFor(uint32_t ms) override;
 
@@ -83,28 +62,6 @@ class PeriodicTask : public PeriodicTaskIF, public FreeRTOSTaskIF {
   bool started;
   TaskHandle_t handle;
 
-  //! Typedef for the List of objects.
-  typedef std::vector<ExecutableObjectIF*> ObjectList;
-  /**
-   * @brief	This attribute holds a list of objects to be executed.
-   */
-  ObjectList objectList;
-  /**
-   * @brief	The period of the task.
-   * @details
-   * The period determines the frequency of the task's execution.
-   * It is expressed in clock ticks.
-   */
-  TaskPeriod period;
-  /**
-   * @brief	The pointer to the deadline-missed function.
-   * @details
-   * This pointer stores the function that is executed if the task's deadline
-   * is missed so each may react individually on a timing failure.
-   * The pointer may be NULL, then nothing happens on missing the deadline.
-   * The deadline is equal to the next execution of the periodic task.
-   */
-  void (*deadlineMissedFunc)(void);
   /**
    * @brief	This is the function executed in the new task's context.
    * @details
@@ -125,7 +82,7 @@ class PeriodicTask : public PeriodicTaskIF, public FreeRTOSTaskIF {
    * the next period.
    * On missing the deadline, the deadlineMissedFunction is executed.
    */
-  void taskFunctionality(void);
+  [[noreturn]] void taskFunctionality();
 
   void handleMissedDeadline();
 };

src/fsfw/osal/host/FixedTimeslotTask.cpp

@@ -74,8 +74,10 @@ ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-[[noreturn]] void FixedTimeslotTask::taskFunctionality() {
+void FixedTimeslotTask::taskFunctionality() {
-  pollingSeqTable.intializeSequenceAfterTaskCreation();
+  ReturnValue_t result = pollingSeqTable.intializeSequenceAfterTaskCreation();
+  // Ignore returnvalue for now
+  static_cast<void>(result);
 
   // A local iterator for the Polling Sequence Table is created to
   // find the start time for the first entry.
@@ -109,26 +111,6 @@ ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
   }
 }
 
-ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId, uint32_t slotTimeMs,
-                                         int8_t executionStep) {
-  auto* executableObject = ObjectManager::instance()->get<ExecutableObjectIF>(componentId);
-  if (executableObject != nullptr) {
-    pollingSeqTable.addSlot(componentId, slotTimeMs, executionStep, executableObject, this);
-    return HasReturnvaluesIF::RETURN_OK;
-  }
-
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::error << "Component " << std::hex << "0x" << componentId
-             << "not found, "
-                "not adding it to PST.."
-             << std::dec << std::endl;
-#else
-  sif::printError("Component 0x%08x not found, not adding it to PST..\n",
-                  static_cast<unsigned int>(componentId));
-#endif
-  return HasReturnvaluesIF::RETURN_FAILED;
-}
-
 bool FixedTimeslotTask::delayForInterval(chron_ms* previousWakeTimeMs, const chron_ms interval) {
   bool shouldDelay = false;
   // Get current wakeup time

src/fsfw/osal/host/FixedTimeslotTask.h

@@ -50,16 +50,6 @@ class FixedTimeslotTask : public FixedTimeslotTaskBase {
    */
   ReturnValue_t startTask() override;
 
-  /**
-   * Add timeslot to the polling sequence table.
-   * @param componentId
-   * @param slotTimeMs
-   * @param executionStep
-   * @return
-   */
-  ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
-                        int8_t executionStep) override;
-
   ReturnValue_t sleepFor(uint32_t ms) override;
 
  protected:
@@ -93,7 +83,7 @@ class FixedTimeslotTask : public FixedTimeslotTaskBase {
    * the checkAndRestartPeriod system call blocks the task until the next
    *  period. On missing the deadline, the deadlineMissedFunction is executed.
    */
-  [[noreturn]] void taskFunctionality();
+  void taskFunctionality();
 
   static bool delayForInterval(chron_ms* previousWakeTimeMs, chron_ms interval);
 };

src/fsfw/osal/host/PeriodicTask.cpp

@@ -133,5 +133,3 @@ bool PeriodicTask::delayForInterval(chron_ms* previousWakeTimeMs, const chron_ms
   (*previousWakeTimeMs) = currentStartTime;
   return false;
 }
-
-bool PeriodicTask::isEmpty() const { return objectList.empty(); }

src/fsfw/osal/host/PeriodicTask.h

@@ -52,7 +52,6 @@ class PeriodicTask : public PeriodicTaskBase {
 
   ReturnValue_t sleepFor(uint32_t ms) override;
 
-  bool isEmpty() const override;
  protected:
   using chron_ms = std::chrono::milliseconds;
   bool started;

src/fsfw/osal/linux/FixedTimeslotTask.cpp

@@ -4,7 +4,6 @@
 
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
-uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
 const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = PTHREAD_STACK_MIN;
 
 FixedTimeslotTask::FixedTimeslotTask(const char* name_, TaskPriority priority_, size_t stackSize_,
@@ -37,7 +36,8 @@ ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
     posixThread.suspend();
   }
 
-  pollingSeqTable.intializeSequenceAfterTaskCreation();
+  // Returnvalue ignored for now
+  static_cast<void>(pollingSeqTable.intializeSequenceAfterTaskCreation());
 
   // The start time for the first entry is read.
   uint64_t lastWakeTime = PosixThread::getCurrentMonotonicTimeMs();
@@ -54,20 +54,12 @@ 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
-        missedDeadlineCounter();
+        if (dlmFunc != nullptr) {
+          dlmFunc();
+        }
       }
     }
     // The device handler for this slot is executed and the next one is chosen.
     pollingSeqTable.executeAndAdvance();
   }
 }
-
-void FixedTimeslotTask::missedDeadlineCounter() {
-  FixedTimeslotTask::deadlineMissedCount++;
-  if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount << " deadlines."
-               << std::endl;
-#endif
-  }
-}

src/fsfw/osal/linux/FixedTimeslotTask.h

@@ -30,17 +30,6 @@ class FixedTimeslotTask : public FixedTimeslotTaskBase {
 
   ReturnValue_t sleepFor(uint32_t ms) override;
 
-  /**
-   * This static function can be used as #deadlineMissedFunc.
-   * It counts missedDeadlines and prints the number of missed deadlines every 10th time.
-   */
-  static void missedDeadlineCounter();
-
-  /**
-   * A helper variable to count missed deadlines.
-   */
-  static uint32_t deadlineMissedCount;
-
  protected:
   /**
    * @brief	This function holds the main functionality of the thread.

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!"
+                      "allowed message depth higher" << std::endl;
-                   << std::endl;
 #else
         sif::printError(
             "MessageQueue::MessageQueue: Default MQ size %d is too small for"

src/fsfw/osal/rtems/FixedTimeslotTask.cpp

@@ -1,42 +1,32 @@
 #include "fsfw/osal/rtems/FixedTimeslotTask.h"
 
-#include <rtems/bspIo.h>
 #include <rtems/io.h>
-#include <rtems/rtems/ratemon.h>
 #include <rtems/rtems/status.h>
 #include <rtems/rtems/tasks.h>
 #include <rtems/rtems/types.h>
-#include <sys/_stdint.h>
 
-#include "fsfw/objectmanager/ObjectManager.h"
-#include "fsfw/objectmanager/SystemObjectIF.h"
 #include "fsfw/osal/rtems/RtemsBasic.h"
 #include "fsfw/returnvalues/HasReturnvaluesIF.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
-#include "fsfw/tasks/FixedSequenceSlot.h"
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 #include <iostream>
 #endif
 
 #include <cstddef>
-#include <list>
-
-uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
 
 FixedTimeslotTask::FixedTimeslotTask(const char *name, rtems_task_priority setPriority,
-                                     size_t setStack, uint32_t setOverallPeriod,
+                                     size_t setStack, TaskPeriod setOverallPeriod,
-                                     void (*setDeadlineMissedFunc)(void))
+                                     TaskDeadlineMissedFunction dlmFunc_)
-    : RTEMSTaskBase(setPriority, setStack, name), periodId(0), pst(setOverallPeriod) {
+    : FixedTimeslotTaskBase(setOverallPeriod, dlmFunc_),
-  // All additional attributes are applied to the object.
+      RTEMSTaskBase(setPriority, setStack, name),
-  this->deadlineMissedFunc = setDeadlineMissedFunc;
+      periodId(0) {}
-}
 
-FixedTimeslotTask::~FixedTimeslotTask() {}
+FixedTimeslotTask::~FixedTimeslotTask() = default;
 
 rtems_task FixedTimeslotTask::taskEntryPoint(rtems_task_argument argument) {
   /* The argument is re-interpreted as a FixedTimeslotTask */
-  FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask *>(argument));
+  auto *originalTask(reinterpret_cast<FixedTimeslotTask *>(argument));
   /* The task's functionality is called. */
   return originalTask->taskFunctionality();
   /* Should never be reached */
@@ -46,16 +36,6 @@ rtems_task FixedTimeslotTask::taskEntryPoint(rtems_task_argument argument) {
 #endif
 }
 
-void FixedTimeslotTask::missedDeadlineCounter() {
-  FixedTimeslotTask::deadlineMissedCount++;
-  if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "PST missed " << FixedTimeslotTask::deadlineMissedCount << " deadlines"
-                 << std::endl;
-#endif
-  }
-}
-
 ReturnValue_t FixedTimeslotTask::startTask() {
   rtems_status_code status =
       rtems_task_start(id, FixedTimeslotTask::taskEntryPoint, rtems_task_argument((void *)this));
@@ -79,54 +59,35 @@ ReturnValue_t FixedTimeslotTask::startTask() {
   }
 }
 
-ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId, uint32_t slotTimeMs,
+[[noreturn]] void FixedTimeslotTask::taskFunctionality() {
-                                         int8_t executionStep) {
-  ExecutableObjectIF *object = ObjectManager::instance()->get<ExecutableObjectIF>(componentId);
-  if (object != nullptr) {
-    pst.addSlot(componentId, slotTimeMs, executionStep, object, this);
-    return HasReturnvaluesIF::RETURN_OK;
-  }
-
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::error << "Component " << std::hex << componentId << " not found, not adding it to pst"
-             << std::endl;
-#endif
-  return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-uint32_t FixedTimeslotTask::getPeriodMs() const { return pst.getLengthMs(); }
-
-ReturnValue_t FixedTimeslotTask::checkSequence() const { return pst.checkSequence(); }
-
-void FixedTimeslotTask::taskFunctionality() {
   /* A local iterator for the Polling Sequence Table is created to find the start time for
       the first entry. */
-  FixedSlotSequence::SlotListIter it = pst.current;
+  auto it = pollingSeqTable.current;
 
   /* Initialize the PST with the correct calling task */
-  pst.intializeSequenceAfterTaskCreation();
+  pollingSeqTable.intializeSequenceAfterTaskCreation();
 
   /* The start time for the first entry is read. */
   rtems_interval interval = RtemsBasic::convertMsToTicks(it->pollingTimeMs);
   RTEMSTaskBase::setAndStartPeriod(interval, &periodId);
   // The task's "infinite" inner loop is entered.
-  while (1) {
+  while (true) {
-    if (pst.slotFollowsImmediately()) {
+    if (pollingSeqTable.slotFollowsImmediately()) {
       /* Do nothing */
     } else {
       /* The interval for the next polling slot is selected. */
-      interval = RtemsBasic::convertMsToTicks(this->pst.getIntervalToNextSlotMs());
+      interval = RtemsBasic::convertMsToTicks(pollingSeqTable.getIntervalToNextSlotMs());
       /* The period is checked and restarted with the new interval.
                   If the deadline was missed, the deadlineMissedFunc is called. */
       rtems_status_code status = RTEMSTaskBase::restartPeriod(interval, periodId);
       if (status == RTEMS_TIMEOUT) {
-        if (this->deadlineMissedFunc != nullptr) {
+        if (dlmFunc != nullptr) {
-          this->deadlineMissedFunc();
+          dlmFunc();
         }
       }
     }
     /* The device handler for this slot is executed and the next one is chosen. */
-    this->pst.executeAndAdvance();
+    this->pollingSeqTable.executeAndAdvance();
   }
 }
 

src/fsfw/osal/rtems/FixedTimeslotTask.h

@@ -1,11 +1,11 @@
 #ifndef FSFW_OSAL_RTEMS_FIXEDTIMESLOTTASK_H_
 #define FSFW_OSAL_RTEMS_FIXEDTIMESLOTTASK_H_
 
-#include "../../tasks/FixedSlotSequence.h"
-#include "../../tasks/FixedTimeslotTaskIF.h"
 #include "RTEMSTaskBase.h"
+#include "fsfw/tasks/FixedSlotSequence.h"
+#include "fsfw/tasks/FixedTimeslotTaskBase.h"
 
-class FixedTimeslotTask : public RTEMSTaskBase, public FixedTimeslotTaskIF {
+class FixedTimeslotTask : public FixedTimeslotTaskBase, public RTEMSTaskBase {
  public:
   /**
    * @brief	The standard constructor of the class.
@@ -17,7 +17,7 @@ class FixedTimeslotTask : public RTEMSTaskBase, public FixedTimeslotTaskIF {
    * @param	getPst The object id of the completely initialized polling sequence.
    */
   FixedTimeslotTask(const char *name, rtems_task_priority setPriority, size_t setStackSize,
-                    uint32_t overallPeriod, void (*setDeadlineMissedFunc)());
+                    TaskPeriod overallPeriod, TaskDeadlineMissedFunction dlmFunc);
 
   /**
    * @brief	The destructor of the class.
@@ -25,44 +25,17 @@ class FixedTimeslotTask : public RTEMSTaskBase, public FixedTimeslotTaskIF {
    * The destructor frees all heap memory that was allocated on thread initialization
    * for the PST andthe device handlers. This is done by calling the PST's destructor.
    */
-  virtual ~FixedTimeslotTask(void);
+  ~FixedTimeslotTask() override;
 
   ReturnValue_t startTask(void);
-  /**
-   * This static function can be used as #deadlineMissedFunc.
-   * It counts missedDeadlines and prints the number of missed deadlines every 10th time.
-   */
-  static void missedDeadlineCounter();
-  /**
-   * A helper variable to count missed deadlines.
-   */
-  static uint32_t deadlineMissedCount;
 
-  ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep);
+  ReturnValue_t sleepFor(uint32_t ms) override;
-
-  uint32_t getPeriodMs() const;
-
-  ReturnValue_t checkSequence() const;
-
-  ReturnValue_t sleepFor(uint32_t ms);
 
  protected:
   /**
    * @brief id of the associated OS period
    */
   rtems_id periodId;
-
-  FixedSlotSequence pst;
-
-  /**
-   * @brief	This attribute holds a function pointer that is executed when a deadline was missed.
-   *
-   * @details
-   * Another function may be announced to determine the actions to perform when a deadline
-   * was missed. Currently, only one function for missing any deadline is allowed.
-   * If not used, it shall be declared NULL.
-   */
-  void (*deadlineMissedFunc)(void) = nullptr;
   /**
    * @brief	This is the entry point in a new polling thread.
    * @details	This method is the entry point in the new thread
@@ -76,7 +49,7 @@ class FixedTimeslotTask : public RTEMSTaskBase, public FixedTimeslotTaskIF {
    * It links the functionalities provided by FixedSlotSequence with the OS's system calls to
    * keep the timing of the periods.
    */
-  void taskFunctionality(void);
+  [[noreturn]] void taskFunctionality();
 };
 
 #endif /* FSFW_OSAL_RTEMS_FIXEDTIMESLOTTASK_H_ */

src/fsfw/osal/rtems/MessageQueue.cpp

@@ -65,7 +65,7 @@ ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo, MessageQueu
   }
 
   ReturnValue_t returnCode = convertReturnCode(result);
-  if (result == MessageQueueIF::EMPTY) {
+  if (returnCode == MessageQueueIF::EMPTY) {
     return HasReturnvaluesIF::RETURN_FAILED;
   }
 

src/fsfw/osal/rtems/MessageQueue.h

@@ -36,9 +36,9 @@ class MessageQueue : public MessageQueueBase {
    * @param max_message_size	With this parameter, the maximum message size can be adjusted.
    * 							This should be left default.
    */
-  MessageQueue(size_t message_depth = 3,
+  explicit MessageQueue(size_t message_depth = 3,
-               size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE,
+                        size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE,
-               MqArgs* args = nullptr);
+                        MqArgs* args = nullptr);
 
   /** Copying message queues forbidden */
   MessageQueue(const MessageQueue&) = delete;
@@ -48,18 +48,19 @@ class MessageQueue : public MessageQueueBase {
    * @brief	The destructor deletes the formerly created message queue.
    * @details	This is accomplished by using the delete call provided by the operating system.
    */
-  virtual ~MessageQueue();
+  ~MessageQueue() override;
 
   // Implement non-generic MessageQueueIF functions not handled by MessageQueueBase
   ReturnValue_t flush(uint32_t* count) override;
+
+  ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
   ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
-                                MessageQueueId_t sentFrom = NO_QUEUE,
+                                MessageQueueId_t sentFrom, bool ignoreFault) override;
-                                bool ignoreFault = false) override;
 
  private:
   /**
-   * \brief	This attribute stores a reference to the internal error reporter for reporting full
+   * @brief	This attribute stores a reference to the internal error reporter for reporting full
-   * queues. \details	In the event of a full destination queue, the reporter will be notified. The
+   * queues. @details	In the event of a full destination queue, the reporter will be notified. The
    * reference is set by lazy loading
    */
   InternalErrorReporterIF* internalErrorReporter;

src/fsfw/osal/rtems/PeriodicTask.cpp

@@ -5,12 +5,12 @@
 #include "fsfw/tasks/ExecutableObjectIF.h"
 
 PeriodicTask::PeriodicTask(const char* name, rtems_task_priority setPriority, size_t setStack,
-                           rtems_interval setPeriod, void (*setDeadlineMissedFunc)())
+                           TaskPeriod setPeriod, TaskDeadlineMissedFunction dlmFunc_)
-    : RTEMSTaskBase(setPriority, setStack, name),
+    : PeriodicTaskBase(setPeriod, dlmFunc_),
-      periodTicks(RtemsBasic::convertMsToTicks(setPeriod)),
+      RTEMSTaskBase(setPriority, setStack, name),
-      deadlineMissedFunc(setDeadlineMissedFunc) {}
+      periodTicks(RtemsBasic::convertMsToTicks(static_cast<uint32_t>(setPeriod * 1000.0))) {}
 
-PeriodicTask::~PeriodicTask(void) {
+PeriodicTask::~PeriodicTask() {
   /* Do not delete objects, we were responsible for pointers only. */
   rtems_rate_monotonic_delete(periodId);
 }
@@ -18,7 +18,7 @@ PeriodicTask::~PeriodicTask(void) {
 rtems_task PeriodicTask::taskEntryPoint(rtems_task_argument argument) {
   /* The argument is re-interpreted as MultiObjectTask. The Task object is global,
   so it is found from any place. */
-  PeriodicTask* originalTask(reinterpret_cast<PeriodicTask*>(argument));
+  auto* originalTask(reinterpret_cast<PeriodicTask*>(argument));
   return originalTask->taskFunctionality();
   ;
 }
@@ -28,8 +28,10 @@ ReturnValue_t PeriodicTask::startTask() {
       rtems_task_start(id, PeriodicTask::taskEntryPoint, rtems_task_argument((void*)this));
   if (status != RTEMS_SUCCESSFUL) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "ObjectTask::startTask for " << std::hex << this->getId() << std::dec
+    sif::error << "PeriodicTask::startTask for " << std::hex << this->getId() << std::dec
-               << " failed." << std::endl;
+               << " failed" << std::endl;
+#else
+    sif::printError("PeriodicTask::startTask for 0x%08x failed\n", getId());
 #endif
   }
   switch (status) {
@@ -47,38 +49,20 @@ ReturnValue_t PeriodicTask::startTask() {
 
 ReturnValue_t PeriodicTask::sleepFor(uint32_t ms) { return RTEMSTaskBase::sleepFor(ms); }
 
-void PeriodicTask::taskFunctionality() {
+[[noreturn]] void PeriodicTask::taskFunctionality() {
   RTEMSTaskBase::setAndStartPeriod(periodTicks, &periodId);
-  for (const auto& object : objectList) {
+  initObjsAfterTaskCreation();
-    object->initializeAfterTaskCreation();
+
-  }
   /* The task's "infinite" inner loop is entered. */
-  while (1) {
+  while (true) {
-    for (const auto& object : objectList) {
+    for (const auto& objectPair : objectList) {
-      object->performOperation();
+      objectPair.first->performOperation(objectPair.second);
     }
     rtems_status_code status = RTEMSTaskBase::restartPeriod(periodTicks, periodId);
     if (status == RTEMS_TIMEOUT) {
-      if (this->deadlineMissedFunc != nullptr) {
+      if (dlmFunc != nullptr) {
-        this->deadlineMissedFunc();
+        dlmFunc();
       }
     }
   }
 }
-
-ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
-  ExecutableObjectIF* newObject = ObjectManager::instance()->get<ExecutableObjectIF>(object);
-  return addComponent(newObject);
-}
-
-ReturnValue_t PeriodicTask::addComponent(ExecutableObjectIF* object) {
-  if (object == nullptr) {
-    return HasReturnvaluesIF::RETURN_FAILED;
-  }
-  objectList.push_back(object);
-  object->setTaskIF(this);
-
-  return HasReturnvaluesIF::RETURN_OK;
-}
-
-uint32_t PeriodicTask::getPeriodMs() const { return RtemsBasic::convertTicksToMs(periodTicks); }

src/fsfw/osal/rtems/PeriodicTask.h

@@ -3,9 +3,10 @@
 
 #include <vector>
 
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../tasks/PeriodicTaskIF.h"
 #include "RTEMSTaskBase.h"
+#include "fsfw/objectmanager/ObjectManagerIF.h"
+#include "fsfw/tasks/PeriodicTaskBase.h"
+#include "fsfw/tasks/PeriodicTaskIF.h"
 
 class ExecutableObjectIF;
 
@@ -18,7 +19,7 @@ class ExecutableObjectIF;
  * @author  baetz
  * @ingroup task_handling
  */
-class PeriodicTask : public RTEMSTaskBase, public PeriodicTaskIF {
+class PeriodicTask : public PeriodicTaskBase, public RTEMSTaskBase {
  public:
   /**
    * @brief	Standard constructor of the class.
@@ -36,12 +37,12 @@ class PeriodicTask : public RTEMSTaskBase, public PeriodicTaskIF {
    * 								that shall be assigned.
    */
   PeriodicTask(const char *name, rtems_task_priority setPriority, size_t setStack,
-               rtems_interval setPeriod, void (*setDeadlineMissedFunc)());
+               TaskPeriod setPeriod, TaskDeadlineMissedFunction dlmFunc);
   /**
    * @brief	Currently, the executed object's lifetime is not coupled with the task object's
    * 			lifetime, so the destructor is empty.
    */
-  virtual ~PeriodicTask(void);
+  ~PeriodicTask() override;
 
   /**
    * @brief	The method to start the task.
@@ -50,33 +51,11 @@ class PeriodicTask : public RTEMSTaskBase, public PeriodicTaskIF {
    * 			The address of the task object is passed as an argument
    * 			to the system call.
    */
-  ReturnValue_t startTask(void);
+  ReturnValue_t startTask() override;
-  /**
-   * Adds an object to the list of objects to be executed.
-   * The objects are executed in the order added.
-   * @param object Id of the object to add.
-   * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
-   */
-  ReturnValue_t addComponent(object_id_t object) override;
-
-  /**
-   * Adds an object to the list of objects to be executed.
-   * The objects are executed in the order added.
-   * @param object pointer to the object to add.
-   * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
-   */
-  ReturnValue_t addComponent(ExecutableObjectIF *object) override;
-
-  uint32_t getPeriodMs() const override;
 
   ReturnValue_t sleepFor(uint32_t ms) override;
 
  protected:
-  typedef std::vector<ExecutableObjectIF *> ObjectList;  //!< Typedef for the List of objects.
-  /**
-   * @brief	This attribute holds a list of objects to be executed.
-   */
-  ObjectList objectList;
   /**
    * @brief	The period of the task.
    * @details	The period determines the frequency of the task's execution. It is expressed in
@@ -87,14 +66,7 @@ class PeriodicTask : public RTEMSTaskBase, public PeriodicTaskIF {
    * @brief id of the associated OS period
    */
   rtems_id periodId = 0;
-  /**
+
-   * @brief	The pointer to the deadline-missed function.
-   * @details	This pointer stores the function that is executed if the task's deadline is missed.
-   * 			So, each may react individually on a timing failure. The pointer may be
-   * nullptr, then nothing happens on missing the deadline. The deadline is equal to the next
-   * execution of the periodic task.
-   */
-  void (*deadlineMissedFunc)(void);
   /**
    * @brief	This is the function executed in the new task's context.
    * @details	It converts the argument back to the thread object type and copies the class
@@ -110,7 +82,7 @@ class PeriodicTask : public RTEMSTaskBase, public PeriodicTaskIF {
    * are called. Afterwards the checkAndRestartPeriod system call blocks the task until the next
    * period. On missing the deadline, the deadlineMissedFunction is executed.
    */
-  void taskFunctionality(void);
+  [[noreturn]] void taskFunctionality();
 };
 
 #endif /* FSFW_OSAL_RTEMS_PERIODICTASK_H_ */

src/fsfw/osal/rtems/QueueFactory.cpp

@@ -45,9 +45,9 @@ QueueFactory* QueueFactory::instance() {
   return factoryInstance;
 }
 
-QueueFactory::QueueFactory() {}
+QueueFactory::QueueFactory() = default;
 
-QueueFactory::~QueueFactory() {}
+QueueFactory::~QueueFactory() = default;
 
 MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth, size_t maxMessageSize,
                                                  MqArgs* args) {

src/fsfw/osal/rtems/RTEMSTaskBase.cpp

@@ -32,7 +32,7 @@ RTEMSTaskBase::RTEMSTaskBase(rtems_task_priority set_priority, size_t stack_size
 
 RTEMSTaskBase::~RTEMSTaskBase() { rtems_task_delete(id); }
 
-rtems_id RTEMSTaskBase::getId() { return this->id; }
+rtems_id RTEMSTaskBase::getId() const { return this->id; }
 
 ReturnValue_t RTEMSTaskBase::sleepFor(uint32_t ms) {
   rtems_status_code status = rtems_task_wake_after(RtemsBasic::convertMsToTicks(ms));

src/fsfw/osal/rtems/RTEMSTaskBase.h

@@ -36,9 +36,9 @@ class RTEMSTaskBase {
   /**
    * @brief	This method returns the task id of this class.
    */
-  rtems_id getId();
+  rtems_id getId() const;
 
-  ReturnValue_t sleepFor(uint32_t ms);
+  static ReturnValue_t sleepFor(uint32_t ms);
   static ReturnValue_t setAndStartPeriod(rtems_interval period, rtems_id *periodId);
   static rtems_status_code restartPeriod(rtems_interval period, rtems_id periodId);
 

src/fsfw/osal/rtems/TaskFactory.cpp

@@ -1,7 +1,6 @@
 #include "fsfw/tasks/TaskFactory.h"
 
 #include "fsfw/osal/rtems/FixedTimeslotTask.h"
-#include "fsfw/osal/rtems/InitTask.h"
 #include "fsfw/osal/rtems/PeriodicTask.h"
 #include "fsfw/osal/rtems/RtemsBasic.h"
 #include "fsfw/returnvalues/HasReturnvaluesIF.h"
@@ -9,29 +8,29 @@
 // TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
 TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
 
-TaskFactory::~TaskFactory() {}
+TaskFactory::TaskFactory() = default;
+
+TaskFactory::~TaskFactory() = default;
 
 TaskFactory* TaskFactory::instance() { return TaskFactory::factoryInstance; }
 
 PeriodicTaskIF* TaskFactory::createPeriodicTask(
     TaskName name_, TaskPriority taskPriority_, TaskStackSize stackSize_,
     TaskPeriod periodInSeconds_, TaskDeadlineMissedFunction deadLineMissedFunction_) {
-  rtems_interval taskPeriod = periodInSeconds_ * Clock::getTicksPerSecond();
+  return static_cast<PeriodicTaskIF*>(new PeriodicTask(name_, taskPriority_, stackSize_,
-
+                                                       periodInSeconds_, deadLineMissedFunction_));
-  return static_cast<PeriodicTaskIF*>(
-      new PeriodicTask(name_, taskPriority_, stackSize_, taskPeriod, deadLineMissedFunction_));
 }
 
 FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(
     TaskName name_, TaskPriority taskPriority_, TaskStackSize stackSize_,
     TaskPeriod periodInSeconds_, TaskDeadlineMissedFunction deadLineMissedFunction_) {
-  rtems_interval taskPeriod = periodInSeconds_ * Clock::getTicksPerSecond();
+  return static_cast<FixedTimeslotTaskIF*>(new FixedTimeslotTask(
-  return static_cast<FixedTimeslotTaskIF*>(
+      name_, taskPriority_, stackSize_, periodInSeconds_, deadLineMissedFunction_));
-      new FixedTimeslotTask(name_, taskPriority_, stackSize_, taskPeriod, deadLineMissedFunction_));
 }
 
 ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
-  // TODO not implemented
+  // This should call the OS specific destructor
+  delete (dynamic_cast<PeriodicTask*>(task));
   return HasReturnvaluesIF::RETURN_FAILED;
 }
 
@@ -45,5 +44,3 @@ void TaskFactory::printMissedDeadline() {
   /* TODO: Implement */
   return;
 }
-
-TaskFactory::TaskFactory() {}

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,

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

src/fsfw/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);
@@ -615,23 +615,23 @@ inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::handleInvalidD
 
 template <size_t MAX_NUM_TCS>
 inline void Service11TelecommandScheduling<MAX_NUM_TCS>::debugPrintMultimapContent() const {
-  for ([[maybe_unused]] const auto &dit : telecommandMap) {
 #if FSFW_DISABLE_PRINTOUT == 0
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::debug << "Service11TelecommandScheduling::debugPrintMultimapContent: Multimap Content"
+  sif::debug << "Service11TelecommandScheduling::debugPrintMultimapContent: Multimap Content"
-               << std::endl;
+             << std::endl;
+#else
+  sif::printDebug("Service11TelecommandScheduling::debugPrintMultimapContent: Multimap Content\n");
+#endif
+  for (const auto &dit : telecommandMap) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::debug << "[" << dit.first << "]: Request ID: " << dit.second.requestId << " | "
                << "Store Address: " << dit.second.storeAddr.raw << std::endl;
 #else
-    sif::printDebug(
+    sif::printDebug("[%d]: Request ID: %d  | Store Address: %d\n", dit.first, dit.second.requestId,
-        "Service11TelecommandScheduling::debugPrintMultimapContent: Multimap Content\n");
+                    dit.second.storeAddr);
-    for (auto dit = telecommandMap.begin(); dit != telecommandMap.end(); ++dit) {
-      sif::printDebug("[%d]: Request ID: %d  | Store Address: %d\n", dit->first,
-                      dit->second.requestId, dit->second.storeAddr);
-    }
-#endif
 #endif
   }
+#endif
 }
 
 template <size_t MAX_NUM_TCS>

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);
-  tmQueue = QueueFactory::instance()->createMessageQueue(
-      messageQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
 
 Service1TelecommandVerification::~Service1TelecommandVerification() {

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,23 +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 "
+                   << command << "!" << std::endl;
 #else
       sif::printWarning(
           "Service3Housekeeping::handleUnrequestedReply: Invalid reply with "
-          "reply command %hu\n",
+          "reply command %hu!\n",
           command);
 #endif
-      break;
+      return;
     }
   }
 
@@ -279,7 +275,6 @@ void Service3Housekeeping::handleUnrequestedReply(CommandMessage* reply) {
         "Could not generate reply!\n");
 #endif
   }
-  CommandingServiceBase::handleUnrequestedReply(reply);
 }
 
 MessageQueueId_t Service3Housekeeping::getHkQueue() const { return commandQueue->getId(); }

src/fsfw/pus/Service5EventReporting.cpp

@@ -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);
-  eventQueue = QueueFactory::instance()->createMessageQueue(
-      messageQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
 
 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;
 }
 

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();
 
   /***

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

src/fsfw/storagemanager/StorageAccessor.cpp

@@ -13,7 +13,7 @@ StorageAccessor::StorageAccessor(store_address_t storeId, StorageManagerIF* stor
 StorageAccessor& StorageAccessor::operator=(StorageAccessor&& other) {
   // Call the parent move assignment and also assign own member.
   dataPointer = other.dataPointer;
-  StorageAccessor::operator=(std::move(other));
+  ConstStorageAccessor::operator=(std::move(other));
   return *this;
 }
 

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
+ * @brief   TODO: documentation missing
- *          and mode sequences
  * @details
- * This class is able to use mode tables and sequences to command all its children into the
- * right mode. Fallback sequences can be used to handle failed transitions or have a fallback
- * in case a component can't keep its current mode.
  */
 class Subsystem : public SubsystemBase, public HasModeSequenceIF {
  public:

src/fsfw/subsystem/SubsystemBase.cpp

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

src/fsfw/subsystem/SubsystemBase.h

@@ -15,14 +15,7 @@
 
 /**
  * @defgroup subsystems Subsystem Objects
- * All Subsystem and Assemblies can derive from this class. It contains helper classes to
+ * Contains all Subsystem and Assemblies
- * 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.
  */
 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
    */

src/fsfw/tasks/FixedSlotSequence.cpp

@@ -29,7 +29,7 @@ void FixedSlotSequence::executeAndAdvance() {
 
 uint32_t FixedSlotSequence::getIntervalToNextSlotMs() {
   uint32_t oldTime;
-  SlotListIter slotListIter = current;
+  auto slotListIter = current;
   // Get the pollingTimeMs of the current slot object.
   oldTime = slotListIter->pollingTimeMs;
   // Advance to the next object.
@@ -51,7 +51,7 @@ uint32_t FixedSlotSequence::getIntervalToNextSlotMs() {
 
 uint32_t FixedSlotSequence::getIntervalToPreviousSlotMs() {
   uint32_t currentTime;
-  SlotListIter slotListIter = current;
+  auto slotListIter = current;
   // Get the pollingTimeMs of the current slot object.
   currentTime = slotListIter->pollingTimeMs;
 
@@ -67,7 +67,7 @@ uint32_t FixedSlotSequence::getIntervalToPreviousSlotMs() {
 
 bool FixedSlotSequence::slotFollowsImmediately() {
   uint32_t currentTime = current->pollingTimeMs;
-  SlotListIter fixedSequenceIter = this->current;
+  auto fixedSequenceIter = this->current;
   // Get the pollingTimeMs of the current slot object.
   if (fixedSequenceIter == slotList.begin()) return false;
   fixedSequenceIter--;
@@ -96,8 +96,8 @@ ReturnValue_t FixedSlotSequence::checkSequence() const {
     return FixedTimeslotTaskIF::SLOT_LIST_EMPTY;
   }
 
-  if (customCheckFunction != nullptr) {
+  if (customChecker != nullptr) {
-    ReturnValue_t result = customCheckFunction(slotList);
+    ReturnValue_t result = customChecker(slotList, customCheckArgs);
     if (result != HasReturnvaluesIF::RETURN_OK) {
       // Continue for now but print error output.
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -161,8 +161,9 @@ ReturnValue_t FixedSlotSequence::intializeSequenceAfterTaskCreation() const {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-void FixedSlotSequence::addCustomCheck(ReturnValue_t (*customCheckFunction)(const SlotList&)) {
+void FixedSlotSequence::addCustomCheck(CustomCheckFunc customChecker_, void* checkerArgs_) {
-  this->customCheckFunction = customCheckFunction;
+  customChecker = customChecker_;
+  customCheckArgs = checkerArgs_;
 }
 
 bool FixedSlotSequence::isEmpty() const { return slotList.empty(); }

src/fsfw/tasks/FixedSlotSequence.h

@@ -30,7 +30,7 @@ class FixedSlotSequence {
  public:
   using SlotList = std::multiset<FixedSequenceSlot>;
   using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
-
+  using CustomCheckFunc = ReturnValue_t (*)(const SlotList&, void* args);
   /**
    * @brief	The constructor of the FixedSlotSequence object.
    * @param	setLength	The period length, expressed in ms.
@@ -106,7 +106,7 @@ class FixedSlotSequence {
   /**
    * @brief	This method returns the length of this FixedSlotSequence instance.
    */
-  uint32_t getLengthMs() const;
+  [[nodiscard]] uint32_t getLengthMs() const;
 
   /**
    * @brief	The method to execute the device handler entered in the current
@@ -137,7 +137,7 @@ class FixedSlotSequence {
    * @return
    *  - SLOT_LIST_EMPTY if the slot list is empty
    */
-  ReturnValue_t checkSequence() const;
+  [[nodiscard]] ReturnValue_t checkSequence() const;
 
   /**
    * @brief   A custom check can be injected for the respective slot list.
@@ -149,7 +149,7 @@ class FixedSlotSequence {
    * @param customCheckFunction
    *
    */
-  void addCustomCheck(ReturnValue_t (*customCheckFunction)(const SlotList&));
+  void addCustomCheck(CustomCheckFunc func, void* userArgs);
 
   /**
    * @brief 	Perform any initialization steps required after the executing
@@ -157,9 +157,9 @@ class FixedSlotSequence {
    * 			executing task!
    * @return
    */
-  ReturnValue_t intializeSequenceAfterTaskCreation() const;
+  [[nodiscard]] ReturnValue_t intializeSequenceAfterTaskCreation() const;
 
-  bool isEmpty() const;
+  [[nodiscard]] bool isEmpty() const;
 
  protected:
   /**
@@ -175,7 +175,8 @@ class FixedSlotSequence {
    */
   SlotList slotList;
 
-  ReturnValue_t (*customCheckFunction)(const SlotList&) = nullptr;
+  CustomCheckFunc customChecker = nullptr;
+  void* customCheckArgs = nullptr;
 
   uint32_t lengthMs;
 };

src/fsfw/tasks/FixedTimeslotTaskBase.cpp

@@ -11,19 +11,17 @@ bool FixedTimeslotTaskBase::isEmpty() const { return pollingSeqTable.isEmpty();
 
 ReturnValue_t FixedTimeslotTaskBase::checkSequence() { return pollingSeqTable.checkSequence(); }
 
-ReturnValue_t FixedTimeslotTaskBase::addSlot(object_id_t componentId, uint32_t slotTimeMs,
+ReturnValue_t FixedTimeslotTaskBase::addSlot(object_id_t execId, ExecutableObjectIF* execObj,
-                                             int8_t executionStep) {
+                                             uint32_t slotTimeMs, int8_t executionStep) {
-  auto* executableObject = ObjectManager::instance()->get<ExecutableObjectIF>(componentId);
+  if (execObj == nullptr) {
-  if (executableObject != nullptr) {
-    pollingSeqTable.addSlot(componentId, slotTimeMs, executionStep, executableObject, this);
-    return HasReturnvaluesIF::RETURN_OK;
-  }
-
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::error << "Component 0x" << std::hex << std::setw(8) << std::setfill('0') << componentId
+    sif::error << "Component 0x" << std::hex << std::setw(8) << std::setfill('0') << execObj
-             << std::setfill(' ') << " not found, not adding it to PST" << std::dec << std::endl;
+               << std::setfill(' ') << " not found, not adding it to PST" << std::dec << std::endl;
 #else
-  sif::printError("Component 0x%08x not found, not adding it to PST\n");
+    sif::printError("Component 0x%08x not found, not adding it to PST\n");
 #endif
-  return HasReturnvaluesIF::RETURN_FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  pollingSeqTable.addSlot(execId, slotTimeMs, executionStep, execObj, this);
+  return HasReturnvaluesIF::RETURN_OK;
 }

src/fsfw/tasks/FixedTimeslotTaskBase.h

@@ -37,7 +37,7 @@ class FixedTimeslotTaskBase : public FixedTimeslotTaskIF {
 
   [[nodiscard]] bool isEmpty() const override;
 
-  ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
+  ReturnValue_t addSlot(object_id_t execId, ExecutableObjectIF* componentId, uint32_t slotTimeMs,
                         int8_t executionStep) override;
 };
 

src/fsfw/tasks/FixedTimeslotTaskIF.h

@@ -2,6 +2,7 @@
 #define FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_
 
 #include "PeriodicTaskIF.h"
+#include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/objectmanager/ObjectManagerIF.h"
 #include "fsfw/returnvalues/FwClassIds.h"
 
@@ -15,6 +16,19 @@ class FixedTimeslotTaskIF : public PeriodicTaskIF {
 
   static constexpr ReturnValue_t SLOT_LIST_EMPTY =
       HasReturnvaluesIF::makeReturnCode(CLASS_ID::FIXED_SLOT_TASK_IF, 0);
+
+  /**
+   * Add an object with a slot time and the execution step to the task.
+   * The execution step will be passed to the object (e.g. as an operation
+   * code in #performOperation)
+   * @param componentId
+   * @param slotTimeMs
+   * @param executionStep
+   * @return
+   */
+  virtual ReturnValue_t addSlot(object_id_t execId, ExecutableObjectIF* obj, uint32_t slotTimeMs,
+                                int8_t executionStep) = 0;
+
   /**
    * Add an object with a slot time and the execution step to the task.
    * The execution step will be passed to the object (e.g. as an operation
@@ -25,12 +39,24 @@ class FixedTimeslotTaskIF : public PeriodicTaskIF {
    * @return
    */
   virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
-                                int8_t executionStep) = 0;
+                                int8_t executionStep) {
+    auto* execObj = ObjectManager::instance()->get<ExecutableObjectIF>(componentId);
+    return addSlot(componentId, execObj, slotTimeMs, executionStep);
+  }
+
   /**
    * Check whether the sequence is valid and perform all other required
    * initialization steps which are needed after task creation
    */
   virtual ReturnValue_t checkSequence() = 0;
+
+  ReturnValue_t addComponent(object_id_t object, uint8_t opCode) override {
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+
+  ReturnValue_t addComponent(ExecutableObjectIF* object, uint8_t opCode) override {
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
 };
 
 #endif /* FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_ */

src/fsfw/tasks/PeriodicTaskBase.cpp

@@ -21,8 +21,14 @@ uint32_t PeriodicTaskBase::getPeriodMs() const { return static_cast<uint32_t>(pe
 
 bool PeriodicTaskBase::isEmpty() const { return objectList.empty(); }
 
+ReturnValue_t PeriodicTaskBase::addComponent(object_id_t object) { return addComponent(object, 0); }
+
+ReturnValue_t PeriodicTaskBase::addComponent(ExecutableObjectIF* object) {
+  return addComponent(object, 0);
+}
+
 ReturnValue_t PeriodicTaskBase::initObjsAfterTaskCreation() {
-  std::multiset<ExecutableObjectIF*> uniqueObjects;
+  std::set<ExecutableObjectIF*> uniqueObjects;
   ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
   uint32_t count = 0;
   for (const auto& obj : objectList) {

src/fsfw/tasks/PeriodicTaskBase.h

@@ -17,6 +17,9 @@ class PeriodicTaskBase : public PeriodicTaskIF {
   ReturnValue_t addComponent(object_id_t object, uint8_t opCode) override;
   ReturnValue_t addComponent(ExecutableObjectIF* object, uint8_t opCode) override;
 
+  ReturnValue_t addComponent(object_id_t object) override;
+  ReturnValue_t addComponent(ExecutableObjectIF* object) override;
+
   [[nodiscard]] uint32_t getPeriodMs() const override;
 
   [[nodiscard]] bool isEmpty() const override;

src/fsfw/tasks/PeriodicTaskIF.h

@@ -31,9 +31,8 @@ class PeriodicTaskIF {
    * @param object Id of the object to add.
    * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
    */
-  virtual ReturnValue_t addComponent(object_id_t object, uint8_t opCode = 0) {
+  virtual ReturnValue_t addComponent(object_id_t object, uint8_t opCode) = 0;
-    return HasReturnvaluesIF::RETURN_FAILED;
+  virtual ReturnValue_t addComponent(object_id_t object) { return addComponent(object, 0); };
-  };
 
   /**
    * Adds an object to the list of objects to be executed.
@@ -41,15 +40,14 @@ class PeriodicTaskIF {
    * @param object pointer to the object to add.
    * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
    */
-  virtual ReturnValue_t addComponent(ExecutableObjectIF* object, uint8_t opCode = 0) {
+  virtual ReturnValue_t addComponent(ExecutableObjectIF* object, uint8_t opCode) = 0;
-    return HasReturnvaluesIF::RETURN_FAILED;
+  virtual ReturnValue_t addComponent(ExecutableObjectIF* object) { return addComponent(object, 0); }
-  };
 
   virtual ReturnValue_t sleepFor(uint32_t ms) = 0;
 
-  virtual uint32_t getPeriodMs() const = 0;
+  [[nodiscard]] virtual uint32_t getPeriodMs() const = 0;
 
-  virtual bool isEmpty() const = 0;
+  [[nodiscard]] virtual bool isEmpty() const = 0;
 };
 
-#endif /* PERIODICTASKIF_H_ */
+#endif /* FRAMEWORK_TASK_PERIODICTASKIF_H_ */