more clang-tidy improvements

Reviewed-on: fsfw/fsfw#643

.gitignore

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

.idea/codeStyles/Project.xml

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

.idea/codeStyles/codeStyleConfig.xml

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

.run/fsfw-tests_coverage.run.xml

@@ -0,0 +1,7 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="fsfw-tests_coverage" type="CMakeRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" PASS_PARENT_ENVS_2="true" PROJECT_NAME="fsfw-example-hosted" TARGET_NAME="fsfw-tests_coverage" CONFIG_NAME="Debug Unittest" RUN_TARGET_PROJECT_NAME="fsfw-example-hosted" RUN_TARGET_NAME="fsfw-tests">
+    <method v="2">
+      <option name="com.jetbrains.cidr.execution.CidrBuildBeforeRunTaskProvider$BuildBeforeRunTask" enabled="true" />
+    </method>
+  </configuration>
+</component>

.run/fsfw.run.xml

@@ -0,0 +1,7 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="fsfw" type="CMakeRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" PASS_PARENT_ENVS_2="true" PROJECT_NAME="fsfw-tests" TARGET_NAME="fsfw" CONFIG_NAME="Debug Unittest" RUN_TARGET_PROJECT_NAME="fsfw-tests" RUN_TARGET_NAME="fsfw-tests">
+    <method v="2">
+      <option name="com.jetbrains.cidr.execution.CidrBuildBeforeRunTaskProvider$BuildBeforeRunTask" enabled="true" />
+    </method>
+  </configuration>
+</component>

CHANGELOG.md

@@ -12,6 +12,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Changes
 
+- Renamed auto-formatting script to `auto-formatter.sh` and made it more robust.
+  If `cmake-format` is installed, it will also auto-format the `CMakeLists.txt` files now.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/625
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/626
 - Bump C++ required version to C++17. Every project which uses the FSFW and every modern
   compiler supports it
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/622
@@ -43,6 +47,38 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
   the message queue. Also streamlined and simplified `MessageQueue` implementation for all OSALs
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/583
 
+### 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
 
 - HAL Linux Uart: Baudrate and bits per word are enums now, avoiding misconfigurations
@@ -84,6 +120,11 @@ https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593
 
 ## Additions
 
+- 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

@@ -71,7 +71,7 @@ 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)
 
@@ -105,6 +105,7 @@ endif()
 
 option(FSFW_BUILD_UNITTESTS
        "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)
   option(FSFW_TESTS_GEN_COV "Generate coverage data for unittests" ON)

README.md

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

automation/Jenkinsfile

@@ -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_UNITTESTS=ON -DFSFW_CICD_BUILD=ON ..'
                 }
             }
         }

hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp

@@ -17,8 +17,6 @@ MgmLIS3MDLHandler::MgmLIS3MDLHandler(object_id_t objectId, object_id_t deviceCom
   registers[4] = MGMLIS3MDL::CTRL_REG5_DEFAULT;
 }
 
