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

src/CMakeLists.txt

@@ -1,3 +1,20 @@
-add_subdirectory(core)
-add_subdirectory(opt)
-add_subdirectory(osal)
+target_include_directories(${LIB_FSFW_NAME} PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+target_include_directories(${LIB_FSFW_NAME} INTERFACE
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+add_subdirectory(fsfw)
+
+# Configure File
+
+target_include_directories(${LIB_FSFW_NAME} PRIVATE
+    ${CMAKE_CURRENT_BINARY_DIR}
+)
+target_include_directories(${LIB_FSFW_NAME} INTERFACE
+    ${CMAKE_CURRENT_BINARY_DIR}
+)
+
+configure_file(fsfw/FSFW.h.in fsfw/FSFW.h)

src/core/devicehandlers/CMakeLists.txt

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

src/core/housekeeping/CMakeLists.txt

@@ -1,4 +0,0 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE 
-    HousekeepingMessage.cpp
-    PeriodicHousekeepingHelper.cpp
-)

src/fsfw/CMakeLists.txt

@@ -1,3 +1,5 @@
+# Core
+
 add_subdirectory(action)
 add_subdirectory(container)
 add_subdirectory(controller)
@@ -26,3 +28,28 @@ add_subdirectory(thermal)
 add_subdirectory(timemanager)
 add_subdirectory(tmtcpacket)
 add_subdirectory(tmtcservices)
+
+# Optional
+
+if(FSFW_ADD_MONITORING)
+add_subdirectory(monitoring)
+endif()
+if(FSFW_ADD_PUS)
+    add_subdirectory(pus)
+endif()
+if(FSFW_ADD_TMSTORAGE)
+    add_subdirectory(tmstorage)
+endif()
+if(FSFW_ADD_COORDINATES)
+    add_subdirectory(coordinates)
+endif()
+if(FSFW_ADD_RMAP)
+    add_subdirectory(rmap)
+endif()
+if(FSFW_ADD_DATALINKLAYER)
+    add_subdirectory(datalinklayer)
+endif()
+
+# OSAL
+
+add_subdirectory(osal)

src/fsfw/FSFW.h.in

@@ -0,0 +1,13 @@
+#ifndef FSFW_FSFW_H_
+#define FSFW_FSFW_H_
+
+#include "FSFWConfig.h"
+
+#cmakedefine FSFW_ADD_RMAP
+#cmakedefine FSFW_ADD_DATALINKLAYER
+#cmakedefine FSFW_ADD_TMSTORAGE
+#cmakedefine FSFW_ADD_COORDINATES
+#cmakedefine FSFW_ADD_PUS
+#cmakedefine FSFW_ADD_MONITORING
+
+#endif /* FSFW_FSFW_H_ */

src/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_ */

src/fsfw/action.h

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

src/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_ */

src/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_ */

src/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_ */

src/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_ */

src/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_ */

src/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_ */

src/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_ */

src/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_ */

src/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_ */

src/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_ */

src/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_ */

src/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

src/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_ */

src/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_ */

src/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_ */

src/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_ */

src/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_ */

src/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_ */

src/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_ */

src/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_ */

src/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_ */

src/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_ */
+

src/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_ */

src/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_ */

src/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_ */

src/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_ */

src/fsfw/coordinates/CoordinateTransformations.h

@@ -0,0 +1,35 @@
+#ifndef COORDINATETRANSFORMATIONS_H_
+#define COORDINATETRANSFORMATIONS_H_
+
+#include "coordinatesConf.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_ */

src/fsfw/coordinates/Jgm3Model.h

@@ -0,0 +1,181 @@
+#ifndef FRAMEWORK_COORDINATES_JGM3MODEL_H_
+#define FRAMEWORK_COORDINATES_JGM3MODEL_H_
+
+#include "coordinatesConf.h"
+#include "CoordinateTransformations.h"
+
+#include "fsfw/globalfunctions/math/VectorOperations.h"
+#include "fsfw/globalfunctions/timevalOperations.h"
+#include "fsfw/globalfunctions/constants.h"
+#include <memory.h>
+#include <cstdint>
+
+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_ */

src/fsfw/coordinates/Sgp4Propagator.h

@@ -0,0 +1,49 @@
+#ifndef SGP4PROPAGATOR_H_
+#define SGP4PROPAGATOR_H_
+
+#include "coordinatesConf.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_ */

src/fsfw/coordinates/coordinatesConf.h

@@ -0,0 +1,11 @@
+#ifndef FSFW_SRC_FSFW_COORDINATES_COORDINATESCONF_H_
+#define FSFW_SRC_FSFW_COORDINATES_COORDINATESCONF_H_
+
+#include "fsfw/FSFW.h"
+
+#ifndef FSFW_ADD_COORDINATES
+#warning Coordinates files were included but compilation was \
+    not enabled with FSFW_ADD_COORDINATES
+#endif
+
+#endif /* FSFW_SRC_FSFW_COORDINATES_COORDINATESCONF_H_ */

src/fsfw/datalinklayer/BCFrame.h

@@ -0,0 +1,63 @@
+/**
+ * @file	BCFrame.h
+ * @brief	This file defines the BCFrame class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef BCFRAME_H_
+#define BCFRAME_H_
+
+#include "dllConf.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_ */

src/fsfw/datalinklayer/CCSDSReturnValuesIF.h

@@ -0,0 +1,57 @@
+/**
+ * @file	CCSDSReturnValuesIF.h
+ * @brief	This file defines the CCSDSReturnValuesIF class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef CCSDSRETURNVALUESIF_H_
+#define CCSDSRETURNVALUESIF_H_
+
+#include "dllConf.h"
+#include "fsfw/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_ */

src/fsfw/datalinklayer/Clcw.h

@@ -0,0 +1,61 @@
+#ifndef CLCW_H_
+#define CLCW_H_
+
+#include "dllConf.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_ */

src/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_ */

src/fsfw/datalinklayer/DataLinkLayer.h

@@ -0,0 +1,120 @@
+#ifndef DATALINKLAYER_H_
+#define DATALINKLAYER_H_
+
+#include "dllConf.h"
+#include "CCSDSReturnValuesIF.h"
+#include "ClcwIF.h"
+#include "TcTransferFrame.h"
+#include "VirtualChannelReceptionIF.h"
+#include "fsfw/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_ */

src/fsfw/datalinklayer/Farm1StateIF.h

@@ -0,0 +1,56 @@
+/**
+ * @file	Farm1StateIF.h
+ * @brief	This file defines the Farm1StateIF class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef FARM1STATEIF_H_
+#define FARM1STATEIF_H_
+
+#include "dllConf.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_ */

src/fsfw/datalinklayer/Farm1StateLockout.h

@@ -0,0 +1,53 @@
+#ifndef FARM1STATELOCKOUT_H_
+#define FARM1STATELOCKOUT_H_
+
+#include "dllConf.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_ */

src/fsfw/datalinklayer/Farm1StateOpen.h

@@ -0,0 +1,63 @@
+/**
+ * @file	Farm1StateOpen.h
+ * @brief	This file defines the Farm1StateOpen class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef FARM1STATEOPEN_H_
+#define FARM1STATEOPEN_H_
+
+#include "dllConf.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_ */

src/fsfw/datalinklayer/Farm1StateWait.h

@@ -0,0 +1,59 @@
+/**
+ * @file	Farm1StateWait.h
+ * @brief	This file defines the Farm1StateWait class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef FARM1STATEWAIT_H_
+#define FARM1STATEWAIT_H_
+
+#include "dllConf.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_ */

src/fsfw/datalinklayer/MapPacketExtraction.h

@@ -0,0 +1,74 @@
+#ifndef FSFW_DATALINKLAYER_MAPPACKETEXTRACTION_H_
+#define FSFW_DATALINKLAYER_MAPPACKETEXTRACTION_H_
+
+#include "dllConf.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_ */

src/fsfw/datalinklayer/MapPacketExtractionIF.h

@@ -0,0 +1,48 @@
+/**
+ * @file	MapPacketExtractionIF.h
+ * @brief	This file defines the MapPacketExtractionIF class.
+ * @date	25.03.2013
+ * @author	baetz
+ */
+
+#ifndef MAPPACKETEXTRACTIONIF_H_
+#define MAPPACKETEXTRACTIONIF_H_
+
+#include "dllConf.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_ */

src/fsfw/datalinklayer/TcTransferFrame.h

@@ -0,0 +1,139 @@
+#ifndef TCTRANSFERFRAME_H_
+#define TCTRANSFERFRAME_H_
+
+#include "dllConf.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_ */

src/fsfw/datalinklayer/TcTransferFrameLocal.h

@@ -0,0 +1,50 @@
+/**
+ * @file	TcTransferFrameLocal.h
+ * @brief	This file defines the TcTransferFrameLocal class.
+ * @date	27.04.2013
+ * @author	baetz
+ */
+
+#ifndef TCTRANSFERFRAMELOCAL_H_
+#define TCTRANSFERFRAMELOCAL_H_
+
+#include "dllConf.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_ */

src/fsfw/datalinklayer/VirtualChannelReception.h

@@ -0,0 +1,116 @@
+/**
+ * @file	VirtualChannelReception.h
+ * @brief	This file defines the VirtualChannelReception class.
+ * @date	25.03.2013
+ * @author	baetz
+ */
+
+#ifndef VIRTUALCHANNELRECEPTION_H_
+#define VIRTUALCHANNELRECEPTION_H_
+
+#include "dllConf.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_ */

src/fsfw/datalinklayer/VirtualChannelReceptionIF.h

@@ -0,0 +1,58 @@
+/**
+ * @file	VirtualChannelReceptionIF.h
+ * @brief	This file defines the VirtualChannelReceptionIF class.
+ * @date	25.03.2013
+ * @author	baetz
+ */
+
+#ifndef VIRTUALCHANNELRECEPTIONIF_H_
+#define VIRTUALCHANNELRECEPTIONIF_H_
+
+#include "dllConf.h"
+#include "ClcwIF.h"
+#include "TcTransferFrame.h"
+#include "fsfw/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_ */

src/fsfw/datalinklayer/dllConf.h

@@ -0,0 +1,11 @@
+#ifndef FSFW_SRC_FSFW_DATALINKLAYER_DLLCONF_H_
+#define FSFW_SRC_FSFW_DATALINKLAYER_DLLCONF_H_
+
+#include "fsfw/FSFW.h"
+
+#ifndef FSFW_ADD_DATALINKLAYER
+#warning Datalinklayer files were included but compilation was \
+    not enabled with FSFW_ADD_DATALINKLAYER
+#endif
+
+#endif /* FSFW_SRC_FSFW_DATALINKLAYER_DLLCONF_H_ */

src/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_ */

src/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_ */

src/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_ */

src/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_ */

src/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_ */

src/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_ */

src/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_ */

src/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_ */

src/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_ */

src/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_ */

src/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_ */

src/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_ */

src/fsfw/datapoollocal.h

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

src/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_ */

src/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_ */

src/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_ */