Merge remote-tracking branch 'upstream/mueller/master' into mueller/master

inc/fsfw/FSFW.h

@@ -0,0 +1,7 @@
+#ifndef FSFW_FSFW_H_
+#define FSFW_FSFW_H_
+
+#include "FSFWConfig.h"
+
+
+#endif /* FSFW_FSFW_H_ */

inc/fsfw/FSFWVersion.h

@@ -0,0 +1,12 @@
+#ifndef FSFW_DEFAULTCFG_VERSION_H_
+#define FSFW_DEFAULTCFG_VERSION_H_
+
+const char* const FSFW_VERSION_NAME = "ASTP";
+
+#define FSFW_VERSION        1
+#define	FSFW_SUBVERSION     0
+#define	FSFW_REVISION       0
+
+
+
+#endif /* FSFW_DEFAULTCFG_VERSION_H_ */

inc/fsfw/action.h

@@ -0,0 +1,11 @@
+#ifndef FSFW_INC_FSFW_ACTION_H_
+#define FSFW_INC_FSFW_ACTION_H_
+
+#include "action/ActionHelper.h"
+#include "action/ActionMessage.h"
+#include "action/CommandActionHelper.h"
+#include "action/HasActionsIF.h"
+#include "action/CommandsActionsIF.h"
+#include "action/SimpleActionHelper.h"
+
+#endif /* FSFW_INC_FSFW_ACTION_H_ */

inc/fsfw/action/ActionHelper.h

@@ -0,0 +1,126 @@
+#ifndef FSFW_ACTION_ACTIONHELPER_H_
+#define FSFW_ACTION_ACTIONHELPER_H_
+
+#include "ActionMessage.h"
+#include "../serialize/SerializeIF.h"
+#include "../ipc/MessageQueueIF.h"
+/**
+ * @brief Action Helper is a helper class which handles action messages
+ *
+ * Components which use the HasActionIF this helper can be used to handle
+ * the action messages.
+ * It does handle step messages as well as other answers to action calls.
+ * It uses the executeAction function of its owner as callback.
+ * The call of the initialize function is mandatory and needs a
+ * valid MessageQueueIF pointer!
+ */
+class HasActionsIF;
+
+class ActionHelper {
+public:
+    /**
+     * Constructor of the action helper
+     * @param setOwner Pointer to the owner of the interface
+     * @param useThisQueue  messageQueue to be used, can be set during
+     *                      initialize function as well.
+     */
+    ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
+
+    virtual ~ActionHelper();
+    /**
+     * Function to be called from the owner with a new command message
+     *
+     * If the message is a valid action message the helper will use the
+     * executeAction function from HasActionsIF.
+     * If the message is invalid or the callback fails a message reply will be
+     * send to the sender of the message automatically.
+     *
+     * @param command Pointer to a command message received by the owner
+     * @return HasReturnvaluesIF::RETURN_OK if the message is a action message,
+     *         CommandMessage::UNKNOW_COMMAND if this message ID is unkown
+     */
+    ReturnValue_t handleActionMessage(CommandMessage* command);
+    /**
+     * Helper initialize function. Must be called before use of any other
+     * helper function
+     * @param queueToUse_   Pointer to the messageQueue to be used, optional
+     *                      if queue was set in constructor
+     * @return Returns RETURN_OK if successful
+     */
+    ReturnValue_t initialize(MessageQueueIF* queueToUse_ = nullptr);
+    /**
+     * Function to be called from the owner to send a step message.
+     * Success or failure will be determined by the result value.
+     *
+     * @param step Number of steps already done
+     * @param reportTo The messageQueueId to report the step message to
+     * @param commandId ID of the executed command
+     * @param result Result of the execution
+     */
+    void step(uint8_t step, MessageQueueId_t reportTo,
+            ActionId_t commandId,
+            ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+    /**
+     * Function to be called by the owner to send a action completion message
+     * @param success   Specify whether action was completed successfully or not.
+     * @param reportTo MessageQueueId_t to report the action completion message to
+     * @param commandId ID of the executed command
+     * @param result Result of the execution
+     */
+    void finish(bool success, MessageQueueId_t reportTo, ActionId_t commandId,
+            ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+    /**
+     * Function to be called by the owner if an action does report data.
+     * Takes a SerializeIF* pointer and serializes it into the IPC store.
+     * @param reportTo  MessageQueueId_t to report the action completion
+     *                  message to
+     * @param replyId ID of the executed command
+     * @param data Pointer to the data
+     * @return Returns RETURN_OK if successful, otherwise failure code
+     */
+    ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId,
+            SerializeIF* data, bool hideSender = false);
+    /**
+     * Function to be called by the owner if an action does report data.
+     * Takes the raw data and writes it into the IPC store.
+     * @param reportTo  MessageQueueId_t to report the action completion
+     *                  message to
+     * @param replyId ID of the executed command
+     * @param data Pointer to the data
+     * @return Returns RETURN_OK if successful, otherwise failure code
+     */
+    ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId,
+            const uint8_t* data, size_t dataSize, bool hideSender = false);
+    /**
+     * Function to setup the MessageQueueIF* of the helper. Can be used to
+     * set the MessageQueueIF* if message queue is unavailable at construction
+     * and initialize but must be setup before first call of other functions.
+     * @param queue Queue to be used by the helper
+     */
+    void setQueueToUse(MessageQueueIF *queue);
+protected:
+    //! Increase of value of this per step
+    static const uint8_t STEP_OFFSET = 1;
+    //! Pointer to the owner
+    HasActionsIF* owner;
+    //! Queue to be used as response sender, has to be set in ctor or with
+    //! setQueueToUse
+    MessageQueueIF* queueToUse;
+    //! Pointer to an IPC Store, initialized during construction or
+    StorageManagerIF* ipcStore = nullptr;
+
+    /**
+     * Internal function called by handleActionMessage
+     * @param commandedBy MessageQueueID of Commander
+     * @param actionId ID of action to be done
+     * @param dataAddress Address of additional data in IPC Store
+     */
+    virtual void prepareExecution(MessageQueueId_t commandedBy,
+            ActionId_t actionId, store_address_t dataAddress);
+    /**
+     * @brief Default implementation is empty.
+     */
+    virtual void resetHelper();
+};
+
+#endif /* FSFW_ACTION_ACTIONHELPER_H_ */

inc/fsfw/action/ActionMessage.h

