fsfw/osal/FreeRTOS/FixedTimeslotTask.cpp

158 lines
5.5 KiB
C++
Raw Normal View History

2018-07-13 15:56:37 +02:00
#include "FixedTimeslotTask.h"
2020-06-19 14:47:01 +02:00
#include <framework/serviceinterface/ServiceInterfaceStream.h>
2018-07-13 15:56:37 +02:00
uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = configMINIMAL_STACK_SIZE;
2018-07-13 15:56:37 +02:00
FixedTimeslotTask::FixedTimeslotTask(const char *name, TaskPriority setPriority,
TaskStackSize setStack, TaskPeriod overallPeriod,
void (*setDeadlineMissedFunc)()) :
started(false), handle(NULL), pst(overallPeriod * 1000) {
xTaskCreate(taskEntryPoint, name, setStack, this, setPriority, &handle);
// All additional attributes are applied to the object.
this->deadlineMissedFunc = setDeadlineMissedFunc;
}
FixedTimeslotTask::~FixedTimeslotTask() {
}
void FixedTimeslotTask::taskEntryPoint(void* argument) {
2020-06-19 14:47:01 +02:00
// 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));
2020-06-19 14:47:01 +02:00
/* 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 (not originalTask->started) {
2018-07-13 15:56:37 +02:00
vTaskSuspend(NULL);
}
originalTask->taskFunctionality();
sif::debug << "Polling task " << originalTask->handle
2018-07-13 15:56:37 +02:00
<< " returned from taskFunctionality." << std::endl;
}
void FixedTimeslotTask::missedDeadlineCounter() {
FixedTimeslotTask::deadlineMissedCount++;
if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
2018-07-13 15:56:37 +02:00
<< " deadlines." << std::endl;
}
}
ReturnValue_t FixedTimeslotTask::startTask() {
started = true;
// We must not call resume if scheduler is not started yet
if (xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED) {
vTaskResume(handle);
}
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
uint32_t slotTimeMs, int8_t executionStep) {
if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
2020-02-15 15:27:06 +01:00
pst.addSlot(componentId, slotTimeMs, executionStep, this);
return HasReturnvaluesIF::RETURN_OK;
}
2020-05-07 19:41:42 +02:00
sif::error << "Component " << std::hex << componentId <<
" not found, not adding it to pst" << std::endl;
2020-02-15 15:27:06 +01:00
return HasReturnvaluesIF::RETURN_FAILED;
2018-07-13 15:56:37 +02:00
}
uint32_t FixedTimeslotTask::getPeriodMs() const {
return pst.getLengthMs();
}
ReturnValue_t FixedTimeslotTask::checkSequence() const {
return pst.checkSequence();
}
void FixedTimeslotTask::taskFunctionality() {
2020-06-19 14:47:01 +02:00
// A local iterator for the Polling Sequence Table is created to find the
// start time for the first entry.
2020-07-06 12:36:01 +02:00
FixedSlotSequence::SlotListIter slotListIter = pst.current;
2018-07-13 15:56:37 +02:00
//The start time for the first entry is read.
2020-07-06 12:36:01 +02:00
uint32_t intervalMs = slotListIter->pollingTimeMs;
2018-07-13 15:56:37 +02:00
TickType_t interval = pdMS_TO_TICKS(intervalMs);
TickType_t xLastWakeTime;
/* The xLastWakeTime variable needs to be initialized with the current tick
2020-06-22 23:31:27 +02:00
count. Note that this is the only time the variable is written to
explicitly. After this assignment, xLastWakeTime is updated automatically
internally within vTaskDelayUntil(). */
2018-07-13 15:56:37 +02:00
xLastWakeTime = xTaskGetTickCount();
// wait for first entry's start time
2020-06-22 20:21:11 +02:00
if(interval > 0) {
vTaskDelayUntil(&xLastWakeTime, interval);
}
2018-07-13 15:56:37 +02:00
/* Enter the loop that defines the task behavior. */
for (;;) {
//The component for this slot is executed and the next one is chosen.
2020-06-19 14:47:01 +02:00
this->pst.executeAndAdvance();
if (not pst.slotFollowsImmediately()) {
2020-06-22 20:21:11 +02:00
// Get the interval till execution of the next slot.
intervalMs = this->pst.getIntervalToPreviousSlotMs();
interval = pdMS_TO_TICKS(intervalMs);
2020-06-22 23:30:17 +02:00
checkMissedDeadline(xLastWakeTime, interval);
2020-06-22 20:21:11 +02:00
// Wait for the interval. This exits immediately if a deadline was
// missed while also updating the last wake time.
2020-06-19 14:47:01 +02:00
vTaskDelayUntil(&xLastWakeTime, interval);
}
2018-07-13 15:56:37 +02:00
}
}
2020-06-22 23:30:17 +02:00
void FixedTimeslotTask::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;
// Time to wake has not overflown.
if(timeToWake > xLastWakeTime) {
/* If the current time has overflown exclusively or the current
* tick count is simply larger than the time to wake, a deadline was
* missed */
if((currentTickCount < xLastWakeTime) or (currentTickCount > timeToWake)) {
2020-06-22 23:30:17 +02:00
handleMissedDeadline();
}
}
/* Time to wake has overflown. A deadline was missed if the current time
* is larger than the time to wake */
else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
2020-06-22 23:30:17 +02:00
handleMissedDeadline();
}
}
void FixedTimeslotTask::handleMissedDeadline() {
#ifdef DEBUG
sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) <<
" missed deadline!\n" << std::flush;
#endif
if(deadlineMissedFunc != nullptr) {
this->deadlineMissedFunc();
}
}
2018-07-13 15:56:37 +02:00
ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
vTaskDelay(pdMS_TO_TICKS(ms));
return HasReturnvaluesIF::RETURN_OK;
}