Merge commit 'd9759581' into mohr/introspection

Reviewed-on: fsfw/fsfw#660

.gitignore

@@ -1,6 +1,17 @@
+# PyCharm and CLion
+/.idea/*
+!/.idea/runConfigurations
+!/.idea/cmake.xml
+!/.idea/codeStyles
+
+# Eclipse
 .cproject
 .project
 .settings
 .metadata
 
+# VSCode
+.vscode
+
 /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

@@ -8,23 +8,28 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 # [unreleased]
 
-# [v5.0.0]
+## Added
+
+- Add new `UnsignedByteField` class
+
+# [v5.0.0] 25.07.2022
 
 ## 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
 - `oneShotAction` flag in the `TestTask` class is not static anymore
+- `SimpleRingBuffer::writeData` now checks if the amount is larger than the total size of the 
+  Buffer and rejects such writeData calls with `HasReturnvaluesIF::RETURN_FAILED`
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/586
 - Major update for version handling, using `git describe` to fetch version information with git.
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/601
   - Add helper functions provided by [`cmake-modules`](https://github.com/bilke/cmake-modules)
@@ -42,6 +47,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 +124,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.

CMakeLists.txt

@@ -13,7 +13,7 @@ list(APPEND CMAKE_MODULE_PATH
 # Version file handling  #
 # ##############################################################################
 
-set(FSFW_VERSION_IF_GIT_FAILS 4)
+set(FSFW_VERSION_IF_GIT_FAILS 5)
 set(FSFW_SUBVERSION_IF_GIT_FAILS 0)
 set(FSFW_REVISION_IF_GIT_FAILS 0)
 
@@ -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
-       "Build unittest binary in addition to static library" OFF)
+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()
 
@@ -116,6 +118,12 @@ option(FSFW_ADD_INTERNAL_TESTS "Add internal unit tests" ON)
 option(FSFW_ADD_UNITTESTS "Add regular unittests. Requires Catch2" OFF)
 option(FSFW_ADD_HAL "Add Hardware Abstraction Layer" ON)
 
+if(UNIX)
+  option(FSFW_HAL_LINUX_ADD_PERIPHERAL_DRIVERS "Add Linux peripheral drivers"
+         OFF)
+  option(FSFW_HAL_LINUX_ADD_LIBGPIOD "Attempt to add Linux GPIOD drivers" OFF)
+endif()
+
 # Optional sources
 option(FSFW_ADD_PUS "Compile with PUS sources" ON)
 option(FSFW_ADD_MONITORING "Compile with monitoring components" ON)
@@ -138,7 +146,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 +169,9 @@ if(FSFW_BUILD_UNITTESTS)
     list(APPEND FSFW_FETCH_CONTENT_TARGETS Catch2)
   endif()
 
-  set(FSFW_CONFIG_PATH tests/src/fsfw_tests/unit/testcfg)
-  configure_file(tests/src/fsfw_tests/unit/testcfg/FSFWConfig.h.in FSFWConfig.h)
-  configure_file(tests/src/fsfw_tests/unit/testcfg/TestsConfig.h.in
-                 tests/TestsConfig.h)
+  set(FSFW_CONFIG_PATH unittests/testcfg)
+  configure_file(unittests/testcfg/FSFWConfig.h.in FSFWConfig.h)
+  configure_file(unittests/testcfg/TestsConfig.h.in tests/TestsConfig.h)
 
   project(${FSFW_TEST_TGT} CXX C)
   add_executable(${FSFW_TEST_TGT})
@@ -182,7 +189,10 @@ 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 with version ${FSFW_ETL_LIB_MAJOR_VERSION}"
+)
 
 # Check whether the user has already installed ETL first
 find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} CONFIG QUIET)
@@ -280,16 +290,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 +455,8 @@ target_include_directories(
 target_compile_options(${LIB_FSFW_NAME} PRIVATE ${FSFW_WARNING_FLAGS}
                                                 ${COMPILER_FLAGS})
 
-target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${FSFW_ETL_LINK_TARGET}
-                                               ${FSFW_ADDITIONAL_LINK_LIBS})
+target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${FSFW_ADDITIONAL_LINK_LIBS})
+target_link_libraries(${LIB_FSFW_NAME} PUBLIC ${FSFW_ETL_LINK_TARGET})
 
 string(
   CONCAT

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,15 +131,15 @@ 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
-cmake -DFSFW_BUILD_UNITTESTS=ON -DFSFW_OSAL=host -DCMAKE_BUILD_TYPE=Debug ..
+mkdir build-tests && cd build-tests
+cmake -DFSFW_BUILD_TESTS=ON -DFSFW_OSAL=host -DCMAKE_BUILD_TYPE=Debug ..
 ```
 
 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 ..'
                 }
             }
         }

docs/getting_started.rst

@@ -106,7 +106,7 @@ You can use the following commands inside the ``fsfw`` folder to set up the buil
 .. code-block:: console
 
    mkdir build-tests && cd build-tests
-   cmake -DFSFW_BUILD_UNITTESTS=ON -DFSFW_OSAL=host ..
+   cmake -DFSFW_BUILD_TESTS=ON -DFSFW_OSAL=host ..
 
 
 You can also use ``-DFSFW_OSAL=linux`` on Linux systems.

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

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

hal/src/fsfw_hal/devicehandlers/CMakeLists.txt

@@ -1,5 +0,0 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
-    GyroL3GD20Handler.cpp
-    MgmRM3100Handler.cpp
-    MgmLIS3MDLHandler.cpp
-)

hal/src/fsfw_hal/linux/CMakeLists.txt

@@ -1,25 +0,0 @@
-if(FSFW_HAL_ADD_RASPBERRY_PI)
-    add_subdirectory(rpi)
-endif()
-
-target_sources(${LIB_FSFW_NAME} PRIVATE
-	UnixFileGuard.cpp
-	CommandExecutor.cpp
-	utility.cpp
-)
-
-if(FSFW_HAL_LINUX_ADD_PERIPHERAL_DRIVERS)
-if(FSFW_HAL_LINUX_ADD_LIBGPIOD)
-	add_subdirectory(gpio)
-endif()
-	add_subdirectory(uart)
-	# Adding those does not really make sense on Apple systems which
-	# are generally host systems. It won't even compile as the headers
-	# are missing
-	if(NOT APPLE)
-		add_subdirectory(i2c)
-		add_subdirectory(spi)
-	endif()
-endif()
-
-add_subdirectory(uio)

hal/src/fsfw_hal/linux/gpio/CMakeLists.txt

@@ -1,16 +0,0 @@
-# This abstraction layer requires the gpiod library. You can install this library
-# with "sudo apt-get install -y libgpiod-dev". If you are cross-compiling, you need
-# to install the package before syncing the sysroot to your host computer.
-find_library(LIB_GPIO gpiod)
-
-if(${LIB_GPIO} MATCHES LIB_GPIO-NOTFOUND)
-    message(STATUS "gpiod library not found, not linking against it")
-else()
-    target_sources(${LIB_FSFW_NAME} PRIVATE
-        LinuxLibgpioIF.cpp
-    )
-    target_link_libraries(${LIB_FSFW_NAME} PRIVATE
-        ${LIB_GPIO}
-    )
-endif()
-

hal/src/fsfw_hal/linux/i2c/CMakeLists.txt

@@ -1,8 +0,0 @@
-target_sources(${LIB_FSFW_NAME} PUBLIC
-    I2cComIF.cpp
-    I2cCookie.cpp
-)
-
-
-
-

hal/src/fsfw_hal/linux/rpi/CMakeLists.txt

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

hal/src/fsfw_hal/linux/spi/CMakeLists.txt

@@ -1,8 +0,0 @@
-target_sources(${LIB_FSFW_NAME} PUBLIC
-    SpiComIF.cpp
-    SpiCookie.cpp
-)
-
-
-
-

hal/src/fsfw_hal/linux/uart/CMakeLists.txt

@@ -1,4 +0,0 @@
-target_sources(${LIB_FSFW_NAME} PUBLIC
-	UartComIF.cpp
-	UartCookie.cpp
-)

hal/src/fsfw_hal/linux/uio/CMakeLists.txt

@@ -1,3 +0,0 @@
-target_sources(${LIB_FSFW_NAME} PUBLIC
-	UioMapper.cpp
-)

hal/src/fsfw_hal/stm32h7/devicetest/CMakeLists.txt

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

hal/src/fsfw_hal/stm32h7/gpio/CMakeLists.txt

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

hal/src/fsfw_hal/stm32h7/i2c/CMakeLists.txt

@@ -1,2 +0,0 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
-)

hal/src/fsfw_hal/stm32h7/spi/CMakeLists.txt

@@ -1,9 +0,0 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
-    spiCore.cpp
-    spiDefinitions.cpp
-    spiInterrupts.cpp
-    mspInit.cpp
-    SpiCookie.cpp
-    SpiComIF.cpp
-    stm32h743zi.cpp
-)

hal/src/fsfw_hal/stm32h7/uart/CMakeLists.txt

@@ -1,2 +0,0 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
-)

scripts/auto-formatter.sh

@@ -5,8 +5,7 @@ fi
 
 folder_list=(
   "./src"
-  "./hal"
-  "./tests"
+  "./unittests"
 )
 
 cmake_fmt="cmake-format"

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

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

src/fsfw/action/Action.cpp

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

src/fsfw/action/Action.h

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

src/fsfw/action/ActionHelper.cpp

@@ -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) {
@@ -57,18 +57,40 @@ void ActionHelper::finish(bool success, MessageQueueId_t reportTo, ActionId_t co
 
 void ActionHelper::setQueueToUse(MessageQueueIF* queue) { queueToUse = queue; }
 
+#include <stdio.h>
+
 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) {
     CommandMessage reply;
     ActionMessage::setStepReply(&reply, actionId, 0, result);
     queueToUse->sendMessage(commandedBy, &reply);
+    ipcStore->deleteData(dataAddress);
     return;
   }
-  result = owner->executeAction(actionId, commandedBy, dataPtr, size);
+  auto actionIter = actionMap.find(actionId);
+  if (actionIter == actionMap.end()){
+    CommandMessage reply;
+    ActionMessage::setStepReply(&reply, actionId, 0, HasActionsIF::INVALID_ACTION_ID);
+    queueToUse->sendMessage(commandedBy, &reply);
+    ipcStore->deleteData(dataAddress);
+    return;
+  }
+  Action* action = actionIter->second;
+  result = action->deSerialize(&dataPtr, &size, SerializeIF::Endianness::NETWORK);
+  if ((result != HasReturnvaluesIF::RETURN_OK) || (size != 0)){ //TODO write unittest for second condition
+    CommandMessage reply;
+    ActionMessage::setStepReply(&reply, actionId, 0, HasActionsIF::INVALID_PARAMETERS);
+    queueToUse->sendMessage(commandedBy, &reply);
+    ipcStore->deleteData(dataAddress);
+    return;
+  }
+  //TODO call action->check()
+  action->commandedBy = commandedBy;
+  result = owner->executeAction(action);
   ipcStore->deleteData(dataAddress);
   if (result == HasActionsIF::EXECUTION_FINISHED) {
     CommandMessage reply;
@@ -163,3 +185,11 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo, ActionId_t rep
   }
   return result;
 }
+
+void ActionHelper::registerAction(Action* action) {
+  //TODO error handling
+  ActionId_t id = action->getId();
+  actionMap.emplace(id, action);
+}
+
+std::map<ActionId_t, Action*> const* ActionHelper::getActionMap() { return &actionMap; }

src/fsfw/action/ActionHelper.h

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

src/fsfw/action/ActionMessage.cpp

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

src/fsfw/action/CMakeLists.txt

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

src/fsfw/action/CommandActionHelper.cpp

@@ -2,14 +2,14 @@
 #include "fsfw/objectmanager/ObjectManager.h"
 
 CommandActionHelper::CommandActionHelper(CommandsActionsIF *setOwner)
-    : owner(setOwner), queueToUse(NULL), ipcStore(NULL), commandCount(0), lastTarget(0) {}
+    : owner(setOwner), queueToUse(nullptr), ipcStore(nullptr), commandCount(0), lastTarget(0) {}
 
-CommandActionHelper::~CommandActionHelper() {}
+CommandActionHelper::~CommandActionHelper() = default;
 
 ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo, ActionId_t actionId,
                                                  SerializeIF *data) {
-  HasActionsIF *receiver = ObjectManager::instance()->get<HasActionsIF>(commandTo);
-  if (receiver == NULL) {
+  auto *receiver = ObjectManager::instance()->get<HasActionsIF>(commandTo);
+  if (receiver == nullptr) {
     return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
   }
   store_address_t storeId;
@@ -29,11 +29,8 @@ ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo, ActionId
 
 ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo, ActionId_t actionId,
                                                  const uint8_t *data, uint32_t size) {
-  //    if (commandCount != 0) {
-  //        return CommandsFunctionsIF::ALREADY_COMMANDING;
-  //    }
-  HasActionsIF *receiver = ObjectManager::instance()->get<HasActionsIF>(commandTo);
-  if (receiver == NULL) {
+  auto *receiver = ObjectManager::instance()->get<HasActionsIF>(commandTo);
+  if (receiver == nullptr) {
     return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
   }
   store_address_t storeId;
@@ -59,12 +56,12 @@ ReturnValue_t CommandActionHelper::sendCommand(MessageQueueId_t queueId, ActionI
 
 ReturnValue_t CommandActionHelper::initialize() {
   ipcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
-  if (ipcStore == NULL) {
+  if (ipcStore == nullptr) {
     return HasReturnvaluesIF::RETURN_FAILED;
   }
 
   queueToUse = owner->getCommandQueuePtr();
-  if (queueToUse == NULL) {
+  if (queueToUse == nullptr) {
     return HasReturnvaluesIF::RETURN_FAILED;
   }
   return HasReturnvaluesIF::RETURN_OK;
@@ -104,7 +101,7 @@ ReturnValue_t CommandActionHelper::handleReply(CommandMessage *reply) {
 uint8_t CommandActionHelper::getCommandCount() const { return commandCount; }
 
 void CommandActionHelper::extractDataForOwner(ActionId_t actionId, store_address_t storeId) {
-  const uint8_t *data = NULL;
+  const uint8_t *data = nullptr;
   size_t size = 0;
   ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
   if (result != HasReturnvaluesIF::RETURN_OK) {

src/fsfw/action/CommandActionHelper.h

@@ -14,14 +14,14 @@ class CommandActionHelper {
   friend class CommandsActionsIF;
 
  public:
-  CommandActionHelper(CommandsActionsIF* owner);
+  explicit CommandActionHelper(CommandsActionsIF* owner);
   virtual ~CommandActionHelper();
   ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId,
                               const uint8_t* data = nullptr, uint32_t size = 0);
   ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId, 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,16 @@ 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;
+
+  [[nodiscard]] virtual ActionHelper* getActionHelper() = 0;
+
   /**
    * Execute or initialize the execution of a certain function.
    * The ActionHelpers will execute this function and behave differently
@@ -55,8 +59,7 @@ class HasActionsIF {
    * -@c EXECUTION_FINISHED Finish reply will be generated
    * -@c Not RETURN_OK Step failure reply will be generated
    */