@@ -0,0 +1,47 @@
+#ifndef FSFW_ACTION_ACTIONMESSAGE_H_
+#define FSFW_ACTION_ACTIONMESSAGE_H_
+
+#include "fsfw/ipc/CommandMessage.h"
+#include "fsfw/objectmanager/ObjectManagerIF.h"
+#include "fsfw/storagemanager/StorageManagerIF.h"
+
+using ActionId_t = uint32_t;
+
+/**
+ * @brief   These messages are part of the action module of the FSFW.
+ * @details
+ * These messages are sent amongst objects implementing the HasActionsIF. Classes like the
+ * ActionHelper are able to process these messages.
+ */
+class ActionMessage {
+private:
+    ActionMessage();
+public:
+    static const uint8_t MESSAGE_ID = messagetypes::ACTION;
+    static const Command_t EXECUTE_ACTION = MAKE_COMMAND_ID(1);
+    static const Command_t STEP_SUCCESS = MAKE_COMMAND_ID(2);
+    static const Command_t STEP_FAILED = MAKE_COMMAND_ID(3);
+    static const Command_t DATA_REPLY =  MAKE_COMMAND_ID(4);
+    static const Command_t COMPLETION_SUCCESS = MAKE_COMMAND_ID(5);
+    static const Command_t COMPLETION_FAILED = MAKE_COMMAND_ID(6);
+
+    virtual ~ActionMessage();
+    static void setCommand(CommandMessage* message, ActionId_t fid,
+            store_address_t parameters);
+
+    static ActionId_t getActionId(const CommandMessage* message );
+    static store_address_t getStoreId(const CommandMessage* message);
+
+    static void setStepReply(CommandMessage* message, ActionId_t fid,
+            uint8_t step, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+    static uint8_t getStep(const CommandMessage* message );
+    static ReturnValue_t getReturnCode(const CommandMessage* message );
+    static void setDataReply(CommandMessage* message, ActionId_t actionId,
+            store_address_t data);
+    static void setCompletionReply(CommandMessage* message, ActionId_t fid,
+            bool success, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+
+    static void clear(CommandMessage* message);
+};
+
+#endif /* FSFW_ACTION_ACTIONMESSAGE_H_ */

inc/fsfw/action/CommandActionHelper.h

@@ -0,0 +1,36 @@
+#ifndef COMMANDACTIONHELPER_H_
+#define COMMANDACTIONHELPER_H_
+
+#include "ActionMessage.h"
+#include "fsfw/objectmanager/ObjectManagerIF.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/serialize/SerializeIF.h"
+#include "fsfw/storagemanager/StorageManagerIF.h"
+#include "fsfw/ipc/MessageQueueIF.h"
+
+class CommandsActionsIF;
+
+class CommandActionHelper {
+    friend class CommandsActionsIF;
+public:
+    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;
+private:
+    CommandsActionsIF* owner;
+    MessageQueueIF* queueToUse;
+    StorageManagerIF* ipcStore;
+    uint8_t commandCount;
+    MessageQueueId_t lastTarget;
+    void extractDataForOwner(ActionId_t actionId, store_address_t storeId);
+    ReturnValue_t sendCommand(MessageQueueId_t queueId, ActionId_t actionId,
+            store_address_t storeId);
+};
+
+#endif /* COMMANDACTIONHELPER_H_ */

inc/fsfw/action/CommandsActionsIF.h

@@ -0,0 +1,37 @@
+#ifndef FSFW_ACTION_COMMANDSACTIONSIF_H_
+#define FSFW_ACTION_COMMANDSACTIONSIF_H_
+
+#include "CommandActionHelper.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueIF.h"
+
+/**
+ * Interface to separate commanding actions of other objects.
+ * In next iteration, IF should be shortened to three calls:
+ * - dataReceived(data)
+ * - successReceived(id, step)
+ * - failureReceived(id, step, cause)
+ * or even
+ * - replyReceived(id, step, cause) (if cause == OK, it's a success).
+ */
+class CommandsActionsIF {
+    friend class CommandActionHelper;
+public:
+    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 MessageQueueIF* getCommandQueuePtr() = 0;
+protected:
+    virtual void stepSuccessfulReceived(ActionId_t actionId, uint8_t step) = 0;
+    virtual void stepFailedReceived(ActionId_t actionId, uint8_t step,
+            ReturnValue_t returnCode) = 0;
+    virtual void dataReceived(ActionId_t actionId, const uint8_t* data,
+            uint32_t size) = 0;
+    virtual void completionSuccessfulReceived(ActionId_t actionId) = 0;
+    virtual void completionFailedReceived(ActionId_t actionId,
+            ReturnValue_t returnCode) = 0;
+};
+
+
+#endif /* FSFW_ACTION_COMMANDSACTIONSIF_H_ */

inc/fsfw/action/HasActionsIF.h

@@ -0,0 +1,63 @@
+#ifndef FSFW_ACTION_HASACTIONSIF_H_
+#define FSFW_ACTION_HASACTIONSIF_H_
+
+#include "ActionHelper.h"
+#include "ActionMessage.h"
+#include "SimpleActionHelper.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueIF.h"
+
+/**
+ * @brief
+ * Interface for component which uses actions
+ *
+ * @details
+ * This interface is used to execute actions in the component. Actions, in the
+ * sense of this interface, are activities with a well-defined beginning and
+ * end in time. They may adjust sub-states of components, but are not supposed
+ * to change the main mode of operation, which is handled with the HasModesIF
+ * described below.
+ *
+ * The HasActionsIF allows components to define such actions and make them
+ * available for other components to use. Implementing the interface is
+ * straightforward: There’s a single executeAction call, which provides an
+ * identifier for the action to execute, as well as arbitrary parameters for
+ * input.
+ * Aside from direct, software-based actions, it is used in device handler
+ * components as an interface to forward commands to devices.
+ * Implementing components of the interface are supposed to check identifier
+ * (ID) and parameters and immediately start execution of the action.
+ * It is, however, not required to immediately finish execution.
+ * Instead, this may be deferred to a later point in time, at which the
+ * component needs to inform the caller about finished or failed execution.
+ *
+ * @ingroup interfaces
+ */
+class HasActionsIF {
+public:
+    static const uint8_t INTERFACE_ID = CLASS_ID::HAS_ACTIONS_IF;
+    static const ReturnValue_t IS_BUSY = MAKE_RETURN_CODE(1);
+    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() { }
+    /**
+     * Function to get the MessageQueueId_t of the implementing object
+     * @return MessageQueueId_t of the object
+     */
+    virtual MessageQueueId_t getCommandQueue() const = 0;
+    /**
+     * Execute or initialize the execution of a certain function.
+     * The ActionHelpers will execute this function and behave differently
+     * depending on the returnvalue.
+     *
+     * @return
+     * -@c EXECUTION_FINISHED Finish reply will be generated
+     * -@c Not RETURN_OK Step failure reply will be generated
+     */
+    virtual ReturnValue_t executeAction(ActionId_t actionId,
+            MessageQueueId_t commandedBy, const uint8_t* data, size_t size) = 0;
+};
+
+
+#endif /* FSFW_ACTION_HASACTIONSIF_H_ */

inc/fsfw/action/SimpleActionHelper.h

@@ -0,0 +1,30 @@
+#ifndef FSFW_ACTION_SIMPLEACTIONHELPER_H_
+#define FSFW_ACTION_SIMPLEACTIONHELPER_H_
+
+#include "ActionHelper.h"
+
+/**
+ * @brief    This is an action helper which is only able to service one action
+ *             at a time but remembers last commander and last action which
+ *             simplifies usage
+ */
+class SimpleActionHelper: public ActionHelper {
+public:
+    SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
+    virtual ~SimpleActionHelper();
+    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();
+private:
+    bool isExecuting;
+    MessageQueueId_t lastCommander = MessageQueueIF::NO_QUEUE;
+    ActionId_t lastAction = 0;
+    uint8_t stepCount = 0;
+};
+
+#endif /* SIMPLEACTIONHELPER_H_ */

inc/fsfw/container/ArrayList.h

@@ -0,0 +1,253 @@
+#ifndef FSFW_CONTAINER_ARRAYLIST_H_
+#define FSFW_CONTAINER_ARRAYLIST_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serialize/SerializeIF.h"
+
+/**
+ * @brief     A List that stores its values in an array.
+ * @details
+ * The underlying storage is an array that can be allocated by the class
+ * itself or supplied via ctor.
+ *
+ * @ingroup container
+ */
+template<typename T, typename count_t = uint8_t>
+class ArrayList {
+    template<typename U, typename count> friend class SerialArrayListAdapter;
+public:
+    static const uint8_t INTERFACE_ID = CLASS_ID::ARRAY_LIST;
+    static const ReturnValue_t FULL = MAKE_RETURN_CODE(0x01);
+
+    /**
+     * This is the allocating constructor.
+     * It allocates an array of the specified size.
+     * @param maxSize
+     */
+    ArrayList(count_t maxSize) :
+        size(0), maxSize_(maxSize), allocated(true) {
+        entries = new T[maxSize];
+    }
+
+    /**
+     * This is the non-allocating constructor
+     *
+     * It expects a pointer to an array of a certain size and initializes
+     * itself to it.
+     *
+     * @param storage the array to use as backend
+     * @param maxSize size of storage
+     * @param size size of data already present in storage
+     */
+    ArrayList(T *storage, count_t maxSize, count_t size = 0) :
+        size(size), entries(storage), maxSize_(maxSize), allocated(false) {
+    }
+
+    /**
+     * Copying is forbiden by declaring copy ctor and copy assignment deleted
+     * It is too ambigous in this case.
+     * (Allocate a new backend? Use the same? What to do in an modifying call?)
+     */
+    ArrayList(const ArrayList& other) = delete;
+    const ArrayList& operator=(const ArrayList& other) = delete;
+
+    /**
+     * Number of Elements stored in this List
+     */
+    count_t size;
+
+
+    /**
+     * Destructor, if the allocating constructor was used, it deletes the array.
+     */
+    virtual ~ArrayList() {
+        if (allocated) {
+            delete[] entries;
+        }
+    }
+
+    /**
+     * An Iterator to go trough an ArrayList
+     *
+     * It stores a pointer to an element and increments the
+     * pointer when incremented itself.
+     */
+    class Iterator {
+    public:
+        /**
+         * Empty ctor, points to NULL
+         */
+        Iterator(): value(0) {}
+
+        /**
+         * Initializes the Iterator to point to an element
+         *
+         * @param initialize
+         */
+        Iterator(T *initialize) {
+            value = initialize;
+        }
+
+        /**
+         * The current element the iterator points to
+         */
+        T *value;
+
+        Iterator& operator++() {
+            value++;
+            return *this;
+        }
+
+        Iterator operator++(int) {
+            Iterator tmp(*this);
+            operator++();
+            return tmp;
+        }
+
+        Iterator& operator--() {
+            value--;
+            return *this;
+        }
+
+        Iterator operator--(int) {
+            Iterator tmp(*this);
+            operator--();
+            return tmp;
+        }
+
+        T& operator*() {
+            return *value;
+        }
+
+        const T& operator*() const {
+            return *value;
+        }
+
+        T *operator->() {
+            return value;
+        }
+
+        const T *operator->() const {
+            return value;
+        }
+    };
+
+    friend bool operator==(const ArrayList::Iterator& lhs,
+            const ArrayList::Iterator& rhs) {
+        return (lhs.value == rhs.value);
+    }
+
+    friend bool operator!=(const ArrayList::Iterator& lhs,
+            const ArrayList::Iterator& rhs) {
+        return not (lhs.value == rhs.value);
+    }
+
+    /**
+     * Iterator pointing to the first stored elmement
+     *
+     * @return Iterator to the first element
+     */
+    Iterator begin() const {
+        return Iterator(&entries[0]);
+    }
+
+    /**
+     * returns an Iterator pointing to the element after the last stored entry
+     *
+     * @return Iterator to the element after the last entry
+     */
+    Iterator end() const {
+        return Iterator(&entries[size]);
+    }
+
+    T & operator[](count_t i) const {
+        return entries[i];
+    }
+
+    /**
+     * The first element
+     *
+     * @return pointer to the first stored element
+     */
+    T *front() {
+        return entries;
+    }
+
+    /**
+     * The last element
+     *
+     * does not return a valid pointer if called on an empty list.
+     *
+     * @return pointer to the last stored element
+     */
+    T *back() {
+        return &entries[size - 1];
+        //Alternative solution
+        //return const_cast<T*>(static_cast<const T*>(*this).back());
+    }
+
+    const T* back() const{
+        return &entries[size-1];
+    }
+
+    /**
+     * The maximum number of elements this List can contain
+     *
+     * @return maximum number of elements
+     */
+    size_t maxSize() const {
+        return this->maxSize_;
+    }
+
+    /**
+     * Insert a new element into the list.
+     *
+     * The new element is inserted after the last stored element.
+     *
+     * @param entry
+     * @return
+     *          -@c FULL if the List is full
+     *          -@c RETURN_OK else
+     */
+    ReturnValue_t insert(T entry) {
+        if (size >= maxSize_) {
+            return FULL;
+        }
+        entries[size] = entry;
+        ++size;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
+    /**
+     * clear the List
+     *
+     * This does not actually clear all entries, it only sets the size to 0.
+     */
+    void clear() {
+        size = 0;
+    }
+
+    count_t remaining() {
+        return (maxSize_ - size);
+    }
+
+protected:
+    /**
+     * pointer to the array in which the entries are stored
+     */
+    T *entries;
+    /**
+     * remembering the maximum size
+     */
+    size_t maxSize_;
+
+    /**
+     * true if the array was allocated and needs to be deleted in the destructor.
+     */
+    bool allocated;
+};
+
+
+
+#endif /* FSFW_CONTAINER_ARRAYLIST_H_ */

inc/fsfw/container/BinaryTree.h

@@ -0,0 +1,153 @@
+#ifndef FRAMEWORK_CONTAINER_BINARYTREE_H_
+#define FRAMEWORK_CONTAINER_BINARYTREE_H_
+
+#include <stddef.h>
+#include <stdint.h>
+#include <map>
+template<typename Tp>
+class BinaryNode {
+public:
+    BinaryNode(Tp* setValue) :
+            value(setValue), left(NULL), right(NULL), parent(NULL) {
+    }
+    Tp *value;
+    BinaryNode* left;
+    BinaryNode* right;
+    BinaryNode* parent;
+};
+
+template<typename Tp>
+class ExplicitNodeIterator {
+public:
+    typedef ExplicitNodeIterator<Tp> _Self;
+    typedef BinaryNode<Tp> _Node;
+    typedef Tp value_type;
+    typedef Tp* pointer;
+    typedef Tp& reference;
+    ExplicitNodeIterator() :
+            element(NULL) {
+    }
+    ExplicitNodeIterator(_Node* node) :
+            element(node) {
+    }
+    BinaryNode<Tp>* element;
+    _Self up() {
+        return _Self(element->parent);
+    }
+    _Self left() {
+        if (element != NULL) {
+            return _Self(element->left);
+        } else {
+            return _Self(NULL);
+        }
+
+    }
+    _Self right() {
+        if (element != NULL) {
+            return _Self(element->right);
+        } else {
+            return _Self(NULL);
+        }
+
+    }
+    bool operator==(const _Self& __x) const {
+        return element == __x.element;
+    }
+    bool operator!=(const _Self& __x) const {
+        return element != __x.element;
+    }
+    pointer
+    operator->() const {
+        if (element != NULL) {
+            return element->value;
+        } else {
+            return NULL;
+        }
+    }
+    pointer operator*() const {
+        return this->operator->();
+    }
+};
+
+/**
+ * Pretty rudimentary version of a simple binary tree (not a binary search tree!).
+ */
+template<typename Tp>
+class BinaryTree {
+public:
+    typedef ExplicitNodeIterator<Tp> iterator;
+    typedef BinaryNode<Tp> Node;
+    typedef std::pair<iterator, iterator> children;
+    BinaryTree() :
+            rootNode(NULL) {
+    }
+    BinaryTree(Node* rootNode) :
+            rootNode(rootNode) {
+    }
+    iterator begin() const {
+        return iterator(rootNode);
+    }
+    static iterator end() {
+        return iterator(NULL);
+    }
+    iterator insert(bool insertLeft, iterator parentNode, Node* newNode ) {
+        newNode->parent = parentNode.element;
+        if (parentNode.element != NULL) {
+            if (insertLeft) {
+                parentNode.element->left = newNode;
+            } else {
+                parentNode.element->right = newNode;
+            }
+        } else {
+            //Insert first element.
+            rootNode = newNode;
+        }
+        return iterator(newNode);
+    }
+    //No recursion to children. Needs to be done externally.
+    children erase(iterator node) {
+        if (node.element == rootNode) {
+            //We're root node
+            rootNode = NULL;
+        } else {
+            //Delete parent's reference
+            if (node.up().left() == node) {
+                node.up().element->left = NULL;
+            } else {
+                node.up().element->right = NULL;
+            }
+        }
+        return children(node.element->left, node.element->right);
+    }
+    static uint32_t countLeft(iterator start) {
+        if (start == end()) {
+            return 0;
+        }
+        //We also count the start node itself.
+        uint32_t count = 1;
+        while (start.left() != end()) {
+            count++;
+            start = start.left();
+        }
+        return count;
+    }
+    static uint32_t countRight(iterator start) {
+        if (start == end()) {
+            return 0;
+        }
+        //We also count the start node itself.
+        uint32_t count = 1;
+        while (start.right() != end()) {
+            count++;
+            start = start.right();
+        }
+        return count;
+    }
+
+protected:
+    Node* rootNode;
+};
+
+
+
+#endif /* FRAMEWORK_CONTAINER_BINARYTREE_H_ */

inc/fsfw/container/DynamicFIFO.h

@@ -0,0 +1,55 @@
+#ifndef FSFW_CONTAINER_DYNAMICFIFO_H_
+#define FSFW_CONTAINER_DYNAMICFIFO_H_
+
+#include "FIFOBase.h"
+#include <vector>
+
+/**
+ * @brief     Simple First-In-First-Out data structure. The maximum size
+ *             can be set in the constructor.
+ * @details
+ * The maximum capacity can be determined at run-time, so this container
+ * performs dynamic memory allocation!
+ * The public interface of FIFOBase exposes the user interface for the FIFO.
+ * @tparam T Entry Type
+ * @tparam capacity Maximum capacity
+ */
+template<typename T>
+class DynamicFIFO: public FIFOBase<T> {
+public:
+    DynamicFIFO(size_t maxCapacity): FIFOBase<T>(nullptr, maxCapacity),
+            fifoVector(maxCapacity)  {
+        // trying to pass the pointer of the uninitialized vector
+        // to the FIFOBase constructor directly lead to a super evil bug.
+        // So we do it like this now.
+        this->setContainer(fifoVector.data());
+    };
+
+    /**
+     * @brief    Custom copy constructor which prevents setting the
+     *             underlying pointer wrong. This function allocates memory!
+     * @details This is a very heavy operation so try to avoid this!
+     *
+     */
+    DynamicFIFO(const DynamicFIFO& other): FIFOBase<T>(other),
+            fifoVector(other.maxCapacity) {
+        this->fifoVector = other.fifoVector;
+        this->setContainer(fifoVector.data());
+    }
+
+    /**
+     * @brief Custom assignment operator
+     * @details This is a very heavy operation so try to avoid this!
+     * @param other DyamicFIFO to copy from
+     */
+    DynamicFIFO& operator=(const DynamicFIFO& other){
+        FIFOBase<T>::operator=(other);
+        this->fifoVector = other.fifoVector;
+        this->setContainer(fifoVector.data());
+        return *this;
+    }
+private:
+    std::vector<T> fifoVector;
+};
+
+#endif /* FSFW_CONTAINER_DYNAMICFIFO_H_ */

inc/fsfw/container/FIFO.h

@@ -0,0 +1,47 @@
+#ifndef FSFW_CONTAINER_FIFO_H_
+#define FSFW_CONTAINER_FIFO_H_
+
+#include "FIFOBase.h"
+#include <array>
+
+/**
+ * @brief     Simple First-In-First-Out data structure with size fixed at
+ *             compile time
+ * @details
+ * Performs no dynamic memory allocation.
+ * The public interface of FIFOBase exposes the user interface for the FIFO.
+ * @tparam T Entry Type
+ * @tparam capacity Maximum capacity
+ */
+template<typename T, size_t capacity>
+class FIFO: public FIFOBase<T> {
+public:
+    FIFO(): FIFOBase<T>(nullptr, capacity) {
+        this->setContainer(fifoArray.data());
+    };
+
+    /**
+     * @brief     Custom copy constructor to set pointer correctly.
+     * @param other
+     */
+    FIFO(const FIFO& other): FIFOBase<T>(other) {
+        this->fifoArray = other.fifoArray;
+        this->setContainer(fifoArray.data());
+    }
+
+    /**
+     * @brief Custom assignment operator
+     * @param other
+     */
+    FIFO& operator=(const FIFO& other){
+        FIFOBase<T>::operator=(other);
+        this->fifoArray = other.fifoArray;
+        this->setContainer(fifoArray.data());
+        return *this;
+    }
+
+private:
+    std::array<T, capacity> fifoArray;
+};
+
+#endif /* FSFW_CONTAINER_FIFO_H_ */

inc/fsfw/container/FIFOBase.h

@@ -0,0 +1,79 @@
+#ifndef FSFW_CONTAINER_FIFOBASE_H_
+#define FSFW_CONTAINER_FIFOBASE_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstddef>
+#include <cstring>
+
+template <typename T>
+class FIFOBase {
+public:
+    static const uint8_t INTERFACE_ID = CLASS_ID::FIFO_CLASS;
+    static const ReturnValue_t FULL = MAKE_RETURN_CODE(1);
+    static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(2);
+
+    /** Default ctor, takes pointer to first entry of underlying container
+     *  and maximum capacity */
+    FIFOBase(T* values, const size_t maxCapacity);
+
+    /**
+     * Insert value into FIFO
+     * @param value
+     * @return RETURN_OK on success, FULL if full
+     */
+    ReturnValue_t insert(T value);
+    /**
+     * Retrieve item from FIFO. This removes the item from the FIFO.
+     * @param value Must point to a valid T
+     * @return RETURN_OK on success, EMPTY if empty and FAILED if nullptr check failed
+     */
+    ReturnValue_t retrieve(T *value);
+    /**
+     * Retrieve item from FIFO without removing it from FIFO.
+     * @param value Must point to a valid T
+     * @return RETURN_OK on success, EMPTY if empty and FAILED if nullptr check failed
+     */
+    ReturnValue_t peek(T * value);
+    /**
+     * Remove item from FIFO.
+     * @return RETURN_OK on success, EMPTY if empty
+     */
+    ReturnValue_t pop();
+
+    /***
+     * Check if FIFO is empty
+     * @return True if empty, False if not
+     */
+    bool empty();
+    /***
+     * Check if FIFO is Full
+     * @return True if full, False if not
+     */
+    bool full();
+    /***
+     *  Current used size (elements) used
+     * @return size_t in elements
+     */
+    size_t size();
+    /***
+     * Get maximal capacity of fifo
+     * @return size_t with max capacity of this fifo
+     */
+    size_t getMaxCapacity() const;
+
+protected:
+    void setContainer(T* data);
+    size_t maxCapacity = 0;
+
+    T* values;
+
+    size_t readIndex = 0;
+    size_t writeIndex = 0;
+    size_t currentSize = 0;
+
+    size_t next(size_t current);
+};
+
+#include "FIFOBase.tpp"
+
+#endif /* FSFW_CONTAINER_FIFOBASE_H_ */

inc/fsfw/container/FIFOBase.tpp

@@ -0,0 +1,93 @@
+#ifndef FSFW_CONTAINER_FIFOBASE_TPP_
+#define FSFW_CONTAINER_FIFOBASE_TPP_
+
+#ifndef FSFW_CONTAINER_FIFOBASE_H_
+#error Include FIFOBase.h before FIFOBase.tpp!
+#endif
+
+template<typename T>
+inline FIFOBase<T>::FIFOBase(T* values, const size_t maxCapacity):
+        maxCapacity(maxCapacity), values(values){};
+
+template<typename T>
+inline ReturnValue_t FIFOBase<T>::insert(T value) {
+    if (full()) {
+        return FULL;
+    } else {
+        values[writeIndex] = value;
+        writeIndex = next(writeIndex);
+        ++currentSize;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+};
+
+template<typename T>
+inline ReturnValue_t FIFOBase<T>::retrieve(T* value) {
+    if (empty()) {
+        return EMPTY;
+    } else {
+        if (value == nullptr){
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        *value = values[readIndex];
+        readIndex = next(readIndex);
+        --currentSize;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+};
+
+template<typename T>
+inline ReturnValue_t FIFOBase<T>::peek(T* value) {
+    if(empty()) {
+        return EMPTY;
+    } else {
+        if (value == nullptr){
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        *value = values[readIndex];
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+};
+
+template<typename T>
+inline ReturnValue_t FIFOBase<T>::pop() {
+    T value;
+    return this->retrieve(&value);
+};
+
+template<typename T>
+inline bool FIFOBase<T>::empty() {
+    return (currentSize == 0);
+};
+
+template<typename T>
+inline bool FIFOBase<T>::full() {
+    return (currentSize == maxCapacity);
+}
+
+template<typename T>
+inline size_t FIFOBase<T>::size() {
+    return currentSize;
+}
+
+template<typename T>
+inline size_t FIFOBase<T>::next(size_t current) {
+    ++current;
+    if (current == maxCapacity) {
+        current = 0;
+    }
+    return current;
+}
+
+template<typename T>
+inline size_t FIFOBase<T>::getMaxCapacity() const {
+    return maxCapacity;
+}
+
+
+template<typename T>
+inline void FIFOBase<T>::setContainer(T *data) {
+    this->values = data;
+}
+
+#endif

inc/fsfw/container/FixedArrayList.h

@@ -0,0 +1,40 @@
+#ifndef FIXEDARRAYLIST_H_
+#define FIXEDARRAYLIST_H_
+
+#include "ArrayList.h"
+#include <cmath>
+/**
+ * \ingroup container
+ */
+template<typename T, size_t MAX_SIZE, typename count_t = uint8_t>
+class FixedArrayList: public ArrayList<T, count_t> {
+#if !defined(_MSC_VER)
+    static_assert(MAX_SIZE <= (std::pow(2,sizeof(count_t)*8)-1), "count_t is not large enough to hold MAX_SIZE");
+#endif
+private:
+    T data[MAX_SIZE];
+public:
+    FixedArrayList() :
+            ArrayList<T, count_t>(data, MAX_SIZE) {
+    }
+
+    FixedArrayList(const FixedArrayList& other) :
+            ArrayList<T, count_t>(data, MAX_SIZE) {
+        memcpy(this->data, other.data, sizeof(this->data));
+        this->entries = data;
+        this->size = other.size;
+    }
+
+    FixedArrayList& operator=(FixedArrayList other) {
+        memcpy(this->data, other.data, sizeof(this->data));
+        this->entries = data;
+        this->size = other.size;
+        return *this;
+    }
+
+    virtual ~FixedArrayList() {
+    }
+
+};
+
+#endif /* FIXEDARRAYLIST_H_ */

inc/fsfw/container/FixedMap.h

@@ -0,0 +1,230 @@
+#ifndef FSFW_CONTAINER_FIXEDMAP_H_
+#define FSFW_CONTAINER_FIXEDMAP_H_
+
+#include "ArrayList.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <utility>
+#include <type_traits>
+
+/**
+ * @brief    Map implementation for maps with a pre-defined size.
+ * @details
+ * Can be initialized with desired maximum size.
+ * Iterator is used to access <key,value> pair and iterate through map entries.
+ * Complexity O(n).
+ * @warning Iterators return a non-const key_t in the pair.
+ * @warning A User is not allowed to change the key, otherwise the map is corrupted.
+ * @ingroup container
+ */
+template<typename key_t, typename T>
+class FixedMap: public SerializeIF {
+    static_assert (std::is_trivially_copyable<T>::value or
+            std::is_base_of<SerializeIF, T>::value,
+            "Types used in FixedMap must either be trivial copy-able or a "
+            "derived class from SerializeIF to be serialize-able");
+public:
+    static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MAP;
+    static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
+    static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
+    static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
+
+private:
+    static const key_t EMPTY_SLOT = -1;
+    ArrayList<std::pair<key_t, T>, uint32_t> theMap;
+    uint32_t _size;
+
+    uint32_t findIndex(key_t key) const {
+        if (_size == 0) {
+            return 1;
+        }
+        uint32_t i = 0;
+        for (i = 0; i < _size; ++i) {
+            if (theMap[i].first == key) {
+                return i;
+            }
+        }
+        return i;
+    }
+public:
+    FixedMap(uint32_t maxSize) :
+            theMap(maxSize), _size(0) {
+    }
+
+    class Iterator: public ArrayList<std::pair<key_t, T>, uint32_t>::Iterator {
+    public:
+        Iterator() :
+                ArrayList<std::pair<key_t, T>, uint32_t>::Iterator() {
+        }
+
+        Iterator(std::pair<key_t, T> *pair) :
+                ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair) {
+        }
+    };
+
+    friend bool operator==(const typename FixedMap::Iterator& lhs,
+            const typename FixedMap::Iterator& rhs) {
+        return (lhs.value == rhs.value);
+    }
+
+    friend bool operator!=(const typename FixedMap::Iterator& lhs,
+            const typename FixedMap::Iterator& rhs) {
+        return not (lhs.value == rhs.value);
+    }
+
+    Iterator begin() const {
+        return Iterator(&theMap[0]);
+    }
+
+    Iterator end() const {
+        return Iterator(&theMap[_size]);
+    }
+
+    uint32_t size() const {
+        return _size;
+    }
+
+    ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr) {
+        if (exists(key) == HasReturnvaluesIF::RETURN_OK) {
+            return KEY_ALREADY_EXISTS;
+        }
+        if (_size == theMap.maxSize()) {
+            return MAP_FULL;
+        }
+        theMap[_size].first = key;
+        theMap[_size].second = value;
+        if (storedValue != nullptr) {
+            *storedValue = Iterator(&theMap[_size]);
+        }
+        ++_size;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
+    ReturnValue_t insert(std::pair<key_t, T> pair) {
+        return insert(pair.first, pair.second);
+    }
+
+    ReturnValue_t exists(key_t key) const {
+        ReturnValue_t result = KEY_DOES_NOT_EXIST;
+        if (findIndex(key) < _size) {
+            result = HasReturnvaluesIF::RETURN_OK;
+        }
+        return result;
+    }
+
+    ReturnValue_t erase(Iterator *iter) {
+        uint32_t i;
+        if ((i = findIndex((*iter).value->first)) >= _size) {
+            return KEY_DOES_NOT_EXIST;
+        }
+        theMap[i] = theMap[_size - 1];
+        --_size;
+        --((*iter).value);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
+    ReturnValue_t erase(key_t key) {
+        uint32_t i;
+        if ((i = findIndex(key)) >= _size) {
+            return KEY_DOES_NOT_EXIST;
+        }
+        theMap[i] = theMap[_size - 1];
+        --_size;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
+    T *findValue(key_t key) const {
+        return &theMap[findIndex(key)].second;
+    }
+
+    Iterator find(key_t key) const {
+        ReturnValue_t result = exists(key);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return end();
+        }
+        return Iterator(&theMap[findIndex(key)]);
+    }
+
+    ReturnValue_t find(key_t key, T **value) const {
+        ReturnValue_t result = exists(key);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+        *value = &theMap[findIndex(key)].second;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
+    bool empty() {
+        if(_size == 0) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+
+    bool full() {
+        if(_size >= theMap.maxSize()) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+
+    void clear() {
+        _size = 0;
+    }
+
+    uint32_t maxSize() const {
+        return theMap.maxSize();
+    }
+
+    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+            size_t maxSize, Endianness streamEndianness) const {
+        ReturnValue_t result = SerializeAdapter::serialize(&this->_size,
+                buffer, size, maxSize, streamEndianness);
+        uint32_t i = 0;
+        while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
+            result = SerializeAdapter::serialize(&theMap[i].first, buffer,
+                    size, maxSize, streamEndianness);
+            result = SerializeAdapter::serialize(&theMap[i].second, buffer, size,
+                    maxSize, streamEndianness);
+            ++i;
+        }
+        return result;
+    }
+
+    virtual size_t getSerializedSize() const {
+        uint32_t printSize = sizeof(_size);
+        uint32_t i = 0;
+
+        for (i = 0; i < _size; ++i) {
+            printSize += SerializeAdapter::getSerializedSize(
+                    &theMap[i].first);
+            printSize += SerializeAdapter::getSerializedSize(&theMap[i].second);
+        }
+
+        return printSize;
+    }
+
+    virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+            Endianness streamEndianness) {
+        ReturnValue_t result = SerializeAdapter::deSerialize(&this->_size,
+                buffer, size, streamEndianness);
+        if (this->_size > theMap.maxSize()) {
+            return SerializeIF::TOO_MANY_ELEMENTS;
+        }
+        uint32_t i = 0;
+        while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
+            result = SerializeAdapter::deSerialize(&theMap[i].first, buffer,
+                    size, streamEndianness);
+            result = SerializeAdapter::deSerialize(&theMap[i].second, buffer, size,
+                    streamEndianness);
+            ++i;
+        }
+        return result;
+    }
+
+};
+
+#endif /* FSFW_CONTAINER_FIXEDMAP_H_ */

inc/fsfw/container/FixedOrderedMultimap.h

@@ -0,0 +1,207 @@
+#ifndef FSFW_CONTAINER_FIXEDORDEREDMULTIMAP_H_
+#define FSFW_CONTAINER_FIXEDORDEREDMULTIMAP_H_
+
+#include "ArrayList.h"
+#include <cstring>
+#include <functional>
+
+/**
+ * @brief  An associative container which allows multiple entries of the same key.
+ * @details
+ * Same keys are ordered by KEY_COMPARE function which is std::less<key_t> > by default.
+ *
+ * It uses the ArrayList, so technically this is not a real map, it is an array of pairs
+ * of type key_t, T. It is ordered by key_t as FixedMap but allows same keys. Thus it has a linear
+ * complexity O(n). As long as the number of entries remains low, this
+ * should not be an issue.
+ * The number of insertion and deletion operation should be minimized
+ * as those incur extensive memory move operations (the underlying container
+ * is not node based).
+ *
+ * Its of fixed size so no allocations are performed after the construction.
+ *
+ * The maximum size is given as first parameter of the constructor.
+ *
+ * It provides an iterator to do list iterations.
+ *
+ * The type T must have a copy constructor if it is not trivial copy-able.
+ *
+ * @warning Iterators return a non-const key_t in the pair.
+ * @warning A User is not allowed to change the key, otherwise the map is corrupted.
+ *
+ * \ingroup container
+ */
+template<typename key_t, typename T, typename KEY_COMPARE = std::less<key_t>>
+class FixedOrderedMultimap {
+public:
+    static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MULTIMAP;
+    static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x01);
+    static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x02);
+
+    /***
+     * Constructor which needs a size_t for the maximum allowed size
+     *
+     * Can not be resized during runtime
+     *
+     * Allocates memory at construction
+     * @param maxSize size_t of Maximum allowed size
+     */
+    FixedOrderedMultimap(size_t maxSize):theMap(maxSize), _size(0){
+    }
+
+    /***
+     * Virtual destructor frees Memory by deleting its member
+     */
+    virtual ~FixedOrderedMultimap() {
+    }
+
+    /***
+     * Special iterator for FixedOrderedMultimap
+     */
+    class Iterator: public ArrayList<std::pair<key_t, T>, size_t>::Iterator {
+    public:
+        Iterator() :
+            ArrayList<std::pair<key_t, T>, size_t>::Iterator() {
+        }
+
+        Iterator(std::pair<key_t, T> *pair) :
+            ArrayList<std::pair<key_t, T>, size_t>::Iterator(pair) {
+        }
+    };
+
+    /***
+     * Returns an iterator pointing to the first element
+     * @return Iterator pointing to first element
+     */
+    Iterator begin() const {
+        return Iterator(&theMap[0]);
+    }
+
+    /**
+     * Returns an iterator pointing to one element past the end
+     * @return Iterator pointing to one element past the end
+     */
+    Iterator end() const {
+        return Iterator(&theMap[_size]);
+    }
+
+    /***
+     * Returns the current size of the map (not maximum size!)
+     * @return Current size
+     */
+    size_t size() const{
+        return _size;
+    }
+
+    /**
+     * Clears the map, does not deallocate any memory
+     */
+    void clear(){
+        _size = 0;
+    }
+
+    /**
+     * Returns the maximum size of the map
+     * @return Maximum size of the map
+     */
+    size_t maxSize() const{
+        return theMap.maxSize();
+    }
+
+    /***
+     * Used to insert a key and value separately.
+     *
+     * @param[in] key Key of the new element
+     * @param[in] value Value of the new element
+     * @param[in/out] (optional) storedValue On success this points to the new value, otherwise a nullptr
+     * @return RETURN_OK if insert was successful, MAP_FULL if no space is available
+     */
+    ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr);
+
+    /***
+     * Used to insert new pair instead of single values
+     *
+     * @param pair Pair to be inserted
+     * @return RETURN_OK if insert was successful, MAP_FULL if no space is available
+     */
+    ReturnValue_t insert(std::pair<key_t, T> pair);
+
+    /***
+     * Can be used to check if a certain key is in the map
+     * @param key Key to be checked
+     * @return RETURN_OK if the key exists KEY_DOES_NOT_EXIST otherwise
+     */
+    ReturnValue_t exists(key_t key) const;
+
+    /***
+     * Used to delete the element in the iterator
+     *
+     * The iterator will point to the element before or begin(),
+     *  but never to one element in front of the map.
+     *
+     * @warning The iterator needs to be valid and dereferenceable
+     * @param[in/out] iter Pointer to iterator to the element that needs to be ereased
+     * @return RETURN_OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
+     */
+    ReturnValue_t erase(Iterator *iter);
+
+    /***
+     * Used to erase by key
+     * @param key Key to be erased
+     * @return RETURN_OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
+     */
+    ReturnValue_t erase(key_t key);
+
+    /***
+     * Find returns the first appearance of the key
+     *
+     * If the key does not exist, it points to end()
+     *
+     * @param key Key to search for
+     * @return Iterator pointing to the first entry of key
+     */
+    Iterator find(key_t key) const{
+        ReturnValue_t result = exists(key);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return end();
+        }
+        return Iterator(&theMap[findFirstIndex(key)]);
+    };
+
+    /***
+     * Finds first entry of the given key and returns a
+     * pointer to the value
+     *
+     * @param key Key to search for
+     * @param value Found value
+     * @return RETURN_OK if it points to the value,
+     * KEY_DOES_NOT_EXIST if the key is not in the map
+     */
+    ReturnValue_t find(key_t key, T **value) const;
+
+    friend bool operator==(const typename FixedOrderedMultimap::Iterator& lhs,
+            const typename FixedOrderedMultimap::Iterator& rhs) {
+        return (lhs.value == rhs.value);
+    }
+
+    friend bool operator!=(const typename FixedOrderedMultimap::Iterator& lhs,
+            const typename FixedOrderedMultimap::Iterator& rhs) {
+        return not (lhs.value == rhs.value);
+    }
+
+private:
+    typedef KEY_COMPARE compare;
+    compare myComp;
+    ArrayList<std::pair<key_t, T>, size_t> theMap;
+    size_t _size;
+
+    size_t findFirstIndex(key_t key, size_t startAt = 0) const;
+
+    size_t findNicePlace(key_t key) const;
+
+    void removeFromPosition(size_t position);
+};
+
+#include "FixedOrderedMultimap.tpp"
+
+#endif /* FSFW_CONTAINER_FIXEDORDEREDMULTIMAP_H_ */

inc/fsfw/container/FixedOrderedMultimap.tpp

@@ -0,0 +1,109 @@
+#ifndef FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_
+#define FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_
+
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(key_t key, T value, Iterator *storedValue) {
+    if (_size == theMap.maxSize()) {
+        return MAP_FULL;
+    }
+    size_t position = findNicePlace(key);
+    memmove(static_cast<void*>(&theMap[position + 1]),static_cast<void*>(&theMap[position]),
+            (_size - position) * sizeof(std::pair<key_t,T>));
+    theMap[position].first = key;
+    theMap[position].second = value;
+    ++_size;
+    if (storedValue != nullptr) {
+        *storedValue = Iterator(&theMap[position]);
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(std::pair<key_t, T> pair) {
+    return insert(pair.first, pair.second);
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::exists(key_t key) const {
+    ReturnValue_t result = KEY_DOES_NOT_EXIST;
+    if (findFirstIndex(key) < _size) {
+        result = HasReturnvaluesIF::RETURN_OK;
+    }
+    return result;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(Iterator *iter) {
+    size_t i;
+    if ((i = findFirstIndex((*iter).value->first)) >= _size) {
+        return KEY_DOES_NOT_EXIST;
+    }
+    removeFromPosition(i);
+    if (*iter != begin()) {
+        (*iter)--;
+    } else {
+        *iter = begin();
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(key_t key) {
+    size_t i;
+    if ((i = findFirstIndex(key)) >= _size) {
+        return KEY_DOES_NOT_EXIST;
+    }
+    do {
+        removeFromPosition(i);
+        i = findFirstIndex(key, i);
+    } while (i < _size);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(key_t key, T **value) const {
+    ReturnValue_t result = exists(key);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    *value = &theMap[findFirstIndex(key)].second;
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findFirstIndex(key_t key, size_t startAt) const {
+    if (startAt >= _size) {
+        return startAt + 1;
+    }
+    size_t i = startAt;
+    for (i = startAt; i < _size; ++i) {
+        if (theMap[i].first == key) {
+            return i;
+        }
+    }
+    return i;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findNicePlace(key_t key) const {
+    size_t i = 0;
+    for (i = 0; i < _size; ++i) {
+        if (myComp(key, theMap[i].first)) {
+            return i;
+        }
+    }
+    return i;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline void FixedOrderedMultimap<key_t, T, KEY_COMPARE>::removeFromPosition(size_t position) {
+    if (_size <= position) {
+        return;
+    }
+    memmove(static_cast<void*>(&theMap[position]), static_cast<void*>(&theMap[position + 1]),
+            (_size - position - 1) * sizeof(std::pair<key_t,T>));
+    --_size;
+}
+
+
+#endif /* FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_ */

inc/fsfw/container/HybridIterator.h

@@ -0,0 +1,90 @@
+#ifndef FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
+#define FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
+
+#include "ArrayList.h"
+#include "SinglyLinkedList.h"
+
+template<typename T, typename count_t = uint8_t>
+class HybridIterator: public LinkedElement<T>::Iterator,
+        public ArrayList<T, count_t>::Iterator {
+public:
+    HybridIterator() {}
+
+    HybridIterator(typename LinkedElement<T>::Iterator *iter) :
+        LinkedElement<T>::Iterator(*iter), value(iter->value),
+        linked(true) {
+
+    }
+
+    HybridIterator(LinkedElement<T> *start) :
+        LinkedElement<T>::Iterator(start), value(start->value),
+        linked(true) {
+
+    }
+
+    HybridIterator(typename ArrayList<T, count_t>::Iterator start,
+            typename ArrayList<T, count_t>::Iterator end) :
+            ArrayList<T, count_t>::Iterator(start), value(start.value),
+            linked(false), end(end.value) {
+        if (value == this->end) {
+            value = NULL;
+        }
+    }
+
+    HybridIterator(T *firstElement, T *lastElement) :
+            ArrayList<T, count_t>::Iterator(firstElement), value(firstElement),
+            linked(false), end(++lastElement) {
+        if (value == end) {
+            value = NULL;
+        }
+    }
+
+    HybridIterator& operator++() {
+        if (linked) {
+            LinkedElement<T>::Iterator::operator++();
+            if (LinkedElement<T>::Iterator::value != nullptr) {
+                value = LinkedElement<T>::Iterator::value->value;
+            } else {
+                value = nullptr;
+            }
+        } else {
+            ArrayList<T, count_t>::Iterator::operator++();
+            value = ArrayList<T, count_t>::Iterator::value;
+
+            if (value == end) {
+                value = nullptr;
+            }
+        }
+        return *this;
+    }
+
+    HybridIterator operator++(int) {
+        HybridIterator tmp(*this);
+        operator++();
+        return tmp;
+    }
+
+    bool operator==(const HybridIterator& other) const {
+        return value == other.value;
+    }
+
+    bool operator!=(const HybridIterator& other) const {
+        return !(*this == other);
+    }
+
+    T operator*() {
+        return *value;
+    }
+
+    T *operator->() {
+        return value;
+    }
+
+    T* value = nullptr;
+
+private:
+    bool linked = false;
+    T *end = nullptr;
+};
+
+#endif /* FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_ */

inc/fsfw/container/IndexedRingMemoryArray.h

@@ -0,0 +1,700 @@
+#ifndef FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_
+#define FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_
+
+#include "ArrayList.h"
+#include "../globalfunctions/CRC.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerialArrayListAdapter.h"
+#include <cmath>
+
+template<typename T>
+class Index: public SerializeIF{
+    /**
+     * Index is the Type used for the list of indices. The template parameter is the type which describes the index, it needs to be a child of SerializeIF to be able to make it persistent
+     */
+    static_assert(std::is_base_of<SerializeIF,T>::value,"Wrong Type for Index, Type must implement SerializeIF");
+public:
+    Index():blockStartAddress(0),size(0),storedPackets(0){}
+
+    Index(uint32_t startAddress):blockStartAddress(startAddress),size(0),storedPackets(0){
+
+    }
+
+    void setBlockStartAddress(uint32_t newAddress){
+        this->blockStartAddress = newAddress;
+    }
+
+    uint32_t getBlockStartAddress() const {
+        return blockStartAddress;
+    }
+
+    const T* getIndexType() const {
+        return &indexType;
+    }
+
+    T* modifyIndexType(){
+        return &indexType;
+    }
+    /**
+     * Updates the index Type. Uses = operator
+     * @param indexType Type to copy from
+     */
+    void setIndexType(T* indexType) {
+        this->indexType = *indexType;
+    }
+
+    uint32_t getSize() const {
+        return size;
+    }
+
+    void setSize(uint32_t size) {
+        this->size = size;
+    }
+
+    void addSize(uint32_t size){
+        this->size += size;
+    }
+
+    void setStoredPackets(uint32_t newStoredPackets){
+        this->storedPackets = newStoredPackets;
+    }
+
+    void addStoredPackets(uint32_t packets){
+        this->storedPackets += packets;
+    }
+
+    uint32_t getStoredPackets() const{
+        return this->storedPackets;
+    }
+
+    ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+                size_t maxSize, Endianness streamEndianness) const {
+        ReturnValue_t result = SerializeAdapter::serialize(&blockStartAddress,buffer,size,maxSize,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        result = indexType.serialize(buffer,size,maxSize,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        result = SerializeAdapter::serialize(&this->storedPackets,buffer,size,maxSize,streamEndianness);
+        return result;
+    }
+
+    ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                Endianness streamEndianness){
+        ReturnValue_t result = SerializeAdapter::deSerialize(&blockStartAddress,buffer,size,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        result = indexType.deSerialize(buffer,size,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        result = SerializeAdapter::deSerialize(&this->size,buffer,size,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        result = SerializeAdapter::deSerialize(&this->storedPackets,buffer,size,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        return result;
+    }
+
+    size_t getSerializedSize() const {
+        uint32_t size = SerializeAdapter::getSerializedSize(&blockStartAddress);
+        size += indexType.getSerializedSize();
+        size += SerializeAdapter::getSerializedSize(&this->size);
+        size += SerializeAdapter::getSerializedSize(&this->storedPackets);
+        return size;
+    }
+
+
+    bool operator==(const Index<T>& other){
+        return ((blockStartAddress == other.getBlockStartAddress()) && (size==other.getSize())) && (indexType == *(other.getIndexType()));
+    }
+
+private:
+    uint32_t blockStartAddress;
+    uint32_t size;
+    uint32_t storedPackets;
+    T indexType;
+};
+
+
+
+template<typename T>
+class IndexedRingMemoryArray: public SerializeIF, public ArrayList<Index<T>, uint32_t>{
+    /**
+     * Indexed Ring Memory Array is a class for a ring memory with indices. It assumes that the newest data comes in last
+     * It uses the currentWriteBlock as pointer to the current writing position
+     * The currentReadBlock must be set manually
+     */
+public:
+    IndexedRingMemoryArray(uint32_t startAddress, uint32_t size, uint32_t bytesPerBlock, SerializeIF* additionalInfo,
+            bool overwriteOld) :ArrayList<Index<T>,uint32_t>(NULL,(uint32_t)10,(uint32_t)0),totalSize(size),indexAddress(startAddress),currentReadSize(0),currentReadBlockSizeCached(0),lastBlockToReadSize(0), additionalInfo(additionalInfo),overwriteOld(overwriteOld){
+
+        //Calculate the maximum number of indices needed for this blocksize
+        uint32_t maxNrOfIndices = floor(static_cast<double>(size)/static_cast<double>(bytesPerBlock));
+
+        //Calculate the Size needeed for the index itself
+        uint32_t serializedSize = 0;
+        if(additionalInfo!=NULL){
+            serializedSize += additionalInfo->getSerializedSize();
+        }
+        //Size of current iterator type
+        Index<T> tempIndex;
+        serializedSize += tempIndex.getSerializedSize();
+
+        //Add Size of Array
+        serializedSize += sizeof(uint32_t); //size of array
+        serializedSize += (tempIndex.getSerializedSize() * maxNrOfIndices); //size of elements
+        serializedSize += sizeof(uint16_t); //size of crc
+
+        //Calculate new size after index
+        if(serializedSize > totalSize){
+            error << "IndexedRingMemory: Store is too small for index" << std::endl;
+        }
+        uint32_t useableSize = totalSize - serializedSize;
+        //Update the totalSize for calculations
+        totalSize = useableSize;
+
+        //True StartAddress
+        uint32_t trueStartAddress = indexAddress + serializedSize;
+
+        //Calculate True number of Blocks and reset size of true Number of Blocks
+        uint32_t trueNumberOfBlocks = floor(static_cast<double>(totalSize) / static_cast<double>(bytesPerBlock));
+
+        //allocate memory now
+        this->entries = new Index<T>[trueNumberOfBlocks];
+        this->size = trueNumberOfBlocks;
+        this->maxSize_ = trueNumberOfBlocks;
+        this->allocated = true;
+
+        //Check trueNumberOfBlocks
+        if(trueNumberOfBlocks<1){
+            error << "IndexedRingMemory: Invalid Number of Blocks: " << trueNumberOfBlocks;
+        }
+
+
+
+        //Fill address into index
+        uint32_t address = trueStartAddress;
+        for (typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it) {
+            it->setBlockStartAddress(address);
+            it->setSize(0);
+            it->setStoredPackets(0);
+            address += bytesPerBlock;
+        }
+
+
+        //Initialize iterators
+        currentWriteBlock = this->begin();
+        currentReadBlock = this->begin();
+        lastBlockToRead = this->begin();
+
+        //Check last blockSize
+        uint32_t lastBlockSize = (trueStartAddress + useableSize) -  (this->back()->getBlockStartAddress());
+        if((lastBlockSize<bytesPerBlock) && (this->size > 1)){
+            //remove the last Block so the second last block has more size
+            this->size -= 1;
+            debug << "IndexedRingMemory: Last Block is smaller than bytesPerBlock, removed last block" << std::endl;
+        }
+    }
+
+    /**
+     * Resets the whole index, the iterators and executes the given reset function on every index type
+     * @param typeResetFnc static reset function which accepts a pointer to the index Type
+     */
+    void reset(void (*typeResetFnc)(T*)){
+        currentReadBlock = this->begin();
+        currentWriteBlock = this->begin();
+        lastBlockToRead = this->begin();
+        currentReadSize = 0;
+        currentReadBlockSizeCached = 0;
+        lastBlockToReadSize = 0;
+        for(typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it){
+            it->setSize(0);
+            it->setStoredPackets(0);
+            (*typeResetFnc)(it->modifyIndexType());
+        }
+    }
+
+    void resetBlock(typename IndexedRingMemoryArray<T>::Iterator it,void (*typeResetFnc)(T*)){
+        it->setSize(0);
+        it->setStoredPackets(0);
+        (*typeResetFnc)(it->modifyIndexType());
+    }
+
+    /*
+     * Reading
+     */
+
+    void setCurrentReadBlock(typename IndexedRingMemoryArray<T>::Iterator it){
+        currentReadBlock = it;
+        currentReadBlockSizeCached = it->getSize();
+    }
+
+    void resetRead(){
+        currentReadBlock = this->begin();
+        currentReadSize = 0;
+        currentReadBlockSizeCached = this->begin()->getSize();
+        lastBlockToRead = currentWriteBlock;
+        lastBlockToReadSize = currentWriteBlock->getSize();
+    }
+    /**
+     * Sets the last block to read to this iterator.
+     * Can be used to dump until block x
+     * @param it The iterator for the last read block
+     */
+    void setLastBlockToRead(typename IndexedRingMemoryArray<T>::Iterator it){
+        lastBlockToRead = it;
+        lastBlockToReadSize = it->getSize();
+    }
+
+    /**
+     * Set the read pointer to the first written Block, which is the first non empty block in front of the write block
+     * Can be the currentWriteBlock as well
+     */
+    void readOldest(){
+        resetRead();
+        currentReadBlock = getNextNonEmptyBlock();
+        currentReadBlockSizeCached = currentReadBlock->getSize();
+
+    }
+
+    /**
+     * Sets the current read iterator to the next Block and resets the current read size
+     * The current size of the block will be cached to avoid race condition between write and read
+     * If the end of the ring is reached the read pointer will be set to the begin
+     */
+    void readNext(){
+        currentReadSize = 0;
+        if((this->size != 0) && (currentReadBlock.value ==this->back())){
+            currentReadBlock = this->begin();
+        }else{
+            currentReadBlock++;
+        }
+
+        currentReadBlockSizeCached = currentReadBlock->getSize();
+    }
+
+    /**
+     * Returns the address which is currently read from
+     * @return Address to read from
+     */
+    uint32_t getCurrentReadAddress() const {
+        return getAddressOfCurrentReadBlock() + currentReadSize;
+    }
+    /**
+     * Adds readSize to the current size and checks if the read has no more data left and advances the read block
+     * @param readSize The size that was read
+     * @return Returns true if the read can go on
+     */
+    bool addReadSize(uint32_t readSize) {
+        if(currentReadBlock == lastBlockToRead){
+            //The current read block is the last to read
+            if((currentReadSize+readSize)<lastBlockToReadSize){
+                //the block has more data -> return true
+                currentReadSize += readSize;
+                return true;
+            }else{
+                //Reached end of read -> return false
+                currentReadSize = lastBlockToReadSize;
+                return false;
+            }
+        }else{
+            //We are not in the last Block
+            if((currentReadSize + readSize)<currentReadBlockSizeCached){
+                //The current Block has more data
+                currentReadSize += readSize;
+                return true;
+            }else{
+                //The current block is written completely
+                readNext();
+                if(currentReadBlockSizeCached==0){
+                    //Next block is empty
+                    typename IndexedRingMemoryArray<T>::Iterator it(currentReadBlock);
+                    //Search if any block between this and the last block is not empty
+                    for(;it!=lastBlockToRead;++it){
+                        if(it == this->end()){
+                            //This is the end, next block is the begin
+                            it = this->begin();
+                            if(it == lastBlockToRead){
+                                //Break if the begin is the lastBlockToRead
+                                break;
+                            }
+                        }
+                        if(it->getSize()!=0){
+                            //This is a non empty block. Go on reading with this block
+                            currentReadBlock = it;
+                            currentReadBlockSizeCached = it->getSize();
+                            return true;
+                        }
+                    }
+                    //reached lastBlockToRead and every block was empty, check if the last block is also empty
+                    if(lastBlockToReadSize!=0){
+                        //go on with last Block
+                        currentReadBlock = lastBlockToRead;
+                        currentReadBlockSizeCached = lastBlockToReadSize;
+                        return true;
+                    }
+                    //There is no non empty block left
+                    return false;
+                }
+                //Size is larger than 0
+                return true;
+            }
+        }
+    }
+    uint32_t getRemainigSizeOfCurrentReadBlock() const{
+        if(currentReadBlock == lastBlockToRead){
+            return (lastBlockToReadSize - currentReadSize);
+        }else{
+            return (currentReadBlockSizeCached - currentReadSize);
+        }
+    }
+
+    uint32_t getAddressOfCurrentReadBlock() const {
+        return currentReadBlock->getBlockStartAddress();
+    }
+
+    /**
+     * Gets the next non empty Block after the current write block,
+     * @return Returns the iterator to the block. If there is non, the current write block is returned
+     */
+    typename IndexedRingMemoryArray<T>::Iterator getNextNonEmptyBlock() const {
+        for(typename IndexedRingMemoryArray<T>::Iterator it = getNextWrite();it!=currentWriteBlock;++it){
+                if(it == this->end()){
+                    it = this->begin();
+                    if(it == currentWriteBlock){
+                        break;
+                    }
+                }
+                if(it->getSize()!=0){
+                    return it;
+                }
+        }
+        return currentWriteBlock;
+    }
+
+    /**
+     * Returns a copy of the oldest Index type
+     * @return Type of Index
+     */
+    T* getOldest(){
+        return (getNextNonEmptyBlock()->modifyIndexType());
+    }
+
+
+    /*
+     * Writing
+     */
+    uint32_t getAddressOfCurrentWriteBlock() const{
+        return currentWriteBlock->getBlockStartAddress();
+    }
+
+    uint32_t getSizeOfCurrentWriteBlock() const{
+        return currentWriteBlock->getSize();
+    }
+
+    uint32_t getCurrentWriteAddress() const{
+        return getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock();
+    }
+
+    void clearCurrentWriteBlock(){
+        currentWriteBlock->setSize(0);
+        currentWriteBlock->setStoredPackets(0);
+    }
+
+    void addCurrentWriteBlock(uint32_t size, uint32_t storedPackets){
+        currentWriteBlock->addSize(size);
+        currentWriteBlock->addStoredPackets(storedPackets);
+    }
+
+    T* modifyCurrentWriteBlockIndexType(){
+        return currentWriteBlock->modifyIndexType();
+    }
+    void updatePreviousWriteSize(uint32_t size, uint32_t storedPackets){
+        typename IndexedRingMemoryArray<T>::Iterator it = getPreviousBlock(currentWriteBlock);
+        it->addSize(size);
+        it->addStoredPackets(storedPackets);
+    }
+
+
+    /**
+     * Checks if the block has enough space for sizeToWrite
+     * @param sizeToWrite The data to be written in the Block
+     * @return Returns true if size to write is smaller the remaining size of the block
+     */
+    bool hasCurrentWriteBlockEnoughSpace(uint32_t sizeToWrite){
+        typename IndexedRingMemoryArray<T>::Iterator next = getNextWrite();
+        uint32_t addressOfNextBlock = next->getBlockStartAddress();
+        uint32_t availableSize = ((addressOfNextBlock+totalSize) - (getAddressOfCurrentWriteBlock()+getSizeOfCurrentWriteBlock()))%totalSize;
+        return (sizeToWrite < availableSize);
+    }
+
+    /**
+     * Checks if the store is full if overwrite old is false
+     * @return Returns true if it is writeable and false if not
+     */
+    bool isNextBlockWritable(){
+        //First check if this is the end of the list
+        typename IndexedRingMemoryArray<T>::Iterator next;
+        next = getNextWrite();
+        if((next->getSize()!=0) && (!overwriteOld)){
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Updates current write Block Index Type
+     * @param infoOfNewBlock
+     */
+    void updateCurrentBlock(T* infoOfNewBlock){
+        currentWriteBlock->setIndexType(infoOfNewBlock);
+    }
+
+
+    /**
+     * Succeed to next block, returns FAILED if overwrite is false and the store is full
+     * @return
+     */
+    ReturnValue_t writeNext(){
+        //Check Next Block
+        if(!isNextBlockWritable()){
+            //The Index is full and does not overwrite old
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        //Next block can be written, update Metadata
+        currentWriteBlock = getNextWrite();
+        currentWriteBlock->setSize(0);
+        currentWriteBlock->setStoredPackets(0);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
+    /**
+     * Serializes the Index and calculates the CRC.
+     * Parameters according to HasSerializeIF
+     * @param buffer
+     * @param size
+     * @param maxSize
+     * @param streamEndianness
+     * @return
+     */
+    ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+                size_t maxSize, Endianness streamEndianness) const{
+        uint8_t* crcBuffer = *buffer;
+        uint32_t oldSize = *size;
+        if(additionalInfo!=NULL){
+            additionalInfo->serialize(buffer,size,maxSize,streamEndianness);
+        }
+        ReturnValue_t result = currentWriteBlock->serialize(buffer,size,maxSize,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+                    return result;
+        }
+        result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+                    return result;
+        }
+
+        uint32_t i = 0;
+        while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
+            result = SerializeAdapter::serialize(&this->entries[i], buffer, size,
+                    maxSize, streamEndianness);
+            ++i;
+        }
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        uint16_t crc = Calculate_CRC(crcBuffer,(*size-oldSize));
+        result = SerializeAdapter::serialize(&crc,buffer,size,maxSize,streamEndianness);
+        return result;
+    }
+
+
+    /**
+     * Get the serialized Size of the index
+     * @return The serialized size of the index
+     */
+    size_t getSerializedSize() const {
+
+        uint32_t size = 0;
+        if(additionalInfo!=NULL){
+            size += additionalInfo->getSerializedSize();
+        }
+        size += currentWriteBlock->getSerializedSize();
+        size += SerializeAdapter::getSerializedSize(&this->size);
+        size += (this->entries[0].getSerializedSize()) * this->size;
+        uint16_t crc = 0;
+        size += SerializeAdapter::getSerializedSize(&crc);
+        return size;
+    }
+    /**
+     * DeSerialize the Indexed Ring from a buffer, deSerializes the current write iterator
+     * CRC Has to be checked before!
+     * @param buffer
+     * @param size
+     * @param streamEndianness
+     * @return
+     */
+
+    ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                Endianness streamEndianness){
+
+        ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+        if(additionalInfo!=NULL){
+            result = additionalInfo->deSerialize(buffer,size,streamEndianness);
+        }
+        if(result != HasReturnvaluesIF::RETURN_OK){
+                    return result;
+        }
+
+        Index<T> tempIndex;
+        result = tempIndex.deSerialize(buffer,size,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+                    return result;
+        }
+        uint32_t tempSize = 0;
+        result = SerializeAdapter::deSerialize(&tempSize,buffer,size,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+                    return result;
+        }
+        if(this->size != tempSize){
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        uint32_t i = 0;
+        while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
+            result = SerializeAdapter::deSerialize(
+                    &this->entries[i], buffer, size,
+                    streamEndianness);
+            ++i;
+        }
+        if(result != HasReturnvaluesIF::RETURN_OK){
+                    return result;
+        }
+        typename IndexedRingMemoryArray<T>::Iterator cmp(&tempIndex);
+        for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+            if(*(cmp.value) == *(it.value)){
+                currentWriteBlock = it;
+                return HasReturnvaluesIF::RETURN_OK;
+            }
+        }
+        //Reached if current write block iterator is not found
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
+    uint32_t getIndexAddress() const {
+        return indexAddress;
+    }
+
+
+    /*
+     * Statistics
+     */
+    uint32_t getStoredPackets() const {
+        uint32_t size = 0;
+        for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+            size += it->getStoredPackets();
+        }
+        return size;
+    }
+
+    uint32_t getTotalSize() const {
+        return totalSize;
+    }
+
+    uint32_t getCurrentSize() const{
+        uint32_t size = 0;
+        for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+            size += it->getSize();
+        }
+        return size;
+    }
+
+    bool isEmpty() const{
+        return getCurrentSize()==0;
+    }
+
+    double getPercentageFilled() const{
+        uint32_t filledSize = 0;
+        for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+            filledSize += it->getSize();
+        }
+
+        return (double)filledSize/(double)this->totalSize;
+    }
+
+    typename IndexedRingMemoryArray<T>::Iterator getCurrentWriteBlock() const{
+        return currentWriteBlock;
+    }
+    /**
+     * Get the next block of the currentWriteBlock.
+     * Returns the first one if currentWriteBlock is the last one
+     * @return Iterator pointing to the next block after currentWriteBlock
+     */
+    typename IndexedRingMemoryArray<T>::Iterator getNextWrite() const{
+        typename IndexedRingMemoryArray<T>::Iterator next(currentWriteBlock);
+        if((this->size != 0) && (currentWriteBlock.value == this->back())){
+            next = this->begin();
+        }else{
+            ++next;
+        }
+        return next;
+    }
+    /**
+     * Get the block in front of the Iterator
+     * Returns the last block if it is the first block
+     * @param it iterator which you want the previous block from
+     * @return pointing to the block before it
+     */
+    typename IndexedRingMemoryArray<T>::Iterator getPreviousBlock(typename IndexedRingMemoryArray<T>::Iterator it) {
+        if(this->begin() == it){
+            typename IndexedRingMemoryArray<T>::Iterator next((this->back()));
+            return next;
+        }
+        typename IndexedRingMemoryArray<T>::Iterator next(it);
+        --next;
+        return next;
+    }
+private:
+    //The total size used by the blocks (without index)
+    uint32_t totalSize;
+
+    //The address of the index
+    const uint32_t indexAddress;
+
+    //The iterators for writing and reading
+    typename IndexedRingMemoryArray<T>::Iterator currentWriteBlock;
+    typename IndexedRingMemoryArray<T>::Iterator currentReadBlock;
+
+    //How much of the current read block is read already
+    uint32_t currentReadSize;
+
+    //Cached Size of current read block
+    uint32_t currentReadBlockSizeCached;
+
+    //Last block of current write (should be write block)
+    typename IndexedRingMemoryArray<T>::Iterator lastBlockToRead;
+    //current size of last Block to read
+    uint32_t lastBlockToReadSize;
+
+    //Additional Info to be serialized with the index
+    SerializeIF* additionalInfo;
+
+    //Does it overwrite old blocks?
+    const bool overwriteOld;
+
+};
+
+
+
+
+#endif /* FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_ */

inc/fsfw/container/PlacementFactory.h

@@ -0,0 +1,71 @@
+#ifndef FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_
+#define FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_
+
+#include "../storagemanager/StorageManagerIF.h"
+#include <utility>
+/**
+ * The Placement Factory is used to create objects at runtime in a specific pool.
+ * In general, this should be avoided and it should only be used if you know what you are doing.
+ * You are not allowed to use this container with a type that allocates memory internally like ArrayList.
+ *
+ * Also, you have to check the returned pointer in generate against nullptr!
+ *
+ * A backend of Type StorageManagerIF must be given as a place to store the new objects.
+ * Therefore ThreadSafety is only provided by your StorageManager Implementation.
+ *
+ * Objects must be destroyed by the user with "destroy"! Otherwise the pool will not be cleared.
+ *
+ * The concept is based on the placement new operator.
+ *
+ * @warning Do not use with any Type that allocates memory internally!
+ * @ingroup container
+ */
+class PlacementFactory {
+public:
+    PlacementFactory(StorageManagerIF* backend) :
+            dataBackend(backend) {
+    }
+
+    /***
+     * Generates an object of type T in the backend storage.
+     *
+     * @warning Do not use with any Type that allocates memory internally!
+     *
+     * @tparam T Type of Object
+     * @param args Constructor Arguments to be passed
+     * @return A pointer to the new object or a nullptr in case of failure
+     */
+    template<typename T, typename ... Args>
+    T* generate(Args&&... args) {
+        store_address_t tempId;
+        uint8_t* pData = nullptr;
+        ReturnValue_t result = dataBackend->getFreeElement(&tempId, sizeof(T),
+                &pData);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return nullptr;
+        }
+        T* temp = new (pData) T(std::forward<Args>(args)...);
+        return temp;
+    }
+    /***
+     * Function to destroy the object allocated with generate and free space in backend.
+     * This must be called by the user.
+     *
+     * @param thisElement Element to be destroyed
+     * @return RETURN_OK if the element was destroyed, different errors on failure
+     */
+    template<typename T>
+    ReturnValue_t destroy(T* thisElement) {
+        if (thisElement == nullptr){
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        //Need to call destructor first, in case something was allocated by the object (shouldn't do that, however).
+        thisElement->~T();
+        uint8_t* pointer = (uint8_t*) (thisElement);
+        return dataBackend->deleteData(pointer, sizeof(T));
+    }
+private:
+    StorageManagerIF* dataBackend;
+};
+
+#endif /* FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_ */

inc/fsfw/container/RingBufferBase.h

@@ -0,0 +1,113 @@
+#ifndef FSFW_CONTAINER_RINGBUFFERBASE_H_
+#define FSFW_CONTAINER_RINGBUFFERBASE_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstddef>
+
+template<uint8_t N_READ_PTRS = 1>
+class RingBufferBase {
+public:
+    RingBufferBase(size_t startAddress, const size_t size, bool overwriteOld) :
+            start(startAddress), write(startAddress), size(size),
+            overwriteOld(overwriteOld) {
+        for (uint8_t count = 0; count < N_READ_PTRS; count++) {
+            read[count] = startAddress;
+        }
+    }
+
+    virtual ~RingBufferBase() {}
+
+    bool isFull(uint8_t n = 0) {
+        return (availableWriteSpace(n) == 0);
+    }
+    bool isEmpty(uint8_t n = 0) {
+        return (getAvailableReadData(n) == 0);
+    }
+
+    size_t getAvailableReadData(uint8_t n = 0) const {
+        return ((write + size) - read[n]) % size;
+    }
+    size_t availableWriteSpace(uint8_t n = 0) const  {
+        //One less to avoid ambiguous full/empty problem.
+        return (((read[n] + size) - write - 1) % size);
+    }
+
+    bool overwritesOld() const {
+        return overwriteOld;
+    }
+
+    size_t getMaxSize() const {
+        return size - 1;
+    }
+
+    void clear() {
+        write = start;
+        for (uint8_t count = 0; count < N_READ_PTRS; count++) {
+            read[count] = start;
+        }
+    }
+
+    size_t writeTillWrap() {
+        return (start + size) - write;
+    }
+
+    size_t readTillWrap(uint8_t n = 0) {
+        return (start + size) - read[n];
+    }
+
+    size_t getStart() const {
+        return start;
+    }
+
+protected:
+    const size_t start;
+    size_t write;
+    size_t read[N_READ_PTRS];
+    const size_t size;
+    const bool overwriteOld;
+
+    void incrementWrite(uint32_t amount) {
+        write = ((write + amount - start) % size) + start;
+    }
+    void incrementRead(uint32_t amount, uint8_t n = 0) {
+        read[n] = ((read[n] + amount - start) % size) + start;
+    }
+
+    ReturnValue_t readData(uint32_t amount, uint8_t n = 0) {
+        if (getAvailableReadData(n) >= amount) {
+            incrementRead(amount, n);
+            return HasReturnvaluesIF::RETURN_OK;
+        } else {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
+
+    ReturnValue_t writeData(uint32_t amount) {
+        if (availableWriteSpace() >= amount or overwriteOld) {
+            incrementWrite(amount);
+            return HasReturnvaluesIF::RETURN_OK;
+        } else {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
+
+    size_t getRead(uint8_t n = 0) const {
+        return read[n];
+    }
+
+    void setRead(uint32_t read, uint8_t n = 0) {
+        if (read >= start && read < (start+size)) {
+            this->read[n] = read;
+        }
+    }
+
+    uint32_t getWrite() const {
+        return write;
+    }
+
+    void setWrite(uint32_t write) {
+        this->write = write;
+    }
+};
+
+#endif /* FSFW_CONTAINER_RINGBUFFERBASE_H_ */

inc/fsfw/container/SharedRingBuffer.h

@@ -0,0 +1,96 @@
+#ifndef FSFW_CONTAINER_SHAREDRINGBUFFER_H_
+#define FSFW_CONTAINER_SHAREDRINGBUFFER_H_
+
+#include "SimpleRingBuffer.h"
+#include "DynamicFIFO.h"
+
+#include "fsfw/ipc/MutexIF.h"
+#include "fsfw/objectmanager/SystemObject.h"
+#include "fsfw/timemanager/Clock.h"
+
+/**
+ * @brief   Ring buffer which can be shared among multiple objects
+ * @details
+ * This class offers a mutex to perform thread-safe operation on the ring
+ * buffer. It is still up to the developer to actually perform the lock
+ * and unlock operations.
+ */
+class SharedRingBuffer: public SystemObject,
+        public SimpleRingBuffer {
+public:
+    /**
+     * This constructor allocates a new internal buffer with the supplied size.
+     * @param size
+     * @param overwriteOld
+     * If the ring buffer is overflowing at a write operartion, the oldest data
+     * will be overwritten.
+     */
+    SharedRingBuffer(object_id_t objectId, const size_t size,
+            bool overwriteOld, size_t maxExcessBytes);
+    /**
+     * This constructor takes an external buffer with the specified size.
+     * @param buffer
+     * @param size
+     * @param overwriteOld
+     * If the ring buffer is overflowing at a write operartion, the oldest data
+     * will be overwritten.
+     */
+    SharedRingBuffer(object_id_t objectId, uint8_t* buffer, const size_t size,
+            bool overwriteOld, size_t maxExcessBytes);
+
+    virtual~ SharedRingBuffer();
+
+    /**
+     * @brief    This function can be used to add an optional FIFO to the class
+     * @details 
+     * This FIFO will be allocated in the initialize function (and will
+     * have a fixed maximum size after that). It can be used to store
+     * values like packet sizes, for example for a shared ring buffer
+     * used by producer/consumer tasks.
+     */
+    void setToUseReceiveSizeFIFO(size_t fifoDepth);
+
+
+
+    /**
+     * Unless a read-only constant value is read, all operations on the
+     * shared ring buffer should be protected by calling this function.
+     * @param timeoutType
+     * @param timeout
+     * @return
+     */
+    virtual ReturnValue_t lockRingBufferMutex(MutexIF::TimeoutType timeoutType,
+            dur_millis_t timeout);
+    /**
+     * Any locked mutex also has to be unlocked, otherwise, access to the
+     * shared ring buffer will be blocked.
+     * @return
+     */
+    virtual ReturnValue_t unlockRingBufferMutex();
+
+    /**
+     * The mutex handle can be accessed directly, for example to perform
+     * the lock with the #MutexGuard for a RAII compliant lock operation.
+     * @return
+     */
+    MutexIF* getMutexHandle() const;
+
+    ReturnValue_t initialize() override;
+
+    /**
+     * If the shared ring buffer was configured to have a sizes FIFO, a handle
+     * to that FIFO can be retrieved with this function.
+     * Do not forget to protect access with a lock if required!
+     * @return
+     */
+    DynamicFIFO<size_t>* getReceiveSizesFIFO();
+private:
+    MutexIF* mutex = nullptr;
+
+    size_t fifoDepth = 0;
+    DynamicFIFO<size_t>* receiveSizesFIFO = nullptr;
+};
+
+
+
+#endif /* FSFW_CONTAINER_SHAREDRINGBUFFER_H_ */

inc/fsfw/container/SimpleRingBuffer.h

@@ -0,0 +1,129 @@
+#ifndef FSFW_CONTAINER_SIMPLERINGBUFFER_H_
+#define FSFW_CONTAINER_SIMPLERINGBUFFER_H_
+
+#include "RingBufferBase.h"
+#include <cstddef>
+
+/**
+ * @brief     Circular buffer implementation, useful for buffering
+ *          into data streams.
+ * @details
+ * Note that the deleteData() has to be called to increment the read pointer.
+ * This class allocated dynamically, so
+ * @ingroup containers
+ */
+class SimpleRingBuffer: public RingBufferBase<> {
+public:
+    /**
+     * This constructor allocates a new internal buffer with the supplied size.
+     *
+     * @param size
+     * @param overwriteOld If the ring buffer is overflowing at a write
+     * operation, the oldest data will be overwritten.
+     * @param maxExcessBytes These additional bytes will be allocated in addtion
+     * to the specified size to accomodate contiguous write operations
+     * with getFreeElement.
+     *
+     */
+    SimpleRingBuffer(const size_t size, bool overwriteOld,
+            size_t maxExcessBytes = 0);
+    /**
+     * This constructor takes an external buffer with the specified size.
+     * @param buffer
+     * @param size
+     * @param overwriteOld
+     * If the ring buffer is overflowing at a write operartion, the oldest data
+     * will be overwritten.
+     * @param maxExcessBytes
+     * If the buffer can accomodate additional bytes for contigous write
+     * operations with getFreeElement, this is the maximum allowed additional
+     * size
+     */
+    SimpleRingBuffer(uint8_t* buffer, const size_t size, bool overwriteOld,
+            size_t maxExcessBytes = 0);
+
+    virtual ~SimpleRingBuffer();
+
+    /**
+     * Write to circular buffer and increment write pointer by amount.
+     * @param data
+     * @param amount
+     * @return -@c RETURN_OK if write operation was successfull
+     * -@c RETURN_FAILED if
+     */
+    ReturnValue_t writeData(const uint8_t* data, size_t amount);
+
+    /**
+     * Returns a pointer to a free element. If the remaining buffer is
+     * not large enough, the data will be written past the actual size
+     * and the amount of excess bytes will be cached. This function
+     * does not increment the write pointer!
+     * @param writePointer Pointer to a pointer which can be used to write
+     * contiguous blocks into the ring buffer
+     * @param amount
+     * @return
+     */
+    ReturnValue_t getFreeElement(uint8_t** writePointer, size_t amount);
+
+    /**
+     * This increments the write pointer and also copies the excess bytes
+     * to the beginning. It should be called if the write operation
+     * conducted after calling getFreeElement() was performed.
+     * @return
+     */
+    void confirmBytesWritten(size_t amount);
+
+    virtual size_t getExcessBytes() const;
+    /**
+     * Helper functions which moves any excess bytes to the start
+     * of the ring buffer.
+     * @return
+     */
+    virtual void moveExcessBytesToStart();
+
+    /**
+     * Read from circular buffer at read pointer.
+     * @param data
+     * @param amount
+     * @param incrementReadPtr
+     * If this is set to true, the read pointer will be incremented.
+     * If readRemaining is set to true, the read pointer will be incremented
+     * accordingly.
+     * @param readRemaining
+     * If this is set to true, the data will be read even if the amount
+     * specified exceeds the read data available.
+     * @param trueAmount [out]
+     * If readRemaining was set to true, the true amount read will be assigned
+     * to the passed value.
+     * @return
+     * - @c RETURN_OK if data was read successfully
+     * - @c RETURN_FAILED if not enough data was available and readRemaining
+     *      was set to false.
+     */
+    ReturnValue_t readData(uint8_t* data, size_t amount,
+            bool incrementReadPtr = false, bool readRemaining = false,
+            size_t* trueAmount = nullptr);
+
+    /**
+     * Delete data by incrementing read pointer.
+     * @param amount
+     * @param deleteRemaining
+     * If the amount specified is larger than the remaing size to read and this
+     * is set to true, the remaining amount will be deleted as well
+     * @param trueAmount [out]
+     * If deleteRemaining was set to true, the amount deleted will be assigned
+     * to the passed value.
+     * @return
+     */
+    ReturnValue_t deleteData(size_t amount, bool deleteRemaining = false,
+            size_t* trueAmount = nullptr);
+
+private:
+    static const uint8_t READ_PTR = 0;
+    uint8_t* buffer = nullptr;
+    size_t maxExcessBytes;
+    size_t excessBytes = 0;
+};
+
+#endif /* FSFW_CONTAINER_SIMPLERINGBUFFER_H_ */
+

inc/fsfw/container/SinglyLinkedList.h

@@ -0,0 +1,154 @@
+#ifndef FRAMEWORK_CONTAINER_SINGLYLINKEDLIST_H_
+#define FRAMEWORK_CONTAINER_SINGLYLINKEDLIST_H_
+
+#include <cstddef>
+#include <cstdint>
+
+/**
+ * @brief    Linked list data structure,
+ *             each entry has a pointer to the next entry (singly)
+ * @ingroup container
+ */
+template<typename T>
+class LinkedElement {
+public:
+    T *value;
+    class Iterator {
+    public:
+        LinkedElement<T> *value = nullptr;
+        Iterator() {}
+
+        Iterator(LinkedElement<T> *element) :
+                value(element) {
+        }
+
+        Iterator& operator++() {
+            value = value->getNext();
+            return *this;
+        }
+
+        Iterator operator++(int) {
+            Iterator tmp(*this);
+            operator++();
+            return tmp;
+        }
+
+        bool operator==(Iterator other) {
+            return value == other.value;
+        }
+
+        bool operator!=(Iterator other) {
+            return !(*this == other);
+        }
+        T *operator->() {
+            return value->value;
+        }
+    };
+
+    LinkedElement(T* setElement, LinkedElement<T>* setNext = nullptr):
+           value(setElement), next(setNext) {}
+
+    virtual ~LinkedElement(){}
+
+    virtual LinkedElement* getNext() const {
+        return next;
+    }
+
+    virtual void setNext(LinkedElement* next) {
+        this->next = next;
+    }
+
+    virtual void setEnd() {
+        this->next = nullptr;
+    }
+
+    LinkedElement* begin() {
+        return this;
+    }
+    LinkedElement* end() {
+        return nullptr;
+    }
+private:
+    LinkedElement *next;
+};
+
+template<typename T>
+class SinglyLinkedList {
+public:
+    using ElementIterator = typename LinkedElement<T>::Iterator;
+
+    SinglyLinkedList() {}
+
+    SinglyLinkedList(ElementIterator start) :
+            start(start.value) {}
+
+    SinglyLinkedList(LinkedElement<T>* startElement) :
+            start(startElement) {}
+
+    ElementIterator begin() const {
+        return ElementIterator::Iterator(start);
+    }
+
+    /** Returns iterator to nulltr */
+    ElementIterator end() const {
+        return ElementIterator::Iterator();
+    }
+
+    /**
+     * Returns last element in singly linked list.
+     * @return
+     */
+    ElementIterator back() const {
+        LinkedElement<T> *element = start;
+        while (element->getNext() != nullptr) {
+            element = element->getNext();
+        }
+        return ElementIterator::Iterator(element);
+    }
+
+    size_t getSize() const {
+        size_t size = 0;
+        LinkedElement<T> *element = start;
+        while (element != nullptr) {
+            size++;
+            element = element->getNext();
+        }
+        return size;
+    }
+    void setStart(LinkedElement<T>* firstElement) {
+        start = firstElement;
+    }
+
+    void setNext(LinkedElement<T>* currentElement,
+            LinkedElement<T>* nextElement) {
+        currentElement->setNext(nextElement);
+    }
+
+    void setLast(LinkedElement<T>* lastElement) {
+        lastElement->setEnd();
+    }
+
+    void insertElement(LinkedElement<T>* element, size_t position) {
+        LinkedElement<T> *currentElement = start;
+        for(size_t count = 0; count < position; count++) {
+            if(currentElement == nullptr) {
+                return;
+            }
+            currentElement = currentElement->getNext();
+        }
+        LinkedElement<T>* elementAfterCurrent = currentElement->next;
+        currentElement->setNext(element);
+        if(elementAfterCurrent != nullptr) {
+            element->setNext(elementAfterCurrent);
+        }
+    }
+
+    void insertBack(LinkedElement<T>* lastElement) {
+        back().value->setNext(lastElement);
+    }
+
+protected:
+    LinkedElement<T> *start = nullptr;
+};
+
+#endif /* SINGLYLINKEDLIST_H_ */

inc/fsfw/container/group.h

@@ -0,0 +1,15 @@
+#ifndef GROUP_H_
+#define GROUP_H_
+
+/**
+ * @defgroup container Container
+ *
+ * General Purpose Container to store various elements.
+ *
+ * Also contains Adapter classes to print elements to a
+ * bytestream and to read them from a bytestream, as well
+ * as an Adapter to swap the endianness.
+ */
+
+
+#endif /* GROUP_H_ */

inc/fsfw/controller/ControllerBase.h

@@ -0,0 +1,94 @@
+#ifndef FSFW_CONTROLLER_CONTROLLERBASE_H_
+#define FSFW_CONTROLLER_CONTROLLERBASE_H_
+
+#include "fsfw/health/HasHealthIF.h"
+#include "fsfw/health/HealthHelper.h"
+#include "fsfw/modes/HasModesIF.h"
+#include "fsfw/modes/ModeHelper.h"
+#include "fsfw/objectmanager/SystemObject.h"
+#include "fsfw/tasks/ExecutableObjectIF.h"
+#include "fsfw/tasks/PeriodicTaskIF.h"
+#include "fsfw/datapool/HkSwitchHelper.h"
+
+/**
+ * @brief   Generic base class for controller classes
+ * @details
+ * Implements common interfaces for controllers, which generally have
+ * a mode and a health state. This avoids boilerplate code.
+ */
+class ControllerBase: public HasModesIF,
+        public HasHealthIF,
+        public ExecutableObjectIF,
+        public SystemObject,
+        public HasReturnvaluesIF {
+public:
+    static const Mode_t MODE_NORMAL = 2;
+
+    ControllerBase(object_id_t setObjectId, object_id_t parentId,
+            size_t commandQueueDepth = 3);
+    virtual ~ControllerBase();
+
+    /** SystemObject override */
+    virtual ReturnValue_t initialize() override;
+
+    virtual MessageQueueId_t getCommandQueue() const override;
+
+    /** HasHealthIF overrides */
+    virtual ReturnValue_t setHealth(HealthState health) override;
+    virtual 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;
+
+protected:
+
+    /**
+     * Implemented by child class. Handle command messages which are not
+     * mode or health messages.
+     * @param message
+     * @return
+     */
+    virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
+
+    /**
+     * Periodic helper, implemented by child class.
+     */
+    virtual void performControlOperation() = 0;
+
+    virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+            uint32_t *msToReachTheMode) = 0;
+
+    const object_id_t parentId;
+
+    Mode_t mode;
+
+    Submode_t submode;
+
+    MessageQueueIF* commandQueue = nullptr;
+
+    ModeHelper modeHelper;
+
+    HealthHelper healthHelper;
+
+    /**
+     * Pointer to the task which executes this component,
+     * is invalid before setTaskIF was called.
+     */
+    PeriodicTaskIF* executingTask = nullptr;
+
+    /** Handle mode and health messages */
+    virtual void handleQueue();
+
+    /** Mode helpers */
+    virtual void modeChanged(Mode_t mode, Submode_t submode);
+    virtual void startTransition(Mode_t mode, Submode_t submode);
+    virtual void getMode(Mode_t *mode, Submode_t *submode);
+    virtual void setToExternalControl();
+    virtual void announceMode(bool recursive);
+    /** HK helpers */
+    virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
+};
+
+#endif /* FSFW_CONTROLLER_CONTROLLERBASE_H_ */

inc/fsfw/controller/ExtendedControllerBase.h

@@ -0,0 +1,76 @@
+#ifndef FSFW_CONTROLLER_EXTENDEDCONTROLLERBASE_H_
+#define FSFW_CONTROLLER_EXTENDEDCONTROLLERBASE_H_
+
+#include "ControllerBase.h"
+
+#include "fsfw/action.h"
+#include "fsfw/datapoollocal/HasLocalDataPoolIF.h"
+#include "fsfw/datapoollocal/LocalDataPoolManager.h"
+
+/**
+ * @brief   Extendes the basic ControllerBase with the common components
+ *          HasActionsIF for commandability and HasLocalDataPoolIF to keep
+ *          a pool of local data pool variables.
+ * @details
+ * Default implementations required for the interfaces will be empty and have
+ * to be implemented by child class.
+ */
+class ExtendedControllerBase: public ControllerBase,
+        public HasActionsIF,
+        public HasLocalDataPoolIF {
+public:
+    ExtendedControllerBase(object_id_t objectId, object_id_t parentId,
+            size_t commandQueueDepth = 3);
+    virtual ~ExtendedControllerBase();
+
+    /* SystemObjectIF overrides */
+    virtual ReturnValue_t initialize() override;
+
+    virtual MessageQueueId_t getCommandQueue() const override;
+
+    /* ExecutableObjectIF overrides */
+    virtual ReturnValue_t performOperation(uint8_t opCode) override;
+    virtual ReturnValue_t initializeAfterTaskCreation() override;
+
+protected:
+    LocalDataPoolManager poolManager;
+    ActionHelper actionHelper;
+
+    /**
+     * Implemented by child class. Handle all command messages which are
+     * not health, mode, action or housekeeping messages.
+     * @param message
+     * @return
+     */
+    virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
+
+    /**
+     * Periodic helper from ControllerBase, implemented by child class.
+     */
+    virtual void performControlOperation() = 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;
+
+    /* HasLocalDatapoolIF overrides */
+    virtual LocalDataPoolManager* getHkManagerHandle() override;
+    virtual object_id_t getObjectId() const override;
+    virtual uint32_t getPeriodicOperationFrequency() const override;
+
+    virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+            LocalDataPoolManager& poolManager) override = 0;
+    virtual 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;
+};
+
+
+
+#endif /* FSFW_CONTROLLER_EXTENDEDCONTROLLERBASE_H_ */

inc/fsfw/coordinates/CoordinateTransformations.h

@@ -0,0 +1,34 @@
+#ifndef COORDINATETRANSFORMATIONS_H_
+#define COORDINATETRANSFORMATIONS_H_
+
+#include "fsfw/timemanager/Clock.h"
+#include <cstring>
+
+class CoordinateTransformations {
+public:
+	static void positionEcfToEci(const double* ecfCoordinates, double* eciCoordinates, timeval *timeUTC = NULL);
+
+	static void velocityEcfToEci(const double* ecfVelocity,
+			const double* ecfPosition,
+			double* eciVelocity, timeval *timeUTC = NULL);
+
+	static void positionEciToEcf(const double* eciCoordinates, double* ecfCoordinates,timeval *timeUTC = NULL);
+	static void velocityEciToEcf(const double* eciVelocity,const double* eciPosition, double* ecfVelocity,timeval* timeUTC = NULL);
+
+	static double getEarthRotationAngle(timeval timeUTC);
+
+	static void getEarthRotationMatrix(timeval timeUTC, double matrix[][3]);
+private:
+	CoordinateTransformations();
+	static void ecfToEci(const double* ecfCoordinates, double* eciCoordinates,
+			const double* ecfPositionIfCoordinatesAreVelocity, timeval *timeUTCin);
+	static void eciToEcf(const double* eciCoordinates,
+				double* ecfCoordinates,
+				const double* eciPositionIfCoordinatesAreVelocity,timeval *timeUTCin);
+
+	static double getJuleanCenturiesTT(timeval timeUTC);
+	static void getTransMatrixECITOECF(timeval time,double Tfi[3][3]);
+
+};
+
+#endif /* COORDINATETRANSFORMATIONS_H_ */

inc/fsfw/coordinates/Jgm3Model.h

@@ -0,0 +1,180 @@
+#ifndef FRAMEWORK_COORDINATES_JGM3MODEL_H_
+#define FRAMEWORK_COORDINATES_JGM3MODEL_H_
+
+#include <stdint.h>
+#include "CoordinateTransformations.h"
+#include "../globalfunctions/math/VectorOperations.h"
+#include "../globalfunctions/timevalOperations.h"
+#include "../globalfunctions/constants.h"
+#include <memory.h>
+
+
+template<uint8_t DEGREE,uint8_t ORDER>
+class Jgm3Model {
+public:
+	static const uint32_t factorialLookupTable[DEGREE+3]; //This table is used instead of factorial calculation, must be increased if order or degree is higher
+
+	Jgm3Model() {
+		y0[0] = 0;
+		y0[1] = 0;
+		y0[2] = 0;
+		y0[3] = 0;
+		y0[4] = 0;
+		y0[5] = 0;
+
+		lastExecutionTime.tv_sec = 0;
+		lastExecutionTime.tv_usec = 0;
+	}
+	virtual ~Jgm3Model(){};
+
+	//double acsNavOrbit(double posECF[3],double velECF[3],timeval gpsTime);
+
+	double y0[6]; //position and velocity at beginning of RK step in EC
+	timeval lastExecutionTime; //Time of last execution
+
+
+	void accelDegOrd(const double pos[3],const double S[ORDER+1][DEGREE+1],const double C[ORDER+1][DEGREE+1],double* accel){
+		//Get radius of this position
+		double r = VectorOperations<double>::norm(pos,3);
+
+
+
+		//Initialize the V and W matrix
+		double V[DEGREE+2][ORDER+2] = {{0}};
+		double W[DEGREE+2][ORDER+2] = {{0}};
+
+		for(uint8_t m=0;m<(ORDER+2);m++){
+			for(uint8_t n=m;n<(DEGREE+2);n++){
+				if((n==0) && (m==0)){
+					//Montenbruck "Satellite Orbits Eq.3.31"
+					V[0][0] = Earth::MEAN_RADIUS / r;
+					W[0][0] = 0;
+				}else{
+					if(n==m){
+						//Montenbruck "Satellite Orbits Eq.3.29"
+						V[m][m] = (2*m-1)* (pos[0]*Earth::MEAN_RADIUS/pow(r,2)*V[m-1][m-1] - pos[1]*Earth::MEAN_RADIUS/pow(r,2)*W[m-1][m-1]);
+						W[m][m] = (2*m-1)* (pos[0]*Earth::MEAN_RADIUS/pow(r,2)*W[m-1][m-1] + pos[1]*Earth::MEAN_RADIUS/pow(r,2)*V[m-1][m-1]);
+					}else{
+						//Montenbruck "Satellite Orbits Eq.3.30"
+						V[n][m] = ((2*n-1)/(double)(n-m))*pos[2]*Earth::MEAN_RADIUS / pow(r,2)*V[n-1][m];
+						W[n][m] = ((2*n-1)/(double)(n-m))*pos[2]*Earth::MEAN_RADIUS / pow(r,2)*W[n-1][m];
+						if(n!=(m+1)){
+							V[n][m] = V[n][m] - (((n+m-1)/(double)(n-m)) * (pow(Earth::MEAN_RADIUS,2) / pow(r,2)) * V[n-2][m]);
+							W[n][m] = W[n][m] - (((n+m-1)/(double)(n-m)) * (pow(Earth::MEAN_RADIUS,2) / pow(r,2)) * W[n-2][m]);
+						}//End of if(n!=(m+1))
+					}//End of if(n==m){
+				}//End of if(n==0 and m==0)
+			}//End of for(uint8_t n=0;n<(DEGREE+1);n++)
+		}//End of for(uint8_t m=0;m<(ORDER+1);m++)
+
+
+		//overwrite accel if not properly initialized
+		accel[0] = 0;
+		accel[1] = 0;
+		accel[2] = 0;
+
+		for(uint8_t m=0;m<(ORDER+1);m++){
+			for(uint8_t n=m;n<(DEGREE+1);n++){
+				//Use table lookup to get factorial
+				double partAccel[3] = {0};
+				double factor = Earth::STANDARD_GRAVITATIONAL_PARAMETER/pow(Earth::MEAN_RADIUS,2);
+				if(m==0){
+					//Montenbruck "Satellite Orbits Eq.3.33"
+					partAccel[0] = factor * (-C[n][0]*V[n+1][1]);
+					partAccel[1] = factor * (-C[n][0]*W[n+1][1]);
+				}else{
+					double factMN = static_cast<double>(factorialLookupTable[n-m+2]) / static_cast<double>(factorialLookupTable[n-m]);
+					partAccel[0] = factor * 0.5 * ((-C[n][m]*V[n+1][m+1]-S[n][m]*W[n+1][m+1])+factMN*(C[n][m]*V[n+1][m-1]+S[n][m]*W[n+1][m-1]));
+					partAccel[1] = factor * 0.5 * ((-C[n][m]*W[n+1][m+1]+S[n][m]*V[n+1][m+1])+factMN*(-C[n][m]*W[n+1][m-1]+S[n][m]*V[n+1][m-1]));
+				}
+
+				partAccel[2] = factor * ((n-m+1)*(-C[n][m]*V[n+1][m]-S[n][m]*W[n+1][m]));
+
+
+				accel[0] += partAccel[0];
+				accel[1] += partAccel[1];
+				accel[2] += partAccel[2];
+			}//End of for(uint8_t n=0;n<DEGREE;n++)
+		}//End of uint8_t m=0;m<ORDER;m++
+	}
+
+	void initializeNavOrbit(const double position[3],const double velocity[3], timeval timeUTC){
+		CoordinateTransformations::positionEcfToEci(position,&y0[0],&timeUTC);
+		CoordinateTransformations::velocityEcfToEci(velocity,position,&y0[3],&timeUTC);
+		lastExecutionTime = timeUTC;
+	}
+
+
+	void acsNavOrbit(timeval timeUTC, const double S[ORDER+1][DEGREE+1],const double C[ORDER+1][DEGREE+1], double outputPos[3],double outputVel[3]){
+
+		//RK4 Integration for this timestamp
+		double deltaT = timevalOperations::toDouble(timeUTC-lastExecutionTime);
+
+		double y0dot[6] = {0,0,0,0,0,0};
+		double yA[6] = {0,0,0,0,0,0};
+		double yAdot[6] = {0,0,0,0,0,0};
+		double yB[6] = {0,0,0,0,0,0};
+		double yBdot[6] = {0,0,0,0,0,0};
+		double yC[6] = {0,0,0,0,0,0};
+		double yCdot[6] = {0,0,0,0,0,0};
+
+		//Step One
+		rungeKuttaStep(y0,y0dot,lastExecutionTime,S,C);
+
+		//Step Two
+		VectorOperations<double>::mulScalar(y0dot,deltaT/2,yA,6);
+		VectorOperations<double>::add(y0,yA,yA,6);
+		rungeKuttaStep(yA,yAdot,lastExecutionTime,S,C);
+
+		//Step Three
+		VectorOperations<double>::mulScalar(yAdot,deltaT/2,yB,6);
+		VectorOperations<double>::add(y0,yB,yB,6);
+		rungeKuttaStep(yB,yBdot,lastExecutionTime,S,C);
+
+		//Step Four
+		VectorOperations<double>::mulScalar(yBdot,deltaT,yC,6);
+		VectorOperations<double>::add(y0,yC,yC,6);
+		rungeKuttaStep(yC,yCdot,lastExecutionTime,S,C);
+
+		//Calc new State
+		VectorOperations<double>::mulScalar(yAdot,2,yAdot,6);
+		VectorOperations<double>::mulScalar(yBdot,2,yBdot,6);
+		VectorOperations<double>::add(y0dot,yAdot,y0dot,6);
+		VectorOperations<double>::add(y0dot,yBdot,y0dot,6);
+		VectorOperations<double>::add(y0dot,yCdot,y0dot,6);
+		VectorOperations<double>::mulScalar(y0dot,1./6.*deltaT,y0dot,6);
+		VectorOperations<double>::add(y0,y0dot,y0,6);
+
+		CoordinateTransformations::positionEciToEcf(&y0[0],outputPos,&timeUTC);
+		CoordinateTransformations::velocityEciToEcf(&y0[3],&y0[0],outputVel,&timeUTC);
+
+		lastExecutionTime = timeUTC;
+
+
+	}
+
+
+	void rungeKuttaStep(const double* yIn,double* yOut,timeval time, const double S[ORDER+1][DEGREE+1],const double C[ORDER+1][DEGREE+1]){
+		double rECF[3] = {0,0,0};
+		double rDotECF[3] = {0,0,0};
+		double accelECF[3] = {0,0,0};
+		double accelECI[3] = {0,0,0};
+
+
+		CoordinateTransformations::positionEciToEcf(&yIn[0],rECF,&time);
+		CoordinateTransformations::velocityEciToEcf(&yIn[3],&yIn[0],rDotECF,&time);
+		accelDegOrd(rECF,S,C,accelECF);
+		//This is not correct, as the acceleration would have derived terms but we don't know the velocity and position at that time
+		//Tests showed that a wrong velocity does make the equation worse than neglecting it
+		CoordinateTransformations::positionEcfToEci(accelECF,accelECI,&time);
+		memcpy(&yOut[0],&yIn[3],sizeof(yOut[0])*3);
+		memcpy(&yOut[3],accelECI,sizeof(yOut[0])*3);
+	}
+};
+
+
+
+
+
+
+#endif /* FRAMEWORK_COORDINATES_JGM3MODEL_H_ */

inc/fsfw/coordinates/Sgp4Propagator.h

@@ -0,0 +1,47 @@
+#ifndef SGP4PROPAGATOR_H_
+#define SGP4PROPAGATOR_H_
+
+#include "fsfw/platform.h"
+#ifndef PLATFORM_WIN
+#include <sys/time.h>
+#endif
+#include "fsfw/contrib/sgp4/sgp4unit.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+
+class Sgp4Propagator {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SGP4PROPAGATOR_CLASS;
+	static const ReturnValue_t INVALID_ECCENTRICITY = MAKE_RETURN_CODE(0xA1);
+	static const ReturnValue_t INVALID_MEAN_MOTION = MAKE_RETURN_CODE(0xA2);
+	static const ReturnValue_t INVALID_PERTURBATION_ELEMENTS = MAKE_RETURN_CODE(0xA3);
+	static const ReturnValue_t INVALID_SEMI_LATUS_RECTUM = MAKE_RETURN_CODE(0xA4);
+	static const ReturnValue_t INVALID_EPOCH_ELEMENTS = MAKE_RETURN_CODE(0xA5);
+	static const ReturnValue_t SATELLITE_HAS_DECAYED = MAKE_RETURN_CODE(0xA6);
+	static const ReturnValue_t TLE_TOO_OLD = MAKE_RETURN_CODE(0xB1);
+	static const ReturnValue_t TLE_NOT_INITIALIZED = MAKE_RETURN_CODE(0xB2);
+
+
+
+	Sgp4Propagator();
+	virtual ~Sgp4Propagator();
+
+	ReturnValue_t initialize(const uint8_t *line1, const uint8_t *line2);
+
+	/**
+	 *
+	 * @param[out] position in ECF
+	 * @param[out] velocity in ECF
+	 * @param time to which to propagate
+	 * @return
+	 */
+	ReturnValue_t propagate(double *position, double *velocity, timeval time, uint8_t gpsUtcOffset);
+
+private:
+	bool initialized;
+	timeval epoch;
+	elsetrec satrec;
+	gravconsttype whichconst;
+
+};
+
+#endif /* SGP4PROPAGATOR_H_ */

inc/fsfw/datalinklayer/BCFrame.h

@@ -0,0 +1,62 @@
+/**
+ * @file	BCFrame.h
+ * @brief	This file defines the BCFrame class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef BCFRAME_H_
+#define BCFRAME_H_
+
+#include "CCSDSReturnValuesIF.h"
+
+/**
+ * Small helper class to identify a BcFrame.
+ * @ingroup ccsds_handling
+ */
+class BcFrame: public CCSDSReturnValuesIF {
+private:
+	static const uint8_t UNLOCK_COMMAND = 0b00000000;//! Identifier for a certain BC Command.
+	static const uint8_t SET_V_R_1 = 0b10000010;//! Identifier for a certain BC Command.
+	static const uint8_t SET_V_R_2 = 0b00000000;//! Identifier for a certain BC Command.
+
+public:
+	uint8_t byte1;	//!< First content byte
+	uint8_t byte2;	//!< Second content byte
+	uint8_t vR;	//!< vR byte
+	/**
+	 * Simple default constructor.
+	 */
+	BcFrame() :
+			byte1(0), byte2(0), vR(0) {
+	}
+	/**
+	 * Main and only useful method of the class.
+	 * With the buffer and size information passed, the class passes the content
+	 * and checks if it is one of the two valid BC Command Frames.
+	 * @param inBuffer	Content of the frame to check,
+	 * @param inSize	Size of the data to check.
+	 * @return 	- #BC_ILLEGAL_COMMAND if it is no command.
+	 * 			- #BC_IS_UNLOCK_COMMAND if it is an unlock command.
+	 * 			- #BC_IS_SET_VR_COMMAND if it is such.
+	 */
+	ReturnValue_t initialize(const uint8_t* inBuffer, uint16_t inSize) {
+		ReturnValue_t returnValue = BC_ILLEGAL_COMMAND;
+		if (inSize == 1) {
+			byte1 = inBuffer[0];
+			if (byte1 == UNLOCK_COMMAND) {
+				returnValue = BC_IS_UNLOCK_COMMAND;
+			}
+		} else if (inSize == 3) {
+			byte1 = inBuffer[0];
+			byte2 = inBuffer[1];
+			vR = inBuffer[2];
+			if (byte1 == SET_V_R_1 && byte2 == SET_V_R_2) {
+				returnValue = BC_IS_SET_VR_COMMAND;
+			}
+		}
+		return returnValue;
+	}
+};
+
+#endif /* BCFRAME_H_ */

inc/fsfw/datalinklayer/CCSDSReturnValuesIF.h

@@ -0,0 +1,56 @@
+/**
+ * @file	CCSDSReturnValuesIF.h
+ * @brief	This file defines the CCSDSReturnValuesIF class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef CCSDSRETURNVALUESIF_H_
+#define CCSDSRETURNVALUESIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+/**
+ * This is a helper class to collect special return values that come up during CCSDS Handling.
+ * @ingroup ccsds_handling
+ */
+class CCSDSReturnValuesIF: public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_HANDLER_IF;	//!< Basic ID of the interface.
+
+	static const ReturnValue_t BC_IS_SET_VR_COMMAND = MAKE_RETURN_CODE( 0x01 );	//!< A value to describe a BC frame.
+	static const ReturnValue_t BC_IS_UNLOCK_COMMAND = MAKE_RETURN_CODE( 0x02 );	//!< A value to describe a BC frame.
+	static const ReturnValue_t BC_ILLEGAL_COMMAND = MAKE_RETURN_CODE( 0xB0 );//!< A value to describe an illegal BC frame.
+	static const ReturnValue_t BOARD_READING_NOT_FINISHED = MAKE_RETURN_CODE( 0xB1 );	//! The CCSDS Board is not yet finished reading, it requires another cycle.
+
+	static const ReturnValue_t NS_POSITIVE_W = MAKE_RETURN_CODE( 0xF0 );//!< NS is in the positive window
+	static const ReturnValue_t NS_NEGATIVE_W = MAKE_RETURN_CODE( 0xF1 );//!< NS is in the negative window
+	static const ReturnValue_t NS_LOCKOUT = MAKE_RETURN_CODE( 0xF2 );	//!< NS is in lockout state
+	static const ReturnValue_t FARM_IN_LOCKOUT = MAKE_RETURN_CODE( 0xF3 );//!< FARM-1 is currently in lockout state
+	static const ReturnValue_t FARM_IN_WAIT = MAKE_RETURN_CODE( 0xF4 );	//!< FARM-1 is currently in wait state
+
+	static const ReturnValue_t WRONG_SYMBOL = MAKE_RETURN_CODE( 0xE0 );	//!< An error code in the FrameFinder.
+	static const ReturnValue_t DOUBLE_START = MAKE_RETURN_CODE( 0xE1 );	//!< An error code in the FrameFinder.
+	static const ReturnValue_t START_SYMBOL_MISSED = MAKE_RETURN_CODE( 0xE2 );//!< An error code in the FrameFinder.
+	static const ReturnValue_t END_WITHOUT_START = MAKE_RETURN_CODE( 0xE3 );//!< An error code in the FrameFinder.
+	static const ReturnValue_t TOO_LARGE = MAKE_RETURN_CODE( 0xE4 );//!< An error code for a frame.
+	static const ReturnValue_t TOO_SHORT = MAKE_RETURN_CODE( 0xE5 );//!< An error code for a frame.
+	static const ReturnValue_t WRONG_TF_VERSION = MAKE_RETURN_CODE( 0xE6 );	//!< An error code for a frame.
+	static const ReturnValue_t WRONG_SPACECRAFT_ID = MAKE_RETURN_CODE( 0xE7 );//!< An error code for a frame.
+	static const ReturnValue_t NO_VALID_FRAME_TYPE = MAKE_RETURN_CODE( 0xE8 );//!< An error code for a frame.
+	static const ReturnValue_t CRC_FAILED = MAKE_RETURN_CODE( 0xE9 );//!< An error code for a frame.
+	static const ReturnValue_t VC_NOT_FOUND = MAKE_RETURN_CODE( 0xEA );	//!< An error code for a frame.
+	static const ReturnValue_t FORWARDING_FAILED = MAKE_RETURN_CODE( 0xEB );//!< An error code for a frame.
+	static const ReturnValue_t CONTENT_TOO_LARGE = MAKE_RETURN_CODE( 0xEC );//!< An error code for a frame.
+	static const ReturnValue_t RESIDUAL_DATA = MAKE_RETURN_CODE( 0xED );//!< An error code for a frame.
+	static const ReturnValue_t DATA_CORRUPTED = MAKE_RETURN_CODE( 0xEE );//!< An error code for a frame.
+	static const ReturnValue_t ILLEGAL_SEGMENTATION_FLAG = MAKE_RETURN_CODE( 0xEF );//!< An error code for a frame.
+	static const ReturnValue_t ILLEGAL_FLAG_COMBINATION = MAKE_RETURN_CODE( 0xD0 );	//!< An error code for a frame.
+	static const ReturnValue_t SHORTER_THAN_HEADER = MAKE_RETURN_CODE( 0xD1 );	//!< An error code for a frame.
+	static const ReturnValue_t TOO_SHORT_BLOCKED_PACKET = MAKE_RETURN_CODE( 0xD2 );	//!< An error code for a frame.
+	static const ReturnValue_t TOO_SHORT_MAP_EXTRACTION = MAKE_RETURN_CODE( 0xD3 );	//!< An error code for a frame.
+
+	virtual ~CCSDSReturnValuesIF() {
+	} //!< Empty virtual destructor
+};
+
+#endif /* CCSDSRETURNVALUESIF_H_ */

inc/fsfw/datalinklayer/Clcw.h

@@ -0,0 +1,59 @@
+#ifndef CLCW_H_
+#define CLCW_H_
+
+#include "ClcwIF.h"
+/**
+ * Small helper method to handle the Clcw values.
+ * It has a content struct that manages the register and can be set externally.
+ * @ingroup ccsds_handling
+ */
+class Clcw : public ClcwIF {
+private:
+	static const uint8_t STATUS_FIELD_DEFAULT = 0b00000001; //!< Default for the status field.
+	static const uint8_t NO_RF_AVIALABLE_POSITION = 7;	//!< Position of a flag in the register (starting with 0).
+	static const uint8_t NO_BIT_LOCK_POSITION = 6;	//!< Position of a flag in the register (starting with 0).
+	static const uint8_t LOCKOUT_FLAG_POSITION = 5;	//!< Position of a flag in the register (starting with 0).
+	static const uint8_t WAIT_FLAG_POSITION = 4;	//!< Position of a flag in the register (starting with 0).
+	static const uint8_t RETRANSMIT_FLAG_POSITION = 3;	//!< Position of a flag in the register (starting with 0).
+	static const uint8_t NO_RF_AVIALABLE_MASK = 0xFF xor (1 << NO_RF_AVIALABLE_POSITION);	//!< Mask for a flag in the register.
+	static const uint8_t NO_BIT_LOCK_MASK = 0xFF xor (1 << NO_BIT_LOCK_POSITION);	//!< Mask for a flag in the register.
+	static const uint8_t LOCKOUT_FLAG_MASK = 0xFF xor (1 << LOCKOUT_FLAG_POSITION);	//!< Mask for a flag in the register.
+	static const uint8_t WAIT_FLAG_MASK = 0xFF xor (1 << WAIT_FLAG_POSITION);	//!< Mask for a flag in the register.
+	static const uint8_t RETRANSMIT_FLAG_MASK = 0xFF xor (1 << RETRANSMIT_FLAG_POSITION);	//!< Mask for a flag in the register.
+	static const uint8_t FARM_B_COUNT_MASK = 0b11111001;	//!< Mask for a counter in the register.
+	/**
+	 * This is the data structure of the CLCW register.
+	 */
+	union clcwContent {
+		uint32_t raw;
+		struct {
+			uint8_t status;
+			uint8_t virtualChannelIdSpare;
+			uint8_t flags;
+			uint8_t vRValue;
+		};
+	};
+	clcwContent content;	//!< Represents the content of the register.
+public:
+	/**
+	 * The constructor sets everything to default values.
+	 */
+	Clcw();
+	/**
+	 * Nothing happens in the destructor.
+	 */
+	~Clcw();
+	void setVirtualChannel( uint8_t setChannel );
+	void setLockoutFlag( bool lockout );
+	void setWaitFlag( bool waitFlag );
+	void setRetransmitFlag( bool retransmitFlag );
+	void setFarmBCount( uint8_t count );
+	void setReceiverFrameSequenceNumber( uint8_t vR );
+	void setRFAvailable( bool rfAvailable );
+	void setBitLock( bool bitLock );
+	uint32_t getAsWhole();
+	void setWhole( uint32_t rawClcw );
+	void print();
+};
+
+#endif /* CLCW_H_ */

inc/fsfw/datalinklayer/ClcwIF.h

@@ -0,0 +1,70 @@
+/**
+ * @file	ClcwIF.h
+ * @brief	This file defines the ClcwIF class.
+ * @date	17.04.2013
+ * @author	baetz
+ */
+
+#ifndef CLCWIF_H_
+#define CLCWIF_H_
+
+#include <stdint.h>
+
+/**
+ * Interface to manage a CLCW register.
+ * @ingroup ccsds_handling
+ */
+class ClcwIF {
+public:
+	/**
+	 * Empty virtual destructor.
+	 */
+	virtual ~ClcwIF() {	}
+	/**
+	 * Simple setter.
+	 * @param setChannel The virtual channel id to set.
+	 */
+	virtual void setVirtualChannel( uint8_t setChannel ) = 0;
+	/**
+	 * Simple setter.
+	 * @param lockout status of the flag.
+	 */
+	virtual void setLockoutFlag( bool lockout ) = 0;
+	/**
+	 * Simple setter.
+	 * @param waitFlag status of the flag.
+	 */
+	virtual void setWaitFlag( bool waitFlag ) = 0;
+	/**
+	 * Simple setter.
+	 * @param retransmitFlag status of the flag.
+	 */
+	virtual void setRetransmitFlag( bool retransmitFlag ) = 0;
+	/**
+	 * Sets the farm B count.
+	 * @param count A full 8bit counter value can be passed. Only the last three bits are used.
+	 */
+	virtual void setFarmBCount( uint8_t count ) = 0;
+	/**
+	 * Simple setter.
+	 * @param vR Value of vR.
+	 */
+	virtual void setReceiverFrameSequenceNumber( uint8_t vR ) = 0;
+	/**
+	 * Returns the register as a full 32bit value.
+	 * @return The value.
+	 */
+	virtual uint32_t getAsWhole() = 0;
+	/**
+	 * Sets the whole content to this value.
+	 * @param rawClcw	The value to set the content.
+	 */
+	virtual void setWhole( uint32_t rawClcw ) = 0;
+	/**
+	 * Debug method to print the CLCW.
+	 */
+	virtual void print() = 0;
+};
+
+
+#endif /* CLCWIF_H_ */

inc/fsfw/datalinklayer/DataLinkLayer.h

@@ -0,0 +1,118 @@
+#ifndef DATALINKLAYER_H_
+#define DATALINKLAYER_H_
+
+#include "CCSDSReturnValuesIF.h"
+#include "ClcwIF.h"
+#include "TcTransferFrame.h"
+#include "VirtualChannelReceptionIF.h"
+#include "../events/Event.h"
+#include <map>
+
+
+class VirtualChannelReception;
+/**
+ * A complete representation of the CCSDS Data Link Layer.
+ * The operations of this layer are defined in the CCSDS TC Space Data Link Protocol
+ * document. It is configured to handle a VC Demultiplexing function. All reception
+ * steps are performed.
+ */
+class DataLinkLayer : public CCSDSReturnValuesIF {
+public:
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_1;
+	//! [EXPORT] : [COMMENT] A RF available signal was detected. P1: raw RFA state, P2: 0
+	static const Event RF_AVAILABLE = MAKE_EVENT(0, severity::INFO);
+	//! [EXPORT] : [COMMENT] A previously found RF available signal was lost.
+	//! P1: raw RFA state, P2: 0
+	static const Event RF_LOST = MAKE_EVENT(1, severity::INFO);
+	//! [EXPORT] : [COMMENT] A Bit Lock signal. Was detected. P1: raw BLO state, P2: 0
+	static const Event BIT_LOCK = MAKE_EVENT(2, severity::INFO);
+	//! [EXPORT] : [COMMENT] A previously found Bit Lock signal was lost. P1: raw BLO state, P2: 0
+	static const Event BIT_LOCK_LOST = MAKE_EVENT(3, severity::INFO);
+//	static const Event RF_CHAIN_LOST = MAKE_EVENT(4, severity::INFO); //!< The CCSDS Board detected that either bit lock or RF available or both are lost. No parameters.
+	//! [EXPORT] : [COMMENT] The CCSDS Board could not interpret a TC
+	static const Event FRAME_PROCESSING_FAILED = MAKE_EVENT(5, severity::LOW);
+	/**
+	 * The Constructor sets the passed parameters and nothing else.
+	 * @param set_frame_buffer The buffer in which incoming frame candidates are stored.
+	 * @param setClcw	The CLCW class to work on when returning CLCW information.
+	 * @param set_start_sequence_length	Length of the Start sequence in front of every TC Transfer Frame.
+	 * @param set_scid	The SCID to operate on.
+	 */
+	DataLinkLayer( uint8_t* set_frame_buffer, ClcwIF* setClcw, uint8_t set_start_sequence_length, uint16_t set_scid );
+	/**
+	 * Empty virtual destructor.
+	 */
+	~DataLinkLayer();
+	/**
+	 * This method tries to process a frame that is placed in #frameBuffer.
+	 * The procedures described in the Standard are performed.
+	 * @param length	Length of the incoming frame candidate.
+	 * @return	@c RETURN_OK on successful handling, otherwise the return codes of the higher methods.
+	 */
+	ReturnValue_t processFrame( uint16_t length );
+	/**
+	 * Configuration method to add a new TC Virtual Channel.
+	 * Shall only be called during initialization. As soon as the method was called, the layer can
+	 * handle Frames directed to this VC.
+	 * @param virtualChannelId	Id of the VC. Shall be smaller than 64.
+	 * @param object	Reference to the object that handles the Frame.
+	 * @return	@c RETURN_OK on success, @c RETURN_FAILED otherwise.
+	 */
+	ReturnValue_t addVirtualChannel( uint8_t virtualChannelId, VirtualChannelReceptionIF* object );
+	/**
+	 * The initialization method calls the @c initialize routine of all virtual channels.
+	 * @return The return code of the first failed VC initialization or @c RETURN_OK.
+	 */
+	ReturnValue_t initialize();
+private:
+	typedef std::map<uint8_t, VirtualChannelReceptionIF*>::iterator virtualChannelIterator; //!< Typedef to simplify handling the #virtualChannels map.
+	static const uint8_t FRAME_VERSION_NUMBER_DEFAULT = 0x00;	//!< Constant for the default value of Frame Version Numbers.
+	static const uint8_t FRAME_PRIMARY_HEADER_LENGTH = 5;	//!< Length of the frame's primary header.
+	static const uint8_t START_SEQUENCE_PATTERN = 0x00; //!< The start sequence pattern which might be with the frame.
+	static const bool USE_CRC = true;	//!< A global, so called "Managed Parameter" that identifies if incoming frames have CRC's or not.
+	uint16_t spacecraftId;	//!< The Space Craft Identifier (SCID) configured.
+	uint8_t* frameBuffer;	//!< A pointer to point to the current incoming frame.
+	ClcwIF* clcw;	//!< Pointer to store the CLCW to work on.
+	uint16_t receivedDataLength;	//!< Stores the length of the currently processed frame.
+	TcTransferFrame currentFrame;	//!< Stores a more convenient access to the current frame.
+	uint8_t startSequenceLength;	//!< Configured length of the start sequence. Maybe this must be done more variable.
+	std::map<uint8_t, VirtualChannelReceptionIF*> virtualChannels;	//!< Map of all virtual channels assigned.
+	/**
+	 * Method that performs all possible frame validity checks (as specified).
+	 * @return	Various error codes or @c RETURN_OK on success.
+	 */
+	ReturnValue_t frameValidationCheck();
+	/**
+	 * First method to call.
+	 * Removes start sequence bytes and checks if the complete frame was received.
+	 * SHOULDDO: Maybe handling the start sequence must be done more variable.
+	 * @return @c RETURN_OK or @c TOO_SHORT.
+	 */
+	ReturnValue_t frameDelimitingAndFillRemoval();
+	/**
+	 * Small helper method to check the CRC of the Frame.
+	 * @return @c RETURN_OK or @c CRC_FAILED.
+	 */
+	ReturnValue_t frameCheckCRC();
+	/**
+	 * Method that groups the reception process of all Frames.
+	 * Calls #frameDelimitingAndFillRemoval and #frameValidationCheck.
+	 * @return The return codes of the sub calls.
+	 */
+	ReturnValue_t allFramesReception();
+	/**
+	 * Dummy method for master channel demultiplexing.
+	 * As there's only one Master Channel here, the method calls #virtualChannelDemultiplexing.
+	 * @return	The return codes of #virtualChannelDemultiplexing.
+	 */
+	ReturnValue_t masterChannelDemultiplexing();
+	/**
+	 * Method to demultiplex the Frames to Virtual Channels (VC's).
+	 * Looks up the requested VC in #virtualChannels and forwards the Frame to its
+	 * #frameAcceptanceAndReportingMechanism method, if found.
+	 * @return The higher method codes or @c VC_NOT_FOUND.
+	 */
+	ReturnValue_t virtualChannelDemultiplexing();
+};
+
+#endif /* DATALINKLAYER_H_ */

inc/fsfw/datalinklayer/Farm1StateIF.h

@@ -0,0 +1,54 @@
+/**
+ * @file	Farm1StateIF.h
+ * @brief	This file defines the Farm1StateIF class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef FARM1STATEIF_H_
+#define FARM1STATEIF_H_
+
+#include "CCSDSReturnValuesIF.h"
+class VirtualChannelReception;
+class TcTransferFrame;
+class ClcwIF;
+
+/**
+ * This is the interface for states of the FARM-1 state machine.
+ * Classes implementing this interface can be used as FARM-1 states. This is a simple implementation
+ * of the state pattern.
+ */
+class Farm1StateIF : public CCSDSReturnValuesIF {
+public:
+	/**
+	 * A method that shall handle an incoming frame as AD Frame.
+	 * @param frame	The frame to handle.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	If forwarding to a MAP Channel is required, the return value shall be #FRAME_OK.
+	 * 			Otherwise, an appropriate return value or error code shall be generated.
+	 */
+	virtual ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw ) = 0;
+	/**
+	 * This method shall handle frames that have been successfully identified as BC Unlock frames.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	If forwarding to a MAP Channel is required, the return value shall be #FRAME_OK.
+	 * 			Otherwise, an appropriate return value or error code shall be generated.
+	 */
+	virtual ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw ) = 0;
+	/**
+	 * This method shall handle frames that have been successfully identified as BC Set VR frames.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @param vr The V(r) value found in the frame.
+	 * @return	If forwarding to a MAP Channel is required, the return value shall be #FRAME_OK.
+	 * 			Otherwise, an appropriate return value or error code shall be generated.
+	 */
+	virtual ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr ) = 0;
+	/**
+	 * Empty virtual destructor.
+	 */
+	virtual ~Farm1StateIF() {
+
+	}
+};
+
+#endif /* FARM1STATEIF_H_ */

inc/fsfw/datalinklayer/Farm1StateLockout.h

@@ -0,0 +1,52 @@
+#ifndef FARM1STATELOCKOUT_H_
+#define FARM1STATELOCKOUT_H_
+
+#include "Farm1StateIF.h"
+
+/**
+ * This class represents the FARM-1 "Lockout" State.
+ * The Lockout state is reached if the received Transfer Frame Sequence Number is completely wrong
+ * (i.e. within the Lockout Window). No AD Frames are forwarded. To leave the State, a BC Unlock
+ * command is required.
+ */
+class Farm1StateLockout : public Farm1StateIF {
+private:
+	/**
+	 * This is a reference to the "owner" class the State works on.
+	 */
+	VirtualChannelReception* myVC;
+public:
+	/**
+	 * The default constructor if the State.
+	 * Sets the "owner" of the State.
+	 * @param setMyVC	The "owner" class.
+	 */
+	Farm1StateLockout( VirtualChannelReception* setMyVC );
+	/**
+	 * All AD Frames are rejected with FARM_IN_LOCKOUT
+	 * @param frame	The frame to handle.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return FARM_IN_LOCKOUT
+	 */
+	ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * State changes to Farm1StateOpen.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_UNLOCK_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * The V(r) value is not set in Lockout State, even though the Command itself is accepted.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @param vr The V(r) value found in the frame.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_SET_VR_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr );
+};
+
+
+#endif /* FARM1STATELOCKOUT_H_ */

inc/fsfw/datalinklayer/Farm1StateOpen.h

@@ -0,0 +1,62 @@
+/**
+ * @file	Farm1StateOpen.h
+ * @brief	This file defines the Farm1StateOpen class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef FARM1STATEOPEN_H_
+#define FARM1STATEOPEN_H_
+
+#include "Farm1StateIF.h"
+
+/**
+ * This class represents the FARM-1 "Open" State.
+ * The Open state is the state of normal operation. It handles all types of frames,
+ * including AD Frames. If a wrong Frame Sequence Number is detected in an AD Frame, the
+ * State reacts as specified.
+ */
+class Farm1StateOpen : public Farm1StateIF {
+private:
+	/**
+	 * This is a reference to the "owner" class the State works on.
+	 */
+	VirtualChannelReception* myVC;
+public:
+	/**
+	 * The default constructor if the State.
+	 * Sets the "owner" of the State.
+	 * @param setMyVC	The "owner" class.
+	 */
+	Farm1StateOpen( VirtualChannelReception* setMyVC );
+	/**
+	 * Method to check the validity of AD Frames.
+	 * It checks the Frame Sequence Number and reacts as specified in the standard. The state may
+	 * change to Farm1StateLockout.
+	 * @param frame	The frame to handle.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return If the Sequence Number is ok, it returns #RETURN_OK. Otherwise either #NS_POSITIVE_W,
+	 * 			#NS_NEGATIVE_W or NS_LOCKOUT is returned.
+	 */
+	ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * State does not change.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_UNLOCK_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * State does not change.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @param vr The V(r) value found in the frame.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_SET_VR_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr );
+};
+
+
+#endif /* FARM1STATEOPEN_H_ */

inc/fsfw/datalinklayer/Farm1StateWait.h

@@ -0,0 +1,58 @@
+/**
+ * @file	Farm1StateWait.h
+ * @brief	This file defines the Farm1StateWait class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef FARM1STATEWAIT_H_
+#define FARM1STATEWAIT_H_
+
+#include "Farm1StateIF.h"
+
+/**
+ * This class represents the FARM-1 "Wait" State.
+ * The Wait state is reached if higher level procedures inform the FARM-1 Machine to wait
+ * for a certain period. Currently, it is not in use.
+ */
+class Farm1StateWait : public Farm1StateIF {
+private:
+	/**
+	 * This is a reference to the "owner" class the State works on.
+	 */
+	VirtualChannelReception* myVC;
+public:
+	/**
+	 * The default constructor if the State.
+	 * Sets the "owner" of the State.
+	 * @param setMyVC	The "owner" class.
+	 */
+	Farm1StateWait( VirtualChannelReception* setMyVC );
+	/**
+	 * AD Frames are always discarded.
+	 * If the frame number is in the lockout window, the state changes to Farm1StateLockout.
+	 * @param frame	The frame to handle.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	Always returns FARM_IN_WAIT.
+	 */
+	ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * State changes to Farm1StateOpen.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_UNLOCK_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @param vr The V(r) value found in the frame.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_SET_VR_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr );
+};
+
+
+#endif /* FARM1STATEWAIT_H_ */

inc/fsfw/datalinklayer/MapPacketExtraction.h

@@ -0,0 +1,73 @@
+#ifndef FSFW_DATALINKLAYER_MAPPACKETEXTRACTION_H_
+#define FSFW_DATALINKLAYER_MAPPACKETEXTRACTION_H_
+
+#include "MapPacketExtractionIF.h"
+#include "fsfw/objectmanager/ObjectManagerIF.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/ipc/MessageQueueSenderIF.h"
+
+class StorageManagerIF;
+
+/**
+ * Implementation of a MAP Packet Extraction class.
+ * The class implements the full MAP Packet Extraction functionality as described in the CCSDS
+ * TC Space Data Link Protocol. It internally stores incomplete segmented packets until they are
+ * fully received. All found packets are forwarded to a single distribution entity.
+ * @author B. Baetz
+ */
+class MapPacketExtraction: public MapPacketExtractionIF {
+private:
+	static const uint32_t MAX_PACKET_SIZE = 4096;
+	uint8_t lastSegmentationFlag;	//!< The segmentation flag of the last received frame.
+	uint8_t mapId;	//!< MAP ID of this MAP Channel.
+	uint32_t packetLength = 0;	//!< Complete length of the current Space Packet.
+	uint8_t* bufferPosition;	//!< Position to write to in the internal Packet buffer.
+	uint8_t packetBuffer[MAX_PACKET_SIZE];	//!< The internal Space Packet Buffer.
+	object_id_t packetDestination;
+	//!< Pointer to the store where full TC packets are stored.
+	StorageManagerIF* packetStore = nullptr;
+	MessageQueueId_t tcQueueId;		//!< QueueId to send found packets to the distributor.
+	/**
+	 * Debug method to print the packet Buffer's content.
+	 */
+	void printPacketBuffer();
+	/**
+	 * Method that is called if the segmentation flag is @c NO_SEGMENTATION.
+	 * The method extracts one or more packets within the frame and forwards them to the OBSW.
+	 * @param frame	The TC Transfer Frame to work on.
+	 * @return	@c RETURN_OK if all Packets were extracted. If something is entirely wrong,
+	 * 	 @c DATA_CORRUPTED is returned, if some bytes are left over @c RESIDUAL_DATA.
+	 */
+	ReturnValue_t unpackBlockingPackets(TcTransferFrame* frame);
+	/**
+	 * Helper method to forward a complete packet to the OBSW.
+	 * @param data	Pointer to the data, either directly from the frame or from the packetBuffer.
+	 * @param size	Complete total size of the packet.
+	 * @return	Return Code of the Packet Store or the Message Queue.
+	 */
+	ReturnValue_t sendCompletePacket( uint8_t* data, uint32_t size );
+	/**
+	 * Helper method to reset the internal buffer.
+	 */
+	void clearBuffers();
+public:
+	/**
+	 * Default constructor.
+	 * Members are set to default values.
+	 * @param setMapId	The MAP ID of the instance.
+	 */
+	MapPacketExtraction( uint8_t setMapId, object_id_t setPacketDestination );
+	ReturnValue_t extractPackets(TcTransferFrame* frame);
+	/**
+	 * The #packetStore and the default destination of #tcQueue are initialized here.
+	 * @return	@c RETURN_OK on success, @c RETURN_FAILED otherwise.
+	 */
+	ReturnValue_t initialize();
+	/**
+	 * Getter.
+	 * @return The MAP ID of this instance.
+	 */
+	uint8_t getMapId() const;
+};
+
+#endif /* FSFW_DATALINKLAYER_MAPPACKETEXTRACTION_H_ */

inc/fsfw/datalinklayer/MapPacketExtractionIF.h

@@ -0,0 +1,47 @@
+/**
+ * @file	MapPacketExtractionIF.h
+ * @brief	This file defines the MapPacketExtractionIF class.
+ * @date	25.03.2013
+ * @author	baetz
+ */
+
+#ifndef MAPPACKETEXTRACTIONIF_H_
+#define MAPPACKETEXTRACTIONIF_H_
+
+#include "CCSDSReturnValuesIF.h"
+#include "TcTransferFrame.h"
+
+/**
+ * This is the interface for MAP Packet Extraction classes.
+ * All classes implementing this interface shall be able to extract blocked or segmented Space
+ * Packets on a certain MAP channel. This is done in accordance with the CCSDS TC Space Data Link
+ * Protocol.
+ */
+class MapPacketExtractionIF : public CCSDSReturnValuesIF {
+protected:
+	static const uint8_t FIRST_PORTION = 0b01;		//!< Identification of the first part of a segmented Packet.
+	static const uint8_t CONTINUING_PORTION = 0b00;	//!< Identification of a continuing part of segmented Packets.
+	static const uint8_t LAST_PORTION = 0b10;		//!< The last portion of a segmented Packet.
+	static const uint8_t NO_SEGMENTATION = 0b11;	//!< A Frame without segmentation but maybe with blocking.
+public:
+	/**
+	 * Empty virtual destructor.
+	 */
+	virtual ~MapPacketExtractionIF() {
+	}
+	/**
+	 * Method to call to handle a single Transfer Frame.
+	 * The method tries to extract Packets from the frame as stated in the Standard.
+	 * @param frame
+	 * @return
+	 */
+	virtual ReturnValue_t extractPackets( TcTransferFrame* frame ) = 0;
+	/**
+	 * Any post-instantiation initialization shall be done in this method.
+	 * @return
+	 */
+	virtual ReturnValue_t initialize() = 0;
+};
+
+
+#endif /* MAPPACKETEXTRACTIONIF_H_ */

inc/fsfw/datalinklayer/TcTransferFrame.h

@@ -0,0 +1,137 @@
+#ifndef TCTRANSFERFRAME_H_
+#define TCTRANSFERFRAME_H_
+
+#include <cstdint>
+#include <cstddef>
+
+/**
+ * The TcTransferFrame class simplifies handling of such Frames.
+ * It operates on any buffer passed on construction. The data length
+ * is determined by the length field in the frame itself.
+ * It has a lot of getters for convenient access to the content.
+ * @ingroup ccsds_handling
+ */
+class TcTransferFrame {
+protected:
+	/**
+	 * The struct that defines the Frame's Primary Header.
+	 */
+	struct TcTransferFramePrimaryHeader {
+		uint8_t flagsAndScid;	//!< Highest byte with Flags and part of SCID.
+		uint8_t spacecraftId_l;	//!< Byte with rest of SCID
+		uint8_t vcidAndLength_h;	//!< Byte with VCID and part of length.
+		uint8_t length_l;			//!< Byte with rest of length.
+		uint8_t sequenceNumber;	//!< Lowest byte with Frame Sequence Number N(S).
+	};
+	/**
+	 * The struct defining the whole Transfer Frame.
+	 */
+	struct tc_transfer_frame {
+		TcTransferFramePrimaryHeader header;	//!< The header struct.
+		uint8_t dataField;				//!< The data field of the Transfer Frame.
+	};
+	tc_transfer_frame* frame;			//!< Pointer to a buffer where a Frame is placed.
+public:
+	static const uint8_t FRAME_CRC_SIZE = 2;	//!< Constant for the CRC size.
+	/**
+	 * Empty Constructor that sets the data pointer to NULL.
+	 */
+	TcTransferFrame();
+	/**
+	 * The data pointer passed in this Constructor is casted to the #tc_transfer_frame struct.
+	 * @param setData The data on which the class shall operate.
+	 */
+	TcTransferFrame(uint8_t* setData);
+	/**
+	 * Getter.
+	 * @return The Version number.
+	 */
+	uint8_t getVersionNumber();
+	/**
+	 * Getter.
+	 * @return	If the bypass flag is set or not.
+	 */
+	bool bypassFlagSet();
+	/**
+	 * Getter.
+	 * @return If the control command flag is set or not.
+	 */
+	bool controlCommandFlagSet();
+	/**
+	 * Getter.
+	 * @return If the spare bits in the Header are zero or not.
+	 */
+	bool spareIsZero();
+	/**
+	 * Getter.
+	 * @return The Spacecraft Identifier.
+	 */
+	uint16_t getSpacecraftId();
+	/**
+	 * Getter.
+	 * @return The Virtual Channel Identifier.
+	 */
+	uint8_t getVirtualChannelId();
+	/**
+	 * Getter.
+	 * @return The Frame length as stored in the Header.
+	 */
+	uint16_t getFrameLength();
+	/**
+	 * Getter.
+	 * @return The length of pure data (without CRC), assuming that a Segment Header is present.
+	 */
+	uint16_t getDataLength();
+	/**
+	 * Getter.
+	 * @return The length of pure data (without CRC), assuming that no Segment Header is present (for BC Frames).
+	 */
+	uint16_t getFullDataLength();
+	/**
+	 * Getter.
+	 * @return The sequence number from the header.
+	 */
+	uint8_t getSequenceNumber();
+	/**
+	 * Getter.
+	 * @return The Sequence Flags in the Segment Header byte (right aligned).
+	 */
+	uint8_t getSequenceFlags();
+	/**
+	 * Getter.
+	 * @return The Multiplexer Access Point Identifier from the Segment Header byte.
+	 */
+	uint8_t getMAPId();
+	/**
+	 * Getter.
+	 * @return A pointer to the date field AFTER a Segment Header.
+	 */
+	uint8_t* getDataField();
+	/**
+	 * Getter.
+	 * @return A pointer to the first byte in the Data Field (ignoring potential Segment Headers, for BC Frames).
+	 */
+	uint8_t* getFullDataField();
+	/**
+	 * Getter.
+	 * @return A pointer to the beginning of the Frame.
+	 */
+	uint8_t* getFullFrame();
+	/**
+	 * Getter
+	 * @return The total size of the Frame, which is the size stated in the Header + 1.
+	 */
+	uint16_t getFullSize();
+	/**
+	 * Getter.
+	 * @return Size of the #TcTransferFramePrimaryHeader.
+	 */
+	uint16_t getHeaderSize();
+	/**
+	 * Debug method to print the whole Frame to screen.
+	 */
+	void print();
+
+};
+
+#endif /* TCTRANSFERFRAME_H_ */

inc/fsfw/datalinklayer/TcTransferFrameLocal.h

@@ -0,0 +1,49 @@
+/**
+ * @file	TcTransferFrameLocal.h
+ * @brief	This file defines the TcTransferFrameLocal class.
+ * @date	27.04.2013
+ * @author	baetz
+ */
+
+#ifndef TCTRANSFERFRAMELOCAL_H_
+#define TCTRANSFERFRAMELOCAL_H_
+
+#include "TcTransferFrame.h"
+
+/**
+ * This is a helper class to locally create TC Transfer Frames.
+ * This is mainly required for testing purposes and therefore not very sophisticated.
+ * @ingroup ccsds_handling
+ */
+class TcTransferFrameLocal : public TcTransferFrame {
+private:
+	/**
+	 * A stuct to locally store the complete data.
+	 */
+	struct frameData {
+		TcTransferFramePrimaryHeader header;	//!< The primary header.
+		uint8_t data[1019];	//!< The data field.
+	};
+public:
+	frameData localData; //!< The local data in the Frame.
+	/**
+	 * The default Constructor.
+	 * All parameters in the Header are passed.
+	 * If a BC Frame is detected no segment header is created.
+	 * Otherwise (AD and BD), the Segment Header is set.
+	 * @param bypass			The bypass flag.
+	 * @param controlCommand	The Control Command flag.
+	 * @param scid				The SCID.
+	 * @param vcId				The VCID.
+	 * @param sequenceNumber	The Frame Sequence Number N(s)
+	 * @param setSegmentHeader	A value for the Segment Header.
+	 * @param data				Data to put into the Frame Data Field.
+	 * @param dataSize			Size of the Data.
+	 * @param forceCrc			if != 0, the value is used as CRC.
+	 */
+	TcTransferFrameLocal(bool bypass, bool controlCommand, uint16_t scid, uint8_t vcId, uint8_t sequenceNumber,
+			uint8_t setSegmentHeader = 0xC0, uint8_t* data = NULL, uint16_t dataSize = 0, uint16_t forceCrc = 0);
+};
+
+
+#endif /* TCTRANSFERFRAMELOCAL_H_ */

inc/fsfw/datalinklayer/VirtualChannelReception.h

@@ -0,0 +1,114 @@
+/**
+ * @file	VirtualChannelReception.h
+ * @brief	This file defines the VirtualChannelReception class.
+ * @date	25.03.2013
+ * @author	baetz
+ */
+
+#ifndef VIRTUALCHANNELRECEPTION_H_
+#define VIRTUALCHANNELRECEPTION_H_
+
+#include "CCSDSReturnValuesIF.h"
+#include "Clcw.h"
+#include "Farm1StateIF.h"
+#include "Farm1StateLockout.h"
+#include "Farm1StateOpen.h"
+#include "Farm1StateWait.h"
+#include "MapPacketExtractionIF.h"
+#include "VirtualChannelReceptionIF.h"
+#include <map>
+/**
+ * Implementation of a TC Virtual Channel.
+ * This is a full implementation of a virtual channel as specified in the CCSDS TC Space Data Link
+ * Protocol. It is designed to operate within an instance of the @c DataLinkLayer class.
+ * Features:
+ *  - any (6bit) Virtual Channel ID is assignable.
+ *  - Supports an arbitrary number of MAP Channels (with a map).
+ *  - Has a complete FARM-1 Machine built-in.
+ *
+ * The FARM-1 state machine uses the State Pattern.
+ */
+class VirtualChannelReception : public VirtualChannelReceptionIF, public CCSDSReturnValuesIF {
+	friend class Farm1StateOpen;
+	friend class Farm1StateWait;
+	friend class Farm1StateLockout;
+private:
+	uint8_t channelId;	//!< Stores the VCID that was assigned on construction.
+	uint8_t slidingWindowWidth;	//!< A constant to set the FARM-1 sliding window width.
+	uint8_t positiveWindow;	//!< The positive window for the FARM-1 machine.
+	uint8_t negativeWindow; //!< The negative window for the FARM-1 machine.
+protected:
+	Farm1StateIF* currentState;	//!< The current state. To change, one of the other states must be assigned to this pointer.
+	Farm1StateOpen openState;	//!< Instance of the FARM-1 State "Open".
+	Farm1StateWait waitState;	//!< Instance of the FARM-1 State "Wait".
+	Farm1StateLockout lockoutState;	//!< Instance of the FARM-1 State "Lockout".
+	Clcw internalClcw;	//!< A CLCW class to internally set the values before writing them back to the TTC System.
+	uint8_t vR;	//!< The Receiver Frame Sequence Number V(R) as it shall be maintained for every Virtual Channel.
+	uint8_t farmBCounter;	//!< The FARM-B COunter as it shall be maintained for every Virtual Channel.
+	typedef std::map<uint8_t, MapPacketExtractionIF*>::iterator mapChannelIterator;	//!< Typedef to simplify handling of the mapChannels map.
+	std::map<uint8_t, MapPacketExtractionIF*> mapChannels;	//!< A map that maintains all map Channels. Channels must be configured on initialization. MAy be omitted in a simplified version.
+	/**
+	 * This method handles demultiplexing to different map channels.
+	 * It parses the entries of #mapChannels and forwards the Frame to a found MAP Channel.
+	 * @param frame	The frame to forward.
+	 * @return	#VC_NOT_FOUND or the return value of the map channel extraction.
+	 */
+	ReturnValue_t mapDemultiplexing( TcTransferFrame* frame );
+	/**
+	 * A sub-method that actually does the FARM-1 handling for different Frame types.
+	 * @param frame	The Tc Transfer Frame to handle.
+	 * @param clcw	Any changes on the CLCW shall be done with this method.
+	 * @return	The return code of higher methods or @c ILLEGAL_FLAG_COMBINATION.
+	 */
+	ReturnValue_t doFARM(TcTransferFrame* frame, ClcwIF* clcw);
+	/**
+	 * Handles incoming BD Frames.
+	 * Handling these Frames is independent of the State, so no subcall to #currentState is
+	 * required.
+	 * @param frame	The Tc Transfer Frame to handle.
+	 * @param clcw	Any changes on the CLCW shall be done with this method.
+	 * @return Always returns @c RETURN_OK.
+	 */
+	ReturnValue_t handleBDFrame( TcTransferFrame* frame, ClcwIF* clcw );
+	/**
+	 * Handles incoming BC Frames.
+	 * The type of the BC Frame is detected and checked first, then methods of #currentState are called.
+	 * @param frame	The Tc Transfer Frame to handle.
+	 * @param clcw	Any changes on the CLCW shall be done with this method.
+	 * @return The failure code of BC Frame interpretation or the return code of higher methods.
+	 */
+	ReturnValue_t handleBCFrame( TcTransferFrame* frame, ClcwIF* clcw );
+public:
+	/**
+	 * Default constructor.
+	 * Only sets the channelId of the channel. Setting the Sliding Window width is possible as well.
+	 * @param setChannelId	Virtual Channel Identifier (VCID) of the channel.
+	 */
+	VirtualChannelReception( uint8_t setChannelId, uint8_t setSlidingWindowWidth );
+	ReturnValue_t frameAcceptanceAndReportingMechanism( TcTransferFrame* frame, ClcwIF* clcw );
+	/**
+	 * Helper method to simplify adding a mapChannel during construction.
+	 * @param mapId	The mapId of the object to add.
+	 * @param object	Pointer to the MapPacketExtraction object itself.
+	 * @return	@c RETURN_OK if the channel was successfully inserted, @c RETURN_FAILED otherwise.
+	 */
+	ReturnValue_t addMapChannel( uint8_t mapId, MapPacketExtractionIF* object );
+	/**
+	 * The initialization routine checks the set #slidingWindowWidth and initializes all MAP
+	 * channels.
+	 * @return	@c RETURN_OK on successful initialization, @c RETURN_FAILED otherwise.
+	 */
+	ReturnValue_t initialize();
+	/**
+	 * Getter for the VCID.
+	 * @return	The #channelId.
+	 */
+	uint8_t getChannelId() const;
+	/**
+	 * Small method to set the state to Farm1StateWait.
+	 */
+	void setToWaitState();
+};
+
+
+#endif /* VIRTUALCHANNELRECEPTION_H_ */

inc/fsfw/datalinklayer/VirtualChannelReceptionIF.h

@@ -0,0 +1,57 @@
+/**
+ * @file	VirtualChannelReceptionIF.h
+ * @brief	This file defines the VirtualChannelReceptionIF class.
+ * @date	25.03.2013
+ * @author	baetz
+ */
+
+#ifndef VIRTUALCHANNELRECEPTIONIF_H_
+#define VIRTUALCHANNELRECEPTIONIF_H_
+
+#include "ClcwIF.h"
+#include "TcTransferFrame.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+/**
+ * This is the interface for Virtual Channel reception classes.
+ * It represents a single TC Virtual Channel that operates on one IO
+ */
+class VirtualChannelReceptionIF {
+public:
+	/**
+	 * Enum including all valid types of frames.
+	 * The type is made up by two flags, so 0b1111 is definitely illegal.
+	 */
+	enum frameType  {
+		AD_FRAME = 0b00,
+		BC_FRAME = 0b11,
+		BD_FRAME = 0b10,
+		ILLEGAL_FRAME = 0b1111
+	};
+	/**
+	 * Empty virtual destructor.
+	 */
+	virtual ~VirtualChannelReceptionIF() {
+	}
+	/**
+	 * This method shall accept frames and do all FARM-1 stuff.
+	 * Handling the Frame includes forwarding to higher-level procedures.
+	 * @param frame	The Tc Transfer Frame that was received and checked.
+	 * @param clcw	Any changes to the CLCW value are forwarded by using this parameter.
+	 * @return The return Value shall indicate successful processing with @c RETURN_OK.
+	 */
+	virtual ReturnValue_t frameAcceptanceAndReportingMechanism( TcTransferFrame* frame, ClcwIF* clcw ) = 0;
+	/**
+	 * If any other System Objects are required for operation they shall be initialized here.
+	 * @return	@c RETURN_OK for successful initialization.
+	 */
+	virtual ReturnValue_t initialize() = 0;
+	/**
+	 * Getter for the VCID.
+	 * @return	The #channelId.
+	 */
+	virtual uint8_t getChannelId() const = 0;
+};
+
+
+#endif /* VIRTUALCHANNELRECEPTIONIF_H_ */

inc/fsfw/datapool/DataSetIF.h

@@ -0,0 +1,45 @@
+#ifndef FSFW_DATAPOOL_DATASETIF_H_
+#define FSFW_DATAPOOL_DATASETIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../timemanager/Clock.h"
+class PoolVariableIF;
+
+/**
+ * @brief	This class defines a small interface to register on a DataSet.
+ *
+ * @details
+ * Currently, the only purpose of this interface is to provide a
+ * method for locally checked-out variables to register on a data set.
+ * Still, it may become useful for other purposes as well.
+ * @author 	Bastian Baetz
+ * @ingroup data_pool
+ */
+class DataSetIF {
+public:
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::DATA_SET_CLASS;
+	static constexpr ReturnValue_t INVALID_PARAMETER_DEFINITION = MAKE_RETURN_CODE(1);
+	static constexpr ReturnValue_t SET_WAS_ALREADY_READ = MAKE_RETURN_CODE(2);
+	static constexpr ReturnValue_t COMMITING_WITHOUT_READING = MAKE_RETURN_CODE(3);
+
+	static constexpr ReturnValue_t DATA_SET_UNINITIALISED = MAKE_RETURN_CODE(4);
+	static constexpr ReturnValue_t DATA_SET_FULL = MAKE_RETURN_CODE(5);
+	static constexpr ReturnValue_t POOL_VAR_NULL = MAKE_RETURN_CODE(6);
+
+	/**
+	 * @brief	This is an empty virtual destructor,
+	 * 			as it is proposed for C++ interfaces.
+	 */
+	virtual ~DataSetIF() {}
+
+	/**
+	 * @brief	This operation provides a method to register local data pool
+	 * 			variables to register in a data set by passing itself
+	 * 			to this DataSet operation.
+	 */
+	virtual ReturnValue_t registerVariable(PoolVariableIF* variable) = 0;
+
+	virtual uint16_t getFillCount() const = 0;
+};
+
+#endif /* FSFW_DATAPOOL_DATASETIF_H_ */

inc/fsfw/datapool/HkSwitchHelper.h

@@ -0,0 +1,46 @@
+#ifndef FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_
+#define FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_
+
+#include "fsfw/tasks/ExecutableObjectIF.h"
+#include "fsfw/action/CommandsActionsIF.h"
+#include "fsfw/events/EventReportingProxyIF.h"
+
+//TODO this class violations separation between mission and framework
+//but it is only a transitional solution until the Datapool is
+//implemented decentrally
+
+class HkSwitchHelper: public ExecutableObjectIF, public CommandsActionsIF {
+public:
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::HK;
+	static const Event SWITCHING_TM_FAILED = MAKE_EVENT(1, severity::LOW); //!< Commanding the HK Service failed, p1: error code, p2 action: 0 disable / 1 enable
+
+	HkSwitchHelper(EventReportingProxyIF *eventProxy);
+	virtual ~HkSwitchHelper();
+
+	ReturnValue_t initialize();
+
+	virtual ReturnValue_t  performOperation(uint8_t operationCode = 0);
+
+	ReturnValue_t switchHK(SerializeIF *sids, bool enable);
+
+	virtual void setTaskIF(PeriodicTaskIF* task_){};
+
+protected:
+	virtual void stepSuccessfulReceived(ActionId_t actionId, uint8_t step);
+	virtual void stepFailedReceived(ActionId_t actionId, uint8_t step,
+			ReturnValue_t returnCode);
+	virtual void dataReceived(ActionId_t actionId, const uint8_t* data,
+			uint32_t size);
+	virtual void completionSuccessfulReceived(ActionId_t actionId);
+	virtual void completionFailedReceived(ActionId_t actionId,
+			ReturnValue_t returnCode);
+	virtual MessageQueueIF* getCommandQueuePtr();
+
+private:
+	CommandActionHelper commandActionHelper;
+	MessageQueueIF* actionQueue;
+	EventReportingProxyIF *eventProxy;
+};
+
+#endif /* FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_ */

inc/fsfw/datapool/PoolDataSetBase.h

@@ -0,0 +1,181 @@
+#ifndef FSFW_DATAPOOL_POOLDATASETBASE_H_
+#define FSFW_DATAPOOL_POOLDATASETBASE_H_
+
+#include "PoolDataSetIF.h"
+#include "PoolVariableIF.h"
+
+#include "fsfw/serialize/SerializeIF.h"
+#include "fsfw/ipc/MutexIF.h"
+
+/**
+ * @brief	The DataSetBase class manages a set of locally checked out variables.
+ * @details
+ * This class manages a list, where a set of local variables (or pool variables)
+ * are registered. They are checked-out (i.e. their values are looked
+ * up and copied) with the read call. After the user finishes working with the
+ * pool variables, he can write back all variable values to the pool with
+ * the commit call. The data set manages locking and freeing the data pool,
+ * to ensure that all values are read and written back at once.
+ *
+ * An internal state manages usage of this class. Variables may only be
+ * registered before the read call is made, and the commit call only
+ * after the read call.
+ *
+ * If pool variables are writable and not committed until destruction
+ * of the set, the DataSet class automatically sets the valid flag in the
+ * data pool to invalid (without) changing the variable's value.
+ *
+ * The base class lockDataPool und unlockDataPool implementation are empty
+ * and should be implemented to protect the underlying pool type.
+ * @author	Bastian Baetz
+ * @ingroup data_pool
+ */
+class PoolDataSetBase:
+        public PoolDataSetIF,
+        public SerializeIF,
+        public HasReturnvaluesIF {
+public:
+
+    /**
+     * @brief	Creates an empty dataset. Use registerVariable or
+     * 			supply a pointer to this dataset to PoolVariable
+     * 			initializations to register pool variables.
+     */
+    PoolDataSetBase(PoolVariableIF** registeredVariablesArray, const size_t maxFillCount);
+
+    /* Forbidden for now */
+    PoolDataSetBase(const PoolDataSetBase& otherSet) = delete;
+    const PoolDataSetBase& operator=(const PoolDataSetBase& otherSet) = delete;
+
+    virtual~ PoolDataSetBase();
+
+    /**
+     * @brief	The read call initializes reading out all registered variables.
+     * 			It is mandatory to call commit after every read call!
+     * @details
+     * It iterates through the list of registered variables and calls all read()
+     * functions of the registered pool variables (which read out their values
+     * from the data pool) which are not write-only.
+     * In case of an error (e.g. a wrong data type, or an invalid data pool id),
+     * the operation is aborted and @c INVALID_PARAMETER_DEFINITION returned.
+     *
+     * The data pool is locked during the whole read operation and
+     * freed afterwards. It is mandatory to call commit after a read call,
+     * even if the read operation is not successful!
+     * @return
+     * - @c RETURN_OK if all variables were read successfully.
+     * - @c INVALID_PARAMETER_DEFINITION if a pool entry does not exist or there
+     *      is a type conflict.
+     * - @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;
+    /**
+     * @brief	The commit call initializes writing back the registered variables.
+     * @details
+     * It iterates through the list of registered variables and calls the
+     * commit() method of the remaining registered variables (which write back
+     * their values to the pool).
+     *
+     * The data pool is locked during the whole commit operation and
+     * freed afterwards. The state changes to "was committed" after this operation.
+     *
+     * If the set does contain at least one variable which is not write-only
+     * commit() can only be called after read(). If the set only contains
+     * variables which are write only, commit() can be called without a
+     * preceding read() call. Every read call must be followed by a commit call!
+     * @return	- @c RETURN_OK if all variables were read successfully.
+     * 			- @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;
+
+    /**
+     * Register the passed pool variable instance into the data set.
+     * @param variable
+     * @return
+     */
+    virtual 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;
+    /**
+     * 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;
+
+    virtual uint16_t getFillCount() const;
+
+    /* 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;
+
+    /**
+     * Can be used to individually protect every read and commit call.
+     * @param protectEveryReadCommit
+     * @param mutexTimeout
+     */
+    void setReadCommitProtectionBehaviour(bool protectEveryReadCommit,
+            MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+            uint32_t mutexTimeout = 20);
+protected:
+
+    /**
+     * @brief	The fill_count attribute ensures that the variables
+     * 			register in the correct array position and that the maximum
+     * 			number of variables is not exceeded.
+     */
+    uint16_t fillCount = 0;
+    /**
+     * States of the seet.
+     */
+    enum class States {
+        STATE_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED
+        STATE_SET_WAS_READ     //!< DATA_SET_WAS_READ
+    };
+    /**
+     * @brief	state manages the internal state of the data set,
+     *          which is important e.g. for the behavior on destruction.
+     */
+    States state = States::STATE_SET_UNINITIALISED;
+
+    /**
+     * @brief	This array represents all pool variables registered in this set.
+     * Child classes can use a static or dynamic container to create
+     * an array of registered variables and assign the first entry here.
+     */
+    PoolVariableIF** registeredVariables = nullptr;
+    const size_t maxFillCount = 0;
+
+    void setContainer(PoolVariableIF** variablesContainer);
+    PoolVariableIF** getContainer() const;
+
+private:
+    bool protectEveryReadCommitCall = false;
+    MutexIF::TimeoutType timeoutTypeForSingleVars = MutexIF::TimeoutType::WAITING;
+    uint32_t mutexTimeoutForSingleVars = 20;
+
+    ReturnValue_t readVariable(uint16_t count);
+    void handleAlreadyReadDatasetCommit(
+            MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+            uint32_t timeoutMs = 20);
+    ReturnValue_t handleUnreadDatasetCommit(
+            MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+            uint32_t timeoutMs = 20);
+};
+
+#endif /* FSFW_DATAPOOL_POOLDATASETBASE_H_ */

inc/fsfw/datapool/PoolDataSetIF.h

@@ -0,0 +1,36 @@
+#ifndef FSFW_DATAPOOL_POOLDATASETIF_H_
+#define FSFW_DATAPOOL_POOLDATASETIF_H_
+
+#include "ReadCommitIF.h"
+#include "DataSetIF.h"
+
+/**
+ * @brief   Extendes the DataSetIF by adding abstract functions to lock
+ *          and unlock a data pool and read/commit semantics.
+ */
+class PoolDataSetIF:
+        virtual public DataSetIF,
+        virtual public ReadCommitIF {
+public:
+    virtual~ PoolDataSetIF() {};
+
+    /**
+     * @brief   Most underlying data structures will have a pool like structure
+     *          and will require a lock and unlock mechanism to ensure
+     *          thread-safety
+     * @return Lock operation result
+     */
+    virtual ReturnValue_t lockDataPool(
+    		MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20) = 0;
+
+    /**
+     * @brief   Unlock call corresponding to the lock call.
+     * @return Unlock operation result
+     */
+    virtual ReturnValue_t unlockDataPool() = 0;
+
+    virtual bool isValid() const = 0;
+};
+
+#endif /* FSFW_DATAPOOL_POOLDATASETIF_H_ */

inc/fsfw/datapool/PoolEntry.h

@@ -0,0 +1,137 @@
+#ifndef FSFW_DATAPOOL_POOLENTRY_H_
+#define FSFW_DATAPOOL_POOLENTRY_H_
+
+#include "PoolEntryIF.h"
+
+#include <initializer_list>
+#include <type_traits>
+#include <cstddef>
+
+/**
+ * @brief	This is a small helper class that defines a single data pool entry.
+ * @details
+ * The helper is used to store all information together with the data as a
+ * single data pool entry. The content's type is defined by the template
+ * argument.
+ *
+ * It is prepared for use with plain old data types, but may be
+ * extended to complex types if necessary. It can be initialized with a
+ * certain value, size and validity flag.
+ *
+ * It holds a pointer to the real data and offers methods to access this data
+ * and to acquire additional information (such as validity and array/byte size).
+ * It is NOT intended to be used outside DataPool implementations as it performs
+ * dynamic memory allocation.
+ *
+ * @ingroup data_pool
+ */
+template <typename T>
+class PoolEntry : public PoolEntryIF {
+public:
+	static_assert(not std::is_same<T, bool>::value,
+				"Do not use boolean for the PoolEntry type, use uint8_t "
+				"instead! The ECSS standard defines a boolean as a one bit "
+				"field. Therefore it is preferred to store a boolean as an "
+				"uint8_t");
+	/**
+	 * @brief	In the classe's constructor, space is allocated on the heap and
+	 * 			potential initialization values are copied to that space.
+	 * @details
+	 * Not passing any arguments will initialize an non-array pool entry
+	 * with an initial invalid state and the value 0.
+	 * Please note that if an initializer list is passed, the length of the
+	 * initializer list needs to be correct for vector entries because
+	 * required allocated space will be deduced from the initializer list length
+	 * and the pool entry type.
+	 * @param initValue
+	 * Initializer list with values to initialize with, for example {0, 0} to
+	 * initialize the a pool entry of a vector with two entries to 0.
+	 * @param setValid
+	 * Sets the initialization flag. It is invalid by default.
+	 */
+	PoolEntry(std::initializer_list<T> initValue = {0}, bool setValid = false);
+
+	/**
+	 * @brief	In the classe's constructor, space is allocated on the heap and
+	 * 			potential init values are copied to that space.
+	 * @param initValue
+	 * A pointer to the single value or array that holds the init value.
+	 * With the default value (nullptr), the entry is initalized with all 0.
+	 * @param setLength
+	 * Defines the array length of this entry.
+	 * @param setValid
+	 * Sets the initialization flag. It is invalid by default.
+	 */
+	PoolEntry(T* initValue, uint8_t setLength = 1, bool setValid = false);
+
+	//! Explicitely deleted copy ctor, copying is not allowed.
+	PoolEntry(const PoolEntry&) = delete;
+	//! Explicitely deleted copy assignment, copying is not allowed.
+	PoolEntry& operator=(const PoolEntry&) = delete;
+
+	/**
+	 * @brief	The allocated memory for the variable is freed
+	 * 			in the destructor.
+	 * @details
+	 * As the data pool is global, this dtor is only called on program exit.
+	 * PoolEntries shall never be copied, as a copy might delete the variable
+	 * on the heap.
+	 */
+	~PoolEntry();
+
+	/**
+	 * Return typed pointer to start of data.
+	 * @return
+	 */
+	T* getDataPtr();
+
+	/**
+	 * @brief	getSize returns the array size of the entry.
+	 * @details
+	 * For non-array pool entries return type size, for vector entries
+	 * return type size times the number of entries.
+	 */
+	uint8_t getSize();
+	/**
+	 * @brief	This operation returns the size in bytes.
+	 * @details	The size is calculated by sizeof(type) * array_size.
+	 */
+	uint16_t getByteSize();
+	/**
+	 * @brief	This operation returns a the address pointer casted to void*.
+	 */
+	void* getRawData();
+	/**
+	 * @brief	This method allows to set the valid information
+	 * 			of the pool entry.
+	 */
+	void setValid( bool isValid );
+	/**
+	 * @brief	This method allows to get the valid information
+	 * 			of the pool entry.
+	 */
+	bool getValid();
+	/**
+	 * @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();
+
+private:
+	/**
+	 * @brief	This attribute stores the length information.
+	 */
+	uint8_t length;
+	/**
+	 * @brief	Here, the validity information for a variable is stored.
+	 * 			Every entry (single variable or vector) has one valid flag.
+	 */
+	uint8_t valid;
+	/**
+	 * @brief	This is the address pointing to the allocated memory.
+	 */
+	T* address;
+};
+
+#endif /* FSFW_DATAPOOL_POOLENTRY_H_ */

inc/fsfw/datapool/PoolEntryIF.h

@@ -0,0 +1,63 @@
+#ifndef FSFW_DATAPOOL_POOLENTRYIF_H_
+#define FSFW_DATAPOOL_POOLENTRYIF_H_
+
+#include "../globalfunctions/Type.h"
+#include <cstdint>
+
+/**
+ * @brief	This interface defines the access possibilities to a
+ * 			single data pool entry.
+ * @details
+ * The interface provides methods to determine the size and the validity
+ * information of a value. It also defines a method to receive a pointer to the
+ * raw data content. It is mainly used by DataPool itself, but also as a
+ * return pointer.
+ *
+ * @author	Bastian Baetz
+ * @ingroup data_pool
+ *
+ */
+class PoolEntryIF {
+public:
+	/**
+	 * @brief	This is an empty virtual destructor,
+	 * 			as it is required for C++ interfaces.
+	 */
+	virtual ~PoolEntryIF() {
+	}
+	/**
+	 * @brief	getSize returns the array size of the entry.
+	 * 			A single variable parameter has size 1.
+	 */
+	virtual uint8_t getSize() = 0;
+	/**
+	 * @brief	This operation returns the size in bytes, which is calculated by
+	 * 			sizeof(type) * array_size.
+	 */
+	virtual uint16_t getByteSize() = 0;
+	/**
+	 * @brief	This operation returns a the address pointer casted to void*.
+	 */
+	virtual void* getRawData() = 0;
+	/**
+	 * @brief	This method allows to set the valid information of the pool entry.
+	 */
+	virtual void setValid(bool isValid) = 0;
+	/**
+	 * @brief	This method allows to set the valid information of the pool entry.
+	 */
+	virtual bool getValid() = 0;
+	/**
+	 * @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.
+	 * @details
+	 * Also displays whether the pool entry is valid or invalid.
+	 */
+	virtual void print() = 0;
+	/**
+	 * Returns the type of the entry.
+	 */
+	virtual Type getType() = 0;
+};
+
+#endif /* FSFW_DATAPOOL_POOLENTRYIF_H_ */

inc/fsfw/datapool/PoolReadGuard.h

@@ -0,0 +1,62 @@
+#ifndef FSFW_DATAPOOL_POOLREADHELPER_H_
+#define FSFW_DATAPOOL_POOLREADHELPER_H_
+
+#include "ReadCommitIF.h"
+#include "../serviceinterface/ServiceInterface.h"
+#include <FSFWConfig.h>
+
+/**
+ * @brief 	Helper class to read data sets or pool variables
+ */
+class PoolReadGuard {
+public:
+    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);
+            if(readResult != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_VERBOSE_LEVEL == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+                sif::error << "PoolReadHelper: Read failed!" << std::endl;
+#else
+                sif::printError("PoolReadHelper: Read failed!\n");
+#endif /* FSFW_PRINT_VERBOSITY_LEVEL == 1 */
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+            }
+        }
+    }
+
+    ReturnValue_t getReadResult() const {
+        return readResult;
+    }
+
+    /**
+     * @brief   Can be used to suppress commit on destruction.
+     */
+    void setNoCommitMode(bool commit) {
+        this->noCommit = commit;
+    }
+
+    /**
+     * @brief   Default destructor which will take care of commiting changed values.
+     */
+    ~PoolReadGuard() {
+        if(readObject != nullptr and not noCommit) {
+            readObject->commit(timeoutType, mutexTimeout);
+        }
+
+    }
+
+private:
+    ReadCommitIF* readObject = nullptr;
+    ReturnValue_t readResult = HasReturnvaluesIF::RETURN_OK;
+    bool noCommit = false;
+    MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+    uint32_t mutexTimeout = 20;
+};
+
+
+
+#endif /* FSFW_DATAPOOL_POOLREADHELPER_H_ */

inc/fsfw/datapool/PoolVarList.h

@@ -0,0 +1,29 @@
+#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_ */

inc/fsfw/datapool/PoolVariableIF.h

@@ -0,0 +1,68 @@
+#ifndef FSFW_DATAPOOL_POOLVARIABLEIF_H_
+#define FSFW_DATAPOOL_POOLVARIABLEIF_H_
+
+#include "ReadCommitIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerializeIF.h"
+
+
+/**
+ * @brief	This interface is used to control data pool
+ * 			variable representations.
+ * @details
+ * To securely handle data pool variables, all pool entries are locally
+ * managed by data pool variable access classes, which are called pool
+ * variables. To ensure a common state of a set of variables needed in a
+ * function, these local pool variables again are managed by other classes,
+ * like the DataSet classes. This interface provides unified access to
+ * local pool variables for such manager classes.
+ * @author 	Bastian Baetz
+ * @ingroup data_pool
+ */
+class PoolVariableIF :
+        public SerializeIF,
+        public ReadCommitIF {
+
+public:
+    static constexpr uint8_t INTERFACE_ID = CLASS_ID::POOL_VARIABLE_IF;
+    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 uint32_t NO_PARAMETER = 0xffffffff;
+
+    enum ReadWriteMode_t {
+        VAR_READ, VAR_WRITE, VAR_READ_WRITE
+    };
+
+    /**
+     * @brief	This is an empty virtual destructor,
+     * 			as it is proposed for C++ interfaces.
+     */
+    virtual ~PoolVariableIF() {}
+    /**
+     * @brief	This method returns if the variable is write-only,
+     * 			read-write or read-only.
+     */
+    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;
+    /**
+     * @brief	With this call, the valid information of the
+     * 			variable is returned.
+     */
+    virtual bool isValid() const = 0;
+    /**
+     * @brief	With this call, the valid information of the variable is set.
+     */
+    virtual void setValid(bool validity) = 0;
+};
+
+using pool_rwm_t = PoolVariableIF::ReadWriteMode_t;
+
+#endif /* FSFW_DATAPOOL_POOLVARIABLEIF_H_ */

inc/fsfw/datapool/ReadCommitIF.h

@@ -0,0 +1,34 @@
+#ifndef FSFW_DATAPOOL_READCOMMITIF_H_
+#define FSFW_DATAPOOL_READCOMMITIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MutexIF.h"
+
+/**
+ * @brief 	Common interface for all software objects which employ read-commit
+ * 			semantics.
+ */
+class ReadCommitIF {
+    friend class ReadCommitIFAttorney;
+public:
+	virtual ~ReadCommitIF() {}
+	virtual ReturnValue_t read(MutexIF::TimeoutType timeoutType,
+			uint32_t timeoutMs) = 0;
+	virtual ReturnValue_t commit(MutexIF::TimeoutType timeoutType,
+			uint32_t timeoutMs) = 0;
+
+protected:
+
+	/* Optional and protected because this is interesting for classes grouping members with commit
+	and read semantics where the lock is only necessary once. */
+	virtual ReturnValue_t readWithoutLock()  {
+		return read(MutexIF::TimeoutType::WAITING, 20);
+	}
+
+	virtual ReturnValue_t commitWithoutLock() {
+		return commit(MutexIF::TimeoutType::WAITING, 20);
+	}
+};
+
+
+#endif /* FSFW_DATAPOOL_READCOMMITIF_H_ */

inc/fsfw/datapool/ReadCommitIFAttorney.h

@@ -0,0 +1,32 @@
+#ifndef FSFW_DATAPOOL_READCOMMITIFATTORNEY_H_
+#define FSFW_DATAPOOL_READCOMMITIFATTORNEY_H_
+
+#include <fsfw/datapool/ReadCommitIF.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+/**
+ * @brief   This class determines which members are allowed to access protected members
+ *          of the ReadCommitIF.
+ */
+class ReadCommitIFAttorney {
+private:
+    static ReturnValue_t readWithoutLock(ReadCommitIF* readCommitIF) {
+        if(readCommitIF == nullptr) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        return readCommitIF->readWithoutLock();
+    }
+
+    static ReturnValue_t commitWithoutLock(ReadCommitIF* readCommitIF) {
+        if(readCommitIF == nullptr) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        return readCommitIF->commitWithoutLock();
+    }
+
+    friend class PoolDataSetBase;
+};
+
+
+
+#endif /* FSFW_DATAPOOL_READCOMMITIFATTORNEY_H_ */

inc/fsfw/datapool/SharedDataSetIF.h

@@ -0,0 +1,16 @@
+#ifndef FRAMEWORK_DATAPOOL_SHAREDDATASETIF_H_
+#define FRAMEWORK_DATAPOOL_SHAREDDATASETIF_H_
+
+#include "PoolDataSetIF.h"
+
+class SharedDataSetIF {
+public:
+    virtual ~SharedDataSetIF() {};
+
+private:
+    virtual ReturnValue_t lockDataset(MutexIF::TimeoutType timeoutType,
+            dur_millis_t mutexTimeout) = 0;
+    virtual ReturnValue_t unlockDataset() = 0;
+};
+
+#endif /* FRAMEWORK_DATAPOOL_SHAREDDATASETIF_H_ */

inc/fsfw/datapoollocal.h

@@ -0,0 +1,12 @@
+#ifndef FSFW_DATAPOOLLOCAL_DATAPOOLLOCAL_H_
+#define FSFW_DATAPOOLLOCAL_DATAPOOLLOCAL_H_
+
+/* Collected related headers */
+#include "datapoollocal/LocalPoolVariable.h"
+#include "datapoollocal/LocalPoolVector.h"
+#include "datapoollocal/StaticLocalDataSet.h"
+#include "datapoollocal/LocalDataSet.h"
+#include "datapoollocal/SharedLocalDataSet.h"
+
+
+#endif /* FSFW_DATAPOOLLOCAL_DATAPOOLLOCAL_H_ */

inc/fsfw/datapoollocal/AccessLocalPoolF.h

@@ -0,0 +1,27 @@
+#ifndef FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_
+#define FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_
+
+class LocalDataPoolManager;
+class MutexIF;
+
+/**
+ * @brief 	Accessor class which can be used by classes which like to use the pool manager.
+ */
+class AccessPoolManagerIF {
+public:
+    virtual ~AccessPoolManagerIF() {};
+
+    virtual MutexIF* getLocalPoolMutex() = 0;
+
+    /**
+     * Can be used to get a handle to the local data pool manager.
+     * This function is protected because it should only be used by the
+     * class imlementing the interface.
+     */
+    virtual LocalDataPoolManager* getPoolManagerHandle() = 0;
+
+protected:
+
+};
+
+#endif /* FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_ */

inc/fsfw/datapoollocal/HasLocalDataPoolIF.h

@@ -0,0 +1,187 @@
+#ifndef FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
+#define FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
+
+#include "localPoolDefinitions.h"
+#include "LocalDataPoolManager.h"
+
+#include "../datapool/PoolEntryIF.h"
+#include "../serviceinterface/ServiceInterface.h"
+#include "../ipc/MessageQueueSenderIF.h"
+#include "../housekeeping/HousekeepingMessage.h"
+
+#include <map>
+
+class AccessPoolManagerIF;
+class ProvidesDataPoolSubscriptionIF;
+class LocalPoolDataSetBase;
+class LocalPoolObjectBase;
+
+/**
+ * @brief 		This interface is implemented by classes which posses a local data pool (not the
+ * 				managing class). It defines the relationship between the local data pool owner
+ * 				and the LocalDataPoolManager.
+ * @details
+ * Any class implementing this interface shall also have a LocalDataPoolManager member class which
+ * contains the actual pool data structure and exposes the public interface for it.
+ *
+ * The local data pool can be accessed using helper classes by using the
+ * LocalPoolVariable, LocalPoolVector or LocalDataSet classes. Every local pool variable can
+ * be uniquely identified by a global pool ID (gp_id_t) and every dataset tied
+ * to a pool manager can be uniqely identified by a global structure ID (sid_t).
+ *
+ * All software objects which want to use the local pool of another object shall also use this
+ * interface, for example to get a handle to the subscription interface. The interface
+ * can be retrieved using the object manager, provided the target object is a SystemObject.
+ * For example, the following line of code can be used to retrieve the interface
+ *
+ *    HasLocalDataPoolIF* poolIF = ObjectManager::instance()->
+ *             get<HasLocalDataPoolIF>(objects::SOME_OBJECT);
+ *    if(poolIF != nullptr) {
+ *        doSomething()
+ *    }
+ */
+class HasLocalDataPoolIF {
+    friend class HasLocalDpIFManagerAttorney;
+    friend class HasLocalDpIFUserAttorney;
+public:
+    virtual~ HasLocalDataPoolIF() {};
+
+    static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
+
+    virtual object_id_t getObjectId() const = 0;
+
+    /** Command queue for housekeeping messages. */
+    virtual MessageQueueId_t getCommandQueue() const = 0;
+
+    /**
+     * Is used by pool owner to initialize the pool map once
+     * The manager instance shall also be passed to this function.
+     * It can be used to subscribe for periodic packets for for updates.
+     */
+    virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+            LocalDataPoolManager& poolManager) = 0;
+
+    /**
+     * Returns the minimum sampling frequency in milliseconds, which will
+     * usually be the period the pool owner performs its periodic operation.
+     * @return
+     */
+    virtual dur_millis_t getPeriodicOperationFrequency() const = 0;
+
+    /**
+     * @brief   This function will be called by the manager if an update
+     *          notification is received.
+     * @details  HasLocalDataPoolIF
+     * Can be overriden by the child class to handle changed datasets.
+     * @param sid           SID of the updated set
+     * @param storeId       If a snapshot was requested, data will be located inside
+     * the IPC store with this store ID.
+     * @param clearMessage  If this is set to true, the pool manager will take care of
+     *                      clearing the store automatically
+     */
+    virtual void handleChangedDataset(sid_t sid,
+            store_address_t storeId = storeId::INVALID_STORE_ADDRESS,
+            bool* clearMessage = nullptr) {
+        if(clearMessage != nullptr) {
+            *clearMessage = true;
+        }
+    }
+
+    /**
+     * @brief   This function will be called by the manager if an update
+     *          notification is received.
+     * @details
+     * Can be overriden by the child class to handle changed pool variables.
+     * @param gpid          GPID of the updated variable.
+     * @param storeId       If a snapshot was requested, data will be located inside
+     * the IPC store with this store ID.
+     * @param clearMessage  Relevant for snapshots. If the boolean this points to is set to true,
+     *                      the pool manager will take care of clearing the store automatically
+     *                      after the callback.
+     */
+    virtual void handleChangedPoolVariable(gp_id_t gpid,
+            store_address_t storeId = storeId::INVALID_STORE_ADDRESS,
+            bool* clearMessage = nullptr) {
+        if(clearMessage != nullptr) {
+            *clearMessage = true;
+        }
+    }
+
+    /**
+     * These function can be implemented by pool owner, if they are required
+     * and used by the housekeeping message interface.
+     * */
+    virtual ReturnValue_t addDataSet(sid_t sid) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    };
+    virtual ReturnValue_t removeDataSet(sid_t sid) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    };
+    virtual ReturnValue_t changeCollectionInterval(sid_t sid, float newIntervalSeconds) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    };
+
+    /**
+     * This function can be used by data pool consumers to retrieve a handle
+     * which allows subscriptions to dataset and variable updates in form of messages.
+     * The consumers can then read the most recent variable value by calling read with
+     * an own pool variable or set instance or using the deserialized snapshot data.
+     * Returns the HK manager casted to the required interface by default.
+     * @return
+     */
+    virtual ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() {
+        return getHkManagerHandle();
+    }
+
+protected:
+
+    /**
+     * Every class implementing this interface should have a local data pool manager. This
+     * function will return a reference to the manager.
+     * @return
+     */
+    virtual LocalDataPoolManager* getHkManagerHandle() = 0;
+
+    /**
+     * Accessor handle required for internal handling. Not intended for users and therefore
+     * declared protected. Users should instead use pool variables, sets or the subscription
+     * interface to access pool entries. Returns the HK manager casted to a different interface
+     * by default.
+     * @return
+     */
+    virtual AccessPoolManagerIF* getAccessorHandle() {
+        return getHkManagerHandle();
+    }
+
+    /**
+     * This function is used by the pool manager to get a valid dataset
+     * from a SID. This function is protected to prevent users from
+     * using raw data set pointers which could not be thread-safe. Users
+     * should use the #ProvidesDataPoolSubscriptionIF.
+     * @param sid Corresponding structure ID
+     * @return
+     */
+    virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) = 0;
+
+    /**
+     * Similar to the function above, but used to get a local pool variable
+     * handle. This is only needed for update notifications, so it is not
+     * defined as abstract. This function is protected to prevent users from
+     * using raw pool variable pointers which could not be thread-safe.
+     * Users should use the #ProvidesDataPoolSubscriptionIF.
+     * @param localPoolId
+     * @return
+     */
+    virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden. "
+                "Returning nullptr!" << std::endl;
+#else
+        sif::printWarning("HasLocalDataPoolIF::getPoolObjectHandle: "
+                "Not overriden. Returning nullptr!\n");
+#endif
+        return nullptr;
+    }
+};
+
+#endif /* FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_ */

