action/ActionMessage.h

@@ -10,7 +10,7 @@ class ActionMessage {
 private:
 	ActionMessage();
 public:
-	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::ACTION;
+	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);

container/ArrayList.h

@@ -72,11 +72,15 @@ public:
 			return tmp;
 		}
 
-		T operator*() {
+		T& operator*(){
 			return *value;
 		}
 
-		T *operator->() {
+		const T& operator*() const{
+			return *value;
+		}
+
+		T *operator->(){
 			return value;
 		}
 

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

container/FIFO.h

@@ -1,82 +1,47 @@
-#ifndef FIFO_H_
-#define FIFO_H_
+#ifndef FSFW_CONTAINER_FIFO_H_
+#define FSFW_CONTAINER_FIFO_H_
 
-#include "../returnvalues/HasReturnvaluesIF.h"
+#include "FIFOBase.h"
+#include <array>
 
 /**
- * @brief Simple First-In-First-Out data structure
+ * @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, uint8_t capacity>
-class FIFO {
-private:
-	uint8_t readIndex, writeIndex, currentSize;
-	T data[capacity];
-
-	uint8_t next(uint8_t current) {
-		++current;
-		if (current == capacity) {
-			current = 0;
-		}
-		return current;
-	}
+template<typename T, size_t capacity>
+class FIFO: public FIFOBase<T> {
 public:
-	FIFO() :
-			readIndex(0), writeIndex(0), currentSize(0) {
+	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());
 	}
 
-	bool empty() {
-		return (currentSize == 0);
+	/**
+	 * @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;
 	}
 
-	bool full() {
-		return (currentSize == capacity);
-	}
-
-	uint8_t size(){
-		return currentSize;
-	}
-
-	ReturnValue_t insert(T value) {
-		if (full()) {
-			return FULL;
-		} else {
-			data[writeIndex] = value;
-			writeIndex = next(writeIndex);
-			++currentSize;
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-	}
-
-	ReturnValue_t retrieve(T *value) {
-		if (empty()) {
-			return EMPTY;
-		} else {
-			*value = data[readIndex];
-			readIndex = next(readIndex);
-			--currentSize;
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-	}
-
-	ReturnValue_t peek(T * value) {
-	    if(empty()) {
-	        return EMPTY;
-	    } else {
-	       *value = data[readIndex];
-	       return HasReturnvaluesIF::RETURN_OK;
-	    }
-	}
-
-	ReturnValue_t pop() {
-		T value;
-		return this->retrieve(&value);
-	}
-
-	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);
+private:
+	std::array<T, capacity> fifoArray;
 };
 
-#endif /* FIFO_H_ */
+#endif /* FSFW_CONTAINER_FIFO_H_ */

container/FIFOBase.h

@@ -0,0 +1,65 @@
+#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
+	 */
+	ReturnValue_t insert(T value);
+	/**
+	 * Retrieve item from FIFO. This removes the item from the FIFO.
+	 * @param value
+	 * @return
+	 */
+	ReturnValue_t retrieve(T *value);
+	/**
+	 * Retrieve item from FIFO without removing it from FIFO.
+	 * @param value
+	 * @return
+	 */
+	ReturnValue_t peek(T * value);
+	/**
+	 * Remove item from FIFO.
+	 * @return
+	 */
+	ReturnValue_t pop();
+
+	bool empty();
+	bool full();
+	size_t size();
+
+
+	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_ */

container/FIFOBase.tpp

@@ -0,0 +1,87 @@
+#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 {
+		*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 {
+		*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

container/FixedMap.h

@@ -1,15 +1,20 @@
-#ifndef FIXEDMAP_H_
-#define FIXEDMAP_H_
+#ifndef FSFW_CONTAINER_FIXEDMAP_H_
+#define FSFW_CONTAINER_FIXEDMAP_H_
 
 #include "ArrayList.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include <utility>
+#include <type_traits>
 
 /**
- * \ingroup container
+ * @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);
@@ -47,15 +52,6 @@ public:
 		Iterator(std::pair<key_t, T> *pair) :
 				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair) {
 		}
-
-		T operator*() {
-			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-		}
-
-		T *operator->() {
-			return &ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-		}
-
 	};
 
 	Iterator begin() const {
@@ -70,7 +66,7 @@ public:
 		return _size;
 	}
 
-	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = NULL) {
+	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr) {
 		if (exists(key) == HasReturnvaluesIF::RETURN_OK) {
 			return KEY_ALREADY_EXISTS;
 		}
@@ -79,7 +75,7 @@ public:
 		}
 		theMap[_size].first = key;
 		theMap[_size].second = value;
-		if (storedValue != NULL) {
+		if (storedValue != nullptr) {
 			*storedValue = Iterator(&theMap[_size]);
 		}
 		++_size;
@@ -87,7 +83,7 @@ public:
 	}
 
 	ReturnValue_t insert(std::pair<key_t, T> pair) {
-		return insert(pair.fist, pair.second);
+		return insert(pair.first, pair.second);
 	}
 
 	ReturnValue_t exists(key_t key) const {
@@ -196,4 +192,4 @@ public:
 
 };
 
-#endif /* FIXEDMAP_H_ */
+#endif /* FSFW_CONTAINER_FIXEDMAP_H_ */

container/FixedOrderedMultimap.h

@@ -48,7 +48,7 @@ private:
 		if (_size <= position) {
 			return;
 		}
-		memmove(&theMap[position], &theMap[position + 1],
+		memmove(static_cast<void*>(&theMap[position]), static_cast<void*>(&theMap[position + 1]),
 				(_size - position - 1) * sizeof(std::pair<key_t,T>));
 		--_size;
 	}
@@ -68,15 +68,6 @@ public:
 		Iterator(std::pair<key_t, T> *pair) :
 				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair) {
 		}
-
-		T operator*() {
-			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-		}
-
-		T *operator->() {
-			return &ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-		}
-
 	};
 
 	Iterator begin() const {
@@ -91,17 +82,17 @@ public:
 		return _size;
 	}
 
-	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = NULL) {
+	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr) {
 		if (_size == theMap.maxSize()) {
 			return MAP_FULL;
 		}
 		uint32_t position = findNicePlace(key);
-		memmove(&theMap[position + 1], &theMap[position],
+		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 != NULL) {
+		if (storedValue != nullptr) {
 			*storedValue = Iterator(&theMap[position]);
 		}
 		return HasReturnvaluesIF::RETURN_OK;
@@ -145,12 +136,6 @@ public:
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
-	//This is potentially unsafe
-//	T *findValue(key_t key) const {
-//		return &theMap[findFirstIndex(key)].second;
-//	}
-
-
 	Iterator find(key_t key) const {
 		ReturnValue_t result = exists(key);
 		if (result != HasReturnvaluesIF::RETURN_OK) {

container/IsDerivedFrom.h

@@ -1,41 +0,0 @@
-#ifndef ISDERIVEDFROM_H_
-#define ISDERIVEDFROM_H_
-
-template<typename D, typename B>
-class IsDerivedFrom {
-	class No {
-	};
-	class Yes {
-		No no[3];
-	};
-
-	static Yes Test(B*); // declared, but not defined
-	static No Test(... ); // declared, but not defined
-
-public:
-	enum {
-		Is = sizeof(Test(static_cast<D*>(0))) == sizeof(Yes)
-	};
-};
-
-template<typename, typename>
-struct is_same {
-    static bool const value = false;
-};
-
-template<typename A>
-struct is_same<A, A> {
-    static bool const value = true;
-};
-
-
-template<bool C, typename T = void>
-struct enable_if {
-  typedef T type;
-};
-
-template<typename T>
-struct enable_if<false, T> { };
-
-
-#endif /* ISDERIVEDFROM_H_ */

container/SimpleRingBuffer.cpp

@@ -1,18 +1,23 @@
 #include "SimpleRingBuffer.h"
 #include <string.h>
 
-SimpleRingBuffer::SimpleRingBuffer(uint32_t size, bool overwriteOld) :
-		RingBufferBase<>(0, size, overwriteOld), buffer(NULL) {
+SimpleRingBuffer::SimpleRingBuffer(const size_t size, bool overwriteOld) :
+		RingBufferBase<>(0, size, overwriteOld) {
 	buffer = new uint8_t[size];
 }
 
+SimpleRingBuffer::SimpleRingBuffer(uint8_t *buffer, const size_t size,
+        bool overwriteOld):
+        RingBufferBase<>(0, size, overwriteOld), buffer(buffer) {}
+
+
 SimpleRingBuffer::~SimpleRingBuffer() {
 	delete[] buffer;
 }
 
 ReturnValue_t SimpleRingBuffer::writeData(const uint8_t* data,
 		uint32_t amount) {
-	if (availableWriteSpace() >= amount || overwriteOld) {
+	if (availableWriteSpace() >= amount or overwriteOld) {
 		uint32_t amountTillWrap = writeTillWrap();
 		if (amountTillWrap >= amount) {
 			memcpy(&buffer[write], data, amount);
@@ -38,7 +43,7 @@ ReturnValue_t SimpleRingBuffer::readData(uint8_t* data, uint32_t amount,
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 	}
-	if (trueAmount != NULL) {
+	if (trueAmount != nullptr) {
 		*trueAmount = amount;
 	}
 	if (amountTillWrap >= amount) {
@@ -60,9 +65,10 @@ ReturnValue_t SimpleRingBuffer::deleteData(uint32_t amount,
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 	}
-	if (trueAmount != NULL) {
+	if (trueAmount != nullptr) {
 		*trueAmount = amount;
 	}
 	incrementRead(amount, READ_PTR);
 	return HasReturnvaluesIF::RETURN_OK;
 }
+

container/SimpleRingBuffer.h

@@ -4,17 +4,64 @@
 #include "RingBufferBase.h"
 #include <stddef.h>
 
+/**
+ * @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:
-	SimpleRingBuffer(uint32_t size, bool overwriteOld);
+    /**
+     * This constructor allocates a new internal buffer with the supplied size.
+     * @param size
+     * @param overwriteOld
+     */
+	SimpleRingBuffer(const size_t size, bool overwriteOld);
+	/**
+	 * This constructor takes an external buffer with the specified size.
+	 * @param buffer
+	 * @param size
+	 * @param overwriteOld
+	 */
+	SimpleRingBuffer(uint8_t* buffer, const size_t size, bool overwriteOld);
+
 	virtual ~SimpleRingBuffer();
+
+	/**
+	 * Write to circular buffer and increment write pointer by amount
+	 * @param data
+	 * @param amount
+	 * @return
+	 */
 	ReturnValue_t writeData(const uint8_t* data, uint32_t amount);
-	ReturnValue_t readData(uint8_t* data, uint32_t amount, bool readRemaining = false, uint32_t* trueAmount = NULL);
-	ReturnValue_t deleteData(uint32_t amount, bool deleteRemaining = false, uint32_t* trueAmount = NULL);
+
+	/**
+	 * Read from circular buffer at read pointer
+	 * @param data
+	 * @param amount
+	 * @param readRemaining
+	 * @param trueAmount
+	 * @return
+	 */
+	ReturnValue_t readData(uint8_t* data, uint32_t amount,
+	        bool readRemaining = false, uint32_t* trueAmount = nullptr);
+
+	/**
+	 * Delete data starting by incrementing read pointer
+	 * @param amount
+	 * @param deleteRemaining
+	 * @param trueAmount
+	 * @return
+	 */
+	ReturnValue_t deleteData(uint32_t amount, bool deleteRemaining = false,
+	        uint32_t* trueAmount = nullptr);
 private:
 //	static const uint8_t TEMP_READ_PTR = 1;
 	static const uint8_t READ_PTR = 0;
-	uint8_t* buffer;
+	uint8_t* buffer = nullptr;
 };
 
 #endif /* FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_ */

devicehandlers/ChildHandlerBase.cpp

@@ -1,17 +1,19 @@
 #include "../subsystem/SubsystemBase.h"
-#include "ChildHandlerBase.h"
+#include "../devicehandlers/ChildHandlerBase.h"
 #include "../subsystem/SubsystemBase.h"
 
 ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId,
-		object_id_t deviceCommunication, CookieIF * comCookie,
-		uint8_t setDeviceSwitch, uint32_t thermalStatePoolId,
-		uint32_t thermalRequestPoolId, uint32_t parent,
-		FailureIsolationBase* customFdir, size_t cmdQueueSize) :
-		DeviceHandlerBase(setObjectId, deviceCommunication, comCookie,
-				setDeviceSwitch, thermalStatePoolId,thermalRequestPoolId,
-				(customFdir == nullptr? &childHandlerFdir : customFdir),
-				cmdQueueSize),
+		object_id_t deviceCommunication, CookieIF * cookie,
+		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
+		object_id_t parent, FailureIsolationBase* customFdir,
+		size_t cmdQueueSize) :
+		DeviceHandlerBase(setObjectId, deviceCommunication, cookie,
+			(customFdir == nullptr? &childHandlerFdir : customFdir),
+			cmdQueueSize),
 		parentId(parent), childHandlerFdir(setObjectId) {
+	this->setThermalStateRequestPoolIds(thermalStatePoolId,
+			thermalRequestPoolId);
+
 }
 
 ChildHandlerBase::~ChildHandlerBase() {
@@ -25,7 +27,7 @@ ReturnValue_t ChildHandlerBase::initialize() {
 
 	MessageQueueId_t parentQueue = 0;
 
-	if (parentId != 0) {
+	if (parentId != objects::NO_OBJECT) {
 		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
 		if (parent == NULL) {
 			return RETURN_FAILED;

devicehandlers/ChildHandlerBase.h

@@ -1,15 +1,15 @@
-#ifndef PAYLOADHANDLERBASE_H_
-#define PAYLOADHANDLERBASE_H_
+#ifndef FSFW_DEVICES_CHILDHANDLERBASE_H_
+#define FSFW_DEVICES_CHILDHANDLERBASE_H_
 
 #include "ChildHandlerFDIR.h"
 #include "DeviceHandlerBase.h"
 
 class ChildHandlerBase: public DeviceHandlerBase {
 public:
-	ChildHandlerBase(object_id_t setObjectId,
-			object_id_t deviceCommunication, CookieIF * comCookie,
-			uint8_t setDeviceSwitch, uint32_t thermalStatePoolId,
-			uint32_t thermalRequestPoolId, uint32_t parent,
+	ChildHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
+			CookieIF * cookie, uint32_t thermalStatePoolId,
+			uint32_t thermalRequestPoolId,
+			object_id_t parent = objects::NO_OBJECT,
 			FailureIsolationBase* customFdir = nullptr,
 			size_t cmdQueueSize = 20);
 	virtual ~ChildHandlerBase();
@@ -22,4 +22,5 @@ protected:
 
 };
 
-#endif /* PAYLOADHANDLERBASE_H_ */
+#endif /* FSFW_DEVICES_CHILDHANDLERBASE_H_ */
+

devicehandlers/DeviceHandlerBase.cpp

@@ -1,12 +1,12 @@
 #include "DeviceHandlerBase.h"
+#include "AcceptsDeviceResponsesIF.h"
+#include "DeviceTmReportingWrapper.h"
+
 #include "../objectmanager/ObjectManager.h"
 #include "../storagemanager/StorageManagerIF.h"
 #include "../thermal/ThermalComponentIF.h"
-#include "AcceptsDeviceResponsesIF.h"
-
 #include "../datapool/DataSet.h"
 #include "../datapool/PoolVariable.h"
-#include "DeviceTmReportingWrapper.h"
 #include "../globalfunctions/CRC.h"
 #include "../subsystem/SubsystemBase.h"
 #include "../ipc/QueueFactory.h"
@@ -14,45 +14,47 @@
 
 #include <iomanip>
 
-object_id_t DeviceHandlerBase::powerSwitcherId = 0;
-object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
-object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
+object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
+object_id_t DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
+object_id_t DeviceHandlerBase::defaultFdirParentId = objects::NO_OBJECT;
 
 DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		object_id_t deviceCommunication, CookieIF * comCookie,
-		uint8_t setDeviceSwitch, uint32_t thermalStatePoolId,
-		uint32_t thermalRequestPoolId, FailureIsolationBase* fdirInstance,
-		size_t cmdQueueSize) :
+		FailureIsolationBase* fdirInstance, size_t cmdQueueSize) :
 		SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
 		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
 		deviceCommunicationId(deviceCommunication), comCookie(comCookie),
-		deviceThermalStatePoolId(thermalStatePoolId),
-		deviceThermalRequestPoolId(thermalRequestPoolId),
 		healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
-		childTransitionFailure(RETURN_OK), fdirInstance(fdirInstance),
-		hkSwitcher(this), defaultFDIRUsed(fdirInstance == nullptr),
-		switchOffWasReported(false), actionHelper(this, nullptr),
-		childTransitionDelay(5000),
-		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(
-		SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
+		actionHelper(this, nullptr), childTransitionFailure(RETURN_OK),
+		fdirInstance(fdirInstance), hkSwitcher(this),
+		defaultFDIRUsed(fdirInstance == nullptr), switchOffWasReported(false),
+		childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
+		transitionSourceSubMode(SUBMODE_NONE) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
-			CommandMessage::MAX_MESSAGE_SIZE);
+			MessageQueueMessage::MAX_MESSAGE_SIZE);
 	insertInCommandMap(RAW_COMMAND_ID);
 	cookieInfo.state = COOKIE_UNUSED;
 	cookieInfo.pendingCommand = deviceCommandMap.end();
 	if (comCookie == nullptr) {
-		sif::error << "DeviceHandlerBase: ObjectID 0x" << std::hex <<
-				std::setw(8) << std::setfill('0') << this->getObjectId() <<
-				std::dec << ": Do not pass nullptr as a cookie, consider "
-				<< std::setfill(' ') << "passing a dummy cookie instead!" <<
-				std::endl;
+		sif::error << "DeviceHandlerBase: ObjectID 0x" << std::hex
+				<< std::setw(8) << std::setfill('0') << this->getObjectId()
+				<< std::dec << ": Do not pass nullptr as a cookie, consider "
+				<< std::setfill(' ') << "passing a dummy cookie instead!"
+				<< std::endl;
 	}
 	if (this->fdirInstance == nullptr) {
 		this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId,
-				defaultFDIRParentId);
+				defaultFdirParentId);
 	}
 }
 
+void DeviceHandlerBase::setThermalStateRequestPoolIds(
+		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId) {
+	this->deviceThermalRequestPoolId = thermalStatePoolId;
+	this->deviceThermalRequestPoolId = thermalRequestPoolId;
+}
+
+
 DeviceHandlerBase::~DeviceHandlerBase() {
 	delete comCookie;
 	if (defaultFDIRUsed) {
@@ -108,8 +110,12 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 
 	communicationInterface = objectManager->get<DeviceCommunicationIF>(
 			deviceCommunicationId);
-	if (communicationInterface == NULL) {
-		return RETURN_FAILED;
+	if (communicationInterface == nullptr) {
+		sif::error << "DeviceHandlerBase::initialize: Communication interface "
+				"invalid." << std::endl;
+		sif::error << "Make sure it is set up properly and implements"
+				" DeviceCommunicationIF" << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
 	result = communicationInterface->initializeInterface(comCookie);
@@ -118,27 +124,40 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	}
 
 	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (IPCStore == NULL) {
-		return RETURN_FAILED;
+	if (IPCStore == nullptr) {
+		sif::error << "DeviceHandlerBase::initialize: IPC store not set up in "
+				"factory." << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
-	AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
-			AcceptsDeviceResponsesIF>(rawDataReceiverId);
+	if(rawDataReceiverId != objects::NO_OBJECT) {
+		AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
+				AcceptsDeviceResponsesIF>(rawDataReceiverId);
 
-	if (rawReceiver == NULL) {
-		return RETURN_FAILED;
+		if (rawReceiver == nullptr) {
+			sif::error << "DeviceHandlerBase::initialize: Raw receiver object "
+					"ID set but no valid object found." << std::endl;
+			sif::error << "Make sure the raw receiver object is set up properly"
+					" and implements AcceptsDeviceResponsesIF" << std::endl;
+			return ObjectManagerIF::CHILD_INIT_FAILED;
+		}
+		defaultRawReceiver = rawReceiver->getDeviceQueue();
 	}
 
-	defaultRawReceiver = rawReceiver->getDeviceQueue();
-
-	powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
-	if (powerSwitcher == NULL) {
-		return RETURN_FAILED;
+	if(powerSwitcherId != objects::NO_OBJECT) {
+		powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
+		if (powerSwitcher == nullptr) {
+			sif::error << "DeviceHandlerBase::initialize: Power switcher "
+					<< "object ID set but no valid object found." << std::endl;
+			sif::error << "Make sure the raw receiver object is set up properly"
+					<< " and implements PowerSwitchIF" << std::endl;
+			return ObjectManagerIF::CHILD_INIT_FAILED;
+		}
 	}
 
 	result = healthHelper.initialize();
 	if (result != RETURN_OK) {
-		return result;
+	    return result;
 	}
 
 	result = modeHelper.initialize();
@@ -168,7 +187,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 
 	//Set temperature target state to NON_OP.
 	DataSet mySet;
-	PoolVariable<int8_t> thermalRequest(deviceThermalRequestPoolId, &mySet,
+	db_int8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
 			PoolVariableIF::VAR_WRITE);
 	mySet.read();
 	thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
@@ -200,38 +219,43 @@ void DeviceHandlerBase::readCommandQueue() {
 		return;
 	}
 
-	CommandMessage message;
-	ReturnValue_t result = commandQueue->receiveMessage(&message);
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result != RETURN_OK) {
 		return;
 	}
 
-	result = healthHelper.handleHealthCommand(&message);
+	result = healthHelper.handleHealthCommand(&command);
+	if (result == RETURN_OK) {
+	    return;
+	}
+
+	result = modeHelper.handleModeCommand(&command);
 	if (result == RETURN_OK) {
 		return;
 	}
 
-	result = modeHelper.handleModeCommand(&message);
+	result = actionHelper.handleActionMessage(&command);
 	if (result == RETURN_OK) {
 		return;
 	}
 
-	result = actionHelper.handleActionMessage(&message);
+	result = parameterHelper.handleParameterMessage(&command);
 	if (result == RETURN_OK) {
 		return;
 	}
 
-	result = parameterHelper.handleParameterMessage(&message);
+//	result = hkManager.handleHousekeepingMessage(&command);
+//	if (result == RETURN_OK) {
+//		return;
+//	}
+
+	result = handleDeviceHandlerMessage(&command);
 	if (result == RETURN_OK) {
 		return;
 	}
 
-	result = handleDeviceHandlerMessage(&message);
-	if (result == RETURN_OK) {
-		return;
-	}
-
-	result = letChildHandleMessage(&message);
+	result = letChildHandleMessage(&command);
 	if (result == RETURN_OK) {
 		return;
 	}
@@ -273,7 +297,8 @@ void DeviceHandlerBase::doStateMachine() {
 	case _MODE_WAIT_ON: {
 		uint32_t currentUptime;
 		Clock::getUptime(&currentUptime);
-		if (currentUptime - timeoutStart >= powerSwitcher->getSwitchDelayMs()) {
+		if (powerSwitcher != nullptr and currentUptime - timeoutStart >=
+				powerSwitcher->getSwitchDelayMs()) {
 			triggerEvent(MODE_TRANSITION_FAILED, PowerSwitchIF::SWITCH_TIMEOUT,
 					0);
 			setMode(_MODE_POWER_DOWN);
@@ -293,6 +318,12 @@ void DeviceHandlerBase::doStateMachine() {
 	case _MODE_WAIT_OFF: {
 		uint32_t currentUptime;
 		Clock::getUptime(&currentUptime);
+
+		if(powerSwitcher == nullptr) {
+		    setMode(MODE_OFF);
+		    break;
+		}
+
 		if (currentUptime - timeoutStart >= powerSwitcher->getSwitchDelayMs()) {
 			triggerEvent(MODE_TRANSITION_FAILED, PowerSwitchIF::SWITCH_TIMEOUT,
 					0);
@@ -343,9 +374,10 @@ ReturnValue_t DeviceHandlerBase::isModeCombinationValid(Mode_t mode,
 	}
 }
 
-ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
-		uint16_t maxDelayCycles, size_t replyLen, bool periodic,
-		bool hasDifferentReplyId, DeviceCommandId_t replyId) {
+ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(
+		DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles,
+		size_t replyLen, bool periodic, bool hasDifferentReplyId,
+		DeviceCommandId_t replyId) {
 	//No need to check, as we may try to insert multiple times.
 	insertInCommandMap(deviceCommand);
 	if (hasDifferentReplyId) {
@@ -371,7 +403,8 @@ ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
 	}
 }
 
-ReturnValue_t DeviceHandlerBase::insertInCommandMap(DeviceCommandId_t deviceCommand) {
+ReturnValue_t DeviceHandlerBase::insertInCommandMap(
+		DeviceCommandId_t deviceCommand) {
 	DeviceCommandInfo info;
 	info.expectedReplies = 0;
 	info.isExecuting = false;
@@ -419,7 +452,7 @@ void DeviceHandlerBase::setTransition(Mode_t modeTo, Submode_t submodeTo) {
 	transitionSourceSubMode = submode;
 	childTransitionFailure = CHILD_TIMEOUT;
 
-//transitionTargetMode is set by setMode
+	// transitionTargetMode is set by setMode
 	setMode((modeTo | TRANSITION_MODE_CHILD_ACTION_MASK), submodeTo);
 }
 
@@ -437,7 +470,7 @@ void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
 
 	if (mode == MODE_OFF) {
 		DataSet mySet;
-		PoolVariable<int8_t> thermalRequest(deviceThermalRequestPoolId, &mySet,
+		db_int8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
 				PoolVariableIF::VAR_READ_WRITE);
 		mySet.read();
 		if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
@@ -578,11 +611,8 @@ void DeviceHandlerBase::doSendRead() {
 }
 
 void DeviceHandlerBase::doGetRead() {
-	size_t receivedDataLen;
-	uint8_t *receivedData;
-	DeviceCommandId_t foundId = 0xFFFFFFFF;
-	size_t foundLen = 0;
-	ReturnValue_t result;
+	size_t receivedDataLen = 0;
+	uint8_t *receivedData = nullptr;
 
 	if (cookieInfo.state != COOKIE_READ_SENT) {
 		cookieInfo.state = COOKIE_UNUSED;
@@ -591,8 +621,8 @@ void DeviceHandlerBase::doGetRead() {
 
 	cookieInfo.state = COOKIE_UNUSED;
 
-	result = communicationInterface->readReceivedMessage(comCookie,
-			&receivedData, &receivedDataLen);
+	ReturnValue_t result = communicationInterface->readReceivedMessage(
+			comCookie, &receivedData, &receivedDataLen);
 
 	if (result != RETURN_OK) {
 		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
@@ -608,51 +638,101 @@ void DeviceHandlerBase::doGetRead() {
 		replyRawData(receivedData, receivedDataLen, requestedRawTraffic);
 	}
 
-	if (mode == MODE_RAW) {
+	if (mode == MODE_RAW and defaultRawReceiver != MessageQueueIF::NO_QUEUE) {
 		replyRawReplyIfnotWiretapped(receivedData, receivedDataLen);
-	} else {
-		//The loop may not execute more often than the number of received bytes (worst case).
-		//This approach avoids infinite loops due to buggy scanForReply routines (seen in bug 1077).
-		uint32_t remainingLength = receivedDataLen;
-		for (uint32_t count = 0; count < receivedDataLen; count++) {
-			result = scanForReply(receivedData, remainingLength, &foundId,
-					&foundLen);
-			switch (result) {
-			case RETURN_OK:
-				handleReply(receivedData, foundId, foundLen);
-				break;
-			case APERIODIC_REPLY: {
-				result = interpretDeviceReply(foundId, receivedData);
-				if (result != RETURN_OK) {
-					replyRawReplyIfnotWiretapped(receivedData, foundLen);
-					triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result,
-							foundId);
-				}
-			}
-				break;
-			case IGNORE_REPLY_DATA:
-				break;
-			case IGNORE_FULL_PACKET:
-				return;
-			default:
-				//We need to wait for timeout.. don't know what command failed and who sent it.
+	}
+	else {
+		parseReply(receivedData, receivedDataLen);
+	}
+}
+
+void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
+		size_t receivedDataLen) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	DeviceCommandId_t foundId = 0xFFFFFFFF;
+	size_t foundLen = 0;
+	// The loop may not execute more often than the number of received bytes
+	// (worst case). This approach avoids infinite loops due to buggy
+	// scanForReply routines.
+	uint32_t remainingLength = receivedDataLen;
+	for (uint32_t count = 0; count < receivedDataLen; count++) {
+		result = scanForReply(receivedData, remainingLength, &foundId,
+				&foundLen);
+		switch (result) {
+		case RETURN_OK:
+			handleReply(receivedData, foundId, foundLen);
+			break;
+		case APERIODIC_REPLY: {
+			result = interpretDeviceReply(foundId, receivedData);
+			if (result != RETURN_OK) {
 				replyRawReplyIfnotWiretapped(receivedData, foundLen);
-				triggerEvent(DEVICE_READING_REPLY_FAILED, result, foundLen);
-				break;
-			}
-			receivedData += foundLen;
-			if (remainingLength > foundLen) {
-				remainingLength -= foundLen;
-			} else {
-				return;
+				triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result,
+						foundId);
 			}
 		}
+		break;
+		case IGNORE_REPLY_DATA:
+			break;
+		case IGNORE_FULL_PACKET:
+			return;
+		default:
+			//We need to wait for timeout.. don't know what command failed and who sent it.
+			replyRawReplyIfnotWiretapped(receivedData, foundLen);
+			triggerEvent(DEVICE_READING_REPLY_FAILED, result, foundLen);
+			break;
+		}
+		receivedData += foundLen;
+		if (remainingLength > foundLen) {
+			remainingLength -= foundLen;
+		} else {
+			return;
+		}
+	}
+}
 
+void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
+		DeviceCommandId_t foundId, uint32_t foundLen) {
+	ReturnValue_t result;
+	DeviceReplyMap::iterator iter = deviceReplyMap.find(foundId);
+
+	if (iter == deviceReplyMap.end()) {
+		replyRawReplyIfnotWiretapped(receivedData, foundLen);
+		triggerEvent(DEVICE_UNKNOWN_REPLY, foundId);
+		return;
+	}
+
+	DeviceReplyInfo *info = &(iter->second);
+
+	if (info->delayCycles != 0) {
+
+		if (info->periodic != false) {
+			info->delayCycles = info->maxDelayCycles;
+		}
+		else {
+			info->delayCycles = 0;
+		}
+
+		result = interpretDeviceReply(foundId, receivedData);
+
+		if (result != RETURN_OK) {
+			// Report failed interpretation to FDIR.
+			replyRawReplyIfnotWiretapped(receivedData, foundLen);
+			triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result, foundId);
+		}
+		replyToReply(iter, result);
+	}
+	else {
+		// Other completion failure messages are created by timeout.
+		// Powering down the device might take some time during which periodic
+		// replies may still come in.
+		if (mode != _MODE_WAIT_OFF) {
+			triggerEvent(DEVICE_UNREQUESTED_REPLY, foundId);
+		}
 	}
 }
 
 ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
-		uint8_t * *data, uint32_t * len) {
+		uint8_t** data, uint32_t * len) {
 	size_t lenTmp;
 
 	if (IPCStore == nullptr) {
@@ -675,7 +755,7 @@ ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
 
 void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 		MessageQueueId_t sendTo, bool isCommand) {
-	if (IPCStore == NULL || len == 0) {
+	if (IPCStore == nullptr or len == 0 or sendTo == MessageQueueIF::NO_QUEUE) {
 		return;
 	}
 	store_address_t address;
@@ -686,18 +766,17 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 		return;
 	}
 
-	CommandMessage message;
+	CommandMessage command;
 
-	DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(&message,
+	DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(&command,
 			getObjectId(), address, isCommand);
 
-//	this->DeviceHandlerCommand = CommandMessage::CMD_NONE;
-
-	result = commandQueue->sendMessage(sendTo, &message);
+	result = commandQueue->sendMessage(sendTo, &command);
 
 	if (result != RETURN_OK) {
 		IPCStore->deleteData(address);
-		//Silently discard data, this indicates heavy TM traffic which should not be increased by additional events.
+		// Silently discard data, this indicates heavy TM traffic which
+		// should not be increased by additional events.
 	}
 }
 
@@ -726,57 +805,6 @@ MessageQueueId_t DeviceHandlerBase::getCommandQueue() const {
 	return commandQueue->getId();
 }
 
-void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
-		DeviceCommandId_t foundId, uint32_t foundLen) {
-	ReturnValue_t result;
-	DeviceReplyMap::iterator iter = deviceReplyMap.find(foundId);
-
-	if (iter == deviceReplyMap.end()) {
-		replyRawReplyIfnotWiretapped(receivedData, foundLen);
-		triggerEvent(DEVICE_UNKNOWN_REPLY, foundId);
-		return;
-	}
-
-	DeviceReplyInfo *info = &(iter->second);
-
-	if (info->delayCycles != 0) {
-
-		if (info->periodic) {
-			info->delayCycles = info->maxDelayCycles;
-		} else {
-			info->delayCycles = 0;
-		}
-		result = interpretDeviceReply(foundId, receivedData);
-		if (result != RETURN_OK) {
-			//Report failed interpretation to FDIR.
-			replyRawReplyIfnotWiretapped(receivedData, foundLen);
-			triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result, foundId);
-		}
-		replyToReply(iter, result);
-	} else {
-		//Other completion failure messages are created by timeout.
-		//Powering down the device might take some time during which periodic replies may still come in.
-		if (mode != _MODE_WAIT_OFF) {
-			triggerEvent(DEVICE_UNREQUESTED_REPLY, foundId);
-		}
-	}
-}
-
-//ReturnValue_t DeviceHandlerBase::switchCookieChannel(object_id_t newChannelId) {
-//	DeviceCommunicationIF *newCommunication = objectManager->get<
-//			DeviceCommunicationIF>(newChannelId);
-//
-//	if (newCommunication != NULL) {
-//		ReturnValue_t result = newCommunication->reOpen(cookie, ioBoardAddress,
-//				maxDeviceReplyLen);
-//		if (result != RETURN_OK) {
-//			return result;
-//		}
-//		return RETURN_OK;
-//	}
-//	return RETURN_FAILED;
-//}
-
 void DeviceHandlerBase::buildRawDeviceCommand(CommandMessage* commandMessage) {
 	storedRawData = DeviceHandlerMessage::getStoreAddress(commandMessage);
 	ReturnValue_t result = getStorageData(storedRawData, &rawPacket,
@@ -793,6 +821,9 @@ void DeviceHandlerBase::buildRawDeviceCommand(CommandMessage* commandMessage) {
 }
 
 void DeviceHandlerBase::commandSwitch(ReturnValue_t onOff) {
+	if(powerSwitcher == nullptr) {
+		return;
+	}
 	const uint8_t *switches;
 	uint8_t numberOfSwitches = 0;
 	ReturnValue_t result = getSwitches(&switches, &numberOfSwitches);
@@ -807,9 +838,7 @@ void DeviceHandlerBase::commandSwitch(ReturnValue_t onOff) {
 
 ReturnValue_t DeviceHandlerBase::getSwitches(const uint8_t **switches,
 		uint8_t *numberOfSwitches) {
-	*switches = &deviceSwitch;
-	*numberOfSwitches = 1;
-	return RETURN_OK;
+	return DeviceHandlerBase::NO_SWITCH;
 }
 
 void DeviceHandlerBase::modeChanged(void) {
@@ -845,6 +874,9 @@ uint32_t DeviceHandlerBase::getTransitionDelayMs(Mode_t modeFrom,
 }
 
 ReturnValue_t DeviceHandlerBase::getStateOfSwitches(void) {
+	if(powerSwitcher == nullptr) {
+		return NO_SWITCH;
+	}
 	uint8_t numberOfSwitches = 0;
 	const uint8_t *switches;
 
@@ -895,9 +927,9 @@ ReturnValue_t DeviceHandlerBase::checkModeCommand(Mode_t commandedMode,
 	if ((commandedMode == MODE_ON) && (mode == MODE_OFF)
 			&& (deviceThermalStatePoolId != PoolVariableIF::NO_PARAMETER)) {
 		DataSet mySet;
-		PoolVariable<int8_t> thermalState(deviceThermalStatePoolId, &mySet,
+		db_int8_t thermalState(deviceThermalStatePoolId, &mySet,
 				PoolVariableIF::VAR_READ);
-		PoolVariable<int8_t> thermalRequest(deviceThermalRequestPoolId, &mySet,
+		db_int8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
 				PoolVariableIF::VAR_READ);
 		mySet.read();
 		if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
@@ -925,7 +957,7 @@ void DeviceHandlerBase::startTransition(Mode_t commandedMode,
 					MODE_ON);
 			triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
 			DataSet mySet;
-			PoolVariable<int8_t> thermalRequest(deviceThermalRequestPoolId,
+			db_int8_t thermalRequest(deviceThermalRequestPoolId,
 					&mySet, PoolVariableIF::VAR_READ_WRITE);
 			mySet.read();
 			if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
@@ -997,8 +1029,8 @@ HasHealthIF::HealthState DeviceHandlerBase::getHealth() {
 }
 
 ReturnValue_t DeviceHandlerBase::setHealth(HealthState health) {
-	healthHelper.setHealth(health);
-	return HasReturnvaluesIF::RETURN_OK;
+    healthHelper.setHealth(health);
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 void DeviceHandlerBase::checkSwitchState() {
@@ -1111,35 +1143,47 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
 		return;
 	}
 	DeviceTmReportingWrapper wrapper(getObjectId(), replyId, data);
-	if (iter->second.command != deviceCommandMap.end()) {//replies to a command
+	//replies to a command
+	if (iter->second.command != deviceCommandMap.end())
+	{
 		MessageQueueId_t queueId = iter->second.command->second.sendReplyTo;
 
 		if (queueId != NO_COMMANDER) {
 			//This may fail, but we'll ignore the fault.
 			actionHelper.reportData(queueId, replyId, data);
 		}
+
 		//This check should make sure we get any TM but don't get anything doubled.
 		if (wiretappingMode == TM && (requestedRawTraffic != queueId)) {
 			actionHelper.reportData(requestedRawTraffic, replyId, &wrapper);
-		} else if (forceDirectTm && (defaultRawReceiver != queueId)) {
-
-			// hiding of sender needed so the service will handle it as unexpected Data, no matter what state
-			//(progress or completed) it is in
-			actionHelper.reportData(defaultRawReceiver, replyId, &wrapper,
-			true);
-
 		}
-	} else { //unrequested/aperiodic replies
-		if (wiretappingMode == TM) {
-			actionHelper.reportData(requestedRawTraffic, replyId, &wrapper);
-		} else if (forceDirectTm) {
-			// hiding of sender needed so the service will handle it as unexpected Data, no matter what state
-			//(progress or completed) it is in
+		else if (forceDirectTm and (defaultRawReceiver != queueId) and
+					(defaultRawReceiver != MessageQueueIF::NO_QUEUE))
+		{
+			// hiding of sender needed so the service will handle it as
+			// unexpected Data, no matter what state (progress or completed)
+			// it is in
 			actionHelper.reportData(defaultRawReceiver, replyId, &wrapper,
-			true);
+					true);
 		}
 	}
-//Try to cast to DataSet and commit data.
+	//unrequested/aperiodic replies
+	else
+	{
+		if (wiretappingMode == TM) {
+			actionHelper.reportData(requestedRawTraffic, replyId, &wrapper);
+		}
+		else if (forceDirectTm and defaultRawReceiver !=
+				MessageQueueIF::NO_QUEUE)
+		{
+			// hiding of sender needed so the service will handle it as
+			// unexpected Data, no matter what state (progress or completed)
+			// it is in
+			actionHelper.reportData(defaultRawReceiver, replyId, &wrapper,
+					true);
+		}
+	}
+	//Try to cast to GlobDataSet and commit data.
 	if (!neverInDataPool) {
 		DataSet* dataSet = dynamic_cast<DataSet*>(data);
 		if (dataSet != NULL) {
@@ -1178,18 +1222,23 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 	if (mode == MODE_NORMAL) {
 		result = buildNormalDeviceCommand(&deviceCommandId);
 		if (result == BUSY) {
+		    //so we can track misconfigurations
 			sif::debug << std::hex << getObjectId()
-					<< ": DHB::buildInternalCommand busy" << std::endl; //so we can track misconfigurations
+					<< ": DHB::buildInternalCommand: Busy" << std::endl;
 			result = NOTHING_TO_SEND; //no need to report this
 		}
-	} else if (mode == MODE_RAW) {
+	}
+	else if (mode == MODE_RAW) {
 		result = buildChildRawCommand();
 		deviceCommandId = RAW_COMMAND_ID;
-	} else if (mode & TRANSITION_MODE_CHILD_ACTION_MASK) {
+	}
+	else if (mode & TRANSITION_MODE_CHILD_ACTION_MASK) {
 		result = buildTransitionDeviceCommand(&deviceCommandId);
-	} else {
+	}
+	else {
 		return;
 	}
+
 	if (result == NOTHING_TO_SEND) {
 		return;
 	}
@@ -1281,11 +1330,22 @@ void DeviceHandlerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
 }
 
 void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_){
-			executingTask = task_;
+	executingTask = task_;
 }
 
 // Default implementations empty.
 void DeviceHandlerBase::debugInterface(uint8_t positionTracker,
 		object_id_t objectId, uint32_t parameter) {}
 
-void DeviceHandlerBase::performOperationHook() {}
+void DeviceHandlerBase::performOperationHook() {
+}
+
+ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
+    // In this function, the task handle should be valid if the task
+    // was implemented correctly. We still check to be 1000 % sure :-)
+    if(executingTask != nullptr) {
+        pstIntervalMs = executingTask->getPeriodMs();
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+

devicehandlers/DeviceHandlerBase.h

@@ -1,22 +1,23 @@
-#ifndef DEVICEHANDLERBASE_H_
-#define DEVICEHANDLERBASE_H_
+#ifndef FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
+#define FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
+
+#include "DeviceHandlerIF.h"
+#include "DeviceCommunicationIF.h"
+#include "DeviceHandlerFailureIsolation.h"
 
 #include "../objectmanager/SystemObject.h"
+#include "../tasks/PeriodicTaskIF.h"
 #include "../tasks/ExecutableObjectIF.h"
-#include "DeviceHandlerIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../action/HasActionsIF.h"
 #include "../datapool/PoolVariableIF.h"
-#include "DeviceCommunicationIF.h"
 #include "../modes/HasModesIF.h"
 #include "../power/PowerSwitchIF.h"
 #include "../ipc/MessageQueueIF.h"
-
 #include "../action/ActionHelper.h"
 #include "../health/HealthHelper.h"
 #include "../parameters/ParameterHelper.h"
 #include "../datapool/HkSwitchHelper.h"
-#include "DeviceHandlerFailureIsolation.h"
 
 #include <map>
 
@@ -46,14 +47,16 @@ class StorageManagerIF;
  * If data has been received (GET_READ), the data will be interpreted.
  * The action for each step can be defined by the child class but as most
  * device handlers share a 4-call (sendRead-getRead-sendWrite-getWrite) structure,
- * a default implementation is provided. NOTE: RMAP is a standard which is used for FLP.
+ * a default implementation is provided.
+ * NOTE: RMAP is a standard which is used for FLP.
  * RMAP communication is not mandatory for projects implementing the FSFW.
  * However, the communication principles are similar to RMAP as there are
  * two write and two send calls involved.
  *
- * Device handler instances should extend this class and implement the abstract functions.
- * Components and drivers can send so called cookies which are used for communication
- * and contain information about the communcation (e.g. slave address for I2C or RMAP structs).
+ * Device handler instances should extend this class and implement the abstract
+ * functions. Components and drivers can send so called cookies which are used
+ * for communication and contain information about the communcation (e.g. slave
+ * address for I2C or RMAP structs).
  * The following abstract methods must be implemented by a device handler:
  *  1. doStartUp()
  *  2. doShutDown()
@@ -100,12 +103,12 @@ public:
 	 * @param cmdQueueSize
 	 */
 	DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
-			CookieIF * comCookie, uint8_t setDeviceSwitch,
-			uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
-			uint32_t thermalRequestPoolId = PoolVariableIF::NO_PARAMETER,
-			FailureIsolationBase* fdirInstance = nullptr,
+			CookieIF * comCookie, FailureIsolationBase* fdirInstance = nullptr,
 			size_t cmdQueueSize = 20);
 
+	void setThermalStateRequestPoolIds(uint32_t thermalStatePoolId,
+			uint32_t thermalRequestPoolId);
+
 	/**
 	 * @brief 	This function is the device handler base core component and is
 	 * 			called periodically.
@@ -150,11 +153,9 @@ public:
 	 * @return
 	 */
 	virtual ReturnValue_t initialize();
-
-	/**
-	 * Destructor.
-	 */
+	/** Destructor. */
 	virtual ~DeviceHandlerBase();
+
 protected:
 	/**
 	 * @brief 	This is used to let the child class handle the transition from
@@ -232,8 +233,9 @@ protected:
 	 * Build the device command to send for a transitional mode.
 	 *
 	 * This is only called in @c _MODE_TO_NORMAL, @c _MODE_TO_ON, @c _MODE_TO_RAW,
-	 * @c _MODE_START_UP and @c _MODE_TO_POWER_DOWN. So it is used by doStartUp()
-	 * and doShutDown() as well as doTransition()
+	 * @c _MODE_START_UP and @c _MODE_SHUT_DOWN. So it is used by doStartUp()
+	 * and doShutDown() as well as doTransition(), by setting those
+	 * modes in the respective functions.
 	 *
 	 * A good idea is to implement a flag indicating a command has to be built
 	 * and a variable containing the command number to be built
@@ -321,12 +323,11 @@ protected:
 	 *     - @c RETURN_FAILED when the reply could not be interpreted,
 	 *     e.g. logical errors or range violations occurred
 	 */
-
 	virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
 			const uint8_t *packet) = 0;
 
 	/**
-	 * @brief fill the #deviceCommandMap
+	 * @brief fill the #DeviceCommandMap and #DeviceReplyMap
 	 *	 	  called by the initialize() of the base class
 	 * @details
 	 * This is used to let the base class know which replies are expected.
@@ -470,6 +471,18 @@ protected:
 	virtual ReturnValue_t getSwitches(const uint8_t **switches,
 			uint8_t *numberOfSwitches);
 
+	/**
+	 * This function is used to initialize the local housekeeping pool
+	 * entries. The default implementation leaves the pool empty.
+	 * @param localDataPoolMap
+	 * @return
+	 */
+	//virtual ReturnValue_t initializePoolEntries(
+	//			LocalDataPool& localDataPoolMap) override;
+
+	/** Get the HK manager object handle */
+	//virtual LocalDataPoolManager* getHkManagerHandle() override;
+
 	/**
 	 * @brief 	Hook function for child handlers which is called once per
 	 * 			performOperation(). Default implementation is empty.
@@ -493,7 +506,7 @@ public:
 	ReturnValue_t setHealth(HealthState health);
 	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
+			const ParameterWrapper *newValues, uint16_t startAtIndex) override;
 	/**
 	 * Implementation of ExecutableObjectIF function
 	 *
@@ -505,7 +518,7 @@ public:
 
 protected:
 	/**
-	 * The Returnvalues ID of this class, required by HasReturnvaluesIF
+	 * The Returnvalues id of this class, required by HasReturnvaluesIF
 	 */
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;
 
@@ -527,114 +540,138 @@ protected:
 	static const DeviceCommandId_t NO_COMMAND_ID = -2;
 	static const MessageQueueId_t NO_COMMANDER = 0;
 
-	/**
-	 * Pointer to the raw packet that will be sent.
-	 */
+	/** Pointer to the raw packet that will be sent.*/
 	uint8_t *rawPacket = nullptr;
-	/**
-	 * Size of the #rawPacket.
-	 */
+	/** Size of the #rawPacket. */
 	uint32_t rawPacketLen = 0;
 
 	/**
 	 * The mode the device handler is currently in.
-	 *
 	 * This should never be changed directly but only with setMode()
 	 */
 	Mode_t mode;
-
 	/**
 	 * The submode the device handler is currently in.
-	 *
 	 * This should never be changed directly but only with setMode()
 	 */
 	Submode_t submode;
 
-	/**
-	 * This is the counter value from performOperation().
-	 */
+	/** This is the counter value from performOperation(). */
 	uint8_t pstStep = 0;
+	uint32_t pstIntervalMs = 0;
 
 	/**
-	 * wiretapping flag:
+	 * Wiretapping flag:
 	 *
-	 * indicates either that all raw messages to and from the device should be sent to #theOneWhoWantsToReadRawTraffic
-	 * or that all device TM should be downlinked to #theOneWhoWantsToReadRawTraffic
+	 * indicates either that all raw messages to and from the device should be
+	 * sent to #defaultRawReceiver
+	 * or that all device TM should be downlinked to #defaultRawReceiver.
 	 */
 	enum WiretappingMode {
 		OFF = 0, RAW = 1, TM = 2
 	} wiretappingMode;
-
 	/**
-	 * A message queue that accepts raw replies
+	 * @brief 	A message queue that accepts raw replies
 	 *
-	 * Statically initialized in initialize() to a configurable object. Used when there is no method
-	 * of finding a recipient, ie raw mode and reporting erreonous replies
+	 * Statically initialized in initialize() to a configurable object.
+	 * Used when there is no method of finding a recipient, ie raw mode and
+	 * reporting erroneous replies
 	 */
-	MessageQueueId_t defaultRawReceiver = 0;
-
+	MessageQueueId_t defaultRawReceiver = MessageQueueIF::NO_QUEUE;
 	store_address_t storedRawData;
 
 	/**
-	 * the message queue which wants to read all raw traffic
-	 *
-	 * if #isWiretappingActive all raw communication from and to the device will be sent to this queue
+	 * @brief 	The message queue which wants to read all raw traffic
+	 * If #isWiretappingActive all raw communication from and to the device
+	 * will be sent to this queue
 	 */
 	MessageQueueId_t requestedRawTraffic = 0;
 
-	/**
-	 * the object used to set power switches
-	 */
-	PowerSwitchIF *powerSwitcher = nullptr;
-
 	/**
 	 * Pointer to the IPCStore.
-	 *
 	 * This caches the pointer received from the objectManager in the constructor.
 	 */
 	StorageManagerIF *IPCStore = nullptr;
-
-	/**
-	 * cached for init
-	 */
+	/** The comIF object ID is cached for the intialize() function */
 	object_id_t deviceCommunicationId;
-
-	/**
-	 * Communication object used for device communication
-	 */
+	/** Communication object used for device communication */
 	DeviceCommunicationIF * communicationInterface = nullptr;
-
-	/**
-	 * Cookie used for communication
-	 */
+	/** Cookie used for communication */
 	CookieIF * comCookie;
 
+	/** Health helper for HasHealthIF */
+	HealthHelper healthHelper;
+	/** Mode helper for HasModesIF */
+	ModeHelper modeHelper;
+	/** Parameter helper for ReceivesParameterMessagesIF */
+	ParameterHelper parameterHelper;
+	/** Action helper for HasActionsIF */
+	ActionHelper actionHelper;
+	/** Housekeeping Manager */
+	//LocalDataPoolManager hkManager;
+
+	/**
+	 *  @brief Information about commands
+	 */
 	struct DeviceCommandInfo {
-		bool isExecuting; //!< Indicates if the command is already executing.
-		uint8_t expectedReplies; //!< Dynamic value to indicate how many replies are expected. Inititated with 0.
-		MessageQueueId_t sendReplyTo; //!< if this is != NO_COMMANDER, DHB was commanded externally and shall report everything to commander.
+		//! Indicates if the command is already executing.
+		bool isExecuting;
+		//! Dynamic value to indicate how many replies are expected.
+		//! Inititated with 0.
+		uint8_t expectedReplies;
+		//! if this is != NO_COMMANDER, DHB was commanded externally and shall
+		//! report everything to commander.
+		MessageQueueId_t sendReplyTo;
 	};
 	using DeviceCommandMap = std::map<DeviceCommandId_t, DeviceCommandInfo> ;
+	/**
+	 * Information about commands
+	 */
+	DeviceCommandMap deviceCommandMap;
 
 	/**
 	 * @brief Information about expected replies
-	 *
-	 * This is used to keep track of pending replies
+	 * This is used to keep track of pending replies.
 	 */
 	struct DeviceReplyInfo {
-		uint16_t maxDelayCycles; //!< The maximum number of cycles the handler should wait for a reply to this command.
-		uint16_t delayCycles; //!< The currently remaining cycles the handler should wait for a reply, 0 means there is no reply expected
+		//! The maximum number of cycles the handler should wait for a reply
+		//! to this command.
+		uint16_t maxDelayCycles;
+		//! The currently remaining cycles the handler should wait for a reply,
+		//! 0 means there is no reply expected
+		uint16_t delayCycles;
 		size_t replyLen = 0; //!< Expected size of the reply.
-		bool periodic; //!< if this is !=0, the delayCycles will not be reset to 0 but to maxDelayCycles
-		DeviceCommandMap::iterator command; //!< The command that expects this reply.
+		//! if this is !=0, the delayCycles will not be reset to 0 but to
+		//! maxDelayCycles
+		bool periodic = false;
+		//! The dataset used to access housekeeping data related to the
+		//! respective device reply. Will point to a dataset held by
+		//! the child handler (if one is specified)
+		// DataSetIF* dataSet = nullptr;
+		//! The command that expects this reply.
+		DeviceCommandMap::iterator command;
 	};
 
 	using DeviceReplyMap = std::map<DeviceCommandId_t, DeviceReplyInfo> ;
 	using DeviceReplyIter = DeviceReplyMap::iterator;
-
 	/**
-	 * The MessageQueue used to receive device handler commands and to send replies.
+	 * This map is used to check and track correct reception of all replies.
+	 *
+	 * It has multiple use:
+	 * - It stores the information on pending replies. If a command is sent,
+	 * 	 the DeviceCommandInfo.count is incremented.
+	 * - It is used to time-out missing replies. If a command is sent, the
+	 * 	 DeviceCommandInfo.DelayCycles is set to MaxDelayCycles.
+	 * - It is queried to check if a reply from the device can be interpreted.
+	 *   scanForReply() returns the id of the command a reply was found for.
+	 * The reply is ignored in the following cases:
+	 *     - No entry for the returned id was found
+	 *     - The deviceReplyInfo.delayCycles is == 0
 	 */
+	DeviceReplyMap deviceReplyMap;
+
+	//! The MessageQueue used to receive device handler commands
+	//! and to send replies.
 	MessageQueueIF* commandQueue = nullptr;
 
 	/**
@@ -642,23 +679,14 @@ protected:
 	 *
 	 * can be set to PoolVariableIF::NO_PARAMETER to deactivate thermal checking
 	 */
-	uint32_t deviceThermalStatePoolId;
+	uint32_t deviceThermalStatePoolId = PoolVariableIF::NO_PARAMETER;
 
 	/**
 	 * this is the datapool variable with the thermal request of the device
 	 *
 	 * can be set to PoolVariableIF::NO_PARAMETER to deactivate thermal checking
 	 */
-	uint32_t deviceThermalRequestPoolId;
-
-	/**
-	 * Taking care of the health
-	 */
-	HealthHelper healthHelper;
-
-	ModeHelper modeHelper;
-
-	ParameterHelper parameterHelper;
+	uint32_t deviceThermalRequestPoolId = PoolVariableIF::NO_PARAMETER;
 
 	/**
 	 * Optional Error code
@@ -676,13 +704,15 @@ protected:
 
 	bool switchOffWasReported; //!< Indicates if SWITCH_WENT_OFF was already thrown.
 
-	PeriodicTaskIF* executingTask = nullptr;//!< Pointer to the task which executes this component, is invalid before setTaskIF was called.
+	//! Pointer to the task which executes this component, is invalid
+	//! before setTaskIF was called.
+	PeriodicTaskIF* executingTask = nullptr;
 
 	static object_id_t powerSwitcherId; //!< Object which switches power on and off.
 
 	static object_id_t rawDataReceiverId; //!< Object which receives RAW data by default.
 
-	static object_id_t defaultFDIRParentId; //!< Object which may be the root cause of an identified fault.
+	static object_id_t defaultFdirParentId; //!< Object which may be the root cause of an identified fault.
 	/**
 	 * Helper function to report a missed reply
 	 *
@@ -730,28 +760,40 @@ protected:
 	/**
 	 * Do the transition to the main modes (MODE_ON, MODE_NORMAL and MODE_RAW).
 	 *
-	 * If the transition is complete, the mode should be set to the target mode, which can be deduced from the current mode which is
+	 * If the transition is complete, the mode should be set to the target mode,
+	 * which can be deduced from the current mode which is
 	 * [_MODE_TO_ON, _MODE_TO_NORMAL, _MODE_TO_RAW]
 	 *
-	 * The intended target submode is already set. The origin submode can be read in subModeFrom.
+	 * The intended target submode is already set.
+	 * The origin submode can be read in subModeFrom.
 	 *
-	 * If the transition can not be completed, the child class can try to reach an working mode by setting the mode either directly
-	 * or setting the mode to an transitional mode (TO_ON, TO_NORMAL, TO_RAW) if the device needs to be reconfigured.
+	 * If the transition can not be completed, the child class can try to reach
+	 * an working mode by setting the mode either directly
+	 * or setting the mode to an transitional mode (TO_ON, TO_NORMAL, TO_RAW)
+	 * if the device needs to be reconfigured.
 	 *
-	 * If nothing works, the child class can wait for the timeout and the base class will reset the mode to the mode where the transition
+	 * If nothing works, the child class can wait for the timeout and the base
+	 * class will reset the mode to the mode where the transition
 	 * originated from (the child should report the reason for the failed transition).
 	 *
-	 * The intended way to send commands is to set a flag (enum) indicating which command is to be sent here
-	 * and then to check in buildTransitionCommand() for the flag. This flag can also be used by doStartUp() and
-	 * doShutDown() to get a nice and clean implementation of buildTransitionCommand() without switching through modes.
+	 * The intended way to send commands is to set a flag (enum) indicating
+	 * which command is to be sent here and then to check in
+	 * buildTransitionCommand() for the flag. This flag can also be used by
+	 * doStartUp() and doShutDown() to get a nice and clean implementation of
+	 * buildTransitionCommand() without switching through modes.
 	 *
-	 * When the the condition for the completion of the transition is met, the mode can be set, for example in the parseReply() function.
+	 * When the the condition for the completion of the transition is met, the
+	 * mode can be set, for example in the scanForReply() function.
 	 *
-	 * The default implementation goes into the target mode;
+	 * The default implementation goes into the target mode directly.
 	 *
-	 * #transitionFailure can be set to a failure code indicating the reason for a failed transition
+	 * #transitionFailure can be set to a failure code indicating the reason
+	 * for a failed transition
 	 *
-	 * @param modeFrom the mode the transition originated from: [MODE_ON, MODE_NORMAL, MODE_RAW and _MODE_POWER_DOWN (if the mode changed from _MODE_START_UP to _MODE_TO_ON)]
+	 * @param modeFrom
+	 * The mode the transition originated from:
+	 * [MODE_ON, MODE_NORMAL, MODE_RAW and _MODE_POWER_DOWN (if the mode changed
+	 * from _MODE_START_UP to _MODE_TO_ON)]
 	 * @param subModeFrom the subMode of modeFrom
 	 */
 	virtual void doTransition(Mode_t modeFrom, Submode_t subModeFrom);
@@ -953,24 +995,11 @@ protected:
 	bool commandIsExecuting(DeviceCommandId_t commandId);
 
 	/**
-	 * This map is used to check and track correct reception of all replies.
+	 * set all switches returned by getSwitches()
 	 *
-	 * It has multiple use:
-	 * - it stores the information on pending replies. If a command is sent, the DeviceCommandInfo.count is incremented.
-	 * - it is used to time-out missing replies. If a command is sent, the DeviceCommandInfo.DelayCycles is set to MaxDelayCycles.
-	 * - it is queried to check if a reply from the device can be interpreted. scanForReply() returns the id of the command a reply was found for.
-	 * The reply is ignored in the following cases:
-	 *     - No entry for the returned id was found
-	 *     - The deviceReplyInfo.delayCycles is == 0
+	 * @param onOff on == @c SWITCH_ON; off != @c SWITCH_ON
 	 */
-	DeviceReplyMap deviceReplyMap;
-
-	/**
-	 * Information about commands
-	 */
-	DeviceCommandMap deviceCommandMap;
-
-	ActionHelper actionHelper;
+	void commandSwitch(ReturnValue_t onOff);
 private:
 
 	/**
@@ -997,15 +1026,16 @@ private:
 	};
 
 	/**
-	 * Info about the #cookie
-	 *
+	 * @brief   Info about the #cookie
 	 * Used to track the state of the communication
 	 */
 	CookieInfo cookieInfo;
 
+	/** the object used to set power switches */
+	PowerSwitchIF *powerSwitcher = nullptr;
+
 	/**
-	 * Used for timing out mode transitions.
-	 *
+	 * @brief   Used for timing out mode transitions.
 	 * Set when setMode() is called.
 	 */
 	uint32_t timeoutStart = 0;
@@ -1016,11 +1046,12 @@ private:
 	uint32_t childTransitionDelay;
 
 	/**
-	 * The mode the current transition originated from
+	 * @brief   The mode the current transition originated from
 	 *
 	 * This is private so the child can not change it and fuck up the timeouts
 	 *
-	 * IMPORTANT: This is not valid during _MODE_SHUT_DOWN and _MODE_START_UP!! (it is _MODE_POWER_DOWN during this modes)
+	 * IMPORTANT: This is not valid during _MODE_SHUT_DOWN and _MODE_START_UP!!
+	 * (it is _MODE_POWER_DOWN during this modes)
 	 *
 	 * is element of [MODE_ON, MODE_NORMAL, MODE_RAW]
 	 */
@@ -1031,13 +1062,6 @@ private:
 	 */
 	Submode_t transitionSourceSubMode;
 
-	/**
-	 * the switch of the device
-	 *
-	 * for devices using two switches override getSwitches()
-	 */
-	const uint8_t deviceSwitch;
-
 	/**
 	 * read the command queue
 	 */
@@ -1135,12 +1159,6 @@ private:
 	ReturnValue_t getStorageData(store_address_t storageAddress, uint8_t **data,
 			uint32_t *len);
 
-	/**
-	 * set all switches returned by getSwitches()
-	 *
-	 * @param onOff on == @c SWITCH_ON; off != @c SWITCH_ON
-	 */
-	void commandSwitch(ReturnValue_t onOff);
 
 	/**
 	 * @param modeTo either @c MODE_ON, MODE_NORMAL or MODE_RAW NOTHING ELSE!!!
@@ -1165,7 +1183,12 @@ private:
 	ReturnValue_t switchCookieChannel(object_id_t newChannelId);
 
 	ReturnValue_t handleDeviceHandlerMessage(CommandMessage *message);
+
+	virtual ReturnValue_t initializeAfterTaskCreation() override;
+
+	void parseReply(const uint8_t* receivedData,
+	            size_t receivedDataLen);
 };
 
-#endif /* DEVICEHANDLERBASE_H_ */
+#endif /* FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */
 

devicehandlers/DeviceHandlerFailureIsolation.cpp

@@ -1,19 +1,27 @@
-#include "DeviceHandlerBase.h"
 #include "DeviceHandlerFailureIsolation.h"
+
+#include "../devicehandlers/DeviceHandlerIF.h"
+#include "../modes/HasModesIF.h"
 #include "../health/HealthTableIF.h"
 #include "../power/Fuse.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../thermal/ThermalComponentIF.h"
 
-object_id_t DeviceHandlerFailureIsolation::powerConfirmationId = 0;
+object_id_t DeviceHandlerFailureIsolation::powerConfirmationId =
+        objects::NO_OBJECT;
 
-DeviceHandlerFailureIsolation::DeviceHandlerFailureIsolation(object_id_t owner, object_id_t parent) :
-		FailureIsolationBase(owner, parent), strangeReplyCount(MAX_STRANGE_REPLIES,
-				STRANGE_REPLIES_TIME_MS, parameterDomainBase++), missedReplyCount(
-				MAX_MISSED_REPLY_COUNT, MISSED_REPLY_TIME_MS,
-				parameterDomainBase++), recoveryCounter(MAX_REBOOT,
-				REBOOT_TIME_MS, parameterDomainBase++), fdirState(NONE), powerConfirmation(
-				0) {
+DeviceHandlerFailureIsolation::DeviceHandlerFailureIsolation(object_id_t owner,
+		object_id_t parent) :
+		FailureIsolationBase(owner, parent),
+		strangeReplyCount(DEFAULT_MAX_STRANGE_REPLIES,
+		        DEFAULT_STRANGE_REPLIES_TIME_MS,
+				parameterDomainBase++),
+		missedReplyCount( DEFAULT_MAX_MISSED_REPLY_COUNT,
+		        DEFAULT_MISSED_REPLY_TIME_MS,
+				parameterDomainBase++),
+		recoveryCounter(DEFAULT_MAX_REBOOT, DEFAULT_REBOOT_TIME_MS,
+		        parameterDomainBase++),
+		fdirState(NONE) {
 }
 
 DeviceHandlerFailureIsolation::~DeviceHandlerFailureIsolation() {
@@ -68,9 +76,11 @@ ReturnValue_t DeviceHandlerFailureIsolation::eventReceived(EventMessage* event)
 		break;
 		//****Power*****
 	case PowerSwitchIF::SWITCH_WENT_OFF:
-		result = sendConfirmationRequest(event, powerConfirmation);
-		if (result == RETURN_OK) {
-			setFdirState(DEVICE_MIGHT_BE_OFF);
+		if(powerConfirmation != MessageQueueIF::NO_QUEUE) {
+			result = sendConfirmationRequest(event, powerConfirmation);
+			if (result == RETURN_OK) {
+				setFdirState(DEVICE_MIGHT_BE_OFF);
+			}
 		}
 		break;
 	case Fuse::FUSE_WENT_OFF:
@@ -133,7 +143,7 @@ void DeviceHandlerFailureIsolation::decrementFaultCounters() {
 
 void DeviceHandlerFailureIsolation::handleRecovery(Event reason) {
 	clearFaultCounters();
-	if (!recoveryCounter.incrementAndCheck()) {
+	if (not recoveryCounter.incrementAndCheck()) {
 		startRecovery(reason);
 	} else {
 		setFaulty(reason);
@@ -142,7 +152,8 @@ void DeviceHandlerFailureIsolation::handleRecovery(Event reason) {
 
 void DeviceHandlerFailureIsolation::wasParentsFault(EventMessage* event) {
 	//We'll better ignore the SWITCH_WENT_OFF event and await a system-wide reset.
-	//This means, no fault message will come through until a MODE_ or HEALTH_INFO message comes through -> Is that ok?
+	//This means, no fault message will come through until a MODE_ or
+	//HEALTH_INFO message comes through -> Is that ok?
 	//Same issue in TxFailureIsolation!
 //	if ((event->getEvent() == PowerSwitchIF::SWITCH_WENT_OFF)
 //			&& (fdirState != RECOVERY_ONGOING)) {
@@ -158,14 +169,16 @@ void DeviceHandlerFailureIsolation::clearFaultCounters() {
 ReturnValue_t DeviceHandlerFailureIsolation::initialize() {
 	ReturnValue_t result = FailureIsolationBase::initialize();
 	if (result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "DeviceHandlerFailureIsolation::initialize: Could not"
+				" initialize FailureIsolationBase." << std::endl;
 		return result;
 	}
 	ConfirmsFailuresIF* power = objectManager->get<ConfirmsFailuresIF>(
 			powerConfirmationId);
-	if (power == NULL) {
-		return RETURN_FAILED;
+	if (power != nullptr) {
+		powerConfirmation = power->getEventReceptionQueue();
 	}
-	powerConfirmation = power->getEventReceptionQueue();
+
 	return RETURN_OK;
 }
 

devicehandlers/DeviceHandlerFailureIsolation.h

@@ -1,13 +1,13 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_
-#define FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_
+#ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_
+#define FSFW_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_
 
 #include "../fdir/FaultCounter.h"
 #include "../fdir/FailureIsolationBase.h"
+
 namespace Factory{
 void setStaticFrameworkObjectIds();
 }
 
-
 class DeviceHandlerFailureIsolation: public FailureIsolationBase {
 	friend void (Factory::setStaticFrameworkObjectIds)();
 	friend class Heater;
@@ -20,22 +20,27 @@ public:
 	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 			ParameterWrapper *parameterWrapper,
 			const ParameterWrapper *newValues, uint16_t startAtIndex);
+
 protected:
 	FaultCounter strangeReplyCount;
 	FaultCounter missedReplyCount;
 	FaultCounter recoveryCounter;
+
 	enum FDIRState {
 		NONE, RECOVERY_ONGOING, DEVICE_MIGHT_BE_OFF, AWAIT_SHUTDOWN
 	};
 	FDIRState fdirState;
-	MessageQueueId_t powerConfirmation;
+
+	MessageQueueId_t powerConfirmation = MessageQueueIF::NO_QUEUE;
 	static object_id_t powerConfirmationId;
-	static const uint32_t MAX_REBOOT = 1;
-	static const uint32_t REBOOT_TIME_MS = 180000;
-	static const uint32_t MAX_STRANGE_REPLIES = 10;
-	static const uint32_t STRANGE_REPLIES_TIME_MS = 10000;
-	static const uint32_t MAX_MISSED_REPLY_COUNT = 5;
-	static const uint32_t MISSED_REPLY_TIME_MS = 10000;
+
+	static const uint32_t DEFAULT_MAX_REBOOT = 1;
+	static const uint32_t DEFAULT_REBOOT_TIME_MS = 180000;
+	static const uint32_t DEFAULT_MAX_STRANGE_REPLIES = 10;
+	static const uint32_t DEFAULT_STRANGE_REPLIES_TIME_MS = 10000;
+	static const uint32_t DEFAULT_MAX_MISSED_REPLY_COUNT = 5;
+	static const uint32_t DEFAULT_MISSED_REPLY_TIME_MS = 10000;
+
 	virtual ReturnValue_t eventReceived(EventMessage* event);
 	virtual void eventConfirmed(EventMessage* event);
 	void wasParentsFault(EventMessage* event);
@@ -49,4 +54,4 @@ protected:
 	bool isFdirInActionOrAreWeFaulty(EventMessage* event);
 };
 
-#endif /* FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_ */
+#endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_ */

devicehandlers/DeviceHandlerMessage.h

@@ -25,7 +25,7 @@ public:
 	/**
 	 * These are the commands that can be sent to a DeviceHandlerBase
 	 */
-	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::DEVICE_HANDLER_COMMAND;
+	static const uint8_t MESSAGE_ID = messagetypes::DEVICE_HANDLER_COMMAND;
 	static const Command_t CMD_RAW = MAKE_COMMAND_ID( 1 ); //!< Sends a raw command, setParameter is a ::store_id_t containing the raw packet to send
 //	static const Command_t CMD_DIRECT = MAKE_COMMAND_ID( 2 ); //!< Sends a direct command, setParameter is a ::DeviceCommandId_t, setParameter2 is a ::store_id_t containing the data needed for the command
 	static const Command_t CMD_SWITCH_IOBOARD = MAKE_COMMAND_ID( 3 ); //!< Requests a IO-Board switch, setParameter() is the IO-Board identifier

events/EventManager.cpp

@@ -8,13 +8,16 @@
 const uint16_t EventManager::POOL_SIZES[N_POOLS] = {
 		sizeof(EventMatchTree::Node), sizeof(EventIdRangeMatcher),
 		sizeof(ReporterRangeMatcher) };
-//If one checks registerListener calls, there are around 40 (to max 50) objects registering for certain events.
-//Each listener requires 1 or 2 EventIdMatcher and 1 or 2 ReportRangeMatcher. So a good guess is 75 to a max of 100 pools required for each, which fits well.
+// If one checks registerListener calls, there are around 40 (to max 50)
+// objects registering for certain events.
+// Each listener requires 1 or 2 EventIdMatcher and 1 or 2 ReportRangeMatcher.
+// So a good guess is 75 to a max of 100 pools required for each, which fits well.
+// SHOULDDO: Shouldn't this be in the config folder and passed via ctor?
 const uint16_t EventManager::N_ELEMENTS[N_POOLS] = { 240, 120, 120 };
 
 EventManager::EventManager(object_id_t setObjectId) :
-		SystemObject(setObjectId), eventReportQueue(NULL), mutex(NULL), factoryBackend(
-				0, POOL_SIZES, N_ELEMENTS, false, true) {
+		SystemObject(setObjectId),
+		factoryBackend(0, POOL_SIZES, N_ELEMENTS, false, true) {
 	mutex = MutexFactory::instance()->createMutex();
 	eventReportQueue = QueueFactory::instance()->createMessageQueue(
 			MAX_EVENTS_PER_CYCLE, EventMessage::EVENT_MESSAGE_SIZE);
@@ -108,41 +111,45 @@ ReturnValue_t EventManager::unsubscribeFromEventRange(MessageQueueId_t listener,
 
 #ifdef DEBUG
 
-//forward declaration, should be implemented by mission
-const char* translateObject(object_id_t object);
-const char * translateEvents(Event event);
-
 void EventManager::printEvent(EventMessage* message) {
 	const char *string = 0;
 	switch (message->getSeverity()) {
 	case SEVERITY::INFO:
-//		string = translateObject(message->getReporter());
-//		sif::info << "EVENT: ";
-//		if (string != 0) {
-//			sif::info << string;
-//		} else {
-//			sif::info << "0x" << std::hex << message->getReporter() << std::dec;
-//		}
-//		sif::info << " reported " << translateEvents(message->getEvent()) << " ("
-//				<< std::dec << message->getEventId() << std::hex << ") P1: 0x"
-//				<< message->getParameter1() << " P2: 0x"
-//				<< message->getParameter2() << std::dec << std::endl;
-		break;
-	default:
+#ifdef DEBUG_INFO_EVENT
 		string = translateObject(message->getReporter());
-		sif::error << "EVENT: ";
+		sif::info << "EVENT: ";
 		if (string != 0) {
-			sif::error << string;
+			sif::info << string;
 		} else {
-			sif::error << "0x" << std::hex << message->getReporter() << std::dec;
+			sif::info << "0x" << std::hex << message->getReporter() << std::dec;
 		}
-		sif::error << " reported " << translateEvents(message->getEvent()) << " ("
+		sif::info << " reported " << translateEvents(message->getEvent()) << " ("
 				<< std::dec << message->getEventId() << std::hex << ") P1: 0x"
 				<< message->getParameter1() << " P2: 0x"
 				<< message->getParameter2() << std::dec << std::endl;
+#endif
+		break;
+	default:
+		string = translateObject(message->getReporter());
+		sif::debug << "EventManager: ";
+		if (string != 0) {
+			sif::debug << string;
+		}
+		else {
+			sif::debug << "0x" << std::hex << message->getReporter() << std::dec;
+		}
+		sif::debug << " reported " << translateEvents(message->getEvent())
+				<< " (" << std::dec << message->getEventId() << ") "
+				<< std::endl;
+
+		sif::debug << std::hex << "P1 Hex: 0x" << message->getParameter1()
+				<< ", P1 Dec: " << std::dec << message->getParameter1()
+				<< std::endl;
+		sif::debug << std::hex << "P2 Hex: 0x" << message->getParameter2()
+				<< ", P2 Dec: " <<  std::dec << message->getParameter2()
+				<< std::endl;
 		break;
 	}
-
 }
 #endif
 

events/EventManager.h

@@ -10,6 +10,12 @@
 #include "../ipc/MutexIF.h"
 #include <map>
 
+#ifdef DEBUG
+// forward declaration, should be implemented by mission
+extern const char* translateObject(object_id_t object);
+extern const char* translateEvents(Event event);
+#endif
+
 class EventManager: public EventManagerIF,
 		public ExecutableObjectIF,
 		public SystemObject {
@@ -36,11 +42,11 @@ public:
 	ReturnValue_t performOperation(uint8_t opCode);
 protected:
 
-	MessageQueueIF* eventReportQueue;
+	MessageQueueIF* eventReportQueue = nullptr;
 
 	std::map<MessageQueueId_t, EventMatchTree> listenerList;
 
-	MutexIF* mutex;
+	MutexIF* mutex = nullptr;
 
 	static const uint8_t N_POOLS = 3;
 	LocalPool<N_POOLS> factoryBackend;

fdir/FailureIsolationBase.cpp

@@ -5,10 +5,12 @@
 #include "../ipc/QueueFactory.h"
 #include "../objectmanager/ObjectManagerIF.h"
 
-FailureIsolationBase::FailureIsolationBase(object_id_t owner, object_id_t parent, uint8_t messageDepth, uint8_t parameterDomainBase) :
-		eventQueue(NULL), ownerId(
-				owner), owner(NULL), faultTreeParent(parent), parameterDomainBase(parameterDomainBase) {
-	eventQueue = QueueFactory::instance()->createMessageQueue(messageDepth, EventMessage::EVENT_MESSAGE_SIZE);
+FailureIsolationBase::FailureIsolationBase(object_id_t owner,
+		object_id_t parent, uint8_t messageDepth, uint8_t parameterDomainBase) :
+		ownerId(owner), faultTreeParent(parent),
+		parameterDomainBase(parameterDomainBase) {
+	eventQueue = QueueFactory::instance()->createMessageQueue(messageDepth,
+			EventMessage::EVENT_MESSAGE_SIZE);
 }
 
 FailureIsolationBase::~FailureIsolationBase() {
@@ -18,27 +20,36 @@ FailureIsolationBase::~FailureIsolationBase() {
 ReturnValue_t FailureIsolationBase::initialize() {
 	EventManagerIF* manager = objectManager->get<EventManagerIF>(
 			objects::EVENT_MANAGER);
-	if (manager == NULL) {
+	if (manager == nullptr) {
+		sif::error << "FailureIsolationBase::initialize: Event Manager has not"
+				" been initialized!" << std::endl;
 		return RETURN_FAILED;
 	}
 	ReturnValue_t result = manager->registerListener(eventQueue->getId());
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	if (ownerId != 0) {
+	if (ownerId != objects::NO_OBJECT) {
 		result = manager->subscribeToAllEventsFrom(eventQueue->getId(), ownerId);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		owner = objectManager->get<HasHealthIF>(ownerId);
-		if (owner == NULL) {
-			return RETURN_FAILED;
+		if (owner == nullptr) {
+			sif::error << "FailureIsolationBase::intialize: Owner object "
+					"invalid. Make sure it implements HasHealthIF" << std::endl;
+			return ObjectManagerIF::CHILD_INIT_FAILED;
 		}
 	}
-	if (faultTreeParent != 0) {
+	if (faultTreeParent != objects::NO_OBJECT) {
 		ConfirmsFailuresIF* parentIF = objectManager->get<ConfirmsFailuresIF>(
 				faultTreeParent);
-		if (parentIF == NULL) {
+		if (parentIF == nullptr) {
+			sif::error << "FailureIsolationBase::intialize: Parent object"
+					<< "invalid." << std::endl;
+			sif::error << "Make sure it implements ConfirmsFailuresIF."
+					<< std::endl;
+			return ObjectManagerIF::CHILD_INIT_FAILED;
 			return RETURN_FAILED;
 		}
 		eventQueue->setDefaultDestination(parentIF->getEventReceptionQueue());
@@ -93,9 +104,9 @@ MessageQueueId_t FailureIsolationBase::getEventReceptionQueue() {
 ReturnValue_t FailureIsolationBase::sendConfirmationRequest(EventMessage* event,
 		MessageQueueId_t destination) {
 	event->setMessageId(EventMessage::CONFIRMATION_REQUEST);
-	if (destination != 0) {
+	if (destination != MessageQueueIF::NO_QUEUE) {
 		return eventQueue->sendMessage(destination, event);
-	} else if (faultTreeParent != 0) {
+	} else if (faultTreeParent != objects::NO_OBJECT) {
 		return eventQueue->sendToDefault(event);
 	}
 	return RETURN_FAILED;

fdir/FailureIsolationBase.h

@@ -17,18 +17,25 @@ public:
 	static const Event FDIR_CHANGED_STATE = MAKE_EVENT(1, SEVERITY::INFO); //!< FDIR has an internal state, which changed from par2 (oldState) to par1 (newState).
 	static const Event FDIR_STARTS_RECOVERY = MAKE_EVENT(2, SEVERITY::MEDIUM); //!< FDIR tries to restart device. Par1: event that caused recovery.
 	static const Event FDIR_TURNS_OFF_DEVICE = MAKE_EVENT(3, SEVERITY::MEDIUM); //!< FDIR turns off device. Par1: event that caused recovery.
-	FailureIsolationBase(object_id_t owner, object_id_t parent = 0,
+
+	FailureIsolationBase(object_id_t owner,
+			object_id_t parent = objects::NO_OBJECT,
 			uint8_t messageDepth = 10, uint8_t parameterDomainBase = 0xF0);
+
 	virtual ~FailureIsolationBase();
 	virtual ReturnValue_t initialize();
+
+	/**
+	 * This is called by the DHB in performOperation()
+	 */
 	void checkForFailures();
-	MessageQueueId_t getEventReceptionQueue();
+	MessageQueueId_t getEventReceptionQueue() override;
 	virtual void triggerEvent(Event event, uint32_t parameter1 = 0,
 			uint32_t parameter2 = 0);
 protected:
-	MessageQueueIF* eventQueue;
+	MessageQueueIF* eventQueue = nullptr;
 	object_id_t ownerId;
-	HasHealthIF* owner;
+	HasHealthIF* owner = nullptr;
 	object_id_t faultTreeParent;
 	uint8_t parameterDomainBase;
 	void setOwnerHealth(HasHealthIF::HealthState health);
@@ -38,7 +45,7 @@ protected:
 	virtual ReturnValue_t confirmFault(EventMessage* event);
 	virtual void decrementFaultCounters() = 0;
 	ReturnValue_t sendConfirmationRequest(EventMessage* event,
-			MessageQueueId_t destination = 0);
+			MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
 	void throwFdirEvent(Event event, uint32_t parameter1 = 0,
 			uint32_t parameter2 = 0);
 private:

globalfunctions/DleEncoder.cpp

@@ -1,95 +1,124 @@
-#include "DleEncoder.h"
+#include "../globalfunctions/DleEncoder.h"
 
-DleEncoder::DleEncoder() {
-}
+DleEncoder::DleEncoder() {}
 
-DleEncoder::~DleEncoder() {
+DleEncoder::~DleEncoder() {}
+
+ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
+		size_t sourceLen, uint8_t* destStream, size_t maxDestLen,
+		size_t* encodedLen, bool addStxEtx) {
+	if (maxDestLen < 2) {
+		return STREAM_TOO_SHORT;
+	}
+	size_t encodedIndex = 0, sourceIndex = 0;
+	uint8_t nextByte;
+	if (addStxEtx) {
+		destStream[0] = STX_CHAR;
+		++encodedIndex;
+	}
+
+	while (encodedIndex < maxDestLen and sourceIndex < sourceLen)
+	{
+		nextByte = sourceStream[sourceIndex];
+		// STX, ETX and CR characters in the stream need to be escaped with DLE
+		if (nextByte == STX_CHAR or nextByte == ETX_CHAR or nextByte == CARRIAGE_RETURN) {
+			if (encodedIndex + 1 >= maxDestLen) {
+				return STREAM_TOO_SHORT;
+			}
+			else {
+				destStream[encodedIndex] = DLE_CHAR;
+				++encodedIndex;
+				/* Escaped byte will be actual byte + 0x40. This prevents
+				 * STX, ETX, and carriage return characters from appearing
+				 * in the encoded data stream at all, so when polling an
+				 * encoded stream, the transmission can be stopped at ETX.
+				 * 0x40 was chosen at random with special requirements:
+				 *  - Prevent going from one control char to another
+				 *  - Prevent overflow for common characters */
+				destStream[encodedIndex] = nextByte + 0x40;
+			}
+		}
+		// DLE characters are simply escaped with DLE.
+		else if (nextByte == DLE_CHAR) {
+			if (encodedIndex + 1 >= maxDestLen) {
+			    return STREAM_TOO_SHORT;
+			}
+			else {
+				destStream[encodedIndex] = DLE_CHAR;
+				++encodedIndex;
+				destStream[encodedIndex] = DLE_CHAR;
+			}
+		}
+		else {
+			destStream[encodedIndex] = nextByte;
+		}
+		++encodedIndex;
+		++sourceIndex;
+	}
+
+	if (sourceIndex == sourceLen and encodedIndex < maxDestLen) {
+		if (addStxEtx) {
+			destStream[encodedIndex] = ETX_CHAR;
+			++encodedIndex;
+		}
+		*encodedLen = encodedIndex;
+		return RETURN_OK;
+	}
+	else {
+		return STREAM_TOO_SHORT;
+	}
 }
 
 ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
-		uint32_t sourceStreamLen, uint32_t *readLen, uint8_t *destStream,
-		uint32_t maxDestStreamlen, uint32_t *decodedLen) {
-	uint32_t encodedIndex = 0, decodedIndex = 0;
+		size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
+		size_t maxDestStreamlen, size_t *decodedLen) {
+	size_t encodedIndex = 0, decodedIndex = 0;
 	uint8_t nextByte;
-	if (*sourceStream != STX) {
-		return RETURN_FAILED;
+	if (*sourceStream != STX_CHAR) {
+		return DECODING_ERROR;
 	}
 	++encodedIndex;
+
 	while ((encodedIndex < sourceStreamLen) && (decodedIndex < maxDestStreamlen)
-			&& (sourceStream[encodedIndex] != ETX)
-			&& (sourceStream[encodedIndex] != STX)) {
-		if (sourceStream[encodedIndex] == DLE) {
+			&& (sourceStream[encodedIndex] != ETX_CHAR)
+			&& (sourceStream[encodedIndex] != STX_CHAR)) {
+		if (sourceStream[encodedIndex] == DLE_CHAR) {
 			nextByte = sourceStream[encodedIndex + 1];
-			if (nextByte == 0x10) {
+			// The next byte is a DLE character that was escaped by another
+			// DLE character, so we can write it to the destination stream.
+			if (nextByte == DLE_CHAR) {
 				destStream[decodedIndex] = nextByte;
-			} else {
-				if ((nextByte == 0x42) || (nextByte == 0x43)
-						|| (nextByte == 0x4D)) {
+			}
+			else {
+			    /* The next byte is a STX, DTX or 0x0D character which
+			     * was escaped by a DLE character. The actual byte was
+				 * also encoded by adding + 0x40 to prevent having control chars,
+				 * in the stream at all, so we convert it back. */
+				if (nextByte == 0x42 or nextByte == 0x43 or nextByte == 0x4D) {
 					destStream[decodedIndex] = nextByte - 0x40;
-				} else {
-					return RETURN_FAILED;
+				}
+				else {
+				    return DECODING_ERROR;
 				}
 			}
 			++encodedIndex;
-		} else {
+		}
+		else {
 			destStream[decodedIndex] = sourceStream[encodedIndex];
 		}
+
 		++encodedIndex;
 		++decodedIndex;
 	}
-	if (sourceStream[encodedIndex] != ETX) {
-		return RETURN_FAILED;
-	} else {
+
+	if (sourceStream[encodedIndex] != ETX_CHAR) {
+		*readLen = ++encodedIndex;
+		return DECODING_ERROR;
+	}
+	else {
 		*readLen = ++encodedIndex;
 		*decodedLen = decodedIndex;
 		return RETURN_OK;
 	}
 }
 
-ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
-		uint32_t sourceLen, uint8_t* destStream, uint32_t maxDestLen,
-		uint32_t* encodedLen, bool addStxEtx) {
-	if (maxDestLen < 2) {
-		return RETURN_FAILED;
-	}
-	uint32_t encodedIndex = 0, sourceIndex = 0;
-	uint8_t nextByte;
-	if (addStxEtx) {
-		destStream[0] = STX;
-		++encodedIndex;
-	}
-	while ((encodedIndex < maxDestLen) && (sourceIndex < sourceLen)) {
-		nextByte = sourceStream[sourceIndex];
-		if ((nextByte == STX) || (nextByte == ETX) || (nextByte == 0x0D)) {
-			if (encodedIndex + 1 >= maxDestLen) {
-				return RETURN_FAILED;
-			} else {
-				destStream[encodedIndex] = DLE;
-				++encodedIndex;
-				destStream[encodedIndex] = nextByte + 0x40;
-			}
-		} else if (nextByte == DLE) {
-			if (encodedIndex + 1 >= maxDestLen) {
-				return RETURN_FAILED;
-			} else {
-				destStream[encodedIndex] = DLE;
-				++encodedIndex;
-				destStream[encodedIndex] = DLE;
-			}
-		} else {
-			destStream[encodedIndex] = nextByte;
-		}
-		++encodedIndex;
-		++sourceIndex;
-	}
-	if ((sourceIndex == sourceLen) && (encodedIndex < maxDestLen)) {
-		if (addStxEtx) {
-			destStream[encodedIndex] = ETX;
-			++encodedIndex;
-		}
-		*encodedLen = encodedIndex;
-		return RETURN_OK;
-	} else {
-		return RETURN_FAILED;
-	}
-}

globalfunctions/DleEncoder.h

@@ -1,25 +1,79 @@
-#ifndef DLEENCODER_H_
-#define DLEENCODER_H_
+#ifndef FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_
+#define FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstddef>
 
+/**
+ * @brief   This DLE Encoder (Data Link Encoder) can be used to encode and
+ *          decode arbitrary data with ASCII control characters
+ * @details
+ * List of control codes:
+ * https://en.wikipedia.org/wiki/C0_and_C1_control_codes
+ *
+ * This encoder can be used to achieve a basic transport layer when using
+ * char based transmission systems.
+ * The passed source strean is converted into a encoded stream by adding
+ * a STX marker at the start of the stream and an ETX marker at the end of
+ * the stream. Any STX, ETX, DLE and CR occurrences in the source stream are
+ * escaped by a DLE character. The encoder also replaces escaped control chars
+ * by another char, so STX, ETX and CR should not appear anywhere in the actual
+ * encoded data stream.
+ *
+ * When using a strictly char based reception of packets encoded with DLE,
+ * STX can be used to notify a reader that actual data will start to arrive
+ * while ETX can be used to notify the reader that the data has ended.
+ */
 class DleEncoder: public HasReturnvaluesIF {
 private:
 	DleEncoder();
 	virtual ~DleEncoder();
 
 public:
-	static const uint8_t STX = 0x02;
-	static const uint8_t ETX = 0x03;
-	static const uint8_t DLE = 0x10;
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::DLE_ENCODER;
+	static constexpr ReturnValue_t STREAM_TOO_SHORT = MAKE_RETURN_CODE(0x01);
+	static constexpr ReturnValue_t DECODING_ERROR = MAKE_RETURN_CODE(0x02);
 
+	//! Start Of Text character. First character is encoded stream
+	static constexpr uint8_t STX_CHAR = 0x02;
+	//! End Of Text character. Last character in encoded stream
+	static constexpr uint8_t ETX_CHAR = 0x03;
+	//! Data Link Escape character. Used to escape STX, ETX and DLE occurrences
+	//! in the source stream.
+	static constexpr uint8_t DLE_CHAR = 0x10;
+	static constexpr uint8_t CARRIAGE_RETURN = 0x0D;
+
+    /**
+     * Encodes the give data stream by preceding it with the STX marker
+     * and ending it with an ETX marker. STX, ETX and DLE characters inside
+     * the stream are escaped by DLE characters and also replaced by adding
+     * 0x40 (which is reverted in the decoding process).
+     * @param sourceStream
+     * @param sourceLen
+     * @param destStream
+     * @param maxDestLen
+     * @param encodedLen
+     * @param addStxEtx
+     * Adding STX and ETX can be omitted, if they are added manually.
+     * @return
+     */
+    static ReturnValue_t encode(const uint8_t *sourceStream, size_t sourceLen,
+            uint8_t *destStream, size_t maxDestLen, size_t *encodedLen,
+            bool addStxEtx = true);
+
+    /**
+     * Converts an encoded stream back.
+     * @param sourceStream
+     * @param sourceStreamLen
+     * @param readLen
+     * @param destStream
+     * @param maxDestStreamlen
+     * @param decodedLen
+     * @return
+     */
 	static ReturnValue_t decode(const uint8_t *sourceStream,
-			uint32_t sourceStreamLen, uint32_t *readLen, uint8_t *destStream,
-			uint32_t maxDestStreamlen, uint32_t *decodedLen);
-
-	static ReturnValue_t encode(const uint8_t *sourceStream, uint32_t sourceLen,
-			uint8_t *destStream, uint32_t maxDestLen, uint32_t *encodedLen,
-			bool addStxEtx = true);
+			size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
+			size_t maxDestStreamlen, size_t *decodedLen);
 };
 
-#endif /* DLEENCODER_H_ */
+#endif /* FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_ */

globalfunctions/PeriodicOperationDivider.cpp

@@ -0,0 +1,34 @@
+#include "PeriodicOperationDivider.h"
+
+
+PeriodicOperationDivider::PeriodicOperationDivider(uint32_t divider,
+		bool resetAutomatically): resetAutomatically(resetAutomatically),
+		counter(divider), divider(divider) {
+}
+
+bool PeriodicOperationDivider::checkAndIncrement() {
+	if(counter >= divider) {
+		if(resetAutomatically) {
+			counter = 0;
+		}
+		return true;
+	}
+	counter ++;
+	return false;
+}
+
+void PeriodicOperationDivider::resetCounter() {
+	counter = 0;
+}
+
+void PeriodicOperationDivider::setDivider(uint32_t newDivider) {
+	divider = newDivider;
+}
+
+uint32_t PeriodicOperationDivider::getCounter() const {
+	return counter;
+}
+
+uint32_t PeriodicOperationDivider::getDivider() const {
+	return divider;
+}

globalfunctions/PeriodicOperationDivider.h

@@ -0,0 +1,55 @@
+#ifndef FSFW_GLOBALFUNCTIONS_PERIODICOPERATIONDIVIDER_H_
+#define FSFW_GLOBALFUNCTIONS_PERIODICOPERATIONDIVIDER_H_
+
+#include <cstdint>
+
+/**
+ * @brief	Lightweight helper class to facilitate periodic operation with
+ * 			decreased frequencies.
+ * @details
+ * This class is useful to perform operations which have to be performed
+ * with a reduced frequency, like debugging printouts in high periodic tasks
+ * or low priority operations.
+ */
+class PeriodicOperationDivider {
+public:
+	/**
+	 * Initialize with the desired divider and specify whether the internal
+	 * counter will be reset automatically.
+	 * @param divider
+	 * @param resetAutomatically
+	 */
+	PeriodicOperationDivider(uint32_t divider, bool resetAutomatically = true);
+
+	/**
+	 * Check whether operation is necessary.
+	 * If an operation is necessary and the class has been
+	 * configured to be reset automatically, the counter will be reset.
+	 * If not, the counter will be incremented.
+	 * @return
+	 * -@c true if the counter is larger or equal to the divider
+	 * -@c false otherwise
+	 */
+	bool checkAndIncrement();
+
+	/**
+	 * Can be used to reset the counter to 0 manually.
+	 */
+	void resetCounter();
+	uint32_t getCounter() const;
+
+	/**
+	 * Can be used to set a new divider value.
+	 * @param newDivider
+	 */
+	void setDivider(uint32_t newDivider);
+	uint32_t getDivider() const;
+private:
+	bool resetAutomatically = true;
+	uint32_t counter = 0;
+	uint32_t divider = 0;
+};
+
+
+
+#endif /* FSFW_GLOBALFUNCTIONS_PERIODICOPERATIONDIVIDER_H_ */

globalfunctions/timevalOperations.cpp

@@ -1,92 +1,99 @@
-#include "timevalOperations.h"
-
-timeval& operator+=(timeval& lhs, const timeval& rhs) {
-	int64_t sum = lhs.tv_sec * 1000000. + lhs.tv_usec;
-	sum += rhs.tv_sec * 1000000. + rhs.tv_usec;
-	lhs.tv_sec = sum / 1000000;
-	lhs.tv_usec = sum - lhs.tv_sec * 1000000;
-	return lhs;
-}
-
-timeval operator+(timeval lhs, const timeval& rhs) {
-	lhs += rhs;
-	return lhs;
-}
-
-timeval& operator-=(timeval& lhs, const timeval& rhs) {
-	int64_t sum = lhs.tv_sec * 1000000. + lhs.tv_usec;
-	sum -= rhs.tv_sec * 1000000. + rhs.tv_usec;
-	lhs.tv_sec = sum / 1000000;
-	lhs.tv_usec = sum - lhs.tv_sec * 1000000;
-	return lhs;
-}
-
-timeval operator-(timeval lhs, const timeval& rhs) {
-	lhs -= rhs;
-	return lhs;
-}
-
-double operator/(const timeval& lhs, const timeval& rhs) {
-	double lhs64 = lhs.tv_sec * 1000000. + lhs.tv_usec;
-	double rhs64 = rhs.tv_sec * 1000000. + rhs.tv_usec;
-	return lhs64 / rhs64;
-}
-
-timeval& operator/=(timeval& lhs, double scalar) {
-	int64_t product = lhs.tv_sec * 1000000. + lhs.tv_usec;
-	product /= scalar;
-	lhs.tv_sec = product / 1000000;
-	lhs.tv_usec = product - lhs.tv_sec * 1000000;
-	return lhs;
-}
-
-timeval operator/(timeval lhs, double scalar) {
-	lhs /= scalar;
-	return lhs;
-}
-
-timeval& operator*=(timeval& lhs, double scalar) {
-	int64_t product = lhs.tv_sec * 1000000. + lhs.tv_usec;
-	product *= scalar;
-	lhs.tv_sec = product / 1000000;
-	lhs.tv_usec = product - lhs.tv_sec * 1000000;
-	return lhs;
-}
-
-timeval operator*(timeval lhs, double scalar) {
-	lhs *= scalar;
-	return lhs;
-}
-
-timeval operator*(double scalar, timeval rhs) {
-	rhs *= scalar;
-	return rhs;
-}
-
-bool operator==(const timeval& lhs, const timeval& rhs) {
-	int64_t lhs64 = lhs.tv_sec * 1000000. + lhs.tv_usec;
-	int64_t rhs64 = rhs.tv_sec * 1000000. + rhs.tv_usec;
-	return lhs64 == rhs64;
-}
-bool operator!=(const timeval& lhs, const timeval& rhs) {
-	return !operator==(lhs, rhs);
-}
-bool operator<(const timeval& lhs, const timeval& rhs) {
-	int64_t lhs64 = lhs.tv_sec * 1000000. + lhs.tv_usec;
-	int64_t rhs64 = rhs.tv_sec * 1000000. + rhs.tv_usec;
-	return lhs64 < rhs64;
-}
-bool operator>(const timeval& lhs, const timeval& rhs) {
-	return operator<(rhs, lhs);
-}
-bool operator<=(const timeval& lhs, const timeval& rhs) {
-	return !operator>(lhs, rhs);
-}
-bool operator>=(const timeval& lhs, const timeval& rhs) {
-	return !operator<(lhs, rhs);
-}
-
-double timevalOperations::toDouble(const timeval timeval) {
-	double result = timeval.tv_sec * 1000000. + timeval.tv_usec;
-	return result / 1000000.;
-}
+#include "timevalOperations.h"
+
+timeval& operator+=(timeval& lhs, const timeval& rhs) {
+	int64_t sum = lhs.tv_sec * 1000000. + lhs.tv_usec;
+	sum += rhs.tv_sec * 1000000. + rhs.tv_usec;
+	lhs.tv_sec = sum / 1000000;
+	lhs.tv_usec = sum - lhs.tv_sec * 1000000;
+	return lhs;
+}
+
+timeval operator+(timeval lhs, const timeval& rhs) {
+	lhs += rhs;
+	return lhs;
+}
+
+timeval& operator-=(timeval& lhs, const timeval& rhs) {
+	int64_t sum = lhs.tv_sec * 1000000. + lhs.tv_usec;
+	sum -= rhs.tv_sec * 1000000. + rhs.tv_usec;
+	lhs.tv_sec = sum / 1000000;
+	lhs.tv_usec = sum - lhs.tv_sec * 1000000;
+	return lhs;
+}
+
+timeval operator-(timeval lhs, const timeval& rhs) {
+	lhs -= rhs;
+	return lhs;
+}
+
+double operator/(const timeval& lhs, const timeval& rhs) {
+	double lhs64 = lhs.tv_sec * 1000000. + lhs.tv_usec;
+	double rhs64 = rhs.tv_sec * 1000000. + rhs.tv_usec;
+	return lhs64 / rhs64;
+}
+
+timeval& operator/=(timeval& lhs, double scalar) {
+	int64_t product = lhs.tv_sec * 1000000. + lhs.tv_usec;
+	product /= scalar;
+	lhs.tv_sec = product / 1000000;
+	lhs.tv_usec = product - lhs.tv_sec * 1000000;
+	return lhs;
+}
+
+timeval operator/(timeval lhs, double scalar) {
+	lhs /= scalar;
+	return lhs;
+}
+
+timeval& operator*=(timeval& lhs, double scalar) {
+	int64_t product = lhs.tv_sec * 1000000. + lhs.tv_usec;
+	product *= scalar;
+	lhs.tv_sec = product / 1000000;
+	lhs.tv_usec = product - lhs.tv_sec * 1000000;
+	return lhs;
+}
+
+timeval operator*(timeval lhs, double scalar) {
+	lhs *= scalar;
+	return lhs;
+}
+
+timeval operator*(double scalar, timeval rhs) {
+	rhs *= scalar;
+	return rhs;
+}
+
+bool operator==(const timeval& lhs, const timeval& rhs) {
+	int64_t lhs64 = lhs.tv_sec * 1000000. + lhs.tv_usec;
+	int64_t rhs64 = rhs.tv_sec * 1000000. + rhs.tv_usec;
+	return lhs64 == rhs64;
+}
+bool operator!=(const timeval& lhs, const timeval& rhs) {
+	return !operator==(lhs, rhs);
+}
+bool operator<(const timeval& lhs, const timeval& rhs) {
+	int64_t lhs64 = lhs.tv_sec * 1000000. + lhs.tv_usec;
+	int64_t rhs64 = rhs.tv_sec * 1000000. + rhs.tv_usec;
+	return lhs64 < rhs64;
+}
+bool operator>(const timeval& lhs, const timeval& rhs) {
+	return operator<(rhs, lhs);
+}
+bool operator<=(const timeval& lhs, const timeval& rhs) {
+	return !operator>(lhs, rhs);
+}
+bool operator>=(const timeval& lhs, const timeval& rhs) {
+	return !operator<(lhs, rhs);
+}
+
+double timevalOperations::toDouble(const timeval timeval) {
+	double result = timeval.tv_sec * 1000000. + timeval.tv_usec;
+	return result / 1000000.;
+}
+
+timeval timevalOperations::toTimeval(const double seconds) {
+	timeval tval;
+	tval.tv_sec = seconds;
+	tval.tv_usec = seconds *(double) 1e6 - (tval.tv_sec *1e6);
+	return tval;
+}

globalfunctions/timevalOperations.h

@@ -41,6 +41,7 @@ namespace timevalOperations {
  * @return seconds
  */
 double toDouble(const timeval timeval);
+timeval toTimeval(const double seconds);
 }
 
 #endif /* TIMEVALOPERATIONS_H_ */

health/HealthHelper.cpp

@@ -1,9 +1,8 @@
 #include "HealthHelper.h"
-#include "../ipc/MessageQueueSenderIF.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
+
 HealthHelper::HealthHelper(HasHealthIF* owner, object_id_t objectId) :
-		healthTable(NULL), eventSender(NULL), objectId(objectId), parentQueue(
-				0), owner(owner) {
+		objectId(objectId), owner(owner) {
 }
 
 HealthHelper::~HealthHelper() {
@@ -40,9 +39,19 @@ void HealthHelper::setParentQueue(MessageQueueId_t parentQueue) {
 ReturnValue_t HealthHelper::initialize() {
 	healthTable = objectManager->get<HealthTableIF>(objects::HEALTH_TABLE);
 	eventSender = objectManager->get<EventReportingProxyIF>(objectId);
-	if ((healthTable == NULL) || eventSender == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
+
+	if (healthTable == nullptr) {
+	    sif::error << "HealthHelper::initialize: Health table object needs"
+	            "to be created in factory." << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
+
+	if(eventSender == nullptr) {
+	    sif::error << "HealthHelper::initialize: Owner has to implement "
+	            "ReportingProxyIF." << std::endl;
+	    return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
 	ReturnValue_t result = healthTable->registerObject(objectId,
 			HasHealthIF::HEALTHY);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -62,22 +71,22 @@ void HealthHelper::setHealth(HasHealthIF::HealthState health) {
 
 void HealthHelper::informParent(HasHealthIF::HealthState health,
 		HasHealthIF::HealthState oldHealth) {
-	if (parentQueue == 0) {
+	if (parentQueue == MessageQueueIF::NO_QUEUE) {
 		return;
 	}
-	CommandMessage message;
-	HealthMessage::setHealthMessage(&message, HealthMessage::HEALTH_INFO,
+	CommandMessage information;
+	HealthMessage::setHealthMessage(&information, HealthMessage::HEALTH_INFO,
 			health, oldHealth);
-	if (MessageQueueSenderIF::sendMessage(parentQueue, &message,
-			owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
+	if (MessageQueueSenderIF::sendMessage(parentQueue, &information,
+	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
 		sif::debug << "HealthHelper::informParent: sending health reply failed."
 				<< std::endl;
 	}
 }
 
-void HealthHelper::handleSetHealthCommand(CommandMessage* message) {
-	ReturnValue_t result = owner->setHealth(HealthMessage::getHealth(message));
-	if (message->getSender() == 0) {
+void HealthHelper::handleSetHealthCommand(CommandMessage* command) {
+	ReturnValue_t result = owner->setHealth(HealthMessage::getHealth(command));
+	if (command->getSender() == MessageQueueIF::NO_QUEUE) {
 		return;
 	}
 	CommandMessage reply;
@@ -85,12 +94,12 @@ void HealthHelper::handleSetHealthCommand(CommandMessage* message) {
 		HealthMessage::setHealthMessage(&reply,
 				HealthMessage::REPLY_HEALTH_SET);
 	} else {
-		reply.setReplyRejected(result, message->getCommand());
+		reply.setReplyRejected(result, command->getCommand());
 	}
-	if (MessageQueueSenderIF::sendMessage(message->getSender(), &reply,
-			owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
-		sif::debug
-				<< "HealthHelper::handleHealthCommand: sending health reply failed."
-				<< std::endl;
+	if (MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
+	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
+		sif::debug << "HealthHelper::handleHealthCommand: sending health "
+		        "reply failed." << std::endl;
+
 	}
 }

health/HealthHelper.h

@@ -1,11 +1,13 @@
-#ifndef HEALTHHELPER_H_
-#define HEALTHHELPER_H_
+#ifndef FSFW_HEALTH_HEALTHHELPER_H_
+#define FSFW_HEALTH_HEALTHHELPER_H_
 
-#include "../events/EventManagerIF.h"
-#include "../events/EventReportingProxyIF.h"
 #include "HasHealthIF.h"
 #include "HealthMessage.h"
 #include "HealthTableIF.h"
+
+#include "../events/EventManagerIF.h"
+#include "../events/EventReportingProxyIF.h"
+#include "../ipc/MessageQueueIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 
@@ -27,8 +29,8 @@ public:
 	/**
 	 * ctor
 	 *
+	 * @param owner
 	 * @param objectId the object Id to use when communication with the HealthTable
-	 * @param useAsFrom id to use as from id when sending replies, can be set to 0
 	 */
 	HealthHelper(HasHealthIF* owner, object_id_t objectId);
 
@@ -39,12 +41,12 @@ public:
 	 *
 	 * only valid after initialize() has been called
 	 */
-	HealthTableIF *healthTable;
+	HealthTableIF *healthTable = nullptr;
 
 	/**
 	 * Proxy to forward events.
 	 */
-	EventReportingProxyIF* eventSender;
+	EventReportingProxyIF* eventSender = nullptr;
 
 	/**
 	 * Try to handle the message.
@@ -100,7 +102,7 @@ private:
 	/**
 	 * The Queue of the parent
 	 */
-	MessageQueueId_t parentQueue;
+	MessageQueueId_t parentQueue = MessageQueueIF::NO_QUEUE;
 
 	/**
 	 * The one using the healthHelper.
@@ -117,4 +119,4 @@ private:
 	void handleSetHealthCommand(CommandMessage *message);
 };
 
-#endif /* HEALTHHELPER_H_ */
+#endif /* FSFW_HEALTH_HEALTHHELPER_H_ */

health/HealthMessage.h

@@ -6,7 +6,7 @@
 
 class HealthMessage {
 public:
-	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::HEALTH_COMMAND;
+	static const uint8_t MESSAGE_ID = messagetypes::HEALTH_COMMAND;
 	static const Command_t HEALTH_SET = MAKE_COMMAND_ID(1);//REPLY_COMMAND_OK/REPLY_REJECTED
 	static const Command_t HEALTH_ANNOUNCE = MAKE_COMMAND_ID(3);	//NO REPLY!
 	static const Command_t HEALTH_INFO = MAKE_COMMAND_ID(5);

ipc/CommandMessage.cpp

@@ -15,7 +15,7 @@
 #include "../tmstorage/TmStoreMessage.h"
 #include "../parameters/ParameterMessage.h"
 
-namespace MESSAGE_TYPE {
+namespace messagetypes {
 void clearMissionMessage(CommandMessage* message);
 }
 
@@ -67,35 +67,35 @@ void CommandMessage::setParameter2(uint32_t parameter2) {
 
 void CommandMessage::clearCommandMessage() {
 	switch((getCommand()>>8) & 0xff){
-	case  MESSAGE_TYPE::MODE_COMMAND:
+	case  messagetypes::MODE_COMMAND:
 		ModeMessage::clear(this);
 		break;
-	case MESSAGE_TYPE::HEALTH_COMMAND:
+	case messagetypes::HEALTH_COMMAND:
 		HealthMessage::clear(this);
 		break;
-	case MESSAGE_TYPE::MODE_SEQUENCE:
+	case messagetypes::MODE_SEQUENCE:
 		ModeSequenceMessage::clear(this);
 		break;
-	case MESSAGE_TYPE::ACTION:
+	case messagetypes::ACTION:
 		ActionMessage::clear(this);
 		break;
-	case MESSAGE_TYPE::DEVICE_HANDLER_COMMAND:
+	case messagetypes::DEVICE_HANDLER_COMMAND:
 		DeviceHandlerMessage::clear(this);
 		break;
-	case MESSAGE_TYPE::MEMORY:
+	case messagetypes::MEMORY:
 		MemoryMessage::clear(this);
 		break;
-	case MESSAGE_TYPE::MONITORING:
+	case messagetypes::MONITORING:
 		MonitoringMessage::clear(this);
 		break;
-	case MESSAGE_TYPE::TM_STORE:
+	case messagetypes::TM_STORE:
 		TmStoreMessage::clear(this);
 		break;
-	case MESSAGE_TYPE::PARAMETER:
+	case messagetypes::PARAMETER:
 		ParameterMessage::clear(this);
 		break;
 	default:
-		MESSAGE_TYPE::clearMissionMessage(this);
+		messagetypes::clearMissionMessage(this);
 		break;
 	}
 }

ipc/CommandMessage.h

@@ -22,7 +22,7 @@ public:
 	static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01);
 
 
-	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::COMMAND;
+	static const uint8_t MESSAGE_ID = messagetypes::COMMAND;
 	static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 );//!< Used internally, will be ignored
 	static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID( 3 );
 	static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID( 0xD1 );//!< Reply indicating that the current command was rejected, par1 should contain the error code

ipc/FwMessageTypes.h

@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_IPC_FWMESSAGETYPES_H_
 #define FRAMEWORK_IPC_FWMESSAGETYPES_H_
 
-namespace MESSAGE_TYPE {
+namespace messagetypes {
 //Remember to add new Message Types to the clearCommandMessage function!
 enum FW_MESSAGE_TYPE {
 	COMMAND = 0,

memory/MemoryMessage.h

@@ -9,7 +9,7 @@ class MemoryMessage {
 private:
 	MemoryMessage(); //A private ctor inhibits instantiation
 public:
-	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::MEMORY;
+	static const uint8_t MESSAGE_ID = messagetypes::MEMORY;
 	static const Command_t CMD_MEMORY_LOAD = MAKE_COMMAND_ID( 0x01 );
 	static const Command_t CMD_MEMORY_DUMP = MAKE_COMMAND_ID( 0x02 );
 	static const Command_t CMD_MEMORY_CHECK = MAKE_COMMAND_ID( 0x03 );

modes/ModeMessage.h

@@ -17,7 +17,7 @@ class ModeMessage {
 private:
 	ModeMessage();
 public:
-	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::MODE_COMMAND;
+	static const uint8_t MESSAGE_ID = messagetypes::MODE_COMMAND;
 	static const Command_t CMD_MODE_COMMAND = MAKE_COMMAND_ID(0x01);//!> Command to set the specified Mode, replies are: REPLY_MODE_REPLY, REPLY_WRONG_MODE_REPLY, and REPLY_REJECTED; don't add any replies, as this will break the subsystem mode machine!!
 	static const Command_t CMD_MODE_COMMAND_FORCED = MAKE_COMMAND_ID(0xF1);//!> Command to set the specified Mode, regardless of external control flag, replies are: REPLY_MODE_REPLY, REPLY_WRONG_MODE_REPLY, and REPLY_REJECTED; don't add any replies, as this will break the subsystem mode machine!!
 	static const Command_t REPLY_MODE_REPLY = MAKE_COMMAND_ID(0x02);//!> Reply to a CMD_MODE_COMMAND or CMD_MODE_READ

monitoring/MonitoringMessage.h

@@ -6,7 +6,7 @@
 
 class MonitoringMessage: public CommandMessage {
 public:
-	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::MONITORING;
+	static const uint8_t MESSAGE_ID = messagetypes::MONITORING;
 	//Object id could be useful, but we better manage that on service level (register potential reporters).
 	static const Command_t LIMIT_VIOLATION_REPORT = MAKE_COMMAND_ID(10);
 	virtual ~MonitoringMessage();

objectmanager/ObjectManager.cpp

@@ -100,7 +100,6 @@ void ObjectManager::initialize() {
 }
 
 void ObjectManager::printList() {
-	std::map<object_id_t, SystemObjectIF*>::iterator it;
 	sif::debug << "ObjectManager: Object List contains:" << std::endl;
 	for (auto const& it : objectList) {
 		sif::debug << std::hex << it.first << " | " << it.second << std::endl;

osal/FreeRTOS/BinSemaphUsingTask.cpp

@@ -0,0 +1,95 @@
+#include "../../osal/FreeRTOS/BinSemaphUsingTask.h"
+#include "../../osal/FreeRTOS/TaskManagement.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+BinarySemaphoreUsingTask::BinarySemaphoreUsingTask() {
+	handle = TaskManagement::getCurrentTaskHandle();
+	if(handle == nullptr) {
+		sif::error << "Could not retrieve task handle. Please ensure the"
+				"constructor was called inside a task." << std::endl;
+	}
+	xTaskNotifyGive(handle);
+}
+
+BinarySemaphoreUsingTask::~BinarySemaphoreUsingTask() {
+	// Clear notification value on destruction.
+	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite, nullptr);
+}
+
+ReturnValue_t BinarySemaphoreUsingTask::acquire(TimeoutType timeoutType,
+        uint32_t timeoutMs) {
+    TickType_t timeout = 0;
+    if(timeoutType == TimeoutType::POLLING) {
+        timeout = 0;
+    }
+    else if(timeoutType == TimeoutType::WAITING){
+        timeout = pdMS_TO_TICKS(timeoutMs);
+    }
+    else {
+        timeout = portMAX_DELAY;
+    }
+	return acquireWithTickTimeout(timeoutType, timeout);
+}
+
+ReturnValue_t BinarySemaphoreUsingTask::acquireWithTickTimeout(
+        TimeoutType timeoutType, TickType_t timeoutTicks) {
+	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeoutTicks);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return SemaphoreIF::SEMAPHORE_TIMEOUT;
+	}
+}
+
+ReturnValue_t BinarySemaphoreUsingTask::release() {
+	return release(this->handle);
+}
+
+ReturnValue_t BinarySemaphoreUsingTask::release(
+		TaskHandle_t taskHandle) {
+	if(getSemaphoreCounter(taskHandle) == 1) {
+		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
+	}
+	BaseType_t returncode = xTaskNotifyGive(taskHandle);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		// This should never happen.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+TaskHandle_t BinarySemaphoreUsingTask::getTaskHandle() {
+	return handle;
+}
+
+uint8_t BinarySemaphoreUsingTask::getSemaphoreCounter() const {
+	return getSemaphoreCounter(this->handle);
+}
+
+uint8_t BinarySemaphoreUsingTask::getSemaphoreCounter(
+		TaskHandle_t taskHandle) {
+	uint32_t notificationValue;
+	xTaskNotifyAndQuery(taskHandle, 0, eNoAction, &notificationValue);
+	return notificationValue;
+}
+
+// Be careful with the stack size here. This is called from an ISR!
+ReturnValue_t BinarySemaphoreUsingTask::releaseFromISR(
+		TaskHandle_t taskHandle, BaseType_t * higherPriorityTaskWoken) {
+	if(getSemaphoreCounterFromISR(taskHandle, higherPriorityTaskWoken) == 1) {
+		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
+	}
+	vTaskNotifyGiveFromISR(taskHandle, higherPriorityTaskWoken);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint8_t BinarySemaphoreUsingTask::getSemaphoreCounterFromISR(
+		TaskHandle_t taskHandle, BaseType_t* higherPriorityTaskWoken) {
+	uint32_t notificationValue = 0;
+	xTaskNotifyAndQueryFromISR(taskHandle, 0, eNoAction, &notificationValue,
+			higherPriorityTaskWoken);
+	return notificationValue;
+}

osal/FreeRTOS/BinSemaphUsingTask.h

@@ -0,0 +1,76 @@
+#ifndef FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
+#define FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../tasks/SemaphoreIF.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+/**
+ * @brief 	Binary Semaphore implementation using the task notification value.
+ * 			The notification value should therefore not be used
+ * 			for other purposes.
+ * @details
+ * Additional information: https://www.freertos.org/RTOS-task-notifications.html
+ * and general semaphore documentation.
+ */
+class BinarySemaphoreUsingTask: public SemaphoreIF,
+		public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
+
+	//! @brief Default ctor
+	BinarySemaphoreUsingTask();
+	//! @brief Default dtor
+	virtual~ BinarySemaphoreUsingTask();
+
+	ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
+	        uint32_t timeoutMs = portMAX_DELAY) override;
+	ReturnValue_t release() override;
+	uint8_t getSemaphoreCounter() const override;
+	static uint8_t getSemaphoreCounter(TaskHandle_t taskHandle);
+	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t taskHandle,
+			BaseType_t* higherPriorityTaskWoken);
+
+	/**
+	 * Same as acquire() with timeout in FreeRTOS ticks.
+	 * @param timeoutTicks
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	ReturnValue_t acquireWithTickTimeout(
+	        TimeoutType timeoutType = TimeoutType::BLOCKING,
+	        TickType_t timeoutTicks = portMAX_DELAY);
+
+	/**
+	 * Get handle to the task related to the semaphore.
+	 * @return
+	 */
+	TaskHandle_t getTaskHandle();
+
+	 /**
+	 * Wrapper function to give back semaphore from handle
+	 * @param semaphore
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	static ReturnValue_t release(TaskHandle_t taskToNotify);
+
+	/**
+	 * Wrapper function to give back semaphore from handle when called from an ISR
+	 * @param semaphore
+	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with
+	 * a higher priority was unblocked. A context switch should be requested
+	 * from an ISR if this is the case (see TaskManagement functions)
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	static ReturnValue_t releaseFromISR(TaskHandle_t taskToNotify,
+				BaseType_t * higherPriorityTaskWoken);
+
+protected:
+	TaskHandle_t handle;
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_ */

osal/FreeRTOS/BinarySemaphore.cpp

@@ -0,0 +1,108 @@
+#include "../../osal/FreeRTOS/BinarySemaphore.h"
+#include "../../osal/FreeRTOS/TaskManagement.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+BinarySemaphore::BinarySemaphore() {
+	handle = xSemaphoreCreateBinary();
+	if(handle == nullptr) {
+		sif::error << "Semaphore: Binary semaph creation failure" << std::endl;
+	}
+	// Initiated semaphore must be given before it can be taken.
+	xSemaphoreGive(handle);
+}
+
+BinarySemaphore::~BinarySemaphore() {
+	vSemaphoreDelete(handle);
+}
+
+BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
+    handle = xSemaphoreCreateBinary();
+    if(handle == nullptr) {
+        sif::error << "Binary semaphore creation failure" << std::endl;
+    }
+    xSemaphoreGive(handle);
+}
+
+BinarySemaphore& BinarySemaphore::operator =(
+        BinarySemaphore&& s) {
+    if(&s != this) {
+        handle = xSemaphoreCreateBinary();
+        if(handle == nullptr) {
+            sif::error << "Binary semaphore creation failure" << std::endl;
+        }
+        xSemaphoreGive(handle);
+    }
+    return *this;
+}
+
+ReturnValue_t BinarySemaphore::acquire(TimeoutType timeoutType,
+        uint32_t timeoutMs) {
+    TickType_t timeout = 0;
+	if(timeoutType == TimeoutType::POLLING) {
+	    timeout = 0;
+	}
+	else if(timeoutType == TimeoutType::WAITING){
+	    timeout = pdMS_TO_TICKS(timeoutMs);
+	}
+	else {
+	    timeout = portMAX_DELAY;
+	}
+	return acquireWithTickTimeout(timeoutType, timeout);
+}
+
+ReturnValue_t BinarySemaphore::acquireWithTickTimeout(TimeoutType timeoutType,
+        TickType_t timeoutTicks) {
+	if(handle == nullptr) {
+		return SemaphoreIF::SEMAPHORE_INVALID;
+	}
+
+	BaseType_t returncode = xSemaphoreTake(handle, timeoutTicks);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return SemaphoreIF::SEMAPHORE_TIMEOUT;
+	}
+}
+
+ReturnValue_t BinarySemaphore::release() {
+	return release(handle);
+}
+
+ReturnValue_t BinarySemaphore::release(SemaphoreHandle_t semaphore) {
+	if (semaphore == nullptr) {
+		return SemaphoreIF::SEMAPHORE_INVALID;
+	}
+	BaseType_t returncode = xSemaphoreGive(semaphore);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
+	}
+}
+
+uint8_t BinarySemaphore::getSemaphoreCounter() const {
+	return uxSemaphoreGetCount(handle);
+}
+
+SemaphoreHandle_t BinarySemaphore::getSemaphore() {
+	return handle;
+}
+
+
+// Be careful with the stack size here. This is called from an ISR!
+ReturnValue_t BinarySemaphore::releaseFromISR(
+		SemaphoreHandle_t semaphore, BaseType_t * higherPriorityTaskWoken) {
+	if (semaphore == nullptr) {
+		return SemaphoreIF::SEMAPHORE_INVALID;
+	}
+	BaseType_t returncode = xSemaphoreGiveFromISR(semaphore,
+			higherPriorityTaskWoken);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
+	}
+}

osal/FreeRTOS/BinarySemaphore.h

@@ -0,0 +1,107 @@
+#ifndef FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
+#define FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../tasks/SemaphoreIF.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+
+/**
+ * @brief 	OS Tool to achieve synchronization of between tasks or between
+ * 			task and ISR. The default semaphore implementation creates a
+ * 			binary semaphore, which can only be taken once.
+ * @details
+ * Documentation: https://www.freertos.org/Embedded-RTOS-Binary-Semaphores.html
+ *
+ * Please note that if the semaphore implementation is only related to
+ * the synchronization of one task, the new task notifications can be used,
+ * also see the BinSemaphUsingTask and CountingSemaphUsingTask classes.
+ * These use the task notification value instead of a queue and are
+ * faster and more efficient.
+ *
+ * @author 	R. Mueller
+ * @ingroup osal
+ */
+class BinarySemaphore: public SemaphoreIF,
+		public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
+
+	//! @brief Default ctor
+	BinarySemaphore();
+	//! @brief Copy ctor, deleted explicitely.
+	BinarySemaphore(const BinarySemaphore&) = delete;
+	//! @brief Copy assignment, deleted explicitely.
+	BinarySemaphore& operator=(const BinarySemaphore&) = delete;
+	//! @brief Move ctor
+	BinarySemaphore (BinarySemaphore &&);
+	//! @brief Move assignment
+	BinarySemaphore & operator=(BinarySemaphore &&);
+	//! @brief Destructor
+	virtual ~BinarySemaphore();
+
+	uint8_t getSemaphoreCounter() const override;
+
+	/**
+	 * Take the binary semaphore.
+	 * If the semaphore has already been taken, the task will be blocked
+	 * for a maximum of #timeoutMs or until the semaphore is given back,
+	 * for example by an ISR or another task.
+	 * @param timeoutMs
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
+	 */
+	ReturnValue_t acquire(TimeoutType timeoutType =
+            TimeoutType::BLOCKING, uint32_t timeoutMs = portMAX_DELAY) override;
+
+	/**
+	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
+	 * @param timeoutTicks
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
+	 */
+	ReturnValue_t  acquireWithTickTimeout(TimeoutType timeoutType =
+            TimeoutType::BLOCKING, TickType_t timeoutTicks = portMAX_DELAY);
+
+	/**
+	 * Release the binary semaphore.
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is
+	 *         	already available.
+	 */
+	ReturnValue_t release() override;
+
+	/**
+	 * Get Handle to the semaphore.
+	 * @return
+	 */
+	SemaphoreHandle_t getSemaphore();
+
+	 /**
+	 * Wrapper function to give back semaphore from handle
+	 * @param semaphore
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is
+	 *         	already available.
+	 */
+	static ReturnValue_t release(SemaphoreHandle_t semaphore);
+
+	/**
+	 * Wrapper function to give back semaphore from handle when called from an ISR
+	 * @param semaphore
+	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with
+	 * a higher priority was unblocked. A context switch from an ISR should
+	 * then be requested (see TaskManagement functions)
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is
+	 *         	already available.
+	 */
+	static ReturnValue_t releaseFromISR(SemaphoreHandle_t semaphore,
+				BaseType_t * higherPriorityTaskWoken);
+
+protected:
+	SemaphoreHandle_t handle;
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */

osal/FreeRTOS/CountingSemaphUsingTask.cpp

@@ -0,0 +1,114 @@
+#include "../../osal/FreeRTOS/CountingSemaphUsingTask.h"
+#include "../../osal/FreeRTOS/TaskManagement.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(const uint8_t maxCount,
+		uint8_t initCount): maxCount(maxCount) {
+	if(initCount > maxCount) {
+		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
+				"intial cout. Setting initial count to max count." << std::endl;
+		initCount = maxCount;
+	}
+
+	handle = TaskManagement::getCurrentTaskHandle();
+	if(handle == nullptr) {
+		sif::error << "CountingSemaphoreUsingTask: Could not retrieve task "
+				"handle. Please ensure the constructor was called inside a "
+				"task." << std::endl;
+	}
+
+	uint32_t oldNotificationValue;
+	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite,
+			&oldNotificationValue);
+	if(oldNotificationValue != 0) {
+		sif::warning << "CountinSemaphoreUsingTask: Semaphore initiated but "
+				"current notification value is not 0. Please ensure the "
+				"notification value is not used for other purposes!" << std::endl;
+	}
+	for(int i = 0; i < initCount; i++) {
+		xTaskNotifyGive(handle);
+	}
+}
+
+CountingSemaphoreUsingTask::~CountingSemaphoreUsingTask() {
+	// Clear notification value on destruction.
+	// If this is not desired, don't call the destructor
+	// (or implement a boolean which disables the reset)
+	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite, nullptr);
+}
+
+ReturnValue_t CountingSemaphoreUsingTask::acquire(TimeoutType timeoutType,
+        uint32_t timeoutMs) {
+    TickType_t timeout = 0;
+    if(timeoutType == TimeoutType::POLLING) {
+        timeout = 0;
+    }
+    else if(timeoutType == TimeoutType::WAITING){
+        timeout = pdMS_TO_TICKS(timeoutMs);
+    }
+    else {
+        timeout = portMAX_DELAY;
+    }
+    return acquireWithTickTimeout(timeoutType, timeout);
+
+}
+
+ReturnValue_t CountingSemaphoreUsingTask::acquireWithTickTimeout(
+        TimeoutType timeoutType, TickType_t timeoutTicks) {
+	// Decrement notfication value without resetting it.
+	BaseType_t oldCount = ulTaskNotifyTake(pdFALSE, timeoutTicks);
+	if (getSemaphoreCounter() == oldCount - 1) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return SemaphoreIF::SEMAPHORE_TIMEOUT;
+	}
+}
+
+ReturnValue_t CountingSemaphoreUsingTask::release() {
+	if(getSemaphoreCounter() == maxCount) {
+		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
+	}
+	return release(handle);
+}
+
+ReturnValue_t CountingSemaphoreUsingTask::release(
+		TaskHandle_t taskToNotify) {
+	BaseType_t returncode = xTaskNotifyGive(taskToNotify);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		// This should never happen.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+
+uint8_t CountingSemaphoreUsingTask::getSemaphoreCounter() const {
+	uint32_t notificationValue = 0;
+	xTaskNotifyAndQuery(handle, 0, eNoAction, &notificationValue);
+	return notificationValue;
+}
+
+TaskHandle_t CountingSemaphoreUsingTask::getTaskHandle() {
+	return handle;
+}
+
+ReturnValue_t CountingSemaphoreUsingTask::releaseFromISR(
+		TaskHandle_t taskToNotify, BaseType_t* higherPriorityTaskWoken) {
+	vTaskNotifyGiveFromISR(taskToNotify, higherPriorityTaskWoken);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint8_t CountingSemaphoreUsingTask::getSemaphoreCounterFromISR(
+		TaskHandle_t task, BaseType_t* higherPriorityTaskWoken) {
+	uint32_t notificationValue;
+	xTaskNotifyAndQueryFromISR(task, 0, eNoAction, &notificationValue,
+			higherPriorityTaskWoken);
+	return notificationValue;
+}
+
+uint8_t CountingSemaphoreUsingTask::getMaxCount() const {
+	return maxCount;
+}

osal/FreeRTOS/CountingSemaphUsingTask.h

@@ -0,0 +1,102 @@
+#ifndef FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_
+#define FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_
+
+#include "../../osal/FreeRTOS/CountingSemaphUsingTask.h"
+#include "../../tasks/SemaphoreIF.h"
+
+extern "C" {
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+}
+
+/**
+ * @brief 	Couting Semaphore implementation which uses the notification value
+ * 			of the task. The notification value should therefore not be used
+ * 			for other purposes.
+ * @details
+ *  Additional information: https://www.freertos.org/RTOS-task-notifications.html
+ *  and general semaphore documentation.
+ */
+class CountingSemaphoreUsingTask: public SemaphoreIF {
+public:
+	CountingSemaphoreUsingTask(const uint8_t maxCount, uint8_t initCount);
+	virtual ~CountingSemaphoreUsingTask();
+
+	/**
+	 * Acquire the counting semaphore.
+	 * If no semaphores are available, the task will be blocked
+	 * for a maximum of #timeoutMs or until one is given back,
+	 * for example by an ISR or another task.
+	 * @param timeoutMs
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
+	 */
+	ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
+	        uint32_t timeoutMs = portMAX_DELAY) override;
+
+	/**
+	 * Release a semaphore, increasing the number of available counting
+	 * semaphores up to the #maxCount value.
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if #maxCount semaphores are
+	 *         	already available.
+	 */
+	ReturnValue_t release() override;
+
+	uint8_t getSemaphoreCounter() const override;
+	/**
+	 * Get the semaphore counter from an ISR.
+	 * @param task
+	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with
+	 * a higher priority was unblocked. A context switch should be requested
+	 * from an ISR if this is the case (see TaskManagement functions)
+	 * @return
+	 */
+	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t task,
+			BaseType_t* higherPriorityTaskWoken);
+
+	/**
+	 * Acquire with a timeout value in ticks
+	 * @param timeoutTicks
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
+	 */
+	ReturnValue_t acquireWithTickTimeout(
+	        TimeoutType timeoutType = TimeoutType::BLOCKING,
+			TickType_t timeoutTicks = portMAX_DELAY);
+
+	/**
+	 * Get handle to the task related to the semaphore.
+	 * @return
+	 */
+	TaskHandle_t getTaskHandle();
+
+	/**
+	 * Release semaphore of task by supplying task handle
+	 * @param taskToNotify
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if #maxCount semaphores are
+	 *         	already available.
+	 */
+	static ReturnValue_t release(TaskHandle_t taskToNotify);
+	/**
+	 * Release seamphore of a task from an ISR.
+	 * @param taskToNotify
+	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with
+	 * a higher priority was unblocked. A context switch should be requested
+	 * from an ISR if this is the case (see TaskManagement functions)
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if #maxCount semaphores are
+	 *         	already available.
+	 */
+	static ReturnValue_t releaseFromISR(TaskHandle_t taskToNotify,
+			BaseType_t* higherPriorityTaskWoken);
+
+	uint8_t getMaxCount() const;
+
+private:
+	TaskHandle_t handle;
+	const uint8_t maxCount;
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_ */

osal/FreeRTOS/CountingSemaphore.cpp

@@ -0,0 +1,43 @@
+#include "../../osal/FreeRTOS/CountingSemaphore.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../osal/FreeRTOS/TaskManagement.h"
+
+#include <freertos/semphr.h>
+
+// Make sure #define configUSE_COUNTING_SEMAPHORES 1 is set in
+// free FreeRTOSConfig.h file.
+CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
+		maxCount(maxCount), initCount(initCount) {
+	if(initCount > maxCount) {
+		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
+				"intial cout. Setting initial count to max count." << std::endl;
+		initCount = maxCount;
+	}
+
+	handle = xSemaphoreCreateCounting(maxCount, initCount);
+	if(handle == nullptr) {
+		sif::error << "CountingSemaphore: Creation failure" << std::endl;
+	}
+}
+
+CountingSemaphore::CountingSemaphore(CountingSemaphore&& other):
+		maxCount(other.maxCount), initCount(other.initCount) {
+	handle = xSemaphoreCreateCounting(other.maxCount, other.initCount);
+	if(handle == nullptr) {
+		sif::error << "CountingSemaphore: Creation failure" << std::endl;
+	}
+}
+
+CountingSemaphore& CountingSemaphore::operator =(
+		CountingSemaphore&& other) {
+	handle = xSemaphoreCreateCounting(other.maxCount, other.initCount);
+	if(handle == nullptr) {
+		sif::error << "CountingSemaphore: Creation failure" << std::endl;
+	}
+	return * this;
+}
+
+
+uint8_t CountingSemaphore::getMaxCount() const {
+	return maxCount;
+}

osal/FreeRTOS/CountingSemaphore.h

@@ -0,0 +1,34 @@
+#ifndef FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_
+#define FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_
+#include "../../osal/FreeRTOS/BinarySemaphore.h"
+
+/**
+ * @brief 	Counting semaphores, which can be acquire more than once.
+ * @details
+ * See: https://www.freertos.org/CreateCounting.html
+ * API of counting semaphores is almost identical to binary semaphores,
+ * so we just inherit from binary semaphore and provide the respective
+ * constructors.
+ */
+class CountingSemaphore: public BinarySemaphore {
+public:
+	CountingSemaphore(const uint8_t maxCount, uint8_t initCount);
+	//! @brief Copy ctor, disabled
+	CountingSemaphore(const CountingSemaphore&) = delete;
+	//! @brief Copy assignment, disabled
+	CountingSemaphore& operator=(const CountingSemaphore&) = delete;
+	//! @brief Move ctor
+	CountingSemaphore (CountingSemaphore &&);
+	//! @brief Move assignment
+	CountingSemaphore & operator=(CountingSemaphore &&);
+
+	/* Same API as binary semaphore otherwise. acquire() can be called
+	 * until there are not semaphores left and release() can be called
+	 * until maxCount is reached. */
+	uint8_t getMaxCount() const;
+private:
+	const uint8_t maxCount;
+	uint8_t initCount = 0;
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_ */

osal/FreeRTOS/FixedTimeslotTask.cpp

@@ -5,11 +5,12 @@
 uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
 const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = configMINIMAL_STACK_SIZE;
 
-FixedTimeslotTask::FixedTimeslotTask(const char *name, TaskPriority setPriority,
+FixedTimeslotTask::FixedTimeslotTask(TaskName name, TaskPriority setPriority,
 		TaskStackSize setStack, TaskPeriod overallPeriod,
 		void (*setDeadlineMissedFunc)()) :
 		started(false), handle(NULL), pst(overallPeriod * 1000) {
-	xTaskCreate(taskEntryPoint, name, setStack, this, setPriority, &handle);
+	configSTACK_DEPTH_TYPE stackSize = setStack / sizeof(configSTACK_DEPTH_TYPE);
+	xTaskCreate(taskEntryPoint, name, stackSize, this, setPriority, &handle);
 	// All additional attributes are applied to the object.
 	this->deadlineMissedFunc = setDeadlineMissedFunc;
 }
@@ -82,7 +83,7 @@ ReturnValue_t FixedTimeslotTask::checkSequence() const {
 void FixedTimeslotTask::taskFunctionality() {
 	// A local iterator for the Polling Sequence Table is created to find the
     // start time for the first entry.
-	FixedSlotSequence::SlotListIter slotListIter = pst.current;
+	auto slotListIter = pst.current;
 
 	//The start time for the first entry is read.
 	uint32_t intervalMs = slotListIter->pollingTimeMs;
@@ -155,3 +156,7 @@ ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
 	vTaskDelay(pdMS_TO_TICKS(ms));
 	return HasReturnvaluesIF::RETURN_OK;
 }
+
+TaskHandle_t FixedTimeslotTask::getTaskHandle() {
+    return handle;
+}

osal/FreeRTOS/FixedTimeslotTask.h

@@ -1,14 +1,16 @@
 #ifndef FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
 #define FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
 
+#include "FreeRTOSTaskIF.h"
 #include "../../devicehandlers/FixedSlotSequence.h"
 #include "../../tasks/FixedTimeslotTaskIF.h"
 #include "../../tasks/Typedef.h"
 
+
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 
-class FixedTimeslotTask: public FixedTimeslotTaskIF {
+class FixedTimeslotTask: public FixedTimeslotTaskIF, public FreeRTOSTaskIF {
 public:
 
 	/**
@@ -23,7 +25,7 @@ public:
 	 * @param setDeadlineMissedFunc Callback if a deadline was missed.
 	 * @return Pointer to the newly created task.
 	 */
-	FixedTimeslotTask(const char *name, TaskPriority setPriority,
+	FixedTimeslotTask(TaskName name, TaskPriority setPriority,
 			TaskStackSize setStack, TaskPeriod overallPeriod,
 			void (*setDeadlineMissedFunc)());
 
@@ -57,6 +59,8 @@ public:
 
 	ReturnValue_t sleepFor(uint32_t ms) override;
 
+	TaskHandle_t getTaskHandle() override;
+
 protected:
 	bool started;
 	TaskHandle_t handle;

osal/FreeRTOS/FreeRTOSTaskIF.h

@@ -0,0 +1,13 @@
+#ifndef FRAMEWORK_OSAL_FREERTOS_FREERTOSTASKIF_H_
+#define FRAMEWORK_OSAL_FREERTOS_FREERTOSTASKIF_H_
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+class FreeRTOSTaskIF {
+public:
+	virtual~ FreeRTOSTaskIF() {}
+	virtual TaskHandle_t getTaskHandle() = 0;
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_FREERTOSTASKIF_H_ */

osal/FreeRTOS/Mutex.cpp

@@ -1,4 +1,4 @@
-#include <framework/osal/FreeRTOS/Mutex.h>
+#include "Mutex.h"
 
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 

osal/FreeRTOS/PeriodicTask.cpp

@@ -5,12 +5,13 @@
 
 PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
 		TaskStackSize setStack, TaskPeriod setPeriod,
-		void (*setDeadlineMissedFunc)()) :
+		TaskDeadlineMissedFunction deadlineMissedFunc) :
 		started(false), handle(NULL), period(setPeriod), deadlineMissedFunc(
-		setDeadlineMissedFunc)
+		deadlineMissedFunc)
 {
+	configSTACK_DEPTH_TYPE stackSize = setStack / sizeof(configSTACK_DEPTH_TYPE);
 	BaseType_t status = xTaskCreate(taskEntryPoint, name,
-			setStack, this, setPriority, &handle);
+			stackSize, this, setPriority, &handle);
 	if(status != pdPASS){
 		sif::debug << "PeriodicTask Insufficient heap memory remaining. "
 		        "Status: " << status << std::endl;
@@ -63,6 +64,11 @@ ReturnValue_t PeriodicTask::sleepFor(uint32_t ms) {
 void PeriodicTask::taskFunctionality() {
 	TickType_t xLastWakeTime;
 	const TickType_t xPeriod = pdMS_TO_TICKS(this->period * 1000.);
+	
+	for (auto const &object: objectList) {
+		object->initializeAfterTaskCreation();
+	}
+
 	/* The xLastWakeTime variable needs to be initialized with the current tick
 	 count. Note that this is the only time the variable is written to
 	 explicitly. After this assignment, xLastWakeTime is updated automatically
@@ -86,12 +92,12 @@ ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
 			object);
 	if (newObject == nullptr) {
 	    sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
-	            "it implements ExecutableObjectIF!" << std::endl;
+	            "it implement ExecutableObjectIF" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	objectList.push_back(newObject);
-
 	newObject->setTaskIF(this);
+
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -122,6 +128,10 @@ void PeriodicTask::checkMissedDeadline(const TickType_t xLastWakeTime,
     }
 }
 
+TaskHandle_t PeriodicTask::getTaskHandle() {
+    return handle;
+}
+
 void PeriodicTask::handleMissedDeadline() {
 #ifdef DEBUG
     sif::warning << "PeriodicTask: " << pcTaskGetName(NULL) <<

osal/FreeRTOS/PeriodicTask.h

@@ -1,6 +1,7 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_
-#define FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_
+#ifndef FSFW_OSAL_FREERTOS_PERIODICTASK_H_
+#define FSFW_OSAL_FREERTOS_PERIODICTASK_H_
 
+#include "FreeRTOSTaskIF.h"
 #include "../../objectmanager/ObjectManagerIF.h"
 #include "../../tasks/PeriodicTaskIF.h"
 #include "../../tasks/Typedef.h"
@@ -17,12 +18,11 @@ class ExecutableObjectIF;
  * 			periodic activities of multiple objects.
  * @ingroup task_handling
  */
-class PeriodicTask: public PeriodicTaskIF {
+class PeriodicTask: public PeriodicTaskIF, public FreeRTOSTaskIF {
 public:
 	/**
 	 * Keep in Mind that you need to call before this vTaskStartScheduler()!
 	 * A lot of task parameters are set in "FreeRTOSConfig.h".
-	 * TODO: why does this need to be called before vTaskStartScheduler?
 	 * @details
 	 * The class is initialized without allocated objects.
 	 * These need to be added with #addComponent.
@@ -38,9 +38,9 @@ public:
 	 * The function pointer to the deadline missed function that shall
 	 * be assigned.
 	 */
-	PeriodicTask(const char *name, TaskPriority setPriority,
+	PeriodicTask(TaskName name, TaskPriority setPriority,
 	        TaskStackSize setStack, TaskPeriod setPeriod,
-	        void (*setDeadlineMissedFunc)());
+	        TaskDeadlineMissedFunction deadlineMissedFunc);
 	/**
 	 * @brief	Currently, the executed object's lifetime is not coupled with
 	 * 			the task object's lifetime, so the destructor is empty.
@@ -68,6 +68,8 @@ public:
 	uint32_t getPeriodMs() const override;
 
 	ReturnValue_t sleepFor(uint32_t ms) override;
+
+	TaskHandle_t getTaskHandle() override;
 protected:
 	bool started;
 	TaskHandle_t handle;
@@ -121,4 +123,4 @@ protected:
 	void handleMissedDeadline();
 };
 
-#endif /* PERIODICTASK_H_ */
+#endif /* FSFW_OSAL_FREERTOS_PERIODICTASK_H_ */

osal/FreeRTOS/SemaphoreFactory.cpp

@@ -0,0 +1,59 @@
+#include "../../osal/FreeRTOS/BinarySemaphore.h"
+#include "../../osal/FreeRTOS/BinSemaphUsingTask.h"
+#include "../../osal/FreeRTOS/CountingSemaphore.h"
+#include "../../osal/FreeRTOS/CountingSemaphUsingTask.h"
+#include "../../tasks/SemaphoreFactory.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
+
+static const uint32_t USE_REGULAR_SEMAPHORES = 0;
+static const uint32_t USE_TASK_NOTIFICATIONS = 1;
+
+SemaphoreFactory::SemaphoreFactory() {
+}
+
+SemaphoreFactory::~SemaphoreFactory() {
+	delete factoryInstance;
+}
+
+SemaphoreFactory* SemaphoreFactory::instance() {
+	if (factoryInstance == nullptr){
+		factoryInstance = new SemaphoreFactory();
+	}
+	return SemaphoreFactory::factoryInstance;
+}
+
+SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t argument) {
+	if(argument == USE_REGULAR_SEMAPHORES) {
+		return new BinarySemaphore();
+	}
+	else if(argument == USE_TASK_NOTIFICATIONS) {
+		return new BinarySemaphoreUsingTask();
+	}
+	else {
+		sif::warning << "SemaphoreFactory: Invalid argument, return regular"
+				"binary semaphore" << std::endl;
+		return new BinarySemaphore();
+	}
+}
+
+SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t maxCount,
+		uint8_t initCount, uint32_t argument) {
+	if(argument == USE_REGULAR_SEMAPHORES) {
+		return new CountingSemaphore(maxCount, initCount);
+	}
+	else if(argument == USE_TASK_NOTIFICATIONS) {
+		return new CountingSemaphoreUsingTask(maxCount, initCount);
+	}
+	else {
+		sif::warning << "SemaphoreFactory: Invalid argument, return regular"
+						"binary semaphore" << std::endl;
+		return new CountingSemaphore(maxCount, initCount);
+	}
+
+}
+
+void SemaphoreFactory::deleteSemaphore(SemaphoreIF* semaphore) {
+	delete semaphore;
+}

osal/FreeRTOS/TaskManagement.cpp

@@ -0,0 +1,24 @@
+#include "../../osal/FreeRTOS/TaskManagement.h"
+
+void TaskManagement::vRequestContextSwitchFromTask() {
+	vTaskDelay(0);
+}
+
+void TaskManagement::requestContextSwitch(
+		CallContext callContext = CallContext::TASK) {
+	if(callContext == CallContext::ISR) {
+		// This function depends on the partmacro.h definition for the specific device
+		vRequestContextSwitchFromISR();
+	} else {
+		vRequestContextSwitchFromTask();
+	}
+}
+
+TaskHandle_t TaskManagement::getCurrentTaskHandle() {
+	return xTaskGetCurrentTaskHandle();
+}
+
+size_t TaskManagement::getTaskStackHighWatermark(
+        TaskHandle_t task) {
+	return uxTaskGetStackHighWaterMark(task) * sizeof(StackType_t);
+}

osal/FreeRTOS/TaskManagement.h

@@ -0,0 +1,64 @@
+#ifndef FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
+#define FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
+
+extern "C" {
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+}
+#include <cstdint>
+
+/**
+ * Architecture dependant portmacro.h function call.
+ * Should be implemented in bsp.
+ */
+extern void vRequestContextSwitchFromISR();
+
+/*!
+ * Used by functions to tell if they are being called from
+ * within an ISR or from a regular task. This is required because FreeRTOS
+ * has different functions for handling semaphores and messages from within
+ * an ISR and task.
+ */
+enum class CallContext {
+	TASK = 0x00,//!< task_context
+	ISR = 0xFF  //!< isr_context
+};
+
+
+class TaskManagement {
+public:
+	/**
+	 * @brief	In this function, a function dependant on the portmacro.h header
+	 * 			function calls to request a context switch can be specified.
+	 * This can be used if sending to the queue from an ISR caused a task
+	 * to unblock and a context switch is required.
+	 */
+	static void requestContextSwitch(CallContext callContext);
+
+	/**
+	 * If task preemption in FreeRTOS is disabled, a context switch
+	 * can be requested manually by calling this function.
+	 */
+	static void vRequestContextSwitchFromTask(void);
+
+	/**
+	 * @return The current task handle
+	 */
+	static TaskHandle_t getCurrentTaskHandle();
+
+	/**
+	 * Get returns the minimum amount of remaining stack space in words
+	 * that was a available to the task since the task started executing.
+	 * Please note that the actual value in bytes depends
+	 * on the stack depth type.
+	 * E.g. on a 32 bit machine, a value of 200 means 800 bytes.
+	 * @return Smallest value of stack remaining since the task was started in
+	 * 		   words.
+	 */
+	static size_t getTaskStackHighWatermark(
+	        TaskHandle_t task = nullptr);
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_ */

osal/host/Clock.cpp

@@ -0,0 +1,227 @@
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../timemanager/Clock.h"
+
+#include <chrono>
+#if defined(WIN32)
+#include <windows.h>
+#elif defined(LINUX)
+#include <fstream>
+#endif
+
+uint16_t Clock::leapSeconds = 0;
+MutexIF* Clock::timeMutex = NULL;
+
+using SystemClock = std::chrono::system_clock;
+
+uint32_t Clock::getTicksPerSecond(void){
+	sif::warning << "Clock::getTicksPerSecond: not implemented yet" << std::endl;
+	return 0;
+	//return CLOCKS_PER_SEC;
+	//uint32_t ticks = sysconf(_SC_CLK_TCK);
+	//return ticks;
+}
+
+ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
+	// do some magic with chrono
+	sif::warning << "Clock::setClock: not implemented yet" << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::setClock(const timeval* time) {
+	// do some magic with chrono
+#if defined(WIN32)
+	return HasReturnvaluesIF::RETURN_OK;
+#elif defined(LINUX)
+	return HasReturnvaluesIF::RETURN_OK;
+#else
+
+#endif
+	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t Clock::getClock_timeval(timeval* time) {
+#if defined(WIN32)
+	auto now  = std::chrono::system_clock::now();
+	auto secondsChrono = std::chrono::time_point_cast<std::chrono::seconds>(now);
+	auto epoch = now.time_since_epoch();
+	time->tv_sec = std::chrono::duration_cast<std::chrono::seconds>(epoch).count();
+	auto fraction = now - secondsChrono;
+	time->tv_usec = std::chrono::duration_cast<std::chrono::microseconds>(
+	        fraction).count();
+	return HasReturnvaluesIF::RETURN_OK;
+#elif defined(LINUX)
+	timespec timeUnix;
+	int status = clock_gettime(CLOCK_REALTIME,&timeUnix);
+	if(status!=0){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	time->tv_sec = timeUnix.tv_sec;
+	time->tv_usec = timeUnix.tv_nsec / 1000.0;
+	return HasReturnvaluesIF::RETURN_OK;
+#else
+	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
+	return HasReturnvaluesIF::RETURN_FAILED;
+#endif
+
+}
+
+ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
+	// do some magic with chrono
+	sif::warning << "Clock::gerClock_usecs: not implemented yet" << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+timeval Clock::getUptime() {
+	timeval timeval;
+#if defined(WIN32)
+	auto uptime  = std::chrono::milliseconds(GetTickCount64());
+	auto secondsChrono = std::chrono::duration_cast<std::chrono::seconds>(uptime);
+	timeval.tv_sec = secondsChrono.count();
+	auto fraction = uptime - secondsChrono;
+	timeval.tv_usec = std::chrono::duration_cast<std::chrono::microseconds>(
+	            fraction).count();
+#elif defined(LINUX)
+	double uptimeSeconds;
+	if (std::ifstream("/proc/uptime", std::ios::in) >> uptimeSeconds)
+	{
+		// value is rounded down automatically
+		timeval.tv_sec = uptimeSeconds;
+		timeval.tv_usec = uptimeSeconds *(double) 1e6 - (timeval.tv_sec *1e6);
+	}
+#else
+	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
+#endif
+	return timeval;
+}
+
+ReturnValue_t Clock::getUptime(timeval* uptime) {
+	*uptime = getUptime();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
+	timeval uptime = getUptime();
+	*uptimeMs = uptime.tv_sec * 1000 + uptime.tv_usec / 1000;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
+	// do some magic with chrono (C++20!)
+	// Right now, the library doesn't have the new features yet.
+	// so we work around that for now.
+	auto now = SystemClock::now();
+	auto seconds = std::chrono::time_point_cast<std::chrono::seconds>(now);
+	auto fraction = now - seconds;
+	time_t tt = SystemClock::to_time_t(now);
+	struct tm* timeInfo;
+	timeInfo = gmtime(&tt);
+	time->year = timeInfo->tm_year + 1900;
+	time->month = timeInfo->tm_mon+1;
+	time->day = timeInfo->tm_mday;
+	time->hour = timeInfo->tm_hour;
+	time->minute = timeInfo->tm_min;
+	time->second = timeInfo->tm_sec;
+	auto usecond = std::chrono::duration_cast<std::chrono::microseconds>(fraction);
+	time->usecond = usecond.count();
+
+	//sif::warning << "Clock::getDateAndTime: not implemented yet" << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
+		timeval* to) {
+	struct tm time_tm;
+
+	time_tm.tm_year = from->year - 1900;
+	time_tm.tm_mon = from->month - 1;
+	time_tm.tm_mday = from->day;
+
+	time_tm.tm_hour = from->hour;
+	time_tm.tm_min = from->minute;
+	time_tm.tm_sec = from->second;
+
+	time_t seconds = mktime(&time_tm);
+
+	to->tv_sec = seconds;
+	to->tv_usec = from->usecond;
+	//Fails in 2038..
+	return HasReturnvaluesIF::RETURN_OK;
+	sif::warning << "Clock::convertTimeBla: not implemented yet" << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
+	*JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24.
+			/ 3600.;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval* tt) {
+	//SHOULDDO: works not for dates in the past (might have less leap seconds)
+	if (timeMutex == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	uint16_t leapSeconds;
+	ReturnValue_t result = getLeapSeconds(&leapSeconds);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	timeval leapSeconds_timeval = { 0, 0 };
+	leapSeconds_timeval.tv_sec = leapSeconds;
+
+	//initial offset between UTC and TAI
+	timeval UTCtoTAI1972 = { 10, 0 };
+
+	timeval TAItoTT = { 32, 184000 };
+
+	*tt = utc + leapSeconds_timeval + UTCtoTAI1972 + TAItoTT;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
+	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	leapSeconds = leapSeconds_;
+
+	result = timeMutex->unlockMutex();
+	return result;
+}
+
+ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
+	if(timeMutex == nullptr){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	*leapSeconds_ = leapSeconds;
+
+	result = timeMutex->unlockMutex();
+	return result;
+}
+
+ReturnValue_t Clock::checkOrCreateClockMutex(){
+	if(timeMutex == nullptr){
+		MutexFactory* mutexFactory = MutexFactory::instance();
+		if (mutexFactory == nullptr) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		timeMutex = mutexFactory->createMutex();
+		if (timeMutex == nullptr) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}

osal/host/FixedTimeslotTask.cpp

@@ -0,0 +1,197 @@
+#include "../../osal/host/FixedTimeslotTask.h"
+
+#include "../../ipc/MutexFactory.h"
+#include "../../osal/host/Mutex.h"
+#include "../../osal/host/FixedTimeslotTask.h"
+
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tasks/ExecutableObjectIF.h"
+
+#include <thread>
+#include <chrono>
+
+#if defined(WIN32)
+#include <windows.h>
+#elif defined(LINUX)
+#include <pthread.h>
+#endif
+
+FixedTimeslotTask::FixedTimeslotTask(const char *name, TaskPriority setPriority,
+        TaskStackSize setStack, TaskPeriod setPeriod,
+        void (*setDeadlineMissedFunc)()) :
+        started(false), pollingSeqTable(setPeriod*1000), taskName(name),
+        period(setPeriod), deadlineMissedFunc(setDeadlineMissedFunc) {
+    // It is propably possible to set task priorities by using the native
+    // task handles for Windows / Linux
+    mainThread = std::thread(&FixedTimeslotTask::taskEntryPoint, this, this);
+#if defined(WIN32)
+    /* List of possible priority classes:
+     * https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/
+     * nf-processthreadsapi-setpriorityclass
+     * And respective thread priority numbers:
+     * https://docs.microsoft.com/en-us/windows/
+     * win32/procthread/scheduling-priorities */
+    int result = SetPriorityClass(
+            reinterpret_cast<HANDLE>(mainThread.native_handle()),
+            ABOVE_NORMAL_PRIORITY_CLASS);
+    if(result != 0) {
+        sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
+                << GetLastError() << std::endl;
+    }
+    result = SetThreadPriority(
+            reinterpret_cast<HANDLE>(mainThread.native_handle()),
+            THREAD_PRIORITY_NORMAL);
+    if(result != 0) {
+        sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
+                << GetLastError() << std::endl;
+    }
+#elif defined(LINUX)
+    // we can just copy and paste the code from linux here.
+#endif
+}
+
+FixedTimeslotTask::~FixedTimeslotTask(void) {
+    //Do not delete objects, we were responsible for ptrs only.
+    terminateThread = true;
+    if(mainThread.joinable()) {
+        mainThread.join();
+    }
+    delete this;
+}
+
+void FixedTimeslotTask::taskEntryPoint(void* argument) {
+    FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
+
+    if (not originalTask->started) {
+        // we have to suspend/block here until the task is started.
+        // if semaphores are implemented, use them here.
+        std::unique_lock<std::mutex> lock(initMutex);
+        initCondition.wait(lock);
+    }
+
+    this->taskFunctionality();
+    sif::debug << "FixedTimeslotTask::taskEntryPoint: "
+            "Returned from taskFunctionality." << std::endl;
+}
+
+ReturnValue_t FixedTimeslotTask::startTask() {
+    started = true;
+
+    // Notify task to start.
+    std::lock_guard<std::mutex> lock(initMutex);
+    initCondition.notify_one();
+
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(ms));
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void FixedTimeslotTask::taskFunctionality() {
+    pollingSeqTable.intializeSequenceAfterTaskCreation();
+
+    // A local iterator for the Polling Sequence Table is created to
+    // find the start time for the first entry.
+    auto slotListIter = pollingSeqTable.current;
+
+    // Get start time for first entry.
+    chron_ms interval(slotListIter->pollingTimeMs);
+    auto currentStartTime {
+            std::chrono::duration_cast<chron_ms>(
+            std::chrono::system_clock::now().time_since_epoch())
+    };
+    if(interval.count() > 0) {
+        delayForInterval(&currentStartTime, interval);
+    }
+
+    /* Enter the loop that defines the task behavior. */
+    for (;;) {
+        if(terminateThread.load()) {
+            break;
+        }
+        //The component for this slot is executed and the next one is chosen.
+        this->pollingSeqTable.executeAndAdvance();
+        if (not pollingSeqTable.slotFollowsImmediately()) {
+            // we need to wait before executing the current slot
+            //this gives us the time to wait:
+            interval = chron_ms(this->pollingSeqTable.getIntervalToPreviousSlotMs());
+            delayForInterval(&currentStartTime, interval);
+            //TODO deadline missed check
+        }
+    }
+}
+
+ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
+        uint32_t slotTimeMs, int8_t executionStep) {
+    ExecutableObjectIF* executableObject = objectManager->
+            get<ExecutableObjectIF>(componentId);
+    if (executableObject != nullptr) {
+        pollingSeqTable.addSlot(componentId, slotTimeMs, executionStep,
+                executableObject, this);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
+    sif::error << "Component " << std::hex << componentId <<
+            " not found, not adding it to pst" << std::endl;
+    return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t FixedTimeslotTask::checkSequence() const {
+    return pollingSeqTable.checkSequence();
+}
+
+uint32_t FixedTimeslotTask::getPeriodMs() const {
+    return period * 1000;
+}
+
+bool FixedTimeslotTask::delayForInterval(chron_ms * previousWakeTimeMs,
+        const chron_ms interval) {
+    bool shouldDelay = false;
+    //Get current wakeup time
+    auto currentStartTime =
+            std::chrono::duration_cast<chron_ms>(
+            std::chrono::system_clock::now().time_since_epoch());
+    /* Generate the tick time at which the task wants to wake. */
+    auto nextTimeToWake_ms = (*previousWakeTimeMs) + interval;
+
+    if (currentStartTime < *previousWakeTimeMs) {
+        /* The tick count has overflowed since this function was
+         lasted called.  In this case the only time we should ever
+         actually delay is if the wake time has also    overflowed,
+         and the wake time is greater than the tick time.  When this
+         is the case it is as if neither time had overflowed. */
+        if ((nextTimeToWake_ms < *previousWakeTimeMs)
+                && (nextTimeToWake_ms > currentStartTime)) {
+            shouldDelay = true;
+        }
+    } else {
+        /* The tick time has not overflowed.  In this case we will
+         delay if either the wake time has overflowed, and/or the
+         tick time is less than the wake time. */
+        if ((nextTimeToWake_ms < *previousWakeTimeMs)
+                || (nextTimeToWake_ms >  currentStartTime)) {
+            shouldDelay = true;
+        }
+    }
+
+    /* Update the wake time ready for the next call. */
+
+    (*previousWakeTimeMs) =  nextTimeToWake_ms;
+
+    if (shouldDelay) {
+        auto sleepTime = std::chrono::duration_cast<chron_ms>(
+                nextTimeToWake_ms - currentStartTime);
+        std::this_thread::sleep_for(sleepTime);
+        return true;
+    }
+    //We are shifting the time in case the deadline was missed like rtems
+    (*previousWakeTimeMs) = currentStartTime;
+    return false;
+
+}
+
+
+
+

osal/host/FixedTimeslotTask.h

@@ -0,0 +1,130 @@
+#ifndef FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_
+#define FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_
+
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../tasks/FixedSlotSequence.h"
+#include "../../tasks/FixedTimeslotTaskIF.h"
+#include "../../tasks/Typedef.h"
+
+#include <vector>
+#include <thread>
+#include <condition_variable>
+#include <atomic>
+
+class ExecutableObjectIF;
+
+/**
+ * @brief   This class represents a task for periodic activities with multiple
+ *          steps and strict timeslot requirements for these steps.
+ * @details
+ * @ingroup task_handling
+ */
+class FixedTimeslotTask: public FixedTimeslotTaskIF {
+public:
+    /**
+     * @brief   Standard constructor of the class.
+     * @details
+     * The class is initialized without allocated objects. These need to be
+     * added with #addComponent.
+     * @param priority
+     * @param stack_size
+     * @param setPeriod
+     * @param setDeadlineMissedFunc
+     * The function pointer to the deadline missed function that shall be
+     * assigned.
+     */
+    FixedTimeslotTask(const char *name, TaskPriority setPriority,
+            TaskStackSize setStack, TaskPeriod setPeriod,
+            void (*setDeadlineMissedFunc)());
+    /**
+     * @brief   Currently, the executed object's lifetime is not coupled with
+     *          the task object's lifetime, so the destructor is empty.
+     */
+    virtual ~FixedTimeslotTask(void);
+
+    /**
+     * @brief   The method to start the task.
+     * @details The method starts the task with the respective system call.
+     *          Entry point is the taskEntryPoint method described below.
+     *          The address of the task object is passed as an argument
+     *          to the system call.
+     */
+    ReturnValue_t startTask(void);
+
+    /**
+     * Add timeslot to the polling sequence table.
+     * @param componentId
+     * @param slotTimeMs
+     * @param executionStep
+     * @return
+     */
+    ReturnValue_t addSlot(object_id_t componentId,
+                   uint32_t slotTimeMs, int8_t executionStep);
+
+    ReturnValue_t checkSequence() const override;
+
+    uint32_t getPeriodMs() const;
+
+    ReturnValue_t sleepFor(uint32_t ms);
+
+protected:
+    using chron_ms = std::chrono::milliseconds;
+
+    bool started;
+    //!< Typedef for the List of objects.
+    typedef std::vector<ExecutableObjectIF*> ObjectList;
+    std::thread mainThread;
+    std::atomic<bool> terminateThread = false;
+
+    //! Polling sequence table which contains the object to execute
+    //! and information like the timeslots and the passed execution step.
+    FixedSlotSequence pollingSeqTable;
+
+    std::condition_variable initCondition;
+    std::mutex initMutex;
+    std::string taskName;
+    /**
+     * @brief   The period of the task.
+     * @details
+     * The period determines the frequency of the task's execution.
+     * It is expressed in clock ticks.
+     */
+    TaskPeriod period;
+
+    /**
+     * @brief   The pointer to the deadline-missed function.
+     * @details
+     * This pointer stores the function that is executed if the task's deadline
+     * is missed. So, each may react individually on a timing failure.
+     * The pointer may be NULL, then nothing happens on missing the deadline.
+     * The deadline is equal to the next execution of the periodic task.
+     */
+    void (*deadlineMissedFunc)(void);
+    /**
+     * @brief   This is the function executed in the new task's context.
+     * @details
+     * It converts the argument back to the thread object type and copies the
+     * class instance to the task context.
+     * The taskFunctionality method is called afterwards.
+     * @param   A pointer to the task object itself is passed as argument.
+     */
+
+    void taskEntryPoint(void* argument);
+    /**
+     * @brief   The function containing the actual functionality of the task.
+     * @details
+     * The method sets and starts the task's period, then enters a loop that is
+     * repeated as long as the isRunning attribute is true. Within the loop,
+     * all performOperation methods of the added objects are called. Afterwards
+     * the checkAndRestartPeriod system call blocks the task until the next
+     *  period. On missing the deadline, the deadlineMissedFunction is executed.
+     */
+    void taskFunctionality(void);
+
+    bool delayForInterval(chron_ms * previousWakeTimeMs,
+            const chron_ms interval);
+};
+
+
+
+#endif /* FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_ */

osal/host/MessageQueue.cpp

@@ -0,0 +1,159 @@
+#include "MessageQueue.h"
+#include "QueueMapManager.h"
+
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../ipc/MutexFactory.h"
+#include "../../ipc/MutexHelper.h"
+
+MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
+		messageSize(maxMessageSize), messageDepth(messageDepth) {
+	queueLock = MutexFactory::instance()->createMutex();
+	auto result = QueueMapManager::instance()->addMessageQueue(this, &mqId);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "MessageQueue::MessageQueue:"
+		        << " Could not be created" << std::endl;
+	}
+}
+
+MessageQueue::~MessageQueue() {
+	MutexFactory::instance()->deleteMutex(queueLock);
+}
+
+ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
+		MessageQueueMessageIF* message, bool ignoreFault) {
+	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
+}
+
+ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
+	return sendToDefaultFrom(message, this->getId());
+}
+
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
+		MessageQueueId_t sentFrom, bool ignoreFault) {
+	return sendMessageFrom(defaultDestination,message,sentFrom,ignoreFault);
+}
+
+ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
+	if (this->lastPartner != 0) {
+		return sendMessageFrom(this->lastPartner, message, this->getId());
+	} else {
+		return MessageQueueIF::NO_REPLY_PARTNER;
+	}
+}
+
+ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
+		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
+	return sendMessageFromMessageQueue(sendTo, message, sentFrom,
+			ignoreFault);
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
+		MessageQueueId_t* receivedFrom) {
+	ReturnValue_t status = this->receiveMessage(message);
+	if(status == HasReturnvaluesIF::RETURN_OK) {
+		*receivedFrom = this->lastPartner;
+	}
+	return status;
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
+	if(messageQueue.empty()) {
+		return MessageQueueIF::EMPTY;
+	}
+	// not sure this will work..
+	//*message = std::move(messageQueue.front());
+	MutexHelper mutexLock(queueLock, MutexIF::TimeoutType::WAITING, 20);
+	MessageQueueMessage* currentMessage = &messageQueue.front();
+	std::copy(currentMessage->getBuffer(),
+			currentMessage->getBuffer() + messageSize, message->getBuffer());
+	messageQueue.pop();
+	// The last partner is the first uint32_t field in the message
+	this->lastPartner = message->getSender();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueId_t MessageQueue::getLastPartner() const {
+	return lastPartner;
+}
+
+ReturnValue_t MessageQueue::flush(uint32_t* count) {
+	*count = messageQueue.size();
+	// Clears the queue.
+	messageQueue = std::queue<MessageQueueMessage>();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueId_t MessageQueue::getId() const {
+	return mqId;
+}
+
+void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
+	defaultDestinationSet = true;
+	this->defaultDestination = defaultDestination;
+}
+
+MessageQueueId_t MessageQueue::getDefaultDestination() const {
+	return defaultDestination;
+}
+
+bool MessageQueue::isDefaultDestinationSet() const {
+	return defaultDestinationSet;
+}
+
+
+// static core function to send messages.
+ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+        MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+        bool ignoreFault) {
+	if(message->getMessageSize() > message->getMaximumMessageSize()) {
+		// Actually, this should never happen or an error will be emitted
+		// in MessageQueueMessage.
+		// But I will still return a failure here.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	MessageQueue* targetQueue = dynamic_cast<MessageQueue*>(
+			QueueMapManager::instance()->getMessageQueue(sendTo));
+	if(targetQueue == nullptr) {
+		if(not ignoreFault) {
+			InternalErrorReporterIF* internalErrorReporter =
+					objectManager->get<InternalErrorReporterIF>(
+							objects::INTERNAL_ERROR_REPORTER);
+			if (internalErrorReporter != nullptr) {
+				internalErrorReporter->queueMessageNotSent();
+			}
+		}
+		// TODO: Better returnvalue
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if(targetQueue->messageQueue.size() < targetQueue->messageDepth) {
+		MutexHelper mutexLock(targetQueue->queueLock,
+		        MutexIF::TimeoutType::WAITING, 20);
+		// not ideal, works for now though.
+		MessageQueueMessage* mqmMessage =
+				dynamic_cast<MessageQueueMessage*>(message);
+		if(message != nullptr) {
+			targetQueue->messageQueue.push(*mqmMessage);
+		}
+		else {
+			sif::error << "MessageQueue::sendMessageFromMessageQueue: Message"
+					"is not MessageQueueMessage!" << std::endl;
+		}
+
+	}
+	else {
+		return MessageQueueIF::FULL;
+	}
+    message->setSender(sentFrom);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t MessageQueue::lockQueue(MutexIF::TimeoutType timeoutType,
+        dur_millis_t lockTimeout) {
+	return queueLock->lockMutex(timeoutType, lockTimeout);
+}
+
+ReturnValue_t MessageQueue::unlockQueue() {
+	return queueLock->unlockMutex();
+}

osal/host/MessageQueue.h

@@ -0,0 +1,231 @@
+#ifndef FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_
+#define FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_
+
+#include "../../internalError/InternalErrorReporterIF.h"
+#include "../../ipc/MessageQueueIF.h"
+#include "../../ipc/MessageQueueMessage.h"
+#include "../../ipc/MutexIF.h"
+#include "../../timemanager/Clock.h"
+
+#include <queue>
+#include <memory>
+
+/**
+ * @brief		This class manages sending and receiving of
+ * 				message queue messages.
+ * @details
+ * Message queues are used to pass asynchronous messages between processes.
+ * They work like post boxes, where all incoming messages are stored in FIFO
+ * order. This class creates a new receiving queue and provides methods to fetch
+ * received messages. Being a child of MessageQueueSender, this class also
+ * provides methods to send a message to a user-defined or a default destination.
+ * In addition it also provides a reply method to answer to the queue it
+ * received its last message from.
+ *
+ * The MessageQueue should be used as "post box" for a single owning object.
+ * So all message queue communication is "n-to-one".
+ * For creating the queue, as well as sending and receiving messages, the class
+ * makes use of the operating system calls provided.
+ *
+ * Please keep in mind that FreeRTOS offers different calls for message queue
+ * operations if called from an ISR.
+ * For now, the system context needs to be switched manually.
+ * @ingroup osal
+ * @ingroup message_queue
+ */
+class MessageQueue : public MessageQueueIF {
+	friend class MessageQueueSenderIF;
+public:
+	/**
+	 * @brief	The constructor initializes and configures the message queue.
+	 * @details
+	 * By making use of the according operating system call, a message queue is
+	 * created and initialized. The message depth - the maximum number of
+	 * messages to be buffered - may be set with the help of a parameter,
+	 * whereas the message size is automatically set to the maximum message
+	 * queue message size. The operating system sets the message queue id, or
+	 * in case of failure, it is set to zero.
+	 * @param message_depth
+	 * The number of messages to be buffered before passing an error to the
+	 * sender. Default is three.
+	 * @param max_message_size
+	 * With this parameter, the maximum message size can be adjusted.
+	 * This should be left default.
+	 */
+	MessageQueue(size_t messageDepth = 3,
+			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);
+
+	/** Copying message queues forbidden */
+	MessageQueue(const MessageQueue&) = delete;
+	MessageQueue& operator=(const MessageQueue&) = delete;
+
+	/**
+	 * @brief	The destructor deletes the formerly created message queue.
+	 * @details	This is accomplished by using the delete call provided
+	 * 			by the operating system.
+	 */
+	virtual ~MessageQueue();
+
+	/**
+	 * @brief	This operation sends a message to the given destination.
+	 * @details	It directly uses the sendMessage call of the MessageQueueSender
+	 * parent, but passes its queue id as "sentFrom" parameter.
+	 * @param sendTo	This parameter specifies the message queue id of the
+	 *  destination message queue.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 * @param ignoreFault If set to true, the internal software fault counter
+	 * is not incremented if queue is full.
+	 */
+	ReturnValue_t sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, bool ignoreFault = false) override;
+	/**
+	 * @brief	This operation sends a message to the default destination.
+	 * @details	As in the sendMessage method, this function uses the
+	 * sendToDefault call of the MessageQueueSender parent class and adds its
+	 * queue id as "sentFrom" information.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 */
+	ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
+	/**
+	 * @brief	This operation sends a message to the last communication partner.
+	 * @details	This operation simplifies answering an incoming message by using
+	 * the stored lastPartner information as destination. If there was no
+	 * message received yet (i.e. lastPartner is zero), an error code is returned.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 */
+	ReturnValue_t reply(MessageQueueMessageIF* message) override;
+
+	/**
+	 * @brief	With the sendMessage call, a queue message is sent to a
+	 * 			receiving queue.
+	 * @details
+	 * This method takes the message provided, adds the sentFrom information and
+	 * passes it on to the destination provided with an operating system call.
+	 *  The OS's return value is returned.
+	 * @param sendTo	This parameter specifies the message queue id to send
+	 * the message to.
+	 * @param message	This is a pointer to a previously created message,
+	 * which is sent.
+	 * @param sentFrom	The sentFrom information can be set to inject the
+	 * sender's queue id into the message. This variable is set to zero by
+	 * default.
+	 * @param ignoreFault If set to true, the internal software fault counter
+	 * is not incremented if queue is full.
+	 */
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault = false) override;
+
+	/**
+	 * @brief	The sendToDefault method sends a queue message to the default
+	 * 			destination.
+	 * @details
+	 * In all other aspects, it works identical to the sendMessage method.
+	 * @param message	This is a pointer to a previously created message,
+	 * which is sent.
+	 * @param sentFrom	The sentFrom information can be set to inject the
+	 * sender's queue id into the message. This variable is set to zero by
+	 * default.
+	 */
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault = false) override;
+
+	/**
+	 * @brief	This function reads available messages from the message queue
+	 * 			and returns the sender.
+	 * @details
+	 * It works identically to the other receiveMessage call, but in  addition
+	 * returns the sender's queue id.
+	 * @param message	A pointer to a message in which the received data is stored.
+	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
+	 */
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
+			MessageQueueId_t *receivedFrom) override;
+
+	/**
+	 * @brief	This function reads available messages from the message queue.
+	 * @details
+	 * If data is available it is stored in the passed message pointer.
+	 * The message's original content is overwritten and the sendFrom
+	 * information is stored in the lastPartner attribute. Else, the lastPartner
+	 * information remains untouched, the message's content is cleared and the
+	 * function returns immediately.
+	 * @param message	A pointer to a message in which the received data is stored.
+	 */
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
+	/**
+	 * Deletes all pending messages in the queue.
+	 * @param count The number of flushed messages.
+	 * @return RETURN_OK on success.
+	 */
+	ReturnValue_t flush(uint32_t* count) override;
+	/**
+	 * @brief	This method returns the message queue id of the last
+	 * 			communication partner.
+	 */
+	MessageQueueId_t getLastPartner() const override;
+	/**
+	 * @brief	This method returns the message queue id of this class's
+	 * 			message queue.
+	 */
+	MessageQueueId_t getId() const override;
+
+	/**
+	 * @brief	This method is a simple setter for the default destination.
+	 */
+	void setDefaultDestination(MessageQueueId_t defaultDestination) override;
+	/**
+	 * @brief	This method is a simple getter for the default destination.
+	 */
+	MessageQueueId_t getDefaultDestination() const override;
+
+	bool isDefaultDestinationSet() const override;
+
+	ReturnValue_t lockQueue(MutexIF::TimeoutType timeoutType,
+	        dur_millis_t lockTimeout);
+	ReturnValue_t unlockQueue();
+protected:
+	/**
+	 * @brief 	Implementation to be called from any send Call within
+	 * 			MessageQueue and MessageQueueSenderIF.
+	 * @details
+	 * This method takes the message provided, adds the sentFrom information and
+	 * passes it on to the destination provided with an operating system call.
+	 * The OS's return value is returned.
+	 * @param sendTo
+	 * This parameter specifies the message queue id to send the message to.
+	 * @param message
+	 * This is a pointer to a previously created message, which is sent.
+	 * @param sentFrom
+	 * The sentFrom information can be set to inject the sender's queue id into
+	 * the message. This variable is set to zero by default.
+	 * @param ignoreFault
+	 * If set to true, the internal software fault counter  is not incremented
+	 * if queue is full.
+	 * @param context Specify whether call is made from task or from an ISR.
+	 */
+	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault=false);
+
+	//static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
+
+private:
+	std::queue<MessageQueueMessage> messageQueue;
+	/**
+	 * @brief	The class stores the queue id it got assigned.
+	 * 			If initialization fails, the queue id is set to zero.
+	 */
+	MessageQueueId_t mqId = 0;
+	size_t messageSize = 0;
+	size_t messageDepth = 0;
+
+	MutexIF* queueLock;
+
+	bool defaultDestinationSet = false;
+	MessageQueueId_t defaultDestination = 0;
+	MessageQueueId_t lastPartner = 0;
+};
+
+#endif /* FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_ */

osal/host/Mutex.cpp

@@ -0,0 +1,39 @@
+#include "Mutex.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+Mutex::Mutex() {}
+
+ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
+	if(timeoutMs == MutexIF::BLOCKING) {
+		mutex.lock();
+		locked = true;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else if(timeoutMs == MutexIF::POLLING) {
+		if(mutex.try_lock()) {
+			locked = true;
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+	}
+	else if(timeoutMs > MutexIF::POLLING){
+		auto chronoMs = std::chrono::milliseconds(timeoutMs);
+		if(mutex.try_lock_for(chronoMs)) {
+			locked = true;
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+	}
+	return MutexIF::MUTEX_TIMEOUT;
+}
+
+ReturnValue_t Mutex::unlockMutex() {
+	if(not locked) {
+		return MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX;
+	}
+	mutex.unlock();
+	locked = false;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+std::timed_mutex* Mutex::getMutexHandle() {
+	return &mutex;
+}

osal/host/Mutex.h

@@ -0,0 +1,29 @@
+#ifndef FSFW_OSAL_HOSTED_MUTEX_H_
+#define FSFW_OSAL_HOSTED_MUTEX_H_
+
+#include "../../ipc/MutexIF.h"
+
+#include <mutex>
+
+/**
+ * @brief OS component to implement MUTual EXclusion
+ *
+ * @details
+ * Mutexes are binary semaphores which include a priority inheritance mechanism.
+ * Documentation: https://www.freertos.org/Real-time-embedded-RTOS-mutexes.html
+ * @ingroup osal
+ */
+class Mutex : public MutexIF {
+public:
+	Mutex();
+	ReturnValue_t lockMutex(TimeoutType timeoutType =
+            TimeoutType::BLOCKING, uint32_t timeoutMs = 0) override;
+	ReturnValue_t unlockMutex() override;
+
+	std::timed_mutex* getMutexHandle();
+private:
+	bool locked = false;
+	std::timed_mutex mutex;
+};
+
+#endif /* FSFW_OSAL_HOSTED_MUTEX_H_ */

osal/host/MutexFactory.cpp

@@ -0,0 +1,28 @@
+#include "../../ipc/MutexFactory.h"
+#include "../../osal/host/Mutex.h"
+
+//TODO: Different variant than the lazy loading in QueueFactory.
+//What's better and why? -> one is on heap the other on bss/data
+//MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
+MutexFactory* MutexFactory::factoryInstance = nullptr;
+
+MutexFactory::MutexFactory() {
+}
+
+MutexFactory::~MutexFactory() {
+}
+
+MutexFactory* MutexFactory::instance() {
+	if (factoryInstance == nullptr){
+		factoryInstance = new MutexFactory();
+	}
+	return MutexFactory::factoryInstance;
+}
+
+MutexIF* MutexFactory::createMutex() {
+	return new Mutex();
+}
+
+void MutexFactory::deleteMutex(MutexIF* mutex) {
+	delete mutex;
+}

osal/host/PeriodicTask.cpp

@@ -0,0 +1,176 @@
+#include "Mutex.h"
+#include "PeriodicTask.h"
+
+#include "../../ipc/MutexFactory.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tasks/ExecutableObjectIF.h"
+
+#include <thread>
+#include <chrono>
+
+#if defined(WIN32)
+#include <windows.h>
+#elif defined(LINUX)
+#include <pthread.h>
+#endif
+
+PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
+		TaskStackSize setStack, TaskPeriod setPeriod,
+		void (*setDeadlineMissedFunc)()) :
+		started(false), taskName(name), period(setPeriod),
+		deadlineMissedFunc(setDeadlineMissedFunc) {
+    // It is propably possible to set task priorities by using the native
+    // task handles for Windows / Linux
+	mainThread = std::thread(&PeriodicTask::taskEntryPoint, this, this);
+#if defined(WIN32)
+    /* List of possible priority classes:
+     * https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/
+     * nf-processthreadsapi-setpriorityclass
+     * And respective thread priority numbers:
+     * https://docs.microsoft.com/en-us/windows/
+     * win32/procthread/scheduling-priorities */
+    int result = SetPriorityClass(
+            reinterpret_cast<HANDLE>(mainThread.native_handle()),
+            ABOVE_NORMAL_PRIORITY_CLASS);
+    if(result != 0) {
+        sif::error << "PeriodicTask: Windows SetPriorityClass failed with code "
+                << GetLastError() << std::endl;
+    }
+    result = SetThreadPriority(
+            reinterpret_cast<HANDLE>(mainThread.native_handle()),
+            THREAD_PRIORITY_NORMAL);
+    if(result != 0) {
+        sif::error << "PeriodicTask: Windows SetPriorityClass failed with code "
+                << GetLastError() << std::endl;
+    }
+#elif defined(LINUX)
+    // we can just copy and paste the code from linux here.
+#endif
+}
+
+PeriodicTask::~PeriodicTask(void) {
+	//Do not delete objects, we were responsible for ptrs only.
+	terminateThread = true;
+	if(mainThread.joinable()) {
+		mainThread.join();
+	}
+	delete this;
+}
+
+void PeriodicTask::taskEntryPoint(void* argument) {
+	PeriodicTask *originalTask(reinterpret_cast<PeriodicTask*>(argument));
+
+
+	if (not originalTask->started) {
+		// we have to suspend/block here until the task is started.
+		// if semaphores are implemented, use them here.
+		std::unique_lock<std::mutex> lock(initMutex);
+		initCondition.wait(lock);
+	}
+
+	this->taskFunctionality();
+	sif::debug << "PeriodicTask::taskEntryPoint: "
+			"Returned from taskFunctionality." << std::endl;
+}
+
+ReturnValue_t PeriodicTask::startTask() {
+	started = true;
+
+	// Notify task to start.
+	std::lock_guard<std::mutex> lock(initMutex);
+	initCondition.notify_one();
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t PeriodicTask::sleepFor(uint32_t ms) {
+	std::this_thread::sleep_for(std::chrono::milliseconds(ms));
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void PeriodicTask::taskFunctionality() {
+	std::chrono::milliseconds periodChrono(static_cast<uint32_t>(period*1000));
+	auto currentStartTime {
+	    std::chrono::duration_cast<std::chrono::milliseconds>(
+	    std::chrono::system_clock::now().time_since_epoch())
+	};
+	auto nextStartTime{ currentStartTime };
+
+	/* Enter the loop that defines the task behavior. */
+	for (;;) {
+		if(terminateThread.load()) {
+			break;
+		}
+		for (ObjectList::iterator it = objectList.begin();
+				it != objectList.end(); ++it) {
+			(*it)->performOperation();
+		}
+		if(not delayForInterval(&currentStartTime, periodChrono)) {
+			sif::warning << "PeriodicTask: " << taskName <<
+					" missed deadline!\n" << std::flush;
+			if(deadlineMissedFunc != nullptr) {
+				this->deadlineMissedFunc();
+			}
+		}
+	}
+}
+
+ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
+	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
+			object);
+	if (newObject == nullptr) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	objectList.push_back(newObject);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint32_t PeriodicTask::getPeriodMs() const {
+	return period * 1000;
+}
+
+bool PeriodicTask::delayForInterval(chron_ms* previousWakeTimeMs,
+        const chron_ms interval) {
+    bool shouldDelay = false;
+    //Get current wakeup time
+    auto currentStartTime =
+            std::chrono::duration_cast<std::chrono::milliseconds>(
+            std::chrono::system_clock::now().time_since_epoch());
+    /* Generate the tick time at which the task wants to wake. */
+    auto nextTimeToWake_ms = (*previousWakeTimeMs) + interval;
+
+    if (currentStartTime < *previousWakeTimeMs) {
+        /* The tick count has overflowed since this function was
+         lasted called.  In this case the only time we should ever
+         actually delay is if the wake time has also    overflowed,
+         and the wake time is greater than the tick time.  When this
+         is the case it is as if neither time had overflowed. */
+        if ((nextTimeToWake_ms < *previousWakeTimeMs)
+                && (nextTimeToWake_ms > currentStartTime)) {
+            shouldDelay = true;
+        }
+    } else {
+        /* The tick time has not overflowed.  In this case we will
+         delay if either the wake time has overflowed, and/or the
+         tick time is less than the wake time. */
+        if ((nextTimeToWake_ms < *previousWakeTimeMs)
+                || (nextTimeToWake_ms >  currentStartTime)) {
+            shouldDelay = true;
+        }
+    }
+
+    /* Update the wake time ready for the next call. */
+
+    (*previousWakeTimeMs) =  nextTimeToWake_ms;
+
+    if (shouldDelay) {
+        auto sleepTime = std::chrono::duration_cast<std::chrono::milliseconds>(
+                nextTimeToWake_ms - currentStartTime);
+        std::this_thread::sleep_for(sleepTime);
+        return true;
+    }
+    //We are shifting the time in case the deadline was missed like rtems
+    (*previousWakeTimeMs) = currentStartTime;
+    return false;
+
+}

osal/host/PeriodicTask.h

@@ -0,0 +1,123 @@
+#ifndef FRAMEWORK_OSAL_HOST_PERIODICTASK_H_
+#define FRAMEWORK_OSAL_HOST_PERIODICTASK_H_
+
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../tasks/PeriodicTaskIF.h"
+#include "../../tasks/Typedef.h"
+
+#include <vector>
+#include <thread>
+#include <condition_variable>
+#include <atomic>
+
+class ExecutableObjectIF;
+
+/**
+ * @brief 	This class represents a specialized task for
+ * 			periodic activities of multiple objects.
+ * @details
+ *
+ * @ingroup task_handling
+ */
+class PeriodicTask: public PeriodicTaskIF {
+public:
+	/**
+	 * @brief	Standard constructor of the class.
+	 * @details
+	 * The class is initialized without allocated objects. These need to be
+	 * added with #addComponent.
+	 * @param priority
+	 * @param stack_size
+	 * @param setPeriod
+	 * @param setDeadlineMissedFunc
+	 * The function pointer to the deadline missed function that shall be
+	 * assigned.
+	 */
+	PeriodicTask(const char *name, TaskPriority setPriority, TaskStackSize setStack,
+			TaskPeriod setPeriod,void (*setDeadlineMissedFunc)());
+	/**
+	 * @brief	Currently, the executed object's lifetime is not coupled with
+	 * 			the task object's lifetime, so the destructor is empty.
+	 */
+	virtual ~PeriodicTask(void);
+
+	/**
+	 * @brief	The method to start the task.
+	 * @details	The method starts the task with the respective system call.
+	 * 			Entry point is the taskEntryPoint method described below.
+	 * 			The address of the task object is passed as an argument
+	 * 			to the system call.
+	 */
+	ReturnValue_t startTask(void);
+	/**
+	 * Adds an object to the list of objects to be executed.
+	 * The objects are executed in the order added.
+	 * @param object Id of the object to add.
+	 * @return
+	 *  -@c RETURN_OK on success
+	 *  -@c RETURN_FAILED if the object could not be added.
+	 */
+	ReturnValue_t addComponent(object_id_t object);
+
+	uint32_t getPeriodMs() const;
+
+	ReturnValue_t sleepFor(uint32_t ms);
+
+protected:
+	using chron_ms = std::chrono::milliseconds;
+	bool started;
+	//!< Typedef for the List of objects.
+	typedef std::vector<ExecutableObjectIF*> ObjectList;
+	std::thread mainThread;
+	std::atomic<bool> terminateThread = false;
+
+	/**
+	 * @brief	This attribute holds a list of objects to be executed.
+	 */
+	ObjectList objectList;
+
+	std::condition_variable initCondition;
+	std::mutex initMutex;
+	std::string taskName;
+	/**
+	 * @brief	The period of the task.
+	 * @details
+	 * The period determines the frequency of the task's execution.
+	 * It is expressed in clock ticks.
+	 */
+	TaskPeriod period;
+	/**
+	 * @brief	The pointer to the deadline-missed function.
+	 * @details
+	 * This pointer stores the function that is executed if the task's deadline
+	 * is missed. So, each may react individually on a timing failure.
+	 * The pointer may be NULL, then nothing happens on missing the deadline.
+	 * The deadline is equal to the next execution of the periodic task.
+	 */
+	void (*deadlineMissedFunc)(void);
+	/**
+	 * @brief	This is the function executed in the new task's context.
+	 * @details
+	 * It converts the argument back to the thread object type and copies the
+	 * class instance to the task context.
+	 * The taskFunctionality method is called afterwards.
+	 * @param	A pointer to the task object itself is passed as argument.
+	 */
+
+	void taskEntryPoint(void* argument);
+	/**
+	 * @brief	The function containing the actual functionality of the task.
+	 * @details
+	 * The method sets and starts the task's period, then enters a loop that is
+	 * repeated as long as the isRunning attribute is true. Within the loop,
+	 * all performOperation methods of the added objects are called. Afterwards
+	 * the checkAndRestartPeriod system call blocks the task until the next
+	 *  period. On missing the deadline, the deadlineMissedFunction is executed.
+	 */
+	void taskFunctionality(void);
+
+	bool delayForInterval(chron_ms * previousWakeTimeMs,
+	        const chron_ms interval);
+};
+
+#endif /* PERIODICTASK_H_ */

osal/host/QueueFactory.cpp

@@ -0,0 +1,41 @@
+#include "../../ipc/QueueFactory.h"
+#include "../../osal/host/MessageQueue.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include <cstring>
+
+QueueFactory* QueueFactory::factoryInstance = nullptr;
+
+
+ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+			bool ignoreFault) {
+	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
+			sentFrom,ignoreFault);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+QueueFactory* QueueFactory::instance() {
+	if (factoryInstance == nullptr) {
+		factoryInstance = new QueueFactory;
+	}
+	return factoryInstance;
+}
+
+QueueFactory::QueueFactory() {
+}
+
+QueueFactory::~QueueFactory() {
+}
+
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
+		size_t maxMessageSize) {
+	// A thread-safe queue can be implemented  by using a combination
+	// of std::queue and std::mutex. This uses dynamic memory allocation
+	// which could be alleviated by using a custom allocator, external library
+	// (etl::queue) or simply using std::queue, we're on a host machine anyway.
+	return new MessageQueue(messageDepth, maxMessageSize);
+}
+
+void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
+	delete queue;
+}

osal/host/QueueMapManager.cpp

@@ -0,0 +1,52 @@
+#include "QueueMapManager.h"
+
+#include "../../ipc/MutexFactory.h"
+#include "../../ipc/MutexHelper.h"
+
+QueueMapManager* QueueMapManager::mqManagerInstance = nullptr;
+
+QueueMapManager::QueueMapManager() {
+    mapLock = MutexFactory::instance()->createMutex();
+}
+
+QueueMapManager* QueueMapManager::instance() {
+	if (mqManagerInstance == nullptr){
+		mqManagerInstance = new QueueMapManager();
+	}
+	return QueueMapManager::mqManagerInstance;
+}
+
+ReturnValue_t QueueMapManager::addMessageQueue(
+		MessageQueueIF* queueToInsert, MessageQueueId_t* id) {
+	// Not thread-safe, but it is assumed all message queues are created
+	// at software initialization now. If this is to be made thread-safe in
+	// the future, it propably would be sufficient to lock the increment
+	// operation here
+	uint32_t currentId = queueCounter++;
+	auto returnPair = queueMap.emplace(currentId, queueToInsert);
+	if(not returnPair.second) {
+		// this should never happen for the atomic variable.
+		sif::error << "QueueMapManager: This ID is already inside the map!"
+				<< std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	if (id != nullptr) {
+		*id = currentId;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueIF* QueueMapManager::getMessageQueue(
+		MessageQueueId_t messageQueueId) const {
+	MutexHelper(mapLock, MutexIF::TimeoutType::WAITING, 50);
+	auto queueIter = queueMap.find(messageQueueId);
+	if(queueIter != queueMap.end()) {
+		return queueIter->second;
+	}
+	else {
+		sif::warning << "QueueMapManager::getQueueHandle: The ID" <<
+				messageQueueId << " does not exists in the map" << std::endl;
+		return nullptr;
+	}
+}
+

osal/host/QueueMapManager.h

@@ -0,0 +1,47 @@
+#ifndef FSFW_OSAL_HOST_QUEUEMAPMANAGER_H_
+#define FSFW_OSAL_HOST_QUEUEMAPMANAGER_H_
+
+#include "../../ipc/MessageQueueSenderIF.h"
+#include "../../osal/host/MessageQueue.h"
+#include <unordered_map>
+#include <atomic>
+
+using QueueMap = std::unordered_map<MessageQueueId_t, MessageQueueIF*>;
+
+
+/**
+ * An internal map to map message queue IDs to message queues.
+ * This propably should be a singleton..
+ */
+class QueueMapManager {
+public:
+	//! Returns the single instance of SemaphoreFactory.
+	static QueueMapManager* instance();
+
+	/**
+	 * Insert a message queue into the map and returns a message queue ID
+	 * @param queue The message queue to insert.
+	 * @param id The passed value will be set unless a nullptr is passed
+	 * @return
+	 */
+	ReturnValue_t addMessageQueue(MessageQueueIF* queue, MessageQueueId_t*
+			id = nullptr);
+	/**
+	 * Get the message queue handle by providing a message queue ID.
+	 * @param messageQueueId
+	 * @return
+	 */
+	MessageQueueIF* getMessageQueue(MessageQueueId_t messageQueueId) const;
+
+private:
+	//! External instantiation is forbidden.
+	QueueMapManager();
+	uint32_t queueCounter = 1;
+	MutexIF* mapLock;
+	QueueMap queueMap;
+	static QueueMapManager* mqManagerInstance;
+};
+
+
+
+#endif /* FSFW_OSAL_HOST_QUEUEMAPMANAGER_H_ */

osal/host/SemaphoreFactory.cpp

@@ -0,0 +1,39 @@
+#include "../../tasks/SemaphoreFactory.h"
+#include "../../osal/linux/BinarySemaphore.h"
+#include "../../osal/linux/CountingSemaphore.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
+
+SemaphoreFactory::SemaphoreFactory() {
+}
+
+SemaphoreFactory::~SemaphoreFactory() {
+	delete factoryInstance;
+}
+
+SemaphoreFactory* SemaphoreFactory::instance() {
+	if (factoryInstance == nullptr){
+		factoryInstance = new SemaphoreFactory();
+	}
+	return SemaphoreFactory::factoryInstance;
+}
+
+SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t arguments) {
+	// Just gonna wait for full C++20 for now.
+	sif::error << "SemaphoreFactory: Binary Semaphore not implemented yet."
+			" Returning nullptr!\n" << std::flush;
+	return nullptr;
+}
+
+SemaphoreIF* SemaphoreFactory::createCountingSemaphore(const uint8_t maxCount,
+		uint8_t initCount, uint32_t arguments) {
+	// Just gonna wait for full C++20 for now.
+	sif::error << "SemaphoreFactory: Counting Semaphore not implemented yet."
+				" Returning nullptr!\n" << std::flush;
+	return nullptr;
+}
+
+void SemaphoreFactory::deleteSemaphore(SemaphoreIF* semaphore) {
+	delete semaphore;
+}

osal/host/TaskFactory.cpp

@@ -0,0 +1,51 @@
+#include "../../osal/host/FixedTimeslotTask.h"
+#include "../../osal/host/PeriodicTask.h"
+#include "../../tasks/TaskFactory.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../tasks/PeriodicTaskIF.h"
+
+#include <chrono>
+
+TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
+
+// Will propably not be used for hosted implementation
+const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = 0;
+
+TaskFactory::TaskFactory() {
+}
+
+TaskFactory::~TaskFactory() {
+}
+
+TaskFactory* TaskFactory::instance() {
+	return TaskFactory::factoryInstance;
+}
+
+PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
+		TaskPriority taskPriority_,TaskStackSize stackSize_,
+		TaskPeriod periodInSeconds_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	return new PeriodicTask(name_, taskPriority_, stackSize_, periodInSeconds_,
+			deadLineMissedFunction_);
+}
+
+FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
+		TaskPriority taskPriority_,TaskStackSize stackSize_,
+		TaskPeriod periodInSeconds_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	return new FixedTimeslotTask(name_, taskPriority_, stackSize_,
+	        periodInSeconds_, deadLineMissedFunction_);
+}
+
+ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
+	// This might block for some time!
+	delete task;
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
+	std::this_thread::sleep_for(std::chrono::milliseconds(delayMs));
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+

osal/linux/BinarySemaphore.cpp

@@ -0,0 +1,149 @@
+#include "../../osal/linux/BinarySemaphore.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+extern "C" {
+#include <errno.h>
+#include <string.h>
+}
+
+BinarySemaphore::BinarySemaphore() {
+	// Using unnamed semaphores for now
+	initSemaphore();
+}
+
+BinarySemaphore::~BinarySemaphore() {
+	sem_destroy(&handle);
+}
+
+BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
+	initSemaphore();
+}
+
+BinarySemaphore& BinarySemaphore::operator =(
+        BinarySemaphore&& s) {
+	initSemaphore();
+	return * this;
+}
+
+ReturnValue_t BinarySemaphore::acquire(TimeoutType timeoutType,
+		 uint32_t timeoutMs) {
+	int result = 0;
+	if(timeoutType == TimeoutType::POLLING) {
+		result = sem_trywait(&handle);
+	}
+	else if(timeoutType == TimeoutType::BLOCKING) {
+	    result = sem_wait(&handle);
+	}
+	else if(timeoutType == TimeoutType::WAITING){
+		timespec timeOut;
+		clock_gettime(CLOCK_REALTIME, &timeOut);
+		uint64_t nseconds = timeOut.tv_sec * 1000000000 + timeOut.tv_nsec;
+		nseconds += timeoutMs * 1000000;
+		timeOut.tv_sec = nseconds / 1000000000;
+		timeOut.tv_nsec = nseconds - timeOut.tv_sec * 1000000000;
+	    result = sem_timedwait(&handle, &timeOut);
+	    if(result != 0 and errno == EINVAL) {
+	    	sif::debug << "BinarySemaphore::acquire: Invalid time value possible"
+	    			<< std::endl;
+	    }
+	}
+	if(result == 0) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	switch(errno) {
+	case(EAGAIN):
+		// Operation could not be performed without blocking (for sem_trywait)
+	case(ETIMEDOUT):
+		// Semaphore is 0
+		return SemaphoreIF::SEMAPHORE_TIMEOUT;
+	case(EINVAL):
+		// Semaphore invalid
+		return SemaphoreIF::SEMAPHORE_INVALID;
+	case(EINTR):
+		// Call was interrupted by signal handler
+		sif::debug << "BinarySemaphore::acquire: Signal handler interrupted."
+				"Code " << strerror(errno) << std::endl;
+		/* No break */
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t BinarySemaphore::release() {
+	return BinarySemaphore::release(&this->handle);
+}
+
+ReturnValue_t BinarySemaphore::release(sem_t *handle) {
+	ReturnValue_t countResult = checkCount(handle, 1);
+	if(countResult != HasReturnvaluesIF::RETURN_OK) {
+		return countResult;
+	}
+
+	int result = sem_post(handle);
+	if(result == 0) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	switch(errno) {
+	case(EINVAL):
+		// Semaphore invalid
+		return SemaphoreIF::SEMAPHORE_INVALID;
+	case(EOVERFLOW):
+		// SEM_MAX_VALUE overflow. This should never happen
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+uint8_t BinarySemaphore::getSemaphoreCounter() const {
+	// And another ugly cast :-D
+	return getSemaphoreCounter(const_cast<sem_t*>(&this->handle));
+}
+
+uint8_t BinarySemaphore::getSemaphoreCounter(sem_t *handle) {
+	int value = 0;
+	int result = sem_getvalue(handle, &value);
+	if (result == 0) {
+		return value;
+	}
+	else if(result != 0 and errno == EINVAL) {
+		// Could be called from interrupt, use lightweight printf
+		printf("BinarySemaphore::getSemaphoreCounter: Invalid semaphore\n");
+		return 0;
+	}
+	else {
+		// This should never happen.
+		return 0;
+	}
+}
+
+void BinarySemaphore::initSemaphore(uint8_t initCount) {
+	auto result = sem_init(&handle, true, initCount);
+	if(result == -1) {
+		switch(errno) {
+		case(EINVAL):
+			// Value exceeds SEM_VALUE_MAX
+		case(ENOSYS):
+		// System does not support process-shared semaphores
+		sif::error << "BinarySemaphore: Init failed with" << strerror(errno)
+				<< std::endl;
+		}
+	}
+}
+
+ReturnValue_t BinarySemaphore::checkCount(sem_t* handle, uint8_t maxCount) {
+	int value = getSemaphoreCounter(handle);
+	if(value >= maxCount) {
+		if(maxCount == 1 and value > 1) {
+			// Binary Semaphore special case.
+			// This is a config error use lightweight printf is this is called
+			// from an interrupt
+			printf("BinarySemaphore::release: Value of binary semaphore greater"
+					" than 1!\n");
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}

osal/linux/BinarySemaphore.h

@@ -0,0 +1,81 @@
+#ifndef FRAMEWORK_OSAL_LINUX_BINARYSEMPAHORE_H_
+#define FRAMEWORK_OSAL_LINUX_BINARYSEMPAHORE_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../tasks/SemaphoreIF.h"
+
+extern "C" {
+#include <semaphore.h>
+}
+
+/**
+ * @brief 	OS Tool to achieve synchronization of between tasks or between
+ * 			task and ISR. The default semaphore implementation creates a
+ * 			binary semaphore, which can only be taken once.
+ * @details
+ * See: http://www.man7.org/linux/man-pages/man7/sem_overview.7.html
+ * @author 	R. Mueller
+ * @ingroup osal
+ */
+class BinarySemaphore: public SemaphoreIF,
+		public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
+
+	//! @brief Default ctor
+	BinarySemaphore();
+	//! @brief Copy ctor, deleted explicitely.
+	BinarySemaphore(const BinarySemaphore&) = delete;
+	//! @brief Copy assignment, deleted explicitely.
+	BinarySemaphore& operator=(const BinarySemaphore&) = delete;
+	//! @brief Move ctor
+	BinarySemaphore (BinarySemaphore &&);
+	//! @brief Move assignment
+	BinarySemaphore & operator=(BinarySemaphore &&);
+	//! @brief Destructor
+	virtual ~BinarySemaphore();
+
+	void initSemaphore(uint8_t initCount = 1);
+
+	uint8_t getSemaphoreCounter() const override;
+	static uint8_t getSemaphoreCounter(sem_t* handle);
+
+	/**
+	 * Take the binary semaphore.
+	 * If the semaphore has already been taken, the task will be blocked
+	 * for a maximum of #timeoutMs or until the semaphore is given back,
+	 * for example by an ISR or another task.
+	 * @param timeoutMs
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
+	 */
+	ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
+			uint32_t timeoutMs = 0) override;
+
+	/**
+	 * Release the binary semaphore.
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is
+	 *         	already available.
+	 */
+	virtual ReturnValue_t release() override;
+	/**
+	 * This static function can be used to release a semaphore  by providing
+	 * its handle.
+	 * @param handle
+	 * @return
+	 */
+	static ReturnValue_t release(sem_t* handle);
+
+	/** Checks the validity of the semaphore count against a specified
+	 * known maxCount
+	 * @param handle
+	 * @param maxCount
+	 * @return
+	 */
+	static ReturnValue_t checkCount(sem_t* handle, uint8_t maxCount);
+protected:
+	sem_t handle;
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */

osal/linux/CountingSemaphore.cpp

@@ -0,0 +1,54 @@
+#include "../../osal/linux/CountingSemaphore.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
+		maxCount(maxCount), initCount(initCount) {
+	if(initCount > maxCount) {
+		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
+				"intial cout. Setting initial count to max count." << std::endl;
+		initCount = maxCount;
+	}
+
+	initSemaphore(initCount);
+}
+
+CountingSemaphore::CountingSemaphore(CountingSemaphore&& other):
+		maxCount(other.maxCount), initCount(other.initCount) {
+	initSemaphore(initCount);
+}
+
+CountingSemaphore& CountingSemaphore::operator =(
+		CountingSemaphore&& other) {
+	initSemaphore(other.initCount);
+	return * this;
+}
+
+ReturnValue_t CountingSemaphore::release() {
+	ReturnValue_t result = checkCount(&handle, maxCount);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return CountingSemaphore::release(&this->handle);
+}
+
+ReturnValue_t CountingSemaphore::release(sem_t* handle) {
+	int result = sem_post(handle);
+	if(result == 0) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	switch(errno) {
+	case(EINVAL):
+		// Semaphore invalid
+		return SemaphoreIF::SEMAPHORE_INVALID;
+	case(EOVERFLOW):
+		// SEM_MAX_VALUE overflow. This should never happen
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+uint8_t CountingSemaphore::getMaxCount() const {
+	return maxCount;
+}
+

osal/linux/CountingSemaphore.h

@@ -0,0 +1,37 @@
+#ifndef FRAMEWORK_OSAL_LINUX_COUNTINGSEMAPHORE_H_
+#define FRAMEWORK_OSAL_LINUX_COUNTINGSEMAPHORE_H_
+#include "../../osal/linux/BinarySemaphore.h"
+
+/**
+ * @brief 	Counting semaphores, which can be acquired more than once.
+ * @details
+ * See: https://www.freertos.org/CreateCounting.html
+ * API of counting semaphores is almost identical to binary semaphores,
+ * so we just inherit from binary semaphore and provide the respective
+ * constructors.
+ */
+class CountingSemaphore: public BinarySemaphore {
+public:
+	CountingSemaphore(const uint8_t maxCount, uint8_t initCount);
+	//! @brief Copy ctor, disabled
+	CountingSemaphore(const CountingSemaphore&) = delete;
+	//! @brief Copy assignment, disabled
+	CountingSemaphore& operator=(const CountingSemaphore&) = delete;
+	//! @brief Move ctor
+	CountingSemaphore (CountingSemaphore &&);
+	//! @brief Move assignment
+	CountingSemaphore & operator=(CountingSemaphore &&);
+
+	ReturnValue_t release() override;
+	static ReturnValue_t release(sem_t* sem);
+	/* Same API as binary semaphore otherwise. acquire() can be called
+	 * until there are not semaphores left and release() can be called
+	 * until maxCount is reached. */
+
+	uint8_t getMaxCount() const;
+private:
+	const uint8_t maxCount;
+	uint8_t initCount = 0;
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_ */

osal/linux/PeriodicPosixTask.cpp

@@ -5,8 +5,8 @@
 
 PeriodicPosixTask::PeriodicPosixTask(const char* name_, int priority_,
 		size_t stackSize_, uint32_t period_, void(deadlineMissedFunc_)()):
-		PosixThread(name_,priority_,stackSize_),objectList(),started(false),
-		periodMs(period_),deadlineMissedFunc(deadlineMissedFunc_) {
+		PosixThread(name_, priority_, stackSize_), objectList(), started(false),
+		periodMs(period_), deadlineMissedFunc(deadlineMissedFunc_) {
 }
 
 PeriodicPosixTask::~PeriodicPosixTask() {
@@ -25,6 +25,8 @@ ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object) {
 	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
 			object);
 	if (newObject == nullptr) {
+		sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
+				<< " it implements ExecutableObjectIF!" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	objectList.push_back(newObject);
@@ -38,35 +40,41 @@ ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
 }
 
 
-ReturnValue_t PeriodicPosixTask::startTask(void){
+ReturnValue_t PeriodicPosixTask::startTask(void) {
 	started = true;
 	//sif::info << stackSize << std::endl;
 	PosixThread::createTask(&taskEntryPoint,this);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-void PeriodicPosixTask::taskFunctionality(void){
-	if(!started){
+void PeriodicPosixTask::taskFunctionality(void) {
+	if(not started) {
 		suspend();
 	}
+
+	for (auto const &object: objectList) {
+		object->initializeAfterTaskCreation();
+	}
+
 	uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
 	//The task's "infinite" inner loop is entered.
 	while (1) {
-		for (ObjectList::iterator it = objectList.begin();
-				it != objectList.end(); ++it) {
-			(*it)->performOperation();
+		for (auto const &object: objectList) {
+			object->performOperation();
 		}
-		if(!PosixThread::delayUntil(&lastWakeTime,periodMs)){
+
+		if(not PosixThread::delayUntil(&lastWakeTime, periodMs)){
 			char name[20] = {0};
-			int status = pthread_getname_np(pthread_self(),name,sizeof(name));
-			if(status==0){
+			int status = pthread_getname_np(pthread_self(), name, sizeof(name));
+			if(status == 0) {
 				sif::error << "PeriodicPosixTask " << name << ": Deadline "
 						"missed." << std::endl;
-			}else{
+			}
+			else {
 				sif::error << "PeriodicPosixTask X: Deadline missed. " <<
 						status << std::endl;
 			}
-			if (this->deadlineMissedFunc != NULL) {
+			if (this->deadlineMissedFunc != nullptr) {
 				this->deadlineMissedFunc();
 			}
 		}

osal/linux/PeriodicPosixTask.h

@@ -32,7 +32,7 @@ public:
 	 * 			The address of the task object is passed as an argument
 	 * 			to the system call.
 	 */
-	ReturnValue_t startTask(void);
+	ReturnValue_t startTask() override;
 	/**
 	 * Adds an object to the list of objects to be executed.
 	 * The objects are executed in the order added.

osal/linux/SemaphoreFactory.cpp

@@ -0,0 +1,33 @@
+#include "../../tasks/SemaphoreFactory.h"
+#include "BinarySemaphore.h"
+#include "CountingSemaphore.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
+
+SemaphoreFactory::SemaphoreFactory() {
+}
+
+SemaphoreFactory::~SemaphoreFactory() {
+	delete factoryInstance;
+}
+
+SemaphoreFactory* SemaphoreFactory::instance() {
+	if (factoryInstance == nullptr){
+		factoryInstance = new SemaphoreFactory();
+	}
+	return SemaphoreFactory::factoryInstance;
+}
+
+SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t arguments) {
+	return new BinarySemaphore();
+}
+
+SemaphoreIF* SemaphoreFactory::createCountingSemaphore(const uint8_t maxCount,
+		uint8_t initCount, uint32_t arguments) {
+	return new CountingSemaphore(maxCount, initCount);
+}
+
+void SemaphoreFactory::deleteSemaphore(SemaphoreIF* semaphore) {
+	delete semaphore;
+}

osal/linux/TcUnixUdpPollingTask.cpp

@@ -0,0 +1,138 @@
+#include "TcUnixUdpPollingTask.h"
+#include "../../globalfunctions/arrayprinter.h"
+
+TcUnixUdpPollingTask::TcUnixUdpPollingTask(object_id_t objectId,
+		object_id_t tmtcUnixUdpBridge, size_t frameSize,
+		double timeoutSeconds): SystemObject(objectId),
+		tmtcBridgeId(tmtcUnixUdpBridge) {
+
+	if(frameSize > 0) {
+		this->frameSize = frameSize;
+	}
+	else {
+		this->frameSize = DEFAULT_MAX_FRAME_SIZE;
+	}
+
+	// Set up reception buffer with specified frame size.
+	// For now, it is assumed that only one frame is held in the buffer!
+	receptionBuffer.reserve(this->frameSize);
+	receptionBuffer.resize(this->frameSize);
+
+	if(timeoutSeconds == -1) {
+		receptionTimeout = DEFAULT_TIMEOUT;
+	}
+	else {
+		receptionTimeout = timevalOperations::toTimeval(timeoutSeconds);
+	}
+}
+
+TcUnixUdpPollingTask::~TcUnixUdpPollingTask() {}
+
+ReturnValue_t TcUnixUdpPollingTask::performOperation(uint8_t opCode) {
+	// Poll for new UDP datagrams in permanent loop.
+	while(1) {
+		//! Sender Address is cached here.
+		struct sockaddr_in senderAddress;
+		socklen_t senderSockLen = 0;
+		ssize_t bytesReceived = recvfrom(serverUdpSocket,
+				receptionBuffer.data(), frameSize, receptionFlags,
+				reinterpret_cast<sockaddr*>(&senderAddress), &senderSockLen);
+		if(bytesReceived < 0) {
+			// handle error
+			sif::error << "TcSocketPollingTask::performOperation: Reception"
+					"error." << std::endl;
+			handleReadError();
+
+			continue;
+		}
+//		sif::debug << "TcSocketPollingTask::performOperation: " << bytesReceived
+//				<< " bytes received" << std::endl;
+
+		ReturnValue_t result = handleSuccessfullTcRead(bytesReceived);
+		if(result != HasReturnvaluesIF::RETURN_FAILED) {
+
+		}
+		tmtcBridge->registerCommConnect();
+		tmtcBridge->checkAndSetClientAddress(senderAddress);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
+	store_address_t storeId;
+	ReturnValue_t result = tcStore->addData(&storeId,
+			receptionBuffer.data(), bytesRead);
+	// arrayprinter::print(receptionBuffer.data(), bytesRead);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "TcSerialPollingTask::transferPusToSoftwareBus: Data "
+				"storage failed" << std::endl;
+		sif::error << "Packet size: " << bytesRead << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	TmTcMessage message(storeId);
+
+	result  = MessageQueueSenderIF::sendMessage(targetTcDestination, &message);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "Serial Polling: Sending message to queue failed"
+				<< std::endl;
+		tcStore->deleteData(storeId);
+	}
+	return result;
+}
+
+ReturnValue_t TcUnixUdpPollingTask::initialize() {
+	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
+	if (tcStore == nullptr) {
+		sif::error << "TcSerialPollingTask::initialize: TC Store uninitialized!"
+				<< std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	tmtcBridge = objectManager->get<TmTcUnixUdpBridge>(tmtcBridgeId);
+	if(tmtcBridge == nullptr) {
+		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Invalid"
+				" TMTC bridge object!" << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	serverUdpSocket = tmtcBridge->serverSocket;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TcUnixUdpPollingTask::initializeAfterTaskCreation() {
+	// Initialize the destination after task creation. This ensures
+	// that the destination will be set in the TMTC bridge.
+	targetTcDestination = tmtcBridge->getRequestQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void TcUnixUdpPollingTask::setTimeout(double timeoutSeconds) {
+	timeval tval;
+	tval = timevalOperations::toTimeval(timeoutSeconds);
+	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
+			&tval, sizeof(receptionTimeout));
+	if(result == -1) {
+		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting "
+				"receive timeout failed with " << strerror(errno) << std::endl;
+	}
+}
+
+// TODO: sleep after error detection to prevent spam
+void TcUnixUdpPollingTask::handleReadError() {
+	switch(errno) {
+	case(EAGAIN): {
+		// todo: When working in timeout mode, this will occur more often
+		// and is not an error.
+		sif::error << "TcUnixUdpPollingTask::handleReadError: Timeout."
+				<< std::endl;
+		break;
+	}
+	default: {
+		sif::error << "TcUnixUdpPollingTask::handleReadError: "
+				<< strerror(errno) << std::endl;
+	}
+	}
+}

osal/linux/TcUnixUdpPollingTask.h

@@ -0,0 +1,67 @@
+#ifndef FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
+#define FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
+
+#include "../../objectmanager/SystemObject.h"
+#include "../../osal/linux/TmTcUnixUdpBridge.h"
+#include "../../tasks/ExecutableObjectIF.h"
+
+#include <sys/socket.h>
+#include <vector>
+
+/**
+ * @brief 	This class can be used to implement the polling of a Unix socket,
+ * 			using UDP for now.
+ * @details
+ * The task will be blocked while the specified number of bytes has not been
+ * received, so TC reception is handled inside a separate task.
+ * This class caches the IP address of the sender. It is assumed there
+ * is only one sender for now.
+ */
+class TcUnixUdpPollingTask: public SystemObject,
+		public ExecutableObjectIF {
+	friend class TmTcUnixUdpBridge;
+public:
+	static constexpr size_t DEFAULT_MAX_FRAME_SIZE = 2048;
+	//! 0.5  default milliseconds timeout for now.
+	static constexpr timeval DEFAULT_TIMEOUT = {.tv_sec = 0, .tv_usec = 500};
+
+	TcUnixUdpPollingTask(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
+			size_t frameSize = 0, double timeoutSeconds = -1);
+	virtual~ TcUnixUdpPollingTask();
+
+	/**
+	 * Turn on optional timeout for UDP polling. In the default mode,
+	 * the receive function will block until a packet is received.
+	 * @param timeoutSeconds
+	 */
+	void setTimeout(double timeoutSeconds);
+
+	virtual ReturnValue_t performOperation(uint8_t opCode) override;
+	virtual ReturnValue_t initialize() override;
+	virtual ReturnValue_t initializeAfterTaskCreation() override;
+
+protected:
+	StorageManagerIF* tcStore = nullptr;
+
+private:
+	//! TMTC bridge is cached.
+	object_id_t tmtcBridgeId = objects::NO_OBJECT;
+	TmTcUnixUdpBridge* tmtcBridge = nullptr;
+	MessageQueueId_t targetTcDestination = MessageQueueIF::NO_QUEUE;
+	//! Reception flags: https://linux.die.net/man/2/recvfrom.
+	int receptionFlags = 0;
+
+	//! Server socket, which is member of TMTC bridge and is assigned in
+	//! constructor
+	int serverUdpSocket = 0;
+
+	std::vector<uint8_t> receptionBuffer;
+
+	size_t frameSize = 0;
+	timeval receptionTimeout;
+
+	ReturnValue_t handleSuccessfullTcRead(size_t bytesRead);
+	void handleReadError();
+};
+
+#endif /* FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_ */

osal/linux/TmTcUnixUdpBridge.cpp

@@ -0,0 +1,170 @@
+#include "TmTcUnixUdpBridge.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../ipc/MutexHelper.h"
+
+#include <errno.h>
+#include <arpa/inet.h>
+
+
+TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
+		object_id_t tcDestination, object_id_t tmStoreId, object_id_t tcStoreId,
+		uint16_t serverPort, uint16_t clientPort):
+		TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
+	mutex = MutexFactory::instance()->createMutex();
+
+	uint16_t setServerPort = DEFAULT_UDP_SERVER_PORT;
+	if(serverPort != 0xFFFF) {
+		setServerPort = serverPort;
+	}
+
+	uint16_t setClientPort = DEFAULT_UDP_CLIENT_PORT;
+	if(clientPort != 0xFFFF) {
+		setClientPort = clientPort;
+	}
+
+	// Set up UDP socket: https://man7.org/linux/man-pages/man7/ip.7.html
+	//clientSocket = socket(AF_INET, SOCK_DGRAM, 0);
+	serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+	if(serverSocket < 0) {
+		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
+				" UDP socket!" << std::endl;
+		handleSocketError();
+		return;
+	}
+
+	serverAddress.sin_family = AF_INET;
+
+	// Accept packets from any interface.
+	//serverAddress.sin_addr.s_addr = inet_addr("127.73.73.0");
+	serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
+	serverAddress.sin_port = htons(setServerPort);
+	serverAddressLen = sizeof(serverAddress);
+	setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR, &serverSocketOptions,
+			sizeof(serverSocketOptions));
+
+	clientAddress.sin_family = AF_INET;
+	clientAddress.sin_addr.s_addr = htonl(INADDR_ANY);
+	clientAddress.sin_port = htons(setClientPort);
+	clientAddressLen = sizeof(clientAddress);
+
+	int result = bind(serverSocket,
+			reinterpret_cast<struct sockaddr*>(&serverAddress),
+			serverAddressLen);
+	if(result == -1) {
+		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
+				"local port " << setServerPort << " to server socket!"
+				<< std::endl;
+		handleBindError();
+		return;
+	}
+}
+
+TmTcUnixUdpBridge::~TmTcUnixUdpBridge() {
+}
+
+ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
+	int flags = 0;
+
+	clientAddress.sin_addr.s_addr = htons(INADDR_ANY);
+	//clientAddress.sin_addr.s_addr = inet_addr("127.73.73.1");
+	clientAddressLen = sizeof(serverAddress);
+
+//	char ipAddress [15];
+//	sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
+//					&clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+
+	ssize_t bytesSent = sendto(serverSocket, data, dataLen, flags,
+			reinterpret_cast<sockaddr*>(&clientAddress), clientAddressLen);
+	if(bytesSent < 0) {
+		sif::error << "TmTcUnixUdpBridge::sendTm: Send operation failed."
+				<< std::endl;
+		handleSendError();
+	}
+//	sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
+//			" sent." << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
+	MutexHelper lock(mutex, MutexIF::TimeoutType::WAITING, 10);
+
+//	char ipAddress [15];
+//	sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
+//			&newAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+//	sif::debug << "IP Address Old: " <<  inet_ntop(AF_INET,
+//			&clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+
+	// Set new IP address if it has changed.
+	if(clientAddress.sin_addr.s_addr != newAddress.sin_addr.s_addr) {
+		clientAddress.sin_addr.s_addr = newAddress.sin_addr.s_addr;
+		clientAddressLen = sizeof(clientAddress);
+	}
+}
+
+
+void TmTcUnixUdpBridge::handleSocketError() {
+	// See: https://man7.org/linux/man-pages/man2/socket.2.html
+	switch(errno) {
+	case(EACCES):
+	case(EINVAL):
+	case(EMFILE):
+	case(ENFILE):
+	case(EAFNOSUPPORT):
+	case(ENOBUFS):
+	case(ENOMEM):
+	case(EPROTONOSUPPORT):
+		sif::error << "TmTcUnixBridge::handleSocketError: Socket creation failed"
+				<< " with " << strerror(errno) << std::endl;
+		break;
+	default:
+		sif::error << "TmTcUnixBridge::handleSocketError: Unknown error"
+				<< std::endl;
+		break;
+	}
+}
+
+void TmTcUnixUdpBridge::handleBindError() {
+	// See: https://man7.org/linux/man-pages/man2/bind.2.html
+	switch(errno) {
+	case(EACCES): {
+		/*
+		 Ephermeral ports can be shown with following command:
+		 sysctl -A | grep ip_local_port_range
+		 */
+		sif::error << "TmTcUnixBridge::handleBindError: Port access issue."
+				"Ports 1-1024 are reserved on UNIX systems and require root "
+				"rights while ephermeral ports should not be used as well."
+				<< std::endl;
+	}
+	break;
+	case(EADDRINUSE):
+	case(EBADF):
+	case(EINVAL):
+	case(ENOTSOCK):
+	case(EADDRNOTAVAIL):
+	case(EFAULT):
+	case(ELOOP):
+	case(ENAMETOOLONG):
+	case(ENOENT):
+	case(ENOMEM):
+	case(ENOTDIR):
+	case(EROFS): {
+		sif::error << "TmTcUnixBridge::handleBindError: Socket creation failed"
+				<< " with " << strerror(errno) << std::endl;
+		break;
+	}
+	default:
+		sif::error << "TmTcUnixBridge::handleBindError: Unknown error"
+				<< std::endl;
+		break;
+	}
+}
+
+void TmTcUnixUdpBridge::handleSendError() {
+	switch(errno) {
+	default:
+		sif::error << "TmTcUnixBridge::handleSendError: "
+		        << strerror(errno) << std::endl;
+	}
+}
+

osal/linux/TmTcUnixUdpBridge.h

@@ -0,0 +1,48 @@
+#ifndef FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_
+#define FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_
+
+#include "../../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../../tmtcservices/TmTcBridge.h"
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/udp.h>
+
+class TmTcUnixUdpBridge: public TmTcBridge {
+	friend class TcUnixUdpPollingTask;
+public:
+	// The ports chosen here should not be used by any other process.
+	// List of used ports on Linux: /etc/services
+	static constexpr uint16_t DEFAULT_UDP_SERVER_PORT = 7301;
+	static constexpr uint16_t DEFAULT_UDP_CLIENT_PORT = 7302;
+
+	TmTcUnixUdpBridge(object_id_t objectId, object_id_t tcDestination,
+			object_id_t tmStoreId, object_id_t tcStoreId,
+			uint16_t serverPort = 0xFFFF,uint16_t clientPort = 0xFFFF);
+	virtual~ TmTcUnixUdpBridge();
+
+	void checkAndSetClientAddress(sockaddr_in clientAddress);
+
+protected:
+	virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) override;
+
+private:
+	int serverSocket = 0;
+
+	const int serverSocketOptions = 0;
+
+	struct sockaddr_in clientAddress;
+	socklen_t clientAddressLen = 0;
+
+	struct sockaddr_in serverAddress;
+	socklen_t serverAddressLen = 0;
+
+	//! Access to the client address is mutex protected as it is set
+	//! by another task.
+	MutexIF* mutex;
+
+	void handleSocketError();
+	void handleBindError();
+	void handleSendError();
+};
+
+#endif /* FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_ */

parameters/HasParametersIF.h

@@ -1,12 +1,27 @@
-#ifndef HASPARAMETERSIF_H_
-#define HASPARAMETERSIF_H_
+#ifndef FSFW_PARAMETERS_HASPARAMETERSIF_H_
+#define FSFW_PARAMETERS_HASPARAMETERSIF_H_
 
-#include "ParameterWrapper.h"
+#include "../parameters/ParameterWrapper.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include <stdint.h>
 
+/** Each parameter is identified with a unique parameter ID */
 typedef uint32_t ParameterId_t;
 
+/**
+ * @brief	This interface is used by components which have modifiable
+ * 			parameters, e.g. atittude controllers
+ * @details
+ * Each parameter has a unique parameter ID. The first byte of the parameter
+ * ID is the domain ID which can be used to identify unqiue spacecraft domains
+ * (e.g. control and sensor domain in the AOCS controller).
+ *
+ * The second and third byte represent the matrix ID, which can represent
+ * a 8-bit row and column number and the last byte...
+ *
+ * Yeah, it it matrix ID oder parameter ID now and is index a 16 bit number
+ * of a 8 bit number now?
+ */
 class HasParametersIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_PARAMETERS_IF;
@@ -32,13 +47,11 @@ public:
 		return (domainId << 24) + (parameterId << 8) + index;
 	}
 
-	virtual ~HasParametersIF() {
-	}
+	virtual ~HasParametersIF() {}
 
 	/**
 	 * Always set parameter before checking newValues!
 	 *
-	 *
 	 * @param domainId
 	 * @param parameterId
 	 * @param parameterWrapper
@@ -51,4 +64,4 @@ public:
 			const ParameterWrapper *newValues, uint16_t startAtIndex) = 0;
 };
 
-#endif /* HASPARAMETERSIF_H_ */
+#endif /* FSFW_PARAMETERS_HASPARAMETERSIF_H_ */

parameters/ParameterHelper.cpp

@@ -1,11 +1,9 @@
-#include "../objectmanager/ObjectManagerIF.h"
 #include "ParameterHelper.h"
 #include "ParameterMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
 
 ParameterHelper::ParameterHelper(ReceivesParameterMessagesIF* owner) :
-		owner(owner), storage(NULL) {
-
-}
+		owner(owner) {}
 
 ParameterHelper::~ParameterHelper() {
 }
@@ -28,7 +26,6 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
 	}
 		break;
 	case ParameterMessage::CMD_PARAMETER_LOAD: {
-
 		uint8_t domain = HasParametersIF::getDomain(
 				ParameterMessage::getParameterId(message));
 		uint16_t parameterId = HasParametersIF::getMatrixId(
@@ -36,12 +33,14 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
 		uint8_t index = HasParametersIF::getIndex(
 				ParameterMessage::getParameterId(message));
 
-		const uint8_t *storedStream;
-		size_t storedStreamSize;
+		const uint8_t *storedStream = nullptr;
+		size_t storedStreamSize = 0;
 		result = storage->getData(
 				ParameterMessage::getStoreId(message), &storedStream,
 				&storedStreamSize);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
+			sif::error << "ParameterHelper::handleParameterMessage: Getting"
+					" store data failed for load command." << std::endl;
 			break;
 		}
 
@@ -125,7 +124,8 @@ ReturnValue_t ParameterHelper::initialize() {
 	}
 }
 
-void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason, Command_t initialCommand) {
+void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
+		Command_t initialCommand) {
 	CommandMessage reply;
 	reply.setReplyRejected(reason, initialCommand);
 	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);

parameters/ParameterHelper.h

@@ -1,9 +1,16 @@
-#ifndef PARAMETERHELPER_H_
-#define PARAMETERHELPER_H_
+#ifndef FSFW_PARAMETERS_PARAMETERHELPER_H_
+#define FSFW_PARAMETERS_PARAMETERHELPER_H_
 
 #include "ParameterMessage.h"
 #include "ReceivesParameterMessagesIF.h"
+#include "../ipc/MessageQueueIF.h"
 
+/**
+ * @brief	Helper class to handle parameter messages.
+ * @details
+ * This class simplfies handling of parameter messages, which are sent
+ * to a class which implements ReceivesParameterMessagesIF.
+ */
 class ParameterHelper {
 public:
 	ParameterHelper(ReceivesParameterMessagesIF *owner);
@@ -15,13 +22,15 @@ public:
 private:
 	ReceivesParameterMessagesIF *owner;
 
-	MessageQueueId_t ownerQueueId;
+	MessageQueueId_t ownerQueueId = MessageQueueIF::NO_QUEUE;
 
-	StorageManagerIF *storage;
+	StorageManagerIF *storage = nullptr;
 
-	ReturnValue_t sendParameter(MessageQueueId_t to, uint32_t id, const ParameterWrapper *description);
+	ReturnValue_t sendParameter(MessageQueueId_t to, uint32_t id,
+			const ParameterWrapper *description);
 
-	void rejectCommand(MessageQueueId_t to, ReturnValue_t reason, Command_t initialCommand);
+	void rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
+			Command_t initialCommand);
 };
 
-#endif /* PARAMETERHELPER_H_ */
+#endif /* FSFW_PARAMETERS_PARAMETERHELPER_H_ */

parameters/ParameterMessage.cpp

@@ -1,4 +1,4 @@
-#include "ParameterMessage.h"
+#include "../parameters/ParameterMessage.h"
 #include "../objectmanager/ObjectManagerIF.h"
 
 ParameterId_t ParameterMessage::getParameterId(const CommandMessage* message) {

parameters/ParameterMessage.h

@@ -1,15 +1,15 @@
-#ifndef PARAMETERMESSAGE_H_
-#define PARAMETERMESSAGE_H_
+#ifndef FSFW_PARAMETERS_PARAMETERMESSAGE_H_
+#define FSFW_PARAMETERS_PARAMETERMESSAGE_H_
 
-#include "../ipc/CommandMessage.h"
 #include "HasParametersIF.h"
+#include "../ipc/CommandMessage.h"
 #include "../storagemanager/StorageManagerIF.h"
 
 class ParameterMessage {
 private:
 	ParameterMessage();
 public:
-	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::PARAMETER;
+	static const uint8_t MESSAGE_ID = messagetypes::PARAMETER;
 	static const Command_t CMD_PARAMETER_LOAD = MAKE_COMMAND_ID( 0x01 );
 	static const Command_t CMD_PARAMETER_DUMP = MAKE_COMMAND_ID( 0x02 );
 	static const Command_t REPLY_PARAMETER_DUMP = MAKE_COMMAND_ID( 0x03 );
@@ -26,4 +26,4 @@ public:
 
 };
 
-#endif /* PARAMETERMESSAGE_H_ */
+#endif /* FSFW_PARAMETERS_PARAMETERMESSAGE_H_ */

parameters/ParameterWrapper.cpp

@@ -1,20 +1,19 @@
 #include "ParameterWrapper.h"
 
 ParameterWrapper::ParameterWrapper() :
-		pointsToStream(false), type(Type::UNKNOWN_TYPE), rows(0), columns(0), data(
-		NULL), readonlyData(NULL) {
+		pointsToStream(false), type(Type::UNKNOWN_TYPE) {
 }
 
 ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
 		void *data) :
-		pointsToStream(false), type(type), rows(rows), columns(columns), data(
-				data), readonlyData(data) {
+		pointsToStream(false), type(type), rows(rows), columns(columns),
+		data(data), readonlyData(data) {
 }
 
 ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
 		const void *data) :
-		pointsToStream(false), type(type), rows(rows), columns(columns), data(
-		NULL), readonlyData(data) {
+		pointsToStream(false), type(type), rows(rows), columns(columns),
+		data(nullptr), readonlyData(data) {
 }
 
 ParameterWrapper::~ParameterWrapper() {
@@ -141,6 +140,7 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 
 }
 
+
 ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
 		size_t *size, Endianness streamEndianness) {
 	return deSerialize(buffer, size, streamEndianness, 0);
@@ -184,16 +184,16 @@ ReturnValue_t ParameterWrapper::set(const uint8_t *stream, size_t streamSize,
 		return SerializeIF::STREAM_TOO_SHORT;
 	}
 
-	data = NULL;
+	data = nullptr;
 	readonlyData = stream;
 	pointsToStream = true;
 
 	stream += dataSize;
-	if (remainingStream != NULL) {
+	if (remainingStream !=  nullptr) {
 		*remainingStream = stream;
 	}
 	streamSize -= dataSize;
-	if (remainingSize != NULL) {
+	if (remainingSize != nullptr) {
 		*remainingSize = streamSize;
 	}
 
@@ -265,15 +265,15 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
 			result = UNKNOW_DATATYPE;
 			break;
 		}
-	} else {
+	}
+	else {
 		//need a type to do arithmetic
-		uint8_t *toDataWithType = (uint8_t*) data;
+		uint8_t* typedData = static_cast<uint8_t*>(data);
 		for (uint8_t fromRow = 0; fromRow < from->rows; fromRow++) {
-			memcpy(
-					toDataWithType
-							+ (((startingRow + fromRow) * columns)
-									+ startingColumn) * typeSize,
-					from->readonlyData, typeSize * from->columns);
+			size_t offset = (((startingRow + fromRow) * columns) +
+					startingColumn) * typeSize;
+			std::memcpy(typedData +  offset, from->readonlyData,
+					typeSize * from->columns);
 		}
 	}
 

parameters/ParameterWrapper.h

@@ -1,12 +1,16 @@
-#ifndef PARAMETERWRAPPER_H_
-#define PARAMETERWRAPPER_H_
+#ifndef FSFW_PARAMETERS_PARAMETERWRAPPER_H_
+#define FSFW_PARAMETERS_PARAMETERWRAPPER_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../serialize/SerializeAdapter.h"
 #include "../serialize/SerializeIF.h"
-#include <stddef.h>
 #include "../globalfunctions/Type.h"
+#include <cstddef>
 
+/**
+ * @brief
+ * @details
+ */
 class ParameterWrapper: public SerializeIF {
 	friend class DataPoolParameterWrapper;
 public:
@@ -36,32 +40,21 @@ public:
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			Endianness streamEndianness, uint16_t startWritingAtIndex = 0);
 
+	/**
+	 * Get a specific parameter value by supplying the row and the column.
+	 * @tparam T Type of target data
+	 * @param value [out] Pointer to storage location
+	 * @param row
+	 * @param column
+	 * @return
+	 * -@c RETURN_OK if element was retrieved successfully
+	 * -@c NOT_SET data has not been set yet
+	 * -@c DATATYPE_MISSMATCH Invalid supplied type
+	 * -@c OUT_OF_BOUNDS Invalid row and/or column.
+	 */
 	template<typename T>
-	ReturnValue_t getElement(T *value, uint8_t row = 0, uint8_t column = 0) const {
-		if (readonlyData == NULL){
-			return NOT_SET;
-		}
-
-		if (PodTypeConversion<T>::type != type) {
-			return DATATYPE_MISSMATCH;
-		}
-
-		if ((row >= rows) || (column >= columns)) {
-			return OUT_OF_BOUNDS;
-		}
-
-		if (pointsToStream) {
-			const uint8_t *streamWithtype = (const uint8_t *) readonlyData;
-			streamWithtype += (row * columns + column) * type.getSize();
-			int32_t size = type.getSize();
-			return SerializeAdapter::deSerialize(value, &streamWithtype,
-					&size, true);
-		} else {
-			const T *dataWithType = (const T *) readonlyData;
-			*value = dataWithType[row * columns + column];
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-	}
+	ReturnValue_t getElement(T *value, uint8_t row = 0,
+			uint8_t column = 0) const;
 
 	template<typename T>
 	void set(T *data, uint8_t rows, uint8_t columns) {
@@ -111,21 +104,22 @@ public:
 	void setMatrix(const T& member) {
 		this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
 	}
+
 	ReturnValue_t set(const uint8_t *stream, size_t streamSize,
-			const uint8_t **remainingStream = NULL, size_t *remainingSize =
-					NULL);
+			const uint8_t **remainingStream = nullptr,
+			size_t *remainingSize = nullptr);
 
 	ReturnValue_t copyFrom(const ParameterWrapper *from,
 			uint16_t startWritingAtIndex);
 
 private:
-	bool pointsToStream;
+	bool pointsToStream = false;
 
 	Type type;
-	uint8_t rows;
-	uint8_t columns;
-	void *data;
-	const void *readonlyData;
+	uint8_t rows = 0;
+	uint8_t columns = 0;
+	void *data = nullptr;
+	const void *readonlyData = nullptr;
 
 	template<typename T>
 	ReturnValue_t serializeData(uint8_t** buffer, size_t* size,
@@ -136,4 +130,33 @@ private:
 			const void *from, uint8_t fromRows, uint8_t fromColumns);
 };
 
-#endif /* PARAMETERWRAPPER_H_ */
+template <typename T>
+inline ReturnValue_t ParameterWrapper::getElement(T *value, uint8_t row,
+		uint8_t column) const {
+	if (readonlyData == nullptr){
+		return NOT_SET;
+	}
+
+	if (PodTypeConversion<T>::type != type) {
+		return DATATYPE_MISSMATCH;
+	}
+
+	if ((row >= rows) or (column >= columns)) {
+		return OUT_OF_BOUNDS;
+	}
+
+	if (pointsToStream) {
+		const uint8_t *streamWithType = static_cast<const uint8_t*>(readonlyData);
+		streamWithType += (row * columns + column) * type.getSize();
+		int32_t size = type.getSize();
+		return SerializeAdapter::deSerialize(value, &streamWithType,
+				&size, true);
+	}
+	else {
+		const T *dataWithType = static_cast<const T*>(readonlyData);
+		*value = dataWithType[row * columns + column];
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+}
+
+#endif /* FSFW_PARAMETERS_PARAMETERWRAPPER_H_ */

parameters/ReceivesParameterMessagesIF.h

@@ -1,5 +1,5 @@
-#ifndef RECEIVESPARAMETERMESSAGESIF_H_
-#define RECEIVESPARAMETERMESSAGESIF_H_
+#ifndef FSFW_PARAMETERS_RECEIVESPARAMETERMESSAGESIF_H_
+#define FSFW_PARAMETERS_RECEIVESPARAMETERMESSAGESIF_H_
 
 
 #include "HasParametersIF.h"
@@ -16,4 +16,4 @@ public:
 };
 
 
-#endif /* RECEIVESPARAMETERMESSAGESIF_H_ */
+#endif /* FSFW_PARAMETERS_RECEIVESPARAMETERMESSAGESIF_H_ */

returnvalues/FwClassIds.h

@@ -64,6 +64,7 @@ enum {
 	LOCAL_POOL_OWNER_IF, //LPIF 58
 	POOL_VARIABLE_IF, //PVA 59
 	HOUSEKEEPING_MANAGER, //HKM 60
+	DLE_ENCODER, //DLEE 61
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };

serialize/EndianConverter.h

@@ -1,5 +1,5 @@
-#ifndef ENDIANSWAPPER_H_
-#define ENDIANSWAPPER_H_
+#ifndef FSFW_SERIALIZE_ENDIANCONVERTER_H_
+#define FSFW_SERIALIZE_ENDIANCONVERTER_H_
 
 #include "../osal/Endiness.h"
 #include <cstring>
@@ -35,9 +35,7 @@
  */
 class EndianConverter {
 private:
-	EndianConverter() {
-	}
-	;
+	EndianConverter() {};
 public:
 	/**
 	 * Convert a typed variable between big endian and machine endian.
@@ -123,4 +121,4 @@ public:
 	}
 };
 
-#endif /* ENDIANSWAPPER_H_ */
+#endif /* FSFW_SERIALIZE_ENDIANCONVERTER_H_ */

serialize/SerialArrayListAdapter.h

@@ -1,13 +1,14 @@
-#ifndef FRAMEWORK_SERIALIZE_SERIALARRAYLISTADAPTER_H_
-#define FRAMEWORK_SERIALIZE_SERIALARRAYLISTADAPTER_H_
+#ifndef FSFW_SERIALIZE_SERIALARRAYLISTADAPTER_H_
+#define FSFW_SERIALIZE_SERIALARRAYLISTADAPTER_H_
 
-#include "../container/ArrayList.h"
 #include "SerializeIF.h"
+#include "../container/ArrayList.h"
 #include <utility>
 
 /**
+ * Also serializes length field !
+ * @author 	baetz
  * @ingroup serialize
- * @author  baetz
  */
 template<typename T, typename count_t = uint8_t>
 class SerialArrayListAdapter : public SerializeIF {
@@ -21,14 +22,14 @@ public:
 	}
 
 	static ReturnValue_t serialize(const ArrayList<T, count_t>* list,
-	        uint8_t** buffer, size_t* size, size_t maxSize,
-	        Endianness streamEndianness) {
+			uint8_t** buffer, size_t* size, size_t maxSize,
+			Endianness streamEndianness) {
 		ReturnValue_t result = SerializeAdapter::serialize(&list->size,
 				buffer, size, maxSize, streamEndianness);
 		count_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
-			result = SerializeAdapter::serialize(&list->entries[i], buffer,
-			        size, maxSize, streamEndianness);
+			result = SerializeAdapter::serialize(&list->entries[i], buffer, size,
+					maxSize, streamEndianness);
 			++i;
 		}
 		return result;
@@ -55,17 +56,18 @@ public:
 	}
 
 	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list,
-	        const uint8_t** buffer, size_t* size,
+			const uint8_t** buffer, size_t* size,
 			Endianness streamEndianness) {
 		count_t tempSize = 0;
 		ReturnValue_t result = SerializeAdapter::deSerialize(&tempSize,
 				buffer, size, streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK) {
-		    return result;
+			return result;
 		}
 		if (tempSize > list->maxSize()) {
 			return SerializeIF::TOO_MANY_ELEMENTS;
 		}
+
 		list->size = tempSize;
 		count_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
@@ -76,10 +78,9 @@ public:
 		}
 		return result;
 	}
+
 private:
 	ArrayList<T, count_t> *adaptee;
 };
 
-
-
-#endif /* FRAMEWORK_SERIALIZE_SERIALARRAYLISTADAPTER_H_ */
+#endif /* FSFW_SERIALIZE_SERIALARRAYLISTADAPTER_H_ */

serialize/SerialBufferAdapter.cpp

@@ -1,94 +1,129 @@
-#include "SerialBufferAdapter.h"
-#include <cstring>
-
-
-
-template<typename T>
-SerialBufferAdapter<T>::SerialBufferAdapter(const uint8_t* buffer,
-		T bufferLength, bool serializeLenght) :
-		serializeLength(serializeLenght), constBuffer(buffer), buffer(NULL), bufferLength(
-				bufferLength) {
-}
-
-template<typename T>
-SerialBufferAdapter<T>::SerialBufferAdapter(uint8_t* buffer, T bufferLength,
-		bool serializeLenght) :
-		serializeLength(serializeLenght), constBuffer(NULL), buffer(buffer), bufferLength(
-				bufferLength) {
-}
-
-template<typename T>
-SerialBufferAdapter<T>::~SerialBufferAdapter() {
-}
-
-template<typename T>
-ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, size_t* size,
-		size_t maxSize, Endianness streamEndianness) const {
-	uint32_t serializedLength = bufferLength;
-	if (serializeLength) {
-		serializedLength += SerializeAdapter::getSerializedSize(
-				&bufferLength);
-	}
-	if (*size + serializedLength > maxSize) {
-		return BUFFER_TOO_SHORT;
-	} else {
-		if (serializeLength) {
-			SerializeAdapter::serialize(&bufferLength, buffer, size,
-					maxSize, streamEndianness);
-		}
-		if (this->constBuffer != NULL) {
-			memcpy(*buffer, this->constBuffer, bufferLength);
-		} else if (this->buffer != NULL) {
-			memcpy(*buffer, this->buffer, bufferLength);
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		*size += bufferLength;
-		(*buffer) += bufferLength;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-}
-
-template<typename T>
-size_t SerialBufferAdapter<T>::getSerializedSize() const {
-	if (serializeLength) {
-		return bufferLength + SerializeAdapter::getSerializedSize(&bufferLength);
-	} else {
-		return bufferLength;
-	}
-}
-template<typename T>
-ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
-		size_t* size, Endianness streamEndianness) {
-	//TODO Ignores Endian flag!
-	if (buffer != NULL) {
-		if(serializeLength){
-			T serializedSize = SerializeAdapter::getSerializedSize(
-					&bufferLength);
-			if((*size - bufferLength - serializedSize) >= 0){
-				*buffer +=  serializedSize;
-				*size -= serializedSize;
-			}else{
-				return STREAM_TOO_SHORT;
-			}
-		}
-		//No Else If, go on with buffer
-		if (*size - bufferLength >= 0) {
-			*size -= bufferLength;
-			memcpy(this->buffer, *buffer, bufferLength);
-			(*buffer) += bufferLength;
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return STREAM_TOO_SHORT;
-		}
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-
-//forward Template declaration for linker
-template class SerialBufferAdapter<uint8_t>;
-template class SerialBufferAdapter<uint16_t>;
-template class SerialBufferAdapter<uint32_t>;
-
+#include "../serialize/SerialBufferAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include <cstring>
+
+template<typename count_t>
+SerialBufferAdapter<count_t>::SerialBufferAdapter(const uint8_t* buffer,
+		count_t bufferLength, bool serializeLength) :
+		serializeLength(serializeLength),
+		constBuffer(buffer), buffer(nullptr),
+		bufferLength(bufferLength) {}
+
+template<typename count_t>
+SerialBufferAdapter<count_t>::SerialBufferAdapter(uint8_t* buffer,
+		count_t bufferLength, bool serializeLength) :
+		serializeLength(serializeLength), constBuffer(buffer), buffer(buffer),
+		bufferLength(bufferLength) {}
+
+
+template<typename count_t>
+SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
+}
+
+template<typename count_t>
+ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer,
+		size_t* size, size_t maxSize, Endianness streamEndianness) const {
+	if (serializeLength) {
+		ReturnValue_t result = SerializeAdapter::serialize(&bufferLength,
+				buffer, size, maxSize, streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
+
+	if (*size + bufferLength > maxSize) {
+		return BUFFER_TOO_SHORT;
+	}
+
+	if (this->constBuffer != nullptr) {
+		std::memcpy(*buffer, this->constBuffer, bufferLength);
+	}
+	else if (this->buffer != nullptr) {
+		// This will propably be never reached, constBuffer should always be
+		// set if non-const buffer is set.
+		std::memcpy(*buffer, this->buffer, bufferLength);
+	}
+	else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	*size += bufferLength;
+	(*buffer) += bufferLength;
+	return HasReturnvaluesIF::RETURN_OK;
+
+}
+
+template<typename count_t>
+size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
+	if (serializeLength) {
+		return bufferLength + SerializeAdapter::getSerializedSize(&bufferLength);
+	} else {
+		return bufferLength;
+	}
+}
+
+template<typename count_t>
+ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
+		size_t* size, Endianness streamEndianness) {
+	if (this->buffer == nullptr) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if(serializeLength){
+		count_t lengthField = 0;
+		ReturnValue_t result = SerializeAdapter::deSerialize(&lengthField,
+				buffer, size, streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if(lengthField > bufferLength) {
+			return TOO_MANY_ELEMENTS;
+		}
+		bufferLength = lengthField;
+	}
+
+	if (bufferLength <= *size) {
+		*size -= bufferLength;
+		std::memcpy(this->buffer, *buffer, bufferLength);
+		(*buffer) += bufferLength;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return STREAM_TOO_SHORT;
+	}
+}
+
+template<typename count_t>
+uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
+	if(buffer == nullptr) {
+		sif::error << "Wrong access function for stored type !"
+				 " Use getConstBuffer()." << std::endl;
+		return nullptr;
+	}
+	return buffer;
+}
+
+template<typename count_t>
+const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
+	if(constBuffer == nullptr) {
+		sif::error << "SerialBufferAdapter::getConstBuffer:"
+				" Buffers are unitialized!" << std::endl;
+		return nullptr;
+	}
+	return constBuffer;
+}
+
+template<typename count_t>
+void SerialBufferAdapter<count_t>::setBuffer(uint8_t* buffer,
+		count_t bufferLength) {
+	this->buffer = buffer;
+	this->constBuffer = buffer;
+	this->bufferLength = bufferLength;
+}
+
+
+//forward Template declaration for linker
+template class SerialBufferAdapter<uint8_t>;
+template class SerialBufferAdapter<uint16_t>;
+template class SerialBufferAdapter<uint32_t>;
+template class SerialBufferAdapter<uint64_t>;
+

serialize/SerialBufferAdapter.h

@@ -1,35 +1,78 @@
-#ifndef SERIALBUFFERADAPTER_H_
-#define SERIALBUFFERADAPTER_H_
-
-#include "SerializeIF.h"
-#include "SerializeAdapter.h"
-
-/**
- * \ingroup serialize
- */
-template<typename T>
-class SerialBufferAdapter: public SerializeIF {
-public:
-	SerialBufferAdapter(const uint8_t * buffer, T bufferLength, bool serializeLenght = false);
-	SerialBufferAdapter(uint8_t* buffer, T bufferLength,
-			bool serializeLenght = false);
-
-	virtual ~SerialBufferAdapter();
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const override;
-
-	virtual size_t getSerializedSize() const override;
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) override;
-private:
-	bool serializeLength;
-	const uint8_t *constBuffer;
-	uint8_t *buffer;
-	T bufferLength;
-};
-
-
-
-#endif /* SERIALBUFFERADAPTER_H_ */
+#ifndef SERIALBUFFERADAPTER_H_
+#define SERIALBUFFERADAPTER_H_
+
+#include "../serialize/SerializeIF.h"
+#include "../serialize/SerializeAdapter.h"
+
+/**
+ * This adapter provides an interface for SerializeIF to serialize or deserialize
+ * buffers with no length header but a known size.
+ *
+ * Additionally, the buffer length can be serialized too and will be put in
+ * front of the serialized buffer.
+ *
+ * Can be used with SerialLinkedListAdapter by declaring a SerializeElement with
+ * SerialElement<SerialBufferAdapter<bufferLengthType(will be uint8_t mostly)>>.
+ * Right now, the SerialBufferAdapter must always
+ * be initialized with the buffer and size !
+ *
+ * \ingroup serialize
+ */
+template<typename count_t>
+class SerialBufferAdapter: public SerializeIF {
+public:
+
+    /**
+     * Constructor for constant uint8_t buffer. Length field can be serialized optionally.
+     * Type of length can be supplied as template type.
+     * @param buffer
+     * @param bufferLength
+     * @param serializeLength
+     */
+    SerialBufferAdapter(const uint8_t* buffer, count_t bufferLength,
+            bool serializeLength = false);
+
+    /**
+     * Constructor for non-constant uint8_t buffer.
+     * Length field can be serialized optionally.
+     * Type of length can be supplied as template type.
+     * @param buffer
+     * @param bufferLength
+     * @param serializeLength Length field will be serialized with size count_t
+     */
+    SerialBufferAdapter(uint8_t* buffer, count_t bufferLength,
+            bool serializeLength = false);
+
+    virtual ~SerialBufferAdapter();
+
+    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+            size_t maxSize, Endianness streamEndianness) const override;
+
+    virtual size_t getSerializedSize() const override;
+
+    /**
+     * @brief This function deserializes a buffer into the member buffer.
+     * @details
+     * If a length field is present, it is ignored, as the size should have
+     * been set in the constructor. If the size is not known beforehand,
+     * consider using SerialFixedArrayListAdapter instead.
+     * @param buffer [out] Resulting buffer
+     * @param size remaining size to deserialize, should be larger than buffer
+     *        + size field size
+     * @param bigEndian
+     * @return
+     */
+    virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+            Endianness streamEndianness) override;
+
+    uint8_t * getBuffer();
+    const uint8_t * getConstBuffer();
+    void setBuffer(uint8_t* buffer, count_t bufferLength);
+private:
+	bool serializeLength = false;
+	const uint8_t *constBuffer = nullptr;
+	uint8_t *buffer = nullptr;
+	count_t bufferLength = 0;
+};
+
+#endif /* SERIALBUFFERADAPTER_H_ */

serialize/SerialFixedArrayListAdapter.h

@@ -1,31 +1,57 @@
-#ifndef SERIALFIXEDARRAYLISTADAPTER_H_
-#define SERIALFIXEDARRAYLISTADAPTER_H_
+#ifndef FSFW_SERIALIZE_SERIALFIXEDARRAYLISTADAPTER_H_
+#define FSFW_SERIALIZE_SERIALFIXEDARRAYLISTADAPTER_H_
 
-#include "../container/FixedArrayList.h"
 #include "SerialArrayListAdapter.h"
+#include "../container/FixedArrayList.h"
 
 /**
- * \ingroup serialize
+ * @brief 	This adapter provides an interface for SerializeIF to serialize and
+ * 			deserialize buffers with a header containing the buffer length.
+ * @details
+ * Can be used by SerialLinkedListAdapter by declaring
+ * as a linked element with SerializeElement<SerialFixedArrayListAdapter<...>>.
+ * The sequence of objects is defined in the constructor by
+ * using the setStart and setNext functions.
+ *
+ * @tparam BUFFER_TYPE: Specifies the data type of the buffer
+ * @tparam MAX_SIZE: Specifies the maximum allowed number of elements
+ * 					 (not bytes!)
+ * @tparam count_t: specifies the type/size of the length field which defaults
+ * 					to one byte.
+ * @ingroup serialize
  */
-template<typename T, uint32_t MAX_SIZE, typename count_t = uint8_t>
-class SerialFixedArrayListAdapter : public FixedArrayList<T, MAX_SIZE, count_t>, public SerializeIF {
+template<typename BUFFER_TYPE, uint32_t MAX_SIZE, typename count_t = uint8_t>
+class SerialFixedArrayListAdapter :
+		public FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>,
+		public SerializeIF {
 public:
+	/**
+	 * Constructor arguments are forwarded to FixedArrayList constructor.
+	 * Refer to the fixed array list constructors for different options.
+	 * @param args
+	 */
 	template<typename... Args>
-	SerialFixedArrayListAdapter(Args... args) : FixedArrayList<T, MAX_SIZE, count_t>(std::forward<Args>(args)...) {
-	}
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		return SerialArrayListAdapter<T, count_t>::serialize(this, buffer, size, maxSize, streamEndianness);
-	}
-	size_t getSerializedSize() const {
-		return SerialArrayListAdapter<T, count_t>::getSerializedSize(this);
-	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		return SerialArrayListAdapter<T, count_t>::deSerialize(this, buffer, size, streamEndianness);
-	}
+	SerialFixedArrayListAdapter(Args... args) :
+	        FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(
+	        std::forward<Args>(args)...){}
+
+    ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+            size_t maxSize, Endianness streamEndianness) const {
+        return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this,
+                buffer, size, maxSize, streamEndianness);
+    }
+
+    size_t getSerializedSize() const {
+        return SerialArrayListAdapter<BUFFER_TYPE, count_t>::
+        		getSerializedSize(this);
+    }
+
+    ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+            Endianness streamEndianness) {
+        return SerialArrayListAdapter<BUFFER_TYPE, count_t>::deSerialize(this,
+                buffer, size, streamEndianness);
+    }
+
 };
 
-
-
-#endif /* SERIALFIXEDARRAYLISTADAPTER_H_ */
+#endif /* FSFW_SERIALIZE_SERIALFIXEDARRAYLISTADAPTER_H_ */

serialize/SerialLinkedListAdapter.h

@@ -1,32 +1,52 @@
-/**
- * @file	SerialLinkedListAdapter.h
- * @brief	This file defines the SerialLinkedListAdapter class.
- * @date	22.07.2014
- * @author	baetz
- */
-#ifndef SERIALLINKEDLISTADAPTER_H_
-#define SERIALLINKEDLISTADAPTER_H_
+#ifndef FSFW_SERIALIZE_SERIALLINKEDLISTADAPTER_H_
+#define FSFW_SERIALIZE_SERIALLINKEDLISTADAPTER_H_
 
 #include "../container/SinglyLinkedList.h"
 #include "SerializeAdapter.h"
 #include "SerializeElement.h"
 #include "SerializeIF.h"
-//This is where we need the SerializeAdapter!
 
-/**
- * \ingroup serialize
+ /**
+ * @brief  	Implement the conversion of object data to data streams
+ * 		   	or vice-versa, using linked lists.
+ * @details
+ * An alternative to the AutoSerializeAdapter functions
+ *   - All object members with a datatype are declared as
+ *     SerializeElement<element_type> members inside the class
+ *     implementing this adapter.
+ *   - The element type can also be a SerialBufferAdapter to
+ *     de-/serialize buffers.
+ *   - The element type can also be a SerialFixedArrayListAdapter to
+ *     de-/serialize buffers with a size header, which is scanned automatically.
+ *
+ * The sequence of objects is defined in the constructor by using
+ * the setStart and setNext functions.
+ *
+ * 1. The serialization process is done by instantiating the class and
+ *    calling serialize after all SerializeElement entries have been set by
+ *    using the constructor or setter functions. An additional size variable
+ *    can be supplied which is calculated/incremented automatically.
+ * 2. The deserialization process is done by instantiating the class and
+ *    supplying a buffer with the data which is converted into an object.
+ *    The size of data to serialize can be supplied and is
+ *    decremented in the function. Range checking is done internally.
+ * @author baetz
+ * @ingroup serialize
  */
 template<typename T, typename count_t = uint8_t>
 class SerialLinkedListAdapter: public SinglyLinkedList<T>, public SerializeIF {
 public:
+
 	SerialLinkedListAdapter(typename LinkedElement<T>::Iterator start,
 			bool printCount = false) :
 			SinglyLinkedList<T>(start), printCount(printCount) {
 	}
+
 	SerialLinkedListAdapter(LinkedElement<T>* first, bool printCount = false) :
 			SinglyLinkedList<T>(first), printCount(printCount) {
 
 	}
+
 	SerialLinkedListAdapter(bool printCount = false) :
 			SinglyLinkedList<T>(), printCount(printCount) {
 	}
@@ -49,13 +69,14 @@ public:
 			uint8_t** buffer, size_t* size, size_t maxSize,
 			Endianness streamEndianness) {
 		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
+		while ((result == HasReturnvaluesIF::RETURN_OK) and (element != nullptr)) {
 			result = element->value->serialize(buffer, size, maxSize,
 					streamEndianness);
 			element = element->getNext();
 		}
 		return result;
 	}
+
 	virtual size_t getSerializedSize() const override {
 		if (printCount) {
 			return SerialLinkedListAdapter<T>::getSerializedSize()
@@ -64,32 +85,44 @@ public:
 			return getSerializedSize(SinglyLinkedList<T>::start);
 		}
 	}
+
 	static size_t getSerializedSize(const LinkedElement<T> *element) {
 		size_t size = 0;
-		while (element != NULL) {
+		while (element != nullptr) {
 			size += element->value->getSerializedSize();
 			element = element->getNext();
 		}
 		return size;
 	}
 
+
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			Endianness streamEndianness) override {
-		return deSerialize(SinglyLinkedList<T>::start, buffer, size, streamEndianness);
+		return deSerialize(SinglyLinkedList<T>::start, buffer, size,
+				streamEndianness);
 	}
 
 	static ReturnValue_t deSerialize(LinkedElement<T>* element,
 			const uint8_t** buffer, size_t* size, Endianness streamEndianness) {
 		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
+		while ((result == HasReturnvaluesIF::RETURN_OK) and (element != nullptr)) {
 			result = element->value->deSerialize(buffer, size, streamEndianness);
 			element = element->getNext();
 		}
 		return result;
 	}
 
-	bool printCount;
+	/**
+	 * Copying is forbidden by deleting the copy constructor and the copy
+	 * assignment operator because of the pointers to the linked list members.
+	 * Unless the child class implements an own copy constructor or
+	 * copy assignment operator, these operation will throw a compiler error.
+	 * @param
+	 */
+	SerialLinkedListAdapter(const SerialLinkedListAdapter &) = delete;
+	SerialLinkedListAdapter& operator=(const SerialLinkedListAdapter&) = delete;
 
+	bool printCount;
 };
 
-#endif /* SERIALLINKEDLISTADAPTER_H_ */
+#endif /* FSFW_SERIALIZE_SERIALLINKEDLISTADAPTER_H_ */

serialize/SerializeAdapter.h

@@ -1,48 +1,114 @@
-#ifndef SERIALIZEADAPTER_H_
-#define SERIALIZEADAPTER_H_
+#ifndef _FSFW_SERIALIZE_SERIALIZEADAPTER_H_
+#define _FSFW_SERIALIZE_SERIALIZEADAPTER_H_
 
-#include "../container/IsDerivedFrom.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "EndianConverter.h"
 #include "SerializeIF.h"
-#include <string.h>
+#include <cstddef>
+#include <type_traits>
 
-/**
- * \ingroup serialize
+ /**
+ * @brief These adapters provides an interface to use the SerializeIF functions
+ * 		  with arbitrary template objects to facilitate and simplify the
+ * 		  serialization of classes with different multiple different data types
+ * 		  into buffers and vice-versa.
+ * @details
+ * The correct serialization or deserialization function is chosen at
+ * compile time with template type deduction.
+ *
+ * @ingroup serialize
  */
-
 class SerializeAdapter {
 public:
+	/***
+	 * This function can be used to serialize a trivial copy-able type or a
+	 * child of SerializeIF.
+	 * The right template to be called is determined in the function itself.
+	 * For objects of non trivial copy-able type this function is almost never
+	 * called by the user directly. Instead helpers for specific types like
+	 * SerialArrayListAdapter or SerialLinkedListAdapter is the right choice here.
+	 *
+	 * @param[in] object Object to serialize, the used type is deduced from this pointer
+	 * @param[in/out] buffer Buffer to serialize into. Will be moved by the function.
+	 * @param[in/out] size Size of current written buffer. Will be incremented by the function.
+	 * @param[in] maxSize Max size of Buffer
+	 * @param[in] streamEndianness Endianness of serialized element as in according to SerializeIF::Endianness
+	 * @return
+	 * 		- @c BUFFER_TOO_SHORT The given buffer in is too short
+	 * 		- @c RETURN_FAILED Generic Error
+	 * 		- @c RETURN_OK Successful serialization
+	 */
 	template<typename T>
 	static ReturnValue_t serialize(const T *object, uint8_t **buffer,
-			size_t *size, size_t maxSize, SerializeIF::Endianness streamEndianness) {
-		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+			size_t *size, size_t maxSize,
+			SerializeIF::Endianness streamEndianness) {
+		InternalSerializeAdapter<T, std::is_base_of<SerializeIF, T>::value> adapter;
 		return adapter.serialize(object, buffer, size, maxSize,
 				streamEndianness);
 	}
+	/**
+	 * Function to return the serialized size of the object in the pointer.
+	 * May be a trivially copy-able object or a Child of SerializeIF
+	 *
+	 * @param object Pointer to Object
+	 * @return Serialized size of object
+	 */
 	template<typename T>
-	static uint32_t getSerializedSize(const T *object) {
-		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+	static size_t getSerializedSize(const T *object){
+		InternalSerializeAdapter<T, std::is_base_of<SerializeIF, T>::value> adapter;
 		return adapter.getSerializedSize(object);
 	}
+	/**
+	 * @brief
+	 * Deserializes a object from a given buffer of given size.
+	 * Object Must be trivially copy-able or a child of SerializeIF.
+	 *
+	 * @details
+	 * Buffer will be moved to the current read location. Size will be decreased by the function.
+	 *
+	 * @param[in/out] buffer Buffer to deSerialize from. Will be moved by the function.
+	 * @param[in/out] size Remaining size of the buffer to read from. Will be decreased by function.
+	 * @param[in] streamEndianness Endianness as in according to SerializeIF::Endianness
+	 * @return
+	 * 	- @c STREAM_TOO_SHORT The input stream is too short to deSerialize the object
+	 * 	- @c TOO_MANY_ELEMENTS The buffer has more inputs than expected
+	 * 	- @c RETURN_FAILED Generic Error
+	 * 	- @c RETURN_OK Successful deserialization
+	 */
 	template<typename T>
 	static ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
 			size_t *size, SerializeIF::Endianness streamEndianness) {
-		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		InternalSerializeAdapter<T, std::is_base_of<SerializeIF, T>::value> adapter;
 		return adapter.deSerialize(object, buffer, size, streamEndianness);
 	}
 private:
-	template<typename T, int>
-	class InternalSerializeAdapter {
+	/**
+	 * Internal template to deduce the right function calls at compile time
+	 */
+	template<typename T, bool> class InternalSerializeAdapter;
+
+	/**
+	 * Template to be used if T is not a child of SerializeIF
+	 *
+	 * @tparam T T must be trivially_copyable
+	 */
+	template<typename T>
+	class InternalSerializeAdapter<T, false> {
+		static_assert (std::is_trivially_copyable<T>::value,
+				"If a type needs to be serialized it must be a child of "
+				"SerializeIF or trivially copy-able");
 	public:
 		static ReturnValue_t serialize(const T *object, uint8_t **buffer,
-				size_t *size, size_t max_size, SerializeIF::Endianness streamEndianness) {
+				size_t *size, size_t max_size,
+				SerializeIF::Endianness streamEndianness) {
 			size_t ignoredSize = 0;
-			if (size == NULL) {
+			if (size == nullptr) {
 				size = &ignoredSize;
 			}
-			//TODO check integer overflow of *size
-			if (sizeof(T) + *size <= max_size) {
+			// Check remaining size is large enough and check integer
+			// overflow of *size
+			size_t newSize = sizeof(T) + *size;
+			if ((newSize <= max_size) and (newSize > *size)) {
 				T tmp;
 				switch (streamEndianness) {
 				case SerializeIF::Endianness::BIG:
@@ -56,7 +122,7 @@ private:
 					tmp = *object;
 					break;
 				}
-				memcpy(*buffer, &tmp, sizeof(T));
+				std::memcpy(*buffer, &tmp, sizeof(T));
 				*size += sizeof(T);
 				(*buffer) += sizeof(T);
 				return HasReturnvaluesIF::RETURN_OK;
@@ -70,7 +136,7 @@ private:
 			T tmp;
 			if (*size >= sizeof(T)) {
 				*size -= sizeof(T);
-				memcpy(&tmp, *buffer, sizeof(T));
+				std::memcpy(&tmp, *buffer, sizeof(T));
 				switch (streamEndianness) {
 				case SerializeIF::Endianness::BIG:
 					*object = EndianConverter::convertBigEndian<T>(tmp);
@@ -94,22 +160,26 @@ private:
 		uint32_t getSerializedSize(const T *object) {
 			return sizeof(T);
 		}
-
 	};
 
+	/**
+	 * Template for objects that inherit from SerializeIF
+	 *
+	 * @tparam T A child of SerializeIF
+	 */
 	template<typename T>
-	class InternalSerializeAdapter<T, 1> {
+	class InternalSerializeAdapter<T, true> {
 	public:
-		ReturnValue_t serialize(const T *object, uint8_t **buffer,
-				size_t *size, size_t max_size,
+		ReturnValue_t serialize(const T *object, uint8_t **buffer, size_t *size,
+				size_t max_size,
 				SerializeIF::Endianness streamEndianness) const {
 			size_t ignoredSize = 0;
-			if (size == NULL) {
+			if (size == nullptr) {
 				size = &ignoredSize;
 			}
 			return object->serialize(buffer, size, max_size, streamEndianness);
 		}
-		uint32_t getSerializedSize(const T *object) const {
+		size_t getSerializedSize(const T *object) const {
 			return object->getSerializedSize();
 		}
 
@@ -120,4 +190,4 @@ private:
 	};
 };
 
-#endif /* SERIALIZEADAPTER_H_ */
+#endif /* _FSFW_SERIALIZE_SERIALIZEADAPTER_H_ */

serialize/SerializeElement.h

@@ -1,12 +1,20 @@
-#ifndef SERIALIZEELEMENT_H_
-#define SERIALIZEELEMENT_H_
+#ifndef FSFW_SERIALIZE_SERIALIZEELEMENT_H_
+#define FSFW_SERIALIZE_SERIALIZEELEMENT_H_
 
-#include "../container/SinglyLinkedList.h"
 #include "SerializeAdapter.h"
+#include "../container/SinglyLinkedList.h"
 #include <utility>
 
 /**
- * \ingroup serialize
+ * @brief This class is used to mark datatypes for serialization with the
+ *        SerialLinkedListAdapter
+ * @details
+ * Used by declaring any arbitrary datatype with SerializeElement<T> myVariable,
+ * inside a SerialLinkedListAdapter implementation and setting the sequence
+ * of objects with setNext() and setStart().
+ * Serialization and Deserialization is then performed automatically in
+ * specified sequence order.
+ * @ingroup serialize
  */
 template<typename T>
 class SerializeElement: public SerializeIF, public LinkedElement<SerializeIF> {
@@ -19,7 +27,7 @@ public:
 	SerializeElement() :
 			LinkedElement<SerializeIF>(this) {
 	}
-	T entry;
+
 	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
 			Endianness streamEndianness) const override {
 		return SerializeAdapter::serialize(&entry, buffer, size, maxSize,
@@ -35,6 +43,7 @@ public:
 		return SerializeAdapter::deSerialize(&entry, buffer, size,
 				streamEndianness);
 	}
+
 	operator T() {
 		return entry;
 	}
@@ -43,9 +52,12 @@ public:
 		entry = newValue;
 		return *this;
 	}
+
 	T* operator->() {
 		return &entry;
 	}
+
+	T entry;
 };
 
-#endif /* SERIALIZEELEMENT_H_ */
+#endif /* FSFW_SERIALIZE_SERIALIZEELEMENT_H_ */

serialize/SerializeIF.h

@@ -1,17 +1,20 @@
-#ifndef SERIALIZEIF_H_
-#define SERIALIZEIF_H_
+#ifndef FSFW_SERIALIZE_SERIALIZEIF_H_
+#define FSFW_SERIALIZE_SERIALIZEIF_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include <stddef.h>
+#include <cstddef>
 
 /**
- * \defgroup serialize Serialization
- * Contains serialisation services.
+ * @defgroup serialize Serialization
+ * Contains serialization services.
  */
 
 /**
- * Translation of objects into data streams.
- * \ingroup serialize
+ * @brief 	Translation of objects into data streams and from data streams.
+ * @details
+ * Also provides options to convert from/to data with different endianness.
+ * variables.
+ * @ingroup serialize
  */
 class SerializeIF {
 public:
@@ -20,21 +23,65 @@ public:
 	};
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::SERIALIZE_IF;
-	static const ReturnValue_t BUFFER_TOO_SHORT = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t STREAM_TOO_SHORT = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t TOO_MANY_ELEMENTS = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t BUFFER_TOO_SHORT = MAKE_RETURN_CODE(1); // !< The given buffer in serialize is too short
+	static const ReturnValue_t STREAM_TOO_SHORT = MAKE_RETURN_CODE(2); // !< The input stream in deserialize is too short
+	static const ReturnValue_t TOO_MANY_ELEMENTS = MAKE_RETURN_CODE(3);// !< There are too many elements to be deserialized
 
 	virtual ~SerializeIF() {
 	}
-
+	/**
+	 * @brief
+	 * Function to serialize the object into a buffer with maxSize. Size represents the written amount.
+	 * If a part of the buffer has been used already, size must be set to the used amount of bytes.
+	 *
+	 * @details
+	 * Implementations of this function must increase the size variable and move the buffer pointer.
+	 * MaxSize must be checked by implementations of this function
+	 * and BUFFER_TOO_SHORT has to be returned if size would be larger than maxSize.
+	 *
+	 * Custom implementations might use additional return values.
+	 *
+	 * @param[in/out] buffer Buffer to serialize into, will be set to the current write location
+	 * @param[in/out] size Size that has been used in the buffer already, will be increased by the function
+	 * @param[in] maxSize The size of the buffer that is allowed to be used for serialize.
+	 * @param[in] streamEndianness Endianness of the serialized data according to SerializeIF::Endianness
+	 * @return
+	 * 		- @c BUFFER_TOO_SHORT The given buffer in is too short
+	 * 		- @c RETURN_FAILED Generic error
+	 * 		- @c RETURN_OK Successful serialization
+	 */
 	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
 			size_t maxSize, Endianness streamEndianness) const = 0;
 
+	/**
+	 * Gets the size of a object if it would be serialized in a buffer
+	 * @return Size of serialized object
+	 */
 	virtual size_t getSerializedSize() const = 0;
 
+	/**
+	 * @brief
+	 * Deserializes a object from a given buffer of given size.
+	 *
+	 * @details
+	 * Buffer must be moved to the current read location by the implementation
+	 * of this function. Size must be decreased by the implementation.
+	 * Implementations are not allowed to alter the buffer as indicated by const pointer.
+	 *
+	 * Custom implementations might use additional return values.
+	 *
+	 * @param[in/out] buffer Buffer to deSerialize from. Will be moved by the function.
+	 * @param[in/out] size Remaining size of the buffer to read from. Will be decreased by function.
+	 * @param[in] streamEndianness Endianness as in according to SerializeIF::Endianness
+	 * @return
+	 * 	- @c STREAM_TOO_SHORT The input stream is too short to deSerialize the object
+	 * 	- @c TOO_MANY_ELEMENTS The buffer has more inputs than expected
+	 * 	- @c RETURN_FAILED Generic Error
+	 * 	- @c RETURN_OK Successful deserialization
+	 */
 	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
 			Endianness streamEndianness) = 0;
 
 };
 
-#endif /* SERIALIZEIF_H_ */
+#endif /* FSFW_SERIALIZE_SERIALIZEIF_H_ */

subsystem/Subsystem.cpp

@@ -151,7 +151,6 @@ HybridIterator<ModeListEntry> Subsystem::getTable(Mode_t id) {
 }
 
 ReturnValue_t Subsystem::handleCommandMessage(CommandMessage *message) {
-	ReturnValue_t result;
 	switch (message->getCommand()) {
 	case HealthMessage::HEALTH_INFO: {
 		HealthState health = HealthMessage::getHealth(message);
@@ -166,7 +165,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage *message) {
 		FixedArrayList<ModeListEntry, MAX_LENGTH_OF_TABLE_OR_SEQUENCE> sequence;
 		const uint8_t *pointer;
 		size_t sizeRead;
-		result = IPCStore->getData(
+		ReturnValue_t result = IPCStore->getData(
 				ModeSequenceMessage::getStoreAddress(message), &pointer,
 				&sizeRead);
 		if (result == RETURN_OK) {
@@ -193,7 +192,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage *message) {
 		FixedArrayList<ModeListEntry, MAX_LENGTH_OF_TABLE_OR_SEQUENCE> table;
 		const uint8_t *pointer;
 		size_t sizeRead;
-		result = IPCStore->getData(
+		ReturnValue_t result = IPCStore->getData(
 				ModeSequenceMessage::getStoreAddress(message), &pointer,
 				&sizeRead);
 		if (result == RETURN_OK) {
@@ -210,21 +209,23 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage *message) {
 
 	}
 		break;
-	case ModeSequenceMessage::DELETE_SEQUENCE:
+	case ModeSequenceMessage::DELETE_SEQUENCE:{
 		if (isInTransition) {
 			replyToCommand(IN_TRANSITION, 0);
 			break;
 		}
-		result = deleteSequence(ModeSequenceMessage::getSequenceId(message));
+		ReturnValue_t result = deleteSequence(ModeSequenceMessage::getSequenceId(message));
 		replyToCommand(result, 0);
+	}
 		break;
-	case ModeSequenceMessage::DELETE_TABLE:
+	case ModeSequenceMessage::DELETE_TABLE:{
 		if (isInTransition) {
 			replyToCommand(IN_TRANSITION, 0);
 			break;
 		}
-		result = deleteTable(ModeSequenceMessage::getTableId(message));
+		ReturnValue_t result = deleteTable(ModeSequenceMessage::getTableId(message));
 		replyToCommand(result, 0);
+	}
 		break;
 	case ModeSequenceMessage::LIST_SEQUENCES: {
 		SerialFixedArrayListAdapter<Mode_t, MAX_NUMBER_OF_TABLES_OR_SEQUENCES> sequences;
@@ -549,7 +550,7 @@ Mode_t Subsystem::getFallbackSequence(Mode_t sequence) {
 	for (FixedMap<Mode_t, SequenceInfo>::Iterator iter = modeSequences.begin();
 			iter != modeSequences.end(); ++iter) {
 		if (iter.value->first == sequence) {
-			return iter->fallbackSequence;
+			return iter->second.fallbackSequence;
 		}
 	}
 	return -1;
@@ -558,7 +559,7 @@ Mode_t Subsystem::getFallbackSequence(Mode_t sequence) {
 bool Subsystem::isFallbackSequence(Mode_t SequenceId) {
 	for (FixedMap<Mode_t, SequenceInfo>::Iterator iter = modeSequences.begin();
 			iter != modeSequences.end(); iter++) {
-		if (iter->fallbackSequence == SequenceId) {
+		if (iter->second.fallbackSequence == SequenceId) {
 			return true;
 		}
 	}