diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index deab2dc15..44a7b8010 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -1,17 +1,19 @@
+#include "PeriodicTask.h"
+
#include <framework/serviceinterface/ServiceInterfaceStream.h>
#include <framework/tasks/ExecutableObjectIF.h>
-#include "PeriodicTask.h"
PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
TaskStackSize setStack, TaskPeriod setPeriod,
void (*setDeadlineMissedFunc)()) :
started(false), handle(NULL), period(setPeriod), deadlineMissedFunc(
- setDeadlineMissedFunc) {
-
- BaseType_t status = xTaskCreate(taskEntryPoint, name, setStack, this, setPriority, &handle);
+ setDeadlineMissedFunc)
+{
+ BaseType_t status = xTaskCreate(taskEntryPoint, name,
+ setStack, this, setPriority, &handle);
if(status != pdPASS){
- sif::debug << "PeriodicTask Insufficient heap memory remaining. Status: "
- << status << std::endl;
+ sif::debug << "PeriodicTask Insufficient heap memory remaining. "
+ "Status: " << status << std::endl;
}
}
@@ -21,16 +23,19 @@ PeriodicTask::~PeriodicTask(void) {
}
void PeriodicTask::taskEntryPoint(void* argument) {
- //The argument is re-interpreted as PeriodicTask. The Task object is global, so it is found from any place.
+ // 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));
- // Task should not start until explicitly requested
- // in FreeRTOS, tasks start as soon as they are created if the scheduler is running
- // but not if the scheduler is not running.
- // to be able to accommodate both cases we check a member which is set in #startTask()
- // if it is not set and we get here, the scheduler was started before #startTask() was called and we need to suspend
- // if it is set, the scheduler was not running before #startTask() was called and we can continue
+ /* 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.
+ * To be able to accommodate both cases we check a member which is set in
+ * #startTask(). If it is not set and we get here, the scheduler was started
+ * before #startTask() was called and we need to suspend if it is set,
+ * the scheduler was not running before #startTask() was called and we
+ * can continue */
- if (!originalTask->started) {
+ if (not originalTask->started) {
vTaskSuspend(NULL);
}
@@ -59,31 +64,73 @@ void PeriodicTask::taskFunctionality() {
TickType_t xLastWakeTime;
const TickType_t xPeriod = pdMS_TO_TICKS(this->period * 1000.);
/* The xLastWakeTime variable needs to be initialized with the current tick
- count. Note that this is the only time the variable is written to explicitly.
- After this assignment, xLastWakeTime is updated automatically internally within
- vTaskDelayUntil(). */
+ count. Note that this is the only time the variable is written to
+ explicitly. After this assignment, xLastWakeTime is updated automatically
+ internally within vTaskDelayUntil(). */
xLastWakeTime = xTaskGetTickCount();
/* Enter the loop that defines the task behavior. */
for (;;) {
- for (ObjectList::iterator it = objectList.begin();
- it != objectList.end(); ++it) {
- (*it)->performOperation();
+ for (auto const& object: objectList) {
+ object->performOperation();
}
- //TODO deadline missed check
+
+ checkMissedDeadline(xLastWakeTime, xPeriod);
+
vTaskDelayUntil(&xLastWakeTime, xPeriod);
+
}
}
-ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
+ReturnValue_t PeriodicTask::addComponent(object_id_t object, bool setTaskIF) {
ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
object);
- if (newObject == NULL) {
+ if (newObject == nullptr) {
+ sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
+ "it implements ExecutableObjectIF!" << std::endl;
return HasReturnvaluesIF::RETURN_FAILED;
}
objectList.push_back(newObject);
+
+ if(setTaskIF) {
+ newObject->setTaskIF(this);
+ }
return HasReturnvaluesIF::RETURN_OK;
}
uint32_t PeriodicTask::getPeriodMs() const {
return period * 1000;
}
+
+void PeriodicTask::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. */
+ TickType_t currentTickCount = xTaskGetTickCount();
+ TickType_t timeToWake = xLastWakeTime + interval;
+ // Tick count has overflown
+ if(currentTickCount < xLastWakeTime) {
+ // Time to wake has overflown as well. If the tick count
+ // is larger than the time to wake, a deadline was missed.
+ if(timeToWake < xLastWakeTime and
+ currentTickCount > timeToWake) {
+ handleMissedDeadline();
+ }
+ }
+ // No tick count overflow. If the timeToWake has not overflown
+ // and the current tick count is larger than the time to wake,
+ // a deadline was missed.
+ else if(timeToWake > xLastWakeTime and currentTickCount > timeToWake) {
+ handleMissedDeadline();
+ }
+}
+
+void PeriodicTask::handleMissedDeadline() {
+#ifdef DEBUG
+ sif::warning << "PeriodicTask: " << pcTaskGetName(NULL) <<
+ " missed deadline!\n" << std::flush;
+#endif
+ if(deadlineMissedFunc != nullptr) {
+ this->deadlineMissedFunc();
+ }
+}
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index e7ba8dd26..09aa6bc7d 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -1,48 +1,49 @@
-#ifndef MULTIOBJECTTASK_H_
-#define MULTIOBJECTTASK_H_
+#ifndef FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_
+#define FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_
#include <framework/objectmanager/ObjectManagerIF.h>
#include <framework/tasks/PeriodicTaskIF.h>
#include <framework/tasks/Typedef.h>
-#include <FreeRTOS.h>
-#include "task.h"
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
#include <vector>
class ExecutableObjectIF;
/**
- * @brief This class represents a specialized task for periodic activities of multiple objects.
- *
- * @details MultiObjectTask is an extension to ObjectTask in the way that it is able to execute
- * multiple objects that implement the ExecutableObjectIF interface. The objects must be
- * added prior to starting the task.
- *
+ * @brief This class represents a specialized task for
+ * periodic activities of multiple objects.
* @ingroup task_handling
*/
class PeriodicTask: public PeriodicTaskIF {
public:
/**
- * @brief Standard constructor of the class.
- * @details The class is initialized without allocated objects. These need to be added
- * with #addObject.
- * In the underlying TaskBase class, a new operating system task is created.
- * In addition to the TaskBase parameters, the period, the pointer to the
- * aforementioned initialization function and an optional "deadline-missed"
- * function pointer is passed.
- * @param priority Sets the priority of a task. Values range from a low 0 to a high 99.
- * @param stack_size The stack size reserved by the operating system for the task.
- * @param setPeriod The length of the period with which the task's functionality will be
- * executed. It is expressed in clock ticks.
- * @param setDeadlineMissedFunc The function pointer to the deadline missed function
- * that shall be assigned.
+ * Keep in Mind that you need to call before this vTaskStartScheduler()!
+ * A lot of task parameters are set in "FreeRTOSConfig.h".
+ * TODO: why does this need to be called before vTaskStartScheduler?
+ * @details
+ * The class is initialized without allocated objects.
+ * These need to be added with #addComponent.
+ * @param priority
+ * Sets the priority of a task. Values depend on freeRTOS configuration,
+ * high number means high priority.
+ * @param stack_size
+ * The stack size reserved by the operating system for the task.
+ * @param setPeriod
+ * The length of the period with which the task's
+ * functionality will be executed. It is expressed in clock ticks.
+ * @param setDeadlineMissedFunc
+ * The function pointer to the deadline missed function that shall
+ * be assigned.
*/
- PeriodicTask(const char *name, TaskPriority setPriority, TaskStackSize setStack, TaskPeriod setPeriod,
- void (*setDeadlineMissedFunc)());
+ PeriodicTask(const char *name, TaskPriority setPriority,
+ TaskStackSize setStack, TaskPeriod setPeriod,
+ void (*setDeadlineMissedFunc)());
/**
- * @brief Currently, the executed object's lifetime is not coupled with the task object's
- * lifetime, so the destructor is empty.
+ * @brief Currently, the executed object's lifetime is not coupled with
+ * the task object's lifetime, so the destructor is empty.
*/
virtual ~PeriodicTask(void);
@@ -53,58 +54,72 @@ public:
* The address of the task object is passed as an argument
* to the system call.
*/
- ReturnValue_t startTask(void);
+ ReturnValue_t startTask() override;
/**
* Adds an object to the list of objects to be executed.
* The objects are executed in the order added.
* @param object Id of the object to add.
- * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
+ * @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 addComponent(object_id_t object,
+ bool setTaskIF = true) override;
- uint32_t getPeriodMs() const;
+ uint32_t getPeriodMs() const override;
- ReturnValue_t sleepFor(uint32_t ms);
+ ReturnValue_t sleepFor(uint32_t ms) override;
protected:
bool started;
TaskHandle_t handle;
- typedef std::vector<ExecutableObjectIF*> ObjectList; //!< Typedef for the List of objects.
+ //! 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.
+ * @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.
+ * @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 It converts the argument back to the thread object type and copies the class instance
- * to the task context. The taskFunctionality method is called afterwards.
+ * @details
+ * It converts the argument back to the thread object type and copies the
+ * class instance to the task context. The taskFunctionality method is
+ * called afterwards.
* @param A pointer to the task object itself is passed as argument.
*/
static void taskEntryPoint(void* argument);
/**
* @brief The function containing the actual functionality of the task.
- * @details The method sets and starts
- * the task's period, then enters a loop that is repeated as long as the isRunning
- * attribute is true. Within the loop, all performOperation methods of the added
- * objects are called. Afterwards the checkAndRestartPeriod system call blocks the task
- * until the next period.
- * On missing the deadline, the deadlineMissedFunction is executed.
+ * @details
+ * The method sets and starts the task's period, then enters a loop that is
+ * repeated as long as the isRunning attribute is true. Within the loop,
+ * all performOperation methods of the added objects 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);
+
+ void checkMissedDeadline(const TickType_t xLastWakeTime,
+ const TickType_t interval);
+ void handleMissedDeadline();
};
-#endif /* MULTIOBJECTTASK_H_ */
+#endif /* PERIODICTASK_H_ */
diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index df5bbf930..c05f1030c 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -21,13 +21,18 @@ void* PeriodicPosixTask::taskEntryPoint(void* arg) {
return NULL;
}
-ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object) {
+ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object,
+ bool addTaskIF) {
ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
object);
- if (newObject == NULL) {
+ if (newObject == nullptr) {
return HasReturnvaluesIF::RETURN_FAILED;
}
objectList.push_back(newObject);
+
+ if(setTaskIF) {
+ newObject->setTaskIF(this);
+ }
return HasReturnvaluesIF::RETURN_OK;
}
diff --git a/osal/linux/PeriodicPosixTask.h b/osal/linux/PeriodicPosixTask.h
index 85de0d597..bf1a995be 100644
--- a/osal/linux/PeriodicPosixTask.h
+++ b/osal/linux/PeriodicPosixTask.h
@@ -39,11 +39,12 @@ public:
* @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);
+ ReturnValue_t addComponent(object_id_t object,
+ bool addTaskIF = true) override;
- uint32_t getPeriodMs() const;
+ uint32_t getPeriodMs() const override;
- ReturnValue_t sleepFor(uint32_t ms);
+ ReturnValue_t sleepFor(uint32_t ms) override;
private:
typedef std::vector<ExecutableObjectIF*> ObjectList; //!< Typedef for the List of objects.
diff --git a/tasks/PeriodicTaskIF.h b/tasks/PeriodicTaskIF.h
index 304a7de60..6f4909771 100644
--- a/tasks/PeriodicTaskIF.h
+++ b/tasks/PeriodicTaskIF.h
@@ -1,9 +1,11 @@
-#ifndef PERIODICTASKIF_H_
-#define PERIODICTASKIF_H_
+#ifndef FRAMEWORK_TASK_PERIODICTASKIF_H_
+#define FRAMEWORK_TASK_PERIODICTASKIF_H_
#include <framework/objectmanager/SystemObjectIF.h>
+#include <framework/timemanager/Clock.h>
#include <cstddef>
class ExecutableObjectIF;
+
/**
* New version of TaskIF
* Follows RAII principles, i.e. there's no create or delete method.
@@ -17,11 +19,27 @@ public:
*/
virtual ~PeriodicTaskIF() { }
/**
- * @brief With the startTask method, a created task can be started for the first time.
+ * @brief With the startTask method, a created task can be started
+ * for the first time.
*/
virtual ReturnValue_t startTask() = 0;
- virtual ReturnValue_t addComponent(object_id_t object) {return HasReturnvaluesIF::RETURN_FAILED;};
+ /**
+ * Add a component (object) to a periodic task. The pointer to the
+ * task can be set optionally
+ * @param object
+ * Add an object to the task. The most important case is to add an
+ * executable object with a function which will be called regularly
+ * (see ExecutableObjectIF)
+ * @param setTaskIF
+ * Can be used to specify whether the task object pointer is passed
+ * to the component.
+ * @return
+ */
+ virtual ReturnValue_t addComponent(object_id_t object,
+ bool setTaskIF = true) {
+ return HasReturnvaluesIF::RETURN_FAILED;
+ };
virtual ReturnValue_t sleepFor(uint32_t ms) = 0;