inc/fsfw/datapoollocal/LocalDataPoolManager.h

@@ -0,0 +1,415 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
+#define FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
+
+#include "ProvidesDataPoolSubscriptionIF.h"
+#include "AccessLocalPoolF.h"
+
+#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw/housekeeping/HousekeepingPacketDownlink.h"
+#include "fsfw/housekeeping/HousekeepingMessage.h"
+#include "fsfw/housekeeping/PeriodicHousekeepingHelper.h"
+#include "fsfw/datapool/DataSetIF.h"
+#include "fsfw/datapool/PoolEntry.h"
+#include "fsfw/objectmanager/SystemObjectIF.h"
+#include "fsfw/ipc/MutexIF.h"
+#include "fsfw/ipc/CommandMessage.h"
+#include "fsfw/ipc/MessageQueueIF.h"
+#include "fsfw/ipc/MutexGuard.h"
+
+#include <map>
+#include <vector>
+
+namespace Factory {
+void setStaticFrameworkObjectIds();
+}
+
+class LocalPoolDataSetBase;
+class HousekeepingSnapshot;
+class HasLocalDataPoolIF;
+class LocalDataPool;
+
+/**
+ * @brief 		This class is the managing instance for the local data pool.
+ * @details
+ * The actual data pool structure is a member of this class. Any class which
+ * has a local data pool shall have this manager class as a member and implement
+ * the HasLocalDataPoolIF.
+ *
+ * The manager offers some adaption points and functions which can be used
+ * by the owning class to simplify data handling significantly.
+ *
+ * Please ensure that both initialize and initializeAfterTaskCreation are
+ * called at some point by the owning class in the respective functions of the
+ * same name!
+ *
+ * Users of the data pool use the helper classes LocalDataSet,
+ * LocalPoolVariable and LocalPoolVector to access pool entries in
+ * a thread-safe and efficient way.
+ *
+ * The local data pools employ a blackboard logic: Only the most recent
+ * value is stored. The helper classes offer a read() and commit() interface
+ * through the PoolVariableIF which is used to read and update values.
+ * Each pool entry has a valid state too.
+ * @author 		R. Mueller
+ */
+class LocalDataPoolManager:
+        public ProvidesDataPoolSubscriptionIF,
+        public AccessPoolManagerIF {
+    friend void (Factory::setStaticFrameworkObjectIds)();
+    //! Some classes using the pool manager directly need to access class internals of the
+    //! manager. The attorney provides granular control of access to these internals.
+    friend class LocalDpManagerAttorney;
+public:
+    static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
+
+    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_INVALID = MAKE_RETURN_CODE(0);
+    static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(1);
+    static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(2);
+    static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(3);
+    static constexpr ReturnValue_t POOLOBJECT_NOT_FOUND = MAKE_RETURN_CODE(4);
+    static constexpr ReturnValue_t DATASET_NOT_FOUND = MAKE_RETURN_CODE(5);
+
+
+    /**
+     * This constructor is used by a class which wants to implement
+     * a personal local data pool. The queueToUse can be supplied if it
+     * is already known.
+     *
+     * initialize() has to be called in any case before using the object!
+     * @param owner
+     * @param queueToUse
+     * @param appendValidityBuffer Specify whether a buffer containing the
+     * validity state is generated  when serializing or deserializing packets.
+     */
+    LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
+            bool appendValidityBuffer = true);
+    virtual~ LocalDataPoolManager();
+
+    /**
+     * Assigns the queue to use. Make sure to call this in the #initialize
+     * function of the owner.
+     * @param queueToUse
+     * @param nonDiagInvlFactor See #setNonDiagnosticIntervalFactor doc
+     * @return
+     */
+    ReturnValue_t initialize(MessageQueueIF* queueToUse);
+
+    /**
+     * Initializes the map by calling the map initialization function and
+     * setting the periodic factor for non-diagnostic packets.
+     * Don't forget to call this in the #initializeAfterTaskCreation call of
+     * the owner, otherwise the map will be invalid!
+     * @param nonDiagInvlFactor
+     * @return
+     */
+    ReturnValue_t initializeAfterTaskCreation(
+            uint8_t nonDiagInvlFactor = 5);
+
+    /**
+     * @brief   This should be called in the periodic handler of the owner.
+     * @details
+     * This in generally called in the #performOperation function of the owner.
+     * It performs all the periodic functionalities of the data pool manager,
+     * for example generating periodic HK packets.
+     * Marked virtual as an adaption point for custom data pool managers.
+     * @return
+     */
+    virtual ReturnValue_t performHkOperation();
+
+    /**
+     * @brief   Subscribe for the generation of periodic packets.
+     * @details
+     * This subscription mechanism will generally be used by the data creator
+     * to generate housekeeping packets which are downlinked directly.
+     * @return
+     */
+    ReturnValue_t subscribeForPeriodicPacket(sid_t sid, bool enableReporting,
+            float collectionInterval, bool isDiagnostics,
+            object_id_t packetDestination = defaultHkDestination) override;
+
+    /**
+     * @brief   Subscribe for the  generation of packets if the dataset
+     *          is marked as changed.
+     * @details
+     * This subscription mechanism will generally be used by the data creator.
+     * @param sid
+     * @param isDiagnostics
+     * @param packetDestination
+     * @return
+     */
+    ReturnValue_t subscribeForUpdatePacket(sid_t sid, bool reportingEnabled,
+            bool isDiagnostics,
+            object_id_t packetDestination = defaultHkDestination) override;
+
+    /**
+     * @brief   Subscribe for a notification message which will be sent
+     *          if a dataset has changed.
+     * @details
+     * This subscription mechanism will generally be used internally by
+     * other software components.
+     * @param setId     Set ID of the set to receive update messages from.
+     * @param destinationObject
+     * @param targetQueueId
+     * @param generateSnapshot If this is set to true, a copy of the current
+     * data with a timestamp will be generated and sent via message.
+     * Otherwise, only an notification message is sent.
+     * @return
+     */
+    ReturnValue_t subscribeForSetUpdateMessage(const uint32_t setId,
+            object_id_t destinationObject,
+            MessageQueueId_t targetQueueId,
+            bool generateSnapshot) override;
+
+    /**
+     * @brief   Subscribe for an notification message which will be sent if a
+     *          pool variable has changed.
+     * @details
+     * This subscription mechanism will generally be used internally by
+     * other software components.
+     * @param localPoolId Pool ID of the pool variable
+     * @param destinationObject
+     * @param targetQueueId
+     * @param generateSnapshot If this is set to true, a copy of the current
+     * data with a timestamp will be generated and sent via message.
+     * Otherwise, only an notification message is sent.
+     * @return
+     */
+    ReturnValue_t subscribeForVariableUpdateMessage(const lp_id_t localPoolId,
+            object_id_t destinationObject,
+            MessageQueueId_t targetQueueId,
+            bool generateSnapshot) override;
+
+    /**
+     * Non-Diagnostics packets usually have a lower minimum sampling frequency
+     * than diagnostic packets.
+     * A factor can be specified to determine the minimum sampling frequency
+     * for non-diagnostic packets. The minimum sampling frequency of the
+     * diagnostics packets,which is usually jusst the period of the
+     * performOperation calls, is multiplied with that factor.
+     * @param factor
+     */
+    void setNonDiagnosticIntervalFactor(uint8_t nonDiagInvlFactor);
+
+    /**
+     * @brief   The manager is also able to handle housekeeping messages.
+     * @details
+     * This most commonly is used to handle messages for the housekeeping
+     * interface, but the manager is also able to handle update notifications
+     * and calls a special function which can be overriden by a child class
+     * to handle data set or pool variable updates. This is relevant
+     * for classes like controllers which have their own local datapool
+     * but pull their data from other local datapools.
+     * @param message
+     * @return
+     */
+    virtual ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
+
+    /**
+     * Generate a housekeeping packet with a given SID.
+     * @param sid
+     * @return
+     */
+    ReturnValue_t generateHousekeepingPacket(sid_t sid,
+            LocalPoolDataSetBase* dataSet, bool forDownlink,
+            MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
+
+    HasLocalDataPoolIF* getOwner();
+
+    ReturnValue_t printPoolEntry(lp_id_t localPoolId);
+
+    /**
+     * Different types of housekeeping reporting are possible.
+     *  1. PERIODIC:
+     *     HK packets are generated in fixed intervals and sent to
+     *     destination. Fromat will be raw.
+     *  2. UPDATE_NOTIFICATION:
+     *     Notification will be sent out if HK data has changed.
+     *  3. UPDATE_SNAPSHOT:
+     *     HK packets are only generated if explicitely requested.
+     *     Propably not necessary, just use multiple local data sets or
+     *     shared datasets.
+     */
+    enum class ReportingType: uint8_t {
+        //! Periodic generation of HK packets.
+        PERIODIC,
+        //! Housekeeping packet will be generated if values have changed.
+        UPDATE_HK,
+        //! Update notification will be sent out as message.
+        UPDATE_NOTIFICATION,
+        //! Notification will be sent out as message and a snapshot of the
+        //! current data will be generated.
+        UPDATE_SNAPSHOT,
+    };
+
+    /** Different data types are possible in the HK receiver map. For example, updates can be
+    requested for full datasets or for single pool variables. Periodic reporting is only possible
+    for data sets. */
+    enum class DataType: uint8_t {
+        LOCAL_POOL_VARIABLE,
+        DATA_SET
+    };
+
+    /* Copying forbidden */
+    LocalDataPoolManager(const LocalDataPoolManager &) = delete;
+    LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
+
+    /**
+     * This function can be used to clear the receivers list. This is
+     * intended for test functions and not for regular operations, because
+     * the insertion operations allocate dynamically.
+     */
+    void clearReceiversList();
+
+    object_id_t getCreatorObjectId() const;
+
+    /**
+     * Get the pointer to the mutex. Can be used to lock the data pool
+     * externally. Use with care and don't forget to unlock locked mutexes!
+     * For now, only friend classes can accss this function.
+     * @return
+     */
+    MutexIF* getMutexHandle();
+
+    virtual LocalDataPoolManager* getPoolManagerHandle() override;
+
+protected:
+
+    /** Core data structure for the actual pool data */
+    localpool::DataPool localPoolMap;
+    /** Every housekeeping data manager has a mutex to protect access
+    to it's data pool. */
+    MutexIF* mutex = nullptr;
+
+    /** The class which actually owns the manager (and its datapool). */
+    HasLocalDataPoolIF* owner = nullptr;
+
+    uint8_t nonDiagnosticIntervalFactor = 0;
+
+    /** Default receiver for periodic HK packets */
+    static object_id_t defaultHkDestination;
+    MessageQueueId_t hkDestinationId = MessageQueueIF::NO_QUEUE;
+
+    union DataId {
+        DataId(): sid() {};
+        sid_t sid;
+        lp_id_t localPoolId;
+    };
+
+    /** The data pool manager will keep an internal map of HK receivers. */
+    struct HkReceiver {
+        /** Object ID of receiver */
+        object_id_t objectId = objects::NO_OBJECT;
+
+        DataType dataType = DataType::DATA_SET;
+        DataId dataId;
+
+        ReportingType reportingType = ReportingType::PERIODIC;
+        MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
+    };
+
+    /** This vector will contain the list of HK receivers. */
+    using HkReceivers = std::vector<struct HkReceiver>;
+
+    HkReceivers hkReceivers;
+
+    struct HkUpdateResetHelper {
+        DataType dataType = DataType::DATA_SET;
+        DataId dataId;
+        uint8_t updateCounter;
+        uint8_t currentUpdateCounter;
+    };
+
+    using HkUpdateResetList = std::vector<struct HkUpdateResetHelper>;
+    /** This list is used to manage creating multiple update packets and only resetting
+    the update flag if all of them were created. Will only be created when needed. */
+    HkUpdateResetList* hkUpdateResetList = nullptr;
+
+    /** This is the map holding the actual data. Should only be initialized
+     * once ! */
+    bool mapInitialized = false;
+    /** This specifies whether a validity buffer is appended at the end
+     * of generated housekeeping packets. */
+    bool appendValidityBuffer = true;
+
+    /**
+     * @brief Queue used for communication, for example commands.
+     * Is also used to send messages. Can be set either in the constructor
+     * or in the initialize() function.
+     */
+    MessageQueueIF* hkQueue = nullptr;
+
+    /** Global IPC store is used to store all packets. */
+    StorageManagerIF* ipcStore = nullptr;
+
+    /**
+     * Read a variable by supplying its local pool ID and assign the pool
+     * entry to the supplied PoolEntry pointer. The type of the pool entry
+     * is deduced automatically. This call is not thread-safe!
+     * For now, only classes designated by the LocalDpManagerAttorney may use this function.
+     * @tparam T Type of the pool entry
+     * @param localPoolId Pool ID of the variable to read
+     * @param poolVar [out] Corresponding pool entry will be assigned to the
+     * 						supplied pointer.
+     * @return
+     */
+    template <class T> ReturnValue_t fetchPoolEntry(lp_id_t localPoolId, PoolEntry<T> **poolEntry);
+
+    /**
+     * This function is used to fill the local data pool map with pool
+     * entries. It should only be called once by the pool owner.
+     * @param localDataPoolMap
+     * @return
+     */
+    ReturnValue_t initializeHousekeepingPoolEntriesOnce();
+
+    MutexIF* getLocalPoolMutex() override;
+
+    ReturnValue_t serializeHkPacketIntoStore(HousekeepingPacketDownlink& hkPacket,
+            store_address_t& storeId, bool forDownlink, size_t* serializedSize);
+
+    void performPeriodicHkGeneration(HkReceiver& hkReceiver);
+    ReturnValue_t togglePeriodicGeneration(sid_t sid, bool enable, bool isDiagnostics);
+    ReturnValue_t changeCollectionInterval(sid_t sid, float newCollectionInterval,
+            bool isDiagnostics);
+    ReturnValue_t generateSetStructurePacket(sid_t sid, bool isDiagnostics);
+
+    void handleHkUpdateResetListInsertion(DataType dataType, DataId dataId);
+    void handleChangeResetLogic(DataType type,
+            DataId dataId, MarkChangedIF* toReset);
+    void resetHkUpdateResetHelper();
+
+    ReturnValue_t handleHkUpdate(HkReceiver& hkReceiver, ReturnValue_t& status);
+    ReturnValue_t handleNotificationUpdate(HkReceiver& hkReceiver, ReturnValue_t& status);
+    ReturnValue_t handleNotificationSnapshot(HkReceiver& hkReceiver, ReturnValue_t& status);
+    ReturnValue_t addUpdateToStore(HousekeepingSnapshot& updatePacket, store_address_t& storeId);
+
+    void printWarningOrError(sif::OutputTypes outputType, const char* functionName,
+            ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_FAILED,
+            const char* errorPrint = nullptr);
+};
+
+
+template<class T> inline
+ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId, PoolEntry<T> **poolEntry) {
+    if(poolEntry == nullptr) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
+    auto poolIter = localPoolMap.find(localPoolId);
+    if (poolIter == localPoolMap.end()) {
+        printWarningOrError(sif::OutputTypes::OUT_WARNING, "fetchPoolEntry",
+                localpool::POOL_ENTRY_NOT_FOUND);
+        return localpool::POOL_ENTRY_NOT_FOUND;
+    }
+
+    *poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
+    if(*poolEntry == nullptr) {
+        printWarningOrError(sif::OutputTypes::OUT_WARNING, "fetchPoolEntry",
+                localpool::POOL_ENTRY_TYPE_CONFLICT);
+        return localpool::POOL_ENTRY_TYPE_CONFLICT;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_ */

inc/fsfw/datapoollocal/LocalDataSet.h

@@ -0,0 +1,36 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCALDATASET_H_
+#define FSFW_DATAPOOLLOCAL_LOCALDATASET_H_
+
+#include "LocalPoolDataSetBase.h"
+#include <vector>
+
+/**
+ * @brief   This dataset type can be used to group related pool variables if the number of
+ *          variables should not be fixed.
+ * @details
+ * This will is the primary data structure to organize pool variables into
+ * sets which can be accessed via the housekeeping service interface or
+ * which can be sent to other software objects.
+ *
+ * It is recommended to read the documentation of the LocalPoolDataSetBase
+ * class for more information on how this class works and how to use it.
+ * @tparam capacity Capacity of the static dataset, which is usually known
+ * beforehand.
+ */
+class LocalDataSet: public LocalPoolDataSetBase {
+public:
+    LocalDataSet(HasLocalDataPoolIF* hkOwner, uint32_t setId,
+            const size_t maxSize);
+
+    LocalDataSet(sid_t sid, const size_t maxSize);
+
+    virtual~ LocalDataSet();
+
+    //! Copying forbidden for now.
+    LocalDataSet(const LocalDataSet&) = delete;
+    LocalDataSet& operator=(const LocalDataSet&) = delete;
+private:
+    std::vector<PoolVariableIF*> poolVarList;
+};
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCALDATASET_H_ */

inc/fsfw/datapoollocal/LocalPoolDataSetBase.h

@@ -0,0 +1,241 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
+
+#include "MarkChangedIF.h"
+#include "localPoolDefinitions.h"
+
+#include "fsfw/datapool/DataSetIF.h"
+#include "fsfw/datapool/PoolDataSetBase.h"
+
+#include <vector>
+
+class LocalDataPoolManager;
+class HasLocalDataPoolIF;
+class PeriodicHousekeepingHelper;
+
+/**
+ * @brief	The LocalDataSet class manages a set of locally checked out
+ *          variables for local data pools
+ * @details
+ * Extends the PoolDataSetBase class for local data pools by introducing
+ * a validity state, a flag to mark the set as changed, and various other
+ * functions to make it usable by the LocalDataPoolManager class.
+ *
+ * This class manages a list, where a set of local variables (or pool variables)
+ * are registered. They are checked-out (i.e. their values are looked
+ * up and copied) with the read call. After the user finishes working with the
+ * pool variables, he can write back all variable values to the pool with
+ * the commit call. The data set manages locking and freeing the local data
+ * pools, to ensure thread-safety.
+ *
+ * Pool variables can be added to the dataset by using the constructor
+ * argument of the pool variable or using the #registerVariable member function.
+ *
+ * An internal state manages usage of this class. Variables may only be
+ * registered before any read call is made, and the commit call can only happen
+ * after the read call.
+ *
+ * If pool variables are writable and not committed until destruction
+ * of the set, the DataSet class automatically sets the valid flag in the
+ * data pool to invalid (without) changing the variable's value.
+ *
+ * @ingroup data_pool
+ */
+class LocalPoolDataSetBase:
+        public PoolDataSetBase,
+        public MarkChangedIF {
+    friend class LocalPoolDataSetAttorney;
+    friend class PeriodicHousekeepingHelper;
+public:
+    /**
+     * @brief	Constructor for the creator of local pool data.
+     * @details
+     * This constructor also initializes the components required for
+     * periodic handling.
+     */
+    LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
+            uint32_t setId, PoolVariableIF** registeredVariablesArray,
+            const size_t maxNumberOfVariables, bool periodicHandling = true);
+
+    /**
+     * @brief	Constructor for users of the local pool data, which need
+     *          to access data created by one HK manager.
+     * @details
+     * Unlike the first constructor, no component for periodic handling
+     * will be initiated.
+     * @param sid Unique identifier of dataset consisting of object ID and
+     * set ID.
+     * @param registeredVariablesArray
+     * @param maxNumberOfVariables
+     */
+    LocalPoolDataSetBase(sid_t sid, PoolVariableIF** registeredVariablesArray,
+            const size_t maxNumberOfVariables);
+
+    /**
+     * @brief	Simple constructor, if the dataset is not the owner by
+     * 			a class with a HK manager.
+     * @details
+     * This constructor won't create components required for periodic handling
+     * and it also won't try to deduce the HK manager because no SID is
+     * supplied. This function should therefore be called by classes which need
+     * to access pool variables from different creators.
+     *
+     * If the class is intended to access pool variables from different
+     * creators, the third argument should be set to true. The mutex
+     * properties can be set with #setReadCommitProtectionBehaviour .
+     * @param registeredVariablesArray
+     * @param maxNumberOfVariables
+     * @param protectEveryReadCommitCall If the pool variables are created by
+     * multiple creators, this flag can be set to protect all read and
+     * commit calls separately.
+     */
+    LocalPoolDataSetBase(PoolVariableIF** registeredVariablesArray,
+            const size_t maxNumberOfVariables,
+            bool protectEveryReadCommitCall = true);
+
+    /**
+     * @brief	The destructor automatically manages writing the valid
+     * 			information of variables.
+     * @details
+     * In case the data set was read out, but not committed (indicated by state),
+     * the destructor parses all variables that are still registered to the set.
+     * For each, the valid flag in the data pool is set to "invalid".
+     */
+    ~LocalPoolDataSetBase();
+
+    /* The copy constructor and assingment constructor are forbidden for now.
+    The use-cases are limited and the first step would be to implement them properly for the
+    base class */
+    LocalPoolDataSetBase(const LocalPoolDataSetBase& otherSet) = delete;
+    const LocalPoolDataSetBase& operator=(const LocalPoolDataSetBase& otherSet) = delete;
+
+    /**
+     * Helper functions used to set all currently contained variables to read-only.
+     * It is recommended to call this in set constructors intended to be used
+     * by data consumers to prevent accidentally changing pool data.
+     */
+    void setAllVariablesReadOnly();
+    void setValidityBufferGeneration(bool withValidityBuffer);
+
+    sid_t getSid() const;
+
+    /** SerializeIF overrides */
+    ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+            SerializeIF::Endianness streamEndianness) const override;
+    ReturnValue_t deSerialize(const uint8_t** buffer, size_t *size,
+            SerializeIF::Endianness streamEndianness) override;
+    size_t getSerializedSize() const override;
+
+    /**
+     * Special version of the serilization function which appends a
+     * validity buffer at the end. Each bit of this validity buffer
+     * denotes whether the container data set entries are valid from left
+     * to right, MSB first. (length = ceil(N/8), N = number of pool variables)
+     * @param buffer
+     * @param size
+     * @param maxSize
+     * @param bigEndian
+     * @param withValidityBuffer
+     * @return
+     */
+    ReturnValue_t serializeWithValidityBuffer(uint8_t** buffer,
+            size_t* size, size_t maxSize,
+            SerializeIF::Endianness streamEndianness) const;
+    ReturnValue_t deSerializeWithValidityBuffer(const uint8_t** buffer,
+            size_t *size, SerializeIF::Endianness streamEndianness);
+    ReturnValue_t serializeLocalPoolIds(uint8_t** buffer,
+            size_t* size, size_t maxSize,
+            SerializeIF::Endianness streamEndianness,
+            bool serializeFillCount = true) const;
+    uint8_t getLocalPoolIdsSerializedSize(bool serializeFillCount = true) const;
+
+    /**
+     * Set the dataset valid or invalid. These calls are mutex protected.
+     * @param setEntriesRecursively
+     * If this is true, all contained datasets will also be set recursively.
+     */
+    void setValidity(bool valid, bool setEntriesRecursively);
+    bool isValid() const override;
+
+    /**
+     * These calls are mutex protected.
+     * @param changed
+     */
+    void setChanged(bool changed) override;
+    bool hasChanged() const override;
+
+    object_id_t getCreatorObjectId();
+
+    bool getReportingEnabled() const;
+
+    /**
+     * Returns the current periodic HK generation interval this set
+     * belongs to a HK manager and the interval is not 0. Otherwise,
+     * returns 0.0
+     * @return
+     */
+    float getCollectionInterval() const;
+
+protected:
+    sid_t sid;
+    //! This mutex is used if the data is created by one object only.
+    MutexIF* mutexIfSingleDataCreator = nullptr;
+
+    bool diagnostic = false;
+    void setDiagnostic(bool diagnostics);
+    bool isDiagnostics() const;
+
+    /**
+     * Used for periodic generation.
+     */
+    bool reportingEnabled = false;
+    void setReportingEnabled(bool enabled);
+
+    void initializePeriodicHelper(float collectionInterval, dur_millis_t minimumPeriodicInterval,
+            uint8_t nonDiagIntervalFactor = 5);
+
+    /**
+     * If the valid state of a dataset is always relevant to the whole
+     * data set we can use this flag.
+     */
+    bool valid = false;
+
+    /**
+     * Can be used to mark the dataset as changed, which is used
+     * by the LocalDataPoolManager to send out update messages.
+     */
+    bool changed = false;
+
+    /**
+     * Specify whether the validity buffer is serialized too when serializing
+     * or deserializing the packet. Each bit of the validity buffer will
+     * contain the validity state of the pool variables from left to right.
+     * The size of validity buffer thus will be ceil(N / 8) with N = number of
+     * pool variables.
+     */
+    bool withValidityBuffer = true;
+
+    /**
+     * @brief	This is a small helper function to facilitate locking
+     * 			the global data pool.
+     * @details
+     * It makes use of the lockDataPool method offered by the DataPool class.
+     */
+    ReturnValue_t lockDataPool(MutexIF::TimeoutType timeoutType,
+            uint32_t timeoutMs) override;
+
+    /**
+     * @brief	This is a small helper function to facilitate
+     * 			unlocking the global data pool
+     * @details
+     * It makes use of the freeDataPoolLock method offered by the DataPool class.
+     */
+    ReturnValue_t unlockDataPool() override;
+
+    PeriodicHousekeepingHelper* periodicHelper = nullptr;
+    LocalDataPoolManager* poolManager = nullptr;
+
+};
+
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_ */