-  virtual ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                                      const uint8_t* data, size_t size) = 0;
+  virtual ReturnValue_t executeAction(Action* action) = 0;
 };
 
 #endif /* FSFW_ACTION_HASACTIONSIF_H_ */

src/fsfw/action/MinMaxParameter.h

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

src/fsfw/action/Parameter.h

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

src/fsfw/action/ParameterIF.h

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

src/fsfw/action/SimpleActionHelper.cpp

@@ -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,17 +38,33 @@ 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) {
     ActionMessage::setStepReply(&reply, actionId, 0, result);
     queueToUse->sendMessage(commandedBy, &reply);
+    ipcStore->deleteData(dataAddress);
     return;
   }
-  lastCommander = commandedBy;
-  lastAction = actionId;
-  result = owner->executeAction(actionId, commandedBy, dataPtr, size);
+  auto actionIter = actionMap.find(actionId);
+  if (actionIter == actionMap.end()){
+    CommandMessage reply;
+    ActionMessage::setStepReply(&reply, actionId, 0, HasActionsIF::INVALID_ACTION_ID);
+    queueToUse->sendMessage(commandedBy, &reply);
+    ipcStore->deleteData(dataAddress);
+    return;
+  }
+  Action* action = actionIter->second;
+  result = action->deSerialize(&dataPtr, &size, SerializeIF::Endianness::NETWORK);
+  if (result != HasReturnvaluesIF::RETURN_OK){
+    CommandMessage reply;
+    ActionMessage::setStepReply(&reply, actionId, 0, HasActionsIF::INVALID_PARAMETERS);
+    queueToUse->sendMessage(commandedBy, &reply);
+    ipcStore->deleteData(dataAddress);
+    return;
+  }
+  result = action->handle();
   ipcStore->deleteData(dataAddress);
   switch (result) {
     case 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);
