Merge remote-tracking branch 'upstream/mueller/task-if-refactoring' into mueller/task-if-refactoring-eive

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)())
+                                     TaskDeadlineMissedFunction dlmFunc_)
-    : started(false),
+    : FixedTimeslotTaskBase(setPeriod, dlmFunc_), started(false), taskName(name) {
-      pollingSeqTable(setPeriod * 1000),
-      taskName(name),
-      period(setPeriod),
-      deadlineMissedFunc(setDeadlineMissedFunc) {
   // 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.
@@ -80,7 +74,7 @@ ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-void FixedTimeslotTask::taskFunctionality() {
+[[noreturn]] void FixedTimeslotTask::taskFunctionality() {
   pollingSeqTable.intializeSequenceAfterTaskCreation();
 
   // A local iterator for the Polling Sequence Table is created to
@@ -106,16 +100,18 @@ 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);
+      if (not delayForInterval(&currentStartTime, interval)) {
-      // TODO deadline missed check
+        if (dlmFunc != nullptr) {
+          dlmFunc();
+        }
+      }
     }
   }
 }
 
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId, uint32_t slotTimeMs,
                                          int8_t executionStep) {
-  ExecutableObjectIF* executableObject =
+  auto* executableObject = ObjectManager::instance()->get<ExecutableObjectIF>(componentId);
-      ObjectManager::instance()->get<ExecutableObjectIF>(componentId);
   if (executableObject != nullptr) {
     pollingSeqTable.addSlot(componentId, slotTimeMs, executionStep, executableObject, this);
     return HasReturnvaluesIF::RETURN_OK;
@@ -133,10 +129,6 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId, uint32_t slotT
   return HasReturnvaluesIF::RETURN_FAILED;
 }
 
-ReturnValue_t FixedTimeslotTask::checkSequence() { 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
@@ -176,5 +168,3 @@ bool FixedTimeslotTask::delayForInterval(chron_ms* previousWakeTimeMs, const chr
   (*previousWakeTimeMs) = currentStartTime;
   return false;
 }
-
-bool FixedTimeslotTask::isEmpty() const { return pollingSeqTable.isEmpty(); }

src/fsfw/osal/host/FixedTimeslotTask.h

@@ -6,10 +6,10 @@
 #include <thread>
 #include <vector>
 
-#include "../../objectmanager/ObjectManagerIF.h"
+#include "fsfw/objectmanager/ObjectManagerIF.h"
-#include "../../tasks/FixedSlotSequence.h"
+#include "fsfw/tasks/FixedSlotSequence.h"
-#include "../../tasks/FixedTimeslotTaskIF.h"
+#include "fsfw/tasks/FixedTimeslotTaskBase.h"
-#include "../../tasks/Typedef.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,7 +48,7 @@ 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.
@@ -57,49 +57,23 @@ class FixedTimeslotTask : public FixedTimeslotTaskIF {
    * @param executionStep
    * @return
    */
-  ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep);
+  ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
+                        int8_t executionStep) override;
 
-  ReturnValue_t checkSequence() override;
+  ReturnValue_t sleepFor(uint32_t ms) override;
-
-  uint32_t getPeriodMs() const;
-
-  ReturnValue_t sleepFor(uint32_t ms);
-
-  bool isEmpty() const 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
@@ -119,9 +93,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);
+  [[noreturn]] 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)())
+                           TaskPeriod setPeriod, TaskDeadlineMissedFunction dlmFunc_)
-    : started(false), taskName(name), period(setPeriod), deadlineMissedFunc(setDeadlineMissedFunc) {
+    : 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) {
+  initObjsAfterTaskCreation();
-    object->initializeAfterTaskCreation();
-  }
 
   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) {
+    for (const auto& objectPair : objectList) {
-      object->performOperation();
+      objectPair.first->performOperation(objectPair.second);
     }
     if (not delayForInterval(&currentStartTime, periodChrono)) {
-      if (deadlineMissedFunc != nullptr) {
+      if (dlmFunc != nullptr) {
-        this->deadlineMissedFunc();
+        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 "fsfw/objectmanager/ObjectManagerIF.h"
-#include "../../tasks/PeriodicTaskIF.h"
+#include "fsfw/tasks/PeriodicTaskBase.h"
-#include "../../tasks/Typedef.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,64 +48,21 @@ class PeriodicTask : public PeriodicTaskIF {
    * 			The address of the task object is passed as an argument
    * 			to the system call.
    */
-  ReturnValue_t startTask(void);
+  ReturnValue_t startTask() override;
-  /**
-   * Adds an object to the list of objects to be executed.
-   * The objects are executed in the order added.
-   * @param object Id of the object to add.
-   * @return
-   *  -@c RETURN_OK on success
-   *  -@c RETURN_FAILED if the object could not be added.
-   */
-  ReturnValue_t addComponent(object_id_t object);
 
-  /**
+  ReturnValue_t sleepFor(uint32_t ms) 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);
 
   bool isEmpty() const 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
@@ -125,9 +82,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,24 +1,21 @@
 #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_,
+FixedTimeslotTask::FixedTimeslotTask(const char* name_, TaskPriority priority_, size_t stackSize_,
-                                     uint32_t periodMs_)
+                                     TaskPeriod periodSeconds_, TaskDeadlineMissedFunction dlmFunc_)
-    : PosixThread(name_, priority_, stackSize_), pst(periodMs_), started(false) {}
+    : FixedTimeslotTaskBase(periodSeconds_, dlmFunc_),
-
+      posixThread(name_, priority_, stackSize_),
-FixedTimeslotTask::~FixedTimeslotTask() {}
+      started(false) {}
-
-bool FixedTimeslotTask::isEmpty() const { return pst.isEmpty(); }
 
 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;
@@ -26,7 +23,7 @@ void* FixedTimeslotTask::taskEntryPoint(void* arg) {
 
 ReturnValue_t FixedTimeslotTask::startTask() {
   started = true;
-  createTask(&taskEntryPoint, this);
+  posixThread.createTask(&taskEntryPoint, this);
   return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -34,45 +31,25 @@ ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
   return PosixThread::sleep((uint64_t)ms * 1000000);
 }
 
-uint32_t FixedTimeslotTask::getPeriodMs() const { return pst.getLengthMs(); }
+[[noreturn]] void FixedTimeslotTask::taskFunctionality() {
-
-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() { return pst.checkSequence(); }
-
-void FixedTimeslotTask::taskFunctionality() {
   // Like FreeRTOS pthreads are running as soon as they are created
   if (!started) {
-    suspend();
+    posixThread.suspend();
   }
 
-  pst.intializeSequenceAfterTaskCreation();
+  pollingSeqTable.intializeSequenceAfterTaskCreation();
 
   // The start time for the first entry is read.
-  uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
+  uint64_t lastWakeTime = PosixThread::getCurrentMonotonicTimeMs();
-  uint64_t interval = pst.getIntervalToNextSlotMs();
+  uint32_t interval = 0;
 
   // The task's "infinite" inner loop is entered.
-  while (1) {
+  while (true) {
-    if (pst.slotFollowsImmediately()) {
+    if (pollingSeqTable.slotFollowsImmediately()) {
       // Do nothing
     } else {
       // The interval for the next polling slot is selected.
-      interval = 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)) {
@@ -81,7 +58,7 @@ void FixedTimeslotTask::taskFunctionality() {
       }
     }
     // The device handler for this slot is executed and the next one is chosen.
-    this->pst.executeAndAdvance();
+    pollingSeqTable.executeAndAdvance();
   }
 }
 
@@ -89,7 +66,7 @@ void FixedTimeslotTask::missedDeadlineCounter() {
   FixedTimeslotTask::deadlineMissedCount++;
   if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "PST missed " << FixedTimeslotTask::deadlineMissedCount << " deadlines"
+    sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount << " deadlines."
                << std::endl;
 #endif
   }

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,22 +22,14 @@ class FixedTimeslotTask : public FixedTimeslotTaskIF, public PosixThread {
    * @param period_
    * @param deadlineMissedFunc_
    */
-  FixedTimeslotTask(const char* name_, int priority_, size_t stackSize_, uint32_t periodMs_);
+  FixedTimeslotTask(const char* name_, TaskPriority priority_, size_t stackSize_,
-  virtual ~FixedTimeslotTask();
+                    TaskPeriod periodSeconds_, TaskDeadlineMissedFunction dlmFunc_);
+  ~FixedTimeslotTask() override = default;
 
   ReturnValue_t startTask() override;
 
   ReturnValue_t sleepFor(uint32_t ms) override;
 
-  uint32_t getPeriodMs() const override;
-
-  ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
-                        int8_t executionStep) override;
-
-  ReturnValue_t checkSequence() override;
-
-  bool isEmpty() const override;
-
   /**
    * This static function can be used as #deadlineMissedFunc.
    * It counts missedDeadlines and prints the number of missed deadlines every 10th time.
@@ -56,9 +49,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.
    *
@@ -71,9 +67,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,60 +1,53 @@
-#include "fsfw/osal/linux/PeriodicPosixTask.h"
+#include "PeriodicPosixTask.h"
 
-#include <set>
+#include "fsfw/serviceinterface.h"
-#include <cerrno>
-
-#include "fsfw/objectmanager/ObjectManager.h"
-#include "fsfw/serviceinterface/ServiceInterface.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
 
 PeriodicPosixTask::PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_,
-                                     uint32_t period_, TaskDeadlineMissedFunction dlMissedFunc_)
+                                     TaskPeriod period_, TaskDeadlineMissedFunction dlmFunc_)
-    : PosixThread(name_, priority_, stackSize_),
+    : PeriodicTaskBase(period_, dlmFunc_),
-      PeriodicTaskBase(period_, dlMissedFunc_),
+      posixThread(name_, priority_, stackSize_),
       started(false) {}
 
-PeriodicPosixTask::~PeriodicPosixTask() {
-  // Not Implemented
-}
-
 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 nullptr;
 }
 
 ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
-  return PosixThread::sleep(static_cast<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();
   }
 
   initObjsAfterTaskCreation();
 
-  uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
+  uint64_t lastWakeTime = PosixThread::getCurrentMonotonicTimeMs();
+  uint64_t periodMs = getPeriodMs();
   // The task's "infinite" inner loop is entered.
-  while (1) {
+  while (true) {
     for (auto const& objOpCodePair : objectList) {
       objOpCodePair.first->performOperation(objOpCodePair.second);
     }
 
     if (not PosixThread::delayUntil(&lastWakeTime, periodMs)) {
-      if (this->deadlineMissedFunc != nullptr) {
+      if (dlmFunc != nullptr) {
-        this->deadlineMissedFunc();
+        dlmFunc();
       }
     }
   }

src/fsfw/osal/linux/PeriodicPosixTask.h

@@ -1,17 +1,15 @@
 #ifndef FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_
 #define FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_
 
-#include "PosixThread.h"
-
 #include <vector>
 
+#include "PosixThread.h"
 #include "fsfw/objectmanager/ObjectManagerIF.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
-#include "fsfw/tasks/PeriodicTaskIF.h"
 #include "fsfw/tasks/PeriodicTaskBase.h"
+#include "fsfw/tasks/PeriodicTaskIF.h"
 
-
+class PeriodicPosixTask : public PeriodicTaskBase {
-class PeriodicPosixTask : public PosixThread, public PeriodicTaskBase {
  public:
   /**
    * Create a generic periodic task.
@@ -25,9 +23,9 @@ class PeriodicPosixTask : public PosixThread, public PeriodicTaskBase {
    * @param period_
    * @param deadlineMissedFunc_
    */
-  PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_, uint32_t period_,
+  PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_, TaskPeriod period_,
-                    void (*deadlineMissedFunc_)());
+                    TaskDeadlineMissedFunction dlmFunc_);
-  virtual ~PeriodicPosixTask();
+  ~PeriodicPosixTask() override = default;
 
   /**
    * @brief	The method to start the task.
@@ -41,6 +39,7 @@ class PeriodicPosixTask : public PosixThread, public PeriodicTaskBase {
   ReturnValue_t sleepFor(uint32_t ms) override;
 
  private:
+  PosixThread posixThread;
 
   /**
    * @brief Flag to indicate that the task was started and is allowed to run
@@ -55,7 +54,7 @@ class PeriodicPosixTask : public PosixThread, public PeriodicTaskBase {
    * 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.
    *

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

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

src/fsfw/tasks/FixedSlotSequence.h

@@ -35,7 +35,7 @@ class FixedSlotSequence {
    * @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.

src/fsfw/tasks/FixedTimeslotTaskBase.cpp

@@ -0,0 +1,29 @@
+#include "FixedTimeslotTaskBase.h"
+
+#include "fsfw/objectmanager/ObjectManager.h"
+
+FixedTimeslotTaskBase::FixedTimeslotTaskBase(TaskPeriod period_,
+                                             TaskDeadlineMissedFunction dlmFunc_)
+    : pollingSeqTable(getPeriodMs()), period(period_), 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 componentId, uint32_t slotTimeMs,
+                                             int8_t executionStep) {
+  auto* executableObject = ObjectManager::instance()->get<ExecutableObjectIF>(componentId);
+  if (executableObject != nullptr) {
+    pollingSeqTable.addSlot(componentId, slotTimeMs, executionStep, executableObject, this);
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::error << "Component 0x" << std::hex << std::setw(8) << std::setfill('0') << componentId
+             << 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;
+}

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:
+  //! Polling sequence table which contains the object to execute
+  //! and information like the timeslots and the passed execution step.
+  FixedSlotSequence pollingSeqTable;
+
+  /**
+   * @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;
+
+  ReturnValue_t checkSequence() override;
+
+  [[nodiscard]] uint32_t getPeriodMs() const override;
+
+  [[nodiscard]] bool isEmpty() const override;
+
+  ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
+                        int8_t executionStep) override;
+};
+
+#endif  // FSFW_EXAMPLE_HOSTED_FIXEDTIMESLOTTASKBASE_H

src/fsfw/tasks/FixedTimeslotTaskIF.h

@@ -11,7 +11,7 @@
  */
 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);