inc/fsfw/datapoollocal/LocalPoolObjectBase.h

@@ -0,0 +1,71 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_
+
+#include "MarkChangedIF.h"
+#include "localPoolDefinitions.h"
+
+#include "fsfw/objectmanager/SystemObjectIF.h"
+#include "fsfw/datapool/PoolVariableIF.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+
+class LocalDataPoolManager;
+class DataSetIF;
+class HasLocalDataPoolIF;
+
+/**
+ * @brief 	This class serves as a non-template base for pool objects like pool variables
+ * 			or pool vectors.
+ */
+class LocalPoolObjectBase: public PoolVariableIF,
+        public HasReturnvaluesIF,
+        public MarkChangedIF {
+public:
+    LocalPoolObjectBase(lp_id_t poolId, HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
+            pool_rwm_t setReadWriteMode);
+
+    LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId, DataSetIF* dataSet = nullptr,
+            pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+
+    void setReadWriteMode(pool_rwm_t newReadWriteMode);
+    pool_rwm_t getReadWriteMode() const;
+
+    bool isValid() const override;
+    void setValid(bool valid) override;
+
+    void setChanged(bool changed) override;
+    bool hasChanged() const override;
+
+    lp_id_t getDataPoolId() const override;
+    void setDataPoolId(lp_id_t poolId);
+
+protected:
+    /**
+     * @brief   To access the correct data pool entry on read and commit calls,
+     *          the data pool id is stored.
+     */
+    uint32_t localPoolId = PoolVariableIF::NO_PARAMETER;
+    /**
+     * @brief   The valid information as it was stored in the data pool
+     *          is copied to this attribute.
+     */
+    bool valid = false;
+
+    /**
+     * @brief   A local pool variable can be marked as changed.
+     */
+    bool changed = false;
+
+    /**
+     * @brief   The information whether the class is read-write or
+     *          read-only is stored here.
+     */
+    ReadWriteMode_t readWriteMode = pool_rwm_t::VAR_READ_WRITE;
+
+    //! @brief  Pointer to the class which manages the HK pool.
+    LocalDataPoolManager* hkManager = nullptr;
+
+    void reportReadCommitError(const char* variableType,
+            ReturnValue_t error, bool read, object_id_t objectId, lp_id_t lpId);
+};
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_ */