-  virtual void resetHelper();
+                        store_address_t dataAddress) override;
+  void resetHelper() override;
 
  private:
   bool isExecuting;
@@ -28,4 +28,4 @@ class SimpleActionHelper : public ActionHelper {
   uint8_t stepCount = 0;
 };
 
-#endif /* SIMPLEACTIONHELPER_H_ */
+#endif /* FSFW_ACTION_SIMPLEACTIONHELPER_H_ */

src/fsfw/action/TemplateAction.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "Action.h"
+
+template <class owner, class action, class ActionEnum>
+class TemplateAction : public Action {
+ public:
+#ifdef FSFW_INTROSPECTION
+  TemplateAction(owner *myOwner, ActionEnum id) : Action(), myOwner(myOwner) {
+    Action::setEnum(&id);
+    myOwner->getActionHelper()->registerAction(this);
+  }
+#else
+  TemplateAction(owner *myOwner, ActionEnum id) : Action((uint32_t) id), myOwner(myOwner) {
+    myOwner->getActionHelper()->registerAction(this);
+  }
+#endif
+
+  ReturnValue_t handle() override { return myOwner->handleAction(dynamic_cast<action *>(this)); }
+
+ private:
+  owner *myOwner;
+};

src/fsfw/container/SimpleRingBuffer.cpp