src/fsfw/tasks/PeriodicTaskBase.cpp

@@ -1,18 +1,26 @@
-#include <fsfw/objectmanager/ObjectManager.h>
 #include "PeriodicTaskBase.h"
 
 #include <set>
 
-PeriodicTaskBase::PeriodicTaskBase(uint32_t periodMs_,
+#include "fsfw/objectmanager/ObjectManager.h"
-    TaskDeadlineMissedFunction deadlineMissedFunc_)
+#include "fsfw/serviceinterface.h"
-  : periodMs(periodMs_), deadlineMissedFunc(deadlineMissedFunc_) {}
 
-uint32_t PeriodicTaskBase::getPeriodMs() const { return periodMs; }
+PeriodicTaskBase::PeriodicTaskBase(TaskPeriod period_, TaskDeadlineMissedFunction dlmFunc_)
-
+    : period(period_), dlmFunc(dlmFunc_) {
-bool PeriodicTaskBase::isEmpty() const {
+  // Hints at configuration error
-  return objectList.empty();
+  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::initObjsAfterTaskCreation() {
   std::multiset<ExecutableObjectIF*> uniqueObjects;
   ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
@@ -34,7 +42,7 @@ ReturnValue_t PeriodicTaskBase::initObjsAfterTaskCreation() {
 }
 
 ReturnValue_t PeriodicTaskBase::addComponent(object_id_t object, uint8_t opCode) {
-  ExecutableObjectIF* newObject = ObjectManager::instance()->get<ExecutableObjectIF>(object);
+  auto* newObject = ObjectManager::instance()->get<ExecutableObjectIF>(object);
   return addComponent(newObject, opCode);
 }
 

src/fsfw/tasks/PeriodicTaskBase.h

@@ -1,28 +1,29 @@
 #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"
-#include <vector>
-#include <cstdint>
 
 class ExecutableObjectIF;
 
-class PeriodicTaskBase: public PeriodicTaskIF {
+class PeriodicTaskBase : public PeriodicTaskIF {
-public:
+ public:
-  PeriodicTaskBase(uint32_t periodMs, TaskDeadlineMissedFunction deadlineMissedFunc = nullptr);
+  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;
 
-  uint32_t getPeriodMs() const override;
+  [[nodiscard]] uint32_t getPeriodMs() const override;
 
-  bool isEmpty() const override;
+  [[nodiscard]] bool isEmpty() const override;
 
   ReturnValue_t initObjsAfterTaskCreation();
 
-protected:
+ 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>>;
@@ -32,20 +33,19 @@ protected:
   ObjectList objectList;
 
   /**
-   * @brief Period of the task in milliseconds
+   * @brief Period of task in floating point seconds
    */
-  uint32_t periodMs;
+  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.
+   * @details
-   *            So, each may react individually on a timing failure. The pointer may be
+   * This pointer stores the function that is executed if the task's deadline
-   * NULL, then nothing happens on missing the deadline. The deadline is equal to the next execution
+   * is missed. So, each may react individually on a timing failure.
-   *            of the periodic task.
+   * 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 deadlineMissedFunc = nullptr;
+  TaskDeadlineMissedFunction dlmFunc = nullptr;
 };
 
-
-
 #endif /* FSFW_SRC_FSFW_TASKS_PERIODICTASKBASE_H_ */

src/fsfw/tasks/PeriodicTaskIF.h

@@ -1,11 +1,11 @@
 #ifndef FRAMEWORK_TASK_PERIODICTASKIF_H_
 #define FRAMEWORK_TASK_PERIODICTASKIF_H_
 
+#include <cstddef>
+
 #include "fsfw/objectmanager/SystemObjectIF.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
 
-#include <cstddef>
-
 /**
  * New version of TaskIF
  * Follows RAII principles, i.e. there's no create or delete method.
@@ -17,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.

src/fsfw/tasks/definitions.h

@@ -5,7 +5,7 @@
 #include <cstdint>
 
 using TaskName = const char*;
-using TaskPriority = uint32_t;
+using TaskPriority = int;
 using TaskStackSize = size_t;
 using TaskPeriod = double;
 using TaskDeadlineMissedFunction = void (*)();