inc/fsfw/datapoollocal/LocalPoolVariable.h

@@ -0,0 +1,203 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
+
+#include "LocalPoolObjectBase.h"
+#include "HasLocalDataPoolIF.h"
+#include "LocalDataPoolManager.h"
+#include "AccessLocalPoolF.h"
+#include "internal/LocalDpManagerAttorney.h"
+
+#include "../datapool/PoolVariableIF.h"
+#include "../datapool/DataSetIF.h"
+#include "../serviceinterface/ServiceInterface.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../serialize/SerializeAdapter.h"
+
+/**
+ * @brief 	Local Pool Variable class which is used to access the local pools.
+ * @details
+ * This class is not stored in the map. Instead, it is used to access
+ * the pool entries by using a pointer to the map storing the pool
+ * entries. It can also be used to organize these pool entries into data sets.
+ *
+ * @tparam T The template parameter sets the type of the variable. Currently,
+ * all plain data types are supported, but in principle  any type is possible.
+ * @ingroup data_pool
+ */
+template<typename T>
+class LocalPoolVariable: public LocalPoolObjectBase {
+public:
+    //! Default ctor is forbidden.
+    LocalPoolVariable() = delete;
+
+    /**
+     * This constructor is used by the data creators to have pool variable
+     * instances which can also be stored in datasets.
+     *
+     * It does not fetch the current value from the data pool, which
+     * has to be done by calling the read() operation.
+     * Datasets can be used to access multiple local pool entries in an
+     * efficient way. A pointer to a dataset can be passed to register
+     * the pool variable in that dataset directly.
+     * @param poolId ID of the local pool entry.
+     * @param hkOwner Pointer of the owner. This will generally be the calling
+     * class itself which passes "this".
+     * @param dataSet The data set in which the variable shall register itself.
+     * If nullptr, the variable is not registered.
+     * @param setReadWriteMode Specify the read-write mode of the pool variable.
+     */
+    LocalPoolVariable(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
+            DataSetIF* dataSet = nullptr,
+            pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+
+    /**
+     * This constructor is used by data users like controllers to have
+     * access to the local pool variables of data creators by supplying
+     * the respective creator object ID.
+     *
+     * It does not fetch the current value from the data pool, which
+     * has to be done by calling the read() operation.
+     * Datasets can be used to access multiple local pool entries in an
+     * efficient way. A pointer to a dataset can be passed to register
+     * the pool variable in that dataset directly.
+     * @param poolId ID of the local pool entry.
+     * @param hkOwner object ID of the pool owner.
+     * @param dataSet The data set in which the variable shall register itself.
+     * If nullptr, the variable is not registered.
+     * @param setReadWriteMode Specify the read-write mode of the pool variable.
+     *
+     */
+    LocalPoolVariable(object_id_t poolOwner, lp_id_t poolId,
+            DataSetIF* dataSet = nullptr,
+            pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+    /**
+     * Variation which takes the global unique identifier of a pool variable.
+     * @param globalPoolId
+     * @param dataSet
+     * @param setReadWriteMode
+     */
+    LocalPoolVariable(gp_id_t globalPoolId, DataSetIF* dataSet = nullptr,
+            pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+
+    virtual~ LocalPoolVariable() {};
+
+    /**
+     * @brief	This is the local copy of the data pool entry.
+     * @details	The user can work on this attribute
+     * 			just like he would on a simple local variable.
+     */
+    T value = 0;
+
+    ReturnValue_t serialize(uint8_t** buffer, size_t* size, 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;
+
+    /**
+     * @brief	This is a call to read the array's values
+     * 			from the global data pool.
+     * @details
+     * When executed, this operation tries to fetch the pool entry with matching
+     * data pool id from the data pool and copies all array values and the valid
+     * information to its local attributes.
+     * In case of a failure (wrong type, size or pool id not found), the
+     * variable is set to zero and invalid.
+     * The read call is protected with a lock.
+     * It is recommended to use DataSets to read and commit multiple variables
+     * at once to avoid the overhead of unnecessary lock und unlock operations.
+     *
+     */
+    ReturnValue_t read(MutexIF::TimeoutType timeoutType =
+            MutexIF::TimeoutType::WAITING,
+            uint32_t timeoutMs = 20) override;
+    /**
+     * @brief	The commit call copies the array values back to the data pool.
+     * @details
+     * It checks type and size, as well as if the variable is writable. If so,
+     * the value is copied and the local valid flag is written back as well.
+     * The read call is protected with a lock.
+     * It is recommended to use DataSets to read and commit multiple variables
+     * at once to avoid the overhead of unnecessary lock und unlock operations.
+     */
+    ReturnValue_t commit(MutexIF::TimeoutType timeoutType =
+            MutexIF::TimeoutType::WAITING,
+            uint32_t timeoutMs = 20) override;
+
+    /**
+     * @brief	This commit function can be used to set the pool variable valid
+     * 			as well.
+     * @param setValid
+     * @param timeoutType
+     * @param timeoutMs
+     * @return
+     */
+    ReturnValue_t commit(bool setValid, MutexIF::TimeoutType timeoutType =
+            MutexIF::TimeoutType::WAITING,
+            uint32_t timeoutMs = 20);
+
+    LocalPoolVariable<T> &operator=(const T& newValue);
+    LocalPoolVariable<T> &operator=(const LocalPoolVariable<T>& newPoolVariable);
+
+    //! Explicit type conversion operator. Allows casting the class to
+    //! its template type to perform operations on value.
+    explicit operator T() const;
+
+    bool operator==(const LocalPoolVariable<T>& other) const;
+    bool operator==(const T& other) const;
+
+    bool operator!=(const LocalPoolVariable<T>& other) const;
+    bool operator!=(const T& other) const;
+
+    bool operator<(const LocalPoolVariable<T>& other) const;
+    bool operator<(const T& other) const;
+
+    bool operator>(const LocalPoolVariable<T>& other) const;
+    bool operator>(const T& other) const;
+
+protected:
+    /**
+     * @brief	Like #read, but without a lock protection of the global pool.
+     * @details
+     * The operation does NOT provide any mutual exclusive protection by itself.
+     * This can be used if the lock is handled externally to avoid the overhead
+     * of consecutive lock und unlock operations.
+     * Declared protected to discourage free public usage.
+     */
+    ReturnValue_t readWithoutLock() override;
+    /**
+     * @brief	Like #commit, but without a lock protection of the global pool.
+     * @details
+     * The operation does NOT provide any mutual exclusive protection by itself.
+     * This can be used if the lock is handled externally to avoid the overhead
+     * of consecutive lock und unlock operations.
+     * Declared protected to discourage free public usage.
+     */
+    ReturnValue_t commitWithoutLock() override;
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    // std::ostream is the type for object std::cout
+    template <typename U>
+    friend std::ostream& operator<< (std::ostream &out,
+            const LocalPoolVariable<U> &var);
+#endif
+};
+
+#include "LocalPoolVariable.tpp"
+
+template<class T>
+using lp_var_t = LocalPoolVariable<T>;
+
+using lp_bool_t = LocalPoolVariable<uint8_t>;
+using lp_uint8_t = LocalPoolVariable<uint8_t>;
+using lp_uint16_t = LocalPoolVariable<uint16_t>;
+using lp_uint32_t = LocalPoolVariable<uint32_t>;
+using lp_uint64_t = LocalPoolVariable<uint64_t>;
+using lp_int8_t = LocalPoolVariable<int8_t>;
+using lp_int16_t = LocalPoolVariable<int16_t>;
+using lp_int32_t = LocalPoolVariable<int32_t>;
+using lp_int64_t = LocalPoolVariable<int64_t>;
+using lp_float_t = LocalPoolVariable<float>;
+using lp_double_t = LocalPoolVariable<double>;
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_ */

inc/fsfw/datapoollocal/LocalPoolVariable.tpp

@@ -0,0 +1,209 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_
+
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
+#error Include LocalPoolVariable.h before LocalPoolVariable.tpp!
+#endif
+
+template<typename T>
+inline LocalPoolVariable<T>::LocalPoolVariable(HasLocalDataPoolIF* hkOwner,
+        lp_id_t poolId, DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
+        LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
+
+template<typename T>
+inline LocalPoolVariable<T>::LocalPoolVariable(object_id_t poolOwner,
+        lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+        LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
+
+
+template<typename T>
+inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId,
+        DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+        LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
+                dataSet, setReadWriteMode){}
+
+
+template<typename T>
+inline ReturnValue_t LocalPoolVariable<T>::read(
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+    if(hkManager == nullptr) {
+        return readWithoutLock();
+    }
+    MutexIF* mutex = LocalDpManagerAttorney::getMutexHandle(*hkManager);
+    ReturnValue_t result = mutex->lockMutex(timeoutType, timeoutMs);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    result = readWithoutLock();
+    mutex->unlockMutex();
+    return result;
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
+    if(readWriteMode == pool_rwm_t::VAR_WRITE) {
+        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVector",
+                PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
+                localPoolId);
+        return PoolVariableIF::INVALID_READ_WRITE_MODE;
+    }
+
+    PoolEntry<T>* poolEntry = nullptr;
+    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+            &poolEntry);
+    if(result != RETURN_OK) {
+        object_id_t ownerObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVariable", result,
+                false, ownerObjectId, localPoolId);
+        return result;
+    }
+
+    this->value = *(poolEntry->getDataPtr());
+    this->valid = poolEntry->getValid();
+    return RETURN_OK;
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVariable<T>::commit(bool setValid,
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+    this->setValid(setValid);
+    return commit(timeoutType, timeoutMs);
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVariable<T>::commit(
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+    if(hkManager == nullptr) {
+        return commitWithoutLock();
+    }
+    MutexIF* mutex = LocalDpManagerAttorney::getMutexHandle(*hkManager);
+    ReturnValue_t result = mutex->lockMutex(timeoutType, timeoutMs);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    result = commitWithoutLock();
+    mutex->unlockMutex();
+    return result;
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
+    if(readWriteMode == pool_rwm_t::VAR_READ) {
+        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVector",
+                PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
+                localPoolId);
+        return PoolVariableIF::INVALID_READ_WRITE_MODE;
+    }
+
+    PoolEntry<T>* poolEntry = nullptr;
+    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+            &poolEntry);
+    if(result != RETURN_OK) {
+        object_id_t ownerObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVariable", result,
+                false, ownerObjectId, localPoolId);
+        return result;
+    }
+
+    *(poolEntry->getDataPtr()) = this->value;
+    poolEntry->setValid(this->valid);
+    return RETURN_OK;
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVariable<T>::serialize(uint8_t** buffer,
+        size_t* size, const size_t max_size,
+        SerializeIF::Endianness streamEndianness) const {
+    return SerializeAdapter::serialize(&value,
+            buffer, size ,max_size, streamEndianness);
+}
+
+template<typename T>
+inline size_t LocalPoolVariable<T>::getSerializedSize() const {
+    return SerializeAdapter::getSerializedSize(&value);
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVariable<T>::deSerialize(const uint8_t** buffer,
+        size_t* size, SerializeIF::Endianness streamEndianness) {
+    return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
+}
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+template<typename T>
+inline std::ostream& operator<< (std::ostream &out,
+        const LocalPoolVariable<T> &var) {
+    out << var.value;
+    return out;
+}
+#endif
+
+template<typename T>
+inline LocalPoolVariable<T>::operator T() const {
+    return value;
+}
+
+template<typename T>
+inline LocalPoolVariable<T> & LocalPoolVariable<T>::operator=(
+        const T& newValue) {
+    value = newValue;
+    return *this;
+}
+
+template<typename T>
+inline LocalPoolVariable<T>& LocalPoolVariable<T>::operator =(
+        const LocalPoolVariable<T>& newPoolVariable) {
+    value = newPoolVariable.value;
+    return *this;
+}
+
+template<typename T>
+inline bool LocalPoolVariable<T>::operator ==(
+        const LocalPoolVariable<T> &other) const {
+    return this->value == other.value;
+}
+
+template<typename T>
+inline bool LocalPoolVariable<T>::operator ==(const T &other) const {
+    return this->value == other;
+}
+
+
+template<typename T>
+inline bool LocalPoolVariable<T>::operator !=(
+        const LocalPoolVariable<T> &other) const {
+    return not (*this == other);
+}
+
+template<typename T>
+inline bool LocalPoolVariable<T>::operator !=(const T &other) const {
+    return not (*this == other);
+}
+
+
+template<typename T>
+inline bool LocalPoolVariable<T>::operator <(
+        const LocalPoolVariable<T> &other) const {
+    return this->value < other.value;
+}
+
+template<typename T>
+inline bool LocalPoolVariable<T>::operator <(const T &other) const {
+    return this->value < other;
+}
+
+
+template<typename T>
+inline bool LocalPoolVariable<T>::operator >(
+        const LocalPoolVariable<T> &other) const {
+    return not (*this < other);
+}
+
+template<typename T>
+inline bool LocalPoolVariable<T>::operator >(const T &other) const {
+    return not (*this < other);
+}
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_ */

inc/fsfw/datapoollocal/LocalPoolVector.h

@@ -0,0 +1,188 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+
+#include "LocalPoolObjectBase.h"
+#include "internal/LocalDpManagerAttorney.h"
+
+#include "../datapool/DataSetIF.h"
+#include "../datapool/PoolEntry.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../datapoollocal/LocalDataPoolManager.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterface.h"
+
+
+/**
+ * @brief	This is the access class for array-type data pool entries.
+ * @details
+ * To ensure safe usage of the data pool, operation is not done directly on the
+ * data pool entries, but on local copies. This class provides simple type-
+ * and length-safe access to vector-style data pool entries (i.e. entries with
+ * length > 1). The class can be instantiated as read-write and read only.
+ *
+ * It provides a commit-and-roll-back semantic, which means that no array
+ * entry in the data pool is changed until the commit call is executed.
+ * There are two template parameters:
+ * @tparam	T
+ * This template parameter specifies the data type of an array entry. Currently,
+ * all plain data types are supported, but in principle any type is possible.
+ * @tparam  vector_size
+ * This template parameter specifies the vector size of this entry. Using a
+ * template parameter for this is not perfect, but avoids
+ * dynamic memory allocation.
+ * @ingroup data_pool
+ */
+template<typename T, uint16_t vectorSize>
+class LocalPoolVector: public LocalPoolObjectBase {
+public:
+    LocalPoolVector() = delete;
+    /**
+     * This constructor is used by the data creators to have pool variable
+     * instances which can also be stored in datasets.
+     * It does not fetch the current value from the data pool. This is performed
+     * by the read() operation (which is not thread-safe).
+     * Datasets can be used to access local pool entires in a thread-safe way.
+     * @param poolId ID of the local pool entry.
+     * @param hkOwner Pointer of the owner. This will generally be the calling
+     * class itself which passes "this".
+     * @param setReadWriteMode Specify the read-write mode of the pool variable.
+     * @param dataSet The data set in which the variable shall register itself.
+     * If nullptr, the variable is not registered.
+     */
+    LocalPoolVector(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
+            DataSetIF* dataSet = nullptr,
+            pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+
+    /**
+     * This constructor is used by data users like controllers to have
+     * access to the local pool variables of data creators by supplying
+     * the respective creator object ID.
+     * It does not fetch the current value from the data pool. This is performed
+     * by the read() operation (which is not thread-safe).
+     * Datasets can be used to access local pool entires in a thread-safe way.
+     * @param poolId ID of the local pool entry.
+     * @param hkOwner Pointer of the owner. This will generally be the calling
+     * class itself which passes "this".
+     * @param setReadWriteMode Specify the read-write mode of the pool variable.
+     * @param dataSet The data set in which the variable shall register itself.
+     * If nullptr, the variable is not registered.
+     */
+    LocalPoolVector(object_id_t poolOwner, lp_id_t poolId,
+            DataSetIF* dataSet = nullptr,
+            pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+    /**
+     * Variation which takes the unique global identifier of a local pool
+     * vector.
+     * @param globalPoolId
+     * @param dataSet
+     * @param setReadWriteMode
+     */
+    LocalPoolVector(gp_id_t globalPoolId, DataSetIF* dataSet = nullptr,
+            pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+
+    /**
+     * @brief	This is the local copy of the data pool entry.
+     * @details
+     * The user can work on this attribute just like he would on a local
+     * array of this type.
+     */
+    T value[vectorSize]= {};
+    /**
+     * @brief	The classes destructor is empty.
+     * @details	If commit() was not called, the local value is
+     * 			discarded and not written back to the data pool.
+     */
+    ~LocalPoolVector() {};
+    /**
+     * @brief	The operation returns the number of array entries
+     * 			in this variable.
+     */
+    uint8_t getSize() {
+        return vectorSize;
+    }
+
+    T& operator [](size_t i);
+    const T &operator [](size_t i) const;
+
+    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+            const size_t maxSize,
+            SerializeIF::Endianness streamEndiannes) const override;
+    virtual size_t getSerializedSize() const override;
+    virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+            SerializeIF::Endianness streamEndianness) override;
+
+    /**
+     * @brief	This is a call to read the array's values
+     * 			from the global data pool.
+     * @details
+     * When executed, this operation tries to fetch the pool entry with matching
+     * data pool id from the data pool and copies all array values and the valid
+     * information to its local attributes.
+     * In case of a failure (wrong type, size or pool id not found), the
+     * variable is set to zero and invalid.
+     * The read call is protected with a lock.
+     * It is recommended to use DataSets to read and commit multiple variables
+     * at once to avoid the overhead of unnecessary lock und unlock operations.
+     */
+    ReturnValue_t read(MutexIF::TimeoutType timeoutType =
+            MutexIF::TimeoutType::WAITING,
+            uint32_t timeoutMs = 20) override;
+
+    /**
+     * @brief	The commit call copies the array values back to the data pool.
+     * @details
+     * It checks type and size, as well as if the variable is writable. If so,
+     * the value is copied and the local valid flag is written back as well.
+     * The read call is protected with a lock.
+     * It is recommended to use DataSets to read and commit multiple variables
+     * at once to avoid the overhead of unnecessary lock und unlock operations.
+     */
+    ReturnValue_t commit(MutexIF::TimeoutType timeoutType =
+            MutexIF::TimeoutType::WAITING,
+            uint32_t timeoutMs = 20) override;
+
+    /**
+     * @brief	This commit call also sets the validity of the pool entry.
+     * @details
+     */
+    ReturnValue_t commit(bool valid, MutexIF::TimeoutType timeoutType =
+            MutexIF::TimeoutType::WAITING,
+            uint32_t timeoutMs = 20);
+
+protected:
+    /**
+     * @brief	Like #read, but without a lock protection of the global pool.
+     * @details
+     * The operation does NOT provide any mutual exclusive protection by itself.
+     * This can be used if the lock is handled externally to avoid the overhead
+     * of consecutive lock und unlock operations.
+     * Declared protected to discourage free public usage.
+     */
+    ReturnValue_t readWithoutLock() override;
+    /**
+     * @brief	Like #commit, but without a lock protection of the global pool.
+     * @details
+     * The operation does NOT provide any mutual exclusive protection by itself.
+     * This can be used if the lock is handled externally to avoid the overhead
+     * of consecutive lock und unlock operations.
+     * Declared protected to discourage free public usage.
+     */
+    ReturnValue_t commitWithoutLock() override;
+
+private:
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    // std::ostream is the type for object std::cout
+    template <typename U, uint16_t otherSize>
+    friend std::ostream& operator<< (std::ostream &out,
+            const LocalPoolVector<U, otherSize> &var);
+#endif
+
+};
+
+#include "LocalPoolVector.tpp"
+
+template<typename T, uint16_t vectorSize>
+using lp_vec_t = LocalPoolVector<T, vectorSize>;
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_ */

inc/fsfw/datapoollocal/LocalPoolVector.tpp

@@ -0,0 +1,179 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_
+
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+#error Include LocalPoolVector.h before LocalPoolVector.tpp!
+#endif
+
+template<typename T, uint16_t vectorSize>
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(
+        HasLocalDataPoolIF* hkOwner, lp_id_t poolId, DataSetIF* dataSet,
+        pool_rwm_t setReadWriteMode):
+        LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
+
+template<typename T, uint16_t vectorSize>
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(object_id_t poolOwner,
+        lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+        LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
+
+template<typename T, uint16_t vectorSize>
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(gp_id_t globalPoolId,
+        DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+        LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
+                dataSet, setReadWriteMode) {}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+    MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
+    return readWithoutLock();
+}
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
+    if(readWriteMode == pool_rwm_t::VAR_WRITE) {
+        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVector",
+                PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
+                localPoolId);
+        return PoolVariableIF::INVALID_READ_WRITE_MODE;
+    }
+
+    PoolEntry<T>* poolEntry = nullptr;
+    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+            &poolEntry);
+    memset(this->value, 0, vectorSize * sizeof(T));
+
+    if(result != RETURN_OK) {
+        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVector", result, true, targetObjectId,
+                localPoolId);
+        return result;
+    }
+    std::memcpy(this->value, poolEntry->getDataPtr(), poolEntry->getByteSize());
+    this->valid = poolEntry->getValid();
+    return RETURN_OK;
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(bool valid,
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+    this->setValid(valid);
+    return commit(timeoutType, timeoutMs);
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+    MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
+    return commitWithoutLock();
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
+    if(readWriteMode == pool_rwm_t::VAR_READ) {
+        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVector",
+                PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
+                localPoolId);
+        return PoolVariableIF::INVALID_READ_WRITE_MODE;
+    }
+    PoolEntry<T>* poolEntry = nullptr;
+    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+            &poolEntry);
+    if(result != RETURN_OK) {
+        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVector", result, false, targetObjectId,
+                localPoolId);
+        return result;
+    }
+    std::memcpy(poolEntry->getDataPtr(), this->value, poolEntry->getByteSize());
+    poolEntry->setValid(this->valid);
+    return RETURN_OK;
+}
+
+template<typename T, uint16_t vectorSize>
+inline T& LocalPoolVector<T, vectorSize>::operator [](size_t i) {
+    if(i < vectorSize) {
+        return value[i];
+    }
+    // If this happens, I have to set some value. I consider this
+    // a configuration error, but I wont exit here.
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
+            " last value!" << std::endl;
+#else
+    sif::printWarning("LocalPoolVector: Invalid index. Setting or returning"
+            " last value!\n");
+#endif
+    return value[vectorSize - 1];
+}
+
+template<typename T, uint16_t vectorSize>
+inline const T& LocalPoolVector<T, vectorSize>::operator [](size_t i) const {
+    if(i < vectorSize) {
+        return value[i];
+    }
+    // If this happens, I have to set some value. I consider this
+    // a configuration error, but I wont exit here.
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
+            " last value!" << std::endl;
+#else
+    sif::printWarning("LocalPoolVector: Invalid index. Setting or returning"
+            " last value!\n");
+#endif
+    return value[vectorSize - 1];
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
+        size_t* size, size_t maxSize,
+        SerializeIF::Endianness streamEndianness) const {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    for (uint16_t i = 0; i < vectorSize; i++) {
+        result = SerializeAdapter::serialize(&(value[i]), buffer, size,
+                maxSize, streamEndianness);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            break;
+        }
+    }
+    return result;
+}
+
+template<typename T, uint16_t vectorSize>
+inline size_t LocalPoolVector<T, vectorSize>::getSerializedSize() const {
+    return vectorSize * SerializeAdapter::getSerializedSize(value);
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::deSerialize(
+        const uint8_t** buffer, size_t* size,
+        SerializeIF::Endianness streamEndianness) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    for (uint16_t i = 0; i < vectorSize; i++) {
+        result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
+                streamEndianness);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            break;
+        }
+    }
+    return result;
+}
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+template<typename T, uint16_t vectorSize>
+inline std::ostream& operator<< (std::ostream &out,
+        const LocalPoolVector<T, vectorSize> &var) {
+    out << "Vector: [";
+    for(int i = 0;i < vectorSize; i++) {
+        out << var.value[i];
+        if(i < vectorSize - 1) {
+            out << ", ";
+        }
+    }
+    out << "]";
+    return out;
+}
+#endif
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_ */