@@ -2,6 +2,9 @@
 
 #include <cstring>
 
+#include "fsfw/FSFW.h"
+#include "fsfw/serviceinterface.h"
+
 SimpleRingBuffer::SimpleRingBuffer(const size_t size, bool overwriteOld, size_t maxExcessBytes)
     : RingBufferBase<>(0, size, overwriteOld), maxExcessBytes(maxExcessBytes) {
   if (maxExcessBytes > size) {
@@ -48,6 +51,19 @@ void SimpleRingBuffer::confirmBytesWritten(size_t amount) {
 }
 
 ReturnValue_t SimpleRingBuffer::writeData(const uint8_t* data, size_t amount) {
+  if (data == nullptr) {
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  if (amount > getMaxSize()) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "SimpleRingBuffer::writeData: Amount of data too large" << std::endl;
+#else
+    sif::printError("SimpleRingBuffer::writeData: Amount of data too large\n");
+#endif
+#endif
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
   if (availableWriteSpace() >= amount or overwriteOld) {
     size_t amountTillWrap = writeTillWrap();
     if (amountTillWrap >= amount) {

src/fsfw/controller/ControllerBase.cpp

@@ -28,7 +28,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 +54,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 +75,20 @@ void ControllerBase::handleQueue() {
   }
 }
 
-void ControllerBase::startTransition(Mode_t mode, Submode_t submode) {
+void ControllerBase::startTransition(Mode_t mode_, Submode_t submode_) {
   changeHK(this->mode, this->submode, false);
   triggerEvent(CHANGING_MODE, mode, submode);
-  this->mode = mode;
-  this->submode = submode;
+  mode = mode_;
+  submode = submode_;
   modeHelper.modeChanged(mode, submode);
   modeChanged(mode, submode);
   announceMode(false);
   changeHK(this->mode, this->submode, true);
 }
 
-void ControllerBase::getMode(Mode_t* mode, Submode_t* submode) {
-  *mode = this->mode;
-  *submode = this->submode;
+void ControllerBase::getMode(Mode_t* mode_, Submode_t* submode_) {
+  *mode_ = this->mode;
+  *submode_ = this->submode;
 }
 
 void ControllerBase::setToExternalControl() { healthHelper.setHealth(EXTERNAL_CONTROL); }
@@ -101,7 +101,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 +117,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;
-  virtual HasHealthIF::HealthState getHealth() override;
+  ReturnValue_t setHealth(HealthState health) override;
+  HasHealthIF::HealthState getHealth() override;
 
   /** ExecutableObjectIF overrides */
-  virtual ReturnValue_t performOperation(uint8_t opCode) override;
-  virtual void setTaskIF(PeriodicTaskIF *task) override;
-  virtual ReturnValue_t initializeAfterTaskCreation() override;
+  ReturnValue_t performOperation(uint8_t opCode) override;
+  void setTaskIF(PeriodicTaskIF *task) override;
+  ReturnValue_t initializeAfterTaskCreation() override;
 
  protected:
   /**
@@ -54,8 +54,8 @@ class ControllerBase : public HasModesIF,
    */
   virtual void performControlOperation() = 0;
 
-  virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-                                         uint32_t *msToReachTheMode) override = 0;
+  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+                                 uint32_t *msToReachTheMode) override = 0;
 
   const object_id_t parentId;
 
@@ -80,10 +80,10 @@ class ControllerBase : public HasModesIF,
 
   /** Mode helpers */
   virtual void modeChanged(Mode_t mode, Submode_t submode);
-  virtual void startTransition(Mode_t mode, Submode_t submode) override;
-  virtual void getMode(Mode_t *mode, Submode_t *submode) override;
-  virtual void setToExternalControl() override;
-  virtual void announceMode(bool recursive);
+  void startTransition(Mode_t mode, Submode_t submode) override;
+  void getMode(Mode_t *mode, Submode_t *submode) override;
+  void setToExternalControl() override;
+  void announceMode(bool recursive) override;
   /** HK helpers */
   virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
 };

src/fsfw/controller/ExtendedControllerBase.cpp

@@ -6,13 +6,14 @@ 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,
-                                                    const uint8_t *data, size_t size) {
-  /* Needs to be overriden and implemented by child class. */
-  return HasReturnvaluesIF::RETURN_OK;
+ActionHelper *ExtendedControllerBase::getActionHelper() {
+  return &actionHelper;
+}
+
+ReturnValue_t ExtendedControllerBase::executeAction(Action *action) {
+  return action->handle();
 }
 
 object_id_t ExtendedControllerBase::getObjectId() const { return SystemObject::getObjectId(); }
@@ -31,7 +32,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,20 @@ class ExtendedControllerBase : public ControllerBase,
                                public HasLocalDataPoolIF {
  public:
   ExtendedControllerBase(object_id_t objectId, object_id_t parentId, size_t commandQueueDepth = 3);
-  virtual ~ExtendedControllerBase();
+  ~ExtendedControllerBase() override;
 
   /* SystemObjectIF overrides */
-  virtual ReturnValue_t initialize() override;
+  ReturnValue_t initialize() override;
 
-  virtual MessageQueueId_t getCommandQueue() const override;
+  [[nodiscard]] MessageQueueId_t getCommandQueue() const override;
 
   /* ExecutableObjectIF overrides */
-  virtual ReturnValue_t performOperation(uint8_t opCode) override;
-  virtual ReturnValue_t initializeAfterTaskCreation() override;
+  ReturnValue_t performOperation(uint8_t opCode) override;
+  ReturnValue_t initializeAfterTaskCreation() override;
+
+  /* HasActionsIF overrides */
+  ActionHelper* getActionHelper() override;
+  ReturnValue_t executeAction(Action* actionId) override;
 
  protected:
   LocalDataPoolManager poolManager;
@@ -39,32 +43,28 @@ class ExtendedControllerBase : public ControllerBase,
    * @param message
    * @return
    */
-  virtual ReturnValue_t handleCommandMessage(CommandMessage* message) = 0;
+  ReturnValue_t handleCommandMessage(CommandMessage* message) override = 0;
 
   /**
    * Periodic helper from ControllerBase, implemented by child class.
    */
-  virtual void performControlOperation() = 0;
+  void performControlOperation() override = 0;
 
   /* Handle the four messages mentioned above */
   void handleQueue() override;
 
-  /* HasActionsIF overrides */
-  virtual ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                                      const uint8_t* data, size_t size) override;
-
   /* HasLocalDatapoolIF overrides */
-  virtual LocalDataPoolManager* getHkManagerHandle() override;
-  virtual object_id_t getObjectId() const override;
-  virtual uint32_t getPeriodicOperationFrequency() const override;
+  LocalDataPoolManager* getHkManagerHandle() override;
+  [[nodiscard]] object_id_t getObjectId() const override;
+  [[nodiscard]] uint32_t getPeriodicOperationFrequency() const override;
 
-  virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
-                                                LocalDataPoolManager& poolManager) override = 0;
-  virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override = 0;
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+                                        LocalDataPoolManager& poolManager) override = 0;
+  LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override = 0;
 
   // Mode abstract functions
-  virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-                                         uint32_t* msToReachTheMode) override = 0;
+  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+                                 uint32_t* msToReachTheMode) override = 0;
 };
 
 #endif /* FSFW_CONTROLLER_EXTENDEDCONTROLLERBASE_H_ */

