fsfw/tasks/FixedSlotSequence.h

173 lines
5.9 KiB
C
Raw Normal View History

2020-09-04 14:11:59 +02:00
#ifndef FSFW_TASKS_FIXEDSLOTSEQUENCE_H_
#define FSFW_TASKS_FIXEDSLOTSEQUENCE_H_
2020-09-04 13:52:54 +02:00
2020-09-04 14:11:59 +02:00
#include "FixedSequenceSlot.h"
2020-09-04 13:52:54 +02:00
#include "../objectmanager/SystemObject.h"
#include <set>
/**
2020-09-04 14:11:59 +02:00
* @brief This class is the representation of a
* Polling Sequence Table in software.
2020-09-04 13:52:54 +02:00
* @details
* The FixedSlotSequence object maintains the dynamic execution of
2020-09-04 14:11:59 +02:00
* objects with stricter timing requirements for the FixedTimeslotTask.
2020-09-04 13:52:54 +02:00
*
2020-09-04 14:11:59 +02:00
* The main idea is to create a list of executable objects (for example
* device handlers), to announce all handlers to the polling sequence and to
* maintain a list of polling slot objects.
* This slot list represents the Polling Sequence Table in software.
2020-09-04 13:52:54 +02:00
*
* Each polling slot contains information to indicate when and
2020-09-04 14:11:59 +02:00
* which executable object shall be executed within a given polling period.
* When adding a slot, a pointer to the executing task, a pointer to the
* executable object and a step number can be passed. The step number will be
* passed to the periodic handler.
* The sequence is executed by iterating through the slot sequence and
* executing the executable object in the correct timeslot.
2020-09-04 13:52:54 +02:00
*/
class FixedSlotSequence {
public:
using SlotList = std::multiset<FixedSequenceSlot>;
using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
/**
* @brief The constructor of the FixedSlotSequence object.
* @param setLength The period length, expressed in ms.
*/
FixedSlotSequence(uint32_t setLengthMs);
/**
* @brief The destructor of the FixedSlotSequence object.
2020-09-04 14:11:59 +02:00
* @details
* The destructor frees all allocated memory by iterating through the
* slotList and deleting all allocated resources.
2020-09-04 13:52:54 +02:00
*/
virtual ~FixedSlotSequence();
/**
* @brief This is a method to add an PollingSlot object to slotList.
*
2020-09-04 14:11:59 +02:00
* @details
* Here, a polling slot object is added to the slot list. It is appended
* to the end of the list. The list is currently NOT reordered.
* Afterwards, the iterator current is set to the beginning of the list.
* @param handlerId ID of the object to add
* @param setTime
* Value between (0 to 1) * slotLengthMs, when a FixedTimeslotTask
* will be called inside the slot period.
* @param setSequenceId
* ID which can be used to distinguish different task operations. This
* value will be passed to the executable function.
2020-09-04 13:52:54 +02:00
* @param
* @param
*/
void addSlot(object_id_t handlerId, uint32_t setTime, int8_t setSequenceId,
2020-09-04 14:11:59 +02:00
ExecutableObjectIF* executableObject,
PeriodicTaskIF* executingTask);
2020-09-04 13:52:54 +02:00
/**
2020-09-04 14:11:59 +02:00
* @brief Checks if the current slot shall be executed immediately
* after the one before.
* @details
* This allows to distinguish between grouped and separated handlers.
2020-09-04 13:52:54 +02:00
* @return - @c true if the slot has the same polling time as the previous
* - @c false else
*/
bool slotFollowsImmediately();
/**
* @brief This method returns the time until the next software
* component is invoked.
*
* @details
* This method is vitally important for the operation of the PST.
* By fetching the polling time of the current slot and that of the
* next one (or the first one, if the list end is reached)
* it calculates and returns the interval in milliseconds within
* which the handler execution shall take place.
* If the next slot has the same time as the current one, it is ignored
* until a slot with different time or the end of the PST is found.
*/
uint32_t getIntervalToNextSlotMs();
/**
* @brief This method returns the time difference between the current
* slot and the previous slot
*
* @details
* This method is vitally important for the operation of the PST.
* By fetching the polling time of the current slot and that of the previous
* one (or the last one, if the slot is the first one) it calculates and
* returns the interval in milliseconds that the handler execution shall
* be delayed.
*/
uint32_t getIntervalToPreviousSlotMs();
/**
* @brief This method returns the length of this FixedSlotSequence instance.
*/
uint32_t getLengthMs() const;
/**
* @brief The method to execute the device handler entered in the current
* PollingSlot object.
*
* @details
* Within this method the device handler object to be executed is chosen by
* looking up the handler address of the current slot in the handlerMap.
* Either the device handler's talkToInterface or its listenToInterface
* method is invoked, depending on the isTalking flag of the polling slot.
* After execution the iterator current is increased or, by reaching the
* end of slotList, reset to the beginning.
*/
void executeAndAdvance();
/**
* @brief An iterator that indicates the current polling slot to execute.
*
* @details This is an iterator for slotList and always points to the
* polling slot which is executed next.
*/
SlotListIter current;
/**
* @brief Check and initialize slot list.
* @details
* Checks if timing is ok (must be ascending) and if all handlers were found.
* @return
*/
ReturnValue_t checkSequence() const;
void addCustomCheck(ReturnValue_t (*customCheckFunction)(const SlotList &));
2020-09-04 14:11:59 +02:00
/**
* @brief Perform any initialization steps required after the executing
* task has been created. This function should be called from the
* executing task!
* @return
*/
2020-09-04 13:52:54 +02:00
ReturnValue_t intializeSequenceAfterTaskCreation() const;
protected:
/**
* @brief This list contains all PollingSlot objects, defining order and
* execution time of the device handler objects.
*
* @details
* The slot list is a std:list object that contains all created
* PollingSlot instances. They are NOT ordered automatically, so by
* adding entries, the correct order needs to be ensured. By iterating
* through this list the polling sequence is executed. Two entries with
* identical polling times are executed immediately one after another.
*/
SlotList slotList;
ReturnValue_t (*customCheckFunction)(const SlotList&) = nullptr;
2020-09-04 13:52:54 +02:00
uint32_t lengthMs;
};
2020-09-04 14:11:59 +02:00
#endif /* FSFW_TASKS_FIXEDSLOTSEQUENCE_H_ */