inc/fsfw/datapoollocal/MarkChangedIF.h

@@ -0,0 +1,17 @@
+#ifndef FSFW_DATAPOOLLOCAL_MARKCHANGEDIF_H_
+#define FSFW_DATAPOOLLOCAL_MARKCHANGEDIF_H_
+
+/**
+ * Common interface for local pool entities which can be marked as changed.
+ */
+class MarkChangedIF {
+public:
+    virtual~ MarkChangedIF() {};
+
+    virtual bool hasChanged() const = 0;
+    virtual void setChanged(bool changed) = 0;
+};
+
+
+
+#endif /* FSFW_DATAPOOLLOCAL_MARKCHANGEDIF_H_ */

inc/fsfw/datapoollocal/ProvidesDataPoolSubscriptionIF.h

@@ -0,0 +1,70 @@
+#ifndef FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_
+#define FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_
+
+#include "localPoolDefinitions.h"
+#include "../ipc/messageQueueDefinitions.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+
+class ProvidesDataPoolSubscriptionIF {
+public:
+    virtual ~ProvidesDataPoolSubscriptionIF(){};
+
+    /**
+     * @brief   Subscribe for the generation of periodic packets.
+     * @details
+     * This subscription mechanism will generally be used by the data creator
+     * to generate housekeeping packets which are downlinked directly.
+     * @return
+     */
+    virtual ReturnValue_t subscribeForPeriodicPacket(sid_t sid, bool enableReporting,
+            float collectionInterval, bool isDiagnostics, object_id_t packetDestination) = 0;
+    /**
+     * @brief   Subscribe for the  generation of packets if the dataset
+     *          is marked as changed.
+     * @details
+     * This subscription mechanism will generally be used by the data creator.
+     * @param sid
+     * @param isDiagnostics
+     * @param packetDestination
+     * @return
+     */
+    virtual ReturnValue_t subscribeForUpdatePacket(sid_t sid, bool reportingEnabled,
+            bool isDiagnostics, object_id_t packetDestination) = 0;
+    /**
+     * @brief   Subscribe for a notification message which will be sent
+     *          if a dataset has changed.
+     * @details
+     * This subscription mechanism will generally be used internally by
+     * other software components.
+     * @param setId                 Set ID of the set to receive update messages from.
+     * @param destinationObject     Object ID of the receiver.
+     * @param targetQueueId         Receiver queue ID
+     * @param generateSnapshot      If this is set to true, a copy of the current data with a
+     *                              timestamp will be generated and sent via message.
+     *                              Otherwise, only an notification message is sent.
+     * @return
+     */
+    virtual ReturnValue_t subscribeForSetUpdateMessage(const uint32_t setId,
+            object_id_t destinationObject, MessageQueueId_t targetQueueId,
+            bool generateSnapshot) = 0;
+    /**
+     * @brief   Subscribe for an notification message which will be sent if a
+     *          pool variable has changed.
+     * @details
+     * This subscription mechanism will generally be used internally by
+     * other software components.
+     * @param localPoolId           Pool ID of the pool variable
+     * @param destinationObject     Object ID of the receiver
+     * @param targetQueueId         Receiver queue ID
+     * @param generateSnapshot      If this is set to true, a copy of the current data with a
+     *                              timestamp will be generated and sent via message. Otherwise,
+     *                              only an notification message is sent.
+     * @return
+     */
+    virtual ReturnValue_t subscribeForVariableUpdateMessage(const lp_id_t localPoolId,
+            object_id_t destinationObject, MessageQueueId_t targetQueueId,
+            bool generateSnapshot) = 0;
+};
+
+#endif /* FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_ */