src/fsfw/datapoollocal/LocalDataPoolManager.cpp

@@ -577,8 +577,9 @@ 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);
+    if (result == WRONG_HK_PACKET_TYPE) {
+      printWarningOrError(sif::OutputTypes::OUT_WARNING, "handleHousekeepingMessage",
+                          WRONG_HK_PACKET_TYPE);
     }
     HousekeepingMessage::setHkRequestFailureReply(&reply, sid, result);
   } else {
@@ -699,7 +700,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

src/fsfw/devicehandlers/DeviceHandlerBase.cpp

@@ -63,7 +63,9 @@ void DeviceHandlerBase::setThermalStateRequestPoolIds(lp_id_t thermalStatePoolId
 }
 
 DeviceHandlerBase::~DeviceHandlerBase() {
-  delete comCookie;
+  if (comCookie != nullptr) {
+    delete comCookie;
+  }
   if (defaultFDIRUsed) {
     delete fdirInstance;
   }
@@ -247,15 +249,14 @@ void DeviceHandlerBase::decrementDeviceReplyMap() {
   for (std::pair<const DeviceCommandId_t, DeviceReplyInfo>& replyPair : deviceReplyMap) {
     if (replyPair.second.countdown != nullptr && replyPair.second.active) {
       if (replyPair.second.countdown->hasTimedOut()) {
+        resetTimeoutControlledReply(&replyPair.second);
         timedOut = true;
       }
     }
     if (replyPair.second.delayCycles != 0 && replyPair.second.countdown == nullptr) {
       replyPair.second.delayCycles--;
       if (replyPair.second.delayCycles == 0) {
-        if (replyPair.second.periodic) {
-          replyPair.second.delayCycles = replyPair.second.maxDelayCycles;
-        }
+        resetDelayCyclesControlledReply(&replyPair.second);
         timedOut = true;
       }
     }
@@ -263,7 +264,6 @@ void DeviceHandlerBase::decrementDeviceReplyMap() {
       replyToReply(replyPair.first, replyPair.second, TIMEOUT);
       missedReply(replyPair.first);
       timedOut = false;
-      replyPair.second.active = false;
     }
   }
 }
@@ -451,9 +451,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 +523,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;
@@ -846,9 +853,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 +874,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 +883,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 +1014,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;
@@ -1316,22 +1325,25 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* dataSet, DeviceCommandId_t r
   }
 }
 
-ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                                               const uint8_t* data, size_t size) {
+ActionHelper *DeviceHandlerBase::getActionHelper() {
+  return &actionHelper;
+}
+
+ReturnValue_t DeviceHandlerBase::executeAction(Action *action) {
   ReturnValue_t result = acceptExternalDeviceCommands();
   if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
-  DeviceCommandMap::iterator iter = deviceCommandMap.find(actionId);
+  DeviceCommandMap::iterator iter = deviceCommandMap.find(action->getId());
   if (iter == deviceCommandMap.end()) {
     result = COMMAND_NOT_SUPPORTED;
   } else if (iter->second.isExecuting) {
     result = COMMAND_ALREADY_SENT;
   } else {
-    result = buildCommandFromCommand(actionId, data, size);
+    result = action->handle();
   }
   if (result == RETURN_OK) {
-    iter->second.sendReplyTo = commandedBy;
+    iter->second.sendReplyTo = action->commandedBy;
     iter->second.isExecuting = true;
     cookieInfo.pendingCommand = iter;
     cookieInfo.state = COOKIE_WRITE_READY;
@@ -1405,7 +1417,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;
 }
@@ -1581,8 +1598,7 @@ void DeviceHandlerBase::disableCommandsAndReplies() {
     if (!reply.second.periodic) {
       if (reply.second.countdown != nullptr) {
         reply.second.countdown->timeOut();
-      }
-      else {
+      } else {
         reply.second.delayCycles = 0;
       }
       reply.second.active = false;

src/fsfw/devicehandlers/DeviceHandlerBase.h

@@ -204,9 +204,9 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    */
   virtual void setParentQueue(MessageQueueId_t parentQueueId);
 
-  /** @brief  Implementation required for HasActionIF */
-  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                              const uint8_t *data, size_t size) override;
+  /** @brief  Implementations required for HasActionIF */
+  ActionHelper* getActionHelper() override;
+  ReturnValue_t executeAction(Action *action) override;
 
   Mode_t getTransitionSourceMode() const;
   Submode_t getTransitionSourceSubMode() const;
@@ -314,6 +314,8 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    *    - Anything else triggers an even with the returnvalue as a parameter
    */
   virtual ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) = 0;
+  
+  //TODO Remove and update documentation
   /**
    * @brief 	Build a device command packet from data supplied by a direct
    *          command (PUS Service 8)
@@ -469,12 +471,21 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * @param maxDelayCycles The maximum number of delay cycles the reply waits
    *    until it times out.
    * @param periodic	Indicates if the command is periodic (i.e. it is sent
+<<<<<<< HEAD
    *    by the device repeatedly without request) or not. Default is aperiodic (0).
    *    Please note that periodic replies are disabled by default. You can enable them with
    *    #updatePeriodicReply
    * @param countdown Instead of using maxDelayCycles to timeout a device reply it is also possible
    *    to provide a pointer to a Countdown object which will signal the timeout
    *    when expired
+=======
+   * by the device repeatedly without request) or not. Default is aperiodic (0).
+   * Please note that periodic replies are disabled by default. You can enable them with
+   * #updatePeriodicReply
+   * @param countdown Instead of using maxDelayCycles to timeout a device reply it is also possible
+   *                  to provide a pointer to a Countdown object which will signal the timeout
+   *                  when expired
+>>>>>>> upstream/development
    * @return	- @c RETURN_OK when the command was successfully inserted,
    *          - @c RETURN_FAILED else.
    */
@@ -1274,15 +1285,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.

src/fsfw/events/EventManager.cpp

@@ -100,6 +100,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,

src/fsfw/events/EventManager.h

@@ -37,6 +37,7 @@ 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,

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

@@ -15,6 +15,16 @@ FailureIsolationBase::FailureIsolationBase(object_id_t owner, object_id_t parent
 }
 
 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);
 }
 