-MgmLIS3MDLHandler::~MgmLIS3MDLHandler() {}
-
 void MgmLIS3MDLHandler::doStartUp() {
   switch (internalState) {
     case (InternalState::STATE_NONE): {
@@ -90,7 +88,7 @@ ReturnValue_t MgmLIS3MDLHandler::buildTransitionDeviceCommand(DeviceCommandId_t
 
 uint8_t MgmLIS3MDLHandler::readCommand(uint8_t command, bool continuousCom) {
   command |= (1 << MGMLIS3MDL::RW_BIT);
-  if (continuousCom == true) {
+  if (continuousCom) {
     command |= (1 << MGMLIS3MDL::MS_BIT);
   }
   return command;
@@ -98,7 +96,7 @@ uint8_t MgmLIS3MDLHandler::readCommand(uint8_t command, bool continuousCom) {
 
 uint8_t MgmLIS3MDLHandler::writeCommand(uint8_t command, bool continuousCom) {
   command &= ~(1 << MGMLIS3MDL::RW_BIT);
-  if (continuousCom == true) {
+  if (continuousCom) {
     command |= (1 << MGMLIS3MDL::MS_BIT);
   }
   return command;

hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h

@@ -28,7 +28,7 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase {
 
   MgmLIS3MDLHandler(uint32_t objectId, object_id_t deviceCommunication, CookieIF *comCookie,
                     uint32_t transitionDelay);
-  virtual ~MgmLIS3MDLHandler();
+  ~MgmLIS3MDLHandler() override = default;
 
   void enablePeriodicPrintouts(bool enable, uint8_t divider);
   /**
@@ -46,7 +46,7 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase {
   void doShutDown() override;
   void doStartUp() override;
   void doTransition(Mode_t modeFrom, Submode_t subModeFrom) override;
-  virtual uint32_t getTransitionDelayMs(Mode_t from, Mode_t to) override;
+  uint32_t getTransitionDelayMs(Mode_t from, Mode_t to) override;
   ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
                                         size_t commandDataLen) override;
   ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
@@ -60,9 +60,9 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase {
    * @param packet
    * @return
    */
-  virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
+  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
   void fillCommandAndReplyMap() override;
-  void modeChanged(void) override;
+  void modeChanged() override;
   ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                         LocalDataPoolManager &poolManager) override;
 
@@ -72,8 +72,6 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase {
   static const uint8_t SINGLE_COMMAND_ANSWER_LEN = 2;
 
   uint32_t transitionDelay;
-  // Single SPI command has 2 bytes, first for adress, second for content
-  size_t singleComandSize = 2;
   // Has the size for all adresses of the lis3mdl + the continous write bit
   uint8_t commandBuffer[MGMLIS3MDL::NR_OF_DATA_AND_CFG_REGISTERS + 1];
 
@@ -88,7 +86,6 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase {
    */
   uint8_t registers[MGMLIS3MDL::NR_OF_CTRL_REGISTERS];
 
-  uint8_t statusRegister = 0;
   bool goToNormalMode = false;
 
   enum class InternalState {
@@ -111,14 +108,14 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase {
    * @param single command to set the read-bit at
    * @param boolean to select a continuous read bit, default = false
    */
-  uint8_t readCommand(uint8_t command, bool continuousCom = false);
+  static uint8_t readCommand(uint8_t command, bool continuousCom = false);
 
   /**
    * Sets the write bit for the command
    * @param single command to set the write-bit at
    * @param boolean to select a continuous write bit, default = false
    */
-  uint8_t writeCommand(uint8_t command, bool continuousCom = false);
+  static uint8_t writeCommand(uint8_t command, bool continuousCom = false);
 
   /**
    * This Method gets the full scale for the measurement range

hal/src/fsfw_hal/devicehandlers/MgmRM3100Handler.cpp

@@ -329,9 +329,9 @@ ReturnValue_t MgmRM3100Handler::handleDataReadout(const uint8_t *packet) {
   int32_t fieldStrengthRawZ = ((packet[7] << 24) | (packet[8] << 16) | (packet[3] << 8)) >> 8;
 
   // Now scale to physical value in microtesla
-  float fieldStrengthX = fieldStrengthRawX * scaleFactorX;
-  float fieldStrengthY = fieldStrengthRawY * scaleFactorX;
-  float fieldStrengthZ = fieldStrengthRawZ * scaleFactorX;
+  float fieldStrengthX = static_cast<float>(fieldStrengthRawX) * scaleFactorX;
+  float fieldStrengthY = static_cast<float>(fieldStrengthRawY) * scaleFactorY;
+  float fieldStrengthZ = static_cast<float>(fieldStrengthRawZ) * scaleFactorZ;
 
   if (periodicPrintout) {
     if (debugDivider.checkAndIncrement()) {

hal/src/fsfw_hal/devicehandlers/MgmRM3100Handler.h

@@ -72,7 +72,6 @@ class MgmRM3100Handler : public DeviceHandlerBase {
   RM3100::Rm3100PrimaryDataset primaryDataset;
 
   uint8_t commandBuffer[10];
-  uint8_t commandBufferLen = 0;
 
   uint8_t cmmRegValue = RM3100::CMM_VALUE;
   uint8_t tmrcRegValue = RM3100::TMRC_DEFAULT_VALUE;
@@ -100,4 +99,4 @@ class MgmRM3100Handler : public DeviceHandlerBase {
   PeriodicOperationDivider debugDivider = PeriodicOperationDivider(3);
 };
 
-#endif /* MISSION_DEVICEHANDLING_MGMRM3100HANDLER_H_ */
+#endif /* MISSION_DEVICES_MGMRM3100HANDLER_H_ */

hal/src/fsfw_hal/linux/spi/SpiComIF.cpp

@@ -210,7 +210,7 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
 #endif
       return result;
     }
-    ReturnValue_t result = gpioComIF->pullLow(gpioId);
+    result = gpioComIF->pullLow(gpioId);
     if (result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1

hal/src/fsfw_hal/stm32h7/devicetest/GyroL3GD20H.h

@@ -10,6 +10,10 @@
 #include "stm32h7xx_hal.h"
 #include "stm32h7xx_hal_spi.h"
 
+#ifndef STM_USE_PERIPHERAL_TX_BUFFER_MPU_PROTECTION
+#define STM_USE_PERIPHERAL_TX_BUFFER_MPU_PROTECTION 1
+#endif
+
 enum class TransferStates { IDLE, WAIT, SUCCESS, FAILURE };
 
 class GyroL3GD20H {

src/fsfw/action/ActionHelper.cpp

@@ -6,7 +6,7 @@
 ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue)
     : owner(setOwner), queueToUse(useThisQueue) {}
 
-ActionHelper::~ActionHelper() {}
+ActionHelper::~ActionHelper() = default;
 
 ReturnValue_t ActionHelper::handleActionMessage(CommandMessage* command) {
   if (command->getCommand() == ActionMessage::EXECUTE_ACTION) {
@@ -59,7 +59,7 @@ void ActionHelper::setQueueToUse(MessageQueueIF* queue) { queueToUse = queue; }
 
 void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
                                     store_address_t dataAddress) {
-  const uint8_t* dataPtr = NULL;
+  const uint8_t* dataPtr = nullptr;
   size_t size = 0;
   ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
   if (result != HasReturnvaluesIF::RETURN_OK) {

src/fsfw/action/ActionHelper.h

@@ -1,9 +1,9 @@
 #ifndef FSFW_ACTION_ACTIONHELPER_H_
 #define FSFW_ACTION_ACTIONHELPER_H_
 
-#include "../ipc/MessageQueueIF.h"
-#include "../serialize/SerializeIF.h"
 #include "ActionMessage.h"
+#include "fsfw/ipc/MessageQueueIF.h"
+#include "fsfw/serialize/SerializeIF.h"
 /**
  * @brief Action Helper is a helper class which handles action messages
  *

src/fsfw/action/ActionMessage.cpp

@@ -2,9 +2,9 @@
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/storagemanager/StorageManagerIF.h"
 
-ActionMessage::ActionMessage() {}
+ActionMessage::ActionMessage() = default;
 
-ActionMessage::~ActionMessage() {}
+ActionMessage::~ActionMessage() = default;
 
 void ActionMessage::setCommand(CommandMessage* message, ActionId_t fid,
                                store_address_t parameters) {
@@ -64,9 +64,8 @@ void ActionMessage::clear(CommandMessage* message) {
   switch (message->getCommand()) {
     case EXECUTE_ACTION:
     case DATA_REPLY: {
-      StorageManagerIF* ipcStore =
-          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/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,
                               uint32_t size);
   ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId, SerializeIF* data);
   ReturnValue_t initialize();
   ReturnValue_t handleReply(CommandMessage* reply);
-  uint8_t getCommandCount() const;
+  [[nodiscard]] uint8_t getCommandCount() const;
 
  private:
   CommandsActionsIF* owner;

src/fsfw/action/CommandsActionsIF.h

@@ -1,9 +1,9 @@
 #ifndef FSFW_ACTION_COMMANDSACTIONSIF_H_
 #define FSFW_ACTION_COMMANDSACTIONSIF_H_
 
-#include "../ipc/MessageQueueIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
 #include "CommandActionHelper.h"
+#include "fsfw/ipc/MessageQueueIF.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
 
 /**
  * Interface to separate commanding actions of other objects.
@@ -21,7 +21,7 @@ class CommandsActionsIF {
   static const uint8_t INTERFACE_ID = CLASS_ID::COMMANDS_ACTIONS_IF;
   static const ReturnValue_t OBJECT_HAS_NO_FUNCTIONS = MAKE_RETURN_CODE(1);
   static const ReturnValue_t ALREADY_COMMANDING = MAKE_RETURN_CODE(2);
-  virtual ~CommandsActionsIF() {}
+  virtual ~CommandsActionsIF() = default;
   virtual MessageQueueIF* getCommandQueuePtr() = 0;
 
  protected:

src/fsfw/action/HasActionsIF.h

@@ -1,11 +1,11 @@
 #ifndef FSFW_ACTION_HASACTIONSIF_H_
 #define FSFW_ACTION_HASACTIONSIF_H_
 
-#include "../ipc/MessageQueueIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
 #include "ActionHelper.h"
 #include "ActionMessage.h"
 #include "SimpleActionHelper.h"
+#include "fsfw/ipc/MessageQueueIF.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
 
 /**
  * @brief
@@ -40,12 +40,12 @@ class HasActionsIF {
   static const ReturnValue_t INVALID_PARAMETERS = MAKE_RETURN_CODE(2);
   static const ReturnValue_t EXECUTION_FINISHED = MAKE_RETURN_CODE(3);
   static const ReturnValue_t INVALID_ACTION_ID = MAKE_RETURN_CODE(4);
-  virtual ~HasActionsIF() {}
+  virtual ~HasActionsIF() = default;
   /**
    * Function to get the MessageQueueId_t of the implementing object
    * @return MessageQueueId_t of the object
    */
-  virtual MessageQueueId_t getCommandQueue() const = 0;
+  [[nodiscard]] virtual MessageQueueId_t getCommandQueue() const = 0;
   /**
    * Execute or initialize the execution of a certain function.
    * The ActionHelpers will execute this function and behave differently

src/fsfw/action/SimpleActionHelper.cpp

@@ -3,7 +3,7 @@
 SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue)
     : ActionHelper(setOwner, useThisQueue), isExecuting(false) {}
 
-SimpleActionHelper::~SimpleActionHelper() {}
+SimpleActionHelper::~SimpleActionHelper() = default;
 
 void SimpleActionHelper::step(ReturnValue_t result) {
   // STEP_OFFESET is subtracted to compensate for adding offset in base
@@ -38,7 +38,7 @@ void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId
     ActionMessage::setStepReply(&reply, actionId, 0, HasActionsIF::IS_BUSY);
     queueToUse->sendMessage(commandedBy, &reply);
   }
-  const uint8_t* dataPtr = NULL;
+  const uint8_t* dataPtr = nullptr;
   size_t size = 0;
   ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
   if (result != HasReturnvaluesIF::RETURN_OK) {

src/fsfw/action/SimpleActionHelper.h

@@ -11,15 +11,15 @@
 class SimpleActionHelper : public ActionHelper {
  public:
   SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
-  virtual ~SimpleActionHelper();
+  ~SimpleActionHelper() override;
   void step(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
   void finish(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
   ReturnValue_t reportData(SerializeIF* data);
 
  protected:
   void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
-                        store_address_t dataAddress);
-  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/cfdp/pdu/AckInfo.cpp

@@ -13,10 +13,12 @@ AckInfo::AckInfo(cfdp::FileDirectives ackedDirective, cfdp::ConditionCode ackedC
   }
 }
 
+AckInfo::AckInfo() = default;
+
 cfdp::ConditionCode AckInfo::getAckedConditionCode() const { return ackedConditionCode; }
 
-void AckInfo::setAckedConditionCode(cfdp::ConditionCode ackedConditionCode) {
-  this->ackedConditionCode = ackedConditionCode;
+void AckInfo::setAckedConditionCode(cfdp::ConditionCode ackedConditionCode_) {
+  ackedConditionCode = ackedConditionCode_;
   if (ackedDirective == cfdp::FileDirectives::FINISH) {
     this->directiveSubtypeCode = 0b0001;
   } else {
@@ -26,20 +28,18 @@ void AckInfo::setAckedConditionCode(cfdp::ConditionCode ackedConditionCode) {
 
 cfdp::FileDirectives AckInfo::getAckedDirective() const { return ackedDirective; }
 
-void AckInfo::setAckedDirective(cfdp::FileDirectives ackedDirective) {
-  this->ackedDirective = ackedDirective;
+void AckInfo::setAckedDirective(cfdp::FileDirectives ackedDirective_) {
+  ackedDirective = ackedDirective_;
 }
 
 uint8_t AckInfo::getDirectiveSubtypeCode() const { return directiveSubtypeCode; }
 
-void AckInfo::setDirectiveSubtypeCode(uint8_t directiveSubtypeCode) {
-  this->directiveSubtypeCode = directiveSubtypeCode;
+void AckInfo::setDirectiveSubtypeCode(uint8_t directiveSubtypeCode_) {
+  directiveSubtypeCode = directiveSubtypeCode_;
 }
 
 cfdp::AckTransactionStatus AckInfo::getTransactionStatus() const { return transactionStatus; }
 
-AckInfo::AckInfo() {}
-
-void AckInfo::setTransactionStatus(cfdp::AckTransactionStatus transactionStatus) {
-  this->transactionStatus = transactionStatus;
+void AckInfo::setTransactionStatus(cfdp::AckTransactionStatus transactionStatus_) {
+  transactionStatus = transactionStatus_;
 }

src/fsfw/cfdp/pdu/AckInfo.h

@@ -9,16 +9,16 @@ class AckInfo {
   AckInfo(cfdp::FileDirectives ackedDirective, cfdp::ConditionCode ackedConditionCode,
           cfdp::AckTransactionStatus transactionStatus, uint8_t directiveSubtypeCode = 0);
 
-  cfdp::ConditionCode getAckedConditionCode() const;
-  void setAckedConditionCode(cfdp::ConditionCode ackedConditionCode);
+  [[nodiscard]] cfdp::ConditionCode getAckedConditionCode() const;
+  void setAckedConditionCode(cfdp::ConditionCode ackedConditionCode_);
 
-  cfdp::FileDirectives getAckedDirective() const;
+  [[nodiscard]] cfdp::FileDirectives getAckedDirective() const;
   void setAckedDirective(cfdp::FileDirectives ackedDirective);
 
-  uint8_t getDirectiveSubtypeCode() const;
+  [[nodiscard]] uint8_t getDirectiveSubtypeCode() const;
   void setDirectiveSubtypeCode(uint8_t directiveSubtypeCode);
 
-  cfdp::AckTransactionStatus getTransactionStatus() const;
+  [[nodiscard]] cfdp::AckTransactionStatus getTransactionStatus() const;
   void setTransactionStatus(cfdp::AckTransactionStatus transactionStatus);
 
  private:

src/fsfw/cfdp/pdu/AckPduDeserializer.h

@@ -13,7 +13,7 @@ class AckPduDeserializer : public FileDirectiveDeserializer {
    * @return
    *  - cfdp::INVALID_DIRECTIVE_FIELDS: Invalid fields
    */
-  ReturnValue_t parseData();
+  ReturnValue_t parseData() override;
 
  private:
   bool checkAndSetCodes(uint8_t rawAckedByte, uint8_t rawAckedConditionCode);

src/fsfw/cfdp/pdu/AckPduSerializer.h

@@ -18,7 +18,7 @@ class AckPduSerializer : public FileDirectiveSerializer {
    */
   AckPduSerializer(AckInfo& ackInfo, PduConfig& pduConf);
 
-  size_t getSerializedSize() const override;
+  [[nodiscard]] size_t getSerializedSize() const override;
 
   ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
                           Endianness streamEndianness) const override;

src/fsfw/controller/ControllerBase.cpp

@@ -26,7 +26,7 @@ ReturnValue_t ControllerBase::initialize() {
 
   MessageQueueId_t parentQueue = 0;
   if (parentId != objects::NO_OBJECT) {
-    SubsystemBase* parent = ObjectManager::instance()->get<SubsystemBase>(parentId);
+    auto* parent = ObjectManager::instance()->get<SubsystemBase>(parentId);
     if (parent == nullptr) {
       return RETURN_FAILED;
     }
@@ -52,7 +52,7 @@ MessageQueueId_t ControllerBase::getCommandQueue() const { return commandQueue->
 
 void ControllerBase::handleQueue() {
   CommandMessage command;
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result;
   for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
        result = commandQueue->receiveMessage(&command)) {
     result = modeHelper.handleModeCommand(&command);
@@ -73,20 +73,20 @@ void ControllerBase::handleQueue() {
   }
 }
 
-void ControllerBase::startTransition(Mode_t mode, Submode_t submode) {
+void ControllerBase::startTransition(Mode_t mode_, Submode_t submode_) {
   changeHK(this->mode, this->submode, false);
   triggerEvent(CHANGING_MODE, mode, submode);
-  this->mode = mode;
-  this->submode = submode;
+  mode = mode_;
+  submode = submode_;
   modeHelper.modeChanged(mode, submode);
   modeChanged(mode, submode);
   announceMode(false);
   changeHK(this->mode, this->submode, true);
 }
 
-void ControllerBase::getMode(Mode_t* mode, Submode_t* submode) {
-  *mode = this->mode;
-  *submode = this->submode;
+void ControllerBase::getMode(Mode_t* mode_, Submode_t* submode_) {
+  *mode_ = this->mode;
+  *submode_ = this->submode;
 }
 
 void ControllerBase::setToExternalControl() { healthHelper.setHealth(EXTERNAL_CONTROL); }
@@ -99,7 +99,7 @@ ReturnValue_t ControllerBase::performOperation(uint8_t opCode) {
   return RETURN_OK;
 }
 
-void ControllerBase::modeChanged(Mode_t mode, Submode_t submode) { return; }
+void ControllerBase::modeChanged(Mode_t mode_, Submode_t submode_) {}
 
 ReturnValue_t ControllerBase::setHealth(HealthState health) {
   switch (health) {
@@ -115,6 +115,6 @@ ReturnValue_t ControllerBase::setHealth(HealthState health) {
 HasHealthIF::HealthState ControllerBase::getHealth() { return healthHelper.getHealth(); }
 void ControllerBase::setTaskIF(PeriodicTaskIF* task_) { executingTask = task_; }
 
-void ControllerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {}
+void ControllerBase::changeHK(Mode_t mode_, Submode_t submode_, bool enable) {}
 
 ReturnValue_t ControllerBase::initializeAfterTaskCreation() { return HasReturnvaluesIF::RETURN_OK; }

src/fsfw/controller/ControllerBase.h

@@ -24,21 +24,21 @@ class ControllerBase : public HasModesIF,
   static const Mode_t MODE_NORMAL = 2;
 
   ControllerBase(object_id_t setObjectId, object_id_t parentId, size_t commandQueueDepth = 3);
-  virtual ~ControllerBase();
+  ~ControllerBase() override;
 
   /** SystemObject override */
-  virtual ReturnValue_t initialize() override;
+  ReturnValue_t initialize() override;
 
-  virtual MessageQueueId_t getCommandQueue() const override;
+  [[nodiscard]] MessageQueueId_t getCommandQueue() const override;
 
   /** HasHealthIF overrides */
-  virtual ReturnValue_t setHealth(HealthState health) override;
-  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,7 +6,7 @@ ExtendedControllerBase::ExtendedControllerBase(object_id_t objectId, object_id_t
       poolManager(this, commandQueue),
       actionHelper(this, commandQueue) {}
 
-ExtendedControllerBase::~ExtendedControllerBase() {}
+ExtendedControllerBase::~ExtendedControllerBase() = default;
 
 ReturnValue_t ExtendedControllerBase::executeAction(ActionId_t actionId,
                                                     MessageQueueId_t commandedBy,
@@ -31,7 +31,7 @@ ReturnValue_t ExtendedControllerBase::handleCommandMessage(CommandMessage *messa
 
 void ExtendedControllerBase::handleQueue() {
   CommandMessage command;
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result;
   for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
        result = commandQueue->receiveMessage(&command)) {
     result = actionHelper.handleActionMessage(&command);

src/fsfw/controller/ExtendedControllerBase.h

@@ -18,16 +18,16 @@ class ExtendedControllerBase : public ControllerBase,
                                public HasLocalDataPoolIF {
  public:
   ExtendedControllerBase(object_id_t objectId, object_id_t parentId, size_t commandQueueDepth = 3);
-  virtual ~ExtendedControllerBase();
+  ~ExtendedControllerBase() override;
 
   /* SystemObjectIF overrides */
-  virtual ReturnValue_t initialize() override;
+  ReturnValue_t initialize() override;
 
-  virtual MessageQueueId_t getCommandQueue() const override;
+  [[nodiscard]] MessageQueueId_t getCommandQueue() const override;
 
   /* ExecutableObjectIF overrides */
-  virtual ReturnValue_t performOperation(uint8_t opCode) override;
-  virtual ReturnValue_t initializeAfterTaskCreation() override;
+  ReturnValue_t performOperation(uint8_t opCode) override;
+  ReturnValue_t initializeAfterTaskCreation() override;
 
  protected:
   LocalDataPoolManager poolManager;
@@ -39,32 +39,32 @@ class ExtendedControllerBase : public ControllerBase,
    * @param message
    * @return
    */
-  virtual ReturnValue_t handleCommandMessage(CommandMessage* message) = 0;
+  ReturnValue_t handleCommandMessage(CommandMessage* message) override = 0;
 
   /**
    * Periodic helper from ControllerBase, implemented by child class.
    */
-  virtual void performControlOperation() = 0;
+  void performControlOperation() override = 0;
 
   /* Handle the four messages mentioned above */
   void handleQueue() override;
 
   /* HasActionsIF overrides */
-  virtual ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                                      const uint8_t* data, size_t size) override;
+  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+                              const uint8_t* data, size_t size) override;
 
   /* HasLocalDatapoolIF overrides */
-  virtual LocalDataPoolManager* getHkManagerHandle() override;
-  virtual object_id_t getObjectId() const override;
-  virtual uint32_t getPeriodicOperationFrequency() const override;
+  LocalDataPoolManager* getHkManagerHandle() override;
+  [[nodiscard]] object_id_t getObjectId() const override;
+  [[nodiscard]] uint32_t getPeriodicOperationFrequency() const override;
 
-  virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
-                                                LocalDataPoolManager& poolManager) override = 0;
-  virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override = 0;
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+                                        LocalDataPoolManager& poolManager) override = 0;
+  LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override = 0;
 
   // Mode abstract functions
-  virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-                                         uint32_t* msToReachTheMode) override = 0;
+  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+                                 uint32_t* msToReachTheMode) override = 0;
 };
 
 #endif /* FSFW_CONTROLLER_EXTENDEDCONTROLLERBASE_H_ */

src/fsfw/datapool/DataSetIF.h

@@ -30,7 +30,7 @@ class DataSetIF {
    * @brief	This is an empty virtual destructor,
    * 			as it is proposed for C++ interfaces.
    */
-  virtual ~DataSetIF() {}
+  virtual ~DataSetIF() = default;
 
   /**
    * @brief	This operation provides a method to register local data pool
@@ -39,7 +39,7 @@ class DataSetIF {
    */
   virtual ReturnValue_t registerVariable(PoolVariableIF* variable) = 0;
 
-  virtual uint16_t getFillCount() const = 0;
+  [[nodiscard]] virtual uint16_t getFillCount() const = 0;
 };
 
 #endif /* FSFW_DATAPOOL_DATASETIF_H_ */

src/fsfw/datapool/PoolDataSetBase.cpp

@@ -9,7 +9,7 @@ PoolDataSetBase::PoolDataSetBase(PoolVariableIF** registeredVariablesArray,
                                  const size_t maxFillCount)
     : registeredVariables(registeredVariablesArray), maxFillCount(maxFillCount) {}
 
-PoolDataSetBase::~PoolDataSetBase() {}
+PoolDataSetBase::~PoolDataSetBase() = default;
 
 ReturnValue_t PoolDataSetBase::registerVariable(PoolVariableIF* variable) {
   if (registeredVariables == nullptr) {

src/fsfw/datapool/PoolDataSetBase.h

@@ -64,8 +64,8 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF, public HasRetu
    * - @c SET_WAS_ALREADY_READ if read() is called twice without calling
    *      commit() in between
    */
-  virtual ReturnValue_t read(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-                             uint32_t lockTimeout = 20) override;
+  ReturnValue_t read(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+                     uint32_t lockTimeout = 20) override;
   /**
    * @brief	The commit call initializes writing back the registered variables.
    * @details
@@ -84,39 +84,38 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF, public HasRetu
    * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
    * 			  contains non write-only variables
    */
-  virtual ReturnValue_t commit(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-                               uint32_t lockTimeout = 20) override;
+  ReturnValue_t commit(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+                       uint32_t lockTimeout = 20) override;
 
   /**
    * Register the passed pool variable instance into the data set.
    * @param variable
    * @return
    */
-  virtual ReturnValue_t registerVariable(PoolVariableIF* variable) override;
+  ReturnValue_t registerVariable(PoolVariableIF* variable) override;
 
   /**
    * Provides the means to lock the underlying data structure to ensure
    * thread-safety. Default implementation is empty
    * @return Always returns -@c RETURN_OK
    */
-  virtual ReturnValue_t lockDataPool(
-      MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-      uint32_t timeoutMs = 20) override;
+  ReturnValue_t lockDataPool(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+                             uint32_t timeoutMs = 20) override;
   /**
    * Provides the means to unlock the underlying data structure to ensure
    * thread-safety. Default implementation is empty
    * @return Always returns -@c RETURN_OK
    */
-  virtual ReturnValue_t unlockDataPool() override;
+  ReturnValue_t unlockDataPool() override;
 
-  virtual uint16_t getFillCount() const override;
+  [[nodiscard]] uint16_t getFillCount() const override;
 
   /* SerializeIF implementations */
-  virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, const size_t maxSize,
-                                  SerializeIF::Endianness streamEndianness) const override;
-  virtual size_t getSerializedSize() const override;
-  virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                                    SerializeIF::Endianness streamEndianness) override;
+  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                          SerializeIF::Endianness streamEndianness) const override;
+  [[nodiscard]] size_t getSerializedSize() const override;
+  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                            SerializeIF::Endianness streamEndianness) override;
 
   /**
    * Can be used to individually protect every read and commit call.
@@ -156,7 +155,7 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF, public HasRetu
   const size_t maxFillCount = 0;
 
   void setContainer(PoolVariableIF** variablesContainer);
-  PoolVariableIF** getContainer() const;
+  [[nodiscard]] PoolVariableIF** getContainer() const;
 
  private:
   bool protectEveryReadCommitCall = false;

src/fsfw/datapool/PoolEntry.cpp

@@ -11,7 +11,7 @@ PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, bool setValid)
     : length(static_cast<uint8_t>(initValue.size())), valid(setValid) {
   this->address = new T[this->length];
   if (initValue.size() == 0) {
-    std::memset(this->address, 0, this->getByteSize());
+    std::memset(this->address, 0, PoolEntry<T>::getByteSize());
   } else {
     std::copy(initValue.begin(), initValue.end(), this->address);
   }
@@ -22,9 +22,9 @@ PoolEntry<T>::PoolEntry(T* initValue, uint8_t setLength, bool setValid)
     : length(setLength), valid(setValid) {
   this->address = new T[this->length];
   if (initValue != nullptr) {
-    std::memcpy(this->address, initValue, this->getByteSize());
+    std::memcpy(this->address, initValue, PoolEntry<T>::getByteSize());
   } else {
-    std::memset(this->address, 0, this->getByteSize());
+    std::memset(this->address, 0, PoolEntry<T>::getByteSize());
   }
 }
 
@@ -62,7 +62,7 @@ bool PoolEntry<T>::getValid() {
 
 template <typename T>
 void PoolEntry<T>::print() {
-  const char* validString = nullptr;
+  const char* validString;
   if (valid) {
     validString = "Valid";
   } else {

src/fsfw/datapool/PoolEntry.h

@@ -62,7 +62,7 @@ class PoolEntry : public PoolEntryIF {
    * @param setValid
    * Sets the initialization flag. It is invalid by default.
    */
-  PoolEntry(T* initValue, uint8_t setLength = 1, bool setValid = false);
+  explicit PoolEntry(T* initValue, uint8_t setLength = 1, bool setValid = false);
 
   //! Explicitely deleted copy ctor, copying is not allowed.
   PoolEntry(const PoolEntry&) = delete;
@@ -77,7 +77,7 @@ class PoolEntry : public PoolEntryIF {
    * PoolEntries shall never be copied, as a copy might delete the variable
    * on the heap.
    */
-  ~PoolEntry();
+  ~PoolEntry() override;
 
   /**
    * Return typed pointer to start of data.
@@ -91,32 +91,32 @@ class PoolEntry : public PoolEntryIF {
    * For non-array pool entries return type size, for vector entries
    * return type size times the number of entries.
    */
-  uint8_t getSize();
+  uint8_t getSize() override;
   /**
    * @brief	This operation returns the size in bytes.
    * @details	The size is calculated by sizeof(type) * array_size.
    */
-  uint16_t getByteSize();
+  uint16_t getByteSize() override;
   /**
    * @brief	This operation returns a the address pointer casted to void*.
    */
-  void* getRawData();
+  void* getRawData() override;
   /**
    * @brief	This method allows to set the valid information
    * 			of the pool entry.
    */
-  void setValid(bool isValid);
+  void setValid(bool isValid) override;
   /**
    * @brief	This method allows to get the valid information
    * 			of the pool entry.
    */
-  bool getValid();
+  bool getValid() override;
   /**
    * @brief	This is a debug method that prints all values and the valid
    * 			information to the screen. It prints all array entries in a row.
    */
-  void print();
-  Type getType();
+  void print() override;
+  Type getType() override;
 
  private:
   /**

src/fsfw/datapool/PoolEntryIF.h

@@ -24,7 +24,7 @@ class PoolEntryIF {
    * @brief	This is an empty virtual destructor,
    * 			as it is required for C++ interfaces.
    */
-  virtual ~PoolEntryIF() {}
+  virtual ~PoolEntryIF() = default;
   /**
    * @brief	getSize returns the array size of the entry.
    * 			A single variable parameter has size 1.

src/fsfw/datapool/PoolReadGuard.h

@@ -11,9 +11,9 @@
  */
 class PoolReadGuard {
  public:
-  PoolReadGuard(ReadCommitIF* readObject,
-                MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-                uint32_t mutexTimeout = 20)
+  explicit PoolReadGuard(ReadCommitIF* readObject,
+                         MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+                         uint32_t mutexTimeout = 20)
       : readObject(readObject), mutexTimeout(mutexTimeout) {
     if (readObject != nullptr) {
       readResult = readObject->read(timeoutType, mutexTimeout);
@@ -29,7 +29,7 @@ class PoolReadGuard {
     }
   }
 
-  ReturnValue_t getReadResult() const { return readResult; }
+  [[nodiscard]] ReturnValue_t getReadResult() const { return readResult; }
 
   /**
    * @brief   Can be used to suppress commit on destruction.

src/fsfw/datapool/PoolVarList.h

@@ -1,28 +0,0 @@
-#ifndef FSFW_DATAPOOL_POOLVARLIST_H_
-#define FSFW_DATAPOOL_POOLVARLIST_H_
-
-#include "../datapool/PoolVariableIF.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
-template <class T, uint8_t n_var>
-class PoolVarList {
- private:
-  GlobPoolVar<T> variables[n_var];
-
- public:
-  PoolVarList(const uint32_t set_id[n_var], DataSetIF* dataSet,
-              PoolVariableIF::ReadWriteMode_t setReadWriteMode) {
-    // I really should have a look at the new init list c++ syntax.
-    if (dataSet == NULL) {
-      return;
-    }
-    for (uint8_t count = 0; count < n_var; count++) {
-      variables[count].dataPoolId = set_id[count];
-      variables[count].readWriteMode = setReadWriteMode;
-      dataSet->registerVariable(&variables[count]);
-    }
-  }
-
-  GlobPoolVar<T>& operator[](int i) { return variables[i]; }
-};
-
-#endif /* FSFW_DATAPOOL_POOLVARLIST_H_ */

src/fsfw/datapool/PoolVariableIF.h

@@ -24,8 +24,8 @@ class PoolVariableIF : public SerializeIF, public ReadCommitIF {
   static constexpr ReturnValue_t INVALID_READ_WRITE_MODE = MAKE_RETURN_CODE(0xA0);
   static constexpr ReturnValue_t INVALID_POOL_ENTRY = MAKE_RETURN_CODE(0xA1);
 
-  static constexpr bool VALID = 1;
-  static constexpr bool INVALID = 0;
+  static constexpr bool VALID = true;
+  static constexpr bool INVALID = false;
   static constexpr uint32_t NO_PARAMETER = 0xffffffff;
 
   enum ReadWriteMode_t { VAR_READ, VAR_WRITE, VAR_READ_WRITE };
@@ -34,23 +34,23 @@ class PoolVariableIF : public SerializeIF, public ReadCommitIF {
    * @brief	This is an empty virtual destructor,
    * 			as it is proposed for C++ interfaces.
    */
-  virtual ~PoolVariableIF() {}
+  ~PoolVariableIF() override = default;
   /**
    * @brief	This method returns if the variable is write-only,
    * 			read-write or read-only.
    */
-  virtual ReadWriteMode_t getReadWriteMode() const = 0;
+  [[nodiscard]] virtual ReadWriteMode_t getReadWriteMode() const = 0;
   virtual void setReadWriteMode(ReadWriteMode_t newMode) = 0;
 
   /**
    * @brief	This operation shall return the data pool id of the variable.
    */
-  virtual uint32_t getDataPoolId() const = 0;
+  [[nodiscard]] virtual uint32_t getDataPoolId() const = 0;
   /**
    * @brief	With this call, the valid information of the
    * 			variable is returned.
    */
-  virtual bool isValid() const = 0;
+  [[nodiscard]] virtual bool isValid() const = 0;
   /**
    * @brief	With this call, the valid information of the variable is set.
    */

src/fsfw/datapool/ReadCommitIF.h

@@ -12,7 +12,7 @@ class ReadCommitIF {
   friend class ReadCommitIFAttorney;
 
  public:
-  virtual ~ReadCommitIF() {}
+  virtual ~ReadCommitIF() = default;
   virtual ReturnValue_t read(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) = 0;
   virtual ReturnValue_t commit(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) = 0;
 

src/fsfw/datapool/SharedDataSetIF.h

@@ -5,7 +5,7 @@
 
 class SharedDataSetIF {
  public:
-  virtual ~SharedDataSetIF(){};
+  virtual ~SharedDataSetIF() = default;
 
  private:
   virtual ReturnValue_t lockDataset(MutexIF::TimeoutType timeoutType,

src/fsfw/datapoollocal/AccessLocalPoolF.h

@@ -9,7 +9,8 @@ class MutexIF;
  */
 class AccessPoolManagerIF {
  public:
-  virtual ~AccessPoolManagerIF(){};
+  virtual ~AccessPoolManagerIF() = default;
+  ;
 
   virtual MutexIF* getLocalPoolMutex() = 0;
 

src/fsfw/datapoollocal/HasLocalDataPoolIF.h

@@ -44,14 +44,15 @@ class HasLocalDataPoolIF {
   friend class HasLocalDpIFUserAttorney;
 
  public:
-  virtual ~HasLocalDataPoolIF(){};
+  virtual ~HasLocalDataPoolIF() = default;
+  ;
 
   static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
 
-  virtual object_id_t getObjectId() const = 0;
+  [[nodiscard]] virtual object_id_t getObjectId() const = 0;
 
   /** Command queue for housekeeping messages. */
-  virtual MessageQueueId_t getCommandQueue() const = 0;
+  [[nodiscard]] virtual MessageQueueId_t getCommandQueue() const = 0;
 
   /**
    * Is used by pool owner to initialize the pool map once
@@ -66,7 +67,7 @@ class HasLocalDataPoolIF {
    * usually be the period the pool owner performs its periodic operation.
    * @return
    */
-  virtual dur_millis_t getPeriodicOperationFrequency() const = 0;
+  [[nodiscard]] virtual dur_millis_t getPeriodicOperationFrequency() const = 0;
 
   /**
    * @brief   This function will be called by the manager if an update

src/fsfw/datapoollocal/LocalDataPoolManager.cpp

@@ -1,6 +1,5 @@
 #include "fsfw/datapoollocal/LocalDataPoolManager.h"
 
-#include <array>
 #include <cmath>
 
 #include "fsfw/datapoollocal.h"
@@ -57,7 +56,7 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
   }
 
   if (defaultHkDestination != objects::NO_OBJECT) {
-    AcceptsHkPacketsIF* hkPacketReceiver =
+    auto* hkPacketReceiver =
         ObjectManager::instance()->get<AcceptsHkPacketsIF>(defaultHkDestination);
     if (hkPacketReceiver != nullptr) {
       hkDestinationId = hkPacketReceiver->getHkQueue();
@@ -209,9 +208,9 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(HkReceiver& recei
     }
 
     /* Prepare and send update snapshot */
-    timeval now;
+    timeval now{};
     Clock::getClock_timeval(&now);
-    CCSDSTime::CDS_short cds;
+    CCSDSTime::CDS_short cds{};
     CCSDSTime::convertToCcsds(&cds, &now);
     HousekeepingSnapshot updatePacket(
         reinterpret_cast<uint8_t*>(&cds), sizeof(cds),
@@ -245,9 +244,9 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(HkReceiver& recei
     }
 
     /* Prepare and send update snapshot */
-    timeval now;
+    timeval now{};
     Clock::getClock_timeval(&now);
-    CCSDSTime::CDS_short cds;
+    CCSDSTime::CDS_short cds{};
     CCSDSTime::convertToCcsds(&cds, &now);
     HousekeepingSnapshot updatePacket(
         reinterpret_cast<uint8_t*>(&cds), sizeof(cds),
@@ -339,8 +338,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid, bool e
                                                                float collectionInterval,
                                                                bool isDiagnostics,
                                                                object_id_t packetDestination) {
-  AcceptsHkPacketsIF* hkReceiverObject =
-      ObjectManager::instance()->get<AcceptsHkPacketsIF>(packetDestination);
+  auto* hkReceiverObject = ObjectManager::instance()->get<AcceptsHkPacketsIF>(packetDestination);
   if (hkReceiverObject == nullptr) {
     printWarningOrError(sif::OutputTypes::OUT_WARNING, "subscribeForPeriodicPacket",
                         QUEUE_OR_DESTINATION_INVALID);
@@ -368,8 +366,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid, bool e
 ReturnValue_t LocalDataPoolManager::subscribeForUpdatePacket(sid_t sid, bool isDiagnostics,
                                                              bool reportingEnabled,
                                                              object_id_t packetDestination) {
-  AcceptsHkPacketsIF* hkReceiverObject =
-      ObjectManager::instance()->get<AcceptsHkPacketsIF>(packetDestination);
+  auto* hkReceiverObject = ObjectManager::instance()->get<AcceptsHkPacketsIF>(packetDestination);
   if (hkReceiverObject == nullptr) {
     printWarningOrError(sif::OutputTypes::OUT_WARNING, "subscribeForPeriodicPacket",
                         QUEUE_OR_DESTINATION_INVALID);
@@ -696,9 +693,10 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
   if (result != HasReturnvaluesIF::RETURN_OK) {
     /* Configuration error */
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "LocalDataPoolManager::performHkOperation: HK generation failed." << std::endl;
+    sif::warning << "LocalDataPoolManager::performPeriodicHkOperation: HK generation failed."
+                 << std::endl;
 #else
-    sif::printWarning("LocalDataPoolManager::performHkOperation: HK generation failed.\n");
+    sif::printWarning("LocalDataPoolManager::performPeriodicHkOperation: HK generation failed.\n");
 #endif
   }
 }

src/fsfw/datapoollocal/LocalDataPoolManager.h

@@ -80,7 +80,7 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
    */
   LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
                        bool appendValidityBuffer = true);
-  virtual ~LocalDataPoolManager();
+  ~LocalDataPoolManager() override;
 
   /**
    * Assigns the queue to use. Make sure to call this in the #initialize
@@ -151,7 +151,7 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
    * Otherwise, only an notification message is sent.
    * @return
    */
-  ReturnValue_t subscribeForSetUpdateMessage(const uint32_t setId, object_id_t destinationObject,
+  ReturnValue_t subscribeForSetUpdateMessage(uint32_t setId, object_id_t destinationObject,
                                              MessageQueueId_t targetQueueId,
                                              bool generateSnapshot) override;
 
@@ -169,7 +169,7 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
    * Otherwise, only an notification message is sent.
    * @return
    */
-  ReturnValue_t subscribeForVariableUpdateMessage(const lp_id_t localPoolId,
+  ReturnValue_t subscribeForVariableUpdateMessage(lp_id_t localPoolId,
                                                   object_id_t destinationObject,
                                                   MessageQueueId_t targetQueueId,
                                                   bool generateSnapshot) override;
@@ -252,7 +252,7 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
    */
   void clearReceiversList();
 
-  object_id_t getCreatorObjectId() const;
+  [[nodiscard]] object_id_t getCreatorObjectId() const;
 
   /**
    * Get the pointer to the mutex. Can be used to lock the data pool
@@ -262,7 +262,7 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
    */
   MutexIF* getMutexHandle();
 
-  virtual LocalDataPoolManager* getPoolManagerHandle() override;
+  LocalDataPoolManager* getPoolManagerHandle() override;
 
  protected:
   /** Core data structure for the actual pool data */
@@ -306,8 +306,8 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
   struct HkUpdateResetHelper {
     DataType dataType = DataType::DATA_SET;
     DataId dataId;
-    uint8_t updateCounter;
-    uint8_t currentUpdateCounter;
+    uint8_t updateCounter{};
+    uint8_t currentUpdateCounter{};
   };
 
   using HkUpdateResetList = std::vector<struct HkUpdateResetHelper>;

src/fsfw/devicehandlers/DeviceHandlerBase.h

@@ -207,13 +207,11 @@ class DeviceHandlerBase : public DeviceHandlerIF,
 
   Mode_t getTransitionSourceMode() const;
   Submode_t getTransitionSourceSubMode() const;
-  virtual void getMode(Mode_t *mode, Submode_t *submode);
-  HealthState getHealth();
-  ReturnValue_t setHealth(HealthState health);
-  virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
-                                     ParameterWrapper *parameterWrapper,
-                                     const ParameterWrapper *newValues,
-                                     uint16_t startAtIndex) override;
+  void getMode(Mode_t *mode, Submode_t *submode) override;
+  HealthState getHealth() override;
+  ReturnValue_t setHealth(HealthState health) override;
+  ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId, ParameterWrapper *parameterWrapper,
+                             const ParameterWrapper *newValues, uint16_t startAtIndex) override;
 
  protected:
   /**
@@ -1042,11 +1040,9 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   bool isAwaitingReply();
 
   void handleDeviceTM(SerializeIF *dataSet, DeviceCommandId_t replyId, bool forceDirectTm = false);
-  //	void handleDeviceTM(uint8_t* data, size_t dataSize, DeviceCommandId_t replyId,
-  //	        bool forceDirectTm);
 
-  virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-                                         uint32_t *msToReachTheMode);
+  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+                                 uint32_t *msToReachTheMode) override;
 
   virtual ReturnValue_t letChildHandleMessage(CommandMessage *message);
 
@@ -1062,8 +1058,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   /**
    * Same as triggerEvent, but for forwarding if object is used as proxy.
    */
-  virtual void forwardEvent(Event event, uint32_t parameter1 = 0,
-                            uint32_t parameter2 = 0) const override;
+  void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const override;
 
   /**
    * Checks if current mode is transitional mode.

src/fsfw/health/HasHealthIF.h

@@ -36,7 +36,7 @@ class HasHealthIF {
       12,
       severity::MEDIUM);  //!< Recovery was completed. Not necessarily successful. No parameters.
 
-  virtual ~HasHealthIF() {}
+  virtual ~HasHealthIF() = default;
 
   virtual MessageQueueId_t getCommandQueue() const = 0;
 

src/fsfw/housekeeping/HousekeepingSnapshot.h

@@ -55,7 +55,7 @@ class HousekeepingSnapshot : public SerializeIF {
       : timeStamp(timeStamp), timeStampSize(timeStampSize), updateData(dataSetPtr){};
 
   virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                                  Endianness streamEndianness) const {
+                                  Endianness streamEndianness) const override {
     if (timeStamp != nullptr) {
       /* Endianness will always be MACHINE, so we can simply use memcpy
       here. */
@@ -70,7 +70,7 @@ class HousekeepingSnapshot : public SerializeIF {
     return updateData->serialize(buffer, size, maxSize, streamEndianness);
   }
 
-  virtual size_t getSerializedSize() const {
+  virtual size_t getSerializedSize() const override {
     if (updateData == nullptr) {
       return 0;
     }

src/fsfw/ipc/MessageQueueBase.h

@@ -10,25 +10,25 @@ class MessageQueueBase : public MessageQueueIF {
   virtual ~MessageQueueBase();
 
   // Default implementations for MessageQueueIF where possible
-  virtual MessageQueueId_t getLastPartner() const override;
-  virtual MessageQueueId_t getId() const override;
-  virtual MqArgs& getMqArgs() override;
-  virtual void setDefaultDestination(MessageQueueId_t defaultDestination) override;
-  virtual MessageQueueId_t getDefaultDestination() const override;
-  virtual bool isDefaultDestinationSet() const override;
-  virtual ReturnValue_t sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
-                                    bool ignoreFault) override;
-  virtual ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
-  virtual ReturnValue_t reply(MessageQueueMessageIF* message) override;
-  virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
-                                       MessageQueueId_t* receivedFrom) override;
-  virtual ReturnValue_t sendToDefaultFrom(MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-                                          bool ignoreFault = false) override;
+  MessageQueueId_t getLastPartner() const override;
+  MessageQueueId_t getId() const override;
+  MqArgs& getMqArgs() override;
+  void setDefaultDestination(MessageQueueId_t defaultDestination) override;
+  MessageQueueId_t getDefaultDestination() const override;
+  bool isDefaultDestinationSet() const override;
+  ReturnValue_t sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
+                            bool ignoreFault) override;
+  ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
+  ReturnValue_t reply(MessageQueueMessageIF* message) override;
+  ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
+                               MessageQueueId_t* receivedFrom) override;
+  ReturnValue_t sendToDefaultFrom(MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+                                  bool ignoreFault = false) override;
 
   // OSAL specific, forward the abstract function
-  virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) = 0;
-  virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
-                                        MessageQueueId_t sentFrom, bool ignoreFault = false) = 0;
+  ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override = 0;
+  ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
+                                MessageQueueId_t sentFrom, bool ignoreFault = false) override = 0;
 
  protected:
   MessageQueueId_t id = MessageQueueIF::NO_QUEUE;

src/fsfw/monitoring/AbsLimitMonitor.h

@@ -17,8 +17,8 @@ class AbsLimitMonitor : public MonitorBase<T> {
         limit(limit),
         violationEvent(violationEvent),
         aboveIsViolation(aboveIsViolation) {}
-  virtual ~AbsLimitMonitor() {}
-  virtual ReturnValue_t checkSample(T sample, T *crossedLimit) {
+  virtual ~AbsLimitMonitor() = default;
+  ReturnValue_t checkSample(T sample, T *crossedLimit) override {
     *crossedLimit = limit;
     if (aboveIsViolation) {
       if ((std::abs(sample) > limit)) {
@@ -32,9 +32,9 @@ class AbsLimitMonitor : public MonitorBase<T> {
     return HasReturnvaluesIF::RETURN_OK;  // We're not out of range.
   }
 
-  virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-                                     ParameterWrapper *parameterWrapper,
-                                     const ParameterWrapper *newValues, uint16_t startAtIndex) {
+  ReturnValue_t getParameter(uint8_t domainId, uint8_t parameterId,
+                             ParameterWrapper *parameterWrapper, const ParameterWrapper *newValues,
+                             uint16_t startAtIndex) override {
     ReturnValue_t result = this->MonitorBase<T>::getParameter(
         domainId, parameterId, parameterWrapper, newValues, startAtIndex);
     // We'll reuse the DOMAIN_ID of MonitorReporter,
@@ -61,7 +61,7 @@ class AbsLimitMonitor : public MonitorBase<T> {
   void setLimit(T value) { limit = value; }
 
  protected:
-  void sendTransitionEvent(T currentValue, ReturnValue_t state) {
+  void sendTransitionEvent(T currentValue, ReturnValue_t state) override {
     switch (state) {
       case MonitoringIF::OUT_OF_RANGE:
         EventManagerIF::triggerEvent(this->reportingId, violationEvent, this->globalPoolId.objectId,

src/fsfw/monitoring/MonitorReporter.h

@@ -51,9 +51,8 @@ class MonitorReporter : public HasParametersIF {
     return state;
   }
 
-  virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
-                                     ParameterWrapper *parameterWrapper,
-                                     const ParameterWrapper *newValues, uint16_t startAtIndex) {
+  ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId, ParameterWrapper *parameterWrapper,
+                             const ParameterWrapper *newValues, uint16_t startAtIndex) override {
     if (domainId != monitorId) {
       return INVALID_DOMAIN_ID;
     }

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::error << "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

@@ -3,9 +3,7 @@
 #include <chrono>
 #include <thread>
 
-#include "fsfw/ipc/MutexFactory.h"
 #include "fsfw/objectmanager/ObjectManager.h"
-#include "fsfw/osal/host/FixedTimeslotTask.h"
 #include "fsfw/osal/host/Mutex.h"
 #include "fsfw/osal/host/taskHelpers.h"
 #include "fsfw/platform.h"
@@ -22,12 +20,8 @@
 
 FixedTimeslotTask::FixedTimeslotTask(const char* name, TaskPriority setPriority,
                                      TaskStackSize setStack, TaskPeriod setPeriod,
-                                     void (*setDeadlineMissedFunc)())
-    : started(false),
-      pollingSeqTable(setPeriod * 1000),
-      taskName(name),
-      period(setPeriod),
-      deadlineMissedFunc(setDeadlineMissedFunc) {
+                                     TaskDeadlineMissedFunction dlmFunc_)
+    : FixedTimeslotTaskBase(setPeriod, dlmFunc_), started(false), taskName(name) {
   // It is propably possible to set task priorities by using the native
   // task handles for Windows / Linux
   mainThread = std::thread(&FixedTimeslotTask::taskEntryPoint, this, this);
@@ -39,7 +33,7 @@ FixedTimeslotTask::FixedTimeslotTask(const char* name, TaskPriority setPriority,
   tasks::insertTaskName(mainThread.get_id(), taskName);
 }
 
-FixedTimeslotTask::~FixedTimeslotTask(void) {
+FixedTimeslotTask::~FixedTimeslotTask() {
   // Do not delete objects, we were responsible for ptrs only.
   terminateThread = true;
   if (mainThread.joinable()) {
@@ -48,7 +42,7 @@ FixedTimeslotTask::~FixedTimeslotTask(void) {
 }
 
 void FixedTimeslotTask::taskEntryPoint(void* argument) {
-  FixedTimeslotTask* originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
+  auto* originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
 
   if (not originalTask->started) {
     // we have to suspend/block here until the task is started.
@@ -81,7 +75,9 @@ ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
 }
 
 void FixedTimeslotTask::taskFunctionality() {
-  pollingSeqTable.intializeSequenceAfterTaskCreation();
+  ReturnValue_t result = pollingSeqTable.intializeSequenceAfterTaskCreation();
+  // Ignore returnvalue for now
+  static_cast<void>(result);
 
   // A local iterator for the Polling Sequence Table is created to
   // find the start time for the first entry.
@@ -106,37 +102,15 @@ void FixedTimeslotTask::taskFunctionality() {
       // we need to wait before executing the current slot
       // this gives us the time to wait:
       interval = chron_ms(this->pollingSeqTable.getIntervalToPreviousSlotMs());
-      delayForInterval(&currentStartTime, interval);
-      // TODO deadline missed check
+      if (not delayForInterval(&currentStartTime, interval)) {
+        if (dlmFunc != nullptr) {
+          dlmFunc();
+        }
+      }
     }
   }
 }
 
-ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId, uint32_t slotTimeMs,
-                                         int8_t executionStep) {
-  ExecutableObjectIF* 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;
-}
-
-ReturnValue_t FixedTimeslotTask::checkSequence() const { return pollingSeqTable.checkSequence(); }
-
-uint32_t FixedTimeslotTask::getPeriodMs() const { return period * 1000; }
-
 bool FixedTimeslotTask::delayForInterval(chron_ms* previousWakeTimeMs, const chron_ms interval) {
   bool shouldDelay = false;
   // Get current wakeup time

src/fsfw/osal/host/FixedTimeslotTask.h

@@ -6,10 +6,10 @@
 #include <thread>
 #include <vector>
 
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../tasks/FixedSlotSequence.h"
-#include "../../tasks/FixedTimeslotTaskIF.h"
-#include "../../tasks/Typedef.h"
+#include "fsfw/objectmanager/ObjectManagerIF.h"
+#include "fsfw/tasks/FixedSlotSequence.h"
+#include "fsfw/tasks/FixedTimeslotTaskBase.h"
+#include "fsfw/tasks/definitions.h"
 
 class ExecutableObjectIF;
 
@@ -19,7 +19,7 @@ class ExecutableObjectIF;
  * @details
  * @ingroup task_handling
  */
-class FixedTimeslotTask : public FixedTimeslotTaskIF {
+class FixedTimeslotTask : public FixedTimeslotTaskBase {
  public:
   /**
    * @brief   Standard constructor of the class.
@@ -39,7 +39,7 @@ class FixedTimeslotTask : public FixedTimeslotTaskIF {
    * @brief   Currently, the executed object's lifetime is not coupled with
    *          the task object's lifetime, so the destructor is empty.
    */
-  virtual ~FixedTimeslotTask(void);
+  ~FixedTimeslotTask() override;
 
   /**
    * @brief   The method to start the task.
@@ -48,56 +48,22 @@ class FixedTimeslotTask : public FixedTimeslotTaskIF {
    *          The address of the task object is passed as an argument
    *          to the system call.
    */
-  ReturnValue_t startTask(void);
+  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);
-
-  ReturnValue_t checkSequence() const override;
-
-  uint32_t getPeriodMs() const;
-
-  ReturnValue_t sleepFor(uint32_t ms);
+  ReturnValue_t sleepFor(uint32_t ms) override;
 
  protected:
   using chron_ms = std::chrono::milliseconds;
 
   bool started;
-  //!< Typedef for the List of objects.
-  typedef std::vector<ExecutableObjectIF*> ObjectList;
+
   std::thread mainThread;
   std::atomic<bool> terminateThread{false};
 
-  //! Polling sequence table which contains the object to execute
-  //! and information like the timeslots and the passed execution step.
-  FixedSlotSequence pollingSeqTable;
-
   std::condition_variable initCondition;
   std::mutex initMutex;
   std::string taskName;
-  /**
-   * @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
@@ -117,9 +83,9 @@ class FixedTimeslotTask : public FixedTimeslotTaskIF {
    * the checkAndRestartPeriod system call blocks the task until the next
    *  period. On missing the deadline, the deadlineMissedFunction is executed.
    */
-  void taskFunctionality(void);
+  void taskFunctionality();
 
-  bool delayForInterval(chron_ms* previousWakeTimeMs, const chron_ms interval);
+  static bool delayForInterval(chron_ms* previousWakeTimeMs, chron_ms interval);
 };
 
 #endif /* FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_ */

src/fsfw/osal/host/PeriodicTask.cpp

@@ -3,13 +3,10 @@
 #include <chrono>
 #include <thread>
 
-#include "fsfw/ipc/MutexFactory.h"
-#include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/osal/host/Mutex.h"
 #include "fsfw/osal/host/taskHelpers.h"
 #include "fsfw/platform.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
-#include "fsfw/tasks/ExecutableObjectIF.h"
 
 #if defined(PLATFORM_WIN)
 #include <processthreadsapi.h>
@@ -20,8 +17,8 @@
 #endif
 
 PeriodicTask::PeriodicTask(const char* name, TaskPriority setPriority, TaskStackSize setStack,
-                           TaskPeriod setPeriod, void (*setDeadlineMissedFunc)())
-    : started(false), taskName(name), period(setPeriod), deadlineMissedFunc(setDeadlineMissedFunc) {
+                           TaskPeriod setPeriod, TaskDeadlineMissedFunction dlmFunc_)
+    : PeriodicTaskBase(setPeriod, dlmFunc_), started(false), taskName(name) {
   // It is probably possible to set task priorities by using the native
   // task handles for Windows / Linux
   mainThread = std::thread(&PeriodicTask::taskEntryPoint, this, this);
@@ -33,7 +30,7 @@ PeriodicTask::PeriodicTask(const char* name, TaskPriority setPriority, TaskStack
   tasks::insertTaskName(mainThread.get_id(), taskName);
 }
 
-PeriodicTask::~PeriodicTask(void) {
+PeriodicTask::~PeriodicTask() {
   // Do not delete objects, we were responsible for ptrs only.
   terminateThread = true;
   if (mainThread.joinable()) {
@@ -42,7 +39,7 @@ PeriodicTask::~PeriodicTask(void) {
 }
 
 void PeriodicTask::taskEntryPoint(void* argument) {
-  PeriodicTask* originalTask(reinterpret_cast<PeriodicTask*>(argument));
+  auto* originalTask(reinterpret_cast<PeriodicTask*>(argument));
 
   if (not originalTask->started) {
     // we have to suspend/block here until the task is started.
@@ -75,47 +72,27 @@ ReturnValue_t PeriodicTask::sleepFor(uint32_t ms) {
 }
 
 void PeriodicTask::taskFunctionality() {
-  for (const auto& object : objectList) {
-    object->initializeAfterTaskCreation();
-  }
+  initObjsAfterTaskCreation();
 
   std::chrono::milliseconds periodChrono(static_cast<uint32_t>(period * 1000));
   auto currentStartTime{std::chrono::duration_cast<std::chrono::milliseconds>(
       std::chrono::system_clock::now().time_since_epoch())};
-  auto nextStartTime{currentStartTime};
-
   /* Enter the loop that defines the task behavior. */
   for (;;) {
     if (terminateThread.load()) {
       break;
     }
-    for (const auto& object : objectList) {
-      object->performOperation();
+    for (const auto& objectPair : objectList) {
+      objectPair.first->performOperation(objectPair.second);
     }
     if (not delayForInterval(&currentStartTime, periodChrono)) {
-      if (deadlineMissedFunc != nullptr) {
-        this->deadlineMissedFunc();
+      if (dlmFunc != nullptr) {
+        this->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;
-  }
-  object->setTaskIF(this);
-  objectList.push_back(object);
-  return HasReturnvaluesIF::RETURN_OK;
-}
-
-uint32_t PeriodicTask::getPeriodMs() const { return period * 1000; }
-
 bool PeriodicTask::delayForInterval(chron_ms* previousWakeTimeMs, const chron_ms interval) {
   bool shouldDelay = false;
   // Get current wakeup time

src/fsfw/osal/host/PeriodicTask.h

@@ -6,9 +6,9 @@
 #include <thread>
 #include <vector>
 
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../tasks/PeriodicTaskIF.h"
-#include "../../tasks/Typedef.h"
+#include "fsfw/objectmanager/ObjectManagerIF.h"
+#include "fsfw/tasks/PeriodicTaskBase.h"
+#include "fsfw/tasks/definitions.h"
 
 class ExecutableObjectIF;
 
@@ -19,7 +19,7 @@ class ExecutableObjectIF;
  *
  * @ingroup task_handling
  */
-class PeriodicTask : public PeriodicTaskIF {
+class PeriodicTask : public PeriodicTaskBase {
  public:
   /**
    * @brief	Standard constructor of the class.
@@ -34,12 +34,12 @@ class PeriodicTask : public PeriodicTaskIF {
    * assigned.
    */
   PeriodicTask(const char* name, TaskPriority setPriority, TaskStackSize setStack,
-               TaskPeriod 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.
@@ -48,63 +48,20 @@ class PeriodicTask : 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
-   *  -@c RETURN_OK on success
-   *  -@c RETURN_FAILED if the object could not be added.
-   */
-  ReturnValue_t addComponent(object_id_t object);
+  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 pointer to 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);
-
-  uint32_t getPeriodMs() const;
-
-  ReturnValue_t sleepFor(uint32_t ms);
+  ReturnValue_t sleepFor(uint32_t ms) override;
 
  protected:
   using chron_ms = std::chrono::milliseconds;
   bool started;
-  //!< Typedef for the List of objects.
-  typedef std::vector<ExecutableObjectIF*> ObjectList;
   std::thread mainThread;
   std::atomic<bool> terminateThread{false};
 
-  /**
-   * @brief	This attribute holds a list of objects to be executed.
-   */
-  ObjectList objectList;
-
   std::condition_variable initCondition;
   std::mutex initMutex;
   std::string taskName;
-  /**
-   * @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
@@ -124,9 +81,9 @@ class PeriodicTask : public PeriodicTaskIF {
    * the checkAndRestartPeriod system call blocks the task until the next
    *  period. On missing the deadline, the deadlineMissedFunction is executed.
    */
-  void taskFunctionality(void);
+  void taskFunctionality();
 
-  bool delayForInterval(chron_ms* previousWakeTimeMs, const chron_ms interval);
+  static bool delayForInterval(chron_ms* previousWakeTimeMs, chron_ms interval);
 };
 
-#endif /* PERIODICTASK_H_ */
+#endif /* FRAMEWORK_OSAL_HOST_PERIODICTASK_H_ */

src/fsfw/osal/host/TaskFactory.cpp

@@ -14,9 +14,9 @@ TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
 // Not used for the host implementation for now because C++ thread abstraction is used
 const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = 0;
 
-TaskFactory::TaskFactory() {}
+TaskFactory::TaskFactory() = default;
 
-TaskFactory::~TaskFactory() {}
+TaskFactory::~TaskFactory() = default;
 
 TaskFactory* TaskFactory::instance() { return TaskFactory::factoryInstance; }
 

src/fsfw/osal/host/taskHelpers.cpp

@@ -6,7 +6,7 @@
 std::mutex nameMapLock;
 std::map<std::thread::id, std::string> taskNameMap;
 
-ReturnValue_t tasks::insertTaskName(std::thread::id threadId, std::string taskName) {
+ReturnValue_t tasks::insertTaskName(std::thread::id threadId, const std::string& taskName) {
   std::lock_guard<std::mutex> lg(nameMapLock);
   auto returnPair = taskNameMap.emplace(threadId, taskName);
   if (not returnPair.second) {

src/fsfw/osal/host/taskHelpers.h

@@ -7,7 +7,7 @@
 
 namespace tasks {
 
-ReturnValue_t insertTaskName(std::thread::id threadId, std::string taskName);
+ReturnValue_t insertTaskName(std::thread::id threadId, const std::string& taskName);
 std::string getTaskName(std::thread::id threadId);
 
 }  // namespace tasks

src/fsfw/osal/linux/FixedTimeslotTask.cpp

@@ -1,22 +1,20 @@
 #include "fsfw/osal/linux/FixedTimeslotTask.h"
 
-#include <limits.h>
+#include <climits>
 
-#include "fsfw/objectmanager/ObjectManager.h"
 #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_, int priority_, size_t stackSize_,
-                                     uint32_t periodMs_)
-    : PosixThread(name_, priority_, stackSize_), pst(periodMs_), started(false) {}
-
-FixedTimeslotTask::~FixedTimeslotTask() {}
+FixedTimeslotTask::FixedTimeslotTask(const char* name_, TaskPriority priority_, size_t stackSize_,
+                                     TaskPeriod periodSeconds_, TaskDeadlineMissedFunction dlmFunc_)
+    : FixedTimeslotTaskBase(periodSeconds_, dlmFunc_),
+      posixThread(name_, priority_, stackSize_),
+      started(false) {}
 
 void* FixedTimeslotTask::taskEntryPoint(void* arg) {
   // The argument is re-interpreted as PollingTask.
-  FixedTimeslotTask* originalTask(reinterpret_cast<FixedTimeslotTask*>(arg));
+  auto* originalTask(reinterpret_cast<FixedTimeslotTask*>(arg));
   // The task's functionality is called.
   originalTask->taskFunctionality();
   return nullptr;
@@ -24,7 +22,7 @@ void* FixedTimeslotTask::taskEntryPoint(void* arg) {
 
 ReturnValue_t FixedTimeslotTask::startTask() {
   started = true;
-  createTask(&taskEntryPoint, this);
+  posixThread.createTask(&taskEntryPoint, this);
   return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -32,63 +30,36 @@ ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
   return PosixThread::sleep((uint64_t)ms * 1000000);
 }
 
-uint32_t FixedTimeslotTask::getPeriodMs() const { return pst.getLengthMs(); }
-
-ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId, uint32_t slotTimeMs,
-                                         int8_t executionStep) {
-  ExecutableObjectIF* executableObject =
-      ObjectManager::instance()->get<ExecutableObjectIF>(componentId);
-  if (executableObject != nullptr) {
-    pst.addSlot(componentId, slotTimeMs, executionStep, executableObject, 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::dec << std::endl;
-#endif
-  return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-ReturnValue_t FixedTimeslotTask::checkSequence() const { return pst.checkSequence(); }
-
-void FixedTimeslotTask::taskFunctionality() {
+[[noreturn]] void FixedTimeslotTask::taskFunctionality() {
   // Like FreeRTOS pthreads are running as soon as they are created
   if (!started) {
-    suspend();
+    posixThread.suspend();
   }
 
-  pst.intializeSequenceAfterTaskCreation();
+  // Returnvalue ignored for now
+  static_cast<void>(pollingSeqTable.intializeSequenceAfterTaskCreation());
 
   // The start time for the first entry is read.
-  uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
-  uint64_t interval = pst.getIntervalToNextSlotMs();
+  uint64_t lastWakeTime = PosixThread::getCurrentMonotonicTimeMs();
+  uint32_t interval = 0;
 
   // 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 = this->pst.getIntervalToPreviousSlotMs();
+      interval = pollingSeqTable.getIntervalToPreviousSlotMs();
       // The period is checked and restarted with the new interval.
       // 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.
-    this->pst.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
+    pollingSeqTable.executeAndAdvance();
   }
 }

src/fsfw/osal/linux/FixedTimeslotTask.h

@@ -3,11 +3,12 @@
 
 #include <pthread.h>
 
-#include "../../tasks/FixedSlotSequence.h"
-#include "../../tasks/FixedTimeslotTaskIF.h"
 #include "PosixThread.h"
+#include "fsfw/tasks/FixedSlotSequence.h"
+#include "fsfw/tasks/FixedTimeslotTaskBase.h"
+#include "fsfw/tasks/definitions.h"
 
-class FixedTimeslotTask : public FixedTimeslotTaskIF, public PosixThread {
+class FixedTimeslotTask : public FixedTimeslotTaskBase {
  public:
   /**
    * Create a generic periodic task.
@@ -21,29 +22,13 @@ class FixedTimeslotTask : public FixedTimeslotTaskIF, public PosixThread {
    * @param period_
    * @param deadlineMissedFunc_
    */
-  FixedTimeslotTask(const char* name_, int priority_, size_t stackSize_, uint32_t periodMs_);
-  virtual ~FixedTimeslotTask();
+  FixedTimeslotTask(const char* name_, TaskPriority priority_, size_t stackSize_,
+                    TaskPeriod periodSeconds_, TaskDeadlineMissedFunction dlmFunc_);
+  ~FixedTimeslotTask() override = default;
 
-  virtual ReturnValue_t startTask();
+  ReturnValue_t startTask() override;
 
-  virtual ReturnValue_t sleepFor(uint32_t ms);
-
-  virtual uint32_t getPeriodMs() const;
-
-  virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep);
-
-  virtual ReturnValue_t checkSequence() const;
-
-  /**
-   * 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 sleepFor(uint32_t ms) override;
 
  protected:
   /**
@@ -53,9 +38,12 @@ class FixedTimeslotTask : public FixedTimeslotTaskIF, public PosixThread {
    * It links the functionalities provided by FixedSlotSequence with the
    * OS's System Calls to keep the timing of the periods.
    */
-  virtual void taskFunctionality();
+  [[noreturn]] virtual void taskFunctionality();
 
  private:
+  PosixThread posixThread;
+  bool started;
+
   /**
    * @brief	This is the entry point in a new thread.
    *
@@ -68,9 +56,6 @@ class FixedTimeslotTask : public FixedTimeslotTaskIF, public PosixThread {
    * arbitrary data.
    */
   static void* taskEntryPoint(void* arg);
-  FixedSlotSequence pst;
-
-  bool started;
 };
 
 #endif /* FSFW_OSAL_LINUX_FIXEDTIMESLOTTASK_H_ */

src/fsfw/osal/linux/PeriodicPosixTask.cpp

@@ -1,86 +1,54 @@
-#include "fsfw/osal/linux/PeriodicPosixTask.h"
+#include "PeriodicPosixTask.h"
 
-#include <errno.h>
-
-#include "fsfw/objectmanager/ObjectManager.h"
-#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw/serviceinterface.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
 
 PeriodicPosixTask::PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_,
-                                     uint32_t period_, void(deadlineMissedFunc_)())
-    : PosixThread(name_, priority_, stackSize_),
-      objectList(),
-      started(false),
-      periodMs(period_),
-      deadlineMissedFunc(deadlineMissedFunc_) {}
-
-PeriodicPosixTask::~PeriodicPosixTask() {
-  // Not Implemented
-}
+                                     TaskPeriod period_, TaskDeadlineMissedFunction dlmFunc_)
+    : PeriodicTaskBase(period_, dlmFunc_),
+      posixThread(name_, priority_, stackSize_),
+      started(false) {}
 
 void* PeriodicPosixTask::taskEntryPoint(void* arg) {
   // The argument is re-interpreted as PollingTask.
-  PeriodicPosixTask* originalTask(reinterpret_cast<PeriodicPosixTask*>(arg));
+  auto* originalTask(reinterpret_cast<PeriodicPosixTask*>(arg));
   // The task's functionality is called.
   originalTask->taskFunctionality();
-  return NULL;
-}
-
-ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object) {
-  ExecutableObjectIF* newObject = ObjectManager::instance()->get<ExecutableObjectIF>(object);
-  return addComponent(newObject);
-}
-
-ReturnValue_t PeriodicPosixTask::addComponent(ExecutableObjectIF* object) {
-  if (object == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
-               << " it implements ExecutableObjectIF!" << std::endl;
-#else
-    sif::printError(
-        "PeriodicTask::addComponent: Invalid object. Make sure it "
-        "implements ExecutableObjectIF!\n");
-#endif
-    return HasReturnvaluesIF::RETURN_FAILED;
-  }
-  objectList.push_back(object);
-  object->setTaskIF(this);
-
-  return HasReturnvaluesIF::RETURN_OK;
+  return nullptr;
 }
 
 ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
-  return PosixThread::sleep((uint64_t)ms * 1000000);
+  return PosixThread::sleep(static_cast<uint64_t>(ms) * 1000000);
 }
 
-ReturnValue_t PeriodicPosixTask::startTask(void) {
+ReturnValue_t PeriodicPosixTask::startTask() {
+  if (isEmpty()) {
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
   started = true;
-  PosixThread::createTask(&taskEntryPoint, this);
+  posixThread.createTask(&taskEntryPoint, this);
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-void PeriodicPosixTask::taskFunctionality(void) {
+[[noreturn]] void PeriodicPosixTask::taskFunctionality() {
   if (not started) {
-    suspend();
+    posixThread.suspend();
   }
 
-  for (auto const& object : objectList) {
-    object->initializeAfterTaskCreation();
-  }
+  initObjsAfterTaskCreation();
 
-  uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
+  uint64_t lastWakeTime = PosixThread::getCurrentMonotonicTimeMs();
+  uint64_t periodMs = getPeriodMs();
   // The task's "infinite" inner loop is entered.
-  while (1) {
-    for (auto const& object : objectList) {
-      object->performOperation();
+  while (true) {
+    for (auto const& objOpCodePair : objectList) {
+      objOpCodePair.first->performOperation(objOpCodePair.second);
     }
 
     if (not PosixThread::delayUntil(&lastWakeTime, periodMs)) {
-      if (this->deadlineMissedFunc != nullptr) {
-        this->deadlineMissedFunc();
+      if (dlmFunc != nullptr) {
+        dlmFunc();
       }
     }
   }
 }
-
-uint32_t PeriodicPosixTask::getPeriodMs() const { return periodMs; }

src/fsfw/osal/linux/PeriodicPosixTask.h

@@ -3,12 +3,13 @@
 
 #include <vector>
 
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../tasks/ExecutableObjectIF.h"
-#include "../../tasks/PeriodicTaskIF.h"
 #include "PosixThread.h"
+#include "fsfw/objectmanager/ObjectManagerIF.h"
+#include "fsfw/tasks/ExecutableObjectIF.h"
+#include "fsfw/tasks/PeriodicTaskBase.h"
+#include "fsfw/tasks/PeriodicTaskIF.h"
 
-class PeriodicPosixTask : public PosixThread, public PeriodicTaskIF {
+class PeriodicPosixTask : public PeriodicTaskBase {
  public:
   /**
    * Create a generic periodic task.
@@ -22,9 +23,9 @@ class PeriodicPosixTask : public PosixThread, public PeriodicTaskIF {
    * @param period_
    * @param deadlineMissedFunc_
    */
-  PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_, uint32_t period_,
-                    void (*deadlineMissedFunc_)());
-  virtual ~PeriodicPosixTask();
+  PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_, TaskPeriod period_,
+                    TaskDeadlineMissedFunction dlmFunc_);
+  ~PeriodicPosixTask() override = default;
 
   /**
    * @brief	The method to start the task.
@@ -34,42 +35,17 @@ class PeriodicPosixTask : public PosixThread, public PeriodicTaskIF {
    * 			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 RETURN_OK on success, RETURN_FAILED if the object could not be added.
-   */
-  ReturnValue_t addComponent(object_id_t object) override;
-
-  /**
-   * Adds an object to the list of objects to be executed.
-   * The objects are executed in the order added.
-   * @param object pointer to the object to add.
-   * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
-   */
-  ReturnValue_t addComponent(ExecutableObjectIF* object) override;
-
-  uint32_t getPeriodMs() const override;
 
   ReturnValue_t sleepFor(uint32_t ms) override;
 
  private:
-  typedef std::vector<ExecutableObjectIF*> ObjectList;  //!< Typedef for the List of objects.
-  /**
-   * @brief	This attribute holds a list of objects to be executed.
-   */
-  ObjectList objectList;
+  PosixThread posixThread;
 
   /**
    * @brief Flag to indicate that the task was started and is allowed to run
    */
   bool started;
 
-  /**
-   * @brief Period of the task in milliseconds
-   */
-  uint32_t periodMs;
   /**
    * @brief	The function containing the actual functionality of the task.
    * @details	The method sets and starts
@@ -78,7 +54,7 @@ class PeriodicPosixTask : public PosixThread, public PeriodicTaskIF {
    * will be blocked until the next period. On missing the deadline, the deadlineMissedFunction is
    * executed.
    */
-  virtual void taskFunctionality(void);
+  [[noreturn]] virtual void taskFunctionality();
   /**
    * @brief	This is the entry point in a new thread.
    *
@@ -86,14 +62,6 @@ class PeriodicPosixTask : public PosixThread, public PeriodicTaskIF {
    * of the child class. Needs a valid pointer to the derived class.
    */
   static void* taskEntryPoint(void* arg);
-  /**
-   * @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)();
 };
 
 #endif /* FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_ */

src/fsfw/osal/linux/PosixThread.h

@@ -35,6 +35,21 @@ class PosixThread {
    */
   void resume();
 
+  /**
+   * @brief     Function that has to be called by derived class because the
+   *        derived class pointer has to be valid as argument.
+   * @details
+   * This function creates a pthread with the given parameters. As the
+   * function requires a pointer to the derived object it has to be called
+   * after the this pointer of the derived object is valid.
+   * Sets the taskEntryPoint as function to be called by new a thread.
+   * @param fnc_ Function which will be executed by the thread.
+   * @param arg_
+   * argument of the taskEntryPoint function, needs to be this pointer
+   * of derived class
+   */
+  void createTask(void* (*fnc_)(void*), void* arg_);
+
   /**
    * Delay function similar to FreeRtos delayUntil function
    *
@@ -55,21 +70,6 @@ class PosixThread {
  protected:
   pthread_t thread;
 
-  /**
-   * @brief 	Function that has to be called by derived class because the
-   *  		derived class pointer has to be valid as argument.
-   * @details
-   * This function creates a pthread with the given parameters. As the
-   * function requires a pointer to the derived object it has to be called
-   * after the this pointer of the derived object is valid.
-   * Sets the taskEntryPoint as function to be called by new a thread.
-   * @param fnc_ Function which will be executed by the thread.
-   * @param arg_
-   * argument of the taskEntryPoint function, needs to be this pointer
-   * of derived class
-   */
-  void createTask(void* (*fnc_)(void*), void* arg_);
-
  private:
   char name[PTHREAD_MAX_NAMELEN];
   int priority;

src/fsfw/osal/linux/TaskFactory.cpp

@@ -8,21 +8,22 @@
 // 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::instance() { return TaskFactory::factoryInstance; }
 
 PeriodicTaskIF* TaskFactory::createPeriodicTask(
     TaskName name_, TaskPriority taskPriority_, TaskStackSize stackSize_,
     TaskPeriod periodInSeconds_, TaskDeadlineMissedFunction deadLineMissedFunction_) {
-  return new PeriodicPosixTask(name_, taskPriority_, stackSize_, periodInSeconds_ * 1000,
+  return new PeriodicPosixTask(name_, taskPriority_, stackSize_, periodInSeconds_,
                                deadLineMissedFunction_);
 }
 
 FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(
     TaskName name_, TaskPriority taskPriority_, TaskStackSize stackSize_,
     TaskPeriod periodInSeconds_, TaskDeadlineMissedFunction deadLineMissedFunction_) {
-  return new FixedTimeslotTask(name_, taskPriority_, stackSize_, periodInSeconds_ * 1000);
+  return new FixedTimeslotTask(name_, taskPriority_, stackSize_, periodInSeconds_,
+                               deadLineMissedFunction_);
 }
 
 ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {

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::error << "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/parameters/HasParametersIF.h

@@ -51,7 +51,7 @@ class HasParametersIF {
     return (domainId << 24) + (uniqueId << 16) + linearIndex;
   }
 
-  virtual ~HasParametersIF() {}
+  virtual ~HasParametersIF() = default;
 
   /**
    * This is the generic function overriden by child classes to set

src/fsfw/power/Fuse.h

@@ -63,13 +63,13 @@ class Fuse : public SystemObject,
                             SerializeIF::Endianness streamEndianness) override;
   void setAllMonitorsToUnchecked();
   ReturnValue_t performOperation(uint8_t opCode);
-  MessageQueueId_t getCommandQueue() const;
+  MessageQueueId_t getCommandQueue() const override;
   void setDataPoolEntriesInvalid();
-  ReturnValue_t setHealth(HealthState health);
-  HasHealthIF::HealthState getHealth();
+  ReturnValue_t setHealth(HealthState health) override;
+  HasHealthIF::HealthState getHealth() override;
 
   ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId, ParameterWrapper *parameterWrapper,
-                             const ParameterWrapper *newValues, uint16_t startAtIndex);
+                             const ParameterWrapper *newValues, uint16_t startAtIndex) override;
 
  private:
   uint8_t oldFuseState;
@@ -81,7 +81,7 @@ class Fuse : public SystemObject,
     template <typename... Args>
     PowerMonitor(Args... args) : MonitorReporter<float>(std::forward<Args>(args)...) {}
     ReturnValue_t checkPower(float sample, float lowerLimit, float upperLimit);
-    void sendTransitionEvent(float currentValue, ReturnValue_t state) {}
+    void sendTransitionEvent(float currentValue, ReturnValue_t state_) override {}
   };
   PowerMonitor powerMonitor;
   StaticLocalDataSet<3> set;

src/fsfw/power/PowerComponent.h

@@ -10,15 +10,15 @@ class PowerComponent : public PowerComponentIF {
   PowerComponent(object_id_t setId, uint8_t moduleId, float minPower, float maxPower,
                  uint8_t switchId1, bool twoSwitches = false, uint8_t switchId2 = 0xFF);
 
-  virtual object_id_t getDeviceObjectId();
+  object_id_t getDeviceObjectId() override;
 
-  virtual uint8_t getSwitchId1();
-  virtual uint8_t getSwitchId2();
+  uint8_t getSwitchId1() override;
+  uint8_t getSwitchId2() override;
 
-  bool hasTwoSwitches();
+  bool hasTwoSwitches() override;
 
-  float getMin();
-  float getMax();
+  float getMin() override;
+  float getMax() override;
 
   ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
                           Endianness streamEndianness) const override;
@@ -29,7 +29,7 @@ class PowerComponent : public PowerComponentIF {
                             Endianness streamEndianness) override;
 
   ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId, ParameterWrapper* parameterWrapper,
-                             const ParameterWrapper* newValues, uint16_t startAtIndex);
+                             const ParameterWrapper* newValues, uint16_t startAtIndex) override;
 
  private:
   const object_id_t deviceObjectId = objects::NO_OBJECT;

src/fsfw/power/PowerComponentIF.h

@@ -7,7 +7,7 @@
 
 class PowerComponentIF : public SerializeIF, public HasParametersIF {
  public:
-  virtual ~PowerComponentIF() {}
+  ~PowerComponentIF() override = default;
 
   virtual object_id_t getDeviceObjectId() = 0;
 

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/servicepackets/Service1Packets.h

@@ -69,7 +69,7 @@ class FailureReport : public SerializeIF {  //!< [EXPORT] : [SUBSERVICE] 2, 4, 6
     return result;
   }
 
-  virtual size_t getSerializedSize() const {
+  size_t getSerializedSize() const override {
     size_t size = 0;
     size += SerializeAdapter::getSerializedSize(&packetId);
     size += sizeof(packetSequenceControl);

src/fsfw/serialize/SerializeIF.h

@@ -34,7 +34,7 @@ class SerializeIF {
   static const ReturnValue_t TOO_MANY_ELEMENTS =
       MAKE_RETURN_CODE(3);  // !< There are too many elements to be deserialized
 
-  virtual ~SerializeIF() {}
+  virtual ~SerializeIF() = default;
   /**
    * @brief
    * Function to serialize the object into a buffer with maxSize. Size represents the written
@@ -66,7 +66,7 @@ class SerializeIF {
    * Gets the size of a object if it would be serialized in a buffer
    * @return Size of serialized object
    */
-  virtual size_t getSerializedSize() const = 0;
+  [[nodiscard]] virtual size_t getSerializedSize() const = 0;
 
   /**
    * @brief

src/fsfw/storagemanager/StorageAccessor.cpp

@@ -10,15 +10,15 @@ StorageAccessor::StorageAccessor(store_address_t storeId) : ConstStorageAccessor
 StorageAccessor::StorageAccessor(store_address_t storeId, StorageManagerIF* store)
     : ConstStorageAccessor(storeId, store) {}
 
-StorageAccessor& StorageAccessor::operator=(StorageAccessor&& other) {
+StorageAccessor& StorageAccessor::operator=(StorageAccessor&& other) noexcept {
   // Call the parent move assignment and also assign own member.
   dataPointer = other.dataPointer;
-  StorageAccessor::operator=(std::move(other));
+  ConstStorageAccessor::operator=(std::move(other));
   return *this;
 }
 
 // Call the parent move ctor and also transfer own member.
-StorageAccessor::StorageAccessor(StorageAccessor&& other)
+StorageAccessor::StorageAccessor(StorageAccessor&& other) noexcept
     : ConstStorageAccessor(std::move(other)), dataPointer(other.dataPointer) {}
 
 ReturnValue_t StorageAccessor::getDataCopy(uint8_t* pointer, size_t maxSize) {

src/fsfw/storagemanager/StorageAccessor.h

@@ -14,7 +14,7 @@ class StorageAccessor : public ConstStorageAccessor {
   friend class LocalPool;
 
  public:
-  StorageAccessor(store_address_t storeId);
+  explicit StorageAccessor(store_address_t storeId);
   StorageAccessor(store_address_t storeId, StorageManagerIF* store);
 
   /**
@@ -25,8 +25,8 @@ class StorageAccessor : public ConstStorageAccessor {
    * @param
    * @return
    */
-  StorageAccessor& operator=(StorageAccessor&&);
-  StorageAccessor(StorageAccessor&&);
+  StorageAccessor& operator=(StorageAccessor&&) noexcept;
+  StorageAccessor(StorageAccessor&&) noexcept;
 
   ReturnValue_t write(uint8_t* data, size_t size, uint16_t offset = 0);
   uint8_t* data();

src/fsfw/tasks/CMakeLists.txt

@@ -1,2 +1,3 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE FixedSequenceSlot.cpp
-                                        FixedSlotSequence.cpp)
+target_sources(
+  ${LIB_FSFW_NAME} PRIVATE FixedSequenceSlot.cpp FixedSlotSequence.cpp
+                           PeriodicTaskBase.cpp FixedTimeslotTaskBase.cpp)

src/fsfw/tasks/FixedSlotSequence.cpp

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

src/fsfw/tasks/FixedSlotSequence.h

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

src/fsfw/tasks/FixedTimeslotTaskBase.cpp

@@ -0,0 +1,27 @@
+#include "FixedTimeslotTaskBase.h"
+
+#include "fsfw/objectmanager/ObjectManager.h"
+
+FixedTimeslotTaskBase::FixedTimeslotTaskBase(TaskPeriod period_,
+                                             TaskDeadlineMissedFunction dlmFunc_)
+    : period(period_), pollingSeqTable(getPeriodMs()), dlmFunc(dlmFunc_) {}
+uint32_t FixedTimeslotTaskBase::getPeriodMs() const { return static_cast<uint32_t>(period * 1000); }
+
+bool FixedTimeslotTaskBase::isEmpty() const { return pollingSeqTable.isEmpty(); }
+
+ReturnValue_t FixedTimeslotTaskBase::checkSequence() { return pollingSeqTable.checkSequence(); }
+
+ReturnValue_t FixedTimeslotTaskBase::addSlot(object_id_t execId, ExecutableObjectIF* execObj,
+                                             uint32_t slotTimeMs, int8_t executionStep) {
+  if (execObj == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "Component 0x" << std::hex << std::setw(8) << std::setfill('0') << execObj
+               << std::setfill(' ') << " not found, not adding it to PST" << std::dec << std::endl;
+#else
+    sif::printError("Component 0x%08x not found, not adding it to PST\n");
+#endif
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  pollingSeqTable.addSlot(execId, slotTimeMs, executionStep, execObj, this);
+  return HasReturnvaluesIF::RETURN_OK;
+}

src/fsfw/tasks/FixedTimeslotTaskBase.h

@@ -0,0 +1,44 @@
+#ifndef FSFW_EXAMPLE_HOSTED_FIXEDTIMESLOTTASKBASE_H
+#define FSFW_EXAMPLE_HOSTED_FIXEDTIMESLOTTASKBASE_H
+
+#include "FixedSlotSequence.h"
+#include "FixedTimeslotTaskIF.h"
+#include "definitions.h"
+
+class FixedTimeslotTaskBase : public FixedTimeslotTaskIF {
+ public:
+  explicit FixedTimeslotTaskBase(TaskPeriod period, TaskDeadlineMissedFunction dlmFunc = nullptr);
+  ~FixedTimeslotTaskBase() override = default;
+  ;
+
+ protected:
+  /**
+   * @brief Period of task in floating point seconds
+   */
+  TaskPeriod period;
+
+  //! Polling sequence table which contains the object to execute
+  //! and information like the timeslots and the passed execution step.
+  FixedSlotSequence pollingSeqTable;
+
+  /**
+   * @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.
+   */
+  TaskDeadlineMissedFunction dlmFunc = nullptr;
+
+  ReturnValue_t checkSequence() override;
+
+  [[nodiscard]] uint32_t getPeriodMs() const override;
+
+  [[nodiscard]] bool isEmpty() const override;
+
+  ReturnValue_t addSlot(object_id_t execId, ExecutableObjectIF* componentId, uint32_t slotTimeMs,
+                        int8_t executionStep) override;
+};
+
+#endif  // FSFW_EXAMPLE_HOSTED_FIXEDTIMESLOTTASKBASE_H

src/fsfw/tasks/FixedTimeslotTaskIF.h

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

src/fsfw/tasks/PeriodicTaskBase.cpp

@@ -0,0 +1,71 @@
+#include "PeriodicTaskBase.h"
+
+#include <set>
+
+#include "fsfw/objectmanager/ObjectManager.h"
+#include "fsfw/serviceinterface.h"
+
+PeriodicTaskBase::PeriodicTaskBase(TaskPeriod period_, TaskDeadlineMissedFunction dlmFunc_)
+    : period(period_), dlmFunc(dlmFunc_) {
+  // Hints at configuration error
+  if (PeriodicTaskBase::getPeriodMs() <= 1) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "Passed task period 0 or smaller than 1 ms" << std::endl;
+#else
+    sif::printWarning("Passed task period 0 or smaller than 1ms\n");
+#endif
+  }
+}
+
+uint32_t PeriodicTaskBase::getPeriodMs() const { return static_cast<uint32_t>(period * 1000); }
+
+bool PeriodicTaskBase::isEmpty() const { return objectList.empty(); }
+
+ReturnValue_t PeriodicTaskBase::addComponent(object_id_t object) { return addComponent(object, 0); }
+
+ReturnValue_t PeriodicTaskBase::addComponent(ExecutableObjectIF* object) {
+  return addComponent(object, 0);
+}
+
+ReturnValue_t PeriodicTaskBase::initObjsAfterTaskCreation() {
+  std::set<ExecutableObjectIF*> uniqueObjects;
+  ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
+  uint32_t count = 0;
+  for (const auto& obj : objectList) {
+    // Ensure that each unique object is initialized once.
+    if (uniqueObjects.find(obj.first) == uniqueObjects.end()) {
+      ReturnValue_t result = obj.first->initializeAfterTaskCreation();
+      if (result != HasReturnvaluesIF::RETURN_OK) {
+        count++;
+        status = result;
+      }
+      uniqueObjects.emplace(obj.first);
+    }
+  }
+  if (count > 0) {
+  }
+  return status;
+}
+
+ReturnValue_t PeriodicTaskBase::addComponent(object_id_t object, uint8_t opCode) {
+  auto* newObject = ObjectManager::instance()->get<ExecutableObjectIF>(object);
+  return addComponent(newObject, opCode);
+}
+
+ReturnValue_t PeriodicTaskBase::addComponent(ExecutableObjectIF* object, uint8_t opCode) {
+  if (object == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
+               << " it implements ExecutableObjectIF!" << std::endl;
+#else
+    sif::printError(
+        "PeriodicTask::addComponent: Invalid object. Make sure it "
+        "implements ExecutableObjectIF!\n");
+#endif
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  objectList.push_back({object, opCode});
+  object->setTaskIF(this);
+
+  return HasReturnvaluesIF::RETURN_OK;
+}

src/fsfw/tasks/PeriodicTaskBase.h

@@ -0,0 +1,54 @@
+#ifndef FSFW_SRC_FSFW_TASKS_PERIODICTASKBASE_H_
+#define FSFW_SRC_FSFW_TASKS_PERIODICTASKBASE_H_
+
+#include <cstdint>
+#include <vector>
+
+#include "fsfw/tasks/PeriodicTaskIF.h"
+#include "fsfw/tasks/definitions.h"
+
+class ExecutableObjectIF;
+
+class PeriodicTaskBase : public PeriodicTaskIF {
+ public:
+  explicit PeriodicTaskBase(TaskPeriod period,
+                            TaskDeadlineMissedFunction deadlineMissedFunc = nullptr);
+
+  ReturnValue_t addComponent(object_id_t object, uint8_t opCode) override;
+  ReturnValue_t addComponent(ExecutableObjectIF* object, uint8_t opCode) override;
+
+  ReturnValue_t addComponent(object_id_t object) override;
+  ReturnValue_t addComponent(ExecutableObjectIF* object) override;
+
+  [[nodiscard]] uint32_t getPeriodMs() const override;
+
+  [[nodiscard]] bool isEmpty() const override;
+
+  ReturnValue_t initObjsAfterTaskCreation();
+
+ protected:
+  //! Typedef for the List of objects. Will contain the objects to execute and their respective
+  //! operation codes
+  using ObjectList = std::vector<std::pair<ExecutableObjectIF*, uint8_t>>;
+  /**
+   * @brief This attribute holds a list of objects to be executed.
+   */
+  ObjectList objectList;
+
+  /**
+   * @brief Period of task in floating point seconds
+   */
+  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.
+   */
+  TaskDeadlineMissedFunction dlmFunc = nullptr;
+};
+
+#endif /* FSFW_SRC_FSFW_TASKS_PERIODICTASKBASE_H_ */

src/fsfw/tasks/PeriodicTaskIF.h

@@ -3,9 +3,8 @@
 
 #include <cstddef>
 
-#include "../objectmanager/SystemObjectIF.h"
-#include "../timemanager/Clock.h"
-class ExecutableObjectIF;
+#include "fsfw/objectmanager/SystemObjectIF.h"
+#include "fsfw/tasks/ExecutableObjectIF.h"
 
 /**
  * New version of TaskIF
@@ -18,7 +17,7 @@ class PeriodicTaskIF {
   /**
    * @brief	A virtual destructor as it is mandatory for interfaces.
    */
-  virtual ~PeriodicTaskIF() {}
+  virtual ~PeriodicTaskIF() = default;
   /**
    * @brief	With the startTask method, a created task can be started
    *          for the first time.
@@ -26,28 +25,29 @@ class PeriodicTaskIF {
   virtual ReturnValue_t startTask() = 0;
 
   /**
-   * Add a component (object) to a periodic task.
-   * @param object
-   * Add an object to the task. The object needs to implement ExecutableObjectIF
-   * @return
+   * Adds an object to the list of objects to be executed.
+   * The objects are executed in the order added. The object needs to implement
+   * ExecutableObjectIF
+   * @param object Id of the object to add.
+   * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
    */
-  virtual ReturnValue_t addComponent(object_id_t object) {
-    return HasReturnvaluesIF::RETURN_FAILED;
-  };
+  virtual ReturnValue_t addComponent(object_id_t object, uint8_t opCode) = 0;
+  virtual ReturnValue_t addComponent(object_id_t object) { return addComponent(object, 0); };
 
   /**
-   * Add an object to a periodic task.
-   * @param object
-   * Add an object to the task.
-   * @return
+   * 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.
    */
-  virtual ReturnValue_t addComponent(ExecutableObjectIF* object) {
-    return HasReturnvaluesIF::RETURN_FAILED;
-  };
+  virtual ReturnValue_t addComponent(ExecutableObjectIF* object, uint8_t opCode) = 0;
+  virtual ReturnValue_t addComponent(ExecutableObjectIF* object) { return addComponent(object, 0); }
 
   virtual ReturnValue_t sleepFor(uint32_t ms) = 0;
 
-  virtual uint32_t getPeriodMs() const = 0;
+  [[nodiscard]] virtual uint32_t getPeriodMs() const = 0;
+
+  [[nodiscard]] virtual bool isEmpty() const = 0;
 };
 
-#endif /* PERIODICTASKIF_H_ */
+#endif /* FRAMEWORK_TASK_PERIODICTASKIF_H_ */

src/fsfw/tasks/TaskFactory.h

@@ -4,7 +4,7 @@
 #include <cstdlib>
 
 #include "FixedTimeslotTaskIF.h"
-#include "Typedef.h"
+#include "definitions.h"
 
 /**
  * Singleton Class that produces Tasks.