inc/fsfw/datapoollocal/SharedLocalDataSet.h

@@ -0,0 +1,38 @@
+#ifndef FSFW_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_
+#define FSFW_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_
+
+#include "LocalPoolDataSetBase.h"
+#include "../datapool/SharedDataSetIF.h"
+#include "../objectmanager/SystemObject.h"
+#include <vector>
+
+/**
+ * This local dataset variation can be used if the dataset is used concurrently across
+ * multiple threads. It provides a lock in addition to all other functionalities provided
+ * by the LocalPoolDataSetBase class.
+ *
+ * The user is completely responsible for lockingand unlocking the dataset when using the
+ * shared dataset.
+ */
+class SharedLocalDataSet:
+        public SystemObject,
+        public LocalPoolDataSetBase,
+        public SharedDataSetIF {
+public:
+    SharedLocalDataSet(object_id_t objectId, HasLocalDataPoolIF* owner, uint32_t setId,
+            const size_t maxSize);
+    SharedLocalDataSet(object_id_t objectId, sid_t sid, const size_t maxSize);
+
+    virtual~ SharedLocalDataSet();
+
+    ReturnValue_t lockDataset(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+            dur_millis_t mutexTimeout = 20) override;
+    ReturnValue_t unlockDataset() override;
+private:
+
+    MutexIF* datasetLock = nullptr;
+    std::vector<PoolVariableIF*> poolVarVector;
+};
+
+
+#endif /* FSFW_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_ */

inc/fsfw/datapoollocal/StaticLocalDataSet.h

@@ -0,0 +1,52 @@
+#ifndef FSFW_DATAPOOLLOCAL_STATICLOCALDATASET_H_
+#define FSFW_DATAPOOLLOCAL_STATICLOCALDATASET_H_
+
+#include "LocalPoolDataSetBase.h"
+#include "LocalPoolVariable.h"
+#include "LocalPoolVector.h"
+
+#include "../objectmanager/SystemObjectIF.h"
+#include <array>
+
+/**
+ * @brief   This dataset type can be used to group related pool variables if the number of
+ *          variables is fixed.
+ * @details
+ * This will is the primary data structure to organize pool variables into
+ * sets which can be accessed via the housekeeping service interface or
+ * which can be sent to other software objects.
+ *
+ * It is recommended to read the documentation of the LocalPoolDataSetBase
+ * class for more information on how this class works and how to use it.
+ * @tparam capacity Capacity of the static dataset, which is usually known
+ * beforehand.
+ */
+template <uint8_t NUM_VARIABLES>
+class StaticLocalDataSet: public LocalPoolDataSetBase {
+public:
+    /**
+     * Constructor used by data owner and creator like device handlers.
+     * This constructor also initialized the components required for
+     * periodic handling.
+     * @param hkOwner
+     * @param setId
+     */
+    StaticLocalDataSet(HasLocalDataPoolIF* hkOwner, uint32_t setId):
+            LocalPoolDataSetBase(hkOwner, setId, nullptr, NUM_VARIABLES) {
+        this->setContainer(poolVarList.data());
+    }
+
+    /**
+     * Constructor used by data users like controllers.
+     * @param hkOwner
+     * @param setId
+     */
+    StaticLocalDataSet(sid_t sid): LocalPoolDataSetBase(sid, nullptr, NUM_VARIABLES) {
+        this->setContainer(poolVarList.data());
+    }
+
+private:
+    std::array<PoolVariableIF*, NUM_VARIABLES> poolVarList;
+};
+
+#endif /* FSFW_DATAPOOLLOCAL_STATICLOCALDATASET_H_ */

inc/fsfw/datapoollocal/internal/LocalDpManagerAttorney.h

@@ -0,0 +1,31 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCALDPMANAGERATTORNEY_H_
+#define FSFW_DATAPOOLLOCAL_LOCALDPMANAGERATTORNEY_H_
+
+#include "../LocalDataPoolManager.h"
+
+/**
+ * @brief	This is a helper class implements the Attorney-Client idiom for access to
+ * 			LocalDataPoolManager internals
+ * @details
+ * This helper class provides better control over which classes are allowed to access
+ * LocalDataPoolManager internals in a granular and encapsulated way when compared to
+ * other methods like direct friend declarations. It allows these classes to use
+ * an explicit subset of the pool manager private/protected functions.
+ * See: https://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Friendship_and_the_Attorney-Client
+ */
+class LocalDpManagerAttorney {
+private:
+    template<typename T> static ReturnValue_t fetchPoolEntry(LocalDataPoolManager& manager,
+            lp_id_t localPoolId, PoolEntry<T> **poolEntry) {
+        return manager.fetchPoolEntry(localPoolId, poolEntry);
+    }
+
+    static MutexIF* getMutexHandle(LocalDataPoolManager& manager) {
+        return manager.getMutexHandle();
+    }
+
+    template<typename T> friend class LocalPoolVariable;
+    template<typename T, uint16_t vecSize> friend class LocalPoolVector;
+};
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCALDPMANAGERATTORNEY_H_ */

inc/fsfw/datapoollocal/localPoolDefinitions.h

@@ -0,0 +1,108 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDEFINITIONS_H_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLDEFINITIONS_H_
+
+#include "../datapool/PoolEntryIF.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../objectmanager/frameworkObjects.h"
+
+#include <cstdint>
+#include <map>
+
+/**
+ * @brief   Type definition for local pool entries.
+ */
+using lp_id_t = uint32_t;
+
+namespace localpool {
+static constexpr uint32_t INVALID_LPID = -1;
+
+static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
+
+static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x00);
+static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x01);
+
+/** This is the core data structure of the local data pools. Users should insert all desired
+pool variables, using the std::map interface. */
+using DataPool =  std::map<lp_id_t, PoolEntryIF*>;
+using DataPoolMapIter = DataPool::iterator;
+
+}
+
+/**
+ * Used as a unique identifier for data sets. Consists of 4 byte object ID and 4 byte set ID.
+ */
+union sid_t {
+    static constexpr uint64_t INVALID_SID = -1;
+    static constexpr uint32_t INVALID_OBJECT_ID = objects::NO_OBJECT;
+    static constexpr uint32_t INVALID_SET_ID = -1;
+
+
+    sid_t(): raw(INVALID_SID) {}
+
+    sid_t(object_id_t objectId, uint32_t setId):
+        objectId(objectId),
+        ownerSetId(setId) {}
+
+    struct {
+        object_id_t objectId ;
+        /**
+         * A generic 32 bit ID to identify unique HK packets for a single
+         * object. For example, the DeviceCommandId_t is used for
+         * DeviceHandlers
+         */
+        uint32_t ownerSetId;
+    };
+    /**
+     * Alternative access to the raw value. This is also the size of the type.
+     */
+    uint64_t raw;
+
+    bool notSet() const {
+        return raw == INVALID_SID;
+    }
+
+    bool operator==(const sid_t& other) const {
+        return raw == other.raw;
+    }
+
+    bool operator!=(const sid_t& other) const {
+        return not (raw == other.raw);
+    }
+};
+
+/**
+ * Used as a global unique identifier for local pool variables. Consists of 4 byte object ID
+ * and 4 byte local pool ID.
+ */
+union gp_id_t {
+    static constexpr uint64_t INVALID_GPID = -1;
+    static constexpr uint32_t INVALID_OBJECT_ID = objects::NO_OBJECT;
+    static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
+
+    gp_id_t(): raw(INVALID_GPID) {}
+
+    gp_id_t(object_id_t objectId, lp_id_t localPoolId):
+        objectId(objectId),
+        localPoolId(localPoolId) {}
+
+    struct {
+        object_id_t objectId;
+        lp_id_t localPoolId;
+    };
+
+    uint64_t raw;
+
+    bool notSet() const {
+        return raw == INVALID_GPID;
+    }
+
+    bool operator==(const gp_id_t& other) const {
+        return raw == other.raw;
+    }
+
+    bool operator!=(const gp_id_t& other) const {
+        return not (raw == other.raw);
+    }
+};
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLDEFINITIONS_H_ */

inc/fsfw/devicehandlers/AcceptsDeviceResponsesIF.h

@@ -0,0 +1,19 @@
+#ifndef FSFW_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
+#define FSFW_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
+
+#include "../ipc/MessageQueueSenderIF.h"
+
+/**
+ * This interface is used by the device handler to send a device response
+ * to the queue ID, which is returned in the implemented abstract method.
+ */
+class AcceptsDeviceResponsesIF {
+public:
+	/**
+	 * Default empty virtual destructor.
+	 */
+	virtual ~AcceptsDeviceResponsesIF() {}
+	virtual MessageQueueId_t getDeviceQueue() = 0;
+};
+
+#endif /* FSFW_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_ */

inc/fsfw/devicehandlers/AssemblyBase.h

@@ -0,0 +1,180 @@
+#ifndef FSFW_DEVICEHANDLERS_ASSEMBLYBASE_H_
+#define FSFW_DEVICEHANDLERS_ASSEMBLYBASE_H_
+
+#include "DeviceHandlerBase.h"
+#include "../container/FixedArrayList.h"
+#include "../subsystem/SubsystemBase.h"
+
+/**
+ * @brief   Base class to implement reconfiguration and failure handling for
+ *          redundant devices by monitoring their modes health states.
+ * @details
+ * Documentation: Dissertation Baetz p.156, 157.
+ *
+ * This class reduces the complexity of controller components which would
+ * otherwise be needed for the handling of redundant devices.
+ *
+ * The template class monitors mode and health state of its children
+ * and checks availability of devices on every detected change.
+ * AssemblyBase does not implement any redundancy logic by itself, but provides
+ * adaptation points for implementations to do so. Since most monitoring
+ * activities rely on mode and health state only and are therefore
+ * generic, it is sufficient for subclasses to provide:
+ *
+ * 1. check logic when active-> checkChildrenStateOn
+ * 2. transition logic to change the mode -> commandChildren
+ *
+ * Important:
+ *
+ * The implementation must call registerChild(object_id_t child)
+ * for all commanded children during initialization.
+ * The implementation must call the initialization function of the base class.
+ * (This will call the function in SubsystemBase)
+ *
+ */
+class AssemblyBase: public SubsystemBase {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::ASSEMBLY_BASE;
+	static const ReturnValue_t NEED_SECOND_STEP = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t NEED_TO_RECONFIGURE = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t MODE_FALLBACK = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t CHILD_NOT_COMMANDABLE = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t NEED_TO_CHANGE_HEALTH = MAKE_RETURN_CODE(0x05);
+	static const ReturnValue_t NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE =
+			MAKE_RETURN_CODE(0xa1);
+
+	AssemblyBase(object_id_t objectId, object_id_t parentId,
+	        uint16_t commandQueueDepth = 8);
+	virtual ~AssemblyBase();
+
+protected:
+    /**
+     * Command children to reach [mode,submode] combination
+     * Can be done by setting #commandsOutstanding correctly,
+     * or using executeTable()
+     * @param mode
+     * @param submode
+     * @return
+     *    - @c RETURN_OK if ok
+     *    - @c NEED_SECOND_STEP if children need to be commanded again
+     */
+    virtual ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) = 0;
+
+    /**
+     * Check whether desired assembly mode was achieved by checking the modes
+     * or/and health states of child device handlers.
+     * The assembly template class will also call this function if a health
+     * or mode change of a child device handler was detected.
+     * @param wantedMode
+     * @param wantedSubmode
+     * @return
+     */
+    virtual ReturnValue_t checkChildrenStateOn(Mode_t wantedMode,
+            Submode_t wantedSubmode) = 0;
+
+    /**
+     * Check whether a combination of mode and submode is valid.
+     *
+     * Ground Controller like precise return values from HasModesIF.
+     * So, please return any of them.
+     *
+     * @param mode The targeted mode
+     * @param submode The targeted submmode
+     * @return Any information why this combination is invalid from HasModesIF
+     * 			like HasModesIF::INVALID_SUBMODE.
+     * 			On success return HasReturnvaluesIF::RETURN_OK
+     */
+    virtual ReturnValue_t isModeCombinationValid(Mode_t mode,
+            Submode_t submode) = 0;
+
+	enum InternalState {
+		STATE_NONE,
+		STATE_OVERWRITE_HEALTH,
+		STATE_NEED_SECOND_STEP,
+		STATE_SINGLE_STEP,
+		STATE_SECOND_STEP,
+	} internalState;
+
+	enum RecoveryState {
+		RECOVERY_IDLE,
+		RECOVERY_STARTED,
+		RECOVERY_ONGOING,
+		RECOVERY_ONGOING_2,
+		RECOVERY_WAIT
+	} recoveryState; //!< Indicates if one of the children requested a recovery.
+	ChildrenMap::iterator recoveringDevice;
+
+	/**
+	 * the mode the current transition is trying to achieve.
+	 * Can be different from the modehelper.commandedMode!
+	 */
+	Mode_t targetMode;
+
+	/**
+	 * the submode the current transition is trying to achieve.
+	 * Can be different from the modehelper.commandedSubmode!
+	 */
+	Submode_t targetSubmode;
+
+	Countdown recoveryOffTimer;
+
+	static const uint32_t POWER_OFF_TIME_MS = 1000;
+
+	virtual ReturnValue_t handleCommandMessage(CommandMessage *message);
+
+	virtual ReturnValue_t handleHealthReply(CommandMessage *message);
+
+	virtual void performChildOperation();
+
+	bool handleChildrenChanged();
+
+	/**
+	 * This method is called if the children changed its mode in a way that
+	 * the current mode can't be kept.
+	 * Default behavior is to go to MODE_OFF.
+	 * @param result The failure code which was returned by checkChildrenState.
+	 */
+	virtual void handleChildrenLostMode(ReturnValue_t result);
+
+	bool handleChildrenChangedHealth();
+
+	virtual void handleChildrenTransition();
+
+	ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+			uint32_t *msToReachTheMode);
+
+	virtual void startTransition(Mode_t mode, Submode_t submode);
+
+	virtual void doStartTransition(Mode_t mode, Submode_t submode);
+
+	virtual bool isInTransition();
+
+	virtual void handleModeReached();
+
+	virtual void handleModeTransitionFailed(ReturnValue_t result);
+
+	void sendHealthCommand(MessageQueueId_t sendTo, HealthState health);
+
+	virtual ReturnValue_t checkChildrenStateOff();
+
+	ReturnValue_t checkChildrenState();
+
+	virtual ReturnValue_t checkChildOff(uint32_t objectId);
+
+	/**
+	 * Manages recovery of a device
+	 * @return true if recovery is still ongoing, false else.
+	 */
+	bool checkAndHandleRecovery();
+
+	/**
+	 * Helper method to overwrite health state of one of the children.
+	 * Also sets state to STATE_OVERWRITE_HEATH.
+	 * @param objectId Must be a registered child.
+	 */
+	void overwriteDeviceHealth(object_id_t objectId,
+	        HasHealthIF::HealthState oldHealth);
+
+};
+
+#endif /* FSFW_DEVICEHANDLERS_ASSEMBLYBASE_H_ */

inc/fsfw/devicehandlers/CMakeLists.txt

@@ -0,0 +1,11 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		AssemblyBase.cpp
+		ChildHandlerBase.cpp
+		ChildHandlerFDIR.cpp
+		DeviceHandlerBase.cpp
+		DeviceHandlerFailureIsolation.cpp
+		DeviceHandlerMessage.cpp
+		DeviceTmReportingWrapper.cpp
+		HealthDevice.cpp
+)

inc/fsfw/devicehandlers/ChildHandlerBase.h

@@ -0,0 +1,26 @@
+#ifndef FSFW_DEVICEHANDLER_CHILDHANDLERBASE_H_
+#define FSFW_DEVICEHANDLER_CHILDHANDLERBASE_H_
+
+#include "DeviceHandlerBase.h"
+#include "ChildHandlerFDIR.h"
+
+class ChildHandlerBase: public DeviceHandlerBase {
+public:
+	ChildHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
+			CookieIF * cookie, object_id_t hkDestination,
+			uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
+			object_id_t parent = objects::NO_OBJECT,
+			FailureIsolationBase* customFdir = nullptr,
+			size_t cmdQueueSize = 20);
+
+	virtual ~ChildHandlerBase();
+
+	virtual ReturnValue_t initialize();
+
+protected:
+	const uint32_t parentId;
+	ChildHandlerFDIR childHandlerFdir;
+
+};
+
+#endif /* FSFW_DEVICEHANDLER_CHILDHANDLERBASE_H_ */

inc/fsfw/devicehandlers/ChildHandlerFDIR.h

@@ -0,0 +1,20 @@
+#ifndef FSFW_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
+#define FSFW_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
+
+#include "DeviceHandlerFailureIsolation.h"
+
+/**
+ * Very simple extension to normal FDIR.
+ * Does not have a default fault tree parent and
+ * allows to make the recovery count settable to 0.
+ */
+class ChildHandlerFDIR: public DeviceHandlerFailureIsolation {
+public:
+	ChildHandlerFDIR(object_id_t owner, object_id_t faultTreeParent =
+			NO_FAULT_TREE_PARENT, uint32_t recoveryCount = 0);
+	virtual ~ChildHandlerFDIR();
+protected:
+	static const object_id_t NO_FAULT_TREE_PARENT = 0;
+};
+
+#endif /* FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_ */

inc/fsfw/devicehandlers/CookieIF.h

@@ -0,0 +1,34 @@
+#ifndef FSFW_DEVICEHANDLER_COOKIE_H_
+#define FSFW_DEVICEHANDLER_COOKIE_H_
+
+#include <cstdint>
+
+/**
+ * @brief Physical address type
+ */
+using address_t = uint32_t;
+
+/**
+ * @brief 	This datatype is used to identify different connection over a
+ * 			single interface (like RMAP or I2C)
+ * @details
+ * To use this class, implement a communication specific child cookie which
+ * inherits Cookie. Cookie instances are created in config/Factory.cpp by
+ * calling @code{.cpp} CookieIF* childCookie = new ChildCookie(...)
+ * @endcode .
+ *
+ * This cookie is then passed to the child device handlers, which stores the
+ * pointer and passes it to the communication interface functions.
+ *
+ * The cookie can be used to store all kinds of information
+ * about the communication, like slave addresses, communication status,
+ * communication parameters etc.
+ *
+ * @ingroup comm
+ */
+class CookieIF {
+public:
+	virtual ~CookieIF() {};
+};
+
+#endif /* FSFW_DEVICEHANDLER_COOKIE_H_ */

inc/fsfw/devicehandlers/DeviceCommunicationIF.h