src/fsfw/fdir/FaultCounter.cpp

@@ -60,14 +60,14 @@ ReturnValue_t FaultCounter::getParameter(uint8_t domainId, uint8_t uniqueId,
     return INVALID_DOMAIN_ID;
   }
 
-  switch (uniqueId) {
-    case 0:
+  switch (static_cast<ParameterIds>(uniqueId)) {
+    case ParameterIds::FAILURE_THRESHOLD:
       parameterWrapper->set(failureThreshold);
       break;
-    case 1:
+    case ParameterIds::FAULT_COUNT:
       parameterWrapper->set(faultCount);
       break;
-    case 2:
+    case ParameterIds::TIMEOUT:
       parameterWrapper->set(timer.timeout);
       break;
     default:

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

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

src/fsfw/introspection/ClasslessEnum.h

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

src/fsfw/introspection/Enum.h

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

src/fsfw/introspection/EnumCommon.h

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

src/fsfw/introspection/EnumIF.h

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

src/fsfw/introspection/ParameterTypeSelector.cpp

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

src/fsfw/introspection/ParameterTypeSelector.h

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

src/fsfw/introspection/Types.h

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

src/fsfw/introspection/TypesHelper.h

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

src/fsfw/objectmanager/SystemObjectIF.h

@@ -16,7 +16,7 @@
  * This is the typedef for object identifiers.
  * @ingroup system_objects
  */
-typedef uint32_t object_id_t;
+using object_id_t = uint32_t;
 
 /**
  * This interface allows a class to be included in the object manager

src/fsfw/osal/CMakeLists.txt

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

src/fsfw/osal/freertos/FixedTimeslotTask.cpp

@@ -1,27 +1,23 @@
 #include "fsfw/osal/freertos/FixedTimeslotTask.h"
 
-#include "fsfw/objectmanager/ObjectManager.h"
-#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw/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,
-                                     void (*setDeadlineMissedFunc)())
-    : started(false), handle(nullptr), pst(overallPeriod * 1000) {
+                                     TaskStackSize setStack, TaskPeriod period,
+                                     TaskDeadlineMissedFunction dlmFunc_)
+    : 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,
-                                         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() {
+[[noreturn]] 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();
-    if (not pst.slotFollowsImmediately()) {
+    this->pollingSeqTable.executeAndAdvance();
+    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) {
-    this->deadlineMissedFunc();
+  if (dlmFunc != nullptr) {
+    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/Typedef.h"
+#include "fsfw/tasks/FixedTimeslotTaskBase.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);
-  /**
-   * 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 startTask() 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)
-    : started(false), handle(NULL), period(setPeriod), deadlineMissedFunc(deadlineMissedFunc) {
+                           TaskPeriod setPeriod, TaskDeadlineMissedFunction dlmFunc_)
+    : 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. "
-                  "Status: "
+    sif::debug << "PeriodicTask::PeriodicTask Insufficient heap memory remaining. 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) {
-    object->initializeAfterTaskCreation();
-  }
+  initObjsAfterTaskCreation();
 
   /* 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) {
-      object->performOperation();
+    for (auto const& objectPair : objectList) {
+      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) {
-    this->deadlineMissedFunc();
+  if (dlmFunc != nullptr) {
+    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/Typedef.h"
+#include "fsfw/tasks/PeriodicTaskBase.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() {
-  pollingSeqTable.intializeSequenceAfterTaskCreation();
+void FixedTimeslotTask::taskFunctionality() {
+  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,9 +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;
 #else
         sif::printError(

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,
-                                     void (*setDeadlineMissedFunc)(void))
-    : RTEMSTaskBase(setPriority, setStack, name), periodId(0), pst(setOverallPeriod) {
-  // All additional attributes are applied to the object.
-  this->deadlineMissedFunc = setDeadlineMissedFunc;
-}
+                                     size_t setStack, TaskPeriod setOverallPeriod,
+                                     TaskDeadlineMissedFunction dlmFunc_)
+    : FixedTimeslotTaskBase(setOverallPeriod, dlmFunc_),
+      RTEMSTaskBase(setPriority, setStack, name),
+      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,
-                                         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() {
+[[noreturn]] 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) {
-    if (pst.slotFollowsImmediately()) {
+  while (true) {
+    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) {
-          this->deadlineMissedFunc();
+        if (dlmFunc != nullptr) {
+          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);
-
-  uint32_t getPeriodMs() const;
-
-  ReturnValue_t checkSequence() const;
-
-  ReturnValue_t sleepFor(uint32_t ms);
+  ReturnValue_t sleepFor(uint32_t ms) override;
 
  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,
-               size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE,
-               MqArgs* args = nullptr);
+  explicit MessageQueue(size_t message_depth = 3,
+                        size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE,
+                        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,
-                                bool ignoreFault = false) override;
+                                MessageQueueId_t sentFrom, bool ignoreFault) override;
 
  private:
   /**
-   * \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
+   * @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
    * 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)())
-    : RTEMSTaskBase(setPriority, setStack, name),
-      periodTicks(RtemsBasic::convertMsToTicks(setPeriod)),
-      deadlineMissedFunc(setDeadlineMissedFunc) {}
+                           TaskPeriod setPeriod, TaskDeadlineMissedFunction dlmFunc_)
+    : PeriodicTaskBase(setPeriod, dlmFunc_),
+      RTEMSTaskBase(setPriority, setStack, name),
+      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
-               << " failed." << std::endl;
+    sif::error << "PeriodicTask::startTask for " << std::hex << this->getId() << std::dec
+               << " 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) {
-    object->initializeAfterTaskCreation();
-  }
+  initObjsAfterTaskCreation();
+
   /* The task's "infinite" inner loop is entered. */
-  while (1) {
-    for (const auto& object : objectList) {
-      object->performOperation();
+  while (true) {
+    for (const auto& objectPair : objectList) {
+      objectPair.first->performOperation(objectPair.second);
     }
     rtems_status_code status = RTEMSTaskBase::restartPeriod(periodTicks, periodId);
     if (status == RTEMS_TIMEOUT) {
-      if (this->deadlineMissedFunc != nullptr) {
-        this->deadlineMissedFunc();
+      if (dlmFunc != nullptr) {
+        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);
-  /**
-   * 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 startTask() 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_, taskPeriod, deadLineMissedFunction_));
+  return static_cast<PeriodicTaskIF*>(new PeriodicTask(name_, taskPriority_, stackSize_,
+                                                       periodInSeconds_, 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(name_, taskPriority_, stackSize_, taskPeriod, deadLineMissedFunction_));
+  return static_cast<FixedTimeslotTaskIF*>(new FixedTimeslotTask(
+      name_, taskPriority_, stackSize_, periodInSeconds_, 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/power/PowerSwitchIF.h

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

src/fsfw/pus/Service11TelecommandScheduling.tpp

@@ -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"
-               << std::endl;
+  sif::debug << "Service11TelecommandScheduling::debugPrintMultimapContent: Multimap Content"
+             << 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(
-        "Service11TelecommandScheduling::debugPrintMultimapContent: Multimap Content\n");
-    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
+    sif::printDebug("[%d]: Request ID: %d  | Store Address: %d\n", dit.first, dit.second.requestId,
+                    dit.second.storeAddr);
 #endif
   }
+#endif
 }
 
 template <size_t MAX_NUM_TCS>

src/fsfw/pus/Service3Housekeeping.cpp

@@ -248,16 +248,21 @@ void Service3Housekeeping::handleUnrequestedReply(CommandMessage* reply) {
     case (HousekeepingMessage::HK_REQUEST_FAILURE): {
       break;
     }
-    case(CommandMessage::REPLY_REJECTED): {
+    case (CommandMessage::REPLY_REJECTED): {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::warning << "Service3Housekeeping::handleUnrequestedReply: Unexpected reply "
-          "rejected with error code" << reply->getParameter() << std::endl;
+                      "rejected with error code"
+                   << reply->getParameter() << std::endl;
+#else
+#endif
       break;
     }
 
     default: {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::warning << "Service3Housekeeping::handleUnrequestedReply: Invalid reply with reply "
-                      "command " << command << "" << std::endl;
+                      "command "
+                   << command << "" << std::endl;
 #else
       sif::printWarning(
           "Service3Housekeeping::handleUnrequestedReply: Invalid reply with "

src/fsfw/serialize.h

@@ -1,10 +1,10 @@
 #ifndef FSFW_INC_FSFW_SERIALIZE_H_
 #define FSFW_INC_FSFW_SERIALIZE_H_
 
-#include "src/core/serialize/EndianConverter.h"
-#include "src/core/serialize/SerialArrayListAdapter.h"
-#include "src/core/serialize/SerialBufferAdapter.h"
-#include "src/core/serialize/SerialLinkedListAdapter.h"
-#include "src/core/serialize/SerializeElement.h"
+#include "fsfw/serialize/EndianConverter.h"
+#include "fsfw/serialize/SerialArrayListAdapter.h"
+#include "fsfw/serialize/SerialBufferAdapter.h"
+#include "fsfw/serialize/SerialLinkedListAdapter.h"
+#include "fsfw/serialize/SerializeElement.h"
 
 #endif /* FSFW_INC_FSFW_SERIALIZE_H_ */