@@ -0,0 +1,128 @@
+#ifndef FSFW_DEVICES_DEVICECOMMUNICATIONIF_H_
+#define FSFW_DEVICES_DEVICECOMMUNICATIONIF_H_
+
+#include "CookieIF.h"
+#include "DeviceHandlerIF.h"
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+/**
+ * @defgroup interfaces Interfaces
+ * @brief Interfaces for flight software objects
+ */
+
+/**
+ * @defgroup comm Communication
+ * @brief Communication software components.
+ */
+
+/**
+ * @brief This is an interface to decouple device communication from
+ * the device handler to allow reuse of these components.
+ * @details
+ * Documentation: Dissertation Baetz p.138.
+ * It works with the assumption that received data  is polled by a component.
+ * There are four generic steps of device communication:
+ *
+ *   1. Send data to a device
+ *   2. Get acknowledgement for sending
+ *   3. Request reading data from a device
+ *   4. Read received data
+ *
+ *  To identify different connection over a single interface can return
+ *  so-called cookies to components.
+ *  The CommunicationMessage message type can be used to extend the
+ *  functionality of the ComIF if a separate polling task is required.
+ *  @ingroup interfaces
+ *  @ingroup comm
+ */
+class DeviceCommunicationIF: public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_COMMUNICATION_IF;
+
+	//! This is returned in readReceivedMessage() if no reply was reived.
+	static const ReturnValue_t NO_REPLY_RECEIVED = MAKE_RETURN_CODE(0x01);
+
+	//! General protocol error. Define more concrete errors in child handler
+	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0x02);
+	//! If cookie is a null pointer
+	static const ReturnValue_t NULLPOINTER = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t INVALID_COOKIE_TYPE = MAKE_RETURN_CODE(0x04);
+	// is this needed if there is no open/close call?
+	static const ReturnValue_t NOT_ACTIVE = MAKE_RETURN_CODE(0x05);
+	static const ReturnValue_t TOO_MUCH_DATA = MAKE_RETURN_CODE(0x06);
+
+	virtual ~DeviceCommunicationIF() {}
+
+	/**
+	 * @brief Device specific initialization, using the cookie.
+	 * @details
+	 * The cookie is already prepared in the factory. If the communication
+	 * interface needs to be set up in some way and requires cookie information,
+	 * this can be performed in this function, which is called on device handler
+	 * initialization.
+	 * @param cookie
+	 * @return
+	 *  - @c RETURN_OK if initialization was successfull
+	 *  - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
+
+	/**
+	 * Called by DHB in the SEND_WRITE doSendWrite().
+	 * This function is used to send data to the physical device
+	 * by implementing and calling related drivers or wrapper functions.
+	 * @param cookie
+	 * @param data
+	 * @param len If this is 0, nothing shall be sent.
+	 * @return
+	 *  - @c RETURN_OK for successfull send
+	 *  - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t sendMessage(CookieIF *cookie,
+	        const uint8_t * sendData, size_t sendLen) = 0;
+
+	/**
+	 * Called by DHB in the GET_WRITE doGetWrite().
+	 * Get send confirmation that the data in sendMessage() was sent successfully.
+	 * @param cookie
+	 * @return - @c RETURN_OK if data was sent successfull
+	 * 		   - Everything else triggers falure event with
+	 * 		     returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t getSendSuccess(CookieIF *cookie) = 0;
+
+	/**
+	 * Called by DHB in the SEND_WRITE doSendRead().
+	 * It is assumed that it is always possible to request a reply
+	 * from a device. If a requestLen of 0 is supplied, no reply was enabled
+	 * and communication specific action should be taken (e.g. read nothing
+	 * or read everything).
+	 *
+	 * @param cookie
+	 * @param requestLen Size of data to read
+	 * @return - @c RETURN_OK to confirm the request for data has been sent.
+	 *         - Everything else triggers failure event with
+	 *           returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie,
+	        size_t requestLen) = 0;
+
+	/**
+	 * Called by DHB in the GET_WRITE doGetRead().
+	 * This function is used to receive data from the physical device
+	 * by implementing and calling related drivers or wrapper functions.
+	 * @param cookie
+	 * @param buffer [out] Set reply here (by using *buffer = ...)
+	 * @param size [out] size pointer to set (by using *size = ...).
+	 * 	           Set to 0 if no reply was received
+	 * @return - @c RETURN_OK for successfull receive
+	 * 		   - @c NO_REPLY_RECEIVED if not reply was received. Setting size to
+	 * 		   	   0 has the same effect
+	 *         - Everything else triggers failure event with
+	 *           returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie,
+	        uint8_t **buffer, size_t *size) = 0;
+};
+
+#endif /* FSFW_DEVICES_DEVICECOMMUNICATIONIF_H_ */

inc/fsfw/devicehandlers/DeviceHandlerFailureIsolation.h

@@ -0,0 +1,57 @@
+#ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_
+#define FSFW_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_
+
+#include "../fdir/FaultCounter.h"
+#include "../fdir/FailureIsolationBase.h"
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+class DeviceHandlerFailureIsolation: public FailureIsolationBase {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+	friend class Heater;
+public:
+	DeviceHandlerFailureIsolation(object_id_t owner, object_id_t parent);
+	~DeviceHandlerFailureIsolation();
+	ReturnValue_t initialize();
+	void triggerEvent(Event event, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0);bool isFdirActionInProgress();
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
+			ParameterWrapper *parameterWrapper, const ParameterWrapper *newValues,
+			uint16_t startAtIndex);
+
+protected:
+	FaultCounter strangeReplyCount;
+	FaultCounter missedReplyCount;
+	FaultCounter recoveryCounter;
+
+	enum FDIRState {
+		NONE, RECOVERY_ONGOING, DEVICE_MIGHT_BE_OFF, AWAIT_SHUTDOWN
+	};
+	FDIRState fdirState;
+
+	MessageQueueId_t powerConfirmation = MessageQueueIF::NO_QUEUE;
+	static object_id_t powerConfirmationId;
+
+	static const uint32_t DEFAULT_MAX_REBOOT = 1;
+	static const uint32_t DEFAULT_REBOOT_TIME_MS = 180000;
+	static const uint32_t DEFAULT_MAX_STRANGE_REPLIES = 10;
+	static const uint32_t DEFAULT_STRANGE_REPLIES_TIME_MS = 10000;
+	static const uint32_t DEFAULT_MAX_MISSED_REPLY_COUNT = 5;
+	static const uint32_t DEFAULT_MISSED_REPLY_TIME_MS = 10000;
+
+	virtual ReturnValue_t eventReceived(EventMessage* event);
+	virtual void eventConfirmed(EventMessage* event);
+	void wasParentsFault(EventMessage* event);
+	void decrementFaultCounters();
+	void handleRecovery(Event reason);
+	virtual void clearFaultCounters();
+	void setFdirState(FDIRState state);
+	void startRecovery(Event reason);
+	void setFaulty(Event reason);
+
+	bool isFdirInActionOrAreWeFaulty(EventMessage* event);
+};
+
+#endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_ */

inc/fsfw/devicehandlers/DeviceHandlerIF.h

@@ -0,0 +1,178 @@
+#ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_
+#define FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_
+
+#include "DeviceHandlerMessage.h"
+
+#include "../datapoollocal/localPoolDefinitions.h"
+#include "../action/HasActionsIF.h"
+#include "../events/Event.h"
+#include "../modes/HasModesIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+/**
+ * This is used to uniquely identify commands that are sent to a device
+ * The values are defined in the device-specific implementations
+ */
+using DeviceCommandId_t = uint32_t;
+
+/**
+ * @brief 	This is the Interface used to communicate with a device handler.
+ * @details Includes all expected return values, events and modes.
+ *
+ */
+class DeviceHandlerIF {
+public:
+	static const DeviceCommandId_t RAW_COMMAND_ID = -1;
+	static const DeviceCommandId_t NO_COMMAND_ID = -2;
+
+	static constexpr uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
+	static constexpr uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;
+
+	using dh_heater_request_t = uint8_t;
+	using dh_thermal_state_t = int8_t;
+
+	/**
+	 * @brief This is the mode the <strong>device handler</strong> is in.
+	 *
+	 * @details The mode of the device handler must not be confused with the mode the device is in.
+	 * The mode of the device itself is transparent to the user but related to the mode of the handler.
+	 * MODE_ON and MODE_OFF are included in hasModesIF.h
+	 */
+
+	// MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
+	// MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
+	//! The device is powered on and the device handler periodically sends
+	//! commands. The commands to be sent are selected by the handler
+	//! according to the submode.
+	static const Mode_t MODE_NORMAL = 2;
+	//! The device is powered on and ready to perform operations. In this mode,
+	//! raw commands can be sent. The device handler will send all replies
+	//! received from the command back to the commanding object.
+	static const Mode_t MODE_RAW = 3;
+	//! The device is shut down but the switch could not be turned off, so the
+	//! device still is powered. In this mode, only a mode change to @c MODE_OFF
+	//! can be commanded, which tries to switch off the device again.
+	static const Mode_t MODE_ERROR_ON = 4;
+	//! This is a transitional state which can not be commanded. The device
+	//! handler performs all commands to get the device in a state ready to
+	//! perform commands. When this is completed, the mode changes to @c MODE_ON.
+	static const Mode_t _MODE_START_UP = TRANSITION_MODE_CHILD_ACTION_MASK | 5;
+	//! This is a transitional state which can not be commanded.
+	//! The device handler performs all actions and commands to get the device
+	//! shut down. When the device is off, the mode changes to @c MODE_OFF.
+	//! It is possible to set the mode to _MODE_SHUT_DOWN to use the to off
+	//! transition if available.
+	static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6;
+	//! It is possible to set the mode to _MODE_TO_ON to use the to on
+	//! transition if available.
+	static const Mode_t _MODE_TO_ON = TRANSITION_MODE_CHILD_ACTION_MASK | HasModesIF::MODE_ON;
+	//! It is possible to set the mode to _MODE_TO_RAW to use the to raw
+	//! transition if available.
+	static const Mode_t _MODE_TO_RAW = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_RAW;
+	//! It is possible to set the mode to _MODE_TO_NORMAL to use the to normal
+	//! transition if available.
+	static const Mode_t _MODE_TO_NORMAL = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_NORMAL;
+	//! This is a transitional state which can not be commanded.
+	//! The device is shut down and ready to be switched off.
+	//! After the command to set the switch off has been sent,
+	//! the mode changes to @c MODE_WAIT_OFF
+	static const Mode_t _MODE_POWER_DOWN = TRANSITION_MODE_BASE_ACTION_MASK | 1;
+	//! This is a transitional state which can not be commanded. The device
+	//! will be switched on in this state. After the command to set the switch
+	//! on has been sent, the mode changes to @c MODE_WAIT_ON.
+	static const Mode_t _MODE_POWER_ON = TRANSITION_MODE_BASE_ACTION_MASK | 2;
+	//! This is a transitional state which can not be commanded. The switch has
+	//! been commanded off and the handler waits for it to be off.
+	//! When the switch is off, the mode changes to @c MODE_OFF.
+	static const Mode_t _MODE_WAIT_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 3;
+	//! This is a transitional state which can not be commanded. The switch
+	//! has been commanded on and the handler waits for it to be on.
+	//! When the switch is on, the mode changes to @c MODE_TO_ON.
+	static const Mode_t _MODE_WAIT_ON = TRANSITION_MODE_BASE_ACTION_MASK | 4;
+	//! This is a transitional state which can not be commanded. The switch has
+	//! been commanded off and is off now. This state is only to do an RMAP
+	//! cycle once more where the doSendRead() function will set the mode to
+	//! MODE_OFF. The reason to do this is to get rid of stuck packets in the IO Board.
+	static const Mode_t _MODE_SWITCH_IS_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 5;
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CDH;
+	static const Event DEVICE_BUILDING_COMMAND_FAILED = MAKE_EVENT(0, severity::LOW);
+	static const Event DEVICE_SENDING_COMMAND_FAILED = MAKE_EVENT(1, severity::LOW);
+	static const Event DEVICE_REQUESTING_REPLY_FAILED = MAKE_EVENT(2, severity::LOW);
+	static const Event DEVICE_READING_REPLY_FAILED = MAKE_EVENT(3, severity::LOW);
+	static const Event DEVICE_INTERPRETING_REPLY_FAILED = MAKE_EVENT(4, severity::LOW);
+	static const Event DEVICE_MISSED_REPLY = MAKE_EVENT(5, severity::LOW);
+	static const Event DEVICE_UNKNOWN_REPLY = MAKE_EVENT(6, severity::LOW);
+	static const Event DEVICE_UNREQUESTED_REPLY = MAKE_EVENT(7, severity::LOW);
+	//! [EXPORT] : [COMMENT] Indicates a SW bug in child class.
+	static const Event INVALID_DEVICE_COMMAND = MAKE_EVENT(8, severity::LOW);
+	static const Event MONITORING_LIMIT_EXCEEDED = MAKE_EVENT(9, severity::LOW);
+	static const Event MONITORING_AMBIGUOUS = MAKE_EVENT(10, severity::HIGH);
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
+
+	// Standard codes used when building commands.
+	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0); //!< If no command data was given when expected.
+	static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA1); //!< Command ID not in commandMap. Checked in DHB
+	static const ReturnValue_t COMMAND_ALREADY_SENT = MAKE_RETURN_CODE(0xA2); //!< Command was already executed. Checked in DHB
+	static const ReturnValue_t COMMAND_WAS_NOT_SENT = MAKE_RETURN_CODE(0xA3);
+	static const ReturnValue_t CANT_SWITCH_ADDRESS = MAKE_RETURN_CODE(0xA4);
+	static const ReturnValue_t WRONG_MODE_FOR_COMMAND = MAKE_RETURN_CODE(0xA5);
+	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(0xA6);
+	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(0xA7);
+	static const ReturnValue_t NO_REPLY_EXPECTED = MAKE_RETURN_CODE(0xA8); //!< Used to indicate that this is a command-only command.
+	static const ReturnValue_t NON_OP_TEMPERATURE = MAKE_RETURN_CODE(0xA9);
+	static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xAA);
+
+	// Standard codes used in scanForReply
+	static const ReturnValue_t CHECKSUM_ERROR = MAKE_RETURN_CODE(0xB0);
+	static const ReturnValue_t LENGTH_MISSMATCH = MAKE_RETURN_CODE(0xB1);
+	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(0xB2);
+	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0xB3);
+
+	// Standard codes used in  interpretDeviceReply
+	static const ReturnValue_t DEVICE_DID_NOT_EXECUTE = MAKE_RETURN_CODE(0xC0); //the device reported, that it did not execute the command
+	static const ReturnValue_t DEVICE_REPORTED_ERROR = MAKE_RETURN_CODE(0xC1);
+	static const ReturnValue_t UNKNOWN_DEVICE_REPLY = MAKE_RETURN_CODE(0xC2); //the deviceCommandId reported by scanforReply is unknown
+	static const ReturnValue_t DEVICE_REPLY_INVALID = MAKE_RETURN_CODE(0xC3); //syntax etc is correct but still not ok, eg parameters where none are expected
+
+	// Standard codes used in buildCommandFromCommand
+	static const ReturnValue_t INVALID_COMMAND_PARAMETER = MAKE_RETURN_CODE(0xD0);
+	static const ReturnValue_t INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS = MAKE_RETURN_CODE(0xD1);
+
+	/**
+	 * Communication action that will be executed.
+	 *
+	 * This is used by the child class to tell the base class what to do.
+	 */
+	enum CommunicationAction: uint8_t {
+		PERFORM_OPERATION,
+		SEND_WRITE,//!< Send write
+		GET_WRITE, //!< Get write
+		SEND_READ, //!< Send read
+		GET_READ,  //!< Get read
+		NOTHING    //!< Do nothing.
+	};
+
+	static constexpr uint32_t DEFAULT_THERMAL_SET_ID = sid_t::INVALID_SET_ID - 1;
+
+	static constexpr lp_id_t DEFAULT_THERMAL_STATE_POOL_ID =
+			localpool::INVALID_LPID - 2;
+	static constexpr lp_id_t DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID =
+			localpool::INVALID_LPID - 1;
+
+
+	/**
+	 * Default Destructor
+	 */
+	virtual ~DeviceHandlerIF() {}
+
+	/**
+	 * This MessageQueue is used to command the device handler.
+	 * @return the id of the MessageQueue
+	 */
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+
+};
+
+#endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_ */

inc/fsfw/devicehandlers/DeviceHandlerMessage.h

@@ -0,0 +1,73 @@
+#ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERMESSAGE_H_
+#define FSFW_DEVICEHANDLERS_DEVICEHANDLERMESSAGE_H_
+
+#include "../action/ActionMessage.h"
+#include "../ipc/CommandMessage.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+// SHOULDDO: rework the static constructors to name the type of command
+// they are building, maybe even hide setting the commandID.
+
+
+/**
+ * @brief   The DeviceHandlerMessage is used to send commands to classes
+ *          implementing DeviceHandlerIF
+ */
+class DeviceHandlerMessage {
+public:
+    /**
+     * Instantiation forbidden. Instead, use static functions to operate
+     * on messages.
+     */
+	DeviceHandlerMessage() = delete;
+	virtual ~DeviceHandlerMessage() {}
+
+	/**
+	 * These are the commands that can be sent to a DeviceHandlerBase
+	 */
+	static const uint8_t MESSAGE_ID = messagetypes::DEVICE_HANDLER_COMMAND;
+	//! Sends a raw command, setParameter is a storeId containing the
+	//! raw packet to send
+	static const Command_t CMD_RAW = MAKE_COMMAND_ID(1);
+	//! Requests a IO-Board switch, setParameter() is the IO-Board identifier
+	static const Command_t CMD_SWITCH_ADDRESS = MAKE_COMMAND_ID(3);
+	//! (De)Activates the monitoring of all raw traffic in DeviceHandlers,
+	//! setParameter is 0 to deactivate, 1 to activate
+	static const Command_t CMD_WIRETAPPING = MAKE_COMMAND_ID(4);
+
+	//! Signals that a direct command was sent
+	static const Command_t REPLY_DIRECT_COMMAND_SENT = ActionMessage::STEP_SUCCESS;
+	//! Contains a raw command sent to the Device
+	static const Command_t REPLY_RAW_COMMAND = MAKE_COMMAND_ID(0x11);
+	//! Contains a raw reply from the Device, getParameter() is the ObjcetId
+	//! of the sender, getParameter2() is a ::store_id_t containing the
+	//! raw packet received
+	static const Command_t REPLY_RAW_REPLY = MAKE_COMMAND_ID(0x12);
+	static const Command_t REPLY_DIRECT_COMMAND_DATA = ActionMessage::DATA_REPLY;
+
+	static store_address_t getStoreAddress(const CommandMessage* message);
+	static uint32_t getDeviceCommandId(const CommandMessage* message);
+	static object_id_t getDeviceObjectId(const CommandMessage *message);
+	static object_id_t getIoBoardObjectId(const CommandMessage* message);
+	static uint8_t getWiretappingMode(const CommandMessage* message);
+
+	static void setDeviceHandlerDirectCommandReply(CommandMessage* message,
+			object_id_t deviceObjectid,
+			store_address_t commandParametersStoreId);
+
+	static void setDeviceHandlerRawCommandMessage(CommandMessage* message,
+			store_address_t rawPacketStoreId);
+
+	static void setDeviceHandlerRawReplyMessage(CommandMessage* message,
+			object_id_t deviceObjectid, store_address_t rawPacketStoreId,
+			bool isCommand);
+
+	static void setDeviceHandlerWiretappingMessage(CommandMessage* message,
+			uint8_t wiretappingMode);
+	static void setDeviceHandlerSwitchIoBoardMessage(CommandMessage* message,
+			object_id_t ioBoardIdentifier);
+
+	static void clear(CommandMessage* message);
+};
+
+#endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERMESSAGE_H_ */

inc/fsfw/devicehandlers/DeviceHandlerThermalSet.h

@@ -0,0 +1,44 @@
+#ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERTHERMALSET_H_
+#define FSFW_DEVICEHANDLERS_DEVICEHANDLERTHERMALSET_H_
+
+#include "DeviceHandlerIF.h"
+#include "../datapoollocal/StaticLocalDataSet.h"
+#include "../datapoollocal/LocalPoolVariable.h"
+
+
+class DeviceHandlerThermalSet: public StaticLocalDataSet<2> {
+public:
+
+	DeviceHandlerThermalSet(HasLocalDataPoolIF* hkOwner, uint32_t setId =
+			DeviceHandlerIF::DEFAULT_THERMAL_SET_ID,
+			lp_id_t thermalStateId =
+					DeviceHandlerIF::DEFAULT_THERMAL_STATE_POOL_ID,
+			lp_id_t heaterRequestId =
+					DeviceHandlerIF::DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID):
+			DeviceHandlerThermalSet(hkOwner->getObjectId(), setId,
+					thermalStateId, heaterRequestId) {}
+
+	DeviceHandlerThermalSet(object_id_t deviceHandler, uint32_t setId =
+					DeviceHandlerIF::DEFAULT_THERMAL_SET_ID,
+			lp_id_t thermalStateId =
+					DeviceHandlerIF::DEFAULT_THERMAL_STATE_POOL_ID,
+			lp_id_t thermalStateRequestId =
+					DeviceHandlerIF::DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID):
+			StaticLocalDataSet(sid_t(deviceHandler, setId)),
+			thermalStatePoolId(thermalStateId),
+			heaterRequestPoolId(thermalStateRequestId) {}
+
+	const lp_id_t thermalStatePoolId;
+	const lp_id_t heaterRequestPoolId;
+
+	lp_var_t<DeviceHandlerIF::dh_thermal_state_t> thermalState =
+			lp_var_t<DeviceHandlerIF::dh_thermal_state_t>(
+			thermalStatePoolId, sid.objectId, this);
+	lp_var_t<DeviceHandlerIF::dh_heater_request_t> heaterRequest =
+			lp_var_t<DeviceHandlerIF::dh_heater_request_t>(
+			heaterRequestPoolId, sid.objectId, this);
+};
+
+
+
+#endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERTHERMALSET_H_ */

inc/fsfw/devicehandlers/DeviceTmReportingWrapper.h

@@ -0,0 +1,27 @@
+#ifndef FSFW_DEVICEHANDLERS_DEVICETMREPORTINGWRAPPER_H_
+#define FSFW_DEVICEHANDLERS_DEVICETMREPORTINGWRAPPER_H_
+
+#include "../action/HasActionsIF.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../serialize/SerializeIF.h"
+
+class DeviceTmReportingWrapper: public SerializeIF {
+public:
+	DeviceTmReportingWrapper(object_id_t objectId, ActionId_t actionId,
+			SerializeIF *data);
+	virtual ~DeviceTmReportingWrapper();
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
+
+	virtual size_t getSerializedSize() const override;
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
+private:
+	object_id_t objectId;
+	ActionId_t actionId;
+	SerializeIF *data;
+};
+
+#endif /* FSFW_DEVICEHANDLERS_DEVICETMREPORTINGWRAPPER_H_ */

inc/fsfw/devicehandlers/HealthDevice.h

@@ -0,0 +1,40 @@
+#ifndef FSFW_DEVICEHANDLERS_HEALTHDEVICE_H_
+#define FSFW_DEVICEHANDLERS_HEALTHDEVICE_H_
+
+#include "fsfw/health/HasHealthIF.h"
+#include "fsfw/health/HealthHelper.h"
+#include "fsfw/objectmanager/SystemObject.h"
+#include "fsfw/tasks/ExecutableObjectIF.h"
+#include "fsfw/ipc/MessageQueueIF.h"
+
+class HealthDevice: public SystemObject,
+		public ExecutableObjectIF,
+		public HasHealthIF {
+public:
+	HealthDevice(object_id_t setObjectId, MessageQueueId_t parentQueue);
+	virtual ~HealthDevice();
+
+	ReturnValue_t performOperation(uint8_t opCode);
+
+	ReturnValue_t initialize();
+
+	virtual MessageQueueId_t getCommandQueue() const;
+
+	void setParentQueue(MessageQueueId_t parentQueue);
+
+	bool hasHealthChanged();
+
+	virtual ReturnValue_t setHealth(HealthState health);
+
+	virtual HealthState getHealth();
+
+protected:
+	HealthState lastHealth;
+
+	MessageQueueId_t parentQueue;
+	MessageQueueIF* commandQueue;
+public:
+	HealthHelper healthHelper;
+};
+
+#endif /* FSFW_DEVICEHANDLERS_HEALTHDEVICE_H_ */

inc/fsfw/events/Event.h

@@ -0,0 +1,40 @@
+#ifndef EVENTOBJECT_EVENT_H_
+#define EVENTOBJECT_EVENT_H_
+
+#include <stdint.h>
+#include "fwSubsystemIdRanges.h"
+// could be moved to more suitable location
+#include <events/subsystemIdRanges.h>
+
+typedef uint16_t EventId_t;
+typedef uint8_t EventSeverity_t;
+
+#define MAKE_EVENT(id, severity) (((severity)<<16)+(SUBSYSTEM_ID*100)+(id))
+
+typedef uint32_t Event;
+
+namespace event {
+
+constexpr EventId_t getEventId(Event event) {
+	return (event & 0xFFFF);
+}
+
+constexpr EventSeverity_t getSeverity(Event event) {
+	return ((event >> 16) & 0xFF);
+}
+
+constexpr Event makeEvent(uint8_t subsystemId, uint8_t uniqueEventId,
+		EventSeverity_t eventSeverity) {
+	return (eventSeverity << 16) + (subsystemId * 100) + uniqueEventId;
+}
+
+}
+
+namespace severity {
+	static constexpr EventSeverity_t INFO = 1;
+	static constexpr EventSeverity_t LOW = 2;
+	static constexpr EventSeverity_t MEDIUM = 3;
+	static constexpr EventSeverity_t HIGH = 4;
+}
+
+#endif /* EVENTOBJECT_EVENT_H_ */

inc/fsfw/events/EventManager.h

@@ -0,0 +1,78 @@
+#ifndef FSFW_EVENT_EVENTMANAGER_H_
+#define FSFW_EVENT_EVENTMANAGER_H_
+
+#include "EventManagerIF.h"
+#include "eventmatching/EventMatchTree.h"
+#include "FSFWConfig.h"
+
+#include "../serviceinterface/ServiceInterface.h"
+#include "../objectmanager/SystemObject.h"
+#include "../storagemanager/LocalPool.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../ipc/MessageQueueIF.h"
+#include "../ipc/MutexIF.h"
+
+#include <map>
+
+#if FSFW_OBJ_EVENT_TRANSLATION == 1
+// forward declaration, should be implemented by mission
+extern const char* translateObject(object_id_t object);
+extern const char* translateEvents(Event event);
+#endif
+
+class EventManager: public EventManagerIF,
+		public ExecutableObjectIF,
+		public SystemObject {
+public:
+	static const uint16_t MAX_EVENTS_PER_CYCLE = 80;
+
+	EventManager(object_id_t setObjectId);
+	virtual ~EventManager();
+
+	void setMutexTimeout(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs);
+
+	MessageQueueId_t getEventReportQueue();
+
+	ReturnValue_t registerListener(MessageQueueId_t listener, bool forwardAllButSelected = false);
+	ReturnValue_t subscribeToEvent(MessageQueueId_t listener, EventId_t event);
+	ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener,
+			object_id_t object);
+	ReturnValue_t subscribeToEventRange(MessageQueueId_t listener,
+			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false);
+	ReturnValue_t unsubscribeFromEventRange(MessageQueueId_t listener,
+			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false);
+	ReturnValue_t performOperation(uint8_t opCode);
+protected:
+
+	MessageQueueIF* eventReportQueue = nullptr;
+
+	std::map<MessageQueueId_t, EventMatchTree> listenerList;
+
+	MutexIF* mutex = nullptr;
+	MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+	uint32_t timeoutMs = 20;
+
+	static const uint8_t N_POOLS = 3;
+	LocalPool factoryBackend;
+	static const LocalPool::LocalPoolConfig poolConfig;
+
+	static const uint16_t POOL_SIZES[N_POOLS];
+	static const uint16_t N_ELEMENTS[N_POOLS];
+
+	void notifyListeners(EventMessage *message);
+
+#if FSFW_OBJ_EVENT_TRANSLATION == 1
+	void printEvent(EventMessage *message);
+	void printUtility(sif::OutputTypes printType, EventMessage* message);
+#endif
+
+	void lockMutex();
+
+	void unlockMutex();
+};
+
+#endif /* FSFW_EVENT_EVENTMANAGER_H_ */

inc/fsfw/events/EventManagerIF.h

@@ -0,0 +1,71 @@
+#ifndef FSFW_EVENTS_EVENTMANAGERIF_H_
+#define FSFW_EVENTS_EVENTMANAGERIF_H_
+
+#include "EventMessage.h"
+#include "eventmatching/eventmatching.h"
+#include "../objectmanager/ObjectManager.h"
+#include "../ipc/MessageQueueSenderIF.h"
+#include "../ipc/MessageQueueIF.h"
+#include "../serviceinterface/ServiceInterface.h"
+
+class EventManagerIF {
+public:
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::EVENT_MANAGER_IF;
+	static const ReturnValue_t LISTENER_NOT_FOUND = MAKE_RETURN_CODE(1);
+	virtual ~EventManagerIF() {
+	}
+
+	virtual MessageQueueId_t getEventReportQueue() = 0;
+
+	virtual ReturnValue_t registerListener(MessageQueueId_t listener,
+	        bool forwardAllButSelected = false) = 0;
+	virtual ReturnValue_t subscribeToEvent(MessageQueueId_t listener,
+			EventId_t event) = 0;
+	virtual ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener,
+			object_id_t object) = 0;
+	virtual ReturnValue_t subscribeToEventRange(MessageQueueId_t listener,
+			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false) = 0;
+	virtual ReturnValue_t unsubscribeFromEventRange(MessageQueueId_t listener,
+			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false) = 0;
+
+	static void triggerEvent(object_id_t reportingObject, Event event,
+			uint32_t parameter1 = 0, uint32_t parameter2 = 0,
+			MessageQueueId_t sentFrom = 0) {
+		EventMessage message(event, reportingObject, parameter1, parameter2);
+		triggerEvent(&message, sentFrom);
+	}
+
+	static void triggerEvent(EventMessage* message,
+	        MessageQueueId_t sentFrom = 0) {
+		if (eventmanagerQueue == MessageQueueIF::NO_QUEUE) {
+			EventManagerIF *eventmanager = ObjectManager::instance()->get<EventManagerIF>(
+					objects::EVENT_MANAGER);
+			if (eventmanager == nullptr) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+			    sif::warning << "EventManagerIF::triggerEvent: EventManager invalid or not found!"
+			            << std::endl;
+#else
+			    sif::printWarning("EventManagerIF::triggerEvent: "
+			            "EventManager invalid or not found!");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+			    return;
+			}
+			eventmanagerQueue = eventmanager->getEventReportQueue();
+		}
+		MessageQueueSenderIF::sendMessage(eventmanagerQueue, message, sentFrom);
+	}
+
+private:
+	//! Initialized by EventManager (C++11 does not allow header-only static member initialization).
+    static MessageQueueId_t eventmanagerQueue;
+
+};
+
+#endif /* FSFW_EVENTS_EVENTMANAGERIF_H_ */

inc/fsfw/events/EventMessage.h

@@ -0,0 +1,52 @@
+#ifndef FSFW_EVENTS_EVENTMESSAGE_H_
+#define FSFW_EVENTS_EVENTMESSAGE_H_
+
+#include "Event.h"
+#include "fsfw/ipc/MessageQueueMessage.h"
+#include "fsfw/objectmanager/ObjectManagerIF.h"
+
+/**
+ * Passing on events through IPC.
+ * Event Id, severity and message type retrieval is a bit difficult.
+ */
+class EventMessage: public MessageQueueMessage {
+public:
+	static const uint8_t EVENT_MESSAGE = 0; //!< Normal event
+	static const uint8_t CONFIRMATION_REQUEST = 1; //!< Request to parent if event is caused by child or not.
+	static const uint8_t YOUR_FAULT = 2; //!< The fault was caused by child, parent believes it's ok.
+	static const uint8_t MY_FAULT = 3; //!< The fault was caused by the parent, child is ok.
+	//Add other messageIDs here if necessary.
+	static const uint8_t EVENT_MESSAGE_SIZE = HEADER_SIZE + sizeof(Event)
+			+ 3 * sizeof(uint32_t);
+
+	EventMessage();
+//	EventMessage(EventId_t event, EventSeverity_t severity,
+//			object_id_t reporter, uint32_t parameter1, uint32_t parameter2 = 0);
+	EventMessage(Event event, object_id_t reporter, uint32_t parameter1,
+			uint32_t parameter2 = 0);
+	virtual ~EventMessage();
+	Event getEvent();
+	void setEvent(Event event);
+	uint8_t getMessageId();
+	void setMessageId(uint8_t id);
+	EventSeverity_t getSeverity();
+	void setSeverity(EventSeverity_t severity);
+	EventId_t getEventId();
+	void setEventId(EventId_t event);
+	object_id_t getReporter();
+	void setReporter(object_id_t reporter);
+	uint32_t getParameter1();
+	void setParameter1(uint32_t parameter);
+	uint32_t getParameter2();
+	void setParameter2(uint32_t parameter);
+
+	void clearEventMessage();
+	bool isClearedEventMessage();
+
+protected:
+	static const Event INVALID_EVENT = 0;
+	virtual size_t getMinimumMessageSize() const override;
+
+};
+
+#endif /* FSFW_EVENTS_EVENTMESSAGE_H_ */

inc/fsfw/events/EventReportingProxyIF.h

@@ -0,0 +1,19 @@
+#ifndef FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_
+#define FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_
+
+#include "Event.h"
+
+
+class EventReportingProxyIF {
+public:
+	virtual ~EventReportingProxyIF() {
+	}
+
+	virtual void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const = 0;
+
+};
+
+
+
+
+#endif /* FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_ */

inc/fsfw/events/eventmatching/EventIdRangeMatcher.h

@@ -0,0 +1,13 @@
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_
+
+#include "EventRangeMatcherBase.h"
+
+class EventIdRangeMatcher: public EventRangeMatcherBase<EventId_t> {
+public:
+	EventIdRangeMatcher(EventId_t lower, EventId_t upper, bool inverted);
+	~EventIdRangeMatcher();
+	bool match(EventMessage* message);
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_ */

inc/fsfw/events/eventmatching/EventMatchTree.h

@@ -0,0 +1,36 @@
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_
+
+#include "../../container/PlacementFactory.h"
+#include "../../events/EventMessage.h"
+#include "../../globalfunctions/matching/MatchTree.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+class StorageManagerIF;
+
+class EventMatchTree: public MatchTree<EventMessage*>, public HasReturnvaluesIF {
+public:
+	EventMatchTree(StorageManagerIF* storageBackend, bool invertedMatch);
+	virtual ~EventMatchTree();
+	ReturnValue_t addMatch(EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false);
+	ReturnValue_t removeMatch(EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false);
+	bool match(EventMessage* number);
+protected:
+	ReturnValue_t cleanUpElement(iterator position);
+private:
+	PlacementFactory factory;
+	bool invertedMatch;
+	template<typename VALUE_T, typename INSERTION_T>
+	ReturnValue_t findOrInsertRangeMatcher(iterator start, VALUE_T idFrom,
+			VALUE_T idTo, bool inverted, iterator* lastTest);
+
+	template<typename VALUE_T, typename INSERTION_T>
+	iterator findRangeMatcher(iterator start, VALUE_T idFrom, VALUE_T idTo,
+			bool inverted);
+
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_ */

inc/fsfw/events/eventmatching/EventRangeMatcherBase.h

@@ -0,0 +1,29 @@
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_
+
+#include "../../events/EventMessage.h"
+#include "../../globalfunctions/matching/RangeMatcher.h"
+#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+
+template <typename T>
+class EventRangeMatcherBase: public SerializeableMatcherIF<EventMessage*> {
+	friend class EventMatchTree;
+public:
+	EventRangeMatcherBase(T from, T till, bool inverted) : rangeMatcher(from, till, inverted) {	}
+	virtual ~EventRangeMatcherBase() { }
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return rangeMatcher.serialize(buffer, size, maxSize, streamEndianness);
+	}
+	size_t getSerializedSize() const {
+		return rangeMatcher.getSerializedSize();
+	}
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return rangeMatcher.deSerialize(buffer, size, streamEndianness);
+	}
+protected:
+	RangeMatcher<T> rangeMatcher;
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_ */

inc/fsfw/events/eventmatching/ReporterRangeMatcher.h

@@ -0,0 +1,13 @@
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_
+
+#include "EventRangeMatcherBase.h"
+
+class ReporterRangeMatcher: public EventRangeMatcherBase<object_id_t> {
+public:
+	ReporterRangeMatcher(object_id_t lower, object_id_t upper, bool inverted);
+	~ReporterRangeMatcher();
+	bool match(EventMessage* message);
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_ */

inc/fsfw/events/eventmatching/SeverityRangeMatcher.h

@@ -0,0 +1,13 @@
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_
+
+#include "EventRangeMatcherBase.h"
+
+class SeverityRangeMatcher: public EventRangeMatcherBase<EventSeverity_t> {
+public:
+	SeverityRangeMatcher(EventSeverity_t from, EventSeverity_t till, bool inverted);
+	~SeverityRangeMatcher();
+	bool match(EventMessage* message);
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_ */